diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000000..2b1f789c4a --- /dev/null +++ b/.dockerignore @@ -0,0 +1,37 @@ +# Git +.git +.gitignore +.gitattributes + +# CI/CD +.github + +# Generated files +gen/ +!gen/go/** + +# Dependencies +node_modules/ +target/ +**/Cargo.lock +*.pyc +__pycache__/ + +# IDE +.vscode/ +.idea/ +*.swp +*.swo +*~ + +# OS +.DS_Store +Thumbs.db + +# Logs +*.log + +# Test coverage +coverage/ +*.coverage +.pytest_cache/ diff --git a/.github/actions/setup-python-env/action.yml b/.github/actions/setup-python-env/action.yml new file mode 100644 index 0000000000..cab3a17b96 --- /dev/null +++ b/.github/actions/setup-python-env/action.yml @@ -0,0 +1,47 @@ +name: "Setup Python Environment" +description: "Set up Python environment for the given Python version" + +inputs: + python-version: + description: "Python version to use" + required: true + default: "3.12" + uv-version: + description: "uv version to use" + required: true + default: "0.8.4" + working-directory: + description: "Default working directory for all steps" + required: false + default: "" + +runs: + using: "composite" + steps: + - uses: actions/setup-python@v5 + with: + python-version: ${{ inputs.python-version }} + + - name: Install uv + uses: astral-sh/setup-uv@v6 + id: setup-uv + with: + version: ${{ inputs.uv-version }} + enable-cache: 'true' + cache-suffix: ${{ inputs.python-version }} + cache-dependency-glob: | + pyproject.toml + uv.lock + working-directory: ${{ inputs.working-directory }} + + - name: Install Python dependencies + if: steps.setup-uv.outputs.cache-hit == 'false' + working-directory: ${{ inputs.working-directory }} + run: uv sync --all-groups --frozen + shell: bash + + - name: List Python dependencies + if: steps.setup-uv.outputs.cache-hit == 'true' + working-directory: ${{ inputs.working-directory }} + run: uv pip list + shell: bash diff --git a/.github/workflows/build-ci-image.yml b/.github/workflows/build-ci-image.yml new file mode 100644 index 0000000000..dd90db43e4 --- /dev/null +++ b/.github/workflows/build-ci-image.yml @@ -0,0 +1,158 @@ +name: Build and Publish CI Docker Image + +on: + push: + branches: + - main + - v2 + paths: + - 'gen.Dockerfile' + - '.github/workflows/build-ci-image.yml' + pull_request: + paths: + - 'gen.Dockerfile' + - '.github/workflows/build-ci-image.yml' + workflow_dispatch: + inputs: + force_rebuild: + description: 'Force rebuild of the image' + required: false + default: 'false' + +env: + REGISTRY: ghcr.io + IMAGE_NAME: ${{ github.repository }}/ci + +jobs: + build: + runs-on: ubuntu-latest + permissions: + contents: read + packages: write + pull-requests: write + + outputs: + image-tag: ${{ steps.set-tag.outputs.tag }} + + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@v3 + + - name: Log in to GitHub Container Registry + uses: docker/login-action@v3 + with: + registry: ${{ env.REGISTRY }} + username: ${{ github.actor }} + password: ${{ secrets.GITHUB_TOKEN }} + + - name: Extract metadata (tags, labels) + id: meta + uses: docker/metadata-action@v5 + with: + images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }} + tags: | + # Use branch name for branch pushes + type=ref,event=branch + # Use PR number for pull requests + type=ref,event=pr + # Use 'latest' tag for main branch + type=raw,value=latest,enable=${{ github.ref == 'refs/heads/main' }} + # Use 'v2' tag for v2 branch + type=raw,value=v2,enable=${{ github.ref == 'refs/heads/v2' }} + # Add git sha as tag + type=sha,prefix=${{ github.head_ref }}-,enable=${{ github.ref != 'refs/heads/v2' && github.ref != 'refs/heads/main' }} + + - name: Set image tag output + id: set-tag + run: | + if [ "${{ github.event_name }}" == "pull_request" ]; then + echo "tag=pr-${{ github.event.pull_request.number }}" >> $GITHUB_OUTPUT + elif [ "${{ github.ref }}" == "refs/heads/v2" ]; then + echo "tag=v2" >> $GITHUB_OUTPUT + elif [ "${{ github.ref }}" == "refs/heads/main" ]; then + echo "tag=latest" >> $GITHUB_OUTPUT + else + echo "tag=$(echo ${{ github.ref }} | sed 's/refs\/heads\///')" >> $GITHUB_OUTPUT + fi + + - name: Build and push Docker image + uses: docker/build-push-action@v6 + with: + context: . + file: ./gen.Dockerfile + push: true + tags: ${{ steps.meta.outputs.tags }} + labels: ${{ steps.meta.outputs.labels }} + platforms: linux/amd64,linux/arm64 + # Multi-layer caching strategy for speed + cache-from: | + type=registry,ref=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:buildcache + type=registry,ref=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.set-tag.outputs.tag }} + type=registry,ref=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:v2 + type=gha + cache-to: | + type=registry,ref=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:buildcache,mode=max + type=gha,mode=max + # Enable BuildKit features for better caching + build-args: | + BUILDKIT_INLINE_CACHE=1 + + - name: Image digest + run: echo "Image built with digest ${{ steps.meta.outputs.digest }}" + + - name: Comment on PR with image tag + if: github.event_name == 'pull_request' + uses: actions/github-script@v7 + with: + script: | + const tag = '${{ steps.set-tag.outputs.tag }}'; + const registry = '${{ env.REGISTRY }}'; + const imageName = '${{ env.IMAGE_NAME }}'; + const fullImage = `${registry}/${imageName}:${tag}`; + + const comment = `## ๐Ÿณ Docker CI Image Built + + The CI Docker image has been built and pushed for this PR! + + **Image:** \`${fullImage}\` + + This image will be automatically used by CI workflows in this PR. + + To test locally: + \`\`\`bash + make gen DOCKER_CI_IMAGE=${fullImage} + \`\`\` + `; + + // Find existing comment + const { data: comments } = await github.rest.issues.listComments({ + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: context.issue.number, + }); + + const botComment = comments.find(comment => + comment.user.type === 'Bot' && + comment.body.includes('๐Ÿณ Docker CI Image Built') + ); + + if (botComment) { + // Update existing comment + await github.rest.issues.updateComment({ + owner: context.repo.owner, + repo: context.repo.repo, + comment_id: botComment.id, + body: comment + }); + } else { + // Create new comment + await github.rest.issues.createComment({ + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: context.issue.number, + body: comment + }); + } diff --git a/.github/workflows/check-generate.yml b/.github/workflows/check-generate.yml new file mode 100644 index 0000000000..8960da2a22 --- /dev/null +++ b/.github/workflows/check-generate.yml @@ -0,0 +1,114 @@ +name: Check Generated Files + +on: + pull_request: + types: [opened, synchronize, reopened] + +jobs: + check-generate: + runs-on: ubuntu-latest + permissions: + contents: read + actions: read + packages: read + steps: + - name: Checkout code + uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Determine Docker image + id: docker-image + run: | + # Check if gen.Dockerfile or build workflow was modified + git fetch origin ${{ github.base_ref }} + if git diff --name-only origin/${{ github.base_ref }}...HEAD | grep -E '^(gen\.Dockerfile|Dockerfile\.ci|\.github/workflows/build-ci-image\.yml)$'; then + echo "modified=true" >> $GITHUB_OUTPUT + echo "image=ghcr.io/flyteorg/flyte/ci:pr-${{ github.event.pull_request.number }}" >> $GITHUB_OUTPUT + echo "๐Ÿ“ฆ gen.Dockerfile modified - will use PR-specific image" + else + echo "modified=false" >> $GITHUB_OUTPUT + echo "image=ghcr.io/flyteorg/flyte/ci:v2" >> $GITHUB_OUTPUT + echo "๐Ÿ“ฆ Using default v2 image" + fi + + - name: Wait for Docker image build workflow + if: steps.docker-image.outputs.modified == 'true' + uses: actions/github-script@v7 + with: + script: | + const maxAttempts = 60; // 20 minutes max + const delaySeconds = 20; + + console.log('โณ Waiting for Docker image build workflow to complete...'); + + for (let attempt = 0; attempt < maxAttempts; attempt++) { + // Get workflow runs for this PR + const { data: runs } = await github.rest.actions.listWorkflowRuns({ + owner: context.repo.owner, + repo: context.repo.repo, + workflow_id: 'build-ci-image.yml', + event: 'pull_request', + per_page: 10 + }); + + // Find the run for this PR + const prRun = runs.workflow_runs.find(run => + run.head_sha === context.payload.pull_request.head.sha + ); + + if (prRun) { + console.log(`Found workflow run: ${prRun.html_url}`); + console.log(`Status: ${prRun.status}, Conclusion: ${prRun.conclusion}`); + + if (prRun.status === 'completed') { + if (prRun.conclusion === 'success') { + console.log('โœ… Docker image build completed successfully!'); + return; + } else { + core.setFailed(`โŒ Docker image build failed with conclusion: ${prRun.conclusion}`); + return; + } + } + + console.log(`Attempt ${attempt + 1}/${maxAttempts}: Build still running, waiting ${delaySeconds} seconds...`); + } else { + console.log(`Attempt ${attempt + 1}/${maxAttempts}: Build not started yet, waiting ${delaySeconds} seconds...`); + } + + await new Promise(resolve => setTimeout(resolve, delaySeconds * 1000)); + } + + core.setFailed('โŒ Timeout waiting for Docker image build to complete'); + + - name: Login to GHCR + if: steps.docker-image.outputs.modified == 'true' + run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin + + - name: Pull Docker image + if: steps.docker-image.outputs.modified == 'true' + run: | + IMAGE="${{ steps.docker-image.outputs.image }}" + echo "๐Ÿ“ฆ Pulling image: $IMAGE" + docker pull "$IMAGE" + + - name: Run checks in container + run: | + IMAGE="${{ steps.docker-image.outputs.image }}" + echo "Using image: $IMAGE" + + docker run --rm \ + -v ${{ github.workspace }}:/workspace \ + -w /workspace \ + -e SETUPTOOLS_SCM_PRETEND_VERSION=0.0.0 \ + -e UV_PROJECT_ENVIRONMENT=/tmp/flyte-venv \ + "$IMAGE" \ + bash -c " + git config --global --add safe.directory /workspace && + cd gen/python && uv sync --all-groups --frozen && cd ../.. && + make gen-local && + git diff --exit-code || (echo 'Generated files are out of date. Run \`make gen\` and commit changes.' && exit 1) && + make build-crate + " + + diff --git a/.github/workflows/publish-npm.yml b/.github/workflows/publish-npm.yml new file mode 100644 index 0000000000..fd29a9dad4 --- /dev/null +++ b/.github/workflows/publish-npm.yml @@ -0,0 +1,44 @@ +name: Publish TypeScript Package + +on: + push: + tags: + - 'v*' + +jobs: + publish: + runs-on: ubuntu-latest + container: + image: ghcr.io/flyteorg/flyte/ci:v2 + credentials: + username: ${{ github.actor }} + password: ${{ secrets.GITHUB_TOKEN }} + defaults: + run: + working-directory: ./gen/ts/ + steps: + - name: Checkout code + uses: actions/checkout@v4 + - name: Debug Info + run: | + pwd + ls -la + - uses: actions/setup-node@v1 + with: + node-version: "20.x" + registry-url: "https://registry.npmjs.org" + - name: Set version in npm package + run: | + # v1.2.3 get 1.2.3 + VERSION=$(echo "${GITHUB_REF#refs/tags/v}") + VERSION=$VERSION make update_npmversion + shell: bash + + - name: Install dependencies + run: npm install + - name: Publish + env: + NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} + run: | + NPM_REGISTRY_URL="https://registry.npmjs.org/" + npm publish --access=public --registry $NPM_REGISTRY_URL diff --git a/.github/workflows/publish-python.yml b/.github/workflows/publish-python.yml new file mode 100644 index 0000000000..cadbaecc33 --- /dev/null +++ b/.github/workflows/publish-python.yml @@ -0,0 +1,65 @@ +name: Publish Python Package + +on: + push: + tags: + - 'v*' + +jobs: + publish: + runs-on: ubuntu-latest + container: + image: ghcr.io/flyteorg/flyte/ci:v2 + credentials: + username: ${{ github.actor }} + password: ${{ secrets.GITHUB_TOKEN }} + defaults: + run: + working-directory: ./gen/python + env: + PUBLISH_TO_TESTPYPI: ${{ vars.PUBLISH_TO_TESTPYPI || 'false' }} + steps: + - name: Checkout code + uses: actions/checkout@v4 + with: + fetch-depth: '0' + + - name: Debug Info + run: | + pwd + ls -la + + - name: Set version from tag + run: | + # Convert 1.2.3-b1 to 1.2.3b1 for Python versioning + VERSION="${{ github.ref_name }}" + VERSION_NO_V="${VERSION#v}" + VERSION_PY=$(echo "$VERSION_NO_V" | sed -E 's/-//') + export SETUPTOOLS_SCM_PRETEND_VERSION="$VERSION_PY" + echo "SETUPTOOLS_SCM_PRETEND_VERSION=$SETUPTOOLS_SCM_PRETEND_VERSION" >> $GITHUB_ENV + echo "SETUPTOOLS_SCM_PRETEND_VERSION=$SETUPTOOLS_SCM_PRETEND_VERSION" + + - name: Install dependencies + run: | + uv venv + uv pip install build twine setuptools wheel + + - name: Build + run: | + uv run python -m build --wheel --installer uv + - name: Publish to Test + if: ${{ env.PUBLISH_TO_TESTPYPI == 'true' }} + env: + TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} + TWINE_PASSWORD: ${{ secrets.PYPI_TEST_PASSWORD }} + run: | + REPOSITORY_URL="https://test.pypi.org/legacy/" + uv run python -m twine upload --repository-url "$REPOSITORY_URL" --verbose dist/* + - name: Publish to Pypi + if: ${{ env.PUBLISH_TO_TESTPYPI == 'false' }} + env: + TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} + TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} + run: | + REPOSITORY_URL="https://upload.pypi.org/legacy/" + uv run python -m twine upload --repository-url "$REPOSITORY_URL" --verbose dist/* diff --git a/.github/workflows/publish-rust.yml b/.github/workflows/publish-rust.yml new file mode 100644 index 0000000000..834ad840e2 --- /dev/null +++ b/.github/workflows/publish-rust.yml @@ -0,0 +1,69 @@ +name: Publish Rust Crate + +on: + push: + tags: + - 'v*' + +jobs: + publish: + runs-on: ubuntu-latest + container: + image: ghcr.io/flyteorg/flyte/ci:v2 + credentials: + username: ${{ github.actor }} + password: ${{ secrets.GITHUB_TOKEN }} + defaults: + run: + working-directory: ./gen/rust + permissions: + id-token: write # Required for OIDC token exchange + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Cache cargo registry + uses: actions/cache@v4 + with: + path: ~/.cargo/registry + key: ${{ runner.os }}-cargo-registry-${{ hashFiles('gen/rust/Cargo.lock') }} + restore-keys: | + ${{ runner.os }}-cargo-registry- + + - name: Cache cargo git + uses: actions/cache@v4 + with: + path: ~/.cargo/git + key: ${{ runner.os }}-cargo-git-${{ hashFiles('gen/rust/Cargo.lock') }} + restore-keys: | + ${{ runner.os }}-cargo-git- + + - name: Cache cargo build + uses: actions/cache@v4 + with: + path: gen/rust/target + key: ${{ runner.os }}-cargo-build-${{ hashFiles('gen/rust/Cargo.lock') }} + restore-keys: | + ${{ runner.os }}-cargo-build- + - name: Temporarily modify the rust toolchain version + run: rustup override set stable + - name: Output rust version for educational purposes + run: rustup --version + - name: Set Cargo.toml version from release tag + run: | + VERSION="${{ github.ref_name }}" + VERSION_NO_V="${VERSION#v}" + # Convert 1.2.3b1 to 1.2.3-b1 for semver compliance + VERSION_SEMVER=$(echo "$VERSION_NO_V" | sed -E 's/^([0-9]+\.[0-9]+\.[0-9]+)b([0-9]+)$/\1-b\2/') + sed -i.bak "s/^version = \".*\"/version = \"$VERSION_SEMVER\"/" Cargo.toml + rm Cargo.toml.bak + - name: "Package for crates.io" + run: cargo package --allow-dirty # publishes a package as a tarball + - uses: rust-lang/crates-io-auth-action@v1 + id: auth + - name: Build binaries in "release" mode + run: cargo build -r + - name: "Publish to crates.io" + env: + CARGO_REGISTRY_TOKEN: ${{ steps.auth.outputs.token }} + run: cargo publish --allow-dirty # publishes your crate as a library that can be added as a dependency diff --git a/.github/workflows/regenerate-on-comment.yml b/.github/workflows/regenerate-on-comment.yml new file mode 100644 index 0000000000..23cc4f5163 --- /dev/null +++ b/.github/workflows/regenerate-on-comment.yml @@ -0,0 +1,74 @@ +name: Regenerate and Push + +on: + issue_comment: + types: [created] + +jobs: + regenerate: + if: github.event.issue.pull_request && (contains(github.event.comment.body, '/regen') || contains(github.event.comment.body, ':repeat:')) + runs-on: ubuntu-latest + permissions: + contents: write + pull-requests: write + steps: + - name: Get PR details + id: pr + uses: actions/github-script@v7 + with: + script: | + const pr = await github.rest.pulls.get({ + owner: context.repo.owner, + repo: context.repo.repo, + pull_number: context.issue.number + }); + core.setOutput('number', pr.data.number); + core.setOutput('head_ref', pr.data.head.ref); + core.setOutput('head_sha', pr.data.head.sha); + + - name: Checkout code + uses: actions/checkout@v4 + with: + ref: ${{ steps.pr.outputs.head_ref }} + token: ${{ secrets.GITHUB_TOKEN }} + fetch-depth: 0 + + - name: Determine Docker image + id: docker-image + run: | + # Check if gen.Dockerfile was modified + git fetch origin ${{ github.event.repository.default_branch }} + if git diff --name-only origin/${{ github.event.repository.default_branch }}...HEAD | grep -E '^(gen\.Dockerfile|\.github/workflows/build-ci-image\.yml)$'; then + echo "image=ghcr.io/flyteorg/flyte/ci:pr-${{ steps.pr.outputs.number }}" >> $GITHUB_OUTPUT + echo "๐Ÿ“ฆ Using PR-specific image" + else + echo "image=ghcr.io/flyteorg/flyte/ci:v2" >> $GITHUB_OUTPUT + echo "๐Ÿ“ฆ Using default v2 image" + fi + + - name: Login to GHCR + run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin + + - name: Pull Docker image + run: docker pull ${{ steps.docker-image.outputs.image }} + + - name: Run generate in container + run: | + docker run --rm \ + -v ${{ github.workspace }}:/workspace \ + -w /workspace \ + -e SETUPTOOLS_SCM_PRETEND_VERSION=0.0.0 \ + -e UV_PROJECT_ENVIRONMENT=/tmp/flyte-venv \ + ${{ steps.docker-image.outputs.image }} \ + bash -c "git config --global --add safe.directory /workspace && cd gen/python && uv sync --all-groups --frozen && cd ../.. && make gen-local" + + - name: Commit and push changes + run: | + git config --global user.name "github-actions[bot]" + git config --global user.email "github-actions[bot]@users.noreply.github.com" + git add . + if ! git diff --cached --quiet; then + git commit -m "chore: regenerate files via workflow" + git push origin HEAD:${{ steps.pr.outputs.head_ref }} + fi + diff --git a/.github/workflows/selfassign.yml b/.github/workflows/selfassign.yml new file mode 100644 index 0000000000..a60bcb4c70 --- /dev/null +++ b/.github/workflows/selfassign.yml @@ -0,0 +1,24 @@ +# Allow users to automatically tag themselves to issues +# +# Usage: +# - a github user (a member of the repo) needs to comment +# with "#self-assign" on an issue to be assigned to them. +#------------------------------------------------------------ + +name: Self-assign +on: + issue_comment: + types: created +jobs: + one: + runs-on: ubuntu-latest + if: >- + (github.event.comment.body == '#take' || + github.event.comment.body == '#self-assign') + steps: + - run: | + echo "Assigning issue ${{ github.event.issue.number }} to ${{ github.event.comment.user.login }}" + curl -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \ + -d '{"assignees": ["${{ github.event.comment.user.login }}"]}' \ + https://api.github.com/repos/${{ github.repository }}/issues/${{ github.event.issue.number }}/assignees + echo "Done ๐Ÿ”ฅ " diff --git a/.github/workflows/update_site.yml b/.github/workflows/update_site.yml new file mode 100644 index 0000000000..222c1d03c8 --- /dev/null +++ b/.github/workflows/update_site.yml @@ -0,0 +1,25 @@ +name: Update version in flyte.org +on: + push: + tags: + - 'v[0-9]+.[0-9]+.[0-9]+' + + +jobs: + repository-dispatch: + name: Repository Dispatch + runs-on: ubuntu-latest + steps: + - name: Fetch version + id: bump + run: | + # from refs/tags/v1.2.3 get 1.2.3 + VERSION=$(echo $GITHUB_REF | sed 's#.*/v##') + echo "::set-output name=version::$VERSION" + - name: Create an event for the release + uses: peter-evans/repository-dispatch@v2 + with: + token: ${{ secrets.FLYTE_BOT_PAT }} + repository: flyteorg/flyteorg.github.io + event-type: release + client-payload: '{"tag": "${{ steps.bump.outputs.version }}"}' diff --git a/.gitignore b/.gitignore index 80120c5095..f0ce0a066f 100644 --- a/.gitignore +++ b/.gitignore @@ -39,3 +39,11 @@ docs/_src docs/_projects docs/tests empty-config.yaml + +**/rust/target +**/rust/Cargo.lock +**/flyteidl_new.egg-info +**/flyteidl.egg-info +**/flyteidl2.egg-info +node_modules +.claude/ diff --git a/.mockery.yaml b/.mockery.yaml new file mode 100644 index 0000000000..be23a02315 --- /dev/null +++ b/.mockery.yaml @@ -0,0 +1,122 @@ +log-level: warn +resolve-type-alias: False +disable-version-string: True +issue-845-fix: True +structname: "" +mockname: "{{.InterfaceName}}" +filename: "{{.InterfaceName | snakecase}}.go" +inpackage: false +outpkg: "mocks" +with-expecter: true +packages: + github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector: + config: + include-auto-generated: true + all: true + dir: 'gen/go/flyteidl2/connector/mocks' + github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app: + config: + include-auto-generated: true + all: true + dir: 'gen/go/flyteidl2/app/mocks' + github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow: + config: + include-auto-generated: true + all: true + dir: 'gen/go/flyteidl2/workflow/mocks' + github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow/workflowconnect: + config: + include-auto-generated: true + all: true + dir: 'gen/go/flyteidl2/workflow/workflowconnect/mocks' + github.com/flyteorg/flyte/v2/gen/go/flyteidl2/secret: + config: + include-auto-generated: true + all: true + dir: 'gen/go/flyteidl2/secret/mocks' + github.com/flyteorg/flyte/v2/gen/go/flyteidl2/imagebuilder: + config: + include-auto-generated: true + all: true + dir: 'gen/go/flyteidl2/imagebuilder/mocks' + github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task: + config: + include-auto-generated: true + all: true + dir: 'gen/go/flyteidl2/task/mocks' + github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common: + config: + include-auto-generated: true + all: true + dir: 'gen/go/flyteidl2/common/mocks' + github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins: + config: + include-auto-generated: true + all: true + dir: 'gen/go/flyteidl2/plugins/mocks' + github.com/flyteorg/flyte/v2/gen/go/flyteidl2/service: + config: + include-auto-generated: true + all: true + dir: 'gen/go/flyteidl2/service/mocks' + github.com/flyteorg/flyte/v2/runs/repository/interfaces: + config: + include-auto-generated: true + all: true + dir: 'runs/repository/mocks' + github.com/flyteorg/flyte/v2/queue/service: + config: + include-auto-generated: true + all: true + dir: 'queue/service/mocks' + + # flyteplugins + github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core: + config: + all: true + dir: 'flyteplugins/go/tasks/pluginmachinery/core/mocks' + github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/workqueue: + config: + all: true + dir: 'flyteplugins/go/tasks/pluginmachinery/workqueue/mocks' + github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s: + config: + all: true + dir: 'flyteplugins/go/tasks/pluginmachinery/k8s/mocks' + github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/catalog: + config: + all: true + dir: 'flyteplugins/go/tasks/pluginmachinery/catalog/mocks' + github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io: + config: + all: true + dir: 'flyteplugins/go/tasks/pluginmachinery/io/mocks' + + # flytestdlib + github.com/flyteorg/flyte/v2/flytestdlib/cache: + config: + all: true + dir: 'flytestdlib/cache/mocks' + github.com/flyteorg/flyte/v2/flytestdlib/utils: + config: + all: true + dir: 'flytestdlib/utils/mocks' + github.com/flyteorg/flyte/v2/flytestdlib/storage: + config: + all: false + dir: 'flytestdlib/storage/mocks' + interfaces: + RawStore: + ReferenceConstructor: + ComposedProtobufStore: + Metadata: + github.com/flyteorg/flyte/v2/flytestdlib/fastcheck: + config: + all: false + dir: 'flytestdlib/fastcheck/mocks' + interfaces: + Filter: + github.com/flyteorg/flyte/v2/flytestdlib/random: + config: + all: true + dir: 'flytestdlib/random/mocks' diff --git a/CODEOWNERS b/CODEOWNERS new file mode 100644 index 0000000000..7db3360542 --- /dev/null +++ b/CODEOWNERS @@ -0,0 +1,9 @@ +# This file defines code owners for the Flyte repository. +# Each line is a file pattern followed by one or more owners. +# Order matters - later patterns take precedence over earlier ones. + +# Default owners for everything in the repo +* @flyteorg/flyte2-contributors + +# flyteidl2 directory requires approval from flyteidl2-contributors team +/flyteidl2/ @flyteorg/flyteidl2-contributors diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000000..e06db538c7 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,362 @@ +# Contributing to Flyte 2 + +Thank you for your interest in contributing to Flyte 2! This guide will help you understand the contribution workflow, testing requirements, and release process. + +## Table of Contents +- [Getting Started](#getting-started) +- [Development Workflow](#development-workflow) +- [Making Changes](#making-changes) +- [Testing and Verification](#testing-and-verification) +- [Submitting Changes](#submitting-changes) +- [Release Process](#release-process) +- [Best Practices](#best-practices) + +## Getting Started + +### Prerequisites + +Before contributing, ensure you have: +- [Buf CLI](https://buf.build/docs/installation) installed +- Go 1.24.6 or later +- Node.js and npm (for TypeScript) +- Python 3.9+ with `uv` package manager +- Rust toolchain (if working with Rust bindings) +- Git configured with your name and email + +### Setting Up Your Environment + +1. **Fork the repository** on GitHub + +2. **Clone your fork**: + ```bash + git clone https://github.com/YOUR_USERNAME/flyte.git + cd flyte/flyte + ``` + +3. **Add upstream remote**: + ```bash + git remote add upstream https://github.com/flyteorg/flyte.git + ``` + +4. **Verify your setup**: + ```bash + make docker-pull # Pull the docker image for generation + make gen + ``` + +## Development Workflow + +### Creating a Feature Branch + +Always create a new branch for your changes: + +```bash +git checkout -b feature/your-feature-name +``` + +Use descriptive branch names: +- `feature/add-new-task-type` - for new features +- `fix/workflow-literal-bug` - for bug fixes +- `docs/improve-readme` - for documentation +- `refactor/simplify-interface` - for refactoring + +### Keeping Your Branch Updated + +Regularly sync with upstream: + +```bash +git fetch upstream +git rebase upstream/v2 +``` + +## Making Changes + +### 1. Modifying Protocol Buffers + +When editing `.proto` files in `flyteidl2/`: + +**Naming Conventions:** +- Use `snake_case` for field names: `task_id`, `execution_time` +- Use `PascalCase` for message names: `TaskDefinition`, `WorkflowSpec` +- Use `SCREAMING_SNAKE_CASE` for enum values: `TASK_STATE_RUNNING` + +**Backward Compatibility:** +- Never change field numbers +- Never change field types +- Never remove required fields +- Use `reserved` for removed fields: + ```protobuf + message Example { + reserved 2, 15, 9 to 11; + reserved "old_field_name"; + } + ``` + +**Documentation:** +- Add clear comments for all messages, fields, and enums +- Include examples where helpful +- Document any constraints or validation rules + +**Example:** +```protobuf +// TaskDefinition defines the structure and configuration of a task. +message TaskDefinition { + // Unique identifier for the task + string task_id = 1; + + // Human-readable name for the task + string name = 2; + + // Optional description explaining the task's purpose + string description = 3; +} +``` + +### 2. Generate and Format Code + +After making changes: + +```bash +# Format proto files +make buf-format + +# Lint proto files +make buf-lint + +# Generate all language bindings +make buf +``` + +### 3. Update Language-Specific Utilities (if needed) + +If you need to customize generation for a specific language, update files in `flyteidl2/gen_utils/`: +- `flyteidl2/gen_utils/go/` - Go-specific utilities +- `flyteidl2/gen_utils/ts/` - TypeScript utilities +- `flyteidl2/gen_utils/python/` - Python package configuration +- `flyteidl2/gen_utils/rust/` - Rust crate configuration + +## Testing and Verification + +### 1. Lint and Format Checks + +```bash +make buf-lint +make buf-format +``` + +All proto files must pass linting without errors. + +### 2. Verify Generated Code Builds + +**Go:** +```bash +make buf-go +make go-tidy +cd gen/go +go build ./... +go test ./... +``` + +**TypeScript:** +```bash +make buf-ts +cd gen/ts +npm install +npm run build # if there's a build script +``` + +**Python:** +```bash +make buf-python +cd gen/python +uv lock +uv sync +``` + +**Rust:** +```bash +make buf-rust +make build-crate +``` + +### 3. Generate Mocks (Go) + +If you've modified Go interfaces: + +```bash +make mocks +``` + +### 4. Integration Testing + +Test your changes in a downstream project that uses flyte: +1. Use `replace` directive in `go.mod` to point to your local changes +2. Generate code and verify it works as expected +3. Run integration tests in the consuming project + +## Submitting Changes + +### 1. Commit Your Changes + +Write clear, descriptive commit messages: + +```bash +git add . +git commit -s -m "feat: add new task execution state + +- Add TASK_STATE_CACHED for cached task results +- Update state transitions to support caching +- Add documentation for caching behavior + +Fixes #123" +``` + +**Commit message format:** +- Use conventional commits: `feat:`, `fix:`, `docs:`, `refactor:`, `test:` +- Include `-s` flag to sign your commits (required) +- Reference issue numbers with `Fixes #123` or `Closes #456` + +### 2. Push Your Changes + +```bash +git push origin feature/your-feature-name +``` + +### 3. Create a Pull Request + +1. Go to the [Flyte repository](https://github.com/flyteorg/flyte) +2. Click "New Pull Request" +3. Select your fork and branch +4. Target the `v2` branch (not `main`) +5. Fill out the PR template with: + - Description of changes + - Motivation and context + - Testing performed + - Screenshots (if UI changes) + - Breaking changes (if any) + +### 4. Code Review Process + +- Address reviewer feedback promptly +- Push new commits to the same branch +- Use `git commit --amend` for small fixes (then `git push --force`) +- Engage in constructive discussion +- Be patient - reviews may take time + +## Release Process + +Releases are created by maintainers following these steps: + +### Version Management + +Flyte 2 follows [Semantic Versioning 2.0.0](https://semver.org/): + +- **MAJOR** version (v2.0.0 โ†’ v3.0.0): Breaking changes +- **MINOR** version (v2.1.0 โ†’ v2.2.0): New features, backward compatible +- **PATCH** version (v2.1.1 โ†’ v2.1.2): Bug fixes, backward compatible + +### Creating a Release (Maintainers Only) + +1. **Ensure all changes are merged into `v2` branch** + +2. **Determine the version number** based on changes: + ```bash + # View changes since last release + git log v2.X.Y..HEAD --oneline + ``` + +3. **Create and push a tag**: + ```bash + git checkout v2 + git pull upstream v2 + git tag -a v2.X.Y -m "Release v2.X.Y" + git push upstream v2.X.Y + ``` + +4. **Create GitHub Release**: + - Go to [Releases](https://github.com/flyteorg/flyte/releases) + - Click "Draft a new release" + - Select the tag you just created + - Generate release notes + - Add any additional context or highlights + - Publish release + +5. **Verify Artifacts**: + The release triggers automated publishing to: + - Go modules: `github.com/flyteorg/flyte/v2` + - NPM: `@flyteorg/flyte` + - PyPI: `flyteidl2` + - Crates.io: `flyte` + +### Post-Release + +1. **Verify published packages**: + ```bash + # Go + GOPROXY=https://proxy.golang.org go list -m github.com/flyteorg/flyte/v2@v2.X.Y + + # NPM + npm view @flyteorg/flyte@2.X.Y + + # PyPI + pip index versions flyteidl2 + + # Crates.io + cargo search flyte + ``` + +2. **Update dependent projects** with the new version + +3. **Announce the release** in community channels + +## Best Practices + +### Protocol Buffer Design + +- **Keep messages small and focused** - Single responsibility principle +- **Use oneof for mutually exclusive fields**: + ```protobuf + message Task { + oneof task_type { + PythonTask python = 1; + ContainerTask container = 2; + } + } + ``` +- **Use optional for truly optional fields** (proto3) +- **Use repeated for arrays/lists** +- **Provide sensible defaults** where appropriate + +### Documentation + +- Document all public APIs +- Include usage examples in comments +- Keep README.md and CONTRIBUTING.md up to date +- Add inline comments for complex logic + +### Git Workflow + +- Commit early and often +- Keep commits atomic and focused +- Write meaningful commit messages +- Squash small "fix" commits before PR +- Rebase instead of merge when updating your branch + +### Communication + +- Be respectful and professional +- Ask questions when unclear +- Provide context in discussions +- Update PR descriptions as scope changes +- Respond to reviews in a timely manner + +## Getting Help + +- **Documentation**: [Flyte Documentation](https://docs.flyte.org) +- **Community Slack**: [Flyte Slack](https://slack.flyte.org) +- **GitHub Issues**: [Report Issues](https://github.com/flyteorg/flyte/issues) +- **GitHub Discussions**: [Ask Questions](https://github.com/flyteorg/flyte/discussions) + +## License + +By contributing to Flyte 2, you agree that your contributions will be licensed under the Apache License 2.0. diff --git a/DOCKER_QUICK_START.md b/DOCKER_QUICK_START.md new file mode 100644 index 0000000000..66ac073fbf --- /dev/null +++ b/DOCKER_QUICK_START.md @@ -0,0 +1,136 @@ +# Docker Development - Quick Start + +This guide gets you started with Docker-based development in under 5 minutes. + +## Why Docker? + +Using Docker ensures your local environment matches CI exactly, eliminating "works on my machine" issues. + +## Quick Start + +### 1. Pull the Image + +```bash +make docker-pull +``` + +or + +```bash +docker pull ghcr.io/flyteorg/flyte/ci:v2 +``` + +### 2. Run Common Commands + +#### Generate Protocol Buffers +```bash +make gen +``` + +#### Interactive Shell +```bash +make docker-shell +``` + +### 3. Manual Docker Commands + +If you prefer not to use Make: + +```bash +# Generate files +docker run --rm -v $(pwd):/workspace -w /workspace \ + ghcr.io/flyteorg/flyte/ci:v2 make gen + +# Interactive shell +docker run --rm -it -v $(pwd):/workspace -w /workspace \ + ghcr.io/flyteorg/flyte/ci:v2 bash +``` + +## Available Make Targets + +Run `make help` to see all available targets including Docker-based ones: + +```bash +make help +``` + +Docker-specific targets: +- `make docker-pull` - Pull the latest CI image +- `make docker-shell` - Start interactive shell +- `make gen` - Run code generation +- `make build-crate` - Build Rust crate + +## Troubleshooting + +### Permission Issues + +If generated files have wrong ownership: + +```bash +docker run --rm -v $(pwd):/workspace -w /workspace \ + --user $(id -u):$(id -g) \ + ghcr.io/flyteorg/flyte/ci:v2 make gen +``` + +### Authentication Issues + +Login to GitHub Container Registry: + +```bash +gh auth token | docker login ghcr.io -u YOUR_USERNAME --password-stdin +``` + +## Updating the Docker Image + +### Fast Local Iteration (Recommended) + +If you're modifying `gen.Dockerfile`, build and test locally first: + +```bash +# One command to build and generate +make docker-dev + +# Or step-by-step +make docker-build # Build image +make docker-shell # Test interactively +make gen # Run generation +``` + +This is **much faster** than waiting for PR builds! + +### PR Testing (After Local Testing) + +Once your local changes work: + +1. **Create a PR** with your changes +2. **Wait for build** - A bot will comment with the PR-specific image tag +3. **Test with PR image** to verify CI works: + ```bash + docker pull ghcr.io/flyteorg/flyte/ci:pr-123 # Use your PR number + docker run --rm -it -v $(pwd):/workspace -w /workspace \ + ghcr.io/flyteorg/flyte/ci:pr-123 bash + ``` +4. **CI automatically uses** your new image in the PR + +### Workflow Comparison + +**Local iteration** (seconds to minutes): +```bash +vim gen.Dockerfile +make docker-dev # Fast! +# Repeat until it works +``` + +**PR iteration** (5-10 minutes per build): +```bash +git push +# Wait for build... +docker pull ghcr.io/flyteorg/flyte/ci:pr-123 +# Test +``` + +Use local iteration first, then validate with PR! + +## More Information + +See [docs/docker-image-workflow.md](docs/docker-image-workflow.md) for comprehensive documentation. diff --git a/IMPLEMENTATION_SPEC.md b/IMPLEMENTATION_SPEC.md new file mode 100644 index 0000000000..66253b5949 --- /dev/null +++ b/IMPLEMENTATION_SPEC.md @@ -0,0 +1,1270 @@ +# Implementation Specification: Queue, Runs, and State Services + +## Overview + +This document specifies the implementation of three gRPC services using buf connect: +- **QueueService** - Manages execution queue for actions +- **RunService** - Manages workflow runs and their lifecycle +- **StateService** - Manages state persistence for actions + +Each service will have a simple implementation backed by PostgreSQL, using pgx for database operations, and leveraging existing flytestdlib packages for database connectivity and configuration management. + +## Architecture + +``` +flyte/ +โ”œโ”€โ”€ queue/ # QueueService implementation +โ”‚ โ”œโ”€โ”€ config/ +โ”‚ โ”‚ โ””โ”€โ”€ config.go # Queue-specific configuration +โ”‚ โ”œโ”€โ”€ repository/ +โ”‚ โ”‚ โ”œโ”€โ”€ interfaces.go # Repository interfaces +โ”‚ โ”‚ โ”œโ”€โ”€ postgres.go # PostgreSQL implementation +โ”‚ โ”‚ โ””โ”€โ”€ models.go # Database models +โ”‚ โ”œโ”€โ”€ service/ +โ”‚ โ”‚ โ””โ”€โ”€ queue_service.go # QueueServiceHandler implementation +โ”‚ โ”œโ”€โ”€ cmd/ +โ”‚ โ”‚ โ””โ”€โ”€ main.go # Standalone queue service binary +โ”‚ โ””โ”€โ”€ migrations/ +โ”‚ โ””โ”€โ”€ *.sql # Database migration files +โ”‚ +โ”œโ”€โ”€ runs/ # RunService implementation +โ”‚ โ”œโ”€โ”€ config/ +โ”‚ โ”‚ โ””โ”€โ”€ config.go # Runs-specific configuration +โ”‚ โ”œโ”€โ”€ repository/ +โ”‚ โ”‚ โ”œโ”€โ”€ interfaces.go # Repository interfaces +โ”‚ โ”‚ โ”œโ”€โ”€ postgres.go # PostgreSQL implementation +โ”‚ โ”‚ โ””โ”€โ”€ models.go # Database models +โ”‚ โ”œโ”€โ”€ service/ +โ”‚ โ”‚ โ””โ”€โ”€ run_service.go # RunServiceHandler implementation +โ”‚ โ”œโ”€โ”€ cmd/ +โ”‚ โ”‚ โ””โ”€โ”€ main.go # Standalone runs service binary +โ”‚ โ””โ”€โ”€ migrations/ +โ”‚ โ””โ”€โ”€ *.sql # Database migration files +โ”‚ +โ”œโ”€โ”€ state/ # StateService implementation +โ”‚ โ”œโ”€โ”€ config/ +โ”‚ โ”‚ โ””โ”€โ”€ config.go # State-specific configuration +โ”‚ โ”œโ”€โ”€ repository/ +โ”‚ โ”‚ โ”œโ”€โ”€ interfaces.go # Repository interfaces +โ”‚ โ”‚ โ”œโ”€โ”€ postgres.go # PostgreSQL implementation +โ”‚ โ”‚ โ””โ”€โ”€ models.go # Database models +โ”‚ โ”œโ”€โ”€ service/ +โ”‚ โ”‚ โ””โ”€โ”€ state_service.go # StateServiceHandler implementation +โ”‚ โ”œโ”€โ”€ cmd/ +โ”‚ โ”‚ โ””โ”€โ”€ main.go # Standalone state service binary +โ”‚ โ””โ”€โ”€ migrations/ +โ”‚ โ””โ”€โ”€ *.sql # Database migration files +โ”‚ +โ””โ”€โ”€ cmd/ + โ””โ”€โ”€ flyte-services/ + โ””โ”€โ”€ main.go # Unified binary for all services + executor +``` + +## Technology Stack + +### Core Dependencies +- **Protocol**: buf connect (using generated code from `gen/go/flyteidl2/workflow/workflowconnect/`) +- **Database**: PostgreSQL +- **Database Driver**: pgx/v5 (for raw queries) +- **ORM**: gorm (for migrations and basic operations) +- **Config Management**: `github.com/flyteorg/flyte/v2/flytestdlib/config` +- **Database Utils**: `github.com/flyteorg/flyte/v2/flytestdlib/database` +- **Logging**: `github.com/flyteorg/flyte/v2/flytestdlib/logger` +- **CLI**: `github.com/spf13/cobra` + +### Service Framework +- HTTP server using `net/http` +- buf connect handlers mounted on HTTP server +- Graceful shutdown support +- Health check endpoints + +## Service Specifications + +### 1. QueueService + +**Location**: `queue/` + +**Proto Definition**: `flyteidl2/workflow/queue_service.proto` + +**Connect Interface**: `workflowconnect.QueueServiceHandler` + +#### RPCs to Implement: +1. `EnqueueAction(EnqueueActionRequest) -> EnqueueActionResponse` + - Validates request + - Persists action to queue table + - Returns immediately (async processing) + +2. `AbortQueuedRun(AbortQueuedRunRequest) -> AbortQueuedRunResponse` + - Marks all actions in a run as aborted + - Updates abort metadata + +3. `AbortQueuedAction(AbortQueuedActionRequest) -> AbortQueuedActionResponse` + - Marks specific action as aborted + - Updates abort metadata + +#### Database Schema: + +```sql +-- queue/migrations/001_create_queue_tables.sql + +CREATE TABLE IF NOT EXISTS queued_actions ( + id BIGSERIAL PRIMARY KEY, + + -- Action Identifier + org VARCHAR(255) NOT NULL, + project VARCHAR(255) NOT NULL, + domain VARCHAR(255) NOT NULL, + run_name VARCHAR(255) NOT NULL, + action_name VARCHAR(255) NOT NULL, + + -- Parent reference + parent_action_name VARCHAR(255), + + -- Action group + action_group VARCHAR(255), + + -- Subject who created the action + subject VARCHAR(255), + + -- Serialized action spec (protobuf or JSON) + action_spec JSONB NOT NULL, + + -- Input/Output paths + input_uri TEXT NOT NULL, + run_output_base TEXT NOT NULL, + + -- Queue metadata + enqueued_at TIMESTAMP NOT NULL DEFAULT NOW(), + processed_at TIMESTAMP, + + -- Status tracking + status VARCHAR(50) NOT NULL DEFAULT 'queued', -- queued, processing, completed, aborted, failed + abort_reason TEXT, + error_message TEXT, + + -- Indexing + created_at TIMESTAMP NOT NULL DEFAULT NOW(), + updated_at TIMESTAMP NOT NULL DEFAULT NOW(), + + -- Unique constraint on action identifier + UNIQUE(org, project, domain, run_name, action_name) +); + +CREATE INDEX idx_queued_actions_run ON queued_actions(org, project, domain, run_name); +CREATE INDEX idx_queued_actions_status ON queued_actions(status); +CREATE INDEX idx_queued_actions_enqueued_at ON queued_actions(enqueued_at) WHERE status = 'queued'; +CREATE INDEX idx_queued_actions_parent ON queued_actions(parent_action_name) WHERE parent_action_name IS NOT NULL; +``` + +#### Configuration: + +```go +// queue/config/config.go + +type Config struct { + // HTTP server configuration + Server ServerConfig `json:"server"` + + // Database configuration (reuses flytestdlib) + Database database.DbConfig `json:"database"` + + // Queue specific settings + MaxQueueSize int `json:"maxQueueSize" pflag:",Maximum number of queued actions"` + WorkerCount int `json:"workerCount" pflag:",Number of worker goroutines for processing queue"` +} + +type ServerConfig struct { + Port int `json:"port" pflag:",Port to bind the HTTP server"` + Host string `json:"host" pflag:",Host to bind the HTTP server"` +} +``` + +--- + +### 2. RunService + +**Location**: `runs/` + +**Proto Definition**: `flyteidl2/workflow/run_service.proto` + +**Connect Interface**: `workflowconnect.RunServiceHandler` + +#### RPCs to Implement: +1. `CreateRun(CreateRunRequest) -> CreateRunResponse` + - Creates a new run record + - Initializes root action + - Returns run metadata + +2. `AbortRun(AbortRunRequest) -> AbortRunResponse` + - Marks run as aborted + - Cascades to all actions + +3. `GetRunDetails(GetRunDetailsRequest) -> GetRunDetailsResponse` + - Fetches complete run information + - Includes root action details + +4. `WatchRunDetails(WatchRunDetailsRequest) -> stream WatchRunDetailsResponse` + - Streams run updates + - Uses PostgreSQL LISTEN/NOTIFY for real-time updates + +5. `GetActionDetails(GetActionDetailsRequest) -> GetActionDetailsResponse` + - Fetches detailed action information + - Includes all attempts + +6. `WatchActionDetails(WatchActionDetailsRequest) -> stream WatchActionDetailsResponse` + - Streams action updates + +7. `GetActionData(GetActionDataRequest) -> GetActionDataResponse` + - Returns input/output references + - Does NOT load actual data (just URIs) + +8. `ListRuns(ListRunsRequest) -> ListRunsResponse` + - Paginated run listing + - Supports filtering by org/project/trigger + +9. `WatchRuns(WatchRunsRequest) -> stream WatchRunsResponse` + - Streams run updates matching filter + +10. `ListActions(ListActionsRequest) -> ListActionsResponse` + - Lists actions for a run + - Paginated + +11. `WatchActions(WatchActionsRequest) -> stream WatchActionsResponse` + - Streams action updates for a run + - Supports filtering + +12. `WatchClusterEvents(WatchClusterEventsRequest) -> stream WatchClusterEventsResponse` + - Streams cluster events for an action attempt + +13. `AbortAction(AbortActionRequest) -> AbortActionResponse` + - Aborts a specific action + +#### Database Schema: + +```sql +-- runs/migrations/001_create_runs_tables.sql + +CREATE TYPE phase AS ENUM ( + 'PHASE_UNSPECIFIED', + 'PHASE_QUEUED', + 'PHASE_WAITING_FOR_RESOURCES', + 'PHASE_INITIALIZING', + 'PHASE_RUNNING', + 'PHASE_SUCCEEDED', + 'PHASE_FAILED', + 'PHASE_ABORTED', + 'PHASE_TIMED_OUT' +); + +CREATE TYPE action_type AS ENUM ( + 'ACTION_TYPE_UNSPECIFIED', + 'ACTION_TYPE_TASK', + 'ACTION_TYPE_TRACE', + 'ACTION_TYPE_CONDITION' +); + +CREATE TYPE error_kind AS ENUM ( + 'KIND_UNSPECIFIED', + 'KIND_USER', + 'KIND_SYSTEM' +); + +CREATE TABLE IF NOT EXISTS runs ( + id BIGSERIAL PRIMARY KEY, + + -- Run Identifier + org VARCHAR(255) NOT NULL, + project VARCHAR(255) NOT NULL, + domain VARCHAR(255) NOT NULL, + name VARCHAR(255) NOT NULL, + + -- Root action reference + root_action_name VARCHAR(255) NOT NULL, + + -- Trigger reference (if applicable) + trigger_org VARCHAR(255), + trigger_project VARCHAR(255), + trigger_domain VARCHAR(255), + trigger_name VARCHAR(255), + + -- Run spec (serialized) + run_spec JSONB NOT NULL, + + -- Metadata + created_by_principal VARCHAR(255), + created_by_k8s_service_account VARCHAR(255), + + -- Timestamps + created_at TIMESTAMP NOT NULL DEFAULT NOW(), + updated_at TIMESTAMP NOT NULL DEFAULT NOW(), + + -- Unique constraint + UNIQUE(org, project, domain, name) +); + +CREATE TABLE IF NOT EXISTS actions ( + id BIGSERIAL PRIMARY KEY, + + -- Action Identifier + org VARCHAR(255) NOT NULL, + project VARCHAR(255) NOT NULL, + domain VARCHAR(255) NOT NULL, + run_name VARCHAR(255) NOT NULL, + name VARCHAR(255) NOT NULL, + + -- Foreign key to run + run_id BIGINT NOT NULL REFERENCES runs(id) ON DELETE CASCADE, + + -- Parent action (for nested actions) + parent_action_name VARCHAR(255), + + -- Action type and metadata + action_type action_type NOT NULL, + action_group VARCHAR(255), + + -- Task action metadata (nullable) + task_org VARCHAR(255), + task_project VARCHAR(255), + task_domain VARCHAR(255), + task_name VARCHAR(255), + task_version VARCHAR(255), + task_type VARCHAR(255), + task_short_name VARCHAR(255), + + -- Trace action metadata (nullable) + trace_name VARCHAR(255), + + -- Condition action metadata (nullable) + condition_name VARCHAR(255), + condition_scope_type VARCHAR(50), -- run_id, action_id, global + condition_scope_value TEXT, + + -- Execution metadata + executed_by_principal VARCHAR(255), + executed_by_k8s_service_account VARCHAR(255), + + -- Status + phase phase NOT NULL DEFAULT 'PHASE_QUEUED', + start_time TIMESTAMP, + end_time TIMESTAMP, + attempts_count INT NOT NULL DEFAULT 0, + + -- Cache status + cache_status VARCHAR(50), + + -- Error info (if failed) + error_kind error_kind, + error_message TEXT, + + -- Abort info (if aborted) + abort_reason TEXT, + aborted_by_principal VARCHAR(255), + aborted_by_k8s_service_account VARCHAR(255), + + -- Serialized specs + task_spec JSONB, + trace_spec JSONB, + condition_spec JSONB, + + -- Input/Output references + input_uri TEXT, + run_output_base TEXT, + + -- Timestamps + created_at TIMESTAMP NOT NULL DEFAULT NOW(), + updated_at TIMESTAMP NOT NULL DEFAULT NOW(), + + -- Unique constraint + UNIQUE(org, project, domain, run_name, name) +); + +CREATE TABLE IF NOT EXISTS action_attempts ( + id BIGSERIAL PRIMARY KEY, + + -- Foreign key to action + action_id BIGINT NOT NULL REFERENCES actions(id) ON DELETE CASCADE, + + -- Attempt number (1-indexed) + attempt_number INT NOT NULL, + + -- Phase tracking + phase phase NOT NULL, + start_time TIMESTAMP NOT NULL, + end_time TIMESTAMP, + + -- Error info (if failed) + error_kind error_kind, + error_message TEXT, + + -- Output references + outputs JSONB, + + -- Logs + log_info JSONB, -- Array of TaskLog + logs_available BOOLEAN DEFAULT FALSE, + + -- Cache status + cache_status VARCHAR(50), + + -- Cluster assignment + cluster VARCHAR(255), + + -- Log context (k8s pod/container info) + log_context JSONB, + + -- Timestamps + created_at TIMESTAMP NOT NULL DEFAULT NOW(), + updated_at TIMESTAMP NOT NULL DEFAULT NOW(), + + -- Unique constraint + UNIQUE(action_id, attempt_number) +); + +CREATE TABLE IF NOT EXISTS cluster_events ( + id BIGSERIAL PRIMARY KEY, + + -- Foreign key to attempt + attempt_id BIGINT NOT NULL REFERENCES action_attempts(id) ON DELETE CASCADE, + + -- Event details + occurred_at TIMESTAMP NOT NULL, + message TEXT NOT NULL, + + -- Timestamps + created_at TIMESTAMP NOT NULL DEFAULT NOW() +); + +CREATE TABLE IF NOT EXISTS phase_transitions ( + id BIGSERIAL PRIMARY KEY, + + -- Foreign key to attempt + attempt_id BIGINT NOT NULL REFERENCES action_attempts(id) ON DELETE CASCADE, + + -- Phase transition + phase phase NOT NULL, + start_time TIMESTAMP NOT NULL, + end_time TIMESTAMP, + + -- Timestamps + created_at TIMESTAMP NOT NULL DEFAULT NOW() +); + +-- Indexes for performance +CREATE INDEX idx_runs_org_project ON runs(org, project); +CREATE INDEX idx_runs_trigger ON runs(trigger_org, trigger_project, trigger_domain, trigger_name) WHERE trigger_name IS NOT NULL; +CREATE INDEX idx_actions_run_id ON actions(run_id); +CREATE INDEX idx_actions_phase ON actions(phase); +CREATE INDEX idx_actions_parent ON actions(parent_action_name) WHERE parent_action_name IS NOT NULL; +CREATE INDEX idx_attempts_action_id ON action_attempts(action_id); +CREATE INDEX idx_cluster_events_attempt_id ON cluster_events(attempt_id); +CREATE INDEX idx_phase_transitions_attempt_id ON phase_transitions(attempt_id); + +-- For real-time updates using LISTEN/NOTIFY +CREATE OR REPLACE FUNCTION notify_action_change() RETURNS TRIGGER AS $$ +BEGIN + PERFORM pg_notify('action_updates', NEW.id::TEXT); + RETURN NEW; +END; +$$ LANGUAGE plpgsql; + +CREATE TRIGGER action_update_trigger +AFTER INSERT OR UPDATE ON actions +FOR EACH ROW EXECUTE FUNCTION notify_action_change(); + +CREATE OR REPLACE FUNCTION notify_run_change() RETURNS TRIGGER AS $$ +BEGIN + PERFORM pg_notify('run_updates', NEW.id::TEXT); + RETURN NEW; +END; +$$ LANGUAGE plpgsql; + +CREATE TRIGGER run_update_trigger +AFTER INSERT OR UPDATE ON runs +FOR EACH ROW EXECUTE FUNCTION notify_run_change(); +``` + +#### Configuration: + +```go +// runs/config/config.go + +type Config struct { + // HTTP server configuration + Server ServerConfig `json:"server"` + + // Database configuration + Database database.DbConfig `json:"database"` + + // Watch/streaming settings + WatchBufferSize int `json:"watchBufferSize" pflag:",Buffer size for watch streams"` +} + +type ServerConfig struct { + Port int `json:"port" pflag:",Port to bind the HTTP server"` + Host string `json:"host" pflag:",Host to bind the HTTP server"` +} +``` + +--- + +### 3. StateService + +**Location**: `state/` + +**Proto Definition**: `flyteidl2/workflow/state_service.proto` + +**Connect Interface**: `workflowconnect.StateServiceHandler` + +#### RPCs to Implement: +1. `Put(stream PutRequest) -> stream PutResponse` + - Bidirectional streaming + - Persists action state (NodeStatus JSON) + - Returns status for each request + +2. `Get(stream GetRequest) -> stream GetResponse` + - Bidirectional streaming + - Retrieves action state + +3. `Watch(WatchRequest) -> stream WatchResponse` + - Server streaming + - Watches state changes for child actions + - Uses PostgreSQL LISTEN/NOTIFY + +#### Database Schema: + +```sql +-- state/migrations/001_create_state_tables.sql + +CREATE TABLE IF NOT EXISTS action_states ( + id BIGSERIAL PRIMARY KEY, + + -- Action Identifier + org VARCHAR(255) NOT NULL, + project VARCHAR(255) NOT NULL, + domain VARCHAR(255) NOT NULL, + run_name VARCHAR(255) NOT NULL, + action_name VARCHAR(255) NOT NULL, + + -- Parent reference + parent_action_name VARCHAR(255), + + -- State data (NodeStatus as JSON) + state JSONB NOT NULL, + + -- Phase (extracted from state for indexing/filtering) + phase VARCHAR(50), + + -- Output URI (extracted from state) + output_uri TEXT, + + -- Error (extracted from state) + error JSONB, + + -- Version tracking for optimistic locking + version BIGINT NOT NULL DEFAULT 1, + + -- Timestamps + created_at TIMESTAMP NOT NULL DEFAULT NOW(), + updated_at TIMESTAMP NOT NULL DEFAULT NOW(), + + -- Unique constraint + UNIQUE(org, project, domain, run_name, action_name) +); + +CREATE INDEX idx_action_states_parent ON action_states(parent_action_name) WHERE parent_action_name IS NOT NULL; +CREATE INDEX idx_action_states_phase ON action_states(phase); + +-- For real-time updates using LISTEN/NOTIFY +CREATE OR REPLACE FUNCTION notify_state_change() RETURNS TRIGGER AS $$ +BEGIN + PERFORM pg_notify('state_updates', + json_build_object( + 'action_id', NEW.id, + 'parent_action_name', NEW.parent_action_name + )::TEXT + ); + RETURN NEW; +END; +$$ LANGUAGE plpgsql; + +CREATE TRIGGER state_update_trigger +AFTER INSERT OR UPDATE ON action_states +FOR EACH ROW EXECUTE FUNCTION notify_state_change(); +``` + +#### Configuration: + +```go +// state/config/config.go + +type Config struct { + // HTTP server configuration + Server ServerConfig `json:"server"` + + // Database configuration + Database database.DbConfig `json:"database"` + + // State specific settings + MaxStateSizeBytes int `json:"maxStateSizeBytes" pflag:",Maximum size of state JSON in bytes"` +} + +type ServerConfig struct { + Port int `json:"port" pflag:",Port to bind the HTTP server"` + Host string `json:"host" pflag:",Host to bind the HTTP server"` +} +``` + +--- + +## Unified Binary + +**Location**: `cmd/flyte-services/main.go` + +The unified binary provides a single entrypoint that can run: +1. **queue** - QueueService only +2. **runs** - RunService only +3. **state** - StateService only +4. **executor** - Kubernetes controller only +5. **all** - All services together on different ports + +### Command Structure: + +```bash +# Run queue service only +flyte-services queue --config config.yaml + +# Run runs service only +flyte-services runs --config config.yaml + +# Run state service only +flyte-services state --config config.yaml + +# Run executor only +flyte-services executor --config config.yaml + +# Run all services +flyte-services all --config config.yaml +``` + +### Implementation: + +```go +// cmd/flyte-services/main.go + +package main + +import ( + "context" + "os" + "os/signal" + "syscall" + + "github.com/spf13/cobra" + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + + queuecmd "github.com/flyteorg/flyte/v2/queue/cmd" + runscmd "github.com/flyteorg/flyte/v2/runs/cmd" + statecmd "github.com/flyteorg/flyte/v2/state/cmd" + executorcmd "github.com/flyteorg/flyte/v2/executor/cmd" +) + +var rootCmd = &cobra.Command{ + Use: "flyte-services", + Short: "Flyte services unified binary", +} + +func init() { + rootCmd.AddCommand(queuecmd.NewQueueCommand()) + rootCmd.AddCommand(runscmd.NewRunsCommand()) + rootCmd.AddCommand(statecmd.NewStateCommand()) + rootCmd.AddCommand(executorcmd.NewExecutorCommand()) + rootCmd.AddCommand(newAllCommand()) +} + +func main() { + if err := rootCmd.Execute(); err != nil { + os.Exit(1) + } +} + +func newAllCommand() *cobra.Command { + return &cobra.Command{ + Use: "all", + Short: "Run all services (queue, runs, state, executor)", + RunE: func(cmd *cobra.Command, args []string) error { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + // Setup signal handling + sigCh := make(chan os.Signal, 1) + signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM) + + // Start all services in goroutines + errCh := make(chan error, 4) + + go func() { + errCh <- queuecmd.RunQueue(ctx) + }() + + go func() { + errCh <- runscmd.RunRuns(ctx) + }() + + go func() { + errCh <- statecmd.RunState(ctx) + }() + + go func() { + errCh <- executorcmd.RunExecutor(ctx) + }() + + // Wait for signal or error + select { + case sig := <-sigCh: + logger.Infof(ctx, "Received signal %v, shutting down...", sig) + cancel() + case err := <-errCh: + logger.Errorf(ctx, "Service error: %v", err) + cancel() + return err + } + + return nil + }, + } +} +``` + +--- + +## Database Connection Management + +All services use flytestdlib for database management: + +```go +// Example from queue/service/queue_service.go + +import ( + "github.com/flyteorg/flyte/v2/flytestdlib/database" + "gorm.io/gorm" +) + +func initDB(ctx context.Context, cfg *database.DbConfig) (*gorm.DB, error) { + gormConfig := &gorm.Config{ + // Configuration options + } + + // Create database if it doesn't exist + db, err := database.CreatePostgresDbIfNotExists(ctx, gormConfig, cfg.Postgres) + if err != nil { + return nil, err + } + + // Apply connection pool settings + sqlDB, err := db.DB() + if err != nil { + return nil, err + } + + sqlDB.SetMaxIdleConns(cfg.MaxIdleConnections) + sqlDB.SetMaxOpenConns(cfg.MaxOpenConnections) + sqlDB.SetConnMaxLifetime(cfg.ConnMaxLifeTime.Duration) + + return db, nil +} +``` + +For pgx-specific operations (like LISTEN/NOTIFY for streaming): + +```go +import ( + "github.com/jackc/pgx/v5/pgxpool" +) + +func initPgxPool(ctx context.Context, cfg *database.PostgresConfig) (*pgxpool.Pool, error) { + connString := fmt.Sprintf( + "postgres://%s:%s@%s:%d/%s?%s", + cfg.User, + resolvePassword(ctx, cfg.Password, cfg.PasswordPath), + cfg.Host, + cfg.Port, + cfg.DbName, + cfg.ExtraOptions, + ) + + return pgxpool.New(ctx, connString) +} +``` + +--- + +## Configuration Management + +All services use flytestdlib config: + +```go +// Example from queue/cmd/main.go + +import ( + "github.com/flyteorg/flyte/v2/flytestdlib/config" + queueconfig "github.com/flyteorg/flyte/v2/queue/config" +) + +var ( + configSection = config.MustRegisterSection("queue", &queueconfig.Config{}) +) + +func main() { + // Parse config from file and flags + if err := config.LoadConfig(...); err != nil { + panic(err) + } + + cfg := configSection.GetConfig().(*queueconfig.Config) + // Use cfg... +} +``` + +--- + +## Service Implementation Pattern + +Each service follows this pattern: + +```go +// queue/service/queue_service.go + +package service + +import ( + "context" + + "connectrpc.com/connect" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow/workflowconnect" + "github.com/flyteorg/flyte/v2/queue/repository" +) + +type QueueService struct { + repo repository.Repository +} + +func NewQueueService(repo repository.Repository) *QueueService { + return &QueueService{repo: repo} +} + +// Ensure we implement the interface +var _ workflowconnect.QueueServiceHandler = (*QueueService)(nil) + +func (s *QueueService) EnqueueAction( + ctx context.Context, + req *connect.Request[workflow.EnqueueActionRequest], +) (*connect.Response[workflow.EnqueueActionResponse], error) { + // Validate request + if err := req.Msg.Validate(); err != nil { + return nil, connect.NewError(connect.CodeInvalidArgument, err) + } + + // Persist to database + if err := s.repo.EnqueueAction(ctx, req.Msg); err != nil { + return nil, connect.NewError(connect.CodeInternal, err) + } + + return connect.NewResponse(&workflow.EnqueueActionResponse{}), nil +} + +// ... other methods +``` + +--- + +## HTTP Server Setup + +Each service's main.go sets up an HTTP server: + +```go +// queue/cmd/main.go + +package cmd + +import ( + "context" + "fmt" + "net/http" + + "golang.org/x/net/http2" + "golang.org/x/net/http2/h2c" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow/workflowconnect" + "github.com/flyteorg/flyte/v2/queue/service" + "github.com/flyteorg/flyte/v2/queue/repository" +) + +func RunQueue(ctx context.Context) error { + // Initialize database + db, err := initDB(ctx) + if err != nil { + return err + } + + // Run migrations + if err := runMigrations(db); err != nil { + return err + } + + // Create repository + repo := repository.NewPostgresRepository(db) + + // Create service + svc := service.NewQueueService(repo) + + // Create HTTP handler + mux := http.NewServeMux() + + path, handler := workflowconnect.NewQueueServiceHandler(svc) + mux.Handle(path, handler) + + // Add health check + mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + w.Write([]byte("OK")) + }) + + // Setup HTTP/2 support + addr := fmt.Sprintf("%s:%d", cfg.Server.Host, cfg.Server.Port) + server := &http.Server{ + Addr: addr, + Handler: h2c.NewHandler(mux, &http2.Server{}), + } + + logger.Infof(ctx, "Starting Queue Service on %s", addr) + return server.ListenAndServe() +} +``` + +--- + +## Migration Management + +Each service uses golang-migrate or similar: + +```go +// queue/repository/migrations.go + +func RunMigrations(db *gorm.DB) error { + return db.AutoMigrate( + &models.QueuedAction{}, + ) +} +``` + +Or use raw SQL migrations with a migration tool. + +--- + +## Repository Pattern + +Each service implements a repository interface: + +```go +// queue/repository/interfaces.go + +type Repository interface { + EnqueueAction(ctx context.Context, req *workflow.EnqueueActionRequest) error + AbortQueuedRun(ctx context.Context, runID *common.RunIdentifier, reason string) error + AbortQueuedAction(ctx context.Context, actionID *common.ActionIdentifier, reason string) error + GetQueuedActions(ctx context.Context, limit int) ([]*models.QueuedAction, error) +} +``` + +```go +// queue/repository/postgres.go + +type PostgresRepository struct { + db *gorm.DB +} + +func NewPostgresRepository(db *gorm.DB) Repository { + return &PostgresRepository{db: db} +} + +func (r *PostgresRepository) EnqueueAction(ctx context.Context, req *workflow.EnqueueActionRequest) error { + action := &models.QueuedAction{ + Org: req.ActionId.RunId.Org, + Project: req.ActionId.RunId.Project, + Domain: req.ActionId.RunId.Domain, + RunName: req.ActionId.RunId.Name, + ActionName: req.ActionId.Name, + ParentActionName: req.ParentActionName, + ActionGroup: req.Group, + Subject: req.Subject, + ActionSpec: req, // Will be marshaled to JSONB + InputUri: req.InputUri, + RunOutputBase: req.RunOutputBase, + Status: "queued", + } + + return r.db.WithContext(ctx).Create(action).Error +} +``` + +--- + +## Streaming Implementation (Watch/Listen) + +For streaming RPCs, use PostgreSQL LISTEN/NOTIFY: + +```go +// runs/service/run_service.go + +func (s *RunService) WatchRunDetails( + ctx context.Context, + req *connect.Request[workflow.WatchRunDetailsRequest], + stream *connect.ServerStream[workflow.WatchRunDetailsResponse], +) error { + // Get initial state + details, err := s.repo.GetRunDetails(ctx, req.Msg.RunId) + if err != nil { + return err + } + + if err := stream.Send(&workflow.WatchRunDetailsResponse{Details: details}); err != nil { + return err + } + + // Subscribe to updates via PostgreSQL LISTEN + updates := make(chan *workflow.RunDetails) + errs := make(chan error) + + go s.repo.WatchRunDetails(ctx, req.Msg.RunId, updates, errs) + + for { + select { + case <-ctx.Done(): + return nil + case err := <-errs: + return err + case details := <-updates: + if err := stream.Send(&workflow.WatchRunDetailsResponse{Details: details}); err != nil { + return err + } + } + } +} +``` + +```go +// runs/repository/postgres.go + +func (r *PostgresRepository) WatchRunDetails( + ctx context.Context, + runID *common.RunIdentifier, + updates chan<- *workflow.RunDetails, + errs chan<- error, +) { + conn, err := r.pgxPool.Acquire(ctx) + if err != nil { + errs <- err + return + } + defer conn.Release() + + // Listen for notifications + _, err = conn.Exec(ctx, "LISTEN run_updates") + if err != nil { + errs <- err + return + } + + for { + notification, err := conn.Conn().WaitForNotification(ctx) + if err != nil { + errs <- err + return + } + + // Fetch updated run details + details, err := r.GetRunDetails(ctx, runID) + if err != nil { + errs <- err + return + } + + select { + case updates <- details: + case <-ctx.Done(): + return + } + } +} +``` + +--- + +## Testing Strategy + +### Unit Tests +- Repository layer: Mock database using testcontainers with PostgreSQL +- Service layer: Mock repository interface +- Use table-driven tests + +### Integration Tests +- End-to-end tests with real PostgreSQL +- Use docker-compose for local testing +- Test streaming with multiple concurrent clients + +### Example: + +```go +// queue/service/queue_service_test.go + +func TestEnqueueAction(t *testing.T) { + mockRepo := &mocks.Repository{} + svc := service.NewQueueService(mockRepo) + + req := connect.NewRequest(&workflow.EnqueueActionRequest{ + // ... populate request + }) + + mockRepo.On("EnqueueAction", mock.Anything, req.Msg).Return(nil) + + resp, err := svc.EnqueueAction(context.Background(), req) + assert.NoError(t, err) + assert.NotNil(t, resp) +} +``` + +--- + +## Deployment Considerations + +### Configuration Files + +Example `config.yaml`: + +```yaml +database: + postgres: + host: postgres.flyte.svc.cluster.local + port: 5432 + dbname: flyte_queue + username: flyte + passwordPath: /etc/secrets/db-password + extraOptions: "sslmode=require" + maxIdleConnections: 10 + maxOpenConnections: 100 + connMaxLifeTime: 1h + +queue: + server: + host: 0.0.0.0 + port: 8089 + maxQueueSize: 10000 + workerCount: 10 + +runs: + server: + host: 0.0.0.0 + port: 8090 + watchBufferSize: 100 + +state: + server: + host: 0.0.0.0 + port: 8091 + maxStateSizeBytes: 1048576 # 1MB +``` + +### Docker Compose (for local development) + +```yaml +version: '3.8' +services: + postgres: + image: postgres:15 + environment: + POSTGRES_USER: flyte + POSTGRES_PASSWORD: flyte + POSTGRES_DB: flyte + ports: + - "5432:5432" + + queue: + build: . + command: queue --config /etc/flyte/config.yaml + ports: + - "8089:8089" + depends_on: + - postgres + + runs: + build: . + command: runs --config /etc/flyte/config.yaml + ports: + - "8090:8090" + depends_on: + - postgres + + state: + build: . + command: state --config /etc/flyte/config.yaml + ports: + - "8091:8091" + depends_on: + - postgres +``` + +--- + +## Implementation Phases + +### Phase 1: Core Infrastructure +1. Setup project structure +2. Implement database schemas and migrations +3. Implement repository interfaces and PostgreSQL implementations +4. Setup configuration management using flytestdlib + +### Phase 2: Service Implementation +1. Implement QueueService +2. Implement RunService (non-streaming RPCs first) +3. Implement StateService (non-streaming RPCs first) + +### Phase 3: Streaming Support +1. Add PostgreSQL LISTEN/NOTIFY support +2. Implement streaming RPCs (Watch*) +3. Test concurrent streaming clients + +### Phase 4: Integration +1. Implement unified binary command structure +2. Add health checks and metrics +3. Integration testing +4. Documentation + +### Phase 5: Production Readiness +1. Add observability (metrics, tracing, logging) +2. Performance testing and optimization +3. Security audit +4. Deployment documentation + +--- + +## Open Questions + +1. **Migration Strategy**: Should we use golang-migrate, gorm AutoMigrate, or custom SQL scripts? +2. **Protobuf Serialization**: Store protobuf as JSONB or use binary serialization? +3. **Queue Processing**: Should QueueService also include worker implementation for processing queued actions? +4. **Multi-tenancy**: How to handle org/project isolation at the database level? +5. **Metrics**: What metrics should each service expose? +6. **Rate Limiting**: Should services implement rate limiting per org/project? + +--- + +## References + +- Protocol Buffers: [queue_service.proto](flyteidl2/workflow/queue_service.proto), [run_service.proto](flyteidl2/workflow/run_service.proto), [state_service.proto](flyteidl2/workflow/state_service.proto) +- Generated Code: `gen/go/flyteidl2/workflow/workflowconnect/` +- Database Utils: `flytestdlib/database/` +- Config Management: `flytestdlib/config/` +- Buf Connect: https://connectrpc.com/docs/go/getting-started +- PostgreSQL LISTEN/NOTIFY: https://www.postgresql.org/docs/current/sql-notify.html diff --git a/Makefile b/Makefile new file mode 100644 index 0000000000..0ff07449b0 --- /dev/null +++ b/Makefile @@ -0,0 +1,249 @@ +.DEFAULT_GOAL := help + +# Docker CI image configuration +DOCKER_CI_IMAGE := ghcr.io/flyteorg/flyte/ci:v2 + +# Environment variable flags for Docker +DOCKER_ENV_FLAGS := +ifdef GITHUB_TOKEN + DOCKER_ENV_FLAGS += -e GITHUB_TOKEN=$(GITHUB_TOKEN) +endif +ifdef BUF_TOKEN + DOCKER_ENV_FLAGS += -e BUF_TOKEN=$(BUF_TOKEN) +endif + +DOCKER_RUN := docker run --rm -v $(CURDIR):/workspace -w /workspace -e UV_PROJECT_ENVIRONMENT=/tmp/flyte-venv $(DOCKER_ENV_FLAGS) $(DOCKER_CI_IMAGE) + +SEPARATOR := \033[1;36m========================================\033[0m + +# Include common Go targets +include go.Makefile + +.PHONY: help +help: ## Show this help message + @echo '๐Ÿ†˜ Showing help message' + @echo 'Usage: make [target]' + @echo '' + @echo 'Available targets:' + @awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {printf " %-15s %s\n", $$1, $$2}' $(MAKEFILE_LIST) + +.PHONY: sep +sep: + @echo "$(SEPARATOR)" + +# ============================================================================= +# Local Tool Commands (require buf, go, cargo, uv installed locally) +# ============================================================================= + +.PHONY: buf-dep +buf-dep: + @echo '๐Ÿ“ฆ Updating buf modules (local)' + buf dep update + @$(MAKE) sep + +.PHONY: buf-format +buf-format: + @echo 'Running buf format (local)' + buf format -w + @$(MAKE) sep + +.PHONY: buf-lint +buf-lint: + @echo '๐Ÿงน Linting protocol buffer files (local)' + buf lint --exclude-path flytestdlib/ + @$(MAKE) sep + +.PHONY: buf-ts +buf-ts: + @echo '๐ŸŸฆ Generating TypeScript protocol buffer files (local)' + buf generate --clean --template buf.gen.ts.yaml --exclude-path flytestdlib/ + @cp -r flyteidl2/gen_utils/ts/* gen/ts/ + @echo '๐Ÿ“ฆ Installing TypeScript dependencies' + @cd gen/ts && npm install --silent + @echo 'โœ… TypeScript generation complete' + @$(MAKE) sep + +.PHONY: buf-ts-check +buf-ts-check: buf-ts + @echo '๐Ÿ” Type checking generated TypeScript files' + @cd gen/ts && npx tsc --noEmit || (echo 'โš ๏ธ Type checking found issues (non-fatal)' && exit 0) + @echo 'โœ… Type checking complete' + @$(MAKE) sep + +.PHONY: buf-go +buf-go: + @echo '๐ŸŸฉ Generating Go protocol buffer files (local)' + buf generate --clean --template buf.gen.go.yaml --exclude-path flytestdlib/ + @$(MAKE) sep + +.PHONY: buf-rust +buf-rust: + @echo '๐Ÿฆ€ Generating Rust protocol buffer files (local)' + buf generate --clean --template buf.gen.rust.yaml --exclude-path flytestdlib/ + @cp -R flyteidl2/gen_utils/rust/* gen/rust/ + @cd gen/rust && cargo update + @$(MAKE) sep + +export SETUPTOOLS_SCM_PRETEND_VERSION=0.0.0 +.PHONY: buf-python +buf-python: + @echo '๐Ÿ Generating Python protocol buffer files (local)' + buf generate --clean --template buf.gen.python.yaml --exclude-path flytestdlib/ + @cp flyteidl2/gen_utils/python/* gen/python/ + @find gen/python -type d -exec touch {}/__init__.py \; + @cd gen/python && uv lock + @$(MAKE) sep + +.PHONY: buf +buf: buf-dep buf-format buf-lint buf-rust buf-python buf-go buf-ts buf-ts-check + @echo '๐Ÿ› ๏ธ Finished generating all protocol buffer files (local)' + @$(MAKE) sep + +.PHONY: go-tidy +go-tidy: + @echo '๐Ÿงน Running go mod tidy (local)' + @go mod tidy $(OUT_REDIRECT) + @$(MAKE) sep + +.PHONY: mocks +mocks: + @echo "๐Ÿงช Generating go mocks (local)" + mockery $(OUT_REDIRECT) + @$(MAKE) sep + +.PHONY: gen-local +gen-local: buf mocks go-tidy ## Generate everything using local tools (requires buf, go, cargo, uv) + @echo 'โšก Finished generating everything in the gen directory (local)' + @$(MAKE) sep + +.PHONY: build-crate +build-crate: ## Build Rust crate using local cargo + @echo 'Cargo build the generated rust code (local)' + cd gen/rust && cargo build + @$(MAKE) sep + +# ============================================================================= +# Package Dry-Run Commands (validate packages before publishing) +# ============================================================================= + +.PHONY: dry-run-npm +dry-run-npm: ## Dry-run npm package (shows what will be published) + @echo '๐Ÿ“ฆ NPM Package Dry Run' + @echo 'โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€' + @echo '๐Ÿ“„ Package files that will be included:' + @cd gen/ts && npm pack --dry-run 2>&1 | grep -v "npm notice" || true + @echo '' + @echo '๐Ÿ“‹ Package contents (from package.json "files" field):' + @cd gen/ts && cat package.json | grep -A 10 '"files"' + @echo '' + @echo 'โœ… Validation: Running npm pack to create tarball...' + @cd gen/ts && npm pack + @echo '' + @echo '๐Ÿ“ฆ Contents of generated tarball:' + @cd gen/ts && tar -tzf flyteorg-flyteidl2-*.tgz | head -50 + @echo '' + @echo '๐Ÿงน Cleaning up tarball...' + @cd gen/ts && rm -f flyteorg-flyteidl2-*.tgz + @echo 'โœ… NPM dry run complete!' + @$(MAKE) sep + +.PHONY: dry-run-python +dry-run-python: ## Dry-run Python package (shows what will be published) + @echo '๐Ÿ Python Package Dry Run' + @echo 'โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€' + @echo '๐Ÿ“ฆ Cleaning previous builds and venvs...' + @rm -rf .venv + @cd gen/python && rm -rf dist build *.egg-info .venv + @echo '๐Ÿ“ฆ Building Python wheel (using Docker CI image)...' + @docker run --rm -v $(CURDIR):/workspace -w /workspace $(DOCKER_ENV_FLAGS) $(DOCKER_CI_IMAGE) bash -c "cd gen/python && export SETUPTOOLS_SCM_PRETEND_VERSION=0.0.0 && uv venv && uv pip install build twine setuptools wheel && uv run python -m build --wheel --installer uv" + @echo '' + @echo 'โœ… Running twine check for validation...' + @docker run --rm -v $(CURDIR):/workspace -w /workspace $(DOCKER_ENV_FLAGS) $(DOCKER_CI_IMAGE) bash -c "cd gen/python && uv pip install twine && uv run python -m twine check dist/* --strict" + @echo '' + @echo '๐Ÿ“‹ Package metadata (from pyproject.toml):' + @cd gen/python && grep -A 5 "^\[tool.setuptools.packages.find\]" pyproject.toml + @echo '' + @echo '๐Ÿ“ฆ Contents of wheel (first 100 files):' + @cd gen/python && unzip -l dist/*.whl | head -100 + @echo '' + @echo '๐Ÿ“Š Wheel file size:' + @cd gen/python && ls -lh dist/*.whl + @echo '' + @echo '๐Ÿงน Note: build artifacts preserved for inspection in gen/python/' + @echo ' Run: cd gen/python && rm -rf dist/ build/ *.egg-info to clean up' + @echo 'โœ… Python dry run complete!' + @$(MAKE) sep + +.PHONY: dry-run-rust +dry-run-rust: ## Dry-run Rust package (shows what will be published) + @echo '๐Ÿฆ€ Rust Package Dry Run' + @echo 'โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€' + @echo '๐Ÿ“‹ Files that will be included in crate:' + @cd gen/rust && cargo package --list --allow-dirty | head -100 + @echo '' + @echo '๐Ÿ“ฆ Creating package tarball...' + @cd gen/rust && cargo package --allow-dirty + @echo '' + @echo '๐Ÿ“Š Package tarball info:' + @cd gen/rust && ls -lh target/package/flyteidl2-*.crate + @echo '' + @echo '๐Ÿ“ฆ Contents of crate tarball (first 50 files):' + @cd gen/rust && tar -tzf target/package/flyteidl2-*.crate | head -50 + @echo '' + @echo 'โœ… Validation: Running cargo build on packaged crate...' + @cd gen/rust && cargo build --release + @echo '' + @echo '๐Ÿงน Note: target/package/ directory preserved for inspection' + @echo ' Run: rm -rf gen/rust/target/package/ to clean up' + @echo 'โœ… Rust dry run complete!' + @$(MAKE) sep + +.PHONY: dry-run-all +dry-run-all: dry-run-npm dry-run-python dry-run-rust ## Run dry-run for all packages (TypeScript, Python, Rust) + @echo '๐ŸŽ‰ All package dry runs complete!' + @echo '' + @echo 'Summary:' + @echo ' - TypeScript: gen/ts (npm package @flyteorg/flyteidl2)' + @echo ' - Python: gen/python/dist/ (PyPI package flyteidl2)' + @echo ' - Rust: gen/rust/target/package/ (crates.io package flyteidl2)' + @echo '' + @echo 'Clean up artifacts with:' + @echo ' - rm -f gen/ts/*.tgz' + @echo ' - rm -rf gen/python/dist/' + @echo ' - rm -rf gen/rust/target/package/' + @$(MAKE) sep + +# ============================================================================= +# Default Commands (use Docker - no local tools required) +# ============================================================================= + +.PHONY: gen +gen: ## Generate everything (uses Docker - no local tools required) + $(DOCKER_RUN) make gen-local + @echo 'โšก Finished generating everything in the gen directory (Docker)' + @$(MAKE) sep + +# Docker-based development targets +.PHONY: docker-pull +docker-pull: ## Pull the latest CI Docker image + @echo '๐Ÿ“ฆ Pulling latest CI Docker image' + docker pull $(DOCKER_CI_IMAGE) + @$(MAKE) sep + +.PHONY: docker-build +docker-build: ## Build Docker CI image locally (faster iteration) + @echo '๐Ÿ”จ Building Docker CI image locally (fast mode)' + docker build -f gen.Dockerfile -t $(DOCKER_CI_IMAGE) --cache-from $(DOCKER_CI_IMAGE) . + @echo 'โœ… Image built: $(DOCKER_CI_IMAGE)' + @$(MAKE) sep + +.PHONY: docker-shell +docker-shell: ## Start an interactive shell in the CI Docker container + @echo '๐Ÿณ Starting interactive shell in CI container' + docker run --rm -it -v $(CURDIR):/workspace -w /workspace -e UV_PROJECT_ENVIRONMENT=/tmp/flyte-venv $(DOCKER_ENV_FLAGS) $(DOCKER_CI_IMAGE) bash + +# Combined workflow for fast iteration +.PHONY: docker-dev +docker-dev: docker-build gen ## Build local image and run generation (fast iteration) + @echo 'โœ… Local Docker image built and generation complete!' + @$(MAKE) sep diff --git a/README.md b/README.md new file mode 100644 index 0000000000..6822b5a7ca --- /dev/null +++ b/README.md @@ -0,0 +1,163 @@ +# Flyte 2 + +Flyte 2 is a next-generation IDL (Interface Definition Language) repository that defines the protocol buffer schemas for Flyte's APIs. This repository generates client libraries and type definitions for Go, TypeScript, Python, and Rust. + +## Repository Structure + +``` +flyte/ +โ”œโ”€โ”€ flyteidl2/ # Protocol buffer definitions +โ”‚ โ”œโ”€โ”€ common/ # Common types and utilities +โ”‚ โ”œโ”€โ”€ core/ # Core Flyte types (tasks, workflows, literals) +โ”‚ โ”œโ”€โ”€ imagebuilder/ # Image builder service definitions +โ”‚ โ”œโ”€โ”€ logs/ # Logging types +โ”‚ โ”œโ”€โ”€ secret/ # Secret management types +โ”‚ โ”œโ”€โ”€ task/ # Task execution types +โ”‚ โ”œโ”€โ”€ trigger/ # Trigger service definitions +โ”‚ โ”œโ”€โ”€ workflow/ # Workflow types +โ”‚ โ””โ”€โ”€ gen_utils/ # Language-specific generation utilities +โ”œโ”€โ”€ gen/ # Generated code (not checked into version control) +โ”‚ โ”œโ”€โ”€ go/ # Generated Go code +โ”‚ โ”œโ”€โ”€ ts/ # Generated TypeScript code +โ”‚ โ”œโ”€โ”€ python/ # Generated Python code +โ”‚ โ””โ”€โ”€ rust/ # Generated Rust code +โ”œโ”€โ”€ buf.yaml # Buf configuration +โ”œโ”€โ”€ buf.gen.*.yaml # Language-specific generation configs +โ””โ”€โ”€ Makefile # Build automation +``` + +## Prerequisites + +- [Buf CLI](https://buf.build/docs/installation) - Protocol buffer tooling +- Go 1.24.6 or later +- Node.js/npm (for TypeScript generation) +- Python 3.9+ with `uv` package manager (for Python generation) +- Rust toolchain (for Rust generation) + +## Quick Start + +### Generate All Code + +To generate code for all supported languages: + +```bash +make gen +``` + +This will: +1. Update buf dependencies +2. Format and lint proto files +3. Generate code for Go, TypeScript, Python, and Rust +4. Generate mocks for Go +5. Run `go mod tidy` + +### Generate for Specific Languages Locally + +```bash +make buf-go # Generate Go code only +make buf-ts # Generate TypeScript code only +make buf-python # Generate Python code only +make buf-rust # Generate Rust code only +``` + +## Making Changes + +### 1. Modify Protocol Buffers + +Edit `.proto` files in the `flyteidl2/` directory following these guidelines: +- Follow the existing naming conventions +- Use proper protobuf style (snake_case for fields, PascalCase for messages) +- Add appropriate comments and documentation +- Ensure backward compatibility when modifying existing messages + +### 2. Generate Code + +After modifying proto files: + +```bash +make docker-pull # Pull the docker image for generation +make gen +``` + +### 3. Verify Your Changes + +Run the following to ensure everything builds correctly: + +```bash +# For Go +make go-tidy +go build ./... + +# For Rust +make build-crate + +# For Python +cd gen/python && uv lock + +# For TypeScript +cd gen/ts && npm install +``` + +### 4. Generate Mocks (Go only) + +If you've added or modified Go interfaces: + +```bash +make gen +``` + +## Development Workflow + +1. **Format proto files**: `make buf-format` +2. **Lint proto files**: `make buf-lint` +3. **Generate code**: `make buf` or `make gen` +4. **Verify builds**: Build generated code in your target language +5. **Commit changes**: Commit both proto files and generated code + +## Common Tasks + +### Update Buf Dependencies + +```bash +make gen +``` + +### View Available Commands + +```bash +make help +``` + +## Versioning and Releases + +See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed release instructions. + +## Generated Code + +The `gen/` directory contains auto-generated code and should not be manually edited. Changes to generated code should be made by: +1. Modifying the source `.proto` files in `flyteidl2/` +2. Updating generation utilities in `flyteidl2/gen_utils/` if needed +3. Running `make gen` to regenerate all code + +## Troubleshooting + +### Buf Errors +- Ensure you have the latest version of Buf: `buf --version` +- Update dependencies: `make buf-dep` +- Check `buf.lock` for dependency conflicts + +### Go Module Issues +- Run `make go-tidy` to clean up dependencies +- Ensure you're using Go 1.24.6 or later + +### Python Generation Issues +- Ensure `uv` is installed: `pip install uv` +- Set the environment variable: `export SETUPTOOLS_SCM_PRETEND_VERSION=0.0.0` + +### Rust Build Issues +- Update Rust toolchain: `rustup update` +- Navigate to `gen/rust` and run `cargo update` + +## Contributing + +We welcome contributions to Flyte 2! Please follow the guide [here](CONTRIBUTING.md). \ No newline at end of file diff --git a/boilerplate/flyte/code_of_conduct/CODE_OF_CONDUCT.md b/boilerplate/flyte/code_of_conduct/CODE_OF_CONDUCT.md new file mode 100644 index 0000000000..e12139d691 --- /dev/null +++ b/boilerplate/flyte/code_of_conduct/CODE_OF_CONDUCT.md @@ -0,0 +1,2 @@ +This project is governed by LF AI Foundation's [code of conduct](https://lfprojects.org/policies/code-of-conduct/). +All contributors and participants agree to abide by its terms. diff --git a/boilerplate/flyte/code_of_conduct/README.rst b/boilerplate/flyte/code_of_conduct/README.rst new file mode 100644 index 0000000000..0c9f2f1ec5 --- /dev/null +++ b/boilerplate/flyte/code_of_conduct/README.rst @@ -0,0 +1,2 @@ +CODE OF CONDUCT +~~~~~~~~~~~~~~~ diff --git a/boilerplate/flyte/code_of_conduct/update.sh b/boilerplate/flyte/code_of_conduct/update.sh new file mode 100755 index 0000000000..42f6158460 --- /dev/null +++ b/boilerplate/flyte/code_of_conduct/update.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash + +# WARNING: THIS FILE IS MANAGED IN THE 'BOILERPLATE' REPO AND COPIED TO OTHER REPOSITORIES. +# ONLY EDIT THIS FILE FROM WITHIN THE 'FLYTEORG/BOILERPLATE' REPOSITORY: +# +# TO OPT OUT OF UPDATES, SEE https://github.com/flyteorg/boilerplate/blob/master/Readme.rst + +set -e + +DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && pwd )" + +cp ${DIR}/CODE_OF_CONDUCT.md ${DIR}/../../../CODE_OF_CONDUCT.md diff --git a/boilerplate/flyte/docker_build/Makefile b/boilerplate/flyte/docker_build/Makefile new file mode 100644 index 0000000000..e2b2b8a18d --- /dev/null +++ b/boilerplate/flyte/docker_build/Makefile @@ -0,0 +1,12 @@ +# WARNING: THIS FILE IS MANAGED IN THE 'BOILERPLATE' REPO AND COPIED TO OTHER REPOSITORIES. +# ONLY EDIT THIS FILE FROM WITHIN THE 'FLYTEORG/BOILERPLATE' REPOSITORY: +# +# TO OPT OUT OF UPDATES, SEE https://github.com/flyteorg/boilerplate/blob/master/Readme.rst + +.PHONY: docker_build +docker_build: + IMAGE_NAME=$$REPOSITORY ./boilerplate/flyte/docker_build/docker_build.sh + +.PHONY: dockerhub_push +dockerhub_push: + IMAGE_NAME=flyteorg/$$REPOSITORY REGISTRY=docker.io ./boilerplate/flyte/docker_build/docker_build.sh diff --git a/boilerplate/flyte/docker_build/Readme.rst b/boilerplate/flyte/docker_build/Readme.rst new file mode 100644 index 0000000000..7790b8fbfd --- /dev/null +++ b/boilerplate/flyte/docker_build/Readme.rst @@ -0,0 +1,23 @@ +Docker Build and Push +~~~~~~~~~~~~~~~~~~~~~ + +Provides a ``make docker_build`` target that builds your image locally. + +Provides a ``make dockerhub_push`` target that pushes your final image to Dockerhub. + +The Dockerhub image will tagged ``:`` + +If git head has a git tag, the Dockerhub image will also be tagged ``:``. + +**To Enable:** + +Add ``flyteorg/docker_build`` to your ``boilerplate/update.cfg`` file. + +Add ``include boilerplate/flyte/docker_build/Makefile`` in your main ``Makefile`` _after_ your REPOSITORY environment variable + +:: + + REPOSITORY= + include boilerplate/flyte/docker_build/Makefile + +(this ensures the extra Make targets get included in your main Makefile) diff --git a/boilerplate/flyte/docker_build/docker_build.sh b/boilerplate/flyte/docker_build/docker_build.sh new file mode 100755 index 0000000000..817189aee1 --- /dev/null +++ b/boilerplate/flyte/docker_build/docker_build.sh @@ -0,0 +1,67 @@ +#!/usr/bin/env bash + +# WARNING: THIS FILE IS MANAGED IN THE 'BOILERPLATE' REPO AND COPIED TO OTHER REPOSITORIES. +# ONLY EDIT THIS FILE FROM WITHIN THE 'FLYTEORG/BOILERPLATE' REPOSITORY: +# +# TO OPT OUT OF UPDATES, SEE https://github.com/flyteorg/boilerplate/blob/master/Readme.rst + +set -e + +echo "" +echo "------------------------------------" +echo " DOCKER BUILD" +echo "------------------------------------" +echo "" + +if [ -n "$REGISTRY" ]; then + # Do not push if there are unstaged git changes + CHANGED=$(git status --porcelain) + if [ -n "$CHANGED" ]; then + echo "Please commit git changes before pushing to a registry" + exit 1 + fi +fi + + +GIT_SHA=$(git rev-parse HEAD) + +IMAGE_TAG_SUFFIX="" +# for intermediate build phases, append -$BUILD_PHASE to all image tags +if [ -n "$BUILD_PHASE" ]; then + IMAGE_TAG_SUFFIX="-${BUILD_PHASE}" +fi + +IMAGE_TAG_WITH_SHA="${IMAGE_NAME}:${GIT_SHA}${IMAGE_TAG_SUFFIX}" + +RELEASE_SEMVER=$(git describe --tags --exact-match "$GIT_SHA" 2>/dev/null) || true +if [ -n "$RELEASE_SEMVER" ]; then + IMAGE_TAG_WITH_SEMVER="${IMAGE_NAME}:${RELEASE_SEMVER}${IMAGE_TAG_SUFFIX}" +fi + +# build the image +# passing no build phase will build the final image +docker build -t "$IMAGE_TAG_WITH_SHA" --target=${BUILD_PHASE} . +echo "${IMAGE_TAG_WITH_SHA} built locally." + +# if REGISTRY specified, push the images to the remote registry +if [ -n "$REGISTRY" ]; then + + if [ -n "${DOCKER_REGISTRY_PASSWORD}" ]; then + docker login --username="$DOCKER_REGISTRY_USERNAME" --password="$DOCKER_REGISTRY_PASSWORD" + fi + + docker tag "$IMAGE_TAG_WITH_SHA" "${REGISTRY}/${IMAGE_TAG_WITH_SHA}" + + docker push "${REGISTRY}/${IMAGE_TAG_WITH_SHA}" + echo "${REGISTRY}/${IMAGE_TAG_WITH_SHA} pushed to remote." + + # If the current commit has a semver tag, also push the images with the semver tag + if [ -n "$RELEASE_SEMVER" ]; then + + docker tag "$IMAGE_TAG_WITH_SHA" "${REGISTRY}/${IMAGE_TAG_WITH_SEMVER}" + + docker push "${REGISTRY}/${IMAGE_TAG_WITH_SEMVER}" + echo "${REGISTRY}/${IMAGE_TAG_WITH_SEMVER} pushed to remote." + + fi +fi diff --git a/boilerplate/flyte/end2end/Makefile b/boilerplate/flyte/end2end/Makefile new file mode 100644 index 0000000000..983b6e22d9 --- /dev/null +++ b/boilerplate/flyte/end2end/Makefile @@ -0,0 +1,18 @@ +# WARNING: THIS FILE IS MANAGED IN THE 'BOILERPLATE' REPO AND COPIED TO OTHER REPOSITORIES. +# ONLY EDIT THIS FILE FROM WITHIN THE 'FLYTEORG/BOILERPLATE' REPOSITORY: +# +# TO OPT OUT OF UPDATES, SEE https://github.com/flyteorg/boilerplate/blob/master/Readme.rst + +.PHONY: end2end_execute +end2end_execute: export FLYTESNACKS_PRIORITIES ?= P0 +end2end_execute: export FLYTESNACKS_VERSION ?= $(shell curl --silent "https://api.github.com/repos/flyteorg/flytesnacks/releases/latest" | jq -r .tag_name) +end2end_execute: + pytest ./boilerplate/flyte/end2end/test_run.py \ + --flytesnacks_release_tag=$(FLYTESNACKS_VERSION) \ + --priorities=$(FLYTESNACKS_PRIORITIES) \ + --config_file=./boilerplate/flyte/end2end/functional-test-config.yaml \ + --return_non_zero_on_failure + +.PHONY: k8s_integration_execute +k8s_integration_execute: + echo "pass" diff --git a/boilerplate/flyte/end2end/conftest.py b/boilerplate/flyte/end2end/conftest.py new file mode 100644 index 0000000000..d77fad05d9 --- /dev/null +++ b/boilerplate/flyte/end2end/conftest.py @@ -0,0 +1,47 @@ +import pytest + +def pytest_addoption(parser): + parser.addoption("--flytesnacks_release_tag", required=True) + parser.addoption("--priorities", required=True) + parser.addoption("--config_file", required=True) + parser.addoption( + "--return_non_zero_on_failure", + action="store_true", + default=False, + help="Return a non-zero exit status if any workflow fails", + ) + parser.addoption( + "--terminate_workflow_on_failure", + action="store_true", + default=False, + help="Abort failing workflows upon exit", + ) + parser.addoption( + "--test_project_name", + default="flytesnacks", + help="Name of project to run functional tests on" + ) + parser.addoption( + "--test_project_domain", + default="development", + help="Name of domain in project to run functional tests on" + ) + parser.addoption( + "--cluster_pool_name", + required=False, + type=str, + default=None, + ) + +@pytest.fixture +def setup_flytesnacks_env(pytestconfig): + return { + "flytesnacks_release_tag": pytestconfig.getoption("--flytesnacks_release_tag"), + "priorities": pytestconfig.getoption("--priorities"), + "config_file": pytestconfig.getoption("--config_file"), + "return_non_zero_on_failure": pytestconfig.getoption("--return_non_zero_on_failure"), + "terminate_workflow_on_failure": pytestconfig.getoption("--terminate_workflow_on_failure"), + "test_project_name": pytestconfig.getoption("--test_project_name"), + "test_project_domain": pytestconfig.getoption("--test_project_domain"), + "cluster_pool_name": pytestconfig.getoption("--cluster_pool_name"), + } diff --git a/boilerplate/flyte/end2end/functional-test-config.yaml b/boilerplate/flyte/end2end/functional-test-config.yaml new file mode 100644 index 0000000000..13fc445675 --- /dev/null +++ b/boilerplate/flyte/end2end/functional-test-config.yaml @@ -0,0 +1,5 @@ +admin: + # For GRPC endpoints you might want to use dns:///flyte.myexample.com + endpoint: dns:///localhost:30080 + authType: Pkce + insecure: true diff --git a/boilerplate/flyte/end2end/test_run.py b/boilerplate/flyte/end2end/test_run.py new file mode 100644 index 0000000000..b300ee974a --- /dev/null +++ b/boilerplate/flyte/end2end/test_run.py @@ -0,0 +1,217 @@ +#!/usr/bin/env python3 +import json +import sys +import time +import traceback +from typing import Dict, List, Optional + +import pytest +import requests +from flytekit.configuration import Config +from flytekit.models.core.execution import WorkflowExecutionPhase +from flytekit.remote import FlyteRemote +from flytekit.remote.executions import FlyteWorkflowExecution + +WAIT_TIME = 10 +MAX_ATTEMPTS = 200 + +def execute_workflow( + remote: FlyteRemote, + version, + workflow_name, + inputs, + cluster_pool_name: Optional[str] = None, +): + print(f"Fetching workflow={workflow_name} and version={version}") + wf = remote.fetch_workflow(name=workflow_name, version=version) + return remote.execute(wf, inputs=inputs, wait=False, cluster_pool=cluster_pool_name) + +def executions_finished( + executions_by_wfgroup: Dict[str, List[FlyteWorkflowExecution]] +) -> bool: + for executions in executions_by_wfgroup.values(): + if not all([execution.is_done for execution in executions]): + return False + return True + +def sync_executions( + remote: FlyteRemote, executions_by_wfgroup: Dict[str, List[FlyteWorkflowExecution]] +): + try: + for executions in executions_by_wfgroup.values(): + for execution in executions: + print(f"About to sync execution_id={execution.id.name}") + remote.sync(execution) + except Exception: + print(traceback.format_exc()) + print("GOT TO THE EXCEPT") + print("COUNT THIS!") + +def report_executions(executions_by_wfgroup: Dict[str, List[FlyteWorkflowExecution]]): + for executions in executions_by_wfgroup.values(): + for execution in executions: + print(execution) + +def schedule_workflow_groups( + tag: str, + workflow_groups: List[str], + remote: FlyteRemote, + terminate_workflow_on_failure: bool, + parsed_manifest: List[dict], + cluster_pool_name: Optional[str] = None, +) -> Dict[str, bool]: + executions_by_wfgroup = {} + # Schedule executions for each workflow group, + for wf_group in workflow_groups: + workflow_group_item = list( + filter(lambda item: item["name"] == wf_group, parsed_manifest) + ) + if not workflow_group_item: + continue + workflows = workflow_group_item[0].get("examples") + if not workflows: + continue + executions_by_wfgroup[wf_group] = [ + execute_workflow(remote, tag, workflow[0], workflow[1], cluster_pool_name) + for workflow in workflows + ] + + # Wait for all executions to finish + attempt = 0 + while attempt == 0 or ( + not executions_finished(executions_by_wfgroup) and attempt < MAX_ATTEMPTS + ): + attempt += 1 + print( + f"Not all executions finished yet. Sleeping for some time, will check again in {WAIT_TIME}s" + ) + time.sleep(WAIT_TIME) + sync_executions(remote, executions_by_wfgroup) + + report_executions(executions_by_wfgroup) + + results = {} + for wf_group, executions in executions_by_wfgroup.items(): + non_succeeded_executions = [] + for execution in executions: + if execution.closure.phase != WorkflowExecutionPhase.SUCCEEDED: + non_succeeded_executions.append(execution) + # Report failing cases + if len(non_succeeded_executions) != 0: + print(f"Failed executions for {wf_group}:") + for execution in non_succeeded_executions: + print( + f" workflow={execution.spec.launch_plan.name}, execution_id={execution.id.name}" + ) + if terminate_workflow_on_failure: + remote.terminate( + execution, "aborting execution scheduled in functional test" + ) + # A workflow group succeeds iff all of its executions succeed + results[wf_group] = len(non_succeeded_executions) == 0 + return results + +def valid(workflow_group, parsed_manifest): + """ + Return True if a workflow group is contained in parsed_manifest, + False otherwise. + """ + return workflow_group in set(wf_group["name"] for wf_group in parsed_manifest) + +def test_run(setup_flytesnacks_env): + + env = setup_flytesnacks_env + + flytesnacks_release_tag = env["flytesnacks_release_tag"] + priorities = env["priorities"] + config_file_path = env["config_file"] + terminate_workflow_on_failure = env["terminate_workflow_on_failure"] + test_project_name = env["test_project_name"] + test_project_domain = env["test_project_domain"] + cluster_pool_name = env["cluster_pool_name"] + return_non_zero_on_failure = env["return_non_zero_on_failure"] + + remote = FlyteRemote( + Config.auto(config_file=config_file_path), + test_project_name, + test_project_domain, + ) + + # For a given release tag and priority, this function filters the workflow groups from the flytesnacks + # manifest file. For example, for the release tag "v0.2.224" and the priority "P0" it returns [ "core" ]. + manifest_url = ( + "https://raw.githubusercontent.com/flyteorg/flytesnacks/" + f"{flytesnacks_release_tag}/flyte_tests_manifest.json" + ) + r = requests.get(manifest_url) + parsed_manifest = r.json() + workflow_groups = [] + workflow_groups = ( + ["lite"] + if "lite" in priorities + else [ + group["name"] + for group in parsed_manifest + if group["priority"] in priorities + ] + ) + + results = [] + valid_workgroups = [] + for workflow_group in workflow_groups: + if not valid(workflow_group, parsed_manifest): + results.append( + { + "label": workflow_group, + "status": "coming soon", + "color": "grey", + } + ) + continue + valid_workgroups.append(workflow_group) + + results_by_wfgroup = schedule_workflow_groups( + flytesnacks_release_tag, + valid_workgroups, + remote, + terminate_workflow_on_failure, + parsed_manifest, + cluster_pool_name, + ) + + for workflow_group, succeeded in results_by_wfgroup.items(): + if succeeded: + background_color = "green" + status = "passing" + else: + background_color = "red" + status = "failing" + + # Workflow groups can be only in one of three states: + # 1. passing: this indicates all the workflow executions for that workflow group + # executed successfully + # 2. failing: this state indicates that at least one execution failed in that + # workflow group + # 3. coming soon: this state is used to indicate that the workflow group was not + # implemented yet. + # + # Each state has a corresponding status and color to be used in the badge for that + # workflow group. + result = { + "label": workflow_group, + "status": status, + "color": background_color, + } + results.append(result) + + print(f"Result of run:\n{json.dumps(results)}") + + if return_non_zero_on_failure: + fail_results = [result for result in results if result["status"] not in ("passing", "coming soon")] + if fail_results: + fail_msgs = [ + f"Workflow '{r['label']}' failed with status '{r['status']}'" for r in fail_results + ] + pytest.fail("\n".join(fail_msgs)) + + assert results == [{"label": "core", "status": "passing", "color": "green"}] diff --git a/boilerplate/flyte/flyte_golang_compile/Readme.rst b/boilerplate/flyte/flyte_golang_compile/Readme.rst new file mode 100644 index 0000000000..e6b56dd16e --- /dev/null +++ b/boilerplate/flyte/flyte_golang_compile/Readme.rst @@ -0,0 +1,16 @@ +Flyte Golang Compile +~~~~~~~~~~~~~~~~~~~~ + +Common compile script for Flyte golang services. + +**To Enable:** + +Add ``flyteorg/flyte_golang_compile`` to your ``boilerplate/update.cfg`` file. + +Add the following to your Makefile + +:: + + .PHONY: compile_linux + compile_linux: + PACKAGES={{ *your packages }} OUTPUT={{ /path/to/output }} ./boilerplate/flyte/flyte_golang_compile.sh diff --git a/boilerplate/flyte/flyte_golang_compile/flyte_golang_compile.Template b/boilerplate/flyte/flyte_golang_compile/flyte_golang_compile.Template new file mode 100644 index 0000000000..f587e971be --- /dev/null +++ b/boilerplate/flyte/flyte_golang_compile/flyte_golang_compile.Template @@ -0,0 +1,26 @@ +# WARNING: THIS FILE IS MANAGED IN THE 'BOILERPLATE' REPO AND COPIED TO OTHER REPOSITORIES. +# ONLY EDIT THIS FILE FROM WITHIN THE 'FLYTEORG/BOILERPLATE' REPOSITORY: +# +# TO OPT OUT OF UPDATES, SEE https://github.com/flyteorg/boilerplate/blob/master/Readme.rst + +if [ -z "$PACKAGES" ]; then + echo "PACKAGES environment VAR not set" + exit 1 +fi + +if [ -z "$OUTPUT" ]; then + echo "OUTPUT environment VAR not set" + exit 1 +fi + +# get the GIT_SHA and RELEASE_SEMVER + +GIT_SHA=$(git rev-parse HEAD) +RELEASE_SEMVER=$(git describe --tags --exact-match $GIT_SHA 2>/dev/null) + +CURRENT_PKG=github.com/flyteorg/{{ REPOSITORY }} +VERSION_PKG="${CURRENT_PKG}/vendor/github.com/flyteorg/flytestdlib" + +LDFLAGS="-X ${VERSION_PKG}/version.Build=${GIT_SHA} -X ${VERSION_PKG}/version.Version=${RELEASE_SEMVER}" + +GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -ldflags "$LDFLAGS" -o "$OUTPUT" "$PACKAGES" diff --git a/boilerplate/flyte/flyte_golang_compile/update.sh b/boilerplate/flyte/flyte_golang_compile/update.sh new file mode 100755 index 0000000000..b1e6101c2b --- /dev/null +++ b/boilerplate/flyte/flyte_golang_compile/update.sh @@ -0,0 +1,13 @@ +#!/usr/bin/env bash + +# WARNING: THIS FILE IS MANAGED IN THE 'BOILERPLATE' REPO AND COPIED TO OTHER REPOSITORIES. +# ONLY EDIT THIS FILE FROM WITHIN THE 'FLYTEORG/BOILERPLATE' REPOSITORY: +# +# TO OPT OUT OF UPDATES, SEE https://github.com/flyteorg/boilerplate/blob/master/Readme.rst + +set -e + +DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && pwd )" + +echo " - generating ${DIR}/flyte_golang_compile.sh" +sed -e "s/{{REPOSITORY}}/${REPOSITORY}/g" ${DIR}/flyte_golang_compile.Template > ${DIR}/flyte_golang_compile.sh diff --git a/boilerplate/flyte/github_workflows/Readme.rst b/boilerplate/flyte/github_workflows/Readme.rst new file mode 100644 index 0000000000..f236923514 --- /dev/null +++ b/boilerplate/flyte/github_workflows/Readme.rst @@ -0,0 +1,22 @@ +Golang Github Actions +~~~~~~~~~~~~~~~~~ + +Provides a two github actions workflows. + +**To Enable:** + +Add ``flyteorg/github_workflows`` to your ``boilerplate/update.cfg`` file. + +Add a github secret ``package_name`` with the name to use for publishing (e.g. ``flytepropeller``). Typically, this will be the same name as the repository. + +*Note*: If you are working on a fork, include that prefix in your package name (``myfork/flytepropeller``). + +The actions will push to 2 repos: + + 1. ``docker.pkg.github.com/flyteorg//`` + 2. ``docker.pkg.github.com/flyteorg//-stages`` : this repo is used to cache build stages to speed up iterative builds after. + +There are two workflows that get deployed: + + 1. A workflow that runs on Pull Requests to build and push images to github registry tagged with the commit sha. + 2. A workflow that runs on master merges that bump the patch version of release tag, builds and pushes images to github registry tagged with the version, commit sha as well as "latest" diff --git a/boilerplate/flyte/github_workflows/boilerplate_automation.yml b/boilerplate/flyte/github_workflows/boilerplate_automation.yml new file mode 100644 index 0000000000..4e586a2e7e --- /dev/null +++ b/boilerplate/flyte/github_workflows/boilerplate_automation.yml @@ -0,0 +1,36 @@ +name: Update Boilerplate Automation +on: + workflow_dispatch: +jobs: + update-boilerplate: + name: Update Boilerplate + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: "0" + - name: Update Boilerplate + run: | + make update_boilerplate + - name: Create Pull Request + id: cpr + uses: peter-evans/create-pull-request@v3 + with: + token: ${{ secrets.FLYTE_BOT_PAT }} + commit-message: Update Boilerplate + committer: Flyte-Bot + author: ${{ github.actor }} <${{ github.actor }}@users.noreply.github.com> + signoff: true + branch: flyte-bot-update-boilerplate + delete-branch: true + title: 'Update Boilerplate' + body: | + Update Boilerplate + - Auto-generated by [flyte-bot] + labels: | + boilerplate + team-reviewers: | + owners + maintainers + draft: false + diff --git a/boilerplate/flyte/github_workflows/master.yml b/boilerplate/flyte/github_workflows/master.yml new file mode 100644 index 0000000000..8007b291d0 --- /dev/null +++ b/boilerplate/flyte/github_workflows/master.yml @@ -0,0 +1,31 @@ +name: Master + +on: + push: + branches: + - master + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: '0' + - name: Bump version and push tag + id: bump-version + uses: anothrNick/github-tag-action@1.17.2 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + WITH_V: true + DEFAULT_BUMP: patch + - name: Push Docker Image to Github Registry + uses: whoan/docker-build-with-cache-action@v5 + with: + username: "${{ github.actor }}" + password: "${{ secrets.GITHUB_TOKEN }}" + image_name: ${{ secrets.package_name }} + image_tag: latest,${{ github.sha }},${{ steps.bump-version.outputs.tag }} + push_git_tag: true + registry: docker.pkg.github.com + build_extra_args: "--compress=true" diff --git a/boilerplate/flyte/github_workflows/pull_request.yml b/boilerplate/flyte/github_workflows/pull_request.yml new file mode 100644 index 0000000000..f4e9a5252a --- /dev/null +++ b/boilerplate/flyte/github_workflows/pull_request.yml @@ -0,0 +1,19 @@ +name: Pull Request + +on: + pull_request + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Push Docker Image to Github Registry + uses: whoan/docker-build-with-cache-action@v5 + with: + username: "${{ github.actor }}" + password: "${{ secrets.GITHUB_TOKEN }}" + image_name: ${{ secrets.package_name }} + image_tag: ${{ github.sha }} + push_git_tag: true + registry: docker.pkg.github.com diff --git a/boilerplate/flyte/github_workflows/stale.yml b/boilerplate/flyte/github_workflows/stale.yml new file mode 100644 index 0000000000..385321acb9 --- /dev/null +++ b/boilerplate/flyte/github_workflows/stale.yml @@ -0,0 +1,61 @@ +# Configuration for probot-stale - https://github.com/probot/stale + +# Number of days of inactivity before an Issue or Pull Request becomes stale +daysUntilStale: 120 + +# Number of days of inactivity before an Issue or Pull Request with the stale label is closed. +# Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale. +daysUntilClose: 7 + +# Only issues or pull requests with all of these labels are check if stale. Defaults to `[]` (disabled) +onlyLabels: [] + +# Issues or Pull Requests with these labels will never be considered stale. Set to `[]` to disable +exemptLabels: + - pinned + - security + - "[Status] Maybe Later" + +# Set to true to ignore issues in a project (defaults to false) +exemptProjects: false + +# Set to true to ignore issues in a milestone (defaults to false) +exemptMilestones: false + +# Set to true to ignore issues with an assignee (defaults to false) +exemptAssignees: false + +# Label to use when marking as stale +staleLabel: wontfix + +# Comment to post when marking as stale. Set to `false` to disable +markComment: > + This issue/pullrequest has been automatically marked as stale because it has not had + recent activity. It will be closed if no further activity occurs. Thank you + for your contributions. + +# Comment to post when removing the stale label. +# unmarkComment: > +# Your comment here. + +# Comment to post when closing a stale Issue or Pull Request. +# closeComment: > +# Your comment here. + +# Limit the number of actions per hour, from 1-30. Default is 30 +limitPerRun: 30 + +# Limit to only `issues` or `pulls` +only: pulls + +# Optionally, specify configuration settings that are specific to just 'issues' or 'pulls': +# pulls: +# daysUntilStale: 30 +# markComment: > +# This pull request has been automatically marked as stale because it has not had +# recent activity. It will be closed if no further activity occurs. Thank you +# for your contributions. + +# issues: +# exemptLabels: +# - confirmed \ No newline at end of file diff --git a/boilerplate/flyte/github_workflows/update.sh b/boilerplate/flyte/github_workflows/update.sh new file mode 100755 index 0000000000..15c3cb18e2 --- /dev/null +++ b/boilerplate/flyte/github_workflows/update.sh @@ -0,0 +1,17 @@ +#!/usr/bin/env bash + +# WARNING: THIS FILE IS MANAGED IN THE 'BOILERPLATE' REPO AND COPIED TO OTHER REPOSITORIES. +# ONLY EDIT THIS FILE FROM WITHIN THE 'FLYTEORG/BOILERPLATE' REPOSITORY: +# +# TO OPT OUT OF UPDATES, SEE https://github.com/flyteorg/boilerplate/blob/master/Readme.rst + +set -e + +DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && pwd )" + +mkdir -p ${DIR}/../../../.github/workflows + +echo " - generating github action workflows in root directory." +sed -e "s/{{REPOSITORY}}/${REPOSITORY}/g" ${DIR}/master.yml > ${DIR}/../../../.github/workflows/master.yml +sed -e "s/{{REPOSITORY}}/${REPOSITORY}/g" ${DIR}/pull_request.yml > ${DIR}/../../../.github/workflows/pull_request.yml +cp ${DIR}/stale.yml ${DIR}/../../../.github/stale.yml diff --git a/boilerplate/flyte/golang_support_tools/go.mod b/boilerplate/flyte/golang_support_tools/go.mod new file mode 100644 index 0000000000..0a7582b7ca --- /dev/null +++ b/boilerplate/flyte/golang_support_tools/go.mod @@ -0,0 +1,284 @@ +module github.com/flyteorg/boilerplate + +go 1.23.0 + +require ( + github.com/alvaroloes/enumer v1.1.2 + github.com/flyteorg/flyte/flytestdlib v1.11.0 + github.com/golangci/golangci-lint v1.61.0 + github.com/pseudomuto/protoc-gen-doc v1.4.1 + github.com/vektra/mockery/v2 v2.52.1 +) + +require ( + 4d63.com/gocheckcompilerdirectives v1.2.1 // indirect + 4d63.com/gochecknoglobals v0.2.1 // indirect + cloud.google.com/go v0.115.1 // indirect + cloud.google.com/go/auth v0.9.3 // indirect + cloud.google.com/go/auth/oauth2adapt v0.2.4 // indirect + cloud.google.com/go/compute/metadata v0.5.0 // indirect + cloud.google.com/go/iam v1.2.0 // indirect + cloud.google.com/go/storage v1.43.0 // indirect + github.com/4meepo/tagalign v1.3.4 // indirect + github.com/Abirdcfly/dupword v0.1.1 // indirect + github.com/Antonboom/errname v0.1.13 // indirect + github.com/Antonboom/nilnil v0.1.9 // indirect + github.com/Antonboom/testifylint v1.4.3 // indirect + github.com/Azure/azure-sdk-for-go/sdk/azcore v1.13.0 // indirect + github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.7.0 // indirect + github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0 // indirect + github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.4.0 // indirect + github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2 // indirect + github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c // indirect + github.com/Crocmagnon/fatcontext v0.5.2 // indirect + github.com/Djarvur/go-err113 v0.0.0-20210108212216-aea10b59be24 // indirect + github.com/GaijinEntertainment/go-exhaustruct/v3 v3.3.0 // indirect + github.com/Masterminds/semver v1.5.0 // indirect + github.com/Masterminds/semver/v3 v3.3.0 // indirect + github.com/Masterminds/sprig v2.15.0+incompatible // indirect + github.com/OpenPeeDeeP/depguard/v2 v2.2.0 // indirect + github.com/alecthomas/go-check-sumtype v0.1.4 // indirect + github.com/alexkohler/nakedret/v2 v2.0.4 // indirect + github.com/alexkohler/prealloc v1.0.0 // indirect + github.com/alingse/asasalint v0.0.11 // indirect + github.com/aokoli/goutils v1.0.1 // indirect + github.com/ashanbrown/forbidigo v1.6.0 // indirect + github.com/ashanbrown/makezero v1.1.1 // indirect + github.com/aws/aws-sdk-go v1.44.2 // indirect + github.com/beorn7/perks v1.0.1 // indirect + github.com/bkielbasa/cyclop v1.2.1 // indirect + github.com/blizzy78/varnamelen v0.8.0 // indirect + github.com/bombsimon/wsl/v4 v4.4.1 // indirect + github.com/breml/bidichk v0.2.7 // indirect + github.com/breml/errchkjson v0.3.6 // indirect + github.com/butuzov/ireturn v0.3.0 // indirect + github.com/butuzov/mirror v1.2.0 // indirect + github.com/catenacyber/perfsprint v0.7.1 // indirect + github.com/ccojocar/zxcvbn-go v1.0.2 // indirect + github.com/cespare/xxhash v1.1.0 // indirect + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/charithe/durationcheck v0.0.10 // indirect + github.com/chavacava/garif v0.1.0 // indirect + github.com/chigopher/pathlib v0.19.1 // indirect + github.com/ckaznocha/intrange v0.2.0 // indirect + github.com/coocood/freecache v1.1.1 // indirect + github.com/curioswitch/go-reassign v0.2.0 // indirect + github.com/daixiang0/gci v0.13.5 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/denis-tingaikin/go-header v0.5.0 // indirect + github.com/emicklei/go-restful/v3 v3.9.0 // indirect + github.com/envoyproxy/protoc-gen-validate v1.0.4 // indirect + github.com/ernesto-jimenez/gogen v0.0.0-20180125220232-d7d4131e6607 // indirect + github.com/ettle/strcase v0.2.0 // indirect + github.com/evanphx/json-patch/v5 v5.6.0 // indirect + github.com/fatih/color v1.17.0 // indirect + github.com/fatih/structtag v1.2.0 // indirect + github.com/felixge/httpsnoop v1.0.4 // indirect + github.com/firefart/nonamedreturns v1.0.5 // indirect + github.com/flyteorg/stow v0.3.12 // indirect + github.com/fsnotify/fsnotify v1.6.0 // indirect + github.com/fzipp/gocyclo v0.6.0 // indirect + github.com/ghodss/yaml v1.0.0 // indirect + github.com/ghostiam/protogetter v0.3.6 // indirect + github.com/go-critic/go-critic v0.11.4 // indirect + github.com/go-logr/logr v1.4.2 // indirect + github.com/go-logr/stdr v1.2.2 // indirect + github.com/go-openapi/jsonpointer v0.19.6 // indirect + github.com/go-openapi/jsonreference v0.20.2 // indirect + github.com/go-openapi/swag v0.22.3 // indirect + github.com/go-toolsmith/astcast v1.1.0 // indirect + github.com/go-toolsmith/astcopy v1.1.0 // indirect + github.com/go-toolsmith/astequal v1.2.0 // indirect + github.com/go-toolsmith/astfmt v1.1.0 // indirect + github.com/go-toolsmith/astp v1.1.0 // indirect + github.com/go-toolsmith/strparse v1.1.0 // indirect + github.com/go-toolsmith/typep v1.1.0 // indirect + github.com/go-viper/mapstructure/v2 v2.4.0 // indirect + github.com/go-xmlfmt/xmlfmt v1.1.2 // indirect + github.com/gobwas/glob v0.2.3 // indirect + github.com/gofrs/flock v0.12.1 // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/golang-jwt/jwt/v5 v5.2.2 // indirect + github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect + github.com/golang/protobuf v1.5.4 // indirect + github.com/golangci/dupl v0.0.0-20180902072040-3e9179ac440a // indirect + github.com/golangci/gofmt v0.0.0-20240816233607-d8596aa466a9 // indirect + github.com/golangci/misspell v0.6.0 // indirect + github.com/golangci/modinfo v0.3.4 // indirect + github.com/golangci/plugin-module-register v0.1.1 // indirect + github.com/golangci/revgrep v0.5.3 // indirect + github.com/golangci/unconvert v0.0.0-20240309020433-c5143eacb3ed // indirect + github.com/google/gnostic-models v0.6.8 // indirect + github.com/google/go-cmp v0.6.0 // indirect + github.com/google/gofuzz v1.2.0 // indirect + github.com/google/s2a-go v0.1.8 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/googleapis/enterprise-certificate-proxy v0.3.3 // indirect + github.com/googleapis/gax-go/v2 v2.13.0 // indirect + github.com/gordonklaus/ineffassign v0.1.0 // indirect + github.com/gostaticanalysis/analysisutil v0.7.1 // indirect + github.com/gostaticanalysis/comment v1.4.2 // indirect + github.com/gostaticanalysis/forcetypeassert v0.1.0 // indirect + github.com/gostaticanalysis/nilerr v0.1.1 // indirect + github.com/hashicorp/go-version v1.7.0 // indirect + github.com/hashicorp/hcl v1.0.0 // indirect + github.com/hexops/gotextdiff v1.0.3 // indirect + github.com/huandu/xstrings v1.4.0 // indirect + github.com/iancoleman/strcase v0.3.0 // indirect + github.com/imdario/mergo v0.3.6 // indirect + github.com/inconshreveable/mousetrap v1.1.0 // indirect + github.com/jgautheron/goconst v1.7.1 // indirect + github.com/jingyugao/rowserrcheck v1.1.1 // indirect + github.com/jinzhu/copier v0.3.5 // indirect + github.com/jirfag/go-printf-func-name v0.0.0-20200119135958-7558a9eaa5af // indirect + github.com/jjti/go-spancheck v0.6.2 // indirect + github.com/jmespath/go-jmespath v0.4.0 // indirect + github.com/josharian/intern v1.0.0 // indirect + github.com/json-iterator/go v1.1.12 // indirect + github.com/julz/importas v0.1.0 // indirect + github.com/karamaru-alpha/copyloopvar v1.1.0 // indirect + github.com/kisielk/errcheck v1.7.0 // indirect + github.com/kkHAIKE/contextcheck v1.1.5 // indirect + github.com/kulti/thelper v0.6.3 // indirect + github.com/kunwardeep/paralleltest v1.0.10 // indirect + github.com/kylelemons/godebug v1.1.0 // indirect + github.com/kyoh86/exportloopref v0.1.11 // indirect + github.com/lasiar/canonicalheader v1.1.1 // indirect + github.com/ldez/gomoddirectives v0.2.4 // indirect + github.com/ldez/tagliatelle v0.5.0 // indirect + github.com/leonklingele/grouper v1.1.2 // indirect + github.com/lufeee/execinquery v1.2.1 // indirect + github.com/macabu/inamedparam v0.1.3 // indirect + github.com/magiconair/properties v1.8.7 // indirect + github.com/mailru/easyjson v0.7.7 // indirect + github.com/maratori/testableexamples v1.0.0 // indirect + github.com/maratori/testpackage v1.1.1 // indirect + github.com/matoous/godox v0.0.0-20230222163458-006bad1f9d26 // indirect + github.com/mattn/go-colorable v0.1.13 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mattn/go-runewidth v0.0.9 // indirect + github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect + github.com/mgechev/revive v1.3.9 // indirect + github.com/mitchellh/go-homedir v1.1.0 // indirect + github.com/mitchellh/mapstructure v1.5.0 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/moricho/tparallel v0.3.2 // indirect + github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect + github.com/mwitkow/go-proto-validators v0.0.0-20180403085117-0950a7990007 // indirect + github.com/nakabonne/nestif v0.3.1 // indirect + github.com/ncw/swift v1.0.53 // indirect + github.com/nishanths/exhaustive v0.12.0 // indirect + github.com/nishanths/predeclared v0.2.2 // indirect + github.com/nunnatsa/ginkgolinter v0.16.2 // indirect + github.com/olekukonko/tablewriter v0.0.5 // indirect + github.com/pascaldekloe/name v0.0.0-20180628100202-0fd16699aae1 // indirect + github.com/pelletier/go-toml/v2 v2.2.3 // indirect + github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/polyfloyd/go-errorlint v1.6.0 // indirect + github.com/prometheus/client_golang v1.16.0 // indirect + github.com/prometheus/client_model v0.4.0 // indirect + github.com/prometheus/common v0.44.0 // indirect + github.com/prometheus/procfs v0.10.1 // indirect + github.com/pseudomuto/protokit v0.2.0 // indirect + github.com/quasilyte/go-ruleguard v0.4.3-0.20240823090925-0fe6f58b47b1 // indirect + github.com/quasilyte/go-ruleguard/dsl v0.3.22 // indirect + github.com/quasilyte/gogrep v0.5.0 // indirect + github.com/quasilyte/regex/syntax v0.0.0-20210819130434-b3f0c404a727 // indirect + github.com/quasilyte/stdinfo v0.0.0-20220114132959-f7386bf02567 // indirect + github.com/rs/zerolog v1.33.0 // indirect + github.com/ryancurrah/gomodguard v1.3.5 // indirect + github.com/ryanrolds/sqlclosecheck v0.5.1 // indirect + github.com/sanposhiho/wastedassign/v2 v2.0.7 // indirect + github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 // indirect + github.com/sashamelentyev/interfacebloat v1.1.0 // indirect + github.com/sashamelentyev/usestdlibvars v1.27.0 // indirect + github.com/securego/gosec/v2 v2.21.2 // indirect + github.com/shazow/go-diff v0.0.0-20160112020656-b6b7b6733b8c // indirect + github.com/sirupsen/logrus v1.9.3 // indirect + github.com/sivchari/containedctx v1.0.3 // indirect + github.com/sivchari/tenv v1.10.0 // indirect + github.com/sonatard/noctx v0.0.2 // indirect + github.com/sourcegraph/go-diff v0.7.0 // indirect + github.com/spf13/afero v1.11.0 // indirect + github.com/spf13/cast v1.5.0 // indirect + github.com/spf13/cobra v1.8.1 // indirect + github.com/spf13/jwalterweatherman v1.1.0 // indirect + github.com/spf13/pflag v1.0.5 // indirect + github.com/spf13/viper v1.15.0 // indirect + github.com/ssgreg/nlreturn/v2 v2.2.1 // indirect + github.com/stbenjam/no-sprintf-host-port v0.1.1 // indirect + github.com/stretchr/objx v0.5.2 // indirect + github.com/stretchr/testify v1.9.0 // indirect + github.com/subosito/gotenv v1.4.2 // indirect + github.com/tdakkota/asciicheck v0.2.0 // indirect + github.com/tetafro/godot v1.4.17 // indirect + github.com/timakin/bodyclose v0.0.0-20230421092635-574207250966 // indirect + github.com/timonwong/loggercheck v0.9.4 // indirect + github.com/tomarrell/wrapcheck/v2 v2.9.0 // indirect + github.com/tommy-muehle/go-mnd/v2 v2.5.1 // indirect + github.com/ultraware/funlen v0.1.0 // indirect + github.com/ultraware/whitespace v0.1.1 // indirect + github.com/uudashr/gocognit v1.1.3 // indirect + github.com/xen0n/gosmopolitan v1.2.2 // indirect + github.com/yagipy/maintidx v1.0.0 // indirect + github.com/yeya24/promlinter v0.3.0 // indirect + github.com/ykadowak/zerologlint v0.1.5 // indirect + gitlab.com/bosi/decorder v0.4.2 // indirect + go-simpler.org/musttag v0.12.2 // indirect + go-simpler.org/sloglint v0.7.2 // indirect + go.opencensus.io v0.24.0 // indirect + go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.54.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0 // indirect + go.opentelemetry.io/otel v1.29.0 // indirect + go.opentelemetry.io/otel/exporters/jaeger v1.17.0 // indirect + go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.19.0 // indirect + go.opentelemetry.io/otel/metric v1.29.0 // indirect + go.opentelemetry.io/otel/sdk v1.28.0 // indirect + go.opentelemetry.io/otel/trace v1.29.0 // indirect + go.uber.org/automaxprocs v1.5.3 // indirect + go.uber.org/multierr v1.11.0 // indirect + go.uber.org/zap v1.25.0 // indirect + golang.org/x/crypto v0.36.0 // indirect + golang.org/x/exp v0.0.0-20240904232852-e7e105dedf7e // indirect + golang.org/x/exp/typeparams v0.0.0-20240314144324-c7f7c6466f7f // indirect + golang.org/x/mod v0.21.0 // indirect + golang.org/x/net v0.38.0 // indirect + golang.org/x/oauth2 v0.27.0 // indirect + golang.org/x/sync v0.12.0 // indirect + golang.org/x/sys v0.31.0 // indirect + golang.org/x/term v0.30.0 // indirect + golang.org/x/text v0.23.0 // indirect + golang.org/x/time v0.6.0 // indirect + golang.org/x/tools v0.24.0 // indirect + google.golang.org/api v0.196.0 // indirect + google.golang.org/genproto v0.0.0-20240903143218-8af14fe29dc1 // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20240827150818-7e3bb234dfed // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1 // indirect + google.golang.org/grpc v1.66.0 // indirect + google.golang.org/protobuf v1.34.2 // indirect + gopkg.in/inf.v0 v0.9.1 // indirect + gopkg.in/ini.v1 v1.67.0 // indirect + gopkg.in/yaml.v2 v2.4.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect + honnef.co/go/tools v0.5.1 // indirect + k8s.io/api v0.28.2 // indirect + k8s.io/apimachinery v0.28.2 // indirect + k8s.io/client-go v0.28.1 // indirect + k8s.io/klog/v2 v2.100.1 // indirect + k8s.io/kube-openapi v0.0.0-20230717233707-2695361300d9 // indirect + k8s.io/utils v0.0.0-20230406110748-d93618cff8a2 // indirect + mvdan.cc/gofumpt v0.7.0 // indirect + mvdan.cc/unparam v0.0.0-20240528143540-8a5130ca722f // indirect + sigs.k8s.io/controller-runtime v0.0.0-00010101000000-000000000000 // indirect + sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd // indirect + sigs.k8s.io/structured-merge-diff/v4 v4.2.3 // indirect + sigs.k8s.io/yaml v1.3.0 // indirect +) + +replace ( + github.com/pseudomuto/protoc-gen-doc => github.com/flyteorg/protoc-gen-doc v1.4.2 + sigs.k8s.io/controller-runtime => sigs.k8s.io/controller-runtime v0.16.2 +) diff --git a/boilerplate/flyte/golang_support_tools/go.sum b/boilerplate/flyte/golang_support_tools/go.sum new file mode 100644 index 0000000000..a45319f99c --- /dev/null +++ b/boilerplate/flyte/golang_support_tools/go.sum @@ -0,0 +1,855 @@ +4d63.com/gocheckcompilerdirectives v1.2.1 h1:AHcMYuw56NPjq/2y615IGg2kYkBdTvOaojYCBcRE7MA= +4d63.com/gocheckcompilerdirectives v1.2.1/go.mod h1:yjDJSxmDTtIHHCqX0ufRYZDL6vQtMG7tJdKVeWwsqvs= +4d63.com/gochecknoglobals v0.2.1 h1:1eiorGsgHOFOuoOiJDy2psSrQbRdIHrlge0IJIkUgDc= +4d63.com/gochecknoglobals v0.2.1/go.mod h1:KRE8wtJB3CXCsb1xy421JfTHIIbmT3U5ruxw2Qu8fSU= +cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.115.1 h1:Jo0SM9cQnSkYfp44+v+NQXHpcHqlnRJk2qxh6yvxxxQ= +cloud.google.com/go v0.115.1/go.mod h1:DuujITeaufu3gL68/lOFIirVNJwQeyf5UXyi+Wbgknc= +cloud.google.com/go/auth v0.9.3 h1:VOEUIAADkkLtyfr3BLa3R8Ed/j6w1jTBmARx+wb5w5U= +cloud.google.com/go/auth v0.9.3/go.mod h1:7z6VY+7h3KUdRov5F1i8NDP5ZzWKYmEPO842BgCsmTk= +cloud.google.com/go/auth/oauth2adapt v0.2.4 h1:0GWE/FUsXhf6C+jAkWgYm7X9tK8cuEIfy19DBn6B6bY= +cloud.google.com/go/auth/oauth2adapt v0.2.4/go.mod h1:jC/jOpwFP6JBxhB3P5Rr0a9HLMC/Pe3eaL4NmdvqPtc= +cloud.google.com/go/compute/metadata v0.5.0 h1:Zr0eK8JbFv6+Wi4ilXAR8FJ3wyNdpxHKJNPos6LTZOY= +cloud.google.com/go/compute/metadata v0.5.0/go.mod h1:aHnloV2TPI38yx4s9+wAZhHykWvVCfu7hQbF+9CWoiY= +cloud.google.com/go/iam v1.2.0 h1:kZKMKVNk/IsSSc/udOb83K0hL/Yh/Gcqpz+oAkoIFN8= +cloud.google.com/go/iam v1.2.0/go.mod h1:zITGuWgsLZxd8OwAlX+eMFgZDXzBm7icj1PVTYG766Q= +cloud.google.com/go/longrunning v0.6.0 h1:mM1ZmaNsQsnb+5n1DNPeL0KwQd9jQRqSqSDEkBZr+aI= +cloud.google.com/go/longrunning v0.6.0/go.mod h1:uHzSZqW89h7/pasCWNYdUpwGz3PcVWhrWupreVPYLts= +cloud.google.com/go/storage v1.43.0 h1:CcxnSohZwizt4LCzQHWvBf1/kvtHUn7gk9QERXPyXFs= +cloud.google.com/go/storage v1.43.0/go.mod h1:ajvxEa7WmZS1PxvKRq4bq0tFT3vMd502JwstCcYv0Q0= +github.com/4meepo/tagalign v1.3.4 h1:P51VcvBnf04YkHzjfclN6BbsopfJR5rxs1n+5zHt+w8= +github.com/4meepo/tagalign v1.3.4/go.mod h1:M+pnkHH2vG8+qhE5bVc/zeP7HS/j910Fwa9TUSyZVI0= +github.com/Abirdcfly/dupword v0.1.1 h1:Bsxe0fIw6OwBtXMIncaTxCLHYO5BB+3mcsR5E8VXloY= +github.com/Abirdcfly/dupword v0.1.1/go.mod h1:B49AcJdTYYkpd4HjgAcutNGG9HZ2JWwKunH9Y2BA6sM= +github.com/Antonboom/errname v0.1.13 h1:JHICqsewj/fNckzrfVSe+T33svwQxmjC+1ntDsHOVvM= +github.com/Antonboom/errname v0.1.13/go.mod h1:uWyefRYRN54lBg6HseYCFhs6Qjcy41Y3Jl/dVhA87Ns= +github.com/Antonboom/nilnil v0.1.9 h1:eKFMejSxPSA9eLSensFmjW2XTgTwJMjZ8hUHtV4s/SQ= +github.com/Antonboom/nilnil v0.1.9/go.mod h1:iGe2rYwCq5/Me1khrysB4nwI7swQvjclR8/YRPl5ihQ= +github.com/Antonboom/testifylint v1.4.3 h1:ohMt6AHuHgttaQ1xb6SSnxCeK4/rnK7KKzbvs7DmEck= +github.com/Antonboom/testifylint v1.4.3/go.mod h1:+8Q9+AOLsz5ZiQiiYujJKs9mNz398+M6UgslP4qgJLA= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.13.0 h1:GJHeeA2N7xrG3q30L2UXDyuWRzDM900/65j70wcM4Ww= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.13.0/go.mod h1:l38EPgmsp71HHLq9j7De57JcKOWPyhrsW1Awm1JS6K0= +github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.7.0 h1:tfLQ34V6F7tVSwoTf/4lH5sE0o6eCJuNDTmH09nDpbc= +github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.7.0/go.mod h1:9kIvujWAA58nmPmWB1m23fyWic1kYZMxD9CxaWn4Qpg= +github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0 h1:ywEEhmNahHBihViHepv3xPBn1663uRv2t2q/ESv9seY= +github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0/go.mod h1:iZDifYGJTIgIIkYRNWPENUnqx6bJ2xnSDFI2tjwZNuY= +github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.6.0 h1:PiSrjRPpkQNjrM8H0WwKMnZUdu1RGMtd/LdGKUrOo+c= +github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.6.0/go.mod h1:oDrbWx4ewMylP7xHivfgixbfGBT6APAwsSoHRKotnIc= +github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.4.0 h1:Be6KInmFEKV81c0pOAEbRYehLMwmmGI1exuFj248AMk= +github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.4.0/go.mod h1:WCPBHsOXfBVnivScjs2ypRfimjEW0qPVLGgJkZlrIOA= +github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2 h1:XHOnouVk1mxXfQidrMEnLlPk9UMeRtyBTnEFtxkV0kU= +github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2/go.mod h1:wP83P5OoQ5p6ip3ScPr0BAq0BvuPAvacpEuSzyouqAI= +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c h1:pxW6RcqyfI9/kWtOwnv/G+AzdKuy2ZrqINhenH4HyNs= +github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho= +github.com/Crocmagnon/fatcontext v0.5.2 h1:vhSEg8Gqng8awhPju2w7MKHqMlg4/NI+gSDHtR3xgwA= +github.com/Crocmagnon/fatcontext v0.5.2/go.mod h1:87XhRMaInHP44Q7Tlc7jkgKKB7kZAOPiDkFMdKCC+74= +github.com/Djarvur/go-err113 v0.0.0-20210108212216-aea10b59be24 h1:sHglBQTwgx+rWPdisA5ynNEsoARbiCBOyGcJM4/OzsM= +github.com/Djarvur/go-err113 v0.0.0-20210108212216-aea10b59be24/go.mod h1:4UJr5HIiMZrwgkSPdsjy2uOQExX/WEILpIrO9UPGuXs= +github.com/GaijinEntertainment/go-exhaustruct/v3 v3.3.0 h1:/fTUt5vmbkAcMBt4YQiuC23cV0kEsN1MVMNqeOW43cU= +github.com/GaijinEntertainment/go-exhaustruct/v3 v3.3.0/go.mod h1:ONJg5sxcbsdQQ4pOW8TGdTidT2TMAUy/2Xhr8mrYaao= +github.com/Masterminds/semver v1.4.2/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y= +github.com/Masterminds/semver v1.5.0 h1:H65muMkzWKEuNDnfl9d70GUjFniHKHRbFPGBuZ3QEww= +github.com/Masterminds/semver v1.5.0/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y= +github.com/Masterminds/semver/v3 v3.3.0 h1:B8LGeaivUe71a5qox1ICM/JLl0NqZSW5CHyL+hmvYS0= +github.com/Masterminds/semver/v3 v3.3.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM= +github.com/Masterminds/sprig v2.15.0+incompatible h1:0gSxPGWS9PAr7U2NsQ2YQg6juRDINkUyuvbb4b2Xm8w= +github.com/Masterminds/sprig v2.15.0+incompatible/go.mod h1:y6hNFY5UBTIWBxnzTeuNhlNS5hqE0NB0E6fgfo2Br3o= +github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE= +github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= +github.com/OpenPeeDeeP/depguard/v2 v2.2.0 h1:vDfG60vDtIuf0MEOhmLlLLSzqaRM8EMcgJPdp74zmpA= +github.com/OpenPeeDeeP/depguard/v2 v2.2.0/go.mod h1:CIzddKRvLBC4Au5aYP/i3nyaWQ+ClszLIuVocRiCYFQ= +github.com/alecthomas/assert/v2 v2.2.2 h1:Z/iVC0xZfWTaFNE6bA3z07T86hd45Xe2eLt6WVy2bbk= +github.com/alecthomas/assert/v2 v2.2.2/go.mod h1:pXcQ2Asjp247dahGEmsZ6ru0UVwnkhktn7S0bBDLxvQ= +github.com/alecthomas/go-check-sumtype v0.1.4 h1:WCvlB3l5Vq5dZQTFmodqL2g68uHiSwwlWcT5a2FGK0c= +github.com/alecthomas/go-check-sumtype v0.1.4/go.mod h1:WyYPfhfkdhyrdaligV6svFopZV8Lqdzn5pyVBaV6jhQ= +github.com/alecthomas/repr v0.2.0 h1:HAzS41CIzNW5syS8Mf9UwXhNH1J9aix/BvDRf1Ml2Yk= +github.com/alecthomas/repr v0.2.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4= +github.com/alexkohler/nakedret/v2 v2.0.4 h1:yZuKmjqGi0pSmjGpOC016LtPJysIL0WEUiaXW5SUnNg= +github.com/alexkohler/nakedret/v2 v2.0.4/go.mod h1:bF5i0zF2Wo2o4X4USt9ntUWve6JbFv02Ff4vlkmS/VU= +github.com/alexkohler/prealloc v1.0.0 h1:Hbq0/3fJPQhNkN0dR95AVrr6R7tou91y0uHG5pOcUuw= +github.com/alexkohler/prealloc v1.0.0/go.mod h1:VetnK3dIgFBBKmg0YnD9F9x6Icjd+9cvfHR56wJVlKE= +github.com/alingse/asasalint v0.0.11 h1:SFwnQXJ49Kx/1GghOFz1XGqHYKp21Kq1nHad/0WQRnw= +github.com/alingse/asasalint v0.0.11/go.mod h1:nCaoMhw7a9kSJObvQyVzNTPBDbNpdocqrSP7t/cW5+I= +github.com/alvaroloes/enumer v1.1.2 h1:5khqHB33TZy1GWCO/lZwcroBFh7u+0j40T83VUbfAMY= +github.com/alvaroloes/enumer v1.1.2/go.mod h1:FxrjvuXoDAx9isTJrv4c+T410zFi0DtXIT0m65DJ+Wo= +github.com/aokoli/goutils v1.0.1 h1:7fpzNGoJ3VA8qcrm++XEE1QUe0mIwNeLa02Nwq7RDkg= +github.com/aokoli/goutils v1.0.1/go.mod h1:SijmP0QR8LtwsmDs8Yii5Z/S4trXFGFC2oO5g9DP+DQ= +github.com/ashanbrown/forbidigo v1.6.0 h1:D3aewfM37Yb3pxHujIPSpTf6oQk9sc9WZi8gerOIVIY= +github.com/ashanbrown/forbidigo v1.6.0/go.mod h1:Y8j9jy9ZYAEHXdu723cUlraTqbzjKF1MUyfOKL+AjcU= +github.com/ashanbrown/makezero v1.1.1 h1:iCQ87C0V0vSyO+M9E/FZYbu65auqH0lnsOkf5FcB28s= +github.com/ashanbrown/makezero v1.1.1/go.mod h1:i1bJLCRSCHOcOa9Y6MyF2FTfMZMFdHvxKHxgO5Z1axI= +github.com/aws/aws-sdk-go v1.44.2 h1:5VBk5r06bgxgRKVaUtm1/4NT/rtrnH2E4cnAYv5zgQc= +github.com/aws/aws-sdk-go v1.44.2/go.mod h1:y4AeaBuwd2Lk+GepC1E9v0qOiTws0MIWAX4oIKwKHZo= +github.com/benbjohnson/clock v1.3.0 h1:ip6w0uFQkncKQ979AypyG0ER7mqUSBdKLOgAle/AT8A= +github.com/benbjohnson/clock v1.3.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= +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/bkielbasa/cyclop v1.2.1 h1:AeF71HZDob1P2/pRm1so9cd1alZnrpyc4q2uP2l0gJY= +github.com/bkielbasa/cyclop v1.2.1/go.mod h1:K/dT/M0FPAiYjBgQGau7tz+3TMh4FWAEqlMhzFWCrgM= +github.com/blizzy78/varnamelen v0.8.0 h1:oqSblyuQvFsW1hbBHh1zfwrKe3kcSj0rnXkKzsQ089M= +github.com/blizzy78/varnamelen v0.8.0/go.mod h1:V9TzQZ4fLJ1DSrjVDfl89H7aMnTvKkApdHeyESmyR7k= +github.com/bombsimon/wsl/v4 v4.4.1 h1:jfUaCkN+aUpobrMO24zwyAMwMAV5eSziCkOKEauOLdw= +github.com/bombsimon/wsl/v4 v4.4.1/go.mod h1:Xu/kDxGZTofQcDGCtQe9KCzhHphIe0fDuyWTxER9Feo= +github.com/breml/bidichk v0.2.7 h1:dAkKQPLl/Qrk7hnP6P+E0xOodrq8Us7+U0o4UBOAlQY= +github.com/breml/bidichk v0.2.7/go.mod h1:YodjipAGI9fGcYM7II6wFvGhdMYsC5pHDlGzqvEW3tQ= +github.com/breml/errchkjson v0.3.6 h1:VLhVkqSBH96AvXEyclMR37rZslRrY2kcyq+31HCsVrA= +github.com/breml/errchkjson v0.3.6/go.mod h1:jhSDoFheAF2RSDOlCfhHO9KqhZgAYLyvHe7bRCX8f/U= +github.com/butuzov/ireturn v0.3.0 h1:hTjMqWw3y5JC3kpnC5vXmFJAWI/m31jaCYQqzkS6PL0= +github.com/butuzov/ireturn v0.3.0/go.mod h1:A09nIiwiqzN/IoVo9ogpa0Hzi9fex1kd9PSD6edP5ZA= +github.com/butuzov/mirror v1.2.0 h1:9YVK1qIjNspaqWutSv8gsge2e/Xpq1eqEkslEUHy5cs= +github.com/butuzov/mirror v1.2.0/go.mod h1:DqZZDtzm42wIAIyHXeN8W/qb1EPlb9Qn/if9icBOpdQ= +github.com/catenacyber/perfsprint v0.7.1 h1:PGW5G/Kxn+YrN04cRAZKC+ZuvlVwolYMrIyyTJ/rMmc= +github.com/catenacyber/perfsprint v0.7.1/go.mod h1:/wclWYompEyjUD2FuIIDVKNkqz7IgBIWXIH3V0Zol50= +github.com/ccojocar/zxcvbn-go v1.0.2 h1:na/czXU8RrhXO4EZme6eQJLR4PzcGsahsBOAwU6I3Vg= +github.com/ccojocar/zxcvbn-go v1.0.2/go.mod h1:g1qkXtUSvHP8lhHp5GrSmTz6uWALGRMQdw6Qnz/hi60= +github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +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.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/charithe/durationcheck v0.0.10 h1:wgw73BiocdBDQPik+zcEoBG/ob8uyBHf2iyoHGPf5w4= +github.com/charithe/durationcheck v0.0.10/go.mod h1:bCWXb7gYRysD1CU3C+u4ceO49LoGOY1C1L6uouGNreQ= +github.com/chavacava/garif v0.1.0 h1:2JHa3hbYf5D9dsgseMKAmc/MZ109otzgNFk5s87H9Pc= +github.com/chavacava/garif v0.1.0/go.mod h1:XMyYCkEL58DF0oyW4qDjjnPWONs2HBqYKI+UIPD+Gww= +github.com/cheekybits/is v0.0.0-20150225183255-68e9c0620927 h1:SKI1/fuSdodxmNNyVBR8d7X/HuLnRpvvFO0AgyQk764= +github.com/cheekybits/is v0.0.0-20150225183255-68e9c0620927/go.mod h1:h/aW8ynjgkuj+NQRlZcDbAbM1ORAbXjXX77sX7T289U= +github.com/chigopher/pathlib v0.19.1 h1:RoLlUJc0CqBGwq239cilyhxPNLXTK+HXoASGyGznx5A= +github.com/chigopher/pathlib v0.19.1/go.mod h1:tzC1dZLW8o33UQpWkNkhvPwL5n4yyFRFm/jL1YGWFvY= +github.com/ckaznocha/intrange v0.2.0 h1:FykcZuJ8BD7oX93YbO1UY9oZtkRbp+1/kJcDjkefYLs= +github.com/ckaznocha/intrange v0.2.0/go.mod h1:r5I7nUlAAG56xmkOpw4XVr16BXhwYTUdcuRFeevn1oE= +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/coocood/freecache v1.1.1 h1:uukNF7QKCZEdZ9gAV7WQzvh0SbjwdMF6m3x3rxEkaPc= +github.com/coocood/freecache v1.1.1/go.mod h1:OKrEjkGVoxZhyWAJoeFi5BMLUJm2Tit0kpGkIr7NGYY= +github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= +github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= +github.com/curioswitch/go-reassign v0.2.0 h1:G9UZyOcpk/d7Gd6mqYgd8XYWFMw/znxwGDUstnC9DIo= +github.com/curioswitch/go-reassign v0.2.0/go.mod h1:x6OpXuWvgfQaMGks2BZybTngWjT84hqJfKoO8Tt/Roc= +github.com/daixiang0/gci v0.13.5 h1:kThgmH1yBmZSBCh1EJVxQ7JsHpm5Oms0AMed/0LaH4c= +github.com/daixiang0/gci v0.13.5/go.mod h1:12etP2OniiIdP4q+kjUGrC/rUagga7ODbqsom5Eo5Yk= +github.com/davecgh/go-spew v0.0.0-20161028175848-04cdfd42973b/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/denis-tingaikin/go-header v0.5.0 h1:SRdnP5ZKvcO9KKRP1KJrhFR3RrlGuD+42t4429eC9k8= +github.com/denis-tingaikin/go-header v0.5.0/go.mod h1:mMenU5bWrok6Wl2UsZjy+1okegmwQ3UgWl4V1D8gjlY= +github.com/emicklei/go-restful/v3 v3.9.0 h1:XwGDlfxEnQZzuopoqxwSEllNcCOM9DhhFyhFIIGKwxE= +github.com/emicklei/go-restful/v3 v3.9.0/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc= +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/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= +github.com/envoyproxy/protoc-gen-validate v0.3.0-java/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= +github.com/envoyproxy/protoc-gen-validate v1.0.4 h1:gVPz/FMfvh57HdSJQyvBtF00j8JU4zdyUgIUNhlgg0A= +github.com/envoyproxy/protoc-gen-validate v1.0.4/go.mod h1:qys6tmnRsYrQqIhm2bvKZH4Blx/1gTIZ2UKVY1M+Yew= +github.com/ernesto-jimenez/gogen v0.0.0-20180125220232-d7d4131e6607 h1:cTavhURetDkezJCvxFggiyLeP40Mrk/TtVg2+ycw1Es= +github.com/ernesto-jimenez/gogen v0.0.0-20180125220232-d7d4131e6607/go.mod h1:Cg4fM0vhYWOZdgM7RIOSTRNIc8/VT7CXClC3Ni86lu4= +github.com/ettle/strcase v0.2.0 h1:fGNiVF21fHXpX1niBgk0aROov1LagYsOwV/xqKDKR/Q= +github.com/ettle/strcase v0.2.0/go.mod h1:DajmHElDSaX76ITe3/VHVyMin4LWSJN5Z909Wp+ED1A= +github.com/evanphx/json-patch/v5 v5.6.0 h1:b91NhWfaz02IuVxO9faSllyAtNXHMPkC5J8sJCLunww= +github.com/evanphx/json-patch/v5 v5.6.0/go.mod h1:G79N1coSVB93tBe7j6PhzjmR3/2VvlbKOFpnXhI9Bw4= +github.com/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4= +github.com/fatih/color v1.17.0/go.mod h1:YZ7TlrGPkiz6ku9fK3TLD/pl3CpsiFyu8N92HLgmosI= +github.com/fatih/structtag v1.2.0 h1:/OdNE99OxoI/PqaW/SuSK9uxxT3f/tcSZgon/ssNSx4= +github.com/fatih/structtag v1.2.0/go.mod h1:mBJUNpUnHmRKrKlQQlmCrh5PuhftFbNv8Ys4/aAZl94= +github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= +github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/firefart/nonamedreturns v1.0.5 h1:tM+Me2ZaXs8tfdDw3X6DOX++wMCOqzYUho6tUTYIdRA= +github.com/firefart/nonamedreturns v1.0.5/go.mod h1:gHJjDqhGM4WyPt639SOZs+G89Ko7QKH5R5BhnO6xJhw= +github.com/flyteorg/flyte/flytestdlib v1.11.0 h1:DxM/sf6H0ong8LIjgh0YwXK+abnGV8kWVi6EgfVCkO8= +github.com/flyteorg/flyte/flytestdlib v1.11.0/go.mod h1:AmgNCq/tGEDwVfilW1nFtgPQn8vQ9gcDu6SNwz1YY+M= +github.com/flyteorg/protoc-gen-doc v1.4.2 h1:Otw0F+RHaPQ8XlpzhLLgjsCMcrAIcMO01Zh+ALe3rrE= +github.com/flyteorg/protoc-gen-doc v1.4.2/go.mod h1:exDTOVwqpp30eV/EDPFLZy3Pwr2sn6hBC1WIYH/UbIg= +github.com/flyteorg/stow v0.3.12 h1:RRXI5RUdxaK6A46HrO0D2r14cRlW1lJRL6qyzqpVMPU= +github.com/flyteorg/stow v0.3.12/go.mod h1:nyaBf8ZWkpHWkKIl4rqKI2uXfPx+VbL0PmEtvq4Pxkc= +github.com/frankban/quicktest v1.14.4 h1:g2rn0vABPOOXmZUj+vbmUp0lPoXEMuhTpIluN0XL9UY= +github.com/frankban/quicktest v1.14.4/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= +github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY= +github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= +github.com/fzipp/gocyclo v0.6.0 h1:lsblElZG7d3ALtGMx9fmxeTKZaLLpU8mET09yN4BBLo= +github.com/fzipp/gocyclo v0.6.0/go.mod h1:rXPyn8fnlpa0R2csP/31uerbiVBugk5whMdlyaLkLoA= +github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= +github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= +github.com/ghostiam/protogetter v0.3.6 h1:R7qEWaSgFCsy20yYHNIJsU9ZOb8TziSRRxuAOTVKeOk= +github.com/ghostiam/protogetter v0.3.6/go.mod h1:7lpeDnEJ1ZjL/YtyoN99ljO4z0pd3H0d18/t2dPBxHw= +github.com/go-critic/go-critic v0.11.4 h1:O7kGOCx0NDIni4czrkRIXTnit0mkyKOCePh3My6OyEU= +github.com/go-critic/go-critic v0.11.4/go.mod h1:2QAdo4iuLik5S9YG0rT4wcZ8QxwHYkrr6/2MWAiv/vc= +github.com/go-logr/logr v1.2.0/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= +github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/go-logr/zapr v1.2.4 h1:QHVo+6stLbfJmYGkQ7uGHUCu5hnAFAj6mDe6Ea0SeOo= +github.com/go-logr/zapr v1.2.4/go.mod h1:FyHWQIzQORZ0QVE1BtVHv3cKtNLuXsbNLtpuhNapBOA= +github.com/go-openapi/jsonpointer v0.19.6 h1:eCs3fxoIi3Wh6vtgmLTOjdhSpiqphQ+DaPn38N2ZdrE= +github.com/go-openapi/jsonpointer v0.19.6/go.mod h1:osyAmYz/mB/C3I+WsTTSgw1ONzaLJoLCyoi6/zppojs= +github.com/go-openapi/jsonreference v0.20.2 h1:3sVjiK66+uXK/6oQ8xgcRKcFgQ5KXa2KvnJRumpMGbE= +github.com/go-openapi/jsonreference v0.20.2/go.mod h1:Bl1zwGIM8/wsvqjsOQLJ/SH+En5Ap4rVB5KVcIDZG2k= +github.com/go-openapi/swag v0.22.3 h1:yMBqmnQ0gyZvEb/+KzuWZOXgllrXT4SADYbvDaXHv/g= +github.com/go-openapi/swag v0.22.3/go.mod h1:UzaqsxGiab7freDnrUUra0MwWfN/q7tE4j+VcZ0yl14= +github.com/go-quicktest/qt v1.101.0 h1:O1K29Txy5P2OK0dGo59b7b0LR6wKfIhttaAhHUyn7eI= +github.com/go-quicktest/qt v1.101.0/go.mod h1:14Bz/f7NwaXPtdYEgzsx46kqSxVwTbzVZsDC26tQJow= +github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI= +github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI= +github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8= +github.com/go-toolsmith/astcast v1.1.0 h1:+JN9xZV1A+Re+95pgnMgDboWNVnIMMQXwfBwLRPgSC8= +github.com/go-toolsmith/astcast v1.1.0/go.mod h1:qdcuFWeGGS2xX5bLM/c3U9lewg7+Zu4mr+xPwZIB4ZU= +github.com/go-toolsmith/astcopy v1.1.0 h1:YGwBN0WM+ekI/6SS6+52zLDEf8Yvp3n2seZITCUBt5s= +github.com/go-toolsmith/astcopy v1.1.0/go.mod h1:hXM6gan18VA1T/daUEHCFcYiW8Ai1tIwIzHY6srfEAw= +github.com/go-toolsmith/astequal v1.0.3/go.mod h1:9Ai4UglvtR+4up+bAD4+hCj7iTo4m/OXVTSLnCyTAx4= +github.com/go-toolsmith/astequal v1.1.0/go.mod h1:sedf7VIdCL22LD8qIvv7Nn9MuWJruQA/ysswh64lffQ= +github.com/go-toolsmith/astequal v1.2.0 h1:3Fs3CYZ1k9Vo4FzFhwwewC3CHISHDnVUPC4x0bI2+Cw= +github.com/go-toolsmith/astequal v1.2.0/go.mod h1:c8NZ3+kSFtFY/8lPso4v8LuJjdJiUFVnSuU3s0qrrDY= +github.com/go-toolsmith/astfmt v1.1.0 h1:iJVPDPp6/7AaeLJEruMsBUlOYCmvg0MoCfJprsOmcco= +github.com/go-toolsmith/astfmt v1.1.0/go.mod h1:OrcLlRwu0CuiIBp/8b5PYF9ktGVZUjlNMV634mhwuQ4= +github.com/go-toolsmith/astp v1.1.0 h1:dXPuCl6u2llURjdPLLDxJeZInAeZ0/eZwFJmqZMnpQA= +github.com/go-toolsmith/astp v1.1.0/go.mod h1:0T1xFGz9hicKs8Z5MfAqSUitoUYS30pDMsRVIDHs8CA= +github.com/go-toolsmith/pkgload v1.2.2 h1:0CtmHq/02QhxcF7E9N5LIFcYFsMR5rdovfqTtRKkgIk= +github.com/go-toolsmith/pkgload v1.2.2/go.mod h1:R2hxLNRKuAsiXCo2i5J6ZQPhnPMOVtU+f0arbFPWCus= +github.com/go-toolsmith/strparse v1.0.0/go.mod h1:YI2nUKP9YGZnL/L1/DLFBfixrcjslWct4wyljWhSRy8= +github.com/go-toolsmith/strparse v1.1.0 h1:GAioeZUK9TGxnLS+qfdqNbA4z0SSm5zVNtCQiyP2Bvw= +github.com/go-toolsmith/strparse v1.1.0/go.mod h1:7ksGy58fsaQkGQlY8WVoBFNyEPMGuJin1rfoPS4lBSQ= +github.com/go-toolsmith/typep v1.1.0 h1:fIRYDyF+JywLfqzyhdiHzRop/GQDxxNhLGQ6gFUNHus= +github.com/go-toolsmith/typep v1.1.0/go.mod h1:fVIw+7zjdsMxDA3ITWnH1yOiw1rnTQKCsF/sk2H/qig= +github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs= +github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= +github.com/go-xmlfmt/xmlfmt v1.1.2 h1:Nea7b4icn8s57fTx1M5AI4qQT5HEM3rVUO8MuE6g80U= +github.com/go-xmlfmt/xmlfmt v1.1.2/go.mod h1:aUCEOzzezBEjDBbFBoSiya/gduyIiWYRP6CnSFIV8AM= +github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y= +github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8= +github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= +github.com/gofrs/flock v0.12.1 h1:MTLVXXHf8ekldpJk3AKicLij9MdwOWkZ+a/jHHZby9E= +github.com/gofrs/flock v0.12.1/go.mod h1:9zxTsyu5xtJ9DK+1tFZyibEV7y3uwDxPPfbxeeHCoD0= +github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang-jwt/jwt/v5 v5.2.2 h1:Rl4B7itRWVtYIHFrSNd7vhTiz9UpLdi6gZhZ3wEeDy8= +github.com/golang-jwt/jwt/v5 v5.2.2/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk= +github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE= +github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= +github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= +github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= +github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= +github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/golangci/dupl v0.0.0-20180902072040-3e9179ac440a h1:w8hkcTqaFpzKqonE9uMCefW1WDie15eSP/4MssdenaM= +github.com/golangci/dupl v0.0.0-20180902072040-3e9179ac440a/go.mod h1:ryS0uhF+x9jgbj/N71xsEqODy9BN81/GonCZiOzirOk= +github.com/golangci/gofmt v0.0.0-20240816233607-d8596aa466a9 h1:/1322Qns6BtQxUZDTAT4SdcoxknUki7IAoK4SAXr8ME= +github.com/golangci/gofmt v0.0.0-20240816233607-d8596aa466a9/go.mod h1:Oesb/0uFAyWoaw1U1qS5zyjCg5NP9C9iwjnI4tIsXEE= +github.com/golangci/golangci-lint v1.61.0 h1:VvbOLaRVWmyxCnUIMTbf1kDsaJbTzH20FAMXTAlQGu8= +github.com/golangci/golangci-lint v1.61.0/go.mod h1:e4lztIrJJgLPhWvFPDkhiMwEFRrWlmFbrZea3FsJyN8= +github.com/golangci/misspell v0.6.0 h1:JCle2HUTNWirNlDIAUO44hUsKhOFqGPoC4LZxlaSXDs= +github.com/golangci/misspell v0.6.0/go.mod h1:keMNyY6R9isGaSAu+4Q8NMBwMPkh15Gtc8UCVoDtAWo= +github.com/golangci/modinfo v0.3.4 h1:oU5huX3fbxqQXdfspamej74DFX0kyGLkw1ppvXoJ8GA= +github.com/golangci/modinfo v0.3.4/go.mod h1:wytF1M5xl9u0ij8YSvhkEVPP3M5Mc7XLl1pxH3B2aUM= +github.com/golangci/plugin-module-register v0.1.1 h1:TCmesur25LnyJkpsVrupv1Cdzo+2f7zX0H6Jkw1Ol6c= +github.com/golangci/plugin-module-register v0.1.1/go.mod h1:TTpqoB6KkwOJMV8u7+NyXMrkwwESJLOkfl9TxR1DGFc= +github.com/golangci/revgrep v0.5.3 h1:3tL7c1XBMtWHHqVpS5ChmiAAoe4PF/d5+ULzV9sLAzs= +github.com/golangci/revgrep v0.5.3/go.mod h1:U4R/s9dlXZsg8uJmaR1GrloUr14D7qDl8gi2iPXJH8k= +github.com/golangci/unconvert v0.0.0-20240309020433-c5143eacb3ed h1:IURFTjxeTfNFP0hTEi1YKjB/ub8zkpaOqFFMApi2EAs= +github.com/golangci/unconvert v0.0.0-20240309020433-c5143eacb3ed/go.mod h1:XLXN8bNw4CGRPaqgl3bv/lhz7bsGPh4/xSaMTbo2vkQ= +github.com/google/gnostic-models v0.6.8 h1:yo/ABAfM5IMRsS1VnXjTBvUb61tFIHozhlYvRgGre9I= +github.com/google/gnostic-models v0.6.8/go.mod h1:5n7qKqH0f5wFt+aWF8CW6pZLLNOfYuF5OpfBSENuI8U= +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.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.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= +github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/martian/v3 v3.3.3 h1:DIhPTQrbPkgs2yJYdXU/eNACCG5DVQjySNRNlflZ9Fc= +github.com/google/martian/v3 v3.3.3/go.mod h1:iEPrYcgCF7jA9OtScMFQyAlZZ4YXTKEtJ1E6RWzmBA0= +github.com/google/pprof v0.0.0-20240827171923-fa2c70bbbfe5 h1:5iH8iuqE5apketRbSFBy+X1V0o+l+8NF1avt4HWl7cA= +github.com/google/pprof v0.0.0-20240827171923-fa2c70bbbfe5/go.mod h1:vavhavw2zAxS5dIdcRluK6cSGGPlZynqzFM8NdvU144= +github.com/google/s2a-go v0.1.8 h1:zZDs9gcbt9ZPLV0ndSyQk6Kacx2g/X+SKYovpnz3SMM= +github.com/google/s2a-go v0.1.8/go.mod h1:6iNWHTpQ+nfNRN5E00MSdfDwVesa8hhS32PhPO8deJA= +github.com/google/uuid v0.0.0-20161128191214-064e2069ce9c/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/googleapis/enterprise-certificate-proxy v0.3.3 h1:QRje2j5GZimBzlbhGA2V2QlGNgL8G6e+wGo/+/2bWI0= +github.com/googleapis/enterprise-certificate-proxy v0.3.3/go.mod h1:YKe7cfqYXjKGpGvmSg28/fFvhNzinZQm8DGnaburhGA= +github.com/googleapis/gax-go/v2 v2.13.0 h1:yitjD5f7jQHhyDsnhKEBU52NdvvdSeGzlAnDPT0hH1s= +github.com/googleapis/gax-go/v2 v2.13.0/go.mod h1:Z/fvTZXF8/uw7Xu5GuslPw+bplx6SS338j1Is2S+B7A= +github.com/gordonklaus/ineffassign v0.1.0 h1:y2Gd/9I7MdY1oEIt+n+rowjBNDcLQq3RsH5hwJd0f9s= +github.com/gordonklaus/ineffassign v0.1.0/go.mod h1:Qcp2HIAYhR7mNUVSIxZww3Guk4it82ghYcEXIAk+QT0= +github.com/gostaticanalysis/analysisutil v0.7.1 h1:ZMCjoue3DtDWQ5WyU16YbjbQEQ3VuzwxALrpYd+HeKk= +github.com/gostaticanalysis/analysisutil v0.7.1/go.mod h1:v21E3hY37WKMGSnbsw2S/ojApNWb6C1//mXO48CXbVc= +github.com/gostaticanalysis/comment v1.4.1/go.mod h1:ih6ZxzTHLdadaiSnF5WY3dxUoXfXAlTaRzuaNDlSado= +github.com/gostaticanalysis/comment v1.4.2 h1:hlnx5+S2fY9Zo9ePo4AhgYsYHbM2+eAv8m/s1JiCd6Q= +github.com/gostaticanalysis/comment v1.4.2/go.mod h1:KLUTGDv6HOCotCH8h2erHKmpci2ZoR8VPu34YA2uzdM= +github.com/gostaticanalysis/forcetypeassert v0.1.0 h1:6eUflI3DiGusXGK6X7cCcIgVCpZ2CiZ1Q7jl6ZxNV70= +github.com/gostaticanalysis/forcetypeassert v0.1.0/go.mod h1:qZEedyP/sY1lTGV1uJ3VhWZ2mqag3IkWsDHVbplHXak= +github.com/gostaticanalysis/nilerr v0.1.1 h1:ThE+hJP0fEp4zWLkWHWcRyI2Od0p7DlgYG3Uqrmrcpk= +github.com/gostaticanalysis/nilerr v0.1.1/go.mod h1:wZYb6YI5YAxxq0i1+VJbY0s2YONW0HU0GPE3+5PWN4A= +github.com/gostaticanalysis/testutil v0.3.1-0.20210208050101-bfb5c8eec0e4/go.mod h1:D+FIZ+7OahH3ePw/izIEeH5I06eKs1IKI4Xr64/Am3M= +github.com/gostaticanalysis/testutil v0.4.0 h1:nhdCmubdmDF6VEatUNjgUZBJKWRqugoISdUv3PPQgHY= +github.com/gostaticanalysis/testutil v0.4.0/go.mod h1:bLIoPefWXrRi/ssLFWX1dx7Repi5x3CuviD3dgAZaBU= +github.com/hashicorp/go-version v1.2.1/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= +github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY= +github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= +github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= +github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= +github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM= +github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg= +github.com/huandu/xstrings v1.0.0/go.mod h1:4qWG/gcEcfX4z/mBDHJ++3ReCw9ibxbsNJbcucJdbSo= +github.com/huandu/xstrings v1.4.0 h1:D17IlohoQq4UcpqD7fDk80P7l+lwAmlFaBHgOipl2FU= +github.com/huandu/xstrings v1.4.0/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= +github.com/iancoleman/strcase v0.3.0 h1:nTXanmYxhfFAMjZL34Ov6gkzEsSJZ5DbhxWjvSASxEI= +github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= +github.com/imdario/mergo v0.3.4/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA= +github.com/imdario/mergo v0.3.6 h1:xTNEAn+kxVO7dTZGu0CegyqKZmoWFI0rF8UxjlB2d28= +github.com/imdario/mergo v0.3.6/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA= +github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= +github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= +github.com/jgautheron/goconst v1.7.1 h1:VpdAG7Ca7yvvJk5n8dMwQhfEZJh95kl/Hl9S1OI5Jkk= +github.com/jgautheron/goconst v1.7.1/go.mod h1:aAosetZ5zaeC/2EfMeRswtxUFBpe2Hr7HzkgX4fanO4= +github.com/jingyugao/rowserrcheck v1.1.1 h1:zibz55j/MJtLsjP1OF4bSdgXxwL1b+Vn7Tjzq7gFzUs= +github.com/jingyugao/rowserrcheck v1.1.1/go.mod h1:4yvlZSDb3IyDTUZJUmpZfm2Hwok+Dtp+nu2qOq+er9c= +github.com/jinzhu/copier v0.3.5 h1:GlvfUwHk62RokgqVNvYsku0TATCF7bAHVwEXoBh3iJg= +github.com/jinzhu/copier v0.3.5/go.mod h1:DfbEm0FYsaqBcKcFuvmOZb218JkPGtvSHsKg8S8hyyg= +github.com/jirfag/go-printf-func-name v0.0.0-20200119135958-7558a9eaa5af h1:KA9BjwUk7KlCh6S9EAGWBt1oExIUv9WyNCiRz5amv48= +github.com/jirfag/go-printf-func-name v0.0.0-20200119135958-7558a9eaa5af/go.mod h1:HEWGJkRDzjJY2sqdDwxccsGicWEf9BQOZsq2tV+xzM0= +github.com/jjti/go-spancheck v0.6.2 h1:iYtoxqPMzHUPp7St+5yA8+cONdyXD3ug6KK15n7Pklk= +github.com/jjti/go-spancheck v0.6.2/go.mod h1:+X7lvIrR5ZdUTkxFYqzJ0abr8Sb5LOo80uOhWNqIrYA= +github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg= +github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= +github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8= +github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= +github.com/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.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/julz/importas v0.1.0 h1:F78HnrsjY3cR7j0etXy5+TU1Zuy7Xt08X/1aJnH5xXY= +github.com/julz/importas v0.1.0/go.mod h1:oSFU2R4XK/P7kNBrnL/FEQlDGN1/6WoxXEjSSXO0DV0= +github.com/karamaru-alpha/copyloopvar v1.1.0 h1:x7gNyKcC2vRBO1H2Mks5u1VxQtYvFiym7fCjIP8RPos= +github.com/karamaru-alpha/copyloopvar v1.1.0/go.mod h1:u7CIfztblY0jZLOQZgH3oYsJzpC2A7S6u/lfgSXHy0k= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/errcheck v1.7.0 h1:+SbscKmWJ5mOK/bO1zS60F5I9WwZDWOfRsC4RwfwRV0= +github.com/kisielk/errcheck v1.7.0/go.mod h1:1kLL+jV4e+CFfueBmI1dSK2ADDyQnlrnrY/FqKluHJQ= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/kkHAIKE/contextcheck v1.1.5 h1:CdnJh63tcDe53vG+RebdpdXJTc9atMgGqdx8LXxiilg= +github.com/kkHAIKE/contextcheck v1.1.5/go.mod h1:O930cpht4xb1YQpK+1+AgoM3mFsvxr7uyFptcnWTYUA= +github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/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/kulti/thelper v0.6.3 h1:ElhKf+AlItIu+xGnI990no4cE2+XaSu1ULymV2Yulxs= +github.com/kulti/thelper v0.6.3/go.mod h1:DsqKShOvP40epevkFrvIwkCMNYxMeTNjdWL4dqWHZ6I= +github.com/kunwardeep/paralleltest v1.0.10 h1:wrodoaKYzS2mdNVnc4/w31YaXFtsc21PCTdvWJ/lDDs= +github.com/kunwardeep/paralleltest v1.0.10/go.mod h1:2C7s65hONVqY7Q5Efj5aLzRCNLjw2h4eMc9EcypGjcY= +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/kyoh86/exportloopref v0.1.11 h1:1Z0bcmTypkL3Q4k+IDHMWTcnCliEZcaPiIe0/ymEyhQ= +github.com/kyoh86/exportloopref v0.1.11/go.mod h1:qkV4UF1zGl6EkF1ox8L5t9SwyeBAZ3qLMd6up458uqA= +github.com/lasiar/canonicalheader v1.1.1 h1:wC+dY9ZfiqiPwAexUApFush/csSPXeIi4QqyxXmng8I= +github.com/lasiar/canonicalheader v1.1.1/go.mod h1:cXkb3Dlk6XXy+8MVQnF23CYKWlyA7kfQhSw2CcZtZb0= +github.com/ldez/gomoddirectives v0.2.4 h1:j3YjBIjEBbqZ0NKtBNzr8rtMHTOrLPeiwTkfUJZ3alg= +github.com/ldez/gomoddirectives v0.2.4/go.mod h1:oWu9i62VcQDYp9EQ0ONTfqLNh+mDLWWDO+SO0qSQw5g= +github.com/ldez/tagliatelle v0.5.0 h1:epgfuYt9v0CG3fms0pEgIMNPuFf/LpPIfjk4kyqSioo= +github.com/ldez/tagliatelle v0.5.0/go.mod h1:rj1HmWiL1MiKQuOONhd09iySTEkUuE/8+5jtPYz9xa4= +github.com/leonklingele/grouper v1.1.2 h1:o1ARBDLOmmasUaNDesWqWCIFH3u7hoFlM84YrjT3mIY= +github.com/leonklingele/grouper v1.1.2/go.mod h1:6D0M/HVkhs2yRKRFZUoGjeDy7EZTfFBE9gl4kjmIGkA= +github.com/lufeee/execinquery v1.2.1 h1:hf0Ems4SHcUGBxpGN7Jz78z1ppVkP/837ZlETPCEtOM= +github.com/lufeee/execinquery v1.2.1/go.mod h1:EC7DrEKView09ocscGHC+apXMIaorh4xqSxS/dy8SbM= +github.com/macabu/inamedparam v0.1.3 h1:2tk/phHkMlEL/1GNe/Yf6kkR/hkcUdAEY3L0hjYV1Mk= +github.com/macabu/inamedparam v0.1.3/go.mod h1:93FLICAIk/quk7eaPPQvbzihUdn/QkGDwIZEoLtpH6I= +github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY= +github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= +github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0= +github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= +github.com/maratori/testableexamples v1.0.0 h1:dU5alXRrD8WKSjOUnmJZuzdxWOEQ57+7s93SLMxb2vI= +github.com/maratori/testableexamples v1.0.0/go.mod h1:4rhjL1n20TUTT4vdh3RDqSizKLyXp7K2u6HgraZCGzE= +github.com/maratori/testpackage v1.1.1 h1:S58XVV5AD7HADMmD0fNnziNHqKvSdDuEKdPD1rNTU04= +github.com/maratori/testpackage v1.1.1/go.mod h1:s4gRK/ym6AMrqpOa/kEbQTV4Q4jb7WeLZzVhVVVOQMc= +github.com/matoous/godox v0.0.0-20230222163458-006bad1f9d26 h1:gWg6ZQ4JhDfJPqlo2srm/LN17lpybq15AryXIRcWYLE= +github.com/matoous/godox v0.0.0-20230222163458-006bad1f9d26/go.mod h1:1BELzlh859Sh1c6+90blK8lbYy0kwQf1bYlBhBysy1s= +github.com/matryer/is v1.4.0 h1:sosSmIWwkYITGrxZ25ULNDeKiMNzFSr4V/eqBQP0PeE= +github.com/matryer/is v1.4.0/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0= +github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= +github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo= +github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= +github.com/mgechev/revive v1.3.9 h1:18Y3R4a2USSBF+QZKFQwVkBROUda7uoBlkEuBD+YD1A= +github.com/mgechev/revive v1.3.9/go.mod h1:+uxEIr5UH0TjXWHTno3xh4u7eg6jDpXKzQccA9UGhHU= +github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y= +github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= +github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= +github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +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 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/moricho/tparallel v0.3.2 h1:odr8aZVFA3NZrNybggMkYO3rgPRcqjeQUlBBFVxKHTI= +github.com/moricho/tparallel v0.3.2/go.mod h1:OQ+K3b4Ln3l2TZveGCywybl68glfLEwFGqvnjok8b+U= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= +github.com/mwitkow/go-proto-validators v0.0.0-20180403085117-0950a7990007 h1:28i1IjGcx8AofiB4N3q5Yls55VEaitzuEPkFJEVgGkA= +github.com/mwitkow/go-proto-validators v0.0.0-20180403085117-0950a7990007/go.mod h1:m2XC9Qq0AlmmVksL6FktJCdTYyLk7V3fKyp0sl1yWQo= +github.com/nakabonne/nestif v0.3.1 h1:wm28nZjhQY5HyYPx+weN3Q65k6ilSBxDb8v5S81B81U= +github.com/nakabonne/nestif v0.3.1/go.mod h1:9EtoZochLn5iUprVDmDjqGKPofoUEBL8U4Ngq6aY7OE= +github.com/ncw/swift v1.0.53 h1:luHjjTNtekIEvHg5KdAFIBaH7bWfNkefwFnpDffSIks= +github.com/ncw/swift v1.0.53/go.mod h1:23YIA4yWVnGwv2dQlN4bB7egfYX6YLn0Yo/S6zZO/ZM= +github.com/nishanths/exhaustive v0.12.0 h1:vIY9sALmw6T/yxiASewa4TQcFsVYZQQRUQJhKRf3Swg= +github.com/nishanths/exhaustive v0.12.0/go.mod h1:mEZ95wPIZW+x8kC4TgC+9YCUgiST7ecevsVDTgc2obs= +github.com/nishanths/predeclared v0.2.2 h1:V2EPdZPliZymNAn79T8RkNApBjMmVKh5XRpLm/w98Vk= +github.com/nishanths/predeclared v0.2.2/go.mod h1:RROzoN6TnGQupbC+lqggsOlcgysk3LMK/HI84Mp280c= +github.com/nunnatsa/ginkgolinter v0.16.2 h1:8iLqHIZvN4fTLDC0Ke9tbSZVcyVHoBs0HIbnVSxfHJk= +github.com/nunnatsa/ginkgolinter v0.16.2/go.mod h1:4tWRinDN1FeJgU+iJANW/kz7xKN5nYRAOfJDQUS9dOQ= +github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= +github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= +github.com/onsi/ginkgo/v2 v2.20.2 h1:7NVCeyIWROIAheY21RLS+3j2bb52W0W82tkberYytp4= +github.com/onsi/ginkgo/v2 v2.20.2/go.mod h1:K9gyxPIlb+aIvnZ8bd9Ak+YP18w3APlR+5coaZoE2ag= +github.com/onsi/gomega v1.34.2 h1:pNCwDkzrsv7MS9kpaQvVb1aVLahQXyJ/Tv5oAZMI3i8= +github.com/onsi/gomega v1.34.2/go.mod h1:v1xfxRgk0KIsG+QOdm7p8UosrOzPYRo60fd3B/1Dukc= +github.com/otiai10/copy v1.2.0/go.mod h1:rrF5dJ5F0t/EWSYODDu4j9/vEeYHMkc8jt0zJChqQWw= +github.com/otiai10/copy v1.14.0 h1:dCI/t1iTdYGtkvCuBG2BgR6KZa83PTclw4U5n2wAllU= +github.com/otiai10/copy v1.14.0/go.mod h1:ECfuL02W+/FkTWZWgQqXPWZgW9oeKCSQ5qVfSc4qc4w= +github.com/otiai10/curr v0.0.0-20150429015615-9b4961190c95/go.mod h1:9qAhocn7zKJG+0mI8eUu6xqkFDYS2kb2saOteoSB3cE= +github.com/otiai10/curr v1.0.0/go.mod h1:LskTG5wDwr8Rs+nNQ+1LlxRjAtTZZjtJW4rMXl6j4vs= +github.com/otiai10/mint v1.3.0/go.mod h1:F5AjcsTsWUqX+Na9fpHb52P8pcRX2CI6A3ctIT91xUo= +github.com/otiai10/mint v1.3.1/go.mod h1:/yxELlJQ0ufhjUwhshSj+wFjZ78CnZ48/1wtmBH1OTc= +github.com/pascaldekloe/name v0.0.0-20180628100202-0fd16699aae1 h1:/I3lTljEEDNYLho3/FUB7iD/oc2cEFgVmbHzV+O0PtU= +github.com/pascaldekloe/name v0.0.0-20180628100202-0fd16699aae1/go.mod h1:eD5JxqMiuNYyFNmyY9rkJ/slN8y59oEu4Ei7F8OoKWQ= +github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M= +github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc= +github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ= +github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU= +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 v0.0.0-20151028094244-d8ed2627bdf0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/polyfloyd/go-errorlint v1.6.0 h1:tftWV9DE7txiFzPpztTAwyoRLKNj9gpVm2cg8/OwcYY= +github.com/polyfloyd/go-errorlint v1.6.0/go.mod h1:HR7u8wuP1kb1NeN1zqTd1ZMlqUKPPHF+Id4vIPvDqVw= +github.com/prashantv/gostub v1.1.0 h1:BTyx3RfQjRHnUWaGF9oQos79AlQ5k8WNktv7VGvVH4g= +github.com/prashantv/gostub v1.1.0/go.mod h1:A5zLQHz7ieHGG7is6LLXLz7I8+3LZzsrV0P1IAHhP5U= +github.com/prometheus/client_golang v1.16.0 h1:yk/hx9hDbrGHovbci4BY+pRMfSuuat626eFsHb7tmT8= +github.com/prometheus/client_golang v1.16.0/go.mod h1:Zsulrv/L9oM40tJ7T815tM89lFEugiJ9HzIqaAx4LKc= +github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.4.0 h1:5lQXD3cAg1OXBf4Wq03gTrXHeaV0TQvGfUooCfx1yqY= +github.com/prometheus/client_model v0.4.0/go.mod h1:oMQmHW1/JoDwqLtg57MGgP/Fb1CJEYF2imWWhWtMkYU= +github.com/prometheus/common v0.44.0 h1:+5BrQJwiBB9xsMygAB3TNvpQKOwlkc25LbISbrdOOfY= +github.com/prometheus/common v0.44.0/go.mod h1:ofAIvZbQ1e/nugmZGz4/qCb9Ap1VoSTIO7x0VV9VvuY= +github.com/prometheus/procfs v0.10.1 h1:kYK1Va/YMlutzCGazswoHKo//tZVlFpKYh+PymziUAg= +github.com/prometheus/procfs v0.10.1/go.mod h1:nwNm2aOCAYw8uTR/9bWRREkZFxAUcWzPHWJq+XBB/FM= +github.com/pseudomuto/protokit v0.2.0 h1:hlnBDcy3YEDXH7kc9gV+NLaN0cDzhDvD1s7Y6FZ8RpM= +github.com/pseudomuto/protokit v0.2.0/go.mod h1:2PdH30hxVHsup8KpBTOXTBeMVhJZVio3Q8ViKSAXT0Q= +github.com/quasilyte/go-ruleguard v0.4.3-0.20240823090925-0fe6f58b47b1 h1:+Wl/0aFp0hpuHM3H//KMft64WQ1yX9LdJY64Qm/gFCo= +github.com/quasilyte/go-ruleguard v0.4.3-0.20240823090925-0fe6f58b47b1/go.mod h1:GJLgqsLeo4qgavUoL8JeGFNS7qcisx3awV/w9eWTmNI= +github.com/quasilyte/go-ruleguard/dsl v0.3.22 h1:wd8zkOhSNr+I+8Qeciml08ivDt1pSXe60+5DqOpCjPE= +github.com/quasilyte/go-ruleguard/dsl v0.3.22/go.mod h1:KeCP03KrjuSO0H1kTuZQCWlQPulDV6YMIXmpQss17rU= +github.com/quasilyte/gogrep v0.5.0 h1:eTKODPXbI8ffJMN+W2aE0+oL0z/nh8/5eNdiO34SOAo= +github.com/quasilyte/gogrep v0.5.0/go.mod h1:Cm9lpz9NZjEoL1tgZ2OgeUKPIxL1meE7eo60Z6Sk+Ng= +github.com/quasilyte/regex/syntax v0.0.0-20210819130434-b3f0c404a727 h1:TCg2WBOl980XxGFEZSS6KlBGIV0diGdySzxATTWoqaU= +github.com/quasilyte/regex/syntax v0.0.0-20210819130434-b3f0c404a727/go.mod h1:rlzQ04UMyJXu/aOvhd8qT+hvDrFpiwqp8MRXDY9szc0= +github.com/quasilyte/stdinfo v0.0.0-20220114132959-f7386bf02567 h1:M8mH9eK4OUR4lu7Gd+PU1fV2/qnDNfzT635KRSObncs= +github.com/quasilyte/stdinfo v0.0.0-20220114132959-f7386bf02567/go.mod h1:DWNGW8A4Y+GyBgPuaQJuWiy0XYftx4Xm/y5Jqk9I6VQ= +github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= +github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= +github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= +github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8= +github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/ryancurrah/gomodguard v1.3.5 h1:cShyguSwUEeC0jS7ylOiG/idnd1TpJ1LfHGpV3oJmPU= +github.com/ryancurrah/gomodguard v1.3.5/go.mod h1:MXlEPQRxgfPQa62O8wzK3Ozbkv9Rkqr+wKjSxTdsNJE= +github.com/ryanrolds/sqlclosecheck v0.5.1 h1:dibWW826u0P8jNLsLN+En7+RqWWTYrjCB9fJfSfdyCU= +github.com/ryanrolds/sqlclosecheck v0.5.1/go.mod h1:2g3dUjoS6AL4huFdv6wn55WpLIDjY7ZgUR4J8HOO/XQ= +github.com/sanposhiho/wastedassign/v2 v2.0.7 h1:J+6nrY4VW+gC9xFzUc+XjPD3g3wF3je/NsJFwFK7Uxc= +github.com/sanposhiho/wastedassign/v2 v2.0.7/go.mod h1:KyZ0MWTwxxBmfwn33zh3k1dmsbF2ud9pAAGfoLfjhtI= +github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 h1:lZUw3E0/J3roVtGQ+SCrUrg3ON6NgVqpn3+iol9aGu4= +github.com/santhosh-tekuri/jsonschema/v5 v5.3.1/go.mod h1:uToXkOrWAZ6/Oc07xWQrPOhJotwFIyu2bBVN41fcDUY= +github.com/sashamelentyev/interfacebloat v1.1.0 h1:xdRdJp0irL086OyW1H/RTZTr1h/tMEOsumirXcOJqAw= +github.com/sashamelentyev/interfacebloat v1.1.0/go.mod h1:+Y9yU5YdTkrNvoX0xHc84dxiN1iBi9+G8zZIhPVoNjQ= +github.com/sashamelentyev/usestdlibvars v1.27.0 h1:t/3jZpSXtRPRf2xr0m63i32ZrusyurIGT9E5wAvXQnI= +github.com/sashamelentyev/usestdlibvars v1.27.0/go.mod h1:9nl0jgOfHKWNFS43Ojw0i7aRoS4j6EBye3YBhmAIRF8= +github.com/securego/gosec/v2 v2.21.2 h1:deZp5zmYf3TWwU7A7cR2+SolbTpZ3HQiwFqnzQyEl3M= +github.com/securego/gosec/v2 v2.21.2/go.mod h1:au33kg78rNseF5PwPnTWhuYBFf534bvJRvOrgZ/bFzU= +github.com/shazow/go-diff v0.0.0-20160112020656-b6b7b6733b8c h1:W65qqJCIOVP4jpqPQ0YvHYKwcMEMVWIzWC5iNQQfBTU= +github.com/shazow/go-diff v0.0.0-20160112020656-b6b7b6733b8c/go.mod h1:/PevMnwAxekIXwN8qQyfc5gl2NlkB3CQlkizAbOkeBs= +github.com/shurcooL/go v0.0.0-20180423040247-9e1955d9fb6e/go.mod h1:TDJrrUr11Vxrven61rcy3hJMUqaf/CLWYhHNPmT14Lk= +github.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041/go.mod h1:N5mDOmsrJOB+vfqUK+7DmDyjhSLIIBnXo9lvZJj3MWQ= +github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= +github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= +github.com/sivchari/containedctx v1.0.3 h1:x+etemjbsh2fB5ewm5FeLNi5bUjK0V8n0RB+Wwfd0XE= +github.com/sivchari/containedctx v1.0.3/go.mod h1:c1RDvCbnJLtH4lLcYD/GqwiBSSf4F5Qk0xld2rBqzJ4= +github.com/sivchari/tenv v1.10.0 h1:g/hzMA+dBCKqGXgW8AV/1xIWhAvDrx0zFKNR48NFMg0= +github.com/sivchari/tenv v1.10.0/go.mod h1:tdY24masnVoZFxYrHv/nD6Tc8FbkEtAQEEziXpyMgqY= +github.com/sonatard/noctx v0.0.2 h1:L7Dz4De2zDQhW8S0t+KUjY0MAQJd6SgVwhzNIc4ok00= +github.com/sonatard/noctx v0.0.2/go.mod h1:kzFz+CzWSjQ2OzIm46uJZoXuBpa2+0y3T36U18dWqIo= +github.com/sourcegraph/go-diff v0.7.0 h1:9uLlrd5T46OXs5qpp8L/MTltk0zikUGi0sNNyCpA8G0= +github.com/sourcegraph/go-diff v0.7.0/go.mod h1:iBszgVvyxdc8SFZ7gm69go2KDdt3ag071iBaWPF6cjs= +github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72 h1:qLC7fQah7D6K1B0ujays3HV9gkFtllcxhzImRR7ArPQ= +github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= +github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8= +github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY= +github.com/spf13/cast v1.5.0 h1:rj3WzYc11XZaIZMPKmwP96zkFEnnAmV8s6XbB2aY32w= +github.com/spf13/cast v1.5.0/go.mod h1:SpXXQ5YoyJw6s3/6cMTQuxvgRl3PCJiyaX9p6b155UU= +github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM= +github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y= +github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk= +github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= +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.15.0 h1:js3yy885G8xwJa6iOISGFwd+qlUo5AvyXb7CiihdtiU= +github.com/spf13/viper v1.15.0/go.mod h1:fFcTBJxvhhzSJiZy8n+PeW6t8l+KeT/uTARa0jHOQLA= +github.com/ssgreg/nlreturn/v2 v2.2.1 h1:X4XDI7jstt3ySqGU86YGAURbxw3oTDPK9sPEi6YEwQ0= +github.com/ssgreg/nlreturn/v2 v2.2.1/go.mod h1:E/iiPB78hV7Szg2YfRgyIrk1AD6JVMTRkkxBiELzh2I= +github.com/stbenjam/no-sprintf-host-port v0.1.1 h1:tYugd/yrm1O0dV+ThCbaKZh195Dfm07ysF0U6JQXczc= +github.com/stbenjam/no-sprintf-host-port v0.1.1/go.mod h1:TLhvtIvONRzdmkFiio4O8LHsN9N74I+PhRquPsxpL0I= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/testify v0.0.0-20170130113145-4d4bfba8f1d1/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/subosito/gotenv v1.4.2 h1:X1TuBLAMDFbaTAChgCBLu3DU3UPyELpnF2jjJ2cz/S8= +github.com/subosito/gotenv v1.4.2/go.mod h1:ayKnFf/c6rvx/2iiLrJUk1e6plDbT3edrFNGqEflhK0= +github.com/tdakkota/asciicheck v0.2.0 h1:o8jvnUANo0qXtnslk2d3nMKTFNlOnJjRrNcj0j9qkHM= +github.com/tdakkota/asciicheck v0.2.0/go.mod h1:Qb7Y9EgjCLJGup51gDHFzbI08/gbGhL/UVhYIPWG2rg= +github.com/tenntenn/modver v1.0.1 h1:2klLppGhDgzJrScMpkj9Ujy3rXPUspSjAcev9tSEBgA= +github.com/tenntenn/modver v1.0.1/go.mod h1:bePIyQPb7UeioSRkw3Q0XeMhYZSMx9B8ePqg6SAMGH0= +github.com/tenntenn/text/transform v0.0.0-20200319021203-7eef512accb3 h1:f+jULpRQGxTSkNYKJ51yaw6ChIqO+Je8UqsTKN/cDag= +github.com/tenntenn/text/transform v0.0.0-20200319021203-7eef512accb3/go.mod h1:ON8b8w4BN/kE1EOhwT0o+d62W65a6aPw1nouo9LMgyY= +github.com/tetafro/godot v1.4.17 h1:pGzu+Ye7ZUEFx7LHU0dAKmCOXWsPjl7qA6iMGndsjPs= +github.com/tetafro/godot v1.4.17/go.mod h1:2oVxTBSftRTh4+MVfUaUXR6bn2GDXCaMcOG4Dk3rfio= +github.com/timakin/bodyclose v0.0.0-20230421092635-574207250966 h1:quvGphlmUVU+nhpFa4gg4yJyTRJ13reZMDHrKwYw53M= +github.com/timakin/bodyclose v0.0.0-20230421092635-574207250966/go.mod h1:27bSVNWSBOHm+qRp1T9qzaIpsWEP6TbUnei/43HK+PQ= +github.com/timonwong/loggercheck v0.9.4 h1:HKKhqrjcVj8sxL7K77beXh0adEm6DLjV/QOGeMXEVi4= +github.com/timonwong/loggercheck v0.9.4/go.mod h1:caz4zlPcgvpEkXgVnAJGowHAMW2NwHaNlpS8xDbVhTg= +github.com/tomarrell/wrapcheck/v2 v2.9.0 h1:801U2YCAjLhdN8zhZ/7tdjB3EnAoRlJHt/s+9hijLQ4= +github.com/tomarrell/wrapcheck/v2 v2.9.0/go.mod h1:g9vNIyhb5/9TQgumxQyOEqDHsmGYcGsVMOx/xGkqdMo= +github.com/tommy-muehle/go-mnd/v2 v2.5.1 h1:NowYhSdyE/1zwK9QCLeRb6USWdoif80Ie+v+yU8u1Zw= +github.com/tommy-muehle/go-mnd/v2 v2.5.1/go.mod h1:WsUAkMJMYww6l/ufffCD3m+P7LEvr8TnZn9lwVDlgzw= +github.com/ultraware/funlen v0.1.0 h1:BuqclbkY6pO+cvxoq7OsktIXZpgBSkYTQtmwhAK81vI= +github.com/ultraware/funlen v0.1.0/go.mod h1:XJqmOQja6DpxarLj6Jj1U7JuoS8PvL4nEqDaQhy22p4= +github.com/ultraware/whitespace v0.1.1 h1:bTPOGejYFulW3PkcrqkeQwOd6NKOOXvmGD9bo/Gk8VQ= +github.com/ultraware/whitespace v0.1.1/go.mod h1:XcP1RLD81eV4BW8UhQlpaR+SDc2givTvyI8a586WjW8= +github.com/uudashr/gocognit v1.1.3 h1:l+a111VcDbKfynh+airAy/DJQKaXh2m9vkoysMPSZyM= +github.com/uudashr/gocognit v1.1.3/go.mod h1:aKH8/e8xbTRBwjbCkwZ8qt4l2EpKXl31KMHgSS+lZ2U= +github.com/vektra/mockery/v2 v2.52.1 h1:ejpWJSsInVNsFUvaAX4szecrpYxErN+Ny5X+0RXBP+s= +github.com/vektra/mockery/v2 v2.52.1/go.mod h1:ZJeus9igl4Uf8FGLwXZgtCnp2XUDFD9Mkipi7nsObq0= +github.com/xen0n/gosmopolitan v1.2.2 h1:/p2KTnMzwRexIW8GlKawsTWOxn7UHA+jCMF/V8HHtvU= +github.com/xen0n/gosmopolitan v1.2.2/go.mod h1:7XX7Mj61uLYrj0qmeN0zi7XDon9JRAEhYQqAPLVNTeg= +github.com/yagipy/maintidx v1.0.0 h1:h5NvIsCz+nRDapQ0exNv4aJ0yXSI0420omVANTv3GJM= +github.com/yagipy/maintidx v1.0.0/go.mod h1:0qNf/I/CCZXSMhsRsrEPDZ+DkekpKLXAJfsTACwgXLk= +github.com/yeya24/promlinter v0.3.0 h1:JVDbMp08lVCP7Y6NP3qHroGAO6z2yGKQtS5JsjqtoFs= +github.com/yeya24/promlinter v0.3.0/go.mod h1:cDfJQQYv9uYciW60QT0eeHlFodotkYZlL+YcPQN+mW4= +github.com/ykadowak/zerologlint v0.1.5 h1:Gy/fMz1dFQN9JZTPjv1hxEk+sRWm05row04Yoolgdiw= +github.com/ykadowak/zerologlint v0.1.5/go.mod h1:KaUskqF3e/v59oPmdq1U1DnKcuHokl2/K1U4pmIELKg= +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.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +gitlab.com/bosi/decorder v0.4.2 h1:qbQaV3zgwnBZ4zPMhGLW4KZe7A7NwxEhJx39R3shffo= +gitlab.com/bosi/decorder v0.4.2/go.mod h1:muuhHoaJkA9QLcYHq4Mj8FJUwDZ+EirSHRiaTcTf6T8= +go-simpler.org/assert v0.9.0 h1:PfpmcSvL7yAnWyChSjOz6Sp6m9j5lyK8Ok9pEL31YkQ= +go-simpler.org/assert v0.9.0/go.mod h1:74Eqh5eI6vCK6Y5l3PI8ZYFXG4Sa+tkr70OIPJAUr28= +go-simpler.org/musttag v0.12.2 h1:J7lRc2ysXOq7eM8rwaTYnNrHd5JwjppzB6mScysB2Cs= +go-simpler.org/musttag v0.12.2/go.mod h1:uN1DVIasMTQKk6XSik7yrJoEysGtR2GRqvWnI9S7TYM= +go-simpler.org/sloglint v0.7.2 h1:Wc9Em/Zeuu7JYpl+oKoYOsQSy2X560aVueCW/m6IijY= +go-simpler.org/sloglint v0.7.2/go.mod h1:US+9C80ppl7VsThQclkM7BkCHQAzuz8kHLsW3ppuluo= +go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0= +go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.54.0 h1:r6I7RJCN86bpD/FQwedZ0vSixDpwuWREjW9oRMsmqDc= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.54.0/go.mod h1:B9yO6b04uB80CzjedvewuqDhxJxi11s7/GtiGa8bAjI= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0 h1:TT4fX+nBOA/+LUkobKGW1ydGcn+G3vRw9+g5HwCphpk= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0/go.mod h1:L7UH0GbB0p47T4Rri3uHjbpCFYrVrwc1I25QhNPiGK8= +go.opentelemetry.io/otel v1.29.0 h1:PdomN/Al4q/lN6iBJEN3AwPvUiHPMlt93c8bqTG5Llw= +go.opentelemetry.io/otel v1.29.0/go.mod h1:N/WtXPs1CNCUEx+Agz5uouwCba+i+bJGFicT8SR4NP8= +go.opentelemetry.io/otel/exporters/jaeger v1.17.0 h1:D7UpUy2Xc2wsi1Ras6V40q806WM07rqoCWzXu7Sqy+4= +go.opentelemetry.io/otel/exporters/jaeger v1.17.0/go.mod h1:nPCqOnEH9rNLKqH/+rrUjiMzHJdV1BlpKcTwRTyKkKI= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.19.0 h1:Nw7Dv4lwvGrI68+wULbcq7su9K2cebeCUrDjVrUJHxM= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.19.0/go.mod h1:1MsF6Y7gTqosgoZvHlzcaaM8DIMNZgJh87ykokoNH7Y= +go.opentelemetry.io/otel/metric v1.29.0 h1:vPf/HFWTNkPu1aYeIsc98l4ktOQaL6LeSoeV2g+8YLc= +go.opentelemetry.io/otel/metric v1.29.0/go.mod h1:auu/QWieFVWx+DmQOUMgj0F8LHWdgalxXqvp7BII/W8= +go.opentelemetry.io/otel/sdk v1.28.0 h1:b9d7hIry8yZsgtbmM0DKyPWMMUMlK9NEKuIG4aBqWyE= +go.opentelemetry.io/otel/sdk v1.28.0/go.mod h1:oYj7ClPUA7Iw3m+r7GeEjz0qckQRJK2B8zjcZEfu7Pg= +go.opentelemetry.io/otel/trace v1.29.0 h1:J/8ZNK4XgR7a21DZUAsbF8pZ5Jcw1VhACmnYt39JTi4= +go.opentelemetry.io/otel/trace v1.29.0/go.mod h1:eHl3w0sp3paPkYstJOmAimxhiFXPg+MMTlEh3nsQgWQ= +go.uber.org/automaxprocs v1.5.3 h1:kWazyxZUrS3Gs4qUpbwo5kEIMGe/DAvi5Z4tl2NW4j8= +go.uber.org/automaxprocs v1.5.3/go.mod h1:eRbA25aqJrxAbsLO0xy5jVwPt7FQnRgjW+efnwa1WM0= +go.uber.org/goleak v1.2.1 h1:NBol2c7O1ZokfZ0LEU9K6Whx/KnwvepVetCUhtKja4A= +go.uber.org/goleak v1.2.1/go.mod h1:qlT2yGI9QafXHhZZLxlSuNsMw3FFLxBr+tBRlmO1xH4= +go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= +go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= +go.uber.org/zap v1.25.0 h1:4Hvk6GtkucQ790dqmj7l1eEnRdKm3k3ZUrUMS2d5+5c= +go.uber.org/zap v1.25.0/go.mod h1:JIAUzQIH94IC4fOJQm7gMmBJP5k7wQfdcnYdPoEXJYk= +golang.org/x/crypto v0.0.0-20180501155221-613d6eafa307/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-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-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw= +golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34= +golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc= +golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20240904232852-e7e105dedf7e h1:I88y4caeGeuDQxgdoFPUq097j7kNfw6uvuiNxUBfcBk= +golang.org/x/exp v0.0.0-20240904232852-e7e105dedf7e/go.mod h1:akd2r19cwCdwSwWeIdzYQGa/EZZyqcOdwWiwj5L5eKQ= +golang.org/x/exp/typeparams v0.0.0-20220428152302-39d4317da171/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk= +golang.org/x/exp/typeparams v0.0.0-20230203172020-98cc5a0785f9/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk= +golang.org/x/exp/typeparams v0.0.0-20240314144324-c7f7c6466f7f h1:phY1HzDcf18Aq9A8KkmRtY9WvOFIxN8wgfvy6Zm1DV8= +golang.org/x/exp/typeparams v0.0.0-20240314144324-c7f7c6466f7f/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk= +golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= +golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +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.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= +golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3/go.mod h1:3p9vT2HGsQu2K1YbXdKPJLVgG5VJdoTa1poYQBtP1AY= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.6.0/go.mod h1:4mET923SAdbXp2ki8ey+zGs1SLqsuM2Y0uvdZR/fUNI= +golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.21.0 h1:vvrHzRwRfVKSiLrG+d4FMl/Qi4ukBCE6kZlTUkDYRT0= +golang.org/x/mod v0.21.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY= +golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/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-20200625001655-4c5254603344/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-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco= +golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY= +golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.38.0 h1:vRMAPTMaeGqVhG5QyLJHqNDwecKTomGeqbnfZyKlBI8= +golang.org/x/net v0.38.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8= +golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= +golang.org/x/oauth2 v0.27.0 h1:da9Vo7/tDv5RH/7nZDz1eMGS/q1Vv1N/7FCrBhI9I3M= +golang.org/x/oauth2 v0.27.0/go.mod h1:onh5ek6nERTohokkhCD/y2cV4Do3fxFHFuAejCkRWT8= +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-20190412183630-56d357773e84/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-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-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw= +golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/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-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/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-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-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-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211105183446-c75c47738b0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik= +golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc= +golang.org/x/term v0.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/term v0.30.0 h1:PQ39fJZ+mfadBm0y5WlL4vlM7Sx1Hgf13sMIY2+QS9Y= +golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g= +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/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY= +golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4= +golang.org/x/time v0.6.0 h1:eTDhh4ZXt5Qf0augr54TN6suAUudPcawVZeIAPU7D4U= +golang.org/x/time v0.6.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= +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= +golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190321232350-e250d351ecad/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190524210228-3d17549cdc6b/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190910044552-dd2b5c81c578/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200324003944-a576cf524670/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= +golang.org/x/tools v0.0.0-20200329025819-fd4102a86c65/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200724022722-7017fd6b1305/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200820010801-b793a1359eac/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20201023174141-c8cfbd0f21e6/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= +golang.org/x/tools v0.1.1-0.20210205202024-ef80cdb6ec6d/go.mod h1:9bzcO0MWcOuT0tm1iBGzDVPshzfwoVvREIui8C+MHqU= +golang.org/x/tools v0.1.1-0.20210302220138-2ac05c832e1a/go.mod h1:9bzcO0MWcOuT0tm1iBGzDVPshzfwoVvREIui8C+MHqU= +golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.9/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= +golang.org/x/tools v0.1.10/go.mod h1:Uh6Zz+xoGYZom868N8YTex3t7RhtHDBrE8Gzo9bV56E= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.2.0/go.mod h1:y4OqIKeOV/fWJetJ8bXPU1sEVniLMIyDAZWeHdV+NTA= +golang.org/x/tools v0.3.0/go.mod h1:/rWhSS2+zyEVwoJf8YAX6L2f0ntZ7Kn/mGgAWcipA5k= +golang.org/x/tools v0.5.0/go.mod h1:N+Kgy78s5I24c24dU8OfWNEotWjutIs8SnJvn5IDq+k= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +golang.org/x/tools v0.24.0 h1:J1shsA93PJUEVaUSaay7UXAyE8aimq3GW0pjlolpa24= +golang.org/x/tools v0.24.0/go.mod h1:YhNqVBIfWHdzvTLs0d8LCuMhkKUgSUKldakyV7W/WDQ= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +gomodules.xyz/jsonpatch/v2 v2.4.0 h1:Ci3iUJyx9UeRx7CeFN8ARgGbkESwJK+KB9lLcWxY/Zw= +gomodules.xyz/jsonpatch/v2 v2.4.0/go.mod h1:AH3dM2RI6uoBZxn3LVrfvJ3E0/9dG4cSrbuBJT4moAY= +google.golang.org/api v0.196.0 h1:k/RafYqebaIJBO3+SMnfEGtFVlvp5vSgqTUF54UN/zg= +google.golang.org/api v0.196.0/go.mod h1:g9IL21uGkYgvQ5BZg6BAtoGJQIm8r6EgaAbpNey5wBE= +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/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/genproto v0.0.0-20181107211654-5fc9ac540362/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= +google.golang.org/genproto v0.0.0-20240903143218-8af14fe29dc1 h1:BulPr26Jqjnd4eYDVe+YvyR7Yc2vJGkO5/0UxD0/jZU= +google.golang.org/genproto v0.0.0-20240903143218-8af14fe29dc1/go.mod h1:hL97c3SYopEHblzpxRL4lSs523++l8DYxGM1FQiYmb4= +google.golang.org/genproto/googleapis/api v0.0.0-20240827150818-7e3bb234dfed h1:3RgNmBoI9MZhsj3QxC+AP/qQhNwpCLOvYDYYsFrhFt0= +google.golang.org/genproto/googleapis/api v0.0.0-20240827150818-7e3bb234dfed/go.mod h1:OCdP9MfskevB/rbYvHTsXTtKC+3bHWajPdoKgjcYkfo= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1 h1:pPJltXNxVzT4pK9yD8vR9X75DaWYYmLGMsEvBfFQZzQ= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= +google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= +google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= +google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= +google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= +google.golang.org/grpc v1.66.0 h1:DibZuoBznOxbDQxRINckZcUvnCEvrW9pcWIE2yF9r1c= +google.golang.org/grpc v1.66.0/go.mod h1:s3/l6xSSCURdVfAnL+TqCNMyTDAGN6+lZeVxnZR128Y= +google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= +google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= +google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= +google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= +google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= +google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg= +google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/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.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= +gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +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= +honnef.co/go/tools v0.5.1 h1:4bH5o3b5ZULQ4UrBmP+63W9r7qIkqJClEA9ko5YKx+I= +honnef.co/go/tools v0.5.1/go.mod h1:e9irvo83WDG9/irijV44wr3tbhcFeRnfpVlRqVwpzMs= +k8s.io/api v0.28.2 h1:9mpl5mOb6vXZvqbQmankOfPIGiudghwCoLl1EYfUZbw= +k8s.io/api v0.28.2/go.mod h1:RVnJBsjU8tcMq7C3iaRSGMeaKt2TWEUXcpIt/90fjEg= +k8s.io/apiextensions-apiserver v0.28.0 h1:CszgmBL8CizEnj4sj7/PtLGey6Na3YgWyGCPONv7E9E= +k8s.io/apiextensions-apiserver v0.28.0/go.mod h1:uRdYiwIuu0SyqJKriKmqEN2jThIJPhVmOWETm8ud1VE= +k8s.io/apimachinery v0.28.2 h1:KCOJLrc6gu+wV1BYgwik4AF4vXOlVJPdiqn0yAWWwXQ= +k8s.io/apimachinery v0.28.2/go.mod h1:RdzF87y/ngqk9H4z3EL2Rppv5jj95vGS/HaFXrLDApU= +k8s.io/client-go v0.28.1 h1:pRhMzB8HyLfVwpngWKE8hDcXRqifh1ga2Z/PU9SXVK8= +k8s.io/client-go v0.28.1/go.mod h1:pEZA3FqOsVkCc07pFVzK076R+P/eXqsgx5zuuRWukNE= +k8s.io/component-base v0.28.1 h1:LA4AujMlK2mr0tZbQDZkjWbdhTV5bRyEyAFe0TJxlWg= +k8s.io/component-base v0.28.1/go.mod h1:jI11OyhbX21Qtbav7JkhehyBsIRfnO8oEgoAR12ArIU= +k8s.io/klog/v2 v2.100.1 h1:7WCHKK6K8fNhTqfBhISHQ97KrnJNFZMcQvKp7gP/tmg= +k8s.io/klog/v2 v2.100.1/go.mod h1:y1WjHnz7Dj687irZUWR/WLkLc5N1YHtjLdmgWjndZn0= +k8s.io/kube-openapi v0.0.0-20230717233707-2695361300d9 h1:LyMgNKD2P8Wn1iAwQU5OhxCKlKJy0sHc+PcDwFB24dQ= +k8s.io/kube-openapi v0.0.0-20230717233707-2695361300d9/go.mod h1:wZK2AVp1uHCp4VamDVgBP2COHZjqD1T68Rf0CM3YjSM= +k8s.io/utils v0.0.0-20230406110748-d93618cff8a2 h1:qY1Ad8PODbnymg2pRbkyMT/ylpTrCM8P2RJ0yroCyIk= +k8s.io/utils v0.0.0-20230406110748-d93618cff8a2/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0= +mvdan.cc/gofumpt v0.7.0 h1:bg91ttqXmi9y2xawvkuMXyvAA/1ZGJqYAEGjXuP0JXU= +mvdan.cc/gofumpt v0.7.0/go.mod h1:txVFJy/Sc/mvaycET54pV8SW8gWxTlUuGHVEcncmNUo= +mvdan.cc/unparam v0.0.0-20240528143540-8a5130ca722f h1:lMpcwN6GxNbWtbpI1+xzFLSW8XzX0u72NttUGVFjO3U= +mvdan.cc/unparam v0.0.0-20240528143540-8a5130ca722f/go.mod h1:RSLa7mKKCNeTTMHBw5Hsy2rfJmd6O2ivt9Dw9ZqCQpQ= +sigs.k8s.io/controller-runtime v0.16.2 h1:mwXAVuEk3EQf478PQwQ48zGOXvW27UJc8NHktQVuIPU= +sigs.k8s.io/controller-runtime v0.16.2/go.mod h1:vpMu3LpI5sYWtujJOa2uPK61nB5rbwlN7BAB8aSLvGU= +sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd h1:EDPBXCAspyGV4jQlpZSudPeMmr1bNJefnuqLsRAsHZo= +sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd/go.mod h1:B8JuhiUyNFVKdsE8h686QcCxMaH6HrOAZj4vswFpcB0= +sigs.k8s.io/structured-merge-diff/v4 v4.2.3 h1:PRbqxJClWWYMNV1dhaG4NsibJbArud9kFxnAMREiWFE= +sigs.k8s.io/structured-merge-diff/v4 v4.2.3/go.mod h1:qjx8mGObPmV2aSZepjQjbmb2ihdVs8cGKBraizNC69E= +sigs.k8s.io/yaml v1.3.0 h1:a2VclLzOGrwOHDiV8EfBGhvjHvP46CtW5j6POvhYGGo= +sigs.k8s.io/yaml v1.3.0/go.mod h1:GeOyir5tyXNByN85N/dRIT9es5UQNerPYEKK56eTBm8= diff --git a/boilerplate/flyte/golang_support_tools/tools.go b/boilerplate/flyte/golang_support_tools/tools.go new file mode 100644 index 0000000000..4ff02ff238 --- /dev/null +++ b/boilerplate/flyte/golang_support_tools/tools.go @@ -0,0 +1,13 @@ +//go:build tools +// +build tools + +package tools + +import ( + _ "github.com/vektra/mockery/v2/cmd" + _ "github.com/alvaroloes/enumer" + _ "github.com/golangci/golangci-lint/cmd/golangci-lint" + _ "github.com/pseudomuto/protoc-gen-doc/cmd/protoc-gen-doc" + + _ "github.com/flyteorg/flyte/flytestdlib/cli/pflags" +) diff --git a/boilerplate/flyte/golang_test_targets/Makefile b/boilerplate/flyte/golang_test_targets/Makefile new file mode 100644 index 0000000000..6492014917 --- /dev/null +++ b/boilerplate/flyte/golang_test_targets/Makefile @@ -0,0 +1,59 @@ +# WARNING: THIS FILE IS MANAGED IN THE 'BOILERPLATE' REPO AND COPIED TO OTHER REPOSITORIES. +# ONLY EDIT THIS FILE FROM WITHIN THE 'FLYTEORG/BOILERPLATE' REPOSITORY: +# +# TO OPT OUT OF UPDATES, SEE https://github.com/flyteorg/boilerplate/blob/master/Readme.rst + +LINT_FLAGS ?= + +.PHONY: download_tooling +download_tooling: #download dependencies (including test deps) for the package + @../boilerplate/flyte/golang_test_targets/download_tooling.sh + +.PHONY: generate +generate: download_tooling #generate go code + @../boilerplate/flyte/golang_test_targets/go-gen.sh + +.PHONY: lint +lint: download_tooling #lints the package for common code smells + GL_DEBUG=linters_output,env golangci-lint run $(LINT_FLAGS) --timeout=5m --exclude deprecated -v + +.PHONY: lint-fix +lint-fix: LINT_FLAGS=--fix +lint-fix: lint + +.PHONY: mod_download +mod_download: #download dependencies (including test deps) for the package + go mod download + +.PHONY: install +install: download_tooling mod_download + +.PHONY: show +show: + go list -m all + +.PHONY: test_unit +test_unit: + go test -cover ./... -race + +.PHONY: test_benchmark +test_benchmark: + go test -bench . ./... + +.PHONY: test_unit_cover +test_unit_cover: + go test ./... -coverprofile /tmp/cover.out -covermode=count + go tool cover -func /tmp/cover.out + +.PHONY: test_unit_visual +test_unit_visual: + go test ./... -coverprofile /tmp/cover.out -covermode=count + go tool cover -html=/tmp/cover.out + +.PHONY: test_unit_codecov +test_unit_codecov: + go test ./... -race -coverprofile=coverage.txt -covermode=atomic + +.PHONY: go-tidy +go-tidy: + go mod tidy diff --git a/boilerplate/flyte/golang_test_targets/Readme.rst b/boilerplate/flyte/golang_test_targets/Readme.rst new file mode 100644 index 0000000000..700feb33a2 --- /dev/null +++ b/boilerplate/flyte/golang_test_targets/Readme.rst @@ -0,0 +1,33 @@ +Golang Test Targets +~~~~~~~~~~~~~~~~~~~ + +Provides an ``install`` make target that uses ``go mod`` to install golang dependencies. + +Provides a ``lint`` make target that uses golangci to lint your code. + +Provides a ``lint-fix`` make target that uses golangci to lint and fix your code in place. + +Provides a ``test_unit`` target for unit tests. + +Provides a ``test_unit_cover`` target for analysing coverage of unit tests, which will output the coverage of each function and total statement coverage. + +Provides a ``test_unit_visual`` target for visualizing coverage of unit tests through an interactive html code heat map. + +Provides a ``test_benchmark`` target for benchmark tests. + +**To Enable:** + +Add ``flyteorg/golang_test_targets`` to your ``boilerplate/update.cfg`` file. + +Make sure you're using ``go mod`` for dependency management. + +Provide a ``.golangci`` configuration (the lint target requires it). + +Add ``include boilerplate/flyte/golang_test_targets/Makefile`` in your main ``Makefile`` _after_ your REPOSITORY environment variable + +:: + + REPOSITORY= + include boilerplate/flyte/golang_test_targets/Makefile + +(this ensures the extra make targets get included in your main Makefile) diff --git a/boilerplate/flyte/golang_test_targets/download_tooling.sh b/boilerplate/flyte/golang_test_targets/download_tooling.sh new file mode 100755 index 0000000000..1aa4c15010 --- /dev/null +++ b/boilerplate/flyte/golang_test_targets/download_tooling.sh @@ -0,0 +1,42 @@ +#!/bin/bash + +# Everything in this file needs to be installed outside of current module +# The reason we cannot turn off module entirely and install is that we need the replace statement in go.mod +# because we are installing a mockery fork. Turning it off would result installing the original not the fork. +# We also want to version all the other tools. We also want to be able to run go mod tidy without removing the version +# pins. To facilitate this, we're maintaining two sets of go.mod/sum files - the second one only for tooling. This is +# the same approach that go 1.14 will take as well. +# See: +# https://github.com/flyteorg/flyte/issues/129 +# https://github.com/golang/go/issues/30515 for some background context +# https://github.com/go-modules-by-example/index/blob/5ec250b4b78114a55001bd7c9cb88f6e07270ea5/010_tools/README.md + +set -e + +# List of tools to go get +# In the format of ":" or ":" if no cli +tools=( + "github.com/vektra/mockery/v2@v2.52.1" + "github.com/golangci/golangci-lint/cmd/golangci-lint" + "github.com/daixiang0/gci" + "github.com/alvaroloes/enumer" + "github.com/pseudomuto/protoc-gen-doc/cmd/protoc-gen-doc" +) + +# This ensures pflags are up to date. +make -C "${REPO_ROOT}/flytestdlib" compile +GO_BIN="$(go env GOPATH)/bin" +mkdir -p "${GO_BIN}" +cp "${REPO_ROOT}/flytestdlib/bin/pflags" "${GO_BIN}" + +tmp_dir="$(mktemp -d -t gotooling-XXX)" +echo "Using temp directory ${tmp_dir}" +cp -R ../boilerplate/flyte/golang_support_tools/* "${tmp_dir}" +pushd "${tmp_dir}" + +for tool in "${tools[@]}"; do + echo "Installing ${tool}" + GO111MODULE=on go install "${tool}" +done + +popd diff --git a/boilerplate/flyte/golang_test_targets/go-gen.sh b/boilerplate/flyte/golang_test_targets/go-gen.sh new file mode 100755 index 0000000000..b954df0b14 --- /dev/null +++ b/boilerplate/flyte/golang_test_targets/go-gen.sh @@ -0,0 +1,22 @@ +#!/usr/bin/env bash + +set -ex + +echo "Running go generate" +go generate ./... +go mod tidy +# This section is used by GitHub workflow to ensure that the generation step was run +if [ -n "$DELTA_CHECK" ]; then + DIRTY=$(git status --porcelain) + if [ -n "$DIRTY" ]; then + echo "FAILED: Go code updated without committing generated code." + echo "Ensure make generate has run and all changes are committed." + DIFF=$(git diff) + echo "diff detected: $DIFF" + DIFF=$(git diff --name-only) + echo "files different: $DIFF" + exit 1 + else + echo "SUCCESS: Generated code is up to date." + fi +fi diff --git a/boilerplate/flyte/golangci_file/.golangci.yml b/boilerplate/flyte/golangci_file/.golangci.yml new file mode 100644 index 0000000000..7f4dbc80e8 --- /dev/null +++ b/boilerplate/flyte/golangci_file/.golangci.yml @@ -0,0 +1,40 @@ +# WARNING: THIS FILE IS MANAGED IN THE 'BOILERPLATE' REPO AND COPIED TO OTHER REPOSITORIES. +# ONLY EDIT THIS FILE FROM WITHIN THE 'FLYTEORG/BOILERPLATE' REPOSITORY: +# +# TO OPT OUT OF UPDATES, SEE https://github.com/flyteorg/boilerplate/blob/master/Readme.rst + +run: + skip-dirs: + - pkg/client + +linters: + disable-all: true + enable: + - deadcode + - errcheck + - gas + - gci + - goconst + - goimports + - golint + - gosimple + - govet + - ineffassign + - misspell + - nakedret + - staticcheck + - structcheck + - typecheck + - unconvert + - unparam + - unused + - varcheck + +linters-settings: + gci: + custom-order: true + sections: + - standard + - default + - prefix(github.com/flyteorg) + skip-generated: true diff --git a/boilerplate/flyte/golangci_file/Readme.rst b/boilerplate/flyte/golangci_file/Readme.rst new file mode 100644 index 0000000000..e4cbd18b96 --- /dev/null +++ b/boilerplate/flyte/golangci_file/Readme.rst @@ -0,0 +1,8 @@ +GolangCI File +~~~~~~~~~~~~~ + +Provides a ``.golangci`` file with the linters we've agreed upon. + +**To Enable:** + +Add ``flyteorg/golangci_file`` to your ``boilerplate/update.cfg`` file. diff --git a/boilerplate/flyte/golangci_file/update.sh b/boilerplate/flyte/golangci_file/update.sh new file mode 100755 index 0000000000..ab2f85c680 --- /dev/null +++ b/boilerplate/flyte/golangci_file/update.sh @@ -0,0 +1,14 @@ +#!/usr/bin/env bash + +# WARNING: THIS FILE IS MANAGED IN THE 'BOILERPLATE' REPO AND COPIED TO OTHER REPOSITORIES. +# ONLY EDIT THIS FILE FROM WITHIN THE 'FLYTEORG/BOILERPLATE' REPOSITORY: +# +# TO OPT OUT OF UPDATES, SEE https://github.com/flyteorg/boilerplate/blob/master/Readme.rst + +set -e + +DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && pwd )" + +# Clone the .golangci file +echo " - copying ${DIR}/.golangci to the root directory." +cp ${DIR}/.golangci.yml ${DIR}/../../../.golangci.yml diff --git a/boilerplate/flyte/precommit/Makefile b/boilerplate/flyte/precommit/Makefile new file mode 100644 index 0000000000..3c6f17d6b2 --- /dev/null +++ b/boilerplate/flyte/precommit/Makefile @@ -0,0 +1,9 @@ +# WARNING: THIS FILE IS MANAGED IN THE 'BOILERPLATE' REPO AND COPIED TO OTHER REPOSITORIES. +# ONLY EDIT THIS FILE FROM WITHIN THE 'FLYTEORG/BOILERPLATE' REPOSITORY: +# +# TO OPT OUT OF UPDATES, SEE https://github.com/flyteorg/boilerplate/blob/master/Readme.rst + + +.PHONY: setup-precommit +setup-precommit: #setup the precommit + @boilerplate/flyte/precommit/update.sh diff --git a/boilerplate/flyte/precommit/hooks/pre-push b/boilerplate/flyte/precommit/hooks/pre-push new file mode 100755 index 0000000000..f161cfe856 --- /dev/null +++ b/boilerplate/flyte/precommit/hooks/pre-push @@ -0,0 +1,41 @@ +DUMMY_SHA=0000000000000000000000000000000000000000 + +echo "Running pre-push check; to skip this step use 'push --no-verify'" + +while read LOCAL_REF LOCAL_SHA REMOTE_REF REMOTE_SHA +do + if [ "$LOCAL_SHA" = $DUMMY_SHA ] + then + # Branch deleted. Do nothing. + exit 0 + else + if [ "$REMOTE_SHA" = $DUMMY_SHA ] + then + # New branch. Verify the last commit, since this is very likely where the new code is + # (though there is no way to know for sure). In the extremely uncommon case in which someone + # pushes more than 1 new commit to a branch, CI will enforce full checking. + RANGE="$LOCAL_SHA~1..$LOCAL_SHA" + else + # Updating branch. Verify new commits. + RANGE="$REMOTE_SHA..$LOCAL_SHA" + fi + + # Verify DCO signoff. We do this before the format checker, since it has + # some probability of failing spuriously, while this check never should. + # + # In general, we can't assume that the commits are signed off by author + # pushing, so we settle for just checking that there is a signoff at all. + SIGNED_OFF=$(git rev-list --no-merges --grep "^Signed-off-by: " "$RANGE") + NOT_SIGNED_OFF=$(git rev-list --no-merges "$RANGE" | grep -Fxv "$SIGNED_OFF") + if [ -n "$NOT_SIGNED_OFF" ] + then + echo >&2 "ERROR: The following commits do not have DCO signoff:" + while read -r commit; do + echo " $(git log --pretty=oneline --abbrev-commit -n 1 $commit)" + done <<< "$NOT_SIGNED_OFF" + exit 1 + fi + fi +done + +exit 0 diff --git a/boilerplate/flyte/precommit/hooks/prepare-commit-msg b/boilerplate/flyte/precommit/hooks/prepare-commit-msg new file mode 100755 index 0000000000..8148d104b8 --- /dev/null +++ b/boilerplate/flyte/precommit/hooks/prepare-commit-msg @@ -0,0 +1,16 @@ +# WARNING: THIS FILE IS MANAGED IN THE 'BOILERPLATE' REPO AND COPIED TO OTHER REPOSITORIES. +# ONLY EDIT THIS FILE FROM WITHIN THE 'FLYTEORG/BOILERPLATE' REPOSITORY: +# +# TO OPT OUT OF UPDATES, SEE https://github.com/flyteorg/boilerplate/blob/master/Readme.rst +# $ ln -s ../../support/hooks/prepare-commit-msg .git/hooks/prepare-commit-msg + +COMMIT_MESSAGE_FILE="$1" +AUTHOR=$(git var GIT_AUTHOR_IDENT) +SIGNOFF=$(echo $AUTHOR | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p') + +# Check for DCO signoff message. If one doesn't exist, append one and then warn +# the user that you did so. +if ! $(grep -qs "^$SIGNOFF" "$COMMIT_MESSAGE_FILE") ; then + echo "\n$SIGNOFF" >> "$COMMIT_MESSAGE_FILE" + echo "Appended the following signoff to the end of the commit message:\n $SIGNOFF\n" +fi diff --git a/boilerplate/flyte/precommit/update.sh b/boilerplate/flyte/precommit/update.sh new file mode 100755 index 0000000000..971c8386c1 --- /dev/null +++ b/boilerplate/flyte/precommit/update.sh @@ -0,0 +1,60 @@ +#!/usr/bin/env bash + +# WARNING: THIS FILE IS MANAGED IN THE 'BOILERPLATE' REPO AND COPIED TO OTHER REPOSITORIES. +# ONLY EDIT THIS FILE FROM WITHIN THE 'FLYTEORG/BOILERPLATE' REPOSITORY: +# +# TO OPT OUT OF UPDATES, SEE https://github.com/flyteorg/boilerplate/blob/master/Readme.rst + +set -e + +# Helper script for Automatically add DCO signoff with commit hooks +# Taken from Envoy https://gitlab.cncf.ci/envoyproxy/envoy +if [ ! "$PWD" == "$(git rev-parse --show-toplevel)" ]; then + cat >&2 <<__EOF__ +ERROR: this script must be run at the root of the envoy source tree +__EOF__ + exit 1 +fi + +# Helper functions that calculate `abspath` and `relpath`. Taken from Mesos +# commit 82b040a60561cf94dec3197ea88ae15e57bcaa97, which also carries the Apache +# V2 license, and has deployed this code successfully for some time. +abspath() { + cd "$(dirname "${1}")" + echo "${PWD}"/"$(basename "${1}")" + cd "${OLDPWD}" +} +relpath() { + local FROM TO UP + FROM="$(abspath "${1%/}")" TO="$(abspath "${2%/}"/)" + while test "${TO}" = "${TO#"${FROM}"/}" \ + -a "${TO}" != "${FROM}"; do + FROM="${FROM%/*}" UP="../${UP}" + done + TO="${UP%/}${TO#${FROM}}" + echo "${TO:-.}" +} + +# Try to find the `.git` directory, even if it's not in Flyte project root (as +# it wouldn't be if, say, this were in a submodule). The "blessed" but fairly +# new way to do this is to use `--git-common-dir`. +DOT_GIT_DIR=$(git rev-parse --git-common-dir) +if test ! -d "${DOT_GIT_DIR}"; then + # If `--git-common-dir` is not available, fall back to older way of doing it. + DOT_GIT_DIR=$(git rev-parse --git-dir) +fi + +mkdir -p ${DOT_GIT_DIR}/hooks + +HOOKS_DIR="${DOT_GIT_DIR}/hooks" +HOOKS_DIR_RELPATH=$(relpath "${HOOKS_DIR}" "${PWD}") + +if [ ! -e "${HOOKS_DIR}/prepare-commit-msg" ]; then + echo "Installing hook 'prepare-commit-msg'" + ln -s "${HOOKS_DIR_RELPATH}/boilerplate/flyte/precommit/hooks/prepare-commit-msg" "${HOOKS_DIR}/prepare-commit-msg" +fi + +if [ ! -e "${HOOKS_DIR}/pre-push" ]; then + echo "Installing hook 'pre-push'" + ln -s "${HOOKS_DIR_RELPATH}/boilerplate/flyte/precommit/hooks/pre-push" "${HOOKS_DIR}/pre-push" +fi diff --git a/boilerplate/flyte/pull_request_template/Readme.rst b/boilerplate/flyte/pull_request_template/Readme.rst new file mode 100644 index 0000000000..ee54437252 --- /dev/null +++ b/boilerplate/flyte/pull_request_template/Readme.rst @@ -0,0 +1,8 @@ +Pull Request Template +~~~~~~~~~~~~~~~~~~~~~ + +Provides a Pull Request template. + +**To Enable:** + +Add ``flyteorg/golang_test_targets`` to your ``boilerplate/update.cfg`` file. diff --git a/boilerplate/flyte/pull_request_template/pull_request_template.md b/boilerplate/flyte/pull_request_template/pull_request_template.md new file mode 100644 index 0000000000..9cdab99b46 --- /dev/null +++ b/boilerplate/flyte/pull_request_template/pull_request_template.md @@ -0,0 +1,35 @@ +## _Read then delete this section_ + +_- Make sure to use a concise title for the pull-request._ + +_- Use #patch, #minor or #major in the pull-request title to bump the corresponding version. Otherwise, the patch version +will be bumped. [More details](https://github.com/marketplace/actions/github-tag-bump)_ + +# TL;DR +_Please replace this text with a description of what this PR accomplishes._ + +## Type + - [ ] Bug Fix + - [ ] Feature + - [ ] Plugin + +## Are all requirements met? + + - [ ] Code completed + - [ ] Smoke tested + - [ ] Unit tests added + - [ ] Code documentation added + - [ ] Any pending items have an associated Issue + +## Complete description + _How did you fix the bug, make the feature etc. Link to any design docs etc_ + +## Tracking Issue +_Remove the '*fixes*' keyword if there will be multiple PRs to fix the linked issue_ + +fixes https://github.com/flyteorg/flyte/issues/ + +## Follow-up issue +_NA_ +OR +_https://github.com/flyteorg/flyte/issues/_ diff --git a/boilerplate/flyte/pull_request_template/update.sh b/boilerplate/flyte/pull_request_template/update.sh new file mode 100755 index 0000000000..051e9dbce0 --- /dev/null +++ b/boilerplate/flyte/pull_request_template/update.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash + +# WARNING: THIS FILE IS MANAGED IN THE 'BOILERPLATE' REPO AND COPIED TO OTHER REPOSITORIES. +# ONLY EDIT THIS FILE FROM WITHIN THE 'FLYTEORG/BOILERPLATE' REPOSITORY: +# +# TO OPT OUT OF UPDATES, SEE https://github.com/flyteorg/boilerplate/blob/master/Readme.rst + +set -e + +DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && pwd )" + +cp ${DIR}/pull_request_template.md ${DIR}/../../../pull_request_template.md diff --git a/boilerplate/update.sh b/boilerplate/update.sh new file mode 100755 index 0000000000..73de4dc91c --- /dev/null +++ b/boilerplate/update.sh @@ -0,0 +1,73 @@ +#!/usr/bin/env bash + +# WARNING: THIS FILE IS MANAGED IN THE 'BOILERPLATE' REPO AND COPIED TO OTHER REPOSITORIES. +# ONLY EDIT THIS FILE FROM WITHIN THE 'FLYTEORG/BOILERPLATE' REPOSITORY: +# +# TO OPT OUT OF UPDATES, SEE https://github.com/flyteorg/boilerplate/blob/master/Readme.rst + +set -e + +DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && pwd )" + +OUT="$(mktemp -d)" +trap 'rm -fr $OUT' EXIT + +git clone https://github.com/flyteorg/boilerplate.git "${OUT}" + +echo "Updating the update.sh script." +cp "${OUT}/boilerplate/update.sh" "${DIR}/update.sh" + +CONFIG_FILE="${DIR}/update.cfg" +README="https://github.com/flyteorg/boilerplate/blob/master/Readme.rst" + +if [ ! -f "$CONFIG_FILE" ]; then + echo "$CONFIG_FILE not found." + echo "This file is required in order to select which features to include." + echo "See $README for more details." + exit 1 +fi + +if [ -z "$REPOSITORY" ]; then + echo "$REPOSITORY is required to run this script" + echo "See $README for more details." + exit 1 +fi + +while read -r directory junk; do + # Skip comment lines (which can have leading whitespace) + if [[ "$directory" == '#'* ]]; then + continue + fi + # Skip blank or whitespace-only lines + if [[ "$directory" == "" ]]; then + continue + fi + # Lines like + # valid/path other_junk + # are not acceptable, unless `other_junk` is a comment + if [[ "$junk" != "" ]] && [[ "$junk" != '#'* ]]; then + echo "Invalid config! Only one directory is allowed per line. Found '$junk'" + exit 1 + fi + + dir_path="${OUT}/boilerplate/${directory}" + # Make sure the directory exists + if ! [[ -d "$dir_path" ]]; then + echo "Invalid boilerplate directory: '$directory'" + exit 1 + fi + + echo "***********************************************************************************" + echo "$directory is configured in update.cfg." + echo "-----------------------------------------------------------------------------------" + echo "syncing files from source." + rm -rf "${DIR:?}/${directory}" + mkdir -p "$(dirname "${DIR}"/"${directory}")" + cp -r "$dir_path" "${DIR}/${directory}" + if [ -f "${DIR}/${directory}/update.sh" ]; then + echo "executing ${DIR}/${directory}/update.sh" + "${DIR}/${directory}/update.sh" + fi + echo "***********************************************************************************" + echo "" +done < "$CONFIG_FILE" diff --git a/buf.gen.go.yaml b/buf.gen.go.yaml new file mode 100644 index 0000000000..fcba205edc --- /dev/null +++ b/buf.gen.go.yaml @@ -0,0 +1,40 @@ +version: v2 +managed: + enabled: true + override: + - file_option: optimize_for + value: CODE_SIZE + # Use managed mode. Ref: https://protovalidate.com/quickstart/#depend-on-protovalidate + disable: + - file_option: go_package + - module: buf.build/bufbuild/protovalidate +plugins: + - remote: buf.build/protocolbuffers/go:v1.30.0 + out: gen/go + opt: + - paths=source_relative + - remote: buf.build/grpc/go:v1.3.0 + out: gen/go + opt: + - paths=source_relative + - require_unimplemented_servers=false + - remote: buf.build/connectrpc/go:v1.16.2 + out: gen/go + opt: + - paths=source_relative + - remote: buf.build/bufbuild/validate-go:v1.2.1 + out: gen/go + opt: + - paths=source_relative + - remote: buf.build/grpc-ecosystem/gateway:v2.15.2 + out: gen/go/gateway + opt: + - paths=import + - module=github.com/flyteorg/flyte/v2/gen/go + - standalone=true + - allow_delete_body=true + - remote: buf.build/grpc-ecosystem/openapiv2:v2.27.4 + out: gen/go/gateway + opt: + - json_names_for_fields=false + - allow_delete_body=true diff --git a/buf.gen.python.yaml b/buf.gen.python.yaml new file mode 100644 index 0000000000..6a843ca9dd --- /dev/null +++ b/buf.gen.python.yaml @@ -0,0 +1,17 @@ +version: v2 +managed: + enabled: true + override: + - file_option: optimize_for + value: CODE_SIZE + # Use managed mode: https://buf.build/docs/generate/managed-mode/#managed-mode +plugins: + - remote: buf.build/protocolbuffers/python:v24.1 + out: gen/python + include_imports: true + - remote: buf.build/protocolbuffers/pyi:v24.1 + out: gen/python + include_imports: true + - remote: buf.build/grpc/python:v1.58.1 + out: gen/python + include_imports: true diff --git a/buf.gen.rust.yaml b/buf.gen.rust.yaml new file mode 100644 index 0000000000..f2d2e27616 --- /dev/null +++ b/buf.gen.rust.yaml @@ -0,0 +1,17 @@ +version: v2 +managed: + enabled: true + # Use managed mode: https://buf.build/docs/generate/managed-mode/#managed-mode + disable: + - module: buf.build/bufbuild/protovalidate +plugins: + - remote: buf.build/community/neoeinstein-prost:v0.4.0 + out: gen/rust/src + opt: + - file_descriptor_set + - type_attribute=.=#[pyo3::pyclass(dict\, get_all\, set_all)] + - compile_well_known_types + - remote: buf.build/community/neoeinstein-tonic:v0.4.1 + out: gen/rust/src + opt: + - compile_well_known_types diff --git a/buf.gen.ts.yaml b/buf.gen.ts.yaml new file mode 100644 index 0000000000..3c9fd2f7d8 --- /dev/null +++ b/buf.gen.ts.yaml @@ -0,0 +1,16 @@ +version: v2 +managed: + enabled: true + override: + - file_option: optimize_for + value: CODE_SIZE + # Use managed mode: https://buf.build/docs/generate/managed-mode/#managed-mode + disable: + - module: buf.build/bufbuild/protovalidate +plugins: + - remote: buf.build/bufbuild/es:v2.2.5 + out: gen/ts + include_imports: true + opt: + - target=ts + - import_extension=.ts diff --git a/buf.lock b/buf.lock new file mode 100644 index 0000000000..c6b7e8e3b3 --- /dev/null +++ b/buf.lock @@ -0,0 +1,12 @@ +# Generated by buf. DO NOT EDIT. +version: v2 +deps: + - name: buf.build/bufbuild/protovalidate + commit: 6c6e0d3c608e4549802254a2eee81bc8 + digest: b5:a7ca081f38656fc0f5aaa685cc111d3342876723851b47ca6b80cbb810cbb2380f8c444115c495ada58fa1f85eff44e68dc54a445761c195acdb5e8d9af675b6 + - name: buf.build/googleapis/googleapis + commit: 62f35d8aed1149c291d606d958a7ce32 + digest: b5:d66bf04adc77a0870bdc9328aaf887c7188a36fb02b83a480dc45ef9dc031b4d39fc6e9dc6435120ccf4fe5bfd5c6cb6592533c6c316595571f9a31420ab47fe + - name: buf.build/grpc-ecosystem/grpc-gateway + commit: 6467306b4f624747aaf6266762ee7a1c + digest: b5:c2caa61467d992749812c909f93c07e9a667da33c758a7c1973d63136c23b3cafcc079985b12cdf54a10049ed3297418f1eda42cdffdcf34113792dcc3a990af diff --git a/buf.yaml b/buf.yaml new file mode 100755 index 0000000000..a0800f0762 --- /dev/null +++ b/buf.yaml @@ -0,0 +1,68 @@ +version: v2 +name: buf.build/flyteorg/flyte +deps: + - buf.build/googleapis/googleapis:62f35d8aed1149c291d606d958a7ce32 + - buf.build/bufbuild/protovalidate:v0.14.1 + - buf.build/grpc-ecosystem/grpc-gateway +lint: + except: + - PACKAGE_VERSION_SUFFIX + - FIELD_LOWER_SNAKE_CASE + ignore_only: + ENUM_VALUE_PREFIX: + - flyteidl2/common/configuration.proto + - flyteidl2/common/list.proto + - flyteidl2/common/runtime_version.proto + - flyteidl2/core/artifact_id.proto + - flyteidl2/core/catalog.proto + - flyteidl2/core/errors.proto + - flyteidl2/event/event.proto + - flyteidl2/core/execution.proto + - flyteidl2/core/identifier.proto + - flyteidl2/core/security.proto + - flyteidl2/core/tasks.proto + - flyteidl2/core/types.proto + - flyteidl2/datacatalog/datacatalog.proto + - flyteidl2/logs/dataplane/payload.proto + - flyteidl2/secret/definition.proto + - flyteidl2/plugins/spark.proto + - flyteidl2/task/common.proto + - flyteidl2/plugins/kubeflow/common.proto + - flyteidl2/project/project_service.proto + - flyteidl2/project/common.proto + ENUM_ZERO_VALUE_SUFFIX: + - flyteidl2/common/authorization.proto + - flyteidl2/plugins/common.proto + - flyteidl2/common/list.proto + - flyteidl2/common/role.proto + - flyteidl2/common/runtime_version.proto + - flyteidl2/core/artifact_id.proto + - flyteidl2/core/catalog.proto + - flyteidl2/core/errors.proto + - flyteidl2/event/event.proto + - flyteidl2/core/execution.proto + - flyteidl2/core/identifier.proto + - flyteidl2/core/security.proto + - flyteidl2/core/tasks.proto + - flyteidl2/core/types.proto + - flyteidl2/datacatalog/datacatalog.proto + - flyteidl2/logs/dataplane/payload.proto + - flyteidl2/secret/definition.proto + - flyteidl2/plugins/spark.proto + - flyteidl2/plugins/kubeflow/common.proto + - flyteidl2/project/project_service.proto + - flyteidl2/project/common.proto + RPC_REQUEST_RESPONSE_UNIQUE: + - flyteidl2/cacheservice/cacheservice.proto + - flyteidl2/cacheservice/v2/cacheservice.proto + - flyteidl2/project/project_service.proto + RPC_REQUEST_STANDARD_NAME: + - flyteidl2/cacheservice/cacheservice.proto + - flyteidl2/cacheservice/v2/cacheservice.proto + - flyteidl2/project/project_service.proto + RPC_RESPONSE_STANDARD_NAME: + - flyteidl2/cacheservice/cacheservice.proto + - flyteidl2/cacheservice/v2/cacheservice.proto + - flyteidl2/project/project_service.proto + SERVICE_SUFFIX: + - flyteidl2/datacatalog/datacatalog.proto diff --git a/dataproxy/DEVELOPMENT.md b/dataproxy/DEVELOPMENT.md new file mode 100644 index 0000000000..1c39efab04 --- /dev/null +++ b/dataproxy/DEVELOPMENT.md @@ -0,0 +1,124 @@ +# Data Proxy Development Guide + +This guide provides steps on how to develop and iterate changes for the Data Proxy service. + +## Prerequisites + +- go version v1.24.0+ +- docker version 17.03+ +- kubectl version v1.11.3+ + +## Use go v1.24 + +Currently, flyte-v2 uses go v1.24 for development. + +```sh +go install golang.org/dl/go1.24.0@latest +go1.24.0 download +export GOROOT=$(go1.24.0 env GOROOT) +export PATH="$GOROOT/bin:$PATH" +``` + +## Local Development + +Following steps require you to switch your working directory to the `dataproxy/`. + +```sh +cd dataproxy +``` + +### Run Data Proxy Service + +1. Create a kind cluster + +```sh +kind create cluster --image=kindest/node:v1.26.0 --name flytev2 +``` + +2. Deploy MinIO storage backend + +```sh +kubectl apply -f deployment/minio.yaml +``` + +3. Wait for MinIO to be ready + +```sh +kubectl wait --for=condition=ready pod -l app=minio -n flyte-dataproxy --timeout=60s +``` + +4. Port-forward MinIO for local access + +```sh +# Port-forward both MinIO API (9000) and Console (9001) +kubectl port-forward -n flyte-dataproxy svc/minio 9000:9000 9001:9001 +``` + +Keep this running in a separate terminal. + +You can now access MinIO Console in your browser: +- URL: http://localhost:9001 +- Username: `minioadmin` +- Password: `minioadmin` + +5. Run the Data Proxy service + +```sh +go run cmd/main.go --config config/config.example.yaml +``` + +The service will start on port 8088. + +6. Test the service + +```sh +# Check health +curl http://localhost:8088/healthz + +# Check readiness +curl http://localhost:8088/readyz +``` + +## Scripts + +Convenient scripts are provided in `dataproxy/test/scripts/` to interact with the service using `buf curl`. +Ensure the service is running before executing these scripts. + +- `./dataproxy/test/scripts/create_upload_location.sh` - Create a signed upload URL with all options + +### Usage + +```sh +# Use default values +./dataproxy/test/scripts/create_upload_location.sh + +# Customize with environment variables +PROJECT=myproject DOMAIN=staging ./dataproxy/test/scripts/create_upload_location.sh + +# Custom filename +FILENAME=mydata.csv FILENAME_ROOT=my-upload ./dataproxy/test/scripts/create_upload_location.sh + +# Custom endpoint +ENDPOINT=http://localhost:9000 ./dataproxy/test/scripts/create_upload_location.sh +``` + +### Clean Up + +```sh +kind delete cluster --name flytev2 +``` + +## Tests + +### Run unit tests + +```sh +# Run all tests +go test ./... + +# Run tests with verbose output +go test -v ./... + +# Run specific test package +go test -v ./service +``` diff --git a/dataproxy/README.md b/dataproxy/README.md new file mode 100644 index 0000000000..5271f6eb43 --- /dev/null +++ b/dataproxy/README.md @@ -0,0 +1,164 @@ +# Data Proxy + +Data proxy is the service that communicates with the data storage to handle operations like: +- Generate signed URLs for uploading data +- Generate download URLs for retrieving data +- Manage data access and permissions + +Data proxy lives in the Flyte control plane, while the data storage lives in the data plane. Data proxy is the bridge +to request URLs for uploading/downloading data to any data storage you have. + +## Quick Start + +For local development, see [DEVELOPMENT.md](DEVELOPMENT.md) for detailed steps on setting up MinIO and running the service locally. + +For production deployment: + +1. Configure your storage backend (S3, MinIO, GCS, etc.) +2. Create a configuration file based on `config/config.example.yaml` +3. Run the service: + +```bash +go run cmd/main.go --config config/config.yaml +``` + +The service will start on port 8088 by default. You can override with `--port` and `--host` flags. + +## Configuration + +The data proxy service uses a YAML configuration file. See [config.example.yaml](config/config.example.yaml) for a complete example. + +### Data Proxy Settings + +| Field | Description | Default | +|-------|-------------|---------| +| `dataproxy.upload.maxSize` | Maximum allowed upload size | `100Mi` | +| `dataproxy.upload.maxExpiresIn` | Maximum expiration time for signed upload URLs | `1h` | +| `dataproxy.upload.defaultFileNameLength` | Default length for auto-generated filenames | `20` | +| `dataproxy.upload.storagePrefix` | Prefix for all uploaded files in storage | `uploads` | +| `dataproxy.download.maxExpiresIn` | Maximum expiration time for download URLs | `1h` | + +### Storage Backend Settings + +| Field | Description | Options | +|-------|-------------|---------| +| `storage.type` | Storage backend type | `s3`, `minio`, `local`, `mem`, `stow` | +| `storage.container` | Initial bucket/container name | - | +| `storage.enable-multicontainer` | Allow access to multiple buckets | `true`/`false` | +| `storage.connection.endpoint` | Storage endpoint URL | - | +| `storage.connection.auth-type` | Authentication method | `iam`, `accesskey` | +| `storage.connection.access-key` | Access key (when using `accesskey` auth) | - | +| `storage.connection.secret-key` | Secret key (when using `accesskey` auth) | - | +| `storage.connection.region` | Storage region | `us-east-1` | +| `storage.connection.disable-ssl` | Disable SSL (for local dev only) | `true`/`false` | + +### MinIO-Specific Configuration + +For MinIO, use the following configuration: + +```yaml +storage: + type: minio + container: "flyte-data" + connection: + endpoint: "http://minio.flyte-dataproxy.svc.cluster.local:9000" + auth-type: accesskey + access-key: "minioadmin" + secret-key: "minioadmin" + region: "us-east-1" + disable-ssl: true +``` + +### S3-Compatible Storage + +For AWS S3 or S3-compatible storage: + +```yaml +storage: + type: s3 + container: "my-flyte-bucket" + connection: + auth-type: iam # Use IAM roles + region: "us-west-2" + disable-ssl: false +``` + +## Architecture + +``` +โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” +โ”‚ Flyte Client โ”‚ +โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”ฌโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ + โ”‚ Request signed URL + โ”‚ + โ–ผ +โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” +โ”‚ Data Proxy โ”‚โ”€โ”€โ”€โ”€โ”€โ–ถโ”‚ MinIO/S3 API โ”‚ +โ”‚ (Control โ”‚ โ”‚ (Data Plane) โ”‚ +โ”‚ Plane) โ”‚โ—€โ”€โ”€โ”€โ”€โ”€โ”‚ โ”‚ +โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ + โ”‚ โ–ฒ + โ”‚ Return signed URL โ”‚ + โ”‚ โ”‚ + โ–ผ โ”‚ +โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” โ”‚ +โ”‚ Flyte Client โ”‚โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ +โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ Upload/Download + using signed URL +``` + +## Development + +For local development and testing, see [DEVELOPMENT.md](DEVELOPMENT.md). + +## Troubleshooting + +### MinIO Connection Issues + +1. **Check MinIO is running:** + ```bash + kubectl get pods -n flyte-dataproxy + ``` + +2. **Check MinIO logs:** + ```bash + kubectl logs -n flyte-dataproxy -l app=minio + ``` + +3. **Verify network connectivity:** + ```bash + kubectl run -it --rm debug --image=curlimages/curl --restart=Never -- \ + curl http://minio.flyte-dataproxy.svc.cluster.local:9000/minio/health/live + ``` + +### Data Proxy Service Issues + +1. **Check configuration:** + - Verify the storage endpoint is correct + - Ensure credentials are valid + - Check that the bucket/container exists + +2. **Enable debug logging:** + ```yaml + logger: + level: 5 # Debug level + show-source: true + ``` + +3. **Common errors:** + - `connection refused`: MinIO service not reachable + - `access denied`: Invalid credentials + - `bucket not found`: Container doesn't exist (enable auto-creation or create manually) + +## Production Deployment + +For production use: + +1. **Use a production-grade storage backend** (AWS S3, GCS, Azure Blob Storage, or MinIO in distributed mode) +2. **Enable TLS/SSL** for all connections +3. **Use IAM roles** instead of static credentials when possible +4. **Configure resource limits** and proper scaling +5. **Set up monitoring and alerting** for storage operations +6. **Review security settings** for signed URL expiration times + +See the Flyte documentation for production deployment guides. diff --git a/dataproxy/cmd/main.go b/dataproxy/cmd/main.go new file mode 100644 index 0000000000..a2fb5fbb6f --- /dev/null +++ b/dataproxy/cmd/main.go @@ -0,0 +1,161 @@ +package main + +import ( + "context" + "errors" + "fmt" + "net/http" + "os" + "os/signal" + "syscall" + "time" + + "github.com/spf13/cobra" + "golang.org/x/net/http2" + "golang.org/x/net/http2/h2c" + + "github.com/flyteorg/flyte/v2/dataproxy/config" + "github.com/flyteorg/flyte/v2/dataproxy/service" + stdconfig "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/config/viper" + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils/labeled" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/dataproxy/dataproxyconnect" +) + +var ( + cfgFile string + port int + host string + + rootCmd = &cobra.Command{ + Use: "dataproxy-service", + Short: "Data Proxy Service for Flyte", + RunE: func(cmd *cobra.Command, args []string) error { + return serve(cmd.Context()) + }, + } +) + +func init() { + rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.flyte/config.yaml)") + rootCmd.PersistentFlags().IntVar(&port, "port", 8088, "server port") + rootCmd.PersistentFlags().StringVar(&host, "host", "0.0.0.0", "server host") +} + +func main() { + if err := rootCmd.Execute(); err != nil { + os.Exit(1) + } +} + +func serve(ctx context.Context) error { + // Initialize config + if err := initConfig(); err != nil { + return fmt.Errorf("failed to initialize config: %w", err) + } + + // Initialize logger + logConfig := logger.GetConfig() + if err := logger.SetConfig(logConfig); err != nil { + return fmt.Errorf("failed to initialize logger: %w", err) + } + + logger.Infof(ctx, "Starting Data Proxy Service") + + // Initialize labeled metrics (required before using storage) + labeled.SetMetricKeys(contextutils.ProjectKey, contextutils.DomainKey, contextutils.WorkflowIDKey, contextutils.TaskIDKey) + + // Get configuration + dataProxyCfg := config.GetConfig() + storageCfg := storage.GetConfig() + + // Initialize storage with metrics scope + metricsScope := promutils.NewTestScope() + dataStore, err := storage.NewDataStore(storageCfg, metricsScope) + if err != nil { + return fmt.Errorf("failed to initialize storage: %w", err) + } + logger.Infof(ctx, "Storage initialized with type: %s", storageCfg.Type) + + // Create data proxy service + dataProxySvc := service.NewService(*dataProxyCfg, dataStore) + + // Setup HTTP server with Connect handlers + mux := http.NewServeMux() + + // Mount the Data Proxy Service + path, handler := dataproxyconnect.NewDataProxyServiceHandler(dataProxySvc) + mux.Handle(path, handler) + logger.Infof(ctx, "Mounted DataProxyService at %s", path) + + // Add health check endpoint + mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte("OK")) + }) + + // Add readiness check endpoint + mux.HandleFunc("/readyz", func(w http.ResponseWriter, r *http.Request) { + // Check storage connection by getting base container + baseContainer := dataStore.GetBaseContainerFQN(r.Context()) + if baseContainer == "" { + w.WriteHeader(http.StatusServiceUnavailable) + _, _ = w.Write([]byte("Storage connection error")) + return + } + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte("OK")) + }) + + // Setup HTTP/2 support (required for gRPC and Connect) + addr := fmt.Sprintf("%s:%d", host, port) + server := &http.Server{ + Addr: addr, + Handler: h2c.NewHandler(mux, &http2.Server{}), + } + + // Start server in a goroutine + errCh := make(chan error, 1) + go func() { + logger.Infof(ctx, "Data Proxy Service listening on %s", addr) + if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { + errCh <- fmt.Errorf("server error: %w", err) + } + }() + + // Wait for interrupt signal or error + sigCh := make(chan os.Signal, 1) + signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM) + + select { + case sig := <-sigCh: + logger.Infof(ctx, "Received signal %v, shutting down gracefully...", sig) + case err := <-errCh: + return err + } + + // Graceful shutdown + shutdownCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + + if err := server.Shutdown(shutdownCtx); err != nil { + return fmt.Errorf("server shutdown failed: %w", err) + } + + logger.Infof(ctx, "Data Proxy Service stopped") + return nil +} + +func initConfig() error { + // Use viper to load config + configAccessor := viper.NewAccessor(stdconfig.Options{ + SearchPaths: []string{cfgFile, ".", "/etc/flyte/config"}, + StrictMode: false, + }) + + return configAccessor.UpdateConfig(context.Background()) +} diff --git a/dataproxy/config/config.example.yaml b/dataproxy/config/config.example.yaml new file mode 100644 index 0000000000..fcc44534ab --- /dev/null +++ b/dataproxy/config/config.example.yaml @@ -0,0 +1,43 @@ +# Example configuration for Data Proxy with MinIO storage backend +# This configuration is for local development and testing purposes. + +# Data Proxy Configuration +dataproxy: + upload: + # Maximum size for uploads (100MB) + maxSize: "100Mi" + # Maximum expiration time for signed URLs (1 hour) + maxExpiresIn: 1h + # Default filename length when auto-generating names + defaultFileNameLength: 20 + # Storage prefix for all uploads + storagePrefix: "uploads" + + download: + # Maximum expiration time for download URLs (1 hour) + maxExpiresIn: 1h + +# Storage Configuration +storage: + # Type of storage backend (options: s3, minio, local, mem, stow) + type: minio + + # Initial bucket/container name + # This bucket will be created automatically if it doesn't exist + container: "flyte-data" + + # Enable multi-container support + # When true, allows accessing multiple buckets + enable-multicontainer: false + + # Stow Configuration (recommended) + # This is the modern way to configure storage backends + stow: + kind: "s3" + config: + auth_type: "accesskey" + access_key_id: "minioadmin" + secret_key: "minioadmin" + region: "us-east-1" + endpoint: "http://localhost:9000" + disable_ssl: "true" diff --git a/dataproxy/config/config.go b/dataproxy/config/config.go new file mode 100644 index 0000000000..b503091030 --- /dev/null +++ b/dataproxy/config/config.go @@ -0,0 +1,43 @@ +package config + +import ( + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "k8s.io/apimachinery/pkg/api/resource" +) + +const configSectionKey = "dataproxy" + +var defaultConfig = &DataProxyConfig{ + Upload: DataProxyUploadConfig{ + MaxSize: resource.MustParse("100Mi"), + MaxExpiresIn: config.Duration{Duration: 3600000000000}, // 1 hour + DefaultFileNameLength: 20, + StoragePrefix: "uploads", + }, + Download: DataProxyDownloadConfig{ + MaxExpiresIn: config.Duration{Duration: 3600000000000}, // 1 hour + }, +} + +var configSection = config.MustRegisterSection(configSectionKey, defaultConfig) + +type DataProxyConfig struct { + Upload DataProxyUploadConfig `json:"upload" pflag:",Defines data proxy upload configuration."` + Download DataProxyDownloadConfig `json:"download" pflag:",Defines data proxy download configuration."` +} + +// GetConfig returns the parsed data proxy configuration +func GetConfig() *DataProxyConfig { + return configSection.GetConfig().(*DataProxyConfig) +} + +type DataProxyDownloadConfig struct { + MaxExpiresIn config.Duration `json:"maxExpiresIn" pflag:",Maximum allowed expiration duration."` +} + +type DataProxyUploadConfig struct { + MaxSize resource.Quantity `json:"maxSize" pflag:",Maximum allowed upload size."` + MaxExpiresIn config.Duration `json:"maxExpiresIn" pflag:",Maximum allowed expiration duration."` + DefaultFileNameLength int `json:"defaultFileNameLength" pflag:",Default length for the generated file name if file name not provided in the request."` + StoragePrefix string `json:"storagePrefix" pflag:",Storage prefix to use for all upload requests."` +} diff --git a/dataproxy/deployment/minio.yaml b/dataproxy/deployment/minio.yaml new file mode 100644 index 0000000000..f5aeda7524 --- /dev/null +++ b/dataproxy/deployment/minio.yaml @@ -0,0 +1,86 @@ +--- +# MinIO Deployment for Data Proxy Development +# This is a simple single-node MinIO deployment for local testing and development. +# For production use, please refer to MinIO's official deployment guides. + +apiVersion: v1 +kind: Namespace +metadata: + name: flyte-dataproxy +--- +apiVersion: v1 +kind: Service +metadata: + name: minio + namespace: flyte-dataproxy +spec: + type: ClusterIP + ports: + - name: api + port: 9000 + targetPort: 9000 + protocol: TCP + - name: console + port: 9001 + targetPort: 9001 + protocol: TCP + selector: + app: minio +--- +apiVersion: apps/v1 +kind: Deployment +metadata: + name: minio + namespace: flyte-dataproxy +spec: + replicas: 1 + selector: + matchLabels: + app: minio + template: + metadata: + labels: + app: minio + spec: + containers: + - name: minio + image: minio/minio:latest + args: + - server + - /data + - --console-address + - ":9001" + env: + - name: MINIO_ROOT_USER + value: "minioadmin" + - name: MINIO_ROOT_PASSWORD + value: "minioadmin" + ports: + - containerPort: 9000 + name: api + - containerPort: 9001 + name: console + volumeMounts: + - name: data + mountPath: /data + readinessProbe: + httpGet: + path: /minio/health/ready + port: 9000 + initialDelaySeconds: 10 + periodSeconds: 10 + livenessProbe: + httpGet: + path: /minio/health/live + port: 9000 + initialDelaySeconds: 10 + periodSeconds: 10 + volumes: + - name: data + emptyDir: {} +--- +# Optional: Port forward service for local access +# Run: kubectl port-forward -n flyte-dataproxy svc/minio 9000:9000 9001:9001 +# Then access: +# - MinIO API: http://localhost:9000 +# - MinIO Console: http://localhost:9001 diff --git a/dataproxy/service/dataproxy_service.go b/dataproxy/service/dataproxy_service.go new file mode 100644 index 0000000000..d630019de1 --- /dev/null +++ b/dataproxy/service/dataproxy_service.go @@ -0,0 +1,176 @@ +package service + +import ( + "context" + "encoding/base32" + "encoding/base64" + "fmt" + "time" + + "connectrpc.com/connect" + "github.com/flyteorg/stow" + "github.com/samber/lo" + "google.golang.org/protobuf/types/known/durationpb" + "google.golang.org/protobuf/types/known/timestamppb" + + "github.com/flyteorg/flyte/v2/dataproxy/config" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/dataproxy" +) + +type Service struct { + dataproxy.UnimplementedDataProxyServiceServer + + cfg config.DataProxyConfig + dataStore *storage.DataStore +} + +// NewService creates a new DataProxyService instance. +func NewService(cfg config.DataProxyConfig, dataStore *storage.DataStore) *Service { + return &Service{ + cfg: cfg, + dataStore: dataStore, + } +} + +// CreateUploadLocation generates a signed URL for uploading data to the configured storage backend. +func (s *Service) CreateUploadLocation( + ctx context.Context, + req *connect.Request[dataproxy.CreateUploadLocationRequest], +) (*connect.Response[dataproxy.CreateUploadLocationResponse], error) { + logger.Infof(ctx, "CreateUploadLocation request for project=%s, domain=%s, org=%s, filename=%s", + req.Msg.Project, req.Msg.Domain, req.Msg.Org, req.Msg.Filename) + + // Validation on request + if err := req.Msg.Validate(); err != nil { + logger.Errorf(ctx, "Invalid CreateUploadLocation request: %v", err) + return nil, connect.NewError(connect.CodeInvalidArgument, err) + } + if err := validateUploadRequest(ctx, req.Msg, s.cfg); err != nil { + logger.Errorf(ctx, "Request validation failed: %v", err) + return nil, connect.NewError(connect.CodeInvalidArgument, err) + } + + // Build the storage path + storagePath, err := s.constructStoragePath(ctx, req.Msg) + if err != nil { + logger.Errorf(ctx, "Failed to construct storage path: %v", err) + return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to construct storage path: %w", err)) + } + + // Check if file already exists and validate for safe upload + if err := s.checkFileExists(ctx, storagePath, req.Msg); err != nil { + return nil, err + } + + // Set expires_in to default if not provided in request + if req.Msg.GetExpiresIn() == nil { + req.Msg.ExpiresIn = durationpb.New(s.cfg.Upload.MaxExpiresIn.Duration) + } + + // Create signed URL properties + expiresIn := req.Msg.GetExpiresIn().AsDuration() + props := storage.SignedURLProperties{ + Scope: stow.ClientMethodPut, + ExpiresIn: expiresIn, + ContentMD5: base64.StdEncoding.EncodeToString(req.Msg.GetContentMd5()), + AddContentMD5Metadata: req.Msg.GetAddContentMd5Metadata(), + } + + // Generate signed URL + signedResp, err := s.dataStore.CreateSignedURL(ctx, storagePath, props) + if err != nil { + logger.Errorf(ctx, "Failed to create signed URL: %v", err) + return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to create signed URL: %w", err)) + } + + // Build response + expiresAt := time.Now().Add(expiresIn) + resp := &dataproxy.CreateUploadLocationResponse{ + SignedUrl: signedResp.URL.String(), + NativeUrl: storagePath.String(), + ExpiresAt: timestamppb.New(expiresAt), + Headers: signedResp.RequiredRequestHeaders, + } + + logger.Infof(ctx, "Successfully created upload location: native_url=%s, expires_at=%s", + resp.NativeUrl, resp.ExpiresAt.AsTime().Format(time.RFC3339)) + + return connect.NewResponse(resp), nil +} + +// checkFileExists validates whether a file upload is safe by checking existing files. +// Returns an error if: +// - File exists without content_md5 provided (cannot verify safe overwrite) +// - File exists with different content_md5 (prevents accidental overwrite) +// +// Returns nil if: +// - File does not exist (safe to upload) +// - File exists with matching content_md5 (safe to re-upload same content) +func (s *Service) checkFileExists(ctx context.Context, storagePath storage.DataReference, req *dataproxy.CreateUploadLocationRequest) error { + // Only check if both filename and filename_root are provided + if len(req.GetFilename()) == 0 || len(req.GetFilenameRoot()) == 0 { + return nil + } + + metadata, err := s.dataStore.Head(ctx, storagePath) + if err != nil { + logger.Errorf(ctx, "Failed to check if file exists at location [%s]: %v", storagePath.String(), err) + return connect.NewError(connect.CodeInternal, fmt.Errorf("failed to check if file exists at location [%s]: %w", storagePath.String(), err)) + } + + if !metadata.Exists() { + return nil + } + + // Validate based on content hash if file exists + // NOTE: This is a best-effort check. Race conditions may occur when multiple clients + // upload to the same location simultaneously. + if len(req.GetContentMd5()) == 0 { + // Cannot verify content, reject to prevent accidental overwrites + return connect.NewError(connect.CodeAlreadyExists, + fmt.Errorf("file already exists at [%v]; content_md5 is required to verify safe overwrite", storagePath)) + } + + // Validate hash matches + base64Digest := base64.StdEncoding.EncodeToString(req.GetContentMd5()) + if base64Digest != metadata.ContentMD5() { + // Hash mismatch, reject to prevent overwriting different content + logger.Errorf(ctx, "File exists at [%v] with different content hash", storagePath) + return connect.NewError(connect.CodeAlreadyExists, + fmt.Errorf("file already exists at [%v] with different content (hash mismatch)", storagePath)) + } + + // File exists with matching hash, allow upload to proceed + logger.Debugf(ctx, "File already exists at [%v] with matching hash, allowing upload", storagePath) + return nil +} + +// constructStoragePath builds the storage path based on the request parameters. +// Path patterns: +// - storage_prefix/org/project/domain/filename_root/filename (if filename_root is provided) +// - storage_prefix/org/project/domain/base32_hash/filename (if only content_md5 is provided) +func (s *Service) constructStoragePath(ctx context.Context, req *dataproxy.CreateUploadLocationRequest) (storage.DataReference, error) { + baseRef := s.dataStore.GetBaseContainerFQN(ctx) + + // Build path components: storage_prefix/org/project/domain/prefix/filename + pathComponents := []string{s.cfg.Upload.StoragePrefix, req.GetOrg(), req.GetProject(), req.GetDomain()} + + // Set filename_root or base32-encoded content hash as prefix + if len(req.GetFilenameRoot()) > 0 { + pathComponents = append(pathComponents, req.GetFilenameRoot()) + } else { + // URL-safe base32 encoding of content hash + pathComponents = append(pathComponents, base32.StdEncoding.EncodeToString(req.GetContentMd5())) + } + + pathComponents = append(pathComponents, req.GetFilename()) + + // Filter out empty components to avoid double slashes in path + pathComponents = lo.Filter(pathComponents, func(key string, _ int) bool { + return key != "" + }) + + return s.dataStore.ConstructReference(ctx, baseRef, pathComponents...) +} diff --git a/dataproxy/service/dataproxy_service_test.go b/dataproxy/service/dataproxy_service_test.go new file mode 100644 index 0000000000..360301fe72 --- /dev/null +++ b/dataproxy/service/dataproxy_service_test.go @@ -0,0 +1,362 @@ +package service + +import ( + "context" + "encoding/base64" + "net/url" + "testing" + "time" + + "connectrpc.com/connect" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "google.golang.org/protobuf/types/known/durationpb" + "k8s.io/apimachinery/pkg/api/resource" + + "github.com/flyteorg/flyte/v2/dataproxy/config" + flyteconfig "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + storageMocks "github.com/flyteorg/flyte/v2/flytestdlib/storage/mocks" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/dataproxy" +) + +func TestCreateUploadLocation(t *testing.T) { + ctx := context.Background() + + cfg := config.DataProxyConfig{ + Upload: config.DataProxyUploadConfig{ + MaxExpiresIn: flyteconfig.Duration{Duration: 1 * time.Hour}, + MaxSize: resource.MustParse("100Mi"), // 100MB + StoragePrefix: "uploads", + DefaultFileNameLength: 20, + }, + } + + tests := []struct { + name string + req *dataproxy.CreateUploadLocationRequest + wantErr bool + errContains string + validateResult func(t *testing.T, resp *connect.Response[dataproxy.CreateUploadLocationResponse]) + }{ + { + name: "success with valid request", + req: &dataproxy.CreateUploadLocationRequest{ + Project: "test-project", + Domain: "test-domain", + Filename: "test-file.txt", + FilenameRoot: "test-root", + ContentMd5: []byte("test-hash"), + ExpiresIn: durationpb.New(30 * time.Minute), + }, + wantErr: false, + validateResult: func(t *testing.T, resp *connect.Response[dataproxy.CreateUploadLocationResponse]) { + assert.Contains(t, resp.Msg.SignedUrl, "https://test-bucket") + assert.Contains(t, resp.Msg.NativeUrl, "uploads/test-project/test-domain/test-root/test-file.txt") + }, + }, + { + name: "validation error - missing both filename_root and content_md5", + req: &dataproxy.CreateUploadLocationRequest{ + Project: "test-project", + Domain: "test-domain", + Filename: "test-file.txt", + }, + wantErr: true, + errContains: "either filename_root or content_md5 must be provided", + }, + { + name: "validation error - expires_in exceeds maximum", + req: &dataproxy.CreateUploadLocationRequest{ + Project: "test-project", + Domain: "test-domain", + Filename: "test-file.txt", + FilenameRoot: "test-root", + ExpiresIn: durationpb.New(2 * time.Hour), + }, + wantErr: true, + errContains: "exceeds maximum allowed duration", + }, + { + name: "validation error - content_length exceeds maximum", + req: &dataproxy.CreateUploadLocationRequest{ + Project: "test-project", + Domain: "test-domain", + Filename: "test-file.txt", + FilenameRoot: "test-root", + ContentLength: 1024 * 1024 * 200, // 200MB + }, + wantErr: true, + errContains: "exceeds maximum allowed size", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mockStore := setupMockDataStore(t) + service := NewService(cfg, mockStore) + + req := &connect.Request[dataproxy.CreateUploadLocationRequest]{ + Msg: tt.req, + } + + resp, err := service.CreateUploadLocation(ctx, req) + + if tt.wantErr { + assert.Error(t, err) + assert.Nil(t, resp) + assert.Contains(t, err.Error(), tt.errContains) + } else { + assert.NoError(t, err) + assert.NotNil(t, resp) + if tt.validateResult != nil { + tt.validateResult(t, resp) + } + } + }) + } +} + +func TestCheckFileExists(t *testing.T) { + ctx := context.Background() + + cfg := config.DataProxyConfig{ + Upload: config.DataProxyUploadConfig{ + StoragePrefix: "uploads", + }, + } + + tests := []struct { + name string + req *dataproxy.CreateUploadLocationRequest + existingFileMD5 string // Empty means file doesn't exist + expectErr bool + errContains string + }{ + { + name: "file does not exist", + req: &dataproxy.CreateUploadLocationRequest{ + Project: "test-project", + Domain: "test-domain", + Filename: "test-file.txt", + FilenameRoot: "test-root", + }, + existingFileMD5: "", // File doesn't exist + expectErr: false, + }, + { + name: "file exists without hash provided", + req: &dataproxy.CreateUploadLocationRequest{ + Project: "test-project", + Domain: "test-domain", + Filename: "test-file.txt", + FilenameRoot: "test-root", + // No ContentMd5 provided + }, + existingFileMD5: "existing-hash", + expectErr: true, + errContains: "content_md5 is required to verify safe overwrite", + }, + { + name: "file exists with matching hash", + req: &dataproxy.CreateUploadLocationRequest{ + Project: "test-project", + Domain: "test-domain", + Filename: "test-file.txt", + FilenameRoot: "test-root", + ContentMd5: []byte("test-hash-123"), + }, + existingFileMD5: base64.StdEncoding.EncodeToString([]byte("test-hash-123")), + expectErr: false, + }, + { + name: "file exists with different hash", + req: &dataproxy.CreateUploadLocationRequest{ + Project: "test-project", + Domain: "test-domain", + Filename: "test-file.txt", + FilenameRoot: "test-root", + ContentMd5: []byte("different-hash"), + }, + existingFileMD5: base64.StdEncoding.EncodeToString([]byte("existing-hash")), + expectErr: true, + errContains: "with different content (hash mismatch)", + }, + { + name: "skip check when filename is empty", + req: &dataproxy.CreateUploadLocationRequest{ + Project: "test-project", + Domain: "test-domain", + Filename: "", // Empty filename + FilenameRoot: "test-root", + }, + existingFileMD5: "", + expectErr: false, + }, + { + name: "skip check when filename_root is empty", + req: &dataproxy.CreateUploadLocationRequest{ + Project: "test-project", + Domain: "test-domain", + Filename: "test-file.txt", + FilenameRoot: "", // Empty filename_root + }, + existingFileMD5: "", + expectErr: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + var mockStore *storage.DataStore + if tt.existingFileMD5 == "" { + mockStore = setupMockDataStore(t) + } else { + mockStore = setupMockDataStoreWithExistingFile(t, tt.existingFileMD5) + } + + service := NewService(cfg, mockStore) + storagePath := storage.DataReference("s3://test-bucket/uploads/test-project/test-domain/test-root/test-file.txt") + + err := service.checkFileExists(ctx, storagePath, tt.req) + + if tt.expectErr { + assert.Error(t, err) + assert.Contains(t, err.Error(), tt.errContains) + } else { + assert.NoError(t, err) + } + }) + } +} + +func TestConstructStoragePath(t *testing.T) { + ctx := context.Background() + + cfg := config.DataProxyConfig{ + Upload: config.DataProxyUploadConfig{ + StoragePrefix: "uploads", + }, + } + + tests := []struct { + name string + req *dataproxy.CreateUploadLocationRequest + expectedPath string + }{ + { + name: "with filename_root", + req: &dataproxy.CreateUploadLocationRequest{ + Org: "test-org", + Project: "test-project", + Domain: "test-domain", + Filename: "test-file.txt", + FilenameRoot: "test-root", + }, + expectedPath: "s3://test-bucket/uploads/test-org/test-project/test-domain/test-root/test-file.txt", + }, + { + name: "with content_md5 uses base32 encoding", + req: &dataproxy.CreateUploadLocationRequest{ + Project: "test-project", + Domain: "test-domain", + Filename: "test-file.txt", + ContentMd5: []byte("test-hash"), + }, + // base32 encoding for "test-hash" is ORSXG5BNNBQXG2A= + expectedPath: "s3://test-bucket/uploads/test-project/test-domain/ORSXG5BNNBQXG2A=/test-file.txt", + }, + { + name: "filters empty org component", + req: &dataproxy.CreateUploadLocationRequest{ + Org: "", // Empty org + Project: "test-project", + Domain: "test-domain", + Filename: "test-file.txt", + FilenameRoot: "test-root", + }, + expectedPath: "s3://test-bucket/uploads/test-project/test-domain/test-root/test-file.txt", + }, + { + name: "with all components including org", + req: &dataproxy.CreateUploadLocationRequest{ + Org: "test-org", + Project: "test-project", + Domain: "test-domain", + Filename: "test-file.txt", + FilenameRoot: "test-root", + }, + expectedPath: "s3://test-bucket/uploads/test-org/test-project/test-domain/test-root/test-file.txt", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mockStore := setupMockDataStore(t) + service := NewService(cfg, mockStore) + + path, err := service.constructStoragePath(ctx, tt.req) + + assert.NoError(t, err) + assert.Equal(t, tt.expectedPath, path.String()) + }) + } +} + +// Helper functions to setup mocks + +// simpleRefConstructor is a simple implementation of ReferenceConstructor for testing +type simpleRefConstructor struct{} + +func (s *simpleRefConstructor) ConstructReference(ctx context.Context, base storage.DataReference, keys ...string) (storage.DataReference, error) { + path := string(base) + for _, key := range keys { + if key != "" { + path += "/" + key + } + } + return storage.DataReference(path), nil +} + +func setupMockDataStore(t *testing.T) *storage.DataStore { + mockComposedStore := storageMocks.NewComposedProtobufStore(t) + + // Setup base container + mockComposedStore.On("GetBaseContainerFQN", mock.Anything).Return(storage.DataReference("s3://test-bucket")).Maybe() + + // Setup Head to return file does not exist + mockMetadata := storageMocks.NewMetadata(t) + mockMetadata.On("Exists").Return(false).Maybe() + mockComposedStore.On("Head", mock.Anything, mock.Anything).Return(mockMetadata, nil).Maybe() + + // Setup CreateSignedURL + testURL, _ := url.Parse("https://test-bucket.s3.amazonaws.com/signed-url") + mockComposedStore.On("CreateSignedURL", mock.Anything, mock.Anything, mock.Anything).Return( + storage.SignedURLResponse{ + URL: *testURL, + RequiredRequestHeaders: map[string]string{"Content-Type": "application/octet-stream"}, + }, nil).Maybe() + + return &storage.DataStore{ + ComposedProtobufStore: mockComposedStore, + ReferenceConstructor: &simpleRefConstructor{}, + } +} + +func setupMockDataStoreWithExistingFile(t *testing.T, contentMD5 string) *storage.DataStore { + mockComposedStore := storageMocks.NewComposedProtobufStore(t) + + // Setup base container + mockComposedStore.On("GetBaseContainerFQN", mock.Anything).Return(storage.DataReference("s3://test-bucket")).Maybe() + + // Setup Head to return file exists with given hash + mockMetadata := storageMocks.NewMetadata(t) + mockMetadata.On("Exists").Return(true) + mockMetadata.On("ContentMD5").Return(contentMD5).Maybe() + mockComposedStore.On("Head", mock.Anything, mock.Anything).Return(mockMetadata, nil) + + return &storage.DataStore{ + ComposedProtobufStore: mockComposedStore, + ReferenceConstructor: &simpleRefConstructor{}, + } +} diff --git a/dataproxy/service/validation.go b/dataproxy/service/validation.go new file mode 100644 index 0000000000..e15527706c --- /dev/null +++ b/dataproxy/service/validation.go @@ -0,0 +1,39 @@ +package service + +import ( + "context" + "fmt" + + "github.com/flyteorg/flyte/v2/dataproxy/config" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/dataproxy" +) + +// validateUploadRequest performs validation on the upload request. +func validateUploadRequest(ctx context.Context, req *dataproxy.CreateUploadLocationRequest, cfg config.DataProxyConfig) error { + if len(req.FilenameRoot) == 0 && len(req.ContentMd5) == 0 { + return fmt.Errorf("either filename_root or content_md5 must be provided") + } + + // Validate expires_in against platform maximum + if req.ExpiresIn != nil { + if !req.ExpiresIn.IsValid() { + return fmt.Errorf("expires_in (%v) is invalid", req.ExpiresIn) + } + maxExpiration := cfg.Upload.MaxExpiresIn.Duration + if maxExpiration > 0 && req.ExpiresIn.AsDuration() > maxExpiration { + return fmt.Errorf("expires_in (%v) exceeds maximum allowed duration of %v", + req.ExpiresIn.AsDuration(), maxExpiration) + } + } + + // Validate content_length against platform maximum + if req.ContentLength > 0 { + maxSize := cfg.Upload.MaxSize.Value() + if maxSize > 0 && req.ContentLength > maxSize { + return fmt.Errorf("content_length (%d bytes) exceeds maximum allowed size of %d bytes", + req.ContentLength, maxSize) + } + } + + return nil +} diff --git a/dataproxy/service/validation_test.go b/dataproxy/service/validation_test.go new file mode 100644 index 0000000000..058864828c --- /dev/null +++ b/dataproxy/service/validation_test.go @@ -0,0 +1,95 @@ +package service + +import ( + "context" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "google.golang.org/protobuf/types/known/durationpb" + "k8s.io/apimachinery/pkg/api/resource" + + "github.com/flyteorg/flyte/v2/dataproxy/config" + flyteconfig "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/dataproxy" +) + +func TestValidateUploadRequest(t *testing.T) { + ctx := context.Background() + cfg := config.DataProxyConfig{ + Upload: config.DataProxyUploadConfig{ + MaxExpiresIn: flyteconfig.Duration{Duration: 1 * time.Hour}, + MaxSize: resource.MustParse("100Mi"), + }, + } + + tests := []struct { + name string + req *dataproxy.CreateUploadLocationRequest + wantErr bool + errMsg string + }{ + { + name: "valid request with filename_root", + req: &dataproxy.CreateUploadLocationRequest{ + FilenameRoot: "test-root", + ExpiresIn: durationpb.New(30 * time.Minute), + }, + wantErr: false, + }, + { + name: "valid request with content_md5", + req: &dataproxy.CreateUploadLocationRequest{ + ContentMd5: []byte("test-hash"), + ExpiresIn: durationpb.New(30 * time.Minute), + }, + wantErr: false, + }, + { + name: "missing both filename_root and content_md5", + req: &dataproxy.CreateUploadLocationRequest{ + ExpiresIn: durationpb.New(30 * time.Minute), + }, + wantErr: true, + errMsg: "either filename_root or content_md5 must be provided", + }, + { + name: "expires_in exceeds max", + req: &dataproxy.CreateUploadLocationRequest{ + FilenameRoot: "test-root", + ExpiresIn: durationpb.New(2 * time.Hour), + }, + wantErr: true, + errMsg: "exceeds maximum allowed duration", + }, + { + name: "content_length exceeds max", + req: &dataproxy.CreateUploadLocationRequest{ + FilenameRoot: "test-root", + ContentLength: 1024 * 1024 * 200, + }, + wantErr: true, + errMsg: "exceeds maximum allowed size", + }, + { + name: "valid request without expires_in (will use default)", + req: &dataproxy.CreateUploadLocationRequest{ + FilenameRoot: "test-root", + }, + wantErr: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := validateUploadRequest(ctx, tt.req, cfg) + + if tt.wantErr { + assert.Error(t, err) + assert.Contains(t, err.Error(), tt.errMsg) + } else { + assert.NoError(t, err) + } + }) + } +} diff --git a/dataproxy/test/scripts/create_upload_location.sh b/dataproxy/test/scripts/create_upload_location.sh new file mode 100755 index 0000000000..27689d3246 --- /dev/null +++ b/dataproxy/test/scripts/create_upload_location.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +ENDPOINT="${ENDPOINT:-http://localhost:8088}" +PROJECT="${PROJECT:-testproject}" +DOMAIN="${DOMAIN:-development}" +ORG="${ORG:-testorg}" +FILENAME="${FILENAME:-test-file.txt}" +FILENAME_ROOT="${FILENAME_ROOT:-test-upload}" + +# Create a simple MD5 hash (16 bytes in base64) +# "test-content-hash" -> base64 encoded +CONTENT_MD5="dGVzdC1jb250ZW50LWhhc2g=" + +buf curl --schema . $ENDPOINT/flyteidl2.dataproxy.DataProxyService/CreateUploadLocation --data @- <\033[0m\n"} /^[a-zA-Z_0-9-]+:.*?##/ { printf " \033[36m%-15s\033[0m %s\n", $$1, $$2 } /^##@/ { printf "\n\033[1m%s\033[0m\n", substr($$0, 5) } ' $(MAKEFILE_LIST) + +##@ Development + +.PHONY: manifests +manifests: controller-gen ## Generate WebhookConfiguration, ClusterRole and CustomResourceDefinition objects. + $(CONTROLLER_GEN) rbac:roleName=manager-role crd webhook paths="./..." output:crd:artifacts:config=config/crd/bases + +.PHONY: generate +generate: controller-gen ## Generate code containing DeepCopy, DeepCopyInto, and DeepCopyObject method implementations. + $(CONTROLLER_GEN) object:headerFile="hack/boilerplate.go.txt" paths="./..." + +.PHONY: fmt +fmt: ## Run go fmt against code. + go fmt ./... + +.PHONY: vet +vet: ## Run go vet against code. + go vet ./... + +.PHONY: test +test: manifests generate fmt vet setup-envtest ## Run tests. + KUBEBUILDER_ASSETS="$(shell $(ENVTEST) use $(ENVTEST_K8S_VERSION) --bin-dir $(LOCALBIN) -p path)" go test $$(go list ./... | grep -v /e2e) -coverprofile cover.out + +# TODO(user): To use a different vendor for e2e tests, modify the setup under 'tests/e2e'. +# The default setup assumes Kind is pre-installed and builds/loads the Manager Docker image locally. +# CertManager is installed by default; skip with: +# - CERT_MANAGER_INSTALL_SKIP=true +KIND_CLUSTER ?= executor-test-e2e + +.PHONY: setup-test-e2e +setup-test-e2e: ## Set up a Kind cluster for e2e tests if it does not exist + @command -v $(KIND) >/dev/null 2>&1 || { \ + echo "Kind is not installed. Please install Kind manually."; \ + exit 1; \ + } + @case "$$($(KIND) get clusters)" in \ + *"$(KIND_CLUSTER)"*) \ + echo "Kind cluster '$(KIND_CLUSTER)' already exists. Skipping creation." ;; \ + *) \ + echo "Creating Kind cluster '$(KIND_CLUSTER)'..."; \ + $(KIND) create cluster --name $(KIND_CLUSTER) ;; \ + esac + +.PHONY: test-e2e +test-e2e: setup-test-e2e manifests generate fmt vet ## Run the e2e tests. Expected an isolated environment using Kind. + KIND=$(KIND) KIND_CLUSTER=$(KIND_CLUSTER) go test -tags=e2e ./test/e2e/ -v -ginkgo.v + $(MAKE) cleanup-test-e2e + +.PHONY: cleanup-test-e2e +cleanup-test-e2e: ## Tear down the Kind cluster used for e2e tests + @$(KIND) delete cluster --name $(KIND_CLUSTER) + +.PHONY: lint +lint: golangci-lint ## Run golangci-lint linter + $(GOLANGCI_LINT) run + +.PHONY: lint-fix +lint-fix: golangci-lint ## Run golangci-lint linter and perform fixes + $(GOLANGCI_LINT) run --fix + +.PHONY: lint-config +lint-config: golangci-lint ## Verify golangci-lint linter configuration + $(GOLANGCI_LINT) config verify + +##@ Build + +.PHONY: build +build: manifests generate fmt vet ## Build manager binary. + go build -o bin/manager cmd/main.go + +.PHONY: run +run: manifests generate fmt vet ## Run a controller from your host. + go run ./cmd/main.go + +# If you wish to build the manager image targeting other platforms you can use the --platform flag. +# (i.e. docker build --platform linux/arm64). However, you must enable docker buildKit for it. +# More info: https://docs.docker.com/develop/develop-images/build_enhancements/ +.PHONY: docker-build +docker-build: ## Build docker image with the manager. + $(CONTAINER_TOOL) build -t ${IMG} -f Dockerfile .. + +.PHONY: docker-push +docker-push: ## Push docker image with the manager. + $(CONTAINER_TOOL) push ${IMG} + +# PLATFORMS defines the target platforms for the manager image be built to provide support to multiple +# architectures. (i.e. make docker-buildx IMG=myregistry/mypoperator:0.0.1). To use this option you need to: +# - be able to use docker buildx. More info: https://docs.docker.com/build/buildx/ +# - have enabled BuildKit. More info: https://docs.docker.com/develop/develop-images/build_enhancements/ +# - be able to push the image to your registry (i.e. if you do not set a valid value via IMG=> then the export will fail) +# To adequately provide solutions that are compatible with multiple platforms, you should consider using this option. +PLATFORMS ?= linux/arm64,linux/amd64,linux/s390x,linux/ppc64le +.PHONY: docker-buildx +docker-buildx: ## Build and push docker image for the manager for cross-platform support + # copy existing Dockerfile and insert --platform=${BUILDPLATFORM} into Dockerfile.cross, and preserve the original Dockerfile + sed -e '1 s/\(^FROM\)/FROM --platform=\$$\{BUILDPLATFORM\}/; t' -e ' 1,// s//FROM --platform=\$$\{BUILDPLATFORM\}/' Dockerfile > Dockerfile.cross + - $(CONTAINER_TOOL) buildx create --name executor-builder + $(CONTAINER_TOOL) buildx use executor-builder + - $(CONTAINER_TOOL) buildx build --push --platform=$(PLATFORMS) --tag ${IMG} -f Dockerfile.cross . + - $(CONTAINER_TOOL) buildx rm executor-builder + rm Dockerfile.cross + +.PHONY: build-installer +build-installer: manifests generate kustomize ## Generate a consolidated YAML with CRDs and deployment. + mkdir -p dist + cd config/manager && $(KUSTOMIZE) edit set image controller=${IMG} + $(KUSTOMIZE) build config/default > dist/install.yaml + +##@ Deployment + +ifndef ignore-not-found + ignore-not-found = false +endif + +.PHONY: install +install: manifests kustomize ## Install CRDs into the K8s cluster specified in ~/.kube/config. + @out="$$( $(KUSTOMIZE) build config/crd 2>/dev/null || true )"; \ + if [ -n "$$out" ]; then echo "$$out" | $(KUBECTL) apply -f -; else echo "No CRDs to install; skipping."; fi + +.PHONY: uninstall +uninstall: manifests kustomize ## Uninstall CRDs from the K8s cluster specified in ~/.kube/config. Call with ignore-not-found=true to ignore resource not found errors during deletion. + @out="$$( $(KUSTOMIZE) build config/crd 2>/dev/null || true )"; \ + if [ -n "$$out" ]; then echo "$$out" | $(KUBECTL) delete --ignore-not-found=$(ignore-not-found) -f -; else echo "No CRDs to delete; skipping."; fi + +.PHONY: deploy +deploy: manifests kustomize ## Deploy controller to the K8s cluster specified in ~/.kube/config. + cd config/manager && $(KUSTOMIZE) edit set image controller=${IMG} + $(KUSTOMIZE) build config/default | $(KUBECTL) apply -f - + +.PHONY: undeploy +undeploy: kustomize ## Undeploy controller from the K8s cluster specified in ~/.kube/config. Call with ignore-not-found=true to ignore resource not found errors during deletion. + $(KUSTOMIZE) build config/default | $(KUBECTL) delete --ignore-not-found=$(ignore-not-found) -f - + +##@ Dependencies + +## Location to install dependencies to +LOCALBIN ?= $(shell pwd)/bin +$(LOCALBIN): + mkdir -p $(LOCALBIN) + +.PHONY: clean +clean: ## Cleanup local binaries such as controller-gen and kustomize + rm -rf $(LOCALBIN) + +## Tool Binaries +KUBECTL ?= kubectl +KIND ?= kind +KUSTOMIZE ?= $(LOCALBIN)/kustomize +CONTROLLER_GEN ?= $(LOCALBIN)/controller-gen +ENVTEST ?= $(LOCALBIN)/setup-envtest +GOLANGCI_LINT = $(LOCALBIN)/golangci-lint + +## Tool Versions +KUSTOMIZE_VERSION ?= v5.7.1 +CONTROLLER_TOOLS_VERSION ?= v0.19.0 +#ENVTEST_VERSION is the version of controller-runtime release branch to fetch the envtest setup script (i.e. release-0.20) +ENVTEST_VERSION ?= $(shell go list -m -f "{{ .Version }}" sigs.k8s.io/controller-runtime | awk -F'[v.]' '{printf "release-%d.%d", $$2, $$3}') +#ENVTEST_K8S_VERSION is the version of Kubernetes to use for setting up ENVTEST binaries (i.e. 1.31) +ENVTEST_K8S_VERSION ?= $(shell go list -m -f "{{ .Version }}" k8s.io/api | awk -F'[v.]' '{printf "1.%d", $$3}') +GOLANGCI_LINT_VERSION ?= v2.4.0 + +.PHONY: kustomize +kustomize: $(KUSTOMIZE) ## Download kustomize locally if necessary. +$(KUSTOMIZE): $(LOCALBIN) + $(call go-install-tool,$(KUSTOMIZE),sigs.k8s.io/kustomize/kustomize/v5,$(KUSTOMIZE_VERSION)) + +.PHONY: controller-gen +controller-gen: $(CONTROLLER_GEN) ## Download controller-gen locally if necessary. +$(CONTROLLER_GEN): $(LOCALBIN) + $(call go-install-tool,$(CONTROLLER_GEN),sigs.k8s.io/controller-tools/cmd/controller-gen,$(CONTROLLER_TOOLS_VERSION)) + +.PHONY: setup-envtest +setup-envtest: envtest ## Download the binaries required for ENVTEST in the local bin directory. + @echo "Setting up envtest binaries for Kubernetes version $(ENVTEST_K8S_VERSION)..." + @$(ENVTEST) use $(ENVTEST_K8S_VERSION) --bin-dir $(LOCALBIN) -p path || { \ + echo "Error: Failed to set up envtest binaries for version $(ENVTEST_K8S_VERSION)."; \ + exit 1; \ + } + +.PHONY: envtest +envtest: $(ENVTEST) ## Download setup-envtest locally if necessary. +$(ENVTEST): $(LOCALBIN) + $(call go-install-tool,$(ENVTEST),sigs.k8s.io/controller-runtime/tools/setup-envtest,$(ENVTEST_VERSION)) + +.PHONY: golangci-lint +golangci-lint: $(GOLANGCI_LINT) ## Download golangci-lint locally if necessary. +$(GOLANGCI_LINT): $(LOCALBIN) + $(call go-install-tool,$(GOLANGCI_LINT),github.com/golangci/golangci-lint/v2/cmd/golangci-lint,$(GOLANGCI_LINT_VERSION)) + +# go-install-tool will 'go install' any package with custom target and name of binary, if it doesn't exist +# $1 - target path with name of binary +# $2 - package url which can be installed +# $3 - specific version of package +define go-install-tool +@[ -f "$(1)-$(3)" ] && [ "$$(readlink -- "$(1)" 2>/dev/null)" = "$(1)-$(3)" ] || { \ +set -e; \ +package=$(2)@$(3) ;\ +echo "Downloading $${package}" ;\ +rm -f $(1) ;\ +GOBIN=$(LOCALBIN) go install $${package} ;\ +mv $(1) $(1)-$(3) ;\ +} ;\ +ln -sf $$(realpath $(1)-$(3)) $(1) +endef diff --git a/executor/PROJECT b/executor/PROJECT new file mode 100644 index 0000000000..f3b14c92e8 --- /dev/null +++ b/executor/PROJECT @@ -0,0 +1,21 @@ +# Code generated by tool. DO NOT EDIT. +# This file is used to track the info used to scaffold your project +# and allow the plugins properly work. +# More info: https://book.kubebuilder.io/reference/project-config.html +cliVersion: 4.9.0 +domain: flyte.org +layout: +- go.kubebuilder.io/v4 +projectName: executor +repo: github.com/flyteorg/flyte/v2/executor +resources: +- api: + crdVersion: v1 + namespaced: true + controller: true + domain: flyte.org + group: flyte.org + kind: TaskAction + path: github.com/flyteorg/flyte/v2/executor/api/v1 + version: v1 +version: "3" diff --git a/executor/README.md b/executor/README.md new file mode 100644 index 0000000000..583215a077 --- /dev/null +++ b/executor/README.md @@ -0,0 +1,150 @@ +# Executor + +The Executor is a Kubernetes operator that manages the execution of Flyte tasks in the data plane. Built using the Kubernetes Operator pattern with `controller-runtime`, it watches and reconciles `TaskAction` custom resources to orchestrate task execution. + +## Description + +The Executor controller is responsible for: +- **Monitoring TaskAction CRs**: Watches for TaskAction resources created in the Kubernetes cluster +- **Task Execution**: Executes tasks based on the specifications defined in TaskAction resources +- **State Management**: Reports task execution state to the State Service +- **Lifecycle Management**: Manages the full lifecycle of task execution from queued to completed/failed states + +The executor uses conditions to track task progress: +- `Progressing`: Indicates active execution (reasons: Queued, Initializing, Executing) +- `Succeeded`: Task completed successfully +- `Failed`: Task execution failed + + +## Getting Started + +### Prerequisites +- go version v1.24.0+ +- docker version 17.03+. +- kubectl version v1.11.3+. +- Access to a Kubernetes v1.11.3+ cluster. + +### To Deploy on the cluster +**Build and push your image to the location specified by `IMG`:** + +```sh +make docker-build docker-push IMG=/executor:tag +``` + +**NOTE:** This image ought to be published in the personal registry you specified. +And it is required to have access to pull the image from the working environment. +Make sure you have the proper permission to the registry if the above commands donโ€™t work. + +**Install the CRDs into the cluster:** + +```sh +make install +``` + +**Deploy the Manager to the cluster with the image specified by `IMG`:** + +```sh +make deploy IMG=/executor:tag +``` + +> **NOTE**: If you encounter RBAC errors, you may need to grant yourself cluster-admin +privileges or be logged in as admin. + +**Create instances of your solution** +You can apply the samples (examples) from the config/sample: + +```sh +kubectl apply -k config/samples/ +``` + +>**NOTE**: Ensure that the samples has default values to test it out. + +### To Uninstall +**Delete the instances (CRs) from the cluster:** + +```sh +kubectl delete -k config/samples/ +``` + +**Delete the APIs(CRDs) from the cluster:** + +```sh +make uninstall +``` + +**UnDeploy the controller from the cluster:** + +```sh +make undeploy +``` + +## Project Distribution + +Following the options to release and provide this solution to the users. + +### By providing a bundle with all YAML files + +1. Build the installer for the image built and published in the registry: + +```sh +make build-installer IMG=/executor:tag +``` + +**NOTE:** The makefile target mentioned above generates an 'install.yaml' +file in the dist directory. This file contains all the resources built +with Kustomize, which are necessary to install this project without its +dependencies. + +2. Using the installer + +Users can just run 'kubectl apply -f ' to install +the project, i.e.: + +```sh +kubectl apply -f https://raw.githubusercontent.com//executor//dist/install.yaml +``` + +### By providing a Helm Chart + +1. Build the chart using the optional helm plugin + +```sh +kubebuilder edit --plugins=helm/v1-alpha +``` + +2. See that a chart was generated under 'dist/chart', and users +can obtain this solution from there. + +**NOTE:** If you change the project, you need to update the Helm Chart +using the same command above to sync the latest changes. Furthermore, +if you create webhooks, you need to use the above command with +the '--force' flag and manually ensure that any custom configuration +previously added to 'dist/chart/values.yaml' or 'dist/chart/manager/manager.yaml' +is manually re-applied afterwards. + + +## Contributing + +Please read our [CONTRIBUTING](../CONTRIBUTING.md) guide before making a pull request. Refer to our +[DEVELOPMENT.md](DEVELOPMENT.md) to build and run tests for executor locally. + +**NOTE:** Run `make help` for more information on all potential `make` targets + +More information can be found via the [Kubebuilder Documentation](https://book.kubebuilder.io/introduction.html) + +## License + +Copyright 2025. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + diff --git a/executor/api/v1/groupversion_info.go b/executor/api/v1/groupversion_info.go new file mode 100644 index 0000000000..ad3d901438 --- /dev/null +++ b/executor/api/v1/groupversion_info.go @@ -0,0 +1,36 @@ +/* +Copyright 2025. + +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 contains API Schema definitions for the flyte.org v1 API group. +// +kubebuilder:object:generate=true +// +groupName=flyte.org +package v1 + +import ( + "k8s.io/apimachinery/pkg/runtime/schema" + "sigs.k8s.io/controller-runtime/pkg/scheme" +) + +var ( + // GroupVersion is group version used to register these objects. + GroupVersion = schema.GroupVersion{Group: "flyte.org", Version: "v1"} + + // SchemeBuilder is used to add go types to the GroupVersionKind scheme. + SchemeBuilder = &scheme.Builder{GroupVersion: GroupVersion} + + // AddToScheme adds the types in this group-version to the given scheme. + AddToScheme = SchemeBuilder.AddToScheme +) diff --git a/executor/api/v1/taskaction_types.go b/executor/api/v1/taskaction_types.go new file mode 100644 index 0000000000..52452299c6 --- /dev/null +++ b/executor/api/v1/taskaction_types.go @@ -0,0 +1,222 @@ +/* +Copyright 2025. + +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 ( + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// EDIT THIS FILE! THIS IS SCAFFOLDING FOR YOU TO OWN! +// NOTE: json tags are required. Any new fields you add must have json tags for the fields to be serialized. + +type ( + TaskActionConditionType string + TaskActionConditionReason string +) + +// Condition type constants +// Following Kubernetes API conventions: +// - Condition types describe the current observed state +// - Use Reason field to track sub-states (like Queued, Initializing, Executing) +const ( + // ConditionTypeProgressing indicates whether the TaskAction is actively progressing. + // This is True when the TaskAction is queued, initializing, or executing. + // This is False when the TaskAction has completed or failed. + ConditionTypeProgressing TaskActionConditionType = "Progressing" + + // ConditionTypeSucceeded indicates whether the TaskAction has completed successfully. + // This is a terminal condition. Once True, the TaskAction will not be reconciled further. + ConditionTypeSucceeded TaskActionConditionType = "Succeeded" + + // ConditionTypeFailed indicates whether the TaskAction has failed. + // This is a terminal condition. Once True, the TaskAction will not be reconciled further. + ConditionTypeFailed TaskActionConditionType = "Failed" +) + +// Condition reason constants +// Reasons explain why a condition has a particular status. +// These are used in the Reason field of conditions to provide detailed sub-state information. +const ( + // ConditionReasonQueued indicates the TaskAction is queued and waiting for resources + ConditionReasonQueued TaskActionConditionReason = "Queued" + + // ConditionReasonInitializing indicates the TaskAction is being initialized + ConditionReasonInitializing TaskActionConditionReason = "Initializing" + + // ConditionReasonExecuting indicates the TaskAction is actively executing + ConditionReasonExecuting TaskActionConditionReason = "Executing" + + // ConditionReasonCompleted indicates the TaskAction has completed successfully + ConditionReasonCompleted TaskActionConditionReason = "Completed" +) + +// TaskActionSpec defines the desired state of TaskAction +type TaskActionSpec struct { + // RunName is the name of the run this action belongs to + // +kubebuilder:validation:Required + // +kubebuilder:validation:MinLength=1 + // +kubebuilder:validation:MaxLength=30 + RunName string `json:"runName"` + + // Org this action belongs to + // +kubebuilder:validation:Required + // +kubebuilder:validation:MinLength=1 + // +kubebuilder:validation:MaxLength=63 + Org string `json:"org"` + + // Project this action belongs to + // +kubebuilder:validation:Required + // +kubebuilder:validation:MinLength=1 + // +kubebuilder:validation:MaxLength=63 + Project string `json:"project"` + + // Domain this action belongs to + // +kubebuilder:validation:Required + // +kubebuilder:validation:MinLength=1 + // +kubebuilder:validation:MaxLength=63 + Domain string `json:"domain"` + + // ActionName is the unique name of this action within the run + // +kubebuilder:validation:Required + // +kubebuilder:validation:MinLength=1 + // +kubebuilder:validation:MaxLength=30 + ActionName string `json:"actionName"` + + // ParentActionName is the optional name of the parent action + // +optional + // +kubebuilder:validation:MinLength=1 + // +kubebuilder:validation:MaxLength=30 + ParentActionName *string `json:"parentActionName,omitempty"` + + // InputURI is the path to the input data for this action + // +kubebuilder:validation:Required + // +kubebuilder:validation:MinLength=1 + InputURI string `json:"inputUri"` + + // RunOutputBase is the base path where this action should write its output + // +kubebuilder:validation:Required + // +kubebuilder:validation:MinLength=1 + RunOutputBase string `json:"runOutputBase"` +} + +func (in *TaskActionSpec) GetActionSpec() (*workflow.ActionSpec, error) { + // Build ActionSpec from structured fields + spec := &workflow.ActionSpec{ + ActionId: &common.ActionIdentifier{ + Run: &common.RunIdentifier{ + Org: in.Org, + Project: in.Project, + Domain: in.Domain, + Name: in.RunName, + }, + Name: in.ActionName, + }, + ParentActionName: in.ParentActionName, + InputUri: in.InputURI, + RunOutputBase: in.RunOutputBase, + } + + return spec, nil +} + +func (in *TaskActionSpec) SetActionSpec(spec *workflow.ActionSpec) error { + // Populate structured fields from ActionSpec + if spec.ActionId != nil { + if spec.ActionId.Run != nil { + in.Org = spec.ActionId.Run.Org + in.Project = spec.ActionId.Run.Project + in.Domain = spec.ActionId.Run.Domain + in.RunName = spec.ActionId.Run.Name + } + in.ActionName = spec.ActionId.Name + } + in.ParentActionName = spec.ParentActionName + in.InputURI = spec.InputUri + in.RunOutputBase = spec.RunOutputBase + + return nil +} + +// TaskActionStatus defines the observed state of TaskAction. +type TaskActionStatus struct { + // INSERT ADDITIONAL STATUS FIELD - define observed state of cluster + // Important: Run "make" to regenerate code after modifying this file + + // For Kubernetes API conventions, see: + // https://github.com/kubernetes/community/blob/master/contributors/devel/sig-architecture/api-conventions.md#typical-status-properties + + // StateJSON is the JSON serialized NodeStatus that was last sent to the State Service + // +optional + StateJSON string `json:"stateJson,omitempty"` + + // conditions represent the current state of the TaskAction resource. + // Each condition has a unique type and reflects the status of a specific aspect of the resource. + // + // Standard condition types include: + // - "Available": the resource is fully functional + // - "Progressing": the resource is being created or updated + // - "Degraded": the resource failed to reach or maintain its desired state + // + // The status of each condition is one of True, False, or Unknown. + // +listType=map + // +listMapKey=type + // +optional + Conditions []metav1.Condition `json:"conditions,omitempty"` +} + +// +kubebuilder:object:root=true +// +kubebuilder:subresource:status +// +kubebuilder:printcolumn:name="Run",type="string",JSONPath=".spec.runName" +// +kubebuilder:printcolumn:name="Action",type="string",JSONPath=".spec.actionName" +// +kubebuilder:printcolumn:name="Status",type="string",JSONPath=".status.conditions[?(@.type=='Progressing')].reason" +// +kubebuilder:printcolumn:name="Age",type="date",JSONPath=".metadata.creationTimestamp" +// +kubebuilder:printcolumn:name="Progressing",type="string",JSONPath=".status.conditions[?(@.type=='Progressing')].status",priority=1 +// +kubebuilder:printcolumn:name="Succeeded",type="string",JSONPath=".status.conditions[?(@.type=='Succeeded')].status",priority=1 +// +kubebuilder:printcolumn:name="Failed",type="string",JSONPath=".status.conditions[?(@.type=='Failed')].status",priority=1 + +// TaskAction is the Schema for the taskactions API +type TaskAction struct { + metav1.TypeMeta `json:",inline"` + + // metadata is a standard object metadata + // +optional + metav1.ObjectMeta `json:"metadata,omitempty,omitzero"` + + // spec defines the desired state of TaskAction + // +required + Spec TaskActionSpec `json:"spec"` + + // status defines the observed state of TaskAction + // +optional + Status TaskActionStatus `json:"status,omitempty,omitzero"` +} + +// +kubebuilder:object:root=true + +// TaskActionList contains a list of TaskAction +type TaskActionList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []TaskAction `json:"items"` +} + +func init() { + SchemeBuilder.Register(&TaskAction{}, &TaskActionList{}) +} diff --git a/executor/api/v1/zz_generated.deepcopy.go b/executor/api/v1/zz_generated.deepcopy.go new file mode 100644 index 0000000000..a5627c610f --- /dev/null +++ b/executor/api/v1/zz_generated.deepcopy.go @@ -0,0 +1,127 @@ +//go:build !ignore_autogenerated + +/* +Copyright 2025. + +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 controller-gen. DO NOT EDIT. + +package v1 + +import ( + metav1 "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 *TaskAction) DeepCopyInto(out *TaskAction) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + in.Status.DeepCopyInto(&out.Status) +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TaskAction. +func (in *TaskAction) DeepCopy() *TaskAction { + if in == nil { + return nil + } + out := new(TaskAction) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *TaskAction) 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 *TaskActionList) DeepCopyInto(out *TaskActionList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]TaskAction, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TaskActionList. +func (in *TaskActionList) DeepCopy() *TaskActionList { + if in == nil { + return nil + } + out := new(TaskActionList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *TaskActionList) 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 *TaskActionSpec) DeepCopyInto(out *TaskActionSpec) { + *out = *in + if in.ParentActionName != nil { + in, out := &in.ParentActionName, &out.ParentActionName + *out = new(string) + **out = **in + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TaskActionSpec. +func (in *TaskActionSpec) DeepCopy() *TaskActionSpec { + if in == nil { + return nil + } + out := new(TaskActionSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *TaskActionStatus) DeepCopyInto(out *TaskActionStatus) { + *out = *in + if in.Conditions != nil { + in, out := &in.Conditions, &out.Conditions + *out = make([]metav1.Condition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TaskActionStatus. +func (in *TaskActionStatus) DeepCopy() *TaskActionStatus { + if in == nil { + return nil + } + out := new(TaskActionStatus) + in.DeepCopyInto(out) + return out +} diff --git a/executor/cmd/main.go b/executor/cmd/main.go new file mode 100644 index 0000000000..20f03d2303 --- /dev/null +++ b/executor/cmd/main.go @@ -0,0 +1,207 @@ +/* +Copyright 2025. + +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 main + +import ( + "crypto/tls" + "flag" + "os" + + "k8s.io/apimachinery/pkg/runtime" + utilruntime "k8s.io/apimachinery/pkg/util/runtime" + clientgoscheme "k8s.io/client-go/kubernetes/scheme" + // Import all Kubernetes client auth plugins (e.g. Azure, GCP, OIDC, etc.) + // to ensure that exec-entrypoint and run can make use of them. + _ "k8s.io/client-go/plugin/pkg/client/auth" + ctrl "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/healthz" + "sigs.k8s.io/controller-runtime/pkg/log/zap" + "sigs.k8s.io/controller-runtime/pkg/metrics/filters" + metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server" + "sigs.k8s.io/controller-runtime/pkg/webhook" + + flyteorgv1 "github.com/flyteorg/flyte/v2/executor/api/v1" + "github.com/flyteorg/flyte/v2/executor/pkg/controller" +) + +var ( + scheme = runtime.NewScheme() + setupLog = ctrl.Log.WithName("setup") +) + +func init() { + utilruntime.Must(clientgoscheme.AddToScheme(scheme)) + + utilruntime.Must(flyteorgv1.AddToScheme(scheme)) + // +kubebuilder:scaffold:scheme +} + +// nolint:gocyclo +func main() { + var metricsAddr string + var metricsCertPath, metricsCertName, metricsCertKey string + var webhookCertPath, webhookCertName, webhookCertKey string + var enableLeaderElection bool + var probeAddr string + var secureMetrics bool + var enableHTTP2 bool + var stateServiceURL string + var tlsOpts []func(*tls.Config) + flag.StringVar(&metricsAddr, "metrics-bind-address", "0", "The address the metrics endpoint binds to. "+ + "Use :8443 for HTTPS or :8080 for HTTP, or leave as 0 to disable the metrics service.") + flag.StringVar(&probeAddr, "health-probe-bind-address", ":8081", "The address the probe endpoint binds to.") + flag.BoolVar(&enableLeaderElection, "leader-elect", false, + "Enable leader election for controller manager. "+ + "Enabling this will ensure there is only one active controller manager.") + flag.BoolVar(&secureMetrics, "metrics-secure", true, + "If set, the metrics endpoint is served securely via HTTPS. Use --metrics-secure=false to use HTTP instead.") + flag.StringVar(&webhookCertPath, "webhook-cert-path", "", "The directory that contains the webhook certificate.") + flag.StringVar(&webhookCertName, "webhook-cert-name", "tls.crt", "The name of the webhook certificate file.") + flag.StringVar(&webhookCertKey, "webhook-cert-key", "tls.key", "The name of the webhook key file.") + flag.StringVar(&metricsCertPath, "metrics-cert-path", "", + "The directory that contains the metrics server certificate.") + flag.StringVar(&metricsCertName, "metrics-cert-name", "tls.crt", "The name of the metrics server certificate file.") + flag.StringVar(&metricsCertKey, "metrics-cert-key", "tls.key", "The name of the metrics server key file.") + flag.BoolVar(&enableHTTP2, "enable-http2", false, + "If set, HTTP/2 will be enabled for the metrics and webhook servers") + flag.StringVar(&stateServiceURL, "state-service-url", "http://localhost:8090", + "The URL of the State Service for reporting action state updates") + opts := zap.Options{ + Development: true, + } + opts.BindFlags(flag.CommandLine) + flag.Parse() + + ctrl.SetLogger(zap.New(zap.UseFlagOptions(&opts))) + + // if the enable-http2 flag is false (the default), http/2 should be disabled + // due to its vulnerabilities. More specifically, disabling http/2 will + // prevent from being vulnerable to the HTTP/2 Stream Cancellation and + // Rapid Reset CVEs. For more information see: + // - https://github.com/advisories/GHSA-qppj-fm5r-hxr3 + // - https://github.com/advisories/GHSA-4374-p667-p6c8 + disableHTTP2 := func(c *tls.Config) { + setupLog.Info("disabling http/2") + c.NextProtos = []string{"http/1.1"} + } + + if !enableHTTP2 { + tlsOpts = append(tlsOpts, disableHTTP2) + } + + // Initial webhook TLS options + webhookTLSOpts := tlsOpts + webhookServerOptions := webhook.Options{ + TLSOpts: webhookTLSOpts, + } + + if len(webhookCertPath) > 0 { + setupLog.Info("Initializing webhook certificate watcher using provided certificates", + "webhook-cert-path", webhookCertPath, "webhook-cert-name", webhookCertName, "webhook-cert-key", webhookCertKey) + + webhookServerOptions.CertDir = webhookCertPath + webhookServerOptions.CertName = webhookCertName + webhookServerOptions.KeyName = webhookCertKey + } + + webhookServer := webhook.NewServer(webhookServerOptions) + + // Metrics endpoint is enabled in 'config/default/kustomization.yaml'. The Metrics options configure the server. + // More info: + // - https://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.22.1/pkg/metrics/server + // - https://book.kubebuilder.io/reference/metrics.html + metricsServerOptions := metricsserver.Options{ + BindAddress: metricsAddr, + SecureServing: secureMetrics, + TLSOpts: tlsOpts, + } + + if secureMetrics { + // FilterProvider is used to protect the metrics endpoint with authn/authz. + // These configurations ensure that only authorized users and service accounts + // can access the metrics endpoint. The RBAC are configured in 'config/rbac/kustomization.yaml'. More info: + // https://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.22.1/pkg/metrics/filters#WithAuthenticationAndAuthorization + metricsServerOptions.FilterProvider = filters.WithAuthenticationAndAuthorization + } + + // If the certificate is not specified, controller-runtime will automatically + // generate self-signed certificates for the metrics server. While convenient for development and testing, + // this setup is not recommended for production. + // + // TODO(user): If you enable certManager, uncomment the following lines: + // - [METRICS-WITH-CERTS] at config/default/kustomization.yaml to generate and use certificates + // managed by cert-manager for the metrics server. + // - [PROMETHEUS-WITH-CERTS] at config/prometheus/kustomization.yaml for TLS certification. + if len(metricsCertPath) > 0 { + setupLog.Info("Initializing metrics certificate watcher using provided certificates", + "metrics-cert-path", metricsCertPath, "metrics-cert-name", metricsCertName, "metrics-cert-key", metricsCertKey) + + metricsServerOptions.CertDir = metricsCertPath + metricsServerOptions.CertName = metricsCertName + metricsServerOptions.KeyName = metricsCertKey + } + + mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{ + Scheme: scheme, + Metrics: metricsServerOptions, + WebhookServer: webhookServer, + HealthProbeBindAddress: probeAddr, + LeaderElection: enableLeaderElection, + LeaderElectionID: "abf369a8.flyte.org", + // LeaderElectionReleaseOnCancel defines if the leader should step down voluntarily + // when the Manager ends. This requires the binary to immediately end when the + // Manager is stopped, otherwise, this setting is unsafe. Setting this significantly + // speeds up voluntary leader transitions as the new leader don't have to wait + // LeaseDuration time first. + // + // In the default scaffold provided, the program ends immediately after + // the manager stops, so would be fine to enable this option. However, + // if you are doing or is intended to do any operation such as perform cleanups + // after the manager stops then its usage might be unsafe. + // LeaderElectionReleaseOnCancel: true, + }) + if err != nil { + setupLog.Error(err, "unable to start manager") + os.Exit(1) + } + + if err := controller.NewTaskActionReconciler( + mgr.GetClient(), + mgr.GetScheme(), + stateServiceURL, + ).SetupWithManager(mgr); err != nil { + setupLog.Error(err, "unable to create controller", "controller", "TaskAction") + os.Exit(1) + } + setupLog.Info("TaskActionReconciler configured", "state-service-url", stateServiceURL) + // +kubebuilder:scaffold:builder + + if err := mgr.AddHealthzCheck("healthz", healthz.Ping); err != nil { + setupLog.Error(err, "unable to set up health check") + os.Exit(1) + } + if err := mgr.AddReadyzCheck("readyz", healthz.Ping); err != nil { + setupLog.Error(err, "unable to set up ready check") + os.Exit(1) + } + + setupLog.Info("starting manager") + if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil { + setupLog.Error(err, "problem running manager") + os.Exit(1) + } +} diff --git a/executor/config/crd/bases/flyte.org_taskactions.yaml b/executor/config/crd/bases/flyte.org_taskactions.yaml new file mode 100644 index 0000000000..5cb943cd3f --- /dev/null +++ b/executor/config/crd/bases/flyte.org_taskactions.yaml @@ -0,0 +1,199 @@ +--- +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + controller-gen.kubebuilder.io/version: v0.19.0 + name: taskactions.flyte.org +spec: + group: flyte.org + names: + kind: TaskAction + listKind: TaskActionList + plural: taskactions + singular: taskaction + scope: Namespaced + versions: + - additionalPrinterColumns: + - jsonPath: .spec.runName + name: Run + type: string + - jsonPath: .spec.actionName + name: Action + type: string + - jsonPath: .status.conditions[?(@.type=='Progressing')].reason + name: Status + type: string + - jsonPath: .metadata.creationTimestamp + name: Age + type: date + - jsonPath: .status.conditions[?(@.type=='Progressing')].status + name: Progressing + priority: 1 + type: string + - jsonPath: .status.conditions[?(@.type=='Succeeded')].status + name: Succeeded + priority: 1 + type: string + - jsonPath: .status.conditions[?(@.type=='Failed')].status + name: Failed + priority: 1 + type: string + name: v1 + schema: + openAPIV3Schema: + description: TaskAction is the Schema for the taskactions 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: spec defines the desired state of TaskAction + properties: + actionName: + description: ActionName is the unique name of this action within the + run + maxLength: 30 + minLength: 1 + type: string + domain: + description: Domain this action belongs to + maxLength: 63 + minLength: 1 + type: string + inputUri: + description: InputURI is the path to the input data for this action + minLength: 1 + type: string + org: + description: Org this action belongs to + maxLength: 63 + minLength: 1 + type: string + parentActionName: + description: ParentActionName is the optional name of the parent action + maxLength: 30 + minLength: 1 + type: string + project: + description: Project this action belongs to + maxLength: 63 + minLength: 1 + type: string + runName: + description: RunName is the name of the run this action belongs to + maxLength: 30 + minLength: 1 + type: string + runOutputBase: + description: RunOutputBase is the base path where this action should + write its output + minLength: 1 + type: string + required: + - actionName + - domain + - inputUri + - org + - project + - runName + - runOutputBase + type: object + status: + description: status defines the observed state of TaskAction + properties: + conditions: + description: |- + conditions represent the current state of the TaskAction resource. + Each condition has a unique type and reflects the status of a specific aspect of the resource. + + Standard condition types include: + - "Available": the resource is fully functional + - "Progressing": the resource is being created or updated + - "Degraded": the resource failed to reach or maintain its desired state + + The status of each condition is one of True, False, or Unknown. + items: + description: Condition contains details for one aspect of the current + state of this API Resource. + properties: + lastTransitionTime: + description: |- + lastTransitionTime is the last time the condition transitioned from one status to another. + This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. + format: date-time + type: string + message: + description: |- + message is a human readable message indicating details about the transition. + This may be an empty string. + maxLength: 32768 + type: string + observedGeneration: + description: |- + observedGeneration represents the .metadata.generation that the condition was set based upon. + For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date + with respect to the current state of the instance. + format: int64 + minimum: 0 + type: integer + reason: + description: |- + reason contains a programmatic identifier indicating the reason for the condition's last transition. + Producers of specific condition types may define expected values and meanings for this field, + and whether the values are considered a guaranteed API. + The value should be a CamelCase string. + This field may not be empty. + maxLength: 1024 + minLength: 1 + pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$ + type: string + status: + description: status of the condition, one of True, False, Unknown. + enum: + - "True" + - "False" + - Unknown + type: string + type: + description: type of condition in CamelCase or in foo.example.com/CamelCase. + maxLength: 316 + pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$ + type: string + required: + - lastTransitionTime + - message + - reason + - status + - type + type: object + type: array + x-kubernetes-list-map-keys: + - type + x-kubernetes-list-type: map + stateJson: + description: StateJSON is the JSON serialized NodeStatus that was + last sent to the State Service + type: string + type: object + required: + - spec + type: object + served: true + storage: true + subresources: + status: {} diff --git a/executor/config/crd/kustomization.yaml b/executor/config/crd/kustomization.yaml new file mode 100644 index 0000000000..eb1df2e15e --- /dev/null +++ b/executor/config/crd/kustomization.yaml @@ -0,0 +1,16 @@ +# This kustomization.yaml is not intended to be run by itself, +# since it depends on service name and namespace that are out of this kustomize package. +# It should be run by config/default +resources: +- bases/flyte.org_taskactions.yaml +# +kubebuilder:scaffold:crdkustomizeresource + +patches: +# [WEBHOOK] To enable webhook, uncomment all the sections with [WEBHOOK] prefix. +# patches here are for enabling the conversion webhook for each CRD +# +kubebuilder:scaffold:crdkustomizewebhookpatch + +# [WEBHOOK] To enable webhook, uncomment the following section +# the following config is for teaching kustomize how to do kustomization for CRDs. +#configurations: +#- kustomizeconfig.yaml diff --git a/executor/config/crd/kustomizeconfig.yaml b/executor/config/crd/kustomizeconfig.yaml new file mode 100644 index 0000000000..ec5c150a9d --- /dev/null +++ b/executor/config/crd/kustomizeconfig.yaml @@ -0,0 +1,19 @@ +# This file is for teaching kustomize how to substitute name and namespace reference in CRD +nameReference: +- kind: Service + version: v1 + fieldSpecs: + - kind: CustomResourceDefinition + version: v1 + group: apiextensions.k8s.io + path: spec/conversion/webhook/clientConfig/service/name + +namespace: +- kind: CustomResourceDefinition + version: v1 + group: apiextensions.k8s.io + path: spec/conversion/webhook/clientConfig/service/namespace + create: false + +varReference: +- path: metadata/annotations diff --git a/executor/config/default/cert_metrics_manager_patch.yaml b/executor/config/default/cert_metrics_manager_patch.yaml new file mode 100644 index 0000000000..d975015538 --- /dev/null +++ b/executor/config/default/cert_metrics_manager_patch.yaml @@ -0,0 +1,30 @@ +# This patch adds the args, volumes, and ports to allow the manager to use the metrics-server certs. + +# Add the volumeMount for the metrics-server certs +- op: add + path: /spec/template/spec/containers/0/volumeMounts/- + value: + mountPath: /tmp/k8s-metrics-server/metrics-certs + name: metrics-certs + readOnly: true + +# Add the --metrics-cert-path argument for the metrics server +- op: add + path: /spec/template/spec/containers/0/args/- + value: --metrics-cert-path=/tmp/k8s-metrics-server/metrics-certs + +# Add the metrics-server certs volume configuration +- op: add + path: /spec/template/spec/volumes/- + value: + name: metrics-certs + secret: + secretName: metrics-server-cert + optional: false + items: + - key: ca.crt + path: ca.crt + - key: tls.crt + path: tls.crt + - key: tls.key + path: tls.key diff --git a/executor/config/default/kustomization.yaml b/executor/config/default/kustomization.yaml new file mode 100644 index 0000000000..07ab34a211 --- /dev/null +++ b/executor/config/default/kustomization.yaml @@ -0,0 +1,234 @@ +# Adds namespace to all resources. +namespace: executor-system + +# Value of this field is prepended to the +# names of all resources, e.g. a deployment named +# "wordpress" becomes "alices-wordpress". +# Note that it should also match with the prefix (text before '-') of the namespace +# field above. +namePrefix: executor- + +# Labels to add to all resources and selectors. +#labels: +#- includeSelectors: true +# pairs: +# someName: someValue + +resources: +- ../crd +- ../rbac +- ../manager +# [WEBHOOK] To enable webhook, uncomment all the sections with [WEBHOOK] prefix including the one in +# crd/kustomization.yaml +#- ../webhook +# [CERTMANAGER] To enable cert-manager, uncomment all sections with 'CERTMANAGER'. 'WEBHOOK' components are required. +#- ../certmanager +# [PROMETHEUS] To enable prometheus monitor, uncomment all sections with 'PROMETHEUS'. +#- ../prometheus +# [METRICS] Expose the controller manager metrics service. +- metrics_service.yaml +# [NETWORK POLICY] Protect the /metrics endpoint and Webhook Server with NetworkPolicy. +# Only Pod(s) running a namespace labeled with 'metrics: enabled' will be able to gather the metrics. +# Only CR(s) which requires webhooks and are applied on namespaces labeled with 'webhooks: enabled' will +# be able to communicate with the Webhook Server. +#- ../network-policy + +# Uncomment the patches line if you enable Metrics +patches: +# [METRICS] The following patch will enable the metrics endpoint using HTTPS and the port :8443. +# More info: https://book.kubebuilder.io/reference/metrics +- path: manager_metrics_patch.yaml + target: + kind: Deployment + +# Uncomment the patches line if you enable Metrics and CertManager +# [METRICS-WITH-CERTS] To enable metrics protected with certManager, uncomment the following line. +# This patch will protect the metrics with certManager self-signed certs. +#- path: cert_metrics_manager_patch.yaml +# target: +# kind: Deployment + +# [WEBHOOK] To enable webhook, uncomment all the sections with [WEBHOOK] prefix including the one in +# crd/kustomization.yaml +#- path: manager_webhook_patch.yaml +# target: +# kind: Deployment + +# [CERTMANAGER] To enable cert-manager, uncomment all sections with 'CERTMANAGER' prefix. +# Uncomment the following replacements to add the cert-manager CA injection annotations +#replacements: +# - source: # Uncomment the following block to enable certificates for metrics +# kind: Service +# version: v1 +# name: controller-manager-metrics-service +# fieldPath: metadata.name +# targets: +# - select: +# kind: Certificate +# group: cert-manager.io +# version: v1 +# name: metrics-certs +# fieldPaths: +# - spec.dnsNames.0 +# - spec.dnsNames.1 +# options: +# delimiter: '.' +# index: 0 +# create: true +# - select: # Uncomment the following to set the Service name for TLS config in Prometheus ServiceMonitor +# kind: ServiceMonitor +# group: monitoring.coreos.com +# version: v1 +# name: controller-manager-metrics-monitor +# fieldPaths: +# - spec.endpoints.0.tlsConfig.serverName +# options: +# delimiter: '.' +# index: 0 +# create: true + +# - source: +# kind: Service +# version: v1 +# name: controller-manager-metrics-service +# fieldPath: metadata.namespace +# targets: +# - select: +# kind: Certificate +# group: cert-manager.io +# version: v1 +# name: metrics-certs +# fieldPaths: +# - spec.dnsNames.0 +# - spec.dnsNames.1 +# options: +# delimiter: '.' +# index: 1 +# create: true +# - select: # Uncomment the following to set the Service namespace for TLS in Prometheus ServiceMonitor +# kind: ServiceMonitor +# group: monitoring.coreos.com +# version: v1 +# name: controller-manager-metrics-monitor +# fieldPaths: +# - spec.endpoints.0.tlsConfig.serverName +# options: +# delimiter: '.' +# index: 1 +# create: true + +# - source: # Uncomment the following block if you have any webhook +# kind: Service +# version: v1 +# name: webhook-service +# fieldPath: .metadata.name # Name of the service +# targets: +# - select: +# kind: Certificate +# group: cert-manager.io +# version: v1 +# name: serving-cert +# fieldPaths: +# - .spec.dnsNames.0 +# - .spec.dnsNames.1 +# options: +# delimiter: '.' +# index: 0 +# create: true +# - source: +# kind: Service +# version: v1 +# name: webhook-service +# fieldPath: .metadata.namespace # Namespace of the service +# targets: +# - select: +# kind: Certificate +# group: cert-manager.io +# version: v1 +# name: serving-cert +# fieldPaths: +# - .spec.dnsNames.0 +# - .spec.dnsNames.1 +# options: +# delimiter: '.' +# index: 1 +# create: true + +# - source: # Uncomment the following block if you have a ValidatingWebhook (--programmatic-validation) +# kind: Certificate +# group: cert-manager.io +# version: v1 +# name: serving-cert # This name should match the one in certificate.yaml +# fieldPath: .metadata.namespace # Namespace of the certificate CR +# targets: +# - select: +# kind: ValidatingWebhookConfiguration +# fieldPaths: +# - .metadata.annotations.[cert-manager.io/inject-ca-from] +# options: +# delimiter: '/' +# index: 0 +# create: true +# - source: +# kind: Certificate +# group: cert-manager.io +# version: v1 +# name: serving-cert +# fieldPath: .metadata.name +# targets: +# - select: +# kind: ValidatingWebhookConfiguration +# fieldPaths: +# - .metadata.annotations.[cert-manager.io/inject-ca-from] +# options: +# delimiter: '/' +# index: 1 +# create: true + +# - source: # Uncomment the following block if you have a DefaultingWebhook (--defaulting ) +# kind: Certificate +# group: cert-manager.io +# version: v1 +# name: serving-cert +# fieldPath: .metadata.namespace # Namespace of the certificate CR +# targets: +# - select: +# kind: MutatingWebhookConfiguration +# fieldPaths: +# - .metadata.annotations.[cert-manager.io/inject-ca-from] +# options: +# delimiter: '/' +# index: 0 +# create: true +# - source: +# kind: Certificate +# group: cert-manager.io +# version: v1 +# name: serving-cert +# fieldPath: .metadata.name +# targets: +# - select: +# kind: MutatingWebhookConfiguration +# fieldPaths: +# - .metadata.annotations.[cert-manager.io/inject-ca-from] +# options: +# delimiter: '/' +# index: 1 +# create: true + +# - source: # Uncomment the following block if you have a ConversionWebhook (--conversion) +# kind: Certificate +# group: cert-manager.io +# version: v1 +# name: serving-cert +# fieldPath: .metadata.namespace # Namespace of the certificate CR +# targets: # Do not remove or uncomment the following scaffold marker; required to generate code for target CRD. +# +kubebuilder:scaffold:crdkustomizecainjectionns +# - source: +# kind: Certificate +# group: cert-manager.io +# version: v1 +# name: serving-cert +# fieldPath: .metadata.name +# targets: # Do not remove or uncomment the following scaffold marker; required to generate code for target CRD. +# +kubebuilder:scaffold:crdkustomizecainjectionname diff --git a/executor/config/default/manager_metrics_patch.yaml b/executor/config/default/manager_metrics_patch.yaml new file mode 100644 index 0000000000..2aaef6536f --- /dev/null +++ b/executor/config/default/manager_metrics_patch.yaml @@ -0,0 +1,4 @@ +# This patch adds the args to allow exposing the metrics endpoint using HTTPS +- op: add + path: /spec/template/spec/containers/0/args/0 + value: --metrics-bind-address=:8443 diff --git a/executor/config/default/metrics_service.yaml b/executor/config/default/metrics_service.yaml new file mode 100644 index 0000000000..49837187de --- /dev/null +++ b/executor/config/default/metrics_service.yaml @@ -0,0 +1,18 @@ +apiVersion: v1 +kind: Service +metadata: + labels: + control-plane: controller-manager + app.kubernetes.io/name: executor + app.kubernetes.io/managed-by: kustomize + name: controller-manager-metrics-service + namespace: system +spec: + ports: + - name: https + port: 8443 + protocol: TCP + targetPort: 8443 + selector: + control-plane: controller-manager + app.kubernetes.io/name: executor diff --git a/executor/config/manager/kustomization.yaml b/executor/config/manager/kustomization.yaml new file mode 100644 index 0000000000..ad13e96b3f --- /dev/null +++ b/executor/config/manager/kustomization.yaml @@ -0,0 +1,8 @@ +resources: +- manager.yaml +apiVersion: kustomize.config.k8s.io/v1beta1 +kind: Kustomization +images: +- name: controller + newName: controller + newTag: latest diff --git a/executor/config/manager/manager.yaml b/executor/config/manager/manager.yaml new file mode 100644 index 0000000000..ff13f0329b --- /dev/null +++ b/executor/config/manager/manager.yaml @@ -0,0 +1,99 @@ +apiVersion: v1 +kind: Namespace +metadata: + labels: + control-plane: controller-manager + app.kubernetes.io/name: executor + app.kubernetes.io/managed-by: kustomize + name: system +--- +apiVersion: apps/v1 +kind: Deployment +metadata: + name: controller-manager + namespace: system + labels: + control-plane: controller-manager + app.kubernetes.io/name: executor + app.kubernetes.io/managed-by: kustomize +spec: + selector: + matchLabels: + control-plane: controller-manager + app.kubernetes.io/name: executor + replicas: 1 + template: + metadata: + annotations: + kubectl.kubernetes.io/default-container: manager + labels: + control-plane: controller-manager + app.kubernetes.io/name: executor + spec: + # TODO(user): Uncomment the following code to configure the nodeAffinity expression + # according to the platforms which are supported by your solution. + # It is considered best practice to support multiple architectures. You can + # build your manager image using the makefile target docker-buildx. + # affinity: + # nodeAffinity: + # requiredDuringSchedulingIgnoredDuringExecution: + # nodeSelectorTerms: + # - matchExpressions: + # - key: kubernetes.io/arch + # operator: In + # values: + # - amd64 + # - arm64 + # - ppc64le + # - s390x + # - key: kubernetes.io/os + # operator: In + # values: + # - linux + securityContext: + # Projects are configured by default to adhere to the "restricted" Pod Security Standards. + # This ensures that deployments meet the highest security requirements for Kubernetes. + # For more details, see: https://kubernetes.io/docs/concepts/security/pod-security-standards/#restricted + runAsNonRoot: true + seccompProfile: + type: RuntimeDefault + containers: + - command: + - /manager + args: + - --leader-elect + - --health-probe-bind-address=:8081 + image: controller:latest + name: manager + ports: [] + securityContext: + readOnlyRootFilesystem: true + allowPrivilegeEscalation: false + capabilities: + drop: + - "ALL" + livenessProbe: + httpGet: + path: /healthz + port: 8081 + initialDelaySeconds: 15 + periodSeconds: 20 + readinessProbe: + httpGet: + path: /readyz + port: 8081 + initialDelaySeconds: 5 + periodSeconds: 10 + # TODO(user): Configure the resources accordingly based on the project requirements. + # More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ + resources: + limits: + cpu: 500m + memory: 128Mi + requests: + cpu: 10m + memory: 64Mi + volumeMounts: [] + volumes: [] + serviceAccountName: controller-manager + terminationGracePeriodSeconds: 10 diff --git a/executor/config/network-policy/allow-metrics-traffic.yaml b/executor/config/network-policy/allow-metrics-traffic.yaml new file mode 100644 index 0000000000..943675cac5 --- /dev/null +++ b/executor/config/network-policy/allow-metrics-traffic.yaml @@ -0,0 +1,27 @@ +# This NetworkPolicy allows ingress traffic +# with Pods running on namespaces labeled with 'metrics: enabled'. Only Pods on those +# namespaces are able to gather data from the metrics endpoint. +apiVersion: networking.k8s.io/v1 +kind: NetworkPolicy +metadata: + labels: + app.kubernetes.io/name: executor + app.kubernetes.io/managed-by: kustomize + name: allow-metrics-traffic + namespace: system +spec: + podSelector: + matchLabels: + control-plane: controller-manager + app.kubernetes.io/name: executor + policyTypes: + - Ingress + ingress: + # This allows ingress traffic from any namespace with the label metrics: enabled + - from: + - namespaceSelector: + matchLabels: + metrics: enabled # Only from namespaces with this label + ports: + - port: 8443 + protocol: TCP diff --git a/executor/config/network-policy/kustomization.yaml b/executor/config/network-policy/kustomization.yaml new file mode 100644 index 0000000000..ec0fb5e57d --- /dev/null +++ b/executor/config/network-policy/kustomization.yaml @@ -0,0 +1,2 @@ +resources: +- allow-metrics-traffic.yaml diff --git a/executor/config/prometheus/kustomization.yaml b/executor/config/prometheus/kustomization.yaml new file mode 100644 index 0000000000..fdc5481b10 --- /dev/null +++ b/executor/config/prometheus/kustomization.yaml @@ -0,0 +1,11 @@ +resources: +- monitor.yaml + +# [PROMETHEUS-WITH-CERTS] The following patch configures the ServiceMonitor in ../prometheus +# to securely reference certificates created and managed by cert-manager. +# Additionally, ensure that you uncomment the [METRICS WITH CERTMANAGER] patch under config/default/kustomization.yaml +# to mount the "metrics-server-cert" secret in the Manager Deployment. +#patches: +# - path: monitor_tls_patch.yaml +# target: +# kind: ServiceMonitor diff --git a/executor/config/prometheus/monitor.yaml b/executor/config/prometheus/monitor.yaml new file mode 100644 index 0000000000..96d85a14ce --- /dev/null +++ b/executor/config/prometheus/monitor.yaml @@ -0,0 +1,27 @@ +# Prometheus Monitor Service (Metrics) +apiVersion: monitoring.coreos.com/v1 +kind: ServiceMonitor +metadata: + labels: + control-plane: controller-manager + app.kubernetes.io/name: executor + app.kubernetes.io/managed-by: kustomize + name: controller-manager-metrics-monitor + namespace: system +spec: + endpoints: + - path: /metrics + port: https # Ensure this is the name of the port that exposes HTTPS metrics + scheme: https + bearerTokenFile: /var/run/secrets/kubernetes.io/serviceaccount/token + tlsConfig: + # TODO(user): The option insecureSkipVerify: true is not recommended for production since it disables + # certificate verification, exposing the system to potential man-in-the-middle attacks. + # For production environments, it is recommended to use cert-manager for automatic TLS certificate management. + # To apply this configuration, enable cert-manager and use the patch located at config/prometheus/servicemonitor_tls_patch.yaml, + # which securely references the certificate from the 'metrics-server-cert' secret. + insecureSkipVerify: true + selector: + matchLabels: + control-plane: controller-manager + app.kubernetes.io/name: executor diff --git a/executor/config/prometheus/monitor_tls_patch.yaml b/executor/config/prometheus/monitor_tls_patch.yaml new file mode 100644 index 0000000000..5bf84ce0d5 --- /dev/null +++ b/executor/config/prometheus/monitor_tls_patch.yaml @@ -0,0 +1,19 @@ +# Patch for Prometheus ServiceMonitor to enable secure TLS configuration +# using certificates managed by cert-manager +- op: replace + path: /spec/endpoints/0/tlsConfig + value: + # SERVICE_NAME and SERVICE_NAMESPACE will be substituted by kustomize + serverName: SERVICE_NAME.SERVICE_NAMESPACE.svc + insecureSkipVerify: false + ca: + secret: + name: metrics-server-cert + key: ca.crt + cert: + secret: + name: metrics-server-cert + key: tls.crt + keySecret: + name: metrics-server-cert + key: tls.key diff --git a/executor/config/rbac/kustomization.yaml b/executor/config/rbac/kustomization.yaml new file mode 100644 index 0000000000..d864140ad6 --- /dev/null +++ b/executor/config/rbac/kustomization.yaml @@ -0,0 +1,28 @@ +resources: +# All RBAC will be applied under this service account in +# the deployment namespace. You may comment out this resource +# if your manager will use a service account that exists at +# runtime. Be sure to update RoleBinding and ClusterRoleBinding +# subjects if changing service account names. +- service_account.yaml +- role.yaml +- role_binding.yaml +- leader_election_role.yaml +- leader_election_role_binding.yaml +# The following RBAC configurations are used to protect +# the metrics endpoint with authn/authz. These configurations +# ensure that only authorized users and service accounts +# can access the metrics endpoint. Comment the following +# permissions if you want to disable this protection. +# More info: https://book.kubebuilder.io/reference/metrics.html +- metrics_auth_role.yaml +- metrics_auth_role_binding.yaml +- metrics_reader_role.yaml +# For each CRD, "Admin", "Editor" and "Viewer" roles are scaffolded by +# default, aiding admins in cluster management. Those roles are +# not used by the executor itself. You can comment the following lines +# if you do not want those helpers be installed with your Project. +- taskaction_admin_role.yaml +- taskaction_editor_role.yaml +- taskaction_viewer_role.yaml + diff --git a/executor/config/rbac/leader_election_role.yaml b/executor/config/rbac/leader_election_role.yaml new file mode 100644 index 0000000000..60b04c17f7 --- /dev/null +++ b/executor/config/rbac/leader_election_role.yaml @@ -0,0 +1,40 @@ +# permissions to do leader election. +apiVersion: rbac.authorization.k8s.io/v1 +kind: Role +metadata: + labels: + app.kubernetes.io/name: executor + app.kubernetes.io/managed-by: kustomize + name: leader-election-role +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 diff --git a/executor/config/rbac/leader_election_role_binding.yaml b/executor/config/rbac/leader_election_role_binding.yaml new file mode 100644 index 0000000000..38e25e5157 --- /dev/null +++ b/executor/config/rbac/leader_election_role_binding.yaml @@ -0,0 +1,15 @@ +apiVersion: rbac.authorization.k8s.io/v1 +kind: RoleBinding +metadata: + labels: + app.kubernetes.io/name: executor + app.kubernetes.io/managed-by: kustomize + name: leader-election-rolebinding +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: Role + name: leader-election-role +subjects: +- kind: ServiceAccount + name: controller-manager + namespace: system diff --git a/executor/config/rbac/metrics_auth_role.yaml b/executor/config/rbac/metrics_auth_role.yaml new file mode 100644 index 0000000000..32d2e4ec6b --- /dev/null +++ b/executor/config/rbac/metrics_auth_role.yaml @@ -0,0 +1,17 @@ +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRole +metadata: + name: metrics-auth-role +rules: +- apiGroups: + - authentication.k8s.io + resources: + - tokenreviews + verbs: + - create +- apiGroups: + - authorization.k8s.io + resources: + - subjectaccessreviews + verbs: + - create diff --git a/executor/config/rbac/metrics_auth_role_binding.yaml b/executor/config/rbac/metrics_auth_role_binding.yaml new file mode 100644 index 0000000000..e775d67ff0 --- /dev/null +++ b/executor/config/rbac/metrics_auth_role_binding.yaml @@ -0,0 +1,12 @@ +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRoleBinding +metadata: + name: metrics-auth-rolebinding +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: ClusterRole + name: metrics-auth-role +subjects: +- kind: ServiceAccount + name: controller-manager + namespace: system diff --git a/executor/config/rbac/metrics_reader_role.yaml b/executor/config/rbac/metrics_reader_role.yaml new file mode 100644 index 0000000000..51a75db47a --- /dev/null +++ b/executor/config/rbac/metrics_reader_role.yaml @@ -0,0 +1,9 @@ +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRole +metadata: + name: metrics-reader +rules: +- nonResourceURLs: + - "/metrics" + verbs: + - get diff --git a/executor/config/rbac/role.yaml b/executor/config/rbac/role.yaml new file mode 100644 index 0000000000..e60efcc13a --- /dev/null +++ b/executor/config/rbac/role.yaml @@ -0,0 +1,32 @@ +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRole +metadata: + name: manager-role +rules: +- apiGroups: + - flyte.org + resources: + - taskactions + verbs: + - create + - delete + - get + - list + - patch + - update + - watch +- apiGroups: + - flyte.org + resources: + - taskactions/finalizers + verbs: + - update +- apiGroups: + - flyte.org + resources: + - taskactions/status + verbs: + - get + - patch + - update diff --git a/executor/config/rbac/role_binding.yaml b/executor/config/rbac/role_binding.yaml new file mode 100644 index 0000000000..1ccec8a967 --- /dev/null +++ b/executor/config/rbac/role_binding.yaml @@ -0,0 +1,15 @@ +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRoleBinding +metadata: + labels: + app.kubernetes.io/name: executor + app.kubernetes.io/managed-by: kustomize + name: manager-rolebinding +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: ClusterRole + name: manager-role +subjects: +- kind: ServiceAccount + name: controller-manager + namespace: system diff --git a/executor/config/rbac/service_account.yaml b/executor/config/rbac/service_account.yaml new file mode 100644 index 0000000000..46fcf8c7f8 --- /dev/null +++ b/executor/config/rbac/service_account.yaml @@ -0,0 +1,8 @@ +apiVersion: v1 +kind: ServiceAccount +metadata: + labels: + app.kubernetes.io/name: executor + app.kubernetes.io/managed-by: kustomize + name: controller-manager + namespace: system diff --git a/executor/config/rbac/taskaction_admin_role.yaml b/executor/config/rbac/taskaction_admin_role.yaml new file mode 100644 index 0000000000..efb6d4e877 --- /dev/null +++ b/executor/config/rbac/taskaction_admin_role.yaml @@ -0,0 +1,27 @@ +# This rule is not used by the project executor itself. +# It is provided to allow the cluster admin to help manage permissions for users. +# +# Grants full permissions ('*') over flyte.org. +# This role is intended for users authorized to modify roles and bindings within the cluster, +# enabling them to delegate specific permissions to other users or groups as needed. + +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRole +metadata: + labels: + app.kubernetes.io/name: executor + app.kubernetes.io/managed-by: kustomize + name: taskaction-admin-role +rules: +- apiGroups: + - flyte.org + resources: + - taskactions + verbs: + - '*' +- apiGroups: + - flyte.org + resources: + - taskactions/status + verbs: + - get diff --git a/executor/config/rbac/taskaction_editor_role.yaml b/executor/config/rbac/taskaction_editor_role.yaml new file mode 100644 index 0000000000..63ac23c6ea --- /dev/null +++ b/executor/config/rbac/taskaction_editor_role.yaml @@ -0,0 +1,33 @@ +# This rule is not used by the project executor itself. +# It is provided to allow the cluster admin to help manage permissions for users. +# +# Grants permissions to create, update, and delete resources within the flyte.org. +# This role is intended for users who need to manage these resources +# but should not control RBAC or manage permissions for others. + +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRole +metadata: + labels: + app.kubernetes.io/name: executor + app.kubernetes.io/managed-by: kustomize + name: taskaction-editor-role +rules: +- apiGroups: + - flyte.org + resources: + - taskactions + verbs: + - create + - delete + - get + - list + - patch + - update + - watch +- apiGroups: + - flyte.org + resources: + - taskactions/status + verbs: + - get diff --git a/executor/config/rbac/taskaction_viewer_role.yaml b/executor/config/rbac/taskaction_viewer_role.yaml new file mode 100644 index 0000000000..5899d036d0 --- /dev/null +++ b/executor/config/rbac/taskaction_viewer_role.yaml @@ -0,0 +1,29 @@ +# This rule is not used by the project executor itself. +# It is provided to allow the cluster admin to help manage permissions for users. +# +# Grants read-only access to flyte.org resources. +# This role is intended for users who need visibility into these resources +# without permissions to modify them. It is ideal for monitoring purposes and limited-access viewing. + +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRole +metadata: + labels: + app.kubernetes.io/name: executor + app.kubernetes.io/managed-by: kustomize + name: taskaction-viewer-role +rules: +- apiGroups: + - flyte.org + resources: + - taskactions + verbs: + - get + - list + - watch +- apiGroups: + - flyte.org + resources: + - taskactions/status + verbs: + - get diff --git a/executor/config/samples/flyte.org_v1_taskaction.yaml b/executor/config/samples/flyte.org_v1_taskaction.yaml new file mode 100644 index 0000000000..d53f870f1c --- /dev/null +++ b/executor/config/samples/flyte.org_v1_taskaction.yaml @@ -0,0 +1,15 @@ +apiVersion: flyte.org/v1 +kind: TaskAction +metadata: + labels: + app.kubernetes.io/name: executor + app.kubernetes.io/managed-by: kustomize + name: taskaction-sample +spec: + runName: "sample-run" + org: "demo" + project: "default" + domain: "dev" + actionName: "sample-task" + inputUri: "/tmp/input" + runOutputBase: "/tmp/output" diff --git a/executor/config/samples/kustomization.yaml b/executor/config/samples/kustomization.yaml new file mode 100644 index 0000000000..30e5acbdaa --- /dev/null +++ b/executor/config/samples/kustomization.yaml @@ -0,0 +1,4 @@ +## Append samples of your project ## +resources: +- flyte.org_v1_taskaction.yaml +# +kubebuilder:scaffold:manifestskustomizesamples diff --git a/executor/hack/boilerplate.go.txt b/executor/hack/boilerplate.go.txt new file mode 100644 index 0000000000..221dcbe0bd --- /dev/null +++ b/executor/hack/boilerplate.go.txt @@ -0,0 +1,15 @@ +/* +Copyright 2025. + +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. +*/ \ No newline at end of file diff --git a/executor/pkg/controller/suite_test.go b/executor/pkg/controller/suite_test.go new file mode 100644 index 0000000000..4ef1241b40 --- /dev/null +++ b/executor/pkg/controller/suite_test.go @@ -0,0 +1,114 @@ +/* +Copyright 2025. + +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 controller + +import ( + "context" + "os" + "path/filepath" + "testing" + + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + "k8s.io/client-go/kubernetes/scheme" + "k8s.io/client-go/rest" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/envtest" + logf "sigs.k8s.io/controller-runtime/pkg/log" + "sigs.k8s.io/controller-runtime/pkg/log/zap" + + flyteorgv1 "github.com/flyteorg/flyte/v2/executor/api/v1" +) + +// These tests use Ginkgo (BDD-style Go testing framework). Refer to +// http://onsi.github.io/ginkgo/ to learn more about Ginkgo. + +var ( + ctx context.Context + cancel context.CancelFunc + testEnv *envtest.Environment + cfg *rest.Config + k8sClient client.Client +) + +func TestControllers(t *testing.T) { + RegisterFailHandler(Fail) + + RunSpecs(t, "Controller Suite") +} + +var _ = BeforeSuite(func() { + logf.SetLogger(zap.New(zap.WriteTo(GinkgoWriter), zap.UseDevMode(true))) + + ctx, cancel = context.WithCancel(context.TODO()) + + var err error + err = flyteorgv1.AddToScheme(scheme.Scheme) + Expect(err).NotTo(HaveOccurred()) + + // +kubebuilder:scaffold:scheme + + By("bootstrapping test environment") + testEnv = &envtest.Environment{ + CRDDirectoryPaths: []string{filepath.Join("..", "..", "config", "crd", "bases")}, + ErrorIfCRDPathMissing: true, + } + + // Retrieve the first found binary directory to allow running tests from IDEs + if getFirstFoundEnvTestBinaryDir() != "" { + testEnv.BinaryAssetsDirectory = getFirstFoundEnvTestBinaryDir() + } + + // cfg is defined in this file globally. + cfg, err = testEnv.Start() + Expect(err).NotTo(HaveOccurred()) + Expect(cfg).NotTo(BeNil()) + + k8sClient, err = client.New(cfg, client.Options{Scheme: scheme.Scheme}) + Expect(err).NotTo(HaveOccurred()) + Expect(k8sClient).NotTo(BeNil()) +}) + +var _ = AfterSuite(func() { + By("tearing down the test environment") + cancel() + err := testEnv.Stop() + Expect(err).NotTo(HaveOccurred()) +}) + +// getFirstFoundEnvTestBinaryDir locates the first binary in the specified path. +// ENVTEST-based tests depend on specific binaries, usually located in paths set by +// controller-runtime. When running tests directly (e.g., via an IDE) without using +// Makefile targets, the 'BinaryAssetsDirectory' must be explicitly configured. +// +// This function streamlines the process by finding the required binaries, similar to +// setting the 'KUBEBUILDER_ASSETS' environment variable. To ensure the binaries are +// properly set up, run 'make setup-envtest' beforehand. +func getFirstFoundEnvTestBinaryDir() string { + basePath := filepath.Join("..", "..", "bin", "k8s") + entries, err := os.ReadDir(basePath) + if err != nil { + logf.Log.Error(err, "Failed to read directory", "path", basePath) + return "" + } + for _, entry := range entries { + if entry.IsDir() { + return filepath.Join(basePath, entry.Name()) + } + } + return "" +} diff --git a/executor/pkg/controller/taskaction_controller.go b/executor/pkg/controller/taskaction_controller.go new file mode 100644 index 0000000000..bcc280b899 --- /dev/null +++ b/executor/pkg/controller/taskaction_controller.go @@ -0,0 +1,281 @@ +/* +Copyright 2025. + +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 controller + +import ( + "context" + "crypto/tls" + "encoding/json" + "fmt" + "net" + "net/http" + "time" + + "connectrpc.com/connect" + "golang.org/x/net/http2" + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/meta" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/client-go/tools/record" + ctrl "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/log" + + flyteorgv1 "github.com/flyteorg/flyte/v2/executor/api/v1" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow/workflowconnect" +) + +type K8sEventType string + +const ( + TaskActionDefaultRequeueDuration = 5 * time.Second + FailedUnmarshal K8sEventType = "FailedUnmarshal" +) + +// TaskActionReconciler reconciles a TaskAction object +type TaskActionReconciler struct { + client.Client + Scheme *runtime.Scheme + StateServiceURL string + stateServiceClient workflowconnect.StateServiceClient + Recorder record.EventRecorder +} + +// NewTaskActionReconciler creates a new TaskActionReconciler with initialized clients +func NewTaskActionReconciler(c client.Client, scheme *runtime.Scheme, stateServiceURL string) *TaskActionReconciler { + // Create HTTP/2 cleartext (h2c) client for buf connect + // This is required because the state service uses h2c (HTTP/2 without TLS) + httpClient := &http.Client{ + Transport: &http2.Transport{ + // Allow HTTP/2 without TLS (h2c) + AllowHTTP: true, + // Use HTTP/2 dialer + DialTLSContext: func(ctx context.Context, network, addr string, cfg *tls.Config) (net.Conn, error) { + // Dial without TLS for h2c + return net.Dial(network, addr) + }, + }, + } + + return &TaskActionReconciler{ + Client: c, + Scheme: scheme, + StateServiceURL: stateServiceURL, + stateServiceClient: workflowconnect.NewStateServiceClient(httpClient, stateServiceURL), + } +} + +// +kubebuilder:rbac:groups=flyte.org,resources=taskactions,verbs=get;list;watch;create;update;patch;delete +// +kubebuilder:rbac:groups=flyte.org,resources=taskactions/status,verbs=get;update;patch +// +kubebuilder:rbac:groups=flyte.org,resources=taskactions/finalizers,verbs=update + +// Reconcile is part of the main kubernetes reconciliation loop which aims to +// move the current state of the cluster closer to the desired state. +func (r *TaskActionReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { + logger := log.FromContext(ctx) + + // Fetch the TaskAction instance + taskAction := &flyteorgv1.TaskAction{} + if err := r.Get(ctx, req.NamespacedName, taskAction); err != nil { + return ctrl.Result{}, client.IgnoreNotFound(err) + } + + // Get the ActionSpec from the TaskAction + actionSpec, err := taskAction.Spec.GetActionSpec() + if err != nil { + r.Recorder.Eventf(taskAction, corev1.EventTypeWarning, string(FailedUnmarshal), "Failed to unmarshal ActionSpec %s/%s: %v", taskAction.Namespace, taskAction.Name, err) + return ctrl.Result{}, err + } + + // TODO (haytham): Remove when we add real code that executes plugins. For now this is here so that watchers can see + // things transition between states. + time.Sleep(2 * time.Second) + + // Check terminal conditions first + succeededCond := findConditionByType(taskAction.Status.Conditions, flyteorgv1.ConditionTypeSucceeded) + if succeededCond != nil && succeededCond.Status == metav1.ConditionTrue { + logger.Info("TaskAction already succeeded", + "name", taskAction.Name, "action", actionSpec.ActionId.Name) + return ctrl.Result{}, nil + } + + failedCond := findConditionByType(taskAction.Status.Conditions, flyteorgv1.ConditionTypeFailed) + if failedCond != nil && failedCond.Status == metav1.ConditionTrue { + logger.Info("TaskAction already failed", + "name", taskAction.Name, "action", actionSpec.ActionId.Name) + return ctrl.Result{}, nil + } + + // Sequential condition evaluation for Progressing + progressingCond := findConditionByType(taskAction.Status.Conditions, flyteorgv1.ConditionTypeProgressing) + if progressingCond != nil && progressingCond.Status == metav1.ConditionTrue { + // Check the Reason to determine sub-state + if progressingCond.Reason == string(flyteorgv1.ConditionReasonExecuting) { + // Executing to Succeeded + logger.Info("TaskAction is executing, transitioning to Succeeded", + "name", taskAction.Name, "action", actionSpec.ActionId.Name) + + setCondition(taskAction, flyteorgv1.ConditionTypeProgressing, metav1.ConditionFalse, + flyteorgv1.ConditionReasonCompleted, "TaskAction has completed") + setCondition(taskAction, flyteorgv1.ConditionTypeSucceeded, metav1.ConditionTrue, + flyteorgv1.ConditionReasonCompleted, "TaskAction completed successfully") + + stateJSON := r.createStateJSON(actionSpec, "Succeeded") + if err := r.updateStateService(ctx, actionSpec.ActionId, actionSpec.ParentActionName, stateJSON); err != nil { + logger.Error(err, "Failed to update state service") + } + taskAction.Status.StateJSON = stateJSON + + if err := r.Status().Update(ctx, taskAction); err != nil { + return ctrl.Result{}, err + } + return ctrl.Result{}, nil + } + + if progressingCond.Reason == string(flyteorgv1.ConditionReasonInitializing) { + // Initializing to Executing + logger.Info("TaskAction is initializing, transitioning to Executing", + "name", taskAction.Name, "action", actionSpec.ActionId.Name) + + setCondition(taskAction, flyteorgv1.ConditionTypeProgressing, metav1.ConditionTrue, + flyteorgv1.ConditionReasonExecuting, "TaskAction is executing") + + stateJSON := r.createStateJSON(actionSpec, "Running") + if err := r.updateStateService(ctx, actionSpec.ActionId, actionSpec.ParentActionName, stateJSON); err != nil { + logger.Error(err, "Failed to update state service") + } + taskAction.Status.StateJSON = stateJSON + + if err := r.Status().Update(ctx, taskAction); err != nil { + return ctrl.Result{}, err + } + return ctrl.Result{RequeueAfter: 5 * time.Second}, nil + } + + if progressingCond.Reason == string(flyteorgv1.ConditionReasonQueued) { + // Queued to Initializing + logger.Info("TaskAction is queued, transitioning to Initializing", + "name", taskAction.Name, "action", actionSpec.ActionId.Name) + + setCondition(taskAction, flyteorgv1.ConditionTypeProgressing, metav1.ConditionTrue, + flyteorgv1.ConditionReasonInitializing, "TaskAction is being initialized") + + stateJSON := r.createStateJSON(actionSpec, "Initializing") + if err := r.updateStateService(ctx, actionSpec.ActionId, actionSpec.ParentActionName, stateJSON); err != nil { + logger.Error(err, "Failed to update state service") + } + taskAction.Status.StateJSON = stateJSON + + if err := r.Status().Update(ctx, taskAction); err != nil { + return ctrl.Result{}, err + } + return ctrl.Result{RequeueAfter: 5 * time.Second}, nil + } + } + + // No conditions exist, this is the first reconcile + // Set Condition to Queued + logger.Info("New TaskAction, setting Progressing condition", + "name", taskAction.Name, "action", actionSpec.ActionId.Name) + + setCondition(taskAction, flyteorgv1.ConditionTypeProgressing, metav1.ConditionTrue, + flyteorgv1.ConditionReasonQueued, "TaskAction is queued and waiting for resources") + + stateJSON := r.createStateJSON(actionSpec, "Queued") + if err := r.updateStateService(ctx, actionSpec.ActionId, actionSpec.ParentActionName, stateJSON); err != nil { + logger.Error(err, "Failed to update state service") + } + taskAction.Status.StateJSON = stateJSON + + if err := r.Status().Update(ctx, taskAction); err != nil { + return ctrl.Result{}, err + } + return ctrl.Result{RequeueAfter: TaskActionDefaultRequeueDuration}, nil +} + +// createStateJSON creates a simplified NodeStatus JSON representation +func (r *TaskActionReconciler) createStateJSON(actionSpec *workflow.ActionSpec, phase string) string { + // Create a simplified state object + state := map[string]interface{}{ + "phase": phase, + "actionId": fmt.Sprintf("%s/%s", actionSpec.ActionId.Run.Name, actionSpec.ActionId.Name), + "timestamp": time.Now().Format(time.RFC3339), + } + + stateBytes, err := json.Marshal(state) + if err != nil { + return "{}" + } + + return string(stateBytes) +} + +// updateStateService sends a state update to the State Service via unary RPC +func (r *TaskActionReconciler) updateStateService(ctx context.Context, actionID *common.ActionIdentifier, parentActionName *string, stateJSON string) error { + // Create PutRequest + reqMsg := &workflow.PutRequest{ + ActionId: actionID, + ParentActionName: parentActionName, + State: stateJSON, + } + + // Make unary Put call + resp, err := r.stateServiceClient.Put(ctx, connect.NewRequest(reqMsg)) + if err != nil { + return fmt.Errorf("failed to call put: %w", err) + } + + // Check response status + if resp.Msg.Status.Code != 0 { + return fmt.Errorf("state service returned error: %s", resp.Msg.Status.Message) + } + + return nil +} + +// SetupWithManager sets up the controller with the Manager. +func (r *TaskActionReconciler) SetupWithManager(mgr ctrl.Manager) error { + return ctrl.NewControllerManagedBy(mgr). + For(&flyteorgv1.TaskAction{}). + Named("taskaction"). + Complete(r) +} + +// findConditionByType finds a condition by type in the conditions list +// Returns nil if not found +func findConditionByType(conditions []metav1.Condition, condType flyteorgv1.TaskActionConditionType) *metav1.Condition { + for i := range conditions { + if conditions[i].Type == string(condType) { + return &conditions[i] + } + } + return nil +} + +// setCondition sets or updates a condition on the TaskAction +func setCondition(taskAction *flyteorgv1.TaskAction, conditionType flyteorgv1.TaskActionConditionType, status metav1.ConditionStatus, reason flyteorgv1.TaskActionConditionReason, message string) { + condition := metav1.Condition{ + Type: string(conditionType), + Status: status, + Reason: string(reason), + Message: message, + } + meta.SetStatusCondition(&taskAction.Status.Conditions, condition) +} diff --git a/executor/pkg/controller/taskaction_controller_test.go b/executor/pkg/controller/taskaction_controller_test.go new file mode 100644 index 0000000000..53df8c21a1 --- /dev/null +++ b/executor/pkg/controller/taskaction_controller_test.go @@ -0,0 +1,115 @@ +/* +Copyright 2025. + +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 controller + +import ( + "context" + + "connectrpc.com/connect" + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + "github.com/stretchr/testify/mock" + rpcstatus "google.golang.org/genproto/googleapis/rpc/status" + "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + "sigs.k8s.io/controller-runtime/pkg/reconcile" + + flyteorgv1 "github.com/flyteorg/flyte/v2/executor/api/v1" + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + workflowconnectmocks "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow/workflowconnect/mocks" +) + +var _ = Describe("TaskAction Controller", func() { + Context("When reconciling a resource", func() { + const resourceName = "test-resource" + + ctx := context.Background() + + typeNamespacedName := types.NamespacedName{ + Name: resourceName, + Namespace: "default", // TODO(user):Modify as needed + } + taskaction := &flyteorgv1.TaskAction{} + + BeforeEach(func() { + By("creating the custom resource for the Kind TaskAction") + err := k8sClient.Get(ctx, typeNamespacedName, taskaction) + if err != nil && errors.IsNotFound(err) { + resource := &flyteorgv1.TaskAction{ + ObjectMeta: metav1.ObjectMeta{ + Name: resourceName, + Namespace: "default", + }, + Spec: flyteorgv1.TaskActionSpec{ + RunName: "test-run", + Org: "test-org", + Project: "test-project", + Domain: "test-domain", + ActionName: "test-action", + InputURI: "/tmp/input", + RunOutputBase: "/tmp/output", + }, + } + Expect(k8sClient.Create(ctx, resource)).To(Succeed()) + } + }) + + AfterEach(func() { + // TODO(user): Cleanup logic after each test, like removing the resource instance. + resource := &flyteorgv1.TaskAction{} + err := k8sClient.Get(ctx, typeNamespacedName, resource) + Expect(err).NotTo(HaveOccurred()) + + By("Cleanup the specific resource instance TaskAction") + Expect(k8sClient.Delete(ctx, resource)).To(Succeed()) + }) + It("should successfully reconcile the resource", func() { + By("Reconciling the created resource") + + // Create a mock state service client + mockClient := &workflowconnectmocks.StateServiceClient{} + + // Set up expectations for Put calls - return a proper response with status + mockClient.EXPECT().Put(mock.Anything, mock.Anything). + Return(connect.NewResponse(&workflow.PutResponse{ + Status: &rpcstatus.Status{ + Code: 0, + Message: "success", + }, + }), nil). + Maybe() + + controllerReconciler := &TaskActionReconciler{ + Client: k8sClient, + Scheme: k8sClient.Scheme(), + stateServiceClient: mockClient, + } + + _, err := controllerReconciler.Reconcile(ctx, reconcile.Request{ + NamespacedName: typeNamespacedName, + }) + Expect(err).NotTo(HaveOccurred()) + + // Verify that the TaskAction was updated with a condition + updatedTaskAction := &flyteorgv1.TaskAction{} + err = k8sClient.Get(ctx, typeNamespacedName, updatedTaskAction) + Expect(err).NotTo(HaveOccurred()) + Expect(updatedTaskAction.Status.Conditions).NotTo(BeEmpty()) + }) + }) +}) diff --git a/executor/test/e2e/e2e_suite_test.go b/executor/test/e2e/e2e_suite_test.go new file mode 100644 index 0000000000..d6b44cd10f --- /dev/null +++ b/executor/test/e2e/e2e_suite_test.go @@ -0,0 +1,92 @@ +//go:build e2e +// +build e2e + +/* +Copyright 2025. + +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 e2e + +import ( + "fmt" + "os" + "os/exec" + "testing" + + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + + "github.com/flyteorg/flyte/v2/executor/test/utils" +) + +var ( + // Optional Environment Variables: + // - CERT_MANAGER_INSTALL_SKIP=true: Skips CertManager installation during test setup. + // These variables are useful if CertManager is already installed, avoiding + // re-installation and conflicts. + skipCertManagerInstall = os.Getenv("CERT_MANAGER_INSTALL_SKIP") == "true" + // isCertManagerAlreadyInstalled will be set true when CertManager CRDs be found on the cluster + isCertManagerAlreadyInstalled = false + + // projectImage is the name of the image which will be build and loaded + // with the code source changes to be tested. + projectImage = "example.com/executor:v0.0.1" +) + +// TestE2E runs the end-to-end (e2e) test suite for the project. These tests execute in an isolated, +// temporary environment to validate project changes with the purpose of being used in CI jobs. +// The default setup requires Kind, builds/loads the Manager Docker image locally, and installs +// CertManager. +func TestE2E(t *testing.T) { + RegisterFailHandler(Fail) + _, _ = fmt.Fprintf(GinkgoWriter, "Starting executor integration test suite\n") + RunSpecs(t, "e2e suite") +} + +var _ = BeforeSuite(func() { + By("building the manager(Operator) image") + cmd := exec.Command("make", "docker-build", fmt.Sprintf("IMG=%s", projectImage)) + _, err := utils.Run(cmd) + ExpectWithOffset(1, err).NotTo(HaveOccurred(), "Failed to build the manager(Operator) image") + + // TODO(user): If you want to change the e2e test vendor from Kind, ensure the image is + // built and available before running the tests. Also, remove the following block. + By("loading the manager(Operator) image on Kind") + err = utils.LoadImageToKindClusterWithName(projectImage) + ExpectWithOffset(1, err).NotTo(HaveOccurred(), "Failed to load the manager(Operator) image into Kind") + + // The tests-e2e are intended to run on a temporary cluster that is created and destroyed for testing. + // To prevent errors when tests run in environments with CertManager already installed, + // we check for its presence before execution. + // Setup CertManager before the suite if not skipped and if not already installed + if !skipCertManagerInstall { + By("checking if cert manager is installed already") + isCertManagerAlreadyInstalled = utils.IsCertManagerCRDsInstalled() + if !isCertManagerAlreadyInstalled { + _, _ = fmt.Fprintf(GinkgoWriter, "Installing CertManager...\n") + Expect(utils.InstallCertManager()).To(Succeed(), "Failed to install CertManager") + } else { + _, _ = fmt.Fprintf(GinkgoWriter, "WARNING: CertManager is already installed. Skipping installation...\n") + } + } +}) + +var _ = AfterSuite(func() { + // Teardown CertManager after the suite if not skipped and if it was not already installed + if !skipCertManagerInstall && !isCertManagerAlreadyInstalled { + _, _ = fmt.Fprintf(GinkgoWriter, "Uninstalling CertManager...\n") + utils.UninstallCertManager() + } +}) diff --git a/executor/test/e2e/e2e_test.go b/executor/test/e2e/e2e_test.go new file mode 100644 index 0000000000..37b87a1f42 --- /dev/null +++ b/executor/test/e2e/e2e_test.go @@ -0,0 +1,334 @@ +//go:build e2e +// +build e2e + +/* +Copyright 2025. + +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 e2e + +import ( + "encoding/json" + "fmt" + "os" + "os/exec" + "path/filepath" + "time" + + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + + "github.com/flyteorg/flyte/v2/executor/test/utils" +) + +// namespace where the project is deployed in +const namespace = "executor-system" + +// serviceAccountName created for the project +const serviceAccountName = "executor-controller-manager" + +// metricsServiceName is the name of the metrics service of the project +const metricsServiceName = "executor-controller-manager-metrics-service" + +// metricsRoleBindingName is the name of the RBAC that will be created to allow get the metrics data +const metricsRoleBindingName = "executor-metrics-binding" + +var _ = Describe("Manager", Ordered, func() { + var controllerPodName string + + // Before running the tests, set up the environment by creating the namespace, + // enforce the restricted security policy to the namespace, installing CRDs, + // and deploying the controller. + BeforeAll(func() { + By("creating manager namespace") + cmd := exec.Command("kubectl", "create", "ns", namespace) + _, err := utils.Run(cmd) + Expect(err).NotTo(HaveOccurred(), "Failed to create namespace") + + By("labeling the namespace to enforce the restricted security policy") + cmd = exec.Command("kubectl", "label", "--overwrite", "ns", namespace, + "pod-security.kubernetes.io/enforce=restricted") + _, err = utils.Run(cmd) + Expect(err).NotTo(HaveOccurred(), "Failed to label namespace with restricted policy") + + By("installing CRDs") + cmd = exec.Command("make", "install") + _, err = utils.Run(cmd) + Expect(err).NotTo(HaveOccurred(), "Failed to install CRDs") + + By("deploying the controller-manager") + cmd = exec.Command("make", "deploy", fmt.Sprintf("IMG=%s", projectImage)) + _, err = utils.Run(cmd) + Expect(err).NotTo(HaveOccurred(), "Failed to deploy the controller-manager") + }) + + // After all tests have been executed, clean up by undeploying the controller, uninstalling CRDs, + // and deleting the namespace. + AfterAll(func() { + By("cleaning up the curl pod for metrics") + cmd := exec.Command("kubectl", "delete", "pod", "curl-metrics", "-n", namespace) + _, _ = utils.Run(cmd) + + By("undeploying the controller-manager") + cmd = exec.Command("make", "undeploy") + _, _ = utils.Run(cmd) + + By("uninstalling CRDs") + cmd = exec.Command("make", "uninstall") + _, _ = utils.Run(cmd) + + By("removing manager namespace") + cmd = exec.Command("kubectl", "delete", "ns", namespace) + _, _ = utils.Run(cmd) + }) + + // After each test, check for failures and collect logs, events, + // and pod descriptions for debugging. + AfterEach(func() { + specReport := CurrentSpecReport() + if specReport.Failed() { + By("Fetching controller manager pod logs") + cmd := exec.Command("kubectl", "logs", controllerPodName, "-n", namespace) + controllerLogs, err := utils.Run(cmd) + if err == nil { + _, _ = fmt.Fprintf(GinkgoWriter, "Controller logs:\n %s", controllerLogs) + } else { + _, _ = fmt.Fprintf(GinkgoWriter, "Failed to get Controller logs: %s", err) + } + + By("Fetching Kubernetes events") + cmd = exec.Command("kubectl", "get", "events", "-n", namespace, "--sort-by=.lastTimestamp") + eventsOutput, err := utils.Run(cmd) + if err == nil { + _, _ = fmt.Fprintf(GinkgoWriter, "Kubernetes events:\n%s", eventsOutput) + } else { + _, _ = fmt.Fprintf(GinkgoWriter, "Failed to get Kubernetes events: %s", err) + } + + By("Fetching curl-metrics logs") + cmd = exec.Command("kubectl", "logs", "curl-metrics", "-n", namespace) + metricsOutput, err := utils.Run(cmd) + if err == nil { + _, _ = fmt.Fprintf(GinkgoWriter, "Metrics logs:\n %s", metricsOutput) + } else { + _, _ = fmt.Fprintf(GinkgoWriter, "Failed to get curl-metrics logs: %s", err) + } + + By("Fetching controller manager pod description") + cmd = exec.Command("kubectl", "describe", "pod", controllerPodName, "-n", namespace) + podDescription, err := utils.Run(cmd) + if err == nil { + fmt.Println("Pod description:\n", podDescription) + } else { + fmt.Println("Failed to describe controller pod") + } + } + }) + + SetDefaultEventuallyTimeout(2 * time.Minute) + SetDefaultEventuallyPollingInterval(time.Second) + + Context("Manager", func() { + It("should run successfully", func() { + By("validating that the controller-manager pod is running as expected") + verifyControllerUp := func(g Gomega) { + // Get the name of the controller-manager pod + cmd := exec.Command("kubectl", "get", + "pods", "-l", "control-plane=controller-manager", + "-o", "go-template={{ range .items }}"+ + "{{ if not .metadata.deletionTimestamp }}"+ + "{{ .metadata.name }}"+ + "{{ \"\\n\" }}{{ end }}{{ end }}", + "-n", namespace, + ) + + podOutput, err := utils.Run(cmd) + g.Expect(err).NotTo(HaveOccurred(), "Failed to retrieve controller-manager pod information") + podNames := utils.GetNonEmptyLines(podOutput) + g.Expect(podNames).To(HaveLen(1), "expected 1 controller pod running") + controllerPodName = podNames[0] + g.Expect(controllerPodName).To(ContainSubstring("controller-manager")) + + // Validate the pod's status + cmd = exec.Command("kubectl", "get", + "pods", controllerPodName, "-o", "jsonpath={.status.phase}", + "-n", namespace, + ) + output, err := utils.Run(cmd) + g.Expect(err).NotTo(HaveOccurred()) + g.Expect(output).To(Equal("Running"), "Incorrect controller-manager pod status") + } + Eventually(verifyControllerUp).Should(Succeed()) + }) + + It("should ensure the metrics endpoint is serving metrics", func() { + By("creating a ClusterRoleBinding for the service account to allow access to metrics") + cmd := exec.Command("kubectl", "create", "clusterrolebinding", metricsRoleBindingName, + "--clusterrole=executor-metrics-reader", + fmt.Sprintf("--serviceaccount=%s:%s", namespace, serviceAccountName), + ) + _, err := utils.Run(cmd) + Expect(err).NotTo(HaveOccurred(), "Failed to create ClusterRoleBinding") + + By("validating that the metrics service is available") + cmd = exec.Command("kubectl", "get", "service", metricsServiceName, "-n", namespace) + _, err = utils.Run(cmd) + Expect(err).NotTo(HaveOccurred(), "Metrics service should exist") + + By("getting the service account token") + token, err := serviceAccountToken() + Expect(err).NotTo(HaveOccurred()) + Expect(token).NotTo(BeEmpty()) + + By("waiting for the metrics endpoint to be ready") + verifyMetricsEndpointReady := func(g Gomega) { + cmd := exec.Command("kubectl", "get", "endpoints", metricsServiceName, "-n", namespace) + output, err := utils.Run(cmd) + g.Expect(err).NotTo(HaveOccurred()) + g.Expect(output).To(ContainSubstring("8443"), "Metrics endpoint is not ready") + } + Eventually(verifyMetricsEndpointReady).Should(Succeed()) + + By("verifying that the controller manager is serving the metrics server") + verifyMetricsServerStarted := func(g Gomega) { + cmd := exec.Command("kubectl", "logs", controllerPodName, "-n", namespace) + output, err := utils.Run(cmd) + g.Expect(err).NotTo(HaveOccurred()) + g.Expect(output).To(ContainSubstring("controller-runtime.metrics\tServing metrics server"), + "Metrics server not yet started") + } + Eventually(verifyMetricsServerStarted).Should(Succeed()) + + By("creating the curl-metrics pod to access the metrics endpoint") + cmd = exec.Command("kubectl", "run", "curl-metrics", "--restart=Never", + "--namespace", namespace, + "--image=curlimages/curl:latest", + "--overrides", + fmt.Sprintf(`{ + "spec": { + "containers": [{ + "name": "curl", + "image": "curlimages/curl:latest", + "command": ["/bin/sh", "-c"], + "args": ["curl -v -k -H 'Authorization: Bearer %s' https://%s.%s.svc.cluster.local:8443/metrics"], + "securityContext": { + "readOnlyRootFilesystem": true, + "allowPrivilegeEscalation": false, + "capabilities": { + "drop": ["ALL"] + }, + "runAsNonRoot": true, + "runAsUser": 1000, + "seccompProfile": { + "type": "RuntimeDefault" + } + } + }], + "serviceAccountName": "%s" + } + }`, token, metricsServiceName, namespace, serviceAccountName)) + _, err = utils.Run(cmd) + Expect(err).NotTo(HaveOccurred(), "Failed to create curl-metrics pod") + + By("waiting for the curl-metrics pod to complete.") + verifyCurlUp := func(g Gomega) { + cmd := exec.Command("kubectl", "get", "pods", "curl-metrics", + "-o", "jsonpath={.status.phase}", + "-n", namespace) + output, err := utils.Run(cmd) + g.Expect(err).NotTo(HaveOccurred()) + g.Expect(output).To(Equal("Succeeded"), "curl pod in wrong status") + } + Eventually(verifyCurlUp, 5*time.Minute).Should(Succeed()) + + By("getting the metrics by checking curl-metrics logs") + verifyMetricsAvailable := func(g Gomega) { + metricsOutput, err := getMetricsOutput() + g.Expect(err).NotTo(HaveOccurred(), "Failed to retrieve logs from curl pod") + g.Expect(metricsOutput).NotTo(BeEmpty()) + g.Expect(metricsOutput).To(ContainSubstring("< HTTP/1.1 200 OK")) + } + Eventually(verifyMetricsAvailable, 2*time.Minute).Should(Succeed()) + }) + + // +kubebuilder:scaffold:e2e-webhooks-checks + + // TODO: Customize the e2e test suite with scenarios specific to your project. + // Consider applying sample/CR(s) and check their status and/or verifying + // the reconciliation by using the metrics, i.e.: + // metricsOutput, err := getMetricsOutput() + // Expect(err).NotTo(HaveOccurred(), "Failed to retrieve logs from curl pod") + // Expect(metricsOutput).To(ContainSubstring( + // fmt.Sprintf(`controller_runtime_reconcile_total{controller="%s",result="success"} 1`, + // strings.ToLower(), + // )) + }) +}) + +// serviceAccountToken returns a token for the specified service account in the given namespace. +// It uses the Kubernetes TokenRequest API to generate a token by directly sending a request +// and parsing the resulting token from the API response. +func serviceAccountToken() (string, error) { + const tokenRequestRawString = `{ + "apiVersion": "authentication.k8s.io/v1", + "kind": "TokenRequest" + }` + + // Temporary file to store the token request + secretName := fmt.Sprintf("%s-token-request", serviceAccountName) + tokenRequestFile := filepath.Join("/tmp", secretName) + err := os.WriteFile(tokenRequestFile, []byte(tokenRequestRawString), os.FileMode(0o644)) + if err != nil { + return "", err + } + + var out string + verifyTokenCreation := func(g Gomega) { + // Execute kubectl command to create the token + cmd := exec.Command("kubectl", "create", "--raw", fmt.Sprintf( + "/api/v1/namespaces/%s/serviceaccounts/%s/token", + namespace, + serviceAccountName, + ), "-f", tokenRequestFile) + + output, err := cmd.CombinedOutput() + g.Expect(err).NotTo(HaveOccurred()) + + // Parse the JSON output to extract the token + var token tokenRequest + err = json.Unmarshal(output, &token) + g.Expect(err).NotTo(HaveOccurred()) + + out = token.Status.Token + } + Eventually(verifyTokenCreation).Should(Succeed()) + + return out, err +} + +// getMetricsOutput retrieves and returns the logs from the curl pod used to access the metrics endpoint. +func getMetricsOutput() (string, error) { + By("getting the curl-metrics logs") + cmd := exec.Command("kubectl", "logs", "curl-metrics", "-n", namespace) + return utils.Run(cmd) +} + +// tokenRequest is a simplified representation of the Kubernetes TokenRequest API response, +// containing only the token field that we need to extract. +type tokenRequest struct { + Status struct { + Token string `json:"token"` + } `json:"status"` +} diff --git a/executor/test/utils/utils.go b/executor/test/utils/utils.go new file mode 100644 index 0000000000..cf67d9019a --- /dev/null +++ b/executor/test/utils/utils.go @@ -0,0 +1,226 @@ +/* +Copyright 2025. + +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 utils + +import ( + "bufio" + "bytes" + "fmt" + "os" + "os/exec" + "strings" + + . "github.com/onsi/ginkgo/v2" // nolint:revive,staticcheck +) + +const ( + certmanagerVersion = "v1.18.2" + certmanagerURLTmpl = "https://github.com/cert-manager/cert-manager/releases/download/%s/cert-manager.yaml" + + defaultKindBinary = "kind" + defaultKindCluster = "kind" +) + +func warnError(err error) { + _, _ = fmt.Fprintf(GinkgoWriter, "warning: %v\n", err) +} + +// Run executes the provided command within this context +func Run(cmd *exec.Cmd) (string, error) { + dir, _ := GetProjectDir() + cmd.Dir = dir + + if err := os.Chdir(cmd.Dir); err != nil { + _, _ = fmt.Fprintf(GinkgoWriter, "chdir dir: %q\n", err) + } + + cmd.Env = append(os.Environ(), "GO111MODULE=on") + command := strings.Join(cmd.Args, " ") + _, _ = fmt.Fprintf(GinkgoWriter, "running: %q\n", command) + output, err := cmd.CombinedOutput() + if err != nil { + return string(output), fmt.Errorf("%q failed with error %q: %w", command, string(output), err) + } + + return string(output), nil +} + +// UninstallCertManager uninstalls the cert manager +func UninstallCertManager() { + url := fmt.Sprintf(certmanagerURLTmpl, certmanagerVersion) + cmd := exec.Command("kubectl", "delete", "-f", url) + if _, err := Run(cmd); err != nil { + warnError(err) + } + + // Delete leftover leases in kube-system (not cleaned by default) + kubeSystemLeases := []string{ + "cert-manager-cainjector-leader-election", + "cert-manager-controller", + } + for _, lease := range kubeSystemLeases { + cmd = exec.Command("kubectl", "delete", "lease", lease, + "-n", "kube-system", "--ignore-not-found", "--force", "--grace-period=0") + if _, err := Run(cmd); err != nil { + warnError(err) + } + } +} + +// InstallCertManager installs the cert manager bundle. +func InstallCertManager() error { + url := fmt.Sprintf(certmanagerURLTmpl, certmanagerVersion) + cmd := exec.Command("kubectl", "apply", "-f", url) + if _, err := Run(cmd); err != nil { + return err + } + // Wait for cert-manager-webhook to be ready, which can take time if cert-manager + // was re-installed after uninstalling on a cluster. + cmd = exec.Command("kubectl", "wait", "deployment.apps/cert-manager-webhook", + "--for", "condition=Available", + "--namespace", "cert-manager", + "--timeout", "5m", + ) + + _, err := Run(cmd) + return err +} + +// IsCertManagerCRDsInstalled checks if any Cert Manager CRDs are installed +// by verifying the existence of key CRDs related to Cert Manager. +func IsCertManagerCRDsInstalled() bool { + // List of common Cert Manager CRDs + certManagerCRDs := []string{ + "certificates.cert-manager.io", + "issuers.cert-manager.io", + "clusterissuers.cert-manager.io", + "certificaterequests.cert-manager.io", + "orders.acme.cert-manager.io", + "challenges.acme.cert-manager.io", + } + + // Execute the kubectl command to get all CRDs + cmd := exec.Command("kubectl", "get", "crds") + output, err := Run(cmd) + if err != nil { + return false + } + + // Check if any of the Cert Manager CRDs are present + crdList := GetNonEmptyLines(output) + for _, crd := range certManagerCRDs { + for _, line := range crdList { + if strings.Contains(line, crd) { + return true + } + } + } + + return false +} + +// LoadImageToKindClusterWithName loads a local docker image to the kind cluster +func LoadImageToKindClusterWithName(name string) error { + cluster := defaultKindCluster + if v, ok := os.LookupEnv("KIND_CLUSTER"); ok { + cluster = v + } + kindOptions := []string{"load", "docker-image", name, "--name", cluster} + kindBinary := defaultKindBinary + if v, ok := os.LookupEnv("KIND"); ok { + kindBinary = v + } + cmd := exec.Command(kindBinary, kindOptions...) + _, err := Run(cmd) + return err +} + +// GetNonEmptyLines converts given command output string into individual objects +// according to line breakers, and ignores the empty elements in it. +func GetNonEmptyLines(output string) []string { + var res []string + elements := strings.Split(output, "\n") + for _, element := range elements { + if element != "" { + res = append(res, element) + } + } + + return res +} + +// GetProjectDir will return the directory where the project is +func GetProjectDir() (string, error) { + wd, err := os.Getwd() + if err != nil { + return wd, fmt.Errorf("failed to get current working directory: %w", err) + } + wd = strings.ReplaceAll(wd, "/test/e2e", "") + return wd, nil +} + +// UncommentCode searches for target in the file and remove the comment prefix +// of the target content. The target content may span multiple lines. +func UncommentCode(filename, target, prefix string) error { + // false positive + // nolint:gosec + content, err := os.ReadFile(filename) + if err != nil { + return fmt.Errorf("failed to read file %q: %w", filename, err) + } + strContent := string(content) + + idx := strings.Index(strContent, target) + if idx < 0 { + return fmt.Errorf("unable to find the code %q to be uncomment", target) + } + + out := new(bytes.Buffer) + _, err = out.Write(content[:idx]) + if err != nil { + return fmt.Errorf("failed to write to output: %w", err) + } + + scanner := bufio.NewScanner(bytes.NewBufferString(target)) + if !scanner.Scan() { + return nil + } + for { + if _, err = out.WriteString(strings.TrimPrefix(scanner.Text(), prefix)); err != nil { + return fmt.Errorf("failed to write to output: %w", err) + } + // Avoid writing a newline in case the previous line was the last in target. + if !scanner.Scan() { + break + } + if _, err = out.WriteString("\n"); err != nil { + return fmt.Errorf("failed to write to output: %w", err) + } + } + + if _, err = out.Write(content[idx+len(target):]); err != nil { + return fmt.Errorf("failed to write to output: %w", err) + } + + // false positive + // nolint:gosec + if err = os.WriteFile(filename, out.Bytes(), 0644); err != nil { + return fmt.Errorf("failed to write file %q: %w", filename, err) + } + + return nil +} diff --git a/flytecopilot/.gitignore b/flytecopilot/.gitignore new file mode 100644 index 0000000000..6f17a622f0 --- /dev/null +++ b/flytecopilot/.gitignore @@ -0,0 +1,17 @@ +# Binaries for programs and plugins +*.exe +*.exe~ +*.dll +*.so +*.dylib + +# Test binary, built with `go test -c` +*.test + +# Output of the go coverage tool, specifically when used with LiteIDE +*.out + +# Dependency directories (remove the comment below to include it) +# vendor/ +.idea +artifacts/* diff --git a/flytecopilot/.golangci.yml b/flytecopilot/.golangci.yml new file mode 100644 index 0000000000..71a85ec5c3 --- /dev/null +++ b/flytecopilot/.golangci.yml @@ -0,0 +1,32 @@ +run: + skip-dirs: + - pkg/client +linters: + disable-all: true + enable: + - errcheck + - gosec + - gci + - goconst + - goimports + - gosimple + - govet + - ineffassign + - misspell + - nakedret + - staticcheck + - typecheck + - unconvert + - unparam + - unused + - protogetter +linters-settings: + gci: + custom-order: true + sections: + - standard + - default + - prefix(github.com/flyteorg) + skip-generated: true + goconst: + ignore-tests: true diff --git a/flytecopilot/.goreleaser.yml b/flytecopilot/.goreleaser.yml new file mode 100644 index 0000000000..07e0f7d8d1 --- /dev/null +++ b/flytecopilot/.goreleaser.yml @@ -0,0 +1,36 @@ +project_name: flytecopilot +before: + hooks: + - go mod download +builds: + - id: flytecopilot + env: + - CGO_ENABLED=0 + main: ./main.go + ldflags: + - -s -w -X github.com/flyteorg/flytestdlib/version.Version={{.Version}} -X github.com/flyteorg/flytestdlib/version.Build={{.ShortCommit}} -X github.com/flyteorg/flytestdlib/version.BuildTime={{.Date}} + binary: flytecopilot + goos: + - linux + - windows + - darwin +archives: + - id: flytecopilot-archive + name_template: |- + flytecopilot_{{ .Tag }}_{{ .Os }}_ + {{- if eq .Arch "amd64" }}x86_64 + {{- else if eq .Arch "386" }}i386 + {{- else }}{{ .Arch }}{{ end }} + builds: + - flytecopilot + format_overrides: + - goos: windows + format: zip +checksum: + name_template: 'checksums.txt' +changelog: + sort: asc + filters: + exclude: + - '^docs:' + - '^test:' diff --git a/flytecopilot/Makefile b/flytecopilot/Makefile new file mode 100755 index 0000000000..8a21a884ff --- /dev/null +++ b/flytecopilot/Makefile @@ -0,0 +1,27 @@ +export REPOSITORY=flytecopilot +export REPO_ROOT=.. +include ../boilerplate/flyte/docker_build/Makefile +include ../boilerplate/flyte/golang_test_targets/Makefile + +.PHONY: update_boilerplate +update_boilerplate: + @curl https://raw.githubusercontent.com/flyteorg/boilerplate/master/boilerplate/update.sh -o boilerplate/update.sh + @boilerplate/update.sh + +clean: + rm -rf bin + +.PHONY: linux_compile +linux_compile: export CGO_ENABLED ?= 0 +linux_compile: export GOOS ?= linux +linux_compile: + go build -o /artifacts/flyte-copilot . + +.PHONY: compile +compile: + mkdir -p ./artifacts + go build -o ./artifacts/flyte-copilot . + +cross_compile: + @mkdir -p ./artifacts/cross + GOOS=linux GOARCH=amd64 go build -o ./artifacts/flyte-copilot . diff --git a/flytecopilot/README.md b/flytecopilot/README.md new file mode 100644 index 0000000000..92304e947f --- /dev/null +++ b/flytecopilot/README.md @@ -0,0 +1,52 @@ +# Flyte CoPilot + +## Overview +Flyte CoPilot provides a sidecar that understand Flyte Metadata Format as specified in FlyteIDL and make it possible to run arbitrary containers in Flyte. +This is achieved using `flyte-copilot` a binary that runs in 2 modes, + -*Downloader* - Downloads the metadata and any other data (if configured) to a provided path. In kubernetes this path could be a shared volume. + - *Sidecar* - Monitors the process and uploads any data that is generated by the process in a prescribed path/ + +## Mode: Downloader + +```bash +$ flyte-copilot downloader +``` + +In K8s `flyte-copilot downloader` can be run as part of the init containers with the download volume mounted. This guarantees that the metadata and any data (if configured) +is downloaded before the main container starts up. + +## Mode: Sidecar + As a sidecar process, that runs in parallel with the main container/process, the goal is to + 1. identify the main container + 2. Wait for the main container to start up + 3. Wait for the main container to exit + 4. Copy the data to remote store (especially the metadata) + 5. Exit + +```bash +$ flyte-copilot sidecar +``` + +### Raw notes + Solution 1: + poll Kubeapi. + - Works perfectly fine, but too much load on kubeapi + + Solution 2: + Create a protocol. Main container will exit and write a _SUCCESS file to a known location + - problem in the case of oom or random exits. Uploader will be stuck. We could use a timeout? and in the sidecar just kill the pod, when the main exits unhealthy? + + Solution 3: + Use shared process namespace. This allows all pids in a pod to share the namespace. Thus pids can see each other. + + Problems: + How to identify the main container? + - Container id is not known ahead of time and container name -> Pid mapping is not possible? + - How to wait for main container to start up. + One solution for both, call kubeapi and get pod info and find the container id + + Note: we can poll /proc/pid/cgroup file (it contains the container id) so we can create a blind container id to pid mapping. Then somehow get the main container id + + Once we know the main container, waiting for it to exit is simple and implemented + Copying data is simple and implemented + diff --git a/flytecopilot/cmd/containerwatcher/iface.go b/flytecopilot/cmd/containerwatcher/iface.go new file mode 100644 index 0000000000..766d6f5988 --- /dev/null +++ b/flytecopilot/cmd/containerwatcher/iface.go @@ -0,0 +1,28 @@ +package containerwatcher + +import ( + "context" + "fmt" +) + +var ErrTimeout = fmt.Errorf("timeout while waiting") + +type Watcher interface { + WaitToStart(ctx context.Context) error + WaitToExit(ctx context.Context) error +} + +type WatcherType = string + +const ( + // Uses Kube 1.28 feature - https://kubernetes.io/docs/concepts/workloads/pods/sidecar-containers/ + // Watching SIGTERM when main container exit + WatcherTypeSignal WatcherType = "signal" + // Dummy watcher. Exits immediately, assuming success + WatcherTypeNoop WatcherType = "noop" +) + +var AllWatcherTypes = []WatcherType{ + WatcherTypeSignal, + WatcherTypeNoop, +} diff --git a/flytecopilot/cmd/containerwatcher/noop_watcher.go b/flytecopilot/cmd/containerwatcher/noop_watcher.go new file mode 100644 index 0000000000..2084e8afcf --- /dev/null +++ b/flytecopilot/cmd/containerwatcher/noop_watcher.go @@ -0,0 +1,20 @@ +package containerwatcher + +import ( + "context" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +type NoopWatcher struct { +} + +func (n NoopWatcher) WaitToStart(ctx context.Context) error { + logger.Warn(ctx, "noop container watcher setup. assuming container started.") + return nil +} + +func (n NoopWatcher) WaitToExit(ctx context.Context) error { + logger.Warn(ctx, "noop container watcher setup. assuming container exited.") + return nil +} diff --git a/flytecopilot/cmd/containerwatcher/signal_watcher.go b/flytecopilot/cmd/containerwatcher/signal_watcher.go new file mode 100644 index 0000000000..1d4615337e --- /dev/null +++ b/flytecopilot/cmd/containerwatcher/signal_watcher.go @@ -0,0 +1,38 @@ +package containerwatcher + +import ( + "context" + "os" + "os/signal" + "syscall" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +type SignalWatcher struct { +} + +func (n SignalWatcher) WaitToStart(ctx context.Context) error { + logger.Warn(ctx, "WaitToStart is not needed for signal watcher.") + return nil +} + +func (n SignalWatcher) WaitToExit(ctx context.Context) error { + logger.Infof(ctx, "Signal Watcher waiting for termination signal") + defer logger.Infof(ctx, "Signal Watcher exiting on termination signal") + + // Listen for SIGTERM + sigs := make(chan os.Signal, 1) + signal.Notify(sigs, syscall.SIGTERM) + defer signal.Stop(sigs) + + // Wait for SIGTERM signal or cancel context + select { + case sig := <-sigs: + logger.Infof(ctx, "Received signal: %v", sig) + return nil + case <-ctx.Done(): + logger.Infof(ctx, "Context canceled") + return nil + } +} diff --git a/flytecopilot/cmd/download.go b/flytecopilot/cmd/download.go new file mode 100644 index 0000000000..0a575cfe6e --- /dev/null +++ b/flytecopilot/cmd/download.go @@ -0,0 +1,121 @@ +package cmd + +import ( + "context" + "fmt" + "time" + + "github.com/spf13/cobra" + + "github.com/flyteorg/flyte/v2/flytecopilot/data" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +type DownloadOptions struct { + *RootOptions + remoteInputsPath string + remoteOutputsPrefix string + localDirectoryPath string + inputInterface []byte + metadataFormat string + downloadMode string + timeout time.Duration +} + +func GetFormatVals() []string { + var vals []string + for k := range core.DataLoadingConfig_LiteralMapFormat_value { + vals = append(vals, k) + } + return vals +} + +func GetDownloadModeVals() []string { + var vals []string + for k := range core.IOStrategy_DownloadMode_value { + vals = append(vals, k) + } + return vals +} + +func GetUploadModeVals() []string { + var vals []string + for k := range core.IOStrategy_UploadMode_value { + vals = append(vals, k) + } + return vals +} + +func (d *DownloadOptions) Download(ctx context.Context) error { + if d.remoteOutputsPrefix == "" { + return fmt.Errorf("to-output-prefix is required") + } + + // We need remote outputs prefix to write and error file + err := func() error { + if d.localDirectoryPath == "" { + return fmt.Errorf("to-local-dir is required") + } + if d.remoteInputsPath == "" { + return fmt.Errorf("from-remote is required") + } + f, ok := core.DataLoadingConfig_LiteralMapFormat_value[d.metadataFormat] + if !ok { + return fmt.Errorf("incorrect input download format specified, given [%s], possible values [%+v]", d.metadataFormat, GetFormatVals()) + } + + m, ok := core.IOStrategy_DownloadMode_value[d.downloadMode] + if !ok { + return fmt.Errorf("incorrect input download mode specified, given [%s], possible values [%+v]", d.downloadMode, GetDownloadModeVals()) + } + dl := data.NewDownloader(ctx, d.Store, core.DataLoadingConfig_LiteralMapFormat(f), core.IOStrategy_DownloadMode(m)) + childCtx := ctx + cancelFn := func() {} + if d.timeout > 0 { + childCtx, cancelFn = context.WithTimeout(ctx, d.timeout) + } + defer cancelFn() + err := dl.DownloadInputs(childCtx, storage.DataReference(d.remoteInputsPath), d.localDirectoryPath) + if err != nil { + logger.Errorf(ctx, "Downloading failed, err %s", err) + return err + } + return nil + }() + + if err != nil { + if err2 := d.UploadError(ctx, "InputDownloadFailed", err, storage.DataReference(d.remoteOutputsPrefix)); err2 != nil { + logger.Errorf(ctx, "Failed to write error document, err :%s", err2) + return err2 + } + } + return nil +} + +func NewDownloadCommand(opts *RootOptions) *cobra.Command { + + downloadOpts := &DownloadOptions{ + RootOptions: opts, + } + + // deleteCmd represents the delete command + downloadCmd := &cobra.Command{ + Use: "download ", + Short: "downloads flytedata from the remotepath to a local directory.", + Long: `Currently it looks at the outputs.pb and creates one file per variable.`, + RunE: func(cmd *cobra.Command, args []string) error { + return downloadOpts.Download(context.Background()) + }, + } + + downloadCmd.Flags().StringVarP(&downloadOpts.remoteInputsPath, "from-remote", "f", "", "The remote path/key for inputs in stow store.") + downloadCmd.Flags().StringVarP(&downloadOpts.remoteOutputsPrefix, "to-output-prefix", "", "", "The remote path/key prefix for outputs in stow store. this is mostly used to write errors.pb.") + downloadCmd.Flags().StringVarP(&downloadOpts.localDirectoryPath, "to-local-dir", "o", "", "The local directory on disk where data should be downloaded.") + downloadCmd.Flags().StringVarP(&downloadOpts.metadataFormat, "format", "m", core.DataLoadingConfig_JSON.String(), fmt.Sprintf("What should be the output format for the primitive and structured types. Options [%v]", GetFormatVals())) + downloadCmd.Flags().StringVarP(&downloadOpts.downloadMode, "download-mode", "d", core.IOStrategy_DOWNLOAD_EAGER.String(), fmt.Sprintf("Download mode to use. Options [%v]", GetDownloadModeVals())) + downloadCmd.Flags().DurationVarP(&downloadOpts.timeout, "timeout", "t", time.Hour*1, "Max time to allow for downloads to complete, default is 1H") + downloadCmd.Flags().BytesBase64VarP(&downloadOpts.inputInterface, "input-interface", "i", nil, "Input interface proto message - core.VariableMap, base64 encoced string") + return downloadCmd +} diff --git a/flytecopilot/cmd/download_test.go b/flytecopilot/cmd/download_test.go new file mode 100644 index 0000000000..4d3a477af9 --- /dev/null +++ b/flytecopilot/cmd/download_test.go @@ -0,0 +1,189 @@ +package cmd + +import ( + "bytes" + "context" + "io/ioutil" + "os" + "path/filepath" + "sort" + "strings" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flyteidl2/clients/go/coreutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestDownloadOptions_Download(t *testing.T) { + + tmpFolderLocation := "" + tmpPrefix := "download_test" + inputPath := "input/inputs.pb" + outputPath := "output" + + ctx := context.TODO() + dopts := DownloadOptions{ + remoteInputsPath: inputPath, + remoteOutputsPrefix: outputPath, + metadataFormat: core.DataLoadingConfig_JSON.String(), + downloadMode: core.IOStrategy_DOWNLOAD_EAGER.String(), + } + + collectFile := func(d string) []string { + var files []string + assert.NoError(t, filepath.Walk(d, func(path string, info os.FileInfo, err error) error { + if !strings.Contains(info.Name(), tmpPrefix) { + files = append(files, info.Name()) + } // Skip tmp folder + return nil + })) + sort.Strings(files) + return files + } + + t.Run("emptyInputs", func(t *testing.T) { + tmpDir, err := ioutil.TempDir(tmpFolderLocation, tmpPrefix) + assert.NoError(t, err) + defer func() { + assert.NoError(t, os.RemoveAll(tmpDir)) + }() + dopts.localDirectoryPath = tmpDir + + s := promutils.NewTestScope() + store, err := storage.NewDataStore(&storage.Config{Type: storage.TypeMemory}, s.NewSubScope("storage")) + assert.NoError(t, err) + dopts.RootOptions = &RootOptions{ + Scope: s, + Store: store, + } + + assert.NoError(t, store.WriteProtobuf(ctx, storage.DataReference(inputPath), storage.Options{}, &core.LiteralMap{})) + assert.NoError(t, dopts.Download(ctx)) + + assert.Len(t, collectFile(tmpDir), 0) + }) + + t.Run("primitiveInputs", func(t *testing.T) { + tmpDir, err := ioutil.TempDir(tmpFolderLocation, tmpPrefix) + assert.NoError(t, err) + defer func() { + assert.NoError(t, os.RemoveAll(tmpDir)) + }() + dopts.localDirectoryPath = tmpDir + + s := promutils.NewTestScope() + store, err := storage.NewDataStore(&storage.Config{Type: storage.TypeMemory}, s.NewSubScope("storage")) + assert.NoError(t, err) + dopts.RootOptions = &RootOptions{ + Scope: s, + Store: store, + } + + assert.NoError(t, store.WriteProtobuf(ctx, storage.DataReference(inputPath), storage.Options{}, &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "x": coreutils.MustMakePrimitiveLiteral(1), + "y": coreutils.MustMakePrimitiveLiteral("hello"), + }, + })) + assert.NoError(t, dopts.Download(ctx), "Download Operation failed") + assert.Equal(t, []string{"inputs.json", "inputs.pb", "x", "y"}, collectFile(tmpDir)) + }) + + t.Run("primitiveAndBlobInputs", func(t *testing.T) { + tmpDir, err := ioutil.TempDir(tmpFolderLocation, tmpPrefix) + assert.NoError(t, err) + defer func() { + assert.NoError(t, os.RemoveAll(tmpDir)) + }() + dopts.localDirectoryPath = tmpDir + + s := promutils.NewTestScope() + store, err := storage.NewDataStore(&storage.Config{Type: storage.TypeMemory}, s.NewSubScope("storage")) + assert.NoError(t, err) + dopts.RootOptions = &RootOptions{ + Scope: s, + Store: store, + } + + blobLoc := storage.DataReference("blob-loc") + br := bytes.NewBuffer([]byte("Hello World!")) + assert.NoError(t, store.WriteRaw(ctx, blobLoc, int64(br.Len()), storage.Options{}, br)) + assert.NoError(t, store.WriteProtobuf(ctx, storage.DataReference(inputPath), storage.Options{}, &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "x": coreutils.MustMakePrimitiveLiteral(1), + "y": coreutils.MustMakePrimitiveLiteral("hello"), + "blob": {Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Blob{ + Blob: &core.Blob{ + Uri: blobLoc.String(), + Metadata: &core.BlobMetadata{ + Type: &core.BlobType{ + Dimensionality: core.BlobType_SINGLE, + Format: ".xyz", + }, + }, + }, + }, + }, + }}, + }, + })) + assert.NoError(t, dopts.Download(ctx), "Download Operation failed") + assert.ElementsMatch(t, []string{"inputs.json", "inputs.pb", "x", "y", "blob"}, collectFile(tmpDir)) + }) + + t.Run("primitiveAndMissingBlobInputs", func(t *testing.T) { + tmpDir, err := ioutil.TempDir(tmpFolderLocation, tmpPrefix) + assert.NoError(t, err) + defer func() { + assert.NoError(t, os.RemoveAll(tmpDir)) + }() + dopts.localDirectoryPath = tmpDir + + s := promutils.NewTestScope() + store, err := storage.NewDataStore(&storage.Config{Type: storage.TypeMemory}, s.NewSubScope("storage")) + assert.NoError(t, err) + dopts.RootOptions = &RootOptions{ + Scope: s, + Store: store, + errorOutputName: "errors.pb", + } + + assert.NoError(t, store.WriteProtobuf(ctx, storage.DataReference(inputPath), storage.Options{}, &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "x": coreutils.MustMakePrimitiveLiteral(1), + "y": coreutils.MustMakePrimitiveLiteral("hello"), + "blob": {Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Blob{ + Blob: &core.Blob{ + Uri: "blob", + Metadata: &core.BlobMetadata{ + Type: &core.BlobType{ + Dimensionality: core.BlobType_SINGLE, + Format: ".xyz", + }, + }, + }, + }, + }, + }}, + }, + })) + err = dopts.Download(ctx) + assert.NoError(t, err, "Download Operation failed") + errFile, err := store.ConstructReference(ctx, storage.DataReference(outputPath), "errors.pb") + assert.NoError(t, err) + errProto := &core.ErrorDocument{} + err = store.ReadProtobuf(ctx, errFile, errProto) + assert.NoError(t, err) + if assert.NotNil(t, errProto.GetError()) { + assert.Equal(t, core.ContainerError_RECOVERABLE, errProto.GetError().GetKind()) + } + }) +} diff --git a/flytecopilot/cmd/root.go b/flytecopilot/cmd/root.go new file mode 100644 index 0000000000..ee6fdca010 --- /dev/null +++ b/flytecopilot/cmd/root.go @@ -0,0 +1,146 @@ +package cmd + +import ( + "context" + "flag" + "fmt" + "os" + "runtime" + + "github.com/pkg/errors" + "github.com/spf13/cobra" + "github.com/spf13/pflag" + "k8s.io/client-go/tools/clientcmd" + "k8s.io/klog/v2" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/config/viper" + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils/labeled" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/flytestdlib/version" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +type RootOptions struct { + *clientcmd.ConfigOverrides + showSource bool + clientConfig clientcmd.ClientConfig + Scope promutils.Scope + Store *storage.DataStore + configAccessor config.Accessor + cfgFile string + // The actual key name that should be created under the remote prefix where the error document is written of the form errors.pb + errorOutputName string +} + +func (r *RootOptions) executeRootCmd() error { + ctx := context.TODO() + logger.Infof(ctx, "Go Version: %s", runtime.Version()) + logger.Infof(ctx, "Go OS/Arch: %s/%s", runtime.GOOS, runtime.GOARCH) + version.LogBuildInformation("flytedata") + return fmt.Errorf("use one of the sub-commands") +} + +func (r RootOptions) UploadError(ctx context.Context, code string, recvErr error, prefix storage.DataReference) error { + if recvErr == nil { + recvErr = fmt.Errorf("unknown error") + } + errorPath, err := r.Store.ConstructReference(ctx, prefix, r.errorOutputName) + if err != nil { + logger.Errorf(ctx, "failed to create error file path err: %s", err) + return err + } + logger.Infof(ctx, "Uploading Error file to path [%s], errFile: %s", errorPath, r.errorOutputName) + return r.Store.WriteProtobuf(ctx, errorPath, storage.Options{}, &core.ErrorDocument{ + Error: &core.ContainerError{ + Code: code, + Message: recvErr.Error(), + Kind: core.ContainerError_RECOVERABLE, + }, + }) +} + +// NewDataCommand returns a new instance of the co-pilot root command +func NewDataCommand() *cobra.Command { + rootOpts := &RootOptions{} + command := &cobra.Command{ + Use: "flytedata", + Short: "flytedata is a simple go binary that can be used to retrieve and upload data from/to remote stow store to local disk.", + Long: `flytedata when used with conjunction with flytepropeller eliminates the need to have any flyte library installed inside the container`, + PersistentPreRunE: func(cmd *cobra.Command, args []string) error { + if err := rootOpts.initConfig(cmd, args); err != nil { + return err + } + rootOpts.Scope = promutils.NewScope("flyte:data") + cfg := storage.GetConfig() + store, err := storage.NewDataStore(cfg, rootOpts.Scope) + if err != nil { + return errors.Wrap(err, "failed to create datastore client") + } + rootOpts.Store = store + return nil + }, + RunE: func(cmd *cobra.Command, args []string) error { + return rootOpts.executeRootCmd() + }, + } + + command.AddCommand(NewDownloadCommand(rootOpts)) + command.AddCommand(NewUploadCommand(rootOpts)) + + loadingRules := clientcmd.NewDefaultClientConfigLoadingRules() + loadingRules.DefaultClientConfig = &clientcmd.DefaultClientConfig + rootOpts.ConfigOverrides = &clientcmd.ConfigOverrides{} + kflags := clientcmd.RecommendedConfigOverrideFlags("") + command.PersistentFlags().StringVar(&loadingRules.ExplicitPath, "kubeconfig", "", "Path to a kube config. Only required if out-of-cluster") + clientcmd.BindOverrideFlags(rootOpts.ConfigOverrides, command.PersistentFlags(), kflags) + rootOpts.clientConfig = clientcmd.NewInteractiveDeferredLoadingClientConfig(loadingRules, rootOpts.ConfigOverrides, os.Stdin) + + command.PersistentFlags().StringVar(&rootOpts.cfgFile, "config", "", "config file (default is $HOME/config.yaml)") + command.PersistentFlags().BoolVarP(&rootOpts.showSource, "show-source", "s", false, "Show line number for errors") + command.PersistentFlags().StringVar(&rootOpts.errorOutputName, "err-output-name", "errors.pb", "Actual key name under the prefix where the error protobuf should be written to") + + rootOpts.configAccessor = viper.NewAccessor(config.Options{StrictMode: true}) + // Here you will define your flags and configuration settings. Cobra supports persistent flags, which, if defined + // here, will be global for your application. + rootOpts.configAccessor.InitializePflags(command.PersistentFlags()) + + command.AddCommand(viper.GetConfigCommand()) + + return command +} + +func (r *RootOptions) initConfig(cmd *cobra.Command, _ []string) error { + r.configAccessor = viper.NewAccessor(config.Options{ + StrictMode: true, + SearchPaths: []string{r.cfgFile}, + }) + + rootCmd := cmd + for rootCmd.Parent() != nil { + rootCmd = rootCmd.Parent() + } + + // persistent flags were initially bound to the root command so we must bind to the same command to avoid + r.configAccessor.InitializePflags(rootCmd.PersistentFlags()) + + err := r.configAccessor.UpdateConfig(context.TODO()) + if err != nil { + return err + } + return nil +} + +func init() { + klog.InitFlags(flag.CommandLine) + pflag.CommandLine.AddGoFlagSet(flag.CommandLine) + err := flag.CommandLine.Parse([]string{}) + if err != nil { + logger.Errorf(context.TODO(), "Error in initializing: %v", err) + os.Exit(-1) + } + labeled.SetMetricKeys(contextutils.ProjectKey, contextutils.DomainKey, contextutils.WorkflowIDKey, contextutils.TaskIDKey) +} diff --git a/flytecopilot/cmd/sidecar.go b/flytecopilot/cmd/sidecar.go new file mode 100644 index 0000000000..08baa175b1 --- /dev/null +++ b/flytecopilot/cmd/sidecar.go @@ -0,0 +1,155 @@ +package cmd + +import ( + "context" + "fmt" + "time" + + "github.com/golang/protobuf/proto" + "github.com/pkg/errors" + "github.com/spf13/cobra" + + "github.com/flyteorg/flyte/v2/flytecopilot/cmd/containerwatcher" + "github.com/flyteorg/flyte/v2/flytecopilot/data" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const ( + StartFile = "_START" + SuccessFile = "_SUCCESS" + ErrorFile = "_ERROR" +) + +type UploadOptions struct { + *RootOptions + // The remote prefix where all the meta outputs or error should be uploaded of the form s3://bucket/prefix + remoteOutputsPrefix string + // Name like outputs.pb under the remoteOutputsPrefix that should be created to upload the metaOutputs + metaOutputName string + // The remote prefix where all the raw outputs should be uploaded of the form s3://bucket/prefix/ + remoteOutputsRawPrefix string + // Local directory path where the sidecar should look for outputs. + localDirectoryPath string + // Non primitive types will be dumped in this output format + metadataFormat string + uploadMode string + timeout time.Duration + typedInterface []byte + startWatcherType containerwatcher.WatcherType + exitWatcherType containerwatcher.WatcherType +} + +func (u *UploadOptions) createWatcher(_ context.Context, w containerwatcher.WatcherType) (containerwatcher.Watcher, error) { + switch w { + case containerwatcher.WatcherTypeSignal: + return containerwatcher.SignalWatcher{}, nil + case containerwatcher.WatcherTypeNoop: + return containerwatcher.NoopWatcher{}, nil + } + return nil, fmt.Errorf("unsupported watcher type") +} + +func (u *UploadOptions) uploader(ctx context.Context) error { + if u.typedInterface == nil { + logger.Infof(ctx, "No output interface provided. Assuming Void outputs.") + return nil + } + + iface := &core.TypedInterface{} + if err := proto.Unmarshal(u.typedInterface, iface); err != nil { + logger.Errorf(ctx, "Bad interface passed, failed to unmarshal err: %s", err) + return errors.Wrap(err, "Bad interface passed, failed to unmarshal, expected core.TypedInterface") + } + outputInterface := iface.GetOutputs() + + if iface.GetOutputs() == nil || iface.Outputs.Variables == nil || len(iface.GetOutputs().GetVariables()) == 0 { + logger.Infof(ctx, "Empty output interface received. Assuming void outputs. Sidecar will exit immediately.") + return nil + } + + f, ok := core.DataLoadingConfig_LiteralMapFormat_value[u.metadataFormat] + if !ok { + return fmt.Errorf("incorrect input data format specified, given [%s], possible values [%+v]", u.metadataFormat, GetFormatVals()) + } + + m, ok := core.IOStrategy_UploadMode_value[u.uploadMode] + if !ok { + return fmt.Errorf("incorrect input upload mode specified, given [%s], possible values [%+v]", u.uploadMode, GetUploadModeVals()) + } + + logger.Infof(ctx, "Creating start watcher type: %s", u.startWatcherType) + w, err := u.createWatcher(ctx, u.startWatcherType) + if err != nil { + return err + } + + logger.Infof(ctx, "Waiting for Container to exit.") + if err := w.WaitToExit(ctx); err != nil { + logger.Errorf(ctx, "Failed waiting for container to exit. Err: %s", err) + return err + } + + logger.Infof(ctx, "Container Exited! uploading data.") + + // TODO maybe we should just take the meta output path as an input argument + toOutputPath, err := u.Store.ConstructReference(ctx, storage.DataReference(u.remoteOutputsPrefix), u.metaOutputName) + if err != nil { + return err + } + + dl := data.NewUploader(ctx, u.Store, core.DataLoadingConfig_LiteralMapFormat(f), core.IOStrategy_UploadMode(m), ErrorFile) + + childCtx, cancelFn := context.WithTimeout(ctx, u.timeout) + defer cancelFn() + if err := dl.RecursiveUpload(childCtx, outputInterface, u.localDirectoryPath, toOutputPath, storage.DataReference(u.remoteOutputsRawPrefix)); err != nil { + logger.Errorf(ctx, "Uploading failed, err %s", err) + return err + } + + logger.Infof(ctx, "Uploader completed successfully!") + return nil +} + +func (u *UploadOptions) Sidecar(ctx context.Context) error { + + if err := u.uploader(ctx); err != nil { + logger.Errorf(ctx, "Uploading failed, err %s", err) + if err := u.UploadError(ctx, "OutputUploadFailed", err, storage.DataReference(u.remoteOutputsPrefix)); err != nil { + logger.Errorf(ctx, "Failed to write error document, err :%s", err) + return err + } + } + return nil +} + +func NewUploadCommand(opts *RootOptions) *cobra.Command { + + uploadOptions := &UploadOptions{ + RootOptions: opts, + } + + // deleteCmd represents the delete command + uploadCmd := &cobra.Command{ + Use: "sidecar ", + Short: "uploads flyteData from the localpath to a remote dir.", + Long: `Currently it looks at the outputs.pb and creates one file per variable.`, + RunE: func(cmd *cobra.Command, args []string) error { + return uploadOptions.Sidecar(context.Background()) + }, + } + + uploadCmd.Flags().StringVarP(&uploadOptions.remoteOutputsPrefix, "to-output-prefix", "o", "", "The remote path/key prefix for output metadata in stow store.") + uploadCmd.Flags().StringVarP(&uploadOptions.remoteOutputsRawPrefix, "to-raw-output", "x", "", "The remote path/key prefix for outputs in remote store. This is a sandbox directory and all data will be uploaded here.") + uploadCmd.Flags().StringVarP(&uploadOptions.localDirectoryPath, "from-local-dir", "f", "", "The local directory on disk where data will be available for upload.") + uploadCmd.Flags().StringVarP(&uploadOptions.metadataFormat, "format", "m", core.DataLoadingConfig_JSON.String(), fmt.Sprintf("What should be the output format for the primitive and structured types. Options [%v]", GetFormatVals())) + uploadCmd.Flags().StringVarP(&uploadOptions.uploadMode, "upload-mode", "u", core.IOStrategy_UPLOAD_ON_EXIT.String(), fmt.Sprintf("When should upload start/upload mode. Options [%v]", GetUploadModeVals())) + uploadCmd.Flags().StringVarP(&uploadOptions.metaOutputName, "meta-output-name", "", "outputs.pb", "The key name under the remoteOutputPrefix that should be return to provide meta information about the outputs on successful execution") + uploadCmd.Flags().DurationVarP(&uploadOptions.timeout, "timeout", "t", time.Hour*1, "Max time to allow for uploads to complete, default is 1H") + uploadCmd.Flags().BytesBase64VarP(&uploadOptions.typedInterface, "interface", "i", nil, "Typed Interface - core.TypedInterface, base64 encoded string of the serialized protobuf") + uploadCmd.Flags().DurationVarP(&uploadOptions.timeout, "start-timeout", "", 0, "Deprecated: Use --timeout instead. Specifies the maximum duration to allow uploads to complete. Retained for backward compatibility.") + uploadCmd.Flags().StringVarP(&uploadOptions.startWatcherType, "start-watcher-type", "", containerwatcher.WatcherTypeSignal, fmt.Sprintf("Sidecar will wait for container before starting upload process. Watcher type makes the type configurable. Available Type %+v", containerwatcher.AllWatcherTypes)) + uploadCmd.Flags().StringVarP(&uploadOptions.exitWatcherType, "exit-watcher-type", "", containerwatcher.WatcherTypeSignal, fmt.Sprintf("Sidecar will wait for completion of the container before starting upload process. Watcher type makes the type configurable. Available Type %+v", containerwatcher.AllWatcherTypes)) + return uploadCmd +} diff --git a/flytecopilot/cmd/sidecar_test.go b/flytecopilot/cmd/sidecar_test.go new file mode 100644 index 0000000000..e305ba9dea --- /dev/null +++ b/flytecopilot/cmd/sidecar_test.go @@ -0,0 +1,93 @@ +package cmd + +import ( + "context" + "io/ioutil" + "os" + "testing" + + "github.com/golang/protobuf/proto" + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytecopilot/cmd/containerwatcher" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestUploadOptions_Upload(t *testing.T) { + tmpFolderLocation := "" + tmpPrefix := "upload_test" + outputPath := "output" + + ctx := context.TODO() + + t.Run("uploadNoOutputs", func(t *testing.T) { + tmpDir, err := ioutil.TempDir(tmpFolderLocation, tmpPrefix) + assert.NoError(t, err) + defer func() { + assert.NoError(t, os.RemoveAll(tmpDir)) + }() + + s := promutils.NewTestScope() + store, err := storage.NewDataStore(&storage.Config{Type: storage.TypeMemory}, s.NewSubScope("storage")) + assert.NoError(t, err) + uopts := UploadOptions{ + RootOptions: &RootOptions{ + Scope: s, + Store: store, + }, + remoteOutputsPrefix: outputPath, + metadataFormat: core.DataLoadingConfig_JSON.String(), + uploadMode: core.IOStrategy_UPLOAD_ON_EXIT.String(), + startWatcherType: containerwatcher.WatcherTypeNoop, + localDirectoryPath: tmpDir, + } + + assert.NoError(t, uopts.Sidecar(ctx)) + }) + + t.Run("uploadBlobType-FileNotFound", func(t *testing.T) { + tmpDir, err := ioutil.TempDir(tmpFolderLocation, tmpPrefix) + assert.NoError(t, err) + defer func() { + assert.NoError(t, os.RemoveAll(tmpDir)) + }() + s := promutils.NewTestScope() + store, err := storage.NewDataStore(&storage.Config{Type: storage.TypeMemory}, s.NewSubScope("storage")) + assert.NoError(t, err) + + iface := &core.TypedInterface{ + Outputs: &core.VariableMap{ + Variables: map[string]*core.Variable{ + "x": { + Type: &core.LiteralType{Type: &core.LiteralType_Blob{Blob: &core.BlobType{Dimensionality: core.BlobType_SINGLE}}}, + Description: "example", + }, + }, + }, + } + d, err := proto.Marshal(iface) + assert.NoError(t, err) + + uopts := UploadOptions{ + RootOptions: &RootOptions{ + Scope: s, + Store: store, + errorOutputName: "errors.pb", + }, + remoteOutputsPrefix: outputPath, + metadataFormat: core.DataLoadingConfig_JSON.String(), + uploadMode: core.IOStrategy_UPLOAD_ON_EXIT.String(), + startWatcherType: containerwatcher.WatcherTypeNoop, + exitWatcherType: containerwatcher.WatcherTypeNoop, + typedInterface: d, + localDirectoryPath: tmpDir, + } + + assert.NoError(t, uopts.Sidecar(ctx)) + v, err := store.Head(ctx, "/output/errors.pb") + assert.NoError(t, err) + assert.True(t, v.Exists()) + }) +} diff --git a/flytecopilot/data/common.go b/flytecopilot/data/common.go new file mode 100644 index 0000000000..132d57b37b --- /dev/null +++ b/flytecopilot/data/common.go @@ -0,0 +1,22 @@ +// This module contains Flyte CoPilot related code. +// Currently it only has 2 utilities - downloader and an uploader. +// Usage Downloader: +// +// downloader := NewDownloader(...) +// downloader.DownloadInputs(...) // will recursively download all inputs +// +// Usage uploader: +// +// uploader := NewUploader(...) +// uploader.RecursiveUpload(...) // Will recursively upload all the data from the given path depending on the output interface +// +// All errors are bubbled up. +// +// Both the uploader and downloader accept context.Context variables. These should be used to control timeouts etc. +// TODO: Currently retries are not automatically handled. +package data + +import "github.com/flyteorg/flyte/v2/flytestdlib/futures" + +type VarMap map[string]interface{} +type FutureMap map[string]futures.Future diff --git a/flytecopilot/data/download.go b/flytecopilot/data/download.go new file mode 100644 index 0000000000..853487cfa2 --- /dev/null +++ b/flytecopilot/data/download.go @@ -0,0 +1,575 @@ +package data + +import ( + "context" + "encoding/json" + "fmt" + "io" + "os" + "path" + "path/filepath" + "reflect" + "strconv" + "strings" + "sync" + + "github.com/ghodss/yaml" + "github.com/golang/protobuf/jsonpb" + "github.com/golang/protobuf/proto" + "github.com/golang/protobuf/ptypes" + structpb "github.com/golang/protobuf/ptypes/struct" + "github.com/pkg/errors" + + "github.com/flyteorg/flyte/v2/flytestdlib/futures" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +type Downloader struct { + format core.DataLoadingConfig_LiteralMapFormat + store *storage.DataStore + // TODO support download mode + mode core.IOStrategy_DownloadMode +} + +// TODO add timeout and rate limit +// TODO use chunk to download +func (d Downloader) handleBlob(ctx context.Context, blob *core.Blob, toPath string) (interface{}, error) { + /* + handleBlob handles the retrieval and local storage of blob data, including support for both single and multipart blob types. + For multipart blobs, it lists all parts recursively and spawns concurrent goroutines to download each part while managing file I/O in parallel. + + - The function begins by validating the blob URI and categorizing the blob type (single or multipart). + - In the multipart case, it recursively lists all blob parts and launches goroutines to download and save each part. + Goroutine closure and I/O success tracking are managed to avoid resource leaks. + - For single-part blobs, it directly downloads and writes the data to the specified path. + + Life Cycle: + 1. Blob URI -> Blob Metadata Type check -> Recursive List parts if Multipart -> Launch goroutines to download parts + (input blob object) (determine multipart/single) (List API, handles recursive case) (each part handled in parallel) + 2. Download part or full blob -> Save locally with error checks -> Handle reader/writer closures -> Return local path or error + (download each part) (error on write or directory) (close streams safely, track success) (completion or report missing closures) + + More clarification on Folders. If a user returns FlyteFile("/my/folder") and inside /my/folder is + - sample.txt + - nested/ + - deep_file.txt + + The blob uri is something like: s3://container/oz/a9ss8w4mnkk8zttr9p7z-n0-0/0fda6abb7cd4e45cfae4920f0b8a586d + and inside are the files: + - s3://container/oz/a9ss8w4mnkk8zttr9p7z-n0-0/0fda6abb7cd4e45cfae4920f0b8a586d/sample.txt + - s3://container/oz/a9ss8w4mnkk8zttr9p7z-n0-0/0fda6abb7cd4e45cfae4920f0b8a586d/nested/deep_file.txt + the top level folder disappears. If we want t + */ + + blobRef := storage.DataReference(blob.GetUri()) + scheme, baseContainer, basePrefix, err := blobRef.Split() + logger.Debugf(ctx, "Downloader handling blob [%s] uri [%s] in bucket [%s] prefix [%s]", scheme, blob.GetUri(), baseContainer, basePrefix) + if err != nil { + return nil, errors.Wrapf(err, "Blob uri incorrectly formatted") + } + + if blob.GetMetadata().GetType().GetDimensionality() == core.BlobType_MULTIPART { + // Collect all parts of the multipart blob recursively (List API handles nested directories) + // Set maxItems to 100 as a parameter for the List API, enabling batch retrieval of items until all are downloaded + maxItems := 100 + cursor := storage.NewCursorAtStart() + var items []storage.DataReference + var absPaths []string + + for { + items, cursor, err = d.store.List(ctx, blobRef, maxItems, cursor) + if err != nil || len(items) == 0 { + logger.Errorf(ctx, "failed to collect items from multipart blob [%s]", blobRef) + return nil, err + } + for _, item := range items { + absPaths = append(absPaths, item.String()) + } + if storage.IsCursorEnd(cursor) { + break + } + } + + // Track the count of successful downloads and the total number of items + downloadSuccess := 0 + itemCount := len(absPaths) + // Track successful closures of readers and writers in deferred functions + readerCloseSuccessCount := 0 + writerCloseSuccessCount := 0 + // We use Mutex to avoid race conditions when updating counters and creating directories + var mu sync.Mutex + var wg sync.WaitGroup + for _, absPath := range absPaths { + absPath := absPath + + wg.Add(1) + go func() { + defer wg.Done() + defer func() { + if err := recover(); err != nil { + logger.Errorf(ctx, "recover receives error: [%s]", err) + } + }() + + ref := storage.DataReference(absPath) + scheme, _, prefix, err := ref.Split() + if err != nil { + logger.Errorf(ctx, "Failed to parse [%s] [%s]", ref, err) + return + } + var reader io.ReadCloser + if scheme == "http" || scheme == "https" { + reader, err = DownloadFileFromHTTP(ctx, ref) + } else { + reader, err = DownloadFileFromStorage(ctx, ref, d.store) + } + if err != nil { + logger.Errorf(ctx, "Failed to download from ref [%s]", ref) + return + } + defer func() { + err := reader.Close() + if err != nil { + logger.Errorf(ctx, "failed to close Blob read stream @ref [%s].\n"+ + "Error: %s", ref, err) + } + mu.Lock() + readerCloseSuccessCount++ + mu.Unlock() + }() + + // Strip the base path from the item prefix to get the relative path + // For HTTP/HTTPS URLs: prefix includes bucket + path (e.g., "bucket/sm/akm6s4bgd6lwx6fhzf58-n0-0/705fe4570586b256a5b0e5fd598b4c28/sample.txt") + // For S3/GS URLs: prefix only includes path (e.g., "sm/akm6s4bgd6lwx6fhzf58-n0-0/705fe4570586b256a5b0e5fd598b4c28/sample.txt") + // We need to strip the blob's base path to get just the relative file path + relativePath := prefix + + // Strip the base path from the item prefix to get the relative path + // This works for both HTTP and native cloud storage URLs: + // - HTTP: prefix="bucket/path/file.txt", basePrefix="path" + // - S3/GS: prefix="path/file.txt", basePrefix="path" + if strings.HasPrefix(absPath, "http") { + // Try matching two ways... + logger.Debugf(ctx, "matching with container, prefix=[%s] %s", prefix, baseContainer+"/"+basePrefix) + if strings.HasPrefix(prefix, baseContainer) { + // This works for S3 + relativePath = strings.TrimPrefix(prefix, baseContainer+"/"+basePrefix) + } else { + // This is here because google has the aggravating behavior of injecting a /o/ into the download + // link so we can't use the above. instead just look for the basePrefix in the prefix. + // This should work for S3 too, but using the base container feels safer. + idx := strings.Index(prefix, basePrefix) + if idx == -1 { + logger.Errorf(ctx, "Failed to find container prefix [%s]", prefix) + } else { + // Extract everything after basePrefix + relativePath = prefix[idx+len(basePrefix):] + } + } + } else { + logger.Debugf(ctx, "matching prefix=[%s] %s", prefix, basePrefix) + relativePath = strings.TrimPrefix(prefix, basePrefix) + } + // Remove leading slash if it exists + relativePath = strings.TrimPrefix(relativePath, "/") + logger.Debugf(ctx, "Extracting file from %s, using relative path %s", absPath, relativePath) + + newPath := filepath.Join(toPath, relativePath) + dir := filepath.Dir(newPath) + + mu.Lock() + // os.MkdirAll creates the specified directory structure if it doesnโ€™t already exist + // 0777: the directory can be read and written by anyone + err = os.MkdirAll(dir, 0777) + mu.Unlock() + if err != nil { + logger.Errorf(ctx, "failed to make dir at path [%s]", dir) + return + } + + writer, err := os.Create(newPath) + if err != nil { + logger.Errorf(ctx, "failed to open file at path [%s]", newPath) + return + } + defer func() { + err := writer.Close() + if err != nil { + logger.Errorf(ctx, "failed to close File write stream.\n"+ + "Error: [%s]", err) + } + mu.Lock() + writerCloseSuccessCount++ + mu.Unlock() + }() + + _, err = io.Copy(writer, reader) + if err != nil { + logger.Errorf(ctx, "failed to write remote data to local filesystem") + return + } + mu.Lock() + downloadSuccess++ + mu.Unlock() + }() + } + // Go routines are synchronized with a WaitGroup to prevent goroutine leaks. + wg.Wait() + if downloadSuccess != itemCount || readerCloseSuccessCount != itemCount || writerCloseSuccessCount != itemCount { + return nil, errors.Errorf( + "Failed to copy %d out of %d remote files from [%s] to local [%s].\n"+ + "Failed to close %d readers\n"+ + "Failed to close %d writers.", + itemCount-downloadSuccess, itemCount, blobRef, toPath, itemCount-readerCloseSuccessCount, itemCount-writerCloseSuccessCount, + ) + } + logger.Infof(ctx, "successfully copied %d remote files from [%s] to local [%s]", downloadSuccess, blobRef, toPath) + return toPath, nil + } else if blob.GetMetadata().GetType().GetDimensionality() == core.BlobType_SINGLE { + // reader should be declared here (avoid being shared across all goroutines) + var reader io.ReadCloser + if scheme == "http" || scheme == "https" { + reader, err = DownloadFileFromHTTP(ctx, blobRef) + } else { + reader, err = DownloadFileFromStorage(ctx, blobRef, d.store) + } + if err != nil { + logger.Errorf(ctx, "Failed to download from ref [%s]", blobRef) + return nil, err + } + defer func() { + err := reader.Close() + if err != nil { + logger.Errorf(ctx, "failed to close Blob read stream @ref [%s]. Error: %s", blobRef, err) + } + }() + + writer, err := os.Create(toPath) + if err != nil { + return nil, errors.Wrapf(err, "failed to open file at path %s", toPath) + } + defer func() { + err := writer.Close() + if err != nil { + logger.Errorf(ctx, "failed to close File write stream. Error: %s", err) + } + }() + v, err := io.Copy(writer, reader) + if err != nil { + return nil, errors.Wrapf(err, "failed to write remote data to local filesystem") + } + logger.Infof(ctx, "Successfully copied [%d] bytes remote data from [%s] to local [%s]", v, blobRef, toPath) + return toPath, nil + } + + return nil, errors.Errorf("unexpected Blob type encountered") +} + +func (d Downloader) handleSchema(ctx context.Context, schema *core.Schema, toFilePath string) (interface{}, error) { + return d.handleBlob(ctx, &core.Blob{Uri: schema.GetUri(), Metadata: &core.BlobMetadata{Type: &core.BlobType{Dimensionality: core.BlobType_MULTIPART}}}, toFilePath) +} + +func (d Downloader) handleBinary(_ context.Context, b *core.Binary, toFilePath string, writeToFile bool) (interface{}, error) { + // maybe we should return a map + v := b.GetValue() + if writeToFile { + return v, os.WriteFile(toFilePath, v, os.ModePerm) // #nosec G306 + } + return v, nil +} + +func (d Downloader) handleError(_ context.Context, b *core.Error, toFilePath string, writeToFile bool) (interface{}, error) { + // maybe we should return a map + if writeToFile { + return b.GetMessage(), os.WriteFile(toFilePath, []byte(b.GetMessage()), os.ModePerm) // #nosec G306 + } + return b.GetMessage(), nil +} + +func (d Downloader) handleGeneric(ctx context.Context, b *structpb.Struct, toFilePath string, writeToFile bool) (interface{}, error) { + if writeToFile && b != nil { + m := jsonpb.Marshaler{} + writer, err := os.Create(toFilePath) + if err != nil { + return nil, errors.Wrapf(err, "failed to open file at path %s", toFilePath) + } + defer func() { + err := writer.Close() + if err != nil { + logger.Errorf(ctx, "failed to close File write stream. Error: %s", err) + } + }() + return b, m.Marshal(writer, b) + } + return b, nil +} + +// Returns the primitive value in Golang native format and if the filePath is not empty, then writes the value to the given file path. +func (d Downloader) handlePrimitive(primitive *core.Primitive, toFilePath string, writeToFile bool) (interface{}, error) { + + var toByteArray func() ([]byte, error) + var v interface{} + var err error + + switch primitive.GetValue().(type) { + case *core.Primitive_StringValue: + v = primitive.GetStringValue() + toByteArray = func() ([]byte, error) { + return []byte(primitive.GetStringValue()), nil + } + case *core.Primitive_Boolean: + v = primitive.GetBoolean() + toByteArray = func() ([]byte, error) { + return []byte(strconv.FormatBool(primitive.GetBoolean())), nil + } + case *core.Primitive_Integer: + v = primitive.GetInteger() + toByteArray = func() ([]byte, error) { + return []byte(strconv.FormatInt(primitive.GetInteger(), 10)), nil + } + case *core.Primitive_FloatValue: + v = primitive.GetFloatValue() + toByteArray = func() ([]byte, error) { + return []byte(strconv.FormatFloat(primitive.GetFloatValue(), 'f', -1, 64)), nil + } + case *core.Primitive_Datetime: + v, err = ptypes.Timestamp(primitive.GetDatetime()) + if err != nil { + return nil, err + } + toByteArray = func() ([]byte, error) { + return []byte(ptypes.TimestampString(primitive.GetDatetime())), nil + } + case *core.Primitive_Duration: + v, err := ptypes.Duration(primitive.GetDuration()) + if err != nil { + return nil, err + } + toByteArray = func() ([]byte, error) { + return []byte(v.String()), nil + } + default: + v = nil + toByteArray = func() ([]byte, error) { + return []byte("null"), nil + } + } + if writeToFile { + b, err := toByteArray() + if err != nil { + return nil, err + } + return v, os.WriteFile(toFilePath, b, os.ModePerm) // #nosec G306 + } + return v, nil +} + +func (d Downloader) handleScalar(ctx context.Context, scalar *core.Scalar, toFilePath string, writeToFile bool) (interface{}, *core.Scalar, error) { + switch scalar.GetValue().(type) { + case *core.Scalar_Primitive: + p := scalar.GetPrimitive() + i, err := d.handlePrimitive(p, toFilePath, writeToFile) + return i, scalar, err + case *core.Scalar_Blob: + b := scalar.GetBlob() + i, err := d.handleBlob(ctx, b, toFilePath) + return i, &core.Scalar{Value: &core.Scalar_Blob{Blob: &core.Blob{Metadata: b.GetMetadata(), Uri: toFilePath}}}, err + case *core.Scalar_Schema: + b := scalar.GetSchema() + i, err := d.handleSchema(ctx, b, toFilePath) + return i, &core.Scalar{Value: &core.Scalar_Schema{Schema: &core.Schema{Type: b.GetType(), Uri: toFilePath}}}, err + case *core.Scalar_Binary: + b := scalar.GetBinary() + i, err := d.handleBinary(ctx, b, toFilePath, writeToFile) + return i, scalar, err + case *core.Scalar_Error: + b := scalar.GetError() + i, err := d.handleError(ctx, b, toFilePath, writeToFile) + return i, scalar, err + case *core.Scalar_Generic: + b := scalar.GetGeneric() + i, err := d.handleGeneric(ctx, b, toFilePath, writeToFile) + return i, scalar, err + case *core.Scalar_Union: + b := scalar.GetUnion() + i, lit, err := d.handleLiteral(ctx, b.GetValue(), toFilePath, writeToFile) + return i, &core.Scalar{Value: &core.Scalar_Union{Union: &core.Union{Type: b.GetType(), Value: lit}}}, err + case *core.Scalar_NoneType: + if writeToFile { + return nil, scalar, os.WriteFile(toFilePath, []byte("null"), os.ModePerm) // #nosec G306 + } + return nil, scalar, nil + default: + return nil, nil, fmt.Errorf("unsupported scalar type [%v]", reflect.TypeOf(scalar.GetValue())) + } +} + +func (d Downloader) handleLiteral(ctx context.Context, lit *core.Literal, filePath string, writeToFile bool) (interface{}, *core.Literal, error) { + switch lit.GetValue().(type) { + case *core.Literal_Scalar: + v, s, err := d.handleScalar(ctx, lit.GetScalar(), filePath, writeToFile) + if err != nil { + return nil, nil, err + } + return v, &core.Literal{Value: &core.Literal_Scalar{ + Scalar: s, + }}, nil + case *core.Literal_Collection: + err := os.MkdirAll(filePath, os.ModePerm) + if err != nil { + return nil, nil, errors.Wrapf(err, "failed to create directory [%s]", filePath) + } + v, c2, err := d.handleCollection(ctx, lit.GetCollection(), filePath, writeToFile) + if err != nil { + return nil, nil, err + } + return v, &core.Literal{Value: &core.Literal_Collection{ + Collection: c2, + }}, nil + case *core.Literal_Map: + err := os.MkdirAll(filePath, os.ModePerm) + if err != nil { + return nil, nil, errors.Wrapf(err, "failed to create directory [%s]", filePath) + } + v, m, err := d.RecursiveDownload(ctx, lit.GetMap(), filePath, writeToFile) + if err != nil { + return nil, nil, err + } + return v, &core.Literal{Value: &core.Literal_Map{ + Map: m, + }}, nil + default: + return nil, nil, fmt.Errorf("unsupported literal type [%v]", reflect.TypeOf(lit.GetValue())) + } +} + +// Collection should be stored as a top level list file and may have accompanying files? +func (d Downloader) handleCollection(ctx context.Context, c *core.LiteralCollection, dir string, writePrimitiveToFile bool) ([]interface{}, *core.LiteralCollection, error) { + if c == nil || len(c.GetLiterals()) == 0 { + return []interface{}{}, c, nil + } + var collection []interface{} + litCollection := &core.LiteralCollection{} + for i, lit := range c.GetLiterals() { + filePath := path.Join(dir, strconv.Itoa(i)) + v, lit, err := d.handleLiteral(ctx, lit, filePath, writePrimitiveToFile) + if err != nil { + return nil, nil, err + } + collection = append(collection, v) + litCollection.Literals = append(litCollection.Literals, lit) + } + return collection, litCollection, nil +} + +type downloadedResult struct { + lit *core.Literal + v interface{} +} + +func (d Downloader) RecursiveDownload(ctx context.Context, inputs *core.LiteralMap, dir string, writePrimitiveToFile bool) (VarMap, *core.LiteralMap, error) { + childCtx, cancel := context.WithCancel(ctx) + defer cancel() + if inputs == nil || len(inputs.GetLiterals()) == 0 { + return VarMap{}, nil, nil + } + f := make(FutureMap, len(inputs.GetLiterals())) + for variable, literal := range inputs.GetLiterals() { + if literal.GetOffloadedMetadata() != nil { + offloadedMetadataURI := literal.GetOffloadedMetadata().GetUri() + // literal will be overwritten with the contents of the offloaded data which contains the actual large literal. + if err := d.store.ReadProtobuf(ctx, storage.DataReference(offloadedMetadataURI), literal); err != nil { + errString := fmt.Sprintf("Failed to read the object at location [%s] with error [%s]", offloadedMetadataURI, err) + logger.Error(ctx, errString) + return nil, nil, fmt.Errorf("%s", errString) + } + logger.Infof(ctx, "read object at location [%s]", offloadedMetadataURI) + } + varPath := path.Join(dir, variable) + lit := literal + f[variable] = futures.NewAsyncFuture(childCtx, func(ctx2 context.Context) (interface{}, error) { + v, lit, err := d.handleLiteral(ctx2, lit, varPath, writePrimitiveToFile) + if err != nil { + return nil, err + } + return downloadedResult{lit: lit, v: v}, nil + }) + } + + m := &core.LiteralMap{ + Literals: make(map[string]*core.Literal), + } + vmap := make(VarMap, len(f)) + for variable, future := range f { + logger.Infof(ctx, "Waiting for [%s] to be persisted", variable) + v, err := future.Get(childCtx) + if err != nil { + logger.Errorf(ctx, "Failed to persist [%s], err %s", variable, err) + if err == futures.ErrAsyncFutureCanceled { + logger.Errorf(ctx, "Future was canceled, possibly Timeout!") + } + return nil, nil, errors.Wrapf(err, "variable [%s] download/store failed", variable) + } + dr := v.(downloadedResult) + vmap[variable] = dr.v + m.Literals[variable] = dr.lit + logger.Infof(ctx, "Completed persisting [%s]", variable) + } + + return vmap, m, nil +} + +func (d Downloader) DownloadInputs(ctx context.Context, inputRef storage.DataReference, outputDir string) error { + logger.Infof(ctx, "Downloading inputs from [%s]", inputRef) + defer logger.Infof(ctx, "Exited downloading inputs from [%s]", inputRef) + if err := os.MkdirAll(outputDir, os.ModePerm); err != nil { + logger.Errorf(ctx, "Failed to create output directories, err: %s", err) + return err + } + inputs := &core.LiteralMap{} + err := d.store.ReadProtobuf(ctx, inputRef, inputs) + if err != nil { + logger.Errorf(ctx, "Failed to download inputs from [%s], err [%s]", inputRef, err) + return errors.Wrapf(err, "failed to download input metadata message from remote store") + } + varMap, lMap, err := d.RecursiveDownload(ctx, inputs, outputDir, true) + if err != nil { + return errors.Wrapf(err, "failed to download input variable from remote store") + } + + // We will always write the protobuf + b, err := proto.Marshal(lMap) + if err != nil { + return err + } + // #nosec G306 + if err := os.WriteFile(path.Join(outputDir, "inputs.pb"), b, os.ModePerm); err != nil { + return err + } + + if d.format == core.DataLoadingConfig_JSON { + m, err := json.Marshal(varMap) + if err != nil { + return errors.Wrapf(err, "failed to marshal out inputs") + } + return os.WriteFile(path.Join(outputDir, "inputs.json"), m, os.ModePerm) // #nosec G306 + } + if d.format == core.DataLoadingConfig_YAML { + m, err := yaml.Marshal(varMap) + if err != nil { + return errors.Wrapf(err, "failed to marshal out inputs") + } + return os.WriteFile(path.Join(outputDir, "inputs.yaml"), m, os.ModePerm) // #nosec G306 + } + return nil +} + +func NewDownloader(_ context.Context, store *storage.DataStore, format core.DataLoadingConfig_LiteralMapFormat, mode core.IOStrategy_DownloadMode) Downloader { + return Downloader{ + format: format, + store: store, + mode: mode, + } +} diff --git a/flytecopilot/data/download_test.go b/flytecopilot/data/download_test.go new file mode 100644 index 0000000000..2fb23847f6 --- /dev/null +++ b/flytecopilot/data/download_test.go @@ -0,0 +1,413 @@ +package data + +import ( + "bytes" + "context" + "os" + "path/filepath" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestHandleBlobMultipart(t *testing.T) { + t.Run("Successful Query", func(t *testing.T) { + s, err := storage.NewDataStore(&storage.Config{Type: storage.TypeMemory}, promutils.NewTestScope()) + assert.NoError(t, err) + + // Create one file at root level and another in a nested folder + ref1 := storage.DataReference("s3://container/oz/a9ss8w4mnkk8zttr9p7z-n0-0/0fda6abb7c/root_file.txt") + err = s.WriteRaw(context.Background(), ref1, 0, storage.Options{}, bytes.NewReader([]byte("root content"))) + assert.NoError(t, err) + + ref2 := storage.DataReference("s3://container/oz/a9ss8w4mnkk8zttr9p7z-n0-0/0fda6abb7c/nested/deep_file.txt") + err = s.WriteRaw(context.Background(), ref2, 0, storage.Options{}, bytes.NewReader([]byte("nested content"))) + assert.NoError(t, err) + + d := Downloader{store: s} + + blob := &core.Blob{ + Uri: "s3://container/oz/a9ss8w4mnkk8zttr9p7z-n0-0/0fda6abb7c", + Metadata: &core.BlobMetadata{ + Type: &core.BlobType{ + Dimensionality: core.BlobType_MULTIPART, + }, + }, + } + + // Create temporary directory with inputs/my_var structure + tmpDir, err := os.MkdirTemp("", "blob_test") + assert.NoError(t, err) + testPath := filepath.Join(tmpDir, "inputs", "my_var") + defer func() { + err := os.RemoveAll(tmpDir) + if err != nil { + t.Errorf("Failed to delete directory: %v", err) + } + }() + + result, err := d.handleBlob(context.Background(), blob, testPath) + assert.NoError(t, err) + assert.Equal(t, testPath, result) + + // Check if files were created and data written + // With the new fix, files should be directly under testPath, not in a "folder" subdirectory + expectedFiles := []string{ + filepath.Join(testPath, "root_file.txt"), + filepath.Join(testPath, "nested", "deep_file.txt"), + } + + for _, expectedFile := range expectedFiles { + if _, err := os.Stat(expectedFile); os.IsNotExist(err) { + t.Errorf("expected file %s to exist", expectedFile) + } + } + }) + + t.Run("No Items", func(t *testing.T) { + s, err := storage.NewDataStore(&storage.Config{Type: storage.TypeMemory}, promutils.NewTestScope()) + assert.NoError(t, err) + + d := Downloader{store: s} + + blob := &core.Blob{ + Uri: "s3://container/folder", + Metadata: &core.BlobMetadata{ + Type: &core.BlobType{ + Dimensionality: core.BlobType_MULTIPART, + }, + }, + } + + toPath := "./inputs" + defer func() { + err := os.RemoveAll(toPath) + if err != nil { + t.Errorf("Failed to delete directory: %v", err) + } + }() + + result, err := d.handleBlob(context.Background(), blob, toPath) + assert.Error(t, err) + assert.Nil(t, result) + }) +} + +func TestHandleBlobSinglePart(t *testing.T) { + s, err := storage.NewDataStore(&storage.Config{Type: storage.TypeMemory}, promutils.NewTestScope()) + assert.NoError(t, err) + ref := storage.DataReference("s3://container/file") + err = s.WriteRaw(context.Background(), ref, 0, storage.Options{}, bytes.NewReader([]byte{})) + assert.NoError(t, err) + + d := Downloader{store: s} + + blob := &core.Blob{ + Uri: "s3://container/file", + Metadata: &core.BlobMetadata{ + Type: &core.BlobType{ + Dimensionality: core.BlobType_SINGLE, + }, + }, + } + + toPath := "./input" + defer func() { + err := os.RemoveAll(toPath) + if err != nil { + t.Errorf("Failed to delete file: %v", err) + } + }() + + result, err := d.handleBlob(context.Background(), blob, toPath) + assert.NoError(t, err) + assert.Equal(t, toPath, result) + + // Check if files were created and data written + if _, err := os.Stat(toPath); os.IsNotExist(err) { + t.Errorf("expected file %s to exist", toPath) + } +} + +func TestHandleBlobHTTP(t *testing.T) { + s, err := storage.NewDataStore(&storage.Config{Type: storage.TypeMemory}, promutils.NewTestScope()) + assert.NoError(t, err) + d := Downloader{store: s} + + blob := &core.Blob{ + Uri: "https://raw.githubusercontent.com/flyteorg/flyte/master/README.md", + Metadata: &core.BlobMetadata{ + Type: &core.BlobType{ + Dimensionality: core.BlobType_SINGLE, + }, + }, + } + + toPath := "./input" + defer func() { + err := os.RemoveAll(toPath) + if err != nil { + t.Errorf("Failed to delete file: %v", err) + } + }() + + result, err := d.handleBlob(context.Background(), blob, toPath) + assert.NoError(t, err) + assert.Equal(t, toPath, result) + + // Check if files were created and data written + if _, err := os.Stat(toPath); os.IsNotExist(err) { + t.Errorf("expected file %s to exist", toPath) + } +} + +func TestRecursiveDownload(t *testing.T) { + t.Run("OffloadedMetadataContainsCollectionOfStrings", func(t *testing.T) { + s, err := storage.NewDataStore(&storage.Config{Type: storage.TypeMemory}, promutils.NewTestScope()) + assert.NoError(t, err) + + d := Downloader{store: s} + + offloadedLiteral := &core.Literal{ + Value: &core.Literal_OffloadedMetadata{ + OffloadedMetadata: &core.LiteralOffloadedMetadata{ + Uri: "s3://container/offloaded", + }, + }, + } + + inputs := &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "input1": offloadedLiteral, + }, + } + + // Mock reading the offloaded metadata + err = s.WriteProtobuf(context.Background(), storage.DataReference("s3://container/offloaded"), storage.Options{}, &core.Literal{ + Value: &core.Literal_Collection{ + Collection: &core.LiteralCollection{ + Literals: []*core.Literal{ + { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{ + Primitive: &core.Primitive{ + Value: &core.Primitive_StringValue{ + StringValue: "string1", + }, + }, + }, + }, + }, + }, + { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{ + Primitive: &core.Primitive{ + Value: &core.Primitive_StringValue{ + StringValue: "string2", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }) + assert.NoError(t, err) + + toPath := "./inputs" + defer func() { + err := os.RemoveAll(toPath) + if err != nil { + t.Errorf("Failed to delete directory: %v", err) + } + }() + + varMap, lMap, err := d.RecursiveDownload(context.Background(), inputs, toPath, true) + assert.NoError(t, err) + assert.NotNil(t, varMap) + assert.NotNil(t, lMap) + assert.Equal(t, []interface{}{"string1", "string2"}, varMap["input1"]) + // Check if files were created and data written + for _, file := range []string{"0", "1"} { + if _, err := os.Stat(filepath.Join(toPath, "input1", file)); os.IsNotExist(err) { + t.Errorf("expected file %s to exist", file) + } + } + }) + + t.Run("OffloadedMetadataContainsMapOfStringString", func(t *testing.T) { + s, err := storage.NewDataStore(&storage.Config{Type: storage.TypeMemory}, promutils.NewTestScope()) + assert.NoError(t, err) + + d := Downloader{store: s} + + offloadedLiteral := &core.Literal{ + Value: &core.Literal_OffloadedMetadata{ + OffloadedMetadata: &core.LiteralOffloadedMetadata{ + Uri: "s3://container/offloaded", + }, + }, + } + + inputs := &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "input1": offloadedLiteral, + }, + } + + // Mock reading the offloaded metadata + err = s.WriteProtobuf(context.Background(), storage.DataReference("s3://container/offloaded"), storage.Options{}, &core.Literal{ + Value: &core.Literal_Map{ + Map: &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "key1": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{ + Primitive: &core.Primitive{ + Value: &core.Primitive_StringValue{ + StringValue: "value1", + }, + }, + }, + }, + }, + }, + "key2": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{ + Primitive: &core.Primitive{ + Value: &core.Primitive_StringValue{ + StringValue: "value2", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }) + assert.NoError(t, err) + + toPath := "./inputs" + defer func() { + err := os.RemoveAll(toPath) + if err != nil { + t.Errorf("Failed to delete directory: %v", err) + } + }() + + varMap, lMap, err := d.RecursiveDownload(context.Background(), inputs, toPath, true) + assert.NoError(t, err) + assert.NotNil(t, varMap) + assert.NotNil(t, lMap) + assert.Equal(t, "value1", varMap["input1"].(VarMap)["key1"]) + assert.Equal(t, "value2", varMap["input1"].(VarMap)["key2"]) + + for _, file := range []string{"key1", "key2"} { + if _, err := os.Stat(filepath.Join(toPath, "input1", file)); os.IsNotExist(err) { + t.Errorf("expected file %s to exist", file) + } + } + }) +} + +func TestHandleScalar(t *testing.T) { + t.Run("Handles Union Scalar with scalar value", func(t *testing.T) { + d := Downloader{} + + scalar := &core.Scalar{ + Value: &core.Scalar_Union{ + Union: &core.Union{ + Value: &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{ + Primitive: &core.Primitive{ + Value: &core.Primitive_StringValue{ + StringValue: "string1", + }, + }, + }, + }, + }, + }, + }, + }, + } + + resultValue, resultScalar, err := d.handleScalar(context.Background(), scalar, "./inputs", false) + assert.NoError(t, err) + assert.Equal(t, "string1", resultValue) + assert.Equal(t, scalar, resultScalar) + }) + t.Run("Handles Union Scalar with collection value", func(t *testing.T) { + d := Downloader{} + + toPath := "./inputs" + defer func() { + err := os.RemoveAll(toPath) + if err != nil { + t.Errorf("Failed to delete directory: %v", err) + } + }() + + scalar := &core.Scalar{ + Value: &core.Scalar_Union{ + Union: &core.Union{ + Value: &core.Literal{ + Value: &core.Literal_Collection{ + Collection: &core.LiteralCollection{ + Literals: []*core.Literal{ + { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{ + Primitive: &core.Primitive{ + Value: &core.Primitive_StringValue{ + StringValue: "string1", + }, + }, + }, + }, + }, + }, + { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{ + Primitive: &core.Primitive{ + Value: &core.Primitive_StringValue{ + StringValue: "string2", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + } + + resultValue, resultScalar, err := d.handleScalar(context.Background(), scalar, toPath, false) + assert.NoError(t, err) + assert.Equal(t, []interface{}{"string1", "string2"}, resultValue) + assert.Equal(t, scalar, resultScalar) + }) +} diff --git a/flytecopilot/data/upload.go b/flytecopilot/data/upload.go new file mode 100644 index 0000000000..417d48dbb6 --- /dev/null +++ b/flytecopilot/data/upload.go @@ -0,0 +1,200 @@ +package data + +import ( + "context" + "fmt" + "io" + "io/ioutil" + "os" + "path" + "path/filepath" + "reflect" + + "github.com/golang/protobuf/proto" + "github.com/pkg/errors" + + "github.com/flyteorg/flyte/v2/flyteidl2/clients/go/coreutils" + "github.com/flyteorg/flyte/v2/flytestdlib/futures" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const maxPrimitiveSize = 1024 + +type Unmarshal func(r io.Reader, msg proto.Message) error +type Uploader struct { + format core.DataLoadingConfig_LiteralMapFormat + mode core.IOStrategy_UploadMode + // TODO support multiple buckets + store *storage.DataStore + aggregateOutputFileName string + errorFileName string +} + +type dirFile struct { + path string + info os.FileInfo + ref storage.DataReference +} + +func (u Uploader) handleSimpleType(_ context.Context, t core.SimpleType, filePath string) (*core.Literal, error) { + fpath, info, err := IsFileReadable(filePath, true) + if err != nil { + return nil, err + } + if info.IsDir() { + return nil, fmt.Errorf("expected file for type [%s], found dir at path [%s]", t.String(), filePath) + } + if info.Size() > maxPrimitiveSize { + return nil, fmt.Errorf("maximum allowed filesize is [%d], but found [%d]", maxPrimitiveSize, info.Size()) + } + b, err := ioutil.ReadFile(fpath) + if err != nil { + return nil, err + } + return coreutils.MakeLiteralForSimpleType(t, string(b)) +} + +func (u Uploader) handleBlobType(ctx context.Context, localPath string, toPath storage.DataReference) (*core.Literal, error) { + fpath, info, err := IsFileReadable(localPath, true) + if err != nil { + return nil, err + } + if info.IsDir() { + var files []dirFile + err := filepath.Walk(localPath, func(path string, info os.FileInfo, err error) error { + if err != nil { + logger.Errorf(ctx, "encountered error when uploading multipart blob, %s", err) + return err + } + if info.IsDir() { + logger.Warnf(ctx, "Currently nested directories are not supported in multipart blob uploads, for directory @ %s", path) + } else { + ref, err := u.store.ConstructReference(ctx, toPath, info.Name()) + if err != nil { + return err + } + files = append(files, dirFile{ + path: path, + info: info, + ref: ref, + }) + } + return nil + }) + if err != nil { + return nil, err + } + + childCtx, cancel := context.WithCancel(ctx) + defer cancel() + fileUploader := make([]futures.Future, 0, len(files)) + for _, f := range files { + pth := f.path + ref := f.ref + size := f.info.Size() + fileUploader = append(fileUploader, futures.NewAsyncFuture(childCtx, func(i2 context.Context) (i interface{}, e error) { + return nil, UploadFileToStorage(i2, pth, ref, size, u.store) + })) + } + + for _, f := range fileUploader { + // TODO maybe we should have timeouts, or we can have a global timeout at the top level + _, err := f.Get(ctx) + if err != nil { + return nil, err + } + } + + return coreutils.MakeLiteralForBlob(toPath, false, ""), nil + } + size := info.Size() + // Should we make this a go routine as well, so that we can introduce timeouts + return coreutils.MakeLiteralForBlob(toPath, false, ""), UploadFileToStorage(ctx, fpath, toPath, size, u.store) +} + +func (u Uploader) RecursiveUpload(ctx context.Context, vars *core.VariableMap, fromPath string, metaOutputPath, dataRawPath storage.DataReference) error { + childCtx, cancel := context.WithCancel(ctx) + defer cancel() + + errFile := path.Join(fromPath, u.errorFileName) + if info, err := os.Stat(errFile); err != nil { + if !os.IsNotExist(err) { + return err + } + } else if info.Size() > 1024*1024 { + return fmt.Errorf("error file too large %d", info.Size()) + } else if info.IsDir() { + return fmt.Errorf("error file is a directory") + } else { + b, err := ioutil.ReadFile(errFile) + if err != nil { + return err + } + return errors.Errorf("User Error: %s", string(b)) + } + + varFutures := make(map[string]futures.Future, len(vars.GetVariables())) + for varName, variable := range vars.GetVariables() { + varPath := path.Join(fromPath, varName) + varType := variable.GetType() + switch varType.GetType().(type) { + case *core.LiteralType_Blob: + var varOutputPath storage.DataReference + var err error + if varName == u.aggregateOutputFileName { + varOutputPath, err = u.store.ConstructReference(ctx, dataRawPath, "_"+varName) + } else { + varOutputPath, err = u.store.ConstructReference(ctx, dataRawPath, varName) + } + if err != nil { + return err + } + varFutures[varName] = futures.NewAsyncFuture(childCtx, func(ctx2 context.Context) (interface{}, error) { + return u.handleBlobType(ctx2, varPath, varOutputPath) + }) + case *core.LiteralType_Simple: + varFutures[varName] = futures.NewAsyncFuture(childCtx, func(ctx2 context.Context) (interface{}, error) { + return u.handleSimpleType(ctx2, varType.GetSimple(), varPath) + }) + default: + return fmt.Errorf("currently CoPilot uploader does not support [%s], system error", varType) + } + } + + outputs := &core.LiteralMap{ + Literals: make(map[string]*core.Literal, len(varFutures)), + } + for k, f := range varFutures { + logger.Infof(ctx, "Waiting for [%s] to complete (it may have a background upload too)", k) + v, err := f.Get(ctx) + if err != nil { + logger.Errorf(ctx, "Failed to upload [%s], reason [%s]", k, err) + return err + } + l, ok := v.(*core.Literal) + if !ok { + return fmt.Errorf("IllegalState, expected core.Literal, received [%s]", reflect.TypeOf(v)) + } + outputs.Literals[k] = l + logger.Infof(ctx, "Var [%s] completed", k) + } + + logger.Infof(ctx, "Uploading final outputs to [%s]", metaOutputPath) + if err := u.store.WriteProtobuf(ctx, metaOutputPath, storage.Options{}, outputs); err != nil { + logger.Errorf(ctx, "Failed to upload final outputs file to [%s], err [%s]", metaOutputPath, err) + return err + } + logger.Infof(ctx, "Uploaded final outputs to [%s]", metaOutputPath) + return nil +} + +func NewUploader(_ context.Context, store *storage.DataStore, format core.DataLoadingConfig_LiteralMapFormat, mode core.IOStrategy_UploadMode, errorFileName string) Uploader { + return Uploader{ + format: format, + store: store, + errorFileName: errorFileName, + mode: mode, + } +} diff --git a/flytecopilot/data/upload_test.go b/flytecopilot/data/upload_test.go new file mode 100644 index 0000000000..99146fffdb --- /dev/null +++ b/flytecopilot/data/upload_test.go @@ -0,0 +1,64 @@ +package data + +import ( + "context" + "fmt" + "io" + "os" + "path" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestUploader_RecursiveUpload(t *testing.T) { + + tmpFolderLocation := "" + tmpPrefix := "upload_test" + + t.Run("upload-blob", func(t *testing.T) { + tmpDir, err := os.MkdirTemp(tmpFolderLocation, tmpPrefix) + assert.NoError(t, err) + defer func() { + assert.NoError(t, os.RemoveAll(tmpDir)) + }() + + vmap := &core.VariableMap{ + Variables: map[string]*core.Variable{ + "x": { + Type: &core.LiteralType{Type: &core.LiteralType_Blob{Blob: &core.BlobType{Dimensionality: core.BlobType_SINGLE}}}, + }, + }, + } + + data := []byte("data") + assert.NoError(t, os.WriteFile(path.Join(tmpDir, "x"), data, os.ModePerm)) // #nosec G306 + fmt.Printf("Written to %s ", path.Join(tmpDir, "x")) + + store, err := storage.NewDataStore(&storage.Config{Type: storage.TypeMemory}, promutils.NewTestScope()) + assert.NoError(t, err) + + outputRef := storage.DataReference("output") + rawRef := storage.DataReference("raw") + u := NewUploader(context.TODO(), store, core.DataLoadingConfig_JSON, core.IOStrategy_UPLOAD_ON_EXIT, "error") + assert.NoError(t, u.RecursiveUpload(context.TODO(), vmap, tmpDir, outputRef, rawRef)) + + outputs := &core.LiteralMap{} + assert.NoError(t, store.ReadProtobuf(context.TODO(), outputRef, outputs)) + assert.Len(t, outputs.GetLiterals(), 1) + assert.NotNil(t, outputs.GetLiterals()["x"]) + assert.NotNil(t, outputs.GetLiterals()["x"].GetScalar()) + assert.NotNil(t, outputs.GetLiterals()["x"].GetScalar().GetBlob()) + ref := storage.DataReference(outputs.GetLiterals()["x"].GetScalar().GetBlob().GetUri()) + r, err := store.ReadRaw(context.TODO(), ref) + assert.NoError(t, err, "%s does not exist", ref) + defer r.Close() + b, err := io.ReadAll(r) + assert.NoError(t, err) + assert.Equal(t, string(data), string(b), "content dont match") + }) +} diff --git a/flytecopilot/data/utils.go b/flytecopilot/data/utils.go new file mode 100644 index 0000000000..494c643bf0 --- /dev/null +++ b/flytecopilot/data/utils.go @@ -0,0 +1,91 @@ +package data + +import ( + "context" + "fmt" + "io" + "net/http" + "os" + "path/filepath" + + "github.com/pkg/errors" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + +// Checks if the given filepath is a valid and existing file path. If ignoreExtension is true, then the dir + basepath is checked for existence +// ignoring the extension. +// In the return the first return value is the actual path that exists (with the extension), second argument is the file info and finally the error +func IsFileReadable(fpath string, ignoreExtension bool) (string, os.FileInfo, error) { + info, err := os.Stat(fpath) + if err != nil { + if os.IsNotExist(err) { + if ignoreExtension { + logger.Infof(context.TODO(), "looking for any extensions") + matches, err := filepath.Glob(fpath + ".*") + if err == nil && len(matches) == 1 { + logger.Infof(context.TODO(), "Extension match found [%s]", matches[0]) + info, err = os.Stat(matches[0]) + if err == nil { + return matches[0], info, nil + } + } else { + logger.Errorf(context.TODO(), "Extension match not found [%v,%v]", err, matches) + } + } + return "", nil, errors.Wrapf(err, "file not found at path [%s]", fpath) + } + if os.IsPermission(err) { + return "", nil, errors.Wrapf(err, "unable to read file [%s], Flyte does not have permissions", fpath) + } + return "", nil, errors.Wrapf(err, "failed to read file") + } + return fpath, info, nil +} + +// Uploads a file to the data store. +func UploadFileToStorage(ctx context.Context, filePath string, toPath storage.DataReference, size int64, store *storage.DataStore) error { + f, err := os.Open(filePath) + if err != nil { + return err + } + defer func() { + err := f.Close() + if err != nil { + logger.Errorf(ctx, "failed to close blob file at path [%s]", filePath) + } + }() + return store.WriteRaw(ctx, toPath, size, storage.Options{}, f) +} + +func DownloadFileFromStorage(ctx context.Context, ref storage.DataReference, store *storage.DataStore) (io.ReadCloser, error) { + // We should probably directly use stow!?? + m, err := store.Head(ctx, ref) + if err != nil { + return nil, errors.Wrapf(err, "failed when looking up Blob") + } + if m.Exists() { + r, err := store.ReadRaw(ctx, ref) + if err != nil { + return nil, errors.Wrapf(err, "failed to read Blob from storage") + } + return r, err + + } + return nil, fmt.Errorf("incorrect blob reference, does not exist") +} + +// Downloads data from the given HTTP URL. If context is canceled then the request will be canceled. +func DownloadFileFromHTTP(ctx context.Context, ref storage.DataReference) (io.ReadCloser, error) { + req, err := http.NewRequestWithContext(ctx, http.MethodGet, ref.String(), nil) + if err != nil { + logger.Errorf(ctx, "failed to create new http request with context, %s", err) + return nil, err + } + resp, err := http.DefaultClient.Do(req) + if err != nil { + return nil, errors.Wrapf(err, "Failed to download from url :%s", ref) + } + return resp.Body, nil +} diff --git a/flytecopilot/data/utils_test.go b/flytecopilot/data/utils_test.go new file mode 100644 index 0000000000..5bf093d5cf --- /dev/null +++ b/flytecopilot/data/utils_test.go @@ -0,0 +1,119 @@ +package data + +import ( + "bytes" + "context" + "os" + "path" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils/labeled" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + +func TestIsFileReadable(t *testing.T) { + tmpFolderLocation := "" + tmpPrefix := "util_test" + + tmpDir, err := os.MkdirTemp(tmpFolderLocation, tmpPrefix) + assert.NoError(t, err) + defer func() { + assert.NoError(t, os.RemoveAll(tmpDir)) + }() + p := path.Join(tmpDir, "x") + f, i, err := IsFileReadable(p, false) + assert.Error(t, err) + assert.Empty(t, f) + assert.Nil(t, i) + + assert.NoError(t, os.WriteFile(p, []byte("data"), os.ModePerm)) // #nosec G306 + f, i, err = IsFileReadable(p, false) + assert.NoError(t, err) + assert.Equal(t, p, f) + assert.NotNil(t, i) + assert.Equal(t, p, f) + + noExt := path.Join(tmpDir, "y") + p = path.Join(tmpDir, "y.png") + _, _, err = IsFileReadable(noExt, false) + assert.Error(t, err) + + assert.NoError(t, os.WriteFile(p, []byte("data"), os.ModePerm)) // #nosec G306 + _, _, err = IsFileReadable(noExt, false) + assert.Error(t, err) + + f, i, err = IsFileReadable(noExt, true) + assert.NoError(t, err) + assert.Equal(t, p, f) + assert.NotNil(t, i) + assert.Equal(t, p, f) +} + +func TestUploadFile(t *testing.T) { + tmpFolderLocation := "" + tmpPrefix := "util_test" + + tmpDir, err := os.MkdirTemp(tmpFolderLocation, tmpPrefix) + assert.NoError(t, err) + defer func() { + assert.NoError(t, os.RemoveAll(tmpDir)) + }() + + exist := path.Join(tmpDir, "exist-file") + data := []byte("data") + l := int64(len(data)) + assert.NoError(t, os.WriteFile(exist, data, os.ModePerm)) // #nosec G306 + nonExist := path.Join(tmpDir, "non-exist-file") + + store, err := storage.NewDataStore(&storage.Config{Type: storage.TypeMemory}, promutils.NewTestScope()) + assert.NoError(t, err) + + ctx := context.TODO() + assert.NoError(t, UploadFileToStorage(ctx, exist, "exist", l, store)) + m, err := store.Head(ctx, "exist") + assert.True(t, m.Exists()) + assert.NoError(t, err) + + assert.Error(t, UploadFileToStorage(ctx, nonExist, "nonExist", l, store)) +} + +func TestDownloadFromHttp(t *testing.T) { + loc := storage.DataReference("https://raw.githubusercontent.com/flyteorg/flyte/master/README.md") + badLoc := storage.DataReference("https://no-exist") + f, err := DownloadFileFromHTTP(context.TODO(), loc) + if assert.NoError(t, err) { + if assert.NotNil(t, f) { + f.Close() + } + } + + _, err = DownloadFileFromHTTP(context.TODO(), badLoc) + assert.Error(t, err) +} + +func TestDownloadFromStorage(t *testing.T) { + store, err := storage.NewDataStore(&storage.Config{Type: storage.TypeMemory}, promutils.NewTestScope()) + assert.NoError(t, err) + ref := storage.DataReference("ref") + + f, err := DownloadFileFromStorage(context.TODO(), ref, store) + assert.Error(t, err) + assert.Nil(t, f) + + data := []byte("data") + l := int64(len(data)) + + assert.NoError(t, store.WriteRaw(context.TODO(), ref, l, storage.Options{}, bytes.NewReader(data))) + f, err = DownloadFileFromStorage(context.TODO(), ref, store) + if assert.NoError(t, err) { + assert.NotNil(t, f) + f.Close() + } +} + +func init() { + labeled.SetMetricKeys("test") +} diff --git a/flytecopilot/main.go b/flytecopilot/main.go new file mode 100644 index 0000000000..5095b5771a --- /dev/null +++ b/flytecopilot/main.go @@ -0,0 +1,16 @@ +package main + +import ( + "fmt" + "os" + + "github.com/flyteorg/flyte/v2/flytecopilot/cmd" +) + +func main() { + rootCmd := cmd.NewDataCommand() + if err := rootCmd.Execute(); err != nil { + fmt.Println(err) + os.Exit(1) + } +} diff --git a/flyteidl2/app/app_definition.proto b/flyteidl2/app/app_definition.proto new file mode 100644 index 0000000000..0e21023a08 --- /dev/null +++ b/flyteidl2/app/app_definition.proto @@ -0,0 +1,444 @@ +syntax = "proto3"; + +package flyteidl2.app; + +import "buf/validate/validate.proto"; +import "flyteidl2/common/identity.proto"; +import "flyteidl2/common/runtime_version.proto"; +import "flyteidl2/core/artifact_id.proto"; +import "flyteidl2/core/security.proto"; +import "flyteidl2/core/tasks.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app"; + +message Identifier { + // Org that the app belongs to. + string org = 1; + + // Project that the app belongs to. + string project = 2 [(buf.validate.field).string.min_len = 1]; + + // Domain that the app belongs to. + string domain = 3 [(buf.validate.field).string.min_len = 1]; + + // Name that the user provided for the app. + string name = 4 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 30, + // Validate that the string is a valid DNS-1123 subdomain. This validation runs after + // the length validation, so it's safe to assume that the length is within the limits. + (buf.validate.field).string.pattern = "^[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?$" + ]; +} + +message Meta { + // ID of the app. + Identifier id = 1 [(buf.validate.field).required = true]; + + // Revision of the app object. + uint64 revision = 2 [(buf.validate.field).uint64.gte = 0]; + + // Labels for the app. + map labels = 3; +} + +// For internal usage only. This message is used to wrap the app message with the host. +message AppWrapper { + string host = 1; + oneof payload { + App app = 2; + Identifier app_id = 3; + } +} + +// Represents an app with its specification and status. +message App { + // Metadata of the app. + Meta metadata = 1 [(buf.validate.field).required = true]; + + // Specification of the app. + Spec spec = 2 [(buf.validate.field).required = true]; + + // Status of the app. + Status status = 3; +} + +/* State machine for the app status + + โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” + โ”‚ โ”‚ + โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ–บ Unassigned โ”‚ + โ”‚ โ”‚ โ”‚ + โ”‚ โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”ฌโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ + โ”‚Lease โ”‚ + โ”‚Expired โ”‚ Leased to a cluster + โ”‚ โ”‚ + โ”‚ โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ–ผโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” + โ”‚ โ”‚ Assigned โ”‚ + โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”ผ + โ”‚ + โ”‚ Timeout โ”‚ + โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”ฌโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ + โ”‚ + โ”‚ Acknowledged by cluster + โ”‚ + โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ–ผโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” + โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ–บ Pending โ”‚ + โ”‚ โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”ฌโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ + โ”‚New โ”‚ + โ”‚Revision โ”‚ Action performed by cluster + โ”‚ โ”‚ + โ”‚ โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ–ผโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” + โ””โ”€โ”€โ”€โ”€โ”€โ”ผ Stopped/Started/Failed โ”‚ + โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ +*/ + +// Represents the condition of an app. +message Condition { + // Last transition time of the condition. + google.protobuf.Timestamp last_transition_time = 1; + + // Deployment status of the app. + Status.DeploymentStatus deployment_status = 2; + + // Message for the condition. + string message = 3; + + // Revision the Condition applies to. This can be used by consumers + // to introspect and visualize which revisions are up. + uint64 revision = 4 [(buf.validate.field).uint64.gte = 0]; + + // Actor is the principal that caused the condition. + common.EnrichedIdentity actor = 5; +} + +// Represents the status of an app. +message Status { + string assigned_cluster = 1; + + // Enum for deployment status of the app. + enum DeploymentStatus { + // Unspecified deployment status. + DEPLOYMENT_STATUS_UNSPECIFIED = 0; + // Deployment is enabled but hasn't been assigned to a cluster yet. + DEPLOYMENT_STATUS_UNASSIGNED = 1; + // Deployment is assigned to a cluster but hasn't been acknowledged yet. + DEPLOYMENT_STATUS_ASSIGNED = 2; + // Deployment is picked up by a cluster but is awaiting deployment. + DEPLOYMENT_STATUS_PENDING = 3; + // Deployment is disabled. + DEPLOYMENT_STATUS_STOPPED = 4; + // Deployment is completed. Please use DEPLOYMENT_STATUS_ACTIVE instead. + DEPLOYMENT_STATUS_STARTED = 5 [deprecated = true]; + // Deployment has failed. + DEPLOYMENT_STATUS_FAILED = 6; + // Deployment is completed. + DEPLOYMENT_STATUS_ACTIVE = 7; + // Triggered in response to desired app replicas > actual app replicas + DEPLOYMENT_STATUS_SCALING_UP = 8; + // Triggered in response to desired app replicas < actual app replicas + DEPLOYMENT_STATUS_SCALING_DOWN = 9; + // Triggered in response to the latest app spec changing + DEPLOYMENT_STATUS_DEPLOYING = 10; + } + + // Current number of replicas. + uint32 current_replicas = 2 [(buf.validate.field).uint32.gte = 0]; + + // List of public URLs for the app. + Ingress ingress = 3; + + // CreatedAt is the time when the app was first created + google.protobuf.Timestamp created_at = 4; + + // LastUpdatedAt is the time when the app was last updated + google.protobuf.Timestamp last_updated_at = 5; + + // Conditions for the app. + repeated Condition conditions = 6; + + // LeaseExpiration refers to how long the app is leased to a cluster for it to start processing it. If the lease + // period expires, the cluster will no longer be allowed to update this app and another cluster can pick it up. + google.protobuf.Timestamp lease_expiration = 7; + + // K8sMetadata contains metadata about the app in the K8s cluster. + K8sMetadata k8s_metadata = 8; + + MaterializedInputs materialized_inputs = 9; +} + +message K8sMetadata { + // Namespace points to the namespace the app is deployed in. + string namespace = 1; +} + +message Ingress { + // Public URL of the app. + string public_url = 1 [ + (buf.validate.field).ignore = IGNORE_IF_ZERO_VALUE, + (buf.validate.field).string.uri = true + ]; + + // Canonical name (CNAME) URL of the app. + string cname_url = 2 [ + (buf.validate.field).ignore = IGNORE_IF_ZERO_VALUE, + (buf.validate.field).string.uri = true + ]; + + // VPC URL of the app. + string vpc_url = 3 [ + (buf.validate.field).ignore = IGNORE_IF_ZERO_VALUE, + (buf.validate.field).string.uri = true + ]; +} + +// Represents the specification of an app. +message Spec { + // Payload of the app, which can be either a container or a K8s pod. + oneof app_payload { + option (buf.validate.oneof).required = true; + + // Container payload. + flyteidl2.core.Container container = 1; + + // K8s pod payload. + flyteidl2.core.K8sPod pod = 2; + } + + // Autoscaling configuration for the app. + AutoscalingConfig autoscaling = 3; + + // Ingress configuration for the app. + IngressConfig ingress = 4; + + // Enum for deployment status of the app. + enum DesiredState { + // Unspecified state + DESIRED_STATE_UNSPECIFIED = 0; + // Deployment is disabled. + DESIRED_STATE_STOPPED = 1; + // Deployment is completed. Please use DESIRED_STATE_ACTIVE instead. + DESIRED_STATE_STARTED = 2 [deprecated = true]; + // Deployment is completed. + DESIRED_STATE_ACTIVE = 3; + } + + // Deployment status of the app. + DesiredState desired_state = 5; + + // ClusterPool to place this app on. By default it'll use the default cluster pool. + string cluster_pool = 6; + + // Set of image specifications for the app. + ImageSpecSet images = 7; + + // security_context encapsulates security attributes requested to run this task. + SecurityContext security_context = 8; + + // Encapsulates all non-standard resources, not captured by + // v1.ResourceRequirements, to allocate to a task. + flyteidl2.core.ExtendedResources extended_resources = 9; + + // Runtime metadata for the app. + common.RuntimeMetadata runtime_metadata = 10; + + // Profile of the app. + Profile profile = 11; + + // Creator of the app is the first principal that provisioned this app. Other principals may + // interact with the app by updating its spec or stopping/starting it. + common.EnrichedIdentity creator = 12; + + // Inputs of the app. + InputList inputs = 13; + + repeated Link links = 14; + + // Timeout configuration for the app. + TimeoutConfig timeouts = 15; +} + +// Represents a link to an external resource (Arize project link, W&B dashboard, etc) +message Link { + // URL of the external service. + // This can be an absolute or relative path. + string path = 1 [(buf.validate.field).string.min_len = 1]; + + // Human readable name of the external service. + string title = 2; + + // Whether the path is absolute (default) or relative. + bool is_relative = 3; +} + +message Input { + // Name is a unique identifier of the input within the list of inputs of the app + string name = 1 [(buf.validate.field).string.min_len = 1]; + + oneof value { + option (buf.validate.oneof).required = true; + + // StringValue is a plain string value for the input + string string_value = 2 [(buf.validate.field).string.min_len = 1]; + + // ArtifactQuery is that should result in a single artifact that will be used as the input to the app at runtime. + // The artifact will be pinned at the time of the app creation. + flyteidl2.core.ArtifactQuery artifact_query = 3; + + // ArtifactId is an identifier of an artifact that will be used as the input to the app at runtime. + flyteidl2.core.ArtifactID artifact_id = 4; + + // ID of the app. + Identifier app_id = 5; + } +} + +message MaterializedInputs { + repeated MaterializedInput items = 1; + + // Revision of the app object that we materialized the input for. + uint64 revision = 2 [(buf.validate.field).uint64.gte = 0]; +} + +message MaterializedInput { + // Name is a unique identifier of the input within the list of inputs of the app + string name = 1 [(buf.validate.field).string.min_len = 1]; + + oneof value { + option (buf.validate.oneof).required = true; + + // ArtifactId is an identifier of an artifact that will be used as the input to the app at runtime. + flyteidl2.core.ArtifactID artifact_id = 2; + } +} + +// InputList is a list of dependencies for the app. +message InputList { + // Items is the list of inputs to fulfil for the app. + repeated Input items = 1; +} + +message Profile { + // App Type (e.g. FastAPI, Flask, VLLM, NIM etc.) + string type = 1; + + // Friendly name of the app. + string name = 2; + + // Short description of the app. + string short_description = 3 [(buf.validate.field).string.max_len = 100]; + + // Icon URL of the app. + string icon_url = 4; +} + +// SecurityContext holds security attributes that apply to tasks. +message SecurityContext { + // run_as encapsulates the identity a pod should run as. If the task fills in multiple fields here, it'll be up to the + // backend plugin to choose the appropriate identity for the execution engine the task will run on. + flyteidl2.core.Identity run_as = 1; + + // secrets indicate the list of secrets the task needs in order to proceed. Secrets will be mounted/passed to the + // pod as it starts. If the plugin responsible for kicking of the task will not run it on a flyte cluster (e.g. AWS + // Batch), it's the responsibility of the plugin to fetch the secret (which means propeller identity will need access + // to the secret) and to pass it to the remote execution engine. + repeated flyteidl2.core.Secret secrets = 2; + + reserved 3; + reserved 4; + + // AllowAnonymous indicates if the app should be accessible without authentication. This assumes the app will handle + // its own authentication or that it's a public app. + bool allow_anonymous = 5; +} + +message ImageSpec { + // Tag of the image. + string tag = 1; + // URL of the build job for the image. + string build_job_url = 2; +} + +message ImageSpecSet { + // List of image specifications. + repeated ImageSpec images = 1; +} + +// Represents the ingress configuration of an app. +message IngressConfig { + // Indicates if the app should be private. + bool private = 1; + + // Subdomain for the app. If not specified, a random subdomain will be generated. + string subdomain = 2; + + // Canonical name (CNAME) for the app. + string cname = 3; +} + +// Represents the autoscaling configuration of an app. +message AutoscalingConfig { + // Configuration for the number of replicas. + Replicas replicas = 1; + // The period for scaling down the object. + google.protobuf.Duration scaledown_period = 2; + // Metric for scaling the app. + ScalingMetric scaling_metric = 3; +} + +// ScalingMetric allows different scaling strategies for the app. +// See: https://knative.dev/docs/serving/autoscaling/autoscaling-metrics/ +message ScalingMetric { + oneof metric { + option (buf.validate.oneof).required = true; + + // Configuration for scaling based on request rate. + RequestRate request_rate = 1; + // Configuration for scaling based on concurrency. + Concurrency concurrency = 2; + } +} + +// This section enables scaling based on the request concurrency. Concurrency calculates how many +// requests are being processed at the same time. This is useful for apps that take longer to process +// requests (e.g. seconds) +// The autoscaler has a default window of 60 seconds to calculate the concurrency value. However, it has +// panic mode that kicks in if the request rate jumps to 2x its value within 6 seconds. If that's +// triggered, it'll start scaling up immediately instead of waiting for the full 60 seconds. +message Concurrency { + // This is the target value for the scaling configuration. + // default=100 + uint32 target_value = 1 [(buf.validate.field).uint32.gt = 0]; +} + +// RequestRate enables scaling based on the request rate. Request rate calculates how many requests +// the app is receiving per second. +// The autoscaler has a default window of 60 seconds to calculate the request rate. However, it has +// panic mode that kicks in if the request rate jumps to 2x its value within 6 seconds. If that's +// triggered, it'll start scaling up immediately instead of waiting for the full 60 seconds. +message RequestRate { + // This is the target value for the scaling configuration. + // default=100 + uint32 target_value = 1 [(buf.validate.field).uint32.gte = 0]; +} + +// Represents the configuration for the number of replicas. +message Replicas { + // Minimum number of replicas. + uint32 min = 1 [(buf.validate.field).uint32.gte = 0]; + + // Maximum number of replicas. + uint32 max = 2 [(buf.validate.field).uint32.gte = 0]; +} + +message TimeoutConfig { + // This is the maximum duration that the request instance + // is allowed to respond to a request. If unspecified, a system default will + // be provided. + // default=300s + google.protobuf.Duration request_timeout = 1 [(buf.validate.field).duration = { + gte: {seconds: 0} + lte: {seconds: 3600} + }]; +} diff --git a/flyteidl2/app/app_logs_payload.proto b/flyteidl2/app/app_logs_payload.proto new file mode 100644 index 0000000000..cb22381e54 --- /dev/null +++ b/flyteidl2/app/app_logs_payload.proto @@ -0,0 +1,56 @@ +syntax = "proto3"; + +package flyteidl2.app; + +import "buf/validate/validate.proto"; +import "flyteidl2/app/app_definition.proto"; +import "flyteidl2/app/replica_definition.proto"; +import "flyteidl2/logs/dataplane/payload.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app"; + +message TailLogsRequest { + oneof target { + option (buf.validate.oneof).required = true; + + // Identifier of the application to get logs for. + Identifier app_id = 1; + + // Identifier of the replica to get logs for. + ReplicaIdentifier replica_id = 2; + } +} + +message ReplicaIdentifierList { + repeated ReplicaIdentifier replicas = 1; +} + +message LogLines { + repeated string lines = 1 [deprecated = true]; + + ReplicaIdentifier replica_id = 2 [(buf.validate.field).required = true]; + + repeated flyteidl2.logs.dataplane.LogLine structured_lines = 3; +} + +message LogLinesBatch { + repeated LogLines logs = 1; +} + +message TailLogsResponse { + oneof resp { + option (buf.validate.oneof).required = true; + + // Replicas lists the replicas that the logs are being tailed for. This is expected to be the first + // message to be sent in the stream but also can be sent at any later time to update the list of + // replicas being tailed. + ReplicaIdentifierList replicas = 1; + + // The latest log lines for the application. + // Deprecated, use batches instead. + flyteidl2.logs.dataplane.LogLines log_lines = 2 [deprecated = true]; + + // The latest log lines for the application. + LogLinesBatch batches = 3; + } +} diff --git a/flyteidl2/app/app_logs_service.proto b/flyteidl2/app/app_logs_service.proto new file mode 100644 index 0000000000..445ac12431 --- /dev/null +++ b/flyteidl2/app/app_logs_service.proto @@ -0,0 +1,13 @@ +syntax = "proto3"; + +package flyteidl2.app; + +import "flyteidl2/app/app_logs_payload.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app"; + +service AppLogsService { + rpc TailLogs(TailLogsRequest) returns (stream TailLogsResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } +} diff --git a/flyteidl2/app/app_payload.proto b/flyteidl2/app/app_payload.proto new file mode 100644 index 0000000000..9fc54bf67e --- /dev/null +++ b/flyteidl2/app/app_payload.proto @@ -0,0 +1,162 @@ +syntax = "proto3"; + +package flyteidl2.app; + +import "buf/validate/validate.proto"; +import "flyteidl2/app/app_definition.proto"; +import "flyteidl2/common/identifier.proto"; +import "flyteidl2/common/list.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app"; + +// Request message for creating an app. +message CreateRequest { + // The app to be created. + App app = 1 [(buf.validate.field).required = true]; +} + +// Response message for creating an app. +message CreateResponse { + // The created app. + App app = 1; +} + +// Request message for retrieving an app. +message GetRequest { + oneof identifier { + option (buf.validate.oneof).required = true; + + // Identifier of the app to be retrieved. + Identifier app_id = 1; + + // Ingress of the app to be retrieved. Only one field need to be set. + // If multiple fields are set, they must resolve into the same app. + // Otherwise, an error is returned. + Ingress ingress = 2; + } +} + +// Response message for retrieving an app. +message GetResponse { + // The retrieved app. + App app = 1; +} + +// Request message for updating an app. +message UpdateRequest { + // The app to be updated. + App app = 1 [(buf.validate.field).required = true]; + string reason = 2 [(buf.validate.field).string.max_len = 100]; +} + +// Response message for updating an app. +message UpdateResponse { + // The updated app. + App app = 1; +} + +// Request message for deleting an app. +message DeleteRequest { + // Identifier of the app to be deleted. + Identifier app_id = 1 [(buf.validate.field).required = true]; +} + +// Response message for deleting an app. +message DeleteResponse {} + +// Request message for listing apps. +message ListRequest { + // Common list request parameters. + common.ListRequest request = 1; + + oneof filter_by { + option (buf.validate.oneof).required = true; + + // Organization name for filtering apps. + string org = 2 [(buf.validate.field).string.min_len = 1]; + // Cluster identifier for filtering apps. + common.ClusterIdentifier cluster_id = 3; + // Project identifier for filtering apps. + common.ProjectIdentifier project = 4; + } +} + +// Response message for listing apps. +message ListResponse { + // List of apps. + repeated App apps = 1; + // Token for fetching the next page of results, if any. + string token = 2; +} + +// Request message for watching app events. +message WatchRequest { + oneof target { + option (buf.validate.oneof).required = true; + + // Organization name for filtering events. + string org = 1 [(buf.validate.field).string.min_len = 1]; + // Cluster identifier for filtering events. + common.ClusterIdentifier cluster_id = 2; + // Project identifier for filtering events. + common.ProjectIdentifier project = 3; + // App identifier for filtering events. + Identifier app_id = 4; + } +} + +// Event message for app creation. +message CreateEvent { + // The created app. + App app = 1; +} + +// Event message for app update. +message UpdateEvent { + // The updated app. + App updated_app = 1; + // The old app before the update. + App old_app = 2; +} + +// Event message for app deletion. +message DeleteEvent { + // The deleted app. + App app = 1; +} + +// Response message for watching app events. +message WatchResponse { + oneof event { + // Event for app creation. + CreateEvent create_event = 1; + // Event for app update. + UpdateEvent update_event = 2; + // Event for app deletion. + DeleteEvent delete_event = 3; + } +} + +// Request message for updating app status. +message UpdateStatusRequest { + // The app with updated status. + App app = 1 [(buf.validate.field).required = true]; +} + +// Response message for updating app status. +message UpdateStatusResponse { + // The app with updated status. + App app = 1; +} + +// Request message for leasing apps. +message LeaseRequest { + // Cluster identifier for leasing apps. + common.ClusterIdentifier id = 1 [(buf.validate.field).required = true]; +} + +// Response message for leasing apps. +message LeaseResponse { + // List of leased apps. + repeated App apps = 1; +} diff --git a/flyteidl2/app/app_service.proto b/flyteidl2/app/app_service.proto new file mode 100644 index 0000000000..443577c8ca --- /dev/null +++ b/flyteidl2/app/app_service.proto @@ -0,0 +1,40 @@ +syntax = "proto3"; + +package flyteidl2.app; + +import "flyteidl2/app/app_payload.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app"; + +// AppService defines the service for managing apps. +service AppService { + // Create creates a new app. + rpc Create(CreateRequest) returns (CreateResponse) {} + + // Get retrieves an app by its identifier. + rpc Get(GetRequest) returns (GetResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + + // Update updates an existing app. + rpc Update(UpdateRequest) returns (UpdateResponse) {} + + // UpdateStatus updates the status of an existing app. + rpc UpdateStatus(UpdateStatusRequest) returns (UpdateStatusResponse) {} + + // Delete deletes an app by its identifier. + rpc Delete(DeleteRequest) returns (DeleteResponse) {} + + // List lists all apps with optional filtering. + rpc List(ListRequest) returns (ListResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + + // Watch watches for app events. + rpc Watch(WatchRequest) returns (stream WatchResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + + // Lease leases apps. + rpc Lease(LeaseRequest) returns (stream LeaseResponse) {} +} diff --git a/flyteidl2/app/replica_definition.proto b/flyteidl2/app/replica_definition.proto new file mode 100644 index 0000000000..44241074b3 --- /dev/null +++ b/flyteidl2/app/replica_definition.proto @@ -0,0 +1,43 @@ +syntax = "proto3"; + +package flyteidl2.app; + +import "buf/validate/validate.proto"; +import "flyteidl2/app/app_definition.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app"; + +message ReplicaIdentifier { + // ID of the app. + Identifier app_id = 1 [(buf.validate.field).required = true]; + string name = 2 [(buf.validate.field).string.min_len = 1]; +} + +message ReplicaMeta { + // ID of the replica. + ReplicaIdentifier id = 1 [(buf.validate.field).required = true]; + + // Revision of the replica object. + uint64 revision = 2; +} + +message ReplicaList { + // List of replicas. + repeated Replica items = 1; +} + +// Represents a replica of an app with its specification and status. +message Replica { + // Metadata of the app. + ReplicaMeta metadata = 1 [(buf.validate.field).required = true]; + // Status of the app. + ReplicaStatus status = 2; +} + +// Represents the status of the replica. +message ReplicaStatus { + // Current deployment status of the replica. + string deployment_status = 1; + + string reason = 2; +} diff --git a/flyteidl2/auth/auth_service.proto b/flyteidl2/auth/auth_service.proto new file mode 100644 index 0000000000..0897a8ff6c --- /dev/null +++ b/flyteidl2/auth/auth_service.proto @@ -0,0 +1,81 @@ +syntax = "proto3"; +package flyteidl2.auth; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/auth"; + +message GetOAuth2MetadataRequest {} + +// OAuth2MetadataResponse defines an RFC-Compliant response for /.well-known/oauth-authorization-server metadata +// as defined in https://tools.ietf.org/html/rfc8414 +message GetOAuth2MetadataResponse { + // Defines the issuer string in all JWT tokens this server issues. The issuer can be admin itself or an external + // issuer. + string issuer = 1; + + // URL of the authorization server's authorization endpoint [RFC6749]. This is REQUIRED unless no grant types are + // supported that use the authorization endpoint. + string authorization_endpoint = 2; + + // URL of the authorization server's token endpoint [RFC6749]. + string token_endpoint = 3; + + // Array containing a list of the OAuth 2.0 response_type values that this authorization server supports. + repeated string response_types_supported = 4; + + // JSON array containing a list of the OAuth 2.0 [RFC6749] scope values that this authorization server supports. + repeated string scopes_supported = 5; + + // JSON array containing a list of client authentication methods supported by this token endpoint. + repeated string token_endpoint_auth_methods_supported = 6; + + // URL of the authorization server's JWK Set [JWK] document. The referenced document contains the signing key(s) the + // client uses to validate signatures from the authorization server. + string jwks_uri = 7; + + // JSON array containing a list of Proof Key for Code Exchange (PKCE) [RFC7636] code challenge methods supported by + // this authorization server. + repeated string code_challenge_methods_supported = 8; + + // JSON array containing a list of the OAuth 2.0 grant type values that this authorization server supports. + repeated string grant_types_supported = 9; + + // URL of the authorization server's device authorization endpoint, as defined in Section 3.1 of [RFC8628] + string device_authorization_endpoint = 10; +} + +message GetPublicClientConfigRequest {} + +// FlyteClientResponse encapsulates public information that flyte clients (CLIs... etc.) can use to authenticate users. +message GetPublicClientConfigResponse { + // client_id to use when initiating OAuth2 authorization requests. + string client_id = 1; + // redirect uri to use when initiating OAuth2 authorization requests. + string redirect_uri = 2; + // scopes to request when initiating OAuth2 authorization requests. + repeated string scopes = 3; + // Authorization Header to use when passing Access Tokens to the server. If not provided, the client should use the + // default http `Authorization` header. + string authorization_metadata_key = 4; + // ServiceHttpEndpoint points to the http endpoint for the backend. If empty, clients can assume the endpoint used + // to configure the gRPC connection can be used for the http one respecting the insecure flag to choose between + // SSL or no SSL connections. + string service_http_endpoint = 5; + // audience to use when initiating OAuth2 authorization requests. + string audience = 6; +} + +// The following defines an RPC service that is also served over HTTP via grpc-gateway. +// Standard response codes for both are defined here: https://github.com/grpc-ecosystem/grpc-gateway/blob/master/runtime/errors.go +// RPCs defined in this service must be anonymously accessible. +service AuthMetadataService { + // Anonymously accessible. Retrieves local or external oauth authorization server metadata. + rpc GetOAuth2Metadata(GetOAuth2MetadataRequest) returns (GetOAuth2MetadataResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + + // Anonymously accessible. Retrieves the client information clients should use when initiating OAuth2 authorization + // requests. + rpc GetPublicClientConfig(GetPublicClientConfigRequest) returns (GetPublicClientConfigResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } +} diff --git a/flyteidl2/auth/identity.proto b/flyteidl2/auth/identity.proto new file mode 100644 index 0000000000..8c9365bdc6 --- /dev/null +++ b/flyteidl2/auth/identity.proto @@ -0,0 +1,42 @@ +syntax = "proto3"; +package flyteidl2.auth; + +import "google/protobuf/struct.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/auth"; + +message UserInfoRequest {} + +// See the OpenID Connect spec at https://openid.net/specs/openid-connect-core-1_0.html#UserInfoResponse for more information. +message UserInfoResponse { + // Locally unique and never reassigned identifier within the Issuer for the End-User, which is intended to be consumed + // by the Client. + string subject = 1; + + // Full name + string name = 2; + + // Shorthand name by which the End-User wishes to be referred to + string preferred_username = 3; + + // Given name(s) or first name(s) + string given_name = 4; + + // Surname(s) or last name(s) + string family_name = 5; + + // Preferred e-mail address + string email = 6; + + // Profile picture URL + string picture = 7; + + // Additional claims + google.protobuf.Struct additional_claims = 8; +} + +// IdentityService defines an RPC Service that interacts with user/app identities. +service IdentityService { + // Retrieves user information about the currently logged in user. + rpc UserInfo(UserInfoRequest) returns (UserInfoResponse) {} +} diff --git a/flyteidl2/cacheservice/cacheservice.proto b/flyteidl2/cacheservice/cacheservice.proto new file mode 100644 index 0000000000..efbfef105b --- /dev/null +++ b/flyteidl2/cacheservice/cacheservice.proto @@ -0,0 +1,147 @@ +syntax = "proto3"; + +package flyteidl2.cacheservice; + +import "flyteidl2/core/identifier.proto"; +import "flyteidl2/core/literals.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/cacheservice"; + +/* + * CacheService defines operations for cache management including retrieval, storage, and deletion of cached task/workflow outputs. + */ +service CacheService { + // Retrieves cached data by key. + rpc Get(GetCacheRequest) returns (GetCacheResponse); + + // Stores or updates cached data by key. + rpc Put(PutCacheRequest) returns (PutCacheResponse); + + // Deletes cached data by key. + rpc Delete(DeleteCacheRequest) returns (DeleteCacheResponse); + + // Get or extend a reservation for a cache key + rpc GetOrExtendReservation(GetOrExtendReservationRequest) returns (GetOrExtendReservationResponse); + + // Release the reservation for a cache key + rpc ReleaseReservation(ReleaseReservationRequest) returns (ReleaseReservationResponse); +} + +/* + * Additional metadata as key-value pairs + */ +message KeyMapMetadata { + map values = 1; // Additional metadata as key-value pairs +} + +/* + * Metadata for cached outputs, including the source identifier and timestamps. + */ +message Metadata { + core.Identifier source_identifier = 1; // Source task or workflow identifier + KeyMapMetadata key_map = 2; // Additional metadata as key-value pairs + google.protobuf.Timestamp created_at = 3; // Creation timestamp + google.protobuf.Timestamp last_updated_at = 4; // Last update timestamp +} + +/* + * Represents cached output, either as literals or an URI, with associated metadata. + */ +message CachedOutput { + oneof output { + flyteidl2.core.LiteralMap output_literals = 1; // Output literals + string output_uri = 2; // URI to output data + } + Metadata metadata = 3; // Associated metadata +} + +/* + * Request to retrieve cached data by key. + */ +message GetCacheRequest { + string key = 1; // Cache key +} + +/* + * Response with cached data for a given key. + */ +message GetCacheResponse { + CachedOutput output = 1; // Cached output +} + +message OverwriteOutput { + bool overwrite = 1; // Overwrite flag + bool delete_blob = 2; // Delete existing blob + google.protobuf.Duration max_age = 3; // Maximum age of the cached output since last update +} + +/* + * Request to store/update cached data by key. + */ +message PutCacheRequest { + string key = 1; // Cache key + CachedOutput output = 2; // Output to cache + OverwriteOutput overwrite = 3; // Overwrite flag if exists +} + +/* + * Response message of cache store/update operation. + */ +message PutCacheResponse { + // Empty, success indicated by no errors +} + +/* + * Request to delete cached data by key. + */ +message DeleteCacheRequest { + string key = 1; // Cache key +} + +/* + * Response message of cache deletion operation. + */ +message DeleteCacheResponse { + // Empty, success indicated by no errors +} + +// A reservation including owner, heartbeat interval, expiration timestamp, and various metadata. +message Reservation { + string key = 1; // The unique ID for the reservation - same as the cache key + string owner_id = 2; // The unique ID of the owner for the reservation + google.protobuf.Duration heartbeat_interval = 3; // Requested reservation extension heartbeat interval + google.protobuf.Timestamp expires_at = 4; // Expiration timestamp of this reservation +} + +/* + * Request to get or extend a reservation for a cache key + */ +message GetOrExtendReservationRequest { + string key = 1; // The unique ID for the reservation - same as the cache key + string owner_id = 2; // The unique ID of the owner for the reservation + google.protobuf.Duration heartbeat_interval = 3; // Requested reservation extension heartbeat interval +} + +/* + * Request to get or extend a reservation for a cache key + */ +message GetOrExtendReservationResponse { + Reservation reservation = 1; // The reservation that was created or extended +} + +/* + * Request to release the reservation for a cache key + */ +message ReleaseReservationRequest { + string key = 1; // The unique ID for the reservation - same as the cache key + string owner_id = 2; // The unique ID of the owner for the reservation +} + +/* + * Response message of release reservation operation. + */ +message ReleaseReservationResponse { + // Empty, success indicated by no errors +} diff --git a/flyteidl2/cacheservice/v2/cacheservice.proto b/flyteidl2/cacheservice/v2/cacheservice.proto new file mode 100644 index 0000000000..bf98b3e1ee --- /dev/null +++ b/flyteidl2/cacheservice/v2/cacheservice.proto @@ -0,0 +1,78 @@ +syntax = "proto3"; + +package flyteidl2.cacheservice.v2; + +import "buf/validate/validate.proto"; +import "flyteidl2/cacheservice/cacheservice.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/cacheservice/v2"; + +/* + * CacheService defines operations for cache management including retrieval, storage, and deletion of cached task/workflow outputs. + */ +service CacheService { + // Retrieves cached data by key. + rpc Get(GetCacheRequest) returns (flyteidl2.cacheservice.GetCacheResponse); + + // Stores or updates cached data by key. + rpc Put(PutCacheRequest) returns (flyteidl2.cacheservice.PutCacheResponse); + + // Deletes cached data by key. + rpc Delete(DeleteCacheRequest) returns (flyteidl2.cacheservice.DeleteCacheResponse); + + // Get or extend a reservation for a cache key + rpc GetOrExtendReservation(GetOrExtendReservationRequest) returns (flyteidl2.cacheservice.GetOrExtendReservationResponse); + + // Release the reservation for a cache key + rpc ReleaseReservation(ReleaseReservationRequest) returns (flyteidl2.cacheservice.ReleaseReservationResponse); +} + +/* + * Identifier for cache operations, including org, project, and domain. + * This is used to scope cache operations to specific organizational contexts. + */ +message Identifier { + string org = 1 [(buf.validate.field).string.min_len = 1]; // Organization identifier + string project = 2 [(buf.validate.field).string.min_len = 1]; // Project identifier + string domain = 3 [(buf.validate.field).string.min_len = 1]; // Domain identifier +} + +/* + * Request to retrieve cached data by key. + */ +message GetCacheRequest { + flyteidl2.cacheservice.GetCacheRequest base_request = 1; + Identifier identifier = 2 [(buf.validate.field).required = true]; // Identifier for the cache operation +} + +/* + * Request to store/update cached data by key. + */ +message PutCacheRequest { + flyteidl2.cacheservice.PutCacheRequest base_request = 1; + Identifier identifier = 2 [(buf.validate.field).required = true]; // Identifier for the cache operation +} + +/* + * Request to delete cached data by key. + */ +message DeleteCacheRequest { + flyteidl2.cacheservice.DeleteCacheRequest base_request = 1; + Identifier identifier = 2 [(buf.validate.field).required = true]; // Identifier for the cache operation +} + +/* + * Request to get or extend a reservation for a cache key + */ +message GetOrExtendReservationRequest { + flyteidl2.cacheservice.GetOrExtendReservationRequest base_request = 1; + Identifier identifier = 2 [(buf.validate.field).required = true]; // Identifier for the cache operation +} + +/* + * Request to release the reservation for a cache key + */ +message ReleaseReservationRequest { + flyteidl2.cacheservice.ReleaseReservationRequest base_request = 1; + Identifier identifier = 2 [(buf.validate.field).required = true]; // Identifier for the cache operation +} diff --git a/flyteidl2/clients/go/coreutils/extract_literal.go b/flyteidl2/clients/go/coreutils/extract_literal.go new file mode 100644 index 0000000000..aa8fde2b91 --- /dev/null +++ b/flyteidl2/clients/go/coreutils/extract_literal.go @@ -0,0 +1,107 @@ +// extract_literal.go +// Utility methods to extract a native golang value from a given Literal. +// Usage: +// 1] string literal extraction +// lit, _ := MakeLiteral("test_string") +// val, _ := ExtractFromLiteral(lit) +// 2] integer literal extraction. integer would be extracted in type int64. +// lit, _ := MakeLiteral([]interface{}{1, 2, 3}) +// val, _ := ExtractFromLiteral(lit) +// 3] float literal extraction. float would be extracted in type float64. +// lit, _ := MakeLiteral([]interface{}{1.0, 2.0, 3.0}) +// val, _ := ExtractFromLiteral(lit) +// 4] map of boolean literal extraction. +// mapInstance := map[string]interface{}{ +// "key1": []interface{}{1, 2, 3}, +// "key2": []interface{}{5}, +// } +// lit, _ := MakeLiteral(mapInstance) +// val, _ := ExtractFromLiteral(lit) +// For further examples check the test TestFetchLiteral in extract_literal_test.go + +package coreutils + +import ( + "fmt" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func ExtractFromLiteral(literal *core.Literal) (interface{}, error) { + switch literalValue := literal.Value.(type) { + case *core.Literal_Scalar: + switch scalarValue := literalValue.Scalar.Value.(type) { + case *core.Scalar_Primitive: + switch scalarPrimitive := scalarValue.Primitive.Value.(type) { + case *core.Primitive_Integer: + scalarPrimitiveInt := scalarPrimitive.Integer + return scalarPrimitiveInt, nil + case *core.Primitive_FloatValue: + scalarPrimitiveFloat := scalarPrimitive.FloatValue + return scalarPrimitiveFloat, nil + case *core.Primitive_StringValue: + scalarPrimitiveString := scalarPrimitive.StringValue + return scalarPrimitiveString, nil + case *core.Primitive_Boolean: + scalarPrimitiveBoolean := scalarPrimitive.Boolean + return scalarPrimitiveBoolean, nil + case *core.Primitive_Datetime: + scalarPrimitiveDateTime := scalarPrimitive.Datetime.AsTime() + return scalarPrimitiveDateTime, nil + case *core.Primitive_Duration: + scalarPrimitiveDuration := scalarPrimitive.Duration.AsDuration() + return scalarPrimitiveDuration, nil + default: + return nil, fmt.Errorf("unsupported literal scalar primitive type %T", scalarValue) + } + case *core.Scalar_Binary: + return scalarValue.Binary, nil + case *core.Scalar_Blob: + return scalarValue.Blob.Uri, nil + case *core.Scalar_Schema: + return scalarValue.Schema.Uri, nil + case *core.Scalar_Generic: + return scalarValue.Generic, nil + case *core.Scalar_StructuredDataset: + return scalarValue.StructuredDataset.Uri, nil + case *core.Scalar_Union: + // extract the value of the union but not the actual union object + extractedVal, err := ExtractFromLiteral(scalarValue.Union.Value) + if err != nil { + return nil, err + } + return extractedVal, nil + case *core.Scalar_NoneType: + return nil, nil + default: + return nil, fmt.Errorf("unsupported literal scalar type %T", scalarValue) + } + case *core.Literal_Collection: + collectionValue := literalValue.Collection.Literals + collection := make([]interface{}, len(collectionValue)) + for index, val := range collectionValue { + if collectionElem, err := ExtractFromLiteral(val); err == nil { + collection[index] = collectionElem + } else { + return nil, err + } + } + return collection, nil + case *core.Literal_Map: + mapLiteralValue := literalValue.Map.Literals + mapResult := make(map[string]interface{}, len(mapLiteralValue)) + for key, val := range mapLiteralValue { + if val, err := ExtractFromLiteral(val); err == nil { + mapResult[key] = val + } else { + return nil, err + } + } + return mapResult, nil + case *core.Literal_OffloadedMetadata: + // Return the URI of the offloaded metadata to be used when displaying in flytectl + return literalValue.OffloadedMetadata.Uri, nil + + } + return nil, fmt.Errorf("unsupported literal type %T", literal) +} diff --git a/flyteidl2/clients/go/coreutils/extract_literal_test.go b/flyteidl2/clients/go/coreutils/extract_literal_test.go new file mode 100644 index 0000000000..8781c6b3a5 --- /dev/null +++ b/flyteidl2/clients/go/coreutils/extract_literal_test.go @@ -0,0 +1,267 @@ +// extract_literal_test.go +// Test class for the utility methods which extract a native golang value from a flyte Literal. + +package coreutils + +import ( + "os" + "testing" + "time" + + structpb "github.com/golang/protobuf/ptypes/struct" + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestFetchLiteral(t *testing.T) { + t.Run("Primitive", func(t *testing.T) { + lit, err := MakeLiteral("test_string") + assert.NoError(t, err) + val, err := ExtractFromLiteral(lit) + assert.NoError(t, err) + assert.Equal(t, "test_string", val) + }) + + t.Run("Timestamp", func(t *testing.T) { + now := time.Now().UTC() + lit, err := MakeLiteral(now) + assert.NoError(t, err) + val, err := ExtractFromLiteral(lit) + assert.NoError(t, err) + assert.Equal(t, now, val) + }) + + t.Run("Duration", func(t *testing.T) { + duration := time.Second * 10 + lit, err := MakeLiteral(duration) + assert.NoError(t, err) + val, err := ExtractFromLiteral(lit) + assert.NoError(t, err) + assert.Equal(t, duration, val) + }) + + t.Run("Array", func(t *testing.T) { + lit, err := MakeLiteral([]interface{}{1, 2, 3}) + assert.NoError(t, err) + val, err := ExtractFromLiteral(lit) + assert.NoError(t, err) + arr := []interface{}{int64(1), int64(2), int64(3)} + assert.Equal(t, arr, val) + }) + + t.Run("Map", func(t *testing.T) { + mapInstance := map[string]interface{}{ + "key1": []interface{}{1, 2, 3}, + "key2": []interface{}{5}, + } + lit, err := MakeLiteral(mapInstance) + assert.NoError(t, err) + val, err := ExtractFromLiteral(lit) + assert.NoError(t, err) + expectedMapInstance := map[string]interface{}{ + "key1": []interface{}{int64(1), int64(2), int64(3)}, + "key2": []interface{}{int64(5)}, + } + assert.Equal(t, expectedMapInstance, val) + }) + + t.Run("Map_Booleans", func(t *testing.T) { + mapInstance := map[string]interface{}{ + "key1": []interface{}{true, false, true}, + "key2": []interface{}{false}, + } + lit, err := MakeLiteral(mapInstance) + assert.NoError(t, err) + val, err := ExtractFromLiteral(lit) + assert.NoError(t, err) + assert.Equal(t, mapInstance, val) + }) + + t.Run("Map_Floats", func(t *testing.T) { + mapInstance := map[string]interface{}{ + "key1": []interface{}{1.0, 2.0, 3.0}, + "key2": []interface{}{1.0}, + } + lit, err := MakeLiteral(mapInstance) + assert.NoError(t, err) + val, err := ExtractFromLiteral(lit) + assert.NoError(t, err) + expectedMapInstance := map[string]interface{}{ + "key1": []interface{}{float64(1.0), float64(2.0), float64(3.0)}, + "key2": []interface{}{float64(1.0)}, + } + assert.Equal(t, expectedMapInstance, val) + }) + + t.Run("NestedMap", func(t *testing.T) { + mapInstance := map[string]interface{}{ + "key1": map[string]interface{}{"key11": 1.0, "key12": 2.0, "key13": 3.0}, + "key2": map[string]interface{}{"key21": 1.0}, + } + lit, err := MakeLiteral(mapInstance) + assert.NoError(t, err) + val, err := ExtractFromLiteral(lit) + assert.NoError(t, err) + expectedMapInstance := map[string]interface{}{ + "key1": map[string]interface{}{"key11": float64(1.0), "key12": float64(2.0), "key13": float64(3.0)}, + "key2": map[string]interface{}{"key21": float64(1.0)}, + } + assert.Equal(t, expectedMapInstance, val) + }) + + t.Run("Binary", func(t *testing.T) { + s := MakeBinaryLiteral([]byte{'h'}) + assert.Equal(t, []byte{'h'}, s.GetScalar().GetBinary().GetValue()) + _, err := ExtractFromLiteral(s) + assert.Nil(t, err) + }) + + t.Run("NoneType", func(t *testing.T) { + p, err := MakeLiteral(nil) + assert.NoError(t, err) + assert.NotNil(t, p.GetScalar()) + _, err = ExtractFromLiteral(p) + assert.Nil(t, err) + }) + + t.Run("Generic", func(t *testing.T) { + os.Setenv(FlyteUseOldDcFormat, "true") + literalVal := map[string]interface{}{ + "x": 1, + "y": "ystringvalue", + } + var literalType = &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_STRUCT}} + lit, err := MakeLiteralForType(literalType, literalVal) + assert.NoError(t, err) + extractedLiteralVal, err := ExtractFromLiteral(lit) + assert.NoError(t, err) + fieldsMap := map[string]*structpb.Value{ + "x": { + Kind: &structpb.Value_NumberValue{NumberValue: 1}, + }, + "y": { + Kind: &structpb.Value_StringValue{StringValue: "ystringvalue"}, + }, + } + expectedStructVal := &structpb.Struct{ + Fields: fieldsMap, + } + extractedStructValue := extractedLiteralVal.(*structpb.Struct) + assert.Equal(t, len(expectedStructVal.Fields), len(extractedStructValue.Fields)) + for key, val := range expectedStructVal.Fields { + assert.Equal(t, val.Kind, extractedStructValue.Fields[key].Kind) + } + os.Unsetenv(FlyteUseOldDcFormat) + }) + + t.Run("Generic Passed As String", func(t *testing.T) { + literalVal := "{\"x\": 1,\"y\": \"ystringvalue\"}" + var literalType = &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_STRUCT}} + lit, err := MakeLiteralForType(literalType, literalVal) + assert.NoError(t, err) + extractedLiteralVal, err := ExtractFromLiteral(lit) + assert.NoError(t, err) + fieldsMap := map[string]*structpb.Value{ + "x": { + Kind: &structpb.Value_NumberValue{NumberValue: 1}, + }, + "y": { + Kind: &structpb.Value_StringValue{StringValue: "ystringvalue"}, + }, + } + expectedStructVal := &structpb.Struct{ + Fields: fieldsMap, + } + extractedStructValue := extractedLiteralVal.(*structpb.Struct) + assert.Equal(t, len(expectedStructVal.Fields), len(extractedStructValue.Fields)) + for key, val := range expectedStructVal.Fields { + assert.Equal(t, val.Kind, extractedStructValue.Fields[key].Kind) + } + }) + + t.Run("Structured dataset", func(t *testing.T) { + literalVal := "s3://blah/blah/blah" + var dataSetColumns []*core.StructuredDatasetType_DatasetColumn + dataSetColumns = append(dataSetColumns, &core.StructuredDatasetType_DatasetColumn{ + Name: "Price", + LiteralType: &core.LiteralType{ + Type: &core.LiteralType_Simple{ + Simple: core.SimpleType_FLOAT, + }, + }, + }) + var literalType = &core.LiteralType{Type: &core.LiteralType_StructuredDatasetType{StructuredDatasetType: &core.StructuredDatasetType{ + Columns: dataSetColumns, + Format: "testFormat", + }}} + + lit, err := MakeLiteralForType(literalType, literalVal) + assert.NoError(t, err) + extractedLiteralVal, err := ExtractFromLiteral(lit) + assert.NoError(t, err) + assert.Equal(t, literalVal, extractedLiteralVal) + }) + + t.Run("Offloaded metadata", func(t *testing.T) { + literalVal := "s3://blah/blah/blah" + var storedLiteralType = &core.LiteralType{ + Type: &core.LiteralType_CollectionType{ + CollectionType: &core.LiteralType{ + Type: &core.LiteralType_Simple{ + Simple: core.SimpleType_INTEGER, + }, + }, + }, + } + offloadedLiteral := &core.Literal{ + Value: &core.Literal_OffloadedMetadata{ + OffloadedMetadata: &core.LiteralOffloadedMetadata{ + Uri: literalVal, + InferredType: storedLiteralType, + }, + }, + } + extractedLiteralVal, err := ExtractFromLiteral(offloadedLiteral) + assert.NoError(t, err) + assert.Equal(t, literalVal, extractedLiteralVal) + }) + + t.Run("Union", func(t *testing.T) { + literalVal := int64(1) + var literalType = &core.LiteralType{ + Type: &core.LiteralType_UnionType{ + UnionType: &core.UnionType{ + Variants: []*core.LiteralType{ + {Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}, + {Type: &core.LiteralType_Simple{Simple: core.SimpleType_FLOAT}}, + }, + }, + }, + } + lit, err := MakeLiteralForType(literalType, literalVal) + assert.NoError(t, err) + extractedLiteralVal, err := ExtractFromLiteral(lit) + assert.NoError(t, err) + assert.Equal(t, literalVal, extractedLiteralVal) + }) + + t.Run("Union with None", func(t *testing.T) { + var literalType = &core.LiteralType{ + Type: &core.LiteralType_UnionType{ + UnionType: &core.UnionType{ + Variants: []*core.LiteralType{ + {Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}, + {Type: &core.LiteralType_Simple{Simple: core.SimpleType_NONE}}, + }, + }, + }, + } + lit, err := MakeLiteralForType(literalType, nil) + + assert.NoError(t, err) + extractedLiteralVal, err := ExtractFromLiteral(lit) + assert.NoError(t, err) + assert.Nil(t, extractedLiteralVal) + }) +} diff --git a/flyteidl2/clients/go/coreutils/literals.go b/flyteidl2/clients/go/coreutils/literals.go new file mode 100644 index 0000000000..8a1f882a64 --- /dev/null +++ b/flyteidl2/clients/go/coreutils/literals.go @@ -0,0 +1,670 @@ +// Contains convenience methods for constructing core types. +package coreutils + +import ( + "encoding/json" + "fmt" + "math" + "os" + "reflect" + "strconv" + "strings" + "time" + + "github.com/golang/protobuf/jsonpb" + "github.com/golang/protobuf/ptypes" + structpb "github.com/golang/protobuf/ptypes/struct" + "github.com/pkg/errors" + "github.com/shamaton/msgpack/v2" + + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const MESSAGEPACK = "msgpack" +const FlyteUseOldDcFormat = "FLYTE_USE_OLD_DC_FORMAT" + +func MakePrimitive(v interface{}) (*core.Primitive, error) { + switch p := v.(type) { + case int: + return &core.Primitive{ + Value: &core.Primitive_Integer{ + Integer: int64(p), + }, + }, nil + case int64: + return &core.Primitive{ + Value: &core.Primitive_Integer{ + Integer: p, + }, + }, nil + case float64: + return &core.Primitive{ + Value: &core.Primitive_FloatValue{ + FloatValue: p, + }, + }, nil + case time.Time: + t, err := ptypes.TimestampProto(p) + if err != nil { + return nil, err + } + return &core.Primitive{ + Value: &core.Primitive_Datetime{ + Datetime: t, + }, + }, nil + case time.Duration: + d := ptypes.DurationProto(p) + return &core.Primitive{ + Value: &core.Primitive_Duration{ + Duration: d, + }, + }, nil + case string: + return &core.Primitive{ + Value: &core.Primitive_StringValue{ + StringValue: p, + }, + }, nil + case bool: + return &core.Primitive{ + Value: &core.Primitive_Boolean{ + Boolean: p, + }, + }, nil + } + return nil, fmt.Errorf("failed to convert to a known primitive type. Input Type [%v] not supported", reflect.TypeOf(v).String()) +} + +func MustMakePrimitive(v interface{}) *core.Primitive { + f, err := MakePrimitive(v) + if err != nil { + panic(err) + } + return f +} + +func MakePrimitiveLiteral(v interface{}) (*core.Literal, error) { + p, err := MakePrimitive(v) + if err != nil { + return nil, err + } + return &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{ + Primitive: p, + }, + }, + }, + }, nil +} + +func MustMakePrimitiveLiteral(v interface{}) *core.Literal { + p, err := MakePrimitiveLiteral(v) + if err != nil { + panic(err) + } + return p +} + +func MakeLiteralForMap(v map[string]interface{}) (*core.Literal, error) { + m, err := MakeLiteralMap(v) + if err != nil { + return nil, err + } + + return &core.Literal{ + Value: &core.Literal_Map{ + Map: m, + }, + }, nil +} + +func MakeLiteralForCollection(v []interface{}) (*core.Literal, error) { + literals := make([]*core.Literal, 0, len(v)) + for _, val := range v { + l, err := MakeLiteral(val) + if err != nil { + return nil, err + } + + literals = append(literals, l) + } + + return &core.Literal{ + Value: &core.Literal_Collection{ + Collection: &core.LiteralCollection{ + Literals: literals, + }, + }, + }, nil +} + +func MakeBinaryLiteral(v []byte) *core.Literal { + return &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Binary{ + Binary: &core.Binary{ + Value: v, + Tag: MESSAGEPACK, + }, + }, + }, + }, + } +} + +func MakeGenericLiteral(v *structpb.Struct) *core.Literal { + return &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Generic{ + Generic: v, + }, + }, + }} +} + +func MakeLiteral(v interface{}) (*core.Literal, error) { + if v == nil { + return &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_NoneType{ + NoneType: &core.Void{}, + }, + }, + }, + }, nil + } + switch o := v.(type) { + case *core.Literal: + return o, nil + case []interface{}: + return MakeLiteralForCollection(o) + case map[string]interface{}: + return MakeLiteralForMap(o) + case []byte: + return MakeBinaryLiteral(v.([]byte)), nil + case *structpb.Struct: + return MakeGenericLiteral(v.(*structpb.Struct)), nil + case *core.Error: + return &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Error{ + Error: v.(*core.Error), + }, + }, + }, + }, nil + default: + return MakePrimitiveLiteral(o) + } +} + +func MustMakeDefaultLiteralForType(typ *core.LiteralType) *core.Literal { + if res, err := MakeDefaultLiteralForType(typ); err != nil { + panic(err) + } else { + return res + } +} + +func MakeDefaultLiteralForType(typ *core.LiteralType) (*core.Literal, error) { + switch t := typ.GetType().(type) { + case *core.LiteralType_Simple: + switch t.Simple { + case core.SimpleType_NONE: + return MakeLiteral(nil) + case core.SimpleType_INTEGER: + return MakeLiteral(int(0)) + case core.SimpleType_FLOAT: + return MakeLiteral(float64(0)) + case core.SimpleType_STRING: + return MakeLiteral("") + case core.SimpleType_BOOLEAN: + return MakeLiteral(false) + case core.SimpleType_DATETIME: + return MakeLiteral(time.Now()) + case core.SimpleType_DURATION: + return MakeLiteral(time.Second) + case core.SimpleType_BINARY: + return MakeLiteral([]byte{}) + case core.SimpleType_ERROR: + return &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Error{ + Error: &core.Error{ + Message: "Default Error message", + }, + }, + }, + }, + }, nil + case core.SimpleType_STRUCT: + return &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Generic{ + Generic: &structpb.Struct{}, + }, + }, + }, + }, nil + } + return nil, errors.Errorf("Not yet implemented. Default creation is not yet implemented for [%s] ", t.Simple.String()) + case *core.LiteralType_Blob: + return &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Blob{ + Blob: &core.Blob{ + Metadata: &core.BlobMetadata{ + Type: t.Blob, + }, + Uri: "/tmp/somepath", + }, + }, + }, + }, + }, nil + case *core.LiteralType_CollectionType: + single, err := MakeDefaultLiteralForType(t.CollectionType) + if err != nil { + return nil, err + } + + return &core.Literal{ + Value: &core.Literal_Collection{ + Collection: &core.LiteralCollection{ + Literals: []*core.Literal{single}, + }, + }, + }, nil + case *core.LiteralType_MapValueType: + single, err := MakeDefaultLiteralForType(t.MapValueType) + if err != nil { + return nil, err + } + + return &core.Literal{ + Value: &core.Literal_Map{ + Map: &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "itemKey": single, + }, + }, + }, + }, nil + case *core.LiteralType_EnumType: + return MakeLiteralForType(typ, nil) + case *core.LiteralType_Schema: + return MakeLiteralForType(typ, nil) + case *core.LiteralType_UnionType: + if len(t.UnionType.Variants) == 0 { + return nil, errors.Errorf("Union type must have at least one variant") + } + // For union types, we just return the default for the first variant + val, err := MakeDefaultLiteralForType(t.UnionType.Variants[0]) + if err != nil { + return nil, errors.Errorf("Failed to create default literal for first union type variant [%v]", t.UnionType.Variants[0]) + } + res := &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Union{ + Union: &core.Union{ + Type: t.UnionType.Variants[0], + Value: val, + }, + }, + }, + }, + } + return res, nil + } + + return nil, fmt.Errorf("failed to convert to a known Literal. Input Type [%v] not supported", typ.String()) +} + +func MakePrimitiveForType(t core.SimpleType, s string) (*core.Primitive, error) { + p := &core.Primitive{} + switch t { + case core.SimpleType_INTEGER: + v, err := strconv.ParseInt(s, 10, 64) + if err != nil { + return nil, errors.Wrap(err, "failed to parse integer value") + } + p.Value = &core.Primitive_Integer{Integer: v} + case core.SimpleType_FLOAT: + v, err := strconv.ParseFloat(s, 64) + if err != nil { + return nil, errors.Wrap(err, "failed to parse Float value") + } + p.Value = &core.Primitive_FloatValue{FloatValue: v} + case core.SimpleType_BOOLEAN: + v, err := strconv.ParseBool(s) + if err != nil { + return nil, errors.Wrap(err, "failed to parse Bool value") + } + p.Value = &core.Primitive_Boolean{Boolean: v} + case core.SimpleType_STRING: + p.Value = &core.Primitive_StringValue{StringValue: s} + case core.SimpleType_DURATION: + v, err := time.ParseDuration(s) + if err != nil { + return nil, errors.Wrap(err, "failed to parse Duration, valid formats: e.g. 300ms, -1.5h, 2h45m") + } + p.Value = &core.Primitive_Duration{Duration: ptypes.DurationProto(v)} + case core.SimpleType_DATETIME: + v, err := time.Parse(time.RFC3339, s) + if err != nil { + return nil, errors.Wrap(err, "failed to parse Datetime in RFC3339 format") + } + ts, err := ptypes.TimestampProto(v) + if err != nil { + return nil, errors.Wrap(err, "failed to convert datetime to proto") + } + p.Value = &core.Primitive_Datetime{Datetime: ts} + default: + return nil, fmt.Errorf("unsupported type %s", t.String()) + } + return p, nil +} + +func MakeLiteralForSimpleType(t core.SimpleType, s string) (*core.Literal, error) { + s = strings.Trim(s, " \n\t") + scalar := &core.Scalar{} + switch t { + case core.SimpleType_STRUCT: + st := &structpb.Struct{} + unmarshaler := jsonpb.Unmarshaler{AllowUnknownFields: true} + err := unmarshaler.Unmarshal(strings.NewReader(s), st) + if err != nil { + return nil, errors.Wrapf(err, "failed to load generic type as json.") + } + scalar.Value = &core.Scalar_Generic{ + Generic: st, + } + case core.SimpleType_BINARY: + scalar.Value = &core.Scalar_Binary{ + Binary: &core.Binary{ + Value: []byte(s), + Tag: MESSAGEPACK, + }, + } + case core.SimpleType_ERROR: + scalar.Value = &core.Scalar_Error{ + Error: &core.Error{ + Message: s, + }, + } + case core.SimpleType_NONE: + scalar.Value = &core.Scalar_NoneType{ + NoneType: &core.Void{}, + } + default: + p, err := MakePrimitiveForType(t, s) + if err != nil { + return nil, err + } + scalar.Value = &core.Scalar_Primitive{Primitive: p} + } + return &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: scalar, + }, + }, nil +} + +func MustMakeLiteral(v interface{}) *core.Literal { + p, err := MakeLiteral(v) + if err != nil { + panic(err) + } + + return p +} + +func MakeLiteralMap(v map[string]interface{}) (*core.LiteralMap, error) { + + literals := make(map[string]*core.Literal, len(v)) + for key, val := range v { + l, err := MakeLiteral(val) + if err != nil { + return nil, err + } + + literals[key] = l + } + + return &core.LiteralMap{ + Literals: literals, + }, nil +} + +func MakeLiteralForSchema(path storage.DataReference, columns []*core.SchemaType_SchemaColumn) *core.Literal { + return &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Schema{ + Schema: &core.Schema{ + Uri: path.String(), + Type: &core.SchemaType{ + Columns: columns, + }, + }, + }, + }, + }, + } +} + +func MakeLiteralForStructuredDataSet(path storage.DataReference, columns []*core.StructuredDatasetType_DatasetColumn, format string) *core.Literal { + return &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: path.String(), + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Columns: columns, + Format: format, + }, + }, + }, + }, + }, + }, + } +} + +func MakeLiteralForBlob(path storage.DataReference, isDir bool, format string) *core.Literal { + dim := core.BlobType_SINGLE + if isDir { + dim = core.BlobType_MULTIPART + } + return &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Blob{ + Blob: &core.Blob{ + Uri: path.String(), + Metadata: &core.BlobMetadata{ + Type: &core.BlobType{ + Dimensionality: dim, + Format: format, + }, + }, + }, + }, + }, + }, + } +} + +func MakeLiteralForType(t *core.LiteralType, v interface{}) (*core.Literal, error) { + l := &core.Literal{} + switch newT := t.Type.(type) { + case *core.LiteralType_MapValueType: + newV, ok := v.(map[string]interface{}) + if !ok { + return nil, fmt.Errorf("map value types can only be of type map[string]interface{}, but found %v", reflect.TypeOf(v)) + } + + literals := make(map[string]*core.Literal, len(newV)) + for key, val := range newV { + lv, err := MakeLiteralForType(newT.MapValueType, val) + if err != nil { + return nil, err + } + literals[key] = lv + } + l.Value = &core.Literal_Map{ + Map: &core.LiteralMap{ + Literals: literals, + }, + } + + case *core.LiteralType_CollectionType: + newV, ok := v.([]interface{}) + if !ok { + return nil, fmt.Errorf("collection type expected but found %v", reflect.TypeOf(v)) + } + + literals := make([]*core.Literal, 0, len(newV)) + for _, val := range newV { + lv, err := MakeLiteralForType(newT.CollectionType, val) + if err != nil { + return nil, err + } + literals = append(literals, lv) + } + l.Value = &core.Literal_Collection{ + Collection: &core.LiteralCollection{ + Literals: literals, + }, + } + + case *core.LiteralType_Simple: + strValue := fmt.Sprintf("%v", v) + if v == nil { + strValue = "" + } + // Note this is to support large integers which by default when passed from an unmarshalled json will be + // converted to float64 and printed as exponential format by Sprintf. + // eg : 8888888 get converted to 8.888888e+06 and which causes strconv.ParseInt to fail + // Inorder to avoid this we explicitly add this check. + if f, ok := v.(float64); ok && math.Trunc(f) == f { + strValue = fmt.Sprintf("%.0f", math.Trunc(f)) + } + if newT.Simple == core.SimpleType_STRUCT { + useOldFormat := strings.ToLower(os.Getenv(FlyteUseOldDcFormat)) + if _, isValueStringType := v.(string); !isValueStringType { + if useOldFormat == "1" || useOldFormat == "t" || useOldFormat == "true" { + byteValue, err := json.Marshal(v) + if err != nil { + return nil, fmt.Errorf("unable to marshal to json string for struct value %v", v) + } + strValue = string(byteValue) + } else { + byteValue, err := msgpack.Marshal(v) + if err != nil { + return nil, fmt.Errorf("unable to marshal to msgpack bytes for struct value %v", v) + } + return &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Binary{ + Binary: &core.Binary{ + Value: byteValue, + Tag: MESSAGEPACK, + }, + }, + }, + }, + }, nil + } + } + } + lv, err := MakeLiteralForSimpleType(newT.Simple, strValue) + if err != nil { + return nil, err + } + return lv, nil + + case *core.LiteralType_Blob: + isDir := newT.Blob.Dimensionality == core.BlobType_MULTIPART + lv := MakeLiteralForBlob(storage.DataReference(fmt.Sprintf("%v", v)), isDir, newT.Blob.Format) + return lv, nil + + case *core.LiteralType_Schema: + lv := MakeLiteralForSchema(storage.DataReference(fmt.Sprintf("%v", v)), newT.Schema.Columns) + return lv, nil + case *core.LiteralType_StructuredDatasetType: + lv := MakeLiteralForStructuredDataSet(storage.DataReference(fmt.Sprintf("%v", v)), newT.StructuredDatasetType.Columns, newT.StructuredDatasetType.Format) + return lv, nil + + case *core.LiteralType_EnumType: + var newV string + if v == nil { + if len(t.GetEnumType().Values) == 0 { + return nil, fmt.Errorf("enum types need at least one value") + } + newV = t.GetEnumType().Values[0] + } else { + var ok bool + newV, ok = v.(string) + if !ok { + return nil, fmt.Errorf("cannot convert [%v] to enum representations, only string values are supported in enum literals", reflect.TypeOf(v)) + } + found := false + for _, val := range t.GetEnumType().GetValues() { + if val == newV { + found = true + break + } + } + if !found { + return nil, fmt.Errorf("incorrect enum value [%s], supported values %+v", newV, t.GetEnumType().GetValues()) + } + } + return MakePrimitiveLiteral(newV) + + case *core.LiteralType_UnionType: + // Try different types in the variants, return the first one matched + found := false + for _, subType := range newT.UnionType.Variants { + lv, err := MakeLiteralForType(subType, v) + if err == nil { + l = &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Union{ + Union: &core.Union{ + Value: lv, + Type: subType, + }, + }, + }, + }, + } + found = true + break + } + } + if !found { + return nil, fmt.Errorf("incorrect union value [%s], supported values %+v", v, newT.UnionType.Variants) + } + default: + return nil, fmt.Errorf("unsupported type %s", t.String()) + } + + return l, nil +} diff --git a/flyteidl2/clients/go/coreutils/literals_test.go b/flyteidl2/clients/go/coreutils/literals_test.go new file mode 100644 index 0000000000..fecb19840c --- /dev/null +++ b/flyteidl2/clients/go/coreutils/literals_test.go @@ -0,0 +1,868 @@ +// extract_literal_test.go +// Test class for the utility methods which construct flyte literals. + +package coreutils + +import ( + "fmt" + "os" + "reflect" + "strconv" + "testing" + "time" + + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/go-test/deep" + "github.com/golang/protobuf/ptypes" + structpb "github.com/golang/protobuf/ptypes/struct" + "github.com/pkg/errors" + "github.com/shamaton/msgpack/v2" + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestMakePrimitive(t *testing.T) { + { + v := 1 + p, err := MakePrimitive(v) + assert.NoError(t, err) + assert.Equal(t, "*core.Primitive_Integer", reflect.TypeOf(p.Value).String()) + assert.Equal(t, int64(v), p.GetInteger()) + } + { + v := int64(1) + p, err := MakePrimitive(v) + assert.NoError(t, err) + assert.Equal(t, "*core.Primitive_Integer", reflect.TypeOf(p.Value).String()) + assert.Equal(t, v, p.GetInteger()) + } + { + v := 1.0 + p, err := MakePrimitive(v) + assert.NoError(t, err) + assert.Equal(t, "*core.Primitive_FloatValue", reflect.TypeOf(p.Value).String()) + assert.Equal(t, v, p.GetFloatValue()) + } + { + v := "blah" + p, err := MakePrimitive(v) + assert.NoError(t, err) + assert.Equal(t, "*core.Primitive_StringValue", reflect.TypeOf(p.Value).String()) + assert.Equal(t, v, p.GetStringValue()) + } + { + v := true + p, err := MakePrimitive(v) + assert.NoError(t, err) + assert.Equal(t, "*core.Primitive_Boolean", reflect.TypeOf(p.Value).String()) + assert.Equal(t, v, p.GetBoolean()) + } + { + v := time.Now() + p, err := MakePrimitive(v) + assert.NoError(t, err) + assert.Equal(t, "*core.Primitive_Datetime", reflect.TypeOf(p.Value).String()) + j, err := ptypes.TimestampProto(v) + assert.NoError(t, err) + assert.Equal(t, j, p.GetDatetime()) + _, err = MakePrimitive(time.Date(0, 0, 0, 0, 0, 0, 0, time.UTC)) + assert.Error(t, err) + } + { + v := time.Second * 10 + p, err := MakePrimitive(v) + assert.NoError(t, err) + assert.Equal(t, "*core.Primitive_Duration", reflect.TypeOf(p.Value).String()) + assert.Equal(t, ptypes.DurationProto(v), p.GetDuration()) + } + { + v := struct { + }{} + _, err := MakePrimitive(v) + assert.Error(t, err) + } +} + +func TestMustMakePrimitive(t *testing.T) { + { + v := struct { + }{} + assert.Panics(t, func() { + MustMakePrimitive(v) + }) + } + { + v := time.Second * 10 + p := MustMakePrimitive(v) + assert.Equal(t, "*core.Primitive_Duration", reflect.TypeOf(p.Value).String()) + assert.Equal(t, ptypes.DurationProto(v), p.GetDuration()) + } +} + +func TestMakePrimitiveLiteral(t *testing.T) { + { + v := 1.0 + p, err := MakePrimitiveLiteral(v) + assert.NoError(t, err) + assert.NotNil(t, p.GetScalar()) + assert.Equal(t, "*core.Primitive_FloatValue", reflect.TypeOf(p.GetScalar().GetPrimitive().Value).String()) + assert.Equal(t, v, p.GetScalar().GetPrimitive().GetFloatValue()) + } + { + v := struct { + }{} + _, err := MakePrimitiveLiteral(v) + assert.Error(t, err) + } +} + +func TestMustMakePrimitiveLiteral(t *testing.T) { + t.Run("Panic", func(t *testing.T) { + v := struct { + }{} + assert.Panics(t, func() { + MustMakePrimitiveLiteral(v) + }) + }) + t.Run("FloatValue", func(t *testing.T) { + v := 1.0 + p := MustMakePrimitiveLiteral(v) + assert.NotNil(t, p.GetScalar()) + assert.Equal(t, "*core.Primitive_FloatValue", reflect.TypeOf(p.GetScalar().GetPrimitive().Value).String()) + assert.Equal(t, v, p.GetScalar().GetPrimitive().GetFloatValue()) + }) +} + +func TestMakeLiteral(t *testing.T) { + t.Run("Primitive", func(t *testing.T) { + lit, err := MakeLiteral("test_string") + assert.NoError(t, err) + assert.Equal(t, "*core.Primitive_StringValue", reflect.TypeOf(lit.GetScalar().GetPrimitive().Value).String()) + }) + + t.Run("Array", func(t *testing.T) { + lit, err := MakeLiteral([]interface{}{1, 2, 3}) + assert.NoError(t, err) + assert.Equal(t, "*core.Literal_Collection", reflect.TypeOf(lit.GetValue()).String()) + assert.Equal(t, "*core.Primitive_Integer", reflect.TypeOf(lit.GetCollection().Literals[0].GetScalar().GetPrimitive().Value).String()) + }) + + t.Run("Map", func(t *testing.T) { + lit, err := MakeLiteral(map[string]interface{}{ + "key1": []interface{}{1, 2, 3}, + "key2": []interface{}{5}, + }) + assert.NoError(t, err) + assert.Equal(t, "*core.Literal_Map", reflect.TypeOf(lit.GetValue()).String()) + assert.Equal(t, "*core.Literal_Collection", reflect.TypeOf(lit.GetMap().Literals["key1"].GetValue()).String()) + }) + + t.Run("Binary", func(t *testing.T) { + s := MakeBinaryLiteral([]byte{'h'}) + assert.Equal(t, []byte{'h'}, s.GetScalar().GetBinary().GetValue()) + }) + + t.Run("NoneType", func(t *testing.T) { + p, err := MakeLiteral(nil) + assert.NoError(t, err) + assert.NotNil(t, p.GetScalar()) + assert.Equal(t, "*core.Scalar_NoneType", reflect.TypeOf(p.GetScalar().Value).String()) + }) +} + +func TestMustMakeLiteral(t *testing.T) { + v := "hello" + l := MustMakeLiteral(v) + assert.NotNil(t, l.GetScalar()) + assert.Equal(t, v, l.GetScalar().GetPrimitive().GetStringValue()) +} + +func TestMakeBinaryLiteral(t *testing.T) { + s := MakeBinaryLiteral([]byte{'h'}) + assert.Equal(t, []byte{'h'}, s.GetScalar().GetBinary().GetValue()) +} + +func TestMakeDefaultLiteralForType(t *testing.T) { + type args struct { + name string + ty core.SimpleType + tyName string + isPrimitive bool + } + tests := []args{ + {"None", core.SimpleType_NONE, "*core.Scalar_NoneType", false}, + {"Binary", core.SimpleType_BINARY, "*core.Scalar_Binary", false}, + {"Integer", core.SimpleType_INTEGER, "*core.Primitive_Integer", true}, + {"Float", core.SimpleType_FLOAT, "*core.Primitive_FloatValue", true}, + {"String", core.SimpleType_STRING, "*core.Primitive_StringValue", true}, + {"Boolean", core.SimpleType_BOOLEAN, "*core.Primitive_Boolean", true}, + {"Duration", core.SimpleType_DURATION, "*core.Primitive_Duration", true}, + {"Datetime", core.SimpleType_DATETIME, "*core.Primitive_Datetime", true}, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + l, err := MakeDefaultLiteralForType(&core.LiteralType{Type: &core.LiteralType_Simple{Simple: test.ty}}) + assert.NoError(t, err) + if test.isPrimitive { + assert.Equal(t, test.tyName, reflect.TypeOf(l.GetScalar().GetPrimitive().Value).String()) + } else { + assert.Equal(t, test.tyName, reflect.TypeOf(l.GetScalar().Value).String()) + } + }) + } + + t.Run("Binary", func(t *testing.T) { + s, err := MakeLiteral([]byte{'h'}) + assert.NoError(t, err) + assert.Equal(t, []byte{'h'}, s.GetScalar().GetBinary().GetValue()) + }) + + t.Run("Blob", func(t *testing.T) { + l, err := MakeDefaultLiteralForType(&core.LiteralType{Type: &core.LiteralType_Blob{}}) + assert.NoError(t, err) + assert.Equal(t, "*core.Scalar_Blob", reflect.TypeOf(l.GetScalar().Value).String()) + }) + + t.Run("Collection", func(t *testing.T) { + l, err := MakeDefaultLiteralForType(&core.LiteralType{Type: &core.LiteralType_CollectionType{CollectionType: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}}) + assert.NoError(t, err) + assert.Equal(t, "*core.LiteralCollection", reflect.TypeOf(l.GetCollection()).String()) + }) + + t.Run("Map", func(t *testing.T) { + l, err := MakeDefaultLiteralForType(&core.LiteralType{Type: &core.LiteralType_MapValueType{MapValueType: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}}) + assert.NoError(t, err) + assert.Equal(t, "*core.LiteralMap", reflect.TypeOf(l.GetMap()).String()) + }) + + t.Run("error", func(t *testing.T) { + l, err := MakeDefaultLiteralForType(&core.LiteralType{Type: &core.LiteralType_Simple{ + Simple: core.SimpleType_ERROR, + }}) + assert.NoError(t, err) + assert.NotNil(t, l.GetScalar().GetError()) + }) + + t.Run("binary", func(t *testing.T) { + l, err := MakeDefaultLiteralForType(&core.LiteralType{Type: &core.LiteralType_Simple{ + Simple: core.SimpleType_BINARY, + }}) + assert.NoError(t, err) + assert.NotNil(t, l.GetScalar().GetBinary()) + assert.NotNil(t, l.GetScalar().GetBinary().GetValue()) + assert.NotNil(t, l.GetScalar().GetBinary().GetTag()) + }) + + t.Run("struct", func(t *testing.T) { + l, err := MakeDefaultLiteralForType(&core.LiteralType{Type: &core.LiteralType_Simple{ + Simple: core.SimpleType_STRUCT, + }}) + assert.NoError(t, err) + assert.NotNil(t, l.GetScalar().GetGeneric()) + }) + + t.Run("enum", func(t *testing.T) { + l, err := MakeDefaultLiteralForType(&core.LiteralType{Type: &core.LiteralType_EnumType{ + EnumType: &core.EnumType{Values: []string{"x", "y", "z"}}, + }}) + assert.NoError(t, err) + assert.NotNil(t, l.GetScalar().GetPrimitive().GetStringValue()) + expected := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_StringValue{StringValue: "x"}}}}}} + assert.Equal(t, expected, l) + }) + + t.Run("union", func(t *testing.T) { + l, err := MakeDefaultLiteralForType( + &core.LiteralType{ + Type: &core.LiteralType_UnionType{ + UnionType: &core.UnionType{ + Variants: []*core.LiteralType{ + {Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}, + {Type: &core.LiteralType_Simple{Simple: core.SimpleType_FLOAT}}, + }, + }, + }, + }, + ) + assert.NoError(t, err) + assert.Equal(t, "*core.Union", reflect.TypeOf(l.GetScalar().GetUnion()).String()) + }) +} + +func TestMustMakeDefaultLiteralForType(t *testing.T) { + t.Run("error", func(t *testing.T) { + assert.Panics(t, func() { + MustMakeDefaultLiteralForType(nil) + }) + }) + + t.Run("Blob", func(t *testing.T) { + l := MustMakeDefaultLiteralForType(&core.LiteralType{Type: &core.LiteralType_Blob{}}) + assert.Equal(t, "*core.Scalar_Blob", reflect.TypeOf(l.GetScalar().Value).String()) + }) +} + +func TestMakePrimitiveForType(t *testing.T) { + n := time.Now() + type args struct { + t core.SimpleType + s string + } + tests := []struct { + name string + args args + want *core.Primitive + wantErr bool + }{ + {"error-type", args{core.SimpleType_NONE, "x"}, nil, true}, + + {"error-int", args{core.SimpleType_INTEGER, "x"}, nil, true}, + {"int", args{core.SimpleType_INTEGER, "1"}, MustMakePrimitive(1), false}, + + {"error-bool", args{core.SimpleType_BOOLEAN, "x"}, nil, true}, + {"bool", args{core.SimpleType_BOOLEAN, "true"}, MustMakePrimitive(true), false}, + + {"error-float", args{core.SimpleType_FLOAT, "x"}, nil, true}, + {"float", args{core.SimpleType_FLOAT, "3.1416"}, MustMakePrimitive(3.1416), false}, + + {"string", args{core.SimpleType_STRING, "string"}, MustMakePrimitive("string"), false}, + + {"error-dt", args{core.SimpleType_DATETIME, "x"}, nil, true}, + {"dt", args{core.SimpleType_DATETIME, n.Format(time.RFC3339Nano)}, MustMakePrimitive(n), false}, + + {"error-dur", args{core.SimpleType_DURATION, "x"}, nil, true}, + {"dur", args{core.SimpleType_DURATION, time.Hour.String()}, MustMakePrimitive(time.Hour), false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := MakePrimitiveForType(tt.args.t, tt.args.s) + if (err != nil) != tt.wantErr { + t.Errorf("MakePrimitiveForType() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("MakePrimitiveForType() got = %v, want %v", got, tt.want) + } + }) + } +} + +func TestMakeLiteralForSimpleType(t *testing.T) { + type args struct { + t core.SimpleType + s string + } + tests := []struct { + name string + args args + want *core.Literal + wantErr bool + }{ + {"error-int", args{core.SimpleType_INTEGER, "x"}, nil, true}, + {"int", args{core.SimpleType_INTEGER, "1"}, MustMakeLiteral(1), false}, + + {"error-struct", args{core.SimpleType_STRUCT, "x"}, nil, true}, + {"struct", args{core.SimpleType_STRUCT, `{"x": 1}`}, MustMakeLiteral(&structpb.Struct{Fields: map[string]*structpb.Value{"x": {Kind: &structpb.Value_NumberValue{NumberValue: 1}}}}), false}, + + {"bin", args{core.SimpleType_BINARY, "x"}, MustMakeLiteral([]byte("x")), false}, + + {"error", args{core.SimpleType_ERROR, "err"}, MustMakeLiteral(&core.Error{Message: "err"}), false}, + + {"none", args{core.SimpleType_NONE, "null"}, MustMakeLiteral(nil), false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := MakeLiteralForSimpleType(tt.args.t, tt.args.s) + if (err != nil) != tt.wantErr { + t.Errorf("MakeLiteralForSimpleType() error = %v, wantErr %v", err, tt.wantErr) + return + } + if diff := deep.Equal(tt.want, got); diff != nil { + t.Errorf("MakeLiteralForSimpleType() got = %v, want %v", got, tt.want) + } + }) + } +} + +func TestMakeLiteralForBlob(t *testing.T) { + type args struct { + path storage.DataReference + isDir bool + format string + } + tests := []struct { + name string + args args + want *core.Blob + }{ + {"simple-key", args{path: "/key", isDir: false, format: "xyz"}, &core.Blob{Uri: "/key", Metadata: &core.BlobMetadata{Type: &core.BlobType{Format: "xyz", Dimensionality: core.BlobType_SINGLE}}}}, + {"simple-dir", args{path: "/key", isDir: true, format: "xyz"}, &core.Blob{Uri: "/key", Metadata: &core.BlobMetadata{Type: &core.BlobType{Format: "xyz", Dimensionality: core.BlobType_MULTIPART}}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := MakeLiteralForBlob(tt.args.path, tt.args.isDir, tt.args.format); !reflect.DeepEqual(got.GetScalar().GetBlob(), tt.want) { + t.Errorf("MakeLiteralForBlob() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestMakeLiteralForType(t *testing.T) { + t.Run("SimpleInteger", func(t *testing.T) { + var literalType = &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}} + val, err := MakeLiteralForType(literalType, 1) + assert.NoError(t, err) + literalVal := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_Integer{Integer: 1}}}}}} + expectedVal, _ := ExtractFromLiteral(literalVal) + actualVal, _ := ExtractFromLiteral(val) + assert.Equal(t, expectedVal, actualVal) + }) + + t.Run("IntegerComingInAsFloatOverFlow", func(t *testing.T) { + var literalType = &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}} + _, err := MakeLiteralForType(literalType, 8.888888e+19) + assert.NotNil(t, err) + numError := &strconv.NumError{ + Func: "ParseInt", + Num: "88888880000000000000", + Err: fmt.Errorf("value out of range"), + } + parseIntError := errors.WithMessage(numError, "failed to parse integer value") + assert.Equal(t, errors.WithStack(parseIntError).Error(), err.Error()) + }) + + t.Run("IntegerComingInAsFloat", func(t *testing.T) { + var literalType = &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}} + val, err := MakeLiteralForType(literalType, 8.888888e+18) + assert.NoError(t, err) + literalVal := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_Integer{Integer: 8.888888e+18}}}}}} + expectedVal, _ := ExtractFromLiteral(literalVal) + actualVal, _ := ExtractFromLiteral(val) + assert.Equal(t, expectedVal, actualVal) + }) + + t.Run("SimpleFloat", func(t *testing.T) { + var literalType = &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_FLOAT}} + val, err := MakeLiteralForType(literalType, 1) + assert.NoError(t, err) + literalVal := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_FloatValue{FloatValue: 1.0}}}}}} + expectedVal, _ := ExtractFromLiteral(literalVal) + actualVal, _ := ExtractFromLiteral(val) + assert.Equal(t, expectedVal, actualVal) + }) + + t.Run("Generic", func(t *testing.T) { + os.Setenv(FlyteUseOldDcFormat, "true") + literalVal := map[string]interface{}{ + "x": 1, + "y": "ystringvalue", + } + var literalType = &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_STRUCT}} + lit, err := MakeLiteralForType(literalType, literalVal) + assert.NoError(t, err) + extractedLiteralVal, err := ExtractFromLiteral(lit) + assert.NoError(t, err) + fieldsMap := map[string]*structpb.Value{ + "x": { + Kind: &structpb.Value_NumberValue{NumberValue: 1}, + }, + "y": { + Kind: &structpb.Value_StringValue{StringValue: "ystringvalue"}, + }, + } + expectedStructVal := &structpb.Struct{ + Fields: fieldsMap, + } + extractedStructValue := extractedLiteralVal.(*structpb.Struct) + assert.Equal(t, len(expectedStructVal.Fields), len(extractedStructValue.Fields)) + for key, val := range expectedStructVal.Fields { + assert.Equal(t, val.Kind, extractedStructValue.Fields[key].Kind) + } + os.Unsetenv(FlyteUseOldDcFormat) + }) + + t.Run("SimpleBinary", func(t *testing.T) { + // We compare the deserialized values instead of the raw msgpack bytes because Go does not guarantee the order + // of map keys during serialization. This means that while the serialized bytes may differ, the deserialized + // values should be logically equivalent. + + var literalType = &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_STRUCT}} + v := map[string]interface{}{ + "a": int64(1), + "b": 3.14, + "c": "example_string", + "d": map[string]interface{}{ + "1": int64(100), + "2": int64(200), + }, + "e": map[string]interface{}{ + "a": int64(1), + "b": 3.14, + }, + "f": []string{"a", "b", "c"}, + } + + val, err := MakeLiteralForType(literalType, v) + assert.NoError(t, err) + + msgpackBytes, err := msgpack.Marshal(v) + assert.NoError(t, err) + + literalVal := &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Binary{ + Binary: &core.Binary{ + Value: msgpackBytes, + Tag: MESSAGEPACK, + }, + }, + }, + }, + } + + expectedLiteralVal, err := ExtractFromLiteral(literalVal) + assert.NoError(t, err) + actualLiteralVal, err := ExtractFromLiteral(val) + assert.NoError(t, err) + + // Check if the extracted value is of type *core.Binary (not []byte) + expectedBinary, ok := expectedLiteralVal.(*core.Binary) + assert.True(t, ok, "expectedLiteralVal is not of type *core.Binary") + actualBinary, ok := actualLiteralVal.(*core.Binary) + assert.True(t, ok, "actualLiteralVal is not of type *core.Binary") + + // Now check if the Binary values match + var expectedVal, actualVal map[string]interface{} + err = msgpack.Unmarshal(expectedBinary.Value, &expectedVal) + assert.NoError(t, err) + err = msgpack.Unmarshal(actualBinary.Value, &actualVal) + assert.NoError(t, err) + + // Finally, assert that the deserialized values are equal + assert.Equal(t, expectedVal, actualVal) + }) + + t.Run("ArrayStrings", func(t *testing.T) { + var literalType = &core.LiteralType{Type: &core.LiteralType_CollectionType{ + CollectionType: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_STRING}}}} + strArray := []interface{}{"hello", "world"} + val, err := MakeLiteralForType(literalType, strArray) + assert.NoError(t, err) + literalVal1 := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_StringValue{StringValue: "hello"}}}}}} + literalVal2 := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_StringValue{StringValue: "world"}}}}}} + literalCollection := []*core.Literal{literalVal1, literalVal2} + literalVal := &core.Literal{Value: &core.Literal_Collection{Collection: &core.LiteralCollection{Literals: literalCollection}}} + expectedVal, _ := ExtractFromLiteral(literalVal) + actualVal, _ := ExtractFromLiteral(val) + assert.Equal(t, expectedVal, actualVal) + }) + + t.Run("ArrayOfArrayStringsNotSupported", func(t *testing.T) { + var literalType = &core.LiteralType{Type: &core.LiteralType_CollectionType{ + CollectionType: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_STRING}}}} + strArrayOfArray := [][]interface{}{{"hello1", "world1"}, {"hello2", "world2"}} + _, err := MakeLiteralForType(literalType, strArrayOfArray) + expectedErrorf := fmt.Errorf("collection type expected but found [][]interface {}") + assert.Equal(t, expectedErrorf, err) + }) + + t.Run("ArrayOfArrayStringsTypeErasure", func(t *testing.T) { + var collectionType = &core.LiteralType{Type: &core.LiteralType_CollectionType{ + CollectionType: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_STRING}}}} + var literalType = &core.LiteralType{Type: &core.LiteralType_CollectionType{ + CollectionType: collectionType}} + + createList1 := func() interface{} { + return []interface{}{"hello1", "world1"} + } + createList2 := func() interface{} { + return []interface{}{"hello2", "world2"} + } + createNestedList := func() interface{} { + return []interface{}{createList1(), createList2()} + } + var strArrayOfArray = createNestedList() + val, err := MakeLiteralForType(literalType, strArrayOfArray) + assert.NoError(t, err) + literalVal11 := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_StringValue{StringValue: "hello1"}}}}}} + literalVal12 := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_StringValue{StringValue: "world1"}}}}}} + literalCollection1Val := []*core.Literal{literalVal11, literalVal12} + + literalCollection1 := &core.Literal{Value: &core.Literal_Collection{Collection: &core.LiteralCollection{Literals: literalCollection1Val}}} + + literalVal21 := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_StringValue{StringValue: "hello2"}}}}}} + literalVal22 := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_StringValue{StringValue: "world2"}}}}}} + literalCollection2Val := []*core.Literal{literalVal21, literalVal22} + literalCollection2 := &core.Literal{Value: &core.Literal_Collection{Collection: &core.LiteralCollection{Literals: literalCollection2Val}}} + literalCollection := []*core.Literal{literalCollection1, literalCollection2} + + literalVal := &core.Literal{Value: &core.Literal_Collection{Collection: &core.LiteralCollection{Literals: literalCollection}}} + expectedVal, _ := ExtractFromLiteral(literalVal) + actualVal, _ := ExtractFromLiteral(val) + assert.Equal(t, expectedVal, actualVal) + }) + + t.Run("MapStrings", func(t *testing.T) { + var literalType = &core.LiteralType{Type: &core.LiteralType_MapValueType{ + MapValueType: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_STRING}}}} + mapVal := map[string]interface{}{"hello1": "world1", "hello2": "world2"} + val, err := MakeLiteralForType(literalType, mapVal) + assert.NoError(t, err) + literalVal1 := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_StringValue{StringValue: "world1"}}}}}} + literalVal2 := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_StringValue{StringValue: "world2"}}}}}} + literalMapVal := map[string]*core.Literal{"hello1": literalVal1, "hello2": literalVal2} + literalVal := &core.Literal{Value: &core.Literal_Map{Map: &core.LiteralMap{Literals: literalMapVal}}} + expectedVal, _ := ExtractFromLiteral(literalVal) + actualVal, _ := ExtractFromLiteral(val) + assert.Equal(t, expectedVal, actualVal) + }) + + t.Run("MapArrayOfStringsFail", func(t *testing.T) { + var literalType = &core.LiteralType{Type: &core.LiteralType_MapValueType{ + MapValueType: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_STRING}}}} + strArray := map[string][]interface{}{"hello1": {"world11", "world12"}, "hello2": {"world21", "world22"}} + _, err := MakeLiteralForType(literalType, strArray) + expectedErrorf := fmt.Errorf("map value types can only be of type map[string]interface{}, but found map[string][]interface {}") + assert.Equal(t, expectedErrorf, err) + }) + + t.Run("MapArrayOfStringsTypeErasure", func(t *testing.T) { + var collectionType = &core.LiteralType{Type: &core.LiteralType_CollectionType{ + CollectionType: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_STRING}}}} + var literalType = &core.LiteralType{Type: &core.LiteralType_MapValueType{ + MapValueType: collectionType}} + createList1 := func() interface{} { + return []interface{}{"world11", "world12"} + } + createList2 := func() interface{} { + return []interface{}{"world21", "world22"} + } + strArray := map[string]interface{}{"hello1": createList1(), "hello2": createList2()} + val, err := MakeLiteralForType(literalType, strArray) + assert.NoError(t, err) + literalVal11 := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_StringValue{StringValue: "world11"}}}}}} + literalVal12 := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_StringValue{StringValue: "world12"}}}}}} + literalCollection1 := []*core.Literal{literalVal11, literalVal12} + literalVal1 := &core.Literal{Value: &core.Literal_Collection{Collection: &core.LiteralCollection{Literals: literalCollection1}}} + literalVal21 := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_StringValue{StringValue: "world21"}}}}}} + literalVal22 := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_StringValue{StringValue: "world22"}}}}}} + literalCollection2 := []*core.Literal{literalVal21, literalVal22} + literalVal2 := &core.Literal{Value: &core.Literal_Collection{Collection: &core.LiteralCollection{Literals: literalCollection2}}} + literalMapVal := map[string]*core.Literal{"hello1": literalVal1, "hello2": literalVal2} + literalVal := &core.Literal{Value: &core.Literal_Map{Map: &core.LiteralMap{Literals: literalMapVal}}} + expectedVal, _ := ExtractFromLiteral(literalVal) + actualVal, _ := ExtractFromLiteral(val) + assert.Equal(t, expectedVal, actualVal) + }) + + t.Run("Schema", func(t *testing.T) { + var schemaColumns []*core.SchemaType_SchemaColumn + schemaColumns = append(schemaColumns, &core.SchemaType_SchemaColumn{ + Name: "Price", + Type: core.SchemaType_SchemaColumn_FLOAT, + }) + var literalType = &core.LiteralType{Type: &core.LiteralType_Schema{Schema: &core.SchemaType{ + Columns: schemaColumns, + }}} + + expectedLV := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Schema{ + Schema: &core.Schema{ + Uri: "s3://blah/blah/blah", + Type: &core.SchemaType{ + Columns: schemaColumns, + }, + }, + }, + }}} + lv, err := MakeLiteralForType(literalType, "s3://blah/blah/blah") + assert.NoError(t, err) + + assert.Equal(t, expectedLV, lv) + + expectedVal, err := ExtractFromLiteral(expectedLV) + assert.NoError(t, err) + actualVal, err := ExtractFromLiteral(lv) + assert.NoError(t, err) + assert.Equal(t, expectedVal, actualVal) + }) + + t.Run("Blob", func(t *testing.T) { + var literalType = &core.LiteralType{Type: &core.LiteralType_Blob{Blob: &core.BlobType{ + Dimensionality: core.BlobType_SINGLE, + }}} + expectedLV := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Blob{ + Blob: &core.Blob{ + Uri: "s3://blah/blah/blah", + Metadata: &core.BlobMetadata{ + Type: &core.BlobType{ + Dimensionality: core.BlobType_SINGLE, + }, + }, + }, + }, + }}} + lv, err := MakeLiteralForType(literalType, "s3://blah/blah/blah") + assert.NoError(t, err) + + assert.Equal(t, expectedLV, lv) + + expectedVal, err := ExtractFromLiteral(expectedLV) + assert.NoError(t, err) + actualVal, err := ExtractFromLiteral(lv) + assert.NoError(t, err) + assert.Equal(t, expectedVal, actualVal) + }) + + t.Run("MultipartBlob", func(t *testing.T) { + var literalType = &core.LiteralType{Type: &core.LiteralType_Blob{Blob: &core.BlobType{ + Dimensionality: core.BlobType_MULTIPART, + }}} + expectedLV := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Blob{ + Blob: &core.Blob{ + Uri: "s3://blah/blah/blah", + Metadata: &core.BlobMetadata{ + Type: &core.BlobType{ + Dimensionality: core.BlobType_MULTIPART, + }, + }, + }, + }, + }}} + lv, err := MakeLiteralForType(literalType, "s3://blah/blah/blah") + assert.NoError(t, err) + + assert.Equal(t, expectedLV, lv) + + expectedVal, err := ExtractFromLiteral(expectedLV) + assert.NoError(t, err) + actualVal, err := ExtractFromLiteral(lv) + assert.NoError(t, err) + assert.Equal(t, expectedVal, actualVal) + }) + + t.Run("enumtype-nil", func(t *testing.T) { + var literalType = &core.LiteralType{Type: &core.LiteralType_EnumType{EnumType: &core.EnumType{}}} + _, err := MakeLiteralForType(literalType, nil) + assert.Error(t, err) + _, err = MakeLiteralForType(literalType, "") + assert.Error(t, err) + }) + + t.Run("enumtype-happy", func(t *testing.T) { + var literalType = &core.LiteralType{Type: &core.LiteralType_EnumType{EnumType: &core.EnumType{Values: []string{"x", "y", "z"}}}} + expected := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_StringValue{StringValue: "x"}}}}}} + v, err := MakeLiteralForType(literalType, "x") + assert.NoError(t, err) + assert.Equal(t, expected, v) + _, err = MakeLiteralForType(literalType, "") + assert.Error(t, err) + }) + + t.Run("enumtype-illegal-val", func(t *testing.T) { + var literalType = &core.LiteralType{Type: &core.LiteralType_EnumType{EnumType: &core.EnumType{Values: []string{"x", "y", "z"}}}} + _, err := MakeLiteralForType(literalType, "m") + assert.Error(t, err) + }) + + t.Run("Nil string", func(t *testing.T) { + var literalType = &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_STRING}} + l, err := MakeLiteralForType(literalType, nil) + assert.NoError(t, err) + assert.Equal(t, "", l.GetScalar().GetPrimitive().GetStringValue()) + l, err = MakeLiteralForType(literalType, "") + assert.NoError(t, err) + assert.Equal(t, "", l.GetScalar().GetPrimitive().GetStringValue()) + }) + + t.Run("Structured Data Set", func(t *testing.T) { + var dataSetColumns []*core.StructuredDatasetType_DatasetColumn + dataSetColumns = append(dataSetColumns, &core.StructuredDatasetType_DatasetColumn{ + Name: "Price", + LiteralType: &core.LiteralType{ + Type: &core.LiteralType_Simple{ + Simple: core.SimpleType_FLOAT, + }, + }, + }) + var literalType = &core.LiteralType{Type: &core.LiteralType_StructuredDatasetType{StructuredDatasetType: &core.StructuredDatasetType{ + Columns: dataSetColumns, + Format: "testFormat", + }}} + + expectedLV := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "s3://blah/blah/blah", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Columns: dataSetColumns, + Format: "testFormat", + }, + }, + }, + }, + }}} + lv, err := MakeLiteralForType(literalType, "s3://blah/blah/blah") + assert.NoError(t, err) + + assert.Equal(t, expectedLV, lv) + + expectedVal, err := ExtractFromLiteral(expectedLV) + assert.NoError(t, err) + actualVal, err := ExtractFromLiteral(lv) + assert.NoError(t, err) + assert.Equal(t, expectedVal, actualVal) + }) + + t.Run("Union", func(t *testing.T) { + var literalType = &core.LiteralType{ + Type: &core.LiteralType_UnionType{ + UnionType: &core.UnionType{ + Variants: []*core.LiteralType{ + {Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}, + {Type: &core.LiteralType_Simple{Simple: core.SimpleType_FLOAT}}, + }, + }, + }, + } + expectedLV := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Union{ + Union: &core.Union{ + Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_FLOAT}}, + Value: &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_FloatValue{FloatValue: 0.1}}}}}}, + }, + }, + }}} + lv, err := MakeLiteralForType(literalType, float64(0.1)) + assert.NoError(t, err) + assert.Equal(t, expectedLV, lv) + expectedVal, err := ExtractFromLiteral(expectedLV) + assert.NoError(t, err) + actualVal, err := ExtractFromLiteral(lv) + assert.NoError(t, err) + assert.Equal(t, expectedVal, actualVal) + }) +} diff --git a/flyteidl2/common/authorization.proto b/flyteidl2/common/authorization.proto new file mode 100644 index 0000000000..656083da65 --- /dev/null +++ b/flyteidl2/common/authorization.proto @@ -0,0 +1,94 @@ +syntax = "proto3"; + +package flyteidl2.common; + +import "buf/validate/validate.proto"; +import "flyteidl2/common/identifier.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common"; + +message Organization { + string name = 1 [(buf.validate.field).string.min_len = 1]; +} + +message Domain { + string name = 1; + Organization organization = 2 [(buf.validate.field).required = true]; +} + +message Project { + string name = 1 [(buf.validate.field).string.min_len = 1]; + Domain domain = 2 [(buf.validate.field).required = true]; +} + +message Workflow { + string name = 1 [(buf.validate.field).string.min_len = 1]; + Project project = 2 [(buf.validate.field).required = true]; +} + +message LaunchPlan { + string name = 1 [(buf.validate.field).string.min_len = 1]; + Project project = 2 [(buf.validate.field).required = true]; +} + +message Resource { + oneof resource { + Organization organization = 1; + Domain domain = 2; + Project project = 3; + Workflow workflow = 4; + LaunchPlan launch_plan = 5; + ClusterIdentifier cluster = 6; + } +} + +enum Action { + ACTION_NONE = 0; + ACTION_CREATE = 1 [deprecated = true]; + ACTION_READ = 2 [deprecated = true]; + ACTION_UPDATE = 3 [deprecated = true]; + ACTION_DELETE = 4 [deprecated = true]; + + // Read Flyte workflows, tasks and launch plans + ACTION_VIEW_FLYTE_INVENTORY = 5; + + // View Flyte executions + ACTION_VIEW_FLYTE_EXECUTIONS = 6; + + // Register new versions of Flyte workflows, tasks and launch plans + ACTION_REGISTER_FLYTE_INVENTORY = 7; + + // Create new Flyte workflow and task executions + ACTION_CREATE_FLYTE_EXECUTIONS = 8; + + // Create new projects and update project descriptions + ACTION_ADMINISTER_PROJECT = 9; + + // Add users, roles and update role assignments. + ACTION_MANAGE_PERMISSIONS = 10; + + // Manage billing, account-wide settings + ACTION_ADMINISTER_ACCOUNT = 11; + + // Operations for clusters + ACTION_MANAGE_CLUSTER = 12; + + // Edit execution related attributes, including TASK_RESOURCE, WORKFLOW_EXECUTION_CONFIG, and EXTERNAL_RESOURCE + ACTION_EDIT_EXECUTION_RELATED_ATTRIBUTES = 13; + + // Edit cluster related attributes, including CLUSTER_RESOURCE and CLUSTER_ASSIGNMENT + ACTION_EDIT_CLUSTER_RELATED_ATTRIBUTES = 14; + + // Edit unused attributes, including EXECUTION_QUEUE, EXECUTION_CLUSTER_LABEL, QUALITY_OF_SERVICE_SPECIFICATION, and PLUGIN_OVERRIDE + ACTION_EDIT_UNUSED_ATTRIBUTES = 15; + + // View system logs + ACTION_SUPPORT_SYSTEM_LOGS = 16; +} + +// Defines a set of allowed actions on a specific authorization resource. +message Permission { + Resource resource = 1; + + repeated Action actions = 2; +} diff --git a/flyteidl2/common/configuration.proto b/flyteidl2/common/configuration.proto new file mode 100644 index 0000000000..1d47395336 --- /dev/null +++ b/flyteidl2/common/configuration.proto @@ -0,0 +1,26 @@ +syntax = "proto3"; + +package flyteidl2.common; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common"; + +// The source of an attribute. We may have other sources in the future. +enum AttributesSource { + // The source is unspecified. + SOURCE_UNSPECIFIED = 0; + + // The configuration is a global configuration. + GLOBAL = 1; + + // The configuration is a domain configuration. + DOMAIN = 2; + + // The configuration is a project configuration. + PROJECT = 3; + + // The configuration is a project-domain configuration. + PROJECT_DOMAIN = 4; + + // The configuration is a org configuration. + ORG = 5; +} diff --git a/flyteidl2/common/identifier.proto b/flyteidl2/common/identifier.proto new file mode 100644 index 0000000000..685c396cb2 --- /dev/null +++ b/flyteidl2/common/identifier.proto @@ -0,0 +1,156 @@ +syntax = "proto3"; + +package flyteidl2.common; + +import "buf/validate/validate.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common"; + +message ProjectIdentifier { + string organization = 1 [(buf.validate.field).string.min_len = 1]; + string domain = 2 [(buf.validate.field).string.min_len = 1]; + string name = 3 [(buf.validate.field).string.min_len = 1]; +} + +message ClusterIdentifier { + string organization = 1; + string name = 2 [(buf.validate.field).string.min_len = 1]; +} + +message ClusterPoolIdentifier { + string organization = 1; + string name = 2; +} + +message ClusterConfigIdentifier { + string organization = 1 [(buf.validate.field).string.min_len = 1]; + string id = 2 [(buf.validate.field).string.min_len = 1]; +} + +message ClusterNodepoolIdentifier { + string organization = 1; + string cluster_name = 2 [(buf.validate.field).string.min_len = 1]; + string name = 3 [(buf.validate.field).string.min_len = 1]; +} + +message UserIdentifier { + string subject = 1 [(buf.validate.field).string.min_len = 1]; +} + +message ApplicationIdentifier { + string subject = 1 [(buf.validate.field).string.min_len = 1]; +} + +message RoleIdentifier { + string organization = 1; + + // Unique name for this role within the organization + string name = 2 [(buf.validate.field).string.min_len = 1]; +} + +message OrgIdentifier { + string name = 1 [(buf.validate.field).string = { + min_len: 1 + max_len: 63 + pattern: "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$" + }]; +} + +message ManagedClusterIdentifier { + reserved 1; + string name = 2 [(buf.validate.field).string.min_len = 1]; + OrgIdentifier org = 3 [(buf.validate.field).required = true]; +} + +message PolicyIdentifier { + string organization = 1; + + // Unique name for this policy within the organization + string name = 2 [(buf.validate.field).string.min_len = 1]; +} + +// Unique identifier of a run. +message RunIdentifier { + // Org this run belongs to. + string org = 1 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 63 + ]; + + // Project this run belongs to. + string project = 2 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 63 + ]; + + // Domain this run belongs to. + string domain = 3 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 63 + ]; + + // Name of the run. Must be unique across all runs in this org, project, and domain pairing. + string name = 4 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 30 + ]; +} + +// Unique identifier of an action. +message ActionIdentifier { + // Identifier for the run. + RunIdentifier run = 1 [(buf.validate.field).required = true]; + + // Name of the action. Must be unique within the run. + string name = 2 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 30 + ]; +} + +// Unique identifier of a single action attempt +message ActionAttemptIdentifier { + ActionIdentifier action_id = 1 [(buf.validate.field).required = true]; + + uint32 attempt = 2 [(buf.validate.field).uint32.gt = 0]; +} + +// Identifies trigger within an org, project and domain +message TriggerName { + // Org this trigger belongs to. + string org = 1 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 63 + ]; + + // Project this trigger belongs to. + string project = 2 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 63 + ]; + + // Domain this trigger belongs to. + string domain = 3 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 63 + ]; + + // Unique name of the trigger. + string name = 4 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 255 + ]; + + string task_name = 5 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 255 + ]; +} + +// Identifies a trigger revision within an org, project and domain +message TriggerIdentifier { + TriggerName name = 1 [(buf.validate.field).required = true]; + + // Revision of the trigger. + uint64 revision = 2 [(buf.validate.field).uint64.gt = 0]; +} diff --git a/flyteidl2/common/identity.proto b/flyteidl2/common/identity.proto new file mode 100644 index 0000000000..6340f353e8 --- /dev/null +++ b/flyteidl2/common/identity.proto @@ -0,0 +1,64 @@ +syntax = "proto3"; + +package flyteidl2.common; + +import "buf/validate/validate.proto"; +import "flyteidl2/common/identifier.proto"; +import "flyteidl2/common/policy.proto"; +import "flyteidl2/common/role.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common"; + +// Encapsulates user profile details for a member of an organization. +message User { + UserIdentifier id = 1; + + UserSpec spec = 2; + + repeated Role roles = 3 [deprecated = true]; + + repeated Policy policies = 4; +} + +message UserSpec { + string first_name = 1; + + string last_name = 2; + + string email = 3; + + string organization = 4; + + string user_handle = 5; + + repeated string groups = 6; + + string photo_url = 7; +} + +message Application { + ApplicationIdentifier id = 1; + + AppSpec spec = 2; +} + +message AppSpec { + string name = 1; + + string organization = 2; +} + +message EnrichedIdentity { + oneof principal { + option (buf.validate.oneof).required = true; + User user = 1; + Application application = 2; + } +} + +message Identity { + oneof principal { + common.UserIdentifier user_id = 1; + common.ApplicationIdentifier application_id = 2; + } +} diff --git a/flyteidl2/common/list.proto b/flyteidl2/common/list.proto new file mode 100644 index 0000000000..105f097b03 --- /dev/null +++ b/flyteidl2/common/list.proto @@ -0,0 +1,81 @@ +syntax = "proto3"; + +package flyteidl2.common; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common"; + +// Specifies sort ordering in a list request. +message Sort { + enum Direction { + // By default, fields are sorted in descending order. + DESCENDING = 0; + ASCENDING = 1; + } + + // Indicates an attribute to sort the response values. + // +required + string key = 1; + + // Indicates the direction to apply sort key for response values. + // +optional + Direction direction = 2; +} + +message ListRequest { + // Indicates the number of resources to be returned. + // +required + uint32 limit = 1; + + // In the case of multiple pages of results, the server-provided token can be used to fetch the next page + // in a query. + // +optional + string token = 2; + + // Deprecated, use sort_by_fields instead. + // Specifies how listed entities should be sorted in the response. + // +optional + Sort sort_by = 3 [deprecated = true]; + + // Indicates a list of filters. This field is used for grpc get requests. + // +optional + repeated Filter filters = 4; + + // Indicates a raw list of filters passed as string.This field is used for REST get requests + // +optional + repeated string raw_filters = 5; + + // Specifies how listed entities should be sorted in the response. + // Sort fields are applied in order. + // +optional + repeated Sort sort_by_fields = 6; +} + +message Filter { + enum Function { + EQUAL = 0; + NOT_EQUAL = 1; + GREATER_THAN = 2; + GREATER_THAN_OR_EQUAL = 3; + LESS_THAN = 4; + LESS_THAN_OR_EQUAL = 5; + CONTAINS = 6; // Case sensitive contains function. + VALUE_IN = 7; + + // NOT_CONTAINS = 8; + // VALUE_NOT_IN = 9; + // STARTS_WITH = 10; + // NOT_STARTS_WITH = 11; + + ENDS_WITH = 12; + NOT_ENDS_WITH = 13; + CONTAINS_CASE_INSENSITIVE = 14; // Case insensitive contains function. + } + + Function function = 1; + + // e.g. name or version + string field = 2; + + // Only in the case of a VALUE_IN function, values may contain multiple entries. + repeated string values = 3; +} diff --git a/flyteidl2/common/phase.proto b/flyteidl2/common/phase.proto new file mode 100644 index 0000000000..6713f85dd6 --- /dev/null +++ b/flyteidl2/common/phase.proto @@ -0,0 +1,38 @@ +syntax = "proto3"; + +package flyteidl2.common; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common"; + +// ActionPhase represents the execution state of an action. +// +// Phase transitions follow this typical flow: +// QUEUED -> WAITING_FOR_RESOURCES -> INITIALIZING -> RUNNING -> {SUCCEEDED|FAILED|ABORTED|TIMED_OUT} +enum ActionPhase { + // Default/unknown phase + ACTION_PHASE_UNSPECIFIED = 0; + + // Action has been accepted and is waiting to be scheduled + ACTION_PHASE_QUEUED = 1; + + // Action is scheduled but waiting for compute resources to become available + ACTION_PHASE_WAITING_FOR_RESOURCES = 2; + + // Resources have been allocated and the action is being set up + ACTION_PHASE_INITIALIZING = 3; + + // Action is actively executing + ACTION_PHASE_RUNNING = 4; + + // Action completed successfully + ACTION_PHASE_SUCCEEDED = 5; + + // Action failed during execution + ACTION_PHASE_FAILED = 6; + + // Action was manually terminated or cancelled + ACTION_PHASE_ABORTED = 7; + + // Action exceeded its execution time limit + ACTION_PHASE_TIMED_OUT = 8; +} diff --git a/flyteidl2/common/policy.proto b/flyteidl2/common/policy.proto new file mode 100644 index 0000000000..bf3fbc2402 --- /dev/null +++ b/flyteidl2/common/policy.proto @@ -0,0 +1,27 @@ +syntax = "proto3"; + +package flyteidl2.common; + +import "buf/validate/validate.proto"; +import "flyteidl2/common/authorization.proto"; +import "flyteidl2/common/identifier.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common"; + +// A policy is a collection of roles bound to a resource. +message Policy { + PolicyIdentifier id = 1 [(buf.validate.field).required = true]; + + repeated PolicyBinding bindings = 2; + + // Optional: human readable description + string description = 3; +} + +// A policy binding represents a role (a set of actions) defined on a resource. +message PolicyBinding { + // The role designates the permitted set of actions which can be applied to the resource. + RoleIdentifier role_id = 1 [(buf.validate.field).required = true]; + + common.Resource resource = 2 [(buf.validate.field).required = true]; +} diff --git a/flyteidl2/common/role.proto b/flyteidl2/common/role.proto new file mode 100644 index 0000000000..67e67dd966 --- /dev/null +++ b/flyteidl2/common/role.proto @@ -0,0 +1,58 @@ +syntax = "proto3"; + +package flyteidl2.common; + +import "buf/validate/validate.proto"; +import "flyteidl2/common/authorization.proto"; +import "flyteidl2/common/identifier.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common"; + +// A role type is a short-hand for understanding the permissions associated with a role. +// Boilerplate role types include a conventional collection of permissions +// Custom role types include a user-defined collection of permissions +enum RoleType { + // Default group. Not used in practice. + ROLE_TYPE_NONE = 0; + // The admin role has a collective set of permissions to do everything + ROLE_TYPE_ADMIN = 1; + // The contributor role has a collective set of permissions to view inventory, view executions, write inventory and create executions + ROLE_TYPE_CONTRIBUTOR = 2; + // The viewer role has a collective set of permissions to view inventory and view executions + ROLE_TYPE_VIEWER = 3; + + // Represent a role with user-defined sets of permissions. + ROLE_TYPE_CUSTOM = 4; + + // The role with permissions to administer a specific customer cluster. + ROLE_TYPE_CLUSTER_MANAGER = 5; + + // Role with permissions specific to administer flyte project(s). + ROLE_TYPE_FLYTE_PROJECT_ADMIN = 6; + + // The viewer role for serverless + ROLE_TYPE_SERVERLESS_VIEWER = 7; + + // The contributor role for serverless + ROLE_TYPE_SERVERLESS_CONTRIBUTOR = 8; + + // The support role would have contributor permissions plus the access to support endpoints + ROLE_TYPE_SUPPORT = 9; +} + +message Role { + RoleIdentifier id = 1 [(buf.validate.field).required = true]; + + repeated Permission permissions = 2 [deprecated = true]; + + RoleSpec role_spec = 3; + + RoleType role_type = 4; + + repeated Action actions = 5; +} + +message RoleSpec { + // Optional, human readable description for this role. + string description = 1; +} diff --git a/flyteidl2/common/runtime_version.proto b/flyteidl2/common/runtime_version.proto new file mode 100644 index 0000000000..8196b82f4e --- /dev/null +++ b/flyteidl2/common/runtime_version.proto @@ -0,0 +1,24 @@ +syntax = "proto3"; + +package flyteidl2.common; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common"; + +// Runtime information. This is loosely defined to allow for extensibility. +message RuntimeMetadata { + enum RuntimeType { + OTHER = 0; + FLYTE_SDK = 1; + UNION_SDK = 2; + } + + // Type of runtime. + RuntimeType type = 1; + + // Version of the runtime. All versions should be backward compatible. However, certain cases call for version + // checks to ensure tighter validation or setting expectations. + string version = 2; + + //+optional It can be used to provide extra information about the runtime (e.g. python, golang... etc.). + string flavor = 3; +} diff --git a/flyteidl2/connector/connector.proto b/flyteidl2/connector/connector.proto new file mode 100644 index 0000000000..577038a85c --- /dev/null +++ b/flyteidl2/connector/connector.proto @@ -0,0 +1,221 @@ +syntax = "proto3"; + +package flyteidl2.connector; + +import "flyteidl2/core/execution.proto"; +import "flyteidl2/core/identifier.proto"; +import "flyteidl2/core/metrics.proto"; +import "flyteidl2/core/security.proto"; +import "flyteidl2/core/tasks.proto"; +import "flyteidl2/task/common.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/struct.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector"; + +// Represents a subset of runtime task execution metadata that are relevant to external plugins. +message TaskExecutionMetadata { + // ID of the task execution + + core.TaskExecutionIdentifier task_execution_id = 1; + // k8s namespace where the task is executed in + string namespace = 2; + // Labels attached to the task execution + map labels = 3; + // Annotations attached to the task execution + map annotations = 4; + // k8s service account associated with the task execution + string k8s_service_account = 5; + // Environment variables attached to the task execution + map environment_variables = 6; + // Represents the maximum number of attempts allowed for a task. + // If a task fails, it can be retried up to this maximum number of attempts. + int32 max_attempts = 7; + // Indicates whether the task execution can be interrupted. + // If set to true, the task can be stopped before completion. + bool interruptible = 8; + // Specifies the threshold for failure count at which the interruptible property + // will take effect. If the number of consecutive task failures exceeds this threshold, + // interruptible behavior will be activated. + int32 interruptible_failure_threshold = 9; + // Identity of user running this task execution + core.Identity identity = 11; +} + +// Represents a request structure to create task. +message CreateTaskRequest { + // The inputs required to start the execution. All required inputs must be + // included in this map. If not required and not provided, defaults apply. + // +optional + task.Inputs inputs = 1; + // Template of the task that encapsulates all the metadata of the task. + core.TaskTemplate template = 2; + // Prefix for where task output data will be written. (e.g. s3://my-bucket/randomstring) + string output_prefix = 3; + // subset of runtime task execution metadata. + TaskExecutionMetadata task_execution_metadata = 4; + // Connection (secret and config) required by the connector. + // Connector will use the secret and config in the taskTemplate if it's None. + // +optional + core.Connection connection = 5; +} + +// Represents a create response structure. +message CreateTaskResponse { + // ResourceMeta is created by the connector. It could be a string (jobId) or a dict (more complex metadata). + bytes resource_meta = 1; +} + +message CreateRequestHeader { + // Template of the task that encapsulates all the metadata of the task. + core.TaskTemplate template = 1; + // Prefix for where task output data will be written. (e.g. s3://my-bucket/randomstring) + string output_prefix = 2; + // subset of runtime task execution metadata. + TaskExecutionMetadata task_execution_metadata = 3; + // MaxDatasetSizeBytes is the maximum size of the dataset that can be generated by the task. + int64 max_dataset_size_bytes = 4; + // Connection (secret and config) required by the connector. + // Connector will use the secret and config in the taskTemplate if it's None. + // +optional + core.Connection connection = 5; +} + +// A message used to fetch a job resource from flyte connector server. +message GetTaskRequest { + // Metadata about the resource to be pass to the connector. + bytes resource_meta = 2; + // A predefined yet extensible Task type identifier. + TaskCategory task_category = 3; + // Prefix for where task output data will be written. (e.g. s3://my-bucket/randomstring) + string output_prefix = 4; + // Connection (secret and config) required by the connector. + // Connector will use the secret and config in the taskTemplate if it's None. + // +optional + core.Connection connection = 5; +} + +// Response to get an individual task resource. +message GetTaskResponse { + Resource resource = 1; +} + +message Resource { + // The outputs of the execution. It's typically used by sql task. connector service will create a + // Structured dataset pointing to the query result table. + // +optional + task.Outputs outputs = 2; + // A descriptive message for the current state. e.g. waiting for cluster. + string message = 3; + // log information for the task execution. + repeated core.TaskLog log_links = 4; + // The phase of the execution is used to determine the phase of the plugin's execution. + core.TaskExecution.Phase phase = 5; + // Custom data specific to the connector. + google.protobuf.Struct custom_info = 6; +} + +// A message used to delete a task. +message DeleteTaskRequest { + // Metadata about the resource to be pass to the connector. + bytes resource_meta = 2; + // A predefined yet extensible Task type identifier. + TaskCategory task_category = 3; + // Connection (secret and config) required by the connector. + // Connector will use the secret and config in the taskTemplate if it's None. + // +optional + core.Connection connection = 5; +} + +// Response to delete a task. +message DeleteTaskResponse {} + +// A message containing the connector metadata. +message Connector { + // Name is the developer-assigned name of the connector. + string name = 1; + // Supported_task_categories are the categories of the tasks that the connector can handle. + repeated TaskCategory supported_task_categories = 4; +} + +message TaskCategory { + // The name of the task type. + string name = 1; + // The version of the task type. + int32 version = 2; +} + +// A request to get an connector. +message GetConnectorRequest { + // The name of the connector. + string name = 1; +} + +// A response containing an connector. +message GetConnectorResponse { + Connector connector = 1; +} + +// A request to list all connectors. +message ListConnectorsRequest {} + +// A response containing a list of connectors. +message ListConnectorsResponse { + repeated Connector connectors = 1; +} + +// A request to get the metrics from a task execution. +message GetTaskMetricsRequest { + // Metadata is created by the connector. It could be a string (jobId) or a dict (more complex metadata). + bytes resource_meta = 2; + // The metrics to query. If empty, will return a default set of metrics. + // e.g. EXECUTION_METRIC_USED_CPU_AVG or EXECUTION_METRIC_USED_MEMORY_BYTES_AVG + repeated string queries = 3; + // Start timestamp, inclusive. + google.protobuf.Timestamp start_time = 4; + // End timestamp, inclusive.. + google.protobuf.Timestamp end_time = 5; + // Query resolution step width in duration format or float number of seconds. + google.protobuf.Duration step = 6; + // A predefined yet extensible Task type identifier. + TaskCategory task_category = 7; +} + +// A response containing a list of metrics for a task execution. +message GetTaskMetricsResponse { + // The execution metric results. + repeated core.ExecutionMetricResult results = 1; +} + +// A request to get the log from a task execution. +message GetTaskLogsRequest { + // Metadata is created by the connector. It could be a string (jobId) or a dict (more complex metadata). + bytes resource_meta = 2; + // Number of lines to return. + uint64 lines = 3; + // In the case of multiple pages of results, the server-provided token can be used to fetch the next page + // in a query. If there are no more results, this value will be empty. + string token = 4; + // A predefined yet extensible Task type identifier. + TaskCategory task_category = 5; +} + +message GetTaskLogsResponseHeader { + // In the case of multiple pages of results, the server-provided token can be used to fetch the next page + // in a query. If there are no more results, this value will be empty. + string token = 1; +} + +message GetTaskLogsResponseBody { + // The execution log results. + repeated string results = 1; +} + +// A response containing the logs for a task execution. +message GetTaskLogsResponse { + oneof part { + GetTaskLogsResponseHeader header = 1; + GetTaskLogsResponseBody body = 2; + } +} diff --git a/flyteidl2/connector/service.proto b/flyteidl2/connector/service.proto new file mode 100644 index 0000000000..23d6bb9467 --- /dev/null +++ b/flyteidl2/connector/service.proto @@ -0,0 +1,56 @@ +syntax = "proto3"; +package flyteidl2.connector; + +import "flyteidl2/connector/connector.proto"; +import "google/api/annotations.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector"; + +// AsyncConnectorService defines an RPC Service that allows executor to send the request to the connector server asynchronously. +service AsyncConnectorService { + // CreateTask sends a task create request to the connector service. + rpc CreateTask(flyteidl2.connector.CreateTaskRequest) returns (flyteidl2.connector.CreateTaskResponse) { + option (google.api.http) = { + post: "/api/v1/connector/task" + body: "*" + }; + } + + // Get job status. + rpc GetTask(flyteidl2.connector.GetTaskRequest) returns (flyteidl2.connector.GetTaskResponse) { + option (google.api.http) = {get: "/api/v1/connector/task/{task_category.name}/{task_category.version}/{resource_meta}"}; + } + + // Delete the task resource. + rpc DeleteTask(flyteidl2.connector.DeleteTaskRequest) returns (flyteidl2.connector.DeleteTaskResponse) { + option (google.api.http) = {delete: "/api/v1/connector/task_executions/{task_category.name}/{task_category.version}/{resource_meta}"}; + } + + // GetTaskMetrics returns one or more task execution metrics, if available. + // + // Errors include + // * OutOfRange if metrics are not available for the specified task time range + // * various other errors + rpc GetTaskMetrics(flyteidl2.connector.GetTaskMetricsRequest) returns (flyteidl2.connector.GetTaskMetricsResponse) { + option (google.api.http) = {get: "/api/v1/connector/task/metrics/{task_category.name}/{task_category.version}/{resource_meta}"}; + } + + // GetTaskLogs returns task execution logs, if available. + rpc GetTaskLogs(flyteidl2.connector.GetTaskLogsRequest) returns (stream flyteidl2.connector.GetTaskLogsResponse) { + option (google.api.http) = {get: "/api/v1/connector/task/logs/{task_category.name}/{task_category.version}/{resource_meta}"}; + } +} + +// ConnectorMetadataService defines an RPC service that is also served over HTTP via grpc-gateway. +// This service allows executor or users to get the metadata of connectors. +service ConnectorMetadataService { + // Fetch a :ref:`ref_flyteidl2.plugins.Connector` definition. + rpc GetConnector(flyteidl2.connector.GetConnectorRequest) returns (flyteidl2.connector.GetConnectorResponse) { + option (google.api.http) = {get: "/api/v1/connector/{name}"}; + } + + // Fetch a list of :ref:`ref_flyteidl2.plugins.Connector` definitions. + rpc ListConnectors(flyteidl2.connector.ListConnectorsRequest) returns (flyteidl2.connector.ListConnectorsResponse) { + option (google.api.http) = {get: "/api/v1/connectors"}; + } +} diff --git a/flyteidl2/core/artifact_id.proto b/flyteidl2/core/artifact_id.proto new file mode 100644 index 0000000000..a86707f934 --- /dev/null +++ b/flyteidl2/core/artifact_id.proto @@ -0,0 +1,110 @@ +syntax = "proto3"; + +package flyteidl2.core; + +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core"; + +message ArtifactKey { + // Project and domain and suffix needs to be unique across a given artifact store. + string project = 1; + string domain = 2; + string name = 3; + string org = 4; +} + +// Only valid for triggers +message ArtifactBindingData { + reserved 1 to 4; + // These two fields are only relevant in the partition value case + oneof partition_data { + string partition_key = 5; + bool bind_to_time_partition = 6; + } + + // This is only relevant in the time partition case + TimeTransform time_transform = 7; +} + +enum Granularity { + UNSET = 0; + MINUTE = 1; + HOUR = 2; + DAY = 3; // default + MONTH = 4; +} + +enum Operator { + MINUS = 0; + PLUS = 1; +} + +message TimeTransform { + string transform = 1; + Operator op = 2; +} + +message InputBindingData { + string var = 1; +} + +message RuntimeBinding {} + +message LabelValue { + oneof value { + // The string static value is for use in the Partitions object + string static_value = 1; + + // The time value is for use in the TimePartition case + google.protobuf.Timestamp time_value = 2; + ArtifactBindingData triggered_binding = 3; + InputBindingData input_binding = 4; + RuntimeBinding runtime_binding = 5; + } +} + +message Partitions { + map value = 1; +} + +message TimePartition { + LabelValue value = 1; + Granularity granularity = 2; +} + +message ArtifactID { + ArtifactKey artifact_key = 1; + + string version = 2; + + // Think of a partition as a tag on an Artifact, except it's a key-value pair. + // Different partitions naturally have different versions (execution ids). + Partitions partitions = 3; + + // There is no such thing as an empty time partition - if it's not set, then there is no time partition. + TimePartition time_partition = 4; +} + +message ArtifactTag { + ArtifactKey artifact_key = 1; + + LabelValue value = 2; +} + +// Uniqueness constraints for Artifacts +// - project, domain, name, version, partitions +// Option 2 (tags are standalone, point to an individual artifact id): +// - project, domain, name, alias (points to one partition if partitioned) +// - project, domain, name, partition key, partition value +message ArtifactQuery { + oneof identifier { + ArtifactID artifact_id = 1; + ArtifactTag artifact_tag = 2; + string uri = 3; + + // This is used in the trigger case, where a user specifies a value for an input that is one of the triggering + // artifacts, or a partition value derived from a triggering artifact. + ArtifactBindingData binding = 4; + } +} diff --git a/flyteidl2/core/catalog.proto b/flyteidl2/core/catalog.proto new file mode 100644 index 0000000000..f01523c815 --- /dev/null +++ b/flyteidl2/core/catalog.proto @@ -0,0 +1,63 @@ +syntax = "proto3"; + +package flyteidl2.core; + +import "flyteidl2/core/identifier.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core"; + +// Indicates the status of CatalogCaching. The reason why this is not embedded in TaskNodeMetadata is, that we may use for other types of nodes as well in the future +enum CatalogCacheStatus { + // Used to indicate that caching was disabled + CACHE_DISABLED = 0; + // Used to indicate that the cache lookup resulted in no matches + CACHE_MISS = 1; + // used to indicate that the associated artifact was a result of a previous execution + CACHE_HIT = 2; + // used to indicate that the resultant artifact was added to the cache + CACHE_POPULATED = 3; + // Used to indicate that cache lookup failed because of an error + CACHE_LOOKUP_FAILURE = 4; + // Used to indicate that cache lookup failed because of an error + CACHE_PUT_FAILURE = 5; + // Used to indicate the cache lookup was skipped + CACHE_SKIPPED = 6; + // Used to indicate that the cache was evicted + CACHE_EVICTED = 7; +} + +message CatalogArtifactTag { + // Artifact ID is generated name + string artifact_id = 1; + // Flyte computes the tag automatically, as the hash of the values + string name = 2; +} + +// Catalog artifact information with specific metadata +message CatalogMetadata { + // Dataset ID in the catalog + Identifier dataset_id = 1; + // Artifact tag in the catalog + CatalogArtifactTag artifact_tag = 2; + // Optional: Source Execution identifier, if this dataset was generated by another execution in Flyte. This is a one-of field and will depend on the caching context + oneof source_execution { + // Today we only support TaskExecutionIdentifier as a source, as catalog caching only works for task executions + TaskExecutionIdentifier source_task_execution = 3; + } +} + +message CatalogReservation { + // Indicates the status of a catalog reservation operation. + enum Status { + // Used to indicate that reservations are disabled + RESERVATION_DISABLED = 0; + // Used to indicate that a reservation was successfully acquired or extended + RESERVATION_ACQUIRED = 1; + // Used to indicate that an active reservation currently exists + RESERVATION_EXISTS = 2; + // Used to indicate that the reservation has been successfully released + RESERVATION_RELEASED = 3; + // Used to indicate that a reservation operation resulted in failure + RESERVATION_FAILURE = 4; + } +} diff --git a/flyteidl2/core/errors.proto b/flyteidl2/core/errors.proto new file mode 100644 index 0000000000..417f1f6e32 --- /dev/null +++ b/flyteidl2/core/errors.proto @@ -0,0 +1,35 @@ +syntax = "proto3"; + +package flyteidl2.core; + +import "flyteidl2/core/execution.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core"; + +// Error message to propagate detailed errors from container executions to the execution +// engine. +message ContainerError { + // A simplified code for errors, so that we can provide a glossary of all possible errors. + string code = 1; + // A detailed error message. + string message = 2; + + // Defines a generic error type that dictates the behavior of the retry strategy. + enum Kind { + NON_RECOVERABLE = 0; + RECOVERABLE = 1; + } + + // An abstract error kind for this error. Defaults to Non_Recoverable if not specified. + Kind kind = 3; + + // Defines the origin of the error (system, user, unknown). + ExecutionError.ErrorKind origin = 4; +} + +// Defines the errors.pb file format the container can produce to communicate +// failure reasons to the execution engine. +message ErrorDocument { + // The error raised during execution. + ContainerError error = 1; +} diff --git a/flyteidl2/core/execution.proto b/flyteidl2/core/execution.proto new file mode 100644 index 0000000000..f5c1970f25 --- /dev/null +++ b/flyteidl2/core/execution.proto @@ -0,0 +1,166 @@ +syntax = "proto3"; + +package flyteidl2.core; + +import "google/protobuf/duration.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core"; + +// Indicates various phases of Workflow Execution +message WorkflowExecution { + enum Phase { + UNDEFINED = 0; + QUEUED = 1; + RUNNING = 2; + SUCCEEDING = 3; + SUCCEEDED = 4; + FAILING = 5; + FAILED = 6; + ABORTED = 7; + TIMED_OUT = 8; + ABORTING = 9; + } +} + +// Indicates various phases of Node Execution that only include the time spent to run the nodes/workflows +message NodeExecution { + enum Phase { + UNDEFINED = 0; + QUEUED = 1; + RUNNING = 2; + SUCCEEDED = 3; + FAILING = 4; + FAILED = 5; + ABORTED = 6; + SKIPPED = 7; + TIMED_OUT = 8; + DYNAMIC_RUNNING = 9; + RECOVERED = 10; + } +} + +// Phases that task plugins can go through. Not all phases may be applicable to a specific plugin task, +// but this is the cumulative list that customers may want to know about for their task. +message TaskExecution { + enum Phase { + UNDEFINED = 0; + QUEUED = 1; + RUNNING = 2; + SUCCEEDED = 3; + ABORTED = 4; + FAILED = 5; + // To indicate cases where task is initializing, like: ErrImagePull, ContainerCreating, PodInitializing + INITIALIZING = 6; + // To address cases, where underlying resource is not available: Backoff error, Resource quota exceeded + WAITING_FOR_RESOURCES = 7; + RETRYABLE_FAILED = 8; + } +} + +// Represents the error message from the execution. +message ExecutionError { + // Error code indicates a grouping of a type of error. + // More Info: + string code = 1; + // Detailed description of the error - including stack trace. + string message = 2; + // Full error contents accessible via a URI + string error_uri = 3; + // Error type: System or User + enum ErrorKind { + UNKNOWN = 0; + USER = 1; + SYSTEM = 2; + } + ErrorKind kind = 4; + // Timestamp of the error + google.protobuf.Timestamp timestamp = 5; + // Worker that generated the error + string worker = 6; +} + +// Log information for the task that is specific to a log sink +// When our log story is flushed out, we may have more metadata here like log link expiry +message TaskLog { + enum MessageFormat { + UNKNOWN = 0; + CSV = 1; + JSON = 2; + } + + enum LinkType { + // The link for task log. For example, the aws cloudwatch logs, gcp stackdriver logs, etc. + EXTERNAL = 0; + // The link for spark UI, ray dashboard, etc. + DASHBOARD = 1; + // The link for vscode or other IDEs. + IDE = 2; + } + + string uri = 1; + string name = 2; + MessageFormat message_format = 3; + google.protobuf.Duration ttl = 4; + bool ShowWhilePending = 5; + bool HideOnceFinished = 6; + LinkType link_type = 7; + bool ready = 8; + string icon_uri = 9; +} + +// Contains metadata required to identify logs produces by a set of pods +message LogContext { + repeated PodLogContext pods = 1; + string primary_pod_name = 2; +} + +// Contains metadata required to identify logs produces by a single pod +message PodLogContext { + string namespace = 1; + + string pod_name = 2; + + repeated ContainerContext containers = 3; + + string primary_container_name = 4; + + repeated ContainerContext init_containers = 5; +} + +// Contains metadata required to identify logs produces by a single container +message ContainerContext { + string container_name = 1; + + // Contains metadata required to identify logs produces by a single light-weight process that was run inside a container + message ProcessContext { + google.protobuf.Timestamp container_start_time = 1; + google.protobuf.Timestamp container_end_time = 2; + } + + ProcessContext process = 2; +} + +// Represents customized execution run-time attributes. +message QualityOfServiceSpec { + // Indicates how much queueing delay an execution can tolerate. + google.protobuf.Duration queueing_budget = 1; + + // Add future, user-configurable options here +} + +// Indicates the priority of an execution. +message QualityOfService { + enum Tier { + // Default: no quality of service specified. + UNDEFINED = 0; + HIGH = 1; + MEDIUM = 2; + LOW = 3; + } + + oneof designation { + Tier tier = 1; + QualityOfServiceSpec spec = 2; + } +} diff --git a/flyteidl2/core/identifier.proto b/flyteidl2/core/identifier.proto new file mode 100644 index 0000000000..522c01eb60 --- /dev/null +++ b/flyteidl2/core/identifier.proto @@ -0,0 +1,80 @@ +syntax = "proto3"; + +package flyteidl2.core; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core"; + +// Indicates a resource type within Flyte. +enum ResourceType { + UNSPECIFIED = 0; + TASK = 1; + WORKFLOW = 2; + LAUNCH_PLAN = 3; + // A dataset represents an entity modeled in Flyte DataCatalog. A Dataset is also a versioned entity and can be a compilation of multiple individual objects. + // Eventually all Catalog objects should be modeled similar to Flyte Objects. The Dataset entities makes it possible for the UI and CLI to act on the objects + // in a similar manner to other Flyte objects + DATASET = 4; +} + +// Encapsulation of fields that uniquely identifies a Flyte resource. +message Identifier { + // Identifies the specific type of resource that this identifier corresponds to. + core.ResourceType resource_type = 1; + + // Name of the project the resource belongs to. + string project = 2; + + // Name of the domain the resource belongs to. + // A domain can be considered as a subset within a specific project. + string domain = 3; + + // User provided value for the resource. + string name = 4; + + // Specific version of the resource. + string version = 5; + + // Optional, org key applied to the resource. + string org = 6; +} + +// Encapsulation of fields that uniquely identifies a Flyte workflow execution +message WorkflowExecutionIdentifier { + // Name of the project the resource belongs to. + string project = 1; + + // Name of the domain the resource belongs to. + // A domain can be considered as a subset within a specific project. + string domain = 2; + + // User or system provided value for the resource. + string name = 4; + + // Optional, org key applied to the resource. + string org = 5; +} + +// Encapsulation of fields that identify a Flyte node execution entity. +message NodeExecutionIdentifier { + string node_id = 1; + + WorkflowExecutionIdentifier execution_id = 2; +} + +// Encapsulation of fields that identify a Flyte task execution entity. +message TaskExecutionIdentifier { + core.Identifier task_id = 1; + + core.NodeExecutionIdentifier node_execution_id = 2; + + uint32 retry_attempt = 3; +} + +// Encapsulation of fields the uniquely identify a signal. +message SignalIdentifier { + // Unique identifier for a signal. + string signal_id = 1; + + // Identifies the Flyte workflow execution this signal belongs to. + WorkflowExecutionIdentifier execution_id = 2; +} diff --git a/flyteidl2/core/interface.proto b/flyteidl2/core/interface.proto new file mode 100644 index 0000000000..226cc43031 --- /dev/null +++ b/flyteidl2/core/interface.proto @@ -0,0 +1,64 @@ +syntax = "proto3"; + +package flyteidl2.core; + +import "flyteidl2/core/artifact_id.proto"; +import "flyteidl2/core/literals.proto"; +import "flyteidl2/core/types.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core"; + +// Defines a strongly typed variable. +message Variable { + // Variable literal type. + LiteralType type = 1; + + //+optional string describing input variable + string description = 2; + + //+optional This object allows the user to specify how Artifacts are created. + // name, tag, partitions can be specified. The other fields (version and project/domain) are ignored. + core.ArtifactID artifact_partial_id = 3; + + core.ArtifactTag artifact_tag = 4; +} + +// A map of Variables +message VariableMap { + // Defines a map of variable names to variables. + map variables = 1; +} + +// Defines strongly typed inputs and outputs. +message TypedInterface { + VariableMap inputs = 1; + VariableMap outputs = 2; +} + +// A parameter is used as input to a launch plan and has +// the special ability to have a default value or mark itself as required. +message Parameter { + //+required Variable. Defines the type of the variable backing this parameter. + Variable var = 1; + + //+optional + oneof behavior { + // Defines a default value that has to match the variable type defined. + Literal default = 2; + + //+optional, is this value required to be filled. + bool required = 3; + + // This is an execution time search basically that should result in exactly one Artifact with a Type that + // matches the type of the variable. + core.ArtifactQuery artifact_query = 4; + + core.ArtifactID artifact_id = 5; + } +} + +// A map of Parameters. +message ParameterMap { + // Defines a map of parameter names to parameters. + map parameters = 1; +} diff --git a/flyteidl2/core/literals.proto b/flyteidl2/core/literals.proto new file mode 100644 index 0000000000..a8fa64ebb8 --- /dev/null +++ b/flyteidl2/core/literals.proto @@ -0,0 +1,204 @@ +syntax = "proto3"; + +package flyteidl2.core; + +import "flyteidl2/core/types.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/struct.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core"; + +// Primitive Types +message Primitive { + // Defines one of simple primitive types. These types will get translated into different programming languages as + // described in https://developers.google.com/protocol-buffers/docs/proto#scalar. + oneof value { + int64 integer = 1; + double float_value = 2; + string string_value = 3; + bool boolean = 4; + google.protobuf.Timestamp datetime = 5; + google.protobuf.Duration duration = 6; + } +} + +// Used to denote a nil/null/None assignment to a scalar value. The underlying LiteralType for Void is intentionally +// undefined since it can be assigned to a scalar of any LiteralType. +message Void {} + +// Refers to an offloaded set of files. It encapsulates the type of the store and a unique uri for where the data is. +// There are no restrictions on how the uri is formatted since it will depend on how to interact with the store. +message Blob { + BlobMetadata metadata = 1; + string uri = 3; +} + +message BlobMetadata { + BlobType type = 1; +} + +// A simple byte array with a tag to help different parts of the system communicate about what is in the byte array. +// It's strongly advisable that consumers of this type define a unique tag and validate the tag before parsing the data. +message Binary { + bytes value = 1; // Serialized data (MessagePack) for supported types like Dataclass, Pydantic BaseModel, and untyped dict. + string tag = 2; // The serialization format identifier (e.g., MessagePack). Consumers must define unique tags and validate them before deserialization. +} + +// A strongly typed schema that defines the interface of data retrieved from the underlying storage medium. +message Schema { + string uri = 1; + SchemaType type = 3; +} + +// The runtime representation of a tagged union value. See `UnionType` for more details. +message Union { + Literal value = 1; + LiteralType type = 2; +} + +message StructuredDatasetMetadata { + // Bundle the type information along with the literal. + // This is here because StructuredDatasets can often be more defined at run time than at compile time. + // That is, at compile time you might only declare a task to return a pandas dataframe or a StructuredDataset, + // without any column information, but at run time, you might have that column information. + // flytekit python will copy this type information into the literal, from the type information, if not provided by + // the various plugins (encoders). + // Since this field is run time generated, it's not used for any type checking. + StructuredDatasetType structured_dataset_type = 1; +} + +message StructuredDataset { + // String location uniquely identifying where the data is. + // Should start with the storage location (e.g. s3://, gs://, bq://, etc.) + string uri = 1; + + StructuredDatasetMetadata metadata = 2; +} + +message Scalar { + oneof value { + Primitive primitive = 1; + Blob blob = 2; + Binary binary = 3; + Schema schema = 4; + Void none_type = 5; + Error error = 6; + google.protobuf.Struct generic = 7; + StructuredDataset structured_dataset = 8; + Union union = 9; + } +} + +// A simple value. This supports any level of nesting (e.g. array of array of array of Blobs) as well as simple primitives. +message Literal { + reserved 6, 7; + oneof value { + // A simple value. + Scalar scalar = 1; + + // A collection of literals to allow nesting. + LiteralCollection collection = 2; + + // A map of strings to literals. + LiteralMap map = 3; + + // Offloaded literal metadata + // When you deserialize the offloaded metadata, it would be of Literal and its type would be defined by LiteralType stored in offloaded_metadata. + LiteralOffloadedMetadata offloaded_metadata = 8; + } + + // A hash representing this literal. + // This is used for caching purposes. For more details refer to RFC 1893 + // (https://github.com/flyteorg/flyte/blob/master/rfc/system/1893-caching-of-offloaded-objects.md) + string hash = 4; + + // Additional metadata for literals. + map metadata = 5; +} + +// A message that contains the metadata of the offloaded data. +message LiteralOffloadedMetadata { + // The location of the offloaded core.Literal. + string uri = 1; + + // The size of the offloaded data. + uint64 size_bytes = 2; + + // The inferred literal type of the offloaded data. + LiteralType inferred_type = 3; +} + +// A collection of literals. This is a workaround since oneofs in proto messages cannot contain a repeated field. +message LiteralCollection { + repeated Literal literals = 1; +} + +// A map of literals. This is a workaround since oneofs in proto messages cannot contain a repeated field. +message LiteralMap { + map literals = 1; +} + +// A collection of BindingData items. +message BindingDataCollection { + repeated BindingData bindings = 1; +} + +// A map of BindingData items. +message BindingDataMap { + map bindings = 1; +} + +message UnionInfo { + LiteralType targetType = 1; +} + +// Specifies either a simple value or a reference to another output. +message BindingData { + oneof value { + // A simple scalar value. + Scalar scalar = 1; + + // A collection of binding data. This allows nesting of binding data to any number + // of levels. + BindingDataCollection collection = 2; + + // References an output promised by another node. + OutputReference promise = 3; + + // A map of bindings. The key is always a string. + BindingDataMap map = 4; + + // Offloaded literal metadata + // When you deserialize the offloaded metadata, it would be of Literal and its type would be defined by LiteralType stored in offloaded_metadata. + // Used for nodes that don't have promises from upstream nodes such as ArrayNode subNodes. + LiteralOffloadedMetadata offloaded_metadata = 6; + } + + UnionInfo union = 5; +} + +// An input/output binding of a variable to either static value or a node output. +message Binding { + // Variable name must match an input/output variable of the node. + string var = 1; + + // Data to use to bind this variable. + BindingData binding = 2; +} + +// A generic key value pair. +message KeyValuePair { + //required. + string key = 1; + + //+optional. + string value = 2; +} + +// Retry strategy associated with an executable unit. +message RetryStrategy { + // Number of retries. Retries will be consumed when the job fails with a recoverable error. + // The number of retries must be less than or equals to 10. + uint32 retries = 5; +} diff --git a/flyteidl2/core/metrics.proto b/flyteidl2/core/metrics.proto new file mode 100644 index 0000000000..30c270e731 --- /dev/null +++ b/flyteidl2/core/metrics.proto @@ -0,0 +1,20 @@ +syntax = "proto3"; + +package flyteidl2.core; + +import "google/protobuf/struct.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core"; + +// ExecutionMetrics is a collection of metrics that are collected during the execution of a Flyte task. +message ExecutionMetricResult { + // The metric this data represents. e.g. EXECUTION_METRIC_USED_CPU_AVG or EXECUTION_METRIC_USED_MEMORY_BYTES_AVG. + string metric = 1; + + // The result data in prometheus range query result format + // https://prometheus.io/docs/prometheus/latest/querying/api/#expression-query-result-formats. + // This may include multiple time series, differentiated by their metric labels. + // Start time is greater of (execution attempt start, 48h ago) + // End time is lesser of (execution attempt end, now) + google.protobuf.Struct data = 2; +} diff --git a/flyteidl2/core/security.proto b/flyteidl2/core/security.proto new file mode 100644 index 0000000000..e89f8c8f60 --- /dev/null +++ b/flyteidl2/core/security.proto @@ -0,0 +1,148 @@ +syntax = "proto3"; + +package flyteidl2.core; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core"; + +// Secret encapsulates information about the secret a task needs to proceed. An environment variable +// FLYTE_SECRETS_ENV_PREFIX will be passed to indicate the prefix of the environment variables that will be present if +// secrets are passed through environment variables. +// FLYTE_SECRETS_DEFAULT_DIR will be passed to indicate the prefix of the path where secrets will be mounted if secrets +// are passed through file mounts. +message Secret { + enum MountType { + // Default case, indicates the client can tolerate either mounting options. + ANY = 0; + + // ENV_VAR indicates the secret needs to be mounted as an environment variable. + ENV_VAR = 1; + + // FILE indicates the secret needs to be mounted as a file. + FILE = 2; + } + + // The name of the secret group where to find the key referenced below. For K8s secrets, this should be the name of + // the v1/secret object. For Confidant, this should be the Credential name. For Vault, this should be the secret name. + // For AWS Secret Manager, this should be the name of the secret. + // +required + string group = 1; + + // The group version to fetch. This is not supported in all secret management systems. It'll be ignored for the ones + // that do not support it. + // +optional + string group_version = 2; + + // The name of the secret to mount. This has to match an existing secret in the system. It's up to the implementation + // of the secret management system to require case sensitivity. For K8s secrets, Confidant and Vault, this should + // match one of the keys inside the secret. For AWS Secret Manager, it's ignored. + // +optional + string key = 3; + + // mount_requirement is optional. Indicates where the secret has to be mounted. If provided, the execution will fail + // if the underlying key management system cannot satisfy that requirement. If not provided, the default location + // will depend on the key management system. + // +optional + MountType mount_requirement = 4; + + // env_var is optional. Custom environment variable to set the value of the secret. If mount_requirement is ENV_VAR, + // then the value is the secret itself. If mount_requirement is FILE, then the value is the path to the secret file. + // +optional + string env_var = 5; +} + +message Connection { + // The task type that the connection is used for. + string task_type = 1; + // The credentials to use for the connection, such as API keys, OAuth2 tokens, etc. + // The key is the name of the secret, and it's defined in the flytekit. + // flytekit uses the key to locate the desired secret within the map. + map secrets = 2; + + // The configuration to use for the connection, such as the endpoint, account name, etc. + // The key is the name of the config, and it's defined in the flytekit. + map configs = 3; +} + +// OAuth2Client encapsulates OAuth2 Client Credentials to be used when making calls on behalf of that task. +message OAuth2Client { + // client_id is the public id for the client to use. The system will not perform any pre-auth validation that the + // secret requested matches the client_id indicated here. + // +required + string client_id = 1; + + // client_secret is a reference to the secret used to authenticate the OAuth2 client. + // +required + Secret client_secret = 2; +} + +// Identity encapsulates the various security identities a task can run as. It's up to the underlying plugin to pick the +// right identity for the execution environment. +message Identity { + // iam_role references the fully qualified name of Identity & Access Management role to impersonate. + string iam_role = 1; + + // k8s_service_account references a kubernetes service account to impersonate. + string k8s_service_account = 2; + + // oauth2_client references an oauth2 client. Backend plugins can use this information to impersonate the client when + // making external calls. + OAuth2Client oauth2_client = 3; + + // execution_identity references the subject who makes the execution + string execution_identity = 4; +} + +// OAuth2TokenRequest encapsulates information needed to request an OAuth2 token. +// FLYTE_TOKENS_ENV_PREFIX will be passed to indicate the prefix of the environment variables that will be present if +// tokens are passed through environment variables. +// FLYTE_TOKENS_PATH_PREFIX will be passed to indicate the prefix of the path where secrets will be mounted if tokens +// are passed through file mounts. +message OAuth2TokenRequest { + // Type of the token requested. + enum Type { + // CLIENT_CREDENTIALS indicates a 2-legged OAuth token requested using client credentials. + CLIENT_CREDENTIALS = 0; + } + + // name indicates a unique id for the token request within this task token requests. It'll be used as a suffix for + // environment variables and as a filename for mounting tokens as files. + // +required + string name = 1; + + // type indicates the type of the request to make. Defaults to CLIENT_CREDENTIALS. + // +required + Type type = 2; + + // client references the client_id/secret to use to request the OAuth2 token. + // +required + OAuth2Client client = 3; + + // idp_discovery_endpoint references the discovery endpoint used to retrieve token endpoint and other related + // information. + // +optional + string idp_discovery_endpoint = 4; + + // token_endpoint references the token issuance endpoint. If idp_discovery_endpoint is not provided, this parameter is + // mandatory. + // +optional + string token_endpoint = 5; +} + +// SecurityContext holds security attributes that apply to tasks. +message SecurityContext { + // run_as encapsulates the identity a pod should run as. If the task fills in multiple fields here, it'll be up to the + // backend plugin to choose the appropriate identity for the execution engine the task will run on. + Identity run_as = 1; + + // secrets indicate the list of secrets the task needs in order to proceed. Secrets will be mounted/passed to the + // pod as it starts. If the plugin responsible for kicking of the task will not run it on a flyte cluster (e.g. AWS + // Batch), it's the responsibility of the plugin to fetch the secret (which means propeller identity will need access + // to the secret) and to pass it to the remote execution engine. + repeated Secret secrets = 2; + + // tokens indicate the list of token requests the task needs in order to proceed. Tokens will be mounted/passed to the + // pod as it starts. If the plugin responsible for kicking of the task will not run it on a flyte cluster (e.g. AWS + // Batch), it's the responsibility of the plugin to fetch the secret (which means propeller identity will need access + // to the secret) and to pass it to the remote execution engine. + repeated OAuth2TokenRequest tokens = 3; +} diff --git a/flyteidl2/core/tasks.proto b/flyteidl2/core/tasks.proto new file mode 100644 index 0000000000..c328cbe97d --- /dev/null +++ b/flyteidl2/core/tasks.proto @@ -0,0 +1,414 @@ +syntax = "proto3"; + +package flyteidl2.core; + +import "flyteidl2/core/execution.proto"; +import "flyteidl2/core/identifier.proto"; +import "flyteidl2/core/interface.proto"; +import "flyteidl2/core/literals.proto"; +import "flyteidl2/core/security.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/struct.proto"; +import "google/protobuf/wrappers.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core"; + +// A customizable interface to convey resources requested for a container. This can be interpreted differently for different +// container engines. +message Resources { + // Known resource names. + enum ResourceName { + UNKNOWN = 0; + CPU = 1; + GPU = 2; + MEMORY = 3; + STORAGE = 4; + // For Kubernetes-based deployments, pods use ephemeral local storage for scratch space, caching, and for logs. + EPHEMERAL_STORAGE = 5; + } + + // Encapsulates a resource name and value. + message ResourceEntry { + // Resource name. + ResourceName name = 1; + + // Value must be a valid k8s quantity. See + // https://github.com/kubernetes/apimachinery/blob/master/pkg/api/resource/quantity.go#L30-L80 + string value = 2; + } + + // The desired set of resources requested. ResourceNames must be unique within the list. + repeated ResourceEntry requests = 1; + + // Defines a set of bounds (e.g. min/max) within which the task can reliably run. ResourceNames must be unique + // within the list. + repeated ResourceEntry limits = 2; +} + +// Metadata associated with the GPU accelerator to allocate to a task. Contains +// information about device type, and for multi-instance GPUs, the partition size to +// use. +message GPUAccelerator { + // Specifies the class of accelerator device. + enum DeviceClass { + // NVIDIA GPU devices (default for backward compatibility) + NVIDIA_GPU = 0; + // Google TPU devices + GOOGLE_TPU = 1; + // Amazon Neuron devices + AMAZON_NEURON = 2; + // AMD GPU devices + AMD_GPU = 3; + // Habana Gaudi devices + HABANA_GAUDI = 4; + } + + // This can be any arbitrary string, and should be informed by the labels or taints + // associated with the nodes in question. Default cloud provider labels typically + // use the following values: `nvidia-tesla-t4`, `nvidia-tesla-a100`, etc. + string device = 1; + oneof partition_size_value { + bool unpartitioned = 2; + // Like `device`, this can be any arbitrary string, and should be informed by + // the labels or taints associated with the nodes in question. Default cloud + // provider labels typically use the following values: `1g.5gb`, `2g.10gb`, etc. + string partition_size = 3; + } + // The class of accelerator device. Defaults to NVIDIA_GPU if not specified. + DeviceClass device_class = 4; +} + +// Metadata associated with configuring a shared memory volume for a task. +message SharedMemory { + // Mount path to place in container + string mount_path = 1; + // Name for volume + string mount_name = 2; + // Size limit for shared memory. If not set, then the shared memory is equal + // to the allocated memory. + // +optional + string size_limit = 3; +} + +// Encapsulates all non-standard resources, not captured by v1.ResourceRequirements, to +// allocate to a task. +message ExtendedResources { + // GPU accelerator to select for task. Contains information about device type, and + // for multi-instance GPUs, the partition size to use. + GPUAccelerator gpu_accelerator = 1; + SharedMemory shared_memory = 2; +} + +// Runtime information. This is loosely defined to allow for extensibility. +message RuntimeMetadata { + enum RuntimeType { + OTHER = 0; + FLYTE_SDK = 1; + } + + // Type of runtime. + RuntimeType type = 1; + + // Version of the runtime. All versions should be backward compatible. However, certain cases call for version + // checks to ensure tighter validation or setting expectations. + string version = 2; + + //+optional It can be used to provide extra information about the runtime (e.g. python, golang... etc.). + string flavor = 3; +} + +// Task Metadata +message TaskMetadata { + // Field number 10 is reserved because we are reusing the name generates_deck for field number 15, + // but with a different type. + reserved 10; + + // Indicates whether the system should attempt to lookup this task's output to avoid duplication of work. + bool discoverable = 1; + + // Runtime information about the task. + RuntimeMetadata runtime = 2; + + // The overall timeout of a task including user-triggered retries. + google.protobuf.Duration timeout = 4; + + // Number of retries per task. + RetryStrategy retries = 5; + + // Indicates a logical version to apply to this task for the purpose of discovery. + string discovery_version = 6; + + // If set, this indicates that this task is deprecated. This will enable owners of tasks to notify consumers + // of the ending of support for a given task. + string deprecated_error_message = 7; + + // For interruptible we will populate it at the node level but require it be part of TaskMetadata + // for a user to set the value. + // We are using oneof instead of bool because otherwise we would be unable to distinguish between value being + // set by the user or defaulting to false. + // The logic of handling precedence will be done as part of flytepropeller. + + // Identify whether task is interruptible + oneof interruptible_value { + bool interruptible = 8; + } + + // Indicates whether the system should attempt to execute discoverable instances in serial to avoid duplicate work + bool cache_serializable = 9; + + // Arbitrary tags that allow users and the platform to store small but arbitrary labels + map tags = 11; + + // pod_template_name is the unique name of a PodTemplate k8s resource to be used as the base configuration if this + // task creates a k8s Pod. If this value is set, the specified PodTemplate will be used instead of, but applied + // identically as, the default PodTemplate configured in FlytePropeller. + string pod_template_name = 12; + + // cache_ignore_input_vars is the input variables that should not be included when calculating hash for cache. + repeated string cache_ignore_input_vars = 13; + // is_eager indicates whether the task is eager or not. + // This would be used by CreateTask endpoint. + bool is_eager = 14; + + // Indicates whether the task will generate a deck when it finishes executing. + // The BoolValue can have three states: + // - nil: The value is not set. + // - true: The task will generate a deck. + // - false: The task will not generate a deck. + google.protobuf.BoolValue generates_deck = 15; + + // Metadata applied to task pods or task CR objects. + // In flytekit, labels and annotations resulting in this metadata field + // are provided via `@task(labels=..., annotations=...)`. + // For tasks backed by pods like PythonFunctionTask, these take precedence + // over the metadata provided via `@task(pod_template=PodTemplate(labels=...))` which are transported + // in the K8sPod message. For tasks backed by CRDs, this metadata is applied to + // the CR object itself while the metadata in the pod template/K8sPod is applied + // to the pod template spec of the CR object. + K8sObjectMetadata metadata = 16; + + // Whether the task is able to run the debugger (vscode server) inside the task container. + bool debuggable = 17; + + // Log links associated with this task. + repeated core.TaskLog log_links = 18; +} + +// A Task structure that uniquely identifies a task in the system +// Tasks are registered as a first step in the system. +message TaskTemplate { + // Auto generated taskId by the system. Task Id uniquely identifies this task globally. + Identifier id = 1; + + // A predefined yet extensible Task type identifier. This can be used to customize any of the components. If no + // extensions are provided in the system, Flyte will resolve the this task to its TaskCategory and default the + // implementation registered for the TaskCategory. + string type = 2; + + // Extra metadata about the task. + TaskMetadata metadata = 3; + + // A strongly typed interface for the task. This enables others to use this task within a workflow and guarantees + // compile-time validation of the workflow to avoid costly runtime failures. + TypedInterface interface = 4; + + // Custom data about the task. This is extensible to allow various plugins in the system. + google.protobuf.Struct custom = 5; + + // Known target types that the system will guarantee plugins for. Custom SDK plugins are allowed to set these if needed. + // If no corresponding execution-layer plugins are found, the system will default to handling these using built-in + // handlers. + oneof target { + Container container = 6; + K8sPod k8s_pod = 17; + Sql sql = 18; + } + + // This can be used to customize task handling at execution time for the same task type. + int32 task_type_version = 7; + + // security_context encapsulates security attributes requested to run this task. + SecurityContext security_context = 8; + + // Encapsulates all non-standard resources, not captured by + // v1.ResourceRequirements, to allocate to a task. + ExtendedResources extended_resources = 9; + + // Metadata about the custom defined for this task. This is extensible to allow various plugins in the system + // to use as required. + // reserve the field numbers 1 through 15 for very frequently occurring message elements + map config = 16; +} + +// ----------------- First class Plugins + +// Defines port properties for a container. +message ContainerPort { + // Number of port to expose on the pod's IP address. + // This must be a valid port number, 0 < x < 65536. + uint32 container_port = 1; + // Name of the port to expose on the pod's IP address. + string name = 2; +} + +message Container { + // Container image url. Eg: docker/redis:latest + string image = 1; + + // Command to be executed, if not provided, the default entrypoint in the container image will be used. + repeated string command = 2; + + // These will default to Flyte given paths. If provided, the system will not append known paths. If the task still + // needs flyte's inputs and outputs path, add $(FLYTE_INPUT_FILE), $(FLYTE_OUTPUT_FILE) wherever makes sense and the + // system will populate these before executing the container. + repeated string args = 3; + + // Container resources requirement as specified by the container engine. + Resources resources = 4; + + // Environment variables will be set as the container is starting up. + repeated KeyValuePair env = 5; + + // Allows extra configs to be available for the container. + // TODO: elaborate on how configs will become available. + // Deprecated, please use TaskTemplate.config instead. + repeated KeyValuePair config = 6 [deprecated = true]; + + // Ports to open in the container. This feature is not supported by all execution engines. (e.g. supported on K8s but + // not supported on AWS Batch) + // Only K8s + repeated ContainerPort ports = 7; + + // BETA: Optional configuration for DataLoading. If not specified, then default values are used. + // This makes it possible to to run a completely portable container, that uses inputs and outputs + // only from the local file-system and without having any reference to flyteidl. This is supported only on K8s at the moment. + // If data loading is enabled, then data will be mounted in accompanying directories specified in the DataLoadingConfig. If the directories + // are not specified, inputs will be mounted onto and outputs will be uploaded from a pre-determined file-system path. Refer to the documentation + // to understand the default paths. + // Only K8s + DataLoadingConfig data_config = 9; + + // Architecture-type the container image supports. + enum Architecture { + UNKNOWN = 0; + AMD64 = 1; + ARM64 = 2; + ARM_V6 = 3; + ARM_V7 = 4; + } + Architecture architecture = 10; +} + +// Strategy to use when dealing with Blob, Schema, or multipart blob data (large datasets) +message IOStrategy { + // Mode to use for downloading + enum DownloadMode { + // All data will be downloaded before the main container is executed + DOWNLOAD_EAGER = 0; + // Data will be downloaded as a stream and an End-Of-Stream marker will be written to indicate all data has been downloaded. Refer to protocol for details + DOWNLOAD_STREAM = 1; + // Large objects (offloaded) will not be downloaded + DO_NOT_DOWNLOAD = 2; + } + // Mode to use for uploading + enum UploadMode { + // All data will be uploaded after the main container exits + UPLOAD_ON_EXIT = 0; + // Data will be uploaded as it appears. Refer to protocol specification for details + UPLOAD_EAGER = 1; + // Data will not be uploaded, only references will be written + DO_NOT_UPLOAD = 2; + } + // Mode to use to manage downloads + DownloadMode download_mode = 1; + // Mode to use to manage uploads + UploadMode upload_mode = 2; +} + +// This configuration allows executing raw containers in Flyte using the Flyte CoPilot system. +// Flyte CoPilot, eliminates the needs of flytekit or sdk inside the container. Any inputs required by the users container are side-loaded in the input_path +// Any outputs generated by the user container - within output_path are automatically uploaded. +message DataLoadingConfig { + // LiteralMapFormat decides the encoding format in which the input metadata should be made available to the containers. + // If the user has access to the protocol buffer definitions, it is recommended to use the PROTO format. + // JSON and YAML do not need any protobuf definitions to read it + // All remote references in core.LiteralMap are replaced with local filesystem references (the data is downloaded to local filesystem) + enum LiteralMapFormat { + // JSON / YAML for the metadata (which contains inlined primitive values). The representation is inline with the standard json specification as specified - https://www.json.org/json-en.html + JSON = 0; + YAML = 1; + // Proto is a serialized binary of `core.LiteralMap` defined in flyteidl/core + PROTO = 2; + } + // Flag enables DataLoading Config. If this is not set, data loading will not be used! + bool enabled = 1; + // File system path (start at root). This folder will contain all the inputs exploded to a separate file. + // Example, if the input interface needs (x: int, y: blob, z: multipart_blob) and the input path is '/var/flyte/inputs', then the file system will look like + // /var/flyte/inputs/inputs. .pb .json .yaml> -> Format as defined previously. The Blob and Multipart blob will reference local filesystem instead of remote locations + // /var/flyte/inputs/x -> X is a file that contains the value of x (integer) in string format + // /var/flyte/inputs/y -> Y is a file in Binary format + // /var/flyte/inputs/z/... -> Note Z itself is a directory + // More information about the protocol - refer to docs #TODO reference docs here + string input_path = 2; + // File system path (start at root). This folder should contain all the outputs for the task as individual files and/or an error text file + string output_path = 3; + // In the inputs folder, there will be an additional summary/metadata file that contains references to all files or inlined primitive values. + // This format decides the actual encoding for the data. Refer to the encoding to understand the specifics of the contents and the encoding + LiteralMapFormat format = 4; + IOStrategy io_strategy = 5; +} + +// Defines a pod spec and additional pod metadata that is created when a task is executed. +message K8sPod { + // Contains additional metadata for building a kubernetes pod. + K8sObjectMetadata metadata = 1; + + // Defines the primary pod spec created when a task is executed. + // This should be a JSON-marshalled pod spec, which can be defined in + // - go, using: https://github.com/kubernetes/api/blob/release-1.21/core/v1/types.go#L2936 + // - python: using https://github.com/kubernetes-client/python/blob/release-19.0/kubernetes/client/models/v1_pod_spec.py + google.protobuf.Struct pod_spec = 2; + + // BETA: Optional configuration for DataLoading. If not specified, then default values are used. + // This makes it possible to to run a completely portable container, that uses inputs and outputs + // only from the local file-system and without having any reference to flytekit. This is supported only on K8s at the moment. + // If data loading is enabled, then data will be mounted in accompanying directories specified in the DataLoadingConfig. If the directories + // are not specified, inputs will be mounted onto and outputs will be uploaded from a pre-determined file-system path. Refer to the documentation + // to understand the default paths. + // Only K8s + DataLoadingConfig data_config = 3; + + // Defines the primary container name when pod template override is executed. + string primary_container_name = 4; +} + +// Metadata for building a kubernetes object when a task is executed. +message K8sObjectMetadata { + // Optional labels to add to the pod definition. + map labels = 1; + + // Optional annotations to add to the pod definition. + map annotations = 2; +} + +// Sql represents a generic sql workload with a statement and dialect. +message Sql { + // The actual query to run, the query can have templated parameters. + // We use Flyte's Golang templating format for Query templating. + // For example, + // insert overwrite directory '{{ .rawOutputDataPrefix }}' stored as parquet + // select * + // from my_table + // where ds = '{{ .Inputs.ds }}' + string statement = 1; + // The dialect of the SQL statement. This is used to validate and parse SQL statements at compilation time to avoid + // expensive runtime operations. If set to an unsupported dialect, no validation will be done on the statement. + // We support the following dialect: ansi, hive. + enum Dialect { + UNDEFINED = 0; + ANSI = 1; + HIVE = 2; + OTHER = 3; + } + Dialect dialect = 2; +} diff --git a/flyteidl2/core/types.proto b/flyteidl2/core/types.proto new file mode 100644 index 0000000000..c21bbc2920 --- /dev/null +++ b/flyteidl2/core/types.proto @@ -0,0 +1,208 @@ +syntax = "proto3"; + +package flyteidl2.core; + +import "google/protobuf/struct.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core"; + +// Define a set of simple types. +enum SimpleType { + NONE = 0; + INTEGER = 1; + FLOAT = 2; + STRING = 3; + BOOLEAN = 4; + DATETIME = 5; + DURATION = 6; + BINARY = 7; + ERROR = 8; + STRUCT = 9; +} + +// Defines schema columns and types to strongly type-validate schemas interoperability. +message SchemaType { + message SchemaColumn { + // A unique name -within the schema type- for the column + string name = 1; + + enum SchemaColumnType { + INTEGER = 0; + FLOAT = 1; + STRING = 2; + BOOLEAN = 3; + DATETIME = 4; + DURATION = 5; + } + + // The column type. This allows a limited set of types currently. + SchemaColumnType type = 2; + } + + // A list of ordered columns this schema comprises of. + repeated SchemaColumn columns = 3; +} + +message StructuredDatasetType { + message DatasetColumn { + // A unique name within the schema type for the column. + string name = 1; + + // The column type. + LiteralType literal_type = 2; + } + + // A list of ordered columns this schema comprises of. + repeated DatasetColumn columns = 1; + + // This is the storage format, the format of the bits at rest + // parquet, feather, csv, etc. + // For two types to be compatible, the format will need to be an exact match. + string format = 2; + + // This is a string representing the type that the bytes in external_schema_bytes are formatted in. + // This is an optional field that will not be used for type checking. + string external_schema_type = 3; + + // The serialized bytes of a third-party schema library like Arrow. + // This is an optional field that will not be used for type checking. + bytes external_schema_bytes = 4; +} + +// Defines type behavior for blob objects +message BlobType { + enum BlobDimensionality { + SINGLE = 0; + MULTIPART = 1; + } + + // Format can be a free form string understood by SDK/UI etc like + // csv, parquet etc + string format = 1; + BlobDimensionality dimensionality = 2; +} + +// Enables declaring enum types, with predefined string values +// For len(values) > 0, the first value in the ordered list is regarded as the default value. If you wish +// To provide no defaults, make the first value as undefined. +message EnumType { + // Predefined set of enum values. + repeated string values = 1; +} + +// Defines a tagged union type, also known as a variant (and formally as the sum type). +// +// A sum type S is defined by a sequence of types (A, B, C, ...), each tagged by a string tag +// A value of type S is constructed from a value of any of the variant types. The specific choice of type is recorded by +// storing the varaint's tag with the literal value and can be examined in runtime. +// +// Type S is typically written as +// S := Apple A | Banana B | Cantaloupe C | ... +// +// Notably, a nullable (optional) type is a sum type between some type X and the singleton type representing a null-value: +// Optional X := X | Null +// +// See also: https://en.wikipedia.org/wiki/Tagged_union +message UnionType { + // Predefined set of variants in union. + repeated LiteralType variants = 1; +} + +// Hints to improve type matching +// e.g. allows distinguishing output from custom type transformers +// even if the underlying IDL serialization matches. +message TypeStructure { + // Must exactly match for types to be castable + string tag = 1; + // dataclass_type only exists for dataclasses. + // This is used to resolve the type of the fields of dataclass + // The key is the field name, and the value is the literal type of the field + // e.g. For dataclass Foo, with fields a, and a is a string + // Foo.a will be resolved as a literal type of string from dataclass_type + map dataclass_type = 2; +} + +// TypeAnnotation encapsulates registration time information about a type. This can be used for various control-plane operations. TypeAnnotation will not be available at runtime when a task runs. +message TypeAnnotation { + // A arbitrary JSON payload to describe a type. + google.protobuf.Struct annotations = 1; +} + +// Defines a strong type to allow type checking between interfaces. +message LiteralType { + oneof type { + // A simple type that can be compared one-to-one with another. + SimpleType simple = 1; + + // A complex type that requires matching of inner fields. + SchemaType schema = 2; + + // Defines the type of the value of a collection. Only homogeneous collections are allowed. + LiteralType collection_type = 3; + + // Defines the type of the value of a map type. The type of the key is always a string. + LiteralType map_value_type = 4; + + // A blob might have specialized implementation details depending on associated metadata. + BlobType blob = 5; + + // Defines an enum with pre-defined string values. + EnumType enum_type = 7; + + // Generalized schema support + StructuredDatasetType structured_dataset_type = 8; + + // Defines an union type with pre-defined LiteralTypes. + UnionType union_type = 10; + } + + // This field contains type metadata that is descriptive of the type, but is NOT considered in type-checking. This might be used by + // consumers to identify special behavior or display extended information for the type. + google.protobuf.Struct metadata = 6; + + // This field contains arbitrary data that might have special semantic + // meaning for the client but does not effect internal flyte behavior. + TypeAnnotation annotation = 9; + + // Hints to improve type matching. + TypeStructure structure = 11; +} + +// A reference to an output produced by a node. The type can be retrieved -and validated- from +// the underlying interface of the node. +message OutputReference { + // Node id must exist at the graph layer. + string node_id = 1; + + // Variable name must refer to an output variable for the node. + string var = 2; + + repeated PromiseAttribute attr_path = 3; +} + +// PromiseAttribute stores the attribute path of a promise, which will be resolved at runtime. +// The attribute path is a list of strings and integers. +// In the following example, +// ``` +// @workflow +// def wf(): +// o = t1() +// t2(o.a["b"][0]) +// ``` +// the output reference t2 binds to has a list of PromiseAttribute ["a", "b", 0] + +message PromiseAttribute { + oneof value { + string string_value = 1; + int32 int_value = 2; + } +} + +// Represents an error thrown from a node. +message Error { + // The node id that threw the error. + string failed_node_id = 1; + + // Error message thrown. + string message = 2; +} diff --git a/flyteidl2/dataproxy/dataproxy_service.proto b/flyteidl2/dataproxy/dataproxy_service.proto new file mode 100644 index 0000000000..7219e1c60f --- /dev/null +++ b/flyteidl2/dataproxy/dataproxy_service.proto @@ -0,0 +1,92 @@ +syntax = "proto3"; + +package flyteidl2.dataproxy; + +import "buf/validate/validate.proto"; +import "google/api/annotations.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/timestamp.proto"; +import "protoc-gen-openapiv2/options/annotations.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/dataproxy"; + +// DataProxyService provides an interface for managing data uploads and downloads. +service DataProxyService { + // CreateUploadLocation generates a signed URL for uploading data to the configured storage backend. + rpc CreateUploadLocation(CreateUploadLocationRequest) returns (CreateUploadLocationResponse) { + option (google.api.http) = { + post: "/api/v1/dataproxy/artifact_urn" + body: "*" + additional_bindings: { + post: "/api/v1/org/dataproxy/artifact_urn" + body: "*" + } + }; + option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {description: "Creates a write-only http location that is accessible for tasks at runtime."}; + } +} + +// CreateUploadLocationRequest specifies the request for the CreateUploadLocation API. +// The data proxy service will generate a storage location with server-side configured prefixes. +// The generated path follows one of these patterns: +// - project/domain/(deterministic hash of content_md5)/filename (if filename is present); OR +// - project/domain/filename_root/filename (if filename_root and filename are present). +message CreateUploadLocationRequest { + // Project to create the upload location for. + // +required + string project = 1 [(buf.validate.field).string.min_len = 1]; + + // Domain to create the upload location for. + // +required + string domain = 2 [(buf.validate.field).string.min_len = 1]; + + // Filename specifies the desired suffix for the generated location. E.g. `file.py` or `pre/fix/file.zip`. + // +optional. By default, the service generates a consistent name based on the default filename length provided in the global config.. + string filename = 3; + + // ExpiresIn defines the requested expiration duration for the generated URL. The request will be rejected if this + // exceeds the platform's configured maximum. + // +optional. The default value comes from the global config. + google.protobuf.Duration expires_in = 4; + + // ContentMD5 restricts the upload location to the specific MD5 provided. The MD5 hash will also appear in the + // generated path for verification. + // +required + bytes content_md5 = 5 [(buf.validate.field).bytes.len = 16]; + + // FilenameRoot, if present, will be used instead of the MD5 hash in the path. When combined with filename, + // this makes the upload location deterministic. The native URL will still be prefixed by the upload location prefix + // configured in the data proxy. This option is useful when uploading multiple related files. + // +optional + string filename_root = 6; + + // If true, the data proxy will add content_md5 to the Signed URL requirements, + // forcing clients to send this checksum with the object. + // This is required to enforce data integrity on backends like GCP, ensuring that + // the uploaded file matches the hash. + bool add_content_md5_metadata = 7; + + // Org is the organization key applied to the resource. + // +optional + string org = 8; + + // ContentLength specifies the size of the content to be uploaded in bytes. + // This is validated against the platform's maximum upload size if provided. + // +optional + int64 content_length = 9; +} + +// CreateUploadLocationResponse specifies the response for the CreateUploadLocation API. +message CreateUploadLocationResponse { + // SignedUrl is the URL to use for uploading content (e.g. https://my-bucket.s3.amazonaws.com/randomstring/suffix.tar?X-...). + string signed_url = 1; + + // NativeUrl is the URL in the format of the configured storage provider (e.g. s3://my-bucket/randomstring/suffix.tar). + string native_url = 2; + + // ExpiresAt defines when the signed URL will expire. + google.protobuf.Timestamp expires_at = 3; + + // Headers are generated by the data proxy for the client. Clients must include these headers in the upload request. + map headers = 4; +} diff --git a/flyteidl2/event/cloudevents.proto b/flyteidl2/event/cloudevents.proto new file mode 100644 index 0000000000..3d1144384a --- /dev/null +++ b/flyteidl2/event/cloudevents.proto @@ -0,0 +1,79 @@ +syntax = "proto3"; + +package flyteidl2.event; + +import "flyteidl2/core/artifact_id.proto"; +import "flyteidl2/core/identifier.proto"; +import "flyteidl2/core/interface.proto"; +import "flyteidl2/event/event.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/event"; + +// This is the cloud event parallel to the raw WorkflowExecutionEvent message. It's filled in with additional +// information that downstream consumers may find useful. +message CloudEventWorkflowExecution { + event.WorkflowExecutionEvent raw_event = 1; + + core.TypedInterface output_interface = 2; + + // The following are ExecutionMetadata fields + // We can't have the ExecutionMetadata object directly because of import cycle + repeated core.ArtifactID artifact_ids = 3; + core.WorkflowExecutionIdentifier reference_execution = 4; + string principal = 5; + + // The ID of the LP that generated the execution that generated the Artifact. + // Here for provenance information. + // Launch plan IDs are easier to get than workflow IDs so we'll use these for now. + core.Identifier launch_plan_id = 6; + + // We can't have the ExecutionMetadata object directly because of import cycle + map labels = 7; +} + +message CloudEventNodeExecution { + event.NodeExecutionEvent raw_event = 1; + + // The relevant task execution if applicable + core.TaskExecutionIdentifier task_exec_id = 2; + + // The typed interface for the task that produced the event. + core.TypedInterface output_interface = 3; + + // The following are ExecutionMetadata fields + // We can't have the ExecutionMetadata object directly because of import cycle + repeated core.ArtifactID artifact_ids = 4; + string principal = 5; + + // The ID of the LP that generated the execution that generated the Artifact. + // Here for provenance information. + // Launch plan IDs are easier to get than workflow IDs so we'll use these for now. + core.Identifier launch_plan_id = 6; + + // We can't have the ExecutionMetadata object directly because of import cycle + map labels = 7; +} + +message CloudEventTaskExecution { + event.TaskExecutionEvent raw_event = 1; + // We can't have the ExecutionMetadata object directly because of import cycle + map labels = 2; +} + +// This event is to be sent by Admin after it creates an execution. +message CloudEventExecutionStart { + // The execution created. + core.WorkflowExecutionIdentifier execution_id = 1; + // The launch plan used. + core.Identifier launch_plan_id = 2; + + core.Identifier workflow_id = 3; + + // Artifact inputs to the workflow execution for which we have the full Artifact ID. These are likely the result of artifact queries that are run. + repeated core.ArtifactID artifact_ids = 4; + + // Artifact inputs to the workflow execution for which we only have the tracking bit that's installed into the Literal's metadata by the Artifact service. + repeated string artifact_trackers = 5; + + string principal = 6; +} diff --git a/flyteidl2/event/event.proto b/flyteidl2/event/event.proto new file mode 100644 index 0000000000..526efde052 --- /dev/null +++ b/flyteidl2/event/event.proto @@ -0,0 +1,326 @@ +syntax = "proto3"; + +package flyteidl2.event; + +import "flyteidl2/core/catalog.proto"; +import "flyteidl2/core/execution.proto"; +import "flyteidl2/core/identifier.proto"; +import "flyteidl2/core/literals.proto"; +import "google/protobuf/struct.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/event"; + +message WorkflowExecutionEvent { + // Workflow execution id + core.WorkflowExecutionIdentifier execution_id = 1; + + // the id of the originator (Propeller) of the event + string producer_id = 2; + + core.WorkflowExecution.Phase phase = 3; + + // This timestamp represents when the original event occurred, it is generated + // by the executor of the workflow. + google.protobuf.Timestamp occurred_at = 4; + + oneof output_result { + // URL to the output of the execution, it encodes all the information + // including Cloud source provider. ie., s3://... + string output_uri = 5; + + // Error information for the execution + core.ExecutionError error = 6; + + // Raw output data produced by this workflow execution. + core.LiteralMap output_data = 7; + } +} + +message NodeExecutionEvent { + // Unique identifier for this node execution + core.NodeExecutionIdentifier id = 1; + + // the id of the originator (Propeller) of the event + string producer_id = 2; + + core.NodeExecution.Phase phase = 3; + + // This timestamp represents when the original event occurred, it is generated + // by the executor of the node. + google.protobuf.Timestamp occurred_at = 4; + + oneof input_value { + string input_uri = 5; + + // Raw input data consumed by this node execution. + core.LiteralMap input_data = 20; + } + + oneof output_result { + // URL to the output of the execution, it encodes all the information + // including Cloud source provider. ie., s3://... + string output_uri = 6; + + // Error information for the execution + core.ExecutionError error = 7; + + // Raw output data produced by this node execution. + core.LiteralMap output_data = 15; + } + + // Additional metadata to do with this event's node target based + // on the node type + oneof target_metadata { + WorkflowNodeMetadata workflow_node_metadata = 8; + TaskNodeMetadata task_node_metadata = 14; + } + + // [To be deprecated] Specifies which task (if any) launched this node. + ParentTaskExecutionMetadata parent_task_metadata = 9; + + // Specifies the parent node of the current node execution. Node executions at level zero will not have a parent node. + ParentNodeExecutionMetadata parent_node_metadata = 10; + + // Retry group to indicate grouping of nodes by retries + string retry_group = 11; + + // Identifier of the node in the original workflow/graph + // This maps to value of WorkflowTemplate.nodes[X].id + string spec_node_id = 12; + + // Friendly readable name for the node + string node_name = 13; + + int32 event_version = 16; + + // Whether this node launched a subworkflow. + bool is_parent = 17; + + // Whether this node yielded a dynamic workflow. + bool is_dynamic = 18; + + // String location uniquely identifying where the deck HTML file is + // NativeUrl specifies the url in the format of the configured storage provider (e.g. s3://my-bucket/randomstring/suffix.tar) + string deck_uri = 19; + + // This timestamp represents the instant when the event was reported by the executing framework. For example, + // when first processing a node the `occurred_at` timestamp should be the instant propeller makes progress, so when + // literal inputs are initially copied. The event however will not be sent until after the copy completes. + // Extracting both of these timestamps facilitates a more accurate portrayal of the evaluation time-series. + google.protobuf.Timestamp reported_at = 21; + + // Indicates if this node is an ArrayNode. + bool is_array = 22; + + // So that Admin doesn't have to rebuild the node execution graph to find the target entity, propeller will fill this + // in optionally - currently this is only filled in for subworkflows. This is the ID of the subworkflow corresponding + // to this node execution. It is difficult to find because Admin only sees one node at a time. A subworkflow could be + // nested multiple layers deep, and you'd need to access the correct workflow template to know the target subworkflow. + core.Identifier target_entity = 23; + + // Tasks and subworkflows (but not launch plans) that are run within a dynamic task are effectively independent of + // the tasks that are registered in Admin's db. Confusingly, they are often identical, but sometimes they are not + // even registered at all. Similar to the target_entity field, at the time Admin receives this event, it has no idea + // if the relevant execution entity is was registered, or dynamic. This field indicates that the target_entity ID, + // as well as task IDs in any corresponding Task Executions, should not be used to looked up the task in Admin's db. + bool is_in_dynamic_chain = 24; + + // Whether this node launched an eager task. + bool is_eager = 25; +} + +// For Workflow Nodes we need to send information about the workflow that's launched +message WorkflowNodeMetadata { + core.WorkflowExecutionIdentifier execution_id = 1; +} + +message TaskNodeMetadata { + // Captures the status of caching for this execution. + core.CatalogCacheStatus cache_status = 1; + // This structure carries the catalog artifact information + core.CatalogMetadata catalog_key = 2; + // Captures the status of cache reservations for this execution. + core.CatalogReservation.Status reservation_status = 3; + // The latest checkpoint location + string checkpoint_uri = 4; +} + +message ParentTaskExecutionMetadata { + core.TaskExecutionIdentifier id = 1; +} + +message ParentNodeExecutionMetadata { + // Unique identifier of the parent node id within the execution + // This is value of core.NodeExecutionIdentifier.node_id of the parent node + string node_id = 1; +} + +message EventReason { + // An explanation for this event + string reason = 1; + + // The time this reason occurred + google.protobuf.Timestamp occurred_at = 2; +} + +// Plugin specific execution event information. For tasks like Python, Hive, Spark, DynamicJob. +message TaskExecutionEvent { + // ID of the task. In combination with the retryAttempt this will indicate + // the task execution uniquely for a given parent node execution. + core.Identifier task_id = 1; + + // A task execution is always kicked off by a node execution, the event consumer + // will use the parent_id to relate the task to it's parent node execution + core.NodeExecutionIdentifier parent_node_execution_id = 2; + + // retry attempt number for this task, ie., 2 for the second attempt + uint32 retry_attempt = 3; + + // Phase associated with the event + core.TaskExecution.Phase phase = 4; + + // id of the process that sent this event, mainly for trace debugging + string producer_id = 5; + + // log information for the task execution + repeated core.TaskLog logs = 6; + + // This timestamp represents when the original event occurred, it is generated + // by the executor of the task. + google.protobuf.Timestamp occurred_at = 7; + + oneof input_value { + // URI of the input file, it encodes all the information + // including Cloud source provider. ie., s3://... + string input_uri = 8; + + // Raw input data consumed by this task execution. + core.LiteralMap input_data = 19; + } + + oneof output_result { + // URI to the output of the execution, it will be in a format that encodes all the information + // including Cloud source provider. ie., s3://... + string output_uri = 9; + + // Error information for the execution + core.ExecutionError error = 10; + + // Raw output data produced by this task execution. + core.LiteralMap output_data = 17; + } + + // Custom data that the task plugin sends back. This is extensible to allow various plugins in the system. + google.protobuf.Struct custom_info = 11; + + // Some phases, like RUNNING, can send multiple events with changed metadata (new logs, additional custom_info, etc) + // that should be recorded regardless of the lack of phase change. + // The version field should be incremented when metadata changes across the duration of an individual phase. + uint32 phase_version = 12; + + // An optional explanation for the phase transition. + // Deprecated: Use reasons instead. + string reason = 13 [deprecated = true]; + + // An optional list of explanations for the phase transition. + repeated EventReason reasons = 21; + + // A predefined yet extensible Task type identifier. If the task definition is already registered in flyte admin + // this type will be identical, but not all task executions necessarily use pre-registered definitions and this + // type is useful to render the task in the UI, filter task executions, etc. + string task_type = 14; + + // Metadata around how a task was executed. + TaskExecutionMetadata metadata = 16; + + // The event version is used to indicate versioned changes in how data is reported using this + // proto message. For example, event_verison > 0 means that maps tasks report logs using the + // TaskExecutionMetadata ExternalResourceInfo fields for each subtask rather than the TaskLog + // in this message. + int32 event_version = 18; + + // This timestamp represents the instant when the event was reported by the executing framework. For example, a k8s + // pod task may be marked completed at (ie. `occurred_at`) the instant the container running user code completes, + // but this event will not be reported until the pod is marked as completed. Extracting both of these timestamps + // facilitates a more accurate portrayal of the evaluation time-series. + google.protobuf.Timestamp reported_at = 20; + + // Contains metadata required to identify logs related to this task execution + core.LogContext log_context = 22; +} + +// This message contains metadata about external resources produced or used by a specific task execution. +message ExternalResourceInfo { + // Identifier for an external resource created by this task execution, for example Qubole query ID or presto query ids. + string external_id = 1; + + // A unique index for the external resource with respect to all external resources for this task. Although the + // identifier may change between task reporting events or retries, this will remain the same to enable aggregating + // information from multiple reports. + uint32 index = 2; + + // Retry attempt number for this external resource, ie., 2 for the second attempt + uint32 retry_attempt = 3; + + // Phase associated with the external resource + core.TaskExecution.Phase phase = 4; + + // Captures the status of caching for this external resource execution. + core.CatalogCacheStatus cache_status = 5; + + // log information for the external resource execution + repeated core.TaskLog logs = 6; + + // Additional metadata to do with this event's node target based on the node type. We are + // explicitly not including the task_node_metadata here because it is not clear if it is needed. + // If we decide to include in the future, we should deprecate the cache_status field. + oneof target_metadata { + WorkflowNodeMetadata workflow_node_metadata = 7; + } + + // Extensible field for custom, plugin-specific info + google.protobuf.Struct custom_info = 8; + + // Contains metadata required to identify logs related to this task execution + core.LogContext log_context = 9; +} + +// This message holds task execution metadata specific to resource allocation used to manage concurrent +// executions for a project namespace. +message ResourcePoolInfo { + // Unique resource ID used to identify this execution when allocating a token. + string allocation_token = 1; + + // Namespace under which this task execution requested an allocation token. + string namespace = 2; +} + +// Holds metadata around how a task was executed. +// As a task transitions across event phases during execution some attributes, such its generated name, generated external resources, +// and more may grow in size but not change necessarily based on the phase transition that sparked the event update. +// Metadata is a container for these attributes across the task execution lifecycle. +message TaskExecutionMetadata { + // Unique, generated name for this task execution used by the backend. + string generated_name = 1; + + // Additional data on external resources on other back-ends or platforms (e.g. Hive, Qubole, etc) launched by this task execution. + repeated ExternalResourceInfo external_resources = 2; + + // Includes additional data on concurrent resource management used during execution.. + // This is a repeated field because a plugin can request multiple resource allocations during execution. + repeated ResourcePoolInfo resource_pool_info = 3; + + // The identifier of the plugin used to execute this task. + string plugin_identifier = 4; + + // Includes the broad category of machine used for this specific task execution. + enum InstanceClass { + // The default instance class configured for the flyte application platform. + DEFAULT = 0; + + // The instance class configured for interruptible tasks. + INTERRUPTIBLE = 1; + } + InstanceClass instance_class = 16; +} diff --git a/flyteidl2/gen_utils/python/README.md b/flyteidl2/gen_utils/python/README.md new file mode 100644 index 0000000000..cae843b7a3 --- /dev/null +++ b/flyteidl2/gen_utils/python/README.md @@ -0,0 +1 @@ +# Python library of flyte IDL (protobuf) \ No newline at end of file diff --git a/flyteidl2/gen_utils/python/pyproject.toml b/flyteidl2/gen_utils/python/pyproject.toml new file mode 100644 index 0000000000..5d69d55360 --- /dev/null +++ b/flyteidl2/gen_utils/python/pyproject.toml @@ -0,0 +1,45 @@ +[build-system] +requires = ["setuptools", "setuptools_scm"] +build-backend = "setuptools.build_meta" + +[project] +name = "flyteidl2" +dynamic = ["version"] +authors = [{ name = "Union Eng", email = "support@union.ai" }] +description = "IDL for Flyte" +readme = { file = "README.md", content-type = "text/markdown" } +requires-python = ">=3.10" +dependencies = [ + 'googleapis-common-protos', + 'protoc-gen-openapiv2', + 'protobuf>=4.21.1', + "protovalidate>=1.0.0", +] +classifiers = [ + "Intended Audience :: Science/Research", + "Intended Audience :: Developers", + "License :: OSI Approved :: Apache Software License", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Topic :: Scientific/Engineering", + "Topic :: Scientific/Engineering :: Artificial Intelligence", + "Topic :: Software Development", + "Topic :: Software Development :: Libraries", + "Topic :: Software Development :: Libraries :: Python Modules", +] +license-files = ["licenses/*.txt", "LICENSE"] + +[tool.setuptools] +include-package-data = true + +# Intentionally leaving out the google folder, which contains googleapis-common-protos. This library is a dependency +# of too many google libraries including grpcio-status which flyte already depends on, so don't want to +# risk version conflicts. +[tool.setuptools.packages.find] +include = ["flyteidl2*", "buf*"] +exclude = ["build*"] + +[tool.setuptools_scm] +root = "../../" diff --git a/flyteidl2/gen_utils/python/setup.py b/flyteidl2/gen_utils/python/setup.py new file mode 100644 index 0000000000..7f576889bf --- /dev/null +++ b/flyteidl2/gen_utils/python/setup.py @@ -0,0 +1,6 @@ +from setuptools import setup + + +__version__ = "0.0.0+develop" + +setup() \ No newline at end of file diff --git a/flyteidl2/gen_utils/python/uv.lock b/flyteidl2/gen_utils/python/uv.lock new file mode 100644 index 0000000000..5ae7fb08e4 --- /dev/null +++ b/flyteidl2/gen_utils/python/uv.lock @@ -0,0 +1,285 @@ +version = 1 +revision = 3 +requires-python = ">=3.10" +resolution-markers = [ + "python_full_version == '3.13.*'", + "python_full_version == '3.12.*'", + "python_full_version < '3.12' or python_full_version >= '3.14'", +] + +[[package]] +name = "bufbuild-protovalidate-protocolbuffers-pyi" +version = "32.1.0.1.20240401165935+b983156c5e99" +source = { registry = "https://buf.build/gen/python" } +dependencies = [ + { name = "protobuf" }, + { name = "types-protobuf" }, +] +wheels = [ + { url = "https://buf.build/gen/python/bufbuild-protovalidate-protocolbuffers-pyi/bufbuild_protovalidate_protocolbuffers_pyi-32.1.0.1.20240401165935+b983156c5e99-py3-none-any.whl" }, +] + +[[package]] +name = "bufbuild-protovalidate-protocolbuffers-python" +version = "32.0.0.1.20250912141014+52f32327d4b0" +source = { registry = "https://buf.build/gen/python" } +dependencies = [ + { name = "bufbuild-protovalidate-protocolbuffers-pyi" }, + { name = "protobuf" }, +] +wheels = [ + { url = "https://buf.build/gen/python/bufbuild-protovalidate-protocolbuffers-python/bufbuild_protovalidate_protocolbuffers_python-32.0.0.1.20250912141014+52f32327d4b0-py3-none-any.whl" }, +] + +[[package]] +name = "cel-python" +version = "0.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jmespath" }, + { name = "lark" }, + { name = "python-dateutil" }, + { name = "pyyaml" }, + { name = "types-python-dateutil" }, + { name = "types-pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/10/87/85a1b99b98f6466bb87d40df636626385945ae82348e82cd97d44313f612/cel_python-0.2.0.tar.gz", hash = "sha256:75de72a5cf223ec690b236f0cc24da267219e667bd3e7f8f4f20595fcc1c0c0f", size = 67185, upload-time = "2025-02-14T11:42:21.882Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/28/08871462a0347b3e707658a8308be6f979167488a2196f93b402c2ea7170/cel_python-0.2.0-py3-none-any.whl", hash = "sha256:478ff73def7b39d51e6982f95d937a57c2b088c491c578fe5cecdbd79f476f60", size = 71337, upload-time = "2025-02-14T11:42:19.996Z" }, +] + +[[package]] +name = "flyteidl2" +source = { editable = "." } +dependencies = [ + { name = "bufbuild-protovalidate-protocolbuffers-pyi" }, + { name = "bufbuild-protovalidate-protocolbuffers-python" }, + { name = "googleapis-common-protos" }, + { name = "protobuf" }, + { name = "protoc-gen-openapiv2" }, + { name = "protovalidate" }, +] + +[package.metadata] +requires-dist = [ + { name = "bufbuild-protovalidate-protocolbuffers-pyi", specifier = "==32.1.0.1.20240401165935+b983156c5e99", index = "https://buf.build/gen/python" }, + { name = "bufbuild-protovalidate-protocolbuffers-python", specifier = "==32.0.0.1.20250912141014+52f32327d4b0", index = "https://buf.build/gen/python" }, + { name = "googleapis-common-protos" }, + { name = "protobuf", specifier = ">=4.21.1" }, + { name = "protoc-gen-openapiv2" }, + { name = "protovalidate", specifier = ">=1.0.0" }, +] + +[[package]] +name = "google-re2" +version = "1.1.20250805" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/93/ed/7caa25b34a201ef8db5a635e03ca71c926caff92aba1b17e86b78190de43/google_re2-1.1.20250805.tar.gz", hash = "sha256:c55d9f7c92a814eb53918a7b38e5ba5eaa1c99548321acb826da9532781af5b5", size = 11698, upload-time = "2025-08-05T19:30:24.345Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/9c/e120dc14daa0b6d5e0ddb659e0f132292abf22fad3563c017b73ab549a01/google_re2-1.1.20250805-1-cp310-cp310-macosx_13_0_arm64.whl", hash = "sha256:7d2a7dea1448733184a99516a41f28ffcfc9eda345697a14fd5c6d8144b60841", size = 483036, upload-time = "2025-08-05T19:29:05.84Z" }, + { url = "https://files.pythonhosted.org/packages/b2/b6/981ae8734410617c0cb6d32b059a6833ca980bbe6e65840bc8e68f5697ea/google_re2-1.1.20250805-1-cp310-cp310-macosx_13_0_x86_64.whl", hash = "sha256:51b4e3c5e6f3f74193666295385b44e1043e55cf98e4b933fe11a0d7a2457a67", size = 514139, upload-time = "2025-08-05T19:29:07.721Z" }, + { url = "https://files.pythonhosted.org/packages/73/56/d1c1c729b7e356dd8b8224bf1873d90fa94c350eddce0ef7da775440a552/google_re2-1.1.20250805-1-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:0c43d2120ba62e8da4d064dcb5b5c9ac103bfe4cd71a5472055a7f02298b544b", size = 484050, upload-time = "2025-08-05T19:29:09.163Z" }, + { url = "https://files.pythonhosted.org/packages/1d/78/a07b752d7d879f25b6de12f442ebfd57be9acc79857f16c026ba989afad0/google_re2-1.1.20250805-1-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:46eb32ca99136e5ff76b33195b37d41342afcc505f4b60309a4159008f80b064", size = 515591, upload-time = "2025-08-05T19:29:10.742Z" }, + { url = "https://files.pythonhosted.org/packages/0b/4a/651971a6ece6a85ff6598bcf801cb0c7ee20a251b9631b7b5d4886642818/google_re2-1.1.20250805-1-cp310-cp310-macosx_15_0_arm64.whl", hash = "sha256:eaf8b912020ec9bcc1811f64478e2dfb82907e502b718ad4b263045820519595", size = 484613, upload-time = "2025-08-05T19:29:12.348Z" }, + { url = "https://files.pythonhosted.org/packages/fa/ad/8768a99b2b79b14806b7da89f783f6828f540469169066cf3a7bb16cbe44/google_re2-1.1.20250805-1-cp310-cp310-macosx_15_0_x86_64.whl", hash = "sha256:0df2591355131457f9a008b3bd8fbdb104f8344b75d150fd90ddc0bc19b80935", size = 511041, upload-time = "2025-08-05T19:29:13.87Z" }, + { url = "https://files.pythonhosted.org/packages/68/34/997ee9e113398c5ca6ec8bb5c2d210e7931e44b1fbd38024d09dabd2ba9a/google_re2-1.1.20250805-1-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fb56c6e7c8fe2eaf045b987dbf8dfc979f61a21e6446dd8b3c0e4028f9ff8611", size = 572722, upload-time = "2025-08-05T19:29:15.435Z" }, + { url = "https://files.pythonhosted.org/packages/51/e2/f99887835200a961a957dab4208d00ae344a8906ed9e0bb1ce578aec87a1/google_re2-1.1.20250805-1-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7f2124ccc4e06c1841e18360edbc379f050b8dcb54096293e2e6e90b5f913f92", size = 588956, upload-time = "2025-08-05T19:29:16.975Z" }, + { url = "https://files.pythonhosted.org/packages/4c/fc/bd56b2133ce1d6853e4abafa89685860eda725a2fe62c233a30cfe928abb/google_re2-1.1.20250805-1-cp310-cp310-win32.whl", hash = "sha256:0bcf2acdc32a3890ddfca87fa846806b6db200a059a83ab114e6ab390beaf10e", size = 432851, upload-time = "2025-08-05T19:29:18.568Z" }, + { url = "https://files.pythonhosted.org/packages/a8/ac/21473b4de4a829bc9822d810fc1a26c7abdbee76c60a915a8ade0dae6372/google_re2-1.1.20250805-1-cp310-cp310-win_amd64.whl", hash = "sha256:8c6da22b158459e5a592fcd66a9e99347f517284d91d61b6ff2befff3eb79339", size = 490154, upload-time = "2025-08-05T19:29:19.762Z" }, + { url = "https://files.pythonhosted.org/packages/ec/6f/c99a04f13114282362bf73dd1a79e96b92ed80ed47bf1f57744646753e08/google_re2-1.1.20250805-1-cp311-cp311-macosx_13_0_arm64.whl", hash = "sha256:e7f7e960002c702ae2c0aff3b8db895ded37006ac7aa0c158743fb20dcd485c2", size = 483730, upload-time = "2025-08-05T19:29:21.181Z" }, + { url = "https://files.pythonhosted.org/packages/23/c8/994a5fef87eb977d06ff8dfe7bb59ba31f535d3f2622334b6b32f1b65528/google_re2-1.1.20250805-1-cp311-cp311-macosx_13_0_x86_64.whl", hash = "sha256:bfacaa9b274871796bfd0750e23f804ff632a5397b830c640449d3d57b3d148f", size = 515513, upload-time = "2025-08-05T19:29:22.63Z" }, + { url = "https://files.pythonhosted.org/packages/30/25/81672efc1d0cce43813e0b3bffc14c3d32e102cf254c9d280bf4e5194664/google_re2-1.1.20250805-1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:c4f72b275ec6b5ef6e3215dab9392aefc2e8f8590d0c3d8b266e6a913503d2a1", size = 485374, upload-time = "2025-08-05T19:29:23.925Z" }, + { url = "https://files.pythonhosted.org/packages/da/04/7a3361618217d401203a9eb34712c824e9645f7d2830d1e804eb9859374c/google_re2-1.1.20250805-1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:c6b5550a9767e444b17a9c3c4b020c51629282748d77244d833aacbd765f28fe", size = 517105, upload-time = "2025-08-05T19:29:25.196Z" }, + { url = "https://files.pythonhosted.org/packages/38/97/29e8097e449b0af993acd7d7d658ecfac3914ac501e6c6d40ffcebc03b8e/google_re2-1.1.20250805-1-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:4c1e5ec68dfe2e0866f14468600e2e2928dcfe684c0f2fbeda8d16f14f909141", size = 485756, upload-time = "2025-08-05T19:29:26.975Z" }, + { url = "https://files.pythonhosted.org/packages/1c/88/cb3647eb92c991d93fde8b1fefddd52ff3bb45a5d1c20185e2fd24e1e5fa/google_re2-1.1.20250805-1-cp311-cp311-macosx_15_0_x86_64.whl", hash = "sha256:336d6830888ea2abdc1744d201e19cf76c4f001cf821bed3e8844c1899bcbdaf", size = 512227, upload-time = "2025-08-05T19:29:28.207Z" }, + { url = "https://files.pythonhosted.org/packages/b8/fe/33e357bb8d090a4879e9e257be577740d1b5d762686b4fa448f050b15caf/google_re2-1.1.20250805-1-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:52a153ce37ccfd5429257a91d68f4338fe2809711bff64c7ab84c97ddef2de25", size = 573694, upload-time = "2025-08-05T19:29:29.52Z" }, + { url = "https://files.pythonhosted.org/packages/96/97/e1648859b140b76717319a8d8aceec3365e354ea9ff0690d0fbbcb5774e3/google_re2-1.1.20250805-1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2ffc79fe2f4be9c5e3e8bb04c8e84e0c9a27b5f08ad5103779b084005e99d220", size = 590760, upload-time = "2025-08-05T19:29:30.967Z" }, + { url = "https://files.pythonhosted.org/packages/af/0a/1dae50eece5fe4f53503f47f8535ee7f8667e2f84dbbf87f0fa8942678b6/google_re2-1.1.20250805-1-cp311-cp311-win32.whl", hash = "sha256:2cfccbbd8577250406a3a3ff1b5d3ee21a479e3f1a01f78042d4d15c461eca1e", size = 434080, upload-time = "2025-08-05T19:29:32.578Z" }, + { url = "https://files.pythonhosted.org/packages/d2/b8/1c4e100d2b1dac7c4ab52d18b8c3060a835f1e2b9dc0802024313fa69277/google_re2-1.1.20250805-1-cp311-cp311-win_amd64.whl", hash = "sha256:4d0669fed9f9f993c5cffae42d7193da752e5b4e42e95b0e9ee0b95de9fcd8ad", size = 490954, upload-time = "2025-08-05T19:29:33.784Z" }, + { url = "https://files.pythonhosted.org/packages/8d/ac/3ed55b2f70cb1b091a59c5242376524e68de88d0280ea0be7c8f4754a37d/google_re2-1.1.20250805-1-cp311-cp311-win_arm64.whl", hash = "sha256:50495e5f783e0c1577384bac75455a799904158b5077284c70e6a9510995f3be", size = 642137, upload-time = "2025-08-05T19:29:34.973Z" }, + { url = "https://files.pythonhosted.org/packages/78/b5/5ed6ffcb1f33348e7f212819d1082f125bd224c89aef842b78b63f9a97e0/google_re2-1.1.20250805-1-cp312-cp312-macosx_13_0_arm64.whl", hash = "sha256:39f81ff026701533593ffb43acd999d11b8ff769d2234e2083c9ae38d02a01a4", size = 485610, upload-time = "2025-08-05T19:29:36.243Z" }, + { url = "https://files.pythonhosted.org/packages/ff/e3/b4db34e633b0c5c880c2a3371eedcab600ea0c04a51a2509cda09c913e1e/google_re2-1.1.20250805-1-cp312-cp312-macosx_13_0_x86_64.whl", hash = "sha256:7d26aecd8850ec469bf8ae7d3a1ad26b1b1c0477400351ff5df181ef5dff68f0", size = 518722, upload-time = "2025-08-05T19:29:37.51Z" }, + { url = "https://files.pythonhosted.org/packages/b9/96/ca6f0ff5693558ba104007cf7cc8187d3d47c5d01af06c4204bbe9d8d160/google_re2-1.1.20250805-1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:f45314ef7b22c28a1c43469d522398068af4bd1b59839c831033723c782c7402", size = 486962, upload-time = "2025-08-05T19:29:38.775Z" }, + { url = "https://files.pythonhosted.org/packages/e9/e5/41e316d9a160bca99f7a4bff2dc9f4a9b8a3b3b927a610fdf7717f0af2f7/google_re2-1.1.20250805-1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:13e8b83655fcb97d7190d8c07a2886dd5bf9c55935419c98a4b7f09cc6e2019d", size = 520209, upload-time = "2025-08-05T19:29:39.967Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c6/30d8c5988c640d6de7a9b0739bc33d9b2a4d00bf12a7e6c0abfebc0c365b/google_re2-1.1.20250805-1-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:9c17c678b3bf2ca874c74b898a21b534d3e60123eda8ef18dde1c1932d142b1f", size = 487152, upload-time = "2025-08-05T19:29:41.596Z" }, + { url = "https://files.pythonhosted.org/packages/73/1f/d3f04e5c66c2bf235cb449f4e7372596375f6a8537eaeaa35f076927bd0b/google_re2-1.1.20250805-1-cp312-cp312-macosx_15_0_x86_64.whl", hash = "sha256:a848f44752286372cfb0ff225a836ed7b02738b29ca31ed3c58e70dc7d584537", size = 514497, upload-time = "2025-08-05T19:29:43.196Z" }, + { url = "https://files.pythonhosted.org/packages/2b/e3/14c2999896aa5bc111a18fe41c56283f222179076c52d515ea5c3e0043ad/google_re2-1.1.20250805-1-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a90f090081e415ee182a01f4113076ad5707c5501ae985c8edc5bfc439cbdee6", size = 572418, upload-time = "2025-08-05T19:29:44.478Z" }, + { url = "https://files.pythonhosted.org/packages/5f/ad/7c4e61bccbfaf036011960ebbc8743971a34f1bd1b07d1f379b2feb81296/google_re2-1.1.20250805-1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9b5749bcbb363cdfdff5da14aa0c53de28f918662d0b6f546af31f96c8fd46dd", size = 591359, upload-time = "2025-08-05T19:29:46.186Z" }, + { url = "https://files.pythonhosted.org/packages/9f/fe/f1a0966c76a52467879f951ba1ffbbc5f2a4a0ecc2f2c2e40b131613b9e9/google_re2-1.1.20250805-1-cp312-cp312-win32.whl", hash = "sha256:19689531ce9839813035663df68aa49074c92e426b20095e5e665521c55c1cab", size = 433756, upload-time = "2025-08-05T19:29:47.416Z" }, + { url = "https://files.pythonhosted.org/packages/7e/27/f20d98d5121479eed67127eafb3ed99531d9bc43fac2e75e04938950b2ca/google_re2-1.1.20250805-1-cp312-cp312-win_amd64.whl", hash = "sha256:b533077b8a1c120c5f446e6734893d2a18d098e3edde149dda6a9ff9a3e2e7d2", size = 491663, upload-time = "2025-08-05T19:29:48.726Z" }, + { url = "https://files.pythonhosted.org/packages/80/5a/8997a1e00fcd75db5a6c1243ee512f174a2e266f0017d2a209de36007cef/google_re2-1.1.20250805-1-cp312-cp312-win_arm64.whl", hash = "sha256:3a0193237b274faf57492efbeecc9be5818f3852f186ea5c672490b49da4d124", size = 642623, upload-time = "2025-08-05T19:29:50.172Z" }, + { url = "https://files.pythonhosted.org/packages/79/c0/f4b5c894335bc7d276e5be58d72e24811db8d5900dfdf37069528d65b73c/google_re2-1.1.20250805-1-cp313-cp313-macosx_13_0_arm64.whl", hash = "sha256:049732fce70dea6246f035027e512f7cbc22fa9c7f2969c503cd0abb0fcfc674", size = 485546, upload-time = "2025-08-05T19:29:51.461Z" }, + { url = "https://files.pythonhosted.org/packages/dd/a8/afcddbf964add57569cc0081e99fc968e1bc9d65c34612e0a63ec2085606/google_re2-1.1.20250805-1-cp313-cp313-macosx_13_0_x86_64.whl", hash = "sha256:552e37f08514778d98b6d27aea2abd80efca19c4812ca6388175fd5e54d08229", size = 518842, upload-time = "2025-08-05T19:29:52.826Z" }, + { url = "https://files.pythonhosted.org/packages/02/a4/82063779d7c6c56136b8217c022f6d95c490d73ccc78ca5e57158fd91855/google_re2-1.1.20250805-1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:6d452dab6bd9dedecef4cc4a0ba22203f5c4273395fd7896fe9ed0cc85643b11", size = 487043, upload-time = "2025-08-05T19:29:54.526Z" }, + { url = "https://files.pythonhosted.org/packages/5d/06/aee9f7315c00c77e1f3653d44a356c68c2066bc1de516c1bd473b6d827c5/google_re2-1.1.20250805-1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:358f497682cb5d57f0dd107944f7a2167226d31fb5211cfd187ec16cb5275355", size = 520233, upload-time = "2025-08-05T19:29:55.8Z" }, + { url = "https://files.pythonhosted.org/packages/08/7f/d28e64ce85604635da2870c99ac8c8c3e078aaba1f132ecea239f65f0030/google_re2-1.1.20250805-1-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:af66c822179f7f412e4c1fcc8b5ca84885e24ba77c2ee8aa7364f19131b77e7d", size = 487233, upload-time = "2025-08-05T19:29:57.531Z" }, + { url = "https://files.pythonhosted.org/packages/ff/37/bc22d185861461aafa8e8193a1e22f9eac1217e9bec9ac34b681f1c10bd9/google_re2-1.1.20250805-1-cp313-cp313-macosx_15_0_x86_64.whl", hash = "sha256:555b6183fa1a6f54117ec0eda333b98d96620c5d59b563a1dbe2a3eddf64ca24", size = 514473, upload-time = "2025-08-05T19:29:58.826Z" }, + { url = "https://files.pythonhosted.org/packages/56/05/a6da22582817396e30931e0d292d2ef4819c2eea3fb21b08661f9a6f3106/google_re2-1.1.20250805-1-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e7dfeab6a641a8e6c8ac1cb7fa40b4d2cb91571a3c4bcc840a6d1245d37c33bb", size = 572370, upload-time = "2025-08-05T19:30:00.164Z" }, + { url = "https://files.pythonhosted.org/packages/ec/14/feb54f3f11522f334294a916dffb54ab36dfaba47c7c8d0e091aec1084f1/google_re2-1.1.20250805-1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8b328e6d75e7b1e161dd834c42a7e1762d2e03919453257a64712a5bda798226", size = 591407, upload-time = "2025-08-05T19:30:01.62Z" }, + { url = "https://files.pythonhosted.org/packages/f3/b2/7c785a0596e8535794b5c21d27c3081928748acd556a4a0ef3b2c8338881/google_re2-1.1.20250805-1-cp313-cp313-win32.whl", hash = "sha256:eb1c398eaec3c8ffe74fe7064008c81f452ca5bdf12c2538acc4c087d043a6e1", size = 433845, upload-time = "2025-08-05T19:30:03.46Z" }, + { url = "https://files.pythonhosted.org/packages/5b/1d/af1fc1a5247d6549e67716bcb5e790761bb550026e659dfcfd89408389fd/google_re2-1.1.20250805-1-cp313-cp313-win_amd64.whl", hash = "sha256:18f72952c71de0ace48fbe0ca9928bd7b7bbe1062f685c0d1326a0205966f2dc", size = 491718, upload-time = "2025-08-05T19:30:05.14Z" }, + { url = "https://files.pythonhosted.org/packages/eb/89/39fd1d16a9cbda45cf55b920fac4840fc16ca668b96333f1a5d8931e1ec0/google_re2-1.1.20250805-1-cp313-cp313-win_arm64.whl", hash = "sha256:149ec3ce1a4711daf45aab4fc7d5926f9e3082ee2c6ea138043c27e64ff1d782", size = 642609, upload-time = "2025-08-05T19:30:06.632Z" }, +] + +[[package]] +name = "googleapis-common-protos" +version = "1.70.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "protobuf" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/39/24/33db22342cf4a2ea27c9955e6713140fedd51e8b141b5ce5260897020f1a/googleapis_common_protos-1.70.0.tar.gz", hash = "sha256:0e1b44e0ea153e6594f9f394fef15193a68aaaea2d843f83e2742717ca753257", size = 145903, upload-time = "2025-04-14T10:17:02.924Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/86/f1/62a193f0227cf15a920390abe675f386dec35f7ae3ffe6da582d3ade42c7/googleapis_common_protos-1.70.0-py3-none-any.whl", hash = "sha256:b8bfcca8c25a2bb253e0e0b0adaf8c00773e5e6af6fd92397576680b807e0fd8", size = 294530, upload-time = "2025-04-14T10:17:01.271Z" }, +] + +[[package]] +name = "jmespath" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/00/2a/e867e8531cf3e36b41201936b7fa7ba7b5702dbef42922193f05c8976cd6/jmespath-1.0.1.tar.gz", hash = "sha256:90261b206d6defd58fdd5e85f478bf633a2901798906be2ad389150c5c60edbe", size = 25843, upload-time = "2022-06-17T18:00:12.224Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/31/b4/b9b800c45527aadd64d5b442f9b932b00648617eb5d63d2c7a6587b7cafc/jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980", size = 20256, upload-time = "2022-06-17T18:00:10.251Z" }, +] + +[[package]] +name = "lark" +version = "0.12.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/02/1d/29681d27b84e384ea50b5546e9f0089126afbc91754db4ca89593fcfd0e8/lark-0.12.0.tar.gz", hash = "sha256:7da76fcfddadabbbbfd949bbae221efd33938451d90b1fefbbc423c3cccf48ef", size = 235168, upload-time = "2021-11-12T11:15:32.124Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/39/cef2ccdfd984ae3cf93878d050c1b7c9354dd9493ce83fd9bb33a41f7a33/lark-0.12.0-py2.py3-none-any.whl", hash = "sha256:ed1d891cbcf5151ead1c1d14663bf542443e579e63a76ae175b01b899bd854ca", size = 103540, upload-time = "2021-11-12T11:15:34.408Z" }, +] + +[[package]] +name = "protobuf" +version = "6.32.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fa/a4/cc17347aa2897568beece2e674674359f911d6fe21b0b8d6268cd42727ac/protobuf-6.32.1.tar.gz", hash = "sha256:ee2469e4a021474ab9baafea6cd070e5bf27c7d29433504ddea1a4ee5850f68d", size = 440635, upload-time = "2025-09-11T21:38:42.935Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/98/645183ea03ab3995d29086b8bf4f7562ebd3d10c9a4b14ee3f20d47cfe50/protobuf-6.32.1-cp310-abi3-win32.whl", hash = "sha256:a8a32a84bc9f2aad712041b8b366190f71dde248926da517bde9e832e4412085", size = 424411, upload-time = "2025-09-11T21:38:27.427Z" }, + { url = "https://files.pythonhosted.org/packages/8c/f3/6f58f841f6ebafe076cebeae33fc336e900619d34b1c93e4b5c97a81fdfa/protobuf-6.32.1-cp310-abi3-win_amd64.whl", hash = "sha256:b00a7d8c25fa471f16bc8153d0e53d6c9e827f0953f3c09aaa4331c718cae5e1", size = 435738, upload-time = "2025-09-11T21:38:30.959Z" }, + { url = "https://files.pythonhosted.org/packages/10/56/a8a3f4e7190837139e68c7002ec749190a163af3e330f65d90309145a210/protobuf-6.32.1-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d8c7e6eb619ffdf105ee4ab76af5a68b60a9d0f66da3ea12d1640e6d8dab7281", size = 426454, upload-time = "2025-09-11T21:38:34.076Z" }, + { url = "https://files.pythonhosted.org/packages/3f/be/8dd0a927c559b37d7a6c8ab79034fd167dcc1f851595f2e641ad62be8643/protobuf-6.32.1-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:2f5b80a49e1eb7b86d85fcd23fe92df154b9730a725c3b38c4e43b9d77018bf4", size = 322874, upload-time = "2025-09-11T21:38:35.509Z" }, + { url = "https://files.pythonhosted.org/packages/5c/f6/88d77011b605ef979aace37b7703e4eefad066f7e84d935e5a696515c2dd/protobuf-6.32.1-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:b1864818300c297265c83a4982fd3169f97122c299f56a56e2445c3698d34710", size = 322013, upload-time = "2025-09-11T21:38:37.017Z" }, + { url = "https://files.pythonhosted.org/packages/97/b7/15cc7d93443d6c6a84626ae3258a91f4c6ac8c0edd5df35ea7658f71b79c/protobuf-6.32.1-py3-none-any.whl", hash = "sha256:2601b779fc7d32a866c6b4404f9d42a3f67c5b9f3f15b4db3cccabe06b95c346", size = 169289, upload-time = "2025-09-11T21:38:41.234Z" }, +] + +[[package]] +name = "protoc-gen-openapiv2" +version = "0.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "googleapis-common-protos" }, + { name = "protobuf" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d8/d2/84fecd8df61640226c726c12ad7ddd2a7666a7cd7f898b9a5b72e3a66d44/protoc-gen-openapiv2-0.0.1.tar.gz", hash = "sha256:6f79188d842c13177c9c0558845442c340b43011bf67dfef1dfc3bc067506409", size = 7323, upload-time = "2022-12-02T01:40:57.306Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2d/ac/bd8961859d8f3f81530465d2ce9b165627e961c00348939009bac2700cc6/protoc_gen_openapiv2-0.0.1-py3-none-any.whl", hash = "sha256:18090c8be3877c438e7da0f7eb7cace45a9a210306bca4707708dbad367857be", size = 7883, upload-time = "2022-12-02T01:40:55.244Z" }, +] + +[[package]] +name = "protovalidate" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cel-python" }, + { name = "google-re2" }, + { name = "protobuf" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/dd/98/1595ae90c4a29c625580ee84415bb0c752e09c6c7aa13595e8ea94a7c929/protovalidate-1.0.0.tar.gz", hash = "sha256:926f7a212fed9190d00cc076fa24ef5e48a404b5577465028697f4dea8c4a507", size = 215286, upload-time = "2025-09-12T16:28:02.665Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/17/1d/30a86726b317593469eb526c8ca25dd8ce7f7b9f4237137fedb1f352ffff/protovalidate-1.0.0-py3-none-any.whl", hash = "sha256:933818942700c85d4a47f1030e61f59d7bd9a8c1572e9dc822f98eef45a39d9e", size = 29478, upload-time = "2025-09-12T16:28:01.201Z" }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631, upload-time = "2024-08-06T20:33:50.674Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/95/a3fac87cb7158e231b5a6012e438c647e1a87f09f8e0d123acec8ab8bf71/PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086", size = 184199, upload-time = "2024-08-06T20:31:40.178Z" }, + { url = "https://files.pythonhosted.org/packages/c7/7a/68bd47624dab8fd4afbfd3c48e3b79efe09098ae941de5b58abcbadff5cb/PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf", size = 171758, upload-time = "2024-08-06T20:31:42.173Z" }, + { url = "https://files.pythonhosted.org/packages/49/ee/14c54df452143b9ee9f0f29074d7ca5516a36edb0b4cc40c3f280131656f/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237", size = 718463, upload-time = "2024-08-06T20:31:44.263Z" }, + { url = "https://files.pythonhosted.org/packages/4d/61/de363a97476e766574650d742205be468921a7b532aa2499fcd886b62530/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b", size = 719280, upload-time = "2024-08-06T20:31:50.199Z" }, + { url = "https://files.pythonhosted.org/packages/6b/4e/1523cb902fd98355e2e9ea5e5eb237cbc5f3ad5f3075fa65087aa0ecb669/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed", size = 751239, upload-time = "2024-08-06T20:31:52.292Z" }, + { url = "https://files.pythonhosted.org/packages/b7/33/5504b3a9a4464893c32f118a9cc045190a91637b119a9c881da1cf6b7a72/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180", size = 695802, upload-time = "2024-08-06T20:31:53.836Z" }, + { url = "https://files.pythonhosted.org/packages/5c/20/8347dcabd41ef3a3cdc4f7b7a2aff3d06598c8779faa189cdbf878b626a4/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68", size = 720527, upload-time = "2024-08-06T20:31:55.565Z" }, + { url = "https://files.pythonhosted.org/packages/be/aa/5afe99233fb360d0ff37377145a949ae258aaab831bde4792b32650a4378/PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99", size = 144052, upload-time = "2024-08-06T20:31:56.914Z" }, + { url = "https://files.pythonhosted.org/packages/b5/84/0fa4b06f6d6c958d207620fc60005e241ecedceee58931bb20138e1e5776/PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e", size = 161774, upload-time = "2024-08-06T20:31:58.304Z" }, + { url = "https://files.pythonhosted.org/packages/f8/aa/7af4e81f7acba21a4c6be026da38fd2b872ca46226673c89a758ebdc4fd2/PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774", size = 184612, upload-time = "2024-08-06T20:32:03.408Z" }, + { url = "https://files.pythonhosted.org/packages/8b/62/b9faa998fd185f65c1371643678e4d58254add437edb764a08c5a98fb986/PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee", size = 172040, upload-time = "2024-08-06T20:32:04.926Z" }, + { url = "https://files.pythonhosted.org/packages/ad/0c/c804f5f922a9a6563bab712d8dcc70251e8af811fce4524d57c2c0fd49a4/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c", size = 736829, upload-time = "2024-08-06T20:32:06.459Z" }, + { url = "https://files.pythonhosted.org/packages/51/16/6af8d6a6b210c8e54f1406a6b9481febf9c64a3109c541567e35a49aa2e7/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317", size = 764167, upload-time = "2024-08-06T20:32:08.338Z" }, + { url = "https://files.pythonhosted.org/packages/75/e4/2c27590dfc9992f73aabbeb9241ae20220bd9452df27483b6e56d3975cc5/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85", size = 762952, upload-time = "2024-08-06T20:32:14.124Z" }, + { url = "https://files.pythonhosted.org/packages/9b/97/ecc1abf4a823f5ac61941a9c00fe501b02ac3ab0e373c3857f7d4b83e2b6/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4", size = 735301, upload-time = "2024-08-06T20:32:16.17Z" }, + { url = "https://files.pythonhosted.org/packages/45/73/0f49dacd6e82c9430e46f4a027baa4ca205e8b0a9dce1397f44edc23559d/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e", size = 756638, upload-time = "2024-08-06T20:32:18.555Z" }, + { url = "https://files.pythonhosted.org/packages/22/5f/956f0f9fc65223a58fbc14459bf34b4cc48dec52e00535c79b8db361aabd/PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5", size = 143850, upload-time = "2024-08-06T20:32:19.889Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/8da0bbe2ab9dcdd11f4f4557ccaf95c10b9811b13ecced089d43ce59c3c8/PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44", size = 161980, upload-time = "2024-08-06T20:32:21.273Z" }, + { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873, upload-time = "2024-08-06T20:32:25.131Z" }, + { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302, upload-time = "2024-08-06T20:32:26.511Z" }, + { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154, upload-time = "2024-08-06T20:32:28.363Z" }, + { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223, upload-time = "2024-08-06T20:32:30.058Z" }, + { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542, upload-time = "2024-08-06T20:32:31.881Z" }, + { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164, upload-time = "2024-08-06T20:32:37.083Z" }, + { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611, upload-time = "2024-08-06T20:32:38.898Z" }, + { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591, upload-time = "2024-08-06T20:32:40.241Z" }, + { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338, upload-time = "2024-08-06T20:32:41.93Z" }, + { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309, upload-time = "2024-08-06T20:32:43.4Z" }, + { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679, upload-time = "2024-08-06T20:32:44.801Z" }, + { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428, upload-time = "2024-08-06T20:32:46.432Z" }, + { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361, upload-time = "2024-08-06T20:32:51.188Z" }, + { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523, upload-time = "2024-08-06T20:32:53.019Z" }, + { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660, upload-time = "2024-08-06T20:32:54.708Z" }, + { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597, upload-time = "2024-08-06T20:32:56.985Z" }, + { url = "https://files.pythonhosted.org/packages/14/0d/e2c3b43bbce3cf6bd97c840b46088a3031085179e596d4929729d8d68270/PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183", size = 140527, upload-time = "2024-08-06T20:33:03.001Z" }, + { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446, upload-time = "2024-08-06T20:33:04.33Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "types-protobuf" +version = "6.30.2.20250914" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/36/d1/e12dad323fe6e2455b768828de288f60d5160f41dad5d31af8ef92a6acbb/types_protobuf-6.30.2.20250914.tar.gz", hash = "sha256:c2105326d0a52de3d33b84af0010d834ebbd4c17c50ff261fa82551ab75d9559", size = 62424, upload-time = "2025-09-14T02:56:00.798Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6c/c4/3fcb1f8e03456a8a33a5dfb9f9788b0a91023e5fad6a37d46fc6831629a7/types_protobuf-6.30.2.20250914-py3-none-any.whl", hash = "sha256:cfc24977c0f38cf2896d918a59faed7650eb983be6070343a6204ac8ac0a297e", size = 76546, upload-time = "2025-09-14T02:55:59.489Z" }, +] + +[[package]] +name = "types-python-dateutil" +version = "2.9.0.20250822" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0c/0a/775f8551665992204c756be326f3575abba58c4a3a52eef9909ef4536428/types_python_dateutil-2.9.0.20250822.tar.gz", hash = "sha256:84c92c34bd8e68b117bff742bc00b692a1e8531262d4507b33afcc9f7716cd53", size = 16084, upload-time = "2025-08-22T03:02:00.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ab/d9/a29dfa84363e88b053bf85a8b7f212a04f0d7343a4d24933baa45c06e08b/types_python_dateutil-2.9.0.20250822-py3-none-any.whl", hash = "sha256:849d52b737e10a6dc6621d2bd7940ec7c65fcb69e6aa2882acf4e56b2b508ddc", size = 17892, upload-time = "2025-08-22T03:01:59.436Z" }, +] + +[[package]] +name = "types-pyyaml" +version = "6.0.12.20250915" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/69/3c51b36d04da19b92f9e815be12753125bd8bc247ba0470a982e6979e71c/types_pyyaml-6.0.12.20250915.tar.gz", hash = "sha256:0f8b54a528c303f0e6f7165687dd33fafa81c807fcac23f632b63aa624ced1d3", size = 17522, upload-time = "2025-09-15T03:01:00.728Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/e0/1eed384f02555dde685fff1a1ac805c1c7dcb6dd019c916fe659b1c1f9ec/types_pyyaml-6.0.12.20250915-py3-none-any.whl", hash = "sha256:e7d4d9e064e89a3b3cae120b4990cd370874d2bf12fa5f46c97018dd5d3c9ab6", size = 20338, upload-time = "2025-09-15T03:00:59.218Z" }, +] diff --git a/flyteidl2/gen_utils/rust/Cargo.toml b/flyteidl2/gen_utils/rust/Cargo.toml new file mode 100644 index 0000000000..8c17d109ab --- /dev/null +++ b/flyteidl2/gen_utils/rust/Cargo.toml @@ -0,0 +1,50 @@ +[package] +name = "flyteidl2" +version = "0.1.0" +edition = "2021" +description = "Rust bindings and utilities for FlyteIDL protobufs." +license = "Apache-2.0" + +[dependencies] +pyo3 = { version = "0.24", features = ["experimental-async"] } +pyo3-async-runtimes = { version = "0.24", features = ["tokio-runtime"] } +tokio = { version = "1.0", features = ["full"] } +tonic = "0.12.3" +prost = { version = "0.13.5", features = ["std"] } +prost-types = { version = "0.12", features = ["std"] } +futures = "0.3" +tower = "0.4" +tower-http = { version = "0.5", features = ["trace"] } +tracing = "0.1" +tracing-subscriber = "0.3" +async-trait = "0.1" +thiserror = "1.0" +serde = { version = "1.0", features = ["derive"] } +pbjson = { version = "0.7.0" } +pbjson-types = { version = "0.7.0" } +protobuf = { version = "4.31.1-release" } +prost-build = "0.14" +quote = "1.0" +syn = { version = "2.0", features = ["full", "extra-traits"] } +prettyplease = "0.2" +regex = "1.11.1" + +[lib] +name = "flyteidl2" +path = "src/lib.rs" +#crate-type = ["cdylib"] + +[features] +default = [] +## @@protoc_insertion_point(features) + +[build-dependencies] +prost-build = "0.14" +pbjson-build = { version = "0.7.0" } +quote = "1.0" +syn = { version = "2.0", features = ["full", "extra-traits"] } +prettyplease = "0.2" +regex = "1.10" + +#[profile.dev.build-override] +#debug = true \ No newline at end of file diff --git a/flyteidl2/gen_utils/rust/build.rs b/flyteidl2/gen_utils/rust/build.rs new file mode 100644 index 0000000000..10e4c5c9df --- /dev/null +++ b/flyteidl2/gen_utils/rust/build.rs @@ -0,0 +1,516 @@ +//! Compiles Protocol Buffers and FlatBuffers schema definitions into +//! native Rust types. + +use prettyplease::unparse; +use quote::quote; +use std::fs::File; +use std::io::Write; +use std::path::PathBuf; +use syn::{parse_quote, Type}; + +type Error = Box; +type Result = std::result::Result; + +fn generate_boxed_impls() -> String { + // Define the types we want to implement Box for + let types: Vec = vec![ + parse_quote!(crate::validate::FieldRules), + parse_quote!(crate::validate::RepeatedRules), + parse_quote!(crate::validate::MapRules), + parse_quote!(crate::flyteidl::core::LiteralType), + parse_quote!(crate::flyteidl::core::Literal), + parse_quote!(crate::flyteidl::core::Union), + parse_quote!(crate::google::protobuf::FeatureSet), + parse_quote!(crate::flyteidl::core::Scalar), + // parse_quote!(crate::pyo3::types::PyBytes), + ]; + + // Generate the code using quote + let tokens = quote! { + use pyo3::prelude::*; + use pyo3::conversion::{IntoPyObject, FromPyObject}; + use std::convert::Infallible; + + #( + impl<'py> IntoPyObject<'py> for Box<#types> { + type Target = PyAny; + type Output = Bound<'py, Self::Target>; + type Error = Infallible; + + fn into_pyobject(self, py: Python<'py>) -> Result { + Ok(self.as_ref().clone().into_py(py).into_bound(py)) + } + } + + impl<'py> FromPyObject<'py> for Box<#types> { + fn extract_bound(obj: &Bound<'py, PyAny>) -> PyResult { + Ok(Box::new(#types::extract_bound(obj)?)) + } + } + )* + }; + + // Convert the generated code to a string and format it + let syntax = syn::parse_file(&tokens.to_string()).expect("Failed to parse generated code"); + unparse(&syntax) +} + +// Map file names to module paths +fn file_to_modpath(file: &str) -> Option<&'static str> { + match file { + "cloudidl.common.rs" => Some("crate::cloudidl::common"), + "cloudidl.workflow.rs" => Some("crate::cloudidl::workflow"), + "cloudidl.logs.dataplane.rs" => Some("crate::cloudidl::logs::dataplane"), + "flyteidl.core.rs" => Some("crate::flyteidl::core"), + "google.rpc.rs" => Some("crate::google::rpc"), + "validate.rs" => Some("crate::validate"), + _ => None, + } +} + +#[derive(Debug)] +struct ProstStructInfo { + ty: Type, + fq_name: String, + fields: Vec<(String, String)>, + is_tuple: bool, + mod_path: String, // e.g. crate::cloudidl::common +} + +// Find all prost-generated types in src/ +fn find_prost_types(src_dir: &PathBuf) -> Vec { + use std::collections::HashSet; + use std::path::Path; + use syn::{Fields, Item}; + + let mut structs = Vec::new(); + let mut visited = HashSet::new(); + + // Helper to recursively walk modules + fn walk_items(items: &[Item], mod_path: &mut Vec, structs: &mut Vec) { + for item in items { + match item { + Item::Mod(m) => { + mod_path.push(m.ident.to_string()); + // If inline module, recurse into its content + if let Some((_, items)) = &m.content { + walk_items(items, mod_path, structs); + } + // Outline modules are handled in the main loop + mod_path.pop(); + } + Item::Struct(s) => { + let fq = format!("{}::{}", mod_path.join("::"), s.ident); + let ty = match syn::parse_str::(&fq) { + Ok(t) => t, + Err(_) => continue, + }; + let (fields, is_tuple) = match &s.fields { + Fields::Named(fields) => { + let fields = fields + .named + .iter() + .map(|f| { + let name = f.ident.as_ref().unwrap().to_string(); + let ty = quote::ToTokens::to_token_stream(&f.ty).to_string(); + (name, ty) + }) + .collect(); + (fields, false) + } + Fields::Unnamed(fields) => { + let fields = fields + .unnamed + .iter() + .enumerate() + .map(|(i, f)| { + let name = format!("field{}", i); + let ty = quote::ToTokens::to_token_stream(&f.ty).to_string(); + (name, ty) + }) + .collect(); + (fields, true) + } + Fields::Unit => (vec![], false), + }; + let mod_path = mod_path.join("::"); + let mod_path = if !mod_path.is_empty() { + format!("crate::{}", mod_path) + } else { + "crate".to_string() + }; + structs.push(ProstStructInfo { + ty, + fq_name: fq, + fields, + is_tuple, + mod_path, + }); + } + _ => {} + } + } + } + + // Helper to parse a file and walk its items + fn parse_and_walk( + path: &Path, + mod_path: &mut Vec, + structs: &mut Vec, + visited: &mut HashSet, + ) { + if !visited.insert(path.to_path_buf()) { + return; + } + let content = match std::fs::read_to_string(path) { + Ok(c) => c, + Err(_) => return, + }; + let ast: syn::File = match syn::parse_file(&content) { + Ok(f) => f, + Err(_) => return, + }; + walk_items(&ast.items, mod_path, structs); + // Recursively handle outline modules + for item in &ast.items { + if let Item::Mod(m) = item { + if m.content.is_none() { + // Outline module: look for mod.rs or .rs + let mod_name = m.ident.to_string(); + let parent = path.parent().unwrap_or(Path::new("")); + let mod_rs = parent.join(&mod_name).join("mod.rs"); + let mod_file = parent.join(format!("{}.rs", mod_name)); + if mod_rs.exists() { + mod_path.push(mod_name.clone()); + parse_and_walk(&mod_rs, mod_path, structs, visited); + mod_path.pop(); + } else if mod_file.exists() { + mod_path.push(mod_name.clone()); + parse_and_walk(&mod_file, mod_path, structs, visited); + mod_path.pop(); + } + } + } + } + } + + for entry in std::fs::read_dir(src_dir).unwrap() { + let entry = entry.unwrap(); + let path = entry.path(); + let file_name = path.file_name().unwrap().to_string_lossy(); + + if !file_name.ends_with(".rs") || file_name == "serde_impl.rs" || file_name == "lib.rs" { + continue; + } + + let modpath = match file_to_modpath(&file_name) { + Some(m) => m.replace("crate::", ""), + None => continue, + }; + let mut mod_path: Vec = modpath.split("::").map(|s| s.to_string()).collect(); + parse_and_walk(&path, &mut mod_path, &mut structs, &mut visited); + } + structs +} + +fn generate_encode_decode(infos: &[ProstStructInfo]) -> String { + // Helper to qualify types + fn qualify_type(ty: &str, current_mod: &str) -> String { + let primitives = [ + "String", "u8", "u16", "u32", "u64", "i8", "i16", "i32", "i64", "bool", "f32", "f64", + "usize", "isize", "char", "str", + ]; + let ty = ty.trim(); + let mut ty_clean = ty + .replace(" :: ", "::") + .replace("crate ::", "crate::") + .replace("super ::", "super::") + .replace("self ::", "self::"); + while ty_clean.contains("::::") { + ty_clean = ty_clean.replace("::::", "::"); + } + // Handle generics recursively (e.g., Option, Vec) + if let Some(start) = ty_clean.find('<') { + if let Some(end) = ty_clean.rfind('>') { + let outer = &ty_clean[..start]; + let inner = &ty_clean[start + 1..end]; + let qualified_inner = inner + .split(',') + .map(|s| qualify_type(s, current_mod)) + .collect::>() + .join(", "); + return format!("{}<{}>", outer, qualified_inner); + } + } + // Handle super:: prefix by resolving up the module path + if ty_clean.starts_with("super::") { + let mut mod_parts: Vec<&str> = current_mod.split("::").collect(); + let mut ty_remainder = ty_clean.to_string(); + while ty_remainder.starts_with("super::") { + ty_remainder = ty_remainder[7..].to_string(); + if mod_parts.len() > 1 { + mod_parts.pop(); + } + } + let abs_path = if ty_remainder.is_empty() { + mod_parts.join("::") + } else { + format!("{}::{}", mod_parts.join("::"), ty_remainder) + }; + return abs_path; + } + if ty_clean.starts_with("self::") { + // self:: just means current_mod + let ty_remainder = &ty_clean[6..]; + return format!("{}::{}", current_mod, ty_remainder); + } + if ty_clean.starts_with("crate::") + || ty_clean.starts_with("::") + || ty_clean.starts_with("prost::") + || ty_clean.starts_with("core::") + || ty_clean.starts_with("std::") + || ty_clean.starts_with("alloc::") + { + ty_clean + } else if primitives.iter().any(|&p| ty_clean == p) + || ty_clean.starts_with("Option") + || ty_clean.starts_with("Vec") + || ty_clean.starts_with("HashMap") + { + ty_clean + } else if ty_clean.contains("::") { + // Prepend current_mod for relative paths like enriched_identity::Principal + format!("{}::{}", current_mod, ty_clean) + } else { + format!("{}::{}", current_mod, ty_clean.replace(' ', "")) + } + } + let mut py_methods = String::new(); + for info in infos { + let fq = info + .fq_name + .replace("crate :: ", "crate::") + .replace(" :: ", "::"); + let fields = &info.fields; + let is_tuple = info.is_tuple; + let mod_path = &info.mod_path; + let py_new = if fields.is_empty() { + format!( + " #[new]\n pub fn py_new() -> Self {{\n Self::default()\n }}\n" + ) + } else if is_tuple { + let args = fields + .iter() + .map(|(n, t)| format!("{}: {}", n, qualify_type(t, mod_path))) + .collect::>() + .join(", "); + let vals = fields + .iter() + .map(|(n, _)| n.clone()) + .collect::>() + .join(", "); + format!( + " #[new]\n pub fn py_new({}) -> Self {{\n Self({})\n }}\n", + args, vals + ) + } else { + let args = fields + .iter() + .map(|(n, t)| format!("{}: {}", n, qualify_type(t, mod_path))) + .collect::>() + .join(", "); + let vals = fields + .iter() + .map(|(n, _)| format!("{}", n)) + .collect::>() + .join(", "); + format!( + " #[new]\n pub fn py_new({}) -> Self {{\n Self {{ {} }}\n }}\n", + args, vals + ) + }; + py_methods += &format!( + r#" + #[::pyo3::pymethods] + impl {fq} {{ +{py_new} + fn __repr__(&self) -> String {{ + format!("{{:?}}", self) + }} + fn __str__(&self) -> String {{ + format!("{{:?}}", self) + }} + }} +"#, + fq = fq, + py_new = py_new + ); + } + + let syntax = syn::parse_file(&py_methods.to_string()).expect("Failed to parse generated code"); + unparse(&syntax) +} + +#[derive(Default)] +struct ModuleNode { + children: std::collections::HashMap, + types: Vec, // store fully qualified type paths +} + +fn build_module_tree( + types: &[Type], + all_types: &mut std::collections::BTreeSet, +) -> ModuleNode { + let mut root = ModuleNode::default(); + for ty in types { + let fq = quote!(#ty) + .to_string() + .replace("crate :: ", "crate::") + .replace(" :: ", "::"); + let parts: Vec<_> = fq.split("::").map(|s| s.trim().to_string()).collect(); + if parts.len() < 2 { + continue; + } + let (mod_path, type_name) = parts.split_at(parts.len() - 1); + let mut node = &mut root; + for part in mod_path { + node = node.children.entry(part.clone()).or_default(); + } + let full_type = parts.join("::"); + node.types.push(full_type.clone()); + all_types.insert(full_type); + } + root +} + +fn generate_pymodules_file( + module_tree: &ModuleNode, + all_types: &std::collections::BTreeSet, +) -> String { + let mut code = String::new(); + code += "use pyo3::prelude::*;\n\ + #[pyo3::pymodule]\n"; + // for ty in all_types { + // code += &format!( + // "use {}; + // ", + // ty + // ); + // } + code += &generate_pymodules(module_tree, &[]); + code +} + +fn generate_pymodules(node: &ModuleNode, mod_path: &[String]) -> String { + let mod_name = mod_path + .last() + .cloned() + .unwrap_or_else(|| "cloud".to_string()); + let func_name = if mod_path.is_empty() { + "init_pymodule".to_string() + } else { + format!("init_{}", mod_path.join("_")) + }; + let mut code = format!( + "pub fn {}_mod(_py: pyo3::Python, m: &Bound<'_, PyModule>) -> pyo3::PyResult<()> {{\n", + mod_name + ); + for ty in &node.types { + code += &format!(" m.add_class::()?;\n", ty); + } + for (child_name, _child_node) in &node.children { + let submod_func = format!("{}_mod", child_name.clone()); + code += &format!( + " let submod = pyo3::types::PyModule::new(_py, \"{}\")?;\n", + child_name + ); + code += &format!(" {}(_py, &submod)?;\n", submod_func); + code += &format!(" m.add_submodule(&submod)?;\n"); + } + code += " Ok(())\n}\n"; + for (child_name, child_node) in &node.children { + let mut child_path = mod_path.to_vec(); + child_path.push(child_name.clone()); + code += &generate_pymodules(child_node, &child_path); + } + code +} + +fn main() -> Result<()> { + let descriptor_path: PathBuf = "descriptors.bin".into(); + println!("cargo:rerun-if-changed={}", descriptor_path.display()); + + let mut config = prost_build::Config::new(); + config + .file_descriptor_set_path(&descriptor_path) + .compile_well_known_types() + .disable_comments(["."]) + // .bytes(["."]) // Add prost::bytes::Bytes exclusion + .type_attribute(".", "#[pyo3::pyclass(dict, get_all, set_all)]") + // .type_attribute(".", "#[pyo3_prost::pyclass_for_prost_struct]") + // .type_attribute("bytes::Bytes", "#[pyo3::pyclass(dict, get_all, set_all)]") + // .type_attribute( + // "::pyo3::types::PyBytes", + // "#[pyo3::pyclass(dict, get_all, set_all)]", + // ) + .skip_protoc_run(); + + let empty: &[&str] = &[]; + config.compile_protos(empty, empty)?; + + let descriptor_set = std::fs::read(descriptor_path)?; + pbjson_build::Builder::new() + .register_descriptors(&descriptor_set)? + .exclude([ + ".google.protobuf.Duration", + ".google.protobuf.Timestamp", + ".google.protobuf.Value", + ".google.protobuf.Struct", + ".google.protobuf.ListValue", + ".google.protobuf.NullValue", + ".google.protobuf.BoolValue", + ".google.protobuf.BytesValue", + ".google.protobuf.DoubleValue", + ".google.protobuf.FloatValue", + ".google.protobuf.Int32Value", + ".google.protobuf.Int64Value", + ".google.protobuf.StringValue", + ".google.protobuf.UInt32Value", + ".google.protobuf.UInt64Value", + ]) + .build(&[".google"])?; + + // Generate Box implementations + let boxed_impls = generate_boxed_impls(); + let out_dir = std::env::var("OUT_DIR").unwrap(); + let boxed_impls_path = PathBuf::from(&out_dir).join("boxed_impls.rs"); + let mut file = File::create(boxed_impls_path)?; + file.write_all(boxed_impls.as_bytes())?; + + // Find all prost types + let src_dir = PathBuf::from("src"); + let prost_infos = find_prost_types(&src_dir); + eprintln!("Found {} prost types", prost_infos.len()); + eprintln!("Generating implementations for {:?} types", prost_infos); + // unsafe { std::intrinsics::breakpoint(); } + + // Generate encode,decode implementations for all prost types + let serde_impls = generate_encode_decode(&prost_infos); + let serde_impls_path = PathBuf::from(&out_dir).join("serde_impls.rs"); + let mut file = File::create(serde_impls_path)?; + file.write_all(serde_impls.as_bytes())?; + + // --- New: Generate PyO3 module tree code --- + let mut all_types = std::collections::BTreeSet::new(); + let module_tree = build_module_tree( + &prost_infos.iter().map(|i| i.ty.clone()).collect::>(), + &mut all_types, + ); + let pymodules_code = generate_pymodules_file(&module_tree, &all_types); + let pymodules_path = PathBuf::from(&out_dir).join("pymodules.rs"); + let mut file = File::create(pymodules_path)?; + file.write_all(pymodules_code.as_bytes())?; + // --- End new --- + + Ok(()) +} diff --git a/flyteidl2/gen_utils/rust/descriptors.bin b/flyteidl2/gen_utils/rust/descriptors.bin new file mode 100644 index 0000000000..0e370ea3c1 Binary files /dev/null and b/flyteidl2/gen_utils/rust/descriptors.bin differ diff --git a/flyteidl2/gen_utils/rust/pyproject.toml b/flyteidl2/gen_utils/rust/pyproject.toml new file mode 100644 index 0000000000..350cb34e25 --- /dev/null +++ b/flyteidl2/gen_utils/rust/pyproject.toml @@ -0,0 +1,17 @@ +[build-system] +requires = ["maturin>=1.9,<2.0"] +build-backend = "maturin" + +[project] +name = "flyteidl" +version = "0.1.0" +description = "Rust protos for Flyte" +requires-python = ">=3.10" +classifiers = [ + "Programming Language :: Python", + "Programming Language :: Rust", +] + +[tool.maturin] +python-source = "src" +module-name = "flyte_mod" diff --git a/flyteidl2/gen_utils/rust/src/google.rpc.rs b/flyteidl2/gen_utils/rust/src/google.rpc.rs new file mode 100644 index 0000000000..2576dadaf8 --- /dev/null +++ b/flyteidl2/gen_utils/rust/src/google.rpc.rs @@ -0,0 +1,163 @@ +// @generated +// This file is @generated by prost-build. +/// The `Status` type defines a logical error model that is suitable for +/// different programming environments, including REST APIs and RPC APIs. It is +/// used by [gRPC](). Each `Status` message contains +/// three pieces of data: error code, error message, and error details. +/// +/// You can find out more about this error model and how to work with it in the +/// [API Design Guide](). +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Status { + /// The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]. + #[prost(int32, tag="1")] + pub code: i32, + /// A developer-facing error message, which should be in English. Any + /// user-facing error message should be localized and sent in the + /// [google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client. + #[prost(string, tag="2")] + pub message: ::prost::alloc::string::String, + /// A list of messages that carry the error details. There is a common set of + /// message types for APIs to use. + #[prost(message, repeated, tag="3")] + pub details: ::prost::alloc::vec::Vec, +} +/// Encoded file descriptor set for the `google.rpc` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xc5, 0x10, 0x0a, 0x17, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x72, 0x70, 0x63, 0x2f, + 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0a, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x72, 0x70, 0x63, 0x1a, 0x19, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x22, 0x66, 0x0a, 0x06, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x12, 0x0a, + 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x63, 0x6f, 0x64, + 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x2e, 0x0a, 0x07, 0x64, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, + 0x6e, 0x79, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x42, 0xa2, 0x01, 0x0a, 0x0e, + 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x72, 0x70, 0x63, 0x42, 0x0b, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x37, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, + 0x2f, 0x67, 0x65, 0x6e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x61, 0x70, 0x69, 0x73, 0x2f, 0x72, 0x70, 0x63, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x3b, + 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0xf8, 0x01, 0x01, 0xa2, 0x02, 0x03, 0x47, 0x52, 0x58, 0xaa, + 0x02, 0x0a, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x52, 0x70, 0x63, 0xca, 0x02, 0x0a, 0x47, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5c, 0x52, 0x70, 0x63, 0xe2, 0x02, 0x16, 0x47, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x5c, 0x52, 0x70, 0x63, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x0b, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x3a, 0x3a, 0x52, 0x70, 0x63, + 0x4a, 0xed, 0x0d, 0x0a, 0x06, 0x12, 0x04, 0x0e, 0x00, 0x2e, 0x01, 0x0a, 0xbc, 0x04, 0x0a, 0x01, + 0x0c, 0x12, 0x03, 0x0e, 0x00, 0x12, 0x32, 0xb1, 0x04, 0x20, 0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x20, 0x32, 0x30, 0x32, 0x30, 0x20, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x20, + 0x4c, 0x4c, 0x43, 0x0a, 0x0a, 0x20, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x64, 0x20, 0x75, + 0x6e, 0x64, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x41, 0x70, 0x61, 0x63, 0x68, 0x65, 0x20, + 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x2c, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x20, 0x32, 0x2e, 0x30, 0x20, 0x28, 0x74, 0x68, 0x65, 0x20, 0x22, 0x4c, 0x69, 0x63, 0x65, 0x6e, + 0x73, 0x65, 0x22, 0x29, 0x3b, 0x0a, 0x20, 0x79, 0x6f, 0x75, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x6e, + 0x6f, 0x74, 0x20, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6c, 0x65, + 0x20, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, + 0x69, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4c, + 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x2e, 0x0a, 0x20, 0x59, 0x6f, 0x75, 0x20, 0x6d, 0x61, 0x79, + 0x20, 0x6f, 0x62, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x70, 0x79, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x20, 0x61, 0x74, + 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, + 0x77, 0x2e, 0x61, 0x70, 0x61, 0x63, 0x68, 0x65, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x6c, 0x69, 0x63, + 0x65, 0x6e, 0x73, 0x65, 0x73, 0x2f, 0x4c, 0x49, 0x43, 0x45, 0x4e, 0x53, 0x45, 0x2d, 0x32, 0x2e, + 0x30, 0x0a, 0x0a, 0x20, 0x55, 0x6e, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, + 0x72, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, + 0x65, 0x20, 0x6c, 0x61, 0x77, 0x20, 0x6f, 0x72, 0x20, 0x61, 0x67, 0x72, 0x65, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x72, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x2c, 0x20, 0x73, + 0x6f, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x0a, 0x20, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4c, + 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x20, 0x69, 0x73, 0x20, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, + 0x62, 0x75, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x20, 0x22, 0x41, 0x53, 0x20, + 0x49, 0x53, 0x22, 0x20, 0x42, 0x41, 0x53, 0x49, 0x53, 0x2c, 0x0a, 0x20, 0x57, 0x49, 0x54, 0x48, + 0x4f, 0x55, 0x54, 0x20, 0x57, 0x41, 0x52, 0x52, 0x41, 0x4e, 0x54, 0x49, 0x45, 0x53, 0x20, 0x4f, + 0x52, 0x20, 0x43, 0x4f, 0x4e, 0x44, 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x53, 0x20, 0x4f, 0x46, 0x20, + 0x41, 0x4e, 0x59, 0x20, 0x4b, 0x49, 0x4e, 0x44, 0x2c, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, + 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x20, 0x6f, 0x72, 0x20, 0x69, 0x6d, 0x70, 0x6c, + 0x69, 0x65, 0x64, 0x2e, 0x0a, 0x20, 0x53, 0x65, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4c, 0x69, + 0x63, 0x65, 0x6e, 0x73, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x20, + 0x67, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x0a, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x2e, 0x0a, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, + 0x03, 0x10, 0x00, 0x13, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x12, 0x00, 0x23, 0x0a, + 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x14, 0x00, 0x1f, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x1f, 0x12, + 0x03, 0x14, 0x00, 0x1f, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x15, 0x00, 0x4e, 0x0a, 0x09, + 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x15, 0x00, 0x4e, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, + 0x16, 0x00, 0x22, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0a, 0x12, 0x03, 0x16, 0x00, 0x22, 0x0a, 0x08, + 0x0a, 0x01, 0x08, 0x12, 0x03, 0x17, 0x00, 0x2c, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x08, 0x12, 0x03, + 0x17, 0x00, 0x2c, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x18, 0x00, 0x27, 0x0a, 0x09, 0x0a, + 0x02, 0x08, 0x01, 0x12, 0x03, 0x18, 0x00, 0x27, 0x0a, 0xbe, 0x03, 0x0a, 0x02, 0x04, 0x00, 0x12, + 0x04, 0x22, 0x00, 0x2e, 0x01, 0x1a, 0xb1, 0x03, 0x20, 0x54, 0x68, 0x65, 0x20, 0x60, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x60, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, + 0x65, 0x73, 0x20, 0x61, 0x20, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x65, 0x72, 0x72, + 0x6f, 0x72, 0x20, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, + 0x20, 0x73, 0x75, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x0a, 0x20, 0x64, + 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, + 0x6d, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, + 0x73, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x52, 0x45, 0x53, + 0x54, 0x20, 0x41, 0x50, 0x49, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x52, 0x50, 0x43, 0x20, 0x41, + 0x50, 0x49, 0x73, 0x2e, 0x20, 0x49, 0x74, 0x20, 0x69, 0x73, 0x0a, 0x20, 0x75, 0x73, 0x65, 0x64, + 0x20, 0x62, 0x79, 0x20, 0x5b, 0x67, 0x52, 0x50, 0x43, 0x5d, 0x28, 0x68, 0x74, 0x74, 0x70, 0x73, + 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x72, + 0x70, 0x63, 0x29, 0x2e, 0x20, 0x45, 0x61, 0x63, 0x68, 0x20, 0x60, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x60, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x73, 0x0a, 0x20, 0x74, 0x68, 0x72, 0x65, 0x65, 0x20, 0x70, 0x69, 0x65, 0x63, 0x65, + 0x73, 0x20, 0x6f, 0x66, 0x20, 0x64, 0x61, 0x74, 0x61, 0x3a, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, + 0x20, 0x63, 0x6f, 0x64, 0x65, 0x2c, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, + 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x0a, 0x0a, 0x20, 0x59, 0x6f, 0x75, 0x20, 0x63, + 0x61, 0x6e, 0x20, 0x66, 0x69, 0x6e, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6d, 0x6f, 0x72, 0x65, + 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x65, 0x72, 0x72, 0x6f, + 0x72, 0x20, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x68, 0x6f, 0x77, 0x20, + 0x74, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x69, 0x74, 0x20, + 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x5b, 0x41, 0x50, 0x49, 0x20, 0x44, 0x65, 0x73, + 0x69, 0x67, 0x6e, 0x20, 0x47, 0x75, 0x69, 0x64, 0x65, 0x5d, 0x28, 0x68, 0x74, 0x74, 0x70, 0x73, + 0x3a, 0x2f, 0x2f, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x2f, + 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x29, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, + 0x12, 0x03, 0x22, 0x08, 0x0e, 0x0a, 0x64, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x24, + 0x02, 0x11, 0x1a, 0x57, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, + 0x63, 0x6f, 0x64, 0x65, 0x2c, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x6e, 0x75, 0x6d, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x5b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x72, + 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x64, 0x65, 0x5d, 0x5b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x64, 0x65, 0x5d, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x24, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x24, 0x08, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x24, 0x0f, 0x10, 0x0a, 0xeb, 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, + 0x29, 0x02, 0x15, 0x1a, 0xdd, 0x01, 0x20, 0x41, 0x20, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, + 0x65, 0x72, 0x2d, 0x66, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2c, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x45, 0x6e, 0x67, 0x6c, + 0x69, 0x73, 0x68, 0x2e, 0x20, 0x41, 0x6e, 0x79, 0x0a, 0x20, 0x75, 0x73, 0x65, 0x72, 0x2d, 0x66, + 0x61, 0x63, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x6f, + 0x63, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x65, 0x6e, 0x74, + 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x5b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x64, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x5d, 0x5b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x72, 0x70, 0x63, 0x2e, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x5d, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x69, + 0x7a, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x29, 0x02, + 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x29, 0x09, 0x10, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x29, 0x13, 0x14, 0x0a, 0x79, 0x0a, + 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x2d, 0x02, 0x2b, 0x1a, 0x6c, 0x20, 0x41, 0x20, 0x6c, + 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x72, 0x72, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, + 0x72, 0x72, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x20, 0x20, 0x54, + 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x41, 0x50, 0x49, 0x73, 0x20, + 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, + 0x04, 0x12, 0x03, 0x2d, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, + 0x03, 0x2d, 0x0b, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x2d, + 0x1f, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x2d, 0x29, 0x2a, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +]; +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/flyteidl2/gen_utils/rust/src/lib.rs b/flyteidl2/gen_utils/rust/src/lib.rs new file mode 100644 index 0000000000..31b27dc8b9 --- /dev/null +++ b/flyteidl2/gen_utils/rust/src/lib.rs @@ -0,0 +1,99 @@ +// mod test_foo; + +// mod serde; + +// mod serde_impl; + +use pyo3; +use pyo3::prelude::*; +// use crate::HeartbeatResponse; +// include!("flyteidl.common.rs"); +// include!("flyteidl.workflow.rs"); +// include!("flyteidl.workflow.tonic.rs"); +// inculde!("flyteidl.logs.dataplane.rs"); +// include!("flyteidl.core.rs"); +// include!("google.rpc.rs"); +// include!("validate.rs"); + +// use crate::*; +// Re-export all generated protobuf modules +pub mod flyteidl { + + pub mod common { + include!("flyteidl2.common.rs"); + } + pub mod workflow { + include!("flyteidl2.workflow.rs"); + } + + pub mod logs { + pub mod dataplane { + include!("flyteidl2.logs.dataplane.rs"); + } + } + + pub mod core { + include!("flyteidl2.core.rs"); + } + + pub mod task { + include!("flyteidl2.task.rs"); + } + + pub mod trigger { + include!("flyteidl2.trigger.rs"); + } + + pub mod secret { + include!("flyteidl2.secret.rs"); + } +} + +// use pyo3_prost::pyclass_for_prost_struct; +pub mod google { + pub mod rpc { + include!("google.rpc.rs"); + // pub mod serde { + // include!("google.rpc.serde.rs"); + // } + } + pub mod protobuf { + include!(concat!(env!("OUT_DIR"), "/google.protobuf.rs")); + include!(concat!(env!("OUT_DIR"), "/google.protobuf.serde.rs")); + } +} + +pub mod validate { + include!("validate.rs"); + // pub mod serde { + // include!("validate.serde.rs"); + // } +} + +// Include the generated Box implementations +include!(concat!(env!("OUT_DIR"), "/boxed_impls.rs")); +// pub mod serde { +// include!(concat!(env!("OUT_DIR"), "/serde_impls.rs")); +// } +pub mod pymodules { + include!(concat!(env!("OUT_DIR"), "/pymodules.rs")); +} + +include!(concat!(env!("OUT_DIR"), "/serde_impls.rs")); +// include!("serde_impl.rs"); + +// +// // Re-export commonly used types at the root level for convenience +// pub use flyteidl::common::*; +// pub use flyteidl::workflow::*; +// pub use flyteidl::core::*; +// pub use google::rpc::*; +// pub use validate::*; +// pub use crate::*; + +// #[pymodule] +// fn pb_rust(_py: Python, m: &PyModule) -> PyResult<()> { +// m.add_submodule(flyteidl::workflow::make_module(_py)?)?; +// // ... all submodules ... +// Ok(()) +// } diff --git a/flyteidl2/gen_utils/rust/src/validate.rs b/flyteidl2/gen_utils/rust/src/validate.rs new file mode 100644 index 0000000000..01f02e8ad8 --- /dev/null +++ b/flyteidl2/gen_utils/rust/src/validate.rs @@ -0,0 +1,3658 @@ +// @generated +// This file is @generated by prost-build. +/// FieldRules encapsulates the rules for each type of field. Depending on the +/// field, the correct set should be used to ensure proper validations. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FieldRules { + #[prost(message, optional, tag="17")] + pub message: ::core::option::Option, + #[prost(oneof="field_rules::Type", tags="1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 20, 21, 22")] + pub r#type: ::core::option::Option, +} +/// Nested message and enum types in `FieldRules`. +pub mod field_rules { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Type { + /// Scalar Field Types + #[prost(message, tag="1")] + Float(super::FloatRules), + #[prost(message, tag="2")] + Double(super::DoubleRules), + #[prost(message, tag="3")] + Int32(super::Int32Rules), + #[prost(message, tag="4")] + Int64(super::Int64Rules), + #[prost(message, tag="5")] + Uint32(super::UInt32Rules), + #[prost(message, tag="6")] + Uint64(super::UInt64Rules), + #[prost(message, tag="7")] + Sint32(super::SInt32Rules), + #[prost(message, tag="8")] + Sint64(super::SInt64Rules), + #[prost(message, tag="9")] + Fixed32(super::Fixed32Rules), + #[prost(message, tag="10")] + Fixed64(super::Fixed64Rules), + #[prost(message, tag="11")] + Sfixed32(super::SFixed32Rules), + #[prost(message, tag="12")] + Sfixed64(super::SFixed64Rules), + #[prost(message, tag="13")] + Bool(super::BoolRules), + #[prost(message, tag="14")] + String(super::StringRules), + #[prost(message, tag="15")] + Bytes(super::BytesRules), + /// Complex Field Types + #[prost(message, tag="16")] + Enum(super::EnumRules), + #[prost(message, tag="18")] + Repeated(::prost::alloc::boxed::Box), + #[prost(message, tag="19")] + Map(::prost::alloc::boxed::Box), + /// Well-Known Field Types + #[prost(message, tag="20")] + Any(super::AnyRules), + #[prost(message, tag="21")] + Duration(super::DurationRules), + #[prost(message, tag="22")] + Timestamp(super::TimestampRules), + } +} +/// FloatRules describes the constraints applied to `float` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FloatRules { + /// Const specifies that this field must be exactly the specified value + #[prost(float, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(float, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(float, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(float, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(float, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(float, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(float, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// DoubleRules describes the constraints applied to `double` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DoubleRules { + /// Const specifies that this field must be exactly the specified value + #[prost(double, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(double, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(double, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(double, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(double, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(double, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(double, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// Int32Rules describes the constraints applied to `int32` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Int32Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(int32, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(int32, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(int32, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(int32, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(int32, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(int32, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(int32, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// Int64Rules describes the constraints applied to `int64` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Int64Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(int64, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(int64, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(int64, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(int64, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(int64, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(int64, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(int64, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// UInt32Rules describes the constraints applied to `uint32` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UInt32Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(uint32, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(uint32, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(uint32, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(uint32, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(uint32, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(uint32, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(uint32, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// UInt64Rules describes the constraints applied to `uint64` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UInt64Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(uint64, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(uint64, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(uint64, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(uint64, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(uint64, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(uint64, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(uint64, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// SInt32Rules describes the constraints applied to `sint32` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SInt32Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(sint32, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(sint32, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(sint32, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(sint32, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(sint32, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(sint32, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(sint32, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// SInt64Rules describes the constraints applied to `sint64` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SInt64Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(sint64, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(sint64, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(sint64, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(sint64, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(sint64, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(sint64, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(sint64, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// Fixed32Rules describes the constraints applied to `fixed32` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Fixed32Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(fixed32, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(fixed32, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(fixed32, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(fixed32, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(fixed32, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(fixed32, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(fixed32, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// Fixed64Rules describes the constraints applied to `fixed64` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Fixed64Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(fixed64, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(fixed64, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(fixed64, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(fixed64, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(fixed64, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(fixed64, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(fixed64, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// SFixed32Rules describes the constraints applied to `sfixed32` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SFixed32Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(sfixed32, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(sfixed32, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(sfixed32, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(sfixed32, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(sfixed32, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(sfixed32, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(sfixed32, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// SFixed64Rules describes the constraints applied to `sfixed64` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SFixed64Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(sfixed64, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(sfixed64, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(sfixed64, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(sfixed64, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(sfixed64, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(sfixed64, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(sfixed64, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// BoolRules describes the constraints applied to `bool` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct BoolRules { + /// Const specifies that this field must be exactly the specified value + #[prost(bool, optional, tag="1")] + pub r#const: ::core::option::Option, +} +/// StringRules describe the constraints applied to `string` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct StringRules { + /// Const specifies that this field must be exactly the specified value + #[prost(string, optional, tag="1")] + pub r#const: ::core::option::Option<::prost::alloc::string::String>, + /// Len specifies that this field must be the specified number of + /// characters (Unicode code points). Note that the number of + /// characters may differ from the number of bytes in the string. + #[prost(uint64, optional, tag="19")] + pub len: ::core::option::Option, + /// MinLen specifies that this field must be the specified number of + /// characters (Unicode code points) at a minimum. Note that the number of + /// characters may differ from the number of bytes in the string. + #[prost(uint64, optional, tag="2")] + pub min_len: ::core::option::Option, + /// MaxLen specifies that this field must be the specified number of + /// characters (Unicode code points) at a maximum. Note that the number of + /// characters may differ from the number of bytes in the string. + #[prost(uint64, optional, tag="3")] + pub max_len: ::core::option::Option, + /// LenBytes specifies that this field must be the specified number of bytes + #[prost(uint64, optional, tag="20")] + pub len_bytes: ::core::option::Option, + /// MinBytes specifies that this field must be the specified number of bytes + /// at a minimum + #[prost(uint64, optional, tag="4")] + pub min_bytes: ::core::option::Option, + /// MaxBytes specifies that this field must be the specified number of bytes + /// at a maximum + #[prost(uint64, optional, tag="5")] + pub max_bytes: ::core::option::Option, + /// Pattern specifies that this field must match against the specified + /// regular expression (RE2 syntax). The included expression should elide + /// any delimiters. + #[prost(string, optional, tag="6")] + pub pattern: ::core::option::Option<::prost::alloc::string::String>, + /// Prefix specifies that this field must have the specified substring at + /// the beginning of the string. + #[prost(string, optional, tag="7")] + pub prefix: ::core::option::Option<::prost::alloc::string::String>, + /// Suffix specifies that this field must have the specified substring at + /// the end of the string. + #[prost(string, optional, tag="8")] + pub suffix: ::core::option::Option<::prost::alloc::string::String>, + /// Contains specifies that this field must have the specified substring + /// anywhere in the string. + #[prost(string, optional, tag="9")] + pub contains: ::core::option::Option<::prost::alloc::string::String>, + /// NotContains specifies that this field cannot have the specified substring + /// anywhere in the string. + #[prost(string, optional, tag="23")] + pub not_contains: ::core::option::Option<::prost::alloc::string::String>, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(string, repeated, tag="10")] + pub r#in: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(string, repeated, tag="11")] + pub not_in: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// This applies to regexes HTTP_HEADER_NAME and HTTP_HEADER_VALUE to enable + /// strict header validation. + /// By default, this is true, and HTTP header validations are RFC-compliant. + /// Setting to false will enable a looser validations that only disallows + /// \r\n\0 characters, which can be used to bypass header matching rules. + #[prost(bool, optional, tag="25", default="true")] + pub strict: ::core::option::Option, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="26")] + pub ignore_empty: ::core::option::Option, + /// WellKnown rules provide advanced constraints against common string + /// patterns + #[prost(oneof="string_rules::WellKnown", tags="12, 13, 14, 15, 16, 17, 18, 21, 22, 24")] + pub well_known: ::core::option::Option, +} +/// Nested message and enum types in `StringRules`. +pub mod string_rules { + /// WellKnown rules provide advanced constraints against common string + /// patterns + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Oneof)] + pub enum WellKnown { + /// Email specifies that the field must be a valid email address as + /// defined by RFC 5322 + #[prost(bool, tag="12")] + Email(bool), + /// Hostname specifies that the field must be a valid hostname as + /// defined by RFC 1034. This constraint does not support + /// internationalized domain names (IDNs). + #[prost(bool, tag="13")] + Hostname(bool), + /// Ip specifies that the field must be a valid IP (v4 or v6) address. + /// Valid IPv6 addresses should not include surrounding square brackets. + #[prost(bool, tag="14")] + Ip(bool), + /// Ipv4 specifies that the field must be a valid IPv4 address. + #[prost(bool, tag="15")] + Ipv4(bool), + /// Ipv6 specifies that the field must be a valid IPv6 address. Valid + /// IPv6 addresses should not include surrounding square brackets. + #[prost(bool, tag="16")] + Ipv6(bool), + /// Uri specifies that the field must be a valid, absolute URI as defined + /// by RFC 3986 + #[prost(bool, tag="17")] + Uri(bool), + /// UriRef specifies that the field must be a valid URI as defined by RFC + /// 3986 and may be relative or absolute. + #[prost(bool, tag="18")] + UriRef(bool), + /// Address specifies that the field must be either a valid hostname as + /// defined by RFC 1034 (which does not support internationalized domain + /// names or IDNs), or it can be a valid IP (v4 or v6). + #[prost(bool, tag="21")] + Address(bool), + /// Uuid specifies that the field must be a valid UUID as defined by + /// RFC 4122 + #[prost(bool, tag="22")] + Uuid(bool), + /// WellKnownRegex specifies a common well known pattern defined as a regex. + #[prost(enumeration="super::KnownRegex", tag="24")] + WellKnownRegex(i32), + } +} +/// BytesRules describe the constraints applied to `bytes` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BytesRules { + /// Const specifies that this field must be exactly the specified value + #[prost(bytes="vec", optional, tag="1")] + pub r#const: ::core::option::Option<::prost::alloc::vec::Vec>, + /// Len specifies that this field must be the specified number of bytes + #[prost(uint64, optional, tag="13")] + pub len: ::core::option::Option, + /// MinLen specifies that this field must be the specified number of bytes + /// at a minimum + #[prost(uint64, optional, tag="2")] + pub min_len: ::core::option::Option, + /// MaxLen specifies that this field must be the specified number of bytes + /// at a maximum + #[prost(uint64, optional, tag="3")] + pub max_len: ::core::option::Option, + /// Pattern specifies that this field must match against the specified + /// regular expression (RE2 syntax). The included expression should elide + /// any delimiters. + #[prost(string, optional, tag="4")] + pub pattern: ::core::option::Option<::prost::alloc::string::String>, + /// Prefix specifies that this field must have the specified bytes at the + /// beginning of the string. + #[prost(bytes="vec", optional, tag="5")] + pub prefix: ::core::option::Option<::prost::alloc::vec::Vec>, + /// Suffix specifies that this field must have the specified bytes at the + /// end of the string. + #[prost(bytes="vec", optional, tag="6")] + pub suffix: ::core::option::Option<::prost::alloc::vec::Vec>, + /// Contains specifies that this field must have the specified bytes + /// anywhere in the string. + #[prost(bytes="vec", optional, tag="7")] + pub contains: ::core::option::Option<::prost::alloc::vec::Vec>, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(bytes="vec", repeated, tag="8")] + pub r#in: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(bytes="vec", repeated, tag="9")] + pub not_in: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="14")] + pub ignore_empty: ::core::option::Option, + /// WellKnown rules provide advanced constraints against common byte + /// patterns + #[prost(oneof="bytes_rules::WellKnown", tags="10, 11, 12")] + pub well_known: ::core::option::Option, +} +/// Nested message and enum types in `BytesRules`. +pub mod bytes_rules { + /// WellKnown rules provide advanced constraints against common byte + /// patterns + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Oneof)] + pub enum WellKnown { + /// Ip specifies that the field must be a valid IP (v4 or v6) address in + /// byte format + #[prost(bool, tag="10")] + Ip(bool), + /// Ipv4 specifies that the field must be a valid IPv4 address in byte + /// format + #[prost(bool, tag="11")] + Ipv4(bool), + /// Ipv6 specifies that the field must be a valid IPv6 address in byte + /// format + #[prost(bool, tag="12")] + Ipv6(bool), + } +} +/// EnumRules describe the constraints applied to enum values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EnumRules { + /// Const specifies that this field must be exactly the specified value + #[prost(int32, optional, tag="1")] + pub r#const: ::core::option::Option, + /// DefinedOnly specifies that this field must be only one of the defined + /// values for this enum, failing on any undefined value. + #[prost(bool, optional, tag="2")] + pub defined_only: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(int32, repeated, packed="false", tag="3")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(int32, repeated, packed="false", tag="4")] + pub not_in: ::prost::alloc::vec::Vec, +} +/// MessageRules describe the constraints applied to embedded message values. +/// For message-type fields, validation is performed recursively. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MessageRules { + /// Skip specifies that the validation rules of this field should not be + /// evaluated + #[prost(bool, optional, tag="1")] + pub skip: ::core::option::Option, + /// Required specifies that this field must be set + #[prost(bool, optional, tag="2")] + pub required: ::core::option::Option, +} +/// RepeatedRules describe the constraints applied to `repeated` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RepeatedRules { + /// MinItems specifies that this field must have the specified number of + /// items at a minimum + #[prost(uint64, optional, tag="1")] + pub min_items: ::core::option::Option, + /// MaxItems specifies that this field must have the specified number of + /// items at a maximum + #[prost(uint64, optional, tag="2")] + pub max_items: ::core::option::Option, + /// Unique specifies that all elements in this field must be unique. This + /// constraint is only applicable to scalar and enum types (messages are not + /// supported). + #[prost(bool, optional, tag="3")] + pub unique: ::core::option::Option, + /// Items specifies the constraints to be applied to each item in the field. + /// Repeated message fields will still execute validation against each item + /// unless skip is specified here. + #[prost(message, optional, boxed, tag="4")] + pub items: ::core::option::Option<::prost::alloc::boxed::Box>, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="5")] + pub ignore_empty: ::core::option::Option, +} +/// MapRules describe the constraints applied to `map` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MapRules { + /// MinPairs specifies that this field must have the specified number of + /// KVs at a minimum + #[prost(uint64, optional, tag="1")] + pub min_pairs: ::core::option::Option, + /// MaxPairs specifies that this field must have the specified number of + /// KVs at a maximum + #[prost(uint64, optional, tag="2")] + pub max_pairs: ::core::option::Option, + /// NoSparse specifies values in this field cannot be unset. This only + /// applies to map's with message value types. + #[prost(bool, optional, tag="3")] + pub no_sparse: ::core::option::Option, + /// Keys specifies the constraints to be applied to each key in the field. + #[prost(message, optional, boxed, tag="4")] + pub keys: ::core::option::Option<::prost::alloc::boxed::Box>, + /// Values specifies the constraints to be applied to the value of each key + /// in the field. Message values will still have their validations evaluated + /// unless skip is specified here. + #[prost(message, optional, boxed, tag="5")] + pub values: ::core::option::Option<::prost::alloc::boxed::Box>, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="6")] + pub ignore_empty: ::core::option::Option, +} +/// AnyRules describe constraints applied exclusively to the +/// `google.protobuf.Any` well-known type +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AnyRules { + /// Required specifies that this field must be set + #[prost(bool, optional, tag="1")] + pub required: ::core::option::Option, + /// In specifies that this field's `type_url` must be equal to one of the + /// specified values. + #[prost(string, repeated, tag="2")] + pub r#in: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// NotIn specifies that this field's `type_url` must not be equal to any of + /// the specified values. + #[prost(string, repeated, tag="3")] + pub not_in: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +/// DurationRules describe the constraints applied exclusively to the +/// `google.protobuf.Duration` well-known type +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DurationRules { + /// Required specifies that this field must be set + #[prost(bool, optional, tag="1")] + pub required: ::core::option::Option, + /// Const specifies that this field must be exactly the specified value + #[prost(message, optional, tag="2")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(message, optional, tag="3")] + pub lt: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// inclusive + #[prost(message, optional, tag="4")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive + #[prost(message, optional, tag="5")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than the specified value, + /// inclusive + #[prost(message, optional, tag="6")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(message, repeated, tag="7")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(message, repeated, tag="8")] + pub not_in: ::prost::alloc::vec::Vec, +} +/// TimestampRules describe the constraints applied exclusively to the +/// `google.protobuf.Timestamp` well-known type +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct TimestampRules { + /// Required specifies that this field must be set + #[prost(bool, optional, tag="1")] + pub required: ::core::option::Option, + /// Const specifies that this field must be exactly the specified value + #[prost(message, optional, tag="2")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(message, optional, tag="3")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than the specified value, + /// inclusive + #[prost(message, optional, tag="4")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive + #[prost(message, optional, tag="5")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than the specified value, + /// inclusive + #[prost(message, optional, tag="6")] + pub gte: ::core::option::Option, + /// LtNow specifies that this must be less than the current time. LtNow + /// can only be used with the Within rule. + #[prost(bool, optional, tag="7")] + pub lt_now: ::core::option::Option, + /// GtNow specifies that this must be greater than the current time. GtNow + /// can only be used with the Within rule. + #[prost(bool, optional, tag="8")] + pub gt_now: ::core::option::Option, + /// Within specifies that this field must be within this duration of the + /// current time. This constraint can be used alone or with the LtNow and + /// GtNow rules. + #[prost(message, optional, tag="9")] + pub within: ::core::option::Option, +} +/// WellKnownRegex contain some well-known patterns. +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum KnownRegex { + Unknown = 0, + /// HTTP header name as defined by RFC 7230. + HttpHeaderName = 1, + /// HTTP header value as defined by RFC 7230. + HttpHeaderValue = 2, +} +impl KnownRegex { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + KnownRegex::Unknown => "UNKNOWN", + KnownRegex::HttpHeaderName => "HTTP_HEADER_NAME", + KnownRegex::HttpHeaderValue => "HTTP_HEADER_VALUE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNKNOWN" => Some(Self::Unknown), + "HTTP_HEADER_NAME" => Some(Self::HttpHeaderName), + "HTTP_HEADER_VALUE" => Some(Self::HttpHeaderValue), + _ => None, + } + } +} +/// Encoded file descriptor set for the `validate` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xbb, 0xcf, 0x02, 0x0a, 0x17, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x08, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc8, 0x08, 0x0a, 0x0a, 0x46, + 0x69, 0x65, 0x6c, 0x64, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x30, 0x0a, 0x07, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x75, 0x6c, + 0x65, 0x73, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x2c, 0x0a, 0x05, 0x66, + 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x73, + 0x48, 0x00, 0x52, 0x05, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x2f, 0x0a, 0x06, 0x64, 0x6f, 0x75, + 0x62, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x65, 0x2e, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x73, + 0x48, 0x00, 0x52, 0x06, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x2c, 0x0a, 0x05, 0x69, 0x6e, + 0x74, 0x33, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x65, 0x2e, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, + 0x00, 0x52, 0x05, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x2c, 0x0a, 0x05, 0x69, 0x6e, 0x74, 0x36, + 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x65, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, + 0x05, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2f, 0x0a, 0x06, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, + 0x65, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, + 0x06, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x2f, 0x0a, 0x06, 0x75, 0x69, 0x6e, 0x74, 0x36, + 0x34, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x65, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, + 0x52, 0x06, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2f, 0x0a, 0x06, 0x73, 0x69, 0x6e, 0x74, + 0x33, 0x32, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x2e, 0x53, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, + 0x00, 0x52, 0x06, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x2f, 0x0a, 0x06, 0x73, 0x69, 0x6e, + 0x74, 0x36, 0x34, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x65, 0x2e, 0x53, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, + 0x48, 0x00, 0x52, 0x06, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x32, 0x0a, 0x07, 0x66, 0x69, + 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x52, 0x75, + 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, 0x07, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x32, + 0x0a, 0x07, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x16, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x46, 0x69, 0x78, 0x65, 0x64, + 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, 0x07, 0x66, 0x69, 0x78, 0x65, 0x64, + 0x36, 0x34, 0x12, 0x35, 0x0a, 0x08, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x0b, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, + 0x53, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, + 0x08, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x35, 0x0a, 0x08, 0x73, 0x66, 0x69, + 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x53, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, 0x08, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, + 0x12, 0x29, 0x0a, 0x04, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, + 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x52, 0x75, + 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, 0x04, 0x62, 0x6f, 0x6f, 0x6c, 0x12, 0x2f, 0x0a, 0x06, 0x73, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, + 0x65, 0x73, 0x48, 0x00, 0x52, 0x06, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x2c, 0x0a, 0x05, + 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73, 0x52, 0x75, 0x6c, 0x65, + 0x73, 0x48, 0x00, 0x52, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x12, 0x29, 0x0a, 0x04, 0x65, 0x6e, + 0x75, 0x6d, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, + 0x04, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x35, 0x0a, 0x08, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, + 0x64, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x65, 0x2e, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x52, 0x75, 0x6c, 0x65, 0x73, + 0x48, 0x00, 0x52, 0x08, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x12, 0x26, 0x0a, 0x03, + 0x6d, 0x61, 0x70, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x65, 0x2e, 0x4d, 0x61, 0x70, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, + 0x03, 0x6d, 0x61, 0x70, 0x12, 0x26, 0x0a, 0x03, 0x61, 0x6e, 0x79, 0x18, 0x14, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x12, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x41, 0x6e, 0x79, + 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, 0x03, 0x61, 0x6e, 0x79, 0x12, 0x35, 0x0a, 0x08, + 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, + 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, 0x08, 0x64, 0x75, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x38, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x18, 0x16, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, + 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x75, 0x6c, 0x65, 0x73, + 0x48, 0x00, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x06, 0x0a, + 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0xb0, 0x01, 0x0a, 0x0a, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x02, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x74, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x02, 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x74, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x02, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, + 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x02, 0x52, 0x02, 0x67, 0x74, 0x12, 0x10, 0x0a, 0x03, + 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x02, 0x52, 0x03, 0x67, 0x74, 0x65, 0x12, 0x0e, + 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x02, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, + 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x02, 0x52, 0x05, + 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, + 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, + 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0xb1, 0x01, 0x0a, 0x0b, 0x44, 0x6f, 0x75, + 0x62, 0x6c, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, + 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, + 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x6c, 0x74, 0x65, + 0x12, 0x0e, 0x0a, 0x02, 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x02, 0x67, 0x74, + 0x12, 0x10, 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x67, + 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x01, 0x52, 0x02, + 0x69, 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, + 0x28, 0x01, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, + 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0xb0, 0x01, 0x0a, + 0x0a, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, + 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, + 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x6c, + 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, + 0x6c, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x02, 0x67, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x03, 0x67, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, + 0x05, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, + 0x07, 0x20, 0x03, 0x28, 0x05, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x21, 0x0a, 0x0c, + 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, + 0xb0, 0x01, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, + 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x63, + 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x02, 0x67, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x03, 0x67, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, + 0x20, 0x03, 0x28, 0x03, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, + 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x03, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, + 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, + 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, + 0x74, 0x79, 0x22, 0xb1, 0x01, 0x0a, 0x0b, 0x55, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x52, 0x75, 0x6c, + 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0d, 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x67, 0x74, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x02, 0x67, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x67, 0x74, + 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x67, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, + 0x69, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, 0x0a, 0x06, + 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x05, 0x6e, 0x6f, + 0x74, 0x49, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, + 0x70, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, + 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0xb1, 0x01, 0x0a, 0x0b, 0x55, 0x49, 0x6e, 0x74, 0x36, + 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, + 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, + 0x6c, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x0e, + 0x0a, 0x02, 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x02, 0x67, 0x74, 0x12, 0x10, + 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x67, 0x74, 0x65, + 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x04, 0x52, 0x02, 0x69, 0x6e, + 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x04, + 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, + 0x65, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, + 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0xb1, 0x01, 0x0a, 0x0b, 0x53, + 0x49, 0x6e, 0x74, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, + 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x11, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, + 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x11, 0x52, 0x02, 0x6c, 0x74, + 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x11, 0x52, 0x03, 0x6c, + 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x11, 0x52, 0x02, + 0x67, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x11, 0x52, + 0x03, 0x67, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x11, + 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x07, + 0x20, 0x03, 0x28, 0x11, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x69, + 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0xb1, + 0x01, 0x0a, 0x0b, 0x53, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, + 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x12, 0x52, 0x05, 0x63, + 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x12, + 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x12, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x12, 0x52, 0x02, 0x67, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x12, 0x52, 0x03, 0x67, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, + 0x20, 0x03, 0x28, 0x12, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, + 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x12, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, + 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, + 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, + 0x74, 0x79, 0x22, 0xb2, 0x01, 0x0a, 0x0c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x52, 0x75, + 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x07, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x74, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x07, 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x74, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x07, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x67, + 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x07, 0x52, 0x02, 0x67, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x67, + 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x07, 0x52, 0x03, 0x67, 0x74, 0x65, 0x12, 0x0e, 0x0a, + 0x02, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x07, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, 0x0a, + 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x07, 0x52, 0x05, 0x6e, + 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, + 0x6d, 0x70, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, + 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0xb2, 0x01, 0x0a, 0x0c, 0x46, 0x69, 0x78, 0x65, + 0x64, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, + 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, + 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x06, 0x52, 0x03, 0x6c, 0x74, 0x65, + 0x12, 0x0e, 0x0a, 0x02, 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x06, 0x52, 0x02, 0x67, 0x74, + 0x12, 0x10, 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x06, 0x52, 0x03, 0x67, + 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x06, 0x52, 0x02, + 0x69, 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, + 0x28, 0x06, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, + 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0xb3, 0x01, 0x0a, + 0x0d, 0x53, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, + 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0f, 0x52, 0x05, 0x63, + 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0f, + 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0f, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0f, 0x52, 0x02, 0x67, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x0f, 0x52, 0x03, 0x67, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, + 0x20, 0x03, 0x28, 0x0f, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, + 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0f, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, + 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, + 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, + 0x74, 0x79, 0x22, 0xb3, 0x01, 0x0a, 0x0d, 0x53, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x10, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x74, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x10, 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x74, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x10, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, + 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x10, 0x52, 0x02, 0x67, 0x74, 0x12, 0x10, 0x0a, 0x03, + 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x10, 0x52, 0x03, 0x67, 0x74, 0x65, 0x12, 0x0e, + 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x10, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, + 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x10, 0x52, 0x05, + 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, + 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, + 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x21, 0x0a, 0x09, 0x42, 0x6f, 0x6f, 0x6c, + 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x22, 0xd4, 0x05, 0x0a, 0x0b, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, + 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, + 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x65, 0x6e, 0x18, 0x13, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, + 0x6c, 0x65, 0x6e, 0x12, 0x17, 0x0a, 0x07, 0x6d, 0x69, 0x6e, 0x5f, 0x6c, 0x65, 0x6e, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x6d, 0x69, 0x6e, 0x4c, 0x65, 0x6e, 0x12, 0x17, 0x0a, 0x07, + 0x6d, 0x61, 0x78, 0x5f, 0x6c, 0x65, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x6d, + 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x65, 0x6e, 0x5f, 0x62, 0x79, 0x74, + 0x65, 0x73, 0x18, 0x14, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x6c, 0x65, 0x6e, 0x42, 0x79, 0x74, + 0x65, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x69, 0x6e, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x6d, 0x69, 0x6e, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, + 0x1b, 0x0a, 0x09, 0x6d, 0x61, 0x78, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x04, 0x52, 0x08, 0x6d, 0x61, 0x78, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x18, 0x0a, 0x07, + 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, + 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x16, + 0x0a, 0x06, 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x6e, 0x6f, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x73, 0x18, 0x17, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6e, 0x6f, 0x74, 0x43, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x73, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x0a, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, + 0x0b, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x16, 0x0a, 0x05, + 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x05, 0x65, + 0x6d, 0x61, 0x69, 0x6c, 0x12, 0x1c, 0x0a, 0x08, 0x68, 0x6f, 0x73, 0x74, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x08, 0x68, 0x6f, 0x73, 0x74, 0x6e, 0x61, + 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x02, 0x69, 0x70, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, + 0x52, 0x02, 0x69, 0x70, 0x12, 0x14, 0x0a, 0x04, 0x69, 0x70, 0x76, 0x34, 0x18, 0x0f, 0x20, 0x01, + 0x28, 0x08, 0x48, 0x00, 0x52, 0x04, 0x69, 0x70, 0x76, 0x34, 0x12, 0x14, 0x0a, 0x04, 0x69, 0x70, + 0x76, 0x36, 0x18, 0x10, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x04, 0x69, 0x70, 0x76, 0x36, + 0x12, 0x12, 0x0a, 0x03, 0x75, 0x72, 0x69, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, + 0x03, 0x75, 0x72, 0x69, 0x12, 0x19, 0x0a, 0x07, 0x75, 0x72, 0x69, 0x5f, 0x72, 0x65, 0x66, 0x18, + 0x12, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x06, 0x75, 0x72, 0x69, 0x52, 0x65, 0x66, 0x12, + 0x1a, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x15, 0x20, 0x01, 0x28, 0x08, + 0x48, 0x00, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x14, 0x0a, 0x04, 0x75, + 0x75, 0x69, 0x64, 0x18, 0x16, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x04, 0x75, 0x75, 0x69, + 0x64, 0x12, 0x40, 0x0a, 0x10, 0x77, 0x65, 0x6c, 0x6c, 0x5f, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x5f, + 0x72, 0x65, 0x67, 0x65, 0x78, 0x18, 0x18, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x67, 0x65, + 0x78, 0x48, 0x00, 0x52, 0x0e, 0x77, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x52, 0x65, + 0x67, 0x65, 0x78, 0x12, 0x1c, 0x0a, 0x06, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x18, 0x19, 0x20, + 0x01, 0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65, 0x52, 0x06, 0x73, 0x74, 0x72, 0x69, 0x63, + 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, 0x70, 0x74, + 0x79, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, + 0x6d, 0x70, 0x74, 0x79, 0x42, 0x0c, 0x0a, 0x0a, 0x77, 0x65, 0x6c, 0x6c, 0x5f, 0x6b, 0x6e, 0x6f, + 0x77, 0x6e, 0x22, 0xe2, 0x02, 0x0a, 0x0a, 0x42, 0x79, 0x74, 0x65, 0x73, 0x52, 0x75, 0x6c, 0x65, + 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x65, 0x6e, 0x18, 0x0d, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x6c, 0x65, 0x6e, 0x12, 0x17, 0x0a, 0x07, 0x6d, 0x69, 0x6e, + 0x5f, 0x6c, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x6d, 0x69, 0x6e, 0x4c, + 0x65, 0x6e, 0x12, 0x17, 0x0a, 0x07, 0x6d, 0x61, 0x78, 0x5f, 0x6c, 0x65, 0x6e, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x04, 0x52, 0x06, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x70, + 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x61, + 0x74, 0x74, 0x65, 0x72, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x16, 0x0a, + 0x06, 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x73, + 0x75, 0x66, 0x66, 0x69, 0x78, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x73, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x02, 0x69, + 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x09, 0x20, 0x03, 0x28, + 0x0c, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x10, 0x0a, 0x02, 0x69, 0x70, 0x18, 0x0a, + 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x02, 0x69, 0x70, 0x12, 0x14, 0x0a, 0x04, 0x69, 0x70, + 0x76, 0x34, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x04, 0x69, 0x70, 0x76, 0x34, + 0x12, 0x14, 0x0a, 0x04, 0x69, 0x70, 0x76, 0x36, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, + 0x52, 0x04, 0x69, 0x70, 0x76, 0x36, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, + 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, + 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x42, 0x0c, 0x0a, 0x0a, 0x77, 0x65, 0x6c, + 0x6c, 0x5f, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x22, 0x6b, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x65, 0x64, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x0b, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x4f, 0x6e, 0x6c, 0x79, 0x12, 0x0e, 0x0a, + 0x02, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x03, 0x28, 0x05, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, 0x0a, + 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x04, 0x20, 0x03, 0x28, 0x05, 0x52, 0x05, 0x6e, + 0x6f, 0x74, 0x49, 0x6e, 0x22, 0x3e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x6b, 0x69, 0x70, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x04, 0x73, 0x6b, 0x69, 0x70, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, + 0x69, 0x72, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x71, 0x75, + 0x69, 0x72, 0x65, 0x64, 0x22, 0xb0, 0x01, 0x0a, 0x0d, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, + 0x64, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x69, 0x6e, 0x5f, 0x69, 0x74, + 0x65, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x6d, 0x69, 0x6e, 0x49, 0x74, + 0x65, 0x6d, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x61, 0x78, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x73, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x6d, 0x61, 0x78, 0x49, 0x74, 0x65, 0x6d, 0x73, + 0x12, 0x16, 0x0a, 0x06, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x06, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x12, 0x2a, 0x0a, 0x05, 0x69, 0x74, 0x65, 0x6d, + 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x65, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x05, 0x69, + 0x74, 0x65, 0x6d, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, + 0x6d, 0x70, 0x74, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, + 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0xdc, 0x01, 0x0a, 0x08, 0x4d, 0x61, 0x70, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x69, 0x6e, 0x5f, 0x70, 0x61, 0x69, 0x72, + 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x6d, 0x69, 0x6e, 0x50, 0x61, 0x69, 0x72, + 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x61, 0x78, 0x5f, 0x70, 0x61, 0x69, 0x72, 0x73, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x6d, 0x61, 0x78, 0x50, 0x61, 0x69, 0x72, 0x73, 0x12, 0x1b, + 0x0a, 0x09, 0x6e, 0x6f, 0x5f, 0x73, 0x70, 0x61, 0x72, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x08, 0x6e, 0x6f, 0x53, 0x70, 0x61, 0x72, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x6b, + 0x65, 0x79, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x65, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, + 0x04, 0x6b, 0x65, 0x79, 0x73, 0x12, 0x2c, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, + 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x06, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, + 0x70, 0x74, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, + 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x4d, 0x0a, 0x08, 0x41, 0x6e, 0x79, 0x52, 0x75, 0x6c, + 0x65, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x12, 0x0e, + 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, + 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, + 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x22, 0xe9, 0x02, 0x0a, 0x0d, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, + 0x72, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, + 0x72, 0x65, 0x64, 0x12, 0x2f, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x05, 0x63, + 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x29, 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x02, 0x6c, 0x74, 0x12, + 0x2b, 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, + 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x02, + 0x67, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x02, 0x67, 0x74, 0x12, 0x2b, 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x03, 0x67, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x02, 0x69, 0x6e, 0x12, + 0x30, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, + 0x6e, 0x22, 0xf3, 0x02, 0x0a, 0x0e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, + 0x12, 0x30, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x05, 0x63, 0x6f, 0x6e, + 0x73, 0x74, 0x12, 0x2a, 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x02, 0x6c, 0x74, 0x12, 0x2c, + 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x2a, 0x0a, 0x02, + 0x67, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x52, 0x02, 0x67, 0x74, 0x12, 0x2c, 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x52, 0x03, 0x67, 0x74, 0x65, 0x12, 0x15, 0x0a, 0x06, 0x6c, 0x74, 0x5f, 0x6e, 0x6f, 0x77, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x6c, 0x74, 0x4e, 0x6f, 0x77, 0x12, 0x15, 0x0a, + 0x06, 0x67, 0x74, 0x5f, 0x6e, 0x6f, 0x77, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x67, + 0x74, 0x4e, 0x6f, 0x77, 0x12, 0x31, 0x0a, 0x06, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x18, 0x09, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x06, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x2a, 0x46, 0x0a, 0x0a, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, + 0x52, 0x65, 0x67, 0x65, 0x78, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, + 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, 0x48, 0x54, 0x54, 0x50, 0x5f, 0x48, 0x45, 0x41, 0x44, 0x45, + 0x52, 0x5f, 0x4e, 0x41, 0x4d, 0x45, 0x10, 0x01, 0x12, 0x15, 0x0a, 0x11, 0x48, 0x54, 0x54, 0x50, + 0x5f, 0x48, 0x45, 0x41, 0x44, 0x45, 0x52, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x10, 0x02, 0x3a, + 0x3c, 0x0a, 0x08, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x1f, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xaf, 0x08, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x08, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x3a, 0x3a, 0x0a, + 0x07, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x64, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xb0, 0x08, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x07, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x64, 0x3a, 0x3a, 0x0a, 0x08, 0x72, 0x65, 0x71, + 0x75, 0x69, 0x72, 0x65, 0x64, 0x12, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x4f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xaf, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x71, + 0x75, 0x69, 0x72, 0x65, 0x64, 0x3a, 0x4a, 0x0a, 0x05, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x1d, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xaf, 0x08, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, + 0x46, 0x69, 0x65, 0x6c, 0x64, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x05, 0x72, 0x75, 0x6c, 0x65, + 0x73, 0x42, 0x91, 0x01, 0x0a, 0x0c, 0x63, 0x6f, 0x6d, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x65, 0x42, 0x0d, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x74, + 0x6f, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, + 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0xa2, 0x02, 0x03, 0x56, 0x58, 0x58, 0xaa, 0x02, 0x08, + 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0xca, 0x02, 0x08, 0x56, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0xe2, 0x02, 0x14, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x5c, 0x47, + 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x08, 0x56, 0x61, 0x6c, + 0x69, 0x64, 0x61, 0x74, 0x65, 0x4a, 0xc6, 0x9d, 0x02, 0x0a, 0x07, 0x12, 0x05, 0x00, 0x00, 0xdd, + 0x06, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, + 0x02, 0x12, 0x03, 0x01, 0x00, 0x11, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x03, 0x00, 0x49, + 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x03, 0x00, 0x49, 0x0a, 0x09, 0x0a, 0x02, 0x03, + 0x00, 0x12, 0x03, 0x06, 0x00, 0x2a, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x07, 0x00, + 0x28, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x08, 0x00, 0x29, 0x0a, 0x3a, 0x0a, 0x01, + 0x07, 0x12, 0x04, 0x0b, 0x00, 0x11, 0x01, 0x1a, 0x2f, 0x20, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, + 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x20, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x0a, 0x0a, 0x94, 0x01, 0x0a, 0x02, 0x07, 0x00, 0x12, + 0x03, 0x0e, 0x04, 0x22, 0x1a, 0x88, 0x01, 0x20, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, + 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x6e, 0x79, 0x0a, + 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, + 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x69, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, + 0x72, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x07, 0x00, 0x02, 0x12, 0x03, 0x0b, 0x07, 0x25, 0x0a, 0x0a, 0x0a, 0x03, 0x07, + 0x00, 0x04, 0x12, 0x03, 0x0e, 0x04, 0x0c, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x00, 0x05, 0x12, 0x03, + 0x0e, 0x0d, 0x11, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x00, 0x01, 0x12, 0x03, 0x0e, 0x12, 0x1a, 0x0a, + 0x0a, 0x0a, 0x03, 0x07, 0x00, 0x03, 0x12, 0x03, 0x0e, 0x1d, 0x21, 0x0a, 0x4c, 0x0a, 0x02, 0x07, + 0x01, 0x12, 0x03, 0x10, 0x04, 0x21, 0x1a, 0x41, 0x20, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x20, + 0x73, 0x6b, 0x69, 0x70, 0x73, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x6f, 0x66, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6d, + 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x01, 0x02, + 0x12, 0x03, 0x0b, 0x07, 0x25, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x01, 0x04, 0x12, 0x03, 0x10, 0x04, + 0x0c, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x01, 0x05, 0x12, 0x03, 0x10, 0x0d, 0x11, 0x0a, 0x0a, 0x0a, + 0x03, 0x07, 0x01, 0x01, 0x12, 0x03, 0x10, 0x12, 0x19, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x01, 0x03, + 0x12, 0x03, 0x10, 0x1c, 0x20, 0x0a, 0x38, 0x0a, 0x01, 0x07, 0x12, 0x04, 0x14, 0x00, 0x18, 0x01, + 0x1a, 0x2d, 0x20, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, + 0x6c, 0x65, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x20, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x0a, 0x0a, + 0x88, 0x01, 0x0a, 0x02, 0x07, 0x02, 0x12, 0x03, 0x17, 0x04, 0x22, 0x1a, 0x7d, 0x20, 0x52, 0x65, + 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x65, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x6f, 0x6e, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x20, 0x69, 0x73, 0x20, + 0x73, 0x65, 0x74, 0x3b, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x66, 0x61, 0x69, 0x6c, 0x73, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x6e, 0x65, 0x6f, 0x66, + 0x20, 0x61, 0x72, 0x65, 0x20, 0x73, 0x65, 0x74, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x02, + 0x02, 0x12, 0x03, 0x14, 0x07, 0x23, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x02, 0x04, 0x12, 0x03, 0x17, + 0x04, 0x0c, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x02, 0x05, 0x12, 0x03, 0x17, 0x0d, 0x11, 0x0a, 0x0a, + 0x0a, 0x03, 0x07, 0x02, 0x01, 0x12, 0x03, 0x17, 0x12, 0x1a, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x02, + 0x03, 0x12, 0x03, 0x17, 0x1d, 0x21, 0x0a, 0x38, 0x0a, 0x01, 0x07, 0x12, 0x04, 0x1b, 0x00, 0x1f, + 0x01, 0x1a, 0x2d, 0x20, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, + 0x75, 0x6c, 0x65, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x0a, + 0x0a, 0x82, 0x01, 0x0a, 0x02, 0x07, 0x03, 0x12, 0x03, 0x1e, 0x04, 0x25, 0x1a, 0x77, 0x20, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x79, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x74, 0x6f, 0x20, + 0x62, 0x65, 0x20, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2e, 0x20, 0x42, 0x79, 0x20, 0x64, + 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x2c, 0x0a, 0x20, 0x6e, 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, + 0x6d, 0x65, 0x64, 0x20, 0x61, 0x67, 0x61, 0x69, 0x6e, 0x73, 0x74, 0x20, 0x61, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x03, 0x02, 0x12, 0x03, 0x1b, 0x07, + 0x23, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x03, 0x04, 0x12, 0x03, 0x1e, 0x04, 0x0c, 0x0a, 0x0a, 0x0a, + 0x03, 0x07, 0x03, 0x06, 0x12, 0x03, 0x1e, 0x0d, 0x17, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x03, 0x01, + 0x12, 0x03, 0x1e, 0x18, 0x1d, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x03, 0x03, 0x12, 0x03, 0x1e, 0x20, + 0x24, 0x0a, 0x9e, 0x01, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x23, 0x00, 0x41, 0x01, 0x1a, 0x91, + 0x01, 0x20, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x65, 0x6e, 0x63, + 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, + 0x6c, 0x65, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x74, 0x79, 0x70, + 0x65, 0x20, 0x6f, 0x66, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2e, 0x20, 0x44, 0x65, 0x70, 0x65, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74, + 0x20, 0x73, 0x65, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x75, + 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x20, 0x70, 0x72, + 0x6f, 0x70, 0x65, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x23, 0x08, 0x12, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x24, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x00, 0x04, 0x12, 0x03, 0x24, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x24, 0x0d, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x24, 0x1a, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x24, 0x24, 0x26, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x00, 0x08, 0x00, 0x12, 0x04, 0x25, 0x04, 0x40, + 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x08, 0x00, 0x01, 0x12, 0x03, 0x25, 0x0a, 0x0e, 0x0a, + 0x21, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x27, 0x08, 0x23, 0x1a, 0x14, 0x20, 0x53, + 0x63, 0x61, 0x6c, 0x61, 0x72, 0x20, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x54, 0x79, 0x70, 0x65, + 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x27, 0x08, 0x12, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x27, 0x16, 0x1b, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x27, 0x21, 0x22, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x28, 0x08, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x02, 0x06, 0x12, 0x03, 0x28, 0x08, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x28, 0x16, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, + 0x28, 0x21, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x29, 0x08, 0x23, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x06, 0x12, 0x03, 0x29, 0x08, 0x12, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x29, 0x16, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x29, 0x21, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x04, 0x12, 0x03, 0x2a, 0x08, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x06, + 0x12, 0x03, 0x2a, 0x08, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, + 0x2a, 0x16, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, 0x2a, 0x21, + 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x2b, 0x08, 0x23, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x06, 0x12, 0x03, 0x2b, 0x08, 0x13, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x2b, 0x16, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x05, 0x03, 0x12, 0x03, 0x2b, 0x21, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x06, + 0x12, 0x03, 0x2c, 0x08, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x06, 0x12, 0x03, + 0x2c, 0x08, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x2c, 0x16, + 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x03, 0x12, 0x03, 0x2c, 0x21, 0x22, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x07, 0x12, 0x03, 0x2d, 0x08, 0x23, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x07, 0x06, 0x12, 0x03, 0x2d, 0x08, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x07, 0x01, 0x12, 0x03, 0x2d, 0x16, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x07, + 0x03, 0x12, 0x03, 0x2d, 0x21, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x08, 0x12, 0x03, + 0x2e, 0x08, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x06, 0x12, 0x03, 0x2e, 0x08, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x01, 0x12, 0x03, 0x2e, 0x16, 0x1c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x03, 0x12, 0x03, 0x2e, 0x21, 0x22, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x00, 0x02, 0x09, 0x12, 0x03, 0x2f, 0x08, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x09, 0x06, 0x12, 0x03, 0x2f, 0x08, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x09, + 0x01, 0x12, 0x03, 0x2f, 0x16, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x09, 0x03, 0x12, + 0x03, 0x2f, 0x21, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x0a, 0x12, 0x03, 0x30, 0x08, + 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0a, 0x06, 0x12, 0x03, 0x30, 0x08, 0x14, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0a, 0x01, 0x12, 0x03, 0x30, 0x16, 0x1d, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x0a, 0x03, 0x12, 0x03, 0x30, 0x21, 0x23, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x0b, 0x12, 0x03, 0x31, 0x08, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0b, + 0x06, 0x12, 0x03, 0x31, 0x08, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0b, 0x01, 0x12, + 0x03, 0x31, 0x16, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0b, 0x03, 0x12, 0x03, 0x31, + 0x21, 0x23, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x0c, 0x12, 0x03, 0x32, 0x08, 0x24, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0c, 0x06, 0x12, 0x03, 0x32, 0x08, 0x15, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x0c, 0x01, 0x12, 0x03, 0x32, 0x16, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x0c, 0x03, 0x12, 0x03, 0x32, 0x21, 0x23, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x0d, 0x12, 0x03, 0x33, 0x08, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0d, 0x06, 0x12, + 0x03, 0x33, 0x08, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0d, 0x01, 0x12, 0x03, 0x33, + 0x16, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0d, 0x03, 0x12, 0x03, 0x33, 0x21, 0x23, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x0e, 0x12, 0x03, 0x34, 0x08, 0x24, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x0e, 0x06, 0x12, 0x03, 0x34, 0x08, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x0e, 0x01, 0x12, 0x03, 0x34, 0x16, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x0e, 0x03, 0x12, 0x03, 0x34, 0x21, 0x23, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x0f, 0x12, + 0x03, 0x35, 0x08, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0f, 0x06, 0x12, 0x03, 0x35, + 0x08, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0f, 0x01, 0x12, 0x03, 0x35, 0x16, 0x1b, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0f, 0x03, 0x12, 0x03, 0x35, 0x21, 0x23, 0x0a, 0x22, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x10, 0x12, 0x03, 0x38, 0x08, 0x24, 0x1a, 0x15, 0x20, 0x43, 0x6f, + 0x6d, 0x70, 0x6c, 0x65, 0x78, 0x20, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x54, 0x79, 0x70, 0x65, + 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x10, 0x06, 0x12, 0x03, 0x38, 0x08, 0x11, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x10, 0x01, 0x12, 0x03, 0x38, 0x16, 0x1a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x10, 0x03, 0x12, 0x03, 0x38, 0x21, 0x23, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x11, 0x12, 0x03, 0x39, 0x08, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x11, 0x06, 0x12, 0x03, 0x39, 0x08, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x11, 0x01, + 0x12, 0x03, 0x39, 0x16, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x11, 0x03, 0x12, 0x03, + 0x39, 0x21, 0x23, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x12, 0x12, 0x03, 0x3a, 0x08, 0x24, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x12, 0x06, 0x12, 0x03, 0x3a, 0x08, 0x10, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x12, 0x01, 0x12, 0x03, 0x3a, 0x16, 0x19, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x12, 0x03, 0x12, 0x03, 0x3a, 0x21, 0x23, 0x0a, 0x25, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x13, 0x12, 0x03, 0x3d, 0x08, 0x26, 0x1a, 0x18, 0x20, 0x57, 0x65, 0x6c, 0x6c, 0x2d, 0x4b, + 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x54, 0x79, 0x70, 0x65, 0x73, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x13, 0x06, 0x12, 0x03, 0x3d, 0x08, 0x10, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x13, 0x01, 0x12, 0x03, 0x3d, 0x17, 0x1a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x13, 0x03, 0x12, 0x03, 0x3d, 0x23, 0x25, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x14, 0x12, 0x03, 0x3e, 0x08, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x14, + 0x06, 0x12, 0x03, 0x3e, 0x08, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x14, 0x01, 0x12, + 0x03, 0x3e, 0x17, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x14, 0x03, 0x12, 0x03, 0x3e, + 0x23, 0x25, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x15, 0x12, 0x03, 0x3f, 0x08, 0x26, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x15, 0x06, 0x12, 0x03, 0x3f, 0x08, 0x16, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x15, 0x01, 0x12, 0x03, 0x3f, 0x17, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x15, 0x03, 0x12, 0x03, 0x3f, 0x23, 0x25, 0x0a, 0x4c, 0x0a, 0x02, 0x04, 0x01, 0x12, + 0x04, 0x44, 0x00, 0x65, 0x01, 0x1a, 0x40, 0x20, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x52, 0x75, 0x6c, + 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, + 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x60, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, + 0x44, 0x08, 0x12, 0x0a, 0x52, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x46, 0x04, 0x1d, + 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, + 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x04, + 0x12, 0x03, 0x46, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x46, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x46, 0x13, + 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x46, 0x1b, 0x1c, 0x0a, + 0x5d, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x4a, 0x04, 0x1a, 0x1a, 0x50, 0x20, 0x4c, + 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x04, 0x12, 0x03, 0x4a, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, 0x4a, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x4a, 0x13, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x4a, 0x18, 0x19, 0x0a, 0x6a, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, + 0x4e, 0x04, 0x1b, 0x1a, 0x5d, 0x20, 0x4c, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, + 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, + 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x04, 0x12, 0x03, 0x4e, 0x04, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x05, 0x12, 0x03, 0x4e, 0x0d, 0x12, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x4e, 0x13, 0x16, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x4e, 0x19, 0x1a, 0x0a, 0xb3, 0x01, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x03, 0x12, 0x03, 0x53, 0x04, 0x1a, 0x1a, 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, + 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, + 0x74, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, + 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, 0x6e, + 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x04, 0x12, 0x03, 0x53, 0x04, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x05, 0x12, 0x03, 0x53, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x03, 0x01, 0x12, 0x03, 0x53, 0x13, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x03, 0x03, 0x12, 0x03, 0x53, 0x18, 0x19, 0x0a, 0xc1, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, + 0x04, 0x12, 0x03, 0x58, 0x04, 0x1b, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, + 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, + 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x0a, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, + 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, + 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x04, 0x04, 0x12, 0x03, 0x58, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x04, 0x05, 0x12, 0x03, 0x58, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, + 0x01, 0x12, 0x03, 0x58, 0x13, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x03, 0x12, + 0x03, 0x58, 0x19, 0x1a, 0x0a, 0x59, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x05, 0x12, 0x03, 0x5c, 0x04, + 0x1a, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, + 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x04, 0x12, 0x03, 0x5c, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x05, 0x05, 0x12, 0x03, 0x5c, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x05, 0x01, 0x12, 0x03, 0x5c, 0x13, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x05, 0x03, 0x12, 0x03, 0x5c, 0x18, 0x19, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x06, 0x12, + 0x03, 0x60, 0x04, 0x1e, 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, + 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x04, + 0x12, 0x03, 0x60, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x05, 0x12, 0x03, + 0x60, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x01, 0x12, 0x03, 0x60, 0x13, + 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x03, 0x12, 0x03, 0x60, 0x1c, 0x1d, 0x0a, + 0x80, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x07, 0x12, 0x03, 0x64, 0x04, 0x23, 0x1a, 0x73, 0x20, + 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, + 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, + 0x79, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x04, 0x12, 0x03, 0x64, 0x04, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x05, 0x12, 0x03, 0x64, 0x0d, 0x11, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x01, 0x12, 0x03, 0x64, 0x12, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x07, 0x03, 0x12, 0x03, 0x64, 0x21, 0x22, 0x0a, 0x4f, 0x0a, 0x02, 0x04, 0x02, + 0x12, 0x05, 0x68, 0x00, 0x89, 0x01, 0x01, 0x1a, 0x42, 0x20, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, + 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, + 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x64, 0x6f, 0x75, 0x62, + 0x6c, 0x65, 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x02, 0x01, 0x12, 0x03, 0x68, 0x08, 0x13, 0x0a, 0x52, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, + 0x03, 0x6a, 0x04, 0x1e, 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, + 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x00, 0x04, 0x12, 0x03, 0x6a, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x6a, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x6a, 0x14, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x6a, 0x1c, 0x1d, 0x0a, 0x5d, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x6e, 0x04, 0x1b, + 0x1a, 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, + 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x04, 0x12, 0x03, 0x6e, 0x04, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x05, 0x12, 0x03, 0x6e, 0x0d, 0x13, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x6e, 0x14, 0x16, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x6e, 0x19, 0x1a, 0x0a, 0x6a, 0x0a, 0x04, 0x04, 0x02, + 0x02, 0x02, 0x12, 0x03, 0x72, 0x04, 0x1c, 0x1a, 0x5d, 0x20, 0x4c, 0x74, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, + 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, + 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x04, 0x12, + 0x03, 0x72, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x05, 0x12, 0x03, 0x72, + 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, 0x72, 0x14, 0x17, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x03, 0x12, 0x03, 0x72, 0x1a, 0x1b, 0x0a, 0xb3, + 0x01, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, 0x77, 0x04, 0x1b, 0x1a, 0xa5, 0x01, 0x20, + 0x47, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, + 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, + 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x47, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, + 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, + 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x04, 0x12, 0x03, 0x77, + 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x05, 0x12, 0x03, 0x77, 0x0d, 0x13, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x01, 0x12, 0x03, 0x77, 0x14, 0x16, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x03, 0x12, 0x03, 0x77, 0x19, 0x1a, 0x0a, 0xc1, 0x01, 0x0a, + 0x04, 0x04, 0x02, 0x02, 0x04, 0x12, 0x03, 0x7c, 0x04, 0x1c, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, + 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, + 0x65, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x61, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, + 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, + 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x04, 0x04, 0x12, 0x03, 0x7c, 0x04, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x04, 0x05, 0x12, 0x03, 0x7c, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x04, 0x01, 0x12, 0x03, 0x7c, 0x14, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x04, 0x03, 0x12, 0x03, 0x7c, 0x1a, 0x1b, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x05, + 0x12, 0x04, 0x80, 0x01, 0x04, 0x1b, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, + 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x05, 0x04, 0x12, 0x04, 0x80, + 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x05, 0x05, 0x12, 0x04, 0x80, 0x01, + 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x05, 0x01, 0x12, 0x04, 0x80, 0x01, 0x14, + 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x05, 0x03, 0x12, 0x04, 0x80, 0x01, 0x19, 0x1a, + 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x06, 0x12, 0x04, 0x84, 0x01, 0x04, 0x1f, 0x1a, 0x51, + 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, + 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x06, 0x04, 0x12, 0x04, 0x84, 0x01, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x06, 0x05, 0x12, 0x04, 0x84, 0x01, 0x0d, 0x13, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x06, 0x01, 0x12, 0x04, 0x84, 0x01, 0x14, 0x1a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x06, 0x03, 0x12, 0x04, 0x84, 0x01, 0x1d, 0x1e, 0x0a, 0x81, 0x01, + 0x0a, 0x04, 0x04, 0x02, 0x02, 0x07, 0x12, 0x04, 0x88, 0x01, 0x04, 0x23, 0x1a, 0x73, 0x20, 0x49, + 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x07, 0x04, 0x12, 0x04, 0x88, 0x01, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x07, 0x05, 0x12, 0x04, 0x88, 0x01, 0x0d, 0x11, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x07, 0x01, 0x12, 0x04, 0x88, 0x01, 0x12, 0x1e, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x07, 0x03, 0x12, 0x04, 0x88, 0x01, 0x21, 0x22, 0x0a, 0x4e, 0x0a, + 0x02, 0x04, 0x03, 0x12, 0x06, 0x8c, 0x01, 0x00, 0xad, 0x01, 0x01, 0x1a, 0x40, 0x20, 0x49, 0x6e, + 0x74, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, + 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x69, + 0x6e, 0x74, 0x33, 0x32, 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, + 0x03, 0x04, 0x03, 0x01, 0x12, 0x04, 0x8c, 0x01, 0x08, 0x12, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x03, + 0x02, 0x00, 0x12, 0x04, 0x8e, 0x01, 0x04, 0x1d, 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x04, 0x12, 0x04, 0x8e, 0x01, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x05, 0x12, 0x04, 0x8e, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x04, 0x8e, 0x01, 0x13, 0x18, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x04, 0x8e, 0x01, 0x1b, 0x1c, 0x0a, 0x5e, 0x0a, 0x04, 0x04, + 0x03, 0x02, 0x01, 0x12, 0x04, 0x92, 0x01, 0x04, 0x1a, 0x1a, 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, + 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, + 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x01, 0x04, 0x12, 0x04, 0x92, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x01, 0x05, 0x12, 0x04, 0x92, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x01, 0x01, 0x12, 0x04, 0x92, 0x01, 0x13, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, + 0x03, 0x12, 0x04, 0x92, 0x01, 0x18, 0x19, 0x0a, 0x6b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x02, 0x12, + 0x04, 0x96, 0x01, 0x04, 0x1b, 0x1a, 0x5d, 0x20, 0x4c, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, + 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, + 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, + 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x04, 0x12, 0x04, 0x96, + 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x05, 0x12, 0x04, 0x96, 0x01, + 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x01, 0x12, 0x04, 0x96, 0x01, 0x13, + 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x03, 0x12, 0x04, 0x96, 0x01, 0x19, 0x1a, + 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x03, 0x12, 0x04, 0x9b, 0x01, 0x04, 0x1a, 0x1a, + 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, + 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, + 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, + 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, + 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x04, + 0x12, 0x04, 0x9b, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x05, 0x12, + 0x04, 0x9b, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x01, 0x12, 0x04, + 0x9b, 0x01, 0x13, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x03, 0x12, 0x04, 0x9b, + 0x01, 0x18, 0x19, 0x0a, 0xc2, 0x01, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x04, 0x12, 0x04, 0xa0, 0x01, + 0x04, 0x1b, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, + 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, + 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, + 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, + 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, + 0x04, 0x12, 0x04, 0xa0, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x05, + 0x12, 0x04, 0xa0, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x01, 0x12, + 0x04, 0xa0, 0x01, 0x13, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x03, 0x12, 0x04, + 0xa0, 0x01, 0x19, 0x1a, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x05, 0x12, 0x04, 0xa4, 0x01, + 0x04, 0x1a, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, + 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x04, 0x12, 0x04, 0xa4, 0x01, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x05, 0x12, 0x04, 0xa4, 0x01, 0x0d, 0x12, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x01, 0x12, 0x04, 0xa4, 0x01, 0x13, 0x15, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x05, 0x03, 0x12, 0x04, 0xa4, 0x01, 0x18, 0x19, 0x0a, 0x5f, 0x0a, 0x04, + 0x04, 0x03, 0x02, 0x06, 0x12, 0x04, 0xa8, 0x01, 0x04, 0x1e, 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, + 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, + 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, + 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x06, 0x04, 0x12, 0x04, 0xa8, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x06, 0x05, 0x12, 0x04, 0xa8, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x06, 0x01, 0x12, 0x04, 0xa8, 0x01, 0x13, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x06, 0x03, 0x12, 0x04, 0xa8, 0x01, 0x1c, 0x1d, 0x0a, 0x81, 0x01, 0x0a, 0x04, 0x04, 0x03, + 0x02, 0x07, 0x12, 0x04, 0xac, 0x01, 0x04, 0x23, 0x1a, 0x73, 0x20, 0x49, 0x67, 0x6e, 0x6f, 0x72, + 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, + 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, + 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x07, 0x04, 0x12, 0x04, 0xac, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x07, 0x05, 0x12, 0x04, 0xac, 0x01, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x07, 0x01, 0x12, 0x04, 0xac, 0x01, 0x12, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x07, 0x03, 0x12, 0x04, 0xac, 0x01, 0x21, 0x22, 0x0a, 0x4e, 0x0a, 0x02, 0x04, 0x04, 0x12, + 0x06, 0xb0, 0x01, 0x00, 0xd1, 0x01, 0x01, 0x1a, 0x40, 0x20, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, + 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x69, 0x6e, 0x74, 0x36, 0x34, + 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x04, 0x01, + 0x12, 0x04, 0xb0, 0x01, 0x08, 0x12, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x04, + 0xb2, 0x01, 0x04, 0x1d, 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, + 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x00, 0x04, 0x12, 0x04, 0xb2, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x00, 0x05, 0x12, 0x04, 0xb2, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x00, 0x01, 0x12, 0x04, 0xb2, 0x01, 0x13, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, + 0x03, 0x12, 0x04, 0xb2, 0x01, 0x1b, 0x1c, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, + 0x04, 0xb6, 0x01, 0x04, 0x1a, 0x1a, 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, + 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x04, + 0x12, 0x04, 0xb6, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x05, 0x12, + 0x04, 0xb6, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x04, + 0xb6, 0x01, 0x13, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x04, 0xb6, + 0x01, 0x18, 0x19, 0x0a, 0x6b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x02, 0x12, 0x04, 0xba, 0x01, 0x04, + 0x1b, 0x1a, 0x5d, 0x20, 0x4c, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, + 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x04, 0x12, 0x04, 0xba, 0x01, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x05, 0x12, 0x04, 0xba, 0x01, 0x0d, 0x12, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x04, 0xba, 0x01, 0x13, 0x16, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x04, 0xba, 0x01, 0x19, 0x1a, 0x0a, 0xb4, 0x01, 0x0a, + 0x04, 0x04, 0x04, 0x02, 0x03, 0x12, 0x04, 0xbf, 0x01, 0x04, 0x1a, 0x1a, 0xa5, 0x01, 0x20, 0x47, + 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, + 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x47, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, + 0x68, 0x61, 0x6e, 0x20, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, + 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, + 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x04, 0x12, 0x04, 0xbf, 0x01, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x05, 0x12, 0x04, 0xbf, 0x01, 0x0d, + 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x01, 0x12, 0x04, 0xbf, 0x01, 0x13, 0x15, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x03, 0x12, 0x04, 0xbf, 0x01, 0x18, 0x19, 0x0a, + 0xc2, 0x01, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x04, 0x12, 0x04, 0xc4, 0x01, 0x04, 0x1b, 0x1a, 0xb3, + 0x01, 0x20, 0x47, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, + 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, + 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x47, 0x74, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, + 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x04, 0x12, 0x04, 0xc4, + 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x05, 0x12, 0x04, 0xc4, 0x01, + 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x01, 0x12, 0x04, 0xc4, 0x01, 0x13, + 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x03, 0x12, 0x04, 0xc4, 0x01, 0x19, 0x1a, + 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x05, 0x12, 0x04, 0xc8, 0x01, 0x04, 0x1a, 0x1a, 0x4c, + 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, + 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x05, 0x04, 0x12, 0x04, 0xc8, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x05, 0x05, 0x12, 0x04, 0xc8, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x05, 0x01, 0x12, 0x04, 0xc8, 0x01, 0x13, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x05, 0x03, 0x12, 0x04, 0xc8, 0x01, 0x18, 0x19, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x06, + 0x12, 0x04, 0xcc, 0x01, 0x04, 0x1e, 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x06, 0x04, 0x12, 0x04, 0xcc, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x06, + 0x05, 0x12, 0x04, 0xcc, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x06, 0x01, + 0x12, 0x04, 0xcc, 0x01, 0x13, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x06, 0x03, 0x12, + 0x04, 0xcc, 0x01, 0x1c, 0x1d, 0x0a, 0x81, 0x01, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x07, 0x12, 0x04, + 0xd0, 0x01, 0x04, 0x23, 0x1a, 0x73, 0x20, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, + 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, + 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, + 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x07, 0x04, 0x12, 0x04, 0xd0, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x07, + 0x05, 0x12, 0x04, 0xd0, 0x01, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x07, 0x01, + 0x12, 0x04, 0xd0, 0x01, 0x12, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x07, 0x03, 0x12, + 0x04, 0xd0, 0x01, 0x21, 0x22, 0x0a, 0x50, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x06, 0xd4, 0x01, 0x00, + 0xf5, 0x01, 0x01, 0x1a, 0x42, 0x20, 0x55, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, + 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, + 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x60, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x04, + 0xd4, 0x01, 0x08, 0x13, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x04, 0xd6, 0x01, + 0x04, 0x1e, 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, + 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x00, 0x04, 0x12, 0x04, 0xd6, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, + 0x05, 0x12, 0x04, 0xd6, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, + 0x12, 0x04, 0xd6, 0x01, 0x14, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, + 0x04, 0xd6, 0x01, 0x1c, 0x1d, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x04, 0xda, + 0x01, 0x04, 0x1b, 0x1a, 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, + 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x04, 0x12, 0x04, + 0xda, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x05, 0x12, 0x04, 0xda, + 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, 0x12, 0x04, 0xda, 0x01, + 0x14, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x04, 0xda, 0x01, 0x19, + 0x1a, 0x0a, 0x6b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x02, 0x12, 0x04, 0xde, 0x01, 0x04, 0x1c, 0x1a, + 0x5d, 0x20, 0x4c, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, + 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x04, 0x12, 0x04, 0xde, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x02, 0x05, 0x12, 0x04, 0xde, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x02, 0x01, 0x12, 0x04, 0xde, 0x01, 0x14, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x02, 0x03, 0x12, 0x04, 0xde, 0x01, 0x1a, 0x1b, 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, + 0x05, 0x02, 0x03, 0x12, 0x04, 0xe3, 0x01, 0x04, 0x1b, 0x1a, 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, + 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, + 0x47, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, + 0x6e, 0x20, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, + 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, + 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x04, 0x12, 0x04, 0xe3, 0x01, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x05, 0x12, 0x04, 0xe3, 0x01, 0x0d, 0x13, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x01, 0x12, 0x04, 0xe3, 0x01, 0x14, 0x16, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x03, 0x12, 0x04, 0xe3, 0x01, 0x19, 0x1a, 0x0a, 0xc2, 0x01, + 0x0a, 0x04, 0x04, 0x05, 0x02, 0x04, 0x12, 0x04, 0xe8, 0x01, 0x04, 0x1c, 0x1a, 0xb3, 0x01, 0x20, + 0x47, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, + 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, + 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, + 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, + 0x47, 0x74, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, + 0x61, 0x6e, 0x20, 0x61, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, + 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x04, 0x12, 0x04, 0xe8, 0x01, 0x04, + 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x05, 0x12, 0x04, 0xe8, 0x01, 0x0d, 0x13, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x01, 0x12, 0x04, 0xe8, 0x01, 0x14, 0x17, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x03, 0x12, 0x04, 0xe8, 0x01, 0x1a, 0x1b, 0x0a, 0x5a, + 0x0a, 0x04, 0x04, 0x05, 0x02, 0x05, 0x12, 0x04, 0xec, 0x01, 0x04, 0x1b, 0x1a, 0x4c, 0x20, 0x49, + 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x05, 0x04, 0x12, 0x04, 0xec, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x05, 0x05, 0x12, 0x04, 0xec, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x05, + 0x01, 0x12, 0x04, 0xec, 0x01, 0x14, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x05, 0x03, + 0x12, 0x04, 0xec, 0x01, 0x19, 0x1a, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x06, 0x12, 0x04, + 0xf0, 0x01, 0x04, 0x1f, 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, + 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, 0x04, + 0x12, 0x04, 0xf0, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, 0x05, 0x12, + 0x04, 0xf0, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, 0x01, 0x12, 0x04, + 0xf0, 0x01, 0x14, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, 0x03, 0x12, 0x04, 0xf0, + 0x01, 0x1d, 0x1e, 0x0a, 0x81, 0x01, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x07, 0x12, 0x04, 0xf4, 0x01, + 0x04, 0x23, 0x1a, 0x73, 0x20, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, + 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, + 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, + 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x04, + 0x12, 0x04, 0xf4, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x05, 0x12, + 0x04, 0xf4, 0x01, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x01, 0x12, 0x04, + 0xf4, 0x01, 0x12, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x03, 0x12, 0x04, 0xf4, + 0x01, 0x21, 0x22, 0x0a, 0x50, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x06, 0xf8, 0x01, 0x00, 0x99, 0x02, + 0x01, 0x1a, 0x42, 0x20, 0x55, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, + 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x60, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x04, 0xf8, 0x01, + 0x08, 0x13, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x04, 0xfa, 0x01, 0x04, 0x1e, + 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, + 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x04, + 0x12, 0x04, 0xfa, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x05, 0x12, + 0x04, 0xfa, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x04, + 0xfa, 0x01, 0x14, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x04, 0xfa, + 0x01, 0x1c, 0x1d, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x01, 0x12, 0x04, 0xfe, 0x01, 0x04, + 0x1b, 0x1a, 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, + 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x04, 0x12, 0x04, 0xfe, 0x01, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x05, 0x12, 0x04, 0xfe, 0x01, 0x0d, + 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x01, 0x12, 0x04, 0xfe, 0x01, 0x14, 0x16, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x03, 0x12, 0x04, 0xfe, 0x01, 0x19, 0x1a, 0x0a, + 0x6b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x02, 0x12, 0x04, 0x82, 0x02, 0x04, 0x1c, 0x1a, 0x5d, 0x20, + 0x4c, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, + 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x02, 0x04, 0x12, 0x04, 0x82, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x02, 0x05, 0x12, 0x04, 0x82, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x02, 0x01, 0x12, 0x04, 0x82, 0x02, 0x14, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x02, 0x03, 0x12, 0x04, 0x82, 0x02, 0x1a, 0x1b, 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, 0x06, 0x02, + 0x03, 0x12, 0x04, 0x87, 0x02, 0x04, 0x1b, 0x1a, 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, + 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, + 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, + 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, 0x6e, 0x67, + 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x03, 0x04, 0x12, 0x04, 0x87, 0x02, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x03, 0x05, 0x12, 0x04, 0x87, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x03, 0x01, 0x12, 0x04, 0x87, 0x02, 0x14, 0x16, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x03, 0x03, 0x12, 0x04, 0x87, 0x02, 0x19, 0x1a, 0x0a, 0xc2, 0x01, 0x0a, 0x04, + 0x04, 0x06, 0x02, 0x04, 0x12, 0x04, 0x8c, 0x02, 0x04, 0x1c, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, + 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, + 0x65, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x61, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, + 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, + 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x04, 0x12, 0x04, 0x8c, 0x02, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x05, 0x12, 0x04, 0x8c, 0x02, 0x0d, 0x13, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x01, 0x12, 0x04, 0x8c, 0x02, 0x14, 0x17, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x04, 0x03, 0x12, 0x04, 0x8c, 0x02, 0x1a, 0x1b, 0x0a, 0x5a, 0x0a, 0x04, + 0x04, 0x06, 0x02, 0x05, 0x12, 0x04, 0x90, 0x02, 0x04, 0x1b, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, + 0x04, 0x12, 0x04, 0x90, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, 0x05, + 0x12, 0x04, 0x90, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, 0x01, 0x12, + 0x04, 0x90, 0x02, 0x14, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, 0x03, 0x12, 0x04, + 0x90, 0x02, 0x19, 0x1a, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x06, 0x12, 0x04, 0x94, 0x02, + 0x04, 0x1f, 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, + 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x06, 0x04, 0x12, 0x04, + 0x94, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x06, 0x05, 0x12, 0x04, 0x94, + 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x06, 0x01, 0x12, 0x04, 0x94, 0x02, + 0x14, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x06, 0x03, 0x12, 0x04, 0x94, 0x02, 0x1d, + 0x1e, 0x0a, 0x81, 0x01, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x07, 0x12, 0x04, 0x98, 0x02, 0x04, 0x23, + 0x1a, 0x73, 0x20, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, + 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, + 0x75, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, + 0x6d, 0x70, 0x74, 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x07, 0x04, 0x12, 0x04, + 0x98, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x07, 0x05, 0x12, 0x04, 0x98, + 0x02, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x07, 0x01, 0x12, 0x04, 0x98, 0x02, + 0x12, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x07, 0x03, 0x12, 0x04, 0x98, 0x02, 0x21, + 0x22, 0x0a, 0x50, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x06, 0x9c, 0x02, 0x00, 0xbd, 0x02, 0x01, 0x1a, + 0x42, 0x20, 0x53, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, + 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x20, 0x60, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x04, 0x9c, 0x02, 0x08, 0x13, + 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x04, 0x9e, 0x02, 0x04, 0x1e, 0x1a, 0x45, + 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x04, 0x12, 0x04, + 0x9e, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x05, 0x12, 0x04, 0x9e, + 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x01, 0x12, 0x04, 0x9e, 0x02, + 0x14, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x03, 0x12, 0x04, 0x9e, 0x02, 0x1c, + 0x1d, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x01, 0x12, 0x04, 0xa2, 0x02, 0x04, 0x1b, 0x1a, + 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, + 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x04, 0x12, 0x04, 0xa2, 0x02, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x05, 0x12, 0x04, 0xa2, 0x02, 0x0d, 0x13, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x01, 0x12, 0x04, 0xa2, 0x02, 0x14, 0x16, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, 0x04, 0xa2, 0x02, 0x19, 0x1a, 0x0a, 0x6b, 0x0a, + 0x04, 0x04, 0x07, 0x02, 0x02, 0x12, 0x04, 0xa6, 0x02, 0x04, 0x1c, 0x1a, 0x5d, 0x20, 0x4c, 0x74, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, + 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, + 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x02, 0x04, 0x12, 0x04, 0xa6, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x02, 0x05, 0x12, 0x04, 0xa6, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, + 0x01, 0x12, 0x04, 0xa6, 0x02, 0x14, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x03, + 0x12, 0x04, 0xa6, 0x02, 0x1a, 0x1b, 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x03, 0x12, + 0x04, 0xab, 0x02, 0x04, 0x1b, 0x1a, 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, + 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x20, 0x69, + 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, + 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, + 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x03, 0x04, 0x12, 0x04, 0xab, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x03, 0x05, 0x12, 0x04, 0xab, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x03, 0x01, 0x12, 0x04, 0xab, 0x02, 0x14, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x03, 0x03, 0x12, 0x04, 0xab, 0x02, 0x19, 0x1a, 0x0a, 0xc2, 0x01, 0x0a, 0x04, 0x04, 0x07, + 0x02, 0x04, 0x12, 0x04, 0xb0, 0x02, 0x04, 0x1c, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, + 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, + 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x65, 0x20, + 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, + 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, + 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, + 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x04, 0x04, 0x12, 0x04, 0xb0, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x04, 0x05, 0x12, 0x04, 0xb0, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x04, 0x01, 0x12, 0x04, 0xb0, 0x02, 0x14, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x04, 0x03, 0x12, 0x04, 0xb0, 0x02, 0x1a, 0x1b, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x07, + 0x02, 0x05, 0x12, 0x04, 0xb4, 0x02, 0x04, 0x1b, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x05, 0x04, 0x12, + 0x04, 0xb4, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x05, 0x05, 0x12, 0x04, + 0xb4, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x05, 0x01, 0x12, 0x04, 0xb4, + 0x02, 0x14, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x05, 0x03, 0x12, 0x04, 0xb4, 0x02, + 0x19, 0x1a, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x06, 0x12, 0x04, 0xb8, 0x02, 0x04, 0x1f, + 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, + 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x06, 0x04, 0x12, 0x04, 0xb8, 0x02, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x06, 0x05, 0x12, 0x04, 0xb8, 0x02, 0x0d, + 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x06, 0x01, 0x12, 0x04, 0xb8, 0x02, 0x14, 0x1a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x06, 0x03, 0x12, 0x04, 0xb8, 0x02, 0x1d, 0x1e, 0x0a, + 0x81, 0x01, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x07, 0x12, 0x04, 0xbc, 0x02, 0x04, 0x23, 0x1a, 0x73, + 0x20, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, + 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, + 0x74, 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x07, 0x04, 0x12, 0x04, 0xbc, 0x02, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x07, 0x05, 0x12, 0x04, 0xbc, 0x02, 0x0d, + 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x07, 0x01, 0x12, 0x04, 0xbc, 0x02, 0x12, 0x1e, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x07, 0x03, 0x12, 0x04, 0xbc, 0x02, 0x21, 0x22, 0x0a, + 0x50, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x06, 0xc0, 0x02, 0x00, 0xe1, 0x02, 0x01, 0x1a, 0x42, 0x20, + 0x53, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, + 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x20, 0x60, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x08, 0x01, 0x12, 0x04, 0xc0, 0x02, 0x08, 0x13, 0x0a, 0x53, + 0x0a, 0x04, 0x04, 0x08, 0x02, 0x00, 0x12, 0x04, 0xc2, 0x02, 0x04, 0x1e, 0x1a, 0x45, 0x20, 0x43, + 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, + 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x04, 0x12, 0x04, 0xc2, 0x02, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x05, 0x12, 0x04, 0xc2, 0x02, 0x0d, + 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x04, 0xc2, 0x02, 0x14, 0x19, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x04, 0xc2, 0x02, 0x1c, 0x1d, 0x0a, + 0x5e, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x01, 0x12, 0x04, 0xc6, 0x02, 0x04, 0x1b, 0x1a, 0x50, 0x20, + 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, + 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x04, 0x12, 0x04, 0xc6, 0x02, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x05, 0x12, 0x04, 0xc6, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x01, 0x01, 0x12, 0x04, 0xc6, 0x02, 0x14, 0x16, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x08, 0x02, 0x01, 0x03, 0x12, 0x04, 0xc6, 0x02, 0x19, 0x1a, 0x0a, 0x6b, 0x0a, 0x04, 0x04, + 0x08, 0x02, 0x02, 0x12, 0x04, 0xca, 0x02, 0x04, 0x1c, 0x1a, 0x5d, 0x20, 0x4c, 0x74, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, + 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, + 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, + 0x04, 0x12, 0x04, 0xca, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x05, + 0x12, 0x04, 0xca, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x01, 0x12, + 0x04, 0xca, 0x02, 0x14, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x03, 0x12, 0x04, + 0xca, 0x02, 0x1a, 0x1b, 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x03, 0x12, 0x04, 0xcf, + 0x02, 0x04, 0x1b, 0x1a, 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, + 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x20, 0x69, 0x73, 0x20, + 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, + 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x03, 0x04, 0x12, 0x04, 0xcf, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x03, 0x05, 0x12, 0x04, 0xcf, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x03, 0x01, 0x12, 0x04, 0xcf, 0x02, 0x14, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, + 0x03, 0x12, 0x04, 0xcf, 0x02, 0x19, 0x1a, 0x0a, 0xc2, 0x01, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x04, + 0x12, 0x04, 0xd4, 0x02, 0x04, 0x1c, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, + 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, + 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x0a, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, + 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, + 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x08, 0x02, 0x04, 0x04, 0x12, 0x04, 0xd4, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x04, 0x05, 0x12, 0x04, 0xd4, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x04, 0x01, 0x12, 0x04, 0xd4, 0x02, 0x14, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x04, 0x03, 0x12, 0x04, 0xd4, 0x02, 0x1a, 0x1b, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x05, + 0x12, 0x04, 0xd8, 0x02, 0x04, 0x1b, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, + 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x04, 0x12, 0x04, 0xd8, + 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x05, 0x12, 0x04, 0xd8, 0x02, + 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x01, 0x12, 0x04, 0xd8, 0x02, 0x14, + 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x03, 0x12, 0x04, 0xd8, 0x02, 0x19, 0x1a, + 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x06, 0x12, 0x04, 0xdc, 0x02, 0x04, 0x1f, 0x1a, 0x51, + 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, + 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x04, 0x12, 0x04, 0xdc, 0x02, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x05, 0x12, 0x04, 0xdc, 0x02, 0x0d, 0x13, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x01, 0x12, 0x04, 0xdc, 0x02, 0x14, 0x1a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x03, 0x12, 0x04, 0xdc, 0x02, 0x1d, 0x1e, 0x0a, 0x81, 0x01, + 0x0a, 0x04, 0x04, 0x08, 0x02, 0x07, 0x12, 0x04, 0xe0, 0x02, 0x04, 0x23, 0x1a, 0x73, 0x20, 0x49, + 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x04, 0x12, 0x04, 0xe0, 0x02, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x05, 0x12, 0x04, 0xe0, 0x02, 0x0d, 0x11, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x01, 0x12, 0x04, 0xe0, 0x02, 0x12, 0x1e, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x03, 0x12, 0x04, 0xe0, 0x02, 0x21, 0x22, 0x0a, 0x52, 0x0a, + 0x02, 0x04, 0x09, 0x12, 0x06, 0xe4, 0x02, 0x00, 0x85, 0x03, 0x01, 0x1a, 0x44, 0x20, 0x46, 0x69, + 0x78, 0x65, 0x64, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, + 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x60, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, 0x04, 0xe4, 0x02, 0x08, 0x14, 0x0a, 0x53, + 0x0a, 0x04, 0x04, 0x09, 0x02, 0x00, 0x12, 0x04, 0xe6, 0x02, 0x04, 0x1f, 0x1a, 0x45, 0x20, 0x43, + 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, + 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x04, 0x12, 0x04, 0xe6, 0x02, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x05, 0x12, 0x04, 0xe6, 0x02, 0x0d, + 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x04, 0xe6, 0x02, 0x15, 0x1a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, 0x04, 0xe6, 0x02, 0x1d, 0x1e, 0x0a, + 0x5e, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x01, 0x12, 0x04, 0xea, 0x02, 0x04, 0x1c, 0x1a, 0x50, 0x20, + 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, + 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x04, 0x12, 0x04, 0xea, 0x02, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x05, 0x12, 0x04, 0xea, 0x02, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x09, 0x02, 0x01, 0x01, 0x12, 0x04, 0xea, 0x02, 0x15, 0x17, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x09, 0x02, 0x01, 0x03, 0x12, 0x04, 0xea, 0x02, 0x1a, 0x1b, 0x0a, 0x6b, 0x0a, 0x04, 0x04, + 0x09, 0x02, 0x02, 0x12, 0x04, 0xee, 0x02, 0x04, 0x1d, 0x1a, 0x5d, 0x20, 0x4c, 0x74, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, + 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, + 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, + 0x04, 0x12, 0x04, 0xee, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x05, + 0x12, 0x04, 0xee, 0x02, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x01, 0x12, + 0x04, 0xee, 0x02, 0x15, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x03, 0x12, 0x04, + 0xee, 0x02, 0x1b, 0x1c, 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x03, 0x12, 0x04, 0xf3, + 0x02, 0x04, 0x1c, 0x1a, 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, + 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x20, 0x69, 0x73, 0x20, + 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, + 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x09, 0x02, 0x03, 0x04, 0x12, 0x04, 0xf3, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x03, 0x05, 0x12, 0x04, 0xf3, 0x02, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, + 0x03, 0x01, 0x12, 0x04, 0xf3, 0x02, 0x15, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, + 0x03, 0x12, 0x04, 0xf3, 0x02, 0x1a, 0x1b, 0x0a, 0xc2, 0x01, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x04, + 0x12, 0x04, 0xf8, 0x02, 0x04, 0x1d, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, + 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, + 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x0a, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, + 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, + 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x09, 0x02, 0x04, 0x04, 0x12, 0x04, 0xf8, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x09, 0x02, 0x04, 0x05, 0x12, 0x04, 0xf8, 0x02, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x04, 0x01, 0x12, 0x04, 0xf8, 0x02, 0x15, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, + 0x04, 0x03, 0x12, 0x04, 0xf8, 0x02, 0x1b, 0x1c, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x05, + 0x12, 0x04, 0xfc, 0x02, 0x04, 0x1c, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, + 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x05, 0x04, 0x12, 0x04, 0xfc, + 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x05, 0x05, 0x12, 0x04, 0xfc, 0x02, + 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x05, 0x01, 0x12, 0x04, 0xfc, 0x02, 0x15, + 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x05, 0x03, 0x12, 0x04, 0xfc, 0x02, 0x1a, 0x1b, + 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x06, 0x12, 0x04, 0x80, 0x03, 0x04, 0x20, 0x1a, 0x51, + 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, + 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x06, 0x04, 0x12, 0x04, 0x80, 0x03, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x06, 0x05, 0x12, 0x04, 0x80, 0x03, 0x0d, 0x14, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x06, 0x01, 0x12, 0x04, 0x80, 0x03, 0x15, 0x1b, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x09, 0x02, 0x06, 0x03, 0x12, 0x04, 0x80, 0x03, 0x1e, 0x1f, 0x0a, 0x81, 0x01, + 0x0a, 0x04, 0x04, 0x09, 0x02, 0x07, 0x12, 0x04, 0x84, 0x03, 0x04, 0x23, 0x1a, 0x73, 0x20, 0x49, + 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x07, 0x04, 0x12, 0x04, 0x84, 0x03, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x07, 0x05, 0x12, 0x04, 0x84, 0x03, 0x0d, 0x11, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x07, 0x01, 0x12, 0x04, 0x84, 0x03, 0x12, 0x1e, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x09, 0x02, 0x07, 0x03, 0x12, 0x04, 0x84, 0x03, 0x21, 0x22, 0x0a, 0x52, 0x0a, + 0x02, 0x04, 0x0a, 0x12, 0x06, 0x88, 0x03, 0x00, 0xa9, 0x03, 0x01, 0x1a, 0x44, 0x20, 0x46, 0x69, + 0x78, 0x65, 0x64, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, + 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x60, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0a, 0x01, 0x12, 0x04, 0x88, 0x03, 0x08, 0x14, 0x0a, 0x53, + 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x00, 0x12, 0x04, 0x8a, 0x03, 0x04, 0x1f, 0x1a, 0x45, 0x20, 0x43, + 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, + 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x04, 0x12, 0x04, 0x8a, 0x03, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x05, 0x12, 0x04, 0x8a, 0x03, 0x0d, + 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x04, 0x8a, 0x03, 0x15, 0x1a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, 0x04, 0x8a, 0x03, 0x1d, 0x1e, 0x0a, + 0x5e, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x01, 0x12, 0x04, 0x8e, 0x03, 0x04, 0x1c, 0x1a, 0x50, 0x20, + 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, + 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x04, 0x12, 0x04, 0x8e, 0x03, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x05, 0x12, 0x04, 0x8e, 0x03, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0a, 0x02, 0x01, 0x01, 0x12, 0x04, 0x8e, 0x03, 0x15, 0x17, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0a, 0x02, 0x01, 0x03, 0x12, 0x04, 0x8e, 0x03, 0x1a, 0x1b, 0x0a, 0x6b, 0x0a, 0x04, 0x04, + 0x0a, 0x02, 0x02, 0x12, 0x04, 0x92, 0x03, 0x04, 0x1d, 0x1a, 0x5d, 0x20, 0x4c, 0x74, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, + 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, + 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, + 0x04, 0x12, 0x04, 0x92, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x05, + 0x12, 0x04, 0x92, 0x03, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x01, 0x12, + 0x04, 0x92, 0x03, 0x15, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x03, 0x12, 0x04, + 0x92, 0x03, 0x1b, 0x1c, 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x03, 0x12, 0x04, 0x97, + 0x03, 0x04, 0x1c, 0x1a, 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, + 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x20, 0x69, 0x73, 0x20, + 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, + 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0a, 0x02, 0x03, 0x04, 0x12, 0x04, 0x97, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, + 0x02, 0x03, 0x05, 0x12, 0x04, 0x97, 0x03, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, + 0x03, 0x01, 0x12, 0x04, 0x97, 0x03, 0x15, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, + 0x03, 0x12, 0x04, 0x97, 0x03, 0x1a, 0x1b, 0x0a, 0xc2, 0x01, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x04, + 0x12, 0x04, 0x9c, 0x03, 0x04, 0x1d, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, + 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, + 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x0a, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, + 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, + 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x9c, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x9c, 0x03, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, + 0x02, 0x04, 0x01, 0x12, 0x04, 0x9c, 0x03, 0x15, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, + 0x04, 0x03, 0x12, 0x04, 0x9c, 0x03, 0x1b, 0x1c, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x05, + 0x12, 0x04, 0xa0, 0x03, 0x04, 0x1c, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, + 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x05, 0x04, 0x12, 0x04, 0xa0, + 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x05, 0x05, 0x12, 0x04, 0xa0, 0x03, + 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x05, 0x01, 0x12, 0x04, 0xa0, 0x03, 0x15, + 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x05, 0x03, 0x12, 0x04, 0xa0, 0x03, 0x1a, 0x1b, + 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x06, 0x12, 0x04, 0xa4, 0x03, 0x04, 0x20, 0x1a, 0x51, + 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, + 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x06, 0x04, 0x12, 0x04, 0xa4, 0x03, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x06, 0x05, 0x12, 0x04, 0xa4, 0x03, 0x0d, 0x14, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x06, 0x01, 0x12, 0x04, 0xa4, 0x03, 0x15, 0x1b, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x06, 0x03, 0x12, 0x04, 0xa4, 0x03, 0x1e, 0x1f, 0x0a, 0x81, 0x01, + 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x07, 0x12, 0x04, 0xa8, 0x03, 0x04, 0x23, 0x1a, 0x73, 0x20, 0x49, + 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x07, 0x04, 0x12, 0x04, 0xa8, 0x03, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x07, 0x05, 0x12, 0x04, 0xa8, 0x03, 0x0d, 0x11, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x07, 0x01, 0x12, 0x04, 0xa8, 0x03, 0x12, 0x1e, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x07, 0x03, 0x12, 0x04, 0xa8, 0x03, 0x21, 0x22, 0x0a, 0x54, 0x0a, + 0x02, 0x04, 0x0b, 0x12, 0x06, 0xac, 0x03, 0x00, 0xcd, 0x03, 0x01, 0x1a, 0x46, 0x20, 0x53, 0x46, + 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, + 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x20, 0x60, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0b, 0x01, 0x12, 0x04, 0xac, 0x03, 0x08, 0x15, + 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x00, 0x12, 0x04, 0xae, 0x03, 0x04, 0x20, 0x1a, 0x45, + 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x04, 0x12, 0x04, + 0xae, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x05, 0x12, 0x04, 0xae, + 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x01, 0x12, 0x04, 0xae, 0x03, + 0x16, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x03, 0x12, 0x04, 0xae, 0x03, 0x1e, + 0x1f, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x01, 0x12, 0x04, 0xb2, 0x03, 0x04, 0x1d, 0x1a, + 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, + 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x04, 0x12, 0x04, 0xb2, 0x03, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x05, 0x12, 0x04, 0xb2, 0x03, 0x0d, 0x15, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x01, 0x12, 0x04, 0xb2, 0x03, 0x16, 0x18, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x03, 0x12, 0x04, 0xb2, 0x03, 0x1b, 0x1c, 0x0a, 0x6b, 0x0a, + 0x04, 0x04, 0x0b, 0x02, 0x02, 0x12, 0x04, 0xb6, 0x03, 0x04, 0x1e, 0x1a, 0x5d, 0x20, 0x4c, 0x74, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, + 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, + 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, + 0x02, 0x02, 0x04, 0x12, 0x04, 0xb6, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, + 0x02, 0x05, 0x12, 0x04, 0xb6, 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x02, + 0x01, 0x12, 0x04, 0xb6, 0x03, 0x16, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x02, 0x03, + 0x12, 0x04, 0xb6, 0x03, 0x1c, 0x1d, 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x03, 0x12, + 0x04, 0xbb, 0x03, 0x04, 0x1d, 0x1a, 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, + 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x20, 0x69, + 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, + 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, + 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0b, 0x02, 0x03, 0x04, 0x12, 0x04, 0xbb, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0b, 0x02, 0x03, 0x05, 0x12, 0x04, 0xbb, 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0b, 0x02, 0x03, 0x01, 0x12, 0x04, 0xbb, 0x03, 0x16, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, + 0x02, 0x03, 0x03, 0x12, 0x04, 0xbb, 0x03, 0x1b, 0x1c, 0x0a, 0xc2, 0x01, 0x0a, 0x04, 0x04, 0x0b, + 0x02, 0x04, 0x12, 0x04, 0xc0, 0x03, 0x04, 0x1e, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, + 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, + 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x65, 0x20, + 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, + 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, + 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, + 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x04, 0x04, 0x12, 0x04, 0xc0, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0b, 0x02, 0x04, 0x05, 0x12, 0x04, 0xc0, 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0b, 0x02, 0x04, 0x01, 0x12, 0x04, 0xc0, 0x03, 0x16, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0b, 0x02, 0x04, 0x03, 0x12, 0x04, 0xc0, 0x03, 0x1c, 0x1d, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x0b, + 0x02, 0x05, 0x12, 0x04, 0xc4, 0x03, 0x04, 0x1d, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x05, 0x04, 0x12, + 0x04, 0xc4, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x05, 0x05, 0x12, 0x04, + 0xc4, 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x05, 0x01, 0x12, 0x04, 0xc4, + 0x03, 0x16, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x05, 0x03, 0x12, 0x04, 0xc4, 0x03, + 0x1b, 0x1c, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x06, 0x12, 0x04, 0xc8, 0x03, 0x04, 0x21, + 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, + 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x06, 0x04, 0x12, 0x04, 0xc8, 0x03, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x06, 0x05, 0x12, 0x04, 0xc8, 0x03, 0x0d, + 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x06, 0x01, 0x12, 0x04, 0xc8, 0x03, 0x16, 0x1c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x06, 0x03, 0x12, 0x04, 0xc8, 0x03, 0x1f, 0x20, 0x0a, + 0x81, 0x01, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x07, 0x12, 0x04, 0xcc, 0x03, 0x04, 0x23, 0x1a, 0x73, + 0x20, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, + 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, + 0x74, 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x07, 0x04, 0x12, 0x04, 0xcc, 0x03, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x07, 0x05, 0x12, 0x04, 0xcc, 0x03, 0x0d, + 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x07, 0x01, 0x12, 0x04, 0xcc, 0x03, 0x12, 0x1e, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x07, 0x03, 0x12, 0x04, 0xcc, 0x03, 0x21, 0x22, 0x0a, + 0x54, 0x0a, 0x02, 0x04, 0x0c, 0x12, 0x06, 0xd0, 0x03, 0x00, 0xf1, 0x03, 0x01, 0x1a, 0x46, 0x20, + 0x53, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, + 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x20, 0x60, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x60, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0c, 0x01, 0x12, 0x04, 0xd0, 0x03, + 0x08, 0x15, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x00, 0x12, 0x04, 0xd2, 0x03, 0x04, 0x20, + 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, + 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x04, + 0x12, 0x04, 0xd2, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x05, 0x12, + 0x04, 0xd2, 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x01, 0x12, 0x04, + 0xd2, 0x03, 0x16, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x03, 0x12, 0x04, 0xd2, + 0x03, 0x1e, 0x1f, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x01, 0x12, 0x04, 0xd6, 0x03, 0x04, + 0x1d, 0x1a, 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, + 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x04, 0x12, 0x04, 0xd6, 0x03, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x05, 0x12, 0x04, 0xd6, 0x03, 0x0d, + 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x01, 0x12, 0x04, 0xd6, 0x03, 0x16, 0x18, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x03, 0x12, 0x04, 0xd6, 0x03, 0x1b, 0x1c, 0x0a, + 0x6b, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x02, 0x12, 0x04, 0xda, 0x03, 0x04, 0x1e, 0x1a, 0x5d, 0x20, + 0x4c, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, + 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0c, 0x02, 0x02, 0x04, 0x12, 0x04, 0xda, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0c, 0x02, 0x02, 0x05, 0x12, 0x04, 0xda, 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, + 0x02, 0x02, 0x01, 0x12, 0x04, 0xda, 0x03, 0x16, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, + 0x02, 0x03, 0x12, 0x04, 0xda, 0x03, 0x1c, 0x1d, 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, 0x0c, 0x02, + 0x03, 0x12, 0x04, 0xdf, 0x03, 0x04, 0x1d, 0x1a, 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, + 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, + 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, + 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, 0x6e, 0x67, + 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x03, 0x04, 0x12, 0x04, 0xdf, 0x03, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x03, 0x05, 0x12, 0x04, 0xdf, 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0c, 0x02, 0x03, 0x01, 0x12, 0x04, 0xdf, 0x03, 0x16, 0x18, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0c, 0x02, 0x03, 0x03, 0x12, 0x04, 0xdf, 0x03, 0x1b, 0x1c, 0x0a, 0xc2, 0x01, 0x0a, 0x04, + 0x04, 0x0c, 0x02, 0x04, 0x12, 0x04, 0xe4, 0x03, 0x04, 0x1e, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, + 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, + 0x65, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x61, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, + 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, + 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x04, 0x04, 0x12, 0x04, 0xe4, 0x03, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x04, 0x05, 0x12, 0x04, 0xe4, 0x03, 0x0d, 0x15, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x04, 0x01, 0x12, 0x04, 0xe4, 0x03, 0x16, 0x19, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0c, 0x02, 0x04, 0x03, 0x12, 0x04, 0xe4, 0x03, 0x1c, 0x1d, 0x0a, 0x5a, 0x0a, 0x04, + 0x04, 0x0c, 0x02, 0x05, 0x12, 0x04, 0xe8, 0x03, 0x04, 0x1d, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x05, + 0x04, 0x12, 0x04, 0xe8, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x05, 0x05, + 0x12, 0x04, 0xe8, 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x05, 0x01, 0x12, + 0x04, 0xe8, 0x03, 0x16, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x05, 0x03, 0x12, 0x04, + 0xe8, 0x03, 0x1b, 0x1c, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x06, 0x12, 0x04, 0xec, 0x03, + 0x04, 0x21, 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, + 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x06, 0x04, 0x12, 0x04, + 0xec, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x06, 0x05, 0x12, 0x04, 0xec, + 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x06, 0x01, 0x12, 0x04, 0xec, 0x03, + 0x16, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x06, 0x03, 0x12, 0x04, 0xec, 0x03, 0x1f, + 0x20, 0x0a, 0x81, 0x01, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x07, 0x12, 0x04, 0xf0, 0x03, 0x04, 0x23, + 0x1a, 0x73, 0x20, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, + 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, + 0x75, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, + 0x6d, 0x70, 0x74, 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x07, 0x04, 0x12, 0x04, + 0xf0, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x07, 0x05, 0x12, 0x04, 0xf0, + 0x03, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x07, 0x01, 0x12, 0x04, 0xf0, 0x03, + 0x12, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x07, 0x03, 0x12, 0x04, 0xf0, 0x03, 0x21, + 0x22, 0x0a, 0x4c, 0x0a, 0x02, 0x04, 0x0d, 0x12, 0x06, 0xf4, 0x03, 0x00, 0xf7, 0x03, 0x01, 0x1a, + 0x3e, 0x20, 0x42, 0x6f, 0x6f, 0x6c, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, + 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x20, 0x60, 0x62, 0x6f, 0x6f, 0x6c, 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, + 0x0b, 0x0a, 0x03, 0x04, 0x0d, 0x01, 0x12, 0x04, 0xf4, 0x03, 0x08, 0x11, 0x0a, 0x53, 0x0a, 0x04, + 0x04, 0x0d, 0x02, 0x00, 0x12, 0x04, 0xf6, 0x03, 0x04, 0x1c, 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, + 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, + 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x04, 0x12, 0x04, 0xf6, 0x03, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x05, 0x12, 0x04, 0xf6, 0x03, 0x0d, 0x11, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x01, 0x12, 0x04, 0xf6, 0x03, 0x12, 0x17, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x03, 0x12, 0x04, 0xf6, 0x03, 0x1a, 0x1b, 0x0a, 0x4f, 0x0a, + 0x02, 0x04, 0x0e, 0x12, 0x06, 0xfa, 0x03, 0x00, 0xeb, 0x04, 0x01, 0x1a, 0x41, 0x20, 0x53, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, + 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x73, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0b, + 0x0a, 0x03, 0x04, 0x0e, 0x01, 0x12, 0x04, 0xfa, 0x03, 0x08, 0x13, 0x0a, 0x53, 0x0a, 0x04, 0x04, + 0x0e, 0x02, 0x00, 0x12, 0x04, 0xfc, 0x03, 0x04, 0x1e, 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, + 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x04, 0x12, 0x04, 0xfc, 0x03, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x05, 0x12, 0x04, 0xfc, 0x03, 0x0d, 0x13, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x01, 0x12, 0x04, 0xfc, 0x03, 0x14, 0x19, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x00, 0x03, 0x12, 0x04, 0xfc, 0x03, 0x1c, 0x1d, 0x0a, 0xc8, 0x01, 0x0a, + 0x04, 0x04, 0x0e, 0x02, 0x01, 0x12, 0x04, 0x81, 0x04, 0x04, 0x1d, 0x1a, 0xb9, 0x01, 0x20, 0x4c, + 0x65, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, + 0x74, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x63, 0x68, + 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x73, 0x20, 0x28, 0x55, 0x6e, 0x69, 0x63, 0x6f, 0x64, + 0x65, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x29, 0x2e, 0x20, + 0x4e, 0x6f, 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, + 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, + 0x65, 0x72, 0x73, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x20, 0x66, + 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, + 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x04, + 0x12, 0x04, 0x81, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x05, 0x12, + 0x04, 0x81, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x01, 0x12, 0x04, + 0x81, 0x04, 0x14, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x03, 0x12, 0x04, 0x81, + 0x04, 0x1a, 0x1c, 0x0a, 0xd8, 0x01, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x02, 0x12, 0x04, 0x86, 0x04, + 0x04, 0x20, 0x1a, 0xc9, 0x01, 0x20, 0x4d, 0x69, 0x6e, 0x4c, 0x65, 0x6e, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x6e, 0x75, 0x6d, + 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, + 0x72, 0x73, 0x20, 0x28, 0x55, 0x6e, 0x69, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x63, 0x6f, 0x64, 0x65, + 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x29, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6d, 0x69, + 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x2e, 0x20, 0x4e, 0x6f, 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, + 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x73, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x64, + 0x69, 0x66, 0x66, 0x65, 0x72, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, + 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x69, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x02, 0x04, 0x12, 0x04, 0x86, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x02, 0x05, 0x12, 0x04, 0x86, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x02, 0x01, 0x12, 0x04, 0x86, 0x04, 0x14, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x02, 0x03, 0x12, 0x04, 0x86, 0x04, 0x1e, 0x1f, 0x0a, 0xd8, 0x01, 0x0a, 0x04, 0x04, + 0x0e, 0x02, 0x03, 0x12, 0x04, 0x8b, 0x04, 0x04, 0x20, 0x1a, 0xc9, 0x01, 0x20, 0x4d, 0x61, 0x78, + 0x4c, 0x65, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x63, + 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x73, 0x20, 0x28, 0x55, 0x6e, 0x69, 0x63, 0x6f, + 0x64, 0x65, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x29, 0x20, + 0x61, 0x74, 0x20, 0x61, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x2e, 0x20, 0x4e, 0x6f, + 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, + 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, + 0x73, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x20, 0x66, 0x72, 0x6f, + 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, + 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x04, 0x12, 0x04, + 0x8b, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x05, 0x12, 0x04, 0x8b, + 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x01, 0x12, 0x04, 0x8b, 0x04, + 0x14, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x03, 0x12, 0x04, 0x8b, 0x04, 0x1e, + 0x1f, 0x0a, 0x58, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x04, 0x12, 0x04, 0x8e, 0x04, 0x04, 0x23, 0x1a, + 0x4a, 0x20, 0x4c, 0x65, 0x6e, 0x42, 0x79, 0x74, 0x65, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, + 0x72, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x04, 0x04, 0x12, 0x04, 0x8e, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x04, 0x05, 0x12, 0x04, 0x8e, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x04, 0x01, 0x12, 0x04, 0x8e, 0x04, 0x14, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x04, + 0x03, 0x12, 0x04, 0x8e, 0x04, 0x20, 0x22, 0x0a, 0x66, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x05, 0x12, + 0x04, 0x92, 0x04, 0x04, 0x22, 0x1a, 0x58, 0x20, 0x4d, 0x69, 0x6e, 0x42, 0x79, 0x74, 0x65, 0x73, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, + 0x0a, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x05, 0x04, 0x12, 0x04, 0x92, 0x04, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x05, 0x05, 0x12, 0x04, 0x92, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x05, 0x01, 0x12, 0x04, 0x92, 0x04, 0x14, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x05, 0x03, 0x12, 0x04, 0x92, 0x04, 0x20, 0x21, 0x0a, 0x66, 0x0a, 0x04, 0x04, + 0x0e, 0x02, 0x06, 0x12, 0x04, 0x96, 0x04, 0x04, 0x22, 0x1a, 0x58, 0x20, 0x4d, 0x61, 0x78, 0x42, + 0x79, 0x74, 0x65, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, + 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x62, + 0x79, 0x74, 0x65, 0x73, 0x0a, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, + 0x75, 0x6d, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x06, 0x04, 0x12, 0x04, 0x96, 0x04, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x06, 0x05, 0x12, 0x04, 0x96, 0x04, 0x0d, + 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x06, 0x01, 0x12, 0x04, 0x96, 0x04, 0x14, 0x1d, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x06, 0x03, 0x12, 0x04, 0x96, 0x04, 0x20, 0x21, 0x0a, + 0xab, 0x01, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x07, 0x12, 0x04, 0x9b, 0x04, 0x04, 0x21, 0x1a, 0x9c, + 0x01, 0x20, 0x50, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x20, 0x61, + 0x67, 0x61, 0x69, 0x6e, 0x73, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x20, 0x65, 0x78, + 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x52, 0x45, 0x32, 0x20, 0x73, 0x79, + 0x6e, 0x74, 0x61, 0x78, 0x29, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, + 0x64, 0x65, 0x64, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x65, 0x6c, 0x69, 0x64, 0x65, 0x0a, 0x20, 0x61, 0x6e, 0x79, + 0x20, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x07, 0x04, 0x12, 0x04, 0x9b, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x07, 0x05, 0x12, 0x04, 0x9b, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x07, 0x01, 0x12, 0x04, 0x9b, 0x04, 0x14, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x07, 0x03, 0x12, 0x04, 0x9b, 0x04, 0x1f, 0x20, 0x0a, 0x73, 0x0a, 0x04, 0x04, 0x0e, 0x02, + 0x08, 0x12, 0x04, 0x9f, 0x04, 0x04, 0x21, 0x1a, 0x65, 0x20, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, + 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x74, 0x0a, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x08, 0x04, 0x12, 0x04, 0x9f, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x08, 0x05, 0x12, 0x04, 0x9f, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x08, 0x01, 0x12, 0x04, 0x9f, 0x04, 0x14, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x08, 0x03, 0x12, 0x04, 0x9f, 0x04, 0x1f, 0x20, 0x0a, 0x6d, 0x0a, 0x04, 0x04, 0x0e, + 0x02, 0x09, 0x12, 0x04, 0xa3, 0x04, 0x04, 0x21, 0x1a, 0x5f, 0x20, 0x53, 0x75, 0x66, 0x66, 0x69, + 0x78, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x20, 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x74, + 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x64, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x09, 0x04, 0x12, 0x04, 0xa3, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x09, + 0x05, 0x12, 0x04, 0xa3, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x09, 0x01, + 0x12, 0x04, 0xa3, 0x04, 0x14, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x09, 0x03, 0x12, + 0x04, 0xa3, 0x04, 0x1f, 0x20, 0x0a, 0x6d, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x0a, 0x12, 0x04, 0xa7, + 0x04, 0x04, 0x21, 0x1a, 0x5f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x68, 0x61, + 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x61, 0x6e, 0x79, 0x77, + 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0a, 0x04, 0x12, 0x04, 0xa7, + 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0a, 0x05, 0x12, 0x04, 0xa7, 0x04, + 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0a, 0x01, 0x12, 0x04, 0xa7, 0x04, 0x14, + 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0a, 0x03, 0x12, 0x04, 0xa7, 0x04, 0x1f, 0x20, + 0x0a, 0x72, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x0b, 0x12, 0x04, 0xab, 0x04, 0x04, 0x26, 0x1a, 0x64, + 0x20, 0x4e, 0x6f, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x68, 0x61, + 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x61, 0x6e, 0x79, 0x77, + 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0b, 0x04, 0x12, 0x04, 0xab, + 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0b, 0x05, 0x12, 0x04, 0xab, 0x04, + 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0b, 0x01, 0x12, 0x04, 0xab, 0x04, 0x14, + 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0b, 0x03, 0x12, 0x04, 0xab, 0x04, 0x23, 0x25, + 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x0c, 0x12, 0x04, 0xaf, 0x04, 0x04, 0x20, 0x1a, 0x4c, + 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, + 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x0c, 0x04, 0x12, 0x04, 0xaf, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x0c, 0x05, 0x12, 0x04, 0xaf, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x0c, 0x01, 0x12, 0x04, 0xaf, 0x04, 0x14, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x0c, 0x03, 0x12, 0x04, 0xaf, 0x04, 0x1d, 0x1f, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x0d, + 0x12, 0x04, 0xb3, 0x04, 0x04, 0x20, 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x0d, 0x04, 0x12, 0x04, 0xb3, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0d, + 0x05, 0x12, 0x04, 0xb3, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0d, 0x01, + 0x12, 0x04, 0xb3, 0x04, 0x14, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0d, 0x03, 0x12, + 0x04, 0xb3, 0x04, 0x1d, 0x1f, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x0e, 0x08, 0x00, 0x12, 0x06, 0xb7, + 0x04, 0x04, 0xdf, 0x04, 0x05, 0x1a, 0x4e, 0x20, 0x57, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77, + 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x20, + 0x61, 0x64, 0x76, 0x61, 0x6e, 0x63, 0x65, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, + 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x67, 0x61, 0x69, 0x6e, 0x73, 0x74, 0x20, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x70, 0x61, 0x74, 0x74, + 0x65, 0x72, 0x6e, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x08, 0x00, 0x01, 0x12, 0x04, + 0xb7, 0x04, 0x0a, 0x14, 0x0a, 0x64, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x0e, 0x12, 0x04, 0xba, 0x04, + 0x08, 0x1b, 0x1a, 0x56, 0x20, 0x45, 0x6d, 0x61, 0x69, 0x6c, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x20, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, + 0x73, 0x20, 0x61, 0x73, 0x0a, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, + 0x20, 0x52, 0x46, 0x43, 0x20, 0x35, 0x33, 0x32, 0x32, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x0e, 0x05, 0x12, 0x04, 0xba, 0x04, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x0e, 0x01, 0x12, 0x04, 0xba, 0x04, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0e, + 0x03, 0x12, 0x04, 0xba, 0x04, 0x18, 0x1a, 0x0a, 0xad, 0x01, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x0f, + 0x12, 0x04, 0xbf, 0x04, 0x08, 0x1b, 0x1a, 0x9e, 0x01, 0x20, 0x48, 0x6f, 0x73, 0x74, 0x6e, 0x61, + 0x6d, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x68, 0x6f, 0x73, 0x74, + 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x61, 0x73, 0x0a, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, + 0x20, 0x62, 0x79, 0x20, 0x52, 0x46, 0x43, 0x20, 0x31, 0x30, 0x33, 0x34, 0x2e, 0x20, 0x54, 0x68, + 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x20, 0x64, 0x6f, + 0x65, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x0a, 0x20, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, + 0x64, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x20, 0x28, + 0x49, 0x44, 0x4e, 0x73, 0x29, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0f, 0x05, + 0x12, 0x04, 0xbf, 0x04, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0f, 0x01, 0x12, + 0x04, 0xbf, 0x04, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0f, 0x03, 0x12, 0x04, + 0xbf, 0x04, 0x18, 0x1a, 0x0a, 0x99, 0x01, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x10, 0x12, 0x04, 0xc3, + 0x04, 0x08, 0x1b, 0x1a, 0x8a, 0x01, 0x20, 0x49, 0x70, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x20, 0x49, 0x50, 0x20, 0x28, 0x76, 0x34, 0x20, 0x6f, 0x72, 0x20, 0x76, 0x36, 0x29, + 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x2e, 0x0a, 0x20, 0x56, 0x61, 0x6c, 0x69, 0x64, + 0x20, 0x49, 0x50, 0x76, 0x36, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x20, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, + 0x64, 0x65, 0x20, 0x73, 0x75, 0x72, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x73, + 0x71, 0x75, 0x61, 0x72, 0x65, 0x20, 0x62, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x10, 0x05, 0x12, 0x04, 0xc3, 0x04, 0x08, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x10, 0x01, 0x12, 0x04, 0xc3, 0x04, 0x0d, 0x0f, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x10, 0x03, 0x12, 0x04, 0xc3, 0x04, 0x18, 0x1a, 0x0a, 0x4b, 0x0a, + 0x04, 0x04, 0x0e, 0x02, 0x11, 0x12, 0x04, 0xc6, 0x04, 0x08, 0x1b, 0x1a, 0x3d, 0x20, 0x49, 0x70, + 0x76, 0x34, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x49, 0x50, 0x76, 0x34, + 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x11, 0x05, 0x12, 0x04, 0xc6, 0x04, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x11, 0x01, 0x12, 0x04, 0xc6, 0x04, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x11, + 0x03, 0x12, 0x04, 0xc6, 0x04, 0x18, 0x1a, 0x0a, 0x92, 0x01, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x12, + 0x12, 0x04, 0xca, 0x04, 0x08, 0x1b, 0x1a, 0x83, 0x01, 0x20, 0x49, 0x70, 0x76, 0x36, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x49, 0x50, 0x76, 0x36, 0x20, 0x61, 0x64, 0x64, + 0x72, 0x65, 0x73, 0x73, 0x2e, 0x20, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x0a, 0x20, 0x49, 0x50, 0x76, + 0x36, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x20, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x73, + 0x75, 0x72, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x71, 0x75, 0x61, 0x72, + 0x65, 0x20, 0x62, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x12, 0x05, 0x12, 0x04, 0xca, 0x04, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x12, 0x01, 0x12, 0x04, 0xca, 0x04, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x12, 0x03, 0x12, 0x04, 0xca, 0x04, 0x18, 0x1a, 0x0a, 0x62, 0x0a, 0x04, 0x04, 0x0e, 0x02, + 0x13, 0x12, 0x04, 0xce, 0x04, 0x08, 0x1b, 0x1a, 0x54, 0x20, 0x55, 0x72, 0x69, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, + 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x2c, 0x20, 0x61, 0x62, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x65, + 0x20, 0x55, 0x52, 0x49, 0x20, 0x61, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x0a, + 0x20, 0x62, 0x79, 0x20, 0x52, 0x46, 0x43, 0x20, 0x33, 0x39, 0x38, 0x36, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x13, 0x05, 0x12, 0x04, 0xce, 0x04, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x13, 0x01, 0x12, 0x04, 0xce, 0x04, 0x0d, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x13, 0x03, 0x12, 0x04, 0xce, 0x04, 0x18, 0x1a, 0x0a, 0x7c, 0x0a, 0x04, 0x04, 0x0e, + 0x02, 0x14, 0x12, 0x04, 0xd2, 0x04, 0x08, 0x1b, 0x1a, 0x6e, 0x20, 0x55, 0x72, 0x69, 0x52, 0x65, + 0x66, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x55, 0x52, 0x49, 0x20, 0x61, + 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x52, 0x46, 0x43, + 0x0a, 0x20, 0x33, 0x39, 0x38, 0x36, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, + 0x65, 0x20, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x6f, 0x72, 0x20, 0x61, 0x62, + 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x14, + 0x05, 0x12, 0x04, 0xd2, 0x04, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x14, 0x01, + 0x12, 0x04, 0xd2, 0x04, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x14, 0x03, 0x12, + 0x04, 0xd2, 0x04, 0x18, 0x1a, 0x0a, 0xcf, 0x01, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x15, 0x12, 0x04, + 0xd7, 0x04, 0x08, 0x1b, 0x1a, 0xc0, 0x01, 0x20, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, + 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, + 0x68, 0x6f, 0x73, 0x74, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x61, 0x73, 0x0a, 0x20, 0x64, 0x65, 0x66, + 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x52, 0x46, 0x43, 0x20, 0x31, 0x30, 0x33, 0x34, + 0x20, 0x28, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x20, 0x6e, 0x6f, 0x74, + 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, + 0x6e, 0x0a, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x20, 0x6f, 0x72, 0x20, 0x49, 0x44, 0x4e, 0x73, + 0x29, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x69, 0x74, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, + 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x49, 0x50, 0x20, 0x28, 0x76, 0x34, 0x20, 0x6f, + 0x72, 0x20, 0x76, 0x36, 0x29, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x15, 0x05, + 0x12, 0x04, 0xd7, 0x04, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x15, 0x01, 0x12, + 0x04, 0xd7, 0x04, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x15, 0x03, 0x12, 0x04, + 0xd7, 0x04, 0x18, 0x1a, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x16, 0x12, 0x04, 0xdb, 0x04, + 0x08, 0x1b, 0x1a, 0x4c, 0x20, 0x55, 0x75, 0x69, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x20, 0x55, 0x55, 0x49, 0x44, 0x20, 0x61, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, + 0x65, 0x64, 0x20, 0x62, 0x79, 0x0a, 0x20, 0x52, 0x46, 0x43, 0x20, 0x34, 0x31, 0x32, 0x32, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x16, 0x05, 0x12, 0x04, 0xdb, 0x04, 0x08, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x16, 0x01, 0x12, 0x04, 0xdb, 0x04, 0x0d, 0x11, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x16, 0x03, 0x12, 0x04, 0xdb, 0x04, 0x18, 0x1a, 0x0a, 0x58, 0x0a, + 0x04, 0x04, 0x0e, 0x02, 0x17, 0x12, 0x04, 0xde, 0x04, 0x08, 0x29, 0x1a, 0x4a, 0x20, 0x57, 0x65, + 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x67, 0x65, 0x78, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, + 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, + 0x72, 0x6e, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, + 0x72, 0x65, 0x67, 0x65, 0x78, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x17, 0x06, + 0x12, 0x04, 0xde, 0x04, 0x08, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x17, 0x01, 0x12, + 0x04, 0xde, 0x04, 0x13, 0x23, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x17, 0x03, 0x12, 0x04, + 0xde, 0x04, 0x26, 0x28, 0x0a, 0xcc, 0x02, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x18, 0x12, 0x04, 0xe6, + 0x04, 0x02, 0x2d, 0x1a, 0xbd, 0x02, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x67, 0x65, 0x78, 0x65, 0x73, 0x20, 0x48, + 0x54, 0x54, 0x50, 0x5f, 0x48, 0x45, 0x41, 0x44, 0x45, 0x52, 0x5f, 0x4e, 0x41, 0x4d, 0x45, 0x20, + 0x61, 0x6e, 0x64, 0x20, 0x48, 0x54, 0x54, 0x50, 0x5f, 0x48, 0x45, 0x41, 0x44, 0x45, 0x52, 0x5f, + 0x56, 0x41, 0x4c, 0x55, 0x45, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x0a, + 0x20, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x20, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x42, 0x79, 0x20, 0x64, + 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, + 0x74, 0x72, 0x75, 0x65, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x48, 0x54, 0x54, 0x50, 0x20, 0x68, + 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x52, 0x46, 0x43, 0x2d, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x69, + 0x61, 0x6e, 0x74, 0x2e, 0x0a, 0x20, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, + 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x65, 0x6e, 0x61, 0x62, + 0x6c, 0x65, 0x20, 0x61, 0x20, 0x6c, 0x6f, 0x6f, 0x73, 0x65, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x6f, 0x6e, 0x6c, + 0x79, 0x20, 0x64, 0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x0a, 0x20, 0x5c, 0x72, 0x5c, + 0x6e, 0x5c, 0x30, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x73, 0x2c, 0x20, + 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x79, 0x70, 0x61, 0x73, 0x73, 0x20, 0x68, 0x65, 0x61, 0x64, + 0x65, 0x72, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x75, 0x6c, 0x65, + 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x18, 0x04, 0x12, 0x04, 0xe6, 0x04, + 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x18, 0x05, 0x12, 0x04, 0xe6, 0x04, 0x0b, + 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x18, 0x01, 0x12, 0x04, 0xe6, 0x04, 0x10, 0x16, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x18, 0x03, 0x12, 0x04, 0xe6, 0x04, 0x19, 0x1b, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x18, 0x07, 0x12, 0x04, 0xe6, 0x04, 0x1d, 0x2b, 0x0a, 0x81, + 0x01, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x19, 0x12, 0x04, 0xea, 0x04, 0x02, 0x22, 0x1a, 0x73, 0x20, + 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, + 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, + 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x19, 0x04, 0x12, 0x04, 0xea, 0x04, 0x02, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x19, 0x05, 0x12, 0x04, 0xea, 0x04, 0x0b, 0x0f, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x19, 0x01, 0x12, 0x04, 0xea, 0x04, 0x10, 0x1c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x19, 0x03, 0x12, 0x04, 0xea, 0x04, 0x1f, 0x21, 0x0a, 0x40, + 0x0a, 0x02, 0x05, 0x00, 0x12, 0x06, 0xee, 0x04, 0x00, 0xf6, 0x04, 0x01, 0x1a, 0x32, 0x20, 0x57, + 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x67, 0x65, 0x78, 0x20, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x77, 0x65, 0x6c, 0x6c, 0x2d, + 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x73, 0x2e, 0x0a, + 0x0a, 0x0b, 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, 0x04, 0xee, 0x04, 0x05, 0x0f, 0x0a, 0x0c, 0x0a, + 0x04, 0x05, 0x00, 0x02, 0x00, 0x12, 0x04, 0xef, 0x04, 0x02, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, 0xef, 0x04, 0x02, 0x09, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x00, + 0x02, 0x00, 0x02, 0x12, 0x04, 0xef, 0x04, 0x0c, 0x0d, 0x0a, 0x38, 0x0a, 0x04, 0x05, 0x00, 0x02, + 0x01, 0x12, 0x04, 0xf2, 0x04, 0x02, 0x17, 0x1a, 0x2a, 0x20, 0x48, 0x54, 0x54, 0x50, 0x20, 0x68, + 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x61, 0x73, 0x20, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x52, 0x46, 0x43, 0x20, 0x37, 0x32, 0x33, + 0x30, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x04, 0xf2, 0x04, + 0x02, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x02, 0x12, 0x04, 0xf2, 0x04, 0x15, + 0x16, 0x0a, 0x39, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x02, 0x12, 0x04, 0xf5, 0x04, 0x02, 0x18, 0x1a, + 0x2b, 0x20, 0x48, 0x54, 0x54, 0x50, 0x20, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x20, 0x61, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, + 0x79, 0x20, 0x52, 0x46, 0x43, 0x20, 0x37, 0x32, 0x33, 0x30, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x05, 0x00, 0x02, 0x02, 0x01, 0x12, 0x04, 0xf5, 0x04, 0x02, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x02, 0x02, 0x12, 0x04, 0xf5, 0x04, 0x16, 0x17, 0x0a, 0x4d, 0x0a, 0x02, 0x04, 0x0f, + 0x12, 0x06, 0xf9, 0x04, 0x00, 0xb4, 0x05, 0x01, 0x1a, 0x3f, 0x20, 0x42, 0x79, 0x74, 0x65, 0x73, + 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, + 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x62, 0x79, 0x74, 0x65, 0x73, + 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0f, 0x01, + 0x12, 0x04, 0xf9, 0x04, 0x08, 0x12, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x00, 0x12, 0x04, + 0xfb, 0x04, 0x04, 0x1d, 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, + 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0f, 0x02, 0x00, 0x04, 0x12, 0x04, 0xfb, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, + 0x02, 0x00, 0x05, 0x12, 0x04, 0xfb, 0x04, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, + 0x00, 0x01, 0x12, 0x04, 0xfb, 0x04, 0x13, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, + 0x03, 0x12, 0x04, 0xfb, 0x04, 0x1b, 0x1c, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x01, 0x12, + 0x04, 0xfe, 0x04, 0x04, 0x1d, 0x1a, 0x45, 0x20, 0x4c, 0x65, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, + 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0f, 0x02, 0x01, 0x04, 0x12, 0x04, 0xfe, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0f, 0x02, 0x01, 0x05, 0x12, 0x04, 0xfe, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, + 0x02, 0x01, 0x01, 0x12, 0x04, 0xfe, 0x04, 0x14, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, + 0x01, 0x03, 0x12, 0x04, 0xfe, 0x04, 0x1a, 0x1c, 0x0a, 0x64, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x02, + 0x12, 0x04, 0x82, 0x05, 0x04, 0x20, 0x1a, 0x56, 0x20, 0x4d, 0x69, 0x6e, 0x4c, 0x65, 0x6e, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, + 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x02, 0x04, 0x12, 0x04, 0x82, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0f, 0x02, 0x02, 0x05, 0x12, 0x04, 0x82, 0x05, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0f, 0x02, 0x02, 0x01, 0x12, 0x04, 0x82, 0x05, 0x14, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0f, 0x02, 0x02, 0x03, 0x12, 0x04, 0x82, 0x05, 0x1e, 0x1f, 0x0a, 0x64, 0x0a, 0x04, 0x04, 0x0f, + 0x02, 0x03, 0x12, 0x04, 0x86, 0x05, 0x04, 0x20, 0x1a, 0x56, 0x20, 0x4d, 0x61, 0x78, 0x4c, 0x65, + 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, + 0x73, 0x0a, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x03, 0x04, 0x12, 0x04, 0x86, 0x05, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x03, 0x05, 0x12, 0x04, 0x86, 0x05, 0x0d, 0x13, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x03, 0x01, 0x12, 0x04, 0x86, 0x05, 0x14, 0x1b, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0f, 0x02, 0x03, 0x03, 0x12, 0x04, 0x86, 0x05, 0x1e, 0x1f, 0x0a, 0xab, 0x01, 0x0a, + 0x04, 0x04, 0x0f, 0x02, 0x04, 0x12, 0x04, 0x8b, 0x05, 0x04, 0x21, 0x1a, 0x9c, 0x01, 0x20, 0x50, + 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x20, 0x61, 0x67, 0x61, 0x69, + 0x6e, 0x73, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x64, 0x0a, 0x20, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, + 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x52, 0x45, 0x32, 0x20, 0x73, 0x79, 0x6e, 0x74, 0x61, + 0x78, 0x29, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, + 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x20, 0x65, 0x6c, 0x69, 0x64, 0x65, 0x0a, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x64, 0x65, + 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, + 0x02, 0x04, 0x04, 0x12, 0x04, 0x8b, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, + 0x04, 0x05, 0x12, 0x04, 0x8b, 0x05, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x04, + 0x01, 0x12, 0x04, 0x8b, 0x05, 0x14, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x04, 0x03, + 0x12, 0x04, 0x8b, 0x05, 0x1f, 0x20, 0x0a, 0x6f, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x05, 0x12, 0x04, + 0x8f, 0x05, 0x04, 0x21, 0x1a, 0x61, 0x20, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x68, 0x61, 0x76, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x62, 0x65, + 0x67, 0x69, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x05, 0x04, + 0x12, 0x04, 0x8f, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x05, 0x05, 0x12, + 0x04, 0x8f, 0x05, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x05, 0x01, 0x12, 0x04, + 0x8f, 0x05, 0x14, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x05, 0x03, 0x12, 0x04, 0x8f, + 0x05, 0x1f, 0x20, 0x0a, 0x69, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x06, 0x12, 0x04, 0x93, 0x05, 0x04, + 0x21, 0x1a, 0x5b, 0x20, 0x53, 0x75, 0x66, 0x66, 0x69, 0x78, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, + 0x65, 0x73, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x65, 0x6e, 0x64, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x06, 0x04, 0x12, 0x04, 0x93, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0f, 0x02, 0x06, 0x05, 0x12, 0x04, 0x93, 0x05, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0f, 0x02, 0x06, 0x01, 0x12, 0x04, 0x93, 0x05, 0x14, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0f, 0x02, 0x06, 0x03, 0x12, 0x04, 0x93, 0x05, 0x1f, 0x20, 0x0a, 0x69, 0x0a, 0x04, 0x04, 0x0f, + 0x02, 0x07, 0x12, 0x04, 0x97, 0x05, 0x04, 0x21, 0x1a, 0x5b, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, 0x20, 0x61, 0x6e, 0x79, + 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x07, 0x04, 0x12, 0x04, + 0x97, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x07, 0x05, 0x12, 0x04, 0x97, + 0x05, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x07, 0x01, 0x12, 0x04, 0x97, 0x05, + 0x14, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x07, 0x03, 0x12, 0x04, 0x97, 0x05, 0x1f, + 0x20, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x08, 0x12, 0x04, 0x9b, 0x05, 0x04, 0x1e, 0x1a, + 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, + 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, + 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0f, 0x02, 0x08, 0x04, 0x12, 0x04, 0x9b, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0f, 0x02, 0x08, 0x05, 0x12, 0x04, 0x9b, 0x05, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0f, 0x02, 0x08, 0x01, 0x12, 0x04, 0x9b, 0x05, 0x13, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, + 0x02, 0x08, 0x03, 0x12, 0x04, 0x9b, 0x05, 0x1c, 0x1d, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x0f, 0x02, + 0x09, 0x12, 0x04, 0x9f, 0x05, 0x04, 0x1e, 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, + 0x02, 0x09, 0x04, 0x12, 0x04, 0x9f, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, + 0x09, 0x05, 0x12, 0x04, 0x9f, 0x05, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x09, + 0x01, 0x12, 0x04, 0x9f, 0x05, 0x13, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x09, 0x03, + 0x12, 0x04, 0x9f, 0x05, 0x1c, 0x1d, 0x0a, 0x5c, 0x0a, 0x04, 0x04, 0x0f, 0x08, 0x00, 0x12, 0x06, + 0xa3, 0x05, 0x04, 0xaf, 0x05, 0x05, 0x1a, 0x4c, 0x20, 0x57, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, + 0x77, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x20, 0x61, 0x64, 0x76, 0x61, 0x6e, 0x63, 0x65, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, + 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x67, 0x61, 0x69, 0x6e, 0x73, 0x74, 0x20, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x62, 0x79, 0x74, 0x65, 0x0a, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, + 0x72, 0x6e, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x08, 0x00, 0x01, 0x12, 0x04, 0xa3, + 0x05, 0x0a, 0x14, 0x0a, 0x61, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x0a, 0x12, 0x04, 0xa6, 0x05, 0x08, + 0x17, 0x1a, 0x53, 0x20, 0x49, 0x70, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, + 0x49, 0x50, 0x20, 0x28, 0x76, 0x34, 0x20, 0x6f, 0x72, 0x20, 0x76, 0x36, 0x29, 0x20, 0x61, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x69, 0x6e, 0x0a, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x66, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0a, 0x05, 0x12, + 0x04, 0xa6, 0x05, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0a, 0x01, 0x12, 0x04, + 0xa6, 0x05, 0x0d, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0a, 0x03, 0x12, 0x04, 0xa6, + 0x05, 0x14, 0x16, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x0b, 0x12, 0x04, 0xaa, 0x05, 0x08, + 0x17, 0x1a, 0x4c, 0x20, 0x49, 0x70, 0x76, 0x34, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x20, 0x49, 0x50, 0x76, 0x34, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x69, + 0x6e, 0x20, 0x62, 0x79, 0x74, 0x65, 0x0a, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0b, 0x05, 0x12, 0x04, 0xaa, 0x05, 0x08, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0b, 0x01, 0x12, 0x04, 0xaa, 0x05, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0f, 0x02, 0x0b, 0x03, 0x12, 0x04, 0xaa, 0x05, 0x14, 0x16, 0x0a, 0x5a, 0x0a, 0x04, + 0x04, 0x0f, 0x02, 0x0c, 0x12, 0x04, 0xae, 0x05, 0x08, 0x17, 0x1a, 0x4c, 0x20, 0x49, 0x70, 0x76, + 0x36, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x49, 0x50, 0x76, 0x36, 0x20, + 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x62, 0x79, 0x74, 0x65, 0x0a, + 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0c, + 0x05, 0x12, 0x04, 0xae, 0x05, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0c, 0x01, + 0x12, 0x04, 0xae, 0x05, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0c, 0x03, 0x12, + 0x04, 0xae, 0x05, 0x14, 0x16, 0x0a, 0x81, 0x01, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x0d, 0x12, 0x04, + 0xb3, 0x05, 0x04, 0x24, 0x1a, 0x73, 0x20, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, + 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, + 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, + 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, + 0x0d, 0x04, 0x12, 0x04, 0xb3, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0d, + 0x05, 0x12, 0x04, 0xb3, 0x05, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0d, 0x01, + 0x12, 0x04, 0xb3, 0x05, 0x12, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0d, 0x03, 0x12, + 0x04, 0xb3, 0x05, 0x21, 0x23, 0x0a, 0x49, 0x0a, 0x02, 0x04, 0x10, 0x12, 0x06, 0xb7, 0x05, 0x00, + 0xc6, 0x05, 0x01, 0x1a, 0x3b, 0x20, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x20, 0x65, 0x6e, 0x75, 0x6d, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, + 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x10, 0x01, 0x12, 0x04, 0xb7, 0x05, 0x08, 0x11, 0x0a, 0x53, 0x0a, + 0x04, 0x04, 0x10, 0x02, 0x00, 0x12, 0x04, 0xb9, 0x05, 0x04, 0x24, 0x1a, 0x45, 0x20, 0x43, 0x6f, + 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, 0x04, 0x12, 0x04, 0xb9, 0x05, 0x04, + 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, 0x05, 0x12, 0x04, 0xb9, 0x05, 0x0d, 0x12, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, 0x01, 0x12, 0x04, 0xb9, 0x05, 0x13, 0x18, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, 0x03, 0x12, 0x04, 0xb9, 0x05, 0x22, 0x23, 0x0a, 0x8c, + 0x01, 0x0a, 0x04, 0x04, 0x10, 0x02, 0x01, 0x12, 0x04, 0xbd, 0x05, 0x04, 0x24, 0x1a, 0x7e, 0x20, + 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x4f, 0x6e, 0x6c, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6f, 0x6e, + 0x6c, 0x79, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x65, 0x6e, 0x75, 0x6d, 0x2c, 0x20, 0x66, 0x61, 0x69, + 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x75, 0x6e, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x10, 0x02, 0x01, 0x04, 0x12, 0x04, 0xbd, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x10, 0x02, 0x01, 0x05, 0x12, 0x04, 0xbd, 0x05, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x10, 0x02, 0x01, 0x01, 0x12, 0x04, 0xbd, 0x05, 0x13, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, + 0x02, 0x01, 0x03, 0x12, 0x04, 0xbd, 0x05, 0x22, 0x23, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x10, 0x02, + 0x02, 0x12, 0x04, 0xc1, 0x05, 0x04, 0x24, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, + 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x02, 0x04, 0x12, 0x04, + 0xc1, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x02, 0x05, 0x12, 0x04, 0xc1, + 0x05, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x02, 0x01, 0x12, 0x04, 0xc1, 0x05, + 0x13, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x02, 0x03, 0x12, 0x04, 0xc1, 0x05, 0x22, + 0x23, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x10, 0x02, 0x03, 0x12, 0x04, 0xc5, 0x05, 0x04, 0x24, 0x1a, + 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, + 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x03, 0x04, 0x12, 0x04, 0xc5, 0x05, 0x04, + 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x03, 0x05, 0x12, 0x04, 0xc5, 0x05, 0x0d, 0x12, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x03, 0x01, 0x12, 0x04, 0xc5, 0x05, 0x13, 0x19, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x03, 0x03, 0x12, 0x04, 0xc5, 0x05, 0x22, 0x23, 0x0a, 0x99, + 0x01, 0x0a, 0x02, 0x04, 0x11, 0x12, 0x06, 0xca, 0x05, 0x00, 0xd1, 0x05, 0x01, 0x1a, 0x8a, 0x01, + 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, + 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, + 0x6f, 0x20, 0x65, 0x6d, 0x62, 0x65, 0x64, 0x64, 0x65, 0x64, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x46, 0x6f, 0x72, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x73, 0x2c, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x69, 0x73, 0x20, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x64, 0x20, 0x72, 0x65, 0x63, + 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x11, + 0x01, 0x12, 0x04, 0xca, 0x05, 0x08, 0x14, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x11, 0x02, 0x00, 0x12, + 0x04, 0xcd, 0x05, 0x04, 0x1f, 0x1a, 0x51, 0x20, 0x53, 0x6b, 0x69, 0x70, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, + 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, + 0x04, 0x12, 0x04, 0xcd, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, 0x05, + 0x12, 0x04, 0xcd, 0x05, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, 0x01, 0x12, + 0x04, 0xcd, 0x05, 0x12, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, 0x03, 0x12, 0x04, + 0xcd, 0x05, 0x1d, 0x1e, 0x0a, 0x3e, 0x0a, 0x04, 0x04, 0x11, 0x02, 0x01, 0x12, 0x04, 0xd0, 0x05, + 0x04, 0x1f, 0x1a, 0x30, 0x20, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x73, 0x65, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x01, 0x04, 0x12, 0x04, 0xd0, + 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x01, 0x05, 0x12, 0x04, 0xd0, 0x05, + 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x01, 0x01, 0x12, 0x04, 0xd0, 0x05, 0x12, + 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x01, 0x03, 0x12, 0x04, 0xd0, 0x05, 0x1d, 0x1e, + 0x0a, 0x53, 0x0a, 0x02, 0x04, 0x12, 0x12, 0x06, 0xd4, 0x05, 0x00, 0xea, 0x05, 0x01, 0x1a, 0x45, + 0x20, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, + 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x20, 0x60, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x60, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x12, 0x01, 0x12, 0x04, 0xd4, 0x05, + 0x08, 0x15, 0x0a, 0x68, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x00, 0x12, 0x04, 0xd7, 0x05, 0x04, 0x22, + 0x1a, 0x5a, 0x20, 0x4d, 0x69, 0x6e, 0x49, 0x74, 0x65, 0x6d, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x6e, 0x75, + 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x20, 0x61, + 0x74, 0x20, 0x61, 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x12, 0x02, 0x00, 0x04, 0x12, 0x04, 0xd7, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x12, 0x02, 0x00, 0x05, 0x12, 0x04, 0xd7, 0x05, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, + 0x02, 0x00, 0x01, 0x12, 0x04, 0xd7, 0x05, 0x14, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, + 0x00, 0x03, 0x12, 0x04, 0xd7, 0x05, 0x20, 0x21, 0x0a, 0x68, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x01, + 0x12, 0x04, 0xdb, 0x05, 0x04, 0x22, 0x1a, 0x5a, 0x20, 0x4d, 0x61, 0x78, 0x49, 0x74, 0x65, 0x6d, + 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x69, + 0x74, 0x65, 0x6d, 0x73, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, + 0x6d, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x01, 0x04, 0x12, 0x04, 0xdb, 0x05, 0x04, + 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x01, 0x05, 0x12, 0x04, 0xdb, 0x05, 0x0d, 0x13, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x01, 0x01, 0x12, 0x04, 0xdb, 0x05, 0x14, 0x1d, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x01, 0x03, 0x12, 0x04, 0xdb, 0x05, 0x20, 0x21, 0x0a, 0xad, + 0x01, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x02, 0x12, 0x04, 0xe0, 0x05, 0x04, 0x22, 0x1a, 0x9e, 0x01, + 0x20, 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65, + 0x6e, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, + 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x0a, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, + 0x6e, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x63, 0x61, 0x6c, 0x61, 0x72, 0x20, + 0x61, 0x6e, 0x64, 0x20, 0x65, 0x6e, 0x75, 0x6d, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x28, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6e, 0x6f, 0x74, + 0x0a, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x29, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x12, 0x02, 0x02, 0x04, 0x12, 0x04, 0xe0, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x12, 0x02, 0x02, 0x05, 0x12, 0x04, 0xe0, 0x05, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x12, 0x02, 0x02, 0x01, 0x12, 0x04, 0xe0, 0x05, 0x14, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x12, 0x02, 0x02, 0x03, 0x12, 0x04, 0xe0, 0x05, 0x20, 0x21, 0x0a, 0xc2, 0x01, 0x0a, 0x04, 0x04, + 0x12, 0x02, 0x03, 0x12, 0x04, 0xe5, 0x05, 0x04, 0x22, 0x1a, 0xb3, 0x01, 0x20, 0x49, 0x74, 0x65, + 0x6d, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x20, + 0x62, 0x65, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x61, + 0x63, 0x68, 0x20, 0x69, 0x74, 0x65, 0x6d, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x2e, 0x0a, 0x20, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, 0x77, + 0x69, 0x6c, 0x6c, 0x20, 0x73, 0x74, 0x69, 0x6c, 0x6c, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x67, 0x61, + 0x69, 0x6e, 0x73, 0x74, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x69, 0x74, 0x65, 0x6d, 0x0a, 0x20, + 0x75, 0x6e, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x73, 0x6b, 0x69, 0x70, 0x20, 0x69, 0x73, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x68, 0x65, 0x72, 0x65, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x03, 0x04, 0x12, 0x04, 0xe5, 0x05, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x12, 0x02, 0x03, 0x06, 0x12, 0x04, 0xe5, 0x05, 0x0d, 0x17, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x12, 0x02, 0x03, 0x01, 0x12, 0x04, 0xe5, 0x05, 0x18, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x12, 0x02, 0x03, 0x03, 0x12, 0x04, 0xe5, 0x05, 0x20, 0x21, 0x0a, 0x81, 0x01, 0x0a, 0x04, + 0x04, 0x12, 0x02, 0x04, 0x12, 0x04, 0xe9, 0x05, 0x04, 0x23, 0x1a, 0x73, 0x20, 0x49, 0x67, 0x6e, + 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x20, + 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x04, 0x04, 0x12, 0x04, 0xe9, 0x05, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x12, 0x02, 0x04, 0x05, 0x12, 0x04, 0xe9, 0x05, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x12, 0x02, 0x04, 0x01, 0x12, 0x04, 0xe9, 0x05, 0x12, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x12, 0x02, 0x04, 0x03, 0x12, 0x04, 0xe9, 0x05, 0x21, 0x22, 0x0a, 0x49, 0x0a, 0x02, 0x04, + 0x13, 0x12, 0x06, 0xed, 0x05, 0x00, 0x85, 0x06, 0x01, 0x1a, 0x3b, 0x20, 0x4d, 0x61, 0x70, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, + 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x6d, 0x61, 0x70, 0x60, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x13, 0x01, 0x12, 0x04, 0xed, + 0x05, 0x08, 0x10, 0x0a, 0x66, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x00, 0x12, 0x04, 0xf0, 0x05, 0x04, + 0x22, 0x1a, 0x58, 0x20, 0x4d, 0x69, 0x6e, 0x50, 0x61, 0x69, 0x72, 0x73, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x6e, + 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x4b, 0x56, 0x73, 0x20, 0x61, 0x74, + 0x20, 0x61, 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x13, 0x02, 0x00, 0x04, 0x12, 0x04, 0xf0, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, + 0x02, 0x00, 0x05, 0x12, 0x04, 0xf0, 0x05, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, + 0x00, 0x01, 0x12, 0x04, 0xf0, 0x05, 0x14, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x00, + 0x03, 0x12, 0x04, 0xf0, 0x05, 0x20, 0x21, 0x0a, 0x66, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x01, 0x12, + 0x04, 0xf4, 0x05, 0x04, 0x22, 0x1a, 0x58, 0x20, 0x4d, 0x61, 0x78, 0x50, 0x61, 0x69, 0x72, 0x73, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, + 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x4b, 0x56, + 0x73, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x01, 0x04, 0x12, 0x04, 0xf4, 0x05, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x13, 0x02, 0x01, 0x05, 0x12, 0x04, 0xf4, 0x05, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x13, 0x02, 0x01, 0x01, 0x12, 0x04, 0xf4, 0x05, 0x14, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x13, 0x02, 0x01, 0x03, 0x12, 0x04, 0xf4, 0x05, 0x20, 0x21, 0x0a, 0x7e, 0x0a, 0x04, 0x04, + 0x13, 0x02, 0x02, 0x12, 0x04, 0xf8, 0x05, 0x04, 0x20, 0x1a, 0x70, 0x20, 0x4e, 0x6f, 0x53, 0x70, + 0x61, 0x72, 0x73, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x75, 0x6e, + 0x73, 0x65, 0x74, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x0a, 0x20, + 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x61, 0x70, 0x27, 0x73, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x13, 0x02, 0x02, 0x04, 0x12, 0x04, 0xf8, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, + 0x02, 0x02, 0x05, 0x12, 0x04, 0xf8, 0x05, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, + 0x02, 0x01, 0x12, 0x04, 0xf8, 0x05, 0x12, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x02, + 0x03, 0x12, 0x04, 0xf8, 0x05, 0x1e, 0x1f, 0x0a, 0x56, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x03, 0x12, + 0x04, 0xfb, 0x05, 0x04, 0x23, 0x1a, 0x48, 0x20, 0x4b, 0x65, 0x79, 0x73, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, + 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x61, 0x70, 0x70, + 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x6b, 0x65, 0x79, + 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x03, 0x04, 0x12, 0x04, 0xfb, 0x05, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x13, 0x02, 0x03, 0x06, 0x12, 0x04, 0xfb, 0x05, 0x0d, 0x17, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x13, 0x02, 0x03, 0x01, 0x12, 0x04, 0xfb, 0x05, 0x18, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x13, 0x02, 0x03, 0x03, 0x12, 0x04, 0xfb, 0x05, 0x21, 0x22, 0x0a, 0xc2, 0x01, 0x0a, 0x04, + 0x04, 0x13, 0x02, 0x04, 0x12, 0x04, 0x80, 0x06, 0x04, 0x23, 0x1a, 0xb3, 0x01, 0x20, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x74, + 0x6f, 0x20, 0x62, 0x65, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x65, 0x61, 0x63, + 0x68, 0x20, 0x6b, 0x65, 0x79, 0x0a, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x2e, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x73, 0x74, 0x69, 0x6c, 0x6c, 0x20, 0x68, + 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x69, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x0a, + 0x20, 0x75, 0x6e, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x73, 0x6b, 0x69, 0x70, 0x20, 0x69, 0x73, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x68, 0x65, 0x72, 0x65, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x04, 0x04, 0x12, 0x04, 0x80, 0x06, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x04, 0x06, 0x12, 0x04, 0x80, 0x06, 0x0d, 0x17, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x13, 0x02, 0x04, 0x01, 0x12, 0x04, 0x80, 0x06, 0x18, 0x1e, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x13, 0x02, 0x04, 0x03, 0x12, 0x04, 0x80, 0x06, 0x21, 0x22, 0x0a, 0x81, 0x01, 0x0a, + 0x04, 0x04, 0x13, 0x02, 0x05, 0x12, 0x04, 0x84, 0x06, 0x04, 0x23, 0x1a, 0x73, 0x20, 0x49, 0x67, + 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x05, 0x04, 0x12, 0x04, 0x84, 0x06, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x05, 0x05, 0x12, 0x04, 0x84, 0x06, 0x0d, 0x11, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x13, 0x02, 0x05, 0x01, 0x12, 0x04, 0x84, 0x06, 0x12, 0x1e, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x13, 0x02, 0x05, 0x03, 0x12, 0x04, 0x84, 0x06, 0x21, 0x22, 0x0a, 0x6f, 0x0a, 0x02, + 0x04, 0x14, 0x12, 0x06, 0x89, 0x06, 0x00, 0x94, 0x06, 0x01, 0x1a, 0x61, 0x20, 0x41, 0x6e, 0x79, + 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x63, + 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, + 0x65, 0x64, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x20, 0x74, + 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x60, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x60, 0x20, 0x77, 0x65, 0x6c, + 0x6c, 0x2d, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x0a, 0x0a, 0x0b, 0x0a, + 0x03, 0x04, 0x14, 0x01, 0x12, 0x04, 0x89, 0x06, 0x08, 0x10, 0x0a, 0x3e, 0x0a, 0x04, 0x04, 0x14, + 0x02, 0x00, 0x12, 0x04, 0x8b, 0x06, 0x04, 0x1f, 0x1a, 0x30, 0x20, 0x52, 0x65, 0x71, 0x75, 0x69, + 0x72, 0x65, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, + 0x02, 0x00, 0x04, 0x12, 0x04, 0x8b, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, + 0x00, 0x05, 0x12, 0x04, 0x8b, 0x06, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x00, + 0x01, 0x12, 0x04, 0x8b, 0x06, 0x12, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x00, 0x03, + 0x12, 0x04, 0x8b, 0x06, 0x1d, 0x1e, 0x0a, 0x68, 0x0a, 0x04, 0x04, 0x14, 0x02, 0x01, 0x12, 0x04, + 0x8f, 0x06, 0x04, 0x1f, 0x1a, 0x5a, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x27, 0x73, 0x20, 0x60, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x60, + 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, + 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x01, 0x04, 0x12, 0x04, 0x8f, 0x06, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x01, 0x05, 0x12, 0x04, 0x8f, 0x06, 0x0d, 0x13, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x14, 0x02, 0x01, 0x01, 0x12, 0x04, 0x8f, 0x06, 0x14, 0x16, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x14, 0x02, 0x01, 0x03, 0x12, 0x04, 0x8f, 0x06, 0x1d, 0x1e, 0x0a, 0x6f, 0x0a, 0x04, + 0x04, 0x14, 0x02, 0x02, 0x12, 0x04, 0x93, 0x06, 0x04, 0x1f, 0x1a, 0x61, 0x20, 0x4e, 0x6f, 0x74, + 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x27, 0x73, 0x20, 0x60, + 0x74, 0x79, 0x70, 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x60, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x6e, + 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x61, + 0x6e, 0x79, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x14, 0x02, 0x02, 0x04, 0x12, 0x04, 0x93, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x14, 0x02, 0x02, 0x05, 0x12, 0x04, 0x93, 0x06, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x14, 0x02, 0x02, 0x01, 0x12, 0x04, 0x93, 0x06, 0x14, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, + 0x02, 0x02, 0x03, 0x12, 0x04, 0x93, 0x06, 0x1d, 0x1e, 0x0a, 0x7d, 0x0a, 0x02, 0x04, 0x15, 0x12, + 0x06, 0x98, 0x06, 0x00, 0xb6, 0x06, 0x01, 0x1a, 0x6f, 0x20, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, + 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, + 0x76, 0x65, 0x6c, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x60, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x60, 0x20, 0x77, 0x65, 0x6c, 0x6c, 0x2d, 0x6b, 0x6e, 0x6f, + 0x77, 0x6e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x15, 0x01, 0x12, + 0x04, 0x98, 0x06, 0x08, 0x15, 0x0a, 0x3e, 0x0a, 0x04, 0x04, 0x15, 0x02, 0x00, 0x12, 0x04, 0x9a, + 0x06, 0x04, 0x1f, 0x1a, 0x30, 0x20, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, + 0x20, 0x73, 0x65, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x00, 0x04, 0x12, 0x04, + 0x9a, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x00, 0x05, 0x12, 0x04, 0x9a, + 0x06, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x00, 0x01, 0x12, 0x04, 0x9a, 0x06, + 0x12, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x00, 0x03, 0x12, 0x04, 0x9a, 0x06, 0x1d, + 0x1e, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x15, 0x02, 0x01, 0x12, 0x04, 0x9d, 0x06, 0x04, 0x30, 0x1a, + 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, + 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x01, 0x04, 0x12, + 0x04, 0x9d, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x01, 0x06, 0x12, 0x04, + 0x9d, 0x06, 0x0d, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x01, 0x01, 0x12, 0x04, 0x9d, + 0x06, 0x26, 0x2b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x01, 0x03, 0x12, 0x04, 0x9d, 0x06, + 0x2e, 0x2f, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x15, 0x02, 0x02, 0x12, 0x04, 0xa1, 0x06, 0x04, 0x2d, + 0x1a, 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, + 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x02, 0x04, 0x12, 0x04, 0xa1, 0x06, 0x04, + 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x02, 0x06, 0x12, 0x04, 0xa1, 0x06, 0x0d, 0x25, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x02, 0x01, 0x12, 0x04, 0xa1, 0x06, 0x26, 0x28, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x02, 0x03, 0x12, 0x04, 0xa1, 0x06, 0x2b, 0x2c, 0x0a, 0x5e, + 0x0a, 0x04, 0x04, 0x15, 0x02, 0x03, 0x12, 0x04, 0xa5, 0x06, 0x04, 0x2e, 0x1a, 0x50, 0x20, 0x4c, + 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x2c, 0x0a, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x15, 0x02, 0x03, 0x04, 0x12, 0x04, 0xa5, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x15, 0x02, 0x03, 0x06, 0x12, 0x04, 0xa5, 0x06, 0x0d, 0x25, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x15, 0x02, 0x03, 0x01, 0x12, 0x04, 0xa5, 0x06, 0x26, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x15, 0x02, 0x03, 0x03, 0x12, 0x04, 0xa5, 0x06, 0x2c, 0x2d, 0x0a, 0x61, 0x0a, 0x04, 0x04, 0x15, + 0x02, 0x04, 0x12, 0x04, 0xa9, 0x06, 0x04, 0x2d, 0x1a, 0x53, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x15, 0x02, 0x04, 0x04, 0x12, 0x04, 0xa9, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x15, 0x02, 0x04, 0x06, 0x12, 0x04, 0xa9, 0x06, 0x0d, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x15, 0x02, 0x04, 0x01, 0x12, 0x04, 0xa9, 0x06, 0x26, 0x28, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, + 0x02, 0x04, 0x03, 0x12, 0x04, 0xa9, 0x06, 0x2b, 0x2c, 0x0a, 0x62, 0x0a, 0x04, 0x04, 0x15, 0x02, + 0x05, 0x12, 0x04, 0xad, 0x06, 0x04, 0x2e, 0x1a, 0x54, 0x20, 0x47, 0x74, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x2c, 0x0a, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x15, 0x02, 0x05, 0x04, 0x12, 0x04, 0xad, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x15, 0x02, 0x05, 0x06, 0x12, 0x04, 0xad, 0x06, 0x0d, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x15, 0x02, 0x05, 0x01, 0x12, 0x04, 0xad, 0x06, 0x26, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, + 0x02, 0x05, 0x03, 0x12, 0x04, 0xad, 0x06, 0x2c, 0x2d, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x15, 0x02, + 0x06, 0x12, 0x04, 0xb1, 0x06, 0x04, 0x2d, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, + 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x06, 0x04, 0x12, 0x04, + 0xb1, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x06, 0x06, 0x12, 0x04, 0xb1, + 0x06, 0x0d, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x06, 0x01, 0x12, 0x04, 0xb1, 0x06, + 0x26, 0x28, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x06, 0x03, 0x12, 0x04, 0xb1, 0x06, 0x2b, + 0x2c, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x15, 0x02, 0x07, 0x12, 0x04, 0xb5, 0x06, 0x04, 0x31, 0x1a, + 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, + 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x07, 0x04, 0x12, 0x04, 0xb5, 0x06, 0x04, + 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x07, 0x06, 0x12, 0x04, 0xb5, 0x06, 0x0d, 0x25, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x07, 0x01, 0x12, 0x04, 0xb5, 0x06, 0x26, 0x2c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x07, 0x03, 0x12, 0x04, 0xb5, 0x06, 0x2f, 0x30, 0x0a, 0x7f, + 0x0a, 0x02, 0x04, 0x16, 0x12, 0x06, 0xba, 0x06, 0x00, 0xdd, 0x06, 0x01, 0x1a, 0x71, 0x20, 0x54, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, + 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x65, + 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, + 0x65, 0x0a, 0x20, 0x60, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x60, 0x20, 0x77, + 0x65, 0x6c, 0x6c, 0x2d, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x0a, 0x0a, + 0x0b, 0x0a, 0x03, 0x04, 0x16, 0x01, 0x12, 0x04, 0xba, 0x06, 0x08, 0x16, 0x0a, 0x3e, 0x0a, 0x04, + 0x04, 0x16, 0x02, 0x00, 0x12, 0x04, 0xbc, 0x06, 0x04, 0x1f, 0x1a, 0x30, 0x20, 0x52, 0x65, 0x71, + 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x16, 0x02, 0x00, 0x04, 0x12, 0x04, 0xbc, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x16, 0x02, 0x00, 0x05, 0x12, 0x04, 0xbc, 0x06, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, + 0x02, 0x00, 0x01, 0x12, 0x04, 0xbc, 0x06, 0x12, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, + 0x00, 0x03, 0x12, 0x04, 0xbc, 0x06, 0x1d, 0x1e, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x16, 0x02, 0x01, + 0x12, 0x04, 0xbf, 0x06, 0x04, 0x31, 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, + 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x16, 0x02, 0x01, 0x04, 0x12, 0x04, 0xbf, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x16, 0x02, 0x01, 0x06, 0x12, 0x04, 0xbf, 0x06, 0x0d, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x16, 0x02, 0x01, 0x01, 0x12, 0x04, 0xbf, 0x06, 0x27, 0x2c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, + 0x02, 0x01, 0x03, 0x12, 0x04, 0xbf, 0x06, 0x2f, 0x30, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x16, 0x02, + 0x02, 0x12, 0x04, 0xc3, 0x06, 0x04, 0x2e, 0x1a, 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, + 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, + 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, + 0x02, 0x04, 0x12, 0x04, 0xc3, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x02, + 0x06, 0x12, 0x04, 0xc3, 0x06, 0x0d, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x02, 0x01, + 0x12, 0x04, 0xc3, 0x06, 0x27, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x02, 0x03, 0x12, + 0x04, 0xc3, 0x06, 0x2c, 0x2d, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x16, 0x02, 0x03, 0x12, 0x04, 0xc7, + 0x06, 0x04, 0x2f, 0x1a, 0x51, 0x20, 0x4c, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x69, 0x6e, 0x63, 0x6c, + 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x03, 0x04, 0x12, + 0x04, 0xc7, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x03, 0x06, 0x12, 0x04, + 0xc7, 0x06, 0x0d, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x03, 0x01, 0x12, 0x04, 0xc7, + 0x06, 0x27, 0x2a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x03, 0x03, 0x12, 0x04, 0xc7, 0x06, + 0x2d, 0x2e, 0x0a, 0x61, 0x0a, 0x04, 0x04, 0x16, 0x02, 0x04, 0x12, 0x04, 0xcb, 0x06, 0x04, 0x2e, + 0x1a, 0x53, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, + 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x04, 0x04, 0x12, 0x04, + 0xcb, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x04, 0x06, 0x12, 0x04, 0xcb, + 0x06, 0x0d, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x04, 0x01, 0x12, 0x04, 0xcb, 0x06, + 0x27, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x04, 0x03, 0x12, 0x04, 0xcb, 0x06, 0x2c, + 0x2d, 0x0a, 0x62, 0x0a, 0x04, 0x04, 0x16, 0x02, 0x05, 0x12, 0x04, 0xcf, 0x06, 0x04, 0x2f, 0x1a, + 0x54, 0x20, 0x47, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, + 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x05, 0x04, 0x12, 0x04, + 0xcf, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x05, 0x06, 0x12, 0x04, 0xcf, + 0x06, 0x0d, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x05, 0x01, 0x12, 0x04, 0xcf, 0x06, + 0x27, 0x2a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x05, 0x03, 0x12, 0x04, 0xcf, 0x06, 0x2d, + 0x2e, 0x0a, 0x7b, 0x0a, 0x04, 0x04, 0x16, 0x02, 0x06, 0x12, 0x04, 0xd3, 0x06, 0x04, 0x1e, 0x1a, + 0x6d, 0x20, 0x4c, 0x74, 0x4e, 0x6f, 0x77, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x20, + 0x4c, 0x74, 0x4e, 0x6f, 0x77, 0x0a, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, + 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x57, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x16, 0x02, 0x06, 0x04, 0x12, 0x04, 0xd3, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x16, 0x02, 0x06, 0x05, 0x12, 0x04, 0xd3, 0x06, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x16, 0x02, 0x06, 0x01, 0x12, 0x04, 0xd3, 0x06, 0x12, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x16, 0x02, 0x06, 0x03, 0x12, 0x04, 0xd3, 0x06, 0x1c, 0x1d, 0x0a, 0x7e, 0x0a, 0x04, 0x04, 0x16, + 0x02, 0x07, 0x12, 0x04, 0xd7, 0x06, 0x04, 0x1e, 0x1a, 0x70, 0x20, 0x47, 0x74, 0x4e, 0x6f, 0x77, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x20, 0x47, 0x74, 0x4e, 0x6f, + 0x77, 0x0a, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x62, 0x65, 0x20, 0x75, + 0x73, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x57, 0x69, 0x74, + 0x68, 0x69, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, + 0x02, 0x07, 0x04, 0x12, 0x04, 0xd7, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, + 0x07, 0x05, 0x12, 0x04, 0xd7, 0x06, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x07, + 0x01, 0x12, 0x04, 0xd7, 0x06, 0x12, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x07, 0x03, + 0x12, 0x04, 0xd7, 0x06, 0x1c, 0x1d, 0x0a, 0xaa, 0x01, 0x0a, 0x04, 0x04, 0x16, 0x02, 0x08, 0x12, + 0x04, 0xdc, 0x06, 0x04, 0x31, 0x1a, 0x9b, 0x01, 0x20, 0x57, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x64, 0x75, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x20, 0x54, 0x68, 0x69, + 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x20, 0x63, 0x61, 0x6e, + 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x61, 0x6c, 0x6f, 0x6e, 0x65, 0x20, 0x6f, + 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4c, 0x74, 0x4e, 0x6f, 0x77, + 0x20, 0x61, 0x6e, 0x64, 0x0a, 0x20, 0x47, 0x74, 0x4e, 0x6f, 0x77, 0x20, 0x72, 0x75, 0x6c, 0x65, + 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x08, 0x04, 0x12, 0x04, 0xdc, 0x06, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x08, 0x06, 0x12, 0x04, 0xdc, 0x06, 0x0d, + 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x08, 0x01, 0x12, 0x04, 0xdc, 0x06, 0x26, 0x2c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x08, 0x03, 0x12, 0x04, 0xdc, 0x06, 0x2f, 0x30, +]; +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/flyteidl2/gen_utils/ts/Makefile b/flyteidl2/gen_utils/ts/Makefile new file mode 100644 index 0000000000..b6a0167bb8 --- /dev/null +++ b/flyteidl2/gen_utils/ts/Makefile @@ -0,0 +1,6 @@ +PLACEHOLDER_NPM := \"version\": \"0.0.0-develop\" + +.PHONY: update_npmversion +update_npmversion: + grep "$(PLACEHOLDER_NPM)" "package.json" + sed -i "s/$(PLACEHOLDER_NPM)/\"version\": \"${VERSION}\"/g" "package.json" diff --git a/flyteidl2/gen_utils/ts/buf/validate/validate_pb.ts b/flyteidl2/gen_utils/ts/buf/validate/validate_pb.ts new file mode 100644 index 0000000000..2f630f4e41 --- /dev/null +++ b/flyteidl2/gen_utils/ts/buf/validate/validate_pb.ts @@ -0,0 +1,4754 @@ +// Copyright 2023-2025 Buf Technologies, Inc. +// +// 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. + +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file buf/validate/validate.proto (package buf.validate, syntax proto2) +/* eslint-disable */ + +import type { GenEnum, GenExtension, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, extDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Duration, FieldDescriptorProto_Type, FieldOptions, MessageOptions, OneofOptions, Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_descriptor, file_google_protobuf_duration, file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file buf/validate/validate.proto. + */ +export const file_buf_validate_validate: GenFile = /*@__PURE__*/ + fileDesc("ChtidWYvdmFsaWRhdGUvdmFsaWRhdGUucHJvdG8SDGJ1Zi52YWxpZGF0ZSI3CgRSdWxlEgoKAmlkGAEgASgJEg8KB21lc3NhZ2UYAiABKAkSEgoKZXhwcmVzc2lvbhgDIAEoCSJuCgxNZXNzYWdlUnVsZXMSHwoDY2VsGAMgAygLMhIuYnVmLnZhbGlkYXRlLlJ1bGUSLQoFb25lb2YYBCADKAsyHi5idWYudmFsaWRhdGUuTWVzc2FnZU9uZW9mUnVsZUoECAEQAlIIZGlzYWJsZWQiNAoQTWVzc2FnZU9uZW9mUnVsZRIOCgZmaWVsZHMYASADKAkSEAoIcmVxdWlyZWQYAiABKAgiHgoKT25lb2ZSdWxlcxIQCghyZXF1aXJlZBgBIAEoCCK/CAoKRmllbGRSdWxlcxIfCgNjZWwYFyADKAsyEi5idWYudmFsaWRhdGUuUnVsZRIQCghyZXF1aXJlZBgZIAEoCBIkCgZpZ25vcmUYGyABKA4yFC5idWYudmFsaWRhdGUuSWdub3JlEikKBWZsb2F0GAEgASgLMhguYnVmLnZhbGlkYXRlLkZsb2F0UnVsZXNIABIrCgZkb3VibGUYAiABKAsyGS5idWYudmFsaWRhdGUuRG91YmxlUnVsZXNIABIpCgVpbnQzMhgDIAEoCzIYLmJ1Zi52YWxpZGF0ZS5JbnQzMlJ1bGVzSAASKQoFaW50NjQYBCABKAsyGC5idWYudmFsaWRhdGUuSW50NjRSdWxlc0gAEisKBnVpbnQzMhgFIAEoCzIZLmJ1Zi52YWxpZGF0ZS5VSW50MzJSdWxlc0gAEisKBnVpbnQ2NBgGIAEoCzIZLmJ1Zi52YWxpZGF0ZS5VSW50NjRSdWxlc0gAEisKBnNpbnQzMhgHIAEoCzIZLmJ1Zi52YWxpZGF0ZS5TSW50MzJSdWxlc0gAEisKBnNpbnQ2NBgIIAEoCzIZLmJ1Zi52YWxpZGF0ZS5TSW50NjRSdWxlc0gAEi0KB2ZpeGVkMzIYCSABKAsyGi5idWYudmFsaWRhdGUuRml4ZWQzMlJ1bGVzSAASLQoHZml4ZWQ2NBgKIAEoCzIaLmJ1Zi52YWxpZGF0ZS5GaXhlZDY0UnVsZXNIABIvCghzZml4ZWQzMhgLIAEoCzIbLmJ1Zi52YWxpZGF0ZS5TRml4ZWQzMlJ1bGVzSAASLwoIc2ZpeGVkNjQYDCABKAsyGy5idWYudmFsaWRhdGUuU0ZpeGVkNjRSdWxlc0gAEicKBGJvb2wYDSABKAsyFy5idWYudmFsaWRhdGUuQm9vbFJ1bGVzSAASKwoGc3RyaW5nGA4gASgLMhkuYnVmLnZhbGlkYXRlLlN0cmluZ1J1bGVzSAASKQoFYnl0ZXMYDyABKAsyGC5idWYudmFsaWRhdGUuQnl0ZXNSdWxlc0gAEicKBGVudW0YECABKAsyFy5idWYudmFsaWRhdGUuRW51bVJ1bGVzSAASLwoIcmVwZWF0ZWQYEiABKAsyGy5idWYudmFsaWRhdGUuUmVwZWF0ZWRSdWxlc0gAEiUKA21hcBgTIAEoCzIWLmJ1Zi52YWxpZGF0ZS5NYXBSdWxlc0gAEiUKA2FueRgUIAEoCzIWLmJ1Zi52YWxpZGF0ZS5BbnlSdWxlc0gAEi8KCGR1cmF0aW9uGBUgASgLMhsuYnVmLnZhbGlkYXRlLkR1cmF0aW9uUnVsZXNIABIxCgl0aW1lc3RhbXAYFiABKAsyHC5idWYudmFsaWRhdGUuVGltZXN0YW1wUnVsZXNIAEIGCgR0eXBlSgQIGBAZSgQIGhAbUgdza2lwcGVkUgxpZ25vcmVfZW1wdHkiVQoPUHJlZGVmaW5lZFJ1bGVzEh8KA2NlbBgBIAMoCzISLmJ1Zi52YWxpZGF0ZS5SdWxlSgQIGBAZSgQIGhAbUgdza2lwcGVkUgxpZ25vcmVfZW1wdHki2hcKCkZsb2F0UnVsZXMSgwEKBWNvbnN0GAEgASgCQnTCSHEKbwoLZmxvYXQuY29uc3QaYHRoaXMgIT0gZ2V0RmllbGQocnVsZXMsICdjb25zdCcpID8gJ3ZhbHVlIG11c3QgZXF1YWwgJXMnLmZvcm1hdChbZ2V0RmllbGQocnVsZXMsICdjb25zdCcpXSkgOiAnJxKfAQoCbHQYAiABKAJCkAHCSIwBCokBCghmbG9hdC5sdBp9IWhhcyhydWxlcy5ndGUpICYmICFoYXMocnVsZXMuZ3QpICYmICh0aGlzLmlzTmFuKCkgfHwgdGhpcyA+PSBydWxlcy5sdCk/ICd2YWx1ZSBtdXN0IGJlIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5sdF0pIDogJydIABKvAQoDbHRlGAMgASgCQp8BwkibAQqYAQoJZmxvYXQubHRlGooBIWhhcyhydWxlcy5ndGUpICYmICFoYXMocnVsZXMuZ3QpICYmICh0aGlzLmlzTmFuKCkgfHwgdGhpcyA+IHJ1bGVzLmx0ZSk/ICd2YWx1ZSBtdXN0IGJlIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5sdGVdKSA6ICcnSAAS7wcKAmd0GAQgASgCQuAHwkjcBwqNAQoIZmxvYXQuZ3QagAEhaGFzKHJ1bGVzLmx0KSAmJiAhaGFzKHJ1bGVzLmx0ZSkgJiYgKHRoaXMuaXNOYW4oKSB8fCB0aGlzIDw9IHJ1bGVzLmd0KT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0XSkgOiAnJwrDAQoLZmxvYXQuZ3RfbHQaswFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0ID49IHJ1bGVzLmd0ICYmICh0aGlzLmlzTmFuKCkgfHwgdGhpcyA+PSBydWxlcy5sdCB8fCB0aGlzIDw9IHJ1bGVzLmd0KT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuICVzIGFuZCBsZXNzIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3QsIHJ1bGVzLmx0XSkgOiAnJwrNAQoVZmxvYXQuZ3RfbHRfZXhjbHVzaXZlGrMBaGFzKHJ1bGVzLmx0KSAmJiBydWxlcy5sdCA8IHJ1bGVzLmd0ICYmICh0aGlzLmlzTmFuKCkgfHwgKHJ1bGVzLmx0IDw9IHRoaXMgJiYgdGhpcyA8PSBydWxlcy5ndCkpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgb3IgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdF0pIDogJycK0wEKDGZsb2F0Lmd0X2x0ZRrCAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA+PSBydWxlcy5ndCAmJiAodGhpcy5pc05hbigpIHx8IHRoaXMgPiBydWxlcy5sdGUgfHwgdGhpcyA8PSBydWxlcy5ndCk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcyBhbmQgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdGVdKSA6ICcnCt0BChZmbG9hdC5ndF9sdGVfZXhjbHVzaXZlGsIBaGFzKHJ1bGVzLmx0ZSkgJiYgcnVsZXMubHRlIDwgcnVsZXMuZ3QgJiYgKHRoaXMuaXNOYW4oKSB8fCAocnVsZXMubHRlIDwgdGhpcyAmJiB0aGlzIDw9IHJ1bGVzLmd0KSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcyBvciBsZXNzIHRoYW4gb3IgZXF1YWwgdG8gJXMnLmZvcm1hdChbcnVsZXMuZ3QsIHJ1bGVzLmx0ZV0pIDogJydIARK6CAoDZ3RlGAUgASgCQqoIwkimCAqbAQoJZmxvYXQuZ3RlGo0BIWhhcyhydWxlcy5sdCkgJiYgIWhhcyhydWxlcy5sdGUpICYmICh0aGlzLmlzTmFuKCkgfHwgdGhpcyA8IHJ1bGVzLmd0ZSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5ndGVdKSA6ICcnCtIBCgxmbG9hdC5ndGVfbHQawQFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0ID49IHJ1bGVzLmd0ZSAmJiAodGhpcy5pc05hbigpIHx8IHRoaXMgPj0gcnVsZXMubHQgfHwgdGhpcyA8IHJ1bGVzLmd0ZSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcyBhbmQgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRdKSA6ICcnCtwBChZmbG9hdC5ndGVfbHRfZXhjbHVzaXZlGsEBaGFzKHJ1bGVzLmx0KSAmJiBydWxlcy5sdCA8IHJ1bGVzLmd0ZSAmJiAodGhpcy5pc05hbigpIHx8IChydWxlcy5sdCA8PSB0aGlzICYmIHRoaXMgPCBydWxlcy5ndGUpKT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzIG9yIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndGUsIHJ1bGVzLmx0XSkgOiAnJwriAQoNZmxvYXQuZ3RlX2x0ZRrQAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA+PSBydWxlcy5ndGUgJiYgKHRoaXMuaXNOYW4oKSB8fCB0aGlzID4gcnVsZXMubHRlIHx8IHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgYW5kIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5ndGUsIHJ1bGVzLmx0ZV0pIDogJycK7AEKF2Zsb2F0Lmd0ZV9sdGVfZXhjbHVzaXZlGtABaGFzKHJ1bGVzLmx0ZSkgJiYgcnVsZXMubHRlIDwgcnVsZXMuZ3RlICYmICh0aGlzLmlzTmFuKCkgfHwgKHJ1bGVzLmx0ZSA8IHRoaXMgJiYgdGhpcyA8IHJ1bGVzLmd0ZSkpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgb3IgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRlXSkgOiAnJ0gBEn8KAmluGAYgAygCQnPCSHAKbgoIZmxvYXQuaW4aYiEodGhpcyBpbiBnZXRGaWVsZChydWxlcywgJ2luJykpID8gJ3ZhbHVlIG11c3QgYmUgaW4gbGlzdCAlcycuZm9ybWF0KFtnZXRGaWVsZChydWxlcywgJ2luJyldKSA6ICcnEnYKBm5vdF9pbhgHIAMoAkJmwkhjCmEKDGZsb2F0Lm5vdF9pbhpRdGhpcyBpbiBydWxlcy5ub3RfaW4gPyAndmFsdWUgbXVzdCBub3QgYmUgaW4gbGlzdCAlcycuZm9ybWF0KFtydWxlcy5ub3RfaW5dKSA6ICcnEnUKBmZpbml0ZRgIIAEoCEJlwkhiCmAKDGZsb2F0LmZpbml0ZRpQcnVsZXMuZmluaXRlID8gKHRoaXMuaXNOYW4oKSB8fCB0aGlzLmlzSW5mKCkgPyAndmFsdWUgbXVzdCBiZSBmaW5pdGUnIDogJycpIDogJycSKwoHZXhhbXBsZRgJIAMoAkIawkgXChUKDWZsb2F0LmV4YW1wbGUaBHRydWUqCQjoBxCAgICAAkILCglsZXNzX3RoYW5CDgoMZ3JlYXRlcl90aGFuIu0XCgtEb3VibGVSdWxlcxKEAQoFY29uc3QYASABKAFCdcJIcgpwCgxkb3VibGUuY29uc3QaYHRoaXMgIT0gZ2V0RmllbGQocnVsZXMsICdjb25zdCcpID8gJ3ZhbHVlIG11c3QgZXF1YWwgJXMnLmZvcm1hdChbZ2V0RmllbGQocnVsZXMsICdjb25zdCcpXSkgOiAnJxKgAQoCbHQYAiABKAFCkQHCSI0BCooBCglkb3VibGUubHQafSFoYXMocnVsZXMuZ3RlKSAmJiAhaGFzKHJ1bGVzLmd0KSAmJiAodGhpcy5pc05hbigpIHx8IHRoaXMgPj0gcnVsZXMubHQpPyAndmFsdWUgbXVzdCBiZSBsZXNzIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMubHRdKSA6ICcnSAASsAEKA2x0ZRgDIAEoAUKgAcJInAEKmQEKCmRvdWJsZS5sdGUaigEhaGFzKHJ1bGVzLmd0ZSkgJiYgIWhhcyhydWxlcy5ndCkgJiYgKHRoaXMuaXNOYW4oKSB8fCB0aGlzID4gcnVsZXMubHRlKT8gJ3ZhbHVlIG11c3QgYmUgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmx0ZV0pIDogJydIABL0BwoCZ3QYBCABKAFC5QfCSOEHCo4BCglkb3VibGUuZ3QagAEhaGFzKHJ1bGVzLmx0KSAmJiAhaGFzKHJ1bGVzLmx0ZSkgJiYgKHRoaXMuaXNOYW4oKSB8fCB0aGlzIDw9IHJ1bGVzLmd0KT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0XSkgOiAnJwrEAQoMZG91YmxlLmd0X2x0GrMBaGFzKHJ1bGVzLmx0KSAmJiBydWxlcy5sdCA+PSBydWxlcy5ndCAmJiAodGhpcy5pc05hbigpIHx8IHRoaXMgPj0gcnVsZXMubHQgfHwgdGhpcyA8PSBydWxlcy5ndCk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcyBhbmQgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdF0pIDogJycKzgEKFmRvdWJsZS5ndF9sdF9leGNsdXNpdmUaswFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0IDwgcnVsZXMuZ3QgJiYgKHRoaXMuaXNOYW4oKSB8fCAocnVsZXMubHQgPD0gdGhpcyAmJiB0aGlzIDw9IHJ1bGVzLmd0KSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcyBvciBsZXNzIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3QsIHJ1bGVzLmx0XSkgOiAnJwrUAQoNZG91YmxlLmd0X2x0ZRrCAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA+PSBydWxlcy5ndCAmJiAodGhpcy5pc05hbigpIHx8IHRoaXMgPiBydWxlcy5sdGUgfHwgdGhpcyA8PSBydWxlcy5ndCk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcyBhbmQgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdGVdKSA6ICcnCt4BChdkb3VibGUuZ3RfbHRlX2V4Y2x1c2l2ZRrCAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA8IHJ1bGVzLmd0ICYmICh0aGlzLmlzTmFuKCkgfHwgKHJ1bGVzLmx0ZSA8IHRoaXMgJiYgdGhpcyA8PSBydWxlcy5ndCkpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgb3IgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdGVdKSA6ICcnSAESvwgKA2d0ZRgFIAEoAUKvCMJIqwgKnAEKCmRvdWJsZS5ndGUajQEhaGFzKHJ1bGVzLmx0KSAmJiAhaGFzKHJ1bGVzLmx0ZSkgJiYgKHRoaXMuaXNOYW4oKSB8fCB0aGlzIDwgcnVsZXMuZ3RlKT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0ZV0pIDogJycK0wEKDWRvdWJsZS5ndGVfbHQawQFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0ID49IHJ1bGVzLmd0ZSAmJiAodGhpcy5pc05hbigpIHx8IHRoaXMgPj0gcnVsZXMubHQgfHwgdGhpcyA8IHJ1bGVzLmd0ZSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcyBhbmQgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRdKSA6ICcnCt0BChdkb3VibGUuZ3RlX2x0X2V4Y2x1c2l2ZRrBAWhhcyhydWxlcy5sdCkgJiYgcnVsZXMubHQgPCBydWxlcy5ndGUgJiYgKHRoaXMuaXNOYW4oKSB8fCAocnVsZXMubHQgPD0gdGhpcyAmJiB0aGlzIDwgcnVsZXMuZ3RlKSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcyBvciBsZXNzIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3RlLCBydWxlcy5sdF0pIDogJycK4wEKDmRvdWJsZS5ndGVfbHRlGtABaGFzKHJ1bGVzLmx0ZSkgJiYgcnVsZXMubHRlID49IHJ1bGVzLmd0ZSAmJiAodGhpcy5pc05hbigpIHx8IHRoaXMgPiBydWxlcy5sdGUgfHwgdGhpcyA8IHJ1bGVzLmd0ZSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcyBhbmQgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRlXSkgOiAnJwrtAQoYZG91YmxlLmd0ZV9sdGVfZXhjbHVzaXZlGtABaGFzKHJ1bGVzLmx0ZSkgJiYgcnVsZXMubHRlIDwgcnVsZXMuZ3RlICYmICh0aGlzLmlzTmFuKCkgfHwgKHJ1bGVzLmx0ZSA8IHRoaXMgJiYgdGhpcyA8IHJ1bGVzLmd0ZSkpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgb3IgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRlXSkgOiAnJ0gBEoABCgJpbhgGIAMoAUJ0wkhxCm8KCWRvdWJsZS5pbhpiISh0aGlzIGluIGdldEZpZWxkKHJ1bGVzLCAnaW4nKSkgPyAndmFsdWUgbXVzdCBiZSBpbiBsaXN0ICVzJy5mb3JtYXQoW2dldEZpZWxkKHJ1bGVzLCAnaW4nKV0pIDogJycSdwoGbm90X2luGAcgAygBQmfCSGQKYgoNZG91YmxlLm5vdF9pbhpRdGhpcyBpbiBydWxlcy5ub3RfaW4gPyAndmFsdWUgbXVzdCBub3QgYmUgaW4gbGlzdCAlcycuZm9ybWF0KFtydWxlcy5ub3RfaW5dKSA6ICcnEnYKBmZpbml0ZRgIIAEoCEJmwkhjCmEKDWRvdWJsZS5maW5pdGUaUHJ1bGVzLmZpbml0ZSA/ICh0aGlzLmlzTmFuKCkgfHwgdGhpcy5pc0luZigpID8gJ3ZhbHVlIG11c3QgYmUgZmluaXRlJyA6ICcnKSA6ICcnEiwKB2V4YW1wbGUYCSADKAFCG8JIGAoWCg5kb3VibGUuZXhhbXBsZRoEdHJ1ZSoJCOgHEICAgIACQgsKCWxlc3NfdGhhbkIOCgxncmVhdGVyX3RoYW4ijBUKCkludDMyUnVsZXMSgwEKBWNvbnN0GAEgASgFQnTCSHEKbwoLaW50MzIuY29uc3QaYHRoaXMgIT0gZ2V0RmllbGQocnVsZXMsICdjb25zdCcpID8gJ3ZhbHVlIG11c3QgZXF1YWwgJXMnLmZvcm1hdChbZ2V0RmllbGQocnVsZXMsICdjb25zdCcpXSkgOiAnJxKKAQoCbHQYAiABKAVCfMJIeQp3CghpbnQzMi5sdBprIWhhcyhydWxlcy5ndGUpICYmICFoYXMocnVsZXMuZ3QpICYmIHRoaXMgPj0gcnVsZXMubHQ/ICd2YWx1ZSBtdXN0IGJlIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5sdF0pIDogJydIABKcAQoDbHRlGAMgASgFQowBwkiIAQqFAQoJaW50MzIubHRlGnghaGFzKHJ1bGVzLmd0ZSkgJiYgIWhhcyhydWxlcy5ndCkgJiYgdGhpcyA+IHJ1bGVzLmx0ZT8gJ3ZhbHVlIG11c3QgYmUgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmx0ZV0pIDogJydIABKXBwoCZ3QYBCABKAVCiAfCSIQHCnoKCGludDMyLmd0Gm4haGFzKHJ1bGVzLmx0KSAmJiAhaGFzKHJ1bGVzLmx0ZSkgJiYgdGhpcyA8PSBydWxlcy5ndD8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0XSkgOiAnJwqzAQoLaW50MzIuZ3RfbHQaowFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0ID49IHJ1bGVzLmd0ICYmICh0aGlzID49IHJ1bGVzLmx0IHx8IHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgYW5kIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndCwgcnVsZXMubHRdKSA6ICcnCrsBChVpbnQzMi5ndF9sdF9leGNsdXNpdmUaoQFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0IDwgcnVsZXMuZ3QgJiYgKHJ1bGVzLmx0IDw9IHRoaXMgJiYgdGhpcyA8PSBydWxlcy5ndCk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcyBvciBsZXNzIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3QsIHJ1bGVzLmx0XSkgOiAnJwrDAQoMaW50MzIuZ3RfbHRlGrIBaGFzKHJ1bGVzLmx0ZSkgJiYgcnVsZXMubHRlID49IHJ1bGVzLmd0ICYmICh0aGlzID4gcnVsZXMubHRlIHx8IHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgYW5kIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5ndCwgcnVsZXMubHRlXSkgOiAnJwrLAQoWaW50MzIuZ3RfbHRlX2V4Y2x1c2l2ZRqwAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA8IHJ1bGVzLmd0ICYmIChydWxlcy5sdGUgPCB0aGlzICYmIHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgb3IgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdGVdKSA6ICcnSAES4wcKA2d0ZRgFIAEoBULTB8JIzwcKiAEKCWludDMyLmd0ZRp7IWhhcyhydWxlcy5sdCkgJiYgIWhhcyhydWxlcy5sdGUpICYmIHRoaXMgPCBydWxlcy5ndGU/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5ndGVdKSA6ICcnCsIBCgxpbnQzMi5ndGVfbHQasQFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0ID49IHJ1bGVzLmd0ZSAmJiAodGhpcyA+PSBydWxlcy5sdCB8fCB0aGlzIDwgcnVsZXMuZ3RlKT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzIGFuZCBsZXNzIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3RlLCBydWxlcy5sdF0pIDogJycKygEKFmludDMyLmd0ZV9sdF9leGNsdXNpdmUarwFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0IDwgcnVsZXMuZ3RlICYmIChydWxlcy5sdCA8PSB0aGlzICYmIHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgb3IgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRdKSA6ICcnCtIBCg1pbnQzMi5ndGVfbHRlGsABaGFzKHJ1bGVzLmx0ZSkgJiYgcnVsZXMubHRlID49IHJ1bGVzLmd0ZSAmJiAodGhpcyA+IHJ1bGVzLmx0ZSB8fCB0aGlzIDwgcnVsZXMuZ3RlKT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzIGFuZCBsZXNzIHRoYW4gb3IgZXF1YWwgdG8gJXMnLmZvcm1hdChbcnVsZXMuZ3RlLCBydWxlcy5sdGVdKSA6ICcnCtoBChdpbnQzMi5ndGVfbHRlX2V4Y2x1c2l2ZRq+AWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA8IHJ1bGVzLmd0ZSAmJiAocnVsZXMubHRlIDwgdGhpcyAmJiB0aGlzIDwgcnVsZXMuZ3RlKT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzIG9yIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5ndGUsIHJ1bGVzLmx0ZV0pIDogJydIARJ/CgJpbhgGIAMoBUJzwkhwCm4KCGludDMyLmluGmIhKHRoaXMgaW4gZ2V0RmllbGQocnVsZXMsICdpbicpKSA/ICd2YWx1ZSBtdXN0IGJlIGluIGxpc3QgJXMnLmZvcm1hdChbZ2V0RmllbGQocnVsZXMsICdpbicpXSkgOiAnJxJ2CgZub3RfaW4YByADKAVCZsJIYwphCgxpbnQzMi5ub3RfaW4aUXRoaXMgaW4gcnVsZXMubm90X2luID8gJ3ZhbHVlIG11c3Qgbm90IGJlIGluIGxpc3QgJXMnLmZvcm1hdChbcnVsZXMubm90X2luXSkgOiAnJxIrCgdleGFtcGxlGAggAygFQhrCSBcKFQoNaW50MzIuZXhhbXBsZRoEdHJ1ZSoJCOgHEICAgIACQgsKCWxlc3NfdGhhbkIOCgxncmVhdGVyX3RoYW4ijBUKCkludDY0UnVsZXMSgwEKBWNvbnN0GAEgASgDQnTCSHEKbwoLaW50NjQuY29uc3QaYHRoaXMgIT0gZ2V0RmllbGQocnVsZXMsICdjb25zdCcpID8gJ3ZhbHVlIG11c3QgZXF1YWwgJXMnLmZvcm1hdChbZ2V0RmllbGQocnVsZXMsICdjb25zdCcpXSkgOiAnJxKKAQoCbHQYAiABKANCfMJIeQp3CghpbnQ2NC5sdBprIWhhcyhydWxlcy5ndGUpICYmICFoYXMocnVsZXMuZ3QpICYmIHRoaXMgPj0gcnVsZXMubHQ/ICd2YWx1ZSBtdXN0IGJlIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5sdF0pIDogJydIABKcAQoDbHRlGAMgASgDQowBwkiIAQqFAQoJaW50NjQubHRlGnghaGFzKHJ1bGVzLmd0ZSkgJiYgIWhhcyhydWxlcy5ndCkgJiYgdGhpcyA+IHJ1bGVzLmx0ZT8gJ3ZhbHVlIG11c3QgYmUgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmx0ZV0pIDogJydIABKXBwoCZ3QYBCABKANCiAfCSIQHCnoKCGludDY0Lmd0Gm4haGFzKHJ1bGVzLmx0KSAmJiAhaGFzKHJ1bGVzLmx0ZSkgJiYgdGhpcyA8PSBydWxlcy5ndD8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0XSkgOiAnJwqzAQoLaW50NjQuZ3RfbHQaowFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0ID49IHJ1bGVzLmd0ICYmICh0aGlzID49IHJ1bGVzLmx0IHx8IHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgYW5kIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndCwgcnVsZXMubHRdKSA6ICcnCrsBChVpbnQ2NC5ndF9sdF9leGNsdXNpdmUaoQFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0IDwgcnVsZXMuZ3QgJiYgKHJ1bGVzLmx0IDw9IHRoaXMgJiYgdGhpcyA8PSBydWxlcy5ndCk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcyBvciBsZXNzIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3QsIHJ1bGVzLmx0XSkgOiAnJwrDAQoMaW50NjQuZ3RfbHRlGrIBaGFzKHJ1bGVzLmx0ZSkgJiYgcnVsZXMubHRlID49IHJ1bGVzLmd0ICYmICh0aGlzID4gcnVsZXMubHRlIHx8IHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgYW5kIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5ndCwgcnVsZXMubHRlXSkgOiAnJwrLAQoWaW50NjQuZ3RfbHRlX2V4Y2x1c2l2ZRqwAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA8IHJ1bGVzLmd0ICYmIChydWxlcy5sdGUgPCB0aGlzICYmIHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgb3IgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdGVdKSA6ICcnSAES4wcKA2d0ZRgFIAEoA0LTB8JIzwcKiAEKCWludDY0Lmd0ZRp7IWhhcyhydWxlcy5sdCkgJiYgIWhhcyhydWxlcy5sdGUpICYmIHRoaXMgPCBydWxlcy5ndGU/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5ndGVdKSA6ICcnCsIBCgxpbnQ2NC5ndGVfbHQasQFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0ID49IHJ1bGVzLmd0ZSAmJiAodGhpcyA+PSBydWxlcy5sdCB8fCB0aGlzIDwgcnVsZXMuZ3RlKT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzIGFuZCBsZXNzIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3RlLCBydWxlcy5sdF0pIDogJycKygEKFmludDY0Lmd0ZV9sdF9leGNsdXNpdmUarwFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0IDwgcnVsZXMuZ3RlICYmIChydWxlcy5sdCA8PSB0aGlzICYmIHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgb3IgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRdKSA6ICcnCtIBCg1pbnQ2NC5ndGVfbHRlGsABaGFzKHJ1bGVzLmx0ZSkgJiYgcnVsZXMubHRlID49IHJ1bGVzLmd0ZSAmJiAodGhpcyA+IHJ1bGVzLmx0ZSB8fCB0aGlzIDwgcnVsZXMuZ3RlKT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzIGFuZCBsZXNzIHRoYW4gb3IgZXF1YWwgdG8gJXMnLmZvcm1hdChbcnVsZXMuZ3RlLCBydWxlcy5sdGVdKSA6ICcnCtoBChdpbnQ2NC5ndGVfbHRlX2V4Y2x1c2l2ZRq+AWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA8IHJ1bGVzLmd0ZSAmJiAocnVsZXMubHRlIDwgdGhpcyAmJiB0aGlzIDwgcnVsZXMuZ3RlKT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzIG9yIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5ndGUsIHJ1bGVzLmx0ZV0pIDogJydIARJ/CgJpbhgGIAMoA0JzwkhwCm4KCGludDY0LmluGmIhKHRoaXMgaW4gZ2V0RmllbGQocnVsZXMsICdpbicpKSA/ICd2YWx1ZSBtdXN0IGJlIGluIGxpc3QgJXMnLmZvcm1hdChbZ2V0RmllbGQocnVsZXMsICdpbicpXSkgOiAnJxJ2CgZub3RfaW4YByADKANCZsJIYwphCgxpbnQ2NC5ub3RfaW4aUXRoaXMgaW4gcnVsZXMubm90X2luID8gJ3ZhbHVlIG11c3Qgbm90IGJlIGluIGxpc3QgJXMnLmZvcm1hdChbcnVsZXMubm90X2luXSkgOiAnJxIrCgdleGFtcGxlGAkgAygDQhrCSBcKFQoNaW50NjQuZXhhbXBsZRoEdHJ1ZSoJCOgHEICAgIACQgsKCWxlc3NfdGhhbkIOCgxncmVhdGVyX3RoYW4inhUKC1VJbnQzMlJ1bGVzEoQBCgVjb25zdBgBIAEoDUJ1wkhyCnAKDHVpbnQzMi5jb25zdBpgdGhpcyAhPSBnZXRGaWVsZChydWxlcywgJ2NvbnN0JykgPyAndmFsdWUgbXVzdCBlcXVhbCAlcycuZm9ybWF0KFtnZXRGaWVsZChydWxlcywgJ2NvbnN0JyldKSA6ICcnEosBCgJsdBgCIAEoDUJ9wkh6CngKCXVpbnQzMi5sdBprIWhhcyhydWxlcy5ndGUpICYmICFoYXMocnVsZXMuZ3QpICYmIHRoaXMgPj0gcnVsZXMubHQ/ICd2YWx1ZSBtdXN0IGJlIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5sdF0pIDogJydIABKdAQoDbHRlGAMgASgNQo0BwkiJAQqGAQoKdWludDMyLmx0ZRp4IWhhcyhydWxlcy5ndGUpICYmICFoYXMocnVsZXMuZ3QpICYmIHRoaXMgPiBydWxlcy5sdGU/ICd2YWx1ZSBtdXN0IGJlIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5sdGVdKSA6ICcnSAASnAcKAmd0GAQgASgNQo0HwkiJBwp7Cgl1aW50MzIuZ3QabiFoYXMocnVsZXMubHQpICYmICFoYXMocnVsZXMubHRlKSAmJiB0aGlzIDw9IHJ1bGVzLmd0PyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3RdKSA6ICcnCrQBCgx1aW50MzIuZ3RfbHQaowFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0ID49IHJ1bGVzLmd0ICYmICh0aGlzID49IHJ1bGVzLmx0IHx8IHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgYW5kIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndCwgcnVsZXMubHRdKSA6ICcnCrwBChZ1aW50MzIuZ3RfbHRfZXhjbHVzaXZlGqEBaGFzKHJ1bGVzLmx0KSAmJiBydWxlcy5sdCA8IHJ1bGVzLmd0ICYmIChydWxlcy5sdCA8PSB0aGlzICYmIHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgb3IgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdF0pIDogJycKxAEKDXVpbnQzMi5ndF9sdGUasgFoYXMocnVsZXMubHRlKSAmJiBydWxlcy5sdGUgPj0gcnVsZXMuZ3QgJiYgKHRoaXMgPiBydWxlcy5sdGUgfHwgdGhpcyA8PSBydWxlcy5ndCk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcyBhbmQgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdGVdKSA6ICcnCswBChd1aW50MzIuZ3RfbHRlX2V4Y2x1c2l2ZRqwAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA8IHJ1bGVzLmd0ICYmIChydWxlcy5sdGUgPCB0aGlzICYmIHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgb3IgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdGVdKSA6ICcnSAES6AcKA2d0ZRgFIAEoDULYB8JI1AcKiQEKCnVpbnQzMi5ndGUaeyFoYXMocnVsZXMubHQpICYmICFoYXMocnVsZXMubHRlKSAmJiB0aGlzIDwgcnVsZXMuZ3RlPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMnLmZvcm1hdChbcnVsZXMuZ3RlXSkgOiAnJwrDAQoNdWludDMyLmd0ZV9sdBqxAWhhcyhydWxlcy5sdCkgJiYgcnVsZXMubHQgPj0gcnVsZXMuZ3RlICYmICh0aGlzID49IHJ1bGVzLmx0IHx8IHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgYW5kIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndGUsIHJ1bGVzLmx0XSkgOiAnJwrLAQoXdWludDMyLmd0ZV9sdF9leGNsdXNpdmUarwFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0IDwgcnVsZXMuZ3RlICYmIChydWxlcy5sdCA8PSB0aGlzICYmIHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgb3IgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRdKSA6ICcnCtMBCg51aW50MzIuZ3RlX2x0ZRrAAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA+PSBydWxlcy5ndGUgJiYgKHRoaXMgPiBydWxlcy5sdGUgfHwgdGhpcyA8IHJ1bGVzLmd0ZSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcyBhbmQgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRlXSkgOiAnJwrbAQoYdWludDMyLmd0ZV9sdGVfZXhjbHVzaXZlGr4BaGFzKHJ1bGVzLmx0ZSkgJiYgcnVsZXMubHRlIDwgcnVsZXMuZ3RlICYmIChydWxlcy5sdGUgPCB0aGlzICYmIHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgb3IgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRlXSkgOiAnJ0gBEoABCgJpbhgGIAMoDUJ0wkhxCm8KCXVpbnQzMi5pbhpiISh0aGlzIGluIGdldEZpZWxkKHJ1bGVzLCAnaW4nKSkgPyAndmFsdWUgbXVzdCBiZSBpbiBsaXN0ICVzJy5mb3JtYXQoW2dldEZpZWxkKHJ1bGVzLCAnaW4nKV0pIDogJycSdwoGbm90X2luGAcgAygNQmfCSGQKYgoNdWludDMyLm5vdF9pbhpRdGhpcyBpbiBydWxlcy5ub3RfaW4gPyAndmFsdWUgbXVzdCBub3QgYmUgaW4gbGlzdCAlcycuZm9ybWF0KFtydWxlcy5ub3RfaW5dKSA6ICcnEiwKB2V4YW1wbGUYCCADKA1CG8JIGAoWCg51aW50MzIuZXhhbXBsZRoEdHJ1ZSoJCOgHEICAgIACQgsKCWxlc3NfdGhhbkIOCgxncmVhdGVyX3RoYW4inhUKC1VJbnQ2NFJ1bGVzEoQBCgVjb25zdBgBIAEoBEJ1wkhyCnAKDHVpbnQ2NC5jb25zdBpgdGhpcyAhPSBnZXRGaWVsZChydWxlcywgJ2NvbnN0JykgPyAndmFsdWUgbXVzdCBlcXVhbCAlcycuZm9ybWF0KFtnZXRGaWVsZChydWxlcywgJ2NvbnN0JyldKSA6ICcnEosBCgJsdBgCIAEoBEJ9wkh6CngKCXVpbnQ2NC5sdBprIWhhcyhydWxlcy5ndGUpICYmICFoYXMocnVsZXMuZ3QpICYmIHRoaXMgPj0gcnVsZXMubHQ/ICd2YWx1ZSBtdXN0IGJlIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5sdF0pIDogJydIABKdAQoDbHRlGAMgASgEQo0BwkiJAQqGAQoKdWludDY0Lmx0ZRp4IWhhcyhydWxlcy5ndGUpICYmICFoYXMocnVsZXMuZ3QpICYmIHRoaXMgPiBydWxlcy5sdGU/ICd2YWx1ZSBtdXN0IGJlIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5sdGVdKSA6ICcnSAASnAcKAmd0GAQgASgEQo0HwkiJBwp7Cgl1aW50NjQuZ3QabiFoYXMocnVsZXMubHQpICYmICFoYXMocnVsZXMubHRlKSAmJiB0aGlzIDw9IHJ1bGVzLmd0PyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3RdKSA6ICcnCrQBCgx1aW50NjQuZ3RfbHQaowFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0ID49IHJ1bGVzLmd0ICYmICh0aGlzID49IHJ1bGVzLmx0IHx8IHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgYW5kIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndCwgcnVsZXMubHRdKSA6ICcnCrwBChZ1aW50NjQuZ3RfbHRfZXhjbHVzaXZlGqEBaGFzKHJ1bGVzLmx0KSAmJiBydWxlcy5sdCA8IHJ1bGVzLmd0ICYmIChydWxlcy5sdCA8PSB0aGlzICYmIHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgb3IgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdF0pIDogJycKxAEKDXVpbnQ2NC5ndF9sdGUasgFoYXMocnVsZXMubHRlKSAmJiBydWxlcy5sdGUgPj0gcnVsZXMuZ3QgJiYgKHRoaXMgPiBydWxlcy5sdGUgfHwgdGhpcyA8PSBydWxlcy5ndCk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcyBhbmQgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdGVdKSA6ICcnCswBChd1aW50NjQuZ3RfbHRlX2V4Y2x1c2l2ZRqwAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA8IHJ1bGVzLmd0ICYmIChydWxlcy5sdGUgPCB0aGlzICYmIHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgb3IgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdGVdKSA6ICcnSAES6AcKA2d0ZRgFIAEoBELYB8JI1AcKiQEKCnVpbnQ2NC5ndGUaeyFoYXMocnVsZXMubHQpICYmICFoYXMocnVsZXMubHRlKSAmJiB0aGlzIDwgcnVsZXMuZ3RlPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMnLmZvcm1hdChbcnVsZXMuZ3RlXSkgOiAnJwrDAQoNdWludDY0Lmd0ZV9sdBqxAWhhcyhydWxlcy5sdCkgJiYgcnVsZXMubHQgPj0gcnVsZXMuZ3RlICYmICh0aGlzID49IHJ1bGVzLmx0IHx8IHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgYW5kIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndGUsIHJ1bGVzLmx0XSkgOiAnJwrLAQoXdWludDY0Lmd0ZV9sdF9leGNsdXNpdmUarwFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0IDwgcnVsZXMuZ3RlICYmIChydWxlcy5sdCA8PSB0aGlzICYmIHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgb3IgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRdKSA6ICcnCtMBCg51aW50NjQuZ3RlX2x0ZRrAAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA+PSBydWxlcy5ndGUgJiYgKHRoaXMgPiBydWxlcy5sdGUgfHwgdGhpcyA8IHJ1bGVzLmd0ZSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcyBhbmQgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRlXSkgOiAnJwrbAQoYdWludDY0Lmd0ZV9sdGVfZXhjbHVzaXZlGr4BaGFzKHJ1bGVzLmx0ZSkgJiYgcnVsZXMubHRlIDwgcnVsZXMuZ3RlICYmIChydWxlcy5sdGUgPCB0aGlzICYmIHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgb3IgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRlXSkgOiAnJ0gBEoABCgJpbhgGIAMoBEJ0wkhxCm8KCXVpbnQ2NC5pbhpiISh0aGlzIGluIGdldEZpZWxkKHJ1bGVzLCAnaW4nKSkgPyAndmFsdWUgbXVzdCBiZSBpbiBsaXN0ICVzJy5mb3JtYXQoW2dldEZpZWxkKHJ1bGVzLCAnaW4nKV0pIDogJycSdwoGbm90X2luGAcgAygEQmfCSGQKYgoNdWludDY0Lm5vdF9pbhpRdGhpcyBpbiBydWxlcy5ub3RfaW4gPyAndmFsdWUgbXVzdCBub3QgYmUgaW4gbGlzdCAlcycuZm9ybWF0KFtydWxlcy5ub3RfaW5dKSA6ICcnEiwKB2V4YW1wbGUYCCADKARCG8JIGAoWCg51aW50NjQuZXhhbXBsZRoEdHJ1ZSoJCOgHEICAgIACQgsKCWxlc3NfdGhhbkIOCgxncmVhdGVyX3RoYW4inhUKC1NJbnQzMlJ1bGVzEoQBCgVjb25zdBgBIAEoEUJ1wkhyCnAKDHNpbnQzMi5jb25zdBpgdGhpcyAhPSBnZXRGaWVsZChydWxlcywgJ2NvbnN0JykgPyAndmFsdWUgbXVzdCBlcXVhbCAlcycuZm9ybWF0KFtnZXRGaWVsZChydWxlcywgJ2NvbnN0JyldKSA6ICcnEosBCgJsdBgCIAEoEUJ9wkh6CngKCXNpbnQzMi5sdBprIWhhcyhydWxlcy5ndGUpICYmICFoYXMocnVsZXMuZ3QpICYmIHRoaXMgPj0gcnVsZXMubHQ/ICd2YWx1ZSBtdXN0IGJlIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5sdF0pIDogJydIABKdAQoDbHRlGAMgASgRQo0BwkiJAQqGAQoKc2ludDMyLmx0ZRp4IWhhcyhydWxlcy5ndGUpICYmICFoYXMocnVsZXMuZ3QpICYmIHRoaXMgPiBydWxlcy5sdGU/ICd2YWx1ZSBtdXN0IGJlIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5sdGVdKSA6ICcnSAASnAcKAmd0GAQgASgRQo0HwkiJBwp7CglzaW50MzIuZ3QabiFoYXMocnVsZXMubHQpICYmICFoYXMocnVsZXMubHRlKSAmJiB0aGlzIDw9IHJ1bGVzLmd0PyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3RdKSA6ICcnCrQBCgxzaW50MzIuZ3RfbHQaowFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0ID49IHJ1bGVzLmd0ICYmICh0aGlzID49IHJ1bGVzLmx0IHx8IHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgYW5kIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndCwgcnVsZXMubHRdKSA6ICcnCrwBChZzaW50MzIuZ3RfbHRfZXhjbHVzaXZlGqEBaGFzKHJ1bGVzLmx0KSAmJiBydWxlcy5sdCA8IHJ1bGVzLmd0ICYmIChydWxlcy5sdCA8PSB0aGlzICYmIHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgb3IgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdF0pIDogJycKxAEKDXNpbnQzMi5ndF9sdGUasgFoYXMocnVsZXMubHRlKSAmJiBydWxlcy5sdGUgPj0gcnVsZXMuZ3QgJiYgKHRoaXMgPiBydWxlcy5sdGUgfHwgdGhpcyA8PSBydWxlcy5ndCk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcyBhbmQgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdGVdKSA6ICcnCswBChdzaW50MzIuZ3RfbHRlX2V4Y2x1c2l2ZRqwAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA8IHJ1bGVzLmd0ICYmIChydWxlcy5sdGUgPCB0aGlzICYmIHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgb3IgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdGVdKSA6ICcnSAES6AcKA2d0ZRgFIAEoEULYB8JI1AcKiQEKCnNpbnQzMi5ndGUaeyFoYXMocnVsZXMubHQpICYmICFoYXMocnVsZXMubHRlKSAmJiB0aGlzIDwgcnVsZXMuZ3RlPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMnLmZvcm1hdChbcnVsZXMuZ3RlXSkgOiAnJwrDAQoNc2ludDMyLmd0ZV9sdBqxAWhhcyhydWxlcy5sdCkgJiYgcnVsZXMubHQgPj0gcnVsZXMuZ3RlICYmICh0aGlzID49IHJ1bGVzLmx0IHx8IHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgYW5kIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndGUsIHJ1bGVzLmx0XSkgOiAnJwrLAQoXc2ludDMyLmd0ZV9sdF9leGNsdXNpdmUarwFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0IDwgcnVsZXMuZ3RlICYmIChydWxlcy5sdCA8PSB0aGlzICYmIHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgb3IgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRdKSA6ICcnCtMBCg5zaW50MzIuZ3RlX2x0ZRrAAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA+PSBydWxlcy5ndGUgJiYgKHRoaXMgPiBydWxlcy5sdGUgfHwgdGhpcyA8IHJ1bGVzLmd0ZSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcyBhbmQgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRlXSkgOiAnJwrbAQoYc2ludDMyLmd0ZV9sdGVfZXhjbHVzaXZlGr4BaGFzKHJ1bGVzLmx0ZSkgJiYgcnVsZXMubHRlIDwgcnVsZXMuZ3RlICYmIChydWxlcy5sdGUgPCB0aGlzICYmIHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgb3IgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRlXSkgOiAnJ0gBEoABCgJpbhgGIAMoEUJ0wkhxCm8KCXNpbnQzMi5pbhpiISh0aGlzIGluIGdldEZpZWxkKHJ1bGVzLCAnaW4nKSkgPyAndmFsdWUgbXVzdCBiZSBpbiBsaXN0ICVzJy5mb3JtYXQoW2dldEZpZWxkKHJ1bGVzLCAnaW4nKV0pIDogJycSdwoGbm90X2luGAcgAygRQmfCSGQKYgoNc2ludDMyLm5vdF9pbhpRdGhpcyBpbiBydWxlcy5ub3RfaW4gPyAndmFsdWUgbXVzdCBub3QgYmUgaW4gbGlzdCAlcycuZm9ybWF0KFtydWxlcy5ub3RfaW5dKSA6ICcnEiwKB2V4YW1wbGUYCCADKBFCG8JIGAoWCg5zaW50MzIuZXhhbXBsZRoEdHJ1ZSoJCOgHEICAgIACQgsKCWxlc3NfdGhhbkIOCgxncmVhdGVyX3RoYW4inhUKC1NJbnQ2NFJ1bGVzEoQBCgVjb25zdBgBIAEoEkJ1wkhyCnAKDHNpbnQ2NC5jb25zdBpgdGhpcyAhPSBnZXRGaWVsZChydWxlcywgJ2NvbnN0JykgPyAndmFsdWUgbXVzdCBlcXVhbCAlcycuZm9ybWF0KFtnZXRGaWVsZChydWxlcywgJ2NvbnN0JyldKSA6ICcnEosBCgJsdBgCIAEoEkJ9wkh6CngKCXNpbnQ2NC5sdBprIWhhcyhydWxlcy5ndGUpICYmICFoYXMocnVsZXMuZ3QpICYmIHRoaXMgPj0gcnVsZXMubHQ/ICd2YWx1ZSBtdXN0IGJlIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5sdF0pIDogJydIABKdAQoDbHRlGAMgASgSQo0BwkiJAQqGAQoKc2ludDY0Lmx0ZRp4IWhhcyhydWxlcy5ndGUpICYmICFoYXMocnVsZXMuZ3QpICYmIHRoaXMgPiBydWxlcy5sdGU/ICd2YWx1ZSBtdXN0IGJlIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5sdGVdKSA6ICcnSAASnAcKAmd0GAQgASgSQo0HwkiJBwp7CglzaW50NjQuZ3QabiFoYXMocnVsZXMubHQpICYmICFoYXMocnVsZXMubHRlKSAmJiB0aGlzIDw9IHJ1bGVzLmd0PyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3RdKSA6ICcnCrQBCgxzaW50NjQuZ3RfbHQaowFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0ID49IHJ1bGVzLmd0ICYmICh0aGlzID49IHJ1bGVzLmx0IHx8IHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgYW5kIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndCwgcnVsZXMubHRdKSA6ICcnCrwBChZzaW50NjQuZ3RfbHRfZXhjbHVzaXZlGqEBaGFzKHJ1bGVzLmx0KSAmJiBydWxlcy5sdCA8IHJ1bGVzLmd0ICYmIChydWxlcy5sdCA8PSB0aGlzICYmIHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgb3IgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdF0pIDogJycKxAEKDXNpbnQ2NC5ndF9sdGUasgFoYXMocnVsZXMubHRlKSAmJiBydWxlcy5sdGUgPj0gcnVsZXMuZ3QgJiYgKHRoaXMgPiBydWxlcy5sdGUgfHwgdGhpcyA8PSBydWxlcy5ndCk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcyBhbmQgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdGVdKSA6ICcnCswBChdzaW50NjQuZ3RfbHRlX2V4Y2x1c2l2ZRqwAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA8IHJ1bGVzLmd0ICYmIChydWxlcy5sdGUgPCB0aGlzICYmIHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgb3IgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdGVdKSA6ICcnSAES6AcKA2d0ZRgFIAEoEkLYB8JI1AcKiQEKCnNpbnQ2NC5ndGUaeyFoYXMocnVsZXMubHQpICYmICFoYXMocnVsZXMubHRlKSAmJiB0aGlzIDwgcnVsZXMuZ3RlPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMnLmZvcm1hdChbcnVsZXMuZ3RlXSkgOiAnJwrDAQoNc2ludDY0Lmd0ZV9sdBqxAWhhcyhydWxlcy5sdCkgJiYgcnVsZXMubHQgPj0gcnVsZXMuZ3RlICYmICh0aGlzID49IHJ1bGVzLmx0IHx8IHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgYW5kIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndGUsIHJ1bGVzLmx0XSkgOiAnJwrLAQoXc2ludDY0Lmd0ZV9sdF9leGNsdXNpdmUarwFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0IDwgcnVsZXMuZ3RlICYmIChydWxlcy5sdCA8PSB0aGlzICYmIHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgb3IgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRdKSA6ICcnCtMBCg5zaW50NjQuZ3RlX2x0ZRrAAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA+PSBydWxlcy5ndGUgJiYgKHRoaXMgPiBydWxlcy5sdGUgfHwgdGhpcyA8IHJ1bGVzLmd0ZSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcyBhbmQgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRlXSkgOiAnJwrbAQoYc2ludDY0Lmd0ZV9sdGVfZXhjbHVzaXZlGr4BaGFzKHJ1bGVzLmx0ZSkgJiYgcnVsZXMubHRlIDwgcnVsZXMuZ3RlICYmIChydWxlcy5sdGUgPCB0aGlzICYmIHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgb3IgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRlXSkgOiAnJ0gBEoABCgJpbhgGIAMoEkJ0wkhxCm8KCXNpbnQ2NC5pbhpiISh0aGlzIGluIGdldEZpZWxkKHJ1bGVzLCAnaW4nKSkgPyAndmFsdWUgbXVzdCBiZSBpbiBsaXN0ICVzJy5mb3JtYXQoW2dldEZpZWxkKHJ1bGVzLCAnaW4nKV0pIDogJycSdwoGbm90X2luGAcgAygSQmfCSGQKYgoNc2ludDY0Lm5vdF9pbhpRdGhpcyBpbiBydWxlcy5ub3RfaW4gPyAndmFsdWUgbXVzdCBub3QgYmUgaW4gbGlzdCAlcycuZm9ybWF0KFtydWxlcy5ub3RfaW5dKSA6ICcnEiwKB2V4YW1wbGUYCCADKBJCG8JIGAoWCg5zaW50NjQuZXhhbXBsZRoEdHJ1ZSoJCOgHEICAgIACQgsKCWxlc3NfdGhhbkIOCgxncmVhdGVyX3RoYW4irxUKDEZpeGVkMzJSdWxlcxKFAQoFY29uc3QYASABKAdCdsJIcwpxCg1maXhlZDMyLmNvbnN0GmB0aGlzICE9IGdldEZpZWxkKHJ1bGVzLCAnY29uc3QnKSA/ICd2YWx1ZSBtdXN0IGVxdWFsICVzJy5mb3JtYXQoW2dldEZpZWxkKHJ1bGVzLCAnY29uc3QnKV0pIDogJycSjAEKAmx0GAIgASgHQn7CSHsKeQoKZml4ZWQzMi5sdBprIWhhcyhydWxlcy5ndGUpICYmICFoYXMocnVsZXMuZ3QpICYmIHRoaXMgPj0gcnVsZXMubHQ/ICd2YWx1ZSBtdXN0IGJlIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5sdF0pIDogJydIABKeAQoDbHRlGAMgASgHQo4BwkiKAQqHAQoLZml4ZWQzMi5sdGUaeCFoYXMocnVsZXMuZ3RlKSAmJiAhaGFzKHJ1bGVzLmd0KSAmJiB0aGlzID4gcnVsZXMubHRlPyAndmFsdWUgbXVzdCBiZSBsZXNzIHRoYW4gb3IgZXF1YWwgdG8gJXMnLmZvcm1hdChbcnVsZXMubHRlXSkgOiAnJ0gAEqEHCgJndBgEIAEoB0KSB8JIjgcKfAoKZml4ZWQzMi5ndBpuIWhhcyhydWxlcy5sdCkgJiYgIWhhcyhydWxlcy5sdGUpICYmIHRoaXMgPD0gcnVsZXMuZ3Q/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndF0pIDogJycKtQEKDWZpeGVkMzIuZ3RfbHQaowFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0ID49IHJ1bGVzLmd0ICYmICh0aGlzID49IHJ1bGVzLmx0IHx8IHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgYW5kIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndCwgcnVsZXMubHRdKSA6ICcnCr0BChdmaXhlZDMyLmd0X2x0X2V4Y2x1c2l2ZRqhAWhhcyhydWxlcy5sdCkgJiYgcnVsZXMubHQgPCBydWxlcy5ndCAmJiAocnVsZXMubHQgPD0gdGhpcyAmJiB0aGlzIDw9IHJ1bGVzLmd0KT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuICVzIG9yIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndCwgcnVsZXMubHRdKSA6ICcnCsUBCg5maXhlZDMyLmd0X2x0ZRqyAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA+PSBydWxlcy5ndCAmJiAodGhpcyA+IHJ1bGVzLmx0ZSB8fCB0aGlzIDw9IHJ1bGVzLmd0KT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuICVzIGFuZCBsZXNzIHRoYW4gb3IgZXF1YWwgdG8gJXMnLmZvcm1hdChbcnVsZXMuZ3QsIHJ1bGVzLmx0ZV0pIDogJycKzQEKGGZpeGVkMzIuZ3RfbHRlX2V4Y2x1c2l2ZRqwAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA8IHJ1bGVzLmd0ICYmIChydWxlcy5sdGUgPCB0aGlzICYmIHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgb3IgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdGVdKSA6ICcnSAES7QcKA2d0ZRgFIAEoB0LdB8JI2QcKigEKC2ZpeGVkMzIuZ3RlGnshaGFzKHJ1bGVzLmx0KSAmJiAhaGFzKHJ1bGVzLmx0ZSkgJiYgdGhpcyA8IHJ1bGVzLmd0ZT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0ZV0pIDogJycKxAEKDmZpeGVkMzIuZ3RlX2x0GrEBaGFzKHJ1bGVzLmx0KSAmJiBydWxlcy5sdCA+PSBydWxlcy5ndGUgJiYgKHRoaXMgPj0gcnVsZXMubHQgfHwgdGhpcyA8IHJ1bGVzLmd0ZSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcyBhbmQgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRdKSA6ICcnCswBChhmaXhlZDMyLmd0ZV9sdF9leGNsdXNpdmUarwFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0IDwgcnVsZXMuZ3RlICYmIChydWxlcy5sdCA8PSB0aGlzICYmIHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgb3IgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRdKSA6ICcnCtQBCg9maXhlZDMyLmd0ZV9sdGUawAFoYXMocnVsZXMubHRlKSAmJiBydWxlcy5sdGUgPj0gcnVsZXMuZ3RlICYmICh0aGlzID4gcnVsZXMubHRlIHx8IHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgYW5kIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5ndGUsIHJ1bGVzLmx0ZV0pIDogJycK3AEKGWZpeGVkMzIuZ3RlX2x0ZV9leGNsdXNpdmUavgFoYXMocnVsZXMubHRlKSAmJiBydWxlcy5sdGUgPCBydWxlcy5ndGUgJiYgKHJ1bGVzLmx0ZSA8IHRoaXMgJiYgdGhpcyA8IHJ1bGVzLmd0ZSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcyBvciBsZXNzIHRoYW4gb3IgZXF1YWwgdG8gJXMnLmZvcm1hdChbcnVsZXMuZ3RlLCBydWxlcy5sdGVdKSA6ICcnSAESgQEKAmluGAYgAygHQnXCSHIKcAoKZml4ZWQzMi5pbhpiISh0aGlzIGluIGdldEZpZWxkKHJ1bGVzLCAnaW4nKSkgPyAndmFsdWUgbXVzdCBiZSBpbiBsaXN0ICVzJy5mb3JtYXQoW2dldEZpZWxkKHJ1bGVzLCAnaW4nKV0pIDogJycSeAoGbm90X2luGAcgAygHQmjCSGUKYwoOZml4ZWQzMi5ub3RfaW4aUXRoaXMgaW4gcnVsZXMubm90X2luID8gJ3ZhbHVlIG11c3Qgbm90IGJlIGluIGxpc3QgJXMnLmZvcm1hdChbcnVsZXMubm90X2luXSkgOiAnJxItCgdleGFtcGxlGAggAygHQhzCSBkKFwoPZml4ZWQzMi5leGFtcGxlGgR0cnVlKgkI6AcQgICAgAJCCwoJbGVzc190aGFuQg4KDGdyZWF0ZXJfdGhhbiKvFQoMRml4ZWQ2NFJ1bGVzEoUBCgVjb25zdBgBIAEoBkJ2wkhzCnEKDWZpeGVkNjQuY29uc3QaYHRoaXMgIT0gZ2V0RmllbGQocnVsZXMsICdjb25zdCcpID8gJ3ZhbHVlIG11c3QgZXF1YWwgJXMnLmZvcm1hdChbZ2V0RmllbGQocnVsZXMsICdjb25zdCcpXSkgOiAnJxKMAQoCbHQYAiABKAZCfsJIewp5CgpmaXhlZDY0Lmx0GmshaGFzKHJ1bGVzLmd0ZSkgJiYgIWhhcyhydWxlcy5ndCkgJiYgdGhpcyA+PSBydWxlcy5sdD8gJ3ZhbHVlIG11c3QgYmUgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmx0XSkgOiAnJ0gAEp4BCgNsdGUYAyABKAZCjgHCSIoBCocBCgtmaXhlZDY0Lmx0ZRp4IWhhcyhydWxlcy5ndGUpICYmICFoYXMocnVsZXMuZ3QpICYmIHRoaXMgPiBydWxlcy5sdGU/ICd2YWx1ZSBtdXN0IGJlIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5sdGVdKSA6ICcnSAASoQcKAmd0GAQgASgGQpIHwkiOBwp8CgpmaXhlZDY0Lmd0Gm4haGFzKHJ1bGVzLmx0KSAmJiAhaGFzKHJ1bGVzLmx0ZSkgJiYgdGhpcyA8PSBydWxlcy5ndD8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0XSkgOiAnJwq1AQoNZml4ZWQ2NC5ndF9sdBqjAWhhcyhydWxlcy5sdCkgJiYgcnVsZXMubHQgPj0gcnVsZXMuZ3QgJiYgKHRoaXMgPj0gcnVsZXMubHQgfHwgdGhpcyA8PSBydWxlcy5ndCk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcyBhbmQgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdF0pIDogJycKvQEKF2ZpeGVkNjQuZ3RfbHRfZXhjbHVzaXZlGqEBaGFzKHJ1bGVzLmx0KSAmJiBydWxlcy5sdCA8IHJ1bGVzLmd0ICYmIChydWxlcy5sdCA8PSB0aGlzICYmIHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgb3IgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdF0pIDogJycKxQEKDmZpeGVkNjQuZ3RfbHRlGrIBaGFzKHJ1bGVzLmx0ZSkgJiYgcnVsZXMubHRlID49IHJ1bGVzLmd0ICYmICh0aGlzID4gcnVsZXMubHRlIHx8IHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgYW5kIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5ndCwgcnVsZXMubHRlXSkgOiAnJwrNAQoYZml4ZWQ2NC5ndF9sdGVfZXhjbHVzaXZlGrABaGFzKHJ1bGVzLmx0ZSkgJiYgcnVsZXMubHRlIDwgcnVsZXMuZ3QgJiYgKHJ1bGVzLmx0ZSA8IHRoaXMgJiYgdGhpcyA8PSBydWxlcy5ndCk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcyBvciBsZXNzIHRoYW4gb3IgZXF1YWwgdG8gJXMnLmZvcm1hdChbcnVsZXMuZ3QsIHJ1bGVzLmx0ZV0pIDogJydIARLtBwoDZ3RlGAUgASgGQt0HwkjZBwqKAQoLZml4ZWQ2NC5ndGUaeyFoYXMocnVsZXMubHQpICYmICFoYXMocnVsZXMubHRlKSAmJiB0aGlzIDwgcnVsZXMuZ3RlPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMnLmZvcm1hdChbcnVsZXMuZ3RlXSkgOiAnJwrEAQoOZml4ZWQ2NC5ndGVfbHQasQFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0ID49IHJ1bGVzLmd0ZSAmJiAodGhpcyA+PSBydWxlcy5sdCB8fCB0aGlzIDwgcnVsZXMuZ3RlKT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzIGFuZCBsZXNzIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3RlLCBydWxlcy5sdF0pIDogJycKzAEKGGZpeGVkNjQuZ3RlX2x0X2V4Y2x1c2l2ZRqvAWhhcyhydWxlcy5sdCkgJiYgcnVsZXMubHQgPCBydWxlcy5ndGUgJiYgKHJ1bGVzLmx0IDw9IHRoaXMgJiYgdGhpcyA8IHJ1bGVzLmd0ZSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcyBvciBsZXNzIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3RlLCBydWxlcy5sdF0pIDogJycK1AEKD2ZpeGVkNjQuZ3RlX2x0ZRrAAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA+PSBydWxlcy5ndGUgJiYgKHRoaXMgPiBydWxlcy5sdGUgfHwgdGhpcyA8IHJ1bGVzLmd0ZSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcyBhbmQgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRlXSkgOiAnJwrcAQoZZml4ZWQ2NC5ndGVfbHRlX2V4Y2x1c2l2ZRq+AWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA8IHJ1bGVzLmd0ZSAmJiAocnVsZXMubHRlIDwgdGhpcyAmJiB0aGlzIDwgcnVsZXMuZ3RlKT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzIG9yIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5ndGUsIHJ1bGVzLmx0ZV0pIDogJydIARKBAQoCaW4YBiADKAZCdcJIcgpwCgpmaXhlZDY0LmluGmIhKHRoaXMgaW4gZ2V0RmllbGQocnVsZXMsICdpbicpKSA/ICd2YWx1ZSBtdXN0IGJlIGluIGxpc3QgJXMnLmZvcm1hdChbZ2V0RmllbGQocnVsZXMsICdpbicpXSkgOiAnJxJ4CgZub3RfaW4YByADKAZCaMJIZQpjCg5maXhlZDY0Lm5vdF9pbhpRdGhpcyBpbiBydWxlcy5ub3RfaW4gPyAndmFsdWUgbXVzdCBub3QgYmUgaW4gbGlzdCAlcycuZm9ybWF0KFtydWxlcy5ub3RfaW5dKSA6ICcnEi0KB2V4YW1wbGUYCCADKAZCHMJIGQoXCg9maXhlZDY0LmV4YW1wbGUaBHRydWUqCQjoBxCAgICAAkILCglsZXNzX3RoYW5CDgoMZ3JlYXRlcl90aGFuIsAVCg1TRml4ZWQzMlJ1bGVzEoYBCgVjb25zdBgBIAEoD0J3wkh0CnIKDnNmaXhlZDMyLmNvbnN0GmB0aGlzICE9IGdldEZpZWxkKHJ1bGVzLCAnY29uc3QnKSA/ICd2YWx1ZSBtdXN0IGVxdWFsICVzJy5mb3JtYXQoW2dldEZpZWxkKHJ1bGVzLCAnY29uc3QnKV0pIDogJycSjQEKAmx0GAIgASgPQn/CSHwKegoLc2ZpeGVkMzIubHQaayFoYXMocnVsZXMuZ3RlKSAmJiAhaGFzKHJ1bGVzLmd0KSAmJiB0aGlzID49IHJ1bGVzLmx0PyAndmFsdWUgbXVzdCBiZSBsZXNzIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMubHRdKSA6ICcnSAASnwEKA2x0ZRgDIAEoD0KPAcJIiwEKiAEKDHNmaXhlZDMyLmx0ZRp4IWhhcyhydWxlcy5ndGUpICYmICFoYXMocnVsZXMuZ3QpICYmIHRoaXMgPiBydWxlcy5sdGU/ICd2YWx1ZSBtdXN0IGJlIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5sdGVdKSA6ICcnSAASpgcKAmd0GAQgASgPQpcHwkiTBwp9CgtzZml4ZWQzMi5ndBpuIWhhcyhydWxlcy5sdCkgJiYgIWhhcyhydWxlcy5sdGUpICYmIHRoaXMgPD0gcnVsZXMuZ3Q/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndF0pIDogJycKtgEKDnNmaXhlZDMyLmd0X2x0GqMBaGFzKHJ1bGVzLmx0KSAmJiBydWxlcy5sdCA+PSBydWxlcy5ndCAmJiAodGhpcyA+PSBydWxlcy5sdCB8fCB0aGlzIDw9IHJ1bGVzLmd0KT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuICVzIGFuZCBsZXNzIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3QsIHJ1bGVzLmx0XSkgOiAnJwq+AQoYc2ZpeGVkMzIuZ3RfbHRfZXhjbHVzaXZlGqEBaGFzKHJ1bGVzLmx0KSAmJiBydWxlcy5sdCA8IHJ1bGVzLmd0ICYmIChydWxlcy5sdCA8PSB0aGlzICYmIHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgb3IgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdF0pIDogJycKxgEKD3NmaXhlZDMyLmd0X2x0ZRqyAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA+PSBydWxlcy5ndCAmJiAodGhpcyA+IHJ1bGVzLmx0ZSB8fCB0aGlzIDw9IHJ1bGVzLmd0KT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuICVzIGFuZCBsZXNzIHRoYW4gb3IgZXF1YWwgdG8gJXMnLmZvcm1hdChbcnVsZXMuZ3QsIHJ1bGVzLmx0ZV0pIDogJycKzgEKGXNmaXhlZDMyLmd0X2x0ZV9leGNsdXNpdmUasAFoYXMocnVsZXMubHRlKSAmJiBydWxlcy5sdGUgPCBydWxlcy5ndCAmJiAocnVsZXMubHRlIDwgdGhpcyAmJiB0aGlzIDw9IHJ1bGVzLmd0KT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuICVzIG9yIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5ndCwgcnVsZXMubHRlXSkgOiAnJ0gBEvIHCgNndGUYBSABKA9C4gfCSN4HCosBCgxzZml4ZWQzMi5ndGUaeyFoYXMocnVsZXMubHQpICYmICFoYXMocnVsZXMubHRlKSAmJiB0aGlzIDwgcnVsZXMuZ3RlPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMnLmZvcm1hdChbcnVsZXMuZ3RlXSkgOiAnJwrFAQoPc2ZpeGVkMzIuZ3RlX2x0GrEBaGFzKHJ1bGVzLmx0KSAmJiBydWxlcy5sdCA+PSBydWxlcy5ndGUgJiYgKHRoaXMgPj0gcnVsZXMubHQgfHwgdGhpcyA8IHJ1bGVzLmd0ZSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcyBhbmQgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRdKSA6ICcnCs0BChlzZml4ZWQzMi5ndGVfbHRfZXhjbHVzaXZlGq8BaGFzKHJ1bGVzLmx0KSAmJiBydWxlcy5sdCA8IHJ1bGVzLmd0ZSAmJiAocnVsZXMubHQgPD0gdGhpcyAmJiB0aGlzIDwgcnVsZXMuZ3RlKT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzIG9yIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndGUsIHJ1bGVzLmx0XSkgOiAnJwrVAQoQc2ZpeGVkMzIuZ3RlX2x0ZRrAAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA+PSBydWxlcy5ndGUgJiYgKHRoaXMgPiBydWxlcy5sdGUgfHwgdGhpcyA8IHJ1bGVzLmd0ZSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcyBhbmQgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRlXSkgOiAnJwrdAQoac2ZpeGVkMzIuZ3RlX2x0ZV9leGNsdXNpdmUavgFoYXMocnVsZXMubHRlKSAmJiBydWxlcy5sdGUgPCBydWxlcy5ndGUgJiYgKHJ1bGVzLmx0ZSA8IHRoaXMgJiYgdGhpcyA8IHJ1bGVzLmd0ZSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcyBvciBsZXNzIHRoYW4gb3IgZXF1YWwgdG8gJXMnLmZvcm1hdChbcnVsZXMuZ3RlLCBydWxlcy5sdGVdKSA6ICcnSAESggEKAmluGAYgAygPQnbCSHMKcQoLc2ZpeGVkMzIuaW4aYiEodGhpcyBpbiBnZXRGaWVsZChydWxlcywgJ2luJykpID8gJ3ZhbHVlIG11c3QgYmUgaW4gbGlzdCAlcycuZm9ybWF0KFtnZXRGaWVsZChydWxlcywgJ2luJyldKSA6ICcnEnkKBm5vdF9pbhgHIAMoD0JpwkhmCmQKD3NmaXhlZDMyLm5vdF9pbhpRdGhpcyBpbiBydWxlcy5ub3RfaW4gPyAndmFsdWUgbXVzdCBub3QgYmUgaW4gbGlzdCAlcycuZm9ybWF0KFtydWxlcy5ub3RfaW5dKSA6ICcnEi4KB2V4YW1wbGUYCCADKA9CHcJIGgoYChBzZml4ZWQzMi5leGFtcGxlGgR0cnVlKgkI6AcQgICAgAJCCwoJbGVzc190aGFuQg4KDGdyZWF0ZXJfdGhhbiLAFQoNU0ZpeGVkNjRSdWxlcxKGAQoFY29uc3QYASABKBBCd8JIdApyCg5zZml4ZWQ2NC5jb25zdBpgdGhpcyAhPSBnZXRGaWVsZChydWxlcywgJ2NvbnN0JykgPyAndmFsdWUgbXVzdCBlcXVhbCAlcycuZm9ybWF0KFtnZXRGaWVsZChydWxlcywgJ2NvbnN0JyldKSA6ICcnEo0BCgJsdBgCIAEoEEJ/wkh8CnoKC3NmaXhlZDY0Lmx0GmshaGFzKHJ1bGVzLmd0ZSkgJiYgIWhhcyhydWxlcy5ndCkgJiYgdGhpcyA+PSBydWxlcy5sdD8gJ3ZhbHVlIG11c3QgYmUgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmx0XSkgOiAnJ0gAEp8BCgNsdGUYAyABKBBCjwHCSIsBCogBCgxzZml4ZWQ2NC5sdGUaeCFoYXMocnVsZXMuZ3RlKSAmJiAhaGFzKHJ1bGVzLmd0KSAmJiB0aGlzID4gcnVsZXMubHRlPyAndmFsdWUgbXVzdCBiZSBsZXNzIHRoYW4gb3IgZXF1YWwgdG8gJXMnLmZvcm1hdChbcnVsZXMubHRlXSkgOiAnJ0gAEqYHCgJndBgEIAEoEEKXB8JIkwcKfQoLc2ZpeGVkNjQuZ3QabiFoYXMocnVsZXMubHQpICYmICFoYXMocnVsZXMubHRlKSAmJiB0aGlzIDw9IHJ1bGVzLmd0PyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3RdKSA6ICcnCrYBCg5zZml4ZWQ2NC5ndF9sdBqjAWhhcyhydWxlcy5sdCkgJiYgcnVsZXMubHQgPj0gcnVsZXMuZ3QgJiYgKHRoaXMgPj0gcnVsZXMubHQgfHwgdGhpcyA8PSBydWxlcy5ndCk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcyBhbmQgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdF0pIDogJycKvgEKGHNmaXhlZDY0Lmd0X2x0X2V4Y2x1c2l2ZRqhAWhhcyhydWxlcy5sdCkgJiYgcnVsZXMubHQgPCBydWxlcy5ndCAmJiAocnVsZXMubHQgPD0gdGhpcyAmJiB0aGlzIDw9IHJ1bGVzLmd0KT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuICVzIG9yIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndCwgcnVsZXMubHRdKSA6ICcnCsYBCg9zZml4ZWQ2NC5ndF9sdGUasgFoYXMocnVsZXMubHRlKSAmJiBydWxlcy5sdGUgPj0gcnVsZXMuZ3QgJiYgKHRoaXMgPiBydWxlcy5sdGUgfHwgdGhpcyA8PSBydWxlcy5ndCk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcyBhbmQgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdGVdKSA6ICcnCs4BChlzZml4ZWQ2NC5ndF9sdGVfZXhjbHVzaXZlGrABaGFzKHJ1bGVzLmx0ZSkgJiYgcnVsZXMubHRlIDwgcnVsZXMuZ3QgJiYgKHJ1bGVzLmx0ZSA8IHRoaXMgJiYgdGhpcyA8PSBydWxlcy5ndCk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcyBvciBsZXNzIHRoYW4gb3IgZXF1YWwgdG8gJXMnLmZvcm1hdChbcnVsZXMuZ3QsIHJ1bGVzLmx0ZV0pIDogJydIARLyBwoDZ3RlGAUgASgQQuIHwkjeBwqLAQoMc2ZpeGVkNjQuZ3RlGnshaGFzKHJ1bGVzLmx0KSAmJiAhaGFzKHJ1bGVzLmx0ZSkgJiYgdGhpcyA8IHJ1bGVzLmd0ZT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0ZV0pIDogJycKxQEKD3NmaXhlZDY0Lmd0ZV9sdBqxAWhhcyhydWxlcy5sdCkgJiYgcnVsZXMubHQgPj0gcnVsZXMuZ3RlICYmICh0aGlzID49IHJ1bGVzLmx0IHx8IHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgYW5kIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndGUsIHJ1bGVzLmx0XSkgOiAnJwrNAQoZc2ZpeGVkNjQuZ3RlX2x0X2V4Y2x1c2l2ZRqvAWhhcyhydWxlcy5sdCkgJiYgcnVsZXMubHQgPCBydWxlcy5ndGUgJiYgKHJ1bGVzLmx0IDw9IHRoaXMgJiYgdGhpcyA8IHJ1bGVzLmd0ZSk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcyBvciBsZXNzIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3RlLCBydWxlcy5sdF0pIDogJycK1QEKEHNmaXhlZDY0Lmd0ZV9sdGUawAFoYXMocnVsZXMubHRlKSAmJiBydWxlcy5sdGUgPj0gcnVsZXMuZ3RlICYmICh0aGlzID4gcnVsZXMubHRlIHx8IHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgYW5kIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5ndGUsIHJ1bGVzLmx0ZV0pIDogJycK3QEKGnNmaXhlZDY0Lmd0ZV9sdGVfZXhjbHVzaXZlGr4BaGFzKHJ1bGVzLmx0ZSkgJiYgcnVsZXMubHRlIDwgcnVsZXMuZ3RlICYmIChydWxlcy5sdGUgPCB0aGlzICYmIHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgb3IgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRlXSkgOiAnJ0gBEoIBCgJpbhgGIAMoEEJ2wkhzCnEKC3NmaXhlZDY0LmluGmIhKHRoaXMgaW4gZ2V0RmllbGQocnVsZXMsICdpbicpKSA/ICd2YWx1ZSBtdXN0IGJlIGluIGxpc3QgJXMnLmZvcm1hdChbZ2V0RmllbGQocnVsZXMsICdpbicpXSkgOiAnJxJ5CgZub3RfaW4YByADKBBCacJIZgpkCg9zZml4ZWQ2NC5ub3RfaW4aUXRoaXMgaW4gcnVsZXMubm90X2luID8gJ3ZhbHVlIG11c3Qgbm90IGJlIGluIGxpc3QgJXMnLmZvcm1hdChbcnVsZXMubm90X2luXSkgOiAnJxIuCgdleGFtcGxlGAggAygQQh3CSBoKGAoQc2ZpeGVkNjQuZXhhbXBsZRoEdHJ1ZSoJCOgHEICAgIACQgsKCWxlc3NfdGhhbkIOCgxncmVhdGVyX3RoYW4ixwEKCUJvb2xSdWxlcxKCAQoFY29uc3QYASABKAhCc8JIcApuCgpib29sLmNvbnN0GmB0aGlzICE9IGdldEZpZWxkKHJ1bGVzLCAnY29uc3QnKSA/ICd2YWx1ZSBtdXN0IGVxdWFsICVzJy5mb3JtYXQoW2dldEZpZWxkKHJ1bGVzLCAnY29uc3QnKV0pIDogJycSKgoHZXhhbXBsZRgCIAMoCEIZwkgWChQKDGJvb2wuZXhhbXBsZRoEdHJ1ZSoJCOgHEICAgIACIpA3CgtTdHJpbmdSdWxlcxKGAQoFY29uc3QYASABKAlCd8JIdApyCgxzdHJpbmcuY29uc3QaYnRoaXMgIT0gZ2V0RmllbGQocnVsZXMsICdjb25zdCcpID8gJ3ZhbHVlIG11c3QgZXF1YWwgYCVzYCcuZm9ybWF0KFtnZXRGaWVsZChydWxlcywgJ2NvbnN0JyldKSA6ICcnEn4KA2xlbhgTIAEoBEJxwkhuCmwKCnN0cmluZy5sZW4aXnVpbnQodGhpcy5zaXplKCkpICE9IHJ1bGVzLmxlbiA/ICd2YWx1ZSBsZW5ndGggbXVzdCBiZSAlcyBjaGFyYWN0ZXJzJy5mb3JtYXQoW3J1bGVzLmxlbl0pIDogJycSmQEKB21pbl9sZW4YAiABKARChwHCSIMBCoABCg5zdHJpbmcubWluX2xlbhpudWludCh0aGlzLnNpemUoKSkgPCBydWxlcy5taW5fbGVuID8gJ3ZhbHVlIGxlbmd0aCBtdXN0IGJlIGF0IGxlYXN0ICVzIGNoYXJhY3RlcnMnLmZvcm1hdChbcnVsZXMubWluX2xlbl0pIDogJycSlwEKB21heF9sZW4YAyABKARChQHCSIEBCn8KDnN0cmluZy5tYXhfbGVuGm11aW50KHRoaXMuc2l6ZSgpKSA+IHJ1bGVzLm1heF9sZW4gPyAndmFsdWUgbGVuZ3RoIG11c3QgYmUgYXQgbW9zdCAlcyBjaGFyYWN0ZXJzJy5mb3JtYXQoW3J1bGVzLm1heF9sZW5dKSA6ICcnEpsBCglsZW5fYnl0ZXMYFCABKARChwHCSIMBCoABChBzdHJpbmcubGVuX2J5dGVzGmx1aW50KGJ5dGVzKHRoaXMpLnNpemUoKSkgIT0gcnVsZXMubGVuX2J5dGVzID8gJ3ZhbHVlIGxlbmd0aCBtdXN0IGJlICVzIGJ5dGVzJy5mb3JtYXQoW3J1bGVzLmxlbl9ieXRlc10pIDogJycSowEKCW1pbl9ieXRlcxgEIAEoBEKPAcJIiwEKiAEKEHN0cmluZy5taW5fYnl0ZXMadHVpbnQoYnl0ZXModGhpcykuc2l6ZSgpKSA8IHJ1bGVzLm1pbl9ieXRlcyA/ICd2YWx1ZSBsZW5ndGggbXVzdCBiZSBhdCBsZWFzdCAlcyBieXRlcycuZm9ybWF0KFtydWxlcy5taW5fYnl0ZXNdKSA6ICcnEqIBCgltYXhfYnl0ZXMYBSABKARCjgHCSIoBCocBChBzdHJpbmcubWF4X2J5dGVzGnN1aW50KGJ5dGVzKHRoaXMpLnNpemUoKSkgPiBydWxlcy5tYXhfYnl0ZXMgPyAndmFsdWUgbGVuZ3RoIG11c3QgYmUgYXQgbW9zdCAlcyBieXRlcycuZm9ybWF0KFtydWxlcy5tYXhfYnl0ZXNdKSA6ICcnEo0BCgdwYXR0ZXJuGAYgASgJQnzCSHkKdwoOc3RyaW5nLnBhdHRlcm4aZSF0aGlzLm1hdGNoZXMocnVsZXMucGF0dGVybikgPyAndmFsdWUgZG9lcyBub3QgbWF0Y2ggcmVnZXggcGF0dGVybiBgJXNgJy5mb3JtYXQoW3J1bGVzLnBhdHRlcm5dKSA6ICcnEoQBCgZwcmVmaXgYByABKAlCdMJIcQpvCg1zdHJpbmcucHJlZml4Gl4hdGhpcy5zdGFydHNXaXRoKHJ1bGVzLnByZWZpeCkgPyAndmFsdWUgZG9lcyBub3QgaGF2ZSBwcmVmaXggYCVzYCcuZm9ybWF0KFtydWxlcy5wcmVmaXhdKSA6ICcnEoIBCgZzdWZmaXgYCCABKAlCcsJIbwptCg1zdHJpbmcuc3VmZml4GlwhdGhpcy5lbmRzV2l0aChydWxlcy5zdWZmaXgpID8gJ3ZhbHVlIGRvZXMgbm90IGhhdmUgc3VmZml4IGAlc2AnLmZvcm1hdChbcnVsZXMuc3VmZml4XSkgOiAnJxKQAQoIY29udGFpbnMYCSABKAlCfsJIewp5Cg9zdHJpbmcuY29udGFpbnMaZiF0aGlzLmNvbnRhaW5zKHJ1bGVzLmNvbnRhaW5zKSA/ICd2YWx1ZSBkb2VzIG5vdCBjb250YWluIHN1YnN0cmluZyBgJXNgJy5mb3JtYXQoW3J1bGVzLmNvbnRhaW5zXSkgOiAnJxKYAQoMbm90X2NvbnRhaW5zGBcgASgJQoEBwkh+CnwKE3N0cmluZy5ub3RfY29udGFpbnMaZXRoaXMuY29udGFpbnMocnVsZXMubm90X2NvbnRhaW5zKSA/ICd2YWx1ZSBjb250YWlucyBzdWJzdHJpbmcgYCVzYCcuZm9ybWF0KFtydWxlcy5ub3RfY29udGFpbnNdKSA6ICcnEoABCgJpbhgKIAMoCUJ0wkhxCm8KCXN0cmluZy5pbhpiISh0aGlzIGluIGdldEZpZWxkKHJ1bGVzLCAnaW4nKSkgPyAndmFsdWUgbXVzdCBiZSBpbiBsaXN0ICVzJy5mb3JtYXQoW2dldEZpZWxkKHJ1bGVzLCAnaW4nKV0pIDogJycSdwoGbm90X2luGAsgAygJQmfCSGQKYgoNc3RyaW5nLm5vdF9pbhpRdGhpcyBpbiBydWxlcy5ub3RfaW4gPyAndmFsdWUgbXVzdCBub3QgYmUgaW4gbGlzdCAlcycuZm9ybWF0KFtydWxlcy5ub3RfaW5dKSA6ICcnEt8BCgVlbWFpbBgMIAEoCELNAcJIyQEKYQoMc3RyaW5nLmVtYWlsEiN2YWx1ZSBtdXN0IGJlIGEgdmFsaWQgZW1haWwgYWRkcmVzcxosIXJ1bGVzLmVtYWlsIHx8IHRoaXMgPT0gJycgfHwgdGhpcy5pc0VtYWlsKCkKZAoSc3RyaW5nLmVtYWlsX2VtcHR5EjJ2YWx1ZSBpcyBlbXB0eSwgd2hpY2ggaXMgbm90IGEgdmFsaWQgZW1haWwgYWRkcmVzcxoaIXJ1bGVzLmVtYWlsIHx8IHRoaXMgIT0gJydIABLnAQoIaG9zdG5hbWUYDSABKAhC0gHCSM4BCmUKD3N0cmluZy5ob3N0bmFtZRIedmFsdWUgbXVzdCBiZSBhIHZhbGlkIGhvc3RuYW1lGjIhcnVsZXMuaG9zdG5hbWUgfHwgdGhpcyA9PSAnJyB8fCB0aGlzLmlzSG9zdG5hbWUoKQplChVzdHJpbmcuaG9zdG5hbWVfZW1wdHkSLXZhbHVlIGlzIGVtcHR5LCB3aGljaCBpcyBub3QgYSB2YWxpZCBob3N0bmFtZRodIXJ1bGVzLmhvc3RuYW1lIHx8IHRoaXMgIT0gJydIABLHAQoCaXAYDiABKAhCuAHCSLQBClUKCXN0cmluZy5pcBIgdmFsdWUgbXVzdCBiZSBhIHZhbGlkIElQIGFkZHJlc3MaJiFydWxlcy5pcCB8fCB0aGlzID09ICcnIHx8IHRoaXMuaXNJcCgpClsKD3N0cmluZy5pcF9lbXB0eRIvdmFsdWUgaXMgZW1wdHksIHdoaWNoIGlzIG5vdCBhIHZhbGlkIElQIGFkZHJlc3MaFyFydWxlcy5pcCB8fCB0aGlzICE9ICcnSAAS1gEKBGlwdjQYDyABKAhCxQHCSMEBClwKC3N0cmluZy5pcHY0EiJ2YWx1ZSBtdXN0IGJlIGEgdmFsaWQgSVB2NCBhZGRyZXNzGikhcnVsZXMuaXB2NCB8fCB0aGlzID09ICcnIHx8IHRoaXMuaXNJcCg0KQphChFzdHJpbmcuaXB2NF9lbXB0eRIxdmFsdWUgaXMgZW1wdHksIHdoaWNoIGlzIG5vdCBhIHZhbGlkIElQdjQgYWRkcmVzcxoZIXJ1bGVzLmlwdjQgfHwgdGhpcyAhPSAnJ0gAEtYBCgRpcHY2GBAgASgIQsUBwkjBAQpcCgtzdHJpbmcuaXB2NhIidmFsdWUgbXVzdCBiZSBhIHZhbGlkIElQdjYgYWRkcmVzcxopIXJ1bGVzLmlwdjYgfHwgdGhpcyA9PSAnJyB8fCB0aGlzLmlzSXAoNikKYQoRc3RyaW5nLmlwdjZfZW1wdHkSMXZhbHVlIGlzIGVtcHR5LCB3aGljaCBpcyBub3QgYSB2YWxpZCBJUHY2IGFkZHJlc3MaGSFydWxlcy5pcHY2IHx8IHRoaXMgIT0gJydIABK/AQoDdXJpGBEgASgIQq8BwkirAQpRCgpzdHJpbmcudXJpEhl2YWx1ZSBtdXN0IGJlIGEgdmFsaWQgVVJJGighcnVsZXMudXJpIHx8IHRoaXMgPT0gJycgfHwgdGhpcy5pc1VyaSgpClYKEHN0cmluZy51cmlfZW1wdHkSKHZhbHVlIGlzIGVtcHR5LCB3aGljaCBpcyBub3QgYSB2YWxpZCBVUkkaGCFydWxlcy51cmkgfHwgdGhpcyAhPSAnJ0gAEnAKB3VyaV9yZWYYEiABKAhCXcJIWgpYCg5zdHJpbmcudXJpX3JlZhIjdmFsdWUgbXVzdCBiZSBhIHZhbGlkIFVSSSBSZWZlcmVuY2UaISFydWxlcy51cmlfcmVmIHx8IHRoaXMuaXNVcmlSZWYoKUgAEpACCgdhZGRyZXNzGBUgASgIQvwBwkj4AQqBAQoOc3RyaW5nLmFkZHJlc3MSLXZhbHVlIG11c3QgYmUgYSB2YWxpZCBob3N0bmFtZSwgb3IgaXAgYWRkcmVzcxpAIXJ1bGVzLmFkZHJlc3MgfHwgdGhpcyA9PSAnJyB8fCB0aGlzLmlzSG9zdG5hbWUoKSB8fCB0aGlzLmlzSXAoKQpyChRzdHJpbmcuYWRkcmVzc19lbXB0eRI8dmFsdWUgaXMgZW1wdHksIHdoaWNoIGlzIG5vdCBhIHZhbGlkIGhvc3RuYW1lLCBvciBpcCBhZGRyZXNzGhwhcnVsZXMuYWRkcmVzcyB8fCB0aGlzICE9ICcnSAASmAIKBHV1aWQYFiABKAhChwLCSIMCCqUBCgtzdHJpbmcudXVpZBIadmFsdWUgbXVzdCBiZSBhIHZhbGlkIFVVSUQaeiFydWxlcy51dWlkIHx8IHRoaXMgPT0gJycgfHwgdGhpcy5tYXRjaGVzKCdeWzAtOWEtZkEtRl17OH0tWzAtOWEtZkEtRl17NH0tWzAtOWEtZkEtRl17NH0tWzAtOWEtZkEtRl17NH0tWzAtOWEtZkEtRl17MTJ9JCcpClkKEXN0cmluZy51dWlkX2VtcHR5Eil2YWx1ZSBpcyBlbXB0eSwgd2hpY2ggaXMgbm90IGEgdmFsaWQgVVVJRBoZIXJ1bGVzLnV1aWQgfHwgdGhpcyAhPSAnJ0gAEvABCgV0dXVpZBghIAEoCELeAcJI2gEKcwoMc3RyaW5nLnR1dWlkEiJ2YWx1ZSBtdXN0IGJlIGEgdmFsaWQgdHJpbW1lZCBVVUlEGj8hcnVsZXMudHV1aWQgfHwgdGhpcyA9PSAnJyB8fCB0aGlzLm1hdGNoZXMoJ15bMC05YS1mQS1GXXszMn0kJykKYwoSc3RyaW5nLnR1dWlkX2VtcHR5EjF2YWx1ZSBpcyBlbXB0eSwgd2hpY2ggaXMgbm90IGEgdmFsaWQgdHJpbW1lZCBVVUlEGhohcnVsZXMudHV1aWQgfHwgdGhpcyAhPSAnJ0gAEpYCChFpcF93aXRoX3ByZWZpeGxlbhgaIAEoCEL4AcJI9AEKeAoYc3RyaW5nLmlwX3dpdGhfcHJlZml4bGVuEh92YWx1ZSBtdXN0IGJlIGEgdmFsaWQgSVAgcHJlZml4GjshcnVsZXMuaXBfd2l0aF9wcmVmaXhsZW4gfHwgdGhpcyA9PSAnJyB8fCB0aGlzLmlzSXBQcmVmaXgoKQp4Ch5zdHJpbmcuaXBfd2l0aF9wcmVmaXhsZW5fZW1wdHkSLnZhbHVlIGlzIGVtcHR5LCB3aGljaCBpcyBub3QgYSB2YWxpZCBJUCBwcmVmaXgaJiFydWxlcy5pcF93aXRoX3ByZWZpeGxlbiB8fCB0aGlzICE9ICcnSAASzwIKE2lwdjRfd2l0aF9wcmVmaXhsZW4YGyABKAhCrwLCSKsCCpMBChpzdHJpbmcuaXB2NF93aXRoX3ByZWZpeGxlbhI1dmFsdWUgbXVzdCBiZSBhIHZhbGlkIElQdjQgYWRkcmVzcyB3aXRoIHByZWZpeCBsZW5ndGgaPiFydWxlcy5pcHY0X3dpdGhfcHJlZml4bGVuIHx8IHRoaXMgPT0gJycgfHwgdGhpcy5pc0lwUHJlZml4KDQpCpIBCiBzdHJpbmcuaXB2NF93aXRoX3ByZWZpeGxlbl9lbXB0eRJEdmFsdWUgaXMgZW1wdHksIHdoaWNoIGlzIG5vdCBhIHZhbGlkIElQdjQgYWRkcmVzcyB3aXRoIHByZWZpeCBsZW5ndGgaKCFydWxlcy5pcHY0X3dpdGhfcHJlZml4bGVuIHx8IHRoaXMgIT0gJydIABLPAgoTaXB2Nl93aXRoX3ByZWZpeGxlbhgcIAEoCEKvAsJIqwIKkwEKGnN0cmluZy5pcHY2X3dpdGhfcHJlZml4bGVuEjV2YWx1ZSBtdXN0IGJlIGEgdmFsaWQgSVB2NiBhZGRyZXNzIHdpdGggcHJlZml4IGxlbmd0aBo+IXJ1bGVzLmlwdjZfd2l0aF9wcmVmaXhsZW4gfHwgdGhpcyA9PSAnJyB8fCB0aGlzLmlzSXBQcmVmaXgoNikKkgEKIHN0cmluZy5pcHY2X3dpdGhfcHJlZml4bGVuX2VtcHR5EkR2YWx1ZSBpcyBlbXB0eSwgd2hpY2ggaXMgbm90IGEgdmFsaWQgSVB2NiBhZGRyZXNzIHdpdGggcHJlZml4IGxlbmd0aBooIXJ1bGVzLmlwdjZfd2l0aF9wcmVmaXhsZW4gfHwgdGhpcyAhPSAnJ0gAEvIBCglpcF9wcmVmaXgYHSABKAhC3AHCSNgBCmwKEHN0cmluZy5pcF9wcmVmaXgSH3ZhbHVlIG11c3QgYmUgYSB2YWxpZCBJUCBwcmVmaXgaNyFydWxlcy5pcF9wcmVmaXggfHwgdGhpcyA9PSAnJyB8fCB0aGlzLmlzSXBQcmVmaXgodHJ1ZSkKaAoWc3RyaW5nLmlwX3ByZWZpeF9lbXB0eRIudmFsdWUgaXMgZW1wdHksIHdoaWNoIGlzIG5vdCBhIHZhbGlkIElQIHByZWZpeBoeIXJ1bGVzLmlwX3ByZWZpeCB8fCB0aGlzICE9ICcnSAASgwIKC2lwdjRfcHJlZml4GB4gASgIQusBwkjnAQp1ChJzdHJpbmcuaXB2NF9wcmVmaXgSIXZhbHVlIG11c3QgYmUgYSB2YWxpZCBJUHY0IHByZWZpeBo8IXJ1bGVzLmlwdjRfcHJlZml4IHx8IHRoaXMgPT0gJycgfHwgdGhpcy5pc0lwUHJlZml4KDQsIHRydWUpCm4KGHN0cmluZy5pcHY0X3ByZWZpeF9lbXB0eRIwdmFsdWUgaXMgZW1wdHksIHdoaWNoIGlzIG5vdCBhIHZhbGlkIElQdjQgcHJlZml4GiAhcnVsZXMuaXB2NF9wcmVmaXggfHwgdGhpcyAhPSAnJ0gAEoMCCgtpcHY2X3ByZWZpeBgfIAEoCELrAcJI5wEKdQoSc3RyaW5nLmlwdjZfcHJlZml4EiF2YWx1ZSBtdXN0IGJlIGEgdmFsaWQgSVB2NiBwcmVmaXgaPCFydWxlcy5pcHY2X3ByZWZpeCB8fCB0aGlzID09ICcnIHx8IHRoaXMuaXNJcFByZWZpeCg2LCB0cnVlKQpuChhzdHJpbmcuaXB2Nl9wcmVmaXhfZW1wdHkSMHZhbHVlIGlzIGVtcHR5LCB3aGljaCBpcyBub3QgYSB2YWxpZCBJUHY2IHByZWZpeBogIXJ1bGVzLmlwdjZfcHJlZml4IHx8IHRoaXMgIT0gJydIABK1AgoNaG9zdF9hbmRfcG9ydBggIAEoCEKbAsJIlwIKmQEKFHN0cmluZy5ob3N0X2FuZF9wb3J0EkF2YWx1ZSBtdXN0IGJlIGEgdmFsaWQgaG9zdCAoaG9zdG5hbWUgb3IgSVAgYWRkcmVzcykgYW5kIHBvcnQgcGFpcho+IXJ1bGVzLmhvc3RfYW5kX3BvcnQgfHwgdGhpcyA9PSAnJyB8fCB0aGlzLmlzSG9zdEFuZFBvcnQodHJ1ZSkKeQoac3RyaW5nLmhvc3RfYW5kX3BvcnRfZW1wdHkSN3ZhbHVlIGlzIGVtcHR5LCB3aGljaCBpcyBub3QgYSB2YWxpZCBob3N0IGFuZCBwb3J0IHBhaXIaIiFydWxlcy5ob3N0X2FuZF9wb3J0IHx8IHRoaXMgIT0gJydIABKoBQoQd2VsbF9rbm93bl9yZWdleBgYIAEoDjIYLmJ1Zi52YWxpZGF0ZS5Lbm93blJlZ2V4QvEEwkjtBArwAQojc3RyaW5nLndlbGxfa25vd25fcmVnZXguaGVhZGVyX25hbWUSJnZhbHVlIG11c3QgYmUgYSB2YWxpZCBIVFRQIGhlYWRlciBuYW1lGqABcnVsZXMud2VsbF9rbm93bl9yZWdleCAhPSAxIHx8IHRoaXMgPT0gJycgfHwgdGhpcy5tYXRjaGVzKCFoYXMocnVsZXMuc3RyaWN0KSB8fCBydWxlcy5zdHJpY3QgPydeOj9bMC05YS16QS1aISMkJSZcJyorLS5eX3x+XHg2MF0rJCcgOideW15cdTAwMDBcdTAwMEFcdTAwMERdKyQnKQqNAQopc3RyaW5nLndlbGxfa25vd25fcmVnZXguaGVhZGVyX25hbWVfZW1wdHkSNXZhbHVlIGlzIGVtcHR5LCB3aGljaCBpcyBub3QgYSB2YWxpZCBIVFRQIGhlYWRlciBuYW1lGilydWxlcy53ZWxsX2tub3duX3JlZ2V4ICE9IDEgfHwgdGhpcyAhPSAnJwrnAQokc3RyaW5nLndlbGxfa25vd25fcmVnZXguaGVhZGVyX3ZhbHVlEid2YWx1ZSBtdXN0IGJlIGEgdmFsaWQgSFRUUCBoZWFkZXIgdmFsdWUalQFydWxlcy53ZWxsX2tub3duX3JlZ2V4ICE9IDIgfHwgdGhpcy5tYXRjaGVzKCFoYXMocnVsZXMuc3RyaWN0KSB8fCBydWxlcy5zdHJpY3QgPydeW15cdTAwMDAtXHUwMDA4XHUwMDBBLVx1MDAxRlx1MDA3Rl0qJCcgOideW15cdTAwMDBcdTAwMEFcdTAwMERdKiQnKUgAEg4KBnN0cmljdBgZIAEoCBIsCgdleGFtcGxlGCIgAygJQhvCSBgKFgoOc3RyaW5nLmV4YW1wbGUaBHRydWUqCQjoBxCAgICAAkIMCgp3ZWxsX2tub3duIuoQCgpCeXRlc1J1bGVzEoABCgVjb25zdBgBIAEoDEJxwkhuCmwKC2J5dGVzLmNvbnN0Gl10aGlzICE9IGdldEZpZWxkKHJ1bGVzLCAnY29uc3QnKSA/ICd2YWx1ZSBtdXN0IGJlICV4Jy5mb3JtYXQoW2dldEZpZWxkKHJ1bGVzLCAnY29uc3QnKV0pIDogJycSeAoDbGVuGA0gASgEQmvCSGgKZgoJYnl0ZXMubGVuGll1aW50KHRoaXMuc2l6ZSgpKSAhPSBydWxlcy5sZW4gPyAndmFsdWUgbGVuZ3RoIG11c3QgYmUgJXMgYnl0ZXMnLmZvcm1hdChbcnVsZXMubGVuXSkgOiAnJxKQAQoHbWluX2xlbhgCIAEoBEJ/wkh8CnoKDWJ5dGVzLm1pbl9sZW4aaXVpbnQodGhpcy5zaXplKCkpIDwgcnVsZXMubWluX2xlbiA/ICd2YWx1ZSBsZW5ndGggbXVzdCBiZSBhdCBsZWFzdCAlcyBieXRlcycuZm9ybWF0KFtydWxlcy5taW5fbGVuXSkgOiAnJxKIAQoHbWF4X2xlbhgDIAEoBEJ3wkh0CnIKDWJ5dGVzLm1heF9sZW4aYXVpbnQodGhpcy5zaXplKCkpID4gcnVsZXMubWF4X2xlbiA/ICd2YWx1ZSBtdXN0IGJlIGF0IG1vc3QgJXMgYnl0ZXMnLmZvcm1hdChbcnVsZXMubWF4X2xlbl0pIDogJycSkAEKB3BhdHRlcm4YBCABKAlCf8JIfAp6Cg1ieXRlcy5wYXR0ZXJuGmkhc3RyaW5nKHRoaXMpLm1hdGNoZXMocnVsZXMucGF0dGVybikgPyAndmFsdWUgbXVzdCBtYXRjaCByZWdleCBwYXR0ZXJuIGAlc2AnLmZvcm1hdChbcnVsZXMucGF0dGVybl0pIDogJycSgQEKBnByZWZpeBgFIAEoDEJxwkhuCmwKDGJ5dGVzLnByZWZpeBpcIXRoaXMuc3RhcnRzV2l0aChydWxlcy5wcmVmaXgpID8gJ3ZhbHVlIGRvZXMgbm90IGhhdmUgcHJlZml4ICV4Jy5mb3JtYXQoW3J1bGVzLnByZWZpeF0pIDogJycSfwoGc3VmZml4GAYgASgMQm/CSGwKagoMYnl0ZXMuc3VmZml4GlohdGhpcy5lbmRzV2l0aChydWxlcy5zdWZmaXgpID8gJ3ZhbHVlIGRvZXMgbm90IGhhdmUgc3VmZml4ICV4Jy5mb3JtYXQoW3J1bGVzLnN1ZmZpeF0pIDogJycSgwEKCGNvbnRhaW5zGAcgASgMQnHCSG4KbAoOYnl0ZXMuY29udGFpbnMaWiF0aGlzLmNvbnRhaW5zKHJ1bGVzLmNvbnRhaW5zKSA/ICd2YWx1ZSBkb2VzIG5vdCBjb250YWluICV4Jy5mb3JtYXQoW3J1bGVzLmNvbnRhaW5zXSkgOiAnJxKnAQoCaW4YCCADKAxCmgHCSJYBCpMBCghieXRlcy5pbhqGAWdldEZpZWxkKHJ1bGVzLCAnaW4nKS5zaXplKCkgPiAwICYmICEodGhpcyBpbiBnZXRGaWVsZChydWxlcywgJ2luJykpID8gJ3ZhbHVlIG11c3QgYmUgaW4gbGlzdCAlcycuZm9ybWF0KFtnZXRGaWVsZChydWxlcywgJ2luJyldKSA6ICcnEnYKBm5vdF9pbhgJIAMoDEJmwkhjCmEKDGJ5dGVzLm5vdF9pbhpRdGhpcyBpbiBydWxlcy5ub3RfaW4gPyAndmFsdWUgbXVzdCBub3QgYmUgaW4gbGlzdCAlcycuZm9ybWF0KFtydWxlcy5ub3RfaW5dKSA6ICcnEusBCgJpcBgKIAEoCELcAcJI2AEKdAoIYnl0ZXMuaXASIHZhbHVlIG11c3QgYmUgYSB2YWxpZCBJUCBhZGRyZXNzGkYhcnVsZXMuaXAgfHwgdGhpcy5zaXplKCkgPT0gMCB8fCB0aGlzLnNpemUoKSA9PSA0IHx8IHRoaXMuc2l6ZSgpID09IDE2CmAKDmJ5dGVzLmlwX2VtcHR5Ei92YWx1ZSBpcyBlbXB0eSwgd2hpY2ggaXMgbm90IGEgdmFsaWQgSVAgYWRkcmVzcxodIXJ1bGVzLmlwIHx8IHRoaXMuc2l6ZSgpICE9IDBIABLkAQoEaXB2NBgLIAEoCELTAcJIzwEKZQoKYnl0ZXMuaXB2NBIidmFsdWUgbXVzdCBiZSBhIHZhbGlkIElQdjQgYWRkcmVzcxozIXJ1bGVzLmlwdjQgfHwgdGhpcy5zaXplKCkgPT0gMCB8fCB0aGlzLnNpemUoKSA9PSA0CmYKEGJ5dGVzLmlwdjRfZW1wdHkSMXZhbHVlIGlzIGVtcHR5LCB3aGljaCBpcyBub3QgYSB2YWxpZCBJUHY0IGFkZHJlc3MaHyFydWxlcy5pcHY0IHx8IHRoaXMuc2l6ZSgpICE9IDBIABLlAQoEaXB2NhgMIAEoCELUAcJI0AEKZgoKYnl0ZXMuaXB2NhIidmFsdWUgbXVzdCBiZSBhIHZhbGlkIElQdjYgYWRkcmVzcxo0IXJ1bGVzLmlwdjYgfHwgdGhpcy5zaXplKCkgPT0gMCB8fCB0aGlzLnNpemUoKSA9PSAxNgpmChBieXRlcy5pcHY2X2VtcHR5EjF2YWx1ZSBpcyBlbXB0eSwgd2hpY2ggaXMgbm90IGEgdmFsaWQgSVB2NiBhZGRyZXNzGh8hcnVsZXMuaXB2NiB8fCB0aGlzLnNpemUoKSAhPSAwSAASKwoHZXhhbXBsZRgOIAMoDEIawkgXChUKDWJ5dGVzLmV4YW1wbGUaBHRydWUqCQjoBxCAgICAAkIMCgp3ZWxsX2tub3duItQDCglFbnVtUnVsZXMSggEKBWNvbnN0GAEgASgFQnPCSHAKbgoKZW51bS5jb25zdBpgdGhpcyAhPSBnZXRGaWVsZChydWxlcywgJ2NvbnN0JykgPyAndmFsdWUgbXVzdCBlcXVhbCAlcycuZm9ybWF0KFtnZXRGaWVsZChydWxlcywgJ2NvbnN0JyldKSA6ICcnEhQKDGRlZmluZWRfb25seRgCIAEoCBJ+CgJpbhgDIAMoBUJywkhvCm0KB2VudW0uaW4aYiEodGhpcyBpbiBnZXRGaWVsZChydWxlcywgJ2luJykpID8gJ3ZhbHVlIG11c3QgYmUgaW4gbGlzdCAlcycuZm9ybWF0KFtnZXRGaWVsZChydWxlcywgJ2luJyldKSA6ICcnEnUKBm5vdF9pbhgEIAMoBUJlwkhiCmAKC2VudW0ubm90X2luGlF0aGlzIGluIHJ1bGVzLm5vdF9pbiA/ICd2YWx1ZSBtdXN0IG5vdCBiZSBpbiBsaXN0ICVzJy5mb3JtYXQoW3J1bGVzLm5vdF9pbl0pIDogJycSKgoHZXhhbXBsZRgFIAMoBUIZwkgWChQKDGVudW0uZXhhbXBsZRoEdHJ1ZSoJCOgHEICAgIACIvsDCg1SZXBlYXRlZFJ1bGVzEp4BCgltaW5faXRlbXMYASABKARCigHCSIYBCoMBChJyZXBlYXRlZC5taW5faXRlbXMabXVpbnQodGhpcy5zaXplKCkpIDwgcnVsZXMubWluX2l0ZW1zID8gJ3ZhbHVlIG11c3QgY29udGFpbiBhdCBsZWFzdCAlZCBpdGVtKHMpJy5mb3JtYXQoW3J1bGVzLm1pbl9pdGVtc10pIDogJycSogEKCW1heF9pdGVtcxgCIAEoBEKOAcJIigEKhwEKEnJlcGVhdGVkLm1heF9pdGVtcxpxdWludCh0aGlzLnNpemUoKSkgPiBydWxlcy5tYXhfaXRlbXMgPyAndmFsdWUgbXVzdCBjb250YWluIG5vIG1vcmUgdGhhbiAlcyBpdGVtKHMpJy5mb3JtYXQoW3J1bGVzLm1heF9pdGVtc10pIDogJycScAoGdW5pcXVlGAMgASgIQmDCSF0KWwoPcmVwZWF0ZWQudW5pcXVlEihyZXBlYXRlZCB2YWx1ZSBtdXN0IGNvbnRhaW4gdW5pcXVlIGl0ZW1zGh4hcnVsZXMudW5pcXVlIHx8IHRoaXMudW5pcXVlKCkSJwoFaXRlbXMYBCABKAsyGC5idWYudmFsaWRhdGUuRmllbGRSdWxlcyoJCOgHEICAgIACIooDCghNYXBSdWxlcxKPAQoJbWluX3BhaXJzGAEgASgEQnzCSHkKdwoNbWFwLm1pbl9wYWlycxpmdWludCh0aGlzLnNpemUoKSkgPCBydWxlcy5taW5fcGFpcnMgPyAnbWFwIG11c3QgYmUgYXQgbGVhc3QgJWQgZW50cmllcycuZm9ybWF0KFtydWxlcy5taW5fcGFpcnNdKSA6ICcnEo4BCgltYXhfcGFpcnMYAiABKARCe8JIeAp2Cg1tYXAubWF4X3BhaXJzGmV1aW50KHRoaXMuc2l6ZSgpKSA+IHJ1bGVzLm1heF9wYWlycyA/ICdtYXAgbXVzdCBiZSBhdCBtb3N0ICVkIGVudHJpZXMnLmZvcm1hdChbcnVsZXMubWF4X3BhaXJzXSkgOiAnJxImCgRrZXlzGAQgASgLMhguYnVmLnZhbGlkYXRlLkZpZWxkUnVsZXMSKAoGdmFsdWVzGAUgASgLMhguYnVmLnZhbGlkYXRlLkZpZWxkUnVsZXMqCQjoBxCAgICAAiImCghBbnlSdWxlcxIKCgJpbhgCIAMoCRIOCgZub3RfaW4YAyADKAkimRcKDUR1cmF0aW9uUnVsZXMSoQEKBWNvbnN0GAIgASgLMhkuZ29vZ2xlLnByb3RvYnVmLkR1cmF0aW9uQnfCSHQKcgoOZHVyYXRpb24uY29uc3QaYHRoaXMgIT0gZ2V0RmllbGQocnVsZXMsICdjb25zdCcpID8gJ3ZhbHVlIG11c3QgZXF1YWwgJXMnLmZvcm1hdChbZ2V0RmllbGQocnVsZXMsICdjb25zdCcpXSkgOiAnJxKoAQoCbHQYAyABKAsyGS5nb29nbGUucHJvdG9idWYuRHVyYXRpb25Cf8JIfAp6CgtkdXJhdGlvbi5sdBprIWhhcyhydWxlcy5ndGUpICYmICFoYXMocnVsZXMuZ3QpICYmIHRoaXMgPj0gcnVsZXMubHQ/ICd2YWx1ZSBtdXN0IGJlIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5sdF0pIDogJydIABK6AQoDbHRlGAQgASgLMhkuZ29vZ2xlLnByb3RvYnVmLkR1cmF0aW9uQo8BwkiLAQqIAQoMZHVyYXRpb24ubHRlGnghaGFzKHJ1bGVzLmd0ZSkgJiYgIWhhcyhydWxlcy5ndCkgJiYgdGhpcyA+IHJ1bGVzLmx0ZT8gJ3ZhbHVlIG11c3QgYmUgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmx0ZV0pIDogJydIABLBBwoCZ3QYBSABKAsyGS5nb29nbGUucHJvdG9idWYuRHVyYXRpb25ClwfCSJMHCn0KC2R1cmF0aW9uLmd0Gm4haGFzKHJ1bGVzLmx0KSAmJiAhaGFzKHJ1bGVzLmx0ZSkgJiYgdGhpcyA8PSBydWxlcy5ndD8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0XSkgOiAnJwq2AQoOZHVyYXRpb24uZ3RfbHQaowFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0ID49IHJ1bGVzLmd0ICYmICh0aGlzID49IHJ1bGVzLmx0IHx8IHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgYW5kIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndCwgcnVsZXMubHRdKSA6ICcnCr4BChhkdXJhdGlvbi5ndF9sdF9leGNsdXNpdmUaoQFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0IDwgcnVsZXMuZ3QgJiYgKHJ1bGVzLmx0IDw9IHRoaXMgJiYgdGhpcyA8PSBydWxlcy5ndCk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcyBvciBsZXNzIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3QsIHJ1bGVzLmx0XSkgOiAnJwrGAQoPZHVyYXRpb24uZ3RfbHRlGrIBaGFzKHJ1bGVzLmx0ZSkgJiYgcnVsZXMubHRlID49IHJ1bGVzLmd0ICYmICh0aGlzID4gcnVsZXMubHRlIHx8IHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgYW5kIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5ndCwgcnVsZXMubHRlXSkgOiAnJwrOAQoZZHVyYXRpb24uZ3RfbHRlX2V4Y2x1c2l2ZRqwAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA8IHJ1bGVzLmd0ICYmIChydWxlcy5sdGUgPCB0aGlzICYmIHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgb3IgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdGVdKSA6ICcnSAESjQgKA2d0ZRgGIAEoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJhdGlvbkLiB8JI3gcKiwEKDGR1cmF0aW9uLmd0ZRp7IWhhcyhydWxlcy5sdCkgJiYgIWhhcyhydWxlcy5sdGUpICYmIHRoaXMgPCBydWxlcy5ndGU/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5ndGVdKSA6ICcnCsUBCg9kdXJhdGlvbi5ndGVfbHQasQFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0ID49IHJ1bGVzLmd0ZSAmJiAodGhpcyA+PSBydWxlcy5sdCB8fCB0aGlzIDwgcnVsZXMuZ3RlKT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzIGFuZCBsZXNzIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3RlLCBydWxlcy5sdF0pIDogJycKzQEKGWR1cmF0aW9uLmd0ZV9sdF9leGNsdXNpdmUarwFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0IDwgcnVsZXMuZ3RlICYmIChydWxlcy5sdCA8PSB0aGlzICYmIHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgb3IgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0ZSwgcnVsZXMubHRdKSA6ICcnCtUBChBkdXJhdGlvbi5ndGVfbHRlGsABaGFzKHJ1bGVzLmx0ZSkgJiYgcnVsZXMubHRlID49IHJ1bGVzLmd0ZSAmJiAodGhpcyA+IHJ1bGVzLmx0ZSB8fCB0aGlzIDwgcnVsZXMuZ3RlKT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzIGFuZCBsZXNzIHRoYW4gb3IgZXF1YWwgdG8gJXMnLmZvcm1hdChbcnVsZXMuZ3RlLCBydWxlcy5sdGVdKSA6ICcnCt0BChpkdXJhdGlvbi5ndGVfbHRlX2V4Y2x1c2l2ZRq+AWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA8IHJ1bGVzLmd0ZSAmJiAocnVsZXMubHRlIDwgdGhpcyAmJiB0aGlzIDwgcnVsZXMuZ3RlKT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzIG9yIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5ndGUsIHJ1bGVzLmx0ZV0pIDogJydIARKdAQoCaW4YByADKAsyGS5nb29nbGUucHJvdG9idWYuRHVyYXRpb25CdsJIcwpxCgtkdXJhdGlvbi5pbhpiISh0aGlzIGluIGdldEZpZWxkKHJ1bGVzLCAnaW4nKSkgPyAndmFsdWUgbXVzdCBiZSBpbiBsaXN0ICVzJy5mb3JtYXQoW2dldEZpZWxkKHJ1bGVzLCAnaW4nKV0pIDogJycSlAEKBm5vdF9pbhgIIAMoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJhdGlvbkJpwkhmCmQKD2R1cmF0aW9uLm5vdF9pbhpRdGhpcyBpbiBydWxlcy5ub3RfaW4gPyAndmFsdWUgbXVzdCBub3QgYmUgaW4gbGlzdCAlcycuZm9ybWF0KFtydWxlcy5ub3RfaW5dKSA6ICcnEkkKB2V4YW1wbGUYCSADKAsyGS5nb29nbGUucHJvdG9idWYuRHVyYXRpb25CHcJIGgoYChBkdXJhdGlvbi5leGFtcGxlGgR0cnVlKgkI6AcQgICAgAJCCwoJbGVzc190aGFuQg4KDGdyZWF0ZXJfdGhhbiKSGAoOVGltZXN0YW1wUnVsZXMSowEKBWNvbnN0GAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEJ4wkh1CnMKD3RpbWVzdGFtcC5jb25zdBpgdGhpcyAhPSBnZXRGaWVsZChydWxlcywgJ2NvbnN0JykgPyAndmFsdWUgbXVzdCBlcXVhbCAlcycuZm9ybWF0KFtnZXRGaWVsZChydWxlcywgJ2NvbnN0JyldKSA6ICcnEqsBCgJsdBgDIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCgAHCSH0KewoMdGltZXN0YW1wLmx0GmshaGFzKHJ1bGVzLmd0ZSkgJiYgIWhhcyhydWxlcy5ndCkgJiYgdGhpcyA+PSBydWxlcy5sdD8gJ3ZhbHVlIG11c3QgYmUgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmx0XSkgOiAnJ0gAErwBCgNsdGUYBCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQpABwkiMAQqJAQoNdGltZXN0YW1wLmx0ZRp4IWhhcyhydWxlcy5ndGUpICYmICFoYXMocnVsZXMuZ3QpICYmIHRoaXMgPiBydWxlcy5sdGU/ICd2YWx1ZSBtdXN0IGJlIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5sdGVdKSA6ICcnSAASbAoGbHRfbm93GAcgASgIQlrCSFcKVQoQdGltZXN0YW1wLmx0X25vdxpBKHJ1bGVzLmx0X25vdyAmJiB0aGlzID4gbm93KSA/ICd2YWx1ZSBtdXN0IGJlIGxlc3MgdGhhbiBub3cnIDogJydIABLHBwoCZ3QYBSABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQpwHwkiYBwp+Cgx0aW1lc3RhbXAuZ3QabiFoYXMocnVsZXMubHQpICYmICFoYXMocnVsZXMubHRlKSAmJiB0aGlzIDw9IHJ1bGVzLmd0PyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3RdKSA6ICcnCrcBCg90aW1lc3RhbXAuZ3RfbHQaowFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0ID49IHJ1bGVzLmd0ICYmICh0aGlzID49IHJ1bGVzLmx0IHx8IHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgYW5kIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndCwgcnVsZXMubHRdKSA6ICcnCr8BChl0aW1lc3RhbXAuZ3RfbHRfZXhjbHVzaXZlGqEBaGFzKHJ1bGVzLmx0KSAmJiBydWxlcy5sdCA8IHJ1bGVzLmd0ICYmIChydWxlcy5sdCA8PSB0aGlzICYmIHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgb3IgbGVzcyB0aGFuICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdF0pIDogJycKxwEKEHRpbWVzdGFtcC5ndF9sdGUasgFoYXMocnVsZXMubHRlKSAmJiBydWxlcy5sdGUgPj0gcnVsZXMuZ3QgJiYgKHRoaXMgPiBydWxlcy5sdGUgfHwgdGhpcyA8PSBydWxlcy5ndCk/ICd2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAlcyBhbmQgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdGVdKSA6ICcnCs8BChp0aW1lc3RhbXAuZ3RfbHRlX2V4Y2x1c2l2ZRqwAWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA8IHJ1bGVzLmd0ICYmIChydWxlcy5sdGUgPCB0aGlzICYmIHRoaXMgPD0gcnVsZXMuZ3QpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gJXMgb3IgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0LCBydWxlcy5sdGVdKSA6ICcnSAESkwgKA2d0ZRgGIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBC5wfCSOMHCowBCg10aW1lc3RhbXAuZ3RlGnshaGFzKHJ1bGVzLmx0KSAmJiAhaGFzKHJ1bGVzLmx0ZSkgJiYgdGhpcyA8IHJ1bGVzLmd0ZT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzJy5mb3JtYXQoW3J1bGVzLmd0ZV0pIDogJycKxgEKEHRpbWVzdGFtcC5ndGVfbHQasQFoYXMocnVsZXMubHQpICYmIHJ1bGVzLmx0ID49IHJ1bGVzLmd0ZSAmJiAodGhpcyA+PSBydWxlcy5sdCB8fCB0aGlzIDwgcnVsZXMuZ3RlKT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzIGFuZCBsZXNzIHRoYW4gJXMnLmZvcm1hdChbcnVsZXMuZ3RlLCBydWxlcy5sdF0pIDogJycKzgEKGnRpbWVzdGFtcC5ndGVfbHRfZXhjbHVzaXZlGq8BaGFzKHJ1bGVzLmx0KSAmJiBydWxlcy5sdCA8IHJ1bGVzLmd0ZSAmJiAocnVsZXMubHQgPD0gdGhpcyAmJiB0aGlzIDwgcnVsZXMuZ3RlKT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzIG9yIGxlc3MgdGhhbiAlcycuZm9ybWF0KFtydWxlcy5ndGUsIHJ1bGVzLmx0XSkgOiAnJwrWAQoRdGltZXN0YW1wLmd0ZV9sdGUawAFoYXMocnVsZXMubHRlKSAmJiBydWxlcy5sdGUgPj0gcnVsZXMuZ3RlICYmICh0aGlzID4gcnVsZXMubHRlIHx8IHRoaXMgPCBydWxlcy5ndGUpPyAndmFsdWUgbXVzdCBiZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gJXMgYW5kIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5ndGUsIHJ1bGVzLmx0ZV0pIDogJycK3gEKG3RpbWVzdGFtcC5ndGVfbHRlX2V4Y2x1c2l2ZRq+AWhhcyhydWxlcy5sdGUpICYmIHJ1bGVzLmx0ZSA8IHJ1bGVzLmd0ZSAmJiAocnVsZXMubHRlIDwgdGhpcyAmJiB0aGlzIDwgcnVsZXMuZ3RlKT8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICVzIG9yIGxlc3MgdGhhbiBvciBlcXVhbCB0byAlcycuZm9ybWF0KFtydWxlcy5ndGUsIHJ1bGVzLmx0ZV0pIDogJydIARJvCgZndF9ub3cYCCABKAhCXcJIWgpYChB0aW1lc3RhbXAuZ3Rfbm93GkQocnVsZXMuZ3Rfbm93ICYmIHRoaXMgPCBub3cpID8gJ3ZhbHVlIG11c3QgYmUgZ3JlYXRlciB0aGFuIG5vdycgOiAnJ0gBErgBCgZ3aXRoaW4YCSABKAsyGS5nb29nbGUucHJvdG9idWYuRHVyYXRpb25CjAHCSIgBCoUBChB0aW1lc3RhbXAud2l0aGluGnF0aGlzIDwgbm93LXJ1bGVzLndpdGhpbiB8fCB0aGlzID4gbm93K3J1bGVzLndpdGhpbiA/ICd2YWx1ZSBtdXN0IGJlIHdpdGhpbiAlcyBvZiBub3cnLmZvcm1hdChbcnVsZXMud2l0aGluXSkgOiAnJxJLCgdleGFtcGxlGAogAygLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEIewkgbChkKEXRpbWVzdGFtcC5leGFtcGxlGgR0cnVlKgkI6AcQgICAgAJCCwoJbGVzc190aGFuQg4KDGdyZWF0ZXJfdGhhbiI5CgpWaW9sYXRpb25zEisKCnZpb2xhdGlvbnMYASADKAsyFy5idWYudmFsaWRhdGUuVmlvbGF0aW9uIp8BCglWaW9sYXRpb24SJgoFZmllbGQYBSABKAsyFy5idWYudmFsaWRhdGUuRmllbGRQYXRoEiUKBHJ1bGUYBiABKAsyFy5idWYudmFsaWRhdGUuRmllbGRQYXRoEg8KB3J1bGVfaWQYAiABKAkSDwoHbWVzc2FnZRgDIAEoCRIPCgdmb3Jfa2V5GAQgASgISgQIARACUgpmaWVsZF9wYXRoIj0KCUZpZWxkUGF0aBIwCghlbGVtZW50cxgBIAMoCzIeLmJ1Zi52YWxpZGF0ZS5GaWVsZFBhdGhFbGVtZW50IukCChBGaWVsZFBhdGhFbGVtZW50EhQKDGZpZWxkX251bWJlchgBIAEoBRISCgpmaWVsZF9uYW1lGAIgASgJEj4KCmZpZWxkX3R5cGUYAyABKA4yKi5nb29nbGUucHJvdG9idWYuRmllbGREZXNjcmlwdG9yUHJvdG8uVHlwZRI8CghrZXlfdHlwZRgEIAEoDjIqLmdvb2dsZS5wcm90b2J1Zi5GaWVsZERlc2NyaXB0b3JQcm90by5UeXBlEj4KCnZhbHVlX3R5cGUYBSABKA4yKi5nb29nbGUucHJvdG9idWYuRmllbGREZXNjcmlwdG9yUHJvdG8uVHlwZRIPCgVpbmRleBgGIAEoBEgAEhIKCGJvb2xfa2V5GAcgASgISAASEQoHaW50X2tleRgIIAEoA0gAEhIKCHVpbnRfa2V5GAkgASgESAASFAoKc3RyaW5nX2tleRgKIAEoCUgAQgsKCXN1YnNjcmlwdCqhAQoGSWdub3JlEhYKEklHTk9SRV9VTlNQRUNJRklFRBAAEhgKFElHTk9SRV9JRl9aRVJPX1ZBTFVFEAESEQoNSUdOT1JFX0FMV0FZUxADIgQIAhACKgxJR05PUkVfRU1QVFkqDklHTk9SRV9ERUZBVUxUKhdJR05PUkVfSUZfREVGQVVMVF9WQUxVRSoVSUdOT1JFX0lGX1VOUE9QVUxBVEVEKm4KCktub3duUmVnZXgSGwoXS05PV05fUkVHRVhfVU5TUEVDSUZJRUQQABIgChxLTk9XTl9SRUdFWF9IVFRQX0hFQURFUl9OQU1FEAESIQodS05PV05fUkVHRVhfSFRUUF9IRUFERVJfVkFMVUUQAjpWCgdtZXNzYWdlEh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGIcJIAEoCzIaLmJ1Zi52YWxpZGF0ZS5NZXNzYWdlUnVsZXNSB21lc3NhZ2U6TgoFb25lb2YSHS5nb29nbGUucHJvdG9idWYuT25lb2ZPcHRpb25zGIcJIAEoCzIYLmJ1Zi52YWxpZGF0ZS5PbmVvZlJ1bGVzUgVvbmVvZjpOCgVmaWVsZBIdLmdvb2dsZS5wcm90b2J1Zi5GaWVsZE9wdGlvbnMYhwkgASgLMhguYnVmLnZhbGlkYXRlLkZpZWxkUnVsZXNSBWZpZWxkOl0KCnByZWRlZmluZWQSHS5nb29nbGUucHJvdG9idWYuRmllbGRPcHRpb25zGIgJIAEoCzIdLmJ1Zi52YWxpZGF0ZS5QcmVkZWZpbmVkUnVsZXNSCnByZWRlZmluZWRCvQEKEGNvbS5idWYudmFsaWRhdGVCDVZhbGlkYXRlUHJvdG9IAlABWkdidWYuYnVpbGQvZ2VuL2dvL2J1ZmJ1aWxkL3Byb3RvdmFsaWRhdGUvcHJvdG9jb2xidWZmZXJzL2dvL2J1Zi92YWxpZGF0ZaICA0JWWKoCDEJ1Zi5WYWxpZGF0ZcoCDEJ1ZlxWYWxpZGF0ZeICGEJ1ZlxWYWxpZGF0ZVxHUEJNZXRhZGF0YeoCDUJ1Zjo6VmFsaWRhdGU", [file_google_protobuf_descriptor, file_google_protobuf_duration, file_google_protobuf_timestamp]); + +/** + * `Rule` represents a validation rule written in the Common Expression + * Language (CEL) syntax. Each Rule includes a unique identifier, an + * optional error message, and the CEL expression to evaluate. For more + * information, [see our documentation](https://buf.build/docs/protovalidate/schemas/custom-rules/). + * + * ```proto + * message Foo { + * option (buf.validate.message).cel = { + * id: "foo.bar" + * message: "bar must be greater than 0" + * expression: "this.bar > 0" + * }; + * int32 bar = 1; + * } + * ``` + * + * @generated from message buf.validate.Rule + */ +export type Rule = Message<"buf.validate.Rule"> & { + /** + * `id` is a string that serves as a machine-readable name for this Rule. + * It should be unique within its scope, which could be either a message or a field. + * + * @generated from field: optional string id = 1; + */ + id: string; + + /** + * `message` is an optional field that provides a human-readable error message + * for this Rule when the CEL expression evaluates to false. If a + * non-empty message is provided, any strings resulting from the CEL + * expression evaluation are ignored. + * + * @generated from field: optional string message = 2; + */ + message: string; + + /** + * `expression` is the actual CEL expression that will be evaluated for + * validation. This string must resolve to either a boolean or a string + * value. If the expression evaluates to false or a non-empty string, the + * validation is considered failed, and the message is rejected. + * + * @generated from field: optional string expression = 3; + */ + expression: string; +}; + +/** + * Describes the message buf.validate.Rule. + * Use `create(RuleSchema)` to create a new message. + */ +export const RuleSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 0); + +/** + * MessageRules represents validation rules that are applied to the entire message. + * It includes disabling options and a list of Rule messages representing Common Expression Language (CEL) validation rules. + * + * @generated from message buf.validate.MessageRules + */ +export type MessageRules = Message<"buf.validate.MessageRules"> & { + /** + * `cel` is a repeated field of type Rule. Each Rule specifies a validation rule to be applied to this message. + * These rules are written in Common Expression Language (CEL) syntax. For more information, + * [see our documentation](https://buf.build/docs/protovalidate/schemas/custom-rules/). + * + * + * ```proto + * message MyMessage { + * // The field `foo` must be greater than 42. + * option (buf.validate.message).cel = { + * id: "my_message.value", + * message: "value must be greater than 42", + * expression: "this.foo > 42", + * }; + * optional int32 foo = 1; + * } + * ``` + * + * @generated from field: repeated buf.validate.Rule cel = 3; + */ + cel: Rule[]; + + /** + * `oneof` is a repeated field of type MessageOneofRule that specifies a list of fields + * of which at most one can be present. If `required` is also specified, then exactly one + * of the specified fields _must_ be present. + * + * This will enforce oneof-like constraints with a few features not provided by + * actual Protobuf oneof declarations: + * 1. Repeated and map fields are allowed in this validation. In a Protobuf oneof, + * only scalar fields are allowed. + * 2. Fields with implicit presence are allowed. In a Protobuf oneof, all member + * fields have explicit presence. This means that, for the purpose of determining + * how many fields are set, explicitly setting such a field to its zero value is + * effectively the same as not setting it at all. + * 3. This will always generate validation errors for a message unmarshalled from + * serialized data that sets more than one field. With a Protobuf oneof, when + * multiple fields are present in the serialized form, earlier values are usually + * silently ignored when unmarshalling, with only the last field being set when + * unmarshalling completes. + * + * Note that adding a field to a `oneof` will also set the IGNORE_IF_ZERO_VALUE on the fields. This means + * only the field that is set will be validated and the unset fields are not validated according to the field rules. + * This behavior can be overridden by setting `ignore` against a field. + * + * ```proto + * message MyMessage { + * // Only one of `field1` or `field2` _can_ be present in this message. + * option (buf.validate.message).oneof = { fields: ["field1", "field2"] }; + * // Exactly one of `field3` or `field4` _must_ be present in this message. + * option (buf.validate.message).oneof = { fields: ["field3", "field4"], required: true }; + * string field1 = 1; + * bytes field2 = 2; + * bool field3 = 3; + * int32 field4 = 4; + * } + * ``` + * + * @generated from field: repeated buf.validate.MessageOneofRule oneof = 4; + */ + oneof: MessageOneofRule[]; +}; + +/** + * Describes the message buf.validate.MessageRules. + * Use `create(MessageRulesSchema)` to create a new message. + */ +export const MessageRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 1); + +/** + * @generated from message buf.validate.MessageOneofRule + */ +export type MessageOneofRule = Message<"buf.validate.MessageOneofRule"> & { + /** + * A list of field names to include in the oneof. All field names must be + * defined in the message. At least one field must be specified, and + * duplicates are not permitted. + * + * @generated from field: repeated string fields = 1; + */ + fields: string[]; + + /** + * If true, one of the fields specified _must_ be set. + * + * @generated from field: optional bool required = 2; + */ + required: boolean; +}; + +/** + * Describes the message buf.validate.MessageOneofRule. + * Use `create(MessageOneofRuleSchema)` to create a new message. + */ +export const MessageOneofRuleSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 2); + +/** + * The `OneofRules` message type enables you to manage rules for + * oneof fields in your protobuf messages. + * + * @generated from message buf.validate.OneofRules + */ +export type OneofRules = Message<"buf.validate.OneofRules"> & { + /** + * If `required` is true, exactly one field of the oneof must be set. A + * validation error is returned if no fields in the oneof are set. Further rules + * should be placed on the fields themselves to ensure they are valid values, + * such as `min_len` or `gt`. + * + * ```proto + * message MyMessage { + * oneof value { + * // Either `a` or `b` must be set. If `a` is set, it must also be + * // non-empty; whereas if `b` is set, it can still be an empty string. + * option (buf.validate.oneof).required = true; + * string a = 1 [(buf.validate.field).string.min_len = 1]; + * string b = 2; + * } + * } + * ``` + * + * @generated from field: optional bool required = 1; + */ + required: boolean; +}; + +/** + * Describes the message buf.validate.OneofRules. + * Use `create(OneofRulesSchema)` to create a new message. + */ +export const OneofRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 3); + +/** + * FieldRules encapsulates the rules for each type of field. Depending on + * the field, the correct set should be used to ensure proper validations. + * + * @generated from message buf.validate.FieldRules + */ +export type FieldRules = Message<"buf.validate.FieldRules"> & { + /** + * `cel` is a repeated field used to represent a textual expression + * in the Common Expression Language (CEL) syntax. For more information, + * [see our documentation](https://buf.build/docs/protovalidate/schemas/custom-rules/). + * + * ```proto + * message MyMessage { + * // The field `value` must be greater than 42. + * optional int32 value = 1 [(buf.validate.field).cel = { + * id: "my_message.value", + * message: "value must be greater than 42", + * expression: "this > 42", + * }]; + * } + * ``` + * + * @generated from field: repeated buf.validate.Rule cel = 23; + */ + cel: Rule[]; + + /** + * If `required` is true, the field must be set. A validation error is returned + * if the field is not set. + * + * ```proto + * syntax="proto3"; + * + * message FieldsWithPresence { + * // Requires any string to be set, including the empty string. + * optional string link = 1 [ + * (buf.validate.field).required = true + * ]; + * // Requires true or false to be set. + * optional bool disabled = 2 [ + * (buf.validate.field).required = true + * ]; + * // Requires a message to be set, including the empty message. + * SomeMessage msg = 4 [ + * (buf.validate.field).required = true + * ]; + * } + * ``` + * + * All fields in the example above track presence. By default, Protovalidate + * ignores rules on those fields if no value is set. `required` ensures that + * the fields are set and valid. + * + * Fields that don't track presence are always validated by Protovalidate, + * whether they are set or not. It is not necessary to add `required`: + * + * ```proto + * syntax="proto3"; + * + * message FieldsWithoutPresence { + * // `string.email` always applies, even to an empty string. + * string link = 1 [ + * (buf.validate.field).string.email = true + * ]; + * // `repeated.min_items` always applies, even to an empty list. + * repeated string labels = 4 [ + * (buf.validate.field).repeated.min_items = 1 + * ]; + * } + * ``` + * + * To learn which fields track presence, see the + * [Field Presence cheat sheet](https://protobuf.dev/programming-guides/field_presence/#cheat). + * + * Note: While field rules can be applied to repeated items, map keys, and map + * values, the elements are always considered to be set. Consequently, + * specifying `repeated.items.required` is redundant. + * + * @generated from field: optional bool required = 25; + */ + required: boolean; + + /** + * Ignore validation rules on the field if its value matches the specified + * criteria. See the `Ignore` enum for details. + * + * ```proto + * message UpdateRequest { + * // The uri rule only applies if the field is not an empty string. + * string url = 1 [ + * (buf.validate.field).ignore = IGNORE_IF_ZERO_VALUE, + * (buf.validate.field).string.uri = true + * ]; + * } + * ``` + * + * @generated from field: optional buf.validate.Ignore ignore = 27; + */ + ignore: Ignore; + + /** + * @generated from oneof buf.validate.FieldRules.type + */ + type: { + /** + * Scalar Field Types + * + * @generated from field: buf.validate.FloatRules float = 1; + */ + value: FloatRules; + case: "float"; + } | { + /** + * @generated from field: buf.validate.DoubleRules double = 2; + */ + value: DoubleRules; + case: "double"; + } | { + /** + * @generated from field: buf.validate.Int32Rules int32 = 3; + */ + value: Int32Rules; + case: "int32"; + } | { + /** + * @generated from field: buf.validate.Int64Rules int64 = 4; + */ + value: Int64Rules; + case: "int64"; + } | { + /** + * @generated from field: buf.validate.UInt32Rules uint32 = 5; + */ + value: UInt32Rules; + case: "uint32"; + } | { + /** + * @generated from field: buf.validate.UInt64Rules uint64 = 6; + */ + value: UInt64Rules; + case: "uint64"; + } | { + /** + * @generated from field: buf.validate.SInt32Rules sint32 = 7; + */ + value: SInt32Rules; + case: "sint32"; + } | { + /** + * @generated from field: buf.validate.SInt64Rules sint64 = 8; + */ + value: SInt64Rules; + case: "sint64"; + } | { + /** + * @generated from field: buf.validate.Fixed32Rules fixed32 = 9; + */ + value: Fixed32Rules; + case: "fixed32"; + } | { + /** + * @generated from field: buf.validate.Fixed64Rules fixed64 = 10; + */ + value: Fixed64Rules; + case: "fixed64"; + } | { + /** + * @generated from field: buf.validate.SFixed32Rules sfixed32 = 11; + */ + value: SFixed32Rules; + case: "sfixed32"; + } | { + /** + * @generated from field: buf.validate.SFixed64Rules sfixed64 = 12; + */ + value: SFixed64Rules; + case: "sfixed64"; + } | { + /** + * @generated from field: buf.validate.BoolRules bool = 13; + */ + value: BoolRules; + case: "bool"; + } | { + /** + * @generated from field: buf.validate.StringRules string = 14; + */ + value: StringRules; + case: "string"; + } | { + /** + * @generated from field: buf.validate.BytesRules bytes = 15; + */ + value: BytesRules; + case: "bytes"; + } | { + /** + * Complex Field Types + * + * @generated from field: buf.validate.EnumRules enum = 16; + */ + value: EnumRules; + case: "enum"; + } | { + /** + * @generated from field: buf.validate.RepeatedRules repeated = 18; + */ + value: RepeatedRules; + case: "repeated"; + } | { + /** + * @generated from field: buf.validate.MapRules map = 19; + */ + value: MapRules; + case: "map"; + } | { + /** + * Well-Known Field Types + * + * @generated from field: buf.validate.AnyRules any = 20; + */ + value: AnyRules; + case: "any"; + } | { + /** + * @generated from field: buf.validate.DurationRules duration = 21; + */ + value: DurationRules; + case: "duration"; + } | { + /** + * @generated from field: buf.validate.TimestampRules timestamp = 22; + */ + value: TimestampRules; + case: "timestamp"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message buf.validate.FieldRules. + * Use `create(FieldRulesSchema)` to create a new message. + */ +export const FieldRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 4); + +/** + * PredefinedRules are custom rules that can be re-used with + * multiple fields. + * + * @generated from message buf.validate.PredefinedRules + */ +export type PredefinedRules = Message<"buf.validate.PredefinedRules"> & { + /** + * `cel` is a repeated field used to represent a textual expression + * in the Common Expression Language (CEL) syntax. For more information, + * [see our documentation](https://buf.build/docs/protovalidate/schemas/predefined-rules/). + * + * ```proto + * message MyMessage { + * // The field `value` must be greater than 42. + * optional int32 value = 1 [(buf.validate.predefined).cel = { + * id: "my_message.value", + * message: "value must be greater than 42", + * expression: "this > 42", + * }]; + * } + * ``` + * + * @generated from field: repeated buf.validate.Rule cel = 1; + */ + cel: Rule[]; +}; + +/** + * Describes the message buf.validate.PredefinedRules. + * Use `create(PredefinedRulesSchema)` to create a new message. + */ +export const PredefinedRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 5); + +/** + * FloatRules describes the rules applied to `float` values. These + * rules may also be applied to the `google.protobuf.FloatValue` Well-Known-Type. + * + * @generated from message buf.validate.FloatRules + */ +export type FloatRules = Message<"buf.validate.FloatRules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MyFloat { + * // value must equal 42.0 + * float value = 1 [(buf.validate.field).float.const = 42.0]; + * } + * ``` + * + * @generated from field: optional float const = 1; + */ + const: number; + + /** + * @generated from oneof buf.validate.FloatRules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field < + * value). If the field value is equal to or greater than the specified value, + * an error message is generated. + * + * ```proto + * message MyFloat { + * // value must be less than 10.0 + * float value = 1 [(buf.validate.field).float.lt = 10.0]; + * } + * ``` + * + * @generated from field: float lt = 2; + */ + value: number; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MyFloat { + * // value must be less than or equal to 10.0 + * float value = 1 [(buf.validate.field).float.lte = 10.0]; + * } + * ``` + * + * @generated from field: float lte = 3; + */ + value: number; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.FloatRules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyFloat { + * // value must be greater than 5.0 [float.gt] + * float value = 1 [(buf.validate.field).float.gt = 5.0]; + * + * // value must be greater than 5 and less than 10.0 [float.gt_lt] + * float other_value = 2 [(buf.validate.field).float = { gt: 5.0, lt: 10.0 }]; + * + * // value must be greater than 10 or less than 5.0 [float.gt_lt_exclusive] + * float another_value = 3 [(buf.validate.field).float = { gt: 10.0, lt: 5.0 }]; + * } + * ``` + * + * @generated from field: float gt = 4; + */ + value: number; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyFloat { + * // value must be greater than or equal to 5.0 [float.gte] + * float value = 1 [(buf.validate.field).float.gte = 5.0]; + * + * // value must be greater than or equal to 5.0 and less than 10.0 [float.gte_lt] + * float other_value = 2 [(buf.validate.field).float = { gte: 5.0, lt: 10.0 }]; + * + * // value must be greater than or equal to 10.0 or less than 5.0 [float.gte_lt_exclusive] + * float another_value = 3 [(buf.validate.field).float = { gte: 10.0, lt: 5.0 }]; + * } + * ``` + * + * @generated from field: float gte = 5; + */ + value: number; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message + * is generated. + * + * ```proto + * message MyFloat { + * // value must be in list [1.0, 2.0, 3.0] + * float value = 1 [(buf.validate.field).float = { in: [1.0, 2.0, 3.0] }]; + * } + * ``` + * + * @generated from field: repeated float in = 6; + */ + in: number[]; + + /** + * `in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MyFloat { + * // value must not be in list [1.0, 2.0, 3.0] + * float value = 1 [(buf.validate.field).float = { not_in: [1.0, 2.0, 3.0] }]; + * } + * ``` + * + * @generated from field: repeated float not_in = 7; + */ + notIn: number[]; + + /** + * `finite` requires the field value to be finite. If the field value is + * infinite or NaN, an error message is generated. + * + * @generated from field: optional bool finite = 8; + */ + finite: boolean; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyFloat { + * float value = 1 [ + * (buf.validate.field).float.example = 1.0, + * (buf.validate.field).float.example = inf + * ]; + * } + * ``` + * + * @generated from field: repeated float example = 9; + */ + example: number[]; +}; + +/** + * Describes the message buf.validate.FloatRules. + * Use `create(FloatRulesSchema)` to create a new message. + */ +export const FloatRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 6); + +/** + * DoubleRules describes the rules applied to `double` values. These + * rules may also be applied to the `google.protobuf.DoubleValue` Well-Known-Type. + * + * @generated from message buf.validate.DoubleRules + */ +export type DoubleRules = Message<"buf.validate.DoubleRules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MyDouble { + * // value must equal 42.0 + * double value = 1 [(buf.validate.field).double.const = 42.0]; + * } + * ``` + * + * @generated from field: optional double const = 1; + */ + const: number; + + /** + * @generated from oneof buf.validate.DoubleRules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field < + * value). If the field value is equal to or greater than the specified + * value, an error message is generated. + * + * ```proto + * message MyDouble { + * // value must be less than 10.0 + * double value = 1 [(buf.validate.field).double.lt = 10.0]; + * } + * ``` + * + * @generated from field: double lt = 2; + */ + value: number; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified value + * (field <= value). If the field value is greater than the specified value, + * an error message is generated. + * + * ```proto + * message MyDouble { + * // value must be less than or equal to 10.0 + * double value = 1 [(buf.validate.field).double.lte = 10.0]; + * } + * ``` + * + * @generated from field: double lte = 3; + */ + value: number; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.DoubleRules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or `lte`, + * the range is reversed, and the field value must be outside the specified + * range. If the field value doesn't meet the required conditions, an error + * message is generated. + * + * ```proto + * message MyDouble { + * // value must be greater than 5.0 [double.gt] + * double value = 1 [(buf.validate.field).double.gt = 5.0]; + * + * // value must be greater than 5 and less than 10.0 [double.gt_lt] + * double other_value = 2 [(buf.validate.field).double = { gt: 5.0, lt: 10.0 }]; + * + * // value must be greater than 10 or less than 5.0 [double.gt_lt_exclusive] + * double another_value = 3 [(buf.validate.field).double = { gt: 10.0, lt: 5.0 }]; + * } + * ``` + * + * @generated from field: double gt = 4; + */ + value: number; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyDouble { + * // value must be greater than or equal to 5.0 [double.gte] + * double value = 1 [(buf.validate.field).double.gte = 5.0]; + * + * // value must be greater than or equal to 5.0 and less than 10.0 [double.gte_lt] + * double other_value = 2 [(buf.validate.field).double = { gte: 5.0, lt: 10.0 }]; + * + * // value must be greater than or equal to 10.0 or less than 5.0 [double.gte_lt_exclusive] + * double another_value = 3 [(buf.validate.field).double = { gte: 10.0, lt: 5.0 }]; + * } + * ``` + * + * @generated from field: double gte = 5; + */ + value: number; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message is + * generated. + * + * ```proto + * message MyDouble { + * // value must be in list [1.0, 2.0, 3.0] + * double value = 1 [(buf.validate.field).double = { in: [1.0, 2.0, 3.0] }]; + * } + * ``` + * + * @generated from field: repeated double in = 6; + */ + in: number[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MyDouble { + * // value must not be in list [1.0, 2.0, 3.0] + * double value = 1 [(buf.validate.field).double = { not_in: [1.0, 2.0, 3.0] }]; + * } + * ``` + * + * @generated from field: repeated double not_in = 7; + */ + notIn: number[]; + + /** + * `finite` requires the field value to be finite. If the field value is + * infinite or NaN, an error message is generated. + * + * @generated from field: optional bool finite = 8; + */ + finite: boolean; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyDouble { + * double value = 1 [ + * (buf.validate.field).double.example = 1.0, + * (buf.validate.field).double.example = inf + * ]; + * } + * ``` + * + * @generated from field: repeated double example = 9; + */ + example: number[]; +}; + +/** + * Describes the message buf.validate.DoubleRules. + * Use `create(DoubleRulesSchema)` to create a new message. + */ +export const DoubleRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 7); + +/** + * Int32Rules describes the rules applied to `int32` values. These + * rules may also be applied to the `google.protobuf.Int32Value` Well-Known-Type. + * + * @generated from message buf.validate.Int32Rules + */ +export type Int32Rules = Message<"buf.validate.Int32Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MyInt32 { + * // value must equal 42 + * int32 value = 1 [(buf.validate.field).int32.const = 42]; + * } + * ``` + * + * @generated from field: optional int32 const = 1; + */ + const: number; + + /** + * @generated from oneof buf.validate.Int32Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field + * < value). If the field value is equal to or greater than the specified + * value, an error message is generated. + * + * ```proto + * message MyInt32 { + * // value must be less than 10 + * int32 value = 1 [(buf.validate.field).int32.lt = 10]; + * } + * ``` + * + * @generated from field: int32 lt = 2; + */ + value: number; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MyInt32 { + * // value must be less than or equal to 10 + * int32 value = 1 [(buf.validate.field).int32.lte = 10]; + * } + * ``` + * + * @generated from field: int32 lte = 3; + */ + value: number; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.Int32Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyInt32 { + * // value must be greater than 5 [int32.gt] + * int32 value = 1 [(buf.validate.field).int32.gt = 5]; + * + * // value must be greater than 5 and less than 10 [int32.gt_lt] + * int32 other_value = 2 [(buf.validate.field).int32 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [int32.gt_lt_exclusive] + * int32 another_value = 3 [(buf.validate.field).int32 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: int32 gt = 4; + */ + value: number; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified value + * (exclusive). If the value of `gte` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyInt32 { + * // value must be greater than or equal to 5 [int32.gte] + * int32 value = 1 [(buf.validate.field).int32.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [int32.gte_lt] + * int32 other_value = 2 [(buf.validate.field).int32 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [int32.gte_lt_exclusive] + * int32 another_value = 3 [(buf.validate.field).int32 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: int32 gte = 5; + */ + value: number; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message is + * generated. + * + * ```proto + * message MyInt32 { + * // value must be in list [1, 2, 3] + * int32 value = 1 [(buf.validate.field).int32 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated int32 in = 6; + */ + in: number[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error message + * is generated. + * + * ```proto + * message MyInt32 { + * // value must not be in list [1, 2, 3] + * int32 value = 1 [(buf.validate.field).int32 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated int32 not_in = 7; + */ + notIn: number[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyInt32 { + * int32 value = 1 [ + * (buf.validate.field).int32.example = 1, + * (buf.validate.field).int32.example = -10 + * ]; + * } + * ``` + * + * @generated from field: repeated int32 example = 8; + */ + example: number[]; +}; + +/** + * Describes the message buf.validate.Int32Rules. + * Use `create(Int32RulesSchema)` to create a new message. + */ +export const Int32RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 8); + +/** + * Int64Rules describes the rules applied to `int64` values. These + * rules may also be applied to the `google.protobuf.Int64Value` Well-Known-Type. + * + * @generated from message buf.validate.Int64Rules + */ +export type Int64Rules = Message<"buf.validate.Int64Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MyInt64 { + * // value must equal 42 + * int64 value = 1 [(buf.validate.field).int64.const = 42]; + * } + * ``` + * + * @generated from field: optional int64 const = 1; + */ + const: bigint; + + /** + * @generated from oneof buf.validate.Int64Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field < + * value). If the field value is equal to or greater than the specified value, + * an error message is generated. + * + * ```proto + * message MyInt64 { + * // value must be less than 10 + * int64 value = 1 [(buf.validate.field).int64.lt = 10]; + * } + * ``` + * + * @generated from field: int64 lt = 2; + */ + value: bigint; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MyInt64 { + * // value must be less than or equal to 10 + * int64 value = 1 [(buf.validate.field).int64.lte = 10]; + * } + * ``` + * + * @generated from field: int64 lte = 3; + */ + value: bigint; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.Int64Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyInt64 { + * // value must be greater than 5 [int64.gt] + * int64 value = 1 [(buf.validate.field).int64.gt = 5]; + * + * // value must be greater than 5 and less than 10 [int64.gt_lt] + * int64 other_value = 2 [(buf.validate.field).int64 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [int64.gt_lt_exclusive] + * int64 another_value = 3 [(buf.validate.field).int64 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: int64 gt = 4; + */ + value: bigint; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyInt64 { + * // value must be greater than or equal to 5 [int64.gte] + * int64 value = 1 [(buf.validate.field).int64.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [int64.gte_lt] + * int64 other_value = 2 [(buf.validate.field).int64 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [int64.gte_lt_exclusive] + * int64 another_value = 3 [(buf.validate.field).int64 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: int64 gte = 5; + */ + value: bigint; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message is + * generated. + * + * ```proto + * message MyInt64 { + * // value must be in list [1, 2, 3] + * int64 value = 1 [(buf.validate.field).int64 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated int64 in = 6; + */ + in: bigint[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MyInt64 { + * // value must not be in list [1, 2, 3] + * int64 value = 1 [(buf.validate.field).int64 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated int64 not_in = 7; + */ + notIn: bigint[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyInt64 { + * int64 value = 1 [ + * (buf.validate.field).int64.example = 1, + * (buf.validate.field).int64.example = -10 + * ]; + * } + * ``` + * + * @generated from field: repeated int64 example = 9; + */ + example: bigint[]; +}; + +/** + * Describes the message buf.validate.Int64Rules. + * Use `create(Int64RulesSchema)` to create a new message. + */ +export const Int64RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 9); + +/** + * UInt32Rules describes the rules applied to `uint32` values. These + * rules may also be applied to the `google.protobuf.UInt32Value` Well-Known-Type. + * + * @generated from message buf.validate.UInt32Rules + */ +export type UInt32Rules = Message<"buf.validate.UInt32Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MyUInt32 { + * // value must equal 42 + * uint32 value = 1 [(buf.validate.field).uint32.const = 42]; + * } + * ``` + * + * @generated from field: optional uint32 const = 1; + */ + const: number; + + /** + * @generated from oneof buf.validate.UInt32Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field < + * value). If the field value is equal to or greater than the specified value, + * an error message is generated. + * + * ```proto + * message MyUInt32 { + * // value must be less than 10 + * uint32 value = 1 [(buf.validate.field).uint32.lt = 10]; + * } + * ``` + * + * @generated from field: uint32 lt = 2; + */ + value: number; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MyUInt32 { + * // value must be less than or equal to 10 + * uint32 value = 1 [(buf.validate.field).uint32.lte = 10]; + * } + * ``` + * + * @generated from field: uint32 lte = 3; + */ + value: number; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.UInt32Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyUInt32 { + * // value must be greater than 5 [uint32.gt] + * uint32 value = 1 [(buf.validate.field).uint32.gt = 5]; + * + * // value must be greater than 5 and less than 10 [uint32.gt_lt] + * uint32 other_value = 2 [(buf.validate.field).uint32 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [uint32.gt_lt_exclusive] + * uint32 another_value = 3 [(buf.validate.field).uint32 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: uint32 gt = 4; + */ + value: number; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyUInt32 { + * // value must be greater than or equal to 5 [uint32.gte] + * uint32 value = 1 [(buf.validate.field).uint32.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [uint32.gte_lt] + * uint32 other_value = 2 [(buf.validate.field).uint32 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [uint32.gte_lt_exclusive] + * uint32 another_value = 3 [(buf.validate.field).uint32 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: uint32 gte = 5; + */ + value: number; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message is + * generated. + * + * ```proto + * message MyUInt32 { + * // value must be in list [1, 2, 3] + * uint32 value = 1 [(buf.validate.field).uint32 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated uint32 in = 6; + */ + in: number[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MyUInt32 { + * // value must not be in list [1, 2, 3] + * uint32 value = 1 [(buf.validate.field).uint32 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated uint32 not_in = 7; + */ + notIn: number[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyUInt32 { + * uint32 value = 1 [ + * (buf.validate.field).uint32.example = 1, + * (buf.validate.field).uint32.example = 10 + * ]; + * } + * ``` + * + * @generated from field: repeated uint32 example = 8; + */ + example: number[]; +}; + +/** + * Describes the message buf.validate.UInt32Rules. + * Use `create(UInt32RulesSchema)` to create a new message. + */ +export const UInt32RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 10); + +/** + * UInt64Rules describes the rules applied to `uint64` values. These + * rules may also be applied to the `google.protobuf.UInt64Value` Well-Known-Type. + * + * @generated from message buf.validate.UInt64Rules + */ +export type UInt64Rules = Message<"buf.validate.UInt64Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MyUInt64 { + * // value must equal 42 + * uint64 value = 1 [(buf.validate.field).uint64.const = 42]; + * } + * ``` + * + * @generated from field: optional uint64 const = 1; + */ + const: bigint; + + /** + * @generated from oneof buf.validate.UInt64Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field < + * value). If the field value is equal to or greater than the specified value, + * an error message is generated. + * + * ```proto + * message MyUInt64 { + * // value must be less than 10 + * uint64 value = 1 [(buf.validate.field).uint64.lt = 10]; + * } + * ``` + * + * @generated from field: uint64 lt = 2; + */ + value: bigint; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MyUInt64 { + * // value must be less than or equal to 10 + * uint64 value = 1 [(buf.validate.field).uint64.lte = 10]; + * } + * ``` + * + * @generated from field: uint64 lte = 3; + */ + value: bigint; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.UInt64Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyUInt64 { + * // value must be greater than 5 [uint64.gt] + * uint64 value = 1 [(buf.validate.field).uint64.gt = 5]; + * + * // value must be greater than 5 and less than 10 [uint64.gt_lt] + * uint64 other_value = 2 [(buf.validate.field).uint64 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [uint64.gt_lt_exclusive] + * uint64 another_value = 3 [(buf.validate.field).uint64 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: uint64 gt = 4; + */ + value: bigint; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyUInt64 { + * // value must be greater than or equal to 5 [uint64.gte] + * uint64 value = 1 [(buf.validate.field).uint64.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [uint64.gte_lt] + * uint64 other_value = 2 [(buf.validate.field).uint64 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [uint64.gte_lt_exclusive] + * uint64 another_value = 3 [(buf.validate.field).uint64 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: uint64 gte = 5; + */ + value: bigint; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message is + * generated. + * + * ```proto + * message MyUInt64 { + * // value must be in list [1, 2, 3] + * uint64 value = 1 [(buf.validate.field).uint64 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated uint64 in = 6; + */ + in: bigint[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MyUInt64 { + * // value must not be in list [1, 2, 3] + * uint64 value = 1 [(buf.validate.field).uint64 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated uint64 not_in = 7; + */ + notIn: bigint[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyUInt64 { + * uint64 value = 1 [ + * (buf.validate.field).uint64.example = 1, + * (buf.validate.field).uint64.example = -10 + * ]; + * } + * ``` + * + * @generated from field: repeated uint64 example = 8; + */ + example: bigint[]; +}; + +/** + * Describes the message buf.validate.UInt64Rules. + * Use `create(UInt64RulesSchema)` to create a new message. + */ +export const UInt64RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 11); + +/** + * SInt32Rules describes the rules applied to `sint32` values. + * + * @generated from message buf.validate.SInt32Rules + */ +export type SInt32Rules = Message<"buf.validate.SInt32Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MySInt32 { + * // value must equal 42 + * sint32 value = 1 [(buf.validate.field).sint32.const = 42]; + * } + * ``` + * + * @generated from field: optional sint32 const = 1; + */ + const: number; + + /** + * @generated from oneof buf.validate.SInt32Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field + * < value). If the field value is equal to or greater than the specified + * value, an error message is generated. + * + * ```proto + * message MySInt32 { + * // value must be less than 10 + * sint32 value = 1 [(buf.validate.field).sint32.lt = 10]; + * } + * ``` + * + * @generated from field: sint32 lt = 2; + */ + value: number; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MySInt32 { + * // value must be less than or equal to 10 + * sint32 value = 1 [(buf.validate.field).sint32.lte = 10]; + * } + * ``` + * + * @generated from field: sint32 lte = 3; + */ + value: number; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.SInt32Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MySInt32 { + * // value must be greater than 5 [sint32.gt] + * sint32 value = 1 [(buf.validate.field).sint32.gt = 5]; + * + * // value must be greater than 5 and less than 10 [sint32.gt_lt] + * sint32 other_value = 2 [(buf.validate.field).sint32 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [sint32.gt_lt_exclusive] + * sint32 another_value = 3 [(buf.validate.field).sint32 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: sint32 gt = 4; + */ + value: number; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MySInt32 { + * // value must be greater than or equal to 5 [sint32.gte] + * sint32 value = 1 [(buf.validate.field).sint32.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [sint32.gte_lt] + * sint32 other_value = 2 [(buf.validate.field).sint32 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [sint32.gte_lt_exclusive] + * sint32 another_value = 3 [(buf.validate.field).sint32 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: sint32 gte = 5; + */ + value: number; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message is + * generated. + * + * ```proto + * message MySInt32 { + * // value must be in list [1, 2, 3] + * sint32 value = 1 [(buf.validate.field).sint32 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated sint32 in = 6; + */ + in: number[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MySInt32 { + * // value must not be in list [1, 2, 3] + * sint32 value = 1 [(buf.validate.field).sint32 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated sint32 not_in = 7; + */ + notIn: number[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MySInt32 { + * sint32 value = 1 [ + * (buf.validate.field).sint32.example = 1, + * (buf.validate.field).sint32.example = -10 + * ]; + * } + * ``` + * + * @generated from field: repeated sint32 example = 8; + */ + example: number[]; +}; + +/** + * Describes the message buf.validate.SInt32Rules. + * Use `create(SInt32RulesSchema)` to create a new message. + */ +export const SInt32RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 12); + +/** + * SInt64Rules describes the rules applied to `sint64` values. + * + * @generated from message buf.validate.SInt64Rules + */ +export type SInt64Rules = Message<"buf.validate.SInt64Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MySInt64 { + * // value must equal 42 + * sint64 value = 1 [(buf.validate.field).sint64.const = 42]; + * } + * ``` + * + * @generated from field: optional sint64 const = 1; + */ + const: bigint; + + /** + * @generated from oneof buf.validate.SInt64Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field + * < value). If the field value is equal to or greater than the specified + * value, an error message is generated. + * + * ```proto + * message MySInt64 { + * // value must be less than 10 + * sint64 value = 1 [(buf.validate.field).sint64.lt = 10]; + * } + * ``` + * + * @generated from field: sint64 lt = 2; + */ + value: bigint; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MySInt64 { + * // value must be less than or equal to 10 + * sint64 value = 1 [(buf.validate.field).sint64.lte = 10]; + * } + * ``` + * + * @generated from field: sint64 lte = 3; + */ + value: bigint; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.SInt64Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MySInt64 { + * // value must be greater than 5 [sint64.gt] + * sint64 value = 1 [(buf.validate.field).sint64.gt = 5]; + * + * // value must be greater than 5 and less than 10 [sint64.gt_lt] + * sint64 other_value = 2 [(buf.validate.field).sint64 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [sint64.gt_lt_exclusive] + * sint64 another_value = 3 [(buf.validate.field).sint64 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: sint64 gt = 4; + */ + value: bigint; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MySInt64 { + * // value must be greater than or equal to 5 [sint64.gte] + * sint64 value = 1 [(buf.validate.field).sint64.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [sint64.gte_lt] + * sint64 other_value = 2 [(buf.validate.field).sint64 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [sint64.gte_lt_exclusive] + * sint64 another_value = 3 [(buf.validate.field).sint64 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: sint64 gte = 5; + */ + value: bigint; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message + * is generated. + * + * ```proto + * message MySInt64 { + * // value must be in list [1, 2, 3] + * sint64 value = 1 [(buf.validate.field).sint64 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated sint64 in = 6; + */ + in: bigint[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MySInt64 { + * // value must not be in list [1, 2, 3] + * sint64 value = 1 [(buf.validate.field).sint64 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated sint64 not_in = 7; + */ + notIn: bigint[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MySInt64 { + * sint64 value = 1 [ + * (buf.validate.field).sint64.example = 1, + * (buf.validate.field).sint64.example = -10 + * ]; + * } + * ``` + * + * @generated from field: repeated sint64 example = 8; + */ + example: bigint[]; +}; + +/** + * Describes the message buf.validate.SInt64Rules. + * Use `create(SInt64RulesSchema)` to create a new message. + */ +export const SInt64RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 13); + +/** + * Fixed32Rules describes the rules applied to `fixed32` values. + * + * @generated from message buf.validate.Fixed32Rules + */ +export type Fixed32Rules = Message<"buf.validate.Fixed32Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. + * If the field value doesn't match, an error message is generated. + * + * ```proto + * message MyFixed32 { + * // value must equal 42 + * fixed32 value = 1 [(buf.validate.field).fixed32.const = 42]; + * } + * ``` + * + * @generated from field: optional fixed32 const = 1; + */ + const: number; + + /** + * @generated from oneof buf.validate.Fixed32Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field < + * value). If the field value is equal to or greater than the specified value, + * an error message is generated. + * + * ```proto + * message MyFixed32 { + * // value must be less than 10 + * fixed32 value = 1 [(buf.validate.field).fixed32.lt = 10]; + * } + * ``` + * + * @generated from field: fixed32 lt = 2; + */ + value: number; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MyFixed32 { + * // value must be less than or equal to 10 + * fixed32 value = 1 [(buf.validate.field).fixed32.lte = 10]; + * } + * ``` + * + * @generated from field: fixed32 lte = 3; + */ + value: number; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.Fixed32Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyFixed32 { + * // value must be greater than 5 [fixed32.gt] + * fixed32 value = 1 [(buf.validate.field).fixed32.gt = 5]; + * + * // value must be greater than 5 and less than 10 [fixed32.gt_lt] + * fixed32 other_value = 2 [(buf.validate.field).fixed32 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [fixed32.gt_lt_exclusive] + * fixed32 another_value = 3 [(buf.validate.field).fixed32 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: fixed32 gt = 4; + */ + value: number; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyFixed32 { + * // value must be greater than or equal to 5 [fixed32.gte] + * fixed32 value = 1 [(buf.validate.field).fixed32.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [fixed32.gte_lt] + * fixed32 other_value = 2 [(buf.validate.field).fixed32 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [fixed32.gte_lt_exclusive] + * fixed32 another_value = 3 [(buf.validate.field).fixed32 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: fixed32 gte = 5; + */ + value: number; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message + * is generated. + * + * ```proto + * message MyFixed32 { + * // value must be in list [1, 2, 3] + * fixed32 value = 1 [(buf.validate.field).fixed32 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated fixed32 in = 6; + */ + in: number[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MyFixed32 { + * // value must not be in list [1, 2, 3] + * fixed32 value = 1 [(buf.validate.field).fixed32 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated fixed32 not_in = 7; + */ + notIn: number[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyFixed32 { + * fixed32 value = 1 [ + * (buf.validate.field).fixed32.example = 1, + * (buf.validate.field).fixed32.example = 2 + * ]; + * } + * ``` + * + * @generated from field: repeated fixed32 example = 8; + */ + example: number[]; +}; + +/** + * Describes the message buf.validate.Fixed32Rules. + * Use `create(Fixed32RulesSchema)` to create a new message. + */ +export const Fixed32RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 14); + +/** + * Fixed64Rules describes the rules applied to `fixed64` values. + * + * @generated from message buf.validate.Fixed64Rules + */ +export type Fixed64Rules = Message<"buf.validate.Fixed64Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MyFixed64 { + * // value must equal 42 + * fixed64 value = 1 [(buf.validate.field).fixed64.const = 42]; + * } + * ``` + * + * @generated from field: optional fixed64 const = 1; + */ + const: bigint; + + /** + * @generated from oneof buf.validate.Fixed64Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field < + * value). If the field value is equal to or greater than the specified value, + * an error message is generated. + * + * ```proto + * message MyFixed64 { + * // value must be less than 10 + * fixed64 value = 1 [(buf.validate.field).fixed64.lt = 10]; + * } + * ``` + * + * @generated from field: fixed64 lt = 2; + */ + value: bigint; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MyFixed64 { + * // value must be less than or equal to 10 + * fixed64 value = 1 [(buf.validate.field).fixed64.lte = 10]; + * } + * ``` + * + * @generated from field: fixed64 lte = 3; + */ + value: bigint; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.Fixed64Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyFixed64 { + * // value must be greater than 5 [fixed64.gt] + * fixed64 value = 1 [(buf.validate.field).fixed64.gt = 5]; + * + * // value must be greater than 5 and less than 10 [fixed64.gt_lt] + * fixed64 other_value = 2 [(buf.validate.field).fixed64 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [fixed64.gt_lt_exclusive] + * fixed64 another_value = 3 [(buf.validate.field).fixed64 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: fixed64 gt = 4; + */ + value: bigint; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyFixed64 { + * // value must be greater than or equal to 5 [fixed64.gte] + * fixed64 value = 1 [(buf.validate.field).fixed64.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [fixed64.gte_lt] + * fixed64 other_value = 2 [(buf.validate.field).fixed64 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [fixed64.gte_lt_exclusive] + * fixed64 another_value = 3 [(buf.validate.field).fixed64 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: fixed64 gte = 5; + */ + value: bigint; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message is + * generated. + * + * ```proto + * message MyFixed64 { + * // value must be in list [1, 2, 3] + * fixed64 value = 1 [(buf.validate.field).fixed64 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated fixed64 in = 6; + */ + in: bigint[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MyFixed64 { + * // value must not be in list [1, 2, 3] + * fixed64 value = 1 [(buf.validate.field).fixed64 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated fixed64 not_in = 7; + */ + notIn: bigint[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyFixed64 { + * fixed64 value = 1 [ + * (buf.validate.field).fixed64.example = 1, + * (buf.validate.field).fixed64.example = 2 + * ]; + * } + * ``` + * + * @generated from field: repeated fixed64 example = 8; + */ + example: bigint[]; +}; + +/** + * Describes the message buf.validate.Fixed64Rules. + * Use `create(Fixed64RulesSchema)` to create a new message. + */ +export const Fixed64RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 15); + +/** + * SFixed32Rules describes the rules applied to `fixed32` values. + * + * @generated from message buf.validate.SFixed32Rules + */ +export type SFixed32Rules = Message<"buf.validate.SFixed32Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MySFixed32 { + * // value must equal 42 + * sfixed32 value = 1 [(buf.validate.field).sfixed32.const = 42]; + * } + * ``` + * + * @generated from field: optional sfixed32 const = 1; + */ + const: number; + + /** + * @generated from oneof buf.validate.SFixed32Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field < + * value). If the field value is equal to or greater than the specified value, + * an error message is generated. + * + * ```proto + * message MySFixed32 { + * // value must be less than 10 + * sfixed32 value = 1 [(buf.validate.field).sfixed32.lt = 10]; + * } + * ``` + * + * @generated from field: sfixed32 lt = 2; + */ + value: number; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MySFixed32 { + * // value must be less than or equal to 10 + * sfixed32 value = 1 [(buf.validate.field).sfixed32.lte = 10]; + * } + * ``` + * + * @generated from field: sfixed32 lte = 3; + */ + value: number; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.SFixed32Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MySFixed32 { + * // value must be greater than 5 [sfixed32.gt] + * sfixed32 value = 1 [(buf.validate.field).sfixed32.gt = 5]; + * + * // value must be greater than 5 and less than 10 [sfixed32.gt_lt] + * sfixed32 other_value = 2 [(buf.validate.field).sfixed32 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [sfixed32.gt_lt_exclusive] + * sfixed32 another_value = 3 [(buf.validate.field).sfixed32 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: sfixed32 gt = 4; + */ + value: number; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MySFixed32 { + * // value must be greater than or equal to 5 [sfixed32.gte] + * sfixed32 value = 1 [(buf.validate.field).sfixed32.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [sfixed32.gte_lt] + * sfixed32 other_value = 2 [(buf.validate.field).sfixed32 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [sfixed32.gte_lt_exclusive] + * sfixed32 another_value = 3 [(buf.validate.field).sfixed32 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: sfixed32 gte = 5; + */ + value: number; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message is + * generated. + * + * ```proto + * message MySFixed32 { + * // value must be in list [1, 2, 3] + * sfixed32 value = 1 [(buf.validate.field).sfixed32 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated sfixed32 in = 6; + */ + in: number[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MySFixed32 { + * // value must not be in list [1, 2, 3] + * sfixed32 value = 1 [(buf.validate.field).sfixed32 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated sfixed32 not_in = 7; + */ + notIn: number[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MySFixed32 { + * sfixed32 value = 1 [ + * (buf.validate.field).sfixed32.example = 1, + * (buf.validate.field).sfixed32.example = 2 + * ]; + * } + * ``` + * + * @generated from field: repeated sfixed32 example = 8; + */ + example: number[]; +}; + +/** + * Describes the message buf.validate.SFixed32Rules. + * Use `create(SFixed32RulesSchema)` to create a new message. + */ +export const SFixed32RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 16); + +/** + * SFixed64Rules describes the rules applied to `fixed64` values. + * + * @generated from message buf.validate.SFixed64Rules + */ +export type SFixed64Rules = Message<"buf.validate.SFixed64Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MySFixed64 { + * // value must equal 42 + * sfixed64 value = 1 [(buf.validate.field).sfixed64.const = 42]; + * } + * ``` + * + * @generated from field: optional sfixed64 const = 1; + */ + const: bigint; + + /** + * @generated from oneof buf.validate.SFixed64Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field < + * value). If the field value is equal to or greater than the specified value, + * an error message is generated. + * + * ```proto + * message MySFixed64 { + * // value must be less than 10 + * sfixed64 value = 1 [(buf.validate.field).sfixed64.lt = 10]; + * } + * ``` + * + * @generated from field: sfixed64 lt = 2; + */ + value: bigint; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MySFixed64 { + * // value must be less than or equal to 10 + * sfixed64 value = 1 [(buf.validate.field).sfixed64.lte = 10]; + * } + * ``` + * + * @generated from field: sfixed64 lte = 3; + */ + value: bigint; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.SFixed64Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MySFixed64 { + * // value must be greater than 5 [sfixed64.gt] + * sfixed64 value = 1 [(buf.validate.field).sfixed64.gt = 5]; + * + * // value must be greater than 5 and less than 10 [sfixed64.gt_lt] + * sfixed64 other_value = 2 [(buf.validate.field).sfixed64 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [sfixed64.gt_lt_exclusive] + * sfixed64 another_value = 3 [(buf.validate.field).sfixed64 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: sfixed64 gt = 4; + */ + value: bigint; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MySFixed64 { + * // value must be greater than or equal to 5 [sfixed64.gte] + * sfixed64 value = 1 [(buf.validate.field).sfixed64.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [sfixed64.gte_lt] + * sfixed64 other_value = 2 [(buf.validate.field).sfixed64 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [sfixed64.gte_lt_exclusive] + * sfixed64 another_value = 3 [(buf.validate.field).sfixed64 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: sfixed64 gte = 5; + */ + value: bigint; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message is + * generated. + * + * ```proto + * message MySFixed64 { + * // value must be in list [1, 2, 3] + * sfixed64 value = 1 [(buf.validate.field).sfixed64 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated sfixed64 in = 6; + */ + in: bigint[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MySFixed64 { + * // value must not be in list [1, 2, 3] + * sfixed64 value = 1 [(buf.validate.field).sfixed64 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated sfixed64 not_in = 7; + */ + notIn: bigint[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MySFixed64 { + * sfixed64 value = 1 [ + * (buf.validate.field).sfixed64.example = 1, + * (buf.validate.field).sfixed64.example = 2 + * ]; + * } + * ``` + * + * @generated from field: repeated sfixed64 example = 8; + */ + example: bigint[]; +}; + +/** + * Describes the message buf.validate.SFixed64Rules. + * Use `create(SFixed64RulesSchema)` to create a new message. + */ +export const SFixed64RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 17); + +/** + * BoolRules describes the rules applied to `bool` values. These rules + * may also be applied to the `google.protobuf.BoolValue` Well-Known-Type. + * + * @generated from message buf.validate.BoolRules + */ +export type BoolRules = Message<"buf.validate.BoolRules"> & { + /** + * `const` requires the field value to exactly match the specified boolean value. + * If the field value doesn't match, an error message is generated. + * + * ```proto + * message MyBool { + * // value must equal true + * bool value = 1 [(buf.validate.field).bool.const = true]; + * } + * ``` + * + * @generated from field: optional bool const = 1; + */ + const: boolean; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyBool { + * bool value = 1 [ + * (buf.validate.field).bool.example = 1, + * (buf.validate.field).bool.example = 2 + * ]; + * } + * ``` + * + * @generated from field: repeated bool example = 2; + */ + example: boolean[]; +}; + +/** + * Describes the message buf.validate.BoolRules. + * Use `create(BoolRulesSchema)` to create a new message. + */ +export const BoolRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 18); + +/** + * StringRules describes the rules applied to `string` values These + * rules may also be applied to the `google.protobuf.StringValue` Well-Known-Type. + * + * @generated from message buf.validate.StringRules + */ +export type StringRules = Message<"buf.validate.StringRules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MyString { + * // value must equal `hello` + * string value = 1 [(buf.validate.field).string.const = "hello"]; + * } + * ``` + * + * @generated from field: optional string const = 1; + */ + const: string; + + /** + * `len` dictates that the field value must have the specified + * number of characters (Unicode code points), which may differ from the number + * of bytes in the string. If the field value does not meet the specified + * length, an error message will be generated. + * + * ```proto + * message MyString { + * // value length must be 5 characters + * string value = 1 [(buf.validate.field).string.len = 5]; + * } + * ``` + * + * @generated from field: optional uint64 len = 19; + */ + len: bigint; + + /** + * `min_len` specifies that the field value must have at least the specified + * number of characters (Unicode code points), which may differ from the number + * of bytes in the string. If the field value contains fewer characters, an error + * message will be generated. + * + * ```proto + * message MyString { + * // value length must be at least 3 characters + * string value = 1 [(buf.validate.field).string.min_len = 3]; + * } + * ``` + * + * @generated from field: optional uint64 min_len = 2; + */ + minLen: bigint; + + /** + * `max_len` specifies that the field value must have no more than the specified + * number of characters (Unicode code points), which may differ from the + * number of bytes in the string. If the field value contains more characters, + * an error message will be generated. + * + * ```proto + * message MyString { + * // value length must be at most 10 characters + * string value = 1 [(buf.validate.field).string.max_len = 10]; + * } + * ``` + * + * @generated from field: optional uint64 max_len = 3; + */ + maxLen: bigint; + + /** + * `len_bytes` dictates that the field value must have the specified number of + * bytes. If the field value does not match the specified length in bytes, + * an error message will be generated. + * + * ```proto + * message MyString { + * // value length must be 6 bytes + * string value = 1 [(buf.validate.field).string.len_bytes = 6]; + * } + * ``` + * + * @generated from field: optional uint64 len_bytes = 20; + */ + lenBytes: bigint; + + /** + * `min_bytes` specifies that the field value must have at least the specified + * number of bytes. If the field value contains fewer bytes, an error message + * will be generated. + * + * ```proto + * message MyString { + * // value length must be at least 4 bytes + * string value = 1 [(buf.validate.field).string.min_bytes = 4]; + * } + * + * ``` + * + * @generated from field: optional uint64 min_bytes = 4; + */ + minBytes: bigint; + + /** + * `max_bytes` specifies that the field value must have no more than the + * specified number of bytes. If the field value contains more bytes, an + * error message will be generated. + * + * ```proto + * message MyString { + * // value length must be at most 8 bytes + * string value = 1 [(buf.validate.field).string.max_bytes = 8]; + * } + * ``` + * + * @generated from field: optional uint64 max_bytes = 5; + */ + maxBytes: bigint; + + /** + * `pattern` specifies that the field value must match the specified + * regular expression (RE2 syntax), with the expression provided without any + * delimiters. If the field value doesn't match the regular expression, an + * error message will be generated. + * + * ```proto + * message MyString { + * // value does not match regex pattern `^[a-zA-Z]//$` + * string value = 1 [(buf.validate.field).string.pattern = "^[a-zA-Z]//$"]; + * } + * ``` + * + * @generated from field: optional string pattern = 6; + */ + pattern: string; + + /** + * `prefix` specifies that the field value must have the + * specified substring at the beginning of the string. If the field value + * doesn't start with the specified prefix, an error message will be + * generated. + * + * ```proto + * message MyString { + * // value does not have prefix `pre` + * string value = 1 [(buf.validate.field).string.prefix = "pre"]; + * } + * ``` + * + * @generated from field: optional string prefix = 7; + */ + prefix: string; + + /** + * `suffix` specifies that the field value must have the + * specified substring at the end of the string. If the field value doesn't + * end with the specified suffix, an error message will be generated. + * + * ```proto + * message MyString { + * // value does not have suffix `post` + * string value = 1 [(buf.validate.field).string.suffix = "post"]; + * } + * ``` + * + * @generated from field: optional string suffix = 8; + */ + suffix: string; + + /** + * `contains` specifies that the field value must have the + * specified substring anywhere in the string. If the field value doesn't + * contain the specified substring, an error message will be generated. + * + * ```proto + * message MyString { + * // value does not contain substring `inside`. + * string value = 1 [(buf.validate.field).string.contains = "inside"]; + * } + * ``` + * + * @generated from field: optional string contains = 9; + */ + contains: string; + + /** + * `not_contains` specifies that the field value must not have the + * specified substring anywhere in the string. If the field value contains + * the specified substring, an error message will be generated. + * + * ```proto + * message MyString { + * // value contains substring `inside`. + * string value = 1 [(buf.validate.field).string.not_contains = "inside"]; + * } + * ``` + * + * @generated from field: optional string not_contains = 23; + */ + notContains: string; + + /** + * `in` specifies that the field value must be equal to one of the specified + * values. If the field value isn't one of the specified values, an error + * message will be generated. + * + * ```proto + * message MyString { + * // value must be in list ["apple", "banana"] + * string value = 1 [(buf.validate.field).string.in = "apple", (buf.validate.field).string.in = "banana"]; + * } + * ``` + * + * @generated from field: repeated string in = 10; + */ + in: string[]; + + /** + * `not_in` specifies that the field value cannot be equal to any + * of the specified values. If the field value is one of the specified values, + * an error message will be generated. + * ```proto + * message MyString { + * // value must not be in list ["orange", "grape"] + * string value = 1 [(buf.validate.field).string.not_in = "orange", (buf.validate.field).string.not_in = "grape"]; + * } + * ``` + * + * @generated from field: repeated string not_in = 11; + */ + notIn: string[]; + + /** + * `WellKnown` rules provide advanced rules against common string + * patterns. + * + * @generated from oneof buf.validate.StringRules.well_known + */ + wellKnown: { + /** + * `email` specifies that the field value must be a valid email address, for + * example "foo@example.com". + * + * Conforms to the definition for a valid email address from the [HTML standard](https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address). + * Note that this standard willfully deviates from [RFC 5322](https://datatracker.ietf.org/doc/html/rfc5322), + * which allows many unexpected forms of email addresses and will easily match + * a typographical error. + * + * If the field value isn't a valid email address, an error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid email address + * string value = 1 [(buf.validate.field).string.email = true]; + * } + * ``` + * + * @generated from field: bool email = 12; + */ + value: boolean; + case: "email"; + } | { + /** + * `hostname` specifies that the field value must be a valid hostname, for + * example "foo.example.com". + * + * A valid hostname follows the rules below: + * - The name consists of one or more labels, separated by a dot ("."). + * - Each label can be 1 to 63 alphanumeric characters. + * - A label can contain hyphens ("-"), but must not start or end with a hyphen. + * - The right-most label must not be digits only. + * - The name can have a trailing dotโ€”for example, "foo.example.com.". + * - The name can be 253 characters at most, excluding the optional trailing dot. + * + * If the field value isn't a valid hostname, an error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid hostname + * string value = 1 [(buf.validate.field).string.hostname = true]; + * } + * ``` + * + * @generated from field: bool hostname = 13; + */ + value: boolean; + case: "hostname"; + } | { + /** + * `ip` specifies that the field value must be a valid IP (v4 or v6) address. + * + * IPv4 addresses are expected in the dotted decimal formatโ€”for example, "192.168.5.21". + * IPv6 addresses are expected in their text representationโ€”for example, "::1", + * or "2001:0DB8:ABCD:0012::0". + * + * Both formats are well-defined in the internet standard [RFC 3986](https://datatracker.ietf.org/doc/html/rfc3986). + * Zone identifiers for IPv6 addresses (for example, "fe80::a%en1") are supported. + * + * If the field value isn't a valid IP address, an error message will be + * generated. + * + * ```proto + * message MyString { + * // value must be a valid IP address + * string value = 1 [(buf.validate.field).string.ip = true]; + * } + * ``` + * + * @generated from field: bool ip = 14; + */ + value: boolean; + case: "ip"; + } | { + /** + * `ipv4` specifies that the field value must be a valid IPv4 addressโ€”for + * example "192.168.5.21". If the field value isn't a valid IPv4 address, an + * error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid IPv4 address + * string value = 1 [(buf.validate.field).string.ipv4 = true]; + * } + * ``` + * + * @generated from field: bool ipv4 = 15; + */ + value: boolean; + case: "ipv4"; + } | { + /** + * `ipv6` specifies that the field value must be a valid IPv6 addressโ€”for + * example "::1", or "d7a:115c:a1e0:ab12:4843:cd96:626b:430b". If the field + * value is not a valid IPv6 address, an error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid IPv6 address + * string value = 1 [(buf.validate.field).string.ipv6 = true]; + * } + * ``` + * + * @generated from field: bool ipv6 = 16; + */ + value: boolean; + case: "ipv6"; + } | { + /** + * `uri` specifies that the field value must be a valid URI, for example + * "https://example.com/foo/bar?baz=quux#frag". + * + * URI is defined in the internet standard [RFC 3986](https://datatracker.ietf.org/doc/html/rfc3986). + * Zone Identifiers in IPv6 address literals are supported ([RFC 6874](https://datatracker.ietf.org/doc/html/rfc6874)). + * + * If the field value isn't a valid URI, an error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid URI + * string value = 1 [(buf.validate.field).string.uri = true]; + * } + * ``` + * + * @generated from field: bool uri = 17; + */ + value: boolean; + case: "uri"; + } | { + /** + * `uri_ref` specifies that the field value must be a valid URI Referenceโ€”either + * a URI such as "https://example.com/foo/bar?baz=quux#frag", or a Relative + * Reference such as "./foo/bar?query". + * + * URI, URI Reference, and Relative Reference are defined in the internet + * standard [RFC 3986](https://datatracker.ietf.org/doc/html/rfc3986). Zone + * Identifiers in IPv6 address literals are supported ([RFC 6874](https://datatracker.ietf.org/doc/html/rfc6874)). + * + * If the field value isn't a valid URI Reference, an error message will be + * generated. + * + * ```proto + * message MyString { + * // value must be a valid URI Reference + * string value = 1 [(buf.validate.field).string.uri_ref = true]; + * } + * ``` + * + * @generated from field: bool uri_ref = 18; + */ + value: boolean; + case: "uriRef"; + } | { + /** + * `address` specifies that the field value must be either a valid hostname + * (for example, "example.com"), or a valid IP (v4 or v6) address (for example, + * "192.168.0.1", or "::1"). If the field value isn't a valid hostname or IP, + * an error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid hostname, or ip address + * string value = 1 [(buf.validate.field).string.address = true]; + * } + * ``` + * + * @generated from field: bool address = 21; + */ + value: boolean; + case: "address"; + } | { + /** + * `uuid` specifies that the field value must be a valid UUID as defined by + * [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.2). If the + * field value isn't a valid UUID, an error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid UUID + * string value = 1 [(buf.validate.field).string.uuid = true]; + * } + * ``` + * + * @generated from field: bool uuid = 22; + */ + value: boolean; + case: "uuid"; + } | { + /** + * `tuuid` (trimmed UUID) specifies that the field value must be a valid UUID as + * defined by [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.2) with all dashes + * omitted. If the field value isn't a valid UUID without dashes, an error message + * will be generated. + * + * ```proto + * message MyString { + * // value must be a valid trimmed UUID + * string value = 1 [(buf.validate.field).string.tuuid = true]; + * } + * ``` + * + * @generated from field: bool tuuid = 33; + */ + value: boolean; + case: "tuuid"; + } | { + /** + * `ip_with_prefixlen` specifies that the field value must be a valid IP + * (v4 or v6) address with prefix lengthโ€”for example, "192.168.5.21/16" or + * "2001:0DB8:ABCD:0012::F1/64". If the field value isn't a valid IP with + * prefix length, an error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid IP with prefix length + * string value = 1 [(buf.validate.field).string.ip_with_prefixlen = true]; + * } + * ``` + * + * @generated from field: bool ip_with_prefixlen = 26; + */ + value: boolean; + case: "ipWithPrefixlen"; + } | { + /** + * `ipv4_with_prefixlen` specifies that the field value must be a valid + * IPv4 address with prefix lengthโ€”for example, "192.168.5.21/16". If the + * field value isn't a valid IPv4 address with prefix length, an error + * message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid IPv4 address with prefix length + * string value = 1 [(buf.validate.field).string.ipv4_with_prefixlen = true]; + * } + * ``` + * + * @generated from field: bool ipv4_with_prefixlen = 27; + */ + value: boolean; + case: "ipv4WithPrefixlen"; + } | { + /** + * `ipv6_with_prefixlen` specifies that the field value must be a valid + * IPv6 address with prefix lengthโ€”for example, "2001:0DB8:ABCD:0012::F1/64". + * If the field value is not a valid IPv6 address with prefix length, + * an error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid IPv6 address prefix length + * string value = 1 [(buf.validate.field).string.ipv6_with_prefixlen = true]; + * } + * ``` + * + * @generated from field: bool ipv6_with_prefixlen = 28; + */ + value: boolean; + case: "ipv6WithPrefixlen"; + } | { + /** + * `ip_prefix` specifies that the field value must be a valid IP (v4 or v6) + * prefixโ€”for example, "192.168.0.0/16" or "2001:0DB8:ABCD:0012::0/64". + * + * The prefix must have all zeros for the unmasked bits. For example, + * "2001:0DB8:ABCD:0012::0/64" designates the left-most 64 bits for the + * prefix, and the remaining 64 bits must be zero. + * + * If the field value isn't a valid IP prefix, an error message will be + * generated. + * + * ```proto + * message MyString { + * // value must be a valid IP prefix + * string value = 1 [(buf.validate.field).string.ip_prefix = true]; + * } + * ``` + * + * @generated from field: bool ip_prefix = 29; + */ + value: boolean; + case: "ipPrefix"; + } | { + /** + * `ipv4_prefix` specifies that the field value must be a valid IPv4 + * prefix, for example "192.168.0.0/16". + * + * The prefix must have all zeros for the unmasked bits. For example, + * "192.168.0.0/16" designates the left-most 16 bits for the prefix, + * and the remaining 16 bits must be zero. + * + * If the field value isn't a valid IPv4 prefix, an error message + * will be generated. + * + * ```proto + * message MyString { + * // value must be a valid IPv4 prefix + * string value = 1 [(buf.validate.field).string.ipv4_prefix = true]; + * } + * ``` + * + * @generated from field: bool ipv4_prefix = 30; + */ + value: boolean; + case: "ipv4Prefix"; + } | { + /** + * `ipv6_prefix` specifies that the field value must be a valid IPv6 prefixโ€”for + * example, "2001:0DB8:ABCD:0012::0/64". + * + * The prefix must have all zeros for the unmasked bits. For example, + * "2001:0DB8:ABCD:0012::0/64" designates the left-most 64 bits for the + * prefix, and the remaining 64 bits must be zero. + * + * If the field value is not a valid IPv6 prefix, an error message will be + * generated. + * + * ```proto + * message MyString { + * // value must be a valid IPv6 prefix + * string value = 1 [(buf.validate.field).string.ipv6_prefix = true]; + * } + * ``` + * + * @generated from field: bool ipv6_prefix = 31; + */ + value: boolean; + case: "ipv6Prefix"; + } | { + /** + * `host_and_port` specifies that the field value must be valid host/port + * pairโ€”for example, "example.com:8080". + * + * The host can be one of: + * - An IPv4 address in dotted decimal formatโ€”for example, "192.168.5.21". + * - An IPv6 address enclosed in square bracketsโ€”for example, "[2001:0DB8:ABCD:0012::F1]". + * - A hostnameโ€”for example, "example.com". + * + * The port is separated by a colon. It must be non-empty, with a decimal number + * in the range of 0-65535, inclusive. + * + * @generated from field: bool host_and_port = 32; + */ + value: boolean; + case: "hostAndPort"; + } | { + /** + * `well_known_regex` specifies a common well-known pattern + * defined as a regex. If the field value doesn't match the well-known + * regex, an error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid HTTP header value + * string value = 1 [(buf.validate.field).string.well_known_regex = KNOWN_REGEX_HTTP_HEADER_VALUE]; + * } + * ``` + * + * #### KnownRegex + * + * `well_known_regex` contains some well-known patterns. + * + * | Name | Number | Description | + * |-------------------------------|--------|-------------------------------------------| + * | KNOWN_REGEX_UNSPECIFIED | 0 | | + * | KNOWN_REGEX_HTTP_HEADER_NAME | 1 | HTTP header name as defined by [RFC 7230](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2) | + * | KNOWN_REGEX_HTTP_HEADER_VALUE | 2 | HTTP header value as defined by [RFC 7230](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.4) | + * + * @generated from field: buf.validate.KnownRegex well_known_regex = 24; + */ + value: KnownRegex; + case: "wellKnownRegex"; + } | { case: undefined; value?: undefined }; + + /** + * This applies to regexes `HTTP_HEADER_NAME` and `HTTP_HEADER_VALUE` to + * enable strict header validation. By default, this is true, and HTTP header + * validations are [RFC-compliant](https://datatracker.ietf.org/doc/html/rfc7230#section-3). Setting to false will enable looser + * validations that only disallow `\r\n\0` characters, which can be used to + * bypass header matching rules. + * + * ```proto + * message MyString { + * // The field `value` must have be a valid HTTP headers, but not enforced with strict rules. + * string value = 1 [(buf.validate.field).string.strict = false]; + * } + * ``` + * + * @generated from field: optional bool strict = 25; + */ + strict: boolean; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyString { + * string value = 1 [ + * (buf.validate.field).string.example = "hello", + * (buf.validate.field).string.example = "world" + * ]; + * } + * ``` + * + * @generated from field: repeated string example = 34; + */ + example: string[]; +}; + +/** + * Describes the message buf.validate.StringRules. + * Use `create(StringRulesSchema)` to create a new message. + */ +export const StringRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 19); + +/** + * BytesRules describe the rules applied to `bytes` values. These rules + * may also be applied to the `google.protobuf.BytesValue` Well-Known-Type. + * + * @generated from message buf.validate.BytesRules + */ +export type BytesRules = Message<"buf.validate.BytesRules"> & { + /** + * `const` requires the field value to exactly match the specified bytes + * value. If the field value doesn't match, an error message is generated. + * + * ```proto + * message MyBytes { + * // value must be "\x01\x02\x03\x04" + * bytes value = 1 [(buf.validate.field).bytes.const = "\x01\x02\x03\x04"]; + * } + * ``` + * + * @generated from field: optional bytes const = 1; + */ + const: Uint8Array; + + /** + * `len` requires the field value to have the specified length in bytes. + * If the field value doesn't match, an error message is generated. + * + * ```proto + * message MyBytes { + * // value length must be 4 bytes. + * optional bytes value = 1 [(buf.validate.field).bytes.len = 4]; + * } + * ``` + * + * @generated from field: optional uint64 len = 13; + */ + len: bigint; + + /** + * `min_len` requires the field value to have at least the specified minimum + * length in bytes. + * If the field value doesn't meet the requirement, an error message is generated. + * + * ```proto + * message MyBytes { + * // value length must be at least 2 bytes. + * optional bytes value = 1 [(buf.validate.field).bytes.min_len = 2]; + * } + * ``` + * + * @generated from field: optional uint64 min_len = 2; + */ + minLen: bigint; + + /** + * `max_len` requires the field value to have at most the specified maximum + * length in bytes. + * If the field value exceeds the requirement, an error message is generated. + * + * ```proto + * message MyBytes { + * // value must be at most 6 bytes. + * optional bytes value = 1 [(buf.validate.field).bytes.max_len = 6]; + * } + * ``` + * + * @generated from field: optional uint64 max_len = 3; + */ + maxLen: bigint; + + /** + * `pattern` requires the field value to match the specified regular + * expression ([RE2 syntax](https://github.com/google/re2/wiki/Syntax)). + * The value of the field must be valid UTF-8 or validation will fail with a + * runtime error. + * If the field value doesn't match the pattern, an error message is generated. + * + * ```proto + * message MyBytes { + * // value must match regex pattern "^[a-zA-Z0-9]+$". + * optional bytes value = 1 [(buf.validate.field).bytes.pattern = "^[a-zA-Z0-9]+$"]; + * } + * ``` + * + * @generated from field: optional string pattern = 4; + */ + pattern: string; + + /** + * `prefix` requires the field value to have the specified bytes at the + * beginning of the string. + * If the field value doesn't meet the requirement, an error message is generated. + * + * ```proto + * message MyBytes { + * // value does not have prefix \x01\x02 + * optional bytes value = 1 [(buf.validate.field).bytes.prefix = "\x01\x02"]; + * } + * ``` + * + * @generated from field: optional bytes prefix = 5; + */ + prefix: Uint8Array; + + /** + * `suffix` requires the field value to have the specified bytes at the end + * of the string. + * If the field value doesn't meet the requirement, an error message is generated. + * + * ```proto + * message MyBytes { + * // value does not have suffix \x03\x04 + * optional bytes value = 1 [(buf.validate.field).bytes.suffix = "\x03\x04"]; + * } + * ``` + * + * @generated from field: optional bytes suffix = 6; + */ + suffix: Uint8Array; + + /** + * `contains` requires the field value to have the specified bytes anywhere in + * the string. + * If the field value doesn't meet the requirement, an error message is generated. + * + * ```protobuf + * message MyBytes { + * // value does not contain \x02\x03 + * optional bytes value = 1 [(buf.validate.field).bytes.contains = "\x02\x03"]; + * } + * ``` + * + * @generated from field: optional bytes contains = 7; + */ + contains: Uint8Array; + + /** + * `in` requires the field value to be equal to one of the specified + * values. If the field value doesn't match any of the specified values, an + * error message is generated. + * + * ```protobuf + * message MyBytes { + * // value must in ["\x01\x02", "\x02\x03", "\x03\x04"] + * optional bytes value = 1 [(buf.validate.field).bytes.in = {"\x01\x02", "\x02\x03", "\x03\x04"}]; + * } + * ``` + * + * @generated from field: repeated bytes in = 8; + */ + in: Uint8Array[]; + + /** + * `not_in` requires the field value to be not equal to any of the specified + * values. + * If the field value matches any of the specified values, an error message is + * generated. + * + * ```proto + * message MyBytes { + * // value must not in ["\x01\x02", "\x02\x03", "\x03\x04"] + * optional bytes value = 1 [(buf.validate.field).bytes.not_in = {"\x01\x02", "\x02\x03", "\x03\x04"}]; + * } + * ``` + * + * @generated from field: repeated bytes not_in = 9; + */ + notIn: Uint8Array[]; + + /** + * WellKnown rules provide advanced rules against common byte + * patterns + * + * @generated from oneof buf.validate.BytesRules.well_known + */ + wellKnown: { + /** + * `ip` ensures that the field `value` is a valid IP address (v4 or v6) in byte format. + * If the field value doesn't meet this rule, an error message is generated. + * + * ```proto + * message MyBytes { + * // value must be a valid IP address + * optional bytes value = 1 [(buf.validate.field).bytes.ip = true]; + * } + * ``` + * + * @generated from field: bool ip = 10; + */ + value: boolean; + case: "ip"; + } | { + /** + * `ipv4` ensures that the field `value` is a valid IPv4 address in byte format. + * If the field value doesn't meet this rule, an error message is generated. + * + * ```proto + * message MyBytes { + * // value must be a valid IPv4 address + * optional bytes value = 1 [(buf.validate.field).bytes.ipv4 = true]; + * } + * ``` + * + * @generated from field: bool ipv4 = 11; + */ + value: boolean; + case: "ipv4"; + } | { + /** + * `ipv6` ensures that the field `value` is a valid IPv6 address in byte format. + * If the field value doesn't meet this rule, an error message is generated. + * ```proto + * message MyBytes { + * // value must be a valid IPv6 address + * optional bytes value = 1 [(buf.validate.field).bytes.ipv6 = true]; + * } + * ``` + * + * @generated from field: bool ipv6 = 12; + */ + value: boolean; + case: "ipv6"; + } | { case: undefined; value?: undefined }; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyBytes { + * bytes value = 1 [ + * (buf.validate.field).bytes.example = "\x01\x02", + * (buf.validate.field).bytes.example = "\x02\x03" + * ]; + * } + * ``` + * + * @generated from field: repeated bytes example = 14; + */ + example: Uint8Array[]; +}; + +/** + * Describes the message buf.validate.BytesRules. + * Use `create(BytesRulesSchema)` to create a new message. + */ +export const BytesRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 20); + +/** + * EnumRules describe the rules applied to `enum` values. + * + * @generated from message buf.validate.EnumRules + */ +export type EnumRules = Message<"buf.validate.EnumRules"> & { + /** + * `const` requires the field value to exactly match the specified enum value. + * If the field value doesn't match, an error message is generated. + * + * ```proto + * enum MyEnum { + * MY_ENUM_UNSPECIFIED = 0; + * MY_ENUM_VALUE1 = 1; + * MY_ENUM_VALUE2 = 2; + * } + * + * message MyMessage { + * // The field `value` must be exactly MY_ENUM_VALUE1. + * MyEnum value = 1 [(buf.validate.field).enum.const = 1]; + * } + * ``` + * + * @generated from field: optional int32 const = 1; + */ + const: number; + + /** + * `defined_only` requires the field value to be one of the defined values for + * this enum, failing on any undefined value. + * + * ```proto + * enum MyEnum { + * MY_ENUM_UNSPECIFIED = 0; + * MY_ENUM_VALUE1 = 1; + * MY_ENUM_VALUE2 = 2; + * } + * + * message MyMessage { + * // The field `value` must be a defined value of MyEnum. + * MyEnum value = 1 [(buf.validate.field).enum.defined_only = true]; + * } + * ``` + * + * @generated from field: optional bool defined_only = 2; + */ + definedOnly: boolean; + + /** + * `in` requires the field value to be equal to one of the + * specified enum values. If the field value doesn't match any of the + * specified values, an error message is generated. + * + * ```proto + * enum MyEnum { + * MY_ENUM_UNSPECIFIED = 0; + * MY_ENUM_VALUE1 = 1; + * MY_ENUM_VALUE2 = 2; + * } + * + * message MyMessage { + * // The field `value` must be equal to one of the specified values. + * MyEnum value = 1 [(buf.validate.field).enum = { in: [1, 2]}]; + * } + * ``` + * + * @generated from field: repeated int32 in = 3; + */ + in: number[]; + + /** + * `not_in` requires the field value to be not equal to any of the + * specified enum values. If the field value matches one of the specified + * values, an error message is generated. + * + * ```proto + * enum MyEnum { + * MY_ENUM_UNSPECIFIED = 0; + * MY_ENUM_VALUE1 = 1; + * MY_ENUM_VALUE2 = 2; + * } + * + * message MyMessage { + * // The field `value` must not be equal to any of the specified values. + * MyEnum value = 1 [(buf.validate.field).enum = { not_in: [1, 2]}]; + * } + * ``` + * + * @generated from field: repeated int32 not_in = 4; + */ + notIn: number[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * enum MyEnum { + * MY_ENUM_UNSPECIFIED = 0; + * MY_ENUM_VALUE1 = 1; + * MY_ENUM_VALUE2 = 2; + * } + * + * message MyMessage { + * (buf.validate.field).enum.example = 1, + * (buf.validate.field).enum.example = 2 + * } + * ``` + * + * @generated from field: repeated int32 example = 5; + */ + example: number[]; +}; + +/** + * Describes the message buf.validate.EnumRules. + * Use `create(EnumRulesSchema)` to create a new message. + */ +export const EnumRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 21); + +/** + * RepeatedRules describe the rules applied to `repeated` values. + * + * @generated from message buf.validate.RepeatedRules + */ +export type RepeatedRules = Message<"buf.validate.RepeatedRules"> & { + /** + * `min_items` requires that this field must contain at least the specified + * minimum number of items. + * + * Note that `min_items = 1` is equivalent to setting a field as `required`. + * + * ```proto + * message MyRepeated { + * // value must contain at least 2 items + * repeated string value = 1 [(buf.validate.field).repeated.min_items = 2]; + * } + * ``` + * + * @generated from field: optional uint64 min_items = 1; + */ + minItems: bigint; + + /** + * `max_items` denotes that this field must not exceed a + * certain number of items as the upper limit. If the field contains more + * items than specified, an error message will be generated, requiring the + * field to maintain no more than the specified number of items. + * + * ```proto + * message MyRepeated { + * // value must contain no more than 3 item(s) + * repeated string value = 1 [(buf.validate.field).repeated.max_items = 3]; + * } + * ``` + * + * @generated from field: optional uint64 max_items = 2; + */ + maxItems: bigint; + + /** + * `unique` indicates that all elements in this field must + * be unique. This rule is strictly applicable to scalar and enum + * types, with message types not being supported. + * + * ```proto + * message MyRepeated { + * // repeated value must contain unique items + * repeated string value = 1 [(buf.validate.field).repeated.unique = true]; + * } + * ``` + * + * @generated from field: optional bool unique = 3; + */ + unique: boolean; + + /** + * `items` details the rules to be applied to each item + * in the field. Even for repeated message fields, validation is executed + * against each item unless `ignore` is specified. + * + * ```proto + * message MyRepeated { + * // The items in the field `value` must follow the specified rules. + * repeated string value = 1 [(buf.validate.field).repeated.items = { + * string: { + * min_len: 3 + * max_len: 10 + * } + * }]; + * } + * ``` + * + * Note that the `required` rule does not apply. Repeated items + * cannot be unset. + * + * @generated from field: optional buf.validate.FieldRules items = 4; + */ + items?: FieldRules; +}; + +/** + * Describes the message buf.validate.RepeatedRules. + * Use `create(RepeatedRulesSchema)` to create a new message. + */ +export const RepeatedRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 22); + +/** + * MapRules describe the rules applied to `map` values. + * + * @generated from message buf.validate.MapRules + */ +export type MapRules = Message<"buf.validate.MapRules"> & { + /** + * Specifies the minimum number of key-value pairs allowed. If the field has + * fewer key-value pairs than specified, an error message is generated. + * + * ```proto + * message MyMap { + * // The field `value` must have at least 2 key-value pairs. + * map value = 1 [(buf.validate.field).map.min_pairs = 2]; + * } + * ``` + * + * @generated from field: optional uint64 min_pairs = 1; + */ + minPairs: bigint; + + /** + * Specifies the maximum number of key-value pairs allowed. If the field has + * more key-value pairs than specified, an error message is generated. + * + * ```proto + * message MyMap { + * // The field `value` must have at most 3 key-value pairs. + * map value = 1 [(buf.validate.field).map.max_pairs = 3]; + * } + * ``` + * + * @generated from field: optional uint64 max_pairs = 2; + */ + maxPairs: bigint; + + /** + * Specifies the rules to be applied to each key in the field. + * + * ```proto + * message MyMap { + * // The keys in the field `value` must follow the specified rules. + * map value = 1 [(buf.validate.field).map.keys = { + * string: { + * min_len: 3 + * max_len: 10 + * } + * }]; + * } + * ``` + * + * Note that the `required` rule does not apply. Map keys cannot be unset. + * + * @generated from field: optional buf.validate.FieldRules keys = 4; + */ + keys?: FieldRules; + + /** + * Specifies the rules to be applied to the value of each key in the + * field. Message values will still have their validations evaluated unless + * `ignore` is specified. + * + * ```proto + * message MyMap { + * // The values in the field `value` must follow the specified rules. + * map value = 1 [(buf.validate.field).map.values = { + * string: { + * min_len: 5 + * max_len: 20 + * } + * }]; + * } + * ``` + * Note that the `required` rule does not apply. Map values cannot be unset. + * + * @generated from field: optional buf.validate.FieldRules values = 5; + */ + values?: FieldRules; +}; + +/** + * Describes the message buf.validate.MapRules. + * Use `create(MapRulesSchema)` to create a new message. + */ +export const MapRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 23); + +/** + * AnyRules describe rules applied exclusively to the `google.protobuf.Any` well-known type. + * + * @generated from message buf.validate.AnyRules + */ +export type AnyRules = Message<"buf.validate.AnyRules"> & { + /** + * `in` requires the field's `type_url` to be equal to one of the + * specified values. If it doesn't match any of the specified values, an error + * message is generated. + * + * ```proto + * message MyAny { + * // The `value` field must have a `type_url` equal to one of the specified values. + * google.protobuf.Any value = 1 [(buf.validate.field).any = { + * in: ["type.googleapis.com/MyType1", "type.googleapis.com/MyType2"] + * }]; + * } + * ``` + * + * @generated from field: repeated string in = 2; + */ + in: string[]; + + /** + * requires the field's type_url to be not equal to any of the specified values. If it matches any of the specified values, an error message is generated. + * + * ```proto + * message MyAny { + * // The `value` field must not have a `type_url` equal to any of the specified values. + * google.protobuf.Any value = 1 [(buf.validate.field).any = { + * not_in: ["type.googleapis.com/ForbiddenType1", "type.googleapis.com/ForbiddenType2"] + * }]; + * } + * ``` + * + * @generated from field: repeated string not_in = 3; + */ + notIn: string[]; +}; + +/** + * Describes the message buf.validate.AnyRules. + * Use `create(AnyRulesSchema)` to create a new message. + */ +export const AnyRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 24); + +/** + * DurationRules describe the rules applied exclusively to the `google.protobuf.Duration` well-known type. + * + * @generated from message buf.validate.DurationRules + */ +export type DurationRules = Message<"buf.validate.DurationRules"> & { + /** + * `const` dictates that the field must match the specified value of the `google.protobuf.Duration` type exactly. + * If the field's value deviates from the specified value, an error message + * will be generated. + * + * ```proto + * message MyDuration { + * // value must equal 5s + * google.protobuf.Duration value = 1 [(buf.validate.field).duration.const = "5s"]; + * } + * ``` + * + * @generated from field: optional google.protobuf.Duration const = 2; + */ + const?: Duration; + + /** + * @generated from oneof buf.validate.DurationRules.less_than + */ + lessThan: { + /** + * `lt` stipulates that the field must be less than the specified value of the `google.protobuf.Duration` type, + * exclusive. If the field's value is greater than or equal to the specified + * value, an error message will be generated. + * + * ```proto + * message MyDuration { + * // value must be less than 5s + * google.protobuf.Duration value = 1 [(buf.validate.field).duration.lt = "5s"]; + * } + * ``` + * + * @generated from field: google.protobuf.Duration lt = 3; + */ + value: Duration; + case: "lt"; + } | { + /** + * `lte` indicates that the field must be less than or equal to the specified + * value of the `google.protobuf.Duration` type, inclusive. If the field's value is greater than the specified value, + * an error message will be generated. + * + * ```proto + * message MyDuration { + * // value must be less than or equal to 10s + * google.protobuf.Duration value = 1 [(buf.validate.field).duration.lte = "10s"]; + * } + * ``` + * + * @generated from field: google.protobuf.Duration lte = 4; + */ + value: Duration; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.DurationRules.greater_than + */ + greaterThan: { + /** + * `gt` requires the duration field value to be greater than the specified + * value (exclusive). If the value of `gt` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyDuration { + * // duration must be greater than 5s [duration.gt] + * google.protobuf.Duration value = 1 [(buf.validate.field).duration.gt = { seconds: 5 }]; + * + * // duration must be greater than 5s and less than 10s [duration.gt_lt] + * google.protobuf.Duration another_value = 2 [(buf.validate.field).duration = { gt: { seconds: 5 }, lt: { seconds: 10 } }]; + * + * // duration must be greater than 10s or less than 5s [duration.gt_lt_exclusive] + * google.protobuf.Duration other_value = 3 [(buf.validate.field).duration = { gt: { seconds: 10 }, lt: { seconds: 5 } }]; + * } + * ``` + * + * @generated from field: google.protobuf.Duration gt = 5; + */ + value: Duration; + case: "gt"; + } | { + /** + * `gte` requires the duration field value to be greater than or equal to the + * specified value (exclusive). If the value of `gte` is larger than a + * specified `lt` or `lte`, the range is reversed, and the field value must + * be outside the specified range. If the field value doesn't meet the + * required conditions, an error message is generated. + * + * ```proto + * message MyDuration { + * // duration must be greater than or equal to 5s [duration.gte] + * google.protobuf.Duration value = 1 [(buf.validate.field).duration.gte = { seconds: 5 }]; + * + * // duration must be greater than or equal to 5s and less than 10s [duration.gte_lt] + * google.protobuf.Duration another_value = 2 [(buf.validate.field).duration = { gte: { seconds: 5 }, lt: { seconds: 10 } }]; + * + * // duration must be greater than or equal to 10s or less than 5s [duration.gte_lt_exclusive] + * google.protobuf.Duration other_value = 3 [(buf.validate.field).duration = { gte: { seconds: 10 }, lt: { seconds: 5 } }]; + * } + * ``` + * + * @generated from field: google.protobuf.Duration gte = 6; + */ + value: Duration; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` asserts that the field must be equal to one of the specified values of the `google.protobuf.Duration` type. + * If the field's value doesn't correspond to any of the specified values, + * an error message will be generated. + * + * ```proto + * message MyDuration { + * // value must be in list [1s, 2s, 3s] + * google.protobuf.Duration value = 1 [(buf.validate.field).duration.in = ["1s", "2s", "3s"]]; + * } + * ``` + * + * @generated from field: repeated google.protobuf.Duration in = 7; + */ + in: Duration[]; + + /** + * `not_in` denotes that the field must not be equal to + * any of the specified values of the `google.protobuf.Duration` type. + * If the field's value matches any of these values, an error message will be + * generated. + * + * ```proto + * message MyDuration { + * // value must not be in list [1s, 2s, 3s] + * google.protobuf.Duration value = 1 [(buf.validate.field).duration.not_in = ["1s", "2s", "3s"]]; + * } + * ``` + * + * @generated from field: repeated google.protobuf.Duration not_in = 8; + */ + notIn: Duration[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyDuration { + * google.protobuf.Duration value = 1 [ + * (buf.validate.field).duration.example = { seconds: 1 }, + * (buf.validate.field).duration.example = { seconds: 2 }, + * ]; + * } + * ``` + * + * @generated from field: repeated google.protobuf.Duration example = 9; + */ + example: Duration[]; +}; + +/** + * Describes the message buf.validate.DurationRules. + * Use `create(DurationRulesSchema)` to create a new message. + */ +export const DurationRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 25); + +/** + * TimestampRules describe the rules applied exclusively to the `google.protobuf.Timestamp` well-known type. + * + * @generated from message buf.validate.TimestampRules + */ +export type TimestampRules = Message<"buf.validate.TimestampRules"> & { + /** + * `const` dictates that this field, of the `google.protobuf.Timestamp` type, must exactly match the specified value. If the field value doesn't correspond to the specified timestamp, an error message will be generated. + * + * ```proto + * message MyTimestamp { + * // value must equal 2023-05-03T10:00:00Z + * google.protobuf.Timestamp created_at = 1 [(buf.validate.field).timestamp.const = {seconds: 1727998800}]; + * } + * ``` + * + * @generated from field: optional google.protobuf.Timestamp const = 2; + */ + const?: Timestamp; + + /** + * @generated from oneof buf.validate.TimestampRules.less_than + */ + lessThan: { + /** + * requires the duration field value to be less than the specified value (field < value). If the field value doesn't meet the required conditions, an error message is generated. + * + * ```proto + * message MyDuration { + * // duration must be less than 'P3D' [duration.lt] + * google.protobuf.Duration value = 1 [(buf.validate.field).duration.lt = { seconds: 259200 }]; + * } + * ``` + * + * @generated from field: google.protobuf.Timestamp lt = 3; + */ + value: Timestamp; + case: "lt"; + } | { + /** + * requires the timestamp field value to be less than or equal to the specified value (field <= value). If the field value doesn't meet the required conditions, an error message is generated. + * + * ```proto + * message MyTimestamp { + * // timestamp must be less than or equal to '2023-05-14T00:00:00Z' [timestamp.lte] + * google.protobuf.Timestamp value = 1 [(buf.validate.field).timestamp.lte = { seconds: 1678867200 }]; + * } + * ``` + * + * @generated from field: google.protobuf.Timestamp lte = 4; + */ + value: Timestamp; + case: "lte"; + } | { + /** + * `lt_now` specifies that this field, of the `google.protobuf.Timestamp` type, must be less than the current time. `lt_now` can only be used with the `within` rule. + * + * ```proto + * message MyTimestamp { + * // value must be less than now + * google.protobuf.Timestamp created_at = 1 [(buf.validate.field).timestamp.lt_now = true]; + * } + * ``` + * + * @generated from field: bool lt_now = 7; + */ + value: boolean; + case: "ltNow"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.TimestampRules.greater_than + */ + greaterThan: { + /** + * `gt` requires the timestamp field value to be greater than the specified + * value (exclusive). If the value of `gt` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyTimestamp { + * // timestamp must be greater than '2023-01-01T00:00:00Z' [timestamp.gt] + * google.protobuf.Timestamp value = 1 [(buf.validate.field).timestamp.gt = { seconds: 1672444800 }]; + * + * // timestamp must be greater than '2023-01-01T00:00:00Z' and less than '2023-01-02T00:00:00Z' [timestamp.gt_lt] + * google.protobuf.Timestamp another_value = 2 [(buf.validate.field).timestamp = { gt: { seconds: 1672444800 }, lt: { seconds: 1672531200 } }]; + * + * // timestamp must be greater than '2023-01-02T00:00:00Z' or less than '2023-01-01T00:00:00Z' [timestamp.gt_lt_exclusive] + * google.protobuf.Timestamp other_value = 3 [(buf.validate.field).timestamp = { gt: { seconds: 1672531200 }, lt: { seconds: 1672444800 } }]; + * } + * ``` + * + * @generated from field: google.protobuf.Timestamp gt = 5; + */ + value: Timestamp; + case: "gt"; + } | { + /** + * `gte` requires the timestamp field value to be greater than or equal to the + * specified value (exclusive). If the value of `gte` is larger than a + * specified `lt` or `lte`, the range is reversed, and the field value + * must be outside the specified range. If the field value doesn't meet + * the required conditions, an error message is generated. + * + * ```proto + * message MyTimestamp { + * // timestamp must be greater than or equal to '2023-01-01T00:00:00Z' [timestamp.gte] + * google.protobuf.Timestamp value = 1 [(buf.validate.field).timestamp.gte = { seconds: 1672444800 }]; + * + * // timestamp must be greater than or equal to '2023-01-01T00:00:00Z' and less than '2023-01-02T00:00:00Z' [timestamp.gte_lt] + * google.protobuf.Timestamp another_value = 2 [(buf.validate.field).timestamp = { gte: { seconds: 1672444800 }, lt: { seconds: 1672531200 } }]; + * + * // timestamp must be greater than or equal to '2023-01-02T00:00:00Z' or less than '2023-01-01T00:00:00Z' [timestamp.gte_lt_exclusive] + * google.protobuf.Timestamp other_value = 3 [(buf.validate.field).timestamp = { gte: { seconds: 1672531200 }, lt: { seconds: 1672444800 } }]; + * } + * ``` + * + * @generated from field: google.protobuf.Timestamp gte = 6; + */ + value: Timestamp; + case: "gte"; + } | { + /** + * `gt_now` specifies that this field, of the `google.protobuf.Timestamp` type, must be greater than the current time. `gt_now` can only be used with the `within` rule. + * + * ```proto + * message MyTimestamp { + * // value must be greater than now + * google.protobuf.Timestamp created_at = 1 [(buf.validate.field).timestamp.gt_now = true]; + * } + * ``` + * + * @generated from field: bool gt_now = 8; + */ + value: boolean; + case: "gtNow"; + } | { case: undefined; value?: undefined }; + + /** + * `within` specifies that this field, of the `google.protobuf.Timestamp` type, must be within the specified duration of the current time. If the field value isn't within the duration, an error message is generated. + * + * ```proto + * message MyTimestamp { + * // value must be within 1 hour of now + * google.protobuf.Timestamp created_at = 1 [(buf.validate.field).timestamp.within = {seconds: 3600}]; + * } + * ``` + * + * @generated from field: optional google.protobuf.Duration within = 9; + */ + within?: Duration; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyTimestamp { + * google.protobuf.Timestamp value = 1 [ + * (buf.validate.field).timestamp.example = { seconds: 1672444800 }, + * (buf.validate.field).timestamp.example = { seconds: 1672531200 }, + * ]; + * } + * ``` + * + * @generated from field: repeated google.protobuf.Timestamp example = 10; + */ + example: Timestamp[]; +}; + +/** + * Describes the message buf.validate.TimestampRules. + * Use `create(TimestampRulesSchema)` to create a new message. + */ +export const TimestampRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 26); + +/** + * `Violations` is a collection of `Violation` messages. This message type is returned by + * Protovalidate when a proto message fails to meet the requirements set by the `Rule` validation rules. + * Each individual violation is represented by a `Violation` message. + * + * @generated from message buf.validate.Violations + */ +export type Violations = Message<"buf.validate.Violations"> & { + /** + * `violations` is a repeated field that contains all the `Violation` messages corresponding to the violations detected. + * + * @generated from field: repeated buf.validate.Violation violations = 1; + */ + violations: Violation[]; +}; + +/** + * Describes the message buf.validate.Violations. + * Use `create(ViolationsSchema)` to create a new message. + */ +export const ViolationsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 27); + +/** + * `Violation` represents a single instance where a validation rule, expressed + * as a `Rule`, was not met. It provides information about the field that + * caused the violation, the specific rule that wasn't fulfilled, and a + * human-readable error message. + * + * For example, consider the following message: + * + * ```proto + * message User { + * int32 age = 1 [(buf.validate.field).cel = { + * id: "user.age", + * expression: "this < 18 ? 'User must be at least 18 years old' : ''", + * }]; + * } + * ``` + * + * It could produce the following violation: + * + * ```json + * { + * "ruleId": "user.age", + * "message": "User must be at least 18 years old", + * "field": { + * "elements": [ + * { + * "fieldNumber": 1, + * "fieldName": "age", + * "fieldType": "TYPE_INT32" + * } + * ] + * }, + * "rule": { + * "elements": [ + * { + * "fieldNumber": 23, + * "fieldName": "cel", + * "fieldType": "TYPE_MESSAGE", + * "index": "0" + * } + * ] + * } + * } + * ``` + * + * @generated from message buf.validate.Violation + */ +export type Violation = Message<"buf.validate.Violation"> & { + /** + * `field` is a machine-readable path to the field that failed validation. + * This could be a nested field, in which case the path will include all the parent fields leading to the actual field that caused the violation. + * + * For example, consider the following message: + * + * ```proto + * message Message { + * bool a = 1 [(buf.validate.field).required = true]; + * } + * ``` + * + * It could produce the following violation: + * + * ```textproto + * violation { + * field { element { field_number: 1, field_name: "a", field_type: 8 } } + * ... + * } + * ``` + * + * @generated from field: optional buf.validate.FieldPath field = 5; + */ + field?: FieldPath; + + /** + * `rule` is a machine-readable path that points to the specific rule that failed validation. + * This will be a nested field starting from the FieldRules of the field that failed validation. + * For custom rules, this will provide the path of the rule, e.g. `cel[0]`. + * + * For example, consider the following message: + * + * ```proto + * message Message { + * bool a = 1 [(buf.validate.field).required = true]; + * bool b = 2 [(buf.validate.field).cel = { + * id: "custom_rule", + * expression: "!this ? 'b must be true': ''" + * }] + * } + * ``` + * + * It could produce the following violations: + * + * ```textproto + * violation { + * rule { element { field_number: 25, field_name: "required", field_type: 8 } } + * ... + * } + * violation { + * rule { element { field_number: 23, field_name: "cel", field_type: 11, index: 0 } } + * ... + * } + * ``` + * + * @generated from field: optional buf.validate.FieldPath rule = 6; + */ + rule?: FieldPath; + + /** + * `rule_id` is the unique identifier of the `Rule` that was not fulfilled. + * This is the same `id` that was specified in the `Rule` message, allowing easy tracing of which rule was violated. + * + * @generated from field: optional string rule_id = 2; + */ + ruleId: string; + + /** + * `message` is a human-readable error message that describes the nature of the violation. + * This can be the default error message from the violated `Rule`, or it can be a custom message that gives more context about the violation. + * + * @generated from field: optional string message = 3; + */ + message: string; + + /** + * `for_key` indicates whether the violation was caused by a map key, rather than a value. + * + * @generated from field: optional bool for_key = 4; + */ + forKey: boolean; +}; + +/** + * Describes the message buf.validate.Violation. + * Use `create(ViolationSchema)` to create a new message. + */ +export const ViolationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 28); + +/** + * `FieldPath` provides a path to a nested protobuf field. + * + * This message provides enough information to render a dotted field path even without protobuf descriptors. + * It also provides enough information to resolve a nested field through unknown wire data. + * + * @generated from message buf.validate.FieldPath + */ +export type FieldPath = Message<"buf.validate.FieldPath"> & { + /** + * `elements` contains each element of the path, starting from the root and recursing downward. + * + * @generated from field: repeated buf.validate.FieldPathElement elements = 1; + */ + elements: FieldPathElement[]; +}; + +/** + * Describes the message buf.validate.FieldPath. + * Use `create(FieldPathSchema)` to create a new message. + */ +export const FieldPathSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 29); + +/** + * `FieldPathElement` provides enough information to nest through a single protobuf field. + * + * If the selected field is a map or repeated field, the `subscript` value selects a specific element from it. + * A path that refers to a value nested under a map key or repeated field index will have a `subscript` value. + * The `field_type` field allows unambiguous resolution of a field even if descriptors are not available. + * + * @generated from message buf.validate.FieldPathElement + */ +export type FieldPathElement = Message<"buf.validate.FieldPathElement"> & { + /** + * `field_number` is the field number this path element refers to. + * + * @generated from field: optional int32 field_number = 1; + */ + fieldNumber: number; + + /** + * `field_name` contains the field name this path element refers to. + * This can be used to display a human-readable path even if the field number is unknown. + * + * @generated from field: optional string field_name = 2; + */ + fieldName: string; + + /** + * `field_type` specifies the type of this field. When using reflection, this value is not needed. + * + * This value is provided to make it possible to traverse unknown fields through wire data. + * When traversing wire data, be mindful of both packed[1] and delimited[2] encoding schemes. + * + * [1]: https://protobuf.dev/programming-guides/encoding/#packed + * [2]: https://protobuf.dev/programming-guides/encoding/#groups + * + * N.B.: Although groups are deprecated, the corresponding delimited encoding scheme is not, and + * can be explicitly used in Protocol Buffers 2023 Edition. + * + * @generated from field: optional google.protobuf.FieldDescriptorProto.Type field_type = 3; + */ + fieldType: FieldDescriptorProto_Type; + + /** + * `key_type` specifies the map key type of this field. This value is useful when traversing + * unknown fields through wire data: specifically, it allows handling the differences between + * different integer encodings. + * + * @generated from field: optional google.protobuf.FieldDescriptorProto.Type key_type = 4; + */ + keyType: FieldDescriptorProto_Type; + + /** + * `value_type` specifies map value type of this field. This is useful if you want to display a + * value inside unknown fields through wire data. + * + * @generated from field: optional google.protobuf.FieldDescriptorProto.Type value_type = 5; + */ + valueType: FieldDescriptorProto_Type; + + /** + * `subscript` contains a repeated index or map key, if this path element nests into a repeated or map field. + * + * @generated from oneof buf.validate.FieldPathElement.subscript + */ + subscript: { + /** + * `index` specifies a 0-based index into a repeated field. + * + * @generated from field: uint64 index = 6; + */ + value: bigint; + case: "index"; + } | { + /** + * `bool_key` specifies a map key of type bool. + * + * @generated from field: bool bool_key = 7; + */ + value: boolean; + case: "boolKey"; + } | { + /** + * `int_key` specifies a map key of type int32, int64, sint32, sint64, sfixed32 or sfixed64. + * + * @generated from field: int64 int_key = 8; + */ + value: bigint; + case: "intKey"; + } | { + /** + * `uint_key` specifies a map key of type uint32, uint64, fixed32 or fixed64. + * + * @generated from field: uint64 uint_key = 9; + */ + value: bigint; + case: "uintKey"; + } | { + /** + * `string_key` specifies a map key of type string. + * + * @generated from field: string string_key = 10; + */ + value: string; + case: "stringKey"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message buf.validate.FieldPathElement. + * Use `create(FieldPathElementSchema)` to create a new message. + */ +export const FieldPathElementSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 30); + +/** + * Specifies how `FieldRules.ignore` behaves, depending on the field's value, and + * whether the field tracks presence. + * + * @generated from enum buf.validate.Ignore + */ +export enum Ignore { + /** + * Ignore rules if the field tracks presence and is unset. This is the default + * behavior. + * + * In proto3, only message fields, members of a Protobuf `oneof`, and fields + * with the `optional` label track presence. Consequently, the following fields + * are always validated, whether a value is set or not: + * + * ```proto + * syntax="proto3"; + * + * message RulesApply { + * string email = 1 [ + * (buf.validate.field).string.email = true + * ]; + * int32 age = 2 [ + * (buf.validate.field).int32.gt = 0 + * ]; + * repeated string labels = 3 [ + * (buf.validate.field).repeated.min_items = 1 + * ]; + * } + * ``` + * + * In contrast, the following fields track presence, and are only validated if + * a value is set: + * + * ```proto + * syntax="proto3"; + * + * message RulesApplyIfSet { + * optional string email = 1 [ + * (buf.validate.field).string.email = true + * ]; + * oneof ref { + * string reference = 2 [ + * (buf.validate.field).string.uuid = true + * ]; + * string name = 3 [ + * (buf.validate.field).string.min_len = 4 + * ]; + * } + * SomeMessage msg = 4 [ + * (buf.validate.field).cel = {/* ... *\/} + * ]; + * } + * ``` + * + * To ensure that such a field is set, add the `required` rule. + * + * To learn which fields track presence, see the + * [Field Presence cheat sheet](https://protobuf.dev/programming-guides/field_presence/#cheat). + * + * @generated from enum value: IGNORE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * Ignore rules if the field is unset, or set to the zero value. + * + * The zero value depends on the field type: + * - For strings, the zero value is the empty string. + * - For bytes, the zero value is empty bytes. + * - For bool, the zero value is false. + * - For numeric types, the zero value is zero. + * - For enums, the zero value is the first defined enum value. + * - For repeated fields, the zero is an empty list. + * - For map fields, the zero is an empty map. + * - For message fields, absence of the message (typically a null-value) is considered zero value. + * + * For fields that track presence (e.g. adding the `optional` label in proto3), + * this a no-op and behavior is the same as the default `IGNORE_UNSPECIFIED`. + * + * @generated from enum value: IGNORE_IF_ZERO_VALUE = 1; + */ + IF_ZERO_VALUE = 1, + + /** + * Always ignore rules, including the `required` rule. + * + * This is useful for ignoring the rules of a referenced message, or to + * temporarily ignore rules during development. + * + * ```proto + * message MyMessage { + * // The field's rules will always be ignored, including any validations + * // on value's fields. + * MyOtherMessage value = 1 [ + * (buf.validate.field).ignore = IGNORE_ALWAYS]; + * } + * ``` + * + * @generated from enum value: IGNORE_ALWAYS = 3; + */ + ALWAYS = 3, +} + +/** + * Describes the enum buf.validate.Ignore. + */ +export const IgnoreSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_buf_validate_validate, 0); + +/** + * KnownRegex contains some well-known patterns. + * + * @generated from enum buf.validate.KnownRegex + */ +export enum KnownRegex { + /** + * @generated from enum value: KNOWN_REGEX_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * HTTP header name as defined by [RFC 7230](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2). + * + * @generated from enum value: KNOWN_REGEX_HTTP_HEADER_NAME = 1; + */ + HTTP_HEADER_NAME = 1, + + /** + * HTTP header value as defined by [RFC 7230](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.4). + * + * @generated from enum value: KNOWN_REGEX_HTTP_HEADER_VALUE = 2; + */ + HTTP_HEADER_VALUE = 2, +} + +/** + * Describes the enum buf.validate.KnownRegex. + */ +export const KnownRegexSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_buf_validate_validate, 1); + +/** + * Rules specify the validations to be performed on this message. By default, + * no validation is performed against a message. + * + * @generated from extension: optional buf.validate.MessageRules message = 1159; + */ +export const message: GenExtension = /*@__PURE__*/ + extDesc(file_buf_validate_validate, 0); + +/** + * Rules specify the validations to be performed on this oneof. By default, + * no validation is performed against a oneof. + * + * @generated from extension: optional buf.validate.OneofRules oneof = 1159; + */ +export const oneof: GenExtension = /*@__PURE__*/ + extDesc(file_buf_validate_validate, 1); + +/** + * Rules specify the validations to be performed on this field. By default, + * no validation is performed against a field. + * + * @generated from extension: optional buf.validate.FieldRules field = 1159; + */ +export const field: GenExtension = /*@__PURE__*/ + extDesc(file_buf_validate_validate, 2); + +/** + * Specifies predefined rules. When extending a standard rule message, + * this adds additional CEL expressions that apply when the extension is used. + * + * ```proto + * extend buf.validate.Int32Rules { + * bool is_zero [(buf.validate.predefined).cel = { + * id: "int32.is_zero", + * message: "value must be zero", + * expression: "!rule || this == 0", + * }]; + * } + * + * message Foo { + * int32 reserved = 1 [(buf.validate.field).int32.(is_zero) = true]; + * } + * ``` + * + * @generated from extension: optional buf.validate.PredefinedRules predefined = 1160; + */ +export const predefined: GenExtension = /*@__PURE__*/ + extDesc(file_buf_validate_validate, 3); + diff --git a/flyteidl2/gen_utils/ts/package.json b/flyteidl2/gen_utils/ts/package.json new file mode 100644 index 0000000000..2c6e180d91 --- /dev/null +++ b/flyteidl2/gen_utils/ts/package.json @@ -0,0 +1,26 @@ +{ + "name": "@flyteorg/flyteidl2", + "version": "0.0.0-develop", + "description": "Compiled protocol buffers and gRPC service and connect clients/servers for Flyte IDLs", + "repository": { + "type": "git", + "url": "git@github.com:flyteorg/flyte" + }, + "author": "Union Eng ", + "license": "Apache-2.0", + "keywords": [ + "flyte", + "flyte2" + ], + "files": [ + "flyteidl2", + "buf", + "google" + ], + "dependencies": { + "@bufbuild/protobuf": "^2.10.0" + }, + "devDependencies": { + "typescript": "^5.6.0" + } +} diff --git a/flyteidl2/gen_utils/ts/tsconfig.json b/flyteidl2/gen_utils/ts/tsconfig.json new file mode 100644 index 0000000000..3b37703eef --- /dev/null +++ b/flyteidl2/gen_utils/ts/tsconfig.json @@ -0,0 +1,23 @@ +{ + "compilerOptions": { + "target": "ES2020", + "module": "ESNext", + "lib": ["ES2020"], + "moduleResolution": "bundler", + "strict": true, + "skipLibCheck": true, + "esModuleInterop": true, + "allowSyntheticDefaultImports": true, + "forceConsistentCasingInFileNames": true, + "noEmit": true, + "resolveJsonModule": true, + "isolatedModules": true, + "allowImportingTsExtensions": true + }, + "include": [ + "**/*.ts" + ], + "exclude": [ + "node_modules" + ] +} diff --git a/flyteidl2/imagebuilder/definition.proto b/flyteidl2/imagebuilder/definition.proto new file mode 100644 index 0000000000..0abbbae44e --- /dev/null +++ b/flyteidl2/imagebuilder/definition.proto @@ -0,0 +1,148 @@ +syntax = "proto3"; + +package flyteidl2.imagebuilder; + +import "buf/validate/validate.proto"; +import "flyteidl2/core/security.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/imagebuilder"; + +// ImageIdentifier is how to identify an image +message ImageIdentifier { + string name = 1 [(buf.validate.field).string.min_len = 1]; +} + +// Simple container to surface if image exists +message Image { + ImageIdentifier id = 1; + // Fully qualified, pullable, image name + string fqin = 2; +} + +// AptPackages defines a list of apt packages to install in the image. +message AptPackages { + // List of apt packages to install + repeated string packages = 1; + repeated flyteidl2.core.Secret secret_mounts = 2; +} + +// PipOptions defines options for pip packages to install in the image. +message PipOptions { + // Optional index URL for pip packages + string index_url = 2; + // Optional list of extra index URLs for pip packages + repeated string extra_index_urls = 3; + // Optional pre-release flag for pip packages + bool pre = 4; + // Optional extra arguments for pip install command + string extra_args = 5; +} + +// PipPackages defines a list of pip packages to install in the image. +message PipPackages { + // List of pip packages to install + repeated string packages = 1; + // Options for pip packages. + PipOptions options = 2; + repeated flyteidl2.core.Secret secret_mounts = 3; +} + +// Requirements defines a python requirements file to use in the image. +message Requirements { + // The requirements file to use. + string file = 1; + // Options for pip packages. + PipOptions options = 2; + repeated flyteidl2.core.Secret secret_mounts = 3; +} + +message PythonWheels { + // The directory containing Python wheel files. + string dir = 1; + // Options for pip packages. + PipOptions options = 2; + repeated flyteidl2.core.Secret secret_mounts = 3; +} + +// UVProject defines a UV project configuration, which includes +// a pyproject.toml file and a uvlock file. +message UVProject { + string pyproject = 1; + string uvlock = 2; + // Options for pip packages. + PipOptions options = 3; + repeated flyteidl2.core.Secret secret_mounts = 4; +} + +// Commands defines a list of commands to run in the image. +message Commands { + // The command to run. + repeated string cmd = 2; + repeated flyteidl2.core.Secret secret_mounts = 3; +} + +// WorkDir defines the working directory to set in the image. +message WorkDir { + // The working directory to use. + string workdir = 1; +} + +// CopyConfig defines a configuration for copying files/directories into the image. +message CopyConfig { + // The source directory to copy from. + string src = 1; + // The destination directory to copy to. + string dst = 2; +} + +// Env defines environment to set in the image. +message Env { + // Environment variables to set in the image. + map env_variables = 1; +} + +message PoetryProject { + string pyproject = 1; + string poetry_lock = 2; + // Optional extra arguments for poetry install command + string extra_args = 3; + repeated flyteidl2.core.Secret secret_mounts = 4; +} + +// Layer defines a layer in the image, which can be one of several types. +message Layer { + oneof layer { + // Apt packages to install. + AptPackages apt_packages = 1; + // Python packages to install. + PipPackages pip_packages = 2; + // Custom command to run. + Commands commands = 3; + // Requirements file to use. + Requirements requirements = 4; + // Python wheel file to use. + PythonWheels python_wheels = 5; + // Working directory to set. + WorkDir workdir = 6; + // Copy files/directories into the image. + CopyConfig copy_config = 7; + // UV project configuration. + UVProject uv_project = 8; + // Environment variables to set. + Env env = 9; + // Poetry project configuration + PoetryProject poetry_project = 10; + } +} + +// Image definition defined in the sdk. +message ImageSpec { + // Identifier for the base image. + string base_image = 1; + // python version to use in the image. + string python_version = 2; + // List of layers to apply to the image. + repeated Layer layers = 3; + // List of platforms to build the image for. + repeated string platform = 4; +} diff --git a/flyteidl2/imagebuilder/payload.proto b/flyteidl2/imagebuilder/payload.proto new file mode 100644 index 0000000000..d5a9e12a46 --- /dev/null +++ b/flyteidl2/imagebuilder/payload.proto @@ -0,0 +1,28 @@ +syntax = "proto3"; + +package flyteidl2.imagebuilder; + +import "buf/validate/validate.proto"; +import "flyteidl2/common/identifier.proto"; +import "flyteidl2/imagebuilder/definition.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/imagebuilder"; + +message GetImageRequest { + // Image ID + ImageIdentifier id = 1 [(buf.validate.field).required = true]; + + // Optional organization that dictates which dataplane registry to reference + // Deprecated, please use the full ProjectIdentifier instead + string organization = 2 [deprecated = true]; + + // The scope in which to look for the image. Images maybe accessible in different project-domain pairs through + // different container registries (i.e. different image FQDNs) + // TODO: This scope will be made required after updating all clients/servers to respect it. + flyteidl2.common.ProjectIdentifier project_id = 3; +} + +// GetSecretProxyResponse returns the looked up secret from the secret service +message GetImageResponse { + Image image = 1; +} diff --git a/flyteidl2/imagebuilder/service.proto b/flyteidl2/imagebuilder/service.proto new file mode 100644 index 0000000000..34696b7543 --- /dev/null +++ b/flyteidl2/imagebuilder/service.proto @@ -0,0 +1,13 @@ +syntax = "proto3"; + +package flyteidl2.imagebuilder; + +import "flyteidl2/imagebuilder/payload.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/imagebuilder"; + +service ImageService { + rpc GetImage(GetImageRequest) returns (GetImageResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } +} diff --git a/flyteidl2/logs/dataplane/payload.proto b/flyteidl2/logs/dataplane/payload.proto new file mode 100644 index 0000000000..001ac602e3 --- /dev/null +++ b/flyteidl2/logs/dataplane/payload.proto @@ -0,0 +1,139 @@ +syntax = "proto3"; + +package flyteidl2.logs.dataplane; + +import "buf/validate/validate.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/logs/dataplane"; + +message PodResource { + // The namespace of the pod. + string namespace = 1 [(buf.validate.field).string.min_len = 1]; + + // The pod name. + string name = 2 [(buf.validate.field).string.min_len = 1]; + + // The container name. If not provided, attempt to find the primary container, else assume the first container. + // +optional + string container = 3; +} + +// Parameters of environment in which logs were collected. Should contain everything +// necessary to identify location of task execution logs in cloud providers. +message LoggingContext { + reserved 1, 2; + + string cluster_name = 3 [(buf.validate.field).string.min_len = 1]; + string kubernetes_namespace = 4 [(buf.validate.field).string.min_len = 1]; + string kubernetes_pod_name = 5 [(buf.validate.field).string.min_len = 1]; + string kubernetes_container_name = 6 [(buf.validate.field).string.min_len = 1]; + google.protobuf.Timestamp execution_attempt_start_time = 7; + google.protobuf.Timestamp execution_attempt_end_time = 8; + map kubernetes_pod_labels = 9; +} + +// Parameters of environment in which logs were collected. Should contain everything +// necessary to identify location of task execution logs in cloud providers. +message ContainerIdentifier { + // The name of the cluster. + string cluster_name = 1 [(buf.validate.field).string.min_len = 1]; + + // The namespace in Kubernetes. + string kubernetes_namespace = 2 [(buf.validate.field).string.min_len = 1]; + + // The name of the pod in Kubernetes. + string kubernetes_pod_name = 3 [(buf.validate.field).string.min_len = 1]; + + // The name of the container in Kubernetes. + string kubernetes_container_name = 4; +} + +message ContainerSelector { + // The name of the cluster. + string cluster_name = 1 [(buf.validate.field).string.min_len = 1]; + + // The namespace in Kubernetes. + string kubernetes_namespace = 2 [(buf.validate.field).string.min_len = 1]; + + // The prefix of the name of the pod in Kubernetes. This will only apply to persisted pods' logs because listing by + // prefix is the supported way to filter pods. + string kubernetes_pod_name_prefix = 3; + + // The name of the container in Kubernetes. If not specified, logs for all containers + // will be streamed. + string kubernetes_container_name = 4; + + // The label selector to filter pods. This will only apply to live pods' logs because Listing by prefix + // isn't supported. + string kubernetes_pod_label_selector = 5; +} + +message LiveLogsOptions { + // LogPodStatus indicates whether to log the pod status along with the logs. + bool log_pod_status = 1; + + // LogTimestamps indicates whether to log the timestamps along with the logs. It prepends RFC3339 or RFC3339Nano + // format in the beginning of each log line. + bool log_timestamps = 2; +} + +enum LogLineOriginator { + // The originator of the log line is unknown. + UNKNOWN = 0; + + // The originator of the log line is the user application. + USER = 1; + + // The originator of the log line is the system. + SYSTEM = 2; +} + +message LogLine { + google.protobuf.Timestamp timestamp = 1; + + // Each line is separated by either CRLF, CR or LF, which are included + // at the ends of the lines. This lets clients know whether log emitter + // wanted to overwrite the previous line (LF) or append a new line (CRLF). + string message = 2; + + LogLineOriginator originator = 3; +} + +message LogLines { + // Each line is separated by either CRLF, CR or LF, which are included + // at the ends of the lines. This lets clients know whether log emitter + // wanted to overwrite the previous line (LF) or append a new line (CRLF). + repeated string lines = 1 [deprecated = true]; + + // The index of the container in the list of containers. If the request was made with a single container identifier, + // this value will always be 0. Otherwise, it'll be an index into the last list of containers sent in the stream. + uint32 container_index = 2; + + // The container identifier. + ContainerIdentifier container = 3 [(buf.validate.field).required = true]; + + // Each line is separated by either CRLF, CR or LF, which are included + // at the ends of the lines. This lets clients know whether log emitter + // wanted to overwrite the previous line (LF) or append a new line (CRLF). + repeated LogLine structured_lines = 4; +} + +message LogContainersList { + repeated ContainerIdentifier containers = 1; +} + +message LogLinesBatch { + repeated LogLines logs = 1; +} + +enum LogsSource { + // Return live logs and fall back to persisted if not available. + LIVE_OR_PERSISTED = 0; + + // Return live logs only or error if pod is no longer around. + LIVE_ONLY = 1; + + // Return persisted logs only. + PERSISTED_ONLY = 2; +} diff --git a/flyteidl2/plugins/common.proto b/flyteidl2/plugins/common.proto new file mode 100644 index 0000000000..bd00e0a7e6 --- /dev/null +++ b/flyteidl2/plugins/common.proto @@ -0,0 +1,27 @@ +syntax = "proto3"; + +package flyteidl2.plugins; + +import "flyteidl2/core/tasks.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins"; + +enum RestartPolicy { + RESTART_POLICY_NEVER = 0; + RESTART_POLICY_ON_FAILURE = 1; + RESTART_POLICY_ALWAYS = 2; +} + +message CommonReplicaSpec { + // Number of replicas + int32 replicas = 1; + + // Image used for the replica group + string image = 2; + + // Resources required for the replica group + core.Resources resources = 3; + + // RestartPolicy determines whether pods will be restarted when they exit + RestartPolicy restart_policy = 4; +} diff --git a/flyteidl2/plugins/dask.proto b/flyteidl2/plugins/dask.proto new file mode 100644 index 0000000000..06ea1f6be6 --- /dev/null +++ b/flyteidl2/plugins/dask.proto @@ -0,0 +1,40 @@ +syntax = "proto3"; + +package flyteidl2.plugins; + +import "flyteidl2/core/tasks.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins"; + +// Custom Proto for Dask Plugin. +message DaskJob { + // Spec for the scheduler pod. + DaskScheduler scheduler = 1; + + // Spec of the default worker group. + DaskWorkerGroup workers = 2; +} + +// Specification for the scheduler pod. +message DaskScheduler { + // Optional image to use. If unset, will use the default image. + string image = 1; + + // Resources assigned to the scheduler pod. + flyteidl2.core.Resources resources = 2; +} + +message DaskWorkerGroup { + // Number of workers in the group. + uint32 number_of_workers = 1; + + // Optional image to use for the pods of the worker group. If unset, will use the default image. + string image = 2; + + // Resources assigned to the all pods of the worker group. + // As per https://kubernetes.dask.org/en/latest/kubecluster.html?highlight=limit#best-practices + // it is advised to only set limits. If requests are not explicitly set, the plugin will make + // sure to set requests==limits. + // The plugin sets ` --memory-limit` as well as `--nthreads` for the workers according to the limit. + flyteidl2.core.Resources resources = 3; +} diff --git a/flyteidl2/plugins/kubeflow/common.proto b/flyteidl2/plugins/kubeflow/common.proto new file mode 100644 index 0000000000..00ebf4775d --- /dev/null +++ b/flyteidl2/plugins/kubeflow/common.proto @@ -0,0 +1,26 @@ +syntax = "proto3"; + +package flyteidl2.plugins.kubeflow; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow"; + +enum CleanPodPolicy { + CLEANPOD_POLICY_NONE = 0; + CLEANPOD_POLICY_RUNNING = 1; + CLEANPOD_POLICY_ALL = 2; +} + +message RunPolicy { + // Defines the policy to kill pods after the job completes. Default to None. + CleanPodPolicy clean_pod_policy = 1; + + // TTL to clean up jobs. Default to infinite. + int32 ttl_seconds_after_finished = 2; + + // Specifies the duration in seconds relative to the startTime that the job may be active + // before the system tries to terminate it; value must be positive integer. + int32 active_deadline_seconds = 3; + + // Number of retries before marking this job failed. + int32 backoff_limit = 4; +} diff --git a/flyteidl2/plugins/kubeflow/mpi.proto b/flyteidl2/plugins/kubeflow/mpi.proto new file mode 100644 index 0000000000..601f3b0ed0 --- /dev/null +++ b/flyteidl2/plugins/kubeflow/mpi.proto @@ -0,0 +1,48 @@ +syntax = "proto3"; + +package flyteidl2.plugins.kubeflow; + +import "flyteidl2/core/tasks.proto"; +import "flyteidl2/plugins/common.proto"; +import "flyteidl2/plugins/kubeflow/common.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow"; + +// Proto for plugin that enables distributed training using https://github.com/kubeflow/mpi-operator +message DistributedMPITrainingTask { + // Worker replicas spec + DistributedMPITrainingReplicaSpec worker_replicas = 1; + + // Master replicas spec + DistributedMPITrainingReplicaSpec launcher_replicas = 2; + + // RunPolicy encapsulates various runtime policies of the distributed training + // job, for example how to clean up resources and how long the job can stay + // active. + RunPolicy run_policy = 3; + + // Number of slots per worker + int32 slots = 4; +} + +// Replica specification for distributed MPI training +message DistributedMPITrainingReplicaSpec { + // 1~4 deprecated. Use common instead. + // Number of replicas + int32 replicas = 1 [deprecated = true]; + + // Image used for the replica group + string image = 2 [deprecated = true]; + + // Resources required for the replica group + core.Resources resources = 3 [deprecated = true]; + + // Restart policy determines whether pods will be restarted when they exit + RestartPolicy restart_policy = 4 [deprecated = true]; + + // MPI sometimes requires different command set for different replica groups + repeated string command = 5; + + // The common replica spec + CommonReplicaSpec common = 6; +} diff --git a/flyteidl2/plugins/kubeflow/pytorch.proto b/flyteidl2/plugins/kubeflow/pytorch.proto new file mode 100644 index 0000000000..76172b6aa9 --- /dev/null +++ b/flyteidl2/plugins/kubeflow/pytorch.proto @@ -0,0 +1,54 @@ +syntax = "proto3"; + +package flyteidl2.plugins.kubeflow; + +import "flyteidl2/core/tasks.proto"; +import "flyteidl2/plugins/common.proto"; +import "flyteidl2/plugins/kubeflow/common.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow"; + +// Custom proto for torch elastic config for distributed training using +// https://github.com/kubeflow/training-operator/blob/master/pkg/apis/kubeflow.org/v1/pytorch_types.go +message ElasticConfig { + string rdzv_backend = 1; + int32 min_replicas = 2; + int32 max_replicas = 3; + int32 nproc_per_node = 4; + int32 max_restarts = 5; +} + +// Proto for plugin that enables distributed training using https://github.com/kubeflow/pytorch-operator +message DistributedPyTorchTrainingTask { + // Worker replicas spec + DistributedPyTorchTrainingReplicaSpec worker_replicas = 1; + + // Master replicas spec, master replicas can only have 1 replica + DistributedPyTorchTrainingReplicaSpec master_replicas = 2; + + // RunPolicy encapsulates various runtime policies of the distributed training + // job, for example how to clean up resources and how long the job can stay + // active. + RunPolicy run_policy = 3; + + // config for an elastic pytorch job + ElasticConfig elastic_config = 4; +} + +message DistributedPyTorchTrainingReplicaSpec { + // 1~4 deprecated. Use common instead. + // Number of replicas + int32 replicas = 1 [deprecated = true]; + + // Image used for the replica group + string image = 2 [deprecated = true]; + + // Resources required for the replica group + core.Resources resources = 3 [deprecated = true]; + + // Restart policy determines whether pods will be restarted when they exit + RestartPolicy restart_policy = 4 [deprecated = true]; + + // The common replica spec + CommonReplicaSpec common = 5; +} diff --git a/flyteidl2/plugins/kubeflow/tensorflow.proto b/flyteidl2/plugins/kubeflow/tensorflow.proto new file mode 100644 index 0000000000..8573cf71dd --- /dev/null +++ b/flyteidl2/plugins/kubeflow/tensorflow.proto @@ -0,0 +1,47 @@ +syntax = "proto3"; + +package flyteidl2.plugins.kubeflow; + +import "flyteidl2/core/tasks.proto"; +import "flyteidl2/plugins/common.proto"; +import "flyteidl2/plugins/kubeflow/common.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow"; + +// Proto for plugin that enables distributed training using https://github.com/kubeflow/tf-operator +message DistributedTensorflowTrainingTask { + // Worker replicas spec + DistributedTensorflowTrainingReplicaSpec worker_replicas = 1; + + // Parameter server replicas spec + DistributedTensorflowTrainingReplicaSpec ps_replicas = 2; + + // Chief replicas spec + DistributedTensorflowTrainingReplicaSpec chief_replicas = 3; + + // RunPolicy encapsulates various runtime policies of the distributed training + // job, for example how to clean up resources and how long the job can stay + // active. + RunPolicy run_policy = 4; + + // Evaluator replicas spec + DistributedTensorflowTrainingReplicaSpec evaluator_replicas = 5; +} + +message DistributedTensorflowTrainingReplicaSpec { + // 1~4 deprecated. Use common instead. + // Number of replicas + int32 replicas = 1 [deprecated = true]; + + // Image used for the replica group + string image = 2 [deprecated = true]; + + // Resources required for the replica group + core.Resources resources = 3 [deprecated = true]; + + // Restart policy determines whether pods will be restarted when they exit + RestartPolicy restart_policy = 4 [deprecated = true]; + + // The common replica spec + CommonReplicaSpec common = 5; +} diff --git a/flyteidl2/plugins/mpi.proto b/flyteidl2/plugins/mpi.proto new file mode 100644 index 0000000000..70136607fc --- /dev/null +++ b/flyteidl2/plugins/mpi.proto @@ -0,0 +1,20 @@ +syntax = "proto3"; + +package flyteidl2.plugins; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins"; + +// MPI operator proposal https://github.com/kubeflow/community/blob/master/proposals/mpi-operator-proposal.md +// Custom proto for plugin that enables distributed training using https://github.com/kubeflow/mpi-operator +message DistributedMPITrainingTask { + // number of worker spawned in the cluster for this job + int32 num_workers = 1; + + // number of launcher replicas spawned in the cluster for this job + // The launcher pod invokes mpirun and communicates with worker pods through MPI. + int32 num_launcher_replicas = 2; + + // number of slots per worker used in hostfile. + // The available slots (GPUs) in each pod. + int32 slots = 3; +} diff --git a/flyteidl2/plugins/presto.proto b/flyteidl2/plugins/presto.proto new file mode 100644 index 0000000000..4eb6628bec --- /dev/null +++ b/flyteidl2/plugins/presto.proto @@ -0,0 +1,14 @@ +syntax = "proto3"; + +package flyteidl2.plugins; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins"; + +// This message works with the 'presto' task type in the SDK and is the object that will be in the 'custom' field +// of a Presto task's TaskTemplate +message PrestoQuery { + string routing_group = 1; + string catalog = 2; + string schema = 3; + string statement = 4; +} diff --git a/flyteidl2/plugins/pytorch.proto b/flyteidl2/plugins/pytorch.proto new file mode 100644 index 0000000000..536e046c74 --- /dev/null +++ b/flyteidl2/plugins/pytorch.proto @@ -0,0 +1,24 @@ +syntax = "proto3"; + +package flyteidl2.plugins; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins"; + +// Custom proto for torch elastic config for distributed training using +// https://github.com/kubeflow/trainer/blob/e31d11faa9f6ce5111b60c01079d39295589e0ef/pkg/apis/kubeflow.org/v1/pytorch_types.go#L98 +message ElasticConfig { + string rdzv_backend = 1; + int32 min_replicas = 2; + int32 max_replicas = 3; + int32 nproc_per_node = 4; + int32 max_restarts = 5; +} + +// Custom proto for plugin that enables distributed training using https://github.com/kubeflow/trainer +message DistributedPyTorchTrainingTask { + // number of worker replicas spawned in the cluster for this job + int32 workers = 1; + + // config for an elastic pytorch job + ElasticConfig elastic_config = 2; +} diff --git a/flyteidl2/plugins/qubole.proto b/flyteidl2/plugins/qubole.proto new file mode 100644 index 0000000000..10c7686975 --- /dev/null +++ b/flyteidl2/plugins/qubole.proto @@ -0,0 +1,26 @@ +syntax = "proto3"; + +package flyteidl2.plugins; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins"; + +// Defines a query to execute on a hive cluster. +message HiveQuery { + string query = 1; + uint32 timeout_sec = 2; + uint32 retryCount = 3; +} + +// Defines a collection of hive queries. +message HiveQueryCollection { + repeated HiveQuery queries = 2; +} + +// This message works with the 'hive' task type in the SDK and is the object that will be in the 'custom' field +// of a hive task's TaskTemplate +message QuboleHiveJob { + string cluster_label = 1; + HiveQueryCollection query_collection = 2 [deprecated = true]; + repeated string tags = 3; + HiveQuery query = 4; +} diff --git a/flyteidl2/plugins/ray.proto b/flyteidl2/plugins/ray.proto new file mode 100644 index 0000000000..d490823143 --- /dev/null +++ b/flyteidl2/plugins/ray.proto @@ -0,0 +1,59 @@ +syntax = "proto3"; + +package flyteidl2.plugins; + +import "flyteidl2/core/tasks.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins"; + +// RayJobSpec defines the desired state of RayJob +message RayJob { + // RayClusterSpec is the cluster template to run the job + RayCluster ray_cluster = 1; + // runtime_env is base64 encoded. + // Ray runtime environments: https://docs.ray.io/en/latest/ray-core/handling-dependencies.html#runtime-environments + string runtime_env = 2 [deprecated = true]; + // shutdown_after_job_finishes specifies whether the RayCluster should be deleted after the RayJob finishes. + bool shutdown_after_job_finishes = 3; + // ttl_seconds_after_finished specifies the number of seconds after which the RayCluster will be deleted after the RayJob finishes. + int32 ttl_seconds_after_finished = 4; + // RuntimeEnvYAML represents the runtime environment configuration + // provided as a multi-line YAML string. + string runtime_env_yaml = 5; +} + +// Define Ray cluster defines the desired state of RayCluster +message RayCluster { + // HeadGroupSpecs are the spec for the head pod + HeadGroupSpec head_group_spec = 1; + // WorkerGroupSpecs are the specs for the worker pods + repeated WorkerGroupSpec worker_group_spec = 2; + // Whether to enable autoscaling. + bool enable_autoscaling = 3; +} + +// HeadGroupSpec are the spec for the head pod +message HeadGroupSpec { + // Optional. RayStartParams are the params of the start command: address, object-store-memory. + // Refer to https://docs.ray.io/en/latest/ray-core/package-ref.html#ray-start + map ray_start_params = 1; + // Pod Spec for the ray head pod + core.K8sPod k8s_pod = 2; +} + +// WorkerGroupSpec are the specs for the worker pods +message WorkerGroupSpec { + // Required. RayCluster can have multiple worker groups, and it distinguishes them by name + string group_name = 1; + // Required. Desired replicas of the worker group. Defaults to 1. + int32 replicas = 2; + // Optional. Min replicas of the worker group. MinReplicas defaults to 1. + int32 min_replicas = 3; + // Optional. Max replicas of the worker group. MaxReplicas defaults to maxInt32 + int32 max_replicas = 4; + // Optional. RayStartParams are the params of the start command: address, object-store-memory. + // Refer to https://docs.ray.io/en/latest/ray-core/package-ref.html#ray-start + map ray_start_params = 5; + // Pod Spec for ray worker pods + core.K8sPod k8s_pod = 6; +} diff --git a/flyteidl2/plugins/spark.proto b/flyteidl2/plugins/spark.proto new file mode 100644 index 0000000000..2a2f90d692 --- /dev/null +++ b/flyteidl2/plugins/spark.proto @@ -0,0 +1,42 @@ +syntax = "proto3"; + +package flyteidl2.plugins; + +import "flyteidl2/core/tasks.proto"; +import "google/protobuf/struct.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins"; + +message SparkApplication { + enum Type { + PYTHON = 0; + JAVA = 1; + SCALA = 2; + R = 3; + } +} + +// Custom Proto for Spark Plugin. +message SparkJob { + SparkApplication.Type applicationType = 1; + string mainApplicationFile = 2; + string mainClass = 3; + map sparkConf = 4; + map hadoopConf = 5; + string executorPath = 6; // Executor path for Python jobs. + // Databricks job configuration. + // Config structure can be found here. https://docs.databricks.com/dev-tools/api/2.0/jobs.html#request-structure. + google.protobuf.Struct databricksConf = 7; + // Databricks access token. https://docs.databricks.com/dev-tools/api/latest/authentication.html + // This token can be set in either flytepropeller or flytekit. + string databricksToken = 8; + // Domain name of your deployment. Use the form .cloud.databricks.com. + // This instance name can be set in either flytepropeller or flytekit. + string databricksInstance = 9; + + // Pod Spec for the Spark driver pod + core.K8sPod driverPod = 10; + + // Pod Spec for the Spark executor pod + core.K8sPod executorPod = 11; +} diff --git a/flyteidl2/plugins/tensorflow.proto b/flyteidl2/plugins/tensorflow.proto new file mode 100644 index 0000000000..0a8367b9bd --- /dev/null +++ b/flyteidl2/plugins/tensorflow.proto @@ -0,0 +1,18 @@ +syntax = "proto3"; + +package flyteidl2.plugins; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins"; + +// Custom proto for plugin that enables distributed training using https://github.com/kubeflow/tf-operator +message DistributedTensorflowTrainingTask { + // number of worker replicas spawned in the cluster for this job + int32 workers = 1; + // PS -> Parameter server + // number of ps replicas spawned in the cluster for this job + int32 ps_replicas = 2; + // number of chief replicas spawned in the cluster for this job + int32 chief_replicas = 3; + // number of evaluator replicas spawned in the cluster for this job + int32 evaluator_replicas = 4; +} diff --git a/flyteidl2/project/project_service.proto b/flyteidl2/project/project_service.proto new file mode 100644 index 0000000000..01d6a2b481 --- /dev/null +++ b/flyteidl2/project/project_service.proto @@ -0,0 +1,138 @@ +syntax = "proto3"; +package flyteidl2.project; + +import "flyteidl2/common/list.proto"; +import "flyteidl2/task/run.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/project"; + +// Namespace within a project commonly used to differentiate between different service instances. +// e.g. "production", "development", etc. +message Domain { + // Globally unique domain name. + string id = 1; + + // Display name. + string name = 2; +} + +// The state of the project is used to control its visibility in the UI and validity. +enum ProjectState { + // By default, all projects are considered active. + PROJECT_STATE_ACTIVE = 0; + + // Archived projects are no longer visible in the UI and no longer valid. + PROJECT_STATE_ARCHIVED = 1; + + // System generated projects that aren't explicitly created or managed by a user. + PROJECT_STATE_SYSTEM_GENERATED = 2; + + // System archived projects that aren't explicitly archived by a user. + PROJECT_STATE_SYSTEM_ARCHIVED = 3; +} + +message Project { + // Globally unique project name. + string id = 1; + + // Display name. + string name = 2; + + repeated Domain domains = 3; + + string description = 4; + + // Leverage Labels from flyteidl.admin.common.proto to + // tag projects with ownership information. + flyteidl2.task.Labels labels = 5; + + ProjectState state = 6; + + // Optional, org key applied to the resource. + string org = 7; +} + +// Represents a list of projects. +// See :ref:`ref_flyteidl.admin.Project` for more details +message Projects { + repeated Project projects = 1; + + // In the case of multiple pages of results, the server-provided token can be used to fetch the next page + // in a query. If there are no more results, this value will be empty. + string token = 2; +} + +// Adds a new user-project within the Flyte deployment. +// See :ref:`ref_flyteidl.admin.Project` for more details +message CreateProjectRequest { + // +required + Project project = 1; +} + +// Purposefully empty, may be updated in the future. +message CreateProjectResponse {} + +message UpdateProjectRequest { + // +required + Project project = 1; +} + +// Purposefully empty, may be updated in the future. +message UpdateProjectResponse {} + +message GetProjectRequest { + // Indicates a unique project. + // +required + string id = 1; + + // Optional, org key applied to the resource. + string org = 2; +} + +message GetProjectResponse { + // +required + Project project = 1; +} + +// Request to retrieve a list of projects matching specified filters. +// See :ref:`ref_flyteidl.admin.Project` for more details +message ListProjectsRequest { + // Indicates the number of projects to be returned. + // +required + uint32 limit = 1; + + // In the case of multiple pages of results, this server-provided token can be used to fetch the next page + // in a query. + // +optional + string token = 2; + + // Indicates a list of filters passed as string. + // More info on constructing filters : + // +optional + string filters = 3; + + // Sort ordering. + // +optional + flyteidl2.common.Sort sort_by = 4; + + // Optional, org filter applied to list project requests. + string org = 5; +} + +message ListProjectsResponse { + // +required + Projects projects = 1; +} + +service ProjectService { + rpc CreateProject(CreateProjectRequest) returns (CreateProjectResponse) {} + + // it will be ignored in the handler as domains cannot be updated via this API. + rpc UpdateProject(UpdateProjectRequest) returns (UpdateProjectResponse) {} + + rpc GetProject(GetProjectRequest) returns (GetProjectResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + + rpc ListProjects(ListProjectsRequest) returns (ListProjectsResponse) {} +} diff --git a/flyteidl2/secret/definition.proto b/flyteidl2/secret/definition.proto new file mode 100644 index 0000000000..2cda82d703 --- /dev/null +++ b/flyteidl2/secret/definition.proto @@ -0,0 +1,96 @@ +syntax = "proto3"; + +package flyteidl2.secret; + +import "buf/validate/validate.proto"; +import "flyteidl2/common/identifier.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/secret"; + +enum SecretType { + // Default, unspecified secret type. Assumed to be generic and no type specific handling required. + SECRET_TYPE_GENERIC = 0; + // Secret used specifically for pulling images from a container registry. + SECRET_TYPE_IMAGE_PULL_SECRET = 1; +} + +// SecretSpec contains information used for creating/updating the secret. +// Mainly it contains the value of the secret +// In future we could add meta info like tags, rotation config, whether stored secret has any binary format etc for storage/retrieval. +message SecretSpec { + oneof value { + option (buf.validate.oneof).required = true; + + string string_value = 1; + bytes binary_value = 2; + } + + // The secret type + SecretType type = 3; +} + +// SecretIdentifier contains the uniquely identifiable way of storing or retrieving the secret +// Name and scope combination are used for defining the format for storage and retrieval of the secret +// For eg : for org scope secrets +// storage format org::name:secret-name +message SecretIdentifier { + string name = 1 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.pattern = "^[-a-zA-Z0-9_]+$" + ]; + // Only org scoped resources are supported right now + string organization = 2; + // domain scoped secret + string domain = 3; + // Project-domain scoped secret + string project = 4; +} + +enum OverallStatus { + UNSPECIFIED = 0; + PARTIALLY_PRESENT = 1; // Exists in some cluster + FULLY_PRESENT = 2; // Exists in all enabled clusters + UNKNOWN_STATUS = 3; // Status is unknown +} + +enum SecretPresenceStatus { + UNKNOWN = 0; + MISSING = 1; // Secret is missing in the cluster + PRESENT = 2; // Secret is present in the cluster +} + +// SecretMetadata contain meta info about the secret +message SecretMetadata { + // created_time of the secret. + google.protobuf.Timestamp created_time = 1; + // secret_status reports the overall status of the secret across all the clusters. + // This relies on number of clusters queried which relies on there enabled state. + SecretStatus secret_status = 2; + + // The secret type + SecretType type = 3; +} + +// SecretStatus contains the status of the secret across all the clusters +message SecretStatus { + // overall_status reports the overall status of the secret across all the clusters. + OverallStatus overall_status = 1; + // cluster_status reports the status of the secret in each cluster + repeated ClusterSecretStatus cluster_status = 2; +} + +// ClusterSecretStatus contains the status of the secret in a cluster +message ClusterSecretStatus { + common.ClusterIdentifier cluster = 1; + // presence_status reports the status of the secret in the cluster + SecretPresenceStatus presence_status = 2; +} + +// Secret is the returned object for Get and List calls which returns the identifier of the secret along with +// meta information in future about the creation data, update date, tags etc +// This doesn't contain the value of the secret +message Secret { + SecretIdentifier id = 1; + SecretMetadata secret_metadata = 2; +} diff --git a/flyteidl2/secret/payload.proto b/flyteidl2/secret/payload.proto new file mode 100644 index 0000000000..5f074ba07b --- /dev/null +++ b/flyteidl2/secret/payload.proto @@ -0,0 +1,78 @@ +syntax = "proto3"; + +package flyteidl2.secret; + +import "buf/validate/validate.proto"; +import "flyteidl2/secret/definition.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/secret"; + +// CreateSecretProxyRequest contains the spec and identifier used for secret creation +message CreateSecretRequest { + SecretIdentifier id = 1 [(buf.validate.field).required = true]; + SecretSpec secret_spec = 2; +} + +// CreateSecretResponse +message CreateSecretResponse {} + +// UpdateSecretProxyRequest contains the spec and identifier used for secret updation +message UpdateSecretRequest { + SecretIdentifier id = 1 [(buf.validate.field).required = true]; + SecretSpec secret_spec = 2; +} + +// UpdateSecretResponse returns an empty response if the secret is successfully updated +message UpdateSecretResponse {} + +// GetSecretRequest contains the identifier used for looking up the secret +message GetSecretRequest { + SecretIdentifier id = 1 [(buf.validate.field).required = true]; +} + +// GetSecretProxyResponse returns the looked up secret from the secret service +message GetSecretResponse { + Secret secret = 1; +} + +// DeleteSecretRequest contains the identifier used for looking up the secret for deletion +message DeleteSecretRequest { + // name to be used for looking up the secret + SecretIdentifier id = 1 [(buf.validate.field).required = true]; +} + +// DeleteSecretResponse is an empty response right now on successfully deleting the secret. +message DeleteSecretResponse {} + +// ListSecretsRequest is used for listing all the secrets accessible to the user at the passed in scope. +// With org scope, user is given all secrets at org, domain, project-domain level etc +// And returns paginated results +message ListSecretsRequest { + // Only org scoped resources are supported right now + string organization = 1; + // domain scoped secret + string domain = 2; + // Project-domain scoped secret + string project = 3; + // Max page results + int32 limit = 4; + // Leave this empty if you are getting the first set of results. The next_token would be set in the response that can be used to fetch the next set of results. + string token = 5; + // Per cluster token. This allows the service to return paginated results per cluster. + // Service collates the results from all clusters and returns the next token for each cluster. + // The client can use the next token for each cluster to fetch the next page of results. + // In multi cluster, inorder to page through next set of results, client needs to send this token in the next request + map per_cluster_tokens = 6; +} + +// ListSecretsResponse returns paginated results of the accessible secrets at the scope defined in the request. +message ListSecretsResponse { + repeated Secret secrets = 1; + // next token to use for fetching new page results. + string token = 2; + // Per cluster token. This allows the service to return paginated results per cluster. + // Service collates the results from all clusters and returns the next token for each cluster. + // The client can use the next token for each cluster to fetch the next page of results. + // In multi cluster, inorder to page through next set of results, client needs to send this token in the next request + map per_cluster_tokens = 3; +} diff --git a/flyteidl2/secret/secret.proto b/flyteidl2/secret/secret.proto new file mode 100644 index 0000000000..5baec8c51d --- /dev/null +++ b/flyteidl2/secret/secret.proto @@ -0,0 +1,32 @@ +syntax = "proto3"; + +package flyteidl2.secret; + +import "flyteidl2/secret/payload.proto"; +import "google/api/annotations.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/secret"; + +service SecretService { + rpc CreateSecret(CreateSecretRequest) returns (CreateSecretResponse) { + option (google.api.http) = { + post: "/secrets/api/v1" + body: "*" + }; + } + rpc UpdateSecret(UpdateSecretRequest) returns (UpdateSecretResponse) { + option (google.api.http) = { + put: "/secrets/api/v1/name/{id.name}" + body: "*" + }; + } + rpc GetSecret(GetSecretRequest) returns (GetSecretResponse) { + option (google.api.http) = {get: "/secrets/api/v1/name/{id.name}"}; + } + rpc DeleteSecret(DeleteSecretRequest) returns (DeleteSecretResponse) { + option (google.api.http) = {delete: "/secrets/api/v1/name/{id.name}"}; + } + rpc ListSecrets(ListSecretsRequest) returns (ListSecretsResponse) { + option (google.api.http) = {get: "/secrets/api/v1"}; + } +} diff --git a/flyteidl2/task/common.proto b/flyteidl2/task/common.proto new file mode 100644 index 0000000000..beb28f6ac5 --- /dev/null +++ b/flyteidl2/task/common.proto @@ -0,0 +1,117 @@ +syntax = "proto3"; + +package flyteidl2.task; + +import "buf/validate/validate.proto"; +import "flyteidl2/core/interface.proto"; +import "flyteidl2/core/literals.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task"; + +message NamedParameter { + string name = 1; + + flyteidl2.core.Parameter parameter = 2; +} + +// Represents a frequency at which to run a schedule. +enum FixedRateUnit { + FIXED_RATE_UNIT_UNSPECIFIED = 0; + FIXED_RATE_UNIT_MINUTE = 1; + FIXED_RATE_UNIT_HOUR = 2; + FIXED_RATE_UNIT_DAY = 3; +} + +// Option for schedules run at a certain frequency e.g. every 2 minutes. +message FixedRate { + uint32 value = 1 [(buf.validate.field).uint32.gt = 0]; + FixedRateUnit unit = 2 [(buf.validate.field).enum = { + not_in: [0] + }]; + + // Optional, timestamp after which rate should be calculated. Can be only in future. + // E.g. We create a rate schedule "every 5 minutes" with start_time="12:00" inactive. + // Activate it at "12:04". + // Trigger should fire at "12:05" as it adds 5 minutes to start_time="12:00". + google.protobuf.Timestamp start_time = 3; +} + +message Cron { + // Uses AWS syntax: Minutes Hours Day-of-month Month Day-of-week Year + // e.g. for a schedule that runs every 15 minutes: 0/15 * * * ? * + string expression = 1 [(buf.validate.field).string.min_len = 1]; + + string timezone = 2; // default is UTC +} + +// Defines complete set of information required to trigger an execution on a schedule. +message Schedule { + oneof expression { + option (buf.validate.oneof).required = true; + + FixedRate rate = 1; + string cron_expression = 2 [deprecated = true]; + Cron cron = 4; + } + + // Name of the input variable that the kickoff time will be supplied to when the workflow is kicked off. + string kickoff_time_input_arg = 3; +} + +enum TriggerAutomationSpecType { + TYPE_UNSPECIFIED = 0; + TYPE_NONE = 1; + TYPE_SCHEDULE = 2; +} + +message TriggerAutomationSpec { + // Explicitly defines trigger automation type. + TriggerAutomationSpecType type = 1 [(buf.validate.field).enum = { + not_in: [0] + }]; + + oneof automation { + Schedule schedule = 2; + + // In future will be extended with other automation types: webhook, artifacts, etc. + } +} + +// Named literal value. +message NamedLiteral { + // Name of the literal. + string name = 1; + + // Literal value. + flyteidl2.core.Literal value = 2; +} + +// Output references. +message OutputReferences { + // The output uri. + string output_uri = 1; + + // Native URI to HTML report + string report_uri = 2; +} + +// Input payload for an action. +message Inputs { + // Ordered inputs. THIS FIELD MUST REMAIN FIRST as this would break Run service assumptions if it were to move. + repeated NamedLiteral literals = 1; + + // Context for the action. If an action receives context, it'll automatically pass it to any actions it spawns. + // Context will not be used for cache key computation. + // Examples for context include: + // - User-provided metadata that is not part of the action's inputs. + // - Information about the environment the action is running in (e.g. cluster, region, etc.) + // - Tracing information about the action + repeated flyteidl2.core.KeyValuePair context = 2; +} + +// Output payload for an action. +message Outputs { + // Ordered outputs. THIS FIELD MUST REMAIN FIRST as this would break Run service assumptions if it were to move. + repeated NamedLiteral literals = 1; +} diff --git a/flyteidl2/task/environment.proto b/flyteidl2/task/environment.proto new file mode 100644 index 0000000000..a1c65d80f1 --- /dev/null +++ b/flyteidl2/task/environment.proto @@ -0,0 +1,19 @@ +syntax = "proto3"; + +package flyteidl2.task; + +import "buf/validate/validate.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task"; + +// Environment for a task. +message Environment { + // Name of the environment. + string name = 1 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 63 + ]; + + // Description of environment + string description = 2 [(buf.validate.field).string.max_len = 255]; +} diff --git a/flyteidl2/task/run.proto b/flyteidl2/task/run.proto new file mode 100644 index 0000000000..0dfda4bc1b --- /dev/null +++ b/flyteidl2/task/run.proto @@ -0,0 +1,96 @@ +syntax = "proto3"; + +package flyteidl2.task; + +import "flyteidl2/core/literals.proto"; +import "flyteidl2/core/security.proto"; +import "google/protobuf/wrappers.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task"; + +// Label values to be applied to an execution resource. +// In the future a mode (e.g. OVERRIDE, APPEND, etc) can be defined +// to specify how to merge labels defined at registration and execution time. +message Labels { + // Map of custom labels to be applied to the execution resource. + map values = 1; +} + +// Annotation values to be applied to an execution resource. +// In the future a mode (e.g. OVERRIDE, APPEND, etc) can be defined +// to specify how to merge annotations defined at registration and execution time. +message Annotations { + // Map of custom annotations to be applied to the execution resource. + map values = 1; +} + +// Environment variable values to be applied to an execution resource. +// In the future a mode (e.g. OVERRIDE, APPEND, etc) can be defined +// to specify how to merge environment variables defined at registration and execution time. +message Envs { + // Map of custom environment variables to be applied to the execution resource. + repeated flyteidl2.core.KeyValuePair values = 1; +} + +message RawDataStorage { + // Prefix for where offloaded data from user actions will be written + // e.g. s3://bucket/key or s3://bucket/ + string raw_data_prefix = 1; +} + +enum CacheLookupScope { + // CACHE_LOOKUP_SCOPE_UNSPECIFIED instructs cache lookup to follow the default behavior (global unless configured + // otherwise) + CACHE_LOOKUP_SCOPE_UNSPECIFIED = 0; + + // CACHE_LOOKUP_SCOPE_GLOBAL instructs cache lookups to do a global lookup (unless overridden by a system config). + // This has traditionally been the default behavior. It requires all workloads running in all projects/domains + // to have access to the same artifacts/buckets. Otherwise it risks runtime failures. + CACHE_LOOKUP_SCOPE_GLOBAL = 1; + + // CACHE_LOOKUP_SCOPE_PROJECT_DOMAIN instructs cache lookups to do a project-domain scoped lookup. This ensures + // data access success at the expense of potentially more cache misses and recomputation happening. This should not + // be considered a security enforcement (that can happen through the system-wide config). + CACHE_LOOKUP_SCOPE_PROJECT_DOMAIN = 2; +} + +// CacheConfig contains configurations that influence the behavior of cache reads and writes +message CacheConfig { + // If true, recompute outputs for this run and overwrite any existing cache. + bool overwrite_cache = 1; + + // CacheLookupScope defines the cache lookup behavior. If left unspecified, the default value from the system config + // will be used (global unless configured otherwise). + CacheLookupScope cache_lookup_scope = 2; +} + +message RunSpec { + // Labels to apply to the run. + Labels labels = 1; + + // Annotations to apply to the run. + Annotations annotations = 2; + + // Envs to apply to the run. + Envs envs = 3; + + // Explicit override for executing this run as interruptible or not. If not set, use the default. + google.protobuf.BoolValue interruptible = 4; + + // If true, recompute outputs for this run and overwrite any existing cache. + // Deprecated, please use CacheConfig.OverwriteCache instead + bool overwrite_cache = 5 [deprecated = true]; + + // the specific cluster that this action should be executed on. this value will be used as the + // default for all actions in the run unless overridden. + string cluster = 6; + + // Encapsulates user settings pertaining to offloaded data (i.e. Blobs, Schema, query data, etc.). + RawDataStorage raw_data_storage = 7; + + // SecurityContext holds security attributes that apply to tasks. + flyteidl2.core.SecurityContext security_context = 8; + + // CacheConfig contains configurations that influence the behavior of cache reads and writes + CacheConfig cache_config = 9; +} diff --git a/flyteidl2/task/task_definition.proto b/flyteidl2/task/task_definition.proto new file mode 100644 index 0000000000..1a47fd57a6 --- /dev/null +++ b/flyteidl2/task/task_definition.proto @@ -0,0 +1,232 @@ +syntax = "proto3"; + +package flyteidl2.task; + +import "buf/validate/validate.proto"; +import "flyteidl2/common/identifier.proto"; +import "flyteidl2/common/identity.proto"; +import "flyteidl2/common/phase.proto"; +import "flyteidl2/core/interface.proto"; +import "flyteidl2/core/tasks.proto"; +import "flyteidl2/task/common.proto"; +import "flyteidl2/task/environment.proto"; +import "flyteidl2/task/run.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task"; + +// Name of a task. It may have multiple versions deployed. +message TaskName { + // Org this task belongs to. + string org = 1 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 63 + ]; + + // Project this task belongs to. + string project = 2 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 63 + ]; + + // Domain this task belongs to. + string domain = 3 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 63 + ]; + + // Unique name of the task. Should not be interpreted/parsed. Use `short_name` and `environment_name` for user facing names. + string name = 4 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 255 + ]; +} + +// TaskIdentifier is the unique identifier for a task. +message TaskIdentifier { + // Org this task belongs to. + string org = 1 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 63 + ]; + + // Project this task belongs to. + string project = 2 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 63 + ]; + + // Domain this task belongs to. + string domain = 3 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 63 + ]; + + // Unique name of the task. Should not be interpreted/parsed. Use `short_name` and `environment_name` for user facing names. + string name = 4 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 255 + ]; + + // Version of the task. + string version = 5 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 63 + ]; +} + +message TaskTriggersSummary { + reserved 1; + + message TriggerDetails { + string name = 1; + bool active = 2; + TriggerAutomationSpec automation_spec = 3; + } + + message TriggerStats { + uint32 total = 1; + uint32 active = 2; + } + + oneof summary { + TriggerDetails details = 3; + TriggerStats stats = 2; + } +} + +// LatestRunSummary contains minimal information about the most recent run of a task. +// This is a lightweight summary that avoids circular dependencies with workflow package. +message LatestRunSummary { + // Run identifier + common.RunIdentifier run_id = 1; + + // Last run time + google.protobuf.Timestamp run_time = 2; + + // Phase of the last run + common.ActionPhase phase = 3; + + // Name of the root task of the last run (env.task name) + string root_task_name = 4; +} + +// TaskMetadata is static, lightweight metadata about a task. +message TaskMetadata { + // Identity that deployed the task. + common.EnrichedIdentity deployed_by = 1 [(buf.validate.field).required = true]; + + // The short name for this task + string short_name = 2; + + // The time the task was deployed + google.protobuf.Timestamp deployed_at = 3 [(buf.validate.field).required = true]; + + // The environment name for this task, if present. + string environment_name = 4; + + // Brief overview of attached triggers if any. + TaskTriggersSummary triggers_summary = 5; + + // The short description for this task + string short_description = 6; +} + +message TaskSummary { + // Summary of the latest run for this task, if any + optional LatestRunSummary latest_run = 1; +} + +// Lightweight representation of a task. +message Task { + // Id for this task. + TaskIdentifier task_id = 1 [(buf.validate.field).required = true]; + + // Metadata for this task. + TaskMetadata metadata = 2 [(buf.validate.field).required = true]; + + // Summary for this task. + optional TaskSummary task_summary = 3; +} + +// Link to source code used to define this entity +message SourceCode { + string link = 1; +} + +message DocumentationEntity { + // One-liner overview of the entity. + string short_description = 1 [(buf.validate.field).string.max_len = 255]; + // Full user description with formatting preserved. + string long_description = 2 [(buf.validate.field).string.max_len = 2048]; + // Optional link to source code used to define this entity. + SourceCode source_code = 3; +} + +// Specification for a task. +message TaskSpec { + // The template for this task. + flyteidl2.core.TaskTemplate task_template = 1 [(buf.validate.field).required = true]; + + // Ordered default inputs. + // These can be overridden when an run is created. + // Client should not send required=true flag in underlying flyteidl2.core.Parameter. + repeated NamedParameter default_inputs = 2; + + // User facing display name for this task. Not required to be unique. + // This is passed in via the SDK when the task is created and is either a user defined override or the name of the task. + string short_name = 3 [(buf.validate.field).string.max_len = 63]; + + // Optional environment for this task. Note, some tasks may not be run in the context of an environment. + Environment environment = 4; + + // The documentation entity for the task + DocumentationEntity documentation = 5; +} + +// Specification for a trace action. +message TraceSpec { + // A strongly typed interface for the trace. + flyteidl2.core.TypedInterface interface = 1; +} + +// Detailed information about a task. +message TaskDetails { + // Id for this task. + TaskIdentifier task_id = 1 [(buf.validate.field).required = true]; + + // Metadata for this task. + TaskMetadata metadata = 2 [(buf.validate.field).required = true]; + + // Specification for this task. + TaskSpec spec = 3 [(buf.validate.field).required = true]; +} + +// Contains details about a single trigger attached to a task. Should only be used in DeployTask endpoint. +message TaskTrigger { + string name = 1 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 255 + ]; + + TaskTriggerSpec spec = 2 [(buf.validate.field).required = true]; + + // Optional automation spec. + flyteidl2.task.TriggerAutomationSpec automation_spec = 3; +} + +// TaskTriggerSpec this is a copy of TriggerSpec without mandatory 'task_version' field. +// This is supposed to be used only in DeployTask endpoint where 'task_version' is already provided in task_id. +message TaskTriggerSpec { + // Whether trigger is active + bool active = 1; + + // Inputs for triggered task. + Inputs inputs = 2; + + // The run spec for triggered task. + flyteidl2.task.RunSpec run_spec = 3; + + // Optional description + string description = 4; +} diff --git a/flyteidl2/task/task_service.proto b/flyteidl2/task/task_service.proto new file mode 100644 index 0000000000..e57a90abdb --- /dev/null +++ b/flyteidl2/task/task_service.proto @@ -0,0 +1,127 @@ +syntax = "proto3"; + +package flyteidl2.task; + +import "buf/validate/validate.proto"; +import "flyteidl2/common/identifier.proto"; +import "flyteidl2/common/list.proto"; +import "flyteidl2/task/task_definition.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task"; + +// TaskService provides an interface for managing tasks. +service TaskService { + // Deploy a task. + rpc DeployTask(DeployTaskRequest) returns (DeployTaskResponse) {} + + // Get detailed information about a task. + rpc GetTaskDetails(GetTaskDetailsRequest) returns (GetTaskDetailsResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + + // Lists tasks, one per task name, returning the latest version and who it was deployed by. + rpc ListTasks(ListTasksRequest) returns (ListTasksResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + + // Lists all versions for a task. + rpc ListVersions(ListVersionsRequest) returns (ListVersionsResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } +} + +// Request message for deploying a task. +message DeployTaskRequest { + // The user provided task id. + TaskIdentifier task_id = 1 [(buf.validate.field).required = true]; + + // Specification for the task. + TaskSpec spec = 2 [(buf.validate.field).required = true]; + + // Optional, set of triggers for a given task. Replaces previous set of triggers entirely if any. + repeated TaskTrigger triggers = 3; +} + +// Response message for deploying a task. +message DeployTaskResponse {} + +// Request message for getting detailed information about a task. +message GetTaskDetailsRequest { + // Id of the task. + TaskIdentifier task_id = 1 [(buf.validate.field).required = true]; +} + +// Response message for deploying a task. +message GetTaskDetailsResponse { + // Detailed information about the task. + TaskDetails details = 1; +} + +message ListTasksRequest { + // Common list request parameters. + common.ListRequest request = 1; + + oneof scope_by { + option (buf.validate.oneof).required = true; + + // Organization name for filtering. + string org = 2 [(buf.validate.field).string.min_len = 1]; + + // Project identifier for filtering. + common.ProjectIdentifier project_id = 3; + } + + message KnownFilter { + oneof filter_by { + // Filter by user + string deployed_by = 1; + } + } + + // Known filters for listing tasks. + repeated KnownFilter known_filters = 4; +} + +message ListTasksResponse { + repeated Task tasks = 1; + + // Pagination token for the next page of tasks. + string token = 2; + + message ListTasksMetadata { + // Total number of tasks without filters applied + uint32 total = 1; + + // Total number of tasks matching the applied filters. + uint32 filtered_total = 2; + } + + // Metadata for the ListTasksResponse + ListTasksMetadata metadata = 3; +} + +// Request message for listing versions for a task. +message ListVersionsRequest { + // Common list request parameters. + common.ListRequest request = 1; + + // Id of the task. + TaskName task_name = 2 [(buf.validate.field).required = true]; +} + +// Response message for listing versions. +message ListVersionsResponse { + message VersionResponse { + string version = 1; + + // The time the task version was deployed + google.protobuf.Timestamp deployed_at = 2 [(buf.validate.field).required = true]; + } + + // Version with deployed_at + repeated VersionResponse versions = 1; + + // Pagination token for the next page of versions. + string token = 2; +} diff --git a/flyteidl2/trigger/trigger_definition.proto b/flyteidl2/trigger/trigger_definition.proto new file mode 100644 index 0000000000..3e789c52f6 --- /dev/null +++ b/flyteidl2/trigger/trigger_definition.proto @@ -0,0 +1,111 @@ +syntax = "proto3"; + +package flyteidl2.trigger; + +import "buf/validate/validate.proto"; +import "flyteidl2/common/identifier.proto"; +import "flyteidl2/common/identity.proto"; +import "flyteidl2/task/common.proto"; +import "flyteidl2/task/run.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/trigger"; + +message TriggerMetadata { + // Identity that last deployed the trigger + common.EnrichedIdentity deployed_by = 1 [(buf.validate.field).required = true]; + + // Identity that last activated or deactivated the trigger + common.EnrichedIdentity updated_by = 2 [(buf.validate.field).required = true]; +} + +message TriggerSpec { + reserved 1; + + // Inputs for triggered task. + flyteidl2.task.Inputs inputs = 2; + + // The run spec for triggered task. + flyteidl2.task.RunSpec run_spec = 3; + + // Whether trigger is active + bool active = 4; + + // Task version together with trigger name will give us the unique task id + string task_version = 5 [ + (buf.validate.field).string.min_len = 1, + (buf.validate.field).string.max_len = 63 + ]; + + // Optional description + string description = 6; +} + +message TriggerStatus { + // The first time trigger was deployed. + google.protobuf.Timestamp deployed_at = 1 [(buf.validate.field).required = true]; + + // The last time the trigger was updated. + google.protobuf.Timestamp updated_at = 2 [(buf.validate.field).required = true]; + + // The last time the trigger fired. + google.protobuf.Timestamp triggered_at = 3; + + // The time trigger was deleted. + google.protobuf.Timestamp deleted_at = 4; +} + +// Stores human- and machine-friendly explanation of what changed in the revision +enum TriggerRevisionAction { + TRIGGER_REVISION_ACTION_UNSPECIFIED = 0; + TRIGGER_REVISION_ACTION_DEPLOY = 1; + TRIGGER_REVISION_ACTION_ACTIVATE = 2; + TRIGGER_REVISION_ACTION_DEACTIVATE = 3; + TRIGGER_REVISION_ACTION_DELETE = 4; +} + +// Light-weight information about a single trigger revision +message TriggerRevision { + flyteidl2.common.TriggerIdentifier id = 1; + + TriggerMetadata metadata = 2; + + TriggerStatus status = 3; + + TriggerRevisionAction action = 4; + + // Timestamp at which given revision was created. + google.protobuf.Timestamp created_at = 5; +} + +// Full details about a trigger stored in DB +message TriggerDetails { + common.TriggerIdentifier id = 1 [(buf.validate.field).required = true]; + + TriggerMetadata metadata = 2; + + TriggerSpec spec = 3 [(buf.validate.field).required = true]; + + TriggerStatus status = 4; + + // Optional automation spec. + flyteidl2.task.TriggerAutomationSpec automation_spec = 5; + + // Trigger description + optional string description = 6 [(buf.validate.field).string.max_len = 255]; +} + +// Light-weight information about trigger for a list view +message Trigger { + reserved 4; + + flyteidl2.common.TriggerIdentifier id = 1; + + TriggerMetadata metadata = 2; + + TriggerStatus status = 3; + + bool active = 5; + + flyteidl2.task.TriggerAutomationSpec automation_spec = 6; +} diff --git a/flyteidl2/trigger/trigger_service.proto b/flyteidl2/trigger/trigger_service.proto new file mode 100644 index 0000000000..9dde393f6c --- /dev/null +++ b/flyteidl2/trigger/trigger_service.proto @@ -0,0 +1,155 @@ +syntax = "proto3"; + +package flyteidl2.trigger; + +import "buf/validate/validate.proto"; +import "flyteidl2/common/identifier.proto"; +import "flyteidl2/common/list.proto"; +import "flyteidl2/task/common.proto"; +import "flyteidl2/task/task_definition.proto"; +import "flyteidl2/trigger/trigger_definition.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/trigger"; + +// TriggerService provides an interface for managing triggers. +service TriggerService { + // Create if trigger didn't exist previously. + // Update if it already exists. + // Re-create(or undelete) if it was soft-deleted. + // Client must fetch the latest trigger in order to obtain the latest `trigger.id.revision`. + // If trigger is not found, client can set `trigger.id.revision` to 1, it is ignored and set automatically by backend. + // If trigger is found, client should set `trigger.id.revision` to the . + // Backend validates that version is the latest and creates a new revision of the trigger. + // Otherwise, operation is rejected(optimistic locking) and client must re-fetch trigger again. + rpc DeployTrigger(DeployTriggerRequest) returns (DeployTriggerResponse) {} + + // Get detailed info about the latest trigger revision + rpc GetTriggerDetails(GetTriggerDetailsRequest) returns (GetTriggerDetailsResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + + // Get detailed info about a specific trigger revision + rpc GetTriggerRevisionDetails(GetTriggerRevisionDetailsRequest) returns (GetTriggerRevisionDetailsResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + + // List basic info about triggers based on various filtering and sorting rules. + rpc ListTriggers(ListTriggersRequest) returns (ListTriggersResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + + // GetTriggerRevisionHistory returns all revisions for a given trigger + rpc GetTriggerRevisionHistory(GetTriggerRevisionHistoryRequest) returns (GetTriggerRevisionHistoryResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + + // Update some trigger spec fields for multiple triggers at once + rpc UpdateTriggers(UpdateTriggersRequest) returns (UpdateTriggersResponse) {} + + // Soft-delete multiple triggers at once. + rpc DeleteTriggers(DeleteTriggersRequest) returns (DeleteTriggersResponse) {} +} + +// Request message for saving a trigger. +message DeployTriggerRequest { + reserved 1; + + flyteidl2.common.TriggerName name = 4 [(buf.validate.field).required = true]; + + // Revision of the trigger. + // Optional for the initial deploy of the trigger. + // Mandatory for updating existing trigger and should store latest previously deployed revision. + uint64 revision = 5; + + TriggerSpec spec = 2 [(buf.validate.field).required = true]; + + // Optional automation spec. + flyteidl2.task.TriggerAutomationSpec automation_spec = 3; +} + +// Response message for saving a trigger. +message DeployTriggerResponse { + flyteidl2.trigger.TriggerDetails trigger = 1 [(buf.validate.field).required = true]; +} + +// Request message for saving a trigger. +message GetTriggerDetailsRequest { + common.TriggerName name = 1 [(buf.validate.field).required = true]; +} + +// Response message for saving a trigger. +message GetTriggerDetailsResponse { + flyteidl2.trigger.TriggerDetails trigger = 1 [(buf.validate.field).required = true]; +} + +// Request message for saving a trigger. +message GetTriggerRevisionDetailsRequest { + common.TriggerIdentifier id = 1 [(buf.validate.field).required = true]; +} + +// Response message for saving a trigger. +message GetTriggerRevisionDetailsResponse { + flyteidl2.trigger.TriggerDetails trigger = 1 [(buf.validate.field).required = true]; +} + +message ListTriggersRequest { + // Common list request parameters. + flyteidl2.common.ListRequest request = 1; + + oneof scope_by { + option (buf.validate.oneof).required = true; + + // Organization name for filtering. + string org = 2 [(buf.validate.field).string.min_len = 1]; + + // Project identifier for filtering. + flyteidl2.common.ProjectIdentifier project_id = 3; + + // List all triggers attached to a given version of a task . + flyteidl2.task.TaskIdentifier task_id = 4; + + // List all triggers attached to a given task. + flyteidl2.task.TaskName task_name = 5; + } +} + +// Response message for listing triggers. +message ListTriggersResponse { + // List of triggers matching the filter criteria. + repeated flyteidl2.trigger.Trigger triggers = 1; + + // Token for fetching the next page of results, if any. + string token = 2; +} + +message GetTriggerRevisionHistoryRequest { + flyteidl2.common.ListRequest request = 1; + + common.TriggerName name = 2 [(buf.validate.field).required = true]; +} + +message GetTriggerRevisionHistoryResponse { + // List of triggers matching the filter criteria. + repeated flyteidl2.trigger.TriggerRevision triggers = 1; + + // Token for fetching the next page of results, if any. + string token = 2; +} + +// Request message for updating some trigger spec fields for multiple triggers +message UpdateTriggersRequest { + repeated common.TriggerName names = 1 [(buf.validate.field).repeated.min_items = 1]; + + bool active = 2; +} + +// Response message for updating some trigger spec fields for multiple triggers +message UpdateTriggersResponse {} + +// Request message for activating or deactivating multiple triggers +message DeleteTriggersRequest { + repeated common.TriggerName names = 1 [(buf.validate.field).repeated.min_items = 1]; +} + +// Response message for activating or deactivating multiple triggers. +message DeleteTriggersResponse {} diff --git a/flyteidl2/workflow/queue_service.proto b/flyteidl2/workflow/queue_service.proto new file mode 100644 index 0000000000..8bad791558 --- /dev/null +++ b/flyteidl2/workflow/queue_service.proto @@ -0,0 +1,80 @@ +syntax = "proto3"; + +package flyteidl2.workflow; + +import "buf/validate/validate.proto"; +import "flyteidl2/common/identifier.proto"; +import "flyteidl2/task/common.proto"; +import "flyteidl2/task/run.proto"; +import "flyteidl2/workflow/run_definition.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow"; + +// provides an interface for managing execution of runs over a collection of workers. +service QueueService { + // queue a new action for execution. + rpc EnqueueAction(EnqueueActionRequest) returns (EnqueueActionResponse) {} + + // abort a queued run. + rpc AbortQueuedRun(AbortQueuedRunRequest) returns (AbortQueuedRunResponse) {} + + // AbortAction aborts a single action that was previously queued or is currently being processed by a worker. + rpc AbortQueuedAction(AbortQueuedActionRequest) returns (AbortQueuedActionResponse) {} +} + +// request message for queuing an action. +message EnqueueActionRequest { + // the unique identifier for the action. + flyteidl2.common.ActionIdentifier action_id = 1 [(buf.validate.field).required = true]; + + // an optional name for the parent action, if it exists. the remaining run metadata (ex. org, + // project, domain) will be the same as the action_id defined above. + optional string parent_action_name = 2; + + // Optional run spec passed in by the root action to be utilized by all downstream actions in the run. + task.RunSpec run_spec = 3; + + // the path to the input data for this action. + string input_uri = 6 [(buf.validate.field).string.min_len = 1]; + + // the run base path this action should write its output to. + string run_output_base = 7 [(buf.validate.field).string.min_len = 1]; + + // group this action belongs to, if applicable. + string group = 8; + + // subject that created the run, if known. + string subject = 9; + + oneof spec { + option (buf.validate.oneof).required = true; + TaskAction task = 10; + TraceAction trace = 11; + ConditionAction condition = 12; + } +} + +// response message for queuing an action. +message EnqueueActionResponse {} + +// request message for aborting a run. +message AbortQueuedRunRequest { + // the unique identifier for the run to be aborted. + common.RunIdentifier run_id = 1 [(buf.validate.field).required = true]; + + // Reason for aborting the run, if applicable. + optional string reason = 2; +} + +// response message for aborting a run. +message AbortQueuedRunResponse {} + +message AbortQueuedActionRequest { + // ActionId is the unique identifier for the action to be aborted + common.ActionIdentifier action_id = 1 [(buf.validate.field).required = true]; + + // Reason for aborting the action, if applicable. + optional string reason = 2; +} + +message AbortQueuedActionResponse {} diff --git a/flyteidl2/workflow/run_definition.proto b/flyteidl2/workflow/run_definition.proto new file mode 100644 index 0000000000..3165a35869 --- /dev/null +++ b/flyteidl2/workflow/run_definition.proto @@ -0,0 +1,482 @@ +syntax = "proto3"; + +package flyteidl2.workflow; + +import "buf/validate/validate.proto"; +import "flyteidl2/common/identifier.proto"; +import "flyteidl2/common/identity.proto"; +import "flyteidl2/common/phase.proto"; +import "flyteidl2/core/catalog.proto"; +import "flyteidl2/core/execution.proto"; +import "flyteidl2/core/types.proto"; +import "flyteidl2/task/common.proto"; +import "flyteidl2/task/run.proto"; +import "flyteidl2/task/task_definition.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/wrappers.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow"; + +message Run { + // Lightweight information about the root action. + Action action = 1; +} + +message RunDetails { + // Run spec. + task.RunSpec run_spec = 1; + + // Detailed information about the root action. + ActionDetails action = 2; +} + +message TaskAction { + // a unique identifier for the task this action is associated with, if applicable. + task.TaskIdentifier id = 1; + + // the definition of the task to be executed. + task.TaskSpec spec = 2 [(buf.validate.field).required = true]; + + // Enables caching when set and specifies the cache version to use. + google.protobuf.StringValue cache_key = 3; + + // the specific cluster that this action should be executed on. if not set, the cluster from the + // `RunSpec` will be used. + string cluster = 4; +} + +// TraceAction is used to define a trace action that can be used to track the execution of an action that's managed +// by the local worker. This can be used to bring determinism to code that's otherwise not deterministic (e.g. current +// time). +message TraceAction { + string name = 1 [(buf.validate.field).string.min_len = 1]; + + // Last known phase. + common.ActionPhase phase = 2; + + // Time the attempt started. + google.protobuf.Timestamp start_time = 3; + + // Time the attempt ended, if applicable. + optional google.protobuf.Timestamp end_time = 4; + + // Output references. + task.OutputReferences outputs = 5; + + // Task spec for the trace, useful for the typed interface inside. + task.TraceSpec spec = 6 [(buf.validate.field).required = true]; +} + +// ConditionAction is used to define a condition that can be evaluated at runtime. It can be used to +// await a signal from an external system and can carry a value. +message ConditionAction { + // Name is the unique identifier for the action. It must be unique within the defined scope below. + string name = 1 [(buf.validate.field).string.min_len = 1]; + + oneof scope { + option (buf.validate.oneof).required = true; + // RunId is the unique identifier for the run this action is associated with. + string run_id = 2 [(buf.validate.field).string.min_len = 1]; + + // ActionId is the unique identifier for the action this action is associated with. + string action_id = 3 [(buf.validate.field).string.min_len = 1]; + + // Global indicates the condition is global and can be used across all runs and actions. + bool global = 4; + } + + // Type is the type of the value the condition is expected. This can be used to properly render + // a UI element for the condition or validate when a value is received that it is of the expected + // type. + flyteidl2.core.LiteralType type = 6; + + // Prompt is the prompt that will be shown to the user when the condition is awaited. + string prompt = 7; + + // Description is a description of the condition. This can be used to provide additional + // information to the user about the condition. + string description = 8; +} + +message TaskActionMetadata { + // Id of the task this action is associated with. + task.TaskIdentifier id = 1; + + // Extensible task type. + string task_type = 2; + + // The short name for this task. + string short_name = 3; +} + +message TraceActionMetadata { + string name = 1; +} + +message ConditionActionMetadata { + string name = 1; + oneof scope { + option (buf.validate.oneof).required = true; + // RunId is the unique identifier for the run this action is associated with. + string run_id = 2 [(buf.validate.field).string.min_len = 1]; + + // ActionId is the unique identifier for the action this action is associated with. + string action_id = 3 [(buf.validate.field).string.min_len = 1]; + + // Global indicates the condition is global and can be used across all runs and actions. + bool global = 4; + } +} + +// Static, lightweight metadata about an action. +message ActionMetadata { + // Parent action if not the root. + string parent = 3; + + // Group this action belongs to, if applicable. + string group = 5; + + // Identity that executed this run. + common.EnrichedIdentity executed_by = 6; + + oneof spec { + // Task action. + TaskActionMetadata task = 7; + + // Trace action. + TraceActionMetadata trace = 8; + + // Condition action. + ConditionActionMetadata condition = 9; + } + + // Action type. + ActionType action_type = 10; + + // If this run was initiated by a trigger, this will store the trigger identifier. + common.TriggerIdentifier trigger_id = 11; + + // Environment name + string environment_name = 12; + + // Function name + string funtion_name = 13; + + // Trigger name + string trigger_name = 14; + + // Trigger Type + task.TriggerAutomationSpec trigger_type = 15; + + // Who initiated this run + RunSource source = 16; +} + +enum ActionType { + ACTION_TYPE_UNSPECIFIED = 0; + ACTION_TYPE_TASK = 1; + ACTION_TYPE_TRACE = 2; + ACTION_TYPE_CONDITION = 3; +} + +// Lightweight status of an action. For more detailed status see ActionDetails. +message ActionStatus { + // Last known phase. + common.ActionPhase phase = 1; + + // Time the action started. + google.protobuf.Timestamp start_time = 2; + + // Time the action ended, if applicable. + optional google.protobuf.Timestamp end_time = 3; + + // Number of action attempts. + uint32 attempts = 4 [(buf.validate.field).uint32.gt = 0]; + + // cache status of the action's latest attempt + flyteidl2.core.CatalogCacheStatus cache_status = 5; + + // Duration of the action in milliseconds. + optional uint64 duration_ms = 6; +} + +// Lightweight representation of an action. +message Action { + // Id for this action. + common.ActionIdentifier id = 1; + + // Metadata for this action. + ActionMetadata metadata = 2; + + // Last known status. + ActionStatus status = 3; +} + +// EnrichedAction is a wrapper around Action that contains additional information +message EnrichedAction { + // The action itself. + Action action = 1; + + // Whether this action meets specified filters of the request or not. + // If an action that was previously meeting the filter but no longer does, will be sent with this flag set to false + bool meets_filter = 2; + + // Child phase info for this action (Map of phase to counts of children in given phase) + map children_phase_counts = 3; +} + +// ErrorInfo captures details of an error. +message ErrorInfo { + // Error message. + string message = 1; + + enum Kind { + KIND_UNSPECIFIED = 0; + KIND_USER = 1; + KIND_SYSTEM = 2; + } + + // Error kind. + Kind kind = 2; +} + +// AbortInfo captures details of an aborted run. +message AbortInfo { + // Reason provided for the abort. + string reason = 1; + + // Identity that aborted the run. + common.EnrichedIdentity aborted_by = 2; +} + +// ActionDetails is the full details of an action. +message ActionDetails { + // Id for this action. + common.ActionIdentifier id = 1; + + // Metadata for this action. + ActionMetadata metadata = 2; + + // Last known status. + ActionStatus status = 3; + + oneof result { + // Error info for the action, if failed. + ErrorInfo error_info = 4; + // Abort info for the action, if aborted. + AbortInfo abort_info = 5; + } + + // Fully resolved spec of the action. Merges user submitted task spec with platform defaults. + oneof spec { + task.TaskSpec task = 6; + task.TraceSpec trace = 8; + } + + // List of action attempts. + repeated ActionAttempt attempts = 7; +} + +// ActionAttempt is a single attempt of an action. +message ActionAttempt { + // Last known phase. + common.ActionPhase phase = 1; + + // Time the attempt started. + google.protobuf.Timestamp start_time = 2; + + // Time the attempt ended, if applicable. + optional google.protobuf.Timestamp end_time = 3; + + // Error info for the attempt, if failed. + optional ErrorInfo error_info = 4; + + // The attempt number, starting with 1. + uint32 attempt = 5 [(buf.validate.field).uint32.gt = 0]; + + // Log references. + repeated flyteidl2.core.TaskLog log_info = 6; + + // Output references. + flyteidl2.task.OutputReferences outputs = 7; + + // Indicates whether logs are available for tailing. It doesn't necessarily indicate the logs are present, but that + // we have the info we need to look them up. + bool logs_available = 8; + + // cache status of the action attempt + flyteidl2.core.CatalogCacheStatus cache_status = 9; + + // Cluster events like k8s events in a human-readable form. + repeated ClusterEvent cluster_events = 10; + + // History of phase transitions. + repeated PhaseTransition phase_transitions = 11; + + // The cluster this attempt is assigned to. + string cluster = 12; + + // Contains corresponding k8s pods and containers information for this action attempt. + flyteidl2.core.LogContext log_context = 13; +} + +message ClusterEvent { + // occurred_at is the timestamp indicating the instant that this reason happened. + google.protobuf.Timestamp occurred_at = 1; + + // message is the explanation for the most recent phase transition or status update. + string message = 2; + + // TODO add event_kind or event_type with a fixed set of classification values like "ScaleUp, OutOfResources... etc." +} + +message PhaseTransition { + // The phase. + common.ActionPhase phase = 1; + + // Time this phase started. + google.protobuf.Timestamp start_time = 2; + + // Time this phase ended, if applicable. For terminal phases, start time will equal end time. + optional google.protobuf.Timestamp end_time = 3; +} + +// Event payload for an action +message ActionEvent { + // The action id. + common.ActionIdentifier id = 1 [(buf.validate.field).required = true]; + + // The attempt number. + uint32 attempt = 2 [(buf.validate.field).uint32.gt = 0]; + + // The phase for this attempt. + common.ActionPhase phase = 3; + + // The version of this attempt and phase. + uint32 version = 4; + + // Time the attempt started. + google.protobuf.Timestamp start_time = 5 [deprecated = true]; + + // Timestamp when the event occurred, as recorded by the underlying platform (e.g. Kubernetes). + google.protobuf.Timestamp updated_time = 6; + + // Time the attempt ended, if applicable. + optional google.protobuf.Timestamp end_time = 7 [deprecated = true]; + + // Error info for the attempt, if failed. + optional ErrorInfo error_info = 8; + + // Log references. + repeated flyteidl2.core.TaskLog log_info = 9; + + // Metadata to associate containers with logs. + flyteidl2.core.LogContext log_context = 10; + + // The cluster this attempt is running on. + string cluster = 11; + + // Output references. + flyteidl2.task.OutputReferences outputs = 12; + + // cache status of the action attempt + flyteidl2.core.CatalogCacheStatus cache_status = 13; + + // Cluster events like k8s events in a human-readable form. + repeated ClusterEvent cluster_events = 14; + + // Timestamp when the event was observed and reported by the executor + google.protobuf.Timestamp reported_time = 15; +} + +message ActionSpec { + // the unique identifier for the action. + flyteidl2.common.ActionIdentifier action_id = 1 [(buf.validate.field).required = true]; + + // an optional name for the parent action, if it exists. the remaining run metadata (ex. org, + // project, domain) will be the same as the action_id defined above. + optional string parent_action_name = 2; + + // the run spec for this action + flyteidl2.task.RunSpec run_spec = 3; + + // the path to the input data for this action. + string input_uri = 4 [(buf.validate.field).string.min_len = 1]; + + // the run base path this action should write its output to. + string run_output_base = 5 [(buf.validate.field).string.min_len = 1]; + + oneof spec { + option (buf.validate.oneof).required = true; + TaskAction task = 6; + ConditionAction condition = 7; + TraceAction trace = 10; + } + + // group this action belongs to, if applicable. + string group = 8; +} + +enum RunSource { + RUN_SOURCE_UNSPECIFIED = 0; + RUN_SOURCE_WEB = 1; + RUN_SOURCE_CLI = 2; + RUN_SOURCE_SCHEDULE_TRIGGER = 3; +} + +// TaskGroup represents a group of runs for a specific task. +message TaskGroup { + // Task name. + string task_name = 1; + + // Environment name. + string environment_name = 2; + + // Total number of runs for this task. + int64 total_runs = 3; + + // Timestamp of the most recent run. + google.protobuf.Timestamp latest_run_time = 4; + + message RecentStatus { + string run_name = 1; + common.ActionPhase phase = 2; + } + + // Recent run statuses, ordered from newest to oldest. Number of statuses determined by request. + repeated RecentStatus recent_statuses = 5; + + // Average failure rate of runs in this group (0.0 to 1.0). + // Computed as number of root actions with phase FAILED divided by total root actions. + double average_failure_rate = 6; + + // Average duration of runs in this group. + google.protobuf.Duration average_duration = 7; + + // Timestamp of the most recent finished run (terminal phase). + google.protobuf.Timestamp latest_finished_time = 8; + + // List of user/application's enriched identity that created runs in this group. + repeated common.EnrichedIdentity created_by = 9; + + bool should_delete = 10; + + // short name (function name) of the task. + string short_name = 11; + + message ErrorCounts { + int64 user_error = 1; + int64 system_error = 2; + int64 unspecified_error = 3; + } + + ErrorCounts error_counts = 12; + + message PhaseCounts { + common.ActionPhase phase = 1; + int64 count = 2; + } + + repeated PhaseCounts phase_counts = 13; +} diff --git a/flyteidl2/workflow/run_logs_service.proto b/flyteidl2/workflow/run_logs_service.proto new file mode 100644 index 0000000000..3b9438fe33 --- /dev/null +++ b/flyteidl2/workflow/run_logs_service.proto @@ -0,0 +1,37 @@ +syntax = "proto3"; + +package flyteidl2.workflow; + +import "buf/validate/validate.proto"; +import "flyteidl2/common/identifier.proto"; +import "flyteidl2/logs/dataplane/payload.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow"; + +// RunLogsService provides an interface for streaming logs. +service RunLogsService { + rpc TailLogs(TailLogsRequest) returns (stream TailLogsResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } +} + +// Request message for tailing logs. +message TailLogsRequest { + // The action id. + common.ActionIdentifier action_id = 1 [(buf.validate.field).required = true]; + + // The attempt number. + uint32 attempt = 2 [(buf.validate.field).uint32.gt = 0]; +} + +// Reponse message for tailing logs. +message TailLogsResponse { + // A batch of logs. + message Logs { + // Structured log lines. + repeated flyteidl2.logs.dataplane.LogLine lines = 1; + } + + // One or more batches of logs. + repeated Logs logs = 1; +} diff --git a/flyteidl2/workflow/run_service.proto b/flyteidl2/workflow/run_service.proto new file mode 100644 index 0000000000..a5946a5f11 --- /dev/null +++ b/flyteidl2/workflow/run_service.proto @@ -0,0 +1,343 @@ +syntax = "proto3"; + +package flyteidl2.workflow; + +import "buf/validate/validate.proto"; +import "flyteidl2/common/identifier.proto"; +import "flyteidl2/common/list.proto"; +import "flyteidl2/task/common.proto"; +import "flyteidl2/task/run.proto"; +import "flyteidl2/task/task_definition.proto"; +import "flyteidl2/workflow/run_definition.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow"; + +// RunService provides an interface for managing runs. +service RunService { + // Create a new run of the given task. + rpc CreateRun(CreateRunRequest) returns (CreateRunResponse) {} + + // Abort a run. + rpc AbortRun(AbortRunRequest) returns (AbortRunResponse) {} + + // Get detailed information about a run. + rpc GetRunDetails(GetRunDetailsRequest) returns (GetRunDetailsResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + + // Stream detailed information updates about a run. The call will terminate when the run reaches a terminal phase. + rpc WatchRunDetails(WatchRunDetailsRequest) returns (stream WatchRunDetailsResponse) {} + + // Get detailed information about an action. + rpc GetActionDetails(GetActionDetailsRequest) returns (GetActionDetailsResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + + // Stream detailed information updates about an action. The call will terminate when the action reaches a terminal phase. + rpc WatchActionDetails(WatchActionDetailsRequest) returns (stream WatchActionDetailsResponse) {} + + // Get input and output for an action. + rpc GetActionData(GetActionDataRequest) returns (GetActionDataResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + + // List runs based on the provided filter criteria. + rpc ListRuns(ListRunsRequest) returns (ListRunsResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + + // Stream updates for runs based on the provided filter criteria. Responses may include newly discovered + // runs or updates to existing ones from the point of invocation. + rpc WatchRuns(WatchRunsRequest) returns (stream WatchRunsResponse) {} + + // List all actions for a given run. + rpc ListActions(ListActionsRequest) returns (ListActionsResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + + // Stream updates for actions given a run. Responses may include newly discovered nested runs or updates + // to existing ones from the point of invocation. + rpc WatchActions(WatchActionsRequest) returns (stream WatchActionsResponse) {} + + // Stream of k8s cluster events in human readable form + rpc WatchClusterEvents(WatchClusterEventsRequest) returns (stream WatchClusterEventsResponse) {} + + // AbortAction aborts a single action that was previously created or is currently being processed by a worker. + rpc AbortAction(AbortActionRequest) returns (AbortActionResponse) {} + + // Stream updates for task groups based on the provided filter criteria. + rpc WatchGroups(WatchGroupsRequest) returns (stream WatchGroupsResponse) {} +} + +// Request message for creating a run. +message CreateRunRequest { + oneof id { + option (buf.validate.oneof).required = true; + + // The user provided run id. + common.RunIdentifier run_id = 1; + + // The project id for this run. Run name will be generated. + common.ProjectIdentifier project_id = 6; + } + + // The task to run. + oneof task { + option (buf.validate.oneof).required = true; + + // The task id to use. + task.TaskIdentifier task_id = 2; + + // The task spec to use. + task.TaskSpec task_spec = 3; + + // The trigger name to use. + common.TriggerName trigger_name = 7; + } + + // Inputs to use. + task.Inputs inputs = 4; + + // The run spec to use. + task.RunSpec run_spec = 5; + + // Indicates client that created this run. + RunSource source = 8; +} + +// Response message for creating a run. +message CreateRunResponse { + Run run = 1; +} + +// Request message for aborting a run. +message AbortRunRequest { + // Run to abort. + common.RunIdentifier run_id = 1 [(buf.validate.field).required = true]; + + // Reason for aborting the run. if applicable. + optional string reason = 2; +} + +// Response message for aborting a run. +message AbortRunResponse {} + +// Request message for getting detailed information about a run. +message GetRunDetailsRequest { + // Run to query. + common.RunIdentifier run_id = 1 [(buf.validate.field).required = true]; +} + +// Response message for getting detailed information about a run. +message GetRunDetailsResponse { + // Detailed information about the run. + RunDetails details = 1; +} + +// Request message for watching detailed information about a run. +message WatchRunDetailsRequest { + // Run to query. + common.RunIdentifier run_id = 1 [(buf.validate.field).required = true]; +} + +// Response message for watching detailed information about a run. +message WatchRunDetailsResponse { + // Detailed information about the run. + RunDetails details = 1; +} + +// Request message for getting detailed information about an action. +message GetActionDetailsRequest { + // Action to query. + common.ActionIdentifier action_id = 1 [(buf.validate.field).required = true]; +} + +// Response message for getting detailed information about an action. +message GetActionDetailsResponse { + // Detailed information about the action. + ActionDetails details = 1; +} + +// Request message for watching detailed information about an action. +message WatchActionDetailsRequest { + // Action to query. + common.ActionIdentifier action_id = 1 [(buf.validate.field).required = true]; +} + +// Response message for watching detailed information about an action. +message WatchActionDetailsResponse { + // Detailed information about the action. + ActionDetails details = 1; +} + +// Request message for querying action data. +message GetActionDataRequest { + // Action to query. + common.ActionIdentifier action_id = 1 [(buf.validate.field).required = true]; +} + +// Response message for querying action data. +message GetActionDataResponse { + // Inputs for the action. + task.Inputs inputs = 1; + + // Outputs for the action. + task.Outputs outputs = 2; +} + +// Request message for listing runs. +message ListRunsRequest { + reserved 3, 5; // Deprecated + + // Common list request parameters. + common.ListRequest request = 1; + + oneof scope_by { + option (buf.validate.oneof).required = true; + + // Organization name for filtering runs. + string org = 2 [(buf.validate.field).string.min_len = 1]; + + // Project identifier for filtering runs. + common.ProjectIdentifier project_id = 4; + + // List runs created from a trigger. + common.TriggerName trigger_name = 6; + + // Task name for filtering runs + task.TaskName task_name = 7; + + // Task identifier for filtering runs + task.TaskIdentifier task_id = 8; + } +} + +// Response message for listing runs. +message ListRunsResponse { + // List of runs matching the filter criteria. + repeated Run runs = 1; + + // Token for fetching the next page of results, if any. + string token = 2; +} + +// Request message for watching runs. +message WatchRunsRequest { + oneof target { + option (buf.validate.oneof).required = true; + + // Organization name for filtering runs. + string org = 2 [(buf.validate.field).string.min_len = 1]; + // Cluster identifier for filtering runs. + common.ClusterIdentifier cluster_id = 3; + // Project identifier for filtering runs. + common.ProjectIdentifier project_id = 4; + // Task identifier for filtering runs. + task.TaskIdentifier task_id = 5; + } +} + +// Response message for watching runs. +message WatchRunsResponse { + // New or updated runs matching the filter criteria. + repeated Run runs = 1; +} + +// Request message for listing actions. +message ListActionsRequest { + // Common list request parameters. + common.ListRequest request = 1; + + // Run identifier for filtering actions. + common.RunIdentifier run_id = 2 [(buf.validate.field).required = true]; +} + +// Response message for listing actions. +message ListActionsResponse { + // List of actions matching the filter criteria. + repeated Action actions = 1; + + // Token for fetching the next page of results, if any. + string token = 2; + + // Note: This response does not include the enriched actions. + // The enriched actions are only available in the WatchActionsResponse. +} + +// Request message for watching actions. +message WatchActionsRequest { + // Run identifier for filtering actions. + common.RunIdentifier run_id = 1 [(buf.validate.field).required = true]; + + // Optional filter(s) criteria for actions. + // Valid filter fields include: + // - NAME (must use function CONTAINS_CASE_INSENSITIVE): the value is whatever string to match to. This will cast all strings to lowercase and match. + // - PHASE (must use function VALUE_IN): the value is the stringified integer of the enum of the phase and you can pass multiple phases (i.e. ["1", "4"]) + repeated common.Filter filter = 2; +} + +// Response message for watching actions, comes with enriched action metadata. +message WatchActionsResponse { + // New or updated actions matching the filter criteria. Enriched with children status counts + repeated EnrichedAction enriched_actions = 1; +} + +message WatchClusterEventsRequest { + common.ActionIdentifier id = 1 [(buf.validate.field).required = true]; + + uint32 attempt = 2 [(buf.validate.field).uint32.gt = 0]; +} + +message WatchClusterEventsResponse { + repeated ClusterEvent cluster_events = 1; +} + +message AbortActionRequest { + // Action to abort. + common.ActionIdentifier action_id = 1 [(buf.validate.field).required = true]; + + // Optional reason for aborting the action. + string reason = 2; +} + +message AbortActionResponse {} + +message WatchGroupsRequest { + oneof scope_by { + option (buf.validate.oneof).required = true; + // Watch groups within a project. + common.ProjectIdentifier project_id = 1; + } + + // Filter groups after this date (inclusive). Required. + google.protobuf.Timestamp start_date = 2 [(buf.validate.field).required = true]; + + // Filter groups before this date (inclusive). + // If null, will stream updates up to current time. + // If not null, will return groups once and close stream. + google.protobuf.Timestamp end_date = 3; + + // Common list request parameters. + common.ListRequest request = 4; + + message KnownSortField { + oneof sort_by { + common.Sort.Direction created_at = 1; + } + } + + // Known sort fields in watch group + repeated KnownSortField known_sort_fields = 5; +} + +// Response message for watching task groups. +message WatchGroupsResponse { + // List of task groups matching the filter criteria. + // For the initial response, this contains all groups. + // For subsequent updates, this contains only changed groups. + repeated TaskGroup task_groups = 1; + + // Indicates when the initial List call is complete, and subsequent messages are updates. + bool sentinel = 2; +} diff --git a/flyteidl2/workflow/state_service.proto b/flyteidl2/workflow/state_service.proto new file mode 100644 index 0000000000..0462c45858 --- /dev/null +++ b/flyteidl2/workflow/state_service.proto @@ -0,0 +1,107 @@ +syntax = "proto3"; + +package flyteidl2.workflow; + +import "buf/validate/validate.proto"; +import "flyteidl2/common/identifier.proto"; +import "flyteidl2/common/phase.proto"; +import "flyteidl2/core/execution.proto"; +import "google/rpc/status.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow"; + +// provides an interface for managing the state of actions. +service StateService { + // put the state of an action. + rpc Put(PutRequest) returns (PutResponse) {} + + // get the state of an action. + rpc Get(GetRequest) returns (GetResponse) {} + + // watch for updates to the state of actions. this api guarantees at-least-once delivery semantics. + rpc Watch(WatchRequest) returns (stream WatchResponse) {} +} + +// request message to put the state of an action. +message PutRequest { + // a unique identifier for the action. + common.ActionIdentifier action_id = 1 [(buf.validate.field).required = true]; + + // optional name of the parent action if this is a nested action. + optional string parent_action_name = 2; + + // currently we will store state as a json serialized `NodeStatus` object. this will be required + // to seamlessly integrate with existing FlytePropeller node execution logic. we can update this + // to be a subset of fields in the future if there are necessary performance improvements. + string state = 3 [(buf.validate.field).string.min_len = 1]; +} + +// response message for putting the state of an action. +message PutResponse { + // a unique identifier for the action. + common.ActionIdentifier action_id = 1 [(buf.validate.field).required = true]; + + // The result. + google.rpc.Status status = 2 [(buf.validate.field).required = true]; +} + +// request message to get the state of an action. +message GetRequest { + // a unique identifier for the action. + common.ActionIdentifier action_id = 1 [(buf.validate.field).required = true]; +} + +// response message for getting the state of an action. +message GetResponse { + // a unique identifier for the action. + common.ActionIdentifier action_id = 1 [(buf.validate.field).required = true]; + // + // The result. + google.rpc.Status status = 2 [(buf.validate.field).required = true]; + + // a json serialized `NodeStatus` object. + string state = 3 [(buf.validate.field).string.min_len = 1]; +} + +// request message for watching updates to the state of actions. +message WatchRequest { + // criteria for filtering which actions to watch. + oneof filter { + option (buf.validate.oneof).required = true; + + // a unique identifier for the parent action to watch. this will result in updates for all child + // actions. + common.ActionIdentifier parent_action_id = 1; + } +} + +// response message for watching updates to the state of actions. +message WatchResponse { + // an update to the state of a specific action. + oneof message { + ActionUpdate action_update = 1; + ControlMessage control_message = 2; + } +} + +message ControlMessage { + // a sentinel value to indicate the end of a stream. this is used to disambiguate between a control message and a + // regular message. When a watch begins the service will return the existing state of all actions, then a sentinel value, + // before continuing on with ongoing updates. this sequence disambiguates the current state from new updates. + bool sentinel = 1; +} + +// message to represent an update to the state of an action. +message ActionUpdate { + // A unique identifier for the action. `nil` is used as a sentinel value; for example, + common.ActionIdentifier action_id = 1 [(buf.validate.field).required = true]; + + // the current phase of the action. + common.ActionPhase phase = 2; + + // the error associated with the action (if exists). + optional flyteidl2.core.ExecutionError error = 3; + + // the output uri for the action + string output_uri = 4; +} diff --git a/flyteidl2/workflow/translator_service.proto b/flyteidl2/workflow/translator_service.proto new file mode 100644 index 0000000000..138ce45c83 --- /dev/null +++ b/flyteidl2/workflow/translator_service.proto @@ -0,0 +1,70 @@ +syntax = "proto3"; + +package flyteidl2.workflow; + +import "flyteidl2/core/interface.proto"; +import "flyteidl2/task/common.proto"; +import "flyteidl2/task/task_definition.proto"; +import "google/protobuf/struct.proto"; + +option go_package = "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow"; + +// TranslatorService provides an interface for all diferent types of translations for the platform. +service TranslatorService { + rpc LiteralsToLaunchFormJson(LiteralsToLaunchFormJsonRequest) returns (LiteralsToLaunchFormJsonResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + rpc LaunchFormJsonToLiterals(LaunchFormJsonToLiteralsRequest) returns (LaunchFormJsonToLiteralsResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + rpc TaskSpecToLaunchFormJson(TaskSpecToLaunchFormJsonRequest) returns (TaskSpecToLaunchFormJsonResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } + rpc JsonValuesToLiterals(JsonValuesToLiteralsRequest) returns (JsonValuesToLiteralsResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } +} + +message LiteralsToLaunchFormJsonRequest { + // The literals to convert to JSON. + repeated task.NamedLiteral literals = 1; + flyteidl2.core.VariableMap variables = 2; +} + +message LiteralsToLaunchFormJsonResponse { + // The JSON for the literals. + google.protobuf.Struct json = 1; +} + +message LaunchFormJsonToLiteralsRequest { + // The JSON schema to convert to literals. + google.protobuf.Struct json = 1; +} + +message LaunchFormJsonToLiteralsResponse { + // The literals generated from the JSON schema. + repeated task.NamedLiteral literals = 1; +} + +message TaskSpecToLaunchFormJsonRequest { + // The task spec to convert to JSON. + // Merges the VariableMap and the default inputs + flyteidl2.task.TaskSpec task_spec = 1; +} + +message TaskSpecToLaunchFormJsonResponse { + // The JSON for the variables. + google.protobuf.Struct json = 1; +} + +message JsonValuesToLiteralsRequest { + // The type definitions (VariableMap) describing the expected structure. + flyteidl2.core.VariableMap variables = 1; + // The raw JSON values to convert to literals. + google.protobuf.Struct values = 2; +} + +message JsonValuesToLiteralsResponse { + // The literals generated from the JSON values using the type definitions. + repeated task.NamedLiteral literals = 1; +} diff --git a/flyteplugins/.golangci.yml b/flyteplugins/.golangci.yml new file mode 100644 index 0000000000..9767445d04 --- /dev/null +++ b/flyteplugins/.golangci.yml @@ -0,0 +1,38 @@ +# WARNING: THIS FILE IS MANAGED IN THE 'BOILERPLATE' REPO AND COPIED TO OTHER REPOSITORIES. +# ONLY EDIT THIS FILE FROM WITHIN THE 'FLYTEORG/BOILERPLATE' REPOSITORY: +# +# TO OPT OUT OF UPDATES, SEE https://github.com/flyteorg/boilerplate/blob/master/Readme.rst + +issues: + exclude: + - copylocks + exclude-dirs: + - pkg/client + +linters: + disable-all: true + enable: + - errcheck + - gci + - goconst + - goimports + - gosec + - gosimple + - govet + - ineffassign + - misspell + - nakedret + - staticcheck + - typecheck + - unconvert + - unparam + - unused + +linters-settings: + gci: + custom-order: true + sections: + - standard + - default + - prefix(github.com/flyteorg) + skip-generated: true diff --git a/flyteplugins/.goreleaser.yml b/flyteplugins/.goreleaser.yml new file mode 100644 index 0000000000..8bdbc957bf --- /dev/null +++ b/flyteplugins/.goreleaser.yml @@ -0,0 +1,9 @@ +project_name: flyteplugins +builds: + - skip: true +changelog: + sort: asc + filters: + exclude: + - '^docs:' + - '^test:' diff --git a/flyteplugins/CODE_OF_CONDUCT.md b/flyteplugins/CODE_OF_CONDUCT.md new file mode 100755 index 0000000000..e12139d691 --- /dev/null +++ b/flyteplugins/CODE_OF_CONDUCT.md @@ -0,0 +1,2 @@ +This project is governed by LF AI Foundation's [code of conduct](https://lfprojects.org/policies/code-of-conduct/). +All contributors and participants agree to abide by its terms. diff --git a/flyteplugins/LICENSE b/flyteplugins/LICENSE new file mode 100755 index 0000000000..bed437514f --- /dev/null +++ b/flyteplugins/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2019 Lyft, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/flyteplugins/Makefile b/flyteplugins/Makefile new file mode 100755 index 0000000000..9861909e96 --- /dev/null +++ b/flyteplugins/Makefile @@ -0,0 +1,9 @@ +export REPOSITORY=flyteplugins +export REPO_ROOT=.. +include ../boilerplate/flyte/docker_build/Makefile +include ../boilerplate/flyte/golang_test_targets/Makefile + +.PHONY: update_boilerplate +update_boilerplate: + @curl https://raw.githubusercontent.com/flyteorg/boilerplate/master/boilerplate/update.sh -o boilerplate/update.sh + @boilerplate/update.sh diff --git a/flyteplugins/NOTICE b/flyteplugins/NOTICE new file mode 100755 index 0000000000..c3aef1fa32 --- /dev/null +++ b/flyteplugins/NOTICE @@ -0,0 +1,4 @@ +flyteplugins +Copyright 2019 Lyft Inc. + +This product includes software developed at Lyft Inc. diff --git a/flyteplugins/README.md b/flyteplugins/README.md new file mode 100755 index 0000000000..d2002cc54d --- /dev/null +++ b/flyteplugins/README.md @@ -0,0 +1,2 @@ +# flyteplugins +Plugins contributed by flyte community. diff --git a/flyteplugins/go/tasks/aws/client.go b/flyteplugins/go/tasks/aws/client.go new file mode 100644 index 0000000000..4bb781281d --- /dev/null +++ b/flyteplugins/go/tasks/aws/client.go @@ -0,0 +1,137 @@ +/* + * Copyright (c) 2018 Lyft. All rights reserved. + */ + +// Package aws contains AWS-specific logic to handle execution and monitoring of batch jobs. +package aws + +import ( + "context" + "fmt" + "os" + "sync" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/credentials" + "github.com/aws/aws-sdk-go/aws/session" + + "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +const ( + EnvSharedCredFilePath = "AWS_SHARED_CREDENTIALS_FILE" // #nosec + EnvAwsProfile = "AWS_PROFILE" + ErrEmptyCredentials errors.ErrorCode = "EMPTY_CREDS" + ErrUnknownHost errors.ErrorCode = "UNKNOWN_HOST" +) + +type singleton struct { + client Client + lock sync.RWMutex +} + +var single = singleton{ + lock: sync.RWMutex{}, +} + +// Client is a generic AWS Client that can be used for all AWS Client libraries. +type Client interface { + GetSession() *session.Session + GetSdkConfig() *aws.Config + GetConfig() *Config + GetHostName() string +} + +type client struct { + config *Config + Session *session.Session + SdkConfig *aws.Config + HostName string +} + +// Gets the initialized session. +func (c client) GetSession() *session.Session { + return c.Session +} + +// Gets the final config that was used to initialize AWS Session. +func (c client) GetSdkConfig() *aws.Config { + return c.SdkConfig +} + +// Gets client's Hostname +func (c client) GetHostName() string { + return c.HostName +} + +func (c client) GetConfig() *Config { + return c.config +} + +func newClient(ctx context.Context, cfg *Config) (Client, error) { + awsConfig := aws.NewConfig().WithRegion(cfg.Region).WithMaxRetries(cfg.Retries) + if os.Getenv(EnvSharedCredFilePath) != "" { + creds := credentials.NewSharedCredentials(os.Getenv(EnvSharedCredFilePath), os.Getenv(EnvAwsProfile)) + if creds == nil { + return nil, fmt.Errorf("unable to Load AWS credentials") + } + + _, e := creds.Get() + if e != nil { + return nil, errors.Wrapf(ErrEmptyCredentials, e, "Empty credentials") + } + + awsConfig = awsConfig.WithCredentials(creds) + } + + sess, err := session.NewSession(awsConfig) + if err != nil { + logger.Fatalf(ctx, "Error while creating session: %v", err) + } + + hostname, err := os.Hostname() + if err != nil { + return nil, errors.Wrapf(ErrUnknownHost, err, "Unable to discover current hostname") + } + + return &client{ + config: cfg, + SdkConfig: awsConfig, + Session: sess, + HostName: hostname, + }, nil +} + +// Initializes singleton AWS Client if one hasn't been initialized yet. +func Init(ctx context.Context, cfg *Config) (err error) { + if single.client == nil { + single.lock.Lock() + defer single.lock.Unlock() + + if single.client == nil { + single.client, err = newClient(ctx, cfg) + } + } + + return err +} + +// Gets singleton AWS Client. +func GetClient() (c Client, err error) { + single.lock.RLock() + defer single.lock.RUnlock() + if single.client == nil { + single.client, err = newClient(context.TODO(), GetConfig()) + } + + return single.client, err +} + +func SetClient(c Client) { + single.lock.Lock() + defer single.lock.Unlock() + if single.client == nil { + single.client = c + } +} diff --git a/flyteplugins/go/tasks/aws/client_test.go b/flyteplugins/go/tasks/aws/client_test.go new file mode 100644 index 0000000000..3ead66bea1 --- /dev/null +++ b/flyteplugins/go/tasks/aws/client_test.go @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2018 Lyft. All rights reserved. + */ + +package aws + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestClient_GetConfig(t *testing.T) { + assert.NoError(t, Init(context.TODO(), &Config{ + Retries: 2, + Region: "us-east-1", + })) + + c, err := GetClient() + assert.NoError(t, err) + assert.NotNil(t, c) + assert.NotNil(t, GetConfig()) +} diff --git a/flyteplugins/go/tasks/aws/config.go b/flyteplugins/go/tasks/aws/config.go new file mode 100644 index 0000000000..b98d04c70e --- /dev/null +++ b/flyteplugins/go/tasks/aws/config.go @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2018 Lyft. All rights reserved. + */ + +package aws + +import ( + "context" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/retry" + awsConfig "github.com/aws/aws-sdk-go-v2/config" + + pluginsConfig "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/config" + "github.com/flyteorg/flyte/v2/flytestdlib/config" +) + +//go:generate pflags Config --default-var defaultConfig + +const ConfigSectionKey = "aws" + +var ( + defaultConfig = &Config{ + Region: "us-east-2", + Retries: 3, + } + + configSection = pluginsConfig.MustRegisterSubSection(ConfigSectionKey, defaultConfig) +) + +// Config section for AWS Package +type Config struct { + Region string `json:"region" pflag:",AWS Region to connect to."` + AccountID string `json:"accountId" pflag:",AWS Account Identifier."` + Retries int `json:"retries" pflag:",Number of retries."` + LogLevel aws.ClientLogMode `json:"logLevel" pflag:"-,Defines the Sdk Log Level."` +} + +type RateLimiterConfig struct { + Rate int64 `json:"rate" pflag:",Allowed rate of calls per second."` + Burst int `json:"burst" pflag:",Allowed burst rate of calls."` +} + +// Gets loaded config for AWS +func GetConfig() *Config { + return configSection.GetConfig().(*Config) +} + +func (cfg Config) GetSdkConfig() (aws.Config, error) { + sdkConfig, err := awsConfig.LoadDefaultConfig(context.TODO(), + awsConfig.WithRegion(cfg.Region), + awsConfig.WithRetryer(func() aws.Retryer { + return retry.NewStandard(func(options *retry.StandardOptions) { + options.MaxAttempts = cfg.Retries + }) + }), + awsConfig.WithClientLogMode(cfg.LogLevel)) + if err != nil { + return aws.Config{}, err + } + + return sdkConfig, nil +} + +func MustRegisterSubSection(key config.SectionKey, cfg config.Config) config.Section { + return configSection.MustRegisterSection(key, cfg) +} diff --git a/flyteplugins/go/tasks/aws/config_flags.go b/flyteplugins/go/tasks/aws/config_flags.go new file mode 100755 index 0000000000..efe0c05416 --- /dev/null +++ b/flyteplugins/go/tasks/aws/config_flags.go @@ -0,0 +1,57 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package aws + +import ( + "encoding/json" + "reflect" + + "fmt" + + "github.com/spf13/pflag" +) + +// If v is a pointer, it will get its element value or the zero value of the element type. +// If v is not a pointer, it will return it as is. +func (Config) elemValueOrNil(v interface{}) interface{} { + if t := reflect.TypeOf(v); t.Kind() == reflect.Ptr { + if reflect.ValueOf(v).IsNil() { + return reflect.Zero(t.Elem()).Interface() + } else { + return reflect.ValueOf(v).Interface() + } + } else if v == nil { + return reflect.Zero(t).Interface() + } + + return v +} + +func (Config) mustJsonMarshal(v interface{}) string { + raw, err := json.Marshal(v) + if err != nil { + panic(err) + } + + return string(raw) +} + +func (Config) mustMarshalJSON(v json.Marshaler) string { + raw, err := v.MarshalJSON() + if err != nil { + panic(err) + } + + return string(raw) +} + +// GetPFlagSet will return strongly types pflags for all fields in Config and its nested types. The format of the +// flags is json-name.json-sub-name... etc. +func (cfg Config) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("Config", pflag.ExitOnError) + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "region"), defaultConfig.Region, "AWS Region to connect to.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "accountId"), defaultConfig.AccountID, "AWS Account Identifier.") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "retries"), defaultConfig.Retries, "Number of retries.") + return cmdFlags +} diff --git a/flyteplugins/go/tasks/aws/config_flags_test.go b/flyteplugins/go/tasks/aws/config_flags_test.go new file mode 100755 index 0000000000..4a62659b85 --- /dev/null +++ b/flyteplugins/go/tasks/aws/config_flags_test.go @@ -0,0 +1,144 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package aws + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "testing" + + "github.com/mitchellh/mapstructure" + "github.com/stretchr/testify/assert" +) + +var dereferencableKindsConfig = map[reflect.Kind]struct{}{ + reflect.Array: {}, reflect.Chan: {}, reflect.Map: {}, reflect.Ptr: {}, reflect.Slice: {}, +} + +// Checks if t is a kind that can be dereferenced to get its underlying type. +func canGetElementConfig(t reflect.Kind) bool { + _, exists := dereferencableKindsConfig[t] + return exists +} + +// This decoder hook tests types for json unmarshaling capability. If implemented, it uses json unmarshal to build the +// object. Otherwise, it'll just pass on the original data. +func jsonUnmarshalerHookConfig(_, to reflect.Type, data interface{}) (interface{}, error) { + unmarshalerType := reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + if to.Implements(unmarshalerType) || reflect.PtrTo(to).Implements(unmarshalerType) || + (canGetElementConfig(to.Kind()) && to.Elem().Implements(unmarshalerType)) { + + raw, err := json.Marshal(data) + if err != nil { + fmt.Printf("Failed to marshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + res := reflect.New(to).Interface() + err = json.Unmarshal(raw, &res) + if err != nil { + fmt.Printf("Failed to umarshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + return res, nil + } + + return data, nil +} + +func decode_Config(input, result interface{}) error { + config := &mapstructure.DecoderConfig{ + TagName: "json", + WeaklyTypedInput: true, + Result: result, + DecodeHook: mapstructure.ComposeDecodeHookFunc( + mapstructure.StringToTimeDurationHookFunc(), + mapstructure.StringToSliceHookFunc(","), + jsonUnmarshalerHookConfig, + ), + } + + decoder, err := mapstructure.NewDecoder(config) + if err != nil { + return err + } + + return decoder.Decode(input) +} + +func join_Config(arr interface{}, sep string) string { + listValue := reflect.ValueOf(arr) + strs := make([]string, 0, listValue.Len()) + for i := 0; i < listValue.Len(); i++ { + strs = append(strs, fmt.Sprintf("%v", listValue.Index(i))) + } + + return strings.Join(strs, sep) +} + +func testDecodeJson_Config(t *testing.T, val, result interface{}) { + assert.NoError(t, decode_Config(val, result)) +} + +func testDecodeRaw_Config(t *testing.T, vStringSlice, result interface{}) { + assert.NoError(t, decode_Config(vStringSlice, result)) +} + +func TestConfig_GetPFlagSet(t *testing.T) { + val := Config{} + cmdFlags := val.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) +} + +func TestConfig_SetFlags(t *testing.T) { + actual := Config{} + cmdFlags := actual.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) + + t.Run("Test_region", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("region", testValue) + if vString, err := cmdFlags.GetString("region"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.Region) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_accountId", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("accountId", testValue) + if vString, err := cmdFlags.GetString("accountId"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.AccountID) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_retries", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("retries", testValue) + if vInt, err := cmdFlags.GetInt("retries"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vInt), &actual.Retries) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) +} diff --git a/flyteplugins/go/tasks/config/config.go b/flyteplugins/go/tasks/config/config.go new file mode 100644 index 0000000000..5d0c6007b0 --- /dev/null +++ b/flyteplugins/go/tasks/config/config.go @@ -0,0 +1,30 @@ +package config + +import ( + "github.com/flyteorg/flyte/v2/flytestdlib/config" +) + +const configSectionKey = "plugins" + +var ( + // Root config section. If you are a plugin developer and your plugin needs a config, you should register + // your config as a subsection for this root section. + rootSection = config.MustRegisterSection(configSectionKey, &Config{}) +) + +// Config is the top level plugins config. +type Config struct { +} + +// GetConfig retrieves the current config value or default. +func GetConfig() *Config { + return rootSection.GetConfig().(*Config) +} + +func MustRegisterSubSection(subSectionKey string, section config.Config) config.Section { + return rootSection.MustRegisterSection(subSectionKey, section) +} + +func MustRegisterSubSectionWithUpdates(subSectionKey string, section config.Config, sectionUpdatedFn config.SectionUpdated) config.Section { + return rootSection.MustRegisterSectionWithUpdates(subSectionKey, section, sectionUpdatedFn) +} diff --git a/flyteplugins/go/tasks/config_load_test.go b/flyteplugins/go/tasks/config_load_test.go new file mode 100644 index 0000000000..d9c8467794 --- /dev/null +++ b/flyteplugins/go/tasks/config_load_test.go @@ -0,0 +1,141 @@ +package tasks_test + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/logs" + flyteK8sConfig "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/plugins/k8s/spark" + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/config/viper" +) + +func TestLoadConfig(t *testing.T) { + configAccessor := viper.NewAccessor(config.Options{ + StrictMode: true, + SearchPaths: []string{"testdata/config.yaml"}, + }) + + err := configAccessor.UpdateConfig(context.TODO()) + assert.NoError(t, err) + t.Run("k8s-config-test", func(t *testing.T) { + + k8sConfig := flyteK8sConfig.GetK8sPluginConfig() + assert.True(t, k8sConfig.InjectFinalizer) + assert.Equal(t, map[string]string{ + "annotationKey1": "annotationValue1", + "annotationKey2": "annotationValue2", + }, k8sConfig.DefaultAnnotations) + assert.Equal(t, map[string]string{ + "label1": "labelValue1", + "label2": "labelValue2", + }, k8sConfig.DefaultLabels) + assert.Equal(t, map[string]string{ + "AWS_METADATA_SERVICE_NUM_ATTEMPTS": "20", + "AWS_METADATA_SERVICE_TIMEOUT": "5", + "FLYTE_AWS_ACCESS_KEY_ID": "minio", + "FLYTE_AWS_ENDPOINT": "http://minio.flyte:9000", + "FLYTE_AWS_SECRET_ACCESS_KEY": "miniostorage", + }, k8sConfig.DefaultEnvVars) + assert.NotNil(t, k8sConfig.ResourceTolerations) + assert.Contains(t, k8sConfig.ResourceTolerations, v1.ResourceName("nvidia.com/gpu")) + tolGPU := v1.Toleration{ + Key: "flyte/gpu", + Value: "dedicated", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + } + + assert.Equal(t, []v1.Toleration{tolGPU}, k8sConfig.ResourceTolerations[v1.ResourceName("nvidia.com/gpu")]) + expectedCPU := resource.MustParse("1000m") + assert.True(t, expectedCPU.Equal(k8sConfig.DefaultCPURequest)) + expectedMemory := resource.MustParse("1024Mi") + assert.True(t, expectedMemory.Equal(k8sConfig.DefaultMemoryRequest)) + assert.Equal(t, map[string]string{"x/interruptible": "true"}, k8sConfig.InterruptibleNodeSelector) + assert.Equal(t, "x/flyte", k8sConfig.InterruptibleTolerations[0].Key) + assert.Equal(t, "interruptible", k8sConfig.InterruptibleTolerations[0].Value) + assert.NotNil(t, k8sConfig.DefaultPodSecurityContext) + assert.NotNil(t, k8sConfig.DefaultPodSecurityContext.FSGroup) + assert.Equal(t, *k8sConfig.DefaultPodSecurityContext.FSGroup, int64(2000)) + assert.NotNil(t, k8sConfig.DefaultPodSecurityContext.RunAsGroup) + assert.Equal(t, *k8sConfig.DefaultPodSecurityContext.RunAsGroup, int64(3000)) + assert.NotNil(t, k8sConfig.DefaultPodSecurityContext.RunAsUser) + assert.Equal(t, *k8sConfig.DefaultPodSecurityContext.RunAsUser, int64(1000)) + assert.NotNil(t, k8sConfig.DefaultSecurityContext) + assert.NotNil(t, k8sConfig.DefaultSecurityContext.AllowPrivilegeEscalation) + assert.False(t, *k8sConfig.DefaultSecurityContext.AllowPrivilegeEscalation) + assert.NotNil(t, k8sConfig.EnableHostNetworkingPod) + assert.True(t, *k8sConfig.EnableHostNetworkingPod) + assert.NotNil(t, k8sConfig.DefaultPodDNSConfig) + assert.NotNil(t, k8sConfig.DefaultPodDNSConfig.Options) + assert.NotNil(t, k8sConfig.DefaultPodDNSConfig.Options[0].Name) + assert.Equal(t, "ndots", k8sConfig.DefaultPodDNSConfig.Options[0].Name) + assert.NotNil(t, k8sConfig.DefaultPodDNSConfig.Options[0].Value) + assert.Equal(t, "1", *k8sConfig.DefaultPodDNSConfig.Options[0].Value) + assert.NotNil(t, k8sConfig.DefaultPodDNSConfig.Options[1].Name) + assert.Equal(t, "single-request-reopen", k8sConfig.DefaultPodDNSConfig.Options[1].Name) + assert.Nil(t, k8sConfig.DefaultPodDNSConfig.Options[1].Value) + assert.NotNil(t, k8sConfig.DefaultPodDNSConfig.Options[2].Name) + assert.Equal(t, "timeout", k8sConfig.DefaultPodDNSConfig.Options[2].Name) + assert.NotNil(t, k8sConfig.DefaultPodDNSConfig.Options[2].Value) + assert.Equal(t, "1", *k8sConfig.DefaultPodDNSConfig.Options[2].Value) + assert.NotNil(t, k8sConfig.DefaultPodDNSConfig.Options[3].Name) + assert.Equal(t, "attempts", k8sConfig.DefaultPodDNSConfig.Options[3].Name) + assert.NotNil(t, k8sConfig.DefaultPodDNSConfig.Options[3].Value) + assert.Equal(t, "3", *k8sConfig.DefaultPodDNSConfig.Options[3].Value) + assert.NotNil(t, k8sConfig.DefaultPodDNSConfig.Nameservers) + assert.Equal(t, []string{"8.8.8.8", "8.8.4.4"}, k8sConfig.DefaultPodDNSConfig.Nameservers) + assert.NotNil(t, k8sConfig.DefaultPodDNSConfig.Searches) + assert.Equal(t, []string{"ns1.svc.cluster-domain.example", "my.dns.search.suffix"}, k8sConfig.DefaultPodDNSConfig.Searches) + }) + + t.Run("logs-config-test", func(t *testing.T) { + logsConfig := logs.GetLogConfig() + assert.NotNil(t, logsConfig) + assert.True(t, logsConfig.IsKubernetesEnabled) + + assert.Equal(t, 1, len(logsConfig.AzureLogTemplates)) + assert.Equal(t, "Test Azure Logs", logsConfig.AzureLogTemplates[0].DisplayName) + assert.Equal(t, "https://portal.azure.com#@TEST_AZURE_URI/q/", logsConfig.AzureLogTemplates[0].TemplateURIs[0]) + }) + + t.Run("spark-config-test", func(t *testing.T) { + assert.NotNil(t, spark.GetSparkConfig()) + assert.NotNil(t, spark.GetSparkConfig().DefaultSparkConfig) + assert.Equal(t, 2, len(spark.GetSparkConfig().Features)) + assert.Equal(t, "feature1", spark.GetSparkConfig().Features[0].Name) + assert.Equal(t, "feature2", spark.GetSparkConfig().Features[1].Name) + assert.Equal(t, 2, len(spark.GetSparkConfig().Features[0].SparkConfig)) + assert.Equal(t, 2, len(spark.GetSparkConfig().Features[1].SparkConfig)) + + }) +} + +func TestLoadIncorrectConfig(t *testing.T) { + t.Run("logs-config-test-accept-bad-config", func(t *testing.T) { + configAccessor := viper.NewAccessor(config.Options{ + StrictMode: false, + SearchPaths: []string{"testdata/incorrect-config.yaml"}, + }) + + err := configAccessor.UpdateConfig(context.TODO()) + assert.NoError(t, err) + assert.NotNil(t, logs.GetLogConfig()) + assert.True(t, logs.GetLogConfig().IsKubernetesEnabled) + }) + + t.Run("logs-config-test-failfast", func(t *testing.T) { + configAccessor := viper.NewAccessor(config.Options{ + StrictMode: true, + SearchPaths: []string{"testdata/incorrect-config.yaml"}, + }) + + err := configAccessor.UpdateConfig(context.TODO()) + assert.Error(t, err) + }) +} diff --git a/flyteplugins/go/tasks/errors/errors.go b/flyteplugins/go/tasks/errors/errors.go new file mode 100644 index 0000000000..4eccdb9273 --- /dev/null +++ b/flyteplugins/go/tasks/errors/errors.go @@ -0,0 +1,29 @@ +package errors + +import ( + "github.com/flyteorg/flyte/v2/flytestdlib/errors" +) + +const ( + TaskFailedWithError errors.ErrorCode = "TaskFailedWithError" + DownstreamSystemError errors.ErrorCode = "DownstreamSystemError" + TaskFailedUnknownError errors.ErrorCode = "TaskFailedUnknownError" + BadTaskSpecification errors.ErrorCode = "BadTaskSpecification" + TaskEventRecordingFailed errors.ErrorCode = "TaskEventRecordingFailed" + MetadataAccessFailed errors.ErrorCode = "MetadataAccessFailed" + MetadataTooLarge errors.ErrorCode = "MetadataTooLarge" + PluginInitializationFailed errors.ErrorCode = "PluginInitializationFailed" + CacheFailed errors.ErrorCode = "AutoRefreshCacheFailed" + RuntimeFailure errors.ErrorCode = "RuntimeFailure" + CorruptedPluginState errors.ErrorCode = "CorruptedPluginState" + ResourceManagerFailure errors.ErrorCode = "ResourceManagerFailure" + BackOffError errors.ErrorCode = "BackOffError" +) + +func Errorf(errorCode errors.ErrorCode, msgFmt string, args ...interface{}) error { + return errors.Errorf(errorCode, msgFmt, args...) +} + +func Wrapf(errorCode errors.ErrorCode, err error, msgFmt string, args ...interface{}) error { + return errors.Wrapf(errorCode, err, msgFmt, args...) +} diff --git a/flyteplugins/go/tasks/logs/config.go b/flyteplugins/go/tasks/logs/config.go new file mode 100644 index 0000000000..99aff2ece8 --- /dev/null +++ b/flyteplugins/go/tasks/logs/config.go @@ -0,0 +1,54 @@ +package logs + +import ( + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/tasklog" +) + +//go:generate pflags LogConfig --default-var=DefaultConfig + +// LogConfig encapsulates plugins' log configs +type LogConfig struct { + IsCloudwatchEnabled bool `json:"cloudwatch-enabled" pflag:",Enable Cloudwatch Logging"` + // Deprecated: Please use CloudwatchTemplateURI + CloudwatchRegion string `json:"cloudwatch-region" pflag:",AWS region in which Cloudwatch logs are stored."` + // Deprecated: Please use CloudwatchTemplateURI + CloudwatchLogGroup string `json:"cloudwatch-log-group" pflag:",Log group to which streams are associated."` + CloudwatchTemplateURI tasklog.TemplateURI `json:"cloudwatch-template-uri" pflag:",Template Uri to use when building cloudwatch log links"` + + IsKubernetesEnabled bool `json:"kubernetes-enabled" pflag:",Enable Kubernetes Logging"` + // Deprecated: Please use KubernetesTemplateURI + KubernetesURL string `json:"kubernetes-url" pflag:",Console URL for Kubernetes logs"` + KubernetesTemplateURI tasklog.TemplateURI `json:"kubernetes-template-uri" pflag:",Template Uri to use when building kubernetes log links"` + + IsStackDriverEnabled bool `json:"stackdriver-enabled" pflag:",Enable Log-links to stackdriver"` + // Deprecated: Please use StackDriverTemplateURI + GCPProjectName string `json:"gcp-project" pflag:",Name of the project in GCP"` + // Deprecated: Please use StackDriverTemplateURI + StackdriverLogResourceName string `json:"stackdriver-logresourcename" pflag:",Name of the logresource in stackdriver"` + StackDriverTemplateURI tasklog.TemplateURI `json:"stackdriver-template-uri" pflag:",Template Uri to use when building stackdriver log links"` + + DynamicLogLinks map[string]tasklog.TemplateLogPlugin `json:"dynamic-log-links" pflag:"-,Map of dynamic log links"` + + Templates []tasklog.TemplateLogPlugin `json:"templates" pflag:"-,"` + + AzureLogTemplates []tasklog.AzureLogsTemplatePlugin `json:"azure-log-templates" pflag:"-,"` +} + +var ( + DefaultConfig = LogConfig{ + IsKubernetesEnabled: true, + KubernetesTemplateURI: "http://localhost:30082/#!/log/{{ .namespace }}/{{ .podName }}/pod?namespace={{ .namespace }}", + } + + logConfigSection = config.MustRegisterSubSection("logs", &DefaultConfig) +) + +func GetLogConfig() *LogConfig { + return logConfigSection.GetConfig().(*LogConfig) +} + +// SetLogConfig should be used for unit testing only +func SetLogConfig(logConfig *LogConfig) error { + return logConfigSection.SetConfig(logConfig) +} diff --git a/flyteplugins/go/tasks/logs/logconfig_flags.go b/flyteplugins/go/tasks/logs/logconfig_flags.go new file mode 100755 index 0000000000..00c08a8a58 --- /dev/null +++ b/flyteplugins/go/tasks/logs/logconfig_flags.go @@ -0,0 +1,65 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package logs + +import ( + "encoding/json" + "reflect" + + "fmt" + + "github.com/spf13/pflag" +) + +// If v is a pointer, it will get its element value or the zero value of the element type. +// If v is not a pointer, it will return it as is. +func (LogConfig) elemValueOrNil(v interface{}) interface{} { + if t := reflect.TypeOf(v); t.Kind() == reflect.Ptr { + if reflect.ValueOf(v).IsNil() { + return reflect.Zero(t.Elem()).Interface() + } else { + return reflect.ValueOf(v).Interface() + } + } else if v == nil { + return reflect.Zero(t).Interface() + } + + return v +} + +func (LogConfig) mustJsonMarshal(v interface{}) string { + raw, err := json.Marshal(v) + if err != nil { + panic(err) + } + + return string(raw) +} + +func (LogConfig) mustMarshalJSON(v json.Marshaler) string { + raw, err := v.MarshalJSON() + if err != nil { + panic(err) + } + + return string(raw) +} + +// GetPFlagSet will return strongly types pflags for all fields in LogConfig and its nested types. The format of the +// flags is json-name.json-sub-name... etc. +func (cfg LogConfig) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("LogConfig", pflag.ExitOnError) + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "cloudwatch-enabled"), DefaultConfig.IsCloudwatchEnabled, "Enable Cloudwatch Logging") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "cloudwatch-region"), DefaultConfig.CloudwatchRegion, "AWS region in which Cloudwatch logs are stored.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "cloudwatch-log-group"), DefaultConfig.CloudwatchLogGroup, "Log group to which streams are associated.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "cloudwatch-template-uri"), DefaultConfig.CloudwatchTemplateURI, "Template Uri to use when building cloudwatch log links") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "kubernetes-enabled"), DefaultConfig.IsKubernetesEnabled, "Enable Kubernetes Logging") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "kubernetes-url"), DefaultConfig.KubernetesURL, "Console URL for Kubernetes logs") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "kubernetes-template-uri"), DefaultConfig.KubernetesTemplateURI, "Template Uri to use when building kubernetes log links") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "stackdriver-enabled"), DefaultConfig.IsStackDriverEnabled, "Enable Log-links to stackdriver") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "gcp-project"), DefaultConfig.GCPProjectName, "Name of the project in GCP") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "stackdriver-logresourcename"), DefaultConfig.StackdriverLogResourceName, "Name of the logresource in stackdriver") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "stackdriver-template-uri"), DefaultConfig.StackDriverTemplateURI, "Template Uri to use when building stackdriver log links") + return cmdFlags +} diff --git a/flyteplugins/go/tasks/logs/logconfig_flags_test.go b/flyteplugins/go/tasks/logs/logconfig_flags_test.go new file mode 100755 index 0000000000..8bb775df1f --- /dev/null +++ b/flyteplugins/go/tasks/logs/logconfig_flags_test.go @@ -0,0 +1,256 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package logs + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "testing" + + "github.com/mitchellh/mapstructure" + "github.com/stretchr/testify/assert" +) + +var dereferencableKindsLogConfig = map[reflect.Kind]struct{}{ + reflect.Array: {}, reflect.Chan: {}, reflect.Map: {}, reflect.Ptr: {}, reflect.Slice: {}, +} + +// Checks if t is a kind that can be dereferenced to get its underlying type. +func canGetElementLogConfig(t reflect.Kind) bool { + _, exists := dereferencableKindsLogConfig[t] + return exists +} + +// This decoder hook tests types for json unmarshaling capability. If implemented, it uses json unmarshal to build the +// object. Otherwise, it'll just pass on the original data. +func jsonUnmarshalerHookLogConfig(_, to reflect.Type, data interface{}) (interface{}, error) { + unmarshalerType := reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + if to.Implements(unmarshalerType) || reflect.PtrTo(to).Implements(unmarshalerType) || + (canGetElementLogConfig(to.Kind()) && to.Elem().Implements(unmarshalerType)) { + + raw, err := json.Marshal(data) + if err != nil { + fmt.Printf("Failed to marshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + res := reflect.New(to).Interface() + err = json.Unmarshal(raw, &res) + if err != nil { + fmt.Printf("Failed to umarshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + return res, nil + } + + return data, nil +} + +func decode_LogConfig(input, result interface{}) error { + config := &mapstructure.DecoderConfig{ + TagName: "json", + WeaklyTypedInput: true, + Result: result, + DecodeHook: mapstructure.ComposeDecodeHookFunc( + mapstructure.StringToTimeDurationHookFunc(), + mapstructure.StringToSliceHookFunc(","), + jsonUnmarshalerHookLogConfig, + ), + } + + decoder, err := mapstructure.NewDecoder(config) + if err != nil { + return err + } + + return decoder.Decode(input) +} + +func join_LogConfig(arr interface{}, sep string) string { + listValue := reflect.ValueOf(arr) + strs := make([]string, 0, listValue.Len()) + for i := 0; i < listValue.Len(); i++ { + strs = append(strs, fmt.Sprintf("%v", listValue.Index(i))) + } + + return strings.Join(strs, sep) +} + +func testDecodeJson_LogConfig(t *testing.T, val, result interface{}) { + assert.NoError(t, decode_LogConfig(val, result)) +} + +func testDecodeRaw_LogConfig(t *testing.T, vStringSlice, result interface{}) { + assert.NoError(t, decode_LogConfig(vStringSlice, result)) +} + +func TestLogConfig_GetPFlagSet(t *testing.T) { + val := LogConfig{} + cmdFlags := val.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) +} + +func TestLogConfig_SetFlags(t *testing.T) { + actual := LogConfig{} + cmdFlags := actual.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) + + t.Run("Test_cloudwatch-enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("cloudwatch-enabled", testValue) + if vBool, err := cmdFlags.GetBool("cloudwatch-enabled"); err == nil { + testDecodeJson_LogConfig(t, fmt.Sprintf("%v", vBool), &actual.IsCloudwatchEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_cloudwatch-region", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("cloudwatch-region", testValue) + if vString, err := cmdFlags.GetString("cloudwatch-region"); err == nil { + testDecodeJson_LogConfig(t, fmt.Sprintf("%v", vString), &actual.CloudwatchRegion) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_cloudwatch-log-group", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("cloudwatch-log-group", testValue) + if vString, err := cmdFlags.GetString("cloudwatch-log-group"); err == nil { + testDecodeJson_LogConfig(t, fmt.Sprintf("%v", vString), &actual.CloudwatchLogGroup) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_cloudwatch-template-uri", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("cloudwatch-template-uri", testValue) + if vString, err := cmdFlags.GetString("cloudwatch-template-uri"); err == nil { + testDecodeJson_LogConfig(t, fmt.Sprintf("%v", vString), &actual.CloudwatchTemplateURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_kubernetes-enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("kubernetes-enabled", testValue) + if vBool, err := cmdFlags.GetBool("kubernetes-enabled"); err == nil { + testDecodeJson_LogConfig(t, fmt.Sprintf("%v", vBool), &actual.IsKubernetesEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_kubernetes-url", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("kubernetes-url", testValue) + if vString, err := cmdFlags.GetString("kubernetes-url"); err == nil { + testDecodeJson_LogConfig(t, fmt.Sprintf("%v", vString), &actual.KubernetesURL) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_kubernetes-template-uri", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("kubernetes-template-uri", testValue) + if vString, err := cmdFlags.GetString("kubernetes-template-uri"); err == nil { + testDecodeJson_LogConfig(t, fmt.Sprintf("%v", vString), &actual.KubernetesTemplateURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_stackdriver-enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("stackdriver-enabled", testValue) + if vBool, err := cmdFlags.GetBool("stackdriver-enabled"); err == nil { + testDecodeJson_LogConfig(t, fmt.Sprintf("%v", vBool), &actual.IsStackDriverEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_gcp-project", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("gcp-project", testValue) + if vString, err := cmdFlags.GetString("gcp-project"); err == nil { + testDecodeJson_LogConfig(t, fmt.Sprintf("%v", vString), &actual.GCPProjectName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_stackdriver-logresourcename", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("stackdriver-logresourcename", testValue) + if vString, err := cmdFlags.GetString("stackdriver-logresourcename"); err == nil { + testDecodeJson_LogConfig(t, fmt.Sprintf("%v", vString), &actual.StackdriverLogResourceName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_stackdriver-template-uri", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("stackdriver-template-uri", testValue) + if vString, err := cmdFlags.GetString("stackdriver-template-uri"); err == nil { + testDecodeJson_LogConfig(t, fmt.Sprintf("%v", vString), &actual.StackDriverTemplateURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) +} diff --git a/flyteplugins/go/tasks/logs/logging_utils.go b/flyteplugins/go/tasks/logs/logging_utils.go new file mode 100644 index 0000000000..aa003348da --- /dev/null +++ b/flyteplugins/go/tasks/logs/logging_utils.go @@ -0,0 +1,161 @@ +package logs + +import ( + "context" + "fmt" + "time" + + v1 "k8s.io/api/core/v1" + + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/tasklog" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const ( + kubernetesLogsDisplayName = "Kubernetes Logs" + cloudwatchLoggingDisplayName = "Cloudwatch Logs" + googleCloudLoggingDisplayName = "Google Cloud Logs" + FlyteEnableVscode = "_F_E_VS" +) + +// Internal +func GetLogsForContainerInPod(ctx context.Context, logPlugin tasklog.Plugin, taskExecID pluginsCore.TaskExecutionID, pod *v1.Pod, index uint32, nameSuffix string, extraLogTemplateVars []tasklog.TemplateVar, taskTemplate *core.TaskTemplate) ([]*core.TaskLog, error) { + if logPlugin == nil { + return nil, nil + } + + if pod == nil { + logger.Error(ctx, "cannot extract logs for a nil container") + return nil, nil + } + + var containerID string + if uint32(len(pod.Spec.Containers)) <= index { + logger.Errorf(ctx, "container IndexOutOfBound, requested [%d], but total containers [%d] in pod phase [%v]", index, len(pod.Spec.Containers), pod.Status.Phase) + return nil, nil + } + + if uint32(len(pod.Status.ContainerStatuses)) <= index { + logger.Errorf(ctx, "containerStatus IndexOutOfBound, requested [%d], but total containerStatuses [%d] in pod phase [%v]", index, len(pod.Status.ContainerStatuses), pod.Status.Phase) + return nil, nil + } else { + containerID = pod.Status.ContainerStatuses[index].ContainerID + } + + startTime := pod.CreationTimestamp.Unix() + finishTime := time.Now().Unix() + + enableVscode := flytek8s.IsVscodeEnabled(ctx, pod.Spec.Containers[index].Env) + logs, err := logPlugin.GetTaskLogs( + tasklog.Input{ + PodName: pod.Name, + PodUID: string(pod.GetUID()), + Namespace: pod.Namespace, + ContainerName: pod.Spec.Containers[index].Name, + ContainerID: containerID, + LogName: nameSuffix, + PodRFC3339StartTime: time.Unix(startTime, 0).Format(time.RFC3339), + PodRFC3339FinishTime: time.Unix(finishTime, 0).Format(time.RFC3339), + PodUnixStartTime: startTime, + PodUnixFinishTime: finishTime, + TaskExecutionID: taskExecID, + ExtraTemplateVars: extraLogTemplateVars, + TaskTemplate: taskTemplate, + HostName: pod.Spec.Hostname, + EnableVscode: enableVscode, + }, + ) + + if err != nil { + return nil, err + } + + return logs.TaskLogs, nil +} + +type templateLogPluginCollection struct { + plugins []tasklog.Plugin + dynamicPlugins []tasklog.Plugin +} + +func (t templateLogPluginCollection) GetTaskLogs(input tasklog.Input) (tasklog.Output, error) { + var taskLogs []*core.TaskLog + + for _, plugin := range append(t.plugins, t.dynamicPlugins...) { + o, err := plugin.GetTaskLogs(input) + if err != nil { + return tasklog.Output{}, err + } + taskLogs = append(taskLogs, o.TaskLogs...) + } + + return tasklog.Output{TaskLogs: taskLogs}, nil +} + +// InitializeLogPlugins initializes log plugin based on config. +func InitializeLogPlugins(cfg *LogConfig) (tasklog.Plugin, error) { + // Use a list to maintain order. + var plugins []tasklog.Plugin + var dynamicPlugins []tasklog.Plugin + + if cfg.IsKubernetesEnabled { + if len(cfg.KubernetesTemplateURI) > 0 { + plugins = append(plugins, tasklog.TemplateLogPlugin{DisplayName: kubernetesLogsDisplayName, TemplateURIs: []tasklog.TemplateURI{cfg.KubernetesTemplateURI}, MessageFormat: core.TaskLog_JSON}) + } else { + plugins = append(plugins, tasklog.TemplateLogPlugin{DisplayName: kubernetesLogsDisplayName, TemplateURIs: []tasklog.TemplateURI{fmt.Sprintf("%s/#!/log/{{ .namespace }}/{{ .podName }}/pod?namespace={{ .namespace }}", cfg.KubernetesURL)}, MessageFormat: core.TaskLog_JSON}) + } + } + + if cfg.IsCloudwatchEnabled { + if len(cfg.CloudwatchTemplateURI) > 0 { + plugins = append(plugins, tasklog.TemplateLogPlugin{DisplayName: cloudwatchLoggingDisplayName, TemplateURIs: []tasklog.TemplateURI{cfg.CloudwatchTemplateURI}, MessageFormat: core.TaskLog_JSON}) + } else { + plugins = append(plugins, tasklog.TemplateLogPlugin{DisplayName: cloudwatchLoggingDisplayName, TemplateURIs: []tasklog.TemplateURI{fmt.Sprintf("https://console.aws.amazon.com/cloudwatch/home?region=%s#logEventViewer:group=%s;stream=var.log.containers.{{ .podName }}_{{ .namespace }}_{{ .containerName }}-{{ .containerId }}.log", cfg.CloudwatchRegion, cfg.CloudwatchLogGroup)}, MessageFormat: core.TaskLog_JSON}) + } + } + + if cfg.IsStackDriverEnabled { + if len(cfg.StackDriverTemplateURI) > 0 { + plugins = append(plugins, tasklog.TemplateLogPlugin{DisplayName: googleCloudLoggingDisplayName, TemplateURIs: []tasklog.TemplateURI{cfg.StackDriverTemplateURI}, MessageFormat: core.TaskLog_JSON}) + } else { + plugins = append(plugins, tasklog.TemplateLogPlugin{DisplayName: googleCloudLoggingDisplayName, TemplateURIs: []tasklog.TemplateURI{fmt.Sprintf("https://console.cloud.google.com/logs/viewer?project=%s&angularJsUrl=%%2Flogs%%2Fviewer%%3Fproject%%3D%s&resource=%s&advancedFilter=resource.labels.pod_name%%3D{{ .podName }}", cfg.GCPProjectName, cfg.GCPProjectName, cfg.StackdriverLogResourceName)}, MessageFormat: core.TaskLog_JSON}) + } + } + + for logLinkType, dynamicLogLink := range cfg.DynamicLogLinks { + dynamicPlugins = append( + dynamicPlugins, + tasklog.TemplateLogPlugin{ + Name: logLinkType, + DisplayName: dynamicLogLink.DisplayName, + DynamicTemplateURIs: dynamicLogLink.TemplateURIs, + MessageFormat: core.TaskLog_JSON, + ShowWhilePending: dynamicLogLink.ShowWhilePending, + HideOnceFinished: dynamicLogLink.HideOnceFinished, + LinkType: dynamicLogLink.LinkType, + }) + } + + plugins = append(plugins, azureTemplatePluginsToPluginSlice(cfg.AzureLogTemplates)...) + plugins = append(plugins, templatePluginToPluginSlice(cfg.Templates)...) + return templateLogPluginCollection{plugins: plugins, dynamicPlugins: dynamicPlugins}, nil +} + +func templatePluginToPluginSlice(templatePlugins []tasklog.TemplateLogPlugin) []tasklog.Plugin { + plugins := make([]tasklog.Plugin, len(templatePlugins)) + for i := range templatePlugins { + plugins[i] = &templatePlugins[i] + } + return plugins +} + +func azureTemplatePluginsToPluginSlice(templatePlugins []tasklog.AzureLogsTemplatePlugin) []tasklog.Plugin { + plugins := make([]tasklog.Plugin, len(templatePlugins)) + for i := range templatePlugins { + plugins[i] = &templatePlugins[i] + } + return plugins +} diff --git a/flyteplugins/go/tasks/logs/logging_utils_test.go b/flyteplugins/go/tasks/logs/logging_utils_test.go new file mode 100644 index 0000000000..e310ceb8fd --- /dev/null +++ b/flyteplugins/go/tasks/logs/logging_utils_test.go @@ -0,0 +1,625 @@ +package logs + +import ( + "context" + "testing" + + "github.com/go-test/deep" + "github.com/stretchr/testify/assert" + v1 "k8s.io/api/core/v1" + v12 "k8s.io/apimachinery/pkg/apis/meta/v1" + + pluginCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + coreMocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/tasklog" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const podName = "PodName" + +func dummyTaskExecID() pluginCore.TaskExecutionID { + tID := &coreMocks.TaskExecutionID{} + tID.EXPECT().GetGeneratedName().Return("generated-name") + tID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + TaskId: &core.Identifier{ + ResourceType: core.ResourceType_TASK, + Name: "my-task-name", + Project: "my-task-project", + Domain: "my-task-domain", + Version: "1", + }, + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my-execution-name", + Project: "my-execution-project", + Domain: "my-execution-domain", + }, + }, + RetryAttempt: 1, + }) + tID.EXPECT().GetUniqueNodeID().Return("n0-0-n0") + return tID +} + +func TestGetLogsForContainerInPod_NoPlugins(t *testing.T) { + logPlugin, err := InitializeLogPlugins(&LogConfig{}) + assert.NoError(t, err) + l, err := GetLogsForContainerInPod(context.TODO(), logPlugin, dummyTaskExecID(), nil, 0, " Suffix", nil, nil) + assert.NoError(t, err) + assert.Nil(t, l) +} + +func TestGetLogsForContainerInPod_NoLogs(t *testing.T) { + logPlugin, err := InitializeLogPlugins(&LogConfig{ + IsCloudwatchEnabled: true, + CloudwatchRegion: "us-east-1", + CloudwatchLogGroup: "/kubernetes/flyte-production", + }) + assert.NoError(t, err) + p, err := GetLogsForContainerInPod(context.TODO(), logPlugin, dummyTaskExecID(), nil, 0, " Suffix", nil, nil) + assert.NoError(t, err) + assert.Nil(t, p) +} + +func TestGetLogsForContainerInPod_BadIndex(t *testing.T) { + logPlugin, err := InitializeLogPlugins(&LogConfig{ + IsCloudwatchEnabled: true, + CloudwatchRegion: "us-east-1", + CloudwatchLogGroup: "/kubernetes/flyte-production", + }) + assert.NoError(t, err) + + pod := &v1.Pod{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "ContainerName", + }, + }, + }, + Status: v1.PodStatus{ + ContainerStatuses: []v1.ContainerStatus{ + { + ContainerID: "ContainerID", + }, + }, + }, + } + pod.Name = podName + + p, err := GetLogsForContainerInPod(context.TODO(), logPlugin, dummyTaskExecID(), pod, 1, " Suffix", nil, nil) + assert.NoError(t, err) + assert.Nil(t, p) +} + +func TestGetLogsForContainerInPod_BadIndex_WithoutStatus(t *testing.T) { + logPlugin, err := InitializeLogPlugins(&LogConfig{ + IsCloudwatchEnabled: true, + CloudwatchRegion: "us-east-1", + CloudwatchLogGroup: "/kubernetes/flyte-production", + }) + assert.NoError(t, err) + + pod := &v1.Pod{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "ContainerName", + }, + }, + }, + } + pod.Name = podName + + p, err := GetLogsForContainerInPod(context.TODO(), logPlugin, dummyTaskExecID(), pod, 0, " Suffix", nil, nil) + assert.NoError(t, err) + assert.Nil(t, p) +} + +func TestGetLogsForContainerInPod_MissingStatus(t *testing.T) { + logPlugin, err := InitializeLogPlugins(&LogConfig{ + IsCloudwatchEnabled: true, + CloudwatchRegion: "us-east-1", + CloudwatchLogGroup: "/kubernetes/flyte-production", + }) + assert.NoError(t, err) + + pod := &v1.Pod{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "ContainerName", + }, + }, + }, + Status: v1.PodStatus{}, + } + pod.Name = podName + + p, err := GetLogsForContainerInPod(context.TODO(), logPlugin, dummyTaskExecID(), pod, 1, " Suffix", nil, nil) + assert.NoError(t, err) + assert.Nil(t, p) +} + +func TestGetLogsForContainerInPod_Cloudwatch(t *testing.T) { + logPlugin, err := InitializeLogPlugins(&LogConfig{IsCloudwatchEnabled: true, + CloudwatchRegion: "us-east-1", + CloudwatchLogGroup: "/kubernetes/flyte-production", + }) + assert.NoError(t, err) + + pod := &v1.Pod{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "ContainerName", + }, + }, + }, + Status: v1.PodStatus{ + ContainerStatuses: []v1.ContainerStatus{ + { + ContainerID: "ContainerID", + }, + }, + }, + } + pod.Name = podName + + logs, err := GetLogsForContainerInPod(context.TODO(), logPlugin, dummyTaskExecID(), pod, 0, " Suffix", nil, nil) + assert.Nil(t, err) + assert.Len(t, logs, 1) +} + +func TestGetLogsForContainerInPod_K8s(t *testing.T) { + logPlugin, err := InitializeLogPlugins(&LogConfig{ + IsKubernetesEnabled: true, + KubernetesURL: "k8s.com", + DynamicLogLinks: map[string]tasklog.TemplateLogPlugin{ + "vscode": { + TemplateURIs: []tasklog.TemplateURI{"vscode://flyteinteractive:{{ .taskConfig.port }}/{{ .podName }}"}, + MessageFormat: core.TaskLog_JSON, + }, + }, + }) + assert.NoError(t, err) + + pod := &v1.Pod{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "ContainerName", + Env: []v1.EnvVar{ + { + Name: FlyteEnableVscode, + Value: "True", + }, + }, + }, + }, + }, + Status: v1.PodStatus{ + ContainerStatuses: []v1.ContainerStatus{ + { + ContainerID: "ContainerID", + }, + }, + }, + } + pod.Name = podName + + logs, err := GetLogsForContainerInPod(context.TODO(), logPlugin, dummyTaskExecID(), pod, 0, " Suffix", nil, &core.TaskTemplate{}) + assert.Nil(t, err) + assert.Len(t, logs, 2) +} + +func TestGetLogsForContainerInPod_All(t *testing.T) { + logPlugin, err := InitializeLogPlugins(&LogConfig{ + IsKubernetesEnabled: true, + KubernetesURL: "k8s.com", + IsCloudwatchEnabled: true, + CloudwatchRegion: "us-east-1", + CloudwatchLogGroup: "/kubernetes/flyte-production", + }) + assert.NoError(t, err) + + pod := &v1.Pod{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "ContainerName", + }, + }, + }, + Status: v1.PodStatus{ + ContainerStatuses: []v1.ContainerStatus{ + { + ContainerID: "ContainerID", + }, + }, + }, + } + pod.Name = podName + + logs, err := GetLogsForContainerInPod(context.TODO(), logPlugin, dummyTaskExecID(), pod, 0, " Suffix", nil, nil) + assert.Nil(t, err) + assert.Len(t, logs, 2) +} + +func TestGetLogsForContainerInPod_HostName(t *testing.T) { + logPlugin, err := InitializeLogPlugins(&LogConfig{ + IsKubernetesEnabled: true, + KubernetesURL: "k8s.com", + IsCloudwatchEnabled: true, + CloudwatchRegion: "us-east-1", + CloudwatchLogGroup: "/kubernetes/flyte-production", + }) + assert.NoError(t, err) + + pod := &v1.Pod{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "ContainerName", + }, + }, + Hostname: "my-hostname", + }, + Status: v1.PodStatus{ + ContainerStatuses: []v1.ContainerStatus{ + { + ContainerID: "ContainerID", + }, + }, + }, + } + pod.Name = podName + + logs, err := GetLogsForContainerInPod(context.TODO(), logPlugin, dummyTaskExecID(), pod, 0, " Suffix", nil, nil) + assert.Nil(t, err) + assert.Len(t, logs, 2) +} + +func TestGetLogsForContainerInPod_Stackdriver(t *testing.T) { + logPlugin, err := InitializeLogPlugins(&LogConfig{ + IsStackDriverEnabled: true, + GCPProjectName: "myGCPProject", + StackdriverLogResourceName: "aws_ec2_instance", + }) + assert.NoError(t, err) + + pod := &v1.Pod{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "ContainerName", + }, + }, + }, + Status: v1.PodStatus{ + ContainerStatuses: []v1.ContainerStatus{ + { + ContainerID: "ContainerID", + }, + }, + }, + } + pod.Name = podName + + logs, err := GetLogsForContainerInPod(context.TODO(), logPlugin, dummyTaskExecID(), pod, 0, " Suffix", nil, nil) + assert.Nil(t, err) + assert.Len(t, logs, 1) +} + +func TestGetLogsForContainerInPod_LegacyTemplate(t *testing.T) { + t.Run("All Templates available", func(t *testing.T) { + assertTestSucceeded(t, &LogConfig{ + IsKubernetesEnabled: true, + KubernetesTemplateURI: "https://k8s-my-log-server/{{ .namespace }}/{{ .podName }}/{{ .containerName }}/{{ .containerId }}", + + IsCloudwatchEnabled: true, + CloudwatchTemplateURI: "https://cw-my-log-server/{{ .namespace }}/{{ .podName }}/{{ .containerName }}/{{ .containerId }}", + + IsStackDriverEnabled: true, + StackDriverTemplateURI: "https://sd-my-log-server/{{ .namespace }}/{{ .podName }}/{{ .containerName }}/{{ .containerId }}", + }, nil, []*core.TaskLog{ + { + Uri: "https://k8s-my-log-server/my-namespace/my-pod/ContainerName/ContainerID", + MessageFormat: core.TaskLog_JSON, + Name: "Kubernetes Logs my-Suffix", + Ready: true, + }, + { + Uri: "https://cw-my-log-server/my-namespace/my-pod/ContainerName/ContainerID", + MessageFormat: core.TaskLog_JSON, + Name: "Cloudwatch Logs my-Suffix", + Ready: true, + }, + { + Uri: "https://sd-my-log-server/my-namespace/my-pod/ContainerName/ContainerID", + MessageFormat: core.TaskLog_JSON, + Name: "Google Cloud Logs my-Suffix", + Ready: true, + }, + }, "") + }) + + t.Run("StackDriver", func(t *testing.T) { + assertTestSucceeded(t, &LogConfig{ + IsStackDriverEnabled: true, + StackDriverTemplateURI: "https://sd-my-log-server/{{ .namespace }}/{{ .podName }}/{{ .containerName }}/{{ .containerId }}", + }, nil, []*core.TaskLog{ + { + Uri: "https://sd-my-log-server/my-namespace/my-pod/ContainerName/ContainerID", + MessageFormat: core.TaskLog_JSON, + Name: "Google Cloud Logs my-Suffix", + Ready: true, + }, + }, "") + }) +} + +func assertTestSucceeded(tb testing.TB, config *LogConfig, taskTemplate *core.TaskTemplate, expectedTaskLogs []*core.TaskLog, hostname string) { + logPlugin, err := InitializeLogPlugins(config) + assert.NoError(tb, err) + + pod := &v1.Pod{ + ObjectMeta: v12.ObjectMeta{ + Namespace: "my-namespace", + Name: "my-pod", + }, + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "ContainerName", + }, + }, + Hostname: hostname, + }, + Status: v1.PodStatus{ + ContainerStatuses: []v1.ContainerStatus{ + { + ContainerID: "ContainerID", + }, + }, + }, + } + + logs, err := GetLogsForContainerInPod(context.TODO(), logPlugin, dummyTaskExecID(), pod, 0, " my-Suffix", nil, taskTemplate) + assert.Nil(tb, err) + assert.Len(tb, logs, len(expectedTaskLogs)) + if diff := deep.Equal(logs, expectedTaskLogs); len(diff) > 0 { + assert.FailNowf(tb, "Not Equal.", "Diff: %v", diff) + } +} + +func TestGetLogsForContainerInPod_Templates(t *testing.T) { + assertTestSucceeded(t, &LogConfig{ + Templates: []tasklog.TemplateLogPlugin{ + { + DisplayName: "StackDriver", + TemplateURIs: []string{ + "https://my-log-server/{{ .namespace }}/{{ .podName }}/{{ .containerName }}/{{ .containerId }}", + }, + MessageFormat: core.TaskLog_JSON, + LinkType: core.TaskLog_EXTERNAL.String(), + }, + { + DisplayName: "Internal", + TemplateURIs: []string{ + "https://flyte.corp.net/console/projects/{{ .executionProject }}/domains/{{ .executionDomain }}/executions/{{ .executionName }}/nodeId/{{ .nodeID }}/taskId/{{ .taskID }}/attempt/{{ .taskRetryAttempt }}/view/logs", + }, + MessageFormat: core.TaskLog_JSON, + LinkType: core.TaskLog_EXTERNAL.String(), + }, + }, + }, nil, []*core.TaskLog{ + { + Uri: "https://my-log-server/my-namespace/my-pod/ContainerName/ContainerID", + MessageFormat: core.TaskLog_JSON, + Name: "StackDriver my-Suffix", + LinkType: core.TaskLog_EXTERNAL, + Ready: true, + }, + { + Uri: "https://flyte.corp.net/console/projects/my-execution-project/domains/my-execution-domain/executions/my-execution-name/nodeId/n0-0-n0/taskId/my-task-name/attempt/1/view/logs", + MessageFormat: core.TaskLog_JSON, + Name: "Internal my-Suffix", + LinkType: core.TaskLog_EXTERNAL, + Ready: true, + }, + }, "") +} + +func TestGetLogsForContainerInPodTemplates_Hostname(t *testing.T) { + assertTestSucceeded(t, &LogConfig{ + Templates: []tasklog.TemplateLogPlugin{ + { + DisplayName: "StackDriver", + TemplateURIs: []string{ + "{{ .hostname }}/{{ .namespace }}/{{ .podName }}/{{ .containerName }}/{{ .containerId }}", + }, + MessageFormat: core.TaskLog_JSON, + }, + }, + }, nil, []*core.TaskLog{ + { + Uri: "my-hostname/my-namespace/my-pod/ContainerName/ContainerID", + MessageFormat: core.TaskLog_JSON, + Name: "StackDriver my-Suffix", + Ready: true, + }, + }, "my-hostname") +} + +func TestGetLogsForContainerInPod_Flyteinteractive(t *testing.T) { + tests := []struct { + name string + config *LogConfig + template *core.TaskTemplate + expectedTaskLogs []*core.TaskLog + }{ + { + "Flyteinteractive enabled but no task template", + &LogConfig{ + DynamicLogLinks: map[string]tasklog.TemplateLogPlugin{ + "vscode": tasklog.TemplateLogPlugin{ + DisplayName: "vscode link", + TemplateURIs: []tasklog.TemplateURI{ + "https://flyteinteractive.mydomain.com:{{ .taskConfig.port }}/{{ .namespace }}/{{ .podName }}/{{ .containerName }}/{{ .containerId }}", + }, + }, + }, + }, + nil, + nil, + }, + { + "Flyteinteractive enabled but config not found in task template", + &LogConfig{ + DynamicLogLinks: map[string]tasklog.TemplateLogPlugin{ + "vscode": tasklog.TemplateLogPlugin{ + DisplayName: "vscode link", + TemplateURIs: []tasklog.TemplateURI{ + "https://flyteinteractive.mydomain.com:{{ .taskConfig.port }}/{{ .namespace }}/{{ .podName }}/{{ .containerName }}/{{ .containerId }}", + }, + }, + }, + }, + &core.TaskTemplate{}, + nil, + }, + { + "Flyteinteractive disabled but config present in TaskTemplate", + &LogConfig{}, + &core.TaskTemplate{ + Config: map[string]string{ + "link_type": "vscode", + "port": "65535", + }, + }, + nil, + }, + { + "Flyteinteractive - multiple dynamic options", + &LogConfig{ + DynamicLogLinks: map[string]tasklog.TemplateLogPlugin{ + "vscode": tasklog.TemplateLogPlugin{ + DisplayName: "vscode link", + TemplateURIs: []tasklog.TemplateURI{ + "https://abc.com:{{ .taskConfig.port }}/{{ .taskConfig.route }}", + }, + LinkType: core.TaskLog_IDE.String(), + }, + }, + }, + &core.TaskTemplate{ + Config: map[string]string{ + "link_type": "vscode", + "port": "65535", + "route": "a-route", + }, + }, + []*core.TaskLog{ + { + Uri: "https://abc.com:65535/a-route", + MessageFormat: core.TaskLog_JSON, + Name: "vscode link my-Suffix", + LinkType: core.TaskLog_IDE, + Ready: true, + }, + }, + }, + { + "Flyteinteractive - multiple uses of the template (invalid use of ports in a URI)", + &LogConfig{ + DynamicLogLinks: map[string]tasklog.TemplateLogPlugin{ + "vscode": tasklog.TemplateLogPlugin{ + DisplayName: "vscode link", + TemplateURIs: []tasklog.TemplateURI{ + "https://abc.com:{{ .taskConfig.port }}:{{ .taskConfig.port}}", + }, + }, + }, + }, + &core.TaskTemplate{ + Config: map[string]string{ + "link_type": "vscode", + "port": "65535", + }, + }, + []*core.TaskLog{ + { + Uri: "https://abc.com:65535:65535", + MessageFormat: core.TaskLog_JSON, + Name: "vscode link my-Suffix", + LinkType: core.TaskLog_IDE, + Ready: true, + }, + }, + }, + { + "Flyteinteractive disabled and K8s enabled and flyteinteractive config present in TaskTemplate", + &LogConfig{ + IsKubernetesEnabled: true, + KubernetesTemplateURI: "https://k8s.com/{{ .namespace }}/{{ .podName }}/{{ .containerName }}/{{ .containerId }}", + }, + &core.TaskTemplate{ + Config: map[string]string{ + "link_type": "vscode", + "port": "65535", + }, + }, + []*core.TaskLog{ + { + Uri: "https://k8s.com/my-namespace/my-pod/ContainerName/ContainerID", + MessageFormat: core.TaskLog_JSON, + Name: "Kubernetes Logs my-Suffix", + Ready: true, + }, + }, + }, + { + "Flyteinteractive and K8s enabled", + &LogConfig{ + IsKubernetesEnabled: true, + KubernetesTemplateURI: "https://k8s.com/{{ .namespace }}/{{ .podName }}/{{ .containerName }}/{{ .containerId }}", + DynamicLogLinks: map[string]tasklog.TemplateLogPlugin{ + "vscode": tasklog.TemplateLogPlugin{ + DisplayName: "vscode link", + TemplateURIs: []tasklog.TemplateURI{ + "https://flyteinteractive.mydomain.com:{{ .taskConfig.port }}/{{ .namespace }}/{{ .podName }}/{{ .containerName }}/{{ .containerId }}", + }, + }, + }, + }, + &core.TaskTemplate{ + Config: map[string]string{ + "link_type": "vscode", + "port": "65535", + }, + }, + []*core.TaskLog{ + { + Uri: "https://k8s.com/my-namespace/my-pod/ContainerName/ContainerID", + MessageFormat: core.TaskLog_JSON, + Name: "Kubernetes Logs my-Suffix", + LinkType: core.TaskLog_EXTERNAL, + Ready: true, + }, + { + Uri: "https://flyteinteractive.mydomain.com:65535/my-namespace/my-pod/ContainerName/ContainerID", + MessageFormat: core.TaskLog_JSON, + Name: "vscode link my-Suffix", + LinkType: core.TaskLog_IDE, + Ready: true, + }, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assertTestSucceeded(t, tt.config, tt.template, tt.expectedTaskLogs, "") + }) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/bundle/fail_fast.go b/flyteplugins/go/tasks/pluginmachinery/bundle/fail_fast.go new file mode 100644 index 0000000000..2d1bb85b74 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/bundle/fail_fast.go @@ -0,0 +1,66 @@ +package bundle + +import ( + "context" + "fmt" + "time" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + pluginMachinery "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" +) + +const failFastExecutorName = "fail-fast" + +type failFastHandler struct{} + +func (h failFastHandler) GetID() string { + return failFastExecutorName +} + +func (h failFastHandler) GetProperties() core.PluginProperties { + return core.PluginProperties{} +} + +func (h failFastHandler) Handle(ctx context.Context, tCtx core.TaskExecutionContext) (core.Transition, error) { + occuredAt := time.Now() + taskTemplate, err := tCtx.TaskReader().Read(ctx) + if err != nil { + return core.UnknownTransition, + errors.Errorf(errors.BadTaskSpecification, "unable to fetch task specification [%v]", err.Error()) + } + return core.DoTransition(core.PhaseInfoFailure("AlwaysFail", + fmt.Sprintf("Task [%s] type [%+v] not supported by platform for this project/domain/workflow", + taskTemplate.Type, tCtx.TaskExecutionMetadata().GetTaskExecutionID()), &core.TaskInfo{ + OccurredAt: &occuredAt, + })), nil +} + +func (h failFastHandler) Abort(_ context.Context, _ core.TaskExecutionContext) error { + return nil +} + +func (h failFastHandler) Finalize(_ context.Context, _ core.TaskExecutionContext) error { + return nil +} + +func failFastPluginLoader(_ context.Context, _ core.SetupContext) (core.Plugin, error) { + return &failFastHandler{}, nil +} + +func init() { + // TODO(katrogan): Once we move pluginmachinery to flyteidl make these task types named constants that flyteplugins + // can reference in other handler definitions. + // NOTE: these should match the constants defined flytekit + taskTypes := []core.TaskType{ + "container", "sidecar", "container_array", "hive", "presto", "spark", "pytorch", + "sagemaker_custom_training_job_task", "sagemaker_training_job_task", "sagemaker_hyperparameter_tuning_job_task", + } + pluginMachinery.PluginRegistry().RegisterCorePlugin( + core.PluginEntry{ + ID: failFastExecutorName, + RegisteredTaskTypes: taskTypes, + LoadPlugin: failFastPluginLoader, + IsDefault: false, + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/bundle/fail_fast_test.go b/flyteplugins/go/tasks/pluginmachinery/bundle/fail_fast_test.go new file mode 100644 index 0000000000..b5691c58e6 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/bundle/fail_fast_test.go @@ -0,0 +1,63 @@ +package bundle + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + idlCore "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +var testHandler = failFastHandler{} + +func TestFailFastGetID(t *testing.T) { + assert.Equal(t, "fail-fast", testHandler.GetID()) +} + +func TestGetProperties(t *testing.T) { + assert.Empty(t, testHandler.GetProperties()) +} + +func TestHandleAlwaysFails(t *testing.T) { + tID := &mocks.TaskExecutionID{} + tID.EXPECT().GetID().Return(idlCore.TaskExecutionIdentifier{ + NodeExecutionId: &idlCore.NodeExecutionIdentifier{ + ExecutionId: &idlCore.WorkflowExecutionIdentifier{ + Name: "my_name", + Project: "my_project", + Domain: "my_domain", + }, + }, + }) + + taskExecutionMetadata := &mocks.TaskExecutionMetadata{} + taskExecutionMetadata.EXPECT().GetTaskExecutionID().Return(tID) + + taskCtx := &mocks.TaskExecutionContext{} + taskCtx.EXPECT().TaskExecutionMetadata().Return(taskExecutionMetadata) + taskReader := &mocks.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(&idlCore.TaskTemplate{ + Type: "unsupportedtype", + }, nil) + taskCtx.EXPECT().TaskReader().Return(taskReader) + + transition, err := testHandler.Handle(context.TODO(), taskCtx) + assert.NoError(t, err) + assert.Equal(t, core.PhasePermanentFailure, transition.Info().Phase()) + assert.Equal(t, "AlwaysFail", transition.Info().Err().Code) + assert.Contains(t, transition.Info().Err().Message, "Task [unsupportedtype]") +} + +func TestAbort(t *testing.T) { + err := testHandler.Abort(context.TODO(), nil) + assert.NoError(t, err) +} + +func TestFinalize(t *testing.T) { + err := testHandler.Finalize(context.TODO(), nil) + assert.NoError(t, err) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/async_client.go b/flyteplugins/go/tasks/pluginmachinery/catalog/async_client.go new file mode 100644 index 0000000000..bf973e7aae --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/async_client.go @@ -0,0 +1,83 @@ +package catalog + +import ( + "context" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + "github.com/flyteorg/flyte/v2/flytestdlib/bitarray" + "github.com/flyteorg/flyte/v2/flytestdlib/errors" +) + +type ResponseStatus uint8 + +const ( + ResponseStatusNotReady ResponseStatus = iota + ResponseStatusReady +) + +const ( + ErrResponseNotReady errors.ErrorCode = "RESPONSE_NOT_READY" + ErrSystemError errors.ErrorCode = "SYSTEM_ERROR" +) + +type UploadRequest struct { + Key Key + ArtifactData io.OutputReader + ArtifactMetadata Metadata +} + +type ReadyHandler func(ctx context.Context, future Future) + +// A generic Future interface to represent async operations results +type Future interface { + // Gets the response status for the future. If the future represents multiple operations, the status will only be + // ready if all of them are. + GetResponseStatus() ResponseStatus + + // Sets a callback handler to be called when the future status changes to ready. + OnReady(handler ReadyHandler) + + GetResponseError() error +} + +// Catalog Sidecar future to represent async process of uploading catalog artifacts. +type UploadFuture interface { + Future +} + +// Catalog Download Request to represent async operation download request. +type DownloadRequest struct { + Key Key + Target io.OutputWriter +} + +// Catalog download future to represent async process of downloading catalog artifacts. +type DownloadFuture interface { + Future + + // Gets the actual response from the future. This will return an error if the future isn't ready yet. + GetResponse() (DownloadResponse, error) +} + +// Catalog download response. +type DownloadResponse interface { + // Gets a bit set representing which items from the request were cached. + GetCachedResults() *bitarray.BitSet + + // Gets the total size of the cached result. + GetResultsSize() int + + // A convenience method to retrieve the number of cached items. + GetCachedCount() int +} + +// An interface that helps async interaction with catalog service +type AsyncClient interface { + // Returns if an entry exists for the given task and input. It returns the data as a LiteralMap + Download(ctx context.Context, requests ...DownloadRequest) (outputFuture DownloadFuture, err error) + + // Adds a new entry to catalog for the given task execution context and the generated output + Upload(ctx context.Context, requests ...UploadRequest) (putFuture UploadFuture, err error) +} + +var _ AsyncClient = AsyncClientImpl{} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/async_client_impl.go b/flyteplugins/go/tasks/pluginmachinery/catalog/async_client_impl.go new file mode 100644 index 0000000000..0561acd9ea --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/async_client_impl.go @@ -0,0 +1,171 @@ +package catalog + +import ( + "context" + "encoding/base32" + "fmt" + "hash/fnv" + "reflect" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/workqueue" + "github.com/flyteorg/flyte/v2/flytestdlib/bitarray" + "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const specialEncoderKey = "abcdefghijklmnopqrstuvwxyz123456" + +var base32Encoder = base32.NewEncoding(specialEncoderKey).WithPadding(base32.NoPadding) + +// An async-client for catalog that can queue download and upload requests on workqueues. +type AsyncClientImpl struct { + Reader workqueue.IndexedWorkQueue + Writer workqueue.IndexedWorkQueue +} + +func formatWorkItemID(key Key, idx int, suffix string) string { + return fmt.Sprintf("%v-%v-%v", key, idx, suffix) +} + +func consistentHash(str string) (string, error) { + hasher := fnv.New32a() + _, err := hasher.Write([]byte(str)) + if err != nil { + return "", err + } + + b := hasher.Sum(nil) + return base32Encoder.EncodeToString(b), nil +} + +func hashInputs(ctx context.Context, key Key) (string, error) { + inputs := &core.LiteralMap{} + if key.TypedInterface.Inputs != nil { + retInputs, err := key.InputReader.Get(ctx) + if err != nil { + return "", err + } + inputs = retInputs + } + return HashLiteralMap(ctx, inputs, key.CacheIgnoreInputVars) +} + +func (c AsyncClientImpl) Download(ctx context.Context, requests ...DownloadRequest) (outputFuture DownloadFuture, err error) { + status := ResponseStatusReady + cachedResults := bitarray.NewBitSet(uint(len(requests))) + cachedCount := 0 + var respErr error + for idx, request := range requests { + uniqueOutputLoc, err := consistentHash(request.Target.GetOutputPrefixPath().String()) + if err != nil { + return nil, err + } + + workItemID := formatWorkItemID(request.Key, idx, uniqueOutputLoc) + err = c.Reader.Queue(ctx, workItemID, NewReaderWorkItem( + request.Key, + request.Target)) + + if err != nil { + return nil, err + } + + info, found, err := c.Reader.Get(workItemID) + if err != nil { + return nil, errors.Wrapf(ErrSystemError, err, "Failed to lookup from reader workqueue for info: %v", workItemID) + } + + if !found { + return nil, errors.Errorf(ErrSystemError, "Item not found in the reader workqueue even though it was just added. ItemID: %v", workItemID) + } + + switch info.Status() { + case workqueue.WorkStatusSucceeded: + readerWorkItem, casted := info.Item().(*ReaderWorkItem) + if !casted { + return nil, errors.Errorf(ErrSystemError, "Item wasn't casted to ReaderWorkItem. ItemID: %v. Type: %v", workItemID, reflect.TypeOf(info)) + } + + if readerWorkItem.IsCached() { + cachedResults.Set(uint(idx)) + cachedCount++ + } + case workqueue.WorkStatusFailed: + respErr = info.Error() + case workqueue.WorkStatusNotDone: + status = ResponseStatusNotReady + } + } + + return newDownloadFuture(status, respErr, cachedResults, len(requests), cachedCount), nil +} + +func (c AsyncClientImpl) Upload(ctx context.Context, requests ...UploadRequest) (putFuture UploadFuture, err error) { + status := ResponseStatusReady + var respErr error + for idx, request := range requests { + inputHash, err := hashInputs(ctx, request.Key) + if err != nil { + return nil, errors.Wrapf(ErrSystemError, err, "Failed to hash inputs for item: %v", request.Key) + } + workItemID := formatWorkItemID(request.Key, idx, inputHash) + err = c.Writer.Queue(ctx, workItemID, NewWriterWorkItem( + request.Key, + request.ArtifactData, + request.ArtifactMetadata)) + + if err != nil { + return nil, err + } + + info, found, err := c.Writer.Get(workItemID) + if err != nil { + return nil, errors.Wrapf(ErrSystemError, err, "Failed to lookup from writer workqueue for info: %v", workItemID) + } + + if !found { + return nil, errors.Errorf(ErrSystemError, "Item not found in the writer workqueue even though it was just added. ItemID: %v", workItemID) + } + + switch info.Status() { + case workqueue.WorkStatusNotDone: + status = ResponseStatusNotReady + case workqueue.WorkStatusFailed: + respErr = info.Error() + } + } + + return newUploadFuture(status, respErr), nil +} + +func (c AsyncClientImpl) Start(ctx context.Context) error { + if err := c.Reader.Start(ctx); err != nil { + return errors.Wrapf(ErrSystemError, err, "Failed to start reader queue.") + } + + if err := c.Writer.Start(ctx); err != nil { + return errors.Wrapf(ErrSystemError, err, "Failed to start writer queue.") + } + + return nil +} + +func NewAsyncClient(client Client, cfg Config, scope promutils.Scope) (AsyncClientImpl, error) { + readerWorkQueue, err := workqueue.NewIndexedWorkQueue("reader", NewReaderProcessor(client), cfg.ReaderWorkqueueConfig, + scope.NewSubScope("reader")) + if err != nil { + return AsyncClientImpl{}, err + } + + writerWorkQueue, err := workqueue.NewIndexedWorkQueue("writer", NewWriterProcessor(client), cfg.WriterWorkqueueConfig, + scope.NewSubScope("writer")) + if err != nil { + return AsyncClientImpl{}, err + } + + return AsyncClientImpl{ + Reader: readerWorkQueue, + Writer: writerWorkQueue, + }, nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/async_client_impl_test.go b/flyteplugins/go/tasks/pluginmachinery/catalog/async_client_impl_test.go new file mode 100644 index 0000000000..9f8829ab53 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/async_client_impl_test.go @@ -0,0 +1,212 @@ +package catalog + +import ( + "context" + "reflect" + "testing" + + "github.com/stretchr/testify/mock" + + mocks2 "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/workqueue" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/workqueue/mocks" + "github.com/flyteorg/flyte/v2/flytestdlib/bitarray" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +var exampleInterface = &core.TypedInterface{ + Inputs: &core.VariableMap{ + Variables: map[string]*core.Variable{ + "a": { + Type: &core.LiteralType{ + Type: &core.LiteralType_Simple{ + Simple: core.SimpleType_INTEGER, + }, + }, + }, + }, + }, +} +var input1 = &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "a": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{ + Primitive: &core.Primitive{ + Value: &core.Primitive_Integer{ + Integer: 1, + }, + }, + }, + }, + }, + }, + }, +} +var input2 = &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "a": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{ + Primitive: &core.Primitive{ + Value: &core.Primitive_Integer{ + Integer: 2, + }, + }, + }, + }, + }, + }, + }, +} + +func TestAsyncClientImpl_Download(t *testing.T) { + ctx := context.Background() + + q := &mocks.IndexedWorkQueue{} + info := &mocks.WorkItemInfo{} + info.EXPECT().Item().Return(NewReaderWorkItem(Key{}, &mocks2.OutputWriter{})) + info.EXPECT().Status().Return(workqueue.WorkStatusSucceeded) + q.EXPECT().Get(mock.Anything).Return(info, true, nil) + q.EXPECT().Queue(mock.Anything, mock.Anything, mock.Anything).Return(nil) + + ow := &mocks2.OutputWriter{} + ow.EXPECT().GetOutputPrefixPath().Return("/prefix/") + ow.EXPECT().GetOutputPath().Return("/prefix/outputs.pb") + + tests := []struct { + name string + reader workqueue.IndexedWorkQueue + requests []DownloadRequest + wantOutputFuture DownloadFuture + wantErr bool + }{ + {"DownloadQueued", q, []DownloadRequest{ + { + Key: Key{}, + Target: ow, + }, + }, newDownloadFuture(ResponseStatusReady, nil, bitarray.NewBitSet(1), 1, 0), false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c := AsyncClientImpl{ + Reader: tt.reader, + } + gotOutputFuture, err := c.Download(ctx, tt.requests...) + if (err != nil) != tt.wantErr { + t.Errorf("AsyncClientImpl.Download() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(gotOutputFuture, tt.wantOutputFuture) { + t.Errorf("AsyncClientImpl.Download() = %v, want %v", gotOutputFuture, tt.wantOutputFuture) + } + }) + } +} + +func TestAsyncClientImpl_Upload(t *testing.T) { + ctx := context.Background() + + inputHash1 := "{{{} [] [] } 0 [] UNSPECIFIED }:-0-DNhkpTTPC5YDtRGb4yT-PFxgMSgHzHrKAQKgQGEfGRY" + inputHash2 := "{{{} [] [] } 0 [] UNSPECIFIED }:-1-26M4dwarvBVJqJSUC4JC1GtRYgVBIAmQfsFSdLVMlAc" + + q := &mocks.IndexedWorkQueue{} + info := &mocks.WorkItemInfo{} + info.EXPECT().Item().Return(NewReaderWorkItem(Key{}, &mocks2.OutputWriter{})) + info.EXPECT().Status().Return(workqueue.WorkStatusSucceeded) + q.EXPECT().Get(mock.Anything).Return(info, true, nil) + q.EXPECT().Get(mock.Anything).Return(info, true, nil) + q.EXPECT().Queue(mock.Anything, mock.Anything, mock.Anything).Return(nil) + + inputReader1 := &mocks2.InputReader{} + inputReader1.EXPECT().Get(mock.Anything).Return(input1, nil) + inputReader2 := &mocks2.InputReader{} + inputReader2.EXPECT().Get(mock.Anything).Return(input2, nil) + + tests := []struct { + name string + requests []UploadRequest + wantPutFuture UploadFuture + wantErr bool + }{ + { + "UploadSucceeded", + // The second request has the same Key.Identifier and Key.Cache version but a different + // Key.InputReader. This should lead to a different WorkItemID in the queue. + // See https://github.com/flyteorg/flyte/issues/3787 for more details + []UploadRequest{ + { + Key: Key{ + TypedInterface: *exampleInterface, + InputReader: inputReader1, + }, + }, + { + Key: Key{ + TypedInterface: *exampleInterface, + InputReader: inputReader2, + }, + }, + }, + newUploadFuture(ResponseStatusReady, nil), + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c := AsyncClientImpl{ + Writer: q, + } + gotPutFuture, err := c.Upload(ctx, tt.requests...) + if (err != nil) != tt.wantErr { + t.Errorf("AsyncClientImpl.Sidecar() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(gotPutFuture, tt.wantPutFuture) { + t.Errorf("AsyncClientImpl.Sidecar() = %v, want %v", gotPutFuture, tt.wantPutFuture) + } + expectedWorkItemIDs := []string{inputHash1, inputHash2} + gottenWorkItemIDs := make([]string, 0) + for _, mockCall := range q.Calls { + if mockCall.Method == "Get" { + gottenWorkItemIDs = append(gottenWorkItemIDs, mockCall.Arguments[0].(string)) + } + } + if !reflect.DeepEqual(gottenWorkItemIDs, expectedWorkItemIDs) { + t.Errorf("Retrieved workitem IDs = \n|%v|, want \n|%v|", gottenWorkItemIDs, expectedWorkItemIDs) + } + }) + } +} + +func TestAsyncClientImpl_Start(t *testing.T) { + type fields struct { + Reader workqueue.IndexedWorkQueue + Writer workqueue.IndexedWorkQueue + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c := AsyncClientImpl{ + Reader: tt.fields.Reader, + Writer: tt.fields.Writer, + } + if err := c.Start(tt.args.ctx); (err != nil) != tt.wantErr { + t.Errorf("AsyncClientImpl.Start() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/client.go b/flyteplugins/go/tasks/pluginmachinery/catalog/client.go new file mode 100644 index 0000000000..faedb18da2 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/client.go @@ -0,0 +1,165 @@ +package catalog + +import ( + "context" + "fmt" + "time" + + "google.golang.org/grpc/codes" + grpcStatus "google.golang.org/grpc/status" + "google.golang.org/protobuf/types/known/timestamppb" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/cacheservice" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + + +// Metadata to be associated with the catalog object +type Metadata struct { + WorkflowExecutionIdentifier *core.WorkflowExecutionIdentifier + NodeExecutionIdentifier *core.NodeExecutionIdentifier + TaskExecutionIdentifier *core.TaskExecutionIdentifier + CreatedAt *timestamppb.Timestamp +} + +// An identifier for a catalog object. +type Key struct { + Identifier core.Identifier + CacheVersion string + CacheIgnoreInputVars []string + TypedInterface core.TypedInterface + InputReader io.InputReader + CacheKey string +} + +type ReservationCache struct { + Timestamp time.Time + ReservationStatus core.CatalogReservation_Status +} + +func (k Key) String() string { + return fmt.Sprintf("%v:%v", k.Identifier, k.CacheVersion) +} + +// Indicates that status of the query to Catalog. This can be returned for both Get and Put calls +type Status struct { + cacheStatus core.CatalogCacheStatus + metadata *core.CatalogMetadata +} + +func (s Status) GetCacheStatus() core.CatalogCacheStatus { + return s.cacheStatus +} + +func (s Status) GetMetadata() *core.CatalogMetadata { + return s.metadata +} + +func NewPutFailureStatus(key *Key) Status { + md := &core.CatalogMetadata{ + DatasetId: &key.Identifier, + } + return Status{cacheStatus: core.CatalogCacheStatus_CACHE_PUT_FAILURE, metadata: md} +} + +func NewStatus(cacheStatus core.CatalogCacheStatus, md *core.CatalogMetadata) Status { + return Status{cacheStatus: cacheStatus, metadata: md} +} + +// Indicates the Entry in Catalog that was populated +type Entry struct { + outputs io.OutputReader + status Status +} + +func (e Entry) GetOutputs() io.OutputReader { + return e.outputs +} + +func (e Entry) GetStatus() Status { + return e.status +} + +func NewFailedCatalogEntry(status Status) Entry { + return Entry{status: status} +} + +func NewCatalogEntry(outputs io.OutputReader, status Status) Entry { + return Entry{outputs: outputs, status: status} +} + +// ReservationEntry encapsulates the current state of an artifact reservation within the catalog +type ReservationEntry struct { + expiresAt time.Time + heartbeatInterval time.Duration + ownerID string + status core.CatalogReservation_Status +} + +// Returns the expiration timestamp at which the reservation will no longer be valid +func (r ReservationEntry) GetExpiresAt() time.Time { + return r.expiresAt +} + +// Returns the heartbeat interval, denoting how often the catalog expects a reservation extension request +func (r ReservationEntry) GetHeartbeatInterval() time.Duration { + return r.heartbeatInterval +} + +// Returns the ID of the current reservation owner +func (r ReservationEntry) GetOwnerID() string { + return r.ownerID +} + +// Returns the status of the attempted reservation operation +func (r ReservationEntry) GetStatus() core.CatalogReservation_Status { + return r.status +} + +// Creates a new ReservationEntry using the status, all other fields are set to default values +func NewReservationEntryStatus(status core.CatalogReservation_Status) ReservationEntry { + duration := 0 * time.Second + return ReservationEntry{ + expiresAt: time.Time{}, + heartbeatInterval: duration, + ownerID: "", + status: status, + } +} + +// Creates a new ReservationEntry populated with the specified parameters +func NewReservationEntry(expiresAt time.Time, heartbeatInterval time.Duration, ownerID string, status core.CatalogReservation_Status) ReservationEntry { + return ReservationEntry{ + expiresAt: expiresAt, + heartbeatInterval: heartbeatInterval, + ownerID: ownerID, + status: status, + } +} + +// Client represents the default cache client that allows the memoization data in Flyte +type Client interface { + // Get returns the artifact associated with the given key. + Get(ctx context.Context, key Key) (Entry, error) + // GetOrExtendReservation tries to retrieve a (valid) reservation for the given key, creating a new one using the + // specified owner ID if none was found or updating an existing one if it has expired. + GetOrExtendReservation(ctx context.Context, key Key, ownerID string, heartbeatInterval time.Duration) (*cacheservice.Reservation, error) + // Put stores the given data using the specified key, creating artifact entries as required. + // To update an existing artifact, use Update instead. + Put(ctx context.Context, key Key, reader io.OutputReader, metadata Metadata) (Status, error) + // Update updates existing data stored at the specified key, overwriting artifact entries with the new data provided. + // To create a new (non-existent) artifact, use Put instead. + Update(ctx context.Context, key Key, reader io.OutputReader, metadata Metadata) (Status, error) + // ReleaseReservation releases an acquired reservation for the given key and owner ID. + ReleaseReservation(ctx context.Context, key Key, ownerID string) error + // GetReservationCache checks the reservation cache for the given owner ID + GetReservationCache(ownerID string) ReservationCache + // UpdateReservationCache updates the reservation cache for the given owner ID + UpdateReservationCache(ownerID string, entry ReservationCache) +} + +func IsNotFound(err error) bool { + taskStatus, ok := grpcStatus.FromError(err) + return ok && taskStatus.Code() == codes.NotFound +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/client_test.go b/flyteplugins/go/tasks/pluginmachinery/catalog/client_test.go new file mode 100644 index 0000000000..2b53d80815 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/client_test.go @@ -0,0 +1,123 @@ +package catalog + +import ( + "testing" + "time" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io/mocks" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +var ( + cacheStatus = core.CatalogCacheStatus_CACHE_MISS + catalogMetadata = core.CatalogMetadata{ + DatasetId: &core.Identifier{ + Project: "project", + Domain: "domain", + Name: "name", + }, + ArtifactTag: &core.CatalogArtifactTag{ + ArtifactId: "artifactID", + Name: "artifactName", + }, + } + key = &Key{ + Identifier: core.Identifier{ + Project: "project", + Domain: "domain", + Name: "name", + Version: "1.0.0", + }, + CacheVersion: "1.0.0", + TypedInterface: core.TypedInterface{ + Inputs: nil, + Outputs: nil, + }, + } +) + +func TestNewPutFailureStatus(t *testing.T) { + status := NewPutFailureStatus(key) + + assert.Equal(t, status.GetCacheStatus(), core.CatalogCacheStatus_CACHE_PUT_FAILURE) + assert.EqualValues(t, status.GetMetadata().GetDatasetId(), &key.Identifier) +} + +func TestStatus(t *testing.T) { + status := NewStatus(cacheStatus, &catalogMetadata) + + assert.Equal(t, status.GetCacheStatus(), cacheStatus) + assert.Equal(t, status.GetMetadata().DatasetId.Project, catalogMetadata.DatasetId.Project) + assert.Equal(t, status.GetMetadata().DatasetId.Domain, catalogMetadata.DatasetId.Domain) + assert.Equal(t, status.GetMetadata().DatasetId.Name, catalogMetadata.DatasetId.Name) + assert.Equal(t, status.GetMetadata().ArtifactTag.ArtifactId, catalogMetadata.ArtifactTag.ArtifactId) + assert.Equal(t, status.GetMetadata().ArtifactTag.Name, catalogMetadata.ArtifactTag.Name) +} + +func TestEntry(t *testing.T) { + tests := []struct { + name string + entry Entry + }{ + { + "base", + NewCatalogEntry(&mocks.OutputReader{}, NewStatus(cacheStatus, &catalogMetadata)), + }, + { + "failed", + NewFailedCatalogEntry(NewStatus(cacheStatus, &catalogMetadata)), + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + status := tt.entry.GetStatus() + assert.Equal(t, status.GetCacheStatus(), cacheStatus) + assert.Equal(t, status.GetMetadata().DatasetId.Project, catalogMetadata.DatasetId.Project) + assert.Equal(t, status.GetMetadata().DatasetId.Domain, catalogMetadata.DatasetId.Domain) + assert.Equal(t, status.GetMetadata().DatasetId.Name, catalogMetadata.DatasetId.Name) + assert.Equal(t, status.GetMetadata().ArtifactTag.ArtifactId, catalogMetadata.ArtifactTag.ArtifactId) + assert.Equal(t, status.GetMetadata().ArtifactTag.Name, catalogMetadata.ArtifactTag.Name) + }) + } +} + +func TestReservationEntry(t *testing.T) { + reservationStatus := core.CatalogReservation_RESERVATION_ACQUIRED + tests := []struct { + name string + reservationEntry ReservationEntry + expiresAt time.Time + heartbeatInterval time.Duration + ownerID string + status core.CatalogReservation_Status + }{ + { + "base", + NewReservationEntry(time.Time{}, 5*time.Second, "owner", reservationStatus), + time.Time{}, + 5 * time.Second, + "owner", + reservationStatus, + }, + { + "status", + NewReservationEntryStatus(reservationStatus), + time.Time{}, + 0 * time.Second, + "", + reservationStatus, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.Equal(t, tt.reservationEntry.GetExpiresAt(), tt.expiresAt) + assert.Equal(t, tt.reservationEntry.GetHeartbeatInterval(), tt.heartbeatInterval) + assert.Equal(t, tt.reservationEntry.GetOwnerID(), tt.ownerID) + assert.Equal(t, tt.reservationEntry.GetStatus(), tt.status) + }) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/config.go b/flyteplugins/go/tasks/pluginmachinery/catalog/config.go new file mode 100644 index 0000000000..f37aca05a8 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/config.go @@ -0,0 +1,37 @@ +package catalog + +import ( + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/workqueue" +) + +//go:generate pflags Config --default-var=defaultConfig + +var cfgSection = config.MustRegisterSubSection("catalogCache", defaultConfig) + +type Config struct { + ReaderWorkqueueConfig workqueue.Config `json:"reader" pflag:",Catalog reader workqueue config. Make sure the index cache must be big enough to accommodate the biggest array task allowed to run on the system."` + WriterWorkqueueConfig workqueue.Config `json:"writer" pflag:",Catalog writer workqueue config. Make sure the index cache must be big enough to accommodate the biggest array task allowed to run on the system."` + CacheKey CacheKeyConfig `json:"cacheKey" pflag:",Cache key configuration."` +} + +type CacheKeyConfig struct { + EnforceExecutionProjectDomain bool `json:"enforceExecutionProjectDomain" pflag:", Use execution project domain when computing the cache key. This means that even if you reference tasks/launchplans from a different project, cache keys will be computed based on the execution project domain instead."` +} + +var defaultConfig = &Config{ + ReaderWorkqueueConfig: workqueue.Config{ + MaxRetries: 3, + Workers: 10, + IndexCacheMaxItems: 10000, + }, + WriterWorkqueueConfig: workqueue.Config{ + MaxRetries: 3, + Workers: 10, + IndexCacheMaxItems: 10000, + }, +} + +func GetConfig() *Config { + return cfgSection.GetConfig().(*Config) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/config_flags.go b/flyteplugins/go/tasks/pluginmachinery/catalog/config_flags.go new file mode 100755 index 0000000000..0f62ec99ae --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/config_flags.go @@ -0,0 +1,60 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package catalog + +import ( + "encoding/json" + "reflect" + + "fmt" + + "github.com/spf13/pflag" +) + +// If v is a pointer, it will get its element value or the zero value of the element type. +// If v is not a pointer, it will return it as is. +func (Config) elemValueOrNil(v interface{}) interface{} { + if t := reflect.TypeOf(v); t.Kind() == reflect.Ptr { + if reflect.ValueOf(v).IsNil() { + return reflect.Zero(t.Elem()).Interface() + } else { + return reflect.ValueOf(v).Interface() + } + } else if v == nil { + return reflect.Zero(t).Interface() + } + + return v +} + +func (Config) mustJsonMarshal(v interface{}) string { + raw, err := json.Marshal(v) + if err != nil { + panic(err) + } + + return string(raw) +} + +func (Config) mustMarshalJSON(v json.Marshaler) string { + raw, err := v.MarshalJSON() + if err != nil { + panic(err) + } + + return string(raw) +} + +// GetPFlagSet will return strongly types pflags for all fields in Config and its nested types. The format of the +// flags is json-name.json-sub-name... etc. +func (cfg Config) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("Config", pflag.ExitOnError) + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "reader.workers"), defaultConfig.ReaderWorkqueueConfig.Workers, "Number of concurrent workers to start processing the queue.") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "reader.maxRetries"), defaultConfig.ReaderWorkqueueConfig.MaxRetries, "Maximum number of retries per item.") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "reader.maxItems"), defaultConfig.ReaderWorkqueueConfig.IndexCacheMaxItems, "Maximum number of entries to keep in the index.") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "writer.workers"), defaultConfig.WriterWorkqueueConfig.Workers, "Number of concurrent workers to start processing the queue.") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "writer.maxRetries"), defaultConfig.WriterWorkqueueConfig.MaxRetries, "Maximum number of retries per item.") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "writer.maxItems"), defaultConfig.WriterWorkqueueConfig.IndexCacheMaxItems, "Maximum number of entries to keep in the index.") + return cmdFlags +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/config_flags_test.go b/flyteplugins/go/tasks/pluginmachinery/catalog/config_flags_test.go new file mode 100755 index 0000000000..57a4397361 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/config_flags_test.go @@ -0,0 +1,186 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package catalog + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "testing" + + "github.com/mitchellh/mapstructure" + "github.com/stretchr/testify/assert" +) + +var dereferencableKindsConfig = map[reflect.Kind]struct{}{ + reflect.Array: {}, reflect.Chan: {}, reflect.Map: {}, reflect.Ptr: {}, reflect.Slice: {}, +} + +// Checks if t is a kind that can be dereferenced to get its underlying type. +func canGetElementConfig(t reflect.Kind) bool { + _, exists := dereferencableKindsConfig[t] + return exists +} + +// This decoder hook tests types for json unmarshaling capability. If implemented, it uses json unmarshal to build the +// object. Otherwise, it'll just pass on the original data. +func jsonUnmarshalerHookConfig(_, to reflect.Type, data interface{}) (interface{}, error) { + unmarshalerType := reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + if to.Implements(unmarshalerType) || reflect.PtrTo(to).Implements(unmarshalerType) || + (canGetElementConfig(to.Kind()) && to.Elem().Implements(unmarshalerType)) { + + raw, err := json.Marshal(data) + if err != nil { + fmt.Printf("Failed to marshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + res := reflect.New(to).Interface() + err = json.Unmarshal(raw, &res) + if err != nil { + fmt.Printf("Failed to umarshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + return res, nil + } + + return data, nil +} + +func decode_Config(input, result interface{}) error { + config := &mapstructure.DecoderConfig{ + TagName: "json", + WeaklyTypedInput: true, + Result: result, + DecodeHook: mapstructure.ComposeDecodeHookFunc( + mapstructure.StringToTimeDurationHookFunc(), + mapstructure.StringToSliceHookFunc(","), + jsonUnmarshalerHookConfig, + ), + } + + decoder, err := mapstructure.NewDecoder(config) + if err != nil { + return err + } + + return decoder.Decode(input) +} + +func join_Config(arr interface{}, sep string) string { + listValue := reflect.ValueOf(arr) + strs := make([]string, 0, listValue.Len()) + for i := 0; i < listValue.Len(); i++ { + strs = append(strs, fmt.Sprintf("%v", listValue.Index(i))) + } + + return strings.Join(strs, sep) +} + +func testDecodeJson_Config(t *testing.T, val, result interface{}) { + assert.NoError(t, decode_Config(val, result)) +} + +func testDecodeRaw_Config(t *testing.T, vStringSlice, result interface{}) { + assert.NoError(t, decode_Config(vStringSlice, result)) +} + +func TestConfig_GetPFlagSet(t *testing.T) { + val := Config{} + cmdFlags := val.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) +} + +func TestConfig_SetFlags(t *testing.T) { + actual := Config{} + cmdFlags := actual.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) + + t.Run("Test_reader.workers", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("reader.workers", testValue) + if vInt, err := cmdFlags.GetInt("reader.workers"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vInt), &actual.ReaderWorkqueueConfig.Workers) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_reader.maxRetries", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("reader.maxRetries", testValue) + if vInt, err := cmdFlags.GetInt("reader.maxRetries"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vInt), &actual.ReaderWorkqueueConfig.MaxRetries) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_reader.maxItems", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("reader.maxItems", testValue) + if vInt, err := cmdFlags.GetInt("reader.maxItems"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vInt), &actual.ReaderWorkqueueConfig.IndexCacheMaxItems) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_writer.workers", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("writer.workers", testValue) + if vInt, err := cmdFlags.GetInt("writer.workers"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vInt), &actual.WriterWorkqueueConfig.Workers) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_writer.maxRetries", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("writer.maxRetries", testValue) + if vInt, err := cmdFlags.GetInt("writer.maxRetries"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vInt), &actual.WriterWorkqueueConfig.MaxRetries) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_writer.maxItems", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("writer.maxItems", testValue) + if vInt, err := cmdFlags.GetInt("writer.maxItems"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vInt), &actual.WriterWorkqueueConfig.IndexCacheMaxItems) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/hashing.go b/flyteplugins/go/tasks/pluginmachinery/catalog/hashing.go new file mode 100644 index 0000000000..cee29eba76 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/hashing.go @@ -0,0 +1,102 @@ +package catalog + +import ( + "context" + "encoding/base64" + + "k8s.io/utils/strings/slices" + + "github.com/flyteorg/flyte/v2/flytestdlib/pbhash" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +var emptyLiteralMap = core.LiteralMap{Literals: map[string]*core.Literal{}} + +// Hashify a literal, in other words, produce a new literal where the corresponding value is removed in case +// the literal hash is set. +func hashify(literal *core.Literal) *core.Literal { + // If the hash is set, return an empty literal with the same hash, + // regardless of type (scalar/collection/map). + if literal.GetHash() != "" { + return &core.Literal{ + Hash: literal.GetHash(), + } + } + + // Two recursive cases: + // 1. A collection of literals or + // 2. A map of literals + if literal.GetCollection() != nil { + literals := literal.GetCollection().Literals + literalsHash := make([]*core.Literal, 0) + for _, lit := range literals { + literalsHash = append(literalsHash, hashify(lit)) + } + return &core.Literal{ + Value: &core.Literal_Collection{ + Collection: &core.LiteralCollection{ + Literals: literalsHash, + }, + }, + } + } + if literal.GetMap() != nil { + literalsMap := make(map[string]*core.Literal) + for key, lit := range literal.GetMap().Literals { + literalsMap[key] = hashify(lit) + } + return &core.Literal{ + Value: &core.Literal_Map{ + Map: &core.LiteralMap{ + Literals: literalsMap, + }, + }, + } + } + + return literal +} + +func HashLiteralMap(ctx context.Context, literalMap *core.LiteralMap, cacheIgnoreInputVars []string) (string, error) { + if literalMap == nil || len(literalMap.Literals) == 0 { + literalMap = &emptyLiteralMap + } + + // Hashify, i.e. generate a copy of the literal map where each literal value is removed + // in case the corresponding hash is set. + hashifiedLiteralMap := make(map[string]*core.Literal, len(literalMap.Literals)) + for name, literal := range literalMap.Literals { + if !slices.Contains(cacheIgnoreInputVars, name) { + hashifiedLiteralMap[name] = hashify(literal) + } + } + hashifiedInputs := &core.LiteralMap{ + Literals: hashifiedLiteralMap, + } + + inputsHash, err := pbhash.ComputeHash(ctx, hashifiedInputs) + if err != nil { + return "", err + } + + return base64.RawURLEncoding.EncodeToString(inputsHash), nil +} + +func HashIdentifierExceptVersion(ctx context.Context, id core.Identifier) (string, error) { + + // Exclude version from the ID hash to support cache hits across different versions of the same resource + idCopy := &core.Identifier{ + ResourceType: id.ResourceType, + Project: id.Project, + Domain: id.Domain, + Name: id.Name, + Org: id.Org, + } + + hash, err := pbhash.ComputeHashString(ctx, idCopy) + if err != nil { + return "", err + } + + return hash, nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/hashing_test.go b/flyteplugins/go/tasks/pluginmachinery/catalog/hashing_test.go new file mode 100644 index 0000000000..3300f47e2e --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/hashing_test.go @@ -0,0 +1,699 @@ +package catalog + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flyteidl2/clients/go/coreutils" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestHashLiteralMap_LiteralsWithHashSet(t *testing.T) { + tests := []struct { + name string + literal *core.Literal + expectedLiteral *core.Literal + }{ + { + name: "single literal where hash is not set", + literal: coreutils.MustMakeLiteral(42), + expectedLiteral: coreutils.MustMakeLiteral(42), + }, + { + name: "single literal containing hash", + literal: &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://some-address", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + Hash: "abcde", + }, + expectedLiteral: &core.Literal{ + Value: nil, + Hash: "abcde", + }, + }, + { + name: "list of literals containing a single item where literal sets its hash", + literal: &core.Literal{ + Value: &core.Literal_Collection{ + Collection: &core.LiteralCollection{ + Literals: []*core.Literal{ + { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://some-address", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + Hash: "hash1", + }, + }, + }, + }, + }, + expectedLiteral: &core.Literal{ + Value: &core.Literal_Collection{ + Collection: &core.LiteralCollection{ + Literals: []*core.Literal{ + { + Value: nil, + Hash: "hash1", + }, + }, + }, + }, + }, + }, + { + name: "list of literals containing two items where each literal sets its hash", + literal: &core.Literal{ + Value: &core.Literal_Collection{ + Collection: &core.LiteralCollection{ + Literals: []*core.Literal{ + { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://some-address", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + Hash: "hash1", + }, + { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://another-address", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + Hash: "hash2", + }, + }, + }, + }, + }, + expectedLiteral: &core.Literal{ + Value: &core.Literal_Collection{ + Collection: &core.LiteralCollection{ + Literals: []*core.Literal{ + { + Value: nil, + Hash: "hash1", + }, + { + Value: nil, + Hash: "hash2", + }, + }, + }, + }, + }, + }, + { + name: "list of literals containing two items where only one literal has its hash set", + literal: &core.Literal{ + Value: &core.Literal_Collection{ + Collection: &core.LiteralCollection{ + Literals: []*core.Literal{ + { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://some-address", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + Hash: "hash1", + }, + { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://another-address", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + expectedLiteral: &core.Literal{ + Value: &core.Literal_Collection{ + Collection: &core.LiteralCollection{ + Literals: []*core.Literal{ + { + Value: nil, + Hash: "hash1", + }, + { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://another-address", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "map of literals containing a single item where literal sets its hash", + literal: &core.Literal{ + Value: &core.Literal_Map{ + Map: &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "literal1": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://some-address", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + Hash: "hash-42", + }, + }, + }, + }, + }, + expectedLiteral: &core.Literal{ + Value: &core.Literal_Map{ + Map: &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "literal1": { + Value: nil, + Hash: "hash-42", + }, + }, + }, + }, + }, + }, + { + name: "map of literals containing a three items where only one literal sets its hash", + literal: &core.Literal{ + Value: &core.Literal_Map{ + Map: &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "literal1": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://some-address", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + }, + "literal2-set-its-hash": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://some-address-for-literal-2", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + Hash: "literal-2-hash", + }, + "literal3": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://some-address-for-literal-3", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + expectedLiteral: &core.Literal{ + Value: &core.Literal_Map{ + Map: &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "literal1": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://some-address", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + }, + "literal2-set-its-hash": { + Value: nil, + Hash: "literal-2-hash", + }, + "literal3": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://some-address-for-literal-3", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "list of map of literals containing a mixture of literals have their hashes set or not set", + literal: &core.Literal{ + Value: &core.Literal_Collection{ + Collection: &core.LiteralCollection{ + Literals: []*core.Literal{ + { + Value: &core.Literal_Map{ + Map: &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "literal1": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://some-address", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + }, + "literal2-set-its-hash": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://some-address-for-literal-2", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + Hash: "literal-2-hash", + }, + "literal3": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://some-address-for-literal-3", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + Value: &core.Literal_Map{ + Map: &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "another-literal-1": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://some-address-for-another-literal-1", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + Hash: "another-literal-1-hash", + }, + "another-literal2-set-its-hash": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://some-address-for-literal-2", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + expectedLiteral: &core.Literal{ + Value: &core.Literal_Collection{ + Collection: &core.LiteralCollection{ + Literals: []*core.Literal{ + { + Value: &core.Literal_Map{ + Map: &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "literal1": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://some-address", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + }, + "literal2-set-its-hash": { + Value: nil, + Hash: "literal-2-hash", + }, + "literal3": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://some-address-for-literal-3", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + Value: &core.Literal_Map{ + Map: &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "another-literal-1": { + Value: nil, + Hash: "another-literal-1-hash", + }, + "another-literal2-set-its-hash": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_StructuredDataset{ + StructuredDataset: &core.StructuredDataset{ + Uri: "my-blob-stora://some-address-for-literal-2", + Metadata: &core.StructuredDatasetMetadata{ + StructuredDatasetType: &core.StructuredDatasetType{ + Format: "my-columnar-data-format", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "literal map containing hash", + literal: &core.Literal{ + Value: &core.Literal_Map{ + Map: &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "hello": { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{ + Primitive: &core.Primitive{ + Value: &core.Primitive_StringValue{ + StringValue: "world", + }, + }, + }, + }, + }, + }, + }, + }, + }, + Hash: "0xffff", + }, + expectedLiteral: &core.Literal{ + Value: nil, + Hash: "0xffff", + }, + }, + { + name: "literal collection containing hash", + literal: &core.Literal{ + Value: &core.Literal_Collection{ + Collection: &core.LiteralCollection{ + Literals: []*core.Literal{ + { + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Primitive{ + Primitive: &core.Primitive{ + Value: &core.Primitive_Integer{ + Integer: 42, + }, + }, + }, + }, + }, + }, + }, + }, + }, + Hash: "0xabcdef", + }, + expectedLiteral: &core.Literal{ + Value: nil, + Hash: "0xabcdef", + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.Equal(t, tt.expectedLiteral, hashify(tt.literal)) + + // Double-check that generating a tag is successful + literalMap := &core.LiteralMap{Literals: map[string]*core.Literal{"o0": tt.literal}} + hash, err := HashLiteralMap(context.TODO(), literalMap, nil) + assert.NoError(t, err) + assert.NotEmpty(t, hash) + }) + } +} + +// Ensure the key order on the inputs generates the same hash +func TestInputValueSorted(t *testing.T) { + literalMap, err := coreutils.MakeLiteralMap(map[string]interface{}{"1": 1, "2": 2}) + assert.NoError(t, err) + + hash, err := HashLiteralMap(context.TODO(), literalMap, nil) + assert.NoError(t, err) + assert.Equal(t, "GQid5LjHbakcW68DS3P2jp80QLbiF0olFHF2hTh5bg8", hash) + + literalMap, err = coreutils.MakeLiteralMap(map[string]interface{}{"2": 2, "1": 1}) + assert.NoError(t, err) + + hashDupe, err := HashLiteralMap(context.TODO(), literalMap, nil) + assert.NoError(t, err) + assert.Equal(t, hashDupe, hash) +} + +// Ensure that empty inputs are hashed the same way +func TestNoInputValues(t *testing.T) { + hash, err := HashLiteralMap(context.TODO(), nil, nil) + assert.NoError(t, err) + assert.Equal(t, "GKw-c0PwFokMUQ6T-TUmEWnZ4_VlQ2Qpgw-vCTT0-OQ", hash) + + hashDupe, err := HashLiteralMap(context.TODO(), &core.LiteralMap{Literals: nil}, nil) + assert.NoError(t, err) + assert.Equal(t, "GKw-c0PwFokMUQ6T-TUmEWnZ4_VlQ2Qpgw-vCTT0-OQ", hashDupe) + assert.Equal(t, hashDupe, hash) +} + +// Ensure that empty inputs are hashed the same way +func TestCacheIgnoreInputVars(t *testing.T) { + literalMap, err := coreutils.MakeLiteralMap(map[string]interface{}{"1": 1, "2": 2}) + assert.NoError(t, err) + + hash, err := HashLiteralMap(context.TODO(), literalMap, nil) + assert.NoError(t, err) + assert.Equal(t, "GQid5LjHbakcW68DS3P2jp80QLbiF0olFHF2hTh5bg8", hash) + + literalMap, err = coreutils.MakeLiteralMap(map[string]interface{}{"2": 2, "1": 1, "3": 3}) + assert.NoError(t, err) + + hashDupe, err := HashLiteralMap(context.TODO(), literalMap, []string{"3"}) + assert.NoError(t, err) + assert.Equal(t, hashDupe, hash) +} + +func TestHashIdentifierExceptVersion(t *testing.T) { + identifier := core.Identifier{ + Project: "project_1", + Domain: "domain_1", + Name: "name_1", + Version: "0", + Org: "org_1", + } + + identifierDiffVersion := core.Identifier{ + Project: "project_1", + Domain: "domain_1", + Name: "name_1", + Version: "1", + Org: "org_1", + } + + expectedHashIdentifier := "+UmrGhEwHv3FesdpA4gliBluF3FUXz4tshmuOlw1FSk=" + + hashedIdentifier, err := HashIdentifierExceptVersion(context.TODO(), identifier) + assert.NoError(t, err) + assert.Equal(t, expectedHashIdentifier, hashedIdentifier) + + hashedIdentifierDiffVersion, err := HashIdentifierExceptVersion(context.TODO(), identifierDiffVersion) + assert.NoError(t, err) + assert.Equal(t, expectedHashIdentifier, hashedIdentifierDiffVersion) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/async_client.go b/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/async_client.go new file mode 100644 index 0000000000..9d424a4920 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/async_client.go @@ -0,0 +1,184 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + catalog "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/catalog" + + mock "github.com/stretchr/testify/mock" +) + +// AsyncClient is an autogenerated mock type for the AsyncClient type +type AsyncClient struct { + mock.Mock +} + +type AsyncClient_Expecter struct { + mock *mock.Mock +} + +func (_m *AsyncClient) EXPECT() *AsyncClient_Expecter { + return &AsyncClient_Expecter{mock: &_m.Mock} +} + +// Download provides a mock function with given fields: ctx, requests +func (_m *AsyncClient) Download(ctx context.Context, requests ...catalog.DownloadRequest) (catalog.DownloadFuture, error) { + _va := make([]interface{}, len(requests)) + for _i := range requests { + _va[_i] = requests[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Download") + } + + var r0 catalog.DownloadFuture + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, ...catalog.DownloadRequest) (catalog.DownloadFuture, error)); ok { + return rf(ctx, requests...) + } + if rf, ok := ret.Get(0).(func(context.Context, ...catalog.DownloadRequest) catalog.DownloadFuture); ok { + r0 = rf(ctx, requests...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(catalog.DownloadFuture) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, ...catalog.DownloadRequest) error); ok { + r1 = rf(ctx, requests...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AsyncClient_Download_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Download' +type AsyncClient_Download_Call struct { + *mock.Call +} + +// Download is a helper method to define mock.On call +// - ctx context.Context +// - requests ...catalog.DownloadRequest +func (_e *AsyncClient_Expecter) Download(ctx interface{}, requests ...interface{}) *AsyncClient_Download_Call { + return &AsyncClient_Download_Call{Call: _e.mock.On("Download", + append([]interface{}{ctx}, requests...)...)} +} + +func (_c *AsyncClient_Download_Call) Run(run func(ctx context.Context, requests ...catalog.DownloadRequest)) *AsyncClient_Download_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]catalog.DownloadRequest, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(catalog.DownloadRequest) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *AsyncClient_Download_Call) Return(outputFuture catalog.DownloadFuture, err error) *AsyncClient_Download_Call { + _c.Call.Return(outputFuture, err) + return _c +} + +func (_c *AsyncClient_Download_Call) RunAndReturn(run func(context.Context, ...catalog.DownloadRequest) (catalog.DownloadFuture, error)) *AsyncClient_Download_Call { + _c.Call.Return(run) + return _c +} + +// Upload provides a mock function with given fields: ctx, requests +func (_m *AsyncClient) Upload(ctx context.Context, requests ...catalog.UploadRequest) (catalog.UploadFuture, error) { + _va := make([]interface{}, len(requests)) + for _i := range requests { + _va[_i] = requests[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Upload") + } + + var r0 catalog.UploadFuture + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, ...catalog.UploadRequest) (catalog.UploadFuture, error)); ok { + return rf(ctx, requests...) + } + if rf, ok := ret.Get(0).(func(context.Context, ...catalog.UploadRequest) catalog.UploadFuture); ok { + r0 = rf(ctx, requests...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(catalog.UploadFuture) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, ...catalog.UploadRequest) error); ok { + r1 = rf(ctx, requests...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AsyncClient_Upload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Upload' +type AsyncClient_Upload_Call struct { + *mock.Call +} + +// Upload is a helper method to define mock.On call +// - ctx context.Context +// - requests ...catalog.UploadRequest +func (_e *AsyncClient_Expecter) Upload(ctx interface{}, requests ...interface{}) *AsyncClient_Upload_Call { + return &AsyncClient_Upload_Call{Call: _e.mock.On("Upload", + append([]interface{}{ctx}, requests...)...)} +} + +func (_c *AsyncClient_Upload_Call) Run(run func(ctx context.Context, requests ...catalog.UploadRequest)) *AsyncClient_Upload_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]catalog.UploadRequest, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(catalog.UploadRequest) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *AsyncClient_Upload_Call) Return(putFuture catalog.UploadFuture, err error) *AsyncClient_Upload_Call { + _c.Call.Return(putFuture, err) + return _c +} + +func (_c *AsyncClient_Upload_Call) RunAndReturn(run func(context.Context, ...catalog.UploadRequest) (catalog.UploadFuture, error)) *AsyncClient_Upload_Call { + _c.Call.Return(run) + return _c +} + +// NewAsyncClient creates a new instance of AsyncClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAsyncClient(t interface { + mock.TestingT + Cleanup(func()) +}) *AsyncClient { + mock := &AsyncClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/client.go b/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/client.go new file mode 100644 index 0000000000..61b77dde64 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/client.go @@ -0,0 +1,407 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + catalog "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/catalog" + cacheservice "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/cacheservice" + + context "context" + + io "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + + mock "github.com/stretchr/testify/mock" + + time "time" +) + +// Client is an autogenerated mock type for the Client type +type Client struct { + mock.Mock +} + +type Client_Expecter struct { + mock *mock.Mock +} + +func (_m *Client) EXPECT() *Client_Expecter { + return &Client_Expecter{mock: &_m.Mock} +} + +// Get provides a mock function with given fields: ctx, key +func (_m *Client) Get(ctx context.Context, key catalog.Key) (catalog.Entry, error) { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 catalog.Entry + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, catalog.Key) (catalog.Entry, error)); ok { + return rf(ctx, key) + } + if rf, ok := ret.Get(0).(func(context.Context, catalog.Key) catalog.Entry); ok { + r0 = rf(ctx, key) + } else { + r0 = ret.Get(0).(catalog.Entry) + } + + if rf, ok := ret.Get(1).(func(context.Context, catalog.Key) error); ok { + r1 = rf(ctx, key) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Client_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type Client_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - key catalog.Key +func (_e *Client_Expecter) Get(ctx interface{}, key interface{}) *Client_Get_Call { + return &Client_Get_Call{Call: _e.mock.On("Get", ctx, key)} +} + +func (_c *Client_Get_Call) Run(run func(ctx context.Context, key catalog.Key)) *Client_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(catalog.Key)) + }) + return _c +} + +func (_c *Client_Get_Call) Return(_a0 catalog.Entry, _a1 error) *Client_Get_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Get_Call) RunAndReturn(run func(context.Context, catalog.Key) (catalog.Entry, error)) *Client_Get_Call { + _c.Call.Return(run) + return _c +} + +// GetOrExtendReservation provides a mock function with given fields: ctx, key, ownerID, heartbeatInterval +func (_m *Client) GetOrExtendReservation(ctx context.Context, key catalog.Key, ownerID string, heartbeatInterval time.Duration) (*cacheservice.Reservation, error) { + ret := _m.Called(ctx, key, ownerID, heartbeatInterval) + + if len(ret) == 0 { + panic("no return value specified for GetOrExtendReservation") + } + + var r0 *cacheservice.Reservation + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, catalog.Key, string, time.Duration) (*cacheservice.Reservation, error)); ok { + return rf(ctx, key, ownerID, heartbeatInterval) + } + if rf, ok := ret.Get(0).(func(context.Context, catalog.Key, string, time.Duration) *cacheservice.Reservation); ok { + r0 = rf(ctx, key, ownerID, heartbeatInterval) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cacheservice.Reservation) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, catalog.Key, string, time.Duration) error); ok { + r1 = rf(ctx, key, ownerID, heartbeatInterval) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Client_GetOrExtendReservation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrExtendReservation' +type Client_GetOrExtendReservation_Call struct { + *mock.Call +} + +// GetOrExtendReservation is a helper method to define mock.On call +// - ctx context.Context +// - key catalog.Key +// - ownerID string +// - heartbeatInterval time.Duration +func (_e *Client_Expecter) GetOrExtendReservation(ctx interface{}, key interface{}, ownerID interface{}, heartbeatInterval interface{}) *Client_GetOrExtendReservation_Call { + return &Client_GetOrExtendReservation_Call{Call: _e.mock.On("GetOrExtendReservation", ctx, key, ownerID, heartbeatInterval)} +} + +func (_c *Client_GetOrExtendReservation_Call) Run(run func(ctx context.Context, key catalog.Key, ownerID string, heartbeatInterval time.Duration)) *Client_GetOrExtendReservation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(catalog.Key), args[2].(string), args[3].(time.Duration)) + }) + return _c +} + +func (_c *Client_GetOrExtendReservation_Call) Return(_a0 *cacheservice.Reservation, _a1 error) *Client_GetOrExtendReservation_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_GetOrExtendReservation_Call) RunAndReturn(run func(context.Context, catalog.Key, string, time.Duration) (*cacheservice.Reservation, error)) *Client_GetOrExtendReservation_Call { + _c.Call.Return(run) + return _c +} + +// GetReservationCache provides a mock function with given fields: ownerID +func (_m *Client) GetReservationCache(ownerID string) catalog.ReservationCache { + ret := _m.Called(ownerID) + + if len(ret) == 0 { + panic("no return value specified for GetReservationCache") + } + + var r0 catalog.ReservationCache + if rf, ok := ret.Get(0).(func(string) catalog.ReservationCache); ok { + r0 = rf(ownerID) + } else { + r0 = ret.Get(0).(catalog.ReservationCache) + } + + return r0 +} + +// Client_GetReservationCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReservationCache' +type Client_GetReservationCache_Call struct { + *mock.Call +} + +// GetReservationCache is a helper method to define mock.On call +// - ownerID string +func (_e *Client_Expecter) GetReservationCache(ownerID interface{}) *Client_GetReservationCache_Call { + return &Client_GetReservationCache_Call{Call: _e.mock.On("GetReservationCache", ownerID)} +} + +func (_c *Client_GetReservationCache_Call) Run(run func(ownerID string)) *Client_GetReservationCache_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Client_GetReservationCache_Call) Return(_a0 catalog.ReservationCache) *Client_GetReservationCache_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Client_GetReservationCache_Call) RunAndReturn(run func(string) catalog.ReservationCache) *Client_GetReservationCache_Call { + _c.Call.Return(run) + return _c +} + +// Put provides a mock function with given fields: ctx, key, reader, metadata +func (_m *Client) Put(ctx context.Context, key catalog.Key, reader io.OutputReader, metadata catalog.Metadata) (catalog.Status, error) { + ret := _m.Called(ctx, key, reader, metadata) + + if len(ret) == 0 { + panic("no return value specified for Put") + } + + var r0 catalog.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, catalog.Key, io.OutputReader, catalog.Metadata) (catalog.Status, error)); ok { + return rf(ctx, key, reader, metadata) + } + if rf, ok := ret.Get(0).(func(context.Context, catalog.Key, io.OutputReader, catalog.Metadata) catalog.Status); ok { + r0 = rf(ctx, key, reader, metadata) + } else { + r0 = ret.Get(0).(catalog.Status) + } + + if rf, ok := ret.Get(1).(func(context.Context, catalog.Key, io.OutputReader, catalog.Metadata) error); ok { + r1 = rf(ctx, key, reader, metadata) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Client_Put_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Put' +type Client_Put_Call struct { + *mock.Call +} + +// Put is a helper method to define mock.On call +// - ctx context.Context +// - key catalog.Key +// - reader io.OutputReader +// - metadata catalog.Metadata +func (_e *Client_Expecter) Put(ctx interface{}, key interface{}, reader interface{}, metadata interface{}) *Client_Put_Call { + return &Client_Put_Call{Call: _e.mock.On("Put", ctx, key, reader, metadata)} +} + +func (_c *Client_Put_Call) Run(run func(ctx context.Context, key catalog.Key, reader io.OutputReader, metadata catalog.Metadata)) *Client_Put_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(catalog.Key), args[2].(io.OutputReader), args[3].(catalog.Metadata)) + }) + return _c +} + +func (_c *Client_Put_Call) Return(_a0 catalog.Status, _a1 error) *Client_Put_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Put_Call) RunAndReturn(run func(context.Context, catalog.Key, io.OutputReader, catalog.Metadata) (catalog.Status, error)) *Client_Put_Call { + _c.Call.Return(run) + return _c +} + +// ReleaseReservation provides a mock function with given fields: ctx, key, ownerID +func (_m *Client) ReleaseReservation(ctx context.Context, key catalog.Key, ownerID string) error { + ret := _m.Called(ctx, key, ownerID) + + if len(ret) == 0 { + panic("no return value specified for ReleaseReservation") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, catalog.Key, string) error); ok { + r0 = rf(ctx, key, ownerID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Client_ReleaseReservation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReleaseReservation' +type Client_ReleaseReservation_Call struct { + *mock.Call +} + +// ReleaseReservation is a helper method to define mock.On call +// - ctx context.Context +// - key catalog.Key +// - ownerID string +func (_e *Client_Expecter) ReleaseReservation(ctx interface{}, key interface{}, ownerID interface{}) *Client_ReleaseReservation_Call { + return &Client_ReleaseReservation_Call{Call: _e.mock.On("ReleaseReservation", ctx, key, ownerID)} +} + +func (_c *Client_ReleaseReservation_Call) Run(run func(ctx context.Context, key catalog.Key, ownerID string)) *Client_ReleaseReservation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(catalog.Key), args[2].(string)) + }) + return _c +} + +func (_c *Client_ReleaseReservation_Call) Return(_a0 error) *Client_ReleaseReservation_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Client_ReleaseReservation_Call) RunAndReturn(run func(context.Context, catalog.Key, string) error) *Client_ReleaseReservation_Call { + _c.Call.Return(run) + return _c +} + +// Update provides a mock function with given fields: ctx, key, reader, metadata +func (_m *Client) Update(ctx context.Context, key catalog.Key, reader io.OutputReader, metadata catalog.Metadata) (catalog.Status, error) { + ret := _m.Called(ctx, key, reader, metadata) + + if len(ret) == 0 { + panic("no return value specified for Update") + } + + var r0 catalog.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, catalog.Key, io.OutputReader, catalog.Metadata) (catalog.Status, error)); ok { + return rf(ctx, key, reader, metadata) + } + if rf, ok := ret.Get(0).(func(context.Context, catalog.Key, io.OutputReader, catalog.Metadata) catalog.Status); ok { + r0 = rf(ctx, key, reader, metadata) + } else { + r0 = ret.Get(0).(catalog.Status) + } + + if rf, ok := ret.Get(1).(func(context.Context, catalog.Key, io.OutputReader, catalog.Metadata) error); ok { + r1 = rf(ctx, key, reader, metadata) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Client_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update' +type Client_Update_Call struct { + *mock.Call +} + +// Update is a helper method to define mock.On call +// - ctx context.Context +// - key catalog.Key +// - reader io.OutputReader +// - metadata catalog.Metadata +func (_e *Client_Expecter) Update(ctx interface{}, key interface{}, reader interface{}, metadata interface{}) *Client_Update_Call { + return &Client_Update_Call{Call: _e.mock.On("Update", ctx, key, reader, metadata)} +} + +func (_c *Client_Update_Call) Run(run func(ctx context.Context, key catalog.Key, reader io.OutputReader, metadata catalog.Metadata)) *Client_Update_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(catalog.Key), args[2].(io.OutputReader), args[3].(catalog.Metadata)) + }) + return _c +} + +func (_c *Client_Update_Call) Return(_a0 catalog.Status, _a1 error) *Client_Update_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Client_Update_Call) RunAndReturn(run func(context.Context, catalog.Key, io.OutputReader, catalog.Metadata) (catalog.Status, error)) *Client_Update_Call { + _c.Call.Return(run) + return _c +} + +// UpdateReservationCache provides a mock function with given fields: ownerID, entry +func (_m *Client) UpdateReservationCache(ownerID string, entry catalog.ReservationCache) { + _m.Called(ownerID, entry) +} + +// Client_UpdateReservationCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateReservationCache' +type Client_UpdateReservationCache_Call struct { + *mock.Call +} + +// UpdateReservationCache is a helper method to define mock.On call +// - ownerID string +// - entry catalog.ReservationCache +func (_e *Client_Expecter) UpdateReservationCache(ownerID interface{}, entry interface{}) *Client_UpdateReservationCache_Call { + return &Client_UpdateReservationCache_Call{Call: _e.mock.On("UpdateReservationCache", ownerID, entry)} +} + +func (_c *Client_UpdateReservationCache_Call) Run(run func(ownerID string, entry catalog.ReservationCache)) *Client_UpdateReservationCache_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(catalog.ReservationCache)) + }) + return _c +} + +func (_c *Client_UpdateReservationCache_Call) Return() *Client_UpdateReservationCache_Call { + _c.Call.Return() + return _c +} + +func (_c *Client_UpdateReservationCache_Call) RunAndReturn(run func(string, catalog.ReservationCache)) *Client_UpdateReservationCache_Call { + _c.Run(run) + return _c +} + +// NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewClient(t interface { + mock.TestingT + Cleanup(func()) +}) *Client { + mock := &Client{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/download_future.go b/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/download_future.go new file mode 100644 index 0000000000..178b496f30 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/download_future.go @@ -0,0 +1,215 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + catalog "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/catalog" + mock "github.com/stretchr/testify/mock" +) + +// DownloadFuture is an autogenerated mock type for the DownloadFuture type +type DownloadFuture struct { + mock.Mock +} + +type DownloadFuture_Expecter struct { + mock *mock.Mock +} + +func (_m *DownloadFuture) EXPECT() *DownloadFuture_Expecter { + return &DownloadFuture_Expecter{mock: &_m.Mock} +} + +// GetResponse provides a mock function with no fields +func (_m *DownloadFuture) GetResponse() (catalog.DownloadResponse, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetResponse") + } + + var r0 catalog.DownloadResponse + var r1 error + if rf, ok := ret.Get(0).(func() (catalog.DownloadResponse, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() catalog.DownloadResponse); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(catalog.DownloadResponse) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// DownloadFuture_GetResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResponse' +type DownloadFuture_GetResponse_Call struct { + *mock.Call +} + +// GetResponse is a helper method to define mock.On call +func (_e *DownloadFuture_Expecter) GetResponse() *DownloadFuture_GetResponse_Call { + return &DownloadFuture_GetResponse_Call{Call: _e.mock.On("GetResponse")} +} + +func (_c *DownloadFuture_GetResponse_Call) Run(run func()) *DownloadFuture_GetResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *DownloadFuture_GetResponse_Call) Return(_a0 catalog.DownloadResponse, _a1 error) *DownloadFuture_GetResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *DownloadFuture_GetResponse_Call) RunAndReturn(run func() (catalog.DownloadResponse, error)) *DownloadFuture_GetResponse_Call { + _c.Call.Return(run) + return _c +} + +// GetResponseError provides a mock function with no fields +func (_m *DownloadFuture) GetResponseError() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetResponseError") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// DownloadFuture_GetResponseError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResponseError' +type DownloadFuture_GetResponseError_Call struct { + *mock.Call +} + +// GetResponseError is a helper method to define mock.On call +func (_e *DownloadFuture_Expecter) GetResponseError() *DownloadFuture_GetResponseError_Call { + return &DownloadFuture_GetResponseError_Call{Call: _e.mock.On("GetResponseError")} +} + +func (_c *DownloadFuture_GetResponseError_Call) Run(run func()) *DownloadFuture_GetResponseError_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *DownloadFuture_GetResponseError_Call) Return(_a0 error) *DownloadFuture_GetResponseError_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DownloadFuture_GetResponseError_Call) RunAndReturn(run func() error) *DownloadFuture_GetResponseError_Call { + _c.Call.Return(run) + return _c +} + +// GetResponseStatus provides a mock function with no fields +func (_m *DownloadFuture) GetResponseStatus() catalog.ResponseStatus { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetResponseStatus") + } + + var r0 catalog.ResponseStatus + if rf, ok := ret.Get(0).(func() catalog.ResponseStatus); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(catalog.ResponseStatus) + } + + return r0 +} + +// DownloadFuture_GetResponseStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResponseStatus' +type DownloadFuture_GetResponseStatus_Call struct { + *mock.Call +} + +// GetResponseStatus is a helper method to define mock.On call +func (_e *DownloadFuture_Expecter) GetResponseStatus() *DownloadFuture_GetResponseStatus_Call { + return &DownloadFuture_GetResponseStatus_Call{Call: _e.mock.On("GetResponseStatus")} +} + +func (_c *DownloadFuture_GetResponseStatus_Call) Run(run func()) *DownloadFuture_GetResponseStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *DownloadFuture_GetResponseStatus_Call) Return(_a0 catalog.ResponseStatus) *DownloadFuture_GetResponseStatus_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DownloadFuture_GetResponseStatus_Call) RunAndReturn(run func() catalog.ResponseStatus) *DownloadFuture_GetResponseStatus_Call { + _c.Call.Return(run) + return _c +} + +// OnReady provides a mock function with given fields: handler +func (_m *DownloadFuture) OnReady(handler catalog.ReadyHandler) { + _m.Called(handler) +} + +// DownloadFuture_OnReady_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnReady' +type DownloadFuture_OnReady_Call struct { + *mock.Call +} + +// OnReady is a helper method to define mock.On call +// - handler catalog.ReadyHandler +func (_e *DownloadFuture_Expecter) OnReady(handler interface{}) *DownloadFuture_OnReady_Call { + return &DownloadFuture_OnReady_Call{Call: _e.mock.On("OnReady", handler)} +} + +func (_c *DownloadFuture_OnReady_Call) Run(run func(handler catalog.ReadyHandler)) *DownloadFuture_OnReady_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(catalog.ReadyHandler)) + }) + return _c +} + +func (_c *DownloadFuture_OnReady_Call) Return() *DownloadFuture_OnReady_Call { + _c.Call.Return() + return _c +} + +func (_c *DownloadFuture_OnReady_Call) RunAndReturn(run func(catalog.ReadyHandler)) *DownloadFuture_OnReady_Call { + _c.Run(run) + return _c +} + +// NewDownloadFuture creates a new instance of DownloadFuture. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewDownloadFuture(t interface { + mock.TestingT + Cleanup(func()) +}) *DownloadFuture { + mock := &DownloadFuture{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/download_response.go b/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/download_response.go new file mode 100644 index 0000000000..268b1be275 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/download_response.go @@ -0,0 +1,173 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + bitarray "github.com/flyteorg/flyte/v2/flytestdlib/bitarray" + + mock "github.com/stretchr/testify/mock" +) + +// DownloadResponse is an autogenerated mock type for the DownloadResponse type +type DownloadResponse struct { + mock.Mock +} + +type DownloadResponse_Expecter struct { + mock *mock.Mock +} + +func (_m *DownloadResponse) EXPECT() *DownloadResponse_Expecter { + return &DownloadResponse_Expecter{mock: &_m.Mock} +} + +// GetCachedCount provides a mock function with no fields +func (_m *DownloadResponse) GetCachedCount() int { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetCachedCount") + } + + var r0 int + if rf, ok := ret.Get(0).(func() int); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int) + } + + return r0 +} + +// DownloadResponse_GetCachedCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCachedCount' +type DownloadResponse_GetCachedCount_Call struct { + *mock.Call +} + +// GetCachedCount is a helper method to define mock.On call +func (_e *DownloadResponse_Expecter) GetCachedCount() *DownloadResponse_GetCachedCount_Call { + return &DownloadResponse_GetCachedCount_Call{Call: _e.mock.On("GetCachedCount")} +} + +func (_c *DownloadResponse_GetCachedCount_Call) Run(run func()) *DownloadResponse_GetCachedCount_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *DownloadResponse_GetCachedCount_Call) Return(_a0 int) *DownloadResponse_GetCachedCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DownloadResponse_GetCachedCount_Call) RunAndReturn(run func() int) *DownloadResponse_GetCachedCount_Call { + _c.Call.Return(run) + return _c +} + +// GetCachedResults provides a mock function with no fields +func (_m *DownloadResponse) GetCachedResults() *bitarray.BitSet { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetCachedResults") + } + + var r0 *bitarray.BitSet + if rf, ok := ret.Get(0).(func() *bitarray.BitSet); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*bitarray.BitSet) + } + } + + return r0 +} + +// DownloadResponse_GetCachedResults_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCachedResults' +type DownloadResponse_GetCachedResults_Call struct { + *mock.Call +} + +// GetCachedResults is a helper method to define mock.On call +func (_e *DownloadResponse_Expecter) GetCachedResults() *DownloadResponse_GetCachedResults_Call { + return &DownloadResponse_GetCachedResults_Call{Call: _e.mock.On("GetCachedResults")} +} + +func (_c *DownloadResponse_GetCachedResults_Call) Run(run func()) *DownloadResponse_GetCachedResults_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *DownloadResponse_GetCachedResults_Call) Return(_a0 *bitarray.BitSet) *DownloadResponse_GetCachedResults_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DownloadResponse_GetCachedResults_Call) RunAndReturn(run func() *bitarray.BitSet) *DownloadResponse_GetCachedResults_Call { + _c.Call.Return(run) + return _c +} + +// GetResultsSize provides a mock function with no fields +func (_m *DownloadResponse) GetResultsSize() int { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetResultsSize") + } + + var r0 int + if rf, ok := ret.Get(0).(func() int); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int) + } + + return r0 +} + +// DownloadResponse_GetResultsSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResultsSize' +type DownloadResponse_GetResultsSize_Call struct { + *mock.Call +} + +// GetResultsSize is a helper method to define mock.On call +func (_e *DownloadResponse_Expecter) GetResultsSize() *DownloadResponse_GetResultsSize_Call { + return &DownloadResponse_GetResultsSize_Call{Call: _e.mock.On("GetResultsSize")} +} + +func (_c *DownloadResponse_GetResultsSize_Call) Run(run func()) *DownloadResponse_GetResultsSize_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *DownloadResponse_GetResultsSize_Call) Return(_a0 int) *DownloadResponse_GetResultsSize_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DownloadResponse_GetResultsSize_Call) RunAndReturn(run func() int) *DownloadResponse_GetResultsSize_Call { + _c.Call.Return(run) + return _c +} + +// NewDownloadResponse creates a new instance of DownloadResponse. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewDownloadResponse(t interface { + mock.TestingT + Cleanup(func()) +}) *DownloadResponse { + mock := &DownloadResponse{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/future.go b/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/future.go new file mode 100644 index 0000000000..920a13ef98 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/future.go @@ -0,0 +1,158 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + catalog "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/catalog" + mock "github.com/stretchr/testify/mock" +) + +// Future is an autogenerated mock type for the Future type +type Future struct { + mock.Mock +} + +type Future_Expecter struct { + mock *mock.Mock +} + +func (_m *Future) EXPECT() *Future_Expecter { + return &Future_Expecter{mock: &_m.Mock} +} + +// GetResponseError provides a mock function with no fields +func (_m *Future) GetResponseError() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetResponseError") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Future_GetResponseError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResponseError' +type Future_GetResponseError_Call struct { + *mock.Call +} + +// GetResponseError is a helper method to define mock.On call +func (_e *Future_Expecter) GetResponseError() *Future_GetResponseError_Call { + return &Future_GetResponseError_Call{Call: _e.mock.On("GetResponseError")} +} + +func (_c *Future_GetResponseError_Call) Run(run func()) *Future_GetResponseError_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Future_GetResponseError_Call) Return(_a0 error) *Future_GetResponseError_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Future_GetResponseError_Call) RunAndReturn(run func() error) *Future_GetResponseError_Call { + _c.Call.Return(run) + return _c +} + +// GetResponseStatus provides a mock function with no fields +func (_m *Future) GetResponseStatus() catalog.ResponseStatus { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetResponseStatus") + } + + var r0 catalog.ResponseStatus + if rf, ok := ret.Get(0).(func() catalog.ResponseStatus); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(catalog.ResponseStatus) + } + + return r0 +} + +// Future_GetResponseStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResponseStatus' +type Future_GetResponseStatus_Call struct { + *mock.Call +} + +// GetResponseStatus is a helper method to define mock.On call +func (_e *Future_Expecter) GetResponseStatus() *Future_GetResponseStatus_Call { + return &Future_GetResponseStatus_Call{Call: _e.mock.On("GetResponseStatus")} +} + +func (_c *Future_GetResponseStatus_Call) Run(run func()) *Future_GetResponseStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Future_GetResponseStatus_Call) Return(_a0 catalog.ResponseStatus) *Future_GetResponseStatus_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Future_GetResponseStatus_Call) RunAndReturn(run func() catalog.ResponseStatus) *Future_GetResponseStatus_Call { + _c.Call.Return(run) + return _c +} + +// OnReady provides a mock function with given fields: handler +func (_m *Future) OnReady(handler catalog.ReadyHandler) { + _m.Called(handler) +} + +// Future_OnReady_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnReady' +type Future_OnReady_Call struct { + *mock.Call +} + +// OnReady is a helper method to define mock.On call +// - handler catalog.ReadyHandler +func (_e *Future_Expecter) OnReady(handler interface{}) *Future_OnReady_Call { + return &Future_OnReady_Call{Call: _e.mock.On("OnReady", handler)} +} + +func (_c *Future_OnReady_Call) Run(run func(handler catalog.ReadyHandler)) *Future_OnReady_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(catalog.ReadyHandler)) + }) + return _c +} + +func (_c *Future_OnReady_Call) Return() *Future_OnReady_Call { + _c.Call.Return() + return _c +} + +func (_c *Future_OnReady_Call) RunAndReturn(run func(catalog.ReadyHandler)) *Future_OnReady_Call { + _c.Run(run) + return _c +} + +// NewFuture creates a new instance of Future. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewFuture(t interface { + mock.TestingT + Cleanup(func()) +}) *Future { + mock := &Future{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/ready_handler.go b/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/ready_handler.go new file mode 100644 index 0000000000..7faae67c29 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/ready_handler.go @@ -0,0 +1,72 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + catalog "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/catalog" + + mock "github.com/stretchr/testify/mock" +) + +// ReadyHandler is an autogenerated mock type for the ReadyHandler type +type ReadyHandler struct { + mock.Mock +} + +type ReadyHandler_Expecter struct { + mock *mock.Mock +} + +func (_m *ReadyHandler) EXPECT() *ReadyHandler_Expecter { + return &ReadyHandler_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: ctx, future +func (_m *ReadyHandler) Execute(ctx context.Context, future catalog.Future) { + _m.Called(ctx, future) +} + +// ReadyHandler_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type ReadyHandler_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - ctx context.Context +// - future catalog.Future +func (_e *ReadyHandler_Expecter) Execute(ctx interface{}, future interface{}) *ReadyHandler_Execute_Call { + return &ReadyHandler_Execute_Call{Call: _e.mock.On("Execute", ctx, future)} +} + +func (_c *ReadyHandler_Execute_Call) Run(run func(ctx context.Context, future catalog.Future)) *ReadyHandler_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(catalog.Future)) + }) + return _c +} + +func (_c *ReadyHandler_Execute_Call) Return() *ReadyHandler_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *ReadyHandler_Execute_Call) RunAndReturn(run func(context.Context, catalog.Future)) *ReadyHandler_Execute_Call { + _c.Run(run) + return _c +} + +// NewReadyHandler creates a new instance of ReadyHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewReadyHandler(t interface { + mock.TestingT + Cleanup(func()) +}) *ReadyHandler { + mock := &ReadyHandler{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/upload_future.go b/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/upload_future.go new file mode 100644 index 0000000000..3bd0ca70c9 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/mocks/upload_future.go @@ -0,0 +1,158 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + catalog "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/catalog" + mock "github.com/stretchr/testify/mock" +) + +// UploadFuture is an autogenerated mock type for the UploadFuture type +type UploadFuture struct { + mock.Mock +} + +type UploadFuture_Expecter struct { + mock *mock.Mock +} + +func (_m *UploadFuture) EXPECT() *UploadFuture_Expecter { + return &UploadFuture_Expecter{mock: &_m.Mock} +} + +// GetResponseError provides a mock function with no fields +func (_m *UploadFuture) GetResponseError() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetResponseError") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// UploadFuture_GetResponseError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResponseError' +type UploadFuture_GetResponseError_Call struct { + *mock.Call +} + +// GetResponseError is a helper method to define mock.On call +func (_e *UploadFuture_Expecter) GetResponseError() *UploadFuture_GetResponseError_Call { + return &UploadFuture_GetResponseError_Call{Call: _e.mock.On("GetResponseError")} +} + +func (_c *UploadFuture_GetResponseError_Call) Run(run func()) *UploadFuture_GetResponseError_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UploadFuture_GetResponseError_Call) Return(_a0 error) *UploadFuture_GetResponseError_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UploadFuture_GetResponseError_Call) RunAndReturn(run func() error) *UploadFuture_GetResponseError_Call { + _c.Call.Return(run) + return _c +} + +// GetResponseStatus provides a mock function with no fields +func (_m *UploadFuture) GetResponseStatus() catalog.ResponseStatus { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetResponseStatus") + } + + var r0 catalog.ResponseStatus + if rf, ok := ret.Get(0).(func() catalog.ResponseStatus); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(catalog.ResponseStatus) + } + + return r0 +} + +// UploadFuture_GetResponseStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResponseStatus' +type UploadFuture_GetResponseStatus_Call struct { + *mock.Call +} + +// GetResponseStatus is a helper method to define mock.On call +func (_e *UploadFuture_Expecter) GetResponseStatus() *UploadFuture_GetResponseStatus_Call { + return &UploadFuture_GetResponseStatus_Call{Call: _e.mock.On("GetResponseStatus")} +} + +func (_c *UploadFuture_GetResponseStatus_Call) Run(run func()) *UploadFuture_GetResponseStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UploadFuture_GetResponseStatus_Call) Return(_a0 catalog.ResponseStatus) *UploadFuture_GetResponseStatus_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UploadFuture_GetResponseStatus_Call) RunAndReturn(run func() catalog.ResponseStatus) *UploadFuture_GetResponseStatus_Call { + _c.Call.Return(run) + return _c +} + +// OnReady provides a mock function with given fields: handler +func (_m *UploadFuture) OnReady(handler catalog.ReadyHandler) { + _m.Called(handler) +} + +// UploadFuture_OnReady_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnReady' +type UploadFuture_OnReady_Call struct { + *mock.Call +} + +// OnReady is a helper method to define mock.On call +// - handler catalog.ReadyHandler +func (_e *UploadFuture_Expecter) OnReady(handler interface{}) *UploadFuture_OnReady_Call { + return &UploadFuture_OnReady_Call{Call: _e.mock.On("OnReady", handler)} +} + +func (_c *UploadFuture_OnReady_Call) Run(run func(handler catalog.ReadyHandler)) *UploadFuture_OnReady_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(catalog.ReadyHandler)) + }) + return _c +} + +func (_c *UploadFuture_OnReady_Call) Return() *UploadFuture_OnReady_Call { + _c.Call.Return() + return _c +} + +func (_c *UploadFuture_OnReady_Call) RunAndReturn(run func(catalog.ReadyHandler)) *UploadFuture_OnReady_Call { + _c.Run(run) + return _c +} + +// NewUploadFuture creates a new instance of UploadFuture. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewUploadFuture(t interface { + mock.TestingT + Cleanup(func()) +}) *UploadFuture { + mock := &UploadFuture{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/reader_processor.go b/flyteplugins/go/tasks/pluginmachinery/catalog/reader_processor.go new file mode 100644 index 0000000000..df22f3ac25 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/reader_processor.go @@ -0,0 +1,87 @@ +package catalog + +import ( + "context" + "fmt" + "reflect" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/workqueue" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +type ReaderWorkItem struct { + // ReaderWorkItem outputs: + cached bool + + // ReaderWorkItem Inputs: + outputsWriter io.OutputWriter + // Inputs to query data catalog + key Key +} + +func (item ReaderWorkItem) IsCached() bool { + return item.cached +} + +func NewReaderWorkItem(key Key, outputsWriter io.OutputWriter) *ReaderWorkItem { + return &ReaderWorkItem{ + key: key, + outputsWriter: outputsWriter, + } +} + +type ReaderProcessor struct { + catalogClient Client +} + +func (p ReaderProcessor) Process(ctx context.Context, workItem workqueue.WorkItem) (workqueue.WorkStatus, error) { + wi, casted := workItem.(*ReaderWorkItem) + if !casted { + return workqueue.WorkStatusNotDone, fmt.Errorf("wrong work item type. Received: %v", reflect.TypeOf(workItem)) + } + + op, err := p.catalogClient.Get(ctx, wi.key) + if err != nil { + if IsNotFound(err) { + logger.Infof(ctx, "Artifact not found in Catalog. Key: %v", wi.key) + wi.cached = false + return workqueue.WorkStatusSucceeded, nil + } + + err = errors.Wrapf("CausedBy", err, "Failed to call catalog for Key: %v.", wi.key) + logger.Warnf(ctx, "Cache call failed: %v", err) + return workqueue.WorkStatusFailed, err + } + + if op.status.GetCacheStatus() == core.CatalogCacheStatus_CACHE_LOOKUP_FAILURE { + return workqueue.WorkStatusFailed, errors.Errorf(errors.DownstreamSystemError, "failed to lookup cache") + } + + if op.status.GetCacheStatus() == core.CatalogCacheStatus_CACHE_MISS || op.GetOutputs() == nil { + wi.cached = false + return workqueue.WorkStatusSucceeded, nil + } + + // TODO: Check task interface, if it has outputs but literalmap is empty (or not matching output), error. + logger.Debugf(ctx, "Persisting output to %v", wi.outputsWriter.GetOutputPath()) + err = wi.outputsWriter.Put(ctx, op.GetOutputs()) + if err != nil { + err = errors.Wrapf("CausedBy", err, "Failed to persist cached output for Key: %v.", wi.key) + logger.Warnf(ctx, "Cache write to output writer failed: %v", err) + return workqueue.WorkStatusFailed, err + } + + wi.cached = true + + logger.Debugf(ctx, "Successfully read from catalog. Key [%v]", wi.key) + return workqueue.WorkStatusSucceeded, nil +} + +func NewReaderProcessor(catalogClient Client) ReaderProcessor { + return ReaderProcessor{ + catalogClient: catalogClient, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/response.go b/flyteplugins/go/tasks/pluginmachinery/catalog/response.go new file mode 100644 index 0000000000..8ec56f8e7c --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/response.go @@ -0,0 +1,87 @@ +package catalog + +import ( + "github.com/flyteorg/flyte/v2/flytestdlib/bitarray" + "github.com/flyteorg/flyte/v2/flytestdlib/errors" +) + +type future struct { + responseStatus ResponseStatus + readyHandler ReadyHandler + err error +} + +func (f future) GetResponseStatus() ResponseStatus { + return f.responseStatus +} + +func (f future) GetResponseError() error { + return f.err +} + +func (f *future) SetResponseStatus(status ResponseStatus) { + f.responseStatus = status +} + +func (f *future) OnReady(handler ReadyHandler) { + f.readyHandler = handler +} + +type downloadFuture struct { + *future + + cachedResults *bitarray.BitSet + cachedCount int + resultsSize int +} + +func (r downloadFuture) GetResponse() (DownloadResponse, error) { + if r.GetResponseStatus() != ResponseStatusReady { + return nil, errors.Errorf(ErrResponseNotReady, "Response is not ready yet.") + } + + if r.GetResponseError() != nil { + return nil, errors.Wrapf(ErrSystemError, r.GetResponseError(), "ResponseError() is not nil.") + } + + return r, nil +} + +func (r downloadFuture) GetResultsSize() int { + return r.resultsSize +} + +func (r downloadFuture) GetCachedResults() *bitarray.BitSet { + return r.cachedResults +} + +func (r downloadFuture) GetCachedCount() int { + return r.cachedCount +} + +func newDownloadFuture(status ResponseStatus, err error, cachedResults *bitarray.BitSet, resultsSize int, + cachedCount int) downloadFuture { + + return downloadFuture{ + future: &future{ + responseStatus: status, + err: err, + }, + cachedCount: cachedCount, + cachedResults: cachedResults, + resultsSize: resultsSize, + } +} + +type uploadFuture struct { + *future +} + +func newUploadFuture(status ResponseStatus, err error) uploadFuture { + return uploadFuture{ + future: &future{ + responseStatus: status, + err: err, + }, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/catalog/writer_processor.go b/flyteplugins/go/tasks/pluginmachinery/catalog/writer_processor.go new file mode 100644 index 0000000000..e89c367558 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/catalog/writer_processor.go @@ -0,0 +1,62 @@ +package catalog + +import ( + "context" + "fmt" + "reflect" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/workqueue" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +type WriterWorkItem struct { + // WriterWorkItem Inputs + key Key + data io.OutputReader + metadata Metadata +} + +func NewWriterWorkItem(key Key, data io.OutputReader, metadata Metadata) *WriterWorkItem { + return &WriterWorkItem{ + key: key, + data: data, + metadata: metadata, + } +} + +type writerProcessor struct { + catalogClient Client +} + +func (p writerProcessor) Process(ctx context.Context, workItem workqueue.WorkItem) (workqueue.WorkStatus, error) { + wi, casted := workItem.(*WriterWorkItem) + if !casted { + return workqueue.WorkStatusNotDone, fmt.Errorf("wrong work item type. Received: %v", reflect.TypeOf(workItem)) + } + + status, err := p.catalogClient.Put(ctx, wi.key, wi.data, wi.metadata) + if err != nil { + logger.Errorf(ctx, "Error putting to catalog [%s]", err) + return workqueue.WorkStatusNotDone, errors.Wrapf(errors.DownstreamSystemError, err, + "Error writing to catalog, key id [%v] cache version [%v]", + wi.key.Identifier, wi.key.CacheVersion) + } + + if status.GetCacheStatus() == core.CatalogCacheStatus_CACHE_PUT_FAILURE { + return workqueue.WorkStatusNotDone, errors.Errorf(errors.DownstreamSystemError, + "Error writing to catalog, key id [%v] cache version [%v]", + wi.key.Identifier, wi.key.CacheVersion) + } + + logger.Debugf(ctx, "Successfully wrote to catalog. Key [%v]", wi.key) + return workqueue.WorkStatusSucceeded, nil +} + +func NewWriterProcessor(catalogClient Client) workqueue.Processor { + return writerProcessor{ + catalogClient: catalogClient, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/allocationstatus_enumer.go b/flyteplugins/go/tasks/pluginmachinery/core/allocationstatus_enumer.go new file mode 100644 index 0000000000..dbbb536ca8 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/allocationstatus_enumer.go @@ -0,0 +1,51 @@ +// Code generated by "enumer -type=AllocationStatus -trimprefix=AllocationStatus"; DO NOT EDIT. + +package core + +import ( + "fmt" +) + +const _AllocationStatusName = "AllocationUndefinedGrantedExhaustedNamespaceQuotaExceeded" + +var _AllocationStatusIndex = [...]uint8{0, 19, 26, 35, 57} + +func (i AllocationStatus) String() string { + if i < 0 || i >= AllocationStatus(len(_AllocationStatusIndex)-1) { + return fmt.Sprintf("AllocationStatus(%d)", i) + } + return _AllocationStatusName[_AllocationStatusIndex[i]:_AllocationStatusIndex[i+1]] +} + +var _AllocationStatusValues = []AllocationStatus{0, 1, 2, 3} + +var _AllocationStatusNameToValueMap = map[string]AllocationStatus{ + _AllocationStatusName[0:19]: 0, + _AllocationStatusName[19:26]: 1, + _AllocationStatusName[26:35]: 2, + _AllocationStatusName[35:57]: 3, +} + +// AllocationStatusString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func AllocationStatusString(s string) (AllocationStatus, error) { + if val, ok := _AllocationStatusNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to AllocationStatus values", s) +} + +// AllocationStatusValues returns all values of the enum +func AllocationStatusValues() []AllocationStatus { + return _AllocationStatusValues +} + +// IsAAllocationStatus returns "true" if the value is listed in the enum definition. "false" otherwise +func (i AllocationStatus) IsAAllocationStatus() bool { + for _, v := range _AllocationStatusValues { + if i == v { + return true + } + } + return false +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/exec_context.go b/flyteplugins/go/tasks/pluginmachinery/core/exec_context.go new file mode 100644 index 0000000000..1351191c54 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/exec_context.go @@ -0,0 +1,71 @@ +package core + +import ( + "context" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/catalog" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + + +// An interface to access a remote/sharable location that contains the serialized TaskTemplate +type TaskTemplatePath interface { + // Returns the path + Path(ctx context.Context) (storage.DataReference, error) +} + +// An interface to access the TaskInformation +type TaskReader interface { + TaskTemplatePath + // Returns the core TaskTemplate + Read(ctx context.Context) (*core.TaskTemplate, error) +} + +// An interface that is passed to every plugin invocation. It carries all meta and contextual information for the current +// task execution +type TaskExecutionContext interface { + // Returns a resource manager that can be used to create reservations for limited resources + ResourceManager() ResourceManager + + // Returns a secret manager that can retrieve configured secrets for this plugin + SecretManager() SecretManager + + // Returns a method that allows a plugin to indicate that the task has a new update and can be invoked again to check for updates + TaskRefreshIndicator() SignalAsync + + // Returns a handle to the currently configured storage backend that can be used to communicate with the tasks or write metadata + DataStore() *storage.DataStore + + // Returns a reader that retrieves previously stored plugin internal state. the state itself is immutable + PluginStateReader() PluginStateReader + + // Returns a TaskReader, to retrieve task details + TaskReader() TaskReader + + // Returns an input reader to retrieve input data + InputReader() io.InputReader + + // Returns a handle to the Task's execution metadata. + TaskExecutionMetadata() TaskExecutionMetadata + + // Provides an output sync of type io.OutputWriter + OutputWriter() io.OutputWriter + + // Get a handle to the PluginStateWriter. Any mutations to the plugins internal state can be persisted using this + // These mutation will be visible in the next round + PluginStateWriter() PluginStateWriter + + // Get a handle to catalog client + Catalog() catalog.AsyncClient +} + +// A simple fire-and-forget func +type SignalAsync func(ctx context.Context) + +// Task events recorder, which get stored in the Admin. If this is invoked multiple times, +// multiple events will be sent to Admin. It is not recommended that one uses this interface, a transition will trigger an auto event to admin +type EventsRecorder interface { + RecordRaw(ctx context.Context, ev PhaseInfo) error +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/exec_metadata.go b/flyteplugins/go/tasks/pluginmachinery/core/exec_metadata.go new file mode 100644 index 0000000000..1eb07c5f1b --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/exec_metadata.go @@ -0,0 +1,84 @@ +package core + +import ( + "fmt" + + v1 "k8s.io/api/core/v1" + v12 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +// TaskOverrides interface to expose any overrides that have been set for this task (like resource overrides etc) +type TaskOverrides interface { + GetResources() *v1.ResourceRequirements + GetExtendedResources() *core.ExtendedResources + GetContainerImage() string + GetConfigMap() *v1.ConfigMap + GetPodTemplate() *core.K8SPod + GetConfig() map[string]string +} + +type ConnectionWrapper struct { + Connection core.Connection + Source common.AttributesSource +} + +// ExternalResourceAttributes is a wrapper around ExternalResourceAttributes to expose the source of the attributes +type ExternalResourceAttributes struct { + Connections map[string]ConnectionWrapper +} + +func (e ExternalResourceAttributes) GetConnection(name string) (*core.Connection, common.AttributesSource, error) { + if connWrapper, ok := e.Connections[name]; ok { + return &connWrapper.Connection, connWrapper.Source, nil + } + return nil, common.AttributesSource_SOURCE_UNSPECIFIED, fmt.Errorf("connection [%s] not found", name) +} + +func (e ExternalResourceAttributes) GetConnections() map[string]ConnectionWrapper { + return e.Connections +} + +// TaskExecutionID is a simple Interface to expose the ExecutionID of the running Task +type TaskExecutionID interface { + // GetGeneratedName returns the computed/generated name for the task id + // deprecated: use GetGeneratedNameWithLength + GetGeneratedName() string + + // GetGeneratedNameWith returns the generated name within a bounded length. If the name is smaller than minLength, + // it'll get right-padded with character '0'. If the name is bigger than maxLength, it'll get hashed to fit within. + GetGeneratedNameWith(minLength, maxLength int) (string, error) + + // GetID returns the underlying idl task identifier. + GetID() core.TaskExecutionIdentifier + + // GetUniqueNodeID returns the fully-qualified Node ID that is unique within a + // given workflow execution. + GetUniqueNodeID() string +} + +// TaskExecutionMetadata represents any execution information for a Task. It is used to communicate meta information about the +// execution or any previously stored information +type TaskExecutionMetadata interface { + // GetOwnerID returns the owning Kubernetes object + GetOwnerID() types.NamespacedName + // GetTaskExecutionID is a specially generated task execution id, that is guaranteed to be unique and consistent for subsequent calls + GetTaskExecutionID() TaskExecutionID + GetNamespace() string + GetOwnerReference() v12.OwnerReference + GetOverrides() TaskOverrides + GetLabels() map[string]string + GetMaxAttempts() uint32 + GetAnnotations() map[string]string + GetK8sServiceAccount() string + GetSecurityContext() core.SecurityContext + IsInterruptible() bool + GetPlatformResources() *v1.ResourceRequirements + GetInterruptibleFailureThreshold() int32 + GetEnvironmentVariables() map[string]string + GetExternalResourceAttributes() ExternalResourceAttributes + GetConsoleURL() string +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/kube_client.go b/flyteplugins/go/tasks/pluginmachinery/core/kube_client.go new file mode 100644 index 0000000000..54c8861129 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/kube_client.go @@ -0,0 +1,16 @@ +package core + +import ( + "sigs.k8s.io/controller-runtime/pkg/cache" + "sigs.k8s.io/controller-runtime/pkg/client" +) + +// TODO we may not want to expose this? +// A friendly controller-runtime client that gets passed to executors +type KubeClient interface { + // GetClient returns a client configured with the Config + GetClient() client.Client + + // GetCache returns a cache.Cache + GetCache() cache.Cache +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/enqueue_owner.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/enqueue_owner.go new file mode 100644 index 0000000000..0282b410e2 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/enqueue_owner.go @@ -0,0 +1,78 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// EnqueueOwner is an autogenerated mock type for the EnqueueOwner type +type EnqueueOwner struct { + mock.Mock +} + +type EnqueueOwner_Expecter struct { + mock *mock.Mock +} + +func (_m *EnqueueOwner) EXPECT() *EnqueueOwner_Expecter { + return &EnqueueOwner_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: labels +func (_m *EnqueueOwner) Execute(labels map[string]string) error { + ret := _m.Called(labels) + + if len(ret) == 0 { + panic("no return value specified for Execute") + } + + var r0 error + if rf, ok := ret.Get(0).(func(map[string]string) error); ok { + r0 = rf(labels) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// EnqueueOwner_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type EnqueueOwner_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - labels map[string]string +func (_e *EnqueueOwner_Expecter) Execute(labels interface{}) *EnqueueOwner_Execute_Call { + return &EnqueueOwner_Execute_Call{Call: _e.mock.On("Execute", labels)} +} + +func (_c *EnqueueOwner_Execute_Call) Run(run func(labels map[string]string)) *EnqueueOwner_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(map[string]string)) + }) + return _c +} + +func (_c *EnqueueOwner_Execute_Call) Return(_a0 error) *EnqueueOwner_Execute_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *EnqueueOwner_Execute_Call) RunAndReturn(run func(map[string]string) error) *EnqueueOwner_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewEnqueueOwner creates a new instance of EnqueueOwner. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewEnqueueOwner(t interface { + mock.TestingT + Cleanup(func()) +}) *EnqueueOwner { + mock := &EnqueueOwner{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/events_recorder.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/events_recorder.go new file mode 100644 index 0000000000..5958e95388 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/events_recorder.go @@ -0,0 +1,84 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + mock "github.com/stretchr/testify/mock" +) + +// EventsRecorder is an autogenerated mock type for the EventsRecorder type +type EventsRecorder struct { + mock.Mock +} + +type EventsRecorder_Expecter struct { + mock *mock.Mock +} + +func (_m *EventsRecorder) EXPECT() *EventsRecorder_Expecter { + return &EventsRecorder_Expecter{mock: &_m.Mock} +} + +// RecordRaw provides a mock function with given fields: ctx, ev +func (_m *EventsRecorder) RecordRaw(ctx context.Context, ev core.PhaseInfo) error { + ret := _m.Called(ctx, ev) + + if len(ret) == 0 { + panic("no return value specified for RecordRaw") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, core.PhaseInfo) error); ok { + r0 = rf(ctx, ev) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// EventsRecorder_RecordRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecordRaw' +type EventsRecorder_RecordRaw_Call struct { + *mock.Call +} + +// RecordRaw is a helper method to define mock.On call +// - ctx context.Context +// - ev core.PhaseInfo +func (_e *EventsRecorder_Expecter) RecordRaw(ctx interface{}, ev interface{}) *EventsRecorder_RecordRaw_Call { + return &EventsRecorder_RecordRaw_Call{Call: _e.mock.On("RecordRaw", ctx, ev)} +} + +func (_c *EventsRecorder_RecordRaw_Call) Run(run func(ctx context.Context, ev core.PhaseInfo)) *EventsRecorder_RecordRaw_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(core.PhaseInfo)) + }) + return _c +} + +func (_c *EventsRecorder_RecordRaw_Call) Return(_a0 error) *EventsRecorder_RecordRaw_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *EventsRecorder_RecordRaw_Call) RunAndReturn(run func(context.Context, core.PhaseInfo) error) *EventsRecorder_RecordRaw_Call { + _c.Call.Return(run) + return _c +} + +// NewEventsRecorder creates a new instance of EventsRecorder. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewEventsRecorder(t interface { + mock.TestingT + Cleanup(func()) +}) *EventsRecorder { + mock := &EventsRecorder{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/fake_k8s_cache.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/fake_k8s_cache.go new file mode 100644 index 0000000000..09e76b7949 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/fake_k8s_cache.go @@ -0,0 +1,176 @@ +package mocks + +import ( + "context" + "fmt" + "reflect" + "sync" + + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/api/meta" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/types" + "sigs.k8s.io/controller-runtime/pkg/cache" + "sigs.k8s.io/controller-runtime/pkg/client" +) + +type FakeKubeCache struct { + // Reader acts as a client to objects stored in the cache. + client.Reader + + // Informers loads informers and adds field indices. + cache.Informers + syncObj sync.RWMutex + Cache map[string]runtime.Object +} + +func (m *FakeKubeCache) GetInformer(ctx context.Context, obj client.Object, opts ...cache.InformerGetOption) (cache.Informer, error) { + panic("implement me") +} + +func (m *FakeKubeCache) GetInformerForKind(ctx context.Context, gvk schema.GroupVersionKind, opts ...cache.InformerGetOption) (cache.Informer, error) { + panic("implement me") +} + +func (m *FakeKubeCache) Start(ctx context.Context) error { + panic("implement me") +} + +func (m *FakeKubeCache) WaitForCacheSync(ctx context.Context) bool { + panic("implement me") +} + +func (m *FakeKubeCache) IndexField(ctx context.Context, obj client.Object, field string, extractValue client.IndexerFunc) error { + panic("implement me") +} + +func (m *FakeKubeCache) Get(ctx context.Context, key client.ObjectKey, out client.Object, opts ...client.GetOption) error { + m.syncObj.RLock() + defer m.syncObj.RUnlock() + + item, found := m.Cache[formatKey(key, out.GetObjectKind().GroupVersionKind())] + if found { + // deep copy to avoid mutating cache + item = item.DeepCopyObject() + _, isUnstructured := out.(*unstructured.Unstructured) + if isUnstructured { + // Copy the value of the item in the cache to the returned value + outVal := reflect.ValueOf(out) + objVal := reflect.ValueOf(item) + if !objVal.Type().AssignableTo(outVal.Type()) { + return fmt.Errorf("cache had type %s, but %s was asked for", objVal.Type(), outVal.Type()) + } + reflect.Indirect(outVal).Set(reflect.Indirect(objVal)) + return nil + } + + p, err := runtime.DefaultUnstructuredConverter.ToUnstructured(item) + if err != nil { + return err + } + + return runtime.DefaultUnstructuredConverter.FromUnstructured(p, out) + } + + return errors.NewNotFound(schema.GroupResource{}, key.Name) +} + +func (m *FakeKubeCache) List(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error { + m.syncObj.RLock() + defer m.syncObj.RUnlock() + + objs := make([]runtime.Object, 0, len(m.Cache)) + + listOptions := &client.ListOptions{} + for _, opt := range opts { + opt.ApplyToList(listOptions) + } + + for _, val := range m.Cache { + if listOptions.Raw != nil { + if val.GetObjectKind().GroupVersionKind().Kind != listOptions.Raw.Kind { + continue + } + + if val.GetObjectKind().GroupVersionKind().GroupVersion().String() != listOptions.Raw.APIVersion { + continue + } + } + + objs = append(objs, val.DeepCopyObject()) + } + + return meta.SetList(list, objs) +} + +func (m *FakeKubeCache) Create(ctx context.Context, obj client.Object, opts ...client.CreateOption) (err error) { + m.syncObj.Lock() + defer m.syncObj.Unlock() + + accessor, err := meta.Accessor(obj) + if err != nil { + return err + } + + key := formatKey(types.NamespacedName{ + Name: accessor.GetName(), + Namespace: accessor.GetNamespace(), + }, obj.GetObjectKind().GroupVersionKind()) + + if _, exists := m.Cache[key]; !exists { + m.Cache[key] = obj + return nil + } + + return errors.NewAlreadyExists(schema.GroupResource{}, accessor.GetName()) +} + +func (m *FakeKubeCache) Delete(ctx context.Context, obj client.Object, opts ...client.DeleteOption) error { + m.syncObj.Lock() + defer m.syncObj.Unlock() + + accessor, err := meta.Accessor(obj) + if err != nil { + return err + } + + key := formatKey(types.NamespacedName{ + Name: accessor.GetName(), + Namespace: accessor.GetNamespace(), + }, obj.GetObjectKind().GroupVersionKind()) + + delete(m.Cache, key) + + return nil +} + +func (m *FakeKubeCache) Update(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error { + m.syncObj.Lock() + defer m.syncObj.Unlock() + + accessor, err := meta.Accessor(obj) + if err != nil { + return err + } + + key := formatKey(types.NamespacedName{ + Name: accessor.GetName(), + Namespace: accessor.GetNamespace(), + }, obj.GetObjectKind().GroupVersionKind()) + + if _, exists := m.Cache[key]; exists { + m.Cache[key] = obj + return nil + } + + return errors.NewNotFound(schema.GroupResource{}, accessor.GetName()) +} + +func NewFakeKubeCache() *FakeKubeCache { + return &FakeKubeCache{ + syncObj: sync.RWMutex{}, + Cache: map[string]runtime.Object{}, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/fake_k8s_client.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/fake_k8s_client.go new file mode 100644 index 0000000000..e590ac04ee --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/fake_k8s_client.go @@ -0,0 +1,208 @@ +package mocks + +import ( + "context" + "fmt" + "reflect" + "sync" + + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/api/meta" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/types" + "sigs.k8s.io/controller-runtime/pkg/client" +) + +type FakeKubeClient struct { + client.Reader + client.Writer + client.StatusClient + client.SubResourceClientConstructor + syncObj sync.RWMutex + Cache map[string]runtime.Object +} + +func formatKey(name types.NamespacedName, kind schema.GroupVersionKind) string { + key := fmt.Sprintf("%v:%v", name.String(), kind.String()) + return key +} + +func (m *FakeKubeClient) Get(ctx context.Context, key client.ObjectKey, out client.Object, opts ...client.GetOption) error { + m.syncObj.RLock() + defer m.syncObj.RUnlock() + + item, found := m.Cache[formatKey(key, out.GetObjectKind().GroupVersionKind())] + if found { + // deep copy to avoid mutating cache + item = item.DeepCopyObject() + _, isUnstructured := out.(*unstructured.Unstructured) + if isUnstructured { + // Copy the value of the item in the cache to the returned value + outVal := reflect.ValueOf(out) + objVal := reflect.ValueOf(item) + if !objVal.Type().AssignableTo(outVal.Type()) { + return fmt.Errorf("cache had type %s, but %s was asked for", objVal.Type(), outVal.Type()) + } + reflect.Indirect(outVal).Set(reflect.Indirect(objVal)) + return nil + } + + p, err := runtime.DefaultUnstructuredConverter.ToUnstructured(item) + if err != nil { + return err + } + + return runtime.DefaultUnstructuredConverter.FromUnstructured(p, out) + } + + return errors.NewNotFound(schema.GroupResource{}, key.Name) +} + +// GroupVersionKindFor returns the GroupVersionKind for the given object. +func (m *FakeKubeClient) GroupVersionKindFor(obj runtime.Object) (schema.GroupVersionKind, error) { + panic("implement me") +} + +// IsObjectNamespaced returns true if the GroupVersionKind of the object is namespaced. +func (m *FakeKubeClient) IsObjectNamespaced(obj runtime.Object) (bool, error) { + panic("implement me") +} + +func (m *FakeKubeClient) List(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error { + m.syncObj.RLock() + defer m.syncObj.RUnlock() + + objs := make([]runtime.Object, 0, len(m.Cache)) + + listOptions := &client.ListOptions{} + for _, opt := range opts { + opt.ApplyToList(listOptions) + } + + for _, val := range m.Cache { + if listOptions.Raw != nil { + if val.GetObjectKind().GroupVersionKind().Kind != listOptions.Raw.Kind { + continue + } + + if val.GetObjectKind().GroupVersionKind().GroupVersion().String() != listOptions.Raw.APIVersion { + continue + } + } + + objs = append(objs, val.DeepCopyObject()) + } + + return meta.SetList(list, objs) +} + +func (m *FakeKubeClient) Create(ctx context.Context, obj client.Object, opts ...client.CreateOption) (err error) { + m.syncObj.Lock() + defer m.syncObj.Unlock() + + // if obj is a *v1.Pod then append a ContainerStatus for each Container + pod, ok := obj.(*v1.Pod) + if ok { + for i := range pod.Spec.Containers { + if len(pod.Status.ContainerStatuses) > i { + continue + } + + pod.Status.ContainerStatuses = append(pod.Status.ContainerStatuses, v1.ContainerStatus{ + ContainerID: "docker://container-name", + }) + } + } + + accessor, err := meta.Accessor(obj) + if err != nil { + return err + } + + key := formatKey(types.NamespacedName{ + Name: accessor.GetName(), + Namespace: accessor.GetNamespace(), + }, obj.GetObjectKind().GroupVersionKind()) + + if _, exists := m.Cache[key]; !exists { + m.Cache[key] = obj + return nil + } + + return errors.NewAlreadyExists(schema.GroupResource{}, accessor.GetName()) +} + +func (m *FakeKubeClient) Delete(ctx context.Context, obj client.Object, opts ...client.DeleteOption) error { + m.syncObj.Lock() + defer m.syncObj.Unlock() + + accessor, err := meta.Accessor(obj) + if err != nil { + return err + } + + key := formatKey(types.NamespacedName{ + Name: accessor.GetName(), + Namespace: accessor.GetNamespace(), + }, obj.GetObjectKind().GroupVersionKind()) + + delete(m.Cache, key) + + return nil +} + +func (m *FakeKubeClient) Update(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error { + m.syncObj.Lock() + defer m.syncObj.Unlock() + + accessor, err := meta.Accessor(obj) + if err != nil { + return err + } + + key := formatKey(types.NamespacedName{ + Name: accessor.GetName(), + Namespace: accessor.GetNamespace(), + }, obj.GetObjectKind().GroupVersionKind()) + + if _, exists := m.Cache[key]; exists { + m.Cache[key] = obj + return nil + } + + return errors.NewNotFound(schema.GroupResource{}, accessor.GetName()) +} + +func (*FakeKubeClient) Status() client.StatusWriter { + panic("implement me") +} + +// Patch patches the given obj in the Kubernetes cluster. obj must be a +// struct pointer so that obj can be updated with the content returned by the Server. +func (*FakeKubeClient) Patch(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption) error { + panic("implement me") + +} + +// DeleteAllOf deletes all objects of the given type matching the given options. +func (*FakeKubeClient) DeleteAllOf(ctx context.Context, obj client.Object, opts ...client.DeleteAllOfOption) error { + panic("implement me") +} + +func (*FakeKubeClient) Scheme() *runtime.Scheme { + panic("implement me") +} + +func (*FakeKubeClient) RESTMapper() meta.RESTMapper { + panic("implement me") +} + +func NewFakeKubeClient() *FakeKubeClient { + return &FakeKubeClient{ + syncObj: sync.RWMutex{}, + Cache: map[string]runtime.Object{}, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/kube_client.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/kube_client.go new file mode 100644 index 0000000000..7ab1c765ef --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/kube_client.go @@ -0,0 +1,131 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + cache "sigs.k8s.io/controller-runtime/pkg/cache" + client "sigs.k8s.io/controller-runtime/pkg/client" + + mock "github.com/stretchr/testify/mock" +) + +// KubeClient is an autogenerated mock type for the KubeClient type +type KubeClient struct { + mock.Mock +} + +type KubeClient_Expecter struct { + mock *mock.Mock +} + +func (_m *KubeClient) EXPECT() *KubeClient_Expecter { + return &KubeClient_Expecter{mock: &_m.Mock} +} + +// GetCache provides a mock function with no fields +func (_m *KubeClient) GetCache() cache.Cache { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetCache") + } + + var r0 cache.Cache + if rf, ok := ret.Get(0).(func() cache.Cache); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(cache.Cache) + } + } + + return r0 +} + +// KubeClient_GetCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCache' +type KubeClient_GetCache_Call struct { + *mock.Call +} + +// GetCache is a helper method to define mock.On call +func (_e *KubeClient_Expecter) GetCache() *KubeClient_GetCache_Call { + return &KubeClient_GetCache_Call{Call: _e.mock.On("GetCache")} +} + +func (_c *KubeClient_GetCache_Call) Run(run func()) *KubeClient_GetCache_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *KubeClient_GetCache_Call) Return(_a0 cache.Cache) *KubeClient_GetCache_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *KubeClient_GetCache_Call) RunAndReturn(run func() cache.Cache) *KubeClient_GetCache_Call { + _c.Call.Return(run) + return _c +} + +// GetClient provides a mock function with no fields +func (_m *KubeClient) GetClient() client.Client { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetClient") + } + + var r0 client.Client + if rf, ok := ret.Get(0).(func() client.Client); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(client.Client) + } + } + + return r0 +} + +// KubeClient_GetClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClient' +type KubeClient_GetClient_Call struct { + *mock.Call +} + +// GetClient is a helper method to define mock.On call +func (_e *KubeClient_Expecter) GetClient() *KubeClient_GetClient_Call { + return &KubeClient_GetClient_Call{Call: _e.mock.On("GetClient")} +} + +func (_c *KubeClient_GetClient_Call) Run(run func()) *KubeClient_GetClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *KubeClient_GetClient_Call) Return(_a0 client.Client) *KubeClient_GetClient_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *KubeClient_GetClient_Call) RunAndReturn(run func() client.Client) *KubeClient_GetClient_Call { + _c.Call.Return(run) + return _c +} + +// NewKubeClient creates a new instance of KubeClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewKubeClient(t interface { + mock.TestingT + Cleanup(func()) +}) *KubeClient { + mock := &KubeClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/plugin.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/plugin.go new file mode 100644 index 0000000000..444a24aa8d --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/plugin.go @@ -0,0 +1,278 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + mock "github.com/stretchr/testify/mock" +) + +// Plugin is an autogenerated mock type for the Plugin type +type Plugin struct { + mock.Mock +} + +type Plugin_Expecter struct { + mock *mock.Mock +} + +func (_m *Plugin) EXPECT() *Plugin_Expecter { + return &Plugin_Expecter{mock: &_m.Mock} +} + +// Abort provides a mock function with given fields: ctx, tCtx +func (_m *Plugin) Abort(ctx context.Context, tCtx core.TaskExecutionContext) error { + ret := _m.Called(ctx, tCtx) + + if len(ret) == 0 { + panic("no return value specified for Abort") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, core.TaskExecutionContext) error); ok { + r0 = rf(ctx, tCtx) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Plugin_Abort_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Abort' +type Plugin_Abort_Call struct { + *mock.Call +} + +// Abort is a helper method to define mock.On call +// - ctx context.Context +// - tCtx core.TaskExecutionContext +func (_e *Plugin_Expecter) Abort(ctx interface{}, tCtx interface{}) *Plugin_Abort_Call { + return &Plugin_Abort_Call{Call: _e.mock.On("Abort", ctx, tCtx)} +} + +func (_c *Plugin_Abort_Call) Run(run func(ctx context.Context, tCtx core.TaskExecutionContext)) *Plugin_Abort_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(core.TaskExecutionContext)) + }) + return _c +} + +func (_c *Plugin_Abort_Call) Return(_a0 error) *Plugin_Abort_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Plugin_Abort_Call) RunAndReturn(run func(context.Context, core.TaskExecutionContext) error) *Plugin_Abort_Call { + _c.Call.Return(run) + return _c +} + +// Finalize provides a mock function with given fields: ctx, tCtx +func (_m *Plugin) Finalize(ctx context.Context, tCtx core.TaskExecutionContext) error { + ret := _m.Called(ctx, tCtx) + + if len(ret) == 0 { + panic("no return value specified for Finalize") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, core.TaskExecutionContext) error); ok { + r0 = rf(ctx, tCtx) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Plugin_Finalize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Finalize' +type Plugin_Finalize_Call struct { + *mock.Call +} + +// Finalize is a helper method to define mock.On call +// - ctx context.Context +// - tCtx core.TaskExecutionContext +func (_e *Plugin_Expecter) Finalize(ctx interface{}, tCtx interface{}) *Plugin_Finalize_Call { + return &Plugin_Finalize_Call{Call: _e.mock.On("Finalize", ctx, tCtx)} +} + +func (_c *Plugin_Finalize_Call) Run(run func(ctx context.Context, tCtx core.TaskExecutionContext)) *Plugin_Finalize_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(core.TaskExecutionContext)) + }) + return _c +} + +func (_c *Plugin_Finalize_Call) Return(_a0 error) *Plugin_Finalize_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Plugin_Finalize_Call) RunAndReturn(run func(context.Context, core.TaskExecutionContext) error) *Plugin_Finalize_Call { + _c.Call.Return(run) + return _c +} + +// GetID provides a mock function with no fields +func (_m *Plugin) GetID() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetID") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// Plugin_GetID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetID' +type Plugin_GetID_Call struct { + *mock.Call +} + +// GetID is a helper method to define mock.On call +func (_e *Plugin_Expecter) GetID() *Plugin_GetID_Call { + return &Plugin_GetID_Call{Call: _e.mock.On("GetID")} +} + +func (_c *Plugin_GetID_Call) Run(run func()) *Plugin_GetID_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Plugin_GetID_Call) Return(_a0 string) *Plugin_GetID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Plugin_GetID_Call) RunAndReturn(run func() string) *Plugin_GetID_Call { + _c.Call.Return(run) + return _c +} + +// GetProperties provides a mock function with no fields +func (_m *Plugin) GetProperties() core.PluginProperties { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetProperties") + } + + var r0 core.PluginProperties + if rf, ok := ret.Get(0).(func() core.PluginProperties); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(core.PluginProperties) + } + + return r0 +} + +// Plugin_GetProperties_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProperties' +type Plugin_GetProperties_Call struct { + *mock.Call +} + +// GetProperties is a helper method to define mock.On call +func (_e *Plugin_Expecter) GetProperties() *Plugin_GetProperties_Call { + return &Plugin_GetProperties_Call{Call: _e.mock.On("GetProperties")} +} + +func (_c *Plugin_GetProperties_Call) Run(run func()) *Plugin_GetProperties_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Plugin_GetProperties_Call) Return(_a0 core.PluginProperties) *Plugin_GetProperties_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Plugin_GetProperties_Call) RunAndReturn(run func() core.PluginProperties) *Plugin_GetProperties_Call { + _c.Call.Return(run) + return _c +} + +// Handle provides a mock function with given fields: ctx, tCtx +func (_m *Plugin) Handle(ctx context.Context, tCtx core.TaskExecutionContext) (core.Transition, error) { + ret := _m.Called(ctx, tCtx) + + if len(ret) == 0 { + panic("no return value specified for Handle") + } + + var r0 core.Transition + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, core.TaskExecutionContext) (core.Transition, error)); ok { + return rf(ctx, tCtx) + } + if rf, ok := ret.Get(0).(func(context.Context, core.TaskExecutionContext) core.Transition); ok { + r0 = rf(ctx, tCtx) + } else { + r0 = ret.Get(0).(core.Transition) + } + + if rf, ok := ret.Get(1).(func(context.Context, core.TaskExecutionContext) error); ok { + r1 = rf(ctx, tCtx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Plugin_Handle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Handle' +type Plugin_Handle_Call struct { + *mock.Call +} + +// Handle is a helper method to define mock.On call +// - ctx context.Context +// - tCtx core.TaskExecutionContext +func (_e *Plugin_Expecter) Handle(ctx interface{}, tCtx interface{}) *Plugin_Handle_Call { + return &Plugin_Handle_Call{Call: _e.mock.On("Handle", ctx, tCtx)} +} + +func (_c *Plugin_Handle_Call) Run(run func(ctx context.Context, tCtx core.TaskExecutionContext)) *Plugin_Handle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(core.TaskExecutionContext)) + }) + return _c +} + +func (_c *Plugin_Handle_Call) Return(_a0 core.Transition, _a1 error) *Plugin_Handle_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Plugin_Handle_Call) RunAndReturn(run func(context.Context, core.TaskExecutionContext) (core.Transition, error)) *Plugin_Handle_Call { + _c.Call.Return(run) + return _c +} + +// NewPlugin creates a new instance of Plugin. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewPlugin(t interface { + mock.TestingT + Cleanup(func()) +}) *Plugin { + mock := &Plugin{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/plugin_loader.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/plugin_loader.go new file mode 100644 index 0000000000..0b327a2a87 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/plugin_loader.go @@ -0,0 +1,96 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + mock "github.com/stretchr/testify/mock" +) + +// PluginLoader is an autogenerated mock type for the PluginLoader type +type PluginLoader struct { + mock.Mock +} + +type PluginLoader_Expecter struct { + mock *mock.Mock +} + +func (_m *PluginLoader) EXPECT() *PluginLoader_Expecter { + return &PluginLoader_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: ctx, iCtx +func (_m *PluginLoader) Execute(ctx context.Context, iCtx core.SetupContext) (core.Plugin, error) { + ret := _m.Called(ctx, iCtx) + + if len(ret) == 0 { + panic("no return value specified for Execute") + } + + var r0 core.Plugin + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, core.SetupContext) (core.Plugin, error)); ok { + return rf(ctx, iCtx) + } + if rf, ok := ret.Get(0).(func(context.Context, core.SetupContext) core.Plugin); ok { + r0 = rf(ctx, iCtx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.Plugin) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, core.SetupContext) error); ok { + r1 = rf(ctx, iCtx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// PluginLoader_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type PluginLoader_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - ctx context.Context +// - iCtx core.SetupContext +func (_e *PluginLoader_Expecter) Execute(ctx interface{}, iCtx interface{}) *PluginLoader_Execute_Call { + return &PluginLoader_Execute_Call{Call: _e.mock.On("Execute", ctx, iCtx)} +} + +func (_c *PluginLoader_Execute_Call) Run(run func(ctx context.Context, iCtx core.SetupContext)) *PluginLoader_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(core.SetupContext)) + }) + return _c +} + +func (_c *PluginLoader_Execute_Call) Return(_a0 core.Plugin, _a1 error) *PluginLoader_Execute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *PluginLoader_Execute_Call) RunAndReturn(run func(context.Context, core.SetupContext) (core.Plugin, error)) *PluginLoader_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewPluginLoader creates a new instance of PluginLoader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewPluginLoader(t interface { + mock.TestingT + Cleanup(func()) +}) *PluginLoader { + mock := &PluginLoader{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/plugin_state_reader.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/plugin_state_reader.go new file mode 100644 index 0000000000..8529fb445a --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/plugin_state_reader.go @@ -0,0 +1,133 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// PluginStateReader is an autogenerated mock type for the PluginStateReader type +type PluginStateReader struct { + mock.Mock +} + +type PluginStateReader_Expecter struct { + mock *mock.Mock +} + +func (_m *PluginStateReader) EXPECT() *PluginStateReader_Expecter { + return &PluginStateReader_Expecter{mock: &_m.Mock} +} + +// Get provides a mock function with given fields: t +func (_m *PluginStateReader) Get(t interface{}) (uint8, error) { + ret := _m.Called(t) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 uint8 + var r1 error + if rf, ok := ret.Get(0).(func(interface{}) (uint8, error)); ok { + return rf(t) + } + if rf, ok := ret.Get(0).(func(interface{}) uint8); ok { + r0 = rf(t) + } else { + r0 = ret.Get(0).(uint8) + } + + if rf, ok := ret.Get(1).(func(interface{}) error); ok { + r1 = rf(t) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// PluginStateReader_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type PluginStateReader_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - t interface{} +func (_e *PluginStateReader_Expecter) Get(t interface{}) *PluginStateReader_Get_Call { + return &PluginStateReader_Get_Call{Call: _e.mock.On("Get", t)} +} + +func (_c *PluginStateReader_Get_Call) Run(run func(t interface{})) *PluginStateReader_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{})) + }) + return _c +} + +func (_c *PluginStateReader_Get_Call) Return(stateVersion uint8, err error) *PluginStateReader_Get_Call { + _c.Call.Return(stateVersion, err) + return _c +} + +func (_c *PluginStateReader_Get_Call) RunAndReturn(run func(interface{}) (uint8, error)) *PluginStateReader_Get_Call { + _c.Call.Return(run) + return _c +} + +// GetStateVersion provides a mock function with no fields +func (_m *PluginStateReader) GetStateVersion() uint8 { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetStateVersion") + } + + var r0 uint8 + if rf, ok := ret.Get(0).(func() uint8); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(uint8) + } + + return r0 +} + +// PluginStateReader_GetStateVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStateVersion' +type PluginStateReader_GetStateVersion_Call struct { + *mock.Call +} + +// GetStateVersion is a helper method to define mock.On call +func (_e *PluginStateReader_Expecter) GetStateVersion() *PluginStateReader_GetStateVersion_Call { + return &PluginStateReader_GetStateVersion_Call{Call: _e.mock.On("GetStateVersion")} +} + +func (_c *PluginStateReader_GetStateVersion_Call) Run(run func()) *PluginStateReader_GetStateVersion_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *PluginStateReader_GetStateVersion_Call) Return(_a0 uint8) *PluginStateReader_GetStateVersion_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PluginStateReader_GetStateVersion_Call) RunAndReturn(run func() uint8) *PluginStateReader_GetStateVersion_Call { + _c.Call.Return(run) + return _c +} + +// NewPluginStateReader creates a new instance of PluginStateReader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewPluginStateReader(t interface { + mock.TestingT + Cleanup(func()) +}) *PluginStateReader { + mock := &PluginStateReader{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/plugin_state_writer.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/plugin_state_writer.go new file mode 100644 index 0000000000..49703f90b2 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/plugin_state_writer.go @@ -0,0 +1,124 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// PluginStateWriter is an autogenerated mock type for the PluginStateWriter type +type PluginStateWriter struct { + mock.Mock +} + +type PluginStateWriter_Expecter struct { + mock *mock.Mock +} + +func (_m *PluginStateWriter) EXPECT() *PluginStateWriter_Expecter { + return &PluginStateWriter_Expecter{mock: &_m.Mock} +} + +// Put provides a mock function with given fields: stateVersion, v +func (_m *PluginStateWriter) Put(stateVersion uint8, v interface{}) error { + ret := _m.Called(stateVersion, v) + + if len(ret) == 0 { + panic("no return value specified for Put") + } + + var r0 error + if rf, ok := ret.Get(0).(func(uint8, interface{}) error); ok { + r0 = rf(stateVersion, v) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// PluginStateWriter_Put_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Put' +type PluginStateWriter_Put_Call struct { + *mock.Call +} + +// Put is a helper method to define mock.On call +// - stateVersion uint8 +// - v interface{} +func (_e *PluginStateWriter_Expecter) Put(stateVersion interface{}, v interface{}) *PluginStateWriter_Put_Call { + return &PluginStateWriter_Put_Call{Call: _e.mock.On("Put", stateVersion, v)} +} + +func (_c *PluginStateWriter_Put_Call) Run(run func(stateVersion uint8, v interface{})) *PluginStateWriter_Put_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(uint8), args[1].(interface{})) + }) + return _c +} + +func (_c *PluginStateWriter_Put_Call) Return(_a0 error) *PluginStateWriter_Put_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PluginStateWriter_Put_Call) RunAndReturn(run func(uint8, interface{}) error) *PluginStateWriter_Put_Call { + _c.Call.Return(run) + return _c +} + +// Reset provides a mock function with no fields +func (_m *PluginStateWriter) Reset() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Reset") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// PluginStateWriter_Reset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reset' +type PluginStateWriter_Reset_Call struct { + *mock.Call +} + +// Reset is a helper method to define mock.On call +func (_e *PluginStateWriter_Expecter) Reset() *PluginStateWriter_Reset_Call { + return &PluginStateWriter_Reset_Call{Call: _e.mock.On("Reset")} +} + +func (_c *PluginStateWriter_Reset_Call) Run(run func()) *PluginStateWriter_Reset_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *PluginStateWriter_Reset_Call) Return(_a0 error) *PluginStateWriter_Reset_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PluginStateWriter_Reset_Call) RunAndReturn(run func() error) *PluginStateWriter_Reset_Call { + _c.Call.Return(run) + return _c +} + +// NewPluginStateWriter creates a new instance of PluginStateWriter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewPluginStateWriter(t interface { + mock.TestingT + Cleanup(func()) +}) *PluginStateWriter { + mock := &PluginStateWriter{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/resource_manager.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/resource_manager.go new file mode 100644 index 0000000000..79866a8edb --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/resource_manager.go @@ -0,0 +1,189 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + mock "github.com/stretchr/testify/mock" +) + +// ResourceManager is an autogenerated mock type for the ResourceManager type +type ResourceManager struct { + mock.Mock +} + +type ResourceManager_Expecter struct { + mock *mock.Mock +} + +func (_m *ResourceManager) EXPECT() *ResourceManager_Expecter { + return &ResourceManager_Expecter{mock: &_m.Mock} +} + +// AllocateResource provides a mock function with given fields: ctx, namespace, allocationToken, constraintsSpec +func (_m *ResourceManager) AllocateResource(ctx context.Context, namespace core.ResourceNamespace, allocationToken string, constraintsSpec core.ResourceConstraintsSpec) (core.AllocationStatus, error) { + ret := _m.Called(ctx, namespace, allocationToken, constraintsSpec) + + if len(ret) == 0 { + panic("no return value specified for AllocateResource") + } + + var r0 core.AllocationStatus + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, core.ResourceNamespace, string, core.ResourceConstraintsSpec) (core.AllocationStatus, error)); ok { + return rf(ctx, namespace, allocationToken, constraintsSpec) + } + if rf, ok := ret.Get(0).(func(context.Context, core.ResourceNamespace, string, core.ResourceConstraintsSpec) core.AllocationStatus); ok { + r0 = rf(ctx, namespace, allocationToken, constraintsSpec) + } else { + r0 = ret.Get(0).(core.AllocationStatus) + } + + if rf, ok := ret.Get(1).(func(context.Context, core.ResourceNamespace, string, core.ResourceConstraintsSpec) error); ok { + r1 = rf(ctx, namespace, allocationToken, constraintsSpec) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ResourceManager_AllocateResource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllocateResource' +type ResourceManager_AllocateResource_Call struct { + *mock.Call +} + +// AllocateResource is a helper method to define mock.On call +// - ctx context.Context +// - namespace core.ResourceNamespace +// - allocationToken string +// - constraintsSpec core.ResourceConstraintsSpec +func (_e *ResourceManager_Expecter) AllocateResource(ctx interface{}, namespace interface{}, allocationToken interface{}, constraintsSpec interface{}) *ResourceManager_AllocateResource_Call { + return &ResourceManager_AllocateResource_Call{Call: _e.mock.On("AllocateResource", ctx, namespace, allocationToken, constraintsSpec)} +} + +func (_c *ResourceManager_AllocateResource_Call) Run(run func(ctx context.Context, namespace core.ResourceNamespace, allocationToken string, constraintsSpec core.ResourceConstraintsSpec)) *ResourceManager_AllocateResource_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(core.ResourceNamespace), args[2].(string), args[3].(core.ResourceConstraintsSpec)) + }) + return _c +} + +func (_c *ResourceManager_AllocateResource_Call) Return(_a0 core.AllocationStatus, _a1 error) *ResourceManager_AllocateResource_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ResourceManager_AllocateResource_Call) RunAndReturn(run func(context.Context, core.ResourceNamespace, string, core.ResourceConstraintsSpec) (core.AllocationStatus, error)) *ResourceManager_AllocateResource_Call { + _c.Call.Return(run) + return _c +} + +// GetID provides a mock function with no fields +func (_m *ResourceManager) GetID() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetID") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// ResourceManager_GetID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetID' +type ResourceManager_GetID_Call struct { + *mock.Call +} + +// GetID is a helper method to define mock.On call +func (_e *ResourceManager_Expecter) GetID() *ResourceManager_GetID_Call { + return &ResourceManager_GetID_Call{Call: _e.mock.On("GetID")} +} + +func (_c *ResourceManager_GetID_Call) Run(run func()) *ResourceManager_GetID_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ResourceManager_GetID_Call) Return(_a0 string) *ResourceManager_GetID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ResourceManager_GetID_Call) RunAndReturn(run func() string) *ResourceManager_GetID_Call { + _c.Call.Return(run) + return _c +} + +// ReleaseResource provides a mock function with given fields: ctx, namespace, allocationToken +func (_m *ResourceManager) ReleaseResource(ctx context.Context, namespace core.ResourceNamespace, allocationToken string) error { + ret := _m.Called(ctx, namespace, allocationToken) + + if len(ret) == 0 { + panic("no return value specified for ReleaseResource") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, core.ResourceNamespace, string) error); ok { + r0 = rf(ctx, namespace, allocationToken) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// ResourceManager_ReleaseResource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReleaseResource' +type ResourceManager_ReleaseResource_Call struct { + *mock.Call +} + +// ReleaseResource is a helper method to define mock.On call +// - ctx context.Context +// - namespace core.ResourceNamespace +// - allocationToken string +func (_e *ResourceManager_Expecter) ReleaseResource(ctx interface{}, namespace interface{}, allocationToken interface{}) *ResourceManager_ReleaseResource_Call { + return &ResourceManager_ReleaseResource_Call{Call: _e.mock.On("ReleaseResource", ctx, namespace, allocationToken)} +} + +func (_c *ResourceManager_ReleaseResource_Call) Run(run func(ctx context.Context, namespace core.ResourceNamespace, allocationToken string)) *ResourceManager_ReleaseResource_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(core.ResourceNamespace), args[2].(string)) + }) + return _c +} + +func (_c *ResourceManager_ReleaseResource_Call) Return(_a0 error) *ResourceManager_ReleaseResource_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ResourceManager_ReleaseResource_Call) RunAndReturn(run func(context.Context, core.ResourceNamespace, string) error) *ResourceManager_ReleaseResource_Call { + _c.Call.Return(run) + return _c +} + +// NewResourceManager creates a new instance of ResourceManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewResourceManager(t interface { + mock.TestingT + Cleanup(func()) +}) *ResourceManager { + mock := &ResourceManager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/resource_negotiator.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/resource_negotiator.go new file mode 100644 index 0000000000..eabec21e8e --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/resource_negotiator.go @@ -0,0 +1,47 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + context "context" + + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + mock "github.com/stretchr/testify/mock" +) + +// ResourceRegistrar is an autogenerated mock type for the ResourceRegistrar type +type ResourceNegotiator struct { + mock.Mock +} + +type ResourceNegotiator_RegisterResourceQuota struct { + *mock.Call +} + +func (_m ResourceNegotiator_RegisterResourceQuota) Return(_a0 error) *ResourceNegotiator_RegisterResourceQuota { + return &ResourceNegotiator_RegisterResourceQuota{Call: _m.Call.Return(_a0)} +} + +func (_m *ResourceNegotiator) OnRegisterResourceQuota(ctx context.Context, namespace core.ResourceNamespace, quota int) *ResourceNegotiator_RegisterResourceQuota { + c := _m.On("RegisterResourceQuota", ctx, namespace, quota) + return &ResourceNegotiator_RegisterResourceQuota{Call: c} +} + +func (_m *ResourceNegotiator) OnRegisterResourceQuotaMatch(matchers ...interface{}) *ResourceNegotiator_RegisterResourceQuota { + c := _m.On("RegisterResourceQuota", matchers...) + return &ResourceNegotiator_RegisterResourceQuota{Call: c} +} + +// RegisterResourceQuota provides a mock function with given fields: ctx, namespace, quota +func (_m *ResourceNegotiator) RegisterResourceQuota(ctx context.Context, namespace core.ResourceNamespace, quota int) error { + ret := _m.Called(ctx, namespace, quota) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, core.ResourceNamespace, int) error); ok { + r0 = rf(ctx, namespace, quota) + } else { + r0 = ret.Error(0) + } + + return r0 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/resource_registrar.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/resource_registrar.go new file mode 100644 index 0000000000..b8011149ec --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/resource_registrar.go @@ -0,0 +1,85 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + mock "github.com/stretchr/testify/mock" +) + +// ResourceRegistrar is an autogenerated mock type for the ResourceRegistrar type +type ResourceRegistrar struct { + mock.Mock +} + +type ResourceRegistrar_Expecter struct { + mock *mock.Mock +} + +func (_m *ResourceRegistrar) EXPECT() *ResourceRegistrar_Expecter { + return &ResourceRegistrar_Expecter{mock: &_m.Mock} +} + +// RegisterResourceQuota provides a mock function with given fields: ctx, namespace, quota +func (_m *ResourceRegistrar) RegisterResourceQuota(ctx context.Context, namespace core.ResourceNamespace, quota int) error { + ret := _m.Called(ctx, namespace, quota) + + if len(ret) == 0 { + panic("no return value specified for RegisterResourceQuota") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, core.ResourceNamespace, int) error); ok { + r0 = rf(ctx, namespace, quota) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// ResourceRegistrar_RegisterResourceQuota_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterResourceQuota' +type ResourceRegistrar_RegisterResourceQuota_Call struct { + *mock.Call +} + +// RegisterResourceQuota is a helper method to define mock.On call +// - ctx context.Context +// - namespace core.ResourceNamespace +// - quota int +func (_e *ResourceRegistrar_Expecter) RegisterResourceQuota(ctx interface{}, namespace interface{}, quota interface{}) *ResourceRegistrar_RegisterResourceQuota_Call { + return &ResourceRegistrar_RegisterResourceQuota_Call{Call: _e.mock.On("RegisterResourceQuota", ctx, namespace, quota)} +} + +func (_c *ResourceRegistrar_RegisterResourceQuota_Call) Run(run func(ctx context.Context, namespace core.ResourceNamespace, quota int)) *ResourceRegistrar_RegisterResourceQuota_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(core.ResourceNamespace), args[2].(int)) + }) + return _c +} + +func (_c *ResourceRegistrar_RegisterResourceQuota_Call) Return(_a0 error) *ResourceRegistrar_RegisterResourceQuota_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ResourceRegistrar_RegisterResourceQuota_Call) RunAndReturn(run func(context.Context, core.ResourceNamespace, int) error) *ResourceRegistrar_RegisterResourceQuota_Call { + _c.Call.Return(run) + return _c +} + +// NewResourceRegistrar creates a new instance of ResourceRegistrar. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewResourceRegistrar(t interface { + mock.TestingT + Cleanup(func()) +}) *ResourceRegistrar { + mock := &ResourceRegistrar{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/secret_manager.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/secret_manager.go new file mode 100644 index 0000000000..6505714ee6 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/secret_manager.go @@ -0,0 +1,93 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" +) + +// SecretManager is an autogenerated mock type for the SecretManager type +type SecretManager struct { + mock.Mock +} + +type SecretManager_Expecter struct { + mock *mock.Mock +} + +func (_m *SecretManager) EXPECT() *SecretManager_Expecter { + return &SecretManager_Expecter{mock: &_m.Mock} +} + +// Get provides a mock function with given fields: ctx, key +func (_m *SecretManager) Get(ctx context.Context, key string) (string, error) { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string) (string, error)); ok { + return rf(ctx, key) + } + if rf, ok := ret.Get(0).(func(context.Context, string) string); ok { + r0 = rf(ctx, key) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = rf(ctx, key) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SecretManager_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type SecretManager_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *SecretManager_Expecter) Get(ctx interface{}, key interface{}) *SecretManager_Get_Call { + return &SecretManager_Get_Call{Call: _e.mock.On("Get", ctx, key)} +} + +func (_c *SecretManager_Get_Call) Run(run func(ctx context.Context, key string)) *SecretManager_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *SecretManager_Get_Call) Return(_a0 string, _a1 error) *SecretManager_Get_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SecretManager_Get_Call) RunAndReturn(run func(context.Context, string) (string, error)) *SecretManager_Get_Call { + _c.Call.Return(run) + return _c +} + +// NewSecretManager creates a new instance of SecretManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewSecretManager(t interface { + mock.TestingT + Cleanup(func()) +}) *SecretManager { + mock := &SecretManager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/setup_context.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/setup_context.go new file mode 100644 index 0000000000..e2780b68d9 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/setup_context.go @@ -0,0 +1,364 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + mock "github.com/stretchr/testify/mock" + + promutils "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +// SetupContext is an autogenerated mock type for the SetupContext type +type SetupContext struct { + mock.Mock +} + +type SetupContext_Expecter struct { + mock *mock.Mock +} + +func (_m *SetupContext) EXPECT() *SetupContext_Expecter { + return &SetupContext_Expecter{mock: &_m.Mock} +} + +// EnqueueOwner provides a mock function with no fields +func (_m *SetupContext) EnqueueOwner() core.EnqueueOwner { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for EnqueueOwner") + } + + var r0 core.EnqueueOwner + if rf, ok := ret.Get(0).(func() core.EnqueueOwner); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.EnqueueOwner) + } + } + + return r0 +} + +// SetupContext_EnqueueOwner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnqueueOwner' +type SetupContext_EnqueueOwner_Call struct { + *mock.Call +} + +// EnqueueOwner is a helper method to define mock.On call +func (_e *SetupContext_Expecter) EnqueueOwner() *SetupContext_EnqueueOwner_Call { + return &SetupContext_EnqueueOwner_Call{Call: _e.mock.On("EnqueueOwner")} +} + +func (_c *SetupContext_EnqueueOwner_Call) Run(run func()) *SetupContext_EnqueueOwner_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SetupContext_EnqueueOwner_Call) Return(_a0 core.EnqueueOwner) *SetupContext_EnqueueOwner_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SetupContext_EnqueueOwner_Call) RunAndReturn(run func() core.EnqueueOwner) *SetupContext_EnqueueOwner_Call { + _c.Call.Return(run) + return _c +} + +// IncludeEnqueueLabels provides a mock function with no fields +func (_m *SetupContext) IncludeEnqueueLabels() []string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for IncludeEnqueueLabels") + } + + var r0 []string + if rf, ok := ret.Get(0).(func() []string); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + + return r0 +} + +// SetupContext_IncludeEnqueueLabels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IncludeEnqueueLabels' +type SetupContext_IncludeEnqueueLabels_Call struct { + *mock.Call +} + +// IncludeEnqueueLabels is a helper method to define mock.On call +func (_e *SetupContext_Expecter) IncludeEnqueueLabels() *SetupContext_IncludeEnqueueLabels_Call { + return &SetupContext_IncludeEnqueueLabels_Call{Call: _e.mock.On("IncludeEnqueueLabels")} +} + +func (_c *SetupContext_IncludeEnqueueLabels_Call) Run(run func()) *SetupContext_IncludeEnqueueLabels_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SetupContext_IncludeEnqueueLabels_Call) Return(_a0 []string) *SetupContext_IncludeEnqueueLabels_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SetupContext_IncludeEnqueueLabels_Call) RunAndReturn(run func() []string) *SetupContext_IncludeEnqueueLabels_Call { + _c.Call.Return(run) + return _c +} + +// KubeClient provides a mock function with no fields +func (_m *SetupContext) KubeClient() core.KubeClient { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for KubeClient") + } + + var r0 core.KubeClient + if rf, ok := ret.Get(0).(func() core.KubeClient); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.KubeClient) + } + } + + return r0 +} + +// SetupContext_KubeClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'KubeClient' +type SetupContext_KubeClient_Call struct { + *mock.Call +} + +// KubeClient is a helper method to define mock.On call +func (_e *SetupContext_Expecter) KubeClient() *SetupContext_KubeClient_Call { + return &SetupContext_KubeClient_Call{Call: _e.mock.On("KubeClient")} +} + +func (_c *SetupContext_KubeClient_Call) Run(run func()) *SetupContext_KubeClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SetupContext_KubeClient_Call) Return(_a0 core.KubeClient) *SetupContext_KubeClient_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SetupContext_KubeClient_Call) RunAndReturn(run func() core.KubeClient) *SetupContext_KubeClient_Call { + _c.Call.Return(run) + return _c +} + +// MetricsScope provides a mock function with no fields +func (_m *SetupContext) MetricsScope() promutils.Scope { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for MetricsScope") + } + + var r0 promutils.Scope + if rf, ok := ret.Get(0).(func() promutils.Scope); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(promutils.Scope) + } + } + + return r0 +} + +// SetupContext_MetricsScope_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MetricsScope' +type SetupContext_MetricsScope_Call struct { + *mock.Call +} + +// MetricsScope is a helper method to define mock.On call +func (_e *SetupContext_Expecter) MetricsScope() *SetupContext_MetricsScope_Call { + return &SetupContext_MetricsScope_Call{Call: _e.mock.On("MetricsScope")} +} + +func (_c *SetupContext_MetricsScope_Call) Run(run func()) *SetupContext_MetricsScope_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SetupContext_MetricsScope_Call) Return(_a0 promutils.Scope) *SetupContext_MetricsScope_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SetupContext_MetricsScope_Call) RunAndReturn(run func() promutils.Scope) *SetupContext_MetricsScope_Call { + _c.Call.Return(run) + return _c +} + +// OwnerKind provides a mock function with no fields +func (_m *SetupContext) OwnerKind() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for OwnerKind") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// SetupContext_OwnerKind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OwnerKind' +type SetupContext_OwnerKind_Call struct { + *mock.Call +} + +// OwnerKind is a helper method to define mock.On call +func (_e *SetupContext_Expecter) OwnerKind() *SetupContext_OwnerKind_Call { + return &SetupContext_OwnerKind_Call{Call: _e.mock.On("OwnerKind")} +} + +func (_c *SetupContext_OwnerKind_Call) Run(run func()) *SetupContext_OwnerKind_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SetupContext_OwnerKind_Call) Return(_a0 string) *SetupContext_OwnerKind_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SetupContext_OwnerKind_Call) RunAndReturn(run func() string) *SetupContext_OwnerKind_Call { + _c.Call.Return(run) + return _c +} + +// ResourceRegistrar provides a mock function with no fields +func (_m *SetupContext) ResourceRegistrar() core.ResourceRegistrar { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for ResourceRegistrar") + } + + var r0 core.ResourceRegistrar + if rf, ok := ret.Get(0).(func() core.ResourceRegistrar); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.ResourceRegistrar) + } + } + + return r0 +} + +// SetupContext_ResourceRegistrar_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceRegistrar' +type SetupContext_ResourceRegistrar_Call struct { + *mock.Call +} + +// ResourceRegistrar is a helper method to define mock.On call +func (_e *SetupContext_Expecter) ResourceRegistrar() *SetupContext_ResourceRegistrar_Call { + return &SetupContext_ResourceRegistrar_Call{Call: _e.mock.On("ResourceRegistrar")} +} + +func (_c *SetupContext_ResourceRegistrar_Call) Run(run func()) *SetupContext_ResourceRegistrar_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SetupContext_ResourceRegistrar_Call) Return(_a0 core.ResourceRegistrar) *SetupContext_ResourceRegistrar_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SetupContext_ResourceRegistrar_Call) RunAndReturn(run func() core.ResourceRegistrar) *SetupContext_ResourceRegistrar_Call { + _c.Call.Return(run) + return _c +} + +// SecretManager provides a mock function with no fields +func (_m *SetupContext) SecretManager() core.SecretManager { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for SecretManager") + } + + var r0 core.SecretManager + if rf, ok := ret.Get(0).(func() core.SecretManager); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.SecretManager) + } + } + + return r0 +} + +// SetupContext_SecretManager_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SecretManager' +type SetupContext_SecretManager_Call struct { + *mock.Call +} + +// SecretManager is a helper method to define mock.On call +func (_e *SetupContext_Expecter) SecretManager() *SetupContext_SecretManager_Call { + return &SetupContext_SecretManager_Call{Call: _e.mock.On("SecretManager")} +} + +func (_c *SetupContext_SecretManager_Call) Run(run func()) *SetupContext_SecretManager_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SetupContext_SecretManager_Call) Return(_a0 core.SecretManager) *SetupContext_SecretManager_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SetupContext_SecretManager_Call) RunAndReturn(run func() core.SecretManager) *SetupContext_SecretManager_Call { + _c.Call.Return(run) + return _c +} + +// NewSetupContext creates a new instance of SetupContext. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewSetupContext(t interface { + mock.TestingT + Cleanup(func()) +}) *SetupContext { + mock := &SetupContext{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/signal_async.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/signal_async.go new file mode 100644 index 0000000000..36006afb9a --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/signal_async.go @@ -0,0 +1,69 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" +) + +// SignalAsync is an autogenerated mock type for the SignalAsync type +type SignalAsync struct { + mock.Mock +} + +type SignalAsync_Expecter struct { + mock *mock.Mock +} + +func (_m *SignalAsync) EXPECT() *SignalAsync_Expecter { + return &SignalAsync_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: ctx +func (_m *SignalAsync) Execute(ctx context.Context) { + _m.Called(ctx) +} + +// SignalAsync_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type SignalAsync_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - ctx context.Context +func (_e *SignalAsync_Expecter) Execute(ctx interface{}) *SignalAsync_Execute_Call { + return &SignalAsync_Execute_Call{Call: _e.mock.On("Execute", ctx)} +} + +func (_c *SignalAsync_Execute_Call) Run(run func(ctx context.Context)) *SignalAsync_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *SignalAsync_Execute_Call) Return() *SignalAsync_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *SignalAsync_Execute_Call) RunAndReturn(run func(context.Context)) *SignalAsync_Execute_Call { + _c.Run(run) + return _c +} + +// NewSignalAsync creates a new instance of SignalAsync. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewSignalAsync(t interface { + mock.TestingT + Cleanup(func()) +}) *SignalAsync { + mock := &SignalAsync{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/task_execution_context.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/task_execution_context.go new file mode 100644 index 0000000000..2deffb5aec --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/task_execution_context.go @@ -0,0 +1,558 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + catalog "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/catalog" + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + + io "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + + mock "github.com/stretchr/testify/mock" + + storage "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + +// TaskExecutionContext is an autogenerated mock type for the TaskExecutionContext type +type TaskExecutionContext struct { + mock.Mock +} + +type TaskExecutionContext_Expecter struct { + mock *mock.Mock +} + +func (_m *TaskExecutionContext) EXPECT() *TaskExecutionContext_Expecter { + return &TaskExecutionContext_Expecter{mock: &_m.Mock} +} + +// Catalog provides a mock function with no fields +func (_m *TaskExecutionContext) Catalog() catalog.AsyncClient { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Catalog") + } + + var r0 catalog.AsyncClient + if rf, ok := ret.Get(0).(func() catalog.AsyncClient); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(catalog.AsyncClient) + } + } + + return r0 +} + +// TaskExecutionContext_Catalog_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Catalog' +type TaskExecutionContext_Catalog_Call struct { + *mock.Call +} + +// Catalog is a helper method to define mock.On call +func (_e *TaskExecutionContext_Expecter) Catalog() *TaskExecutionContext_Catalog_Call { + return &TaskExecutionContext_Catalog_Call{Call: _e.mock.On("Catalog")} +} + +func (_c *TaskExecutionContext_Catalog_Call) Run(run func()) *TaskExecutionContext_Catalog_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionContext_Catalog_Call) Return(_a0 catalog.AsyncClient) *TaskExecutionContext_Catalog_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionContext_Catalog_Call) RunAndReturn(run func() catalog.AsyncClient) *TaskExecutionContext_Catalog_Call { + _c.Call.Return(run) + return _c +} + +// DataStore provides a mock function with no fields +func (_m *TaskExecutionContext) DataStore() *storage.DataStore { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for DataStore") + } + + var r0 *storage.DataStore + if rf, ok := ret.Get(0).(func() *storage.DataStore); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storage.DataStore) + } + } + + return r0 +} + +// TaskExecutionContext_DataStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DataStore' +type TaskExecutionContext_DataStore_Call struct { + *mock.Call +} + +// DataStore is a helper method to define mock.On call +func (_e *TaskExecutionContext_Expecter) DataStore() *TaskExecutionContext_DataStore_Call { + return &TaskExecutionContext_DataStore_Call{Call: _e.mock.On("DataStore")} +} + +func (_c *TaskExecutionContext_DataStore_Call) Run(run func()) *TaskExecutionContext_DataStore_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionContext_DataStore_Call) Return(_a0 *storage.DataStore) *TaskExecutionContext_DataStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionContext_DataStore_Call) RunAndReturn(run func() *storage.DataStore) *TaskExecutionContext_DataStore_Call { + _c.Call.Return(run) + return _c +} + +// InputReader provides a mock function with no fields +func (_m *TaskExecutionContext) InputReader() io.InputReader { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for InputReader") + } + + var r0 io.InputReader + if rf, ok := ret.Get(0).(func() io.InputReader); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(io.InputReader) + } + } + + return r0 +} + +// TaskExecutionContext_InputReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InputReader' +type TaskExecutionContext_InputReader_Call struct { + *mock.Call +} + +// InputReader is a helper method to define mock.On call +func (_e *TaskExecutionContext_Expecter) InputReader() *TaskExecutionContext_InputReader_Call { + return &TaskExecutionContext_InputReader_Call{Call: _e.mock.On("InputReader")} +} + +func (_c *TaskExecutionContext_InputReader_Call) Run(run func()) *TaskExecutionContext_InputReader_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionContext_InputReader_Call) Return(_a0 io.InputReader) *TaskExecutionContext_InputReader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionContext_InputReader_Call) RunAndReturn(run func() io.InputReader) *TaskExecutionContext_InputReader_Call { + _c.Call.Return(run) + return _c +} + +// OutputWriter provides a mock function with no fields +func (_m *TaskExecutionContext) OutputWriter() io.OutputWriter { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for OutputWriter") + } + + var r0 io.OutputWriter + if rf, ok := ret.Get(0).(func() io.OutputWriter); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(io.OutputWriter) + } + } + + return r0 +} + +// TaskExecutionContext_OutputWriter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OutputWriter' +type TaskExecutionContext_OutputWriter_Call struct { + *mock.Call +} + +// OutputWriter is a helper method to define mock.On call +func (_e *TaskExecutionContext_Expecter) OutputWriter() *TaskExecutionContext_OutputWriter_Call { + return &TaskExecutionContext_OutputWriter_Call{Call: _e.mock.On("OutputWriter")} +} + +func (_c *TaskExecutionContext_OutputWriter_Call) Run(run func()) *TaskExecutionContext_OutputWriter_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionContext_OutputWriter_Call) Return(_a0 io.OutputWriter) *TaskExecutionContext_OutputWriter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionContext_OutputWriter_Call) RunAndReturn(run func() io.OutputWriter) *TaskExecutionContext_OutputWriter_Call { + _c.Call.Return(run) + return _c +} + +// PluginStateReader provides a mock function with no fields +func (_m *TaskExecutionContext) PluginStateReader() core.PluginStateReader { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for PluginStateReader") + } + + var r0 core.PluginStateReader + if rf, ok := ret.Get(0).(func() core.PluginStateReader); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.PluginStateReader) + } + } + + return r0 +} + +// TaskExecutionContext_PluginStateReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PluginStateReader' +type TaskExecutionContext_PluginStateReader_Call struct { + *mock.Call +} + +// PluginStateReader is a helper method to define mock.On call +func (_e *TaskExecutionContext_Expecter) PluginStateReader() *TaskExecutionContext_PluginStateReader_Call { + return &TaskExecutionContext_PluginStateReader_Call{Call: _e.mock.On("PluginStateReader")} +} + +func (_c *TaskExecutionContext_PluginStateReader_Call) Run(run func()) *TaskExecutionContext_PluginStateReader_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionContext_PluginStateReader_Call) Return(_a0 core.PluginStateReader) *TaskExecutionContext_PluginStateReader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionContext_PluginStateReader_Call) RunAndReturn(run func() core.PluginStateReader) *TaskExecutionContext_PluginStateReader_Call { + _c.Call.Return(run) + return _c +} + +// PluginStateWriter provides a mock function with no fields +func (_m *TaskExecutionContext) PluginStateWriter() core.PluginStateWriter { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for PluginStateWriter") + } + + var r0 core.PluginStateWriter + if rf, ok := ret.Get(0).(func() core.PluginStateWriter); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.PluginStateWriter) + } + } + + return r0 +} + +// TaskExecutionContext_PluginStateWriter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PluginStateWriter' +type TaskExecutionContext_PluginStateWriter_Call struct { + *mock.Call +} + +// PluginStateWriter is a helper method to define mock.On call +func (_e *TaskExecutionContext_Expecter) PluginStateWriter() *TaskExecutionContext_PluginStateWriter_Call { + return &TaskExecutionContext_PluginStateWriter_Call{Call: _e.mock.On("PluginStateWriter")} +} + +func (_c *TaskExecutionContext_PluginStateWriter_Call) Run(run func()) *TaskExecutionContext_PluginStateWriter_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionContext_PluginStateWriter_Call) Return(_a0 core.PluginStateWriter) *TaskExecutionContext_PluginStateWriter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionContext_PluginStateWriter_Call) RunAndReturn(run func() core.PluginStateWriter) *TaskExecutionContext_PluginStateWriter_Call { + _c.Call.Return(run) + return _c +} + +// ResourceManager provides a mock function with no fields +func (_m *TaskExecutionContext) ResourceManager() core.ResourceManager { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for ResourceManager") + } + + var r0 core.ResourceManager + if rf, ok := ret.Get(0).(func() core.ResourceManager); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.ResourceManager) + } + } + + return r0 +} + +// TaskExecutionContext_ResourceManager_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceManager' +type TaskExecutionContext_ResourceManager_Call struct { + *mock.Call +} + +// ResourceManager is a helper method to define mock.On call +func (_e *TaskExecutionContext_Expecter) ResourceManager() *TaskExecutionContext_ResourceManager_Call { + return &TaskExecutionContext_ResourceManager_Call{Call: _e.mock.On("ResourceManager")} +} + +func (_c *TaskExecutionContext_ResourceManager_Call) Run(run func()) *TaskExecutionContext_ResourceManager_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionContext_ResourceManager_Call) Return(_a0 core.ResourceManager) *TaskExecutionContext_ResourceManager_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionContext_ResourceManager_Call) RunAndReturn(run func() core.ResourceManager) *TaskExecutionContext_ResourceManager_Call { + _c.Call.Return(run) + return _c +} + +// SecretManager provides a mock function with no fields +func (_m *TaskExecutionContext) SecretManager() core.SecretManager { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for SecretManager") + } + + var r0 core.SecretManager + if rf, ok := ret.Get(0).(func() core.SecretManager); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.SecretManager) + } + } + + return r0 +} + +// TaskExecutionContext_SecretManager_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SecretManager' +type TaskExecutionContext_SecretManager_Call struct { + *mock.Call +} + +// SecretManager is a helper method to define mock.On call +func (_e *TaskExecutionContext_Expecter) SecretManager() *TaskExecutionContext_SecretManager_Call { + return &TaskExecutionContext_SecretManager_Call{Call: _e.mock.On("SecretManager")} +} + +func (_c *TaskExecutionContext_SecretManager_Call) Run(run func()) *TaskExecutionContext_SecretManager_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionContext_SecretManager_Call) Return(_a0 core.SecretManager) *TaskExecutionContext_SecretManager_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionContext_SecretManager_Call) RunAndReturn(run func() core.SecretManager) *TaskExecutionContext_SecretManager_Call { + _c.Call.Return(run) + return _c +} + +// TaskExecutionMetadata provides a mock function with no fields +func (_m *TaskExecutionContext) TaskExecutionMetadata() core.TaskExecutionMetadata { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for TaskExecutionMetadata") + } + + var r0 core.TaskExecutionMetadata + if rf, ok := ret.Get(0).(func() core.TaskExecutionMetadata); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.TaskExecutionMetadata) + } + } + + return r0 +} + +// TaskExecutionContext_TaskExecutionMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TaskExecutionMetadata' +type TaskExecutionContext_TaskExecutionMetadata_Call struct { + *mock.Call +} + +// TaskExecutionMetadata is a helper method to define mock.On call +func (_e *TaskExecutionContext_Expecter) TaskExecutionMetadata() *TaskExecutionContext_TaskExecutionMetadata_Call { + return &TaskExecutionContext_TaskExecutionMetadata_Call{Call: _e.mock.On("TaskExecutionMetadata")} +} + +func (_c *TaskExecutionContext_TaskExecutionMetadata_Call) Run(run func()) *TaskExecutionContext_TaskExecutionMetadata_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionContext_TaskExecutionMetadata_Call) Return(_a0 core.TaskExecutionMetadata) *TaskExecutionContext_TaskExecutionMetadata_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionContext_TaskExecutionMetadata_Call) RunAndReturn(run func() core.TaskExecutionMetadata) *TaskExecutionContext_TaskExecutionMetadata_Call { + _c.Call.Return(run) + return _c +} + +// TaskReader provides a mock function with no fields +func (_m *TaskExecutionContext) TaskReader() core.TaskReader { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for TaskReader") + } + + var r0 core.TaskReader + if rf, ok := ret.Get(0).(func() core.TaskReader); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.TaskReader) + } + } + + return r0 +} + +// TaskExecutionContext_TaskReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TaskReader' +type TaskExecutionContext_TaskReader_Call struct { + *mock.Call +} + +// TaskReader is a helper method to define mock.On call +func (_e *TaskExecutionContext_Expecter) TaskReader() *TaskExecutionContext_TaskReader_Call { + return &TaskExecutionContext_TaskReader_Call{Call: _e.mock.On("TaskReader")} +} + +func (_c *TaskExecutionContext_TaskReader_Call) Run(run func()) *TaskExecutionContext_TaskReader_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionContext_TaskReader_Call) Return(_a0 core.TaskReader) *TaskExecutionContext_TaskReader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionContext_TaskReader_Call) RunAndReturn(run func() core.TaskReader) *TaskExecutionContext_TaskReader_Call { + _c.Call.Return(run) + return _c +} + +// TaskRefreshIndicator provides a mock function with no fields +func (_m *TaskExecutionContext) TaskRefreshIndicator() core.SignalAsync { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for TaskRefreshIndicator") + } + + var r0 core.SignalAsync + if rf, ok := ret.Get(0).(func() core.SignalAsync); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.SignalAsync) + } + } + + return r0 +} + +// TaskExecutionContext_TaskRefreshIndicator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TaskRefreshIndicator' +type TaskExecutionContext_TaskRefreshIndicator_Call struct { + *mock.Call +} + +// TaskRefreshIndicator is a helper method to define mock.On call +func (_e *TaskExecutionContext_Expecter) TaskRefreshIndicator() *TaskExecutionContext_TaskRefreshIndicator_Call { + return &TaskExecutionContext_TaskRefreshIndicator_Call{Call: _e.mock.On("TaskRefreshIndicator")} +} + +func (_c *TaskExecutionContext_TaskRefreshIndicator_Call) Run(run func()) *TaskExecutionContext_TaskRefreshIndicator_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionContext_TaskRefreshIndicator_Call) Return(_a0 core.SignalAsync) *TaskExecutionContext_TaskRefreshIndicator_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionContext_TaskRefreshIndicator_Call) RunAndReturn(run func() core.SignalAsync) *TaskExecutionContext_TaskRefreshIndicator_Call { + _c.Call.Return(run) + return _c +} + +// NewTaskExecutionContext creates a new instance of TaskExecutionContext. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTaskExecutionContext(t interface { + mock.TestingT + Cleanup(func()) +}) *TaskExecutionContext { + mock := &TaskExecutionContext{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/task_execution_id.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/task_execution_id.go new file mode 100644 index 0000000000..561f817ab8 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/task_execution_id.go @@ -0,0 +1,227 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + flyteidl2core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + mock "github.com/stretchr/testify/mock" +) + +// TaskExecutionID is an autogenerated mock type for the TaskExecutionID type +type TaskExecutionID struct { + mock.Mock +} + +type TaskExecutionID_Expecter struct { + mock *mock.Mock +} + +func (_m *TaskExecutionID) EXPECT() *TaskExecutionID_Expecter { + return &TaskExecutionID_Expecter{mock: &_m.Mock} +} + +// GetGeneratedName provides a mock function with no fields +func (_m *TaskExecutionID) GetGeneratedName() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetGeneratedName") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// TaskExecutionID_GetGeneratedName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGeneratedName' +type TaskExecutionID_GetGeneratedName_Call struct { + *mock.Call +} + +// GetGeneratedName is a helper method to define mock.On call +func (_e *TaskExecutionID_Expecter) GetGeneratedName() *TaskExecutionID_GetGeneratedName_Call { + return &TaskExecutionID_GetGeneratedName_Call{Call: _e.mock.On("GetGeneratedName")} +} + +func (_c *TaskExecutionID_GetGeneratedName_Call) Run(run func()) *TaskExecutionID_GetGeneratedName_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionID_GetGeneratedName_Call) Return(_a0 string) *TaskExecutionID_GetGeneratedName_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionID_GetGeneratedName_Call) RunAndReturn(run func() string) *TaskExecutionID_GetGeneratedName_Call { + _c.Call.Return(run) + return _c +} + +// GetGeneratedNameWith provides a mock function with given fields: minLength, maxLength +func (_m *TaskExecutionID) GetGeneratedNameWith(minLength int, maxLength int) (string, error) { + ret := _m.Called(minLength, maxLength) + + if len(ret) == 0 { + panic("no return value specified for GetGeneratedNameWith") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func(int, int) (string, error)); ok { + return rf(minLength, maxLength) + } + if rf, ok := ret.Get(0).(func(int, int) string); ok { + r0 = rf(minLength, maxLength) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(int, int) error); ok { + r1 = rf(minLength, maxLength) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TaskExecutionID_GetGeneratedNameWith_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGeneratedNameWith' +type TaskExecutionID_GetGeneratedNameWith_Call struct { + *mock.Call +} + +// GetGeneratedNameWith is a helper method to define mock.On call +// - minLength int +// - maxLength int +func (_e *TaskExecutionID_Expecter) GetGeneratedNameWith(minLength interface{}, maxLength interface{}) *TaskExecutionID_GetGeneratedNameWith_Call { + return &TaskExecutionID_GetGeneratedNameWith_Call{Call: _e.mock.On("GetGeneratedNameWith", minLength, maxLength)} +} + +func (_c *TaskExecutionID_GetGeneratedNameWith_Call) Run(run func(minLength int, maxLength int)) *TaskExecutionID_GetGeneratedNameWith_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int), args[1].(int)) + }) + return _c +} + +func (_c *TaskExecutionID_GetGeneratedNameWith_Call) Return(_a0 string, _a1 error) *TaskExecutionID_GetGeneratedNameWith_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TaskExecutionID_GetGeneratedNameWith_Call) RunAndReturn(run func(int, int) (string, error)) *TaskExecutionID_GetGeneratedNameWith_Call { + _c.Call.Return(run) + return _c +} + +// GetID provides a mock function with no fields +func (_m *TaskExecutionID) GetID() flyteidl2core.TaskExecutionIdentifier { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetID") + } + + var r0 flyteidl2core.TaskExecutionIdentifier + if rf, ok := ret.Get(0).(func() flyteidl2core.TaskExecutionIdentifier); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(flyteidl2core.TaskExecutionIdentifier) + } + + return r0 +} + +// TaskExecutionID_GetID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetID' +type TaskExecutionID_GetID_Call struct { + *mock.Call +} + +// GetID is a helper method to define mock.On call +func (_e *TaskExecutionID_Expecter) GetID() *TaskExecutionID_GetID_Call { + return &TaskExecutionID_GetID_Call{Call: _e.mock.On("GetID")} +} + +func (_c *TaskExecutionID_GetID_Call) Run(run func()) *TaskExecutionID_GetID_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionID_GetID_Call) Return(_a0 flyteidl2core.TaskExecutionIdentifier) *TaskExecutionID_GetID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionID_GetID_Call) RunAndReturn(run func() flyteidl2core.TaskExecutionIdentifier) *TaskExecutionID_GetID_Call { + _c.Call.Return(run) + return _c +} + +// GetUniqueNodeID provides a mock function with no fields +func (_m *TaskExecutionID) GetUniqueNodeID() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetUniqueNodeID") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// TaskExecutionID_GetUniqueNodeID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUniqueNodeID' +type TaskExecutionID_GetUniqueNodeID_Call struct { + *mock.Call +} + +// GetUniqueNodeID is a helper method to define mock.On call +func (_e *TaskExecutionID_Expecter) GetUniqueNodeID() *TaskExecutionID_GetUniqueNodeID_Call { + return &TaskExecutionID_GetUniqueNodeID_Call{Call: _e.mock.On("GetUniqueNodeID")} +} + +func (_c *TaskExecutionID_GetUniqueNodeID_Call) Run(run func()) *TaskExecutionID_GetUniqueNodeID_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionID_GetUniqueNodeID_Call) Return(_a0 string) *TaskExecutionID_GetUniqueNodeID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionID_GetUniqueNodeID_Call) RunAndReturn(run func() string) *TaskExecutionID_GetUniqueNodeID_Call { + _c.Call.Return(run) + return _c +} + +// NewTaskExecutionID creates a new instance of TaskExecutionID. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTaskExecutionID(t interface { + mock.TestingT + Cleanup(func()) +}) *TaskExecutionID { + mock := &TaskExecutionID{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/task_execution_metadata.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/task_execution_metadata.go new file mode 100644 index 0000000000..b2182af236 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/task_execution_metadata.go @@ -0,0 +1,775 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + corev1 "k8s.io/api/core/v1" + + flyteidl2core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + + mock "github.com/stretchr/testify/mock" + + types "k8s.io/apimachinery/pkg/types" + + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// TaskExecutionMetadata is an autogenerated mock type for the TaskExecutionMetadata type +type TaskExecutionMetadata struct { + mock.Mock +} + +type TaskExecutionMetadata_Expecter struct { + mock *mock.Mock +} + +func (_m *TaskExecutionMetadata) EXPECT() *TaskExecutionMetadata_Expecter { + return &TaskExecutionMetadata_Expecter{mock: &_m.Mock} +} + +// GetAnnotations provides a mock function with no fields +func (_m *TaskExecutionMetadata) GetAnnotations() map[string]string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetAnnotations") + } + + var r0 map[string]string + if rf, ok := ret.Get(0).(func() map[string]string); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[string]string) + } + } + + return r0 +} + +// TaskExecutionMetadata_GetAnnotations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAnnotations' +type TaskExecutionMetadata_GetAnnotations_Call struct { + *mock.Call +} + +// GetAnnotations is a helper method to define mock.On call +func (_e *TaskExecutionMetadata_Expecter) GetAnnotations() *TaskExecutionMetadata_GetAnnotations_Call { + return &TaskExecutionMetadata_GetAnnotations_Call{Call: _e.mock.On("GetAnnotations")} +} + +func (_c *TaskExecutionMetadata_GetAnnotations_Call) Run(run func()) *TaskExecutionMetadata_GetAnnotations_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionMetadata_GetAnnotations_Call) Return(_a0 map[string]string) *TaskExecutionMetadata_GetAnnotations_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionMetadata_GetAnnotations_Call) RunAndReturn(run func() map[string]string) *TaskExecutionMetadata_GetAnnotations_Call { + _c.Call.Return(run) + return _c +} + +// GetConsoleURL provides a mock function with no fields +func (_m *TaskExecutionMetadata) GetConsoleURL() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetConsoleURL") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// TaskExecutionMetadata_GetConsoleURL_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConsoleURL' +type TaskExecutionMetadata_GetConsoleURL_Call struct { + *mock.Call +} + +// GetConsoleURL is a helper method to define mock.On call +func (_e *TaskExecutionMetadata_Expecter) GetConsoleURL() *TaskExecutionMetadata_GetConsoleURL_Call { + return &TaskExecutionMetadata_GetConsoleURL_Call{Call: _e.mock.On("GetConsoleURL")} +} + +func (_c *TaskExecutionMetadata_GetConsoleURL_Call) Run(run func()) *TaskExecutionMetadata_GetConsoleURL_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionMetadata_GetConsoleURL_Call) Return(_a0 string) *TaskExecutionMetadata_GetConsoleURL_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionMetadata_GetConsoleURL_Call) RunAndReturn(run func() string) *TaskExecutionMetadata_GetConsoleURL_Call { + _c.Call.Return(run) + return _c +} + +// GetEnvironmentVariables provides a mock function with no fields +func (_m *TaskExecutionMetadata) GetEnvironmentVariables() map[string]string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetEnvironmentVariables") + } + + var r0 map[string]string + if rf, ok := ret.Get(0).(func() map[string]string); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[string]string) + } + } + + return r0 +} + +// TaskExecutionMetadata_GetEnvironmentVariables_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEnvironmentVariables' +type TaskExecutionMetadata_GetEnvironmentVariables_Call struct { + *mock.Call +} + +// GetEnvironmentVariables is a helper method to define mock.On call +func (_e *TaskExecutionMetadata_Expecter) GetEnvironmentVariables() *TaskExecutionMetadata_GetEnvironmentVariables_Call { + return &TaskExecutionMetadata_GetEnvironmentVariables_Call{Call: _e.mock.On("GetEnvironmentVariables")} +} + +func (_c *TaskExecutionMetadata_GetEnvironmentVariables_Call) Run(run func()) *TaskExecutionMetadata_GetEnvironmentVariables_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionMetadata_GetEnvironmentVariables_Call) Return(_a0 map[string]string) *TaskExecutionMetadata_GetEnvironmentVariables_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionMetadata_GetEnvironmentVariables_Call) RunAndReturn(run func() map[string]string) *TaskExecutionMetadata_GetEnvironmentVariables_Call { + _c.Call.Return(run) + return _c +} + +// GetExternalResourceAttributes provides a mock function with no fields +func (_m *TaskExecutionMetadata) GetExternalResourceAttributes() core.ExternalResourceAttributes { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetExternalResourceAttributes") + } + + var r0 core.ExternalResourceAttributes + if rf, ok := ret.Get(0).(func() core.ExternalResourceAttributes); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(core.ExternalResourceAttributes) + } + + return r0 +} + +// TaskExecutionMetadata_GetExternalResourceAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetExternalResourceAttributes' +type TaskExecutionMetadata_GetExternalResourceAttributes_Call struct { + *mock.Call +} + +// GetExternalResourceAttributes is a helper method to define mock.On call +func (_e *TaskExecutionMetadata_Expecter) GetExternalResourceAttributes() *TaskExecutionMetadata_GetExternalResourceAttributes_Call { + return &TaskExecutionMetadata_GetExternalResourceAttributes_Call{Call: _e.mock.On("GetExternalResourceAttributes")} +} + +func (_c *TaskExecutionMetadata_GetExternalResourceAttributes_Call) Run(run func()) *TaskExecutionMetadata_GetExternalResourceAttributes_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionMetadata_GetExternalResourceAttributes_Call) Return(_a0 core.ExternalResourceAttributes) *TaskExecutionMetadata_GetExternalResourceAttributes_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionMetadata_GetExternalResourceAttributes_Call) RunAndReturn(run func() core.ExternalResourceAttributes) *TaskExecutionMetadata_GetExternalResourceAttributes_Call { + _c.Call.Return(run) + return _c +} + +// GetInterruptibleFailureThreshold provides a mock function with no fields +func (_m *TaskExecutionMetadata) GetInterruptibleFailureThreshold() int32 { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetInterruptibleFailureThreshold") + } + + var r0 int32 + if rf, ok := ret.Get(0).(func() int32); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int32) + } + + return r0 +} + +// TaskExecutionMetadata_GetInterruptibleFailureThreshold_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInterruptibleFailureThreshold' +type TaskExecutionMetadata_GetInterruptibleFailureThreshold_Call struct { + *mock.Call +} + +// GetInterruptibleFailureThreshold is a helper method to define mock.On call +func (_e *TaskExecutionMetadata_Expecter) GetInterruptibleFailureThreshold() *TaskExecutionMetadata_GetInterruptibleFailureThreshold_Call { + return &TaskExecutionMetadata_GetInterruptibleFailureThreshold_Call{Call: _e.mock.On("GetInterruptibleFailureThreshold")} +} + +func (_c *TaskExecutionMetadata_GetInterruptibleFailureThreshold_Call) Run(run func()) *TaskExecutionMetadata_GetInterruptibleFailureThreshold_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionMetadata_GetInterruptibleFailureThreshold_Call) Return(_a0 int32) *TaskExecutionMetadata_GetInterruptibleFailureThreshold_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionMetadata_GetInterruptibleFailureThreshold_Call) RunAndReturn(run func() int32) *TaskExecutionMetadata_GetInterruptibleFailureThreshold_Call { + _c.Call.Return(run) + return _c +} + +// GetK8sServiceAccount provides a mock function with no fields +func (_m *TaskExecutionMetadata) GetK8sServiceAccount() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetK8sServiceAccount") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// TaskExecutionMetadata_GetK8sServiceAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetK8sServiceAccount' +type TaskExecutionMetadata_GetK8sServiceAccount_Call struct { + *mock.Call +} + +// GetK8sServiceAccount is a helper method to define mock.On call +func (_e *TaskExecutionMetadata_Expecter) GetK8sServiceAccount() *TaskExecutionMetadata_GetK8sServiceAccount_Call { + return &TaskExecutionMetadata_GetK8sServiceAccount_Call{Call: _e.mock.On("GetK8sServiceAccount")} +} + +func (_c *TaskExecutionMetadata_GetK8sServiceAccount_Call) Run(run func()) *TaskExecutionMetadata_GetK8sServiceAccount_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionMetadata_GetK8sServiceAccount_Call) Return(_a0 string) *TaskExecutionMetadata_GetK8sServiceAccount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionMetadata_GetK8sServiceAccount_Call) RunAndReturn(run func() string) *TaskExecutionMetadata_GetK8sServiceAccount_Call { + _c.Call.Return(run) + return _c +} + +// GetLabels provides a mock function with no fields +func (_m *TaskExecutionMetadata) GetLabels() map[string]string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetLabels") + } + + var r0 map[string]string + if rf, ok := ret.Get(0).(func() map[string]string); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[string]string) + } + } + + return r0 +} + +// TaskExecutionMetadata_GetLabels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLabels' +type TaskExecutionMetadata_GetLabels_Call struct { + *mock.Call +} + +// GetLabels is a helper method to define mock.On call +func (_e *TaskExecutionMetadata_Expecter) GetLabels() *TaskExecutionMetadata_GetLabels_Call { + return &TaskExecutionMetadata_GetLabels_Call{Call: _e.mock.On("GetLabels")} +} + +func (_c *TaskExecutionMetadata_GetLabels_Call) Run(run func()) *TaskExecutionMetadata_GetLabels_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionMetadata_GetLabels_Call) Return(_a0 map[string]string) *TaskExecutionMetadata_GetLabels_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionMetadata_GetLabels_Call) RunAndReturn(run func() map[string]string) *TaskExecutionMetadata_GetLabels_Call { + _c.Call.Return(run) + return _c +} + +// GetMaxAttempts provides a mock function with no fields +func (_m *TaskExecutionMetadata) GetMaxAttempts() uint32 { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetMaxAttempts") + } + + var r0 uint32 + if rf, ok := ret.Get(0).(func() uint32); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(uint32) + } + + return r0 +} + +// TaskExecutionMetadata_GetMaxAttempts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMaxAttempts' +type TaskExecutionMetadata_GetMaxAttempts_Call struct { + *mock.Call +} + +// GetMaxAttempts is a helper method to define mock.On call +func (_e *TaskExecutionMetadata_Expecter) GetMaxAttempts() *TaskExecutionMetadata_GetMaxAttempts_Call { + return &TaskExecutionMetadata_GetMaxAttempts_Call{Call: _e.mock.On("GetMaxAttempts")} +} + +func (_c *TaskExecutionMetadata_GetMaxAttempts_Call) Run(run func()) *TaskExecutionMetadata_GetMaxAttempts_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionMetadata_GetMaxAttempts_Call) Return(_a0 uint32) *TaskExecutionMetadata_GetMaxAttempts_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionMetadata_GetMaxAttempts_Call) RunAndReturn(run func() uint32) *TaskExecutionMetadata_GetMaxAttempts_Call { + _c.Call.Return(run) + return _c +} + +// GetNamespace provides a mock function with no fields +func (_m *TaskExecutionMetadata) GetNamespace() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetNamespace") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// TaskExecutionMetadata_GetNamespace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNamespace' +type TaskExecutionMetadata_GetNamespace_Call struct { + *mock.Call +} + +// GetNamespace is a helper method to define mock.On call +func (_e *TaskExecutionMetadata_Expecter) GetNamespace() *TaskExecutionMetadata_GetNamespace_Call { + return &TaskExecutionMetadata_GetNamespace_Call{Call: _e.mock.On("GetNamespace")} +} + +func (_c *TaskExecutionMetadata_GetNamespace_Call) Run(run func()) *TaskExecutionMetadata_GetNamespace_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionMetadata_GetNamespace_Call) Return(_a0 string) *TaskExecutionMetadata_GetNamespace_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionMetadata_GetNamespace_Call) RunAndReturn(run func() string) *TaskExecutionMetadata_GetNamespace_Call { + _c.Call.Return(run) + return _c +} + +// GetOverrides provides a mock function with no fields +func (_m *TaskExecutionMetadata) GetOverrides() core.TaskOverrides { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetOverrides") + } + + var r0 core.TaskOverrides + if rf, ok := ret.Get(0).(func() core.TaskOverrides); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.TaskOverrides) + } + } + + return r0 +} + +// TaskExecutionMetadata_GetOverrides_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOverrides' +type TaskExecutionMetadata_GetOverrides_Call struct { + *mock.Call +} + +// GetOverrides is a helper method to define mock.On call +func (_e *TaskExecutionMetadata_Expecter) GetOverrides() *TaskExecutionMetadata_GetOverrides_Call { + return &TaskExecutionMetadata_GetOverrides_Call{Call: _e.mock.On("GetOverrides")} +} + +func (_c *TaskExecutionMetadata_GetOverrides_Call) Run(run func()) *TaskExecutionMetadata_GetOverrides_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionMetadata_GetOverrides_Call) Return(_a0 core.TaskOverrides) *TaskExecutionMetadata_GetOverrides_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionMetadata_GetOverrides_Call) RunAndReturn(run func() core.TaskOverrides) *TaskExecutionMetadata_GetOverrides_Call { + _c.Call.Return(run) + return _c +} + +// GetOwnerID provides a mock function with no fields +func (_m *TaskExecutionMetadata) GetOwnerID() types.NamespacedName { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetOwnerID") + } + + var r0 types.NamespacedName + if rf, ok := ret.Get(0).(func() types.NamespacedName); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(types.NamespacedName) + } + + return r0 +} + +// TaskExecutionMetadata_GetOwnerID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOwnerID' +type TaskExecutionMetadata_GetOwnerID_Call struct { + *mock.Call +} + +// GetOwnerID is a helper method to define mock.On call +func (_e *TaskExecutionMetadata_Expecter) GetOwnerID() *TaskExecutionMetadata_GetOwnerID_Call { + return &TaskExecutionMetadata_GetOwnerID_Call{Call: _e.mock.On("GetOwnerID")} +} + +func (_c *TaskExecutionMetadata_GetOwnerID_Call) Run(run func()) *TaskExecutionMetadata_GetOwnerID_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionMetadata_GetOwnerID_Call) Return(_a0 types.NamespacedName) *TaskExecutionMetadata_GetOwnerID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionMetadata_GetOwnerID_Call) RunAndReturn(run func() types.NamespacedName) *TaskExecutionMetadata_GetOwnerID_Call { + _c.Call.Return(run) + return _c +} + +// GetOwnerReference provides a mock function with no fields +func (_m *TaskExecutionMetadata) GetOwnerReference() v1.OwnerReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetOwnerReference") + } + + var r0 v1.OwnerReference + if rf, ok := ret.Get(0).(func() v1.OwnerReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(v1.OwnerReference) + } + + return r0 +} + +// TaskExecutionMetadata_GetOwnerReference_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOwnerReference' +type TaskExecutionMetadata_GetOwnerReference_Call struct { + *mock.Call +} + +// GetOwnerReference is a helper method to define mock.On call +func (_e *TaskExecutionMetadata_Expecter) GetOwnerReference() *TaskExecutionMetadata_GetOwnerReference_Call { + return &TaskExecutionMetadata_GetOwnerReference_Call{Call: _e.mock.On("GetOwnerReference")} +} + +func (_c *TaskExecutionMetadata_GetOwnerReference_Call) Run(run func()) *TaskExecutionMetadata_GetOwnerReference_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionMetadata_GetOwnerReference_Call) Return(_a0 v1.OwnerReference) *TaskExecutionMetadata_GetOwnerReference_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionMetadata_GetOwnerReference_Call) RunAndReturn(run func() v1.OwnerReference) *TaskExecutionMetadata_GetOwnerReference_Call { + _c.Call.Return(run) + return _c +} + +// GetPlatformResources provides a mock function with no fields +func (_m *TaskExecutionMetadata) GetPlatformResources() *corev1.ResourceRequirements { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPlatformResources") + } + + var r0 *corev1.ResourceRequirements + if rf, ok := ret.Get(0).(func() *corev1.ResourceRequirements); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.ResourceRequirements) + } + } + + return r0 +} + +// TaskExecutionMetadata_GetPlatformResources_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPlatformResources' +type TaskExecutionMetadata_GetPlatformResources_Call struct { + *mock.Call +} + +// GetPlatformResources is a helper method to define mock.On call +func (_e *TaskExecutionMetadata_Expecter) GetPlatformResources() *TaskExecutionMetadata_GetPlatformResources_Call { + return &TaskExecutionMetadata_GetPlatformResources_Call{Call: _e.mock.On("GetPlatformResources")} +} + +func (_c *TaskExecutionMetadata_GetPlatformResources_Call) Run(run func()) *TaskExecutionMetadata_GetPlatformResources_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionMetadata_GetPlatformResources_Call) Return(_a0 *corev1.ResourceRequirements) *TaskExecutionMetadata_GetPlatformResources_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionMetadata_GetPlatformResources_Call) RunAndReturn(run func() *corev1.ResourceRequirements) *TaskExecutionMetadata_GetPlatformResources_Call { + _c.Call.Return(run) + return _c +} + +// GetSecurityContext provides a mock function with no fields +func (_m *TaskExecutionMetadata) GetSecurityContext() flyteidl2core.SecurityContext { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetSecurityContext") + } + + var r0 flyteidl2core.SecurityContext + if rf, ok := ret.Get(0).(func() flyteidl2core.SecurityContext); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(flyteidl2core.SecurityContext) + } + + return r0 +} + +// TaskExecutionMetadata_GetSecurityContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSecurityContext' +type TaskExecutionMetadata_GetSecurityContext_Call struct { + *mock.Call +} + +// GetSecurityContext is a helper method to define mock.On call +func (_e *TaskExecutionMetadata_Expecter) GetSecurityContext() *TaskExecutionMetadata_GetSecurityContext_Call { + return &TaskExecutionMetadata_GetSecurityContext_Call{Call: _e.mock.On("GetSecurityContext")} +} + +func (_c *TaskExecutionMetadata_GetSecurityContext_Call) Run(run func()) *TaskExecutionMetadata_GetSecurityContext_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionMetadata_GetSecurityContext_Call) Return(_a0 flyteidl2core.SecurityContext) *TaskExecutionMetadata_GetSecurityContext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionMetadata_GetSecurityContext_Call) RunAndReturn(run func() flyteidl2core.SecurityContext) *TaskExecutionMetadata_GetSecurityContext_Call { + _c.Call.Return(run) + return _c +} + +// GetTaskExecutionID provides a mock function with no fields +func (_m *TaskExecutionMetadata) GetTaskExecutionID() core.TaskExecutionID { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetTaskExecutionID") + } + + var r0 core.TaskExecutionID + if rf, ok := ret.Get(0).(func() core.TaskExecutionID); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.TaskExecutionID) + } + } + + return r0 +} + +// TaskExecutionMetadata_GetTaskExecutionID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTaskExecutionID' +type TaskExecutionMetadata_GetTaskExecutionID_Call struct { + *mock.Call +} + +// GetTaskExecutionID is a helper method to define mock.On call +func (_e *TaskExecutionMetadata_Expecter) GetTaskExecutionID() *TaskExecutionMetadata_GetTaskExecutionID_Call { + return &TaskExecutionMetadata_GetTaskExecutionID_Call{Call: _e.mock.On("GetTaskExecutionID")} +} + +func (_c *TaskExecutionMetadata_GetTaskExecutionID_Call) Run(run func()) *TaskExecutionMetadata_GetTaskExecutionID_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionMetadata_GetTaskExecutionID_Call) Return(_a0 core.TaskExecutionID) *TaskExecutionMetadata_GetTaskExecutionID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionMetadata_GetTaskExecutionID_Call) RunAndReturn(run func() core.TaskExecutionID) *TaskExecutionMetadata_GetTaskExecutionID_Call { + _c.Call.Return(run) + return _c +} + +// IsInterruptible provides a mock function with no fields +func (_m *TaskExecutionMetadata) IsInterruptible() bool { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for IsInterruptible") + } + + var r0 bool + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// TaskExecutionMetadata_IsInterruptible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsInterruptible' +type TaskExecutionMetadata_IsInterruptible_Call struct { + *mock.Call +} + +// IsInterruptible is a helper method to define mock.On call +func (_e *TaskExecutionMetadata_Expecter) IsInterruptible() *TaskExecutionMetadata_IsInterruptible_Call { + return &TaskExecutionMetadata_IsInterruptible_Call{Call: _e.mock.On("IsInterruptible")} +} + +func (_c *TaskExecutionMetadata_IsInterruptible_Call) Run(run func()) *TaskExecutionMetadata_IsInterruptible_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskExecutionMetadata_IsInterruptible_Call) Return(_a0 bool) *TaskExecutionMetadata_IsInterruptible_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskExecutionMetadata_IsInterruptible_Call) RunAndReturn(run func() bool) *TaskExecutionMetadata_IsInterruptible_Call { + _c.Call.Return(run) + return _c +} + +// NewTaskExecutionMetadata creates a new instance of TaskExecutionMetadata. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTaskExecutionMetadata(t interface { + mock.TestingT + Cleanup(func()) +}) *TaskExecutionMetadata { + mock := &TaskExecutionMetadata{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/task_overrides.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/task_overrides.go new file mode 100644 index 0000000000..6ae7d4498e --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/task_overrides.go @@ -0,0 +1,317 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + flyteidl2core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + mock "github.com/stretchr/testify/mock" + + v1 "k8s.io/api/core/v1" +) + +// TaskOverrides is an autogenerated mock type for the TaskOverrides type +type TaskOverrides struct { + mock.Mock +} + +type TaskOverrides_Expecter struct { + mock *mock.Mock +} + +func (_m *TaskOverrides) EXPECT() *TaskOverrides_Expecter { + return &TaskOverrides_Expecter{mock: &_m.Mock} +} + +// GetConfig provides a mock function with no fields +func (_m *TaskOverrides) GetConfig() map[string]string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetConfig") + } + + var r0 map[string]string + if rf, ok := ret.Get(0).(func() map[string]string); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[string]string) + } + } + + return r0 +} + +// TaskOverrides_GetConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConfig' +type TaskOverrides_GetConfig_Call struct { + *mock.Call +} + +// GetConfig is a helper method to define mock.On call +func (_e *TaskOverrides_Expecter) GetConfig() *TaskOverrides_GetConfig_Call { + return &TaskOverrides_GetConfig_Call{Call: _e.mock.On("GetConfig")} +} + +func (_c *TaskOverrides_GetConfig_Call) Run(run func()) *TaskOverrides_GetConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskOverrides_GetConfig_Call) Return(_a0 map[string]string) *TaskOverrides_GetConfig_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskOverrides_GetConfig_Call) RunAndReturn(run func() map[string]string) *TaskOverrides_GetConfig_Call { + _c.Call.Return(run) + return _c +} + +// GetConfigMap provides a mock function with no fields +func (_m *TaskOverrides) GetConfigMap() *v1.ConfigMap { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetConfigMap") + } + + var r0 *v1.ConfigMap + if rf, ok := ret.Get(0).(func() *v1.ConfigMap); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v1.ConfigMap) + } + } + + return r0 +} + +// TaskOverrides_GetConfigMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConfigMap' +type TaskOverrides_GetConfigMap_Call struct { + *mock.Call +} + +// GetConfigMap is a helper method to define mock.On call +func (_e *TaskOverrides_Expecter) GetConfigMap() *TaskOverrides_GetConfigMap_Call { + return &TaskOverrides_GetConfigMap_Call{Call: _e.mock.On("GetConfigMap")} +} + +func (_c *TaskOverrides_GetConfigMap_Call) Run(run func()) *TaskOverrides_GetConfigMap_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskOverrides_GetConfigMap_Call) Return(_a0 *v1.ConfigMap) *TaskOverrides_GetConfigMap_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskOverrides_GetConfigMap_Call) RunAndReturn(run func() *v1.ConfigMap) *TaskOverrides_GetConfigMap_Call { + _c.Call.Return(run) + return _c +} + +// GetContainerImage provides a mock function with no fields +func (_m *TaskOverrides) GetContainerImage() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetContainerImage") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// TaskOverrides_GetContainerImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetContainerImage' +type TaskOverrides_GetContainerImage_Call struct { + *mock.Call +} + +// GetContainerImage is a helper method to define mock.On call +func (_e *TaskOverrides_Expecter) GetContainerImage() *TaskOverrides_GetContainerImage_Call { + return &TaskOverrides_GetContainerImage_Call{Call: _e.mock.On("GetContainerImage")} +} + +func (_c *TaskOverrides_GetContainerImage_Call) Run(run func()) *TaskOverrides_GetContainerImage_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskOverrides_GetContainerImage_Call) Return(_a0 string) *TaskOverrides_GetContainerImage_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskOverrides_GetContainerImage_Call) RunAndReturn(run func() string) *TaskOverrides_GetContainerImage_Call { + _c.Call.Return(run) + return _c +} + +// GetExtendedResources provides a mock function with no fields +func (_m *TaskOverrides) GetExtendedResources() *flyteidl2core.ExtendedResources { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetExtendedResources") + } + + var r0 *flyteidl2core.ExtendedResources + if rf, ok := ret.Get(0).(func() *flyteidl2core.ExtendedResources); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flyteidl2core.ExtendedResources) + } + } + + return r0 +} + +// TaskOverrides_GetExtendedResources_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetExtendedResources' +type TaskOverrides_GetExtendedResources_Call struct { + *mock.Call +} + +// GetExtendedResources is a helper method to define mock.On call +func (_e *TaskOverrides_Expecter) GetExtendedResources() *TaskOverrides_GetExtendedResources_Call { + return &TaskOverrides_GetExtendedResources_Call{Call: _e.mock.On("GetExtendedResources")} +} + +func (_c *TaskOverrides_GetExtendedResources_Call) Run(run func()) *TaskOverrides_GetExtendedResources_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskOverrides_GetExtendedResources_Call) Return(_a0 *flyteidl2core.ExtendedResources) *TaskOverrides_GetExtendedResources_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskOverrides_GetExtendedResources_Call) RunAndReturn(run func() *flyteidl2core.ExtendedResources) *TaskOverrides_GetExtendedResources_Call { + _c.Call.Return(run) + return _c +} + +// GetPodTemplate provides a mock function with no fields +func (_m *TaskOverrides) GetPodTemplate() *flyteidl2core.K8SPod { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPodTemplate") + } + + var r0 *flyteidl2core.K8SPod + if rf, ok := ret.Get(0).(func() *flyteidl2core.K8SPod); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flyteidl2core.K8SPod) + } + } + + return r0 +} + +// TaskOverrides_GetPodTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPodTemplate' +type TaskOverrides_GetPodTemplate_Call struct { + *mock.Call +} + +// GetPodTemplate is a helper method to define mock.On call +func (_e *TaskOverrides_Expecter) GetPodTemplate() *TaskOverrides_GetPodTemplate_Call { + return &TaskOverrides_GetPodTemplate_Call{Call: _e.mock.On("GetPodTemplate")} +} + +func (_c *TaskOverrides_GetPodTemplate_Call) Run(run func()) *TaskOverrides_GetPodTemplate_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskOverrides_GetPodTemplate_Call) Return(_a0 *flyteidl2core.K8SPod) *TaskOverrides_GetPodTemplate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskOverrides_GetPodTemplate_Call) RunAndReturn(run func() *flyteidl2core.K8SPod) *TaskOverrides_GetPodTemplate_Call { + _c.Call.Return(run) + return _c +} + +// GetResources provides a mock function with no fields +func (_m *TaskOverrides) GetResources() *v1.ResourceRequirements { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetResources") + } + + var r0 *v1.ResourceRequirements + if rf, ok := ret.Get(0).(func() *v1.ResourceRequirements); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v1.ResourceRequirements) + } + } + + return r0 +} + +// TaskOverrides_GetResources_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResources' +type TaskOverrides_GetResources_Call struct { + *mock.Call +} + +// GetResources is a helper method to define mock.On call +func (_e *TaskOverrides_Expecter) GetResources() *TaskOverrides_GetResources_Call { + return &TaskOverrides_GetResources_Call{Call: _e.mock.On("GetResources")} +} + +func (_c *TaskOverrides_GetResources_Call) Run(run func()) *TaskOverrides_GetResources_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskOverrides_GetResources_Call) Return(_a0 *v1.ResourceRequirements) *TaskOverrides_GetResources_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskOverrides_GetResources_Call) RunAndReturn(run func() *v1.ResourceRequirements) *TaskOverrides_GetResources_Call { + _c.Call.Return(run) + return _c +} + +// NewTaskOverrides creates a new instance of TaskOverrides. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTaskOverrides(t interface { + mock.TestingT + Cleanup(func()) +}) *TaskOverrides { + mock := &TaskOverrides{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/task_reader.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/task_reader.go new file mode 100644 index 0000000000..4305eae7eb --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/task_reader.go @@ -0,0 +1,154 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + flyteidl2core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + + mock "github.com/stretchr/testify/mock" + + storage "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + +// TaskReader is an autogenerated mock type for the TaskReader type +type TaskReader struct { + mock.Mock +} + +type TaskReader_Expecter struct { + mock *mock.Mock +} + +func (_m *TaskReader) EXPECT() *TaskReader_Expecter { + return &TaskReader_Expecter{mock: &_m.Mock} +} + +// Path provides a mock function with given fields: ctx +func (_m *TaskReader) Path(ctx context.Context) (storage.DataReference, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Path") + } + + var r0 storage.DataReference + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (storage.DataReference, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) storage.DataReference); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TaskReader_Path_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Path' +type TaskReader_Path_Call struct { + *mock.Call +} + +// Path is a helper method to define mock.On call +// - ctx context.Context +func (_e *TaskReader_Expecter) Path(ctx interface{}) *TaskReader_Path_Call { + return &TaskReader_Path_Call{Call: _e.mock.On("Path", ctx)} +} + +func (_c *TaskReader_Path_Call) Run(run func(ctx context.Context)) *TaskReader_Path_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *TaskReader_Path_Call) Return(_a0 storage.DataReference, _a1 error) *TaskReader_Path_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TaskReader_Path_Call) RunAndReturn(run func(context.Context) (storage.DataReference, error)) *TaskReader_Path_Call { + _c.Call.Return(run) + return _c +} + +// Read provides a mock function with given fields: ctx +func (_m *TaskReader) Read(ctx context.Context) (*flyteidl2core.TaskTemplate, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Read") + } + + var r0 *flyteidl2core.TaskTemplate + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (*flyteidl2core.TaskTemplate, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) *flyteidl2core.TaskTemplate); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flyteidl2core.TaskTemplate) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TaskReader_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read' +type TaskReader_Read_Call struct { + *mock.Call +} + +// Read is a helper method to define mock.On call +// - ctx context.Context +func (_e *TaskReader_Expecter) Read(ctx interface{}) *TaskReader_Read_Call { + return &TaskReader_Read_Call{Call: _e.mock.On("Read", ctx)} +} + +func (_c *TaskReader_Read_Call) Run(run func(ctx context.Context)) *TaskReader_Read_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *TaskReader_Read_Call) Return(_a0 *flyteidl2core.TaskTemplate, _a1 error) *TaskReader_Read_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TaskReader_Read_Call) RunAndReturn(run func(context.Context) (*flyteidl2core.TaskTemplate, error)) *TaskReader_Read_Call { + _c.Call.Return(run) + return _c +} + +// NewTaskReader creates a new instance of TaskReader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTaskReader(t interface { + mock.TestingT + Cleanup(func()) +}) *TaskReader { + mock := &TaskReader{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/mocks/task_template_path.go b/flyteplugins/go/tasks/pluginmachinery/core/mocks/task_template_path.go new file mode 100644 index 0000000000..7084081ee1 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/mocks/task_template_path.go @@ -0,0 +1,94 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + + storage "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + +// TaskTemplatePath is an autogenerated mock type for the TaskTemplatePath type +type TaskTemplatePath struct { + mock.Mock +} + +type TaskTemplatePath_Expecter struct { + mock *mock.Mock +} + +func (_m *TaskTemplatePath) EXPECT() *TaskTemplatePath_Expecter { + return &TaskTemplatePath_Expecter{mock: &_m.Mock} +} + +// Path provides a mock function with given fields: ctx +func (_m *TaskTemplatePath) Path(ctx context.Context) (storage.DataReference, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Path") + } + + var r0 storage.DataReference + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (storage.DataReference, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) storage.DataReference); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TaskTemplatePath_Path_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Path' +type TaskTemplatePath_Path_Call struct { + *mock.Call +} + +// Path is a helper method to define mock.On call +// - ctx context.Context +func (_e *TaskTemplatePath_Expecter) Path(ctx interface{}) *TaskTemplatePath_Path_Call { + return &TaskTemplatePath_Path_Call{Call: _e.mock.On("Path", ctx)} +} + +func (_c *TaskTemplatePath_Path_Call) Run(run func(ctx context.Context)) *TaskTemplatePath_Path_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *TaskTemplatePath_Path_Call) Return(_a0 storage.DataReference, _a1 error) *TaskTemplatePath_Path_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TaskTemplatePath_Path_Call) RunAndReturn(run func(context.Context) (storage.DataReference, error)) *TaskTemplatePath_Path_Call { + _c.Call.Return(run) + return _c +} + +// NewTaskTemplatePath creates a new instance of TaskTemplatePath. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTaskTemplatePath(t interface { + mock.TestingT + Cleanup(func()) +}) *TaskTemplatePath { + mock := &TaskTemplatePath{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/phase.go b/flyteplugins/go/tasks/pluginmachinery/core/phase.go new file mode 100644 index 0000000000..7ede39b4c2 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/phase.go @@ -0,0 +1,312 @@ +package core + +import ( + "fmt" + "time" + + structpb "github.com/golang/protobuf/ptypes/struct" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const DefaultPhaseVersion = uint32(0) +const SystemErrorCode = "SystemError" + +//go:generate enumer -type=Phase + +type Phase int8 + +const ( + // Does not mean an error, but simply states that we dont know the state in this round, try again later. But can be used to signal a system error too + PhaseUndefined Phase = iota + PhaseNotReady + // Indicates plugin is not ready to submit the request as it is waiting for resources + PhaseWaitingForResources + // Indicates plugin has submitted the execution, but it has not started executing yet + PhaseQueued + // The system has started the pre-execution process, like container download, cluster startup etc + PhaseInitializing + // Indicates that the task has started executing + PhaseRunning + // Indicates that the task has completed successfully + PhaseSuccess + // Indicates that the Failure is recoverable, by re-executing the task if retries permit + PhaseRetryableFailure + // Indicate that the failure is non recoverable even if retries exist + PhasePermanentFailure + // Indicates the task is waiting for the cache to be populated so it can reuse results + PhaseWaitingForCache + // Indicate the task has been aborted + PhaseAborted +) + +var Phases = []Phase{ + PhaseUndefined, + PhaseNotReady, + PhaseWaitingForResources, + PhaseQueued, + PhaseInitializing, + PhaseRunning, + PhaseSuccess, + PhaseRetryableFailure, + PhasePermanentFailure, + PhaseWaitingForCache, + PhaseAborted, +} + +// Returns true if the given phase is failure, retryable failure or success +func (p Phase) IsTerminal() bool { + return p.IsFailure() || p.IsSuccess() || p.IsAborted() +} + +func (p Phase) IsFailure() bool { + return p == PhasePermanentFailure || p == PhaseRetryableFailure +} + +func (p Phase) IsSuccess() bool { + return p == PhaseSuccess +} + +func (p Phase) IsAborted() bool { + return p == PhaseAborted +} + +func (p Phase) IsWaitingForResources() bool { + return p == PhaseWaitingForResources +} + +type ExternalResource struct { + // A unique identifier for the external resource + ExternalID string + // Captures the status of caching for this external resource + CacheStatus core.CatalogCacheStatus + // A unique index for the external resource. Although the ID may change, this will remain the same + // throughout task event reports and retries. + Index uint32 + // Log information for the external resource + Logs []*core.TaskLog + // Contains metadata required to identify logs related to this task execution + LogContext *core.LogContext + // The number of times this external resource has been attempted + RetryAttempt uint32 + // Phase (if exists) associated with the external resource + Phase Phase + // Extensible field for custom, plugin-specific info + CustomInfo *structpb.Struct +} + +type ReasonInfo struct { + Reason string + OccurredAt *time.Time +} + +type TaskInfo struct { + // log information for the task execution + Logs []*core.TaskLog + // Contains metadata required to identify logs related to this task execution + LogContext *core.LogContext + // This value represents the time the status occurred at. If not provided, it will be defaulted to the time Flyte + // checked the task status. + OccurredAt *time.Time + // This value represents the time the status was reported at. If not provided, will be defaulted to the current time + // when Flyte published the event. + ReportedAt *time.Time + // Custom Event information that the plugin would like to expose to the front-end + CustomInfo *structpb.Struct + // A collection of information about external resources launched by this task + ExternalResources []*ExternalResource + // Additional reasons for this case. Note, these are not included in the phase state. + AdditionalReasons []ReasonInfo +} + +func (t *TaskInfo) String() string { + return fmt.Sprintf("Info<@%s>", t.OccurredAt.String()) +} + +// Additional info that should be sent to the front end. The Information is sent to the front-end if it meets certain +// criterion, for example currently, it is sent only if an event was not already sent for +type PhaseInfo struct { + // Observed Phase of the launched Task execution + phase Phase + // Phase version. by default this can be left as empty => 0. This can be used if there is some additional information + // to be provided to the Control plane. Phase information is immutable in control plane for a given Phase, unless + // a new version is provided. + version uint32 + // In case info needs to be provided + info *TaskInfo + // If only an error is observed. It is complementary to info + err *core.ExecutionError + // reason why the current phase exists. + reason string + // cleanupOnFailure indicates that this task should be cleaned up even though the phase indicates a failure. This + // applies to situations where a task is marked a failure but is still running, for example an ImagePullBackoff in + // a k8s Pod where the image does not exist will continually reattempt the pull even though it will never succeed. + cleanupOnFailure bool +} + +func (p PhaseInfo) Phase() Phase { + return p.phase +} + +func (p PhaseInfo) Version() uint32 { + return p.version +} + +func (p PhaseInfo) Reason() string { + return p.reason +} + +func (p PhaseInfo) Info() *TaskInfo { + return p.info +} + +func (p PhaseInfo) Err() *core.ExecutionError { + return p.err +} + +func (p PhaseInfo) CleanupOnFailure() bool { + return p.cleanupOnFailure +} + +func (p PhaseInfo) WithVersion(version uint32) PhaseInfo { + return PhaseInfo{ + phase: p.phase, + version: version, + info: p.info, + err: p.err, + reason: p.reason, + } +} + +func (p *PhaseInfo) WithReason(reason string) { + if p.reason != "" { + p.reason += ", " + reason + } else { + p.reason = reason + } +} + +func (p PhaseInfo) String() string { + if p.err != nil { + return fmt.Sprintf("Phase<%s:%d Error:%s>", p.phase, p.version, p.err) + } + return fmt.Sprintf("Phase<%s:%d %s Reason:%s>", p.phase, p.version, p.info, p.reason) +} + +// PhaseInfoUndefined should be used when the Phase is unknown usually associated with an error +var PhaseInfoUndefined = PhaseInfo{phase: PhaseUndefined} + +func phaseInfo(p Phase, v uint32, err *core.ExecutionError, info *TaskInfo, cleanupOnFailure bool) PhaseInfo { + if info == nil { + info = &TaskInfo{} + } + if info.OccurredAt == nil { + t := time.Now() + info.OccurredAt = &t + } + return PhaseInfo{ + phase: p, + version: v, + info: info, + err: err, + cleanupOnFailure: cleanupOnFailure, + } +} + +// PhaseInfoNotReady represents the case the plugin is not ready to start +func PhaseInfoNotReady(t time.Time, version uint32, reason string) PhaseInfo { + pi := phaseInfo(PhaseNotReady, version, nil, &TaskInfo{OccurredAt: &t}, false) + pi.reason = reason + return pi +} + +// Deprecated: Please use PhaseInfoWaitingForResourcesInfo instead +func PhaseInfoWaitingForResources(t time.Time, version uint32, reason string) PhaseInfo { + pi := phaseInfo(PhaseWaitingForResources, version, nil, &TaskInfo{OccurredAt: &t}, false) + pi.reason = reason + return pi +} + +// PhaseInfoWaitingForResourcesInfo represents the case the plugin is not ready to start +func PhaseInfoWaitingForResourcesInfo(t time.Time, version uint32, reason string, info *TaskInfo) PhaseInfo { + pi := phaseInfo(PhaseWaitingForResources, version, nil, info, false) + pi.reason = reason + return pi +} + +func PhaseInfoQueued(t time.Time, version uint32, reason string) PhaseInfo { + pi := phaseInfo(PhaseQueued, version, nil, &TaskInfo{OccurredAt: &t}, false) + pi.reason = reason + return pi +} + +func PhaseInfoQueuedWithTaskInfo(t time.Time, version uint32, reason string, info *TaskInfo) PhaseInfo { + pi := phaseInfo(PhaseQueued, version, nil, info, false) + pi.reason = reason + return pi +} + +func PhaseInfoInitializing(t time.Time, version uint32, reason string, info *TaskInfo) PhaseInfo { + pi := phaseInfo(PhaseInitializing, version, nil, info, false) + pi.reason = reason + return pi +} + +func phaseInfoFailed(p Phase, err *core.ExecutionError, info *TaskInfo, cleanupOnFailure bool) PhaseInfo { + if err == nil { + err = &core.ExecutionError{ + Code: "Unknown", + Message: "Unknown error message", + } + } + return phaseInfo(p, DefaultPhaseVersion, err, info, cleanupOnFailure) +} + +func PhaseInfoFailed(p Phase, err *core.ExecutionError, info *TaskInfo) PhaseInfo { + return phaseInfo(p, DefaultPhaseVersion, err, info, false) +} + +func PhaseInfoRunning(version uint32, info *TaskInfo) PhaseInfo { + return phaseInfo(PhaseRunning, version, nil, info, false) +} + +func PhaseInfoSuccess(info *TaskInfo) PhaseInfo { + return phaseInfo(PhaseSuccess, DefaultPhaseVersion, nil, info, false) +} + +func PhaseInfoSystemFailure(code, reason string, info *TaskInfo) PhaseInfo { + return phaseInfoFailed(PhasePermanentFailure, &core.ExecutionError{Code: code, Message: reason, Kind: core.ExecutionError_SYSTEM}, info, false) +} + +func PhaseInfoSystemFailureWithCleanup(code, reason string, info *TaskInfo) PhaseInfo { + return phaseInfoFailed(PhasePermanentFailure, &core.ExecutionError{Code: code, Message: reason, Kind: core.ExecutionError_SYSTEM}, info, true) +} + +func PhaseInfoFailure(code, reason string, info *TaskInfo) PhaseInfo { + return phaseInfoFailed(PhasePermanentFailure, &core.ExecutionError{Code: code, Message: reason, Kind: core.ExecutionError_USER}, info, false) +} + +func PhaseInfoFailureWithCleanup(code, reason string, info *TaskInfo) PhaseInfo { + return phaseInfoFailed(PhasePermanentFailure, &core.ExecutionError{Code: code, Message: reason, Kind: core.ExecutionError_USER}, info, true) +} + +func PhaseInfoRetryableFailure(code, reason string, info *TaskInfo) PhaseInfo { + return phaseInfoFailed(PhaseRetryableFailure, &core.ExecutionError{Code: code, Message: reason, Kind: core.ExecutionError_USER}, info, false) +} + +func PhaseInfoRetryableFailureWithCleanup(code, reason string, info *TaskInfo) PhaseInfo { + return phaseInfoFailed(PhaseRetryableFailure, &core.ExecutionError{Code: code, Message: reason, Kind: core.ExecutionError_USER}, info, true) +} + +func PhaseInfoSystemRetryableFailure(code, reason string, info *TaskInfo) PhaseInfo { + return phaseInfoFailed(PhaseRetryableFailure, &core.ExecutionError{Code: code, Message: reason, Kind: core.ExecutionError_SYSTEM}, info, false) +} + +func PhaseInfoSystemRetryableFailureWithCleanup(code, reason string, info *TaskInfo) PhaseInfo { + return phaseInfoFailed(PhaseRetryableFailure, &core.ExecutionError{Code: code, Message: reason, Kind: core.ExecutionError_SYSTEM}, info, true) +} + +// Creates a new PhaseInfo with phase set to PhaseWaitingForCache +func PhaseInfoWaitingForCache(version uint32, info *TaskInfo) PhaseInfo { + return phaseInfo(PhaseWaitingForCache, version, nil, info, false) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/phase_enumer.go b/flyteplugins/go/tasks/pluginmachinery/core/phase_enumer.go new file mode 100644 index 0000000000..caa4d86250 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/phase_enumer.go @@ -0,0 +1,58 @@ +// Code generated by "enumer -type=Phase"; DO NOT EDIT. + +package core + +import ( + "fmt" +) + +const _PhaseName = "PhaseUndefinedPhaseNotReadyPhaseWaitingForResourcesPhaseQueuedPhaseInitializingPhaseRunningPhaseSuccessPhaseRetryableFailurePhasePermanentFailurePhaseWaitingForCachePhaseAborted" + +var _PhaseIndex = [...]uint8{0, 14, 27, 51, 62, 79, 91, 103, 124, 145, 165, 177} + +func (i Phase) String() string { + if i < 0 || i >= Phase(len(_PhaseIndex)-1) { + return fmt.Sprintf("Phase(%d)", i) + } + return _PhaseName[_PhaseIndex[i]:_PhaseIndex[i+1]] +} + +var _PhaseValues = []Phase{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10} + +var _PhaseNameToValueMap = map[string]Phase{ + _PhaseName[0:14]: 0, + _PhaseName[14:27]: 1, + _PhaseName[27:51]: 2, + _PhaseName[51:62]: 3, + _PhaseName[62:79]: 4, + _PhaseName[79:91]: 5, + _PhaseName[91:103]: 6, + _PhaseName[103:124]: 7, + _PhaseName[124:145]: 8, + _PhaseName[145:165]: 9, + _PhaseName[165:177]: 10, +} + +// PhaseString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func PhaseString(s string) (Phase, error) { + if val, ok := _PhaseNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to Phase values", s) +} + +// PhaseValues returns all values of the enum +func PhaseValues() []Phase { + return _PhaseValues +} + +// IsAPhase returns "true" if the value is listed in the enum definition. "false" otherwise +func (i Phase) IsAPhase() bool { + for _, v := range _PhaseValues { + if i == v { + return true + } + } + return false +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/phase_test.go b/flyteplugins/go/tasks/pluginmachinery/core/phase_test.go new file mode 100644 index 0000000000..08dc44fb78 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/phase_test.go @@ -0,0 +1,71 @@ +package core + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestPhaseInfo_WithReason(t *testing.T) { + tests := []struct { + name string + initialReason string + newReason string + expectedReason string + }{ + { + name: "empty initial reason", + initialReason: "", + newReason: "new reason", + expectedReason: "new reason", + }, + { + name: "existing reason gets concatenated", + initialReason: "initial reason", + newReason: "additional reason", + expectedReason: "initial reason, additional reason", + }, + { + name: "multiple concatenations", + initialReason: "first reason, second reason", + newReason: "third reason", + expectedReason: "first reason, second reason, third reason", + }, + { + name: "empty new reason", + initialReason: "existing reason", + newReason: "", + expectedReason: "existing reason, ", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + phaseInfo := PhaseInfo{ + phase: PhaseRunning, + reason: tt.initialReason, + } + + phaseInfo.WithReason(tt.newReason) + + assert.Equal(t, tt.expectedReason, phaseInfo.reason) + }) + } +} + +func TestPhaseInfo_WithReason_DoesNotAffectOtherFields(t *testing.T) { + info := &TaskInfo{} + phaseInfo := PhaseInfo{ + phase: PhaseRunning, + version: 1, + info: info, + reason: "initial", + } + + phaseInfo.WithReason("additional") + + assert.Equal(t, PhaseRunning, phaseInfo.phase) + assert.Equal(t, uint32(1), phaseInfo.version) + assert.Equal(t, info, phaseInfo.info) + assert.Equal(t, "initial, additional", phaseInfo.reason) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/plugin.go b/flyteplugins/go/tasks/pluginmachinery/core/plugin.go new file mode 100644 index 0000000000..5b055a5d98 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/plugin.go @@ -0,0 +1,69 @@ +package core + +import ( + "context" + "fmt" +) + +// https://github.com/flyteorg/flytepropeller/blob/979fabe1d1b22b01645259a03b8096f227681d08/pkg/utils/encoder.go#L25-L26 +const minGeneratedNameLength = 8 + +type TaskType = string + +// A Lazy loading function, that will load the plugin. Plugins should be initialized in this method. It is guaranteed +// that the plugin loader will be called before any Handle/Abort/Finalize functions are invoked +type PluginLoader func(ctx context.Context, iCtx SetupContext) (Plugin, error) + +// An entry that identifies the CorePlugin +type PluginEntry struct { + // System wide unique identifier for the plugin + ID TaskType + // A list of all the task types for which this plugin is applicable. + RegisteredTaskTypes []TaskType + // A Lazy loading function, that will load the plugin. Plugins should be initialized in this method. It is guaranteed + // that the plugin loader will be called before any Handle/Abort/Finalize functions are invoked + LoadPlugin PluginLoader + // Boolean that indicates if this plugin can be used as the default for unknown task types. There can only be + // one default in the system + IsDefault bool +} + +// System level properties that this Plugin supports +type PluginProperties struct { + // Instructs the execution engine to not attempt to cache lookup or write for the node. + DisableNodeLevelCaching bool + // Specifies the length of TaskExecutionID generated name. default: 50 + GeneratedNameMaxLength *int +} + +// Interface for the core Flyte plugin +type Plugin interface { + // Unique ID for the plugin, should be ideally the same the ID in PluginEntry + GetID() string + // Properties desired by the plugin from the available set + GetProperties() PluginProperties + // The actual method that is invoked for every single task execution. The method should be a non blocking method. + // It maybe invoked multiple times and hence all actions should be idempotent. If idempotency is not possible look at + // Transitions to get some system level guarantees + Handle(ctx context.Context, tCtx TaskExecutionContext) (Transition, error) + // Called when the task is to be killed/aborted, because the top level entity was aborted or some other failure happened. + // Abort should always be idempotent + Abort(ctx context.Context, tCtx TaskExecutionContext) error + // Finalize is always called, after Handle or Abort. Finalize should be an idempotent operation + Finalize(ctx context.Context, tCtx TaskExecutionContext) error +} + +// LoadPlugin Loads and validates a plugin. +func LoadPlugin(ctx context.Context, iCtx SetupContext, entry PluginEntry) (Plugin, error) { + plugin, err := entry.LoadPlugin(ctx, iCtx) + if err != nil { + return nil, err + } + + length := plugin.GetProperties().GeneratedNameMaxLength + if length != nil && *length < minGeneratedNameLength { + return nil, fmt.Errorf("GeneratedNameMaxLength needs to be greater then %d", minGeneratedNameLength) + } + + return plugin, err +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/plugin_test.go b/flyteplugins/go/tasks/pluginmachinery/core/plugin_test.go new file mode 100644 index 0000000000..7363973fdf --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/plugin_test.go @@ -0,0 +1,95 @@ +package core_test + +import ( + "context" + "testing" + + "gotest.tools/assert" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" +) + +func TestLoadPlugin(t *testing.T) { + corePluginType := "core" + + t.Run("valid", func(t *testing.T) { + corePlugin := &mocks.Plugin{} + corePlugin.EXPECT().GetID().Return(corePluginType) + corePlugin.EXPECT().GetProperties().Return(core.PluginProperties{}) + + corePluginEntry := core.PluginEntry{ + ID: corePluginType, + RegisteredTaskTypes: []core.TaskType{corePluginType}, + LoadPlugin: func(ctx context.Context, iCtx core.SetupContext) (core.Plugin, error) { + return corePlugin, nil + }, + } + setupCtx := mocks.SetupContext{} + p, err := core.LoadPlugin(context.TODO(), &setupCtx, corePluginEntry) + assert.NilError(t, err) + assert.Equal(t, corePluginType, p.GetID()) + }) + + t.Run("valid GeneratedNameMaxLength", func(t *testing.T) { + corePlugin := &mocks.Plugin{} + corePlugin.EXPECT().GetID().Return(corePluginType) + length := 10 + corePlugin.EXPECT().GetProperties().Return(core.PluginProperties{ + GeneratedNameMaxLength: &length, + }) + + corePluginEntry := core.PluginEntry{ + ID: corePluginType, + RegisteredTaskTypes: []core.TaskType{corePluginType}, + LoadPlugin: func(ctx context.Context, iCtx core.SetupContext) (core.Plugin, error) { + return corePlugin, nil + }, + } + setupCtx := mocks.SetupContext{} + p, err := core.LoadPlugin(context.TODO(), &setupCtx, corePluginEntry) + assert.NilError(t, err) + assert.Equal(t, corePluginType, p.GetID()) + }) + + t.Run("valid GeneratedNameMaxLength", func(t *testing.T) { + corePlugin := &mocks.Plugin{} + corePlugin.EXPECT().GetID().Return(corePluginType) + length := 10 + corePlugin.EXPECT().GetProperties().Return(core.PluginProperties{ + GeneratedNameMaxLength: &length, + }) + + corePluginEntry := core.PluginEntry{ + ID: corePluginType, + RegisteredTaskTypes: []core.TaskType{corePluginType}, + LoadPlugin: func(ctx context.Context, iCtx core.SetupContext) (core.Plugin, error) { + return corePlugin, nil + }, + } + setupCtx := mocks.SetupContext{} + _, err := core.LoadPlugin(context.TODO(), &setupCtx, corePluginEntry) + assert.NilError(t, err) + }) + + t.Run("invalid GeneratedNameMaxLength", func(t *testing.T) { + corePlugin := &mocks.Plugin{} + corePlugin.EXPECT().GetID().Return(corePluginType) + length := 5 + corePlugin.EXPECT().GetProperties().Return(core.PluginProperties{ + GeneratedNameMaxLength: &length, + }) + + corePluginEntry := core.PluginEntry{ + ID: corePluginType, + RegisteredTaskTypes: []core.TaskType{corePluginType}, + LoadPlugin: func(ctx context.Context, iCtx core.SetupContext) (core.Plugin, error) { + return corePlugin, nil + }, + } + setupCtx := mocks.SetupContext{} + _, err := core.LoadPlugin(context.TODO(), &setupCtx, corePluginEntry) + assert.Error(t, err, "GeneratedNameMaxLength needs to be greater then 8") + }) + +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/resource_manager.go b/flyteplugins/go/tasks/pluginmachinery/core/resource_manager.go new file mode 100644 index 0000000000..f16bde9ea0 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/resource_manager.go @@ -0,0 +1,106 @@ +package core + +import ( + "context" +) + +//go:generate enumer -type=AllocationStatus -trimprefix=AllocationStatus + +type AllocationStatus int + +const ( + // This is the enum returned when there's an error + AllocationUndefined AllocationStatus = iota + + // Go for it + AllocationStatusGranted + + // This means that no resources are available globally. This is the only rejection message we use right now. + AllocationStatusExhausted + + // We're not currently using this - but this would indicate that things globally are okay, but that your + // own namespace is too busy + AllocationStatusNamespaceQuotaExceeded +) + +const namespaceSeparator = ":" + +type ResourceNamespace string + +func (r ResourceNamespace) CreateSubNamespace(namespace ResourceNamespace) ResourceNamespace { + return r + namespaceSeparator + namespace +} + +type ResourceRegistrar interface { + RegisterResourceQuota(ctx context.Context, namespace ResourceNamespace, quota int) error +} + +// ResourceManager Interface +// 1. Terms and definitions +// +// - Resource: resource is an abstraction of anything that has a limited quota of units and can be claimed in a +// single unit or multiple units at once. At Flyte's current state, a resource means a logical +// separation (e.g., a cluster) of an external service that allows a limited number of outstanding +// requests to be sent to. +// +// - Token: Flyte uses a token to serve as the placeholder to represent a unit of resource. Flyte resource manager +// manages resources by managing the tokens of the resources. +// +// 2. Description +// ResourceManager provides a task-type-specific pooling system for Flyte Tasks. Plugin writers can optionally +// request for resources in their tasks, in single quantity. +// +// 3. Usage +// A Flyte plugin registers the resources and the desired quota of each resource with ResourceRegistrar at the +// setup time of Flyte Propeller. At the end of the setup time, Flyte Propeller builds a ResourceManager based on +// these registration requests. +// +// During runtime, the ResourceManager does two simple things: allocating tokens and releasing tokens. When a Flyte +// task execution wants to send a request to an external service, the plugin should claim a unit of the corresponding +// resource. Specifically, an execution needs to generate a unique token, and register the token with ResourceManager +// by calling ResourceManager's AllocateResource() function. ResourceManager will check its current utilization and +// the allocation policy to decide whether or not to grant the request. Only when receiving the "AllocationGranted" +// status shall this execution move forward and send out the request. The granted token will be recorded in a token +// pool corresponding to the resource and managed by ResourceManager. When the request is done, the plugin will ask +// the resource manager to release the token by calling ResourceManager's ReleaseResource(), and the token will be +// erased from the corresponding pool. +// +// 4. Example +// Flyte has a built-on Qubole plugin that allows Flyte tasks to send out Hive commands to Qubole. +// In the plugin, a single Qubole cluster is a resource, and sending out a single Hive command to a Qubole cluster consumes +// a token of the corresponding resource. The resource allocation is achieved by the Qubole plugin calling +// status, err := AllocateResource(ctx, , , ) +// and the de-allocation is achieved by the plugin calling +// status, err := AllocateResource(ctx, , , ) +// +// For example, +// status, err := AllocateResource(ctx, "default_cluster", "flkgiwd13-akjdoe-0", ResourceConstraintsSpec{}) +// When the corresponding Hive command finishes, the plugin needs to make the following function call to release +// the corresponding token +// err := ReleaseResource(ctx, "default_cluster", "flkgiwd13-akjdoe-0") +type ResourceManager interface { + GetID() string + // During execution time, plugins can call AllocateResource() to register a token to the token pool associated with a resource with the resource manager. + // If granted an allocation, the token will be recorded in the corresponding token pool until the same plugin releases it. + // When calling AllocateResource, the plugin needs to specify a ResourceConstraintsSpec which contains resource capping constraints at different levels. + // The ResourceConstraint pointers in ResourceConstraintsSpec, however, can be set to nil to present a non-constraint at that level + AllocateResource(ctx context.Context, namespace ResourceNamespace, allocationToken string, constraintsSpec ResourceConstraintsSpec) (AllocationStatus, error) + // During execution time, after an outstanding request is completed, the plugin need to use ReleaseResource() to release the allocation of the corresponding token + // from the token pool in order to gain back the quota taken by the token + ReleaseResource(ctx context.Context, namespace ResourceNamespace, allocationToken string) error +} + +type ResourceConstraint struct { + Value int64 +} + +// ResourceConstraintsSpec is a contract that a plugin can specify with ResourceManager to force runtime quota-allocation constraints +// at different levels. +// +// Setting constraints in a ResourceConstraintsSpec to nil objects is valid, meaning there's no constraint at the corresponding level. +// For example, a ResourceConstraintsSpec with nil ProjectScopeResourceConstraint and a non-nil NamespaceScopeResourceConstraint means +// that it only poses a cap at the namespace level. A zero-value ResourceConstraintsSpec means there's no constraints posed at any level. +type ResourceConstraintsSpec struct { + ProjectScopeResourceConstraint *ResourceConstraint + NamespaceScopeResourceConstraint *ResourceConstraint +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/secret_manager.go b/flyteplugins/go/tasks/pluginmachinery/core/secret_manager.go new file mode 100644 index 0000000000..b3d181c086 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/secret_manager.go @@ -0,0 +1,45 @@ +package core + +import ( + "context" + "fmt" + "unicode/utf8" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" +) + +type SecretManager interface { + Get(ctx context.Context, key string) (string, error) +} + +type EmbeddedSecretManager struct { + secretFetcher secret.SecretFetcher +} + +func (e *EmbeddedSecretManager) Get(ctx context.Context, key string) (string, error) { + secretValue, err := e.secretFetcher.GetSecretValue(ctx, key) + if err != nil { + return "", err + } + + if secretValue.StringValue != "" { + return secretValue.StringValue, nil + } + + // GCP secrets store values as binary only. We could fail this path for AWS, but for + // consistent behaviour between AWS and GCP we will allow this path for AWS as well. + if !utf8.Valid(secretValue.BinaryValue) { + return "", fmt.Errorf("secret %q has a binary value that is not a valid UTF-8 string", key) + } + return string(secretValue.BinaryValue), nil +} + +func NewEmbeddedSecretManager(ctx context.Context, cfg config.EmbeddedSecretManagerConfig) (SecretManager, error) { + secretFetcher, err := secret.NewSecretFetcher(ctx, cfg) + if err != nil { + return nil, err + } + + return &EmbeddedSecretManager{secretFetcher}, nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/setup_context.go b/flyteplugins/go/tasks/pluginmachinery/core/setup_context.go new file mode 100644 index 0000000000..3736cba2e7 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/setup_context.go @@ -0,0 +1,26 @@ +package core + +import ( + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +// When a change is observed, the owning entity can be triggered for re-validation +type EnqueueOwner func(labels map[string]string) error + +// Passed to the Loader function when setting up a plugin +type SetupContext interface { + // returns a callback mechanism that indicates that (workflow, task) is ready to be re-evaluated + EnqueueOwner() EnqueueOwner + // returns a list of labels that should be used to enqueue the owner + IncludeEnqueueLabels() []string + // provides a k8s specific owner kind + OwnerKind() string + // a metrics scope to publish stats under + MetricsScope() promutils.Scope + // A kubernetes client to the bound cluster + KubeClient() KubeClient + // Returns a secret manager that can retrieve configured secrets for this plugin + SecretManager() SecretManager + // Returns a resource negotiator that the plugin can register resource quota against + ResourceRegistrar() ResourceRegistrar +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/state.go b/flyteplugins/go/tasks/pluginmachinery/core/state.go new file mode 100644 index 0000000000..55d8d63862 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/state.go @@ -0,0 +1,19 @@ +package core + +// Write new plugin state for a plugin +type PluginStateWriter interface { + // Only the last call to this method is recorded. All previous calls are overwritten + // This data is also not accessible until the next round. + Put(stateVersion uint8, v interface{}) error + // Resets the state to empty or zero value + Reset() error +} + +// Read previously written plugin state (previous round) +type PluginStateReader interface { + // Retrieve state version that is currently stored + GetStateVersion() uint8 + // Retrieve the typed state in t from the stored value. It also returns the stateversion. + // If there is no state, t will be zero value, stateversion will be 0 + Get(t interface{}) (stateVersion uint8, err error) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/template/template.go b/flyteplugins/go/tasks/pluginmachinery/core/template/template.go new file mode 100644 index 0000000000..7549412e33 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/template/template.go @@ -0,0 +1,243 @@ +// Package template exports the Render method +// Render Evaluates templates in each command with the equivalent value from passed args. Templates are case-insensitive +// Supported templates are: +// - {{ .InputFile }} to receive the input file path. The protocol used will depend on the underlying system +// configuration. E.g. s3://bucket/key/to/file.pb or /var/run/local.pb are both valid. +// - {{ .OutputPrefix }} to receive the path prefix for where to store the outputs. +// - {{ .Inputs.myInput }} to receive the actual value of the input passed. See docs on LiteralMapToTemplateArgs for how +// what to expect each literal type to be serialized as. +// - {{ .RawOutputDataPrefix }} to receive a path where the raw output data should be ideally written. It is guaranteed +// to be unique per retry and finally one will be saved as the output path +// - {{ .PerRetryUniqueKey }} A key/id/str that is generated per retry and is guaranteed to be unique. Useful in query +// manipulations +// - {{ .TaskTemplatePath }} A path in blobstore/metadata store (e.g. s3, gcs etc) to where an offloaded version of the +// task template exists and can be accessed by the container / task execution environment. The template is a +// a serialized protobuf +// - {{ .PrevCheckpointPrefix }} A path to the checkpoint directory for the previous attempt. If this is the first attempt +// then this is replaced by an empty string +// - {{ .CheckpointOutputPrefix }} A Flyte aware path where the current execution should write the checkpoints. +package template + +import ( + "context" + "fmt" + "reflect" + "regexp" + "strings" + + "github.com/golang/protobuf/ptypes" + "github.com/pkg/errors" + "github.com/shamaton/msgpack/v2" + + "github.com/flyteorg/flyte/v2/flyteidl2/clients/go/coreutils" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + idlCore "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +var alphaNumericOnly = regexp.MustCompile("[^a-zA-Z0-9_]+") +var startsWithAlpha = regexp.MustCompile("^[^a-zA-Z_]+") + +// Regexes for Supported templates +var inputFileRegex = regexp.MustCompile(`(?i){{\s*[\.$]Input\s*}}`) +var inputPrefixRegex = regexp.MustCompile(`(?i){{\s*[\.$]InputPrefix\s*}}`) +var outputRegex = regexp.MustCompile(`(?i){{\s*[\.$]OutputPrefix\s*}}`) +var inputVarRegex = regexp.MustCompile(`(?i){{\s*[\.$]Inputs\.(?P[^}\s]+)\s*}}`) +var rawOutputDataPrefixRegex = regexp.MustCompile(`(?i){{\s*[\.$]RawOutputDataPrefix\s*}}`) +var perRetryUniqueKey = regexp.MustCompile(`(?i){{\s*[\.$]PerRetryUniqueKey\s*}}`) +var taskTemplateRegex = regexp.MustCompile(`(?i){{\s*[\.$]TaskTemplatePath\s*}}`) +var prevCheckpointPrefixRegex = regexp.MustCompile(`(?i){{\s*[\.$]PrevCheckpointPrefix\s*}}`) +var currCheckpointPrefixRegex = regexp.MustCompile(`(?i){{\s*[\.$]CheckpointOutputPrefix\s*}}`) +var namespaceRegex = regexp.MustCompile(`(?i){{\s*[\.$]Namespace\s*}}`) + +type ErrorCollection struct { + Errors []error +} + +func (e ErrorCollection) Error() string { + sb := strings.Builder{} + for idx, err := range e.Errors { + sb.WriteString(fmt.Sprintf("%v: %v\r\n", idx, err)) + } + + return sb.String() +} + +// Parameters struct is used by the Templating Engine to replace the templated parameters +type Parameters struct { + TaskExecMetadata core.TaskExecutionMetadata + Inputs io.InputReader + OutputPath io.OutputFilePaths + Task core.TaskTemplatePath + IncludeConsoleURL bool +} + +// Render Evaluates templates in each command with the equivalent value from passed args. Templates are case-insensitive +// If a command isn't a valid template or failed to evaluate, it'll be returned as is. +// Refer to the package docs for a list of supported templates +// NOTE: I wanted to do in-place replacement, until I realized that in-place replacement will alter the definition of the +// graph. This is not desirable, as we may have to retry and in that case the replacement will not work and we want +// to create a new location for outputs +func Render(ctx context.Context, inputTemplate []string, params Parameters) ([]string, error) { + if len(inputTemplate) == 0 { + return []string{}, nil + } + + // TODO: Change GetGeneratedName to follow these conventions + var perRetryUniqueKey = params.TaskExecMetadata.GetTaskExecutionID().GetGeneratedName() + perRetryUniqueKey = startsWithAlpha.ReplaceAllString(perRetryUniqueKey, "a") + perRetryUniqueKey = alphaNumericOnly.ReplaceAllString(perRetryUniqueKey, "_") + + logger.Debugf(ctx, "Using [%s] from [%s]", perRetryUniqueKey, params.TaskExecMetadata.GetTaskExecutionID().GetGeneratedName()) + if params.Inputs == nil || params.OutputPath == nil { + return nil, fmt.Errorf("input reader and output path cannot be nil") + } + res := make([]string, 0, len(inputTemplate)) + for _, t := range inputTemplate { + updated, err := render(ctx, t, params, perRetryUniqueKey) + if err != nil { + return res, err + } + + res = append(res, updated) + } + + return res, nil +} + +func render(ctx context.Context, inputTemplate string, params Parameters, perRetryKey string) (string, error) { + + val := inputFileRegex.ReplaceAllString(inputTemplate, params.Inputs.GetInputPath().String()) + val = outputRegex.ReplaceAllString(val, params.OutputPath.GetOutputPrefixPath().String()) + val = inputPrefixRegex.ReplaceAllString(val, params.Inputs.GetInputPrefixPath().String()) + val = rawOutputDataPrefixRegex.ReplaceAllString(val, params.OutputPath.GetRawOutputPrefix().String()) + prevCheckpoint := params.OutputPath.GetPreviousCheckpointsPrefix().String() + if prevCheckpoint == "" { + prevCheckpoint = "\"\"" + } + val = prevCheckpointPrefixRegex.ReplaceAllString(val, prevCheckpoint) + val = currCheckpointPrefixRegex.ReplaceAllString(val, params.OutputPath.GetCheckpointPrefix().String()) + val = perRetryUniqueKey.ReplaceAllString(val, perRetryKey) + + // For Task template, we will replace only if there is a match. This is because, task template replacement + // may be expensive, as we may offload + if taskTemplateRegex.MatchString(val) { + p, err := params.Task.Path(ctx) + if err != nil { + logger.Debugf(ctx, "Failed to substitute Task Template reference - reason %s", err) + return "", err + } + val = taskTemplateRegex.ReplaceAllString(val, p.String()) + } + + // Replace namespace last, in case it was embedded in other templates + val = namespaceRegex.ReplaceAllString(val, params.TaskExecMetadata.GetNamespace()) + + var errs ErrorCollection + if inputVarRegex.MatchString(val) { + inputs, err := params.Inputs.Get(ctx) + if err != nil { + return val, errors.Wrapf(err, "unable to read inputs") + } + if inputs == nil || inputs.Literals == nil { + return val, nil + } + val = inputVarRegex.ReplaceAllStringFunc(val, func(s string) string { + matches := inputVarRegex.FindAllStringSubmatch(s, 1) + varName := matches[0][1] + replaced, err := transformVarNameToStringVal(ctx, varName, inputs) + if err != nil { + errs.Errors = append(errs.Errors, errors.Wrapf(err, "input template [%s]", s)) + return "" + } + return replaced + }) + } + + if len(errs.Errors) > 0 { + return "", errs + } + + return val, nil +} + +func transformVarNameToStringVal(ctx context.Context, varName string, inputs *idlCore.LiteralMap) (string, error) { + inputVal, exists := inputs.Literals[varName] + if !exists { + return "", fmt.Errorf("requested input is not found [%s]", varName) + } + + v, err := serializeLiteral(ctx, inputVal) + if err != nil { + return "", errors.Wrapf(err, "failed to bind a value to inputName [%s]", varName) + } + return v, nil +} + +func serializePrimitive(p *idlCore.Primitive) (string, error) { + switch o := p.Value.(type) { + case *idlCore.Primitive_Integer: + return fmt.Sprintf("%v", o.Integer), nil + case *idlCore.Primitive_Boolean: + return fmt.Sprintf("%v", o.Boolean), nil + case *idlCore.Primitive_Datetime: + return ptypes.TimestampString(o.Datetime), nil + case *idlCore.Primitive_Duration: + return o.Duration.String(), nil + case *idlCore.Primitive_FloatValue: + return fmt.Sprintf("%v", o.FloatValue), nil + case *idlCore.Primitive_StringValue: + return o.StringValue, nil + default: + return "", fmt.Errorf("received an unexpected primitive type [%v]", reflect.TypeOf(p.Value)) + } +} + +func serializeLiteralScalar(l *idlCore.Scalar) (string, error) { + switch o := l.Value.(type) { + case *idlCore.Scalar_Primitive: + return serializePrimitive(o.Primitive) + case *idlCore.Scalar_Blob: + return o.Blob.Uri, nil + case *idlCore.Scalar_Schema: + return o.Schema.Uri, nil + case *idlCore.Scalar_Binary: + binaryBytes := o.Binary.Value + var currVal any + if o.Binary.Tag == coreutils.MESSAGEPACK { + err := msgpack.Unmarshal(binaryBytes, &currVal) + if err != nil { + return "", fmt.Errorf("failed to unmarshal messagepack bytes with literal:[%v], err:[%v]", l, err) + } + // TODO: Try to support Primitive_Datetime, Primitive_Duration, Flyte File, and Flyte Directory. + return fmt.Sprintf("%v", currVal), nil + } + return "", fmt.Errorf("unsupported binary tag [%v]", o.Binary.Tag) + + default: + return "", fmt.Errorf("received an unexpected scalar type [%v]", reflect.TypeOf(l.Value)) + } +} + +func serializeLiteral(ctx context.Context, l *idlCore.Literal) (string, error) { + switch o := l.Value.(type) { + case *idlCore.Literal_Collection: + res := make([]string, 0, len(o.Collection.Literals)) + for _, sub := range o.Collection.Literals { + s, err := serializeLiteral(ctx, sub) + if err != nil { + return "", err + } + + res = append(res, s) + } + + return fmt.Sprintf("[%v]", strings.Join(res, ",")), nil + case *idlCore.Literal_Scalar: + return serializeLiteralScalar(o.Scalar) + default: + logger.Debugf(ctx, "received unexpected primitive type") + return "", fmt.Errorf("received an unexpected primitive type [%v]", reflect.TypeOf(l.Value)) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/template/template_test.go b/flyteplugins/go/tasks/pluginmachinery/core/template/template_test.go new file mode 100644 index 0000000000..e810bf77fa --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/template/template_test.go @@ -0,0 +1,802 @@ +package template + +import ( + "context" + "fmt" + "regexp" + "testing" + "time" + + "github.com/shamaton/msgpack/v2" + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flyteidl2/clients/go/coreutils" + pluginsCoreMocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +type dummyInputReader struct { + inputPrefix storage.DataReference + inputPath storage.DataReference + inputs *core.LiteralMap + inputErr bool +} + +func (d dummyInputReader) GetInputPrefixPath() storage.DataReference { + return d.inputPrefix +} + +func (d dummyInputReader) GetInputPath() storage.DataReference { + return d.inputPath +} + +func (d dummyInputReader) Get(ctx context.Context) (*core.LiteralMap, error) { + if d.inputErr { + return nil, fmt.Errorf("expected input fetch error") + } + return d.inputs, nil +} + +type dummyOutputPaths struct { + outputPath storage.DataReference + rawOutputDataPrefix storage.DataReference + prevCheckpointPath storage.DataReference + checkpointPath storage.DataReference +} + +func (d dummyOutputPaths) GetDeckPath() storage.DataReference { + panic("should not be called") +} + +func (d dummyOutputPaths) GetPreviousCheckpointsPrefix() storage.DataReference { + return d.prevCheckpointPath +} + +func (d dummyOutputPaths) GetCheckpointPrefix() storage.DataReference { + return d.checkpointPath +} + +func (d dummyOutputPaths) GetRawOutputPrefix() storage.DataReference { + return d.rawOutputDataPrefix +} + +func (d dummyOutputPaths) GetOutputPrefixPath() storage.DataReference { + return d.outputPath +} + +func (d dummyOutputPaths) GetOutputPath() storage.DataReference { + panic("should not be called") +} + +func (d dummyOutputPaths) GetErrorPath() storage.DataReference { + panic("should not be called") +} + +func TestReplaceTemplateCommandArgs(t *testing.T) { + taskExecutionID := &pluginsCoreMocks.TaskExecutionID{} + taskExecutionID.EXPECT().GetGeneratedName().Return("per_retry_unique_key") + taskMetadata := &pluginsCoreMocks.TaskExecutionMetadata{} + taskMetadata.EXPECT().GetTaskExecutionID().Return(taskExecutionID) + taskMetadata.EXPECT().GetNamespace().Return("test-namespace") + + t.Run("empty cmd", func(t *testing.T) { + actual, err := Render(context.TODO(), []string{}, Parameters{}) + assert.NoError(t, err) + assert.Equal(t, []string{}, actual) + }) + + in := dummyInputReader{inputPath: "input/blah"} + out := dummyOutputPaths{ + outputPath: "output/blah", + rawOutputDataPrefix: "s3://custom-bucket", + } + + params := Parameters{ + TaskExecMetadata: taskMetadata, + Inputs: in, + OutputPath: out, + Task: nil, + } + t.Run("nothing to substitute", func(t *testing.T) { + actual, err := Render(context.TODO(), []string{ + "hello", + "world", + }, params) + assert.NoError(t, err) + + assert.Equal(t, []string{ + "hello", + "world", + }, actual) + }) + + t.Run("Sub InputFile", func(t *testing.T) { + actual, err := Render(context.TODO(), []string{ + "hello", + "world", + "{{ .Input }}", + }, params) + assert.NoError(t, err) + + assert.Equal(t, []string{ + "hello", + "world", + "input/blah", + }, actual) + }) + + t.Run("Sub Input Prefix", func(t *testing.T) { + in := dummyInputReader{inputPath: "input/prefix"} + params := Parameters{ + TaskExecMetadata: taskMetadata, + Inputs: in, + OutputPath: out, + Task: nil, + } + actual, err := Render(context.TODO(), []string{ + "hello", + "world", + "{{ .Input }}", + }, params) + assert.NoError(t, err) + + assert.Equal(t, []string{ + "hello", + "world", + "input/prefix", + }, actual) + }) + + t.Run("Sub Output Prefix", func(t *testing.T) { + actual, err := Render(context.TODO(), []string{ + "hello", + "world", + "{{ .OutputPrefix }}", + }, params) + assert.NoError(t, err) + assert.Equal(t, []string{ + "hello", + "world", + "output/blah", + }, actual) + }) + + t.Run("Sub Input Output prefix", func(t *testing.T) { + actual, err := Render(context.TODO(), []string{ + "hello", + "world", + "{{ .Input }}", + "{{ .OutputPrefix }}", + }, params) + assert.NoError(t, err) + assert.Equal(t, []string{ + "hello", + "world", + "input/blah", + "output/blah", + }, actual) + }) + + t.Run("Bad input template", func(t *testing.T) { + actual, err := Render(context.TODO(), []string{ + "hello", + "world", + "${{input}}", + "{{ .OutputPrefix }}", + "--switch {{ .rawOutputDataPrefix }}", + }, params) + assert.NoError(t, err) + assert.Equal(t, []string{ + "hello", + "world", + "${{input}}", + "output/blah", + "--switch s3://custom-bucket", + }, actual) + }) + + t.Run("Input arg", func(t *testing.T) { + in := dummyInputReader{inputs: &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "arr": { + Value: &core.Literal_Collection{ + Collection: &core.LiteralCollection{ + Literals: []*core.Literal{coreutils.MustMakeLiteral("a"), coreutils.MustMakeLiteral("b")}, + }, + }, + }, + }, + }} + params := Parameters{ + TaskExecMetadata: taskMetadata, + Inputs: in, + OutputPath: out, + Task: nil, + } + actual, err := Render(context.TODO(), []string{ + "hello", + "world", + `--someArg {{ .Inputs.arr }}`, + "{{ .OutputPrefix }}", + "{{ $RawOutputDataPrefix }}", + }, params) + assert.NoError(t, err) + assert.Equal(t, []string{ + "hello", + "world", + "--someArg [a,b]", + "output/blah", + "s3://custom-bucket", + }, actual) + }) + + t.Run("Date", func(t *testing.T) { + in := dummyInputReader{inputs: &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "date": coreutils.MustMakeLiteral(time.Date(1900, 01, 01, 01, 01, 01, 000000001, time.UTC)), + }, + }} + params := Parameters{ + TaskExecMetadata: taskMetadata, + Inputs: in, + OutputPath: out, + Task: nil, + } + actual, err := Render(context.TODO(), []string{ + "hello", + "world", + `--someArg {{ .Inputs.date }}`, + "{{ .OutputPrefix }}", + "{{ .rawOutputDataPrefix }}", + }, params) + assert.NoError(t, err) + assert.Equal(t, []string{ + "hello", + "world", + "--someArg 1900-01-01T01:01:01.000000001Z", + "output/blah", + "s3://custom-bucket", + }, actual) + }) + + t.Run("2d Array arg", func(t *testing.T) { + in := dummyInputReader{inputs: &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "arr": coreutils.MustMakeLiteral([]interface{}{[]interface{}{"a", "b"}, []interface{}{1, 2}}), + }, + }} + params := Parameters{ + TaskExecMetadata: taskMetadata, + Inputs: in, + OutputPath: out, + Task: nil, + } + actual, err := Render(context.TODO(), []string{ + "hello", + "world", + `--someArg {{ .Inputs.arr }}`, + "{{ .OutputPrefix }}", + "{{ .wrongOutputDataPrefix }}", + }, params) + assert.NoError(t, err) + assert.Equal(t, []string{ + "hello", + "world", + "--someArg [[a,b],[1,2]]", + "output/blah", + "{{ .wrongOutputDataPrefix }}", + }, actual) + }) + + t.Run("nil input", func(t *testing.T) { + in := dummyInputReader{inputs: &core.LiteralMap{}} + params := Parameters{ + TaskExecMetadata: taskMetadata, + Inputs: in, + OutputPath: out, + Task: nil, + } + + actual, err := Render(context.TODO(), []string{ + "hello", + "world", + `--someArg {{ .Inputs.arr }}`, + "{{ .OutputPrefix }}", + "--raw-data-output-prefix {{ .rawOutputDataPrefix }}", + }, params) + assert.NoError(t, err) + assert.Equal(t, []string{ + "hello", + "world", + `--someArg {{ .Inputs.arr }}`, + "output/blah", + "--raw-data-output-prefix s3://custom-bucket", + }, actual) + }) + + t.Run("multi-input", func(t *testing.T) { + in := dummyInputReader{inputs: &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "ds": coreutils.MustMakeLiteral(time.Date(1900, 01, 01, 01, 01, 01, 000000001, time.UTC)), + "table": coreutils.MustMakeLiteral("my_table"), + "hr": coreutils.MustMakeLiteral("hr"), + "min": coreutils.MustMakeLiteral(15), + }, + }} + params := Parameters{ + TaskExecMetadata: taskMetadata, + Inputs: in, + OutputPath: out, + Task: nil, + } + actual, err := Render(context.TODO(), []string{ + `SELECT + COUNT(*) as total_count + FROM + hive.events.{{ .Inputs.table }} + WHERE + ds = '{{ .Inputs.ds }}' AND hr = '{{ .Inputs.hr }}' AND min = {{ .Inputs.min }} + `}, params) + assert.NoError(t, err) + assert.Equal(t, []string{ + `SELECT + COUNT(*) as total_count + FROM + hive.events.my_table + WHERE + ds = '1900-01-01T01:01:01.000000001Z' AND hr = 'hr' AND min = 15 + `}, actual) + }) + + t.Run("missing input", func(t *testing.T) { + in := dummyInputReader{inputs: &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "arr": coreutils.MustMakeLiteral([]interface{}{[]interface{}{"a", "b"}, []interface{}{1, 2}}), + }, + }} + params := Parameters{ + TaskExecMetadata: taskMetadata, + Inputs: in, + OutputPath: out, + Task: nil, + } + _, err := Render(context.TODO(), []string{ + "hello", + "world", + `--someArg {{ .Inputs.blah }}`, + "{{ .OutputPrefix }}", + }, params) + assert.Error(t, err) + }) + + t.Run("bad template", func(t *testing.T) { + in := dummyInputReader{inputs: &core.LiteralMap{ + Literals: map[string]*core.Literal{ + "arr": coreutils.MustMakeLiteral([]interface{}{[]interface{}{"a", "b"}, []interface{}{1, 2}}), + }, + }} + params := Parameters{ + TaskExecMetadata: taskMetadata, + Inputs: in, + OutputPath: out, + Task: nil, + } + actual, err := Render(context.TODO(), []string{ + "hello", + "world", + `--someArg {{ .Inputs.blah blah }} {{ .PerretryuNIqueKey }}`, + "{{ .OutputPrefix }}", + }, params) + assert.NoError(t, err) + assert.Equal(t, []string{ + "hello", + "world", + `--someArg {{ .Inputs.blah blah }} per_retry_unique_key`, + "output/blah", + }, actual) + }) + + t.Run("sub raw output data prefix", func(t *testing.T) { + actual, err := Render(context.TODO(), []string{ + "hello", + "{{ .perRetryUniqueKey }}", + "world", + "{{ .rawOutputDataPrefix }}", + }, params) + assert.NoError(t, err) + assert.Equal(t, []string{ + "hello", + "per_retry_unique_key", + "world", + "s3://custom-bucket", + }, actual) + }) + + t.Run("sub task template happy", func(t *testing.T) { + ctx := context.TODO() + tMock := &pluginsCoreMocks.TaskTemplatePath{} + tMock.EXPECT().Path(ctx).Return("s3://task-path", nil) + params := Parameters{ + TaskExecMetadata: taskMetadata, + Inputs: in, + OutputPath: out, + Task: tMock, + } + + actual, err := Render(ctx, []string{ + "hello", + "{{ .perRetryUniqueKey }}", + "world", + "{{ .taskTemplatePath }}", + }, params) + assert.NoError(t, err) + assert.Equal(t, []string{ + "hello", + "per_retry_unique_key", + "world", + "s3://task-path", + }, actual) + }) + + t.Run("sub task template error", func(t *testing.T) { + ctx := context.TODO() + tMock := &pluginsCoreMocks.TaskTemplatePath{} + tMock.EXPECT().Path(ctx).Return("", fmt.Errorf("error")) + params := Parameters{ + TaskExecMetadata: taskMetadata, + Inputs: in, + OutputPath: out, + Task: tMock, + } + + _, err := Render(ctx, []string{ + "hello", + "{{ .perRetryUniqueKey }}", + "world", + "{{ .taskTemplatePath }}", + }, params) + assert.Error(t, err) + }) + + t.Run("missing checkpoint args", func(t *testing.T) { + params := Parameters{ + TaskExecMetadata: taskMetadata, + Inputs: in, + OutputPath: dummyOutputPaths{ + outputPath: out.outputPath, + rawOutputDataPrefix: out.rawOutputDataPrefix, + prevCheckpointPath: "s3://prev-checkpoint/prefix", + checkpointPath: "s3://new-checkpoint/prefix", + }, + } + actual, err := Render(context.TODO(), []string{ + "hello", + "world", + "{{ .Input }}", + "{{ .OutputPrefix }}", + }, params) + assert.NoError(t, err) + assert.Equal(t, []string{ + "hello", + "world", + "input/blah", + "output/blah", + }, actual) + }) + + t.Run("no prev checkpoint", func(t *testing.T) { + params := Parameters{ + TaskExecMetadata: taskMetadata, + Inputs: in, + OutputPath: dummyOutputPaths{ + outputPath: out.outputPath, + rawOutputDataPrefix: out.rawOutputDataPrefix, + prevCheckpointPath: "", + checkpointPath: "s3://new-checkpoint/prefix", + }, + } + actual, err := Render(context.TODO(), []string{ + "hello", + "world", + "{{ .Input }}", + "{{ .OutputPrefix }}", + "--prev={{ .PrevCheckpointPrefix }}", + "--checkpoint={{ .CheckpointOutputPrefix }}", + }, params) + assert.NoError(t, err) + assert.Equal(t, []string{ + "hello", + "world", + "input/blah", + "output/blah", + "--prev=\"\"", + "--checkpoint=s3://new-checkpoint/prefix", + }, actual) + }) + + t.Run("all checkpoints", func(t *testing.T) { + params := Parameters{ + TaskExecMetadata: taskMetadata, + Inputs: in, + OutputPath: dummyOutputPaths{ + outputPath: out.outputPath, + rawOutputDataPrefix: out.rawOutputDataPrefix, + prevCheckpointPath: "s3://prev-checkpoint/prefix", + checkpointPath: "s3://new-checkpoint/prefix", + }, + } + actual, err := Render(context.TODO(), []string{ + "hello", + "world", + "{{ .Input }}", + "{{ .OutputPrefix }}", + "--prev={{ .PrevCheckpointPrefix }}", + "--checkpoint={{ .CheckpointOutputPrefix }}", + }, params) + assert.NoError(t, err) + assert.Equal(t, []string{ + "hello", + "world", + "input/blah", + "output/blah", + "--prev=s3://prev-checkpoint/prefix", + "--checkpoint=s3://new-checkpoint/prefix", + }, actual) + }) + + t.Run("all checkpoints ignore case", func(t *testing.T) { + params := Parameters{ + TaskExecMetadata: taskMetadata, + Inputs: in, + OutputPath: dummyOutputPaths{ + outputPath: out.outputPath, + rawOutputDataPrefix: out.rawOutputDataPrefix, + prevCheckpointPath: "s3://prev-checkpoint/prefix", + checkpointPath: "s3://new-checkpoint/prefix", + }, + } + actual, err := Render(context.TODO(), []string{ + "hello", + "world", + "{{ .Input }}", + "{{ .OutputPrefix }}", + "--prev={{ .prevcheckpointprefix }}", + "--checkpoint={{ .checkpointoutputprefix }}", + }, params) + assert.NoError(t, err) + assert.Equal(t, []string{ + "hello", + "world", + "input/blah", + "output/blah", + "--prev=s3://prev-checkpoint/prefix", + "--checkpoint=s3://new-checkpoint/prefix", + }, actual) + }) + + t.Run("namespace embedded replacement", func(t *testing.T) { + params := Parameters{ + TaskExecMetadata: taskMetadata, + Inputs: in, + OutputPath: dummyOutputPaths{ + outputPath: out.outputPath, + rawOutputDataPrefix: "s3://raw-data/prefix/{{ .Namespace }}", + prevCheckpointPath: "s3://prev-checkpoint/prefix/{{ .Namespace}}", + checkpointPath: "s3://new-checkpoint/prefix/{{.namespace}}", + }, + } + actual, err := Render(context.TODO(), []string{ + "hello", + "world", + "{{ .Input }}", + "{{ .OutputPrefix }}", + "--prev={{ .prevcheckpointprefix }}", + "--checkpoint={{ .checkpointoutputprefix }}", + "--raw-data-output={{ .rawoutputdataprefix }}", + }, params) + assert.NoError(t, err) + assert.Equal(t, []string{ + "hello", + "world", + "input/blah", + "output/blah", + "--prev=s3://prev-checkpoint/prefix/test-namespace", + "--checkpoint=s3://new-checkpoint/prefix/test-namespace", + "--raw-data-output=s3://raw-data/prefix/test-namespace", + }, actual) + }) +} + +func TestReplaceTemplateCommandArgsSpecialChars(t *testing.T) { + in := dummyInputReader{inputPath: "input/blah"} + out := dummyOutputPaths{ + outputPath: "output/blah", + rawOutputDataPrefix: "s3://custom-bucket", + } + + params := Parameters{Inputs: in, OutputPath: out} + + t.Run("dashes are replaced", func(t *testing.T) { + taskExecutionID := &pluginsCoreMocks.TaskExecutionID{} + taskExecutionID.EXPECT().GetGeneratedName().Return("per-retry-unique-key") + taskMetadata := &pluginsCoreMocks.TaskExecutionMetadata{} + taskMetadata.EXPECT().GetTaskExecutionID().Return(taskExecutionID) + taskMetadata.EXPECT().GetNamespace().Return("my-namespace") + + params.TaskExecMetadata = taskMetadata + actual, err := Render(context.TODO(), []string{ + "hello", + "{{ .perRetryUniqueKey }}", + "world", + "{{ .rawOutputDataPrefix }}", + }, params) + assert.NoError(t, err) + assert.Equal(t, []string{ + "hello", + "per_retry_unique_key", + "world", + "s3://custom-bucket", + }, actual) + }) + + t.Run("non-alphabet leading characters are stripped", func(t *testing.T) { + var startsWithAlpha = regexp.MustCompile("^[^a-zA-Z_]+") + taskExecutionID := &pluginsCoreMocks.TaskExecutionID{} + taskExecutionID.EXPECT().GetGeneratedName().Return("33 per retry-unique-key") + taskMetadata := &pluginsCoreMocks.TaskExecutionMetadata{} + taskMetadata.EXPECT().GetTaskExecutionID().Return(taskExecutionID) + taskMetadata.EXPECT().GetNamespace().Return("my-namespace") + + params.TaskExecMetadata = taskMetadata + testString := "doesn't start with a number" + testString2 := "1 does start with a number" + testString3 := " 1 3 nd spaces " + assert.Equal(t, testString, startsWithAlpha.ReplaceAllString(testString, "a")) + assert.Equal(t, "adoes start with a number", startsWithAlpha.ReplaceAllString(testString2, "a")) + assert.Equal(t, "and spaces ", startsWithAlpha.ReplaceAllString(testString3, "a")) + + actual, err := Render(context.TODO(), []string{ + "hello", + "{{ .perRetryUniqueKey }}", + "world", + "{{ .rawOutputDataPrefix }}", + }, params) + assert.NoError(t, err) + assert.Equal(t, []string{ + "hello", + "aper_retry_unique_key", + "world", + "s3://custom-bucket", + }, actual) + }) +} + +func BenchmarkRegexCommandArgs(b *testing.B) { + for i := 0; i < b.N; i++ { + inputFileRegex.MatchString("{{ .InputFile }}") + } +} + +func TestInputRegexMatch(t *testing.T) { + assert.True(t, inputFileRegex.MatchString("{{$input}}")) + assert.True(t, inputFileRegex.MatchString("{{ $Input }}")) + assert.True(t, inputFileRegex.MatchString("{{.input}}")) + assert.True(t, inputFileRegex.MatchString("{{ .Input }}")) + assert.True(t, inputFileRegex.MatchString("{{ .Input }}")) + assert.True(t, inputFileRegex.MatchString("{{ .Input }}")) + assert.True(t, inputFileRegex.MatchString("{{ .Input}}")) + assert.True(t, inputFileRegex.MatchString("{{.Input }}")) + assert.True(t, inputFileRegex.MatchString("--something={{.Input}}")) + assert.False(t, inputFileRegex.MatchString("{{input}}"), "Missing $") + assert.False(t, inputFileRegex.MatchString("{$input}}"), "Missing Brace") +} + +func TestOutputRegexMatch(t *testing.T) { + assert.True(t, outputRegex.MatchString("{{.OutputPrefix}}")) + assert.True(t, outputRegex.MatchString("{{ .OutputPrefix }}")) + assert.True(t, outputRegex.MatchString("{{ .OutputPrefix }}")) + assert.True(t, outputRegex.MatchString("{{ .OutputPrefix }}")) + assert.True(t, outputRegex.MatchString("{{ .OutputPrefix}}")) + assert.True(t, outputRegex.MatchString("{{.OutputPrefix }}")) + assert.True(t, outputRegex.MatchString("--something={{.OutputPrefix}}")) + assert.False(t, outputRegex.MatchString("{{output}}"), "Missing $") + assert.False(t, outputRegex.MatchString("{.OutputPrefix}}"), "Missing Brace") +} + +func getBlobLiteral(uri string) *core.Literal { + return &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Blob{ + Blob: &core.Blob{ + Metadata: nil, + Uri: uri, + }, + }, + }, + }, + } +} + +func getSchemaLiteral(uri string) *core.Literal { + return &core.Literal{ + Value: &core.Literal_Scalar{ + Scalar: &core.Scalar{ + Value: &core.Scalar_Schema{ + Schema: &core.Schema{Type: nil, Uri: uri}, + }, + }, + }, + } +} + +func TestSerializeLiteral(t *testing.T) { + ctx := context.Background() + + t.Run("serialize blob", func(t *testing.T) { + b := getBlobLiteral("asdf fdsa") + interpolated, err := serializeLiteral(ctx, b) + assert.NoError(t, err) + assert.Equal(t, "asdf fdsa", interpolated) + }) + + t.Run("serialize blob", func(t *testing.T) { + s := getSchemaLiteral("s3://some-bucket/fdsa/x.parquet") + interpolated, err := serializeLiteral(ctx, s) + assert.NoError(t, err) + assert.Equal(t, "s3://some-bucket/fdsa/x.parquet", interpolated) + }) +} + +func TestSerializeLiteralScalar_BinaryMessagePack(t *testing.T) { + // Create a simple map to be serialized into MessagePack format + testMap := map[string]interface{}{ + "a": 1, + "b": true, + "c": 1.1, + "d": "string", + } + + // Serialize the map using MessagePack + encodedData, err := msgpack.Marshal(testMap) + assert.NoError(t, err) + + // Create the core.Scalar_Binary with the encoded MessagePack data and MESSAGEPACK tag + binaryScalar := &core.Scalar{ + Value: &core.Scalar_Binary{ + Binary: &core.Binary{ + Value: encodedData, + Tag: coreutils.MESSAGEPACK, + }, + }, + } + + // Call the function we want to test + result, err := serializeLiteralScalar(binaryScalar) + assert.NoError(t, err) + + // Since the map should be decoded back, we expect a simple string representation of the map + expectedResult := "map[a:1 b:true c:1.1 d:string]" + assert.Equal(t, expectedResult, result) +} + +func TestSerializeLiteralScalar_BinaryUnsupportedTag(t *testing.T) { + // Create some binary data for testing + binaryData := []byte{0x01, 0x02, 0x03} + + // Create a core.Scalar_Binary with an unsupported tag + binaryScalar := &core.Scalar{ + Value: &core.Scalar_Binary{ + Binary: &core.Binary{ + Value: binaryData, + Tag: "unsupported-tag", + }, + }, + } + + // Call the function and expect an error because the tag is unsupported + _, err := serializeLiteralScalar(binaryScalar) + assert.Error(t, err) + assert.Contains(t, err.Error(), "unsupported binary tag") +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/transition.go b/flyteplugins/go/tasks/pluginmachinery/core/transition.go new file mode 100644 index 0000000000..f7feccc4fc --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/transition.go @@ -0,0 +1,59 @@ +package core + +import "fmt" + +//go:generate enumer --type=TransitionType + +// Type of Transition, refer to Transition to understand what transition means +type TransitionType int + +const ( + // The transition is eventually consistent. For all the state written may not be visible in the next call, but eventually will persist + // Best to use when the plugin logic is completely idempotent. This is also the most performant option. + TransitionTypeEphemeral TransitionType = iota + // @deprecated support for Barrier type transitions has been deprecated + // This transition tries its best to make the latest state visible for every consecutive read. But, it is possible + // to go back in time, i.e. monotonic consistency is violated (in rare cases). + TransitionTypeBarrier +) + +// A Plugin Handle method returns a Transition. This transition indicates to the Flyte framework that if the plugin wants to continue "Handle"ing this task, +// or if wants to move the task to success, attempt a retry or fail. The transition automatically sends an event to Admin service which shows the plugin +// provided information in the Console/cli etc +// The information to be published is in the PhaseInfo structure. Transition Type indicates the type of consistency for subsequent handle calls in case the phase info results in a non terminal state. +// the PhaseInfo structure is very important and is used to record events in Admin. Only if the Phase + PhaseVersion was not previously observed, will an event be published to Admin +// there are only a configurable number of phase-versions usable. Usually it is preferred to be a monotonically increasing sequence +type Transition struct { + ttype TransitionType + info PhaseInfo +} + +func (t Transition) Type() TransitionType { + return t.ttype +} + +func (t Transition) Info() PhaseInfo { + return t.info +} + +func (t *Transition) SetInfo(info PhaseInfo) { + t.info = info +} + +func (t Transition) String() string { + return fmt.Sprintf("%s,%s", t.ttype, t.info) +} + +// UnknownTransition is synonymous to UndefinedTransition. To be returned when an error is observed +var UnknownTransition = Transition{TransitionTypeEphemeral, PhaseInfoUndefined} + +// Creates and returns a new Transition based on the PhaseInfo.Phase +// Phases: PhaseNotReady, PhaseQueued, PhaseInitializing, PhaseRunning will cause the system to continue invoking Handle +func DoTransitionType(ttype TransitionType, info PhaseInfo) Transition { + return Transition{ttype: ttype, info: info} +} + +// Same as DoTransition, but TransitionTime is always Ephemeral +func DoTransition(info PhaseInfo) Transition { + return DoTransitionType(TransitionTypeEphemeral, info) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/transition_test.go b/flyteplugins/go/tasks/pluginmachinery/core/transition_test.go new file mode 100644 index 0000000000..3455c9a67b --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/transition_test.go @@ -0,0 +1,53 @@ +package core + +import ( + "fmt" + "testing" + + "github.com/magiconair/properties/assert" +) + +func TestTransitionType_String(t *testing.T) { + assert.Equal(t, TransitionTypeBarrier.String(), "TransitionTypeBarrier") + assert.Equal(t, TransitionTypeEphemeral.String(), "TransitionTypeEphemeral") +} + +func ExampleTransition_String() { + trns := DoTransitionType(TransitionTypeBarrier, PhaseInfoUndefined) + fmt.Println(trns.String()) + // Output: TransitionTypeBarrier,Phase Reason:> +} + +func TestDoTransition(t *testing.T) { + t.Run("unknown", func(t *testing.T) { + trns := DoTransition(PhaseInfoUndefined) + assert.Equal(t, TransitionTypeEphemeral, trns.Type()) + assert.Equal(t, PhaseInfoUndefined, trns.Info()) + assert.Equal(t, PhaseUndefined, trns.Info().Phase()) + }) + + t.Run("someInfo", func(t *testing.T) { + pInfo := PhaseInfoSuccess(nil) + trns := DoTransition(pInfo) + assert.Equal(t, TransitionTypeEphemeral, trns.Type()) + assert.Equal(t, pInfo, trns.Info()) + assert.Equal(t, PhaseSuccess, trns.Info().Phase()) + }) +} + +func TestDoTransitionType(t *testing.T) { + t.Run("unknown", func(t *testing.T) { + trns := DoTransitionType(TransitionTypeBarrier, PhaseInfoUndefined) + assert.Equal(t, TransitionTypeBarrier, trns.Type()) + assert.Equal(t, PhaseInfoUndefined, trns.Info()) + assert.Equal(t, PhaseUndefined, trns.Info().Phase()) + }) + + t.Run("someInfo", func(t *testing.T) { + pInfo := PhaseInfoSuccess(nil) + trns := DoTransitionType(TransitionTypeBarrier, pInfo) + assert.Equal(t, TransitionTypeBarrier, trns.Type()) + assert.Equal(t, pInfo, trns.Info()) + assert.Equal(t, PhaseSuccess, trns.Info().Phase()) + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/core/transitiontype_enumer.go b/flyteplugins/go/tasks/pluginmachinery/core/transitiontype_enumer.go new file mode 100644 index 0000000000..41608fb36a --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/core/transitiontype_enumer.go @@ -0,0 +1,49 @@ +// Code generated by "enumer --type=TransitionType"; DO NOT EDIT. + +package core + +import ( + "fmt" +) + +const _TransitionTypeName = "TransitionTypeEphemeralTransitionTypeBarrier" + +var _TransitionTypeIndex = [...]uint8{0, 23, 44} + +func (i TransitionType) String() string { + if i < 0 || i >= TransitionType(len(_TransitionTypeIndex)-1) { + return fmt.Sprintf("TransitionType(%d)", i) + } + return _TransitionTypeName[_TransitionTypeIndex[i]:_TransitionTypeIndex[i+1]] +} + +var _TransitionTypeValues = []TransitionType{0, 1} + +var _TransitionTypeNameToValueMap = map[string]TransitionType{ + _TransitionTypeName[0:23]: 0, + _TransitionTypeName[23:44]: 1, +} + +// TransitionTypeString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func TransitionTypeString(s string) (TransitionType, error) { + if val, ok := _TransitionTypeNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to TransitionType values", s) +} + +// TransitionTypeValues returns all values of the enum +func TransitionTypeValues() []TransitionType { + return _TransitionTypeValues +} + +// IsATransitionType returns "true" if the value is listed in the enum definition. "false" otherwise +func (i TransitionType) IsATransitionType() bool { + for _, v := range _TransitionTypeValues { + if i == v { + return true + } + } + return false +} diff --git a/flyteplugins/go/tasks/pluginmachinery/encoding/encoder.go b/flyteplugins/go/tasks/pluginmachinery/encoding/encoder.go new file mode 100644 index 0000000000..8e31650edc --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/encoding/encoder.go @@ -0,0 +1,105 @@ +package encoding + +import ( + "encoding/base32" + "fmt" + "hash" + "hash/fnv" + "strings" +) + +const specialEncoderKey = "abcdefghijklmnopqrstuvwxyz123456" + +var Base32Encoder = base32.NewEncoding(specialEncoderKey).WithPadding(base32.NoPadding) + +// Algorithm defines an enum for the encoding algorithm to use. +type Algorithm uint32 + +const ( + // Algorithm32 uses fnv32 bit encoder. + Algorithm32 Algorithm = iota + + // Algorithm64 uses fnv64 bit encoder. + Algorithm64 + + // Algorithm128 uses fnv128 bit encoder. + Algorithm128 +) + +type Option interface { + option() +} + +// AlgorithmOption defines a wrapper to pass the algorithm to encoding functions. +type AlgorithmOption struct { + Option + algo Algorithm +} + +// NewAlgorithmOption wraps the Algorithm into an AlgorithmOption to pass to the encoding functions. +func NewAlgorithmOption(algo Algorithm) AlgorithmOption { + return AlgorithmOption{ + algo: algo, + } +} + +// FixedLengthUniqueID creates a new UniqueID that is based on the inputID and of a specified length, if the given id is +// longer than the maxLength. +func FixedLengthUniqueID(inputID string, maxLength int, options ...Option) (string, error) { + if len(inputID) <= maxLength { + return inputID, nil + } + + var hasher hash.Hash + for _, option := range options { + if algoOption, casted := option.(AlgorithmOption); casted { + switch algoOption.algo { + case Algorithm32: + hasher = fnv.New32a() + case Algorithm64: + hasher = fnv.New64a() + case Algorithm128: + hasher = fnv.New128a() + } + } + } + + if hasher == nil { + hasher = fnv.New32a() + } + + // Using 32a/64a an error can never happen, so this will always remain not covered by a unit test + _, _ = hasher.Write([]byte(inputID)) // #nosec + b := hasher.Sum(nil) + + // Encoding Length Calculation: + // Base32 Encoder will encode every 5 bits into an output character (2 ^ 5 = 32) + // output length = ciel( / 5) + // for 32a hashing = ceil(32 / 5) = 7 + // for 64a hashing = ceil(64 / 5) = 13 + // We prefix with character `f` so the final output is 8 or 14 + + finalStr := "f" + Base32Encoder.EncodeToString(b) + if len(finalStr) > maxLength { + return finalStr, fmt.Errorf("max Length is too small, cannot create an encoded string that is so small") + } + return finalStr, nil +} + +// FixedLengthUniqueIDForParts creates a new uniqueID using the parts concatenated using `-` and ensures that the +// uniqueID is not longer than the maxLength. In case a simple concatenation yields a longer string, a new hashed ID is +// created which is always around 8 characters in length. +func FixedLengthUniqueIDForParts(maxLength int, parts []string, options ...Option) (string, error) { + b := strings.Builder{} + for i, p := range parts { + if i > 0 && b.Len() > 0 { + // Ignoring the error as it always returns a nil error + _, _ = b.WriteRune('-') // #nosec + } + + // Ignoring the error as this is always nil + _, _ = b.WriteString(p) // #nosec + } + + return FixedLengthUniqueID(b.String(), maxLength, options...) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/encoding/encoder_test.go b/flyteplugins/go/tasks/pluginmachinery/encoding/encoder_test.go new file mode 100644 index 0000000000..9dc807f154 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/encoding/encoder_test.go @@ -0,0 +1,104 @@ +package encoding + +import ( + "hash" + "hash/fnv" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestFixedLengthUniqueID(t *testing.T) { + tests := []struct { + name string + input string + maxLength int + output string + expectError bool + }{ + {"smallerThanMax", "x", 5, "x", false}, + {"veryLowLimit", "xx", 1, "flfryc2i", true}, + {"highLimit", "xxxxxx", 5, "fufiti6i", true}, + {"higherLimit", "xxxxx", 10, "xxxxx", false}, + {"largeID", "xxxxxxxxxxxxxxxxxxxxxxxx", 20, "fuaa3aji", false}, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + i, err := FixedLengthUniqueID(test.input, test.maxLength) + if test.expectError { + assert.Error(t, err) + } else { + assert.NoError(t, err) + } + + assert.Equal(t, test.output, i) + }) + } +} + +func TestFixedLengthUniqueIDForParts(t *testing.T) { + tests := []struct { + name string + parts []string + maxLength int + algorithm Algorithm + output string + expectError bool + }{ + {"smallerThanMax", []string{"x", "y", "z"}, 10, Algorithm32, "x-y-z", false}, + {"veryLowLimit", []string{"x", "y"}, 1, Algorithm32, "fz2jizji", true}, + {"fittingID", []string{"x"}, 2, Algorithm32, "x", false}, + {"highLimit", []string{"x", "y", "z"}, 4, Algorithm32, "fxzsoqrq", true}, + {"largeID", []string{"x", "y", "z", "m", "n", "y", "z", "m", "n", "y", "z", "m", "n"}, 15, Algorithm32, "fe63sz6y", false}, + {"largeID", []string{"x", "y", "z", "m", "n", "y", "z", "m", "n", "y", "z", "m", "n"}, 15, Algorithm64, "fwp4bky2kucex5", false}, + {"largeID", []string{"x", "y", "z", "m", "n", "y", "z", "m", "n", "y", "z", "m", "n", "z", "m", "n", "y", "z", "m", "n"}, 30, Algorithm128, "fbmesl15enghpjepzjm5cp1zfqe", false}, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + i, err := FixedLengthUniqueIDForParts(test.maxLength, test.parts, NewAlgorithmOption(test.algorithm)) + if test.expectError { + assert.Error(t, err) + } else { + assert.NoError(t, err) + } + assert.Equal(t, test.output, i) + }) + } +} + +func benchmarkKB(b *testing.B, h hash.Hash) { + b.SetBytes(1024) + data := make([]byte, 1024) + for i := range data { + data[i] = byte(i) + } + + in := make([]byte, 0, h.Size()) + + b.ResetTimer() + for i := 0; i < b.N; i++ { + h.Reset() + h.Write(data) + h.Sum(in) + } +} + +// Documented Results: +// goos: darwin +// goarch: amd64 +// pkg: github.com/flyteorg/flyteplugins/go/tasks/pluginmachinery/encoding +// cpu: Intel(R) Core(TM) i9-9980HK CPU @ 2.40GHz +// BenchmarkFixedLengthUniqueID +// BenchmarkFixedLengthUniqueID/New32a +// BenchmarkFixedLengthUniqueID/New32a-16 1000000 1088 ns/op 941.25 MB/s +// BenchmarkFixedLengthUniqueID/New64a +// BenchmarkFixedLengthUniqueID/New64a-16 1239402 951.3 ns/op 1076.39 MB/s +func BenchmarkFixedLengthUniqueID(b *testing.B) { + b.Run("New32a", func(b *testing.B) { + benchmarkKB(b, fnv.New32a()) + }) + + b.Run("New64a", func(b *testing.B) { + benchmarkKB(b, fnv.New64a()) + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/config/config.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/config/config.go new file mode 100644 index 0000000000..e402e856ce --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/config/config.go @@ -0,0 +1,394 @@ +// Package config contains configuration for the flytek8s module - which is global configuration for all Flyte K8s interactions. +// This config is under the subsection `k8s` and registered under the Plugin config +// All K8s based plugins can optionally use the flytek8s module and this configuration allows controlling the defaults +// For example if for every container execution if some default Environment Variables or Annotations should be used, then they can be configured here +// An important configuration is ResourceTolerations that are applied to every container execution that needs some resource on the cluster +package config + +import ( + "strings" + "time" + + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/config" + config2 "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +//go:generate pflags K8sPluginConfig --default-var=defaultK8sConfig + +const k8sPluginConfigSectionKey = "k8s" + +// ResourceNvidiaGPU is the name of the Nvidia GPU resource. +// Copied from: k8s.io/autoscaler/cluster-autoscaler/utils/gpu/gpu.go +const ResourceNvidiaGPU v1.ResourceName = "nvidia.com/gpu" + +var defaultCPURequest = resource.MustParse("1000m") +var defaultMemoryRequest = resource.MustParse("1024Mi") + +var ( + defaultK8sConfig = K8sPluginConfig{ + DefaultAnnotations: map[string]string{ + "cluster-autoscaler.kubernetes.io/safe-to-evict": "false", + }, + CoPilot: FlyteCoPilotConfig{ + NamePrefix: "flyte-copilot-", + Image: "cr.flyte.org/flyteorg/flytecopilot:v0.0.15", + DefaultInputDataPath: "/var/flyte/inputs", + InputVolumeName: "flyte-inputs", + DefaultOutputPath: "/var/flyte/outputs", + OutputVolumeName: "flyte-outputs", + CPU: "500m", + Memory: "128Mi", + Timeout: config2.Duration{ + Duration: time.Hour * 1, + }, + }, + DefaultCPURequest: defaultCPURequest, + DefaultMemoryRequest: defaultMemoryRequest, + CreateContainerErrorGracePeriod: config2.Duration{ + Duration: time.Minute * 3, + }, + CreateContainerConfigErrorGracePeriod: config2.Duration{ + Duration: time.Minute * 0, + }, + ImagePullBackoffGracePeriod: config2.Duration{ + Duration: time.Minute * 3, + }, + PodPendingTimeout: config2.Duration{ + Duration: 0, + }, + GpuDeviceNodeLabel: "k8s.amazonaws.com/accelerator", + GpuPartitionSizeNodeLabel: "k8s.amazonaws.com/gpu-partition-size", + GpuResourceName: ResourceNvidiaGPU, + AcceleratorDevices: map[string]string{ + // NVIDIA GPUs + "A10": "nvidia-a10", + "A10G": "nvidia-a10g", + "A100": "nvidia-tesla-a100", + "A100 80G": "nvidia-a100-80gb", + "A100G": "nvidia-a100g", + "B200": "nvidia-b200", + "GB200": "nvidia-gb200", + "H100": "nvidia-h100", + "H100 80G": "nvidia-h100-80gb", + "H100 MEGA 80G": "nvidia-h100-mega-80gb", + "H200": "nvidia-h200", + "K80": "nvidia-tesla-k80", + "L4": "nvidia-l4", + "L40s": "nvidia-l40s", + "L4_VWS": "nvidia-l4-vws", + "M60": "nvidia-tesla-m60", + "P4": "nvidia-tesla-p4", + "P100": "nvidia-tesla-p100", + "RTX PRO 6000": "nvidia-rtx-pro-6000", + "T4": "nvidia-tesla-t4", + "V100": "nvidia-tesla-v100", + + // Google Cloud TPUs + "V5E": "tpu-v5-lite-podslice", + "V5P": "tpu-v5p-slice", + "V6E": "tpu-v6e-slice", + + // AWS Neuron + "INF1": "aws-neuron-inf1", + "INF2": "aws-neuron-inf2", + "TRN1": "aws-neuron-trn1", + "TRN1N": "aws-neuron-trn1n", + "TRN2": "aws-neuron-trn2", + "TRN2U": "aws-neuron-trn2u", + + // AMD GPUs + "MI100": "amd-mi100", + "MI210": "amd-mi210", + "MI250": "amd-mi250", + "MI250X": "amd-mi250x", + "MI300A": "amd-mi300a", + "MI300X": "amd-mi300x", + "MI325X": "amd-mi325x", + "MI350X": "amd-mi350x", + "MI355X": "amd-mi355x", + + // Habana Gaudi (Intel) + "GAUDI1": "habana-gaudi-dl1", + }, + AcceleratorDeviceClasses: map[string]AcceleratorDeviceClassConfig{ + core.GPUAccelerator_NVIDIA_GPU.String(): { + ResourceName: "nvidia.com/gpu", + }, + core.GPUAccelerator_GOOGLE_TPU.String(): { + ResourceName: "google.com/tpu", + DeviceNodeLabel: "cloud.google.com/gke-tpu-accelerator", + PartitionSizeNodeLabel: "cloud.google.com/gke-tpu-topology", + }, + core.GPUAccelerator_AMAZON_NEURON.String(): { + ResourceName: "aws.amazon.com/neuron", + }, + core.GPUAccelerator_AMD_GPU.String(): { + ResourceName: "amd.com/gpu", + }, + core.GPUAccelerator_HABANA_GAUDI.String(): { + ResourceName: "habana.ai/gaudi", + }, + }, + DefaultPodTemplateResync: config2.Duration{ + Duration: 30 * time.Second, + }, + UpdateBaseBackoffDuration: 10, + UpdateBackoffRetries: 5, + AddTolerationsForExtendedResources: []string{}, + } + + // K8sPluginConfigSection provides a singular top level config section for all plugins. + // If you are a plugin developer writing a k8s plugin, register your config section as a subsection to this. + K8sPluginConfigSection = config.MustRegisterSubSection(k8sPluginConfigSectionKey, &defaultK8sConfig) +) + +// K8sPluginConfig should be used to configure per-pod defaults for the entire platform. This allows adding global defaults +// for pods that are being launched. For example, default annotations, labels, if a finalizer should be injected, +// if taints/tolerations should be used for certain resource types etc. +type K8sPluginConfig struct { + // InjectFinalizer is a boolean flag that indicates if a finalizer should be injected into every K8s resource launched + InjectFinalizer bool `json:"inject-finalizer" pflag:",Instructs the plugin to inject a finalizer on startTask and remove it on task termination."` + + // ------------------------------------------------------------------------------------------------------------- + // Default Configurations to be applied to all Pods launched by Flyte. These are always applied to every Pod. + // Thus if a Pod is interruptible, it will have the default + interruptible tolerations + + // Provide default annotations that should be added to K8s resource + DefaultAnnotations map[string]string `json:"default-annotations" pflag:"-,Defines a set of default annotations to add to the produced pods."` + // Provide default labels that should be added to K8s resource + DefaultLabels map[string]string `json:"default-labels" pflag:"-,Defines a set of default labels to add to the produced pods."` + // Provide additional environment variable pairs that plugin authors will provide to containers + DefaultEnvVars map[string]string `json:"default-env-vars" pflag:"-,Additional environment variable that should be injected into every resource"` + // Provide additional environment variable pairs whose values resolve from the plugin's execution environment. + DefaultEnvVarsFromEnv map[string]string `json:"default-env-vars-from-env" pflag:"-,Additional environment variable that should be injected into every resource"` + // Provide additional environment variable parts from configMaps + DefaultEnvFromConfigMaps []string `json:"default-env-from-configmaps" pflag:"-,Additional environment variable sets that should be injected into each pod from these configMaps"` + // Provide additional environment variable parts from secrets + DefaultEnvFromSecrets []string `json:"default-env-from-secrets" pflag:"-,Additional environment variable sets that should be injected into each pod from these secret"` + + // default cpu requests for a container + DefaultCPURequest resource.Quantity `json:"default-cpus" pflag:",Defines a default value for cpu for containers if not specified."` + // default memory requests for a container + DefaultMemoryRequest resource.Quantity `json:"default-memory" pflag:",Defines a default value for memory for containers if not specified."` + + // Default Tolerations that will be added to every Pod that is created by Flyte. These can be used in heterogeneous clusters, where one wishes to keep all pods created by Flyte on a separate + // set of nodes. + DefaultTolerations []v1.Toleration `json:"default-tolerations" pflag:"-,Tolerations to be applied for every node that is launched by Flyte. Useful in non dedicated flyte clusters"` + // Default Node Selector Labels for pods. These NodeSelector labels are added to all pods, created by Flyte, unless they are marked as interruptible (default of interruptible are different). + DefaultNodeSelector map[string]string `json:"default-node-selector" pflag:"-,Defines a set of node selector labels to add to the all pods launched by Flyte. Useful in non dedicated Flyte clusters"` + // Default Affinity that is applied to every pod that Flyte launches + DefaultAffinity *v1.Affinity `json:"default-affinity,omitempty" pflag:"-,Defines default Affinity to be added for every Pod launched by Flyte. Useful in non dedicated Flyte clusters"` + + // Default scheduler that should be used for all pods or CRD that accept Scheduler name. + SchedulerName string `json:"scheduler-name" pflag:",Defines scheduler name."` + + // ----------------------------------------------------------------- + // Special tolerations and node selector for Interruptible tasks. This allows scheduling interruptible tasks onto specific hardware + + // Tolerations for interruptible k8s pods: These tolerations are added to the pods that can tolerate getting evicted from a node. We + // can leverage this for better bin-packing and using low-reliability cheaper machines. + InterruptibleTolerations []v1.Toleration `json:"interruptible-tolerations" pflag:"-,Tolerations to be applied for interruptible pods"` + // Node Selector Labels for interruptible pods: Similar to InterruptibleTolerations, these node selector labels are added for pods that can tolerate + // eviction. + // Deprecated: Please use InterruptibleNodeSelectorRequirement/NonInterruptibleNodeSelectorRequirement + InterruptibleNodeSelector map[string]string `json:"interruptible-node-selector" pflag:"-,Defines a set of node selector labels to add to the interruptible pods."` + // Node Selector Requirements to be added to interruptible and non-interruptible + // pods respectively + InterruptibleNodeSelectorRequirement *v1.NodeSelectorRequirement `json:"interruptible-node-selector-requirement" pflag:"-,Node selector requirement to add to interruptible pods"` + NonInterruptibleNodeSelectorRequirement *v1.NodeSelectorRequirement `json:"non-interruptible-node-selector-requirement" pflag:"-,Node selector requirement to add to non-interruptible pods"` + + // ---------------------------------------------------------------------- + // Specific tolerations that are added for certain resources. Useful for maintaining gpu resources separate in the cluster + + // Tolerations in the cluster that should be applied for a specific resource + // Currently we support simple resource based tolerations only + ResourceTolerations map[v1.ResourceName][]v1.Toleration `json:"resource-tolerations" pflag:"-,Default tolerations to be applied for resource of type 'key'"` + + // Flyte CoPilot Configuration + CoPilot FlyteCoPilotConfig `json:"co-pilot" pflag:",Co-Pilot Configuration"` + + // DeleteResourceOnFinalize instructs the system to delete the resource on finalize. This ensures that no resources + // are kept around (potentially consuming cluster resources). This, however, will cause k8s log links to expire as + // soon as the resource is finalized. + DeleteResourceOnFinalize bool `json:"delete-resource-on-finalize" pflag:",Instructs the system to delete the resource upon successful execution of a k8s pod rather than have the k8s garbage collector clean it up.ย This ensures that no resources are kept around (potentially consuming cluster resources). This, however, will cause k8s log links to expire as soon as the resource is finalized."` + + // Time to wait for transient CreateContainerError errors to be resolved. If the + // error persists past this grace period, it will be inferred to be a permanent + // one, and the corresponding task marked as failed + CreateContainerErrorGracePeriod config2.Duration `json:"create-container-error-grace-period" pflag:"-,Time to wait for transient CreateContainerError errors to be resolved."` + + // Time to wait for transient CreateContainerConfigError errors to be resolved. If the + // error persists past this grace period, it will be inferred to be a permanent error. + // The pod will be deleted, and the corresponding task marked as failed. + CreateContainerConfigErrorGracePeriod config2.Duration `json:"create-container-config-error-grace-period" pflag:"-,Time to wait for transient CreateContainerConfigError errors to be resolved."` + + // Time to wait for transient ImagePullBackoff errors to be resolved. If the + // error persists past this grace period, it will be inferred to be a permanent + // one, and the corresponding task marked as failed + ImagePullBackoffGracePeriod config2.Duration `json:"image-pull-backoff-grace-period" pflag:"-,Time to wait for transient ImagePullBackoff errors to be resolved."` + + // ImagePullPolicy for the submitted pod. + ImagePullPolicy v1.PullPolicy `json:"image-pull-policy" pflag:"-,Image pull policy for all k8s pods created by FlytePropeller."` + + // Time to wait while pod is in pending phase. If the pod is stuck in + // pending phase past this timeout, it will be inferred to be a permanent + // issue, and the corresponding task marked as failed + PodPendingTimeout config2.Duration `json:"pod-pending-timeout" pflag:"-,Time to wait while pod is stuck in pending."` + + // The node label that specifies the attached GPU device. + GpuDeviceNodeLabel string `json:"gpu-device-node-label" pflag:"-,The node label that specifies the attached GPU device."` + + // The node label that specifies the attached GPU partition size. + GpuPartitionSizeNodeLabel string `json:"gpu-partition-size-node-label" pflag:"-,The node label that specifies the attached GPU partition size."` + + // Override for node selector requirement added to pods intended for unpartitioned GPU nodes. + GpuUnpartitionedNodeSelectorRequirement *v1.NodeSelectorRequirement `json:"gpu-unpartitioned-node-selector-requirement" pflag:"-,Override for node selector requirement added to pods intended for unpartitioned GPU nodes."` + + // Toleration added to pods intended for unpartitioned GPU nodes. + GpuUnpartitionedToleration *v1.Toleration `json:"gpu-unpartitioned-toleration" pflag:"-,Toleration added to pods intended for unpartitioned GPU nodes."` + + // Deprecated: Use AcceleratorDeviceClasses instead. The name of the GPU resource to use when the task resource requests GPUs. + GpuResourceName v1.ResourceName `json:"gpu-resource-name" pflag:"-,The name of the GPU resource to use when the task resource requests GPUs."` + + // AcceleratorDevices maps accelerator devices to provisioned Kubernetes node labels. + AcceleratorDevices map[string]string `json:"accelerator-devices" pflag:"-,Maps accelerator devices to provisionedKubernetes node labels."` + + // AcceleratorDeviceClasses maps accelerator device classes to their configuration overrides. + // This allows configuring resource names, node labels, and tolerations for different accelerator types (NVIDIA GPU, Google TPU, Amazon Neuron, AMD GPU). + AcceleratorDeviceClasses map[string]AcceleratorDeviceClassConfig `json:"accelerator-device-classes" pflag:"-,Maps accelerator device classes to their configuration overrides."` + + // DefaultPodSecurityContext provides a default pod security context that should be applied for every pod that is launched by FlytePropeller. This may not be applicable to all plugins. For + // downstream plugins - i.e. TensorflowOperators may not support setting this, but Spark does. + DefaultPodSecurityContext *v1.PodSecurityContext `json:"default-pod-security-context" pflag:"-,Optionally specify any default pod security context that should be applied to every Pod launched by FlytePropeller."` + + // DefaultSecurityContext provides a default container security context that should be applied for the primary container launched and created by FlytePropeller. This may not be applicable to all plugins. For + // // downstream plugins - i.e. TensorflowOperators may not support setting this, but Spark does. + DefaultSecurityContext *v1.SecurityContext `json:"default-security-context" pflag:"-,Optionally specify a default security context that should be applied to every container launched/created by FlytePropeller. This will not be applied to plugins that do not support it or to user supplied containers in pod tasks."` + + // EnableHostNetworkingPod is a binary switch to enable `hostNetwork: true` for all pods launched by Flyte. + // Refer to - https://kubernetes.io/docs/concepts/policy/pod-security-policy/#host-namespaces. + // As a follow up, the default pod configurations will now be adjusted using podTemplates per namespace + EnableHostNetworkingPod *bool `json:"enable-host-networking-pod" pflag:"-,If true, will schedule all pods with hostNetwork: true."` + + // DefaultPodDNSConfig provides a default pod DNS config that that should be applied for the primary container launched and created by FlytePropeller. This may not be applicable to all plugins. For + // // downstream plugins - i.e. TensorflowOperators may not support setting this. + DefaultPodDNSConfig *v1.PodDNSConfig `json:"default-pod-dns-config" pflag:"-,Optionally specify a default DNS config that should be applied to every Pod launched by FlytePropeller."` + + // DefaultPodTemplateName that serves as the base PodTemplate for all k8s pods (including + // individual containers) that are creating by FlytePropeller. + DefaultPodTemplateName string `json:"default-pod-template-name" pflag:",Name of the PodTemplate to use as the base for all k8s pods created by FlytePropeller."` + + // DefaultPodTemplateResync defines the frequency at which the k8s informer resyncs the default + // pod template resources. + DefaultPodTemplateResync config2.Duration `json:"default-pod-template-resync" pflag:",Frequency of resyncing default pod templates"` + + // SendObjectEvents indicates whether to send k8s object events in TaskExecutionEvent updates (similar to kubectl get events). + SendObjectEvents bool `json:"send-object-events" pflag:",If true, will send k8s object events in TaskExecutionEvent updates."` + + // Initial delay in exponential backoff when updating a resource in milliseconds. + UpdateBaseBackoffDuration int `json:"update-base-backoff-duration" pflag:",Initial delay in exponential backoff when updating a resource in milliseconds."` + + // Number of retries for exponential backoff when updating a resource. + UpdateBackoffRetries int `json:"update-backoff-retries" pflag:",Number of retries for exponential backoff when updating a resource."` + + // Extended resources that should be added to the tolerations automatically. + AddTolerationsForExtendedResources []string `json:"add-tolerations-for-extended-resources" pflag:",Name of the extended resources for which tolerations should be added."` + + // DisableInjectOwnerReferences is a boolean flag that indicates if owner references should be injected into the k8s resources. + DisableInjectOwnerReferences bool `json:"disable-inject-owner-references" pflag:",Override to not set owner references on k8s resources. This is useful for V2 node execution"` +} + +// FlyteCoPilotConfig specifies configuration for the Flyte CoPilot system. FlyteCoPilot, allows running flytekit-less containers +// in K8s, where the IO is managed by the FlyteCoPilot sidecar process. +type FlyteCoPilotConfig struct { + // Co-pilot sidecar container name + NamePrefix string `json:"name" pflag:",Flyte co-pilot sidecar container name prefix. (additional bits will be added after this)"` + // Docker image FQN where co-pilot binary is installed + Image string `json:"image" pflag:",Flyte co-pilot Docker Image FQN"` + // Default Input Path for every task execution that uses co-pilot. This is used only if a input path is not provided by the user and inputs are required for the task + DefaultInputDataPath string `json:"default-input-path" pflag:",Default path where the volume should be mounted"` + // Default Output Path for every task execution that uses co-pilot. This is used only if a output path is not provided by the user and outputs are required for the task + DefaultOutputPath string `json:"default-output-path" pflag:",Default path where the volume should be mounted"` + // Name of the input volume + InputVolumeName string `json:"input-vol-name" pflag:",Name of the data volume that is created for storing inputs"` + // Name of the output volume + OutputVolumeName string `json:"output-vol-name" pflag:",Name of the data volume that is created for storing outputs"` + // Time for which the sidecar container should wait after starting up, for the primary process to appear. If it does not show up in this time + // the process will be assumed to be dead or in a terminal condition and will trigger an abort. + StartTimeout config2.Duration `json:"start-timeout" pflag:"-,Time for which the sidecar should wait on startup before assuming the primary container to have failed startup."` + // Timeout for upload + Timeout config2.Duration `json:"timeout" pflag:"-,Max time to allow for uploads to complete."` + // Resources for CoPilot Containers + CPU string `json:"cpu" pflag:",Used to set cpu for co-pilot containers"` + Memory string `json:"memory" pflag:",Used to set memory for co-pilot containers"` + Storage string `json:"storage" pflag:",Default storage limit for individual inputs / outputs"` + StorageConfigOverride *storage.Config `json:"storage-config-override" pflag:"-,Override for the storage config to use for co-pilot"` +} + +type AcceleratorDeviceClassConfig struct { + // Kubernetes resource name for the accelerator device class. + ResourceName v1.ResourceName `json:"resource-name" pflag:",Kubernetes resource name for the accelerator device class."` + + // The node label that specifies the attached accelerator device. + DeviceNodeLabel string `json:"device-node-label" pflag:"-,The node label that specifies the attached device."` + + // The node label that specifies the attached accelerator partition size. + PartitionSizeNodeLabel string `json:"partition-size-node-label" pflag:"-,The node label that specifies the attached partition size."` + + // Override for node selector requirement added to pods intended for unpartitioned nodes. + UnpartitionedNodeSelectorRequirement *v1.NodeSelectorRequirement `json:"unpartitioned-node-selector-requirement" pflag:"-,Override for node selector requirement added to pods intended for unpartitioned nodes."` + + // Toleration added to pods intended for unpartitioned nodes. + UnpartitionedToleration *v1.Toleration `json:"unpartitioned-toleration" pflag:"-,Toleration added to pods intended for unpartitioned nodes."` + + // PodTemplate provides device-class-specific defaults for pods using this accelerator. + // Platform operators can define pod-level and container-level configuration that serves + // as a base template for tasks using this device class. Task-specific configurations + // can override these defaults. + // + // Precedence (lowest to highest): + // 1. Base PodTemplate (cluster/namespace defaults) + // 2. Device Class PodTemplate (this config) - device-specific defaults + // 3. Task PodSpec - task-specific values override device class for scalars + // + // Merge behavior (BASE semantics): + // - Scalar fields: Task values WIN (device class provides defaults only) + // Examples: schedulerName, dnsPolicy, hostNetwork + // - Slice fields: Appended (device class values + task values) + // Examples: tolerations, volumes, env vars + // - Map fields: Merged (union with task values winning on conflicts) + // Examples: nodeSelector, labels, annotations + // + // Container (and init container) template support: + // - Containers named "default" provide defaults for ALL containers + // - Containers named "primary" provide defaults for the primary container only + // - Primary template is applied after default (primary wins for conflicts) + // - Containers with other names are merged into containers in the base PodSpec with the same name + // - Uses the same container template merging as base PodTemplates + PodTemplate *v1.PodTemplate `json:"pod-template" pflag:"-,PodTemplate providing defaults for this accelerator device class."` +} + +// GetK8sPluginConfig retrieves the current k8s plugin config or default. +func GetK8sPluginConfig() *K8sPluginConfig { + cfg := K8sPluginConfigSection.GetConfig().(*K8sPluginConfig) + + // Viper casts all keys in YAML configs to lowercase, but all the accelerator device classes should be uppercase. + // See: https://github.com/spf13/viper/issues/260 + acceleratorDeviceClasses := make(map[string]AcceleratorDeviceClassConfig) + for key, value := range cfg.AcceleratorDeviceClasses { + acceleratorDeviceClasses[strings.ToUpper(key)] = value + } + cfg.AcceleratorDeviceClasses = acceleratorDeviceClasses + + return cfg +} + +// SetK8sPluginConfig should be used for TESTING ONLY, It Sets current value for the config. +func SetK8sPluginConfig(cfg *K8sPluginConfig) error { + return K8sPluginConfigSection.SetConfig(cfg) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/config/config_test.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/config/config_test.go new file mode 100644 index 0000000000..eb3429774d --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/config/config_test.go @@ -0,0 +1,12 @@ +package config + +import ( + "testing" + + "gotest.tools/assert" +) + +func TestGetK8sPluginConfig(t *testing.T) { + assert.Equal(t, GetK8sPluginConfig().DefaultCPURequest, defaultCPURequest) + assert.Equal(t, GetK8sPluginConfig().DefaultMemoryRequest, defaultMemoryRequest) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/config/k8spluginconfig_flags.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/config/k8spluginconfig_flags.go new file mode 100755 index 0000000000..6d46d83f92 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/config/k8spluginconfig_flags.go @@ -0,0 +1,75 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package config + +import ( + "encoding/json" + "reflect" + + "fmt" + + "github.com/spf13/pflag" +) + +// If v is a pointer, it will get its element value or the zero value of the element type. +// If v is not a pointer, it will return it as is. +func (K8sPluginConfig) elemValueOrNil(v interface{}) interface{} { + if t := reflect.TypeOf(v); t.Kind() == reflect.Ptr { + if reflect.ValueOf(v).IsNil() { + return reflect.Zero(t.Elem()).Interface() + } else { + return reflect.ValueOf(v).Interface() + } + } else if v == nil { + return reflect.Zero(t).Interface() + } + + return v +} + +func (K8sPluginConfig) mustJsonMarshal(v interface{}) string { + raw, err := json.Marshal(v) + if err != nil { + panic(err) + } + + return string(raw) +} + +func (K8sPluginConfig) mustMarshalJSON(v json.Marshaler) string { + raw, err := v.MarshalJSON() + if err != nil { + panic(err) + } + + return string(raw) +} + +// GetPFlagSet will return strongly types pflags for all fields in K8sPluginConfig and its nested types. The format of the +// flags is json-name.json-sub-name... etc. +func (cfg K8sPluginConfig) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("K8sPluginConfig", pflag.ExitOnError) + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "inject-finalizer"), defaultK8sConfig.InjectFinalizer, "Instructs the plugin to inject a finalizer on startTask and remove it on task termination.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "default-cpus"), defaultK8sConfig.DefaultCPURequest.String(), "Defines a default value for cpu for containers if not specified.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "default-memory"), defaultK8sConfig.DefaultMemoryRequest.String(), "Defines a default value for memory for containers if not specified.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "scheduler-name"), defaultK8sConfig.SchedulerName, "Defines scheduler name.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "co-pilot.name"), defaultK8sConfig.CoPilot.NamePrefix, "Flyte co-pilot sidecar container name prefix. (additional bits will be added after this)") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "co-pilot.image"), defaultK8sConfig.CoPilot.Image, "Flyte co-pilot Docker Image FQN") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "co-pilot.default-input-path"), defaultK8sConfig.CoPilot.DefaultInputDataPath, "Default path where the volume should be mounted") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "co-pilot.default-output-path"), defaultK8sConfig.CoPilot.DefaultOutputPath, "Default path where the volume should be mounted") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "co-pilot.input-vol-name"), defaultK8sConfig.CoPilot.InputVolumeName, "Name of the data volume that is created for storing inputs") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "co-pilot.output-vol-name"), defaultK8sConfig.CoPilot.OutputVolumeName, "Name of the data volume that is created for storing outputs") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "co-pilot.cpu"), defaultK8sConfig.CoPilot.CPU, "Used to set cpu for co-pilot containers") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "co-pilot.memory"), defaultK8sConfig.CoPilot.Memory, "Used to set memory for co-pilot containers") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "co-pilot.storage"), defaultK8sConfig.CoPilot.Storage, "Default storage limit for individual inputs / outputs") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "delete-resource-on-finalize"), defaultK8sConfig.DeleteResourceOnFinalize, "Instructs the system to delete the resource upon successful execution of a k8s pod rather than have the k8s garbage collector clean it up.ย This ensures that no resources are kept around (potentially consuming cluster resources). This, however, will cause k8s log links to expire as soon as the resource is finalized.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "default-pod-template-name"), defaultK8sConfig.DefaultPodTemplateName, "Name of the PodTemplate to use as the base for all k8s pods created by FlytePropeller.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "default-pod-template-resync"), defaultK8sConfig.DefaultPodTemplateResync.String(), "Frequency of resyncing default pod templates") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "send-object-events"), defaultK8sConfig.SendObjectEvents, "If true, will send k8s object events in TaskExecutionEvent updates.") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "update-base-backoff-duration"), defaultK8sConfig.UpdateBaseBackoffDuration, "Initial delay in exponential backoff when updating a resource in milliseconds.") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "update-backoff-retries"), defaultK8sConfig.UpdateBackoffRetries, "Number of retries for exponential backoff when updating a resource.") + cmdFlags.StringSlice(fmt.Sprintf("%v%v", prefix, "add-tolerations-for-extended-resources"), defaultK8sConfig.AddTolerationsForExtendedResources, "Name of the extended resources for which tolerations should be added.") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "disable-inject-owner-references"), defaultK8sConfig.DisableInjectOwnerReferences, "Override to not set owner references on k8s resources. This is useful for V2 node execution") + return cmdFlags +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/config/k8spluginconfig_flags_test.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/config/k8spluginconfig_flags_test.go new file mode 100755 index 0000000000..eefd2f2b58 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/config/k8spluginconfig_flags_test.go @@ -0,0 +1,396 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package config + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "testing" + + "github.com/mitchellh/mapstructure" + "github.com/stretchr/testify/assert" +) + +var dereferencableKindsK8sPluginConfig = map[reflect.Kind]struct{}{ + reflect.Array: {}, reflect.Chan: {}, reflect.Map: {}, reflect.Ptr: {}, reflect.Slice: {}, +} + +// Checks if t is a kind that can be dereferenced to get its underlying type. +func canGetElementK8sPluginConfig(t reflect.Kind) bool { + _, exists := dereferencableKindsK8sPluginConfig[t] + return exists +} + +// This decoder hook tests types for json unmarshaling capability. If implemented, it uses json unmarshal to build the +// object. Otherwise, it'll just pass on the original data. +func jsonUnmarshalerHookK8sPluginConfig(_, to reflect.Type, data interface{}) (interface{}, error) { + unmarshalerType := reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + if to.Implements(unmarshalerType) || reflect.PtrTo(to).Implements(unmarshalerType) || + (canGetElementK8sPluginConfig(to.Kind()) && to.Elem().Implements(unmarshalerType)) { + + raw, err := json.Marshal(data) + if err != nil { + fmt.Printf("Failed to marshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + res := reflect.New(to).Interface() + err = json.Unmarshal(raw, &res) + if err != nil { + fmt.Printf("Failed to umarshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + return res, nil + } + + return data, nil +} + +func decode_K8sPluginConfig(input, result interface{}) error { + config := &mapstructure.DecoderConfig{ + TagName: "json", + WeaklyTypedInput: true, + Result: result, + DecodeHook: mapstructure.ComposeDecodeHookFunc( + mapstructure.StringToTimeDurationHookFunc(), + mapstructure.StringToSliceHookFunc(","), + jsonUnmarshalerHookK8sPluginConfig, + ), + } + + decoder, err := mapstructure.NewDecoder(config) + if err != nil { + return err + } + + return decoder.Decode(input) +} + +func join_K8sPluginConfig(arr interface{}, sep string) string { + listValue := reflect.ValueOf(arr) + strs := make([]string, 0, listValue.Len()) + for i := 0; i < listValue.Len(); i++ { + strs = append(strs, fmt.Sprintf("%v", listValue.Index(i))) + } + + return strings.Join(strs, sep) +} + +func testDecodeJson_K8sPluginConfig(t *testing.T, val, result interface{}) { + assert.NoError(t, decode_K8sPluginConfig(val, result)) +} + +func testDecodeRaw_K8sPluginConfig(t *testing.T, vStringSlice, result interface{}) { + assert.NoError(t, decode_K8sPluginConfig(vStringSlice, result)) +} + +func TestK8sPluginConfig_GetPFlagSet(t *testing.T) { + val := K8sPluginConfig{} + cmdFlags := val.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) +} + +func TestK8sPluginConfig_SetFlags(t *testing.T) { + actual := K8sPluginConfig{} + cmdFlags := actual.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) + + t.Run("Test_inject-finalizer", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("inject-finalizer", testValue) + if vBool, err := cmdFlags.GetBool("inject-finalizer"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vBool), &actual.InjectFinalizer) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_default-cpus", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := defaultK8sConfig.DefaultCPURequest.String() + + cmdFlags.Set("default-cpus", testValue) + if vString, err := cmdFlags.GetString("default-cpus"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vString), &actual.DefaultCPURequest) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_default-memory", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := defaultK8sConfig.DefaultMemoryRequest.String() + + cmdFlags.Set("default-memory", testValue) + if vString, err := cmdFlags.GetString("default-memory"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vString), &actual.DefaultMemoryRequest) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_scheduler-name", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("scheduler-name", testValue) + if vString, err := cmdFlags.GetString("scheduler-name"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vString), &actual.SchedulerName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_co-pilot.name", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("co-pilot.name", testValue) + if vString, err := cmdFlags.GetString("co-pilot.name"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vString), &actual.CoPilot.NamePrefix) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_co-pilot.image", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("co-pilot.image", testValue) + if vString, err := cmdFlags.GetString("co-pilot.image"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vString), &actual.CoPilot.Image) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_co-pilot.default-input-path", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("co-pilot.default-input-path", testValue) + if vString, err := cmdFlags.GetString("co-pilot.default-input-path"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vString), &actual.CoPilot.DefaultInputDataPath) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_co-pilot.default-output-path", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("co-pilot.default-output-path", testValue) + if vString, err := cmdFlags.GetString("co-pilot.default-output-path"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vString), &actual.CoPilot.DefaultOutputPath) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_co-pilot.input-vol-name", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("co-pilot.input-vol-name", testValue) + if vString, err := cmdFlags.GetString("co-pilot.input-vol-name"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vString), &actual.CoPilot.InputVolumeName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_co-pilot.output-vol-name", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("co-pilot.output-vol-name", testValue) + if vString, err := cmdFlags.GetString("co-pilot.output-vol-name"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vString), &actual.CoPilot.OutputVolumeName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_co-pilot.cpu", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("co-pilot.cpu", testValue) + if vString, err := cmdFlags.GetString("co-pilot.cpu"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vString), &actual.CoPilot.CPU) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_co-pilot.memory", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("co-pilot.memory", testValue) + if vString, err := cmdFlags.GetString("co-pilot.memory"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vString), &actual.CoPilot.Memory) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_co-pilot.storage", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("co-pilot.storage", testValue) + if vString, err := cmdFlags.GetString("co-pilot.storage"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vString), &actual.CoPilot.Storage) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_delete-resource-on-finalize", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("delete-resource-on-finalize", testValue) + if vBool, err := cmdFlags.GetBool("delete-resource-on-finalize"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vBool), &actual.DeleteResourceOnFinalize) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_default-pod-template-name", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("default-pod-template-name", testValue) + if vString, err := cmdFlags.GetString("default-pod-template-name"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vString), &actual.DefaultPodTemplateName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_default-pod-template-resync", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := defaultK8sConfig.DefaultPodTemplateResync.String() + + cmdFlags.Set("default-pod-template-resync", testValue) + if vString, err := cmdFlags.GetString("default-pod-template-resync"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vString), &actual.DefaultPodTemplateResync) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_send-object-events", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("send-object-events", testValue) + if vBool, err := cmdFlags.GetBool("send-object-events"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vBool), &actual.SendObjectEvents) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_update-base-backoff-duration", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("update-base-backoff-duration", testValue) + if vInt, err := cmdFlags.GetInt("update-base-backoff-duration"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vInt), &actual.UpdateBaseBackoffDuration) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_update-backoff-retries", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("update-backoff-retries", testValue) + if vInt, err := cmdFlags.GetInt("update-backoff-retries"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vInt), &actual.UpdateBackoffRetries) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_add-tolerations-for-extended-resources", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := join_K8sPluginConfig(defaultK8sConfig.AddTolerationsForExtendedResources, ",") + + cmdFlags.Set("add-tolerations-for-extended-resources", testValue) + if vStringSlice, err := cmdFlags.GetStringSlice("add-tolerations-for-extended-resources"); err == nil { + testDecodeRaw_K8sPluginConfig(t, join_K8sPluginConfig(vStringSlice, ","), &actual.AddTolerationsForExtendedResources) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_disable-inject-owner-references", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("disable-inject-owner-references", testValue) + if vBool, err := cmdFlags.GetBool("disable-inject-owner-references"); err == nil { + testDecodeJson_K8sPluginConfig(t, fmt.Sprintf("%v", vBool), &actual.DisableInjectOwnerReferences) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/container_helper.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/container_helper.go new file mode 100644 index 0000000000..a7f8d1adff --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/container_helper.go @@ -0,0 +1,358 @@ +package flytek8s + +import ( + "context" + + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + "k8s.io/apimachinery/pkg/util/rand" + "k8s.io/apimachinery/pkg/util/validation" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + pluginscore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/template" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const resourceGPU = "gpu" + +// ResourceNvidiaGPU is the name of the Nvidia GPU resource. +// Copied from: k8s.io/autoscaler/cluster-autoscaler/utils/gpu/gpu.go +const ResourceNvidiaGPU = "nvidia.com/gpu" + +// Specifies whether resource resolution should assign unset resource requests or limits from platform defaults +// or existing container values. +const assignIfUnset = true + +func MergeResources(in v1.ResourceRequirements, out *v1.ResourceRequirements) { + if out.Limits == nil { + out.Limits = in.Limits + } else if in.Limits != nil { + for key, val := range in.Limits { + out.Limits[key] = val + } + } + if out.Requests == nil { + out.Requests = in.Requests + } else if in.Requests != nil { + for key, val := range in.Requests { + out.Requests[key] = val + } + } +} + +type ResourceRequirement struct { + Request resource.Quantity + Limit resource.Quantity +} + +func resolvePlatformDefaults(platformResources v1.ResourceRequirements, configCPU, configMemory resource.Quantity) v1.ResourceRequirements { + if len(platformResources.Requests) == 0 { + platformResources.Requests = make(v1.ResourceList) + } + + if _, ok := platformResources.Requests[v1.ResourceCPU]; !ok { + platformResources.Requests[v1.ResourceCPU] = configCPU + } + + if _, ok := platformResources.Requests[v1.ResourceMemory]; !ok { + platformResources.Requests[v1.ResourceMemory] = configMemory + } + + if len(platformResources.Limits) == 0 { + platformResources.Limits = make(v1.ResourceList) + } + + return platformResources +} + +// AdjustOrDefaultResource validates resources conform to platform limits and assigns defaults for Request and Limit values by +// using the Request when the Limit is unset, and vice versa. +func AdjustOrDefaultResource(request, limit, platformDefault, platformLimit resource.Quantity) ResourceRequirement { + if request.IsZero() { + if !limit.IsZero() { + request = limit + } else { + request = platformDefault + } + } + + if limit.IsZero() { + limit = request + } + + return ensureResourceRange(request, limit, platformLimit) +} + +func ensureResourceLimit(value, limit resource.Quantity) resource.Quantity { + if value.IsZero() || limit.IsZero() { + return value + } + + if value.Cmp(limit) == 1 { + return limit + } + + return value +} + +// ensureResourceRange doesn't assign resources unless they need to be adjusted downwards +func ensureResourceRange(request, limit, platformLimit resource.Quantity) ResourceRequirement { + // Ensure request is < platformLimit + request = ensureResourceLimit(request, platformLimit) + // Ensure limit is < platformLimit + limit = ensureResourceLimit(limit, platformLimit) + // Ensure request is < limit + request = ensureResourceLimit(request, limit) + + return ResourceRequirement{ + Request: request, + Limit: limit, + } +} + +func adjustResourceRequirement(resourceName v1.ResourceName, resourceRequirements, + platformResources v1.ResourceRequirements, assignIfUnset bool) { + + var resourceValue ResourceRequirement + if assignIfUnset { + resourceValue = AdjustOrDefaultResource(resourceRequirements.Requests[resourceName], + resourceRequirements.Limits[resourceName], platformResources.Requests[resourceName], + platformResources.Limits[resourceName]) + } else { + resourceValue = ensureResourceRange(resourceRequirements.Requests[resourceName], + resourceRequirements.Limits[resourceName], platformResources.Limits[resourceName]) + } + + resourceRequirements.Requests[resourceName] = resourceValue.Request + resourceRequirements.Limits[resourceName] = resourceValue.Limit +} + +// SanitizeGPUResourceRequirements converts generic 'gpu' resource requirements to the desired accelerator resource name. +func SanitizeGPUResourceRequirements(resources *v1.ResourceRequirements, accelerator *core.GPUAccelerator) { + resourceName := config.GetK8sPluginConfig().GpuResourceName + if accelerator != nil { + resourceName = getAcceleratorResourceName(accelerator) + } + + if res, found := resources.Requests[resourceGPU]; found { + resources.Requests[resourceName] = res + delete(resources.Requests, resourceGPU) + } + + if res, found := resources.Limits[resourceGPU]; found { + resources.Limits[resourceName] = res + delete(resources.Limits, resourceGPU) + } +} + +// ApplyResourceOverrides handles resource resolution, allocation and validation. Primarily, it ensures that container +// resources do not exceed defined platformResource limits and in the case of assignIfUnset, ensures that limits and +// requests are sensibly set for resources of all types. +func ApplyResourceOverrides(resources, platformResources v1.ResourceRequirements, assignIfUnset bool) v1.ResourceRequirements { + if len(resources.Requests) == 0 { + resources.Requests = make(v1.ResourceList) + } + + if len(resources.Limits) == 0 { + resources.Limits = make(v1.ResourceList) + } + + // As a fallback, in the case the Flyte workflow object does not have platformResource defaults set, the defaults + // come from the plugin config. + platformResources = resolvePlatformDefaults(platformResources, config.GetK8sPluginConfig().DefaultCPURequest, + config.GetK8sPluginConfig().DefaultMemoryRequest) + + adjustResourceRequirement(v1.ResourceCPU, resources, platformResources, assignIfUnset) + adjustResourceRequirement(v1.ResourceMemory, resources, platformResources, assignIfUnset) + + _, ephemeralStorageRequested := resources.Requests[v1.ResourceEphemeralStorage] + _, ephemeralStorageLimited := resources.Limits[v1.ResourceEphemeralStorage] + + if ephemeralStorageRequested || ephemeralStorageLimited { + adjustResourceRequirement(v1.ResourceEphemeralStorage, resources, platformResources, assignIfUnset) + } + + // TODO: Make configurable. 1/15/2019 Flyte Cluster doesn't support setting storage requests/limits. + // https://github.com/kubernetes/enhancements/issues/362 + + // Check for accelerator resources (GPU, TPU, Neuron, etc.) + acceleratorResourceNames := getAllAcceleratorResourceNames() + for acceleratorResourceName := range acceleratorResourceNames { + _, requested := resources.Requests[acceleratorResourceName] + _, limited := resources.Limits[acceleratorResourceName] + if requested || limited { + adjustResourceRequirement(acceleratorResourceName, resources, platformResources, assignIfUnset) + } + } + + return resources +} + +// BuildRawContainer constructs a Container based on the definition passed by the TaskExecutionContext. +func BuildRawContainer(ctx context.Context, tCtx pluginscore.TaskExecutionContext) (*v1.Container, error) { + taskTemplate, err := tCtx.TaskReader().Read(ctx) + if err != nil { + logger.Warnf(ctx, "failed to read task information when trying to construct container, err: %s", err.Error()) + return nil, err + } + + // validate arguments + taskContainer := taskTemplate.GetContainer() + if taskContainer == nil { + return nil, errors.Errorf(errors.BadTaskSpecification, "unable to create container with no definition in TaskTemplate") + } + if tCtx.TaskExecutionMetadata().GetOverrides() == nil || tCtx.TaskExecutionMetadata().GetOverrides().GetResources() == nil { + return nil, errors.Errorf(errors.BadTaskSpecification, "resource requirements not found for container task, required!") + } + + // Make the container name the same as the pod name, unless it violates K8s naming conventions + // Container names are subject to the DNS-1123 standard + containerName := tCtx.TaskExecutionMetadata().GetTaskExecutionID().GetGeneratedName() + if errs := validation.IsDNS1123Label(containerName); len(errs) > 0 { + containerName = rand.String(4) + } + + res, err := ToK8sResourceRequirements(taskContainer.Resources) + if err != nil { + return nil, err + } + + container := &v1.Container{ + Name: containerName, + Image: taskContainer.GetImage(), + Args: taskContainer.GetArgs(), + Command: taskContainer.GetCommand(), + Env: ToK8sEnvVar(taskContainer.GetEnv()), + TerminationMessagePolicy: v1.TerminationMessageFallbackToLogsOnError, + Resources: *res, + ImagePullPolicy: config.GetK8sPluginConfig().ImagePullPolicy, + } + + return container, nil +} + +// ToK8sContainer builds a Container based on the definition passed by the TaskExecutionContext. This involves applying +// all Flyte configuration including k8s plugins and resource requests. +func ToK8sContainer(ctx context.Context, tCtx pluginscore.TaskExecutionContext) (*v1.Container, error) { + // build raw container + container, err := BuildRawContainer(ctx, tCtx) + if err != nil { + return nil, err + } + + // extract task template and extended resources + taskTemplate, err := tCtx.TaskReader().Read(ctx) + if err != nil { + return nil, err + } + + extendedResources := ApplyExtendedResourcesOverrides( + taskTemplate.GetExtendedResources(), + tCtx.TaskExecutionMetadata().GetOverrides().GetExtendedResources(), + ) + + if container.SecurityContext == nil && config.GetK8sPluginConfig().DefaultSecurityContext != nil { + container.SecurityContext = config.GetK8sPluginConfig().DefaultSecurityContext.DeepCopy() + } + + // add flyte resource customizations to the container + templateParameters := template.Parameters{ + TaskExecMetadata: tCtx.TaskExecutionMetadata(), + Inputs: tCtx.InputReader(), + OutputPath: tCtx.OutputWriter(), + Task: tCtx.TaskReader(), + } + + if err := AddFlyteCustomizationsToContainer(ctx, templateParameters, ResourceCustomizationModeMergeExistingResources, container, extendedResources); err != nil { + return nil, err + } + + return container, nil +} + +//go:generate enumer -type=ResourceCustomizationMode -trimprefix=ResourceCustomizationMode + +type ResourceCustomizationMode int + +const ( + // ResourceCustomizationModeAssignResources is used for container tasks where resources are validated and assigned if necessary. + ResourceCustomizationModeAssignResources ResourceCustomizationMode = iota + // ResourceCustomizationModeMergeExistingResources is used for primary containers in pod tasks where container requests and limits are + // merged, validated and assigned if necessary. + ResourceCustomizationModeMergeExistingResources + // ResourceCustomizationModeEnsureExistingResourcesInRange is used for secondary containers in pod tasks where requests and limits are only + // adjusted if needed (downwards). + ResourceCustomizationModeEnsureExistingResourcesInRange +) + +// AddFlyteCustomizationsToContainer takes a container definition which specifies how to run a Flyte task and fills in +// templated command and argument values, updates resources and decorates environment variables with platform and +// task-specific customizations. +func AddFlyteCustomizationsToContainer(ctx context.Context, parameters template.Parameters, + mode ResourceCustomizationMode, container *v1.Container, extendedResources *core.ExtendedResources) error { + modifiedCommand, err := template.Render(ctx, container.Command, parameters) + if err != nil { + return err + } + container.Command = modifiedCommand + + modifiedArgs, err := template.Render(ctx, container.Args, parameters) + if err != nil { + return err + } + container.Args = modifiedArgs + + // The flyteconsole url is added based on the `IncludeConsoleURL` bit set via the task template + consoleURL := "" + if parameters.IncludeConsoleURL { + consoleURL = parameters.TaskExecMetadata.GetConsoleURL() + } + container.Env, container.EnvFrom = DecorateEnvVars(ctx, container.Env, container.EnvFrom, parameters.TaskExecMetadata.GetEnvironmentVariables(), parameters.TaskExecMetadata.GetTaskExecutionID(), consoleURL) + + // Sanitize base container GPU resource requirements + // Overrides for extendedResources have already been applied at this point + SanitizeGPUResourceRequirements(&container.Resources, extendedResources.GetGpuAccelerator()) + + // retrieve platformResources and overrideResources to use when aggregating container resources + platformResources := parameters.TaskExecMetadata.GetPlatformResources().DeepCopy() + if platformResources == nil { + platformResources = &v1.ResourceRequirements{} + } + + var overrideResources *v1.ResourceRequirements + if parameters.TaskExecMetadata.GetOverrides() != nil && parameters.TaskExecMetadata.GetOverrides().GetResources() != nil { + overrideResources = parameters.TaskExecMetadata.GetOverrides().GetResources().DeepCopy() + } + + if overrideResources == nil { + overrideResources = &v1.ResourceRequirements{} + } else { + // Sanitize override resource requirements + SanitizeGPUResourceRequirements(overrideResources, extendedResources.GetGpuAccelerator()) + } + + logger.Infof(ctx, "ApplyResourceOverrides with Resources [%v], Platform Resources [%v] and Container"+ + " Resources [%v] with mode [%v]", overrideResources, platformResources, container.Resources, mode) + + switch mode { + case ResourceCustomizationModeAssignResources: + // this will use overrideResources to set container resources and fallback to the platformResource values. + // it is important to note that this ignores the existing container.Resources values. + container.Resources = ApplyResourceOverrides(*overrideResources, *platformResources, assignIfUnset) + case ResourceCustomizationModeMergeExistingResources: + // this merges the overrideResources on top of the existing container.Resources to apply the overrides, then it + // uses the platformResource values to set defaults for any missing resource. + MergeResources(*overrideResources, &container.Resources) + container.Resources = ApplyResourceOverrides(container.Resources, *platformResources, assignIfUnset) + case ResourceCustomizationModeEnsureExistingResourcesInRange: + // this use the platformResources defaults to ensure that the container.Resources values are within the + // platformResources limits. it will not override any existing container.Resources values. + container.Resources = ApplyResourceOverrides(container.Resources, *platformResources, !assignIfUnset) + } + + logger.Infof(ctx, "Adjusted container resources [%v]", container.Resources) + return nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/container_helper_test.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/container_helper_test.go new file mode 100644 index 0000000000..5fe9b3709c --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/container_helper_test.go @@ -0,0 +1,1103 @@ +package flytek8s + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + "k8s.io/apimachinery/pkg/util/validation" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/template" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + mocks2 "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io/mocks" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +var zeroQuantity = resource.MustParse("0") + +func TestAssignResource(t *testing.T) { + t.Run("Leave valid requests and limits unchanged", func(t *testing.T) { + res := AdjustOrDefaultResource( + resource.MustParse("1"), resource.MustParse("2"), + resource.MustParse("10"), resource.MustParse("20")) + assert.True(t, res.Request.Equal(resource.MustParse("1"))) + assert.True(t, res.Limit.Equal(resource.MustParse("2"))) + }) + t.Run("Assign unset Request from Limit", func(t *testing.T) { + res := AdjustOrDefaultResource( + zeroQuantity, resource.MustParse("2"), + resource.MustParse("10"), resource.MustParse("20")) + assert.True(t, res.Request.Equal(resource.MustParse("2"))) + assert.True(t, res.Limit.Equal(resource.MustParse("2"))) + }) + t.Run("Assign unset Limit from Request", func(t *testing.T) { + res := AdjustOrDefaultResource( + resource.MustParse("2"), zeroQuantity, + resource.MustParse("10"), resource.MustParse("20")) + assert.Equal(t, resource.MustParse("2"), res.Request) + assert.Equal(t, resource.MustParse("2"), res.Limit) + }) + t.Run("Assign from platform defaults", func(t *testing.T) { + res := AdjustOrDefaultResource( + zeroQuantity, zeroQuantity, + resource.MustParse("10"), resource.MustParse("20")) + assert.Equal(t, resource.MustParse("10"), res.Request) + assert.Equal(t, resource.MustParse("10"), res.Limit) + }) + t.Run("Adjust Limit when Request > Limit", func(t *testing.T) { + res := AdjustOrDefaultResource( + resource.MustParse("10"), resource.MustParse("2"), + resource.MustParse("10"), resource.MustParse("20")) + assert.Equal(t, resource.MustParse("2"), res.Request) + assert.Equal(t, resource.MustParse("2"), res.Limit) + }) + t.Run("Adjust Limit > platformLimit", func(t *testing.T) { + res := AdjustOrDefaultResource( + resource.MustParse("1"), resource.MustParse("40"), + resource.MustParse("10"), resource.MustParse("20")) + assert.True(t, res.Request.Equal(resource.MustParse("1"))) + assert.True(t, res.Limit.Equal(resource.MustParse("20"))) + }) + t.Run("Adjust Request, Limit > platformLimit", func(t *testing.T) { + res := AdjustOrDefaultResource( + resource.MustParse("40"), resource.MustParse("50"), + resource.MustParse("10"), resource.MustParse("20")) + assert.True(t, res.Request.Equal(resource.MustParse("20"))) + assert.True(t, res.Limit.Equal(resource.MustParse("20"))) + }) +} + +func TestValidateResource(t *testing.T) { + platformLimit := resource.MustParse("5") + t.Run("adjust when Request > Limit", func(t *testing.T) { + res := ensureResourceRange(resource.MustParse("4"), resource.MustParse("3"), platformLimit) + assert.True(t, res.Request.Equal(resource.MustParse("3"))) + assert.True(t, res.Limit.Equal(resource.MustParse("3"))) + }) + t.Run("adjust when Request > platformLimit", func(t *testing.T) { + res := ensureResourceRange(resource.MustParse("6"), platformLimit, platformLimit) + assert.True(t, res.Request.Equal(platformLimit)) + assert.True(t, res.Limit.Equal(platformLimit)) + }) + t.Run("adjust when Limit > platformLimit", func(t *testing.T) { + res := ensureResourceRange(resource.MustParse("4"), resource.MustParse("6"), platformLimit) + assert.True(t, res.Request.Equal(resource.MustParse("4"))) + assert.True(t, res.Limit.Equal(platformLimit)) + }) + t.Run("nothing to do", func(t *testing.T) { + res := ensureResourceRange(resource.MustParse("1"), resource.MustParse("2"), platformLimit) + assert.True(t, res.Request.Equal(resource.MustParse("1"))) + assert.True(t, res.Limit.Equal(resource.MustParse("2"))) + }) +} + +func TestApplyResourceOverrides_OverrideCpu(t *testing.T) { + platformRequirements := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("3"), + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("10"), + }, + } + cpuRequest := resource.MustParse("1") + overrides := ApplyResourceOverrides(v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: cpuRequest, + }, + }, platformRequirements, assignIfUnset) + assert.EqualValues(t, cpuRequest, overrides.Requests[v1.ResourceCPU]) + assert.EqualValues(t, cpuRequest, overrides.Limits[v1.ResourceCPU]) + + cpuLimit := resource.MustParse("2") + overrides = ApplyResourceOverrides(v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: cpuRequest, + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: cpuLimit, + }, + }, platformRequirements, assignIfUnset) + assert.EqualValues(t, cpuRequest, overrides.Requests[v1.ResourceCPU]) + assert.EqualValues(t, cpuLimit, overrides.Limits[v1.ResourceCPU]) + + // Request equals Limit if not set + overrides = ApplyResourceOverrides(v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceCPU: cpuLimit, + }, + }, platformRequirements, assignIfUnset) + assert.EqualValues(t, cpuLimit, overrides.Requests[v1.ResourceCPU]) + assert.EqualValues(t, cpuLimit, overrides.Limits[v1.ResourceCPU]) +} + +func TestApplyResourceOverrides_OverrideMemory(t *testing.T) { + memoryRequest := resource.MustParse("1") + platformRequirements := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceMemory: resource.MustParse("3"), + }, + Limits: v1.ResourceList{ + v1.ResourceMemory: resource.MustParse("10"), + }, + } + overrides := ApplyResourceOverrides(v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceMemory: memoryRequest, + }, + }, platformRequirements, assignIfUnset) + assert.EqualValues(t, memoryRequest, overrides.Requests[v1.ResourceMemory]) + assert.EqualValues(t, memoryRequest, overrides.Limits[v1.ResourceMemory]) + + memoryLimit := resource.MustParse("2") + overrides = ApplyResourceOverrides(v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceMemory: memoryRequest, + }, + Limits: v1.ResourceList{ + v1.ResourceMemory: memoryLimit, + }, + }, platformRequirements, assignIfUnset) + assert.EqualValues(t, memoryRequest, overrides.Requests[v1.ResourceMemory]) + assert.EqualValues(t, memoryLimit, overrides.Limits[v1.ResourceMemory]) + + // Request equals Limit if not set + overrides = ApplyResourceOverrides(v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceMemory: memoryLimit, + }, + }, platformRequirements, assignIfUnset) + assert.EqualValues(t, memoryLimit, overrides.Requests[v1.ResourceMemory]) + assert.EqualValues(t, memoryLimit, overrides.Limits[v1.ResourceMemory]) +} + +func TestApplyResourceOverrides_OverrideEphemeralStorage(t *testing.T) { + ephemeralStorageRequest := resource.MustParse("1") + overrides := ApplyResourceOverrides(v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceEphemeralStorage: ephemeralStorageRequest, + }, + }, v1.ResourceRequirements{}, assignIfUnset) + assert.EqualValues(t, ephemeralStorageRequest, overrides.Requests[v1.ResourceEphemeralStorage]) + assert.EqualValues(t, ephemeralStorageRequest, overrides.Limits[v1.ResourceEphemeralStorage]) + + ephemeralStorageLimit := resource.MustParse("2") + overrides = ApplyResourceOverrides(v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceEphemeralStorage: ephemeralStorageRequest, + }, + Limits: v1.ResourceList{ + v1.ResourceEphemeralStorage: ephemeralStorageLimit, + }, + }, v1.ResourceRequirements{}, assignIfUnset) + assert.EqualValues(t, ephemeralStorageRequest, overrides.Requests[v1.ResourceEphemeralStorage]) + assert.EqualValues(t, ephemeralStorageLimit, overrides.Limits[v1.ResourceEphemeralStorage]) + + // Request equals Limit if not set + overrides = ApplyResourceOverrides(v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceEphemeralStorage: ephemeralStorageLimit, + }, + }, v1.ResourceRequirements{}, assignIfUnset) + assert.EqualValues(t, ephemeralStorageLimit, overrides.Requests[v1.ResourceEphemeralStorage]) +} + +func TestApplyResourceOverrides_RemoveStorage(t *testing.T) { + requestedResourceQuantity := resource.MustParse("1") + overrides := ApplyResourceOverrides(v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceMemory: requestedResourceQuantity, + v1.ResourceCPU: requestedResourceQuantity, + v1.ResourceEphemeralStorage: requestedResourceQuantity, + }, + Limits: v1.ResourceList{ + v1.ResourceMemory: requestedResourceQuantity, + v1.ResourceEphemeralStorage: requestedResourceQuantity, + }, + }, v1.ResourceRequirements{}, assignIfUnset) + assert.EqualValues(t, v1.ResourceList{ + v1.ResourceMemory: requestedResourceQuantity, + v1.ResourceCPU: requestedResourceQuantity, + v1.ResourceEphemeralStorage: requestedResourceQuantity, + }, overrides.Requests) + + assert.EqualValues(t, v1.ResourceList{ + v1.ResourceMemory: requestedResourceQuantity, + v1.ResourceCPU: requestedResourceQuantity, + v1.ResourceEphemeralStorage: requestedResourceQuantity, + }, overrides.Limits) +} + +func TestApplyResourceOverrides_OverrideGpu(t *testing.T) { + gpuRequest := resource.MustParse("1") + overrides := ApplyResourceOverrides(v1.ResourceRequirements{ + Requests: v1.ResourceList{ + ResourceNvidiaGPU: gpuRequest, + }, + }, v1.ResourceRequirements{}, assignIfUnset) + assert.EqualValues(t, gpuRequest, overrides.Requests[ResourceNvidiaGPU]) + + overrides = ApplyResourceOverrides(v1.ResourceRequirements{ + Limits: v1.ResourceList{ + ResourceNvidiaGPU: gpuRequest, + }, + }, v1.ResourceRequirements{}, assignIfUnset) + assert.EqualValues(t, gpuRequest, overrides.Limits[ResourceNvidiaGPU]) +} + +func TestSanitizeGPUResourceRequirements(t *testing.T) { + t.Run("nil accelerator defaults to NVIDIA GPU", func(t *testing.T) { + gpuRequest := resource.MustParse("4") + requirements := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + resourceGPU: gpuRequest, + }, + } + + expectedRequirements := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + ResourceNvidiaGPU: gpuRequest, + }, + } + + SanitizeGPUResourceRequirements(&requirements, nil) + assert.EqualValues(t, expectedRequirements, requirements) + }) + + t.Run("NVIDIA_GPU device class", func(t *testing.T) { + gpuRequest := resource.MustParse("2") + requirements := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + resourceGPU: gpuRequest, + }, + Limits: v1.ResourceList{ + resourceGPU: gpuRequest, + }, + } + + accelerator := &core.GPUAccelerator{ + Device: "nvidia-tesla-a100", + DeviceClass: core.GPUAccelerator_NVIDIA_GPU, + } + + expectedRequirements := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceName("nvidia.com/gpu"): gpuRequest, + }, + Limits: v1.ResourceList{ + v1.ResourceName("nvidia.com/gpu"): gpuRequest, + }, + } + + SanitizeGPUResourceRequirements(&requirements, accelerator) + assert.EqualValues(t, expectedRequirements, requirements) + }) + + t.Run("GOOGLE_TPU device class", func(t *testing.T) { + tpuRequest := resource.MustParse("4") + requirements := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + resourceGPU: tpuRequest, + }, + Limits: v1.ResourceList{ + resourceGPU: tpuRequest, + }, + } + + accelerator := &core.GPUAccelerator{ + Device: "tpu-v4", + DeviceClass: core.GPUAccelerator_GOOGLE_TPU, + } + + expectedRequirements := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceName("google.com/tpu"): tpuRequest, + }, + Limits: v1.ResourceList{ + v1.ResourceName("google.com/tpu"): tpuRequest, + }, + } + + SanitizeGPUResourceRequirements(&requirements, accelerator) + assert.EqualValues(t, expectedRequirements, requirements) + }) + + t.Run("AMAZON_NEURON device class", func(t *testing.T) { + neuronRequest := resource.MustParse("1") + requirements := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + resourceGPU: neuronRequest, + }, + } + + accelerator := &core.GPUAccelerator{ + Device: "inferentia2", + DeviceClass: core.GPUAccelerator_AMAZON_NEURON, + } + + expectedRequirements := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceName("aws.amazon.com/neuron"): neuronRequest, + }, + } + + SanitizeGPUResourceRequirements(&requirements, accelerator) + assert.EqualValues(t, expectedRequirements, requirements) + }) + + t.Run("AMD_GPU device class", func(t *testing.T) { + gpuRequest := resource.MustParse("1") + requirements := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + resourceGPU: gpuRequest, + }, + } + + accelerator := &core.GPUAccelerator{ + Device: "amd-mi250", + DeviceClass: core.GPUAccelerator_AMD_GPU, + } + + expectedRequirements := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceName("amd.com/gpu"): gpuRequest, + }, + } + + SanitizeGPUResourceRequirements(&requirements, accelerator) + assert.EqualValues(t, expectedRequirements, requirements) + }) + + t.Run("HABANA_GAUDI device class", func(t *testing.T) { + gpuRequest := resource.MustParse("1") + requirements := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + resourceGPU: gpuRequest, + }, + } + + accelerator := &core.GPUAccelerator{ + Device: "habana-gaudi-dl1", + DeviceClass: core.GPUAccelerator_HABANA_GAUDI, + } + + expectedRequirements := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceName("habana.ai/gaudi"): gpuRequest, + }, + } + + SanitizeGPUResourceRequirements(&requirements, accelerator) + assert.EqualValues(t, expectedRequirements, requirements) + }) +} + +func TestMergeResources_EmptyIn(t *testing.T) { + requestedResourceQuantity := resource.MustParse("1") + expectedResources := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceMemory: requestedResourceQuantity, + v1.ResourceCPU: requestedResourceQuantity, + v1.ResourceEphemeralStorage: requestedResourceQuantity, + }, + Limits: v1.ResourceList{ + v1.ResourceMemory: requestedResourceQuantity, + v1.ResourceEphemeralStorage: requestedResourceQuantity, + }, + } + outResources := expectedResources.DeepCopy() + MergeResources(v1.ResourceRequirements{}, outResources) + assert.EqualValues(t, *outResources, expectedResources) +} + +func TestMergeResources_EmptyOut(t *testing.T) { + requestedResourceQuantity := resource.MustParse("1") + expectedResources := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceMemory: requestedResourceQuantity, + v1.ResourceCPU: requestedResourceQuantity, + v1.ResourceEphemeralStorage: requestedResourceQuantity, + }, + Limits: v1.ResourceList{ + v1.ResourceMemory: requestedResourceQuantity, + v1.ResourceEphemeralStorage: requestedResourceQuantity, + }, + } + outResources := v1.ResourceRequirements{} + MergeResources(expectedResources, &outResources) + assert.EqualValues(t, outResources, expectedResources) +} + +func TestMergeResources_PartialRequirements(t *testing.T) { + requestedResourceQuantity := resource.MustParse("1") + resourceList := v1.ResourceList{ + v1.ResourceMemory: requestedResourceQuantity, + v1.ResourceCPU: requestedResourceQuantity, + v1.ResourceEphemeralStorage: requestedResourceQuantity, + } + inResources := v1.ResourceRequirements{Requests: resourceList} + outResources := v1.ResourceRequirements{Limits: resourceList} + MergeResources(inResources, &outResources) + assert.EqualValues(t, outResources, v1.ResourceRequirements{ + Requests: resourceList, + Limits: resourceList, + }) +} + +func TestMergeResources_PartialResourceKeys(t *testing.T) { + requestedResourceQuantity := resource.MustParse("1") + resourceList1 := v1.ResourceList{ + v1.ResourceMemory: requestedResourceQuantity, + v1.ResourceEphemeralStorage: requestedResourceQuantity, + } + resourceList2 := v1.ResourceList{v1.ResourceCPU: requestedResourceQuantity} + expectedResourceList := v1.ResourceList{ + v1.ResourceCPU: requestedResourceQuantity, + v1.ResourceMemory: requestedResourceQuantity, + v1.ResourceEphemeralStorage: requestedResourceQuantity, + } + inResources := v1.ResourceRequirements{ + Requests: resourceList1, + Limits: resourceList2, + } + outResources := v1.ResourceRequirements{ + Requests: resourceList2, + Limits: resourceList1, + } + MergeResources(inResources, &outResources) + assert.EqualValues(t, outResources, v1.ResourceRequirements{ + Requests: expectedResourceList, + Limits: expectedResourceList, + }) +} + +func TestToK8sContainer(t *testing.T) { + taskTemplate := &core.TaskTemplate{ + Type: "test", + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Image: "myimage", + Args: []string{ + "arg1", + "arg2", + "arg3", + }, + Command: []string{ + "com1", + "com2", + "com3", + }, + Env: []*core.KeyValuePair{ + { + Key: "k", + Value: "v", + }, + }, + }, + }, + } + + taskReader := &mocks.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(taskTemplate, nil) + + inputReader := &mocks2.InputReader{} + inputReader.EXPECT().GetInputPath().Return(storage.DataReference("test-data-reference")) + inputReader.EXPECT().GetInputPrefixPath().Return(storage.DataReference("test-data-reference-prefix")) + inputReader.EXPECT().Get(mock.Anything).Return(&core.LiteralMap{}, nil) + + outputWriter := &mocks2.OutputWriter{} + outputWriter.EXPECT().GetOutputPrefixPath().Return("") + outputWriter.EXPECT().GetRawOutputPrefix().Return("") + outputWriter.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + outputWriter.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + + mockTaskExecMetadata := mocks.TaskExecutionMetadata{} + mockTaskOverrides := mocks.TaskOverrides{} + mockTaskOverrides.EXPECT().GetResources().Return(&v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceEphemeralStorage: resource.MustParse("1024Mi"), + }, + }) + mockTaskOverrides.EXPECT().GetExtendedResources().Return(nil) + mockTaskExecMetadata.EXPECT().GetOverrides().Return(&mockTaskOverrides) + mockTaskExecutionID := mocks.TaskExecutionID{} + mockTaskExecutionID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{}) + mockTaskExecutionID.EXPECT().GetGeneratedName().Return("gen_name") + mockTaskExecMetadata.EXPECT().GetTaskExecutionID().Return(&mockTaskExecutionID) + mockTaskExecMetadata.EXPECT().GetPlatformResources().Return(&v1.ResourceRequirements{}) + mockTaskExecMetadata.EXPECT().GetEnvironmentVariables().Return(map[string]string{ + "foo": "bar", + }) + mockTaskExecMetadata.EXPECT().GetNamespace().Return("my-namespace") + mockTaskExecMetadata.EXPECT().GetConsoleURL().Return("") + + tCtx := &mocks.TaskExecutionContext{} + tCtx.EXPECT().TaskExecutionMetadata().Return(&mockTaskExecMetadata) + tCtx.EXPECT().InputReader().Return(inputReader) + tCtx.EXPECT().TaskReader().Return(taskReader) + tCtx.EXPECT().OutputWriter().Return(outputWriter) + + cfg := config.GetK8sPluginConfig() + allow := false + cfg.DefaultSecurityContext = &v1.SecurityContext{ + AllowPrivilegeEscalation: &allow, + } + assert.NoError(t, config.SetK8sPluginConfig(cfg)) + + container, err := ToK8sContainer(context.TODO(), tCtx) + assert.NoError(t, err) + assert.Equal(t, container.Image, "myimage") + assert.EqualValues(t, []string{ + "arg1", + "arg2", + "arg3", + }, container.Args) + assert.EqualValues(t, []string{ + "com1", + "com2", + "com3", + }, container.Command) + assert.EqualValues(t, []v1.EnvVar{ + { + Name: "k", + Value: "v", + }, + { + Name: "foo", + Value: "bar", + }, + }, container.Env) + errs := validation.IsDNS1123Label(container.Name) + assert.Nil(t, errs) + assert.NotNil(t, container.SecurityContext) + assert.False(t, *container.SecurityContext.AllowPrivilegeEscalation) +} + +func getTemplateParametersForTest(resourceRequirements, platformResources *v1.ResourceRequirements, includeConsoleURL bool, consoleURL string) template.Parameters { + mockTaskExecMetadata := mocks.TaskExecutionMetadata{} + mockTaskExecutionID := mocks.TaskExecutionID{} + mockTaskExecutionID.EXPECT().GetUniqueNodeID().Return("unique_node_id") + mockTaskExecutionID.EXPECT().GetGeneratedName().Return("gen_name") + mockTaskExecutionID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + TaskId: &core.Identifier{ + ResourceType: core.ResourceType_TASK, + Project: "p1", + Domain: "d1", + Name: "task_name", + Version: "v1", + }, + NodeExecutionId: &core.NodeExecutionIdentifier{ + NodeId: "node_id", + ExecutionId: &core.WorkflowExecutionIdentifier{ + Project: "p2", + Domain: "d2", + Name: "n2", + }, + }, + RetryAttempt: 1, + }) + mockTaskExecMetadata.EXPECT().GetTaskExecutionID().Return(&mockTaskExecutionID) + + mockOverrides := mocks.TaskOverrides{} + mockOverrides.EXPECT().GetResources().Return(resourceRequirements) + mockTaskExecMetadata.EXPECT().GetOverrides().Return(&mockOverrides) + mockTaskExecMetadata.EXPECT().GetPlatformResources().Return(platformResources) + mockTaskExecMetadata.EXPECT().GetEnvironmentVariables().Return(nil) + mockTaskExecMetadata.EXPECT().GetNamespace().Return("my-namespace") + mockTaskExecMetadata.EXPECT().GetConsoleURL().Return(consoleURL) + + mockInputReader := mocks2.InputReader{} + mockInputPath := storage.DataReference("s3://input/path") + mockInputReader.EXPECT().GetInputPath().Return(mockInputPath) + mockInputReader.EXPECT().GetInputPrefixPath().Return(mockInputPath) + mockInputReader.EXPECT().Get(mock.Anything).Return(nil, nil) + + mockOutputPath := mocks2.OutputFilePaths{} + mockOutputPathPrefix := storage.DataReference("s3://output/path") + mockOutputPath.EXPECT().GetRawOutputPrefix().Return(mockOutputPathPrefix) + mockOutputPath.EXPECT().GetOutputPrefixPath().Return(mockOutputPathPrefix) + mockOutputPath.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + mockOutputPath.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + + return template.Parameters{ + TaskExecMetadata: &mockTaskExecMetadata, + Inputs: &mockInputReader, + OutputPath: &mockOutputPath, + IncludeConsoleURL: includeConsoleURL, + } +} + +func TestAddFlyteCustomizationsToContainer(t *testing.T) { + templateParameters := getTemplateParametersForTest(&v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceEphemeralStorage: resource.MustParse("1024Mi"), + }, + Limits: v1.ResourceList{ + v1.ResourceEphemeralStorage: resource.MustParse("2048Mi"), + }, + }, nil, false, "") + container := &v1.Container{ + Command: []string{ + "{{ .Input }}", + }, + Args: []string{ + "{{ .OutputPrefix }}", + }, + } + err := AddFlyteCustomizationsToContainer(context.TODO(), templateParameters, ResourceCustomizationModeAssignResources, container, nil) + assert.NoError(t, err) + assert.EqualValues(t, container.Args, []string{"s3://output/path"}) + assert.EqualValues(t, container.Command, []string{"s3://input/path"}) + assert.Len(t, container.Resources.Limits, 3) + assert.Len(t, container.Resources.Requests, 3) + assert.Len(t, container.Env, 13) +} + +func TestAddFlyteCustomizationsToContainer_Resources(t *testing.T) { + container := &v1.Container{ + Command: []string{ + "{{ .Input }}", + }, + Args: []string{ + "{{ .OutputPrefix }}", + }, + Resources: v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1"), + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("10"), + }, + }, + } + + t.Run("merge requests/limits for pod tasks - primary container", func(t *testing.T) { + templateParameters := getTemplateParametersForTest(&v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceMemory: resource.MustParse("2"), + }, + }, &v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceMemory: resource.MustParse("2"), + }, + Limits: v1.ResourceList{ + v1.ResourceMemory: resource.MustParse("20"), + }, + }, false, "") + err := AddFlyteCustomizationsToContainer(context.TODO(), templateParameters, ResourceCustomizationModeMergeExistingResources, container, nil) + assert.NoError(t, err) + assert.True(t, container.Resources.Requests.Cpu().Equal(resource.MustParse("1"))) + assert.True(t, container.Resources.Limits.Cpu().Equal(resource.MustParse("10"))) + assert.True(t, container.Resources.Requests.Memory().Equal(resource.MustParse("2"))) + assert.True(t, container.Resources.Limits.Memory().Equal(resource.MustParse("2"))) + }) + t.Run("enforce merge requests/limits for pod tasks - values from task overrides", func(t *testing.T) { + templateParameters := getTemplateParametersForTest(&v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceMemory: resource.MustParse("2"), + }, + Limits: v1.ResourceList{ + v1.ResourceMemory: resource.MustParse("200"), + }, + }, &v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceMemory: resource.MustParse("2"), + }, + Limits: v1.ResourceList{ + v1.ResourceMemory: resource.MustParse("20"), + }, + }, false, "") + err := AddFlyteCustomizationsToContainer(context.TODO(), templateParameters, ResourceCustomizationModeMergeExistingResources, container, nil) + assert.NoError(t, err) + assert.True(t, container.Resources.Requests.Cpu().Equal(resource.MustParse("1"))) + assert.True(t, container.Resources.Limits.Cpu().Equal(resource.MustParse("10"))) + assert.True(t, container.Resources.Requests.Memory().Equal(resource.MustParse("2"))) + assert.True(t, container.Resources.Limits.Memory().Equal(resource.MustParse("20"))) + }) + t.Run("enforce requests/limits for pod tasks - values from container", func(t *testing.T) { + container := &v1.Container{ + Command: []string{ + "{{ .Input }}", + }, + Args: []string{ + "{{ .OutputPrefix }}", + }, + Resources: v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("100"), + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("100"), + }, + }, + } + + templateParameters := getTemplateParametersForTest(&v1.ResourceRequirements{}, &v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1"), + v1.ResourceMemory: resource.MustParse("2"), + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("10"), + v1.ResourceMemory: resource.MustParse("20"), + }, + }, false, "") + err := AddFlyteCustomizationsToContainer(context.TODO(), templateParameters, ResourceCustomizationModeMergeExistingResources, container, nil) + assert.NoError(t, err) + assert.True(t, container.Resources.Requests.Cpu().Equal(resource.MustParse("10"))) + assert.True(t, container.Resources.Limits.Cpu().Equal(resource.MustParse("10"))) + assert.True(t, container.Resources.Requests.Memory().Equal(resource.MustParse("2"))) + assert.True(t, container.Resources.Limits.Memory().Equal(resource.MustParse("2"))) + }) + t.Run("ensure gpu resource overriding works for tasks with pod templates", func(t *testing.T) { + container := &v1.Container{ + Command: []string{ + "{{ .Input }}", + }, + Args: []string{ + "{{ .OutputPrefix }}", + }, + Resources: v1.ResourceRequirements{ + Requests: v1.ResourceList{ + resourceGPU: resource.MustParse("2"), // Tasks with pod templates request resource via the "gpu" key + }, + Limits: v1.ResourceList{ + resourceGPU: resource.MustParse("2"), + }, + }, + } + + overrideRequests := v1.ResourceList{ + ResourceNvidiaGPU: resource.MustParse("4"), // Resource overrides specify the "nvidia.com/gpu" key + } + + overrideLimits := v1.ResourceList{ + ResourceNvidiaGPU: resource.MustParse("4"), + } + + templateParameters := getTemplateParametersForTest(&v1.ResourceRequirements{ + Requests: overrideRequests, + Limits: overrideLimits, + }, &v1.ResourceRequirements{}, false, "") + + err := AddFlyteCustomizationsToContainer(context.TODO(), templateParameters, ResourceCustomizationModeMergeExistingResources, container, nil) + assert.NoError(t, err) + assert.Equal(t, container.Resources.Requests[ResourceNvidiaGPU], overrideRequests[ResourceNvidiaGPU]) + assert.Equal(t, container.Resources.Limits[ResourceNvidiaGPU], overrideLimits[ResourceNvidiaGPU]) + }) + t.Run("ensure ExtendedResources.gpu_accelerator.device_class is respected when setting gpu resources", func(t *testing.T) { + container := &v1.Container{ + Command: []string{ + "{{ .Input }}", + }, + Args: []string{ + "{{ .OutputPrefix }}", + }, + Resources: v1.ResourceRequirements{ + Requests: v1.ResourceList{ + resourceGPU: resource.MustParse("2"), + }, + Limits: v1.ResourceList{ + resourceGPU: resource.MustParse("2"), + }, + }, + } + + tpuExtendedResources := &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "tpu-v4", + DeviceClass: core.GPUAccelerator_GOOGLE_TPU, + }, + } + + templateParameters := getTemplateParametersForTest(&v1.ResourceRequirements{}, &v1.ResourceRequirements{}, false, "") + + err := AddFlyteCustomizationsToContainer(context.TODO(), templateParameters, ResourceCustomizationModeMergeExistingResources, container, tpuExtendedResources) + assert.NoError(t, err) + + // Verify generic "gpu" key is removed + _, hasGenericGPU := container.Resources.Requests[resourceGPU] + assert.False(t, hasGenericGPU) + + // Verify TPU resource is set correctly + expectedTPU := resource.MustParse("2") + assert.Equal(t, expectedTPU, container.Resources.Requests[v1.ResourceName("google.com/tpu")]) + assert.Equal(t, expectedTPU, container.Resources.Limits[v1.ResourceName("google.com/tpu")]) + }) +} + +func TestAddFlyteCustomizationsToContainer_ValidateExistingResources(t *testing.T) { + container := &v1.Container{ + Command: []string{ + "{{ .Input }}", + }, + Args: []string{ + "{{ .OutputPrefix }}", + }, + Resources: v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("100"), + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("200"), + }, + }, + } + templateParameters := getTemplateParametersForTest(&v1.ResourceRequirements{}, &v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1"), + v1.ResourceMemory: resource.MustParse("2"), + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("10"), + v1.ResourceMemory: resource.MustParse("20"), + }, + }, false, "") + err := AddFlyteCustomizationsToContainer(context.TODO(), templateParameters, ResourceCustomizationModeEnsureExistingResourcesInRange, container, nil) + assert.NoError(t, err) + + assert.True(t, container.Resources.Requests.Cpu().Equal(resource.MustParse("10"))) + assert.True(t, container.Resources.Limits.Cpu().Equal(resource.MustParse("10"))) +} + +func TestAddFlyteCustomizationsToContainer_GPUResourceOverride(t *testing.T) { + type testCase struct { + name string + initialResources v1.ResourceRequirements + overrideResources v1.ResourceRequirements + extendedResources *core.ExtendedResources + customizationMode ResourceCustomizationMode + expectedRequests v1.ResourceList + expectedLimits v1.ResourceList + } + + tests := []testCase{ + { + name: "override gpu: 1 translates to nvidia.com/gpu", + initialResources: v1.ResourceRequirements{}, + overrideResources: v1.ResourceRequirements{ + Requests: v1.ResourceList{resourceGPU: resource.MustParse("1")}, + Limits: v1.ResourceList{resourceGPU: resource.MustParse("1")}, + }, + extendedResources: nil, + customizationMode: ResourceCustomizationModeAssignResources, + expectedRequests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1"), + v1.ResourceMemory: resource.MustParse("1Gi"), + ResourceNvidiaGPU: resource.MustParse("1"), + }, + expectedLimits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1"), + v1.ResourceMemory: resource.MustParse("1Gi"), + ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + { + name: "override gpu: 1 with extended resources for TPU", + initialResources: v1.ResourceRequirements{}, + overrideResources: v1.ResourceRequirements{ + Requests: v1.ResourceList{resourceGPU: resource.MustParse("1")}, + }, + extendedResources: &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "tpu-v4", + DeviceClass: core.GPUAccelerator_GOOGLE_TPU, + }, + }, + customizationMode: ResourceCustomizationModeAssignResources, + expectedRequests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1"), + v1.ResourceMemory: resource.MustParse("1Gi"), + v1.ResourceName("google.com/tpu"): resource.MustParse("1"), + }, + expectedLimits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1"), + v1.ResourceMemory: resource.MustParse("1Gi"), + v1.ResourceName("google.com/tpu"): resource.MustParse("1"), + }, + }, + { + name: "merge mode - override gpu on container with existing cpu/memory resources", + initialResources: v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("2"), + v1.ResourceMemory: resource.MustParse("4Gi"), + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("4"), + v1.ResourceMemory: resource.MustParse("8Gi"), + }, + }, + overrideResources: v1.ResourceRequirements{ + Requests: v1.ResourceList{resourceGPU: resource.MustParse("2")}, + Limits: v1.ResourceList{resourceGPU: resource.MustParse("2")}, + }, + extendedResources: nil, + customizationMode: ResourceCustomizationModeMergeExistingResources, + expectedRequests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("2"), + v1.ResourceMemory: resource.MustParse("4Gi"), + ResourceNvidiaGPU: resource.MustParse("2"), + }, + expectedLimits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("4"), + v1.ResourceMemory: resource.MustParse("8Gi"), + ResourceNvidiaGPU: resource.MustParse("2"), + }, + }, + { + name: "merge mode - override gpu replaces existing gpu in container", + initialResources: v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("2"), + v1.ResourceMemory: resource.MustParse("4Gi"), + resourceGPU: resource.MustParse("1"), + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("4"), + v1.ResourceMemory: resource.MustParse("8Gi"), + resourceGPU: resource.MustParse("1"), + }, + }, + overrideResources: v1.ResourceRequirements{ + Requests: v1.ResourceList{resourceGPU: resource.MustParse("4")}, + Limits: v1.ResourceList{resourceGPU: resource.MustParse("4")}, + }, + extendedResources: nil, + customizationMode: ResourceCustomizationModeMergeExistingResources, + expectedRequests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("2"), + v1.ResourceMemory: resource.MustParse("4Gi"), + ResourceNvidiaGPU: resource.MustParse("4"), + }, + expectedLimits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("4"), + v1.ResourceMemory: resource.MustParse("8Gi"), + ResourceNvidiaGPU: resource.MustParse("4"), + }, + }, + { + name: "merge mode - override gpu with TPU on container with existing resources", + initialResources: v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("8"), + v1.ResourceMemory: resource.MustParse("16Gi"), + resourceGPU: resource.MustParse("1"), + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("16"), + v1.ResourceMemory: resource.MustParse("32Gi"), + resourceGPU: resource.MustParse("1"), + }, + }, + overrideResources: v1.ResourceRequirements{ + Requests: v1.ResourceList{resourceGPU: resource.MustParse("8")}, + Limits: v1.ResourceList{resourceGPU: resource.MustParse("8")}, + }, + extendedResources: &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "tpu-v5e", + DeviceClass: core.GPUAccelerator_GOOGLE_TPU, + }, + }, + customizationMode: ResourceCustomizationModeMergeExistingResources, + expectedRequests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("8"), + v1.ResourceMemory: resource.MustParse("16Gi"), + v1.ResourceName("google.com/tpu"): resource.MustParse("8"), + }, + expectedLimits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("16"), + v1.ResourceMemory: resource.MustParse("32Gi"), + v1.ResourceName("google.com/tpu"): resource.MustParse("8"), + }, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + container := &v1.Container{ + Command: []string{"{{ .Input }}"}, + Args: []string{"{{ .OutputPrefix }}"}, + Resources: tc.initialResources, + } + + overrideResources := tc.overrideResources + templateParameters := getTemplateParametersForTest( + &overrideResources, + &v1.ResourceRequirements{}, + false, + "", + ) + + err := AddFlyteCustomizationsToContainer( + context.TODO(), + templateParameters, + tc.customizationMode, + container, + tc.extendedResources, + ) + assert.NoError(t, err) + + // Verify requests match exactly + assert.Equal(t, len(tc.expectedRequests), len(container.Resources.Requests), + "requests should have exactly %d resources", len(tc.expectedRequests)) + for resourceName, expectedQuantity := range tc.expectedRequests { + actualQuantity := container.Resources.Requests[resourceName] + assert.True(t, expectedQuantity.Equal(actualQuantity), + "expected %s=%s in requests, got %s", resourceName, expectedQuantity.String(), actualQuantity.String()) + } + + // Verify limits match exactly + assert.Equal(t, len(tc.expectedLimits), len(container.Resources.Limits), + "limits should have exactly %d resources", len(tc.expectedLimits)) + for resourceName, expectedQuantity := range tc.expectedLimits { + actualQuantity := container.Resources.Limits[resourceName] + assert.True(t, expectedQuantity.Equal(actualQuantity), + "expected %s=%s in limits, got %s", resourceName, expectedQuantity.String(), actualQuantity.String()) + } + }) + } +} + +func TestAddFlyteCustomizationsToContainer_ValidateEnvFrom(t *testing.T) { + configMapSource := v1.EnvFromSource{ + ConfigMapRef: &v1.ConfigMapEnvSource{ + LocalObjectReference: v1.LocalObjectReference{ + Name: "my-configmap", + }, + }, + } + secretSource := v1.EnvFromSource{ + SecretRef: &v1.SecretEnvSource{ + LocalObjectReference: v1.LocalObjectReference{ + Name: "my-secret", + }, + }, + } + + container := &v1.Container{ + Command: []string{ + "{{ .Input }}", + }, + Args: []string{ + "{{ .OutputPrefix }}", + }, + EnvFrom: []v1.EnvFromSource{ + configMapSource, + secretSource, + }, + } + + err := AddFlyteCustomizationsToContainer(context.TODO(), getTemplateParametersForTest(nil, nil, false, ""), ResourceCustomizationModeEnsureExistingResourcesInRange, container, nil) + assert.NoError(t, err) + + assert.Len(t, container.EnvFrom, 2) + assert.Equal(t, container.EnvFrom[0], configMapSource) + assert.Equal(t, container.EnvFrom[1], secretSource) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/copilot.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/copilot.go new file mode 100644 index 0000000000..67010a1e50 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/copilot.go @@ -0,0 +1,287 @@ +package flytek8s + +import ( + "context" + "encoding/base64" + "fmt" + "strconv" + "time" + + "github.com/golang/protobuf/proto" + "github.com/pkg/errors" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + + core2 "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const ( + flyteSidecarContainerName = "uploader" + flyteDownloaderContainerName = "downloader" +) + +func FlyteCoPilotContainer(name string, cfg config.FlyteCoPilotConfig, args []string, volumeMounts ...v1.VolumeMount) (v1.Container, error) { + cpu, err := resource.ParseQuantity(cfg.CPU) + if err != nil { + return v1.Container{}, err + } + + mem, err := resource.ParseQuantity(cfg.Memory) + if err != nil { + return v1.Container{}, err + } + + var storageCfg *storage.Config + if cfg.StorageConfigOverride != nil { + storageCfg = cfg.StorageConfigOverride + } else { + storageCfg = storage.GetConfig() + } + + return v1.Container{ + Name: cfg.NamePrefix + name, + Image: cfg.Image, + Command: CopilotCommandArgs(storageCfg), + Args: args, + WorkingDir: "/", + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceCPU: cpu, + v1.ResourceMemory: mem, + }, + Requests: v1.ResourceList{ + v1.ResourceCPU: cpu, + v1.ResourceMemory: mem, + }, + }, + VolumeMounts: volumeMounts, + TerminationMessagePolicy: v1.TerminationMessageFallbackToLogsOnError, + ImagePullPolicy: v1.PullIfNotPresent, + }, nil +} + +func CopilotCommandArgs(storageConfig *storage.Config) []string { + var commands = []string{ + "/bin/flyte-copilot", + "--storage.limits.maxDownloadMBs=0", + "--logger.level=" + strconv.Itoa(logger.GetConfig().Level), + } + if storageConfig.MultiContainerEnabled { + commands = append(commands, "--storage.enable-multicontainer") + } + if len(storageConfig.InitContainer) > 0 { + commands = append(commands, fmt.Sprintf("--storage.container=%s", storageConfig.InitContainer)) + + } + commands = append(commands, fmt.Sprintf("--storage.type=%s", storageConfig.Type)) + + if len(storageConfig.Stow.Config) > 0 && len(storageConfig.Stow.Kind) > 0 { + for key, val := range storageConfig.Stow.Config { + commands = append(commands, "--storage.stow.config") + commands = append(commands, fmt.Sprintf("%s=%s", key, val)) + } + return append(commands, fmt.Sprintf("--storage.stow.kind=%s", storageConfig.Stow.Kind)) + } + return append(commands, []string{ + fmt.Sprintf("--storage.connection.secret-key=%s", storageConfig.Connection.SecretKey), + fmt.Sprintf("--storage.connection.access-key=%s", storageConfig.Connection.AccessKey), + fmt.Sprintf("--storage.connection.auth-type=%s", storageConfig.Connection.AuthType), + fmt.Sprintf("--storage.connection.region=%s", storageConfig.Connection.Region), + fmt.Sprintf("--storage.connection.endpoint=%s", storageConfig.Connection.Endpoint.String()), + }...) +} + +func SidecarCommandArgs(fromLocalPath string, outputPrefix, rawOutputPath storage.DataReference, uploadTimeout time.Duration, iface *core.TypedInterface) ([]string, error) { + if iface == nil { + return nil, fmt.Errorf("interface is required for CoPilot Sidecar") + } + b, err := proto.Marshal(iface) + if err != nil { + return nil, errors.Wrap(err, "failed to marshal given core.TypedInterface") + } + return []string{ + "sidecar", + "--timeout", + uploadTimeout.String(), + "--to-raw-output", + rawOutputPath.String(), + "--to-output-prefix", + outputPrefix.String(), + "--from-local-dir", + fromLocalPath, + "--interface", + base64.StdEncoding.EncodeToString(b), + }, nil +} + +func DownloadCommandArgs(fromInputsPath, outputPrefix storage.DataReference, toLocalPath string, format core.DataLoadingConfig_LiteralMapFormat, inputInterface *core.VariableMap) ([]string, error) { + if inputInterface == nil { + return nil, fmt.Errorf("input Interface is required for CoPilot Downloader") + } + b, err := proto.Marshal(inputInterface) + if err != nil { + return nil, errors.Wrap(err, "failed to marshal given input interface") + } + return []string{ + "download", + "--from-remote", + fromInputsPath.String(), + "--to-output-prefix", + outputPrefix.String(), + "--to-local-dir", + toLocalPath, + "--format", + format.String(), + "--input-interface", + base64.StdEncoding.EncodeToString(b), + }, nil +} + +func DataVolume(name string, size *resource.Quantity) v1.Volume { + return v1.Volume{ + Name: name, + VolumeSource: v1.VolumeSource{ + EmptyDir: &v1.EmptyDirVolumeSource{ + Medium: v1.StorageMediumDefault, + SizeLimit: size, + }, + }, + } +} + +func CalculateStorageSize(requirements *v1.ResourceRequirements) *resource.Quantity { + if requirements == nil { + return nil + } + s, ok := requirements.Limits[v1.ResourceStorage] + if ok { + return &s + } + s, ok = requirements.Requests[v1.ResourceStorage] + if ok { + return &s + } + return nil +} + +func AddCoPilotToContainer(ctx context.Context, cfg config.FlyteCoPilotConfig, c *v1.Container, iFace *core.TypedInterface, pilot *core.DataLoadingConfig) error { + if pilot == nil || !pilot.Enabled { + return nil + } + logger.Infof(ctx, "Enabling CoPilot on main container [%s]", c.Name) + if c.SecurityContext == nil { + c.SecurityContext = &v1.SecurityContext{} + } + if c.SecurityContext.Capabilities == nil { + c.SecurityContext.Capabilities = &v1.Capabilities{} + } + + if iFace != nil { + if iFace.Inputs != nil && len(iFace.Inputs.Variables) > 0 { + inPath := cfg.DefaultInputDataPath + if pilot.GetInputPath() != "" { + inPath = pilot.GetInputPath() + } + + c.VolumeMounts = append(c.VolumeMounts, v1.VolumeMount{ + Name: cfg.InputVolumeName, + MountPath: inPath, + }) + } + + if iFace.Outputs != nil && len(iFace.Outputs.Variables) > 0 { + outPath := cfg.DefaultOutputPath + if pilot.GetOutputPath() != "" { + outPath = pilot.GetOutputPath() + } + c.VolumeMounts = append(c.VolumeMounts, v1.VolumeMount{ + Name: cfg.OutputVolumeName, + MountPath: outPath, + }) + } + } + return nil +} + +func AddCoPilotToPod(ctx context.Context, cfg config.FlyteCoPilotConfig, coPilotPod *v1.PodSpec, iFace *core.TypedInterface, taskExecMetadata core2.TaskExecutionMetadata, inputPaths io.InputFilePaths, outputPaths io.OutputFilePaths, pilot *core.DataLoadingConfig) error { + if pilot == nil || !pilot.Enabled { + return nil + } + + //nolint:protogetter + logger.Infof(ctx, "CoPilot Enabled for task [%s]", taskExecMetadata.GetTaskExecutionID().GetID().TaskId.GetName()) + if iFace != nil { + if iFace.Inputs != nil && len(iFace.Inputs.Variables) > 0 { + inPath := cfg.DefaultInputDataPath + if pilot.GetInputPath() != "" { + inPath = pilot.GetInputPath() + } + + // TODO we should calculate input volume size based on the size of the inputs which is known ahead of time. We should store that as part of the metadata + size := CalculateStorageSize(taskExecMetadata.GetOverrides().GetResources()) + logger.Infof(ctx, "Adding Input path [%s] of Size [%d] for Task [%s]", inPath, size, taskExecMetadata.GetTaskExecutionID().GetID().TaskId.Name) + inputsVolumeMount := v1.VolumeMount{ + Name: cfg.InputVolumeName, + MountPath: inPath, + } + + format := pilot.Format + // Lets add the InputsVolume + coPilotPod.Volumes = append(coPilotPod.Volumes, DataVolume(cfg.InputVolumeName, size)) + + // Lets add the Inputs init container + args, err := DownloadCommandArgs(inputPaths.GetInputPath(), outputPaths.GetOutputPrefixPath(), inPath, format, iFace.Inputs) + if err != nil { + return err + } + downloader, err := FlyteCoPilotContainer(flyteDownloaderContainerName, cfg, args, inputsVolumeMount) + if err != nil { + return err + } + coPilotPod.InitContainers = append(coPilotPod.InitContainers, downloader) + } + + if iFace.Outputs != nil && len(iFace.Outputs.Variables) > 0 { + outPath := cfg.DefaultOutputPath + if pilot.GetOutputPath() != "" { + outPath = pilot.GetOutputPath() + } + + size := CalculateStorageSize(taskExecMetadata.GetOverrides().GetResources()) + logger.Infof(ctx, "Adding Output path [%s] of size [%d] for Task [%s]", size, outPath, taskExecMetadata.GetTaskExecutionID().GetID().TaskId.Name) + + outputsVolumeMount := v1.VolumeMount{ + Name: cfg.OutputVolumeName, + MountPath: outPath, + } + + // Lets add the InputsVolume + coPilotPod.Volumes = append(coPilotPod.Volumes, DataVolume(cfg.OutputVolumeName, size)) + + // Lets add the Inputs init container + args, err := SidecarCommandArgs(outPath, outputPaths.GetOutputPrefixPath(), outputPaths.GetRawOutputPrefix(), cfg.Timeout.Duration, iFace) + if err != nil { + return err + } + sidecar, err := FlyteCoPilotContainer(flyteSidecarContainerName, cfg, args, outputsVolumeMount) + // Make it into sidecar container + restartPolicy := v1.ContainerRestartPolicyAlways + sidecar.RestartPolicy = &restartPolicy + if err != nil { + return err + } + // Let the sidecar container start before the downloader; it will ensure the signal watcher is started before the main container finishes. + coPilotPod.InitContainers = append([]v1.Container{sidecar}, coPilotPod.InitContainers...) + + timeoutSeconds := int64(cfg.Timeout.Duration.Seconds()) + coPilotPod.TerminationGracePeriodSeconds = &timeoutSeconds + } + } + + return nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/copilot_test.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/copilot_test.go new file mode 100644 index 0000000000..7b6211b509 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/copilot_test.go @@ -0,0 +1,599 @@ +package flytek8s + +import ( + "context" + "encoding/base64" + "reflect" + "testing" + "time" + + "github.com/golang/protobuf/proto" + "github.com/stretchr/testify/assert" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + + pluginsCoreMock "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + pluginsIOMock "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io/mocks" + config2 "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +var resourceRequirements = &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1024m"), + v1.ResourceStorage: resource.MustParse("100M"), + }, +} + +func TestFlyteCoPilotContainer(t *testing.T) { + cfg := config.FlyteCoPilotConfig{ + NamePrefix: "test-", + Image: "test", + DefaultInputDataPath: "/in", + DefaultOutputPath: "/out", + InputVolumeName: "inp", + OutputVolumeName: "out", + StartTimeout: config2.Duration{ + Duration: time.Second * 1, + }, + CPU: "1024m", + Memory: "1024Mi", + } + + t.Run("happy", func(t *testing.T) { + c, err := FlyteCoPilotContainer("x", cfg, []string{"hello"}) + assert.NoError(t, err) + assert.Equal(t, "test-x", c.Name) + assert.Equal(t, "test", c.Image) + assert.Equal(t, CopilotCommandArgs(storage.GetConfig()), c.Command) + assert.Equal(t, []string{"hello"}, c.Args) + assert.Equal(t, 0, len(c.VolumeMounts)) + assert.Equal(t, "/", c.WorkingDir) + assert.Equal(t, 2, len(c.Resources.Limits)) + assert.Equal(t, 2, len(c.Resources.Requests)) + }) + + t.Run("happy stow backend", func(t *testing.T) { + storage.GetConfig().Stow.Kind = "S3" + storage.GetConfig().Stow.Config = map[string]string{ + "path": "config.yaml", + } + c, err := FlyteCoPilotContainer("x", cfg, []string{"hello"}) + assert.NoError(t, err) + assert.Equal(t, "test-x", c.Name) + assert.Equal(t, "test", c.Image) + assert.Equal(t, CopilotCommandArgs(storage.GetConfig()), c.Command) + assert.Equal(t, []string{"hello"}, c.Args) + assert.Equal(t, 0, len(c.VolumeMounts)) + assert.Equal(t, "/", c.WorkingDir) + assert.Equal(t, 2, len(c.Resources.Limits)) + assert.Equal(t, 2, len(c.Resources.Requests)) + }) + + t.Run("happy-vols", func(t *testing.T) { + c, err := FlyteCoPilotContainer("x", cfg, []string{"hello"}, v1.VolumeMount{Name: "X", MountPath: "/"}) + assert.NoError(t, err) + assert.Equal(t, 1, len(c.VolumeMounts)) + }) + + t.Run("happy stow GCP backend", func(t *testing.T) { + storage.GetConfig().Type = storage.TypeStow + storage.GetConfig().InitContainer = "bucket" + storage.GetConfig().Stow.Kind = "google" + storage.GetConfig().Stow.Config = map[string]string{ + "json": "", + "project_id": "flyte-gcp", + "scope": "read_write", + } + assert.Equal(t, 12, len(CopilotCommandArgs(storage.GetConfig()))) + }) + + t.Run("storage override", func(t *testing.T) { + + storageConfigOverride := storage.Config{} + + storageConfigOverride.Type = storage.TypeStow + storageConfigOverride.InitContainer = "bucket" + storageConfigOverride.Stow.Kind = "google" + storageConfigOverride.Stow.Config = map[string]string{ + "json": "", + "project_id": "flyte-gcp", + } + cfg.StorageConfigOverride = &storageConfigOverride + + c, err := FlyteCoPilotContainer("x", cfg, []string{"hello"}, v1.VolumeMount{Name: "X", MountPath: "/"}) + assert.NoError(t, err) + assert.Equal(t, 1, len(c.VolumeMounts)) + + assert.ElementsMatch(t, c.Command, CopilotCommandArgs(&storageConfigOverride)) + }) + + t.Run("bad-res-cpu", func(t *testing.T) { + old := cfg.CPU + cfg.CPU = "x" + _, err := FlyteCoPilotContainer("x", cfg, []string{"hello"}, v1.VolumeMount{Name: "X", MountPath: "/"}) + assert.Error(t, err) + cfg.CPU = old + }) + + t.Run("bad-res-mem", func(t *testing.T) { + old := cfg.Memory + cfg.Memory = "x" + _, err := FlyteCoPilotContainer("x", cfg, []string{"hello"}, v1.VolumeMount{Name: "X", MountPath: "/"}) + assert.Error(t, err) + cfg.Memory = old + }) +} + +func TestDownloadCommandArgs(t *testing.T) { + _, err := DownloadCommandArgs("", "", "", core.DataLoadingConfig_YAML, nil) + assert.Error(t, err) + + iFace := &core.VariableMap{ + Variables: map[string]*core.Variable{ + "x": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + "y": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + }, + } + d, err := DownloadCommandArgs("s3://from", "s3://output-meta", "/to", core.DataLoadingConfig_JSON, iFace) + assert.NoError(t, err) + expected := []string{"download", "--from-remote", "s3://from", "--to-output-prefix", "s3://output-meta", "--to-local-dir", "/to", "--format", "JSON", "--input-interface", ""} + if assert.Len(t, d, len(expected)) { + for i := 0; i < len(expected)-1; i++ { + assert.Equal(t, expected[i], d[i]) + } + // We cannot compare the last one, as the interface is a map the order is not guaranteed. + ifaceB64 := d[len(expected)-1] + serIFaceBytes, err := base64.StdEncoding.DecodeString(ifaceB64) + if assert.NoError(t, err) { + vm := &core.VariableMap{} + assert.NoError(t, proto.Unmarshal(serIFaceBytes, vm)) + assert.Len(t, vm.Variables, 2) + for k, v := range iFace.Variables { + v2, ok := vm.Variables[k] + assert.True(t, ok) + assert.Equal(t, v.Type.GetSimple(), v2.Type.GetSimple(), "for %s, types do not match", k) + } + } + } +} + +func TestSidecarCommandArgs(t *testing.T) { + _, err := SidecarCommandArgs("", "", "", time.Second*10, nil) + assert.Error(t, err) + + iFace := &core.TypedInterface{ + Outputs: &core.VariableMap{ + Variables: map[string]*core.Variable{ + "x": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + "y": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + }, + }, + } + d, err := SidecarCommandArgs("/from", "s3://output-meta", "s3://raw-output", time.Hour*1, iFace) + assert.NoError(t, err) + expected := []string{"sidecar", "--timeout", "1h0m0s", "--to-raw-output", "s3://raw-output", "--to-output-prefix", "s3://output-meta", "--from-local-dir", "/from", "--interface", ""} + if assert.Len(t, d, len(expected)) { + for i := 0; i < len(expected)-1; i++ { + assert.Equal(t, expected[i], d[i]) + } + // We cannot compare the last one, as the interface is a map the order is not guaranteed. + ifaceB64 := d[len(expected)-1] + serIFaceBytes, err := base64.StdEncoding.DecodeString(ifaceB64) + if assert.NoError(t, err) { + if2 := &core.TypedInterface{} + assert.NoError(t, proto.Unmarshal(serIFaceBytes, if2)) + assert.Len(t, if2.Outputs.Variables, 2) + for k, v := range iFace.Outputs.Variables { + v2, ok := if2.Outputs.Variables[k] + assert.True(t, ok) + assert.Equal(t, v.Type.GetSimple(), v2.Type.GetSimple(), "for %s, types do not match", k) + } + } + } +} + +func TestDataVolume(t *testing.T) { + v := DataVolume("x", nil) + assert.Equal(t, "x", v.Name) + assert.NotNil(t, v.EmptyDir) + assert.Nil(t, v.EmptyDir.SizeLimit) + assert.Equal(t, v1.StorageMediumDefault, v.EmptyDir.Medium) + + q := resource.MustParse("1024Mi") + v = DataVolume("x", &q) + assert.NotNil(t, v.EmptyDir.SizeLimit) + assert.Equal(t, q, *v.EmptyDir.SizeLimit) +} + +func assertContainerHasVolumeMounts(t *testing.T, cfg config.FlyteCoPilotConfig, pilot *core.DataLoadingConfig, iFace *core.TypedInterface, c *v1.Container) { + if iFace != nil { + vmap := map[string]v1.VolumeMount{} + for _, v := range c.VolumeMounts { + vmap[v.Name] = v + } + if iFace.Inputs != nil { + path := cfg.DefaultInputDataPath + if pilot.InputPath != "" { + path = pilot.InputPath + } + v, found := vmap[cfg.InputVolumeName] + assert.Equal(t, path, v.MountPath, "Input Path does not match") + assert.True(t, found, "Input volume mount expected but not found!") + } + + if iFace.Outputs != nil { + path := cfg.DefaultOutputPath + if pilot.OutputPath != "" { + path = pilot.OutputPath + } + v, found := vmap[cfg.OutputVolumeName] + assert.Equal(t, path, v.MountPath, "Output Path does not match") + assert.True(t, found, "Output volume mount expected but not found!") + } + } else { + assert.Len(t, c.VolumeMounts, 0) + } +} + +func assertPodHasCoPilot(t *testing.T, cfg config.FlyteCoPilotConfig, pilot *core.DataLoadingConfig, iFace *core.TypedInterface, pod *v1.PodSpec) { + containers := append(pod.Containers, pod.InitContainers...) + for _, c := range containers { + if c.Name == "test" { + cntr := c + assertContainerHasVolumeMounts(t, cfg, pilot, iFace, &cntr) + } else { + if c.Name == cfg.NamePrefix+flyteDownloaderContainerName || c.Name == cfg.NamePrefix+flyteSidecarContainerName { + if iFace != nil { + vmap := map[string]v1.VolumeMount{} + for _, v := range c.VolumeMounts { + vmap[v.Name] = v + } + if iFace.Inputs != nil { + path := cfg.DefaultInputDataPath + if pilot != nil { + path = pilot.InputPath + } + v, found := vmap[cfg.InputVolumeName] + if c.Name == cfg.NamePrefix+flyteDownloaderContainerName { + assert.Equal(t, path, v.MountPath, "Input Path does not match") + assert.True(t, found, "Input volume mount expected but not found!") + } else { + assert.False(t, found, "Input volume mount not expected but found!") + } + } + + if iFace.Outputs != nil { + path := cfg.DefaultOutputPath + if pilot != nil { + path = pilot.OutputPath + } + v, found := vmap[cfg.OutputVolumeName] + if c.Name == cfg.NamePrefix+flyteDownloaderContainerName { + assert.False(t, found, "Output volume mount not expected but found on init container!") + } else { + assert.Equal(t, path, v.MountPath, "Output Path does not match") + assert.True(t, found, "Output volume mount expected but not found!") + } + } + + } else { + assert.Len(t, c.VolumeMounts, 0) + } + } + } + } +} + +func TestCalculateStorageSize(t *testing.T) { + twoG := resource.MustParse("2048Mi") + oneG := resource.MustParse("1024Mi") + tests := []struct { + name string + args *v1.ResourceRequirements + want *resource.Quantity + }{ + {"nil", nil, nil}, + {"empty", &v1.ResourceRequirements{}, nil}, + {"limits", &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceStorage: twoG, + }}, &twoG}, + {"requests", &v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceStorage: oneG, + }}, &oneG}, + + {"max", &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceStorage: twoG, + }, + Requests: v1.ResourceList{ + v1.ResourceStorage: oneG, + }}, &twoG}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := CalculateStorageSize(tt.args); !reflect.DeepEqual(got, tt.want) { + t.Errorf("CalculateStorageSize() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestAddCoPilotToContainer(t *testing.T) { + ctx := context.TODO() + cfg := config.FlyteCoPilotConfig{ + NamePrefix: "test-", + Image: "test", + DefaultInputDataPath: "/in", + DefaultOutputPath: "/out", + InputVolumeName: "inp", + OutputVolumeName: "out", + CPU: "1024m", + Memory: "1024Mi", + } + + t.Run("dataload-config-nil", func(t *testing.T) { + pilot := &core.DataLoadingConfig{} + assert.NoError(t, AddCoPilotToContainer(ctx, cfg, nil, nil, pilot)) + }) + + t.Run("disabled", func(t *testing.T) { + pilot := &core.DataLoadingConfig{} + assert.NoError(t, AddCoPilotToContainer(ctx, cfg, nil, nil, pilot)) + }) + + t.Run("nil-iface", func(t *testing.T) { + c := v1.Container{} + pilot := &core.DataLoadingConfig{Enabled: true} + assert.NoError(t, AddCoPilotToContainer(ctx, cfg, &c, nil, pilot)) + assertContainerHasVolumeMounts(t, cfg, pilot, nil, &c) + }) + + t.Run("happy-iface-empty-config", func(t *testing.T) { + + c := v1.Container{} + iface := &core.TypedInterface{ + Inputs: &core.VariableMap{ + Variables: map[string]*core.Variable{ + "x": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + "y": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + }, + }, + Outputs: &core.VariableMap{ + Variables: map[string]*core.Variable{ + "o": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + }, + }, + } + pilot := &core.DataLoadingConfig{Enabled: true} + assert.NoError(t, AddCoPilotToContainer(ctx, cfg, &c, iface, pilot)) + assertContainerHasVolumeMounts(t, cfg, pilot, iface, &c) + }) + + t.Run("happy-iface-set-config", func(t *testing.T) { + + c := v1.Container{} + iface := &core.TypedInterface{ + Inputs: &core.VariableMap{ + Variables: map[string]*core.Variable{ + "x": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + "y": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + }, + }, + Outputs: &core.VariableMap{ + Variables: map[string]*core.Variable{ + "o": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + }, + }, + } + pilot := &core.DataLoadingConfig{ + Enabled: true, + InputPath: "in", + OutputPath: "out", + } + assert.NoError(t, AddCoPilotToContainer(ctx, cfg, &c, iface, pilot)) + assertContainerHasVolumeMounts(t, cfg, pilot, iface, &c) + }) + + t.Run("happy-iface-inputs", func(t *testing.T) { + + c := v1.Container{} + iface := &core.TypedInterface{ + Inputs: &core.VariableMap{ + Variables: map[string]*core.Variable{ + "x": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + "y": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + }, + }, + } + pilot := &core.DataLoadingConfig{ + Enabled: true, + InputPath: "in", + OutputPath: "out", + } + assert.NoError(t, AddCoPilotToContainer(ctx, cfg, &c, iface, pilot)) + assertContainerHasVolumeMounts(t, cfg, pilot, iface, &c) + }) + + t.Run("happy-iface-outputs", func(t *testing.T) { + + c := v1.Container{} + iface := &core.TypedInterface{ + Outputs: &core.VariableMap{ + Variables: map[string]*core.Variable{ + "o": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + }, + }, + } + pilot := &core.DataLoadingConfig{ + Enabled: true, + InputPath: "in", + OutputPath: "out", + } + assert.NoError(t, AddCoPilotToContainer(ctx, cfg, &c, iface, pilot)) + assertContainerHasVolumeMounts(t, cfg, pilot, iface, &c) + }) +} + +func TestAddCoPilotToPod(t *testing.T) { + ctx := context.TODO() + cfg := config.FlyteCoPilotConfig{ + NamePrefix: "test-", + Image: "test", + DefaultInputDataPath: "/in", + DefaultOutputPath: "/out", + InputVolumeName: "inp", + OutputVolumeName: "out", + StartTimeout: config2.Duration{ + Duration: time.Second * 1, + }, + CPU: "1024m", + Memory: "1024Mi", + } + + taskMetadata := &pluginsCoreMock.TaskExecutionMetadata{} + taskMetadata.EXPECT().GetNamespace().Return("test-namespace") + taskMetadata.EXPECT().GetAnnotations().Return(map[string]string{"annotation-1": "val1"}) + taskMetadata.EXPECT().GetLabels().Return(map[string]string{"label-1": "val1"}) + taskMetadata.EXPECT().GetOwnerReference().Return(metav1.OwnerReference{ + Kind: "node", + Name: "blah", + }) + taskMetadata.EXPECT().GetK8sServiceAccount().Return("") + taskMetadata.EXPECT().GetOwnerID().Return(types.NamespacedName{ + Namespace: "test-namespace", + Name: "test-owner-name", + }) + taskMetadata.EXPECT().IsInterruptible().Return(false) + + tID := &pluginsCoreMock.TaskExecutionID{} + tID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + TaskId: &core.Identifier{ + Name: "my-task", + }, + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my_name", + Project: "my_project", + Domain: "my_domain", + }, + }, + }) + tID.EXPECT().GetGeneratedName().Return("name") + taskMetadata.EXPECT().GetTaskExecutionID().Return(tID) + + to := &pluginsCoreMock.TaskOverrides{} + to.EXPECT().GetResources().Return(resourceRequirements) + taskMetadata.EXPECT().GetOverrides().Return(to) + + inputPaths := &pluginsIOMock.InputFilePaths{} + inputs := "/base/inputs" + inputPaths.EXPECT().GetInputPrefixPath().Return(storage.DataReference(inputs)) + inputPaths.EXPECT().GetInputPath().Return(storage.DataReference(inputs + "/inputs.pb")) + + opath := &pluginsIOMock.OutputFilePaths{} + opath.EXPECT().GetRawOutputPrefix().Return("/raw") + opath.EXPECT().GetOutputPrefixPath().Return("/output") + + t.Run("happy", func(t *testing.T) { + pod := v1.PodSpec{} + iface := &core.TypedInterface{ + Inputs: &core.VariableMap{ + Variables: map[string]*core.Variable{ + "x": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + "y": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + }, + }, + Outputs: &core.VariableMap{ + Variables: map[string]*core.Variable{ + "o": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + }, + }, + } + pilot := &core.DataLoadingConfig{ + Enabled: true, + InputPath: "in", + OutputPath: "out", + } + assert.NoError(t, AddCoPilotToPod(ctx, cfg, &pod, iface, taskMetadata, inputPaths, opath, pilot)) + assert.Equal(t, pod.InitContainers[0].Name, cfg.NamePrefix+flyteSidecarContainerName) + assert.Equal(t, pod.InitContainers[1].Name, cfg.NamePrefix+flyteDownloaderContainerName) + assertPodHasCoPilot(t, cfg, pilot, iface, &pod) + }) + + t.Run("happy-nil-iface", func(t *testing.T) { + pod := v1.PodSpec{} + pilot := &core.DataLoadingConfig{ + Enabled: true, + InputPath: "in", + OutputPath: "out", + } + assert.NoError(t, AddCoPilotToPod(ctx, cfg, &pod, nil, taskMetadata, inputPaths, opath, pilot)) + assertPodHasCoPilot(t, cfg, pilot, nil, &pod) + }) + + t.Run("happy-inputs-only", func(t *testing.T) { + pod := v1.PodSpec{} + iface := &core.TypedInterface{ + Inputs: &core.VariableMap{ + Variables: map[string]*core.Variable{ + "x": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + "y": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + }, + }, + } + pilot := &core.DataLoadingConfig{ + Enabled: true, + InputPath: "in", + OutputPath: "out", + } + assert.NoError(t, AddCoPilotToPod(ctx, cfg, &pod, iface, taskMetadata, inputPaths, opath, pilot)) + assertPodHasCoPilot(t, cfg, pilot, iface, &pod) + }) + + t.Run("happy-outputs-only", func(t *testing.T) { + pod := v1.PodSpec{} + iface := &core.TypedInterface{ + Outputs: &core.VariableMap{ + Variables: map[string]*core.Variable{ + "o": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + }, + }, + } + pilot := &core.DataLoadingConfig{ + Enabled: true, + InputPath: "in", + OutputPath: "out", + } + assert.NoError(t, AddCoPilotToPod(ctx, cfg, &pod, iface, taskMetadata, inputPaths, opath, pilot)) + assertPodHasCoPilot(t, cfg, pilot, iface, &pod) + }) + + t.Run("disabled", func(t *testing.T) { + pod := v1.PodSpec{} + iface := &core.TypedInterface{ + Outputs: &core.VariableMap{ + Variables: map[string]*core.Variable{ + "o": {Type: &core.LiteralType{Type: &core.LiteralType_Simple{Simple: core.SimpleType_INTEGER}}}, + }, + }, + } + pilot := &core.DataLoadingConfig{ + Enabled: false, + InputPath: "in", + OutputPath: "out", + } + assert.NoError(t, AddCoPilotToPod(ctx, cfg, &pod, iface, taskMetadata, inputPaths, opath, pilot)) + assert.Len(t, pod.Volumes, 0) + }) + + t.Run("nil", func(t *testing.T) { + assert.NoError(t, AddCoPilotToPod(ctx, cfg, nil, nil, taskMetadata, inputPaths, opath, nil)) + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/k8s_resource_adds.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/k8s_resource_adds.go new file mode 100644 index 0000000000..90a1cf24d1 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/k8s_resource_adds.go @@ -0,0 +1,218 @@ +package flytek8s + +import ( + "context" + "fmt" + "os" + "strconv" + "strings" + + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/util/sets" + + //propellerCfg "github.com/flyteorg/flyte/flytepropeller/pkg/controller/config" + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" +) + +const ( + flyteExecutionURL = "FLYTE_EXECUTION_URL" +) + +func GetContextEnvVars(ownerCtx context.Context) []v1.EnvVar { + var envVars []v1.EnvVar + + if ownerCtx == nil { + return envVars + } + + // Injecting useful env vars from the context + if wfName := contextutils.Value(ownerCtx, contextutils.WorkflowIDKey); wfName != "" { + envVars = append(envVars, + v1.EnvVar{ + Name: "FLYTE_INTERNAL_EXECUTION_WORKFLOW", + Value: wfName, + }, + ) + } + return envVars +} + +func GetExecutionEnvVars(id pluginsCore.TaskExecutionID, consoleURL string) []v1.EnvVar { + + if id == nil || id.GetID().NodeExecutionId == nil || id.GetID().NodeExecutionId.ExecutionId == nil { + return []v1.EnvVar{} + } + + // Execution level env variables. + nodeExecutionID := id.GetID().NodeExecutionId.ExecutionId + attemptNumber := strconv.Itoa(int(id.GetID().RetryAttempt)) + envVars := []v1.EnvVar{ + { + Name: "FLYTE_INTERNAL_EXECUTION_ID", + Value: nodeExecutionID.Name, + }, + { + Name: "FLYTE_INTERNAL_EXECUTION_PROJECT", + Value: nodeExecutionID.Project, + }, + { + Name: "FLYTE_INTERNAL_EXECUTION_DOMAIN", + Value: nodeExecutionID.Domain, + }, + { + // FLYTE_INTERNAL_POD_NAME + Name: "_F_PN", + ValueFrom: &v1.EnvVarSource{ + FieldRef: &v1.ObjectFieldSelector{ + FieldPath: "metadata.name", + }, + }, + }, + { + Name: "FLYTE_ATTEMPT_NUMBER", + Value: attemptNumber, + }, + } + + if len(consoleURL) > 0 { + consoleURL = strings.TrimRight(consoleURL, "/") + envVars = append(envVars, v1.EnvVar{ + Name: flyteExecutionURL, + Value: fmt.Sprintf("%s/projects/%s/domains/%s/executions/%s/nodeId/%s/nodes", consoleURL, nodeExecutionID.Project, nodeExecutionID.Domain, nodeExecutionID.Name, id.GetUniqueNodeID()), + }) + } + + // Task definition Level env variables. + if id.GetID().TaskId != nil { + taskID := id.GetID().TaskId + + envVars = append(envVars, + v1.EnvVar{ + Name: "FLYTE_INTERNAL_TASK_PROJECT", + Value: taskID.Project, + }, + v1.EnvVar{ + Name: "FLYTE_INTERNAL_TASK_DOMAIN", + Value: taskID.Domain, + }, + v1.EnvVar{ + Name: "FLYTE_INTERNAL_TASK_NAME", + Value: taskID.Name, + }, + v1.EnvVar{ + Name: "FLYTE_INTERNAL_TASK_VERSION", + Value: taskID.Version, + }, + // Historic Task Definition Level env variables. + // Remove these once SDK is migrated to use the new ones. + v1.EnvVar{ + Name: "FLYTE_INTERNAL_PROJECT", + Value: taskID.Project, + }, + v1.EnvVar{ + Name: "FLYTE_INTERNAL_DOMAIN", + Value: taskID.Domain, + }, + v1.EnvVar{ + Name: "FLYTE_INTERNAL_NAME", + Value: taskID.Name, + }, + v1.EnvVar{ + Name: "FLYTE_INTERNAL_VERSION", + Value: taskID.Version, + }) + + } + return envVars +} + +func GetLiteralOffloadingEnvVars() []v1.EnvVar { + // TODO @pvditt fix + //propellerConfig := propellerCfg.GetConfig() + //if !propellerConfig.LiteralOffloadingConfig.Enabled { + // return []v1.EnvVar{} + //} + + envVars := []v1.EnvVar{} + //if propellerConfig.LiteralOffloadingConfig.MinSizeInMBForOffloading > 0 { + // envVars = append(envVars, + // v1.EnvVar{ + // Name: "_F_L_MIN_SIZE_MB", + // Value: strconv.FormatInt(propellerConfig.LiteralOffloadingConfig.MinSizeInMBForOffloading, 10), + // }, + // ) + //} + //if propellerConfig.LiteralOffloadingConfig.MaxSizeInMBForOffloading > 0 { + // envVars = append(envVars, + // v1.EnvVar{ + // Name: "_F_L_MAX_SIZE_MB", + // Value: strconv.FormatInt(propellerConfig.LiteralOffloadingConfig.MaxSizeInMBForOffloading, 10), + // }, + // ) + //} + return envVars +} + +func DecorateEnvVars(ctx context.Context, envVars []v1.EnvVar, envFroms []v1.EnvFromSource, taskEnvironmentVariables map[string]string, id pluginsCore.TaskExecutionID, consoleURL string) ([]v1.EnvVar, []v1.EnvFromSource) { + envVars = append(envVars, GetContextEnvVars(ctx)...) + envVars = append(envVars, GetExecutionEnvVars(id, consoleURL)...) + envVars = append(envVars, GetLiteralOffloadingEnvVars()...) + + for k, v := range taskEnvironmentVariables { + envVars = append(envVars, v1.EnvVar{Name: k, Value: v}) + } + for k, v := range config.GetK8sPluginConfig().DefaultEnvVars { + envVars = append(envVars, v1.EnvVar{Name: k, Value: v}) + } + for k, envVarName := range config.GetK8sPluginConfig().DefaultEnvVarsFromEnv { + value := os.Getenv(envVarName) + envVars = append(envVars, v1.EnvVar{Name: k, Value: value}) + } + + for _, secretName := range config.GetK8sPluginConfig().DefaultEnvFromSecrets { + optional := true + secretRef := v1.SecretEnvSource{LocalObjectReference: v1.LocalObjectReference{Name: secretName}, Optional: &optional} + envFroms = append(envFroms, v1.EnvFromSource{SecretRef: &secretRef}) + } + + for _, cmName := range config.GetK8sPluginConfig().DefaultEnvFromConfigMaps { + optional := true + cmRef := v1.ConfigMapEnvSource{LocalObjectReference: v1.LocalObjectReference{Name: cmName}, Optional: &optional} + envFroms = append(envFroms, v1.EnvFromSource{ConfigMapRef: &cmRef}) + } + + return envVars, envFroms +} + +func GetPodTolerations(interruptible bool, resourceRequirements ...v1.ResourceRequirements) []v1.Toleration { + // 1. Get the tolerations for the resources requested + var tolerations []v1.Toleration + resourceNames := sets.NewString() + for _, resources := range resourceRequirements { + for r := range resources.Limits { + resourceNames.Insert(r.String()) + } + for r := range resources.Requests { + resourceNames.Insert(r.String()) + } + } + + resourceTols := config.GetK8sPluginConfig().ResourceTolerations + for _, r := range resourceNames.UnsortedList() { + if v, ok := resourceTols[v1.ResourceName(r)]; ok { + tolerations = append(tolerations, v...) + } + } + + // 2. Get the tolerations for interruptible pods + if interruptible { + tolerations = append(tolerations, config.GetK8sPluginConfig().InterruptibleTolerations...) + } + + // 3. Add default tolerations + tolerations = append(tolerations, config.GetK8sPluginConfig().DefaultTolerations...) + + return tolerations +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/k8s_resource_adds_test.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/k8s_resource_adds_test.go new file mode 100644 index 0000000000..ed4f2b803c --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/k8s_resource_adds_test.go @@ -0,0 +1,403 @@ +package flytek8s + +import ( + "context" + "os" + "reflect" + "testing" + + "github.com/golang/protobuf/proto" + "github.com/stretchr/testify/assert" + v12 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + + //propellerCfg "github.com/flyteorg/flyte/flytepropeller/pkg/controller/config" + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestGetExecutionEnvVars(t *testing.T) { + mock := mockTaskExecutionIdentifier{} + tests := []struct { + name string + expectedEnvVars int + consoleURL string + expectedEnvVar *v12.EnvVar + }{ + { + "no-console-url", + 13, + "", + nil, + }, + { + "with-console-url", + 14, + "scheme://host/path", + &v12.EnvVar{ + Name: "FLYTE_EXECUTION_URL", + Value: "scheme://host/path/projects/proj/domains/domain/executions/name/nodeId/unique-node-id/nodes", + }, + }, + { + "with-console-url-ending-in-single-slash", + 14, + "scheme://host/path/", + &v12.EnvVar{ + Name: "FLYTE_EXECUTION_URL", + Value: "scheme://host/path/projects/proj/domains/domain/executions/name/nodeId/unique-node-id/nodes", + }, + }, + { + "with-console-url-ending-in-multiple-slashes", + 14, + "scheme://host/path////", + &v12.EnvVar{ + Name: "FLYTE_EXECUTION_URL", + Value: "scheme://host/path/projects/proj/domains/domain/executions/name/nodeId/unique-node-id/nodes", + }, + }, + } + for _, tt := range tests { + envVars := GetExecutionEnvVars(mock, tt.consoleURL) + assert.Len(t, envVars, tt.expectedEnvVars) + if tt.expectedEnvVar != nil { + assert.True(t, proto.Equal(&envVars[5], tt.expectedEnvVar)) + } + } +} + +func TestGetTolerationsForResources(t *testing.T) { + var empty []v12.Toleration + var emptyConfig map[v12.ResourceName][]v12.Toleration + + tolGPU := v12.Toleration{ + Key: "flyte/gpu", + Value: "dedicated", + Operator: v12.TolerationOpEqual, + Effect: v12.TaintEffectNoSchedule, + } + + tolEphemeralStorage := v12.Toleration{ + Key: "ephemeral-storage", + Value: "dedicated", + Operator: v12.TolerationOpExists, + Effect: v12.TaintEffectNoSchedule, + } + + type args struct { + resources v12.ResourceRequirements + } + tests := []struct { + name string + args args + setVal map[v12.ResourceName][]v12.Toleration + setDefaults []v12.Toleration + want []v12.Toleration + }{ + { + "no-tolerations-limits", + args{ + v12.ResourceRequirements{ + Limits: v12.ResourceList{ + v12.ResourceCPU: resource.MustParse("1024m"), + v12.ResourceEphemeralStorage: resource.MustParse("100M"), + }, + }, + }, + emptyConfig, + nil, + empty, + }, + { + "no-tolerations-req", + args{ + v12.ResourceRequirements{ + Requests: v12.ResourceList{ + v12.ResourceCPU: resource.MustParse("1024m"), + v12.ResourceEphemeralStorage: resource.MustParse("100M"), + }, + }, + }, + emptyConfig, + nil, + empty, + }, + { + "no-tolerations-both", + args{ + v12.ResourceRequirements{ + Limits: v12.ResourceList{ + v12.ResourceCPU: resource.MustParse("1024m"), + v12.ResourceEphemeralStorage: resource.MustParse("100M"), + }, + Requests: v12.ResourceList{ + v12.ResourceCPU: resource.MustParse("1024m"), + v12.ResourceEphemeralStorage: resource.MustParse("100M"), + }, + }, + }, + emptyConfig, + nil, + empty, + }, + { + "tolerations-limits", + args{ + v12.ResourceRequirements{ + Limits: v12.ResourceList{ + v12.ResourceCPU: resource.MustParse("1024m"), + v12.ResourceEphemeralStorage: resource.MustParse("100M"), + }, + }, + }, + map[v12.ResourceName][]v12.Toleration{ + v12.ResourceEphemeralStorage: {tolEphemeralStorage}, + ResourceNvidiaGPU: {tolGPU}, + }, + nil, + []v12.Toleration{tolEphemeralStorage}, + }, + { + "tolerations-req", + args{ + v12.ResourceRequirements{ + Requests: v12.ResourceList{ + v12.ResourceCPU: resource.MustParse("1024m"), + v12.ResourceEphemeralStorage: resource.MustParse("100M"), + }, + }, + }, + map[v12.ResourceName][]v12.Toleration{ + v12.ResourceEphemeralStorage: {tolEphemeralStorage}, + ResourceNvidiaGPU: {tolGPU}, + }, + nil, + []v12.Toleration{tolEphemeralStorage}, + }, + { + "tolerations-both", + args{ + v12.ResourceRequirements{ + Limits: v12.ResourceList{ + v12.ResourceCPU: resource.MustParse("1024m"), + v12.ResourceEphemeralStorage: resource.MustParse("100M"), + }, + Requests: v12.ResourceList{ + v12.ResourceCPU: resource.MustParse("1024m"), + v12.ResourceEphemeralStorage: resource.MustParse("100M"), + }, + }, + }, + map[v12.ResourceName][]v12.Toleration{ + v12.ResourceEphemeralStorage: {tolEphemeralStorage}, + ResourceNvidiaGPU: {tolGPU}, + }, + nil, + []v12.Toleration{tolEphemeralStorage}, + }, + { + "no-tolerations-both", + args{ + v12.ResourceRequirements{ + Limits: v12.ResourceList{ + v12.ResourceCPU: resource.MustParse("1024m"), + v12.ResourceEphemeralStorage: resource.MustParse("100M"), + ResourceNvidiaGPU: resource.MustParse("1"), + }, + Requests: v12.ResourceList{ + v12.ResourceCPU: resource.MustParse("1024m"), + v12.ResourceEphemeralStorage: resource.MustParse("100M"), + }, + }, + }, + map[v12.ResourceName][]v12.Toleration{ + v12.ResourceEphemeralStorage: {tolEphemeralStorage}, + ResourceNvidiaGPU: {tolGPU}, + }, + nil, + []v12.Toleration{tolEphemeralStorage, tolGPU}, + }, + { + "default-tolerations", + args{}, + nil, + []v12.Toleration{tolEphemeralStorage}, + []v12.Toleration{tolEphemeralStorage}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ResourceTolerations: tt.setVal, DefaultTolerations: tt.setDefaults})) + if got := GetPodTolerations(true, tt.args.resources); len(got) != len(tt.want) { + t.Errorf("GetPodTolerations() = %v, want %v", got, tt.want) + } else { + for _, tol := range tt.want { + assert.Contains(t, got, tol) + } + } + }) + } +} + +var testTaskExecutionIdentifier = core.TaskExecutionIdentifier{ + TaskId: &core.Identifier{ + ResourceType: core.ResourceType_TASK, + Project: "proj", + Domain: "domain", + Name: "name", + }, + RetryAttempt: 1, + NodeExecutionId: &core.NodeExecutionIdentifier{ + NodeId: "nodeId", + ExecutionId: &core.WorkflowExecutionIdentifier{ + Project: "proj", + Domain: "domain", + Name: "name", + }, + }, +} + +type mockTaskExecutionIdentifier struct{} + +func (m mockTaskExecutionIdentifier) GetID() core.TaskExecutionIdentifier { + return testTaskExecutionIdentifier +} + +func (m mockTaskExecutionIdentifier) GetGeneratedNameWith(minLength, maxLength int) (string, error) { + return "task-exec-name", nil +} + +func (m mockTaskExecutionIdentifier) GetGeneratedName() string { + return "task-exec-name" +} + +func (m mockTaskExecutionIdentifier) GetUniqueNodeID() string { + return "unique-node-id" +} + +func TestDecorateEnvVars(t *testing.T) { + ctx := context.Background() + ctx = contextutils.WithWorkflowID(ctx, "fake_workflow") + + defaultEnv := []v12.EnvVar{ + { + Name: "x", + Value: "y", + }, + } + additionalEnv := map[string]string{ + "k": "v", + } + var emptyEnvVar map[string]string + envVarsFromEnv := map[string]string{ + "k": "value", + } + + originalEnvVal := os.Getenv("value") + err := os.Setenv("value", "v") + if err != nil { + t.Fatalf("failed to set env var 'value'; %v", err) + } + defer os.Setenv("value", originalEnvVal) + + expected := append(defaultEnv, GetContextEnvVars(ctx)...) + expected = append(expected, GetExecutionEnvVars(mockTaskExecutionIdentifier{}, "")...) + expectedOffloaded := append(expected, v12.EnvVar{Name: "_F_L_MIN_SIZE_MB", Value: "1"}) + expectedOffloaded = append(expectedOffloaded, v12.EnvVar{Name: "_F_L_MAX_SIZE_MB", Value: "42"}) + + aggregated := append(expected, v12.EnvVar{Name: "k", Value: "v"}) + type args struct { + envVars []v12.EnvVar + id pluginsCore.TaskExecutionID + } + tests := []struct { + name string + args args + additionEnvVar map[string]string + additionEnvVarFromEnv map[string]string + offloadingEnabled bool + offloadingEnvVar map[string]string + executionEnvVar map[string]string + consoleURL string + want []v12.EnvVar + }{ + { + "no-additional", + args{envVars: defaultEnv, id: mockTaskExecutionIdentifier{}}, + emptyEnvVar, + emptyEnvVar, + false, + emptyEnvVar, + emptyEnvVar, + "", + expected, + }, + // TODO @pvditt + //{ + // "no-additional-offloading-enabled", + // args{envVars: defaultEnv, id: mockTaskExecutionIdentifier{}}, + // emptyEnvVar, + // emptyEnvVar, + // true, + // emptyEnvVar, + // emptyEnvVar, + // "", + // expectedOffloaded, + //}, + { + "with-additional", + args{envVars: defaultEnv, id: mockTaskExecutionIdentifier{}}, + additionalEnv, + emptyEnvVar, + false, + emptyEnvVar, + emptyEnvVar, + "", + aggregated, + }, + { + "from-env", + args{envVars: defaultEnv, id: mockTaskExecutionIdentifier{}}, + emptyEnvVar, + envVarsFromEnv, + false, + emptyEnvVar, + emptyEnvVar, + "", + aggregated, + }, + { + "from-execution-metadata", + args{envVars: defaultEnv, id: mockTaskExecutionIdentifier{}}, + emptyEnvVar, + emptyEnvVar, + false, + emptyEnvVar, + additionalEnv, + "", + aggregated, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // TODO @pvditt + //cfg := propellerCfg.GetConfig() + //cfg.LiteralOffloadingConfig = propellerCfg.LiteralOffloadingConfig{ + // Enabled: tt.offloadingEnabled, + // MinSizeInMBForOffloading: 1, + // MaxSizeInMBForOffloading: 42, + //} + + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + DefaultEnvVars: tt.additionEnvVar, + DefaultEnvVarsFromEnv: tt.additionEnvVarFromEnv, + })) + if got, _ := DecorateEnvVars(ctx, tt.args.envVars, nil, tt.executionEnvVar, tt.args.id, tt.consoleURL); !reflect.DeepEqual(got, tt.want) { + t.Errorf("DecorateEnvVars() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/plugin_exec_context.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/plugin_exec_context.go new file mode 100644 index 0000000000..69900e1a42 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/plugin_exec_context.go @@ -0,0 +1,182 @@ +package flytek8s + +import ( + "context" + "reflect" + + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/runtime/schema" + "sigs.k8s.io/controller-runtime/pkg/client" + + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +type pluginTaskOverrides struct { + pluginsCore.TaskOverrides + resources *v1.ResourceRequirements + extendedResources *core.ExtendedResources +} + +func (to *pluginTaskOverrides) GetResources() *v1.ResourceRequirements { + if to.resources != nil { + return to.resources + } + return to.TaskOverrides.GetResources() +} + +func (to *pluginTaskOverrides) GetExtendedResources() *core.ExtendedResources { + if to.extendedResources != nil { + return to.extendedResources + } + return to.TaskOverrides.GetExtendedResources() +} + +func (to *pluginTaskOverrides) GetContainerImage() string { + return to.TaskOverrides.GetContainerImage() +} + +func (to *pluginTaskOverrides) GetPodTemplate() *core.K8SPod { + return to.TaskOverrides.GetPodTemplate() +} + +type pluginTaskExecutionMetadata struct { + pluginsCore.TaskExecutionMetadata + interruptible *bool + overrides *pluginTaskOverrides +} + +func (tm *pluginTaskExecutionMetadata) IsInterruptible() bool { + if tm.interruptible != nil { + return *tm.interruptible + } + return tm.TaskExecutionMetadata.IsInterruptible() +} + +func (tm *pluginTaskExecutionMetadata) GetOverrides() pluginsCore.TaskOverrides { + if tm.overrides != nil { + return tm.overrides + } + return tm.TaskExecutionMetadata.GetOverrides() +} + +type pluginTaskExecutionContext struct { + pluginsCore.TaskExecutionContext + metadata *pluginTaskExecutionMetadata +} + +func (tc *pluginTaskExecutionContext) TaskExecutionMetadata() pluginsCore.TaskExecutionMetadata { + if tc.metadata != nil { + return tc.metadata + } + return tc.TaskExecutionContext.TaskExecutionMetadata() +} + +type PluginTaskExecutionContextOption func(*pluginTaskExecutionContext) + +func WithInterruptible(v bool) PluginTaskExecutionContextOption { + return func(tc *pluginTaskExecutionContext) { + if tc.metadata == nil { + tc.metadata = &pluginTaskExecutionMetadata{ + TaskExecutionMetadata: tc.TaskExecutionContext.TaskExecutionMetadata(), + } + } + tc.metadata.interruptible = &v + } +} + +func WithResources(r *v1.ResourceRequirements) PluginTaskExecutionContextOption { + return func(tc *pluginTaskExecutionContext) { + if tc.metadata == nil { + tc.metadata = &pluginTaskExecutionMetadata{ + TaskExecutionMetadata: tc.TaskExecutionContext.TaskExecutionMetadata(), + } + } + if tc.metadata.overrides == nil { + tc.metadata.overrides = &pluginTaskOverrides{ + TaskOverrides: tc.metadata.TaskExecutionMetadata.GetOverrides(), + } + } + tc.metadata.overrides.resources = r + } +} + +func WithExtendedResources(er *core.ExtendedResources) PluginTaskExecutionContextOption { + return func(tc *pluginTaskExecutionContext) { + if tc.metadata == nil { + tc.metadata = &pluginTaskExecutionMetadata{ + TaskExecutionMetadata: tc.TaskExecutionContext.TaskExecutionMetadata(), + } + } + if tc.metadata.overrides == nil { + tc.metadata.overrides = &pluginTaskOverrides{ + TaskOverrides: tc.metadata.TaskExecutionMetadata.GetOverrides(), + } + } + tc.metadata.overrides.extendedResources = er + } +} + +func NewPluginTaskExecutionContext(tc pluginsCore.TaskExecutionContext, options ...PluginTaskExecutionContextOption) pluginsCore.TaskExecutionContext { + tm := tc.TaskExecutionMetadata() + to := tm.GetOverrides() + ctx := &pluginTaskExecutionContext{ + TaskExecutionContext: tc, + metadata: &pluginTaskExecutionMetadata{ + TaskExecutionMetadata: tm, + overrides: &pluginTaskOverrides{ + TaskOverrides: to, + }, + }, + } + for _, o := range options { + o(ctx) + } + return ctx +} + +type NodeExecutionK8sReader struct { + namespace string + executionID string + nodeID string + client client.Reader +} + +func NewNodeExecutionK8sReader(meta pluginsCore.TaskExecutionMetadata, client pluginsCore.KubeClient) *NodeExecutionK8sReader { + tID := meta.GetTaskExecutionID().GetID() + executionID := tID.GetNodeExecutionId().GetExecutionId().GetName() + nodeID := tID.GetNodeExecutionId().GetNodeId() + namespace := meta.GetNamespace() + return &NodeExecutionK8sReader{ + namespace: namespace, + executionID: executionID, + nodeID: nodeID, + client: client.GetCache(), + } +} + +func (n NodeExecutionK8sReader) Get(ctx context.Context, key client.ObjectKey, obj client.Object, opts ...client.GetOption) error { + key.Namespace = n.namespace + err := n.client.Get(ctx, key, obj, opts...) + if err != nil { + return err + } + + if obj.GetLabels()["node-id"] != n.nodeID || obj.GetLabels()["execution-id"] != n.executionID { + // reset obj to default value, simulate not found + p := reflect.ValueOf(obj).Elem() + p.Set(reflect.Zero(p.Type())) + kind := obj.GetObjectKind().GroupVersionKind() + return errors.NewNotFound(schema.GroupResource{Group: kind.Group, Resource: kind.Kind}, obj.GetName()) + } + return nil +} + +func (n NodeExecutionK8sReader) List(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error { + opts = append(opts, client.InNamespace(n.namespace), client.MatchingLabels{ + "execution-id": n.executionID, + "node-id": n.nodeID, + }) + return n.client.List(ctx, list, opts...) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/plugin_exec_context_test.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/plugin_exec_context_test.go new file mode 100644 index 0000000000..99a122f759 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/plugin_exec_context_test.go @@ -0,0 +1,122 @@ +package flytek8s + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/client/fake" +) + +func Test_NodeExecutionK8sReader(t *testing.T) { + execID := "abc123" + nodeID := "n0" + typeMeta := metav1.TypeMeta{ + Kind: "Pod", + APIVersion: "v1", + } + pod1 := v1.Pod{ + TypeMeta: typeMeta, + ObjectMeta: metav1.ObjectMeta{ + Name: "a", + Namespace: namespace, + Labels: map[string]string{ + "some-label": "bar", + "execution-id": execID, + "node-id": nodeID, + }, + }, + } + pod2 := v1.Pod{ + TypeMeta: typeMeta, + ObjectMeta: metav1.ObjectMeta{ + Name: "b", + Namespace: namespace, + Labels: map[string]string{ + "execution-id": execID, + "node-id": nodeID, + }, + }, + } + pod3 := v1.Pod{ + TypeMeta: typeMeta, + ObjectMeta: metav1.ObjectMeta{ + Name: "c", + Namespace: "wrong", + Labels: map[string]string{ + "execution-id": execID, + "node-id": nodeID, + }, + }, + } + pod4 := v1.Pod{ + TypeMeta: typeMeta, + ObjectMeta: metav1.ObjectMeta{ + Name: "d", + Namespace: namespace, + Labels: map[string]string{ + "execution-id": "wrong", + "node-id": nodeID, + }, + }, + } + pod5 := v1.Pod{ + TypeMeta: typeMeta, + ObjectMeta: metav1.ObjectMeta{ + Name: "e", + Namespace: namespace, + Labels: map[string]string{ + "execution-id": execID, + "node-id": "wrong", + }, + }, + } + pods := []runtime.Object{&pod1, &pod2, &pod3, &pod4, &pod5} + nodeExecReader := NodeExecutionK8sReader{ + namespace: namespace, + executionID: execID, + nodeID: nodeID, + client: fake.NewFakeClient(pods...), + } + ctx := context.TODO() + + t.Run("get", func(t *testing.T) { + p := v1.Pod{} + + err := nodeExecReader.Get(ctx, client.ObjectKeyFromObject(&pod1), &p) + + assert.NoError(t, err) + assert.Equal(t, pod1, p) + }) + + t.Run("get-not-found", func(t *testing.T) { + p := v1.Pod{} + + for _, input := range []*v1.Pod{&pod3, &pod4, &pod5} { + err := nodeExecReader.Get(ctx, client.ObjectKeyFromObject(input), &p) + + assert.True(t, errors.IsNotFound(err)) + } + }) + + t.Run("list", func(t *testing.T) { + p := &v1.PodList{} + expected := &v1.PodList{ + TypeMeta: metav1.TypeMeta{ + Kind: "PodList", + APIVersion: "v1", + }, + Items: []v1.Pod{pod1, pod2}, + } + + err := nodeExecReader.List(ctx, p) + + assert.NoError(t, err) + assert.Equal(t, expected, p) + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/pod_helper.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/pod_helper.go new file mode 100644 index 0000000000..f72e3db86c --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/pod_helper.go @@ -0,0 +1,1553 @@ +package flytek8s + +import ( + "context" + "errors" + "fmt" + "strconv" + "strings" + "time" + + "github.com/golang/protobuf/proto" + "github.com/imdario/mergo" + "google.golang.org/protobuf/types/known/timestamppb" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/util/sets" + "sigs.k8s.io/controller-runtime/pkg/client" + + pluginserrors "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/template" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" + + // TODO @pvditt fix + //propellerCfg "github.com/flyteorg/flyte/flytepropeller/pkg/controller/config" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const PodKind = "pod" +const OOMKilled = "OOMKilled" +const Interrupted = "Interrupted" +const PrimaryContainerNotFound = "PrimaryContainerNotFound" +const SIGKILL = 137 + +// unsignedSIGKILL = 256 - 9 +const unsignedSIGKILL = 247 + +const defaultContainerTemplateName = "default" +const defaultInitContainerTemplateName = "default-init" +const primaryContainerTemplateName = "primary" +const primaryInitContainerTemplateName = "primary-init" +const PrimaryContainerKey = "primary_container_name" +const FlyteEnableVscode = "_F_E_VS" + +var retryableStatusReasons = sets.NewString( + // Reasons that indicate the node was preempted aggressively. + // Kubelet can miss deleting the pod prior to the node being shutdown. + "Shutdown", + "Terminated", + "NodeShutdown", + // kubelet admission rejects the pod before the node gets assigned appropriate labels. + "NodeAffinity", +) + +// AddRequiredNodeSelectorRequirements adds the provided v1.NodeSelectorRequirement +// objects to an existing v1.Affinity object. If there are no existing required +// node selectors, the new v1.NodeSelectorRequirement will be added as-is. +// However, if there are existing required node selectors, we iterate over all existing +// node selector terms and append the node selector requirement. Note that multiple node +// selector terms are OR'd, and match expressions within a single node selector term +// are AND'd during scheduling. +// See: https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#node-affinity +func AddRequiredNodeSelectorRequirements(base *v1.Affinity, new ...v1.NodeSelectorRequirement) { + if base.NodeAffinity == nil { + base.NodeAffinity = &v1.NodeAffinity{} + } + if base.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution == nil { + base.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution = &v1.NodeSelector{} + } + if len(base.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms) > 0 { + nodeSelectorTerms := base.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms + for i := range nodeSelectorTerms { + nst := &nodeSelectorTerms[i] + nst.MatchExpressions = append(nst.MatchExpressions, new...) + } + } else { + base.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms = []v1.NodeSelectorTerm{v1.NodeSelectorTerm{MatchExpressions: new}} + } +} + +// AddPreferredNodeSelectorRequirements appends the provided v1.NodeSelectorRequirement +// objects to an existing v1.Affinity object's list of preferred scheduling terms. +// See: https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#node-affinity-weight +// for how weights are used during scheduling. +func AddPreferredNodeSelectorRequirements(base *v1.Affinity, weight int32, new ...v1.NodeSelectorRequirement) { + if base.NodeAffinity == nil { + base.NodeAffinity = &v1.NodeAffinity{} + } + base.NodeAffinity.PreferredDuringSchedulingIgnoredDuringExecution = append( + base.NodeAffinity.PreferredDuringSchedulingIgnoredDuringExecution, + v1.PreferredSchedulingTerm{ + Weight: weight, + Preference: v1.NodeSelectorTerm{ + MatchExpressions: new, + }, + }, + ) +} + +// ApplyInterruptibleNodeSelectorRequirement configures the node selector requirement of the node-affinity using the configuration specified. +func ApplyInterruptibleNodeSelectorRequirement(interruptible bool, affinity *v1.Affinity) { + // Determine node selector terms to add to node affinity + var nodeSelectorRequirement v1.NodeSelectorRequirement + if interruptible { + if config.GetK8sPluginConfig().InterruptibleNodeSelectorRequirement == nil { + return + } + nodeSelectorRequirement = *config.GetK8sPluginConfig().InterruptibleNodeSelectorRequirement + } else { + if config.GetK8sPluginConfig().NonInterruptibleNodeSelectorRequirement == nil { + return + } + nodeSelectorRequirement = *config.GetK8sPluginConfig().NonInterruptibleNodeSelectorRequirement + } + + AddRequiredNodeSelectorRequirements(affinity, nodeSelectorRequirement) +} + +// ApplyInterruptibleNodeAffinity configures the node-affinity for the pod using the configuration specified. +func ApplyInterruptibleNodeAffinity(interruptible bool, podSpec *v1.PodSpec) { + if podSpec.Affinity == nil { + podSpec.Affinity = &v1.Affinity{} + } + + ApplyInterruptibleNodeSelectorRequirement(interruptible, podSpec.Affinity) +} + +// Specialized merging of overrides into a base *core.ExtendedResources object. Note +// that doing a nested merge may not be the intended behavior all the time, so we +// handle each field separately here. +func ApplyExtendedResourcesOverrides(base, overrides *core.ExtendedResources) *core.ExtendedResources { + // Handle case where base might be nil + var new *core.ExtendedResources + if base == nil { + new = &core.ExtendedResources{} + } else { + new = proto.Clone(base).(*core.ExtendedResources) + } + + // No overrides found + if overrides == nil { + return new + } + + // GPU Accelerator + if overrides.GetGpuAccelerator() != nil { + new.GpuAccelerator = overrides.GetGpuAccelerator() + } + + if overrides.GetSharedMemory() != nil { + new.SharedMemory = overrides.GetSharedMemory() + } + + return new +} + +func ApplySharedMemory(podSpec *v1.PodSpec, primaryContainerName string, SharedMemory *core.SharedMemory) error { + sharedMountName := SharedMemory.GetMountName() + sharedMountPath := SharedMemory.GetMountPath() + if sharedMountName == "" { + return pluginserrors.Errorf(pluginserrors.BadTaskSpecification, "mount name is not set") + } + if sharedMountPath == "" { + return pluginserrors.Errorf(pluginserrors.BadTaskSpecification, "mount path is not set") + } + + var primaryContainer *v1.Container + for index, container := range podSpec.Containers { + if container.Name == primaryContainerName { + primaryContainer = &podSpec.Containers[index] + } + } + if primaryContainer == nil { + return pluginserrors.Errorf(pluginserrors.BadTaskSpecification, "Unable to find primary container") + } + + for _, volume := range podSpec.Volumes { + if volume.Name == sharedMountName { + return pluginserrors.Errorf(pluginserrors.BadTaskSpecification, "A volume is already named %v in pod spec", sharedMountName) + } + } + + for _, volume_mount := range primaryContainer.VolumeMounts { + if volume_mount.Name == sharedMountName { + return pluginserrors.Errorf(pluginserrors.BadTaskSpecification, "A volume is already named %v in container", sharedMountName) + } + if volume_mount.MountPath == sharedMountPath { + return pluginserrors.Errorf(pluginserrors.BadTaskSpecification, "%s is already mounted in container", sharedMountPath) + } + } + + var quantity resource.Quantity + var err error + if len(SharedMemory.GetSizeLimit()) != 0 { + quantity, err = resource.ParseQuantity(SharedMemory.GetSizeLimit()) + if err != nil { + return pluginserrors.Errorf(pluginserrors.BadTaskSpecification, "Unable to parse size limit: %v", err.Error()) + } + } + + podSpec.Volumes = append( + podSpec.Volumes, + v1.Volume{ + Name: sharedMountName, + VolumeSource: v1.VolumeSource{EmptyDir: &v1.EmptyDirVolumeSource{Medium: v1.StorageMediumMemory, SizeLimit: &quantity}}, + }, + ) + primaryContainer.VolumeMounts = append(primaryContainer.VolumeMounts, v1.VolumeMount{Name: sharedMountName, MountPath: sharedMountPath}) + + return nil +} + +// getAcceleratorConfig returns the configuration for the given accelerator device class. +// It first attempts to get device-class-specific configuration from AcceleratorDeviceClasses. +// If not found or incomplete, it falls back to the global GPU configuration fields for backward compatibility. +func getAcceleratorConfig(gpuAccelerator *core.GPUAccelerator) config.AcceleratorDeviceClassConfig { + cfg := config.GetK8sPluginConfig() + + // Start with defaults from global GPU config + accelConfig := config.AcceleratorDeviceClassConfig{ + ResourceName: cfg.GpuResourceName, + DeviceNodeLabel: cfg.GpuDeviceNodeLabel, + PartitionSizeNodeLabel: cfg.GpuPartitionSizeNodeLabel, + UnpartitionedNodeSelectorRequirement: cfg.GpuUnpartitionedNodeSelectorRequirement, + UnpartitionedToleration: cfg.GpuUnpartitionedToleration, + } + + // Override with device-class-specific config if available + if gpuAccelerator != nil { + deviceClass := gpuAccelerator.GetDeviceClass().String() + if deviceClassConfig, ok := cfg.AcceleratorDeviceClasses[deviceClass]; ok { + logger.Debugf(context.TODO(), "Using device-class-specific configuration for accelerator class: %s", deviceClass) + // Override resource name if specified + if deviceClassConfig.ResourceName != "" { + accelConfig.ResourceName = deviceClassConfig.ResourceName + } + // Override device node label if specified + if deviceClassConfig.DeviceNodeLabel != "" { + accelConfig.DeviceNodeLabel = deviceClassConfig.DeviceNodeLabel + } + // Override partition size node label if specified + if deviceClassConfig.PartitionSizeNodeLabel != "" { + accelConfig.PartitionSizeNodeLabel = deviceClassConfig.PartitionSizeNodeLabel + } + // Override unpartitioned node selector requirement if specified + if deviceClassConfig.UnpartitionedNodeSelectorRequirement != nil { + accelConfig.UnpartitionedNodeSelectorRequirement = deviceClassConfig.UnpartitionedNodeSelectorRequirement + } + // Override unpartitioned toleration if specified + if deviceClassConfig.UnpartitionedToleration != nil { + accelConfig.UnpartitionedToleration = deviceClassConfig.UnpartitionedToleration + } + // Override PodTemplate if specified + if deviceClassConfig.PodTemplate != nil { + accelConfig.PodTemplate = deviceClassConfig.PodTemplate + } + } else { + logger.Warnf(context.TODO(), "Device class '%s' not found in AcceleratorDeviceClasses configuration, falling back to global GPU config. Available device classes: %v", + deviceClass, getConfiguredDeviceClasses(cfg.AcceleratorDeviceClasses)) + } + } + + return accelConfig +} + +func ApplyGPUNodeSelectors(podSpec *v1.PodSpec, gpuAccelerator *core.GPUAccelerator) { + // Short circuit if pod spec does not contain any containers that use accelerators + if !podRequiresAccelerator(podSpec) { + return + } + + if podSpec.Affinity == nil { + podSpec.Affinity = &v1.Affinity{} + } + + // Get device-class-specific configuration + accelConfig := getAcceleratorConfig(gpuAccelerator) + + // Apply changes for GPU device + if device := gpuAccelerator.GetDevice(); len(device) > 0 { + // Normalize the device name + normalizedDevice := GetNormalizedAcceleratorDevice(device) + + // Add node selector requirement for GPU device + deviceNsr := v1.NodeSelectorRequirement{ + Key: accelConfig.DeviceNodeLabel, + Operator: v1.NodeSelectorOpIn, + Values: []string{normalizedDevice}, + } + AddRequiredNodeSelectorRequirements(podSpec.Affinity, deviceNsr) + // Add toleration for GPU device + deviceTol := v1.Toleration{ + Key: accelConfig.DeviceNodeLabel, + Value: normalizedDevice, + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + } + podSpec.Tolerations = append(podSpec.Tolerations, deviceTol) + } + + // Short circuit if a partition size preference is not specified + partitionSizeValue := gpuAccelerator.GetPartitionSizeValue() + if partitionSizeValue == nil { + return + } + + // Apply changes for GPU partition size, if applicable + var partitionSizeNsr *v1.NodeSelectorRequirement + var partitionSizeTol *v1.Toleration + switch p := partitionSizeValue.(type) { + case *core.GPUAccelerator_Unpartitioned: + if !p.Unpartitioned { + break + } + if accelConfig.UnpartitionedNodeSelectorRequirement != nil { + partitionSizeNsr = accelConfig.UnpartitionedNodeSelectorRequirement + } else { + partitionSizeNsr = &v1.NodeSelectorRequirement{ + Key: accelConfig.PartitionSizeNodeLabel, + Operator: v1.NodeSelectorOpDoesNotExist, + } + } + if accelConfig.UnpartitionedToleration != nil { + partitionSizeTol = accelConfig.UnpartitionedToleration + } + case *core.GPUAccelerator_PartitionSize: + partitionSizeNsr = &v1.NodeSelectorRequirement{ + Key: accelConfig.PartitionSizeNodeLabel, + Operator: v1.NodeSelectorOpIn, + Values: []string{p.PartitionSize}, + } + partitionSizeTol = &v1.Toleration{ + Key: accelConfig.PartitionSizeNodeLabel, + Value: p.PartitionSize, + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + } + } + if partitionSizeNsr != nil { + AddRequiredNodeSelectorRequirements(podSpec.Affinity, *partitionSizeNsr) + } + if partitionSizeTol != nil { + podSpec.Tolerations = append(podSpec.Tolerations, *partitionSizeTol) + } +} + +// UpdatePod updates the base pod spec used to execute tasks. This is configured with plugins and task metadata-specific options +func UpdatePod(taskExecutionMetadata pluginsCore.TaskExecutionMetadata, + resourceRequirements []v1.ResourceRequirements, podSpec *v1.PodSpec) { + if len(podSpec.RestartPolicy) == 0 { + podSpec.RestartPolicy = v1.RestartPolicyNever + } + podSpec.Tolerations = append( + GetPodTolerations(taskExecutionMetadata.IsInterruptible(), resourceRequirements...), podSpec.Tolerations...) + + if len(podSpec.ServiceAccountName) == 0 { + podSpec.ServiceAccountName = taskExecutionMetadata.GetK8sServiceAccount() + } + if len(podSpec.SchedulerName) == 0 { + podSpec.SchedulerName = config.GetK8sPluginConfig().SchedulerName + } + podSpec.NodeSelector = utils.UnionMaps(config.GetK8sPluginConfig().DefaultNodeSelector, podSpec.NodeSelector) + if taskExecutionMetadata.IsInterruptible() { + podSpec.NodeSelector = utils.UnionMaps(podSpec.NodeSelector, config.GetK8sPluginConfig().InterruptibleNodeSelector) + } + if podSpec.Affinity == nil && config.GetK8sPluginConfig().DefaultAffinity != nil { + podSpec.Affinity = config.GetK8sPluginConfig().DefaultAffinity.DeepCopy() + } + if podSpec.SecurityContext == nil && config.GetK8sPluginConfig().DefaultPodSecurityContext != nil { + podSpec.SecurityContext = config.GetK8sPluginConfig().DefaultPodSecurityContext.DeepCopy() + } + if config.GetK8sPluginConfig().EnableHostNetworkingPod != nil { + podSpec.HostNetwork = *config.GetK8sPluginConfig().EnableHostNetworkingPod + } + if podSpec.DNSConfig == nil && config.GetK8sPluginConfig().DefaultPodDNSConfig != nil { + podSpec.DNSConfig = config.GetK8sPluginConfig().DefaultPodDNSConfig.DeepCopy() + } + ApplyInterruptibleNodeAffinity(taskExecutionMetadata.IsInterruptible(), podSpec) +} + +func mergeMapInto(src map[string]string, dst map[string]string) { + for key, value := range src { + dst[key] = value + } +} + +// BuildRawPod constructs a PodSpec and ObjectMeta based on the definition passed by the TaskExecutionContext. This +// definition does not include any configuration injected by Flyte. +func BuildRawPod(ctx context.Context, tCtx pluginsCore.TaskExecutionContext) (*v1.PodSpec, *metav1.ObjectMeta, string, error) { + taskTemplate, err := tCtx.TaskReader().Read(ctx) + if err != nil { + logger.Warnf(ctx, "failed to read task information when trying to construct Pod, err: %s", err.Error()) + return nil, nil, "", err + } + + var podSpec *v1.PodSpec + objectMeta := metav1.ObjectMeta{ + Annotations: make(map[string]string), + Labels: make(map[string]string), + } + primaryContainerName := "" + + switch target := taskTemplate.GetTarget().(type) { + case *core.TaskTemplate_Container: + // handles tasks defined by a single container + c, err := BuildRawContainer(ctx, tCtx) + if err != nil { + return nil, nil, "", err + } + + primaryContainerName = c.Name + podSpec = &v1.PodSpec{ + Containers: []v1.Container{ + *c, + }, + } + + // handle pod template override + podTemplate := tCtx.TaskExecutionMetadata().GetOverrides().GetPodTemplate() + if podTemplate.GetPodSpec() != nil { + podSpec, objectMeta, err = ApplyPodTemplateOverride(objectMeta, podTemplate) + if err != nil { + return nil, nil, "", err + } + primaryContainerName = podTemplate.GetPrimaryContainerName() + } + + case *core.TaskTemplate_K8SPod: + // handles pod tasks that marshal the pod spec to the k8s_pod task target. + if target.K8SPod.PodSpec == nil { + return nil, nil, "", pluginserrors.Errorf(pluginserrors.BadTaskSpecification, + "Pod tasks with task type version > 1 should specify their target as a K8sPod with a defined pod spec") + } + + err := utils.UnmarshalStructToObj(target.K8SPod.PodSpec, &podSpec) + if err != nil { + return nil, nil, "", pluginserrors.Errorf(pluginserrors.BadTaskSpecification, + "Unable to unmarshal task k8s pod [%v], Err: [%v]", target.K8SPod.PodSpec, err.Error()) + } + + // get primary container name + var ok bool + if primaryContainerName, ok = taskTemplate.GetConfig()[PrimaryContainerKey]; !ok { + return nil, nil, "", pluginserrors.Errorf(pluginserrors.BadTaskSpecification, + "invalid TaskSpecification, config missing [%s] key in [%v]", PrimaryContainerKey, taskTemplate.GetConfig()) + } + + // update annotations and labels + if taskTemplate.GetK8SPod().Metadata != nil { + mergeMapInto(target.K8SPod.Metadata.Annotations, objectMeta.Annotations) + mergeMapInto(target.K8SPod.Metadata.Labels, objectMeta.Labels) + } + + // handle pod template override + podTemplate := tCtx.TaskExecutionMetadata().GetOverrides().GetPodTemplate() + if podTemplate.GetPodSpec() != nil { + podSpec, objectMeta, err = ApplyPodTemplateOverride(objectMeta, podTemplate) + if err != nil { + return nil, nil, "", err + } + primaryContainerName = podTemplate.GetPrimaryContainerName() + } + + default: + return nil, nil, "", pluginserrors.Errorf(pluginserrors.BadTaskSpecification, + "invalid TaskSpecification, unable to determine Pod configuration") + } + + enableServiceLinks := false + podSpec.EnableServiceLinks = &enableServiceLinks + + return podSpec, &objectMeta, primaryContainerName, nil +} + +func hasExternalLinkType(taskTemplate *core.TaskTemplate) bool { + if taskTemplate == nil { + return false + } + config := taskTemplate.GetConfig() + if config == nil { + return false + } + // The presence of any "link_type" is sufficient to guarantee that the console URL should be included. + _, exists := config["link_type"] + return exists +} + +// ApplyFlytePodConfiguration updates the PodSpec and ObjectMeta with various Flyte configuration. This includes +// applying default k8s configuration, applying overrides (resources etc.), injecting copilot containers, and merging with the +// configuration PodTemplate (if exists). +func ApplyFlytePodConfiguration(ctx context.Context, tCtx pluginsCore.TaskExecutionContext, podSpec *v1.PodSpec, objectMeta *metav1.ObjectMeta, primaryContainerName string) (*v1.PodSpec, *metav1.ObjectMeta, error) { + taskTemplate, err := tCtx.TaskReader().Read(ctx) + if err != nil { + logger.Warnf(ctx, "failed to read task information when trying to construct Pod, err: %s", err.Error()) + return nil, nil, err + } + + // add flyte resource customizations to containers + templateParameters := template.Parameters{ + Inputs: tCtx.InputReader(), + OutputPath: tCtx.OutputWriter(), + Task: tCtx.TaskReader(), + TaskExecMetadata: tCtx.TaskExecutionMetadata(), + IncludeConsoleURL: hasExternalLinkType(taskTemplate), + } + + // Merge overrides with base extended resources + extendedResources := ApplyExtendedResourcesOverrides( + taskTemplate.GetExtendedResources(), + tCtx.TaskExecutionMetadata().GetOverrides().GetExtendedResources(), + ) + + // iterate over the initContainers first + for index := range podSpec.InitContainers { + var resourceMode = ResourceCustomizationModeEnsureExistingResourcesInRange + + if err := AddFlyteCustomizationsToContainer(ctx, templateParameters, resourceMode, &podSpec.InitContainers[index], extendedResources); err != nil { + return nil, nil, err + } + } + + resourceRequests := make([]v1.ResourceRequirements, 0, len(podSpec.Containers)) + var primaryContainer *v1.Container + for index, container := range podSpec.Containers { + var resourceMode = ResourceCustomizationModeEnsureExistingResourcesInRange + if container.Name == primaryContainerName { + resourceMode = ResourceCustomizationModeMergeExistingResources + } + + if err := AddFlyteCustomizationsToContainer(ctx, templateParameters, resourceMode, &podSpec.Containers[index], extendedResources); err != nil { + return nil, nil, err + } + + resourceRequests = append(resourceRequests, podSpec.Containers[index].Resources) + if container.Name == primaryContainerName { + primaryContainer = &podSpec.Containers[index] + } + } + + if primaryContainer == nil { + return nil, nil, pluginserrors.Errorf(pluginserrors.BadTaskSpecification, "invalid TaskSpecification, primary container [%s] not defined", primaryContainerName) + } + + // add copilot configuration to primaryContainer and PodSpec (if necessary) + var dataLoadingConfig *core.DataLoadingConfig + if container := taskTemplate.GetContainer(); container != nil { + dataLoadingConfig = container.GetDataConfig() + } else if pod := taskTemplate.GetK8SPod(); pod != nil { + dataLoadingConfig = pod.GetDataConfig() + } + + primaryInitContainerName := "" + + if dataLoadingConfig != nil { + if err := AddCoPilotToContainer(ctx, config.GetK8sPluginConfig().CoPilot, + primaryContainer, taskTemplate.Interface, dataLoadingConfig); err != nil { + return nil, nil, err + } + + if err := AddCoPilotToPod(ctx, config.GetK8sPluginConfig().CoPilot, podSpec, taskTemplate.GetInterface(), + tCtx.TaskExecutionMetadata(), tCtx.InputReader(), tCtx.OutputWriter(), dataLoadingConfig); err != nil { + return nil, nil, err + } + } + + // update primaryContainer and PodSpec with k8s plugin configuration, etc + UpdatePod(tCtx.TaskExecutionMetadata(), resourceRequests, podSpec) + if primaryContainer.SecurityContext == nil && config.GetK8sPluginConfig().DefaultSecurityContext != nil { + primaryContainer.SecurityContext = config.GetK8sPluginConfig().DefaultSecurityContext.DeepCopy() + } + + // Apply device-class-specific PodTemplate (if applicable) + // This provides device-specific defaults while allowing task configs to override + podSpec, err = applyAcceleratorDeviceClassPodTemplate(ctx, podSpec, extendedResources, primaryContainerName, primaryInitContainerName) + if err != nil { + return nil, nil, err + } + + // merge PodSpec and ObjectMeta with configuration pod template (if exists) + podSpec, objectMeta, err = MergeWithBasePodTemplate(ctx, tCtx, podSpec, objectMeta, primaryContainerName, primaryInitContainerName) + if err != nil { + return nil, nil, err + } + + // TODO @pvditt + //if propellerCfg.GetConfig().AcceleratedInputs.Enabled { + // ApplyAcceleratedInputsSpec(podSpec, primaryContainerName) + //} + + // GPU accelerator + if extendedResources.GetGpuAccelerator() != nil { + ApplyGPUNodeSelectors(podSpec, extendedResources.GetGpuAccelerator()) + } + + // Shared memory volume + if extendedResources.GetSharedMemory() != nil { + err = ApplySharedMemory(podSpec, primaryContainerName, extendedResources.GetSharedMemory()) + if err != nil { + return nil, nil, err + } + } + + // Override container image if necessary + if len(tCtx.TaskExecutionMetadata().GetOverrides().GetContainerImage()) > 0 { + ApplyContainerImageOverride(podSpec, tCtx.TaskExecutionMetadata().GetOverrides().GetContainerImage(), primaryContainerName) + } + + return podSpec, objectMeta, nil +} + +func IsVscodeEnabled(ctx context.Context, envVar []v1.EnvVar) bool { + for _, env := range envVar { + if env.Name != FlyteEnableVscode { + continue + } + var err error + enableVscode, err := strconv.ParseBool(env.Value) + if err != nil { + logger.Errorf(ctx, "failed to parse %s env var: [%s]", FlyteEnableVscode, env.Value) + return false + } + return enableVscode + } + return false +} + +func ApplyContainerImageOverride(podSpec *v1.PodSpec, containerImage string, primaryContainerName string) { + for i, c := range podSpec.Containers { + if c.Name == primaryContainerName { + podSpec.Containers[i].Image = containerImage + return + } + } +} + +func ApplyPodTemplateOverride(objectMeta metav1.ObjectMeta, podTemplate *core.K8SPod) (*v1.PodSpec, metav1.ObjectMeta, error) { + if podTemplate.GetMetadata().GetAnnotations() != nil { + mergeMapInto(podTemplate.GetMetadata().GetAnnotations(), objectMeta.Annotations) + } + if podTemplate.GetMetadata().GetLabels() != nil { + mergeMapInto(podTemplate.GetMetadata().GetLabels(), objectMeta.Labels) + } + + var podSpecOverride *v1.PodSpec + err := utils.UnmarshalStructToObj(podTemplate.GetPodSpec(), &podSpecOverride) + if err != nil { + return nil, objectMeta, err + } + + return podSpecOverride, objectMeta, nil +} + +func addTolerationInPodSpec(podSpec *v1.PodSpec, toleration *v1.Toleration) *v1.PodSpec { + podTolerations := podSpec.Tolerations + + var newTolerations []v1.Toleration + for i := range podTolerations { + if toleration.MatchToleration(&podTolerations[i]) { + return podSpec + } + newTolerations = append(newTolerations, podTolerations[i]) + } + newTolerations = append(newTolerations, *toleration) + podSpec.Tolerations = newTolerations + return podSpec +} + +func AddTolerationsForExtendedResources(podSpec *v1.PodSpec) *v1.PodSpec { + if podSpec == nil { + podSpec = &v1.PodSpec{} + } + + resources := sets.NewString() + for _, container := range podSpec.Containers { + for _, extendedResource := range config.GetK8sPluginConfig().AddTolerationsForExtendedResources { + if _, ok := container.Resources.Requests[v1.ResourceName(extendedResource)]; ok { + resources.Insert(extendedResource) + } + } + } + + for _, container := range podSpec.InitContainers { + for _, extendedResource := range config.GetK8sPluginConfig().AddTolerationsForExtendedResources { + if _, ok := container.Resources.Requests[v1.ResourceName(extendedResource)]; ok { + resources.Insert(extendedResource) + } + } + } + + for _, resource := range resources.List() { + addTolerationInPodSpec(podSpec, &v1.Toleration{ + Key: resource, + Operator: v1.TolerationOpExists, + Effect: v1.TaintEffectNoSchedule, + }) + } + + return podSpec +} + +// ToK8sPodSpec builds a PodSpec and ObjectMeta based on the definition passed by the TaskExecutionContext. This +// involves parsing the raw PodSpec definition and applying all Flyte configuration options. +func ToK8sPodSpec(ctx context.Context, tCtx pluginsCore.TaskExecutionContext) (*v1.PodSpec, *metav1.ObjectMeta, string, error) { + // build raw PodSpec and ObjectMeta + podSpec, objectMeta, primaryContainerName, err := BuildRawPod(ctx, tCtx) + if err != nil { + return nil, nil, "", err + } + + // add flyte configuration + podSpec, objectMeta, err = ApplyFlytePodConfiguration(ctx, tCtx, podSpec, objectMeta, primaryContainerName) + if err != nil { + return nil, nil, "", err + } + + podSpec = AddTolerationsForExtendedResources(podSpec) + + return podSpec, objectMeta, primaryContainerName, nil +} + +func GetContainer(podSpec *v1.PodSpec, name string) (*v1.Container, error) { + for _, container := range podSpec.Containers { + if container.Name == name { + return &container, nil + } + } + return nil, pluginserrors.Errorf(pluginserrors.BadTaskSpecification, "invalid TaskSpecification, container [%s] not defined", name) +} + +// getBasePodTemplate attempts to retrieve the PodTemplate to use as the base for k8s Pod configuration. This value can +// come from one of the following: +// (1) PodTemplate name in the TaskMetadata: This name is then looked up in the PodTemplateStore. +// (2) Default PodTemplate name from configuration: This name is then looked up in the PodTemplateStore. +func getBasePodTemplate(ctx context.Context, tCtx pluginsCore.TaskExecutionContext, podTemplateStore PodTemplateStore) (*v1.PodTemplate, error) { + taskTemplate, err := tCtx.TaskReader().Read(ctx) + if err != nil { + return nil, pluginserrors.Errorf(pluginserrors.BadTaskSpecification, "TaskSpecification cannot be read, Err: [%v]", err.Error()) + } + + var podTemplate *v1.PodTemplate + if taskTemplate.Metadata != nil && len(taskTemplate.Metadata.PodTemplateName) > 0 { + // retrieve PodTemplate by name from PodTemplateStore + podTemplate = podTemplateStore.LoadOrDefault(tCtx.TaskExecutionMetadata().GetNamespace(), taskTemplate.Metadata.PodTemplateName) + if podTemplate == nil { + return nil, pluginserrors.Errorf(pluginserrors.BadTaskSpecification, "PodTemplate '%s' does not exist", taskTemplate.Metadata.PodTemplateName) + } + } else { + // check for default PodTemplate + podTemplate = podTemplateStore.LoadOrDefault(tCtx.TaskExecutionMetadata().GetNamespace(), config.GetK8sPluginConfig().DefaultPodTemplateName) + } + + return podTemplate, nil +} + +// MergeWithBasePodTemplate attempts to merge the provided PodSpec and ObjectMeta with the configuration PodTemplate for +// this task. +func MergeWithBasePodTemplate(ctx context.Context, tCtx pluginsCore.TaskExecutionContext, + podSpec *v1.PodSpec, objectMeta *metav1.ObjectMeta, primaryContainerName, primaryInitContainerName string) (*v1.PodSpec, *metav1.ObjectMeta, error) { + + // attempt to retrieve base PodTemplate + podTemplate, err := getBasePodTemplate(ctx, tCtx, DefaultPodTemplateStore) + if err != nil { + return nil, nil, err + } else if podTemplate == nil { + // if no PodTemplate to merge as base -> return + return podSpec, objectMeta, nil + } + + // merge podTemplate onto podSpec + templateSpec := &podTemplate.Template.Spec + mergedPodSpec, err := MergeBasePodSpecOntoTemplate(templateSpec, podSpec, primaryContainerName, primaryInitContainerName) + if err != nil { + return nil, nil, err + } + + // merge PodTemplate PodSpec with podSpec + var mergedObjectMeta *metav1.ObjectMeta = podTemplate.Template.ObjectMeta.DeepCopy() + if err := mergo.Merge(mergedObjectMeta, objectMeta, mergo.WithOverride, mergo.WithAppendSlice); err != nil { + return nil, nil, err + } + + return mergedPodSpec, mergedObjectMeta, nil +} + +// MergeBasePodSpecOntoTemplate merges a base pod spec onto a template pod spec. The template pod spec has some +// magic values that allow users to specify templates that target all containers and primary containers. Aside from +// magic values this method will merge containers that have matching names. +func MergeBasePodSpecOntoTemplate(templatePodSpec *v1.PodSpec, basePodSpec *v1.PodSpec, primaryContainerName string, primaryInitContainerName string) (*v1.PodSpec, error) { + if templatePodSpec == nil || basePodSpec == nil { + return nil, errors.New("neither the templatePodSpec or the basePodSpec can be nil") + } + + // extract primaryContainerTemplate. The base should always contain the primary container. + var defaultContainerTemplate, primaryContainerTemplate *v1.Container + + // extract default container template + for i := 0; i < len(templatePodSpec.Containers); i++ { + if templatePodSpec.Containers[i].Name == defaultContainerTemplateName { + defaultContainerTemplate = &templatePodSpec.Containers[i] + } else if templatePodSpec.Containers[i].Name == primaryContainerTemplateName { + primaryContainerTemplate = &templatePodSpec.Containers[i] + } + } + + // extract primaryInitContainerTemplate. The base should always contain the primary container. + var defaultInitContainerTemplate, primaryInitContainerTemplate *v1.Container + + // extract defaultInitContainerTemplate + for i := 0; i < len(templatePodSpec.InitContainers); i++ { + if templatePodSpec.InitContainers[i].Name == defaultInitContainerTemplateName { + defaultInitContainerTemplate = &templatePodSpec.InitContainers[i] + } else if templatePodSpec.InitContainers[i].Name == primaryInitContainerTemplateName { + primaryInitContainerTemplate = &templatePodSpec.InitContainers[i] + } + } + + // Merge base into template + mergedPodSpec := templatePodSpec.DeepCopy() + if err := mergo.Merge(mergedPodSpec, basePodSpec, mergo.WithOverride, mergo.WithAppendSlice); err != nil { + return nil, err + } + + // merge PodTemplate containers + var mergedContainers []v1.Container + for _, container := range basePodSpec.Containers { + // if applicable start with defaultContainerTemplate + var mergedContainer *v1.Container + if defaultContainerTemplate != nil { + mergedContainer = defaultContainerTemplate.DeepCopy() + } + + // If this is a primary container handle the template + if container.Name == primaryContainerName && primaryContainerTemplate != nil { + if mergedContainer == nil { + mergedContainer = primaryContainerTemplate.DeepCopy() + } else { + err := mergo.Merge(mergedContainer, primaryContainerTemplate, mergo.WithOverride, mergo.WithAppendSlice) + if err != nil { + return nil, err + } + } + } + + // Check for any name matching template containers + for i, templateContainer := range templatePodSpec.Containers { + if templateContainer.Name != container.Name { + continue + } + + if mergedContainer == nil { + mergedContainer = &templatePodSpec.Containers[i] + } else { + err := mergo.Merge(mergedContainer, templateContainer, mergo.WithOverride, mergo.WithAppendSlice) + if err != nil { + return nil, err + } + } + } + + // Merge in the base container + if mergedContainer == nil { + mergedContainer = container.DeepCopy() + } else { + err := mergo.Merge(mergedContainer, container, mergo.WithOverride, mergo.WithAppendSlice) + if err != nil { + return nil, err + } + } + + mergedContainers = append(mergedContainers, *mergedContainer) + + } + + mergedPodSpec.Containers = mergedContainers + + // merge PodTemplate init containers + var mergedInitContainers []v1.Container + for _, initContainer := range basePodSpec.InitContainers { + // if applicable start with defaultContainerTemplate + var mergedInitContainer *v1.Container + if defaultInitContainerTemplate != nil { + mergedInitContainer = defaultInitContainerTemplate.DeepCopy() + } + + // If this is a primary init container handle the template + if initContainer.Name == primaryInitContainerName && primaryInitContainerTemplate != nil { + if mergedInitContainer == nil { + mergedInitContainer = primaryInitContainerTemplate.DeepCopy() + } else { + err := mergo.Merge(mergedInitContainer, primaryInitContainerTemplate, mergo.WithOverride, mergo.WithAppendSlice) + if err != nil { + return nil, err + } + } + } + + // Check for any name matching template containers + for i, templateInitContainer := range templatePodSpec.InitContainers { + if templateInitContainer.Name != initContainer.Name { + continue + } + + if mergedInitContainer == nil { + mergedInitContainer = &templatePodSpec.InitContainers[i] + } else { + err := mergo.Merge(mergedInitContainer, templateInitContainer, mergo.WithOverride, mergo.WithAppendSlice) + if err != nil { + return nil, err + } + } + } + + // Merge in the base init container + if mergedInitContainer == nil { + mergedInitContainer = initContainer.DeepCopy() + } else { + err := mergo.Merge(mergedInitContainer, initContainer, mergo.WithOverride, mergo.WithAppendSlice) + if err != nil { + return nil, err + } + } + + mergedInitContainers = append(mergedInitContainers, *mergedInitContainer) + } + + mergedPodSpec.InitContainers = mergedInitContainers + + return mergedPodSpec, nil +} + +// MergeOverlayPodSpecOntoBase merges a customized pod spec onto a base pod spec. At a container level it will +// merge containers that have matching names. +func MergeOverlayPodSpecOntoBase(basePodSpec *v1.PodSpec, overlayPodSpec *v1.PodSpec) (*v1.PodSpec, error) { + if basePodSpec == nil || overlayPodSpec == nil { + return nil, errors.New("neither the basePodSpec or the overlayPodSpec can be nil") + } + + mergedPodSpec := basePodSpec.DeepCopy() + if err := mergo.Merge(mergedPodSpec, overlayPodSpec, mergo.WithOverride, mergo.WithAppendSlice); err != nil { + return nil, err + } + + // merge PodTemplate containers + var mergedContainers []v1.Container + for _, container := range basePodSpec.Containers { + + mergedContainer := container.DeepCopy() + + for _, overlayContainer := range overlayPodSpec.Containers { + if mergedContainer.Name == overlayContainer.Name { + err := mergo.Merge(mergedContainer, overlayContainer, mergo.WithOverride, mergo.WithAppendSlice) + if err != nil { + return nil, err + } + } + } + mergedContainers = append(mergedContainers, *mergedContainer) + } + + mergedPodSpec.Containers = mergedContainers + + // merge PodTemplate init containers + var mergedInitContainers []v1.Container + for _, initContainer := range basePodSpec.InitContainers { + + mergedInitContainer := initContainer.DeepCopy() + + for _, overlayInitContainer := range overlayPodSpec.InitContainers { + if mergedInitContainer.Name == overlayInitContainer.Name { + err := mergo.Merge(mergedInitContainer, overlayInitContainer, mergo.WithOverride, mergo.WithAppendSlice) + if err != nil { + return nil, err + } + } + } + mergedInitContainers = append(mergedInitContainers, *mergedInitContainer) + } + + mergedPodSpec.InitContainers = mergedInitContainers + + return mergedPodSpec, nil +} + +// applyAcceleratorDeviceClassPodTemplate applies device-class-specific PodTemplate configuration +// to the provided PodSpec using MergeBasePodSpecOntoTemplate. The device class PodTemplate serves as a base, +// with task PodSpec values taking precedence. +// +// See AcceleratorDeviceClassConfig.PodTemplate documentation for detailed merge semantics, +// precedence rules, and container template support. +func applyAcceleratorDeviceClassPodTemplate( + ctx context.Context, + podSpec *v1.PodSpec, + extendedResources *core.ExtendedResources, + primaryContainerName string, + primaryInitContainerName string, +) (*v1.PodSpec, error) { + if extendedResources == nil || extendedResources.GetGpuAccelerator() == nil { + return podSpec, nil + } + + gpuAccelerator := extendedResources.GetGpuAccelerator() + accelConfig := getAcceleratorConfig(gpuAccelerator) + + if accelConfig.PodTemplate == nil { + return podSpec, nil + } + + deviceClass := gpuAccelerator.GetDeviceClass().String() + logger.Infof(ctx, "Applying PodTemplate for accelerator device class: %s", deviceClass) + + // Use MergeBasePodSpecOntoTemplate with device class pod template as base + mergedPodSpec, err := MergeBasePodSpecOntoTemplate(&accelConfig.PodTemplate.Template.Spec, podSpec, primaryContainerName, primaryInitContainerName) + if err != nil { + return nil, pluginserrors.Wrapf( + pluginserrors.DownstreamSystemError, + err, + "Failed to merge PodTemplate for accelerator device class '%s'. "+ + "Check k8s.accelerator-device-classes[%s].pod-template configuration.", + deviceClass, deviceClass, + ) + } + + return mergedPodSpec, nil +} + +// TODO @pvditt +//func ApplyAcceleratedInputsSpec(spec *v1.PodSpec, primaryName string) { +// cfg := propellerCfg.GetConfig().AcceleratedInputs +// hostPathType := v1.HostPathDirectory +// spec.Volumes = append(spec.Volumes, v1.Volume{ +// Name: "union-persistent-data-volume", +// VolumeSource: v1.VolumeSource{ +// HostPath: &v1.HostPathVolumeSource{ +// Path: cfg.VolumePath, +// Type: &hostPathType, +// }, +// }, +// }) +// for i, cont := range spec.Containers { +// if cont.Name == primaryName { +// spec.Containers[i].VolumeMounts = append(cont.VolumeMounts, v1.VolumeMount{ +// Name: "union-persistent-data-volume", +// ReadOnly: true, +// MountPath: cfg.LocalPathPrefix, +// }) +// } +// } +//} + +func BuildIdentityPod() *v1.Pod { + return &v1.Pod{ + TypeMeta: metav1.TypeMeta{ + Kind: PodKind, + APIVersion: v1.SchemeGroupVersion.String(), + }, + } +} + +// DemystifyPending is one the core functions, that helps FlytePropeller determine if a pending pod is indeed pending, +// or it is actually stuck in a un-reparable state. In such a case the pod should be marked as dead and the task should +// be retried. This has to be handled sadly, as K8s is still largely designed for long running services that should +// recover from failures, but Flyte pods are completely automated and should either run or fail +// Important considerations. +// Pending Status in Pod could be for various reasons and sometimes could signal a problem +// Case I: Pending because the Image pull is failing and it is backing off +// +// This could be transient. So we can actually rely on the failure reason. +// The failure transitions from ErrImagePull -> ImagePullBackoff +// +// Case II: Not enough resources are available. This is tricky. It could be that the total number of +// +// resources requested is beyond the capability of the system. for this we will rely on configuration +// and hence input gates. We should not allow bad requests that Request for large number of resource through. +// In the case it makes through, we will fail after timeout +func DemystifyPending(status v1.PodStatus, info pluginsCore.TaskInfo) (pluginsCore.PhaseInfo, error) { + phaseInfo, t := demystifyPendingHelper(status, info) + + if phaseInfo.Phase().IsTerminal() { + return phaseInfo, nil + } + + podPendingTimeout := config.GetK8sPluginConfig().PodPendingTimeout.Duration + if podPendingTimeout > 0 && time.Since(t) >= podPendingTimeout { + return pluginsCore.PhaseInfoSystemRetryableFailureWithCleanup("PodPendingTimeout", phaseInfo.Reason(), &pluginsCore.TaskInfo{ + OccurredAt: &t, + }), nil + } + + if phaseInfo.Phase() != pluginsCore.PhaseUndefined { + return phaseInfo, nil + } + + return pluginsCore.PhaseInfoQueuedWithTaskInfo(time.Now(), pluginsCore.DefaultPhaseVersion, "Scheduling", phaseInfo.Info()), nil +} + +// DemystifyFailedOrPendingPod inspects the pod status of a failed or pending pod and attempts to determine the reason +// for the failure or pending state. This function currently only handles pods in the Failed or Pending phase. +// This is useful to check the specific error from the pod in the rayjob, sparkjob, etc. +// For example, if the pod is in the Failed phase due to an image pull error, this function can return a more specific +// error message indicating that the image could not be pulled. +// Similarly, if the pod is in the Pending phase due to insufficient resources, this function can return an error +// message indicating that the pod could not be scheduled due to lack of resources. +func DemystifyFailedOrPendingPod( + ctx context.Context, + pluginContext k8s.PluginContext, + info pluginsCore.TaskInfo, + namespace string, + podName string, + primaryContainerName string, +) (pluginsCore.PhaseInfo, error) { + pod := &v1.Pod{} + var phaseInfo pluginsCore.PhaseInfo + + err := pluginContext.K8sReader().Get(ctx, client.ObjectKey{Namespace: namespace, Name: podName}, pod) + if err != nil { + logger.Debugf(ctx, "Failed to get pod %s in namespace %s. Error: %v", podName, namespace, err) + } + switch pod.Status.Phase { + case v1.PodFailed: + phaseInfo, err = DemystifyFailure(ctx, pod.Status, info, primaryContainerName) + case v1.PodPending: + phaseInfo, err = DemystifyPending(pod.Status, info) + } + return phaseInfo, err +} + +func demystifyPendingHelper(status v1.PodStatus, info pluginsCore.TaskInfo) (pluginsCore.PhaseInfo, time.Time) { + // Search over the difference conditions in the status object. Note that the 'Pending' this function is + // demystifying is the 'phase' of the pod status. This is different than the PodReady condition type also used below + phaseInfo := pluginsCore.PhaseInfoQueuedWithTaskInfo(time.Now(), pluginsCore.DefaultPhaseVersion, "Demistify Pending", &info) + + t := time.Now() + for _, c := range status.Conditions { + t = c.LastTransitionTime.Time + switch c.Type { + case v1.PodScheduled: + if c.Status == v1.ConditionFalse { + // Waiting to be scheduled. This usually refers to inability to acquire resources. + return pluginsCore.PhaseInfoQueuedWithTaskInfo(t, pluginsCore.DefaultPhaseVersion, fmt.Sprintf("%s:%s", c.Reason, c.Message), phaseInfo.Info()), t + } + + case v1.PodReasonUnschedulable: + // We Ignore case in which we are unable to find resources on the cluster. This is because + // - The resources may be not available at the moment, but may become available eventually + // The pod scheduler will keep on looking at this pod and trying to satisfy it. + // + // Pod status looks like this: + // message: '0/1 nodes are available: 1 Insufficient memory.' + // reason: Unschedulable + // status: "False" + // type: PodScheduled + return pluginsCore.PhaseInfoQueuedWithTaskInfo(t, pluginsCore.DefaultPhaseVersion, fmt.Sprintf("%s:%s", c.Reason, c.Message), phaseInfo.Info()), t + + case v1.PodReady: + if c.Status == v1.ConditionFalse { + // This happens in the case the image is having some problems. In the following example, K8s is having + // problems downloading an image. To ensure that, we will have to iterate over all the container statuses and + // find if some container has imagepull failure + // e.g. + // - lastProbeTime: null + // lastTransitionTime: 2018-12-18T00:57:30Z + // message: 'containers with unready status: [myapp-container]' + // reason: ContainersNotReady + // status: "False" + // type: Ready + // + // e.g. Container status + // - image: blah + // imageID: "" + // lastState: {} + // name: myapp-container + // ready: false + // restartCount: 0 + // state: + // waiting: + // message: Back-off pulling image "blah" + // reason: ImagePullBackOff + for _, containerStatus := range status.ContainerStatuses { + if !containerStatus.Ready { + if containerStatus.State.Waiting != nil { + // There are a variety of reasons that can cause a pod to be in this waiting state. + // Waiting state may be legitimate when the container is being downloaded, started or init containers are running + reason := containerStatus.State.Waiting.Reason + finalReason := fmt.Sprintf("%s|%s", c.Reason, reason) + finalMessage := fmt.Sprintf("%s|%s", c.Message, containerStatus.State.Waiting.Message) + switch reason { + case "ErrImagePull", "ContainerCreating", "PodInitializing": + // But, there are only two "reasons" when a pod is successfully being created and hence it is in + // waiting state + // Refer to https://github.com/kubernetes/kubernetes/blob/master/pkg/kubelet/kubelet_pods.go + // and look for the default waiting states + // We also want to allow Image pulls to be retried, so ErrImagePull will be ignored + // as it eventually enters into ImagePullBackOff + // ErrImagePull -> Transitionary phase to ImagePullBackOff + // ContainerCreating -> Image is being downloaded + // PodInitializing -> Init containers are running + return pluginsCore.PhaseInfoInitializing(t, pluginsCore.DefaultPhaseVersion, fmt.Sprintf("[%s]: %s", finalReason, finalMessage), &pluginsCore.TaskInfo{OccurredAt: &t}), t + + case "CreateContainerError": + // This may consist of: + // 1. Transient errors: e.g. failed to reserve + // container name, container name [...] already in use + // by container + // 2. Permanent errors: e.g. no command specified + // To handle both types of errors gracefully without + // arbitrary pattern matching in the message, we simply + // allow a grace period for kubelet to resolve + // transient issues with the container runtime. If the + // error persists beyond this time, the corresponding + // task is marked as failed. + // NOTE: The current implementation checks for a timeout + // by comparing the condition's LastTransitionTime + // based on the corresponding kubelet's clock with the + // current time based on FlytePropeller's clock. This + // is not ideal given that these 2 clocks are NOT + // synced, and therefore, only provides an + // approximation of the elapsed time since the last + // transition. + + gracePeriod := config.GetK8sPluginConfig().CreateContainerErrorGracePeriod.Duration + if time.Since(t) >= gracePeriod { + return pluginsCore.PhaseInfoFailureWithCleanup(finalReason, GetMessageAfterGracePeriod(finalMessage, gracePeriod), &pluginsCore.TaskInfo{ + OccurredAt: &t, + }), t + } + return pluginsCore.PhaseInfoInitializing( + t, + pluginsCore.DefaultPhaseVersion, + fmt.Sprintf("[%s]: %s", finalReason, finalMessage), + &pluginsCore.TaskInfo{OccurredAt: &t}, + ), t + + case "CreateContainerConfigError": + gracePeriod := config.GetK8sPluginConfig().CreateContainerConfigErrorGracePeriod.Duration + if time.Since(t) >= gracePeriod { + return pluginsCore.PhaseInfoFailureWithCleanup(finalReason, GetMessageAfterGracePeriod(finalMessage, gracePeriod), &pluginsCore.TaskInfo{ + OccurredAt: &t, + }), t + } + return pluginsCore.PhaseInfoInitializing( + t, + pluginsCore.DefaultPhaseVersion, + fmt.Sprintf("[%s]: %s", finalReason, finalMessage), + &pluginsCore.TaskInfo{OccurredAt: &t}, + ), t + + case "InvalidImageName": + return pluginsCore.PhaseInfoFailureWithCleanup(finalReason, finalMessage, &pluginsCore.TaskInfo{ + OccurredAt: &t, + }), t + + case "ImagePullBackOff": + gracePeriod := config.GetK8sPluginConfig().ImagePullBackoffGracePeriod.Duration + if time.Since(t) >= gracePeriod { + return pluginsCore.PhaseInfoRetryableFailureWithCleanup(finalReason, GetMessageAfterGracePeriod(finalMessage, gracePeriod), &pluginsCore.TaskInfo{ + OccurredAt: &t, + }), t + } + + return pluginsCore.PhaseInfoInitializing( + t, + pluginsCore.DefaultPhaseVersion, + fmt.Sprintf("[%s]: %s", finalReason, finalMessage), + &pluginsCore.TaskInfo{OccurredAt: &t}, + ), t + + default: + // Since we are not checking for all error states, we may end up perpetually + // in the queued state returned at the bottom of this function, until the Pod is reaped + // by K8s and we get elusive 'pod not found' errors + // So be default if the container is not waiting with the PodInitializing/ContainerCreating + // reasons, then we will assume a failure reason, and fail instantly + return pluginsCore.PhaseInfoSystemRetryableFailureWithCleanup(finalReason, finalMessage, &pluginsCore.TaskInfo{ + OccurredAt: &t, + }), t + } + } + } + } + } + } + } + + return phaseInfo, t +} + +func GetMessageAfterGracePeriod(message string, gracePeriod time.Duration) string { + return fmt.Sprintf("Grace period [%s] exceeded|%s", gracePeriod, message) +} + +func DemystifySuccess(status v1.PodStatus, info pluginsCore.TaskInfo) (pluginsCore.PhaseInfo, error) { + for _, status := range append( + append(status.InitContainerStatuses, status.ContainerStatuses...), status.EphemeralContainerStatuses...) { + if status.State.Terminated != nil && strings.Contains(status.State.Terminated.Reason, OOMKilled) { + return pluginsCore.PhaseInfoRetryableFailure(OOMKilled, + "Pod reported success despite being OOMKilled", &info), nil + } + } + return pluginsCore.PhaseInfoSuccess(&info), nil +} + +// DeterminePrimaryContainerPhase as the name suggests, given all the containers, will return a pluginsCore.PhaseInfo object +// corresponding to the phase of the primaryContainer which is identified using the provided name. +// This is useful in case of sidecars or pod jobs, where Flyte will monitor successful exit of a single container. +func DeterminePrimaryContainerPhase(ctx context.Context, primaryContainerName string, statuses []v1.ContainerStatus, info *pluginsCore.TaskInfo) pluginsCore.PhaseInfo { + for _, s := range statuses { + if s.Name == primaryContainerName { + if s.State.Waiting != nil || s.State.Running != nil { + return pluginsCore.PhaseInfoRunning(pluginsCore.DefaultPhaseVersion, info) + } + + if s.State.Terminated != nil { + message := fmt.Sprintf("\r\n[%v] terminated with exit code (%v). Reason [%v]. Message: \n%v.", + s.Name, + s.State.Terminated.ExitCode, + s.State.Terminated.Reason, + s.State.Terminated.Message) + + var phaseInfo pluginsCore.PhaseInfo + switch { + case strings.Contains(s.State.Terminated.Reason, OOMKilled): + // OOMKilled typically results in a SIGKILL signal, but we classify it as a user error + phaseInfo = pluginsCore.PhaseInfoRetryableFailure( + s.State.Terminated.Reason, message, info) + case isTerminatedWithSigKill(s.State): + // If the primary container exited with SIGKILL, we treat it as a system-level error + // (such as node termination or preemption). This best-effort approach accepts some false positives. + // In the case that node preemption terminates the kubelet *before* the kubelet is able to persist + // the pod's state to the Kubernetes API server, we rely on Kubernetes to eventually resolve + // the state. This will enable Propeller to eventually query the API server and determine that + // the pod no longer exists, which will then be counted as a system error. + phaseInfo = pluginsCore.PhaseInfoSystemRetryableFailure( + s.State.Terminated.Reason, message, info) + case s.State.Terminated.ExitCode != 0: + phaseInfo = pluginsCore.PhaseInfoRetryableFailure( + s.State.Terminated.Reason, message, info) + default: + return pluginsCore.PhaseInfoSuccess(info) + } + + logger.Warnf(ctx, "Primary container terminated with issue. Message: '%s'", message) + return phaseInfo + } + } + } + + // If for some reason we can't find the primary container, always just return a permanent failure + return pluginsCore.PhaseInfoFailure(PrimaryContainerNotFound, + fmt.Sprintf("Primary container [%s] not found in pod's container statuses", primaryContainerName), info) +} + +// DemystifyFailure resolves the various Kubernetes pod failure modes to determine +// the most appropriate course of action +func DemystifyFailure(ctx context.Context, status v1.PodStatus, info pluginsCore.TaskInfo, primaryContainerName string) (pluginsCore.PhaseInfo, error) { + code := "UnknownError" + message := "Pod failed. No message received from kubernetes." + if len(status.Reason) > 0 { + code = status.Reason + } + + if len(status.Message) > 0 { + message = status.Message + } + + // + // Handle known pod statuses + // + // This is useful for handling node interruption events + // which can be different between providers and versions of Kubernetes. Given that + // we don't have a consistent way of detecting interruption events, we will be + // documenting all possibilities as follows. We will also be handling these as + // system retryable failures that do not count towards user-specified task retries, + // for now. This is required for FlytePropeller to correctly transition + // interruptible nodes to non-interruptible ones after the + // `interruptible-failure-threshold` is exceeded. See: + // https://github.com/flyteorg/flytepropeller/blob/a3c6e91f19c19601a957b29891437112868845de/pkg/controller/nodes/node_exec_context.go#L213 + + // GKE (>= v1.20) Kubelet graceful node shutdown + // See: https://cloud.google.com/kubernetes-engine/docs/how-to/preemptible-vms#graceful-shutdown + // Cloud audit log for patch of Pod object during graceful node shutdown: + // request: { + // @type: "k8s.io/Patch" + // status: { + // conditions: null + // message: "Pod Node is in progress of shutting down, not admitting any new pods" + // phase: "Failed" + // qosClass: null + // reason: "Shutdown" + // startTime: "2022-01-30T14:24:07Z" + // } + // } + // + + var isSystemError bool + // In some versions of GKE the reason can also be "Terminated" or "NodeShutdown" + if retryableStatusReasons.Has(code) { + isSystemError = true + } + + // + // Handle known container statuses + // + for _, c := range append( + append(status.InitContainerStatuses, status.ContainerStatuses...), status.EphemeralContainerStatuses...) { + var containerState v1.ContainerState + if c.LastTerminationState.Terminated != nil { + containerState = c.LastTerminationState + } else if c.State.Terminated != nil { + containerState = c.State + } + if containerState.Terminated != nil { + if strings.Contains(containerState.Terminated.Reason, OOMKilled) { + code = OOMKilled + } else if isTerminatedWithSigKill(containerState) { + // in some setups, node termination sends SIGKILL to all the containers running on that node. Capturing and + // tagging that correctly. + code = Interrupted + // If the primary container exited with SIGKILL, we treat it as a system-level error + // (such as node termination or preemption). This best-effort approach accepts some false positives. + // In the case that node preemption terminates the kubelet *before* the kubelet is able to persist + // the pod's state to the Kubernetes API server, we rely on Kubernetes to eventually resolve + // the state. This will enable Propeller to eventually query the API server and determine that + // the pod no longer exists, which will then be counted as a system error. + if c.Name == primaryContainerName { + isSystemError = true + } + } + + if containerState.Terminated.ExitCode == 0 { + message += fmt.Sprintf("\r\n[%v] terminated with ExitCode 0.", c.Name) + } else { + message += fmt.Sprintf("\r\n[%v] terminated with exit code (%v). Reason [%v]. Message: \n%v.", + c.Name, + containerState.Terminated.ExitCode, + containerState.Terminated.Reason, + containerState.Terminated.Message) + } + } + } + + // If the code remains 'UnknownError', it indicates that the kubelet did not have a chance + // to record a more specific failure before the node was terminated or preempted. + // In such cases, we classify the error as system-level and accept false positives + if code == "UnknownError" { + isSystemError = true + } + + if isSystemError { + logger.Warnf(ctx, "Pod failed with a system error. Code: %s, Message: %s", code, message) + return pluginsCore.PhaseInfoSystemRetryableFailure(Interrupted, message, &info), nil + } + + logger.Warnf(ctx, "Pod failed with a user error. Code: %s, Message: %s", code, message) + return pluginsCore.PhaseInfoRetryableFailure(code, message, &info), nil +} + +func GetLastTransitionOccurredAt(pod *v1.Pod) metav1.Time { + var lastTransitionTime metav1.Time + containerStatuses := append(pod.Status.ContainerStatuses, pod.Status.InitContainerStatuses...) + for _, containerStatus := range containerStatuses { + if r := containerStatus.State.Running; r != nil { + if r.StartedAt.Unix() > lastTransitionTime.Unix() { + lastTransitionTime = r.StartedAt + } + } else if r := containerStatus.State.Terminated; r != nil { + if r.FinishedAt.Unix() > lastTransitionTime.Unix() { + lastTransitionTime = r.FinishedAt + } + } + } + + if lastTransitionTime.IsZero() { + lastTransitionTime = metav1.NewTime(time.Now()) + } + + return lastTransitionTime +} + +func GetReportedAt(pod *v1.Pod) metav1.Time { + var reportedAt metav1.Time + for _, condition := range pod.Status.Conditions { + if condition.Reason == "PodCompleted" && condition.Type == v1.PodReady && condition.Status == v1.ConditionFalse { + if condition.LastTransitionTime.Unix() > reportedAt.Unix() { + reportedAt = condition.LastTransitionTime + } + } + } + + return reportedAt +} + +func GetPrimaryContainerName(pod *v1.Pod) string { + defaultContainer := pod.Annotations["kubectl.kubernetes.io/default-container"] + if defaultContainer != "" { + return defaultContainer + } + primaryContainer := pod.Annotations[PrimaryContainerKey] + if primaryContainer != "" { + return primaryContainer + } + + for _, container := range pod.Spec.Containers { + if container.Name == pod.Name { + return container.Name + } + } + + // default to just 1st container name + if len(pod.Spec.Containers) > 0 { + return pod.Spec.Containers[0].Name + } + return "" +} + +func makeContainerContexts(statuses []v1.ContainerStatus) []*core.ContainerContext { + ctxs := make([]*core.ContainerContext, len(statuses)) + for i, status := range statuses { + var startTime, endTime *timestamppb.Timestamp + if status.State.Running != nil { + startTime = timestamppb.New(status.State.Running.StartedAt.Time) + } + if status.State.Terminated != nil { + startTime = timestamppb.New(status.State.Terminated.StartedAt.Time) + endTime = timestamppb.New(status.State.Terminated.FinishedAt.Time) + } + ctxs[i] = &core.ContainerContext{ + ContainerName: status.Name, + Process: &core.ContainerContext_ProcessContext{ + ContainerStartTime: startTime, + ContainerEndTime: endTime, + }, + } + } + return ctxs +} + +func BuildPodLogContext(pod *v1.Pod) *core.PodLogContext { + return &core.PodLogContext{ + Namespace: pod.Namespace, + PodName: pod.Name, + PrimaryContainerName: GetPrimaryContainerName(pod), + Containers: makeContainerContexts(pod.Status.ContainerStatuses), + InitContainers: makeContainerContexts(pod.Status.InitContainerStatuses), + } +} + +func isTerminatedWithSigKill(state v1.ContainerState) bool { + return state.Terminated != nil && (state.Terminated.ExitCode == SIGKILL || state.Terminated.ExitCode == unsignedSIGKILL) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/pod_helper_test.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/pod_helper_test.go new file mode 100644 index 0000000000..39fc9e0ff6 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/pod_helper_test.go @@ -0,0 +1,4102 @@ +package flytek8s + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "io/ioutil" + "path/filepath" + "reflect" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + pluginsCoreMock "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + pluginsIOMock "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io/mocks" + config1 "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/config/viper" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/flytestdlib/utils" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func dummyTaskExecutionMetadata(resources *v1.ResourceRequirements, extendedResources *core.ExtendedResources, containerImage string, podTemplate *core.K8SPod) pluginsCore.TaskExecutionMetadata { + taskExecutionMetadata := &pluginsCoreMock.TaskExecutionMetadata{} + taskExecutionMetadata.EXPECT().GetNamespace().Return("test-namespace") + taskExecutionMetadata.EXPECT().GetAnnotations().Return(map[string]string{"annotation-1": "val1"}) + taskExecutionMetadata.EXPECT().GetLabels().Return(map[string]string{"label-1": "val1"}) + taskExecutionMetadata.EXPECT().GetOwnerReference().Return(metav1.OwnerReference{ + Kind: "node", + Name: "blah", + }) + taskExecutionMetadata.EXPECT().GetK8sServiceAccount().Return("service-account") + tID := &pluginsCoreMock.TaskExecutionID{} + tID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my_name", + Project: "my_project", + Domain: "my_domain", + }, + }, + }) + tID.EXPECT().GetGeneratedName().Return("some-acceptable-name") + taskExecutionMetadata.EXPECT().GetTaskExecutionID().Return(tID) + + to := &pluginsCoreMock.TaskOverrides{} + to.EXPECT().GetResources().Return(resources) + to.EXPECT().GetExtendedResources().Return(extendedResources) + to.EXPECT().GetContainerImage().Return(containerImage) + to.EXPECT().GetPodTemplate().Return(podTemplate) + taskExecutionMetadata.EXPECT().GetOverrides().Return(to) + taskExecutionMetadata.EXPECT().IsInterruptible().Return(true) + taskExecutionMetadata.EXPECT().GetPlatformResources().Return(&v1.ResourceRequirements{}) + taskExecutionMetadata.EXPECT().GetEnvironmentVariables().Return(nil) + taskExecutionMetadata.EXPECT().GetConsoleURL().Return("") + return taskExecutionMetadata +} + +func dummyTaskTemplate() *core.TaskTemplate { + return &core.TaskTemplate{ + Type: "test", + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Command: []string{"command"}, + Args: []string{"{{.Input}}"}, + }, + }, + } +} + +func dummyInputReader() io.InputReader { + inputReader := &pluginsIOMock.InputReader{} + inputReader.EXPECT().GetInputPath().Return(storage.DataReference("test-data-reference")) + inputReader.EXPECT().GetInputPrefixPath().Return(storage.DataReference("test-data-reference-prefix")) + inputReader.EXPECT().Get(mock.Anything).Return(&core.LiteralMap{}, nil) + return inputReader +} + +func dummyExecContext(taskTemplate *core.TaskTemplate, r *v1.ResourceRequirements, rm *core.ExtendedResources, containerImage string, podTemplate *core.K8SPod) pluginsCore.TaskExecutionContext { + ow := &pluginsIOMock.OutputWriter{} + ow.EXPECT().GetOutputPrefixPath().Return("") + ow.EXPECT().GetRawOutputPrefix().Return("") + ow.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + ow.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + + tCtx := &pluginsCoreMock.TaskExecutionContext{} + tCtx.EXPECT().TaskExecutionMetadata().Return(dummyTaskExecutionMetadata(r, rm, containerImage, podTemplate)) + tCtx.EXPECT().InputReader().Return(dummyInputReader()) + tCtx.EXPECT().OutputWriter().Return(ow) + + taskReader := &pluginsCoreMock.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(taskTemplate, nil) + tCtx.EXPECT().TaskReader().Return(taskReader) + return tCtx +} + +func TestPodSetup(t *testing.T) { + configAccessor := viper.NewAccessor(config1.Options{ + StrictMode: true, + SearchPaths: []string{"testdata/config.yaml"}, + }) + err := configAccessor.UpdateConfig(context.TODO()) + assert.NoError(t, err) + + t.Run("ApplyInterruptibleNodeAffinity", TestApplyInterruptibleNodeAffinity) + t.Run("UpdatePod", updatePod) + t.Run("ToK8sPodInterruptible", toK8sPodInterruptible) +} + +func TestAddRequiredNodeSelectorRequirements(t *testing.T) { + t.Run("with empty node affinity", func(t *testing.T) { + affinity := v1.Affinity{} + nst := v1.NodeSelectorRequirement{ + Key: "new", + Operator: v1.NodeSelectorOpIn, + Values: []string{"new"}, + } + AddRequiredNodeSelectorRequirements(&affinity, nst) + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "new", + Operator: v1.NodeSelectorOpIn, + Values: []string{"new"}, + }, + }, + }, + }, + affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + }) + + t.Run("with existing node affinity", func(t *testing.T) { + affinity := v1.Affinity{ + NodeAffinity: &v1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &v1.NodeSelector{ + NodeSelectorTerms: []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "required", + Operator: v1.NodeSelectorOpIn, + Values: []string{"required"}, + }, + }, + }, + }, + }, + PreferredDuringSchedulingIgnoredDuringExecution: []v1.PreferredSchedulingTerm{ + v1.PreferredSchedulingTerm{ + Weight: 1, + Preference: v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "preferred", + Operator: v1.NodeSelectorOpIn, + Values: []string{"preferred"}, + }, + }, + }, + }, + }, + }, + } + nst := v1.NodeSelectorRequirement{ + Key: "new", + Operator: v1.NodeSelectorOpIn, + Values: []string{"new"}, + } + AddRequiredNodeSelectorRequirements(&affinity, nst) + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "required", + Operator: v1.NodeSelectorOpIn, + Values: []string{"required"}, + }, + v1.NodeSelectorRequirement{ + Key: "new", + Operator: v1.NodeSelectorOpIn, + Values: []string{"new"}, + }, + }, + }, + }, + affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + []v1.PreferredSchedulingTerm{ + v1.PreferredSchedulingTerm{ + Weight: 1, + Preference: v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "preferred", + Operator: v1.NodeSelectorOpIn, + Values: []string{"preferred"}, + }, + }, + }, + }, + }, + affinity.NodeAffinity.PreferredDuringSchedulingIgnoredDuringExecution, + ) + }) +} + +func TestAddPreferredNodeSelectorRequirements(t *testing.T) { + t.Run("with empty node affinity", func(t *testing.T) { + affinity := v1.Affinity{} + nst := v1.NodeSelectorRequirement{ + Key: "new", + Operator: v1.NodeSelectorOpIn, + Values: []string{"new"}, + } + AddPreferredNodeSelectorRequirements(&affinity, 10, nst) + assert.EqualValues( + t, + []v1.PreferredSchedulingTerm{ + v1.PreferredSchedulingTerm{ + Weight: 10, + Preference: v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "new", + Operator: v1.NodeSelectorOpIn, + Values: []string{"new"}, + }, + }, + }, + }, + }, + affinity.NodeAffinity.PreferredDuringSchedulingIgnoredDuringExecution, + ) + }) + + t.Run("with existing node affinity", func(t *testing.T) { + affinity := v1.Affinity{ + NodeAffinity: &v1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &v1.NodeSelector{ + NodeSelectorTerms: []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "required", + Operator: v1.NodeSelectorOpIn, + Values: []string{"required"}, + }, + }, + }, + }, + }, + PreferredDuringSchedulingIgnoredDuringExecution: []v1.PreferredSchedulingTerm{ + v1.PreferredSchedulingTerm{ + Weight: 1, + Preference: v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "preferred", + Operator: v1.NodeSelectorOpIn, + Values: []string{"preferred"}, + }, + }, + }, + }, + }, + }, + } + nst := v1.NodeSelectorRequirement{ + Key: "new", + Operator: v1.NodeSelectorOpIn, + Values: []string{"new"}, + } + AddPreferredNodeSelectorRequirements(&affinity, 10, nst) + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "required", + Operator: v1.NodeSelectorOpIn, + Values: []string{"required"}, + }, + }, + }, + }, + affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + []v1.PreferredSchedulingTerm{ + v1.PreferredSchedulingTerm{ + Weight: 1, + Preference: v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "preferred", + Operator: v1.NodeSelectorOpIn, + Values: []string{"preferred"}, + }, + }, + }, + }, + v1.PreferredSchedulingTerm{ + Weight: 10, + Preference: v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "new", + Operator: v1.NodeSelectorOpIn, + Values: []string{"new"}, + }, + }, + }, + }, + }, + affinity.NodeAffinity.PreferredDuringSchedulingIgnoredDuringExecution, + ) + }) +} + +func TestApplyInterruptibleNodeAffinity(t *testing.T) { + t.Run("WithInterruptibleNodeSelectorRequirement", func(t *testing.T) { + podSpec := v1.PodSpec{} + ApplyInterruptibleNodeAffinity(true, &podSpec) + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "x/interruptible", + Operator: v1.NodeSelectorOpIn, + Values: []string{"true"}, + }, + }, + }, + }, + podSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + }) + + t.Run("WithNonInterruptibleNodeSelectorRequirement", func(t *testing.T) { + podSpec := v1.PodSpec{} + ApplyInterruptibleNodeAffinity(false, &podSpec) + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "x/interruptible", + Operator: v1.NodeSelectorOpDoesNotExist, + }, + }, + }, + }, + podSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + }) + + t.Run("WithExistingAffinityWithInterruptibleNodeSelectorRequirement", func(t *testing.T) { + podSpec := v1.PodSpec{ + Affinity: &v1.Affinity{ + NodeAffinity: &v1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &v1.NodeSelector{ + NodeSelectorTerms: []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "node selector requirement", + Operator: v1.NodeSelectorOpIn, + Values: []string{"exists"}, + }, + }, + }, + }, + }, + }, + }, + } + ApplyInterruptibleNodeAffinity(true, &podSpec) + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "node selector requirement", + Operator: v1.NodeSelectorOpIn, + Values: []string{"exists"}, + }, + v1.NodeSelectorRequirement{ + Key: "x/interruptible", + Operator: v1.NodeSelectorOpIn, + Values: []string{"true"}, + }, + }, + }, + }, + podSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + }) +} + +func TestApplyExtendedResourcesOverrides(t *testing.T) { + t4 := &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-t4", + }, + } + partitionedA100 := &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-a100", + PartitionSizeValue: &core.GPUAccelerator_PartitionSize{ + PartitionSize: "1g.5gb", + }, + }, + } + unpartitionedA100 := &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-a100", + PartitionSizeValue: &core.GPUAccelerator_Unpartitioned{ + Unpartitioned: true, + }, + }, + } + + t.Run("base and overrides are nil", func(t *testing.T) { + final := ApplyExtendedResourcesOverrides(nil, nil) + assert.NotNil(t, final) + }) + + t.Run("base is nil", func(t *testing.T) { + final := ApplyExtendedResourcesOverrides(nil, t4) + assert.EqualValues( + t, + t4.GetGpuAccelerator(), + final.GetGpuAccelerator(), + ) + }) + + t.Run("overrides is nil", func(t *testing.T) { + final := ApplyExtendedResourcesOverrides(t4, nil) + assert.EqualValues( + t, + t4.GetGpuAccelerator(), + final.GetGpuAccelerator(), + ) + }) + + t.Run("merging", func(t *testing.T) { + final := ApplyExtendedResourcesOverrides(partitionedA100, unpartitionedA100) + assert.EqualValues( + t, + unpartitionedA100.GetGpuAccelerator(), + final.GetGpuAccelerator(), + ) + }) +} + +func TestApplyGPUNodeSelectors(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "nvidia.com/gpu", + GpuDeviceNodeLabel: "gpu-device", + GpuPartitionSizeNodeLabel: "gpu-partition-size", + })) + + basePodSpec := &v1.PodSpec{ + Containers: []v1.Container{ + { + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "nvidia.com/gpu": resource.MustParse("1"), + }, + }, + }, + }, + } + + t.Run("without gpu resource", func(t *testing.T) { + podSpec := &v1.PodSpec{} + ApplyGPUNodeSelectors( + podSpec, + &core.GPUAccelerator{Device: "nvidia-tesla-a100"}, + ) + assert.Nil(t, podSpec.Affinity) + }) + + t.Run("with gpu device spec only", func(t *testing.T) { + podSpec := basePodSpec.DeepCopy() + ApplyGPUNodeSelectors( + podSpec, + &core.GPUAccelerator{Device: "nvidia-tesla-a100"}, + ) + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "gpu-device", + Operator: v1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-a100"}, + }, + }, + }, + }, + podSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + []v1.Toleration{ + { + Key: "gpu-device", + Value: "nvidia-tesla-a100", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + }, + podSpec.Tolerations, + ) + }) + + t.Run("with gpu device and partition size spec", func(t *testing.T) { + podSpec := basePodSpec.DeepCopy() + ApplyGPUNodeSelectors( + podSpec, + &core.GPUAccelerator{ + Device: "nvidia-tesla-a100", + PartitionSizeValue: &core.GPUAccelerator_PartitionSize{ + PartitionSize: "1g.5gb", + }, + }, + ) + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "gpu-device", + Operator: v1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-a100"}, + }, + v1.NodeSelectorRequirement{ + Key: "gpu-partition-size", + Operator: v1.NodeSelectorOpIn, + Values: []string{"1g.5gb"}, + }, + }, + }, + }, + podSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + []v1.Toleration{ + { + Key: "gpu-device", + Value: "nvidia-tesla-a100", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + { + Key: "gpu-partition-size", + Value: "1g.5gb", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + }, + podSpec.Tolerations, + ) + }) + + t.Run("with unpartitioned gpu device spec", func(t *testing.T) { + podSpec := basePodSpec.DeepCopy() + ApplyGPUNodeSelectors( + podSpec, + &core.GPUAccelerator{ + Device: "nvidia-tesla-a100", + PartitionSizeValue: &core.GPUAccelerator_Unpartitioned{ + Unpartitioned: true, + }, + }, + ) + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "gpu-device", + Operator: v1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-a100"}, + }, + v1.NodeSelectorRequirement{ + Key: "gpu-partition-size", + Operator: v1.NodeSelectorOpDoesNotExist, + }, + }, + }, + }, + podSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + []v1.Toleration{ + { + Key: "gpu-device", + Value: "nvidia-tesla-a100", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + }, + podSpec.Tolerations, + ) + }) + + t.Run("with unpartitioned gpu device spec with custom node selector and toleration", func(t *testing.T) { + gpuUnpartitionedNodeSelectorRequirement := v1.NodeSelectorRequirement{ + Key: "gpu-unpartitioned", + Operator: v1.NodeSelectorOpIn, + Values: []string{"true"}, + } + gpuUnpartitionedToleration := v1.Toleration{ + Key: "gpu-unpartitioned", + Value: "true", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + } + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "nvidia.com/gpu", + GpuDeviceNodeLabel: "gpu-device", + GpuPartitionSizeNodeLabel: "gpu-partition-size", + GpuUnpartitionedNodeSelectorRequirement: &gpuUnpartitionedNodeSelectorRequirement, + GpuUnpartitionedToleration: &gpuUnpartitionedToleration, + })) + + podSpec := basePodSpec.DeepCopy() + ApplyGPUNodeSelectors( + podSpec, + &core.GPUAccelerator{ + Device: "nvidia-tesla-a100", + PartitionSizeValue: &core.GPUAccelerator_Unpartitioned{ + Unpartitioned: true, + }, + }, + ) + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "gpu-device", + Operator: v1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-a100"}, + }, + gpuUnpartitionedNodeSelectorRequirement, + }, + }, + }, + podSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + []v1.Toleration{ + { + Key: "gpu-device", + Value: "nvidia-tesla-a100", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + gpuUnpartitionedToleration, + }, + podSpec.Tolerations, + ) + }) + + t.Run("with friendly device name normalization - NVIDIA H100", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "nvidia.com/gpu", + GpuDeviceNodeLabel: "gpu-device", + GpuPartitionSizeNodeLabel: "gpu-partition-size", + AcceleratorDevices: map[string]string{ + "H100": "nvidia-h100", + "A100": "nvidia-tesla-a100", + }, + })) + + podSpec := basePodSpec.DeepCopy() + ApplyGPUNodeSelectors( + podSpec, + &core.GPUAccelerator{Device: "H100"}, // Friendly name + ) + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "gpu-device", + Operator: v1.NodeSelectorOpIn, + Values: []string{"nvidia-h100"}, // Normalized name + }, + }, + }, + }, + podSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + []v1.Toleration{ + { + Key: "gpu-device", + Value: "nvidia-h100", // Normalized name + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + }, + podSpec.Tolerations, + ) + }) + + t.Run("with friendly device name normalization - case insensitive", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "nvidia.com/gpu", + GpuDeviceNodeLabel: "gpu-device", + GpuPartitionSizeNodeLabel: "gpu-partition-size", + AcceleratorDevices: map[string]string{ + "H100": "nvidia-h100", + }, + })) + + podSpec := basePodSpec.DeepCopy() + ApplyGPUNodeSelectors( + podSpec, + &core.GPUAccelerator{Device: "h100"}, // Lowercase friendly name + ) + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "gpu-device", + Operator: v1.NodeSelectorOpIn, + Values: []string{"nvidia-h100"}, // Still normalized correctly + }, + }, + }, + }, + podSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + }) + + t.Run("with friendly device name normalization - Google TPU", func(t *testing.T) { + // Configure for TPU usage + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "google.com/tpu", + GpuDeviceNodeLabel: "tpu-device", + GpuPartitionSizeNodeLabel: "tpu-partition-size", + AcceleratorDevices: map[string]string{ + "V5E": "tpu-v5-lite-podslice", + "V5P": "tpu-v5p-slice", + }, + })) + + tpuPodSpec := &v1.PodSpec{ + Containers: []v1.Container{ + { + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "google.com/tpu": resource.MustParse("4"), + }, + }, + }, + }, + } + + ApplyGPUNodeSelectors( + tpuPodSpec, + &core.GPUAccelerator{Device: "V5E"}, // Friendly name for TPU + ) + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "tpu-device", + Operator: v1.NodeSelectorOpIn, + Values: []string{"tpu-v5-lite-podslice"}, // Normalized TPU name + }, + }, + }, + }, + tpuPodSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + }) + + t.Run("with unmapped device uses device name as-is", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "nvidia.com/gpu", + GpuDeviceNodeLabel: "gpu-device", + GpuPartitionSizeNodeLabel: "gpu-partition-size", + AcceleratorDevices: map[string]string{}, // Empty mapping + })) + + podSpec := basePodSpec.DeepCopy() + ApplyGPUNodeSelectors( + podSpec, + &core.GPUAccelerator{Device: "custom-gpu-device"}, + ) + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "gpu-device", + Operator: v1.NodeSelectorOpIn, + Values: []string{"custom-gpu-device"}, // Used as-is since not in mapping + }, + }, + }, + }, + podSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + }) +} + +func TestApplyGPUNodeSelectors_DeviceClassOverrides(t *testing.T) { + // Test device class specific configuration overrides + + t.Run("Google TPU with device class specific config", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "nvidia.com/gpu", + GpuDeviceNodeLabel: "k8s.amazonaws.com/accelerator", + GpuPartitionSizeNodeLabel: "k8s.amazonaws.com/gpu-partition-size", + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "GOOGLE_TPU": { + ResourceName: "google.com/tpu", + DeviceNodeLabel: "cloud.google.com/gke-tpu-accelerator", + PartitionSizeNodeLabel: "cloud.google.com/gke-tpu-topology", + }, + }, + AcceleratorDevices: map[string]string{ + "V5E": "tpu-v5-lite-podslice", + }, + })) + + tpuPodSpec := &v1.PodSpec{ + Containers: []v1.Container{ + { + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "google.com/tpu": resource.MustParse("4"), + }, + }, + }, + }, + } + + ApplyGPUNodeSelectors( + tpuPodSpec, + &core.GPUAccelerator{ + Device: "V5E", + DeviceClass: core.GPUAccelerator_GOOGLE_TPU, + }, + ) + + // Verify it uses Google-specific node labels instead of AWS labels + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + { + MatchExpressions: []v1.NodeSelectorRequirement{ + { + Key: "cloud.google.com/gke-tpu-accelerator", + Operator: v1.NodeSelectorOpIn, + Values: []string{"tpu-v5-lite-podslice"}, + }, + }, + }, + }, + tpuPodSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + []v1.Toleration{ + { + Key: "cloud.google.com/gke-tpu-accelerator", + Value: "tpu-v5-lite-podslice", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + }, + tpuPodSpec.Tolerations, + ) + }) + + t.Run("NVIDIA GPU fallback to global config", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "nvidia.com/gpu", + GpuDeviceNodeLabel: "k8s.amazonaws.com/accelerator", + GpuPartitionSizeNodeLabel: "k8s.amazonaws.com/gpu-partition-size", + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "NVIDIA_GPU": { + ResourceName: "nvidia.com/gpu", + // DeviceNodeLabel not specified - should fallback to global + }, + }, + AcceleratorDevices: map[string]string{ + "A100": "nvidia-tesla-a100", + }, + })) + + podSpec := &v1.PodSpec{ + Containers: []v1.Container{ + { + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "nvidia.com/gpu": resource.MustParse("1"), + }, + }, + }, + }, + } + + ApplyGPUNodeSelectors( + podSpec, + &core.GPUAccelerator{ + Device: "A100", + DeviceClass: core.GPUAccelerator_NVIDIA_GPU, + }, + ) + + // Verify it falls back to global GpuDeviceNodeLabel + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + { + MatchExpressions: []v1.NodeSelectorRequirement{ + { + Key: "k8s.amazonaws.com/accelerator", + Operator: v1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-a100"}, + }, + }, + }, + }, + podSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + }) + + t.Run("TPU with partition size", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "nvidia.com/gpu", + GpuDeviceNodeLabel: "k8s.amazonaws.com/accelerator", + GpuPartitionSizeNodeLabel: "k8s.amazonaws.com/gpu-partition-size", + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "GOOGLE_TPU": { + ResourceName: "google.com/tpu", + DeviceNodeLabel: "cloud.google.com/gke-tpu-accelerator", + PartitionSizeNodeLabel: "cloud.google.com/gke-tpu-topology", + }, + }, + AcceleratorDevices: map[string]string{ + "V5P": "tpu-v5p-slice", + }, + })) + + tpuPodSpec := &v1.PodSpec{ + Containers: []v1.Container{ + { + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "google.com/tpu": resource.MustParse("8"), + }, + }, + }, + }, + } + + ApplyGPUNodeSelectors( + tpuPodSpec, + &core.GPUAccelerator{ + Device: "V5P", + DeviceClass: core.GPUAccelerator_GOOGLE_TPU, + PartitionSizeValue: &core.GPUAccelerator_PartitionSize{ + PartitionSize: "2x2x2", + }, + }, + ) + + // Verify it uses Google-specific topology label + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + { + MatchExpressions: []v1.NodeSelectorRequirement{ + { + Key: "cloud.google.com/gke-tpu-accelerator", + Operator: v1.NodeSelectorOpIn, + Values: []string{"tpu-v5p-slice"}, + }, + { + Key: "cloud.google.com/gke-tpu-topology", + Operator: v1.NodeSelectorOpIn, + Values: []string{"2x2x2"}, + }, + }, + }, + }, + tpuPodSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + []v1.Toleration{ + { + Key: "cloud.google.com/gke-tpu-accelerator", + Value: "tpu-v5p-slice", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + { + Key: "cloud.google.com/gke-tpu-topology", + Value: "2x2x2", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + }, + tpuPodSpec.Tolerations, + ) + }) + + t.Run("NVIDIA GPU unpartitioned with custom node selector and toleration", func(t *testing.T) { + gpuUnpartitionedNodeSelectorRequirement := v1.NodeSelectorRequirement{ + Key: "gpu-unpartitioned", + Operator: v1.NodeSelectorOpIn, + Values: []string{"true"}, + } + gpuUnpartitionedToleration := v1.Toleration{ + Key: "gpu-unpartitioned", + Value: "true", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + } + + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "nvidia.com/gpu", + GpuDeviceNodeLabel: "k8s.amazonaws.com/accelerator", + GpuPartitionSizeNodeLabel: "k8s.amazonaws.com/gpu-partition-size", + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "NVIDIA_GPU": { + ResourceName: "nvidia.com/gpu", + DeviceNodeLabel: "k8s.amazonaws.com/accelerator", + PartitionSizeNodeLabel: "k8s.amazonaws.com/gpu-partition-size", + UnpartitionedNodeSelectorRequirement: &gpuUnpartitionedNodeSelectorRequirement, + UnpartitionedToleration: &gpuUnpartitionedToleration, + }, + }, + AcceleratorDevices: map[string]string{ + "A100": "nvidia-tesla-a100", + }, + })) + + podSpec := &v1.PodSpec{ + Containers: []v1.Container{ + { + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "nvidia.com/gpu": resource.MustParse("1"), + }, + }, + }, + }, + } + + ApplyGPUNodeSelectors( + podSpec, + &core.GPUAccelerator{ + Device: "A100", + DeviceClass: core.GPUAccelerator_NVIDIA_GPU, + PartitionSizeValue: &core.GPUAccelerator_Unpartitioned{ + Unpartitioned: true, + }, + }, + ) + + // Verify it uses device-class-specific unpartitioned config + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + { + MatchExpressions: []v1.NodeSelectorRequirement{ + { + Key: "k8s.amazonaws.com/accelerator", + Operator: v1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-a100"}, + }, + gpuUnpartitionedNodeSelectorRequirement, + }, + }, + }, + podSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + []v1.Toleration{ + { + Key: "k8s.amazonaws.com/accelerator", + Value: "nvidia-tesla-a100", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + gpuUnpartitionedToleration, + }, + podSpec.Tolerations, + ) + }) + + t.Run("NVIDIA GPU unpartitioned with fallback to default behavior", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "nvidia.com/gpu", + GpuDeviceNodeLabel: "k8s.amazonaws.com/accelerator", + GpuPartitionSizeNodeLabel: "k8s.amazonaws.com/gpu-partition-size", + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "NVIDIA_GPU": { + ResourceName: "nvidia.com/gpu", + DeviceNodeLabel: "k8s.amazonaws.com/accelerator", + PartitionSizeNodeLabel: "k8s.amazonaws.com/gpu-partition-size", + // No unpartitioned config - should use default DoesNotExist behavior + }, + }, + AcceleratorDevices: map[string]string{ + "A100": "nvidia-tesla-a100", + }, + })) + + podSpec := &v1.PodSpec{ + Containers: []v1.Container{ + { + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "nvidia.com/gpu": resource.MustParse("1"), + }, + }, + }, + }, + } + + ApplyGPUNodeSelectors( + podSpec, + &core.GPUAccelerator{ + Device: "A100", + DeviceClass: core.GPUAccelerator_NVIDIA_GPU, + PartitionSizeValue: &core.GPUAccelerator_Unpartitioned{ + Unpartitioned: true, + }, + }, + ) + + // Verify it uses default DoesNotExist behavior with GPU partition size label + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + { + MatchExpressions: []v1.NodeSelectorRequirement{ + { + Key: "k8s.amazonaws.com/accelerator", + Operator: v1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-a100"}, + }, + { + Key: "k8s.amazonaws.com/gpu-partition-size", + Operator: v1.NodeSelectorOpDoesNotExist, + }, + }, + }, + }, + podSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + }) + + t.Run("Partial device class config merges with global defaults", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "nvidia.com/gpu", + GpuDeviceNodeLabel: "k8s.amazonaws.com/accelerator", + GpuPartitionSizeNodeLabel: "k8s.amazonaws.com/gpu-partition-size", + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "NVIDIA_GPU": { + ResourceName: "nvidia.com/gpu", + DeviceNodeLabel: "nvidia.com/gpu.present", + // PartitionSizeNodeLabel not specified - should fall back to global + }, + }, + AcceleratorDevices: map[string]string{ + "A100": "nvidia-tesla-a100", + }, + })) + + podSpec := &v1.PodSpec{ + Containers: []v1.Container{ + { + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "nvidia.com/gpu": resource.MustParse("1"), + }, + }, + }, + }, + } + + ApplyGPUNodeSelectors( + podSpec, + &core.GPUAccelerator{ + Device: "A100", + DeviceClass: core.GPUAccelerator_NVIDIA_GPU, + PartitionSizeValue: &core.GPUAccelerator_PartitionSize{ + PartitionSize: "1g.5gb", + }, + }, + ) + + // Verify it uses NVIDIA-specific device label but falls back to global partition label + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + { + MatchExpressions: []v1.NodeSelectorRequirement{ + { + Key: "nvidia.com/gpu.present", + Operator: v1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-a100"}, + }, + { + // Falls back to global partition size label + Key: "k8s.amazonaws.com/gpu-partition-size", + Operator: v1.NodeSelectorOpIn, + Values: []string{"1g.5gb"}, + }, + }, + }, + }, + podSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + []v1.Toleration{ + { + Key: "nvidia.com/gpu.present", + Value: "nvidia-tesla-a100", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + { + Key: "k8s.amazonaws.com/gpu-partition-size", + Value: "1g.5gb", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + }, + podSpec.Tolerations, + ) + }) +} + +func TestApplyAcceleratorDeviceClassPodTemplate(t *testing.T) { + ctx := context.Background() + + t.Run("nil handling", func(t *testing.T) { + // Sub-test: Nil extendedResources returns immediately + t.Run("nil extendedResources", func(t *testing.T) { + podSpec := &v1.PodSpec{SchedulerName: "original"} + podSpec, err := applyAcceleratorDeviceClassPodTemplate( + ctx, + podSpec, + nil, // nil extendedResources + "primary", + "primary-init", + ) + assert.NoError(t, err) + assert.Equal(t, "original", podSpec.SchedulerName) + }) + + // Sub-test: Nil accelerator returns immediately + t.Run("nil accelerator", func(t *testing.T) { + podSpec := &v1.PodSpec{SchedulerName: "original"} + podSpec, err := applyAcceleratorDeviceClassPodTemplate( + ctx, + podSpec, + &core.ExtendedResources{}, + "primary", + "primary-init", + ) + assert.NoError(t, err) + assert.Equal(t, "original", podSpec.SchedulerName) + }) + + // Sub-test: Nil PodTemplate does nothing + t.Run("nil PodTemplate", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "NVIDIA_GPU": { + ResourceName: "nvidia.com/gpu", + // PodTemplate: nil + }, + }, + })) + + podSpec := &v1.PodSpec{SchedulerName: "original"} + podSpec, err := applyAcceleratorDeviceClassPodTemplate( + ctx, + podSpec, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + DeviceClass: core.GPUAccelerator_NVIDIA_GPU, + }, + }, + "primary", + "primary-init", + ) + assert.NoError(t, err) + assert.Equal(t, "original", podSpec.SchedulerName) + }) + }) + + t.Run("scalar field merge behavior", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "NVIDIA_GPU": { + ResourceName: "nvidia.com/gpu", + PodTemplate: &v1.PodTemplate{ + Template: v1.PodTemplateSpec{ + Spec: v1.PodSpec{ + SchedulerName: "volcano", // Device class default + }, + }, + }, + }, + }, + })) + + // Sub-test: Task value overrides device class default + t.Run("task overrides device class", func(t *testing.T) { + podSpec := &v1.PodSpec{SchedulerName: "default-scheduler"} // Task-specific value + podSpec, err := applyAcceleratorDeviceClassPodTemplate( + ctx, + podSpec, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + DeviceClass: core.GPUAccelerator_NVIDIA_GPU, + }, + }, + "primary", + "primary-init", + ) + assert.NoError(t, err) + // Task value should win (BASE semantics) + assert.Equal(t, "default-scheduler", podSpec.SchedulerName) + }) + + // Sub-test: Device class default applies when task doesn't set value + t.Run("device class applies when task unset", func(t *testing.T) { + podSpec := &v1.PodSpec{} // Task doesn't set schedulerName + podSpec, err := applyAcceleratorDeviceClassPodTemplate( + ctx, + podSpec, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + DeviceClass: core.GPUAccelerator_NVIDIA_GPU, + }, + }, + "primary", + "primary-init", + ) + assert.NoError(t, err) + // Device class default should apply + assert.Equal(t, "volcano", podSpec.SchedulerName) + }) + }) + + t.Run("merge semantics validation", func(t *testing.T) { + // Single comprehensive test validating slice append and map merge behaviors + overrideToleration := v1.Toleration{ + Key: "tpu-topology", + Operator: v1.TolerationOpExists, + Effect: v1.TaintEffectNoSchedule, + } + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "GOOGLE_TPU": { + ResourceName: "google.com/tpu", + PodTemplate: &v1.PodTemplate{ + Template: v1.PodTemplateSpec{ + Spec: v1.PodSpec{ + Tolerations: []v1.Toleration{overrideToleration}, + NodeSelector: map[string]string{ + "new-key": "new-value", + "existing-key": "default-value", + }, + }, + }, + }, + }, + }, + })) + + existingToleration := v1.Toleration{ + Key: "interruptible", + Value: "true", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + } + podSpec := &v1.PodSpec{ + Tolerations: []v1.Toleration{existingToleration}, + NodeSelector: map[string]string{ + "existing-key": "task-value", + "keep-key": "keep-value", + }, + } + + podSpec, err := applyAcceleratorDeviceClassPodTemplate( + ctx, + podSpec, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + DeviceClass: core.GPUAccelerator_GOOGLE_TPU, + }, + }, + "primary", + "primary-init", + ) + assert.NoError(t, err) + + // Validate slice append: tolerations from both device class and task + assert.Len(t, podSpec.Tolerations, 2) + assert.Contains(t, podSpec.Tolerations, existingToleration) + assert.Contains(t, podSpec.Tolerations, overrideToleration) + + // Validate map merge: task values win for conflicts, device class adds new keys + assert.Len(t, podSpec.NodeSelector, 3) + assert.Equal(t, "task-value", podSpec.NodeSelector["existing-key"]) // Task wins + assert.Equal(t, "keep-value", podSpec.NodeSelector["keep-key"]) // Task only + assert.Equal(t, "new-value", podSpec.NodeSelector["new-key"]) // Device class adds + }) + + t.Run("default container template affects all containers", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "NVIDIA_GPU": { + ResourceName: "nvidia.com/gpu", + PodTemplate: &v1.PodTemplate{ + Template: v1.PodTemplateSpec{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "default", + Env: []v1.EnvVar{ + {Name: "NVIDIA_VISIBLE_DEVICES", Value: "all"}, + {Name: "NCCL_DEBUG", Value: "INFO"}, + }, + }, + }, + }, + }, + }, + }, + }, + })) + + podSpec := &v1.PodSpec{ + Containers: []v1.Container{ + {Name: "main", Image: "app:1.0"}, + {Name: "sidecar", Image: "monitor:1.0"}, + }, + } + + podSpec, err := applyAcceleratorDeviceClassPodTemplate( + ctx, + podSpec, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + DeviceClass: core.GPUAccelerator_NVIDIA_GPU, + }, + }, + "main", + "main-init", + ) + assert.NoError(t, err) + + // Both containers should have the env vars from the default template + assert.Len(t, podSpec.Containers, 2) + for i, container := range podSpec.Containers { + assert.Contains(t, container.Env, v1.EnvVar{Name: "NVIDIA_VISIBLE_DEVICES", Value: "all"}, + "Container %d (%s) missing env var", i, container.Name) + assert.Contains(t, container.Env, v1.EnvVar{Name: "NCCL_DEBUG", Value: "INFO"}, + "Container %d (%s) missing env var", i, container.Name) + } + }) + + t.Run("primary container template affects only primary container", func(t *testing.T) { + gpuLimit := resource.MustParse("8") + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "NVIDIA_GPU": { + ResourceName: "nvidia.com/gpu", + PodTemplate: &v1.PodTemplate{ + Template: v1.PodTemplateSpec{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "primary", + Env: []v1.EnvVar{ + {Name: "CUDA_VISIBLE_DEVICES", Value: "all"}, + }, + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceName("nvidia.com/gpu"): gpuLimit, + }, + }, + }, + }, + }, + }, + }, + }, + }, + })) + + podSpec := &v1.PodSpec{ + Containers: []v1.Container{ + {Name: "workload", Image: "gpu-app:1.0"}, + {Name: "metrics", Image: "prometheus:1.0"}, + }, + } + + podSpec, err := applyAcceleratorDeviceClassPodTemplate( + ctx, + podSpec, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + DeviceClass: core.GPUAccelerator_NVIDIA_GPU, + }, + }, + "workload", + "workload-init", + ) + assert.NoError(t, err) + + // Primary container should have the template applied + assert.Contains(t, podSpec.Containers[0].Env, v1.EnvVar{Name: "CUDA_VISIBLE_DEVICES", Value: "all"}) + gpuResource := podSpec.Containers[0].Resources.Limits[v1.ResourceName("nvidia.com/gpu")] + assert.Equal(t, "8", gpuResource.String()) + + // Sidecar should NOT have the template + assert.NotContains(t, podSpec.Containers[1].Env, v1.EnvVar{Name: "CUDA_VISIBLE_DEVICES", Value: "all"}) + assert.Empty(t, podSpec.Containers[1].Resources.Limits) + }) + + t.Run("both default and primary templates merge correctly", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "GOOGLE_TPU": { + ResourceName: "google.com/tpu", + PodTemplate: &v1.PodTemplate{ + Template: v1.PodTemplateSpec{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "default", + Env: []v1.EnvVar{ + {Name: "BASE_VAR", Value: "from-default"}, + {Name: "SHARED_VAR", Value: "shared"}, + }, + ImagePullPolicy: v1.PullAlways, + }, + { + Name: "primary", + Env: []v1.EnvVar{ + {Name: "BASE_VAR", Value: "from-primary"}, + {Name: "PRIMARY_ONLY", Value: "primary-value"}, + }, + }, + }, + }, + }, + }, + }, + }, + })) + + podSpec := &v1.PodSpec{ + Containers: []v1.Container{ + {Name: "trainer", Image: "tpu-trainer:1.0"}, + {Name: "logger", Image: "log-collector:1.0"}, + }, + } + + podSpec, err := applyAcceleratorDeviceClassPodTemplate( + ctx, + podSpec, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + DeviceClass: core.GPUAccelerator_GOOGLE_TPU, + }, + }, + "trainer", + "trainer-init", + ) + assert.NoError(t, err) + + // Primary container: primary template overrides default for BASE_VAR + primaryContainer := podSpec.Containers[0] + assert.Equal(t, v1.PullAlways, primaryContainer.ImagePullPolicy) // from default + assert.Contains(t, primaryContainer.Env, v1.EnvVar{Name: "BASE_VAR", Value: "from-primary"}) // primary wins + assert.Contains(t, primaryContainer.Env, v1.EnvVar{Name: "SHARED_VAR", Value: "shared"}) // from default + assert.Contains(t, primaryContainer.Env, v1.EnvVar{Name: "PRIMARY_ONLY", Value: "primary-value"}) // from primary + + // Non-primary container: only gets default template + sidecarContainer := podSpec.Containers[1] + assert.Equal(t, v1.PullAlways, sidecarContainer.ImagePullPolicy) + assert.Contains(t, sidecarContainer.Env, v1.EnvVar{Name: "BASE_VAR", Value: "from-default"}) + assert.Contains(t, sidecarContainer.Env, v1.EnvVar{Name: "SHARED_VAR", Value: "shared"}) + assert.NotContains(t, sidecarContainer.Env, v1.EnvVar{Name: "PRIMARY_ONLY", Value: "primary-value"}) + }) +} + +func updatePod(t *testing.T) { + taskExecutionMetadata := dummyTaskExecutionMetadata(&v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1024m"), + v1.ResourceEphemeralStorage: resource.MustParse("100M"), + }, + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1024m"), + v1.ResourceEphemeralStorage: resource.MustParse("100M"), + }, + }, nil, "", nil) + + pod := &v1.Pod{ + Spec: v1.PodSpec{ + Tolerations: []v1.Toleration{ + { + Key: "my toleration key", + Value: "my toleration value", + }, + }, + NodeSelector: map[string]string{ + "user": "also configured", + }, + }, + } + UpdatePod(taskExecutionMetadata, []v1.ResourceRequirements{}, &pod.Spec) + assert.Equal(t, v1.RestartPolicyNever, pod.Spec.RestartPolicy) + for _, tol := range pod.Spec.Tolerations { + if tol.Key == "x/flyte" { + assert.Equal(t, tol.Value, "interruptible") + assert.Equal(t, tol.Operator, v1.TolerationOperator("Equal")) + assert.Equal(t, tol.Effect, v1.TaintEffect("NoSchedule")) + } else if tol.Key == "my toleration key" { + assert.Equal(t, tol.Value, "my toleration value") + } else { + t.Fatalf("unexpected toleration [%+v]", tol) + } + } + assert.Equal(t, "service-account", pod.Spec.ServiceAccountName) + assert.Equal(t, "flyte-scheduler", pod.Spec.SchedulerName) + assert.Len(t, pod.Spec.Tolerations, 2) + assert.EqualValues(t, map[string]string{ + "x/interruptible": "true", + "user": "also configured", + }, pod.Spec.NodeSelector) + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "x/interruptible", + Operator: v1.NodeSelectorOpIn, + Values: []string{"true"}, + }, + }, + }, + }, + pod.Spec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) +} + +func TestUpdatePodWithDefaultAffinityAndInterruptibleNodeSelectorRequirement(t *testing.T) { + taskExecutionMetadata := dummyTaskExecutionMetadata(&v1.ResourceRequirements{}, nil, "", nil) + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + DefaultAffinity: &v1.Affinity{ + NodeAffinity: &v1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &v1.NodeSelector{ + NodeSelectorTerms: []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "default node affinity", + Operator: v1.NodeSelectorOpIn, + Values: []string{"exists"}, + }, + }, + }, + }, + }, + }, + }, + InterruptibleNodeSelectorRequirement: &v1.NodeSelectorRequirement{ + Key: "x/interruptible", + Operator: v1.NodeSelectorOpIn, + Values: []string{"true"}, + }, + })) + for i := 0; i < 3; i++ { + podSpec := v1.PodSpec{} + UpdatePod(taskExecutionMetadata, []v1.ResourceRequirements{}, &podSpec) + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "default node affinity", + Operator: v1.NodeSelectorOpIn, + Values: []string{"exists"}, + }, + v1.NodeSelectorRequirement{ + Key: "x/interruptible", + Operator: v1.NodeSelectorOpIn, + Values: []string{"true"}, + }, + }, + }, + }, + podSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + } +} + +func toK8sPodInterruptible(t *testing.T) { + ctx := context.TODO() + + x := dummyExecContext(dummyTaskTemplate(), &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1024m"), + v1.ResourceEphemeralStorage: resource.MustParse("100M"), + ResourceNvidiaGPU: resource.MustParse("1"), + }, + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1024m"), + v1.ResourceEphemeralStorage: resource.MustParse("100M"), + }, + }, nil, "", nil) + + p, _, _, err := ToK8sPodSpec(ctx, x) + assert.NoError(t, err) + assert.Len(t, p.Tolerations, 2) + assert.Equal(t, "x/flyte", p.Tolerations[1].Key) + assert.Equal(t, "interruptible", p.Tolerations[1].Value) + assert.Equal(t, 2, len(p.NodeSelector)) + assert.Equal(t, "true", p.NodeSelector["x/interruptible"]) + assert.EqualValues( + t, + []v1.NodeSelectorTerm{ + v1.NodeSelectorTerm{ + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "x/interruptible", + Operator: v1.NodeSelectorOpIn, + Values: []string{"true"}, + }, + }, + }, + }, + p.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) +} + +func TestToK8sPod(t *testing.T) { + ctx := context.TODO() + + tolGPU := v1.Toleration{ + Key: "flyte/gpu", + Value: "dedicated", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + } + + tolEphemeralStorage := v1.Toleration{ + Key: "ephemeral-storage", + Value: "dedicated", + Operator: v1.TolerationOpExists, + Effect: v1.TaintEffectNoSchedule, + } + + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + ResourceTolerations: map[v1.ResourceName][]v1.Toleration{ + v1.ResourceEphemeralStorage: {tolEphemeralStorage}, + ResourceNvidiaGPU: {tolGPU}, + }, + DefaultCPURequest: resource.MustParse("1024m"), + DefaultMemoryRequest: resource.MustParse("1024Mi"), + })) + + op := &pluginsIOMock.OutputFilePaths{} + op.EXPECT().GetOutputPrefixPath().Return(storage.DataReference("")) + op.EXPECT().GetRawOutputPrefix().Return(storage.DataReference("")) + + t.Run("WithGPU", func(t *testing.T) { + x := dummyExecContext(dummyTaskTemplate(), &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1024m"), + v1.ResourceEphemeralStorage: resource.MustParse("100M"), + ResourceNvidiaGPU: resource.MustParse("1"), + }, + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1024m"), + v1.ResourceEphemeralStorage: resource.MustParse("100M"), + }, + }, nil, "", nil) + + p, _, _, err := ToK8sPodSpec(ctx, x) + assert.NoError(t, err) + assert.Equal(t, len(p.Tolerations), 2) + }) + + t.Run("NoGPU", func(t *testing.T) { + x := dummyExecContext(dummyTaskTemplate(), &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1024m"), + v1.ResourceEphemeralStorage: resource.MustParse("100M"), + }, + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1024m"), + v1.ResourceEphemeralStorage: resource.MustParse("100M"), + }, + }, nil, "", nil) + + p, _, _, err := ToK8sPodSpec(ctx, x) + assert.NoError(t, err) + assert.Equal(t, len(p.Tolerations), 1) + assert.Equal(t, "some-acceptable-name", p.Containers[0].Name) + }) + + t.Run("Default toleration, selector, scheduler", func(t *testing.T) { + x := dummyExecContext(dummyTaskTemplate(), &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1024m"), + v1.ResourceEphemeralStorage: resource.MustParse("100M"), + }, + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1024m"), + v1.ResourceEphemeralStorage: resource.MustParse("100M"), + }, + }, nil, "", nil) + + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + DefaultNodeSelector: map[string]string{ + "nodeId": "123", + }, + SchedulerName: "myScheduler", + DefaultCPURequest: resource.MustParse("1024m"), + DefaultMemoryRequest: resource.MustParse("1024Mi"), + })) + + p, _, _, err := ToK8sPodSpec(ctx, x) + assert.NoError(t, err) + assert.Equal(t, 1, len(p.NodeSelector)) + assert.Equal(t, "myScheduler", p.SchedulerName) + assert.Equal(t, "some-acceptable-name", p.Containers[0].Name) + assert.Nil(t, p.SecurityContext) + }) + + t.Run("default-pod-sec-ctx", func(t *testing.T) { + v := int64(1000) + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + DefaultPodSecurityContext: &v1.PodSecurityContext{ + RunAsGroup: &v, + }, + })) + + x := dummyExecContext(dummyTaskTemplate(), &v1.ResourceRequirements{}, nil, "", nil) + p, _, _, err := ToK8sPodSpec(ctx, x) + assert.NoError(t, err) + assert.NotNil(t, p.SecurityContext) + assert.Equal(t, *p.SecurityContext.RunAsGroup, v) + }) + + t.Run("enableHostNetwork", func(t *testing.T) { + enabled := true + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + EnableHostNetworkingPod: &enabled, + })) + x := dummyExecContext(dummyTaskTemplate(), &v1.ResourceRequirements{}, nil, "", nil) + p, _, _, err := ToK8sPodSpec(ctx, x) + assert.NoError(t, err) + assert.True(t, p.HostNetwork) + }) + + t.Run("explicitDisableHostNetwork", func(t *testing.T) { + enabled := false + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + EnableHostNetworkingPod: &enabled, + })) + x := dummyExecContext(dummyTaskTemplate(), &v1.ResourceRequirements{}, nil, "", nil) + p, _, _, err := ToK8sPodSpec(ctx, x) + assert.NoError(t, err) + assert.False(t, p.HostNetwork) + }) + + t.Run("skipSettingHostNetwork", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{})) + x := dummyExecContext(dummyTaskTemplate(), &v1.ResourceRequirements{}, nil, "", nil) + p, _, _, err := ToK8sPodSpec(ctx, x) + assert.NoError(t, err) + assert.False(t, p.HostNetwork) + }) + + t.Run("disableServiceLinks", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{})) + x := dummyExecContext(dummyTaskTemplate(), &v1.ResourceRequirements{}, nil, "", nil) + p, _, _, err := ToK8sPodSpec(ctx, x) + assert.NoError(t, err) + assert.NotNil(t, p.EnableServiceLinks) + assert.False(t, *p.EnableServiceLinks) + }) + + t.Run("default-pod-dns-config", func(t *testing.T) { + val1 := "1" + val2 := "1" + val3 := "3" + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + DefaultPodDNSConfig: &v1.PodDNSConfig{ + Nameservers: []string{"8.8.8.8", "8.8.4.4"}, + Options: []v1.PodDNSConfigOption{ + { + Name: "ndots", + Value: &val1, + }, + { + Name: "single-request-reopen", + }, + { + Name: "timeout", + Value: &val2, + }, + { + Name: "attempts", + Value: &val3, + }, + }, + Searches: []string{"ns1.svc.cluster-domain.example", "my.dns.search.suffix"}, + }, + })) + + x := dummyExecContext(dummyTaskTemplate(), &v1.ResourceRequirements{}, nil, "", nil) + p, _, _, err := ToK8sPodSpec(ctx, x) + assert.NoError(t, err) + assert.NotNil(t, p.DNSConfig) + assert.Equal(t, []string{"8.8.8.8", "8.8.4.4"}, p.DNSConfig.Nameservers) + assert.Equal(t, "ndots", p.DNSConfig.Options[0].Name) + assert.Equal(t, val1, *p.DNSConfig.Options[0].Value) + assert.Equal(t, "single-request-reopen", p.DNSConfig.Options[1].Name) + assert.Equal(t, "timeout", p.DNSConfig.Options[2].Name) + assert.Equal(t, val2, *p.DNSConfig.Options[2].Value) + assert.Equal(t, "attempts", p.DNSConfig.Options[3].Name) + assert.Equal(t, val3, *p.DNSConfig.Options[3].Value) + assert.Equal(t, []string{"ns1.svc.cluster-domain.example", "my.dns.search.suffix"}, p.DNSConfig.Searches) + }) + + t.Run("environmentVariables", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + DefaultEnvVars: map[string]string{ + "foo": "bar", + }, + })) + x := dummyExecContext(dummyTaskTemplate(), &v1.ResourceRequirements{}, nil, "", nil) + p, _, _, err := ToK8sPodSpec(ctx, x) + assert.NoError(t, err) + for _, c := range p.Containers { + uniqueVariableNames := make(map[string]string) + for _, envVar := range c.Env { + if _, ok := uniqueVariableNames[envVar.Name]; ok { + t.Errorf("duplicate environment variable %s", envVar.Name) + } + uniqueVariableNames[envVar.Name] = envVar.Value + } + } + }) + + // TODO @pvditt + //t.Run("AcceleratedInputsEnabled", func(t *testing.T) { + // cfg := propellerCfg.GetConfig() + // cfg.AcceleratedInputs.Enabled = true + // cfg.AcceleratedInputs.VolumePath = "/test/path" + // cfg.AcceleratedInputs.LocalPathPrefix = "/test/local" + // defer func() { cfg.AcceleratedInputs.Enabled = false }() + // x := dummyExecContext(dummyTaskTemplate(), &v1.ResourceRequirements{}, nil, "", nil) + // + // p, _, _, err := ToK8sPodSpec(ctx, x) + // + // assert.NoError(t, err) + // if assert.Len(t, p.Volumes, 1) { + // vol := p.Volumes[0] + // assert.Equal(t, "union-persistent-data-volume", vol.Name) + // assert.Equal(t, cfg.AcceleratedInputs.VolumePath, vol.HostPath.Path) + // } + // if assert.Len(t, p.Containers, 1) && assert.Len(t, p.Containers[0].VolumeMounts, 1) { + // mount := p.Containers[0].VolumeMounts[0] + // assert.Equal(t, "union-persistent-data-volume", mount.Name) + // assert.Equal(t, cfg.AcceleratedInputs.LocalPathPrefix, mount.MountPath) + // assert.True(t, mount.ReadOnly) + // } + //}) +} + +func TestToK8sPodContainerImage(t *testing.T) { + t.Run("Override container image", func(t *testing.T) { + taskContext := dummyExecContext(dummyTaskTemplate(), &v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1024m"), + }}, nil, "foo:latest", nil) + p, _, _, err := ToK8sPodSpec(context.TODO(), taskContext) + assert.NoError(t, err) + assert.Equal(t, "foo:latest", p.Containers[0].Image) + }) +} + +func TestPodTemplateOverride(t *testing.T) { + metadata := &core.K8SObjectMetadata{ + Labels: map[string]string{ + "l": "a", + }, + Annotations: map[string]string{ + "a": "b", + }, + } + + podSpec := v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "foo", + Image: "foo:latest", + Args: []string{"foo", "bar"}, + }, + }, + } + + podSpecStruct, err := utils.MarshalObjToStruct(podSpec) + assert.NoError(t, err) + + t.Run("Override pod template", func(t *testing.T) { + taskContext := dummyExecContext(dummyTaskTemplate(), &v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1024m"), + }}, nil, "", &core.K8SPod{ + PrimaryContainerName: "foo", + PodSpec: podSpecStruct, + Metadata: metadata, + }) + p, m, _, err := ToK8sPodSpec(context.TODO(), taskContext) + assert.NoError(t, err) + assert.Equal(t, "a", m.Labels["l"]) + assert.Equal(t, "b", m.Annotations["a"]) + assert.Equal(t, "foo:latest", p.Containers[0].Image) + assert.Equal(t, "foo", p.Containers[0].Name) + }) +} + +func TestToK8sPodExtendedResources(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuDeviceNodeLabel: "gpu-node-label", + GpuPartitionSizeNodeLabel: "gpu-partition-size", + GpuResourceName: ResourceNvidiaGPU, + })) + + fixtures := []struct { + name string + resources *v1.ResourceRequirements + extendedResourcesBase *core.ExtendedResources + extendedResourcesOverride *core.ExtendedResources + expectedNsr []v1.NodeSelectorTerm + expectedTol []v1.Toleration + }{ + { + "without overrides", + &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-t4", + }, + }, + nil, + []v1.NodeSelectorTerm{ + { + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "gpu-node-label", + Operator: v1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-t4"}, + }, + }, + }, + }, + []v1.Toleration{ + { + Key: "gpu-node-label", + Value: "nvidia-tesla-t4", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + }, + }, + { + "with overrides", + &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-t4", + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-a100", + PartitionSizeValue: &core.GPUAccelerator_PartitionSize{ + PartitionSize: "1g.5gb", + }, + }, + }, + []v1.NodeSelectorTerm{ + { + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "gpu-node-label", + Operator: v1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-a100"}, + }, + v1.NodeSelectorRequirement{ + Key: "gpu-partition-size", + Operator: v1.NodeSelectorOpIn, + Values: []string{"1g.5gb"}, + }, + }, + }, + }, + []v1.Toleration{ + { + Key: "gpu-node-label", + Value: "nvidia-tesla-a100", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + { + Key: "gpu-partition-size", + Value: "1g.5gb", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + }, + }, + } + + for _, f := range fixtures { + t.Run(f.name, func(t *testing.T) { + taskTemplate := dummyTaskTemplate() + taskTemplate.ExtendedResources = f.extendedResourcesBase + taskContext := dummyExecContext(taskTemplate, f.resources, f.extendedResourcesOverride, "", nil) + p, _, _, err := ToK8sPodSpec(context.TODO(), taskContext) + assert.NoError(t, err) + + assert.EqualValues( + t, + f.expectedNsr, + p.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + f.expectedTol, + p.Tolerations, + ) + }) + } +} + +// TestToK8sPodDeviceClass validates the complete three-way merge order through ToK8sPodSpec: +// Task PodSpec > Device Class PodTemplate > Base PodTemplate +func TestToK8sPodDeviceClass(t *testing.T) { + t.Run("device class template merge", func(t *testing.T) { + // 1. Configure base PodTemplate in DefaultPodTemplateStore + basePodTemplate := v1.PodTemplate{ + ObjectMeta: metav1.ObjectMeta{ + Name: "base-template", + Namespace: "test-namespace", + }, + Template: v1.PodTemplateSpec{ + Spec: v1.PodSpec{ + SchedulerName: "base-scheduler", + DNSPolicy: v1.DNSClusterFirst, + Tolerations: []v1.Toleration{ + {Key: "base-tol", Operator: v1.TolerationOpExists, Effect: v1.TaintEffectNoSchedule}, + }, + NodeSelector: map[string]string{ + "base-key": "base-value", + }, + }, + }, + } + DefaultPodTemplateStore.Store(&basePodTemplate) + + // 2. Configure device class PodTemplate for AMAZON_NEURON + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "AMAZON_NEURON": { + ResourceName: "aws.amazon.com/neuron", + PodTemplate: &v1.PodTemplate{ + Template: v1.PodTemplateSpec{ + Spec: v1.PodSpec{ + SchedulerName: "device-scheduler", // Overrides base + PriorityClassName: "device-priority", + Tolerations: []v1.Toleration{ + {Key: "device-tol", Operator: v1.TolerationOpExists, Effect: v1.TaintEffectNoSchedule}, + }, + NodeSelector: map[string]string{ + "device-key": "device-value", + }, + }, + }, + }, + }, + }, + })) + + // 3. Configure task-level K8SPod override + taskPodSpec := v1.PodSpec{ + PriorityClassName: "task-priority", + Tolerations: []v1.Toleration{ + {Key: "task-tol", Operator: v1.TolerationOpExists, Effect: v1.TaintEffectNoSchedule}, + }, + NodeSelector: map[string]string{ + "task-key": "task-value", + }, + Containers: []v1.Container{ + { + Name: "primary-container", + }, + }, + } + taskPodSpecStruct, err := utils.MarshalObjToStruct(taskPodSpec) + assert.NoError(t, err) + + taskTemplate := dummyTaskTemplate() + taskTemplate.Metadata = &core.TaskMetadata{ + PodTemplateName: "base-template", + } + taskTemplate.ExtendedResources = &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + DeviceClass: core.GPUAccelerator_AMAZON_NEURON, + }, + } + + k8sPod := &core.K8SPod{ + PodSpec: taskPodSpecStruct, + PrimaryContainerName: "primary-container", + } + + taskContext := dummyExecContext(taskTemplate, &v1.ResourceRequirements{}, nil, "", k8sPod) + podSpec, _, _, err := ToK8sPodSpec(context.TODO(), taskContext) + assert.NoError(t, err) + + // 4. Validate merge order: Task > Device Class > Base Template + + // Scalars: Device class scalar overrides base + assert.Equal(t, "device-scheduler", podSpec.SchedulerName, + "Device class SchedulerName should override base") + + // Device class scalar overridden by task + assert.Equal(t, "task-priority", podSpec.PriorityClassName, + "Task PriorityClassName should override device class") + + // Base scalar preserved (not in task or device class) + assert.Equal(t, v1.DNSClusterFirst, podSpec.DNSPolicy, + "Base DNSPolicy should be preserved") + + // Slices: All tolerations should be appended + tolerationKeys := make([]string, 0) + for _, tol := range podSpec.Tolerations { + tolerationKeys = append(tolerationKeys, tol.Key) + } + assert.Contains(t, tolerationKeys, "base-tol", + "Base toleration should be present") + assert.Contains(t, tolerationKeys, "device-tol", + "Device class toleration should be present") + assert.Contains(t, tolerationKeys, "task-tol", + "Task toleration should be present") + + // Maps: All node selector entries should be merged + assert.Equal(t, "base-value", podSpec.NodeSelector["base-key"], + "Base node selector should be present") + assert.Equal(t, "device-value", podSpec.NodeSelector["device-key"], + "Device class node selector should be present") + assert.Equal(t, "task-value", podSpec.NodeSelector["task-key"], + "Task node selector should be present") + }) +} + +func TestDemystifyPending(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + CreateContainerErrorGracePeriod: config1.Duration{ + Duration: time.Minute * 3, + }, + CreateContainerConfigErrorGracePeriod: config1.Duration{ + Duration: time.Minute * 4, + }, + ImagePullBackoffGracePeriod: config1.Duration{ + Duration: time.Minute * 3, + }, + PodPendingTimeout: config1.Duration{ + Duration: 0, + }, + })) + + t.Run("PodNotScheduled", func(t *testing.T) { + s := v1.PodStatus{ + Phase: v1.PodPending, + Conditions: []v1.PodCondition{ + { + Type: v1.PodScheduled, + Status: v1.ConditionFalse, + }, + }, + } + taskStatus, err := DemystifyPending(s, pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseQueued, taskStatus.Phase()) + }) + + t.Run("PodUnschedulable", func(t *testing.T) { + s := v1.PodStatus{ + Phase: v1.PodPending, + Conditions: []v1.PodCondition{ + { + Type: v1.PodReasonUnschedulable, + Status: v1.ConditionFalse, + }, + }, + } + taskStatus, err := DemystifyPending(s, pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseQueued, taskStatus.Phase()) + }) + + t.Run("PodNotScheduled", func(t *testing.T) { + s := v1.PodStatus{ + Phase: v1.PodPending, + Conditions: []v1.PodCondition{ + { + Type: v1.PodScheduled, + Status: v1.ConditionTrue, + }, + }, + } + taskStatus, err := DemystifyPending(s, pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseQueued, taskStatus.Phase()) + }) + + t.Run("PodUnschedulable", func(t *testing.T) { + s := v1.PodStatus{ + Phase: v1.PodPending, + Conditions: []v1.PodCondition{ + { + Type: v1.PodReasonUnschedulable, + Status: v1.ConditionUnknown, + }, + }, + } + taskStatus, err := DemystifyPending(s, pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseQueued, taskStatus.Phase()) + }) + + s := v1.PodStatus{ + Phase: v1.PodPending, + Conditions: []v1.PodCondition{ + { + Type: v1.PodReady, + Status: v1.ConditionFalse, + }, + { + Type: v1.PodReasonUnschedulable, + Status: v1.ConditionUnknown, + }, + { + Type: v1.PodScheduled, + Status: v1.ConditionTrue, + }, + }, + } + + t.Run("ContainerCreating", func(t *testing.T) { + s.ContainerStatuses = []v1.ContainerStatus{ + { + Ready: false, + State: v1.ContainerState{ + Waiting: &v1.ContainerStateWaiting{ + Reason: "ContainerCreating", + Message: "this is not an error", + }, + }, + }, + } + taskStatus, err := DemystifyPending(s, pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseInitializing, taskStatus.Phase()) + }) + + t.Run("ErrImagePull", func(t *testing.T) { + s.ContainerStatuses = []v1.ContainerStatus{ + { + Ready: false, + State: v1.ContainerState{ + Waiting: &v1.ContainerStateWaiting{ + Reason: "ErrImagePull", + Message: "this is not an error", + }, + }, + }, + } + taskStatus, err := DemystifyPending(s, pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseInitializing, taskStatus.Phase()) + }) + + t.Run("PodInitializing", func(t *testing.T) { + s.ContainerStatuses = []v1.ContainerStatus{ + { + Ready: false, + State: v1.ContainerState{ + Waiting: &v1.ContainerStateWaiting{ + Reason: "PodInitializing", + Message: "this is not an error", + }, + }, + }, + } + taskStatus, err := DemystifyPending(s, pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseInitializing, taskStatus.Phase()) + }) + + t.Run("ImagePullBackOffWithinGracePeriod", func(t *testing.T) { + s2 := *s.DeepCopy() + s2.Conditions[0].LastTransitionTime = metav1.Now() + s2.ContainerStatuses = []v1.ContainerStatus{ + { + Ready: false, + State: v1.ContainerState{ + Waiting: &v1.ContainerStateWaiting{ + Reason: "ImagePullBackOff", + Message: "this is an error", + }, + }, + }, + } + taskStatus, err := DemystifyPending(s2, pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseInitializing, taskStatus.Phase()) + }) + + t.Run("ImagePullBackOffOutsideGracePeriod", func(t *testing.T) { + s2 := *s.DeepCopy() + s2.Conditions[0].LastTransitionTime.Time = metav1.Now().Add(-config.GetK8sPluginConfig().ImagePullBackoffGracePeriod.Duration) + s2.ContainerStatuses = []v1.ContainerStatus{ + { + Ready: false, + State: v1.ContainerState{ + Waiting: &v1.ContainerStateWaiting{ + Reason: "ImagePullBackOff", + Message: "this is an error", + }, + }, + }, + } + taskStatus, err := DemystifyPending(s2, pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, taskStatus.Phase()) + assert.True(t, taskStatus.CleanupOnFailure()) + }) + + t.Run("InvalidImageName", func(t *testing.T) { + s.ContainerStatuses = []v1.ContainerStatus{ + { + Ready: false, + State: v1.ContainerState{ + Waiting: &v1.ContainerStateWaiting{ + Reason: "InvalidImageName", + Message: "this is an error", + }, + }, + }, + } + taskStatus, err := DemystifyPending(s, pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhasePermanentFailure, taskStatus.Phase()) + assert.True(t, taskStatus.CleanupOnFailure()) + }) + + t.Run("RegistryUnavailable", func(t *testing.T) { + s.ContainerStatuses = []v1.ContainerStatus{ + { + Ready: false, + State: v1.ContainerState{ + Waiting: &v1.ContainerStateWaiting{ + Reason: "RegistryUnavailable", + Message: "this is an error", + }, + }, + }, + } + taskStatus, err := DemystifyPending(s, pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, taskStatus.Phase()) + assert.True(t, taskStatus.CleanupOnFailure()) + }) + + t.Run("RandomError", func(t *testing.T) { + s.ContainerStatuses = []v1.ContainerStatus{ + { + Ready: false, + State: v1.ContainerState{ + Waiting: &v1.ContainerStateWaiting{ + Reason: "RandomError", + Message: "this is an error", + }, + }, + }, + } + taskStatus, err := DemystifyPending(s, pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, taskStatus.Phase()) + assert.True(t, taskStatus.CleanupOnFailure()) + }) + + t.Run("CreateContainerConfigErrorWithinGracePeriod", func(t *testing.T) { + s2 := *s.DeepCopy() + s2.Conditions[0].LastTransitionTime = metav1.Now() + s2.ContainerStatuses = []v1.ContainerStatus{ + { + Ready: false, + State: v1.ContainerState{ + Waiting: &v1.ContainerStateWaiting{ + Reason: "CreateContainerConfigError", + Message: "this is a transient error", + }, + }, + }, + } + taskStatus, err := DemystifyPending(s2, pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseInitializing, taskStatus.Phase()) + }) + + t.Run("CreateContainerConfigErrorOutsideGracePeriod", func(t *testing.T) { + s2 := *s.DeepCopy() + s2.Conditions[0].LastTransitionTime.Time = metav1.Now().Add(-config.GetK8sPluginConfig().CreateContainerConfigErrorGracePeriod.Duration) + s2.ContainerStatuses = []v1.ContainerStatus{ + { + Ready: false, + State: v1.ContainerState{ + Waiting: &v1.ContainerStateWaiting{ + Reason: "CreateContainerConfigError", + Message: "this a permanent error", + }, + }, + }, + } + taskStatus, err := DemystifyPending(s2, pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhasePermanentFailure, taskStatus.Phase()) + assert.True(t, taskStatus.CleanupOnFailure()) + }) + + t.Run("CreateContainerErrorWithinGracePeriod", func(t *testing.T) { + s2 := *s.DeepCopy() + s2.Conditions[0].LastTransitionTime = metav1.Now() + s2.ContainerStatuses = []v1.ContainerStatus{ + { + Ready: false, + State: v1.ContainerState{ + Waiting: &v1.ContainerStateWaiting{ + Reason: "CreateContainerError", + Message: "this is a transient error", + }, + }, + }, + } + taskStatus, err := DemystifyPending(s2, pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseInitializing, taskStatus.Phase()) + }) + + t.Run("CreateContainerErrorOutsideGracePeriod", func(t *testing.T) { + s2 := *s.DeepCopy() + s2.Conditions[0].LastTransitionTime.Time = metav1.Now().Add(-config.GetK8sPluginConfig().CreateContainerErrorGracePeriod.Duration) + s2.ContainerStatuses = []v1.ContainerStatus{ + { + Ready: false, + State: v1.ContainerState{ + Waiting: &v1.ContainerStateWaiting{ + Reason: "CreateContainerError", + Message: "this a permanent error", + }, + }, + }, + } + taskStatus, err := DemystifyPending(s2, pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhasePermanentFailure, taskStatus.Phase()) + assert.True(t, taskStatus.CleanupOnFailure()) + }) +} + +func TestDemystifyPendingTimeout(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + CreateContainerErrorGracePeriod: config1.Duration{ + Duration: time.Minute * 3, + }, + ImagePullBackoffGracePeriod: config1.Duration{ + Duration: time.Minute * 3, + }, + PodPendingTimeout: config1.Duration{ + Duration: 10, + }, + })) + + s := v1.PodStatus{ + Phase: v1.PodPending, + Conditions: []v1.PodCondition{ + { + Type: v1.PodScheduled, + Status: v1.ConditionFalse, + }, + }, + } + s.Conditions[0].LastTransitionTime.Time = metav1.Now().Add(-config.GetK8sPluginConfig().PodPendingTimeout.Duration) + + t.Run("PodPendingExceedsTimeout", func(t *testing.T) { + taskStatus, err := DemystifyPending(s, pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, taskStatus.Phase()) + assert.Equal(t, "PodPendingTimeout", taskStatus.Err().Code) + assert.Equal(t, core.ExecutionError_SYSTEM, taskStatus.Err().Kind) + assert.True(t, taskStatus.CleanupOnFailure()) + }) +} + +func TestDemystifySuccess(t *testing.T) { + t.Run("OOMKilled", func(t *testing.T) { + phaseInfo, err := DemystifySuccess(v1.PodStatus{ + ContainerStatuses: []v1.ContainerStatus{ + { + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + Reason: OOMKilled, + }, + }, + }, + }, + }, pluginsCore.TaskInfo{}) + assert.Nil(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, phaseInfo.Phase()) + assert.Equal(t, "OOMKilled", phaseInfo.Err().Code) + }) + + t.Run("InitContainer OOMKilled", func(t *testing.T) { + phaseInfo, err := DemystifySuccess(v1.PodStatus{ + InitContainerStatuses: []v1.ContainerStatus{ + { + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + Reason: OOMKilled, + }, + }, + }, + }, + }, pluginsCore.TaskInfo{}) + assert.Nil(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, phaseInfo.Phase()) + assert.Equal(t, "OOMKilled", phaseInfo.Err().Code) + }) + + t.Run("success", func(t *testing.T) { + phaseInfo, err := DemystifySuccess(v1.PodStatus{}, pluginsCore.TaskInfo{}) + assert.Nil(t, err) + assert.Equal(t, pluginsCore.PhaseSuccess, phaseInfo.Phase()) + }) +} + +func TestDemystifyFailure(t *testing.T) { + ctx := context.TODO() + + t.Run("unknown-error", func(t *testing.T) { + phaseInfo, err := DemystifyFailure(ctx, v1.PodStatus{}, pluginsCore.TaskInfo{}, "") + assert.Nil(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, phaseInfo.Phase()) + assert.Equal(t, "Interrupted", phaseInfo.Err().Code) + assert.Equal(t, core.ExecutionError_SYSTEM, phaseInfo.Err().Kind) + }) + + t.Run("known-error", func(t *testing.T) { + phaseInfo, err := DemystifyFailure(ctx, v1.PodStatus{Reason: "hello"}, pluginsCore.TaskInfo{}, "") + assert.Nil(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, phaseInfo.Phase()) + assert.Equal(t, "hello", phaseInfo.Err().Code) + assert.Equal(t, core.ExecutionError_USER, phaseInfo.Err().Kind) + }) + + t.Run("OOMKilled", func(t *testing.T) { + phaseInfo, err := DemystifyFailure(ctx, v1.PodStatus{ + ContainerStatuses: []v1.ContainerStatus{ + { + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + Reason: OOMKilled, + ExitCode: 137, + }, + }, + }, + }, + }, pluginsCore.TaskInfo{}, "") + assert.Nil(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, phaseInfo.Phase()) + assert.Equal(t, "OOMKilled", phaseInfo.Err().Code) + assert.Equal(t, core.ExecutionError_USER, phaseInfo.Err().Kind) + }) + + t.Run("SIGKILL non-primary container", func(t *testing.T) { + phaseInfo, err := DemystifyFailure(ctx, v1.PodStatus{ + ContainerStatuses: []v1.ContainerStatus{ + { + LastTerminationState: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + Reason: "some reason", + ExitCode: SIGKILL, + }, + }, + Name: "non-primary-container", + }, + }, + }, pluginsCore.TaskInfo{}, "primary-container") + assert.Nil(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, phaseInfo.Phase()) + assert.Equal(t, "Interrupted", phaseInfo.Err().Code) + assert.Equal(t, core.ExecutionError_USER, phaseInfo.Err().Kind) + }) + + t.Run("SIGKILL primary container", func(t *testing.T) { + phaseInfo, err := DemystifyFailure(ctx, v1.PodStatus{ + ContainerStatuses: []v1.ContainerStatus{ + { + LastTerminationState: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + Reason: "some reason", + ExitCode: SIGKILL, + }, + }, + Name: "primary-container", + }, + }, + }, pluginsCore.TaskInfo{}, "primary-container") + assert.Nil(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, phaseInfo.Phase()) + assert.Equal(t, "Interrupted", phaseInfo.Err().Code) + assert.Equal(t, core.ExecutionError_SYSTEM, phaseInfo.Err().Kind) + }) + + t.Run("GKE node preemption", func(t *testing.T) { + for _, reason := range []string{ + "Terminated", + "Shutdown", + "NodeShutdown", + } { + t.Run(reason, func(t *testing.T) { + message := "Test pod status message" + phaseInfo, err := DemystifyFailure(ctx, v1.PodStatus{ + Message: message, + Reason: reason, + // Can't always rely on GCP returining container statuses when node is preempted + ContainerStatuses: []v1.ContainerStatus{}, + }, pluginsCore.TaskInfo{}, "") + assert.Nil(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, phaseInfo.Phase()) + assert.Equal(t, "Interrupted", phaseInfo.Err().GetCode()) + assert.Equal(t, core.ExecutionError_SYSTEM, phaseInfo.Err().GetKind()) + assert.Equal(t, message, phaseInfo.Err().GetMessage()) + }) + } + }) + + t.Run("Kubelet admission denies pod due to missing node label", func(t *testing.T) { + for _, reason := range []string{ + "NodeAffinity", + } { + t.Run(reason, func(t *testing.T) { + message := "Pod was rejected: Predicate NodeAffinity failed: node(s) didn't match Pod's node affinity/selector" + phaseInfo, err := DemystifyFailure(ctx, v1.PodStatus{ + Message: message, + Reason: reason, + Phase: v1.PodFailed, + // Can't always rely on GCP returining container statuses when node is preempted + ContainerStatuses: []v1.ContainerStatus{}, + }, pluginsCore.TaskInfo{}, "") + assert.Nil(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, phaseInfo.Phase()) + assert.Equal(t, "Interrupted", phaseInfo.Err().GetCode()) + assert.Equal(t, core.ExecutionError_SYSTEM, phaseInfo.Err().GetKind()) + assert.Equal(t, message, phaseInfo.Err().GetMessage()) + }) + } + }) +} + +func TestDemystifyPending_testcases(t *testing.T) { + + tests := []struct { + name string + filename string + isErr bool + errCode string + message string + }{ + {"ImagePullBackOff", "imagepull-failurepod.json", false, "ContainersNotReady|ImagePullBackOff", "Grace period [3m0s] exceeded|containers with unready status: [fdf98e4ed2b524dc3bf7-get-flyte-id-task-0]|Back-off pulling image \"image\""}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + testFile := filepath.Join("testdata", tt.filename) + data, err := ioutil.ReadFile(testFile) + assert.NoError(t, err, "failed to read file %s", testFile) + pod := &v1.Pod{} + if assert.NoError(t, json.Unmarshal(data, pod), "failed to unmarshal json in %s. Expected of type v1.Pod", testFile) { + p, err := DemystifyPending(pod.Status, pluginsCore.TaskInfo{}) + if tt.isErr { + assert.Error(t, err, "Error expected from method") + } else { + assert.NoError(t, err, "Error not expected") + assert.NotNil(t, p) + assert.Equal(t, p.Phase(), pluginsCore.PhaseRetryableFailure) + if assert.NotNil(t, p.Err()) { + assert.Equal(t, p.Err().Code, tt.errCode) + assert.Equal(t, p.Err().Message, tt.message) + } + } + } + }) + } +} + +func TestDeterminePrimaryContainerPhase(t *testing.T) { + ctx := context.TODO() + primaryContainerName := "primary" + secondaryContainer := v1.ContainerStatus{ + Name: "secondary", + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + ExitCode: 0, + }, + }, + } + var info = &pluginsCore.TaskInfo{} + t.Run("primary container waiting", func(t *testing.T) { + phaseInfo := DeterminePrimaryContainerPhase(ctx, primaryContainerName, []v1.ContainerStatus{ + secondaryContainer, { + Name: primaryContainerName, + State: v1.ContainerState{ + Waiting: &v1.ContainerStateWaiting{ + Reason: "just dawdling", + }, + }, + }, + }, info) + assert.Equal(t, pluginsCore.PhaseRunning, phaseInfo.Phase()) + }) + t.Run("primary container running", func(t *testing.T) { + phaseInfo := DeterminePrimaryContainerPhase(ctx, primaryContainerName, []v1.ContainerStatus{ + secondaryContainer, { + Name: primaryContainerName, + State: v1.ContainerState{ + Running: &v1.ContainerStateRunning{ + StartedAt: metav1.Now(), + }, + }, + }, + }, info) + assert.Equal(t, pluginsCore.PhaseRunning, phaseInfo.Phase()) + }) + t.Run("primary container failed", func(t *testing.T) { + phaseInfo := DeterminePrimaryContainerPhase(ctx, primaryContainerName, []v1.ContainerStatus{ + secondaryContainer, { + Name: primaryContainerName, + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + ExitCode: 1, + Reason: "foo", + Message: "foo failed", + }, + }, + }, + }, info) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, phaseInfo.Phase()) + assert.Equal(t, "foo", phaseInfo.Err().Code) + assert.Equal(t, core.ExecutionError_USER, phaseInfo.Err().Kind) + assert.Equal(t, "\r\n[primary] terminated with exit code (1). Reason [foo]. Message: \nfoo failed.", phaseInfo.Err().Message) + }) + t.Run("primary container failed - SIGKILL", func(t *testing.T) { + phaseInfo := DeterminePrimaryContainerPhase(ctx, primaryContainerName, []v1.ContainerStatus{ + secondaryContainer, { + Name: primaryContainerName, + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + ExitCode: 137, + Reason: "foo", + Message: "foo failed", + }, + }, + }, + }, info) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, phaseInfo.Phase()) + assert.Equal(t, "foo", phaseInfo.Err().Code) + assert.Equal(t, core.ExecutionError_SYSTEM, phaseInfo.Err().Kind) + assert.Equal(t, "\r\n[primary] terminated with exit code (137). Reason [foo]. Message: \nfoo failed.", phaseInfo.Err().Message) + }) + t.Run("primary container failed - SIGKILL unsigned", func(t *testing.T) { + phaseInfo := DeterminePrimaryContainerPhase(ctx, primaryContainerName, []v1.ContainerStatus{ + secondaryContainer, { + Name: primaryContainerName, + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + ExitCode: 247, + Reason: "foo", + Message: "foo failed", + }, + }, + }, + }, info) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, phaseInfo.Phase()) + assert.Equal(t, "foo", phaseInfo.Err().Code) + assert.Equal(t, core.ExecutionError_SYSTEM, phaseInfo.Err().Kind) + assert.Equal(t, "\r\n[primary] terminated with exit code (247). Reason [foo]. Message: \nfoo failed.", phaseInfo.Err().Message) + }) + t.Run("primary container succeeded", func(t *testing.T) { + phaseInfo := DeterminePrimaryContainerPhase(ctx, primaryContainerName, []v1.ContainerStatus{ + secondaryContainer, { + Name: primaryContainerName, + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + ExitCode: 0, + }, + }, + }, + }, info) + assert.Equal(t, pluginsCore.PhaseSuccess, phaseInfo.Phase()) + }) + t.Run("missing primary container", func(t *testing.T) { + phaseInfo := DeterminePrimaryContainerPhase(ctx, primaryContainerName, []v1.ContainerStatus{ + secondaryContainer, + }, info) + assert.Equal(t, pluginsCore.PhasePermanentFailure, phaseInfo.Phase()) + assert.Equal(t, PrimaryContainerNotFound, phaseInfo.Err().Code) + assert.Equal(t, "Primary container [primary] not found in pod's container statuses", phaseInfo.Err().Message) + }) + t.Run("primary container failed with OOMKilled", func(t *testing.T) { + phaseInfo := DeterminePrimaryContainerPhase(ctx, primaryContainerName, []v1.ContainerStatus{ + secondaryContainer, { + Name: primaryContainerName, + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + ExitCode: 0, + Reason: OOMKilled, + Message: "foo failed", + }, + }, + }, + }, info) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, phaseInfo.Phase()) + assert.Equal(t, core.ExecutionError_USER, phaseInfo.Err().Kind) + assert.Equal(t, OOMKilled, phaseInfo.Err().Code) + assert.Equal(t, "\r\n[primary] terminated with exit code (0). Reason [OOMKilled]. Message: \nfoo failed.", phaseInfo.Err().Message) + }) + t.Run("primary container failed with OOMKilled - SIGKILL", func(t *testing.T) { + phaseInfo := DeterminePrimaryContainerPhase(ctx, primaryContainerName, []v1.ContainerStatus{ + secondaryContainer, { + Name: primaryContainerName, + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + ExitCode: 137, + Reason: OOMKilled, + Message: "foo failed", + }, + }, + }, + }, info) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, phaseInfo.Phase()) + assert.Equal(t, core.ExecutionError_USER, phaseInfo.Err().Kind) + assert.Equal(t, OOMKilled, phaseInfo.Err().Code) + assert.Equal(t, "\r\n[primary] terminated with exit code (137). Reason [OOMKilled]. Message: \nfoo failed.", phaseInfo.Err().Message) + }) +} + +func TestGetPodTemplate(t *testing.T) { + ctx := context.TODO() + + podTemplate := v1.PodTemplate{ + ObjectMeta: metav1.ObjectMeta{ + Name: "foo", + Namespace: "bar", + }, + } + + t.Run("PodTemplateDoesNotExist", func(t *testing.T) { + // initialize TaskExecutionContext + task := &core.TaskTemplate{ + Type: "test", + } + + taskReader := &pluginsCoreMock.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(task, nil) + + tCtx := &pluginsCoreMock.TaskExecutionContext{} + tCtx.EXPECT().TaskExecutionMetadata().Return(dummyTaskExecutionMetadata(&v1.ResourceRequirements{}, nil, "", nil)) + tCtx.EXPECT().TaskReader().Return(taskReader) + + // initialize PodTemplateStore + store := NewPodTemplateStore() + store.SetDefaultNamespace(podTemplate.Namespace) + + // validate base PodTemplate + basePodTemplate, err := getBasePodTemplate(ctx, tCtx, store) + assert.Nil(t, err) + assert.Nil(t, basePodTemplate) + }) + + t.Run("PodTemplateFromTaskTemplateNameExists", func(t *testing.T) { + // initialize TaskExecutionContext + task := &core.TaskTemplate{ + Metadata: &core.TaskMetadata{ + PodTemplateName: "foo", + }, + Type: "test", + } + + taskReader := &pluginsCoreMock.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(task, nil) + + tCtx := &pluginsCoreMock.TaskExecutionContext{} + tCtx.EXPECT().TaskExecutionMetadata().Return(dummyTaskExecutionMetadata(&v1.ResourceRequirements{}, nil, "", nil)) + tCtx.EXPECT().TaskReader().Return(taskReader) + + // initialize PodTemplateStore + store := NewPodTemplateStore() + store.SetDefaultNamespace(podTemplate.Namespace) + store.Store(&podTemplate) + + // validate base PodTemplate + basePodTemplate, err := getBasePodTemplate(ctx, tCtx, store) + assert.Nil(t, err) + assert.True(t, reflect.DeepEqual(podTemplate, *basePodTemplate)) + }) + + t.Run("PodTemplateFromTaskTemplateNameDoesNotExist", func(t *testing.T) { + // initialize TaskExecutionContext + task := &core.TaskTemplate{ + Type: "test", + Metadata: &core.TaskMetadata{ + PodTemplateName: "foo", + }, + } + + taskReader := &pluginsCoreMock.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(task, nil) + + tCtx := &pluginsCoreMock.TaskExecutionContext{} + tCtx.EXPECT().TaskExecutionMetadata().Return(dummyTaskExecutionMetadata(&v1.ResourceRequirements{}, nil, "", nil)) + tCtx.EXPECT().TaskReader().Return(taskReader) + + // initialize PodTemplateStore + store := NewPodTemplateStore() + store.SetDefaultNamespace(podTemplate.Namespace) + + // validate base PodTemplate + basePodTemplate, err := getBasePodTemplate(ctx, tCtx, store) + assert.NotNil(t, err) + assert.Nil(t, basePodTemplate) + }) + + t.Run("PodTemplateFromDefaultPodTemplate", func(t *testing.T) { + // set default PodTemplate name configuration + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + DefaultPodTemplateName: "foo", + })) + + // initialize TaskExecutionContext + task := &core.TaskTemplate{ + Type: "test", + } + + taskReader := &pluginsCoreMock.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(task, nil) + + tCtx := &pluginsCoreMock.TaskExecutionContext{} + tCtx.EXPECT().TaskExecutionMetadata().Return(dummyTaskExecutionMetadata(&v1.ResourceRequirements{}, nil, "", nil)) + tCtx.EXPECT().TaskReader().Return(taskReader) + + // initialize PodTemplateStore + store := NewPodTemplateStore() + store.SetDefaultNamespace(podTemplate.Namespace) + store.Store(&podTemplate) + + // validate base PodTemplate + basePodTemplate, err := getBasePodTemplate(ctx, tCtx, store) + assert.Nil(t, err) + assert.True(t, reflect.DeepEqual(podTemplate, *basePodTemplate)) + }) +} + +func TestMergeWithBasePodTemplate(t *testing.T) { + podSpec := v1.PodSpec{ + Containers: []v1.Container{ + v1.Container{ + Name: "foo", + }, + v1.Container{ + Name: "bar", + }, + }, + } + + objectMeta := metav1.ObjectMeta{ + Labels: map[string]string{ + "fooKey": "barValue", + }, + } + + t.Run("BasePodTemplateDoesNotExist", func(t *testing.T) { + task := &core.TaskTemplate{ + Type: "test", + } + + taskReader := &pluginsCoreMock.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(task, nil) + + tCtx := &pluginsCoreMock.TaskExecutionContext{} + tCtx.EXPECT().TaskExecutionMetadata().Return(dummyTaskExecutionMetadata(&v1.ResourceRequirements{}, nil, "", nil)) + tCtx.EXPECT().TaskReader().Return(taskReader) + + resultPodSpec, resultObjectMeta, err := MergeWithBasePodTemplate(context.TODO(), tCtx, &podSpec, &objectMeta, "foo", "foo-init") + assert.Nil(t, err) + assert.True(t, reflect.DeepEqual(podSpec, *resultPodSpec)) + assert.True(t, reflect.DeepEqual(objectMeta, *resultObjectMeta)) + }) + + t.Run("BasePodTemplateExists", func(t *testing.T) { + primaryContainerTemplate := v1.Container{ + Name: primaryContainerTemplateName, + TerminationMessagePath: "/dev/primary-termination-log", + } + + primaryInitContainerTemplate := v1.Container{ + Name: primaryInitContainerTemplateName, + TerminationMessagePath: "/dev/primary-init-termination-log", + } + + podTemplate := v1.PodTemplate{ + ObjectMeta: metav1.ObjectMeta{ + Name: "fooTemplate", + Namespace: "test-namespace", + }, + Template: v1.PodTemplateSpec{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + "fooKey": "bazValue", + "barKey": "bazValue", + }, + }, + Spec: v1.PodSpec{ + Containers: []v1.Container{ + primaryContainerTemplate, + }, + InitContainers: []v1.Container{ + primaryInitContainerTemplate, + }, + }, + }, + } + + DefaultPodTemplateStore.Store(&podTemplate) + + task := &core.TaskTemplate{ + Metadata: &core.TaskMetadata{ + PodTemplateName: "fooTemplate", + }, + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Command: []string{"command"}, + Args: []string{"{{.Input}}"}, + }, + }, + Type: "test", + } + + taskReader := &pluginsCoreMock.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(task, nil) + + tCtx := &pluginsCoreMock.TaskExecutionContext{} + tCtx.EXPECT().TaskExecutionMetadata().Return(dummyTaskExecutionMetadata(&v1.ResourceRequirements{}, nil, "", nil)) + tCtx.EXPECT().TaskReader().Return(taskReader) + + resultPodSpec, resultObjectMeta, err := MergeWithBasePodTemplate(context.TODO(), tCtx, &podSpec, &objectMeta, "foo", "foo-init") + assert.Nil(t, err) + + // test that template podSpec is merged + primaryContainer := resultPodSpec.Containers[0] + assert.Equal(t, podSpec.Containers[0].Name, primaryContainer.Name) + assert.Equal(t, primaryContainerTemplate.TerminationMessagePath, primaryContainer.TerminationMessagePath) + + // test that template object metadata is copied + assert.Contains(t, resultObjectMeta.Labels, "fooKey") + assert.Equal(t, resultObjectMeta.Labels["fooKey"], "barValue") + assert.Contains(t, resultObjectMeta.Labels, "barKey") + assert.Equal(t, resultObjectMeta.Labels["barKey"], "bazValue") + }) +} + +func TestMergeBasePodSpecsOntoTemplate(t *testing.T) { + + baseContainer1 := v1.Container{ + Name: "task-1", + Image: "task-image", + } + + baseContainer2 := v1.Container{ + Name: "task-2", + Image: "task-image", + } + + initContainer1 := v1.Container{ + Name: "task-init-1", + Image: "task-init-image", + } + + initContainer2 := v1.Container{ + Name: "task-init-2", + Image: "task-init-image", + } + + tests := []struct { + name string + templatePodSpec *v1.PodSpec + basePodSpec *v1.PodSpec + primaryContainerName string + primaryInitContainerName string + expectedResult *v1.PodSpec + expectedError error + }{ + { + name: "nil template", + templatePodSpec: nil, + basePodSpec: &v1.PodSpec{}, + expectedError: errors.New("neither the templatePodSpec or the basePodSpec can be nil"), + }, + { + name: "nil base", + templatePodSpec: &v1.PodSpec{}, + basePodSpec: nil, + expectedError: errors.New("neither the templatePodSpec or the basePodSpec can be nil"), + }, + { + name: "nil template and base", + templatePodSpec: nil, + basePodSpec: nil, + expectedError: errors.New("neither the templatePodSpec or the basePodSpec can be nil"), + }, + { + name: "template and base with no overlap", + templatePodSpec: &v1.PodSpec{ + SchedulerName: "templateScheduler", + }, + basePodSpec: &v1.PodSpec{ + ServiceAccountName: "baseServiceAccount", + }, + expectedResult: &v1.PodSpec{ + SchedulerName: "templateScheduler", + ServiceAccountName: "baseServiceAccount", + }, + }, + { + name: "template and base with overlap", + templatePodSpec: &v1.PodSpec{ + SchedulerName: "templateScheduler", + }, + basePodSpec: &v1.PodSpec{ + SchedulerName: "baseScheduler", + ServiceAccountName: "baseServiceAccount", + }, + expectedResult: &v1.PodSpec{ + SchedulerName: "baseScheduler", + ServiceAccountName: "baseServiceAccount", + }, + }, + { + name: "template with default containers and base with no containers", + templatePodSpec: &v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "default", + Image: "default-image", + }, + }, + InitContainers: []v1.Container{ + { + Name: "default-init", + Image: "default-init-image", + }, + }, + }, + basePodSpec: &v1.PodSpec{ + SchedulerName: "baseScheduler", + }, + expectedResult: &v1.PodSpec{ + SchedulerName: "baseScheduler", + }, + }, + { + name: "template with no default containers and base containers", + templatePodSpec: &v1.PodSpec{}, + basePodSpec: &v1.PodSpec{ + Containers: []v1.Container{baseContainer1}, + InitContainers: []v1.Container{initContainer1}, + SchedulerName: "baseScheduler", + }, + expectedResult: &v1.PodSpec{ + Containers: []v1.Container{baseContainer1}, + InitContainers: []v1.Container{initContainer1}, + SchedulerName: "baseScheduler", + }, + }, + { + name: "template and base with matching containers", + templatePodSpec: &v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "task-1", + Image: "default-task-image", + TerminationMessagePath: "/dev/template-termination-log", + }, + }, + InitContainers: []v1.Container{ + { + Name: "task-init-1", + Image: "default-task-init-image", + TerminationMessagePath: "/dev/template-init-termination-log", + }, + }, + }, + primaryContainerName: "task-1", + primaryInitContainerName: "task-init-1", + basePodSpec: &v1.PodSpec{ + Containers: []v1.Container{baseContainer1}, + InitContainers: []v1.Container{initContainer1}, + SchedulerName: "baseScheduler", + }, + expectedResult: &v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "task-1", + Image: "task-image", + TerminationMessagePath: "/dev/template-termination-log", + }, + }, + InitContainers: []v1.Container{ + { + Name: "task-init-1", + Image: "task-init-image", + TerminationMessagePath: "/dev/template-init-termination-log", + }, + }, + SchedulerName: "baseScheduler", + }, + }, + { + name: "template and base with no matching containers", + templatePodSpec: &v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "not-matching", + Image: "default-task-image", + TerminationMessagePath: "/dev/template-termination-log", + }, + }, + InitContainers: []v1.Container{ + { + Name: "not-matching-init", + Image: "default-task-init-image", + TerminationMessagePath: "/dev/template-init-termination-log", + }, + }, + }, + basePodSpec: &v1.PodSpec{ + Containers: []v1.Container{baseContainer1}, + InitContainers: []v1.Container{initContainer1}, + SchedulerName: "baseScheduler", + }, + expectedResult: &v1.PodSpec{ + Containers: []v1.Container{baseContainer1}, + InitContainers: []v1.Container{initContainer1}, + SchedulerName: "baseScheduler", + }, + }, + { + name: "template with default containers and base with containers", + templatePodSpec: &v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "default", + Image: "default-task-image", + TerminationMessagePath: "/dev/template-termination-log", + }, + }, + InitContainers: []v1.Container{ + { + Name: "default-init", + Image: "default-task-init-image", + TerminationMessagePath: "/dev/template-init-termination-log", + }, + }, + }, + basePodSpec: &v1.PodSpec{ + Containers: []v1.Container{baseContainer1, baseContainer2}, + InitContainers: []v1.Container{initContainer1, initContainer2}, + SchedulerName: "baseScheduler", + }, + expectedResult: &v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "task-1", + Image: "task-image", + TerminationMessagePath: "/dev/template-termination-log", + }, + { + Name: "task-2", + Image: "task-image", + TerminationMessagePath: "/dev/template-termination-log", + }, + }, + InitContainers: []v1.Container{ + { + Name: "task-init-1", + Image: "task-init-image", + TerminationMessagePath: "/dev/template-init-termination-log", + }, + { + Name: "task-init-2", + Image: "task-init-image", + TerminationMessagePath: "/dev/template-init-termination-log", + }, + }, + SchedulerName: "baseScheduler", + }, + }, + { + name: "template with primary containers and base with containers", + templatePodSpec: &v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "primary", + Image: "default-task-image", + TerminationMessagePath: "/dev/template-termination-log", + }, + }, + InitContainers: []v1.Container{ + { + Name: "primary-init", + Image: "default-task-init-image", + TerminationMessagePath: "/dev/template-init-termination-log", + }, + }, + }, + basePodSpec: &v1.PodSpec{ + Containers: []v1.Container{baseContainer1, baseContainer2}, + InitContainers: []v1.Container{initContainer1, initContainer2}, + SchedulerName: "baseScheduler", + }, + expectedResult: &v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "task-1", + Image: "task-image", + TerminationMessagePath: "/dev/template-termination-log", + }, + baseContainer2, + }, + InitContainers: []v1.Container{ + { + Name: "task-init-1", + Image: "task-init-image", + TerminationMessagePath: "/dev/template-init-termination-log", + }, + initContainer2, + }, + SchedulerName: "baseScheduler", + }, + primaryContainerName: "task-1", + primaryInitContainerName: "task-init-1", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result, mergeErr := MergeBasePodSpecOntoTemplate(tt.templatePodSpec, tt.basePodSpec, tt.primaryContainerName, tt.primaryInitContainerName) + assert.Equal(t, tt.expectedResult, result) + assert.Equal(t, tt.expectedError, mergeErr) + }) + } +} + +func TestMergeOverlayPodSpecOntoBase(t *testing.T) { + + tests := []struct { + name string + basePodSpec *v1.PodSpec + overlayPodSpec *v1.PodSpec + expectedResult *v1.PodSpec + expectedError error + }{ + { + name: "nil overlay", + basePodSpec: &v1.PodSpec{}, + overlayPodSpec: nil, + expectedError: errors.New("neither the basePodSpec or the overlayPodSpec can be nil"), + }, + { + name: "nil base", + basePodSpec: nil, + overlayPodSpec: &v1.PodSpec{}, + expectedError: errors.New("neither the basePodSpec or the overlayPodSpec can be nil"), + }, + { + name: "nil base and overlay", + basePodSpec: nil, + overlayPodSpec: nil, + expectedError: errors.New("neither the basePodSpec or the overlayPodSpec can be nil"), + }, + { + name: "base and overlay no overlap", + basePodSpec: &v1.PodSpec{ + SchedulerName: "baseScheduler", + }, + overlayPodSpec: &v1.PodSpec{ + ServiceAccountName: "overlayServiceAccount", + }, + expectedResult: &v1.PodSpec{ + SchedulerName: "baseScheduler", + ServiceAccountName: "overlayServiceAccount", + }, + }, + { + name: "template and base with overlap", + basePodSpec: &v1.PodSpec{ + SchedulerName: "baseScheduler", + }, + overlayPodSpec: &v1.PodSpec{ + SchedulerName: "overlayScheduler", + ServiceAccountName: "overlayServiceAccount", + }, + expectedResult: &v1.PodSpec{ + SchedulerName: "overlayScheduler", + ServiceAccountName: "overlayServiceAccount", + }, + }, + { + name: "template and base with matching containers", + basePodSpec: &v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "task-1", + Image: "task-image", + }, + }, + InitContainers: []v1.Container{ + { + Name: "task-init-1", + Image: "task-init-image", + }, + }, + }, + overlayPodSpec: &v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "task-1", + Image: "overlay-image", + }, + }, + InitContainers: []v1.Container{ + { + Name: "task-init-1", + Image: "overlay-init-image", + }, + }, + }, + expectedResult: &v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "task-1", + Image: "overlay-image", + }, + }, + InitContainers: []v1.Container{ + { + Name: "task-init-1", + Image: "overlay-init-image", + }, + }, + }, + }, + { + name: "base and overlay with no matching containers", + basePodSpec: &v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "task-1", + Image: "task-image", + }, + }, + InitContainers: []v1.Container{ + { + Name: "task-init-1", + Image: "task-init-image", + }, + }, + }, + overlayPodSpec: &v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "overlay-1", + Image: "overlay-image", + }, + }, + InitContainers: []v1.Container{ + { + Name: "overlay-init-1", + Image: "overlay-init-image", + }, + }, + }, + expectedResult: &v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "task-1", + Image: "task-image", + }, + }, + InitContainers: []v1.Container{ + { + Name: "task-init-1", + Image: "task-init-image", + }, + }, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result, mergeErr := MergeOverlayPodSpecOntoBase(tt.basePodSpec, tt.overlayPodSpec) + assert.Equal(t, tt.expectedResult, result) + assert.Equal(t, tt.expectedError, mergeErr) + }) + } +} + +func TestAddFlyteCustomizationsToContainer_SetConsoleUrl(t *testing.T) { + tests := []struct { + name string + includeConsoleURL bool + consoleURL string + expectedEnvVar *v1.EnvVar + }{ + { + name: "do not include console url and console url is not set", + includeConsoleURL: false, + consoleURL: "", + expectedEnvVar: nil, + }, + { + name: "include console url but console url is not set", + includeConsoleURL: false, + consoleURL: "", + expectedEnvVar: nil, + }, + { + name: "do not include console url but console url is set", + includeConsoleURL: false, + consoleURL: "gopher://flyte:65535/console", + expectedEnvVar: nil, + }, + { + name: "include console url and console url is set", + includeConsoleURL: true, + consoleURL: "gopher://flyte:65535/console", + expectedEnvVar: &v1.EnvVar{ + Name: flyteExecutionURL, + Value: "gopher://flyte:65535/console/projects/p2/domains/d2/executions/n2/nodeId/unique_node_id/nodes", + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + container := &v1.Container{ + Command: []string{ + "{{ .Input }}", + }, + Args: []string{ + "{{ .OutputPrefix }}", + }, + } + templateParameters := getTemplateParametersForTest(&v1.ResourceRequirements{}, &v1.ResourceRequirements{}, tt.includeConsoleURL, tt.consoleURL) + err := AddFlyteCustomizationsToContainer(context.TODO(), templateParameters, ResourceCustomizationModeAssignResources, container, nil) + assert.NoError(t, err) + if tt.expectedEnvVar == nil { + // Confirm that there is no env var FLYTE_EXECUTION_URL set + for _, envVar := range container.Env { + assert.NotEqual(t, "FLYTE_EXECUTION_URL", envVar.Name) + } + } + if tt.expectedEnvVar != nil { + // Assert that the env var FLYTE_EXECUTION_URL is set if its value is non-nil + for _, envVar := range container.Env { + if envVar.Name == tt.expectedEnvVar.Name { + assert.Equal(t, tt.expectedEnvVar.Value, envVar.Value) + return + } + } + t.Fail() + } + }) + } +} + +func TestAddTolerationsForExtendedResources(t *testing.T) { + gpuResourceName := v1.ResourceName("nvidia.com/gpu") + addTolerationResourceName := v1.ResourceName("foo/bar") + noTolerationResourceName := v1.ResourceName("foo/baz") + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: gpuResourceName, + AddTolerationsForExtendedResources: []string{ + gpuResourceName.String(), + addTolerationResourceName.String(), + }, + })) + + podSpec := &v1.PodSpec{ + Containers: []v1.Container{ + v1.Container{ + Resources: v1.ResourceRequirements{ + Requests: v1.ResourceList{ + gpuResourceName: resource.MustParse("1"), + addTolerationResourceName: resource.MustParse("1"), + noTolerationResourceName: resource.MustParse("1"), + }, + }, + }, + }, + Tolerations: []v1.Toleration{ + { + Key: "foo", + Operator: v1.TolerationOpExists, + Effect: v1.TaintEffectNoSchedule, + }, + }, + } + + podSpec = AddTolerationsForExtendedResources(podSpec) + fmt.Printf("%v\n", podSpec.Tolerations) + assert.Equal(t, 3, len(podSpec.Tolerations)) + assert.Equal(t, addTolerationResourceName.String(), podSpec.Tolerations[1].Key) + assert.Equal(t, v1.TolerationOpExists, podSpec.Tolerations[1].Operator) + assert.Equal(t, v1.TaintEffectNoSchedule, podSpec.Tolerations[1].Effect) + assert.Equal(t, gpuResourceName.String(), podSpec.Tolerations[2].Key) + assert.Equal(t, v1.TolerationOpExists, podSpec.Tolerations[2].Operator) + assert.Equal(t, v1.TaintEffectNoSchedule, podSpec.Tolerations[2].Effect) + + podSpec = &v1.PodSpec{ + InitContainers: []v1.Container{ + v1.Container{ + Resources: v1.ResourceRequirements{ + Requests: v1.ResourceList{ + gpuResourceName: resource.MustParse("1"), + addTolerationResourceName: resource.MustParse("1"), + noTolerationResourceName: resource.MustParse("1"), + }, + }, + }, + }, + Tolerations: []v1.Toleration{ + { + Key: "foo", + Operator: v1.TolerationOpExists, + Effect: v1.TaintEffectNoSchedule, + }, + }, + } + + podSpec = AddTolerationsForExtendedResources(podSpec) + assert.Equal(t, 3, len(podSpec.Tolerations)) + assert.Equal(t, addTolerationResourceName.String(), podSpec.Tolerations[1].Key) + assert.Equal(t, v1.TolerationOpExists, podSpec.Tolerations[1].Operator) + assert.Equal(t, v1.TaintEffectNoSchedule, podSpec.Tolerations[1].Effect) + assert.Equal(t, gpuResourceName.String(), podSpec.Tolerations[2].Key) + assert.Equal(t, v1.TolerationOpExists, podSpec.Tolerations[2].Operator) + assert.Equal(t, v1.TaintEffectNoSchedule, podSpec.Tolerations[2].Effect) + + podSpec = &v1.PodSpec{ + Containers: []v1.Container{ + v1.Container{ + Resources: v1.ResourceRequirements{ + Requests: v1.ResourceList{ + gpuResourceName: resource.MustParse("1"), + addTolerationResourceName: resource.MustParse("1"), + noTolerationResourceName: resource.MustParse("1"), + }, + }, + }, + }, + Tolerations: []v1.Toleration{ + { + Key: "foo", + Operator: v1.TolerationOpExists, + Effect: v1.TaintEffectNoSchedule, + }, + { + Key: gpuResourceName.String(), + Operator: v1.TolerationOpExists, + Effect: v1.TaintEffectNoSchedule, + }, + }, + } + + podSpec = AddTolerationsForExtendedResources(podSpec) + assert.Equal(t, 3, len(podSpec.Tolerations)) + assert.Equal(t, gpuResourceName.String(), podSpec.Tolerations[1].Key) + assert.Equal(t, v1.TolerationOpExists, podSpec.Tolerations[1].Operator) + assert.Equal(t, v1.TaintEffectNoSchedule, podSpec.Tolerations[1].Effect) + assert.Equal(t, addTolerationResourceName.String(), podSpec.Tolerations[2].Key) + assert.Equal(t, v1.TolerationOpExists, podSpec.Tolerations[2].Operator) + assert.Equal(t, v1.TaintEffectNoSchedule, podSpec.Tolerations[2].Effect) +} + +func TestApplyExtendedResourcesOverridesSharedMemory(t *testing.T) { + SharedMemory := &core.ExtendedResources{ + SharedMemory: &core.SharedMemory{ + MountName: "flyte-shared-memory", + MountPath: "/dev/shm", + }, + } + + newSharedMemory := &core.ExtendedResources{ + SharedMemory: &core.SharedMemory{ + MountName: "flyte-shared-memory-v2", + MountPath: "/dev/shm", + }, + } + + t.Run("base is nil", func(t *testing.T) { + final := ApplyExtendedResourcesOverrides(nil, SharedMemory) + assert.EqualValues( + t, + SharedMemory.GetSharedMemory(), + final.GetSharedMemory(), + ) + }) + + t.Run("overrides is nil", func(t *testing.T) { + final := ApplyExtendedResourcesOverrides(SharedMemory, nil) + assert.EqualValues( + t, + SharedMemory.GetSharedMemory(), + final.GetSharedMemory(), + ) + }) + + t.Run("merging", func(t *testing.T) { + final := ApplyExtendedResourcesOverrides(SharedMemory, newSharedMemory) + assert.EqualValues( + t, + newSharedMemory.GetSharedMemory(), + final.GetSharedMemory(), + ) + }) +} + +func TestApplySharedMemoryErrors(t *testing.T) { + + type test struct { + name string + podSpec *v1.PodSpec + primaryContainerName string + sharedVolume *core.SharedMemory + errorMsg string + } + + tests := []test{ + { + name: "No mount name", + podSpec: nil, + primaryContainerName: "primary", + sharedVolume: &core.SharedMemory{MountPath: "/dev/shm"}, + errorMsg: "mount name is not set", + }, + { + name: "No mount path name", + podSpec: nil, + primaryContainerName: "primary", + sharedVolume: &core.SharedMemory{MountName: "flyte-shared-memory"}, + errorMsg: "mount path is not set", + }, + { + name: "No primary container", + podSpec: &v1.PodSpec{ + Containers: []v1.Container{{ + Name: "secondary", + }}, + }, + primaryContainerName: "primary", + sharedVolume: &core.SharedMemory{MountName: "flyte-shared-memory", MountPath: "/dev/shm"}, + errorMsg: "Unable to find primary container", + }, + + { + name: "Volume already exists in spec", + podSpec: &v1.PodSpec{ + Containers: []v1.Container{{ + Name: "primary", + }}, + Volumes: []v1.Volume{{ + Name: "flyte-shared-memory", + }}, + }, + primaryContainerName: "primary", + sharedVolume: &core.SharedMemory{MountName: "flyte-shared-memory", MountPath: "/dev/shm"}, + errorMsg: "A volume is already named flyte-shared-memory in pod spec", + }, + { + name: "Volume already in container", + podSpec: &v1.PodSpec{ + Containers: []v1.Container{{ + Name: "primary", + VolumeMounts: []v1.VolumeMount{{ + Name: "flyte-shared-memory", + MountPath: "/dev/shm", + }}, + }}, + }, + primaryContainerName: "primary", + sharedVolume: &core.SharedMemory{MountName: "flyte-shared-memory", MountPath: "/dev/shm"}, + errorMsg: "A volume is already named flyte-shared-memory in container", + }, + { + name: "Mount path already in container", + podSpec: &v1.PodSpec{ + Containers: []v1.Container{{ + Name: "primary", + VolumeMounts: []v1.VolumeMount{{ + Name: "flyte-shared-memory-v2", + MountPath: "/dev/shm", + }}, + }}, + }, + primaryContainerName: "primary", + sharedVolume: &core.SharedMemory{MountName: "flyte-shared-memory", MountPath: "/dev/shm"}, + errorMsg: "/dev/shm is already mounted in container", + }, + { + name: "Mount path already in container", + podSpec: &v1.PodSpec{ + Containers: []v1.Container{{ + Name: "primary", + }}, + }, + primaryContainerName: "primary", + sharedVolume: &core.SharedMemory{MountName: "flyte-shared-memory", MountPath: "/dev/shm", SizeLimit: "bad-name"}, + errorMsg: "Unable to parse size limit: bad-name", + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + err := ApplySharedMemory(test.podSpec, test.primaryContainerName, test.sharedVolume) + assert.Errorf(t, err, test.errorMsg) + }) + } +} + +func TestApplySharedMemory(t *testing.T) { + + type test struct { + name string + podSpec *v1.PodSpec + primaryContainerName string + sharedVolume *core.SharedMemory + } + + tests := []test{ + { + name: "No size limit works", + podSpec: &v1.PodSpec{ + Containers: []v1.Container{{ + Name: "primary", + }}, + }, + primaryContainerName: "primary", + sharedVolume: &core.SharedMemory{MountName: "flyte-shared-memory", MountPath: "/dev/shm"}, + }, + { + name: "With size limits works", + podSpec: &v1.PodSpec{ + Containers: []v1.Container{{ + Name: "primary", + }}, + }, + primaryContainerName: "primary", + sharedVolume: &core.SharedMemory{MountName: "flyte-shared-memory", MountPath: "/dev/shm", SizeLimit: "2Gi"}, + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + err := ApplySharedMemory(test.podSpec, test.primaryContainerName, test.sharedVolume) + assert.NoError(t, err) + + assert.Len(t, test.podSpec.Volumes, 1) + assert.Len(t, test.podSpec.Containers[0].VolumeMounts, 1) + + assert.Equal( + t, + test.podSpec.Containers[0].VolumeMounts[0], + v1.VolumeMount{ + Name: test.sharedVolume.GetMountName(), + MountPath: test.sharedVolume.GetMountPath(), + }, + ) + + var quantity resource.Quantity + if test.sharedVolume.GetSizeLimit() != "" { + quantity, err = resource.ParseQuantity(test.sharedVolume.GetSizeLimit()) + assert.NoError(t, err) + } + + assert.Equal( + t, + test.podSpec.Volumes[0], + v1.Volume{ + Name: test.sharedVolume.GetMountName(), + VolumeSource: v1.VolumeSource{ + EmptyDir: &v1.EmptyDirVolumeSource{Medium: v1.StorageMediumMemory, SizeLimit: &quantity}, + }, + }, + ) + + }) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/pod_template_store.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/pod_template_store.go new file mode 100644 index 0000000000..102a9c534d --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/pod_template_store.go @@ -0,0 +1,92 @@ +package flytek8s + +import ( + "context" + "sync" + + v1 "k8s.io/api/core/v1" + "k8s.io/client-go/tools/cache" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +var DefaultPodTemplateStore PodTemplateStore = NewPodTemplateStore() + +// PodTemplateStore maintains a thread-safe mapping of active PodTemplates with their associated +// namespaces. +type PodTemplateStore struct { + *sync.Map + defaultNamespace string +} + +// NewPodTemplateStore initializes a new PodTemplateStore +func NewPodTemplateStore() PodTemplateStore { + return PodTemplateStore{ + Map: &sync.Map{}, + } +} + +// Delete removes the specified PodTemplate from the store. +func (p *PodTemplateStore) Delete(podTemplate *v1.PodTemplate) { + if value, ok := p.Load(podTemplate.Name); ok { + podTemplates := value.(*sync.Map) + podTemplates.Delete(podTemplate.Namespace) + logger.Debugf(context.Background(), "deleted PodTemplate '%s:%s' from store", podTemplate.Namespace, podTemplate.Name) + + // we specifically are not deleting empty maps from the store because this may introduce race + // conditions where a PodTemplate is being added to the 2nd dimension map while the top level map + // is concurrently being deleted. + } +} + +// LoadOrDefault returns the PodTemplate with the specified name in the given namespace. If one +// does not exist it attempts to retrieve the one associated with the defaultNamespace. +func (p *PodTemplateStore) LoadOrDefault(namespace string, podTemplateName string) *v1.PodTemplate { + if value, ok := p.Load(podTemplateName); ok { + podTemplates := value.(*sync.Map) + if podTemplate, ok := podTemplates.Load(namespace); ok { + return podTemplate.(*v1.PodTemplate) + } + + if podTemplate, ok := podTemplates.Load(p.defaultNamespace); ok { + return podTemplate.(*v1.PodTemplate) + } + } + + return nil +} + +// SetDefaultNamespace sets the default namespace for the PodTemplateStore. +func (p *PodTemplateStore) SetDefaultNamespace(namespace string) { + p.defaultNamespace = namespace +} + +// Store loads the specified PodTemplate into the store. +func (p *PodTemplateStore) Store(podTemplate *v1.PodTemplate) { + value, _ := p.LoadOrStore(podTemplate.Name, &sync.Map{}) + podTemplates := value.(*sync.Map) + podTemplates.Store(podTemplate.Namespace, podTemplate) + logger.Debugf(context.Background(), "registered PodTemplate '%s:%s' in store", podTemplate.Namespace, podTemplate.Name) +} + +// GetPodTemplateUpdatesHandler returns a new ResourceEventHandler which adds / removes +// PodTemplates to / from the provided PodTemplateStore. +func GetPodTemplateUpdatesHandler(store *PodTemplateStore) cache.ResourceEventHandler { + return cache.ResourceEventHandlerFuncs{ + AddFunc: func(obj interface{}) { + if podTemplate, ok := obj.(*v1.PodTemplate); ok { + store.Store(podTemplate) + } + }, + UpdateFunc: func(old, new interface{}) { + if podTemplate, ok := new.(*v1.PodTemplate); ok { + store.Store(podTemplate) + } + }, + DeleteFunc: func(obj interface{}) { + if podTemplate, ok := obj.(*v1.PodTemplate); ok { + store.Delete(podTemplate) + } + }, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/pod_template_store_test.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/pod_template_store_test.go new file mode 100644 index 0000000000..1760a1014a --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/pod_template_store_test.go @@ -0,0 +1,102 @@ +package flytek8s + +import ( + "context" + "reflect" + "testing" + "time" + + "github.com/stretchr/testify/assert" + v1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/informers" + "k8s.io/client-go/kubernetes/fake" +) + +const ( + namespace = "foo" +) + +func TestPodTemplateStore(t *testing.T) { + ctx := context.TODO() + + podTemplate := &v1.PodTemplate{ + ObjectMeta: metav1.ObjectMeta{ + Name: "defaultPodTemplate", + Namespace: "defaultNamespace", + }, + Template: v1.PodTemplateSpec{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + v1.Container{ + Command: []string{"flytepropeller"}, + Args: []string{"--config", "/etc/flyte/config/*.yaml"}, + }, + }, + }, + }, + } + + store := NewPodTemplateStore() + store.SetDefaultNamespace(podTemplate.Namespace) + + kubeClient := fake.NewSimpleClientset() + informerFactory := informers.NewSharedInformerFactoryWithOptions(kubeClient, 30*time.Second) + + updateHandler := GetPodTemplateUpdatesHandler(&store) + _, err := informerFactory.Core().V1().PodTemplates().Informer().AddEventHandler(updateHandler) + assert.NoError(t, err) + go informerFactory.Start(ctx.Done()) + + // create the podTemplate + _, err = kubeClient.CoreV1().PodTemplates(podTemplate.Namespace).Create(ctx, podTemplate, metav1.CreateOptions{}) + assert.NoError(t, err) + + time.Sleep(50 * time.Millisecond) + createPodTemplate := store.LoadOrDefault(podTemplate.Namespace, podTemplate.Name) + assert.NotNil(t, createPodTemplate) + assert.True(t, reflect.DeepEqual(podTemplate, createPodTemplate)) + + // non-default namespace podTemplate does not exist + newNamespacePodTemplate := podTemplate.DeepCopy() + newNamespacePodTemplate.Namespace = namespace + + nonDefaultNamespacePodTemplate := store.LoadOrDefault(newNamespacePodTemplate.Namespace, newNamespacePodTemplate.Name) + assert.NotNil(t, nonDefaultNamespacePodTemplate) + assert.True(t, reflect.DeepEqual(podTemplate, nonDefaultNamespacePodTemplate)) + + // non-default name podTemplate does not exist + newNamePodTemplate := podTemplate.DeepCopy() + newNamePodTemplate.Name = namespace + + nonDefaultNamePodTemplate := store.LoadOrDefault(newNamePodTemplate.Namespace, newNamePodTemplate.Name) + assert.Nil(t, nonDefaultNamePodTemplate) + + // non-default namespace podTemplate exists + _, err = kubeClient.CoreV1().PodTemplates(newNamespacePodTemplate.Namespace).Create(ctx, newNamespacePodTemplate, metav1.CreateOptions{}) + assert.NoError(t, err) + + time.Sleep(50 * time.Millisecond) + createNewNamespacePodTemplate := store.LoadOrDefault(newNamespacePodTemplate.Namespace, newNamespacePodTemplate.Name) + assert.NotNil(t, createNewNamespacePodTemplate) + assert.True(t, reflect.DeepEqual(newNamespacePodTemplate, createNewNamespacePodTemplate)) + + // update the podTemplate + updatedPodTemplate := podTemplate.DeepCopy() + updatedPodTemplate.Template.Spec.RestartPolicy = v1.RestartPolicyNever + _, err = kubeClient.CoreV1().PodTemplates(podTemplate.Namespace).Update(ctx, updatedPodTemplate, metav1.UpdateOptions{}) + assert.NoError(t, err) + + time.Sleep(50 * time.Millisecond) + updatePodTemplate := store.LoadOrDefault(podTemplate.Namespace, podTemplate.Name) + assert.NotNil(t, updatePodTemplate) + assert.True(t, reflect.DeepEqual(updatedPodTemplate, updatePodTemplate)) + + // delete the podTemplate in the namespace + err = kubeClient.CoreV1().PodTemplates(podTemplate.Namespace).Delete(ctx, podTemplate.Name, metav1.DeleteOptions{}) + assert.NoError(t, err) + + time.Sleep(50 * time.Millisecond) + deletePodTemplate := store.LoadOrDefault(podTemplate.Namespace, podTemplate.Name) + assert.Nil(t, deletePodTemplate) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/resourcecustomizationmode_enumer.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/resourcecustomizationmode_enumer.go new file mode 100644 index 0000000000..bf25f1bf06 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/resourcecustomizationmode_enumer.go @@ -0,0 +1,50 @@ +// Code generated by "enumer -type=ResourceCustomizationMode -trimprefix=ResourceCustomizationMode"; DO NOT EDIT. + +package flytek8s + +import ( + "fmt" +) + +const _ResourceCustomizationModeName = "AssignResourcesMergeExistingResourcesEnsureExistingResourcesInRange" + +var _ResourceCustomizationModeIndex = [...]uint8{0, 15, 37, 67} + +func (i ResourceCustomizationMode) String() string { + if i < 0 || i >= ResourceCustomizationMode(len(_ResourceCustomizationModeIndex)-1) { + return fmt.Sprintf("ResourceCustomizationMode(%d)", i) + } + return _ResourceCustomizationModeName[_ResourceCustomizationModeIndex[i]:_ResourceCustomizationModeIndex[i+1]] +} + +var _ResourceCustomizationModeValues = []ResourceCustomizationMode{0, 1, 2} + +var _ResourceCustomizationModeNameToValueMap = map[string]ResourceCustomizationMode{ + _ResourceCustomizationModeName[0:15]: 0, + _ResourceCustomizationModeName[15:37]: 1, + _ResourceCustomizationModeName[37:67]: 2, +} + +// ResourceCustomizationModeString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func ResourceCustomizationModeString(s string) (ResourceCustomizationMode, error) { + if val, ok := _ResourceCustomizationModeNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to ResourceCustomizationMode values", s) +} + +// ResourceCustomizationModeValues returns all values of the enum +func ResourceCustomizationModeValues() []ResourceCustomizationMode { + return _ResourceCustomizationModeValues +} + +// IsAResourceCustomizationMode returns "true" if the value is listed in the enum definition. "false" otherwise +func (i ResourceCustomizationMode) IsAResourceCustomizationMode() bool { + for _, v := range _ResourceCustomizationModeValues { + if i == v { + return true + } + } + return false +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/testdata/config.yaml b/flyteplugins/go/tasks/pluginmachinery/flytek8s/testdata/config.yaml new file mode 100644 index 0000000000..a34968682b --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/testdata/config.yaml @@ -0,0 +1,53 @@ +# Sample plugins config +plugins: + # All k8s plugins default configuration + k8s: + scheduler-name: flyte-scheduler + default-cpus: 1024m + default-memory: 1024Mi + default-annotations: + - annotationKey1: annotationValue1 + - annotationKey2: annotationValue2 + default-labels: + - label1: labelValue1 + - label2: labelValue2 + resource-tolerations: + nvidia.com/gpu: + key: flyte/gpu + value: dedicated + operator: Equal + effect: NoSchedule + storage: + - key: storage + value: special + operator: Equal + effect: PreferNoSchedule + interruptible-node-selector: + - x/interruptible: "true" + interruptible-tolerations: + - key: x/flyte + value: interruptible + operator: Equal + effect: NoSchedule + interruptible-node-selector-requirement: + key: x/interruptible + operator: In + values: + - "true" + non-interruptible-node-selector-requirement: + key: x/interruptible + operator: DoesNotExist + default-env-vars: + - AWS_METADATA_SERVICE_TIMEOUT: 5 + - AWS_METADATA_SERVICE_NUM_ATTEMPTS: 20 + - FLYTE_AWS_ENDPOINT: "http://minio.flyte:9000" + - FLYTE_AWS_ACCESS_KEY_ID: minio + - FLYTE_AWS_SECRET_ACCESS_KEY: miniostorage + default-node-selector: + user: 'default' + default-pod-security-context: + runAsUser: 1000 + runAsGroup: 3000 + fsGroup: 2000 + default-security-context: + allowPrivilegeEscalation: false diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/testdata/imagepull-failurepod.json b/flyteplugins/go/tasks/pluginmachinery/flytek8s/testdata/imagepull-failurepod.json new file mode 100644 index 0000000000..ab39951e02 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/testdata/imagepull-failurepod.json @@ -0,0 +1,400 @@ +{ + "apiVersion": "v1", + "kind": "Pod", + "metadata": { + "annotations": { + "cluster-autoscaler.kubernetes.io/safe-to-evict": "false", + "flyte.flyte.net/deployment": "production", + "iam.amazonaws.com/role": "role", + "flyte.net/iamwait-inject": "injected" + }, + "creationTimestamp": "2020-04-06T21:15:03Z", + "labels": { + "app": "flyte-user-service", + "environment": "staging", + "execution-id": "fdf98e4ed2b524dc3bf7", + "interruptible": "false", + "flyte.net/iamwait-gojson-tag": "8a3b1cb9dbb132b1d973b7a8ce9da8220429e8c0", + "node-id": "get-flyte-id-task", + "task-name": "common-library-utils-get-flyte-id", + "version": "flyte-version", + "workflow-name": "compositionworkflow" + }, + "name": "fdf98e4ed2b524dc3bf7-get-flyte-id-task-0", + "namespace": "project", + "ownerReferences": [ + { + "apiVersion": "flyte.flyte.com/v1alpha1", + "blockOwnerDeletion": true, + "controller": true, + "kind": "flyteworkflow", + "name": "fdf98e4ed2b524dc3bf7", + "uid": "ae02751f-784b-11ea-96a3-0e75025c25bf" + } + ], + "resourceVersion": "185246404", + "selfLink": "/api/v1/namespaces/project/pods/fdf98e4ed2b524dc3bf7-get-flyte-id-task-0", + "uid": "ae7a8c54-784b-11ea-92a3-1298c81fec7f" + }, + "spec": { + "containers": [ + { + "args": [ + "service_venv", + "pyflyte-execute", + "--task-module", + "common.library.utils", + "--task-name", + "get_flyte_id", + "--inputs", + "s3://flyte/metadata/propeller/production/project-fdf98e4ed2b524dc3bf7/get-flyte-id-task/data/inputs.pb", + "--output-prefix", + "s3://flyte/metadata/propeller/production/project-fdf98e4ed2b524dc3bf7/get-flyte-id-task/data/0" + ], + "env": [ + { + "name": "ENABLE_FLYTE2", + "value": "1" + }, + { + "name": "FLYTE_AWS_S3_SHARD_FORMATTER", + "value": "s3://project/{}/development" + }, + { + "name": "FLYTE_AWS_S3_SHARD_STRING_LENGTH", + "value": "2" + }, + { + "name": "FLYTE_INTERNAL_DOMAIN", + "value": "development" + }, + { + "name": "FLYTE_INTERNAL_PROJECT", + "value": "project" + }, + { + "name": "FLYTE_INTERNAL_VERSION", + "value": "3c6869db7101c619908f2b568fa851a9df0016c2" + }, + { + "name": "FLYTE_INTERNAL_IMAGE", + "value": "image" + }, + { + "name": "FLYTE_PLATFORM_URL", + "value": "flyte.flyte.net" + }, + { + "name": "FLYTE_SDK_PYTHON_VENV", + "value": "service_venv" + }, + { + "name": "FLYTE_SDK_EXECUTION_ENGINE", + "value": "flyte" + }, + { + "name": "FLYTE_SDK_TYPE_ENGINES", + "value": "flyte_modelbuilder.api.internal.flyte2_shims.type_engine.Flyte1to2TypeEngine" + }, + { + "name": "FLYTE_SDK_LOCAL_SANDBOX", + "value": "/tmp/modelbuilder/" + }, + { + "name": "FLYTE_SDK_WORKFLOW_PACKAGES", + "value": "common.workflows,fare.workflows,multimode.workflows,multimode.workflows.disco,pisco.workflows,pisco.workflows.anchor,pisco.workflows.csv_report,pisco.workflows.elasticity,primetime.workflows,tolls.workflows" + }, + { + "name": "FLYTE_SDK_NAME_FORMAT", + "value": "{name}" + }, + { + "name": "FLYTE_SDK_TASK_NAME_FORMAT", + "value": "{module}.{name}" + }, + { + "name": "PYTHONPATH", + "value": ":/srv/service/current:/srv/service/current:/srv/service/current" + }, + { + "name": "SERVICE_NAME", + "value": "project" + }, + { + "name": "SERVICE_REPO_NAME", + "value": "project" + }, + { + "name": "SERVICE_INSTANCE", + "value": "development" + }, + { + "name": "APPLICATION_ENV", + "value": "development" + }, + { + "name": "IMAGE_VERSION", + "value": "3c6869db7101c619908f2b568fa851a9df0016c2" + }, + { + "name": "FLYTE_SPARK_EXECUTION_ENGINE", + "value": "kubernetes" + }, + { + "name": "FLYTE_PLATFORM", + "value": "production" + }, + { + "name": "FLYTE_INTERNAL_CONFIGURATION_PATH", + "value": "flytekit.config" + }, + { + "name": "FLYTE_INTERNAL_NAME" + }, + { + "name": "FLYTE_INTERNAL_EXECUTION_WORKFLOW", + "value": "project:development:CompositionWorkflow" + }, + { + "name": "FLYTE_INTERNAL_EXECUTION_ID", + "value": "fdf98e4ed2b524dc3bf7" + }, + { + "name": "FLYTE_INTERNAL_EXECUTION_PROJECT", + "value": "project" + }, + { + "name": "FLYTE_INTERNAL_EXECUTION_DOMAIN", + "value": "development" + }, + { + "name": "FLYTE_INTERNAL_TASK_PROJECT", + "value": "project" + }, + { + "name": "FLYTE_INTERNAL_TASK_DOMAIN", + "value": "development" + }, + { + "name": "FLYTE_INTERNAL_TASK_NAME", + "value": "common.library.utils.get_flyte_id" + }, + { + "name": "FLYTE_INTERNAL_TASK_VERSION", + "value": "3c6869db7101c619908f2b568fa851a9df0016c2" + }, + { + "name": "FLYTE_INTERNAL_PROJECT", + "value": "project" + }, + { + "name": "FLYTE_INTERNAL_DOMAIN", + "value": "development" + }, + { + "name": "FLYTE_INTERNAL_NAME", + "value": "common.library.utils.get_flyte_id" + }, + { + "name": "FLYTE_INTERNAL_VERSION", + "value": "3c6869db7101c619908f2b568fa851a9df0016c2" + }, + { + "name": "AWS_RETRY_MODE", + "value": "standard" + }, + { + "name": "AWS_METADATA_SERVICE_TIMEOUT", + "value": "5" + }, + { + "name": "AWS_METADATA_SERVICE_NUM_ATTEMPTS", + "value": "20" + }, + { + "name": "EMIT_CONTAINER_METRICS", + "value": "true" + }, + { + "name": "FLYTE_STATSD_HOST", + "value": "stats.statsagent" + }, + { + "name": "FLYTE_CREDENTIALS_AUTH_MODE", + "value": "basic" + }, + { + "name": "FLYTE_CREDENTIALS_AUTHORIZATION_METADATA_KEY", + "value": "flyte-authorization" + }, + { + "name": "FLYTE_CREDENTIALS_SCOPE", + "value": "svc" + } + ], + "image": "image", + "imagePullPolicy": "IfNotPresent", + "lifecycle": { + "preStop": { + "exec": { + "command": [ + "k8s-shutdown" + ] + } + } + }, + "name": "fdf98e4ed2b524dc3bf7-get-flyte-id-task-0", + "resources": { + "limits": { + "cpu": "2", + "memory": "2Gi" + }, + "requests": { + "cpu": "2", + "memory": "2Gi" + } + }, + "terminationMessagePath": "/dev/termination-log", + "terminationMessagePolicy": "File", + "volumeMounts": [ + { + "mountPath": "/var/run/secrets/kubernetes.io/serviceaccount", + "name": "default-token-rr2ws", + "readOnly": true + } + ] + } + ], + "dnsPolicy": "ClusterFirst", + "enableServiceLinks": true, + "imagePullSecrets": [ + ], + "initContainers": [ + { + "command": [ + "iamwait", + "-timeout=120s" + ], + "image": "iamwait:8a3b1cb9dbb132b1d973b7a8ce9da8220429e8c0", + "imagePullPolicy": "IfNotPresent", + "name": "iamwait-gojson", + "resources": { + "limits": { + "cpu": "1", + "memory": "1Gi" + }, + "requests": { + "cpu": "20m", + "memory": "10Mi" + } + }, + "terminationMessagePath": "/dev/termination-log", + "terminationMessagePolicy": "File" + } + ], + "nodeName": "ip-10-44-170-4.ec2.internal", + "priority": 0, + "restartPolicy": "Never", + "schedulerName": "default-scheduler", + "securityContext": {}, + "serviceAccount": "default", + "serviceAccountName": "default", + "terminationGracePeriodSeconds": 64, + "tolerations": [ + { + "effect": "NoExecute", + "key": "node.kubernetes.io/not-ready", + "operator": "Exists", + "tolerationSeconds": 300 + }, + { + "effect": "NoExecute", + "key": "node.kubernetes.io/unreachable", + "operator": "Exists", + "tolerationSeconds": 300 + } + ], + "volumes": [ + { + "name": "default-token-rr2ws", + "secret": { + "defaultMode": 420, + "secretName": "default-token-rr2ws" + } + } + ] + }, + "status": { + "conditions": [ + { + "lastProbeTime": null, + "lastTransitionTime": "2020-04-06T21:15:07Z", + "status": "True", + "type": "Initialized" + }, + { + "lastProbeTime": null, + "lastTransitionTime": "2020-04-06T21:15:03Z", + "message": "containers with unready status: [fdf98e4ed2b524dc3bf7-get-flyte-id-task-0]", + "reason": "ContainersNotReady", + "status": "False", + "type": "Ready" + }, + { + "lastProbeTime": null, + "lastTransitionTime": "2020-04-06T21:15:03Z", + "message": "containers with unready status: [fdf98e4ed2b524dc3bf7-get-flyte-id-task-0]", + "reason": "ContainersNotReady", + "status": "False", + "type": "ContainersReady" + }, + { + "lastProbeTime": null, + "lastTransitionTime": "2020-04-06T21:15:03Z", + "status": "True", + "type": "PodScheduled" + } + ], + "containerStatuses": [ + { + "image": "image", + "imageID": "", + "lastState": {}, + "name": "fdf98e4ed2b524dc3bf7-get-flyte-id-task-0", + "ready": false, + "restartCount": 0, + "state": { + "waiting": { + "message": "Back-off pulling image \"image\"", + "reason": "ImagePullBackOff" + } + } + } + ], + "hostIP": "10.44.170.4", + "initContainerStatuses": [ + { + "containerID": "x", + "image": "image", + "imageID": "image1", + "lastState": {}, + "name": "iamwait-gojson", + "ready": true, + "restartCount": 0, + "state": { + "terminated": { + "containerID": "x", + "exitCode": 0, + "finishedAt": "2020-04-06T21:15:06Z", + "reason": "Completed", + "startedAt": "2020-04-06T21:15:06Z" + } + } + } + ], + "phase": "Pending", + "podIP": "10.44.137.175", + "qosClass": "Guaranteed", + "startTime": "2020-04-06T21:15:03Z" + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/utils.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/utils.go new file mode 100644 index 0000000000..a8b6c93448 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/utils.go @@ -0,0 +1,157 @@ +package flytek8s + +import ( + "strings" + + "github.com/pkg/errors" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + + pluginmachinery_core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func ToK8sEnvVar(env []*core.KeyValuePair) []v1.EnvVar { + envVars := make([]v1.EnvVar, 0, len(env)) + for _, kv := range env { + envVars = append(envVars, v1.EnvVar{Name: kv.Key, Value: kv.Value}) + } + return envVars +} + +// TODO we should modify the container resources to contain a map of enum values? +// Also we should probably create tolerations / taints, but we could do that as a post process +func ToK8sResourceList(resources []*core.Resources_ResourceEntry) (v1.ResourceList, error) { + k8sResources := make(v1.ResourceList, len(resources)) + for _, r := range resources { + rVal := r.Value + v, err := resource.ParseQuantity(rVal) + if err != nil { + return nil, errors.Wrap(err, "Failed to parse resource as a valid quantity.") + } + switch r.Name { + case core.Resources_CPU: + if !v.IsZero() { + k8sResources[v1.ResourceCPU] = v + } + case core.Resources_MEMORY: + if !v.IsZero() { + k8sResources[v1.ResourceMemory] = v + } + case core.Resources_GPU: + if !v.IsZero() { + k8sResources[resourceGPU] = v + } + case core.Resources_EPHEMERAL_STORAGE: + if !v.IsZero() { + k8sResources[v1.ResourceEphemeralStorage] = v + } + } + } + return k8sResources, nil +} + +func ToK8sResourceRequirements(resources *core.Resources) (*v1.ResourceRequirements, error) { + res := &v1.ResourceRequirements{} + if resources == nil { + return res, nil + } + req, err := ToK8sResourceList(resources.Requests) + if err != nil { + return res, err + } + lim, err := ToK8sResourceList(resources.Limits) + if err != nil { + return res, err + } + res.Limits = lim + res.Requests = req + return res, nil +} + +// ApplyK8sResourceOverrides ensures that both resource requests and limits are set. +// This is required because we run user executions in namespaces bound with a project quota and the Kubernetes scheduler will reject requests omitting these. +// This function is called by plugins that don't necessarily construct a default flyte container (container and k8s pod tasks) +// and therefore don't already receive the ApplyResourceOverrides treatment and subsequent validation which handles adding sensible defaults for requests and limits. +func ApplyK8sResourceOverrides(teMetadata pluginmachinery_core.TaskExecutionMetadata, resources *v1.ResourceRequirements) v1.ResourceRequirements { + platformResources := teMetadata.GetPlatformResources() + if platformResources == nil { + platformResources = &v1.ResourceRequirements{} + } + + return ApplyResourceOverrides(*resources, *platformResources, assignIfUnset) +} + +func GetServiceAccountNameFromTaskExecutionMetadata(taskExecutionMetadata pluginmachinery_core.TaskExecutionMetadata) string { + var serviceAccount string + securityContext := taskExecutionMetadata.GetSecurityContext() + if securityContext.GetRunAs() != nil { + serviceAccount = securityContext.GetRunAs().GetK8SServiceAccount() + } + + // TO BE DEPRECATED + if len(serviceAccount) == 0 { + serviceAccount = taskExecutionMetadata.GetK8sServiceAccount() + } + + return serviceAccount +} + +// getNormalizedAcceleratorDevice returns the normalized name for the given device. +// This should map to the node label that the corresponding nodes are provisioned with. +// Falls back to the original device name if the device is not configured. +func GetNormalizedAcceleratorDevice(device string) string { + cfg := config.GetK8sPluginConfig() + if normalized, ok := cfg.AcceleratorDevices[strings.ToUpper(device)]; ok { + return normalized + } + return device +} + +// getAcceleratorResourceName returns the Kubernetes resource name for the given device class. +// Falls back to the legacy GpuResourceName if the device class is not configured. +func getAcceleratorResourceName(accelerator *core.GPUAccelerator) v1.ResourceName { + // Use the shared helper function to get the accelerator config + accelConfig := getAcceleratorConfig(accelerator) + return accelConfig.ResourceName +} + +// getAllAcceleratorResourceNames returns the Kubernetes resource names for all accelerator devices. +func getAllAcceleratorResourceNames() map[v1.ResourceName]struct{} { + cfg := config.GetK8sPluginConfig() + acceleratorResourceNames := make(map[v1.ResourceName]struct{}) + + // Add the legacy GPU resource name for backward compatibility + acceleratorResourceNames[cfg.GpuResourceName] = struct{}{} + + // Add resource names from all configured accelerator device classes + for _, deviceClassConfig := range cfg.AcceleratorDeviceClasses { + if deviceClassConfig.ResourceName != "" { + acceleratorResourceNames[deviceClassConfig.ResourceName] = struct{}{} + } + } + return acceleratorResourceNames +} + +// podRequiresAccelerator returns true if any container in the pod requires any accelerator devices. +func podRequiresAccelerator(podSpec *v1.PodSpec) bool { + acceleratorResourceNames := getAllAcceleratorResourceNames() + for _, cnt := range podSpec.Containers { + for resourceName := range acceleratorResourceNames { + if _, ok := cnt.Resources.Limits[resourceName]; ok { + return true + } + } + } + return false +} + +// getConfiguredDeviceClasses returns a list of configured device class names for logging purposes. +func getConfiguredDeviceClasses(deviceClasses map[string]config.AcceleratorDeviceClassConfig) []string { + classes := make([]string, 0, len(deviceClasses)) + for k := range deviceClasses { + classes = append(classes, k) + } + return classes +} diff --git a/flyteplugins/go/tasks/pluginmachinery/flytek8s/utils_test.go b/flyteplugins/go/tasks/pluginmachinery/flytek8s/utils_test.go new file mode 100644 index 0000000000..fc9131515a --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/flytek8s/utils_test.go @@ -0,0 +1,529 @@ +package flytek8s + +import ( + "testing" + + "github.com/stretchr/testify/assert" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestToK8sEnvVar(t *testing.T) { + e := ToK8sEnvVar([]*core.KeyValuePair{ + {Key: "k1", Value: "v1"}, + {Key: "k2", Value: "v2"}, + }) + + assert.NotEmpty(t, e) + assert.Equal(t, []v1.EnvVar{ + {Name: "k1", Value: "v1"}, + {Name: "k2", Value: "v2"}, + }, e) + + e = ToK8sEnvVar(nil) + assert.Empty(t, e) +} + +func TestToK8sResourceList(t *testing.T) { + { + r, err := ToK8sResourceList([]*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + {Name: core.Resources_GPU, Value: "1"}, + {Name: core.Resources_MEMORY, Value: "1024Mi"}, + {Name: core.Resources_EPHEMERAL_STORAGE, Value: "1024Mi"}, + }) + + assert.NoError(t, err) + assert.NotEmpty(t, r) + assert.NotNil(t, r[v1.ResourceCPU]) + assert.Equal(t, resource.MustParse("250m"), r[v1.ResourceCPU]) + assert.Equal(t, resource.MustParse("1"), r[resourceGPU]) + assert.Equal(t, resource.MustParse("1024Mi"), r[v1.ResourceMemory]) + assert.Equal(t, resource.MustParse("1024Mi"), r[v1.ResourceEphemeralStorage]) + } + { + r, err := ToK8sResourceList([]*core.Resources_ResourceEntry{}) + assert.NoError(t, err) + assert.Empty(t, r) + } + { + _, err := ToK8sResourceList([]*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250x"}, + }) + assert.Error(t, err) + } + +} + +func TestToK8sResourceRequirements(t *testing.T) { + + { + r, err := ToK8sResourceRequirements(nil) + assert.NoError(t, err) + assert.NotNil(t, r) + assert.Empty(t, r.Limits) + assert.Empty(t, r.Requests) + } + { + r, err := ToK8sResourceRequirements(&core.Resources{ + Requests: nil, + Limits: nil, + }) + assert.NoError(t, err) + assert.NotNil(t, r) + assert.Empty(t, r.Limits) + assert.Empty(t, r.Requests) + } + { + r, err := ToK8sResourceRequirements(&core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + }, + }) + assert.NoError(t, err) + assert.NotNil(t, r) + assert.Equal(t, resource.MustParse("250m"), r.Requests[v1.ResourceCPU]) + assert.Equal(t, resource.MustParse("1024m"), r.Limits[v1.ResourceCPU]) + } + { + _, err := ToK8sResourceRequirements(&core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "blah"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + }, + }) + assert.Error(t, err) + } + { + _, err := ToK8sResourceRequirements(&core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "blah"}, + }, + }) + assert.Error(t, err) + } +} + +func TestGetServiceAccountNameFromTaskExecutionMetadata(t *testing.T) { + mockTaskExecMetadata := mocks.TaskExecutionMetadata{} + mockTaskExecMetadata.EXPECT().GetSecurityContext().Return(core.SecurityContext{ + RunAs: &core.Identity{K8SServiceAccount: "service-account"}, + }) + result := GetServiceAccountNameFromTaskExecutionMetadata(&mockTaskExecMetadata) + assert.Equal(t, "service-account", result) +} + +func TestGetServiceAccountNameFromServiceAccount(t *testing.T) { + mockTaskExecMetadata := mocks.TaskExecutionMetadata{} + mockTaskExecMetadata.EXPECT().GetSecurityContext().Return(core.SecurityContext{}) + mockTaskExecMetadata.EXPECT().GetK8sServiceAccount().Return("service-account") + result := GetServiceAccountNameFromTaskExecutionMetadata(&mockTaskExecMetadata) + assert.Equal(t, "service-account", result) +} + +func TestGetNormalizedAcceleratorDevice(t *testing.T) { + // Setup config with AcceleratorDevices mapping + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + AcceleratorDevices: map[string]string{ + "A100": "nvidia-tesla-a100", + "H100": "nvidia-h100", + "T4": "nvidia-tesla-t4", + "V5E": "tpu-v5-lite-podslice", + "V5P": "tpu-v5p-slice", + "INF2": "aws-neuron-inf2", + "TRN1": "aws-neuron-trn1", + "MI300X": "amd-mi300x", + "MI250X": "amd-mi250x", + "DL1": "habana-gaudi-dl1", + }, + })) + + t.Run("NVIDIA GPU normalization", func(t *testing.T) { + assert.Equal(t, "nvidia-tesla-a100", GetNormalizedAcceleratorDevice("A100")) + assert.Equal(t, "nvidia-h100", GetNormalizedAcceleratorDevice("H100")) + assert.Equal(t, "nvidia-tesla-t4", GetNormalizedAcceleratorDevice("T4")) + }) + + t.Run("Google TPU normalization", func(t *testing.T) { + assert.Equal(t, "tpu-v5-lite-podslice", GetNormalizedAcceleratorDevice("V5E")) + assert.Equal(t, "tpu-v5p-slice", GetNormalizedAcceleratorDevice("V5P")) + }) + + t.Run("AWS Neuron normalization", func(t *testing.T) { + assert.Equal(t, "aws-neuron-inf2", GetNormalizedAcceleratorDevice("INF2")) + assert.Equal(t, "aws-neuron-trn1", GetNormalizedAcceleratorDevice("TRN1")) + }) + + t.Run("AMD GPU normalization", func(t *testing.T) { + assert.Equal(t, "amd-mi300x", GetNormalizedAcceleratorDevice("MI300X")) + assert.Equal(t, "amd-mi250x", GetNormalizedAcceleratorDevice("MI250X")) + }) + + t.Run("Habana Gaudi normalization", func(t *testing.T) { + assert.Equal(t, "habana-gaudi-dl1", GetNormalizedAcceleratorDevice("DL1")) + }) + + t.Run("case insensitivity", func(t *testing.T) { + assert.Equal(t, "nvidia-tesla-a100", GetNormalizedAcceleratorDevice("a100")) + assert.Equal(t, "nvidia-tesla-a100", GetNormalizedAcceleratorDevice("A100")) + assert.Equal(t, "nvidia-h100", GetNormalizedAcceleratorDevice("h100")) + assert.Equal(t, "tpu-v5-lite-podslice", GetNormalizedAcceleratorDevice("v5e")) + assert.Equal(t, "aws-neuron-inf2", GetNormalizedAcceleratorDevice("inf2")) + }) + + t.Run("unmapped device fallback", func(t *testing.T) { + assert.Equal(t, "custom-device", GetNormalizedAcceleratorDevice("custom-device")) + assert.Equal(t, "unknown-gpu", GetNormalizedAcceleratorDevice("unknown-gpu")) + }) + + t.Run("empty device", func(t *testing.T) { + assert.Equal(t, "", GetNormalizedAcceleratorDevice("")) + }) +} + +func TestGetAcceleratorResourceName(t *testing.T) { + t.Run("returns device class specific resource name", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "nvidia.com/gpu", + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "NVIDIA_GPU": { + ResourceName: "nvidia.com/gpu", + }, + "GOOGLE_TPU": { + ResourceName: "google.com/tpu", + }, + "AMAZON_NEURON": { + ResourceName: "aws.amazon.com/neuron", + }, + "AMD_GPU": { + ResourceName: "amd.com/gpu", + }, + }, + })) + + // Test NVIDIA GPU + result := getAcceleratorResourceName(&core.GPUAccelerator{ + DeviceClass: core.GPUAccelerator_NVIDIA_GPU, + }) + assert.Equal(t, v1.ResourceName("nvidia.com/gpu"), result) + + // Test Google TPU + result = getAcceleratorResourceName(&core.GPUAccelerator{ + DeviceClass: core.GPUAccelerator_GOOGLE_TPU, + }) + assert.Equal(t, v1.ResourceName("google.com/tpu"), result) + + // Test Amazon Neuron + result = getAcceleratorResourceName(&core.GPUAccelerator{ + DeviceClass: core.GPUAccelerator_AMAZON_NEURON, + }) + assert.Equal(t, v1.ResourceName("aws.amazon.com/neuron"), result) + + // Test AMD GPU + result = getAcceleratorResourceName(&core.GPUAccelerator{ + DeviceClass: core.GPUAccelerator_AMD_GPU, + }) + assert.Equal(t, v1.ResourceName("amd.com/gpu"), result) + }) + + t.Run("falls back to legacy GpuResourceName when device class not configured", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "nvidia.com/gpu", + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{}, + })) + + result := getAcceleratorResourceName(&core.GPUAccelerator{ + DeviceClass: core.GPUAccelerator_NVIDIA_GPU, + }) + assert.Equal(t, v1.ResourceName("nvidia.com/gpu"), result) + }) + + t.Run("falls back to legacy GpuResourceName when device class config not found", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "custom.gpu.resource", + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "GOOGLE_TPU": { + ResourceName: "google.com/tpu", + }, + }, + })) + + // Use NVIDIA_GPU (default, value 0) but it's not in the config, so should fallback + result := getAcceleratorResourceName(&core.GPUAccelerator{ + DeviceClass: core.GPUAccelerator_NVIDIA_GPU, + }) + assert.Equal(t, v1.ResourceName("custom.gpu.resource"), result) + }) + + t.Run("falls back to legacy GpuResourceName when accelerator is nil", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "nvidia.com/gpu", + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{}, + })) + + result := getAcceleratorResourceName(nil) + assert.Equal(t, v1.ResourceName("nvidia.com/gpu"), result) + }) + + t.Run("uses device class config even when resource name is empty string", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "nvidia.com/gpu", + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "NVIDIA_GPU": { + ResourceName: "", // Empty - should fallback + }, + }, + })) + + result := getAcceleratorResourceName(&core.GPUAccelerator{ + DeviceClass: core.GPUAccelerator_NVIDIA_GPU, + }) + // Should fallback to global GpuResourceName when device class resource name is empty + assert.Equal(t, v1.ResourceName("nvidia.com/gpu"), result) + }) +} + +func TestGetAllAcceleratorResourceNames(t *testing.T) { + t.Run("returns all configured accelerator resource names", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "nvidia.com/gpu", + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "NVIDIA_GPU": { + ResourceName: "nvidia.com/gpu", + }, + "GOOGLE_TPU": { + ResourceName: "google.com/tpu", + }, + "AMAZON_NEURON": { + ResourceName: "aws.amazon.com/neuron", + }, + "AMD_GPU": { + ResourceName: "amd.com/gpu", + }, + "HABANA_GAUDI": { + ResourceName: "habana.ai/gaudi", + }, + }, + })) + + result := getAllAcceleratorResourceNames() + + // Should include legacy GpuResourceName + assert.Contains(t, result, v1.ResourceName("nvidia.com/gpu")) + // Should include all configured accelerator resource names + assert.Contains(t, result, v1.ResourceName("google.com/tpu")) + assert.Contains(t, result, v1.ResourceName("aws.amazon.com/neuron")) + assert.Contains(t, result, v1.ResourceName("amd.com/gpu")) + assert.Contains(t, result, v1.ResourceName("habana.ai/gaudi")) + + // Should have exactly 5 unique resource names (nvidia.com/gpu appears in both legacy and new map) + assert.Equal(t, 5, len(result)) + }) + + t.Run("includes legacy GpuResourceName for backward compatibility", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "custom.gpu.resource", + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{}, + })) + + result := getAllAcceleratorResourceNames() + + assert.Contains(t, result, v1.ResourceName("custom.gpu.resource")) + assert.Equal(t, 1, len(result)) + }) + + t.Run("ensures uniqueness when legacy and new map overlap", func(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "nvidia.com/gpu", + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "NVIDIA_GPU": { + ResourceName: "nvidia.com/gpu", + }, + "GOOGLE_TPU": { + ResourceName: "google.com/tpu", + }, + }, + })) + + result := getAllAcceleratorResourceNames() + + // Should deduplicate nvidia.com/gpu + assert.Contains(t, result, v1.ResourceName("nvidia.com/gpu")) + assert.Contains(t, result, v1.ResourceName("google.com/tpu")) + assert.Equal(t, 2, len(result)) + }) +} + +func TestPodRequiresAccelerator(t *testing.T) { + // Setup config with multiple accelerator types + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuResourceName: "nvidia.com/gpu", + AcceleratorDeviceClasses: map[string]config.AcceleratorDeviceClassConfig{ + "NVIDIA_GPU": { + ResourceName: "nvidia.com/gpu", + }, + "GOOGLE_TPU": { + ResourceName: "google.com/tpu", + }, + "AMAZON_NEURON": { + ResourceName: "aws.amazon.com/neuron", + }, + "AMD_GPU": { + ResourceName: "amd.com/gpu", + }, + "HABANA_GAUDI": { + ResourceName: "habana.ai/gaudi", + }, + }, + })) + + t.Run("pod with NVIDIA GPU resources returns true", func(t *testing.T) { + podSpec := &v1.PodSpec{ + Containers: []v1.Container{ + { + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "nvidia.com/gpu": resource.MustParse("1"), + }, + }, + }, + }, + } + assert.True(t, podRequiresAccelerator(podSpec)) + }) + + t.Run("pod with Google TPU resources returns true", func(t *testing.T) { + podSpec := &v1.PodSpec{ + Containers: []v1.Container{ + { + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "google.com/tpu": resource.MustParse("4"), + }, + }, + }, + }, + } + assert.True(t, podRequiresAccelerator(podSpec)) + }) + + t.Run("pod with AWS Neuron resources returns true", func(t *testing.T) { + podSpec := &v1.PodSpec{ + Containers: []v1.Container{ + { + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "aws.amazon.com/neuron": resource.MustParse("2"), + }, + }, + }, + }, + } + assert.True(t, podRequiresAccelerator(podSpec)) + }) + + t.Run("pod with AMD GPU resources returns true", func(t *testing.T) { + podSpec := &v1.PodSpec{ + Containers: []v1.Container{ + { + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "amd.com/gpu": resource.MustParse("1"), + }, + }, + }, + }, + } + assert.True(t, podRequiresAccelerator(podSpec)) + }) + + t.Run("pod with Habana Gaudi resources returns true", func(t *testing.T) { + podSpec := &v1.PodSpec{ + Containers: []v1.Container{ + { + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "habana.ai/gaudi": resource.MustParse("1"), + }, + }, + }, + }, + } + assert.True(t, podRequiresAccelerator(podSpec)) + }) + + t.Run("pod with no accelerator resources returns false", func(t *testing.T) { + podSpec := &v1.PodSpec{ + Containers: []v1.Container{ + { + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1"), + v1.ResourceMemory: resource.MustParse("1Gi"), + }, + }, + }, + }, + } + assert.False(t, podRequiresAccelerator(podSpec)) + }) + + t.Run("pod with only CPU and memory returns false", func(t *testing.T) { + podSpec := &v1.PodSpec{ + Containers: []v1.Container{ + { + Resources: v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("500m"), + v1.ResourceMemory: resource.MustParse("512Mi"), + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1"), + v1.ResourceMemory: resource.MustParse("1Gi"), + }, + }, + }, + }, + } + assert.False(t, podRequiresAccelerator(podSpec)) + }) + + t.Run("multiple containers with one having accelerator returns true", func(t *testing.T) { + podSpec := &v1.PodSpec{ + Containers: []v1.Container{ + { + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1"), + }, + }, + }, + { + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "nvidia.com/gpu": resource.MustParse("1"), + }, + }, + }, + }, + } + assert.True(t, podRequiresAccelerator(podSpec)) + }) + + t.Run("empty pod spec returns false", func(t *testing.T) { + podSpec := &v1.PodSpec{} + assert.False(t, podRequiresAccelerator(podSpec)) + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/google/config.go b/flyteplugins/go/tasks/pluginmachinery/google/config.go new file mode 100644 index 0000000000..ecd154e0d5 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/google/config.go @@ -0,0 +1,23 @@ +package google + +type TokenSourceFactoryType = string + +const ( + TokenSourceTypeDefault = "default" + TokenSourceTypeGkeTaskWorkloadIdentity = "gke-task-workload-identity" // #nosec +) + +type TokenSourceFactoryConfig struct { + // Type is type of TokenSourceFactory, possible values are 'default' or 'gke-task-workload-identity'. + // - 'default' uses default credentials, see https://cloud.google.com/iam/docs/service-accounts#default + Type TokenSourceFactoryType `json:"type" pflag:",Defines type of TokenSourceFactory, possible values are 'default' and 'gke-task-workload-identity'"` + + // Configuration for GKE task workload identity token source factory + GkeTaskWorkloadIdentityTokenSourceFactoryConfig GkeTaskWorkloadIdentityTokenSourceFactoryConfig `json:"gke-task-workload-identity" pflag:"Extra configuration for GKE task workload identity token source factory"` +} + +func GetDefaultConfig() TokenSourceFactoryConfig { + return TokenSourceFactoryConfig{ + Type: "default", + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/google/default_token_source_factory.go b/flyteplugins/go/tasks/pluginmachinery/google/default_token_source_factory.go new file mode 100644 index 0000000000..358202f605 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/google/default_token_source_factory.go @@ -0,0 +1,21 @@ +package google + +import ( + "context" + + "golang.org/x/oauth2" + "golang.org/x/oauth2/google" +) + +type defaultTokenSource struct{} + +func (m *defaultTokenSource) GetTokenSource( + ctx context.Context, + identity Identity, +) (oauth2.TokenSource, error) { + return google.DefaultTokenSource(ctx) +} + +func NewDefaultTokenSourceFactory() (TokenSourceFactory, error) { + return &defaultTokenSource{}, nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/google/gke_task_workload_identity_token_source_factory.go b/flyteplugins/go/tasks/pluginmachinery/google/gke_task_workload_identity_token_source_factory.go new file mode 100644 index 0000000000..2f3c2355d7 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/google/gke_task_workload_identity_token_source_factory.go @@ -0,0 +1,112 @@ +package google + +import ( + "context" + + "github.com/pkg/errors" + "golang.org/x/oauth2" + "google.golang.org/api/impersonate" + "google.golang.org/grpc/credentials/oauth" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/kubernetes" + "k8s.io/client-go/rest" + + pluginmachinery "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" +) + +const ( + gcpServiceAccountAnnotationKey = "iam.gke.io/gcp-service-account" + workflowIdentityDocURL = "https://cloud.google.com/kubernetes-engine/docs/how-to/workload-identity" +) + +var impersonationScopes = []string{"https://www.googleapis.com/auth/bigquery"} + +type GkeTaskWorkloadIdentityTokenSourceFactoryConfig struct { + RemoteClusterConfig pluginmachinery.ClusterConfig `json:"remoteClusterConfig" pflag:"Configuration of remote GKE cluster"` +} + +type gkeTaskWorkloadIdentityTokenSourceFactory struct { + kubeClient kubernetes.Interface +} + +func (m *gkeTaskWorkloadIdentityTokenSourceFactory) getGcpServiceAccount( + ctx context.Context, + identity Identity, +) (string, error) { + if identity.K8sServiceAccount == "" { + identity.K8sServiceAccount = "default" + } + serviceAccount, err := m.kubeClient.CoreV1().ServiceAccounts(identity.K8sNamespace).Get( + ctx, + identity.K8sServiceAccount, + metav1.GetOptions{}, + ) + if err != nil { + return "", errors.Wrapf(err, "failed to retrieve task k8s service account") + } + + for key, value := range serviceAccount.Annotations { + if key == gcpServiceAccountAnnotationKey { + return value, nil + } + } + + return "", errors.Errorf( + "[%v] annotation doesn't exist on k8s service account [%v/%v], read more at %v", + gcpServiceAccountAnnotationKey, + identity.K8sNamespace, + identity.K8sServiceAccount, + workflowIdentityDocURL) +} + +func (m *gkeTaskWorkloadIdentityTokenSourceFactory) GetTokenSource( + ctx context.Context, + identity Identity, +) (oauth2.TokenSource, error) { + gcpServiceAccount, err := m.getGcpServiceAccount(ctx, identity) + if err != nil { + return oauth.TokenSource{}, err + } + + return impersonate.CredentialsTokenSource(ctx, impersonate.CredentialsConfig{ + TargetPrincipal: gcpServiceAccount, + Scopes: impersonationScopes, + }) +} + +func getKubeClient( + config *GkeTaskWorkloadIdentityTokenSourceFactoryConfig, +) (*kubernetes.Clientset, error) { + var kubeCfg *rest.Config + var err error + if config.RemoteClusterConfig.Enabled { + kubeCfg, err = pluginmachinery.KubeClientConfig( + config.RemoteClusterConfig.Endpoint, + config.RemoteClusterConfig.Auth, + ) + if err != nil { + return nil, errors.Wrapf(err, "Error building kubeconfig") + } + } else { + kubeCfg, err = rest.InClusterConfig() + if err != nil { + return nil, errors.Wrapf(err, "Cannot get InCluster kubeconfig") + } + } + + kubeClient, err := kubernetes.NewForConfig(kubeCfg) + if err != nil { + return nil, errors.Wrapf(err, "Error building kubernetes clientset") + } + return kubeClient, err +} + +func NewGkeTaskWorkloadIdentityTokenSourceFactory( + config *GkeTaskWorkloadIdentityTokenSourceFactoryConfig, +) (TokenSourceFactory, error) { + kubeClient, err := getKubeClient(config) + if err != nil { + return nil, err + } + return &gkeTaskWorkloadIdentityTokenSourceFactory{kubeClient: kubeClient}, nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/google/gke_task_workload_identity_token_source_factory_test.go b/flyteplugins/go/tasks/pluginmachinery/google/gke_task_workload_identity_token_source_factory_test.go new file mode 100644 index 0000000000..ae88eb5451 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/google/gke_task_workload_identity_token_source_factory_test.go @@ -0,0 +1,64 @@ +package google + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + corev1 "k8s.io/api/core/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/kubernetes/fake" +) + +func TestGetGcpServiceAccount(t *testing.T) { + ctx := context.TODO() + + t.Run("get GCP service account", func(t *testing.T) { + kubeClient := fake.NewSimpleClientset(&corev1.ServiceAccount{ + ObjectMeta: v1.ObjectMeta{ + Name: "name", + Namespace: "namespace", + Annotations: map[string]string{ + "owner": "abc", + "iam.gke.io/gcp-service-account": "gcp-service-account", + }, + }}) + ts := gkeTaskWorkloadIdentityTokenSourceFactory{kubeClient: kubeClient} + gcpServiceAccount, err := ts.getGcpServiceAccount(ctx, Identity{ + K8sNamespace: "namespace", + K8sServiceAccount: "name", + }) + + assert.NoError(t, err) + assert.Equal(t, "gcp-service-account", gcpServiceAccount) + }) + + t.Run("no GCP service account", func(t *testing.T) { + kubeClient := fake.NewSimpleClientset() + ts := gkeTaskWorkloadIdentityTokenSourceFactory{kubeClient: kubeClient} + _, err := ts.getGcpServiceAccount(ctx, Identity{ + K8sNamespace: "namespace", + K8sServiceAccount: "name", + }) + + assert.ErrorContains(t, err, "failed to retrieve task k8s service account") + }) + + t.Run("no GCP service account annotation", func(t *testing.T) { + kubeClient := fake.NewSimpleClientset(&corev1.ServiceAccount{ + ObjectMeta: v1.ObjectMeta{ + Name: "name", + Namespace: "namespace", + Annotations: map[string]string{ + "owner": "abc", + }, + }}) + ts := gkeTaskWorkloadIdentityTokenSourceFactory{kubeClient: kubeClient} + _, err := ts.getGcpServiceAccount(ctx, Identity{ + K8sNamespace: "namespace", + K8sServiceAccount: "name", + }) + + assert.ErrorContains(t, err, "annotation doesn't exist on k8s service account") + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/google/token_source_factory.go b/flyteplugins/go/tasks/pluginmachinery/google/token_source_factory.go new file mode 100644 index 0000000000..18cd1b0a7d --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/google/token_source_factory.go @@ -0,0 +1,33 @@ +package google + +import ( + "context" + + "github.com/pkg/errors" + "golang.org/x/oauth2" +) + +type Identity struct { + K8sNamespace string + K8sServiceAccount string +} + +type TokenSourceFactory interface { + GetTokenSource(ctx context.Context, identity Identity) (oauth2.TokenSource, error) +} + +func NewTokenSourceFactory(config TokenSourceFactoryConfig) (TokenSourceFactory, error) { + switch config.Type { + case TokenSourceTypeDefault: + return NewDefaultTokenSourceFactory() + case TokenSourceTypeGkeTaskWorkloadIdentity: + return NewGkeTaskWorkloadIdentityTokenSourceFactory( + &config.GkeTaskWorkloadIdentityTokenSourceFactoryConfig, + ) + } + + return nil, errors.Errorf( + "unknown token source type [%v], possible values are: 'default' and 'gke-task-workload-identity'", + config.Type, + ) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/internal/webapi/allocation_token.go b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/allocation_token.go new file mode 100644 index 0000000000..29368e7106 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/allocation_token.go @@ -0,0 +1,91 @@ +package webapi + +import ( + "context" + "fmt" + + "k8s.io/utils/clock" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +type tokenAllocator struct { + clock clock.Clock +} + +func newTokenAllocator(c clock.Clock) tokenAllocator { + return tokenAllocator{ + clock: c, + } +} + +func (a tokenAllocator) allocateToken(ctx context.Context, p webapi.AsyncPlugin, tCtx core.TaskExecutionContext, state *State, metrics Metrics) ( + newState *State, phaseInfo core.PhaseInfo, err error) { + if len(p.GetConfig().ResourceQuotas) == 0 { + // No quota, return success + return &State{ + AllocationTokenRequestStartTime: a.clock.Now(), + Phase: PhaseAllocationTokenAcquired, + }, core.PhaseInfoQueued(a.clock.Now(), 0, "No allocation token required"), nil + } + + ns, constraints, err := p.ResourceRequirements(ctx, tCtx) + if err != nil { + logger.Errorf(ctx, "Failed to calculate resource requirements for task. Error: %v", err) + return nil, core.PhaseInfo{}, err + } + + token := tCtx.TaskExecutionMetadata().GetTaskExecutionID().GetGeneratedName() + allocationStatus, err := tCtx.ResourceManager().AllocateResource(ctx, ns, token, constraints) + if err != nil { + logger.Errorf(ctx, "Failed to allocate resources for task. Error: %v", err) + return nil, core.PhaseInfo{}, err + } + + switch allocationStatus { + case core.AllocationStatusGranted: + metrics.AllocationGranted.Inc(ctx) + metrics.ResourceWaitTime.Observe(float64(a.clock.Since(state.AllocationTokenRequestStartTime).Milliseconds())) + return &State{ + AllocationTokenRequestStartTime: a.clock.Now(), + Phase: PhaseAllocationTokenAcquired, + }, core.PhaseInfoQueued(a.clock.Now(), 0, "Allocation token required"), nil + case core.AllocationStatusNamespaceQuotaExceeded: + case core.AllocationStatusExhausted: + metrics.AllocationNotGranted.Inc(ctx) + logger.Infof(ctx, "Couldn't allocate token because allocation status is [%v].", allocationStatus.String()) + startTime := state.AllocationTokenRequestStartTime + if startTime.IsZero() { + startTime = a.clock.Now() + } + + return &State{ + AllocationTokenRequestStartTime: startTime, + Phase: PhaseNotStarted, + }, core.PhaseInfoWaitingForResourcesInfo( + a.clock.Now(), 0, "Quota for task has exceeded. Waiting for the resource.", nil), nil + } + + return nil, core.PhaseInfo{}, fmt.Errorf("allocation status undefined [%v]", allocationStatus) +} + +func (a tokenAllocator) releaseToken(ctx context.Context, p webapi.AsyncPlugin, tCtx core.TaskExecutionContext, metrics Metrics) error { + ns, _, err := p.ResourceRequirements(ctx, tCtx) + if err != nil { + logger.Errorf(ctx, "Failed to calculate resource requirements for task. Error: %v", err) + return err + } + + token := tCtx.TaskExecutionMetadata().GetTaskExecutionID().GetGeneratedName() + err = tCtx.ResourceManager().ReleaseResource(ctx, ns, token) + if err != nil { + metrics.ResourceReleaseFailed.Inc(ctx) + logger.Errorf(ctx, "Failed to release resources for task. Error: %v", err) + return err + } + + metrics.ResourceReleased.Inc(ctx) + return nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/internal/webapi/allocation_token_test.go b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/allocation_token_test.go new file mode 100644 index 0000000000..4d3e3648cc --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/allocation_token_test.go @@ -0,0 +1,141 @@ +package webapi + +import ( + "context" + "testing" + "time" + + "github.com/go-test/deep" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + testing2 "k8s.io/utils/clock/testing" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + mocks2 "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi/mocks" + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils/labeled" +) + +func init() { + labeled.SetMetricKeys(contextutils.NamespaceKey) +} + +func newPluginWithProperties(properties webapi.PluginConfig) *mocks.AsyncPlugin { + m := &mocks.AsyncPlugin{} + m.OnGetConfig().Return(properties) + return m +} + +func Test_allocateToken(t *testing.T) { + ctx := context.Background() + metrics := newMetrics(promutils.NewTestScope()) + + tNow := time.Now() + clck := testing2.NewFakeClock(tNow) + + tID := &mocks2.TaskExecutionID{} + tID.EXPECT().GetGeneratedName().Return("abc") + + tMeta := &mocks2.TaskExecutionMetadata{} + tMeta.EXPECT().GetTaskExecutionID().Return(tID) + + rm := &mocks2.ResourceManager{} + rm.EXPECT().AllocateResource(mock.Anything, core.ResourceNamespace("ns"), "abc", mock.Anything).Return(core.AllocationStatusGranted, nil) + + tCtx := &mocks2.TaskExecutionContext{} + tCtx.EXPECT().TaskExecutionMetadata().Return(tMeta) + tCtx.EXPECT().ResourceManager().Return(rm) + + state := &State{} + + p := newPluginWithProperties(webapi.PluginConfig{ + ResourceQuotas: map[core.ResourceNamespace]int{ + "ns": 1, + }, + }) + + t.Run("no quota", func(t *testing.T) { + p := newPluginWithProperties(webapi.PluginConfig{ResourceQuotas: nil}) + a := newTokenAllocator(clck) + gotNewState, _, err := a.allocateToken(ctx, p, nil, nil, metrics) + assert.NoError(t, err) + if diff := deep.Equal(gotNewState, &State{ + AllocationTokenRequestStartTime: tNow, + Phase: PhaseAllocationTokenAcquired, + }); len(diff) > 0 { + t.Errorf("allocateToken() gotNewState = %v, Diff: %v", gotNewState, diff) + } + }) + + t.Run("Allocation Successful", func(t *testing.T) { + p.OnResourceRequirementsMatch(mock.Anything, mock.Anything).Return("ns", core.ResourceConstraintsSpec{}, nil) + a := newTokenAllocator(clck) + gotNewState, _, err := a.allocateToken(ctx, p, tCtx, state, metrics) + assert.NoError(t, err) + if diff := deep.Equal(gotNewState, &State{ + AllocationTokenRequestStartTime: tNow, + Phase: PhaseAllocationTokenAcquired, + }); len(diff) > 0 { + t.Errorf("allocateToken() gotNewState = %v, Diff: %v", gotNewState, diff) + } + }) + + t.Run("Allocation Failed", func(t *testing.T) { + tID := &mocks2.TaskExecutionID{} + tID.EXPECT().GetGeneratedName().Return("abc2") + + tMeta := &mocks2.TaskExecutionMetadata{} + tMeta.EXPECT().GetTaskExecutionID().Return(tID) + + rm := &mocks2.ResourceManager{} + rm.EXPECT().AllocateResource(mock.Anything, core.ResourceNamespace("ns"), "abc2", mock.Anything).Return(core.AllocationStatusExhausted, nil) + + tCtx := &mocks2.TaskExecutionContext{} + tCtx.EXPECT().TaskExecutionMetadata().Return(tMeta) + tCtx.EXPECT().ResourceManager().Return(rm) + + p.OnResourceRequirementsMatch(mock.Anything, mock.Anything).Return("ns", core.ResourceConstraintsSpec{}, nil) + a := newTokenAllocator(clck) + gotNewState, _, err := a.allocateToken(ctx, p, tCtx, state, metrics) + assert.NoError(t, err) + if diff := deep.Equal(gotNewState, &State{ + AllocationTokenRequestStartTime: tNow, + Phase: PhaseNotStarted, + }); len(diff) > 0 { + t.Errorf("allocateToken() gotNewState = %v, Diff: %v", gotNewState, diff) + } + }) +} + +func Test_releaseToken(t *testing.T) { + ctx := context.Background() + metrics := newMetrics(promutils.NewTestScope()) + + clck := testing2.NewFakeClock(time.Now()) + + tID := &mocks2.TaskExecutionID{} + tID.EXPECT().GetGeneratedName().Return("abc") + + tMeta := &mocks2.TaskExecutionMetadata{} + tMeta.EXPECT().GetTaskExecutionID().Return(tID) + + rm := &mocks2.ResourceManager{} + rm.EXPECT().ReleaseResource(mock.Anything, core.ResourceNamespace("ns"), "abc").Return(nil) + + tCtx := &mocks2.TaskExecutionContext{} + tCtx.EXPECT().TaskExecutionMetadata().Return(tMeta) + tCtx.EXPECT().ResourceManager().Return(rm) + + p := newPluginWithProperties(webapi.PluginConfig{ + ResourceQuotas: map[core.ResourceNamespace]int{ + "ns": 1, + }, + }) + p.OnResourceRequirementsMatch(mock.Anything, mock.Anything).Return("ns", core.ResourceConstraintsSpec{}, nil) + + a := newTokenAllocator(clck) + assert.NoError(t, a.releaseToken(ctx, p, tCtx, metrics)) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/internal/webapi/cache.go b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/cache.go new file mode 100644 index 0000000000..553e945878 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/cache.go @@ -0,0 +1,192 @@ +package webapi + +import ( + "context" + "time" + + "golang.org/x/time/rate" + "k8s.io/client-go/util/workqueue" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi" + "github.com/flyteorg/flyte/v2/flytestdlib/autorefreshcache" + stdErrors "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +//go:generate mockery -all -case=underscore + +const ( + BadReturnCodeError stdErrors.ErrorCode = "RETURNED_UNKNOWN" +) + +// Client interface needed for resource cache to fetch latest updates for resources. +type Client interface { + // Get multiple resources that match all the keys. If the plugin hits any failure, it should stop and return + // the failure. This batch will not be processed further. + Get(ctx context.Context, tCtx webapi.GetContext) (latest webapi.Resource, err error) + + // Status checks the status of a given resource and translates it to a Flyte-understandable PhaseInfo. This API + // should avoid making any network calls and should run very efficiently. + Status(ctx context.Context, tCtx webapi.StatusContext) (phase core.PhaseInfo, err error) +} + +// A generic AutoRefresh cache that uses a client to fetch items' status. +type ResourceCache struct { + // AutoRefresh + autorefreshcache.AutoRefresh + client Client + cfg webapi.CachingConfig +} + +// A wrapper for each item in the cache. +type CacheItem struct { + State + Resource webapi.Resource +} + +func (c CacheItem) IsTerminal() bool { + if c.Resource != nil { + if resource, ok := c.Resource.(interface{ IsTerminal() bool }); ok { + return resource.IsTerminal() + } + } + return c.State.Phase.IsTerminal() +} + +// This basically grab an updated status from Client and store it in the cache +// All other handling should be in the synchronous loop. +func (q *ResourceCache) SyncResource(ctx context.Context, batch autorefreshcache.Batch) ( + updatedBatch []autorefreshcache.ItemSyncResponse, err error) { + + resp := make([]autorefreshcache.ItemSyncResponse, 0, len(batch)) + for _, resource := range batch { + // Cast the item back to the thing we want to work with. + cacheItem, ok := resource.GetItem().(CacheItem) + if !ok { + logger.Errorf(ctx, "Sync loop - Error casting cache object into CacheItem") + return nil, errors.Errorf(errors.CacheFailed, "Failed to cast [%v]", batch[0].GetID()) + } + + if len(resource.GetID()) == 0 { + logger.Warnf(ctx, "Sync loop - ResourceKey is blank for [%s] skipping", resource.GetID()) + resp = append(resp, autorefreshcache.ItemSyncResponse{ + ID: resource.GetID(), + Item: resource.GetItem(), + Action: autorefreshcache.Unchanged, + }) + + continue + } + + logger.Debugf(ctx, "Sync loop - processing resource with cache key [%s]", + resource.GetID()) + + if cacheItem.IsTerminal() { + logger.Debugf(ctx, "Sync loop - resource cache key [%v] in terminal state [%s]", + resource.GetID()) + resp = append(resp, autorefreshcache.ItemSyncResponse{ + ID: resource.GetID(), + Item: cacheItem, + Action: autorefreshcache.Unchanged, + }) + + continue + } + + if cacheItem.SyncFailureCount > q.cfg.MaxSystemFailures { + logger.Debugf(ctx, "Sync loop - Item with key [%v] has failed to sync [%v] time(s). More than the allowed [%v] time(s). Marking as failure.", + cacheItem.SyncFailureCount, q.cfg.MaxSystemFailures) + cacheItem.State.Phase = PhaseSystemFailure + resp = append(resp, autorefreshcache.ItemSyncResponse{ + ID: resource.GetID(), + Item: cacheItem, + Action: autorefreshcache.Update, + }) + + continue + } + + // Get an updated status + logger.Debugf(ctx, "Querying AsyncPlugin for %s", resource.GetID()) + newResource, err := q.client.Get(ctx, newPluginContext(cacheItem.ResourceMeta, cacheItem.Resource, "", nil)) + if err != nil { + logger.Infof(ctx, "Error retrieving resource [%s]. Error: %v", resource.GetID(), err) + cacheItem.SyncFailureCount++ + cacheItem.ErrorMessage = err.Error() + + // Make sure we don't return nil for the first argument, because that deletes it from the cache. + resp = append(resp, autorefreshcache.ItemSyncResponse{ + ID: resource.GetID(), + Item: cacheItem, + Action: autorefreshcache.Update, + }) + + continue + } + + cacheItem.Resource = newResource + + resp = append(resp, autorefreshcache.ItemSyncResponse{ + ID: resource.GetID(), + Item: cacheItem, + Action: autorefreshcache.Update, + }) + } + + return resp, nil +} + +// ToPluginPhase translates the more granular task phase into the webapi plugin phase. +func ToPluginPhase(s core.Phase) (Phase, error) { + switch s { + + case core.PhaseUndefined: + fallthrough + case core.PhaseNotReady: + return PhaseNotStarted, nil + case core.PhaseInitializing: + fallthrough + case core.PhaseWaitingForResources: + fallthrough + case core.PhaseQueued: + fallthrough + case core.PhaseRunning: + return PhaseResourcesCreated, nil + case core.PhaseSuccess: + return PhaseSucceeded, nil + case core.PhasePermanentFailure: + fallthrough + case core.PhaseRetryableFailure: + return PhaseUserFailure, nil + default: + return PhaseSystemFailure, errors.Errorf(BadReturnCodeError, "default fallthrough case") + } +} + +func NewResourceCache(ctx context.Context, name string, client Client, cfg webapi.CachingConfig, + rateCfg webapi.RateLimiterConfig, + scope promutils.Scope) (ResourceCache, error) { + + q := ResourceCache{ + client: client, + cfg: cfg, + } + + autoRefreshCache, err := autorefreshcache.NewAutoRefreshCache(name, q.SyncResource, + workqueue.NewMaxOfRateLimiter( + workqueue.NewItemExponentialFailureRateLimiter(5*time.Millisecond, 1000*time.Second), + &workqueue.BucketRateLimiter{Limiter: rate.NewLimiter(rate.Limit(rateCfg.QPS), rateCfg.Burst)}, + ), cfg.ResyncInterval.Duration, cfg.Workers, cfg.Size, + scope.NewSubScope("cache")) + + if err != nil { + logger.Errorf(ctx, "Could not create AutoRefreshCache. Error: [%s]", err) + return q, errors.Wrapf(errors.CacheFailed, err, "Error creating AutoRefreshCache") + } + + q.AutoRefresh = autoRefreshCache + return q, nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/internal/webapi/cache_test.go b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/cache_test.go new file mode 100644 index 0000000000..86d0120d3b --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/cache_test.go @@ -0,0 +1,194 @@ +package webapi + +import ( + "context" + "fmt" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/internal/webapi/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi" + "github.com/flyteorg/flyte/v2/flytestdlib/autorefreshcache" + cacheMocks "github.com/flyteorg/flyte/v2/flytestdlib/autorefreshcache/mocks" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +func TestNewResourceCache(t *testing.T) { + t.Run("Simple", func(t *testing.T) { + c, err := NewResourceCache(context.Background(), "Cache1", &mocks.Client{}, webapi.CachingConfig{ + Size: 10, + }, webapi.RateLimiterConfig{QPS: 1, Burst: 1}, promutils.NewTestScope()) + assert.NoError(t, err) + assert.NotNil(t, c) + }) + + t.Run("Error", func(t *testing.T) { + _, err := NewResourceCache(context.Background(), "Cache1", &mocks.Client{}, webapi.CachingConfig{}, + webapi.RateLimiterConfig{}, + promutils.NewTestScope()) + assert.Error(t, err) + }) +} + +func TestResourceCache_SyncResource(t *testing.T) { + ctx := context.Background() + + t.Run("Terminal state return unchanged", func(t *testing.T) { + mockCache := &cacheMocks.AutoRefresh{} + mockClient := &mocks.Client{} + + q := ResourceCache{ + AutoRefresh: mockCache, + client: mockClient, + cfg: webapi.CachingConfig{ + MaxSystemFailures: 5, + }, + } + + state := State{ + Phase: PhaseSucceeded, + } + + cacheItem := CacheItem{ + State: state, + } + + iw := &cacheMocks.ItemWrapper{} + iw.OnGetItem().Return(cacheItem) + iw.OnGetID().Return("some-id") + + newCacheItem, err := q.SyncResource(ctx, []autorefreshcache.ItemWrapper{iw}) + assert.NoError(t, err) + assert.Equal(t, autorefreshcache.Unchanged, newCacheItem[0].Action) + assert.Equal(t, cacheItem, newCacheItem[0].Item) + }) + + t.Run("Retry limit exceeded", func(t *testing.T) { + mockCache := &cacheMocks.AutoRefresh{} + mockClient := &mocks.Client{} + + q := ResourceCache{ + AutoRefresh: mockCache, + client: mockClient, + cfg: webapi.CachingConfig{ + MaxSystemFailures: 2, + }, + } + + cacheItem := CacheItem{ + State: State{ + SyncFailureCount: 5, + ErrorMessage: "some error", + }, + } + + iw := &cacheMocks.ItemWrapper{} + iw.OnGetItem().Return(cacheItem) + iw.OnGetID().Return("some-id") + + newCacheItem, err := q.SyncResource(ctx, []autorefreshcache.ItemWrapper{iw}) + assert.NoError(t, err) + assert.Equal(t, autorefreshcache.Update, newCacheItem[0].Action) + cacheItem.State.Phase = PhaseSystemFailure + assert.Equal(t, cacheItem, newCacheItem[0].Item) + }) + + t.Run("move to success", func(t *testing.T) { + mockCache := &cacheMocks.AutoRefresh{} + mockClient := &mocks.Client{} + q := ResourceCache{ + AutoRefresh: mockCache, + client: mockClient, + cfg: webapi.CachingConfig{ + MaxSystemFailures: 5, + }, + } + + state := State{ + ResourceMeta: "123456", + Phase: PhaseResourcesCreated, + } + + cacheItem := CacheItem{ + State: state, + } + + mockClient.OnGet(ctx, newPluginContext("123456", nil, "", nil)).Return("newID", nil) + mockClient.OnStatusMatch(mock.Anything, "newID", mock.Anything).Return(core.PhaseInfoSuccess(nil), nil) + + iw := &cacheMocks.ItemWrapper{} + iw.OnGetItem().Return(cacheItem) + iw.OnGetID().Return("some-id") + + newCacheItem, err := q.SyncResource(ctx, []autorefreshcache.ItemWrapper{iw}) + assert.NoError(t, err) + assert.Equal(t, autorefreshcache.Update, newCacheItem[0].Action) + }) + + t.Run("Failing to retrieve latest", func(t *testing.T) { + mockCache := &cacheMocks.AutoRefresh{} + mockClient := &mocks.Client{} + + q := ResourceCache{ + AutoRefresh: mockCache, + client: mockClient, + cfg: webapi.CachingConfig{ + MaxSystemFailures: 5, + }, + } + + state := State{ + ResourceMeta: "123456", + Phase: PhaseResourcesCreated, + } + + cacheItem := CacheItem{ + State: state, + } + + mockClient.OnGet(ctx, newPluginContext("123456", nil, "", nil)).Return("newID", fmt.Errorf("failed to retrieve resource")) + + iw := &cacheMocks.ItemWrapper{} + iw.OnGetItem().Return(cacheItem) + iw.OnGetID().Return("some-id") + + newCacheItem, err := q.SyncResource(ctx, []autorefreshcache.ItemWrapper{iw}) + newExecutionState := newCacheItem[0].Item.(CacheItem) + assert.NoError(t, err) + assert.Equal(t, autorefreshcache.Update, newCacheItem[0].Action) + assert.Equal(t, PhaseResourcesCreated, newExecutionState.Phase) + }) +} + +func TestToPluginPhase(t *testing.T) { + tests := []struct { + args core.Phase + want Phase + wantErr bool + }{ + {core.PhaseNotReady, PhaseNotStarted, false}, + {core.PhaseUndefined, PhaseNotStarted, false}, + {core.PhaseInitializing, PhaseResourcesCreated, false}, + {core.PhaseWaitingForResources, PhaseResourcesCreated, false}, + {core.PhaseQueued, PhaseResourcesCreated, false}, + {core.PhaseRunning, PhaseResourcesCreated, false}, + {core.PhaseSuccess, PhaseSucceeded, false}, + {core.PhasePermanentFailure, PhaseUserFailure, false}, + {core.PhaseRetryableFailure, PhaseUserFailure, false}, + } + for _, tt := range tests { + t.Run(tt.args.String(), func(t *testing.T) { + got, err := ToPluginPhase(tt.args) + if (err != nil) != tt.wantErr { + t.Errorf("ToPluginPhase() error = %v, wantErr %v", err, tt.wantErr) + return + } + if got != tt.want { + t.Errorf("ToPluginPhase() got = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/internal/webapi/core.go b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/core.go new file mode 100644 index 0000000000..650c2db464 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/core.go @@ -0,0 +1,224 @@ +package webapi + +import ( + "context" + "encoding/gob" + "fmt" + "time" + + "k8s.io/utils/clock" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi" + "github.com/flyteorg/flyte/v2/flytestdlib/autorefreshcache" + stdErrs "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +const ( + pluginStateVersion = 1 + minCacheSize = 10 + maxCacheSize = 500000 + minWorkers = 1 + maxWorkers = 10000 + minSyncDuration = 5 * time.Second + maxSyncDuration = time.Hour + minBurst = 5 + maxBurst = 10000 + minQPS = 1 + maxQPS = 100000 +) + +type CorePlugin struct { + id string + p webapi.AsyncPlugin + cache autorefreshcache.AutoRefresh + tokenAllocator tokenAllocator + metrics Metrics +} + +func (c CorePlugin) unmarshalState(ctx context.Context, stateReader core.PluginStateReader) (State, error) { + t := c.metrics.SucceededUnmarshalState.Start(ctx) + existingState := State{} + + // We assume here that the first time this function is called, the custom state we get back is whatever we passed in, + // namely the zero-value of our struct. + if _, err := stateReader.Get(&existingState); err != nil { + c.metrics.FailedUnmarshalState.Inc(ctx) + logger.Errorf(ctx, "AsyncPlugin [%v] failed to unmarshal custom state. Error: %v", + c.GetID(), err) + + return State{}, errors.Wrapf(errors.CorruptedPluginState, err, + "Failed to unmarshal custom state in Handle") + } + + t.Stop() + return existingState, nil +} + +func (c CorePlugin) GetID() string { + return c.id +} + +func (c CorePlugin) GetProperties() core.PluginProperties { + return core.PluginProperties{} +} + +func (c CorePlugin) Handle(ctx context.Context, tCtx core.TaskExecutionContext) (core.Transition, error) { + incomingState, err := c.unmarshalState(ctx, tCtx.PluginStateReader()) + if err != nil { + return core.UnknownTransition, err + } + + var nextState *State + var phaseInfo core.PhaseInfo + + switch incomingState.Phase { + case PhaseNotStarted: + if len(c.p.GetConfig().ResourceQuotas) > 0 { + nextState, phaseInfo, err = c.tokenAllocator.allocateToken(ctx, c.p, tCtx, &incomingState, c.metrics) + } else { + nextState, phaseInfo, err = launch(ctx, c.p, tCtx, c.cache, &incomingState) + } + case PhaseAllocationTokenAcquired: + nextState, phaseInfo, err = launch(ctx, c.p, tCtx, c.cache, &incomingState) + case PhaseResourcesCreated: + nextState, phaseInfo, err = monitor(ctx, tCtx, c.p, c.cache, &incomingState) + } + + if err != nil { + return core.UnknownTransition, err + } + + if err := tCtx.PluginStateWriter().Put(pluginStateVersion, nextState); err != nil { + return core.UnknownTransition, err + } + + return core.DoTransition(phaseInfo), nil +} + +func (c CorePlugin) Abort(ctx context.Context, tCtx core.TaskExecutionContext) error { + incomingState, err := c.unmarshalState(ctx, tCtx.PluginStateReader()) + if err != nil { + return err + } + + logger.Infof(ctx, "Attempting to abort resource [%v].", tCtx.TaskExecutionMetadata().GetTaskExecutionID().GetID()) + + err = c.p.Delete(ctx, newPluginContext(incomingState.ResourceMeta, nil, "Aborted", tCtx)) + if err != nil { + logger.Errorf(ctx, "Failed to abort some resources [%v]. Error: %v", + tCtx.TaskExecutionMetadata().GetTaskExecutionID().GetGeneratedName(), err) + return err + } + + return nil +} + +func (c CorePlugin) Finalize(ctx context.Context, tCtx core.TaskExecutionContext) error { + cacheItemID := tCtx.TaskExecutionMetadata().GetTaskExecutionID().GetGeneratedName() + err := c.cache.DeleteDelayed(cacheItemID) + if err != nil { + logger.Errorf(ctx, "Failed to delete resource [%v] from cache. Error: %v", cacheItemID, err) + return fmt.Errorf("failed to delete resource [%v] from cache. Error: %v", cacheItemID, err) + } + + if len(c.p.GetConfig().ResourceQuotas) == 0 { + // If there are no defined quotas, there is nothing to cleanup. + return nil + } + + logger.Infof(ctx, "Attempting to finalize resource [%v].", cacheItemID) + + return c.tokenAllocator.releaseToken(ctx, c.p, tCtx, c.metrics) +} + +func validateRangeInt(fieldName string, min, max, provided int) error { + if provided > max || provided < min { + return fmt.Errorf("%v is expected to be between %v and %v. Provided value is %v", + fieldName, min, max, provided) + } + + return nil +} + +func validateRangeFloat64(fieldName string, min, max, provided float64) error { + if provided > max || provided < min { + return fmt.Errorf("%v is expected to be between %v and %v. Provided value is %v", + fieldName, min, max, provided) + } + + return nil +} + +func validateConfig(cfg webapi.PluginConfig) error { + errs := stdErrs.ErrorCollection{} + errs.Append(validateRangeInt("cache size", minCacheSize, maxCacheSize, cfg.Caching.Size)) + errs.Append(validateRangeInt("workers count", minWorkers, maxWorkers, cfg.Caching.Workers)) + errs.Append(validateRangeFloat64("resync interval", minSyncDuration.Seconds(), maxSyncDuration.Seconds(), cfg.Caching.ResyncInterval.Seconds())) + errs.Append(validateRangeInt("read burst", minBurst, maxBurst, cfg.ReadRateLimiter.Burst)) + errs.Append(validateRangeInt("read qps", minQPS, maxQPS, cfg.ReadRateLimiter.QPS)) + errs.Append(validateRangeInt("write burst", minBurst, maxBurst, cfg.WriteRateLimiter.Burst)) + errs.Append(validateRangeInt("write qps", minQPS, maxQPS, cfg.WriteRateLimiter.QPS)) + + return errs.ErrorOrDefault() +} + +func createRemotePlugin(pluginEntry webapi.PluginEntry, c clock.Clock) core.PluginEntry { + return core.PluginEntry{ + ID: pluginEntry.ID, + RegisteredTaskTypes: pluginEntry.SupportedTaskTypes, + LoadPlugin: func(ctx context.Context, iCtx core.SetupContext) ( + core.Plugin, error) { + p, err := pluginEntry.PluginLoader(ctx, iCtx) + if err != nil { + return nil, err + } + + err = validateConfig(p.GetConfig()) + if err != nil { + return nil, fmt.Errorf("config validation failed. Error: %w", err) + } + + // If the plugin will use a custom state, register it to be able to + // serialize/deserialize interfaces later. + if customState := p.GetConfig().ResourceMeta; customState != nil { + gob.Register(customState) + } + + if quotas := p.GetConfig().ResourceQuotas; len(quotas) > 0 { + for ns, quota := range quotas { + err := iCtx.ResourceRegistrar().RegisterResourceQuota(ctx, ns, quota) + if err != nil { + return nil, err + } + } + } + + resourceCache, err := NewResourceCache(ctx, pluginEntry.ID, p, p.GetConfig().Caching, + p.GetConfig().ReadRateLimiter, iCtx.MetricsScope().NewSubScope("cache")) + + if err != nil { + return nil, err + } + + err = resourceCache.Start(ctx) + if err != nil { + return nil, err + } + + return CorePlugin{ + id: pluginEntry.ID, + p: p, + cache: resourceCache, + metrics: newMetrics(iCtx.MetricsScope()), + tokenAllocator: newTokenAllocator(c), + }, nil + }, + } +} + +func CreateRemotePlugin(pluginEntry webapi.PluginEntry) core.PluginEntry { + return createRemotePlugin(pluginEntry, clock.RealClock{}) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/internal/webapi/core_test.go b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/core_test.go new file mode 100644 index 0000000000..8a99a4419d --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/core_test.go @@ -0,0 +1,95 @@ +package webapi + +import ( + "context" + "testing" + "time" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi" + "github.com/flyteorg/flyte/v2/flytestdlib/config" +) + +func Test_validateConfig(t *testing.T) { + t.Run("In range", func(t *testing.T) { + cfg := webapi.PluginConfig{ + ReadRateLimiter: webapi.RateLimiterConfig{ + QPS: 10, + Burst: 100, + }, + WriteRateLimiter: webapi.RateLimiterConfig{ + QPS: 10, + Burst: 100, + }, + Caching: webapi.CachingConfig{ + Size: 10, + ResyncInterval: config.Duration{Duration: 10 * time.Second}, + Workers: 10, + }, + } + + assert.NoError(t, validateConfig(cfg)) + }) + + t.Run("Below min", func(t *testing.T) { + cfg := webapi.PluginConfig{ + ReadRateLimiter: webapi.RateLimiterConfig{ + QPS: 0, + Burst: 0, + }, + WriteRateLimiter: webapi.RateLimiterConfig{ + QPS: 0, + Burst: 0, + }, + Caching: webapi.CachingConfig{ + Size: 0, + ResyncInterval: config.Duration{Duration: 0 * time.Second}, + Workers: 0, + }, + } + + err := validateConfig(cfg) + assert.Error(t, err) + assert.Equal(t, "\ncache size is expected to be between 10 and 500000. Provided value is 0\nworkers count is expected to be between 1 and 10000. Provided value is 0\nresync interval is expected to be between 5 and 3600. Provided value is 0\nread burst is expected to be between 5 and 10000. Provided value is 0\nread qps is expected to be between 1 and 100000. Provided value is 0\nwrite burst is expected to be between 5 and 10000. Provided value is 0\nwrite qps is expected to be between 1 and 100000. Provided value is 0", err.Error()) + }) + + t.Run("Above max", func(t *testing.T) { + cfg := webapi.PluginConfig{ + ReadRateLimiter: webapi.RateLimiterConfig{ + QPS: 1000, + Burst: 1000000, + }, + WriteRateLimiter: webapi.RateLimiterConfig{ + QPS: 1000, + Burst: 1000000, + }, + Caching: webapi.CachingConfig{ + Size: 1000000000, + ResyncInterval: config.Duration{Duration: 10000 * time.Hour}, + Workers: 1000000000, + }, + } + + err := validateConfig(cfg) + assert.Error(t, err) + assert.Equal(t, "\ncache size is expected to be between 10 and 500000. Provided value is 1000000000\nworkers count is expected to be between 1 and 10000. Provided value is 1000000000\nresync interval is expected to be between 5 and 3600. Provided value is 3.6e+07\nread burst is expected to be between 5 and 10000. Provided value is 1000000\nwrite burst is expected to be between 5 and 10000. Provided value is 1000000", err.Error()) + }) +} + +func TestCreateRemotePlugin(t *testing.T) { + CreateRemotePlugin(webapi.PluginEntry{ + ID: "MyTestPlugin", + SupportedTaskTypes: []core.TaskType{"test-task"}, + PluginLoader: func(ctx context.Context, iCtx webapi.PluginSetupContext) (webapi.AsyncPlugin, error) { + return newPluginWithProperties(webapi.PluginConfig{ + Caching: webapi.CachingConfig{ + Size: 10, + }, + }), nil + }, + IsDefault: false, + DefaultForTaskTypes: []core.TaskType{"test-task"}, + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/internal/webapi/launcher.go b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/launcher.go new file mode 100644 index 0000000000..76e8b41fe3 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/launcher.go @@ -0,0 +1,55 @@ +package webapi + +import ( + "context" + "time" + + pluginErrors "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi" + "github.com/flyteorg/flyte/v2/flytestdlib/autorefreshcache" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +func launch(ctx context.Context, p webapi.AsyncPlugin, tCtx core.TaskExecutionContext, cache autorefreshcache.AutoRefresh, + state *State) (newState *State, phaseInfo core.PhaseInfo, err error) { + rMeta, r, err := p.Create(ctx, tCtx) + if err != nil { + logger.Errorf(ctx, "Failed to create resourceeeeee. Error: %v", err) + return state, core.PhaseInfoRetryableFailure(pluginErrors.TaskFailedWithError, err.Error(), nil), nil + } + + // If the plugin also returned the created resource, check to see if it's already in a terminal state. + logger.Infof(ctx, "Created Resource Name [%s] and Meta [%v]", tCtx.TaskExecutionMetadata().GetTaskExecutionID().GetGeneratedName(), rMeta) + if r != nil { + phase, err := p.Status(ctx, newPluginContext(rMeta, r, "", tCtx)) + if err != nil { + logger.Errorf(ctx, "Failed to check resource status. Error: %v", err) + return nil, core.PhaseInfo{}, err + } + + if phase.Phase().IsTerminal() { + logger.Infof(ctx, "Resource has already terminated ID:[%s], Phase:[%s]", + tCtx.TaskExecutionMetadata().GetTaskExecutionID().GetGeneratedName(), phase.Phase()) + return state, phase, nil + } + } + + // Store the created resource name, and update our state. + state.ResourceMeta = rMeta + state.Phase = PhaseResourcesCreated + state.PhaseVersion = 2 + + cacheItem := CacheItem{ + State: *state, + } + + // Also, add to the AutoRefreshCache so we start getting updates through background refresh. + _, err = cache.GetOrCreate(tCtx.TaskExecutionMetadata().GetTaskExecutionID().GetGeneratedName(), cacheItem) + if err != nil { + logger.Errorf(ctx, "Failed to add item to cache. Error: %v", err) + return nil, core.PhaseInfo{}, err + } + + return state, core.PhaseInfoQueued(time.Now(), state.PhaseVersion, "launched"), nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/internal/webapi/launcher_test.go b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/launcher_test.go new file mode 100644 index 0000000000..0ecd91e3aa --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/launcher_test.go @@ -0,0 +1,112 @@ +package webapi + +import ( + "context" + "fmt" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi" + mocks2 "github.com/flyteorg/flyte/v2/flytestdlib/autorefreshcache/mocks" +) + +func Test_launch(t *testing.T) { + t.Run("Successful launch", func(t *testing.T) { + ctx := context.Background() + tCtx := &mocks.TaskExecutionContext{} + meta := &mocks.TaskExecutionMetadata{} + taskID := &mocks.TaskExecutionID{} + taskID.EXPECT().GetGeneratedName().Return("my-id") + meta.EXPECT().GetTaskExecutionID().Return(taskID) + tCtx.EXPECT().TaskExecutionMetadata().Return(meta) + + c := &mocks2.AutoRefresh{} + s := State{ + ResourceMeta: "abc", + Phase: PhaseResourcesCreated, + PhaseVersion: 2, + } + c.OnGetOrCreate("my-id", CacheItem{State: s}).Return(CacheItem{State: s}, nil) + + plgn := newPluginWithProperties(webapi.PluginConfig{}) + plgn.OnCreate(ctx, tCtx).Return("abc", nil, nil) + plgn.OnStatus(ctx, newPluginContext("abc", nil, "", tCtx)).Return(core.PhaseInfoSuccess(nil), nil) + newS, phaseInfo, err := launch(ctx, plgn, tCtx, c, &s) + assert.NoError(t, err) + assert.NotNil(t, newS) + assert.NotNil(t, phaseInfo) + }) + + t.Run("Already succeeded when launched", func(t *testing.T) { + ctx := context.Background() + tCtx := &mocks.TaskExecutionContext{} + meta := &mocks.TaskExecutionMetadata{} + taskID := &mocks.TaskExecutionID{} + taskID.EXPECT().GetGeneratedName().Return("my-id") + meta.EXPECT().GetTaskExecutionID().Return(taskID) + tCtx.EXPECT().TaskExecutionMetadata().Return(meta) + + c := &mocks2.AutoRefresh{} + s := State{ + Phase: PhaseResourcesCreated, + PhaseVersion: 2, + ResourceMeta: "abc", + } + + plgn := newPluginWithProperties(webapi.PluginConfig{}) + plgn.OnCreate(ctx, tCtx).Return("abc", "abc-r", nil) + plgn.OnStatus(ctx, newPluginContext("abc", "abc-r", "", tCtx)).Return(core.PhaseInfoSuccess(nil), nil) + newS, phaseInfo, err := launch(ctx, plgn, tCtx, c, &s) + assert.NoError(t, err) + assert.NotNil(t, newS) + assert.NotNil(t, phaseInfo) + assert.Equal(t, core.PhaseSuccess, phaseInfo.Phase()) + }) + + t.Run("Failed to create resource", func(t *testing.T) { + ctx := context.Background() + tCtx := &mocks.TaskExecutionContext{} + meta := &mocks.TaskExecutionMetadata{} + taskID := &mocks.TaskExecutionID{} + taskID.EXPECT().GetGeneratedName().Return("my-id") + meta.EXPECT().GetTaskExecutionID().Return(taskID) + tCtx.EXPECT().TaskExecutionMetadata().Return(meta) + + c := &mocks2.AutoRefresh{} + s := State{} + c.OnGetOrCreate("my-id", CacheItem{State: s}).Return(CacheItem{State: s}, nil) + + plgn := newPluginWithProperties(webapi.PluginConfig{}) + plgn.OnCreate(ctx, tCtx).Return("", nil, fmt.Errorf("error creating")) + _, phase, err := launch(ctx, plgn, tCtx, c, &s) + assert.Nil(t, err) + assert.Equal(t, core.PhaseRetryableFailure, phase.Phase()) + }) + + t.Run("Failed to cache", func(t *testing.T) { + ctx := context.Background() + tCtx := &mocks.TaskExecutionContext{} + meta := &mocks.TaskExecutionMetadata{} + taskID := &mocks.TaskExecutionID{} + taskID.EXPECT().GetGeneratedName().Return("my-id") + meta.EXPECT().GetTaskExecutionID().Return(taskID) + tCtx.EXPECT().TaskExecutionMetadata().Return(meta) + + c := &mocks2.AutoRefresh{} + s := State{ + Phase: PhaseResourcesCreated, + PhaseVersion: 2, + ResourceMeta: "my-id", + } + c.OnGetOrCreate("my-id", CacheItem{State: s}).Return(CacheItem{State: s}, fmt.Errorf("failed to cache")) + + plgn := newPluginWithProperties(webapi.PluginConfig{}) + plgn.OnCreate(ctx, tCtx).Return("my-id", nil, nil) + plgn.OnStatus(ctx, newPluginContext("my-id", nil, "", tCtx)).Return(core.PhaseInfoRunning(0, nil), nil) + _, _, err := launch(ctx, plgn, tCtx, c, &s) + assert.Error(t, err) + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/internal/webapi/metrics.go b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/metrics.go new file mode 100644 index 0000000000..e59be1d4fd --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/metrics.go @@ -0,0 +1,45 @@ +package webapi + +import ( + "time" + + "github.com/prometheus/client_golang/prometheus" + + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils/labeled" +) + +type Metrics struct { + Scope promutils.Scope + ResourceReleased labeled.Counter + ResourceReleaseFailed labeled.Counter + AllocationGranted labeled.Counter + AllocationNotGranted labeled.Counter + ResourceWaitTime prometheus.Summary + SucceededUnmarshalState labeled.StopWatch + FailedUnmarshalState labeled.Counter +} + +var ( + tokenAgeObjectives = map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001, 1.0: 0.0} +) + +func newMetrics(scope promutils.Scope) Metrics { + return Metrics{ + Scope: scope, + ResourceReleased: labeled.NewCounter("resource_release_success", + "Resource allocation token released", scope, labeled.EmitUnlabeledMetric), + ResourceReleaseFailed: labeled.NewCounter("resource_release_failed", + "Error releasing allocation token", scope, labeled.EmitUnlabeledMetric), + AllocationGranted: labeled.NewCounter("allocation_grant_success", + "Allocation request granted", scope, labeled.EmitUnlabeledMetric), + AllocationNotGranted: labeled.NewCounter("allocation_grant_failed", + "Allocation request did not fail but not granted", scope, labeled.EmitUnlabeledMetric), + ResourceWaitTime: scope.MustNewSummaryWithOptions("resource_wait_time", "Duration the execution has been waiting for a resource allocation token", + promutils.SummaryOptions{Objectives: tokenAgeObjectives}), + SucceededUnmarshalState: labeled.NewStopWatch("unmarshal_state_success", "Successfully unmarshaled state", + time.Millisecond, scope), + FailedUnmarshalState: labeled.NewCounter("unmarshal_state_failed", + "Failed to unmarshal state", scope, labeled.EmitUnlabeledMetric), + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/internal/webapi/mocks/client.go b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/mocks/client.go new file mode 100644 index 0000000000..ea4cd09c7d --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/mocks/client.go @@ -0,0 +1,98 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + context "context" + + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + + mock "github.com/stretchr/testify/mock" + + webapi "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi" +) + +// Client is an autogenerated mock type for the Client type +type Client struct { + mock.Mock +} + +type Client_Get struct { + *mock.Call +} + +func (_m Client_Get) Return(latest interface{}, err error) *Client_Get { + return &Client_Get{Call: _m.Call.Return(latest, err)} +} + +func (_m *Client) OnGet(ctx context.Context, tCtx webapi.GetContext) *Client_Get { + c_call := _m.On("Get", ctx, tCtx) + return &Client_Get{Call: c_call} +} + +func (_m *Client) OnGetMatch(matchers ...interface{}) *Client_Get { + c_call := _m.On("Get", matchers...) + return &Client_Get{Call: c_call} +} + +// Get provides a mock function with given fields: ctx, tCtx +func (_m *Client) Get(ctx context.Context, tCtx webapi.GetContext) (interface{}, error) { + ret := _m.Called(ctx, tCtx) + + var r0 interface{} + if rf, ok := ret.Get(0).(func(context.Context, webapi.GetContext) interface{}); ok { + r0 = rf(ctx, tCtx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interface{}) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, webapi.GetContext) error); ok { + r1 = rf(ctx, tCtx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +type Client_Status struct { + *mock.Call +} + +func (_m Client_Status) Return(phase core.PhaseInfo, err error) *Client_Status { + return &Client_Status{Call: _m.Call.Return(phase, err)} +} + +func (_m *Client) OnStatus(ctx context.Context, tCtx webapi.StatusContext) *Client_Status { + c_call := _m.On("Status", ctx, tCtx) + return &Client_Status{Call: c_call} +} + +func (_m *Client) OnStatusMatch(matchers ...interface{}) *Client_Status { + c_call := _m.On("Status", matchers...) + return &Client_Status{Call: c_call} +} + +// Status provides a mock function with given fields: ctx, tCtx +func (_m *Client) Status(ctx context.Context, tCtx webapi.StatusContext) (core.PhaseInfo, error) { + ret := _m.Called(ctx, tCtx) + + var r0 core.PhaseInfo + if rf, ok := ret.Get(0).(func(context.Context, webapi.StatusContext) core.PhaseInfo); ok { + r0 = rf(ctx, tCtx) + } else { + r0 = ret.Get(0).(core.PhaseInfo) + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, webapi.StatusContext) error); ok { + r1 = rf(ctx, tCtx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/internal/webapi/monitor.go b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/monitor.go new file mode 100644 index 0000000000..2d7726b05c --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/monitor.go @@ -0,0 +1,73 @@ +package webapi + +import ( + "context" + "time" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flytestdlib/autorefreshcache" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +func monitor(ctx context.Context, tCtx core.TaskExecutionContext, p Client, cache autorefreshcache.AutoRefresh, state *State) ( + newState *State, phaseInfo core.PhaseInfo, err error) { + newCacheItem := CacheItem{ + State: *state, + } + + cacheItemID := tCtx.TaskExecutionMetadata().GetTaskExecutionID().GetGeneratedName() + item, err := cache.GetOrCreate(cacheItemID, newCacheItem) + if err != nil { + return nil, core.PhaseInfo{}, err + } + + cacheItem, ok := item.(CacheItem) + if !ok { + logger.Errorf(ctx, "Error casting cache object into ExecutionState") + return nil, core.PhaseInfo{}, errors.Errorf( + errors.CacheFailed, "Failed to cast [%v]", cacheItem) + } + + // If the cache has not synced yet, just return + if cacheItem.Resource == nil { + if cacheItem.Phase.IsTerminal() { + err = cache.DeleteDelayed(cacheItemID) + if err != nil { + logger.Errorf(ctx, "Failed to queue item for deletion in the cache with Item Id: [%v]. Error: %v", + cacheItemID, err) + } + return state, core.PhaseInfoFailure(errors.CacheFailed, cacheItem.ErrorMessage, nil), nil + } + return state, core.PhaseInfoQueued(time.Now(), cacheItem.PhaseVersion, "job submitted"), nil + } + + newPhase, err := p.Status(ctx, newPluginContext(cacheItem.ResourceMeta, cacheItem.Resource, "", tCtx)) + if err != nil { + return nil, core.PhaseInfoUndefined, err + } + + newPluginPhase, err := ToPluginPhase(newPhase.Phase()) + if err != nil { + return nil, core.PhaseInfoUndefined, err + } + + if cacheItem.Phase != newPluginPhase { + logger.Infof(ctx, "Moving Phase for from %s to %s", cacheItem.Phase, newPluginPhase) + } + + cacheItem.Phase = newPluginPhase + cacheItem.PhaseVersion = newPhase.Version() + + if newPluginPhase.IsTerminal() { + // Queue item for deletion in the cache. + err = cache.DeleteDelayed(cacheItemID) + if err != nil { + logger.Errorf(ctx, "Failed to queue item for deletion in the cache with Item Id: [%v]. Error: %v", + cacheItemID, err) + } + } + + // If there were updates made to the state, we'll have picked them up automatically. Nothing more to do. + return &cacheItem.State, newPhase, nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/internal/webapi/monitor_test.go b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/monitor_test.go new file mode 100644 index 0000000000..a676c5862e --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/monitor_test.go @@ -0,0 +1,78 @@ +package webapi + +import ( + "context" + "sync" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "k8s.io/apimachinery/pkg/util/rand" + "k8s.io/client-go/util/workqueue" + + core2 "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + internalMocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/internal/webapi/mocks" + "github.com/flyteorg/flyte/v2/flytestdlib/autorefreshcache" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func Test_monitor(t *testing.T) { + ctx := context.Background() + ctx, cancel := context.WithCancel(ctx) + tCtx := &mocks.TaskExecutionContext{} + ctxMeta := &mocks.TaskExecutionMetadata{} + execID := &mocks.TaskExecutionID{} + execID.On("GetGeneratedName").Return("generated_name") + execID.On("GetID").Return(core.TaskExecutionIdentifier{}) + ctxMeta.On("GetTaskExecutionID").Return(execID) + tCtx.On("TaskExecutionMetadata").Return(ctxMeta) + + client := &internalMocks.Client{} + client.OnStatusMatch(ctx, mock.Anything).Return(core2.PhaseInfoSuccess(nil), nil) + + wg := sync.WaitGroup{} + wg.Add(8) + cacheObj, err := autorefreshcache.NewAutoRefreshCache(rand.String(5), func(ctx context.Context, batch autorefreshcache.Batch) (updatedBatch []autorefreshcache.ItemSyncResponse, err error) { + wg.Done() + t.Logf("Syncing Item [%+v]", batch[0]) + return []autorefreshcache.ItemSyncResponse{ + { + ID: batch[0].GetID(), + Item: batch[0].GetItem(), + Action: autorefreshcache.Update, + }, + }, nil + }, workqueue.DefaultControllerRateLimiter(), time.Second, 1, 10, promutils.NewTestScope()) + assert.NoError(t, err) + + assert.NoError(t, cacheObj.Start(ctx)) + + // Insert a dummy item to make sure the sync loop keeps getting invoked + _, err = cacheObj.GetOrCreate("generated_name2", CacheItem{Resource: "fake_resource2"}) + assert.NoError(t, err) + + _, err = cacheObj.GetOrCreate("generated_name", CacheItem{Resource: "fake_resource"}) + assert.NoError(t, err) + + s := &State{} + newState, phaseInfo, err := monitor(ctx, tCtx, client, cacheObj, s) + assert.NoError(t, err) + assert.NotNil(t, newState) + assert.NotNil(t, phaseInfo) + assert.Equal(t, core2.PhaseSuccess.String(), phaseInfo.Phase().String()) + + // Make sure the item is still in the cache as is... + cachedItem, err := cacheObj.GetOrCreate("generated_name", CacheItem{Resource: "shouldnt_insert"}) + assert.NoError(t, err) + assert.Equal(t, "fake_resource", cachedItem.(CacheItem).Resource.(string)) + + // Wait for sync to run to actually delete the resource + wg.Wait() + cancel() + cachedItem, err = cacheObj.GetOrCreate("generated_name", CacheItem{Resource: "new_resource"}) + assert.NoError(t, err) + assert.Equal(t, "new_resource", cachedItem.(CacheItem).Resource.(string)) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/internal/webapi/phase_enumer.go b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/phase_enumer.go new file mode 100644 index 0000000000..9eff931df6 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/phase_enumer.go @@ -0,0 +1,53 @@ +// Code generated by "enumer -type=Phase -trimprefix=Phase"; DO NOT EDIT. + +package webapi + +import ( + "fmt" +) + +const _PhaseName = "NotStartedAllocationTokenAcquiredResourcesCreatedSucceededUserFailureSystemFailure" + +var _PhaseIndex = [...]uint8{0, 10, 33, 49, 58, 69, 82} + +func (i Phase) String() string { + if i < 0 || i >= Phase(len(_PhaseIndex)-1) { + return fmt.Sprintf("Phase(%d)", i) + } + return _PhaseName[_PhaseIndex[i]:_PhaseIndex[i+1]] +} + +var _PhaseValues = []Phase{0, 1, 2, 3, 4, 5} + +var _PhaseNameToValueMap = map[string]Phase{ + _PhaseName[0:10]: 0, + _PhaseName[10:33]: 1, + _PhaseName[33:49]: 2, + _PhaseName[49:58]: 3, + _PhaseName[58:69]: 4, + _PhaseName[69:82]: 5, +} + +// PhaseString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func PhaseString(s string) (Phase, error) { + if val, ok := _PhaseNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to Phase values", s) +} + +// PhaseValues returns all values of the enum +func PhaseValues() []Phase { + return _PhaseValues +} + +// IsAPhase returns "true" if the value is listed in the enum definition. "false" otherwise +func (i Phase) IsAPhase() bool { + for _, v := range _PhaseValues { + if i == v { + return true + } + } + return false +} diff --git a/flyteplugins/go/tasks/pluginmachinery/internal/webapi/plugin_context.go b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/plugin_context.go new file mode 100644 index 0000000000..75d20dfd27 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/plugin_context.go @@ -0,0 +1,34 @@ +package webapi + +import ( + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi" +) + +type pluginContext struct { + webapi.TaskExecutionContext + + resourceMeta webapi.ResourceMeta + resource webapi.Resource + reason string +} + +func (p pluginContext) Reason() string { + return p.reason +} + +func (p pluginContext) Resource() webapi.Resource { + return p.resource +} + +func (p pluginContext) ResourceMeta() webapi.ResourceMeta { + return p.resourceMeta +} + +func newPluginContext(resourceMeta webapi.ResourceMeta, resource webapi.Resource, reason string, tCtx webapi.TaskExecutionContext) pluginContext { + return pluginContext{ + TaskExecutionContext: tCtx, + resourceMeta: resourceMeta, + resource: resource, + reason: reason, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/internal/webapi/state.go b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/state.go new file mode 100644 index 0000000000..013b9c2103 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/state.go @@ -0,0 +1,62 @@ +package webapi + +import ( + "time" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi" +) + +//go:generate enumer -type=Phase -trimprefix=Phase + +// Phase represents current phase of the execution +type Phase int + +const ( + // PhaseNotStarted the default phase. + PhaseNotStarted Phase = iota + + // PhaseAllocationTokenAcquired once all required tokens have been acquired. The task is ready to be executed + // remotely. + PhaseAllocationTokenAcquired + + // PhaseResourcesCreated indicates the task has been created remotely. + PhaseResourcesCreated + + // The resource has successfully been executed remotely. + PhaseSucceeded + + // The resource has failed to be executed. + PhaseUserFailure + + // The resource has failed to be executed due to a system error. + PhaseSystemFailure +) + +func (i Phase) IsTerminal() bool { + return i == PhaseSucceeded || i == PhaseUserFailure || i == PhaseSystemFailure +} + +// State is the persisted State of the resource. +type State struct { + // Phase current phase of the resource. + Phase Phase `json:"phase,omitempty"` + + // PhaseVersion is the version of the phase. This is used to detect if the phase has changed since the last time + PhaseVersion uint32 + + // ResourceMeta contain metadata about resource this task created. This can be a complex structure or a simple type + // (e.g. a string). It should contain enough information for the plugin to interact (retrieve, check status, delete) + // with the resource through the remote service. + ResourceMeta webapi.ResourceMeta `json:"resourceMeta,omitempty"` + + // This number keeps track of the number of failures within the sync function. Without this, what happens in + // the sync function is entirely opaque. Note that this field is completely orthogonal to Flyte system/node/task + // level retries, just errors from hitting API, inside the sync loop + SyncFailureCount int `json:"syncFailureCount,omitempty"` + + // The time the execution first requests for an allocation token + AllocationTokenRequestStartTime time.Time `json:"allocationTokenRequestStartTime,omitempty"` + + // ErrorMessage generated during cache synchronization. + ErrorMessage string `json:"error_message,omitempty"` +} diff --git a/flyteplugins/go/tasks/pluginmachinery/internal/webapi/state_test.go b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/state_test.go new file mode 100644 index 0000000000..06fcdd3cb2 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/internal/webapi/state_test.go @@ -0,0 +1,24 @@ +package webapi + +import "testing" + +func TestPhase_IsTerminal(t *testing.T) { + tests := []struct { + p Phase + want bool + }{ + {PhaseNotStarted, false}, + {PhaseAllocationTokenAcquired, false}, + {PhaseResourcesCreated, false}, + {PhaseSucceeded, true}, + {PhaseSystemFailure, true}, + {PhaseUserFailure, true}, + } + for _, tt := range tests { + t.Run(tt.p.String(), func(t *testing.T) { + if got := tt.p.IsTerminal(); got != tt.want { + t.Errorf("IsTerminal() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/io/iface.go b/flyteplugins/go/tasks/pluginmachinery/io/iface.go new file mode 100644 index 0000000000..2d17ad9e05 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/io/iface.go @@ -0,0 +1,101 @@ +package io + +import ( + "context" + + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + + +// InputFilePaths contains the different ways available for downstream systems to retrieve inputs. +// If using Files for IO with tasks, then the input will be written to this path. All the files are always created in a +// sandbox per execution +type InputFilePaths interface { + // GetInputPrefixPath returns the inputs file path, minus the protobuf file name. + GetInputPrefixPath() storage.DataReference + // GetInputPath returns a path for where the protobuf encoded inputs of type `core.LiteralMap` can be found. The returned value is an URN in the configured storage backend + GetInputPath() storage.DataReference +} + +// InputReader provides a method to access the inputs for a task execution within the plugin's Task Context +type InputReader interface { + InputFilePaths + // Get the inputs for this task as a literal map, an error is returned only in case of systemic errors. + // No outputs or void is indicated using *core.LiteralMap -> nil + Get(ctx context.Context) (*core.LiteralMap, error) +} + +// OutputReader provides an abstracted OutputReader interface. The plugins are responsible to provide +// the implementations for the interface. Some helper implementations can be found in ioutils +type OutputReader interface { + // IsError returns true if an error was detected when reading the output and false if no error was detected + IsError(ctx context.Context) (bool, error) + // ReadError returns the error as type ExecutionError + ReadError(ctx context.Context) (ExecutionError, error) + // IsFile returns true if the outputs are using the OutputFilePaths specified files. If so it allows the system to + // optimize the reads of the files + IsFile(ctx context.Context) bool + // Exists returns true if the output exists false otherwise + Exists(ctx context.Context) (bool, error) + // Read returns the output -> *core.LiteralMap (nil if void), *ExecutionError if user error when reading the output and error to indicate system problems + Read(ctx context.Context) (*core.LiteralMap, *ExecutionError, error) + // DeckExists checks if the deck file has been generated. + DeckExists(ctx context.Context) (bool, error) +} + +// CheckpointPaths provides the paths / keys to input Checkpoints directory and an output checkpoints directory. +type CheckpointPaths interface { + // GetPreviousCheckpointsPrefix returns the storage prefix for checkpoints for the previous iteration / attempt. + // It is optional and can be an empty string in some cases + GetPreviousCheckpointsPrefix() storage.DataReference + // GetCheckpointPrefix returns the storage prefix that should be used to store checkpoints for the current attempt + // The path is not accessible to Flyte backend and are stored in the users raw path + GetCheckpointPrefix() storage.DataReference +} + +// RawOutputPaths is the actual path where the data produced by a task can be placed. It is completely optional. The advantage +// of using this path is to provide exactly once semantics. It is guaranteed that this path is unique for every new execution +// of a task (across retries etc) and is constant for a specific execution. +// As of 02/20/2020 Flytekit generates this path randomly for S3. This structure proposes migration of this logic to +// FlytePluginMachinery so that it can be used more universally outside of Flytekit. +type RawOutputPaths interface { + // GetRawOutputPrefix is the prefix (blob store prefix or directory) where all data produced can be stored. + GetRawOutputPrefix() storage.DataReference +} + +// OutputFilePaths contains and provides all paths where various meta outputs produced by the task can be placed, +// such that the framework can directly access them. Every path is represented using storage.DataReference -> +// an URN for the configured storage backend +type OutputFilePaths interface { + // RawOutputPaths are available with OutputFilePaths + RawOutputPaths + + // CheckpointPaths that can be optionally used to checkpoint + CheckpointPaths + + // GetOutputPrefixPath returns a path to a directory or prefix that contains all execution metadata for this execution + GetOutputPrefixPath() storage.DataReference + // GetOutputPath returns a fully qualified path (URN) to where the framework expects the output to exist in the configured storage backend + GetOutputPath() storage.DataReference + // GetDeckPath returns a fully qualified path (URN) to where the framework expects the deck.html to exist in the configured storage backend + GetDeckPath() storage.DataReference + // GetErrorPath returns a fully qualified path (URN) where the error information should be placed as a protobuf core.ErrorDocument. It is not directly + // used by the framework, but could be used in the future + GetErrorPath() storage.DataReference +} + +// OutputWriter provides an interface to write back the outputs to the engine. +type OutputWriter interface { + OutputFilePaths + // Put Once the task completes, use this method to indicate the output accessor to the framework + Put(ctx context.Context, reader OutputReader) error +} + +// ExecutionError Indicates any error in executing the task +type ExecutionError struct { + // Core error structure + *core.ExecutionError + // Indicates if this error is recoverable + IsRecoverable bool +} diff --git a/flyteplugins/go/tasks/pluginmachinery/io/mocks/checkpoint_paths.go b/flyteplugins/go/tasks/pluginmachinery/io/mocks/checkpoint_paths.go new file mode 100644 index 0000000000..51741961a0 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/io/mocks/checkpoint_paths.go @@ -0,0 +1,125 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + storage "github.com/flyteorg/flyte/v2/flytestdlib/storage" + mock "github.com/stretchr/testify/mock" +) + +// CheckpointPaths is an autogenerated mock type for the CheckpointPaths type +type CheckpointPaths struct { + mock.Mock +} + +type CheckpointPaths_Expecter struct { + mock *mock.Mock +} + +func (_m *CheckpointPaths) EXPECT() *CheckpointPaths_Expecter { + return &CheckpointPaths_Expecter{mock: &_m.Mock} +} + +// GetCheckpointPrefix provides a mock function with no fields +func (_m *CheckpointPaths) GetCheckpointPrefix() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetCheckpointPrefix") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// CheckpointPaths_GetCheckpointPrefix_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCheckpointPrefix' +type CheckpointPaths_GetCheckpointPrefix_Call struct { + *mock.Call +} + +// GetCheckpointPrefix is a helper method to define mock.On call +func (_e *CheckpointPaths_Expecter) GetCheckpointPrefix() *CheckpointPaths_GetCheckpointPrefix_Call { + return &CheckpointPaths_GetCheckpointPrefix_Call{Call: _e.mock.On("GetCheckpointPrefix")} +} + +func (_c *CheckpointPaths_GetCheckpointPrefix_Call) Run(run func()) *CheckpointPaths_GetCheckpointPrefix_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *CheckpointPaths_GetCheckpointPrefix_Call) Return(_a0 storage.DataReference) *CheckpointPaths_GetCheckpointPrefix_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CheckpointPaths_GetCheckpointPrefix_Call) RunAndReturn(run func() storage.DataReference) *CheckpointPaths_GetCheckpointPrefix_Call { + _c.Call.Return(run) + return _c +} + +// GetPreviousCheckpointsPrefix provides a mock function with no fields +func (_m *CheckpointPaths) GetPreviousCheckpointsPrefix() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPreviousCheckpointsPrefix") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// CheckpointPaths_GetPreviousCheckpointsPrefix_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPreviousCheckpointsPrefix' +type CheckpointPaths_GetPreviousCheckpointsPrefix_Call struct { + *mock.Call +} + +// GetPreviousCheckpointsPrefix is a helper method to define mock.On call +func (_e *CheckpointPaths_Expecter) GetPreviousCheckpointsPrefix() *CheckpointPaths_GetPreviousCheckpointsPrefix_Call { + return &CheckpointPaths_GetPreviousCheckpointsPrefix_Call{Call: _e.mock.On("GetPreviousCheckpointsPrefix")} +} + +func (_c *CheckpointPaths_GetPreviousCheckpointsPrefix_Call) Run(run func()) *CheckpointPaths_GetPreviousCheckpointsPrefix_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *CheckpointPaths_GetPreviousCheckpointsPrefix_Call) Return(_a0 storage.DataReference) *CheckpointPaths_GetPreviousCheckpointsPrefix_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CheckpointPaths_GetPreviousCheckpointsPrefix_Call) RunAndReturn(run func() storage.DataReference) *CheckpointPaths_GetPreviousCheckpointsPrefix_Call { + _c.Call.Return(run) + return _c +} + +// NewCheckpointPaths creates a new instance of CheckpointPaths. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewCheckpointPaths(t interface { + mock.TestingT + Cleanup(func()) +}) *CheckpointPaths { + mock := &CheckpointPaths{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/io/mocks/input_file_paths.go b/flyteplugins/go/tasks/pluginmachinery/io/mocks/input_file_paths.go new file mode 100644 index 0000000000..e68d3fa9ea --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/io/mocks/input_file_paths.go @@ -0,0 +1,125 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + storage "github.com/flyteorg/flyte/v2/flytestdlib/storage" + mock "github.com/stretchr/testify/mock" +) + +// InputFilePaths is an autogenerated mock type for the InputFilePaths type +type InputFilePaths struct { + mock.Mock +} + +type InputFilePaths_Expecter struct { + mock *mock.Mock +} + +func (_m *InputFilePaths) EXPECT() *InputFilePaths_Expecter { + return &InputFilePaths_Expecter{mock: &_m.Mock} +} + +// GetInputPath provides a mock function with no fields +func (_m *InputFilePaths) GetInputPath() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetInputPath") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// InputFilePaths_GetInputPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInputPath' +type InputFilePaths_GetInputPath_Call struct { + *mock.Call +} + +// GetInputPath is a helper method to define mock.On call +func (_e *InputFilePaths_Expecter) GetInputPath() *InputFilePaths_GetInputPath_Call { + return &InputFilePaths_GetInputPath_Call{Call: _e.mock.On("GetInputPath")} +} + +func (_c *InputFilePaths_GetInputPath_Call) Run(run func()) *InputFilePaths_GetInputPath_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *InputFilePaths_GetInputPath_Call) Return(_a0 storage.DataReference) *InputFilePaths_GetInputPath_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *InputFilePaths_GetInputPath_Call) RunAndReturn(run func() storage.DataReference) *InputFilePaths_GetInputPath_Call { + _c.Call.Return(run) + return _c +} + +// GetInputPrefixPath provides a mock function with no fields +func (_m *InputFilePaths) GetInputPrefixPath() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetInputPrefixPath") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// InputFilePaths_GetInputPrefixPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInputPrefixPath' +type InputFilePaths_GetInputPrefixPath_Call struct { + *mock.Call +} + +// GetInputPrefixPath is a helper method to define mock.On call +func (_e *InputFilePaths_Expecter) GetInputPrefixPath() *InputFilePaths_GetInputPrefixPath_Call { + return &InputFilePaths_GetInputPrefixPath_Call{Call: _e.mock.On("GetInputPrefixPath")} +} + +func (_c *InputFilePaths_GetInputPrefixPath_Call) Run(run func()) *InputFilePaths_GetInputPrefixPath_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *InputFilePaths_GetInputPrefixPath_Call) Return(_a0 storage.DataReference) *InputFilePaths_GetInputPrefixPath_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *InputFilePaths_GetInputPrefixPath_Call) RunAndReturn(run func() storage.DataReference) *InputFilePaths_GetInputPrefixPath_Call { + _c.Call.Return(run) + return _c +} + +// NewInputFilePaths creates a new instance of InputFilePaths. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewInputFilePaths(t interface { + mock.TestingT + Cleanup(func()) +}) *InputFilePaths { + mock := &InputFilePaths{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/io/mocks/input_reader.go b/flyteplugins/go/tasks/pluginmachinery/io/mocks/input_reader.go new file mode 100644 index 0000000000..d76059ae91 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/io/mocks/input_reader.go @@ -0,0 +1,188 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + + mock "github.com/stretchr/testify/mock" + + storage "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + +// InputReader is an autogenerated mock type for the InputReader type +type InputReader struct { + mock.Mock +} + +type InputReader_Expecter struct { + mock *mock.Mock +} + +func (_m *InputReader) EXPECT() *InputReader_Expecter { + return &InputReader_Expecter{mock: &_m.Mock} +} + +// Get provides a mock function with given fields: ctx +func (_m *InputReader) Get(ctx context.Context) (*core.LiteralMap, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 *core.LiteralMap + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (*core.LiteralMap, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) *core.LiteralMap); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*core.LiteralMap) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// InputReader_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type InputReader_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +func (_e *InputReader_Expecter) Get(ctx interface{}) *InputReader_Get_Call { + return &InputReader_Get_Call{Call: _e.mock.On("Get", ctx)} +} + +func (_c *InputReader_Get_Call) Run(run func(ctx context.Context)) *InputReader_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *InputReader_Get_Call) Return(_a0 *core.LiteralMap, _a1 error) *InputReader_Get_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *InputReader_Get_Call) RunAndReturn(run func(context.Context) (*core.LiteralMap, error)) *InputReader_Get_Call { + _c.Call.Return(run) + return _c +} + +// GetInputPath provides a mock function with no fields +func (_m *InputReader) GetInputPath() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetInputPath") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// InputReader_GetInputPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInputPath' +type InputReader_GetInputPath_Call struct { + *mock.Call +} + +// GetInputPath is a helper method to define mock.On call +func (_e *InputReader_Expecter) GetInputPath() *InputReader_GetInputPath_Call { + return &InputReader_GetInputPath_Call{Call: _e.mock.On("GetInputPath")} +} + +func (_c *InputReader_GetInputPath_Call) Run(run func()) *InputReader_GetInputPath_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *InputReader_GetInputPath_Call) Return(_a0 storage.DataReference) *InputReader_GetInputPath_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *InputReader_GetInputPath_Call) RunAndReturn(run func() storage.DataReference) *InputReader_GetInputPath_Call { + _c.Call.Return(run) + return _c +} + +// GetInputPrefixPath provides a mock function with no fields +func (_m *InputReader) GetInputPrefixPath() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetInputPrefixPath") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// InputReader_GetInputPrefixPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInputPrefixPath' +type InputReader_GetInputPrefixPath_Call struct { + *mock.Call +} + +// GetInputPrefixPath is a helper method to define mock.On call +func (_e *InputReader_Expecter) GetInputPrefixPath() *InputReader_GetInputPrefixPath_Call { + return &InputReader_GetInputPrefixPath_Call{Call: _e.mock.On("GetInputPrefixPath")} +} + +func (_c *InputReader_GetInputPrefixPath_Call) Run(run func()) *InputReader_GetInputPrefixPath_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *InputReader_GetInputPrefixPath_Call) Return(_a0 storage.DataReference) *InputReader_GetInputPrefixPath_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *InputReader_GetInputPrefixPath_Call) RunAndReturn(run func() storage.DataReference) *InputReader_GetInputPrefixPath_Call { + _c.Call.Return(run) + return _c +} + +// NewInputReader creates a new instance of InputReader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewInputReader(t interface { + mock.TestingT + Cleanup(func()) +}) *InputReader { + mock := &InputReader{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/io/mocks/output_data_sandbox.go b/flyteplugins/go/tasks/pluginmachinery/io/mocks/output_data_sandbox.go new file mode 100644 index 0000000000..29034d0184 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/io/mocks/output_data_sandbox.go @@ -0,0 +1,45 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + storage "github.com/flyteorg/flyte/v2/flytestdlib/storage" + mock "github.com/stretchr/testify/mock" +) + +// RawOutputPaths is an autogenerated mock type for the RawOutputPaths type +type OutputDataSandbox struct { + mock.Mock +} + +type OutputDataSandbox_GetOutputDataSandboxPath struct { + *mock.Call +} + +func (_m OutputDataSandbox_GetOutputDataSandboxPath) Return(_a0 storage.DataReference) *OutputDataSandbox_GetOutputDataSandboxPath { + return &OutputDataSandbox_GetOutputDataSandboxPath{Call: _m.Call.Return(_a0)} +} + +func (_m *OutputDataSandbox) OnGetOutputDataSandboxPath() *OutputDataSandbox_GetOutputDataSandboxPath { + c := _m.On("GetRawOutputPrefix") + return &OutputDataSandbox_GetOutputDataSandboxPath{Call: c} +} + +func (_m *OutputDataSandbox) OnGetOutputDataSandboxPathMatch(matchers ...interface{}) *OutputDataSandbox_GetOutputDataSandboxPath { + c := _m.On("GetRawOutputPrefix", matchers...) + return &OutputDataSandbox_GetOutputDataSandboxPath{Call: c} +} + +// GetRawOutputPrefix provides a mock function with given fields: +func (_m *OutputDataSandbox) GetRawOutputPrefix() storage.DataReference { + ret := _m.Called() + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/io/mocks/output_file_paths.go b/flyteplugins/go/tasks/pluginmachinery/io/mocks/output_file_paths.go new file mode 100644 index 0000000000..de3eb63efa --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/io/mocks/output_file_paths.go @@ -0,0 +1,350 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + storage "github.com/flyteorg/flyte/v2/flytestdlib/storage" + mock "github.com/stretchr/testify/mock" +) + +// OutputFilePaths is an autogenerated mock type for the OutputFilePaths type +type OutputFilePaths struct { + mock.Mock +} + +type OutputFilePaths_Expecter struct { + mock *mock.Mock +} + +func (_m *OutputFilePaths) EXPECT() *OutputFilePaths_Expecter { + return &OutputFilePaths_Expecter{mock: &_m.Mock} +} + +// GetCheckpointPrefix provides a mock function with no fields +func (_m *OutputFilePaths) GetCheckpointPrefix() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetCheckpointPrefix") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// OutputFilePaths_GetCheckpointPrefix_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCheckpointPrefix' +type OutputFilePaths_GetCheckpointPrefix_Call struct { + *mock.Call +} + +// GetCheckpointPrefix is a helper method to define mock.On call +func (_e *OutputFilePaths_Expecter) GetCheckpointPrefix() *OutputFilePaths_GetCheckpointPrefix_Call { + return &OutputFilePaths_GetCheckpointPrefix_Call{Call: _e.mock.On("GetCheckpointPrefix")} +} + +func (_c *OutputFilePaths_GetCheckpointPrefix_Call) Run(run func()) *OutputFilePaths_GetCheckpointPrefix_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *OutputFilePaths_GetCheckpointPrefix_Call) Return(_a0 storage.DataReference) *OutputFilePaths_GetCheckpointPrefix_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OutputFilePaths_GetCheckpointPrefix_Call) RunAndReturn(run func() storage.DataReference) *OutputFilePaths_GetCheckpointPrefix_Call { + _c.Call.Return(run) + return _c +} + +// GetDeckPath provides a mock function with no fields +func (_m *OutputFilePaths) GetDeckPath() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetDeckPath") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// OutputFilePaths_GetDeckPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDeckPath' +type OutputFilePaths_GetDeckPath_Call struct { + *mock.Call +} + +// GetDeckPath is a helper method to define mock.On call +func (_e *OutputFilePaths_Expecter) GetDeckPath() *OutputFilePaths_GetDeckPath_Call { + return &OutputFilePaths_GetDeckPath_Call{Call: _e.mock.On("GetDeckPath")} +} + +func (_c *OutputFilePaths_GetDeckPath_Call) Run(run func()) *OutputFilePaths_GetDeckPath_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *OutputFilePaths_GetDeckPath_Call) Return(_a0 storage.DataReference) *OutputFilePaths_GetDeckPath_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OutputFilePaths_GetDeckPath_Call) RunAndReturn(run func() storage.DataReference) *OutputFilePaths_GetDeckPath_Call { + _c.Call.Return(run) + return _c +} + +// GetErrorPath provides a mock function with no fields +func (_m *OutputFilePaths) GetErrorPath() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetErrorPath") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// OutputFilePaths_GetErrorPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetErrorPath' +type OutputFilePaths_GetErrorPath_Call struct { + *mock.Call +} + +// GetErrorPath is a helper method to define mock.On call +func (_e *OutputFilePaths_Expecter) GetErrorPath() *OutputFilePaths_GetErrorPath_Call { + return &OutputFilePaths_GetErrorPath_Call{Call: _e.mock.On("GetErrorPath")} +} + +func (_c *OutputFilePaths_GetErrorPath_Call) Run(run func()) *OutputFilePaths_GetErrorPath_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *OutputFilePaths_GetErrorPath_Call) Return(_a0 storage.DataReference) *OutputFilePaths_GetErrorPath_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OutputFilePaths_GetErrorPath_Call) RunAndReturn(run func() storage.DataReference) *OutputFilePaths_GetErrorPath_Call { + _c.Call.Return(run) + return _c +} + +// GetOutputPath provides a mock function with no fields +func (_m *OutputFilePaths) GetOutputPath() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetOutputPath") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// OutputFilePaths_GetOutputPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOutputPath' +type OutputFilePaths_GetOutputPath_Call struct { + *mock.Call +} + +// GetOutputPath is a helper method to define mock.On call +func (_e *OutputFilePaths_Expecter) GetOutputPath() *OutputFilePaths_GetOutputPath_Call { + return &OutputFilePaths_GetOutputPath_Call{Call: _e.mock.On("GetOutputPath")} +} + +func (_c *OutputFilePaths_GetOutputPath_Call) Run(run func()) *OutputFilePaths_GetOutputPath_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *OutputFilePaths_GetOutputPath_Call) Return(_a0 storage.DataReference) *OutputFilePaths_GetOutputPath_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OutputFilePaths_GetOutputPath_Call) RunAndReturn(run func() storage.DataReference) *OutputFilePaths_GetOutputPath_Call { + _c.Call.Return(run) + return _c +} + +// GetOutputPrefixPath provides a mock function with no fields +func (_m *OutputFilePaths) GetOutputPrefixPath() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetOutputPrefixPath") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// OutputFilePaths_GetOutputPrefixPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOutputPrefixPath' +type OutputFilePaths_GetOutputPrefixPath_Call struct { + *mock.Call +} + +// GetOutputPrefixPath is a helper method to define mock.On call +func (_e *OutputFilePaths_Expecter) GetOutputPrefixPath() *OutputFilePaths_GetOutputPrefixPath_Call { + return &OutputFilePaths_GetOutputPrefixPath_Call{Call: _e.mock.On("GetOutputPrefixPath")} +} + +func (_c *OutputFilePaths_GetOutputPrefixPath_Call) Run(run func()) *OutputFilePaths_GetOutputPrefixPath_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *OutputFilePaths_GetOutputPrefixPath_Call) Return(_a0 storage.DataReference) *OutputFilePaths_GetOutputPrefixPath_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OutputFilePaths_GetOutputPrefixPath_Call) RunAndReturn(run func() storage.DataReference) *OutputFilePaths_GetOutputPrefixPath_Call { + _c.Call.Return(run) + return _c +} + +// GetPreviousCheckpointsPrefix provides a mock function with no fields +func (_m *OutputFilePaths) GetPreviousCheckpointsPrefix() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPreviousCheckpointsPrefix") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// OutputFilePaths_GetPreviousCheckpointsPrefix_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPreviousCheckpointsPrefix' +type OutputFilePaths_GetPreviousCheckpointsPrefix_Call struct { + *mock.Call +} + +// GetPreviousCheckpointsPrefix is a helper method to define mock.On call +func (_e *OutputFilePaths_Expecter) GetPreviousCheckpointsPrefix() *OutputFilePaths_GetPreviousCheckpointsPrefix_Call { + return &OutputFilePaths_GetPreviousCheckpointsPrefix_Call{Call: _e.mock.On("GetPreviousCheckpointsPrefix")} +} + +func (_c *OutputFilePaths_GetPreviousCheckpointsPrefix_Call) Run(run func()) *OutputFilePaths_GetPreviousCheckpointsPrefix_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *OutputFilePaths_GetPreviousCheckpointsPrefix_Call) Return(_a0 storage.DataReference) *OutputFilePaths_GetPreviousCheckpointsPrefix_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OutputFilePaths_GetPreviousCheckpointsPrefix_Call) RunAndReturn(run func() storage.DataReference) *OutputFilePaths_GetPreviousCheckpointsPrefix_Call { + _c.Call.Return(run) + return _c +} + +// GetRawOutputPrefix provides a mock function with no fields +func (_m *OutputFilePaths) GetRawOutputPrefix() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetRawOutputPrefix") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// OutputFilePaths_GetRawOutputPrefix_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRawOutputPrefix' +type OutputFilePaths_GetRawOutputPrefix_Call struct { + *mock.Call +} + +// GetRawOutputPrefix is a helper method to define mock.On call +func (_e *OutputFilePaths_Expecter) GetRawOutputPrefix() *OutputFilePaths_GetRawOutputPrefix_Call { + return &OutputFilePaths_GetRawOutputPrefix_Call{Call: _e.mock.On("GetRawOutputPrefix")} +} + +func (_c *OutputFilePaths_GetRawOutputPrefix_Call) Run(run func()) *OutputFilePaths_GetRawOutputPrefix_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *OutputFilePaths_GetRawOutputPrefix_Call) Return(_a0 storage.DataReference) *OutputFilePaths_GetRawOutputPrefix_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OutputFilePaths_GetRawOutputPrefix_Call) RunAndReturn(run func() storage.DataReference) *OutputFilePaths_GetRawOutputPrefix_Call { + _c.Call.Return(run) + return _c +} + +// NewOutputFilePaths creates a new instance of OutputFilePaths. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewOutputFilePaths(t interface { + mock.TestingT + Cleanup(func()) +}) *OutputFilePaths { + mock := &OutputFilePaths{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/io/mocks/output_reader.go b/flyteplugins/go/tasks/pluginmachinery/io/mocks/output_reader.go new file mode 100644 index 0000000000..804d69d368 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/io/mocks/output_reader.go @@ -0,0 +1,376 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + io "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + + mock "github.com/stretchr/testify/mock" +) + +// OutputReader is an autogenerated mock type for the OutputReader type +type OutputReader struct { + mock.Mock +} + +type OutputReader_Expecter struct { + mock *mock.Mock +} + +func (_m *OutputReader) EXPECT() *OutputReader_Expecter { + return &OutputReader_Expecter{mock: &_m.Mock} +} + +// DeckExists provides a mock function with given fields: ctx +func (_m *OutputReader) DeckExists(ctx context.Context) (bool, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for DeckExists") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (bool, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) bool); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// OutputReader_DeckExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeckExists' +type OutputReader_DeckExists_Call struct { + *mock.Call +} + +// DeckExists is a helper method to define mock.On call +// - ctx context.Context +func (_e *OutputReader_Expecter) DeckExists(ctx interface{}) *OutputReader_DeckExists_Call { + return &OutputReader_DeckExists_Call{Call: _e.mock.On("DeckExists", ctx)} +} + +func (_c *OutputReader_DeckExists_Call) Run(run func(ctx context.Context)) *OutputReader_DeckExists_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *OutputReader_DeckExists_Call) Return(_a0 bool, _a1 error) *OutputReader_DeckExists_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *OutputReader_DeckExists_Call) RunAndReturn(run func(context.Context) (bool, error)) *OutputReader_DeckExists_Call { + _c.Call.Return(run) + return _c +} + +// Exists provides a mock function with given fields: ctx +func (_m *OutputReader) Exists(ctx context.Context) (bool, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Exists") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (bool, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) bool); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// OutputReader_Exists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exists' +type OutputReader_Exists_Call struct { + *mock.Call +} + +// Exists is a helper method to define mock.On call +// - ctx context.Context +func (_e *OutputReader_Expecter) Exists(ctx interface{}) *OutputReader_Exists_Call { + return &OutputReader_Exists_Call{Call: _e.mock.On("Exists", ctx)} +} + +func (_c *OutputReader_Exists_Call) Run(run func(ctx context.Context)) *OutputReader_Exists_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *OutputReader_Exists_Call) Return(_a0 bool, _a1 error) *OutputReader_Exists_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *OutputReader_Exists_Call) RunAndReturn(run func(context.Context) (bool, error)) *OutputReader_Exists_Call { + _c.Call.Return(run) + return _c +} + +// IsError provides a mock function with given fields: ctx +func (_m *OutputReader) IsError(ctx context.Context) (bool, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for IsError") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (bool, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) bool); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// OutputReader_IsError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsError' +type OutputReader_IsError_Call struct { + *mock.Call +} + +// IsError is a helper method to define mock.On call +// - ctx context.Context +func (_e *OutputReader_Expecter) IsError(ctx interface{}) *OutputReader_IsError_Call { + return &OutputReader_IsError_Call{Call: _e.mock.On("IsError", ctx)} +} + +func (_c *OutputReader_IsError_Call) Run(run func(ctx context.Context)) *OutputReader_IsError_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *OutputReader_IsError_Call) Return(_a0 bool, _a1 error) *OutputReader_IsError_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *OutputReader_IsError_Call) RunAndReturn(run func(context.Context) (bool, error)) *OutputReader_IsError_Call { + _c.Call.Return(run) + return _c +} + +// IsFile provides a mock function with given fields: ctx +func (_m *OutputReader) IsFile(ctx context.Context) bool { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for IsFile") + } + + var r0 bool + if rf, ok := ret.Get(0).(func(context.Context) bool); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// OutputReader_IsFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsFile' +type OutputReader_IsFile_Call struct { + *mock.Call +} + +// IsFile is a helper method to define mock.On call +// - ctx context.Context +func (_e *OutputReader_Expecter) IsFile(ctx interface{}) *OutputReader_IsFile_Call { + return &OutputReader_IsFile_Call{Call: _e.mock.On("IsFile", ctx)} +} + +func (_c *OutputReader_IsFile_Call) Run(run func(ctx context.Context)) *OutputReader_IsFile_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *OutputReader_IsFile_Call) Return(_a0 bool) *OutputReader_IsFile_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OutputReader_IsFile_Call) RunAndReturn(run func(context.Context) bool) *OutputReader_IsFile_Call { + _c.Call.Return(run) + return _c +} + +// Read provides a mock function with given fields: ctx +func (_m *OutputReader) Read(ctx context.Context) (*core.LiteralMap, *io.ExecutionError, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Read") + } + + var r0 *core.LiteralMap + var r1 *io.ExecutionError + var r2 error + if rf, ok := ret.Get(0).(func(context.Context) (*core.LiteralMap, *io.ExecutionError, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) *core.LiteralMap); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*core.LiteralMap) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) *io.ExecutionError); ok { + r1 = rf(ctx) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(*io.ExecutionError) + } + } + + if rf, ok := ret.Get(2).(func(context.Context) error); ok { + r2 = rf(ctx) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OutputReader_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read' +type OutputReader_Read_Call struct { + *mock.Call +} + +// Read is a helper method to define mock.On call +// - ctx context.Context +func (_e *OutputReader_Expecter) Read(ctx interface{}) *OutputReader_Read_Call { + return &OutputReader_Read_Call{Call: _e.mock.On("Read", ctx)} +} + +func (_c *OutputReader_Read_Call) Run(run func(ctx context.Context)) *OutputReader_Read_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *OutputReader_Read_Call) Return(_a0 *core.LiteralMap, _a1 *io.ExecutionError, _a2 error) *OutputReader_Read_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OutputReader_Read_Call) RunAndReturn(run func(context.Context) (*core.LiteralMap, *io.ExecutionError, error)) *OutputReader_Read_Call { + _c.Call.Return(run) + return _c +} + +// ReadError provides a mock function with given fields: ctx +func (_m *OutputReader) ReadError(ctx context.Context) (io.ExecutionError, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ReadError") + } + + var r0 io.ExecutionError + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (io.ExecutionError, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) io.ExecutionError); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(io.ExecutionError) + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// OutputReader_ReadError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadError' +type OutputReader_ReadError_Call struct { + *mock.Call +} + +// ReadError is a helper method to define mock.On call +// - ctx context.Context +func (_e *OutputReader_Expecter) ReadError(ctx interface{}) *OutputReader_ReadError_Call { + return &OutputReader_ReadError_Call{Call: _e.mock.On("ReadError", ctx)} +} + +func (_c *OutputReader_ReadError_Call) Run(run func(ctx context.Context)) *OutputReader_ReadError_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *OutputReader_ReadError_Call) Return(_a0 io.ExecutionError, _a1 error) *OutputReader_ReadError_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *OutputReader_ReadError_Call) RunAndReturn(run func(context.Context) (io.ExecutionError, error)) *OutputReader_ReadError_Call { + _c.Call.Return(run) + return _c +} + +// NewOutputReader creates a new instance of OutputReader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewOutputReader(t interface { + mock.TestingT + Cleanup(func()) +}) *OutputReader { + mock := &OutputReader{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/io/mocks/output_writer.go b/flyteplugins/go/tasks/pluginmachinery/io/mocks/output_writer.go new file mode 100644 index 0000000000..54cd2d62ff --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/io/mocks/output_writer.go @@ -0,0 +1,401 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + io "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + mock "github.com/stretchr/testify/mock" + + storage "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + +// OutputWriter is an autogenerated mock type for the OutputWriter type +type OutputWriter struct { + mock.Mock +} + +type OutputWriter_Expecter struct { + mock *mock.Mock +} + +func (_m *OutputWriter) EXPECT() *OutputWriter_Expecter { + return &OutputWriter_Expecter{mock: &_m.Mock} +} + +// GetCheckpointPrefix provides a mock function with no fields +func (_m *OutputWriter) GetCheckpointPrefix() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetCheckpointPrefix") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// OutputWriter_GetCheckpointPrefix_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCheckpointPrefix' +type OutputWriter_GetCheckpointPrefix_Call struct { + *mock.Call +} + +// GetCheckpointPrefix is a helper method to define mock.On call +func (_e *OutputWriter_Expecter) GetCheckpointPrefix() *OutputWriter_GetCheckpointPrefix_Call { + return &OutputWriter_GetCheckpointPrefix_Call{Call: _e.mock.On("GetCheckpointPrefix")} +} + +func (_c *OutputWriter_GetCheckpointPrefix_Call) Run(run func()) *OutputWriter_GetCheckpointPrefix_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *OutputWriter_GetCheckpointPrefix_Call) Return(_a0 storage.DataReference) *OutputWriter_GetCheckpointPrefix_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OutputWriter_GetCheckpointPrefix_Call) RunAndReturn(run func() storage.DataReference) *OutputWriter_GetCheckpointPrefix_Call { + _c.Call.Return(run) + return _c +} + +// GetDeckPath provides a mock function with no fields +func (_m *OutputWriter) GetDeckPath() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetDeckPath") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// OutputWriter_GetDeckPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDeckPath' +type OutputWriter_GetDeckPath_Call struct { + *mock.Call +} + +// GetDeckPath is a helper method to define mock.On call +func (_e *OutputWriter_Expecter) GetDeckPath() *OutputWriter_GetDeckPath_Call { + return &OutputWriter_GetDeckPath_Call{Call: _e.mock.On("GetDeckPath")} +} + +func (_c *OutputWriter_GetDeckPath_Call) Run(run func()) *OutputWriter_GetDeckPath_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *OutputWriter_GetDeckPath_Call) Return(_a0 storage.DataReference) *OutputWriter_GetDeckPath_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OutputWriter_GetDeckPath_Call) RunAndReturn(run func() storage.DataReference) *OutputWriter_GetDeckPath_Call { + _c.Call.Return(run) + return _c +} + +// GetErrorPath provides a mock function with no fields +func (_m *OutputWriter) GetErrorPath() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetErrorPath") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// OutputWriter_GetErrorPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetErrorPath' +type OutputWriter_GetErrorPath_Call struct { + *mock.Call +} + +// GetErrorPath is a helper method to define mock.On call +func (_e *OutputWriter_Expecter) GetErrorPath() *OutputWriter_GetErrorPath_Call { + return &OutputWriter_GetErrorPath_Call{Call: _e.mock.On("GetErrorPath")} +} + +func (_c *OutputWriter_GetErrorPath_Call) Run(run func()) *OutputWriter_GetErrorPath_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *OutputWriter_GetErrorPath_Call) Return(_a0 storage.DataReference) *OutputWriter_GetErrorPath_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OutputWriter_GetErrorPath_Call) RunAndReturn(run func() storage.DataReference) *OutputWriter_GetErrorPath_Call { + _c.Call.Return(run) + return _c +} + +// GetOutputPath provides a mock function with no fields +func (_m *OutputWriter) GetOutputPath() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetOutputPath") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// OutputWriter_GetOutputPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOutputPath' +type OutputWriter_GetOutputPath_Call struct { + *mock.Call +} + +// GetOutputPath is a helper method to define mock.On call +func (_e *OutputWriter_Expecter) GetOutputPath() *OutputWriter_GetOutputPath_Call { + return &OutputWriter_GetOutputPath_Call{Call: _e.mock.On("GetOutputPath")} +} + +func (_c *OutputWriter_GetOutputPath_Call) Run(run func()) *OutputWriter_GetOutputPath_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *OutputWriter_GetOutputPath_Call) Return(_a0 storage.DataReference) *OutputWriter_GetOutputPath_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OutputWriter_GetOutputPath_Call) RunAndReturn(run func() storage.DataReference) *OutputWriter_GetOutputPath_Call { + _c.Call.Return(run) + return _c +} + +// GetOutputPrefixPath provides a mock function with no fields +func (_m *OutputWriter) GetOutputPrefixPath() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetOutputPrefixPath") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// OutputWriter_GetOutputPrefixPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOutputPrefixPath' +type OutputWriter_GetOutputPrefixPath_Call struct { + *mock.Call +} + +// GetOutputPrefixPath is a helper method to define mock.On call +func (_e *OutputWriter_Expecter) GetOutputPrefixPath() *OutputWriter_GetOutputPrefixPath_Call { + return &OutputWriter_GetOutputPrefixPath_Call{Call: _e.mock.On("GetOutputPrefixPath")} +} + +func (_c *OutputWriter_GetOutputPrefixPath_Call) Run(run func()) *OutputWriter_GetOutputPrefixPath_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *OutputWriter_GetOutputPrefixPath_Call) Return(_a0 storage.DataReference) *OutputWriter_GetOutputPrefixPath_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OutputWriter_GetOutputPrefixPath_Call) RunAndReturn(run func() storage.DataReference) *OutputWriter_GetOutputPrefixPath_Call { + _c.Call.Return(run) + return _c +} + +// GetPreviousCheckpointsPrefix provides a mock function with no fields +func (_m *OutputWriter) GetPreviousCheckpointsPrefix() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPreviousCheckpointsPrefix") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// OutputWriter_GetPreviousCheckpointsPrefix_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPreviousCheckpointsPrefix' +type OutputWriter_GetPreviousCheckpointsPrefix_Call struct { + *mock.Call +} + +// GetPreviousCheckpointsPrefix is a helper method to define mock.On call +func (_e *OutputWriter_Expecter) GetPreviousCheckpointsPrefix() *OutputWriter_GetPreviousCheckpointsPrefix_Call { + return &OutputWriter_GetPreviousCheckpointsPrefix_Call{Call: _e.mock.On("GetPreviousCheckpointsPrefix")} +} + +func (_c *OutputWriter_GetPreviousCheckpointsPrefix_Call) Run(run func()) *OutputWriter_GetPreviousCheckpointsPrefix_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *OutputWriter_GetPreviousCheckpointsPrefix_Call) Return(_a0 storage.DataReference) *OutputWriter_GetPreviousCheckpointsPrefix_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OutputWriter_GetPreviousCheckpointsPrefix_Call) RunAndReturn(run func() storage.DataReference) *OutputWriter_GetPreviousCheckpointsPrefix_Call { + _c.Call.Return(run) + return _c +} + +// GetRawOutputPrefix provides a mock function with no fields +func (_m *OutputWriter) GetRawOutputPrefix() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetRawOutputPrefix") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// OutputWriter_GetRawOutputPrefix_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRawOutputPrefix' +type OutputWriter_GetRawOutputPrefix_Call struct { + *mock.Call +} + +// GetRawOutputPrefix is a helper method to define mock.On call +func (_e *OutputWriter_Expecter) GetRawOutputPrefix() *OutputWriter_GetRawOutputPrefix_Call { + return &OutputWriter_GetRawOutputPrefix_Call{Call: _e.mock.On("GetRawOutputPrefix")} +} + +func (_c *OutputWriter_GetRawOutputPrefix_Call) Run(run func()) *OutputWriter_GetRawOutputPrefix_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *OutputWriter_GetRawOutputPrefix_Call) Return(_a0 storage.DataReference) *OutputWriter_GetRawOutputPrefix_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OutputWriter_GetRawOutputPrefix_Call) RunAndReturn(run func() storage.DataReference) *OutputWriter_GetRawOutputPrefix_Call { + _c.Call.Return(run) + return _c +} + +// Put provides a mock function with given fields: ctx, reader +func (_m *OutputWriter) Put(ctx context.Context, reader io.OutputReader) error { + ret := _m.Called(ctx, reader) + + if len(ret) == 0 { + panic("no return value specified for Put") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, io.OutputReader) error); ok { + r0 = rf(ctx, reader) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// OutputWriter_Put_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Put' +type OutputWriter_Put_Call struct { + *mock.Call +} + +// Put is a helper method to define mock.On call +// - ctx context.Context +// - reader io.OutputReader +func (_e *OutputWriter_Expecter) Put(ctx interface{}, reader interface{}) *OutputWriter_Put_Call { + return &OutputWriter_Put_Call{Call: _e.mock.On("Put", ctx, reader)} +} + +func (_c *OutputWriter_Put_Call) Run(run func(ctx context.Context, reader io.OutputReader)) *OutputWriter_Put_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(io.OutputReader)) + }) + return _c +} + +func (_c *OutputWriter_Put_Call) Return(_a0 error) *OutputWriter_Put_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OutputWriter_Put_Call) RunAndReturn(run func(context.Context, io.OutputReader) error) *OutputWriter_Put_Call { + _c.Call.Return(run) + return _c +} + +// NewOutputWriter creates a new instance of OutputWriter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewOutputWriter(t interface { + mock.TestingT + Cleanup(func()) +}) *OutputWriter { + mock := &OutputWriter{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/io/mocks/raw_output_paths.go b/flyteplugins/go/tasks/pluginmachinery/io/mocks/raw_output_paths.go new file mode 100644 index 0000000000..45e8db71f4 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/io/mocks/raw_output_paths.go @@ -0,0 +1,80 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + storage "github.com/flyteorg/flyte/v2/flytestdlib/storage" + mock "github.com/stretchr/testify/mock" +) + +// RawOutputPaths is an autogenerated mock type for the RawOutputPaths type +type RawOutputPaths struct { + mock.Mock +} + +type RawOutputPaths_Expecter struct { + mock *mock.Mock +} + +func (_m *RawOutputPaths) EXPECT() *RawOutputPaths_Expecter { + return &RawOutputPaths_Expecter{mock: &_m.Mock} +} + +// GetRawOutputPrefix provides a mock function with no fields +func (_m *RawOutputPaths) GetRawOutputPrefix() storage.DataReference { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetRawOutputPrefix") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func() storage.DataReference); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// RawOutputPaths_GetRawOutputPrefix_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRawOutputPrefix' +type RawOutputPaths_GetRawOutputPrefix_Call struct { + *mock.Call +} + +// GetRawOutputPrefix is a helper method to define mock.On call +func (_e *RawOutputPaths_Expecter) GetRawOutputPrefix() *RawOutputPaths_GetRawOutputPrefix_Call { + return &RawOutputPaths_GetRawOutputPrefix_Call{Call: _e.mock.On("GetRawOutputPrefix")} +} + +func (_c *RawOutputPaths_GetRawOutputPrefix_Call) Run(run func()) *RawOutputPaths_GetRawOutputPrefix_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RawOutputPaths_GetRawOutputPrefix_Call) Return(_a0 storage.DataReference) *RawOutputPaths_GetRawOutputPrefix_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RawOutputPaths_GetRawOutputPrefix_Call) RunAndReturn(run func() storage.DataReference) *RawOutputPaths_GetRawOutputPrefix_Call { + _c.Call.Return(run) + return _c +} + +// NewRawOutputPaths creates a new instance of RawOutputPaths. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRawOutputPaths(t interface { + mock.TestingT + Cleanup(func()) +}) *RawOutputPaths { + mock := &RawOutputPaths{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/buffered_output_writer.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/buffered_output_writer.go new file mode 100644 index 0000000000..d6da8c7fe3 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/buffered_output_writer.go @@ -0,0 +1,29 @@ +package ioutils + +import ( + "context" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" +) + +// A Buffered outputWriter just records the io.OutputReader and can be accessed using special methods. +type BufferedOutputWriter struct { + io.OutputFilePaths + outReader io.OutputReader +} + +func (o *BufferedOutputWriter) Put(ctx context.Context, reader io.OutputReader) error { + o.outReader = reader + return nil +} + +func (o *BufferedOutputWriter) GetReader() io.OutputReader { + return o.outReader +} + +// Returns a new object of type BufferedOutputWriter +func NewBufferedOutputWriter(ctx context.Context, paths io.OutputFilePaths) *BufferedOutputWriter { + return &BufferedOutputWriter{ + OutputFilePaths: paths, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/cached_input_reader.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/cached_input_reader.go new file mode 100644 index 0000000000..ee12a31d7b --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/cached_input_reader.go @@ -0,0 +1,32 @@ +package ioutils + +import ( + "context" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +type cachedInputReader struct { + io.InputReader + cachedInputs *core.LiteralMap +} + +func (c *cachedInputReader) Get(ctx context.Context) (*core.LiteralMap, error) { + if c.cachedInputs == nil { + in, err := c.InputReader.Get(ctx) + if err != nil { + return nil, err + } + c.cachedInputs = in + } + return c.cachedInputs, nil +} + +// Creates a new Read-through cached Input Reader. the returned reader is not thread-safe +// It caches the inputs on a successful read from the underlying input reader +func NewCachedInputReader(ctx context.Context, in io.InputReader) io.InputReader { + return &cachedInputReader{ + InputReader: in, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/config.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/config.go new file mode 100644 index 0000000000..ad50995a9c --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/config.go @@ -0,0 +1,27 @@ +package ioutils + +import ( + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/config" +) + +//go:generate pflags Config --default-var=defaultConfig + +var cfgSection = config.MustRegisterSubSection("ioutils", defaultConfig) + +type Config struct { + RemoteFileOutputPathsConfig RemoteFileOutputPathsConfig `json:"remoteFileOutputPaths" pflag:",Config for remote file output paths."` +} + +type RemoteFileOutputPathsConfig struct { + DeckFilename string `json:"deckFilename" pflag:",Filename to use for the deck file."` +} + +var defaultConfig = &Config{ + RemoteFileOutputPathsConfig: RemoteFileOutputPathsConfig{ + DeckFilename: "deck.html", + }, +} + +func GetConfig() *Config { + return cfgSection.GetConfig().(*Config) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/config_flags.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/config_flags.go new file mode 100755 index 0000000000..2658e74658 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/config_flags.go @@ -0,0 +1,55 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package ioutils + +import ( + "encoding/json" + "reflect" + + "fmt" + + "github.com/spf13/pflag" +) + +// If v is a pointer, it will get its element value or the zero value of the element type. +// If v is not a pointer, it will return it as is. +func (Config) elemValueOrNil(v interface{}) interface{} { + if t := reflect.TypeOf(v); t.Kind() == reflect.Ptr { + if reflect.ValueOf(v).IsNil() { + return reflect.Zero(t.Elem()).Interface() + } else { + return reflect.ValueOf(v).Interface() + } + } else if v == nil { + return reflect.Zero(t).Interface() + } + + return v +} + +func (Config) mustJsonMarshal(v interface{}) string { + raw, err := json.Marshal(v) + if err != nil { + panic(err) + } + + return string(raw) +} + +func (Config) mustMarshalJSON(v json.Marshaler) string { + raw, err := v.MarshalJSON() + if err != nil { + panic(err) + } + + return string(raw) +} + +// GetPFlagSet will return strongly types pflags for all fields in Config and its nested types. The format of the +// flags is json-name.json-sub-name... etc. +func (cfg Config) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("Config", pflag.ExitOnError) + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "remoteFileOutputPaths.deckFilename"), defaultConfig.RemoteFileOutputPathsConfig.DeckFilename, "Filename to use for the deck file.") + return cmdFlags +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/config_flags_test.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/config_flags_test.go new file mode 100755 index 0000000000..4db1b9fd1b --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/config_flags_test.go @@ -0,0 +1,116 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package ioutils + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "testing" + + "github.com/mitchellh/mapstructure" + "github.com/stretchr/testify/assert" +) + +var dereferencableKindsConfig = map[reflect.Kind]struct{}{ + reflect.Array: {}, reflect.Chan: {}, reflect.Map: {}, reflect.Ptr: {}, reflect.Slice: {}, +} + +// Checks if t is a kind that can be dereferenced to get its underlying type. +func canGetElementConfig(t reflect.Kind) bool { + _, exists := dereferencableKindsConfig[t] + return exists +} + +// This decoder hook tests types for json unmarshaling capability. If implemented, it uses json unmarshal to build the +// object. Otherwise, it'll just pass on the original data. +func jsonUnmarshalerHookConfig(_, to reflect.Type, data interface{}) (interface{}, error) { + unmarshalerType := reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + if to.Implements(unmarshalerType) || reflect.PtrTo(to).Implements(unmarshalerType) || + (canGetElementConfig(to.Kind()) && to.Elem().Implements(unmarshalerType)) { + + raw, err := json.Marshal(data) + if err != nil { + fmt.Printf("Failed to marshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + res := reflect.New(to).Interface() + err = json.Unmarshal(raw, &res) + if err != nil { + fmt.Printf("Failed to umarshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + return res, nil + } + + return data, nil +} + +func decode_Config(input, result interface{}) error { + config := &mapstructure.DecoderConfig{ + TagName: "json", + WeaklyTypedInput: true, + Result: result, + DecodeHook: mapstructure.ComposeDecodeHookFunc( + mapstructure.StringToTimeDurationHookFunc(), + mapstructure.StringToSliceHookFunc(","), + jsonUnmarshalerHookConfig, + ), + } + + decoder, err := mapstructure.NewDecoder(config) + if err != nil { + return err + } + + return decoder.Decode(input) +} + +func join_Config(arr interface{}, sep string) string { + listValue := reflect.ValueOf(arr) + strs := make([]string, 0, listValue.Len()) + for i := 0; i < listValue.Len(); i++ { + strs = append(strs, fmt.Sprintf("%v", listValue.Index(i))) + } + + return strings.Join(strs, sep) +} + +func testDecodeJson_Config(t *testing.T, val, result interface{}) { + assert.NoError(t, decode_Config(val, result)) +} + +func testDecodeRaw_Config(t *testing.T, vStringSlice, result interface{}) { + assert.NoError(t, decode_Config(vStringSlice, result)) +} + +func TestConfig_GetPFlagSet(t *testing.T) { + val := Config{} + cmdFlags := val.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) +} + +func TestConfig_SetFlags(t *testing.T) { + actual := Config{} + cmdFlags := actual.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) + + t.Run("Test_remoteFileOutputPaths.deckFilename", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("remoteFileOutputPaths.deckFilename", testValue) + if vString, err := cmdFlags.GetString("remoteFileOutputPaths.deckFilename"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.RemoteFileOutputPathsConfig.DeckFilename) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/data_sharder.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/data_sharder.go new file mode 100644 index 0000000000..ae467afb0d --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/data_sharder.go @@ -0,0 +1,8 @@ +package ioutils + +import "context" + +// This interface allows shard selection for OutputSandbox. +type ShardSelector interface { + GetShardPrefix(ctx context.Context, s []byte) (string, error) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/doc.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/doc.go new file mode 100644 index 0000000000..bc0381a283 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/doc.go @@ -0,0 +1,5 @@ +// Package ioutils contains utilities for interacting with the IO Layer of FlytePropeller Metastore +// For example, utilities like reading inputs, writing outputs, computing output paths, prefixes. +// These helpers are intended to be used by FlytePropeller and aim to reduce the burden of implementing simple +// io functions +package ioutils diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/in_memory_output_reader.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/in_memory_output_reader.go new file mode 100644 index 0000000000..55da5b16d6 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/in_memory_output_reader.go @@ -0,0 +1,55 @@ +package ioutils + +import ( + "context" + "fmt" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +type InMemoryOutputReader struct { + literals *core.LiteralMap + DeckPath *storage.DataReference + err *io.ExecutionError +} + +var _ io.OutputReader = InMemoryOutputReader{} + +func (r InMemoryOutputReader) IsError(ctx context.Context) (bool, error) { + return r.err != nil, nil +} + +func (r InMemoryOutputReader) ReadError(ctx context.Context) (io.ExecutionError, error) { + if r.err != nil { + return *r.err, nil + } + + return io.ExecutionError{}, fmt.Errorf("no execution error specified") +} + +func (r InMemoryOutputReader) IsFile(_ context.Context) bool { + return false +} + +func (r InMemoryOutputReader) Exists(_ context.Context) (bool, error) { + // TODO: should this return true if there is an error? + return r.literals != nil, nil +} + +func (r InMemoryOutputReader) Read(_ context.Context) (*core.LiteralMap, *io.ExecutionError, error) { + return r.literals, r.err, nil +} + +func (r InMemoryOutputReader) DeckExists(_ context.Context) (bool, error) { + return r.DeckPath != nil, nil +} + +func NewInMemoryOutputReader(literals *core.LiteralMap, DeckPath *storage.DataReference, err *io.ExecutionError) InMemoryOutputReader { + return InMemoryOutputReader{ + literals: literals, + DeckPath: DeckPath, + err: err, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/in_memory_output_reader_test.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/in_memory_output_reader_test.go new file mode 100644 index 0000000000..8801c5819c --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/in_memory_output_reader_test.go @@ -0,0 +1,45 @@ +package ioutils + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + flyteIdlCore "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestInMemoryOutputReader(t *testing.T) { + deckPath := storage.DataReference("s3://bucket/key") + lt := map[string]*flyteIdlCore.Literal{ + "results": { + Value: &flyteIdlCore.Literal_Scalar{ + Scalar: &flyteIdlCore.Scalar{ + Value: &flyteIdlCore.Scalar_Primitive{ + Primitive: &flyteIdlCore.Primitive{Value: &flyteIdlCore.Primitive_Integer{Integer: 3}}, + }, + }, + }, + }, + } + or := NewInMemoryOutputReader(&flyteIdlCore.LiteralMap{Literals: lt}, &deckPath, nil) + + assert.Equal(t, &deckPath, or.DeckPath) + ctx := context.TODO() + + ok, err := or.IsError(ctx) + assert.False(t, ok) + assert.NoError(t, err) + + assert.False(t, or.IsFile(ctx)) + + ok, err = or.Exists(ctx) + assert.True(t, ok) + assert.NoError(t, err) + + literalMap, executionErr, err := or.Read(ctx) + assert.Equal(t, lt, literalMap.Literals) + assert.Nil(t, executionErr) + assert.NoError(t, err) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/paths.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/paths.go new file mode 100644 index 0000000000..af68f0eade --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/paths.go @@ -0,0 +1,57 @@ +package ioutils + +import ( + "context" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + +const ( + // InputsSuffix specifies the name of the file that contains the task inputs in the form core.LiteralMap + InputsSuffix = "inputs.pb" + // TaskTemplateSuffix In case a task requests for a task template, it is passed into the task using this filename. + // The format is of type core.TaskTemplate + TaskTemplateSuffix = "task.pb" + // FuturesSuffix specifies that for dynamic workflows, the futures files is written with this filename/suffix. + // The format is core.DynamicJobSpec + FuturesSuffix = "futures.pb" + // OutputsSuffix specifies that outputs are assumed to be written to this "file"/"suffix" under the given prefix + // The outputs file has a format of core.LiteralMap + OutputsSuffix = "outputs.pb" + // ErrorsSuffix specifies that the errors are written to this prefix/file under the given prefix. The Error File + // has a format of core.ErrorDocument + ErrorsSuffix = "error.pb" + IndexLookupSuffix = "indexlookup.pb" + // CheckpointPrefix specifies the common prefix that can be used as a directory where all the checkpoint information + // will be stored. This directory is under the raw output-prefix path + CheckpointPrefix = "_flytecheckpoints" +) + +// ConstructCheckpointPath returns a checkpoint path under the given `base` / rawOutputPrefix, following the conventions of +// the store +func ConstructCheckpointPath(store storage.ReferenceConstructor, rawOutputPrefix storage.DataReference) storage.DataReference { + if len(rawOutputPrefix) == 0 { + return "" + } + return constructPath(store, rawOutputPrefix, CheckpointPrefix) +} + +func constructPath(store storage.ReferenceConstructor, base storage.DataReference, suffix string) storage.DataReference { + res, err := store.ConstructReference(context.Background(), base, suffix) + if err != nil { + logger.Errorf(context.Background(), "Failed to construct path. Base[%v] Error: %v", base, err) + } + + return res +} + +// GetTaskTemplatePath returns a protobuf file path where TaskTemplate is stored +func GetTaskTemplatePath(ctx context.Context, store storage.ReferenceConstructor, base storage.DataReference) (storage.DataReference, error) { + return store.ConstructReference(ctx, base, TaskTemplateSuffix) +} + +// GetIndexLookupPath returns the indexpath suffixed to IndexLookupSuffix +func GetIndexLookupPath(ctx context.Context, store storage.ReferenceConstructor, prefix storage.DataReference) (res storage.DataReference, err error) { + return store.ConstructReference(ctx, prefix, IndexLookupSuffix) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/paths_test.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/paths_test.go new file mode 100644 index 0000000000..8f61c0810d --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/paths_test.go @@ -0,0 +1,34 @@ +package ioutils + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + +func TestConstructCheckpointPath(t *testing.T) { + store := storage.URLPathConstructor{} + assert.Equal(t, ConstructCheckpointPath(store, "s3://my-bucket/base"), + storage.DataReference("s3://my-bucket/base/_flytecheckpoints")) + assert.Equal(t, ConstructCheckpointPath(store, "s3://my-bucket/base2/"), + storage.DataReference("s3://my-bucket/base2/_flytecheckpoints")) + assert.Equal(t, ConstructCheckpointPath(store, ""), + storage.DataReference("")) +} + +func TestGetTaskTemplatePath(t *testing.T) { + store := storage.URLPathConstructor{} + tmpl, err := GetTaskTemplatePath(context.TODO(), store, "s3://abc") + assert.NoError(t, err) + assert.Equal(t, tmpl, storage.DataReference("s3://abc/task.pb")) +} + +func TestGetIndexLookupPath(t *testing.T) { + store := storage.URLPathConstructor{} + tmpl, err := GetIndexLookupPath(context.TODO(), store, "s3://abc") + assert.NoError(t, err) + assert.Equal(t, tmpl, storage.DataReference("s3://abc/indexlookup.pb")) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/precomputed_shardselector.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/precomputed_shardselector.go new file mode 100644 index 0000000000..2a20272f6e --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/precomputed_shardselector.go @@ -0,0 +1,73 @@ +package ioutils + +import ( + "context" + "hash/fnv" + "strings" + + "github.com/pkg/errors" +) + +// Generates the entire latin alphabet and appends it to the passed in array and returns the new array +func GenerateAlphabet(b []rune) []rune { + for i := 'a'; i <= 'z'; i++ { + b = append(b, i) + } + return b +} + +// Generates all arabic numerals and appends to the passed in array and returns the new array/slice +func GenerateArabicNumerals(b []rune) []rune { + for i := '0'; i <= '9'; i++ { + b = append(b, i) + } + return b +} + +func createAlphabetAndNumerals() []rune { + b := make([]rune, 0, 36) + b = GenerateAlphabet(b) + return GenerateArabicNumerals(b) +} + +// this sharder distributes data into one of the precomputed buckets. The bucket is deterministically determined given the input s +type PrecomputedShardSelector struct { + precomputedPrefixes []string + buckets uint32 +} + +// Generates deterministic shard id for the given string s +func (d *PrecomputedShardSelector) GetShardPrefix(_ context.Context, s []byte) (string, error) { + h := fnv.New32a() + _, err := h.Write(s) + if err != nil { + return "", errors.Wrap(err, "failed to create shard prefix, reason hash failure.") + } + idx := h.Sum32() % d.buckets + return d.precomputedPrefixes[idx], nil +} + +// Creates a PrecomputedShardSelector with 36*36 unique shards. Each shard is of the format {[0-9a-z][0-9a-z]}, i.e. 2 character long. +func NewBase36PrefixShardSelector(ctx context.Context) (ShardSelector, error) { + permittedChars := createAlphabetAndNumerals() + n := len(permittedChars) + precomputedPrefixes := make([]string, 0, n*n) + for _, c1 := range permittedChars { + for _, c2 := range permittedChars { + sb := strings.Builder{} + sb.WriteRune(c1) + sb.WriteRune(c2) + precomputedPrefixes = append(precomputedPrefixes, sb.String()) + } + } + + return NewConstantShardSelector(precomputedPrefixes), nil +} + +// uses the given shards to select a shard +func NewConstantShardSelector(shards []string) ShardSelector { + return &PrecomputedShardSelector{ + precomputedPrefixes: shards, + buckets: uint32(len(shards)), + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/precomputed_shardselector_test.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/precomputed_shardselector_test.go new file mode 100644 index 0000000000..d988be1309 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/precomputed_shardselector_test.go @@ -0,0 +1,61 @@ +package ioutils + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestPrecomputedShardSelector_GetShardPrefix(t *testing.T) { + ctx := context.TODO() + t.Run("single-shard", func(t *testing.T) { + ss := PrecomputedShardSelector{precomputedPrefixes: []string{"x"}, buckets: 1} + p, err := ss.GetShardPrefix(ctx, []byte("abc")) + assert.NoError(t, err) + assert.Equal(t, "x", p) + }) + + t.Run("two-shards", func(t *testing.T) { + ss := PrecomputedShardSelector{precomputedPrefixes: []string{"x", "y"}, buckets: 2} + p, err := ss.GetShardPrefix(ctx, []byte("abc")) + assert.NoError(t, err) + assert.Equal(t, "y", p) + p, err = ss.GetShardPrefix(ctx, []byte("xyz")) + assert.NoError(t, err) + assert.Equal(t, "x", p) + }) +} + +func TestGenerateAlphabet(t *testing.T) { + var b []rune + b = GenerateAlphabet(b) + + assert.Equal(t, 26, len(b)) + assert.Equal(t, 'a', b[0]) + assert.Equal(t, 'z', b[25]) + + // Additive + b = GenerateAlphabet(b) + + assert.Equal(t, 52, len(b)) + assert.Equal(t, 'a', b[26]) + assert.Equal(t, 'z', b[51]) +} + +func TestGenerateArabicNumerals(t *testing.T) { + var b []rune + b = GenerateArabicNumerals(b) + + assert.Equal(t, 10, len(b)) + assert.Equal(t, '0', b[0]) + assert.Equal(t, '9', b[9]) + + // Additive + b = GenerateArabicNumerals(b) + assert.Equal(t, 20, len(b)) + assert.Equal(t, '0', b[0]) + assert.Equal(t, '9', b[9]) + assert.Equal(t, '0', b[10]) + assert.Equal(t, '9', b[19]) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/raw_output_path.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/raw_output_path.go new file mode 100644 index 0000000000..07199496ff --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/raw_output_path.go @@ -0,0 +1,100 @@ +package ioutils + +import ( + "context" + "crypto/sha1" // #nosec + "encoding/hex" + "strconv" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + core2 "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +type precomputedRawOutputPaths struct { + path storage.DataReference +} + +func (r precomputedRawOutputPaths) GetRawOutputPrefix() storage.DataReference { + return r.path +} + +// Creates a deterministic RawOutputPath whose path is distributed based on the ShardSelector passed in. +// Determinism depends on the outputMetadataPath +// Potential performance problem, as creating a new RawPath creation may be expensive as it hashes the outputMetadataPath +// the final RawOutputPath is created in the shard selected by the sharder at the basePath and then appended by a hashed value of the outputMetadata +func NewShardedDeterministicRawOutputPath(ctx context.Context, sharder ShardSelector, basePrefix, outputMetadataPrefix storage.DataReference, store storage.ReferenceConstructor) (io.RawOutputPaths, error) { + o := []byte(outputMetadataPrefix) + prefix, err := sharder.GetShardPrefix(ctx, o) + if err != nil { + return nil, err + } + /* #nosec */ + // We use SHA1 for sheer speed instead of no collisions. As because of the shard Prefix + hash is pretty unique :) + m := sha1.New() + if _, err := m.Write(o); err != nil { + return nil, err + } + path, err := store.ConstructReference(ctx, basePrefix, prefix, hex.EncodeToString(m.Sum(nil))) + if err != nil { + return nil, err + } + return precomputedRawOutputPaths{ + path: path, + }, nil +} + +// A simple Output sandbox at a given path +func NewRawOutputPaths(_ context.Context, rawOutputPrefix storage.DataReference) io.RawOutputPaths { + return precomputedRawOutputPaths{path: rawOutputPrefix} +} + +// Creates an OutputSandbox in the basePath using the uniqueID and a sharder +// This implementation is faster than the Randomized strategy +// This returns a path in the format of protocol:///{bucket}/{shard}/{optional_suffix_path_parts}/{exec-id}-n0-0/ +func NewShardedRawOutputPath(ctx context.Context, sharder ShardSelector, basePath storage.DataReference, suffixPathParts []string, uniqueID string, store storage.ReferenceConstructor) (io.RawOutputPaths, error) { + o := []byte(uniqueID) + prefix, err := sharder.GetShardPrefix(ctx, o) + if err != nil { + return nil, err + } + suffix := []string{prefix} + suffix = append(suffix, suffixPathParts...) + suffix = append(suffix, uniqueID) + path, err := store.ConstructReference(ctx, basePath, suffix...) + if err != nil { + return nil, err + } + return precomputedRawOutputPaths{ + path: path, + }, nil +} + +// Constructs an output path that is deterministic and unique within the given outputPrefix. No sharding is performed +func NewDeterministicUniqueRawOutputPath(ctx context.Context, rawOutputPrefix, outputMetadataPrefix storage.DataReference, store storage.ReferenceConstructor) (io.RawOutputPaths, error) { + o := []byte(outputMetadataPrefix) + /* #nosec */ + // We use SHA1 for sheer speed instead of no collisions. As because of the shard Prefix + hash is pretty unique :) + m := sha1.New() + if _, err := m.Write(o); err != nil { + return nil, err + } + path, err := store.ConstructReference(ctx, rawOutputPrefix, hex.EncodeToString(m.Sum(nil))) + if err != nil { + return nil, err + } + return precomputedRawOutputPaths{ + path: path, + }, nil +} + +// Generates a RawOutput Path that looks like the TaskExecutionID and can be easily cross referenced with Flyte generated TaskExecution ID +func NewTaskIDRawOutputPath(ctx context.Context, rawOutputPrefix storage.DataReference, taskID *core2.TaskExecutionIdentifier, store storage.ReferenceConstructor) (io.RawOutputPaths, error) { + path, err := store.ConstructReference(ctx, rawOutputPrefix, taskID.GetNodeExecutionId().GetExecutionId().GetProject(), taskID.GetNodeExecutionId().GetExecutionId().GetDomain(), taskID.GetNodeExecutionId().GetExecutionId().GetName(), taskID.GetNodeExecutionId().GetNodeId(), strconv.Itoa(int(taskID.GetRetryAttempt())), taskID.GetTaskId().GetName()) + if err != nil { + return nil, err + } + return precomputedRawOutputPaths{ + path: path, + }, nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/raw_output_path_test.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/raw_output_path_test.go new file mode 100644 index 0000000000..bb8caa7ff9 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/raw_output_path_test.go @@ -0,0 +1,89 @@ +package ioutils + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + core2 "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestNewOutputSandbox(t *testing.T) { + assert.Equal(t, NewRawOutputPaths(context.TODO(), "x").GetRawOutputPrefix(), storage.DataReference("x")) +} + +func TestNewShardedDeterministicRawOutputPath(t *testing.T) { + ctx := context.TODO() + + t.Run("success-path", func(t *testing.T) { + ss := NewConstantShardSelector([]string{"x"}) + sd, err := NewShardedDeterministicRawOutputPath(ctx, ss, "s3://bucket", "m", storage.URLPathConstructor{}) + assert.NoError(t, err) + assert.Equal(t, storage.DataReference("s3://bucket/x/6b0d31c0d563223024da45691584643ac78c96e8"), sd.GetRawOutputPrefix()) + }) + + t.Run("error", func(t *testing.T) { + ss := NewConstantShardSelector([]string{"s3:// abc"}) + sd, err := NewShardedDeterministicRawOutputPath(ctx, ss, "s3://bucket", "m", storage.URLPathConstructor{}) + assert.Error(t, err, "%s", sd) + }) +} + +func TestNewShardedRawOutputPath(t *testing.T) { + ctx := context.TODO() + t.Run("", func(t *testing.T) { + ss := NewConstantShardSelector([]string{"x"}) + sd, err := NewShardedRawOutputPath(ctx, ss, "s3://flyte", make([]string, 0), "unique", storage.URLPathConstructor{}) + assert.NoError(t, err) + assert.Equal(t, storage.DataReference("s3://flyte/x/unique"), sd.GetRawOutputPrefix()) + }) + t.Run("with suffix", func(t *testing.T) { + ss := NewConstantShardSelector([]string{"x"}) + sd, err := NewShardedRawOutputPath(ctx, ss, "s3://flyte", []string{"suffix"}, "unique", storage.URLPathConstructor{}) + assert.NoError(t, err) + assert.Equal(t, storage.DataReference("s3://flyte/x/suffix/unique"), sd.GetRawOutputPrefix()) + }) + + t.Run("error", func(t *testing.T) { + ss := NewConstantShardSelector([]string{"s3:// abc"}) + sd, err := NewShardedRawOutputPath(ctx, ss, "s3://bucket", make([]string, 0), "m", storage.URLPathConstructor{}) + assert.Error(t, err, "%s", sd) + }) +} + +func TestNewDeterministicUniqueRawOutputPath(t *testing.T) { + ctx := context.TODO() + + t.Run("success-path", func(t *testing.T) { + sd, err := NewDeterministicUniqueRawOutputPath(ctx, "s3://bucket", "m", storage.URLPathConstructor{}) + assert.NoError(t, err) + assert.Equal(t, storage.DataReference("s3://bucket/6b0d31c0d563223024da45691584643ac78c96e8"), sd.GetRawOutputPrefix()) + }) + + t.Run("error-not-possible", func(t *testing.T) { + sd, err := NewDeterministicUniqueRawOutputPath(ctx, "bucket", "m", storage.URLPathConstructor{}) + assert.NoError(t, err) + assert.Equal(t, "/bucket/6b0d31c0d563223024da45691584643ac78c96e8", sd.GetRawOutputPrefix().String()) + }) +} + +func TestNewTaskIDRawOutputPath(t *testing.T) { + p, err := NewTaskIDRawOutputPath(context.TODO(), "s3://bucket", &core2.TaskExecutionIdentifier{ + NodeExecutionId: &core2.NodeExecutionIdentifier{ + NodeId: "n1", + ExecutionId: &core2.WorkflowExecutionIdentifier{ + Project: "project", + Domain: "domain", + Name: "exec", + }, + }, + RetryAttempt: 0, + TaskId: &core2.Identifier{ + Name: "task1", + }, + }, storage.URLPathConstructor{}) + assert.NoError(t, err) + assert.Equal(t, "s3://bucket/project/domain/exec/n1/0/task1", p.GetRawOutputPrefix().String()) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/remote_file_input_reader.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/remote_file_input_reader.go new file mode 100644 index 0000000000..04608d8cc2 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/remote_file_input_reader.go @@ -0,0 +1,63 @@ +package ioutils + +import ( + "context" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const ( + ErrFailedRead string = "READ_FAILED" +) + +var ( + // Ensure we get an early build break if interface changes and these classes do not conform. + _ io.InputFilePaths = SimpleInputFilePath{} + _ io.InputReader = RemoteFileInputReader{} +) + +type RemoteFileInputReader struct { + io.InputFilePaths + store storage.ProtobufStore +} + +func (r RemoteFileInputReader) Get(ctx context.Context) (*core.LiteralMap, error) { + d := &core.LiteralMap{} + if err := r.store.ReadProtobuf(ctx, r.InputFilePaths.GetInputPath(), d); err != nil { + // TODO change flytestdlib to return protobuf unmarshal errors separately. As this can indicate malformed output and we should catch that + return nil, errors.Wrapf(ErrFailedRead, err, "failed to read data from dataDir [%v].", r.InputFilePaths.GetInputPath()) + } + + return d, nil + +} + +func NewRemoteFileInputReader(_ context.Context, store storage.ProtobufStore, inputPaths io.InputFilePaths) RemoteFileInputReader { + return RemoteFileInputReader{ + InputFilePaths: inputPaths, + store: store, + } +} + +type SimpleInputFilePath struct { + pathPrefix storage.DataReference + store storage.ReferenceConstructor +} + +func (s SimpleInputFilePath) GetInputPrefixPath() storage.DataReference { + return s.pathPrefix +} + +func (s SimpleInputFilePath) GetInputPath() storage.DataReference { + return constructPath(s.store, s.pathPrefix, InputsSuffix) +} + +func NewInputFilePaths(_ context.Context, store storage.ReferenceConstructor, inputPathPrefix storage.DataReference) SimpleInputFilePath { + return SimpleInputFilePath{ + store: store, + pathPrefix: inputPathPrefix, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/remote_file_input_reader_test.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/remote_file_input_reader_test.go new file mode 100644 index 0000000000..3e9476b2f1 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/remote_file_input_reader_test.go @@ -0,0 +1,18 @@ +package ioutils + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + +func TestSimpleInputFilePath_GetInputPath(t *testing.T) { + s := SimpleInputFilePath{ + pathPrefix: "s3://flyteorg-modelbuilder/metadata/propeller/staging/flyteexamples-development-jf193q0cqo/odd-nums-task/data", + store: storage.URLPathConstructor{}, + } + + assert.Equal(t, "s3://flyteorg-modelbuilder/metadata/propeller/staging/flyteexamples-development-jf193q0cqo/odd-nums-task/data/inputs.pb", s.GetInputPath().String()) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/remote_file_output_reader.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/remote_file_output_reader.go new file mode 100644 index 0000000000..b1f9a61ade --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/remote_file_output_reader.go @@ -0,0 +1,139 @@ +package ioutils + +import ( + "context" + "fmt" + + "github.com/pkg/errors" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +type RemoteFileOutputReader struct { + OutPath io.OutputFilePaths + store storage.ComposedProtobufStore + maxPayloadSize int64 +} + +var _ io.OutputReader = RemoteFileOutputReader{} + +func (r RemoteFileOutputReader) IsError(ctx context.Context) (bool, error) { + metadata, err := r.store.Head(ctx, r.OutPath.GetErrorPath()) + if err != nil { + return false, errors.Wrapf(err, "failed to read error file @[%s]", r.OutPath.GetErrorPath()) + } + if metadata.Exists() { + if metadata.Size() > r.maxPayloadSize { + return false, errors.Wrapf(err, "error file @[%s] is too large [%d] bytes, max allowed [%d] bytes", r.OutPath.GetErrorPath(), metadata.Size(), r.maxPayloadSize) + } + return true, nil + } + return false, nil +} + +func (r RemoteFileOutputReader) ReadError(ctx context.Context) (io.ExecutionError, error) { + errorDoc := &core.ErrorDocument{} + err := r.store.ReadProtobuf(ctx, r.OutPath.GetErrorPath(), errorDoc) + if err != nil { + if storage.IsNotFound(err) { + return io.ExecutionError{ + IsRecoverable: true, + ExecutionError: &core.ExecutionError{ + Code: "ErrorFileNotFound", + Message: err.Error(), + Kind: core.ExecutionError_SYSTEM, + }, + }, nil + } + return io.ExecutionError{}, errors.Wrapf(err, "failed to read error data from task @[%s]", r.OutPath.GetErrorPath()) + } + + if errorDoc.Error == nil { + return io.ExecutionError{ + IsRecoverable: true, + ExecutionError: &core.ExecutionError{ + Code: "ErrorFileBadFormat", + Message: fmt.Sprintf("error not formatted correctly, nil error @path [%s]", r.OutPath.GetErrorPath()), + Kind: core.ExecutionError_SYSTEM, + }, + }, nil + } + + ee := io.ExecutionError{ + ExecutionError: &core.ExecutionError{ + Code: errorDoc.Error.Code, + Message: errorDoc.Error.Message, + Kind: errorDoc.Error.Origin, + }, + } + + if errorDoc.Error.Kind == core.ContainerError_RECOVERABLE { + ee.IsRecoverable = true + } + + return ee, nil +} + +func (r RemoteFileOutputReader) Exists(ctx context.Context) (bool, error) { + md, err := r.store.Head(ctx, r.OutPath.GetOutputPath()) + if err != nil { + return false, err + } + if md.Exists() { + if md.Size() > r.maxPayloadSize { + return false, errors.Errorf("output file @[%s] is too large [%d] bytes, max allowed [%d] bytes", r.OutPath.GetOutputPath(), md.Size(), r.maxPayloadSize) + } + return true, nil + } + return false, nil +} + +func (r RemoteFileOutputReader) Read(ctx context.Context) (*core.LiteralMap, *io.ExecutionError, error) { + + d := &core.LiteralMap{} + if err := r.store.ReadProtobuf(ctx, r.OutPath.GetOutputPath(), d); err != nil { + // TODO change flytestdlib to return protobuf unmarshal errors separately. As this can indicate malformed output and we should catch that + return nil, nil, fmt.Errorf("failed to read data from dataDir [%v]. Error: %v", r.OutPath.GetOutputPath(), err) + } + + if d.Literals == nil { + return nil, &io.ExecutionError{ + IsRecoverable: true, + ExecutionError: &core.ExecutionError{ + Code: "No outputs produced", + Message: fmt.Sprintf("outputs not found at [%s]", r.OutPath.GetOutputPath()), + }, + }, nil + } + + return d, nil, nil +} + +func (r RemoteFileOutputReader) IsFile(ctx context.Context) bool { + return true +} + +func (r RemoteFileOutputReader) DeckExists(ctx context.Context) (bool, error) { + md, err := r.store.Head(ctx, r.OutPath.GetDeckPath()) + if err != nil { + return false, err + } + + return md.Exists(), nil +} + +func NewRemoteFileOutputReader(_ context.Context, store storage.ComposedProtobufStore, outPaths io.OutputFilePaths, maxDatasetSize int64) RemoteFileOutputReader { + // Note: even though the data store retrieval checks against GetLimitMegabytes, there might be external + // storage implementations, so we keep this check here as well. + maxPayloadSize := maxDatasetSize + if maxPayloadSize == 0 { + maxPayloadSize = storage.GetConfig().Limits.GetLimitMegabytes * 1024 * 1024 + } + return RemoteFileOutputReader{ + OutPath: outPaths, + store: store, + maxPayloadSize: maxPayloadSize, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/remote_file_output_reader_test.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/remote_file_output_reader_test.go new file mode 100644 index 0000000000..cedd8fb4d2 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/remote_file_output_reader_test.go @@ -0,0 +1,109 @@ +package ioutils + +import ( + "context" + "testing" + + pluginsIOMock "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io/mocks" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + storageMocks "github.com/flyteorg/flyte/v2/flytestdlib/storage/mocks" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "google.golang.org/protobuf/runtime/protoiface" +) + +type MemoryMetadata struct { + exists bool + size int64 + etag string + contentMD5 string +} + +func (m MemoryMetadata) ContentMD5() string { + return m.contentMD5 +} + +func (m MemoryMetadata) Size() int64 { + return m.size +} + +func (m MemoryMetadata) Exists() bool { + return m.exists +} + +func (m MemoryMetadata) Etag() string { + return m.etag +} + +func TestReadOrigin(t *testing.T) { + ctx := context.TODO() + + opath := &pluginsIOMock.OutputFilePaths{} + opath.EXPECT().GetErrorPath().Return("") + deckPath := "deck.html" + opath.EXPECT().GetDeckPath().Return(storage.DataReference(deckPath)) + + t.Run("user", func(t *testing.T) { + errorDoc := &core.ErrorDocument{ + Error: &core.ContainerError{ + Code: "red", + Message: "hi", + Kind: core.ContainerError_NON_RECOVERABLE, + Origin: core.ExecutionError_USER, + }, + } + store := &storageMocks.ComposedProtobufStore{} + store.EXPECT().ReadProtobuf(mock.Anything, mock.Anything, mock.Anything).Run(func(ctx context.Context, ref storage.DataReference, msg protoiface.MessageV1) { + assert.NotNil(t, msg) + casted := msg.(*core.ErrorDocument) + casted.Error = errorDoc.Error + }).Return(nil) + + store.EXPECT().Head(ctx, storage.DataReference("deck.html")).Return(MemoryMetadata{ + exists: true, + }, nil) + + r := RemoteFileOutputReader{ + OutPath: opath, + store: store, + maxPayloadSize: 0, + } + + ee, err := r.ReadError(ctx) + assert.NoError(t, err) + assert.Equal(t, core.ExecutionError_USER, ee.Kind) + assert.False(t, ee.IsRecoverable) + exists, err := r.DeckExists(ctx) + assert.NoError(t, err) + assert.True(t, exists) + }) + + t.Run("system", func(t *testing.T) { + errorDoc := &core.ErrorDocument{ + Error: &core.ContainerError{ + Code: "red", + Message: "hi", + Kind: core.ContainerError_RECOVERABLE, + Origin: core.ExecutionError_SYSTEM, + }, + } + store := &storageMocks.ComposedProtobufStore{} + store.EXPECT().ReadProtobuf(mock.Anything, mock.Anything, mock.Anything).Run(func(ctx context.Context, ref storage.DataReference, msg protoiface.MessageV1) { + assert.NotNil(t, msg) + casted := msg.(*core.ErrorDocument) + casted.Error = errorDoc.Error + }).Return(nil) + + r := RemoteFileOutputReader{ + OutPath: opath, + store: store, + maxPayloadSize: 0, + } + + ee, err := r.ReadError(ctx) + assert.NoError(t, err) + assert.Equal(t, core.ExecutionError_SYSTEM, ee.Kind) + assert.True(t, ee.IsRecoverable) + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/remote_file_output_writer.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/remote_file_output_writer.go new file mode 100644 index 0000000000..4c3111274b --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/remote_file_output_writer.go @@ -0,0 +1,138 @@ +package ioutils + +import ( + "context" + "fmt" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +var ( + _ io.OutputWriter = RemoteFileOutputWriter{} + _ io.OutputFilePaths = RemoteCheckpointPaths{} +) + +// RemoteFileOutputPaths records all metadata output paths / keys on a remote storage system, e.g. S3 / GCS or any other +// key-value store. Theoretically if the storage.DataReference can support BigTable, this will work with it. +type RemoteFileOutputPaths struct { + // All returned paths for the metadata outputs (inputs.pb and outputs.pb) of an input are constructed to under + // this prefix + outputPrefix storage.DataReference + // Implemented of the ReferenceConstructor, used to construct the actual paths + store storage.ReferenceConstructor + // Arbitrary supplied of the RawOutputPath + io.RawOutputPaths +} + +func (w RemoteFileOutputPaths) GetOutputPrefixPath() storage.DataReference { + return w.outputPrefix +} + +func (w RemoteFileOutputPaths) GetOutputPath() storage.DataReference { + return constructPath(w.store, w.outputPrefix, OutputsSuffix) +} + +func (w RemoteFileOutputPaths) GetDeckPath() storage.DataReference { + deckSuffix := GetConfig().RemoteFileOutputPathsConfig.DeckFilename + return constructPath(w.store, w.outputPrefix, deckSuffix) +} + +func (w RemoteFileOutputPaths) GetErrorPath() storage.DataReference { + return constructPath(w.store, w.outputPrefix, ErrorsSuffix) +} + +func (w RemoteFileOutputPaths) GetFuturesPath() storage.DataReference { + return constructPath(w.store, w.outputPrefix, FuturesSuffix) +} + +// RemoteFileOutputWriter adds storage Write APIs to output paths / keys. In retrospect, the `path` should be +// generally replaced with keys +type RemoteFileOutputWriter struct { + io.OutputFilePaths + store storage.ProtobufStore +} + +func (w RemoteFileOutputWriter) Put(ctx context.Context, reader io.OutputReader) error { + literals, executionErr, err := reader.Read(ctx) + if err != nil { + return err + } + + if executionErr != nil { + errorKind := core.ContainerError_RECOVERABLE + if !executionErr.IsRecoverable { + errorKind = core.ContainerError_NON_RECOVERABLE + } + + errDoc := &core.ErrorDocument{ + Error: &core.ContainerError{ + Code: executionErr.Code, + Message: executionErr.Message, + Kind: errorKind, + }, + } + + return w.store.WriteProtobuf(ctx, w.GetErrorPath(), storage.Options{}, errDoc) + } + + if literals != nil { + return w.store.WriteProtobuf(ctx, w.GetOutputPath(), storage.Options{}, literals) + } + + return fmt.Errorf("no data found to write") +} + +// RemoteCheckpointPaths implements the CheckpointPaths Interface and adds on top of the OutputFilePaths Interface +type RemoteCheckpointPaths struct { + RemoteFileOutputPaths + + previousPath storage.DataReference + + store storage.ReferenceConstructor +} + +// GetPreviousCheckpointsPrefix returns the Prefix path for checkpoints for the previous attempt, or "" if this is +// the first attempt +func (r RemoteCheckpointPaths) GetPreviousCheckpointsPrefix() storage.DataReference { + return r.previousPath +} + +// GetCheckpointPrefix returns a new checkpoint path under the raw output prefix. +func (r RemoteCheckpointPaths) GetCheckpointPrefix() storage.DataReference { + return ConstructCheckpointPath(r.store, r.GetRawOutputPrefix()) +} + +// NewRemoteFileOutputPaths returns a RemoteFileOutputPaths object, where all the paths are configured using the given +// outputPrefix and constructed using the storage.ReferenceConstructor +func NewRemoteFileOutputPaths(_ context.Context, store storage.ReferenceConstructor, outputPrefix storage.DataReference, sandbox io.RawOutputPaths) RemoteFileOutputPaths { + return RemoteFileOutputPaths{ + store: store, + outputPrefix: outputPrefix, + RawOutputPaths: sandbox, + } +} + +// NewCheckpointRemoteFilePaths returns a new object constructed with an optional previousCheckpointPath and derives a new checkpointPath from the outputPrefix +func NewCheckpointRemoteFilePaths(ctx context.Context, store storage.ReferenceConstructor, outputPrefix storage.DataReference, sandbox io.RawOutputPaths, previousCheckpointPath storage.DataReference) RemoteCheckpointPaths { + return RemoteCheckpointPaths{ + previousPath: previousCheckpointPath, + store: store, + RemoteFileOutputPaths: NewRemoteFileOutputPaths(ctx, store, outputPrefix, sandbox), + } +} + +// NewReadOnlyOutputFilePaths can be used when data is only to be read from an existing remote location +func NewReadOnlyOutputFilePaths(ctx context.Context, store storage.ReferenceConstructor, outputPrefix storage.DataReference) RemoteCheckpointPaths { + return NewCheckpointRemoteFilePaths(ctx, store, outputPrefix, nil, "") +} + +// NewRemoteFileOutputWriter returns a writer that records all outputs to remote files / objects. Given outputs, +// it will automatically write it to the outputFile / key that is configured. +func NewRemoteFileOutputWriter(_ context.Context, store storage.ProtobufStore, outputFilePaths io.OutputFilePaths) RemoteFileOutputWriter { + return RemoteFileOutputWriter{ + OutputFilePaths: outputFilePaths, + store: store, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/remote_file_output_writer_test.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/remote_file_output_writer_test.go new file mode 100644 index 0000000000..e7d7f38593 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/remote_file_output_writer_test.go @@ -0,0 +1,49 @@ +package ioutils + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + +func TestRemoteFileOutputWriter(t *testing.T) { + ctx := context.TODO() + memStore, err := storage.NewDataStore(&storage.Config{Type: storage.TypeMemory}, promutils.NewTestScope()) + assert.Nil(t, err) + + outputPrefix := storage.DataReference("output") + rawOutputPrefix := storage.DataReference("sandbox") + previousCheckpointPath := storage.DataReference("checkpoint") + + checkpointPath := NewCheckpointRemoteFilePaths( + ctx, + memStore, + outputPrefix, + NewRawOutputPaths(ctx, rawOutputPrefix), + previousCheckpointPath, + ) + + t.Run("Test NewCheckpointRemoteFilePaths", func(t *testing.T) { + assert.Equal(t, previousCheckpointPath, checkpointPath.GetPreviousCheckpointsPrefix()) + assert.Equal(t, outputPrefix, checkpointPath.GetOutputPrefixPath()) + + assert.Equal(t, constructPath(memStore, rawOutputPrefix, CheckpointPrefix), checkpointPath.GetCheckpointPrefix()) + assert.Equal(t, constructPath(memStore, outputPrefix, OutputsSuffix), checkpointPath.GetOutputPath()) + assert.Equal(t, constructPath(memStore, outputPrefix, "deck.html"), checkpointPath.GetDeckPath()) + assert.Equal(t, constructPath(memStore, outputPrefix, ErrorsSuffix), checkpointPath.GetErrorPath()) + assert.Equal(t, constructPath(memStore, outputPrefix, FuturesSuffix), checkpointPath.GetFuturesPath()) + }) + + t.Run("Test NewRemoteFileOutputWriter", func(t *testing.T) { + p := NewRemoteFileOutputWriter(ctx, memStore, checkpointPath) + + assert.Equal(t, constructPath(memStore, rawOutputPrefix, CheckpointPrefix), p.GetCheckpointPrefix()) + assert.Equal(t, constructPath(memStore, outputPrefix, OutputsSuffix), p.GetOutputPath()) + assert.Equal(t, constructPath(memStore, outputPrefix, "deck.html"), p.GetDeckPath()) + assert.Equal(t, constructPath(memStore, outputPrefix, ErrorsSuffix), p.GetErrorPath()) + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/task_reader.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/task_reader.go new file mode 100644 index 0000000000..4fe685bac9 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/task_reader.go @@ -0,0 +1,59 @@ +package ioutils + +import ( + "context" + + "github.com/pkg/errors" + + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flytestdlib/atomic" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +var ( + _ pluginsCore.TaskReader = &lazyUploadingTaskReader{} +) + +// SimpleTaskReader provides only the TaskReader interface. This is created to conveniently use the uploading taskreader +// interface +type SimpleTaskReader interface { + Read(ctx context.Context) (*core.TaskTemplate, error) +} + +// lazyUploadingTaskReader provides a lazy interface that uploads the core.TaskTemplate to a configured location, +// only if the location is accessed. This reduces the potential overhead of writing the template +type lazyUploadingTaskReader struct { + SimpleTaskReader + uploaded atomic.Bool + store storage.ProtobufStore + remotePath storage.DataReference +} + +func (r *lazyUploadingTaskReader) Path(ctx context.Context) (storage.DataReference, error) { + // We are using atomic because it is ok to re-upload in some cases. We know that most of the plugins are + // executed in a single go-routine, so chances of a race condition are minimal. + if !r.uploaded.Load() { + t, err := r.SimpleTaskReader.Read(ctx) + if err != nil { + return "", err + } + err = r.store.WriteProtobuf(ctx, r.remotePath, storage.Options{}, t) + if err != nil { + return "", errors.Wrapf(err, "failed to store task template to remote path [%s]", r.remotePath) + } + r.uploaded.Store(true) + } + return r.remotePath, nil +} + +// NewLazyUploadingTaskReader decorates an existing TaskReader and adds a functionality to allow lazily uploading the task template to +// a remote location, only when the location information is accessed +func NewLazyUploadingTaskReader(baseTaskReader SimpleTaskReader, remotePath storage.DataReference, store storage.ProtobufStore) pluginsCore.TaskReader { + return &lazyUploadingTaskReader{ + SimpleTaskReader: baseTaskReader, + uploaded: atomic.NewBool(false), + store: store, + remotePath: remotePath, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/ioutils/task_reader_test.go b/flyteplugins/go/tasks/pluginmachinery/ioutils/task_reader_test.go new file mode 100644 index 0000000000..c27f8788b3 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/ioutils/task_reader_test.go @@ -0,0 +1,103 @@ +package ioutils + +import ( + "context" + "fmt" + "testing" + + "github.com/golang/protobuf/proto" + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils/labeled" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const dummyPath = storage.DataReference("test") + +func TestLazyUploadingTaskReader_Happy(t *testing.T) { + ttm := &core.TaskTemplate{} + + ctx := context.TODO() + tr := &mocks.TaskReader{} + tr.EXPECT().Read(ctx).Return(ttm, nil) + + ds, err := storage.NewDataStore(&storage.Config{ + Type: storage.TypeMemory, + }, promutils.NewTestScope()) + assert.NoError(t, err) + + ltr := NewLazyUploadingTaskReader(tr, dummyPath, ds) + + x, err := ltr.Read(ctx) + assert.NoError(t, err) + assert.Equal(t, x, ttm) + + p, err := ltr.Path(ctx) + assert.NoError(t, err) + assert.Equal(t, p, dummyPath) + + v, err := ds.Head(ctx, dummyPath) + assert.NoError(t, err) + assert.True(t, v.Exists()) +} + +// test storage.ProtobufStore to test upload failure +type failingProtoStore struct { + storage.ProtobufStore +} + +func (d *failingProtoStore) WriteProtobuf(ctx context.Context, reference storage.DataReference, opts storage.Options, msg proto.Message) error { + return fmt.Errorf("failed") +} + +func TestLazyUploadingTaskReader_TaskWriteFailure(t *testing.T) { + ttm := &core.TaskTemplate{} + + ctx := context.TODO() + tr := &mocks.TaskReader{} + tr.EXPECT().Read(ctx).Return(ttm, nil) + + ltr := NewLazyUploadingTaskReader(tr, dummyPath, &failingProtoStore{}) + + x, err := ltr.Read(ctx) + assert.NoError(t, err) + assert.Equal(t, x, ttm) + + p, err := ltr.Path(ctx) + assert.Error(t, err) + assert.Equal(t, p, storage.DataReference("")) +} + +func TestLazyUploadingTaskReader_TaskReadFailure(t *testing.T) { + + ctx := context.TODO() + tr := &mocks.TaskReader{} + tr.EXPECT().Read(ctx).Return(nil, fmt.Errorf("read fail")) + + ds, err := storage.NewDataStore(&storage.Config{ + Type: storage.TypeMemory, + }, promutils.NewTestScope()) + assert.NoError(t, err) + + ltr := NewLazyUploadingTaskReader(tr, dummyPath, ds) + + x, err := ltr.Read(ctx) + assert.Error(t, err) + assert.Nil(t, x) + + p, err := ltr.Path(ctx) + assert.Error(t, err) + assert.Equal(t, p, storage.DataReference("")) + + v, err := ds.Head(ctx, dummyPath) + assert.NoError(t, err) + assert.False(t, v.Exists()) +} + +func init() { + labeled.SetMetricKeys(contextutils.ExecIDKey) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/k8s/client.go b/flyteplugins/go/tasks/pluginmachinery/k8s/client.go new file mode 100644 index 0000000000..59068cf6bb --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/k8s/client.go @@ -0,0 +1,88 @@ +// Simple implementation of a KubeClient that caches reads and falls back +// to make direct API calls on failure. Write calls are not cached. +package k8s + +import ( + "k8s.io/apimachinery/pkg/api/meta" + "k8s.io/client-go/rest" + "sigs.k8s.io/controller-runtime/pkg/cache" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/client/apiutil" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" +) + +type kubeClient struct { + client client.Client + cache cache.Cache +} + +func (k *kubeClient) GetClient() client.Client { + return k.client +} + +func (k *kubeClient) GetCache() cache.Cache { + return k.cache +} + +func newKubeClient(c client.Client, cache cache.Cache) core.KubeClient { + return &kubeClient{client: c, cache: cache} +} + +type Options struct { + MapperProvider func(*rest.Config) (meta.RESTMapper, error) + CacheOptions *cache.Options + ClientOptions *client.Options +} + +// NewKubeClient creates a new KubeClient that caches reads and falls back to +// make API calls on failure. Write calls are not cached. +func NewKubeClient(config *rest.Config, options Options) (core.KubeClient, error) { + httpClient, err := rest.HTTPClientFor(config) + if err != nil { + return nil, err + } + + if options.MapperProvider == nil { + options.MapperProvider = func(c *rest.Config) (meta.RESTMapper, error) { + return apiutil.NewDynamicRESTMapper(config, httpClient) + } + } + + mapper, err := options.MapperProvider(config) + if err != nil { + return nil, err + } + + if options.CacheOptions == nil { + options.CacheOptions = &cache.Options{ + HTTPClient: httpClient, + Mapper: mapper, + } + } + + cache, err := cache.New(config, *options.CacheOptions) + if err != nil { + return nil, err + } + + if options.ClientOptions == nil { + options.ClientOptions = &client.Options{ + HTTPClient: httpClient, + Mapper: mapper, + } + } + + client, err := client.New(config, *options.ClientOptions) + if err != nil { + return nil, err + } + + return newKubeClient(client, cache), nil +} + +// NewDefaultKubeClient creates a new KubeClient with default options set. +// This client caches reads and falls back to make API calls on failure. Write calls are not cached. +func NewDefaultKubeClient(config *rest.Config) (core.KubeClient, error) { + return NewKubeClient(config, Options{}) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/k8s/config.go b/flyteplugins/go/tasks/pluginmachinery/k8s/config.go new file mode 100644 index 0000000000..43ad682276 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/k8s/config.go @@ -0,0 +1,58 @@ +package k8s + +import ( + "fmt" + "io/ioutil" + + "github.com/pkg/errors" + restclient "k8s.io/client-go/rest" +) + +type ClusterConfig struct { + Name string `json:"name" pflag:",Friendly name of the remote cluster"` + Endpoint string `json:"endpoint" pflag:", Remote K8s cluster endpoint"` + Auth Auth `json:"auth" pflag:"-, Auth setting for the cluster"` + Enabled bool `json:"enabled" pflag:", Boolean flag to enable or disable"` +} + +type Auth struct { + TokenPath string `json:"tokenPath" pflag:", Token path"` + CaCertPath string `json:"caCertPath" pflag:", Certificate path"` +} + +func (auth Auth) GetCA() ([]byte, error) { + cert, err := ioutil.ReadFile(auth.CaCertPath) + if err != nil { + return nil, errors.Wrap(err, "failed to read k8s CA cert from configured path") + } + return cert, nil +} + +func (auth Auth) GetToken() (string, error) { + token, err := ioutil.ReadFile(auth.TokenPath) + if err != nil { + return "", errors.Wrap(err, "failed to read k8s bearer token from configured path") + } + return string(token), nil +} + +// KubeClientConfig ... +func KubeClientConfig(host string, auth Auth) (*restclient.Config, error) { + tokenString, err := auth.GetToken() + if err != nil { + return nil, errors.New(fmt.Sprintf("Failed to get auth token: %+v", err)) + } + + caCert, err := auth.GetCA() + if err != nil { + return nil, errors.New(fmt.Sprintf("Failed to get auth CA: %+v", err)) + } + + tlsClientConfig := restclient.TLSClientConfig{} + tlsClientConfig.CAData = caCert + return &restclient.Config{ + Host: host, + TLSClientConfig: tlsClientConfig, + BearerToken: tokenString, + }, nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/k8s/mocks/garbage_collectable.go b/flyteplugins/go/tasks/pluginmachinery/k8s/mocks/garbage_collectable.go new file mode 100644 index 0000000000..8b05f2d12a --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/k8s/mocks/garbage_collectable.go @@ -0,0 +1,153 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + client "sigs.k8s.io/controller-runtime/pkg/client" + + mock "github.com/stretchr/testify/mock" + + time "time" +) + +// GarbageCollectable is an autogenerated mock type for the GarbageCollectable type +type GarbageCollectable struct { + mock.Mock +} + +type GarbageCollectable_Expecter struct { + mock *mock.Mock +} + +func (_m *GarbageCollectable) EXPECT() *GarbageCollectable_Expecter { + return &GarbageCollectable_Expecter{mock: &_m.Mock} +} + +// GetCompletionTime provides a mock function with given fields: resource +func (_m *GarbageCollectable) GetCompletionTime(resource client.Object) (time.Time, error) { + ret := _m.Called(resource) + + if len(ret) == 0 { + panic("no return value specified for GetCompletionTime") + } + + var r0 time.Time + var r1 error + if rf, ok := ret.Get(0).(func(client.Object) (time.Time, error)); ok { + return rf(resource) + } + if rf, ok := ret.Get(0).(func(client.Object) time.Time); ok { + r0 = rf(resource) + } else { + r0 = ret.Get(0).(time.Time) + } + + if rf, ok := ret.Get(1).(func(client.Object) error); ok { + r1 = rf(resource) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// GarbageCollectable_GetCompletionTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCompletionTime' +type GarbageCollectable_GetCompletionTime_Call struct { + *mock.Call +} + +// GetCompletionTime is a helper method to define mock.On call +// - resource client.Object +func (_e *GarbageCollectable_Expecter) GetCompletionTime(resource interface{}) *GarbageCollectable_GetCompletionTime_Call { + return &GarbageCollectable_GetCompletionTime_Call{Call: _e.mock.On("GetCompletionTime", resource)} +} + +func (_c *GarbageCollectable_GetCompletionTime_Call) Run(run func(resource client.Object)) *GarbageCollectable_GetCompletionTime_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(client.Object)) + }) + return _c +} + +func (_c *GarbageCollectable_GetCompletionTime_Call) Return(_a0 time.Time, _a1 error) *GarbageCollectable_GetCompletionTime_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *GarbageCollectable_GetCompletionTime_Call) RunAndReturn(run func(client.Object) (time.Time, error)) *GarbageCollectable_GetCompletionTime_Call { + _c.Call.Return(run) + return _c +} + +// IsTerminal provides a mock function with given fields: ctx, resource +func (_m *GarbageCollectable) IsTerminal(ctx context.Context, resource client.Object) (bool, error) { + ret := _m.Called(ctx, resource) + + if len(ret) == 0 { + panic("no return value specified for IsTerminal") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, client.Object) (bool, error)); ok { + return rf(ctx, resource) + } + if rf, ok := ret.Get(0).(func(context.Context, client.Object) bool); ok { + r0 = rf(ctx, resource) + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func(context.Context, client.Object) error); ok { + r1 = rf(ctx, resource) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// GarbageCollectable_IsTerminal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsTerminal' +type GarbageCollectable_IsTerminal_Call struct { + *mock.Call +} + +// IsTerminal is a helper method to define mock.On call +// - ctx context.Context +// - resource client.Object +func (_e *GarbageCollectable_Expecter) IsTerminal(ctx interface{}, resource interface{}) *GarbageCollectable_IsTerminal_Call { + return &GarbageCollectable_IsTerminal_Call{Call: _e.mock.On("IsTerminal", ctx, resource)} +} + +func (_c *GarbageCollectable_IsTerminal_Call) Run(run func(ctx context.Context, resource client.Object)) *GarbageCollectable_IsTerminal_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(client.Object)) + }) + return _c +} + +func (_c *GarbageCollectable_IsTerminal_Call) Return(_a0 bool, _a1 error) *GarbageCollectable_IsTerminal_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *GarbageCollectable_IsTerminal_Call) RunAndReturn(run func(context.Context, client.Object) (bool, error)) *GarbageCollectable_IsTerminal_Call { + _c.Call.Return(run) + return _c +} + +// NewGarbageCollectable creates a new instance of GarbageCollectable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewGarbageCollectable(t interface { + mock.TestingT + Cleanup(func()) +}) *GarbageCollectable { + mock := &GarbageCollectable{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/k8s/mocks/plugin.go b/flyteplugins/go/tasks/pluginmachinery/k8s/mocks/plugin.go new file mode 100644 index 0000000000..dd84fa4425 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/k8s/mocks/plugin.go @@ -0,0 +1,378 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + client "sigs.k8s.io/controller-runtime/pkg/client" + + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + + k8s "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + + mock "github.com/stretchr/testify/mock" + + time "time" +) + +// Plugin is an autogenerated mock type for the Plugin type +type Plugin struct { + mock.Mock +} + +type Plugin_Expecter struct { + mock *mock.Mock +} + +func (_m *Plugin) EXPECT() *Plugin_Expecter { + return &Plugin_Expecter{mock: &_m.Mock} +} + +// BuildIdentityResource provides a mock function with given fields: ctx, taskCtx +func (_m *Plugin) BuildIdentityResource(ctx context.Context, taskCtx core.TaskExecutionMetadata) (client.Object, error) { + ret := _m.Called(ctx, taskCtx) + + if len(ret) == 0 { + panic("no return value specified for BuildIdentityResource") + } + + var r0 client.Object + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, core.TaskExecutionMetadata) (client.Object, error)); ok { + return rf(ctx, taskCtx) + } + if rf, ok := ret.Get(0).(func(context.Context, core.TaskExecutionMetadata) client.Object); ok { + r0 = rf(ctx, taskCtx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(client.Object) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, core.TaskExecutionMetadata) error); ok { + r1 = rf(ctx, taskCtx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Plugin_BuildIdentityResource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BuildIdentityResource' +type Plugin_BuildIdentityResource_Call struct { + *mock.Call +} + +// BuildIdentityResource is a helper method to define mock.On call +// - ctx context.Context +// - taskCtx core.TaskExecutionMetadata +func (_e *Plugin_Expecter) BuildIdentityResource(ctx interface{}, taskCtx interface{}) *Plugin_BuildIdentityResource_Call { + return &Plugin_BuildIdentityResource_Call{Call: _e.mock.On("BuildIdentityResource", ctx, taskCtx)} +} + +func (_c *Plugin_BuildIdentityResource_Call) Run(run func(ctx context.Context, taskCtx core.TaskExecutionMetadata)) *Plugin_BuildIdentityResource_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(core.TaskExecutionMetadata)) + }) + return _c +} + +func (_c *Plugin_BuildIdentityResource_Call) Return(_a0 client.Object, _a1 error) *Plugin_BuildIdentityResource_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Plugin_BuildIdentityResource_Call) RunAndReturn(run func(context.Context, core.TaskExecutionMetadata) (client.Object, error)) *Plugin_BuildIdentityResource_Call { + _c.Call.Return(run) + return _c +} + +// BuildResource provides a mock function with given fields: ctx, taskCtx +func (_m *Plugin) BuildResource(ctx context.Context, taskCtx core.TaskExecutionContext) (client.Object, error) { + ret := _m.Called(ctx, taskCtx) + + if len(ret) == 0 { + panic("no return value specified for BuildResource") + } + + var r0 client.Object + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, core.TaskExecutionContext) (client.Object, error)); ok { + return rf(ctx, taskCtx) + } + if rf, ok := ret.Get(0).(func(context.Context, core.TaskExecutionContext) client.Object); ok { + r0 = rf(ctx, taskCtx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(client.Object) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, core.TaskExecutionContext) error); ok { + r1 = rf(ctx, taskCtx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Plugin_BuildResource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BuildResource' +type Plugin_BuildResource_Call struct { + *mock.Call +} + +// BuildResource is a helper method to define mock.On call +// - ctx context.Context +// - taskCtx core.TaskExecutionContext +func (_e *Plugin_Expecter) BuildResource(ctx interface{}, taskCtx interface{}) *Plugin_BuildResource_Call { + return &Plugin_BuildResource_Call{Call: _e.mock.On("BuildResource", ctx, taskCtx)} +} + +func (_c *Plugin_BuildResource_Call) Run(run func(ctx context.Context, taskCtx core.TaskExecutionContext)) *Plugin_BuildResource_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(core.TaskExecutionContext)) + }) + return _c +} + +func (_c *Plugin_BuildResource_Call) Return(_a0 client.Object, _a1 error) *Plugin_BuildResource_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Plugin_BuildResource_Call) RunAndReturn(run func(context.Context, core.TaskExecutionContext) (client.Object, error)) *Plugin_BuildResource_Call { + _c.Call.Return(run) + return _c +} + +// GetCompletionTime provides a mock function with given fields: resource +func (_m *Plugin) GetCompletionTime(resource client.Object) (time.Time, error) { + ret := _m.Called(resource) + + if len(ret) == 0 { + panic("no return value specified for GetCompletionTime") + } + + var r0 time.Time + var r1 error + if rf, ok := ret.Get(0).(func(client.Object) (time.Time, error)); ok { + return rf(resource) + } + if rf, ok := ret.Get(0).(func(client.Object) time.Time); ok { + r0 = rf(resource) + } else { + r0 = ret.Get(0).(time.Time) + } + + if rf, ok := ret.Get(1).(func(client.Object) error); ok { + r1 = rf(resource) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Plugin_GetCompletionTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCompletionTime' +type Plugin_GetCompletionTime_Call struct { + *mock.Call +} + +// GetCompletionTime is a helper method to define mock.On call +// - resource client.Object +func (_e *Plugin_Expecter) GetCompletionTime(resource interface{}) *Plugin_GetCompletionTime_Call { + return &Plugin_GetCompletionTime_Call{Call: _e.mock.On("GetCompletionTime", resource)} +} + +func (_c *Plugin_GetCompletionTime_Call) Run(run func(resource client.Object)) *Plugin_GetCompletionTime_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(client.Object)) + }) + return _c +} + +func (_c *Plugin_GetCompletionTime_Call) Return(_a0 time.Time, _a1 error) *Plugin_GetCompletionTime_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Plugin_GetCompletionTime_Call) RunAndReturn(run func(client.Object) (time.Time, error)) *Plugin_GetCompletionTime_Call { + _c.Call.Return(run) + return _c +} + +// GetProperties provides a mock function with no fields +func (_m *Plugin) GetProperties() k8s.PluginProperties { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetProperties") + } + + var r0 k8s.PluginProperties + if rf, ok := ret.Get(0).(func() k8s.PluginProperties); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(k8s.PluginProperties) + } + + return r0 +} + +// Plugin_GetProperties_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProperties' +type Plugin_GetProperties_Call struct { + *mock.Call +} + +// GetProperties is a helper method to define mock.On call +func (_e *Plugin_Expecter) GetProperties() *Plugin_GetProperties_Call { + return &Plugin_GetProperties_Call{Call: _e.mock.On("GetProperties")} +} + +func (_c *Plugin_GetProperties_Call) Run(run func()) *Plugin_GetProperties_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Plugin_GetProperties_Call) Return(_a0 k8s.PluginProperties) *Plugin_GetProperties_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Plugin_GetProperties_Call) RunAndReturn(run func() k8s.PluginProperties) *Plugin_GetProperties_Call { + _c.Call.Return(run) + return _c +} + +// GetTaskPhase provides a mock function with given fields: ctx, pluginContext, resource +func (_m *Plugin) GetTaskPhase(ctx context.Context, pluginContext k8s.PluginContext, resource client.Object) (core.PhaseInfo, error) { + ret := _m.Called(ctx, pluginContext, resource) + + if len(ret) == 0 { + panic("no return value specified for GetTaskPhase") + } + + var r0 core.PhaseInfo + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, k8s.PluginContext, client.Object) (core.PhaseInfo, error)); ok { + return rf(ctx, pluginContext, resource) + } + if rf, ok := ret.Get(0).(func(context.Context, k8s.PluginContext, client.Object) core.PhaseInfo); ok { + r0 = rf(ctx, pluginContext, resource) + } else { + r0 = ret.Get(0).(core.PhaseInfo) + } + + if rf, ok := ret.Get(1).(func(context.Context, k8s.PluginContext, client.Object) error); ok { + r1 = rf(ctx, pluginContext, resource) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Plugin_GetTaskPhase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTaskPhase' +type Plugin_GetTaskPhase_Call struct { + *mock.Call +} + +// GetTaskPhase is a helper method to define mock.On call +// - ctx context.Context +// - pluginContext k8s.PluginContext +// - resource client.Object +func (_e *Plugin_Expecter) GetTaskPhase(ctx interface{}, pluginContext interface{}, resource interface{}) *Plugin_GetTaskPhase_Call { + return &Plugin_GetTaskPhase_Call{Call: _e.mock.On("GetTaskPhase", ctx, pluginContext, resource)} +} + +func (_c *Plugin_GetTaskPhase_Call) Run(run func(ctx context.Context, pluginContext k8s.PluginContext, resource client.Object)) *Plugin_GetTaskPhase_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(k8s.PluginContext), args[2].(client.Object)) + }) + return _c +} + +func (_c *Plugin_GetTaskPhase_Call) Return(_a0 core.PhaseInfo, _a1 error) *Plugin_GetTaskPhase_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Plugin_GetTaskPhase_Call) RunAndReturn(run func(context.Context, k8s.PluginContext, client.Object) (core.PhaseInfo, error)) *Plugin_GetTaskPhase_Call { + _c.Call.Return(run) + return _c +} + +// IsTerminal provides a mock function with given fields: ctx, resource +func (_m *Plugin) IsTerminal(ctx context.Context, resource client.Object) (bool, error) { + ret := _m.Called(ctx, resource) + + if len(ret) == 0 { + panic("no return value specified for IsTerminal") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, client.Object) (bool, error)); ok { + return rf(ctx, resource) + } + if rf, ok := ret.Get(0).(func(context.Context, client.Object) bool); ok { + r0 = rf(ctx, resource) + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func(context.Context, client.Object) error); ok { + r1 = rf(ctx, resource) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Plugin_IsTerminal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsTerminal' +type Plugin_IsTerminal_Call struct { + *mock.Call +} + +// IsTerminal is a helper method to define mock.On call +// - ctx context.Context +// - resource client.Object +func (_e *Plugin_Expecter) IsTerminal(ctx interface{}, resource interface{}) *Plugin_IsTerminal_Call { + return &Plugin_IsTerminal_Call{Call: _e.mock.On("IsTerminal", ctx, resource)} +} + +func (_c *Plugin_IsTerminal_Call) Run(run func(ctx context.Context, resource client.Object)) *Plugin_IsTerminal_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(client.Object)) + }) + return _c +} + +func (_c *Plugin_IsTerminal_Call) Return(_a0 bool, _a1 error) *Plugin_IsTerminal_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Plugin_IsTerminal_Call) RunAndReturn(run func(context.Context, client.Object) (bool, error)) *Plugin_IsTerminal_Call { + _c.Call.Return(run) + return _c +} + +// NewPlugin creates a new instance of Plugin. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewPlugin(t interface { + mock.TestingT + Cleanup(func()) +}) *Plugin { + mock := &Plugin{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/k8s/mocks/plugin_abort_override.go b/flyteplugins/go/tasks/pluginmachinery/k8s/mocks/plugin_abort_override.go new file mode 100644 index 0000000000..18abc3c386 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/k8s/mocks/plugin_abort_override.go @@ -0,0 +1,100 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + client "sigs.k8s.io/controller-runtime/pkg/client" + + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + + k8s "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + + mock "github.com/stretchr/testify/mock" +) + +// PluginAbortOverride is an autogenerated mock type for the PluginAbortOverride type +type PluginAbortOverride struct { + mock.Mock +} + +type PluginAbortOverride_Expecter struct { + mock *mock.Mock +} + +func (_m *PluginAbortOverride) EXPECT() *PluginAbortOverride_Expecter { + return &PluginAbortOverride_Expecter{mock: &_m.Mock} +} + +// OnAbort provides a mock function with given fields: ctx, tCtx, resource +func (_m *PluginAbortOverride) OnAbort(ctx context.Context, tCtx core.TaskExecutionContext, resource client.Object) (k8s.AbortBehavior, error) { + ret := _m.Called(ctx, tCtx, resource) + + if len(ret) == 0 { + panic("no return value specified for OnAbort") + } + + var r0 k8s.AbortBehavior + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, core.TaskExecutionContext, client.Object) (k8s.AbortBehavior, error)); ok { + return rf(ctx, tCtx, resource) + } + if rf, ok := ret.Get(0).(func(context.Context, core.TaskExecutionContext, client.Object) k8s.AbortBehavior); ok { + r0 = rf(ctx, tCtx, resource) + } else { + r0 = ret.Get(0).(k8s.AbortBehavior) + } + + if rf, ok := ret.Get(1).(func(context.Context, core.TaskExecutionContext, client.Object) error); ok { + r1 = rf(ctx, tCtx, resource) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// PluginAbortOverride_OnAbort_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnAbort' +type PluginAbortOverride_OnAbort_Call struct { + *mock.Call +} + +// OnAbort is a helper method to define mock.On call +// - ctx context.Context +// - tCtx core.TaskExecutionContext +// - resource client.Object +func (_e *PluginAbortOverride_Expecter) OnAbort(ctx interface{}, tCtx interface{}, resource interface{}) *PluginAbortOverride_OnAbort_Call { + return &PluginAbortOverride_OnAbort_Call{Call: _e.mock.On("OnAbort", ctx, tCtx, resource)} +} + +func (_c *PluginAbortOverride_OnAbort_Call) Run(run func(ctx context.Context, tCtx core.TaskExecutionContext, resource client.Object)) *PluginAbortOverride_OnAbort_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(core.TaskExecutionContext), args[2].(client.Object)) + }) + return _c +} + +func (_c *PluginAbortOverride_OnAbort_Call) Return(behavior k8s.AbortBehavior, err error) *PluginAbortOverride_OnAbort_Call { + _c.Call.Return(behavior, err) + return _c +} + +func (_c *PluginAbortOverride_OnAbort_Call) RunAndReturn(run func(context.Context, core.TaskExecutionContext, client.Object) (k8s.AbortBehavior, error)) *PluginAbortOverride_OnAbort_Call { + _c.Call.Return(run) + return _c +} + +// NewPluginAbortOverride creates a new instance of PluginAbortOverride. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewPluginAbortOverride(t interface { + mock.TestingT + Cleanup(func()) +}) *PluginAbortOverride { + mock := &PluginAbortOverride{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/k8s/mocks/plugin_context.go b/flyteplugins/go/tasks/pluginmachinery/k8s/mocks/plugin_context.go new file mode 100644 index 0000000000..868df570da --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/k8s/mocks/plugin_context.go @@ -0,0 +1,369 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + io "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + client "sigs.k8s.io/controller-runtime/pkg/client" + + mock "github.com/stretchr/testify/mock" + + storage "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + +// PluginContext is an autogenerated mock type for the PluginContext type +type PluginContext struct { + mock.Mock +} + +type PluginContext_Expecter struct { + mock *mock.Mock +} + +func (_m *PluginContext) EXPECT() *PluginContext_Expecter { + return &PluginContext_Expecter{mock: &_m.Mock} +} + +// DataStore provides a mock function with no fields +func (_m *PluginContext) DataStore() *storage.DataStore { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for DataStore") + } + + var r0 *storage.DataStore + if rf, ok := ret.Get(0).(func() *storage.DataStore); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storage.DataStore) + } + } + + return r0 +} + +// PluginContext_DataStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DataStore' +type PluginContext_DataStore_Call struct { + *mock.Call +} + +// DataStore is a helper method to define mock.On call +func (_e *PluginContext_Expecter) DataStore() *PluginContext_DataStore_Call { + return &PluginContext_DataStore_Call{Call: _e.mock.On("DataStore")} +} + +func (_c *PluginContext_DataStore_Call) Run(run func()) *PluginContext_DataStore_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *PluginContext_DataStore_Call) Return(_a0 *storage.DataStore) *PluginContext_DataStore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PluginContext_DataStore_Call) RunAndReturn(run func() *storage.DataStore) *PluginContext_DataStore_Call { + _c.Call.Return(run) + return _c +} + +// InputReader provides a mock function with no fields +func (_m *PluginContext) InputReader() io.InputReader { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for InputReader") + } + + var r0 io.InputReader + if rf, ok := ret.Get(0).(func() io.InputReader); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(io.InputReader) + } + } + + return r0 +} + +// PluginContext_InputReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InputReader' +type PluginContext_InputReader_Call struct { + *mock.Call +} + +// InputReader is a helper method to define mock.On call +func (_e *PluginContext_Expecter) InputReader() *PluginContext_InputReader_Call { + return &PluginContext_InputReader_Call{Call: _e.mock.On("InputReader")} +} + +func (_c *PluginContext_InputReader_Call) Run(run func()) *PluginContext_InputReader_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *PluginContext_InputReader_Call) Return(_a0 io.InputReader) *PluginContext_InputReader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PluginContext_InputReader_Call) RunAndReturn(run func() io.InputReader) *PluginContext_InputReader_Call { + _c.Call.Return(run) + return _c +} + +// K8sReader provides a mock function with no fields +func (_m *PluginContext) K8sReader() client.Reader { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for K8sReader") + } + + var r0 client.Reader + if rf, ok := ret.Get(0).(func() client.Reader); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(client.Reader) + } + } + + return r0 +} + +// PluginContext_K8sReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'K8sReader' +type PluginContext_K8sReader_Call struct { + *mock.Call +} + +// K8sReader is a helper method to define mock.On call +func (_e *PluginContext_Expecter) K8sReader() *PluginContext_K8sReader_Call { + return &PluginContext_K8sReader_Call{Call: _e.mock.On("K8sReader")} +} + +func (_c *PluginContext_K8sReader_Call) Run(run func()) *PluginContext_K8sReader_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *PluginContext_K8sReader_Call) Return(_a0 client.Reader) *PluginContext_K8sReader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PluginContext_K8sReader_Call) RunAndReturn(run func() client.Reader) *PluginContext_K8sReader_Call { + _c.Call.Return(run) + return _c +} + +// OutputWriter provides a mock function with no fields +func (_m *PluginContext) OutputWriter() io.OutputWriter { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for OutputWriter") + } + + var r0 io.OutputWriter + if rf, ok := ret.Get(0).(func() io.OutputWriter); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(io.OutputWriter) + } + } + + return r0 +} + +// PluginContext_OutputWriter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OutputWriter' +type PluginContext_OutputWriter_Call struct { + *mock.Call +} + +// OutputWriter is a helper method to define mock.On call +func (_e *PluginContext_Expecter) OutputWriter() *PluginContext_OutputWriter_Call { + return &PluginContext_OutputWriter_Call{Call: _e.mock.On("OutputWriter")} +} + +func (_c *PluginContext_OutputWriter_Call) Run(run func()) *PluginContext_OutputWriter_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *PluginContext_OutputWriter_Call) Return(_a0 io.OutputWriter) *PluginContext_OutputWriter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PluginContext_OutputWriter_Call) RunAndReturn(run func() io.OutputWriter) *PluginContext_OutputWriter_Call { + _c.Call.Return(run) + return _c +} + +// PluginStateReader provides a mock function with no fields +func (_m *PluginContext) PluginStateReader() core.PluginStateReader { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for PluginStateReader") + } + + var r0 core.PluginStateReader + if rf, ok := ret.Get(0).(func() core.PluginStateReader); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.PluginStateReader) + } + } + + return r0 +} + +// PluginContext_PluginStateReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PluginStateReader' +type PluginContext_PluginStateReader_Call struct { + *mock.Call +} + +// PluginStateReader is a helper method to define mock.On call +func (_e *PluginContext_Expecter) PluginStateReader() *PluginContext_PluginStateReader_Call { + return &PluginContext_PluginStateReader_Call{Call: _e.mock.On("PluginStateReader")} +} + +func (_c *PluginContext_PluginStateReader_Call) Run(run func()) *PluginContext_PluginStateReader_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *PluginContext_PluginStateReader_Call) Return(_a0 core.PluginStateReader) *PluginContext_PluginStateReader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PluginContext_PluginStateReader_Call) RunAndReturn(run func() core.PluginStateReader) *PluginContext_PluginStateReader_Call { + _c.Call.Return(run) + return _c +} + +// TaskExecutionMetadata provides a mock function with no fields +func (_m *PluginContext) TaskExecutionMetadata() core.TaskExecutionMetadata { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for TaskExecutionMetadata") + } + + var r0 core.TaskExecutionMetadata + if rf, ok := ret.Get(0).(func() core.TaskExecutionMetadata); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.TaskExecutionMetadata) + } + } + + return r0 +} + +// PluginContext_TaskExecutionMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TaskExecutionMetadata' +type PluginContext_TaskExecutionMetadata_Call struct { + *mock.Call +} + +// TaskExecutionMetadata is a helper method to define mock.On call +func (_e *PluginContext_Expecter) TaskExecutionMetadata() *PluginContext_TaskExecutionMetadata_Call { + return &PluginContext_TaskExecutionMetadata_Call{Call: _e.mock.On("TaskExecutionMetadata")} +} + +func (_c *PluginContext_TaskExecutionMetadata_Call) Run(run func()) *PluginContext_TaskExecutionMetadata_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *PluginContext_TaskExecutionMetadata_Call) Return(_a0 core.TaskExecutionMetadata) *PluginContext_TaskExecutionMetadata_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PluginContext_TaskExecutionMetadata_Call) RunAndReturn(run func() core.TaskExecutionMetadata) *PluginContext_TaskExecutionMetadata_Call { + _c.Call.Return(run) + return _c +} + +// TaskReader provides a mock function with no fields +func (_m *PluginContext) TaskReader() core.TaskReader { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for TaskReader") + } + + var r0 core.TaskReader + if rf, ok := ret.Get(0).(func() core.TaskReader); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.TaskReader) + } + } + + return r0 +} + +// PluginContext_TaskReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TaskReader' +type PluginContext_TaskReader_Call struct { + *mock.Call +} + +// TaskReader is a helper method to define mock.On call +func (_e *PluginContext_Expecter) TaskReader() *PluginContext_TaskReader_Call { + return &PluginContext_TaskReader_Call{Call: _e.mock.On("TaskReader")} +} + +func (_c *PluginContext_TaskReader_Call) Run(run func()) *PluginContext_TaskReader_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *PluginContext_TaskReader_Call) Return(_a0 core.TaskReader) *PluginContext_TaskReader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PluginContext_TaskReader_Call) RunAndReturn(run func() core.TaskReader) *PluginContext_TaskReader_Call { + _c.Call.Return(run) + return _c +} + +// NewPluginContext creates a new instance of PluginContext. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewPluginContext(t interface { + mock.TestingT + Cleanup(func()) +}) *PluginContext { + mock := &PluginContext{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/k8s/mocks/resource.go b/flyteplugins/go/tasks/pluginmachinery/k8s/mocks/resource.go new file mode 100644 index 0000000000..85bfa9d21f --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/k8s/mocks/resource.go @@ -0,0 +1,730 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + mock "github.com/stretchr/testify/mock" + runtime "k8s.io/apimachinery/pkg/runtime" + + schema "k8s.io/apimachinery/pkg/runtime/schema" + + types "k8s.io/apimachinery/pkg/types" + + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// Resource is an autogenerated mock type for the Resource type +type Resource struct { + mock.Mock +} + +type Resource_DeepCopyObject struct { + *mock.Call +} + +func (_m Resource_DeepCopyObject) Return(_a0 runtime.Object) *Resource_DeepCopyObject { + return &Resource_DeepCopyObject{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnDeepCopyObject() *Resource_DeepCopyObject { + c := _m.On("DeepCopyObject") + return &Resource_DeepCopyObject{Call: c} +} + +func (_m *Resource) OnDeepCopyObjectMatch(matchers ...interface{}) *Resource_DeepCopyObject { + c := _m.On("DeepCopyObject", matchers...) + return &Resource_DeepCopyObject{Call: c} +} + +// DeepCopyObject provides a mock function with given fields: +func (_m *Resource) DeepCopyObject() runtime.Object { + ret := _m.Called() + + var r0 runtime.Object + if rf, ok := ret.Get(0).(func() runtime.Object); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(runtime.Object) + } + } + + return r0 +} + +type Resource_GetAnnotations struct { + *mock.Call +} + +func (_m Resource_GetAnnotations) Return(_a0 map[string]string) *Resource_GetAnnotations { + return &Resource_GetAnnotations{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnGetAnnotations() *Resource_GetAnnotations { + c := _m.On("GetAnnotations") + return &Resource_GetAnnotations{Call: c} +} + +func (_m *Resource) OnGetAnnotationsMatch(matchers ...interface{}) *Resource_GetAnnotations { + c := _m.On("GetAnnotations", matchers...) + return &Resource_GetAnnotations{Call: c} +} + +// GetAnnotations provides a mock function with given fields: +func (_m *Resource) GetAnnotations() map[string]string { + ret := _m.Called() + + var r0 map[string]string + if rf, ok := ret.Get(0).(func() map[string]string); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[string]string) + } + } + + return r0 +} + +type Resource_GetClusterName struct { + *mock.Call +} + +func (_m Resource_GetClusterName) Return(_a0 string) *Resource_GetClusterName { + return &Resource_GetClusterName{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnGetClusterName() *Resource_GetClusterName { + c := _m.On("GetClusterName") + return &Resource_GetClusterName{Call: c} +} + +func (_m *Resource) OnGetClusterNameMatch(matchers ...interface{}) *Resource_GetClusterName { + c := _m.On("GetClusterName", matchers...) + return &Resource_GetClusterName{Call: c} +} + +// GetClusterName provides a mock function with given fields: +func (_m *Resource) GetClusterName() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +type Resource_GetCreationTimestamp struct { + *mock.Call +} + +func (_m Resource_GetCreationTimestamp) Return(_a0 v1.Time) *Resource_GetCreationTimestamp { + return &Resource_GetCreationTimestamp{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnGetCreationTimestamp() *Resource_GetCreationTimestamp { + c := _m.On("GetCreationTimestamp") + return &Resource_GetCreationTimestamp{Call: c} +} + +func (_m *Resource) OnGetCreationTimestampMatch(matchers ...interface{}) *Resource_GetCreationTimestamp { + c := _m.On("GetCreationTimestamp", matchers...) + return &Resource_GetCreationTimestamp{Call: c} +} + +// GetCreationTimestamp provides a mock function with given fields: +func (_m *Resource) GetCreationTimestamp() v1.Time { + ret := _m.Called() + + var r0 v1.Time + if rf, ok := ret.Get(0).(func() v1.Time); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(v1.Time) + } + + return r0 +} + +type Resource_GetDeletionGracePeriodSeconds struct { + *mock.Call +} + +func (_m Resource_GetDeletionGracePeriodSeconds) Return(_a0 *int64) *Resource_GetDeletionGracePeriodSeconds { + return &Resource_GetDeletionGracePeriodSeconds{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnGetDeletionGracePeriodSeconds() *Resource_GetDeletionGracePeriodSeconds { + c := _m.On("GetDeletionGracePeriodSeconds") + return &Resource_GetDeletionGracePeriodSeconds{Call: c} +} + +func (_m *Resource) OnGetDeletionGracePeriodSecondsMatch(matchers ...interface{}) *Resource_GetDeletionGracePeriodSeconds { + c := _m.On("GetDeletionGracePeriodSeconds", matchers...) + return &Resource_GetDeletionGracePeriodSeconds{Call: c} +} + +// GetDeletionGracePeriodSeconds provides a mock function with given fields: +func (_m *Resource) GetDeletionGracePeriodSeconds() *int64 { + ret := _m.Called() + + var r0 *int64 + if rf, ok := ret.Get(0).(func() *int64); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*int64) + } + } + + return r0 +} + +type Resource_GetDeletionTimestamp struct { + *mock.Call +} + +func (_m Resource_GetDeletionTimestamp) Return(_a0 *v1.Time) *Resource_GetDeletionTimestamp { + return &Resource_GetDeletionTimestamp{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnGetDeletionTimestamp() *Resource_GetDeletionTimestamp { + c := _m.On("GetDeletionTimestamp") + return &Resource_GetDeletionTimestamp{Call: c} +} + +func (_m *Resource) OnGetDeletionTimestampMatch(matchers ...interface{}) *Resource_GetDeletionTimestamp { + c := _m.On("GetDeletionTimestamp", matchers...) + return &Resource_GetDeletionTimestamp{Call: c} +} + +// GetDeletionTimestamp provides a mock function with given fields: +func (_m *Resource) GetDeletionTimestamp() *v1.Time { + ret := _m.Called() + + var r0 *v1.Time + if rf, ok := ret.Get(0).(func() *v1.Time); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v1.Time) + } + } + + return r0 +} + +type Resource_GetFinalizers struct { + *mock.Call +} + +func (_m Resource_GetFinalizers) Return(_a0 []string) *Resource_GetFinalizers { + return &Resource_GetFinalizers{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnGetFinalizers() *Resource_GetFinalizers { + c := _m.On("GetFinalizers") + return &Resource_GetFinalizers{Call: c} +} + +func (_m *Resource) OnGetFinalizersMatch(matchers ...interface{}) *Resource_GetFinalizers { + c := _m.On("GetFinalizers", matchers...) + return &Resource_GetFinalizers{Call: c} +} + +// GetFinalizers provides a mock function with given fields: +func (_m *Resource) GetFinalizers() []string { + ret := _m.Called() + + var r0 []string + if rf, ok := ret.Get(0).(func() []string); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + + return r0 +} + +type Resource_GetGenerateName struct { + *mock.Call +} + +func (_m Resource_GetGenerateName) Return(_a0 string) *Resource_GetGenerateName { + return &Resource_GetGenerateName{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnGetGenerateName() *Resource_GetGenerateName { + c := _m.On("GetGenerateName") + return &Resource_GetGenerateName{Call: c} +} + +func (_m *Resource) OnGetGenerateNameMatch(matchers ...interface{}) *Resource_GetGenerateName { + c := _m.On("GetGenerateName", matchers...) + return &Resource_GetGenerateName{Call: c} +} + +// GetGenerateName provides a mock function with given fields: +func (_m *Resource) GetGenerateName() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +type Resource_GetGeneration struct { + *mock.Call +} + +func (_m Resource_GetGeneration) Return(_a0 int64) *Resource_GetGeneration { + return &Resource_GetGeneration{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnGetGeneration() *Resource_GetGeneration { + c := _m.On("GetGeneration") + return &Resource_GetGeneration{Call: c} +} + +func (_m *Resource) OnGetGenerationMatch(matchers ...interface{}) *Resource_GetGeneration { + c := _m.On("GetGeneration", matchers...) + return &Resource_GetGeneration{Call: c} +} + +// GetGeneration provides a mock function with given fields: +func (_m *Resource) GetGeneration() int64 { + ret := _m.Called() + + var r0 int64 + if rf, ok := ret.Get(0).(func() int64); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int64) + } + + return r0 +} + +type Resource_GetLabels struct { + *mock.Call +} + +func (_m Resource_GetLabels) Return(_a0 map[string]string) *Resource_GetLabels { + return &Resource_GetLabels{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnGetLabels() *Resource_GetLabels { + c := _m.On("GetLabels") + return &Resource_GetLabels{Call: c} +} + +func (_m *Resource) OnGetLabelsMatch(matchers ...interface{}) *Resource_GetLabels { + c := _m.On("GetLabels", matchers...) + return &Resource_GetLabels{Call: c} +} + +// GetLabels provides a mock function with given fields: +func (_m *Resource) GetLabels() map[string]string { + ret := _m.Called() + + var r0 map[string]string + if rf, ok := ret.Get(0).(func() map[string]string); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[string]string) + } + } + + return r0 +} + +type Resource_GetManagedFields struct { + *mock.Call +} + +func (_m Resource_GetManagedFields) Return(_a0 []v1.ManagedFieldsEntry) *Resource_GetManagedFields { + return &Resource_GetManagedFields{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnGetManagedFields() *Resource_GetManagedFields { + c := _m.On("GetManagedFields") + return &Resource_GetManagedFields{Call: c} +} + +func (_m *Resource) OnGetManagedFieldsMatch(matchers ...interface{}) *Resource_GetManagedFields { + c := _m.On("GetManagedFields", matchers...) + return &Resource_GetManagedFields{Call: c} +} + +// GetManagedFields provides a mock function with given fields: +func (_m *Resource) GetManagedFields() []v1.ManagedFieldsEntry { + ret := _m.Called() + + var r0 []v1.ManagedFieldsEntry + if rf, ok := ret.Get(0).(func() []v1.ManagedFieldsEntry); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]v1.ManagedFieldsEntry) + } + } + + return r0 +} + +type Resource_GetName struct { + *mock.Call +} + +func (_m Resource_GetName) Return(_a0 string) *Resource_GetName { + return &Resource_GetName{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnGetName() *Resource_GetName { + c := _m.On("GetName") + return &Resource_GetName{Call: c} +} + +func (_m *Resource) OnGetNameMatch(matchers ...interface{}) *Resource_GetName { + c := _m.On("GetName", matchers...) + return &Resource_GetName{Call: c} +} + +// GetName provides a mock function with given fields: +func (_m *Resource) GetName() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +type Resource_GetNamespace struct { + *mock.Call +} + +func (_m Resource_GetNamespace) Return(_a0 string) *Resource_GetNamespace { + return &Resource_GetNamespace{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnGetNamespace() *Resource_GetNamespace { + c := _m.On("GetNamespace") + return &Resource_GetNamespace{Call: c} +} + +func (_m *Resource) OnGetNamespaceMatch(matchers ...interface{}) *Resource_GetNamespace { + c := _m.On("GetNamespace", matchers...) + return &Resource_GetNamespace{Call: c} +} + +// GetNamespace provides a mock function with given fields: +func (_m *Resource) GetNamespace() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +type Resource_GetObjectKind struct { + *mock.Call +} + +func (_m Resource_GetObjectKind) Return(_a0 schema.ObjectKind) *Resource_GetObjectKind { + return &Resource_GetObjectKind{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnGetObjectKind() *Resource_GetObjectKind { + c := _m.On("GetObjectKind") + return &Resource_GetObjectKind{Call: c} +} + +func (_m *Resource) OnGetObjectKindMatch(matchers ...interface{}) *Resource_GetObjectKind { + c := _m.On("GetObjectKind", matchers...) + return &Resource_GetObjectKind{Call: c} +} + +// GetObjectKind provides a mock function with given fields: +func (_m *Resource) GetObjectKind() schema.ObjectKind { + ret := _m.Called() + + var r0 schema.ObjectKind + if rf, ok := ret.Get(0).(func() schema.ObjectKind); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(schema.ObjectKind) + } + } + + return r0 +} + +type Resource_GetOwnerReferences struct { + *mock.Call +} + +func (_m Resource_GetOwnerReferences) Return(_a0 []v1.OwnerReference) *Resource_GetOwnerReferences { + return &Resource_GetOwnerReferences{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnGetOwnerReferences() *Resource_GetOwnerReferences { + c := _m.On("GetOwnerReferences") + return &Resource_GetOwnerReferences{Call: c} +} + +func (_m *Resource) OnGetOwnerReferencesMatch(matchers ...interface{}) *Resource_GetOwnerReferences { + c := _m.On("GetOwnerReferences", matchers...) + return &Resource_GetOwnerReferences{Call: c} +} + +// GetOwnerReferences provides a mock function with given fields: +func (_m *Resource) GetOwnerReferences() []v1.OwnerReference { + ret := _m.Called() + + var r0 []v1.OwnerReference + if rf, ok := ret.Get(0).(func() []v1.OwnerReference); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]v1.OwnerReference) + } + } + + return r0 +} + +type Resource_GetResourceVersion struct { + *mock.Call +} + +func (_m Resource_GetResourceVersion) Return(_a0 string) *Resource_GetResourceVersion { + return &Resource_GetResourceVersion{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnGetResourceVersion() *Resource_GetResourceVersion { + c := _m.On("GetResourceVersion") + return &Resource_GetResourceVersion{Call: c} +} + +func (_m *Resource) OnGetResourceVersionMatch(matchers ...interface{}) *Resource_GetResourceVersion { + c := _m.On("GetResourceVersion", matchers...) + return &Resource_GetResourceVersion{Call: c} +} + +// GetResourceVersion provides a mock function with given fields: +func (_m *Resource) GetResourceVersion() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +type Resource_GetSelfLink struct { + *mock.Call +} + +func (_m Resource_GetSelfLink) Return(_a0 string) *Resource_GetSelfLink { + return &Resource_GetSelfLink{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnGetSelfLink() *Resource_GetSelfLink { + c := _m.On("GetSelfLink") + return &Resource_GetSelfLink{Call: c} +} + +func (_m *Resource) OnGetSelfLinkMatch(matchers ...interface{}) *Resource_GetSelfLink { + c := _m.On("GetSelfLink", matchers...) + return &Resource_GetSelfLink{Call: c} +} + +// GetSelfLink provides a mock function with given fields: +func (_m *Resource) GetSelfLink() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +type Resource_GetUID struct { + *mock.Call +} + +func (_m Resource_GetUID) Return(_a0 types.UID) *Resource_GetUID { + return &Resource_GetUID{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnGetUID() *Resource_GetUID { + c := _m.On("GetUID") + return &Resource_GetUID{Call: c} +} + +func (_m *Resource) OnGetUIDMatch(matchers ...interface{}) *Resource_GetUID { + c := _m.On("GetUID", matchers...) + return &Resource_GetUID{Call: c} +} + +// GetUID provides a mock function with given fields: +func (_m *Resource) GetUID() types.UID { + ret := _m.Called() + + var r0 types.UID + if rf, ok := ret.Get(0).(func() types.UID); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(types.UID) + } + + return r0 +} + +type Resource_GroupVersionKind struct { + *mock.Call +} + +func (_m Resource_GroupVersionKind) Return(_a0 schema.GroupVersionKind) *Resource_GroupVersionKind { + return &Resource_GroupVersionKind{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnGroupVersionKind() *Resource_GroupVersionKind { + c := _m.On("GroupVersionKind") + return &Resource_GroupVersionKind{Call: c} +} + +func (_m *Resource) OnGroupVersionKindMatch(matchers ...interface{}) *Resource_GroupVersionKind { + c := _m.On("GroupVersionKind", matchers...) + return &Resource_GroupVersionKind{Call: c} +} + +// GroupVersionKind provides a mock function with given fields: +func (_m *Resource) GroupVersionKind() schema.GroupVersionKind { + ret := _m.Called() + + var r0 schema.GroupVersionKind + if rf, ok := ret.Get(0).(func() schema.GroupVersionKind); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(schema.GroupVersionKind) + } + + return r0 +} + +// SetAnnotations provides a mock function with given fields: annotations +func (_m *Resource) SetAnnotations(annotations map[string]string) { + _m.Called(annotations) +} + +// SetClusterName provides a mock function with given fields: clusterName +func (_m *Resource) SetClusterName(clusterName string) { + _m.Called(clusterName) +} + +// SetCreationTimestamp provides a mock function with given fields: timestamp +func (_m *Resource) SetCreationTimestamp(timestamp v1.Time) { + _m.Called(timestamp) +} + +// SetDeletionGracePeriodSeconds provides a mock function with given fields: _a0 +func (_m *Resource) SetDeletionGracePeriodSeconds(_a0 *int64) { + _m.Called(_a0) +} + +// SetDeletionTimestamp provides a mock function with given fields: timestamp +func (_m *Resource) SetDeletionTimestamp(timestamp *v1.Time) { + _m.Called(timestamp) +} + +// SetFinalizers provides a mock function with given fields: finalizers +func (_m *Resource) SetFinalizers(finalizers []string) { + _m.Called(finalizers) +} + +// SetGenerateName provides a mock function with given fields: name +func (_m *Resource) SetGenerateName(name string) { + _m.Called(name) +} + +// SetGeneration provides a mock function with given fields: generation +func (_m *Resource) SetGeneration(generation int64) { + _m.Called(generation) +} + +// SetGroupVersionKind provides a mock function with given fields: kind +func (_m *Resource) SetGroupVersionKind(kind schema.GroupVersionKind) { + _m.Called(kind) +} + +// SetLabels provides a mock function with given fields: labels +func (_m *Resource) SetLabels(labels map[string]string) { + _m.Called(labels) +} + +// SetManagedFields provides a mock function with given fields: managedFields +func (_m *Resource) SetManagedFields(managedFields []v1.ManagedFieldsEntry) { + _m.Called(managedFields) +} + +// SetName provides a mock function with given fields: name +func (_m *Resource) SetName(name string) { + _m.Called(name) +} + +// SetNamespace provides a mock function with given fields: namespace +func (_m *Resource) SetNamespace(namespace string) { + _m.Called(namespace) +} + +// SetOwnerReferences provides a mock function with given fields: _a0 +func (_m *Resource) SetOwnerReferences(_a0 []v1.OwnerReference) { + _m.Called(_a0) +} + +// SetResourceVersion provides a mock function with given fields: version +func (_m *Resource) SetResourceVersion(version string) { + _m.Called(version) +} + +// SetSelfLink provides a mock function with given fields: selfLink +func (_m *Resource) SetSelfLink(selfLink string) { + _m.Called(selfLink) +} + +// SetUID provides a mock function with given fields: uid +func (_m *Resource) SetUID(uid types.UID) { + _m.Called(uid) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/k8s/plugin.go b/flyteplugins/go/tasks/pluginmachinery/k8s/plugin.go new file mode 100644 index 0000000000..ab5dac3d4c --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/k8s/plugin.go @@ -0,0 +1,208 @@ +package k8s + +import ( + "context" + "time" + + "sigs.k8s.io/controller-runtime/pkg/client" + + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + + +// PluginEntry is a structure that is used to indicate to the system a K8s plugin +type PluginEntry struct { + // ID/Name of the plugin. This will be used to identify this plugin and has to be unique in the entire system + // All functions like enabling and disabling a plugin use this ID + ID pluginsCore.TaskType + // A list of all the task types for which this plugin is applicable. + RegisteredTaskTypes []pluginsCore.TaskType + // An instance of the kubernetes resource this plugin is responsible for, for example v1.Pod{} + ResourceToWatch client.Object + // An instance of the plugin + Plugin Plugin + // Boolean that indicates if this plugin can be used as the default for unknown task types. There can only be + // one default in the system + IsDefault bool + // Returns a new KubeClient to be used instead of the internal controller-runtime client. + CustomKubeClient func(ctx context.Context) (pluginsCore.KubeClient, error) +} + +// System level properties that this Plugin supports +type PluginProperties struct { + // Disables the inclusion of OwnerReferences in kubernetes resources that this plugin is responsible for. + // Disabling is only useful if resources will be created in a remote cluster. + DisableInjectOwnerReferences bool + // Boolean that indicates if finalizer injection should be disabled for resources that this plugin is + // responsible for. + DisableInjectFinalizer bool + // Specifies the length of TaskExecutionID generated name. default: 50 + GeneratedNameMaxLength *int + // DisableDeleteResourceOnFinalize disables deleting the created resource on finalize. That behavior is controllable + // on the base K8sPluginConfig level but can be disabled for individual plugins. Plugins should generally not + // override that behavior unless the resource that gets created for this plugin does not consume resources (cluster's + // cpu/memory... etc. or external resources) once the plugin's Plugin.GetTaskPhase() returns a terminal phase. + DisableDeleteResourceOnFinalize bool +} + +// Special context passed in to plugins when checking task phase +type PluginContext interface { + // Returns a TaskReader, to retrieve task details + TaskReader() pluginsCore.TaskReader + + // Returns an input reader to retrieve input data + InputReader() io.InputReader + + // Provides an output sync of type io.OutputWriter + OutputWriter() io.OutputWriter + + // Returns a handle to the currently configured storage backend that can be used to communicate with the tasks or write metadata + DataStore() *storage.DataStore + + // Returns a handle to the Task's execution metadata. + TaskExecutionMetadata() pluginsCore.TaskExecutionMetadata + + // Returns a reader that retrieves previously stored plugin internal state. the state itself is immutable + PluginStateReader() pluginsCore.PluginStateReader + + // K8sReader returns a read-only k8s client that can fetch pod(s) for given node execution + K8sReader() client.Reader +} + +// PluginState defines the state of a k8s plugin. This information must be maintained between propeller evaluations to +// determine if there have been any updates since the previously evaluation. +type PluginState struct { + // Phase is the plugin phase. + Phase pluginsCore.Phase + // PhaseVersion is an number used to indicate reportable changes to state that have the same phase. + PhaseVersion uint32 + // Reason is the message explaining the purpose for being in the reported state. + Reason string +} + +// Defines a simplified interface to author plugins for k8s resources. +type Plugin interface { + // Defines a func to create a query object (typically just object and type meta portions) that's used to query k8s + // resources. + BuildIdentityResource(ctx context.Context, taskCtx pluginsCore.TaskExecutionMetadata) (client.Object, error) + + // Defines a func to create the full resource object that will be posted to k8s. + BuildResource(ctx context.Context, taskCtx pluginsCore.TaskExecutionContext) (client.Object, error) + + // Analyses the k8s resource and reports the status as TaskPhase. This call is expected to be relatively fast, + // any operations that might take a long time (limits are configured system-wide) should be offloaded to the + // background. + GetTaskPhase(ctx context.Context, pluginContext PluginContext, resource client.Object) (pluginsCore.PhaseInfo, error) + + // Properties desired by the plugin + GetProperties() PluginProperties + + // GarbageCollectable enables an external garbage collector to clean up resources created by the plugin + GarbageCollectable +} + +// GarbageCollectable is an interface plugins implement to provide an external garbage collector information. +type GarbageCollectable interface { + // IsTerminal returns true if the resource is in a terminal state + IsTerminal(ctx context.Context, resource client.Object) (bool, error) + + // GetCompletionTime returns when the resource reached terminal state + GetCompletionTime(resource client.Object) (time.Time, error) + + // Note: The external garbage collector uses PluginEntry.ResourceToWatch to determine + // which resource type to delete. If a plugin creates additional resources that require + // cleanup, this interface will need to be extended to return those resources. +} + +// An optional interface a Plugin can implement to override its default OnAbort finalizer (deletion of the underlying resource). +type PluginAbortOverride interface { + OnAbort(ctx context.Context, tCtx pluginsCore.TaskExecutionContext, resource client.Object) (behavior AbortBehavior, err error) +} + +// Defines the overridden OnAbort behavior. The resource (by default, the underlying resource, although this +// can be overridden) can be either patched, updated, or deleted. +type AbortBehavior struct { + // Optional override to the default k8s Resource being acted on. + Resource client.Object + DeleteResource bool + Update *UpdateResourceOperation + Patch *PatchResourceOperation + // Determines whether to delete the Resource if the specified operations return an error + DeleteOnErr bool +} + +// Defines a Patch operation on a Resource +type PatchResourceOperation struct { + Patch client.Patch + Options []client.PatchOption +} + +// Defines an Update operation on a Resource +type UpdateResourceOperation struct { + Options []client.UpdateOption +} + +// AbortBehavior that patches the default resource +func AbortBehaviorPatchDefaultResource(patchOperation PatchResourceOperation, deleteOnErr bool) AbortBehavior { + return AbortBehaviorPatch(patchOperation, deleteOnErr, nil) +} + +// AbortBehavior that patches the specified resource +func AbortBehaviorPatch(patchOperation PatchResourceOperation, deleteOnErr bool, resource client.Object) AbortBehavior { + return AbortBehavior{ + Resource: resource, + Patch: &patchOperation, + DeleteOnErr: deleteOnErr, + } +} + +// AbortBehavior that updates the default resource +func AbortBehaviorUpdateDefaultResource(updateOperation UpdateResourceOperation, deleteOnErr bool) AbortBehavior { + return AbortBehaviorUpdate(updateOperation, deleteOnErr, nil) +} + +// AbortBehavior that updates the specified resource +func AbortBehaviorUpdate(updateOperation UpdateResourceOperation, deleteOnErr bool, resource client.Object) AbortBehavior { + return AbortBehavior{ + Resource: resource, + Update: &updateOperation, + DeleteOnErr: deleteOnErr, + } +} + +// AbortBehavior that deletes the default resource +func AbortBehaviorDeleteDefaultResource() AbortBehavior { + return AbortBehaviorDelete(nil) +} + +// AbortBehavior that deletes the specified resource +func AbortBehaviorDelete(resource client.Object) AbortBehavior { + return AbortBehavior{ + Resource: resource, + DeleteResource: true, + } +} + +// if we have the same Phase as the previous evaluation and updated the Reason but not the PhaseVersion we must +// update the PhaseVersion so an event is sent to reflect the Reason update. this does not handle the Running +// Phase because the legacy used `DefaultPhaseVersion + 1` which will only increment to 1. + +func MaybeUpdatePhaseVersion(phaseInfo *pluginsCore.PhaseInfo, pluginState *PluginState) { + if phaseInfo.Phase() == pluginState.Phase && + phaseInfo.Version() <= pluginState.PhaseVersion && phaseInfo.Reason() != pluginState.Reason { + + *phaseInfo = phaseInfo.WithVersion(pluginState.PhaseVersion + 1) + } +} + +func MaybeUpdatePhaseVersionFromPluginContext(phaseInfo *pluginsCore.PhaseInfo, pluginContext *PluginContext) error { + pluginState := PluginState{} + _, err := (*pluginContext).PluginStateReader().Get(&pluginState) + if err != nil { + return err + } + MaybeUpdatePhaseVersion(phaseInfo, &pluginState) + return nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/registry.go b/flyteplugins/go/tasks/pluginmachinery/registry.go new file mode 100644 index 0000000000..248f4c5318 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/registry.go @@ -0,0 +1,111 @@ +package pluginmachinery + +import ( + "context" + "sync" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + + internalRemote "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/internal/webapi" +) + +type taskPluginRegistry struct { + m sync.Mutex + k8sPlugin []k8s.PluginEntry + corePlugin []core.PluginEntry +} + +// A singleton variable that maintains a registry of all plugins. The framework uses this to access all plugins +var pluginRegistry = &taskPluginRegistry{} + +func PluginRegistry() TaskPluginRegistry { + return pluginRegistry +} + +func (p *taskPluginRegistry) RegisterRemotePlugin(info webapi.PluginEntry) { + ctx := context.Background() + if info.ID == "" { + logger.Panicf(ctx, "ID is required attribute for k8s plugin") + } + + if len(info.SupportedTaskTypes) == 0 { + logger.Panicf(ctx, "AsyncPlugin should be registered to handle at least one task type") + } + + if info.PluginLoader == nil { + logger.Panicf(ctx, "PluginLoader cannot be nil") + } + + p.m.Lock() + defer p.m.Unlock() + p.corePlugin = append(p.corePlugin, internalRemote.CreateRemotePlugin(info)) +} + +func CreateRemotePlugin(pluginEntry webapi.PluginEntry) core.PluginEntry { + return internalRemote.CreateRemotePlugin(pluginEntry) +} + +// Use this method to register Kubernetes Plugins +func (p *taskPluginRegistry) RegisterK8sPlugin(info k8s.PluginEntry) { + if info.ID == "" { + logger.Panicf(context.TODO(), "ID is required attribute for k8s plugin") + } + + if len(info.RegisteredTaskTypes) == 0 { + logger.Panicf(context.TODO(), "K8s AsyncPlugin should be registered to handle at least one task type") + } + + if info.Plugin == nil { + logger.Panicf(context.TODO(), "K8s AsyncPlugin cannot be nil") + } + + if info.ResourceToWatch == nil { + logger.Panicf(context.TODO(), "The framework requires a K8s resource to watch, for valid plugin registration") + } + + p.m.Lock() + defer p.m.Unlock() + p.k8sPlugin = append(p.k8sPlugin, info) +} + +// Use this method to register core plugins +func (p *taskPluginRegistry) RegisterCorePlugin(info core.PluginEntry) { + if info.ID == "" { + logger.Panicf(context.TODO(), "ID is required attribute for k8s plugin") + } + if len(info.RegisteredTaskTypes) == 0 { + logger.Panicf(context.TODO(), "AsyncPlugin should be registered to handle at least one task type") + } + if info.LoadPlugin == nil { + logger.Panicf(context.TODO(), "PluginLoader cannot be nil") + } + + p.m.Lock() + defer p.m.Unlock() + p.corePlugin = append(p.corePlugin, info) +} + +// Returns a snapshot of all the registered core plugins. +func (p *taskPluginRegistry) GetCorePlugins() []core.PluginEntry { + p.m.Lock() + defer p.m.Unlock() + return append(p.corePlugin[:0:0], p.corePlugin...) +} + +// Returns a snapshot of all registered K8s plugins +func (p *taskPluginRegistry) GetK8sPlugins() []k8s.PluginEntry { + p.m.Lock() + defer p.m.Unlock() + return append(p.k8sPlugin[:0:0], p.k8sPlugin...) +} + +type TaskPluginRegistry interface { + RegisterK8sPlugin(info k8s.PluginEntry) + RegisterCorePlugin(info core.PluginEntry) + RegisterRemotePlugin(info webapi.PluginEntry) + GetCorePlugins() []core.PluginEntry + GetK8sPlugins() []k8s.PluginEntry +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/aws_secret_fetcher.go b/flyteplugins/go/tasks/pluginmachinery/secret/aws_secret_fetcher.go new file mode 100644 index 0000000000..b3082fbce1 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/aws_secret_fetcher.go @@ -0,0 +1,64 @@ +package secret + +import ( + "context" + "errors" + "fmt" + + "github.com/aws/aws-sdk-go-v2/aws" + awssm "github.com/aws/aws-sdk-go-v2/service/secretsmanager" + "github.com/aws/aws-sdk-go-v2/service/secretsmanager/types" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + stdlibErrors "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +const ( + AWSSecretLatestVersion = "AWSCURRENT" +) + +type AWSSecretFetcher struct { + client AWSSecretManagerClient + cfg config.AWSConfig +} + +func (a AWSSecretFetcher) GetSecretValue(ctx context.Context, secretID string) (*SecretValue, error) { + logger.Infof(ctx, "Got fetch secret Request for %v!", secretID) + resp, err := a.client.GetSecretValue(ctx, &awssm.GetSecretValueInput{ + SecretId: aws.String(secretID), + VersionStage: aws.String(AWSSecretLatestVersion), + }) + + if err != nil { + var notFound *types.ResourceNotFoundException + if errors.As(err, ¬Found) { + wrappedErr := stdlibErrors.Wrapf(ErrCodeSecretNotFound, err, fmt.Sprintf(SecretNotFoundErrorFormat, secretID)) + logger.Warn(ctx, wrappedErr) + return nil, wrappedErr + } + wrappedErr := stdlibErrors.Wrapf(ErrCodeSecretReadFailure, err, fmt.Sprintf(SecretReadFailureErrorFormat, secretID)) + logger.Error(ctx, wrappedErr) + return nil, wrappedErr + } + + if (resp.SecretString == nil || *resp.SecretString == "") && resp.SecretBinary == nil { + wrappedErr := stdlibErrors.Wrapf(ErrCodeSecretNil, err, fmt.Sprintf(SecretNilErrorFormat, secretID)) + logger.Error(ctx, wrappedErr) + return nil, wrappedErr + } + + secretValue := &SecretValue{} + if resp.SecretString != nil { + secretValue.StringValue = *resp.SecretString + } else { + secretValue.BinaryValue = resp.SecretBinary + } + + return secretValue, nil +} + +// NewAWSSecretFetcher creates a secret value fetcher for AWS +func NewAWSSecretFetcher(cfg config.AWSConfig, client AWSSecretManagerClient) SecretFetcher { + return AWSSecretFetcher{cfg: cfg, client: client} +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/aws_secret_fetcher_test.go b/flyteplugins/go/tasks/pluginmachinery/secret/aws_secret_fetcher_test.go new file mode 100644 index 0000000000..7ed43babcd --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/aws_secret_fetcher_test.go @@ -0,0 +1,73 @@ +package secret + +import ( + "context" + "fmt" + "testing" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/secretsmanager" + "github.com/aws/aws-sdk-go-v2/service/secretsmanager/types" + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/mocks" + stdlibErrors "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +var ( + ctx context.Context + scope promutils.Scope + awsClient *mocks.AWSSecretManagerClient +) + +const secretID = "secretID" + +func SetupTest() { + scope = promutils.NewTestScope() + ctx = context.Background() + awsClient = &mocks.AWSSecretManagerClient{} +} + +func TestGetSecretValueAWS(t *testing.T) { + t.Run("get secret successful", func(t *testing.T) { + SetupTest() + awsSecretsFetcher := NewAWSSecretFetcher(config.AWSConfig{}, awsClient) + awsClient.OnGetSecretValueMatch(ctx, &secretsmanager.GetSecretValueInput{ + SecretId: aws.String(secretID), + VersionStage: aws.String(AWSSecretLatestVersion), + }).Return(&secretsmanager.GetSecretValueOutput{ + SecretString: aws.String("secretValue"), + }, nil) + + _, err := awsSecretsFetcher.GetSecretValue(ctx, "secretID") + assert.NoError(t, err) + }) + + t.Run("get secret not found", func(t *testing.T) { + SetupTest() + awsSecretsFetcher := NewAWSSecretFetcher(config.AWSConfig{}, awsClient) + cause := &types.ResourceNotFoundException{} + awsClient.OnGetSecretValueMatch(ctx, &secretsmanager.GetSecretValueInput{ + SecretId: aws.String(secretID), + VersionStage: aws.String(AWSSecretLatestVersion), + }).Return(nil, cause) + + _, err := awsSecretsFetcher.GetSecretValue(ctx, "secretID") + assert.Equal(t, stdlibErrors.Wrapf(ErrCodeSecretNotFound, cause, fmt.Sprintf(SecretNotFoundErrorFormat, secretID)), err) + }) + + t.Run("get secret read failure", func(t *testing.T) { + SetupTest() + awsSecretsFetcher := NewAWSSecretFetcher(config.AWSConfig{}, awsClient) + cause := fmt.Errorf("some error") + awsClient.OnGetSecretValueMatch(ctx, &secretsmanager.GetSecretValueInput{ + SecretId: aws.String(secretID), + VersionStage: aws.String(AWSSecretLatestVersion), + }).Return(nil, cause) + + _, err := awsSecretsFetcher.GetSecretValue(ctx, "secretID") + assert.Equal(t, stdlibErrors.Wrapf(ErrCodeSecretReadFailure, cause, fmt.Sprintf(SecretReadFailureErrorFormat, secretID)), err) + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/aws_secret_manager.go b/flyteplugins/go/tasks/pluginmachinery/secret/aws_secret_manager.go new file mode 100644 index 0000000000..0ec835cd67 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/aws_secret_manager.go @@ -0,0 +1,150 @@ +package secret + +import ( + "context" + "fmt" + "path/filepath" + "strings" + + corev1 "k8s.io/api/core/v1" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const ( + // AWSSecretArnEnvVar defines the environment variable name to use to specify to the sidecar container which secret + // to pull. + AWSSecretArnEnvVar = "SECRET_ARN" + + // AWSSecretFilenameEnvVar defines the environment variable name to use to specify to the sidecar container where + // to store the secret. + AWSSecretFilenameEnvVar = "SECRET_FILENAME" + + // AWSSecretsVolumeName defines the static name of the volume used for mounting/sharing secrets between init-container + // sidecar and the rest of the containers in the pod. + AWSSecretsVolumeName = "aws-secret-vol" // #nosec + + // AWS SideCar Docker Container expects the mount to always be under /tmp + AWSInitContainerMountPath = "/tmp" + + // AWSSecretMountPath defines the default mount path for secrets + AWSSecretMountPath = "/etc/flyte/secrets" // #nosec G101 +) + +// AWSSecretManagerInjector allows injecting of secrets from AWS Secret Manager as files. It uses AWS-provided SideCar +// as an init-container to download the secret and save it to a local volume shared with all other containers in the pod. +// It supports multiple secrets to be mounted but that will result into adding an init container for each secret. +// The role/serviceaccount used to run the Pod must have permissions to pull the secret from AWS Secret Manager. +// Otherwise, the Pod will fail with an init-error. +// Files will be mounted on /etc/flyte/secrets// +type AWSSecretManagerInjector struct { + cfg config.AWSSecretManagerConfig +} + +func formatAWSSecretArn(secret *core.Secret) string { + return strings.TrimRight(secret.Group, ":") + ":" + strings.TrimLeft(secret.Key, ":") +} + +func formatAWSInitContainerName(index int) string { + return fmt.Sprintf("aws-pull-secret-%v", index) +} + +func (i AWSSecretManagerInjector) Type() config.SecretManagerType { + return config.SecretManagerTypeAWS +} + +func (i AWSSecretManagerInjector) Inject(ctx context.Context, secret *core.Secret, p *corev1.Pod) (newP *corev1.Pod, injected bool, err error) { + if len(secret.Group) == 0 || len(secret.Key) == 0 { + return p, false, fmt.Errorf("AWS Secrets Webhook require both key and group to be set. "+ + "Secret: [%v]", secret) + } + + switch secret.MountRequirement { + case core.Secret_ANY: + fallthrough + case core.Secret_FILE: + // A Volume with a static name so that if we try to inject multiple secrets, we won't mount multiple volumes. + // We use Memory as the storage medium for volume source to avoid + vol := corev1.Volume{ + Name: AWSSecretsVolumeName, + VolumeSource: corev1.VolumeSource{ + EmptyDir: &corev1.EmptyDirVolumeSource{ + Medium: corev1.StorageMediumMemory, + }, + }, + } + + p.Spec.Volumes = appendVolumeIfNotExists(p.Spec.Volumes, vol) + p.Spec.InitContainers = append(p.Spec.InitContainers, createAWSSidecarContainer(i.cfg, p, secret)) + + secretVolumeMount := corev1.VolumeMount{ + Name: AWSSecretsVolumeName, + ReadOnly: true, + MountPath: AWSSecretMountPath, + } + + p.Spec.Containers = AppendVolumeMounts(p.Spec.Containers, secretVolumeMount) + p.Spec.InitContainers = AppendVolumeMounts(p.Spec.InitContainers, secretVolumeMount) + + // Inject AWS secret-inject webhook annotations to mount the secret in a predictable location. + envVars := []corev1.EnvVar{ + // Set environment variable to let the container know where to find the mounted files. + { + Name: SecretPathDefaultDirEnvVar, + Value: AWSSecretMountPath, + }, + // Sets an empty prefix to let the containers know the file names will match the secret keys as-is. + { + Name: SecretPathFilePrefixEnvVar, + Value: "", + }, + } + + for _, envVar := range envVars { + p.Spec.InitContainers = AppendEnvVars(p.Spec.InitContainers, envVar) + p.Spec.Containers = AppendEnvVars(p.Spec.Containers, envVar) + } + case core.Secret_ENV_VAR: + fallthrough + default: + err := fmt.Errorf("unrecognized mount requirement [%v] for secret [%v]", secret.MountRequirement.String(), secret.Key) + logger.Error(ctx, err) + return p, false, err + } + + return p, true, nil +} + +func createAWSSidecarContainer(cfg config.AWSSecretManagerConfig, p *corev1.Pod, secret *core.Secret) corev1.Container { + return corev1.Container{ + Image: cfg.SidecarImage, + // Create a unique name to allow multiple secrets to be mounted. + Name: formatAWSInitContainerName(len(p.Spec.InitContainers)), + VolumeMounts: []corev1.VolumeMount{ + { + Name: AWSSecretsVolumeName, + MountPath: AWSInitContainerMountPath, + }, + }, + Env: []corev1.EnvVar{ + { + Name: AWSSecretArnEnvVar, + Value: formatAWSSecretArn(secret), + }, + { + Name: AWSSecretFilenameEnvVar, + Value: filepath.Join(string(filepath.Separator), strings.ToLower(secret.Group), strings.ToLower(secret.Key)), + }, + }, + Resources: cfg.Resources, + } +} + +// NewAWSSecretManagerInjector creates a SecretInjector that's able to mount secrets from AWS Secret Manager. +func NewAWSSecretManagerInjector(cfg config.AWSSecretManagerConfig) AWSSecretManagerInjector { + return AWSSecretManagerInjector{ + cfg: cfg, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/aws_secret_manager_test.go b/flyteplugins/go/tasks/pluginmachinery/secret/aws_secret_manager_test.go new file mode 100644 index 0000000000..5b3c128d2d --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/aws_secret_manager_test.go @@ -0,0 +1,81 @@ +package secret + +import ( + "context" + "testing" + + "github.com/go-test/deep" + "github.com/stretchr/testify/assert" + corev1 "k8s.io/api/core/v1" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestAWSSecretManagerInjector_Inject(t *testing.T) { + injector := NewAWSSecretManagerInjector(config.DefaultConfig.AWSSecretManagerConfig) + p := &corev1.Pod{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{}, + }, + } + inputSecret := &core.Secret{ + Group: "arn", + Key: "name", + } + + expected := &corev1.Pod{ + Spec: corev1.PodSpec{ + Volumes: []corev1.Volume{ + { + Name: "aws-secret-vol", + VolumeSource: corev1.VolumeSource{ + EmptyDir: &corev1.EmptyDirVolumeSource{ + Medium: corev1.StorageMediumMemory, + }, + }, + }, + }, + + InitContainers: []corev1.Container{ + { + Name: "aws-pull-secret-0", + Image: "docker.io/amazon/aws-secrets-manager-secret-sidecar:v0.1.4", + Env: []corev1.EnvVar{ + { + Name: "FLYTE_SECRETS_FILE_PREFIX", + Value: "", + }, + { + Name: "FLYTE_SECRETS_DEFAULT_DIR", + Value: "/etc/flyte/secrets", + }, + { + Name: "SECRET_ARN", + Value: inputSecret.Group + ":" + inputSecret.Key, + }, + { + Name: "SECRET_FILENAME", + Value: "/" + inputSecret.Group + "/" + inputSecret.Key, + }, + }, + VolumeMounts: []corev1.VolumeMount{ + { + Name: "aws-secret-vol", + MountPath: "/tmp", + }, + }, + Resources: config.DefaultConfig.AWSSecretManagerConfig.Resources, + }, + }, + Containers: []corev1.Container{}, + }, + } + + actualP, injected, err := injector.Inject(context.Background(), inputSecret, p.DeepCopy()) + assert.NoError(t, err) + assert.True(t, injected) + if diff := deep.Equal(actualP, expected); diff != nil { + assert.Fail(t, "actual != expected", "Diff: %v", diff) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/azure_secret_fetcher.go b/flyteplugins/go/tasks/pluginmachinery/secret/azure_secret_fetcher.go new file mode 100644 index 0000000000..29b60c22f5 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/azure_secret_fetcher.go @@ -0,0 +1,72 @@ +package secret + +import ( + "context" + "errors" + "fmt" + "net/http" + + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azidentity" + "github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azsecrets" + + stdlibErrors "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +const ( + azureLatestVersion string = "" // Empty string represents the latest version of the secret +) + +type AzureSecretFetcher struct { + // The Azure Key Vault client to use for fetching secrets + client AzureKeyVaultClient +} + +func (a AzureSecretFetcher) GetSecretValue(ctx context.Context, secretID string) (*SecretValue, error) { + secretName, err := EncodeAzureSecretName(secretID) + if err != nil { + logger.Errorf(ctx, "Failed to encode secret name %v: %w", secretID, err) + return nil, stdlibErrors.Wrapf(ErrCodeSecretReadFailure, err, fmt.Sprintf(SecretReadFailureErrorFormat, secretID)) + } + resp, err := a.client.GetSecret(ctx, secretName, azureLatestVersion, nil) + if err != nil { + var notFound *azcore.ResponseError + if errors.As(err, ¬Found) && notFound.StatusCode == http.StatusNotFound { + logger.Errorf(ctx, "Azure secret not found: %w", secretID) + return nil, stdlibErrors.Wrapf(ErrCodeSecretNotFound, err, fmt.Sprintf(SecretNotFoundErrorFormat, secretID)) + } + logger.Errorf(ctx, "Failed to fetch secret %v: %w", secretID, err) + return nil, stdlibErrors.Wrapf(ErrCodeSecretReadFailure, err, fmt.Sprintf(SecretReadFailureErrorFormat, secretID)) + } + + if resp.Value == nil || len(*resp.Value) == 0 { + logger.Errorf(ctx, "Secret %v returned empty value", secretID) + return nil, stdlibErrors.Wrapf(ErrCodeSecretNil, err, fmt.Sprintf(SecretNilErrorFormat, secretID)) + } + + sv, err := AzureToUnionSecret(resp.Secret) + if err != nil { + logger.Errorf(ctx, "Failed to convert Azure secret %v to Union secret", secretID) + return nil, stdlibErrors.Wrapf(ErrCodeSecretReadFailure, err, fmt.Sprintf(SecretReadFailureErrorFormat, secretID)) + } + return sv, nil +} + +func NewAzureSecretFetcher(client AzureKeyVaultClient) SecretFetcher { + return &AzureSecretFetcher{client: client} +} + +func getAzureKVSecretsClient(vaultURI string) (*azsecrets.Client, error) { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + return nil, fmt.Errorf("failed to get azure credentials: %w", err) + } + + client, err := azsecrets.NewClient(vaultURI, cred, nil) + if err != nil { + return nil, fmt.Errorf("failed to create azure secrets client: %w", err) + } + + return client, nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/azure_secret_fetcher_test.go b/flyteplugins/go/tasks/pluginmachinery/secret/azure_secret_fetcher_test.go new file mode 100644 index 0000000000..374f5593fc --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/azure_secret_fetcher_test.go @@ -0,0 +1,158 @@ +package secret + +import ( + "bytes" + "context" + "encoding/base64" + "encoding/json" + "fmt" + "io" + "net/http" + "testing" + + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" + "github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azsecrets" + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/mocks" + stdlibErrors "github.com/flyteorg/flyte/v2/flytestdlib/errors" +) + +func setupAzureSecretFetcherTest() (SecretFetcher, *mocks.AzureKeyVaultClient) { + client := &mocks.AzureKeyVaultClient{} + return NewAzureSecretFetcher(client), client +} + +func Test_AzureSecretFetcher_GetSecretValue(t *testing.T) { + secretName := "test-secret" + validSecretIDFmt := "u__org__test-org__domain__test-domain__project__test-project__key__%s" // #nosec G101 + validSecretID := fmt.Sprintf(validSecretIDFmt, secretName) + validEncodedSecretID, _ := EncodeAzureSecretName(validSecretID) + + sucessfulTests := []struct { + name string + secretIDArg string + returnValue string + }{ + { + "test successful string retrieval", + validSecretID, + "test-secret-value", + }, + } + + ctx := context.Background() + + for _, tt := range sucessfulTests { + t.Run(tt.name, func(t *testing.T) { + fetcher, client := setupAzureSecretFetcherTest() + jsonData, err := json.Marshal(azureSecretValue{ + Type: azureSecretValueTypeSTRING, + Value: tt.returnValue, + }) + assert.NoError(t, err) + returnValue := string(jsonData) + mockedResponse := azsecrets.GetSecretResponse{Secret: azsecrets.Secret{Value: &returnValue}} + client.OnGetSecret(ctx, validEncodedSecretID, azureLatestVersion, nil).Return(mockedResponse, nil) + + sv, err := fetcher.GetSecretValue(ctx, tt.secretIDArg) + if err != nil { + t.Errorf("GetSecretValue() got error %v", err) + } + assert.Equal(t, tt.returnValue, sv.StringValue) + }) + } + + sucessfulBinaryTests := []struct { + name string + secretIDArg string + returnValue *[]byte + }{ + { + "test successful binary retrieval", + validSecretID, + to.Ptr([]byte{0x48, 0x65, 0x6C, 0x6C, 0x6F}), + }, + } + + for _, tt := range sucessfulBinaryTests { + t.Run(tt.name, func(t *testing.T) { + fetcher, client := setupAzureSecretFetcherTest() + jsonData, err := json.Marshal(azureSecretValue{ + Type: azureSecretValueTypeBINARY, + Value: base64.StdEncoding.EncodeToString(*tt.returnValue), + }) + assert.NoError(t, err) + returnValue := string(jsonData) + mockedResponse := azsecrets.GetSecretResponse{Secret: azsecrets.Secret{Value: &returnValue}} + client.OnGetSecret(ctx, validEncodedSecretID, azureLatestVersion, nil).Return(mockedResponse, nil) + + sv, err := fetcher.GetSecretValue(ctx, tt.secretIDArg) + if err != nil { + t.Errorf("GetSecretValue() got error %v", err) + } + assert.Equal(t, *tt.returnValue, sv.BinaryValue) + }) + } + + t.Run("Azure Key Vault returns not found error", func(t *testing.T) { + fetcher, client := setupAzureSecretFetcherTest() + + azError := AzureErrorResponse{ + Error: AzureError{ + Code: "NotFound", + Message: "Not found", + }, + } + rawResponseBody, err := json.Marshal(azError) + assert.NoError(t, err) + respError := runtime.NewResponseError(&http.Response{ + StatusCode: http.StatusNotFound, + Header: http.Header{ + "x-ms-error-code": []string{"NotFound"}, + }, + Body: io.NopCloser(bytes.NewBufferString(string(rawResponseBody))), + }) + client.OnGetSecret(ctx, validEncodedSecretID, azureLatestVersion, nil).Return(azsecrets.GetSecretResponse{}, respError) + + _, err = fetcher.GetSecretValue(ctx, validSecretID) + assert.Equal(t, stdlibErrors.Wrapf(ErrCodeSecretNotFound, respError, fmt.Sprintf(SecretNotFoundErrorFormat, validSecretID)), err) + }) + + t.Run("Azure Key Vault returns unexpected error", func(t *testing.T) { + fetcher, client := setupAzureSecretFetcherTest() + cause := fmt.Errorf("test-error") + client.OnGetSecret(ctx, validEncodedSecretID, azureLatestVersion, nil).Return(azsecrets.GetSecretResponse{}, cause) + + _, err := fetcher.GetSecretValue(ctx, validSecretID) + assert.Equal(t, stdlibErrors.Wrapf(ErrCodeSecretReadFailure, cause, fmt.Sprintf(SecretReadFailureErrorFormat, validSecretID)), err) + }) + + emptyStr := "" + emptyResultTests := []struct { + name string + secretIDArg string + returnValue *string + }{ + { + "nil", + validSecretID, + nil, + }, + { + "empty", + validSecretID, + &emptyStr, + }, + } + + for _, tt := range emptyResultTests { + t.Run(fmt.Sprintf("Azure Key Vault returns %v value", tt.name), func(t *testing.T) { + fetcher, client := setupAzureSecretFetcherTest() + client.OnGetSecret(ctx, validEncodedSecretID, azureLatestVersion, nil).Return(azsecrets.GetSecretResponse{Secret: azsecrets.Secret{Value: tt.returnValue}}, nil) + _, err := fetcher.GetSecretValue(ctx, tt.secretIDArg) + assert.Equal(t, stdlibErrors.Wrapf(ErrCodeSecretNil, nil, fmt.Sprintf(SecretNilErrorFormat, tt.secretIDArg)), err) + }) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/azure_secret_manager.go b/flyteplugins/go/tasks/pluginmachinery/secret/azure_secret_manager.go new file mode 100644 index 0000000000..d76eda8b4f --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/azure_secret_manager.go @@ -0,0 +1,156 @@ +package secret + +import ( + "context" + "fmt" + "path" + "path/filepath" + "strings" + + corev1 "k8s.io/api/core/v1" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const ( + AzureSecretsVolumeName = "azure-secret-vol" // #nosec G101 + + AzureSecretMountPath = "/etc/flyte/secrets" // #nosec G101 +) + +// AzureSecretManagerInjector allows injecting of secrets from Azure Key Vault as files. It uses a Azure az-cli +// SDK SideCar as an init-container to download the secret and save it to a local volume shared with all other +// containers in the pod. It supports multiple secrets to be mounted but that will result into adding an init +// container for each secret. The Azure user-assigned managed identity associated with the Pod via +// Workload Identity Federation, must have permissions to pull +// the secret from Azure Key Vault. +// +// Files will be mounted on +// - /etc/flyte/secrets// when GroupVersion is set +// - /etc/flyte/secrets/ when GroupVersion is not set, retrieving the latest version. +type AzureSecretManagerInjector struct { + cfg config.AzureSecretManagerConfig +} + +func (a AzureSecretManagerInjector) Type() config.SecretManagerType { + return config.SecretManagerTypeAzure +} + +func (a AzureSecretManagerInjector) Inject(ctx context.Context, secret *core.Secret, p *corev1.Pod) (newP *corev1.Pod, injected bool, err error) { + if len(secret.Group) == 0 { // Group version allowed to be empty to retrieve latest secret + return p, false, fmt.Errorf("Azure Secrets Webhook require both group and group version to be set. "+ + "Secret: [%v]", secret) + } + + switch secret.MountRequirement { + case core.Secret_ANY: + fallthrough + case core.Secret_FILE: + // A Volume with a static name so that if we try to inject multiple secrets, we won't mount multiple volumes. + // We use Memory as the storage medium for volume source to avoid + vol := corev1.Volume{ + Name: AzureSecretsVolumeName, + VolumeSource: corev1.VolumeSource{ + EmptyDir: &corev1.EmptyDirVolumeSource{ + Medium: corev1.StorageMediumMemory, + }, + }, + } + + p.Spec.Volumes = appendVolumeIfNotExists(p.Spec.Volumes, vol) + p.Spec.InitContainers = append(p.Spec.InitContainers, createAzureSidecarContainer(a.cfg, p, secret)) + + secretVolumeMount := corev1.VolumeMount{ + Name: AzureSecretsVolumeName, + ReadOnly: true, + MountPath: AzureSecretMountPath, + } + + p.Spec.Containers = AppendVolumeMounts(p.Spec.Containers, secretVolumeMount) + p.Spec.InitContainers = AppendVolumeMounts(p.Spec.InitContainers, secretVolumeMount) + + // Inject Azure secret-inject webhook annotations to mount the secret in a predictable location. + envVars := []corev1.EnvVar{ + // Set environment variable to let the container know where to find the mounted files. + { + Name: SecretPathDefaultDirEnvVar, + Value: AzureSecretMountPath, + }, + // Sets an empty prefix to let the containers know the file names will match the secret keys as-is. + { + Name: SecretPathFilePrefixEnvVar, + Value: "", + }, + } + + for _, envVar := range envVars { + p.Spec.InitContainers = AppendEnvVars(p.Spec.InitContainers, envVar) + p.Spec.Containers = AppendEnvVars(p.Spec.Containers, envVar) + } + case core.Secret_ENV_VAR: + fallthrough + default: + err := fmt.Errorf("unrecognized mount requirement [%v] for secret [%v]", secret.MountRequirement.String(), secret.Key) + logger.Error(ctx, err) + return p, false, err + } + + return p, true, nil +} + +func createAzureSidecarContainer(cfg config.AzureSecretManagerConfig, p *corev1.Pod, secret *core.Secret) corev1.Container { + return corev1.Container{ + Image: cfg.SidecarImage, + // Create a unique name to allow multiple secrets to be mounted. + Name: formatAzureInitContainerName(len(p.Spec.InitContainers)), + Command: formatAzureSecretAccessCommand(secret), + VolumeMounts: []corev1.VolumeMount{ + { + Name: AzureSecretsVolumeName, + MountPath: AzureSecretMountPath, + }, + }, + Resources: cfg.Resources, + } +} + +func formatAzureInitContainerName(index int) string { + return fmt.Sprintf("azure-pull-secret-%v", index) +} + +func formatAzureSecretAccessCommand(secret *core.Secret) []string { + // Azure provides the entire Secret URI the Key Vault Secret. + trimmedUri := strings.TrimRight(secret.Group, "/") + _, path := path.Split(trimmedUri) + segments := strings.Split(path, "/") + secretName := segments[len(segments)-1] + + // Initialize as if GroupVersion is not set + secretDir := AzureSecretMountPath + secretPath := strings.ToLower(filepath.Join(secretDir, secretName)) + mkdirCmd := "" + if len(secret.GroupVersion) > 0 { // Apply GroupVersion specific configuration + secretDir = strings.ToLower(filepath.Join(AzureSecretMountPath, secretName)) + secretPath = strings.ToLower(filepath.Join(secretDir, secret.GroupVersion)) + mkdirCmd = fmt.Sprintf("mkdir -p %[1]s; ", secretDir) + } + + command := "az login --service-principal -u $AZURE_CLIENT_ID -t $AZURE_TENANT_ID --federated-token \"$(cat $AZURE_FEDERATED_TOKEN_FILE)\"; " + + mkdirCmd + "az keyvault secret show --id \"%[1]s/%[2]s\" --query \"value\" -o tsv > %[3]s" + + args := fmt.Sprintf( + command, + trimmedUri, + secret.GroupVersion, + secretPath, + ) + return []string{"sh", "-ec", args} +} + +func NewAzureSecretManagerInjector(cfg config.AzureSecretManagerConfig) AzureSecretManagerInjector { + return AzureSecretManagerInjector{ + cfg: cfg, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/azure_secret_manager_test.go b/flyteplugins/go/tasks/pluginmachinery/secret/azure_secret_manager_test.go new file mode 100644 index 0000000000..9b948a169c --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/azure_secret_manager_test.go @@ -0,0 +1,115 @@ +package secret + +import ( + "context" + "testing" + + "github.com/go-test/deep" + "github.com/stretchr/testify/assert" + corev1 "k8s.io/api/core/v1" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestAzureSecretManagerInjector_Inject(t *testing.T) { + injector := NewAzureSecretManagerInjector(config.DefaultConfig.AzureSecretManagerConfig) + + tests := []struct { + name string + secret *core.Secret + expectedCommand string + }{ + { + "test secret with explicit version", + &core.Secret{ + Group: "https://test-storage-account.vault.azure.net/secrets/test-secret-name", + GroupVersion: "test-version", + }, + "az login --service-principal -u $AZURE_CLIENT_ID -t $AZURE_TENANT_ID --federated-token \"$(cat $AZURE_FEDERATED_TOKEN_FILE)\"; " + + "mkdir -p /etc/flyte/secrets/test-secret-name; az keyvault secret show --id \"https://test-storage-account.vault.azure.net/secrets/test-secret-name/test-version\" --query \"value\" -o tsv > /etc/flyte/secrets/test-secret-name/test-version", + }, + { + "test secret with ending slash", + &core.Secret{ + Group: "https://test-storage-account.vault.azure.net/secrets/test-secret-name/", + GroupVersion: "test-version", + }, + "az login --service-principal -u $AZURE_CLIENT_ID -t $AZURE_TENANT_ID --federated-token \"$(cat $AZURE_FEDERATED_TOKEN_FILE)\"; " + + "mkdir -p /etc/flyte/secrets/test-secret-name; az keyvault secret show --id \"https://test-storage-account.vault.azure.net/secrets/test-secret-name/test-version\" --query \"value\" -o tsv > /etc/flyte/secrets/test-secret-name/test-version", + }, + { + "test secret with no version defaults to latest", + &core.Secret{ + Group: "https://test-storage-account.vault.azure.net/secrets/test-secret-name", + }, + "az login --service-principal -u $AZURE_CLIENT_ID -t $AZURE_TENANT_ID --federated-token \"$(cat $AZURE_FEDERATED_TOKEN_FILE)\"; " + + "az keyvault secret show --id \"https://test-storage-account.vault.azure.net/secrets/test-secret-name/\" --query \"value\" -o tsv > /etc/flyte/secrets/test-secret-name", + }, + } + + for _, tt := range tests { + p := &corev1.Pod{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{}, + }, + } + + t.Run(tt.name, func(t *testing.T) { + expectedPod := expectedInitPod(tt.expectedCommand) + actualPod, injected, err := injector.Inject(context.Background(), tt.secret, p) + assert.NoError(t, err) + assert.True(t, injected) + if diff := deep.Equal(actualPod, expectedPod); diff != nil { + assert.Fail(t, "actual != expected", "Diff: %v", diff) + } + }) + } +} + +func expectedInitPod(command string) *corev1.Pod { + return &corev1.Pod{ + Spec: corev1.PodSpec{ + Volumes: []corev1.Volume{ + { + Name: "azure-secret-vol", + VolumeSource: corev1.VolumeSource{ + EmptyDir: &corev1.EmptyDirVolumeSource{ + Medium: corev1.StorageMediumMemory, + }, + }, + }, + }, + + InitContainers: []corev1.Container{ + { + Name: "azure-pull-secret-0", + Image: "mcr.microsoft.com/azure-cli:cbl-mariner2.0", + Command: []string{ + "sh", + "-ec", + command, + }, + Env: []corev1.EnvVar{ + { + Name: "FLYTE_SECRETS_FILE_PREFIX", + Value: "", + }, + { + Name: "FLYTE_SECRETS_DEFAULT_DIR", + Value: "/etc/flyte/secrets", + }, + }, + VolumeMounts: []corev1.VolumeMount{ + { + Name: "azure-secret-vol", + MountPath: "/etc/flyte/secrets", + }, + }, + Resources: config.DefaultConfig.AzureSecretManagerConfig.Resources, + }, + }, + Containers: []corev1.Container{}, + }, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/azure_utils.go b/flyteplugins/go/tasks/pluginmachinery/secret/azure_utils.go new file mode 100644 index 0000000000..500db5c8ef --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/azure_utils.go @@ -0,0 +1,181 @@ +package secret + +import ( + "encoding/base32" + "encoding/base64" + "encoding/json" + "fmt" + "strings" + + "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" + "github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azsecrets" +) + +const ( + azureSecretNameComponentDelimiter = "-" + azureMaxSecretNameLength = 127 + azureEncodingVersion = 1 + azureEscapeChar = "0" // unique single character to escape special characters + azureHyphenMarker = '1' // unique single character to escape hyphens + EmptyString = "" +) + +// Custom base32 encoding without padding +var base32Encoding = base32.StdEncoding.WithPadding(base32.NoPadding) + +// Azure Key Vault specific encoding for secret names. +// Union introduces __ to deliminate contextual information into the secret. +// +// This codec unwraps the Union specific Key encoding and re-encodes it to a format that is compatible with Azure Key Vault. +// The encoding scheme is versioned and is as follows: +// - Uses 0 as an escape character +// - Uses 1 to escape hyphens +// - Uses 2 to escape underscores +// - Uses base32 encoding for the name component +// +// Ref: https://azure.github.io/PSRule.Rules.Azure/en/rules/Azure.KeyVault.SecretName/ +func EncodeAzureSecretName(secretName string) (string, error) { + components, err := DecodeSecretName(secretName) + if err != nil { + return EmptyString, fmt.Errorf("unable to decode original secret name: %w", err) + } + + encode := func(s string) string { + s = strings.ReplaceAll(s, azureEscapeChar, azureEscapeChar+azureEscapeChar) + return strings.ReplaceAll(s, "-", azureEscapeChar+string(azureHyphenMarker)) + } + + parts := []string{ + encode(components.Org), + encode(components.Domain), + encode(components.Project), + base32Encoding.EncodeToString([]byte(components.Name)), + } + + encoded := fmt.Sprint(azureEncodingVersion) + azureSecretNameComponentDelimiter + strings.Join(parts, azureSecretNameComponentDelimiter) + + if len(encoded) > azureMaxSecretNameLength { + return EmptyString, fmt.Errorf("encoded secret name with length %d exceeds maximum length: %d", len(encoded), azureMaxSecretNameLength) + } + + return encoded, nil +} + +// Azure Key Vault specific decoding for secret names. +// Reverses EncodeAzureSecretName. +func DecodeAzureSecretName(encodedSecretName string) (string, error) { + parts := strings.Split(encodedSecretName, azureSecretNameComponentDelimiter) + if len(parts) != 5 || parts[0] != fmt.Sprint(azureEncodingVersion) { + return EmptyString, fmt.Errorf("invalid secret name format or version") + } + + nameBytes, err := base32Encoding.DecodeString(parts[4]) + if err != nil { + return EmptyString, fmt.Errorf("error decoding name component: %w", err) + } + + decode := func(s string) (*string, error) { + var result strings.Builder + for i := 0; i < len(s); i++ { + if s[i] == '0' && i+1 < len(s) { + if s[i+1] == '0' { + result.WriteByte('0') + } else if s[i+1] == azureHyphenMarker { + result.WriteByte('-') + } else { + return nil, fmt.Errorf("unexpected escape sequence: %c%c", s[i], s[i+1]) + } + i++ + } else { + result.WriteByte(s[i]) + } + } + return to.Ptr(result.String()), nil + } + + org, err := decode(parts[1]) + if err != nil { + return EmptyString, fmt.Errorf("error decoding org from stored secret %s: %w", encodedSecretName, err) + } + + domain, err := decode(parts[2]) + if err != nil { + return EmptyString, fmt.Errorf("error decoding domain from stored secret %s: %w", encodedSecretName, err) + } + + project, err := decode(parts[3]) + if err != nil { + return EmptyString, fmt.Errorf("error decoding project from stored secret %s: %w", encodedSecretName, err) + } + + // Re-encode to Union naming format + return EncodeSecretName(*org, *domain, *project, string(nameBytes)), nil +} + +// Encodes a string value to appropriate Json format for Azure Key Vault storage +func StringToAzureSecret(value string) (string, error) { + return marshalAzureSecretValue(azureSecretValueTypeSTRING, value) +} + +// Encodes a binary value to appropriate Json format for Azure Key Vault storage +func BinaryToAzureSecret(value []byte) (string, error) { + return marshalAzureSecretValue(azureSecretValueTypeBINARY, base64.StdEncoding.EncodeToString(value)) +} + +func AzureToUnionSecret(secret azsecrets.Secret) (*SecretValue, error) { + var sv azureSecretValue + err := json.Unmarshal([]byte(*secret.Value), &sv) + if err != nil { + return nil, err + } + + if sv.Type == azureSecretValueTypeBINARY { + bytes, err := base64.StdEncoding.DecodeString(sv.Value) + if err != nil { + return nil, err + } + return &SecretValue{BinaryValue: bytes}, nil + } + + return &SecretValue{StringValue: sv.Value}, nil +} + +// The AzureErrorResponse object represents an error response from Azure Key Vault API. +// +// Ref: https://learn.microsoft.com/en-us/azure/key-vault/general/authentication-requests-and-responses +type AzureErrorResponse struct { + Error AzureError `json:"error"` +} + +type AzureError struct { + Code string `json:"code"` + Message string `json:"message"` +} + +//go:generate enumer --type=azureSecretValueType --trimprefix=azureSecretValueType -json -yaml + +type azureSecretValueType uint8 + +const ( + azureSecretValueTypeSTRING azureSecretValueType = iota + azureSecretValueTypeBINARY +) + +// A Flyte specific encoding to store strings and binary data as secrets in Azure Key Vault. +// Azure only supports strings and this allows us to store binary data as base64 encoded byte slice. +type azureSecretValue struct { + Type azureSecretValueType `json:"type"` + // utf-8 string if type is STRING, based64 encoded bytes if type is BINARY + Value string `json:"value"` +} + +func marshalAzureSecretValue(t azureSecretValueType, value string) (string, error) { + bytes, err := json.Marshal(azureSecretValue{ + Type: t, + Value: value, + }) + if err != nil { + return EmptyString, err + } + return string(bytes), nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/azure_utils_test.go b/flyteplugins/go/tasks/pluginmachinery/secret/azure_utils_test.go new file mode 100644 index 0000000000..8c388c789b --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/azure_utils_test.go @@ -0,0 +1,238 @@ +package secret + +import ( + "encoding/base64" + "fmt" + "math" + "testing" + + "github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azsecrets" + "github.com/stretchr/testify/assert" +) + +const ( + // Including -, 0, and 1 to tests encoding and decoding escape functionality in addition to specific names + validSecretIDFmt = "u__org__testorg__domain__testdomain__project__testproject__key__%s" // #nosec G101 + longSecretIDPrefix = "u__org__test-org-with-long-name__domain__development__project__union-health-monitoring__key__" // #nosec G101 +) + +var azureEncodingDecodingVars = []struct { + name string + decoded string + encoded string +}{ + { + name: "test name without hyphens, escape characters, nor hyphen markers", + decoded: "u__org__testorg__domain__testdomain__project__testproject__key__testsecret", + encoded: "1-testorg-testdomain-testproject-ORSXG5DTMVRXEZLU", + }, + { + name: "test name with hyphens", + decoded: "u__org__test-org__domain__test--domain__project__--testproject--__key__test-secret--", + encoded: "1-test01org-test0101domain-0101testproject0101-ORSXG5BNONSWG4TFOQWS2", + }, + { + name: "test name with escape characters", + decoded: "u__org__test0org__domain__test00domain__project__00testproject00__key__testsecret", + encoded: "1-test00org-test0000domain-0000testproject0000-ORSXG5DTMVRXEZLU", + }, + { + name: "test name that looks escaped", + decoded: "u__org__test01org__domain__test0102domain__project__01testproject0101__key__testsecret", + encoded: "1-test001org-test001002domain-001testproject001001-ORSXG5DTMVRXEZLU", + }, + { + name: "test secret name that has invalid Azure characters", + decoded: "u__org__test01org__domain__test0101domain__project__01testproject0101__key__test_secret__", + encoded: "1-test001org-test001001domain-001testproject001001-ORSXG5C7ONSWG4TFORPV6", + }, + { + name: "test secret name with capital letters", + decoded: "u__org__test01org__domain__test0101domain__project__01testproject0101__key__TESTSECRET", + encoded: "1-test001org-test001001domain-001testproject001001-KRCVGVCTIVBVERKU", + }, +} + +func Test_EncodeAzureSecretName(t *testing.T) { + for _, tt := range azureEncodingDecodingVars { + t.Run(tt.name, func(t *testing.T) { + got, err := EncodeAzureSecretName(tt.decoded) + assert.NoError(t, err) + assert.Equal(t, tt.encoded, got) + }) + } + + t.Run("secret name is too long", func(t *testing.T) { + encodedPrefix, err := EncodeAzureSecretName(longSecretIDPrefix) + assert.NoError(t, err) + spaceRemaining := azureMaxSecretNameLength - len(encodedPrefix) + maxLength := int(math.Floor(float64(spaceRemaining) * 5 / 8)) + + b := make([]byte, maxLength+1) + for i := range b { + b[i] = 'a' + } + _, err = EncodeAzureSecretName(longSecretIDPrefix + string(b)) + assert.Error(t, err) + }) + + t.Run("supports case insensitive secret name", func(t *testing.T) { + lower, err := EncodeAzureSecretName(fmt.Sprintf(validSecretIDFmt, "testsecret")) + assert.NoError(t, err) + upper, err := EncodeAzureSecretName(fmt.Sprintf(validSecretIDFmt, "TESTSECRET")) + assert.NoError(t, err) + assert.NotEqual(t, lower, upper) + }) +} + +func Test_DecodeAzureSecretName(t *testing.T) { + for _, tt := range azureEncodingDecodingVars { + t.Run(tt.name, func(t *testing.T) { + got, err := DecodeAzureSecretName(tt.encoded) + assert.NoError(t, err) + assert.Equal(t, tt.decoded, got) + }) + } + + t.Run("invalid secret name version", func(t *testing.T) { + _, err := DecodeAzureSecretName("2-test01org00-test01domain0000-test01project001-testsecret") + assert.Error(t, err) + }) + + t.Run("incorrect number of parts", func(t *testing.T) { + _, err := DecodeAzureSecretName("1-test01org00-test01domain0000test01project001-testsecret") + assert.Error(t, err) + }) + + t.Run("org has unexpected escaped character", func(t *testing.T) { + invalidSecretName := "1-test02org-testdomain-testproject-ORSXG5DTMVRXEZLU" + _, err := DecodeAzureSecretName(invalidSecretName) + assert.Error(t, err) + assert.EqualError(t, err, fmt.Sprintf("error decoding org from stored secret %s: unexpected escape sequence: 02", invalidSecretName)) + }) + + t.Run("domain has unexpected escaped character", func(t *testing.T) { + invalidSecretName := "1-testorg-test02domain-testproject-ORSXG5DTMVRXEZLU" // #nosec G101 + _, err := DecodeAzureSecretName(invalidSecretName) + assert.Error(t, err) + assert.EqualError(t, err, fmt.Sprintf("error decoding domain from stored secret %s: unexpected escape sequence: 02", invalidSecretName)) + }) + + t.Run("project has unexpected escaped character", func(t *testing.T) { + invalidSecretName := "1-testorg-testdomain-test02project-ORSXG5DTMVRXEZLU" + _, err := DecodeAzureSecretName(invalidSecretName) + assert.Error(t, err) + assert.EqualError(t, err, fmt.Sprintf("error decoding project from stored secret %s: unexpected escape sequence: 02", invalidSecretName)) + }) +} + +func Test_EncodeDecodeAzureSecretName_Bijectivity(t *testing.T) { + for _, tt := range azureEncodingDecodingVars { + t.Run(tt.name, func(t *testing.T) { + encoded, err := EncodeAzureSecretName(tt.decoded) + assert.NoError(t, err) + decoded, err := DecodeAzureSecretName(encoded) + assert.NoError(t, err) + assert.Equal(t, tt.decoded, decoded) + }) + } +} + +func Test_StringToAzureSecret(t *testing.T) { + tests := []struct { + name string + arg string + }{ + { + "empty string", + "", + }, + { + "test-value", + "test-value", + }, + { + "value with spaces", + " test value ", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + res, err := StringToAzureSecret(tt.arg) + assert.NoError(t, err) + assert.Equal(t, fmt.Sprintf(`{"type":"STRING","value":"%v"}`, tt.arg), res) + // Test bijective property + decoded, err := AzureToUnionSecret(azsecrets.Secret{Value: &res}) + assert.NoError(t, err) + assert.Equal(t, tt.arg, decoded.StringValue) + }) + } +} + +func Test_BinaryToAzureSecret(t *testing.T) { + tests := []struct { + name string + arg []byte + }{ + { + "empty", + []byte{}, + }, + { + "single element", + []byte{0x48}, + }, + { + "non empty", + []byte{0x48, 0x65, 0x6C, 0x6C, 0x6F}, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + res, err := BinaryToAzureSecret(tt.arg) + assert.NoError(t, err) + encodedBinary := base64.StdEncoding.EncodeToString(tt.arg) + assert.Equal(t, fmt.Sprintf(`{"type":"BINARY","value":"%v"}`, encodedBinary), res) + // Test bijective property + decoded, err := AzureToUnionSecret(azsecrets.Secret{Value: &res}) + assert.NoError(t, err) + assert.Equal(t, tt.arg, decoded.BinaryValue) + }) + } +} + +func Test_AzureToUnionSecret(t *testing.T) { + t.Run("successful string translation", func(t *testing.T) { + azSecretValue := `{"type":"STRING","value":"test-value"}` //nolint:gosec + azSecret := azsecrets.Secret{Value: &azSecretValue} + got, err := AzureToUnionSecret(azSecret) + assert.NoError(t, err) + assert.Equal(t, SecretValue{StringValue: "test-value"}, *got) + }) + + t.Run("successful byte translation", func(t *testing.T) { + expectedSecretValue := []byte{0x48, 0x65, 0x6C, 0x6C, 0x6F} + azSecretValueFmt := `{"type":"BINARY","value":"%v"}` //nolint:gosec + azSecretValue := fmt.Sprintf(azSecretValueFmt, base64.StdEncoding.EncodeToString(expectedSecretValue)) + azSecret := azsecrets.Secret{Value: &azSecretValue} + got, err := AzureToUnionSecret(azSecret) + assert.NoError(t, err) + assert.Equal(t, SecretValue{BinaryValue: expectedSecretValue}, *got) + }) + + t.Run("invalid json", func(t *testing.T) { + azSecretValue := `{"type":"STRING","value":"test-value"` //nolint:gosec + azSecret := azsecrets.Secret{Value: &azSecretValue} + _, err := AzureToUnionSecret(azSecret) + assert.Error(t, err) + }) + + t.Run("non valid base64 encoded binary", func(t *testing.T) { + azSecretValue := `{"type":"BINARY","value":"test-value"}` //nolint:gosec + azSecret := azsecrets.Secret{Value: &azSecretValue} + _, err := AzureToUnionSecret(azSecret) + assert.Error(t, err) + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/azuresecretvaluetype_enumer.go b/flyteplugins/go/tasks/pluginmachinery/secret/azuresecretvaluetype_enumer.go new file mode 100644 index 0000000000..40814c121d --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/azuresecretvaluetype_enumer.go @@ -0,0 +1,84 @@ +// Code generated by "enumer --type=azureSecretValueType --trimprefix=azureSecretValueType -json -yaml"; DO NOT EDIT. + +package secret + +import ( + "encoding/json" + "fmt" +) + +const _azureSecretValueTypeName = "STRINGBINARY" + +var _azureSecretValueTypeIndex = [...]uint8{0, 6, 12} + +func (i azureSecretValueType) String() string { + if i >= azureSecretValueType(len(_azureSecretValueTypeIndex)-1) { + return fmt.Sprintf("azureSecretValueType(%d)", i) + } + return _azureSecretValueTypeName[_azureSecretValueTypeIndex[i]:_azureSecretValueTypeIndex[i+1]] +} + +var _azureSecretValueTypeValues = []azureSecretValueType{0, 1} + +var _azureSecretValueTypeNameToValueMap = map[string]azureSecretValueType{ + _azureSecretValueTypeName[0:6]: 0, + _azureSecretValueTypeName[6:12]: 1, +} + +// azureSecretValueTypeString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func azureSecretValueTypeString(s string) (azureSecretValueType, error) { + if val, ok := _azureSecretValueTypeNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to azureSecretValueType values", s) +} + +// azureSecretValueTypeValues returns all values of the enum +func azureSecretValueTypeValues() []azureSecretValueType { + return _azureSecretValueTypeValues +} + +// IsAazureSecretValueType returns "true" if the value is listed in the enum definition. "false" otherwise +func (i azureSecretValueType) IsAazureSecretValueType() bool { + for _, v := range _azureSecretValueTypeValues { + if i == v { + return true + } + } + return false +} + +// MarshalJSON implements the json.Marshaler interface for azureSecretValueType +func (i azureSecretValueType) MarshalJSON() ([]byte, error) { + return json.Marshal(i.String()) +} + +// UnmarshalJSON implements the json.Unmarshaler interface for azureSecretValueType +func (i *azureSecretValueType) UnmarshalJSON(data []byte) error { + var s string + if err := json.Unmarshal(data, &s); err != nil { + return fmt.Errorf("azureSecretValueType should be a string, got %s", data) + } + + var err error + *i, err = azureSecretValueTypeString(s) + return err +} + +// MarshalYAML implements a YAML Marshaler for azureSecretValueType +func (i azureSecretValueType) MarshalYAML() (interface{}, error) { + return i.String(), nil +} + +// UnmarshalYAML implements a YAML Unmarshaler for azureSecretValueType +func (i *azureSecretValueType) UnmarshalYAML(unmarshal func(interface{}) error) error { + var s string + if err := unmarshal(&s); err != nil { + return err + } + + var err error + *i, err = azureSecretValueTypeString(s) + return err +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/config/config.go b/flyteplugins/go/tasks/pluginmachinery/secret/config/config.go new file mode 100644 index 0000000000..e6d948a734 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/config/config.go @@ -0,0 +1,301 @@ +package config + +import ( + "os" + "sync" + "time" + + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" +) + +//go:generate enumer --type=SecretManagerType --trimprefix=SecretManagerType -json -yaml +//go:generate enumer --type=KVVersion --trimprefix=KVVersion -json -yaml +//go:generate pflags Config --default-var=DefaultConfig + +const ( + EmbeddedSecretsFileMountInitContainerName = "init-embedded-secret" + DefaultSecretEnvVarPrefix = "_UNION_" +) + +var ( + DefaultConfig = &Config{ + SecretName: "flyte-pod-webhook", + ServiceName: "flyte-pod-webhook", + ServicePort: 443, + MetricsPrefix: "flyte:", + CertDir: "/etc/webhook/certs", + LocalCert: false, + ListenPort: 9443, + SecretManagerType: SecretManagerTypeK8s, + AWSSecretManagerConfig: AWSSecretManagerConfig{ + SidecarImage: "docker.io/amazon/aws-secrets-manager-secret-sidecar:v0.1.4", + Resources: corev1.ResourceRequirements{ + Requests: corev1.ResourceList{ + corev1.ResourceMemory: resource.MustParse("500Mi"), + corev1.ResourceCPU: resource.MustParse("200m"), + }, + Limits: corev1.ResourceList{ + corev1.ResourceMemory: resource.MustParse("500Mi"), + corev1.ResourceCPU: resource.MustParse("200m"), + }, + }, + }, + GCPSecretManagerConfig: GCPSecretManagerConfig{ + SidecarImage: "gcr.io/google.com/cloudsdktool/cloud-sdk:alpine", + Resources: corev1.ResourceRequirements{ + Requests: corev1.ResourceList{ + corev1.ResourceMemory: resource.MustParse("500Mi"), + corev1.ResourceCPU: resource.MustParse("200m"), + }, + Limits: corev1.ResourceList{ + corev1.ResourceMemory: resource.MustParse("500Mi"), + corev1.ResourceCPU: resource.MustParse("200m"), + }, + }, + }, + AzureSecretManagerConfig: AzureSecretManagerConfig{ + SidecarImage: "mcr.microsoft.com/azure-cli:cbl-mariner2.0", + Resources: corev1.ResourceRequirements{ + Requests: corev1.ResourceList{ + corev1.ResourceMemory: resource.MustParse("500Mi"), + corev1.ResourceCPU: resource.MustParse("200m"), + }, + Limits: corev1.ResourceList{ + corev1.ResourceMemory: resource.MustParse("500Mi"), + corev1.ResourceCPU: resource.MustParse("200m"), + }, + }, + }, + VaultSecretManagerConfig: VaultSecretManagerConfig{ + Role: "flyte", + KVVersion: KVVersion2, + }, + EmbeddedSecretManagerConfig: EmbeddedSecretManagerConfig{ + FileMountInitContainer: FileMountInitContainerConfig{ + Image: "busybox:1.28", + Resources: corev1.ResourceRequirements{ + Requests: corev1.ResourceList{ + corev1.ResourceMemory: resource.MustParse("100Mi"), + corev1.ResourceCPU: resource.MustParse("100m"), + }, + Limits: corev1.ResourceList{ + corev1.ResourceMemory: resource.MustParse("100Mi"), + corev1.ResourceCPU: resource.MustParse("100m"), + }, + }, + ContainerName: EmbeddedSecretsFileMountInitContainerName, + }, + ImagePullSecrets: ImagePullSecretsConfig{ + Enabled: false, + }, + }, + ImageBuilderConfig: ImageBuilderConfig{ + ExcludedContainerNames: []string{EmbeddedSecretsFileMountInitContainerName}, + }, + WebhookTimeout: 30, // default timeout for webhook calls in seconds + DisableCreateMutatingWebhookConfig: false, + KubeClientConfig: KubeClientConfig{ + QPS: 100, + Burst: 25, + Timeout: config.Duration{Duration: 30 * time.Second}, + }, + SecretEnvVarPrefix: DefaultSecretEnvVarPrefix, + } + + configSection = config.MustRegisterSection("webhook", DefaultConfig) + initOnce sync.Once +) + +// SecretManagerType defines which secret manager to use. +type SecretManagerType int + +const ( + // SecretManagerTypeGlobal defines a global secret manager that can read env vars and mounted secrets to the webhook + // pod. + SecretManagerTypeGlobal SecretManagerType = iota + + // SecretManagerTypeK8s defines a secret manager webhook that injects K8s volume mounts to mount K8s secrets. + SecretManagerTypeK8s + + // SecretManagerTypeAWS defines a secret manager webhook that injects a side car to pull secrets from AWS Secret + // Manager and mount them to a local file system (in memory) and share that mount with other containers in the pod. + SecretManagerTypeAWS + + // SecretManagerTypeGCP defines a secret manager webhook that injects a side car to pull secrets from GCP Secret + // Manager and mount them to a local file system (in memory) and share that mount with other containers in the pod. + SecretManagerTypeGCP + + // SecretManagerTypeVault defines a secret manager webhook that pulls secrets from Hashicorp Vault. + SecretManagerTypeVault + + // SecretManagerTypeEmbedded defines an embedded secret manager webhook that pulls secrets from the configured secrets manager. + // Without using sidecar. This type directly calls into the secrets manager for the configured provider directly. + // Currently supported only for AWS. + SecretManagerTypeEmbedded + + // SecretManagerTypeAzure defines a secret manager webhook that injects a side car to pull secrets from Azure Key Vault + SecretManagerTypeAzure +) + +// Defines with KV Engine Version to use with VaultSecretManager - https://www.vaultproject.io/docs/secrets/kv#kv-secrets-engine +type KVVersion int + +const ( + // KV v1 refers to unversioned secrets + KVVersion1 KVVersion = iota + // KV v2 refers to versioned secrets + KVVersion2 +) + +type Config struct { + MetricsPrefix string `json:"metrics-prefix" pflag:",An optional prefix for all published metrics."` + CertDir string `json:"certDir" pflag:",Certificate directory to use to write generated certs. Defaults to /etc/webhook/certs/"` + LocalCert bool `json:"localCert" pflag:",write certs locally. Defaults to false"` + ListenPort int `json:"listenPort" pflag:",The port to use to listen to webhook calls. Defaults to 9443"` + ServiceName string `json:"serviceName" pflag:",The name of the webhook service."` + ServicePort int32 `json:"servicePort" pflag:",The port on the service that hosting webhook."` + SecretName string `json:"secretName" pflag:",Secret name to write generated certs to."` + // Deprecated: use SecretManagerTypes instead. + SecretManagerType SecretManagerType `json:"secretManagerType" pflag:"-,Deprecated. Secret manager type to use if secrets are not found in global secrets. Ignored if secretManagerTypes is set."` + SecretManagerTypes []SecretManagerType `json:"secretManagerTypes" pflag:"-,List of secret manager types to use if secrets are not found in global secrets. In order of preference. Overrides secretManagerType if set."` + AWSSecretManagerConfig AWSSecretManagerConfig `json:"awsSecretManager" pflag:",AWS Secret Manager config."` + GCPSecretManagerConfig GCPSecretManagerConfig `json:"gcpSecretManager" pflag:",GCP Secret Manager config."` + VaultSecretManagerConfig VaultSecretManagerConfig `json:"vaultSecretManager" pflag:",Vault Secret Manager config."` + EmbeddedSecretManagerConfig EmbeddedSecretManagerConfig `json:"embeddedSecretManagerConfig" pflag:",Embedded Secret Manager config without sidecar and which calls into the supported providers directly."` + AzureSecretManagerConfig AzureSecretManagerConfig `json:"azureSecretManager" pflag:",Azure Secret Manager config."` + + // Ignore PFlag for Image Builder + ImageBuilderConfig ImageBuilderConfig `json:"imageBuilderConfig,omitempty" pflag:"-,"` + WebhookTimeout int32 `json:"webhookTimeout" pflag:",Timeout for webhook calls in seconds. Defaults to 30 seconds."` + DisableCreateMutatingWebhookConfig bool `json:"disableCreateMutatingWebhookConfig"` + KubeClientConfig KubeClientConfig `json:"kubeClientConfig" pflag:",Configuration to control the Kubernetes client used by the webhook"` + SecretEnvVarPrefix string `json:"secretEnvVarPrefix" pflag:",The prefix for secret environment variables. Used by K8s, Global, and Embedded secret managers. Defaults to _UNION_"` +} + +//go:generate enumer --type=EmbeddedSecretManagerType -json -yaml -trimprefix=EmbeddedSecretManagerType +type EmbeddedSecretManagerType uint8 + +const ( + EmbeddedSecretManagerTypeAWS EmbeddedSecretManagerType = iota + EmbeddedSecretManagerTypeGCP + EmbeddedSecretManagerTypeAzure + EmbeddedSecretManagerTypeK8s +) + +type EmbeddedSecretManagerConfig struct { + Type EmbeddedSecretManagerType `json:"type" pflags:"-,Type of embedded secret manager to initialize"` + AWSConfig AWSConfig `json:"awsConfig" pflag:",Config for AWS settings"` + GCPConfig GCPConfig `json:"gcpConfig" pflag:",Config for GCP settings"` + AzureConfig AzureConfig `json:"azureConfig" pflag:",Config for Azure settings"` + K8sConfig K8sConfig `json:"k8sConfig" pflag:",Config for K8s settings"` + FileMountInitContainer FileMountInitContainerConfig `json:"fileMountInitContainer" pflag:",Init container configuration to use for mounting secrets as files."` + ImagePullSecrets ImagePullSecretsConfig `json:"imagePullSecrets" pflag:",Whether to enable image pull secrets for the webhook pod."` +} + +type AWSConfig struct { + Region string `json:"region" pflag:",AWS region"` +} + +type GCPConfig struct { + Project string `json:"project" pflag:",GCP project to be used for secret manager"` +} + +type AzureConfig struct { + VaultURI string `json:"vaultURI" pflag:",Azure Vault URI"` +} + +type K8sConfig struct { + Namespace string `json:"namespace" pflag:",K8s namespace to be used for storing union secrets"` + KubeClientConfig KubeClientConfig `json:"kubeClientConfig" pflag:",Configuration to control the Kubernetes client used by the secret fetcher for K8s embedded secret manager. Falls back to webhook.kubeClientConfig if not set."` +} + +type FileMountInitContainerConfig struct { + Image string `json:"image" pflag:",Specifies init container image to use for mounting secrets as files."` + Resources corev1.ResourceRequirements `json:"resources" pflag:"-,Specifies resource requirements for the init container."` + ContainerName string `json:"containerName" pflag:",Specifies the name of the init container that mounts secrets as files."` +} + +func (c Config) ExpandCertDir() string { + return os.ExpandEnv(c.CertDir) +} + +type AWSSecretManagerConfig struct { + SidecarImage string `json:"sidecarImage" pflag:",Specifies the sidecar docker image to use"` + Resources corev1.ResourceRequirements `json:"resources" pflag:"-,Specifies resource requirements for the init container."` +} + +type GCPSecretManagerConfig struct { + SidecarImage string `json:"sidecarImage" pflag:",Specifies the sidecar docker image to use"` + Resources corev1.ResourceRequirements `json:"resources" pflag:"-,Specifies resource requirements for the init container."` +} + +type AzureSecretManagerConfig struct { + SidecarImage string `json:"sidecarImage" pflag:",Specifies the sidecar docker image to use"` + Resources corev1.ResourceRequirements `json:"resources" pflag:"-,Specifies resource requirements for the init container."` +} + +type VaultSecretManagerConfig struct { + Role string `json:"role" pflag:",Specifies the vault role to use"` + KVVersion KVVersion `json:"kvVersion" pflag:"-,DEPRECATED! Use the GroupVersion field of the Secret request instead. The KV Engine Version. Defaults to 2. Use 1 for unversioned secrets. Refer to - https://www.vaultproject.io/docs/secrets/kv#kv-secrets-engine."` + Annotations map[string]string `json:"annotations" pflag:"-,Annotation to be added to user task pod. The annotation can also be used to override default annotations added by Flyte. Useful to customize Vault integration (https://developer.hashicorp.com/vault/docs/platform/k8s/injector/annotations)"` +} + +type HostnameReplacement struct { + Existing string `json:"existing" pflag:",The existing hostname to replace"` + Replacement string `json:"replacement" pflag:",The replacement hostname"` + DisableVerification bool `json:"disableVerification" pflag:",Allow disabling URI verification for development environments"` +} + +type ImageBuilderConfig struct { + Enabled bool `json:"enabled"` + HostnameReplacement HostnameReplacement `json:"hostnameReplacement"` + LabelSelector metav1.LabelSelector `json:"labelSelector"` + ExcludedContainerNames []string `json:"excludedContainerNames"` + ExcludedImagePrefixes []string `json:"excludedImagePrefixes"` +} + +type ImagePullSecretsConfig struct { + Enabled bool `json:"enabled" pflag:",Whether to enable image pull secrets for the webhook pod."` +} + +// KubeClientConfig contains the configuration used by the webhook to configure its internal Kubernetes Client. +type KubeClientConfig struct { + // QPS indicates the maximum QPS to the master from this client. + QPS int32 `json:"qps" pflag:",Max QPS to the master for requests to KubeAPI. 0 defaults to 5."` + // Maximum burst for throttle. + Burst int `json:"burst" pflag:",Max burst rate for throttle. 0 defaults to 10"` + // The maximum length of time to wait before giving up on a server request. + Timeout config.Duration `json:"timeout" pflag:",Max duration allowed for every request to KubeAPI before giving up. 0 implies no timeout."` +} + +// ResolveKubeClientConfigs initializes KubeClientConfig with fallback values +// For K8s secretfetcher: if k8sConfig.kubeClientConfig is not set, use webhook-level kubeClientConfig as fallback +func (c *Config) ResolveKubeClientConfigs() { + // Resolve K8s secret fetcher config with fallback to webhook-level config + if c.EmbeddedSecretManagerConfig.K8sConfig.KubeClientConfig.QPS == 0 { + c.EmbeddedSecretManagerConfig.K8sConfig.KubeClientConfig.QPS = c.KubeClientConfig.QPS + } + if c.EmbeddedSecretManagerConfig.K8sConfig.KubeClientConfig.Burst == 0 { + c.EmbeddedSecretManagerConfig.K8sConfig.KubeClientConfig.Burst = c.KubeClientConfig.Burst + } + if c.EmbeddedSecretManagerConfig.K8sConfig.KubeClientConfig.Timeout.Duration == 0 { + c.EmbeddedSecretManagerConfig.K8sConfig.KubeClientConfig.Timeout = c.KubeClientConfig.Timeout + } +} + +func GetConfig() *Config { + cfg := configSection.GetConfig().(*Config) + // Ensure initialization happens exactly once, thread-safe + initOnce.Do(func() { + cfg.ResolveKubeClientConfigs() + }) + return cfg +} + +func MustRegisterSubsection(key config.SectionKey, section config.Config) config.Section { + return configSection.MustRegisterSection(key, section) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/config/config_flags.go b/flyteplugins/go/tasks/pluginmachinery/secret/config/config_flags.go new file mode 100755 index 0000000000..e49a9c7785 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/config/config_flags.go @@ -0,0 +1,82 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package config + +import ( + "encoding/json" + "reflect" + + "fmt" + + "github.com/spf13/pflag" +) + +// If v is a pointer, it will get its element value or the zero value of the element type. +// If v is not a pointer, it will return it as is. +func (Config) elemValueOrNil(v interface{}) interface{} { + if t := reflect.TypeOf(v); t.Kind() == reflect.Ptr { + if reflect.ValueOf(v).IsNil() { + return reflect.Zero(t.Elem()).Interface() + } else { + return reflect.ValueOf(v).Interface() + } + } else if v == nil { + return reflect.Zero(t).Interface() + } + + return v +} + +func (Config) mustJsonMarshal(v interface{}) string { + raw, err := json.Marshal(v) + if err != nil { + panic(err) + } + + return string(raw) +} + +func (Config) mustMarshalJSON(v json.Marshaler) string { + raw, err := v.MarshalJSON() + if err != nil { + panic(err) + } + + return string(raw) +} + +// GetPFlagSet will return strongly types pflags for all fields in Config and its nested types. The format of the +// flags is json-name.json-sub-name... etc. +func (cfg Config) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("Config", pflag.ExitOnError) + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "metrics-prefix"), DefaultConfig.MetricsPrefix, "An optional prefix for all published metrics.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "certDir"), DefaultConfig.CertDir, "Certificate directory to use to write generated certs. Defaults to /etc/webhook/certs/") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "localCert"), DefaultConfig.LocalCert, "write certs locally. Defaults to false") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "listenPort"), DefaultConfig.ListenPort, "The port to use to listen to webhook calls. Defaults to 9443") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "serviceName"), DefaultConfig.ServiceName, "The name of the webhook service.") + cmdFlags.Int32(fmt.Sprintf("%v%v", prefix, "servicePort"), DefaultConfig.ServicePort, "The port on the service that hosting webhook.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "secretName"), DefaultConfig.SecretName, "Secret name to write generated certs to.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "awsSecretManager.sidecarImage"), DefaultConfig.AWSSecretManagerConfig.SidecarImage, "Specifies the sidecar docker image to use") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "gcpSecretManager.sidecarImage"), DefaultConfig.GCPSecretManagerConfig.SidecarImage, "Specifies the sidecar docker image to use") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "vaultSecretManager.role"), DefaultConfig.VaultSecretManagerConfig.Role, "Specifies the vault role to use") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "embeddedSecretManagerConfig.type"), DefaultConfig.EmbeddedSecretManagerConfig.Type.String(), "") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "embeddedSecretManagerConfig.awsConfig.region"), DefaultConfig.EmbeddedSecretManagerConfig.AWSConfig.Region, "AWS region") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "embeddedSecretManagerConfig.gcpConfig.project"), DefaultConfig.EmbeddedSecretManagerConfig.GCPConfig.Project, "GCP project to be used for secret manager") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "embeddedSecretManagerConfig.azureConfig.vaultURI"), DefaultConfig.EmbeddedSecretManagerConfig.AzureConfig.VaultURI, "Azure Vault URI") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "embeddedSecretManagerConfig.k8sConfig.namespace"), DefaultConfig.EmbeddedSecretManagerConfig.K8sConfig.Namespace, "K8s namespace to be used for storing union secrets") + cmdFlags.Int32(fmt.Sprintf("%v%v", prefix, "embeddedSecretManagerConfig.k8sConfig.kubeClientConfig.qps"), DefaultConfig.EmbeddedSecretManagerConfig.K8sConfig.KubeClientConfig.QPS, "Max QPS to the master for requests to KubeAPI. 0 defaults to 5.") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "embeddedSecretManagerConfig.k8sConfig.kubeClientConfig.burst"), DefaultConfig.EmbeddedSecretManagerConfig.K8sConfig.KubeClientConfig.Burst, "Max burst rate for throttle. 0 defaults to 10") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "embeddedSecretManagerConfig.k8sConfig.kubeClientConfig.timeout"), DefaultConfig.EmbeddedSecretManagerConfig.K8sConfig.KubeClientConfig.Timeout.String(), "Max duration allowed for every request to KubeAPI before giving up. 0 implies no timeout.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "embeddedSecretManagerConfig.fileMountInitContainer.image"), DefaultConfig.EmbeddedSecretManagerConfig.FileMountInitContainer.Image, "Specifies init container image to use for mounting secrets as files.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "embeddedSecretManagerConfig.fileMountInitContainer.containerName"), DefaultConfig.EmbeddedSecretManagerConfig.FileMountInitContainer.ContainerName, "Specifies the name of the init container that mounts secrets as files.") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "embeddedSecretManagerConfig.imagePullSecrets.enabled"), DefaultConfig.EmbeddedSecretManagerConfig.ImagePullSecrets.Enabled, "Whether to enable image pull secrets for the webhook pod.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "azureSecretManager.sidecarImage"), DefaultConfig.AzureSecretManagerConfig.SidecarImage, "Specifies the sidecar docker image to use") + cmdFlags.Int32(fmt.Sprintf("%v%v", prefix, "webhookTimeout"), DefaultConfig.WebhookTimeout, "Timeout for webhook calls in seconds. Defaults to 30 seconds.") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "disableCreateMutatingWebhookConfig"), DefaultConfig.DisableCreateMutatingWebhookConfig, "") + cmdFlags.Int32(fmt.Sprintf("%v%v", prefix, "kubeClientConfig.qps"), DefaultConfig.KubeClientConfig.QPS, "Max QPS to the master for requests to KubeAPI. 0 defaults to 5.") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "kubeClientConfig.burst"), DefaultConfig.KubeClientConfig.Burst, "Max burst rate for throttle. 0 defaults to 10") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "kubeClientConfig.timeout"), DefaultConfig.KubeClientConfig.Timeout.String(), "Max duration allowed for every request to KubeAPI before giving up. 0 implies no timeout.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "secretEnvVarPrefix"), DefaultConfig.SecretEnvVarPrefix, "The prefix for secret environment variables. Used by K8s, Global, and Embedded secret managers. Defaults to _UNION_") + return cmdFlags +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/config/config_flags_test.go b/flyteplugins/go/tasks/pluginmachinery/secret/config/config_flags_test.go new file mode 100755 index 0000000000..b2caeab63c --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/config/config_flags_test.go @@ -0,0 +1,494 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package config + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "testing" + + "github.com/mitchellh/mapstructure" + "github.com/stretchr/testify/assert" +) + +var dereferencableKindsConfig = map[reflect.Kind]struct{}{ + reflect.Array: {}, reflect.Chan: {}, reflect.Map: {}, reflect.Ptr: {}, reflect.Slice: {}, +} + +// Checks if t is a kind that can be dereferenced to get its underlying type. +func canGetElementConfig(t reflect.Kind) bool { + _, exists := dereferencableKindsConfig[t] + return exists +} + +// This decoder hook tests types for json unmarshaling capability. If implemented, it uses json unmarshal to build the +// object. Otherwise, it'll just pass on the original data. +func jsonUnmarshalerHookConfig(_, to reflect.Type, data interface{}) (interface{}, error) { + unmarshalerType := reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + if to.Implements(unmarshalerType) || reflect.PtrTo(to).Implements(unmarshalerType) || + (canGetElementConfig(to.Kind()) && to.Elem().Implements(unmarshalerType)) { + + raw, err := json.Marshal(data) + if err != nil { + fmt.Printf("Failed to marshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + res := reflect.New(to).Interface() + err = json.Unmarshal(raw, &res) + if err != nil { + fmt.Printf("Failed to umarshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + return res, nil + } + + return data, nil +} + +func decode_Config(input, result interface{}) error { + config := &mapstructure.DecoderConfig{ + TagName: "json", + WeaklyTypedInput: true, + Result: result, + DecodeHook: mapstructure.ComposeDecodeHookFunc( + mapstructure.StringToTimeDurationHookFunc(), + mapstructure.StringToSliceHookFunc(","), + jsonUnmarshalerHookConfig, + ), + } + + decoder, err := mapstructure.NewDecoder(config) + if err != nil { + return err + } + + return decoder.Decode(input) +} + +func join_Config(arr interface{}, sep string) string { + listValue := reflect.ValueOf(arr) + strs := make([]string, 0, listValue.Len()) + for i := 0; i < listValue.Len(); i++ { + strs = append(strs, fmt.Sprintf("%v", listValue.Index(i))) + } + + return strings.Join(strs, sep) +} + +func testDecodeJson_Config(t *testing.T, val, result interface{}) { + assert.NoError(t, decode_Config(val, result)) +} + +func testDecodeRaw_Config(t *testing.T, vStringSlice, result interface{}) { + assert.NoError(t, decode_Config(vStringSlice, result)) +} + +func TestConfig_GetPFlagSet(t *testing.T) { + val := Config{} + cmdFlags := val.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) +} + +func TestConfig_SetFlags(t *testing.T) { + actual := Config{} + cmdFlags := actual.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) + + t.Run("Test_metrics-prefix", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("metrics-prefix", testValue) + if vString, err := cmdFlags.GetString("metrics-prefix"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.MetricsPrefix) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_certDir", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("certDir", testValue) + if vString, err := cmdFlags.GetString("certDir"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.CertDir) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_localCert", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("localCert", testValue) + if vBool, err := cmdFlags.GetBool("localCert"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.LocalCert) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_listenPort", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("listenPort", testValue) + if vInt, err := cmdFlags.GetInt("listenPort"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vInt), &actual.ListenPort) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_serviceName", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("serviceName", testValue) + if vString, err := cmdFlags.GetString("serviceName"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.ServiceName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_servicePort", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("servicePort", testValue) + if vInt32, err := cmdFlags.GetInt32("servicePort"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vInt32), &actual.ServicePort) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_secretName", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("secretName", testValue) + if vString, err := cmdFlags.GetString("secretName"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.SecretName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_awsSecretManager.sidecarImage", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("awsSecretManager.sidecarImage", testValue) + if vString, err := cmdFlags.GetString("awsSecretManager.sidecarImage"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.AWSSecretManagerConfig.SidecarImage) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_gcpSecretManager.sidecarImage", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("gcpSecretManager.sidecarImage", testValue) + if vString, err := cmdFlags.GetString("gcpSecretManager.sidecarImage"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.GCPSecretManagerConfig.SidecarImage) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_vaultSecretManager.role", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("vaultSecretManager.role", testValue) + if vString, err := cmdFlags.GetString("vaultSecretManager.role"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.VaultSecretManagerConfig.Role) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_embeddedSecretManagerConfig.type", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("embeddedSecretManagerConfig.type", testValue) + if vString, err := cmdFlags.GetString("embeddedSecretManagerConfig.type"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.EmbeddedSecretManagerConfig.Type) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_embeddedSecretManagerConfig.awsConfig.region", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("embeddedSecretManagerConfig.awsConfig.region", testValue) + if vString, err := cmdFlags.GetString("embeddedSecretManagerConfig.awsConfig.region"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.EmbeddedSecretManagerConfig.AWSConfig.Region) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_embeddedSecretManagerConfig.gcpConfig.project", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("embeddedSecretManagerConfig.gcpConfig.project", testValue) + if vString, err := cmdFlags.GetString("embeddedSecretManagerConfig.gcpConfig.project"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.EmbeddedSecretManagerConfig.GCPConfig.Project) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_embeddedSecretManagerConfig.azureConfig.vaultURI", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("embeddedSecretManagerConfig.azureConfig.vaultURI", testValue) + if vString, err := cmdFlags.GetString("embeddedSecretManagerConfig.azureConfig.vaultURI"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.EmbeddedSecretManagerConfig.AzureConfig.VaultURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_embeddedSecretManagerConfig.k8sConfig.namespace", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("embeddedSecretManagerConfig.k8sConfig.namespace", testValue) + if vString, err := cmdFlags.GetString("embeddedSecretManagerConfig.k8sConfig.namespace"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.EmbeddedSecretManagerConfig.K8sConfig.Namespace) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_embeddedSecretManagerConfig.k8sConfig.kubeClientConfig.qps", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("embeddedSecretManagerConfig.k8sConfig.kubeClientConfig.qps", testValue) + if vInt32, err := cmdFlags.GetInt32("embeddedSecretManagerConfig.k8sConfig.kubeClientConfig.qps"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vInt32), &actual.EmbeddedSecretManagerConfig.K8sConfig.KubeClientConfig.QPS) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_embeddedSecretManagerConfig.k8sConfig.kubeClientConfig.burst", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("embeddedSecretManagerConfig.k8sConfig.kubeClientConfig.burst", testValue) + if vInt, err := cmdFlags.GetInt("embeddedSecretManagerConfig.k8sConfig.kubeClientConfig.burst"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vInt), &actual.EmbeddedSecretManagerConfig.K8sConfig.KubeClientConfig.Burst) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_embeddedSecretManagerConfig.k8sConfig.kubeClientConfig.timeout", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := DefaultConfig.EmbeddedSecretManagerConfig.K8sConfig.KubeClientConfig.Timeout.String() + + cmdFlags.Set("embeddedSecretManagerConfig.k8sConfig.kubeClientConfig.timeout", testValue) + if vString, err := cmdFlags.GetString("embeddedSecretManagerConfig.k8sConfig.kubeClientConfig.timeout"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.EmbeddedSecretManagerConfig.K8sConfig.KubeClientConfig.Timeout) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_embeddedSecretManagerConfig.fileMountInitContainer.image", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("embeddedSecretManagerConfig.fileMountInitContainer.image", testValue) + if vString, err := cmdFlags.GetString("embeddedSecretManagerConfig.fileMountInitContainer.image"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.EmbeddedSecretManagerConfig.FileMountInitContainer.Image) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_embeddedSecretManagerConfig.fileMountInitContainer.containerName", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("embeddedSecretManagerConfig.fileMountInitContainer.containerName", testValue) + if vString, err := cmdFlags.GetString("embeddedSecretManagerConfig.fileMountInitContainer.containerName"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.EmbeddedSecretManagerConfig.FileMountInitContainer.ContainerName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_embeddedSecretManagerConfig.imagePullSecrets.enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("embeddedSecretManagerConfig.imagePullSecrets.enabled", testValue) + if vBool, err := cmdFlags.GetBool("embeddedSecretManagerConfig.imagePullSecrets.enabled"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.EmbeddedSecretManagerConfig.ImagePullSecrets.Enabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_azureSecretManager.sidecarImage", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("azureSecretManager.sidecarImage", testValue) + if vString, err := cmdFlags.GetString("azureSecretManager.sidecarImage"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.AzureSecretManagerConfig.SidecarImage) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_webhookTimeout", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("webhookTimeout", testValue) + if vInt32, err := cmdFlags.GetInt32("webhookTimeout"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vInt32), &actual.WebhookTimeout) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_disableCreateMutatingWebhookConfig", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("disableCreateMutatingWebhookConfig", testValue) + if vBool, err := cmdFlags.GetBool("disableCreateMutatingWebhookConfig"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.DisableCreateMutatingWebhookConfig) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_kubeClientConfig.qps", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("kubeClientConfig.qps", testValue) + if vInt32, err := cmdFlags.GetInt32("kubeClientConfig.qps"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vInt32), &actual.KubeClientConfig.QPS) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_kubeClientConfig.burst", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("kubeClientConfig.burst", testValue) + if vInt, err := cmdFlags.GetInt("kubeClientConfig.burst"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vInt), &actual.KubeClientConfig.Burst) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_kubeClientConfig.timeout", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := DefaultConfig.KubeClientConfig.Timeout.String() + + cmdFlags.Set("kubeClientConfig.timeout", testValue) + if vString, err := cmdFlags.GetString("kubeClientConfig.timeout"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.KubeClientConfig.Timeout) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_secretEnvVarPrefix", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("secretEnvVarPrefix", testValue) + if vString, err := cmdFlags.GetString("secretEnvVarPrefix"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.SecretEnvVarPrefix) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/config/config_test.go b/flyteplugins/go/tasks/pluginmachinery/secret/config/config_test.go new file mode 100644 index 0000000000..247f9a4e95 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/config/config_test.go @@ -0,0 +1,103 @@ +package config + +import ( + "encoding/json" + "testing" + + "github.com/stretchr/testify/assert" +) + +// Ensure HostnameReplacements resolves to non-nil empty list. +func TestConfig_DefaultImageBuilder(t *testing.T) { + assert.Empty(t, DefaultConfig.ImageBuilderConfig.HostnameReplacement) +} + +func TestConfig_LoadSimpleJSON(t *testing.T) { + expectedJSON := `{ + "metrics-prefix": "test-prefix", + "certDir": "/test/cert/dir", + "localCert": true, + "listenPort": 8080, + "serviceName": "test-service", + "servicePort": 8081, + "secretName": "test-secret", + "secretManagerType": "K8s" + }` + + var config Config + err := json.Unmarshal([]byte(expectedJSON), &config) + assert.Nil(t, err) + + assert.Empty(t, config.ImageBuilderConfig) +} + +func TestConfig_ImageBuilderConfig(t *testing.T) { + + t.Run("With verification enabled", func(t *testing.T) { + expectedJSON := `{ + "metrics-prefix": "test-prefix", + "certDir": "/test/cert/dir", + "localCert": true, + "listenPort": 8080, + "serviceName": "test-service", + "servicePort": 8081, + "secretName": "test-secret", + "secretManagerType": "K8s", + "imageBuilderConfig": { + "hostnameReplacement": { + "existing": "test.existing.hostname", + "replacement": "test.replacement.hostname" + }, + "labelSelector": { + "matchLabels": { + "test-key": "test-value" + } + } + } + }` + + var config Config + err := json.Unmarshal([]byte(expectedJSON), &config) + assert.Nil(t, err) + + assert.Equal(t, "test.existing.hostname", config.ImageBuilderConfig.HostnameReplacement.Existing) + assert.Equal(t, "test.replacement.hostname", config.ImageBuilderConfig.HostnameReplacement.Replacement) + assert.Equal(t, false, config.ImageBuilderConfig.HostnameReplacement.DisableVerification) + assert.Equal(t, "test-value", config.ImageBuilderConfig.LabelSelector.MatchLabels["test-key"]) + }) + + t.Run("With verification disabled", func(t *testing.T) { + expectedJSON := `{ + "metrics-prefix": "test-prefix", + "certDir": "/test/cert/dir", + "localCert": true, + "listenPort": 8080, + "serviceName": "test-service", + "servicePort": 8081, + "secretName": "test-secret", + "secretManagerType": "K8s", + "imageBuilderConfig": { + "hostnameReplacement": { + "existing": "test.existing.hostname", + "replacement": "test.replacement.hostname", + "disableVerification": true + }, + "labelSelector": { + "matchLabels": { + "test-key": "test-value" + } + } + } + }` + + var config Config + err := json.Unmarshal([]byte(expectedJSON), &config) + assert.Nil(t, err) + + assert.Equal(t, "test.existing.hostname", config.ImageBuilderConfig.HostnameReplacement.Existing) + assert.Equal(t, "test.replacement.hostname", config.ImageBuilderConfig.HostnameReplacement.Replacement) + assert.Equal(t, true, config.ImageBuilderConfig.HostnameReplacement.DisableVerification) + assert.Equal(t, "test-value", config.ImageBuilderConfig.LabelSelector.MatchLabels["test-key"]) + }) + +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/config/embeddedsecretmanagertype_enumer.go b/flyteplugins/go/tasks/pluginmachinery/secret/config/embeddedsecretmanagertype_enumer.go new file mode 100644 index 0000000000..229e6366b3 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/config/embeddedsecretmanagertype_enumer.go @@ -0,0 +1,86 @@ +// Code generated by "enumer --type=EmbeddedSecretManagerType -json -yaml -trimprefix=EmbeddedSecretManagerType"; DO NOT EDIT. + +package config + +import ( + "encoding/json" + "fmt" +) + +const _EmbeddedSecretManagerTypeName = "AWSGCPAzureK8s" + +var _EmbeddedSecretManagerTypeIndex = [...]uint8{0, 3, 6, 11, 14} + +func (i EmbeddedSecretManagerType) String() string { + if i >= EmbeddedSecretManagerType(len(_EmbeddedSecretManagerTypeIndex)-1) { + return fmt.Sprintf("EmbeddedSecretManagerType(%d)", i) + } + return _EmbeddedSecretManagerTypeName[_EmbeddedSecretManagerTypeIndex[i]:_EmbeddedSecretManagerTypeIndex[i+1]] +} + +var _EmbeddedSecretManagerTypeValues = []EmbeddedSecretManagerType{0, 1, 2, 3} + +var _EmbeddedSecretManagerTypeNameToValueMap = map[string]EmbeddedSecretManagerType{ + _EmbeddedSecretManagerTypeName[0:3]: 0, + _EmbeddedSecretManagerTypeName[3:6]: 1, + _EmbeddedSecretManagerTypeName[6:11]: 2, + _EmbeddedSecretManagerTypeName[11:14]: 3, +} + +// EmbeddedSecretManagerTypeString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func EmbeddedSecretManagerTypeString(s string) (EmbeddedSecretManagerType, error) { + if val, ok := _EmbeddedSecretManagerTypeNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to EmbeddedSecretManagerType values", s) +} + +// EmbeddedSecretManagerTypeValues returns all values of the enum +func EmbeddedSecretManagerTypeValues() []EmbeddedSecretManagerType { + return _EmbeddedSecretManagerTypeValues +} + +// IsAEmbeddedSecretManagerType returns "true" if the value is listed in the enum definition. "false" otherwise +func (i EmbeddedSecretManagerType) IsAEmbeddedSecretManagerType() bool { + for _, v := range _EmbeddedSecretManagerTypeValues { + if i == v { + return true + } + } + return false +} + +// MarshalJSON implements the json.Marshaler interface for EmbeddedSecretManagerType +func (i EmbeddedSecretManagerType) MarshalJSON() ([]byte, error) { + return json.Marshal(i.String()) +} + +// UnmarshalJSON implements the json.Unmarshaler interface for EmbeddedSecretManagerType +func (i *EmbeddedSecretManagerType) UnmarshalJSON(data []byte) error { + var s string + if err := json.Unmarshal(data, &s); err != nil { + return fmt.Errorf("EmbeddedSecretManagerType should be a string, got %s", data) + } + + var err error + *i, err = EmbeddedSecretManagerTypeString(s) + return err +} + +// MarshalYAML implements a YAML Marshaler for EmbeddedSecretManagerType +func (i EmbeddedSecretManagerType) MarshalYAML() (interface{}, error) { + return i.String(), nil +} + +// UnmarshalYAML implements a YAML Unmarshaler for EmbeddedSecretManagerType +func (i *EmbeddedSecretManagerType) UnmarshalYAML(unmarshal func(interface{}) error) error { + var s string + if err := unmarshal(&s); err != nil { + return err + } + + var err error + *i, err = EmbeddedSecretManagerTypeString(s) + return err +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/config/kvversion_enumer.go b/flyteplugins/go/tasks/pluginmachinery/secret/config/kvversion_enumer.go new file mode 100644 index 0000000000..7c60f36507 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/config/kvversion_enumer.go @@ -0,0 +1,84 @@ +// Code generated by "enumer --type=KVVersion --trimprefix=KVVersion -json -yaml"; DO NOT EDIT. + +package config + +import ( + "encoding/json" + "fmt" +) + +const _KVVersionName = "12" + +var _KVVersionIndex = [...]uint8{0, 1, 2} + +func (i KVVersion) String() string { + if i < 0 || i >= KVVersion(len(_KVVersionIndex)-1) { + return fmt.Sprintf("KVVersion(%d)", i) + } + return _KVVersionName[_KVVersionIndex[i]:_KVVersionIndex[i+1]] +} + +var _KVVersionValues = []KVVersion{0, 1} + +var _KVVersionNameToValueMap = map[string]KVVersion{ + _KVVersionName[0:1]: 0, + _KVVersionName[1:2]: 1, +} + +// KVVersionString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func KVVersionString(s string) (KVVersion, error) { + if val, ok := _KVVersionNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to KVVersion values", s) +} + +// KVVersionValues returns all values of the enum +func KVVersionValues() []KVVersion { + return _KVVersionValues +} + +// IsAKVVersion returns "true" if the value is listed in the enum definition. "false" otherwise +func (i KVVersion) IsAKVVersion() bool { + for _, v := range _KVVersionValues { + if i == v { + return true + } + } + return false +} + +// MarshalJSON implements the json.Marshaler interface for KVVersion +func (i KVVersion) MarshalJSON() ([]byte, error) { + return json.Marshal(i.String()) +} + +// UnmarshalJSON implements the json.Unmarshaler interface for KVVersion +func (i *KVVersion) UnmarshalJSON(data []byte) error { + var s string + if err := json.Unmarshal(data, &s); err != nil { + return fmt.Errorf("KVVersion should be a string, got %s", data) + } + + var err error + *i, err = KVVersionString(s) + return err +} + +// MarshalYAML implements a YAML Marshaler for KVVersion +func (i KVVersion) MarshalYAML() (interface{}, error) { + return i.String(), nil +} + +// UnmarshalYAML implements a YAML Unmarshaler for KVVersion +func (i *KVVersion) UnmarshalYAML(unmarshal func(interface{}) error) error { + var s string + if err := unmarshal(&s); err != nil { + return err + } + + var err error + *i, err = KVVersionString(s) + return err +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/config/secretmanagertype_enumer.go b/flyteplugins/go/tasks/pluginmachinery/secret/config/secretmanagertype_enumer.go new file mode 100644 index 0000000000..f0e8773a49 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/config/secretmanagertype_enumer.go @@ -0,0 +1,89 @@ +// Code generated by "enumer --type=SecretManagerType --trimprefix=SecretManagerType -json -yaml"; DO NOT EDIT. + +package config + +import ( + "encoding/json" + "fmt" +) + +const _SecretManagerTypeName = "GlobalK8sAWSGCPVaultEmbeddedAzure" + +var _SecretManagerTypeIndex = [...]uint8{0, 6, 9, 12, 15, 20, 28, 33} + +func (i SecretManagerType) String() string { + if i < 0 || i >= SecretManagerType(len(_SecretManagerTypeIndex)-1) { + return fmt.Sprintf("SecretManagerType(%d)", i) + } + return _SecretManagerTypeName[_SecretManagerTypeIndex[i]:_SecretManagerTypeIndex[i+1]] +} + +var _SecretManagerTypeValues = []SecretManagerType{0, 1, 2, 3, 4, 5, 6} + +var _SecretManagerTypeNameToValueMap = map[string]SecretManagerType{ + _SecretManagerTypeName[0:6]: 0, + _SecretManagerTypeName[6:9]: 1, + _SecretManagerTypeName[9:12]: 2, + _SecretManagerTypeName[12:15]: 3, + _SecretManagerTypeName[15:20]: 4, + _SecretManagerTypeName[20:28]: 5, + _SecretManagerTypeName[28:33]: 6, +} + +// SecretManagerTypeString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func SecretManagerTypeString(s string) (SecretManagerType, error) { + if val, ok := _SecretManagerTypeNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to SecretManagerType values", s) +} + +// SecretManagerTypeValues returns all values of the enum +func SecretManagerTypeValues() []SecretManagerType { + return _SecretManagerTypeValues +} + +// IsASecretManagerType returns "true" if the value is listed in the enum definition. "false" otherwise +func (i SecretManagerType) IsASecretManagerType() bool { + for _, v := range _SecretManagerTypeValues { + if i == v { + return true + } + } + return false +} + +// MarshalJSON implements the json.Marshaler interface for SecretManagerType +func (i SecretManagerType) MarshalJSON() ([]byte, error) { + return json.Marshal(i.String()) +} + +// UnmarshalJSON implements the json.Unmarshaler interface for SecretManagerType +func (i *SecretManagerType) UnmarshalJSON(data []byte) error { + var s string + if err := json.Unmarshal(data, &s); err != nil { + return fmt.Errorf("SecretManagerType should be a string, got %s", data) + } + + var err error + *i, err = SecretManagerTypeString(s) + return err +} + +// MarshalYAML implements a YAML Marshaler for SecretManagerType +func (i SecretManagerType) MarshalYAML() (interface{}, error) { + return i.String(), nil +} + +// UnmarshalYAML implements a YAML Unmarshaler for SecretManagerType +func (i *SecretManagerType) UnmarshalYAML(unmarshal func(interface{}) error) error { + var s string + if err := unmarshal(&s); err != nil { + return err + } + + var err error + *i, err = SecretManagerTypeString(s) + return err +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/embedded_secret_manager.go b/flyteplugins/go/tasks/pluginmachinery/secret/embedded_secret_manager.go new file mode 100644 index 0000000000..f6bb4e766a --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/embedded_secret_manager.go @@ -0,0 +1,499 @@ +package secret + +import ( + "context" + "encoding/base64" + "fmt" + "path/filepath" + "slices" + "strings" + "unicode/utf8" + + goCache "github.com/eko/gocache/lib/v4/cache" + corev1 "k8s.io/api/core/v1" + k8sError "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + "sigs.k8s.io/controller-runtime/pkg/client" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + stdlibErrors "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const ( + // Static name of the volume used for mounting secrets with file mount requirement. + EmbeddedSecretsFileMountVolumeName = "embedded-secret-vol" // #nosec G101 + EmbeddedSecretsFileMountPath = "/etc/flyte/secrets" // #nosec G101 + + // Name of the environment variable in the init container used for mounting secrets as files. + // This environment variable is used to pass secret names and values to the init container. + // The init container then reads its value and writes secrets to files. + // Format of this environment variable's value: + // secret_name1=base64_encoded_secret_value1 + // secret_name2=base64_encoded_secret_value2 + // ... + EmbeddedSecretsFileMountInitContainerEnvVariableName = "SECRETS" // #nosec G101 + + ProjectLabel = "project" + DomainLabel = "domain" + OrganizationLabel = "organization" + EmptySecretScope = "" + + // All of the namespace, group and key cannot contain '/' so it is safe to use '/' as a delimiter. + NamespaceGroupKeyDelimiter = "/" + rawK8sSecretsStorageFormat = valueFormatter + NamespaceGroupKeyDelimiter + valueFormatter + NamespaceGroupKeyDelimiter + valueFormatter + + SecretNotFoundErrorFormat = "secret %v not found in the secret manager" // #nosec G101 + SecretReadFailureErrorFormat = "secret %v failed to be read from secret manager" // #nosec G101 + SecretNilErrorFormat = "secret %v read as empty from the secret manager" // #nosec G101 + SecretRequirementsErrorFormat = "secret read requirements not met due to empty %v field in the pod labels" // #nosec G101 + SecretSecretNotFoundAcrossAllScopes = "secret not found across all scopes" // #nosec G101 + ErrCodeSecretRequirementsError stdlibErrors.ErrorCode = "SecretRequirementsError" // #nosec G101 + ErrCodeSecretNotFound stdlibErrors.ErrorCode = "SecretNotFound" // #nosec G101 + ErrCodeSecretNotFoundAcrossAllScopes stdlibErrors.ErrorCode = "SecretNotFoundAcrossAllScopes" // #nosec G101 + ErrCodeSecretReadFailure stdlibErrors.ErrorCode = "SecretReadFailure" // #nosec G101 + ErrCodeSecretNil stdlibErrors.ErrorCode = "SecretNil" // #nosec G101 +) + +// AWSSecretManagerInjector allows injecting of secrets from AWS Secret Manager as environment variable. It uses AWS-provided SideCar +// as an init-container to download the secret and save it to a local volume shared with all other containers in the pod. +// It supports multiple secrets to be mounted but that will result into adding an init container for each secret. +// The role/serviceaccount used to run the Pod must have permissions to pull the secret from AWS Secret Manager. +// Otherwise, the Pod will fail with an init-error. +// Files will be mounted on /etc/flyte/secrets// +type EmbeddedSecretManagerInjector struct { + cfg config.EmbeddedSecretManagerConfig + secretFetchers []SecretFetcher + k8sClient client.Client + referenceNamespace string + secretCache goCache.CacheInterface[SecretValue] + parentCfg *config.Config +} + +func (i *EmbeddedSecretManagerInjector) Type() config.SecretManagerType { + return config.SecretManagerTypeEmbedded +} + +func GetSecretID(secretKey string, labels map[string]string) (string, error) { + return EncodeSecretName(labels[OrganizationLabel], labels[DomainLabel], labels[ProjectLabel], secretKey), nil +} + +func validateRequiredFieldsExist(labels map[string]string) error { + if labels[OrganizationLabel] == "" { + return stdlibErrors.Errorf(ErrCodeSecretRequirementsError, fmt.Sprintf(SecretRequirementsErrorFormat, OrganizationLabel)) + } + if labels[ProjectLabel] == "" { + return stdlibErrors.Errorf(ErrCodeSecretRequirementsError, fmt.Sprintf(SecretRequirementsErrorFormat, ProjectLabel)) + } + if labels[DomainLabel] == "" { + return stdlibErrors.Errorf(ErrCodeSecretRequirementsError, fmt.Sprintf(SecretRequirementsErrorFormat, DomainLabel)) + } + return nil +} + +func deriveSecretNameComponents(secret *core.Secret, pod *corev1.Pod) (*SecretNameComponents, error) { + err := validateRequiredFieldsExist(pod.Labels) + if err != nil { + return nil, err + } + + return &SecretNameComponents{ + Project: pod.Labels[ProjectLabel], + Domain: pod.Labels[DomainLabel], + Org: pod.Labels[OrganizationLabel], + Name: secret.Key, + }, nil +} + +func encodeSecretName(components *SecretNameComponents) string { + return EncodeSecretName(components.Org, components.Domain, components.Project, components.Name) +} + +func (i *EmbeddedSecretManagerInjector) lookUpSecret(ctx context.Context, components *SecretNameComponents) (*SecretValue, string, error) { + componentsCopy := *components // Create a copy to avoid modifying the original + + // Attempt to lookup from the cache + projectDomainScopedSecret := encodeSecretName(&componentsCopy) + projectDomainScopedImagePullSecretName := ToImagePullK8sName(componentsCopy) + if cachedValue, err := i.secretCache.Get(ctx, projectDomainScopedSecret); err == nil { + logger.Debugf(ctx, "Found secret [%s] in cache.", projectDomainScopedSecret) + return &cachedValue, projectDomainScopedImagePullSecretName, nil + } + + componentsCopy.Project = EmptySecretScope + domainScopedSecret := encodeSecretName(&componentsCopy) + domainScopedImagePullSecretName := ToImagePullK8sName(componentsCopy) + if cachedValue, err := i.secretCache.Get(ctx, domainScopedSecret); err == nil { + logger.Debugf(ctx, "Found secret [%s] in cache.", domainScopedSecret) + return &cachedValue, domainScopedImagePullSecretName, nil + } + + componentsCopy.Domain = EmptySecretScope + orgScopedSecret := encodeSecretName(&componentsCopy) + orgScopedImagePullSecretName := ToImagePullK8sName(componentsCopy) + if cachedValue, err := i.secretCache.Get(ctx, orgScopedSecret); err == nil { + logger.Debugf(ctx, "Found secret [%s] in cache.", orgScopedSecret) + return &cachedValue, orgScopedImagePullSecretName, nil + } + + logger.Infof(ctx, "Secret [%s] not found in cache. Fetching from secret fetchers.", components) + + for _, secretFetcher := range i.secretFetchers { + // Fetch project-domain scoped secret + secretValue, err := secretFetcher.GetSecretValue(ctx, projectDomainScopedSecret) + if err == nil { + if err := i.secretCache.Set(ctx, projectDomainScopedSecret, *secretValue); err != nil { + logger.Warnf(ctx, "Failed to cache secret [%s]: %v", projectDomainScopedSecret, err) + } + + return secretValue, projectDomainScopedImagePullSecretName, nil + } + + if !stdlibErrors.IsCausedBy(err, ErrCodeSecretNotFound) { + return nil, "", err + } + + // Fetch domain scoped secret + secretValue, err = secretFetcher.GetSecretValue(ctx, domainScopedSecret) + if err == nil { + if err := i.secretCache.Set(ctx, domainScopedSecret, *secretValue); err != nil { + logger.Warnf(ctx, "Failed to cache secret [%s]: %v", domainScopedSecret, err) + } + + return secretValue, domainScopedImagePullSecretName, nil + } + + if !stdlibErrors.IsCausedBy(err, ErrCodeSecretNotFound) { + return nil, "", err + } + + // Fetch organization scoped secret + secretValue, err = secretFetcher.GetSecretValue(ctx, orgScopedSecret) + if err == nil { + if err := i.secretCache.Set(ctx, orgScopedSecret, *secretValue); err != nil { + logger.Warnf(ctx, "Failed to cache secret [%s]: %v", orgScopedSecret, err) + } + + return secretValue, orgScopedImagePullSecretName, err + } + + if !stdlibErrors.IsCausedBy(err, ErrCodeSecretNotFound) { + return nil, "", err + } + } + + return nil, "", stdlibErrors.Errorf(ErrCodeSecretNotFoundAcrossAllScopes, SecretSecretNotFoundAcrossAllScopes) +} + +// addImagePullSecretToPod adds an image pull secret to a pod if it doesn't already exist +func (i *EmbeddedSecretManagerInjector) addImagePullSecretToPod( + ctx context.Context, + pod *corev1.Pod, + secret *corev1.Secret, +) (*corev1.Pod, error) { + // Check if there is a Secret in the same namespace of the Pod that has the same labels of the Secret parameter + + mirroredSecret := &corev1.Secret{} + err := i.k8sClient.Get(ctx, types.NamespacedName{Name: secret.GetName(), Namespace: pod.GetNamespace()}, mirroredSecret) + if err != nil && k8sError.IsNotFound(err) { + // Can't deep copy existing secret because it is not in the same namespace and has fields not allowed in Create + newSecret := &corev1.Secret{ + ObjectMeta: metav1.ObjectMeta{ + Name: secret.GetName(), + Namespace: pod.GetNamespace(), + Labels: secret.Labels, + Annotations: secret.Annotations, + }, + Type: secret.Type, + Data: secret.Data, + StringData: secret.StringData, + } + err = i.k8sClient.Create(ctx, newSecret) + mirroredSecret = newSecret + if err != nil { + logger.Errorf(ctx, "Failed to create mirrored secret [%s] in namespace [%s]: %v", secret.GetName(), pod.GetNamespace(), err) + return pod, fmt.Errorf("failed to create mirrored secret [%s] in namespace [%s]: %w", secret.GetName(), pod.GetNamespace(), err) + } + } else if err != nil { + logger.Errorf(ctx, "Failed to check for mirrored secret [%s] in namespace [%s]: %v", secret.GetName(), pod.GetNamespace(), err) + return pod, fmt.Errorf("failed to check for mirrored secret [%s] in namespace [%s]: %w", secret.GetName(), pod.GetNamespace(), err) + } + + // Now add the image pull secret reference to the pod + imagePullSecretRef := corev1.LocalObjectReference{ + Name: mirroredSecret.GetName(), + } + + // Check if the secret reference already exists to avoid duplicates + secretExists := false + if pod.Spec.ImagePullSecrets != nil { + for _, existingSecret := range pod.Spec.ImagePullSecrets { + if existingSecret.Name == mirroredSecret.GetName() { + secretExists = true + break + } + } + } + + // Add the image pull secret reference if it doesn't already exist + if !secretExists { + if pod.Spec.ImagePullSecrets == nil { + pod.Spec.ImagePullSecrets = make([]corev1.LocalObjectReference, 0) + } + + pod.Spec.ImagePullSecrets = append(pod.Spec.ImagePullSecrets, imagePullSecretRef) + logger.Infof(ctx, "Added image pull secret [%s] to pod [%s/%s]", + mirroredSecret.GetName(), pod.Namespace, pod.Name) + return pod, nil + } else { + logger.Debugf(ctx, "Image pull secret [%s] already exists in pod [%s/%s]", + mirroredSecret.GetName(), pod.Namespace, pod.Name) + return pod, nil + } +} + +// findAndAddImagePullSecret finds image pull secrets for the given secret and adds them to the pod +func (i *EmbeddedSecretManagerInjector) findAndAddImagePullSecret( + ctx context.Context, + k8sSecretName string, + pod *corev1.Pod, +) (*corev1.Pod, error) { + referenceSecret := &corev1.Secret{} + // Pass an empty slice of client.GetOption instead of nil + err := i.k8sClient.Get(ctx, types.NamespacedName{Name: k8sSecretName, Namespace: i.referenceNamespace}, referenceSecret) + if err != nil && !k8sError.IsNotFound(err) { + return pod, fmt.Errorf("failed to get reference secret [%s]: %w", k8sSecretName, err) + } + + if k8sError.IsNotFound(err) { + logger.Debugf(ctx, "No reference Kubernetes secret found [%s]. Assuming not image pull secret.", k8sSecretName) + return pod, nil + } + + return i.addImagePullSecretToPod(ctx, pod, referenceSecret) +} + +func (i *EmbeddedSecretManagerInjector) Inject( + ctx context.Context, + secret *core.Secret, + pod *corev1.Pod, +) (*corev1.Pod, bool /*injected*/, error) { + if len(secret.Key) == 0 { + return pod, false, fmt.Errorf("EmbeddedSecretManager requires key to be set. Secret: [%v]", secret) + } + + secretNameComponents, err := deriveSecretNameComponents(secret, pod) + if err != nil { + return pod, false, err + } + + secretValue, k8sImagePullSecretName, err := i.lookUpSecret(ctx, secretNameComponents) + if err != nil { + return pod, false, err + } + + switch secret.MountRequirement { + case core.Secret_ANY: + fallthrough + case core.Secret_ENV_VAR: + var stringValue string + if secretValue.StringValue != "" { + stringValue = secretValue.StringValue + } else { + // GCP secrets store values as binary only. This means a secret could be + // defined as a file, but mounted as an environment variable. + // We could fail this path for AWS, but for consistent behaviour between + // AWS and GCP we will allow this path for AWS as well. + if !utf8.Valid(secretValue.BinaryValue) { + return pod, false, fmt.Errorf( + "secret %q is attempted to be mounted as an environment variable, "+ + "but has a binary value that is not a valid UTF-8 string; mount "+ + "as a file instead", secret.Key) + } + stringValue = string(secretValue.BinaryValue) + } + i.injectAsEnvVar(secret, stringValue, pod) + case core.Secret_FILE: + secretBytes := secretValue.BinaryValue + if len(secretValue.StringValue) > 0 { + secretBytes = []byte(secretValue.StringValue) + } + i.injectAsFile(secret, secretBytes, pod) + default: + err := fmt.Errorf("unrecognized mount requirement [%v] for secret [%v]", secret.MountRequirement.String(), secret.Key) + logger.Error(ctx, err) + return pod, false, err + } + + if i.cfg.ImagePullSecrets.Enabled { + pod, err = i.findAndAddImagePullSecret(ctx, k8sImagePullSecretName, pod) + if err != nil { + logger.Errorf(ctx, "Failed to add image pull secret [%s]: %v", secretNameComponents.Name, err) + return pod, false, err + } + } + + return pod, true, nil +} + +func (i *EmbeddedSecretManagerInjector) injectAsEnvVar(secret *core.Secret, secretValue string, pod *corev1.Pod) { + envVars := []corev1.EnvVar{ + { + Name: SecretEnvVarPrefix, + Value: i.parentCfg.SecretEnvVarPrefix, + }, + { + Name: i.parentCfg.SecretEnvVarPrefix + strings.ToUpper(secret.GetKey()), + Value: secretValue, + }, + } + if secret.GetEnvVar() != "" { + envVars = append(envVars, corev1.EnvVar{ + Name: secret.EnvVar, + Value: secretValue, + }) + } + pod.Spec.InitContainers = AppendEnvVars(pod.Spec.InitContainers, envVars...) + pod.Spec.Containers = AppendEnvVars(pod.Spec.Containers, envVars...) +} + +func (i *EmbeddedSecretManagerInjector) injectAsFile(secret *core.Secret, secretValue []byte, pod *corev1.Pod) { + initContainer, exists := i.getOrAppendFileMountInitContainer(pod) + appendSecretToFileMountInitContainer(initContainer, secret.GetKey(), secretValue) + + if exists { + return + } + + volume := corev1.Volume{ + Name: EmbeddedSecretsFileMountVolumeName, + VolumeSource: corev1.VolumeSource{ + EmptyDir: &corev1.EmptyDirVolumeSource{ + Medium: corev1.StorageMediumMemory, + }, + }, + } + pod.Spec.Volumes = appendVolumeIfNotExists(pod.Spec.Volumes, volume) + + volumeMount := corev1.VolumeMount{ + Name: EmbeddedSecretsFileMountVolumeName, + ReadOnly: true, + MountPath: EmbeddedSecretsFileMountPath, + } + pod.Spec.InitContainers = AppendVolumeMounts(pod.Spec.InitContainers, volumeMount) + pod.Spec.Containers = AppendVolumeMounts(pod.Spec.Containers, volumeMount) + + envVars := []corev1.EnvVar{ + // Set environment variable to let the containers know where to find the mounted files. + { + Name: SecretPathDefaultDirEnvVar, + Value: EmbeddedSecretsFileMountPath, + }, + // Sets an empty prefix to let the containers know the file names will match the secret keys as-is. + { + Name: SecretPathFilePrefixEnvVar, + Value: "", + }, + } + if secret.GetEnvVar() != "" { + envVars = append(envVars, corev1.EnvVar{ + Name: secret.GetEnvVar(), + Value: filepath.Join(EmbeddedSecretsFileMountPath, strings.ToLower(secret.GetKey())), + }) + } + pod.Spec.InitContainers = AppendEnvVars(pod.Spec.InitContainers, envVars...) + pod.Spec.Containers = AppendEnvVars(pod.Spec.Containers, envVars...) +} + +func (i *EmbeddedSecretManagerInjector) getOrAppendFileMountInitContainer(pod *corev1.Pod) (*corev1.Container, bool /*exists*/) { + index := slices.IndexFunc( + pod.Spec.InitContainers, + func(c corev1.Container) bool { + return c.Name == i.cfg.FileMountInitContainer.ContainerName + }) + if index != -1 { + return &pod.Spec.InitContainers[index], true + } + + pod.Spec.InitContainers = append(pod.Spec.InitContainers, corev1.Container{ + Name: i.cfg.FileMountInitContainer.ContainerName, + Image: i.cfg.FileMountInitContainer.Image, + Command: []string{ + "sh", + "-c", + // Script below expects an environment variable EmbeddedSecretsFileMountInitContainerEnvVariableName + // with contents in the following format: + // secret_name1=base64_encoded_secret_value1 + // secret_name2=base64_encoded_secret_value2 + // ... + // + // It base64-decodes each secret value and writes it to a separate + // file in the EmbeddedSecretsFileMountPath directory. + fmt.Sprintf(` + printf "%%s" "$%s" \ + | awk '/^.+=/ { + i = index($0, "="); + name = substr($0, 0, i - 1); + value = substr($0, i + 1); + output_file = "%s/" name; + print value | "base64 -d > " output_file; + }' + `, + EmbeddedSecretsFileMountInitContainerEnvVariableName, + EmbeddedSecretsFileMountPath), + }, + Resources: i.cfg.FileMountInitContainer.Resources, + VolumeMounts: []corev1.VolumeMount{ + { + Name: EmbeddedSecretsFileMountVolumeName, + ReadOnly: false, + MountPath: EmbeddedSecretsFileMountPath, + }, + }, + }) + + return &pod.Spec.InitContainers[len(pod.Spec.InitContainers)-1], false +} + +func appendSecretToFileMountInitContainer(initContainer *corev1.Container, secretKey string, secretValue []byte) { + var envVar *corev1.EnvVar + index := slices.IndexFunc( + initContainer.Env, + func(env corev1.EnvVar) bool { return env.Name == EmbeddedSecretsFileMountInitContainerEnvVariableName }) + if index != -1 { + envVar = &initContainer.Env[index] + } else { + initContainer.Env = append(initContainer.Env, corev1.EnvVar{ + Name: EmbeddedSecretsFileMountInitContainerEnvVariableName, + }) + envVar = &initContainer.Env[len(initContainer.Env)-1] + } + + envVar.Value += fmt.Sprintf("%s=%s\n", secretKey, base64.StdEncoding.EncodeToString(secretValue)) +} + +func NewEmbeddedSecretManagerInjector( + cfg config.EmbeddedSecretManagerConfig, + secretFetchers []SecretFetcher, + k8sClient client.Client, + referenceNamespace string, + secretCache goCache.CacheInterface[SecretValue], + parentCfg *config.Config, +) SecretsInjector { + return &EmbeddedSecretManagerInjector{ + cfg: cfg, + secretFetchers: secretFetchers, + k8sClient: k8sClient, + referenceNamespace: referenceNamespace, + secretCache: secretCache, + parentCfg: parentCfg, + } +} + +//go:generate mockery -name=MockableControllerRuntimeClient -output=./mocks -case=underscore + +type MockableControllerRuntimeClient interface { + client.Client +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/embedded_secret_manager_test.go b/flyteplugins/go/tasks/pluginmachinery/secret/embedded_secret_manager_test.go new file mode 100644 index 0000000000..0d7a187513 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/embedded_secret_manager_test.go @@ -0,0 +1,733 @@ +package secret + +import ( + "context" + "fmt" + "strings" + "testing" + + "cloud.google.com/go/secretmanager/apiv1/secretmanagerpb" + "github.com/go-test/deep" + "github.com/samber/lo" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + corev1 "k8s.io/api/core/v1" + k8sError "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/mocks" + cacheMocks "github.com/flyteorg/flyte/v2/flytestdlib/cache/mocks" + stdlibErrors "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const ( + testReferenceNamespace = "test-reference-namespace" +) + +func TestEmbeddedSecretManagerInjector_Inject(t *testing.T) { + ctx = context.Background() + gcpClient = &mocks.GCPSecretManagerClient{} + gcpProject = "project" + secretIDKey := "secretID" + secretValue := "secretValue" + + projectSecretID := fmt.Sprintf(secretsStorageFormat, OrganizationLabel, DomainLabel, ProjectLabel, secretIDKey) + domainSecretID := fmt.Sprintf(secretsStorageFormat, OrganizationLabel, DomainLabel, EmptySecretScope, secretIDKey) + orgSecretID := fmt.Sprintf(secretsStorageFormat, OrganizationLabel, EmptySecretScope, EmptySecretScope, secretIDKey) + + gcpClient.On("AccessSecretVersion", ctx, &secretmanagerpb.AccessSecretVersionRequest{ + Name: fmt.Sprintf(GCPSecretNameFormat, gcpProject, projectSecretID), + }).Return(nil, stdlibErrors.Errorf(ErrCodeSecretNotFound, fmt.Sprintf(SecretNotFoundErrorFormat, projectSecretID))) + gcpClient.On("AccessSecretVersion", ctx, &secretmanagerpb.AccessSecretVersionRequest{ + Name: fmt.Sprintf(GCPSecretNameFormat, gcpProject, domainSecretID), + }).Return(nil, stdlibErrors.Errorf(ErrCodeSecretNotFound, fmt.Sprintf(SecretNotFoundErrorFormat, projectSecretID))) + gcpClient.On("AccessSecretVersion", ctx, &secretmanagerpb.AccessSecretVersionRequest{ + Name: fmt.Sprintf(GCPSecretNameFormat, gcpProject, orgSecretID), + }).Return(&secretmanagerpb.AccessSecretVersionResponse{ + Payload: &secretmanagerpb.SecretPayload{ + Data: []byte(secretValue), + }, + }, nil) + + gcpSecretsFetcher := NewGCPSecretFetcher(config.GCPConfig{ + Project: gcpProject, + }, gcpClient) + + inputSecret := &core.Secret{ + Key: secretIDKey, + } + type test struct { + name string + pod *corev1.Pod + expectedPod *corev1.Pod + expectedK8sSecretName string + expectedInjected bool + expectedError error + } + + tests := []test{ + { + name: "empty organization", + pod: &corev1.Pod{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{}, + }, + }, + expectedPod: &corev1.Pod{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{}, + }, + }, + expectedK8sSecretName: "", + expectedInjected: false, + expectedError: stdlibErrors.Errorf(ErrCodeSecretRequirementsError, fmt.Sprintf(SecretRequirementsErrorFormat, OrganizationLabel)), + }, + { + name: "empty project", + pod: &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + OrganizationLabel: OrganizationLabel, + }, + }, + Spec: corev1.PodSpec{ + Containers: []corev1.Container{}, + }, + }, + expectedPod: &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + OrganizationLabel: OrganizationLabel, + }, + }, + Spec: corev1.PodSpec{ + Containers: []corev1.Container{}, + }, + }, + expectedK8sSecretName: "", + expectedInjected: false, + expectedError: stdlibErrors.Errorf(ErrCodeSecretRequirementsError, fmt.Sprintf(SecretRequirementsErrorFormat, ProjectLabel)), + }, + { + name: "empty domain", + pod: &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + OrganizationLabel: OrganizationLabel, + ProjectLabel: ProjectLabel, + }, + }, + Spec: corev1.PodSpec{ + Containers: []corev1.Container{}, + }, + }, + expectedPod: &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + OrganizationLabel: OrganizationLabel, + ProjectLabel: ProjectLabel, + }, + }, + Spec: corev1.PodSpec{ + Containers: []corev1.Container{}, + }, + }, + expectedK8sSecretName: "", + expectedInjected: false, + expectedError: stdlibErrors.Errorf(ErrCodeSecretRequirementsError, fmt.Sprintf(SecretRequirementsErrorFormat, DomainLabel)), + }, + { + name: "all labels", + pod: &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + OrganizationLabel: OrganizationLabel, + ProjectLabel: ProjectLabel, + DomainLabel: DomainLabel, + }, + }, + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + {}, + }, + }, + }, + expectedPod: &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + OrganizationLabel: OrganizationLabel, + ProjectLabel: ProjectLabel, + DomainLabel: DomainLabel, + }, + }, + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + { + Env: []corev1.EnvVar{ + { + Name: "_UNION_SECRETID", + Value: secretValue, + }, + { + Name: SecretEnvVarPrefix, + Value: config.DefaultSecretEnvVarPrefix, + }, + }, + }, + }, + InitContainers: []corev1.Container{}, + }, + }, + expectedK8sSecretName: ToImagePullK8sName(SecretNameComponents{ + Org: OrganizationLabel, + Domain: "", + Project: "", + Name: secretIDKey, + }), + expectedInjected: true, + expectedError: nil, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mockClient := &mocks.MockableControllerRuntimeClient{} + + if tt.expectedInjected { + mockClient. + On("Get", ctx, types.NamespacedName{Name: tt.expectedK8sSecretName, Namespace: testReferenceNamespace}, &corev1.Secret{}). + Return(k8sError.NewNotFound(corev1.Resource("secret"), tt.expectedK8sSecretName)) + } + + secretCache := cacheMocks.NewMockCache[SecretValue](true) + parentCfg := &config.Config{SecretEnvVarPrefix: config.DefaultSecretEnvVarPrefix} + injector := NewEmbeddedSecretManagerInjector(config.EmbeddedSecretManagerConfig{}, []SecretFetcher{gcpSecretsFetcher}, mockClient, testReferenceNamespace, secretCache, parentCfg) + + actualP, injected, err := injector.Inject(ctx, inputSecret, tt.pod) + assert.Equal(t, tt.expectedInjected, injected) + assert.Equal(t, tt.expectedError, err) + if diff := deep.Equal(actualP, tt.expectedPod); diff != nil { + logger.Info(ctx, actualP) + assert.Fail(t, "actual != expected", "Diff: %v", diff) + } + }) + } +} + +func TestEmbeddedSecretManagerInjector_InjectAsFile(t *testing.T) { + ctx = context.Background() + + type test struct { + name string + secret *core.Secret + } + tests := []test{ + { + name: "Without envVar", + secret: &core.Secret{ + Key: "secret1", + MountRequirement: core.Secret_FILE, + }, + }, + { + name: "With envVar", + secret: &core.Secret{ + Key: "secret1", + MountRequirement: core.Secret_FILE, + EnvVar: "MY_ENV_VAR", + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + pod := &corev1.Pod{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + {}, + }, + }, + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + "organization": "organization", + "project": "project", + "domain": "domain", + }, + }, + } + + mockClient := &mocks.MockableControllerRuntimeClient{} + kubernetesSecretName := ToImagePullK8sName(SecretNameComponents{ + Org: "organization", + Domain: "domain", + Project: "project", + Name: "secret1", + }) + mockClient. + On("Get", ctx, types.NamespacedName{Name: kubernetesSecretName, Namespace: testReferenceNamespace}, &corev1.Secret{}). + Return(k8sError.NewNotFound(corev1.Resource("secret"), kubernetesSecretName)) + + secretCache := cacheMocks.NewMockCache[SecretValue](true) + injector := NewEmbeddedSecretManagerInjector( + config.EmbeddedSecretManagerConfig{}, + []SecretFetcher{secretFetcherMock{ + Secrets: map[string]SecretValue{ + "u__org__organization__domain__domain__project__project__key__secret1": { + BinaryValue: []byte("banana"), + }, + }, + }}, mockClient, testReferenceNamespace, secretCache, &config.Config{SecretEnvVarPrefix: config.DefaultSecretEnvVarPrefix}) + + pod, injected, err := injector.Inject(ctx, tt.secret, pod) + assert.NoError(t, err) + assert.True(t, injected) + assert.Len(t, pod.Spec.InitContainers, 1) + + env, found := lo.Find( + pod.Spec.InitContainers[0].Env, + func(env corev1.EnvVar) bool { return env.Name == "SECRETS" }) + assert.True(t, found) + assert.Equal(t, "secret1=YmFuYW5h\n", env.Value) + + if tt.secret.GetEnvVar() != "" { + env, found = lo.Find( + pod.Spec.Containers[0].Env, + func(env corev1.EnvVar) bool { return env.Name == tt.secret.GetEnvVar() }) + assert.True(t, found) + assert.Equal(t, "/etc/flyte/secrets/secret1", env.Value) + } + }) + } +} + +func TestEmbeddedSecretManagerInjector_InjectSecretScopedToOrganization(t *testing.T) { + ctx = context.Background() + + type test struct { + name string + secret *core.Secret + } + tests := []test{ + { + name: "Without envVar", + secret: &core.Secret{Key: "secret1"}, + }, + { + name: "With envVar", + secret: &core.Secret{Key: "secret1", EnvVar: "MY_VAR"}, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + pod := &corev1.Pod{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + {}, + }, + }, + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + "organization": "o-apple", + "domain": "d-cherry", + "project": "p-banana", + }, + }, + } + + mockClient := &mocks.MockableControllerRuntimeClient{} + kubernetesSecretName := ToImagePullK8sName(SecretNameComponents{ + Org: "o-apple", + Domain: "", + Project: "", + Name: "secret1", + }) + mockClient. + On("Get", ctx, types.NamespacedName{Name: kubernetesSecretName, Namespace: testReferenceNamespace}, &corev1.Secret{}). + Return(k8sError.NewNotFound(corev1.Resource("secret"), kubernetesSecretName)) + + secretCache := cacheMocks.NewMockCache[SecretValue](true) + injector := NewEmbeddedSecretManagerInjector( + config.EmbeddedSecretManagerConfig{}, + []SecretFetcher{secretFetcherMock{ + Secrets: map[string]SecretValue{ + "u__org__o-apple__domain____project____key__secret1": { + StringValue: "fruits", + }, + }, + }}, mockClient, testReferenceNamespace, secretCache, &config.Config{SecretEnvVarPrefix: config.DefaultSecretEnvVarPrefix}) + + pod, injected, err := injector.Inject(ctx, tt.secret, pod) + assert.NoError(t, err) + assert.True(t, injected) + assert.True(t, podHasSecretInjected(pod, "secret1", "fruits", tt.secret.GetEnvVar())) + + }) + } +} + +func TestEmbeddedSecretManagerInjector_InjectSecretScopedToDomain(t *testing.T) { + ctx = context.Background() + secret := &core.Secret{Key: "secret1"} + pod := &corev1.Pod{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + {}, + }, + }, + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + "organization": "o-apple", + "domain": "d-cherry", + "project": "p-banana", + }, + }, + } + + mockClient := &mocks.MockableControllerRuntimeClient{} + kubernetesSecretName1 := ToImagePullK8sName(SecretNameComponents{ + Org: "o-apple", + Domain: "", + Project: "", + Name: "secret1", + }) + kubernetesSecretName2 := ToImagePullK8sName(SecretNameComponents{ + Org: "o-apple", + Domain: "d-cherry", + Project: "", + Name: "secret1", + }) + mockClient. + On("Get", ctx, types.NamespacedName{Name: kubernetesSecretName1, Namespace: testReferenceNamespace}, &corev1.Secret{}). + Return(k8sError.NewNotFound(corev1.Resource("secret"), kubernetesSecretName1)) + mockClient. + On("Get", ctx, types.NamespacedName{Name: kubernetesSecretName2, Namespace: testReferenceNamespace}, &corev1.Secret{}). + Return(k8sError.NewNotFound(corev1.Resource("secret"), kubernetesSecretName2)) + + secretCache := cacheMocks.NewMockCache[SecretValue](true) + injector := NewEmbeddedSecretManagerInjector( + config.EmbeddedSecretManagerConfig{}, + []SecretFetcher{secretFetcherMock{ + Secrets: map[string]SecretValue{ + "u__org__o-apple__domain____project____key__secret1": { + StringValue: "fruits @ org", + }, + "u__org__o-apple__domain__d-cherry__project____key__secret1": { + StringValue: "fruits @ domain", + }, + }, + }}, mockClient, testReferenceNamespace, secretCache, &config.Config{SecretEnvVarPrefix: config.DefaultSecretEnvVarPrefix}) + + pod, injected, err := injector.Inject(ctx, secret, pod) + assert.NoError(t, err) + assert.True(t, injected) + assert.True(t, podHasSecretInjected(pod, "secret1", "fruits @ domain", "")) +} + +func TestEmbeddedSecretManagerInjector_InjectSecretScopedToProject(t *testing.T) { + ctx = context.Background() + secret := &core.Secret{Key: "secret1"} + pod := &corev1.Pod{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + {}, + }, + }, + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + "organization": "o-apple", + "domain": "d-cherry", + "project": "p-banana", + }, + }, + } + + mockClient := &mocks.MockableControllerRuntimeClient{} + kubernetesSecretName1 := ToImagePullK8sName(SecretNameComponents{ + Org: "o-apple", + Domain: "", + Project: "", + Name: "secret1", + }) + kubernetesSecretName2 := ToImagePullK8sName(SecretNameComponents{ + Org: "o-apple", + Domain: "d-cherry", + Project: "", + Name: "secret1", + }) + kubernetesSecretName3 := ToImagePullK8sName(SecretNameComponents{ + Org: "o-apple", + Domain: "d-cherry", + Project: "p-banana", + Name: "secret1", + }) + mockClient. + On("Get", ctx, types.NamespacedName{Name: kubernetesSecretName1, Namespace: testReferenceNamespace}, &corev1.Secret{}). + Return(k8sError.NewNotFound(corev1.Resource("secret"), kubernetesSecretName1)) + mockClient. + On("Get", ctx, types.NamespacedName{Name: kubernetesSecretName2, Namespace: testReferenceNamespace}, &corev1.Secret{}). + Return(k8sError.NewNotFound(corev1.Resource("secret"), kubernetesSecretName2)) + mockClient. + On("Get", ctx, types.NamespacedName{Name: kubernetesSecretName3, Namespace: testReferenceNamespace}, &corev1.Secret{}). + Return(k8sError.NewNotFound(corev1.Resource("secret"), kubernetesSecretName3)) + + secretCache := cacheMocks.NewMockCache[SecretValue](true) + injector := NewEmbeddedSecretManagerInjector( + config.EmbeddedSecretManagerConfig{}, + []SecretFetcher{secretFetcherMock{ + Secrets: map[string]SecretValue{ + "u__org__o-apple__domain____project____key__secret1": { + StringValue: "fruits @ org", + }, + "u__org__o-apple__domain__d-cherry__project____key__secret1": { + StringValue: "fruits @ domain", + }, + "u__org__o-apple__domain__d-cherry__project__p-banana__key__secret1": { + StringValue: "fruits @ project", + }, + }, + }}, mockClient, testReferenceNamespace, secretCache, &config.Config{SecretEnvVarPrefix: config.DefaultSecretEnvVarPrefix}) + + pod, injected, err := injector.Inject(ctx, secret, pod) + assert.NoError(t, err) + assert.True(t, injected) + assert.True(t, podHasSecretInjected(pod, "secret1", "fruits @ project", "")) +} + +func TestEmbeddedSecretManagerInjector_InjectImagePullSecret(t *testing.T) { + ctx = context.Background() + + testOrganization := "test-organization" + testDomain := "test-domain" + testProject := "test-project" + testSecretName := "test-secret" + testNamespace := "test-pod-namespace" + + secretName := "u__org__test-organization__domain__test-domain__project__test-project__key__test-secret" //nolint:gosec + kubernetesSecretName := ToImagePullK8sName(SecretNameComponents{ + Org: testOrganization, + Domain: testDomain, + Project: testProject, + Name: testSecretName, + }) + + referenceImagePullSecret := &corev1.Secret{ + ObjectMeta: metav1.ObjectMeta{ + Name: kubernetesSecretName, + Namespace: testReferenceNamespace, + }, + Data: map[string][]byte{ + ".dockerconfigjson": []byte("test-credentials"), + }, + } + + existingMirrorImagePullSecret := referenceImagePullSecret.DeepCopy() + existingMirrorImagePullSecret.SetNamespace(testNamespace) + + secret := &core.Secret{Key: testSecretName} + pod := &corev1.Pod{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + {}, + }, + }, + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + "organization": testOrganization, + "domain": testDomain, + "project": testProject, + }, + Namespace: testNamespace, + }, + } + + enabledConfig := config.EmbeddedSecretManagerConfig{ + ImagePullSecrets: config.ImagePullSecretsConfig{ + Enabled: true, + }, + } + + t.Run("existing image pull secret", func(t *testing.T) { + testPod := pod.DeepCopy() + + mockClient := &mocks.MockableControllerRuntimeClient{} + mockClient. + On("Get", ctx, types.NamespacedName{Name: kubernetesSecretName, Namespace: testReferenceNamespace}, &corev1.Secret{}). + Run(func(args mock.Arguments) { + secret := args.Get(2).(*corev1.Secret) + *secret = *referenceImagePullSecret + }). + Return(nil) + + mockClient. + On("Get", ctx, types.NamespacedName{Name: kubernetesSecretName, Namespace: testNamespace}, &corev1.Secret{}). + Run(func(args mock.Arguments) { + secret := args.Get(2).(*corev1.Secret) + *secret = *existingMirrorImagePullSecret + }). + Return(nil) + + secretCache := cacheMocks.NewMockCache[SecretValue](true) + injector := NewEmbeddedSecretManagerInjector( + enabledConfig, + []SecretFetcher{secretFetcherMock{ + Secrets: map[string]SecretValue{ + secretName: { + BinaryValue: []byte("test-credentials"), + }, + }, + }}, mockClient, testReferenceNamespace, secretCache, &config.Config{SecretEnvVarPrefix: config.DefaultSecretEnvVarPrefix}) + + resultPod, injected, err := injector.Inject(ctx, secret, testPod) + assert.NoError(t, err) + assert.True(t, injected) + assert.Equal(t, []corev1.LocalObjectReference{{Name: kubernetesSecretName}}, resultPod.Spec.ImagePullSecrets) + }) + + t.Run("missing image pull secret", func(t *testing.T) { + testPod := pod.DeepCopy() + + mockClient := &mocks.MockableControllerRuntimeClient{} + mockClient. + On("Get", ctx, types.NamespacedName{Name: kubernetesSecretName, Namespace: testReferenceNamespace}, &corev1.Secret{}). + Run(func(args mock.Arguments) { + secret := args.Get(2).(*corev1.Secret) + *secret = *referenceImagePullSecret + }). + Return(nil) + + mockClient. + On("Get", ctx, types.NamespacedName{Name: kubernetesSecretName, Namespace: testNamespace}, &corev1.Secret{}). + Return(k8sError.NewNotFound(corev1.Resource("secret"), kubernetesSecretName)) + + mockClient. + On("Create", ctx, existingMirrorImagePullSecret). + Return(nil) + + secretCache := cacheMocks.NewMockCache[SecretValue](true) + injector := NewEmbeddedSecretManagerInjector( + enabledConfig, + []SecretFetcher{secretFetcherMock{ + Secrets: map[string]SecretValue{ + secretName: { + BinaryValue: []byte("test-credentials"), + }, + }, + }}, mockClient, testReferenceNamespace, secretCache, &config.Config{SecretEnvVarPrefix: config.DefaultSecretEnvVarPrefix}) + + resultPod, injected, err := injector.Inject(ctx, secret, testPod) + assert.NoError(t, err) + assert.True(t, injected) + assert.Equal(t, []corev1.LocalObjectReference{{Name: kubernetesSecretName}}, resultPod.Spec.ImagePullSecrets) + }) + + t.Run("image pull secrets disabled", func(t *testing.T) { + testPod := pod.DeepCopy() + + mockClient := &mocks.MockableControllerRuntimeClient{} + + secretCache := cacheMocks.NewMockCache[SecretValue](true) + injector := NewEmbeddedSecretManagerInjector( + config.EmbeddedSecretManagerConfig{}, + []SecretFetcher{secretFetcherMock{ + Secrets: map[string]SecretValue{ + secretName: { + BinaryValue: []byte("test-credentials"), + }, + }, + }}, mockClient, testReferenceNamespace, secretCache, &config.Config{SecretEnvVarPrefix: config.DefaultSecretEnvVarPrefix}) + + resultPod, injected, err := injector.Inject(ctx, secret, testPod) + assert.NoError(t, err) + assert.True(t, injected) + assert.Nil(t, resultPod.Spec.ImagePullSecrets) + + mockClient.AssertNotCalled(t, "Get", mock.Anything, mock.Anything, mock.Anything) + mockClient.AssertNotCalled(t, "Create", mock.Anything, mock.Anything) + }) + + t.Run("image pull secret is not scoped to project or domain", func(t *testing.T) { + testPod := pod.DeepCopy() + orgBasedSecretName := "u__org__test-organization__domain____project____key__test-secret" //nolint:gosec + orgBasedKubernetesSecretName := ToImagePullK8sName(SecretNameComponents{ + Org: testOrganization, + Domain: "", + Project: "", + Name: testSecretName, + }) + + orgBasedReferenceImagePullSecret := referenceImagePullSecret.DeepCopy() + orgBasedReferenceImagePullSecret.SetName(orgBasedKubernetesSecretName) + mockClient := &mocks.MockableControllerRuntimeClient{} + mockClient. + On("Get", ctx, types.NamespacedName{Name: orgBasedKubernetesSecretName, Namespace: testReferenceNamespace}, &corev1.Secret{}). + Run(func(args mock.Arguments) { + secret := args.Get(2).(*corev1.Secret) + *secret = *orgBasedReferenceImagePullSecret + }). + Return(nil) + + orgBasedExistingMirrorSecret := existingMirrorImagePullSecret.DeepCopy() + orgBasedExistingMirrorSecret.SetName(orgBasedKubernetesSecretName) + mockClient. + On("Get", ctx, types.NamespacedName{Name: orgBasedKubernetesSecretName, Namespace: testNamespace}, &corev1.Secret{}). + Run(func(args mock.Arguments) { + secret := args.Get(2).(*corev1.Secret) + *secret = *orgBasedExistingMirrorSecret + }). + Return(nil) + + secretCache := cacheMocks.NewMockCache[SecretValue](true) + injector := NewEmbeddedSecretManagerInjector( + enabledConfig, + []SecretFetcher{secretFetcherMock{ + Secrets: map[string]SecretValue{ + orgBasedSecretName: { + BinaryValue: []byte("test-credentials"), + }, + }, + }}, mockClient, testReferenceNamespace, secretCache, &config.Config{SecretEnvVarPrefix: config.DefaultSecretEnvVarPrefix}) + + resultPod, injected, err := injector.Inject(ctx, secret, testPod) + assert.NoError(t, err) + assert.True(t, injected) + assert.Equal(t, []corev1.LocalObjectReference{{Name: orgBasedKubernetesSecretName}}, resultPod.Spec.ImagePullSecrets) + }) +} + +func podHasSecretInjected(pod *corev1.Pod, secretKey string, secretValue string, envVar string) bool { + return lo.EveryBy(pod.Spec.Containers, func(container corev1.Container) bool { + hasValueEnvVar := lo.ContainsBy(container.Env, func(env corev1.EnvVar) bool { + return env.Name == ("_UNION_"+strings.ToUpper(secretKey)) && + env.Value == secretValue + }) + hasPrefixEnvVar := lo.ContainsBy(container.Env, func(env corev1.EnvVar) bool { + return env.Name == "FLYTE_SECRETS_ENV_PREFIX" && env.Value == "_UNION_" + }) + hasCustomEnvVar := true + if envVar != "" { + hasCustomEnvVar = lo.ContainsBy(container.Env, func(env corev1.EnvVar) bool { + return env.Name == envVar && env.Value == secretValue + }) + } + + return hasValueEnvVar && hasPrefixEnvVar && hasCustomEnvVar + }) +} + +type secretFetcherMock struct { + Secrets map[string]SecretValue +} + +func (f secretFetcherMock) GetSecretValue(ctx context.Context, secretID string) (*SecretValue, error) { + v, ok := f.Secrets[secretID] + if !ok { + return nil, stdlibErrors.Errorf(ErrCodeSecretNotFound, "secret %q not found", secretID) + } + + return &v, nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/gcp_secret_fetcher.go b/flyteplugins/go/tasks/pluginmachinery/secret/gcp_secret_fetcher.go new file mode 100644 index 0000000000..2bc0861775 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/gcp_secret_fetcher.go @@ -0,0 +1,54 @@ +package secret + +import ( + "context" + "fmt" + + gcpsmpb "cloud.google.com/go/secretmanager/apiv1/secretmanagerpb" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + stdlibErrors "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +const ( + GCPSecretNameFormat = "projects/%s/secrets/%s/versions/latest" // #nosec G101 +) + +type GCPSecretFetcher struct { + client GCPSecretManagerClient + cfg config.GCPConfig +} + +func (g GCPSecretFetcher) GetSecretValue(ctx context.Context, secretID string) (*SecretValue, error) { + logger.Infof(ctx, "Got fetch secret Request for %v!", secretID) + resp, err := g.client.AccessSecretVersion(ctx, &gcpsmpb.AccessSecretVersionRequest{ + Name: fmt.Sprintf(GCPSecretNameFormat, g.cfg.Project, secretID), + }) + if err != nil { + if s, ok := status.FromError(err); ok && s.Code() == codes.NotFound { + wrappedErr := stdlibErrors.Wrapf(ErrCodeSecretNotFound, err, fmt.Sprintf(SecretNotFoundErrorFormat, secretID)) + logger.Warn(ctx, wrappedErr) + return nil, wrappedErr + } + wrappedErr := stdlibErrors.Wrapf(ErrCodeSecretReadFailure, err, fmt.Sprintf(SecretReadFailureErrorFormat, secretID)) + logger.Error(ctx, wrappedErr) + return nil, wrappedErr + } + if resp.GetPayload() == nil { + wrappedErr := stdlibErrors.Wrapf(ErrCodeSecretNil, err, fmt.Sprintf(SecretNilErrorFormat, secretID)) + logger.Error(ctx, wrappedErr) + return nil, wrappedErr + } + + return &SecretValue{ + BinaryValue: resp.GetPayload().GetData(), + }, nil +} + +// NewGCPSecretFetcher creates a secret value fetcher for GCP +func NewGCPSecretFetcher(cfg config.GCPConfig, client GCPSecretManagerClient) SecretFetcher { + return GCPSecretFetcher{cfg: cfg, client: client} +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/gcp_secret_fetcher_test.go b/flyteplugins/go/tasks/pluginmachinery/secret/gcp_secret_fetcher_test.go new file mode 100644 index 0000000000..0938087705 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/gcp_secret_fetcher_test.go @@ -0,0 +1,76 @@ +package secret + +import ( + "context" + "fmt" + "testing" + + "cloud.google.com/go/secretmanager/apiv1/secretmanagerpb" + "github.com/stretchr/testify/assert" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/mocks" + stdlibErrors "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +var ( + gcpClient *mocks.GCPSecretManagerClient + gcpProject string +) + +func SetupGCPTest() { + scope = promutils.NewTestScope() + ctx = context.Background() + gcpClient = &mocks.GCPSecretManagerClient{} + gcpProject = "project" +} + +func TestGetSecretValueGCP(t *testing.T) { + t.Run("get secret successful", func(t *testing.T) { + SetupGCPTest() + gcpSecretsFetcher := NewGCPSecretFetcher(config.GCPConfig{ + Project: gcpProject, + }, gcpClient) + gcpClient.OnAccessSecretVersionMatch(ctx, &secretmanagerpb.AccessSecretVersionRequest{ + Name: fmt.Sprintf(GCPSecretNameFormat, gcpProject, secretID), + }).Return(&secretmanagerpb.AccessSecretVersionResponse{ + Payload: &secretmanagerpb.SecretPayload{ + Data: []byte("secretValue"), + }, + }, nil) + + _, err := gcpSecretsFetcher.GetSecretValue(ctx, "secretID") + assert.NoError(t, err) + }) + + t.Run("get secret not found", func(t *testing.T) { + SetupGCPTest() + gcpSecretsFetcher := NewGCPSecretFetcher(config.GCPConfig{ + Project: gcpProject, + }, gcpClient) + cause := status.Errorf(codes.NotFound, "secret not found") + gcpClient.OnAccessSecretVersionMatch(ctx, &secretmanagerpb.AccessSecretVersionRequest{ + Name: fmt.Sprintf(GCPSecretNameFormat, gcpProject, secretID), + }).Return(nil, cause) + + _, err := gcpSecretsFetcher.GetSecretValue(ctx, "secretID") + assert.Equal(t, stdlibErrors.Wrapf(ErrCodeSecretNotFound, cause, fmt.Sprintf(SecretNotFoundErrorFormat, secretID)), err) + }) + + t.Run("get secret read failure", func(t *testing.T) { + SetupGCPTest() + gcpSecretsFetcher := NewGCPSecretFetcher(config.GCPConfig{ + Project: gcpProject, + }, gcpClient) + cause := fmt.Errorf("some error") + gcpClient.OnAccessSecretVersionMatch(ctx, &secretmanagerpb.AccessSecretVersionRequest{ + Name: fmt.Sprintf(GCPSecretNameFormat, gcpProject, secretID), + }).Return(nil, cause) + + _, err := gcpSecretsFetcher.GetSecretValue(ctx, "secretID") + assert.Equal(t, stdlibErrors.Wrapf(ErrCodeSecretReadFailure, cause, fmt.Sprintf(SecretReadFailureErrorFormat, secretID)), err) + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/gcp_secret_manager.go b/flyteplugins/go/tasks/pluginmachinery/secret/gcp_secret_manager.go new file mode 100644 index 0000000000..3c1683b6c9 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/gcp_secret_manager.go @@ -0,0 +1,143 @@ +package secret + +import ( + "context" + "fmt" + "path/filepath" + "strings" + + corev1 "k8s.io/api/core/v1" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const ( + // GCPSecretsVolumeName defines the static name of the volume used for mounting/sharing secrets between init-container + // sidecar and the rest of the containers in the pod. + GCPSecretsVolumeName = "gcp-secret-vol" // #nosec G101 + + GCPSecretMountPath = "/etc/flyte/secrets" // #nosec G101 +) + +// GCPSecretManagerInjector allows injecting of secrets from GCP Secret Manager as files. It uses a Google Cloud +// SDK SideCar as an init-container to download the secret and save it to a local volume shared with all other +// containers in the pod. It supports multiple secrets to be mounted but that will result into adding an init +// container for each secret. The Google serviceaccount (GSA) associated with the Pod, either via Workload +// Identity (recommended) or the underlying node's serviceacccount, must have permissions to pull the secret +// from GCP Secret Manager. Currently, the secret must also exist in the same project. Otherwise, the Pod will +// fail with an init-error. +// Files will be mounted on /etc/flyte/secrets// +type GCPSecretManagerInjector struct { + cfg config.GCPSecretManagerConfig +} + +func formatGCPSecretAccessCommand(secret *core.Secret) []string { + // `gcloud` writes this file with permission 0600. + // This will cause permission issues in the main container when using non-root + // users, so we fix the file permissions with `chmod`. + secretDir := strings.ToLower(filepath.Join(GCPSecretMountPath, secret.Group)) + secretPath := strings.ToLower(filepath.Join(secretDir, secret.GroupVersion)) + args := fmt.Sprintf( + "gcloud secrets versions access %[1]s/versions/%[2]s --out-file=%[4]s || gcloud secrets versions access %[2]s --secret=%[1]s --out-file=%[4]s; chmod +rX %[3]s %[4]s", + secret.Group, + secret.GroupVersion, + secretDir, + secretPath, + ) + return []string{"sh", "-ec", args} +} + +func formatGCPInitContainerName(index int) string { + return fmt.Sprintf("gcp-pull-secret-%v", index) +} + +func (i GCPSecretManagerInjector) Type() config.SecretManagerType { + return config.SecretManagerTypeGCP +} + +func (i GCPSecretManagerInjector) Inject(ctx context.Context, secret *core.Secret, p *corev1.Pod) (newP *corev1.Pod, injected bool, err error) { + if len(secret.Group) == 0 || len(secret.GroupVersion) == 0 { + return p, false, fmt.Errorf("GCP Secrets Webhook require both group and group version to be set. "+ + "Secret: [%v]", secret) + } + + switch secret.MountRequirement { + case core.Secret_ANY: + fallthrough + case core.Secret_FILE: + // A Volume with a static name so that if we try to inject multiple secrets, we won't mount multiple volumes. + // We use Memory as the storage medium for volume source to avoid + vol := corev1.Volume{ + Name: GCPSecretsVolumeName, + VolumeSource: corev1.VolumeSource{ + EmptyDir: &corev1.EmptyDirVolumeSource{ + Medium: corev1.StorageMediumMemory, + }, + }, + } + + p.Spec.Volumes = appendVolumeIfNotExists(p.Spec.Volumes, vol) + p.Spec.InitContainers = append(p.Spec.InitContainers, createGCPSidecarContainer(i.cfg, p, secret)) + + secretVolumeMount := corev1.VolumeMount{ + Name: GCPSecretsVolumeName, + ReadOnly: true, + MountPath: GCPSecretMountPath, + } + + p.Spec.Containers = AppendVolumeMounts(p.Spec.Containers, secretVolumeMount) + p.Spec.InitContainers = AppendVolumeMounts(p.Spec.InitContainers, secretVolumeMount) + + // Inject GCP secret-inject webhook annotations to mount the secret in a predictable location. + envVars := []corev1.EnvVar{ + // Set environment variable to let the container know where to find the mounted files. + { + Name: SecretPathDefaultDirEnvVar, + Value: GCPSecretMountPath, + }, + // Sets an empty prefix to let the containers know the file names will match the secret keys as-is. + { + Name: SecretPathFilePrefixEnvVar, + Value: "", + }, + } + + for _, envVar := range envVars { + p.Spec.InitContainers = AppendEnvVars(p.Spec.InitContainers, envVar) + p.Spec.Containers = AppendEnvVars(p.Spec.Containers, envVar) + } + case core.Secret_ENV_VAR: + fallthrough + default: + err := fmt.Errorf("unrecognized mount requirement [%v] for secret [%v]", secret.MountRequirement.String(), secret.Key) + logger.Error(ctx, err) + return p, false, err + } + + return p, true, nil +} + +func createGCPSidecarContainer(cfg config.GCPSecretManagerConfig, p *corev1.Pod, secret *core.Secret) corev1.Container { + return corev1.Container{ + Image: cfg.SidecarImage, + // Create a unique name to allow multiple secrets to be mounted. + Name: formatGCPInitContainerName(len(p.Spec.InitContainers)), + Command: formatGCPSecretAccessCommand(secret), + VolumeMounts: []corev1.VolumeMount{ + { + Name: GCPSecretsVolumeName, + MountPath: GCPSecretMountPath, + }, + }, + Resources: cfg.Resources, + } +} + +// NewGCPSecretManagerInjector creates a SecretInjector that's able to mount secrets from GCP Secret Manager. +func NewGCPSecretManagerInjector(cfg config.GCPSecretManagerConfig) GCPSecretManagerInjector { + return GCPSecretManagerInjector{ + cfg: cfg, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/gcp_secret_manager_test.go b/flyteplugins/go/tasks/pluginmachinery/secret/gcp_secret_manager_test.go new file mode 100644 index 0000000000..78243844ac --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/gcp_secret_manager_test.go @@ -0,0 +1,78 @@ +package secret + +import ( + "context" + "testing" + + "github.com/go-test/deep" + "github.com/stretchr/testify/assert" + corev1 "k8s.io/api/core/v1" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestGCPSecretManagerInjector_Inject(t *testing.T) { + injector := NewGCPSecretManagerInjector(config.DefaultConfig.GCPSecretManagerConfig) + inputSecret := &core.Secret{ + Group: "TestSecret", + GroupVersion: "2", + } + + expected := &corev1.Pod{ + Spec: corev1.PodSpec{ + Volumes: []corev1.Volume{ + { + Name: "gcp-secret-vol", + VolumeSource: corev1.VolumeSource{ + EmptyDir: &corev1.EmptyDirVolumeSource{ + Medium: corev1.StorageMediumMemory, + }, + }, + }, + }, + + InitContainers: []corev1.Container{ + { + Name: "gcp-pull-secret-0", + Image: "gcr.io/google.com/cloudsdktool/cloud-sdk:alpine", + Command: []string{ + "sh", + "-ec", + "gcloud secrets versions access TestSecret/versions/2 --out-file=/etc/flyte/secrets/testsecret/2 || gcloud secrets versions access 2 --secret=TestSecret --out-file=/etc/flyte/secrets/testsecret/2; chmod +rX /etc/flyte/secrets/testsecret /etc/flyte/secrets/testsecret/2", + }, + Env: []corev1.EnvVar{ + { + Name: "FLYTE_SECRETS_FILE_PREFIX", + Value: "", + }, + { + Name: "FLYTE_SECRETS_DEFAULT_DIR", + Value: "/etc/flyte/secrets", + }, + }, + VolumeMounts: []corev1.VolumeMount{ + { + Name: "gcp-secret-vol", + MountPath: "/etc/flyte/secrets", + }, + }, + Resources: config.DefaultConfig.GCPSecretManagerConfig.Resources, + }, + }, + Containers: []corev1.Container{}, + }, + } + + p := &corev1.Pod{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{}, + }, + } + actualP, injected, err := injector.Inject(context.Background(), inputSecret, p) + assert.NoError(t, err) + assert.True(t, injected) + if diff := deep.Equal(actualP, expected); diff != nil { + assert.Fail(t, "actual != expected", "Diff: %v", diff) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/global_secrets.go b/flyteplugins/go/tasks/pluginmachinery/secret/global_secrets.go new file mode 100644 index 0000000000..73d62f8ea7 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/global_secrets.go @@ -0,0 +1,79 @@ +package secret + +import ( + "context" + "fmt" + "strings" + + corev1 "k8s.io/api/core/v1" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + coreIdl "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +//go:generate mockery --output=./mocks --case=underscore --name=GlobalSecretProvider +type GlobalSecretProvider interface { + GetForSecret(ctx context.Context, secret *coreIdl.Secret) (string, error) +} + +// GlobalSecrets allows the injection of secrets from the process memory space (env vars) or mounted files into pods +// intercepted through this admission webhook. Secrets injected through this type will be mounted as environment +// variables. If a secret has a mounting requirement that does not allow Env Vars, it'll fail to inject the secret. +type GlobalSecrets struct { + envSecretManager GlobalSecretProvider + cfg *config.Config +} + +func (g GlobalSecrets) Type() config.SecretManagerType { + return config.SecretManagerTypeGlobal +} + +func (g GlobalSecrets) Inject(ctx context.Context, secret *coreIdl.Secret, p *corev1.Pod) (newP *corev1.Pod, injected bool, err error) { + v, err := g.envSecretManager.GetForSecret(ctx, secret) + if err != nil { + return p, false, err + } + + switch secret.MountRequirement { + case coreIdl.Secret_FILE: + return nil, false, fmt.Errorf("global secrets can only be injected as environment "+ + "variables [%v/%v]", secret.Group, secret.Key) + case coreIdl.Secret_ANY: + fallthrough + case coreIdl.Secret_ENV_VAR: + if len(secret.Group) == 0 { + return nil, false, fmt.Errorf("mounting a secret to env var requires selecting the "+ + "secret and a single key within. Key [%v]", secret.Key) + } + + envVar := corev1.EnvVar{ + Name: strings.ToUpper(g.cfg.SecretEnvVarPrefix + secret.Group + EnvVarGroupKeySeparator + secret.Key), + Value: v, + } + + prefixEnvVar := corev1.EnvVar{ + Name: SecretEnvVarPrefix, + Value: g.cfg.SecretEnvVarPrefix, + } + + p.Spec.InitContainers = AppendEnvVars(p.Spec.InitContainers, prefixEnvVar) + p.Spec.Containers = AppendEnvVars(p.Spec.Containers, prefixEnvVar) + + p.Spec.InitContainers = AppendEnvVars(p.Spec.InitContainers, envVar) + p.Spec.Containers = AppendEnvVars(p.Spec.Containers, envVar) + default: + err := fmt.Errorf("unrecognized mount requirement [%v] for secret [%v]", secret.MountRequirement.String(), secret.Key) + logger.Error(ctx, err) + return p, false, err + } + + return p, true, nil +} + +func NewGlobalSecrets(provider GlobalSecretProvider, cfg *config.Config) GlobalSecrets { + return GlobalSecrets{ + envSecretManager: provider, + cfg: cfg, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/global_secrets_test.go b/flyteplugins/go/tasks/pluginmachinery/secret/global_secrets_test.go new file mode 100644 index 0000000000..12c5a5115a --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/global_secrets_test.go @@ -0,0 +1,100 @@ +package secret + +import ( + "context" + "fmt" + "testing" + + "github.com/go-test/deep" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + corev1 "k8s.io/api/core/v1" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/mocks" + coreIdl "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestGlobalSecrets_Inject(t *testing.T) { + secretFound := &mocks.GlobalSecretProvider{} + secretFound.OnGetForSecretMatch(mock.Anything, mock.Anything).Return("my_password", nil) + + secretNotFound := &mocks.GlobalSecretProvider{} + secretNotFound.OnGetForSecretMatch(mock.Anything, mock.Anything).Return("", fmt.Errorf("secret not found")) + + inputPod := corev1.Pod{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + { + Name: "container1", + }, + }, + }, + } + + successPod := corev1.Pod{ + Spec: corev1.PodSpec{ + InitContainers: []corev1.Container{}, + Containers: []corev1.Container{ + { + Name: "container1", + Env: []corev1.EnvVar{ + { + Name: config.DefaultSecretEnvVarPrefix + "GROUP_HELLO", + Value: "my_password", + }, + { + Name: "FLYTE_SECRETS_ENV_PREFIX", + Value: config.DefaultSecretEnvVarPrefix, + }, + }, + }, + }, + }, + } + + type args struct { + secret *coreIdl.Secret + p *corev1.Pod + } + tests := []struct { + name string + envSecretManager GlobalSecretProvider + args args + want *corev1.Pod + wantErr bool + }{ + {name: "require group", envSecretManager: secretFound, args: args{secret: &coreIdl.Secret{Key: "hello"}, p: &corev1.Pod{}}, + want: &corev1.Pod{}, wantErr: true}, + {name: "simple", envSecretManager: secretFound, args: args{secret: &coreIdl.Secret{Group: "group", Key: "hello"}, p: &inputPod}, + want: &successPod, wantErr: false}, + {name: "require file", envSecretManager: secretFound, args: args{secret: &coreIdl.Secret{Key: "hello", MountRequirement: coreIdl.Secret_FILE}, + p: &corev1.Pod{}}, + want: &corev1.Pod{}, wantErr: true}, + {name: "not found", envSecretManager: secretNotFound, args: args{secret: &coreIdl.Secret{Key: "hello", MountRequirement: coreIdl.Secret_FILE}, + p: &corev1.Pod{}}, + want: &corev1.Pod{}, wantErr: true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + g := GlobalSecrets{ + envSecretManager: tt.envSecretManager, + cfg: &config.Config{SecretEnvVarPrefix: config.DefaultSecretEnvVarPrefix}, + } + + assert.Equal(t, config.SecretManagerTypeGlobal, g.Type()) + + got, _, err := g.Inject(context.Background(), tt.args.secret, tt.args.p) + if (err != nil) != tt.wantErr { + t.Errorf("Inject() error = %v, wantErr %v", err, tt.wantErr) + return + } else if err != nil { + return + } + + if diff := deep.Equal(got, tt.want); diff != nil { + t.Errorf("Inject() Diff = %v\r\n got = %v\r\n want = %v", diff, got, tt.want) + } + }) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/imagepull_kubernetes_utils.go b/flyteplugins/go/tasks/pluginmachinery/secret/imagepull_kubernetes_utils.go new file mode 100644 index 0000000000..b5961dad60 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/imagepull_kubernetes_utils.go @@ -0,0 +1,96 @@ +package secret + +import ( + "crypto/sha256" + "fmt" + "regexp" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" +) + +const ( + imagePullPrefix = "img-pull" +) + +const ( + orgLabel = "union.ai/org" + projectLabel = "union.ai/project" + domainLabel = "union.ai/domain" + secretNameLabel = "union.ai/secret-name" + secretTypeLabel = "union.ai/secret-type" +) + +var ( + ImagePullLabels = map[string]string{ + secretTypeLabel: "image-pull-secret", + } +) + +// ToImagePullK8sName generates a Kubernetes secret name based on the provided secret name components. +// The name includes a consistent hash of the components to ensure uniqueness, be Kubernetes compliant, and avoid collisions. +func ToImagePullK8sName(components SecretNameComponents) string { + // Create a deterministic string representation of the components + componentStr := fmt.Sprintf("%s:%s:%s:%s", + components.Org, + components.Domain, + components.Project, + components.Name) + + // Create a hash of the components + h := sha256.New() + h.Write([]byte(componentStr)) + hash := fmt.Sprintf("%x", h.Sum(nil)) + return fmt.Sprintf("%s-%s", imagePullPrefix, hash[:16]) +} + +// ToImagePullK8sLabels generates a map of labels that can be used to identify the image pull Kubernetes secret. +// These labels are intended to supplement the hashed secret name and provide additional metadata. +func ToImagePullK8sLabels(components SecretNameComponents) map[string]string { + return utils.UnionMaps(ImagePullLabels, map[string]string{ + // TODO Create a function that cleans the values of the labels to be Kubernetes compliant + orgLabel: sanitizeLabelValue(components.Org), + projectLabel: sanitizeLabelValue(components.Project), + domainLabel: sanitizeLabelValue(components.Domain), + secretNameLabel: sanitizeLabelValue(components.Name), + }) +} + +// sanitizeLabelValue ensures that a label value conforms to Kubernetes label value requirements: +// - must be 63 characters or less +// - must begin and end with an alphanumeric character +// - may contain dots, dashes, and underscores +func sanitizeLabelValue(value string) string { + // If empty, return a default value + if value == "" { + return "none" + } + + // Replace invalid characters with dashes + re := regexp.MustCompile(`[^a-zA-Z0-9._-]`) + sanitized := re.ReplaceAllString(value, "-") + + // Ensure it starts with an alphanumeric character + re = regexp.MustCompile(`^[^a-zA-Z0-9]`) + if re.MatchString(sanitized) { + sanitized = "x" + sanitized[1:] + } + + // Ensure it ends with an alphanumeric character + re = regexp.MustCompile(`[^a-zA-Z0-9]$`) + if re.MatchString(sanitized) { + sanitized = sanitized[:len(sanitized)-1] + "x" + } + + // Truncate to 63 characters if needed + if len(sanitized) > 63 { + sanitized = sanitized[:63] + + // After truncation, ensure it still ends with an alphanumeric character + re = regexp.MustCompile(`[^a-zA-Z0-9]$`) + if re.MatchString(sanitized) { + sanitized = sanitized[:len(sanitized)-1] + "x" + } + } + + return sanitized +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/imagepull_kubernetes_utils_test.go b/flyteplugins/go/tasks/pluginmachinery/secret/imagepull_kubernetes_utils_test.go new file mode 100644 index 0000000000..89320cd163 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/imagepull_kubernetes_utils_test.go @@ -0,0 +1,247 @@ +package secret + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func Test_ToImagePullK8sName(t *testing.T) { + tests := []struct { + name string + components SecretNameComponents + expectedOutput string + }{ + { + name: "basic case", + components: SecretNameComponents{ + Org: "myorg", + Domain: "development", + Project: "myproject", + Name: "docker-registry", + }, + expectedOutput: "img-pull-93ec8baf1e7d7e87", + }, + { + name: "empty org", + components: SecretNameComponents{ + Org: "", + Domain: "development", + Project: "myproject", + Name: "docker-registry", + }, + expectedOutput: "img-pull-6d48430fc6e4845c", + }, + { + name: "all empty", + components: SecretNameComponents{ + Org: "", + Domain: "", + Project: "", + Name: "", + }, + expectedOutput: "img-pull-f1ae2a75ed1f9972", + }, + { + name: "special characters", + components: SecretNameComponents{ + Org: "my-org", + Domain: "dev.domain", + Project: "project_123", + Name: "docker@registry", + }, + expectedOutput: "img-pull-e0a5894d0b16a3c7", + }, + { + name: "long values", + components: SecretNameComponents{ + Org: "very-long-organization-name-that-exceeds-normal-length", + Domain: "development-domain-with-many-characters", + Project: "project-with-extremely-long-identifier-for-testing", + Name: "docker-registry-with-very-long-descriptive-name", + }, + expectedOutput: "img-pull-b1274c388a3edc4e", + }, + } + + t.Run("conversion", func(t *testing.T) { + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := ToImagePullK8sName(tt.components) + assert.Equal(t, tt.expectedOutput, result) + + // Verify the format meets Kubernetes naming requirements + assert.LessOrEqual(t, len(result), 63, "Name should be 63 chars or less") + assert.Regexp(t, "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$", result, "Name should match Kubernetes DNS naming convention") + }) + } + }) + + t.Run("should yield consistent results", func(t *testing.T) { + components := SecretNameComponents{ + Org: "testorg", + Domain: "testdomain", + Project: "testproject", + Name: "testsecret", + } + + firstResult := ToImagePullK8sName(components) + + // Call multiple times to ensure consistency + for i := 0; i < 10; i++ { + result := ToImagePullK8sName(components) + assert.Equal(t, firstResult, result, "Hash result should be consistent across calls") + } + }) +} + +func Test_ToImagePullK8sLabels(t *testing.T) { + tests := []struct { + name string + components SecretNameComponents + expectedLabels map[string]string + }{ + { + name: "basic case", + components: SecretNameComponents{ + Org: "myorg", + Domain: "development", + Project: "myproject", + Name: "docker-registry", + }, + expectedLabels: map[string]string{ + secretTypeLabel: "image-pull-secret", + orgLabel: "myorg", + domainLabel: "development", + projectLabel: "myproject", + secretNameLabel: "docker-registry", + }, + }, + { + name: "empty values", + components: SecretNameComponents{ + Org: "", + Domain: "", + Project: "", + Name: "", + }, + expectedLabels: map[string]string{ + secretTypeLabel: "image-pull-secret", + orgLabel: "none", + domainLabel: "none", + projectLabel: "none", + secretNameLabel: "none", + }, + }, + { + name: "special characters", + components: SecretNameComponents{ + Org: "my@org", + Domain: "dev.domain!", + Project: "project_123&", + Name: "docker@registry", + }, + expectedLabels: map[string]string{ + secretTypeLabel: "image-pull-secret", + orgLabel: "my-org", + domainLabel: "dev.domainx", + projectLabel: "project_123x", + secretNameLabel: "docker-registry", + }, + }, + { + name: "long values", + components: SecretNameComponents{ + Org: "very-long-organization-name-that-exceeds-normal-length-and-should-be-truncated", + Domain: "development-domain-with-many-characters-that-will-need-to-be-shortened", + Project: "project-with-extremely-long-identifier-for-testing-purposes-only", + Name: "docker-registry-with-very-long-descriptive-name-that-needs-truncation", + }, + expectedLabels: map[string]string{ + secretTypeLabel: "image-pull-secret", + orgLabel: "very-long-organization-name-that-exceeds-normal-length-and-shou", + domainLabel: "development-domain-with-many-characters-that-will-need-to-be-sh", + projectLabel: "project-with-extremely-long-identifier-for-testing-purposes-onl", + secretNameLabel: "docker-registry-with-very-long-descriptive-name-that-needs-trun", + }, + }, + { + name: "sanitization - starts with invalid character", + components: SecretNameComponents{ + Org: "-invalid-start", + Domain: "normal", + Project: "normal", + Name: "normal", + }, + expectedLabels: map[string]string{ + secretTypeLabel: "image-pull-secret", + orgLabel: "xinvalid-start", + domainLabel: "normal", + projectLabel: "normal", + secretNameLabel: "normal", + }, + }, + { + name: "sanitization - ends with invalid character", + components: SecretNameComponents{ + Org: "normal", + Domain: "normal", + Project: "invalid-end-", + Name: "normal", + }, + expectedLabels: map[string]string{ + secretTypeLabel: "image-pull-secret", + orgLabel: "normal", + domainLabel: "normal", + projectLabel: "invalid-endx", + secretNameLabel: "normal", + }, + }, + { + name: "sanitization - invalid characters", + components: SecretNameComponents{ + Org: "normal", + Domain: "normal", + Project: "normal", + Name: "invalid@#$%^&*()value", + }, + expectedLabels: map[string]string{ + secretTypeLabel: "image-pull-secret", + orgLabel: "normal", + domainLabel: "normal", + projectLabel: "normal", + secretNameLabel: "invalid---------value", + }, + }, + { + name: "sanitization - too long and ends with invalid after truncation", + components: SecretNameComponents{ + Org: "normal", + Domain: "this-is-a-very-long-label-value-that-exceeds-the-kubernetes-limit-of-sixty-three-", + Project: "normal", + Name: "normal", + }, + expectedLabels: map[string]string{ + secretTypeLabel: "image-pull-secret", + orgLabel: "normal", + domainLabel: "this-is-a-very-long-label-value-that-exceeds-the-kubernetes-lim", + projectLabel: "normal", + secretNameLabel: "normal", + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + labels := ToImagePullK8sLabels(tt.components) + assert.Equal(t, tt.expectedLabels, labels) + + // Verify all label values meet Kubernetes requirements + for k, value := range labels { + assert.LessOrEqual(t, len(value), 63, "Label value should be 63 chars or less: %s", k) + assert.Regexp(t, "^[a-zA-Z0-9]([-_.a-zA-Z0-9]*[a-zA-Z0-9])?$", value, + "Label value should match Kubernetes label value convention: %s", k) + } + }) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/k8s_secret_fetcher.go b/flyteplugins/go/tasks/pluginmachinery/secret/k8s_secret_fetcher.go new file mode 100644 index 0000000000..d92c4dc9c4 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/k8s_secret_fetcher.go @@ -0,0 +1,56 @@ +package secret + +import ( + "context" + "errors" + "fmt" + + k8sErrors "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + v1 "k8s.io/client-go/kubernetes/typed/core/v1" + + stdlibErrors "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +type K8sSecretFetcher struct { + secretClient v1.SecretInterface +} + +func (s K8sSecretFetcher) GetSecretValue(ctx context.Context, secretID string) (*SecretValue, error) { + logger.Infof(ctx, "Got fetch secret Request for %v!", secretID) + k8sSecretName := EncodeK8sSecretName(secretID) + secret, err := s.secretClient.Get(ctx, k8sSecretName, metav1.GetOptions{}) + + if err != nil { + if k8sErrors.IsNotFound(err) { + wrappedErr := stdlibErrors.Wrapf(ErrCodeSecretNotFound, err, fmt.Sprintf(SecretNotFoundErrorFormat, secretID)) + logger.Warn(ctx, wrappedErr) + return nil, wrappedErr + } else { + wrappedErr := stdlibErrors.Wrapf(ErrCodeSecretReadFailure, err, fmt.Sprintf(SecretReadFailureErrorFormat, secretID)) + logger.Error(ctx, wrappedErr) + return nil, wrappedErr + } + } + + if _, ok := secret.Data[secretID]; !ok { + wrappedErr := stdlibErrors.Wrapf(ErrCodeSecretNil, errors.New("secret data is nil"), fmt.Sprintf(SecretNilErrorFormat, secretID)) + logger.Error(ctx, wrappedErr) + return nil, wrappedErr + } + + // Since all keys and values are merged into the data field on write, we can just return the value in the data field. + secretValue := &SecretValue{ + BinaryValue: secret.Data[secretID], + } + + return secretValue, nil +} + +// NewK8sSecretFetcher creates a secret value fetcher for K8s +func NewK8sSecretFetcher(secretClient v1.SecretInterface) SecretFetcher { + return K8sSecretFetcher{ + secretClient: secretClient, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/k8s_secret_fetcher_test.go b/flyteplugins/go/tasks/pluginmachinery/secret/k8s_secret_fetcher_test.go new file mode 100644 index 0000000000..08e777e3dc --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/k8s_secret_fetcher_test.go @@ -0,0 +1,116 @@ +package secret + +import ( + "context" + "errors" + "fmt" + "testing" + + "github.com/samber/lo" + "github.com/stretchr/testify/assert" + v1 "k8s.io/api/core/v1" + k8sErrors "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/client-go/kubernetes/fake" + k8sTesting "k8s.io/client-go/testing" + + stdlibErrors "github.com/flyteorg/flyte/v2/flytestdlib/errors" +) + +const ( + testNamespace = "test-namespace" +) + +func TestGetSecretValue(t *testing.T) { + testCases := []struct { + name string + secretsName []string + targetSecretName string + expectSuccess bool + expectedError error + includeData bool + reactors []func(action k8sTesting.Action) (handled bool, ret runtime.Object, err error) + }{ + { + name: "Get Secret Successful", + secretsName: []string{ + "test-secret", + }, + targetSecretName: "test-secret", + expectSuccess: true, + expectedError: nil, + includeData: true, + }, + { + name: "Get Secret Not Found", + secretsName: []string{}, + targetSecretName: "test-secret", + expectSuccess: false, + expectedError: stdlibErrors.Wrapf(ErrCodeSecretNotFound, k8sErrors.NewNotFound(v1.Resource("secrets"), EncodeK8sSecretName("test-secret")), fmt.Sprintf(SecretNotFoundErrorFormat, "test-secret")), + includeData: false, + }, + { + name: "Get Secret Failed With Wrong Data", + secretsName: []string{ + "test-secret", + }, + targetSecretName: "test-secret", + expectSuccess: false, + expectedError: stdlibErrors.Wrapf(ErrCodeSecretNil, errors.New("secret data is nil"), fmt.Sprintf(SecretNilErrorFormat, "test-secret")), + includeData: false, + }, + { + name: "Get Secret Failed With K8s Client Error", + secretsName: []string{ + "test-secret", + }, + targetSecretName: "test-secret", + expectSuccess: false, + expectedError: stdlibErrors.Wrapf(ErrCodeSecretReadFailure, errors.New("k8s client error"), fmt.Sprintf(SecretReadFailureErrorFormat, "test-secret")), + includeData: false, + reactors: []func(action k8sTesting.Action) (handled bool, ret runtime.Object, err error){ + func(action k8sTesting.Action) (handled bool, ret runtime.Object, err error) { + if action.GetVerb() == "get" && action.GetResource().Resource == "secrets" { + return true, nil, errors.New("k8s client error") + } + return false, nil, nil + }, + }, + }, + } + for _, test := range testCases { + t.Run(test.name, func(t *testing.T) { + testSecrets := lo.Map(test.secretsName, func(secretName string, _ int) runtime.Object { + secret := &v1.Secret{ + ObjectMeta: metav1.ObjectMeta{ + Name: EncodeK8sSecretName(secretName), + Namespace: testNamespace, + }, + } + if test.includeData { + secret.Data = map[string][]byte{ + secretName: []byte(secretName), + } + } + return secret + }) + fakeClientset := fake.NewSimpleClientset(testSecrets...) + if len(test.reactors) > 0 { + for _, reactor := range test.reactors { + fakeClientset.PrependReactor("*", "secrets", reactor) + } + } + fetcher := NewK8sSecretFetcher(fakeClientset.CoreV1().Secrets(testNamespace)) + secret, err := fetcher.GetSecretValue(context.TODO(), test.targetSecretName) + if test.expectSuccess { + assert.NoError(t, err) + assert.NotNil(t, secret) + assert.Equal(t, []byte(test.targetSecretName), secret.BinaryValue) + } else { + assert.Error(t, err) + assert.Equal(t, test.expectedError.Error(), err.Error()) + } + }) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/k8s_secrets.go b/flyteplugins/go/tasks/pluginmachinery/secret/k8s_secrets.go new file mode 100644 index 0000000000..30b4dcd374 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/k8s_secrets.go @@ -0,0 +1,118 @@ +package secret + +import ( + "context" + "fmt" + "os" + "path/filepath" + + corev1 "k8s.io/api/core/v1" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const ( + EnvVarGroupKeySeparator = "_" +) + +var ( + K8sSecretPathPrefix = []string{string(os.PathSeparator), "etc", "flyte", "secrets"} +) + +// K8sSecretInjector allows injecting of secrets into pods by specifying either EnvVarSource or SecretVolumeSource in +// the Pod Spec. It'll, by default, mount secrets as files into pods. +// The current version does not allow mounting an entire secret object (with all keys inside it). It only supports mounting +// a single key from the referenced secret object. +// The secret.Group will be used to reference the k8s secret object, the Secret.Key will be used to reference a key inside +// and the secret.Version will be ignored. +// Environment variables will be named _UNION__. Files will be mounted on +// /etc/flyte/secrets// +type K8sSecretInjector struct { + cfg *config.Config +} + +func (i K8sSecretInjector) Type() config.SecretManagerType { + return config.SecretManagerTypeK8s +} + +func (i K8sSecretInjector) Inject(ctx context.Context, secret *core.Secret, p *corev1.Pod) (newP *corev1.Pod, injected bool, err error) { + if len(secret.Group) == 0 || len(secret.Key) == 0 { + return nil, false, fmt.Errorf("k8s Secrets Webhook require both key and group to be set. "+ + "Secret: [%v]", secret) + } + + switch secret.MountRequirement { + case core.Secret_ANY: + fallthrough + case core.Secret_FILE: + // Inject a Volume that to the pod and all of its containers and init containers that mounts the secret into a + // file. + + volume := CreateVolumeForSecret(secret) + p.Spec.Volumes = AppendVolume(p.Spec.Volumes, volume) + + // Mount the secret to all containers in the given pod. + mount := CreateVolumeMountForSecret(volume.Name, secret) + p.Spec.InitContainers = AppendVolumeMounts(p.Spec.InitContainers, mount) + p.Spec.Containers = AppendVolumeMounts(p.Spec.Containers, mount) + + // Set environment variable to let the container know where to find the mounted files. + defaultDirEnvVar := corev1.EnvVar{ + Name: SecretPathDefaultDirEnvVar, + Value: filepath.Join(K8sSecretPathPrefix...), + } + + p.Spec.InitContainers = AppendEnvVars(p.Spec.InitContainers, defaultDirEnvVar) + p.Spec.Containers = AppendEnvVars(p.Spec.Containers, defaultDirEnvVar) + + // Sets an empty prefix to let the containers know the file names will match the secret keys as-is. + prefixEnvVar := corev1.EnvVar{ + Name: SecretPathFilePrefixEnvVar, + Value: "", + } + + p.Spec.InitContainers = AppendEnvVars(p.Spec.InitContainers, prefixEnvVar) + p.Spec.Containers = AppendEnvVars(p.Spec.Containers, prefixEnvVar) + + if secret.GetEnvVar() != "" { + extraEnvVar := CreateVolumeMountEnvVarForSecretWithEnvName(secret) + p.Spec.InitContainers = AppendEnvVars(p.Spec.InitContainers, extraEnvVar) + p.Spec.Containers = AppendEnvVars(p.Spec.Containers, extraEnvVar) + } + + case core.Secret_ENV_VAR: + envVar := CreateEnvVarForSecret(secret, i.cfg.SecretEnvVarPrefix) + p.Spec.InitContainers = AppendEnvVars(p.Spec.InitContainers, envVar) + p.Spec.Containers = AppendEnvVars(p.Spec.Containers, envVar) + + if secret.GetEnvVar() != "" { + extraEnvVar := *envVar.DeepCopy() + extraEnvVar.Name = secret.GetEnvVar() + + p.Spec.InitContainers = AppendEnvVars(p.Spec.InitContainers, extraEnvVar) + p.Spec.Containers = AppendEnvVars(p.Spec.Containers, extraEnvVar) + } + + prefixEnvVar := corev1.EnvVar{ + Name: SecretEnvVarPrefix, + Value: i.cfg.SecretEnvVarPrefix, + } + + p.Spec.InitContainers = AppendEnvVars(p.Spec.InitContainers, prefixEnvVar) + p.Spec.Containers = AppendEnvVars(p.Spec.Containers, prefixEnvVar) + default: + err := fmt.Errorf("unrecognized mount requirement [%v] for secret [%v]", secret.MountRequirement.String(), secret.Key) + logger.Error(ctx, err) + return p, false, err + } + + return p, true, nil +} + +func NewK8sSecretsInjector(cfg *config.Config) K8sSecretInjector { + return K8sSecretInjector{ + cfg: cfg, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/k8s_secrets_test.go b/flyteplugins/go/tasks/pluginmachinery/secret/k8s_secrets_test.go new file mode 100644 index 0000000000..2703f44a57 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/k8s_secrets_test.go @@ -0,0 +1,321 @@ +package secret + +import ( + "context" + "testing" + + "github.com/go-test/deep" + corev1 "k8s.io/api/core/v1" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + coreIdl "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestK8sSecretInjector_Inject(t *testing.T) { + optional := true + + inputPod := corev1.Pod{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + { + Name: "container1", + }, + }, + }, + } + + successPodEnv := corev1.Pod{ + Spec: corev1.PodSpec{ + InitContainers: []corev1.Container{}, + Containers: []corev1.Container{ + { + Name: "container1", + Env: []corev1.EnvVar{ + { + Name: "FLYTE_SECRETS_ENV_PREFIX", + Value: config.DefaultSecretEnvVarPrefix, + }, + { + Name: config.DefaultSecretEnvVarPrefix + "GROUP_HELLO", + ValueFrom: &corev1.EnvVarSource{ + SecretKeyRef: &corev1.SecretKeySelector{ + Key: "HELLO", + LocalObjectReference: corev1.LocalObjectReference{ + Name: "grOUP", + }, + Optional: &optional, + }, + }, + }, + }, + }, + }, + }, + } + + successPodFile := corev1.Pod{ + Spec: corev1.PodSpec{ + Volumes: []corev1.Volume{ + { + Name: "m4ze5vkql3", + VolumeSource: corev1.VolumeSource{ + Secret: &corev1.SecretVolumeSource{ + SecretName: "grOUP", + Items: []corev1.KeyToPath{ + { + Key: "HELLO", + Path: "hello", + }, + }, + Optional: &optional, + }, + }, + }, + }, + InitContainers: []corev1.Container{}, + Containers: []corev1.Container{ + { + Name: "container1", + VolumeMounts: []corev1.VolumeMount{ + { + Name: "m4ze5vkql3", + MountPath: "/etc/flyte/secrets/group", + ReadOnly: true, + }, + }, + Env: []corev1.EnvVar{ + { + Name: "FLYTE_SECRETS_FILE_PREFIX", + }, + { + Name: "FLYTE_SECRETS_DEFAULT_DIR", + Value: "/etc/flyte/secrets", + }, + }, + }, + }, + }, + } + + successPodMultiFiles := corev1.Pod{ + Spec: corev1.PodSpec{ + Volumes: []corev1.Volume{ + { + Name: "m4ze5vkql3", + VolumeSource: corev1.VolumeSource{ + Secret: &corev1.SecretVolumeSource{ + SecretName: "grOUP", + Items: []corev1.KeyToPath{ + { + Key: "HELLO", + Path: "hello", + }, + { + Key: "world", + Path: "world", + }, + }, + Optional: &optional, + }, + }, + }, + }, + InitContainers: []corev1.Container{}, + Containers: []corev1.Container{ + { + Name: "container1", + VolumeMounts: []corev1.VolumeMount{ + { + Name: "m4ze5vkql3", + MountPath: "/etc/flyte/secrets/group", + ReadOnly: true, + }, + }, + Env: []corev1.EnvVar{ + { + Name: "FLYTE_SECRETS_FILE_PREFIX", + }, + { + Name: "FLYTE_SECRETS_DEFAULT_DIR", + Value: "/etc/flyte/secrets", + }, + }, + }, + }, + }, + } + + successPodFileAllKeys := corev1.Pod{ + Spec: corev1.PodSpec{ + Volumes: []corev1.Volume{ + { + Name: "hello", + VolumeSource: corev1.VolumeSource{ + Secret: &corev1.SecretVolumeSource{ + SecretName: "hello", + Optional: &optional, + }, + }, + }, + }, + InitContainers: []corev1.Container{}, + Containers: []corev1.Container{ + { + Name: "container1", + VolumeMounts: []corev1.VolumeMount{ + { + Name: "hello", + MountPath: "/etc/flyte/secrets/hello", + ReadOnly: true, + }, + }, + Env: []corev1.EnvVar{ + { + Name: "FLYTE_SECRETS_FILE_PREFIX", + }, + { + Name: "FLYTE_SECRETS_DEFAULT_DIR", + Value: "/etc/flyte/secrets", + }, + }, + }, + }, + }, + } + + successPodEnvWithEnvName := corev1.Pod{ + Spec: corev1.PodSpec{ + InitContainers: []corev1.Container{}, + Containers: []corev1.Container{ + { + Name: "container1", + Env: []corev1.EnvVar{ + { + Name: "FLYTE_SECRETS_ENV_PREFIX", + Value: config.DefaultSecretEnvVarPrefix, + }, + { + Name: "MY_CUSTOM_ENV", + ValueFrom: &corev1.EnvVarSource{ + SecretKeyRef: &corev1.SecretKeySelector{ + Key: "HELLO", + LocalObjectReference: corev1.LocalObjectReference{ + Name: "grOUP", + }, + Optional: &optional, + }, + }, + }, + { + Name: config.DefaultSecretEnvVarPrefix + "GROUP_HELLO", + ValueFrom: &corev1.EnvVarSource{ + SecretKeyRef: &corev1.SecretKeySelector{ + Key: "HELLO", + LocalObjectReference: corev1.LocalObjectReference{ + Name: "grOUP", + }, + Optional: &optional, + }, + }, + }, + }, + }, + }, + }, + } + + successPodFileWithName := corev1.Pod{ + Spec: corev1.PodSpec{ + Volumes: []corev1.Volume{ + { + Name: "m4ze5vkql3", + VolumeSource: corev1.VolumeSource{ + Secret: &corev1.SecretVolumeSource{ + SecretName: "grOUP", + Items: []corev1.KeyToPath{ + { + Key: "HELLO", + Path: "hello", + }, + }, + Optional: &optional, + }, + }, + }, + }, + InitContainers: []corev1.Container{}, + Containers: []corev1.Container{ + { + Name: "container1", + VolumeMounts: []corev1.VolumeMount{ + { + Name: "m4ze5vkql3", + MountPath: "/etc/flyte/secrets/group", + ReadOnly: true, + }, + }, + Env: []corev1.EnvVar{ + { + Name: "MY_CUSTOM_ENV", + Value: "/etc/flyte/secrets/group/hello", + }, + { + Name: "FLYTE_SECRETS_FILE_PREFIX", + }, + { + Name: "FLYTE_SECRETS_DEFAULT_DIR", + Value: "/etc/flyte/secrets", + }, + }, + }, + }, + }, + } + + ctx := context.Background() + type args struct { + secret *coreIdl.Secret + p *corev1.Pod + } + tests := []struct { + name string + args args + want *corev1.Pod + wantErr bool + }{ + {name: "require group", args: args{secret: &coreIdl.Secret{Key: "HELLO", MountRequirement: coreIdl.Secret_ENV_VAR}, p: &corev1.Pod{}}, + want: &corev1.Pod{}, wantErr: true}, + {name: "simple", args: args{secret: &coreIdl.Secret{Group: "grOUP", Key: "HELLO", MountRequirement: coreIdl.Secret_ENV_VAR}, p: inputPod.DeepCopy()}, + want: &successPodEnv, wantErr: false}, + {name: "simple with env_name", args: args{secret: &coreIdl.Secret{Group: "grOUP", Key: "HELLO", MountRequirement: coreIdl.Secret_ENV_VAR, EnvVar: "MY_CUSTOM_ENV"}, p: inputPod.DeepCopy()}, + want: &successPodEnvWithEnvName, wantErr: false}, + {name: "require file single", args: args{secret: &coreIdl.Secret{Group: "grOUP", Key: "HELLO", MountRequirement: coreIdl.Secret_FILE}, + p: inputPod.DeepCopy()}, + want: &successPodFile, wantErr: false}, + {name: "require file single with name", args: args{secret: &coreIdl.Secret{Group: "grOUP", Key: "HELLO", MountRequirement: coreIdl.Secret_FILE, EnvVar: "MY_CUSTOM_ENV"}, + p: inputPod.DeepCopy()}, + want: &successPodFileWithName, wantErr: false}, + {name: "require file multiple from same secret group", args: args{secret: &coreIdl.Secret{Group: "grOUP", Key: "world", MountRequirement: coreIdl.Secret_FILE}, + p: successPodFile.DeepCopy()}, + want: &successPodMultiFiles, wantErr: false}, + {name: "require file all keys", args: args{secret: &coreIdl.Secret{Key: "hello", MountRequirement: coreIdl.Secret_FILE}, + p: inputPod.DeepCopy()}, + want: &successPodFileAllKeys, wantErr: true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + i := K8sSecretInjector{cfg: &config.Config{SecretEnvVarPrefix: config.DefaultSecretEnvVarPrefix}} + got, _, err := i.Inject(ctx, tt.args.secret, tt.args.p) + if (err != nil) != tt.wantErr { + t.Errorf("Inject() error = %v, wantErr %v", err, tt.wantErr) + return + } else if err != nil { + return + } + + if diff := deep.Equal(got, tt.want); diff != nil { + t.Errorf("Inject() Diff = %v\r\n got = %v\r\n want = %v", diff, got, tt.want) + } + }) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/k8s_utils.go b/flyteplugins/go/tasks/pluginmachinery/secret/k8s_utils.go new file mode 100644 index 0000000000..f7eef423ea --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/k8s_utils.go @@ -0,0 +1,20 @@ +package secret + +import ( + "crypto/md5" // #nosec + "fmt" +) + +// A Kubernetes Secret object's name must be a valid DNS subdomain, which prohibits the use of "_". +// However, Union uses "__" to delimit contextual information. +// There are no restrictions on key names within a Kubernetes Secret object, +// so we can store the original secret name as a key inside the Secret. +// To ensure the Kubernetes Secret name complies with DNS subdomain rules, +// we can use a hash of the original secret name. +// Since this is just for avoid Kubernetes naming restrictions and not for security, +// we can use a simple hash function like MD5. +func EncodeK8sSecretName(secretName string) string { + hash := md5.Sum([]byte(secretName)) // #nosec + hashHex := fmt.Sprintf("%x", hash) + return hashHex +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/mocks/aws_secret_manager_client.go b/flyteplugins/go/tasks/pluginmachinery/secret/mocks/aws_secret_manager_client.go new file mode 100644 index 0000000000..345623b599 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/mocks/aws_secret_manager_client.go @@ -0,0 +1,64 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + + secretsmanager "github.com/aws/aws-sdk-go-v2/service/secretsmanager" +) + +// AWSSecretManagerClient is an autogenerated mock type for the AWSSecretManagerClient type +type AWSSecretManagerClient struct { + mock.Mock +} + +type AWSSecretManagerClient_GetSecretValue struct { + *mock.Call +} + +func (_m AWSSecretManagerClient_GetSecretValue) Return(_a0 *secretsmanager.GetSecretValueOutput, _a1 error) *AWSSecretManagerClient_GetSecretValue { + return &AWSSecretManagerClient_GetSecretValue{Call: _m.Call.Return(_a0, _a1)} +} + +func (_m *AWSSecretManagerClient) OnGetSecretValue(_a0 context.Context, _a1 *secretsmanager.GetSecretValueInput, _a2 ...func(*secretsmanager.Options)) *AWSSecretManagerClient_GetSecretValue { + c_call := _m.On("GetSecretValue", _a0, _a1, _a2) + return &AWSSecretManagerClient_GetSecretValue{Call: c_call} +} + +func (_m *AWSSecretManagerClient) OnGetSecretValueMatch(matchers ...interface{}) *AWSSecretManagerClient_GetSecretValue { + c_call := _m.On("GetSecretValue", matchers...) + return &AWSSecretManagerClient_GetSecretValue{Call: c_call} +} + +// GetSecretValue provides a mock function with given fields: _a0, _a1, _a2 +func (_m *AWSSecretManagerClient) GetSecretValue(_a0 context.Context, _a1 *secretsmanager.GetSecretValueInput, _a2 ...func(*secretsmanager.Options)) (*secretsmanager.GetSecretValueOutput, error) { + _va := make([]interface{}, len(_a2)) + for _i := range _a2 { + _va[_i] = _a2[_i] + } + var _ca []interface{} + _ca = append(_ca, _a0, _a1) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 *secretsmanager.GetSecretValueOutput + if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.GetSecretValueInput, ...func(*secretsmanager.Options)) *secretsmanager.GetSecretValueOutput); ok { + r0 = rf(_a0, _a1, _a2...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secretsmanager.GetSecretValueOutput) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.GetSecretValueInput, ...func(*secretsmanager.Options)) error); ok { + r1 = rf(_a0, _a1, _a2...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/mocks/azure_key_vault_client.go b/flyteplugins/go/tasks/pluginmachinery/secret/mocks/azure_key_vault_client.go new file mode 100644 index 0000000000..167fca770b --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/mocks/azure_key_vault_client.go @@ -0,0 +1,55 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + context "context" + + azsecrets "github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azsecrets" + + mock "github.com/stretchr/testify/mock" +) + +// AzureKeyVaultClient is an autogenerated mock type for the AzureKeyVaultClient type +type AzureKeyVaultClient struct { + mock.Mock +} + +type AzureKeyVaultClient_GetSecret struct { + *mock.Call +} + +func (_m AzureKeyVaultClient_GetSecret) Return(_a0 azsecrets.GetSecretResponse, _a1 error) *AzureKeyVaultClient_GetSecret { + return &AzureKeyVaultClient_GetSecret{Call: _m.Call.Return(_a0, _a1)} +} + +func (_m *AzureKeyVaultClient) OnGetSecret(ctx context.Context, name string, version string, options *azsecrets.GetSecretOptions) *AzureKeyVaultClient_GetSecret { + c_call := _m.On("GetSecret", ctx, name, version, options) + return &AzureKeyVaultClient_GetSecret{Call: c_call} +} + +func (_m *AzureKeyVaultClient) OnGetSecretMatch(matchers ...interface{}) *AzureKeyVaultClient_GetSecret { + c_call := _m.On("GetSecret", matchers...) + return &AzureKeyVaultClient_GetSecret{Call: c_call} +} + +// GetSecret provides a mock function with given fields: ctx, name, version, options +func (_m *AzureKeyVaultClient) GetSecret(ctx context.Context, name string, version string, options *azsecrets.GetSecretOptions) (azsecrets.GetSecretResponse, error) { + ret := _m.Called(ctx, name, version, options) + + var r0 azsecrets.GetSecretResponse + if rf, ok := ret.Get(0).(func(context.Context, string, string, *azsecrets.GetSecretOptions) azsecrets.GetSecretResponse); ok { + r0 = rf(ctx, name, version, options) + } else { + r0 = ret.Get(0).(azsecrets.GetSecretResponse) + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, string, string, *azsecrets.GetSecretOptions) error); ok { + r1 = rf(ctx, name, version, options) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/mocks/gcp_secret_manager_client.go b/flyteplugins/go/tasks/pluginmachinery/secret/mocks/gcp_secret_manager_client.go new file mode 100644 index 0000000000..c366d7976e --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/mocks/gcp_secret_manager_client.go @@ -0,0 +1,65 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + context "context" + + gax "github.com/googleapis/gax-go/v2" + mock "github.com/stretchr/testify/mock" + + secretmanagerpb "cloud.google.com/go/secretmanager/apiv1/secretmanagerpb" +) + +// GCPSecretManagerClient is an autogenerated mock type for the GCPSecretManagerClient type +type GCPSecretManagerClient struct { + mock.Mock +} + +type GCPSecretManagerClient_AccessSecretVersion struct { + *mock.Call +} + +func (_m GCPSecretManagerClient_AccessSecretVersion) Return(_a0 *secretmanagerpb.AccessSecretVersionResponse, _a1 error) *GCPSecretManagerClient_AccessSecretVersion { + return &GCPSecretManagerClient_AccessSecretVersion{Call: _m.Call.Return(_a0, _a1)} +} + +func (_m *GCPSecretManagerClient) OnAccessSecretVersion(ctx context.Context, req *secretmanagerpb.AccessSecretVersionRequest, opts ...gax.CallOption) *GCPSecretManagerClient_AccessSecretVersion { + c_call := _m.On("AccessSecretVersion", ctx, req, opts) + return &GCPSecretManagerClient_AccessSecretVersion{Call: c_call} +} + +func (_m *GCPSecretManagerClient) OnAccessSecretVersionMatch(matchers ...interface{}) *GCPSecretManagerClient_AccessSecretVersion { + c_call := _m.On("AccessSecretVersion", matchers...) + return &GCPSecretManagerClient_AccessSecretVersion{Call: c_call} +} + +// AccessSecretVersion provides a mock function with given fields: ctx, req, opts +func (_m *GCPSecretManagerClient) AccessSecretVersion(ctx context.Context, req *secretmanagerpb.AccessSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.AccessSecretVersionResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, req) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 *secretmanagerpb.AccessSecretVersionResponse + if rf, ok := ret.Get(0).(func(context.Context, *secretmanagerpb.AccessSecretVersionRequest, ...gax.CallOption) *secretmanagerpb.AccessSecretVersionResponse); ok { + r0 = rf(ctx, req, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secretmanagerpb.AccessSecretVersionResponse) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *secretmanagerpb.AccessSecretVersionRequest, ...gax.CallOption) error); ok { + r1 = rf(ctx, req, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/mocks/global_secret_provider.go b/flyteplugins/go/tasks/pluginmachinery/secret/mocks/global_secret_provider.go new file mode 100644 index 0000000000..6910772196 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/mocks/global_secret_provider.go @@ -0,0 +1,55 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +// GlobalSecretProvider is an autogenerated mock type for the GlobalSecretProvider type +type GlobalSecretProvider struct { + mock.Mock +} + +type GlobalSecretProvider_GetForSecret struct { + *mock.Call +} + +func (_m GlobalSecretProvider_GetForSecret) Return(_a0 string, _a1 error) *GlobalSecretProvider_GetForSecret { + return &GlobalSecretProvider_GetForSecret{Call: _m.Call.Return(_a0, _a1)} +} + +func (_m *GlobalSecretProvider) OnGetForSecret(ctx context.Context, _a1 *core.Secret) *GlobalSecretProvider_GetForSecret { + c_call := _m.On("GetForSecret", ctx, _a1) + return &GlobalSecretProvider_GetForSecret{Call: c_call} +} + +func (_m *GlobalSecretProvider) OnGetForSecretMatch(matchers ...interface{}) *GlobalSecretProvider_GetForSecret { + c_call := _m.On("GetForSecret", matchers...) + return &GlobalSecretProvider_GetForSecret{Call: c_call} +} + +// GetForSecret provides a mock function with given fields: ctx, _a1 +func (_m *GlobalSecretProvider) GetForSecret(ctx context.Context, _a1 *core.Secret) (string, error) { + ret := _m.Called(ctx, _a1) + + var r0 string + if rf, ok := ret.Get(0).(func(context.Context, *core.Secret) string); ok { + r0 = rf(ctx, _a1) + } else { + r0 = ret.Get(0).(string) + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *core.Secret) error); ok { + r1 = rf(ctx, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/mocks/mockable_controller_runtime_client.go b/flyteplugins/go/tasks/pluginmachinery/secret/mocks/mockable_controller_runtime_client.go new file mode 100644 index 0000000000..cd740c0fcb --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/mocks/mockable_controller_runtime_client.go @@ -0,0 +1,511 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + context "context" + + client "sigs.k8s.io/controller-runtime/pkg/client" + + meta "k8s.io/apimachinery/pkg/api/meta" + + mock "github.com/stretchr/testify/mock" + + runtime "k8s.io/apimachinery/pkg/runtime" + + schema "k8s.io/apimachinery/pkg/runtime/schema" + + types "k8s.io/apimachinery/pkg/types" +) + +// MockableControllerRuntimeClient is an autogenerated mock type for the MockableControllerRuntimeClient type +type MockableControllerRuntimeClient struct { + mock.Mock +} + +type MockableControllerRuntimeClient_Create struct { + *mock.Call +} + +func (_m MockableControllerRuntimeClient_Create) Return(_a0 error) *MockableControllerRuntimeClient_Create { + return &MockableControllerRuntimeClient_Create{Call: _m.Call.Return(_a0)} +} + +func (_m *MockableControllerRuntimeClient) OnCreate(ctx context.Context, obj client.Object, opts ...client.CreateOption) *MockableControllerRuntimeClient_Create { + c_call := _m.On("Create", ctx, obj, opts) + return &MockableControllerRuntimeClient_Create{Call: c_call} +} + +func (_m *MockableControllerRuntimeClient) OnCreateMatch(matchers ...interface{}) *MockableControllerRuntimeClient_Create { + c_call := _m.On("Create", matchers...) + return &MockableControllerRuntimeClient_Create{Call: c_call} +} + +// Create provides a mock function with given fields: ctx, obj, opts +func (_m *MockableControllerRuntimeClient) Create(ctx context.Context, obj client.Object, opts ...client.CreateOption) error { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, obj) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, client.Object, ...client.CreateOption) error); ok { + r0 = rf(ctx, obj, opts...) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +type MockableControllerRuntimeClient_Delete struct { + *mock.Call +} + +func (_m MockableControllerRuntimeClient_Delete) Return(_a0 error) *MockableControllerRuntimeClient_Delete { + return &MockableControllerRuntimeClient_Delete{Call: _m.Call.Return(_a0)} +} + +func (_m *MockableControllerRuntimeClient) OnDelete(ctx context.Context, obj client.Object, opts ...client.DeleteOption) *MockableControllerRuntimeClient_Delete { + c_call := _m.On("Delete", ctx, obj, opts) + return &MockableControllerRuntimeClient_Delete{Call: c_call} +} + +func (_m *MockableControllerRuntimeClient) OnDeleteMatch(matchers ...interface{}) *MockableControllerRuntimeClient_Delete { + c_call := _m.On("Delete", matchers...) + return &MockableControllerRuntimeClient_Delete{Call: c_call} +} + +// Delete provides a mock function with given fields: ctx, obj, opts +func (_m *MockableControllerRuntimeClient) Delete(ctx context.Context, obj client.Object, opts ...client.DeleteOption) error { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, obj) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, client.Object, ...client.DeleteOption) error); ok { + r0 = rf(ctx, obj, opts...) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +type MockableControllerRuntimeClient_DeleteAllOf struct { + *mock.Call +} + +func (_m MockableControllerRuntimeClient_DeleteAllOf) Return(_a0 error) *MockableControllerRuntimeClient_DeleteAllOf { + return &MockableControllerRuntimeClient_DeleteAllOf{Call: _m.Call.Return(_a0)} +} + +func (_m *MockableControllerRuntimeClient) OnDeleteAllOf(ctx context.Context, obj client.Object, opts ...client.DeleteAllOfOption) *MockableControllerRuntimeClient_DeleteAllOf { + c_call := _m.On("DeleteAllOf", ctx, obj, opts) + return &MockableControllerRuntimeClient_DeleteAllOf{Call: c_call} +} + +func (_m *MockableControllerRuntimeClient) OnDeleteAllOfMatch(matchers ...interface{}) *MockableControllerRuntimeClient_DeleteAllOf { + c_call := _m.On("DeleteAllOf", matchers...) + return &MockableControllerRuntimeClient_DeleteAllOf{Call: c_call} +} + +// DeleteAllOf provides a mock function with given fields: ctx, obj, opts +func (_m *MockableControllerRuntimeClient) DeleteAllOf(ctx context.Context, obj client.Object, opts ...client.DeleteAllOfOption) error { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, obj) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, client.Object, ...client.DeleteAllOfOption) error); ok { + r0 = rf(ctx, obj, opts...) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +type MockableControllerRuntimeClient_Get struct { + *mock.Call +} + +func (_m MockableControllerRuntimeClient_Get) Return(_a0 error) *MockableControllerRuntimeClient_Get { + return &MockableControllerRuntimeClient_Get{Call: _m.Call.Return(_a0)} +} + +func (_m *MockableControllerRuntimeClient) OnGet(ctx context.Context, key types.NamespacedName, obj client.Object, opts ...client.GetOption) *MockableControllerRuntimeClient_Get { + c_call := _m.On("Get", ctx, key, obj, opts) + return &MockableControllerRuntimeClient_Get{Call: c_call} +} + +func (_m *MockableControllerRuntimeClient) OnGetMatch(matchers ...interface{}) *MockableControllerRuntimeClient_Get { + c_call := _m.On("Get", matchers...) + return &MockableControllerRuntimeClient_Get{Call: c_call} +} + +// Get provides a mock function with given fields: ctx, key, obj, opts +func (_m *MockableControllerRuntimeClient) Get(ctx context.Context, key types.NamespacedName, obj client.Object, opts ...client.GetOption) error { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key, obj) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, types.NamespacedName, client.Object, ...client.GetOption) error); ok { + r0 = rf(ctx, key, obj, opts...) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +type MockableControllerRuntimeClient_GroupVersionKindFor struct { + *mock.Call +} + +func (_m MockableControllerRuntimeClient_GroupVersionKindFor) Return(_a0 schema.GroupVersionKind, _a1 error) *MockableControllerRuntimeClient_GroupVersionKindFor { + return &MockableControllerRuntimeClient_GroupVersionKindFor{Call: _m.Call.Return(_a0, _a1)} +} + +func (_m *MockableControllerRuntimeClient) OnGroupVersionKindFor(obj runtime.Object) *MockableControllerRuntimeClient_GroupVersionKindFor { + c_call := _m.On("GroupVersionKindFor", obj) + return &MockableControllerRuntimeClient_GroupVersionKindFor{Call: c_call} +} + +func (_m *MockableControllerRuntimeClient) OnGroupVersionKindForMatch(matchers ...interface{}) *MockableControllerRuntimeClient_GroupVersionKindFor { + c_call := _m.On("GroupVersionKindFor", matchers...) + return &MockableControllerRuntimeClient_GroupVersionKindFor{Call: c_call} +} + +// GroupVersionKindFor provides a mock function with given fields: obj +func (_m *MockableControllerRuntimeClient) GroupVersionKindFor(obj runtime.Object) (schema.GroupVersionKind, error) { + ret := _m.Called(obj) + + var r0 schema.GroupVersionKind + if rf, ok := ret.Get(0).(func(runtime.Object) schema.GroupVersionKind); ok { + r0 = rf(obj) + } else { + r0 = ret.Get(0).(schema.GroupVersionKind) + } + + var r1 error + if rf, ok := ret.Get(1).(func(runtime.Object) error); ok { + r1 = rf(obj) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +type MockableControllerRuntimeClient_IsObjectNamespaced struct { + *mock.Call +} + +func (_m MockableControllerRuntimeClient_IsObjectNamespaced) Return(_a0 bool, _a1 error) *MockableControllerRuntimeClient_IsObjectNamespaced { + return &MockableControllerRuntimeClient_IsObjectNamespaced{Call: _m.Call.Return(_a0, _a1)} +} + +func (_m *MockableControllerRuntimeClient) OnIsObjectNamespaced(obj runtime.Object) *MockableControllerRuntimeClient_IsObjectNamespaced { + c_call := _m.On("IsObjectNamespaced", obj) + return &MockableControllerRuntimeClient_IsObjectNamespaced{Call: c_call} +} + +func (_m *MockableControllerRuntimeClient) OnIsObjectNamespacedMatch(matchers ...interface{}) *MockableControllerRuntimeClient_IsObjectNamespaced { + c_call := _m.On("IsObjectNamespaced", matchers...) + return &MockableControllerRuntimeClient_IsObjectNamespaced{Call: c_call} +} + +// IsObjectNamespaced provides a mock function with given fields: obj +func (_m *MockableControllerRuntimeClient) IsObjectNamespaced(obj runtime.Object) (bool, error) { + ret := _m.Called(obj) + + var r0 bool + if rf, ok := ret.Get(0).(func(runtime.Object) bool); ok { + r0 = rf(obj) + } else { + r0 = ret.Get(0).(bool) + } + + var r1 error + if rf, ok := ret.Get(1).(func(runtime.Object) error); ok { + r1 = rf(obj) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +type MockableControllerRuntimeClient_List struct { + *mock.Call +} + +func (_m MockableControllerRuntimeClient_List) Return(_a0 error) *MockableControllerRuntimeClient_List { + return &MockableControllerRuntimeClient_List{Call: _m.Call.Return(_a0)} +} + +func (_m *MockableControllerRuntimeClient) OnList(ctx context.Context, list client.ObjectList, opts ...client.ListOption) *MockableControllerRuntimeClient_List { + c_call := _m.On("List", ctx, list, opts) + return &MockableControllerRuntimeClient_List{Call: c_call} +} + +func (_m *MockableControllerRuntimeClient) OnListMatch(matchers ...interface{}) *MockableControllerRuntimeClient_List { + c_call := _m.On("List", matchers...) + return &MockableControllerRuntimeClient_List{Call: c_call} +} + +// List provides a mock function with given fields: ctx, list, opts +func (_m *MockableControllerRuntimeClient) List(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, list) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, client.ObjectList, ...client.ListOption) error); ok { + r0 = rf(ctx, list, opts...) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +type MockableControllerRuntimeClient_Patch struct { + *mock.Call +} + +func (_m MockableControllerRuntimeClient_Patch) Return(_a0 error) *MockableControllerRuntimeClient_Patch { + return &MockableControllerRuntimeClient_Patch{Call: _m.Call.Return(_a0)} +} + +func (_m *MockableControllerRuntimeClient) OnPatch(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption) *MockableControllerRuntimeClient_Patch { + c_call := _m.On("Patch", ctx, obj, patch, opts) + return &MockableControllerRuntimeClient_Patch{Call: c_call} +} + +func (_m *MockableControllerRuntimeClient) OnPatchMatch(matchers ...interface{}) *MockableControllerRuntimeClient_Patch { + c_call := _m.On("Patch", matchers...) + return &MockableControllerRuntimeClient_Patch{Call: c_call} +} + +// Patch provides a mock function with given fields: ctx, obj, patch, opts +func (_m *MockableControllerRuntimeClient) Patch(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption) error { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, obj, patch) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, client.Object, client.Patch, ...client.PatchOption) error); ok { + r0 = rf(ctx, obj, patch, opts...) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +type MockableControllerRuntimeClient_RESTMapper struct { + *mock.Call +} + +func (_m MockableControllerRuntimeClient_RESTMapper) Return(_a0 meta.RESTMapper) *MockableControllerRuntimeClient_RESTMapper { + return &MockableControllerRuntimeClient_RESTMapper{Call: _m.Call.Return(_a0)} +} + +func (_m *MockableControllerRuntimeClient) OnRESTMapper() *MockableControllerRuntimeClient_RESTMapper { + c_call := _m.On("RESTMapper") + return &MockableControllerRuntimeClient_RESTMapper{Call: c_call} +} + +func (_m *MockableControllerRuntimeClient) OnRESTMapperMatch(matchers ...interface{}) *MockableControllerRuntimeClient_RESTMapper { + c_call := _m.On("RESTMapper", matchers...) + return &MockableControllerRuntimeClient_RESTMapper{Call: c_call} +} + +// RESTMapper provides a mock function with given fields: +func (_m *MockableControllerRuntimeClient) RESTMapper() meta.RESTMapper { + ret := _m.Called() + + var r0 meta.RESTMapper + if rf, ok := ret.Get(0).(func() meta.RESTMapper); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(meta.RESTMapper) + } + } + + return r0 +} + +type MockableControllerRuntimeClient_Scheme struct { + *mock.Call +} + +func (_m MockableControllerRuntimeClient_Scheme) Return(_a0 *runtime.Scheme) *MockableControllerRuntimeClient_Scheme { + return &MockableControllerRuntimeClient_Scheme{Call: _m.Call.Return(_a0)} +} + +func (_m *MockableControllerRuntimeClient) OnScheme() *MockableControllerRuntimeClient_Scheme { + c_call := _m.On("Scheme") + return &MockableControllerRuntimeClient_Scheme{Call: c_call} +} + +func (_m *MockableControllerRuntimeClient) OnSchemeMatch(matchers ...interface{}) *MockableControllerRuntimeClient_Scheme { + c_call := _m.On("Scheme", matchers...) + return &MockableControllerRuntimeClient_Scheme{Call: c_call} +} + +// Scheme provides a mock function with given fields: +func (_m *MockableControllerRuntimeClient) Scheme() *runtime.Scheme { + ret := _m.Called() + + var r0 *runtime.Scheme + if rf, ok := ret.Get(0).(func() *runtime.Scheme); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*runtime.Scheme) + } + } + + return r0 +} + +type MockableControllerRuntimeClient_Status struct { + *mock.Call +} + +func (_m MockableControllerRuntimeClient_Status) Return(_a0 client.SubResourceWriter) *MockableControllerRuntimeClient_Status { + return &MockableControllerRuntimeClient_Status{Call: _m.Call.Return(_a0)} +} + +func (_m *MockableControllerRuntimeClient) OnStatus() *MockableControllerRuntimeClient_Status { + c_call := _m.On("Status") + return &MockableControllerRuntimeClient_Status{Call: c_call} +} + +func (_m *MockableControllerRuntimeClient) OnStatusMatch(matchers ...interface{}) *MockableControllerRuntimeClient_Status { + c_call := _m.On("Status", matchers...) + return &MockableControllerRuntimeClient_Status{Call: c_call} +} + +// Status provides a mock function with given fields: +func (_m *MockableControllerRuntimeClient) Status() client.SubResourceWriter { + ret := _m.Called() + + var r0 client.SubResourceWriter + if rf, ok := ret.Get(0).(func() client.SubResourceWriter); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(client.SubResourceWriter) + } + } + + return r0 +} + +type MockableControllerRuntimeClient_SubResource struct { + *mock.Call +} + +func (_m MockableControllerRuntimeClient_SubResource) Return(_a0 client.SubResourceClient) *MockableControllerRuntimeClient_SubResource { + return &MockableControllerRuntimeClient_SubResource{Call: _m.Call.Return(_a0)} +} + +func (_m *MockableControllerRuntimeClient) OnSubResource(subResource string) *MockableControllerRuntimeClient_SubResource { + c_call := _m.On("SubResource", subResource) + return &MockableControllerRuntimeClient_SubResource{Call: c_call} +} + +func (_m *MockableControllerRuntimeClient) OnSubResourceMatch(matchers ...interface{}) *MockableControllerRuntimeClient_SubResource { + c_call := _m.On("SubResource", matchers...) + return &MockableControllerRuntimeClient_SubResource{Call: c_call} +} + +// SubResource provides a mock function with given fields: subResource +func (_m *MockableControllerRuntimeClient) SubResource(subResource string) client.SubResourceClient { + ret := _m.Called(subResource) + + var r0 client.SubResourceClient + if rf, ok := ret.Get(0).(func(string) client.SubResourceClient); ok { + r0 = rf(subResource) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(client.SubResourceClient) + } + } + + return r0 +} + +type MockableControllerRuntimeClient_Update struct { + *mock.Call +} + +func (_m MockableControllerRuntimeClient_Update) Return(_a0 error) *MockableControllerRuntimeClient_Update { + return &MockableControllerRuntimeClient_Update{Call: _m.Call.Return(_a0)} +} + +func (_m *MockableControllerRuntimeClient) OnUpdate(ctx context.Context, obj client.Object, opts ...client.UpdateOption) *MockableControllerRuntimeClient_Update { + c_call := _m.On("Update", ctx, obj, opts) + return &MockableControllerRuntimeClient_Update{Call: c_call} +} + +func (_m *MockableControllerRuntimeClient) OnUpdateMatch(matchers ...interface{}) *MockableControllerRuntimeClient_Update { + c_call := _m.On("Update", matchers...) + return &MockableControllerRuntimeClient_Update{Call: c_call} +} + +// Update provides a mock function with given fields: ctx, obj, opts +func (_m *MockableControllerRuntimeClient) Update(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, obj) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, client.Object, ...client.UpdateOption) error); ok { + r0 = rf(ctx, obj, opts...) + } else { + r0 = ret.Error(0) + } + + return r0 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/mocks/secrets_injector.go b/flyteplugins/go/tasks/pluginmachinery/secret/mocks/secrets_injector.go new file mode 100644 index 0000000000..24de0e5ad0 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/mocks/secrets_injector.go @@ -0,0 +1,100 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + context "context" + + config "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + + mock "github.com/stretchr/testify/mock" + + v1 "k8s.io/api/core/v1" +) + +// SecretsInjector is an autogenerated mock type for the SecretsInjector type +type SecretsInjector struct { + mock.Mock +} + +type SecretsInjector_Inject struct { + *mock.Call +} + +func (_m SecretsInjector_Inject) Return(newP *v1.Pod, injected bool, err error) *SecretsInjector_Inject { + return &SecretsInjector_Inject{Call: _m.Call.Return(newP, injected, err)} +} + +func (_m *SecretsInjector) OnInject(ctx context.Context, secrets *core.Secret, p *v1.Pod) *SecretsInjector_Inject { + c_call := _m.On("Inject", ctx, secrets, p) + return &SecretsInjector_Inject{Call: c_call} +} + +func (_m *SecretsInjector) OnInjectMatch(matchers ...interface{}) *SecretsInjector_Inject { + c_call := _m.On("Inject", matchers...) + return &SecretsInjector_Inject{Call: c_call} +} + +// Inject provides a mock function with given fields: ctx, secrets, p +func (_m *SecretsInjector) Inject(ctx context.Context, secrets *core.Secret, p *v1.Pod) (*v1.Pod, bool, error) { + ret := _m.Called(ctx, secrets, p) + + var r0 *v1.Pod + if rf, ok := ret.Get(0).(func(context.Context, *core.Secret, *v1.Pod) *v1.Pod); ok { + r0 = rf(ctx, secrets, p) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v1.Pod) + } + } + + var r1 bool + if rf, ok := ret.Get(1).(func(context.Context, *core.Secret, *v1.Pod) bool); ok { + r1 = rf(ctx, secrets, p) + } else { + r1 = ret.Get(1).(bool) + } + + var r2 error + if rf, ok := ret.Get(2).(func(context.Context, *core.Secret, *v1.Pod) error); ok { + r2 = rf(ctx, secrets, p) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +type SecretsInjector_Type struct { + *mock.Call +} + +func (_m SecretsInjector_Type) Return(_a0 config.SecretManagerType) *SecretsInjector_Type { + return &SecretsInjector_Type{Call: _m.Call.Return(_a0)} +} + +func (_m *SecretsInjector) OnType() *SecretsInjector_Type { + c_call := _m.On("Type") + return &SecretsInjector_Type{Call: c_call} +} + +func (_m *SecretsInjector) OnTypeMatch(matchers ...interface{}) *SecretsInjector_Type { + c_call := _m.On("Type", matchers...) + return &SecretsInjector_Type{Call: c_call} +} + +// Type provides a mock function with given fields: +func (_m *SecretsInjector) Type() config.SecretManagerType { + ret := _m.Called() + + var r0 config.SecretManagerType + if rf, ok := ret.Get(0).(func() config.SecretManagerType); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(config.SecretManagerType) + } + + return r0 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/secret_fetcher.go b/flyteplugins/go/tasks/pluginmachinery/secret/secret_fetcher.go new file mode 100644 index 0000000000..6b73ccd9b0 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/secret_fetcher.go @@ -0,0 +1,81 @@ +package secret + +import ( + "context" + "fmt" + + gcpsm "cloud.google.com/go/secretmanager/apiv1" + awsConfig "github.com/aws/aws-sdk-go-v2/config" + awssm "github.com/aws/aws-sdk-go-v2/service/secretsmanager" + "k8s.io/client-go/kubernetes" + "k8s.io/client-go/rest" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +type SecretFetcher interface { + GetSecretValue(ctx context.Context, secretID string) (*SecretValue, error) +} + +type SecretValue struct { + StringValue string + BinaryValue []byte +} + +func NewSecretFetcher(ctx context.Context, cfg config.EmbeddedSecretManagerConfig) (SecretFetcher, error) { + switch cfg.Type { + case config.EmbeddedSecretManagerTypeAWS: + awsCfg, err := awsConfig.LoadDefaultConfig(ctx, awsConfig.WithRegion(cfg.AWSConfig.Region)) + if err != nil { + logger.Errorf(ctx, "failed to start secret manager service due to %v", err) + return nil, fmt.Errorf("failed to start secret manager service due to %v", err) + } + return NewAWSSecretFetcher(cfg.AWSConfig, awssm.NewFromConfig(awsCfg)), nil + case config.EmbeddedSecretManagerTypeGCP: + gcpSmClient, err := gcpsm.NewClient(ctx) + if err != nil { + logger.Errorf(ctx, "failed to start secret manager service due to %v", err) + return nil, fmt.Errorf("failed to start secret manager service due to %v", err) + } + return NewGCPSecretFetcher(cfg.GCPConfig, gcpSmClient), nil + case config.EmbeddedSecretManagerTypeAzure: + client, err := getAzureKVSecretsClient(cfg.AzureConfig.VaultURI) + if err != nil { + logger.Errorf(ctx, "failed to start secret manager service due to %v", err) + return nil, fmt.Errorf("failed to start secret manager service due to %v", err) + } + logger.Info(ctx, "Using Union Azure Secret Name Codec") + return NewAzureSecretFetcher(client), nil + case config.EmbeddedSecretManagerTypeK8s: + logger.Infof(ctx, "use k8s secret manager service") + kubeConfig, err := rest.InClusterConfig() + if err != nil { + logger.Errorf(ctx, "Failed to get kubernetes config: %v", err) + return nil, fmt.Errorf("failed to start secret manager service due to %v", err) + } + // Config is already resolved + if cfg.K8sConfig.KubeClientConfig.QPS > 0 { + kubeConfig.QPS = float32(cfg.K8sConfig.KubeClientConfig.QPS) + logger.Infof(ctx, "K8s secret fetcher using QPS: %v", kubeConfig.QPS) + } + if cfg.K8sConfig.KubeClientConfig.Burst > 0 { + kubeConfig.Burst = cfg.K8sConfig.KubeClientConfig.Burst + logger.Infof(ctx, "K8s secret fetcher using Burst: %v", kubeConfig.Burst) + } + if cfg.K8sConfig.KubeClientConfig.Timeout.Duration > 0 { + kubeConfig.Timeout = cfg.K8sConfig.KubeClientConfig.Timeout.Duration + logger.Infof(ctx, "K8s secret fetcher using Timeout: %v", kubeConfig.Timeout) + } + + kubeClientset, err := kubernetes.NewForConfig(kubeConfig) + if err != nil { + logger.Errorf(ctx, "Failed to create kubernetes clientset: %v", err) + return nil, fmt.Errorf("failed to start secret manager service due to %v", err) + } + secretClient := kubeClientset.CoreV1().Secrets(cfg.K8sConfig.Namespace) + return NewK8sSecretFetcher(secretClient), nil + } + + return nil, fmt.Errorf("failed to start secret fetcher service due to unsupported type %v. Only supported for aws and gcp right now", cfg.Type) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/secret_manager_client.go b/flyteplugins/go/tasks/pluginmachinery/secret/secret_manager_client.go new file mode 100644 index 0000000000..fc8629bc5c --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/secret_manager_client.go @@ -0,0 +1,31 @@ +package secret + +import ( + "context" + + "cloud.google.com/go/secretmanager/apiv1/secretmanagerpb" + "github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azsecrets" + "github.com/aws/aws-sdk-go-v2/service/secretsmanager" + "github.com/googleapis/gax-go/v2" +) + +//go:generate mockery --output=./mocks --case=underscore -name=AWSSecretManagerClient + +// AWSSecretManagerClient AWS Secret Manager API interface used in the webhook for looking up the secret to mount on the user pod. +type AWSSecretManagerClient interface { + GetSecretValue(context.Context, *secretsmanager.GetSecretValueInput, ...func(*secretsmanager.Options)) (*secretsmanager.GetSecretValueOutput, error) +} + +// GCPSecretManagerClient GCP Secret Manager API interface used in the webhook for looking up the secret to mount on the user pod. +// +//go:generate mockery --output=./mocks --case=underscore -name=GCPSecretManagerClient +type GCPSecretManagerClient interface { + AccessSecretVersion(ctx context.Context, req *secretmanagerpb.AccessSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.AccessSecretVersionResponse, error) +} + +// AzureKeyVaultClient Azure Key Vault API interface used in the webhook for looking up the secret to mount on the user pod. +// +//go:generate mockery --output=./mocks --case=underscore -name=AzureKeyVaultClient +type AzureKeyVaultClient interface { + GetSecret(ctx context.Context, name string, version string, options *azsecrets.GetSecretOptions) (azsecrets.GetSecretResponse, error) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/secrets_injector.go b/flyteplugins/go/tasks/pluginmachinery/secret/secrets_injector.go new file mode 100644 index 0000000000..033e6005ed --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/secrets_injector.go @@ -0,0 +1,103 @@ +package secret + +import ( + "context" + "fmt" + + corev1 "k8s.io/api/core/v1" + k8sRuntime "k8s.io/apimachinery/pkg/runtime" + "k8s.io/client-go/rest" + "sigs.k8s.io/controller-runtime/pkg/client" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secretmanager" + stdlibCache "github.com/flyteorg/flyte/v2/flytestdlib/cache" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +//go:generate mockery --output=./mocks --case=underscore --name=SecretsInjector +type SecretsInjector interface { + Type() config.SecretManagerType + Inject(ctx context.Context, secrets *core.Secret, p *corev1.Pod) (newP *corev1.Pod, injected bool, err error) +} + +func newSecretsInjector( + ctx context.Context, + secretManagerType config.SecretManagerType, + webhookConfig *config.Config, + globalSecretManagerConfig *secretmanager.Config, + podNamespace string, + scope promutils.Scope, +) (SecretsInjector, error) { + switch secretManagerType { + case config.SecretManagerTypeGlobal: + return NewGlobalSecrets(secretmanager.NewFileEnvSecretManager(globalSecretManagerConfig), webhookConfig), nil + case config.SecretManagerTypeK8s: + return NewK8sSecretsInjector(webhookConfig), nil + case config.SecretManagerTypeAWS: + return NewAWSSecretManagerInjector(webhookConfig.AWSSecretManagerConfig), nil + case config.SecretManagerTypeGCP: + return NewGCPSecretManagerInjector(webhookConfig.GCPSecretManagerConfig), nil + case config.SecretManagerTypeVault: + return NewVaultSecretManagerInjector(webhookConfig.VaultSecretManagerConfig), nil + case config.SecretManagerTypeEmbedded: + kubeConfig, err := rest.InClusterConfig() + if err != nil { + logger.Errorf(ctx, "Failed to get kubernetes config: %v", err) + return nil, fmt.Errorf("failed to start secret manager service due to %v", err) + } + if webhookConfig.KubeClientConfig.QPS > 0 { + kubeConfig.QPS = float32(webhookConfig.KubeClientConfig.QPS) + } + if webhookConfig.KubeClientConfig.Burst > 0 { + kubeConfig.Burst = webhookConfig.KubeClientConfig.Burst + } + if webhookConfig.KubeClientConfig.Timeout.Duration > 0 { + kubeConfig.Timeout = webhookConfig.KubeClientConfig.Timeout.Duration + } + // Initialize controller-runtime client + ctrlRuntimeScheme := k8sRuntime.NewScheme() + if err := corev1.AddToScheme(ctrlRuntimeScheme); err != nil { + logger.Errorf(ctx, "Failed to add core v1 to scheme: %v", err) + return nil, fmt.Errorf("failed to add core v1 to scheme: %w", err) + } + + ctrlRuntimeClient, err := client.New(kubeConfig, client.Options{ + Scheme: ctrlRuntimeScheme, + }) + if err != nil { + return nil, fmt.Errorf("failed to create controller-runtime client: %w", err) + } + + var secretFetchers []SecretFetcher + secretFetcher, err := NewSecretFetcher(ctx, webhookConfig.EmbeddedSecretManagerConfig) + if err != nil { + return nil, err + } + + secretFetchers = append(secretFetchers, secretFetcher) + + cacheConfig := stdlibCache.GetConfig() + cacheFactory, err := stdlibCache.NewFactory(ctx, cacheConfig, + nil, scope.NewSubScope("secret_cache")) + if err != nil { + logger.Errorf(ctx, "Failed to create cache factory: %v", err) + return nil, fmt.Errorf("failed to create cache factory: %w", err) + } + + secretCache, err := stdlibCache.New[SecretValue]("secret_cache", cacheConfig.Type, cacheFactory, nil, scope.NewSubScope("secret_value")) + if err != nil { + logger.Errorf(ctx, "Failed to create secret cache: %v", err) + return nil, fmt.Errorf("failed to create secret cache: %w", err) + } + + return NewEmbeddedSecretManagerInjector(webhookConfig.EmbeddedSecretManagerConfig, secretFetchers, + ctrlRuntimeClient, podNamespace, secretCache, webhookConfig), nil + case config.SecretManagerTypeAzure: + return NewAzureSecretManagerInjector(webhookConfig.AzureSecretManagerConfig), nil + default: + return nil, fmt.Errorf("unrecognized secret manager type [%v]", secretManagerType) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/secrets_pod_mutator.go b/flyteplugins/go/tasks/pluginmachinery/secret/secrets_pod_mutator.go new file mode 100644 index 0000000000..59c5bdedef --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/secrets_pod_mutator.go @@ -0,0 +1,127 @@ +package secret + +import ( + "context" + "fmt" + "net/http" + + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "sigs.k8s.io/controller-runtime/pkg/webhook/admission" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secretmanager" + secretUtils "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils/secrets" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const ( + SecretPathDefaultDirEnvVar = "FLYTE_SECRETS_DEFAULT_DIR" // #nosec + SecretPathFilePrefixEnvVar = "FLYTE_SECRETS_FILE_PREFIX" // #nosec + SecretEnvVarPrefix = "FLYTE_SECRETS_ENV_PREFIX" // #nosec + SecretsID = "secrets" +) + +const ( + // NotFoundAcrossAllScopesMsg is the error message prefix returned when a secret is not found across all scopes, + // and is used to match on errors. + NotFoundAcrossAllScopesMsg = "none of the secret managers injected secret" +) + +type SecretsPodMutator struct { + // Secret manager types in order that they should be used. + enabledSecretManagerTypes []config.SecretManagerType + + // It is expected that this map contains a key for every element in enabledSecretManagerTypes. + injectors map[config.SecretManagerType]SecretsInjector +} + +func (s SecretsPodMutator) ID() string { + return SecretsID +} + +func (s *SecretsPodMutator) Mutate(ctx context.Context, pod *corev1.Pod) (newP *corev1.Pod, podChanged bool, errResponse *admission.Response) { + secrets, err := secretUtils.UnmarshalStringMapToSecrets(pod.GetAnnotations()) + if err != nil { + admissionError := admission.Errored(http.StatusBadRequest, fmt.Errorf("failed to unmarshal secrets from pod annotations: %w", err)) + return pod, false, &admissionError + } + + for _, secret := range secrets { + mutatedPod, injected, err := s.injectSecret(ctx, secret, pod) + if !injected { + if err == nil { + err = fmt.Errorf("%s [%v]", NotFoundAcrossAllScopesMsg, secret) + } else { + err = fmt.Errorf("%s [%v]: %w", NotFoundAcrossAllScopesMsg, secret, err) + } + admissionError := admission.Errored(http.StatusBadRequest, err) + return pod, false, &admissionError + } + + pod = mutatedPod + } + + return pod, len(secrets) > 0, nil +} + +func (s *SecretsPodMutator) LabelSelector() *metav1.LabelSelector { + return &metav1.LabelSelector{ + MatchLabels: map[string]string{ + secretUtils.PodLabel: secretUtils.PodLabelValue, + }, + } +} + +func (s *SecretsPodMutator) injectSecret(ctx context.Context, secret *core.Secret, pod *corev1.Pod) (*corev1.Pod, bool /*injected*/, error) { + logger.Debugf(ctx, "Injecting secret [%v].", secret) + for _, secretManagerType := range s.enabledSecretManagerTypes { + injector := s.injectors[secretManagerType] + + mutatedPod, injected, err := injector.Inject(ctx, secret, pod) + logger.Debugf( + ctx, + "injection result with injector type [%v]: injected = [%v], error = [%v].", + injector.Type(), injected, err) + + if err != nil { + continue + } + if injected { + return mutatedPod, true, nil + } + } + + err := fmt.Errorf("failed to inject secret [%v] using any of the enabled secret managers: %v. Possible reasons: the secret cannot be found or an internal error occurred", secret, s.enabledSecretManagerTypes) + return pod, false, err +} + +// NewSecretsMutator creates a new SecretsMutator with all available plugins. +func NewSecretsMutator(ctx context.Context, cfg *config.Config, podNamespace string, scope promutils.Scope) (*SecretsPodMutator, error) { + enabledSecretManagerTypes := []config.SecretManagerType{ + config.SecretManagerTypeGlobal, + } + if len(cfg.SecretManagerTypes) != 0 { + enabledSecretManagerTypes = append(enabledSecretManagerTypes, cfg.SecretManagerTypes...) + } else { + enabledSecretManagerTypes = append(enabledSecretManagerTypes, cfg.SecretManagerType) + } + + injectors := make(map[config.SecretManagerType]SecretsInjector, len(enabledSecretManagerTypes)) + globalSecretManagerConfig := secretmanager.GetConfig() + for _, secretManagerType := range enabledSecretManagerTypes { + injector, err := newSecretsInjector(ctx, secretManagerType, cfg, globalSecretManagerConfig, podNamespace, + scope.NewSubScope("secret_injector")) + if err != nil { + return nil, err + } + injectors[secretManagerType] = injector + } + + return &SecretsPodMutator{ + enabledSecretManagerTypes, + injectors, + }, nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/secrets_test.go b/flyteplugins/go/tasks/pluginmachinery/secret/secrets_test.go new file mode 100644 index 0000000000..3ef65389ee --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/secrets_test.go @@ -0,0 +1,69 @@ +package secret + +import ( + "context" + "fmt" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + corev1 "k8s.io/api/core/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/mocks" +) + +func TestSecretsWebhook_Mutate(t *testing.T) { + t.Run("No injectors", func(t *testing.T) { + m := SecretsPodMutator{} + _, changed, err := m.Mutate(context.Background(), &corev1.Pod{}) + assert.Nil(t, err) + assert.False(t, changed) + }) + + namespace := "test-namespace" + podWithAnnotations := &corev1.Pod{ + ObjectMeta: v1.ObjectMeta{ + Namespace: namespace, + Annotations: map[string]string{ + "flyte.secrets/s0": "nnsxsorcnv4v623fperca", + }, + }, + } + + t.Run("First fail", func(t *testing.T) { + mutator := &mocks.SecretsInjector{} + mutator.OnInjectMatch(mock.Anything, mock.Anything, mock.Anything).Return(nil, false, fmt.Errorf("failed")) + mutator.OnType().Return(config.SecretManagerTypeGlobal) + + m := SecretsPodMutator{ + enabledSecretManagerTypes: []config.SecretManagerType{config.SecretManagerTypeGlobal}, + injectors: map[config.SecretManagerType]SecretsInjector{ + config.SecretManagerTypeGlobal: mutator, + }, + } + + _, changed, err := m.Mutate(context.Background(), podWithAnnotations.DeepCopy()) + assert.NotNil(t, err) + assert.False(t, changed) + }) + + t.Run("added", func(t *testing.T) { + mutator := &mocks.SecretsInjector{} + mutator.OnInjectMatch(mock.Anything, mock.Anything, mock.Anything).Return(&corev1.Pod{}, true, nil) + mutator.OnType().Return(config.SecretManagerTypeGlobal) + ctx := context.Background() + + m := SecretsPodMutator{ + enabledSecretManagerTypes: []config.SecretManagerType{config.SecretManagerTypeGlobal}, + injectors: map[config.SecretManagerType]SecretsInjector{ + config.SecretManagerTypeGlobal: mutator, + }, + } + + _, changed, err := m.Mutate(ctx, podWithAnnotations.DeepCopy()) + assert.Nil(t, err) + assert.True(t, changed) + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/utils.go b/flyteplugins/go/tasks/pluginmachinery/secret/utils.go new file mode 100644 index 0000000000..7b3928a5a1 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/utils.go @@ -0,0 +1,246 @@ +package secret + +import ( + "errors" + "fmt" + "path/filepath" + "strings" + + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/util/uuid" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/encoding" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const ( + secretFieldSeparator = "__" + valueFormatter = "%s" + secretsStorageUnionPrefix = "u" + secretsOrgDelimiter = "org" + secretsDomainDelimiter = "domain" + secretsProjectDelimiter = "project" + secretsKeyDelimiter = "key" + secretsStorageOrgPrefixFormat = secretsStorageUnionPrefix + secretFieldSeparator + secretsOrgDelimiter + secretFieldSeparator + valueFormatter + secretsStorageDomainPrefixFormat = secretsStorageOrgPrefixFormat + secretFieldSeparator + secretsDomainDelimiter + secretFieldSeparator + valueFormatter + secretsStorageProjectPrefixFormat = secretsStorageDomainPrefixFormat + secretFieldSeparator + secretsProjectDelimiter + secretFieldSeparator + valueFormatter + secretsStorageFormat = secretsStorageProjectPrefixFormat + secretFieldSeparator + secretsKeyDelimiter + secretFieldSeparator + valueFormatter + + secretNameInvalidNotEnoughPartsMsg = "secret name has an invalid format: not enough parts" + secretNameInvalidUnexpectedPartsMsg = "secret name has an invalid format: unexpected parts" +) + +// If env var exists in the existing list of envVars then return the index for it or else return -1 +func hasEnvVar(envVars []corev1.EnvVar, envVarKey string) int { + for index, e := range envVars { + if e.Name == envVarKey { + return index + } + } + + return -1 +} + +func CreateEnvVarForSecret(secret *core.Secret, envVarPrefix string) corev1.EnvVar { + optional := true + return corev1.EnvVar{ + Name: strings.ToUpper(envVarPrefix + secret.Group + EnvVarGroupKeySeparator + secret.Key), + ValueFrom: &corev1.EnvVarSource{ + SecretKeyRef: &corev1.SecretKeySelector{ + LocalObjectReference: corev1.LocalObjectReference{ + Name: secret.Group, + }, + Key: secret.Key, + Optional: &optional, + }, + }, + } +} + +func CreateVolumeForSecret(secret *core.Secret) corev1.Volume { + optional := true + return corev1.Volume{ + // we don't want to create different volume for the same secret group + Name: encoding.Base32Encoder.EncodeToString([]byte(secret.Group + EnvVarGroupKeySeparator + secret.GroupVersion)), + VolumeSource: corev1.VolumeSource{ + Secret: &corev1.SecretVolumeSource{ + SecretName: secret.Group, + Items: []corev1.KeyToPath{ + { + Key: secret.Key, + Path: strings.ToLower(secret.Key), + }, + }, + Optional: &optional, + }, + }, + } +} + +func CreateVolumeMountForSecret(volumeName string, secret *core.Secret) corev1.VolumeMount { + return corev1.VolumeMount{ + Name: volumeName, + ReadOnly: true, + MountPath: filepath.Join(filepath.Join(K8sSecretPathPrefix...), strings.ToLower(secret.Group)), + } +} + +func CreateVolumeMountEnvVarForSecretWithEnvName(secret *core.Secret) corev1.EnvVar { + return corev1.EnvVar{ + Name: secret.GetEnvVar(), + Value: filepath.Join(filepath.Join(K8sSecretPathPrefix...), strings.ToLower(secret.GetGroup()), strings.ToLower(secret.GetKey())), + } +} + +func AppendVolumeMounts(containers []corev1.Container, mount corev1.VolumeMount) []corev1.Container { + res := make([]corev1.Container, 0, len(containers)) + for _, c := range containers { + c.VolumeMounts = appendVolumeMountIfNotExists(c.VolumeMounts, mount) + res = append(res, c) + } + + return res +} + +func AppendEnvVars(containers []corev1.Container, envVars ...corev1.EnvVar) []corev1.Container { + res := make([]corev1.Container, 0, len(containers)) + for _, c := range containers { + for _, envVar := range envVars { + if foundIndex := hasEnvVar(c.Env, envVar.Name); foundIndex >= 0 { + // This would be someone adding a duplicate key to what the webhook is trying to add. + // We should delete the existing one and then add the new at the beginning + c.Env = append(c.Env[:foundIndex], c.Env[foundIndex+1:]...) + } + + // Append the passed in environment variable to the start of the list. + c.Env = append([]corev1.EnvVar{envVar}, c.Env...) + } + res = append(res, c) + } + + return res +} + +func appendVolumeIfNotExists(volumes []corev1.Volume, vol corev1.Volume) []corev1.Volume { + for _, v := range volumes { + if v.Name == vol.Name { + return volumes + } + } + + return append(volumes, vol) +} + +func appendVolumeMountIfNotExists(volumes []corev1.VolumeMount, vol corev1.VolumeMount) []corev1.VolumeMount { + for _, v := range volumes { + if v.Name == vol.Name { + return volumes + } + } + + return append(volumes, vol) +} + +func AppendVolume(volumes []corev1.Volume, volume corev1.Volume) []corev1.Volume { + for _, v := range volumes { + // append secret items to existing volume for secret within same secret group + if v.Secret != nil && v.Secret.SecretName == volume.Secret.SecretName { + v.Secret.Items = append(v.Secret.Items, volume.Secret.Items...) + return volumes + } + } + + return append(volumes, volume) +} + +func CreateVaultAnnotationsForSecret(secret *core.Secret, kvversion config.KVVersion) map[string]string { + // Creates three grouped annotations "agent-inject-secret", "agent-inject-file" and "agent-inject-template" + // for a given secret request and KV engine version. The annotations respectively handle: 1. retrieving the + // secret from a vault path specified in secret.Group, 2. storing it in a file named after secret.Group/secret.Key + // and 3. creating a template that retrieves only secret.Key from the multiple k:v pairs present in a vault secret. + id := string(uuid.NewUUID()) + + secretVaultAnnotations := map[string]string{ + fmt.Sprintf("vault.hashicorp.com/agent-inject-secret-%s", id): secret.Group, + fmt.Sprintf("vault.hashicorp.com/agent-inject-file-%s", id): fmt.Sprintf("%s/%s", secret.Group, secret.Key), + } + + // Set the consul template language query depending on the KV Secrets Engine version. + // Version 1 stores plain k:v pairs under .Data, version 2 supports versioned secrets + // and wraps the k:v pairs into an additional subfield. + var query string + switch secret.GroupVersion { + case "kv1": + query = ".Data" + case "kv2": + query = ".Data.data" + case "db": + // For the database secrets engine backend we do not want to use the templating + default: + // Deprecated: The config setting KVVersion is deprecated and will be removed in a future release. + // You should instead use the GroupVersion field in the secret definition. + // Support using the legacy KVVersion config if GroupVersion is not set + switch kvversion { + case config.KVVersion1: + query = ".Data" + case config.KVVersion2: + query = ".Data.data" + } + } + if query != "" { + template := fmt.Sprintf(`{{- with secret "%s" -}}{{ %s.%s }}{{- end -}}`, secret.Group, query, secret.Key) + secretVaultAnnotations[fmt.Sprintf("vault.hashicorp.com/agent-inject-template-%s", id)] = template + + } + return secretVaultAnnotations +} + +type SecretNameComponents struct { + Org string + Domain string + Project string + Name string // Secret name +} + +func (s SecretNameComponents) String() string { + return fmt.Sprintf("%s/%s/%s/%s", s.Org, s.Domain, s.Project, s.Name) +} + +func EncodeSecretName(org, domain, project, name string) string { + return fmt.Sprintf(secretsStorageFormat, org, domain, project, name) +} + +// EncodeSecretNamePrefix creates a prefix to search for in the secrets manager +func EncodeSecretNamePrefix(org, domain, project string) string { + switch { + case project != "": + return fmt.Sprintf(secretsStorageProjectPrefixFormat, org, domain, project) + case domain != "": + return fmt.Sprintf(secretsStorageDomainPrefixFormat, org, domain) + default: + return fmt.Sprintf(secretsStorageOrgPrefixFormat, org) + } +} + +func DecodeSecretName(encodedSecretName string) (*SecretNameComponents, error) { + parts := strings.Split(encodedSecretName, secretFieldSeparator) + + // We need at least 5 parts: u, org, , domain, + if len(parts) < 9 { + return nil, errors.New(secretNameInvalidNotEnoughPartsMsg) + } + + if parts[0] != secretsStorageUnionPrefix || parts[1] != secretsOrgDelimiter || parts[3] != secretsDomainDelimiter || parts[5] != secretsProjectDelimiter || parts[7] != secretsKeyDelimiter { + return nil, errors.New(secretNameInvalidUnexpectedPartsMsg) + } + + result := &SecretNameComponents{ + Org: parts[2], + Domain: parts[4], + Project: parts[6], + Name: strings.Join(parts[8:], secretFieldSeparator), + } + + return result, nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/utils_test.go b/flyteplugins/go/tasks/pluginmachinery/secret/utils_test.go new file mode 100644 index 0000000000..0e3add1957 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/utils_test.go @@ -0,0 +1,482 @@ +package secret + +import ( + "errors" + "fmt" + "path/filepath" + "reflect" + "testing" + + "github.com/go-test/deep" + corev1 "k8s.io/api/core/v1" +) + +const ( + testOrg = "test-org" + testDomain = "test-domain" + testProject = "test-project" + testSecretName = "test-secret" +) + +func Test_hasEnvVar(t *testing.T) { + type args struct { + envVars []corev1.EnvVar + envVarKey string + } + tests := []struct { + name string + args args + want int + }{ + { + name: "exists", + args: args{ + envVars: []corev1.EnvVar{ + { + Name: "ENV_VAR_1", + }, + }, + envVarKey: "ENV_VAR_1", + }, + want: 0, + }, + + { + name: "doesn't exist", + args: args{ + envVars: []corev1.EnvVar{ + { + Name: "ENV_VAR_1", + }, + }, + envVarKey: "ENV_VAR", + }, + want: -1, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := hasEnvVar(tt.args.envVars, tt.args.envVarKey); got != tt.want { + t.Errorf("hasEnvVar() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestUpdateVolumeMounts(t *testing.T) { + type args struct { + containers []corev1.Container + volumeMount corev1.VolumeMount + } + tests := []struct { + name string + args args + want []corev1.Container + }{ + { + name: "volume", + args: args{ + containers: []corev1.Container{ + { + Name: "my_container", + }, + }, + volumeMount: corev1.VolumeMount{ + Name: "my_secret", + ReadOnly: true, + MountPath: filepath.Join(filepath.Join(K8sSecretPathPrefix...), "my_secret"), + }, + }, + want: []corev1.Container{ + { + Name: "my_container", + VolumeMounts: []corev1.VolumeMount{ + { + Name: "my_secret", + ReadOnly: true, + MountPath: filepath.Join(filepath.Join(K8sSecretPathPrefix...), "my_secret"), + }, + }, + }, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := AppendVolumeMounts(tt.args.containers, tt.args.volumeMount); !reflect.DeepEqual(got, tt.want) { + t.Errorf("AppendVolumeMounts() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestUpdateEnvVars(t *testing.T) { + type args struct { + containers []corev1.Container + envVar corev1.EnvVar + } + tests := []struct { + name string + args args + want []corev1.Container + }{ + { + name: "env vars already exists", + args: args{ + containers: []corev1.Container{ + { + Name: "my_container", + Env: []corev1.EnvVar{ + { + Name: "my_secret", + Value: "my_val_already", + }, + }, + }, + }, + envVar: corev1.EnvVar{ + Name: "my_secret", + Value: "my_val", + }, + }, + want: []corev1.Container{ + { + Name: "my_container", + Env: []corev1.EnvVar{ + { + Name: "my_secret", + Value: "my_val", + }, + }, + }, + }, + }, + { + name: "env vars already added", + args: args{ + containers: []corev1.Container{ + { + Name: "my_container", + }, + }, + envVar: corev1.EnvVar{ + Name: "my_secret", + Value: "my_val", + }, + }, + want: []corev1.Container{ + { + Name: "my_container", + Env: []corev1.EnvVar{ + { + Name: "my_secret", + Value: "my_val", + }, + }, + }, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := AppendEnvVars(tt.args.containers, tt.args.envVar); !reflect.DeepEqual(got, tt.want) { + t.Errorf("AppendEnvVars() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestAppendVolume(t *testing.T) { + type args struct { + volumes []corev1.Volume + volume corev1.Volume + } + tests := []struct { + name string + args args + want []corev1.Volume + }{ + {name: "append secret", args: args{volumes: []corev1.Volume{}, volume: corev1.Volume{Name: "new_secret"}}, want: []corev1.Volume{{Name: "new_secret"}}}, + {name: "existing other volumes", args: args{volumes: []corev1.Volume{{Name: "existing"}}, volume: corev1.Volume{Name: "new_secret"}}, want: []corev1.Volume{{Name: "existing"}, {Name: "new_secret"}}}, + {name: "existing secret volume", + args: args{ + volumes: []corev1.Volume{{ + Name: "existing", VolumeSource: corev1.VolumeSource{Secret: &corev1.SecretVolumeSource{SecretName: "foo", Items: []corev1.KeyToPath{{Key: "existingKey"}}}}, + }}, + volume: corev1.Volume{Name: "new_secret", VolumeSource: corev1.VolumeSource{Secret: &corev1.SecretVolumeSource{SecretName: "foo", Items: []corev1.KeyToPath{{Key: "newKey"}}}}}}, + want: []corev1.Volume{{ + Name: "existing", VolumeSource: corev1.VolumeSource{Secret: &corev1.SecretVolumeSource{SecretName: "foo", Items: []corev1.KeyToPath{{Key: "existingKey"}, {Key: "newKey"}}}}, + }}, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := AppendVolume(tt.args.volumes, tt.args.volume) + if diff := deep.Equal(got, tt.want); diff != nil { + t.Errorf("AppendVolume() = %v, want %v", got, tt.want) + t.Errorf("Diff: %v", diff) + } + }) + } +} + +func Test_EncodeSecretName(t *testing.T) { + tests := []struct { + name string + org string + domain string + project string + secretName string + want string + }{ + { + name: "test name without domain nor project", + org: testOrg, + domain: "", + project: "", + secretName: testSecretName, + want: "u__org__test-org__domain____project____key__test-secret", + }, + { + name: "test name without project", + org: testOrg, + domain: testDomain, + project: "", + secretName: testSecretName, + want: "u__org__test-org__domain__test-domain__project____key__test-secret", + }, + { + name: "test name with project and domain", + org: testOrg, + domain: testDomain, + project: testProject, + secretName: testSecretName, + want: "u__org__test-org__domain__test-domain__project__test-project__key__test-secret", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := EncodeSecretName(tt.org, tt.domain, tt.project, tt.secretName); got != tt.want { + t.Errorf("EncodeSecretName() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_EncodeSecretNamePrefix(t *testing.T) { + tests := []struct { + name string + org string + domain string + project string + want string + }{ + { + name: "test with org, domain, and project", + org: testOrg, + domain: testDomain, + project: testProject, + want: "u__org__test-org__domain__test-domain__project__test-project", + }, + { + name: "test with org, domain, but no project", + org: testOrg, + domain: testDomain, + project: "", + want: "u__org__test-org__domain__test-domain", + }, + { + name: "test with org but no domain nor project", + org: testOrg, + domain: "", + project: "", + want: "u__org__test-org", + }, + { + name: "test with no org, domain, nor project", + org: "", + domain: "", + project: "", + want: "u__org__", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := EncodeSecretNamePrefix(tt.org, tt.domain, tt.project); got != tt.want { + t.Errorf("EncodeSecretNamePrefix() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_DecodeSecretName(t *testing.T) { + tests := []struct { + name string + arg string + want SecretNameComponents + }{ + { + name: "test name without domain nor project", + arg: "u__org__test-org__domain____project____key__test-secret", + want: SecretNameComponents{ + Org: testOrg, + Domain: "", + Project: "", + Name: testSecretName, + }, + }, + { + name: "test name without project", + arg: "u__org__test-org__domain__test-domain__project____key__test-secret", + want: SecretNameComponents{ + Org: testOrg, + Domain: testDomain, + Project: "", + Name: testSecretName, + }, + }, + { + name: "test name with project and domain", + arg: "u__org__test-org__domain__test-domain__project__test-project__key__test-secret", + want: SecretNameComponents{ + Org: testOrg, + Domain: testDomain, + Project: testProject, + Name: testSecretName, + }, + }, + { + name: "test name with key that has underscores", + arg: "u__org__test-org__domain__test-domain__project__test-project__key__test__secret", + want: SecretNameComponents{ + Org: testOrg, + Domain: testDomain, + Project: testProject, + Name: "test__secret", + }, + }, + { + name: "test name with key that ends with underscores", + arg: "u__org__test-org__domain__test-domain__project__test-project__key__test-secret__", + want: SecretNameComponents{ + Org: testOrg, + Domain: testDomain, + Project: testProject, + Name: "test-secret__", + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got, err := DecodeSecretName(tt.arg); err != nil || !reflect.DeepEqual(*got, tt.want) { + t.Errorf("DecodeSecretName() = %v, want %v", got, tt.want) + } + }) + } + + notEnoughParts := []string{ + "u_org__test-org__domain__test-domain__project__test-project__key__test-secret", + "u__org_test-org__domain__test-domain__project__test-project__key__test-secret", + "u__org__test-org_domain__test-domain__project__test-project__key__test-secret", + "u__org__test-org__domain_test-domain__project__test-project__key__test-secret", + "u__org__test-org__domain__test-domain_project__test-project__key__test-secret", + "u__org__test-org__domain__test-domain__project_test-project__key__test-secret", + "u__org__test-org__domain__test-domain__project__test-project_key__test-secret", + "u__org__test-org__domain__test-domain__project__test-project__key_test-secret", + } + + for _, arg := range notEnoughParts { + t.Run(fmt.Sprintf("test name with not enough parts: %s", arg), func(t *testing.T) { + expectedErr := errors.New(secretNameInvalidNotEnoughPartsMsg) + if got, err := DecodeSecretName(arg); err == nil || errors.Is(err, expectedErr) { + t.Errorf("DecodeSecretName() = %v, %v; want error %v", got, err, expectedErr) + } + }) + } + + unexpectedParts := []string{ + "v__org__test-org__domain__test-domain__project__test-project__key__test-secret", + "u__smorg__test-org__domain__test-domain__project__test-project__key__test-secret", + "u__org__test-org__doman__test-domain__project__test-project__key__test-secret", + "u__org__test-org__domain__test-domain__projects__test-project__key__test-secret", + "u__org__test-org__domain__test-domain__project__test-project__ky__test-secret", + } + + for _, arg := range unexpectedParts { + t.Run(fmt.Sprintf("test name with unexpected parts: %s", arg), func(t *testing.T) { + expectedErr := errors.New(secretNameInvalidUnexpectedPartsMsg) + if got, err := DecodeSecretName(arg); err == nil || errors.Is(err, expectedErr) { + t.Errorf("DecodeSecretName() = %v, %v; want error %v", got, err, expectedErr) + } + }) + } +} + +func Test_EncodeDecodeSecretName_Bijectivity(t *testing.T) { + tests := []struct { + name string + org string + domain string + project string + secretName string + arg SecretNameComponents + }{ + { + name: "test name without domain nor project", + org: testOrg, + domain: "", + project: "", + secretName: testSecretName, + }, + { + name: "test name without project", + org: testOrg, + domain: testDomain, + project: "", + secretName: testSecretName, + }, + { + name: "test name with project and domain", + org: testOrg, + domain: testDomain, + project: testProject, + secretName: testSecretName, + }, + { + name: "test name with key that has underscores", + org: testOrg, + domain: testDomain, + project: testProject, + secretName: "test__secret", + }, + { + name: "test name with key that ends with underscores", + org: testOrg, + domain: testDomain, + project: testProject, + secretName: "test-secret__", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + encoded := EncodeSecretName(tt.org, tt.domain, tt.project, tt.secretName) + decoded, err := DecodeSecretName(encoded) + if err != nil { + t.Errorf("DecodeSecretName() = %v, want nil", err) + } + if !reflect.DeepEqual(*decoded, SecretNameComponents{ + Org: tt.org, + Domain: tt.domain, + Project: tt.project, + Name: tt.secretName, + }) { + t.Errorf("DecodeSecretName() = %v, want %v", *decoded, tt.arg) + } + }) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/vault_secret_manager.go b/flyteplugins/go/tasks/pluginmachinery/secret/vault_secret_manager.go new file mode 100644 index 0000000000..2c7b05f8b0 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/vault_secret_manager.go @@ -0,0 +1,91 @@ +package secret + +import ( + "context" + "fmt" + "os" + "path/filepath" + + corev1 "k8s.io/api/core/v1" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + coreIdl "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +var ( + VaultSecretPathPrefix = []string{string(os.PathSeparator), "etc", "flyte", "secrets"} +) + +// VaultSecretManagerInjector allows injecting of secrets into pods by leveraging an existing deployment of Vault Agent +// Vault Agent functions as an additional webhook that is triggered through annotations and then retrieves and mounts +// the requested secrets from Vault. This injector parses a secret Request into vault annotations, interpreting the secret +// Group as the vault secret path and the secret Key as the key for which to extract a value from a Vault secret. +// It supports adding multiple secrets. (The common annotations will simply be overwritten if added several times) +// Note that you need to configure the Vault role that this injector will try to use and add Vault policies for +// the service account and namespaces that your workflows run under. +// Files will be mounted at /etc/flyte/secrets// +type VaultSecretManagerInjector struct { + cfg config.VaultSecretManagerConfig +} + +func (i VaultSecretManagerInjector) Type() config.SecretManagerType { + return config.SecretManagerTypeVault +} + +func (i VaultSecretManagerInjector) Inject(ctx context.Context, secret *coreIdl.Secret, p *corev1.Pod) (newP *corev1.Pod, injected bool, err error) { + if len(secret.Group) == 0 || len(secret.Key) == 0 { + return p, false, fmt.Errorf("Vault Secrets Webhook requires both key and group to be set. "+ + "Secret: [%v]", secret) + } + + switch secret.MountRequirement { + case coreIdl.Secret_ANY: + fallthrough + case coreIdl.Secret_FILE: + // Set environment variable to let the container know where to find the mounted files. + defaultDirEnvVar := corev1.EnvVar{ + Name: SecretPathDefaultDirEnvVar, + Value: filepath.Join(VaultSecretPathPrefix...), + } + + p.Spec.InitContainers = AppendEnvVars(p.Spec.InitContainers, defaultDirEnvVar) + p.Spec.Containers = AppendEnvVars(p.Spec.Containers, defaultDirEnvVar) + + // Sets an empty prefix to let the containers know the file names will match the secret keys as-is. + prefixEnvVar := corev1.EnvVar{ + Name: SecretPathFilePrefixEnvVar, + Value: "", + } + + p.Spec.InitContainers = AppendEnvVars(p.Spec.InitContainers, prefixEnvVar) + p.Spec.Containers = AppendEnvVars(p.Spec.Containers, prefixEnvVar) + + commonVaultAnnotations := map[string]string{ + "vault.hashicorp.com/agent-inject": "true", + "vault.hashicorp.com/secret-volume-path": filepath.Join(VaultSecretPathPrefix...), + "vault.hashicorp.com/role": i.cfg.Role, + "vault.hashicorp.com/agent-pre-populate-only": "true", + } + + secretVaultAnnotations := CreateVaultAnnotationsForSecret(secret, i.cfg.KVVersion) + + p.ObjectMeta.Annotations = utils.UnionMaps(secretVaultAnnotations, commonVaultAnnotations, i.cfg.Annotations, p.ObjectMeta.Annotations) + + case coreIdl.Secret_ENV_VAR: + return p, false, fmt.Errorf("Env_Var is not a supported mount requirement for Vault Secret Manager") + default: + err := fmt.Errorf("unrecognized mount requirement [%v] for secret [%v]", secret.MountRequirement.String(), secret.Key) + logger.Error(ctx, err) + return p, false, err + } + + return p, true, nil +} + +func NewVaultSecretManagerInjector(cfg config.VaultSecretManagerConfig) VaultSecretManagerInjector { + return VaultSecretManagerInjector{ + cfg: cfg, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secret/vault_secret_manager_test.go b/flyteplugins/go/tasks/pluginmachinery/secret/vault_secret_manager_test.go new file mode 100644 index 0000000000..b0947615a5 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secret/vault_secret_manager_test.go @@ -0,0 +1,316 @@ +package secret + +import ( + "context" + "fmt" + "testing" + + "github.com/go-test/deep" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret/config" + coreIdl "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +var ( + // We expect these outputs for each successful test + PodSpec = corev1.PodSpec{ + InitContainers: []corev1.Container{}, + Containers: []corev1.Container{ + { + Name: "container1", + Env: []corev1.EnvVar{ + { + Name: "FLYTE_SECRETS_FILE_PREFIX", + }, + { + Name: "FLYTE_SECRETS_DEFAULT_DIR", + Value: "/etc/flyte/secrets", + }, + }, + }, + }, + } +) + +func RetrieveUUID(annotations map[string]string) string { + // helper function to retrieve the random uuid from output before comparing + var uuid string + for k := range annotations { + if len(k) > 39 && k[:39] == "vault.hashicorp.com/agent-inject-secret" { + uuid = k[40:] + } + } + return uuid +} + +func ExpectedKVv1(uuid string) *corev1.Pod { + expected := &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Annotations: map[string]string{ + "vault.hashicorp.com/agent-inject": "true", + "vault.hashicorp.com/secret-volume-path": "/etc/flyte/secrets", + "vault.hashicorp.com/role": "flyte", + "vault.hashicorp.com/agent-pre-populate-only": "true", + fmt.Sprintf("vault.hashicorp.com/agent-inject-secret-%s", uuid): "foo", + fmt.Sprintf("vault.hashicorp.com/agent-inject-file-%s", uuid): "foo/bar", + fmt.Sprintf("vault.hashicorp.com/agent-inject-template-%s", uuid): `{{- with secret "foo" -}}{{ .Data.bar }}{{- end -}}`, + }, + }, + Spec: PodSpec, + } + return expected +} + +func ExpectedKVv2(uuid string) *corev1.Pod { + expected := &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Annotations: map[string]string{ + "vault.hashicorp.com/agent-inject": "true", + "vault.hashicorp.com/secret-volume-path": "/etc/flyte/secrets", + "vault.hashicorp.com/role": "flyte", + "vault.hashicorp.com/agent-pre-populate-only": "true", + fmt.Sprintf("vault.hashicorp.com/agent-inject-secret-%s", uuid): "foo", + fmt.Sprintf("vault.hashicorp.com/agent-inject-file-%s", uuid): "foo/bar", + fmt.Sprintf("vault.hashicorp.com/agent-inject-template-%s", uuid): `{{- with secret "foo" -}}{{ .Data.data.bar }}{{- end -}}`, + }, + }, + Spec: PodSpec, + } + return expected +} + +func ExpectedExtraAnnotation(uuid string) *corev1.Pod { + expected := &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Annotations: map[string]string{ + "vault.hashicorp.com/agent-inject": "true", + "vault.hashicorp.com/secret-volume-path": "/etc/flyte/secrets", + "vault.hashicorp.com/role": "flyte", + "vault.hashicorp.com/agent-pre-populate-only": "true", + fmt.Sprintf("vault.hashicorp.com/agent-inject-secret-%s", uuid): "foo", + fmt.Sprintf("vault.hashicorp.com/agent-inject-file-%s", uuid): "foo/bar", + fmt.Sprintf("vault.hashicorp.com/agent-inject-template-%s", uuid): `{{- with secret "foo" -}}{{ .Data.data.bar }}{{- end -}}`, + "vault.hashicorp.com/auth-config-type": "gce", + }, + }, + Spec: PodSpec, + } + return expected +} + +func ExpectedExistingRoleAnnotation(uuid string) *corev1.Pod { + expected := &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Annotations: map[string]string{ + "vault.hashicorp.com/agent-inject": "true", + "vault.hashicorp.com/secret-volume-path": "/etc/flyte/secrets", + "vault.hashicorp.com/role": "my-role", + "vault.hashicorp.com/agent-pre-populate-only": "true", + fmt.Sprintf("vault.hashicorp.com/agent-inject-secret-%s", uuid): "foo", + fmt.Sprintf("vault.hashicorp.com/agent-inject-file-%s", uuid): "foo/bar", + fmt.Sprintf("vault.hashicorp.com/agent-inject-template-%s", uuid): `{{- with secret "foo" -}}{{ .Data.data.bar }}{{- end -}}`, + }, + }, + Spec: PodSpec, + } + return expected +} + +func ExpectedConfigAnnotation(uuid string) *corev1.Pod { + expected := &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Annotations: map[string]string{ + "vault.hashicorp.com/agent-inject": "true", + "vault.hashicorp.com/secret-volume-path": "/etc/flyte/secrets", + "vault.hashicorp.com/role": "flyte", + "vault.hashicorp.com/agent-pre-populate-only": "false", + fmt.Sprintf("vault.hashicorp.com/agent-inject-secret-%s", uuid): "foo", + fmt.Sprintf("vault.hashicorp.com/agent-inject-file-%s", uuid): "foo/bar", + fmt.Sprintf("vault.hashicorp.com/agent-inject-template-%s", uuid): `{{- with secret "foo" -}}{{ .Data.data.bar }}{{- end -}}`, + }, + }, + Spec: PodSpec, + } + return expected +} + +func ExpectedDB(uuid string) *corev1.Pod { + expected := &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Annotations: map[string]string{ + "vault.hashicorp.com/agent-inject": "true", + "vault.hashicorp.com/secret-volume-path": "/etc/flyte/secrets", + "vault.hashicorp.com/role": "flyte", + "vault.hashicorp.com/agent-pre-populate-only": "true", + fmt.Sprintf("vault.hashicorp.com/agent-inject-secret-%s", uuid): "foo", + fmt.Sprintf("vault.hashicorp.com/agent-inject-file-%s", uuid): "foo/bar", + }, + }, + Spec: PodSpec, + } + return expected +} + +func NewInputPod(annotations map[string]string) *corev1.Pod { + // Need to create a new Pod for every test since annotations are otherwise appended to original reference object + p := &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Annotations: annotations, + }, + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + { + Name: "container1", + }, + }, + }, + } + return p +} + +func TestVaultSecretManagerInjector_Inject(t *testing.T) { + inputSecret := &coreIdl.Secret{ + Group: "foo", + Key: "bar", + } + + ctx := context.Background() + type args struct { + cfg config.VaultSecretManagerConfig + secret *coreIdl.Secret + p *corev1.Pod + } + tests := []struct { + name string + args args + want func(string) *corev1.Pod + wantErr bool + }{ + { + name: "KVv1 Secret Group Version argument overwrites config", + args: args{ + cfg: config.VaultSecretManagerConfig{Role: "flyte", KVVersion: config.KVVersion2}, + secret: &coreIdl.Secret{ + Group: "foo", + Key: "bar", + GroupVersion: "kv1", + }, + p: NewInputPod(map[string]string{}), + }, + want: ExpectedKVv1, + wantErr: false, + }, + { + name: "KVv2 Secret Group Version argument overwrites config", + args: args{ + cfg: config.VaultSecretManagerConfig{Role: "flyte", KVVersion: config.KVVersion1}, + secret: &coreIdl.Secret{ + Group: "foo", + Key: "bar", + GroupVersion: "kv2", + }, + p: NewInputPod(map[string]string{}), + }, + want: ExpectedKVv2, + wantErr: false, + }, + { + name: "Extra annotations from config are added", + args: args{ + cfg: config.VaultSecretManagerConfig{Role: "flyte", KVVersion: config.KVVersion2, Annotations: map[string]string{ + "vault.hashicorp.com/auth-config-type": "gce", + }}, + secret: inputSecret, + p: NewInputPod(map[string]string{}), + }, + want: ExpectedExtraAnnotation, + wantErr: false, + }, + { + name: "Already present annotation is not overwritten", + args: args{ + cfg: config.VaultSecretManagerConfig{Role: "flyte", KVVersion: config.KVVersion2, Annotations: map[string]string{}}, + secret: inputSecret, + p: NewInputPod(map[string]string{ + "vault.hashicorp.com/role": "my-role", + }), + }, + want: ExpectedExistingRoleAnnotation, + wantErr: false, + }, + { + name: "Config annotation overwrites system default annotation", + args: args{ + cfg: config.VaultSecretManagerConfig{Role: "flyte", KVVersion: config.KVVersion2, Annotations: map[string]string{ + "vault.hashicorp.com/agent-pre-populate-only": "false", // override vault.hashicorp.com/agent-pre-populate-only + }}, + secret: inputSecret, + p: NewInputPod(map[string]string{}), + }, + want: ExpectedConfigAnnotation, + wantErr: false, + }, + { + name: "DB Secret backend engine is supported", + args: args{ + cfg: config.VaultSecretManagerConfig{Role: "flyte", KVVersion: config.KVVersion1}, + secret: &coreIdl.Secret{ + Group: "foo", + Key: "bar", + GroupVersion: "db", + }, + p: NewInputPod(map[string]string{}), + }, + want: ExpectedDB, + wantErr: false, + }, + { + name: "Legacy config option V1 is still supported", + args: args{ + cfg: config.VaultSecretManagerConfig{Role: "flyte", KVVersion: config.KVVersion1}, + secret: &coreIdl.Secret{ + Group: "foo", + Key: "bar", + }, + p: NewInputPod(map[string]string{}), + }, + want: ExpectedKVv1, + wantErr: false, + }, + { + name: "Legacy config option V2 is still supported", + args: args{ + cfg: config.VaultSecretManagerConfig{Role: "flyte", KVVersion: config.KVVersion2}, + secret: &coreIdl.Secret{ + Group: "foo", + Key: "bar", + }, + p: NewInputPod(map[string]string{}), + }, + want: ExpectedKVv2, + wantErr: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + i := NewVaultSecretManagerInjector(tt.args.cfg) + got, _, err := i.Inject(ctx, tt.args.secret, tt.args.p) + + if (err != nil) != tt.wantErr { + t.Errorf("Inject() error = %v, wantErr %v", err, tt.wantErr) + return + } else if err != nil { + return + } + + uuid := RetrieveUUID(got.ObjectMeta.Annotations) + expected := tt.want(uuid) + if diff := deep.Equal(got, expected); diff != nil { + t.Errorf("Inject() Diff = %v\r\n got = %v\r\n want = %v", diff, got, expected) + } + }) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secretmanager/config.go b/flyteplugins/go/tasks/pluginmachinery/secretmanager/config.go new file mode 100644 index 0000000000..c0fbc0b24f --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secretmanager/config.go @@ -0,0 +1,29 @@ +package secretmanager + +import "github.com/flyteorg/flyte/v2/flytestdlib/config" + +//go:generate pflags Config --default-var defaultConfig + +type Type = string + +const SectionKey = "secrets" + +var ( + defaultConfig = &Config{ + Type: "local", + SecretFilePrefix: "/etc/secrets", + EnvironmentPrefix: "FLYTE_SECRET_", + } + + section = config.MustRegisterSection(SectionKey, defaultConfig) +) + +type Config struct { + Type Type `json:"type" pflag:",Sets the type of storage to configure [local]."` + SecretFilePrefix string `json:"secrets-prefix" pflag:", Prefix where to look for secrets file"` + EnvironmentPrefix string `json:"env-prefix" pflag:", Prefix for environment variables"` +} + +func GetConfig() *Config { + return section.GetConfig().(*Config) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secretmanager/config_flags.go b/flyteplugins/go/tasks/pluginmachinery/secretmanager/config_flags.go new file mode 100755 index 0000000000..504dfa95de --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secretmanager/config_flags.go @@ -0,0 +1,57 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package secretmanager + +import ( + "encoding/json" + "reflect" + + "fmt" + + "github.com/spf13/pflag" +) + +// If v is a pointer, it will get its element value or the zero value of the element type. +// If v is not a pointer, it will return it as is. +func (Config) elemValueOrNil(v interface{}) interface{} { + if t := reflect.TypeOf(v); t.Kind() == reflect.Ptr { + if reflect.ValueOf(v).IsNil() { + return reflect.Zero(t.Elem()).Interface() + } else { + return reflect.ValueOf(v).Interface() + } + } else if v == nil { + return reflect.Zero(t).Interface() + } + + return v +} + +func (Config) mustJsonMarshal(v interface{}) string { + raw, err := json.Marshal(v) + if err != nil { + panic(err) + } + + return string(raw) +} + +func (Config) mustMarshalJSON(v json.Marshaler) string { + raw, err := v.MarshalJSON() + if err != nil { + panic(err) + } + + return string(raw) +} + +// GetPFlagSet will return strongly types pflags for all fields in Config and its nested types. The format of the +// flags is json-name.json-sub-name... etc. +func (cfg Config) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("Config", pflag.ExitOnError) + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "type"), defaultConfig.Type, "Sets the type of storage to configure [local].") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "secrets-prefix"), defaultConfig.SecretFilePrefix, " Prefix where to look for secrets file") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "env-prefix"), defaultConfig.EnvironmentPrefix, " Prefix for environment variables") + return cmdFlags +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secretmanager/config_flags_test.go b/flyteplugins/go/tasks/pluginmachinery/secretmanager/config_flags_test.go new file mode 100755 index 0000000000..aab5ea569d --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secretmanager/config_flags_test.go @@ -0,0 +1,144 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package secretmanager + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "testing" + + "github.com/mitchellh/mapstructure" + "github.com/stretchr/testify/assert" +) + +var dereferencableKindsConfig = map[reflect.Kind]struct{}{ + reflect.Array: {}, reflect.Chan: {}, reflect.Map: {}, reflect.Ptr: {}, reflect.Slice: {}, +} + +// Checks if t is a kind that can be dereferenced to get its underlying type. +func canGetElementConfig(t reflect.Kind) bool { + _, exists := dereferencableKindsConfig[t] + return exists +} + +// This decoder hook tests types for json unmarshaling capability. If implemented, it uses json unmarshal to build the +// object. Otherwise, it'll just pass on the original data. +func jsonUnmarshalerHookConfig(_, to reflect.Type, data interface{}) (interface{}, error) { + unmarshalerType := reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + if to.Implements(unmarshalerType) || reflect.PtrTo(to).Implements(unmarshalerType) || + (canGetElementConfig(to.Kind()) && to.Elem().Implements(unmarshalerType)) { + + raw, err := json.Marshal(data) + if err != nil { + fmt.Printf("Failed to marshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + res := reflect.New(to).Interface() + err = json.Unmarshal(raw, &res) + if err != nil { + fmt.Printf("Failed to umarshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + return res, nil + } + + return data, nil +} + +func decode_Config(input, result interface{}) error { + config := &mapstructure.DecoderConfig{ + TagName: "json", + WeaklyTypedInput: true, + Result: result, + DecodeHook: mapstructure.ComposeDecodeHookFunc( + mapstructure.StringToTimeDurationHookFunc(), + mapstructure.StringToSliceHookFunc(","), + jsonUnmarshalerHookConfig, + ), + } + + decoder, err := mapstructure.NewDecoder(config) + if err != nil { + return err + } + + return decoder.Decode(input) +} + +func join_Config(arr interface{}, sep string) string { + listValue := reflect.ValueOf(arr) + strs := make([]string, 0, listValue.Len()) + for i := 0; i < listValue.Len(); i++ { + strs = append(strs, fmt.Sprintf("%v", listValue.Index(i))) + } + + return strings.Join(strs, sep) +} + +func testDecodeJson_Config(t *testing.T, val, result interface{}) { + assert.NoError(t, decode_Config(val, result)) +} + +func testDecodeRaw_Config(t *testing.T, vStringSlice, result interface{}) { + assert.NoError(t, decode_Config(vStringSlice, result)) +} + +func TestConfig_GetPFlagSet(t *testing.T) { + val := Config{} + cmdFlags := val.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) +} + +func TestConfig_SetFlags(t *testing.T) { + actual := Config{} + cmdFlags := actual.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) + + t.Run("Test_type", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("type", testValue) + if vString, err := cmdFlags.GetString("type"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.Type) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_secrets-prefix", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("secrets-prefix", testValue) + if vString, err := cmdFlags.GetString("secrets-prefix"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.SecretFilePrefix) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_env-prefix", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("env-prefix", testValue) + if vString, err := cmdFlags.GetString("env-prefix"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.EnvironmentPrefix) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/secretmanager/secrets.go b/flyteplugins/go/tasks/pluginmachinery/secretmanager/secrets.go new file mode 100644 index 0000000000..6a11671c92 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/secretmanager/secrets.go @@ -0,0 +1,87 @@ +package secretmanager + +import ( + "context" + "fmt" + "io/ioutil" + "os" + "path/filepath" + "strings" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + coreIdl "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +// Env Var Lookup based on Prefix + SecretGroup + _ + SecretKey +const envVarLookupFormatter = "%s%s_%s" + +// FileEnvSecretManager allows retrieving secrets mounted to this process through Env Vars or Files. +type FileEnvSecretManager struct { + secretPath string + envPrefix string +} + +func (f FileEnvSecretManager) Get(ctx context.Context, key string) (string, error) { + envVar := fmt.Sprintf("%s%s", f.envPrefix, key) + v, ok := os.LookupEnv(envVar) + if ok { + logger.Debugf(ctx, "Secret found %s", v) + return v, nil + } + + secretFile := filepath.Join(f.secretPath, key) + if _, err := os.Stat(secretFile); err != nil { + if os.IsNotExist(err) { + return "", fmt.Errorf("secrets not found - file [%s], Env [%s]", secretFile, envVar) + } + return "", err + } + + logger.Debugf(ctx, "reading secrets from filePath [%s]", secretFile) + b, err := ioutil.ReadFile(secretFile) + if err != nil { + return "", err + } + return string(b), err +} + +// GetForSecret retrieves a secret from the environment of the running process. To lookup secret, both secret's key and +// group must be non-empty. GetForSecret will first lookup env variables using the configured +// Prefix+SecretGroup+_+SecretKey. If the secret is not found in environment, it'll lookup the secret from files using +// the configured SecretPath / SecretGroup / SecretKey. +func (f FileEnvSecretManager) GetForSecret(ctx context.Context, secret *coreIdl.Secret) (string, error) { + if len(secret.Group) == 0 || len(secret.Key) == 0 { + return "", fmt.Errorf("both key and group are required parameters. Secret: [%v]", secret.String()) + } + + envVar := fmt.Sprintf(envVarLookupFormatter, f.envPrefix, strings.ToUpper(secret.Group), strings.ToUpper(secret.Key)) + v, ok := os.LookupEnv(envVar) + if ok { + logger.Debugf(ctx, "Secret found %s", v) + return v, nil + } + + secretFile := filepath.Join(f.secretPath, filepath.Join(secret.Group, secret.Key)) + if _, err := os.Stat(secretFile); err != nil { + if os.IsNotExist(err) { + return "", fmt.Errorf("secrets not found - Env [%s], file [%s]", envVar, secretFile) + } + + return "", err + } + + logger.Debugf(ctx, "reading secrets from filePath [%s]", secretFile) + b, err := ioutil.ReadFile(secretFile) + if err != nil { + return "", err + } + + return string(b), err +} + +func NewFileEnvSecretManager(cfg *Config) FileEnvSecretManager { + return FileEnvSecretManager{ + secretPath: cfg.SecretFilePrefix, + envPrefix: cfg.EnvironmentPrefix, + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/tasklog/azure_plugin.go b/flyteplugins/go/tasks/pluginmachinery/tasklog/azure_plugin.go new file mode 100644 index 0000000000..22b473a560 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/tasklog/azure_plugin.go @@ -0,0 +1,70 @@ +package tasklog + +import ( + "bytes" + "compress/gzip" + "encoding/base64" + "fmt" + "net/url" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const ( + defaultName = "Azure Logs" + defaulQueryFormat = `let StartTime = datetime_add('hour', -1, datetime("{{.podRFC3339StartTime}}")); +let FinishTime = datetime_add('hour', 1, datetime("{{.podRFC3339FinishTime}}")); +ContainerLogV2 +| where TimeGenerated between (StartTime .. FinishTime) + and ContainerName == "{{.containerName}}" + and PodName == "{{.podName}}" + and PodNamespace == "{{.namespace}}"` +) + +// Azure Logs specific templater. +// Azure encodes two parts of the URI in two distinct ways. +// The first half the URI is usually composed of Azure tenant ID, subscription ID, resource group name, etc. +// The second half is the query itself, which is gzipped, base64, and then URL encoded. +type AzureLogsTemplatePlugin struct { + TemplateLogPlugin `json:",squash"` //nolint + + QueryFormat *string `json:"queryFormat" pflag:",The plain text query to use for Azure Logs."` +} + +func (t AzureLogsTemplatePlugin) GetTaskLogs(input Input) (Output, error) { + taskLogs := make([]*core.TaskLog, 0) + + var rawQuery string + if t.QueryFormat == nil { + rawQuery = defaulQueryFormat + } else { + rawQuery = *t.QueryFormat + } + + query := replaceAll(rawQuery, input.templateVars()) + var compressedBuffer bytes.Buffer + gzipWriter := gzip.NewWriter(&compressedBuffer) + _, err := gzipWriter.Write([]byte(query)) + if err != nil { + return Output{TaskLogs: taskLogs}, fmt.Errorf("gzip compression failed: %v", err) + } + err = gzipWriter.Close() + if err != nil { + return Output{TaskLogs: taskLogs}, fmt.Errorf("gzip writer close failed: %v", err) + } + + // Base64 and URL encoding + base64Encoded := base64.StdEncoding.EncodeToString(compressedBuffer.Bytes()) + urlEncoded := url.QueryEscape(base64Encoded) + + for _, baseURL := range t.TemplateURIs { + completeURL := fmt.Sprintf("%s%s", baseURL, urlEncoded) + taskLogs = append(taskLogs, &core.TaskLog{ + Name: t.DisplayName + input.LogName, + Uri: completeURL, + MessageFormat: core.TaskLog_JSON, + }) + } + + return Output{TaskLogs: taskLogs}, nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/tasklog/azure_plugin_test.go b/flyteplugins/go/tasks/pluginmachinery/tasklog/azure_plugin_test.go new file mode 100644 index 0000000000..7caf40fc73 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/tasklog/azure_plugin_test.go @@ -0,0 +1,67 @@ +package tasklog + +import ( + "reflect" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestAzureTemplateLogPlugin(t *testing.T) { + type args struct { + input Input + } + tests := []struct { + name string + plugin AzureLogsTemplatePlugin + args args + want Output + }{ + { + "test azure template log plugin", + AzureLogsTemplatePlugin{ + TemplateLogPlugin: TemplateLogPlugin{ + Name: "Azure Logs", + DisplayName: "Azure Logs", + TemplateURIs: []TemplateURI{"https://portal.azure.com#@test-tenantID/blade/Microsoft_OperationsManagementSuite_Workspace/Logs.ReactView/resourceId/%%2Fsubscriptions%%2Ftest-subscriptionID%%2FresourceGroups%%2Ftest-resourceGroupName/source/LogsBlade.AnalyticsShareLinkToQuery/q/"}, + }, + }, + args{ + input: Input{ + HostName: "test-host", + PodName: "test-pod", + Namespace: "test-namespace", + ContainerName: "test-container", + ContainerID: "test-containerID", + LogName: "main_logs", + PodRFC3339StartTime: "1970-01-01T01:02:03+01:00", + PodRFC3339FinishTime: "1970-01-01T04:25:45+01:00", + PodUnixStartTime: 123, + PodUnixFinishTime: 12345, + TaskExecutionID: dummyTaskExecID(), + }, + }, + Output{ + TaskLogs: []*core.TaskLog{ + { + Name: "Azure Logsmain_logs", + Uri: "https://portal.azure.com#@test-tenantID/blade/Microsoft_OperationsManagementSuite_Workspace/Logs.ReactView/resourceId/%%2Fsubscriptions%%2Ftest-subscriptionID%%2FresourceGroups%%2Ftest-resourceGroupName/source/LogsBlade.AnalyticsShareLinkToQuery/q/H4sIAAAAAAAA%2F3yPwUrFMBBF9%2F2KIZvX4ktJaosY6UrQjYhgcStjM9iATUo60o0fL0Fa24XuhnsuhzsfxPDMGLlzI0ELFpnYjfSK1uanIXzG0xmkPm8gF%2Fr6SkmlpdKd0kZVRl1epEOJorjJkvDOeTcP%2Fxn%2FFNamakzd7IS3wTM6T%2FEhvL9U2RcsA0WCZL8nTxGZLLwRL0Qe8t9fynK3o8gAvYXN9YhpWwuCaWbZr7H4qT0FeyxMwR7RPGG%2F436NxHcAAAD%2F%2F4NTt6FQAQAA", + MessageFormat: core.TaskLog_JSON, + }, + }, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := tt.plugin.GetTaskLogs(tt.args.input) + assert.NoError(t, err) + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("GetTaskLogs() got = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/tasklog/plugin.go b/flyteplugins/go/tasks/pluginmachinery/tasklog/plugin.go new file mode 100644 index 0000000000..054acbc588 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/tasklog/plugin.go @@ -0,0 +1,71 @@ +package tasklog + +import ( + "regexp" + + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +//go:generate enumer --type=TemplateScheme --trimprefix=TemplateScheme -json -yaml + +type TemplateScheme int + +const ( + TemplateSchemePod TemplateScheme = iota + TemplateSchemeTaskExecution +) + +// TemplateURI is a URI that accepts templates. See: go/tasks/pluginmachinery/tasklog/template.go for available templates. +type TemplateURI = string + +type TemplateVar struct { + Regex *regexp.Regexp + Value string +} + +// Input contains all available information about task's execution that a log plugin can use to construct task's +// log links. +type Input struct { + HostName string + PodName string + Namespace string + ContainerName string + ContainerID string + LogName string + PodRFC3339StartTime string + PodRFC3339FinishTime string + PodUnixStartTime int64 + PodUnixFinishTime int64 + PodUID string + TaskExecutionID pluginsCore.TaskExecutionID + ExtraTemplateVars []TemplateVar + TaskTemplate *core.TaskTemplate + EnableVscode bool + AgentID string + ConnectorID string +} + +// Output contains all task logs a plugin generates for a given Input. +type Output struct { + TaskLogs []*core.TaskLog +} + +// Plugin represents an interface for task log plugins to implement to plug generated task log links into task events. +type Plugin interface { + // Generates a TaskLog object given necessary computation information + GetTaskLogs(i Input) (logs Output, err error) +} + +type TemplateLogPlugin struct { + Name string `json:"name" pflag:",Name of the plugin."` + DisplayName string `json:"displayName" pflag:",Display name for the generated log when displayed in the console."` + TemplateURIs []TemplateURI `json:"templateUris" pflag:",URI Templates for generating task log links."` + DynamicTemplateURIs []TemplateURI `json:"dynamicTemplateUris" pflag:",URI Templates for generating dynamic task log links."` + MessageFormat core.TaskLog_MessageFormat `json:"messageFormat" pflag:"-,Log Message Format."` + // Deprecated: Please, do not use + DeprecatedScheme TemplateScheme `json:"scheme" pflag:",Templating scheme to use. Supported values are Pod and TaskExecution."` + ShowWhilePending bool `json:"showWhilePending" pflag:",If true, the log link will be shown even if the task is in a pending state."` + HideOnceFinished bool `json:"hideOnceFinished" pflag:",If true, the log link will be hidden once the task has finished."` + LinkType string `json:"linkType" pflag:",Type of the log. (external, dashboard, or ide). This is used to distinguish between different log links."` +} diff --git a/flyteplugins/go/tasks/pluginmachinery/tasklog/template.go b/flyteplugins/go/tasks/pluginmachinery/tasklog/template.go new file mode 100644 index 0000000000..ff67a27eaa --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/tasklog/template.go @@ -0,0 +1,281 @@ +package tasklog + +import ( + "fmt" + "regexp" + "slices" + "strconv" + "strings" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const vscode = "vscode" + +func MustCreateRegex(varName string) *regexp.Regexp { + return regexp.MustCompile(fmt.Sprintf(`(?i){{\s*[\.$]%s\s*}}`, varName)) +} + +var taskConfigVarRegex = regexp.MustCompile(`(?i){{\s*.taskConfig[\.$]([a-zA-Z_]+)\s*}}`) + +func MustCreateDynamicLogRegex(varName string) *regexp.Regexp { + return regexp.MustCompile(fmt.Sprintf(`(?i){{\s*.taskConfig[\.$]%s\s*}}`, varName)) +} + +type templateRegexes struct { + LogName *regexp.Regexp + PodName *regexp.Regexp + PodUID *regexp.Regexp + Namespace *regexp.Regexp + ContainerName *regexp.Regexp + ContainerID *regexp.Regexp + Hostname *regexp.Regexp + PodRFC3339StartTime *regexp.Regexp + PodRFC3339FinishTime *regexp.Regexp + PodUnixStartTime *regexp.Regexp + PodUnixFinishTime *regexp.Regexp + TaskID *regexp.Regexp + TaskVersion *regexp.Regexp + TaskOrg *regexp.Regexp + TaskProject *regexp.Regexp + TaskDomain *regexp.Regexp + TaskRetryAttempt *regexp.Regexp + NodeID *regexp.Regexp + ExecutionName *regexp.Regexp + ExecutionProject *regexp.Regexp + ExecutionDomain *regexp.Regexp + ExecutionOrg *regexp.Regexp + GeneratedName *regexp.Regexp + AgentID *regexp.Regexp + ConnectorID *regexp.Regexp +} + +func initDefaultRegexes() templateRegexes { + return templateRegexes{ + MustCreateRegex("logName"), + MustCreateRegex("podName"), + MustCreateRegex("podUID"), + MustCreateRegex("namespace"), + MustCreateRegex("containerName"), + MustCreateRegex("containerID"), + MustCreateRegex("hostname"), + MustCreateRegex("podRFC3339StartTime"), + MustCreateRegex("podRFC3339FinishTime"), + MustCreateRegex("podUnixStartTime"), + MustCreateRegex("podUnixFinishTime"), + MustCreateRegex("taskID"), + MustCreateRegex("taskVersion"), + MustCreateRegex("taskOrg"), + MustCreateRegex("taskProject"), + MustCreateRegex("taskDomain"), + MustCreateRegex("taskRetryAttempt"), + MustCreateRegex("nodeID"), + MustCreateRegex("executionName"), + MustCreateRegex("executionProject"), + MustCreateRegex("executionDomain"), + MustCreateRegex("executionOrg"), + MustCreateRegex("generatedName"), + MustCreateRegex("agentID"), + MustCreateRegex("connectorID"), + } +} + +var defaultRegexes = initDefaultRegexes() + +func replaceAll(template string, vars []TemplateVar) string { + for _, v := range vars { + if len(v.Value) > 0 { + template = v.Regex.ReplaceAllLiteralString(template, v.Value) + } + } + return template +} + +func (input Input) templateVars() []TemplateVar { + vars := []TemplateVar{ + TemplateVar{defaultRegexes.LogName, input.LogName}, + } + + gotExtraTemplateVars := input.ExtraTemplateVars != nil + if gotExtraTemplateVars { + vars = append(vars, input.ExtraTemplateVars...) + } + + // Container IDs are prefixed with docker://, cri-o://, etc. which is stripped by fluentd before pushing to a log + // stream. Therefore, we must also strip the prefix. + containerID := input.ContainerID + stripDelimiter := "://" + if split := strings.Split(input.ContainerID, stripDelimiter); len(split) > 1 { + containerID = split[1] + } + vars = append( + vars, + TemplateVar{defaultRegexes.PodName, input.PodName}, + TemplateVar{defaultRegexes.PodUID, input.PodUID}, + TemplateVar{defaultRegexes.Namespace, input.Namespace}, + TemplateVar{defaultRegexes.ContainerName, input.ContainerName}, + TemplateVar{defaultRegexes.ContainerID, containerID}, + TemplateVar{defaultRegexes.Hostname, input.HostName}, + ) + + if input.AgentID != "" { + vars = append(vars, TemplateVar{defaultRegexes.AgentID, input.AgentID}) + } + if input.ConnectorID != "" { + vars = append(vars, TemplateVar{defaultRegexes.ConnectorID, input.ConnectorID}) + } + + if input.TaskExecutionID != nil { + taskExecutionIdentifier := input.TaskExecutionID.GetID() + vars = append( + vars, + TemplateVar{ + defaultRegexes.NodeID, + input.TaskExecutionID.GetUniqueNodeID(), + }, + TemplateVar{ + defaultRegexes.GeneratedName, + input.TaskExecutionID.GetGeneratedName(), + }, + TemplateVar{ + defaultRegexes.TaskRetryAttempt, + strconv.FormatUint(uint64(taskExecutionIdentifier.RetryAttempt), 10), + }, + ) + if taskExecutionIdentifier.TaskId != nil { + vars = append( + vars, + TemplateVar{ + defaultRegexes.TaskID, + taskExecutionIdentifier.TaskId.Name, + }, + TemplateVar{ + defaultRegexes.TaskVersion, + taskExecutionIdentifier.TaskId.Version, + }, + TemplateVar{ + defaultRegexes.TaskOrg, + taskExecutionIdentifier.TaskId.Org, + }, + TemplateVar{ + defaultRegexes.TaskProject, + taskExecutionIdentifier.TaskId.Project, + }, + TemplateVar{ + defaultRegexes.TaskDomain, + taskExecutionIdentifier.TaskId.Domain, + }, + ) + } + if taskExecutionIdentifier.NodeExecutionId != nil && taskExecutionIdentifier.NodeExecutionId.ExecutionId != nil { + vars = append( + vars, + TemplateVar{ + defaultRegexes.ExecutionName, + taskExecutionIdentifier.NodeExecutionId.ExecutionId.Name, + }, + TemplateVar{ + defaultRegexes.ExecutionProject, + taskExecutionIdentifier.NodeExecutionId.ExecutionId.Project, + }, + TemplateVar{ + defaultRegexes.ExecutionDomain, + taskExecutionIdentifier.NodeExecutionId.ExecutionId.Domain, + }, + TemplateVar{ + defaultRegexes.ExecutionOrg, + taskExecutionIdentifier.NodeExecutionId.ExecutionId.Org, + }, + ) + } + } + + vars = append( + vars, + TemplateVar{defaultRegexes.PodRFC3339StartTime, input.PodRFC3339StartTime}, + TemplateVar{defaultRegexes.PodRFC3339FinishTime, input.PodRFC3339FinishTime}, + TemplateVar{ + defaultRegexes.PodUnixStartTime, + strconv.FormatInt(input.PodUnixStartTime, 10), + }, + TemplateVar{ + defaultRegexes.PodUnixFinishTime, + strconv.FormatInt(input.PodUnixFinishTime, 10), + }, + ) + + return vars +} + +func getDynamicLogLinkTypes(input Input) []string { + var dynamicLogLinkTypes []string + if input.EnableVscode { + dynamicLogLinkTypes = []string{vscode} + } + + if input.TaskTemplate == nil { + return dynamicLogLinkTypes + } + + config := input.TaskTemplate.GetConfig() + if config == nil { + return dynamicLogLinkTypes + } + linkType := config["link_type"] + if linkType == "" { + return dynamicLogLinkTypes + } + logLinkTypes := append(strings.Split(linkType, ","), dynamicLogLinkTypes...) + slices.Sort(logLinkTypes) + return slices.Compact(logLinkTypes) +} + +func (p TemplateLogPlugin) GetTaskLogs(input Input) (Output, error) { + templateVars := input.templateVars() + linkType := core.TaskLog_EXTERNAL + if len(p.LinkType) != 0 { + linkType = core.TaskLog_LinkType(core.TaskLog_LinkType_value[strings.ToUpper(p.LinkType)]) + } + + taskLogs := make([]*core.TaskLog, 0, len(p.TemplateURIs)) + for _, templateURI := range p.TemplateURIs { + taskLogs = append(taskLogs, &core.TaskLog{ + Uri: replaceAll(templateURI, templateVars), + Name: replaceAll(p.DisplayName, templateVars) + replaceAll(input.LogName, templateVars), + MessageFormat: p.MessageFormat, + ShowWhilePending: p.ShowWhilePending, + HideOnceFinished: p.HideOnceFinished, + LinkType: linkType, + Ready: true, + }) + } + + for _, dynamicLogLinkType := range getDynamicLogLinkTypes(input) { + for _, dynamicTemplateURI := range p.DynamicTemplateURIs { + if p.Name == dynamicLogLinkType { + for _, match := range taskConfigVarRegex.FindAllStringSubmatch(dynamicTemplateURI, -1) { + if len(match) > 1 { + if value, found := input.TaskTemplate.GetConfig()[match[1]]; found { + templateVars = append(templateVars, TemplateVar{MustCreateDynamicLogRegex(match[1]), value}) + } + } + } + if dynamicLogLinkType == vscode { + linkType = core.TaskLog_IDE + } + + taskLogs = append(taskLogs, &core.TaskLog{ + Uri: replaceAll(dynamicTemplateURI, templateVars), + Name: p.DisplayName + input.LogName, + MessageFormat: p.MessageFormat, + ShowWhilePending: p.ShowWhilePending, + HideOnceFinished: p.HideOnceFinished, + LinkType: linkType, + Ready: true, + }) + } + } + } + + return Output{TaskLogs: taskLogs}, nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/tasklog/template_test.go b/flyteplugins/go/tasks/pluginmachinery/tasklog/template_test.go new file mode 100644 index 0000000000..c276e5bc81 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/tasklog/template_test.go @@ -0,0 +1,681 @@ +package tasklog + +import ( + "reflect" + "regexp" + "testing" + + "github.com/stretchr/testify/assert" + + pluginCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + coreMocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +// Latest Run: Benchmark_mustInitTemplateRegexes-16 45960 26914 ns/op +func Benchmark_initDefaultRegexes(b *testing.B) { + for i := 0; i < b.N; i++ { + initDefaultRegexes() + } +} + +func dummyTaskExecID() pluginCore.TaskExecutionID { + tID := &coreMocks.TaskExecutionID{} + tID.EXPECT().GetGeneratedName().Return("generated-name") + tID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + TaskId: &core.Identifier{ + ResourceType: core.ResourceType_TASK, + Name: "my-task-name", + Project: "my-task-project", + Domain: "my-task-domain", + Version: "1", + Org: "my-task-org", + }, + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my-execution-name", + Project: "my-execution-project", + Domain: "my-execution-domain", + Org: "my-execution-org", + }, + }, + RetryAttempt: 1, + }) + tID.EXPECT().GetUniqueNodeID().Return("n0-0-n0") + return tID +} + +func Test_Input_templateVars(t *testing.T) { + testRegexes := struct { + Foo *regexp.Regexp + Bar *regexp.Regexp + Baz *regexp.Regexp + Ham *regexp.Regexp + Spam *regexp.Regexp + LinkType *regexp.Regexp + Port *regexp.Regexp + }{ + MustCreateRegex("foo"), + MustCreateRegex("bar"), + MustCreateRegex("baz"), + MustCreateRegex("ham"), + MustCreateRegex("spam"), + MustCreateDynamicLogRegex("link_type"), + MustCreateDynamicLogRegex("port"), + } + podBase := Input{ + HostName: "my-host", + PodName: "my-pod", + PodUID: "my-pod-uid", + Namespace: "my-namespace", + ContainerName: "my-container", + ContainerID: "docker://containerID", + LogName: "main_logs", + PodRFC3339StartTime: "1970-01-01T01:02:03+01:00", + PodRFC3339FinishTime: "1970-01-01T04:25:45+01:00", + PodUnixStartTime: 123, + PodUnixFinishTime: 12345, + } + taskExecutionBase := Input{ + LogName: "main_logs", + TaskExecutionID: dummyTaskExecID(), + PodRFC3339StartTime: "1970-01-01T01:02:03+01:00", + PodRFC3339FinishTime: "1970-01-01T04:25:45+01:00", + PodUnixStartTime: 123, + PodUnixFinishTime: 12345, + } + + tests := []struct { + name string + baseVars Input + extraVars []TemplateVar + exact []TemplateVar + contains []TemplateVar + notContains []TemplateVar + }{ + { + "pod happy path", + podBase, + nil, + []TemplateVar{ + {defaultRegexes.LogName, "main_logs"}, + {defaultRegexes.PodName, "my-pod"}, + {defaultRegexes.PodUID, "my-pod-uid"}, + {defaultRegexes.Namespace, "my-namespace"}, + {defaultRegexes.ContainerName, "my-container"}, + {defaultRegexes.ContainerID, "containerID"}, + {defaultRegexes.Hostname, "my-host"}, + {defaultRegexes.PodRFC3339StartTime, "1970-01-01T01:02:03+01:00"}, + {defaultRegexes.PodRFC3339FinishTime, "1970-01-01T04:25:45+01:00"}, + {defaultRegexes.PodUnixStartTime, "123"}, + {defaultRegexes.PodUnixFinishTime, "12345"}, + }, + nil, + nil, + }, + { + "pod with extra vars", + podBase, + []TemplateVar{ + {testRegexes.Foo, "foo"}, + {testRegexes.Bar, "bar"}, + {testRegexes.Baz, "baz"}, + }, + nil, + []TemplateVar{ + {testRegexes.Foo, "foo"}, + {testRegexes.Bar, "bar"}, + {testRegexes.Baz, "baz"}, + }, + nil, + }, + { + "task execution happy path", + taskExecutionBase, + nil, + []TemplateVar{ + {defaultRegexes.LogName, "main_logs"}, + {defaultRegexes.PodName, ""}, + {defaultRegexes.PodUID, ""}, + {defaultRegexes.Namespace, ""}, + {defaultRegexes.ContainerName, ""}, + {defaultRegexes.ContainerID, ""}, + {defaultRegexes.Hostname, ""}, + {defaultRegexes.NodeID, "n0-0-n0"}, + {defaultRegexes.GeneratedName, "generated-name"}, + {defaultRegexes.TaskRetryAttempt, "1"}, + {defaultRegexes.TaskID, "my-task-name"}, + {defaultRegexes.TaskVersion, "1"}, + {defaultRegexes.TaskOrg, "my-task-org"}, + {defaultRegexes.TaskProject, "my-task-project"}, + {defaultRegexes.TaskDomain, "my-task-domain"}, + {defaultRegexes.ExecutionName, "my-execution-name"}, + {defaultRegexes.ExecutionProject, "my-execution-project"}, + {defaultRegexes.ExecutionDomain, "my-execution-domain"}, + {defaultRegexes.ExecutionOrg, "my-execution-org"}, + {defaultRegexes.PodRFC3339StartTime, "1970-01-01T01:02:03+01:00"}, + {defaultRegexes.PodRFC3339FinishTime, "1970-01-01T04:25:45+01:00"}, + {defaultRegexes.PodUnixStartTime, "123"}, + {defaultRegexes.PodUnixFinishTime, "12345"}, + }, + nil, + nil, + }, + { + "task execution with extra vars", + taskExecutionBase, + []TemplateVar{ + {testRegexes.Foo, "foo"}, + {testRegexes.Bar, "bar"}, + {testRegexes.Baz, "baz"}, + }, + nil, + []TemplateVar{ + {testRegexes.Foo, "foo"}, + {testRegexes.Bar, "bar"}, + {testRegexes.Baz, "baz"}, + }, + nil, + }, + { + "pod with port not affected", + podBase, + nil, + nil, + nil, + []TemplateVar{ + {testRegexes.Port, "1234"}, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + base := tt.baseVars + base.ExtraTemplateVars = tt.extraVars + got := base.templateVars() + if tt.exact != nil { + assert.Equal(t, got, tt.exact) + } + if tt.contains != nil { + for _, c := range tt.contains { + assert.Contains(t, got, c) + } + } + if tt.notContains != nil { + for _, c := range tt.notContains { + assert.NotContains(t, got, c) + } + } + }) + } +} + +func TestTemplateLogPlugin(t *testing.T) { + type args struct { + input Input + } + tests := []struct { + name string + plugin TemplateLogPlugin + args args + want Output + }{ + { + "cloudwatch", + TemplateLogPlugin{ + TemplateURIs: []TemplateURI{"https://console.aws.amazon.com/cloudwatch/home?region=us-east-1#logEventViewer:group=/flyte-production/kubernetes;stream=var.log.containers.{{.podName}}_{{.namespace}}_{{.containerName}}-{{.containerId}}.log"}, + MessageFormat: core.TaskLog_JSON, + }, + args{ + input: Input{ + PodName: "f-uuid-driver", + PodUID: "pod-uid", + Namespace: "flyteexamples-production", + ContainerName: "spark-kubernetes-driver", + ContainerID: "cri-o://abc", + LogName: "main_logs", + PodRFC3339StartTime: "1970-01-01T01:02:03+01:00", + PodRFC3339FinishTime: "1970-01-01T04:25:45+01:00", + PodUnixStartTime: 123, + PodUnixFinishTime: 12345, + }, + }, + Output{TaskLogs: []*core.TaskLog{{ + Uri: "https://console.aws.amazon.com/cloudwatch/home?region=us-east-1#logEventViewer:group=/flyte-production/kubernetes;stream=var.log.containers.f-uuid-driver_flyteexamples-production_spark-kubernetes-driver-abc.log", + MessageFormat: core.TaskLog_JSON, + Name: "main_logs", + Ready: true, + }}}, + }, + { + "stackdriver", + TemplateLogPlugin{ + TemplateURIs: []TemplateURI{"https://console.cloud.google.com/logs/viewer?project=test-gcp-project&angularJsUrl=%2Flogs%2Fviewer%3Fproject%3Dtest-gcp-project&resource=aws_ec2_instance&advancedFilter=resource.labels.pod_name%3D{{.podName}}"}, + MessageFormat: core.TaskLog_JSON, + }, + args{ + input: Input{ + PodName: "podName", + PodUID: "pod-uid", + Namespace: "flyteexamples-production", + ContainerName: "spark-kubernetes-driver", + ContainerID: "cri-o://abc", + LogName: "main_logs", + PodRFC3339StartTime: "1970-01-01T01:02:03+01:00", + PodRFC3339FinishTime: "1970-01-01T04:25:45+01:00", + PodUnixStartTime: 123, + PodUnixFinishTime: 12345, + }, + }, + Output{TaskLogs: []*core.TaskLog{{ + Uri: "https://console.cloud.google.com/logs/viewer?project=test-gcp-project&angularJsUrl=%2Flogs%2Fviewer%3Fproject%3Dtest-gcp-project&resource=aws_ec2_instance&advancedFilter=resource.labels.pod_name%3DpodName", + MessageFormat: core.TaskLog_JSON, + Name: "main_logs", + Ready: true, + }}}, + }, + { + "kubernetes", + TemplateLogPlugin{ + TemplateURIs: []TemplateURI{"https://dashboard.k8s.net/#!/log/{{.namespace}}/{{.podName}}/pod?namespace={{.namespace}}"}, + MessageFormat: core.TaskLog_JSON, + }, + args{ + input: Input{ + PodName: "flyteexamples-development-task-name", + PodUID: "pod-uid", + Namespace: "flyteexamples-development", + ContainerName: "ignore", + ContainerID: "ignore", + LogName: "main_logs", + PodRFC3339StartTime: "1970-01-01T01:02:03+01:00", + PodRFC3339FinishTime: "1970-01-01T04:25:45+01:00", + PodUnixStartTime: 123, + PodUnixFinishTime: 12345, + }, + }, + Output{TaskLogs: []*core.TaskLog{{ + Uri: "https://dashboard.k8s.net/#!/log/flyteexamples-development/flyteexamples-development-task-name/pod?namespace=flyteexamples-development", + MessageFormat: core.TaskLog_JSON, + Name: "main_logs", + Ready: true, + }}}, + }, + { + "splunk", + TemplateLogPlugin{ + TemplateURIs: []TemplateURI{"https://prd-p-ighar.splunkcloud.com/en-US/app/search/search?q=search%20container_name%3D%22{{ .containerName }}%22"}, + MessageFormat: core.TaskLog_JSON, + }, + args{ + input: Input{ + HostName: "my-host", + PodName: "my-pod", + Namespace: "my-namespace", + ContainerName: "my-container", + ContainerID: "ignore", + LogName: "main_logs", + PodRFC3339StartTime: "1970-01-01T01:02:03+01:00", + PodRFC3339FinishTime: "1970-01-01T04:25:45+01:00", + PodUnixStartTime: 123, + PodUnixFinishTime: 12345, + }, + }, + Output{ + TaskLogs: []*core.TaskLog{ + { + Uri: "https://prd-p-ighar.splunkcloud.com/en-US/app/search/search?q=search%20container_name%3D%22my-container%22", + MessageFormat: core.TaskLog_JSON, + Name: "main_logs", + Ready: true, + }, + }, + }, + }, + { + "ddog", + TemplateLogPlugin{ + TemplateURIs: []TemplateURI{"https://app.datadoghq.com/logs?event&from_ts={{ .podUnixStartTime }}&live=true&query=pod_name%3A{{ .podName }}&to_ts={{ .podUnixFinishTime }}"}, + MessageFormat: core.TaskLog_JSON, + }, + args{ + input: Input{ + HostName: "my-host", + PodName: "my-pod", + Namespace: "my-namespace", + ContainerName: "my-container", + ContainerID: "ignore", + LogName: "main_logs", + PodRFC3339StartTime: "1970-01-01T01:02:03+01:00", + PodRFC3339FinishTime: "1970-01-01T04:25:45+01:00", + PodUnixStartTime: 123, + PodUnixFinishTime: 12345, + }, + }, + Output{ + TaskLogs: []*core.TaskLog{ + { + Uri: "https://app.datadoghq.com/logs?event&from_ts=123&live=true&query=pod_name%3Amy-pod&to_ts=12345", + MessageFormat: core.TaskLog_JSON, + Name: "main_logs", + Ready: true, + }, + }, + }, + }, + { + "stackdriver-with-rfc3339-timestamp", + TemplateLogPlugin{ + TemplateURIs: []TemplateURI{"https://console.cloud.google.com/logs/viewer?project=test-gcp-project&angularJsUrl=%2Flogs%2Fviewer%3Fproject%3Dtest-gcp-project&resource=aws_ec2_instance&advancedFilter=resource.labels.pod_name%3D{{.podName}}%20%22{{.podRFC3339StartTime}}%22"}, + MessageFormat: core.TaskLog_JSON, + }, + args{ + input: Input{ + HostName: "my-host", + PodName: "my-pod", + Namespace: "my-namespace", + ContainerName: "my-container", + ContainerID: "ignore", + LogName: "main_logs", + PodRFC3339StartTime: "1970-01-01T01:02:03+01:00", + PodRFC3339FinishTime: "1970-01-01T04:25:45+01:00", + PodUnixStartTime: 123, + PodUnixFinishTime: 12345, + }, + }, + Output{ + TaskLogs: []*core.TaskLog{ + { + Uri: "https://console.cloud.google.com/logs/viewer?project=test-gcp-project&angularJsUrl=%2Flogs%2Fviewer%3Fproject%3Dtest-gcp-project&resource=aws_ec2_instance&advancedFilter=resource.labels.pod_name%3Dmy-pod%20%221970-01-01T01:02:03+01:00%22", + MessageFormat: core.TaskLog_JSON, + Name: "main_logs", + Ready: true, + }, + }, + }, + }, + { + "task-with-task-execution-identifier", + TemplateLogPlugin{ + TemplateURIs: []TemplateURI{"https://flyte.corp.net/console/projects/{{ .executionProject }}/domains/{{ .executionDomain }}/executions/{{ .executionName }}/nodeId/{{ .nodeID }}/taskId/{{ .taskID }}/attempt/{{ .taskRetryAttempt }}/view/logs"}, + MessageFormat: core.TaskLog_JSON, + }, + args{ + input: Input{ + HostName: "my-host", + PodName: "my-pod", + Namespace: "my-namespace", + ContainerName: "my-container", + ContainerID: "ignore", + LogName: "main_logs", + PodRFC3339StartTime: "1970-01-01T01:02:03+01:00", + PodRFC3339FinishTime: "1970-01-01T04:25:45+01:00", + PodUnixStartTime: 123, + PodUnixFinishTime: 12345, + TaskExecutionID: dummyTaskExecID(), + }, + }, + Output{ + TaskLogs: []*core.TaskLog{ + { + Uri: "https://flyte.corp.net/console/projects/my-execution-project/domains/my-execution-domain/executions/my-execution-name/nodeId/n0-0-n0/taskId/my-task-name/attempt/1/view/logs", + MessageFormat: core.TaskLog_JSON, + Name: "main_logs", + Ready: true, + }, + }, + }, + }, + { + "task-with-task-execution-identifier-with-org", + TemplateLogPlugin{ + TemplateURIs: []TemplateURI{"https://flyte.corp.net/console/org/{{ .executionOrg }}/projects/{{ .executionProject }}/domains/{{ .executionDomain }}/executions/{{ .executionName }}/nodeId/{{ .nodeID }}/taskId/{{ .taskID }}/taskOrg/{{ .taskOrg }}/attempt/{{ .taskRetryAttempt }}/view/logs"}, + MessageFormat: core.TaskLog_JSON, + }, + args{ + input: Input{ + HostName: "my-host", + PodName: "my-pod", + Namespace: "my-namespace", + ContainerName: "my-container", + ContainerID: "ignore", + LogName: "main_logs", + PodRFC3339StartTime: "1970-01-01T01:02:03+01:00", + PodRFC3339FinishTime: "1970-01-01T04:25:45+01:00", + PodUnixStartTime: 123, + PodUnixFinishTime: 12345, + TaskExecutionID: dummyTaskExecID(), + }, + }, + Output{ + TaskLogs: []*core.TaskLog{ + { + Uri: "https://flyte.corp.net/console/org/my-execution-org/projects/my-execution-project/domains/my-execution-domain/executions/my-execution-name/nodeId/n0-0-n0/taskId/my-task-name/taskOrg/my-task-org/attempt/1/view/logs", + MessageFormat: core.TaskLog_JSON, + Name: "main_logs", + Ready: true, + }, + }, + }, + }, + { + "mapped-task-with-task-execution-identifier", + TemplateLogPlugin{ + TemplateURIs: []TemplateURI{"https://flyte.corp.net/console/projects/{{ .executionProject }}/domains/{{ .executionDomain }}/executions/{{ .executionName }}/nodeId/{{ .nodeID }}/taskId/{{ .taskID }}/attempt/{{ .subtaskParentRetryAttempt }}/mappedIndex/{{ .subtaskExecutionIndex }}/mappedAttempt/{{ .subtaskRetryAttempt }}/view/logs"}, + MessageFormat: core.TaskLog_JSON, + }, + args{ + input: Input{ + HostName: "my-host", + PodName: "my-pod", + Namespace: "my-namespace", + ContainerName: "my-container", + ContainerID: "ignore", + LogName: "main_logs", + PodRFC3339StartTime: "1970-01-01T01:02:03+01:00", + PodRFC3339FinishTime: "1970-01-01T04:25:45+01:00", + PodUnixStartTime: 123, + PodUnixFinishTime: 12345, + TaskExecutionID: dummyTaskExecID(), + ExtraTemplateVars: []TemplateVar{ + {MustCreateRegex("subtaskExecutionIndex"), "1"}, + {MustCreateRegex("subtaskRetryAttempt"), "1"}, + {MustCreateRegex("subtaskParentRetryAttempt"), "0"}, + }, + }, + }, + Output{ + TaskLogs: []*core.TaskLog{ + { + Uri: "https://flyte.corp.net/console/projects/my-execution-project/domains/my-execution-domain/executions/my-execution-name/nodeId/n0-0-n0/taskId/my-task-name/attempt/0/mappedIndex/1/mappedAttempt/1/view/logs", + MessageFormat: core.TaskLog_JSON, + Name: "main_logs", + Ready: true, + }, + }, + }, + }, + { + "flyteinteractive", + TemplateLogPlugin{ + Name: vscode, + DynamicTemplateURIs: []TemplateURI{"vscode://flyteinteractive:{{ .taskConfig.port }}/{{ .podName }}"}, + MessageFormat: core.TaskLog_JSON, + }, + args{ + input: Input{ + PodName: "my-pod-name", + TaskTemplate: &core.TaskTemplate{ + Config: map[string]string{ + "link_type": vscode, + "port": "1234", + }, + }, + }, + }, + Output{ + TaskLogs: []*core.TaskLog{ + { + Uri: "vscode://flyteinteractive:1234/my-pod-name", + MessageFormat: core.TaskLog_JSON, + LinkType: core.TaskLog_IDE, + Ready: true, + }, + }, + }, + }, + { + "flyteinteractive", + TemplateLogPlugin{ + Name: "vscode", + DynamicTemplateURIs: []TemplateURI{"vscode://flyteinteractive:{{ .taskConfig.port }}/{{ .podName }}"}, + MessageFormat: core.TaskLog_JSON, + HideOnceFinished: true, + ShowWhilePending: true, + }, + args{ + input: Input{ + PodName: "my-pod-name", + TaskTemplate: &core.TaskTemplate{ + Config: map[string]string{ + "link_type": "vscode", + "port": "1234", + }, + }, + }, + }, + Output{ + TaskLogs: []*core.TaskLog{ + { + Uri: "vscode://flyteinteractive:1234/my-pod-name", + MessageFormat: core.TaskLog_JSON, + ShowWhilePending: true, + HideOnceFinished: true, + LinkType: core.TaskLog_IDE, + Ready: true, + }, + }, + }, + }, + { + "flyteinteractive - no link_type in task template", + TemplateLogPlugin{ + Name: vscode, + DynamicTemplateURIs: []TemplateURI{"vscode://flyteinteractive:{{ .taskConfig.port }}/{{ .podName }}"}, + MessageFormat: core.TaskLog_JSON, + DisplayName: "Flyteinteractive Logs", + }, + args{ + input: Input{ + PodName: "my-pod-name", + }, + }, + Output{ + TaskLogs: []*core.TaskLog{}, + }, + }, + { + "kubernetes", + TemplateLogPlugin{ + TemplateURIs: []TemplateURI{"https://dashboard.k8s.net/#!/log/{{.namespace}}/{{.podName}}/pod?namespace={{.namespace}}"}, + MessageFormat: core.TaskLog_JSON, + }, + args{ + input: Input{ + PodName: "flyteexamples-development-task-name", + PodUID: "pod-uid", + Namespace: "flyteexamples-development", + ContainerName: "ignore", + ContainerID: "ignore", + LogName: "main_logs", + PodRFC3339StartTime: "1970-01-01T01:02:03+01:00", + PodRFC3339FinishTime: "1970-01-01T04:25:45+01:00", + PodUnixStartTime: 123, + PodUnixFinishTime: 12345, + }, + }, + Output{TaskLogs: []*core.TaskLog{{ + Uri: "https://dashboard.k8s.net/#!/log/flyteexamples-development/flyteexamples-development-task-name/pod?namespace=flyteexamples-development", + MessageFormat: core.TaskLog_JSON, + Name: "main_logs", + Ready: true, + }}}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := tt.plugin.GetTaskLogs(tt.args.input) + assert.NoError(t, err) + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("GetTaskLogs() got = %v, want %v", got, tt.want) + } + }) + } +} + +func TestGetDynamicLogLinkTypes(t *testing.T) { + linkTypes := getDynamicLogLinkTypes(Input{}) + assert.Nil(t, linkTypes) + + linkTypes = getDynamicLogLinkTypes(Input{ + PodName: "my-pod-name", + TaskTemplate: &core.TaskTemplate{}, + }) + assert.Nil(t, linkTypes) + + // Test that empty input with vscode enabled returns vscode + linkTypes = getDynamicLogLinkTypes(Input{ + EnableVscode: true, + }) + assert.Equal(t, []string{vscode}, linkTypes) + + // Test that nil TaskTemplate returns dynamicLogLinkTypes when vscode enabled + linkTypes = getDynamicLogLinkTypes(Input{ + EnableVscode: true, + TaskTemplate: nil, + }) + assert.Equal(t, []string{vscode}, linkTypes) + + linkTypes = getDynamicLogLinkTypes(Input{ + EnableVscode: true, + TaskTemplate: &core.TaskTemplate{ + Config: map[string]string{ + "link_type": vscode, + "port": "8080", + }, + }, + }) + assert.Equal(t, []string{vscode}, linkTypes) + + linkTypes = getDynamicLogLinkTypes(Input{ + EnableVscode: true, + TaskTemplate: &core.TaskTemplate{ + Config: map[string]string{ + "link_type": "vscode,vscode", + }, + }, + }) + assert.Equal(t, []string{vscode}, linkTypes) + + linkTypes = getDynamicLogLinkTypes(Input{ + PodName: "my-pod-name", + TaskTemplate: &core.TaskTemplate{ + Config: map[string]string{ + "link_type": vscode, + "port": "8080", + }, + }, + }) + assert.Equal(t, []string{vscode}, linkTypes) + linkTypes = getDynamicLogLinkTypes(Input{ + PodName: "my-pod-name", + TaskTemplate: &core.TaskTemplate{ + Config: map[string]string{ + "link_type": "wandb", + "port": "8080", + }, + }, + EnableVscode: true, + }) + assert.Equal(t, []string{vscode, "wandb"}, linkTypes) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/tasklog/templatescheme_enumer.go b/flyteplugins/go/tasks/pluginmachinery/tasklog/templatescheme_enumer.go new file mode 100644 index 0000000000..70f15faf01 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/tasklog/templatescheme_enumer.go @@ -0,0 +1,84 @@ +// Code generated by "enumer --type=TemplateScheme --trimprefix=TemplateScheme -json -yaml"; DO NOT EDIT. + +package tasklog + +import ( + "encoding/json" + "fmt" +) + +const _TemplateSchemeName = "PodTaskExecution" + +var _TemplateSchemeIndex = [...]uint8{0, 3, 16} + +func (i TemplateScheme) String() string { + if i < 0 || i >= TemplateScheme(len(_TemplateSchemeIndex)-1) { + return fmt.Sprintf("TemplateScheme(%d)", i) + } + return _TemplateSchemeName[_TemplateSchemeIndex[i]:_TemplateSchemeIndex[i+1]] +} + +var _TemplateSchemeValues = []TemplateScheme{0, 1} + +var _TemplateSchemeNameToValueMap = map[string]TemplateScheme{ + _TemplateSchemeName[0:3]: 0, + _TemplateSchemeName[3:16]: 1, +} + +// TemplateSchemeString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func TemplateSchemeString(s string) (TemplateScheme, error) { + if val, ok := _TemplateSchemeNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to TemplateScheme values", s) +} + +// TemplateSchemeValues returns all values of the enum +func TemplateSchemeValues() []TemplateScheme { + return _TemplateSchemeValues +} + +// IsATemplateScheme returns "true" if the value is listed in the enum definition. "false" otherwise +func (i TemplateScheme) IsATemplateScheme() bool { + for _, v := range _TemplateSchemeValues { + if i == v { + return true + } + } + return false +} + +// MarshalJSON implements the json.Marshaler interface for TemplateScheme +func (i TemplateScheme) MarshalJSON() ([]byte, error) { + return json.Marshal(i.String()) +} + +// UnmarshalJSON implements the json.Unmarshaler interface for TemplateScheme +func (i *TemplateScheme) UnmarshalJSON(data []byte) error { + var s string + if err := json.Unmarshal(data, &s); err != nil { + return fmt.Errorf("TemplateScheme should be a string, got %s", data) + } + + var err error + *i, err = TemplateSchemeString(s) + return err +} + +// MarshalYAML implements a YAML Marshaler for TemplateScheme +func (i TemplateScheme) MarshalYAML() (interface{}, error) { + return i.String(), nil +} + +// UnmarshalYAML implements a YAML Unmarshaler for TemplateScheme +func (i *TemplateScheme) UnmarshalYAML(unmarshal func(interface{}) error) error { + var s string + if err := unmarshal(&s); err != nil { + return err + } + + var err error + *i, err = TemplateSchemeString(s) + return err +} diff --git a/flyteplugins/go/tasks/pluginmachinery/utils/dns.go b/flyteplugins/go/tasks/pluginmachinery/utils/dns.go new file mode 100644 index 0000000000..fa7f7ae405 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/utils/dns.go @@ -0,0 +1,39 @@ +package utils + +import ( + "regexp" + "strings" + + "k8s.io/apimachinery/pkg/util/validation" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/encoding" + "github.com/flyteorg/flyte/v2/flytestdlib/utils" +) + +var dns1123InvalidRegex = regexp.MustCompile("[^-.a-z0-9]") +var camelCaseRegex = regexp.MustCompile("([a-z0-9])([A-Z])") + +// ConvertToDNS1123SubdomainCompatibleString converts a string that doesn't conform to the definition of a subdomain in DNS (RFC 1123) to a string that conforms. It doesn't do well on labels (separated by dots) starting or ending with hyphens. +func ConvertToDNS1123SubdomainCompatibleString(name string) string { + if errs := validation.IsDNS1123Subdomain(name); len(errs) == 0 { + return name + } + name = ConvertCamelCaseToKebabCase(name) // best effort to preserve readability for Java class name + name = strings.ToLower(name) + name = dns1123InvalidRegex.ReplaceAllString(name, "") + name = strings.Trim(name, ".-") + if len(name) > validation.DNS1123SubdomainMaxLength { + fixedLengthID, err := encoding.FixedLengthUniqueID(name, utils.MaxUniqueIDLength) + if err == nil { + name = name[:validation.DNS1123SubdomainMaxLength-utils.MaxUniqueIDLength-1] + "-" + fixedLengthID + } else { + name = name[:validation.DNS1123SubdomainMaxLength] + } + } + return name +} + +// ConvertCamelCaseToKebabCase rewrites a string written in camel case (e.g. PenPineappleApplePen) in kebab case (pen-pineapple-apple-pen) +func ConvertCamelCaseToKebabCase(name string) string { + return strings.ToLower(camelCaseRegex.ReplaceAllString(name, "${1}-${2}")) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/utils/dns_test.go b/flyteplugins/go/tasks/pluginmachinery/utils/dns_test.go new file mode 100644 index 0000000000..b33c2ef1b0 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/utils/dns_test.go @@ -0,0 +1,109 @@ +package utils + +import ( + "testing" + + "k8s.io/apimachinery/pkg/util/validation" +) + +func TestConvertToDNS1123CompatibleString(t *testing.T) { + type args struct { + name string + } + tests := []struct { + name string + args args + want string + }{ + { + name: "flytekit-java task execution", + args: args{"orgflyteexamplesHelloWorldTask-0"}, + want: "orgflyteexamples-hello-world-task-0", + }, + { + name: "good pod name", + args: args{"t7vyqhzju1-fib-5-0"}, + want: "t7vyqhzju1-fib-5-0", + }, + { + name: "good pod name with dots", + args: args{"t7v.yqh.zju1-fib-5-0"}, + want: "t7v.yqh.zju1-fib-5-0", + }, + { + name: "leading hyphen", + args: args{"-t7vyqhzju1-fib-5-0"}, + want: "t7vyqhzju1-fib-5-0", + }, + { + name: "leading dot", + args: args{".t7vyqhzju1-fib-5-0"}, + want: "t7vyqhzju1-fib-5-0", + }, + { + name: "trailing hyphen", + args: args{"t7vyqhzju1-fib-5-0-"}, + want: "t7vyqhzju1-fib-5-0", + }, + { + name: "trailing dot", + args: args{"t7vyqhzju1-fib-5-0."}, + want: "t7vyqhzju1-fib-5-0", + }, + { + name: "long name", + args: args{"0123456789012345678901234567890123456789012345678901234567890123456789"}, + want: "0123456789012345678901234567890123456789012345678901234567890123456789", + }, + { + name: "longer than max len (253)", + args: args{"0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"}, + want: "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901-fbbrvh4i", + }, + { + name: "very invalid name", + args: args{"---..t7vyqhzjJcI==u1-HelloWorldTask[].-.-."}, + want: "t7vyqhzj-jc-iu1-hello-world-task", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := ConvertToDNS1123SubdomainCompatibleString(tt.args.name) + if errs := validation.IsDNS1123Subdomain(got); len(errs) > 0 { + t.Errorf("ConvertToDNS1123SubdomainCompatibleString() = %v, which is not DNS-1123 subdomain compatible", got) + } + if got != tt.want { + t.Errorf("ConvertToDNS1123SubdomainCompatibleString() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestConvertCamelCaseToKebabCase(t *testing.T) { + type args struct { + name string + } + tests := []struct { + name string + args args + want string + }{ + { + name: "flytekit-java task execution", + args: args{"orgflyteexamplesHelloWorldTask"}, + want: "orgflyteexamples-hello-world-task", + }, + { + name: "good pod name", + args: args{"t7vyqhzju1-fib-5-0"}, + want: "t7vyqhzju1-fib-5-0", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := ConvertCamelCaseToKebabCase(tt.args.name); got != tt.want { + t.Errorf("ConvertCamelCaseToKebabCase() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/utils/error_collection.go b/flyteplugins/go/tasks/pluginmachinery/utils/error_collection.go new file mode 100644 index 0000000000..f833b994c2 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/utils/error_collection.go @@ -0,0 +1,19 @@ +package utils + +import ( + "fmt" + "strings" +) + +type ErrorCollection struct { + Errors []error +} + +func (e ErrorCollection) Error() string { + sb := strings.Builder{} + for idx, err := range e.Errors { + sb.WriteString(fmt.Sprintf("%v: %v\r\n", idx, err)) + } + + return sb.String() +} diff --git a/flyteplugins/go/tasks/pluginmachinery/utils/error_collection_test.go b/flyteplugins/go/tasks/pluginmachinery/utils/error_collection_test.go new file mode 100644 index 0000000000..dd53182511 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/utils/error_collection_test.go @@ -0,0 +1,22 @@ +package utils + +import ( + "fmt" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestErrorCollection(t *testing.T) { + ec := ErrorCollection{} + + assert.Empty(t, ec.Error()) + + ec.Errors = append(ec.Errors, fmt.Errorf("error1")) + assert.NotEmpty(t, ec.Error()) + + ec.Errors = append(ec.Errors, fmt.Errorf("error2")) + assert.NotEmpty(t, ec.Error()) + + assert.Equal(t, "0: error1\r\n1: error2\r\n", ec.Error()) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/utils/maps.go b/flyteplugins/go/tasks/pluginmachinery/utils/maps.go new file mode 100644 index 0000000000..2e0f9dbb91 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/utils/maps.go @@ -0,0 +1,19 @@ +package utils + +// This function unions a list of maps (each can be nil or populated) by allocating a new map. +// Conflicting keys will always defer to the later input map's corresponding value. +func UnionMaps(maps ...map[string]string) map[string]string { + size := 0 + for _, m := range maps { + size += len(m) + } + + composite := make(map[string]string, size) + for _, m := range maps { + for k, v := range m { + composite[k] = v + } + } + + return composite +} diff --git a/flyteplugins/go/tasks/pluginmachinery/utils/maps_test.go b/flyteplugins/go/tasks/pluginmachinery/utils/maps_test.go new file mode 100644 index 0000000000..485e811377 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/utils/maps_test.go @@ -0,0 +1,30 @@ +package utils + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestUnionMaps(t *testing.T) { + assert.EqualValues(t, map[string]string{ + "left": "only", + }, UnionMaps(map[string]string{ + "left": "only", + }, nil)) + + assert.EqualValues(t, map[string]string{ + "right": "only", + }, UnionMaps(nil, map[string]string{ + "right": "only", + })) + + assert.EqualValues(t, map[string]string{ + "left": "val", + "right": "val", + }, UnionMaps(map[string]string{ + "left": "val", + }, map[string]string{ + "right": "val", + })) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/utils/marshal_utils.go b/flyteplugins/go/tasks/pluginmachinery/utils/marshal_utils.go new file mode 100755 index 0000000000..d437b47a0e --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/utils/marshal_utils.go @@ -0,0 +1,92 @@ +package utils + +import ( + "encoding/json" + "fmt" + "strings" + + "github.com/golang/protobuf/jsonpb" + "github.com/golang/protobuf/proto" + structpb "github.com/golang/protobuf/ptypes/struct" +) + +var jsonPbMarshaler = jsonpb.Marshaler{} +var jsonPbUnmarshaler = &jsonpb.Unmarshaler{ + AllowUnknownFields: true, +} + +// Deprecated: Use flytestdlib/utils.UnmarshalStructToPb instead. +func UnmarshalStruct(structObj *structpb.Struct, msg proto.Message) error { + if structObj == nil { + return fmt.Errorf("nil Struct Object passed") + } + + jsonObj, err := jsonPbMarshaler.MarshalToString(structObj) + if err != nil { + return err + } + + if err = jsonPbUnmarshaler.Unmarshal(strings.NewReader(jsonObj), msg); err != nil { + return err + } + + return nil +} + +// Deprecated: Use flytestdlib/utils.MarshalPbToStruct instead. +func MarshalStruct(in proto.Message, out *structpb.Struct) error { + if out == nil { + return fmt.Errorf("nil Struct Object passed") + } + + jsonObj, err := jsonPbMarshaler.MarshalToString(in) + if err != nil { + return err + } + + if err = jsonpb.UnmarshalString(jsonObj, out); err != nil { + return err + } + + return nil +} + +// Deprecated: Use flytestdlib/utils.MarshalToString instead. +func MarshalToString(msg proto.Message) (string, error) { + return jsonPbMarshaler.MarshalToString(msg) +} + +// Deprecated: Use flytestdlib/utils.MarshalObjToStruct instead. +// Don't use this if input is a proto Message. +func MarshalObjToStruct(input interface{}) (*structpb.Struct, error) { + b, err := json.Marshal(input) + if err != nil { + return nil, err + } + + // Turn JSON into a protobuf struct + structObj := &structpb.Struct{} + if err := jsonpb.UnmarshalString(string(b), structObj); err != nil { + return nil, err + } + return structObj, nil +} + +// Deprecated: Use flytestdlib/utils.UnmarshalStructToObj instead. +// Don't use this if the unmarshalled obj is a proto message. +func UnmarshalStructToObj(structObj *structpb.Struct, obj interface{}) error { + if structObj == nil { + return fmt.Errorf("nil Struct Object passed") + } + + jsonObj, err := json.Marshal(structObj) + if err != nil { + return err + } + + if err = json.Unmarshal(jsonObj, obj); err != nil { + return err + } + + return nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/utils/marshal_utils_test.go b/flyteplugins/go/tasks/pluginmachinery/utils/marshal_utils_test.go new file mode 100644 index 0000000000..abe1b7d2a2 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/utils/marshal_utils_test.go @@ -0,0 +1,54 @@ +package utils + +import ( + "encoding/json" + "testing" + + "github.com/go-test/deep" + structpb "github.com/golang/protobuf/ptypes/struct" + "github.com/stretchr/testify/assert" + v1 "k8s.io/api/core/v1" +) + +func TestUnmarshalStructToObj(t *testing.T) { + t.Run("no nil structs allowed", func(t *testing.T) { + var podSpec v1.PodSpec + err := UnmarshalStructToObj(nil, &podSpec) + assert.EqualError(t, err, "nil Struct Object passed") + }) + podSpec := v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "a container", + }, + { + Name: "another container", + }, + }, + } + + b, err := json.Marshal(podSpec) + if err != nil { + t.Fatal(err) + } + + structObj := &structpb.Struct{} + if err := json.Unmarshal(b, structObj); err != nil { + t.Fatal(err) + } + + t.Run("no nil pointers as obj allowed", func(t *testing.T) { + var nilPodspec *v1.PodSpec + err := UnmarshalStructToObj(structObj, nilPodspec) + assert.EqualError(t, err, "json: Unmarshal(nil *v1.PodSpec)") + }) + + t.Run("happy case", func(t *testing.T) { + var podSpecObj v1.PodSpec + err := UnmarshalStructToObj(structObj, &podSpecObj) + assert.NoError(t, err) + if diff := deep.Equal(podSpecObj, podSpec); diff != nil { + t.Errorf("UnmarshalStructToObj() got = %v, want %v, diff: %v", podSpecObj, podSpec, diff) + } + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/utils/secrets/marshaler.go b/flyteplugins/go/tasks/pluginmachinery/utils/secrets/marshaler.go new file mode 100644 index 0000000000..162bd8a496 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/utils/secrets/marshaler.go @@ -0,0 +1,85 @@ +package secrets + +import ( + "fmt" + "strconv" + "strings" + + "github.com/golang/protobuf/proto" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/encoding" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const ( + annotationPrefix = "flyte.secrets/s" + PodLabel = "inject-flyte-secrets" + PodLabelValue = "true" +) + +// Copied from: +// https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apimachinery/pkg/api/validation/objectmeta.go#L36 +const totalAnnotationSizeLimitB int = 256 * (1 << 10) // 256 kB + +func encodeSecret(secretAsString string) string { + res := encoding.Base32Encoder.EncodeToString([]byte(secretAsString)) + return strings.TrimSuffix(res, "=") +} + +func decodeSecret(encoded string) (string, error) { + decodedRaw, err := encoding.Base32Encoder.DecodeString(encoded) + if err != nil { + return encoded, err + } + + return string(decodedRaw), nil +} + +func marshalSecret(s *core.Secret) string { + return encodeSecret(proto.MarshalTextString(s)) +} + +func unmarshalSecret(encoded string) (*core.Secret, error) { + decoded, err := decodeSecret(encoded) + if err != nil { + return nil, err + } + + s := &core.Secret{} + err = proto.UnmarshalText(decoded, s) + return s, err +} + +func MarshalSecretsToMapStrings(secrets []*core.Secret) (map[string]string, error) { + res := make(map[string]string, len(secrets)) + for index, s := range secrets { + if _, found := core.Secret_MountType_name[int32(s.MountRequirement)]; !found { + return nil, fmt.Errorf("invalid mount requirement [%v]", s.MountRequirement) + } + + encodedSecret := marshalSecret(s) + res[annotationPrefix+strconv.Itoa(index)] = encodedSecret + + if len(encodedSecret) > totalAnnotationSizeLimitB { + return nil, fmt.Errorf("secret descriptor cannot exceed [%v]", totalAnnotationSizeLimitB) + } + } + + return res, nil +} + +func UnmarshalStringMapToSecrets(m map[string]string) ([]*core.Secret, error) { + res := make([]*core.Secret, 0, len(m)) + for key, val := range m { + if strings.HasPrefix(key, annotationPrefix) { + s, err := unmarshalSecret(val) + if err != nil { + return nil, fmt.Errorf("error unmarshaling secret [%v]. Error: %w", key, err) + } + + res = append(res, s) + } + } + + return res, nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/utils/secrets/marshaler_test.go b/flyteplugins/go/tasks/pluginmachinery/utils/secrets/marshaler_test.go new file mode 100644 index 0000000000..b07899ee63 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/utils/secrets/marshaler_test.go @@ -0,0 +1,77 @@ +package secrets + +import ( + "reflect" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestEncodeSecretGroup(t *testing.T) { + input := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890._-/" + encoded := encodeSecret(input) + t.Log(input + " -> " + encoded) + decoded, err := decodeSecret(encoded) + assert.NoError(t, err) + assert.Equal(t, input, decoded) +} + +func TestMarshalSecretsToMapStrings(t *testing.T) { + type args struct { + secrets []*core.Secret + } + tests := []struct { + name string + args args + want map[string]string + wantErr bool + }{ + {name: "empty", args: args{secrets: []*core.Secret{}}, want: map[string]string{}, wantErr: false}, + {name: "nil", args: args{secrets: nil}, want: map[string]string{}, wantErr: false}, + {name: "forbidden characters", args: args{secrets: []*core.Secret{ + { + Group: ";':/\\", + }, + }}, want: map[string]string{ + "flyte.secrets/s0": "m4zg54lqhiqceozhhixvyxbcbi", + }, wantErr: false}, + {name: "Without group", args: args{secrets: []*core.Secret{ + { + Key: "my_key", + }, + }}, want: map[string]string{ + "flyte.secrets/s0": "nnsxsoraejwxsx2lmv3secq", + }, wantErr: false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := MarshalSecretsToMapStrings(tt.args.secrets) + if (err != nil) != tt.wantErr { + t.Errorf("MarshalSecretsToMapStrings() error = %v, wantErr %v", err, tt.wantErr) + return + } else if err != nil { + return + } + + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("MarshalSecretsToMapStrings() got = %v, want %v", got, tt.want) + } + }) + + t.Run(tt.name+"_unmarshal", func(t *testing.T) { + got, err := UnmarshalStringMapToSecrets(tt.want) + if (err != nil) != tt.wantErr { + t.Errorf("UnmarshalSecretsToMapStrings() error = %v, wantErr %v", err, tt.wantErr) + return + } else if err != nil { + return + } + + if tt.args.secrets != nil && !reflect.DeepEqual(got, tt.args.secrets) { + t.Errorf("UnmarshalSecretsToMapStrings() got = %v, want %v", got, tt.args.secrets) + } + }) + } +} diff --git a/flyteplugins/go/tasks/pluginmachinery/utils/transformers.go b/flyteplugins/go/tasks/pluginmachinery/utils/transformers.go new file mode 100755 index 0000000000..3faf6f12b3 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/utils/transformers.go @@ -0,0 +1,26 @@ +package utils + +func CopyMap(o map[string]string) (r map[string]string) { + if o == nil { + return nil + } + r = make(map[string]string, len(o)) + for k, v := range o { + r[k] = v + } + return +} + +func Contains(s []string, e string) bool { + if s == nil { + return false + } + + for _, a := range s { + if a == e { + return true + } + } + + return false +} diff --git a/flyteplugins/go/tasks/pluginmachinery/utils/transformers_test.go b/flyteplugins/go/tasks/pluginmachinery/utils/transformers_test.go new file mode 100755 index 0000000000..17047211e0 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/utils/transformers_test.go @@ -0,0 +1,26 @@ +package utils + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestContains(t *testing.T) { + + assert.True(t, Contains([]string{"a", "b", "c"}, "b")) + + assert.False(t, Contains([]string{"a", "b", "c"}, "spark")) + + assert.False(t, Contains([]string{}, "spark")) + + assert.False(t, Contains(nil, "b")) +} + +func TestCopyMap(t *testing.T) { + assert.Nil(t, CopyMap(nil)) + m := map[string]string{ + "l": "v", + } + assert.Equal(t, m, CopyMap(m)) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/async_plugin.go b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/async_plugin.go new file mode 100644 index 0000000000..630f091590 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/async_plugin.go @@ -0,0 +1,258 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + + webapi "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi" +) + +// AsyncPlugin is an autogenerated mock type for the AsyncPlugin type +type AsyncPlugin struct { + mock.Mock +} + +type AsyncPlugin_Create struct { + *mock.Call +} + +func (_m AsyncPlugin_Create) Return(resourceMeta interface{}, optionalResource interface{}, err error) *AsyncPlugin_Create { + return &AsyncPlugin_Create{Call: _m.Call.Return(resourceMeta, optionalResource, err)} +} + +func (_m *AsyncPlugin) OnCreate(ctx context.Context, tCtx webapi.TaskExecutionContextReader) *AsyncPlugin_Create { + c_call := _m.On("Create", ctx, tCtx) + return &AsyncPlugin_Create{Call: c_call} +} + +func (_m *AsyncPlugin) OnCreateMatch(matchers ...interface{}) *AsyncPlugin_Create { + c_call := _m.On("Create", matchers...) + return &AsyncPlugin_Create{Call: c_call} +} + +// Create provides a mock function with given fields: ctx, tCtx +func (_m *AsyncPlugin) Create(ctx context.Context, tCtx webapi.TaskExecutionContextReader) (interface{}, interface{}, error) { + ret := _m.Called(ctx, tCtx) + + var r0 interface{} + if rf, ok := ret.Get(0).(func(context.Context, webapi.TaskExecutionContextReader) interface{}); ok { + r0 = rf(ctx, tCtx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interface{}) + } + } + + var r1 interface{} + if rf, ok := ret.Get(1).(func(context.Context, webapi.TaskExecutionContextReader) interface{}); ok { + r1 = rf(ctx, tCtx) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(interface{}) + } + } + + var r2 error + if rf, ok := ret.Get(2).(func(context.Context, webapi.TaskExecutionContextReader) error); ok { + r2 = rf(ctx, tCtx) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +type AsyncPlugin_Delete struct { + *mock.Call +} + +func (_m AsyncPlugin_Delete) Return(_a0 error) *AsyncPlugin_Delete { + return &AsyncPlugin_Delete{Call: _m.Call.Return(_a0)} +} + +func (_m *AsyncPlugin) OnDelete(ctx context.Context, tCtx webapi.DeleteContext) *AsyncPlugin_Delete { + c_call := _m.On("Delete", ctx, tCtx) + return &AsyncPlugin_Delete{Call: c_call} +} + +func (_m *AsyncPlugin) OnDeleteMatch(matchers ...interface{}) *AsyncPlugin_Delete { + c_call := _m.On("Delete", matchers...) + return &AsyncPlugin_Delete{Call: c_call} +} + +// Delete provides a mock function with given fields: ctx, tCtx +func (_m *AsyncPlugin) Delete(ctx context.Context, tCtx webapi.DeleteContext) error { + ret := _m.Called(ctx, tCtx) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, webapi.DeleteContext) error); ok { + r0 = rf(ctx, tCtx) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +type AsyncPlugin_Get struct { + *mock.Call +} + +func (_m AsyncPlugin_Get) Return(latest interface{}, err error) *AsyncPlugin_Get { + return &AsyncPlugin_Get{Call: _m.Call.Return(latest, err)} +} + +func (_m *AsyncPlugin) OnGet(ctx context.Context, tCtx webapi.GetContext) *AsyncPlugin_Get { + c_call := _m.On("Get", ctx, tCtx) + return &AsyncPlugin_Get{Call: c_call} +} + +func (_m *AsyncPlugin) OnGetMatch(matchers ...interface{}) *AsyncPlugin_Get { + c_call := _m.On("Get", matchers...) + return &AsyncPlugin_Get{Call: c_call} +} + +// Get provides a mock function with given fields: ctx, tCtx +func (_m *AsyncPlugin) Get(ctx context.Context, tCtx webapi.GetContext) (interface{}, error) { + ret := _m.Called(ctx, tCtx) + + var r0 interface{} + if rf, ok := ret.Get(0).(func(context.Context, webapi.GetContext) interface{}); ok { + r0 = rf(ctx, tCtx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interface{}) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, webapi.GetContext) error); ok { + r1 = rf(ctx, tCtx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +type AsyncPlugin_GetConfig struct { + *mock.Call +} + +func (_m AsyncPlugin_GetConfig) Return(_a0 webapi.PluginConfig) *AsyncPlugin_GetConfig { + return &AsyncPlugin_GetConfig{Call: _m.Call.Return(_a0)} +} + +func (_m *AsyncPlugin) OnGetConfig() *AsyncPlugin_GetConfig { + c_call := _m.On("GetConfig") + return &AsyncPlugin_GetConfig{Call: c_call} +} + +func (_m *AsyncPlugin) OnGetConfigMatch(matchers ...interface{}) *AsyncPlugin_GetConfig { + c_call := _m.On("GetConfig", matchers...) + return &AsyncPlugin_GetConfig{Call: c_call} +} + +// GetConfig provides a mock function with given fields: +func (_m *AsyncPlugin) GetConfig() webapi.PluginConfig { + ret := _m.Called() + + var r0 webapi.PluginConfig + if rf, ok := ret.Get(0).(func() webapi.PluginConfig); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(webapi.PluginConfig) + } + + return r0 +} + +type AsyncPlugin_ResourceRequirements struct { + *mock.Call +} + +func (_m AsyncPlugin_ResourceRequirements) Return(namespace core.ResourceNamespace, constraints core.ResourceConstraintsSpec, err error) *AsyncPlugin_ResourceRequirements { + return &AsyncPlugin_ResourceRequirements{Call: _m.Call.Return(namespace, constraints, err)} +} + +func (_m *AsyncPlugin) OnResourceRequirements(ctx context.Context, tCtx webapi.TaskExecutionContextReader) *AsyncPlugin_ResourceRequirements { + c_call := _m.On("ResourceRequirements", ctx, tCtx) + return &AsyncPlugin_ResourceRequirements{Call: c_call} +} + +func (_m *AsyncPlugin) OnResourceRequirementsMatch(matchers ...interface{}) *AsyncPlugin_ResourceRequirements { + c_call := _m.On("ResourceRequirements", matchers...) + return &AsyncPlugin_ResourceRequirements{Call: c_call} +} + +// ResourceRequirements provides a mock function with given fields: ctx, tCtx +func (_m *AsyncPlugin) ResourceRequirements(ctx context.Context, tCtx webapi.TaskExecutionContextReader) (core.ResourceNamespace, core.ResourceConstraintsSpec, error) { + ret := _m.Called(ctx, tCtx) + + var r0 core.ResourceNamespace + if rf, ok := ret.Get(0).(func(context.Context, webapi.TaskExecutionContextReader) core.ResourceNamespace); ok { + r0 = rf(ctx, tCtx) + } else { + r0 = ret.Get(0).(core.ResourceNamespace) + } + + var r1 core.ResourceConstraintsSpec + if rf, ok := ret.Get(1).(func(context.Context, webapi.TaskExecutionContextReader) core.ResourceConstraintsSpec); ok { + r1 = rf(ctx, tCtx) + } else { + r1 = ret.Get(1).(core.ResourceConstraintsSpec) + } + + var r2 error + if rf, ok := ret.Get(2).(func(context.Context, webapi.TaskExecutionContextReader) error); ok { + r2 = rf(ctx, tCtx) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +type AsyncPlugin_Status struct { + *mock.Call +} + +func (_m AsyncPlugin_Status) Return(phase core.PhaseInfo, err error) *AsyncPlugin_Status { + return &AsyncPlugin_Status{Call: _m.Call.Return(phase, err)} +} + +func (_m *AsyncPlugin) OnStatus(ctx context.Context, tCtx webapi.StatusContext) *AsyncPlugin_Status { + c_call := _m.On("Status", ctx, tCtx) + return &AsyncPlugin_Status{Call: c_call} +} + +func (_m *AsyncPlugin) OnStatusMatch(matchers ...interface{}) *AsyncPlugin_Status { + c_call := _m.On("Status", matchers...) + return &AsyncPlugin_Status{Call: c_call} +} + +// Status provides a mock function with given fields: ctx, tCtx +func (_m *AsyncPlugin) Status(ctx context.Context, tCtx webapi.StatusContext) (core.PhaseInfo, error) { + ret := _m.Called(ctx, tCtx) + + var r0 core.PhaseInfo + if rf, ok := ret.Get(0).(func(context.Context, webapi.StatusContext) core.PhaseInfo); ok { + r0 = rf(ctx, tCtx) + } else { + r0 = ret.Get(0).(core.PhaseInfo) + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, webapi.StatusContext) error); ok { + r1 = rf(ctx, tCtx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/delete_context.go b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/delete_context.go new file mode 100644 index 0000000000..c6be7e5c60 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/delete_context.go @@ -0,0 +1,76 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// DeleteContext is an autogenerated mock type for the DeleteContext type +type DeleteContext struct { + mock.Mock +} + +type DeleteContext_Reason struct { + *mock.Call +} + +func (_m DeleteContext_Reason) Return(_a0 string) *DeleteContext_Reason { + return &DeleteContext_Reason{Call: _m.Call.Return(_a0)} +} + +func (_m *DeleteContext) OnReason() *DeleteContext_Reason { + c_call := _m.On("Reason") + return &DeleteContext_Reason{Call: c_call} +} + +func (_m *DeleteContext) OnReasonMatch(matchers ...interface{}) *DeleteContext_Reason { + c_call := _m.On("Reason", matchers...) + return &DeleteContext_Reason{Call: c_call} +} + +// Reason provides a mock function with given fields: +func (_m *DeleteContext) Reason() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +type DeleteContext_ResourceMeta struct { + *mock.Call +} + +func (_m DeleteContext_ResourceMeta) Return(_a0 interface{}) *DeleteContext_ResourceMeta { + return &DeleteContext_ResourceMeta{Call: _m.Call.Return(_a0)} +} + +func (_m *DeleteContext) OnResourceMeta() *DeleteContext_ResourceMeta { + c_call := _m.On("ResourceMeta") + return &DeleteContext_ResourceMeta{Call: c_call} +} + +func (_m *DeleteContext) OnResourceMetaMatch(matchers ...interface{}) *DeleteContext_ResourceMeta { + c_call := _m.On("ResourceMeta", matchers...) + return &DeleteContext_ResourceMeta{Call: c_call} +} + +// ResourceMeta provides a mock function with given fields: +func (_m *DeleteContext) ResourceMeta() interface{} { + ret := _m.Called() + + var r0 interface{} + if rf, ok := ret.Get(0).(func() interface{}); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interface{}) + } + } + + return r0 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/get_context.go b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/get_context.go new file mode 100644 index 0000000000..c0dcbcd19e --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/get_context.go @@ -0,0 +1,44 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// GetContext is an autogenerated mock type for the GetContext type +type GetContext struct { + mock.Mock +} + +type GetContext_ResourceMeta struct { + *mock.Call +} + +func (_m GetContext_ResourceMeta) Return(_a0 interface{}) *GetContext_ResourceMeta { + return &GetContext_ResourceMeta{Call: _m.Call.Return(_a0)} +} + +func (_m *GetContext) OnResourceMeta() *GetContext_ResourceMeta { + c_call := _m.On("ResourceMeta") + return &GetContext_ResourceMeta{Call: c_call} +} + +func (_m *GetContext) OnResourceMetaMatch(matchers ...interface{}) *GetContext_ResourceMeta { + c_call := _m.On("ResourceMeta", matchers...) + return &GetContext_ResourceMeta{Call: c_call} +} + +// ResourceMeta provides a mock function with given fields: +func (_m *GetContext) ResourceMeta() interface{} { + ret := _m.Called() + + var r0 interface{} + if rf, ok := ret.Get(0).(func() interface{}); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interface{}) + } + } + + return r0 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/plugin.go b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/plugin.go new file mode 100644 index 0000000000..f803249f0a --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/plugin.go @@ -0,0 +1,46 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + mock "github.com/stretchr/testify/mock" + + webapi "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi" +) + +// Plugin is an autogenerated mock type for the Plugin type +type Plugin struct { + mock.Mock +} + +type Plugin_GetConfig struct { + *mock.Call +} + +func (_m Plugin_GetConfig) Return(_a0 webapi.PluginConfig) *Plugin_GetConfig { + return &Plugin_GetConfig{Call: _m.Call.Return(_a0)} +} + +func (_m *Plugin) OnGetConfig() *Plugin_GetConfig { + c_call := _m.On("GetConfig") + return &Plugin_GetConfig{Call: c_call} +} + +func (_m *Plugin) OnGetConfigMatch(matchers ...interface{}) *Plugin_GetConfig { + c_call := _m.On("GetConfig", matchers...) + return &Plugin_GetConfig{Call: c_call} +} + +// GetConfig provides a mock function with given fields: +func (_m *Plugin) GetConfig() webapi.PluginConfig { + ret := _m.Called() + + var r0 webapi.PluginConfig + if rf, ok := ret.Get(0).(func() webapi.PluginConfig); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(webapi.PluginConfig) + } + + return r0 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/plugin_setup_context.go b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/plugin_setup_context.go new file mode 100644 index 0000000000..968dc89e2e --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/plugin_setup_context.go @@ -0,0 +1,48 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + mock "github.com/stretchr/testify/mock" + + promutils "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +// PluginSetupContext is an autogenerated mock type for the PluginSetupContext type +type PluginSetupContext struct { + mock.Mock +} + +type PluginSetupContext_MetricsScope struct { + *mock.Call +} + +func (_m PluginSetupContext_MetricsScope) Return(_a0 promutils.Scope) *PluginSetupContext_MetricsScope { + return &PluginSetupContext_MetricsScope{Call: _m.Call.Return(_a0)} +} + +func (_m *PluginSetupContext) OnMetricsScope() *PluginSetupContext_MetricsScope { + c_call := _m.On("MetricsScope") + return &PluginSetupContext_MetricsScope{Call: c_call} +} + +func (_m *PluginSetupContext) OnMetricsScopeMatch(matchers ...interface{}) *PluginSetupContext_MetricsScope { + c_call := _m.On("MetricsScope", matchers...) + return &PluginSetupContext_MetricsScope{Call: c_call} +} + +// MetricsScope provides a mock function with given fields: +func (_m *PluginSetupContext) MetricsScope() promutils.Scope { + ret := _m.Called() + + var r0 promutils.Scope + if rf, ok := ret.Get(0).(func() promutils.Scope); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(promutils.Scope) + } + } + + return r0 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/remote_resource.go b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/remote_resource.go new file mode 100644 index 0000000000..5770fab126 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/remote_resource.go @@ -0,0 +1,10 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// RemoteResource is an autogenerated mock type for the RemoteResource type +type RemoteResource struct { + mock.Mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/resource.go b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/resource.go new file mode 100644 index 0000000000..23fede8cab --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/resource.go @@ -0,0 +1,85 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + mock "github.com/stretchr/testify/mock" + + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" +) + +// Resource is an autogenerated mock type for the Resource type +type Resource struct { + mock.Mock +} + +type Resource_ID struct { + *mock.Call +} + +func (_m Resource_ID) Return(_a0 string) *Resource_ID { + return &Resource_ID{Call: _m.Call.Return(_a0)} +} + +func (_m *Resource) OnID() *Resource_ID { + c := _m.On("ID") + return &Resource_ID{Call: c} +} + +func (_m *Resource) OnIDMatch(matchers ...interface{}) *Resource_ID { + c := _m.On("ID", matchers...) + return &Resource_ID{Call: c} +} + +// ID provides a mock function with given fields: +func (_m *Resource) ID() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +type Resource_Status struct { + *mock.Call +} + +func (_m Resource_Status) Return(phase core.PhaseInfo, err error) *Resource_Status { + return &Resource_Status{Call: _m.Call.Return(phase, err)} +} + +func (_m *Resource) OnStatus() *Resource_Status { + c := _m.On("Status") + return &Resource_Status{Call: c} +} + +func (_m *Resource) OnStatusMatch(matchers ...interface{}) *Resource_Status { + c := _m.On("Status", matchers...) + return &Resource_Status{Call: c} +} + +// Status provides a mock function with given fields: +func (_m *Resource) Status() (core.PhaseInfo, error) { + ret := _m.Called() + + var r0 core.PhaseInfo + if rf, ok := ret.Get(0).(func() core.PhaseInfo); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(core.PhaseInfo) + } + + var r1 error + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/status_context.go b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/status_context.go new file mode 100644 index 0000000000..1c6e086a70 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/status_context.go @@ -0,0 +1,289 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + io "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + + mock "github.com/stretchr/testify/mock" + + storage "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + +// StatusContext is an autogenerated mock type for the StatusContext type +type StatusContext struct { + mock.Mock +} + +type StatusContext_DataStore struct { + *mock.Call +} + +func (_m StatusContext_DataStore) Return(_a0 *storage.DataStore) *StatusContext_DataStore { + return &StatusContext_DataStore{Call: _m.Call.Return(_a0)} +} + +func (_m *StatusContext) OnDataStore() *StatusContext_DataStore { + c_call := _m.On("DataStore") + return &StatusContext_DataStore{Call: c_call} +} + +func (_m *StatusContext) OnDataStoreMatch(matchers ...interface{}) *StatusContext_DataStore { + c_call := _m.On("DataStore", matchers...) + return &StatusContext_DataStore{Call: c_call} +} + +// DataStore provides a mock function with given fields: +func (_m *StatusContext) DataStore() *storage.DataStore { + ret := _m.Called() + + var r0 *storage.DataStore + if rf, ok := ret.Get(0).(func() *storage.DataStore); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storage.DataStore) + } + } + + return r0 +} + +type StatusContext_InputReader struct { + *mock.Call +} + +func (_m StatusContext_InputReader) Return(_a0 io.InputReader) *StatusContext_InputReader { + return &StatusContext_InputReader{Call: _m.Call.Return(_a0)} +} + +func (_m *StatusContext) OnInputReader() *StatusContext_InputReader { + c_call := _m.On("InputReader") + return &StatusContext_InputReader{Call: c_call} +} + +func (_m *StatusContext) OnInputReaderMatch(matchers ...interface{}) *StatusContext_InputReader { + c_call := _m.On("InputReader", matchers...) + return &StatusContext_InputReader{Call: c_call} +} + +// InputReader provides a mock function with given fields: +func (_m *StatusContext) InputReader() io.InputReader { + ret := _m.Called() + + var r0 io.InputReader + if rf, ok := ret.Get(0).(func() io.InputReader); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(io.InputReader) + } + } + + return r0 +} + +type StatusContext_OutputWriter struct { + *mock.Call +} + +func (_m StatusContext_OutputWriter) Return(_a0 io.OutputWriter) *StatusContext_OutputWriter { + return &StatusContext_OutputWriter{Call: _m.Call.Return(_a0)} +} + +func (_m *StatusContext) OnOutputWriter() *StatusContext_OutputWriter { + c_call := _m.On("OutputWriter") + return &StatusContext_OutputWriter{Call: c_call} +} + +func (_m *StatusContext) OnOutputWriterMatch(matchers ...interface{}) *StatusContext_OutputWriter { + c_call := _m.On("OutputWriter", matchers...) + return &StatusContext_OutputWriter{Call: c_call} +} + +// OutputWriter provides a mock function with given fields: +func (_m *StatusContext) OutputWriter() io.OutputWriter { + ret := _m.Called() + + var r0 io.OutputWriter + if rf, ok := ret.Get(0).(func() io.OutputWriter); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(io.OutputWriter) + } + } + + return r0 +} + +type StatusContext_Resource struct { + *mock.Call +} + +func (_m StatusContext_Resource) Return(_a0 interface{}) *StatusContext_Resource { + return &StatusContext_Resource{Call: _m.Call.Return(_a0)} +} + +func (_m *StatusContext) OnResource() *StatusContext_Resource { + c_call := _m.On("Resource") + return &StatusContext_Resource{Call: c_call} +} + +func (_m *StatusContext) OnResourceMatch(matchers ...interface{}) *StatusContext_Resource { + c_call := _m.On("Resource", matchers...) + return &StatusContext_Resource{Call: c_call} +} + +// Resource provides a mock function with given fields: +func (_m *StatusContext) Resource() interface{} { + ret := _m.Called() + + var r0 interface{} + if rf, ok := ret.Get(0).(func() interface{}); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interface{}) + } + } + + return r0 +} + +type StatusContext_ResourceMeta struct { + *mock.Call +} + +func (_m StatusContext_ResourceMeta) Return(_a0 interface{}) *StatusContext_ResourceMeta { + return &StatusContext_ResourceMeta{Call: _m.Call.Return(_a0)} +} + +func (_m *StatusContext) OnResourceMeta() *StatusContext_ResourceMeta { + c_call := _m.On("ResourceMeta") + return &StatusContext_ResourceMeta{Call: c_call} +} + +func (_m *StatusContext) OnResourceMetaMatch(matchers ...interface{}) *StatusContext_ResourceMeta { + c_call := _m.On("ResourceMeta", matchers...) + return &StatusContext_ResourceMeta{Call: c_call} +} + +// ResourceMeta provides a mock function with given fields: +func (_m *StatusContext) ResourceMeta() interface{} { + ret := _m.Called() + + var r0 interface{} + if rf, ok := ret.Get(0).(func() interface{}); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interface{}) + } + } + + return r0 +} + +type StatusContext_SecretManager struct { + *mock.Call +} + +func (_m StatusContext_SecretManager) Return(_a0 core.SecretManager) *StatusContext_SecretManager { + return &StatusContext_SecretManager{Call: _m.Call.Return(_a0)} +} + +func (_m *StatusContext) OnSecretManager() *StatusContext_SecretManager { + c_call := _m.On("SecretManager") + return &StatusContext_SecretManager{Call: c_call} +} + +func (_m *StatusContext) OnSecretManagerMatch(matchers ...interface{}) *StatusContext_SecretManager { + c_call := _m.On("SecretManager", matchers...) + return &StatusContext_SecretManager{Call: c_call} +} + +// SecretManager provides a mock function with given fields: +func (_m *StatusContext) SecretManager() core.SecretManager { + ret := _m.Called() + + var r0 core.SecretManager + if rf, ok := ret.Get(0).(func() core.SecretManager); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.SecretManager) + } + } + + return r0 +} + +type StatusContext_TaskExecutionMetadata struct { + *mock.Call +} + +func (_m StatusContext_TaskExecutionMetadata) Return(_a0 core.TaskExecutionMetadata) *StatusContext_TaskExecutionMetadata { + return &StatusContext_TaskExecutionMetadata{Call: _m.Call.Return(_a0)} +} + +func (_m *StatusContext) OnTaskExecutionMetadata() *StatusContext_TaskExecutionMetadata { + c_call := _m.On("TaskExecutionMetadata") + return &StatusContext_TaskExecutionMetadata{Call: c_call} +} + +func (_m *StatusContext) OnTaskExecutionMetadataMatch(matchers ...interface{}) *StatusContext_TaskExecutionMetadata { + c_call := _m.On("TaskExecutionMetadata", matchers...) + return &StatusContext_TaskExecutionMetadata{Call: c_call} +} + +// TaskExecutionMetadata provides a mock function with given fields: +func (_m *StatusContext) TaskExecutionMetadata() core.TaskExecutionMetadata { + ret := _m.Called() + + var r0 core.TaskExecutionMetadata + if rf, ok := ret.Get(0).(func() core.TaskExecutionMetadata); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.TaskExecutionMetadata) + } + } + + return r0 +} + +type StatusContext_TaskReader struct { + *mock.Call +} + +func (_m StatusContext_TaskReader) Return(_a0 core.TaskReader) *StatusContext_TaskReader { + return &StatusContext_TaskReader{Call: _m.Call.Return(_a0)} +} + +func (_m *StatusContext) OnTaskReader() *StatusContext_TaskReader { + c_call := _m.On("TaskReader") + return &StatusContext_TaskReader{Call: c_call} +} + +func (_m *StatusContext) OnTaskReaderMatch(matchers ...interface{}) *StatusContext_TaskReader { + c_call := _m.On("TaskReader", matchers...) + return &StatusContext_TaskReader{Call: c_call} +} + +// TaskReader provides a mock function with given fields: +func (_m *StatusContext) TaskReader() core.TaskReader { + ret := _m.Called() + + var r0 core.TaskReader + if rf, ok := ret.Get(0).(func() core.TaskReader); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.TaskReader) + } + } + + return r0 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/sync_plugin.go b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/sync_plugin.go new file mode 100644 index 0000000000..c2393450b3 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/sync_plugin.go @@ -0,0 +1,89 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + + webapi "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi" +) + +// SyncPlugin is an autogenerated mock type for the SyncPlugin type +type SyncPlugin struct { + mock.Mock +} + +type SyncPlugin_Do struct { + *mock.Call +} + +func (_m SyncPlugin_Do) Return(phase core.PhaseInfo, err error) *SyncPlugin_Do { + return &SyncPlugin_Do{Call: _m.Call.Return(phase, err)} +} + +func (_m *SyncPlugin) OnDo(ctx context.Context, tCtx webapi.TaskExecutionContext) *SyncPlugin_Do { + c_call := _m.On("Do", ctx, tCtx) + return &SyncPlugin_Do{Call: c_call} +} + +func (_m *SyncPlugin) OnDoMatch(matchers ...interface{}) *SyncPlugin_Do { + c_call := _m.On("Do", matchers...) + return &SyncPlugin_Do{Call: c_call} +} + +// Do provides a mock function with given fields: ctx, tCtx +func (_m *SyncPlugin) Do(ctx context.Context, tCtx webapi.TaskExecutionContext) (core.PhaseInfo, error) { + ret := _m.Called(ctx, tCtx) + + var r0 core.PhaseInfo + if rf, ok := ret.Get(0).(func(context.Context, webapi.TaskExecutionContext) core.PhaseInfo); ok { + r0 = rf(ctx, tCtx) + } else { + r0 = ret.Get(0).(core.PhaseInfo) + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, webapi.TaskExecutionContext) error); ok { + r1 = rf(ctx, tCtx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +type SyncPlugin_GetConfig struct { + *mock.Call +} + +func (_m SyncPlugin_GetConfig) Return(_a0 webapi.PluginConfig) *SyncPlugin_GetConfig { + return &SyncPlugin_GetConfig{Call: _m.Call.Return(_a0)} +} + +func (_m *SyncPlugin) OnGetConfig() *SyncPlugin_GetConfig { + c_call := _m.On("GetConfig") + return &SyncPlugin_GetConfig{Call: c_call} +} + +func (_m *SyncPlugin) OnGetConfigMatch(matchers ...interface{}) *SyncPlugin_GetConfig { + c_call := _m.On("GetConfig", matchers...) + return &SyncPlugin_GetConfig{Call: c_call} +} + +// GetConfig provides a mock function with given fields: +func (_m *SyncPlugin) GetConfig() webapi.PluginConfig { + ret := _m.Called() + + var r0 webapi.PluginConfig + if rf, ok := ret.Get(0).(func() webapi.PluginConfig); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(webapi.PluginConfig) + } + + return r0 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/task_execution_context.go b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/task_execution_context.go new file mode 100644 index 0000000000..648a3d6bbd --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/task_execution_context.go @@ -0,0 +1,221 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + io "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + + mock "github.com/stretchr/testify/mock" + + storage "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + +// TaskExecutionContext is an autogenerated mock type for the TaskExecutionContext type +type TaskExecutionContext struct { + mock.Mock +} + +type TaskExecutionContext_DataStore struct { + *mock.Call +} + +func (_m TaskExecutionContext_DataStore) Return(_a0 *storage.DataStore) *TaskExecutionContext_DataStore { + return &TaskExecutionContext_DataStore{Call: _m.Call.Return(_a0)} +} + +func (_m *TaskExecutionContext) OnDataStore() *TaskExecutionContext_DataStore { + c_call := _m.On("DataStore") + return &TaskExecutionContext_DataStore{Call: c_call} +} + +func (_m *TaskExecutionContext) OnDataStoreMatch(matchers ...interface{}) *TaskExecutionContext_DataStore { + c_call := _m.On("DataStore", matchers...) + return &TaskExecutionContext_DataStore{Call: c_call} +} + +// DataStore provides a mock function with given fields: +func (_m *TaskExecutionContext) DataStore() *storage.DataStore { + ret := _m.Called() + + var r0 *storage.DataStore + if rf, ok := ret.Get(0).(func() *storage.DataStore); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storage.DataStore) + } + } + + return r0 +} + +type TaskExecutionContext_InputReader struct { + *mock.Call +} + +func (_m TaskExecutionContext_InputReader) Return(_a0 io.InputReader) *TaskExecutionContext_InputReader { + return &TaskExecutionContext_InputReader{Call: _m.Call.Return(_a0)} +} + +func (_m *TaskExecutionContext) OnInputReader() *TaskExecutionContext_InputReader { + c_call := _m.On("InputReader") + return &TaskExecutionContext_InputReader{Call: c_call} +} + +func (_m *TaskExecutionContext) OnInputReaderMatch(matchers ...interface{}) *TaskExecutionContext_InputReader { + c_call := _m.On("InputReader", matchers...) + return &TaskExecutionContext_InputReader{Call: c_call} +} + +// InputReader provides a mock function with given fields: +func (_m *TaskExecutionContext) InputReader() io.InputReader { + ret := _m.Called() + + var r0 io.InputReader + if rf, ok := ret.Get(0).(func() io.InputReader); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(io.InputReader) + } + } + + return r0 +} + +type TaskExecutionContext_OutputWriter struct { + *mock.Call +} + +func (_m TaskExecutionContext_OutputWriter) Return(_a0 io.OutputWriter) *TaskExecutionContext_OutputWriter { + return &TaskExecutionContext_OutputWriter{Call: _m.Call.Return(_a0)} +} + +func (_m *TaskExecutionContext) OnOutputWriter() *TaskExecutionContext_OutputWriter { + c_call := _m.On("OutputWriter") + return &TaskExecutionContext_OutputWriter{Call: c_call} +} + +func (_m *TaskExecutionContext) OnOutputWriterMatch(matchers ...interface{}) *TaskExecutionContext_OutputWriter { + c_call := _m.On("OutputWriter", matchers...) + return &TaskExecutionContext_OutputWriter{Call: c_call} +} + +// OutputWriter provides a mock function with given fields: +func (_m *TaskExecutionContext) OutputWriter() io.OutputWriter { + ret := _m.Called() + + var r0 io.OutputWriter + if rf, ok := ret.Get(0).(func() io.OutputWriter); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(io.OutputWriter) + } + } + + return r0 +} + +type TaskExecutionContext_SecretManager struct { + *mock.Call +} + +func (_m TaskExecutionContext_SecretManager) Return(_a0 core.SecretManager) *TaskExecutionContext_SecretManager { + return &TaskExecutionContext_SecretManager{Call: _m.Call.Return(_a0)} +} + +func (_m *TaskExecutionContext) OnSecretManager() *TaskExecutionContext_SecretManager { + c_call := _m.On("SecretManager") + return &TaskExecutionContext_SecretManager{Call: c_call} +} + +func (_m *TaskExecutionContext) OnSecretManagerMatch(matchers ...interface{}) *TaskExecutionContext_SecretManager { + c_call := _m.On("SecretManager", matchers...) + return &TaskExecutionContext_SecretManager{Call: c_call} +} + +// SecretManager provides a mock function with given fields: +func (_m *TaskExecutionContext) SecretManager() core.SecretManager { + ret := _m.Called() + + var r0 core.SecretManager + if rf, ok := ret.Get(0).(func() core.SecretManager); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.SecretManager) + } + } + + return r0 +} + +type TaskExecutionContext_TaskExecutionMetadata struct { + *mock.Call +} + +func (_m TaskExecutionContext_TaskExecutionMetadata) Return(_a0 core.TaskExecutionMetadata) *TaskExecutionContext_TaskExecutionMetadata { + return &TaskExecutionContext_TaskExecutionMetadata{Call: _m.Call.Return(_a0)} +} + +func (_m *TaskExecutionContext) OnTaskExecutionMetadata() *TaskExecutionContext_TaskExecutionMetadata { + c_call := _m.On("TaskExecutionMetadata") + return &TaskExecutionContext_TaskExecutionMetadata{Call: c_call} +} + +func (_m *TaskExecutionContext) OnTaskExecutionMetadataMatch(matchers ...interface{}) *TaskExecutionContext_TaskExecutionMetadata { + c_call := _m.On("TaskExecutionMetadata", matchers...) + return &TaskExecutionContext_TaskExecutionMetadata{Call: c_call} +} + +// TaskExecutionMetadata provides a mock function with given fields: +func (_m *TaskExecutionContext) TaskExecutionMetadata() core.TaskExecutionMetadata { + ret := _m.Called() + + var r0 core.TaskExecutionMetadata + if rf, ok := ret.Get(0).(func() core.TaskExecutionMetadata); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.TaskExecutionMetadata) + } + } + + return r0 +} + +type TaskExecutionContext_TaskReader struct { + *mock.Call +} + +func (_m TaskExecutionContext_TaskReader) Return(_a0 core.TaskReader) *TaskExecutionContext_TaskReader { + return &TaskExecutionContext_TaskReader{Call: _m.Call.Return(_a0)} +} + +func (_m *TaskExecutionContext) OnTaskReader() *TaskExecutionContext_TaskReader { + c_call := _m.On("TaskReader") + return &TaskExecutionContext_TaskReader{Call: c_call} +} + +func (_m *TaskExecutionContext) OnTaskReaderMatch(matchers ...interface{}) *TaskExecutionContext_TaskReader { + c_call := _m.On("TaskReader", matchers...) + return &TaskExecutionContext_TaskReader{Call: c_call} +} + +// TaskReader provides a mock function with given fields: +func (_m *TaskExecutionContext) TaskReader() core.TaskReader { + ret := _m.Called() + + var r0 core.TaskReader + if rf, ok := ret.Get(0).(func() core.TaskReader); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.TaskReader) + } + } + + return r0 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/task_execution_context_reader.go b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/task_execution_context_reader.go new file mode 100644 index 0000000000..2832e2ef08 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/webapi/mocks/task_execution_context_reader.go @@ -0,0 +1,185 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + core "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + io "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + + mock "github.com/stretchr/testify/mock" +) + +// TaskExecutionContextReader is an autogenerated mock type for the TaskExecutionContextReader type +type TaskExecutionContextReader struct { + mock.Mock +} + +type TaskExecutionContextReader_InputReader struct { + *mock.Call +} + +func (_m TaskExecutionContextReader_InputReader) Return(_a0 io.InputReader) *TaskExecutionContextReader_InputReader { + return &TaskExecutionContextReader_InputReader{Call: _m.Call.Return(_a0)} +} + +func (_m *TaskExecutionContextReader) OnInputReader() *TaskExecutionContextReader_InputReader { + c_call := _m.On("InputReader") + return &TaskExecutionContextReader_InputReader{Call: c_call} +} + +func (_m *TaskExecutionContextReader) OnInputReaderMatch(matchers ...interface{}) *TaskExecutionContextReader_InputReader { + c_call := _m.On("InputReader", matchers...) + return &TaskExecutionContextReader_InputReader{Call: c_call} +} + +// InputReader provides a mock function with given fields: +func (_m *TaskExecutionContextReader) InputReader() io.InputReader { + ret := _m.Called() + + var r0 io.InputReader + if rf, ok := ret.Get(0).(func() io.InputReader); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(io.InputReader) + } + } + + return r0 +} + +type TaskExecutionContextReader_OutputWriter struct { + *mock.Call +} + +func (_m TaskExecutionContextReader_OutputWriter) Return(_a0 io.OutputWriter) *TaskExecutionContextReader_OutputWriter { + return &TaskExecutionContextReader_OutputWriter{Call: _m.Call.Return(_a0)} +} + +func (_m *TaskExecutionContextReader) OnOutputWriter() *TaskExecutionContextReader_OutputWriter { + c_call := _m.On("OutputWriter") + return &TaskExecutionContextReader_OutputWriter{Call: c_call} +} + +func (_m *TaskExecutionContextReader) OnOutputWriterMatch(matchers ...interface{}) *TaskExecutionContextReader_OutputWriter { + c_call := _m.On("OutputWriter", matchers...) + return &TaskExecutionContextReader_OutputWriter{Call: c_call} +} + +// OutputWriter provides a mock function with given fields: +func (_m *TaskExecutionContextReader) OutputWriter() io.OutputWriter { + ret := _m.Called() + + var r0 io.OutputWriter + if rf, ok := ret.Get(0).(func() io.OutputWriter); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(io.OutputWriter) + } + } + + return r0 +} + +type TaskExecutionContextReader_SecretManager struct { + *mock.Call +} + +func (_m TaskExecutionContextReader_SecretManager) Return(_a0 core.SecretManager) *TaskExecutionContextReader_SecretManager { + return &TaskExecutionContextReader_SecretManager{Call: _m.Call.Return(_a0)} +} + +func (_m *TaskExecutionContextReader) OnSecretManager() *TaskExecutionContextReader_SecretManager { + c_call := _m.On("SecretManager") + return &TaskExecutionContextReader_SecretManager{Call: c_call} +} + +func (_m *TaskExecutionContextReader) OnSecretManagerMatch(matchers ...interface{}) *TaskExecutionContextReader_SecretManager { + c_call := _m.On("SecretManager", matchers...) + return &TaskExecutionContextReader_SecretManager{Call: c_call} +} + +// SecretManager provides a mock function with given fields: +func (_m *TaskExecutionContextReader) SecretManager() core.SecretManager { + ret := _m.Called() + + var r0 core.SecretManager + if rf, ok := ret.Get(0).(func() core.SecretManager); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.SecretManager) + } + } + + return r0 +} + +type TaskExecutionContextReader_TaskExecutionMetadata struct { + *mock.Call +} + +func (_m TaskExecutionContextReader_TaskExecutionMetadata) Return(_a0 core.TaskExecutionMetadata) *TaskExecutionContextReader_TaskExecutionMetadata { + return &TaskExecutionContextReader_TaskExecutionMetadata{Call: _m.Call.Return(_a0)} +} + +func (_m *TaskExecutionContextReader) OnTaskExecutionMetadata() *TaskExecutionContextReader_TaskExecutionMetadata { + c_call := _m.On("TaskExecutionMetadata") + return &TaskExecutionContextReader_TaskExecutionMetadata{Call: c_call} +} + +func (_m *TaskExecutionContextReader) OnTaskExecutionMetadataMatch(matchers ...interface{}) *TaskExecutionContextReader_TaskExecutionMetadata { + c_call := _m.On("TaskExecutionMetadata", matchers...) + return &TaskExecutionContextReader_TaskExecutionMetadata{Call: c_call} +} + +// TaskExecutionMetadata provides a mock function with given fields: +func (_m *TaskExecutionContextReader) TaskExecutionMetadata() core.TaskExecutionMetadata { + ret := _m.Called() + + var r0 core.TaskExecutionMetadata + if rf, ok := ret.Get(0).(func() core.TaskExecutionMetadata); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.TaskExecutionMetadata) + } + } + + return r0 +} + +type TaskExecutionContextReader_TaskReader struct { + *mock.Call +} + +func (_m TaskExecutionContextReader_TaskReader) Return(_a0 core.TaskReader) *TaskExecutionContextReader_TaskReader { + return &TaskExecutionContextReader_TaskReader{Call: _m.Call.Return(_a0)} +} + +func (_m *TaskExecutionContextReader) OnTaskReader() *TaskExecutionContextReader_TaskReader { + c_call := _m.On("TaskReader") + return &TaskExecutionContextReader_TaskReader{Call: c_call} +} + +func (_m *TaskExecutionContextReader) OnTaskReaderMatch(matchers ...interface{}) *TaskExecutionContextReader_TaskReader { + c_call := _m.On("TaskReader", matchers...) + return &TaskExecutionContextReader_TaskReader{Call: c_call} +} + +// TaskReader provides a mock function with given fields: +func (_m *TaskExecutionContextReader) TaskReader() core.TaskReader { + ret := _m.Called() + + var r0 core.TaskReader + if rf, ok := ret.Get(0).(func() core.TaskReader); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(core.TaskReader) + } + } + + return r0 +} diff --git a/flyteplugins/go/tasks/pluginmachinery/webapi/plugin.go b/flyteplugins/go/tasks/pluginmachinery/webapi/plugin.go new file mode 100644 index 0000000000..801441c456 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/webapi/plugin.go @@ -0,0 +1,149 @@ +// Defines the interfaces to implement to add a Web API Plugin (AsyncPlugin and SyncPlugin) to the Flyte system. A +// WebAPI plugin is a plugin that runs the compute for a task on a separate system through a web call (REST/Grpc... +// etc.). By implementing either the AsyncPlugin or SyncPlugin interfaces, the users of the Flyte system can then +// declare tasks of the handled task type in their workflows and the engine (Propeller) will route these tasks to your +// plugin to interact with the remote system. +// +// A sample skeleton plugin is defined in the example directory. +package webapi + +import ( + "context" + + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + +//go:generate mockery -all -case=underscore + +// A Lazy loading function, that will load the plugin. Plugins should be initialized in this method. It is guaranteed +// that the plugin loader will be called before any Handle/Abort/Finalize functions are invoked +type PluginLoader func(ctx context.Context, iCtx PluginSetupContext) (AsyncPlugin, error) + +// PluginEntry is a structure that is used to indicate to the system a WebAPI plugin +type PluginEntry struct { + // ID/Name of the plugin. This will be used to identify this plugin and has to be unique in the entire system + // All functions like enabling and disabling a plugin use this ID + ID pluginsCore.TaskType + + // A list of all the task types for which this plugin is applicable. + SupportedTaskTypes []pluginsCore.TaskType + + // An instance of the plugin + PluginLoader PluginLoader + + // Boolean that indicates if this plugin can be used as the default for unknown task types. There can only be + // one default in the system + IsDefault bool + + // A list of all task types for which this plugin should be default handler when multiple registered plugins + // support the same task type. This must be a subset of RegisteredTaskTypes and at most one default per task type + // is supported. + DefaultForTaskTypes []pluginsCore.TaskType +} + +// PluginSetupContext is the interface made available to the plugin loader when initializing the plugin. +type PluginSetupContext interface { + // a metrics scope to publish stats under + MetricsScope() promutils.Scope +} + +type TaskExecutionContextReader interface { + // Returns a secret manager that can retrieve configured secrets for this plugin + SecretManager() pluginsCore.SecretManager + + // Returns a TaskReader, to retrieve the task details + TaskReader() pluginsCore.TaskReader + + // Returns an input reader to retrieve input data + InputReader() io.InputReader + + // Returns a handle to the Task's execution metadata. + TaskExecutionMetadata() pluginsCore.TaskExecutionMetadata + + // Provides an output sync of type io.OutputWriter + OutputWriter() io.OutputWriter +} + +type TaskExecutionContext interface { + TaskExecutionContextReader + + // Provides the raw datastore to enable persisting outputs. + DataStore() *storage.DataStore +} + +type GetContext interface { + ResourceMeta() ResourceMeta +} + +type DeleteContext interface { + ResourceMeta() ResourceMeta + Reason() string +} + +type StatusContext interface { + TaskExecutionContext + + ResourceMeta() ResourceMeta + Resource() Resource +} + +// Metadata about the resource to be synced from the remote service. +type ResourceMeta = interface{} +type Resource = interface{} + +// AsyncPlugin defines the interface for plugins that call Async Web APIs. +type AsyncPlugin interface { + // GetConfig gets the loaded plugin config. This will be used to control the interactions with the remote service. + GetConfig() PluginConfig + + // ResourceRequirements analyzes the task to execute and determines the ResourceNamespace to be used when allocating tokens. + ResourceRequirements(ctx context.Context, tCtx TaskExecutionContextReader) ( + namespace pluginsCore.ResourceNamespace, constraints pluginsCore.ResourceConstraintsSpec, err error) + + // Create a new resource using the TaskExecutionContext provided. Ideally, the remote service uses the name in the + // TaskExecutionMetadata to launch the resource in an idempotent fashion. This function will be on the critical path + // of the execution of a workflow and therefore it should not do expensive operations before making the webAPI call. + // Flyte will call this api at least once. It's important that the callee service is idempotent to ensure no + // resource leakage or duplicate requests. Flyte has an in-memory cache that does a best effort idempotency + // guarantee. + // It's required to return a resourceMeta object (that will be cached in memory). In case the remote API returns the + // actually created resource, it's advisable to also return that in optionalResource output parameter. Doing so will + // instruct the system to call Status() immediately after Create() and potentially terminate early if the resource + // has already been executed/failed. + // If the remote API failed due to a system error (network failure, timeout... etc.), the plugin should return a + // non-nil error. The system will automatically retry the operation based on the plugin config. + Create(ctx context.Context, tCtx TaskExecutionContextReader) (resourceMeta ResourceMeta, optionalResource Resource, + err error) + + // Get the resource that matches the keys. If the plugin hits any failure, it should stop and return the failure. + // This API will be called asynchronously and periodically to update the set of tasks currently in progress. It's + // acceptable if this API is blocking since it'll be called from a background go-routine. + // Best practices: + // 1) Instead of returning the entire response object retrieved from the WebAPI, construct a smaller object that + // has enough information to construct the status/phase, error and/or output. + // 2) This object will NOT be serialized/marshaled. It's, therefore, not a requirement to make it so. + // 3) There is already client-side throttling in place. If the WebAPI returns a throttling error, you should return + // it as is so that the appropriate metrics are updated and the system administrator can update throttling + // params accordingly. + Get(ctx context.Context, tCtx GetContext) (latest Resource, err error) + + // Delete the object in the remote service using the resource key. Flyte will call this API at least once. If the + // resource has already been deleted, the API should not fail. + Delete(ctx context.Context, tCtx DeleteContext) error + + // Status checks the status of a given resource and translates it to a Flyte-understandable PhaseInfo. This API + // should avoid making any network calls and should run very efficiently. + Status(ctx context.Context, tCtx StatusContext) (phase pluginsCore.PhaseInfo, err error) +} + +// SyncPlugin defines the interface for plugins that call Web APIs synchronously. +type SyncPlugin interface { + // GetConfig gets the loaded plugin config. This will be used to control the interactions with the remote service. + GetConfig() PluginConfig + + // Do performs the action associated with this plugin. + Do(ctx context.Context, tCtx TaskExecutionContext) (phase pluginsCore.PhaseInfo, err error) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/webapi/pluginconfig.go b/flyteplugins/go/tasks/pluginmachinery/webapi/pluginconfig.go new file mode 100644 index 0000000000..e7ed883d0f --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/webapi/pluginconfig.go @@ -0,0 +1,68 @@ +package webapi + +import ( + "time" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flytestdlib/config" +) + +//go:generate pflags PluginConfig --default-var=DefaultPluginConfig + +var ( + DefaultPluginConfig = PluginConfig{ + Caching: CachingConfig{ + Size: 100000, + ResyncInterval: config.Duration{Duration: 30 * time.Second}, + Workers: 10, + MaxSystemFailures: 5, + }, + ReadRateLimiter: RateLimiterConfig{ + QPS: 30, + Burst: 300, + }, + WriteRateLimiter: RateLimiterConfig{ + QPS: 20, + Burst: 200, + }, + } +) + +// The plugin manager automatically queries the remote API +type RateLimiterConfig struct { + // Queries per second from one process to the remote service + QPS int `json:"qps" pflag:",Defines the max rate of calls per second."` + + // Maximum burst size + Burst int `json:"burst" pflag:",Defines the maximum burst size."` +} + +type CachingConfig struct { + // Max number of Resource's to be stored in the local cache + Size int `json:"size" pflag:",Defines the maximum number of items to cache."` + + // How often to query for objects in remote service. + ResyncInterval config.Duration `json:"resyncInterval" pflag:",Defines the sync interval."` + + // Workers control how many parallel workers should start up to retrieve updates + // about resources. + Workers int `json:"workers" pflag:",Defines the number of workers to start up to process items."` + + // MaxSystemFailures defines the number of failures to fetch a task before failing the task. + MaxSystemFailures int `json:"maxSystemFailures" pflag:",Defines the number of failures to fetch a task before failing the task."` +} + +type ResourceQuotas map[core.ResourceNamespace]int + +// Properties that help the system optimize itself to handle the specific plugin +type PluginConfig struct { + // ResourceQuotas allows the plugin to register resources' quotas to ensure the system comply with restrictions in + // the remote service. + ResourceQuotas ResourceQuotas `json:"resourceQuotas" pflag:"-,Defines resource quotas."` + ReadRateLimiter RateLimiterConfig `json:"readRateLimiter" pflag:",Defines rate limiter properties for read actions (e.g. retrieve status)."` + WriteRateLimiter RateLimiterConfig `json:"writeRateLimiter" pflag:",Defines rate limiter properties for write actions."` + Caching CachingConfig `json:"caching" pflag:",Defines caching characteristics."` + // Gets an empty copy for the custom state that can be used in ResourceMeta when + // interacting with the remote service. + ResourceMeta ResourceMeta `json:"resourceMeta" pflag:"-,A copy for the custom state."` +} diff --git a/flyteplugins/go/tasks/pluginmachinery/webapi/pluginconfig_flags.go b/flyteplugins/go/tasks/pluginmachinery/webapi/pluginconfig_flags.go new file mode 100755 index 0000000000..b989f11713 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/webapi/pluginconfig_flags.go @@ -0,0 +1,62 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package webapi + +import ( + "encoding/json" + "reflect" + + "fmt" + + "github.com/spf13/pflag" +) + +// If v is a pointer, it will get its element value or the zero value of the element type. +// If v is not a pointer, it will return it as is. +func (PluginConfig) elemValueOrNil(v interface{}) interface{} { + if t := reflect.TypeOf(v); t.Kind() == reflect.Ptr { + if reflect.ValueOf(v).IsNil() { + return reflect.Zero(t.Elem()).Interface() + } else { + return reflect.ValueOf(v).Interface() + } + } else if v == nil { + return reflect.Zero(t).Interface() + } + + return v +} + +func (PluginConfig) mustJsonMarshal(v interface{}) string { + raw, err := json.Marshal(v) + if err != nil { + panic(err) + } + + return string(raw) +} + +func (PluginConfig) mustMarshalJSON(v json.Marshaler) string { + raw, err := v.MarshalJSON() + if err != nil { + panic(err) + } + + return string(raw) +} + +// GetPFlagSet will return strongly types pflags for all fields in PluginConfig and its nested types. The format of the +// flags is json-name.json-sub-name... etc. +func (cfg PluginConfig) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("PluginConfig", pflag.ExitOnError) + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "readRateLimiter.qps"), DefaultPluginConfig.ReadRateLimiter.QPS, "Defines the max rate of calls per second.") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "readRateLimiter.burst"), DefaultPluginConfig.ReadRateLimiter.Burst, "Defines the maximum burst size.") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "writeRateLimiter.qps"), DefaultPluginConfig.WriteRateLimiter.QPS, "Defines the max rate of calls per second.") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "writeRateLimiter.burst"), DefaultPluginConfig.WriteRateLimiter.Burst, "Defines the maximum burst size.") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "caching.size"), DefaultPluginConfig.Caching.Size, "Defines the maximum number of items to cache.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "caching.resyncInterval"), DefaultPluginConfig.Caching.ResyncInterval.String(), "Defines the sync interval.") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "caching.workers"), DefaultPluginConfig.Caching.Workers, "Defines the number of workers to start up to process items.") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "caching.maxSystemFailures"), DefaultPluginConfig.Caching.MaxSystemFailures, "Defines the number of failures to fetch a task before failing the task.") + return cmdFlags +} diff --git a/flyteplugins/go/tasks/pluginmachinery/webapi/pluginconfig_flags_test.go b/flyteplugins/go/tasks/pluginmachinery/webapi/pluginconfig_flags_test.go new file mode 100755 index 0000000000..9f5124f069 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/webapi/pluginconfig_flags_test.go @@ -0,0 +1,214 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package webapi + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "testing" + + "github.com/mitchellh/mapstructure" + "github.com/stretchr/testify/assert" +) + +var dereferencableKindsPluginConfig = map[reflect.Kind]struct{}{ + reflect.Array: {}, reflect.Chan: {}, reflect.Map: {}, reflect.Ptr: {}, reflect.Slice: {}, +} + +// Checks if t is a kind that can be dereferenced to get its underlying type. +func canGetElementPluginConfig(t reflect.Kind) bool { + _, exists := dereferencableKindsPluginConfig[t] + return exists +} + +// This decoder hook tests types for json unmarshaling capability. If implemented, it uses json unmarshal to build the +// object. Otherwise, it'll just pass on the original data. +func jsonUnmarshalerHookPluginConfig(_, to reflect.Type, data interface{}) (interface{}, error) { + unmarshalerType := reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + if to.Implements(unmarshalerType) || reflect.PtrTo(to).Implements(unmarshalerType) || + (canGetElementPluginConfig(to.Kind()) && to.Elem().Implements(unmarshalerType)) { + + raw, err := json.Marshal(data) + if err != nil { + fmt.Printf("Failed to marshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + res := reflect.New(to).Interface() + err = json.Unmarshal(raw, &res) + if err != nil { + fmt.Printf("Failed to umarshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + return res, nil + } + + return data, nil +} + +func decode_PluginConfig(input, result interface{}) error { + config := &mapstructure.DecoderConfig{ + TagName: "json", + WeaklyTypedInput: true, + Result: result, + DecodeHook: mapstructure.ComposeDecodeHookFunc( + mapstructure.StringToTimeDurationHookFunc(), + mapstructure.StringToSliceHookFunc(","), + jsonUnmarshalerHookPluginConfig, + ), + } + + decoder, err := mapstructure.NewDecoder(config) + if err != nil { + return err + } + + return decoder.Decode(input) +} + +func join_PluginConfig(arr interface{}, sep string) string { + listValue := reflect.ValueOf(arr) + strs := make([]string, 0, listValue.Len()) + for i := 0; i < listValue.Len(); i++ { + strs = append(strs, fmt.Sprintf("%v", listValue.Index(i))) + } + + return strings.Join(strs, sep) +} + +func testDecodeJson_PluginConfig(t *testing.T, val, result interface{}) { + assert.NoError(t, decode_PluginConfig(val, result)) +} + +func testDecodeRaw_PluginConfig(t *testing.T, vStringSlice, result interface{}) { + assert.NoError(t, decode_PluginConfig(vStringSlice, result)) +} + +func TestPluginConfig_GetPFlagSet(t *testing.T) { + val := PluginConfig{} + cmdFlags := val.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) +} + +func TestPluginConfig_SetFlags(t *testing.T) { + actual := PluginConfig{} + cmdFlags := actual.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) + + t.Run("Test_readRateLimiter.qps", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("readRateLimiter.qps", testValue) + if vInt, err := cmdFlags.GetInt("readRateLimiter.qps"); err == nil { + testDecodeJson_PluginConfig(t, fmt.Sprintf("%v", vInt), &actual.ReadRateLimiter.QPS) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_readRateLimiter.burst", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("readRateLimiter.burst", testValue) + if vInt, err := cmdFlags.GetInt("readRateLimiter.burst"); err == nil { + testDecodeJson_PluginConfig(t, fmt.Sprintf("%v", vInt), &actual.ReadRateLimiter.Burst) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_writeRateLimiter.qps", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("writeRateLimiter.qps", testValue) + if vInt, err := cmdFlags.GetInt("writeRateLimiter.qps"); err == nil { + testDecodeJson_PluginConfig(t, fmt.Sprintf("%v", vInt), &actual.WriteRateLimiter.QPS) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_writeRateLimiter.burst", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("writeRateLimiter.burst", testValue) + if vInt, err := cmdFlags.GetInt("writeRateLimiter.burst"); err == nil { + testDecodeJson_PluginConfig(t, fmt.Sprintf("%v", vInt), &actual.WriteRateLimiter.Burst) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_caching.size", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("caching.size", testValue) + if vInt, err := cmdFlags.GetInt("caching.size"); err == nil { + testDecodeJson_PluginConfig(t, fmt.Sprintf("%v", vInt), &actual.Caching.Size) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_caching.resyncInterval", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := DefaultPluginConfig.Caching.ResyncInterval.String() + + cmdFlags.Set("caching.resyncInterval", testValue) + if vString, err := cmdFlags.GetString("caching.resyncInterval"); err == nil { + testDecodeJson_PluginConfig(t, fmt.Sprintf("%v", vString), &actual.Caching.ResyncInterval) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_caching.workers", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("caching.workers", testValue) + if vInt, err := cmdFlags.GetInt("caching.workers"); err == nil { + testDecodeJson_PluginConfig(t, fmt.Sprintf("%v", vInt), &actual.Caching.Workers) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_caching.maxSystemFailures", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("caching.maxSystemFailures", testValue) + if vInt, err := cmdFlags.GetInt("caching.maxSystemFailures"); err == nil { + testDecodeJson_PluginConfig(t, fmt.Sprintf("%v", vInt), &actual.Caching.MaxSystemFailures) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/workqueue/config.go b/flyteplugins/go/tasks/pluginmachinery/workqueue/config.go new file mode 100644 index 0000000000..e05341daa2 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/workqueue/config.go @@ -0,0 +1,8 @@ +package workqueue + +// Config for the queue +type Config struct { + Workers int `json:"workers" pflag:",Number of concurrent workers to start processing the queue."` + MaxRetries int `json:"maxRetries" pflag:",Maximum number of retries per item."` + IndexCacheMaxItems int `json:"maxItems" pflag:",Maximum number of entries to keep in the index."` +} diff --git a/flyteplugins/go/tasks/pluginmachinery/workqueue/mocks/indexed_work_queue.go b/flyteplugins/go/tasks/pluginmachinery/workqueue/mocks/indexed_work_queue.go new file mode 100644 index 0000000000..f0b1b96a20 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/workqueue/mocks/indexed_work_queue.go @@ -0,0 +1,196 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + workqueue "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/workqueue" + mock "github.com/stretchr/testify/mock" +) + +// IndexedWorkQueue is an autogenerated mock type for the IndexedWorkQueue type +type IndexedWorkQueue struct { + mock.Mock +} + +type IndexedWorkQueue_Expecter struct { + mock *mock.Mock +} + +func (_m *IndexedWorkQueue) EXPECT() *IndexedWorkQueue_Expecter { + return &IndexedWorkQueue_Expecter{mock: &_m.Mock} +} + +// Get provides a mock function with given fields: id +func (_m *IndexedWorkQueue) Get(id workqueue.WorkItemID) (workqueue.WorkItemInfo, bool, error) { + ret := _m.Called(id) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 workqueue.WorkItemInfo + var r1 bool + var r2 error + if rf, ok := ret.Get(0).(func(workqueue.WorkItemID) (workqueue.WorkItemInfo, bool, error)); ok { + return rf(id) + } + if rf, ok := ret.Get(0).(func(workqueue.WorkItemID) workqueue.WorkItemInfo); ok { + r0 = rf(id) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(workqueue.WorkItemInfo) + } + } + + if rf, ok := ret.Get(1).(func(workqueue.WorkItemID) bool); ok { + r1 = rf(id) + } else { + r1 = ret.Get(1).(bool) + } + + if rf, ok := ret.Get(2).(func(workqueue.WorkItemID) error); ok { + r2 = rf(id) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// IndexedWorkQueue_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type IndexedWorkQueue_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - id workqueue.WorkItemID +func (_e *IndexedWorkQueue_Expecter) Get(id interface{}) *IndexedWorkQueue_Get_Call { + return &IndexedWorkQueue_Get_Call{Call: _e.mock.On("Get", id)} +} + +func (_c *IndexedWorkQueue_Get_Call) Run(run func(id workqueue.WorkItemID)) *IndexedWorkQueue_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(workqueue.WorkItemID)) + }) + return _c +} + +func (_c *IndexedWorkQueue_Get_Call) Return(info workqueue.WorkItemInfo, found bool, err error) *IndexedWorkQueue_Get_Call { + _c.Call.Return(info, found, err) + return _c +} + +func (_c *IndexedWorkQueue_Get_Call) RunAndReturn(run func(workqueue.WorkItemID) (workqueue.WorkItemInfo, bool, error)) *IndexedWorkQueue_Get_Call { + _c.Call.Return(run) + return _c +} + +// Queue provides a mock function with given fields: ctx, id, once +func (_m *IndexedWorkQueue) Queue(ctx context.Context, id workqueue.WorkItemID, once workqueue.WorkItem) error { + ret := _m.Called(ctx, id, once) + + if len(ret) == 0 { + panic("no return value specified for Queue") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, workqueue.WorkItemID, workqueue.WorkItem) error); ok { + r0 = rf(ctx, id, once) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// IndexedWorkQueue_Queue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Queue' +type IndexedWorkQueue_Queue_Call struct { + *mock.Call +} + +// Queue is a helper method to define mock.On call +// - ctx context.Context +// - id workqueue.WorkItemID +// - once workqueue.WorkItem +func (_e *IndexedWorkQueue_Expecter) Queue(ctx interface{}, id interface{}, once interface{}) *IndexedWorkQueue_Queue_Call { + return &IndexedWorkQueue_Queue_Call{Call: _e.mock.On("Queue", ctx, id, once)} +} + +func (_c *IndexedWorkQueue_Queue_Call) Run(run func(ctx context.Context, id workqueue.WorkItemID, once workqueue.WorkItem)) *IndexedWorkQueue_Queue_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(workqueue.WorkItemID), args[2].(workqueue.WorkItem)) + }) + return _c +} + +func (_c *IndexedWorkQueue_Queue_Call) Return(_a0 error) *IndexedWorkQueue_Queue_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *IndexedWorkQueue_Queue_Call) RunAndReturn(run func(context.Context, workqueue.WorkItemID, workqueue.WorkItem) error) *IndexedWorkQueue_Queue_Call { + _c.Call.Return(run) + return _c +} + +// Start provides a mock function with given fields: ctx +func (_m *IndexedWorkQueue) Start(ctx context.Context) error { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Start") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(ctx) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// IndexedWorkQueue_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start' +type IndexedWorkQueue_Start_Call struct { + *mock.Call +} + +// Start is a helper method to define mock.On call +// - ctx context.Context +func (_e *IndexedWorkQueue_Expecter) Start(ctx interface{}) *IndexedWorkQueue_Start_Call { + return &IndexedWorkQueue_Start_Call{Call: _e.mock.On("Start", ctx)} +} + +func (_c *IndexedWorkQueue_Start_Call) Run(run func(ctx context.Context)) *IndexedWorkQueue_Start_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *IndexedWorkQueue_Start_Call) Return(_a0 error) *IndexedWorkQueue_Start_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *IndexedWorkQueue_Start_Call) RunAndReturn(run func(context.Context) error) *IndexedWorkQueue_Start_Call { + _c.Call.Return(run) + return _c +} + +// NewIndexedWorkQueue creates a new instance of IndexedWorkQueue. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewIndexedWorkQueue(t interface { + mock.TestingT + Cleanup(func()) +}) *IndexedWorkQueue { + mock := &IndexedWorkQueue{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/workqueue/mocks/processor.go b/flyteplugins/go/tasks/pluginmachinery/workqueue/mocks/processor.go new file mode 100644 index 0000000000..da39aa8b32 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/workqueue/mocks/processor.go @@ -0,0 +1,94 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + workqueue "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/workqueue" + mock "github.com/stretchr/testify/mock" +) + +// Processor is an autogenerated mock type for the Processor type +type Processor struct { + mock.Mock +} + +type Processor_Expecter struct { + mock *mock.Mock +} + +func (_m *Processor) EXPECT() *Processor_Expecter { + return &Processor_Expecter{mock: &_m.Mock} +} + +// Process provides a mock function with given fields: ctx, workItem +func (_m *Processor) Process(ctx context.Context, workItem workqueue.WorkItem) (workqueue.WorkStatus, error) { + ret := _m.Called(ctx, workItem) + + if len(ret) == 0 { + panic("no return value specified for Process") + } + + var r0 workqueue.WorkStatus + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, workqueue.WorkItem) (workqueue.WorkStatus, error)); ok { + return rf(ctx, workItem) + } + if rf, ok := ret.Get(0).(func(context.Context, workqueue.WorkItem) workqueue.WorkStatus); ok { + r0 = rf(ctx, workItem) + } else { + r0 = ret.Get(0).(workqueue.WorkStatus) + } + + if rf, ok := ret.Get(1).(func(context.Context, workqueue.WorkItem) error); ok { + r1 = rf(ctx, workItem) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Processor_Process_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Process' +type Processor_Process_Call struct { + *mock.Call +} + +// Process is a helper method to define mock.On call +// - ctx context.Context +// - workItem workqueue.WorkItem +func (_e *Processor_Expecter) Process(ctx interface{}, workItem interface{}) *Processor_Process_Call { + return &Processor_Process_Call{Call: _e.mock.On("Process", ctx, workItem)} +} + +func (_c *Processor_Process_Call) Run(run func(ctx context.Context, workItem workqueue.WorkItem)) *Processor_Process_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(workqueue.WorkItem)) + }) + return _c +} + +func (_c *Processor_Process_Call) Return(_a0 workqueue.WorkStatus, _a1 error) *Processor_Process_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Processor_Process_Call) RunAndReturn(run func(context.Context, workqueue.WorkItem) (workqueue.WorkStatus, error)) *Processor_Process_Call { + _c.Call.Return(run) + return _c +} + +// NewProcessor creates a new instance of Processor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewProcessor(t interface { + mock.TestingT + Cleanup(func()) +}) *Processor { + mock := &Processor{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/workqueue/mocks/work_item.go b/flyteplugins/go/tasks/pluginmachinery/workqueue/mocks/work_item.go new file mode 100644 index 0000000000..5d9b7921b3 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/workqueue/mocks/work_item.go @@ -0,0 +1,32 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// WorkItem is an autogenerated mock type for the WorkItem type +type WorkItem struct { + mock.Mock +} + +type WorkItem_Expecter struct { + mock *mock.Mock +} + +func (_m *WorkItem) EXPECT() *WorkItem_Expecter { + return &WorkItem_Expecter{mock: &_m.Mock} +} + +// NewWorkItem creates a new instance of WorkItem. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewWorkItem(t interface { + mock.TestingT + Cleanup(func()) +}) *WorkItem { + mock := &WorkItem{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/workqueue/mocks/work_item_info.go b/flyteplugins/go/tasks/pluginmachinery/workqueue/mocks/work_item_info.go new file mode 100644 index 0000000000..f8ceb6793d --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/workqueue/mocks/work_item_info.go @@ -0,0 +1,217 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + workqueue "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/workqueue" + mock "github.com/stretchr/testify/mock" +) + +// WorkItemInfo is an autogenerated mock type for the WorkItemInfo type +type WorkItemInfo struct { + mock.Mock +} + +type WorkItemInfo_Expecter struct { + mock *mock.Mock +} + +func (_m *WorkItemInfo) EXPECT() *WorkItemInfo_Expecter { + return &WorkItemInfo_Expecter{mock: &_m.Mock} +} + +// Error provides a mock function with no fields +func (_m *WorkItemInfo) Error() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Error") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// WorkItemInfo_Error_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Error' +type WorkItemInfo_Error_Call struct { + *mock.Call +} + +// Error is a helper method to define mock.On call +func (_e *WorkItemInfo_Expecter) Error() *WorkItemInfo_Error_Call { + return &WorkItemInfo_Error_Call{Call: _e.mock.On("Error")} +} + +func (_c *WorkItemInfo_Error_Call) Run(run func()) *WorkItemInfo_Error_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *WorkItemInfo_Error_Call) Return(_a0 error) *WorkItemInfo_Error_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *WorkItemInfo_Error_Call) RunAndReturn(run func() error) *WorkItemInfo_Error_Call { + _c.Call.Return(run) + return _c +} + +// ID provides a mock function with no fields +func (_m *WorkItemInfo) ID() workqueue.WorkItemID { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for ID") + } + + var r0 workqueue.WorkItemID + if rf, ok := ret.Get(0).(func() workqueue.WorkItemID); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(workqueue.WorkItemID) + } + + return r0 +} + +// WorkItemInfo_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID' +type WorkItemInfo_ID_Call struct { + *mock.Call +} + +// ID is a helper method to define mock.On call +func (_e *WorkItemInfo_Expecter) ID() *WorkItemInfo_ID_Call { + return &WorkItemInfo_ID_Call{Call: _e.mock.On("ID")} +} + +func (_c *WorkItemInfo_ID_Call) Run(run func()) *WorkItemInfo_ID_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *WorkItemInfo_ID_Call) Return(_a0 workqueue.WorkItemID) *WorkItemInfo_ID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *WorkItemInfo_ID_Call) RunAndReturn(run func() workqueue.WorkItemID) *WorkItemInfo_ID_Call { + _c.Call.Return(run) + return _c +} + +// Item provides a mock function with no fields +func (_m *WorkItemInfo) Item() workqueue.WorkItem { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Item") + } + + var r0 workqueue.WorkItem + if rf, ok := ret.Get(0).(func() workqueue.WorkItem); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(workqueue.WorkItem) + } + } + + return r0 +} + +// WorkItemInfo_Item_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Item' +type WorkItemInfo_Item_Call struct { + *mock.Call +} + +// Item is a helper method to define mock.On call +func (_e *WorkItemInfo_Expecter) Item() *WorkItemInfo_Item_Call { + return &WorkItemInfo_Item_Call{Call: _e.mock.On("Item")} +} + +func (_c *WorkItemInfo_Item_Call) Run(run func()) *WorkItemInfo_Item_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *WorkItemInfo_Item_Call) Return(_a0 workqueue.WorkItem) *WorkItemInfo_Item_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *WorkItemInfo_Item_Call) RunAndReturn(run func() workqueue.WorkItem) *WorkItemInfo_Item_Call { + _c.Call.Return(run) + return _c +} + +// Status provides a mock function with no fields +func (_m *WorkItemInfo) Status() workqueue.WorkStatus { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Status") + } + + var r0 workqueue.WorkStatus + if rf, ok := ret.Get(0).(func() workqueue.WorkStatus); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(workqueue.WorkStatus) + } + + return r0 +} + +// WorkItemInfo_Status_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Status' +type WorkItemInfo_Status_Call struct { + *mock.Call +} + +// Status is a helper method to define mock.On call +func (_e *WorkItemInfo_Expecter) Status() *WorkItemInfo_Status_Call { + return &WorkItemInfo_Status_Call{Call: _e.mock.On("Status")} +} + +func (_c *WorkItemInfo_Status_Call) Run(run func()) *WorkItemInfo_Status_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *WorkItemInfo_Status_Call) Return(_a0 workqueue.WorkStatus) *WorkItemInfo_Status_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *WorkItemInfo_Status_Call) RunAndReturn(run func() workqueue.WorkStatus) *WorkItemInfo_Status_Call { + _c.Call.Return(run) + return _c +} + +// NewWorkItemInfo creates a new instance of WorkItemInfo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewWorkItemInfo(t interface { + mock.TestingT + Cleanup(func()) +}) *WorkItemInfo { + mock := &WorkItemInfo{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flyteplugins/go/tasks/pluginmachinery/workqueue/queue.go b/flyteplugins/go/tasks/pluginmachinery/workqueue/queue.go new file mode 100644 index 0000000000..71f44d7c81 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/workqueue/queue.go @@ -0,0 +1,280 @@ +package workqueue + +import ( + "context" + "fmt" + "sync" + + lru "github.com/hashicorp/golang-lru" + "github.com/prometheus/client_golang/prometheus" + "k8s.io/client-go/util/workqueue" + + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +//go:generate enumer --type=WorkStatus + +type WorkItemID = string +type WorkStatus uint8 + +const ( + WorkStatusNotDone WorkStatus = iota + WorkStatusSucceeded + WorkStatusFailed +) + +const ( + ErrNotYetStarted errors.ErrorCode = "NOT_STARTED" +) + +func (w WorkStatus) IsTerminal() bool { + return w == WorkStatusFailed || w == WorkStatusSucceeded +} + +// WorkItem is a generic item that can be stored in the work queue. +type WorkItem interface{} + +// Represents the result of the work item processing. +type WorkItemInfo interface { + Item() WorkItem + ID() WorkItemID + Status() WorkStatus + Error() error +} + +// Represents the indexed queue semantics. An indexed work queue is a work queue that additionally keeps track of the +// final processing results of work items. +type IndexedWorkQueue interface { + // Queues the item to be processed. If the item is already in the cache or has been processed before (and is still + // in-memory), it'll not be added again. + Queue(ctx context.Context, id WorkItemID, once WorkItem) error + + // Retrieves an item by id. + Get(id WorkItemID) (info WorkItemInfo, found bool, err error) + + // Start must be called before queuing items into the queue. + Start(ctx context.Context) error +} + +// Represents the processor logic to operate on work items. +type Processor interface { + Process(ctx context.Context, workItem WorkItem) (WorkStatus, error) +} + +type workItemWrapper struct { + id WorkItemID + logFields map[string]interface{} + payload WorkItem + status WorkStatus + retryCount uint + err error +} + +func (w workItemWrapper) Item() WorkItem { + return w.payload +} + +func (w workItemWrapper) ID() WorkItemID { + return w.id +} + +func (w workItemWrapper) Status() WorkStatus { + return w.status +} + +func (w workItemWrapper) Error() error { + return w.err +} + +func (w workItemWrapper) Clone() workItemWrapper { + return w +} + +type metrics struct { + CacheHit prometheus.Counter + CacheMiss prometheus.Counter + ProcessorErrors prometheus.Counter + Scope promutils.Scope +} + +type queue struct { + name string + metrics metrics + wlock sync.Mutex + rlock sync.RWMutex + workers int + maxRetries int + started bool + queue workqueue.Interface + index workItemCache + processor Processor +} + +type workItemCache struct { + *lru.Cache +} + +func (c workItemCache) Get(id WorkItemID) (item *workItemWrapper, found bool) { + o, found := c.Cache.Get(id) + if !found { + return nil, found + } + + return o.(*workItemWrapper), true +} + +func (c workItemCache) Add(item *workItemWrapper) (evicted bool) { + return c.Cache.Add(item.id, item) +} + +func copyAllowedLogFields(ctx context.Context) map[string]interface{} { + logFields := contextutils.GetLogFields(ctx) + delete(logFields, contextutils.RoutineLabelKey.String()) + return logFields +} + +func (q *queue) Queue(ctx context.Context, id WorkItemID, once WorkItem) error { + q.wlock.Lock() + defer q.wlock.Unlock() + + if !q.started { + return errors.Errorf(ErrNotYetStarted, "Queue must be started before enqueuing any item.") + } + + if _, found := q.index.Get(id); found { + return nil + } + + wrapper := &workItemWrapper{ + id: id, + logFields: copyAllowedLogFields(ctx), + payload: once, + } + + q.index.Add(wrapper) + q.queue.Add(wrapper) + return nil +} + +func (q *queue) Get(id WorkItemID) (info WorkItemInfo, found bool, err error) { + q.rlock.Lock() + defer q.rlock.Unlock() + + wrapper, found := q.index.Get(id) + if !found { + q.metrics.CacheMiss.Inc() + return nil, found, nil + } + + v := wrapper.Clone() + q.metrics.CacheHit.Inc() + return &v, true, nil +} + +func contextWithValues(ctx context.Context, fields map[string]interface{}) context.Context { + for key, value := range fields { + ctx = context.WithValue(ctx, contextutils.Key(key), value) + } + + return ctx +} + +func (q *queue) Start(ctx context.Context) error { + q.wlock.Lock() + defer q.wlock.Unlock() + + if q.started { + return fmt.Errorf("queue already started") + } + + for i := 0; i < q.workers; i++ { + go func(ctx context.Context) { + for { + select { + case <-ctx.Done(): + logger.Debug(ctx, "Context cancelled. Shutting down.") + return + default: + item, shutdown := q.queue.Get() + if shutdown { + logger.Debug(ctx, "Work queue is shutting down.") + return + } + + wrapperV := item.(*workItemWrapper).Clone() + wrapper := &wrapperV + ws := wrapper.status + var err error + + func() { + defer func() { + if e, ok := recover().(error); ok { + logger.Errorf(ctx, "Worker panic'd while processing item [%v]. Error: %v", wrapper.id, e) + err = e + } + }() + + ctxWithFields := contextWithValues(ctx, wrapper.logFields) + ws, err = q.processor.Process(ctxWithFields, wrapper.payload) + }() + + if err != nil { + q.metrics.ProcessorErrors.Inc() + + wrapper.retryCount++ + wrapper.err = err + if wrapper.retryCount >= uint(q.maxRetries) { + logger.Debugf(ctx, "WorkItem [%v] exhausted all retries. Last Error: %v.", + wrapper.ID(), err) + wrapper.status = WorkStatusFailed + ws = WorkStatusFailed + q.index.Add(wrapper) + continue + } + } + + wrapper.status = ws + q.index.Add(wrapper) + if !ws.IsTerminal() { + q.queue.Add(wrapper) + } + } + } + }(contextutils.WithGoroutineLabel(ctx, fmt.Sprintf("%v-worker-%v", q.name, i))) + } + + q.started = true + return nil +} + +func newMetrics(scope promutils.Scope) metrics { + return metrics{ + CacheHit: scope.MustNewCounter("cache_hit", "Counter for cache hits."), + CacheMiss: scope.MustNewCounter("cache_miss", "Counter for cache misses."), + ProcessorErrors: scope.MustNewCounter("proc_errors", "Counter for processor errors."), + Scope: scope, + } +} + +// Instantiates a new Indexed Work queue. +func NewIndexedWorkQueue(name string, processor Processor, cfg Config, metricsScope promutils.Scope) (IndexedWorkQueue, error) { + cache, err := lru.New(cfg.IndexCacheMaxItems) + if err != nil { + return nil, err + } + + return &queue{ + name: name, + metrics: newMetrics(metricsScope), + wlock: sync.Mutex{}, + rlock: sync.RWMutex{}, + workers: cfg.Workers, + maxRetries: cfg.MaxRetries, + queue: workqueue.NewNamed(metricsScope.CurrentScope()), + index: workItemCache{Cache: cache}, + processor: processor, + }, nil +} diff --git a/flyteplugins/go/tasks/pluginmachinery/workqueue/queue_test.go b/flyteplugins/go/tasks/pluginmachinery/workqueue/queue_test.go new file mode 100644 index 0000000000..5f763ace0e --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/workqueue/queue_test.go @@ -0,0 +1,249 @@ +package workqueue + +import ( + "context" + "fmt" + "reflect" + "testing" + "time" + + "github.com/go-test/deep" + lru "github.com/hashicorp/golang-lru" + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +type singleStatusProcessor struct { + targetStatus WorkStatus + expectedType interface{} + expectedContextFields []contextutils.Key +} + +func (s singleStatusProcessor) Process(ctx context.Context, workItem WorkItem) (WorkStatus, error) { + comingType := reflect.TypeOf(workItem) + expectedType := reflect.TypeOf(s.expectedType) + if comingType != expectedType { + return WorkStatusFailed, fmt.Errorf("expected Type != incoming Type. %v != %v", expectedType, comingType) + } + + for _, expectedField := range s.expectedContextFields { + actualVal := ctx.Value(expectedField) + if actualVal == nil { + return WorkStatusFailed, fmt.Errorf("expected field not found. [%v]", expectedField) + } + } + + return s.targetStatus, nil +} + +func newSingleStatusProcessor(expectedType interface{}, status WorkStatus) singleStatusProcessor { + return singleStatusProcessor{targetStatus: status, expectedType: expectedType} +} + +type alwaysFailingProcessor struct{} + +func (alwaysFailingProcessor) Process(ctx context.Context, workItem WorkItem) (WorkStatus, error) { + return WorkStatusNotDone, fmt.Errorf("this processor always errors") +} + +func TestWorkStatus_IsTerminal(t *testing.T) { + tests := []struct { + w WorkStatus + want bool + }{ + {WorkStatusSucceeded, true}, + {WorkStatusNotDone, false}, + {WorkStatusFailed, true}, + } + for _, tt := range tests { + t.Run(string(tt.w), func(t *testing.T) { + if got := tt.w.IsTerminal(); got != tt.want { + t.Errorf("WorkStatus.IsTerminal() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_workItemCache_Get(t *testing.T) { + l, err := lru.New(10) + assert.NoError(t, err) + + c := workItemCache{Cache: l} + item := &workItemWrapper{ + id: "ABC", + payload: "hello", + } + c.Add(item) + + tests := []struct { + name string + c workItemCache + args WorkItemID + wantItem *workItemWrapper + wantFound bool + }{ + {"Found", c, "ABC", item, true}, + {"NotFound", c, "EFG", nil, false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + i, gotFound := tt.c.Get(tt.args) + if gotFound != tt.wantFound { + t.Errorf("workItemCache.Get() gotFound = %v, want %v", gotFound, tt.wantFound) + } + + if tt.wantItem != nil { + assert.Equal(t, tt.wantItem.ID(), i.ID()) + assert.Equal(t, tt.wantItem.Item(), i.Item()) + assert.Equal(t, tt.wantItem.Error(), i.Error()) + assert.Equal(t, tt.wantItem.Status(), i.Status()) + } + }) + } +} + +func Test_workItemCache_Add(t *testing.T) { + l, err := lru.New(1) + assert.NoError(t, err) + + c := workItemCache{Cache: l} + + tests := []struct { + name string + c workItemCache + args *workItemWrapper + wantEvicted bool + }{ + {"NotEvicted", c, &workItemWrapper{id: "abc"}, false}, + {"NotEvicted2", c, &workItemWrapper{id: "abc"}, false}, + {"Evicted", c, &workItemWrapper{id: "efg"}, true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if gotEvicted := tt.c.Add(tt.args); gotEvicted != tt.wantEvicted { + t.Errorf("workItemCache.Add() = %v, want %v", gotEvicted, tt.wantEvicted) + } + }) + } +} + +func Test_queue_Queue(t *testing.T) { + t.Run("Err when not started", func(t *testing.T) { + q, err := NewIndexedWorkQueue("test1", newSingleStatusProcessor("hello", WorkStatusFailed), Config{Workers: 1, MaxRetries: 0, IndexCacheMaxItems: 1}, promutils.NewTestScope()) + assert.NoError(t, err) + assert.Error(t, q.Queue(context.TODO(), "abc", "abc")) + }) + + t.Run("Started first", func(t *testing.T) { + q, err := NewIndexedWorkQueue("test1", newSingleStatusProcessor("hello", WorkStatusSucceeded), Config{Workers: 1, MaxRetries: 0, IndexCacheMaxItems: 1}, promutils.NewTestScope()) + assert.NoError(t, err) + + ctx, cancelNow := context.WithCancel(context.Background()) + assert.NoError(t, q.Start(ctx)) + assert.NoError(t, q.Queue(context.TODO(), "abc", "abc")) + cancelNow() + }) +} + +func Test_queue_Get(t *testing.T) { + q, err := NewIndexedWorkQueue("test1", newSingleStatusProcessor(&workItemWrapper{}, WorkStatusSucceeded), Config{Workers: 1, MaxRetries: 0, IndexCacheMaxItems: 1}, promutils.NewTestScope()) + assert.NoError(t, err) + + ctx, cancelNow := context.WithCancel(context.Background()) + defer cancelNow() + assert.NoError(t, q.Start(ctx)) + + assert.NoError(t, q.Queue(ctx, "abc", &workItemWrapper{ + id: "abc", + payload: "something", + })) + + tests := []struct { + name string + q IndexedWorkQueue + id WorkItemID + wantInfo WorkItemInfo + wantFound bool + wantErr bool + }{ + {"Found", q, "abc", &workItemWrapper{ + status: WorkStatusSucceeded, + id: "abc", + payload: &workItemWrapper{id: "abc", payload: "something"}, + }, true, false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + gotInfo, gotFound, err := tt.q.Get(tt.id) + if (err != nil) != tt.wantErr { + t.Errorf("queue.Get() error = %v, wantErr %v", err, tt.wantErr) + return + } + if diff := deep.Equal(gotInfo, tt.wantInfo); diff != nil { + t.Errorf("queue.Get() diff = %v, gotInfo = %v, want %v", diff, gotInfo, tt.wantInfo) + } + if gotFound != tt.wantFound { + t.Errorf("queue.Get() gotFound = %v, want %v", gotFound, tt.wantFound) + } + }) + } +} + +func Test_queue_contextFields(t *testing.T) { + q, err := NewIndexedWorkQueue("test1", singleStatusProcessor{ + targetStatus: WorkStatusSucceeded, + expectedType: &workItemWrapper{}, + expectedContextFields: []contextutils.Key{contextutils.RoutineLabelKey, contextutils.NamespaceKey}, + }, Config{Workers: 1, MaxRetries: 0, IndexCacheMaxItems: 1}, promutils.NewTestScope()) + assert.NoError(t, err) + + ctx, cancelNow := context.WithCancel(context.Background()) + defer cancelNow() + assert.NoError(t, q.Start(ctx)) + + ctx = context.WithValue(context.Background(), contextutils.NamespaceKey, "blah") + assert.NoError(t, q.Queue(ctx, "abc", &workItemWrapper{ + id: "abc", + payload: "something", + logFields: copyAllowedLogFields(ctx), + })) + + wi, found, err := q.Get("abc") + for ; err == nil && (wi.Status() != WorkStatusSucceeded && wi.Status() != WorkStatusFailed); wi, found, err = q.Get("abc") { + assert.True(t, found) + assert.NoError(t, err) + } + + assert.True(t, found) + assert.NoError(t, err) + assert.Equal(t, WorkStatusSucceeded.String(), wi.Status().String()) + assert.NoError(t, wi.Error()) +} + +func Test_queue_Start(t *testing.T) { + q, err := NewIndexedWorkQueue("test1", newSingleStatusProcessor("", WorkStatusSucceeded), Config{Workers: 1, MaxRetries: 0, IndexCacheMaxItems: 1}, promutils.NewTestScope()) + assert.NoError(t, err) + + ctx, cancelNow := context.WithCancel(context.Background()) + defer cancelNow() + assert.NoError(t, q.Start(ctx)) + assert.Error(t, q.Start(ctx)) +} + +func Test_Failures(t *testing.T) { + q, err := NewIndexedWorkQueue("test1", alwaysFailingProcessor{}, Config{Workers: 1, MaxRetries: 0, IndexCacheMaxItems: 1}, promutils.NewTestScope()) + assert.NoError(t, err) + + ctx, cancelNow := context.WithCancel(context.Background()) + defer cancelNow() + assert.NoError(t, q.Start(ctx)) + + assert.NoError(t, q.Queue(ctx, "abc", "hello")) + time.Sleep(100 * time.Millisecond) + info, found, err := q.Get("abc") + assert.NoError(t, err) + assert.True(t, found) + assert.Equal(t, WorkStatusFailed.String(), info.Status().String()) +} diff --git a/flyteplugins/go/tasks/pluginmachinery/workqueue/workstatus_enumer.go b/flyteplugins/go/tasks/pluginmachinery/workqueue/workstatus_enumer.go new file mode 100644 index 0000000000..d0c51c7983 --- /dev/null +++ b/flyteplugins/go/tasks/pluginmachinery/workqueue/workstatus_enumer.go @@ -0,0 +1,50 @@ +// Code generated by "enumer --type=WorkStatus"; DO NOT EDIT. + +package workqueue + +import ( + "fmt" +) + +const _WorkStatusName = "WorkStatusNotDoneWorkStatusSucceededWorkStatusFailed" + +var _WorkStatusIndex = [...]uint8{0, 17, 36, 52} + +func (i WorkStatus) String() string { + if i >= WorkStatus(len(_WorkStatusIndex)-1) { + return fmt.Sprintf("WorkStatus(%d)", i) + } + return _WorkStatusName[_WorkStatusIndex[i]:_WorkStatusIndex[i+1]] +} + +var _WorkStatusValues = []WorkStatus{0, 1, 2} + +var _WorkStatusNameToValueMap = map[string]WorkStatus{ + _WorkStatusName[0:17]: 0, + _WorkStatusName[17:36]: 1, + _WorkStatusName[36:52]: 2, +} + +// WorkStatusString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func WorkStatusString(s string) (WorkStatus, error) { + if val, ok := _WorkStatusNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to WorkStatus values", s) +} + +// WorkStatusValues returns all values of the enum +func WorkStatusValues() []WorkStatus { + return _WorkStatusValues +} + +// IsAWorkStatus returns "true" if the value is listed in the enum definition. "false" otherwise +func (i WorkStatus) IsAWorkStatus() bool { + for _, v := range _WorkStatusValues { + if i == v { + return true + } + } + return false +} diff --git a/flyteplugins/go/tasks/plugins/awsutils/awsutils.go b/flyteplugins/go/tasks/plugins/awsutils/awsutils.go new file mode 100644 index 0000000000..52bcc785d7 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/awsutils/awsutils.go @@ -0,0 +1,27 @@ +package awsutils + +import ( + core2 "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" +) + +func GetRoleFromSecurityContext(roleKey string, taskExecutionMetadata core2.TaskExecutionMetadata) string { + var role string + securityContext := taskExecutionMetadata.GetSecurityContext() + if securityContext.GetRunAs() != nil { + role = securityContext.GetRunAs().GetIamRole() + } + + // Continue this for backward compatibility + if len(role) == 0 { + role = getRole(roleKey, taskExecutionMetadata.GetAnnotations()) + } + return role +} + +func getRole(roleKey string, keyValueMap map[string]string) string { + if len(roleKey) > 0 { + return keyValueMap[roleKey] + } + + return "" +} diff --git a/flyteplugins/go/tasks/plugins/k8s/dask/config.go b/flyteplugins/go/tasks/plugins/k8s/dask/config.go new file mode 100644 index 0000000000..78393a435e --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/dask/config.go @@ -0,0 +1,29 @@ +package dask + +import ( + pluginsConfig "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/logs" +) + +//go:generate pflags Config --default-var=defaultConfig + +var ( + defaultConfig = Config{ + Logs: logs.DefaultConfig, + } + + configSection = pluginsConfig.MustRegisterSubSection("dask", &defaultConfig) +) + +// Config is config for 'dask' plugin +type Config struct { + Logs logs.LogConfig `json:"logs,omitempty"` +} + +func GetConfig() *Config { + return configSection.GetConfig().(*Config) +} + +func SetConfig(cfg *Config) error { + return configSection.SetConfig(cfg) +} diff --git a/flyteplugins/go/tasks/plugins/k8s/dask/config_flags.go b/flyteplugins/go/tasks/plugins/k8s/dask/config_flags.go new file mode 100755 index 0000000000..03774b772b --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/dask/config_flags.go @@ -0,0 +1,65 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package dask + +import ( + "encoding/json" + "reflect" + + "fmt" + + "github.com/spf13/pflag" +) + +// If v is a pointer, it will get its element value or the zero value of the element type. +// If v is not a pointer, it will return it as is. +func (Config) elemValueOrNil(v interface{}) interface{} { + if t := reflect.TypeOf(v); t.Kind() == reflect.Ptr { + if reflect.ValueOf(v).IsNil() { + return reflect.Zero(t.Elem()).Interface() + } else { + return reflect.ValueOf(v).Interface() + } + } else if v == nil { + return reflect.Zero(t).Interface() + } + + return v +} + +func (Config) mustJsonMarshal(v interface{}) string { + raw, err := json.Marshal(v) + if err != nil { + panic(err) + } + + return string(raw) +} + +func (Config) mustMarshalJSON(v json.Marshaler) string { + raw, err := v.MarshalJSON() + if err != nil { + panic(err) + } + + return string(raw) +} + +// GetPFlagSet will return strongly types pflags for all fields in Config and its nested types. The format of the +// flags is json-name.json-sub-name... etc. +func (cfg Config) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("Config", pflag.ExitOnError) + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "logs.cloudwatch-enabled"), defaultConfig.Logs.IsCloudwatchEnabled, "Enable Cloudwatch Logging") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.cloudwatch-region"), defaultConfig.Logs.CloudwatchRegion, "AWS region in which Cloudwatch logs are stored.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.cloudwatch-log-group"), defaultConfig.Logs.CloudwatchLogGroup, "Log group to which streams are associated.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.cloudwatch-template-uri"), defaultConfig.Logs.CloudwatchTemplateURI, "Template Uri to use when building cloudwatch log links") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "logs.kubernetes-enabled"), defaultConfig.Logs.IsKubernetesEnabled, "Enable Kubernetes Logging") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.kubernetes-url"), defaultConfig.Logs.KubernetesURL, "Console URL for Kubernetes logs") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.kubernetes-template-uri"), defaultConfig.Logs.KubernetesTemplateURI, "Template Uri to use when building kubernetes log links") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "logs.stackdriver-enabled"), defaultConfig.Logs.IsStackDriverEnabled, "Enable Log-links to stackdriver") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.gcp-project"), defaultConfig.Logs.GCPProjectName, "Name of the project in GCP") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.stackdriver-logresourcename"), defaultConfig.Logs.StackdriverLogResourceName, "Name of the logresource in stackdriver") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.stackdriver-template-uri"), defaultConfig.Logs.StackDriverTemplateURI, "Template Uri to use when building stackdriver log links") + return cmdFlags +} diff --git a/flyteplugins/go/tasks/plugins/k8s/dask/config_flags_test.go b/flyteplugins/go/tasks/plugins/k8s/dask/config_flags_test.go new file mode 100755 index 0000000000..4cd2be2b44 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/dask/config_flags_test.go @@ -0,0 +1,256 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package dask + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "testing" + + "github.com/mitchellh/mapstructure" + "github.com/stretchr/testify/assert" +) + +var dereferencableKindsConfig = map[reflect.Kind]struct{}{ + reflect.Array: {}, reflect.Chan: {}, reflect.Map: {}, reflect.Ptr: {}, reflect.Slice: {}, +} + +// Checks if t is a kind that can be dereferenced to get its underlying type. +func canGetElementConfig(t reflect.Kind) bool { + _, exists := dereferencableKindsConfig[t] + return exists +} + +// This decoder hook tests types for json unmarshaling capability. If implemented, it uses json unmarshal to build the +// object. Otherwise, it'll just pass on the original data. +func jsonUnmarshalerHookConfig(_, to reflect.Type, data interface{}) (interface{}, error) { + unmarshalerType := reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + if to.Implements(unmarshalerType) || reflect.PtrTo(to).Implements(unmarshalerType) || + (canGetElementConfig(to.Kind()) && to.Elem().Implements(unmarshalerType)) { + + raw, err := json.Marshal(data) + if err != nil { + fmt.Printf("Failed to marshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + res := reflect.New(to).Interface() + err = json.Unmarshal(raw, &res) + if err != nil { + fmt.Printf("Failed to umarshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + return res, nil + } + + return data, nil +} + +func decode_Config(input, result interface{}) error { + config := &mapstructure.DecoderConfig{ + TagName: "json", + WeaklyTypedInput: true, + Result: result, + DecodeHook: mapstructure.ComposeDecodeHookFunc( + mapstructure.StringToTimeDurationHookFunc(), + mapstructure.StringToSliceHookFunc(","), + jsonUnmarshalerHookConfig, + ), + } + + decoder, err := mapstructure.NewDecoder(config) + if err != nil { + return err + } + + return decoder.Decode(input) +} + +func join_Config(arr interface{}, sep string) string { + listValue := reflect.ValueOf(arr) + strs := make([]string, 0, listValue.Len()) + for i := 0; i < listValue.Len(); i++ { + strs = append(strs, fmt.Sprintf("%v", listValue.Index(i))) + } + + return strings.Join(strs, sep) +} + +func testDecodeJson_Config(t *testing.T, val, result interface{}) { + assert.NoError(t, decode_Config(val, result)) +} + +func testDecodeRaw_Config(t *testing.T, vStringSlice, result interface{}) { + assert.NoError(t, decode_Config(vStringSlice, result)) +} + +func TestConfig_GetPFlagSet(t *testing.T) { + val := Config{} + cmdFlags := val.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) +} + +func TestConfig_SetFlags(t *testing.T) { + actual := Config{} + cmdFlags := actual.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) + + t.Run("Test_logs.cloudwatch-enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.cloudwatch-enabled", testValue) + if vBool, err := cmdFlags.GetBool("logs.cloudwatch-enabled"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.Logs.IsCloudwatchEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.cloudwatch-region", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.cloudwatch-region", testValue) + if vString, err := cmdFlags.GetString("logs.cloudwatch-region"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.Logs.CloudwatchRegion) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.cloudwatch-log-group", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.cloudwatch-log-group", testValue) + if vString, err := cmdFlags.GetString("logs.cloudwatch-log-group"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.Logs.CloudwatchLogGroup) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.cloudwatch-template-uri", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.cloudwatch-template-uri", testValue) + if vString, err := cmdFlags.GetString("logs.cloudwatch-template-uri"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.Logs.CloudwatchTemplateURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.kubernetes-enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.kubernetes-enabled", testValue) + if vBool, err := cmdFlags.GetBool("logs.kubernetes-enabled"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.Logs.IsKubernetesEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.kubernetes-url", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.kubernetes-url", testValue) + if vString, err := cmdFlags.GetString("logs.kubernetes-url"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.Logs.KubernetesURL) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.kubernetes-template-uri", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.kubernetes-template-uri", testValue) + if vString, err := cmdFlags.GetString("logs.kubernetes-template-uri"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.Logs.KubernetesTemplateURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.stackdriver-enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.stackdriver-enabled", testValue) + if vBool, err := cmdFlags.GetBool("logs.stackdriver-enabled"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.Logs.IsStackDriverEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.gcp-project", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.gcp-project", testValue) + if vString, err := cmdFlags.GetString("logs.gcp-project"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.Logs.GCPProjectName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.stackdriver-logresourcename", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.stackdriver-logresourcename", testValue) + if vString, err := cmdFlags.GetString("logs.stackdriver-logresourcename"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.Logs.StackdriverLogResourceName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.stackdriver-template-uri", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.stackdriver-template-uri", testValue) + if vString, err := cmdFlags.GetString("logs.stackdriver-template-uri"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.Logs.StackDriverTemplateURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) +} diff --git a/flyteplugins/go/tasks/plugins/k8s/dask/dask.go b/flyteplugins/go/tasks/plugins/k8s/dask/dask.go new file mode 100644 index 0000000000..ed325d9cfa --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/dask/dask.go @@ -0,0 +1,496 @@ +package dask + +import ( + "context" + "fmt" + "strings" + "time" + + daskAPI "github.com/dask/dask-kubernetes/v2023/dask_kubernetes/operator/go_client/pkg/apis/kubernetes.dask.org/v1" + "github.com/samber/lo" + v1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/util/intstr" + "k8s.io/client-go/kubernetes/scheme" + "sigs.k8s.io/controller-runtime/pkg/client" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/logs" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery" + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/tasklog" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/plugins/k8s/pod" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" +) + +const ( + daskTaskType = "dask" + KindDaskJob = "DaskJob" + defaultDaskJobRunnerPrimaryContainerName = "job-runner" +) + +func mergeMapInto(src map[string]string, dst map[string]string) { + for key, value := range src { + dst[key] = value + } +} + +func replacePrimaryContainer(spec *v1.PodSpec, primaryContainerName string, container v1.Container) error { + for i, c := range spec.Containers { + if c.Name == primaryContainerName { + spec.Containers[i] = container + return nil + } + } + return errors.Errorf(errors.BadTaskSpecification, "primary container [%v] not found in pod spec", primaryContainerName) +} + +type daskResourceHandler struct { +} + +func (daskResourceHandler) BuildIdentityResource(_ context.Context, _ pluginsCore.TaskExecutionMetadata) ( + client.Object, error) { + return &daskAPI.DaskJob{ + TypeMeta: metav1.TypeMeta{ + Kind: KindDaskJob, + APIVersion: daskAPI.SchemeGroupVersion.String(), + }, + }, nil +} + +func (p daskResourceHandler) BuildResource(ctx context.Context, taskCtx pluginsCore.TaskExecutionContext) (client.Object, error) { + taskTemplate, err := taskCtx.TaskReader().Read(ctx) + if err != nil { + return nil, errors.Errorf(errors.BadTaskSpecification, "unable to fetch task specification [%v]", err.Error()) + } else if taskTemplate == nil { + return nil, errors.Errorf(errors.BadTaskSpecification, "nil task specification") + } + + daskJob := plugins.DaskJob{} + err = utils.UnmarshalStruct(taskTemplate.GetCustom(), &daskJob) + if err != nil { + return nil, errors.Wrapf(errors.BadTaskSpecification, err, "invalid TaskSpecification [%v], failed to unmarshal", taskTemplate.GetCustom()) + } + + podSpec, objectMeta, primaryContainerName, err := flytek8s.ToK8sPodSpec(ctx, taskCtx) + if err != nil { + return nil, err + } + nonInterruptibleTaskCtx := flytek8s.NewPluginTaskExecutionContext(taskCtx, flytek8s.WithInterruptible(false)) + nonInterruptiblePodSpec, _, _, err := flytek8s.ToK8sPodSpec(ctx, nonInterruptibleTaskCtx) + if err != nil { + return nil, err + } + + // Add labels and annotations to objectMeta as they're not added by ToK8sPodSpec + mergeMapInto(taskCtx.TaskExecutionMetadata().GetAnnotations(), objectMeta.Annotations) + mergeMapInto(taskCtx.TaskExecutionMetadata().GetLabels(), objectMeta.Labels) + + workerSpec, err := createWorkerSpec(*daskJob.Workers, podSpec, primaryContainerName, taskCtx.TaskExecutionMetadata()) + if err != nil { + return nil, err + } + + clusterName := taskCtx.TaskExecutionMetadata().GetTaskExecutionID().GetGeneratedName() + schedulerSpec, err := createSchedulerSpec(*daskJob.Scheduler, clusterName, nonInterruptiblePodSpec, primaryContainerName, taskCtx.TaskExecutionMetadata()) + if err != nil { + return nil, err + } + + jobSpec, err := createJobSpec(*workerSpec, *schedulerSpec, nonInterruptiblePodSpec, primaryContainerName, objectMeta) + if err != nil { + return nil, err + } + + job := &daskAPI.DaskJob{ + TypeMeta: metav1.TypeMeta{ + Kind: KindDaskJob, + APIVersion: daskAPI.SchemeGroupVersion.String(), + }, + ObjectMeta: *objectMeta, + Spec: *jobSpec, + } + return job, nil +} + +func createWorkerSpec(cluster plugins.DaskWorkerGroup, podSpec *v1.PodSpec, primaryContainerName string, + teMetadata pluginsCore.TaskExecutionMetadata) (*daskAPI.WorkerSpec, error) { + workerPodSpec := podSpec.DeepCopy() + primaryContainer, err := flytek8s.GetContainer(workerPodSpec, primaryContainerName) + if err != nil { + return nil, err + } + primaryContainer.Name = "dask-worker" + + // Set custom image if present + if cluster.GetImage() != "" { + primaryContainer.Image = cluster.GetImage() + } + + // Set custom resources + resources := &primaryContainer.Resources + clusterResources := cluster.GetResources() + if len(clusterResources.GetRequests()) >= 1 || len(clusterResources.GetLimits()) >= 1 { + resources, err = flytek8s.ToK8sResourceRequirements(cluster.GetResources()) + if err != nil { + return nil, err + } + + *resources = flytek8s.ApplyK8sResourceOverrides(teMetadata, resources) + } + if resources == nil { + resources = &v1.ResourceRequirements{} + } + primaryContainer.Resources = *resources + + // Set custom args + workerArgs := []string{ + "dask-worker", + "--name", + "$(DASK_WORKER_NAME)", + } + // If limits are set, append `--nthreads` and `--memory-limit` as per these docs: + // https://kubernetes.dask.org/en/latest/kubecluster.html?#best-practices + if resources.Limits != nil { + limits := resources.Limits + if limits.Cpu() != nil { + cpuCount := fmt.Sprintf("%v", limits.Cpu().Value()) + workerArgs = append(workerArgs, "--nthreads", cpuCount) + } + if limits.Memory() != nil { + memory := limits.Memory().String() + workerArgs = append(workerArgs, "--memory-limit", memory) + } + } + primaryContainer.Args = workerArgs + + err = replacePrimaryContainer(workerPodSpec, primaryContainerName, *primaryContainer) + if err != nil { + return nil, err + } + + // All workers are created as k8s deployment and must have a restart policy of Always + workerPodSpec.RestartPolicy = v1.RestartPolicyAlways + + return &daskAPI.WorkerSpec{ + Replicas: int(cluster.GetNumberOfWorkers()), + Spec: *workerPodSpec, + }, nil +} + +func createSchedulerSpec(scheduler plugins.DaskScheduler, clusterName string, podSpec *v1.PodSpec, primaryContainerName string, + teMetadata pluginsCore.TaskExecutionMetadata) (*daskAPI.SchedulerSpec, error) { + schedulerPodSpec := podSpec.DeepCopy() + primaryContainer, err := flytek8s.GetContainer(schedulerPodSpec, primaryContainerName) + if err != nil { + return nil, err + } + primaryContainer.Name = "scheduler" + + // Override image if applicable + if scheduler.GetImage() != "" { + primaryContainer.Image = scheduler.GetImage() + } + + // Override resources if applicable + resources := &primaryContainer.Resources + schedulerResources := scheduler.GetResources() + if len(schedulerResources.GetRequests()) >= 1 || len(schedulerResources.GetLimits()) >= 1 { + resources, err = flytek8s.ToK8sResourceRequirements(scheduler.GetResources()) + if err != nil { + return nil, err + } + + *resources = flytek8s.ApplyK8sResourceOverrides(teMetadata, resources) + } + primaryContainer.Resources = *resources + + // Override args + primaryContainer.Args = []string{"dask-scheduler"} + + // Add ports + primaryContainer.Ports = []v1.ContainerPort{ + { + Name: "tcp-comm", + ContainerPort: 8786, + Protocol: "TCP", + }, + { + Name: "dashboard", + ContainerPort: 8787, + Protocol: "TCP", + }, + } + + if primaryContainer.ReadinessProbe == nil { + primaryContainer.ReadinessProbe = &v1.Probe{ + ProbeHandler: v1.ProbeHandler{ + HTTPGet: &v1.HTTPGetAction{ + Port: intstr.FromString("dashboard"), + }, + }, + InitialDelaySeconds: 5, + PeriodSeconds: 5, + FailureThreshold: 30, + } + } + + schedulerPodSpec.RestartPolicy = v1.RestartPolicyAlways + + // Set primary container + err = replacePrimaryContainer(schedulerPodSpec, primaryContainerName, *primaryContainer) + if err != nil { + return nil, err + } + + return &daskAPI.SchedulerSpec{ + Spec: *schedulerPodSpec, + Service: v1.ServiceSpec{ + Type: v1.ServiceTypeNodePort, + Selector: map[string]string{ + "dask.org/cluster-name": clusterName, + "dask.org/component": "scheduler", + }, + Ports: []v1.ServicePort{ + { + Name: "tcp-comm", + Protocol: "TCP", + Port: 8786, + TargetPort: intstr.FromString("tcp-comm"), + }, + { + Name: "dashboard", + Protocol: "TCP", + Port: 8787, + TargetPort: intstr.FromString("dashboard"), + }, + }, + }, + }, nil +} + +func createJobSpec(workerSpec daskAPI.WorkerSpec, schedulerSpec daskAPI.SchedulerSpec, podSpec *v1.PodSpec, primaryContainerName string, objectMeta *metav1.ObjectMeta) (*daskAPI.DaskJobSpec, error) { + jobPodSpec := podSpec.DeepCopy() + jobPodSpec.RestartPolicy = v1.RestartPolicyNever + + primaryContainer, err := flytek8s.GetContainer(jobPodSpec, primaryContainerName) + if err != nil { + return nil, err + } + primaryContainer.Name = "job-runner" + + err = replacePrimaryContainer(jobPodSpec, primaryContainerName, *primaryContainer) + if err != nil { + return nil, err + } + + return &daskAPI.DaskJobSpec{ + Job: daskAPI.JobSpec{ + Spec: *jobPodSpec, + }, + Cluster: daskAPI.DaskCluster{ + ObjectMeta: *objectMeta, + Spec: daskAPI.DaskClusterSpec{ + Worker: workerSpec, + Scheduler: schedulerSpec, + }, + }, + }, nil +} + +func (p daskResourceHandler) GetTaskPhase(ctx context.Context, pluginContext k8s.PluginContext, r client.Object) (pluginsCore.PhaseInfo, error) { + logPlugin, err := logs.InitializeLogPlugins(&GetConfig().Logs) + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + job := r.(*daskAPI.DaskJob) + status := job.Status.JobStatus + occurredAt := time.Now() + + info := pluginsCore.TaskInfo{ + OccurredAt: &occurredAt, + } + + taskExecID := pluginContext.TaskExecutionMetadata().GetTaskExecutionID() + schedulerPodName, err := getDaskSchedulerPodName(ctx, job.Name, pluginContext) + if err != nil { + logger.Debug(ctx, "Failed to get dask scheduler pod name. Error: %v", err) + } + var enableVscode bool + if len(job.Spec.Cluster.Spec.Scheduler.Spec.Containers) > 0 { + enableVscode = flytek8s.IsVscodeEnabled(ctx, job.Spec.Cluster.Spec.Scheduler.Spec.Containers[0].Env) + } + input := tasklog.Input{ + Namespace: job.ObjectMeta.Namespace, + PodName: job.Status.JobRunnerPodName, + TaskExecutionID: taskExecID, + EnableVscode: enableVscode, + } + input.ExtraTemplateVars = append( + input.ExtraTemplateVars, + tasklog.TemplateVar{ + Regex: tasklog.MustCreateRegex("daskSchedulerName"), + Value: schedulerPodName, + }, + ) + + o, err := logPlugin.GetTaskLogs(input) + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + info.Logs = o.TaskLogs + info.LogContext = &core.LogContext{ + PrimaryPodName: job.Status.JobRunnerPodName, + Pods: []*core.PodLogContext{ + { + Namespace: job.ObjectMeta.Namespace, + PodName: job.Status.JobRunnerPodName, + PrimaryContainerName: defaultDaskJobRunnerPrimaryContainerName, + Containers: []*core.ContainerContext{ + {ContainerName: defaultDaskJobRunnerPrimaryContainerName}, + }, + }, + }, + } + + phaseInfo, err := flytek8s.DemystifyFailedOrPendingPod(ctx, pluginContext, info, job.ObjectMeta.Namespace, job.Status.JobRunnerPodName, defaultDaskJobRunnerPrimaryContainerName) + if err != nil { + logger.Errorf(ctx, "Failed to demystify pod status for dask job-runner. Error: %v", err) + } + if phaseInfo.Phase().IsFailure() { + // If the job-runner pod is in a failure state, we can fail fast without checking the DaskJob status. + return phaseInfo, nil + } + switch status { + case "": + phaseInfo = pluginsCore.PhaseInfoInitializing(occurredAt, pluginsCore.DefaultPhaseVersion, "unknown", &info) + case daskAPI.DaskJobCreated: + phaseInfo = pluginsCore.PhaseInfoInitializing(occurredAt, pluginsCore.DefaultPhaseVersion, "job created", &info) + case daskAPI.DaskJobClusterCreated: + phaseInfo = pluginsCore.PhaseInfoInitializing(occurredAt, pluginsCore.DefaultPhaseVersion, "cluster created", &info) + case daskAPI.DaskJobFailed: + reason := "Dask Job failed" + phaseInfo = pluginsCore.PhaseInfoRetryableFailure(errors.DownstreamSystemError, reason, &info) + case daskAPI.DaskJobSuccessful: + phaseInfo = pluginsCore.PhaseInfoSuccess(&info) + default: + phaseInfo = pluginsCore.PhaseInfoRunning(pluginsCore.DefaultPhaseVersion, &info) + } + + ready, err := isDaskSchedulerReady(ctx, job.Name, pluginContext) + if err != nil { + logger.Warnf(ctx, "Failed to determine Dask dashboard readiness. Error: %v", err) + } else { + for _, tl := range info.Logs { + if tl != nil && tl.LinkType == core.TaskLog_DASHBOARD { + tl.Ready = ready + if !ready || phaseInfo.Phase() != pluginsCore.PhaseRunning { + phaseInfo.WithReason("Dask dashboard is not ready") + } else { + phaseInfo.WithReason("Dask dashboard is ready") + } + } else if tl != nil && tl.LinkType == core.TaskLog_IDE { + tl.Ready = ready + if !ready || phaseInfo.Phase() != pluginsCore.PhaseRunning { + phaseInfo.WithReason("Vscode server is not ready") + } else { + phaseInfo.WithReason("Vscode server is ready") + } + } + } + } + + phaseVersionUpdateErr := k8s.MaybeUpdatePhaseVersionFromPluginContext(&phaseInfo, &pluginContext) + if phaseVersionUpdateErr != nil { + return phaseInfo, phaseVersionUpdateErr + } + return phaseInfo, nil +} + +func getDaskSchedulerPodName(ctx context.Context, daskJobName string, pluginContext k8s.PluginContext) (string, error) { + podList := &v1.PodList{} + err := pluginContext.K8sReader().List(ctx, podList) + if err != nil { + return "", fmt.Errorf("failed to list dask execution pods. Error: %w", err) + } + pods := lo.Filter(podList.Items, func(pod v1.Pod, _ int) bool { + return strings.HasPrefix(pod.Name, daskJobName) && strings.Contains(pod.Name, "scheduler") && flytek8s.GetPrimaryContainerName(&pod) == "scheduler" + }) + if len(pods) == 0 { + return "", fmt.Errorf("no dask scheduler pod found for dask job [%v]", daskJobName) + } + return pods[0].Name, nil +} + +func isDaskSchedulerReady(ctx context.Context, daskJobName string, pluginContext k8s.PluginContext) (bool, error) { + podList := &v1.PodList{} + err := pluginContext.K8sReader().List(ctx, podList) + if err != nil { + return false, fmt.Errorf("failed to list dask execution pods. Error: %w", err) + } + pods := lo.Filter(podList.Items, func(p v1.Pod, _ int) bool { + return strings.HasPrefix(p.Name, daskJobName) && strings.Contains(p.Name, "scheduler") + }) + if len(pods) == 0 { + return false, nil + } else if len(pods) == 1 { + return pod.IsPodReady(&pods[0]), nil + } + + // More than one dask scheduler pod. Should not happen. + logger.Debug(ctx, "Cannot determine dask scheduler readiness as more than one dask scheduler pod found") + return false, fmt.Errorf("more than one dask scheduler pod found for dask job [%v]", daskJobName) +} + +func (daskResourceHandler) GetProperties() k8s.PluginProperties { + return k8s.PluginProperties{} +} + +// IsTerminal returns true if the DaskJob is in a terminal state (Successful or Failed) +func (daskResourceHandler) IsTerminal(_ context.Context, resource client.Object) (bool, error) { + job, ok := resource.(*daskAPI.DaskJob) + if !ok { + return false, fmt.Errorf("unexpected resource type: expected *DaskJob, got %T", resource) + } + status := job.Status.JobStatus + return status == daskAPI.DaskJobSuccessful || status == daskAPI.DaskJobFailed, nil +} + +// GetCompletionTime returns the end time of the DaskJob +func (daskResourceHandler) GetCompletionTime(resource client.Object) (time.Time, error) { + job, ok := resource.(*daskAPI.DaskJob) + if !ok { + return time.Time{}, fmt.Errorf("unexpected resource type: expected *DaskJob, got %T", resource) + } + + if !job.Status.EndTime.IsZero() { + return job.Status.EndTime.Time, nil + } + + // Fallback to start time or creation time + if !job.Status.StartTime.IsZero() { + return job.Status.StartTime.Time, nil + } + + return job.CreationTimestamp.Time, nil +} + +func init() { + if err := daskAPI.AddToScheme(scheme.Scheme); err != nil { + panic(err) + } + + pluginmachinery.PluginRegistry().RegisterK8sPlugin( + k8s.PluginEntry{ + ID: daskTaskType, + RegisteredTaskTypes: []pluginsCore.TaskType{daskTaskType}, + ResourceToWatch: &daskAPI.DaskJob{}, + Plugin: daskResourceHandler{}, + IsDefault: false, + }) +} diff --git a/flyteplugins/go/tasks/plugins/k8s/dask/dask_test.go b/flyteplugins/go/tasks/plugins/k8s/dask/dask_test.go new file mode 100644 index 0000000000..1e7b098daa --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/dask/dask_test.go @@ -0,0 +1,1201 @@ +package dask + +import ( + "context" + "reflect" + "testing" + "time" + + daskAPI "github.com/dask/dask-kubernetes/v2023/dask_kubernetes/operator/go_client/pkg/apis/kubernetes.dask.org/v1" + "github.com/golang/protobuf/proto" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "google.golang.org/protobuf/types/known/structpb" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/util/intstr" + "sigs.k8s.io/controller-runtime/pkg/client/fake" + + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + pluginIOMocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + k8smocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" + stdlibUtils "github.com/flyteorg/flyte/v2/flytestdlib/utils" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" +) + +const ( + defaultTestImage = "image://" + testNWorkers = 10 + testTaskID = "some-acceptable-name" + podTemplateName = "dask-dummy-pod-template-name" + defaultServiceAccountName = "default-service-account" + defaultNamespace = "default-namespace" + podTempaltePriorityClassName = "pod-template-priority-class-name" +) + +var ( + testEnvVars = []v1.EnvVar{ + {Name: "Env_Var", Value: "Env_Val"}, + } + testArgs = []string{ + "execute-dask-task", + } + testAnnotations = map[string]string{"annotation-1": "val1"} + testLabels = map[string]string{"label-1": "val1"} + testPlatformResources = v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("4"), + v1.ResourceMemory: resource.MustParse("10G"), + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("10"), + v1.ResourceMemory: resource.MustParse("24G"), + }, + } + defaultResources = v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("2"), + v1.ResourceMemory: resource.MustParse("8G"), + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("8"), + v1.ResourceMemory: resource.MustParse("17G"), + }, + } + podTemplate = &v1.PodTemplate{ + ObjectMeta: metav1.ObjectMeta{ + Name: podTemplateName, + }, + Template: v1.PodTemplateSpec{ + Spec: v1.PodSpec{ + PriorityClassName: podTempaltePriorityClassName, + }, + }, + } +) + +func dummyDaskJob(status daskAPI.JobStatus) *daskAPI.DaskJob { + return &daskAPI.DaskJob{ + ObjectMeta: metav1.ObjectMeta{ + Name: "dask-job-name", + Namespace: defaultNamespace, + }, + Spec: daskAPI.DaskJobSpec{ + Cluster: daskAPI.DaskCluster{ + Spec: daskAPI.DaskClusterSpec{ + Scheduler: daskAPI.SchedulerSpec{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "scheduler", + Image: defaultTestImage, + Env: testEnvVars, + }, + }, + }, + }, + }, + }, + }, + Status: daskAPI.DaskJobStatus{ + ClusterName: "dask-cluster-name", + EndTime: metav1.Time{Time: time.Now()}, + JobRunnerPodName: "job-runner-pod-name", + JobStatus: status, + StartTime: metav1.Time{Time: time.Now()}, + }, + } +} + +func dummpyDaskCustomObj(customImage string, resources *core.Resources) *plugins.DaskJob { + scheduler := plugins.DaskScheduler{ + Image: customImage, + Resources: resources, + } + + workers := plugins.DaskWorkerGroup{ + NumberOfWorkers: 10, + Image: customImage, + Resources: resources, + } + + daskJob := plugins.DaskJob{ + Scheduler: &scheduler, + Workers: &workers, + } + return &daskJob +} + +func dummyDaskTaskTemplate(customImage string, resources *core.Resources, podTemplateName string) *core.TaskTemplate { + // In a real usecase, resources will always be filled, but might be empty + if resources == nil { + resources = &core.Resources{ + Requests: []*core.Resources_ResourceEntry{}, + Limits: []*core.Resources_ResourceEntry{}, + } + } + + daskJob := dummpyDaskCustomObj(customImage, resources) + daskJobJSON, err := utils.MarshalToString(daskJob) + if err != nil { + panic(err) + } + + structObj := structpb.Struct{} + err = stdlibUtils.UnmarshalStringToPb(daskJobJSON, &structObj) + if err != nil { + panic(err) + } + var envVars []*core.KeyValuePair + for _, envVar := range testEnvVars { + envVars = append(envVars, &core.KeyValuePair{Key: envVar.Name, Value: envVar.Value}) + } + metadata := &core.TaskMetadata{ + PodTemplateName: podTemplateName, + } + return &core.TaskTemplate{ + Id: &core.Identifier{Name: "test-build-resource"}, + Type: daskTaskType, + Metadata: metadata, + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Image: defaultTestImage, + Args: testArgs, + Env: envVars, + }, + }, + Custom: &structObj, + } +} + +func dummyDaskTaskContext(taskTemplate *core.TaskTemplate, resources *v1.ResourceRequirements, extendedResources *core.ExtendedResources, isInterruptible bool) pluginsCore.TaskExecutionContext { + taskCtx := &mocks.TaskExecutionContext{} + + inputReader := &pluginIOMocks.InputReader{} + inputReader.EXPECT().GetInputPrefixPath().Return("/input/prefix") + inputReader.EXPECT().GetInputPath().Return("/input") + inputReader.EXPECT().Get(mock.Anything).Return(&core.LiteralMap{}, nil) + taskCtx.EXPECT().InputReader().Return(inputReader) + + outputReader := &pluginIOMocks.OutputWriter{} + outputReader.EXPECT().GetOutputPath().Return("/data/outputs.pb") + outputReader.EXPECT().GetOutputPrefixPath().Return("/data/") + outputReader.EXPECT().GetRawOutputPrefix().Return("") + outputReader.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + outputReader.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + taskCtx.EXPECT().OutputWriter().Return(outputReader) + + taskReader := &mocks.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(taskTemplate, nil) + taskCtx.EXPECT().TaskReader().Return(taskReader) + + tID := &mocks.TaskExecutionID{} + tID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my_name", + Project: "my_project", + Domain: "my_domain", + }, + }, + }) + tID.EXPECT().GetGeneratedName().Return(testTaskID) + tID.EXPECT().GetUniqueNodeID().Return("an-unique-id") + + taskExecutionMetadata := &mocks.TaskExecutionMetadata{} + taskExecutionMetadata.EXPECT().GetTaskExecutionID().Return(tID) + taskExecutionMetadata.EXPECT().GetAnnotations().Return(testAnnotations) + taskExecutionMetadata.EXPECT().GetLabels().Return(testLabels) + taskExecutionMetadata.EXPECT().GetPlatformResources().Return(&testPlatformResources) + taskExecutionMetadata.EXPECT().GetMaxAttempts().Return(uint32(1)) + taskExecutionMetadata.EXPECT().IsInterruptible().Return(isInterruptible) + taskExecutionMetadata.EXPECT().GetEnvironmentVariables().Return(nil) + taskExecutionMetadata.EXPECT().GetK8sServiceAccount().Return(defaultServiceAccountName) + taskExecutionMetadata.EXPECT().GetNamespace().Return(defaultNamespace) + taskExecutionMetadata.EXPECT().GetConsoleURL().Return("") + overrides := &mocks.TaskOverrides{} + overrides.EXPECT().GetResources().Return(resources) + overrides.EXPECT().GetExtendedResources().Return(extendedResources) + overrides.EXPECT().GetPodTemplate().Return(nil) + overrides.EXPECT().GetContainerImage().Return("") + taskExecutionMetadata.EXPECT().GetOverrides().Return(overrides) + taskCtx.EXPECT().TaskExecutionMetadata().Return(taskExecutionMetadata) + pluginStateReaderMock := mocks.PluginStateReader{} + pluginStateReaderMock.EXPECT().Get(mock.AnythingOfType(reflect.TypeOf(&k8s.PluginState{}).String())).RunAndReturn( + func(v interface{}) (uint8, error) { + *(v.(*k8s.PluginState)) = k8s.PluginState{} + return 0, nil + }) + + taskCtx.EXPECT().PluginStateReader().Return(&pluginStateReaderMock) + return taskCtx +} + +func dummyDaskPluginContext(taskTemplate *core.TaskTemplate, resources *v1.ResourceRequirements, pluginState k8s.PluginState) *k8smocks.PluginContext { + return dummyDaskPluginContextWithPods(taskTemplate, resources, pluginState) +} + +func dummyDaskPluginContextWithPods(taskTemplate *core.TaskTemplate, resources *v1.ResourceRequirements, pluginState k8s.PluginState, pods ...runtime.Object) *k8smocks.PluginContext { + pCtx := &k8smocks.PluginContext{} + + inputReader := &pluginIOMocks.InputReader{} + inputReader.EXPECT().GetInputPrefixPath().Return("/input/prefix") + inputReader.EXPECT().GetInputPath().Return("/input") + inputReader.EXPECT().Get(mock.Anything).Return(&core.LiteralMap{}, nil) + pCtx.EXPECT().InputReader().Return(inputReader) + + outputReader := &pluginIOMocks.OutputWriter{} + outputReader.EXPECT().GetOutputPath().Return("/data/outputs.pb") + outputReader.EXPECT().GetOutputPrefixPath().Return("/data/") + outputReader.EXPECT().GetRawOutputPrefix().Return("") + outputReader.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + outputReader.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + pCtx.EXPECT().OutputWriter().Return(outputReader) + + taskReader := &mocks.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(taskTemplate, nil) + pCtx.EXPECT().TaskReader().Return(taskReader) + + tID := &mocks.TaskExecutionID{} + tID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my_name", + Project: "my_project", + Domain: "my_domain", + }, + }, + }) + tID.EXPECT().GetGeneratedName().Return(testTaskID) + tID.EXPECT().GetUniqueNodeID().Return("an-unique-id") + + taskExecutionMetadata := &mocks.TaskExecutionMetadata{} + taskExecutionMetadata.EXPECT().GetTaskExecutionID().Return(tID) + taskExecutionMetadata.EXPECT().GetAnnotations().Return(testAnnotations) + taskExecutionMetadata.EXPECT().GetLabels().Return(testLabels) + taskExecutionMetadata.EXPECT().GetPlatformResources().Return(&testPlatformResources) + taskExecutionMetadata.EXPECT().GetMaxAttempts().Return(uint32(1)) + taskExecutionMetadata.EXPECT().IsInterruptible().Return(false) + taskExecutionMetadata.EXPECT().GetEnvironmentVariables().Return(nil) + taskExecutionMetadata.EXPECT().GetK8sServiceAccount().Return(defaultServiceAccountName) + taskExecutionMetadata.EXPECT().GetNamespace().Return(defaultNamespace) + taskExecutionMetadata.EXPECT().GetConsoleURL().Return("") + overrides := &mocks.TaskOverrides{} + overrides.EXPECT().GetResources().Return(resources) + overrides.EXPECT().GetExtendedResources().Return(nil) + overrides.EXPECT().GetContainerImage().Return("") + taskExecutionMetadata.EXPECT().GetOverrides().Return(overrides) + pCtx.EXPECT().TaskExecutionMetadata().Return(taskExecutionMetadata) + + pluginStateReaderMock := mocks.PluginStateReader{} + pluginStateReaderMock.EXPECT().Get(mock.AnythingOfType(reflect.TypeOf(&pluginState).String())).RunAndReturn( + func(v interface{}) (uint8, error) { + *(v.(*k8s.PluginState)) = pluginState + return 0, nil + }) + + // Add K8sReader mock + reader := fake.NewFakeClient(pods...) + pCtx.EXPECT().K8sReader().Return(reader) + + pCtx.EXPECT().PluginStateReader().Return(&pluginStateReaderMock) + return pCtx +} + +func TestBuildResourceDaskHappyPath(t *testing.T) { + daskResourceHandler := daskResourceHandler{} + + taskTemplate := dummyDaskTaskTemplate("", nil, "") + taskContext := dummyDaskTaskContext(taskTemplate, &defaultResources, nil, false) + r, err := daskResourceHandler.BuildResource(context.TODO(), taskContext) + assert.Nil(t, err) + assert.NotNil(t, r) + daskJob, ok := r.(*daskAPI.DaskJob) + assert.True(t, ok) + + var defaultTolerations []v1.Toleration + defaultNodeSelector := map[string]string{} + defaultAffinity := &v1.Affinity{ + NodeAffinity: nil, + PodAffinity: nil, + PodAntiAffinity: nil, + } + + // Job + jobSpec := daskJob.Spec.Job.Spec + assert.Equal(t, testAnnotations, daskJob.ObjectMeta.GetAnnotations()) + assert.Equal(t, testLabels, daskJob.ObjectMeta.GetLabels()) + assert.Equal(t, v1.RestartPolicyNever, jobSpec.RestartPolicy) + assert.Equal(t, "job-runner", jobSpec.Containers[0].Name) + assert.Equal(t, defaultTestImage, jobSpec.Containers[0].Image) + assert.Equal(t, testArgs, jobSpec.Containers[0].Args) + assert.Equal(t, defaultResources, jobSpec.Containers[0].Resources) + assert.Equal(t, defaultTolerations, jobSpec.Tolerations) + assert.Equal(t, defaultNodeSelector, jobSpec.NodeSelector) + assert.Equal(t, defaultAffinity, jobSpec.Affinity) + + // Flyte adds more environment variables to the runner + assert.Contains(t, jobSpec.Containers[0].Env, testEnvVars[0]) + + // Cluster + assert.Equal(t, testAnnotations, daskJob.Spec.Cluster.ObjectMeta.GetAnnotations()) + assert.Equal(t, testLabels, daskJob.Spec.Cluster.ObjectMeta.GetLabels()) + + // Scheduler + schedulerSpec := daskJob.Spec.Cluster.Spec.Scheduler.Spec + expectedPorts := []v1.ContainerPort{ + { + Name: "tcp-comm", + ContainerPort: 8786, + Protocol: "TCP", + }, + { + Name: "dashboard", + ContainerPort: 8787, + Protocol: "TCP", + }, + } + assert.Equal(t, v1.RestartPolicyAlways, schedulerSpec.RestartPolicy) + assert.Equal(t, defaultTestImage, schedulerSpec.Containers[0].Image) + assert.Equal(t, defaultResources, schedulerSpec.Containers[0].Resources) + assert.Equal(t, []string{"dask-scheduler"}, schedulerSpec.Containers[0].Args) + assert.Equal(t, expectedPorts, schedulerSpec.Containers[0].Ports) + // Flyte adds more environment variables to the scheduler + assert.Contains(t, schedulerSpec.Containers[0].Env, testEnvVars[0]) + assert.Equal(t, defaultTolerations, schedulerSpec.Tolerations) + assert.Equal(t, defaultNodeSelector, schedulerSpec.NodeSelector) + assert.Equal(t, defaultAffinity, schedulerSpec.Affinity) + + schedulerServiceSpec := daskJob.Spec.Cluster.Spec.Scheduler.Service + expectedSelector := map[string]string{ + "dask.org/cluster-name": testTaskID, + "dask.org/component": "scheduler", + } + expectedSerivcePorts := []v1.ServicePort{ + { + Name: "tcp-comm", + Protocol: "TCP", + Port: 8786, + TargetPort: intstr.FromString("tcp-comm"), + }, + { + Name: "dashboard", + Protocol: "TCP", + Port: 8787, + TargetPort: intstr.FromString("dashboard"), + }, + } + assert.Equal(t, v1.ServiceTypeNodePort, schedulerServiceSpec.Type) + assert.Equal(t, expectedSelector, schedulerServiceSpec.Selector) + assert.Equal(t, expectedSerivcePorts, schedulerServiceSpec.Ports) + + // Default Workers + workerSpec := daskJob.Spec.Cluster.Spec.Worker.Spec + assert.Equal(t, testNWorkers, daskJob.Spec.Cluster.Spec.Worker.Replicas) + assert.Equal(t, "dask-worker", workerSpec.Containers[0].Name) + assert.Equal(t, defaultTestImage, workerSpec.Containers[0].Image) + assert.Equal(t, defaultResources, workerSpec.Containers[0].Resources) + // Flyte adds more environment variables to the worker + assert.Contains(t, workerSpec.Containers[0].Env, testEnvVars[0]) + assert.Equal(t, defaultTolerations, workerSpec.Tolerations) + assert.Equal(t, defaultNodeSelector, workerSpec.NodeSelector) + assert.Equal(t, defaultAffinity, workerSpec.Affinity) + assert.Equal(t, []string{ + "dask-worker", + "--name", + "$(DASK_WORKER_NAME)", + "--nthreads", + "8", + "--memory-limit", + "17G", + }, workerSpec.Containers[0].Args) + assert.Equal(t, workerSpec.RestartPolicy, v1.RestartPolicyAlways) +} + +func TestBuildResourceDaskCustomImages(t *testing.T) { + customImage := "customImage" + + daskResourceHandler := daskResourceHandler{} + taskTemplate := dummyDaskTaskTemplate(customImage, nil, "") + taskContext := dummyDaskTaskContext(taskTemplate, &v1.ResourceRequirements{}, nil, false) + r, err := daskResourceHandler.BuildResource(context.TODO(), taskContext) + assert.Nil(t, err) + assert.NotNil(t, r) + daskJob, ok := r.(*daskAPI.DaskJob) + assert.True(t, ok) + + // Job + jobSpec := daskJob.Spec.Job.Spec + assert.Equal(t, defaultTestImage, jobSpec.Containers[0].Image) + + // Scheduler + schedulerSpec := daskJob.Spec.Cluster.Spec.Scheduler.Spec + assert.Equal(t, customImage, schedulerSpec.Containers[0].Image) + + // Default Workers + workerSpec := daskJob.Spec.Cluster.Spec.Worker.Spec + assert.Equal(t, customImage, workerSpec.Containers[0].Image) +} + +func TestBuildResourceDaskDefaultResoureRequirements(t *testing.T) { + flyteWorkflowResources := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1"), + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("2"), + v1.ResourceMemory: resource.MustParse("2G"), + }, + } + + daskResourceHandler := daskResourceHandler{} + taskTemplate := dummyDaskTaskTemplate("", nil, "") + taskContext := dummyDaskTaskContext(taskTemplate, &flyteWorkflowResources, nil, false) + r, err := daskResourceHandler.BuildResource(context.TODO(), taskContext) + assert.Nil(t, err) + assert.NotNil(t, r) + daskJob, ok := r.(*daskAPI.DaskJob) + assert.True(t, ok) + + expectedResources := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1"), + v1.ResourceMemory: resource.MustParse("2G"), + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("2"), + v1.ResourceMemory: resource.MustParse("2G"), + }, + } + + // Job + jobSpec := daskJob.Spec.Job.Spec + assert.Equal(t, expectedResources, jobSpec.Containers[0].Resources) + + // Scheduler + schedulerSpec := daskJob.Spec.Cluster.Spec.Scheduler.Spec + assert.Equal(t, expectedResources, schedulerSpec.Containers[0].Resources) + + // Default Workers + workerSpec := daskJob.Spec.Cluster.Spec.Worker.Spec + assert.Equal(t, expectedResources, workerSpec.Containers[0].Resources) + assert.Contains(t, workerSpec.Containers[0].Args, "--nthreads") + assert.Contains(t, workerSpec.Containers[0].Args, "2") + assert.Contains(t, workerSpec.Containers[0].Args, "--memory-limit") + assert.Contains(t, workerSpec.Containers[0].Args, "2G") +} + +func TestBuildResourceDaskAdjustResoureRequirements(t *testing.T) { + flyteWorkflowResources := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1"), + v1.ResourceMemory: resource.MustParse("2G"), + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("16"), // Higher than platform limits + // Unset memory should be defaulted to from the request + }, + } + + daskResourceHandler := daskResourceHandler{} + taskTemplate := dummyDaskTaskTemplate("", nil, "") + taskContext := dummyDaskTaskContext(taskTemplate, &flyteWorkflowResources, nil, false) + r, err := daskResourceHandler.BuildResource(context.TODO(), taskContext) + assert.Nil(t, err) + assert.NotNil(t, r) + daskJob, ok := r.(*daskAPI.DaskJob) + assert.True(t, ok) + + expectedResources := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1"), + v1.ResourceMemory: resource.MustParse("2G"), + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: testPlatformResources.Limits[v1.ResourceCPU], + v1.ResourceMemory: flyteWorkflowResources.Requests[v1.ResourceMemory], + }, + } + + // Job + jobSpec := daskJob.Spec.Job.Spec + assert.Equal(t, expectedResources, jobSpec.Containers[0].Resources) + + // Scheduler + schedulerSpec := daskJob.Spec.Cluster.Spec.Scheduler.Spec + assert.Equal(t, expectedResources, schedulerSpec.Containers[0].Resources) + + // Default Workers + workerSpec := daskJob.Spec.Cluster.Spec.Worker.Spec + assert.Equal(t, expectedResources, workerSpec.Containers[0].Resources) + assert.Contains(t, workerSpec.Containers[0].Args, "--nthreads") + assert.Contains(t, workerSpec.Containers[0].Args, "10") // from the adjusted, platform limits + assert.Contains(t, workerSpec.Containers[0].Args, "--memory-limit") + assert.Contains(t, workerSpec.Containers[0].Args, "2G") +} + +func TestBuildResourcesDaskCustomResoureRequirements(t *testing.T) { + protobufResources := core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + { + Name: core.Resources_CPU, + Value: "5", + }, + }, + Limits: []*core.Resources_ResourceEntry{ + { + Name: core.Resources_CPU, + Value: "10", + }, + { + Name: core.Resources_MEMORY, + Value: "15G", + }, + }, + } + expectedPbResources := proto.Clone(&protobufResources).(*core.Resources) + // We expect the unset memory request to come from the set memory limit + expectedPbResources.Requests = append(expectedPbResources.Requests, &core.Resources_ResourceEntry{ + Name: core.Resources_MEMORY, + Value: "15G", + }) + expectedResources, _ := flytek8s.ToK8sResourceRequirements(expectedPbResources) + + flyteWorkflowResources := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1"), + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("2"), + v1.ResourceMemory: resource.MustParse("2G"), + }, + } + + daskResourceHandler := daskResourceHandler{} + taskTemplate := dummyDaskTaskTemplate("", &protobufResources, "") + taskContext := dummyDaskTaskContext(taskTemplate, &flyteWorkflowResources, nil, false) + r, err := daskResourceHandler.BuildResource(context.TODO(), taskContext) + assert.Nil(t, err) + assert.NotNil(t, r) + daskJob, ok := r.(*daskAPI.DaskJob) + assert.True(t, ok) + + expectedJobResources := v1.ResourceRequirements{ + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1"), + v1.ResourceMemory: resource.MustParse("2G"), + }, + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("2"), + v1.ResourceMemory: resource.MustParse("2G"), + }, + } + + // Job + jobSpec := daskJob.Spec.Job.Spec + assert.Equal(t, expectedJobResources, jobSpec.Containers[0].Resources) + + // Scheduler + schedulerSpec := daskJob.Spec.Cluster.Spec.Scheduler.Spec + assert.Equal(t, *expectedResources, schedulerSpec.Containers[0].Resources) + + // Default Workers + workerSpec := daskJob.Spec.Cluster.Spec.Worker.Spec + assert.Equal(t, *expectedResources, workerSpec.Containers[0].Resources) + assert.Contains(t, workerSpec.Containers[0].Args, "--nthreads") + assert.Contains(t, workerSpec.Containers[0].Args, "10") + assert.Contains(t, workerSpec.Containers[0].Args, "--memory-limit") + assert.Contains(t, workerSpec.Containers[0].Args, "15G") +} + +func TestBuildResourceDaskInterruptible(t *testing.T) { + defaultNodeSelector := map[string]string{} + var defaultAffinity v1.Affinity + var defaultTolerations []v1.Toleration + + interruptibleNodeSelector := map[string]string{ + "x/interruptible": "true", + } + interruptibleNodeSelectorRequirement := &v1.NodeSelectorRequirement{ + Key: "x/interruptible", + Operator: v1.NodeSelectorOpIn, + Values: []string{"true"}, + } + interruptibleTolerations := []v1.Toleration{ + { + Key: "x/flyte", + Value: "interruptible", + Operator: "Equal", + Effect: "NoSchedule", + }, + } + + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + InterruptibleNodeSelector: interruptibleNodeSelector, + InterruptibleNodeSelectorRequirement: interruptibleNodeSelectorRequirement, + InterruptibleTolerations: interruptibleTolerations, + })) + + daskResourceHandler := daskResourceHandler{} + + taskTemplate := dummyDaskTaskTemplate("", nil, "") + taskContext := dummyDaskTaskContext(taskTemplate, &defaultResources, nil, true) + r, err := daskResourceHandler.BuildResource(context.TODO(), taskContext) + assert.Nil(t, err) + assert.NotNil(t, r) + daskJob, ok := r.(*daskAPI.DaskJob) + assert.True(t, ok) + + // Job pod - should not be interruptible + jobSpec := daskJob.Spec.Job.Spec + assert.Equal(t, defaultTolerations, jobSpec.Tolerations) + assert.Equal(t, defaultNodeSelector, jobSpec.NodeSelector) + assert.Equal(t, &defaultAffinity, jobSpec.Affinity) + + // Scheduler - should not be interruptible + schedulerSpec := daskJob.Spec.Cluster.Spec.Scheduler.Spec + assert.Equal(t, defaultTolerations, schedulerSpec.Tolerations) + assert.Equal(t, defaultNodeSelector, schedulerSpec.NodeSelector) + assert.Equal(t, &defaultAffinity, schedulerSpec.Affinity) + + // Default Workers - Should be interruptible + workerSpec := daskJob.Spec.Cluster.Spec.Worker.Spec + assert.Equal(t, interruptibleTolerations, workerSpec.Tolerations) + assert.Equal(t, interruptibleNodeSelector, workerSpec.NodeSelector) + assert.Equal( + t, + workerSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms[0].MatchExpressions[0], + *interruptibleNodeSelectorRequirement, + ) +} + +func TestBuildResouceDaskUsePodTemplate(t *testing.T) { + flytek8s.DefaultPodTemplateStore.Store(podTemplate) + daskResourceHandler := daskResourceHandler{} + taskTemplate := dummyDaskTaskTemplate("", nil, podTemplateName) + taskContext := dummyDaskTaskContext(taskTemplate, &defaultResources, nil, false) + r, err := daskResourceHandler.BuildResource(context.TODO(), taskContext) + assert.Nil(t, err) + assert.NotNil(t, r) + daskJob, ok := r.(*daskAPI.DaskJob) + assert.True(t, ok) + + assert.Equal(t, podTempaltePriorityClassName, daskJob.Spec.Job.Spec.PriorityClassName) + assert.Equal(t, podTempaltePriorityClassName, daskJob.Spec.Cluster.Spec.Scheduler.Spec.PriorityClassName) + assert.Equal(t, podTempaltePriorityClassName, daskJob.Spec.Cluster.Spec.Worker.Spec.PriorityClassName) + + // Cleanup + flytek8s.DefaultPodTemplateStore.Delete(podTemplate) +} + +func TestBuildResourceDaskExtendedResources(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuDeviceNodeLabel: "gpu-node-label", + GpuPartitionSizeNodeLabel: "gpu-partition-size", + GpuResourceName: flytek8s.ResourceNvidiaGPU, + AddTolerationsForExtendedResources: []string{"nvidia.com/gpu"}, + })) + + fixtures := []struct { + name string + resources *v1.ResourceRequirements + extendedResourcesBase *core.ExtendedResources + extendedResourcesOverride *core.ExtendedResources + expectedNsr []v1.NodeSelectorTerm + expectedTol []v1.Toleration + }{ + { + "without overrides", + &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-t4", + }, + }, + nil, + []v1.NodeSelectorTerm{ + { + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "gpu-node-label", + Operator: v1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-t4"}, + }, + }, + }, + }, + []v1.Toleration{ + { + Key: "gpu-node-label", + Value: "nvidia-tesla-t4", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + { + Key: "nvidia.com/gpu", + Operator: v1.TolerationOpExists, + Effect: v1.TaintEffectNoSchedule, + }, + }, + }, + { + "with overrides", + &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-t4", + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-a100", + PartitionSizeValue: &core.GPUAccelerator_PartitionSize{ + PartitionSize: "1g.5gb", + }, + }, + }, + []v1.NodeSelectorTerm{ + { + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "gpu-node-label", + Operator: v1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-a100"}, + }, + v1.NodeSelectorRequirement{ + Key: "gpu-partition-size", + Operator: v1.NodeSelectorOpIn, + Values: []string{"1g.5gb"}, + }, + }, + }, + }, + []v1.Toleration{ + { + Key: "gpu-node-label", + Value: "nvidia-tesla-a100", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + { + Key: "gpu-partition-size", + Value: "1g.5gb", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + { + Key: "nvidia.com/gpu", + Operator: v1.TolerationOpExists, + Effect: v1.TaintEffectNoSchedule, + }, + }, + }, + } + + for _, f := range fixtures { + t.Run(f.name, func(t *testing.T) { + taskTemplate := dummyDaskTaskTemplate("", nil, "") + taskTemplate.ExtendedResources = f.extendedResourcesBase + taskContext := dummyDaskTaskContext(taskTemplate, f.resources, f.extendedResourcesOverride, false) + daskResourceHandler := daskResourceHandler{} + r, err := daskResourceHandler.BuildResource(context.TODO(), taskContext) + assert.Nil(t, err) + assert.NotNil(t, r) + daskJob, ok := r.(*daskAPI.DaskJob) + assert.True(t, ok) + + // Job pod + jobSpec := daskJob.Spec.Job.Spec + assert.EqualValues( + t, + f.expectedNsr, + jobSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + f.expectedTol, + jobSpec.Tolerations, + ) + + // Scheduler + schedulerSpec := daskJob.Spec.Cluster.Spec.Scheduler.Spec + assert.EqualValues( + t, + f.expectedNsr, + schedulerSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + f.expectedTol, + schedulerSpec.Tolerations, + ) + + // Default Workers + workerSpec := daskJob.Spec.Cluster.Spec.Worker.Spec + assert.EqualValues( + t, + f.expectedNsr, + workerSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + f.expectedTol, + workerSpec.Tolerations, + ) + }) + } +} + +func TestGetPropertiesDask(t *testing.T) { + daskResourceHandler := daskResourceHandler{} + expected := k8s.PluginProperties{} + assert.Equal(t, expected, daskResourceHandler.GetProperties()) +} + +func TestBuildIdentityResourceDask(t *testing.T) { + daskResourceHandler := daskResourceHandler{} + expected := &daskAPI.DaskJob{ + TypeMeta: metav1.TypeMeta{ + Kind: KindDaskJob, + APIVersion: daskAPI.SchemeGroupVersion.String(), + }, + } + + taskTemplate := dummyDaskTaskTemplate("", nil, "") + taskContext := dummyDaskTaskContext(taskTemplate, &v1.ResourceRequirements{}, nil, false) + identityResources, err := daskResourceHandler.BuildIdentityResource(context.TODO(), taskContext.TaskExecutionMetadata()) + if err != nil { + panic(err) + } + assert.Equal(t, expected, identityResources) +} + +func TestGetTaskPhaseDask(t *testing.T) { + daskResourceHandler := daskResourceHandler{} + ctx := context.TODO() + + taskTemplate := dummyDaskTaskTemplate("", nil, "") + pluginContext := dummyDaskPluginContext(taskTemplate, &v1.ResourceRequirements{}, k8s.PluginState{}) + expectedLogCtx := &core.LogContext{ + PrimaryPodName: "job-runner-pod-name", + Pods: []*core.PodLogContext{ + { + Namespace: defaultNamespace, + PodName: "job-runner-pod-name", + PrimaryContainerName: "job-runner", + Containers: []*core.ContainerContext{ + { + ContainerName: "job-runner", + }, + }, + }, + }, + } + + taskPhase, err := daskResourceHandler.GetTaskPhase(ctx, pluginContext, dummyDaskJob("")) + assert.NoError(t, err) + assert.Equal(t, taskPhase.Phase(), pluginsCore.PhaseInitializing) + assert.NotNil(t, taskPhase.Info()) + assert.NotNil(t, taskPhase.Info().Logs) + assert.NotNil(t, taskPhase.Info().LogContext) + assert.Nil(t, err) + + taskPhase, err = daskResourceHandler.GetTaskPhase(ctx, pluginContext, dummyDaskJob(daskAPI.DaskJobCreated)) + assert.NoError(t, err) + assert.Equal(t, taskPhase.Phase(), pluginsCore.PhaseInitializing) + assert.NotNil(t, taskPhase.Info()) + assert.NotNil(t, taskPhase.Info().Logs) + assert.NotNil(t, taskPhase.Info().LogContext) + assert.Nil(t, err) + + taskPhase, err = daskResourceHandler.GetTaskPhase(ctx, pluginContext, dummyDaskJob(daskAPI.DaskJobClusterCreated)) + assert.NoError(t, err) + assert.Equal(t, taskPhase.Phase(), pluginsCore.PhaseInitializing) + assert.NotNil(t, taskPhase.Info()) + assert.NotNil(t, taskPhase.Info().Logs) + assert.NotNil(t, taskPhase.Info().LogContext) + assert.Nil(t, err) + + taskPhase, err = daskResourceHandler.GetTaskPhase(ctx, pluginContext, dummyDaskJob(daskAPI.DaskJobRunning)) + assert.NoError(t, err) + assert.Equal(t, taskPhase.Phase(), pluginsCore.PhaseRunning) + assert.NotNil(t, taskPhase.Info()) + assert.NotNil(t, taskPhase.Info().Logs) + assert.Equal(t, expectedLogCtx.PrimaryPodName, taskPhase.Info().LogContext.PrimaryPodName) + assert.Nil(t, err) + + taskPhase, err = daskResourceHandler.GetTaskPhase(ctx, pluginContext, dummyDaskJob(daskAPI.DaskJobSuccessful)) + assert.NoError(t, err) + assert.Equal(t, taskPhase.Phase(), pluginsCore.PhaseSuccess) + assert.NotNil(t, taskPhase.Info()) + assert.NotNil(t, taskPhase.Info().Logs) + assert.Equal(t, expectedLogCtx.PrimaryPodName, taskPhase.Info().LogContext.PrimaryPodName) + assert.Nil(t, err) + + taskPhase, err = daskResourceHandler.GetTaskPhase(ctx, pluginContext, dummyDaskJob(daskAPI.DaskJobFailed)) + assert.NoError(t, err) + assert.Equal(t, taskPhase.Phase(), pluginsCore.PhaseRetryableFailure) + assert.NotNil(t, taskPhase.Info()) + assert.NotNil(t, taskPhase.Info().Logs) + assert.Equal(t, expectedLogCtx.PrimaryPodName, taskPhase.Info().LogContext.PrimaryPodName) + assert.Nil(t, err) +} + +func TestGetTaskPhaseIncreasePhaseVersion(t *testing.T) { + daskResourceHandler := daskResourceHandler{} + ctx := context.TODO() + + pluginState := k8s.PluginState{ + Phase: pluginsCore.PhaseInitializing, + PhaseVersion: pluginsCore.DefaultPhaseVersion, + Reason: "task submitted to K8s", + } + taskTemplate := dummyDaskTaskTemplate("", nil, "") + + pluginContext := dummyDaskPluginContext(taskTemplate, &v1.ResourceRequirements{}, pluginState) + taskPhase, err := daskResourceHandler.GetTaskPhase(ctx, pluginContext, dummyDaskJob(daskAPI.DaskJobCreated)) + + assert.NoError(t, err) + assert.Equal(t, taskPhase.Version(), pluginsCore.DefaultPhaseVersion+1) +} + +func TestGetTaskPhaseWithNamespaceInLogContext(t *testing.T) { + daskResourceHandler := daskResourceHandler{} + ctx := context.TODO() + + taskTemplate := dummyDaskTaskTemplate("", nil, "") + pluginContext := dummyDaskPluginContext(taskTemplate, &v1.ResourceRequirements{}, k8s.PluginState{}) + + taskPhase, err := daskResourceHandler.GetTaskPhase(ctx, pluginContext, dummyDaskJob(daskAPI.DaskJobRunning)) + assert.NoError(t, err) + assert.NotNil(t, taskPhase.Info()) + assert.NotNil(t, taskPhase.Info().LogContext) + assert.Equal(t, 1, len(taskPhase.Info().LogContext.Pods)) + + // Verify namespace is set in the pod log context + podLogContext := taskPhase.Info().LogContext.Pods[0] + assert.Equal(t, defaultNamespace, podLogContext.Namespace) + assert.Equal(t, "job-runner-pod-name", podLogContext.PodName) + assert.Equal(t, defaultDaskJobRunnerPrimaryContainerName, podLogContext.PrimaryContainerName) +} + +func TestGetTaskPhaseWithFailedPod(t *testing.T) { + daskResourceHandler := daskResourceHandler{} + ctx := context.TODO() + + // Create a failed pod in the fake client + pod := &v1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "job-runner-pod-name", + Namespace: defaultNamespace, + }, + Status: v1.PodStatus{ + Phase: v1.PodFailed, + ContainerStatuses: []v1.ContainerStatus{ + { + Name: defaultDaskJobRunnerPrimaryContainerName, + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + ExitCode: 1, + Reason: "Error", + Message: "Container failed", + }, + }, + }, + }, + }, + } + + taskTemplate := dummyDaskTaskTemplate("", nil, "") + pluginContext := dummyDaskPluginContextWithPods(taskTemplate, &v1.ResourceRequirements{}, k8s.PluginState{}, pod) + + // Even though DaskJob status is running, should return failure due to pod status + taskPhase, err := daskResourceHandler.GetTaskPhase(ctx, pluginContext, dummyDaskJob(daskAPI.DaskJobRunning)) + assert.NoError(t, err) + assert.True(t, taskPhase.Phase().IsFailure()) +} + +func TestGetTaskPhaseWithPendingPodInvalidImage(t *testing.T) { + daskResourceHandler := daskResourceHandler{} + ctx := context.TODO() + + // Create a pending pod with InvalidImageName - this should fail immediately + pod := &v1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: "job-runner-pod-name", + Namespace: defaultNamespace, + }, + Status: v1.PodStatus{ + Phase: v1.PodPending, + Conditions: []v1.PodCondition{ + { + Type: v1.PodReady, + Status: v1.ConditionFalse, + LastTransitionTime: metav1.Time{Time: time.Now()}, + Reason: "ContainersNotReady", + Message: "containers with unready status: [job-runner]", + }, + }, + ContainerStatuses: []v1.ContainerStatus{ + { + Name: defaultDaskJobRunnerPrimaryContainerName, + Ready: false, + State: v1.ContainerState{ + Waiting: &v1.ContainerStateWaiting{ + Reason: "InvalidImageName", + Message: "Invalid image name", + }, + }, + }, + }, + }, + } + + taskTemplate := dummyDaskTaskTemplate("", nil, "") + pluginContext := dummyDaskPluginContextWithPods(taskTemplate, &v1.ResourceRequirements{}, k8s.PluginState{}, pod) + + taskPhase, err := daskResourceHandler.GetTaskPhase(ctx, pluginContext, dummyDaskJob(daskAPI.DaskJobClusterCreated)) + assert.NoError(t, err) + // Should detect the InvalidImageName and return a failure phase + assert.True(t, taskPhase.Phase().IsFailure()) +} + +func TestGetTaskPhaseContainerNameConstant(t *testing.T) { + daskResourceHandler := daskResourceHandler{} + ctx := context.TODO() + + taskTemplate := dummyDaskTaskTemplate("", nil, "") + pluginContext := dummyDaskPluginContext(taskTemplate, &v1.ResourceRequirements{}, k8s.PluginState{}) + + taskPhase, err := daskResourceHandler.GetTaskPhase(ctx, pluginContext, dummyDaskJob(daskAPI.DaskJobSuccessful)) + assert.NoError(t, err) + assert.NotNil(t, taskPhase.Info()) + assert.NotNil(t, taskPhase.Info().LogContext) + + // Verify the constant is used for container names + podLogContext := taskPhase.Info().LogContext.Pods[0] + assert.Equal(t, defaultDaskJobRunnerPrimaryContainerName, podLogContext.PrimaryContainerName) + assert.Equal(t, 1, len(podLogContext.Containers)) + assert.Equal(t, defaultDaskJobRunnerPrimaryContainerName, podLogContext.Containers[0].ContainerName) +} + +func TestIsTerminal(t *testing.T) { + daskResourceHandler := daskResourceHandler{} + ctx := context.Background() + + tests := []struct { + name string + status daskAPI.JobStatus + expectedResult bool + }{ + {"Successful", daskAPI.DaskJobSuccessful, true}, + {"Failed", daskAPI.DaskJobFailed, true}, + {"Running", daskAPI.DaskJobRunning, false}, + {"Created", daskAPI.DaskJobCreated, false}, + {"ClusterCreated", daskAPI.DaskJobClusterCreated, false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + job := dummyDaskJob(tt.status) + result, err := daskResourceHandler.IsTerminal(ctx, job) + assert.NoError(t, err) + assert.Equal(t, tt.expectedResult, result) + }) + } +} + +func TestIsTerminal_WrongResourceType(t *testing.T) { + daskResourceHandler := daskResourceHandler{} + ctx := context.Background() + + wrongResource := &v1.Pod{} + result, err := daskResourceHandler.IsTerminal(ctx, wrongResource) + assert.Error(t, err) + assert.False(t, result) + assert.Contains(t, err.Error(), "unexpected resource type") +} + +func TestGetCompletionTime(t *testing.T) { + daskResourceHandler := daskResourceHandler{} + + now := time.Now().Truncate(time.Second) + earlier := now.Add(-1 * time.Hour) + evenEarlier := now.Add(-2 * time.Hour) + + tests := []struct { + name string + job *daskAPI.DaskJob + expectedTime time.Time + }{ + { + name: "uses EndTime", + job: &daskAPI.DaskJob{ + ObjectMeta: metav1.ObjectMeta{ + CreationTimestamp: metav1.NewTime(evenEarlier), + }, + Status: daskAPI.DaskJobStatus{ + EndTime: metav1.NewTime(now), + StartTime: metav1.NewTime(earlier), + }, + }, + expectedTime: now, + }, + { + name: "falls back to StartTime", + job: &daskAPI.DaskJob{ + ObjectMeta: metav1.ObjectMeta{ + CreationTimestamp: metav1.NewTime(evenEarlier), + }, + Status: daskAPI.DaskJobStatus{ + StartTime: metav1.NewTime(now), + }, + }, + expectedTime: now, + }, + { + name: "falls back to CreationTimestamp", + job: &daskAPI.DaskJob{ + ObjectMeta: metav1.ObjectMeta{ + CreationTimestamp: metav1.NewTime(now), + }, + Status: daskAPI.DaskJobStatus{}, + }, + expectedTime: now, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result, err := daskResourceHandler.GetCompletionTime(tt.job) + assert.NoError(t, err) + assert.Equal(t, tt.expectedTime.Unix(), result.Unix()) + }) + } +} + +func TestGetCompletionTime_WrongResourceType(t *testing.T) { + daskResourceHandler := daskResourceHandler{} + + wrongResource := &v1.Pod{} + result, err := daskResourceHandler.GetCompletionTime(wrongResource) + assert.Error(t, err) + assert.True(t, result.IsZero()) + assert.Contains(t, err.Error(), "unexpected resource type") +} diff --git a/flyteplugins/go/tasks/plugins/k8s/kfoperators/common/common_operator.go b/flyteplugins/go/tasks/plugins/k8s/kfoperators/common/common_operator.go new file mode 100644 index 0000000000..bc993d852f --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/kfoperators/common/common_operator.go @@ -0,0 +1,398 @@ +package common + +import ( + "context" + "fmt" + "sort" + "time" + + kubeflowv1 "github.com/kubeflow/training-operator/pkg/apis/kubeflow.org/v1" + v1 "k8s.io/api/core/v1" + meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + flyteerr "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/logs" + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/tasklog" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + pluginsIdl "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" + kfplugins "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow" +) + +const ( + TensorflowTaskType = "tensorflow" + MPITaskType = "mpi" + PytorchTaskType = "pytorch" +) + +// ExtractCurrentCondition will return the first job condition for tensorflow/pytorch +func ExtractCurrentCondition(jobConditions []kubeflowv1.JobCondition) (kubeflowv1.JobCondition, error) { + if jobConditions != nil { + sort.Slice(jobConditions, func(i, j int) bool { + return jobConditions[i].LastTransitionTime.Time.After(jobConditions[j].LastTransitionTime.Time) + }) + + for _, jc := range jobConditions { + if jc.Status == v1.ConditionTrue { + return jc, nil + } + } + return kubeflowv1.JobCondition{}, fmt.Errorf("found no current condition. Conditions: %+v", jobConditions) + } + return kubeflowv1.JobCondition{}, nil +} + +// GetPhaseInfo will return the phase of kubeflow job +func GetPhaseInfo(currentCondition kubeflowv1.JobCondition, occurredAt time.Time, + taskPhaseInfo pluginsCore.TaskInfo) (pluginsCore.PhaseInfo, error) { + if len(currentCondition.Type) == 0 { + return pluginsCore.PhaseInfoQueuedWithTaskInfo(occurredAt, pluginsCore.DefaultPhaseVersion, "JobCreated", &taskPhaseInfo), nil + } + switch currentCondition.Type { + case kubeflowv1.JobCreated: + return pluginsCore.PhaseInfoQueuedWithTaskInfo(occurredAt, pluginsCore.DefaultPhaseVersion, "JobCreated", &taskPhaseInfo), nil + case kubeflowv1.JobRunning: + return pluginsCore.PhaseInfoRunning(pluginsCore.DefaultPhaseVersion, &taskPhaseInfo), nil + case kubeflowv1.JobSucceeded: + return pluginsCore.PhaseInfoSuccess(&taskPhaseInfo), nil + case kubeflowv1.JobFailed: + details := fmt.Sprintf("Job failed:\n\t%v - %v", currentCondition.Reason, currentCondition.Message) + return pluginsCore.PhaseInfoRetryableFailure(flyteerr.DownstreamSystemError, details, &taskPhaseInfo), nil + case kubeflowv1.JobRestarting: + return pluginsCore.PhaseInfoRunning(pluginsCore.DefaultPhaseVersion, &taskPhaseInfo), nil + } + + return pluginsCore.PhaseInfoUndefined, nil +} + +// GetMPIPhaseInfo will return the phase of MPI job +func GetMPIPhaseInfo(currentCondition kubeflowv1.JobCondition, occurredAt time.Time, + taskPhaseInfo pluginsCore.TaskInfo) (pluginsCore.PhaseInfo, error) { + switch currentCondition.Type { + case kubeflowv1.JobCreated: + return pluginsCore.PhaseInfoQueuedWithTaskInfo(occurredAt, pluginsCore.DefaultPhaseVersion, "New job name submitted to MPI operator", &taskPhaseInfo), nil + case kubeflowv1.JobRunning: + return pluginsCore.PhaseInfoRunning(pluginsCore.DefaultPhaseVersion, &taskPhaseInfo), nil + case kubeflowv1.JobSucceeded: + return pluginsCore.PhaseInfoSuccess(&taskPhaseInfo), nil + case kubeflowv1.JobFailed: + details := fmt.Sprintf("Job failed:\n\t%v - %v", currentCondition.Reason, currentCondition.Message) + return pluginsCore.PhaseInfoRetryableFailure(flyteerr.DownstreamSystemError, details, &taskPhaseInfo), nil + case kubeflowv1.JobRestarting: + return pluginsCore.PhaseInfoRunning(pluginsCore.DefaultPhaseVersion, &taskPhaseInfo), nil + } + + return pluginsCore.PhaseInfoUndefined, nil +} + +// GetLogs will return the logs for kubeflow job +func GetLogs(pluginContext k8s.PluginContext, taskType string, objectMeta meta_v1.ObjectMeta, taskTemplate *core.TaskTemplate, hasMaster bool, + workersCount int32, psReplicasCount int32, chiefReplicasCount int32, evaluatorReplicasCount int32, primaryContainerName string) ([]*core.TaskLog, error) { + name := objectMeta.Name + namespace := objectMeta.Namespace + + taskLogs := make([]*core.TaskLog, 0, 10) + taskExecID := pluginContext.TaskExecutionMetadata().GetTaskExecutionID() + + logPlugin, err := logs.InitializeLogPlugins(logs.GetLogConfig()) + + if err != nil { + return nil, err + } + + if logPlugin == nil { + return nil, nil + } + + // We use the creation timestamp of the Kubeflow Job as a proxy for the start time of the pods + startTime := objectMeta.CreationTimestamp.Time.Unix() + // Don't have a good mechanism for this yet, but approximating with time.Now for now + finishTime := time.Now().Unix() + RFC3999StartTime := time.Unix(startTime, 0).Format(time.RFC3339) + RFC3999FinishTime := time.Unix(finishTime, 0).Format(time.RFC3339) + + if taskType == PytorchTaskType && hasMaster { + masterTaskLog, masterErr := logPlugin.GetTaskLogs( + tasklog.Input{ + PodName: name + "-master-0", + Namespace: namespace, + LogName: "master", + PodRFC3339StartTime: RFC3999StartTime, + PodRFC3339FinishTime: RFC3999FinishTime, + PodUnixStartTime: startTime, + PodUnixFinishTime: finishTime, + TaskExecutionID: taskExecID, + TaskTemplate: taskTemplate, + ContainerName: primaryContainerName, + }, + ) + if masterErr != nil { + return nil, masterErr + } + taskLogs = append(taskLogs, masterTaskLog.TaskLogs...) + } + + // get all workers log + for workerIndex := int32(0); workerIndex < workersCount; workerIndex++ { + workerLog, err := logPlugin.GetTaskLogs(tasklog.Input{ + PodName: name + fmt.Sprintf("-worker-%d", workerIndex), + Namespace: namespace, + PodRFC3339StartTime: RFC3999StartTime, + PodRFC3339FinishTime: RFC3999FinishTime, + PodUnixStartTime: startTime, + PodUnixFinishTime: finishTime, + TaskExecutionID: taskExecID, + TaskTemplate: taskTemplate, + ContainerName: primaryContainerName, + }) + if err != nil { + return nil, err + } + taskLogs = append(taskLogs, workerLog.TaskLogs...) + } + + if taskType == MPITaskType || taskType == PytorchTaskType { + return taskLogs, nil + } + + // get all parameter servers logs + for psReplicaIndex := int32(0); psReplicaIndex < psReplicasCount; psReplicaIndex++ { + psReplicaLog, err := logPlugin.GetTaskLogs(tasklog.Input{ + PodName: name + fmt.Sprintf("-psReplica-%d", psReplicaIndex), + Namespace: namespace, + TaskExecutionID: taskExecID, + TaskTemplate: taskTemplate, + }) + if err != nil { + return nil, err + } + taskLogs = append(taskLogs, psReplicaLog.TaskLogs...) + } + // get chief worker log, and the max number of chief worker is 1 + if chiefReplicasCount != 0 { + chiefReplicaLog, err := logPlugin.GetTaskLogs(tasklog.Input{ + PodName: name + fmt.Sprintf("-chiefReplica-%d", 0), + Namespace: namespace, + TaskExecutionID: taskExecID, + TaskTemplate: taskTemplate, + }) + if err != nil { + return nil, err + } + taskLogs = append(taskLogs, chiefReplicaLog.TaskLogs...) + } + // get evaluator log, and the max number of evaluator is 1 + if evaluatorReplicasCount != 0 { + evaluatorReplicasCount, err := logPlugin.GetTaskLogs(tasklog.Input{ + PodName: name + fmt.Sprintf("-evaluatorReplica-%d", 0), + Namespace: namespace, + TaskExecutionID: taskExecID, + TaskTemplate: taskTemplate, + }) + if err != nil { + return nil, err + } + taskLogs = append(taskLogs, evaluatorReplicasCount.TaskLogs...) + } + + return taskLogs, nil +} + +func OverridePrimaryContainerName(podSpec *v1.PodSpec, primaryContainerName string, defaultContainerName string) { + // Pytorch operator forces pod to have container named 'pytorch' + // https://github.com/kubeflow/pytorch-operator/blob/037cd1b18eb77f657f2a4bc8a8334f2a06324b57/pkg/apis/pytorch/validation/validation.go#L54-L62 + // Tensorflow operator forces pod to have container named 'tensorflow' + // https://github.com/kubeflow/tf-operator/blob/984adc287e6fe82841e4ca282dc9a2cbb71e2d4a/pkg/apis/tensorflow/validation/validation.go#L55-L63 + // hence we have to override the name set here + // https://github.com/flyteorg/flyteplugins/blob/209c52d002b4e6a39be5d175bc1046b7e631c153/go/tasks/pluginmachinery/flytek8s/container_helper.go#L116 + for idx, c := range podSpec.Containers { + if c.Name == primaryContainerName { + podSpec.Containers[idx].Name = defaultContainerName + return + } + } +} + +// ParseRunPolicy converts a kubeflow plugin RunPolicy object to a k8s RunPolicy object. +func ParseRunPolicy(flyteRunPolicy kfplugins.RunPolicy) kubeflowv1.RunPolicy { + runPolicy := kubeflowv1.RunPolicy{} + if flyteRunPolicy.GetBackoffLimit() != 0 { + var backoffLimit = flyteRunPolicy.GetBackoffLimit() + runPolicy.BackoffLimit = &backoffLimit + } + var cleanPodPolicy = ParseCleanPodPolicy(flyteRunPolicy.GetCleanPodPolicy()) + runPolicy.CleanPodPolicy = &cleanPodPolicy + if flyteRunPolicy.GetActiveDeadlineSeconds() != 0 { + var ddlSeconds = int64(flyteRunPolicy.GetActiveDeadlineSeconds()) + runPolicy.ActiveDeadlineSeconds = &ddlSeconds + } + if flyteRunPolicy.GetTtlSecondsAfterFinished() != 0 { + var ttl = flyteRunPolicy.GetTtlSecondsAfterFinished() + runPolicy.TTLSecondsAfterFinished = &ttl + } + + return runPolicy +} + +// Get k8s clean pod policy from flyte kubeflow plugins clean pod policy. +func ParseCleanPodPolicy(flyteCleanPodPolicy kfplugins.CleanPodPolicy) kubeflowv1.CleanPodPolicy { + cleanPodPolicyMap := map[kfplugins.CleanPodPolicy]kubeflowv1.CleanPodPolicy{ + kfplugins.CleanPodPolicy_CLEANPOD_POLICY_NONE: kubeflowv1.CleanPodPolicyNone, + kfplugins.CleanPodPolicy_CLEANPOD_POLICY_ALL: kubeflowv1.CleanPodPolicyAll, + kfplugins.CleanPodPolicy_CLEANPOD_POLICY_RUNNING: kubeflowv1.CleanPodPolicyRunning, + } + return cleanPodPolicyMap[flyteCleanPodPolicy] +} + +// Get k8s restart policy from flyte kubeflow plugins restart policy. +func ParseRestartPolicy(flyteRestartPolicy pluginsIdl.RestartPolicy) kubeflowv1.RestartPolicy { + restartPolicyMap := map[pluginsIdl.RestartPolicy]kubeflowv1.RestartPolicy{ + pluginsIdl.RestartPolicy_RESTART_POLICY_NEVER: kubeflowv1.RestartPolicyNever, + pluginsIdl.RestartPolicy_RESTART_POLICY_ON_FAILURE: kubeflowv1.RestartPolicyOnFailure, + pluginsIdl.RestartPolicy_RESTART_POLICY_ALWAYS: kubeflowv1.RestartPolicyAlways, + } + return restartPolicyMap[flyteRestartPolicy] +} + +// OverrideContainerSpec overrides the specified container's properties in the given podSpec. The function +// updates the image and command arguments of the container that matches the given containerName. +func OverrideContainerSpec(podSpec *v1.PodSpec, containerName string, image string, args []string) error { + for idx, c := range podSpec.Containers { + if c.Name == containerName { + if image != "" { + podSpec.Containers[idx].Image = image + } + if len(args) != 0 { + podSpec.Containers[idx].Args = args + } + } + } + return nil +} + +func ToReplicaSpec(ctx context.Context, taskCtx pluginsCore.TaskExecutionContext, primaryContainerName string) (*kubeflowv1.ReplicaSpec, error) { + podSpec, objectMeta, oldPrimaryContainerName, err := flytek8s.ToK8sPodSpec(ctx, taskCtx) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "Unable to create pod spec: [%v]", err.Error()) + } + + OverridePrimaryContainerName(podSpec, oldPrimaryContainerName, primaryContainerName) + + cfg := config.GetK8sPluginConfig() + objectMeta.Annotations = utils.UnionMaps(cfg.DefaultAnnotations, objectMeta.Annotations, utils.CopyMap(taskCtx.TaskExecutionMetadata().GetAnnotations())) + objectMeta.Labels = utils.UnionMaps(cfg.DefaultLabels, objectMeta.Labels, utils.CopyMap(taskCtx.TaskExecutionMetadata().GetLabels())) + + replicas := int32(0) + return &kubeflowv1.ReplicaSpec{ + Replicas: &replicas, + Template: v1.PodTemplateSpec{ + ObjectMeta: *objectMeta, + Spec: *podSpec, + }, + RestartPolicy: kubeflowv1.RestartPolicyNever, + }, nil +} + +type kfDistributedReplicaSpec interface { + GetReplicas() int32 + GetImage() string + GetResources() *core.Resources + GetRestartPolicy() pluginsIdl.RestartPolicy + GetCommon() *pluginsIdl.CommonReplicaSpec +} + +type allowsCommandOverride interface { + GetCommand() []string +} + +func ToReplicaSpecWithOverrides(ctx context.Context, taskCtx pluginsCore.TaskExecutionContext, rs kfDistributedReplicaSpec, primaryContainerName string, isMaster bool) (*kubeflowv1.ReplicaSpec, error) { + var replicas int32 + var image string + var resources *core.Resources + var restartPolicy pluginsIdl.RestartPolicy + + // replicas, image, resources, restartPolicy are deprecated since the common replica spec is introduced. + // Therefore, if the common replica spec is set, use that to get the common fields + common := rs.GetCommon() + if common != nil { + replicas = common.GetReplicas() + image = common.GetImage() + resources = common.GetResources() + restartPolicy = common.GetRestartPolicy() + } else { + replicas = rs.GetReplicas() + image = rs.GetImage() + resources = rs.GetResources() + restartPolicy = rs.GetRestartPolicy() + } + + taskCtxOptions := []flytek8s.PluginTaskExecutionContextOption{} + if resources != nil { + resources, err := flytek8s.ToK8sResourceRequirements(resources) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "invalid TaskSpecification on Resources [%v], Err: [%v]", resources, err.Error()) + } + + // Get extended resources for GPU accelerator info + taskTemplate, err := taskCtx.TaskReader().Read(ctx) + if err != nil { + return nil, err + } + extendedResources := flytek8s.ApplyExtendedResourcesOverrides( + taskTemplate.GetExtendedResources(), + taskCtx.TaskExecutionMetadata().GetOverrides().GetExtendedResources(), + ) + + // Normalize GPU resource names BEFORE applying overrides (e.g., "gpu" โ†’ "nvidia.com/gpu") + // This ensures ApplyK8sResourceOverrides can find GPU resources under the correct name and + // apply platform limits, and later toleration lookups succeed. + flytek8s.SanitizeGPUResourceRequirements(resources, extendedResources.GetGpuAccelerator()) + + *resources = flytek8s.ApplyK8sResourceOverrides(taskCtx.TaskExecutionMetadata(), resources) + taskCtxOptions = append(taskCtxOptions, flytek8s.WithResources(resources)) + } + newTaskCtx := flytek8s.NewPluginTaskExecutionContext(taskCtx, taskCtxOptions...) + replicaSpec, err := ToReplicaSpec(ctx, newTaskCtx, primaryContainerName) + if err != nil { + return nil, err + } + + // Master should have a single replica + if isMaster { + replicas := int32(1) + replicaSpec.Replicas = &replicas + } + + var command []string + if v, ok := rs.(allowsCommandOverride); ok { + command = v.GetCommand() + } + if err := OverrideContainerSpec( + &replicaSpec.Template.Spec, + primaryContainerName, + image, + command, + ); err != nil { + return nil, err + } + + replicaSpec.RestartPolicy = ParseRestartPolicy(restartPolicy) + + if !isMaster { + replicaSpec.Replicas = &replicas + } + + return replicaSpec, nil +} + +func GetReplicaCount(specs map[kubeflowv1.ReplicaType]*kubeflowv1.ReplicaSpec, replicaType kubeflowv1.ReplicaType) *int32 { + if spec, ok := specs[replicaType]; ok && spec.Replicas != nil { + return spec.Replicas + } + + return new(int32) // return 0 as default value +} diff --git a/flyteplugins/go/tasks/plugins/k8s/kfoperators/common/common_operator_test.go b/flyteplugins/go/tasks/plugins/k8s/kfoperators/common/common_operator_test.go new file mode 100644 index 0000000000..64fe433642 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/kfoperators/common/common_operator_test.go @@ -0,0 +1,385 @@ +package common + +import ( + "fmt" + "os" + "testing" + "time" + + kubeflowv1 "github.com/kubeflow/training-operator/pkg/apis/kubeflow.org/v1" + "github.com/stretchr/testify/assert" + "google.golang.org/protobuf/types/known/structpb" + corev1 "k8s.io/api/core/v1" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/logs" + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + k8smocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/tasklog" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func TestMain(m *testing.M) { + // All tests should run assuming UTC timezone. + time.Local = time.UTC + code := m.Run() + os.Exit(code) +} + +func TestExtractCurrentCondition(t *testing.T) { + jobCreated := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobCreated, + Status: corev1.ConditionTrue, + } + jobRunningActive := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobRunning, + Status: corev1.ConditionFalse, + } + jobConditions := []kubeflowv1.JobCondition{ + jobCreated, + jobRunningActive, + } + currentCondition, err := ExtractCurrentCondition(jobConditions) + assert.NoError(t, err) + assert.Equal(t, currentCondition, jobCreated) + assert.Equal(t, currentCondition, jobCreated) + + jobConditions = nil + currentCondition, err = ExtractCurrentCondition(jobConditions) + assert.NoError(t, err) + assert.Equal(t, currentCondition, kubeflowv1.JobCondition{}) + + currentCondition, err = ExtractCurrentCondition(nil) + assert.NoError(t, err) + assert.Equal(t, currentCondition, kubeflowv1.JobCondition{}) + + jobUnknown := kubeflowv1.JobCondition{Type: "unknown"} + jobConditions = []kubeflowv1.JobCondition{jobUnknown} + currentCondition, err = ExtractCurrentCondition(jobConditions) + assert.Error(t, err) + assert.Equal(t, currentCondition, kubeflowv1.JobCondition{}) + assert.Equal(t, currentCondition, kubeflowv1.JobCondition{}) + assert.Equal(t, err, fmt.Errorf("found no current condition. Conditions: %+v", jobConditions)) +} + +func TestGetPhaseInfo(t *testing.T) { + jobCreating := kubeflowv1.JobCondition{} + taskPhase, err := GetPhaseInfo(jobCreating, time.Now(), pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseQueued, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + jobCreated := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobCreated, + } + taskPhase, err = GetPhaseInfo(jobCreated, time.Now(), pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseQueued, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + jobSucceeded := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobSucceeded, + } + taskPhase, err = GetPhaseInfo(jobSucceeded, time.Now(), pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseSuccess, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + jobFailed := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobFailed, + } + taskPhase, err = GetPhaseInfo(jobFailed, time.Now(), pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + jobRestarting := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobRestarting, + } + taskPhase, err = GetPhaseInfo(jobRestarting, time.Now(), pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRunning, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + jobRestarting = kubeflowv1.JobCondition{ + Type: kubeflowv1.JobRunning, + } + taskPhase, err = GetPhaseInfo(jobRestarting, time.Now(), pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRunning, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) +} + +func TestGetMPIPhaseInfo(t *testing.T) { + jobCreated := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobCreated, + } + taskPhase, err := GetMPIPhaseInfo(jobCreated, time.Now(), pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseQueued, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + jobSucceeded := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobSucceeded, + } + taskPhase, err = GetMPIPhaseInfo(jobSucceeded, time.Now(), pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseSuccess, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + jobFailed := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobFailed, + } + taskPhase, err = GetMPIPhaseInfo(jobFailed, time.Now(), pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + jobRestarting := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobRestarting, + } + taskPhase, err = GetMPIPhaseInfo(jobRestarting, time.Now(), pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRunning, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + jobRestarting = kubeflowv1.JobCondition{ + Type: kubeflowv1.JobRunning, + } + taskPhase, err = GetMPIPhaseInfo(jobRestarting, time.Now(), pluginsCore.TaskInfo{}) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRunning, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) +} + +func TestGetLogs(t *testing.T) { + assert.NoError(t, logs.SetLogConfig(&logs.LogConfig{ + IsKubernetesEnabled: true, + KubernetesURL: "k8s.com", + })) + + workers := int32(1) + launcher := int32(1) + + taskTemplate := dummyTaskTemplate() + taskCtx := dummyTaskContext() + mpiJobObjectMeta := meta_v1.ObjectMeta{ + Name: "test", + Namespace: "mpi-namespace", + } + jobLogs, err := GetLogs(taskCtx, MPITaskType, mpiJobObjectMeta, taskTemplate, false, workers, launcher, 0, 0, kubeflowv1.MPIJobDefaultContainerName) + assert.NoError(t, err) + assert.Equal(t, 1, len(jobLogs)) + assert.Equal(t, fmt.Sprintf("k8s.com/#!/log/%s/%s-worker-0/pod?namespace=mpi-namespace", "mpi-namespace", "test"), jobLogs[0].Uri) + + pytorchJobObjectMeta := meta_v1.ObjectMeta{ + Name: "test", + Namespace: "pytorch-namespace", + } + jobLogs, err = GetLogs(taskCtx, PytorchTaskType, pytorchJobObjectMeta, taskTemplate, true, workers, launcher, 0, 0, kubeflowv1.PyTorchJobDefaultContainerName) + assert.NoError(t, err) + assert.Equal(t, 2, len(jobLogs)) + assert.Equal(t, fmt.Sprintf("k8s.com/#!/log/%s/%s-master-0/pod?namespace=pytorch-namespace", "pytorch-namespace", "test"), jobLogs[0].Uri) + assert.Equal(t, fmt.Sprintf("k8s.com/#!/log/%s/%s-worker-0/pod?namespace=pytorch-namespace", "pytorch-namespace", "test"), jobLogs[1].Uri) + + tensorflowJobObjectMeta := meta_v1.ObjectMeta{ + Name: "test", + Namespace: "tensorflow-namespace", + } + jobLogs, err = GetLogs(taskCtx, TensorflowTaskType, tensorflowJobObjectMeta, taskTemplate, false, workers, launcher, 1, 0, kubeflowv1.TFJobDefaultContainerName) + assert.NoError(t, err) + assert.Equal(t, 3, len(jobLogs)) + assert.Equal(t, fmt.Sprintf("k8s.com/#!/log/%s/%s-worker-0/pod?namespace=tensorflow-namespace", "tensorflow-namespace", "test"), jobLogs[0].Uri) + assert.Equal(t, fmt.Sprintf("k8s.com/#!/log/%s/%s-psReplica-0/pod?namespace=tensorflow-namespace", "tensorflow-namespace", "test"), jobLogs[1].Uri) + assert.Equal(t, fmt.Sprintf("k8s.com/#!/log/%s/%s-chiefReplica-0/pod?namespace=tensorflow-namespace", "tensorflow-namespace", "test"), jobLogs[2].Uri) + +} + +func TestGetLogsTemplateUri(t *testing.T) { + assert.NoError(t, logs.SetLogConfig(&logs.LogConfig{ + IsStackDriverEnabled: true, + StackDriverTemplateURI: "https://console.cloud.google.com/logs/query;query=resource.labels.pod_name={{.podName}}×tamp>{{.podRFC3339StartTime}}", + })) + + taskTemplate := dummyTaskTemplate() + taskCtx := dummyTaskContext() + pytorchJobObjectMeta := meta_v1.ObjectMeta{ + Name: "test", + Namespace: "pytorch-" + + "namespace", + CreationTimestamp: meta_v1.Time{ + Time: time.Date(2022, time.January, 1, 12, 0, 0, 0, time.UTC), + }, + } + jobLogs, err := GetLogs(taskCtx, PytorchTaskType, pytorchJobObjectMeta, taskTemplate, true, 1, 0, 0, 0, kubeflowv1.PyTorchJobDefaultContainerName) + assert.NoError(t, err) + assert.Equal(t, 2, len(jobLogs)) + assert.Equal(t, fmt.Sprintf("https://console.cloud.google.com/logs/query;query=resource.labels.pod_name=%s-master-0×tamp>%s", "test", "2022-01-01T12:00:00Z"), jobLogs[0].Uri) + assert.Equal(t, fmt.Sprintf("https://console.cloud.google.com/logs/query;query=resource.labels.pod_name=%s-worker-0×tamp>%s", "test", "2022-01-01T12:00:00Z"), jobLogs[1].Uri) +} + +func TestGetLogsDynamic(t *testing.T) { + dynamicLinks := map[string]tasklog.TemplateLogPlugin{ + "test-dynamic-link": { + TemplateURIs: []string{"https://some-service.com/{{.taskConfig.dynamicParam}}"}, + }, + } + + assert.NoError(t, logs.SetLogConfig(&logs.LogConfig{ + DynamicLogLinks: dynamicLinks, + })) + + taskTemplate := dummyTaskTemplate() + taskTemplate.Config = map[string]string{ + "link_type": "test-dynamic-link", + "dynamicParam": "dynamic-value", + } + taskCtx := dummyTaskContext() + pytorchJobObjectMeta := meta_v1.ObjectMeta{ + Name: "test", + Namespace: "pytorch-" + + "namespace", + CreationTimestamp: meta_v1.Time{ + Time: time.Date(2022, time.January, 1, 12, 0, 0, 0, time.UTC), + }, + } + jobLogs, err := GetLogs(taskCtx, PytorchTaskType, pytorchJobObjectMeta, taskTemplate, true, 1, 0, 0, 0, kubeflowv1.PyTorchJobDefaultContainerName) + assert.NoError(t, err) + assert.Equal(t, 2, len(jobLogs)) + assert.Equal(t, "https://some-service.com/dynamic-value", jobLogs[0].GetUri()) +} + +func dummyPodSpec() v1.PodSpec { + return v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "primary container", + Args: []string{"pyflyte-execute", "--task-module", "tests.flytekit.unit.sdk.tasks.test_sidecar_tasks", "--task-name", "simple_sidecar_task", "--inputs", "{{.input}}", "--output-prefix", "{{.outputPrefix}}"}, + Image: "dummy-image", + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "cpu": resource.MustParse("2"), + "memory": resource.MustParse("200Mi"), + "gpu": resource.MustParse("1"), + }, + Requests: v1.ResourceList{ + "cpu": resource.MustParse("1"), + "memory": resource.MustParse("100Mi"), + "gpu": resource.MustParse("1"), + }, + }, + VolumeMounts: []v1.VolumeMount{ + { + Name: "volume mount", + }, + }, + }, + { + Name: "secondary container", + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "gpu": resource.MustParse("2"), + }, + Requests: v1.ResourceList{ + "gpu": resource.MustParse("2"), + }, + }, + }, + }, + Volumes: []v1.Volume{ + { + Name: "dshm", + }, + }, + Tolerations: []v1.Toleration{ + { + Key: "my toleration key", + Value: "my toleration value", + }, + }, + } +} + +func TestOverrideContainerSpec(t *testing.T) { + podSpec := dummyPodSpec() + err := OverrideContainerSpec( + &podSpec, "primary container", "testing-image", + []string{"python", "-m", "run.py"}, + ) + assert.NoError(t, err) + assert.Equal(t, 2, len(podSpec.Containers)) + assert.Equal(t, "testing-image", podSpec.Containers[0].Image) + assert.Equal(t, []string{"python", "-m", "run.py"}, podSpec.Containers[0].Args) +} + +func TestOverrideContainerSpecEmptyFields(t *testing.T) { + podSpec := dummyPodSpec() + err := OverrideContainerSpec(&podSpec, "primary container", "", []string{}) + assert.NoError(t, err) + assert.Equal(t, 2, len(podSpec.Containers)) + assert.Equal(t, "dummy-image", podSpec.Containers[0].Image) + assert.Equal(t, []string{"pyflyte-execute", "--task-module", "tests.flytekit.unit.sdk.tasks.test_sidecar_tasks", "--task-name", "simple_sidecar_task", "--inputs", "{{.input}}", "--output-prefix", "{{.outputPrefix}}"}, podSpec.Containers[0].Args) +} + +func dummyTaskTemplate() *core.TaskTemplate { + id := "dummy-id" + + testImage := "dummy-image" + + structObj := structpb.Struct{} + + return &core.TaskTemplate{ + Id: &core.Identifier{Name: id}, + Type: "container", + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Image: testImage, + }, + }, + Custom: &structObj, + } +} + +func dummyTaskContext() *k8smocks.PluginContext { + pCtx := &k8smocks.PluginContext{} + + tID := &mocks.TaskExecutionID{} + tID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + TaskId: &core.Identifier{ + ResourceType: core.ResourceType_TASK, + Name: "my-task-name", + Project: "my-task-project", + Domain: "my-task-domain", + Version: "1", + }, + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my-execution-name", + Project: "my-execution-project", + Domain: "my-execution-domain", + }, + }, + RetryAttempt: 0, + }) + tID.EXPECT().GetGeneratedName().Return("some-acceptable-name") + tID.EXPECT().GetUniqueNodeID().Return("an-unique-id") + + taskExecutionMetadata := &mocks.TaskExecutionMetadata{} + taskExecutionMetadata.EXPECT().GetTaskExecutionID().Return(tID) + pCtx.EXPECT().TaskExecutionMetadata().Return(taskExecutionMetadata) + return pCtx +} diff --git a/flyteplugins/go/tasks/plugins/k8s/kfoperators/common/config.go b/flyteplugins/go/tasks/plugins/k8s/kfoperators/common/config.go new file mode 100644 index 0000000000..22ea48ad08 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/kfoperators/common/config.go @@ -0,0 +1,32 @@ +package common + +import ( + "time" + + pluginsConfig "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/config" + "github.com/flyteorg/flyte/v2/flytestdlib/config" +) + +//go:generate pflags Config --default-var=defaultConfig + +var ( + defaultConfig = Config{ + Timeout: config.Duration{Duration: 1 * time.Minute}, + } + + configSection = pluginsConfig.MustRegisterSubSection("kf-operator", &defaultConfig) +) + +// Config is config for 'pytorch' plugin +type Config struct { + // If kubeflow operator doesn't update the status of the task after this timeout, the task will be considered failed. + Timeout config.Duration `json:"timeout,omitempty"` +} + +func GetConfig() *Config { + return configSection.GetConfig().(*Config) +} + +func SetConfig(cfg *Config) error { + return configSection.SetConfig(cfg) +} diff --git a/flyteplugins/go/tasks/plugins/k8s/kfoperators/common/config_flags.go b/flyteplugins/go/tasks/plugins/k8s/kfoperators/common/config_flags.go new file mode 100755 index 0000000000..9fb5c02976 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/kfoperators/common/config_flags.go @@ -0,0 +1,55 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package common + +import ( + "encoding/json" + "reflect" + + "fmt" + + "github.com/spf13/pflag" +) + +// If v is a pointer, it will get its element value or the zero value of the element type. +// If v is not a pointer, it will return it as is. +func (Config) elemValueOrNil(v interface{}) interface{} { + if t := reflect.TypeOf(v); t.Kind() == reflect.Ptr { + if reflect.ValueOf(v).IsNil() { + return reflect.Zero(t.Elem()).Interface() + } else { + return reflect.ValueOf(v).Interface() + } + } else if v == nil { + return reflect.Zero(t).Interface() + } + + return v +} + +func (Config) mustJsonMarshal(v interface{}) string { + raw, err := json.Marshal(v) + if err != nil { + panic(err) + } + + return string(raw) +} + +func (Config) mustMarshalJSON(v json.Marshaler) string { + raw, err := v.MarshalJSON() + if err != nil { + panic(err) + } + + return string(raw) +} + +// GetPFlagSet will return strongly types pflags for all fields in Config and its nested types. The format of the +// flags is json-name.json-sub-name... etc. +func (cfg Config) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("Config", pflag.ExitOnError) + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "timeout"), defaultConfig.Timeout.String(), "") + return cmdFlags +} diff --git a/flyteplugins/go/tasks/plugins/k8s/kfoperators/common/config_flags_test.go b/flyteplugins/go/tasks/plugins/k8s/kfoperators/common/config_flags_test.go new file mode 100755 index 0000000000..0afdf456cd --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/kfoperators/common/config_flags_test.go @@ -0,0 +1,116 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package common + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "testing" + + "github.com/mitchellh/mapstructure" + "github.com/stretchr/testify/assert" +) + +var dereferencableKindsConfig = map[reflect.Kind]struct{}{ + reflect.Array: {}, reflect.Chan: {}, reflect.Map: {}, reflect.Ptr: {}, reflect.Slice: {}, +} + +// Checks if t is a kind that can be dereferenced to get its underlying type. +func canGetElementConfig(t reflect.Kind) bool { + _, exists := dereferencableKindsConfig[t] + return exists +} + +// This decoder hook tests types for json unmarshaling capability. If implemented, it uses json unmarshal to build the +// object. Otherwise, it'll just pass on the original data. +func jsonUnmarshalerHookConfig(_, to reflect.Type, data interface{}) (interface{}, error) { + unmarshalerType := reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + if to.Implements(unmarshalerType) || reflect.PtrTo(to).Implements(unmarshalerType) || + (canGetElementConfig(to.Kind()) && to.Elem().Implements(unmarshalerType)) { + + raw, err := json.Marshal(data) + if err != nil { + fmt.Printf("Failed to marshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + res := reflect.New(to).Interface() + err = json.Unmarshal(raw, &res) + if err != nil { + fmt.Printf("Failed to umarshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + return res, nil + } + + return data, nil +} + +func decode_Config(input, result interface{}) error { + config := &mapstructure.DecoderConfig{ + TagName: "json", + WeaklyTypedInput: true, + Result: result, + DecodeHook: mapstructure.ComposeDecodeHookFunc( + mapstructure.StringToTimeDurationHookFunc(), + mapstructure.StringToSliceHookFunc(","), + jsonUnmarshalerHookConfig, + ), + } + + decoder, err := mapstructure.NewDecoder(config) + if err != nil { + return err + } + + return decoder.Decode(input) +} + +func join_Config(arr interface{}, sep string) string { + listValue := reflect.ValueOf(arr) + strs := make([]string, 0, listValue.Len()) + for i := 0; i < listValue.Len(); i++ { + strs = append(strs, fmt.Sprintf("%v", listValue.Index(i))) + } + + return strings.Join(strs, sep) +} + +func testDecodeJson_Config(t *testing.T, val, result interface{}) { + assert.NoError(t, decode_Config(val, result)) +} + +func testDecodeRaw_Config(t *testing.T, vStringSlice, result interface{}) { + assert.NoError(t, decode_Config(vStringSlice, result)) +} + +func TestConfig_GetPFlagSet(t *testing.T) { + val := Config{} + cmdFlags := val.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) +} + +func TestConfig_SetFlags(t *testing.T) { + actual := Config{} + cmdFlags := actual.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) + + t.Run("Test_timeout", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := defaultConfig.Timeout.String() + + cmdFlags.Set("timeout", testValue) + if vString, err := cmdFlags.GetString("timeout"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.Timeout) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) +} diff --git a/flyteplugins/go/tasks/plugins/k8s/kfoperators/mpi/mpi.go b/flyteplugins/go/tasks/plugins/k8s/kfoperators/mpi/mpi.go new file mode 100644 index 0000000000..de71d52675 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/kfoperators/mpi/mpi.go @@ -0,0 +1,259 @@ +package mpi + +import ( + "context" + "fmt" + "strings" + "time" + + kubeflowv1 "github.com/kubeflow/training-operator/pkg/apis/kubeflow.org/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/kubernetes/scheme" + "sigs.k8s.io/controller-runtime/pkg/client" + + flyteerr "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery" + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/plugins/k8s/kfoperators/common" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" + kfplugins "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow" +) + +const workerSpecCommandKey = "worker_spec_command" + +type mpiOperatorResourceHandler struct { +} + +// Sanity test that the plugin implements method of k8s.Plugin +var _ k8s.Plugin = mpiOperatorResourceHandler{} + +func (mpiOperatorResourceHandler) GetProperties() k8s.PluginProperties { + return k8s.PluginProperties{} +} + +// Defines a func to create a query object (typically just object and type meta portions) that's used to query k8s +// resources. +func (mpiOperatorResourceHandler) BuildIdentityResource(ctx context.Context, taskCtx pluginsCore.TaskExecutionMetadata) (client.Object, error) { + return &kubeflowv1.MPIJob{ + TypeMeta: metav1.TypeMeta{ + Kind: kubeflowv1.MPIJobKind, + APIVersion: kubeflowv1.SchemeGroupVersion.String(), + }, + }, nil +} + +// Defines a func to create the full resource object that will be posted to k8s. +func (mpiOperatorResourceHandler) BuildResource(ctx context.Context, taskCtx pluginsCore.TaskExecutionContext) (client.Object, error) { + taskTemplate, err := taskCtx.TaskReader().Read(ctx) + + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "unable to fetch task specification [%v]", err.Error()) + } else if taskTemplate == nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "nil task specification") + } + + slots := int32(1) + runPolicy := kubeflowv1.RunPolicy{} + + var launcherReplicaSpec, workerReplicaSpec *kubeflowv1.ReplicaSpec + + if taskTemplate.TaskTypeVersion == 0 { + mpiTaskExtraArgs := plugins.DistributedMPITrainingTask{} + err = utils.UnmarshalStruct(taskTemplate.GetCustom(), &mpiTaskExtraArgs) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "invalid TaskSpecification [%v], Err: [%v]", taskTemplate.GetCustom(), err.Error()) + } + + replicaSpec, err := common.ToReplicaSpec(ctx, taskCtx, kubeflowv1.MPIJobDefaultContainerName) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "Unable to create replica spec: [%v]", err.Error()) + } + launcherReplicaSpec = replicaSpec.DeepCopy() + // TODO (jeev): Is this even a valid configuration. Can there be more than 1 + // launcher? TaskTypeVersion 1 does not support overriding this value. + launcherReplicas := mpiTaskExtraArgs.GetNumLauncherReplicas() + if launcherReplicas < 1 { + launcherReplicas = 1 + } + launcherReplicaSpec.Replicas = &launcherReplicas + workerReplicaSpec = replicaSpec.DeepCopy() + workerReplicas := mpiTaskExtraArgs.GetNumWorkers() + workerReplicaSpec.Replicas = &workerReplicas + slots = mpiTaskExtraArgs.GetSlots() + + // V1 requires passing worker command as template config parameter + taskTemplateConfig := taskTemplate.GetConfig() + workerSpecCommand := []string{} + if val, ok := taskTemplateConfig[workerSpecCommandKey]; ok { + workerSpecCommand = strings.Split(val, " ") + } + + for k := range workerReplicaSpec.Template.Spec.Containers { + if workerReplicaSpec.Template.Spec.Containers[k].Name == kubeflowv1.MPIJobDefaultContainerName { + workerReplicaSpec.Template.Spec.Containers[k].Args = workerSpecCommand + workerReplicaSpec.Template.Spec.Containers[k].Command = []string{} + } + } + + } else if taskTemplate.TaskTypeVersion == 1 { + kfMPITaskExtraArgs := kfplugins.DistributedMPITrainingTask{} + + err = utils.UnmarshalStruct(taskTemplate.GetCustom(), &kfMPITaskExtraArgs) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "invalid TaskSpecification [%v], Err: [%v]", taskTemplate.GetCustom(), err.Error()) + } + + launcherReplicaSpec, err = common.ToReplicaSpecWithOverrides(ctx, taskCtx, kfMPITaskExtraArgs.GetLauncherReplicas(), kubeflowv1.MPIJobDefaultContainerName, true) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "Unable to create launcher replica spec: [%v]", err.Error()) + } + + workerReplicaSpec, err = common.ToReplicaSpecWithOverrides(ctx, taskCtx, kfMPITaskExtraArgs.GetWorkerReplicas(), kubeflowv1.MPIJobDefaultContainerName, false) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "Unable to create worker replica spec: [%v]", err.Error()) + } + + if kfMPITaskExtraArgs.GetRunPolicy() != nil { + runPolicy = common.ParseRunPolicy(*kfMPITaskExtraArgs.GetRunPolicy()) + } + + } else { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, + "Invalid TaskSpecification, unsupported task template version [%v] key", taskTemplate.TaskTypeVersion) + } + + if *workerReplicaSpec.Replicas <= 0 { + return nil, fmt.Errorf("number of workers must be greater than 0") + } + if *launcherReplicaSpec.Replicas <= 0 { + return nil, fmt.Errorf("number of launchers must be greater than 0") + } + + jobSpec := kubeflowv1.MPIJobSpec{ + SlotsPerWorker: &slots, + RunPolicy: runPolicy, + MPIReplicaSpecs: map[kubeflowv1.ReplicaType]*kubeflowv1.ReplicaSpec{ + kubeflowv1.MPIJobReplicaTypeLauncher: launcherReplicaSpec, + kubeflowv1.MPIJobReplicaTypeWorker: workerReplicaSpec, + }, + } + + job := &kubeflowv1.MPIJob{ + TypeMeta: metav1.TypeMeta{ + Kind: kubeflowv1.MPIJobKind, + APIVersion: kubeflowv1.SchemeGroupVersion.String(), + }, + Spec: jobSpec, + } + + return job, nil +} + +// Analyzes the k8s resource and reports the status as TaskPhase. This call is expected to be relatively fast, +// any operations that might take a long time (limits are configured system-wide) should be offloaded to the +// background. +func (mpiOperatorResourceHandler) GetTaskPhase(ctx context.Context, pluginContext k8s.PluginContext, resource client.Object) (pluginsCore.PhaseInfo, error) { + var numWorkers, numLauncherReplicas *int32 + app, ok := resource.(*kubeflowv1.MPIJob) + if !ok { + return pluginsCore.PhaseInfoUndefined, fmt.Errorf("failed to convert resource data type") + } + + taskTemplate, err := pluginContext.TaskReader().Read(ctx) + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + + numWorkers = common.GetReplicaCount(app.Spec.MPIReplicaSpecs, kubeflowv1.MPIJobReplicaTypeWorker) + numLauncherReplicas = common.GetReplicaCount(app.Spec.MPIReplicaSpecs, kubeflowv1.MPIJobReplicaTypeLauncher) + + taskLogs, err := common.GetLogs(pluginContext, common.MPITaskType, app.ObjectMeta, taskTemplate, false, + *numWorkers, *numLauncherReplicas, 0, 0, kubeflowv1.MPIJobDefaultContainerName) + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + if app.Status.StartTime == nil && app.CreationTimestamp.Add(common.GetConfig().Timeout.Duration).Before(time.Now()) { + return pluginsCore.PhaseInfoUndefined, fmt.Errorf("kubeflow operator hasn't updated the mpi custom resource since creation time %v", app.CreationTimestamp) + } + currentCondition, err := common.ExtractCurrentCondition(app.Status.Conditions) + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + + occurredAt := time.Now() + statusDetails, _ := utils.MarshalObjToStruct(app.Status) + taskPhaseInfo := pluginsCore.TaskInfo{ + Logs: taskLogs, + LogContext: nil, // TODO populate log context + OccurredAt: &occurredAt, + CustomInfo: statusDetails, + } + + phaseInfo, err := common.GetPhaseInfo(currentCondition, occurredAt, taskPhaseInfo) + + phaseVersionUpdateErr := k8s.MaybeUpdatePhaseVersionFromPluginContext(&phaseInfo, &pluginContext) + if phaseVersionUpdateErr != nil { + return phaseInfo, phaseVersionUpdateErr + } + + return phaseInfo, err +} + +// IsTerminal returns true if the MPIJob is in a terminal state (Succeeded or Failed) +func (mpiOperatorResourceHandler) IsTerminal(_ context.Context, resource client.Object) (bool, error) { + job, ok := resource.(*kubeflowv1.MPIJob) + if !ok { + return false, fmt.Errorf("unexpected resource type: expected *MPIJob, got %T", resource) + } + for _, condition := range job.Status.Conditions { + if condition.Type == kubeflowv1.JobSucceeded || condition.Type == kubeflowv1.JobFailed { + return true, nil + } + } + return false, nil +} + +// GetCompletionTime returns the completion time of the MPIJob +func (mpiOperatorResourceHandler) GetCompletionTime(resource client.Object) (time.Time, error) { + job, ok := resource.(*kubeflowv1.MPIJob) + if !ok { + return time.Time{}, fmt.Errorf("unexpected resource type: expected *MPIJob, got %T", resource) + } + + if job.Status.CompletionTime != nil { + return job.Status.CompletionTime.Time, nil + } + + // Fallback to last condition transition time + for _, condition := range job.Status.Conditions { + if condition.Type == kubeflowv1.JobSucceeded || condition.Type == kubeflowv1.JobFailed { + if !condition.LastTransitionTime.IsZero() { + return condition.LastTransitionTime.Time, nil + } + } + } + + // Fallback to start time or creation time + if job.Status.StartTime != nil { + return job.Status.StartTime.Time, nil + } + + return job.CreationTimestamp.Time, nil +} + +func init() { + if err := kubeflowv1.AddToScheme(scheme.Scheme); err != nil { + panic(err) + } + + pluginmachinery.PluginRegistry().RegisterK8sPlugin( + k8s.PluginEntry{ + ID: common.MPITaskType, + RegisteredTaskTypes: []pluginsCore.TaskType{common.MPITaskType}, + ResourceToWatch: &kubeflowv1.MPIJob{}, + Plugin: mpiOperatorResourceHandler{}, + IsDefault: false, + }) +} diff --git a/flyteplugins/go/tasks/plugins/k8s/kfoperators/mpi/mpi_test.go b/flyteplugins/go/tasks/plugins/k8s/kfoperators/mpi/mpi_test.go new file mode 100644 index 0000000000..83cc1fba29 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/kfoperators/mpi/mpi_test.go @@ -0,0 +1,1135 @@ +package mpi + +import ( + "context" + "fmt" + "reflect" + "testing" + "time" + + structpb "github.com/golang/protobuf/ptypes/struct" + kubeflowv1 "github.com/kubeflow/training-operator/pkg/apis/kubeflow.org/v1" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/logs" + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s" + flytek8sConfig "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + pluginIOMocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + k8smocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/plugins/k8s/kfoperators/common" + stdlibUtils "github.com/flyteorg/flyte/v2/flytestdlib/utils" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" + kfplugins "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow" +) + +const testImage = "image://" +const serviceAccount = "mpi_sa" +const mpiID = "the job 1" +const mpiID2 = "the job 2" + +var ( + dummyEnvVars = []*core.KeyValuePair{ + {Key: "Env_Var", Value: "Env_Val"}, + } + + testArgs = []string{ + "test-args", + } + + dummyAnnotations = map[string]string{ + "annotation-key": "annotation-value", + } + dummyLabels = map[string]string{ + "label-key": "label-value", + } + + resourceRequirements = &corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("1000m"), + corev1.ResourceMemory: resource.MustParse("1Gi"), + }, + Requests: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("100m"), + corev1.ResourceMemory: resource.MustParse("512Mi"), + }, + } + + jobName = "the-job" + jobNamespace = "mpi-namespace" +) + +func dummyMPICustomObj(workers int32, launcher int32, slots int32) *plugins.DistributedMPITrainingTask { + return &plugins.DistributedMPITrainingTask{ + NumWorkers: workers, + NumLauncherReplicas: launcher, + Slots: slots, + } +} + +func dummyMPITaskTemplate(id string, args ...interface{}) *core.TaskTemplate { + + var mpiObjJSON string + var err error + + for _, arg := range args { + switch t := arg.(type) { + case *kfplugins.DistributedMPITrainingTask: + var mpiCustomObj = t + mpiObjJSON, err = utils.MarshalToString(mpiCustomObj) + case *plugins.DistributedMPITrainingTask: + var mpiCustomObj = t + mpiObjJSON, err = utils.MarshalToString(mpiCustomObj) + default: + err = fmt.Errorf("Unknown input type %T", t) + } + } + + if err != nil { + panic(err) + } + + structObj := structpb.Struct{} + + err = stdlibUtils.UnmarshalStringToPb(mpiObjJSON, &structObj) + if err != nil { + panic(err) + } + + return &core.TaskTemplate{ + Id: &core.Identifier{Name: id}, + Type: "container", + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Image: testImage, + Args: testArgs, + Env: dummyEnvVars, + }, + }, + Custom: &structObj, + } +} + +func dummyMPITaskContext(taskTemplate *core.TaskTemplate, resources *corev1.ResourceRequirements, extendedResources *core.ExtendedResources) pluginsCore.TaskExecutionContext { + taskCtx := &mocks.TaskExecutionContext{} + inputReader := &pluginIOMocks.InputReader{} + inputReader.EXPECT().GetInputPrefixPath().Return("/input/prefix") + inputReader.EXPECT().GetInputPath().Return("/input") + inputReader.EXPECT().Get(mock.Anything).Return(&core.LiteralMap{}, nil) + taskCtx.EXPECT().InputReader().Return(inputReader) + + outputReader := &pluginIOMocks.OutputWriter{} + outputReader.EXPECT().GetOutputPath().Return("/data/outputs.pb") + outputReader.EXPECT().GetOutputPrefixPath().Return("/data/") + outputReader.EXPECT().GetRawOutputPrefix().Return("") + outputReader.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + outputReader.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + taskCtx.EXPECT().OutputWriter().Return(outputReader) + + taskReader := &mocks.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(taskTemplate, nil) + taskCtx.EXPECT().TaskReader().Return(taskReader) + + tID := &mocks.TaskExecutionID{} + tID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my_name", + Project: "my_project", + Domain: "my_domain", + }, + }, + }) + tID.EXPECT().GetGeneratedName().Return("some-acceptable-name") + tID.EXPECT().GetUniqueNodeID().Return("an-unique-id") + + overrides := &mocks.TaskOverrides{} + overrides.EXPECT().GetResources().Return(resources) + overrides.EXPECT().GetExtendedResources().Return(extendedResources) + overrides.EXPECT().GetContainerImage().Return("") + overrides.EXPECT().GetPodTemplate().Return(nil) + + taskExecutionMetadata := &mocks.TaskExecutionMetadata{} + taskExecutionMetadata.EXPECT().GetTaskExecutionID().Return(tID) + taskExecutionMetadata.EXPECT().GetNamespace().Return("test-namespace") + taskExecutionMetadata.EXPECT().GetAnnotations().Return(dummyAnnotations) + taskExecutionMetadata.EXPECT().GetLabels().Return(dummyLabels) + taskExecutionMetadata.EXPECT().GetOwnerReference().Return(v1.OwnerReference{ + Kind: "node", + Name: "blah", + }) + taskExecutionMetadata.EXPECT().IsInterruptible().Return(true) + taskExecutionMetadata.EXPECT().GetOverrides().Return(overrides) + taskExecutionMetadata.EXPECT().GetK8sServiceAccount().Return(serviceAccount) + taskExecutionMetadata.EXPECT().GetPlatformResources().Return(&corev1.ResourceRequirements{}) + taskExecutionMetadata.EXPECT().GetEnvironmentVariables().Return(nil) + taskExecutionMetadata.EXPECT().GetConsoleURL().Return("") + taskCtx.EXPECT().TaskExecutionMetadata().Return(taskExecutionMetadata) + + pluginStateReaderMock := mocks.PluginStateReader{} + pluginStateReaderMock.EXPECT().Get(mock.AnythingOfType(reflect.TypeOf(&k8s.PluginState{}).String())).RunAndReturn( + func(v interface{}) (uint8, error) { + *(v.(*k8s.PluginState)) = k8s.PluginState{} + return 0, nil + }) + + taskCtx.EXPECT().PluginStateReader().Return(&pluginStateReaderMock) + return taskCtx +} + +func dummyMPIPluginContext(taskTemplate *core.TaskTemplate, resources *corev1.ResourceRequirements, extendedResources *core.ExtendedResources, pluginState k8s.PluginState) *k8smocks.PluginContext { + pCtx := &k8smocks.PluginContext{} + inputReader := &pluginIOMocks.InputReader{} + inputReader.EXPECT().GetInputPrefixPath().Return("/input/prefix") + inputReader.EXPECT().GetInputPath().Return("/input") + inputReader.EXPECT().Get(mock.Anything).Return(&core.LiteralMap{}, nil) + pCtx.EXPECT().InputReader().Return(inputReader) + + outputReader := &pluginIOMocks.OutputWriter{} + outputReader.EXPECT().GetOutputPath().Return("/data/outputs.pb") + outputReader.EXPECT().GetOutputPrefixPath().Return("/data/") + outputReader.EXPECT().GetRawOutputPrefix().Return("") + outputReader.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + outputReader.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + pCtx.EXPECT().OutputWriter().Return(outputReader) + + taskReader := &mocks.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(taskTemplate, nil) + pCtx.EXPECT().TaskReader().Return(taskReader) + + tID := &mocks.TaskExecutionID{} + tID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my_name", + Project: "my_project", + Domain: "my_domain", + }, + }, + }) + tID.EXPECT().GetGeneratedName().Return("some-acceptable-name") + tID.EXPECT().GetUniqueNodeID().Return("an-unique-id") + + overrides := &mocks.TaskOverrides{} + overrides.EXPECT().GetResources().Return(resources) + overrides.EXPECT().GetExtendedResources().Return(extendedResources) + overrides.EXPECT().GetContainerImage().Return("") + + taskExecutionMetadata := &mocks.TaskExecutionMetadata{} + taskExecutionMetadata.EXPECT().GetTaskExecutionID().Return(tID) + taskExecutionMetadata.EXPECT().GetNamespace().Return("test-namespace") + taskExecutionMetadata.EXPECT().GetAnnotations().Return(dummyAnnotations) + taskExecutionMetadata.EXPECT().GetLabels().Return(dummyLabels) + taskExecutionMetadata.EXPECT().GetOwnerReference().Return(v1.OwnerReference{ + Kind: "node", + Name: "blah", + }) + taskExecutionMetadata.EXPECT().IsInterruptible().Return(true) + taskExecutionMetadata.EXPECT().GetOverrides().Return(overrides) + taskExecutionMetadata.EXPECT().GetK8sServiceAccount().Return(serviceAccount) + taskExecutionMetadata.EXPECT().GetPlatformResources().Return(&corev1.ResourceRequirements{}) + taskExecutionMetadata.EXPECT().GetEnvironmentVariables().Return(nil) + taskExecutionMetadata.EXPECT().GetConsoleURL().Return("") + pCtx.EXPECT().TaskExecutionMetadata().Return(taskExecutionMetadata) + + pluginStateReaderMock := mocks.PluginStateReader{} + pluginStateReaderMock.EXPECT().Get(mock.AnythingOfType(reflect.TypeOf(&pluginState).String())).RunAndReturn( + func(v interface{}) (uint8, error) { + *(v.(*k8s.PluginState)) = pluginState + return 0, nil + }) + + pCtx.EXPECT().PluginStateReader().Return(&pluginStateReaderMock) + return pCtx +} + +func dummyMPIJobResource(mpiResourceHandler mpiOperatorResourceHandler, + workers int32, launcher int32, slots int32, conditionType kubeflowv1.JobConditionType) *kubeflowv1.MPIJob { + var jobConditions []kubeflowv1.JobCondition + + now := time.Now() + + jobCreated := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobCreated, + Status: corev1.ConditionTrue, + Reason: "MPICreated", + Message: "MPIJob the-job is created.", + LastUpdateTime: v1.Time{ + Time: now, + }, + LastTransitionTime: v1.Time{ + Time: now, + }, + } + jobRunningActive := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobRunning, + Status: corev1.ConditionTrue, + Reason: "MPIJobRunning", + Message: "MPIJob the-job is running.", + LastUpdateTime: v1.Time{ + Time: now.Add(time.Minute), + }, + LastTransitionTime: v1.Time{ + Time: now.Add(time.Minute), + }, + } + jobRunningInactive := *jobRunningActive.DeepCopy() + jobRunningInactive.Status = corev1.ConditionFalse + jobSucceeded := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobSucceeded, + Status: corev1.ConditionTrue, + Reason: "MPIJobSucceeded", + Message: "MPIJob the-job is successfully completed.", + LastUpdateTime: v1.Time{ + Time: now.Add(2 * time.Minute), + }, + LastTransitionTime: v1.Time{ + Time: now.Add(2 * time.Minute), + }, + } + jobFailed := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobFailed, + Status: corev1.ConditionTrue, + Reason: "MPIJobFailed", + Message: "MPIJob the-job is failed.", + LastUpdateTime: v1.Time{ + Time: now.Add(2 * time.Minute), + }, + LastTransitionTime: v1.Time{ + Time: now.Add(2 * time.Minute), + }, + } + jobRestarting := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobRestarting, + Status: corev1.ConditionTrue, + Reason: "MPIJobRestarting", + Message: "MPIJob the-job is restarting because some replica(s) failed.", + LastUpdateTime: v1.Time{ + Time: now.Add(3 * time.Minute), + }, + LastTransitionTime: v1.Time{ + Time: now.Add(3 * time.Minute), + }, + } + + switch conditionType { + case kubeflowv1.JobCreated: + jobConditions = []kubeflowv1.JobCondition{ + jobCreated, + } + case kubeflowv1.JobRunning: + jobConditions = []kubeflowv1.JobCondition{ + jobCreated, + jobRunningActive, + } + case kubeflowv1.JobSucceeded: + jobConditions = []kubeflowv1.JobCondition{ + jobCreated, + jobRunningInactive, + jobSucceeded, + } + case kubeflowv1.JobFailed: + jobConditions = []kubeflowv1.JobCondition{ + jobCreated, + jobRunningInactive, + jobFailed, + } + case kubeflowv1.JobRestarting: + jobConditions = []kubeflowv1.JobCondition{ + jobCreated, + jobRunningInactive, + jobFailed, + jobRestarting, + } + } + + mpiObj := dummyMPICustomObj(workers, launcher, slots) + taskTemplate := dummyMPITaskTemplate(mpiID, mpiObj) + resource, err := mpiResourceHandler.BuildResource(context.TODO(), dummyMPITaskContext(taskTemplate, resourceRequirements, nil)) + if err != nil { + panic(err) + } + + return &kubeflowv1.MPIJob{ + ObjectMeta: v1.ObjectMeta{ + Name: jobName, + Namespace: jobNamespace, + }, + Spec: resource.(*kubeflowv1.MPIJob).Spec, + Status: kubeflowv1.JobStatus{ + Conditions: jobConditions, + ReplicaStatuses: nil, + StartTime: &v1.Time{Time: time.Now()}, + CompletionTime: nil, + LastReconcileTime: nil, + }, + } +} + +func TestBuildResourceMPI(t *testing.T) { + mpiResourceHandler := mpiOperatorResourceHandler{} + + mpiObj := dummyMPICustomObj(100, 50, 1) + taskTemplate := dummyMPITaskTemplate(mpiID2, mpiObj) + + resource, err := mpiResourceHandler.BuildResource(context.TODO(), dummyMPITaskContext(taskTemplate, resourceRequirements, nil)) + assert.NoError(t, err) + assert.NotNil(t, resource) + + mpiJob, ok := resource.(*kubeflowv1.MPIJob) + assert.True(t, ok) + assert.Equal(t, int32(50), *mpiJob.Spec.MPIReplicaSpecs[kubeflowv1.MPIJobReplicaTypeLauncher].Replicas) + assert.Equal(t, int32(100), *mpiJob.Spec.MPIReplicaSpecs[kubeflowv1.MPIJobReplicaTypeWorker].Replicas) + assert.Equal(t, int32(1), *mpiJob.Spec.SlotsPerWorker) + + // verify TaskExecutionMetadata labels and annotations are copied to the MPIJob + for k, v := range dummyAnnotations { + for _, replicaSpec := range mpiJob.Spec.MPIReplicaSpecs { + assert.Equal(t, v, replicaSpec.Template.ObjectMeta.Annotations[k]) + } + } + for k, v := range dummyLabels { + for _, replicaSpec := range mpiJob.Spec.MPIReplicaSpecs { + assert.Equal(t, v, replicaSpec.Template.ObjectMeta.Labels[k]) + } + } + + for _, replicaSpec := range mpiJob.Spec.MPIReplicaSpecs { + for _, container := range replicaSpec.Template.Spec.Containers { + assert.Equal(t, resourceRequirements.Requests, container.Resources.Requests) + assert.Equal(t, resourceRequirements.Limits, container.Resources.Limits) + } + } +} + +func TestBuildResourceMPIForWrongInput(t *testing.T) { + mpiResourceHandler := mpiOperatorResourceHandler{} + + mpiObj := dummyMPICustomObj(0, 0, 1) + taskTemplate := dummyMPITaskTemplate(mpiID, mpiObj) + + _, err := mpiResourceHandler.BuildResource(context.TODO(), dummyMPITaskContext(taskTemplate, resourceRequirements, nil)) + assert.Error(t, err) + + mpiObj = dummyMPICustomObj(1, 1, 1) + taskTemplate = dummyMPITaskTemplate(mpiID2, mpiObj) + + resource, err := mpiResourceHandler.BuildResource(context.TODO(), dummyMPITaskContext(taskTemplate, resourceRequirements, nil)) + app, ok := resource.(*kubeflowv1.MPIJob) + assert.Nil(t, err) + assert.Equal(t, true, ok) + assert.Equal(t, []string{}, app.Spec.MPIReplicaSpecs[kubeflowv1.MPIJobReplicaTypeWorker].Template.Spec.Containers[0].Command) + assert.Equal(t, []string{}, app.Spec.MPIReplicaSpecs[kubeflowv1.MPIJobReplicaTypeWorker].Template.Spec.Containers[0].Args) +} + +func TestBuildResourceMPIExtendedResources(t *testing.T) { + assert.NoError(t, flytek8sConfig.SetK8sPluginConfig(&flytek8sConfig.K8sPluginConfig{ + GpuDeviceNodeLabel: "gpu-node-label", + GpuPartitionSizeNodeLabel: "gpu-partition-size", + GpuResourceName: flytek8s.ResourceNvidiaGPU, + AddTolerationsForExtendedResources: []string{"nvidia.com/gpu"}, + })) + + fixtures := []struct { + name string + resources *corev1.ResourceRequirements + extendedResourcesBase *core.ExtendedResources + extendedResourcesOverride *core.ExtendedResources + expectedNsr []corev1.NodeSelectorTerm + expectedTol []corev1.Toleration + }{ + { + "without overrides", + &corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-t4", + }, + }, + nil, + []corev1.NodeSelectorTerm{ + { + MatchExpressions: []corev1.NodeSelectorRequirement{ + corev1.NodeSelectorRequirement{ + Key: "gpu-node-label", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-t4"}, + }, + }, + }, + }, + []corev1.Toleration{ + { + Key: "gpu-node-label", + Value: "nvidia-tesla-t4", + Operator: corev1.TolerationOpEqual, + Effect: corev1.TaintEffectNoSchedule, + }, + { + Key: "nvidia.com/gpu", + Operator: corev1.TolerationOpExists, + Effect: corev1.TaintEffectNoSchedule, + }, + }, + }, + { + "with overrides", + &corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-t4", + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-a100", + PartitionSizeValue: &core.GPUAccelerator_PartitionSize{ + PartitionSize: "1g.5gb", + }, + }, + }, + []corev1.NodeSelectorTerm{ + { + MatchExpressions: []corev1.NodeSelectorRequirement{ + corev1.NodeSelectorRequirement{ + Key: "gpu-node-label", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-a100"}, + }, + corev1.NodeSelectorRequirement{ + Key: "gpu-partition-size", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"1g.5gb"}, + }, + }, + }, + }, + []corev1.Toleration{ + { + Key: "gpu-node-label", + Value: "nvidia-tesla-a100", + Operator: corev1.TolerationOpEqual, + Effect: corev1.TaintEffectNoSchedule, + }, + { + Key: "gpu-partition-size", + Value: "1g.5gb", + Operator: corev1.TolerationOpEqual, + Effect: corev1.TaintEffectNoSchedule, + }, + { + Key: "nvidia.com/gpu", + Operator: corev1.TolerationOpExists, + Effect: corev1.TaintEffectNoSchedule, + }, + }, + }, + } + + for _, f := range fixtures { + t.Run(f.name, func(t *testing.T) { + mpiObj := dummyMPICustomObj(100, 50, 1) + taskTemplate := dummyMPITaskTemplate(mpiID2, mpiObj) + taskTemplate.ExtendedResources = f.extendedResourcesBase + taskContext := dummyMPITaskContext(taskTemplate, f.resources, f.extendedResourcesOverride) + mpiResourceHandler := mpiOperatorResourceHandler{} + r, err := mpiResourceHandler.BuildResource(context.TODO(), taskContext) + assert.Nil(t, err) + assert.NotNil(t, r) + mpiJob, ok := r.(*kubeflowv1.MPIJob) + assert.True(t, ok) + + for _, replicaSpec := range mpiJob.Spec.MPIReplicaSpecs { + assert.EqualValues( + t, + f.expectedNsr, + replicaSpec.Template.Spec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + f.expectedTol, + replicaSpec.Template.Spec.Tolerations, + ) + } + }) + } +} + +func TestGetTaskPhase(t *testing.T) { + mpiResourceHandler := mpiOperatorResourceHandler{} + ctx := context.TODO() + + dummyMPIJobResourceCreator := func(conditionType kubeflowv1.JobConditionType) *kubeflowv1.MPIJob { + return dummyMPIJobResource(mpiResourceHandler, 2, 1, 1, conditionType) + } + + pluginContext := dummyMPIPluginContext(dummyMPITaskTemplate("", dummyMPICustomObj(2, 1, 1)), resourceRequirements, nil, k8s.PluginState{}) + taskPhase, err := mpiResourceHandler.GetTaskPhase(ctx, pluginContext, dummyMPIJobResourceCreator(kubeflowv1.JobCreated)) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseQueued, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + taskPhase, err = mpiResourceHandler.GetTaskPhase(ctx, pluginContext, dummyMPIJobResourceCreator(kubeflowv1.JobRunning)) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRunning, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + taskPhase, err = mpiResourceHandler.GetTaskPhase(ctx, pluginContext, dummyMPIJobResourceCreator(kubeflowv1.JobSucceeded)) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseSuccess, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + taskPhase, err = mpiResourceHandler.GetTaskPhase(ctx, pluginContext, dummyMPIJobResourceCreator(kubeflowv1.JobFailed)) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + taskPhase, err = mpiResourceHandler.GetTaskPhase(ctx, pluginContext, dummyMPIJobResourceCreator(kubeflowv1.JobRestarting)) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRunning, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) +} + +func TestGetTaskPhaseIncreasePhaseVersion(t *testing.T) { + mpiResourceHandler := mpiOperatorResourceHandler{} + ctx := context.TODO() + + pluginState := k8s.PluginState{ + Phase: pluginsCore.PhaseQueued, + PhaseVersion: pluginsCore.DefaultPhaseVersion, + Reason: "task submitted to K8s", + } + pluginContext := dummyMPIPluginContext(dummyMPITaskTemplate("", dummyMPICustomObj(2, 1, 1)), resourceRequirements, nil, pluginState) + + taskPhase, err := mpiResourceHandler.GetTaskPhase(ctx, pluginContext, dummyMPIJobResource(mpiResourceHandler, 2, 1, 1, kubeflowv1.JobCreated)) + + assert.NoError(t, err) + assert.Equal(t, taskPhase.Version(), pluginsCore.DefaultPhaseVersion+1) +} + +func TestGetLogs(t *testing.T) { + assert.NoError(t, logs.SetLogConfig(&logs.LogConfig{ + IsKubernetesEnabled: true, + KubernetesURL: "k8s.com", + })) + + workers := int32(2) + launcher := int32(1) + slots := int32(1) + + mpiResourceHandler := mpiOperatorResourceHandler{} + mpiJob := dummyMPIJobResource(mpiResourceHandler, workers, launcher, slots, kubeflowv1.JobRunning) + taskTemplate := dummyMPITaskTemplate("", dummyMPICustomObj(workers, launcher, slots)) + pluginContext := dummyMPIPluginContext(taskTemplate, resourceRequirements, nil, k8s.PluginState{}) + jobLogs, err := common.GetLogs(pluginContext, common.MPITaskType, mpiJob.ObjectMeta, taskTemplate, false, workers, launcher, 0, 0, kubeflowv1.MPIJobDefaultContainerName) + + assert.NoError(t, err) + assert.Equal(t, 2, len(jobLogs)) + assert.Equal(t, fmt.Sprintf("k8s.com/#!/log/%s/%s-worker-0/pod?namespace=mpi-namespace", jobNamespace, jobName), jobLogs[0].Uri) + assert.Equal(t, fmt.Sprintf("k8s.com/#!/log/%s/%s-worker-1/pod?namespace=mpi-namespace", jobNamespace, jobName), jobLogs[1].Uri) +} + +func TestGetProperties(t *testing.T) { + mpiResourceHandler := mpiOperatorResourceHandler{} + expected := k8s.PluginProperties{} + assert.Equal(t, expected, mpiResourceHandler.GetProperties()) +} + +func TestReplicaCounts(t *testing.T) { + for _, test := range []struct { + name string + launcherReplicaCount int32 + workerReplicaCount int32 + expectError bool + contains []kubeflowv1.ReplicaType + notContains []kubeflowv1.ReplicaType + }{ + {"NoWorkers", 1, 0, true, nil, nil}, + {"Minimum One Launcher", 0, 1, false, []kubeflowv1.ReplicaType{kubeflowv1.MPIJobReplicaTypeLauncher, kubeflowv1.MPIJobReplicaTypeWorker}, []kubeflowv1.ReplicaType{}}, + {"Works", 1, 1, false, []kubeflowv1.ReplicaType{kubeflowv1.MPIJobReplicaTypeLauncher, kubeflowv1.MPIJobReplicaTypeWorker}, []kubeflowv1.ReplicaType{}}, + } { + t.Run(test.name, func(t *testing.T) { + mpiResourceHandler := mpiOperatorResourceHandler{} + + mpiObj := dummyMPICustomObj(test.workerReplicaCount, test.launcherReplicaCount, 1) + taskTemplate := dummyMPITaskTemplate(mpiID2, mpiObj) + + resource, err := mpiResourceHandler.BuildResource(context.TODO(), dummyMPITaskContext(taskTemplate, resourceRequirements, nil)) + if test.expectError { + assert.Error(t, err) + assert.Nil(t, resource) + return + } + + assert.NoError(t, err) + assert.NotNil(t, resource) + + job, ok := resource.(*kubeflowv1.MPIJob) + assert.True(t, ok) + + assert.Len(t, job.Spec.MPIReplicaSpecs, len(test.contains)) + for _, replicaType := range test.contains { + assert.Contains(t, job.Spec.MPIReplicaSpecs, replicaType) + } + for _, replicaType := range test.notContains { + assert.NotContains(t, job.Spec.MPIReplicaSpecs, replicaType) + } + }) + } +} + +func TestBuildResourceMPIV1(t *testing.T) { + launcherCommand := []string{"python", "launcher.py"} + workerCommand := []string{"/usr/sbin/sshd", "/.sshd_config"} + taskConfigs := []*kfplugins.DistributedMPITrainingTask{ + { + LauncherReplicas: &kfplugins.DistributedMPITrainingReplicaSpec{ + Image: testImage, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + {Name: core.Resources_MEMORY, Value: "250Mi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "500m"}, + {Name: core.Resources_MEMORY, Value: "500Mi"}, + }, + }, + Command: launcherCommand, + }, + WorkerReplicas: &kfplugins.DistributedMPITrainingReplicaSpec{ + Replicas: 100, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "2048m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + }, + }, + Command: workerCommand, + }, + Slots: int32(1), + }, + { + LauncherReplicas: &kfplugins.DistributedMPITrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Image: testImage, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + {Name: core.Resources_MEMORY, Value: "250Mi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "500m"}, + {Name: core.Resources_MEMORY, Value: "500Mi"}, + }, + }, + }, + Command: launcherCommand, + }, + WorkerReplicas: &kfplugins.DistributedMPITrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 100, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "2048m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + }, + }, + }, + Command: workerCommand, + }, + Slots: int32(1), + }, + } + + for _, taskConfig := range taskConfigs { + launcherResourceRequirements := &corev1.ResourceRequirements{ + Requests: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("250m"), + corev1.ResourceMemory: resource.MustParse("250Mi"), + }, + Limits: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("500m"), + corev1.ResourceMemory: resource.MustParse("500Mi"), + }, + } + + workerResourceRequirements := &corev1.ResourceRequirements{ + Requests: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("1024m"), + corev1.ResourceMemory: resource.MustParse("1Gi"), + }, + Limits: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("2048m"), + corev1.ResourceMemory: resource.MustParse("2Gi"), + }, + } + + mpiResourceHandler := mpiOperatorResourceHandler{} + + taskTemplate := dummyMPITaskTemplate(mpiID2, taskConfig) + taskTemplate.TaskTypeVersion = 1 + + resource, err := mpiResourceHandler.BuildResource(context.TODO(), dummyMPITaskContext(taskTemplate, resourceRequirements, nil)) + assert.NoError(t, err) + assert.NotNil(t, resource) + + mpiJob, ok := resource.(*kubeflowv1.MPIJob) + assert.True(t, ok) + assert.Equal(t, int32(1), *mpiJob.Spec.MPIReplicaSpecs[kubeflowv1.MPIJobReplicaTypeLauncher].Replicas) + assert.Equal(t, int32(100), *mpiJob.Spec.MPIReplicaSpecs[kubeflowv1.MPIJobReplicaTypeWorker].Replicas) + assert.Equal(t, int32(1), *mpiJob.Spec.SlotsPerWorker) + assert.Equal(t, *launcherResourceRequirements, mpiJob.Spec.MPIReplicaSpecs[kubeflowv1.MPIJobReplicaTypeLauncher].Template.Spec.Containers[0].Resources) + assert.Equal(t, *workerResourceRequirements, mpiJob.Spec.MPIReplicaSpecs[kubeflowv1.MPIJobReplicaTypeWorker].Template.Spec.Containers[0].Resources) + assert.Equal(t, launcherCommand, mpiJob.Spec.MPIReplicaSpecs[kubeflowv1.MPIJobReplicaTypeLauncher].Template.Spec.Containers[0].Args) + assert.Equal(t, workerCommand, mpiJob.Spec.MPIReplicaSpecs[kubeflowv1.MPIJobReplicaTypeWorker].Template.Spec.Containers[0].Args) + } +} + +func TestBuildResourceMPIV1WithOnlyWorkerReplica(t *testing.T) { + workerCommand := []string{"/usr/sbin/sshd", "/.sshd_config"} + + taskConfigs := []*kfplugins.DistributedMPITrainingTask{ + { + WorkerReplicas: &kfplugins.DistributedMPITrainingReplicaSpec{ + Replicas: 100, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "2048m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + }, + }, + Command: []string{"/usr/sbin/sshd", "/.sshd_config"}, + }, + Slots: int32(1), + }, + { + WorkerReplicas: &kfplugins.DistributedMPITrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 100, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "2048m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + }, + }, + }, + Command: []string{"/usr/sbin/sshd", "/.sshd_config"}, + }, + Slots: int32(1), + }, + } + + for _, taskConfig := range taskConfigs { + workerResourceRequirements := &corev1.ResourceRequirements{ + Requests: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("1024m"), + corev1.ResourceMemory: resource.MustParse("1Gi"), + }, + Limits: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("2048m"), + corev1.ResourceMemory: resource.MustParse("2Gi"), + }, + } + + mpiResourceHandler := mpiOperatorResourceHandler{} + + taskTemplate := dummyMPITaskTemplate(mpiID2, taskConfig) + taskTemplate.TaskTypeVersion = 1 + + resource, err := mpiResourceHandler.BuildResource(context.TODO(), dummyMPITaskContext(taskTemplate, resourceRequirements, nil)) + assert.NoError(t, err) + assert.NotNil(t, resource) + + mpiJob, ok := resource.(*kubeflowv1.MPIJob) + assert.True(t, ok) + assert.Equal(t, int32(1), *mpiJob.Spec.MPIReplicaSpecs[kubeflowv1.MPIJobReplicaTypeLauncher].Replicas) + assert.Equal(t, int32(100), *mpiJob.Spec.MPIReplicaSpecs[kubeflowv1.MPIJobReplicaTypeWorker].Replicas) + assert.Equal(t, int32(1), *mpiJob.Spec.SlotsPerWorker) + assert.Equal(t, *workerResourceRequirements, mpiJob.Spec.MPIReplicaSpecs[kubeflowv1.MPIJobReplicaTypeWorker].Template.Spec.Containers[0].Resources) + assert.Equal(t, testArgs, mpiJob.Spec.MPIReplicaSpecs[kubeflowv1.MPIJobReplicaTypeLauncher].Template.Spec.Containers[0].Args) + assert.Equal(t, workerCommand, mpiJob.Spec.MPIReplicaSpecs[kubeflowv1.MPIJobReplicaTypeWorker].Template.Spec.Containers[0].Args) + } +} + +func TestBuildResourceMPIV1ResourceTolerations(t *testing.T) { + gpuToleration := corev1.Toleration{ + Key: "nvidia.com/gpu", + Value: "present", + Operator: corev1.TolerationOpEqual, + Effect: corev1.TaintEffectNoSchedule, + } + assert.NoError(t, flytek8sConfig.SetK8sPluginConfig(&flytek8sConfig.K8sPluginConfig{ + GpuResourceName: flytek8s.ResourceNvidiaGPU, + ResourceTolerations: map[corev1.ResourceName][]corev1.Toleration{ + flytek8s.ResourceNvidiaGPU: {gpuToleration}, + }, + })) + + taskConfigs := []*kfplugins.DistributedMPITrainingTask{ + { + LauncherReplicas: &kfplugins.DistributedMPITrainingReplicaSpec{ + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + {Name: core.Resources_MEMORY, Value: "250Mi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "500m"}, + {Name: core.Resources_MEMORY, Value: "500Mi"}, + }, + }, + }, + WorkerReplicas: &kfplugins.DistributedMPITrainingReplicaSpec{ + Replicas: 100, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "2048m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + }, + }, + }, + { + LauncherReplicas: &kfplugins.DistributedMPITrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + {Name: core.Resources_MEMORY, Value: "250Mi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "500m"}, + {Name: core.Resources_MEMORY, Value: "500Mi"}, + }, + }, + }, + }, + WorkerReplicas: &kfplugins.DistributedMPITrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 100, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "2048m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + }, + }, + }, + }, + } + + for _, taskConfig := range taskConfigs { + mpiResourceHandler := mpiOperatorResourceHandler{} + + taskTemplate := dummyMPITaskTemplate(mpiID2, taskConfig) + taskTemplate.TaskTypeVersion = 1 + + resource, err := mpiResourceHandler.BuildResource(context.TODO(), dummyMPITaskContext(taskTemplate, resourceRequirements, nil)) + assert.NoError(t, err) + assert.NotNil(t, resource) + + mpiJob, ok := resource.(*kubeflowv1.MPIJob) + assert.True(t, ok) + + assert.NotContains(t, mpiJob.Spec.MPIReplicaSpecs[kubeflowv1.MPIJobReplicaTypeLauncher].Template.Spec.Tolerations, gpuToleration) + assert.Contains(t, mpiJob.Spec.MPIReplicaSpecs[kubeflowv1.MPIJobReplicaTypeWorker].Template.Spec.Tolerations, gpuToleration) + } +} + +func TestGetReplicaCount(t *testing.T) { + mpiResourceHandler := mpiOperatorResourceHandler{} + tfObj := dummyMPICustomObj(1, 1, 0) + taskTemplate := dummyMPITaskTemplate("the job", tfObj) + resource, err := mpiResourceHandler.BuildResource(context.TODO(), dummyMPITaskContext(taskTemplate, resourceRequirements, nil)) + assert.NoError(t, err) + assert.NotNil(t, resource) + MPIJob, ok := resource.(*kubeflowv1.MPIJob) + assert.True(t, ok) + + assert.NotNil(t, common.GetReplicaCount(MPIJob.Spec.MPIReplicaSpecs, kubeflowv1.MPIJobReplicaTypeWorker)) + assert.NotNil(t, common.GetReplicaCount(MPIJob.Spec.MPIReplicaSpecs, kubeflowv1.MPIJobReplicaTypeLauncher)) +} + +func TestIsTerminal(t *testing.T) { + mpiResourceHandler := mpiOperatorResourceHandler{} + ctx := context.Background() + + tests := []struct { + name string + conditionType kubeflowv1.JobConditionType + expectedResult bool + }{ + {"Succeeded", kubeflowv1.JobSucceeded, true}, + {"Failed", kubeflowv1.JobFailed, true}, + {"Created", kubeflowv1.JobCreated, false}, + {"Running", kubeflowv1.JobRunning, false}, + {"Restarting", kubeflowv1.JobRestarting, false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // Create a simple job with only the condition we want to test + job := &kubeflowv1.MPIJob{ + Status: kubeflowv1.JobStatus{ + Conditions: []kubeflowv1.JobCondition{ + { + Type: tt.conditionType, + Status: corev1.ConditionTrue, + }, + }, + }, + } + result, err := mpiResourceHandler.IsTerminal(ctx, job) + assert.NoError(t, err) + assert.Equal(t, tt.expectedResult, result) + }) + } +} + +func TestIsTerminal_WrongResourceType(t *testing.T) { + mpiResourceHandler := mpiOperatorResourceHandler{} + ctx := context.Background() + + wrongResource := &corev1.ConfigMap{} + result, err := mpiResourceHandler.IsTerminal(ctx, wrongResource) + assert.Error(t, err) + assert.False(t, result) + assert.Contains(t, err.Error(), "unexpected resource type") +} + +func TestGetCompletionTime(t *testing.T) { + mpiResourceHandler := mpiOperatorResourceHandler{} + + now := time.Now().Truncate(time.Second) + earlier := now.Add(-1 * time.Hour) + evenEarlier := now.Add(-2 * time.Hour) + + tests := []struct { + name string + job *kubeflowv1.MPIJob + expectedTime time.Time + }{ + { + name: "uses CompletionTime", + job: &kubeflowv1.MPIJob{ + ObjectMeta: v1.ObjectMeta{ + CreationTimestamp: v1.NewTime(evenEarlier), + }, + Status: kubeflowv1.JobStatus{ + CompletionTime: &v1.Time{Time: now}, + StartTime: &v1.Time{Time: earlier}, + }, + }, + expectedTime: now, + }, + { + name: "falls back to condition LastTransitionTime", + job: &kubeflowv1.MPIJob{ + ObjectMeta: v1.ObjectMeta{ + CreationTimestamp: v1.NewTime(evenEarlier), + }, + Status: kubeflowv1.JobStatus{ + StartTime: &v1.Time{Time: earlier}, + Conditions: []kubeflowv1.JobCondition{ + { + Type: kubeflowv1.JobSucceeded, + Status: corev1.ConditionTrue, + LastTransitionTime: v1.NewTime(now), + }, + }, + }, + }, + expectedTime: now, + }, + { + name: "falls back to StartTime", + job: &kubeflowv1.MPIJob{ + ObjectMeta: v1.ObjectMeta{ + CreationTimestamp: v1.NewTime(evenEarlier), + }, + Status: kubeflowv1.JobStatus{ + StartTime: &v1.Time{Time: now}, + }, + }, + expectedTime: now, + }, + { + name: "falls back to CreationTimestamp", + job: &kubeflowv1.MPIJob{ + ObjectMeta: v1.ObjectMeta{ + CreationTimestamp: v1.NewTime(now), + }, + Status: kubeflowv1.JobStatus{}, + }, + expectedTime: now, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result, err := mpiResourceHandler.GetCompletionTime(tt.job) + assert.NoError(t, err) + assert.Equal(t, tt.expectedTime.Unix(), result.Unix()) + }) + } +} + +func TestGetCompletionTime_WrongResourceType(t *testing.T) { + mpiResourceHandler := mpiOperatorResourceHandler{} + + wrongResource := &corev1.ConfigMap{} + result, err := mpiResourceHandler.GetCompletionTime(wrongResource) + assert.Error(t, err) + assert.True(t, result.IsZero()) + assert.Contains(t, err.Error(), "unexpected resource type") +} diff --git a/flyteplugins/go/tasks/plugins/k8s/kfoperators/pytorch/pytorch.go b/flyteplugins/go/tasks/plugins/k8s/kfoperators/pytorch/pytorch.go new file mode 100644 index 0000000000..f1b1532768 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/kfoperators/pytorch/pytorch.go @@ -0,0 +1,320 @@ +package pytorch + +import ( + "context" + "fmt" + "strings" + "time" + + kubeflowv1 "github.com/kubeflow/training-operator/pkg/apis/kubeflow.org/v1" + "github.com/samber/lo" + v1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/kubernetes/scheme" + "sigs.k8s.io/controller-runtime/pkg/client" + + flyteerr "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery" + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/plugins/k8s/kfoperators/common" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" + kfplugins "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow" +) + +type pytorchOperatorResourceHandler struct { +} + +// Sanity test that the plugin implements method of k8s.Plugin +var _ k8s.Plugin = pytorchOperatorResourceHandler{} + +func (pytorchOperatorResourceHandler) GetProperties() k8s.PluginProperties { + return k8s.PluginProperties{} +} + +// Defines a func to create a query object (typically just object and type meta portions) that's used to query k8s +// resources. +func (pytorchOperatorResourceHandler) BuildIdentityResource(ctx context.Context, taskCtx pluginsCore.TaskExecutionMetadata) (client.Object, error) { + return &kubeflowv1.PyTorchJob{ + TypeMeta: metav1.TypeMeta{ + Kind: kubeflowv1.PyTorchJobKind, + APIVersion: kubeflowv1.SchemeGroupVersion.String(), + }, + }, nil +} + +// Defines a func to create the full resource object that will be posted to k8s. +func (pytorchOperatorResourceHandler) BuildResource(ctx context.Context, taskCtx pluginsCore.TaskExecutionContext) (client.Object, error) { + taskTemplate, err := taskCtx.TaskReader().Read(ctx) + + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "unable to fetch task specification [%v]", err.Error()) + } else if taskTemplate == nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "nil task specification") + } + + runPolicy := kubeflowv1.RunPolicy{} + var elasticPolicy *kubeflowv1.ElasticPolicy + + var masterReplicaSpec, workerReplicaSpec *kubeflowv1.ReplicaSpec + + if taskTemplate.TaskTypeVersion == 0 { + pytorchTaskExtraArgs := plugins.DistributedPyTorchTrainingTask{} + + err = utils.UnmarshalStruct(taskTemplate.GetCustom(), &pytorchTaskExtraArgs) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "invalid TaskSpecification [%v], Err: [%v]", taskTemplate.GetCustom(), err.Error()) + } + + replicaSpec, err := common.ToReplicaSpec(ctx, taskCtx, kubeflowv1.PyTorchJobDefaultContainerName) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "Unable to create replica spec: [%v]", err.Error()) + } + masterReplicaSpec = replicaSpec.DeepCopy() + masterReplicas := int32(1) + masterReplicaSpec.Replicas = &masterReplicas + workerReplicaSpec = replicaSpec.DeepCopy() + workerReplicas := pytorchTaskExtraArgs.GetWorkers() + workerReplicaSpec.Replicas = &workerReplicas + + // Set elastic config + elasticConfig := pytorchTaskExtraArgs.GetElasticConfig() + if elasticConfig != nil { + elasticPolicy = ParseElasticConfig(elasticConfig) + } + } else if taskTemplate.TaskTypeVersion == 1 { + kfPytorchTaskExtraArgs := kfplugins.DistributedPyTorchTrainingTask{} + + err = utils.UnmarshalStruct(taskTemplate.GetCustom(), &kfPytorchTaskExtraArgs) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "invalid TaskSpecification [%v], Err: [%v]", taskTemplate.GetCustom(), err.Error()) + } + + masterReplicaSpec, err = common.ToReplicaSpecWithOverrides(ctx, taskCtx, kfPytorchTaskExtraArgs.GetMasterReplicas(), kubeflowv1.PyTorchJobDefaultContainerName, true) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "Unable to create master replica spec: [%v]", err.Error()) + } + + workerReplicaSpec, err = common.ToReplicaSpecWithOverrides(ctx, taskCtx, kfPytorchTaskExtraArgs.GetWorkerReplicas(), kubeflowv1.PyTorchJobDefaultContainerName, false) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "Unable to create worker replica spec: [%v]", err.Error()) + } + + if kfPytorchTaskExtraArgs.GetRunPolicy() != nil { + runPolicy = common.ParseRunPolicy(*kfPytorchTaskExtraArgs.GetRunPolicy()) + } + // Set elastic config + elasticConfig := kfPytorchTaskExtraArgs.GetElasticConfig() + if elasticConfig != nil { + elasticPolicy = ParseElasticConfig(elasticConfig) + } + } else { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, + "Invalid TaskSpecification, unsupported task template version [%v] key", taskTemplate.TaskTypeVersion) + } + + if *workerReplicaSpec.Replicas <= 0 { + return nil, fmt.Errorf("number of workers must be greater than 0") + } + + jobSpec := kubeflowv1.PyTorchJobSpec{ + PyTorchReplicaSpecs: map[kubeflowv1.ReplicaType]*kubeflowv1.ReplicaSpec{ + kubeflowv1.PyTorchJobReplicaTypeMaster: masterReplicaSpec, + kubeflowv1.PyTorchJobReplicaTypeWorker: workerReplicaSpec, + }, + RunPolicy: runPolicy, + } + + if elasticPolicy != nil { + jobSpec.ElasticPolicy = elasticPolicy + // Remove master replica spec if elastic policy is set + delete(jobSpec.PyTorchReplicaSpecs, kubeflowv1.PyTorchJobReplicaTypeMaster) + } + + job := &kubeflowv1.PyTorchJob{ + TypeMeta: metav1.TypeMeta{ + Kind: kubeflowv1.PyTorchJobKind, + APIVersion: kubeflowv1.SchemeGroupVersion.String(), + }, + Spec: jobSpec, + } + + return job, nil +} + +// Interface for unified elastic config handling across plugin version v0 and v1. This interface should +// always be aligned with the ElasticConfig defined in flyteidl. +type ElasticConfig interface { + GetMinReplicas() int32 + GetMaxReplicas() int32 + GetNprocPerNode() int32 + GetMaxRestarts() int32 + GetRdzvBackend() string +} + +// To support parsing elastic config from both v0 and v1 of kubeflow pytorch idl +func ParseElasticConfig(elasticConfig ElasticConfig) *kubeflowv1.ElasticPolicy { + minReplicas := elasticConfig.GetMinReplicas() + maxReplicas := elasticConfig.GetMaxReplicas() + nProcPerNode := elasticConfig.GetNprocPerNode() + maxRestarts := elasticConfig.GetMaxRestarts() + rdzvBackend := kubeflowv1.RDZVBackend(elasticConfig.GetRdzvBackend()) + return &kubeflowv1.ElasticPolicy{ + MinReplicas: &minReplicas, + MaxReplicas: &maxReplicas, + RDZVBackend: &rdzvBackend, + NProcPerNode: &nProcPerNode, + MaxRestarts: &maxRestarts, + } +} + +// Analyses the k8s resource and reports the status as TaskPhase. This call is expected to be relatively fast, +// any operations that might take a long time (limits are configured system-wide) should be offloaded to the +// background. +func (pytorchOperatorResourceHandler) GetTaskPhase(ctx context.Context, pluginContext k8s.PluginContext, resource client.Object) (pluginsCore.PhaseInfo, error) { + app, ok := resource.(*kubeflowv1.PyTorchJob) + if !ok { + return pluginsCore.PhaseInfoUndefined, fmt.Errorf("failed to convert resource data type") + } + + // Elastic PytorchJobs don't use master replicas + hasMaster := false + if _, ok := app.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeMaster]; ok { + hasMaster = true + } + + workersCount := common.GetReplicaCount(app.Spec.PyTorchReplicaSpecs, kubeflowv1.PyTorchJobReplicaTypeWorker) + + taskTemplate, err := pluginContext.TaskReader().Read(ctx) + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + + taskLogs, err := common.GetLogs(pluginContext, common.PytorchTaskType, app.ObjectMeta, taskTemplate, hasMaster, *workersCount, 0, 0, 0, kubeflowv1.PyTorchJobDefaultContainerName) + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + + if app.Status.StartTime == nil && app.CreationTimestamp.Add(common.GetConfig().Timeout.Duration).Before(time.Now()) { + return pluginsCore.PhaseInfoUndefined, fmt.Errorf("kubeflow operator hasn't updated the pytorch custom resource since creation time %v", app.CreationTimestamp) + } + currentCondition, err := common.ExtractCurrentCondition(app.Status.Conditions) + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + + occurredAt := time.Now() + statusDetails, _ := utils.MarshalObjToStruct(app.Status) + podList := &v1.PodList{} + err = pluginContext.K8sReader().List(ctx, podList) + if err != nil { + return pluginsCore.PhaseInfoUndefined, fmt.Errorf("failed to list pytorch execution pods. Error: %w", err) + } + logger.Debugf(ctx, "podlist: %+v", podList) + taskPhaseInfo := pluginsCore.TaskInfo{ + Logs: taskLogs, + LogContext: logContextForPods(app.Name, podList.Items), + OccurredAt: &occurredAt, + CustomInfo: statusDetails, + } + var phaseInfo pluginsCore.PhaseInfo + podName := fmt.Sprintf("%s-%s", app.Name, "worker-0") + phaseInfo, err = flytek8s.DemystifyFailedOrPendingPod(ctx, pluginContext, taskPhaseInfo, app.Namespace, podName, "pytorch") + if err != nil { + logger.Errorf(ctx, "Failed to demystify pod status for pytorch worker-0/master. Error: %v", err) + } + if phaseInfo.Phase().IsFailure() { + // If the master node or worker-0 is in a failure state, we can fail fast without checking the PytorchJob status. + return phaseInfo, nil + } + logger.Debugf(ctx, "logcontext: %+v", taskPhaseInfo.LogContext) + logger.Debugf(ctx, "PyTorchJob phase is %s", phaseInfo.Phase()) + logger.Debugf(ctx, "PytorchJob currentCondition: %v", currentCondition) + phaseInfo, err = common.GetPhaseInfo(currentCondition, occurredAt, taskPhaseInfo) + + phaseVersionUpdateErr := k8s.MaybeUpdatePhaseVersionFromPluginContext(&phaseInfo, &pluginContext) + if phaseVersionUpdateErr != nil { + return phaseInfo, phaseVersionUpdateErr + } + + return phaseInfo, err +} + +func logContextForPods(pytorchJobName string, pods []v1.Pod) *core.LogContext { + pods = lo.Filter(pods, func(item v1.Pod, _ int) bool { + // Running, Succeeded or Failed is OK + return item.Status.Phase != v1.PodPending + }) + logCtx := &core.LogContext{ + Pods: make([]*core.PodLogContext, len(pods)), + } + for i, pod := range pods { + p := pod + if strings.HasPrefix(p.Name, pytorchJobName) && strings.Contains(p.Name, "worker-0") { + logCtx.PrimaryPodName = p.Name + } + logCtx.Pods[i] = flytek8s.BuildPodLogContext(&p) + } + return logCtx +} + +// IsTerminal returns true if the PyTorchJob is in a terminal state (Succeeded or Failed) +func (pytorchOperatorResourceHandler) IsTerminal(_ context.Context, resource client.Object) (bool, error) { + job, ok := resource.(*kubeflowv1.PyTorchJob) + if !ok { + return false, fmt.Errorf("unexpected resource type: expected *PyTorchJob, got %T", resource) + } + for _, condition := range job.Status.Conditions { + if condition.Type == kubeflowv1.JobSucceeded || condition.Type == kubeflowv1.JobFailed { + return true, nil + } + } + return false, nil +} + +// GetCompletionTime returns the completion time of the PyTorchJob +func (pytorchOperatorResourceHandler) GetCompletionTime(resource client.Object) (time.Time, error) { + job, ok := resource.(*kubeflowv1.PyTorchJob) + if !ok { + return time.Time{}, fmt.Errorf("unexpected resource type: expected *PyTorchJob, got %T", resource) + } + + if job.Status.CompletionTime != nil { + return job.Status.CompletionTime.Time, nil + } + + // Fallback to last condition transition time + for _, condition := range job.Status.Conditions { + if condition.Type == kubeflowv1.JobSucceeded || condition.Type == kubeflowv1.JobFailed { + if !condition.LastTransitionTime.IsZero() { + return condition.LastTransitionTime.Time, nil + } + } + } + + // Fallback to start time or creation time + if job.Status.StartTime != nil { + return job.Status.StartTime.Time, nil + } + + return job.CreationTimestamp.Time, nil +} + +func init() { + if err := kubeflowv1.AddToScheme(scheme.Scheme); err != nil { + panic(err) + } + + pluginmachinery.PluginRegistry().RegisterK8sPlugin( + k8s.PluginEntry{ + ID: common.PytorchTaskType, + RegisteredTaskTypes: []pluginsCore.TaskType{common.PytorchTaskType}, + ResourceToWatch: &kubeflowv1.PyTorchJob{}, + Plugin: pytorchOperatorResourceHandler{}, + IsDefault: false, + }) +} diff --git a/flyteplugins/go/tasks/plugins/k8s/kfoperators/pytorch/pytorch_test.go b/flyteplugins/go/tasks/plugins/k8s/kfoperators/pytorch/pytorch_test.go new file mode 100644 index 0000000000..3f4e4115ca --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/kfoperators/pytorch/pytorch_test.go @@ -0,0 +1,1557 @@ +package pytorch + +import ( + "context" + "fmt" + "reflect" + "testing" + "time" + + structpb "github.com/golang/protobuf/ptypes/struct" + kubeflowv1 "github.com/kubeflow/training-operator/pkg/apis/kubeflow.org/v1" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "sigs.k8s.io/controller-runtime/pkg/client/fake" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/logs" + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s" + flytek8sConfig "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + pluginIOMocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + k8smocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/plugins/k8s/kfoperators/common" + stdlibUtils "github.com/flyteorg/flyte/v2/flytestdlib/utils" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" + kfplugins "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow" +) + +const testImage = "image://" +const testImageMaster = "image://master" +const serviceAccount = "pytorch_sa" + +var ( + dummyEnvVars = []*core.KeyValuePair{ + {Key: "Env_Var", Value: "Env_Val"}, + } + + testArgs = []string{ + "test-args", + } + + dummyAnnotations = map[string]string{ + "annotation-key": "annotation-value", + } + dummyLabels = map[string]string{ + "label-key": "label-value", + } + + resourceRequirements = &corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("1000m"), + corev1.ResourceMemory: resource.MustParse("1Gi"), + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + Requests: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("100m"), + corev1.ResourceMemory: resource.MustParse("512Mi"), + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + } + + jobName = "the-job" + jobNamespace = "pytorch-namespace" +) + +func dummyPytorchCustomObj(workers int32) *plugins.DistributedPyTorchTrainingTask { + return &plugins.DistributedPyTorchTrainingTask{ + Workers: workers, + } +} + +func dummyElasticPytorchCustomObj(workers int32, elasticConfig plugins.ElasticConfig) *plugins.DistributedPyTorchTrainingTask { + return &plugins.DistributedPyTorchTrainingTask{ + Workers: workers, + ElasticConfig: &elasticConfig, + } +} + +func dummyPytorchTaskTemplate(id string, args ...interface{}) *core.TaskTemplate { + + var ptObjJSON string + var err error + + for _, arg := range args { + switch t := arg.(type) { + case *kfplugins.DistributedPyTorchTrainingTask: + var pytorchCustomObj = t + ptObjJSON, err = utils.MarshalToString(pytorchCustomObj) + case *plugins.DistributedPyTorchTrainingTask: + var pytorchCustomObj = t + ptObjJSON, err = utils.MarshalToString(pytorchCustomObj) + default: + err = fmt.Errorf("Unknown input type %T", t) + } + } + + if err != nil { + panic(err) + } + + structObj := structpb.Struct{} + + err = stdlibUtils.UnmarshalStringToPb(ptObjJSON, &structObj) + if err != nil { + panic(err) + } + + return &core.TaskTemplate{ + Id: &core.Identifier{Name: id}, + Type: "container", + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Image: testImage, + Args: testArgs, + Env: dummyEnvVars, + }, + }, + Custom: &structObj, + } +} + +func dummyPytorchTaskContext(taskTemplate *core.TaskTemplate, resources *corev1.ResourceRequirements, extendedResources *core.ExtendedResources, containerImage string) pluginsCore.TaskExecutionContext { + taskCtx := &mocks.TaskExecutionContext{} + inputReader := &pluginIOMocks.InputReader{} + inputReader.EXPECT().GetInputPrefixPath().Return("/input/prefix") + inputReader.EXPECT().GetInputPath().Return("/input") + inputReader.EXPECT().Get(mock.Anything).Return(&core.LiteralMap{}, nil) + taskCtx.EXPECT().InputReader().Return(inputReader) + + outputReader := &pluginIOMocks.OutputWriter{} + outputReader.EXPECT().GetOutputPath().Return("/data/outputs.pb") + outputReader.EXPECT().GetOutputPrefixPath().Return("/data/") + outputReader.EXPECT().GetRawOutputPrefix().Return("") + outputReader.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + outputReader.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + taskCtx.EXPECT().OutputWriter().Return(outputReader) + + taskReader := &mocks.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(taskTemplate, nil) + taskCtx.EXPECT().TaskReader().Return(taskReader) + + tID := &mocks.TaskExecutionID{} + tID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my_name", + Project: "my_project", + Domain: "my_domain", + }, + }, + }) + tID.EXPECT().GetGeneratedName().Return("some-acceptable-name") + tID.EXPECT().GetUniqueNodeID().Return("an-unique-id") + + overrides := &mocks.TaskOverrides{} + overrides.EXPECT().GetResources().Return(resources) + overrides.EXPECT().GetExtendedResources().Return(extendedResources) + overrides.EXPECT().GetContainerImage().Return(containerImage) + overrides.EXPECT().GetPodTemplate().Return(nil) + + taskExecutionMetadata := &mocks.TaskExecutionMetadata{} + taskExecutionMetadata.EXPECT().GetTaskExecutionID().Return(tID) + taskExecutionMetadata.EXPECT().GetNamespace().Return("test-namespace") + taskExecutionMetadata.EXPECT().GetAnnotations().Return(dummyAnnotations) + taskExecutionMetadata.EXPECT().GetLabels().Return(dummyLabels) + taskExecutionMetadata.EXPECT().GetOwnerReference().Return(v1.OwnerReference{ + Kind: "node", + Name: "blah", + }) + taskExecutionMetadata.EXPECT().IsInterruptible().Return(true) + taskExecutionMetadata.EXPECT().GetOverrides().Return(overrides) + taskExecutionMetadata.EXPECT().GetK8sServiceAccount().Return(serviceAccount) + taskExecutionMetadata.EXPECT().GetPlatformResources().Return(&corev1.ResourceRequirements{}) + taskExecutionMetadata.EXPECT().GetEnvironmentVariables().Return(nil) + taskExecutionMetadata.EXPECT().GetConsoleURL().Return("") + taskCtx.EXPECT().TaskExecutionMetadata().Return(taskExecutionMetadata) + pluginStateReaderMock := mocks.PluginStateReader{} + pluginStateReaderMock.EXPECT().Get(mock.AnythingOfType(reflect.TypeOf(&k8s.PluginState{}).String())).RunAndReturn( + func(v interface{}) (uint8, error) { + *(v.(*k8s.PluginState)) = k8s.PluginState{} + return 0, nil + }) + + taskCtx.EXPECT().PluginStateReader().Return(&pluginStateReaderMock) + return taskCtx +} + +func dummyPytorchPluginContext(taskTemplate *core.TaskTemplate, resources *corev1.ResourceRequirements, pluginState k8s.PluginState) *k8smocks.PluginContext { + pCtx := &k8smocks.PluginContext{} + inputReader := &pluginIOMocks.InputReader{} + inputReader.EXPECT().GetInputPrefixPath().Return("/input/prefix") + inputReader.EXPECT().GetInputPath().Return("/input") + inputReader.EXPECT().Get(mock.Anything).Return(&core.LiteralMap{}, nil) + pCtx.EXPECT().InputReader().Return(inputReader) + + outputReader := &pluginIOMocks.OutputWriter{} + outputReader.EXPECT().GetOutputPath().Return("/data/outputs.pb") + outputReader.EXPECT().GetOutputPrefixPath().Return("/data/") + outputReader.EXPECT().GetRawOutputPrefix().Return("") + outputReader.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + outputReader.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + pCtx.EXPECT().OutputWriter().Return(outputReader) + + taskReader := &mocks.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(taskTemplate, nil) + pCtx.EXPECT().TaskReader().Return(taskReader) + + tID := &mocks.TaskExecutionID{} + tID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my_name", + Project: "my_project", + Domain: "my_domain", + }, + }, + }) + tID.EXPECT().GetGeneratedName().Return("some-acceptable-name") + tID.EXPECT().GetUniqueNodeID().Return("an-unique-id") + + overrides := &mocks.TaskOverrides{} + overrides.EXPECT().GetResources().Return(resources) + overrides.EXPECT().GetExtendedResources().Return(nil) + overrides.EXPECT().GetContainerImage().Return("") + + taskExecutionMetadata := &mocks.TaskExecutionMetadata{} + taskExecutionMetadata.EXPECT().GetTaskExecutionID().Return(tID) + taskExecutionMetadata.EXPECT().GetNamespace().Return("test-namespace") + taskExecutionMetadata.EXPECT().GetAnnotations().Return(dummyAnnotations) + taskExecutionMetadata.EXPECT().GetLabels().Return(dummyLabels) + taskExecutionMetadata.EXPECT().GetOwnerReference().Return(v1.OwnerReference{ + Kind: "node", + Name: "blah", + }) + taskExecutionMetadata.EXPECT().IsInterruptible().Return(true) + taskExecutionMetadata.EXPECT().GetOverrides().Return(overrides) + taskExecutionMetadata.EXPECT().GetK8sServiceAccount().Return(serviceAccount) + taskExecutionMetadata.EXPECT().GetPlatformResources().Return(&corev1.ResourceRequirements{}) + taskExecutionMetadata.EXPECT().GetEnvironmentVariables().Return(nil) + taskExecutionMetadata.EXPECT().GetConsoleURL().Return("") + pCtx.EXPECT().TaskExecutionMetadata().Return(taskExecutionMetadata) + + pluginStateReaderMock := mocks.PluginStateReader{} + pluginStateReaderMock.EXPECT().Get(mock.AnythingOfType(reflect.TypeOf(&pluginState).String())).RunAndReturn( + func(v interface{}) (uint8, error) { + *(v.(*k8s.PluginState)) = pluginState + return 0, nil + }) + + pCtx.EXPECT().PluginStateReader().Return(&pluginStateReaderMock) + return pCtx +} + +func dummyPytorchJobResource(pytorchResourceHandler pytorchOperatorResourceHandler, workers int32, conditionType kubeflowv1.JobConditionType) *kubeflowv1.PyTorchJob { + var jobConditions []kubeflowv1.JobCondition + + now := time.Now() + + jobCreated := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobCreated, + Status: corev1.ConditionTrue, + Reason: "PyTorchJobCreated", + Message: "PyTorchJob the-job is created.", + LastUpdateTime: v1.Time{ + Time: now, + }, + LastTransitionTime: v1.Time{ + Time: now, + }, + } + jobRunningActive := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobRunning, + Status: corev1.ConditionTrue, + Reason: "PyTorchJobRunning", + Message: "PyTorchJob the-job is running.", + LastUpdateTime: v1.Time{ + Time: now.Add(time.Minute), + }, + LastTransitionTime: v1.Time{ + Time: now.Add(time.Minute), + }, + } + jobRunningInactive := *jobRunningActive.DeepCopy() + jobRunningInactive.Status = corev1.ConditionFalse + jobSucceeded := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobSucceeded, + Status: corev1.ConditionTrue, + Reason: "PyTorchJobSucceeded", + Message: "PyTorchJob the-job is successfully completed.", + LastUpdateTime: v1.Time{ + Time: now.Add(2 * time.Minute), + }, + LastTransitionTime: v1.Time{ + Time: now.Add(2 * time.Minute), + }, + } + jobFailed := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobFailed, + Status: corev1.ConditionTrue, + Reason: "PyTorchJobFailed", + Message: "PyTorchJob the-job is failed.", + LastUpdateTime: v1.Time{ + Time: now.Add(2 * time.Minute), + }, + LastTransitionTime: v1.Time{ + Time: now.Add(2 * time.Minute), + }, + } + jobRestarting := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobRestarting, + Status: corev1.ConditionTrue, + Reason: "PyTorchJobRestarting", + Message: "PyTorchJob the-job is restarting because some replica(s) failed.", + LastUpdateTime: v1.Time{ + Time: now.Add(3 * time.Minute), + }, + LastTransitionTime: v1.Time{ + Time: now.Add(3 * time.Minute), + }, + } + + switch conditionType { + case kubeflowv1.JobCreated: + jobConditions = []kubeflowv1.JobCondition{ + jobCreated, + } + case kubeflowv1.JobRunning: + jobConditions = []kubeflowv1.JobCondition{ + jobCreated, + jobRunningActive, + } + case kubeflowv1.JobSucceeded: + jobConditions = []kubeflowv1.JobCondition{ + jobCreated, + jobRunningInactive, + jobSucceeded, + } + case kubeflowv1.JobFailed: + jobConditions = []kubeflowv1.JobCondition{ + jobCreated, + jobRunningInactive, + jobFailed, + } + case kubeflowv1.JobRestarting: + jobConditions = []kubeflowv1.JobCondition{ + jobCreated, + jobRunningInactive, + jobFailed, + jobRestarting, + } + } + + ptObj := dummyPytorchCustomObj(workers) + taskTemplate := dummyPytorchTaskTemplate("job1", ptObj) + resource, err := pytorchResourceHandler.BuildResource(context.TODO(), dummyPytorchTaskContext(taskTemplate, resourceRequirements, nil, "")) + if err != nil { + panic(err) + } + + return &kubeflowv1.PyTorchJob{ + ObjectMeta: v1.ObjectMeta{ + CreationTimestamp: v1.Time{Time: time.Now()}, + Name: jobName, + Namespace: jobNamespace, + }, + Spec: resource.(*kubeflowv1.PyTorchJob).Spec, + Status: kubeflowv1.JobStatus{ + Conditions: jobConditions, + ReplicaStatuses: nil, + StartTime: nil, + CompletionTime: nil, + LastReconcileTime: nil, + }, + } +} + +func TestBuildResourcePytorchElastic(t *testing.T) { + pytorchResourceHandler := pytorchOperatorResourceHandler{} + + ptObj := dummyElasticPytorchCustomObj(2, plugins.ElasticConfig{MinReplicas: 1, MaxReplicas: 2, NprocPerNode: 4, RdzvBackend: "c10d"}) + taskTemplate := dummyPytorchTaskTemplate("job2", ptObj) + + resource, err := pytorchResourceHandler.BuildResource(context.TODO(), dummyPytorchTaskContext(taskTemplate, resourceRequirements, nil, "")) + assert.NoError(t, err) + assert.NotNil(t, resource) + + pytorchJob, ok := resource.(*kubeflowv1.PyTorchJob) + assert.True(t, ok) + assert.Equal(t, int32(2), *pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeWorker].Replicas) + assert.NotNil(t, pytorchJob.Spec.ElasticPolicy) + assert.Equal(t, int32(1), *pytorchJob.Spec.ElasticPolicy.MinReplicas) + assert.Equal(t, int32(2), *pytorchJob.Spec.ElasticPolicy.MaxReplicas) + assert.Equal(t, int32(4), *pytorchJob.Spec.ElasticPolicy.NProcPerNode) + assert.Equal(t, kubeflowv1.RDZVBackend("c10d"), *pytorchJob.Spec.ElasticPolicy.RDZVBackend) + + assert.Equal(t, 1, len(pytorchJob.Spec.PyTorchReplicaSpecs)) + assert.Contains(t, pytorchJob.Spec.PyTorchReplicaSpecs, kubeflowv1.PyTorchJobReplicaTypeWorker) + + for _, replicaSpec := range pytorchJob.Spec.PyTorchReplicaSpecs { + var hasContainerWithDefaultPytorchName = false + podSpec := replicaSpec.Template.Spec + for _, container := range podSpec.Containers { + if container.Name == kubeflowv1.PyTorchJobDefaultContainerName { + hasContainerWithDefaultPytorchName = true + } + } + + assert.True(t, hasContainerWithDefaultPytorchName) + + // verify TaskExecutionMetadata labels and annotations are copied to the PyTorchJob + for k, v := range dummyAnnotations { + assert.Equal(t, v, replicaSpec.Template.ObjectMeta.Annotations[k]) + } + for k, v := range dummyLabels { + assert.Equal(t, v, replicaSpec.Template.ObjectMeta.Labels[k]) + } + } +} + +func TestBuildResourcePytorch(t *testing.T) { + pytorchResourceHandler := pytorchOperatorResourceHandler{} + + ptObj := dummyPytorchCustomObj(100) + taskTemplate := dummyPytorchTaskTemplate("job3", ptObj) + + res, err := pytorchResourceHandler.BuildResource(context.TODO(), dummyPytorchTaskContext(taskTemplate, resourceRequirements, nil, "")) + assert.NoError(t, err) + assert.NotNil(t, res) + + pytorchJob, ok := res.(*kubeflowv1.PyTorchJob) + assert.True(t, ok) + assert.Equal(t, int32(100), *pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeWorker].Replicas) + assert.Nil(t, pytorchJob.Spec.ElasticPolicy) + + // verify TaskExecutionMetadata labels and annotations are copied to the TensorFlowJob + for k, v := range dummyAnnotations { + for _, replicaSpec := range pytorchJob.Spec.PyTorchReplicaSpecs { + assert.Equal(t, v, replicaSpec.Template.ObjectMeta.Annotations[k]) + } + } + for k, v := range dummyLabels { + for _, replicaSpec := range pytorchJob.Spec.PyTorchReplicaSpecs { + assert.Equal(t, v, replicaSpec.Template.ObjectMeta.Labels[k]) + } + } + + for _, replicaSpec := range pytorchJob.Spec.PyTorchReplicaSpecs { + var hasContainerWithDefaultPytorchName = false + for _, container := range replicaSpec.Template.Spec.Containers { + if container.Name == kubeflowv1.PyTorchJobDefaultContainerName { + hasContainerWithDefaultPytorchName = true + } + + assert.Equal(t, resourceRequirements.Requests, container.Resources.Requests, fmt.Sprintf(" container.Resources.Requests [%+v]", container.Resources.Requests.Cpu().String())) + assert.Equal(t, resourceRequirements.Limits, container.Resources.Limits, fmt.Sprintf(" container.Resources.Limits [%+v]", container.Resources.Limits.Cpu().String())) + } + + assert.True(t, hasContainerWithDefaultPytorchName) + } +} + +func TestBuildResourcePytorchContainerImage(t *testing.T) { + assert.NoError(t, flytek8sConfig.SetK8sPluginConfig(&flytek8sConfig.K8sPluginConfig{})) + + fixtures := []struct { + name string + resources *corev1.ResourceRequirements + containerImageOverride string + }{ + { + "without overrides", + &corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + "", + }, + { + "with overrides", + &corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + "container-image-override", + }, + } + + testConfigs := []struct { + name string + plugin *plugins.DistributedPyTorchTrainingTask + }{ + { + "pytorch", + dummyPytorchCustomObj(100), + }, + { + "elastic pytorch", + dummyElasticPytorchCustomObj(2, plugins.ElasticConfig{MinReplicas: 1, MaxReplicas: 2, NprocPerNode: 4, RdzvBackend: "c10d"}), + }, + } + + for _, tCfg := range testConfigs { + for _, f := range fixtures { + t.Run(tCfg.name+" "+f.name, func(t *testing.T) { + taskTemplate := dummyPytorchTaskTemplate("job", tCfg.plugin) + taskContext := dummyPytorchTaskContext(taskTemplate, f.resources, nil, f.containerImageOverride) + pytorchResourceHandler := pytorchOperatorResourceHandler{} + r, err := pytorchResourceHandler.BuildResource(context.TODO(), taskContext) + assert.NoError(t, err) + assert.NotNil(t, r) + pytorchJob, ok := r.(*kubeflowv1.PyTorchJob) + assert.True(t, ok) + + for _, replicaSpec := range pytorchJob.Spec.PyTorchReplicaSpecs { + var expectedContainerImage string + if len(f.containerImageOverride) > 0 { + expectedContainerImage = f.containerImageOverride + } else { + expectedContainerImage = testImage + } + assert.Equal(t, expectedContainerImage, replicaSpec.Template.Spec.Containers[0].Image) + } + }) + } + } +} + +func TestBuildResourcePytorchExtendedResources(t *testing.T) { + assert.NoError(t, flytek8sConfig.SetK8sPluginConfig(&flytek8sConfig.K8sPluginConfig{ + GpuDeviceNodeLabel: "gpu-node-label", + GpuPartitionSizeNodeLabel: "gpu-partition-size", + GpuResourceName: flytek8s.ResourceNvidiaGPU, + AddTolerationsForExtendedResources: []string{"nvidia.com/gpu"}, + })) + + fixtures := []struct { + name string + resources *corev1.ResourceRequirements + extendedResourcesBase *core.ExtendedResources + extendedResourcesOverride *core.ExtendedResources + expectedNsr []corev1.NodeSelectorTerm + expectedTol []corev1.Toleration + }{ + { + "without overrides", + &corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-t4", + }, + }, + nil, + []corev1.NodeSelectorTerm{ + { + MatchExpressions: []corev1.NodeSelectorRequirement{ + corev1.NodeSelectorRequirement{ + Key: "gpu-node-label", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-t4"}, + }, + }, + }, + }, + []corev1.Toleration{ + { + Key: "gpu-node-label", + Value: "nvidia-tesla-t4", + Operator: corev1.TolerationOpEqual, + Effect: corev1.TaintEffectNoSchedule, + }, + { + Key: "nvidia.com/gpu", + Operator: corev1.TolerationOpExists, + Effect: corev1.TaintEffectNoSchedule, + }, + }, + }, + { + "with overrides", + &corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-t4", + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-a100", + PartitionSizeValue: &core.GPUAccelerator_PartitionSize{ + PartitionSize: "1g.5gb", + }, + }, + }, + []corev1.NodeSelectorTerm{ + { + MatchExpressions: []corev1.NodeSelectorRequirement{ + corev1.NodeSelectorRequirement{ + Key: "gpu-node-label", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-a100"}, + }, + corev1.NodeSelectorRequirement{ + Key: "gpu-partition-size", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"1g.5gb"}, + }, + }, + }, + }, + []corev1.Toleration{ + { + Key: "gpu-node-label", + Value: "nvidia-tesla-a100", + Operator: corev1.TolerationOpEqual, + Effect: corev1.TaintEffectNoSchedule, + }, + { + Key: "gpu-partition-size", + Value: "1g.5gb", + Operator: corev1.TolerationOpEqual, + Effect: corev1.TaintEffectNoSchedule, + }, + { + Key: "nvidia.com/gpu", + Operator: corev1.TolerationOpExists, + Effect: corev1.TaintEffectNoSchedule, + }, + }, + }, + } + + testConfigs := []struct { + name string + plugin *plugins.DistributedPyTorchTrainingTask + }{ + { + "pytorch", + dummyPytorchCustomObj(100), + }, + { + "elastic pytorch", + dummyElasticPytorchCustomObj(2, plugins.ElasticConfig{MinReplicas: 1, MaxReplicas: 2, NprocPerNode: 4, RdzvBackend: "c10d"}), + }, + } + + for _, tCfg := range testConfigs { + for _, f := range fixtures { + t.Run(tCfg.name+" "+f.name, func(t *testing.T) { + taskTemplate := dummyPytorchTaskTemplate("job", tCfg.plugin) + taskTemplate.ExtendedResources = f.extendedResourcesBase + taskContext := dummyPytorchTaskContext(taskTemplate, f.resources, f.extendedResourcesOverride, "") + pytorchResourceHandler := pytorchOperatorResourceHandler{} + r, err := pytorchResourceHandler.BuildResource(context.TODO(), taskContext) + assert.NoError(t, err) + assert.NotNil(t, r) + pytorchJob, ok := r.(*kubeflowv1.PyTorchJob) + assert.True(t, ok) + + for _, replicaSpec := range pytorchJob.Spec.PyTorchReplicaSpecs { + assert.EqualValues( + t, + f.expectedNsr, + replicaSpec.Template.Spec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + f.expectedTol, + replicaSpec.Template.Spec.Tolerations, + ) + } + }) + } + } +} + +func TestGetTaskPhase(t *testing.T) { + pytorchResourceHandler := pytorchOperatorResourceHandler{} + ctx := context.TODO() + + dummyPytorchJobResourceCreator := func(conditionType kubeflowv1.JobConditionType) *kubeflowv1.PyTorchJob { + return dummyPytorchJobResource(pytorchResourceHandler, 2, conditionType) + } + + pluginContext := dummyPytorchPluginContext(dummyPytorchTaskTemplate("", dummyPytorchCustomObj(2)), resourceRequirements, k8s.PluginState{}) + podList := []runtime.Object{ + &corev1.Pod{ + ObjectMeta: v1.ObjectMeta{Namespace: "ns", Name: "initializing ignored pod"}, + Status: corev1.PodStatus{Phase: corev1.PodPending}, + }, + &corev1.Pod{ + ObjectMeta: v1.ObjectMeta{Namespace: "ns", Name: "test"}, + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + {Name: "test-work-0"}, + }, + }, + Status: corev1.PodStatus{ + Phase: corev1.PodRunning, + ContainerStatuses: []corev1.ContainerStatus{ + { + Name: "test-work-0", + State: corev1.ContainerState{ + Terminated: &corev1.ContainerStateTerminated{ + StartedAt: v1.Time{Time: time.Now()}, + FinishedAt: v1.Time{Time: time.Now()}, + }, + }, + }, + }, + }, + }, + } + reader := fake.NewFakeClient(podList...) + pluginContext.EXPECT().K8sReader().Return(reader) + taskPhase, err := pytorchResourceHandler.GetTaskPhase(ctx, pluginContext, dummyPytorchJobResourceCreator(kubeflowv1.JobCreated)) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseQueued, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + taskPhase, err = pytorchResourceHandler.GetTaskPhase(ctx, pluginContext, dummyPytorchJobResourceCreator(kubeflowv1.JobRunning)) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRunning, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + taskPhase, err = pytorchResourceHandler.GetTaskPhase(ctx, pluginContext, dummyPytorchJobResourceCreator(kubeflowv1.JobSucceeded)) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseSuccess, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + taskPhase, err = pytorchResourceHandler.GetTaskPhase(ctx, pluginContext, dummyPytorchJobResourceCreator(kubeflowv1.JobFailed)) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + taskPhase, err = pytorchResourceHandler.GetTaskPhase(ctx, pluginContext, dummyPytorchJobResourceCreator(kubeflowv1.JobRestarting)) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRunning, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Equal(t, taskPhase.Info().LogContext.Pods[0].PodName, "test") + assert.Nil(t, err) +} + +func TestGetTaskPhaseIncreasePhaseVersion(t *testing.T) { + pytorchResourceHandler := pytorchOperatorResourceHandler{} + ctx := context.TODO() + + pluginState := k8s.PluginState{ + Phase: pluginsCore.PhaseQueued, + PhaseVersion: pluginsCore.DefaultPhaseVersion, + Reason: "task submitted to K8s", + } + pluginCtx := dummyPytorchPluginContext(dummyPytorchTaskTemplate("", dummyPytorchCustomObj(2)), resourceRequirements, pluginState) + reader := fake.NewFakeClient() + pluginCtx.EXPECT().K8sReader().Return(reader) + taskPhase, err := pytorchResourceHandler.GetTaskPhase(ctx, pluginCtx, dummyPytorchJobResource(pytorchResourceHandler, 4, kubeflowv1.JobCreated)) + + assert.NoError(t, err) + assert.Equal(t, taskPhase.Version(), pluginsCore.DefaultPhaseVersion+1) +} + +func TestGetLogs(t *testing.T) { + assert.NoError(t, logs.SetLogConfig(&logs.LogConfig{ + IsKubernetesEnabled: true, + KubernetesURL: "k8s.com", + })) + + hasMaster := true + workers := int32(2) + + pytorchResourceHandler := pytorchOperatorResourceHandler{} + pytorchJob := dummyPytorchJobResource(pytorchResourceHandler, workers, kubeflowv1.JobRunning) + taskTemplate := dummyPytorchTaskTemplate("", dummyPytorchCustomObj(workers)) + pluginContext := dummyPytorchPluginContext(taskTemplate, resourceRequirements, k8s.PluginState{}) + jobLogs, err := common.GetLogs(pluginContext, common.PytorchTaskType, pytorchJob.ObjectMeta, taskTemplate, hasMaster, workers, 0, 0, 0, kubeflowv1.PyTorchJobDefaultContainerName) + + assert.NoError(t, err) + assert.Equal(t, 3, len(jobLogs)) + assert.Equal(t, fmt.Sprintf("k8s.com/#!/log/%s/%s-master-0/pod?namespace=pytorch-namespace", jobNamespace, jobName), jobLogs[0].Uri) + assert.Equal(t, fmt.Sprintf("k8s.com/#!/log/%s/%s-worker-0/pod?namespace=pytorch-namespace", jobNamespace, jobName), jobLogs[1].Uri) + assert.Equal(t, fmt.Sprintf("k8s.com/#!/log/%s/%s-worker-1/pod?namespace=pytorch-namespace", jobNamespace, jobName), jobLogs[2].Uri) +} + +func TestGetLogsElastic(t *testing.T) { + assert.NoError(t, logs.SetLogConfig(&logs.LogConfig{ + IsKubernetesEnabled: true, + KubernetesURL: "k8s.com", + })) + + hasMaster := false + workers := int32(2) + + pytorchResourceHandler := pytorchOperatorResourceHandler{} + pytorchJob := dummyPytorchJobResource(pytorchResourceHandler, workers, kubeflowv1.JobRunning) + taskTemplate := dummyPytorchTaskTemplate("", dummyPytorchCustomObj(workers)) + pluginContext := dummyPytorchPluginContext(taskTemplate, resourceRequirements, k8s.PluginState{}) + jobLogs, err := common.GetLogs(pluginContext, common.PytorchTaskType, pytorchJob.ObjectMeta, taskTemplate, hasMaster, workers, 0, 0, 0, kubeflowv1.PyTorchJobDefaultContainerName) + + assert.NoError(t, err) + assert.Equal(t, 2, len(jobLogs)) + assert.Equal(t, fmt.Sprintf("k8s.com/#!/log/%s/%s-worker-0/pod?namespace=pytorch-namespace", jobNamespace, jobName), jobLogs[0].Uri) + assert.Equal(t, fmt.Sprintf("k8s.com/#!/log/%s/%s-worker-1/pod?namespace=pytorch-namespace", jobNamespace, jobName), jobLogs[1].Uri) +} + +func TestGetProperties(t *testing.T) { + pytorchResourceHandler := pytorchOperatorResourceHandler{} + expected := k8s.PluginProperties{} + assert.Equal(t, expected, pytorchResourceHandler.GetProperties()) +} + +func TestReplicaCounts(t *testing.T) { + for _, test := range []struct { + name string + workerReplicaCount int32 + expectError bool + contains []kubeflowv1.ReplicaType + notContains []kubeflowv1.ReplicaType + }{ + {"NoWorkers", 0, true, nil, nil}, + {"Works", 1, false, []kubeflowv1.ReplicaType{kubeflowv1.PyTorchJobReplicaTypeMaster, kubeflowv1.PyTorchJobReplicaTypeWorker}, []kubeflowv1.ReplicaType{}}, + } { + t.Run(test.name, func(t *testing.T) { + pytorchResourceHandler := pytorchOperatorResourceHandler{} + + ptObj := dummyPytorchCustomObj(test.workerReplicaCount) + taskTemplate := dummyPytorchTaskTemplate("the job", ptObj) + + res, err := pytorchResourceHandler.BuildResource(context.TODO(), dummyPytorchTaskContext(taskTemplate, resourceRequirements, nil, "")) + if test.expectError { + assert.Error(t, err) + assert.Nil(t, res) + return + } + + assert.NoError(t, err) + assert.NotNil(t, res) + + job, ok := res.(*kubeflowv1.PyTorchJob) + assert.True(t, ok) + + assert.Len(t, job.Spec.PyTorchReplicaSpecs, len(test.contains)) + for _, replicaType := range test.contains { + assert.Contains(t, job.Spec.PyTorchReplicaSpecs, replicaType) + } + for _, replicaType := range test.notContains { + assert.NotContains(t, job.Spec.PyTorchReplicaSpecs, replicaType) + } + }) + } +} + +func TestBuildResourcePytorchV1(t *testing.T) { + taskConfigs := []*kfplugins.DistributedPyTorchTrainingTask{ + { + MasterReplicas: &kfplugins.DistributedPyTorchTrainingReplicaSpec{ + Image: testImageMaster, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + {Name: core.Resources_MEMORY, Value: "250Mi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "500m"}, + {Name: core.Resources_MEMORY, Value: "500Mi"}, + }, + }, + RestartPolicy: plugins.RestartPolicy_RESTART_POLICY_ALWAYS, + }, + WorkerReplicas: &kfplugins.DistributedPyTorchTrainingReplicaSpec{ + Replicas: 100, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "2048m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + }, + }, + }, + }, + { + MasterReplicas: &kfplugins.DistributedPyTorchTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Image: testImageMaster, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + {Name: core.Resources_MEMORY, Value: "250Mi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "500m"}, + {Name: core.Resources_MEMORY, Value: "500Mi"}, + }, + }, + RestartPolicy: plugins.RestartPolicy_RESTART_POLICY_ALWAYS, + }, + }, + WorkerReplicas: &kfplugins.DistributedPyTorchTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 100, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "2048m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + }, + }, + }, + }, + }, + } + + for _, taskConfig := range taskConfigs { + masterResourceRequirements := &corev1.ResourceRequirements{ + Requests: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("250m"), + corev1.ResourceMemory: resource.MustParse("250Mi"), + }, + Limits: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("500m"), + corev1.ResourceMemory: resource.MustParse("500Mi"), + }, + } + + workerResourceRequirements := &corev1.ResourceRequirements{ + Requests: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("1024m"), + corev1.ResourceMemory: resource.MustParse("1Gi"), + }, + Limits: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("2048m"), + corev1.ResourceMemory: resource.MustParse("2Gi"), + }, + } + + pytorchResourceHandler := pytorchOperatorResourceHandler{} + + taskTemplate := dummyPytorchTaskTemplate("job4", taskConfig) + taskTemplate.TaskTypeVersion = 1 + + res, err := pytorchResourceHandler.BuildResource(context.TODO(), dummyPytorchTaskContext(taskTemplate, resourceRequirements, nil, "")) + assert.NoError(t, err) + assert.NotNil(t, res) + + pytorchJob, ok := res.(*kubeflowv1.PyTorchJob) + assert.True(t, ok) + + assert.Equal(t, int32(100), *pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeWorker].Replicas) + assert.Equal(t, int32(1), *pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeMaster].Replicas) + + assert.Equal(t, testImageMaster, pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeMaster].Template.Spec.Containers[0].Image) + assert.Equal(t, testImage, pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeWorker].Template.Spec.Containers[0].Image) + + assert.Equal(t, *masterResourceRequirements, pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeMaster].Template.Spec.Containers[0].Resources) + assert.Equal(t, *workerResourceRequirements, pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeWorker].Template.Spec.Containers[0].Resources) + + assert.Equal(t, kubeflowv1.RestartPolicyAlways, pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeMaster].RestartPolicy) + assert.Equal(t, kubeflowv1.RestartPolicyNever, pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeWorker].RestartPolicy) + + assert.Nil(t, pytorchJob.Spec.RunPolicy.CleanPodPolicy) + assert.Nil(t, pytorchJob.Spec.RunPolicy.BackoffLimit) + assert.Nil(t, pytorchJob.Spec.RunPolicy.TTLSecondsAfterFinished) + assert.Nil(t, pytorchJob.Spec.RunPolicy.ActiveDeadlineSeconds) + + assert.Nil(t, pytorchJob.Spec.ElasticPolicy) + } +} + +func TestBuildResourcePytorchV1WithRunPolicy(t *testing.T) { + taskConfigs := []*kfplugins.DistributedPyTorchTrainingTask{ + { + WorkerReplicas: &kfplugins.DistributedPyTorchTrainingReplicaSpec{ + Replicas: 100, + }, + RunPolicy: &kfplugins.RunPolicy{ + CleanPodPolicy: kfplugins.CleanPodPolicy_CLEANPOD_POLICY_ALL, + BackoffLimit: 100, + ActiveDeadlineSeconds: 1000, + TtlSecondsAfterFinished: 10000, + }, + }, + { + WorkerReplicas: &kfplugins.DistributedPyTorchTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 100, + }, + }, + RunPolicy: &kfplugins.RunPolicy{ + CleanPodPolicy: kfplugins.CleanPodPolicy_CLEANPOD_POLICY_ALL, + BackoffLimit: 100, + ActiveDeadlineSeconds: 1000, + TtlSecondsAfterFinished: 10000, + }, + }, + } + + for _, taskConfig := range taskConfigs { + pytorchResourceHandler := pytorchOperatorResourceHandler{} + + taskTemplate := dummyPytorchTaskTemplate("job5", taskConfig) + taskTemplate.TaskTypeVersion = 1 + + res, err := pytorchResourceHandler.BuildResource(context.TODO(), dummyPytorchTaskContext(taskTemplate, resourceRequirements, nil, "")) + assert.NoError(t, err) + assert.NotNil(t, res) + + pytorchJob, ok := res.(*kubeflowv1.PyTorchJob) + assert.True(t, ok) + assert.Equal(t, int32(100), *pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeWorker].Replicas) + assert.Equal(t, int32(1), *pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeMaster].Replicas) + assert.Equal(t, kubeflowv1.CleanPodPolicyAll, *pytorchJob.Spec.RunPolicy.CleanPodPolicy) + assert.Equal(t, int32(100), *pytorchJob.Spec.RunPolicy.BackoffLimit) + assert.Equal(t, int64(1000), *pytorchJob.Spec.RunPolicy.ActiveDeadlineSeconds) + assert.Equal(t, int32(10000), *pytorchJob.Spec.RunPolicy.TTLSecondsAfterFinished) + } +} + +func TestBuildResourcePytorchV1WithOnlyWorkerSpec(t *testing.T) { + taskConfigs := []*kfplugins.DistributedPyTorchTrainingTask{ + { + WorkerReplicas: &kfplugins.DistributedPyTorchTrainingReplicaSpec{ + Replicas: 100, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "2048m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + }, + }, + }, + }, + { + WorkerReplicas: &kfplugins.DistributedPyTorchTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 100, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "2048m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + }, + }, + }, + }, + }, + } + + for _, taskConfig := range taskConfigs { + // Master Replica should use resource from task override if not set + taskOverrideResourceRequirements := &corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("1000m"), + corev1.ResourceMemory: resource.MustParse("1Gi"), + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + Requests: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("100m"), + corev1.ResourceMemory: resource.MustParse("512Mi"), + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + } + + workerResourceRequirements := &corev1.ResourceRequirements{ + Requests: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("1024m"), + corev1.ResourceMemory: resource.MustParse("1Gi"), + }, + Limits: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("2048m"), + corev1.ResourceMemory: resource.MustParse("2Gi"), + }, + } + + pytorchResourceHandler := pytorchOperatorResourceHandler{} + + taskTemplate := dummyPytorchTaskTemplate("job5", taskConfig) + taskTemplate.TaskTypeVersion = 1 + + res, err := pytorchResourceHandler.BuildResource(context.TODO(), dummyPytorchTaskContext(taskTemplate, resourceRequirements, nil, "")) + assert.NoError(t, err) + assert.NotNil(t, res) + + pytorchJob, ok := res.(*kubeflowv1.PyTorchJob) + assert.True(t, ok) + + assert.Equal(t, int32(100), *pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeWorker].Replicas) + assert.Equal(t, int32(1), *pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeMaster].Replicas) + + assert.Equal(t, testImage, pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeMaster].Template.Spec.Containers[0].Image) + assert.Equal(t, testImage, pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeWorker].Template.Spec.Containers[0].Image) + + assert.Equal(t, *taskOverrideResourceRequirements, pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeMaster].Template.Spec.Containers[0].Resources) + assert.Equal(t, *workerResourceRequirements, pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeWorker].Template.Spec.Containers[0].Resources) + + assert.Equal(t, kubeflowv1.RestartPolicyNever, pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeMaster].RestartPolicy) + assert.Equal(t, kubeflowv1.RestartPolicyNever, pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeWorker].RestartPolicy) + + assert.Nil(t, pytorchJob.Spec.ElasticPolicy) + } +} + +func TestBuildResourcePytorchV1ResourceTolerations(t *testing.T) { + gpuToleration := corev1.Toleration{ + Key: "nvidia.com/gpu", + Value: "present", + Operator: corev1.TolerationOpEqual, + Effect: corev1.TaintEffectNoSchedule, + } + assert.NoError(t, flytek8sConfig.SetK8sPluginConfig(&flytek8sConfig.K8sPluginConfig{ + GpuResourceName: flytek8s.ResourceNvidiaGPU, + ResourceTolerations: map[corev1.ResourceName][]corev1.Toleration{ + flytek8s.ResourceNvidiaGPU: {gpuToleration}, + }, + })) + + taskConfigs := []*kfplugins.DistributedPyTorchTrainingTask{ + { + MasterReplicas: &kfplugins.DistributedPyTorchTrainingReplicaSpec{ + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + {Name: core.Resources_MEMORY, Value: "250Mi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "500m"}, + {Name: core.Resources_MEMORY, Value: "500Mi"}, + }, + }, + }, + WorkerReplicas: &kfplugins.DistributedPyTorchTrainingReplicaSpec{ + Replicas: 100, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "2048m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + }, + }, + }, + { + MasterReplicas: &kfplugins.DistributedPyTorchTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + {Name: core.Resources_MEMORY, Value: "250Mi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "500m"}, + {Name: core.Resources_MEMORY, Value: "500Mi"}, + }, + }, + }, + }, + WorkerReplicas: &kfplugins.DistributedPyTorchTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 100, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "2048m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + }, + }, + }, + }, + } + + for _, taskConfig := range taskConfigs { + pytorchResourceHandler := pytorchOperatorResourceHandler{} + + taskTemplate := dummyPytorchTaskTemplate("job4", taskConfig) + taskTemplate.TaskTypeVersion = 1 + + res, err := pytorchResourceHandler.BuildResource(context.TODO(), dummyPytorchTaskContext(taskTemplate, resourceRequirements, nil, "")) + assert.NoError(t, err) + assert.NotNil(t, res) + + pytorchJob, ok := res.(*kubeflowv1.PyTorchJob) + assert.True(t, ok) + + assert.NotContains(t, pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeMaster].Template.Spec.Tolerations, gpuToleration) + assert.Contains(t, pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeWorker].Template.Spec.Tolerations, gpuToleration) + } +} + +func TestBuildResourcePytorchV1WithElastic(t *testing.T) { + taskConfigs := []*kfplugins.DistributedPyTorchTrainingTask{ + { + WorkerReplicas: &kfplugins.DistributedPyTorchTrainingReplicaSpec{ + Replicas: 2, + }, + ElasticConfig: &kfplugins.ElasticConfig{MinReplicas: 1, MaxReplicas: 2, NprocPerNode: 4, RdzvBackend: "c10d"}, + }, + { + WorkerReplicas: &kfplugins.DistributedPyTorchTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 2, + }, + }, + ElasticConfig: &kfplugins.ElasticConfig{MinReplicas: 1, MaxReplicas: 2, NprocPerNode: 4, RdzvBackend: "c10d"}, + }, + } + + for _, taskConfig := range taskConfigs { + taskTemplate := dummyPytorchTaskTemplate("job5", taskConfig) + taskTemplate.TaskTypeVersion = 1 + + pytorchResourceHandler := pytorchOperatorResourceHandler{} + resource, err := pytorchResourceHandler.BuildResource(context.TODO(), dummyPytorchTaskContext(taskTemplate, resourceRequirements, nil, "")) + assert.NoError(t, err) + assert.NotNil(t, resource) + + pytorchJob, ok := resource.(*kubeflowv1.PyTorchJob) + assert.True(t, ok) + assert.Equal(t, int32(2), *pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeWorker].Replicas) + assert.NotNil(t, pytorchJob.Spec.ElasticPolicy) + assert.Equal(t, int32(1), *pytorchJob.Spec.ElasticPolicy.MinReplicas) + assert.Equal(t, int32(2), *pytorchJob.Spec.ElasticPolicy.MaxReplicas) + assert.Equal(t, int32(4), *pytorchJob.Spec.ElasticPolicy.NProcPerNode) + assert.Equal(t, kubeflowv1.RDZVBackend("c10d"), *pytorchJob.Spec.ElasticPolicy.RDZVBackend) + + assert.Equal(t, 1, len(pytorchJob.Spec.PyTorchReplicaSpecs)) + assert.Contains(t, pytorchJob.Spec.PyTorchReplicaSpecs, kubeflowv1.PyTorchJobReplicaTypeWorker) + + var hasContainerWithDefaultPytorchName = false + + for _, container := range pytorchJob.Spec.PyTorchReplicaSpecs[kubeflowv1.PyTorchJobReplicaTypeWorker].Template.Spec.Containers { + if container.Name == kubeflowv1.PyTorchJobDefaultContainerName { + hasContainerWithDefaultPytorchName = true + } + } + + assert.True(t, hasContainerWithDefaultPytorchName) + } +} + +func TestBuildResourcePytorchV1WithZeroWorker(t *testing.T) { + taskConfigs := []*kfplugins.DistributedPyTorchTrainingTask{ + { + WorkerReplicas: &kfplugins.DistributedPyTorchTrainingReplicaSpec{ + Replicas: 0, + }, + }, + { + WorkerReplicas: &kfplugins.DistributedPyTorchTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 0, + }, + }, + }, + } + + for _, taskConfig := range taskConfigs { + pytorchResourceHandler := pytorchOperatorResourceHandler{} + + taskTemplate := dummyPytorchTaskTemplate("job5", taskConfig) + taskTemplate.TaskTypeVersion = 1 + _, err := pytorchResourceHandler.BuildResource(context.TODO(), dummyPytorchTaskContext(taskTemplate, resourceRequirements, nil, "")) + assert.Error(t, err) + } +} + +func TestParseElasticConfig(t *testing.T) { + elasticConfig := plugins.ElasticConfig{MinReplicas: 1, MaxReplicas: 2, NprocPerNode: 4, RdzvBackend: "c10d"} + elasticPolicy := ParseElasticConfig(&elasticConfig) + assert.Equal(t, int32(1), *elasticPolicy.MinReplicas) + assert.Equal(t, int32(2), *elasticPolicy.MaxReplicas) + assert.Equal(t, int32(4), *elasticPolicy.NProcPerNode) + assert.Equal(t, kubeflowv1.RDZVBackend("c10d"), *elasticPolicy.RDZVBackend) +} + +func TestGetReplicaCount(t *testing.T) { + pytorchResourceHandler := pytorchOperatorResourceHandler{} + tfObj := dummyPytorchCustomObj(1) + taskTemplate := dummyPytorchTaskTemplate("the job", tfObj) + resource, err := pytorchResourceHandler.BuildResource(context.TODO(), dummyPytorchTaskContext(taskTemplate, resourceRequirements, nil, "")) + assert.NoError(t, err) + assert.NotNil(t, resource) + PytorchJob, ok := resource.(*kubeflowv1.PyTorchJob) + assert.True(t, ok) + + assert.NotNil(t, common.GetReplicaCount(PytorchJob.Spec.PyTorchReplicaSpecs, kubeflowv1.PyTorchJobReplicaTypeWorker)) +} + +func TestGetTaskPhaseWithFailedPod(t *testing.T) { + pytorchResourceHandler := pytorchOperatorResourceHandler{} + ctx := context.TODO() + + // Create a failed worker-0 pod + pod := &corev1.Pod{ + ObjectMeta: v1.ObjectMeta{ + Name: jobName + "-worker-0", + Namespace: jobNamespace, + }, + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + { + Name: "pytorch", + }, + }, + }, + Status: corev1.PodStatus{ + Phase: corev1.PodFailed, + ContainerStatuses: []corev1.ContainerStatus{ + { + Name: "pytorch", + State: corev1.ContainerState{ + Terminated: &corev1.ContainerStateTerminated{ + ExitCode: 1, + Reason: "Error", + Message: "Container failed", + }, + }, + }, + }, + }, + } + + pluginContext := dummyPytorchPluginContext(dummyPytorchTaskTemplate("", dummyPytorchCustomObj(2)), resourceRequirements, k8s.PluginState{}) + reader := fake.NewFakeClient(pod) + pluginContext.EXPECT().K8sReader().Return(reader) + + // Even though PyTorchJob status is running, should return failure due to pod status + taskPhase, err := pytorchResourceHandler.GetTaskPhase(ctx, pluginContext, dummyPytorchJobResource(pytorchResourceHandler, 2, kubeflowv1.JobRunning)) + assert.NoError(t, err) + assert.True(t, taskPhase.Phase().IsFailure()) +} + +func TestGetTaskPhaseWithCrashLoopBackOff(t *testing.T) { + pytorchResourceHandler := pytorchOperatorResourceHandler{} + ctx := context.TODO() + + // Create a worker-0 pod in crash loop + pod := &corev1.Pod{ + ObjectMeta: v1.ObjectMeta{ + Name: jobName + "-worker-0", + Namespace: jobNamespace, + }, + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + { + Name: "pytorch", + }, + }, + }, + Status: corev1.PodStatus{ + Phase: corev1.PodRunning, + ContainerStatuses: []corev1.ContainerStatus{ + { + Name: "pytorch", + Ready: false, + RestartCount: 5, + State: corev1.ContainerState{ + Waiting: &corev1.ContainerStateWaiting{ + Reason: "CrashLoopBackOff", + Message: "Back-off restarting failed container", + }, + }, + LastTerminationState: corev1.ContainerState{ + Terminated: &corev1.ContainerStateTerminated{ + ExitCode: 1, + Reason: "Error", + }, + }, + }, + }, + }, + } + + pluginContext := dummyPytorchPluginContext(dummyPytorchTaskTemplate("", dummyPytorchCustomObj(2)), resourceRequirements, k8s.PluginState{}) + reader := fake.NewFakeClient(pod) + pluginContext.EXPECT().K8sReader().Return(reader) + + // CrashLoopBackOff should eventually lead to failure + taskPhase, err := pytorchResourceHandler.GetTaskPhase(ctx, pluginContext, dummyPytorchJobResource(pytorchResourceHandler, 2, kubeflowv1.JobRunning)) + assert.NoError(t, err) + // CrashLoopBackOff may not immediately fail, so we just check it doesn't crash + assert.NotNil(t, taskPhase) +} + +func TestIsTerminal(t *testing.T) { + pytorchResourceHandler := pytorchOperatorResourceHandler{} + ctx := context.Background() + + tests := []struct { + name string + conditionType kubeflowv1.JobConditionType + expectedResult bool + }{ + {"Succeeded", kubeflowv1.JobSucceeded, true}, + {"Failed", kubeflowv1.JobFailed, true}, + {"Created", kubeflowv1.JobCreated, false}, + {"Running", kubeflowv1.JobRunning, false}, + {"Restarting", kubeflowv1.JobRestarting, false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // Create a simple job with only the condition we want to test + job := &kubeflowv1.PyTorchJob{ + Status: kubeflowv1.JobStatus{ + Conditions: []kubeflowv1.JobCondition{ + { + Type: tt.conditionType, + Status: corev1.ConditionTrue, + }, + }, + }, + } + result, err := pytorchResourceHandler.IsTerminal(ctx, job) + assert.NoError(t, err) + assert.Equal(t, tt.expectedResult, result) + }) + } +} + +func TestIsTerminal_WrongResourceType(t *testing.T) { + pytorchResourceHandler := pytorchOperatorResourceHandler{} + ctx := context.Background() + + wrongResource := &corev1.ConfigMap{} + result, err := pytorchResourceHandler.IsTerminal(ctx, wrongResource) + assert.Error(t, err) + assert.False(t, result) + assert.Contains(t, err.Error(), "unexpected resource type") +} + +func TestGetCompletionTime(t *testing.T) { + pytorchResourceHandler := pytorchOperatorResourceHandler{} + + now := time.Now().Truncate(time.Second) + earlier := now.Add(-1 * time.Hour) + evenEarlier := now.Add(-2 * time.Hour) + + tests := []struct { + name string + job *kubeflowv1.PyTorchJob + expectedTime time.Time + }{ + { + name: "uses CompletionTime", + job: &kubeflowv1.PyTorchJob{ + ObjectMeta: v1.ObjectMeta{ + CreationTimestamp: v1.NewTime(evenEarlier), + }, + Status: kubeflowv1.JobStatus{ + CompletionTime: &v1.Time{Time: now}, + StartTime: &v1.Time{Time: earlier}, + }, + }, + expectedTime: now, + }, + { + name: "falls back to condition LastTransitionTime", + job: &kubeflowv1.PyTorchJob{ + ObjectMeta: v1.ObjectMeta{ + CreationTimestamp: v1.NewTime(evenEarlier), + }, + Status: kubeflowv1.JobStatus{ + StartTime: &v1.Time{Time: earlier}, + Conditions: []kubeflowv1.JobCondition{ + { + Type: kubeflowv1.JobSucceeded, + Status: corev1.ConditionTrue, + LastTransitionTime: v1.NewTime(now), + }, + }, + }, + }, + expectedTime: now, + }, + { + name: "falls back to StartTime", + job: &kubeflowv1.PyTorchJob{ + ObjectMeta: v1.ObjectMeta{ + CreationTimestamp: v1.NewTime(evenEarlier), + }, + Status: kubeflowv1.JobStatus{ + StartTime: &v1.Time{Time: now}, + }, + }, + expectedTime: now, + }, + { + name: "falls back to CreationTimestamp", + job: &kubeflowv1.PyTorchJob{ + ObjectMeta: v1.ObjectMeta{ + CreationTimestamp: v1.NewTime(now), + }, + Status: kubeflowv1.JobStatus{}, + }, + expectedTime: now, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result, err := pytorchResourceHandler.GetCompletionTime(tt.job) + assert.NoError(t, err) + assert.Equal(t, tt.expectedTime.Unix(), result.Unix()) + }) + } +} + +func TestGetCompletionTime_WrongResourceType(t *testing.T) { + pytorchResourceHandler := pytorchOperatorResourceHandler{} + + wrongResource := &corev1.ConfigMap{} + result, err := pytorchResourceHandler.GetCompletionTime(wrongResource) + assert.Error(t, err) + assert.True(t, result.IsZero()) + assert.Contains(t, err.Error(), "unexpected resource type") +} diff --git a/flyteplugins/go/tasks/plugins/k8s/kfoperators/tensorflow/tensorflow.go b/flyteplugins/go/tasks/plugins/k8s/kfoperators/tensorflow/tensorflow.go new file mode 100644 index 0000000000..e2352dacef --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/kfoperators/tensorflow/tensorflow.go @@ -0,0 +1,258 @@ +package tensorflow + +import ( + "context" + "fmt" + "time" + + kubeflowv1 "github.com/kubeflow/training-operator/pkg/apis/kubeflow.org/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/kubernetes/scheme" + "sigs.k8s.io/controller-runtime/pkg/client" + + flyteerr "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery" + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/plugins/k8s/kfoperators/common" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" + kfplugins "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow" +) + +type tensorflowOperatorResourceHandler struct { +} + +// Sanity test that the plugin implements method of k8s.Plugin +var _ k8s.Plugin = tensorflowOperatorResourceHandler{} + +func (tensorflowOperatorResourceHandler) GetProperties() k8s.PluginProperties { + return k8s.PluginProperties{} +} + +// Defines a func to create a query object (typically just object and type meta portions) that's used to query k8s +// resources. +func (tensorflowOperatorResourceHandler) BuildIdentityResource(ctx context.Context, taskCtx pluginsCore.TaskExecutionMetadata) (client.Object, error) { + return &kubeflowv1.TFJob{ + TypeMeta: metav1.TypeMeta{ + Kind: kubeflowv1.TFJobKind, + APIVersion: kubeflowv1.SchemeGroupVersion.String(), + }, + }, nil +} + +// Defines a func to create the full resource object that will be posted to k8s. +func (tensorflowOperatorResourceHandler) BuildResource(ctx context.Context, taskCtx pluginsCore.TaskExecutionContext) (client.Object, error) { + taskTemplate, err := taskCtx.TaskReader().Read(ctx) + + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "unable to fetch task specification [%v]", err.Error()) + } else if taskTemplate == nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "nil task specification") + } + + replicaSpecMap := make(map[kubeflowv1.ReplicaType]*kubeflowv1.ReplicaSpec) + runPolicy := kubeflowv1.RunPolicy{} + + if taskTemplate.TaskTypeVersion == 0 { + tensorflowTaskExtraArgs := plugins.DistributedTensorflowTrainingTask{} + + err = utils.UnmarshalStruct(taskTemplate.GetCustom(), &tensorflowTaskExtraArgs) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "invalid TaskSpecification [%v], Err: [%v]", taskTemplate.GetCustom(), err.Error()) + } + + replicaSpec, err := common.ToReplicaSpec(ctx, taskCtx, kubeflowv1.TFJobDefaultContainerName) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "Unable to create replica spec: [%v]", err.Error()) + } + + replicaNumMap := map[kubeflowv1.ReplicaType]int32{ + kubeflowv1.TFJobReplicaTypeChief: tensorflowTaskExtraArgs.GetChiefReplicas(), + kubeflowv1.TFJobReplicaTypeWorker: tensorflowTaskExtraArgs.GetWorkers(), + kubeflowv1.TFJobReplicaTypePS: tensorflowTaskExtraArgs.GetPsReplicas(), + kubeflowv1.TFJobReplicaTypeEval: tensorflowTaskExtraArgs.GetEvaluatorReplicas(), + } + for t, r := range replicaNumMap { + rs := replicaSpec.DeepCopy() + replicas := r + if replicas > 0 { + rs.Replicas = &replicas + replicaSpecMap[t] = rs + } + } + + } else if taskTemplate.TaskTypeVersion == 1 { + kfTensorflowTaskExtraArgs := kfplugins.DistributedTensorflowTrainingTask{} + + err = utils.UnmarshalStruct(taskTemplate.GetCustom(), &kfTensorflowTaskExtraArgs) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "invalid TaskSpecification [%v], Err: [%v]", taskTemplate.GetCustom(), err.Error()) + } + + replicaSpecCfgMap := map[kubeflowv1.ReplicaType]*kfplugins.DistributedTensorflowTrainingReplicaSpec{ + kubeflowv1.TFJobReplicaTypeChief: kfTensorflowTaskExtraArgs.GetChiefReplicas(), + kubeflowv1.TFJobReplicaTypeWorker: kfTensorflowTaskExtraArgs.GetWorkerReplicas(), + kubeflowv1.TFJobReplicaTypePS: kfTensorflowTaskExtraArgs.GetPsReplicas(), + kubeflowv1.TFJobReplicaTypeEval: kfTensorflowTaskExtraArgs.GetEvaluatorReplicas(), + } + for t, cfg := range replicaSpecCfgMap { + // Short circuit if replica set has no replicas to avoid unnecessarily + // generating pod specs + var replicas int32 + // replicas is deprecated since the common replica spec is introduced. + // Therefore, if the common replica spec is set, use that to get the common fields + if cfg.GetCommon() != nil { + replicas = cfg.GetCommon().GetReplicas() + } else { + replicas = cfg.GetReplicas() + } + if replicas <= 0 { + continue + } + + rs, err := common.ToReplicaSpecWithOverrides(ctx, taskCtx, cfg, kubeflowv1.TFJobDefaultContainerName, false) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "Unable to create replica spec: [%v]", err.Error()) + } + replicaSpecMap[t] = rs + } + + if kfTensorflowTaskExtraArgs.GetRunPolicy() != nil { + runPolicy = common.ParseRunPolicy(*kfTensorflowTaskExtraArgs.GetRunPolicy()) + } + + } else { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, + "Invalid TaskSpecification, unsupported task template version [%v] key", taskTemplate.TaskTypeVersion) + } + + if v, ok := replicaSpecMap[kubeflowv1.TFJobReplicaTypeWorker]; !ok || *v.Replicas <= 0 { + return nil, fmt.Errorf("number of workers must be greater than 0") + } + + jobSpec := kubeflowv1.TFJobSpec{ + TFReplicaSpecs: replicaSpecMap, + RunPolicy: runPolicy, + } + + job := &kubeflowv1.TFJob{ + TypeMeta: metav1.TypeMeta{ + Kind: kubeflowv1.TFJobKind, + APIVersion: kubeflowv1.SchemeGroupVersion.String(), + }, + Spec: jobSpec, + } + + return job, nil +} + +// Analyses the k8s resource and reports the status as TaskPhase. This call is expected to be relatively fast, +// any operations that might take a long time (limits are configured system-wide) should be offloaded to the +// background. +func (tensorflowOperatorResourceHandler) GetTaskPhase(ctx context.Context, pluginContext k8s.PluginContext, resource client.Object) (pluginsCore.PhaseInfo, error) { + app, ok := resource.(*kubeflowv1.TFJob) + if !ok { + return pluginsCore.PhaseInfoUndefined, fmt.Errorf("failed to convert resource data type") + } + + taskTemplate, err := pluginContext.TaskReader().Read(ctx) + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + + workersCount := common.GetReplicaCount(app.Spec.TFReplicaSpecs, kubeflowv1.TFJobReplicaTypeWorker) + psReplicasCount := common.GetReplicaCount(app.Spec.TFReplicaSpecs, kubeflowv1.TFJobReplicaTypePS) + chiefCount := common.GetReplicaCount(app.Spec.TFReplicaSpecs, kubeflowv1.TFJobReplicaTypeChief) + evaluatorReplicasCount := common.GetReplicaCount(app.Spec.TFReplicaSpecs, kubeflowv1.TFJobReplicaTypeEval) + + taskLogs, err := common.GetLogs(pluginContext, common.TensorflowTaskType, app.ObjectMeta, taskTemplate, false, + *workersCount, *psReplicasCount, *chiefCount, *evaluatorReplicasCount, kubeflowv1.TFJobDefaultContainerName) + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + + if app.Status.StartTime == nil && app.CreationTimestamp.Add(common.GetConfig().Timeout.Duration).Before(time.Now()) { + return pluginsCore.PhaseInfoUndefined, fmt.Errorf("kubeflow operator hasn't updated the tensorflow custom resource since creation time %v", app.CreationTimestamp) + } + + currentCondition, err := common.ExtractCurrentCondition(app.Status.Conditions) + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + + occurredAt := time.Now() + statusDetails, _ := utils.MarshalObjToStruct(app.Status) + taskPhaseInfo := pluginsCore.TaskInfo{ + Logs: taskLogs, + LogContext: nil, // TODO populate log context + OccurredAt: &occurredAt, + CustomInfo: statusDetails, + } + + phaseInfo, err := common.GetPhaseInfo(currentCondition, occurredAt, taskPhaseInfo) + + phaseVersionUpdateErr := k8s.MaybeUpdatePhaseVersionFromPluginContext(&phaseInfo, &pluginContext) + if phaseVersionUpdateErr != nil { + return phaseInfo, phaseVersionUpdateErr + } + + return phaseInfo, err +} + +// IsTerminal returns true if the TFJob is in a terminal state (Succeeded or Failed) +func (tensorflowOperatorResourceHandler) IsTerminal(_ context.Context, resource client.Object) (bool, error) { + job, ok := resource.(*kubeflowv1.TFJob) + if !ok { + return false, fmt.Errorf("unexpected resource type: expected *TFJob, got %T", resource) + } + for _, condition := range job.Status.Conditions { + if condition.Type == kubeflowv1.JobSucceeded || condition.Type == kubeflowv1.JobFailed { + return true, nil + } + } + return false, nil +} + +// GetCompletionTime returns the completion time of the TFJob +func (tensorflowOperatorResourceHandler) GetCompletionTime(resource client.Object) (time.Time, error) { + job, ok := resource.(*kubeflowv1.TFJob) + if !ok { + return time.Time{}, fmt.Errorf("unexpected resource type: expected *TFJob, got %T", resource) + } + + if job.Status.CompletionTime != nil { + return job.Status.CompletionTime.Time, nil + } + + // Fallback to last condition transition time + for _, condition := range job.Status.Conditions { + if condition.Type == kubeflowv1.JobSucceeded || condition.Type == kubeflowv1.JobFailed { + if !condition.LastTransitionTime.IsZero() { + return condition.LastTransitionTime.Time, nil + } + } + } + + // Fallback to start time or creation time + if job.Status.StartTime != nil { + return job.Status.StartTime.Time, nil + } + + return job.CreationTimestamp.Time, nil +} + +func init() { + if err := kubeflowv1.AddToScheme(scheme.Scheme); err != nil { + panic(err) + } + + pluginmachinery.PluginRegistry().RegisterK8sPlugin( + k8s.PluginEntry{ + ID: common.TensorflowTaskType, + RegisteredTaskTypes: []pluginsCore.TaskType{common.TensorflowTaskType}, + ResourceToWatch: &kubeflowv1.TFJob{}, + Plugin: tensorflowOperatorResourceHandler{}, + IsDefault: false, + }) +} diff --git a/flyteplugins/go/tasks/plugins/k8s/kfoperators/tensorflow/tensorflow_test.go b/flyteplugins/go/tasks/plugins/k8s/kfoperators/tensorflow/tensorflow_test.go new file mode 100644 index 0000000000..5263f77a8d --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/kfoperators/tensorflow/tensorflow_test.go @@ -0,0 +1,1299 @@ +package tensorflow + +import ( + "context" + "fmt" + "reflect" + "testing" + "time" + + structpb "github.com/golang/protobuf/ptypes/struct" + kubeflowv1 "github.com/kubeflow/training-operator/pkg/apis/kubeflow.org/v1" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/logs" + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s" + flytek8sConfig "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + pluginIOMocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + k8smocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/plugins/k8s/kfoperators/common" + stdlibUtils "github.com/flyteorg/flyte/v2/flytestdlib/utils" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" + kfplugins "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow" +) + +const testImage = "image://" +const serviceAccount = "tensorflow_sa" + +var ( + dummyEnvVars = []*core.KeyValuePair{ + {Key: "Env_Var", Value: "Env_Val"}, + } + + testArgs = []string{ + "test-args", + } + + dummyAnnotations = map[string]string{ + "annotation-key": "annotation-value", + } + dummyLabels = map[string]string{ + "label-key": "label-value", + } + + resourceRequirements = &corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("1000m"), + corev1.ResourceMemory: resource.MustParse("1Gi"), + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + Requests: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("100m"), + corev1.ResourceMemory: resource.MustParse("512Mi"), + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + } + + jobName = "the-job" + jobNamespace = "tensorflow-namespace" +) + +func dummyTensorFlowCustomObj(workers int32, psReplicas int32, chiefReplicas int32, evaluatorReplicas int32) *plugins.DistributedTensorflowTrainingTask { + return &plugins.DistributedTensorflowTrainingTask{ + Workers: workers, + PsReplicas: psReplicas, + ChiefReplicas: chiefReplicas, + EvaluatorReplicas: evaluatorReplicas, + } +} + +func dummyTensorFlowTaskTemplate(id string, args ...interface{}) *core.TaskTemplate { + + var tfObjJSON string + var err error + + for _, arg := range args { + switch t := arg.(type) { + case *kfplugins.DistributedTensorflowTrainingTask: + var tensorflowCustomObj = t + tfObjJSON, err = utils.MarshalToString(tensorflowCustomObj) + case *plugins.DistributedTensorflowTrainingTask: + var tensorflowCustomObj = t + tfObjJSON, err = utils.MarshalToString(tensorflowCustomObj) + default: + err = fmt.Errorf("Unknown input type %T", t) + } + } + + if err != nil { + panic(err) + } + + structObj := structpb.Struct{} + + err = stdlibUtils.UnmarshalStringToPb(tfObjJSON, &structObj) + if err != nil { + panic(err) + } + + return &core.TaskTemplate{ + Id: &core.Identifier{Name: id}, + Type: "container", + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Image: testImage, + Args: testArgs, + Env: dummyEnvVars, + }, + }, + Custom: &structObj, + } +} + +func dummyTensorFlowTaskContext(taskTemplate *core.TaskTemplate, resources *corev1.ResourceRequirements, extendedResources *core.ExtendedResources) pluginsCore.TaskExecutionContext { + taskCtx := &mocks.TaskExecutionContext{} + inputReader := &pluginIOMocks.InputReader{} + inputReader.EXPECT().GetInputPrefixPath().Return("/input/prefix") + inputReader.EXPECT().GetInputPath().Return("/input") + inputReader.EXPECT().Get(mock.Anything).Return(&core.LiteralMap{}, nil) + taskCtx.EXPECT().InputReader().Return(inputReader) + + outputReader := &pluginIOMocks.OutputWriter{} + outputReader.EXPECT().GetOutputPath().Return("/data/outputs.pb") + outputReader.EXPECT().GetOutputPrefixPath().Return("/data/") + outputReader.EXPECT().GetRawOutputPrefix().Return("") + outputReader.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + outputReader.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + taskCtx.EXPECT().OutputWriter().Return(outputReader) + + taskReader := &mocks.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(taskTemplate, nil) + taskCtx.EXPECT().TaskReader().Return(taskReader) + + tID := &mocks.TaskExecutionID{} + tID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my_name", + Project: "my_project", + Domain: "my_domain", + }, + }, + }) + tID.EXPECT().GetGeneratedName().Return("some-acceptable-name") + tID.EXPECT().GetUniqueNodeID().Return("an-unique-id") + + overrides := &mocks.TaskOverrides{} + overrides.EXPECT().GetResources().Return(resources) + overrides.EXPECT().GetExtendedResources().Return(extendedResources) + overrides.EXPECT().GetContainerImage().Return("") + overrides.EXPECT().GetPodTemplate().Return(nil) + + taskExecutionMetadata := &mocks.TaskExecutionMetadata{} + taskExecutionMetadata.EXPECT().GetTaskExecutionID().Return(tID) + taskExecutionMetadata.EXPECT().GetNamespace().Return("test-namespace") + taskExecutionMetadata.EXPECT().GetAnnotations().Return(dummyAnnotations) + taskExecutionMetadata.EXPECT().GetLabels().Return(dummyLabels) + taskExecutionMetadata.EXPECT().GetOwnerReference().Return(v1.OwnerReference{ + Kind: "node", + Name: "blah", + }) + taskExecutionMetadata.EXPECT().IsInterruptible().Return(true) + taskExecutionMetadata.EXPECT().GetOverrides().Return(overrides) + taskExecutionMetadata.EXPECT().GetK8sServiceAccount().Return(serviceAccount) + taskExecutionMetadata.EXPECT().GetPlatformResources().Return(&corev1.ResourceRequirements{}) + taskExecutionMetadata.EXPECT().GetEnvironmentVariables().Return(nil) + taskExecutionMetadata.EXPECT().GetConsoleURL().Return("") + taskCtx.EXPECT().TaskExecutionMetadata().Return(taskExecutionMetadata) + pluginStateReaderMock := mocks.PluginStateReader{} + pluginStateReaderMock.EXPECT().Get(mock.AnythingOfType(reflect.TypeOf(&k8s.PluginState{}).String())).RunAndReturn( + func(v interface{}) (uint8, error) { + *(v.(*k8s.PluginState)) = k8s.PluginState{} + return 0, nil + }) + + taskCtx.EXPECT().PluginStateReader().Return(&pluginStateReaderMock) + return taskCtx +} + +func dummyTensorFlowPluginContext(taskTemplate *core.TaskTemplate, resources *corev1.ResourceRequirements, extendedResources *core.ExtendedResources, pluginState k8s.PluginState) *k8smocks.PluginContext { + pCtx := &k8smocks.PluginContext{} + inputReader := &pluginIOMocks.InputReader{} + inputReader.EXPECT().GetInputPrefixPath().Return("/input/prefix") + inputReader.EXPECT().GetInputPath().Return("/input") + inputReader.EXPECT().Get(mock.Anything).Return(&core.LiteralMap{}, nil) + pCtx.EXPECT().InputReader().Return(inputReader) + + outputReader := &pluginIOMocks.OutputWriter{} + outputReader.EXPECT().GetOutputPath().Return("/data/outputs.pb") + outputReader.EXPECT().GetOutputPrefixPath().Return("/data/") + outputReader.EXPECT().GetRawOutputPrefix().Return("") + outputReader.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + outputReader.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + pCtx.EXPECT().OutputWriter().Return(outputReader) + + taskReader := &mocks.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(taskTemplate, nil) + pCtx.EXPECT().TaskReader().Return(taskReader) + + tID := &mocks.TaskExecutionID{} + tID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my_name", + Project: "my_project", + Domain: "my_domain", + }, + }, + }) + tID.EXPECT().GetGeneratedName().Return("some-acceptable-name") + tID.EXPECT().GetUniqueNodeID().Return("an-unique-id") + + overrides := &mocks.TaskOverrides{} + overrides.EXPECT().GetResources().Return(resources) + overrides.EXPECT().GetExtendedResources().Return(extendedResources) + overrides.EXPECT().GetContainerImage().Return("") + + taskExecutionMetadata := &mocks.TaskExecutionMetadata{} + taskExecutionMetadata.EXPECT().GetTaskExecutionID().Return(tID) + taskExecutionMetadata.EXPECT().GetNamespace().Return("test-namespace") + taskExecutionMetadata.EXPECT().GetAnnotations().Return(dummyAnnotations) + taskExecutionMetadata.EXPECT().GetLabels().Return(dummyLabels) + taskExecutionMetadata.EXPECT().GetOwnerReference().Return(v1.OwnerReference{ + Kind: "node", + Name: "blah", + }) + taskExecutionMetadata.EXPECT().IsInterruptible().Return(true) + taskExecutionMetadata.EXPECT().GetOverrides().Return(overrides) + taskExecutionMetadata.EXPECT().GetK8sServiceAccount().Return(serviceAccount) + taskExecutionMetadata.EXPECT().GetPlatformResources().Return(&corev1.ResourceRequirements{}) + taskExecutionMetadata.EXPECT().GetEnvironmentVariables().Return(nil) + taskExecutionMetadata.EXPECT().GetConsoleURL().Return("") + pCtx.EXPECT().TaskExecutionMetadata().Return(taskExecutionMetadata) + + pluginStateReaderMock := mocks.PluginStateReader{} + pluginStateReaderMock.EXPECT().Get(mock.AnythingOfType(reflect.TypeOf(&pluginState).String())).RunAndReturn( + func(v interface{}) (uint8, error) { + *(v.(*k8s.PluginState)) = pluginState + return 0, nil + }) + pCtx.EXPECT().PluginStateReader().Return(&pluginStateReaderMock) + + return pCtx +} + +func dummyTensorFlowJobResource(tensorflowResourceHandler tensorflowOperatorResourceHandler, + workers int32, psReplicas int32, chiefReplicas int32, evaluatorReplicas int32, conditionType kubeflowv1.JobConditionType) *kubeflowv1.TFJob { + var jobConditions []kubeflowv1.JobCondition + + now := time.Now() + + jobCreated := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobCreated, + Status: corev1.ConditionTrue, + Reason: "TensorFlowJobCreated", + Message: "TensorFlowJob the-job is created.", + LastUpdateTime: v1.Time{ + Time: now, + }, + LastTransitionTime: v1.Time{ + Time: now, + }, + } + jobRunningActive := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobRunning, + Status: corev1.ConditionTrue, + Reason: "TensorFlowJobRunning", + Message: "TensorFlowJob the-job is running.", + LastUpdateTime: v1.Time{ + Time: now.Add(time.Minute), + }, + LastTransitionTime: v1.Time{ + Time: now.Add(time.Minute), + }, + } + jobRunningInactive := *jobRunningActive.DeepCopy() + jobRunningInactive.Status = corev1.ConditionFalse + jobSucceeded := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobSucceeded, + Status: corev1.ConditionTrue, + Reason: "TensorFlowJobSucceeded", + Message: "TensorFlowJob the-job is successfully completed.", + LastUpdateTime: v1.Time{ + Time: now.Add(2 * time.Minute), + }, + LastTransitionTime: v1.Time{ + Time: now.Add(2 * time.Minute), + }, + } + jobFailed := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobFailed, + Status: corev1.ConditionTrue, + Reason: "TensorFlowJobFailed", + Message: "TensorFlowJob the-job is failed.", + LastUpdateTime: v1.Time{ + Time: now.Add(2 * time.Minute), + }, + LastTransitionTime: v1.Time{ + Time: now.Add(2 * time.Minute), + }, + } + jobRestarting := kubeflowv1.JobCondition{ + Type: kubeflowv1.JobRestarting, + Status: corev1.ConditionTrue, + Reason: "TensorFlowJobRestarting", + Message: "TensorFlowJob the-job is restarting because some replica(s) failed.", + LastUpdateTime: v1.Time{ + Time: now.Add(3 * time.Minute), + }, + LastTransitionTime: v1.Time{ + Time: now.Add(3 * time.Minute), + }, + } + + switch conditionType { + case kubeflowv1.JobCreated: + jobConditions = []kubeflowv1.JobCondition{ + jobCreated, + } + case kubeflowv1.JobRunning: + jobConditions = []kubeflowv1.JobCondition{ + jobCreated, + jobRunningActive, + } + case kubeflowv1.JobSucceeded: + jobConditions = []kubeflowv1.JobCondition{ + jobCreated, + jobRunningInactive, + jobSucceeded, + } + case kubeflowv1.JobFailed: + jobConditions = []kubeflowv1.JobCondition{ + jobCreated, + jobRunningInactive, + jobFailed, + } + case kubeflowv1.JobRestarting: + jobConditions = []kubeflowv1.JobCondition{ + jobCreated, + jobRunningInactive, + jobFailed, + jobRestarting, + } + } + + tfObj := dummyTensorFlowCustomObj(workers, psReplicas, chiefReplicas, evaluatorReplicas) + taskTemplate := dummyTensorFlowTaskTemplate("the job", tfObj) + resource, err := tensorflowResourceHandler.BuildResource(context.TODO(), dummyTensorFlowTaskContext(taskTemplate, resourceRequirements, nil)) + if err != nil { + panic(err) + } + + return &kubeflowv1.TFJob{ + ObjectMeta: v1.ObjectMeta{ + Name: jobName, + Namespace: jobNamespace, + }, + Spec: resource.(*kubeflowv1.TFJob).Spec, + Status: kubeflowv1.JobStatus{ + Conditions: jobConditions, + ReplicaStatuses: nil, + StartTime: &v1.Time{Time: time.Now()}, + CompletionTime: nil, + LastReconcileTime: nil, + }, + } +} + +func TestGetReplicaCount(t *testing.T) { + tensorflowResourceHandler := tensorflowOperatorResourceHandler{} + tfObj := dummyTensorFlowCustomObj(1, 0, 0, 0) + taskTemplate := dummyTensorFlowTaskTemplate("the job", tfObj) + resource, err := tensorflowResourceHandler.BuildResource(context.TODO(), dummyTensorFlowTaskContext(taskTemplate, resourceRequirements, nil)) + assert.NoError(t, err) + assert.NotNil(t, resource) + tensorflowJob, ok := resource.(*kubeflowv1.TFJob) + assert.True(t, ok) + + assert.NotNil(t, common.GetReplicaCount(tensorflowJob.Spec.TFReplicaSpecs, kubeflowv1.TFJobReplicaTypeWorker)) + assert.NotNil(t, common.GetReplicaCount(tensorflowJob.Spec.TFReplicaSpecs, kubeflowv1.TFJobReplicaTypePS)) + assert.NotNil(t, common.GetReplicaCount(tensorflowJob.Spec.TFReplicaSpecs, kubeflowv1.TFJobReplicaTypeChief)) + assert.NotNil(t, common.GetReplicaCount(tensorflowJob.Spec.TFReplicaSpecs, kubeflowv1.TFJobReplicaTypeEval)) +} + +func TestBuildResourceTensorFlow(t *testing.T) { + tensorflowResourceHandler := tensorflowOperatorResourceHandler{} + + tfObj := dummyTensorFlowCustomObj(100, 50, 1, 1) + taskTemplate := dummyTensorFlowTaskTemplate("the job", tfObj) + + resource, err := tensorflowResourceHandler.BuildResource(context.TODO(), dummyTensorFlowTaskContext(taskTemplate, resourceRequirements, nil)) + assert.NoError(t, err) + assert.NotNil(t, resource) + + tensorflowJob, ok := resource.(*kubeflowv1.TFJob) + assert.True(t, ok) + assert.Equal(t, int32(100), *tensorflowJob.Spec.TFReplicaSpecs[kubeflowv1.TFJobReplicaTypeWorker].Replicas) + assert.Equal(t, int32(50), *tensorflowJob.Spec.TFReplicaSpecs[kubeflowv1.TFJobReplicaTypePS].Replicas) + assert.Equal(t, int32(1), *tensorflowJob.Spec.TFReplicaSpecs[kubeflowv1.TFJobReplicaTypeChief].Replicas) + assert.Equal(t, int32(1), *tensorflowJob.Spec.TFReplicaSpecs[kubeflowv1.TFJobReplicaTypeEval].Replicas) + + // verify TaskExecutionMetadata labels and annotations are copied to the TensorFlowJob + for k, v := range dummyAnnotations { + for _, replicaSpec := range tensorflowJob.Spec.TFReplicaSpecs { + assert.Equal(t, v, replicaSpec.Template.ObjectMeta.Annotations[k]) + } + } + for k, v := range dummyLabels { + for _, replicaSpec := range tensorflowJob.Spec.TFReplicaSpecs { + assert.Equal(t, v, replicaSpec.Template.ObjectMeta.Labels[k]) + } + } + + for _, replicaSpec := range tensorflowJob.Spec.TFReplicaSpecs { + var hasContainerWithDefaultTensorFlowName = false + podSpec := replicaSpec.Template.Spec + for _, container := range podSpec.Containers { + if container.Name == kubeflowv1.TFJobDefaultContainerName { + hasContainerWithDefaultTensorFlowName = true + } + + assert.Equal(t, resourceRequirements.Requests, container.Resources.Requests) + assert.Equal(t, resourceRequirements.Limits, container.Resources.Limits) + } + + assert.True(t, hasContainerWithDefaultTensorFlowName) + } +} + +func TestBuildResourceTensorFlowExtendedResources(t *testing.T) { + assert.NoError(t, flytek8sConfig.SetK8sPluginConfig(&flytek8sConfig.K8sPluginConfig{ + GpuDeviceNodeLabel: "gpu-node-label", + GpuPartitionSizeNodeLabel: "gpu-partition-size", + GpuResourceName: flytek8s.ResourceNvidiaGPU, + })) + + fixtures := []struct { + name string + resources *corev1.ResourceRequirements + extendedResourcesBase *core.ExtendedResources + extendedResourcesOverride *core.ExtendedResources + expectedNsr []corev1.NodeSelectorTerm + expectedTol []corev1.Toleration + }{ + { + "without overrides", + &corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-t4", + }, + }, + nil, + []corev1.NodeSelectorTerm{ + { + MatchExpressions: []corev1.NodeSelectorRequirement{ + corev1.NodeSelectorRequirement{ + Key: "gpu-node-label", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-t4"}, + }, + }, + }, + }, + []corev1.Toleration{ + { + Key: "gpu-node-label", + Value: "nvidia-tesla-t4", + Operator: corev1.TolerationOpEqual, + Effect: corev1.TaintEffectNoSchedule, + }, + }, + }, + { + "with overrides", + &corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-t4", + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-a100", + PartitionSizeValue: &core.GPUAccelerator_PartitionSize{ + PartitionSize: "1g.5gb", + }, + }, + }, + []corev1.NodeSelectorTerm{ + { + MatchExpressions: []corev1.NodeSelectorRequirement{ + corev1.NodeSelectorRequirement{ + Key: "gpu-node-label", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-a100"}, + }, + corev1.NodeSelectorRequirement{ + Key: "gpu-partition-size", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"1g.5gb"}, + }, + }, + }, + }, + []corev1.Toleration{ + { + Key: "gpu-node-label", + Value: "nvidia-tesla-a100", + Operator: corev1.TolerationOpEqual, + Effect: corev1.TaintEffectNoSchedule, + }, + { + Key: "gpu-partition-size", + Value: "1g.5gb", + Operator: corev1.TolerationOpEqual, + Effect: corev1.TaintEffectNoSchedule, + }, + }, + }, + } + + v0TaskTemplate := dummyTensorFlowTaskTemplate("v0", dummyTensorFlowCustomObj(100, 50, 1, 1)) + v1TaskTemplates := []*core.TaskTemplate{ + dummyTensorFlowTaskTemplate("v1", &kfplugins.DistributedTensorflowTrainingTask{ + ChiefReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Replicas: 1, + }, + WorkerReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Replicas: 100, + }, + PsReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Replicas: 50, + }, + EvaluatorReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Replicas: 1, + }, + }), + dummyTensorFlowTaskTemplate("v1", &kfplugins.DistributedTensorflowTrainingTask{ + ChiefReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 1, + }, + }, + WorkerReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 100, + }, + }, + PsReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 50, + }, + }, + EvaluatorReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 1, + }, + }, + }), + } + for _, v1TaskTemplate := range v1TaskTemplates { + v1TaskTemplate.TaskTypeVersion = 1 + testConfigs := []struct { + name string + taskTemplate *core.TaskTemplate + }{ + {"v0", v0TaskTemplate}, + {"v1", v1TaskTemplate}, + } + + for _, tCfg := range testConfigs { + for _, f := range fixtures { + t.Run(tCfg.name+" "+f.name, func(t *testing.T) { + taskTemplate := *tCfg.taskTemplate + taskTemplate.ExtendedResources = f.extendedResourcesBase + tensorflowResourceHandler := tensorflowOperatorResourceHandler{} + taskContext := dummyTensorFlowTaskContext(&taskTemplate, f.resources, f.extendedResourcesOverride) + r, err := tensorflowResourceHandler.BuildResource(context.TODO(), taskContext) + assert.NoError(t, err) + assert.NotNil(t, r) + tensorflowJob, ok := r.(*kubeflowv1.TFJob) + assert.True(t, ok) + + for _, replicaSpec := range tensorflowJob.Spec.TFReplicaSpecs { + assert.EqualValues( + t, + f.expectedNsr, + replicaSpec.Template.Spec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + f.expectedTol, + replicaSpec.Template.Spec.Tolerations, + ) + } + }) + } + } + } +} + +func TestGetTaskPhase(t *testing.T) { + tensorflowResourceHandler := tensorflowOperatorResourceHandler{} + ctx := context.TODO() + + dummyTensorFlowJobResourceCreator := func(conditionType kubeflowv1.JobConditionType) *kubeflowv1.TFJob { + return dummyTensorFlowJobResource(tensorflowResourceHandler, 2, 1, 1, 1, conditionType) + } + + pluginContext := dummyTensorFlowPluginContext(dummyTensorFlowTaskTemplate("", dummyTensorFlowCustomObj(2, 1, 1, 1)), resourceRequirements, nil, k8s.PluginState{}) + taskPhase, err := tensorflowResourceHandler.GetTaskPhase(ctx, pluginContext, dummyTensorFlowJobResourceCreator(kubeflowv1.JobCreated)) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseQueued, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + taskPhase, err = tensorflowResourceHandler.GetTaskPhase(ctx, pluginContext, dummyTensorFlowJobResourceCreator(kubeflowv1.JobRunning)) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRunning, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + taskPhase, err = tensorflowResourceHandler.GetTaskPhase(ctx, pluginContext, dummyTensorFlowJobResourceCreator(kubeflowv1.JobSucceeded)) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseSuccess, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + taskPhase, err = tensorflowResourceHandler.GetTaskPhase(ctx, pluginContext, dummyTensorFlowJobResourceCreator(kubeflowv1.JobFailed)) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) + + taskPhase, err = tensorflowResourceHandler.GetTaskPhase(ctx, pluginContext, dummyTensorFlowJobResourceCreator(kubeflowv1.JobRestarting)) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRunning, taskPhase.Phase()) + assert.NotNil(t, taskPhase.Info()) + assert.Nil(t, err) +} + +func TestGetTaskPhaseIncreasePhaseVersion(t *testing.T) { + tensorflowResourceHandler := tensorflowOperatorResourceHandler{} + ctx := context.TODO() + + pluginState := k8s.PluginState{ + Phase: pluginsCore.PhaseQueued, + PhaseVersion: pluginsCore.DefaultPhaseVersion, + Reason: "task submitted to K8s", + } + pluginContext := dummyTensorFlowPluginContext(dummyTensorFlowTaskTemplate("", dummyTensorFlowCustomObj(2, 1, 1, 1)), resourceRequirements, nil, pluginState) + + taskPhase, err := tensorflowResourceHandler.GetTaskPhase(ctx, pluginContext, dummyTensorFlowJobResource(tensorflowResourceHandler, 2, 1, 1, 1, kubeflowv1.JobCreated)) + + assert.NoError(t, err) + assert.Equal(t, taskPhase.Version(), pluginsCore.DefaultPhaseVersion+1) +} + +func TestGetLogs(t *testing.T) { + assert.NoError(t, logs.SetLogConfig(&logs.LogConfig{ + IsKubernetesEnabled: true, + KubernetesURL: "k8s.com", + })) + + workers := int32(2) + psReplicas := int32(1) + chiefReplicas := int32(1) + evaluatorReplicas := int32(1) + + tensorflowResourceHandler := tensorflowOperatorResourceHandler{} + tensorFlowJob := dummyTensorFlowJobResource(tensorflowResourceHandler, workers, psReplicas, chiefReplicas, evaluatorReplicas, kubeflowv1.JobRunning) + taskTemplate := dummyTensorFlowTaskTemplate("", dummyTensorFlowCustomObj(workers, psReplicas, chiefReplicas, evaluatorReplicas)) + pluginContext := dummyTensorFlowPluginContext(taskTemplate, resourceRequirements, nil, k8s.PluginState{}) + jobLogs, err := common.GetLogs(pluginContext, common.TensorflowTaskType, tensorFlowJob.ObjectMeta, taskTemplate, false, + workers, psReplicas, chiefReplicas, evaluatorReplicas, kubeflowv1.TFJobDefaultContainerName) + + assert.NoError(t, err) + assert.Equal(t, 5, len(jobLogs)) + assert.Equal(t, fmt.Sprintf("k8s.com/#!/log/%s/%s-worker-0/pod?namespace=tensorflow-namespace", jobNamespace, jobName), jobLogs[0].Uri) + assert.Equal(t, fmt.Sprintf("k8s.com/#!/log/%s/%s-worker-1/pod?namespace=tensorflow-namespace", jobNamespace, jobName), jobLogs[1].Uri) + assert.Equal(t, fmt.Sprintf("k8s.com/#!/log/%s/%s-psReplica-0/pod?namespace=tensorflow-namespace", jobNamespace, jobName), jobLogs[2].Uri) + assert.Equal(t, fmt.Sprintf("k8s.com/#!/log/%s/%s-chiefReplica-0/pod?namespace=tensorflow-namespace", jobNamespace, jobName), jobLogs[3].Uri) + assert.Equal(t, fmt.Sprintf("k8s.com/#!/log/%s/%s-evaluatorReplica-0/pod?namespace=tensorflow-namespace", jobNamespace, jobName), jobLogs[4].Uri) +} + +func TestGetProperties(t *testing.T) { + tensorflowResourceHandler := tensorflowOperatorResourceHandler{} + expected := k8s.PluginProperties{} + assert.Equal(t, expected, tensorflowResourceHandler.GetProperties()) +} + +func TestReplicaCounts(t *testing.T) { + for _, test := range []struct { + name string + chiefReplicaCount int32 + psReplicaCount int32 + workerReplicaCount int32 + evaluatorReplicaCount int32 + expectError bool + contains []kubeflowv1.ReplicaType + notContains []kubeflowv1.ReplicaType + }{ + {"NoWorkers", 1, 1, 0, 1, true, nil, nil}, + {"SingleChief", 1, 0, 1, 0, false, + []kubeflowv1.ReplicaType{kubeflowv1.TFJobReplicaTypeChief, kubeflowv1.TFJobReplicaTypeWorker}, + []kubeflowv1.ReplicaType{kubeflowv1.TFJobReplicaTypePS, kubeflowv1.TFJobReplicaTypeEval}}, + {"SinglePS", 0, 1, 1, 0, false, + []kubeflowv1.ReplicaType{kubeflowv1.TFJobReplicaTypePS, kubeflowv1.TFJobReplicaTypeWorker}, + []kubeflowv1.ReplicaType{kubeflowv1.TFJobReplicaTypeChief, kubeflowv1.TFJobReplicaTypeEval}}, + {"AllContains", 1, 1, 1, 1, false, + []kubeflowv1.ReplicaType{kubeflowv1.TFJobReplicaTypePS, kubeflowv1.TFJobReplicaTypeWorker, kubeflowv1.TFJobReplicaTypeChief, kubeflowv1.TFJobReplicaTypeEval}, + nil, + }, + } { + t.Run(test.name, func(t *testing.T) { + tensorflowResourceHandler := tensorflowOperatorResourceHandler{} + + tfObj := dummyTensorFlowCustomObj(test.workerReplicaCount, test.psReplicaCount, test.chiefReplicaCount, test.evaluatorReplicaCount) + taskTemplate := dummyTensorFlowTaskTemplate("the job", tfObj) + + resource, err := tensorflowResourceHandler.BuildResource(context.TODO(), dummyTensorFlowTaskContext(taskTemplate, resourceRequirements, nil)) + if test.expectError { + assert.Error(t, err) + assert.Nil(t, resource) + return + } + + assert.NoError(t, err) + assert.NotNil(t, resource) + + job, ok := resource.(*kubeflowv1.TFJob) + assert.True(t, ok) + + assert.Len(t, job.Spec.TFReplicaSpecs, len(test.contains)) + for _, replicaType := range test.contains { + assert.Contains(t, job.Spec.TFReplicaSpecs, replicaType) + } + for _, replicaType := range test.notContains { + assert.NotContains(t, job.Spec.TFReplicaSpecs, replicaType) + } + }) + } +} + +func TestBuildResourceTensorFlowV1(t *testing.T) { + taskConfigs := []*kfplugins.DistributedTensorflowTrainingTask{ + { + ChiefReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Replicas: 1, + Image: testImage, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "500m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + }, + }, + RestartPolicy: plugins.RestartPolicy_RESTART_POLICY_ALWAYS, + }, + WorkerReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Replicas: 100, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "2048m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + }, + }, + PsReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Replicas: 50, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "500m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + }, + }, + }, + EvaluatorReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Replicas: 1, + Image: testImage, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "500m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + }, + }, + RestartPolicy: plugins.RestartPolicy_RESTART_POLICY_ALWAYS, + }, + RunPolicy: &kfplugins.RunPolicy{ + CleanPodPolicy: kfplugins.CleanPodPolicy_CLEANPOD_POLICY_ALL, + ActiveDeadlineSeconds: int32(100), + }, + }, + { + ChiefReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 1, + Image: testImage, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "500m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + }, + }, + RestartPolicy: plugins.RestartPolicy_RESTART_POLICY_ALWAYS, + }, + }, + WorkerReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 100, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "2048m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + }, + }, + }, + PsReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 50, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "500m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + }, + }, + }, + }, + EvaluatorReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 1, + Image: testImage, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "500m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + }, + }, + RestartPolicy: plugins.RestartPolicy_RESTART_POLICY_ALWAYS, + }, + }, + RunPolicy: &kfplugins.RunPolicy{ + CleanPodPolicy: kfplugins.CleanPodPolicy_CLEANPOD_POLICY_ALL, + ActiveDeadlineSeconds: int32(100), + }, + }, + } + for _, taskConfig := range taskConfigs { + + resourceRequirementsMap := map[kubeflowv1.ReplicaType]*corev1.ResourceRequirements{ + kubeflowv1.TFJobReplicaTypeChief: { + Requests: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("250m"), + corev1.ResourceMemory: resource.MustParse("1Gi"), + }, + Limits: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("500m"), + corev1.ResourceMemory: resource.MustParse("2Gi"), + }, + }, + kubeflowv1.TFJobReplicaTypeWorker: { + Requests: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("1024m"), + corev1.ResourceMemory: resource.MustParse("1Gi"), + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + Limits: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("2048m"), + corev1.ResourceMemory: resource.MustParse("2Gi"), + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + kubeflowv1.TFJobReplicaTypePS: { + Requests: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("250m"), + corev1.ResourceMemory: resource.MustParse("1Gi"), + }, + Limits: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("500m"), + corev1.ResourceMemory: resource.MustParse("2Gi"), + }, + }, + kubeflowv1.TFJobReplicaTypeEval: { + Requests: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("250m"), + corev1.ResourceMemory: resource.MustParse("1Gi"), + }, + Limits: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("500m"), + corev1.ResourceMemory: resource.MustParse("2Gi"), + }, + }, + } + + tensorflowResourceHandler := tensorflowOperatorResourceHandler{} + + taskTemplate := dummyTensorFlowTaskTemplate("v1", taskConfig) + taskTemplate.TaskTypeVersion = 1 + + resource, err := tensorflowResourceHandler.BuildResource(context.TODO(), dummyTensorFlowTaskContext(taskTemplate, resourceRequirements, nil)) + assert.NoError(t, err) + assert.NotNil(t, resource) + + tensorflowJob, ok := resource.(*kubeflowv1.TFJob) + assert.True(t, ok) + assert.Equal(t, int32(100), *tensorflowJob.Spec.TFReplicaSpecs[kubeflowv1.TFJobReplicaTypeWorker].Replicas) + assert.Equal(t, int32(50), *tensorflowJob.Spec.TFReplicaSpecs[kubeflowv1.TFJobReplicaTypePS].Replicas) + assert.Equal(t, int32(1), *tensorflowJob.Spec.TFReplicaSpecs[kubeflowv1.TFJobReplicaTypeChief].Replicas) + assert.Equal(t, int32(1), *tensorflowJob.Spec.TFReplicaSpecs[kubeflowv1.TFJobReplicaTypeEval].Replicas) + + for replicaType, replicaSpec := range tensorflowJob.Spec.TFReplicaSpecs { + var hasContainerWithDefaultTensorFlowName = false + + for _, container := range replicaSpec.Template.Spec.Containers { + if container.Name == kubeflowv1.TFJobDefaultContainerName { + hasContainerWithDefaultTensorFlowName = true + assert.Equal(t, *resourceRequirementsMap[replicaType], container.Resources) + } + } + + assert.True(t, hasContainerWithDefaultTensorFlowName) + } + assert.Equal(t, kubeflowv1.CleanPodPolicyAll, *tensorflowJob.Spec.RunPolicy.CleanPodPolicy) + assert.Equal(t, int64(100), *tensorflowJob.Spec.RunPolicy.ActiveDeadlineSeconds) + } +} + +func TestBuildResourceTensorFlowV1WithOnlyWorker(t *testing.T) { + taskConfigs := []*kfplugins.DistributedTensorflowTrainingTask{ + { + WorkerReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Replicas: 100, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "2048m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + }, + }, + }, + { + WorkerReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 100, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "2048m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + }, + }, + }, + }, + } + + for _, taskConfig := range taskConfigs { + resourceRequirementsMap := map[kubeflowv1.ReplicaType]*corev1.ResourceRequirements{ + kubeflowv1.TFJobReplicaTypeWorker: { + Requests: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("1024m"), + corev1.ResourceMemory: resource.MustParse("1Gi"), + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + Limits: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("2048m"), + corev1.ResourceMemory: resource.MustParse("2Gi"), + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + } + + tensorflowResourceHandler := tensorflowOperatorResourceHandler{} + + taskTemplate := dummyTensorFlowTaskTemplate("v1 with only worker replica", taskConfig) + taskTemplate.TaskTypeVersion = 1 + + resource, err := tensorflowResourceHandler.BuildResource(context.TODO(), dummyTensorFlowTaskContext(taskTemplate, resourceRequirements, nil)) + assert.NoError(t, err) + assert.NotNil(t, resource) + + tensorflowJob, ok := resource.(*kubeflowv1.TFJob) + assert.True(t, ok) + assert.Equal(t, int32(100), *tensorflowJob.Spec.TFReplicaSpecs[kubeflowv1.TFJobReplicaTypeWorker].Replicas) + assert.Nil(t, tensorflowJob.Spec.TFReplicaSpecs[kubeflowv1.TFJobReplicaTypeChief]) + assert.Nil(t, tensorflowJob.Spec.TFReplicaSpecs[kubeflowv1.TFJobReplicaTypePS]) + + for replicaType, replicaSpec := range tensorflowJob.Spec.TFReplicaSpecs { + var hasContainerWithDefaultTensorFlowName = false + + for _, container := range replicaSpec.Template.Spec.Containers { + if container.Name == kubeflowv1.TFJobDefaultContainerName { + hasContainerWithDefaultTensorFlowName = true + assert.Equal(t, *resourceRequirementsMap[replicaType], container.Resources) + } + } + + assert.True(t, hasContainerWithDefaultTensorFlowName) + } + } +} + +func TestBuildResourceTensorFlowV1ResourceTolerations(t *testing.T) { + gpuToleration := corev1.Toleration{ + Key: "nvidia.com/gpu", + Value: "present", + Operator: corev1.TolerationOpEqual, + Effect: corev1.TaintEffectNoSchedule, + } + assert.NoError(t, flytek8sConfig.SetK8sPluginConfig(&flytek8sConfig.K8sPluginConfig{ + GpuResourceName: flytek8s.ResourceNvidiaGPU, + ResourceTolerations: map[corev1.ResourceName][]corev1.Toleration{ + flytek8s.ResourceNvidiaGPU: {gpuToleration}, + }, + })) + + taskConfigs := []*kfplugins.DistributedTensorflowTrainingTask{ + { + ChiefReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Replicas: 1, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "500m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + }, + }, + }, + WorkerReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Replicas: 100, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "2048m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + }, + }, + }, + { + ChiefReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 1, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "250m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "500m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + }, + }, + }, + }, + WorkerReplicas: &kfplugins.DistributedTensorflowTrainingReplicaSpec{ + Common: &plugins.CommonReplicaSpec{ + Replicas: 100, + Resources: &core.Resources{ + Requests: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "1024m"}, + {Name: core.Resources_MEMORY, Value: "1Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + Limits: []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "2048m"}, + {Name: core.Resources_MEMORY, Value: "2Gi"}, + {Name: core.Resources_GPU, Value: "1"}, + }, + }, + }, + }, + }, + } + + for _, taskConfig := range taskConfigs { + + tensorflowResourceHandler := tensorflowOperatorResourceHandler{} + + taskTemplate := dummyTensorFlowTaskTemplate("v1", taskConfig) + taskTemplate.TaskTypeVersion = 1 + + resource, err := tensorflowResourceHandler.BuildResource(context.TODO(), dummyTensorFlowTaskContext(taskTemplate, resourceRequirements, nil)) + assert.NoError(t, err) + assert.NotNil(t, resource) + + tensorflowJob, ok := resource.(*kubeflowv1.TFJob) + assert.True(t, ok) + + assert.NotContains(t, tensorflowJob.Spec.TFReplicaSpecs[kubeflowv1.TFJobReplicaTypeChief].Template.Spec.Tolerations, gpuToleration) + assert.Contains(t, tensorflowJob.Spec.TFReplicaSpecs[kubeflowv1.TFJobReplicaTypeWorker].Template.Spec.Tolerations, gpuToleration) + } +} + +func TestIsTerminal(t *testing.T) { + tensorflowResourceHandler := tensorflowOperatorResourceHandler{} + ctx := context.Background() + + tests := []struct { + name string + conditionType kubeflowv1.JobConditionType + expectedResult bool + }{ + {"Succeeded", kubeflowv1.JobSucceeded, true}, + {"Failed", kubeflowv1.JobFailed, true}, + {"Created", kubeflowv1.JobCreated, false}, + {"Running", kubeflowv1.JobRunning, false}, + {"Restarting", kubeflowv1.JobRestarting, false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // Create a simple job with only the condition we want to test + job := &kubeflowv1.TFJob{ + Status: kubeflowv1.JobStatus{ + Conditions: []kubeflowv1.JobCondition{ + { + Type: tt.conditionType, + Status: corev1.ConditionTrue, + }, + }, + }, + } + result, err := tensorflowResourceHandler.IsTerminal(ctx, job) + assert.NoError(t, err) + assert.Equal(t, tt.expectedResult, result) + }) + } +} + +func TestIsTerminal_WrongResourceType(t *testing.T) { + tensorflowResourceHandler := tensorflowOperatorResourceHandler{} + ctx := context.Background() + + wrongResource := &corev1.ConfigMap{} + result, err := tensorflowResourceHandler.IsTerminal(ctx, wrongResource) + assert.Error(t, err) + assert.False(t, result) + assert.Contains(t, err.Error(), "unexpected resource type") +} + +func TestGetCompletionTime(t *testing.T) { + tensorflowResourceHandler := tensorflowOperatorResourceHandler{} + + now := time.Now().Truncate(time.Second) + earlier := now.Add(-1 * time.Hour) + evenEarlier := now.Add(-2 * time.Hour) + + tests := []struct { + name string + job *kubeflowv1.TFJob + expectedTime time.Time + }{ + { + name: "uses CompletionTime", + job: &kubeflowv1.TFJob{ + ObjectMeta: v1.ObjectMeta{ + CreationTimestamp: v1.NewTime(evenEarlier), + }, + Status: kubeflowv1.JobStatus{ + CompletionTime: &v1.Time{Time: now}, + StartTime: &v1.Time{Time: earlier}, + }, + }, + expectedTime: now, + }, + { + name: "falls back to condition LastTransitionTime", + job: &kubeflowv1.TFJob{ + ObjectMeta: v1.ObjectMeta{ + CreationTimestamp: v1.NewTime(evenEarlier), + }, + Status: kubeflowv1.JobStatus{ + StartTime: &v1.Time{Time: earlier}, + Conditions: []kubeflowv1.JobCondition{ + { + Type: kubeflowv1.JobSucceeded, + Status: corev1.ConditionTrue, + LastTransitionTime: v1.NewTime(now), + }, + }, + }, + }, + expectedTime: now, + }, + { + name: "falls back to StartTime", + job: &kubeflowv1.TFJob{ + ObjectMeta: v1.ObjectMeta{ + CreationTimestamp: v1.NewTime(evenEarlier), + }, + Status: kubeflowv1.JobStatus{ + StartTime: &v1.Time{Time: now}, + }, + }, + expectedTime: now, + }, + { + name: "falls back to CreationTimestamp", + job: &kubeflowv1.TFJob{ + ObjectMeta: v1.ObjectMeta{ + CreationTimestamp: v1.NewTime(now), + }, + Status: kubeflowv1.JobStatus{}, + }, + expectedTime: now, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result, err := tensorflowResourceHandler.GetCompletionTime(tt.job) + assert.NoError(t, err) + assert.Equal(t, tt.expectedTime.Unix(), result.Unix()) + }) + } +} + +func TestGetCompletionTime_WrongResourceType(t *testing.T) { + tensorflowResourceHandler := tensorflowOperatorResourceHandler{} + + wrongResource := &corev1.ConfigMap{} + result, err := tensorflowResourceHandler.GetCompletionTime(wrongResource) + assert.Error(t, err) + assert.True(t, result.IsZero()) + assert.Contains(t, err.Error(), "unexpected resource type") +} diff --git a/flyteplugins/go/tasks/plugins/k8s/pod/container_test.go b/flyteplugins/go/tasks/plugins/k8s/pod/container_test.go new file mode 100644 index 0000000000..160b4a4715 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/pod/container_test.go @@ -0,0 +1,710 @@ +package pod + +import ( + "context" + "fmt" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "google.golang.org/protobuf/types/known/timestamppb" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + pluginsCoreMock "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s" + flytek8sConfig "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + pluginsIOMock "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + k8smocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +var containerResourceRequirements = &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1024m"), + }, +} + +var ( + serviceAccount = "service-account" + podTemplateServiceAccount = "test-service-account" + securityContextServiceAccount = "security-context-service-account" +) + +func dummyContainerTaskTemplate(command []string, args []string) *core.TaskTemplate { + return &core.TaskTemplate{ + Type: "test", + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Command: command, + Args: args, + }, + }, + } +} + +func dummyContainerTaskTemplateWithPodSpec(command []string, args []string) *core.TaskTemplate { + + podSpec := v1.PodSpec{ + InitContainers: []v1.Container{ + v1.Container{ + Name: "test-image", + Command: command, + Args: args, + }, + }, + Containers: []v1.Container{ + v1.Container{ + Name: "test-image", + Command: command, + Args: args, + }, + }, + ServiceAccountName: podTemplateServiceAccount, + } + + podSpecPb, err := utils.MarshalObjToStruct(podSpec) + if err != nil { + panic(err) + } + + taskTemplate := &core.TaskTemplate{ + Type: "test", + Target: &core.TaskTemplate_K8SPod{ + K8SPod: &core.K8SPod{ + PodSpec: podSpecPb, + }, + }, + Config: map[string]string{ + "primary_container_name": "test-image", + }, + } + + return taskTemplate +} + +func dummyContainerTaskMetadata(resources *v1.ResourceRequirements, extendedResources *core.ExtendedResources, returnsServiceAccount bool, containerImage string) pluginsCore.TaskExecutionMetadata { + taskMetadata := &pluginsCoreMock.TaskExecutionMetadata{} + taskMetadata.EXPECT().GetNamespace().Return("test-namespace") + taskMetadata.EXPECT().GetAnnotations().Return(map[string]string{"annotation-1": "val1"}) + taskMetadata.EXPECT().GetLabels().Return(map[string]string{"label-1": "val1"}) + taskMetadata.EXPECT().GetOwnerReference().Return(metav1.OwnerReference{ + Kind: "node", + Name: "blah", + }) + if returnsServiceAccount { + taskMetadata.EXPECT().GetK8sServiceAccount().Return(serviceAccount) + } else { + taskMetadata.EXPECT().GetK8sServiceAccount().Return("") + } + taskMetadata.EXPECT().GetSecurityContext().Return(core.SecurityContext{ + RunAs: &core.Identity{K8SServiceAccount: securityContextServiceAccount}, + }) + taskMetadata.EXPECT().GetOwnerID().Return(types.NamespacedName{ + Namespace: "test-namespace", + Name: "test-owner-name", + }) + taskMetadata.EXPECT().GetPlatformResources().Return(&v1.ResourceRequirements{}) + + tID := &pluginsCoreMock.TaskExecutionID{} + tID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my_name", + Project: "my_project", + Domain: "my_domain", + }, + }, + }) + tID.EXPECT().GetGeneratedName().Return("my_project:my_domain:my_name") + tID.EXPECT().GetUniqueNodeID().Return("unique-node-id") + taskMetadata.EXPECT().GetTaskExecutionID().Return(tID) + + to := &pluginsCoreMock.TaskOverrides{} + to.EXPECT().GetResources().Return(resources) + to.EXPECT().GetExtendedResources().Return(extendedResources) + to.EXPECT().GetPodTemplate().Return(nil) + + to.EXPECT().GetContainerImage().Return(containerImage) + taskMetadata.EXPECT().GetOverrides().Return(to) + taskMetadata.EXPECT().IsInterruptible().Return(true) + taskMetadata.EXPECT().GetEnvironmentVariables().Return(nil) + taskMetadata.EXPECT().GetConsoleURL().Return("") + return taskMetadata +} + +func dummyContainerTaskContext(taskTemplate *core.TaskTemplate, taskMetadata pluginsCore.TaskExecutionMetadata) pluginsCore.TaskExecutionContext { + taskCtx := &pluginsCoreMock.TaskExecutionContext{} + inputReader := &pluginsIOMock.InputReader{} + inputReader.EXPECT().GetInputPrefixPath().Return("test-data-reference") + inputReader.EXPECT().GetInputPath().Return("test-data-reference") + inputReader.EXPECT().Get(mock.Anything).Return(&core.LiteralMap{}, nil) + taskCtx.EXPECT().InputReader().Return(inputReader) + + outputReader := &pluginsIOMock.OutputWriter{} + outputReader.EXPECT().GetOutputPath().Return("/data/outputs.pb") + outputReader.EXPECT().GetOutputPrefixPath().Return("/data/") + outputReader.EXPECT().GetRawOutputPrefix().Return("") + outputReader.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + outputReader.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + + taskCtx.EXPECT().OutputWriter().Return(outputReader) + + taskReader := &pluginsCoreMock.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(taskTemplate, nil) + taskCtx.EXPECT().TaskReader().Return(taskReader) + + taskCtx.EXPECT().TaskExecutionMetadata().Return(taskMetadata) + + pluginStateReader := &pluginsCoreMock.PluginStateReader{} + pluginStateReader.EXPECT().Get(mock.Anything).Return(0, nil) + taskCtx.EXPECT().PluginStateReader().Return(pluginStateReader) + + return taskCtx +} + +func dummyContainerPluginContext(taskTemplate *core.TaskTemplate, taskMetadata pluginsCore.TaskExecutionMetadata) *k8smocks.PluginContext { + pCtx := &k8smocks.PluginContext{} + inputReader := &pluginsIOMock.InputReader{} + inputReader.EXPECT().GetInputPrefixPath().Return("test-data-reference") + inputReader.EXPECT().GetInputPath().Return("test-data-reference") + inputReader.EXPECT().Get(mock.Anything).Return(&core.LiteralMap{}, nil) + pCtx.EXPECT().InputReader().Return(inputReader) + + outputReader := &pluginsIOMock.OutputWriter{} + outputReader.EXPECT().GetOutputPath().Return("/data/outputs.pb") + outputReader.EXPECT().GetOutputPrefixPath().Return("/data/") + outputReader.EXPECT().GetRawOutputPrefix().Return("") + outputReader.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + outputReader.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + + pCtx.EXPECT().OutputWriter().Return(outputReader) + + taskReader := &pluginsCoreMock.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(taskTemplate, nil) + pCtx.EXPECT().TaskReader().Return(taskReader) + + pCtx.EXPECT().TaskExecutionMetadata().Return(taskMetadata) + + pluginStateReader := &pluginsCoreMock.PluginStateReader{} + pluginStateReader.EXPECT().Get(mock.Anything).Return(0, nil) + pCtx.EXPECT().PluginStateReader().Return(pluginStateReader) + + return pCtx +} + +func TestContainerTaskExecutor_BuildIdentityResource(t *testing.T) { + taskMetadata := &pluginsCoreMock.TaskExecutionMetadata{} + r, err := DefaultPodPlugin.BuildIdentityResource(context.TODO(), taskMetadata) + assert.NoError(t, err) + assert.NotNil(t, r) + _, ok := r.(*v1.Pod) + assert.True(t, ok) + assert.Equal(t, flytek8s.PodKind, r.GetObjectKind().GroupVersionKind().Kind) +} + +func TestContainerTaskExecutor_BuildResource(t *testing.T) { + command := []string{"command"} + args := []string{"{{.Input}}"} + testCases := []struct { + name string + taskTemplate *core.TaskTemplate + taskMetadata pluginsCore.TaskExecutionMetadata + expectServiceAccount string + checkInitContainer bool + }{ + { + name: "BuildResource", + taskTemplate: dummyContainerTaskTemplate(command, args), + taskMetadata: dummyContainerTaskMetadata(containerResourceRequirements, nil, true, ""), + expectServiceAccount: serviceAccount, + checkInitContainer: false, + }, + { + name: "BuildResource_PodTemplate", + taskTemplate: dummyContainerTaskTemplateWithPodSpec(command, args), + taskMetadata: dummyContainerTaskMetadata(containerResourceRequirements, nil, true, ""), + expectServiceAccount: podTemplateServiceAccount, + checkInitContainer: true, + }, + { + name: "BuildResource_SecurityContext", + taskTemplate: dummyContainerTaskTemplate(command, args), + taskMetadata: dummyContainerTaskMetadata(containerResourceRequirements, nil, false, ""), + expectServiceAccount: securityContextServiceAccount, + checkInitContainer: false, + }, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + taskCtx := dummyContainerTaskContext(tc.taskTemplate, tc.taskMetadata) + + r, err := DefaultPodPlugin.BuildResource(context.TODO(), taskCtx) + assert.NoError(t, err) + assert.NotNil(t, r) + j, ok := r.(*v1.Pod) + assert.True(t, ok) + + assert.NotEmpty(t, j.Spec.Containers) + assert.Equal(t, containerResourceRequirements.Limits[v1.ResourceCPU], j.Spec.Containers[0].Resources.Limits[v1.ResourceCPU]) + + ephemeralStorageRes := j.Spec.Containers[0].Resources.Limits[v1.ResourceEphemeralStorage] + assert.Equal(t, int64(0), (&ephemeralStorageRes).Value()) + + assert.Equal(t, command, j.Spec.Containers[0].Command) + assert.Equal(t, []string{"test-data-reference"}, j.Spec.Containers[0].Args) + + if tc.checkInitContainer { + assert.Equal(t, command, j.Spec.InitContainers[0].Command) + assert.Equal(t, []string{"test-data-reference"}, j.Spec.InitContainers[0].Args) + } + + assert.Equal(t, tc.expectServiceAccount, j.Spec.ServiceAccountName) + }) + } +} + +func TestContainerTaskExecutor_BuildResource_ExtendedResources(t *testing.T) { + assert.NoError(t, flytek8sConfig.SetK8sPluginConfig(&flytek8sConfig.K8sPluginConfig{ + GpuDeviceNodeLabel: "gpu-node-label", + GpuPartitionSizeNodeLabel: "gpu-partition-size", + GpuResourceName: flytek8s.ResourceNvidiaGPU, + })) + + fixtures := []struct { + name string + resources *v1.ResourceRequirements + extendedResourcesBase *core.ExtendedResources + extendedResourcesOverride *core.ExtendedResources + expectedNsr []v1.NodeSelectorTerm + expectedTol []v1.Toleration + }{ + { + "without overrides", + &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-t4", + }, + }, + nil, + []v1.NodeSelectorTerm{ + { + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "gpu-node-label", + Operator: v1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-t4"}, + }, + }, + }, + }, + []v1.Toleration{ + { + Key: "gpu-node-label", + Value: "nvidia-tesla-t4", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + }, + }, + { + "with overrides", + &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-t4", + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-a100", + PartitionSizeValue: &core.GPUAccelerator_PartitionSize{ + PartitionSize: "1g.5gb", + }, + }, + }, + []v1.NodeSelectorTerm{ + { + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "gpu-node-label", + Operator: v1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-a100"}, + }, + v1.NodeSelectorRequirement{ + Key: "gpu-partition-size", + Operator: v1.NodeSelectorOpIn, + Values: []string{"1g.5gb"}, + }, + }, + }, + }, + []v1.Toleration{ + { + Key: "gpu-node-label", + Value: "nvidia-tesla-a100", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + { + Key: "gpu-partition-size", + Value: "1g.5gb", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + }, + }, + } + + for _, f := range fixtures { + t.Run(f.name, func(t *testing.T) { + taskTemplate := dummyContainerTaskTemplate([]string{"command"}, []string{"{{.Input}}"}) + taskTemplate.ExtendedResources = f.extendedResourcesBase + taskMetadata := dummyContainerTaskMetadata(f.resources, f.extendedResourcesOverride, true, "") + taskContext := dummyContainerTaskContext(taskTemplate, taskMetadata) + r, err := DefaultPodPlugin.BuildResource(context.TODO(), taskContext) + assert.Nil(t, err) + assert.NotNil(t, r) + pod, ok := r.(*v1.Pod) + assert.True(t, ok) + + assert.EqualValues( + t, + f.expectedNsr, + pod.Spec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + f.expectedTol, + pod.Spec.Tolerations, + ) + }) + } +} + +func TestContainerTaskExecutor_BuildResource_ContainerImage(t *testing.T) { + assert.NoError(t, flytek8sConfig.SetK8sPluginConfig(&flytek8sConfig.K8sPluginConfig{})) + + fixtures := []struct { + name string + resources *v1.ResourceRequirements + containerImageOverride string + }{ + { + "without overrides", + &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + "", + }, + { + "with overrides", + &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + "test-image", + }, + } + + for _, f := range fixtures { + t.Run(f.name, func(t *testing.T) { + taskTemplate := dummyContainerTaskTemplate([]string{"command"}, []string{"{{.Input}}"}) + taskMetadata := dummyContainerTaskMetadata(f.resources, nil, true, f.containerImageOverride) + taskContext := dummyContainerTaskContext(taskTemplate, taskMetadata) + r, err := DefaultPodPlugin.BuildResource(context.TODO(), taskContext) + assert.Nil(t, err) + assert.NotNil(t, r) + _, ok := r.(*v1.Pod) + assert.True(t, ok) + assert.Equal(t, f.containerImageOverride, r.(*v1.Pod).Spec.Containers[0].Image) + }) + } +} + +func TestContainerTaskExecutor_GetTaskPhase(t *testing.T) { + command := []string{"command"} + args := []string{"{{.Input}}"} + taskTemplate := dummyContainerTaskTemplate(command, args) + taskMetadata := dummyContainerTaskMetadata(containerResourceRequirements, nil, true, "") + pluginContext := dummyContainerPluginContext(taskTemplate, taskMetadata) + + j := &v1.Pod{ + Status: v1.PodStatus{}, + } + startTime := time.Now() + endTime := startTime.Add(time.Hour) + + ctx := context.TODO() + t.Run("running", func(t *testing.T) { + j.Status.Phase = v1.PodRunning + j.Name = "exec-n0-0" + j.Namespace = "ns" + j.Spec.Containers = []v1.Container{{Name: "primary"}} + j.Status.ContainerStatuses = []v1.ContainerStatus{ + { + Name: "primary", + State: v1.ContainerState{ + Running: &v1.ContainerStateRunning{ + StartedAt: metav1.Time{Time: startTime}, + }, + }, + }, + } + j.Status.InitContainerStatuses = []v1.ContainerStatus{ + { + Name: "init", + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + StartedAt: metav1.Time{Time: startTime}, + FinishedAt: metav1.Time{Time: endTime}, + }, + }, + }, + } + logCtx := &core.LogContext{ + PrimaryPodName: j.Name, + Pods: []*core.PodLogContext{ + { + Namespace: j.Namespace, + PodName: j.Name, + PrimaryContainerName: "primary", + Containers: []*core.ContainerContext{ + { + ContainerName: "primary", + Process: &core.ContainerContext_ProcessContext{ + ContainerStartTime: timestamppb.New(startTime), + }, + }, + }, + InitContainers: []*core.ContainerContext{ + { + ContainerName: "init", + Process: &core.ContainerContext_ProcessContext{ + ContainerStartTime: timestamppb.New(startTime), + ContainerEndTime: timestamppb.New(endTime), + }, + }, + }, + }, + }, + } + + phaseInfo, err := DefaultPodPlugin.GetTaskPhase(ctx, pluginContext, j) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRunning, phaseInfo.Phase()) + assert.Equal(t, logCtx, phaseInfo.Info().LogContext) + }) + + t.Run("queued", func(t *testing.T) { + j.Status.Phase = v1.PodPending + phaseInfo, err := DefaultPodPlugin.GetTaskPhase(ctx, pluginContext, j) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseQueued, phaseInfo.Phase()) + }) + + t.Run("failNoCondition", func(t *testing.T) { + j.Status.Phase = v1.PodFailed + phaseInfo, err := DefaultPodPlugin.GetTaskPhase(ctx, pluginContext, j) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, phaseInfo.Phase()) + ec := phaseInfo.Err().GetCode() + assert.Equal(t, "Interrupted", ec) + }) + + t.Run("failConditionUnschedulable", func(t *testing.T) { + j.Status.Phase = v1.PodFailed + j.Status.Reason = "Unschedulable" + j.Status.Message = "some message" + j.Status.Conditions = []v1.PodCondition{ + { + Type: v1.PodReasonUnschedulable, + }, + } + phaseInfo, err := DefaultPodPlugin.GetTaskPhase(ctx, pluginContext, j) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, phaseInfo.Phase()) + ec := phaseInfo.Err().GetCode() + assert.Equal(t, "Unschedulable", ec) + }) + + t.Run("successOptimized", func(t *testing.T) { + j.Status.Phase = v1.PodRunning + j.Status.ContainerStatuses = []v1.ContainerStatus{ + { + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + ExitCode: 0, + }, + }, + }, + } + + phaseInfo, err := DefaultPodPlugin.GetTaskPhase(ctx, pluginContext, j) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseSuccess, phaseInfo.Phase()) + }) + + t.Run("success", func(t *testing.T) { + j.Status.Phase = v1.PodSucceeded + phaseInfo, err := DefaultPodPlugin.GetTaskPhase(ctx, pluginContext, j) + assert.NoError(t, err) + assert.NotNil(t, phaseInfo) + assert.Equal(t, pluginsCore.PhaseSuccess, phaseInfo.Phase()) + }) +} + +func TestContainerTaskExecutor_GetProperties(t *testing.T) { + expected := k8s.PluginProperties{} + assert.Equal(t, expected, DefaultPodPlugin.GetProperties()) +} + +func TestContainerTaskExecutor_GetTaskStatus_InvalidImageName(t *testing.T) { + command := []string{"command"} + args := []string{"{{.Input}}"} + taskTemplate := dummyContainerTaskTemplate(command, args) + taskMetadata := dummyContainerTaskMetadata(containerResourceRequirements, nil, true, "") + pluginContext := dummyContainerPluginContext(taskTemplate, taskMetadata) + + ctx := context.TODO() + reason := "InvalidImageName" + message := "Failed to apply default image tag \"TEST/flyteorg/myapp:latest\": couldn't parse image reference" + + " \"TEST/flyteorg/myapp:latest\": invalid reference format: repository name must be lowercase" + + pendingPod := &v1.Pod{ + Status: v1.PodStatus{ + Phase: v1.PodPending, + Conditions: []v1.PodCondition{ + { + Type: v1.PodReady, + Status: v1.ConditionFalse, + }, + }, + ContainerStatuses: []v1.ContainerStatus{ + { + ContainerID: "ContainerID", + Ready: false, + State: v1.ContainerState{ + Waiting: &v1.ContainerStateWaiting{ + Reason: reason, + Message: message, + }, + }, + }, + }, + }, + } + + t.Run("failInvalidImageName", func(t *testing.T) { + pendingPod.Status.Phase = v1.PodPending + phaseInfo, err := DefaultPodPlugin.GetTaskPhase(ctx, pluginContext, pendingPod) + finalReason := fmt.Sprintf("|%s", reason) + finalMessage := fmt.Sprintf("|%s", message) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhasePermanentFailure, phaseInfo.Phase()) + assert.Equal(t, &core.ExecutionError{Code: finalReason, Message: finalMessage, Kind: core.ExecutionError_USER}, phaseInfo.Err()) + }) +} + +func TestContainerTaskExecutor_BuildResource_VscodePort(t *testing.T) { + assert.NoError(t, flytek8sConfig.SetK8sPluginConfig(&flytek8sConfig.K8sPluginConfig{})) + + command := []string{"command"} + args := []string{"{{.Input}}"} + + testCases := []struct { + name string + envVars []v1.EnvVar + expectedPort int32 + }{ + { + name: "ACTION_NAME env var present - port 6060", + envVars: []v1.EnvVar{ + { + Name: flytek8s.FlyteEnableVscode, + Value: "true", + }, + { + Name: "ACTION_NAME", + Value: "some-action", + }, + }, + expectedPort: 6060, + }, + { + name: "ACTION_NAME env var absent - port 8080", + envVars: []v1.EnvVar{ + { + Name: flytek8s.FlyteEnableVscode, + Value: "true", + }, + }, + expectedPort: 8080, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + // Create a task template with VSCode enabled and environment variables + podSpec := v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "test-image", + Command: command, + Args: args, + Env: tc.envVars, + }, + }, + } + + podSpecPb, err := utils.MarshalObjToStruct(podSpec) + assert.NoError(t, err) + + taskTemplate := &core.TaskTemplate{ + Type: "test", + Target: &core.TaskTemplate_K8SPod{ + K8SPod: &core.K8SPod{ + PodSpec: podSpecPb, + }, + }, + Config: map[string]string{ + "primary_container_name": "test-image", + }, + } + + taskMetadata := dummyContainerTaskMetadata(containerResourceRequirements, nil, true, "") + taskCtx := dummyContainerTaskContext(taskTemplate, taskMetadata) + + r, err := DefaultPodPlugin.BuildResource(context.TODO(), taskCtx) + assert.NoError(t, err) + assert.NotNil(t, r) + + pod, ok := r.(*v1.Pod) + assert.True(t, ok) + + // Verify the readiness probe port + assert.NotEmpty(t, pod.Spec.Containers) + assert.NotNil(t, pod.Spec.Containers[0].ReadinessProbe) + assert.NotNil(t, pod.Spec.Containers[0].ReadinessProbe.HTTPGet) + assert.Equal(t, tc.expectedPort, pod.Spec.Containers[0].ReadinessProbe.HTTPGet.Port.IntVal) + }) + } +} diff --git a/flyteplugins/go/tasks/plugins/k8s/pod/plugin.go b/flyteplugins/go/tasks/plugins/k8s/pod/plugin.go new file mode 100644 index 0000000000..1cd38c863a --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/pod/plugin.go @@ -0,0 +1,435 @@ +package pod + +import ( + "context" + "fmt" + "time" + + v1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/util/intstr" + "sigs.k8s.io/controller-runtime/pkg/client" + + pluginserrors "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/logs" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery" + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/tasklog" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const ( + ContainerTaskType = "container" + podTaskType = "pod" + pythonTaskType = "python-task" + rawContainerTaskType = "raw-container" + SidecarTaskType = "sidecar" +) + +// Why, you might wonder do we recreate the generated go struct generated from the plugins.SidecarJob proto? Because +// although we unmarshal the task custom json, the PodSpec itself is not generated from a proto definition, +// but a proper go struct defined in k8s libraries. Therefore we only unmarshal the sidecar as a json, rather than jsonpb. +type sidecarJob struct { + PodSpec *v1.PodSpec + PrimaryContainerName string + Annotations map[string]string + Labels map[string]string +} + +var DefaultPodPlugin = plugin{} + +type plugin struct { +} + +func (plugin) BuildIdentityResource(_ context.Context, _ pluginsCore.TaskExecutionMetadata) (client.Object, error) { + return flytek8s.BuildIdentityPod(), nil +} + +func (p plugin) BuildResource(ctx context.Context, taskCtx pluginsCore.TaskExecutionContext) (client.Object, error) { + taskTemplate, err := taskCtx.TaskReader().Read(ctx) + if err != nil { + logger.Warnf(ctx, "failed to read task information when trying to construct Pod, err: %s", err.Error()) + return nil, err + } + + var podSpec *v1.PodSpec + objectMeta := &metav1.ObjectMeta{ + Annotations: make(map[string]string), + Labels: make(map[string]string), + } + primaryContainerName := "" + + if taskTemplate.Type == SidecarTaskType && taskTemplate.TaskTypeVersion == 0 { + // handles pod tasks when they are defined as Sidecar tasks and marshal the podspec using k8s proto. + sidecarJob := sidecarJob{} + err := utils.UnmarshalStructToObj(taskTemplate.GetCustom(), &sidecarJob) + if err != nil { + return nil, pluginserrors.Errorf(pluginserrors.BadTaskSpecification, "invalid TaskSpecification [%v], Err: [%v]", taskTemplate.GetCustom(), err.Error()) + } + + if sidecarJob.PodSpec == nil { + return nil, pluginserrors.Errorf(pluginserrors.BadTaskSpecification, "invalid TaskSpecification, nil PodSpec [%v]", taskTemplate.GetCustom()) + } + + podSpec = sidecarJob.PodSpec + + // get primary container name + primaryContainerName = sidecarJob.PrimaryContainerName + + // update annotations and labels + objectMeta.Annotations = utils.UnionMaps(objectMeta.Annotations, sidecarJob.Annotations) + objectMeta.Labels = utils.UnionMaps(objectMeta.Labels, sidecarJob.Labels) + } else if taskTemplate.Type == SidecarTaskType && taskTemplate.TaskTypeVersion == 1 { + // handles pod tasks that marshal the pod spec to the task custom. + err := utils.UnmarshalStructToObj(taskTemplate.GetCustom(), &podSpec) + if err != nil { + return nil, pluginserrors.Errorf(pluginserrors.BadTaskSpecification, + "Unable to unmarshal task custom [%v], Err: [%v]", taskTemplate.GetCustom(), err.Error()) + } + + // get primary container name + if len(taskTemplate.GetConfig()) == 0 { + return nil, pluginserrors.Errorf(pluginserrors.BadTaskSpecification, + "invalid TaskSpecification, config needs to be non-empty and include missing [%s] key", flytek8s.PrimaryContainerKey) + } + + var ok bool + if primaryContainerName, ok = taskTemplate.GetConfig()[flytek8s.PrimaryContainerKey]; !ok { + return nil, pluginserrors.Errorf(pluginserrors.BadTaskSpecification, + "invalid TaskSpecification, config missing [%s] key in [%v]", flytek8s.PrimaryContainerKey, taskTemplate.GetConfig()) + } + + // update annotations and labels + if taskTemplate.GetK8SPod() != nil && taskTemplate.GetK8SPod().Metadata != nil { + objectMeta.Annotations = utils.UnionMaps(objectMeta.Annotations, taskTemplate.GetK8SPod().Metadata.Annotations) + objectMeta.Labels = utils.UnionMaps(objectMeta.Labels, taskTemplate.GetK8SPod().Metadata.Labels) + } + } else { + // handles both container / pod tasks that use the TaskTemplate Container and K8sPod fields + var err error + podSpec, objectMeta, primaryContainerName, err = flytek8s.BuildRawPod(ctx, taskCtx) + if err != nil { + return nil, err + } + } + + // update podSpec and objectMeta with Flyte customizations + podSpec, objectMeta, err = flytek8s.ApplyFlytePodConfiguration(ctx, taskCtx, podSpec, objectMeta, primaryContainerName) + if err != nil { + return nil, err + } + + for i, c := range podSpec.Containers { + if len(podSpec.Containers) > 1 && c.Name != primaryContainerName { + continue + } + if !flytek8s.IsVscodeEnabled(ctx, podSpec.Containers[i].Env) { + break + } + port := 8080 + // TODO: Will remove this logic once we have a better way to identify v2 tasks + for _, env := range podSpec.Containers[i].Env { + if env.Name != "ACTION_NAME" { + continue + } + port = 6060 + } + + newContainer := c.DeepCopy() + newContainer.ReadinessProbe = &v1.Probe{ + ProbeHandler: v1.ProbeHandler{ + HTTPGet: &v1.HTTPGetAction{ + Port: intstr.FromInt32(int32(port)), + }, + }, + InitialDelaySeconds: 15, + PeriodSeconds: 5, + FailureThreshold: 50, + } + podSpec.Containers[i] = *newContainer + } + + // set primaryContainerKey annotation if this is a Sidecar task or, as an optimization, if there is only a single + // container. this plugin marks the task complete if the primary Container is complete, so if there is only one + // container we can mark the task as complete before the Pod has been marked complete. + if taskTemplate.Type == SidecarTaskType || (len(podSpec.Containers) == 1 && taskTemplate.Type != rawContainerTaskType) { + objectMeta.Annotations[flytek8s.PrimaryContainerKey] = primaryContainerName + } + + if len(podSpec.ServiceAccountName) == 0 { + podSpec.ServiceAccountName = flytek8s.GetServiceAccountNameFromTaskExecutionMetadata(taskCtx.TaskExecutionMetadata()) + } + + pod := flytek8s.BuildIdentityPod() + pod.ObjectMeta = *objectMeta + pod.Spec = *podSpec + + return pod, nil +} + +func (p plugin) GetTaskPhase(ctx context.Context, pluginContext k8s.PluginContext, r client.Object) (pluginsCore.PhaseInfo, error) { + logPlugin, err := logs.InitializeLogPlugins(logs.GetLogConfig()) + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + + return p.GetTaskPhaseWithLogs(ctx, pluginContext, r, logPlugin, "", nil) +} + +func (plugin) GetTaskPhaseWithLogs(ctx context.Context, pluginContext k8s.PluginContext, r client.Object, logPlugin tasklog.Plugin, logSuffix string, extraLogTemplateVarsByScheme []tasklog.TemplateVar) (pluginsCore.PhaseInfo, error) { + pluginState := k8s.PluginState{} + _, err := pluginContext.PluginStateReader().Get(&pluginState) + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + + taskTemplate, err := pluginContext.TaskReader().Read(ctx) + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + + pod := r.(*v1.Pod) + + transitionOccurredAt := flytek8s.GetLastTransitionOccurredAt(pod).Time + reportedAt := flytek8s.GetReportedAt(pod).Time + if reportedAt.IsZero() { + reportedAt = transitionOccurredAt + } + + info := pluginsCore.TaskInfo{ + OccurredAt: &transitionOccurredAt, + ReportedAt: &reportedAt, + } + + taskExecID := pluginContext.TaskExecutionMetadata().GetTaskExecutionID() + if pod.Status.Phase != v1.PodUnknown { + taskLogs, err := logs.GetLogsForContainerInPod(ctx, logPlugin, taskExecID, pod, 0, logSuffix, extraLogTemplateVarsByScheme, taskTemplate) + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + info.Logs = taskLogs + info.LogContext = &core.LogContext{ + PrimaryPodName: pod.Name, + Pods: []*core.PodLogContext{flytek8s.BuildPodLogContext(pod)}, + } + } + + phaseInfo, err := DemystifyPodStatus(ctx, pod, info) + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + + if phaseInfo.Phase() >= pluginsCore.PhaseRunning { + for _, tl := range info.Logs { + if tl != nil && tl.LinkType == core.TaskLog_IDE { + tl.Ready = IsPodReady(pod) + if tl.Ready { + phaseInfo.WithReason("Vscode server is ready") + } else { + phaseInfo.WithReason("Vscode server is not ready") + } + break + } + } + } + + k8s.MaybeUpdatePhaseVersion(&phaseInfo, &pluginState) + return phaseInfo, err +} + +func IsPodReady(pod *v1.Pod) bool { + primaryContainerName := flytek8s.GetPrimaryContainerName(pod) + if len(primaryContainerName) == 0 { + // Check pod readiness only when primary container is nod defined. + for _, cond := range pod.Status.Conditions { + if cond.Type == v1.PodReady && cond.Status == v1.ConditionTrue { + return true + } + } + } else { + for _, status := range pod.Status.ContainerStatuses { + if status.Name == primaryContainerName && status.Ready { + return true + } + } + } + return false +} + +func (plugin) GetProperties() k8s.PluginProperties { + return k8s.PluginProperties{} +} + +func DemystifyPodStatus(ctx context.Context, pod *v1.Pod, info pluginsCore.TaskInfo) (pluginsCore.PhaseInfo, error) { + pluginState := k8s.PluginState{} + transitionOccurredAt := flytek8s.GetLastTransitionOccurredAt(pod).Time + phaseInfo := pluginsCore.PhaseInfoUndefined + var err error + primaryContainerName, primaryContainerExists := pod.GetAnnotations()[flytek8s.PrimaryContainerKey] + + hasLogs := len(info.Logs) > 0 || len(info.LogContext.GetPods()) > 0 + switch pod.Status.Phase { + case v1.PodSucceeded: + phaseInfo, err = flytek8s.DemystifySuccess(pod.Status, info) + case v1.PodFailed: + phaseInfo, err = flytek8s.DemystifyFailure(ctx, pod.Status, info, primaryContainerName) + case v1.PodPending: + phaseInfo, err = flytek8s.DemystifyPending(pod.Status, info) + case v1.PodReasonUnschedulable: + phaseInfo = pluginsCore.PhaseInfoQueuedWithTaskInfo(transitionOccurredAt, pluginsCore.DefaultPhaseVersion, "pod unschedulable", &info) + case v1.PodUnknown: + // DO NOTHING + default: + if !primaryContainerExists { + // if all of the containers in the Pod are complete, as an optimization, we can declare the task as + // succeeded rather than waiting for the Pod to be marked completed. + allSuccessfullyTerminated := len(pod.Status.ContainerStatuses) > 0 + for _, s := range pod.Status.ContainerStatuses { + if s.State.Waiting != nil || s.State.Running != nil || (s.State.Terminated != nil && s.State.Terminated.ExitCode != 0) { + allSuccessfullyTerminated = false + } + } + + // Init container will become sidecar if the restart policy is set to Always + // https://kubernetes.io/docs/concepts/workloads/pods/sidecar-containers/#sidecar-containers-and-pod-lifecycle + for _, s := range pod.Status.InitContainerStatuses { + if s.State.Waiting != nil || s.State.Running != nil || (s.State.Terminated != nil && s.State.Terminated.ExitCode != 0) { + allSuccessfullyTerminated = false + } + } + + if allSuccessfullyTerminated { + return flytek8s.DemystifySuccess(pod.Status, info) + } + + // if the primary container annotation does not exist, then the task requires all containers + // to succeed to declare success. therefore, if the pod is not in one of the above states we + // fallback to declaring the task as 'running'. + phaseInfo = pluginsCore.PhaseInfoRunning(pluginsCore.DefaultPhaseVersion, &info) + if hasLogs { + phaseInfo = phaseInfo.WithVersion(pluginsCore.DefaultPhaseVersion + 1) + } + } else { + // if the primary container annotation exists, we use the status of the specified container + phaseInfo = flytek8s.DeterminePrimaryContainerPhase(ctx, primaryContainerName, pod.Status.ContainerStatuses, &info) + if phaseInfo.Phase() == pluginsCore.PhasePermanentFailure && phaseInfo.Err() != nil && + phaseInfo.Err().GetCode() == flytek8s.PrimaryContainerNotFound { + // if the primary container status is not found ensure that the primary container exists. + // note: it should be impossible for the primary container to not exist at this point. + for _, container := range pod.Spec.Containers { + if container.Name == primaryContainerName { + phaseInfo = pluginsCore.PhaseInfoRunning(pluginsCore.DefaultPhaseVersion, &info) + break + } + } + } else if phaseInfo.Phase() == pluginsCore.PhaseRunning && hasLogs { + phaseInfo = phaseInfo.WithVersion(pluginsCore.DefaultPhaseVersion + 1) + } + } + } + + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + + k8s.MaybeUpdatePhaseVersion(&phaseInfo, &pluginState) + return phaseInfo, err +} + +// latestTime returns the latest non-zero time from the given times +func latestTime(times []metav1.Time) time.Time { + var latest time.Time + for _, t := range times { + if !t.IsZero() && t.Time.After(latest) { + latest = t.Time + } + } + return latest +} + +// IsTerminal returns true if the pod is in a terminal state (Succeeded or Failed) +func (plugin) IsTerminal(_ context.Context, resource client.Object) (bool, error) { + pod, ok := resource.(*v1.Pod) + if !ok { + return false, fmt.Errorf("unexpected resource type: expected *v1.Pod, got %T", resource) + } + return pod.Status.Phase == v1.PodSucceeded || pod.Status.Phase == v1.PodFailed, nil +} + +// GetCompletionTime returns the latest container termination time, or falls back to other timestamps +func (plugin) GetCompletionTime(resource client.Object) (time.Time, error) { + pod, ok := resource.(*v1.Pod) + if !ok { + return time.Time{}, fmt.Errorf("unexpected resource type: expected *v1.Pod, got %T", resource) + } + + var times []metav1.Time + + for _, cs := range pod.Status.InitContainerStatuses { + if cs.State.Terminated != nil { + times = append(times, cs.State.Terminated.FinishedAt) + } + if cs.LastTerminationState.Terminated != nil { + times = append(times, cs.LastTerminationState.Terminated.FinishedAt) + } + } + for _, cs := range pod.Status.ContainerStatuses { + if cs.State.Terminated != nil { + times = append(times, cs.State.Terminated.FinishedAt) + } + if cs.LastTerminationState.Terminated != nil { + times = append(times, cs.LastTerminationState.Terminated.FinishedAt) + } + } + + latest := latestTime(times) + if !latest.IsZero() { + return latest, nil + } + + if pod.DeletionTimestamp != nil { + return pod.DeletionTimestamp.Time, nil + } + if pod.Status.StartTime != nil { + return pod.Status.StartTime.Time, nil + } + return pod.CreationTimestamp.Time, nil +} + +func init() { + // Register ContainerTaskType and SidecarTaskType plugin entries. These separate task types + // still exist within the system, only now both are evaluated using the same internal pod plugin + // instance. This simplifies migration as users may keep the same configuration but are + // seamlessly transitioned from separate container and sidecar plugins to a single pod plugin. + pluginmachinery.PluginRegistry().RegisterK8sPlugin( + k8s.PluginEntry{ + ID: ContainerTaskType, + RegisteredTaskTypes: []pluginsCore.TaskType{ContainerTaskType, pythonTaskType, rawContainerTaskType}, + ResourceToWatch: &v1.Pod{}, + Plugin: DefaultPodPlugin, + IsDefault: true, + }) + + pluginmachinery.PluginRegistry().RegisterK8sPlugin( + k8s.PluginEntry{ + ID: SidecarTaskType, + RegisteredTaskTypes: []pluginsCore.TaskType{SidecarTaskType}, + ResourceToWatch: &v1.Pod{}, + Plugin: DefaultPodPlugin, + IsDefault: false, + }) + + // register podTaskType plugin entry + pluginmachinery.PluginRegistry().RegisterK8sPlugin( + k8s.PluginEntry{ + ID: podTaskType, + RegisteredTaskTypes: []pluginsCore.TaskType{ContainerTaskType, pythonTaskType, rawContainerTaskType, SidecarTaskType}, + ResourceToWatch: &v1.Pod{}, + Plugin: DefaultPodPlugin, + IsDefault: true, + }) +} diff --git a/flyteplugins/go/tasks/plugins/k8s/pod/plugin_test.go b/flyteplugins/go/tasks/plugins/k8s/pod/plugin_test.go new file mode 100644 index 0000000000..433f35ea04 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/pod/plugin_test.go @@ -0,0 +1,208 @@ +package pod + +import ( + "context" + "testing" + "time" + + "github.com/stretchr/testify/assert" + v1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "sigs.k8s.io/controller-runtime/pkg/client" +) + +func TestIsTerminal(t *testing.T) { + p := plugin{} + ctx := context.Background() + + tests := []struct { + name string + phase v1.PodPhase + expectedResult bool + }{ + {"Succeeded", v1.PodSucceeded, true}, + {"Failed", v1.PodFailed, true}, + {"Running", v1.PodRunning, false}, + {"Pending", v1.PodPending, false}, + {"Unknown", v1.PodUnknown, false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + pod := &v1.Pod{ + Status: v1.PodStatus{ + Phase: tt.phase, + }, + } + result, err := p.IsTerminal(ctx, pod) + assert.NoError(t, err) + assert.Equal(t, tt.expectedResult, result) + }) + } +} + +func TestIsTerminal_WrongResourceType(t *testing.T) { + p := plugin{} + ctx := context.Background() + + var wrongResource client.Object = &v1.ConfigMap{} + result, err := p.IsTerminal(ctx, wrongResource) + assert.Error(t, err) + assert.False(t, result) + assert.Contains(t, err.Error(), "unexpected resource type") +} + +func TestGetCompletionTime(t *testing.T) { + p := plugin{} + + now := time.Now().Truncate(time.Second) + earlier := now.Add(-1 * time.Hour) + evenEarlier := now.Add(-2 * time.Hour) + + tests := []struct { + name string + pod *v1.Pod + expectedTime time.Time + }{ + { + name: "uses container termination time", + pod: &v1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + CreationTimestamp: metav1.NewTime(evenEarlier), + }, + Status: v1.PodStatus{ + ContainerStatuses: []v1.ContainerStatus{ + { + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + FinishedAt: metav1.NewTime(now), + }, + }, + }, + }, + }, + }, + expectedTime: now, + }, + { + name: "uses latest of multiple container termination times", + pod: &v1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + CreationTimestamp: metav1.NewTime(evenEarlier), + }, + Status: v1.PodStatus{ + ContainerStatuses: []v1.ContainerStatus{ + { + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + FinishedAt: metav1.NewTime(earlier), + }, + }, + }, + { + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + FinishedAt: metav1.NewTime(now), + }, + }, + }, + }, + }, + }, + expectedTime: now, + }, + { + name: "uses init container termination time", + pod: &v1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + CreationTimestamp: metav1.NewTime(evenEarlier), + }, + Status: v1.PodStatus{ + InitContainerStatuses: []v1.ContainerStatus{ + { + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + FinishedAt: metav1.NewTime(now), + }, + }, + }, + }, + }, + }, + expectedTime: now, + }, + { + name: "uses LastTerminationState", + pod: &v1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + CreationTimestamp: metav1.NewTime(evenEarlier), + }, + Status: v1.PodStatus{ + ContainerStatuses: []v1.ContainerStatus{ + { + LastTerminationState: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + FinishedAt: metav1.NewTime(now), + }, + }, + }, + }, + }, + }, + expectedTime: now, + }, + { + name: "falls back to DeletionTimestamp", + pod: &v1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + CreationTimestamp: metav1.NewTime(evenEarlier), + DeletionTimestamp: &metav1.Time{Time: now}, + }, + Status: v1.PodStatus{ + StartTime: &metav1.Time{Time: earlier}, + }, + }, + expectedTime: now, + }, + { + name: "falls back to StartTime", + pod: &v1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + CreationTimestamp: metav1.NewTime(evenEarlier), + }, + Status: v1.PodStatus{ + StartTime: &metav1.Time{Time: now}, + }, + }, + expectedTime: now, + }, + { + name: "falls back to CreationTimestamp", + pod: &v1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + CreationTimestamp: metav1.NewTime(now), + }, + Status: v1.PodStatus{}, + }, + expectedTime: now, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result, err := p.GetCompletionTime(tt.pod) + assert.NoError(t, err) + assert.Equal(t, tt.expectedTime.Unix(), result.Unix()) + }) + } +} + +func TestGetCompletionTime_WrongResourceType(t *testing.T) { + p := plugin{} + + var wrongResource client.Object = &v1.ConfigMap{} + result, err := p.GetCompletionTime(wrongResource) + assert.Error(t, err) + assert.True(t, result.IsZero()) + assert.Contains(t, err.Error(), "unexpected resource type") +} diff --git a/flyteplugins/go/tasks/plugins/k8s/pod/sidecar_test.go b/flyteplugins/go/tasks/plugins/k8s/pod/sidecar_test.go new file mode 100644 index 0000000000..216e0511ca --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/pod/sidecar_test.go @@ -0,0 +1,939 @@ +package pod + +import ( + "context" + "encoding/json" + "errors" + "io/ioutil" + "os" + "path" + "testing" + + structpb "github.com/golang/protobuf/ptypes/struct" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + "sigs.k8s.io/controller-runtime/pkg/client" + + errors2 "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + pluginsCoreMock "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + pluginsIOMock "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + k8smocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s/mocks" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const ResourceNvidiaGPU = "nvidia.com/gpu" + +var sidecarResourceRequirements = &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("2048m"), + v1.ResourceEphemeralStorage: resource.MustParse("100M"), + ResourceNvidiaGPU: resource.MustParse("1"), + }, +} + +func getSidecarTaskTemplateForTest(sideCarJob sidecarJob) *core.TaskTemplate { + sidecarJSON, err := json.Marshal(&sideCarJob) + if err != nil { + panic(err) + } + structObj := structpb.Struct{} + err = json.Unmarshal(sidecarJSON, &structObj) + if err != nil { + panic(err) + } + return &core.TaskTemplate{ + Type: SidecarTaskType, + Custom: &structObj, + } +} + +func dummySidecarTaskMetadata(resources *v1.ResourceRequirements, extendedResources *core.ExtendedResources) pluginsCore.TaskExecutionMetadata { + taskMetadata := &pluginsCoreMock.TaskExecutionMetadata{} + taskMetadata.EXPECT().GetNamespace().Return("test-namespace") + taskMetadata.EXPECT().GetAnnotations().Return(map[string]string{"annotation-1": "val1"}) + + taskMetadata.EXPECT().GetLabels().Return(map[string]string{"label-1": "val1"}) + taskMetadata.EXPECT().GetOwnerReference().Return(metav1.OwnerReference{ + Kind: "node", + Name: "blah", + }) + taskMetadata.EXPECT().IsInterruptible().Return(true) + taskMetadata.EXPECT().GetSecurityContext().Return(core.SecurityContext{}) + taskMetadata.EXPECT().GetK8sServiceAccount().Return("service-account") + taskMetadata.EXPECT().GetOwnerID().Return(types.NamespacedName{ + Namespace: "test-namespace", + Name: "test-owner-name", + }) + taskMetadata.EXPECT().GetPlatformResources().Return(&v1.ResourceRequirements{}) + + tID := &pluginsCoreMock.TaskExecutionID{} + tID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my_name", + Project: "my_project", + Domain: "my_domain", + }, + }, + }) + tID.EXPECT().GetGeneratedName().Return("my_project:my_domain:my_name") + tID.EXPECT().GetUniqueNodeID().Return("an-unique-id") + taskMetadata.EXPECT().GetTaskExecutionID().Return(tID) + + to := &pluginsCoreMock.TaskOverrides{} + to.EXPECT().GetResources().Return(resources) + to.EXPECT().GetExtendedResources().Return(extendedResources) + to.EXPECT().GetContainerImage().Return("") + to.EXPECT().GetPodTemplate().Return(nil) + taskMetadata.EXPECT().GetOverrides().Return(to) + taskMetadata.EXPECT().GetEnvironmentVariables().Return(nil) + taskMetadata.EXPECT().GetConsoleURL().Return("") + + return taskMetadata +} + +func getDummySidecarTaskContext(taskTemplate *core.TaskTemplate, resources *v1.ResourceRequirements, extendedResources *core.ExtendedResources) pluginsCore.TaskExecutionContext { + taskCtx := &pluginsCoreMock.TaskExecutionContext{} + dummyTaskMetadata := dummySidecarTaskMetadata(resources, extendedResources) + inputReader := &pluginsIOMock.InputReader{} + inputReader.EXPECT().GetInputPrefixPath().Return("test-data-prefix") + inputReader.EXPECT().GetInputPath().Return("test-data-reference") + inputReader.EXPECT().Get(mock.Anything).Return(&core.LiteralMap{}, nil) + taskCtx.EXPECT().InputReader().Return(inputReader) + + outputReader := &pluginsIOMock.OutputWriter{} + outputReader.EXPECT().GetOutputPath().Return("/data/outputs.pb") + outputReader.EXPECT().GetOutputPrefixPath().Return("/data/") + outputReader.EXPECT().GetRawOutputPrefix().Return("") + outputReader.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + outputReader.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + taskCtx.EXPECT().OutputWriter().Return(outputReader) + + taskReader := &pluginsCoreMock.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(taskTemplate, nil) + taskCtx.EXPECT().TaskReader().Return(taskReader) + + taskCtx.EXPECT().TaskExecutionMetadata().Return(dummyTaskMetadata) + + pluginStateReader := &pluginsCoreMock.PluginStateReader{} + pluginStateReader.EXPECT().Get(mock.Anything).Return(0, nil) + taskCtx.EXPECT().PluginStateReader().Return(pluginStateReader) + + return taskCtx +} + +func getDummySidecarPluginContext(taskTemplate *core.TaskTemplate, resources *v1.ResourceRequirements) *k8smocks.PluginContext { + pCtx := &k8smocks.PluginContext{} + dummyTaskMetadata := dummySidecarTaskMetadata(resources, nil) + inputReader := &pluginsIOMock.InputReader{} + inputReader.EXPECT().GetInputPrefixPath().Return("test-data-prefix") + inputReader.EXPECT().GetInputPath().Return("test-data-reference") + inputReader.EXPECT().Get(mock.Anything).Return(&core.LiteralMap{}, nil) + pCtx.EXPECT().InputReader().Return(inputReader) + + outputReader := &pluginsIOMock.OutputWriter{} + outputReader.EXPECT().GetOutputPath().Return("/data/outputs.pb") + outputReader.EXPECT().GetOutputPrefixPath().Return("/data/") + outputReader.EXPECT().GetRawOutputPrefix().Return("") + outputReader.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + outputReader.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + pCtx.EXPECT().OutputWriter().Return(outputReader) + + taskReader := &pluginsCoreMock.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(taskTemplate, nil) + pCtx.EXPECT().TaskReader().Return(taskReader) + + pCtx.EXPECT().TaskExecutionMetadata().Return(dummyTaskMetadata) + + pluginStateReader := &pluginsCoreMock.PluginStateReader{} + pluginStateReader.EXPECT().Get(mock.Anything).Return(0, nil) + pCtx.EXPECT().PluginStateReader().Return(pluginStateReader) + + return pCtx +} + +func getPodSpec() v1.PodSpec { + return v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "primary container", + Args: []string{"pyflyte-execute", "--task-module", "tests.flytekit.unit.sdk.tasks.test_sidecar_tasks", "--task-name", "simple_sidecar_task", "--inputs", "{{.input}}", "--output-prefix", "{{.outputPrefix}}"}, + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "cpu": resource.MustParse("2"), + "memory": resource.MustParse("200Mi"), + "gpu": resource.MustParse("1"), + }, + Requests: v1.ResourceList{ + "cpu": resource.MustParse("1"), + "memory": resource.MustParse("100Mi"), + "gpu": resource.MustParse("1"), + }, + }, + VolumeMounts: []v1.VolumeMount{ + { + Name: "volume mount", + }, + }, + }, + { + Name: "secondary container", + Resources: v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "gpu": resource.MustParse("2"), + }, + Requests: v1.ResourceList{ + "gpu": resource.MustParse("2"), + }, + }, + }, + }, + Volumes: []v1.Volume{ + { + Name: "dshm", + }, + }, + Tolerations: []v1.Toleration{ + { + Key: "my toleration key", + Value: "my toleration value", + }, + }, + } +} + +func checkTolerations(t *testing.T, res client.Object, gpuTol v1.Toleration) { + // Assert user-specified tolerations don't get overridden + assert.Len(t, res.(*v1.Pod).Spec.Tolerations, 2) + for _, tol := range res.(*v1.Pod).Spec.Tolerations { + if tol.Key == "my toleration key" { + assert.Equal(t, tol.Value, "my toleration value") + } else if tol.Key == gpuTol.Key { + assert.Equal(t, tol, gpuTol) + } else { + t.Fatalf("unexpected toleration [%+v]", tol) + } + } +} + +func TestBuildSidecarResource_TaskType2(t *testing.T) { + podSpec := getPodSpec() + + b, err := json.Marshal(podSpec) + if err != nil { + t.Fatal(err) + } + + structObj := &structpb.Struct{} + if err := json.Unmarshal(b, structObj); err != nil { + t.Fatal(err) + } + + task := core.TaskTemplate{ + Type: SidecarTaskType, + TaskTypeVersion: 2, + Config: map[string]string{ + flytek8s.PrimaryContainerKey: "primary container", + }, + Target: &core.TaskTemplate_K8SPod{ + K8SPod: &core.K8SPod{ + PodSpec: structObj, + Metadata: &core.K8SObjectMetadata{ + Labels: map[string]string{ + "label": "foo", + }, + Annotations: map[string]string{ + "anno": "bar", + }, + }, + }, + }, + } + + tolGPU := v1.Toleration{ + Key: "flyte/gpu", + Value: "dedicated", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + } + + tolEphemeralStorage := v1.Toleration{ + Key: "ephemeral-storage", + Value: "dedicated", + Operator: v1.TolerationOpExists, + Effect: v1.TaintEffectNoSchedule, + } + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + ResourceTolerations: map[v1.ResourceName][]v1.Toleration{ + v1.ResourceStorage: {tolEphemeralStorage}, + ResourceNvidiaGPU: {tolGPU}, + }, + DefaultCPURequest: resource.MustParse("1024m"), + DefaultMemoryRequest: resource.MustParse("1024Mi"), + GpuResourceName: ResourceNvidiaGPU, + })) + taskCtx := getDummySidecarTaskContext(&task, sidecarResourceRequirements, nil) + res, err := DefaultPodPlugin.BuildResource(context.TODO(), taskCtx) + assert.Nil(t, err) + assert.EqualValues(t, map[string]string{ + flytek8s.PrimaryContainerKey: "primary container", + "anno": "bar", + }, res.GetAnnotations()) + assert.EqualValues(t, map[string]string{ + "label": "foo", + }, res.GetLabels()) + + // Assert volumes & volume mounts are preserved + assert.Len(t, res.(*v1.Pod).Spec.Volumes, 1) + assert.Equal(t, "dshm", res.(*v1.Pod).Spec.Volumes[0].Name) + + assert.Len(t, res.(*v1.Pod).Spec.Containers[0].VolumeMounts, 1) + assert.Equal(t, "volume mount", res.(*v1.Pod).Spec.Containers[0].VolumeMounts[0].Name) + + checkTolerations(t, res, tolGPU) + + // Assert resource requirements are correctly set + expectedCPURequest := resource.MustParse("1") + assert.Equal(t, expectedCPURequest.Value(), res.(*v1.Pod).Spec.Containers[0].Resources.Requests.Cpu().Value()) + expectedMemRequest := resource.MustParse("100Mi") + assert.Equal(t, expectedMemRequest.Value(), res.(*v1.Pod).Spec.Containers[0].Resources.Requests.Memory().Value()) + expectedCPULimit := resource.MustParse("2048m") + assert.Equal(t, expectedCPULimit.Value(), res.(*v1.Pod).Spec.Containers[0].Resources.Limits.Cpu().Value()) + expectedMemLimit := resource.MustParse("200Mi") + assert.Equal(t, expectedMemLimit.Value(), res.(*v1.Pod).Spec.Containers[0].Resources.Limits.Memory().Value()) + expectedEphemeralStorageLimit := resource.MustParse("100M") + assert.Equal(t, expectedEphemeralStorageLimit.Value(), res.(*v1.Pod).Spec.Containers[0].Resources.Limits.StorageEphemeral().Value()) + + expectedGPURes := resource.MustParse("1") + assert.Equal(t, expectedGPURes, res.(*v1.Pod).Spec.Containers[0].Resources.Requests[ResourceNvidiaGPU]) + assert.Equal(t, expectedGPURes, res.(*v1.Pod).Spec.Containers[0].Resources.Limits[ResourceNvidiaGPU]) + expectedGPURes = resource.MustParse("2") + assert.Equal(t, expectedGPURes, res.(*v1.Pod).Spec.Containers[1].Resources.Requests[ResourceNvidiaGPU]) + assert.Equal(t, expectedGPURes, res.(*v1.Pod).Spec.Containers[1].Resources.Limits[ResourceNvidiaGPU]) +} + +func TestBuildSidecarResource_TaskType2_Invalid_Spec(t *testing.T) { + task := core.TaskTemplate{ + Type: SidecarTaskType, + TaskTypeVersion: 2, + Config: map[string]string{ + flytek8s.PrimaryContainerKey: "primary container", + }, + Target: &core.TaskTemplate_K8SPod{ + K8SPod: &core.K8SPod{ + Metadata: &core.K8SObjectMetadata{ + Labels: map[string]string{ + "label": "foo", + }, + Annotations: map[string]string{ + "anno": "bar", + }, + }, + }, + }, + } + + taskCtx := getDummySidecarTaskContext(&task, sidecarResourceRequirements, nil) + _, err := DefaultPodPlugin.BuildResource(context.TODO(), taskCtx) + assert.EqualError(t, err, "[BadTaskSpecification] Pod tasks with task type version > 1 should specify their target as a K8sPod with a defined pod spec") +} + +func TestBuildSidecarResource_TaskType1(t *testing.T) { + podSpec := getPodSpec() + + b, err := json.Marshal(podSpec) + if err != nil { + t.Fatal(err) + } + + structObj := &structpb.Struct{} + if err := json.Unmarshal(b, structObj); err != nil { + t.Fatal(err) + } + + task := core.TaskTemplate{ + Type: SidecarTaskType, + Custom: structObj, + TaskTypeVersion: 1, + Config: map[string]string{ + flytek8s.PrimaryContainerKey: "primary container", + }, + } + + tolGPU := v1.Toleration{ + Key: "flyte/gpu", + Value: "dedicated", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + } + + tolEphemeralStorage := v1.Toleration{ + Key: "ephemeral-storage", + Value: "dedicated", + Operator: v1.TolerationOpExists, + Effect: v1.TaintEffectNoSchedule, + } + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + ResourceTolerations: map[v1.ResourceName][]v1.Toleration{ + v1.ResourceStorage: {tolEphemeralStorage}, + ResourceNvidiaGPU: {tolGPU}, + }, + DefaultCPURequest: resource.MustParse("1024m"), + DefaultMemoryRequest: resource.MustParse("1024Mi"), + })) + taskCtx := getDummySidecarTaskContext(&task, sidecarResourceRequirements, nil) + res, err := DefaultPodPlugin.BuildResource(context.TODO(), taskCtx) + assert.Nil(t, err) + assert.EqualValues(t, map[string]string{ + flytek8s.PrimaryContainerKey: "primary container", + }, res.GetAnnotations()) + assert.EqualValues(t, map[string]string{}, res.GetLabels()) + + // Assert volumes & volume mounts are preserved + assert.Len(t, res.(*v1.Pod).Spec.Volumes, 1) + assert.Equal(t, "dshm", res.(*v1.Pod).Spec.Volumes[0].Name) + + assert.Len(t, res.(*v1.Pod).Spec.Containers[0].VolumeMounts, 1) + assert.Equal(t, "volume mount", res.(*v1.Pod).Spec.Containers[0].VolumeMounts[0].Name) + + checkTolerations(t, res, tolGPU) + // Assert resource requirements are correctly set + expectedCPURequest := resource.MustParse("1") + assert.Equal(t, expectedCPURequest.Value(), res.(*v1.Pod).Spec.Containers[0].Resources.Requests.Cpu().Value()) + expectedMemRequest := resource.MustParse("100Mi") + assert.Equal(t, expectedMemRequest.Value(), res.(*v1.Pod).Spec.Containers[0].Resources.Requests.Memory().Value()) + expectedCPULimit := resource.MustParse("2048m") + assert.Equal(t, expectedCPULimit.Value(), res.(*v1.Pod).Spec.Containers[0].Resources.Limits.Cpu().Value()) + expectedMemLimit := resource.MustParse("200Mi") + assert.Equal(t, expectedMemLimit.Value(), res.(*v1.Pod).Spec.Containers[0].Resources.Limits.Memory().Value()) + expectedEphemeralStorageLimit := resource.MustParse("100M") + assert.Equal(t, expectedEphemeralStorageLimit.Value(), res.(*v1.Pod).Spec.Containers[0].Resources.Limits.StorageEphemeral().Value()) +} + +func TestBuildSideResource_TaskType1_InvalidSpec(t *testing.T) { + podSpec := v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "primary container", + }, + { + Name: "secondary container", + }, + }, + } + + b, err := json.Marshal(podSpec) + if err != nil { + t.Fatal(err) + } + + structObj := &structpb.Struct{} + if err := json.Unmarshal(b, structObj); err != nil { + t.Fatal(err) + } + + task := core.TaskTemplate{ + Type: SidecarTaskType, + Custom: structObj, + TaskTypeVersion: 1, + } + + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + ResourceTolerations: map[v1.ResourceName][]v1.Toleration{ + v1.ResourceStorage: {}, + ResourceNvidiaGPU: {}, + }, + DefaultCPURequest: resource.MustParse("1024m"), + DefaultMemoryRequest: resource.MustParse("1024Mi"), + })) + taskCtx := getDummySidecarTaskContext(&task, sidecarResourceRequirements, nil) + _, err = DefaultPodPlugin.BuildResource(context.TODO(), taskCtx) + assert.EqualError(t, err, "[BadTaskSpecification] invalid TaskSpecification, config needs to be non-empty and include missing [primary_container_name] key") + + task.Config = map[string]string{ + "foo": "bar", + } + taskCtx = getDummySidecarTaskContext(&task, sidecarResourceRequirements, nil) + _, err = DefaultPodPlugin.BuildResource(context.TODO(), taskCtx) + assert.EqualError(t, err, "[BadTaskSpecification] invalid TaskSpecification, config missing [primary_container_name] key in [map[foo:bar]]") + +} + +func TestBuildSidecarResource(t *testing.T) { + dir, err := os.Getwd() + if err != nil { + t.Fatal(err) + } + sidecarCustomJSON, err := ioutil.ReadFile(path.Join(dir, "testdata", "sidecar_custom")) + if err != nil { + t.Fatal(sidecarCustomJSON) + } + sidecarCustom := structpb.Struct{} + if err := json.Unmarshal(sidecarCustomJSON, &sidecarCustom); err != nil { + t.Fatal(err) + } + task := core.TaskTemplate{ + Type: SidecarTaskType, + Custom: &sidecarCustom, + } + + tolGPU := v1.Toleration{ + Key: "flyte/gpu", + Value: "dedicated", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + } + + tolEphemeralStorage := v1.Toleration{ + Key: "ephemeral-storage", + Value: "dedicated", + Operator: v1.TolerationOpExists, + Effect: v1.TaintEffectNoSchedule, + } + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + ResourceTolerations: map[v1.ResourceName][]v1.Toleration{ + v1.ResourceStorage: {tolEphemeralStorage}, + ResourceNvidiaGPU: {tolGPU}, + }, + DefaultCPURequest: resource.MustParse("1024m"), + DefaultMemoryRequest: resource.MustParse("1024Mi"), + })) + taskCtx := getDummySidecarTaskContext(&task, sidecarResourceRequirements, nil) + res, err := DefaultPodPlugin.BuildResource(context.TODO(), taskCtx) + assert.Nil(t, err) + assert.EqualValues(t, map[string]string{ + flytek8s.PrimaryContainerKey: "a container", + "a1": "a1", + }, res.GetAnnotations()) + + assert.EqualValues(t, map[string]string{ + "b1": "b1", + }, res.GetLabels()) + + // Assert volumes & volume mounts are preserved + assert.Len(t, res.(*v1.Pod).Spec.Volumes, 1) + assert.Equal(t, "dshm", res.(*v1.Pod).Spec.Volumes[0].Name) + + assert.Len(t, res.(*v1.Pod).Spec.Containers[0].VolumeMounts, 1) + assert.Equal(t, "volume mount", res.(*v1.Pod).Spec.Containers[0].VolumeMounts[0].Name) + + assert.Equal(t, "service-account", res.(*v1.Pod).Spec.ServiceAccountName) + + checkTolerations(t, res, tolGPU) + + // Assert resource requirements are correctly set + expectedCPURequest := resource.MustParse("2048m") + assert.Equal(t, expectedCPURequest.Value(), res.(*v1.Pod).Spec.Containers[0].Resources.Requests.Cpu().Value()) + expectedMemRequest := resource.MustParse("1024Mi") + assert.Equal(t, expectedMemRequest.Value(), res.(*v1.Pod).Spec.Containers[0].Resources.Requests.Memory().Value()) + expectedCPULimit := resource.MustParse("2048m") + assert.Equal(t, expectedCPULimit.Value(), res.(*v1.Pod).Spec.Containers[0].Resources.Limits.Cpu().Value()) + expectedMemLimit := resource.MustParse("1024Mi") + assert.Equal(t, expectedMemLimit.Value(), res.(*v1.Pod).Spec.Containers[0].Resources.Limits.Memory().Value()) + expectedEphemeralStorageLimit := resource.MustParse("100M") + assert.Equal(t, expectedEphemeralStorageLimit.Value(), res.(*v1.Pod).Spec.Containers[0].Resources.Limits.StorageEphemeral().Value()) +} + +func TestBuildSidecarReosurceMissingAnnotationsAndLabels(t *testing.T) { + sideCarJob := sidecarJob{ + PrimaryContainerName: "PrimaryContainer", + PodSpec: &v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "PrimaryContainer", + }, + }, + }, + } + + task := getSidecarTaskTemplateForTest(sideCarJob) + + taskCtx := getDummySidecarTaskContext(task, sidecarResourceRequirements, nil) + resp, err := DefaultPodPlugin.BuildResource(context.TODO(), taskCtx) + assert.NoError(t, err) + assert.EqualValues(t, map[string]string{}, resp.GetLabels()) + assert.EqualValues(t, map[string]string{"primary_container_name": "PrimaryContainer"}, resp.GetAnnotations()) +} + +func TestBuildSidecarResourceMissingPrimary(t *testing.T) { + sideCarJob := sidecarJob{ + PrimaryContainerName: "PrimaryContainer", + PodSpec: &v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "SecondaryContainer", + }, + }, + }, + } + + task := getSidecarTaskTemplateForTest(sideCarJob) + + taskCtx := getDummySidecarTaskContext(task, sidecarResourceRequirements, nil) + _, err := DefaultPodPlugin.BuildResource(context.TODO(), taskCtx) + assert.True(t, errors.Is(err, errors2.Errorf("BadTaskSpecification", ""))) +} + +func TestBuildSidecarResource_ExtendedResources(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuDeviceNodeLabel: "gpu-node-label", + GpuPartitionSizeNodeLabel: "gpu-partition-size", + GpuResourceName: flytek8s.ResourceNvidiaGPU, + })) + + fixtures := []struct { + name string + resources *v1.ResourceRequirements + extendedResourcesBase *core.ExtendedResources + extendedResourcesOverride *core.ExtendedResources + expectedNsr []v1.NodeSelectorTerm + expectedTol []v1.Toleration + }{ + { + "without overrides", + &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-t4", + }, + }, + nil, + []v1.NodeSelectorTerm{ + { + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "gpu-node-label", + Operator: v1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-t4"}, + }, + }, + }, + }, + []v1.Toleration{ + { + Key: "gpu-node-label", + Value: "nvidia-tesla-t4", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + }, + }, + { + "with overrides", + &v1.ResourceRequirements{ + Limits: v1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-t4", + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-a100", + PartitionSizeValue: &core.GPUAccelerator_PartitionSize{ + PartitionSize: "1g.5gb", + }, + }, + }, + []v1.NodeSelectorTerm{ + { + MatchExpressions: []v1.NodeSelectorRequirement{ + v1.NodeSelectorRequirement{ + Key: "gpu-node-label", + Operator: v1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-a100"}, + }, + v1.NodeSelectorRequirement{ + Key: "gpu-partition-size", + Operator: v1.NodeSelectorOpIn, + Values: []string{"1g.5gb"}, + }, + }, + }, + }, + []v1.Toleration{ + { + Key: "gpu-node-label", + Value: "nvidia-tesla-a100", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + { + Key: "gpu-partition-size", + Value: "1g.5gb", + Operator: v1.TolerationOpEqual, + Effect: v1.TaintEffectNoSchedule, + }, + }, + }, + } + + podSpec := v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "primary container", + }, + }, + } + b, err := json.Marshal(podSpec) + if err != nil { + t.Fatal(err) + } + structObj := &structpb.Struct{} + if err := json.Unmarshal(b, structObj); err != nil { + t.Fatal(err) + } + testConfigs := []struct { + name string + taskTemplate core.TaskTemplate + }{ + { + "v0", + *getSidecarTaskTemplateForTest(sidecarJob{ + PrimaryContainerName: podSpec.Containers[0].Name, + PodSpec: &podSpec, + }), + }, + { + "v1", + core.TaskTemplate{ + Type: SidecarTaskType, + Custom: structObj, + TaskTypeVersion: 1, + Config: map[string]string{ + flytek8s.PrimaryContainerKey: podSpec.Containers[0].Name, + }, + }, + }, + { + "v2", + core.TaskTemplate{ + Type: SidecarTaskType, + TaskTypeVersion: 2, + Config: map[string]string{ + flytek8s.PrimaryContainerKey: podSpec.Containers[0].Name, + }, + Target: &core.TaskTemplate_K8SPod{ + K8SPod: &core.K8SPod{ + PodSpec: structObj, + }, + }, + }, + }, + } + + for _, tCfg := range testConfigs { + for _, f := range fixtures { + t.Run(tCfg.name+" "+f.name, func(t *testing.T) { + taskTemplate := tCfg.taskTemplate + taskTemplate.ExtendedResources = f.extendedResourcesBase + taskContext := getDummySidecarTaskContext(&taskTemplate, f.resources, f.extendedResourcesOverride) + r, err := DefaultPodPlugin.BuildResource(context.TODO(), taskContext) + assert.Nil(t, err) + assert.NotNil(t, r) + pod, ok := r.(*v1.Pod) + assert.True(t, ok) + + assert.EqualValues( + t, + f.expectedNsr, + pod.Spec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + f.expectedTol, + pod.Spec.Tolerations, + ) + }) + } + } +} + +func TestGetTaskSidecarStatus(t *testing.T) { + sideCarJob := sidecarJob{ + PrimaryContainerName: "PrimaryContainer", + PodSpec: &v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "PrimaryContainer", + }, + }, + }, + } + + task := getSidecarTaskTemplateForTest(sideCarJob) + + var testCases = map[v1.PodPhase]pluginsCore.Phase{ + v1.PodSucceeded: pluginsCore.PhaseSuccess, + v1.PodFailed: pluginsCore.PhaseRetryableFailure, + v1.PodReasonUnschedulable: pluginsCore.PhaseQueued, + v1.PodUnknown: pluginsCore.PhaseUndefined, + } + + for podPhase, expectedTaskPhase := range testCases { + res := &v1.Pod{ + Status: v1.PodStatus{ + Phase: podPhase, + }, + } + res.SetAnnotations(map[string]string{ + flytek8s.PrimaryContainerKey: "PrimaryContainer", + }) + pluginContext := getDummySidecarPluginContext(task, sidecarResourceRequirements) + + phaseInfo, err := DefaultPodPlugin.GetTaskPhase(context.TODO(), pluginContext, res) + + assert.Nil(t, err) + assert.Equal(t, expectedTaskPhase, phaseInfo.Phase(), + "Expected [%v] got [%v] instead, for podPhase [%v]", expectedTaskPhase, phaseInfo.Phase(), podPhase) + } +} + +func TestDemystifiedSidecarStatus_PrimaryFailed(t *testing.T) { + res := &v1.Pod{ + Status: v1.PodStatus{ + Phase: v1.PodRunning, + ContainerStatuses: []v1.ContainerStatus{ + { + Name: "Primary", + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + ExitCode: 1, + }, + }, + }, + }, + }, + } + res.SetAnnotations(map[string]string{ + flytek8s.PrimaryContainerKey: "Primary", + }) + pluginContext := getDummySidecarPluginContext(&core.TaskTemplate{}, sidecarResourceRequirements) + phaseInfo, err := DefaultPodPlugin.GetTaskPhase(context.TODO(), pluginContext, res) + assert.Nil(t, err) + assert.Equal(t, pluginsCore.PhaseRetryableFailure, phaseInfo.Phase()) +} + +func TestDemystifiedSidecarStatus_PrimarySucceeded(t *testing.T) { + res := &v1.Pod{ + Status: v1.PodStatus{ + Phase: v1.PodRunning, + ContainerStatuses: []v1.ContainerStatus{ + { + Name: "Primary", + State: v1.ContainerState{ + Terminated: &v1.ContainerStateTerminated{ + ExitCode: 0, + }, + }, + }, + }, + }, + } + res.SetAnnotations(map[string]string{ + flytek8s.PrimaryContainerKey: "Primary", + }) + pluginContext := getDummySidecarPluginContext(&core.TaskTemplate{}, sidecarResourceRequirements) + phaseInfo, err := DefaultPodPlugin.GetTaskPhase(context.TODO(), pluginContext, res) + assert.Nil(t, err) + assert.Equal(t, pluginsCore.PhaseSuccess, phaseInfo.Phase()) +} + +func TestDemystifiedSidecarStatus_PrimaryRunning(t *testing.T) { + res := &v1.Pod{ + Status: v1.PodStatus{ + Phase: v1.PodRunning, + ContainerStatuses: []v1.ContainerStatus{ + { + Name: "Primary", + State: v1.ContainerState{ + Waiting: &v1.ContainerStateWaiting{ + Reason: "stay patient", + }, + }, + }, + }, + }, + } + res.SetAnnotations(map[string]string{ + flytek8s.PrimaryContainerKey: "Primary", + }) + pluginContext := getDummySidecarPluginContext(&core.TaskTemplate{}, sidecarResourceRequirements) + phaseInfo, err := DefaultPodPlugin.GetTaskPhase(context.TODO(), pluginContext, res) + assert.Nil(t, err) + assert.Equal(t, pluginsCore.PhaseRunning, phaseInfo.Phase()) +} + +func TestDemystifiedSidecarStatus_PrimaryMissing(t *testing.T) { + res := &v1.Pod{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "Secondary", + }, + }, + }, + Status: v1.PodStatus{ + Phase: v1.PodRunning, + ContainerStatuses: []v1.ContainerStatus{ + { + Name: "Secondary", + }, + }, + }, + } + res.SetAnnotations(map[string]string{ + flytek8s.PrimaryContainerKey: "Primary", + }) + pluginContext := getDummySidecarPluginContext(&core.TaskTemplate{}, sidecarResourceRequirements) + phaseInfo, err := DefaultPodPlugin.GetTaskPhase(context.TODO(), pluginContext, res) + assert.Nil(t, err) + assert.Equal(t, pluginsCore.PhasePermanentFailure, phaseInfo.Phase()) +} + +func TestDemystifiedSidecarStatus_PrimaryNotExistsYet(t *testing.T) { + res := &v1.Pod{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "Primary", + }, + }, + }, + Status: v1.PodStatus{ + Phase: v1.PodRunning, + ContainerStatuses: []v1.ContainerStatus{ + { + Name: "Secondary", + }, + }, + }, + } + res.SetAnnotations(map[string]string{ + flytek8s.PrimaryContainerKey: "Primary", + }) + pluginContext := getDummySidecarPluginContext(&core.TaskTemplate{}, sidecarResourceRequirements) + phaseInfo, err := DefaultPodPlugin.GetTaskPhase(context.TODO(), pluginContext, res) + assert.Nil(t, err) + assert.Equal(t, pluginsCore.PhaseRunning, phaseInfo.Phase()) +} + +func TestGetProperties(t *testing.T) { + expected := k8s.PluginProperties{} + assert.Equal(t, expected, DefaultPodPlugin.GetProperties()) +} diff --git a/flyteplugins/go/tasks/plugins/k8s/pod/testdata/sidecar_custom b/flyteplugins/go/tasks/plugins/k8s/pod/testdata/sidecar_custom new file mode 100755 index 0000000000..00b01208a7 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/pod/testdata/sidecar_custom @@ -0,0 +1,54 @@ +{ + "podSpec": { + "restartPolicy": "OnFailure", + "containers": [{ + "name": "a container", + "image": "foo", + "args": ["pyflyte-execute", "--task-module", "tests.flytekit.unit.sdk.tasks.test_sidecar_tasks", "--task-name", "simple_sidecar_task", "--inputs", "{{.input}}", "--output-prefix", "{{.outputPrefix}}"], + "volumeMounts": [{ + "mountPath": "some/where", + "name": "volume mount" + }], + "env": [{ + "name": "FLYTE_INTERNAL_CONFIGURATION_PATH", + "value": "flytekit.config" + }, { + "name": "FLYTE_INTERNAL_PROJECT", + "value": "" + }, { + "name": "foo", + "value": "bar" + }, { + "name": "FLYTE_INTERNAL_DOMAIN", + "value": "" + }, { + "name": "FLYTE_INTERNAL_VERSION", + "value": "" + }] + }, { + "name": "another container" + }], + "volumes": [{ + "volumeSource": { + "emptyDir": { + "sizeLimit": { + "string": "10G" + }, + "medium": "Memory" + } + }, + "name": "dshm" + }], + "tolerations": [{ + "key": "my toleration key", + "value": "my toleration value" + }] + }, + "primaryContainerName": "a container", + "annotations": { + "a1": "a1" + }, + "labels": { + "b1": "b1" + } +} diff --git a/flyteplugins/go/tasks/plugins/k8s/ray/config.go b/flyteplugins/go/tasks/plugins/k8s/ray/config.go new file mode 100644 index 0000000000..082eda0c92 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/ray/config.go @@ -0,0 +1,108 @@ +package ray + +import ( + "context" + + v1 "k8s.io/api/core/v1" + + pluginsConfig "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/logs" + pluginmachinery "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/tasklog" + "github.com/flyteorg/flyte/v2/flytestdlib/config" +) + +//go:generate pflags Config --default-var=defaultConfig + +var ( + defaultConfig = Config{ + ShutdownAfterJobFinishes: true, + TTLSecondsAfterFinished: 3600, + ServiceType: "NodePort", + IncludeDashboard: true, + DashboardHost: "0.0.0.0", + EnableUsageStats: false, + ServiceAccount: "default", + Defaults: DefaultConfig{ + HeadNode: NodeConfig{ + StartParameters: map[string]string{ + // Disable usage reporting by default: https://docs.ray.io/en/latest/cluster/usage-stats.html + DisableUsageStatsStartParameter: "true", + }, + IPAddress: "$MY_POD_IP", + }, + WorkerNode: NodeConfig{ + StartParameters: map[string]string{ + // Disable usage reporting by default: https://docs.ray.io/en/latest/cluster/usage-stats.html + DisableUsageStatsStartParameter: "true", + }, + IPAddress: "$MY_POD_IP", + }, + }, + } + + configSection = pluginsConfig.MustRegisterSubSectionWithUpdates("ray", &defaultConfig, + func(ctx context.Context, newValue config.Config) { + if newValue == nil { + return + } + + if len(newValue.(*Config).Defaults.HeadNode.IPAddress) == 0 { + newValue.(*Config).Defaults.HeadNode.IPAddress = newValue.(*Config).DeprecatedNodeIPAddress + } + + if len(newValue.(*Config).Defaults.WorkerNode.IPAddress) == 0 { + newValue.(*Config).Defaults.WorkerNode.IPAddress = newValue.(*Config).DeprecatedNodeIPAddress + } + }) +) + +// Config is config for 'ray' plugin +type Config struct { + // ShutdownAfterJobFinishes will determine whether to delete the ray cluster once rayJob succeed or failed + ShutdownAfterJobFinishes bool `json:"shutdownAfterJobFinishes,omitempty"` + + // TTLSecondsAfterFinished is the TTL to clean up RayCluster. + // It's only working when ShutdownAfterJobFinishes set to true. + TTLSecondsAfterFinished int32 `json:"ttlSecondsAfterFinished,omitempty"` + + // Kubernetes Service Type, valid values are 'ClusterIP', 'NodePort' and 'LoadBalancer' + ServiceType string `json:"serviceType,omitempty"` + + // IncludeDashboard is used to start a Ray Dashboard if set to true + IncludeDashboard bool `json:"includeDashboard,omitempty"` + + // DashboardHost the host to bind the dashboard server to, either localhost (127.0.0.1) + // or 0.0.0.0 (available from all interfaces). By default, this is localhost. + DashboardHost string `json:"dashboardHost,omitempty"` + + // DeprecatedNodeIPAddress the IP address of the head node. By default, this is pod ip address. + DeprecatedNodeIPAddress string `json:"nodeIPAddress,omitempty" pflag:"-,DEPRECATED. Please use DefaultConfig.[HeadNode|WorkerNode].IPAddress"` + + // Remote Ray Cluster Config + RemoteClusterConfig pluginmachinery.ClusterConfig `json:"remoteClusterConfig" pflag:"Configuration of remote K8s cluster for ray jobs"` + Logs logs.LogConfig `json:"logs" pflag:"-,Log configuration for ray jobs"` + LogsSidecar *v1.Container `json:"logsSidecar" pflag:"-,Sidecar to inject into head pods for capturing ray job logs"` + DashboardURLTemplate *tasklog.TemplateLogPlugin `json:"dashboardURLTemplate" pflag:"-,Template for URL of Ray dashboard running on a head node."` + Defaults DefaultConfig `json:"defaults" pflag:"-,Default configuration for ray jobs"` + EnableUsageStats bool `json:"enableUsageStats" pflag:",Enable usage stats for ray jobs. These stats are submitted to usage-stats.ray.io per https://docs.ray.io/en/latest/cluster/usage-stats.html"` + ServiceAccount string `json:"serviceAccount" pflag:",The k8s service account to run as"` +} + +type DefaultConfig struct { + HeadNode NodeConfig `json:"headNode,omitempty" pflag:"-,Default configuration for head node of ray jobs"` + WorkerNode NodeConfig `json:"workerNode,omitempty" pflag:"-,Default configuration for worker node of ray jobs"` +} + +type NodeConfig struct { + StartParameters map[string]string `json:"startParameters,omitempty" pflag:"-,Start parameters for the node"` + IPAddress string `json:"ipAddress,omitempty" pflag:"-,IP address of the node"` +} + +func GetConfig() *Config { + return configSection.GetConfig().(*Config) +} + +func SetConfig(cfg *Config) error { + return configSection.SetConfig(cfg) +} diff --git a/flyteplugins/go/tasks/plugins/k8s/ray/config_flags.go b/flyteplugins/go/tasks/plugins/k8s/ray/config_flags.go new file mode 100755 index 0000000000..5048869eab --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/ray/config_flags.go @@ -0,0 +1,64 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package ray + +import ( + "encoding/json" + "reflect" + + "fmt" + + "github.com/spf13/pflag" +) + +// If v is a pointer, it will get its element value or the zero value of the element type. +// If v is not a pointer, it will return it as is. +func (Config) elemValueOrNil(v interface{}) interface{} { + if t := reflect.TypeOf(v); t.Kind() == reflect.Ptr { + if reflect.ValueOf(v).IsNil() { + return reflect.Zero(t.Elem()).Interface() + } else { + return reflect.ValueOf(v).Interface() + } + } else if v == nil { + return reflect.Zero(t).Interface() + } + + return v +} + +func (Config) mustJsonMarshal(v interface{}) string { + raw, err := json.Marshal(v) + if err != nil { + panic(err) + } + + return string(raw) +} + +func (Config) mustMarshalJSON(v json.Marshaler) string { + raw, err := v.MarshalJSON() + if err != nil { + panic(err) + } + + return string(raw) +} + +// GetPFlagSet will return strongly types pflags for all fields in Config and its nested types. The format of the +// flags is json-name.json-sub-name... etc. +func (cfg Config) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("Config", pflag.ExitOnError) + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "shutdownAfterJobFinishes"), defaultConfig.ShutdownAfterJobFinishes, "") + cmdFlags.Int32(fmt.Sprintf("%v%v", prefix, "ttlSecondsAfterFinished"), defaultConfig.TTLSecondsAfterFinished, "") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "serviceType"), defaultConfig.ServiceType, "") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "includeDashboard"), defaultConfig.IncludeDashboard, "") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "dashboardHost"), defaultConfig.DashboardHost, "") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "remoteClusterConfig.name"), defaultConfig.RemoteClusterConfig.Name, "Friendly name of the remote cluster") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "remoteClusterConfig.endpoint"), defaultConfig.RemoteClusterConfig.Endpoint, " Remote K8s cluster endpoint") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "remoteClusterConfig.enabled"), defaultConfig.RemoteClusterConfig.Enabled, " Boolean flag to enable or disable") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "enableUsageStats"), defaultConfig.EnableUsageStats, "Enable usage stats for ray jobs. These stats are submitted to usage-stats.ray.io per https://docs.ray.io/en/latest/cluster/usage-stats.html") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "serviceAccount"), defaultConfig.ServiceAccount, "The k8s service account to run as") + return cmdFlags +} diff --git a/flyteplugins/go/tasks/plugins/k8s/ray/config_flags_test.go b/flyteplugins/go/tasks/plugins/k8s/ray/config_flags_test.go new file mode 100755 index 0000000000..05871adc51 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/ray/config_flags_test.go @@ -0,0 +1,242 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package ray + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "testing" + + "github.com/mitchellh/mapstructure" + "github.com/stretchr/testify/assert" +) + +var dereferencableKindsConfig = map[reflect.Kind]struct{}{ + reflect.Array: {}, reflect.Chan: {}, reflect.Map: {}, reflect.Ptr: {}, reflect.Slice: {}, +} + +// Checks if t is a kind that can be dereferenced to get its underlying type. +func canGetElementConfig(t reflect.Kind) bool { + _, exists := dereferencableKindsConfig[t] + return exists +} + +// This decoder hook tests types for json unmarshaling capability. If implemented, it uses json unmarshal to build the +// object. Otherwise, it'll just pass on the original data. +func jsonUnmarshalerHookConfig(_, to reflect.Type, data interface{}) (interface{}, error) { + unmarshalerType := reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + if to.Implements(unmarshalerType) || reflect.PtrTo(to).Implements(unmarshalerType) || + (canGetElementConfig(to.Kind()) && to.Elem().Implements(unmarshalerType)) { + + raw, err := json.Marshal(data) + if err != nil { + fmt.Printf("Failed to marshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + res := reflect.New(to).Interface() + err = json.Unmarshal(raw, &res) + if err != nil { + fmt.Printf("Failed to umarshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + return res, nil + } + + return data, nil +} + +func decode_Config(input, result interface{}) error { + config := &mapstructure.DecoderConfig{ + TagName: "json", + WeaklyTypedInput: true, + Result: result, + DecodeHook: mapstructure.ComposeDecodeHookFunc( + mapstructure.StringToTimeDurationHookFunc(), + mapstructure.StringToSliceHookFunc(","), + jsonUnmarshalerHookConfig, + ), + } + + decoder, err := mapstructure.NewDecoder(config) + if err != nil { + return err + } + + return decoder.Decode(input) +} + +func join_Config(arr interface{}, sep string) string { + listValue := reflect.ValueOf(arr) + strs := make([]string, 0, listValue.Len()) + for i := 0; i < listValue.Len(); i++ { + strs = append(strs, fmt.Sprintf("%v", listValue.Index(i))) + } + + return strings.Join(strs, sep) +} + +func testDecodeJson_Config(t *testing.T, val, result interface{}) { + assert.NoError(t, decode_Config(val, result)) +} + +func testDecodeRaw_Config(t *testing.T, vStringSlice, result interface{}) { + assert.NoError(t, decode_Config(vStringSlice, result)) +} + +func TestConfig_GetPFlagSet(t *testing.T) { + val := Config{} + cmdFlags := val.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) +} + +func TestConfig_SetFlags(t *testing.T) { + actual := Config{} + cmdFlags := actual.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) + + t.Run("Test_shutdownAfterJobFinishes", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("shutdownAfterJobFinishes", testValue) + if vBool, err := cmdFlags.GetBool("shutdownAfterJobFinishes"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.ShutdownAfterJobFinishes) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_ttlSecondsAfterFinished", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("ttlSecondsAfterFinished", testValue) + if vInt32, err := cmdFlags.GetInt32("ttlSecondsAfterFinished"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vInt32), &actual.TTLSecondsAfterFinished) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_serviceType", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("serviceType", testValue) + if vString, err := cmdFlags.GetString("serviceType"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.ServiceType) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_includeDashboard", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("includeDashboard", testValue) + if vBool, err := cmdFlags.GetBool("includeDashboard"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.IncludeDashboard) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_dashboardHost", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("dashboardHost", testValue) + if vString, err := cmdFlags.GetString("dashboardHost"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.DashboardHost) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_remoteClusterConfig.name", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("remoteClusterConfig.name", testValue) + if vString, err := cmdFlags.GetString("remoteClusterConfig.name"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.RemoteClusterConfig.Name) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_remoteClusterConfig.endpoint", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("remoteClusterConfig.endpoint", testValue) + if vString, err := cmdFlags.GetString("remoteClusterConfig.endpoint"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.RemoteClusterConfig.Endpoint) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_remoteClusterConfig.enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("remoteClusterConfig.enabled", testValue) + if vBool, err := cmdFlags.GetBool("remoteClusterConfig.enabled"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.RemoteClusterConfig.Enabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_enableUsageStats", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("enableUsageStats", testValue) + if vBool, err := cmdFlags.GetBool("enableUsageStats"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.EnableUsageStats) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_serviceAccount", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("serviceAccount", testValue) + if vString, err := cmdFlags.GetString("serviceAccount"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.ServiceAccount) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) +} diff --git a/flyteplugins/go/tasks/plugins/k8s/ray/config_test.go b/flyteplugins/go/tasks/plugins/k8s/ray/config_test.go new file mode 100644 index 0000000000..fcfe38cec0 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/ray/config_test.go @@ -0,0 +1,37 @@ +package ray + +import ( + "testing" + + "gotest.tools/assert" + + pluginmachinery "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" +) + +func TestLoadConfig(t *testing.T) { + rayConfig := GetConfig() + assert.Assert(t, rayConfig != nil) + + t.Run("remote cluster", func(t *testing.T) { + config := GetConfig() + remoteConfig := pluginmachinery.ClusterConfig{ + Enabled: false, + Endpoint: "", + Auth: pluginmachinery.Auth{ + TokenPath: "", + CaCertPath: "", + }, + } + assert.DeepEqual(t, config.RemoteClusterConfig, remoteConfig) + }) +} + +func TestLoadDefaultServiceAccountConfig(t *testing.T) { + rayConfig := GetConfig() + assert.Assert(t, rayConfig != nil) + + t.Run("serviceAccount", func(t *testing.T) { + config := GetConfig() + assert.Equal(t, config.ServiceAccount, "default") + }) +} diff --git a/flyteplugins/go/tasks/plugins/k8s/ray/ray.go b/flyteplugins/go/tasks/plugins/k8s/ray/ray.go new file mode 100644 index 0000000000..b66a7fafcd --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/ray/ray.go @@ -0,0 +1,815 @@ +package ray + +import ( + "context" + "encoding/base64" + "encoding/json" + "fmt" + "regexp" + "strconv" + "strings" + "time" + + rayv1 "github.com/ray-project/kuberay/ray-operator/apis/ray/v1" + "github.com/samber/lo" + "gopkg.in/yaml.v2" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/kubernetes/scheme" + "sigs.k8s.io/controller-runtime/pkg/client" + + flyteerr "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/logs" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery" + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/tasklog" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/plugins/k8s/pod" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" +) + +const ( + rayStateMountPath = "/tmp/ray" + defaultRayStateVolName = "system-ray-state" + rayTaskType = "ray" + KindRayJob = "RayJob" + IncludeDashboard = "include-dashboard" + NodeIPAddress = "node-ip-address" + DashboardHost = "dashboard-host" + DisableUsageStatsStartParameter = "disable-usage-stats" + DisableUsageStatsStartParameterVal = "true" + RayHeadContainerName = "ray-head" +) + +var logTemplateRegexes = struct { + RayClusterName *regexp.Regexp + RayJobID *regexp.Regexp +}{ + tasklog.MustCreateRegex("rayClusterName"), + tasklog.MustCreateRegex("rayJobID"), +} + +// Copy it from KubeRay to avoid adding a new dependency to go.mod. +// https://github.com/ray-project/kuberay/blob/1ced2b968eabcfee4dcfa61391d307b60e46a2ed/ray-operator/controllers/ray/common/job.go#L122-L145 +var submitterDefaultResourceRequirements = v1.ResourceRequirements{ + Limits: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("1"), + v1.ResourceMemory: resource.MustParse("1Gi"), + }, + Requests: v1.ResourceList{ + v1.ResourceCPU: resource.MustParse("500m"), + v1.ResourceMemory: resource.MustParse("200Mi"), + }, +} + +type rayJobResourceHandler struct{} + +func (rayJobResourceHandler) GetProperties() k8s.PluginProperties { + maxLength := 47 + return k8s.PluginProperties{GeneratedNameMaxLength: &maxLength} +} + +// BuildResource Creates a new ray job resource +func (rayJobResourceHandler) BuildResource(ctx context.Context, taskCtx pluginsCore.TaskExecutionContext) (client.Object, error) { + taskTemplate, err := taskCtx.TaskReader().Read(ctx) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "unable to fetch task specification [%v]", err.Error()) + } else if taskTemplate == nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "nil task specification") + } + + rayJob := plugins.RayJob{} + err = utils.UnmarshalStruct(taskTemplate.GetCustom(), &rayJob) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "invalid TaskSpecification [%v], Err: [%v]", taskTemplate.GetCustom(), err.Error()) + } + + podSpec, objectMeta, primaryContainerName, err := flytek8s.ToK8sPodSpec(ctx, taskCtx) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "Unable to create pod spec: [%v]", err.Error()) + } + + var primaryContainer *v1.Container + var primaryContainerIdx int + for idx, c := range podSpec.Containers { + if c.Name == primaryContainerName { + c := c + primaryContainer = &c + primaryContainerIdx = idx + break + } + } + + if primaryContainer == nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, "Unable to get primary container from the pod: [%v]", err.Error()) + } + + cfg := GetConfig() + + headNodeRayStartParams := make(map[string]string) + if rayJob.RayCluster.HeadGroupSpec != nil && rayJob.RayCluster.HeadGroupSpec.RayStartParams != nil { + headNodeRayStartParams = rayJob.RayCluster.HeadGroupSpec.RayStartParams + } else if headNode := cfg.Defaults.HeadNode; len(headNode.StartParameters) > 0 { + headNodeRayStartParams = headNode.StartParameters + } + + if _, exist := headNodeRayStartParams[IncludeDashboard]; !exist { + headNodeRayStartParams[IncludeDashboard] = strconv.FormatBool(GetConfig().IncludeDashboard) + } + + if _, exist := headNodeRayStartParams[NodeIPAddress]; !exist { + headNodeRayStartParams[NodeIPAddress] = cfg.Defaults.HeadNode.IPAddress + } + + if _, exist := headNodeRayStartParams[DashboardHost]; !exist { + headNodeRayStartParams[DashboardHost] = cfg.DashboardHost + } + + if _, exists := headNodeRayStartParams[DisableUsageStatsStartParameter]; !exists && !cfg.EnableUsageStats { + headNodeRayStartParams[DisableUsageStatsStartParameter] = DisableUsageStatsStartParameterVal + } + + podSpec.ServiceAccountName = cfg.ServiceAccount + + rayjob, err := constructRayJob(taskCtx, &rayJob, objectMeta, *podSpec, headNodeRayStartParams, primaryContainerIdx, *primaryContainer) + + return rayjob, err +} + +func constructRayJob(taskCtx pluginsCore.TaskExecutionContext, rayJob *plugins.RayJob, objectMeta *metav1.ObjectMeta, taskPodSpec v1.PodSpec, headNodeRayStartParams map[string]string, primaryContainerIdx int, primaryContainer v1.Container) (*rayv1.RayJob, error) { + enableIngress := true + cfg := GetConfig() + + headPodSpec := taskPodSpec.DeepCopy() + headPodTemplate, err := buildHeadPodTemplate( + &headPodSpec.Containers[primaryContainerIdx], + headPodSpec, + objectMeta, + taskCtx, + rayJob.RayCluster.HeadGroupSpec, + ) + if err != nil { + return nil, err + } + + rayClusterSpec := rayv1.RayClusterSpec{ + HeadGroupSpec: rayv1.HeadGroupSpec{ + Template: headPodTemplate, + ServiceType: v1.ServiceType(cfg.ServiceType), + EnableIngress: &enableIngress, + RayStartParams: headNodeRayStartParams, + }, + WorkerGroupSpecs: []rayv1.WorkerGroupSpec{}, + EnableInTreeAutoscaling: &rayJob.RayCluster.EnableAutoscaling, + } + + for _, spec := range rayJob.RayCluster.WorkerGroupSpec { + workerPodSpec := taskPodSpec.DeepCopy() + workerPodTemplate, err := buildWorkerPodTemplate( + &workerPodSpec.Containers[primaryContainerIdx], + workerPodSpec, + objectMeta, + taskCtx, + spec, + ) + if err != nil { + return nil, err + } + + workerNodeRayStartParams := make(map[string]string) + if spec.RayStartParams != nil { + workerNodeRayStartParams = spec.RayStartParams + } else if workerNode := cfg.Defaults.WorkerNode; len(workerNode.StartParameters) > 0 { + workerNodeRayStartParams = workerNode.StartParameters + } + + if _, exist := workerNodeRayStartParams[NodeIPAddress]; !exist { + workerNodeRayStartParams[NodeIPAddress] = cfg.Defaults.WorkerNode.IPAddress + } + + if _, exists := workerNodeRayStartParams[DisableUsageStatsStartParameter]; !exists && !cfg.EnableUsageStats { + workerNodeRayStartParams[DisableUsageStatsStartParameter] = DisableUsageStatsStartParameterVal + } + + minReplicas := spec.MinReplicas + if minReplicas > spec.Replicas { + minReplicas = spec.Replicas + } + maxReplicas := spec.MaxReplicas + if maxReplicas < spec.Replicas { + maxReplicas = spec.Replicas + } + + workerNodeSpec := rayv1.WorkerGroupSpec{ + GroupName: spec.GroupName, + MinReplicas: &minReplicas, + MaxReplicas: &maxReplicas, + Replicas: &spec.Replicas, + RayStartParams: workerNodeRayStartParams, + Template: workerPodTemplate, + } + + rayClusterSpec.WorkerGroupSpecs = append(rayClusterSpec.WorkerGroupSpecs, workerNodeSpec) + } + + serviceAccountName := flytek8s.GetServiceAccountNameFromTaskExecutionMetadata(taskCtx.TaskExecutionMetadata()) + if len(serviceAccountName) == 0 { + serviceAccountName = cfg.ServiceAccount + } + + rayClusterSpec.HeadGroupSpec.Template.Spec.ServiceAccountName = serviceAccountName + for index := range rayClusterSpec.WorkerGroupSpecs { + rayClusterSpec.WorkerGroupSpecs[index].Template.Spec.ServiceAccountName = serviceAccountName + } + + shutdownAfterJobFinishes := cfg.ShutdownAfterJobFinishes + ttlSecondsAfterFinished := &cfg.TTLSecondsAfterFinished + if rayJob.ShutdownAfterJobFinishes { + shutdownAfterJobFinishes = true + ttlSecondsAfterFinished = &rayJob.TtlSecondsAfterFinished + } + + submitterPodTemplate := buildSubmitterPodTemplate(&rayClusterSpec) + + // TODO: This is for backward compatibility. Remove this block once runtime_env is removed from ray proto. + var runtimeEnvYaml string + runtimeEnvYaml = rayJob.RuntimeEnvYaml + // If runtime_env exists but runtime_env_yaml does not, convert runtime_env to runtime_env_yaml + if rayJob.RuntimeEnv != "" && rayJob.RuntimeEnvYaml == "" { + runtimeEnvYaml, err = convertBase64RuntimeEnvToYaml(rayJob.RuntimeEnv) + if err != nil { + return nil, err + } + } + + jobSpec := rayv1.RayJobSpec{ + RayClusterSpec: &rayClusterSpec, + Entrypoint: strings.Join(primaryContainer.Args, " "), + ShutdownAfterJobFinishes: shutdownAfterJobFinishes, + TTLSecondsAfterFinished: *ttlSecondsAfterFinished, + RuntimeEnvYAML: runtimeEnvYaml, + SubmitterPodTemplate: &submitterPodTemplate, + } + + return &rayv1.RayJob{ + TypeMeta: metav1.TypeMeta{ + Kind: KindRayJob, + APIVersion: rayv1.SchemeGroupVersion.String(), + }, + Spec: jobSpec, + ObjectMeta: *objectMeta, + }, nil +} + +func convertBase64RuntimeEnvToYaml(s string) (string, error) { + // Decode from base64 + data, err := base64.StdEncoding.DecodeString(s) + if err != nil { + return "", err + } + + // Unmarshal JSON + var obj map[string]interface{} + err = json.Unmarshal(data, &obj) + if err != nil { + return "", err + } + + // Convert to YAML + y, err := yaml.Marshal(&obj) + if err != nil { + return "", err + } + + return string(y), nil +} + +func injectLogsSidecar(primaryContainer *v1.Container, podSpec *v1.PodSpec) { + cfg := GetConfig() + if cfg.LogsSidecar == nil { + return + } + sidecar := cfg.LogsSidecar.DeepCopy() + + // Ray logs integration + var rayStateVolMount *v1.VolumeMount + // Look for an existing volume mount on the primary container, mounted at /tmp/ray + for _, vm := range primaryContainer.VolumeMounts { + if vm.MountPath == rayStateMountPath { + vm := vm + rayStateVolMount = &vm + break + } + } + // No existing volume mount exists at /tmp/ray. We create a new volume and volume + // mount and add it to the pod and container specs respectively + if rayStateVolMount == nil { + vol := v1.Volume{ + Name: defaultRayStateVolName, + VolumeSource: v1.VolumeSource{ + EmptyDir: &v1.EmptyDirVolumeSource{}, + }, + } + podSpec.Volumes = append(podSpec.Volumes, vol) + volMount := v1.VolumeMount{ + Name: defaultRayStateVolName, + MountPath: rayStateMountPath, + } + primaryContainer.VolumeMounts = append(primaryContainer.VolumeMounts, volMount) + rayStateVolMount = &volMount + } + // We need to mirror the ray state volume mount into the sidecar as readonly, + // so that we can read the logs written by the head node. + readOnlyRayStateVolMount := *rayStateVolMount.DeepCopy() + readOnlyRayStateVolMount.ReadOnly = true + + // Update volume mounts on sidecar + // If one already exists with the desired mount path, simply replace it. Otherwise, + // add it to sidecar's volume mounts. + foundExistingSidecarVolMount := false + for idx, vm := range sidecar.VolumeMounts { + if vm.MountPath == rayStateMountPath { + foundExistingSidecarVolMount = true + sidecar.VolumeMounts[idx] = readOnlyRayStateVolMount + } + } + if !foundExistingSidecarVolMount { + sidecar.VolumeMounts = append(sidecar.VolumeMounts, readOnlyRayStateVolMount) + } + + // Add sidecar to containers + podSpec.Containers = append(podSpec.Containers, *sidecar) +} + +func buildHeadPodTemplate(primaryContainer *v1.Container, basePodSpec *v1.PodSpec, objectMeta *metav1.ObjectMeta, taskCtx pluginsCore.TaskExecutionContext, spec *plugins.HeadGroupSpec) (v1.PodTemplateSpec, error) { + // Some configs are copy from https://github.com/ray-project/kuberay/blob/b72e6bdcd9b8c77a9dc6b5da8560910f3a0c3ffd/apiserver/pkg/util/cluster.go#L97 + // They should always be the same, so we could hard code here. + primaryContainer.Name = RayHeadContainerName + + envs := []v1.EnvVar{ + { + Name: "MY_POD_IP", + ValueFrom: &v1.EnvVarSource{ + FieldRef: &v1.ObjectFieldSelector{ + FieldPath: "status.podIP", + }, + }, + }, + } + + // Removed 'a0 ..' / 'pyflyte-execute ..' args from the pod spec. + primaryContainer.Args = []string{} + primaryContainer.Env = append(primaryContainer.Env, envs...) + + ports := []v1.ContainerPort{ + { + Name: "redis", + ContainerPort: 6379, + }, + { + Name: "head", + ContainerPort: 10001, + }, + { + Name: "dashboard", + ContainerPort: 8265, + }, + } + + primaryContainer.Ports = append(primaryContainer.Ports, ports...) + + // Inject a sidecar for capturing and exposing Ray job logs + injectLogsSidecar(primaryContainer, basePodSpec) + + basePodSpec, err := mergeCustomPodSpec(basePodSpec, spec.GetK8SPod()) + if err != nil { + return v1.PodTemplateSpec{}, err + } + + basePodSpec = flytek8s.AddTolerationsForExtendedResources(basePodSpec) + + podTemplateSpec := v1.PodTemplateSpec{ + Spec: *basePodSpec, + ObjectMeta: *objectMeta, + } + cfg := config.GetK8sPluginConfig() + podTemplateSpec.SetLabels(utils.UnionMaps(cfg.DefaultLabels, podTemplateSpec.GetLabels(), utils.CopyMap(taskCtx.TaskExecutionMetadata().GetLabels()), spec.GetK8SPod().GetMetadata().GetLabels())) + podTemplateSpec.SetAnnotations(utils.UnionMaps(cfg.DefaultAnnotations, podTemplateSpec.GetAnnotations(), utils.CopyMap(taskCtx.TaskExecutionMetadata().GetAnnotations()), spec.GetK8SPod().GetMetadata().GetAnnotations())) + + return podTemplateSpec, nil +} + +func buildSubmitterPodTemplate(rayClusterSpec *rayv1.RayClusterSpec) v1.PodTemplateSpec { + + submitterPodSpec := rayClusterSpec.HeadGroupSpec.Template.DeepCopy() + + submitterPodSpec.Spec.Containers = []v1.Container{ + { + Name: "ray-job-submitter", + // Use the image of the Ray head to be defensive against version mismatch issues + Image: rayClusterSpec.HeadGroupSpec.Template.Spec.Containers[0].Image, + Resources: submitterDefaultResourceRequirements, + }, + } + + return *submitterPodSpec +} + +func buildWorkerPodTemplate(primaryContainer *v1.Container, basePodSpec *v1.PodSpec, objectMetadata *metav1.ObjectMeta, taskCtx pluginsCore.TaskExecutionContext, spec *plugins.WorkerGroupSpec) (v1.PodTemplateSpec, error) { + // Some configs are copy from https://github.com/ray-project/kuberay/blob/b72e6bdcd9b8c77a9dc6b5da8560910f3a0c3ffd/apiserver/pkg/util/cluster.go#L185 + // They should always be the same, so we could hard code here. + + primaryContainer.Name = "ray-worker" + + primaryContainer.Args = []string{} + + envs := []v1.EnvVar{ + { + Name: "RAY_DISABLE_DOCKER_CPU_WARNING", + Value: "1", + }, + { + Name: "TYPE", + Value: "worker", + }, + { + Name: "CPU_REQUEST", + ValueFrom: &v1.EnvVarSource{ + ResourceFieldRef: &v1.ResourceFieldSelector{ + ContainerName: "ray-worker", + Resource: "requests.cpu", + }, + }, + }, + { + Name: "CPU_LIMITS", + ValueFrom: &v1.EnvVarSource{ + ResourceFieldRef: &v1.ResourceFieldSelector{ + ContainerName: "ray-worker", + Resource: "limits.cpu", + }, + }, + }, + { + Name: "MEMORY_REQUESTS", + ValueFrom: &v1.EnvVarSource{ + ResourceFieldRef: &v1.ResourceFieldSelector{ + ContainerName: "ray-worker", + Resource: "requests.cpu", + }, + }, + }, + { + Name: "MEMORY_LIMITS", + ValueFrom: &v1.EnvVarSource{ + ResourceFieldRef: &v1.ResourceFieldSelector{ + ContainerName: "ray-worker", + Resource: "limits.cpu", + }, + }, + }, + { + Name: "MY_POD_NAME", + ValueFrom: &v1.EnvVarSource{ + FieldRef: &v1.ObjectFieldSelector{ + FieldPath: "metadata.name", + }, + }, + }, + { + Name: "MY_POD_IP", + ValueFrom: &v1.EnvVarSource{ + FieldRef: &v1.ObjectFieldSelector{ + FieldPath: "status.podIP", + }, + }, + }, + } + + primaryContainer.Env = append(primaryContainer.Env, envs...) + + primaryContainer.Lifecycle = &v1.Lifecycle{ + PreStop: &v1.LifecycleHandler{ + Exec: &v1.ExecAction{ + Command: []string{ + "/bin/sh", "-c", "ray stop", + }, + }, + }, + } + + ports := []v1.ContainerPort{ + { + Name: "redis", + ContainerPort: 6379, + }, + { + Name: "head", + ContainerPort: 10001, + }, + { + Name: "dashboard", + ContainerPort: 8265, + }, + } + primaryContainer.Ports = append(primaryContainer.Ports, ports...) + + basePodSpec, err := mergeCustomPodSpec(basePodSpec, spec.GetK8SPod()) + if err != nil { + return v1.PodTemplateSpec{}, err + } + + basePodSpec = flytek8s.AddTolerationsForExtendedResources(basePodSpec) + + podTemplateSpec := v1.PodTemplateSpec{ + Spec: *basePodSpec, + ObjectMeta: *objectMetadata, + } + cfg := config.GetK8sPluginConfig() + podTemplateSpec.SetLabels(utils.UnionMaps(cfg.DefaultLabels, podTemplateSpec.GetLabels(), utils.CopyMap(taskCtx.TaskExecutionMetadata().GetLabels()), spec.GetK8SPod().GetMetadata().GetLabels())) + podTemplateSpec.SetAnnotations(utils.UnionMaps(cfg.DefaultAnnotations, podTemplateSpec.GetAnnotations(), utils.CopyMap(taskCtx.TaskExecutionMetadata().GetAnnotations()), spec.GetK8SPod().GetMetadata().GetAnnotations())) + return podTemplateSpec, nil +} + +// Merges a ray head/worker node custom pod specs onto task's generated pod spec +func mergeCustomPodSpec(podSpec *v1.PodSpec, k8sPod *core.K8SPod) (*v1.PodSpec, error) { + if k8sPod == nil { + return podSpec, nil + } + + if k8sPod.PodSpec == nil { + return podSpec, nil + } + + var customPodSpec *v1.PodSpec + + err := utils.UnmarshalStructToObj(k8sPod.PodSpec, &customPodSpec) + if err != nil { + return nil, flyteerr.Errorf(flyteerr.BadTaskSpecification, + "Unable to unmarshal pod spec [%v], Err: [%v]", k8sPod.PodSpec, err.Error()) + } + + podSpec, err = flytek8s.MergeOverlayPodSpecOntoBase(podSpec, customPodSpec) + if err != nil { + return nil, err + } + + return podSpec, nil +} + +func (rayJobResourceHandler) BuildIdentityResource(ctx context.Context, taskCtx pluginsCore.TaskExecutionMetadata) (client.Object, error) { + return &rayv1.RayJob{ + TypeMeta: metav1.TypeMeta{ + Kind: KindRayJob, + APIVersion: rayv1.SchemeGroupVersion.String(), + }, + }, nil +} + +func getEventInfoForRayJob(ctx context.Context, logConfig logs.LogConfig, pluginContext k8s.PluginContext, rayJob *rayv1.RayJob) (*pluginsCore.TaskInfo, error) { + logPlugin, err := logs.InitializeLogPlugins(&logConfig) + if err != nil { + return nil, fmt.Errorf("failed to initialize log plugins. Error: %w", err) + } + + var taskLogs []*core.TaskLog + taskExecID := pluginContext.TaskExecutionMetadata().GetTaskExecutionID() + podList := &v1.PodList{} + err = pluginContext.K8sReader().List(ctx, podList) + if err != nil { + return nil, fmt.Errorf("failed to list node execution pods. Error: %w", err) + } + var enableVscode bool + if rayJob.Spec.RayClusterSpec != nil && + rayJob.Spec.RayClusterSpec.HeadGroupSpec.Template.Spec.Containers != nil && + len(rayJob.Spec.RayClusterSpec.HeadGroupSpec.Template.Spec.Containers) > 0 { + enableVscode = flytek8s.IsVscodeEnabled(ctx, rayJob.Spec.RayClusterSpec.HeadGroupSpec.Template.Spec.Containers[0].Env) + } + input := tasklog.Input{ + PodName: fmt.Sprintf("%s-head", rayJob.Status.RayClusterName), + Namespace: rayJob.Namespace, + TaskExecutionID: taskExecID, + ExtraTemplateVars: []tasklog.TemplateVar{}, + EnableVscode: enableVscode, + } + if rayJob.Status.JobId != "" { + input.ExtraTemplateVars = append( + input.ExtraTemplateVars, + tasklog.TemplateVar{ + Regex: logTemplateRegexes.RayJobID, + Value: rayJob.Status.JobId, + }, + ) + } + if rayJob.Status.RayClusterName != "" { + input.ExtraTemplateVars = append( + input.ExtraTemplateVars, + tasklog.TemplateVar{ + Regex: logTemplateRegexes.RayClusterName, + Value: rayJob.Status.RayClusterName, + }, + ) + } + + // TODO: Retrieve the name of head pod from rayJob.status, and add it to task logs + // RayJob CRD does not include the name of the worker or head pod for now + logOutput, err := logPlugin.GetTaskLogs(input) + if err != nil { + return nil, fmt.Errorf("failed to generate task logs. Error: %w", err) + } + taskLogs = append(taskLogs, logOutput.TaskLogs...) + + // Handling for Ray Dashboard + dashboardURLTemplate := GetConfig().DashboardURLTemplate + if dashboardURLTemplate != nil && + rayJob.Status.DashboardURL != "" && + rayJob.Status.JobStatus == rayv1.JobStatusRunning { + dashboardURLTemplate.LinkType = core.TaskLog_DASHBOARD.String() + dashboardURLOutput, err := dashboardURLTemplate.GetTaskLogs(input) + if err != nil { + return nil, fmt.Errorf("failed to generate Ray dashboard link. Error: %w", err) + } + taskLogs = append(taskLogs, dashboardURLOutput.TaskLogs...) + } + + return &pluginsCore.TaskInfo{ + Logs: taskLogs, + LogContext: logContextForPods(rayJob.Name, podList.Items), + }, nil +} + +func isRayHeadReady(ctx context.Context, rayJobName string, pluginContext k8s.PluginContext) (bool, error) { + podList := &v1.PodList{} + err := pluginContext.K8sReader().List(ctx, podList) + if err != nil { + return false, fmt.Errorf("failed to list node execution pods. Error: %w", err) + } + pods := lo.Filter(podList.Items, func(pod v1.Pod, _ int) bool { + return pod.Status.Phase != v1.PodPending && strings.HasPrefix(pod.Name, rayJobName) && strings.Contains(pod.Name, "head") && flytek8s.GetPrimaryContainerName(&pod) == RayHeadContainerName + }) + if len(pods) == 0 { + return false, nil + } else if len(pods) == 1 { + return pod.IsPodReady(&pods[0]), nil + } + + // More than one head pod. Should not happen. + logger.Debug(ctx, "Cannot determine Ray head readiness: more than one head pod found") + return true, fmt.Errorf("more than one head pod found for Ray job %s", rayJobName) +} + +func logContextForPods(rayJobName string, pods []v1.Pod) *core.LogContext { + pods = lo.Filter(pods, func(item v1.Pod, _ int) bool { + // Running, Succeeded or Failed is OK + return item.Status.Phase != v1.PodPending + }) + logCtx := &core.LogContext{ + Pods: make([]*core.PodLogContext, len(pods)), + } + for i, pod := range pods { + p := pod + // Ray job has name like `az6dh2bxk6wnxn2xv8l6-n0-0` + // Ray head primary pod has name like `az6dh2bxk6wnxn2xv8l6-n0-0-raycluster-szwgz-head-z59ss` + if strings.HasPrefix(p.Name, rayJobName) && strings.Contains(p.Name, "head") && flytek8s.GetPrimaryContainerName(&p) == RayHeadContainerName { + logCtx.PrimaryPodName = p.Name + } + logCtx.Pods[i] = flytek8s.BuildPodLogContext(&p) + } + return logCtx +} + +func (plugin rayJobResourceHandler) GetTaskPhase(ctx context.Context, pluginContext k8s.PluginContext, resource client.Object) (pluginsCore.PhaseInfo, error) { + rayJob := resource.(*rayv1.RayJob) + info, err := getEventInfoForRayJob(ctx, GetConfig().Logs, pluginContext, rayJob) + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + + if len(rayJob.Status.JobDeploymentStatus) == 0 { + return pluginsCore.PhaseInfoQueuedWithTaskInfo(time.Now(), pluginsCore.DefaultPhaseVersion, "Scheduling", info), nil + } + + podName := fmt.Sprintf("%s-head", rayJob.Status.RayClusterName) + phaseInfo, err := flytek8s.DemystifyFailedOrPendingPod(ctx, pluginContext, *info, rayJob.Namespace, podName, RayHeadContainerName) + if err != nil { + logger.Errorf(ctx, "Failed to demystify pod status for ray head node. Error: %v", err) + } + if phaseInfo.Phase().IsFailure() { + // If the ray head node is in a failure state, we can fail fast without checking the RayJob status. + return phaseInfo, nil + } + + // KubeRay creates a Ray cluster first, and then submits a Ray job to the cluster + switch rayJob.Status.JobDeploymentStatus { + case rayv1.JobDeploymentStatusInitializing: + phaseInfo, err = pluginsCore.PhaseInfoInitializing(rayJob.CreationTimestamp.Time, pluginsCore.DefaultPhaseVersion, "cluster is creating", info), nil + case rayv1.JobDeploymentStatusRunning: + phaseInfo, err = pluginsCore.PhaseInfoRunning(pluginsCore.DefaultPhaseVersion, info), nil + case rayv1.JobDeploymentStatusComplete: + phaseInfo, err = pluginsCore.PhaseInfoSuccess(info), nil + case rayv1.JobDeploymentStatusSuspending: + return pluginsCore.PhaseInfoQueuedWithTaskInfo(time.Now(), pluginsCore.DefaultPhaseVersion, "cluster is about to be suspended", info), nil + case rayv1.JobDeploymentStatusSuspended: + return pluginsCore.PhaseInfoQueuedWithTaskInfo(time.Now(), pluginsCore.DefaultPhaseVersion, "cluster is suspended", info), nil + case rayv1.JobDeploymentStatusFailed: + failInfo := fmt.Sprintf("Failed to run Ray job %s with error: [%s] %s", rayJob.Name, rayJob.Status.Reason, rayJob.Status.Message) + phaseInfo, err = pluginsCore.PhaseInfoFailure(flyteerr.TaskFailedWithError, failInfo, info), nil + default: + // We already handle all known deployment status, so this should never happen unless a future version of ray + // introduced a new job status. + phaseInfo, err = pluginsCore.PhaseInfoUndefined, fmt.Errorf("unknown job deployment status: %s", rayJob.Status.JobDeploymentStatus) + } + + if ready, err := isRayHeadReady(ctx, rayJob.Name, pluginContext); err != nil { + logger.Warnf(ctx, "Failed to determine Ray dashboard readiness. Error: %v", err) + } else { + for _, tl := range info.Logs { + if tl != nil && tl.LinkType == core.TaskLog_DASHBOARD { + tl.Ready = ready + if !ready || phaseInfo.Phase() < pluginsCore.PhaseRunning { + phaseInfo.WithReason("Ray dashboard is not ready") + } else { + phaseInfo.WithReason("Ray dashboard is ready") + } + } else if tl != nil && tl.LinkType == core.TaskLog_IDE { + tl.Ready = ready + if !ready || phaseInfo.Phase() != pluginsCore.PhaseRunning { + phaseInfo.WithReason("Vscode server is not ready") + } else { + phaseInfo.WithReason("Vscode server is ready") + } + } + } + } + + phaseVersionUpdateErr := k8s.MaybeUpdatePhaseVersionFromPluginContext(&phaseInfo, &pluginContext) + if phaseVersionUpdateErr != nil { + return phaseInfo, phaseVersionUpdateErr + } + + return phaseInfo, err +} + +// IsTerminal returns true if the RayJob is in a terminal state (Complete or Failed) +func (rayJobResourceHandler) IsTerminal(_ context.Context, resource client.Object) (bool, error) { + job, ok := resource.(*rayv1.RayJob) + if !ok { + return false, fmt.Errorf("unexpected resource type: expected *RayJob, got %T", resource) + } + status := job.Status.JobDeploymentStatus + return status == rayv1.JobDeploymentStatusComplete || status == rayv1.JobDeploymentStatusFailed, nil +} + +// GetCompletionTime returns the end time of the RayJob +func (rayJobResourceHandler) GetCompletionTime(resource client.Object) (time.Time, error) { + job, ok := resource.(*rayv1.RayJob) + if !ok { + return time.Time{}, fmt.Errorf("unexpected resource type: expected *RayJob, got %T", resource) + } + + if job.Status.EndTime != nil && !job.Status.EndTime.IsZero() { + return job.Status.EndTime.Time, nil + } + + // Fallback to start time or creation time + if job.Status.StartTime != nil && !job.Status.StartTime.IsZero() { + return job.Status.StartTime.Time, nil + } + + return job.CreationTimestamp.Time, nil +} + +func init() { + if err := rayv1.AddToScheme(scheme.Scheme); err != nil { + panic(err) + } + + pluginmachinery.PluginRegistry().RegisterK8sPlugin( + k8s.PluginEntry{ + ID: rayTaskType, + RegisteredTaskTypes: []pluginsCore.TaskType{rayTaskType}, + ResourceToWatch: &rayv1.RayJob{}, + Plugin: rayJobResourceHandler{}, + IsDefault: false, + CustomKubeClient: func(ctx context.Context) (pluginsCore.KubeClient, error) { + remoteConfig := GetConfig().RemoteClusterConfig + if !remoteConfig.Enabled { + // use controller-runtime KubeClient + return nil, nil + } + + kubeConfig, err := k8s.KubeClientConfig(remoteConfig.Endpoint, remoteConfig.Auth) + if err != nil { + return nil, err + } + + return k8s.NewDefaultKubeClient(kubeConfig) + }, + }) +} diff --git a/flyteplugins/go/tasks/plugins/k8s/ray/ray_test.go b/flyteplugins/go/tasks/plugins/k8s/ray/ray_test.go new file mode 100644 index 0000000000..1d63201539 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/ray/ray_test.go @@ -0,0 +1,1640 @@ +package ray + +import ( + "context" + "encoding/json" + "reflect" + "testing" + "time" + + rayv1 "github.com/ray-project/kuberay/ray-operator/apis/ray/v1" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/require" + "google.golang.org/protobuf/types/known/structpb" + "google.golang.org/protobuf/types/known/timestamppb" + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "sigs.k8s.io/controller-runtime/pkg/client/fake" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/logs" + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + pluginIOMocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + k8smocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/tasklog" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" +) + +const ( + testImage = "image://" + serviceAccount = "ray_sa" +) + +var ( + dummyEnvVars = []*core.KeyValuePair{ + {Key: "Env_Var", Value: "Env_Val"}, + } + + testArgs = []string{ + "test-args", + } + + resourceRequirements = &corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("1000m"), + corev1.ResourceMemory: resource.MustParse("1Gi"), + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + Requests: corev1.ResourceList{ + corev1.ResourceCPU: resource.MustParse("100m"), + corev1.ResourceMemory: resource.MustParse("512Mi"), + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + } + + workerGroupName = "worker-group" +) + +func transformRayJobToCustomObj(rayJob *plugins.RayJob) *structpb.Struct { + structObj, err := utils.MarshalObjToStruct(rayJob) + if err != nil { + panic(err) + } + return structObj +} + +func transformPodSpecToTaskTemplateTarget(podSpec *corev1.PodSpec) *core.TaskTemplate_K8SPod { + structObj, err := utils.MarshalObjToStruct(&podSpec) + if err != nil { + panic(err) + } + return &core.TaskTemplate_K8SPod{ + K8SPod: &core.K8SPod{ + PodSpec: structObj, + }, + } +} + +func dummyRayCustomObj() *plugins.RayJob { + return &plugins.RayJob{ + RayCluster: &plugins.RayCluster{ + HeadGroupSpec: &plugins.HeadGroupSpec{RayStartParams: map[string]string{"num-cpus": "1"}}, + WorkerGroupSpec: []*plugins.WorkerGroupSpec{{GroupName: workerGroupName, Replicas: 3, MinReplicas: 3, MaxReplicas: 3}}, + EnableAutoscaling: true, + }, + ShutdownAfterJobFinishes: true, + TtlSecondsAfterFinished: 120, + } +} + +func dummyRayTaskTemplate(id string, rayJob *plugins.RayJob) *core.TaskTemplate { + return &core.TaskTemplate{ + Id: &core.Identifier{Name: id}, + Type: "container", + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Image: testImage, + Args: testArgs, + Env: dummyEnvVars, + }, + }, + Custom: transformRayJobToCustomObj(rayJob), + } +} + +func dummyRayTaskContext(taskTemplate *core.TaskTemplate, resources *corev1.ResourceRequirements, extendedResources *core.ExtendedResources, containerImage, serviceAccount string) pluginsCore.TaskExecutionContext { + taskCtx := &mocks.TaskExecutionContext{} + inputReader := &pluginIOMocks.InputReader{} + inputReader.EXPECT().GetInputPrefixPath().Return("/input/prefix") + inputReader.EXPECT().GetInputPath().Return("/input") + inputReader.EXPECT().Get(mock.Anything).Return(&core.LiteralMap{}, nil) + taskCtx.EXPECT().InputReader().Return(inputReader) + + outputReader := &pluginIOMocks.OutputWriter{} + outputReader.EXPECT().GetOutputPath().Return("/data/outputs.pb") + outputReader.EXPECT().GetOutputPrefixPath().Return("/data/") + outputReader.EXPECT().GetRawOutputPrefix().Return("") + outputReader.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + outputReader.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + taskCtx.EXPECT().OutputWriter().Return(outputReader) + + taskReader := &mocks.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(taskTemplate, nil) + taskCtx.EXPECT().TaskReader().Return(taskReader) + + tID := &mocks.TaskExecutionID{} + tID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my_name", + Project: "my_project", + Domain: "my_domain", + }, + }, + }) + tID.EXPECT().GetGeneratedName().Return("some-acceptable-name") + + overrides := &mocks.TaskOverrides{} + overrides.EXPECT().GetResources().Return(resources) + overrides.EXPECT().GetExtendedResources().Return(extendedResources) + overrides.EXPECT().GetContainerImage().Return(containerImage) + overrides.EXPECT().GetPodTemplate().Return(nil) + + taskExecutionMetadata := &mocks.TaskExecutionMetadata{} + taskExecutionMetadata.EXPECT().GetTaskExecutionID().Return(tID) + taskExecutionMetadata.EXPECT().GetNamespace().Return("test-namespace") + taskExecutionMetadata.EXPECT().GetAnnotations().Return(map[string]string{"annotation-1": "val1"}) + taskExecutionMetadata.EXPECT().GetLabels().Return(map[string]string{"label-1": "val1"}) + taskExecutionMetadata.EXPECT().GetOwnerReference().Return(metav1.OwnerReference{ + Kind: "node", + Name: "blah", + }) + taskExecutionMetadata.EXPECT().IsInterruptible().Return(true) + taskExecutionMetadata.EXPECT().GetOverrides().Return(overrides) + taskExecutionMetadata.EXPECT().GetK8sServiceAccount().Return(serviceAccount) + taskExecutionMetadata.EXPECT().GetPlatformResources().Return(&corev1.ResourceRequirements{}) + taskExecutionMetadata.EXPECT().GetSecurityContext().Return(core.SecurityContext{ + RunAs: &core.Identity{K8SServiceAccount: serviceAccount}, + }) + taskExecutionMetadata.EXPECT().GetEnvironmentVariables().Return(nil) + taskExecutionMetadata.EXPECT().GetConsoleURL().Return("") + taskCtx.EXPECT().TaskExecutionMetadata().Return(taskExecutionMetadata) + return taskCtx +} + +func TestBuildResourceRay(t *testing.T) { + rayJobResourceHandler := rayJobResourceHandler{} + taskTemplate := dummyRayTaskTemplate("ray-id", dummyRayCustomObj()) + toleration := []corev1.Toleration{{ + Key: "storage", + Value: "dedicated", + Operator: corev1.TolerationOpExists, + Effect: corev1.TaintEffectNoSchedule, + }} + err := config.SetK8sPluginConfig(&config.K8sPluginConfig{DefaultTolerations: toleration}) + assert.Nil(t, err) + + rayCtx := dummyRayTaskContext(taskTemplate, resourceRequirements, nil, "", serviceAccount) + RayResource, err := rayJobResourceHandler.BuildResource(context.TODO(), rayCtx) + assert.Nil(t, err) + + assert.NotNil(t, RayResource) + ray, ok := RayResource.(*rayv1.RayJob) + assert.True(t, ok) + + assert.Equal(t, *ray.Spec.RayClusterSpec.EnableInTreeAutoscaling, true) + assert.Equal(t, ray.Spec.ShutdownAfterJobFinishes, true) + assert.Equal(t, ray.Spec.TTLSecondsAfterFinished, int32(120)) + + assert.Equal(t, ray.Spec.RayClusterSpec.HeadGroupSpec.Template.Spec.ServiceAccountName, serviceAccount) + assert.Equal(t, ray.Spec.RayClusterSpec.HeadGroupSpec.RayStartParams, + map[string]string{ + "dashboard-host": "0.0.0.0", "disable-usage-stats": "true", "include-dashboard": "true", + "node-ip-address": "$MY_POD_IP", "num-cpus": "1", + }) + assert.Equal(t, ray.Spec.RayClusterSpec.HeadGroupSpec.Template.Annotations, map[string]string{"annotation-1": "val1"}) + assert.Equal(t, ray.Spec.RayClusterSpec.HeadGroupSpec.Template.Labels, map[string]string{"label-1": "val1"}) + assert.Equal(t, ray.Spec.RayClusterSpec.HeadGroupSpec.Template.Spec.Tolerations, toleration) + + workerReplica := int32(3) + assert.Equal(t, *ray.Spec.RayClusterSpec.WorkerGroupSpecs[0].Replicas, workerReplica) + assert.Equal(t, *ray.Spec.RayClusterSpec.WorkerGroupSpecs[0].MinReplicas, workerReplica) + assert.Equal(t, *ray.Spec.RayClusterSpec.WorkerGroupSpecs[0].MaxReplicas, workerReplica) + assert.Equal(t, ray.Spec.RayClusterSpec.WorkerGroupSpecs[0].GroupName, workerGroupName) + assert.Equal(t, ray.Spec.RayClusterSpec.WorkerGroupSpecs[0].Template.Spec.ServiceAccountName, serviceAccount) + assert.Equal(t, ray.Spec.RayClusterSpec.WorkerGroupSpecs[0].RayStartParams, map[string]string{"disable-usage-stats": "true", "node-ip-address": "$MY_POD_IP"}) + assert.Equal(t, ray.Spec.RayClusterSpec.WorkerGroupSpecs[0].Template.Annotations, map[string]string{"annotation-1": "val1"}) + assert.Equal(t, ray.Spec.RayClusterSpec.WorkerGroupSpecs[0].Template.Labels, map[string]string{"label-1": "val1"}) + assert.Equal(t, ray.Spec.RayClusterSpec.WorkerGroupSpecs[0].Template.Spec.Tolerations, toleration) + + // Make sure the default service account is being used if SA is not provided in the task context + rayCtx = dummyRayTaskContext(taskTemplate, resourceRequirements, nil, "", "") + RayResource, err = rayJobResourceHandler.BuildResource(context.TODO(), rayCtx) + assert.Nil(t, err) + assert.NotNil(t, RayResource) + ray, ok = RayResource.(*rayv1.RayJob) + assert.True(t, ok) + assert.Equal(t, ray.Spec.RayClusterSpec.HeadGroupSpec.Template.Spec.ServiceAccountName, GetConfig().ServiceAccount) +} + +func TestBuildResourceRayContainerImage(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{})) + + fixtures := []struct { + name string + resources *corev1.ResourceRequirements + containerImageOverride string + }{ + { + "without overrides", + &corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + "", + }, + { + "with overrides", + &corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + "container-image-override", + }, + } + + for _, f := range fixtures { + t.Run(f.name, func(t *testing.T) { + taskTemplate := dummyRayTaskTemplate("id", dummyRayCustomObj()) + taskContext := dummyRayTaskContext(taskTemplate, f.resources, nil, f.containerImageOverride, serviceAccount) + rayJobResourceHandler := rayJobResourceHandler{} + r, err := rayJobResourceHandler.BuildResource(context.TODO(), taskContext) + assert.Nil(t, err) + assert.NotNil(t, r) + rayJob, ok := r.(*rayv1.RayJob) + assert.True(t, ok) + + var expectedContainerImage string + if len(f.containerImageOverride) > 0 { + expectedContainerImage = f.containerImageOverride + } else { + expectedContainerImage = testImage + } + + // Head node + headNodeSpec := rayJob.Spec.RayClusterSpec.HeadGroupSpec.Template.Spec + assert.Equal(t, expectedContainerImage, headNodeSpec.Containers[0].Image) + + // Worker node + workerNodeSpec := rayJob.Spec.RayClusterSpec.WorkerGroupSpecs[0].Template.Spec + assert.Equal(t, expectedContainerImage, workerNodeSpec.Containers[0].Image) + }) + } +} + +func TestBuildResourceRayExtendedResources(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{ + GpuDeviceNodeLabel: "gpu-node-label", + GpuPartitionSizeNodeLabel: "gpu-partition-size", + GpuResourceName: flytek8s.ResourceNvidiaGPU, + AddTolerationsForExtendedResources: []string{"nvidia.com/gpu"}, + })) + + params := []struct { + name string + resources *corev1.ResourceRequirements + extendedResourcesBase *core.ExtendedResources + extendedResourcesOverride *core.ExtendedResources + expectedNsr []corev1.NodeSelectorTerm + expectedTol []corev1.Toleration + }{ + { + "without overrides", + &corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-t4", + }, + }, + nil, + []corev1.NodeSelectorTerm{ + { + MatchExpressions: []corev1.NodeSelectorRequirement{ + { + Key: "gpu-node-label", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-t4"}, + }, + }, + }, + }, + []corev1.Toleration{ + { + Key: "gpu-node-label", + Value: "nvidia-tesla-t4", + Operator: corev1.TolerationOpEqual, + Effect: corev1.TaintEffectNoSchedule, + }, + { + Key: "nvidia.com/gpu", + Operator: corev1.TolerationOpExists, + Effect: corev1.TaintEffectNoSchedule, + }, + }, + }, + { + "with overrides", + &corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + flytek8s.ResourceNvidiaGPU: resource.MustParse("1"), + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-t4", + }, + }, + &core.ExtendedResources{ + GpuAccelerator: &core.GPUAccelerator{ + Device: "nvidia-tesla-a100", + PartitionSizeValue: &core.GPUAccelerator_PartitionSize{ + PartitionSize: "1g.5gb", + }, + }, + }, + []corev1.NodeSelectorTerm{ + { + MatchExpressions: []corev1.NodeSelectorRequirement{ + { + Key: "gpu-node-label", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"nvidia-tesla-a100"}, + }, + { + Key: "gpu-partition-size", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"1g.5gb"}, + }, + }, + }, + }, + []corev1.Toleration{ + { + Key: "gpu-node-label", + Value: "nvidia-tesla-a100", + Operator: corev1.TolerationOpEqual, + Effect: corev1.TaintEffectNoSchedule, + }, + { + Key: "gpu-partition-size", + Value: "1g.5gb", + Operator: corev1.TolerationOpEqual, + Effect: corev1.TaintEffectNoSchedule, + }, + { + Key: "nvidia.com/gpu", + Operator: corev1.TolerationOpExists, + Effect: corev1.TaintEffectNoSchedule, + }, + }, + }, + } + + for _, p := range params { + t.Run(p.name, func(t *testing.T) { + taskTemplate := dummyRayTaskTemplate("ray-id", dummyRayCustomObj()) + taskTemplate.ExtendedResources = p.extendedResourcesBase + taskContext := dummyRayTaskContext(taskTemplate, p.resources, p.extendedResourcesOverride, "", serviceAccount) + rayJobResourceHandler := rayJobResourceHandler{} + r, err := rayJobResourceHandler.BuildResource(context.TODO(), taskContext) + assert.Nil(t, err) + assert.NotNil(t, r) + rayJob, ok := r.(*rayv1.RayJob) + assert.True(t, ok) + + // Head node + headNodeSpec := rayJob.Spec.RayClusterSpec.HeadGroupSpec.Template.Spec + assert.EqualValues( + t, + p.expectedNsr, + headNodeSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + p.expectedTol, + headNodeSpec.Tolerations, + ) + + // Worker node + workerNodeSpec := rayJob.Spec.RayClusterSpec.WorkerGroupSpecs[0].Template.Spec + assert.EqualValues( + t, + p.expectedNsr, + workerNodeSpec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms, + ) + assert.EqualValues( + t, + p.expectedTol, + workerNodeSpec.Tolerations, + ) + }) + } +} + +func TestBuildResourceRayCustomK8SPod(t *testing.T) { + assert.NoError(t, config.SetK8sPluginConfig(&config.K8sPluginConfig{})) + + headResourceEntries := []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "10"}, + {Name: core.Resources_MEMORY, Value: "10Gi"}, + {Name: core.Resources_GPU, Value: "10"}, + } + headResources := &core.Resources{Requests: headResourceEntries, Limits: headResourceEntries} + + expectedHeadResources, err := flytek8s.ToK8sResourceRequirements(headResources) + require.NoError(t, err) + // Add nvidia.com/gpu from task resources since mergeCustomPodSpec only replaces resources + expectedHeadResources.Limits[flytek8s.ResourceNvidiaGPU] = resource.MustParse("1") + expectedHeadResources.Requests[flytek8s.ResourceNvidiaGPU] = resource.MustParse("1") + + workerResourceEntries := []*core.Resources_ResourceEntry{ + {Name: core.Resources_CPU, Value: "20"}, + {Name: core.Resources_MEMORY, Value: "20Gi"}, + {Name: core.Resources_GPU, Value: "20"}, + } + workerResources := &core.Resources{Requests: workerResourceEntries, Limits: workerResourceEntries} + + expectedWorkerResources, err := flytek8s.ToK8sResourceRequirements(workerResources) + require.NoError(t, err) + // Add nvidia.com/gpu from task resources since mergeCustomPodSpec only replaces resources + expectedWorkerResources.Limits[flytek8s.ResourceNvidiaGPU] = resource.MustParse("1") + expectedWorkerResources.Requests[flytek8s.ResourceNvidiaGPU] = resource.MustParse("1") + + nvidiaRuntimeClassName := "nvidia-cdi" + + headPodSpecCustomResources := &corev1.PodSpec{ + Containers: []corev1.Container{ + { + Name: "ray-head", + Resources: *expectedHeadResources, + }, + }, + } + workerPodSpecCustomResources := &corev1.PodSpec{ + Containers: []corev1.Container{ + { + Name: "ray-worker", + Resources: *expectedWorkerResources, + }, + }, + } + + headPodSpecCustomRuntimeClass := &corev1.PodSpec{ + RuntimeClassName: &nvidiaRuntimeClassName, + } + workerPodSpecCustomRuntimeClass := &corev1.PodSpec{ + RuntimeClassName: &nvidiaRuntimeClassName, + } + + params := []struct { + name string + taskResources *corev1.ResourceRequirements + headK8SPod *core.K8SPod + workerK8SPod *core.K8SPod + expectedSubmitterResources *corev1.ResourceRequirements + expectedHeadResources *corev1.ResourceRequirements + expectedWorkerResources *corev1.ResourceRequirements + expectedSubmitterRuntimeClassName *string + expectedHeadRuntimeClassName *string + expectedWorkerRuntimeClassName *string + }{ + { + name: "task resources", + taskResources: resourceRequirements, + expectedSubmitterResources: &submitterDefaultResourceRequirements, + expectedHeadResources: resourceRequirements, + expectedWorkerResources: resourceRequirements, + }, + { + name: "custom worker and head resources", + taskResources: resourceRequirements, + headK8SPod: &core.K8SPod{ + PodSpec: transformStructToStructPB(t, headPodSpecCustomResources), + }, + workerK8SPod: &core.K8SPod{ + PodSpec: transformStructToStructPB(t, workerPodSpecCustomResources), + }, + expectedSubmitterResources: &submitterDefaultResourceRequirements, + expectedHeadResources: expectedHeadResources, + expectedWorkerResources: expectedWorkerResources, + }, + { + name: "custom runtime class name", + taskResources: resourceRequirements, + expectedSubmitterResources: &submitterDefaultResourceRequirements, + expectedHeadResources: resourceRequirements, + expectedWorkerResources: resourceRequirements, + headK8SPod: &core.K8SPod{ + PodSpec: transformStructToStructPB(t, headPodSpecCustomRuntimeClass), + }, + workerK8SPod: &core.K8SPod{ + PodSpec: transformStructToStructPB(t, workerPodSpecCustomRuntimeClass), + }, + expectedHeadRuntimeClassName: &nvidiaRuntimeClassName, + expectedWorkerRuntimeClassName: &nvidiaRuntimeClassName, + }, + } + + for _, p := range params { + t.Run(p.name, func(t *testing.T) { + rayJobInput := dummyRayCustomObj() + + if p.headK8SPod != nil { + rayJobInput.RayCluster.HeadGroupSpec.K8SPod = p.headK8SPod + } + + if p.workerK8SPod != nil { + for _, spec := range rayJobInput.RayCluster.WorkerGroupSpec { + spec.K8SPod = p.workerK8SPod + } + } + + taskTemplate := dummyRayTaskTemplate("ray-id", rayJobInput) + taskContext := dummyRayTaskContext(taskTemplate, p.taskResources, nil, "", serviceAccount) + rayJobResourceHandler := rayJobResourceHandler{} + r, err := rayJobResourceHandler.BuildResource(context.TODO(), taskContext) + assert.Nil(t, err) + assert.NotNil(t, r) + rayJob, ok := r.(*rayv1.RayJob) + assert.True(t, ok) + + submitterPodResources := rayJob.Spec.SubmitterPodTemplate.Spec.Containers[0].Resources + assert.EqualValues(t, + p.expectedSubmitterResources, + &submitterPodResources, + ) + + headPodSpec := rayJob.Spec.RayClusterSpec.HeadGroupSpec.Template.Spec + headPodResources := headPodSpec.Containers[0].Resources + assert.EqualValues(t, + p.expectedHeadResources, + &headPodResources, + ) + + assert.EqualValues(t, p.expectedHeadRuntimeClassName, headPodSpec.RuntimeClassName) + + for _, workerGroupSpec := range rayJob.Spec.RayClusterSpec.WorkerGroupSpecs { + workerPodSpec := workerGroupSpec.Template.Spec + workerPodResources := workerPodSpec.Containers[0].Resources + assert.EqualValues(t, + p.expectedWorkerResources, + &workerPodResources, + ) + assert.EqualValues(t, p.expectedWorkerRuntimeClassName, workerPodSpec.RuntimeClassName) + } + }) + } +} + +func TestDefaultStartParameters(t *testing.T) { + rayJobResourceHandler := rayJobResourceHandler{} + rayJob := &plugins.RayJob{ + RayCluster: &plugins.RayCluster{ + HeadGroupSpec: &plugins.HeadGroupSpec{}, + WorkerGroupSpec: []*plugins.WorkerGroupSpec{{GroupName: workerGroupName, Replicas: 3, MinReplicas: 3, MaxReplicas: 3}}, + EnableAutoscaling: true, + }, + ShutdownAfterJobFinishes: true, + TtlSecondsAfterFinished: 120, + } + + taskTemplate := dummyRayTaskTemplate("ray-id", rayJob) + toleration := []corev1.Toleration{{ + Key: "storage", + Value: "dedicated", + Operator: corev1.TolerationOpExists, + Effect: corev1.TaintEffectNoSchedule, + }} + err := config.SetK8sPluginConfig(&config.K8sPluginConfig{DefaultTolerations: toleration}) + assert.Nil(t, err) + + RayResource, err := rayJobResourceHandler.BuildResource(context.TODO(), dummyRayTaskContext(taskTemplate, resourceRequirements, nil, "", serviceAccount)) + assert.Nil(t, err) + + assert.NotNil(t, RayResource) + ray, ok := RayResource.(*rayv1.RayJob) + assert.True(t, ok) + + assert.Equal(t, *ray.Spec.RayClusterSpec.EnableInTreeAutoscaling, true) + assert.Equal(t, ray.Spec.ShutdownAfterJobFinishes, true) + assert.Equal(t, ray.Spec.TTLSecondsAfterFinished, int32(120)) + + assert.Equal(t, ray.Spec.RayClusterSpec.HeadGroupSpec.Template.Spec.ServiceAccountName, serviceAccount) + assert.Equal(t, ray.Spec.RayClusterSpec.HeadGroupSpec.RayStartParams, + map[string]string{ + "dashboard-host": "0.0.0.0", "disable-usage-stats": "true", "include-dashboard": "true", + "node-ip-address": "$MY_POD_IP", + }) + assert.Equal(t, ray.Spec.RayClusterSpec.HeadGroupSpec.Template.Annotations, map[string]string{"annotation-1": "val1"}) + assert.Equal(t, ray.Spec.RayClusterSpec.HeadGroupSpec.Template.Labels, map[string]string{"label-1": "val1"}) + assert.Equal(t, ray.Spec.RayClusterSpec.HeadGroupSpec.Template.Spec.Tolerations, toleration) + + workerReplica := int32(3) + assert.Equal(t, *ray.Spec.RayClusterSpec.WorkerGroupSpecs[0].Replicas, workerReplica) + assert.Equal(t, *ray.Spec.RayClusterSpec.WorkerGroupSpecs[0].MinReplicas, workerReplica) + assert.Equal(t, *ray.Spec.RayClusterSpec.WorkerGroupSpecs[0].MaxReplicas, workerReplica) + assert.Equal(t, ray.Spec.RayClusterSpec.WorkerGroupSpecs[0].GroupName, workerGroupName) + assert.Equal(t, ray.Spec.RayClusterSpec.WorkerGroupSpecs[0].Template.Spec.ServiceAccountName, serviceAccount) + assert.Equal(t, ray.Spec.RayClusterSpec.WorkerGroupSpecs[0].RayStartParams, map[string]string{"disable-usage-stats": "true", "node-ip-address": "$MY_POD_IP"}) + assert.Equal(t, ray.Spec.RayClusterSpec.WorkerGroupSpecs[0].Template.Annotations, map[string]string{"annotation-1": "val1"}) + assert.Equal(t, ray.Spec.RayClusterSpec.WorkerGroupSpecs[0].Template.Labels, map[string]string{"label-1": "val1"}) + assert.Equal(t, ray.Spec.RayClusterSpec.WorkerGroupSpecs[0].Template.Spec.Tolerations, toleration) +} + +func TestInjectLogsSidecar(t *testing.T) { + rayJobObj := transformRayJobToCustomObj(dummyRayCustomObj()) + params := []struct { + name string + taskTemplate core.TaskTemplate + // primaryContainerName string + logsSidecarCfg *corev1.Container + expectedVolumes []corev1.Volume + expectedPrimaryContainerVolumeMounts []corev1.VolumeMount + expectedLogsSidecarVolumeMounts []corev1.VolumeMount + }{ + { + "container target", + core.TaskTemplate{ + Id: &core.Identifier{Name: "ray-id"}, + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Image: testImage, + Args: testArgs, + }, + }, + Custom: rayJobObj, + }, + &corev1.Container{ + Name: "logs-sidecar", + Image: "test-image", + }, + []corev1.Volume{ + { + Name: "system-ray-state", + VolumeSource: corev1.VolumeSource{ + EmptyDir: &corev1.EmptyDirVolumeSource{}, + }, + }, + }, + []corev1.VolumeMount{ + { + Name: "system-ray-state", + MountPath: "/tmp/ray", + }, + }, + []corev1.VolumeMount{ + { + Name: "system-ray-state", + MountPath: "/tmp/ray", + ReadOnly: true, + }, + }, + }, + { + "container target with no sidecar", + core.TaskTemplate{ + Id: &core.Identifier{Name: "ray-id"}, + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Image: testImage, + Args: testArgs, + }, + }, + Custom: rayJobObj, + }, + nil, + nil, + nil, + nil, + }, + { + "pod target", + core.TaskTemplate{ + Id: &core.Identifier{Name: "ray-id"}, + Target: transformPodSpecToTaskTemplateTarget(&corev1.PodSpec{ + Containers: []corev1.Container{ + { + Name: "main", + Image: "primary-image", + }, + }, + }), + Custom: rayJobObj, + Config: map[string]string{ + flytek8s.PrimaryContainerKey: "main", + }, + }, + &corev1.Container{ + Name: "logs-sidecar", + Image: "test-image", + }, + []corev1.Volume{ + { + Name: "system-ray-state", + VolumeSource: corev1.VolumeSource{ + EmptyDir: &corev1.EmptyDirVolumeSource{}, + }, + }, + }, + []corev1.VolumeMount{ + { + Name: "system-ray-state", + MountPath: "/tmp/ray", + }, + }, + []corev1.VolumeMount{ + { + Name: "system-ray-state", + MountPath: "/tmp/ray", + ReadOnly: true, + }, + }, + }, + { + "pod target with existing ray state volume", + core.TaskTemplate{ + Id: &core.Identifier{Name: "ray-id"}, + Target: transformPodSpecToTaskTemplateTarget(&corev1.PodSpec{ + Containers: []corev1.Container{ + { + Name: "main", + Image: "primary-image", + VolumeMounts: []corev1.VolumeMount{ + { + Name: "test-vol", + MountPath: "/tmp/ray", + }, + }, + }, + }, + Volumes: []corev1.Volume{ + { + Name: "test-vol", + VolumeSource: corev1.VolumeSource{ + EmptyDir: &corev1.EmptyDirVolumeSource{}, + }, + }, + }, + }), + Custom: rayJobObj, + Config: map[string]string{ + flytek8s.PrimaryContainerKey: "main", + }, + }, + &corev1.Container{ + Name: "logs-sidecar", + Image: "test-image", + }, + []corev1.Volume{ + { + Name: "test-vol", + VolumeSource: corev1.VolumeSource{ + EmptyDir: &corev1.EmptyDirVolumeSource{}, + }, + }, + }, + []corev1.VolumeMount{ + { + Name: "test-vol", + MountPath: "/tmp/ray", + }, + }, + []corev1.VolumeMount{ + { + Name: "test-vol", + MountPath: "/tmp/ray", + ReadOnly: true, + }, + }, + }, + } + + for i := range params { + p := params[i] + t.Run(p.name, func(t *testing.T) { + assert.NoError(t, SetConfig(&Config{ + LogsSidecar: p.logsSidecarCfg, + })) + taskContext := dummyRayTaskContext(&p.taskTemplate, resourceRequirements, nil, "", serviceAccount) + rayJobResourceHandler := rayJobResourceHandler{} + r, err := rayJobResourceHandler.BuildResource(context.TODO(), taskContext) + assert.Nil(t, err) + assert.NotNil(t, r) + rayJob, ok := r.(*rayv1.RayJob) + assert.True(t, ok) + + headPodSpec := rayJob.Spec.RayClusterSpec.HeadGroupSpec.Template.Spec + + // Check volumes + assert.EqualValues(t, p.expectedVolumes, headPodSpec.Volumes) + + // Check containers and respective volume mounts + foundPrimaryContainer := false + foundLogsSidecar := false + for _, cnt := range headPodSpec.Containers { + if cnt.Name == RayHeadContainerName { + foundPrimaryContainer = true + assert.EqualValues( + t, + p.expectedPrimaryContainerVolumeMounts, + cnt.VolumeMounts, + ) + } + if p.logsSidecarCfg != nil && cnt.Name == p.logsSidecarCfg.Name { + foundLogsSidecar = true + assert.EqualValues( + t, + p.expectedLogsSidecarVolumeMounts, + cnt.VolumeMounts, + ) + } + } + assert.Equal(t, true, foundPrimaryContainer) + assert.Equal(t, p.logsSidecarCfg != nil, foundLogsSidecar) + }) + } +} + +func newPluginContext(pluginState k8s.PluginState) *k8smocks.PluginContext { + plg := &k8smocks.PluginContext{} + + taskExecID := &mocks.TaskExecutionID{} + taskExecID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + TaskId: &core.Identifier{ + ResourceType: core.ResourceType_TASK, + Name: "my-task-name", + Project: "my-task-project", + Domain: "my-task-domain", + Version: "1", + }, + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my-execution-name", + Project: "my-execution-project", + Domain: "my-execution-domain", + }, + }, + RetryAttempt: 1, + }) + taskExecID.EXPECT().GetUniqueNodeID().Return("unique-node") + taskExecID.EXPECT().GetGeneratedName().Return("generated-name") + + tskCtx := &mocks.TaskExecutionMetadata{} + tskCtx.EXPECT().GetTaskExecutionID().Return(taskExecID) + plg.EXPECT().TaskExecutionMetadata().Return(tskCtx) + + pluginStateReaderMock := mocks.PluginStateReader{} + pluginStateReaderMock.EXPECT().Get(mock.AnythingOfType(reflect.TypeOf(&pluginState).String())).RunAndReturn( + func(v interface{}) (uint8, error) { + *(v.(*k8s.PluginState)) = pluginState + return 0, nil + }) + + plg.EXPECT().PluginStateReader().Return(&pluginStateReaderMock) + + return plg +} + +func init() { + f := defaultConfig + f.Logs = logs.LogConfig{ + IsKubernetesEnabled: true, + } + + if err := SetConfig(&f); err != nil { + panic(err) + } +} + +func TestGetTaskPhase(t *testing.T) { + ctx := context.Background() + rayJobResourceHandler := rayJobResourceHandler{} + pluginCtx := rayPluginContext(k8s.PluginState{}) + + testCases := []struct { + rayJobPhase rayv1.JobDeploymentStatus + expectedCorePhase pluginsCore.Phase + expectedError bool + }{ + {rayv1.JobDeploymentStatusInitializing, pluginsCore.PhaseInitializing, false}, + {rayv1.JobDeploymentStatusRunning, pluginsCore.PhaseRunning, false}, + {rayv1.JobDeploymentStatusComplete, pluginsCore.PhaseSuccess, false}, + {rayv1.JobDeploymentStatusFailed, pluginsCore.PhasePermanentFailure, false}, + {rayv1.JobDeploymentStatusSuspended, pluginsCore.PhaseQueued, false}, + {rayv1.JobDeploymentStatusSuspending, pluginsCore.PhaseQueued, false}, + } + + startTime := time.Date(2024, 0, 0, 0, 0, 0, 0, time.UTC) + endTime := startTime.Add(time.Hour) + podName, contName, initCont := "ray-clust-ray-head", "ray-head", "init" + logCtx := &core.LogContext{ + PrimaryPodName: podName, + Pods: []*core.PodLogContext{ + { + Namespace: "ns", + PodName: podName, + PrimaryContainerName: contName, + Containers: []*core.ContainerContext{ + { + ContainerName: contName, + Process: &core.ContainerContext_ProcessContext{ + ContainerStartTime: timestamppb.New(startTime), + ContainerEndTime: timestamppb.New(endTime), + }, + }, + }, + InitContainers: []*core.ContainerContext{ + { + ContainerName: initCont, + Process: &core.ContainerContext_ProcessContext{ + ContainerStartTime: timestamppb.New(startTime), + ContainerEndTime: timestamppb.New(endTime), + }, + }, + }, + }, + }, + } + for _, tc := range testCases { + t.Run("TestGetTaskPhase_"+string(tc.rayJobPhase), func(t *testing.T) { + startTime := metav1.NewTime(time.Now()) + rayObject := &rayv1.RayJob{ + Spec: rayv1.RayJobSpec{ + RayClusterSpec: &rayv1.RayClusterSpec{ + HeadGroupSpec: rayv1.HeadGroupSpec{ + Template: corev1.PodTemplateSpec{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + { + Name: "ray-head", + Image: "rayproject/ray:latest", + Env: []corev1.EnvVar{}, + }, + }, + }, + }, + }, + }, + }, + Status: rayv1.RayJobStatus{ + JobDeploymentStatus: tc.rayJobPhase, + RayClusterName: "ray-clust", + StartTime: &startTime, + }, + } + phaseInfo, err := rayJobResourceHandler.GetTaskPhase(ctx, pluginCtx, rayObject) + if tc.expectedError { + assert.Error(t, err) + } else { + assert.NoError(t, err) + assert.Equal(t, tc.expectedCorePhase.String(), phaseInfo.Phase().String()) + assert.Equal(t, logCtx, phaseInfo.Info().LogContext) + } + }) + } +} + +func TestGetTaskPhaseIncreasePhaseVersion(t *testing.T) { + rayJobResourceHandler := rayJobResourceHandler{} + + ctx := context.TODO() + + pluginState := k8s.PluginState{ + Phase: pluginsCore.PhaseInitializing, + PhaseVersion: pluginsCore.DefaultPhaseVersion, + Reason: "task submitted to K8s", + } + pluginCtx := rayPluginContext(pluginState) + + rayObject := &rayv1.RayJob{} + rayObject.Status.JobDeploymentStatus = rayv1.JobDeploymentStatusInitializing + phaseInfo, err := rayJobResourceHandler.GetTaskPhase(ctx, pluginCtx, rayObject) + + assert.NoError(t, err) + assert.Equal(t, phaseInfo.Version(), pluginsCore.DefaultPhaseVersion+1) +} + +func TestGetEventInfo_LogTemplates(t *testing.T) { + pluginCtx := rayPluginContext(k8s.PluginState{}) + testCases := []struct { + name string + rayJob rayv1.RayJob + logPlugin tasklog.TemplateLogPlugin + expectedTaskLogs []*core.TaskLog + }{ + { + name: "namespace", + rayJob: rayv1.RayJob{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: "test-namespace", + }, + }, + logPlugin: tasklog.TemplateLogPlugin{ + DisplayName: "namespace", + TemplateURIs: []tasklog.TemplateURI{"http://test/{{ .namespace }}"}, + }, + expectedTaskLogs: []*core.TaskLog{ + { + Name: "namespace", + Uri: "http://test/test-namespace", + Ready: true, + }, + }, + }, + { + name: "task execution ID", + rayJob: rayv1.RayJob{}, + logPlugin: tasklog.TemplateLogPlugin{ + DisplayName: "taskExecID", + TemplateURIs: []tasklog.TemplateURI{ + "http://test/projects/{{ .executionProject }}/domains/{{ .executionDomain }}/executions/{{ .executionName }}/nodeId/{{ .nodeID }}/taskId/{{ .taskID }}/attempt/{{ .taskRetryAttempt }}", + }, + }, + expectedTaskLogs: []*core.TaskLog{ + { + Name: "taskExecID", + Uri: "http://test/projects/my-execution-project/domains/my-execution-domain/executions/my-execution-name/nodeId/unique-node/taskId/my-task-name/attempt/1", + Ready: true, + }, + }, + }, + { + name: "ray cluster name", + rayJob: rayv1.RayJob{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: "test-namespace", + }, + Status: rayv1.RayJobStatus{ + RayClusterName: "ray-cluster", + }, + }, + logPlugin: tasklog.TemplateLogPlugin{ + DisplayName: "ray cluster name", + TemplateURIs: []tasklog.TemplateURI{"http://test/{{ .namespace }}/{{ .rayClusterName }}"}, + }, + expectedTaskLogs: []*core.TaskLog{ + { + Name: "ray cluster name", + Uri: "http://test/test-namespace/ray-cluster", + Ready: true, + }, + }, + }, + { + name: "ray job ID", + rayJob: rayv1.RayJob{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: "test-namespace", + }, + Status: rayv1.RayJobStatus{ + JobId: "ray-job-1", + }, + }, + logPlugin: tasklog.TemplateLogPlugin{ + DisplayName: "ray job ID", + TemplateURIs: []tasklog.TemplateURI{"http://test/{{ .namespace }}/{{ .rayJobID }}"}, + }, + expectedTaskLogs: []*core.TaskLog{ + { + Name: "ray job ID", + Uri: "http://test/test-namespace/ray-job-1", + Ready: true, + }, + }, + }, + } + + for i := range testCases { + tc := testCases[i] + t.Run(tc.name, func(t *testing.T) { + ti, err := getEventInfoForRayJob( + context.TODO(), + logs.LogConfig{Templates: []tasklog.TemplateLogPlugin{tc.logPlugin}}, + pluginCtx, + &tc.rayJob, + ) + assert.NoError(t, err) + assert.Equal(t, tc.expectedTaskLogs, ti.Logs) + }) + } +} + +func TestGetEventInfo_LogTemplates_V1(t *testing.T) { + pluginCtx := rayPluginContext(k8s.PluginState{}) + testCases := []struct { + name string + rayJob rayv1.RayJob + logPlugin tasklog.TemplateLogPlugin + expectedTaskLogs []*core.TaskLog + }{ + { + name: "namespace", + rayJob: rayv1.RayJob{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: "test-namespace", + }, + }, + logPlugin: tasklog.TemplateLogPlugin{ + DisplayName: "namespace", + TemplateURIs: []tasklog.TemplateURI{"http://test/{{ .namespace }}"}, + }, + expectedTaskLogs: []*core.TaskLog{ + { + Name: "namespace", + Uri: "http://test/test-namespace", + Ready: true, + }, + }, + }, + { + name: "task execution ID", + rayJob: rayv1.RayJob{}, + logPlugin: tasklog.TemplateLogPlugin{ + DisplayName: "taskExecID", + TemplateURIs: []tasklog.TemplateURI{ + "http://test/projects/{{ .executionProject }}/domains/{{ .executionDomain }}/executions/{{ .executionName }}/nodeId/{{ .nodeID }}/taskId/{{ .taskID }}/attempt/{{ .taskRetryAttempt }}", + }, + }, + expectedTaskLogs: []*core.TaskLog{ + { + Name: "taskExecID", + Uri: "http://test/projects/my-execution-project/domains/my-execution-domain/executions/my-execution-name/nodeId/unique-node/taskId/my-task-name/attempt/1", + Ready: true, + }, + }, + }, + { + name: "ray cluster name", + rayJob: rayv1.RayJob{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: "test-namespace", + }, + Status: rayv1.RayJobStatus{ + RayClusterName: "ray-cluster", + }, + }, + logPlugin: tasklog.TemplateLogPlugin{ + DisplayName: "ray cluster name", + TemplateURIs: []tasklog.TemplateURI{"http://test/{{ .namespace }}/{{ .rayClusterName }}"}, + }, + expectedTaskLogs: []*core.TaskLog{ + { + Name: "ray cluster name", + Uri: "http://test/test-namespace/ray-cluster", + Ready: true, + }, + }, + }, + { + name: "ray job ID", + rayJob: rayv1.RayJob{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: "test-namespace", + }, + Status: rayv1.RayJobStatus{ + JobId: "ray-job-1", + }, + }, + logPlugin: tasklog.TemplateLogPlugin{ + DisplayName: "ray job ID", + TemplateURIs: []tasklog.TemplateURI{"http://test/{{ .namespace }}/{{ .rayJobID }}"}, + }, + expectedTaskLogs: []*core.TaskLog{ + { + Name: "ray job ID", + Uri: "http://test/test-namespace/ray-job-1", + Ready: true, + }, + }, + }, + } + + for i := range testCases { + tc := testCases[i] + t.Run(tc.name, func(t *testing.T) { + ti, err := getEventInfoForRayJob( + context.TODO(), + logs.LogConfig{Templates: []tasklog.TemplateLogPlugin{tc.logPlugin}}, + pluginCtx, + &tc.rayJob, + ) + assert.NoError(t, err) + assert.Equal(t, tc.expectedTaskLogs, ti.Logs) + }) + } +} + +func TestGetEventInfo_DashboardURL(t *testing.T) { + pluginCtx := rayPluginContext(k8s.PluginState{}) + testCases := []struct { + name string + rayJob rayv1.RayJob + dashboardURLTemplate tasklog.TemplateLogPlugin + expectedTaskLogs []*core.TaskLog + }{ + { + name: "dashboard URL displayed", + rayJob: rayv1.RayJob{ + Status: rayv1.RayJobStatus{ + DashboardURL: "exists", + JobStatus: rayv1.JobStatusRunning, + }, + }, + dashboardURLTemplate: tasklog.TemplateLogPlugin{ + DisplayName: "Ray Dashboard", + TemplateURIs: []tasklog.TemplateURI{"http://test/{{.generatedName}}"}, + }, + expectedTaskLogs: []*core.TaskLog{ + { + Name: "Ray Dashboard", + Uri: "http://test/generated-name", + LinkType: core.TaskLog_DASHBOARD, + Ready: true, + }, + }, + }, + { + name: "dashboard URL is not displayed", + rayJob: rayv1.RayJob{ + Status: rayv1.RayJobStatus{ + JobStatus: rayv1.JobStatusPending, + }, + }, + dashboardURLTemplate: tasklog.TemplateLogPlugin{ + DisplayName: "dummy", + TemplateURIs: []tasklog.TemplateURI{"http://dummy"}, + }, + expectedTaskLogs: nil, + }, + } + + for i := range testCases { + tc := testCases[i] + t.Run(tc.name, func(t *testing.T) { + assert.NoError(t, SetConfig(&Config{DashboardURLTemplate: &tc.dashboardURLTemplate})) + ti, err := getEventInfoForRayJob(context.TODO(), logs.LogConfig{}, pluginCtx, &tc.rayJob) + assert.NoError(t, err) + assert.Equal(t, tc.expectedTaskLogs, ti.Logs) + }) + } +} + +func TestGetEventInfo_DashboardURL_V1(t *testing.T) { + pluginCtx := rayPluginContext(k8s.PluginState{}) + testCases := []struct { + name string + rayJob rayv1.RayJob + dashboardURLTemplate tasklog.TemplateLogPlugin + expectedTaskLogs []*core.TaskLog + }{ + { + name: "dashboard URL displayed", + rayJob: rayv1.RayJob{ + Status: rayv1.RayJobStatus{ + DashboardURL: "exists", + JobStatus: rayv1.JobStatusRunning, + }, + }, + dashboardURLTemplate: tasklog.TemplateLogPlugin{ + DisplayName: "Ray Dashboard", + TemplateURIs: []tasklog.TemplateURI{"http://test/{{.generatedName}}"}, + }, + expectedTaskLogs: []*core.TaskLog{ + { + Name: "Ray Dashboard", + Uri: "http://test/generated-name", + LinkType: core.TaskLog_DASHBOARD, + Ready: true, + }, + }, + }, + { + name: "dashboard URL is not displayed", + rayJob: rayv1.RayJob{ + Status: rayv1.RayJobStatus{ + JobStatus: rayv1.JobStatusPending, + }, + }, + dashboardURLTemplate: tasklog.TemplateLogPlugin{ + DisplayName: "dummy", + TemplateURIs: []tasklog.TemplateURI{"http://dummy"}, + }, + expectedTaskLogs: nil, + }, + } + + for i := range testCases { + tc := testCases[i] + t.Run(tc.name, func(t *testing.T) { + assert.NoError(t, SetConfig(&Config{DashboardURLTemplate: &tc.dashboardURLTemplate})) + ti, err := getEventInfoForRayJob(context.TODO(), logs.LogConfig{}, pluginCtx, &tc.rayJob) + assert.NoError(t, err) + assert.Equal(t, tc.expectedTaskLogs, ti.Logs) + }) + } +} + +func TestGetPropertiesRay(t *testing.T) { + rayJobResourceHandler := rayJobResourceHandler{} + maxLength := 47 + expected := k8s.PluginProperties{GeneratedNameMaxLength: &maxLength} + assert.Equal(t, expected, rayJobResourceHandler.GetProperties()) +} + +func rayPluginContext(pluginState k8s.PluginState) *k8smocks.PluginContext { + pluginCtx := newPluginContext(pluginState) + startTime := time.Date(2024, 0, 0, 0, 0, 0, 0, time.UTC) + endTime := startTime.Add(time.Hour) + podName, contName, initCont := "ray-clust-ray-head", "ray-head", "init" + podList := []runtime.Object{ + &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{Namespace: "ns", Name: "initializing ignored pod"}, + Status: corev1.PodStatus{Phase: corev1.PodPending}, + }, + &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{Namespace: "ns", Name: podName}, + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + {Name: contName}, + }, + }, + Status: corev1.PodStatus{ + Phase: corev1.PodRunning, + ContainerStatuses: []corev1.ContainerStatus{ + { + Name: contName, + State: corev1.ContainerState{ + Terminated: &corev1.ContainerStateTerminated{ + StartedAt: metav1.Time{Time: startTime}, + FinishedAt: metav1.Time{Time: endTime}, + }, + }, + }, + }, + InitContainerStatuses: []corev1.ContainerStatus{ + { + Name: initCont, + State: corev1.ContainerState{ + Terminated: &corev1.ContainerStateTerminated{ + StartedAt: metav1.Time{Time: startTime}, + FinishedAt: metav1.Time{Time: endTime}, + }, + }, + }, + }, + }, + }, + } + reader := fake.NewFakeClient(podList...) + pluginCtx.EXPECT().K8sReader().Return(reader) + return pluginCtx +} + +func transformStructToStructPB(t *testing.T, obj interface{}) *structpb.Struct { + data, err := json.Marshal(obj) + assert.Nil(t, err) + podSpecMap := make(map[string]interface{}) + err = json.Unmarshal(data, &podSpecMap) + assert.Nil(t, err) + s, err := structpb.NewStruct(podSpecMap) + assert.Nil(t, err) + return s +} + +func rayPluginContextWithPods(pluginState k8s.PluginState, pods ...runtime.Object) *k8smocks.PluginContext { + pluginCtx := newPluginContext(pluginState) + reader := fake.NewFakeClient(pods...) + pluginCtx.EXPECT().K8sReader().Return(reader) + return pluginCtx +} + +func TestGetTaskPhaseWithFailedPod(t *testing.T) { + rayJobResourceHandler := rayJobResourceHandler{} + ctx := context.Background() + + rayJobName := "test-rayjob" + rayClusterName := "test-raycluster" + // Create a failed head pod - name must match pattern used in GetTaskPhase: {RayClusterName}-head + pod := &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: rayClusterName + "-head", + Namespace: "ns", + }, + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + { + Name: RayHeadContainerName, + }, + }, + }, + Status: corev1.PodStatus{ + Phase: corev1.PodFailed, + ContainerStatuses: []corev1.ContainerStatus{ + { + Name: RayHeadContainerName, + State: corev1.ContainerState{ + Terminated: &corev1.ContainerStateTerminated{ + ExitCode: 1, + Reason: "Error", + Message: "Container failed", + }, + }, + }, + }, + }, + } + + pluginCtx := rayPluginContextWithPods(k8s.PluginState{}, pod) + + startTime := metav1.NewTime(time.Now()) + rayObject := &rayv1.RayJob{ + ObjectMeta: metav1.ObjectMeta{ + Name: rayJobName, + Namespace: "ns", + }, + Spec: rayv1.RayJobSpec{ + RayClusterSpec: &rayv1.RayClusterSpec{ + HeadGroupSpec: rayv1.HeadGroupSpec{ + Template: corev1.PodTemplateSpec{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + { + Name: RayHeadContainerName, + Image: "rayproject/ray:latest", + Env: []corev1.EnvVar{}, + }, + }, + }, + }, + }, + }, + }, + Status: rayv1.RayJobStatus{ + JobDeploymentStatus: rayv1.JobDeploymentStatusRunning, + RayClusterName: rayClusterName, + StartTime: &startTime, + }, + } + + // Even though RayJob status is running, should return failure due to pod status + phaseInfo, err := rayJobResourceHandler.GetTaskPhase(ctx, pluginCtx, rayObject) + assert.NoError(t, err) + assert.True(t, phaseInfo.Phase().IsFailure()) +} + +func TestGetTaskPhaseContainerNameConstant(t *testing.T) { + rayJobResourceHandler := rayJobResourceHandler{} + ctx := context.Background() + pluginCtx := rayPluginContext(k8s.PluginState{}) + + startTime := metav1.NewTime(time.Now()) + rayObject := &rayv1.RayJob{ + Spec: rayv1.RayJobSpec{ + RayClusterSpec: &rayv1.RayClusterSpec{ + HeadGroupSpec: rayv1.HeadGroupSpec{ + Template: corev1.PodTemplateSpec{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + { + Name: RayHeadContainerName, + Image: "rayproject/ray:latest", + Env: []corev1.EnvVar{}, + }, + }, + }, + }, + }, + }, + }, + Status: rayv1.RayJobStatus{ + JobDeploymentStatus: rayv1.JobDeploymentStatusComplete, + RayClusterName: "ray-clust", + StartTime: &startTime, + }, + } + + phaseInfo, err := rayJobResourceHandler.GetTaskPhase(ctx, pluginCtx, rayObject) + assert.NoError(t, err) + assert.NotNil(t, phaseInfo.Info()) + assert.NotNil(t, phaseInfo.Info().LogContext) + + // Verify the constant is used for head container names + assert.Equal(t, 1, len(phaseInfo.Info().LogContext.Pods)) + headPodLogContext := phaseInfo.Info().LogContext.Pods[0] + assert.Equal(t, RayHeadContainerName, headPodLogContext.PrimaryContainerName) + assert.Equal(t, 1, len(headPodLogContext.Containers)) + assert.Equal(t, RayHeadContainerName, headPodLogContext.Containers[0].ContainerName) +} + +func TestIsTerminal(t *testing.T) { + rayJobResourceHandler := rayJobResourceHandler{} + ctx := context.Background() + + tests := []struct { + name string + status rayv1.JobDeploymentStatus + expectedResult bool + }{ + {"Complete", rayv1.JobDeploymentStatusComplete, true}, + {"Failed", rayv1.JobDeploymentStatusFailed, true}, + {"Running", rayv1.JobDeploymentStatusRunning, false}, + {"Initializing", rayv1.JobDeploymentStatusInitializing, false}, + {"Suspended", rayv1.JobDeploymentStatusSuspended, false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + job := &rayv1.RayJob{ + Status: rayv1.RayJobStatus{ + JobDeploymentStatus: tt.status, + }, + } + result, err := rayJobResourceHandler.IsTerminal(ctx, job) + assert.NoError(t, err) + assert.Equal(t, tt.expectedResult, result) + }) + } +} + +func TestIsTerminal_WrongResourceType(t *testing.T) { + rayJobResourceHandler := rayJobResourceHandler{} + ctx := context.Background() + + wrongResource := &corev1.ConfigMap{} + result, err := rayJobResourceHandler.IsTerminal(ctx, wrongResource) + assert.Error(t, err) + assert.False(t, result) + assert.Contains(t, err.Error(), "unexpected resource type") +} + +func TestGetCompletionTime(t *testing.T) { + rayJobResourceHandler := rayJobResourceHandler{} + + now := time.Now().Truncate(time.Second) + earlier := now.Add(-1 * time.Hour) + evenEarlier := now.Add(-2 * time.Hour) + + tests := []struct { + name string + job *rayv1.RayJob + expectedTime time.Time + }{ + { + name: "uses EndTime", + job: &rayv1.RayJob{ + ObjectMeta: metav1.ObjectMeta{ + CreationTimestamp: metav1.NewTime(evenEarlier), + }, + Status: rayv1.RayJobStatus{ + EndTime: &metav1.Time{Time: now}, + StartTime: &metav1.Time{Time: earlier}, + }, + }, + expectedTime: now, + }, + { + name: "falls back to StartTime", + job: &rayv1.RayJob{ + ObjectMeta: metav1.ObjectMeta{ + CreationTimestamp: metav1.NewTime(evenEarlier), + }, + Status: rayv1.RayJobStatus{ + StartTime: &metav1.Time{Time: now}, + }, + }, + expectedTime: now, + }, + { + name: "falls back to CreationTimestamp", + job: &rayv1.RayJob{ + ObjectMeta: metav1.ObjectMeta{ + CreationTimestamp: metav1.NewTime(now), + }, + Status: rayv1.RayJobStatus{}, + }, + expectedTime: now, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result, err := rayJobResourceHandler.GetCompletionTime(tt.job) + assert.NoError(t, err) + assert.Equal(t, tt.expectedTime.Unix(), result.Unix()) + }) + } +} + +func TestGetCompletionTime_WrongResourceType(t *testing.T) { + rayJobResourceHandler := rayJobResourceHandler{} + + wrongResource := &corev1.ConfigMap{} + result, err := rayJobResourceHandler.GetCompletionTime(wrongResource) + assert.Error(t, err) + assert.True(t, result.IsZero()) + assert.Contains(t, err.Error(), "unexpected resource type") +} diff --git a/flyteplugins/go/tasks/plugins/k8s/ray/testdata/config.yaml b/flyteplugins/go/tasks/plugins/k8s/ray/testdata/config.yaml new file mode 100644 index 0000000000..cc5ddb5c33 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/ray/testdata/config.yaml @@ -0,0 +1,7 @@ +plugins: + ray: + remoteClusterConfig: + endpoint: 127.0.0.1 + auth: + tokenPath: /path/token + caCertPath: /path/cert \ No newline at end of file diff --git a/flyteplugins/go/tasks/plugins/k8s/spark/config.go b/flyteplugins/go/tasks/plugins/k8s/spark/config.go new file mode 100644 index 0000000000..65525fff21 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/spark/config.go @@ -0,0 +1,51 @@ +package spark + +import ( + pluginsConfig "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/logs" +) + +//go:generate pflags Config --default-var=defaultConfig + +var ( + defaultConfig = &Config{ + LogConfig: LogConfig{ + Mixed: logs.LogConfig{ + IsKubernetesEnabled: true, + KubernetesTemplateURI: "http://localhost:30082/#!/log/{{ .namespace }}/{{ .podName }}/pod?namespace={{ .namespace }}", + }, + }, + } + + sparkConfigSection = pluginsConfig.MustRegisterSubSection("spark", defaultConfig) +) + +// Spark-specific configs +type Config struct { + DefaultSparkConfig map[string]string `json:"spark-config-default" pflag:"-,Key value pairs of default spark configuration that should be applied to every SparkJob"` + SparkHistoryServerURL string `json:"spark-history-server-url" pflag:",URL for SparkHistory Server that each job will publish the execution history to."` + Features []Feature `json:"features" pflag:"-,List of optional features supported."` + LogConfig LogConfig `json:"logs" pflag:",Config for log links for spark applications."` +} + +type LogConfig struct { + Mixed logs.LogConfig `json:"mixed" pflag:",Defines the log config that's not split into user/system."` + User logs.LogConfig `json:"user" pflag:",Defines the log config for user logs."` + System logs.LogConfig `json:"system" pflag:",Defines the log config for system logs."` + AllUser logs.LogConfig `json:"all-user" pflag:",All user logs across driver and executors."` +} + +// Optional feature with name and corresponding spark-config to use. +type Feature struct { + Name string `json:"name"` + SparkConfig map[string]string `json:"spark-config"` +} + +func GetSparkConfig() *Config { + return sparkConfigSection.GetConfig().(*Config) +} + +// This method should be used for unit testing only +func setSparkConfig(cfg *Config) error { + return sparkConfigSection.SetConfig(cfg) +} diff --git a/flyteplugins/go/tasks/plugins/k8s/spark/config_flags.go b/flyteplugins/go/tasks/plugins/k8s/spark/config_flags.go new file mode 100755 index 0000000000..d5d6945f71 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/spark/config_flags.go @@ -0,0 +1,99 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package spark + +import ( + "encoding/json" + "reflect" + + "fmt" + + "github.com/spf13/pflag" +) + +// If v is a pointer, it will get its element value or the zero value of the element type. +// If v is not a pointer, it will return it as is. +func (Config) elemValueOrNil(v interface{}) interface{} { + if t := reflect.TypeOf(v); t.Kind() == reflect.Ptr { + if reflect.ValueOf(v).IsNil() { + return reflect.Zero(t.Elem()).Interface() + } else { + return reflect.ValueOf(v).Interface() + } + } else if v == nil { + return reflect.Zero(t).Interface() + } + + return v +} + +func (Config) mustJsonMarshal(v interface{}) string { + raw, err := json.Marshal(v) + if err != nil { + panic(err) + } + + return string(raw) +} + +func (Config) mustMarshalJSON(v json.Marshaler) string { + raw, err := v.MarshalJSON() + if err != nil { + panic(err) + } + + return string(raw) +} + +// GetPFlagSet will return strongly types pflags for all fields in Config and its nested types. The format of the +// flags is json-name.json-sub-name... etc. +func (cfg Config) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("Config", pflag.ExitOnError) + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "spark-history-server-url"), defaultConfig.SparkHistoryServerURL, "URL for SparkHistory Server that each job will publish the execution history to.") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "logs.mixed.cloudwatch-enabled"), defaultConfig.LogConfig.Mixed.IsCloudwatchEnabled, "Enable Cloudwatch Logging") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.mixed.cloudwatch-region"), defaultConfig.LogConfig.Mixed.CloudwatchRegion, "AWS region in which Cloudwatch logs are stored.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.mixed.cloudwatch-log-group"), defaultConfig.LogConfig.Mixed.CloudwatchLogGroup, "Log group to which streams are associated.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.mixed.cloudwatch-template-uri"), defaultConfig.LogConfig.Mixed.CloudwatchTemplateURI, "Template Uri to use when building cloudwatch log links") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "logs.mixed.kubernetes-enabled"), defaultConfig.LogConfig.Mixed.IsKubernetesEnabled, "Enable Kubernetes Logging") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.mixed.kubernetes-url"), defaultConfig.LogConfig.Mixed.KubernetesURL, "Console URL for Kubernetes logs") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.mixed.kubernetes-template-uri"), defaultConfig.LogConfig.Mixed.KubernetesTemplateURI, "Template Uri to use when building kubernetes log links") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "logs.mixed.stackdriver-enabled"), defaultConfig.LogConfig.Mixed.IsStackDriverEnabled, "Enable Log-links to stackdriver") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.mixed.gcp-project"), defaultConfig.LogConfig.Mixed.GCPProjectName, "Name of the project in GCP") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.mixed.stackdriver-logresourcename"), defaultConfig.LogConfig.Mixed.StackdriverLogResourceName, "Name of the logresource in stackdriver") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.mixed.stackdriver-template-uri"), defaultConfig.LogConfig.Mixed.StackDriverTemplateURI, "Template Uri to use when building stackdriver log links") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "logs.user.cloudwatch-enabled"), defaultConfig.LogConfig.User.IsCloudwatchEnabled, "Enable Cloudwatch Logging") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.user.cloudwatch-region"), defaultConfig.LogConfig.User.CloudwatchRegion, "AWS region in which Cloudwatch logs are stored.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.user.cloudwatch-log-group"), defaultConfig.LogConfig.User.CloudwatchLogGroup, "Log group to which streams are associated.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.user.cloudwatch-template-uri"), defaultConfig.LogConfig.User.CloudwatchTemplateURI, "Template Uri to use when building cloudwatch log links") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "logs.user.kubernetes-enabled"), defaultConfig.LogConfig.User.IsKubernetesEnabled, "Enable Kubernetes Logging") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.user.kubernetes-url"), defaultConfig.LogConfig.User.KubernetesURL, "Console URL for Kubernetes logs") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.user.kubernetes-template-uri"), defaultConfig.LogConfig.User.KubernetesTemplateURI, "Template Uri to use when building kubernetes log links") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "logs.user.stackdriver-enabled"), defaultConfig.LogConfig.User.IsStackDriverEnabled, "Enable Log-links to stackdriver") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.user.gcp-project"), defaultConfig.LogConfig.User.GCPProjectName, "Name of the project in GCP") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.user.stackdriver-logresourcename"), defaultConfig.LogConfig.User.StackdriverLogResourceName, "Name of the logresource in stackdriver") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.user.stackdriver-template-uri"), defaultConfig.LogConfig.User.StackDriverTemplateURI, "Template Uri to use when building stackdriver log links") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "logs.system.cloudwatch-enabled"), defaultConfig.LogConfig.System.IsCloudwatchEnabled, "Enable Cloudwatch Logging") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.system.cloudwatch-region"), defaultConfig.LogConfig.System.CloudwatchRegion, "AWS region in which Cloudwatch logs are stored.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.system.cloudwatch-log-group"), defaultConfig.LogConfig.System.CloudwatchLogGroup, "Log group to which streams are associated.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.system.cloudwatch-template-uri"), defaultConfig.LogConfig.System.CloudwatchTemplateURI, "Template Uri to use when building cloudwatch log links") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "logs.system.kubernetes-enabled"), defaultConfig.LogConfig.System.IsKubernetesEnabled, "Enable Kubernetes Logging") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.system.kubernetes-url"), defaultConfig.LogConfig.System.KubernetesURL, "Console URL for Kubernetes logs") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.system.kubernetes-template-uri"), defaultConfig.LogConfig.System.KubernetesTemplateURI, "Template Uri to use when building kubernetes log links") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "logs.system.stackdriver-enabled"), defaultConfig.LogConfig.System.IsStackDriverEnabled, "Enable Log-links to stackdriver") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.system.gcp-project"), defaultConfig.LogConfig.System.GCPProjectName, "Name of the project in GCP") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.system.stackdriver-logresourcename"), defaultConfig.LogConfig.System.StackdriverLogResourceName, "Name of the logresource in stackdriver") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.system.stackdriver-template-uri"), defaultConfig.LogConfig.System.StackDriverTemplateURI, "Template Uri to use when building stackdriver log links") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "logs.all-user.cloudwatch-enabled"), defaultConfig.LogConfig.AllUser.IsCloudwatchEnabled, "Enable Cloudwatch Logging") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.all-user.cloudwatch-region"), defaultConfig.LogConfig.AllUser.CloudwatchRegion, "AWS region in which Cloudwatch logs are stored.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.all-user.cloudwatch-log-group"), defaultConfig.LogConfig.AllUser.CloudwatchLogGroup, "Log group to which streams are associated.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.all-user.cloudwatch-template-uri"), defaultConfig.LogConfig.AllUser.CloudwatchTemplateURI, "Template Uri to use when building cloudwatch log links") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "logs.all-user.kubernetes-enabled"), defaultConfig.LogConfig.AllUser.IsKubernetesEnabled, "Enable Kubernetes Logging") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.all-user.kubernetes-url"), defaultConfig.LogConfig.AllUser.KubernetesURL, "Console URL for Kubernetes logs") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.all-user.kubernetes-template-uri"), defaultConfig.LogConfig.AllUser.KubernetesTemplateURI, "Template Uri to use when building kubernetes log links") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "logs.all-user.stackdriver-enabled"), defaultConfig.LogConfig.AllUser.IsStackDriverEnabled, "Enable Log-links to stackdriver") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.all-user.gcp-project"), defaultConfig.LogConfig.AllUser.GCPProjectName, "Name of the project in GCP") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.all-user.stackdriver-logresourcename"), defaultConfig.LogConfig.AllUser.StackdriverLogResourceName, "Name of the logresource in stackdriver") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "logs.all-user.stackdriver-template-uri"), defaultConfig.LogConfig.AllUser.StackDriverTemplateURI, "Template Uri to use when building stackdriver log links") + return cmdFlags +} diff --git a/flyteplugins/go/tasks/plugins/k8s/spark/config_flags_test.go b/flyteplugins/go/tasks/plugins/k8s/spark/config_flags_test.go new file mode 100755 index 0000000000..ea8659a48a --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/spark/config_flags_test.go @@ -0,0 +1,732 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package spark + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "testing" + + "github.com/mitchellh/mapstructure" + "github.com/stretchr/testify/assert" +) + +var dereferencableKindsConfig = map[reflect.Kind]struct{}{ + reflect.Array: {}, reflect.Chan: {}, reflect.Map: {}, reflect.Ptr: {}, reflect.Slice: {}, +} + +// Checks if t is a kind that can be dereferenced to get its underlying type. +func canGetElementConfig(t reflect.Kind) bool { + _, exists := dereferencableKindsConfig[t] + return exists +} + +// This decoder hook tests types for json unmarshaling capability. If implemented, it uses json unmarshal to build the +// object. Otherwise, it'll just pass on the original data. +func jsonUnmarshalerHookConfig(_, to reflect.Type, data interface{}) (interface{}, error) { + unmarshalerType := reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + if to.Implements(unmarshalerType) || reflect.PtrTo(to).Implements(unmarshalerType) || + (canGetElementConfig(to.Kind()) && to.Elem().Implements(unmarshalerType)) { + + raw, err := json.Marshal(data) + if err != nil { + fmt.Printf("Failed to marshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + res := reflect.New(to).Interface() + err = json.Unmarshal(raw, &res) + if err != nil { + fmt.Printf("Failed to umarshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + return res, nil + } + + return data, nil +} + +func decode_Config(input, result interface{}) error { + config := &mapstructure.DecoderConfig{ + TagName: "json", + WeaklyTypedInput: true, + Result: result, + DecodeHook: mapstructure.ComposeDecodeHookFunc( + mapstructure.StringToTimeDurationHookFunc(), + mapstructure.StringToSliceHookFunc(","), + jsonUnmarshalerHookConfig, + ), + } + + decoder, err := mapstructure.NewDecoder(config) + if err != nil { + return err + } + + return decoder.Decode(input) +} + +func join_Config(arr interface{}, sep string) string { + listValue := reflect.ValueOf(arr) + strs := make([]string, 0, listValue.Len()) + for i := 0; i < listValue.Len(); i++ { + strs = append(strs, fmt.Sprintf("%v", listValue.Index(i))) + } + + return strings.Join(strs, sep) +} + +func testDecodeJson_Config(t *testing.T, val, result interface{}) { + assert.NoError(t, decode_Config(val, result)) +} + +func testDecodeRaw_Config(t *testing.T, vStringSlice, result interface{}) { + assert.NoError(t, decode_Config(vStringSlice, result)) +} + +func TestConfig_GetPFlagSet(t *testing.T) { + val := Config{} + cmdFlags := val.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) +} + +func TestConfig_SetFlags(t *testing.T) { + actual := Config{} + cmdFlags := actual.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) + + t.Run("Test_spark-history-server-url", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("spark-history-server-url", testValue) + if vString, err := cmdFlags.GetString("spark-history-server-url"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.SparkHistoryServerURL) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.mixed.cloudwatch-enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.mixed.cloudwatch-enabled", testValue) + if vBool, err := cmdFlags.GetBool("logs.mixed.cloudwatch-enabled"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.LogConfig.Mixed.IsCloudwatchEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.mixed.cloudwatch-region", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.mixed.cloudwatch-region", testValue) + if vString, err := cmdFlags.GetString("logs.mixed.cloudwatch-region"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.Mixed.CloudwatchRegion) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.mixed.cloudwatch-log-group", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.mixed.cloudwatch-log-group", testValue) + if vString, err := cmdFlags.GetString("logs.mixed.cloudwatch-log-group"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.Mixed.CloudwatchLogGroup) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.mixed.cloudwatch-template-uri", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.mixed.cloudwatch-template-uri", testValue) + if vString, err := cmdFlags.GetString("logs.mixed.cloudwatch-template-uri"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.Mixed.CloudwatchTemplateURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.mixed.kubernetes-enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.mixed.kubernetes-enabled", testValue) + if vBool, err := cmdFlags.GetBool("logs.mixed.kubernetes-enabled"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.LogConfig.Mixed.IsKubernetesEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.mixed.kubernetes-url", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.mixed.kubernetes-url", testValue) + if vString, err := cmdFlags.GetString("logs.mixed.kubernetes-url"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.Mixed.KubernetesURL) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.mixed.kubernetes-template-uri", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.mixed.kubernetes-template-uri", testValue) + if vString, err := cmdFlags.GetString("logs.mixed.kubernetes-template-uri"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.Mixed.KubernetesTemplateURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.mixed.stackdriver-enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.mixed.stackdriver-enabled", testValue) + if vBool, err := cmdFlags.GetBool("logs.mixed.stackdriver-enabled"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.LogConfig.Mixed.IsStackDriverEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.mixed.gcp-project", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.mixed.gcp-project", testValue) + if vString, err := cmdFlags.GetString("logs.mixed.gcp-project"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.Mixed.GCPProjectName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.mixed.stackdriver-logresourcename", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.mixed.stackdriver-logresourcename", testValue) + if vString, err := cmdFlags.GetString("logs.mixed.stackdriver-logresourcename"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.Mixed.StackdriverLogResourceName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.mixed.stackdriver-template-uri", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.mixed.stackdriver-template-uri", testValue) + if vString, err := cmdFlags.GetString("logs.mixed.stackdriver-template-uri"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.Mixed.StackDriverTemplateURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.user.cloudwatch-enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.user.cloudwatch-enabled", testValue) + if vBool, err := cmdFlags.GetBool("logs.user.cloudwatch-enabled"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.LogConfig.User.IsCloudwatchEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.user.cloudwatch-region", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.user.cloudwatch-region", testValue) + if vString, err := cmdFlags.GetString("logs.user.cloudwatch-region"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.User.CloudwatchRegion) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.user.cloudwatch-log-group", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.user.cloudwatch-log-group", testValue) + if vString, err := cmdFlags.GetString("logs.user.cloudwatch-log-group"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.User.CloudwatchLogGroup) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.user.cloudwatch-template-uri", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.user.cloudwatch-template-uri", testValue) + if vString, err := cmdFlags.GetString("logs.user.cloudwatch-template-uri"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.User.CloudwatchTemplateURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.user.kubernetes-enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.user.kubernetes-enabled", testValue) + if vBool, err := cmdFlags.GetBool("logs.user.kubernetes-enabled"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.LogConfig.User.IsKubernetesEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.user.kubernetes-url", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.user.kubernetes-url", testValue) + if vString, err := cmdFlags.GetString("logs.user.kubernetes-url"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.User.KubernetesURL) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.user.kubernetes-template-uri", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.user.kubernetes-template-uri", testValue) + if vString, err := cmdFlags.GetString("logs.user.kubernetes-template-uri"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.User.KubernetesTemplateURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.user.stackdriver-enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.user.stackdriver-enabled", testValue) + if vBool, err := cmdFlags.GetBool("logs.user.stackdriver-enabled"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.LogConfig.User.IsStackDriverEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.user.gcp-project", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.user.gcp-project", testValue) + if vString, err := cmdFlags.GetString("logs.user.gcp-project"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.User.GCPProjectName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.user.stackdriver-logresourcename", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.user.stackdriver-logresourcename", testValue) + if vString, err := cmdFlags.GetString("logs.user.stackdriver-logresourcename"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.User.StackdriverLogResourceName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.user.stackdriver-template-uri", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.user.stackdriver-template-uri", testValue) + if vString, err := cmdFlags.GetString("logs.user.stackdriver-template-uri"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.User.StackDriverTemplateURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.system.cloudwatch-enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.system.cloudwatch-enabled", testValue) + if vBool, err := cmdFlags.GetBool("logs.system.cloudwatch-enabled"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.LogConfig.System.IsCloudwatchEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.system.cloudwatch-region", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.system.cloudwatch-region", testValue) + if vString, err := cmdFlags.GetString("logs.system.cloudwatch-region"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.System.CloudwatchRegion) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.system.cloudwatch-log-group", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.system.cloudwatch-log-group", testValue) + if vString, err := cmdFlags.GetString("logs.system.cloudwatch-log-group"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.System.CloudwatchLogGroup) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.system.cloudwatch-template-uri", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.system.cloudwatch-template-uri", testValue) + if vString, err := cmdFlags.GetString("logs.system.cloudwatch-template-uri"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.System.CloudwatchTemplateURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.system.kubernetes-enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.system.kubernetes-enabled", testValue) + if vBool, err := cmdFlags.GetBool("logs.system.kubernetes-enabled"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.LogConfig.System.IsKubernetesEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.system.kubernetes-url", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.system.kubernetes-url", testValue) + if vString, err := cmdFlags.GetString("logs.system.kubernetes-url"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.System.KubernetesURL) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.system.kubernetes-template-uri", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.system.kubernetes-template-uri", testValue) + if vString, err := cmdFlags.GetString("logs.system.kubernetes-template-uri"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.System.KubernetesTemplateURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.system.stackdriver-enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.system.stackdriver-enabled", testValue) + if vBool, err := cmdFlags.GetBool("logs.system.stackdriver-enabled"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.LogConfig.System.IsStackDriverEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.system.gcp-project", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.system.gcp-project", testValue) + if vString, err := cmdFlags.GetString("logs.system.gcp-project"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.System.GCPProjectName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.system.stackdriver-logresourcename", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.system.stackdriver-logresourcename", testValue) + if vString, err := cmdFlags.GetString("logs.system.stackdriver-logresourcename"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.System.StackdriverLogResourceName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.system.stackdriver-template-uri", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.system.stackdriver-template-uri", testValue) + if vString, err := cmdFlags.GetString("logs.system.stackdriver-template-uri"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.System.StackDriverTemplateURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.all-user.cloudwatch-enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.all-user.cloudwatch-enabled", testValue) + if vBool, err := cmdFlags.GetBool("logs.all-user.cloudwatch-enabled"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.LogConfig.AllUser.IsCloudwatchEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.all-user.cloudwatch-region", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.all-user.cloudwatch-region", testValue) + if vString, err := cmdFlags.GetString("logs.all-user.cloudwatch-region"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.AllUser.CloudwatchRegion) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.all-user.cloudwatch-log-group", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.all-user.cloudwatch-log-group", testValue) + if vString, err := cmdFlags.GetString("logs.all-user.cloudwatch-log-group"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.AllUser.CloudwatchLogGroup) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.all-user.cloudwatch-template-uri", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.all-user.cloudwatch-template-uri", testValue) + if vString, err := cmdFlags.GetString("logs.all-user.cloudwatch-template-uri"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.AllUser.CloudwatchTemplateURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.all-user.kubernetes-enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.all-user.kubernetes-enabled", testValue) + if vBool, err := cmdFlags.GetBool("logs.all-user.kubernetes-enabled"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.LogConfig.AllUser.IsKubernetesEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.all-user.kubernetes-url", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.all-user.kubernetes-url", testValue) + if vString, err := cmdFlags.GetString("logs.all-user.kubernetes-url"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.AllUser.KubernetesURL) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.all-user.kubernetes-template-uri", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.all-user.kubernetes-template-uri", testValue) + if vString, err := cmdFlags.GetString("logs.all-user.kubernetes-template-uri"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.AllUser.KubernetesTemplateURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.all-user.stackdriver-enabled", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.all-user.stackdriver-enabled", testValue) + if vBool, err := cmdFlags.GetBool("logs.all-user.stackdriver-enabled"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.LogConfig.AllUser.IsStackDriverEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.all-user.gcp-project", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.all-user.gcp-project", testValue) + if vString, err := cmdFlags.GetString("logs.all-user.gcp-project"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.AllUser.GCPProjectName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.all-user.stackdriver-logresourcename", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.all-user.stackdriver-logresourcename", testValue) + if vString, err := cmdFlags.GetString("logs.all-user.stackdriver-logresourcename"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.AllUser.StackdriverLogResourceName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_logs.all-user.stackdriver-template-uri", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("logs.all-user.stackdriver-template-uri", testValue) + if vString, err := cmdFlags.GetString("logs.all-user.stackdriver-template-uri"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.LogConfig.AllUser.StackDriverTemplateURI) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) +} diff --git a/flyteplugins/go/tasks/plugins/k8s/spark/spark.go b/flyteplugins/go/tasks/plugins/k8s/spark/spark.go new file mode 100644 index 0000000000..3c6a57c80f --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/spark/spark.go @@ -0,0 +1,650 @@ +package spark + +import ( + "context" + "fmt" + "regexp" + "strconv" + "strings" + "time" + + sparkOp "github.com/GoogleCloudPlatform/spark-on-k8s-operator/pkg/apis/sparkoperator.k8s.io/v1beta2" + sparkOpConfig "github.com/GoogleCloudPlatform/spark-on-k8s-operator/pkg/config" + v1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/kubernetes/scheme" + "sigs.k8s.io/controller-runtime/pkg/client" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/logs" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery" + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/tasklog" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" +) + +const KindSparkApplication = "SparkApplication" +const sparkDriverUI = "sparkDriverUI" +const sparkHistoryUI = "sparkHistoryUI" +const defaultDriverPrimaryContainerName = "spark-kubernetes-driver" + +var featureRegex = regexp.MustCompile(`^spark.((flyteorg)|(flyte)).(.+).enabled$`) + +var sparkTaskType = "spark" + +type sparkResourceHandler struct { +} + +func validateSparkJob(sparkJob *plugins.SparkJob) error { + if sparkJob == nil { + return fmt.Errorf("empty sparkJob") + } + + if len(sparkJob.MainApplicationFile) == 0 && len(sparkJob.MainClass) == 0 { + return fmt.Errorf("either MainApplicationFile or MainClass must be set") + } + + return nil +} + +func (sparkResourceHandler) GetProperties() k8s.PluginProperties { + return k8s.PluginProperties{} +} + +// Creates a new Job that will execute the main container as well as any generated types the result from the execution. +func (sparkResourceHandler) BuildResource(ctx context.Context, taskCtx pluginsCore.TaskExecutionContext) (client.Object, error) { + taskTemplate, err := taskCtx.TaskReader().Read(ctx) + if err != nil { + return nil, errors.Errorf(errors.BadTaskSpecification, "unable to fetch task specification [%v]", err.Error()) + } else if taskTemplate == nil { + return nil, errors.Errorf(errors.BadTaskSpecification, "nil task specification") + } + + sparkJob := plugins.SparkJob{} + err = utils.UnmarshalStruct(taskTemplate.GetCustom(), &sparkJob) + if err != nil { + return nil, errors.Wrapf(errors.BadTaskSpecification, err, "invalid TaskSpecification [%v], failed to unmarshal", taskTemplate.GetCustom()) + } + + if err = validateSparkJob(&sparkJob); err != nil { + return nil, errors.Wrapf(errors.BadTaskSpecification, err, "invalid TaskSpecification [%v].", taskTemplate.GetCustom()) + } + + sparkConfig := getSparkConfig(taskCtx, &sparkJob) + driverSpec, err := createDriverSpec(ctx, taskCtx, sparkConfig, &sparkJob) + if err != nil { + return nil, err + } + executorSpec, err := createExecutorSpec(ctx, taskCtx, sparkConfig, &sparkJob) + if err != nil { + return nil, err + } + app := createSparkApplication(&sparkJob, sparkConfig, driverSpec, executorSpec) + return app, nil +} + +func getSparkConfig(taskCtx pluginsCore.TaskExecutionContext, sparkJob *plugins.SparkJob) map[string]string { + // Start with default config values. + sparkConfig := make(map[string]string) + for k, v := range GetSparkConfig().DefaultSparkConfig { + sparkConfig[k] = v + } + + if sparkJob.GetExecutorPath() != "" { + sparkConfig["spark.pyspark.python"] = sparkJob.GetExecutorPath() + sparkConfig["spark.pyspark.driver.python"] = sparkJob.GetExecutorPath() + } + + for k, v := range sparkJob.GetSparkConf() { + // Add optional features if present. + if featureRegex.MatchString(k) { + addConfig(sparkConfig, k, v) + } else { + sparkConfig[k] = v + } + } + + // Set pod limits. + if len(sparkConfig[sparkOpConfig.SparkDriverCoreLimitKey]) == 0 { + // spark.kubernetes.driver.request.cores takes precedence over spark.driver.cores + if len(sparkConfig[sparkOpConfig.SparkDriverCoreRequestKey]) != 0 { + sparkConfig[sparkOpConfig.SparkDriverCoreLimitKey] = sparkConfig[sparkOpConfig.SparkDriverCoreRequestKey] + } else if len(sparkConfig["spark.driver.cores"]) != 0 { + sparkConfig[sparkOpConfig.SparkDriverCoreLimitKey] = sparkConfig["spark.driver.cores"] + } + } + + if len(sparkConfig[sparkOpConfig.SparkExecutorCoreLimitKey]) == 0 { + // spark.kubernetes.executor.request.cores takes precedence over spark.executor.cores + if len(sparkConfig[sparkOpConfig.SparkExecutorCoreRequestKey]) != 0 { + sparkConfig[sparkOpConfig.SparkExecutorCoreLimitKey] = sparkConfig[sparkOpConfig.SparkExecutorCoreRequestKey] + } else if len(sparkConfig["spark.executor.cores"]) != 0 { + sparkConfig[sparkOpConfig.SparkExecutorCoreLimitKey] = sparkConfig["spark.executor.cores"] + } + } + + sparkConfig["spark.kubernetes.executor.podNamePrefix"] = taskCtx.TaskExecutionMetadata().GetTaskExecutionID().GetGeneratedName() + sparkConfig["spark.kubernetes.driverEnv.FLYTE_START_TIME"] = strconv.FormatInt(time.Now().UnixNano()/1000000, 10) + + return sparkConfig +} + +func serviceAccountName(metadata pluginsCore.TaskExecutionMetadata) string { + name := flytek8s.GetServiceAccountNameFromTaskExecutionMetadata(metadata) + if len(name) == 0 { + name = sparkTaskType + } + return name +} + +func createSparkPodSpec(taskCtx pluginsCore.TaskExecutionContext, podSpec *v1.PodSpec, container *v1.Container) *sparkOp.SparkPodSpec { + annotations := utils.UnionMaps(config.GetK8sPluginConfig().DefaultAnnotations, utils.CopyMap(taskCtx.TaskExecutionMetadata().GetAnnotations())) + labels := utils.UnionMaps(config.GetK8sPluginConfig().DefaultLabels, utils.CopyMap(taskCtx.TaskExecutionMetadata().GetLabels())) + + sparkEnv := make([]v1.EnvVar, 0) + for _, envVar := range container.Env { + sparkEnv = append(sparkEnv, *envVar.DeepCopy()) + } + sparkEnv = append(sparkEnv, v1.EnvVar{Name: "FLYTE_MAX_ATTEMPTS", Value: strconv.Itoa(int(taskCtx.TaskExecutionMetadata().GetMaxAttempts()))}) + + spec := sparkOp.SparkPodSpec{ + Affinity: podSpec.Affinity, + Annotations: annotations, + Labels: labels, + Env: sparkEnv, + Image: &container.Image, + SecurityContenxt: podSpec.SecurityContext.DeepCopy(), + DNSConfig: podSpec.DNSConfig.DeepCopy(), + Tolerations: podSpec.Tolerations, + SchedulerName: &podSpec.SchedulerName, + NodeSelector: podSpec.NodeSelector, + HostNetwork: &podSpec.HostNetwork, + } + return &spec +} + +type driverSpec struct { + sparkSpec *sparkOp.DriverSpec +} + +func createDriverSpec(ctx context.Context, taskCtx pluginsCore.TaskExecutionContext, sparkConfig map[string]string, sparkJob *plugins.SparkJob) (*driverSpec, error) { + // Spark driver pods should always run as non-interruptible + nonInterruptibleTaskCtx := flytek8s.NewPluginTaskExecutionContext(taskCtx, flytek8s.WithInterruptible(false)) + podSpec, _, primaryContainerName, err := flytek8s.ToK8sPodSpec(ctx, nonInterruptibleTaskCtx) + if err != nil { + return nil, err + } + + driverPod := sparkJob.GetDriverPod() + if driverPod != nil { + if driverPod.GetPodSpec() != nil { + var customPodSpec *v1.PodSpec + + err = utils.UnmarshalStructToObj(driverPod.GetPodSpec(), &customPodSpec) + if err != nil { + return nil, errors.Errorf(errors.BadTaskSpecification, + "Unable to unmarshal driver pod spec [%v], Err: [%v]", driverPod.GetPodSpec(), err.Error()) + } + + podSpec, err = flytek8s.MergeOverlayPodSpecOntoBase(podSpec, customPodSpec) + if err != nil { + return nil, err + } + } + + if driverPod.GetPrimaryContainerName() != "" { + primaryContainerName = driverPod.GetPrimaryContainerName() + } + } + + primaryContainer, err := flytek8s.GetContainer(podSpec, primaryContainerName) + if err != nil { + return nil, err + } + sparkPodSpec := createSparkPodSpec(nonInterruptibleTaskCtx, podSpec, primaryContainer) + serviceAccountName := serviceAccountName(nonInterruptibleTaskCtx.TaskExecutionMetadata()) + spec := driverSpec{ + &sparkOp.DriverSpec{ + SparkPodSpec: *sparkPodSpec, + ServiceAccount: &serviceAccountName, + }, + } + if cores, err := strconv.ParseInt(sparkConfig["spark.driver.cores"], 10, 32); err == nil { + spec.sparkSpec.Cores = intPtr(int32(cores)) + } + spec.sparkSpec.Memory = strPtr(sparkConfig["spark.driver.memory"]) + return &spec, nil +} + +type executorSpec struct { + container *v1.Container + sparkSpec *sparkOp.ExecutorSpec + serviceAccountName string +} + +func createExecutorSpec(ctx context.Context, taskCtx pluginsCore.TaskExecutionContext, sparkConfig map[string]string, sparkJob *plugins.SparkJob) (*executorSpec, error) { + podSpec, _, primaryContainerName, err := flytek8s.ToK8sPodSpec(ctx, taskCtx) + if err != nil { + return nil, err + } + + executorPod := sparkJob.GetExecutorPod() + if executorPod != nil { + if executorPod.GetPodSpec() != nil { + var customPodSpec *v1.PodSpec + + err = utils.UnmarshalStructToObj(executorPod.GetPodSpec(), &customPodSpec) + if err != nil { + return nil, errors.Errorf(errors.BadTaskSpecification, + "Unable to unmarshal executor pod spec [%v], Err: [%v]", executorPod.GetPodSpec(), err.Error()) + } + + podSpec, err = flytek8s.MergeOverlayPodSpecOntoBase(podSpec, customPodSpec) + if err != nil { + return nil, err + } + } + if executorPod.GetPrimaryContainerName() != "" { + primaryContainerName = executorPod.GetPrimaryContainerName() + } + } + + primaryContainer, err := flytek8s.GetContainer(podSpec, primaryContainerName) + if err != nil { + return nil, err + } + sparkPodSpec := createSparkPodSpec(taskCtx, podSpec, primaryContainer) + serviceAccountName := serviceAccountName(taskCtx.TaskExecutionMetadata()) + spec := executorSpec{ + primaryContainer, + &sparkOp.ExecutorSpec{ + SparkPodSpec: *sparkPodSpec, + }, + serviceAccountName, + } + if execCores, err := strconv.ParseInt(sparkConfig["spark.executor.cores"], 10, 32); err == nil { + spec.sparkSpec.Cores = intPtr(int32(execCores)) + } + if execCount, err := strconv.ParseInt(sparkConfig["spark.executor.instances"], 10, 32); err == nil { + spec.sparkSpec.Instances = intPtr(int32(execCount)) + } + spec.sparkSpec.Memory = strPtr(sparkConfig["spark.executor.memory"]) + return &spec, nil +} + +func createSparkApplication(sparkJob *plugins.SparkJob, sparkConfig map[string]string, driverSpec *driverSpec, + executorSpec *executorSpec) *sparkOp.SparkApplication { + // Hack: Retry submit failures in-case of resource limits hit. + submissionFailureRetries := int32(14) + + app := &sparkOp.SparkApplication{ + TypeMeta: metav1.TypeMeta{ + Kind: KindSparkApplication, + APIVersion: sparkOp.SchemeGroupVersion.String(), + }, + Spec: sparkOp.SparkApplicationSpec{ + ServiceAccount: &executorSpec.serviceAccountName, + Type: getApplicationType(sparkJob.GetApplicationType()), + Image: &executorSpec.container.Image, + Arguments: executorSpec.container.Args, + Driver: *driverSpec.sparkSpec, + Executor: *executorSpec.sparkSpec, + SparkConf: sparkConfig, + HadoopConf: sparkJob.GetHadoopConf(), + // SubmissionFailures handled here. Task Failures handled at Propeller/Job level. + RestartPolicy: sparkOp.RestartPolicy{ + Type: sparkOp.OnFailure, + OnSubmissionFailureRetries: &submissionFailureRetries, + }, + }, + } + + if val, ok := sparkConfig["spark.batchScheduler"]; ok { + app.Spec.BatchScheduler = &val + } + + if sparkJob.MainApplicationFile != "" { + app.Spec.MainApplicationFile = &sparkJob.MainApplicationFile + } + if sparkJob.MainClass != "" { + app.Spec.MainClass = &sparkJob.MainClass + } + return app +} + +func addConfig(sparkConfig map[string]string, key string, value string) { + + if strings.ToLower(strings.TrimSpace(value)) != "true" { + sparkConfig[key] = value + return + } + + matches := featureRegex.FindAllStringSubmatch(key, -1) + if len(matches) == 0 || len(matches[0]) == 0 { + sparkConfig[key] = value + return + } + featureName := matches[0][len(matches[0])-1] + + // Use the first matching feature in-case of duplicates. + for _, feature := range GetSparkConfig().Features { + if feature.Name == featureName { + for k, v := range feature.SparkConfig { + sparkConfig[k] = v + } + return + } + } + sparkConfig[key] = value +} + +// Convert SparkJob ApplicationType to Operator CRD ApplicationType +func getApplicationType(applicationType plugins.SparkApplication_Type) sparkOp.SparkApplicationType { + switch applicationType { + case plugins.SparkApplication_PYTHON: + return sparkOp.PythonApplicationType + case plugins.SparkApplication_JAVA: + return sparkOp.JavaApplicationType + case plugins.SparkApplication_SCALA: + return sparkOp.ScalaApplicationType + case plugins.SparkApplication_R: + return sparkOp.RApplicationType + } + return sparkOp.PythonApplicationType +} + +func (sparkResourceHandler) BuildIdentityResource(ctx context.Context, taskCtx pluginsCore.TaskExecutionMetadata) (client.Object, error) { + return &sparkOp.SparkApplication{ + TypeMeta: metav1.TypeMeta{ + Kind: KindSparkApplication, + APIVersion: sparkOp.SchemeGroupVersion.String(), + }, + }, nil +} + +func getEventInfoForSpark(ctx context.Context, pluginContext k8s.PluginContext, sj *sparkOp.SparkApplication) (*pluginsCore.TaskInfo, error) { + + sparkConfig := GetSparkConfig() + taskLogs := make([]*core.TaskLog, 0, 3) + var logCtx *core.LogContext + taskExecID := pluginContext.TaskExecutionMetadata().GetTaskExecutionID() + + if sj.Status.DriverInfo.PodName != "" { + p, err := logs.InitializeLogPlugins(&sparkConfig.LogConfig.Mixed) + if err != nil { + return nil, err + } + + if p != nil { + o, err := p.GetTaskLogs(tasklog.Input{ + PodName: sj.Status.DriverInfo.PodName, + Namespace: sj.Namespace, + TaskExecutionID: taskExecID, + EnableVscode: flytek8s.IsVscodeEnabled(ctx, sj.Spec.Driver.Env), + }) + + if err != nil { + return nil, err + } + + taskLogs = append(taskLogs, o.TaskLogs...) + } + } + + p, err := logs.InitializeLogPlugins(&sparkConfig.LogConfig.User) + if err != nil { + return nil, err + } + + if p != nil { + o, err := p.GetTaskLogs(tasklog.Input{ + PodName: sj.Status.DriverInfo.PodName, + Namespace: sj.Namespace, + TaskExecutionID: taskExecID, + }) + + if err != nil { + return nil, err + } + + taskLogs = append(taskLogs, o.TaskLogs...) + } + + logCtx = &core.LogContext{ + PrimaryPodName: sj.Status.DriverInfo.PodName, + } + logCtx.Pods = append(logCtx.Pods, &core.PodLogContext{ + Namespace: sj.Namespace, + PodName: sj.Status.DriverInfo.PodName, + PrimaryContainerName: defaultDriverPrimaryContainerName, + Containers: []*core.ContainerContext{ + {ContainerName: defaultDriverPrimaryContainerName}, + }, + }) + + for executorPodName, executorState := range sj.Status.ExecutorState { + if executorState != sparkOp.ExecutorPendingState && executorState != sparkOp.ExecutorUnknownState { + logCtx.Pods = append(logCtx.Pods, &core.PodLogContext{ + Namespace: sj.Namespace, + PodName: executorPodName, + PrimaryContainerName: "spark-kubernetes-executor", + Containers: []*core.ContainerContext{ + {ContainerName: "spark-kubernetes-executor"}, + }, + }) + } + } + + p, err = logs.InitializeLogPlugins(&sparkConfig.LogConfig.System) + if err != nil { + return nil, err + } + + if p != nil { + o, err := p.GetTaskLogs(tasklog.Input{ + PodName: sj.Name, + Namespace: sj.Namespace, + TaskExecutionID: taskExecID, + }) + + if err != nil { + return nil, err + } + + taskLogs = append(taskLogs, o.TaskLogs...) + } + + p, err = logs.InitializeLogPlugins(&sparkConfig.LogConfig.AllUser) + if err != nil { + return nil, err + } + + if p != nil { + o, err := p.GetTaskLogs(tasklog.Input{ + PodName: sj.Name, + Namespace: sj.Namespace, + TaskExecutionID: taskExecID, + }) + + if err != nil { + return nil, err + } + + // "All user" logs are shown already in the queuing and initializing phase. + for _, log := range o.TaskLogs { + log.ShowWhilePending = true + } + + taskLogs = append(taskLogs, o.TaskLogs...) + } + + customInfoMap := make(map[string]string) + + // Spark UI. + if sj.Status.AppState.State == sparkOp.FailedState || sj.Status.AppState.State == sparkOp.CompletedState { + if sj.Status.SparkApplicationID != "" && GetSparkConfig().SparkHistoryServerURL != "" { + customInfoMap[sparkHistoryUI] = fmt.Sprintf("%s/history/%s", GetSparkConfig().SparkHistoryServerURL, sj.Status.SparkApplicationID) + // Custom doesn't work unless the UI has a custom plugin to parse this, hence add to Logs as well. + taskLogs = append(taskLogs, &core.TaskLog{ + Uri: customInfoMap[sparkHistoryUI], + Name: "Spark History UI", + Ready: true, + MessageFormat: core.TaskLog_JSON, + LinkType: core.TaskLog_DASHBOARD, + }) + } + } else if sj.Status.AppState.State == sparkOp.RunningState && sj.Status.DriverInfo.WebUIIngressAddress != "" { + // Older versions of spark-operator does not append http:// but newer versions do. + uri := sj.Status.DriverInfo.WebUIIngressAddress + if !strings.HasPrefix(uri, "https://") && !strings.HasPrefix(uri, "http://") { + uri = fmt.Sprintf("https://%s", uri) + } + customInfoMap[sparkDriverUI] = uri + + // Custom doesn't work unless the UI has a custom plugin to parse this, hence add to Logs as well. + taskLogs = append(taskLogs, &core.TaskLog{ + Uri: customInfoMap[sparkDriverUI], + Name: "Spark Driver UI", + Ready: true, + MessageFormat: core.TaskLog_JSON, + LinkType: core.TaskLog_DASHBOARD, + }) + } + + customInfo, err := utils.MarshalObjToStruct(customInfoMap) + if err != nil { + return nil, err + } + + return &pluginsCore.TaskInfo{ + Logs: taskLogs, + LogContext: logCtx, + CustomInfo: customInfo, + }, nil +} + +func (sparkResourceHandler) GetTaskPhase(ctx context.Context, pluginContext k8s.PluginContext, resource client.Object) (pluginsCore.PhaseInfo, error) { + + app := resource.(*sparkOp.SparkApplication) + info, err := getEventInfoForSpark(ctx, pluginContext, app) + if err != nil { + return pluginsCore.PhaseInfoUndefined, err + } + + phaseInfo, err := flytek8s.DemystifyFailedOrPendingPod(ctx, pluginContext, *info, app.Namespace, app.Status.DriverInfo.PodName, defaultDriverPrimaryContainerName) + if err != nil { + logger.Errorf(ctx, "Failed to demystify pod status for spark driver. Error: %v", err) + } + if phaseInfo.Phase().IsFailure() { + // If the spark driver pod is in a failure state, we can fail fast without checking the SparkJob status. + return phaseInfo, nil + } + occurredAt := time.Now() + switch app.Status.AppState.State { + case sparkOp.NewState: + phaseInfo = pluginsCore.PhaseInfoQueuedWithTaskInfo(occurredAt, pluginsCore.DefaultPhaseVersion, "job queued", info) + case sparkOp.SubmittedState, sparkOp.PendingSubmissionState: + phaseInfo = pluginsCore.PhaseInfoInitializing(occurredAt, pluginsCore.DefaultPhaseVersion, "job submitted", info) + case sparkOp.FailedSubmissionState: + reason := fmt.Sprintf("Spark Job Submission Failed with Error: %s", app.Status.AppState.ErrorMessage) + phaseInfo = pluginsCore.PhaseInfoRetryableFailure(errors.DownstreamSystemError, reason, info) + case sparkOp.FailedState: + reason := fmt.Sprintf("Spark Job Failed with Error: %s", app.Status.AppState.ErrorMessage) + phaseInfo = pluginsCore.PhaseInfoRetryableFailure(errors.DownstreamSystemError, reason, info) + case sparkOp.CompletedState: + phaseInfo = pluginsCore.PhaseInfoSuccess(info) + default: + phaseInfo = pluginsCore.PhaseInfoRunning(pluginsCore.DefaultPhaseVersion, info) + } + + for _, tl := range info.Logs { + // TODO: Add readiness probe for spark driver pod. Need to upgrade spark-operator client version. + if tl != nil && tl.LinkType == core.TaskLog_DASHBOARD && strings.Contains(tl.Name, "Spark Driver UI") { + if phaseInfo.Phase() != pluginsCore.PhaseRunning { + tl.Ready = false + phaseInfo.WithReason("Spark driver UI is not ready") + } else { + tl.Ready = true + phaseInfo.WithReason("Spark driver UI is ready") + } + + } else if tl != nil && tl.LinkType == core.TaskLog_IDE { + if phaseInfo.Phase() != pluginsCore.PhaseRunning { + phaseInfo.WithReason("Vscode server is not ready") + } else { + phaseInfo.WithReason("Vscode server is ready") + } + } + } + + phaseVersionUpdateErr := k8s.MaybeUpdatePhaseVersionFromPluginContext(&phaseInfo, &pluginContext) + if phaseVersionUpdateErr != nil { + return phaseInfo, phaseVersionUpdateErr + } + + return phaseInfo, nil +} + +// IsTerminal returns true if the SparkApplication is in a terminal state (Completed, Failed, or FailedSubmission) +func (sparkResourceHandler) IsTerminal(_ context.Context, resource client.Object) (bool, error) { + app, ok := resource.(*sparkOp.SparkApplication) + if !ok { + return false, fmt.Errorf("unexpected resource type: expected *SparkApplication, got %T", resource) + } + state := app.Status.AppState.State + return state == sparkOp.CompletedState || state == sparkOp.FailedState || state == sparkOp.FailedSubmissionState, nil +} + +// GetCompletionTime returns the termination time of the SparkApplication +func (sparkResourceHandler) GetCompletionTime(resource client.Object) (time.Time, error) { + app, ok := resource.(*sparkOp.SparkApplication) + if !ok { + return time.Time{}, fmt.Errorf("unexpected resource type: expected *SparkApplication, got %T", resource) + } + + if !app.Status.TerminationTime.IsZero() { + return app.Status.TerminationTime.Time, nil + } + + // Fallback to submission time or creation time + if !app.Status.SubmissionTime.IsZero() { + return app.Status.SubmissionTime.Time, nil + } + + return app.CreationTimestamp.Time, nil +} + +func init() { + if err := sparkOp.AddToScheme(scheme.Scheme); err != nil { + panic(err) + } + + pluginmachinery.PluginRegistry().RegisterK8sPlugin( + k8s.PluginEntry{ + ID: sparkTaskType, + RegisteredTaskTypes: []pluginsCore.TaskType{sparkTaskType}, + ResourceToWatch: &sparkOp.SparkApplication{}, + Plugin: sparkResourceHandler{}, + IsDefault: false, + }) +} + +func strPtr(str string) *string { + if str == "" { + return nil + } + return &str +} + +func intPtr(val int32) *int32 { + if val == 0 { + return nil + } + return &val +} diff --git a/flyteplugins/go/tasks/plugins/k8s/spark/spark_test.go b/flyteplugins/go/tasks/plugins/k8s/spark/spark_test.go new file mode 100644 index 0000000000..efd4d4a6c3 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/k8s/spark/spark_test.go @@ -0,0 +1,1286 @@ +package spark + +import ( + "context" + "os" + "reflect" + "strconv" + "testing" + "time" + + sj "github.com/GoogleCloudPlatform/spark-on-k8s-operator/pkg/apis/sparkoperator.k8s.io/v1beta2" + sparkOp "github.com/GoogleCloudPlatform/spark-on-k8s-operator/pkg/apis/sparkoperator.k8s.io/v1beta2" + structpb "github.com/golang/protobuf/ptypes/struct" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + corev1 "k8s.io/api/core/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/client/fake" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/logs" + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/flytek8s/config" + pluginIOMocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s" + k8smocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/k8s/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" + stdlibUtils "github.com/flyteorg/flyte/v2/flytestdlib/utils" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" +) + +const sparkMainClass = "MainClass" +const sparkApplicationFile = "local:///spark_app.py" +const testImage = "image://" +const sparkUIAddress = "https://spark-ui.flyte" + +var ( + dummySparkConf = map[string]string{ + "spark.driver.memory": "200M", + "spark.driver.cores": "1", + "spark.executor.cores": "2", + "spark.executor.instances": "3", + "spark.executor.memory": "500M", + "spark.flyte.feature1.enabled": "true", + "spark.flyteorg.feature2.enabled": "true", + "spark.flyteorg.feature3.enabled": "true", + "spark.batchScheduler": "volcano", + } + + dummyEnvVars = []*core.KeyValuePair{ + {Key: "Env_Var", Value: "Env_Val"}, + } + + dummyEnvVarsWithSecretRef = []corev1.EnvVar{ + {Name: "Env_Var", Value: "Env_Val"}, + {Name: "SECRET", ValueFrom: &corev1.EnvVarSource{ + SecretKeyRef: &corev1.SecretKeySelector{ + Key: "key", + LocalObjectReference: corev1.LocalObjectReference{ + Name: "secret-name", + }, + }, + }}, + } + + testArgs = []string{ + "execute-spark-task", + } +) + +func TestGetApplicationType(t *testing.T) { + assert.Equal(t, getApplicationType(plugins.SparkApplication_PYTHON), sj.PythonApplicationType) + assert.Equal(t, getApplicationType(plugins.SparkApplication_R), sj.RApplicationType) + assert.Equal(t, getApplicationType(plugins.SparkApplication_JAVA), sj.JavaApplicationType) + assert.Equal(t, getApplicationType(plugins.SparkApplication_SCALA), sj.ScalaApplicationType) +} + +func TestGetEventInfo(t *testing.T) { + assert.NoError(t, setSparkConfig(&Config{ + LogConfig: LogConfig{ + User: logs.LogConfig{ + IsCloudwatchEnabled: true, + CloudwatchTemplateURI: "https://console.aws.amazon.com/cloudwatch/home?region=us-east-1#logStream:group=/kubernetes/flyte;prefix=var.log.containers.{{ .podName }};streamFilter=typeLogStreamPrefix", + IsKubernetesEnabled: true, + KubernetesURL: "k8s.com", + }, + System: logs.LogConfig{ + IsCloudwatchEnabled: true, + CloudwatchTemplateURI: "https://console.aws.amazon.com/cloudwatch/home?region=us-east-1#logStream:group=/kubernetes/flyte;prefix=system_log.var.log.containers.{{ .podName }};streamFilter=typeLogStreamPrefix", + }, + AllUser: logs.LogConfig{ + IsCloudwatchEnabled: true, + CloudwatchTemplateURI: "https://console.aws.amazon.com/cloudwatch/home?region=us-east-1#logStream:group=/kubernetes/flyte;prefix=var.log.containers.{{ .podName }};streamFilter=typeLogStreamPrefix", + }, + Mixed: logs.LogConfig{ + IsKubernetesEnabled: true, + KubernetesURL: "k8s.com", + }, + }, + })) + pluginContext := dummySparkPluginContext(dummySparkTaskTemplateContainer("blah-1", dummySparkConf), k8s.PluginState{}) + info, err := getEventInfoForSpark(context.TODO(), pluginContext, dummySparkApplication(sj.RunningState)) + assert.NoError(t, err) + assert.Len(t, info.Logs, 6) + assert.Equal(t, "https://spark-ui.flyte", info.CustomInfo.Fields[sparkDriverUI].GetStringValue()) + generatedLinks := make([]string, 0, len(info.Logs)) + for _, l := range info.Logs { + generatedLinks = append(generatedLinks, l.Uri) + } + + expectedLinks := []string{ + "k8s.com/#!/log/spark-namespace/spark-pod/pod?namespace=spark-namespace", + "k8s.com/#!/log/spark-namespace/spark-pod/pod?namespace=spark-namespace", + "https://console.aws.amazon.com/cloudwatch/home?region=us-east-1#logStream:group=/kubernetes/flyte;prefix=var.log.containers.spark-pod;streamFilter=typeLogStreamPrefix", + "https://console.aws.amazon.com/cloudwatch/home?region=us-east-1#logStream:group=/kubernetes/flyte;prefix=system_log.var.log.containers.spark-app-name;streamFilter=typeLogStreamPrefix", + "https://console.aws.amazon.com/cloudwatch/home?region=us-east-1#logStream:group=/kubernetes/flyte;prefix=var.log.containers.spark-app-name;streamFilter=typeLogStreamPrefix", + "https://spark-ui.flyte", + } + + assert.Equal(t, expectedLinks, generatedLinks) + + info, err = getEventInfoForSpark(context.TODO(), pluginContext, dummySparkApplication(sj.SubmittedState)) + generatedLinks = make([]string, 0, len(info.Logs)) + for _, l := range info.Logs { + generatedLinks = append(generatedLinks, l.Uri) + } + assert.NoError(t, err) + assert.Len(t, info.Logs, 5) + assert.Equal(t, expectedLinks[:5], generatedLinks) // No Spark Driver UI for Submitted state + assert.True(t, info.Logs[4].ShowWhilePending) // All User Logs should be shown while pending + generatedLinks = make([]string, 0, len(info.Logs)) + for _, l := range info.Logs { + generatedLinks = append(generatedLinks, l.Uri) + } + assert.NoError(t, err) + assert.Len(t, info.Logs, 5) + assert.Equal(t, expectedLinks[:5], generatedLinks) // No Spark Driver UI for Submitted state + assert.True(t, info.Logs[4].ShowWhilePending) // All User Logs should be shown while pending + + assert.NoError(t, setSparkConfig(&Config{ + SparkHistoryServerURL: "spark-history.flyte", + LogConfig: LogConfig{ + User: logs.LogConfig{ + IsCloudwatchEnabled: true, + CloudwatchTemplateURI: "https://console.aws.amazon.com/cloudwatch/home?region=us-east-1#logStream:group=/kubernetes/flyte;prefix=var.log.containers.{{ .podName }};streamFilter=typeLogStreamPrefix", + IsKubernetesEnabled: true, + KubernetesURL: "k8s.com", + }, + System: logs.LogConfig{ + IsCloudwatchEnabled: true, + CloudwatchTemplateURI: "https://console.aws.amazon.com/cloudwatch/home?region=us-east-1#logStream:group=/kubernetes/flyte;prefix=system_log.var.log.containers.{{ .podName }};streamFilter=typeLogStreamPrefix", + }, + AllUser: logs.LogConfig{ + IsCloudwatchEnabled: true, + CloudwatchTemplateURI: "https://console.aws.amazon.com/cloudwatch/home?region=us-east-1#logStream:group=/kubernetes/flyte;prefix=var.log.containers.{{ .podName }};streamFilter=typeLogStreamPrefix", + }, + }, + })) + + info, err = getEventInfoForSpark(context.TODO(), pluginContext, dummySparkApplication(sj.FailedState)) + assert.NoError(t, err) + assert.Len(t, info.Logs, 5) + assert.Equal(t, "spark-history.flyte/history/app-id", info.CustomInfo.Fields[sparkHistoryUI].GetStringValue()) + generatedLinks = make([]string, 0, len(info.Logs)) + for _, l := range info.Logs { + generatedLinks = append(generatedLinks, l.Uri) + } + + expectedLinks = []string{ + "k8s.com/#!/log/spark-namespace/spark-pod/pod?namespace=spark-namespace", + "https://console.aws.amazon.com/cloudwatch/home?region=us-east-1#logStream:group=/kubernetes/flyte;prefix=var.log.containers.spark-pod;streamFilter=typeLogStreamPrefix", + "https://console.aws.amazon.com/cloudwatch/home?region=us-east-1#logStream:group=/kubernetes/flyte;prefix=system_log.var.log.containers.spark-app-name;streamFilter=typeLogStreamPrefix", + "https://console.aws.amazon.com/cloudwatch/home?region=us-east-1#logStream:group=/kubernetes/flyte;prefix=var.log.containers.spark-app-name;streamFilter=typeLogStreamPrefix", + "spark-history.flyte/history/app-id", + } + + assert.Equal(t, expectedLinks, generatedLinks) +} + +func TestGetTaskPhase(t *testing.T) { + sparkResourceHandler := sparkResourceHandler{} + expectedLogCtx := &core.LogContext{ + PrimaryPodName: "spark-pod", + Pods: []*core.PodLogContext{ + { + Namespace: "spark-namespace", + PodName: "spark-pod", + PrimaryContainerName: "spark-kubernetes-driver", + Containers: []*core.ContainerContext{ + { + ContainerName: "spark-kubernetes-driver", + }, + }, + }, + { + Namespace: "spark-namespace", + PodName: "exec-pod-2", + PrimaryContainerName: "spark-kubernetes-executor", + Containers: []*core.ContainerContext{ + { + ContainerName: "spark-kubernetes-executor", + }, + }, + }, + }, + } + + ctx := context.TODO() + pluginCtx := dummySparkPluginContext(dummySparkTaskTemplateContainer("", dummySparkConf), k8s.PluginState{}) + taskPhase, err := sparkResourceHandler.GetTaskPhase(ctx, pluginCtx, dummySparkApplication(sj.NewState)) + assert.NoError(t, err) + assert.Equal(t, taskPhase.Phase(), pluginsCore.PhaseQueued) + assert.NotNil(t, taskPhase.Info()) + assert.NotNil(t, taskPhase.Info().LogContext) + assert.Nil(t, err) + + taskPhase, err = sparkResourceHandler.GetTaskPhase(ctx, pluginCtx, dummySparkApplication(sj.SubmittedState)) + assert.NoError(t, err) + assert.Equal(t, taskPhase.Phase(), pluginsCore.PhaseInitializing) + assert.NotNil(t, taskPhase.Info()) + assert.NotNil(t, taskPhase.Info().LogContext) + assert.Nil(t, err) + + taskPhase, err = sparkResourceHandler.GetTaskPhase(ctx, pluginCtx, dummySparkApplication(sj.RunningState)) + assert.NoError(t, err) + assert.Equal(t, taskPhase.Phase(), pluginsCore.PhaseRunning) + assert.NotNil(t, taskPhase.Info()) + assert.Equal(t, expectedLogCtx, taskPhase.Info().LogContext) + assert.Nil(t, err) + + taskPhase, err = sparkResourceHandler.GetTaskPhase(ctx, pluginCtx, dummySparkApplication(sj.CompletedState)) + assert.NoError(t, err) + assert.Equal(t, taskPhase.Phase(), pluginsCore.PhaseSuccess) + assert.NotNil(t, taskPhase.Info()) + assert.Equal(t, expectedLogCtx, taskPhase.Info().LogContext) + assert.Nil(t, err) + + taskPhase, err = sparkResourceHandler.GetTaskPhase(ctx, pluginCtx, dummySparkApplication(sj.InvalidatingState)) + assert.NoError(t, err) + assert.Equal(t, taskPhase.Phase(), pluginsCore.PhaseRunning) + assert.NotNil(t, taskPhase.Info()) + assert.Equal(t, expectedLogCtx, taskPhase.Info().LogContext) + assert.Nil(t, err) + + taskPhase, err = sparkResourceHandler.GetTaskPhase(ctx, pluginCtx, dummySparkApplication(sj.FailingState)) + assert.NoError(t, err) + assert.Equal(t, taskPhase.Phase(), pluginsCore.PhaseRunning) + assert.NotNil(t, taskPhase.Info()) + assert.Equal(t, expectedLogCtx, taskPhase.Info().LogContext) + assert.Nil(t, err) + + taskPhase, err = sparkResourceHandler.GetTaskPhase(ctx, pluginCtx, dummySparkApplication(sj.PendingRerunState)) + assert.NoError(t, err) + assert.Equal(t, taskPhase.Phase(), pluginsCore.PhaseRunning) + assert.NotNil(t, taskPhase.Info()) + assert.Equal(t, expectedLogCtx, taskPhase.Info().LogContext) + assert.Nil(t, err) + + taskPhase, err = sparkResourceHandler.GetTaskPhase(ctx, pluginCtx, dummySparkApplication(sj.SucceedingState)) + assert.NoError(t, err) + assert.Equal(t, taskPhase.Phase(), pluginsCore.PhaseRunning) + assert.NotNil(t, taskPhase.Info()) + assert.Equal(t, expectedLogCtx, taskPhase.Info().LogContext) + assert.Nil(t, err) + + taskPhase, err = sparkResourceHandler.GetTaskPhase(ctx, pluginCtx, dummySparkApplication(sj.FailedSubmissionState)) + assert.NoError(t, err) + assert.Equal(t, taskPhase.Phase(), pluginsCore.PhaseRetryableFailure) + assert.NotNil(t, taskPhase.Info()) + assert.Equal(t, expectedLogCtx, taskPhase.Info().LogContext) + assert.Nil(t, err) + + taskPhase, err = sparkResourceHandler.GetTaskPhase(ctx, pluginCtx, dummySparkApplication(sj.FailedState)) + assert.NoError(t, err) + assert.Equal(t, taskPhase.Phase(), pluginsCore.PhaseRetryableFailure) + assert.NotNil(t, taskPhase.Info()) + assert.Equal(t, expectedLogCtx, taskPhase.Info().LogContext) + assert.Nil(t, err) +} + +func TestGetTaskPhaseIncreasePhaseVersion(t *testing.T) { + sparkResourceHandler := sparkResourceHandler{} + ctx := context.TODO() + + pluginState := k8s.PluginState{ + Phase: pluginsCore.PhaseInitializing, + PhaseVersion: pluginsCore.DefaultPhaseVersion, + Reason: "task submitted to K8s", + } + + pluginCtx := dummySparkPluginContext(dummySparkTaskTemplateContainer("", dummySparkConf), pluginState) + taskPhase, err := sparkResourceHandler.GetTaskPhase(ctx, pluginCtx, dummySparkApplication(sj.SubmittedState)) + + assert.NoError(t, err) + assert.Equal(t, taskPhase.Version(), pluginsCore.DefaultPhaseVersion+1) +} + +func dummySparkApplication(state sj.ApplicationStateType) *sj.SparkApplication { + + return &sj.SparkApplication{ + ObjectMeta: v1.ObjectMeta{ + Name: "spark-app-name", + Namespace: "spark-namespace", + }, + Status: sj.SparkApplicationStatus{ + SparkApplicationID: "app-id", + AppState: sj.ApplicationState{ + State: state, + }, + DriverInfo: sj.DriverInfo{ + PodName: "spark-pod", + WebUIIngressAddress: sparkUIAddress, + }, + ExecutionAttempts: 1, + ExecutorState: map[string]sparkOp.ExecutorState{ + "exec-pod-1": sparkOp.ExecutorPendingState, + "exec-pod-2": sparkOp.ExecutorRunningState, + }, + }, + } +} + +func dummySparkCustomObj(sparkConf map[string]string) *plugins.SparkJob { + sparkJob := plugins.SparkJob{} + + sparkJob.MainClass = sparkMainClass + sparkJob.MainApplicationFile = sparkApplicationFile + sparkJob.SparkConf = sparkConf + sparkJob.ApplicationType = plugins.SparkApplication_PYTHON + return &sparkJob +} + +func dummyPodSpec() *corev1.PodSpec { + return &corev1.PodSpec{ + InitContainers: []corev1.Container{ + { + Name: "init", + Image: testImage, + Args: testArgs, + }, + }, + Containers: []corev1.Container{ + { + Name: "primary", + Image: testImage, + Args: testArgs, + Env: dummyEnvVarsWithSecretRef, + }, + { + Name: "secondary", + Image: testImage, + Args: testArgs, + Env: flytek8s.ToK8sEnvVar(dummyEnvVars), + }, + }, + } +} + +func dummySparkTaskTemplateContainer(id string, sparkConf map[string]string) *core.TaskTemplate { + sparkJob := dummySparkCustomObj(sparkConf) + sparkJobJSON, err := utils.MarshalToString(sparkJob) + if err != nil { + panic(err) + } + + structObj := structpb.Struct{} + + err = stdlibUtils.UnmarshalStringToPb(sparkJobJSON, &structObj) + if err != nil { + panic(err) + } + + return &core.TaskTemplate{ + Id: &core.Identifier{Name: id}, + Type: "container", + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Image: testImage, + Args: testArgs, + Env: dummyEnvVars, + }, + }, + Custom: &structObj, + } +} + +func dummySparkTaskTemplatePod(id string, sparkConf map[string]string, podSpec *corev1.PodSpec) *core.TaskTemplate { + sparkJob := dummySparkCustomObj(sparkConf) + sparkJobJSON, err := utils.MarshalToString(sparkJob) + if err != nil { + panic(err) + } + + structObj := structpb.Struct{} + + err = stdlibUtils.UnmarshalStringToPb(sparkJobJSON, &structObj) + if err != nil { + panic(err) + } + + podSpecPb, err := utils.MarshalObjToStruct(podSpec) + if err != nil { + panic(err) + } + + return &core.TaskTemplate{ + Id: &core.Identifier{Name: id}, + Type: "k8s_pod", + Target: &core.TaskTemplate_K8SPod{ + K8SPod: &core.K8SPod{ + PodSpec: podSpecPb, + }, + }, + Config: map[string]string{ + flytek8s.PrimaryContainerKey: "primary", + }, + Custom: &structObj, + } +} + +func dummySparkTaskContext(taskTemplate *core.TaskTemplate, interruptible bool) pluginsCore.TaskExecutionContext { + taskCtx := &mocks.TaskExecutionContext{} + inputReader := &pluginIOMocks.InputReader{} + inputReader.EXPECT().GetInputPrefixPath().Return("/input/prefix") + inputReader.EXPECT().GetInputPath().Return("/input") + inputReader.EXPECT().Get(mock.Anything).Return(&core.LiteralMap{}, nil) + taskCtx.EXPECT().InputReader().Return(inputReader) + + outputReader := &pluginIOMocks.OutputWriter{} + outputReader.EXPECT().GetOutputPath().Return("/data/outputs.pb") + outputReader.EXPECT().GetOutputPrefixPath().Return("/data/") + outputReader.EXPECT().GetRawOutputPrefix().Return("") + outputReader.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + outputReader.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + + taskCtx.EXPECT().OutputWriter().Return(outputReader) + + taskReader := &mocks.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(taskTemplate, nil) + taskCtx.EXPECT().TaskReader().Return(taskReader) + + tID := &mocks.TaskExecutionID{} + tID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my_name", + Project: "my_project", + Domain: "my_domain", + }, + }, + }) + tID.EXPECT().GetGeneratedName().Return("some-acceptable-name") + tID.EXPECT().GetUniqueNodeID().Return("an-unique-id") + + overrides := &mocks.TaskOverrides{} + overrides.EXPECT().GetResources().Return(&corev1.ResourceRequirements{}) + // No support for GPUs, and consequently, ExtendedResources on Spark plugin. + overrides.EXPECT().GetExtendedResources().Return(nil) + overrides.EXPECT().GetPodTemplate().Return(nil) + overrides.EXPECT().GetContainerImage().Return("") + + taskExecutionMetadata := &mocks.TaskExecutionMetadata{} + taskExecutionMetadata.EXPECT().GetTaskExecutionID().Return(tID) + taskExecutionMetadata.EXPECT().GetNamespace().Return("test-namespace") + taskExecutionMetadata.EXPECT().GetAnnotations().Return(map[string]string{"annotation-1": "val1"}) + taskExecutionMetadata.EXPECT().GetLabels().Return(map[string]string{"label-1": "val1"}) + taskExecutionMetadata.EXPECT().GetOwnerReference().Return(v1.OwnerReference{ + Kind: "node", + Name: "blah", + }) + taskExecutionMetadata.EXPECT().GetSecurityContext().Return(core.SecurityContext{ + RunAs: &core.Identity{K8SServiceAccount: "new-val"}, + }) + taskExecutionMetadata.EXPECT().IsInterruptible().Return(interruptible) + taskExecutionMetadata.EXPECT().GetMaxAttempts().Return(uint32(1)) + taskExecutionMetadata.EXPECT().GetEnvironmentVariables().Return(nil) + taskExecutionMetadata.EXPECT().GetPlatformResources().Return(nil) + taskExecutionMetadata.EXPECT().GetOverrides().Return(overrides) + taskExecutionMetadata.EXPECT().GetK8sServiceAccount().Return("new-val") + taskExecutionMetadata.EXPECT().GetConsoleURL().Return("") + taskCtx.EXPECT().TaskExecutionMetadata().Return(taskExecutionMetadata) + pluginStateReaderMock := mocks.PluginStateReader{} + pluginStateReaderMock.EXPECT().Get(mock.AnythingOfType(reflect.TypeOf(&k8s.PluginState{}).String())).RunAndReturn( + func(v interface{}) (uint8, error) { + *(v.(*k8s.PluginState)) = k8s.PluginState{} + return 0, nil + }) + + taskCtx.EXPECT().PluginStateReader().Return(&pluginStateReaderMock) + return taskCtx +} + +func dummySparkPluginContext(taskTemplate *core.TaskTemplate, pluginState k8s.PluginState) k8s.PluginContext { + return dummySparkPluginContextWithPods(taskTemplate, pluginState) +} + +func dummySparkPluginContextWithPods(taskTemplate *core.TaskTemplate, pluginState k8s.PluginState, pods ...client.Object) k8s.PluginContext { + pCtx := &k8smocks.PluginContext{} + inputReader := &pluginIOMocks.InputReader{} + inputReader.EXPECT().GetInputPrefixPath().Return("/input/prefix") + inputReader.EXPECT().GetInputPath().Return("/input") + inputReader.EXPECT().Get(mock.Anything).Return(&core.LiteralMap{}, nil) + pCtx.EXPECT().InputReader().Return(inputReader) + + outputReader := &pluginIOMocks.OutputWriter{} + outputReader.EXPECT().GetOutputPath().Return("/data/outputs.pb") + outputReader.EXPECT().GetOutputPrefixPath().Return("/data/") + outputReader.EXPECT().GetRawOutputPrefix().Return("") + outputReader.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + outputReader.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + + pCtx.EXPECT().OutputWriter().Return(outputReader) + + taskReader := &mocks.TaskReader{} + taskReader.EXPECT().Read(mock.Anything).Return(taskTemplate, nil) + pCtx.EXPECT().TaskReader().Return(taskReader) + + tID := &mocks.TaskExecutionID{} + tID.EXPECT().GetID().Return(core.TaskExecutionIdentifier{ + NodeExecutionId: &core.NodeExecutionIdentifier{ + ExecutionId: &core.WorkflowExecutionIdentifier{ + Name: "my_name", + Project: "my_project", + Domain: "my_domain", + }, + }, + }) + tID.EXPECT().GetGeneratedName().Return("some-acceptable-name") + tID.EXPECT().GetUniqueNodeID().Return("an-unique-id") + + overrides := &mocks.TaskOverrides{} + overrides.EXPECT().GetResources().Return(&corev1.ResourceRequirements{}) + // No support for GPUs, and consequently, ExtendedResources on Spark plugin. + overrides.EXPECT().GetExtendedResources().Return(nil) + overrides.EXPECT().GetContainerImage().Return("") + + taskExecutionMetadata := &mocks.TaskExecutionMetadata{} + taskExecutionMetadata.EXPECT().GetTaskExecutionID().Return(tID) + taskExecutionMetadata.EXPECT().GetNamespace().Return("test-namespace") + taskExecutionMetadata.EXPECT().GetAnnotations().Return(map[string]string{"annotation-1": "val1"}) + taskExecutionMetadata.EXPECT().GetLabels().Return(map[string]string{"label-1": "val1"}) + taskExecutionMetadata.EXPECT().GetOwnerReference().Return(v1.OwnerReference{ + Kind: "node", + Name: "blah", + }) + taskExecutionMetadata.EXPECT().GetSecurityContext().Return(core.SecurityContext{ + RunAs: &core.Identity{K8SServiceAccount: "new-val"}, + }) + taskExecutionMetadata.EXPECT().IsInterruptible().Return(false) + taskExecutionMetadata.EXPECT().GetMaxAttempts().Return(uint32(1)) + taskExecutionMetadata.EXPECT().GetEnvironmentVariables().Return(nil) + taskExecutionMetadata.EXPECT().GetPlatformResources().Return(nil) + taskExecutionMetadata.EXPECT().GetOverrides().Return(overrides) + taskExecutionMetadata.EXPECT().GetK8sServiceAccount().Return("new-val") + taskExecutionMetadata.EXPECT().GetConsoleURL().Return("") + pCtx.EXPECT().TaskExecutionMetadata().Return(taskExecutionMetadata) + + pluginStateReaderMock := mocks.PluginStateReader{} + pluginStateReaderMock.EXPECT().Get(mock.AnythingOfType(reflect.TypeOf(&pluginState).String())).RunAndReturn( + func(v interface{}) (uint8, error) { + *(v.(*k8s.PluginState)) = pluginState + return 0, nil + }) + + // Add K8sReader mock for pods + objs := make([]client.Object, len(pods)) + copy(objs, pods) + reader := fake.NewClientBuilder().WithObjects(objs...).Build() + pCtx.EXPECT().K8sReader().Return(reader) + + pCtx.EXPECT().PluginStateReader().Return(&pluginStateReaderMock) + return pCtx +} + +func defaultPluginConfig() *config.K8sPluginConfig { + // Set Interruptible Config + runAsUser := int64(1000) + dnsOptVal1 := "1" + dnsOptVal2 := "1" + dnsOptVal3 := "3" + + // Set scheduler + schedulerName := "custom-scheduler" + + // Node selectors + defaultNodeSelector := map[string]string{ + "x/default": "true", + } + interruptibleNodeSelector := map[string]string{ + "x/interruptible": "true", + } + + defaultPodHostNetwork := true + + // Default env vars passed explicitly and default env vars derived from environment + defaultEnvVars := make(map[string]string) + defaultEnvVars["foo"] = "bar" + + defaultEnvVarsFromEnv := make(map[string]string) + targetKeyFromEnv := "TEST_VAR_FROM_ENV_KEY" + targetValueFromEnv := "TEST_VAR_FROM_ENV_VALUE" + os.Setenv(targetKeyFromEnv, targetValueFromEnv) + defer os.Unsetenv(targetKeyFromEnv) + defaultEnvVarsFromEnv["fooEnv"] = targetKeyFromEnv + + // Default affinity/anti-affinity + defaultAffinity := &corev1.Affinity{ + NodeAffinity: &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchExpressions: []corev1.NodeSelectorRequirement{ + { + Key: "x/default", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"true"}, + }, + }, + }, + }, + }, + }, + } + + // Interruptible/non-interruptible nodeselector requirement + interruptibleNodeSelectorRequirement := &corev1.NodeSelectorRequirement{ + Key: "x/interruptible", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"true"}, + } + + nonInterruptibleNodeSelectorRequirement := &corev1.NodeSelectorRequirement{ + Key: "x/non-interruptible", + Operator: corev1.NodeSelectorOpIn, + Values: []string{"true"}, + } + + config := &config.K8sPluginConfig{ + DefaultAffinity: defaultAffinity, + DefaultPodSecurityContext: &corev1.PodSecurityContext{ + RunAsUser: &runAsUser, + }, + DefaultPodDNSConfig: &corev1.PodDNSConfig{ + Nameservers: []string{"8.8.8.8", "8.8.4.4"}, + Options: []corev1.PodDNSConfigOption{ + { + Name: "ndots", + Value: &dnsOptVal1, + }, + { + Name: "single-request-reopen", + }, + { + Name: "timeout", + Value: &dnsOptVal2, + }, + { + Name: "attempts", + Value: &dnsOptVal3, + }, + }, + Searches: []string{"ns1.svc.cluster-domain.example", "my.dns.search.suffix"}, + }, + DefaultTolerations: []corev1.Toleration{ + { + Key: "x/flyte", + Value: "default", + Operator: "Equal", + Effect: "NoSchedule", + }, + }, + DefaultNodeSelector: defaultNodeSelector, + InterruptibleNodeSelector: interruptibleNodeSelector, + InterruptibleTolerations: []corev1.Toleration{ + { + Key: "x/flyte", + Value: "interruptible", + Operator: "Equal", + Effect: "NoSchedule", + }, + }, + InterruptibleNodeSelectorRequirement: interruptibleNodeSelectorRequirement, + NonInterruptibleNodeSelectorRequirement: nonInterruptibleNodeSelectorRequirement, + SchedulerName: schedulerName, + EnableHostNetworkingPod: &defaultPodHostNetwork, + DefaultEnvVars: defaultEnvVars, + DefaultEnvVarsFromEnv: defaultEnvVarsFromEnv, + } + return config +} + +func findEnvVarByName(envVars []corev1.EnvVar, name string) *corev1.EnvVar { + for _, envVar := range envVars { + if envVar.Name == name { + return &envVar + } + } + return nil +} + +func TestBuildResourceContainer(t *testing.T) { + sparkResourceHandler := sparkResourceHandler{} + + // Case1: Valid Spark Task-Template + taskTemplate := dummySparkTaskTemplateContainer("blah-1", dummySparkConf) + + // Set spark custom feature config. + assert.NoError(t, setSparkConfig(&Config{ + Features: []Feature{ + { + Name: "feature1", + SparkConfig: map[string]string{"spark.hadoop.feature1": "true"}, + }, + { + Name: "feature2", + SparkConfig: map[string]string{"spark.hadoop.feature2": "true"}, + }, + }, + })) + + defaultConfig := defaultPluginConfig() + assert.NoError(t, config.SetK8sPluginConfig(defaultConfig)) + resource, err := sparkResourceHandler.BuildResource(context.TODO(), dummySparkTaskContext(taskTemplate, true)) + assert.Nil(t, err) + + assert.NotNil(t, resource) + sparkApp, ok := resource.(*sj.SparkApplication) + assert.True(t, ok) + assert.Equal(t, sparkMainClass, *sparkApp.Spec.MainClass) + assert.Equal(t, sparkApplicationFile, *sparkApp.Spec.MainApplicationFile) + assert.Equal(t, sj.PythonApplicationType, sparkApp.Spec.Type) + assert.Equal(t, testArgs, sparkApp.Spec.Arguments) + assert.Equal(t, testImage, *sparkApp.Spec.Image) + assert.NotNil(t, sparkApp.Spec.Driver.SparkPodSpec.SecurityContenxt) + assert.Equal(t, *sparkApp.Spec.Driver.SparkPodSpec.SecurityContenxt.RunAsUser, *defaultConfig.DefaultPodSecurityContext.RunAsUser) + assert.NotNil(t, sparkApp.Spec.Driver.DNSConfig) + assert.Equal(t, []string{"8.8.8.8", "8.8.4.4"}, sparkApp.Spec.Driver.DNSConfig.Nameservers) + assert.ElementsMatch(t, defaultConfig.DefaultPodDNSConfig.Options, sparkApp.Spec.Driver.DNSConfig.Options) + assert.Equal(t, []string{"ns1.svc.cluster-domain.example", "my.dns.search.suffix"}, sparkApp.Spec.Driver.DNSConfig.Searches) + assert.NotNil(t, sparkApp.Spec.Executor.SparkPodSpec.SecurityContenxt) + assert.Equal(t, *sparkApp.Spec.Executor.SparkPodSpec.SecurityContenxt.RunAsUser, *defaultConfig.DefaultPodSecurityContext.RunAsUser) + assert.NotNil(t, sparkApp.Spec.Executor.DNSConfig) + assert.NotNil(t, sparkApp.Spec.Executor.DNSConfig) + assert.ElementsMatch(t, defaultConfig.DefaultPodDNSConfig.Options, sparkApp.Spec.Executor.DNSConfig.Options) + assert.Equal(t, []string{"ns1.svc.cluster-domain.example", "my.dns.search.suffix"}, sparkApp.Spec.Executor.DNSConfig.Searches) + + //Validate Driver/Executor Spec. + driverCores, _ := strconv.ParseInt(dummySparkConf["spark.driver.cores"], 10, 32) + execCores, _ := strconv.ParseInt(dummySparkConf["spark.executor.cores"], 10, 32) + execInstances, _ := strconv.ParseInt(dummySparkConf["spark.executor.instances"], 10, 32) + + assert.Equal(t, "new-val", *sparkApp.Spec.ServiceAccount) + assert.Equal(t, int32(driverCores), *sparkApp.Spec.Driver.Cores) + assert.Equal(t, int32(execCores), *sparkApp.Spec.Executor.Cores) + assert.Equal(t, int32(execInstances), *sparkApp.Spec.Executor.Instances) + assert.Equal(t, dummySparkConf["spark.driver.memory"], *sparkApp.Spec.Driver.Memory) + assert.Equal(t, dummySparkConf["spark.executor.memory"], *sparkApp.Spec.Executor.Memory) + assert.Equal(t, dummySparkConf["spark.batchScheduler"], *sparkApp.Spec.BatchScheduler) + assert.Equal(t, defaultConfig.SchedulerName, *sparkApp.Spec.Executor.SchedulerName) + assert.Equal(t, defaultConfig.SchedulerName, *sparkApp.Spec.Driver.SchedulerName) + assert.Equal(t, *defaultConfig.EnableHostNetworkingPod, *sparkApp.Spec.Executor.HostNetwork) + assert.Equal(t, *defaultConfig.EnableHostNetworkingPod, *sparkApp.Spec.Driver.HostNetwork) + + // Validate + // * Default tolerations set for both Driver and Executor. + // * Interruptible tolerations and node selector set for Executor but not Driver. + // * Default node selector set for both Driver and Executor. + // * Interruptible node selector requirements set for Executor Affinity, non-interruptiblefir Driver Affinity. + assert.Equal(t, 1, len(sparkApp.Spec.Driver.Tolerations)) + assert.Equal(t, 1, len(sparkApp.Spec.Driver.NodeSelector)) + assert.Equal(t, defaultConfig.DefaultNodeSelector, sparkApp.Spec.Driver.NodeSelector) + tolDriverDefault := sparkApp.Spec.Driver.Tolerations[0] + assert.Equal(t, tolDriverDefault.Key, "x/flyte") + assert.Equal(t, tolDriverDefault.Value, "default") + assert.Equal(t, tolDriverDefault.Operator, corev1.TolerationOperator("Equal")) + assert.Equal(t, tolDriverDefault.Effect, corev1.TaintEffect("NoSchedule")) + + assert.Equal(t, 2, len(sparkApp.Spec.Executor.Tolerations)) + assert.Equal(t, 2, len(sparkApp.Spec.Executor.NodeSelector)) + assert.Equal(t, map[string]string{ + "x/default": "true", + "x/interruptible": "true", + }, sparkApp.Spec.Executor.NodeSelector) + + tolExecInterrupt := sparkApp.Spec.Executor.Tolerations[0] + assert.Equal(t, tolExecInterrupt.Key, "x/flyte") + assert.Equal(t, tolExecInterrupt.Value, "interruptible") + assert.Equal(t, tolExecInterrupt.Operator, corev1.TolerationOperator("Equal")) + assert.Equal(t, tolExecInterrupt.Effect, corev1.TaintEffect("NoSchedule")) + + tolExecDefault := sparkApp.Spec.Executor.Tolerations[1] + assert.Equal(t, tolExecDefault.Key, "x/flyte") + assert.Equal(t, tolExecDefault.Value, "default") + assert.Equal(t, tolExecDefault.Operator, corev1.TolerationOperator("Equal")) + assert.Equal(t, tolExecDefault.Effect, corev1.TaintEffect("NoSchedule")) + + for confKey, confVal := range dummySparkConf { + exists := false + + if featureRegex.MatchString(confKey) && confKey != "spark.flyteorg.feature3.enabled" { + match := featureRegex.FindAllStringSubmatch(confKey, -1) + feature := match[0][len(match[0])-1] + assert.True(t, feature == "feature1" || feature == "feature2") + for k, v := range sparkApp.Spec.SparkConf { + key := "spark.hadoop." + feature + if k == key { + assert.Equal(t, v, "true") + exists = true + } + } + } else { + for k, v := range sparkApp.Spec.SparkConf { + + if k == confKey { + assert.Equal(t, v, confVal) + exists = true + } + } + } + assert.True(t, exists) + } + + assert.Equal(t, dummySparkConf["spark.driver.cores"], sparkApp.Spec.SparkConf["spark.kubernetes.driver.limit.cores"]) + assert.Equal(t, dummySparkConf["spark.executor.cores"], sparkApp.Spec.SparkConf["spark.kubernetes.executor.limit.cores"]) + assert.Greater(t, len(sparkApp.Spec.SparkConf["spark.kubernetes.driverEnv.FLYTE_START_TIME"]), 1) + assert.Equal(t, dummySparkConf["spark.flyteorg.feature3.enabled"], sparkApp.Spec.SparkConf["spark.flyteorg.feature3.enabled"]) + + assert.Equal(t, len(findEnvVarByName(sparkApp.Spec.Driver.Env, "FLYTE_MAX_ATTEMPTS").Value), 1) + assert.Equal(t, defaultConfig.DefaultEnvVars["foo"], findEnvVarByName(sparkApp.Spec.Driver.Env, "foo").Value) + assert.Equal(t, defaultConfig.DefaultEnvVars["foo"], findEnvVarByName(sparkApp.Spec.Executor.Env, "foo").Value) + assert.Equal(t, defaultConfig.DefaultEnvVars["fooEnv"], findEnvVarByName(sparkApp.Spec.Driver.Env, "fooEnv").Value) + assert.Equal(t, defaultConfig.DefaultEnvVars["fooEnv"], findEnvVarByName(sparkApp.Spec.Executor.Env, "fooEnv").Value) + + assert.Equal(t, &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchExpressions: []corev1.NodeSelectorRequirement{ + defaultConfig.DefaultAffinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms[0].MatchExpressions[0], + *defaultConfig.NonInterruptibleNodeSelectorRequirement, + }, + }, + }, + }, + }, sparkApp.Spec.Driver.Affinity.NodeAffinity) + + assert.Equal(t, &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchExpressions: []corev1.NodeSelectorRequirement{ + defaultConfig.DefaultAffinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms[0].MatchExpressions[0], + *defaultConfig.InterruptibleNodeSelectorRequirement, + }, + }, + }, + }, + }, sparkApp.Spec.Executor.Affinity.NodeAffinity) + + // Case 2: Driver/Executor request cores set. + dummyConfWithRequest := make(map[string]string) + + for k, v := range dummySparkConf { + dummyConfWithRequest[k] = v + } + + dummyConfWithRequest["spark.kubernetes.driver.request.cores"] = "3" + dummyConfWithRequest["spark.kubernetes.executor.request.cores"] = "4" + + taskTemplate = dummySparkTaskTemplateContainer("blah-1", dummyConfWithRequest) + resource, err = sparkResourceHandler.BuildResource(context.TODO(), dummySparkTaskContext(taskTemplate, false)) + assert.Nil(t, err) + assert.NotNil(t, resource) + sparkApp, ok = resource.(*sj.SparkApplication) + assert.True(t, ok) + + assert.Equal(t, dummyConfWithRequest["spark.kubernetes.driver.request.cores"], sparkApp.Spec.SparkConf["spark.kubernetes.driver.limit.cores"]) + assert.Equal(t, dummyConfWithRequest["spark.kubernetes.executor.request.cores"], sparkApp.Spec.SparkConf["spark.kubernetes.executor.limit.cores"]) + + // Case 3: Interruptible False + resource, err = sparkResourceHandler.BuildResource(context.TODO(), dummySparkTaskContext(taskTemplate, false)) + assert.Nil(t, err) + assert.NotNil(t, resource) + sparkApp, ok = resource.(*sj.SparkApplication) + assert.True(t, ok) + + // Validate Interruptible Toleration and NodeSelector not set for both Driver and Executors. + // Validate that the default Toleration and NodeSelector are set for both Driver and Executors. + assert.Equal(t, 1, len(sparkApp.Spec.Driver.Tolerations)) + assert.Equal(t, 1, len(sparkApp.Spec.Driver.NodeSelector)) + assert.Equal(t, defaultConfig.DefaultNodeSelector, sparkApp.Spec.Driver.NodeSelector) + assert.Equal(t, 1, len(sparkApp.Spec.Executor.Tolerations)) + assert.Equal(t, 1, len(sparkApp.Spec.Executor.NodeSelector)) + assert.Equal(t, defaultConfig.DefaultNodeSelector, sparkApp.Spec.Executor.NodeSelector) + assert.Equal(t, sparkApp.Spec.Executor.Tolerations[0].Key, "x/flyte") + assert.Equal(t, sparkApp.Spec.Executor.Tolerations[0].Value, "default") + assert.Equal(t, sparkApp.Spec.Driver.Tolerations[0].Key, "x/flyte") + assert.Equal(t, sparkApp.Spec.Driver.Tolerations[0].Value, "default") + + // Validate correct affinity and nodeselector requirements are set for both Driver and Executors. + assert.Equal(t, &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchExpressions: []corev1.NodeSelectorRequirement{ + defaultConfig.DefaultAffinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms[0].MatchExpressions[0], + *defaultConfig.NonInterruptibleNodeSelectorRequirement, + }, + }, + }, + }, + }, sparkApp.Spec.Driver.Affinity.NodeAffinity) + + assert.Equal(t, &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchExpressions: []corev1.NodeSelectorRequirement{ + defaultConfig.DefaultAffinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms[0].MatchExpressions[0], + *defaultConfig.NonInterruptibleNodeSelectorRequirement, + }, + }, + }, + }, + }, sparkApp.Spec.Executor.Affinity.NodeAffinity) + + // Case 4: Invalid Spark Task-Template + taskTemplate.Custom = nil + resource, err = sparkResourceHandler.BuildResource(context.TODO(), dummySparkTaskContext(taskTemplate, false)) + assert.NotNil(t, err) + assert.Nil(t, resource) +} + +func TestBuildResourcePodTemplate(t *testing.T) { + defaultConfig := defaultPluginConfig() + assert.NoError(t, config.SetK8sPluginConfig(defaultConfig)) + extraToleration := corev1.Toleration{ + Key: "x/flyte", + Value: "extra", + Operator: "Equal", + } + podSpec := dummyPodSpec() + podSpec.Tolerations = append(podSpec.Tolerations, extraToleration) + podSpec.NodeSelector = map[string]string{"x/custom": "foo"} + taskTemplate := dummySparkTaskTemplatePod("blah-1", dummySparkConf, podSpec) + taskTemplate.GetK8SPod() + sparkResourceHandler := sparkResourceHandler{} + + taskCtx := dummySparkTaskContext(taskTemplate, true) + resource, err := sparkResourceHandler.BuildResource(context.TODO(), taskCtx) + + assert.Nil(t, err) + assert.NotNil(t, resource) + sparkApp, ok := resource.(*sj.SparkApplication) + assert.True(t, ok) + + // Application + assert.Equal(t, v1.TypeMeta{ + Kind: KindSparkApplication, + APIVersion: sparkOp.SchemeGroupVersion.String(), + }, sparkApp.TypeMeta) + + // Application spec + assert.Equal(t, flytek8s.GetServiceAccountNameFromTaskExecutionMetadata(taskCtx.TaskExecutionMetadata()), *sparkApp.Spec.ServiceAccount) + assert.Equal(t, sparkOp.PythonApplicationType, sparkApp.Spec.Type) + assert.Equal(t, testImage, *sparkApp.Spec.Image) + assert.Equal(t, testArgs, sparkApp.Spec.Arguments) + assert.Equal(t, sparkOp.RestartPolicy{ + Type: sparkOp.OnFailure, + OnSubmissionFailureRetries: intPtr(int32(14)), + }, sparkApp.Spec.RestartPolicy) + assert.Equal(t, sparkMainClass, *sparkApp.Spec.MainClass) + assert.Equal(t, sparkApplicationFile, *sparkApp.Spec.MainApplicationFile) + + // Driver + assert.Equal(t, utils.UnionMaps(defaultConfig.DefaultAnnotations, map[string]string{"annotation-1": "val1"}), sparkApp.Spec.Driver.Annotations) + assert.Equal(t, utils.UnionMaps(defaultConfig.DefaultLabels, map[string]string{"label-1": "val1"}), sparkApp.Spec.Driver.Labels) + assert.Equal(t, len(findEnvVarByName(sparkApp.Spec.Driver.Env, "FLYTE_MAX_ATTEMPTS").Value), 1) + assert.Equal(t, defaultConfig.DefaultEnvVars["foo"], findEnvVarByName(sparkApp.Spec.Driver.Env, "foo").Value) + assert.Equal(t, defaultConfig.DefaultEnvVars["fooEnv"], findEnvVarByName(sparkApp.Spec.Driver.Env, "fooEnv").Value) + assert.Equal(t, findEnvVarByName(dummyEnvVarsWithSecretRef, "SECRET"), findEnvVarByName(sparkApp.Spec.Driver.Env, "SECRET")) + assert.Equal(t, 10, len(sparkApp.Spec.Driver.Env)) + assert.Equal(t, testImage, *sparkApp.Spec.Driver.Image) + assert.Equal(t, flytek8s.GetServiceAccountNameFromTaskExecutionMetadata(taskCtx.TaskExecutionMetadata()), *sparkApp.Spec.Driver.ServiceAccount) + assert.Equal(t, defaultConfig.DefaultPodSecurityContext, sparkApp.Spec.Driver.SecurityContenxt) + assert.Equal(t, defaultConfig.DefaultPodDNSConfig, sparkApp.Spec.Driver.DNSConfig) + assert.Equal(t, defaultConfig.EnableHostNetworkingPod, sparkApp.Spec.Driver.HostNetwork) + assert.Equal(t, defaultConfig.SchedulerName, *sparkApp.Spec.Driver.SchedulerName) + assert.Equal(t, []corev1.Toleration{ + defaultConfig.DefaultTolerations[0], + extraToleration, + }, sparkApp.Spec.Driver.Tolerations) + assert.Equal(t, map[string]string{ + "x/default": "true", + "x/custom": "foo", + }, sparkApp.Spec.Driver.NodeSelector) + assert.Equal(t, &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchExpressions: []corev1.NodeSelectorRequirement{ + defaultConfig.DefaultAffinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms[0].MatchExpressions[0], + *defaultConfig.NonInterruptibleNodeSelectorRequirement, + }, + }, + }, + }, + }, sparkApp.Spec.Driver.Affinity.NodeAffinity) + cores, _ := strconv.ParseInt(dummySparkConf["spark.driver.cores"], 10, 32) + assert.Equal(t, intPtr(int32(cores)), sparkApp.Spec.Driver.Cores) + assert.Equal(t, dummySparkConf["spark.driver.memory"], *sparkApp.Spec.Driver.Memory) + + // Executor + assert.Equal(t, utils.UnionMaps(defaultConfig.DefaultAnnotations, map[string]string{"annotation-1": "val1"}), sparkApp.Spec.Executor.Annotations) + assert.Equal(t, utils.UnionMaps(defaultConfig.DefaultLabels, map[string]string{"label-1": "val1"}), sparkApp.Spec.Executor.Labels) + assert.Equal(t, defaultConfig.DefaultEnvVars["foo"], findEnvVarByName(sparkApp.Spec.Executor.Env, "foo").Value) + assert.Equal(t, defaultConfig.DefaultEnvVars["fooEnv"], findEnvVarByName(sparkApp.Spec.Executor.Env, "fooEnv").Value) + assert.Equal(t, findEnvVarByName(dummyEnvVarsWithSecretRef, "SECRET"), findEnvVarByName(sparkApp.Spec.Executor.Env, "SECRET")) + assert.Equal(t, 10, len(sparkApp.Spec.Executor.Env)) + assert.Equal(t, testImage, *sparkApp.Spec.Executor.Image) + assert.Equal(t, defaultConfig.DefaultPodSecurityContext, sparkApp.Spec.Executor.SecurityContenxt) + assert.Equal(t, defaultConfig.DefaultPodDNSConfig, sparkApp.Spec.Executor.DNSConfig) + assert.Equal(t, defaultConfig.EnableHostNetworkingPod, sparkApp.Spec.Executor.HostNetwork) + assert.Equal(t, defaultConfig.SchedulerName, *sparkApp.Spec.Executor.SchedulerName) + assert.ElementsMatch(t, []corev1.Toleration{ + defaultConfig.DefaultTolerations[0], + extraToleration, + defaultConfig.InterruptibleTolerations[0], + }, sparkApp.Spec.Executor.Tolerations) + assert.Equal(t, map[string]string{ + "x/default": "true", + "x/custom": "foo", + "x/interruptible": "true", + }, sparkApp.Spec.Executor.NodeSelector) + assert.Equal(t, &corev1.NodeAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{ + NodeSelectorTerms: []corev1.NodeSelectorTerm{ + { + MatchExpressions: []corev1.NodeSelectorRequirement{ + defaultConfig.DefaultAffinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms[0].MatchExpressions[0], + *defaultConfig.InterruptibleNodeSelectorRequirement, + }, + }, + }, + }, + }, sparkApp.Spec.Executor.Affinity.NodeAffinity) + cores, _ = strconv.ParseInt(dummySparkConf["spark.executor.cores"], 10, 32) + instances, _ := strconv.ParseInt(dummySparkConf["spark.executor.instances"], 10, 32) + assert.Equal(t, intPtr(int32(instances)), sparkApp.Spec.Executor.Instances) + assert.Equal(t, intPtr(int32(cores)), sparkApp.Spec.Executor.Cores) + assert.Equal(t, dummySparkConf["spark.executor.memory"], *sparkApp.Spec.Executor.Memory) +} + +func TestGetPropertiesSpark(t *testing.T) { + sparkResourceHandler := sparkResourceHandler{} + expected := k8s.PluginProperties{} + assert.Equal(t, expected, sparkResourceHandler.GetProperties()) +} + +func TestGetTaskPhaseWithNamespaceInLogContext(t *testing.T) { + sparkResourceHandler := sparkResourceHandler{} + ctx := context.TODO() + + pluginCtx := dummySparkPluginContext(dummySparkTaskTemplateContainer("", dummySparkConf), k8s.PluginState{}) + taskPhase, err := sparkResourceHandler.GetTaskPhase(ctx, pluginCtx, dummySparkApplication(sj.RunningState)) + assert.NoError(t, err) + assert.NotNil(t, taskPhase.Info()) + assert.NotNil(t, taskPhase.Info().LogContext) + assert.Equal(t, 2, len(taskPhase.Info().LogContext.Pods)) + + // Verify namespace is set in the driver pod log context + driverPodLogContext := taskPhase.Info().LogContext.Pods[0] + assert.Equal(t, "spark-namespace", driverPodLogContext.Namespace) + assert.Equal(t, "spark-pod", driverPodLogContext.PodName) + assert.Equal(t, defaultDriverPrimaryContainerName, driverPodLogContext.PrimaryContainerName) +} + +func TestGetTaskPhaseWithFailedPod(t *testing.T) { + sparkResourceHandler := sparkResourceHandler{} + ctx := context.TODO() + + // Create a failed driver pod + pod := &corev1.Pod{ + ObjectMeta: v1.ObjectMeta{ + Name: "spark-pod", + Namespace: "spark-namespace", + }, + Status: corev1.PodStatus{ + Phase: corev1.PodFailed, + ContainerStatuses: []corev1.ContainerStatus{ + { + Name: defaultDriverPrimaryContainerName, + State: corev1.ContainerState{ + Terminated: &corev1.ContainerStateTerminated{ + ExitCode: 1, + Reason: "Error", + Message: "Container failed", + }, + }, + }, + }, + }, + } + + pluginCtx := dummySparkPluginContextWithPods(dummySparkTaskTemplateContainer("", dummySparkConf), k8s.PluginState{}, pod) + + // Even though SparkApplication status is running, should return failure due to pod status + taskPhase, err := sparkResourceHandler.GetTaskPhase(ctx, pluginCtx, dummySparkApplication(sj.RunningState)) + assert.NoError(t, err) + assert.True(t, taskPhase.Phase().IsFailure()) +} + +func TestGetTaskPhaseWithPendingPodInvalidImage(t *testing.T) { + sparkResourceHandler := sparkResourceHandler{} + ctx := context.TODO() + + // Create a pending driver pod with InvalidImageName - this should fail immediately + pod := &corev1.Pod{ + ObjectMeta: v1.ObjectMeta{ + Name: "spark-pod", + Namespace: "spark-namespace", + }, + Status: corev1.PodStatus{ + Phase: corev1.PodPending, + Conditions: []corev1.PodCondition{ + { + Type: corev1.PodReady, + Status: corev1.ConditionFalse, + LastTransitionTime: v1.Time{Time: time.Now()}, + Reason: "ContainersNotReady", + Message: "containers with unready status: [spark-kubernetes-driver]", + }, + }, + ContainerStatuses: []corev1.ContainerStatus{ + { + Name: defaultDriverPrimaryContainerName, + Ready: false, + State: corev1.ContainerState{ + Waiting: &corev1.ContainerStateWaiting{ + Reason: "InvalidImageName", + Message: "Invalid image name", + }, + }, + }, + }, + }, + } + + pluginCtx := dummySparkPluginContextWithPods(dummySparkTaskTemplateContainer("", dummySparkConf), k8s.PluginState{}, pod) + + taskPhase, err := sparkResourceHandler.GetTaskPhase(ctx, pluginCtx, dummySparkApplication(sj.SubmittedState)) + assert.NoError(t, err) + // Should detect the InvalidImageName and return a failure phase + assert.True(t, taskPhase.Phase().IsFailure()) +} + +func TestGetTaskPhaseContainerNameConstant(t *testing.T) { + sparkResourceHandler := sparkResourceHandler{} + ctx := context.TODO() + + pluginCtx := dummySparkPluginContext(dummySparkTaskTemplateContainer("", dummySparkConf), k8s.PluginState{}) + + taskPhase, err := sparkResourceHandler.GetTaskPhase(ctx, pluginCtx, dummySparkApplication(sj.CompletedState)) + assert.NoError(t, err) + assert.NotNil(t, taskPhase.Info()) + assert.NotNil(t, taskPhase.Info().LogContext) + + // Verify the constant is used for driver container names + driverPodLogContext := taskPhase.Info().LogContext.Pods[0] + assert.Equal(t, defaultDriverPrimaryContainerName, driverPodLogContext.PrimaryContainerName) + assert.Equal(t, 1, len(driverPodLogContext.Containers)) + assert.Equal(t, defaultDriverPrimaryContainerName, driverPodLogContext.Containers[0].ContainerName) +} + +func TestIsTerminal(t *testing.T) { + sparkResourceHandler := sparkResourceHandler{} + ctx := context.Background() + + tests := []struct { + name string + state sj.ApplicationStateType + expectedResult bool + }{ + {"Completed", sj.CompletedState, true}, + {"Failed", sj.FailedState, true}, + {"FailedSubmission", sj.FailedSubmissionState, true}, + {"New", sj.NewState, false}, + {"Submitted", sj.SubmittedState, false}, + {"Running", sj.RunningState, false}, + {"PendingRerun", sj.PendingRerunState, false}, + {"Invalidating", sj.InvalidatingState, false}, + {"Succeeding", sj.SucceedingState, false}, + {"Failing", sj.FailingState, false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + app := dummySparkApplication(tt.state) + result, err := sparkResourceHandler.IsTerminal(ctx, app) + assert.NoError(t, err) + assert.Equal(t, tt.expectedResult, result) + }) + } +} + +func TestIsTerminal_WrongResourceType(t *testing.T) { + sparkResourceHandler := sparkResourceHandler{} + ctx := context.Background() + + var wrongResource client.Object = &corev1.ConfigMap{} + result, err := sparkResourceHandler.IsTerminal(ctx, wrongResource) + assert.Error(t, err) + assert.False(t, result) + assert.Contains(t, err.Error(), "unexpected resource type") +} + +func TestGetCompletionTime(t *testing.T) { + sparkResourceHandler := sparkResourceHandler{} + + now := time.Now().Truncate(time.Second) + earlier := now.Add(-1 * time.Hour) + evenEarlier := now.Add(-2 * time.Hour) + + tests := []struct { + name string + app *sj.SparkApplication + expectedTime time.Time + }{ + { + name: "uses TerminationTime", + app: &sj.SparkApplication{ + ObjectMeta: v1.ObjectMeta{ + CreationTimestamp: v1.NewTime(evenEarlier), + }, + Status: sj.SparkApplicationStatus{ + TerminationTime: v1.NewTime(now), + SubmissionTime: v1.NewTime(earlier), + }, + }, + expectedTime: now, + }, + { + name: "falls back to SubmissionTime", + app: &sj.SparkApplication{ + ObjectMeta: v1.ObjectMeta{ + CreationTimestamp: v1.NewTime(evenEarlier), + }, + Status: sj.SparkApplicationStatus{ + SubmissionTime: v1.NewTime(now), + }, + }, + expectedTime: now, + }, + { + name: "falls back to CreationTimestamp", + app: &sj.SparkApplication{ + ObjectMeta: v1.ObjectMeta{ + CreationTimestamp: v1.NewTime(now), + }, + Status: sj.SparkApplicationStatus{}, + }, + expectedTime: now, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result, err := sparkResourceHandler.GetCompletionTime(tt.app) + assert.NoError(t, err) + assert.Equal(t, tt.expectedTime.Unix(), result.Unix()) + }) + } +} + +func TestGetCompletionTime_WrongResourceType(t *testing.T) { + sparkResourceHandler := sparkResourceHandler{} + + var wrongResource client.Object = &corev1.ConfigMap{} + result, err := sparkResourceHandler.GetCompletionTime(wrongResource) + assert.Error(t, err) + assert.True(t, result.IsZero()) + assert.Contains(t, err.Error(), "unexpected resource type") +} diff --git a/flyteplugins/go/tasks/plugins/testing/config.go b/flyteplugins/go/tasks/plugins/testing/config.go new file mode 100644 index 0000000000..7aebb85d5b --- /dev/null +++ b/flyteplugins/go/tasks/plugins/testing/config.go @@ -0,0 +1,23 @@ +package testing + +import ( + "time" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/config" + flytestdconfig "github.com/flyteorg/flyte/v2/flytestdlib/config" +) + +//go:generate pflags Config --default-var=defaultConfig + +var ( + defaultConfig = Config{ + SleepDuration: flytestdconfig.Duration{Duration: 0 * time.Second}, + } + + ConfigSection = config.MustRegisterSubSection(echoTaskType, &defaultConfig) +) + +type Config struct { + // SleepDuration indicates the amount of time before transitioning to success + SleepDuration flytestdconfig.Duration `json:"sleep-duration" pflag:",Indicates the amount of time before transitioning to success"` +} diff --git a/flyteplugins/go/tasks/plugins/testing/config_flags.go b/flyteplugins/go/tasks/plugins/testing/config_flags.go new file mode 100755 index 0000000000..f4b2e60c7a --- /dev/null +++ b/flyteplugins/go/tasks/plugins/testing/config_flags.go @@ -0,0 +1,55 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package testing + +import ( + "encoding/json" + "reflect" + + "fmt" + + "github.com/spf13/pflag" +) + +// If v is a pointer, it will get its element value or the zero value of the element type. +// If v is not a pointer, it will return it as is. +func (Config) elemValueOrNil(v interface{}) interface{} { + if t := reflect.TypeOf(v); t.Kind() == reflect.Ptr { + if reflect.ValueOf(v).IsNil() { + return reflect.Zero(t.Elem()).Interface() + } else { + return reflect.ValueOf(v).Interface() + } + } else if v == nil { + return reflect.Zero(t).Interface() + } + + return v +} + +func (Config) mustJsonMarshal(v interface{}) string { + raw, err := json.Marshal(v) + if err != nil { + panic(err) + } + + return string(raw) +} + +func (Config) mustMarshalJSON(v json.Marshaler) string { + raw, err := v.MarshalJSON() + if err != nil { + panic(err) + } + + return string(raw) +} + +// GetPFlagSet will return strongly types pflags for all fields in Config and its nested types. The format of the +// flags is json-name.json-sub-name... etc. +func (cfg Config) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("Config", pflag.ExitOnError) + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "sleep-duration"), defaultConfig.SleepDuration.String(), "Indicates the amount of time before transitioning to success") + return cmdFlags +} diff --git a/flyteplugins/go/tasks/plugins/testing/config_flags_test.go b/flyteplugins/go/tasks/plugins/testing/config_flags_test.go new file mode 100755 index 0000000000..023e8986e0 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/testing/config_flags_test.go @@ -0,0 +1,116 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package testing + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "testing" + + "github.com/mitchellh/mapstructure" + "github.com/stretchr/testify/assert" +) + +var dereferencableKindsConfig = map[reflect.Kind]struct{}{ + reflect.Array: {}, reflect.Chan: {}, reflect.Map: {}, reflect.Ptr: {}, reflect.Slice: {}, +} + +// Checks if t is a kind that can be dereferenced to get its underlying type. +func canGetElementConfig(t reflect.Kind) bool { + _, exists := dereferencableKindsConfig[t] + return exists +} + +// This decoder hook tests types for json unmarshaling capability. If implemented, it uses json unmarshal to build the +// object. Otherwise, it'll just pass on the original data. +func jsonUnmarshalerHookConfig(_, to reflect.Type, data interface{}) (interface{}, error) { + unmarshalerType := reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + if to.Implements(unmarshalerType) || reflect.PtrTo(to).Implements(unmarshalerType) || + (canGetElementConfig(to.Kind()) && to.Elem().Implements(unmarshalerType)) { + + raw, err := json.Marshal(data) + if err != nil { + fmt.Printf("Failed to marshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + res := reflect.New(to).Interface() + err = json.Unmarshal(raw, &res) + if err != nil { + fmt.Printf("Failed to umarshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + return res, nil + } + + return data, nil +} + +func decode_Config(input, result interface{}) error { + config := &mapstructure.DecoderConfig{ + TagName: "json", + WeaklyTypedInput: true, + Result: result, + DecodeHook: mapstructure.ComposeDecodeHookFunc( + mapstructure.StringToTimeDurationHookFunc(), + mapstructure.StringToSliceHookFunc(","), + jsonUnmarshalerHookConfig, + ), + } + + decoder, err := mapstructure.NewDecoder(config) + if err != nil { + return err + } + + return decoder.Decode(input) +} + +func join_Config(arr interface{}, sep string) string { + listValue := reflect.ValueOf(arr) + strs := make([]string, 0, listValue.Len()) + for i := 0; i < listValue.Len(); i++ { + strs = append(strs, fmt.Sprintf("%v", listValue.Index(i))) + } + + return strings.Join(strs, sep) +} + +func testDecodeJson_Config(t *testing.T, val, result interface{}) { + assert.NoError(t, decode_Config(val, result)) +} + +func testDecodeRaw_Config(t *testing.T, vStringSlice, result interface{}) { + assert.NoError(t, decode_Config(vStringSlice, result)) +} + +func TestConfig_GetPFlagSet(t *testing.T) { + val := Config{} + cmdFlags := val.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) +} + +func TestConfig_SetFlags(t *testing.T) { + actual := Config{} + cmdFlags := actual.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) + + t.Run("Test_sleep-duration", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := defaultConfig.SleepDuration.String() + + cmdFlags.Set("sleep-duration", testValue) + if vString, err := cmdFlags.GetString("sleep-duration"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.SleepDuration) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) +} diff --git a/flyteplugins/go/tasks/plugins/testing/echo.go b/flyteplugins/go/tasks/plugins/testing/echo.go new file mode 100644 index 0000000000..52a2c09e72 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/testing/echo.go @@ -0,0 +1,191 @@ +package testing + +import ( + "context" + "fmt" + "sync" + "time" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/ioutils" + + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + idlcore "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const ( + echoTaskType = "echo" +) + +type EchoPlugin struct { + enqueueOwner core.EnqueueOwner + taskStartTimes map[string]time.Time + sync.Mutex +} + +func (e *EchoPlugin) GetID() string { + return echoTaskType +} + +func (e *EchoPlugin) GetProperties() core.PluginProperties { + return core.PluginProperties{} +} + +// Enqueue the task to be re-evaluated after SleepDuration. +// If the task is already enqueued, return the start time of the task. +func (e *EchoPlugin) addTask(ctx context.Context, tCtx core.TaskExecutionContext) time.Time { + e.Lock() + defer e.Unlock() + var startTime time.Time + var exists bool + taskExecutionID := tCtx.TaskExecutionMetadata().GetTaskExecutionID().GetGeneratedName() + if startTime, exists = e.taskStartTimes[taskExecutionID]; !exists { + startTime = time.Now() + e.taskStartTimes[taskExecutionID] = startTime + + // start timer to enqueue owner once task sleep duration has elapsed + go func() { + echoConfig := ConfigSection.GetConfig().(*Config) + time.Sleep(echoConfig.SleepDuration.Duration) + // TODO @pvditt fix + //labels := map[string]string{ + // k8s.WorkflowID: tCtx.TaskExecutionMetadata().GetOwnerID().String(), + //} + //if err := e.enqueueOwner(labels); err != nil { + // logger.Warnf(ctx, "failed to enqueue owner [%s]: %v", tCtx.TaskExecutionMetadata().GetOwnerID(), err) + //} + }() + } + return startTime +} + +// Remove the task from the taskStartTimes map. +func (e *EchoPlugin) removeTask(taskExecutionID string) { + e.Lock() + defer e.Unlock() + delete(e.taskStartTimes, taskExecutionID) +} + +func (e *EchoPlugin) Handle(ctx context.Context, tCtx core.TaskExecutionContext) (core.Transition, error) { + echoConfig := ConfigSection.GetConfig().(*Config) + + if echoConfig.SleepDuration.Duration == time.Duration(0) { + return copyInputsToOutputs(ctx, tCtx) + } + + startTime := e.addTask(ctx, tCtx) + + if time.Since(startTime) >= echoConfig.SleepDuration.Duration { + return copyInputsToOutputs(ctx, tCtx) + } + + return core.DoTransition(core.PhaseInfoRunning(core.DefaultPhaseVersion, nil)), nil +} + +func (e *EchoPlugin) Abort(ctx context.Context, tCtx core.TaskExecutionContext) error { + return nil +} + +func (e *EchoPlugin) Finalize(ctx context.Context, tCtx core.TaskExecutionContext) error { + taskExecutionID := tCtx.TaskExecutionMetadata().GetTaskExecutionID().GetGeneratedName() + e.removeTask(taskExecutionID) + return nil +} + +// copyInputsToOutputs copies the input literals to the output location. +func copyInputsToOutputs(ctx context.Context, tCtx core.TaskExecutionContext) (core.Transition, error) { + inputToOutputVariableMappings, err := compileInputToOutputVariableMappings(ctx, tCtx) + if err != nil { + return core.UnknownTransition, err + } + + if len(inputToOutputVariableMappings) > 0 { + inputLiterals, err := tCtx.InputReader().Get(ctx) + if err != nil { + return core.UnknownTransition, err + } + + outputLiterals := make(map[string]*idlcore.Literal, len(inputToOutputVariableMappings)) + for inputVariableName, outputVariableName := range inputToOutputVariableMappings { + outputLiterals[outputVariableName] = inputLiterals.Literals[inputVariableName] + } + + outputLiteralMap := &idlcore.LiteralMap{ + Literals: outputLiterals, + } + + outputFile := tCtx.OutputWriter().GetOutputPath() + if err := tCtx.DataStore().WriteProtobuf(ctx, outputFile, storage.Options{}, outputLiteralMap); err != nil { + return core.UnknownTransition, err + } + + or := ioutils.NewRemoteFileOutputReader(ctx, tCtx.DataStore(), tCtx.OutputWriter(), 0) + if err = tCtx.OutputWriter().Put(ctx, or); err != nil { + return core.UnknownTransition, err + } + } + return core.DoTransition(core.PhaseInfoSuccess(nil)), nil +} + +func compileInputToOutputVariableMappings(ctx context.Context, tCtx core.TaskExecutionContext) (map[string]string, error) { + // validate outputs are castable from inputs otherwise error as this plugin is not applicable + taskTemplate, err := tCtx.TaskReader().Read(ctx) + if err != nil { + return nil, fmt.Errorf("failed to read TaskTemplate: [%w]", err) + } + + var inputs, outputs map[string]*idlcore.Variable + if taskTemplate.Interface != nil { + if taskTemplate.Interface.Inputs != nil { + inputs = taskTemplate.Interface.Inputs.Variables + } + if taskTemplate.Interface.Outputs != nil { + outputs = taskTemplate.Interface.Outputs.Variables + } + } + + if len(inputs) != len(outputs) { + return nil, fmt.Errorf("the number of input [%d] and output [%d] variables does not match", len(inputs), len(outputs)) + } else if len(inputs) > 1 { + return nil, fmt.Errorf("this plugin does not currently support more than one input variable") + } + + inputToOutputVariableMappings := make(map[string]string) + outputVariableNameUsed := make(map[string]struct{}) + for inputVariableName := range inputs { + firstCastableOutputName := "" + for outputVariableName := range outputs { + // TODO - need to check if types are castable to support multiple values + if _, ok := outputVariableNameUsed[outputVariableName]; !ok { + firstCastableOutputName = outputVariableName + break + } + } + + if len(firstCastableOutputName) == 0 { + return nil, fmt.Errorf("no castable output variable found for input variable [%s]", inputVariableName) + } + + outputVariableNameUsed[firstCastableOutputName] = struct{}{} + inputToOutputVariableMappings[inputVariableName] = firstCastableOutputName + } + + return inputToOutputVariableMappings, nil +} + +func init() { + pluginmachinery.PluginRegistry().RegisterCorePlugin( + core.PluginEntry{ + ID: echoTaskType, + RegisteredTaskTypes: []core.TaskType{echoTaskType}, + LoadPlugin: func(ctx context.Context, iCtx core.SetupContext) (core.Plugin, error) { + return &EchoPlugin{ + enqueueOwner: iCtx.EnqueueOwner(), + taskStartTimes: make(map[string]time.Time), + }, nil + }, + IsDefault: false, + }, + ) +} diff --git a/flyteplugins/go/tasks/plugins/webapi/connector/client.go b/flyteplugins/go/tasks/plugins/webapi/connector/client.go new file mode 100644 index 0000000000..c735e66ebe --- /dev/null +++ b/flyteplugins/go/tasks/plugins/webapi/connector/client.go @@ -0,0 +1,230 @@ +package connector + +import ( + "context" + "crypto/x509" + "strings" + + "golang.org/x/exp/maps" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/credentials" + "google.golang.org/grpc/credentials/insecure" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/status" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector" +) + +const defaultTaskTypeVersion = 0 + +type Connector struct { + // ConnectorDeployment is the connector deployment where this connector is running. + ConnectorDeployment *Deployment + // ConnectorID is the ID of the connector. + ConnectorID string + // IsConnectorApp indicates whether this connector is a connector app. + IsConnectorApp bool +} + +// ClientSet contains the clients exposed to communicate with various connector services. +type ClientSet struct { + asyncConnectorClients map[string]connector.AsyncConnectorServiceClient // map[endpoint] => AsyncConnectorServiceClient + connectorMetadataClients map[string]connector.ConnectorMetadataServiceClient // map[endpoint] => ConnectorMetadataServiceClient +} + +func getGrpcConnection(ctx context.Context, connector *Deployment) (*grpc.ClientConn, error) { + var opts []grpc.DialOption + + if connector.Insecure { + opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials())) + } else { + pool, err := x509.SystemCertPool() + if err != nil { + return nil, err + } + + creds := credentials.NewClientTLSFromCert(pool, "") + opts = append(opts, grpc.WithTransportCredentials(creds)) + } + + if len(connector.DefaultServiceConfig) != 0 { + opts = append(opts, grpc.WithDefaultServiceConfig(connector.DefaultServiceConfig)) + } + + var err error + conn, err := grpc.Dial(connector.Endpoint, opts...) + if err != nil { + return nil, err + } + + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", connector, cerr) + } + }() + + return conn, nil +} + +func getFinalTimeout(operation string, connector *Deployment) config.Duration { + if t, exists := connector.Timeouts[operation]; exists { + return t + } + + return connector.DefaultTimeout +} + +func getFinalContext(ctx context.Context, operation string, connector *Deployment) (context.Context, context.CancelFunc) { + timeout := getFinalTimeout(operation, connector).Duration + if timeout == 0 { + return ctx, func() {} + } + + return context.WithTimeout(ctx, timeout) +} + +func updateRegistry( + ctx context.Context, + cs *ClientSet, + newConnectorRegistry Registry, + connectorDeployments map[string]*Deployment, + isConnectorApp bool, +) { + for connectorID, connectorDeployment := range connectorDeployments { + client, ok := cs.connectorMetadataClients[connectorDeployment.Endpoint] + if !ok { + logger.Warningf(ctx, "Connector client not found in the clientSet for the endpoint: %v", connectorDeployment.Endpoint) + continue + } + + finalCtx, cancel := getFinalContext(ctx, "ListConnectors", connectorDeployment) + defer cancel() + + res, err := client.ListConnectors(finalCtx, &connector.ListConnectorsRequest{}) + if err != nil { + grpcStatus, ok := status.FromError(err) + if grpcStatus.Code() == codes.Unimplemented { + // we should not panic here, as we want to continue to support old connector settings + logger.Warningf(finalCtx, "list connector method not implemented for connector: [%v]", connectorDeployment.Endpoint) + continue + } + + if !ok { + logger.Errorf(finalCtx, "failed to list connector: [%v] with a non-gRPC error: [%v]", connectorDeployment.Endpoint, err) + continue + } + + logger.Errorf(finalCtx, "failed to list connector: [%v] with error: [%v]", connectorDeployment.Endpoint, err) + continue + } + + connectorSupportedTaskCategories := make(map[string]struct{}) + for _, agent := range res.GetConnectors() { + supportedTaskCategories := agent.GetSupportedTaskCategories() + for _, supportedCategory := range supportedTaskCategories { + connector := &Connector{ + ConnectorDeployment: connectorDeployment, + ConnectorID: connectorID, + IsConnectorApp: isConnectorApp, + } + supportedCategoryName := supportedCategory.GetName() + registryKey := RegistryKey{domain: connectorDeployment.Domain, taskTypeName: supportedCategoryName, taskTypeVersion: supportedCategory.GetVersion()} + newConnectorRegistry[registryKey] = connector + connectorSupportedTaskCategories[supportedCategoryName] = struct{}{} + } + } + logger.Infof(ctx, "ConnectorDeployment [%v] supports the following task types: [%v]", connectorDeployment.Endpoint, + strings.Join(maps.Keys(connectorSupportedTaskCategories), ", ")) + } +} + +func getConnectorRegistry(ctx context.Context, cs *ClientSet) Registry { + newConnectorRegistry := make(Registry) + cfg := GetConfig() + + connectorDeployments := make(map[string]*Deployment) + + if len(cfg.DefaultConnector.Endpoint) != 0 { + connectorDeployments["defaultConnector"] = &cfg.DefaultConnector + } + + for connectorID, deployment := range cfg.ConnectorDeployments { + connectorDeployments[connectorID] = deployment + } + + // Update registry with regular connectors + updateRegistry(ctx, cs, newConnectorRegistry, connectorDeployments, false) + + // If the connector doesn't implement the metadata service, we construct the registry based on the configuration + for taskType, connectorDeploymentID := range cfg.ConnectorForTaskTypes { + if connectorDeployment, ok := cfg.ConnectorDeployments[connectorDeploymentID]; ok { + registryKey := RegistryKey{domain: connectorDeployment.Domain, taskTypeName: taskType, taskTypeVersion: defaultTaskTypeVersion} + connector := &Connector{ + ConnectorDeployment: connectorDeployment, + ConnectorID: connectorDeploymentID, + IsConnectorApp: false, + } + newConnectorRegistry[registryKey] = connector + } + } + + // Ensure that the old configuration is backward compatible + for _, taskType := range cfg.SupportedTaskTypes { + registryKey := RegistryKey{domain: cfg.DefaultConnector.Domain, taskTypeName: taskType, taskTypeVersion: defaultTaskTypeVersion} + if _, ok := newConnectorRegistry[registryKey]; !ok { + connector := &Connector{ + ConnectorDeployment: &cfg.DefaultConnector, + ConnectorID: "defaultConnector", + IsConnectorApp: false, + } + newConnectorRegistry[registryKey] = connector + } + } + + // Update registry with connector apps + updateRegistry(ctx, cs, newConnectorRegistry, cfg.ConnectorApps, true) + + logger.Infof(ctx, "ConnectorDeployments support the following task types: [%v]", strings.Join(newConnectorRegistry.getSupportedTaskTypes(), ", ")) + return newConnectorRegistry +} + +func getConnectorClientSets(ctx context.Context) *ClientSet { + clientSet := &ClientSet{ + asyncConnectorClients: make(map[string]connector.AsyncConnectorServiceClient), + connectorMetadataClients: make(map[string]connector.ConnectorMetadataServiceClient), + } + + var connectorDeployments []*Deployment + cfg := GetConfig() + + if len(cfg.DefaultConnector.Endpoint) != 0 { + connectorDeployments = append(connectorDeployments, &cfg.DefaultConnector) + } + + for _, deployment := range cfg.ConnectorDeployments { + connectorDeployments = append(connectorDeployments, deployment) + } + + for _, deployment := range cfg.ConnectorApps { + connectorDeployments = append(connectorDeployments, deployment) + } + + for _, connectorDeployment := range connectorDeployments { + if _, ok := clientSet.connectorMetadataClients[connectorDeployment.Endpoint]; ok { + logger.Infof(ctx, "Connector client already initialized for [%v]", connectorDeployment.Endpoint) + continue + } + conn, err := getGrpcConnection(ctx, connectorDeployment) + if err != nil { + logger.Errorf(ctx, "failed to create connection to connector: [%v] with error: [%v]", connectorDeployment, err) + continue + } + clientSet.asyncConnectorClients[connectorDeployment.Endpoint] = connector.NewAsyncConnectorServiceClient(conn) + clientSet.connectorMetadataClients[connectorDeployment.Endpoint] = connector.NewConnectorMetadataServiceClient(conn) + } + return clientSet +} diff --git a/flyteplugins/go/tasks/plugins/webapi/connector/client_test.go b/flyteplugins/go/tasks/plugins/webapi/connector/client_test.go new file mode 100644 index 0000000000..9bb92a404d --- /dev/null +++ b/flyteplugins/go/tasks/plugins/webapi/connector/client_test.go @@ -0,0 +1,28 @@ +package connector + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestInitializeClients(t *testing.T) { + cfg := defaultConfig + cfg.ConnectorDeployments = map[string]*Deployment{ + "x": { + Endpoint: "x", + }, + "y": { + Endpoint: "y", + }, + } + ctx := context.Background() + err := SetConfig(&cfg) + assert.NoError(t, err) + cs := getConnectorClientSets(ctx) + _, ok := cs.asyncConnectorClients["y"] + assert.True(t, ok) + _, ok = cs.asyncConnectorClients["x"] + assert.True(t, ok) +} diff --git a/flyteplugins/go/tasks/plugins/webapi/connector/config.go b/flyteplugins/go/tasks/plugins/webapi/connector/config.go new file mode 100644 index 0000000000..fcb82246ef --- /dev/null +++ b/flyteplugins/go/tasks/plugins/webapi/connector/config.go @@ -0,0 +1,114 @@ +package connector + +import ( + "time" + + pluginsConfig "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/config" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/logs" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi" + "github.com/flyteorg/flyte/v2/flytestdlib/config" +) + +var ( + defaultConfig = Config{ + WebAPI: webapi.PluginConfig{ + ResourceQuotas: map[core.ResourceNamespace]int{ + "default": 1000, + }, + ReadRateLimiter: webapi.RateLimiterConfig{ + Burst: 100, + QPS: 10, + }, + WriteRateLimiter: webapi.RateLimiterConfig{ + Burst: 100, + QPS: 10, + }, + Caching: webapi.CachingConfig{ + Size: 500000, + ResyncInterval: config.Duration{Duration: 30 * time.Second}, + Workers: 10, + MaxSystemFailures: 5, + }, + ResourceMeta: nil, + }, + ResourceConstraints: core.ResourceConstraintsSpec{ + ProjectScopeResourceConstraint: &core.ResourceConstraint{ + Value: 100, + }, + NamespaceScopeResourceConstraint: &core.ResourceConstraint{ + Value: 50, + }, + }, + DefaultConnector: Deployment{ + Endpoint: "", + Insecure: true, + DefaultTimeout: config.Duration{Duration: 10 * time.Second}, + DefaultServiceConfig: `{"loadBalancingConfig": [{"round_robin":{}}]}`, + }, + ConnectorDeployments: map[string]*Deployment{}, + ConnectorForTaskTypes: map[string]string{}, + SupportedTaskTypes: []string{"task_type_3", "task_type_4"}, + PollInterval: config.Duration{Duration: 10 * time.Second}, + } + + configSection = pluginsConfig.MustRegisterSubSection("connector-service", &defaultConfig) +) + +// Config is config for 'connector' plugin +type Config struct { + // WebAPI defines config for the base WebAPI plugin + WebAPI webapi.PluginConfig `json:"webApi,omitempty" yaml:"webApi,omitempty" pflag:",Defines config for the base WebAPI plugin."` + + // ResourceConstraints defines resource constraints on how many executions to be created per project/overall at any given time + ResourceConstraints core.ResourceConstraintsSpec `json:"resourceConstraints,omitempty" yaml:"resourceConstraints,omitempty" pflag:"-,Defines resource constraints on how many executions to be created per project/overall at any given time."` + + // The default connector if there does not exist a more specific matching against task types + DefaultConnector Deployment `json:"defaultConnector,omitempty" yaml:"defaultConnector,omitempty" pflag:",The default connector."` + + // The connectors used to match against specific task types. {connectorDeploymentID: ConnectorDeployment} + ConnectorDeployments map[string]*Deployment `json:"connectors,omitempty" yaml:"connectors,omitempty" pflag:",The connectors."` + + // The connectors deployed as connector apps. {connectorDeploymentID: ConnectorDeployment} + ConnectorApps map[string]*Deployment `json:"connectorApps,omitempty" yaml:"connectorApps,omitempty" pflag:",The connectors."` + + // Maps task types to their connectors. {TaskType: connectorDeploymentID} + ConnectorForTaskTypes map[string]string `json:"connectorForTaskTypes,omitempty" yaml:"connectorForTaskTypes,omitempty" pflag:"-,"` + + // SupportedTaskTypes is a list of task types that are supported by this plugin. + SupportedTaskTypes []string `json:"supportedTaskTypes,omitempty" yaml:"supportedTaskTypes,omitempty" pflag:"-,Defines a list of task types that are supported by this plugin."` + + // PollInterval is the interval at which the plugin should poll the connector for metadata updates + PollInterval config.Duration `json:"pollInterval,omitempty" yaml:"pollInterval,omitempty" pflag:",The interval at which the plugin should poll the connector for metadata updates."` + + // Connector App Logs + Logs logs.LogConfig `json:"logs,omitempty" yaml:"logs,omitempty" pflag:",Log configuration for connector tasks"` +} + +type Deployment struct { + // Endpoint points to a connector gRPC endpoint + Endpoint string `json:"endpoint"` + + // Insecure indicates whether the communication with the gRPC service is insecure + Insecure bool `json:"insecure"` + + // DefaultServiceConfig sets default gRPC service config; check https://github.com/grpc/grpc/blob/master/doc/service_config.md for more details + DefaultServiceConfig string `json:"defaultServiceConfig,omitempty" yaml:"defaultServiceConfig,omitempty"` + + // Timeouts defines various RPC timeout values for different plugin operations: CreateTask, GetTask, DeleteTask; if not configured, defaults to DefaultTimeout + Timeouts map[string]config.Duration `json:"timeouts,omitempty" yaml:"timeouts,omitempty"` + + // DefaultTimeout gives the default RPC timeout if a more specific one is not defined in Timeouts; if neither DefaultTimeout nor Timeouts is defined for an operation, RPC timeout will not be enforced + DefaultTimeout config.Duration `json:"defaultTimeout,omitempty" yaml:"defaultTimeout,omitempty"` + + // The tasks in this domain will be handled by this agent + Domain string `json:"domain,omitempty" yaml:"domain,omitempty"` +} + +func GetConfig() *Config { + return configSection.GetConfig().(*Config) +} + +func SetConfig(cfg *Config) error { + return configSection.SetConfig(cfg) +} diff --git a/flyteplugins/go/tasks/plugins/webapi/connector/config_test.go b/flyteplugins/go/tasks/plugins/webapi/connector/config_test.go new file mode 100644 index 0000000000..10779e5d81 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/webapi/connector/config_test.go @@ -0,0 +1,68 @@ +package connector + +import ( + "testing" + "time" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" +) + +func TestGetAndSetConfig(t *testing.T) { + cfg := defaultConfig + cfg.WebAPI.Caching.Workers = 1 + cfg.WebAPI.Caching.ResyncInterval.Duration = 5 * time.Second + cfg.DefaultConnector.Insecure = false + cfg.DefaultConnector.DefaultServiceConfig = "{\"loadBalancingConfig\": [{\"round_robin\":{}}]}" + cfg.DefaultConnector.Timeouts = map[string]config.Duration{ + "CreateTask": { + Duration: 1 * time.Millisecond, + }, + "GetTask": { + Duration: 2 * time.Millisecond, + }, + "DeleteTask": { + Duration: 3 * time.Millisecond, + }, + } + cfg.DefaultConnector.DefaultTimeout = config.Duration{Duration: 10 * time.Second} + cfg.ConnectorDeployments = map[string]*Deployment{ + "connector_1": { + Insecure: cfg.DefaultConnector.Insecure, + DefaultServiceConfig: cfg.DefaultConnector.DefaultServiceConfig, + Timeouts: cfg.DefaultConnector.Timeouts, + }, + } + cfg.ConnectorApps = map[string]*Deployment{ + "connector_app": { + Insecure: cfg.DefaultConnector.Insecure, + DefaultServiceConfig: cfg.DefaultConnector.DefaultServiceConfig, + Timeouts: cfg.DefaultConnector.Timeouts, + }, + } + cfg.ConnectorForTaskTypes = map[string]string{"task_type_1": "agent_1"} + err := SetConfig(&cfg) + assert.NoError(t, err) + assert.Equal(t, &cfg, GetConfig()) +} + +func TestDefaultAgentConfig(t *testing.T) { + cfg := defaultConfig + + assert.Equal(t, "", cfg.DefaultConnector.Endpoint) + assert.True(t, cfg.DefaultConnector.Insecure) + assert.Equal(t, 10*time.Second, cfg.DefaultConnector.DefaultTimeout.Duration) + assert.Equal(t, `{"loadBalancingConfig": [{"round_robin":{}}]}`, cfg.DefaultConnector.DefaultServiceConfig) + + assert.Empty(t, cfg.DefaultConnector.Timeouts) + + expectedTaskTypes := []string{"task_type_3", "task_type_4"} + assert.Equal(t, expectedTaskTypes, cfg.SupportedTaskTypes) + + assert.Empty(t, cfg.ConnectorDeployments) + + assert.Empty(t, cfg.ConnectorDeployments) + + assert.Equal(t, 10*time.Second, cfg.PollInterval.Duration) +} diff --git a/flyteplugins/go/tasks/plugins/webapi/connector/integration_test.go b/flyteplugins/go/tasks/plugins/webapi/connector/integration_test.go new file mode 100644 index 0000000000..c5bc2001bd --- /dev/null +++ b/flyteplugins/go/tasks/plugins/webapi/connector/integration_test.go @@ -0,0 +1,285 @@ +package connector + +import ( + "context" + "encoding/json" + "fmt" + "sync/atomic" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "k8s.io/apimachinery/pkg/util/rand" + "k8s.io/utils/strings/slices" + + "github.com/flyteorg/flyte/v2/flyteidl2/clients/go/coreutils" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + pluginCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + pluginCoreMocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + ioMocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi" + "github.com/flyteorg/flyte/v2/flyteplugins/tests" + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils/labeled" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/flytestdlib/utils" + connectorPb "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector" + connectorMocks "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector/mocks" + flyteIdlCore "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" +) + +func TestEndToEnd(t *testing.T) { + iter := func(ctx context.Context, tCtx pluginCore.TaskExecutionContext) error { + return nil + } + + cfg := defaultConfig + cfg.WebAPI.ResourceQuotas = map[core.ResourceNamespace]int{} + cfg.WebAPI.Caching.Workers = 1 + cfg.WebAPI.Caching.ResyncInterval.Duration = 5 * time.Second + cfg.DefaultConnector.Endpoint = "localhost:8000" + err := SetConfig(&cfg) + assert.NoError(t, err) + + databricksConfDict := map[string]interface{}{ + "name": "flytekit databricks plugin example", + "new_cluster": map[string]string{ + "spark_version": "11.0.x-scala2.12", + "node_type_id": "r3.xlarge", + "num_workers": "4", + }, + "timeout_seconds": 3600, + "max_retries": 1, + } + databricksConfig, err := utils.MarshalObjToStruct(databricksConfDict) + assert.NoError(t, err) + sparkJob := plugins.SparkJob{DatabricksConf: databricksConfig, DatabricksToken: "token", SparkConf: map[string]string{"spark.driver.bindAddress": "127.0.0.1"}} + st, err := utils.MarshalPbToStruct(&sparkJob) + assert.NoError(t, err) + + inputs, _ := coreutils.MakeLiteralMap(map[string]interface{}{"x": 1}) + template := flyteIdlCore.TaskTemplate{ + Type: "spark", + Custom: st, + Target: &flyteIdlCore.TaskTemplate_Container{ + Container: &flyteIdlCore.Container{Args: []string{"pyflyte-fast-execute", "--output-prefix", "/tmp/123"}}, + }, + } + basePrefix := storage.DataReference("fake://bucket/prefix/") + + t.Run("run an async task", func(t *testing.T) { + pluginEntry := pluginmachinery.CreateRemotePlugin(newMockAsyncConnectorPlugin()) + plugin, err := pluginEntry.LoadPlugin(context.TODO(), newFakeSetupContext("async task")) + assert.NoError(t, err) + + phase := tests.RunPluginEndToEndTest(t, plugin, &template, inputs, nil, nil, iter) + assert.Equal(t, true, phase.Phase().IsSuccess()) + + template.Type = "spark" + phase = tests.RunPluginEndToEndTest(t, plugin, &template, inputs, nil, nil, iter) + assert.Equal(t, true, phase.Phase().IsSuccess()) + }) + + t.Run("failed to create a job", func(t *testing.T) { + connectorPlugin := newMockAsyncConnectorPlugin() + connectorPlugin.PluginLoader = func(ctx context.Context, iCtx webapi.PluginSetupContext) (webapi.AsyncPlugin, error) { + return &Plugin{ + metricScope: iCtx.MetricsScope(), + cfg: GetConfig(), + cs: &ClientSet{ + asyncConnectorClients: map[string]connectorPb.AsyncConnectorServiceClient{}, + connectorMetadataClients: map[string]connectorPb.ConnectorMetadataServiceClient{}, + }, + }, nil + } + pluginEntry := pluginmachinery.CreateRemotePlugin(connectorPlugin) + plugin, err := pluginEntry.LoadPlugin(context.TODO(), newFakeSetupContext("test2")) + assert.NoError(t, err) + + tCtx := getTaskContext(t) + tr := &pluginCoreMocks.TaskReader{} + tr.On("Read", mock.Anything).Return(&template, nil) + tCtx.On("TaskReader").Return(tr) + inputReader := &ioMocks.InputReader{} + inputReader.On("GetInputPrefixPath").Return(basePrefix) + inputReader.On("GetInputPath").Return(basePrefix + "/inputs.pb") + inputReader.On("Get", mock.Anything).Return(inputs, nil) + tCtx.On("InputReader").Return(inputReader) + + trns, err := plugin.Handle(context.Background(), tCtx) + assert.Nil(t, err) + assert.Equal(t, trns.Info().Phase(), core.PhaseRetryableFailure) + err = plugin.Abort(context.Background(), tCtx) + assert.Nil(t, err) + }) + + t.Run("failed to read task template", func(t *testing.T) { + tCtx := getTaskContext(t) + + tr := &pluginCoreMocks.TaskReader{} + tr.On("Read", mock.Anything).Return(nil, fmt.Errorf("read fail")) + tCtx.On("TaskReader").Return(tr) + + connectorPlugin := newMockAsyncConnectorPlugin() + pluginEntry := pluginmachinery.CreateRemotePlugin(connectorPlugin) + plugin, err := pluginEntry.LoadPlugin(context.TODO(), newFakeSetupContext("test3")) + assert.NoError(t, err) + + trns, err := plugin.Handle(context.Background(), tCtx) + assert.Nil(t, err) + assert.Equal(t, trns.Info().Phase(), core.PhaseRetryableFailure) + }) + + t.Run("failed to read inputs", func(t *testing.T) { + tCtx := getTaskContext(t) + tr := &pluginCoreMocks.TaskReader{} + tr.On("Read", mock.Anything).Return(&template, nil) + tCtx.On("TaskReader").Return(tr) + inputReader := &ioMocks.InputReader{} + inputReader.On("GetInputPrefixPath").Return(basePrefix) + inputReader.On("GetInputPath").Return(basePrefix + "/inputs.pb") + inputReader.On("Get", mock.Anything).Return(nil, fmt.Errorf("read fail")) + tCtx.On("InputReader").Return(inputReader) + + connectorPlugin := newMockAsyncConnectorPlugin() + pluginEntry := pluginmachinery.CreateRemotePlugin(connectorPlugin) + plugin, err := pluginEntry.LoadPlugin(context.TODO(), newFakeSetupContext("test4")) + assert.NoError(t, err) + + trns, err := plugin.Handle(context.Background(), tCtx) + assert.Nil(t, err) + assert.Equal(t, trns.Info().Phase(), core.PhaseRetryableFailure) + }) +} + +func getTaskContext(t *testing.T) *pluginCoreMocks.TaskExecutionContext { + latestKnownState := atomic.Value{} + pluginStateReader := &pluginCoreMocks.PluginStateReader{} + pluginStateReader.On("Get", mock.Anything).Return(uint8(0), nil).Run(func(args mock.Arguments) { + o := args.Get(0) + x, err := json.Marshal(latestKnownState.Load()) + assert.NoError(t, err) + assert.NoError(t, json.Unmarshal(x, &o)) + }) + + pluginStateWriter := &pluginCoreMocks.PluginStateWriter{} + pluginStateWriter.On("Put", mock.Anything, mock.Anything).Return(nil).Run(func(args mock.Arguments) { + latestKnownState.Store(args.Get(1)) + }) + pluginStateWriter.On("Reset").Return(nil).Run(func(args mock.Arguments) { + latestKnownState.Store(nil) + }) + + execID := rand.String(3) + tID := &pluginCoreMocks.TaskExecutionID{} + tID.On("GetGeneratedName").Return(execID + "-my-task-1") + tID.On("GetID").Return(flyteIdlCore.TaskExecutionIdentifier{ + TaskId: &flyteIdlCore.Identifier{ + ResourceType: flyteIdlCore.ResourceType_TASK, + Project: "a", + Domain: "d", + Name: "n", + Version: "abc", + }, + NodeExecutionId: &flyteIdlCore.NodeExecutionIdentifier{ + NodeId: "node1", + ExecutionId: &flyteIdlCore.WorkflowExecutionIdentifier{ + Project: "a", + Domain: "d", + Name: "exec", + }, + }, + RetryAttempt: 0, + }) + + tMeta := &pluginCoreMocks.TaskExecutionMetadata{} + tMeta.On("GetTaskExecutionID").Return(tID) + tMeta.On("GetNamespace").Return("test-namespace") + tMeta.On("GetLabels").Return(map[string]string{"foo": "bar"}) + tMeta.On("GetAnnotations").Return(map[string]string{"foo": "bar"}) + tMeta.On("GetK8sServiceAccount").Return("k8s-account") + tMeta.On("GetEnvironmentVariables").Return(map[string]string{"foo": "bar"}) + tMeta.On("GetSecurityContext").Return(flyteIdlCore.SecurityContext{ + RunAs: &flyteIdlCore.Identity{ExecutionIdentity: "execution-identity"}, + }) + + resourceManager := &pluginCoreMocks.ResourceManager{} + resourceManager.On("AllocateResource", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(pluginCore.AllocationStatusGranted, nil) + resourceManager.On("ReleaseResource", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil) + + basePrefix := storage.DataReference("fake://bucket/prefix/" + execID) + outputWriter := &ioMocks.OutputWriter{} + outputWriter.On("GetRawOutputPrefix").Return(storage.DataReference("/sandbox/")) + outputWriter.On("GetOutputPrefixPath").Return(basePrefix) + outputWriter.On("GetErrorPath").Return(basePrefix + "/error.pb") + outputWriter.On("GetOutputPath").Return(basePrefix + "/outputs.pb") + outputWriter.On("GetCheckpointPrefix").Return(storage.DataReference("/checkpoint")) + outputWriter.On("GetPreviousCheckpointsPrefix").Return(storage.DataReference("/prev")) + + tCtx := &pluginCoreMocks.TaskExecutionContext{} + tCtx.On("OutputWriter").Return(outputWriter) + tCtx.On("ResourceManager").Return(resourceManager) + tCtx.On("PluginStateReader").Return(pluginStateReader) + tCtx.On("PluginStateWriter").Return(pluginStateWriter) + tCtx.On("TaskExecutionMetadata").Return(tMeta) + + return tCtx +} + +func newMockAsyncConnectorPlugin() webapi.PluginEntry { + asyncConnectorClient := new(connectorMocks.AsyncConnectorServiceClient) + registryKey := RegistryKey{domain: "", taskTypeName: "spark", taskTypeVersion: defaultTaskTypeVersion} + connectorRegistry := Registry{registryKey: {ConnectorDeployment: &Deployment{Endpoint: defaultConnectorEndpoint}}} + + mockCreateRequestMatcher := mock.MatchedBy(func(request *connectorPb.CreateTaskRequest) bool { + expectedArgs := []string{"pyflyte-fast-execute", "--output-prefix", "/tmp/123"} + return slices.Equal(request.Template.GetContainer().Args, expectedArgs) + }) + asyncConnectorClient.On("CreateTask", mock.Anything, mockCreateRequestMatcher).Return(&connectorPb.CreateTaskResponse{ + ResourceMeta: []byte{1, 2, 3, 4}}, nil) + + mockGetRequestMatcher := mock.MatchedBy(func(request *connectorPb.GetTaskRequest) bool { + return request.GetTaskCategory().GetName() == "spark" + }) + asyncConnectorClient.On("GetTask", mock.Anything, mockGetRequestMatcher).Return( + &connectorPb.GetTaskResponse{Resource: &connectorPb.Resource{Phase: flyteIdlCore.TaskExecution_SUCCEEDED}}, nil) + + asyncConnectorClient.On("DeleteTask", mock.Anything, mock.Anything).Return( + &connectorPb.DeleteTaskResponse{}, nil) + + cfg := defaultConfig + cfg.DefaultConnector.Endpoint = "localhost:8000" + + return webapi.PluginEntry{ + ID: "connector-service", + SupportedTaskTypes: []core.TaskType{"bigquery_query_job_task", "spark"}, + PluginLoader: func(ctx context.Context, iCtx webapi.PluginSetupContext) (webapi.AsyncPlugin, error) { + return &Plugin{ + metricScope: iCtx.MetricsScope(), + cfg: &cfg, + cs: &ClientSet{ + asyncConnectorClients: map[string]connectorPb.AsyncConnectorServiceClient{ + defaultConnectorEndpoint: asyncConnectorClient, + }, + }, + registry: connectorRegistry, + }, nil + }, + } +} + +func newFakeSetupContext(name string) *pluginCoreMocks.SetupContext { + fakeResourceRegistrar := pluginCoreMocks.ResourceRegistrar{} + fakeResourceRegistrar.On("RegisterResourceQuota", mock.Anything, mock.Anything, mock.Anything).Return(nil) + labeled.SetMetricKeys(contextutils.NamespaceKey) + + fakeSetupContext := pluginCoreMocks.SetupContext{} + fakeSetupContext.On("MetricsScope").Return(promutils.NewScope(name)) + fakeSetupContext.On("ResourceRegistrar").Return(&fakeResourceRegistrar) + + return &fakeSetupContext +} diff --git a/flyteplugins/go/tasks/plugins/webapi/connector/plugin.go b/flyteplugins/go/tasks/plugins/webapi/connector/plugin.go new file mode 100644 index 0000000000..5d49424ea8 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/webapi/connector/plugin.go @@ -0,0 +1,478 @@ +package connector + +import ( + "context" + "encoding/gob" + "fmt" + "slices" + "sync" + "time" + + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + "google.golang.org/protobuf/types/known/structpb" + "k8s.io/apimachinery/pkg/util/wait" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/secret" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/utils" + + pluginErrors "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/errors" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/logs" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/template" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/ioutils" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/tasklog" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + connectorPb "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector" + flyteIdl "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" +) + +const ID = "connector-service" + +type ConnectorService struct { + mu sync.RWMutex + supportedTaskTypes []string + CorePlugin core.Plugin +} + +// ContainTaskType check if connector supports this task type. +func (p *ConnectorService) ContainTaskType(taskType string) bool { + p.mu.RLock() + defer p.mu.RUnlock() + return slices.Contains(p.supportedTaskTypes, taskType) +} + +// SetSupportedTaskType set supportTaskType in the connector service. +func (p *ConnectorService) SetSupportedTaskType(taskTypes []string) { + p.mu.Lock() + defer p.mu.Unlock() + p.supportedTaskTypes = taskTypes +} + +type RegistryKey struct { + domain string + taskTypeName string + taskTypeVersion int32 +} + +type Registry map[RegistryKey]*Connector + +// getSupportedTaskTypes Get all the supported task types in the registry. +func (r Registry) getSupportedTaskTypes() []string { + var taskTypes []string + for k := range r { + taskTypes = append(taskTypes, k.taskTypeName) + } + return taskTypes +} + +type Plugin struct { + metricScope promutils.Scope + cfg *Config + cs *ClientSet + registry Registry + mu sync.RWMutex +} + +type ResourceWrapper struct { + Phase flyteIdl.TaskExecution_Phase + Outputs *task.Outputs + Message string + LogLinks []*flyteIdl.TaskLog + CustomInfo *structpb.Struct + ConnectorID string + IsConnectorApp bool +} + +// IsTerminal is used to avoid making network calls to the connector service if the resource is already in a terminal state. +func (r ResourceWrapper) IsTerminal() bool { + return r.Phase == flyteIdl.TaskExecution_SUCCEEDED || r.Phase == flyteIdl.TaskExecution_FAILED || r.Phase == flyteIdl.TaskExecution_ABORTED +} + +type ResourceMetaWrapper struct { + OutputPrefix string + ConnectorResourceMeta []byte + TaskCategory connectorPb.TaskCategory + Domain string + Connection flyteIdl.Connection +} + +func (p *Plugin) setRegistry(r Registry) { + p.mu.Lock() + defer p.mu.Unlock() + p.registry = r +} + +func (p *Plugin) GetConfig() webapi.PluginConfig { + return GetConfig().WebAPI +} + +func (p *Plugin) ResourceRequirements(_ context.Context, _ webapi.TaskExecutionContextReader) ( + namespace core.ResourceNamespace, constraints core.ResourceConstraintsSpec, err error) { + + // Resource requirements are assumed to be the same. + return "default", p.cfg.ResourceConstraints, nil +} + +func (p *Plugin) Create(ctx context.Context, taskCtx webapi.TaskExecutionContextReader) (webapi.ResourceMeta, + webapi.Resource, error) { + taskTemplate, err := taskCtx.TaskReader().Read(ctx) + if err != nil { + return nil, nil, fmt.Errorf("failed to read task template with error: %v", err) + } + literalMap, err := taskCtx.InputReader().Get(ctx) + if err != nil { + return nil, nil, fmt.Errorf("failed to read inputs with error: %v", err) + } + + var argTemplate []string + if taskTemplate.GetContainer() != nil { + templateParameters := template.Parameters{ + TaskExecMetadata: taskCtx.TaskExecutionMetadata(), + Inputs: taskCtx.InputReader(), + OutputPath: taskCtx.OutputWriter(), + Task: taskCtx.TaskReader(), + } + argTemplate = taskTemplate.GetContainer().GetArgs() + modifiedArgs, err := template.Render(ctx, taskTemplate.GetContainer().GetArgs(), templateParameters) + if err != nil { + return nil, nil, fmt.Errorf("failed to render args with error: %v", err) + } + taskTemplate.GetContainer().Args = modifiedArgs + defer func() { + // Restore unrendered template for subsequent renders. + taskTemplate.GetContainer().Args = argTemplate + }() + } + outputPrefix := taskCtx.OutputWriter().GetOutputPrefixPath().String() + + taskCategory := connectorPb.TaskCategory{Name: taskTemplate.GetType(), Version: taskTemplate.GetTaskTypeVersion()} + connector, err := p.getFinalConnector(&taskCategory, p.cfg, taskTemplate.GetId().GetDomain()) + if err != nil { + return nil, nil, err + } + + connection := flyteIdl.Connection{} + err = utils.UnmarshalStruct(taskTemplate.GetCustom(), &connection) + if err != nil { + return nil, nil, fmt.Errorf("failed to unmarshal connection from task template custom: %v", err) + } + labels := taskCtx.TaskExecutionMetadata().GetLabels() + for k, v := range connection.GetSecrets() { + secretID, err := secret.GetSecretID(v, labels) + if err != nil { + errString := fmt.Sprintf("Failed to get secret id with error: %v", err) + logger.Errorf(ctx, errString) + return nil, nil, status.Errorf(codes.Internal, errString) + } + secretVal, err := taskCtx.SecretManager().Get(ctx, secretID) + if err != nil { + errString := fmt.Sprintf("Failed to get secret value with error: %v", err) + logger.Errorf(ctx, errString) + return nil, nil, status.Errorf(codes.Internal, errString) + } + connection.Secrets[k] = secretVal + } + + taskExecutionMetadata := buildTaskExecutionMetadata(taskCtx.TaskExecutionMetadata()) + + finalCtx, cancel := getFinalContext(ctx, "CreateTask", connector.ConnectorDeployment) + defer cancel() + + // Use async connector client + client, err := p.getAsyncConnectorClient(ctx, connector.ConnectorDeployment) + if err != nil { + return nil, nil, err + } + var inputs *task.Inputs + if literalMap != nil { + var literals []*task.NamedLiteral + for name, val := range literalMap.Literals { + literals = append(literals, &task.NamedLiteral{Name: name, Value: val}) + } + inputs = &task.Inputs{Literals: literals} + } + + request := &connectorPb.CreateTaskRequest{ + Inputs: inputs, + Template: taskTemplate, + OutputPrefix: outputPrefix, + TaskExecutionMetadata: &taskExecutionMetadata, + Connection: &connection, + } + res, err := client.CreateTask(finalCtx, request) + if err != nil { + return nil, nil, fmt.Errorf("failed to create task from connector with %v", err) + } + + return ResourceMetaWrapper{ + OutputPrefix: outputPrefix, + ConnectorResourceMeta: res.GetResourceMeta(), + TaskCategory: taskCategory, + Connection: connection, + Domain: taskTemplate.GetId().GetDomain(), + }, nil, nil +} + +func (p *Plugin) Get(ctx context.Context, taskCtx webapi.GetContext) (latest webapi.Resource, err error) { + metadata := taskCtx.ResourceMeta().(ResourceMetaWrapper) + connector, err := p.getFinalConnector(&metadata.TaskCategory, p.cfg, metadata.Domain) + if err != nil { + return nil, err + } + + client, err := p.getAsyncConnectorClient(ctx, connector.ConnectorDeployment) + if err != nil { + return nil, err + } + finalCtx, cancel := getFinalContext(ctx, "GetTask", connector.ConnectorDeployment) + defer cancel() + + request := &connectorPb.GetTaskRequest{ + TaskCategory: &metadata.TaskCategory, + ResourceMeta: metadata.ConnectorResourceMeta, + OutputPrefix: metadata.OutputPrefix, + Connection: &metadata.Connection, + } + res, err := client.GetTask(finalCtx, request) + if err != nil { + return nil, fmt.Errorf("failed to get task from connector with %v", err) + } + + return ResourceWrapper{ + Phase: res.GetResource().GetPhase(), + Outputs: res.GetResource().GetOutputs(), + Message: res.GetResource().GetMessage(), + LogLinks: res.GetResource().GetLogLinks(), + CustomInfo: res.GetResource().GetCustomInfo(), + ConnectorID: connector.ConnectorID, + IsConnectorApp: connector.IsConnectorApp, + }, nil +} + +func (p *Plugin) Delete(ctx context.Context, taskCtx webapi.DeleteContext) error { + if taskCtx.ResourceMeta() == nil { + return nil + } + metadata := taskCtx.ResourceMeta().(ResourceMetaWrapper) + connector, err := p.getFinalConnector(&metadata.TaskCategory, p.cfg, metadata.Domain) + if err != nil { + return err + } + + client, err := p.getAsyncConnectorClient(ctx, connector.ConnectorDeployment) + if err != nil { + return err + } + finalCtx, cancel := getFinalContext(ctx, "DeleteTask", connector.ConnectorDeployment) + defer cancel() + + request := &connectorPb.DeleteTaskRequest{ + TaskCategory: &metadata.TaskCategory, + ResourceMeta: metadata.ConnectorResourceMeta, + Connection: &metadata.Connection, + } + _, err = client.DeleteTask(finalCtx, request) + if err != nil { + return fmt.Errorf("failed to delete task from connector with %v", err) + } + return nil +} + +func (p *Plugin) getEventInfoForConnectorApp(taskCtx webapi.StatusContext, resource ResourceWrapper) ([]*flyteIdl.TaskLog, error) { + logPlugin, err := logs.InitializeLogPlugins(&p.cfg.Logs) + if err != nil { + return nil, fmt.Errorf("failed to initialize log plugins with error: %v", err) + } + taskLogs := resource.LogLinks + + if taskCtx.TaskExecutionMetadata().GetTaskExecutionID() == nil || !resource.IsConnectorApp { + return taskLogs, nil + } + + in := tasklog.Input{ + TaskExecutionID: taskCtx.TaskExecutionMetadata().GetTaskExecutionID(), + ConnectorID: resource.ConnectorID, + } + + logs, err := logPlugin.GetTaskLogs(in) + if err != nil { + return nil, fmt.Errorf("failed to get task logs with error: %v", err) + } + + taskLogs = append(taskLogs, logs.TaskLogs...) + + return taskLogs, nil +} + +func (p *Plugin) Status(ctx context.Context, taskCtx webapi.StatusContext) (phase core.PhaseInfo, err error) { + resource := taskCtx.Resource().(ResourceWrapper) + + logLinks, err := p.getEventInfoForConnectorApp(taskCtx, resource) + if err != nil { + return core.PhaseInfoUndefined, err + } + + taskInfo := &core.TaskInfo{Logs: logLinks, CustomInfo: resource.CustomInfo} + errorCode := pluginErrors.TaskFailedWithError + + switch resource.Phase { + case flyteIdl.TaskExecution_QUEUED: + return core.PhaseInfoQueuedWithTaskInfo(time.Now(), core.DefaultPhaseVersion, resource.Message, taskInfo), nil + case flyteIdl.TaskExecution_WAITING_FOR_RESOURCES: + return core.PhaseInfoWaitingForResourcesInfo(time.Now(), core.DefaultPhaseVersion, resource.Message, taskInfo), nil + case flyteIdl.TaskExecution_INITIALIZING: + return core.PhaseInfoInitializing(time.Now(), core.DefaultPhaseVersion, resource.Message, taskInfo), nil + case flyteIdl.TaskExecution_RUNNING: + return core.PhaseInfoRunning(core.DefaultPhaseVersion, taskInfo), nil + case flyteIdl.TaskExecution_SUCCEEDED: + if resource.Outputs != nil { + var literalMap *flyteIdl.LiteralMap + literalMap = &flyteIdl.LiteralMap{Literals: make(map[string]*flyteIdl.Literal)} + for _, val := range resource.Outputs.Literals { + literalMap.Literals[val.Name] = val.Value + } + // TODO: Add support writing outputs proto. + err = writeOutput(ctx, taskCtx, literalMap) + if err != nil { + logger.Errorf(ctx, "failed to write output with err %s", err.Error()) + return core.PhaseInfoUndefined, err + } + } + return core.PhaseInfoSuccess(taskInfo), nil + case flyteIdl.TaskExecution_ABORTED: + return core.PhaseInfoFailure(errorCode, "failed to run the job with aborted phase.", taskInfo), nil + case flyteIdl.TaskExecution_FAILED: + return core.PhaseInfoFailure(errorCode, fmt.Sprintf("failed to run the job: %s", resource.Message), taskInfo), nil + } + // The default phase is undefined. + return core.PhaseInfoUndefined, pluginErrors.Errorf(core.SystemErrorCode, "unknown execution phase [%v].", resource.Phase) +} + +func (p *Plugin) getAsyncConnectorClient(ctx context.Context, connector *Deployment) (connectorPb.AsyncConnectorServiceClient, error) { + client, ok := p.cs.asyncConnectorClients[connector.Endpoint] + if !ok { + conn, err := getGrpcConnection(ctx, connector) + if err != nil { + return nil, err + } + client = connectorPb.NewAsyncConnectorServiceClient(conn) + p.cs.asyncConnectorClients[connector.Endpoint] = client + } + return client, nil +} + +func (p *Plugin) watchConnectors(ctx context.Context, connectorService *ConnectorService) { + go wait.Until(func() { + childCtx, cancel := context.WithCancel(ctx) + defer cancel() + clientSet := getConnectorClientSets(childCtx) + connectorRegistry := getConnectorRegistry(childCtx, clientSet) + p.setRegistry(connectorRegistry) + connectorService.SetSupportedTaskType(connectorRegistry.getSupportedTaskTypes()) + }, p.cfg.PollInterval.Duration, ctx.Done()) +} + +func (p *Plugin) getFinalConnector(taskCategory *connectorPb.TaskCategory, cfg *Config, domain string) (*Connector, error) { + p.mu.RLock() + defer p.mu.RUnlock() + + registryKey := RegistryKey{domain: domain, taskTypeName: taskCategory.GetName(), taskTypeVersion: taskCategory.GetVersion()} + if connector, exists := p.registry[registryKey]; exists { + return connector, nil + } + logger.Debugf(context.Background(), "No connector found for task type [%s] and version [%d] in domain [%s].", taskCategory.GetName(), taskCategory.GetVersion(), domain) + + // Use the connector that supports across all domains. + registryKey = RegistryKey{domain: "", taskTypeName: taskCategory.GetName(), taskTypeVersion: taskCategory.GetVersion()} + if connector, exists := p.registry[registryKey]; exists { + return connector, nil + } + logger.Debugf(context.Background(), "No connector found for task type [%s] and version [%d] in any domain.", taskCategory.GetName(), taskCategory.GetVersion()) + + if len(cfg.DefaultConnector.Endpoint) != 0 { + return &Connector{ + ConnectorDeployment: &cfg.DefaultConnector, + ConnectorID: "defaultConnector", + IsConnectorApp: false, + }, nil + } + + logger.Errorf(context.Background(), "No connector found for task type [%s] and version [%d]. Using default connector.", taskCategory.GetName(), taskCategory.GetVersion()) + return nil, fmt.Errorf("no connector found for task type [%s] and version [%d]", taskCategory.GetName(), taskCategory.GetVersion()) +} + +func writeOutput(ctx context.Context, taskCtx webapi.StatusContext, outputs *flyteIdl.LiteralMap) error { + taskTemplate, err := taskCtx.TaskReader().Read(ctx) + if err != nil { + return err + } + + if taskTemplate.GetInterface() == nil || taskTemplate.GetInterface().GetOutputs() == nil || taskTemplate.Interface.Outputs.Variables == nil { + logger.Debugf(ctx, "The task declares no outputs. Skipping writing the outputs.") + return nil + } + + var opReader io.OutputReader + if outputs != nil { + logger.Debugf(ctx, "ConnectorDeployment returned an output.") + opReader = ioutils.NewInMemoryOutputReader(outputs, nil, nil) + } else { + logger.Debugf(ctx, "ConnectorDeployment didn't return any output, assuming file based outputs.") + opReader = ioutils.NewRemoteFileOutputReader(ctx, taskCtx.DataStore(), taskCtx.OutputWriter(), 0) + } + return taskCtx.OutputWriter().Put(ctx, opReader) +} + +func buildTaskExecutionMetadata(taskExecutionMetadata core.TaskExecutionMetadata) connectorPb.TaskExecutionMetadata { + taskExecutionID := taskExecutionMetadata.GetTaskExecutionID().GetID() + + return connectorPb.TaskExecutionMetadata{ + TaskExecutionId: &taskExecutionID, + Namespace: taskExecutionMetadata.GetNamespace(), + Labels: taskExecutionMetadata.GetLabels(), + Annotations: taskExecutionMetadata.GetAnnotations(), + K8SServiceAccount: taskExecutionMetadata.GetK8sServiceAccount(), + EnvironmentVariables: taskExecutionMetadata.GetEnvironmentVariables(), + Identity: taskExecutionMetadata.GetSecurityContext().RunAs, // nolint:protogetter + } +} + +func newConnectorPlugin(connectorService *ConnectorService) webapi.PluginEntry { + ctx := context.Background() + gob.Register(ResourceMetaWrapper{}) + gob.Register(ResourceWrapper{}) + + clientSet := getConnectorClientSets(ctx) + connectorRegistry := getConnectorRegistry(ctx, clientSet) + supportedTaskTypes := connectorRegistry.getSupportedTaskTypes() + connectorService.SetSupportedTaskType(supportedTaskTypes) + + plugin := &Plugin{ + metricScope: promutils.NewScope("connector_plugin"), + cfg: GetConfig(), + cs: clientSet, + registry: connectorRegistry, + } + plugin.watchConnectors(ctx, connectorService) + + return webapi.PluginEntry{ + ID: ID, + SupportedTaskTypes: supportedTaskTypes, + PluginLoader: func(ctx context.Context, iCtx webapi.PluginSetupContext) (webapi.AsyncPlugin, error) { + return plugin, nil + }, + } +} + +func RegisterConnectorPlugin(connectorService *ConnectorService) { + fmt.Printf("Registering connector plugin...\n") + gob.Register(ResourceMetaWrapper{}) + gob.Register(ResourceWrapper{}) + pluginmachinery.PluginRegistry().RegisterRemotePlugin(newConnectorPlugin(connectorService)) +} diff --git a/flyteplugins/go/tasks/plugins/webapi/connector/plugin_test.go b/flyteplugins/go/tasks/plugins/webapi/connector/plugin_test.go new file mode 100644 index 0000000000..c58c61dea4 --- /dev/null +++ b/flyteplugins/go/tasks/plugins/webapi/connector/plugin_test.go @@ -0,0 +1,305 @@ +package connector + +import ( + "context" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "golang.org/x/exp/maps" + + connectorPb "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector" + + pluginsCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + pluginCoreMocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + webapiPlugin "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/webapi/mocks" + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + connectorMocks "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector/mocks" + flyteIdlCore "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +const defaultConnectorEndpoint = "localhost:8000" + +func TestPlugin(t *testing.T) { + fakeSetupContext := pluginCoreMocks.SetupContext{} + fakeSetupContext.On("MetricsScope").Return(promutils.NewScope("test")) + + cfg := defaultConfig + cfg.WebAPI.Caching.Workers = 1 + cfg.WebAPI.Caching.ResyncInterval.Duration = 5 * time.Second + cfg.DefaultConnector = Deployment{Endpoint: "test-connector.flyte.svc.cluster.local:80"} + cfg.ConnectorDeployments = map[string]*Deployment{"spark_connector": {Endpoint: "localhost:80"}} + cfg.ConnectorForTaskTypes = map[string]string{"spark": "spark_connector", "bar": "bar_connector"} + + sparkConnector := &Connector{ConnectorDeployment: &Deployment{Endpoint: "localhost:80"}} + sparkKey := RegistryKey{domain: "", taskTypeName: "spark", taskTypeVersion: defaultTaskTypeVersion} + rayConnector := &Connector{ConnectorDeployment: &Deployment{Endpoint: "localhost:8080"}} + rayKey := RegistryKey{domain: "production", taskTypeName: "ray", taskTypeVersion: defaultTaskTypeVersion} + connectorRegistry := Registry{sparkKey: sparkConnector, rayKey: rayConnector} + plugin := Plugin{ + metricScope: fakeSetupContext.MetricsScope(), + cfg: GetConfig(), + registry: connectorRegistry, + } + t.Run("get config", func(t *testing.T) { + err := SetConfig(&cfg) + assert.NoError(t, err) + assert.Equal(t, cfg.WebAPI, plugin.GetConfig()) + }) + t.Run("get ResourceRequirements", func(t *testing.T) { + namespace, constraints, err := plugin.ResourceRequirements(context.TODO(), nil) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.ResourceNamespace("default"), namespace) + assert.Equal(t, plugin.cfg.ResourceConstraints, constraints) + }) + + t.Run("test newConnectorPlugin", func(t *testing.T) { + p := newMockAsyncConnectorPlugin() + assert.NotNil(t, p) + assert.Equal(t, "connector-service", p.ID) + assert.NotNil(t, p.PluginLoader) + }) + + t.Run("test getFinalConnector", func(t *testing.T) { + spark := &connectorPb.TaskCategory{Name: "spark", Version: defaultTaskTypeVersion} + ray := &connectorPb.TaskCategory{Name: "ray", Version: defaultTaskTypeVersion} + foo := &connectorPb.TaskCategory{Name: "foo", Version: defaultTaskTypeVersion} + bar := &connectorPb.TaskCategory{Name: "bar", Version: defaultTaskTypeVersion} + connector, err := plugin.getFinalConnector(spark, &cfg, "") + assert.NoError(t, err) + assert.Equal(t, connector.ConnectorDeployment.Endpoint, "localhost:80") + connector, err = plugin.getFinalConnector(foo, &cfg, "") + assert.NoError(t, err) + assert.Equal(t, connector.ConnectorDeployment.Endpoint, cfg.DefaultConnector.Endpoint) + connector, err = plugin.getFinalConnector(bar, &cfg, "") + assert.NoError(t, err) + assert.Equal(t, connector.ConnectorDeployment.Endpoint, cfg.DefaultConnector.Endpoint) + connector, err = plugin.getFinalConnector(ray, &cfg, "production") + assert.NoError(t, err) + assert.Equal(t, connector.ConnectorDeployment.Endpoint, rayConnector.ConnectorDeployment.Endpoint) + }) + + t.Run("test getFinalTimeout", func(t *testing.T) { + timeout := getFinalTimeout("CreateTask", &Deployment{Endpoint: "localhost:8080", Timeouts: map[string]config.Duration{"CreateTask": {Duration: 1 * time.Millisecond}}}) + assert.Equal(t, 1*time.Millisecond, timeout.Duration) + timeout = getFinalTimeout("GetTask", &Deployment{Endpoint: "localhost:8080", Timeouts: map[string]config.Duration{"GetTask": {Duration: 1 * time.Millisecond}}}) + assert.Equal(t, 1*time.Millisecond, timeout.Duration) + timeout = getFinalTimeout("DeleteTask", &Deployment{Endpoint: "localhost:8080", DefaultTimeout: config.Duration{Duration: 10 * time.Second}}) + assert.Equal(t, 10*time.Second, timeout.Duration) + timeout = getFinalTimeout("ExecuteTaskSync", &Deployment{Endpoint: "localhost:8080", Timeouts: map[string]config.Duration{"ExecuteTaskSync": {Duration: 1 * time.Millisecond}}}) + assert.Equal(t, 1*time.Millisecond, timeout.Duration) + }) + + t.Run("test getFinalContext", func(t *testing.T) { + + ctx, _ := getFinalContext(context.TODO(), "CreateTask", &Deployment{Endpoint: "localhost:8080", Timeouts: map[string]config.Duration{"CreateTask": {Duration: 1 * time.Millisecond}}}) + assert.NotEqual(t, context.TODO(), ctx) + + ctx, _ = getFinalContext(context.TODO(), "GetTask", &Deployment{Endpoint: "localhost:8080", Timeouts: map[string]config.Duration{"GetTask": {Duration: 1 * time.Millisecond}}}) + assert.NotEqual(t, context.TODO(), ctx) + + ctx, _ = getFinalContext(context.TODO(), "DeleteTask", &Deployment{}) + assert.Equal(t, context.TODO(), ctx) + + ctx, _ = getFinalContext(context.TODO(), "ExecuteTaskSync", &Deployment{Endpoint: "localhost:8080", Timeouts: map[string]config.Duration{"ExecuteTaskSync": {Duration: 10 * time.Second}}}) + assert.NotEqual(t, context.TODO(), ctx) + }) + + t.Run("test TaskExecution_UNDEFINED Status", func(t *testing.T) { + taskContext := new(webapiPlugin.StatusContext) + taskContext.On("Resource").Return(ResourceWrapper{ + Phase: flyteIdlCore.TaskExecution_UNDEFINED, + Outputs: nil, + Message: "", + LogLinks: []*flyteIdlCore.TaskLog{{Uri: "http://localhost:3000/log", Name: "Log Link"}}, + }) + + mockTaskMetadata := &pluginCoreMocks.TaskExecutionMetadata{} + mockTaskMetadata.On("GetTaskExecutionID").Return(&pluginCoreMocks.TaskExecutionID{}) + taskContext.On("TaskExecutionMetadata").Return(mockTaskMetadata) + + phase, err := plugin.Status(context.Background(), taskContext) + assert.NotNil(t, err) + assert.Equal(t, pluginsCore.PhaseUndefined, phase.Phase()) + }) + + t.Run("test TaskExecution_QUEUED Status", func(t *testing.T) { + taskContext := new(webapiPlugin.StatusContext) + taskContext.On("Resource").Return(ResourceWrapper{ + Phase: flyteIdlCore.TaskExecution_QUEUED, + Outputs: nil, + Message: "", + LogLinks: []*flyteIdlCore.TaskLog{{Uri: "http://localhost:3000/log", Name: "Log Link"}}, + }) + + mockTaskMetadata := &pluginCoreMocks.TaskExecutionMetadata{} + mockTaskMetadata.On("GetTaskExecutionID").Return(&pluginCoreMocks.TaskExecutionID{}) + taskContext.On("TaskExecutionMetadata").Return(mockTaskMetadata) + + phase, err := plugin.Status(context.Background(), taskContext) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseQueued, phase.Phase()) + }) + + t.Run("test TaskExecution_WAITING_FOR_RESOURCES Status", func(t *testing.T) { + taskContext := new(webapiPlugin.StatusContext) + taskContext.On("Resource").Return(ResourceWrapper{ + Phase: flyteIdlCore.TaskExecution_WAITING_FOR_RESOURCES, + Outputs: nil, + Message: "", + LogLinks: []*flyteIdlCore.TaskLog{{Uri: "http://localhost:3000/log", Name: "Log Link"}}, + }) + + mockTaskMetadata := &pluginCoreMocks.TaskExecutionMetadata{} + mockTaskMetadata.On("GetTaskExecutionID").Return(&pluginCoreMocks.TaskExecutionID{}) + taskContext.On("TaskExecutionMetadata").Return(mockTaskMetadata) + + phase, err := plugin.Status(context.Background(), taskContext) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseWaitingForResources, phase.Phase()) + }) + + t.Run("test TaskExecution_INITIALIZING Status", func(t *testing.T) { + taskContext := new(webapiPlugin.StatusContext) + taskContext.On("Resource").Return(ResourceWrapper{ + Phase: flyteIdlCore.TaskExecution_INITIALIZING, + Outputs: nil, + Message: "", + LogLinks: []*flyteIdlCore.TaskLog{{Uri: "http://localhost:3000/log", Name: "Log Link"}}, + }) + + mockTaskMetadata := &pluginCoreMocks.TaskExecutionMetadata{} + mockTaskMetadata.On("GetTaskExecutionID").Return(&pluginCoreMocks.TaskExecutionID{}) + taskContext.On("TaskExecutionMetadata").Return(mockTaskMetadata) + + phase, err := plugin.Status(context.Background(), taskContext) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseInitializing, phase.Phase()) + }) + + t.Run("test TaskExecution_RUNNING Status", func(t *testing.T) { + taskContext := new(webapiPlugin.StatusContext) + taskContext.On("Resource").Return(ResourceWrapper{ + Phase: flyteIdlCore.TaskExecution_RUNNING, + Outputs: nil, + Message: "", + LogLinks: []*flyteIdlCore.TaskLog{{Uri: "http://localhost:3000/log", Name: "Log Link"}}, + }) + + mockTaskMetadata := &pluginCoreMocks.TaskExecutionMetadata{} + mockTaskMetadata.On("GetTaskExecutionID").Return(&pluginCoreMocks.TaskExecutionID{}) + taskContext.On("TaskExecutionMetadata").Return(mockTaskMetadata) + + phase, err := plugin.Status(context.Background(), taskContext) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhaseRunning, phase.Phase()) + }) + + t.Run("test TaskExecution_ABORTED Status", func(t *testing.T) { + taskContext := new(webapiPlugin.StatusContext) + taskContext.On("Resource").Return(ResourceWrapper{ + Phase: flyteIdlCore.TaskExecution_ABORTED, + Outputs: nil, + Message: "", + LogLinks: []*flyteIdlCore.TaskLog{{Uri: "http://localhost:3000/log", Name: "Log Link"}}, + }) + + mockTaskMetadata := &pluginCoreMocks.TaskExecutionMetadata{} + mockTaskMetadata.On("GetTaskExecutionID").Return(&pluginCoreMocks.TaskExecutionID{}) + taskContext.On("TaskExecutionMetadata").Return(mockTaskMetadata) + + phase, err := plugin.Status(context.Background(), taskContext) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhasePermanentFailure, phase.Phase()) + }) + + t.Run("test TaskExecution_FAILED Status", func(t *testing.T) { + taskContext := new(webapiPlugin.StatusContext) + taskContext.On("Resource").Return(ResourceWrapper{ + Phase: flyteIdlCore.TaskExecution_FAILED, + Outputs: nil, + Message: "boom", + LogLinks: []*flyteIdlCore.TaskLog{{Uri: "http://localhost:3000/log", Name: "Log Link"}}, + }) + + mockTaskMetadata := &pluginCoreMocks.TaskExecutionMetadata{} + mockTaskMetadata.On("GetTaskExecutionID").Return(&pluginCoreMocks.TaskExecutionID{}) + taskContext.On("TaskExecutionMetadata").Return(mockTaskMetadata) + + phase, err := plugin.Status(context.Background(), taskContext) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhasePermanentFailure, phase.Phase()) + assert.Equal(t, "failed to run the job: boom", phase.Err().GetMessage()) + }) + + t.Run("test TaskExecution_FAILED Status Without Connector Error", func(t *testing.T) { + taskContext := new(webapiPlugin.StatusContext) + taskContext.On("Resource").Return(ResourceWrapper{ + Phase: flyteIdlCore.TaskExecution_FAILED, + Outputs: nil, + Message: "", + LogLinks: []*flyteIdlCore.TaskLog{{Uri: "http://localhost:3000/log", Name: "Log Link"}}, + }) + + mockTaskMetadata := &pluginCoreMocks.TaskExecutionMetadata{} + mockTaskMetadata.On("GetTaskExecutionID").Return(&pluginCoreMocks.TaskExecutionID{}) + taskContext.On("TaskExecutionMetadata").Return(mockTaskMetadata) + + phase, err := plugin.Status(context.Background(), taskContext) + assert.NoError(t, err) + assert.Equal(t, pluginsCore.PhasePermanentFailure, phase.Phase()) + }) +} + +func getMockMetadataServiceClient() *connectorMocks.ConnectorMetadataServiceClient { + mockMetadataServiceClient := new(connectorMocks.ConnectorMetadataServiceClient) + mockRequest := &connectorPb.ListConnectorsRequest{} + supportedTaskCategories := make([]*connectorPb.TaskCategory, 3) + supportedTaskCategories[0] = &connectorPb.TaskCategory{Name: "task1", Version: defaultTaskTypeVersion} + supportedTaskCategories[1] = &connectorPb.TaskCategory{Name: "task2", Version: defaultTaskTypeVersion} + supportedTaskCategories[2] = &connectorPb.TaskCategory{Name: "task3", Version: defaultTaskTypeVersion} + mockResponse := &connectorPb.ListConnectorsResponse{ + Connectors: []*connectorPb.Connector{ + { + Name: "test-agent", + SupportedTaskCategories: supportedTaskCategories, + }, + }, + } + + mockMetadataServiceClient.On("ListConnectors", mock.Anything, mockRequest).Return(mockResponse, nil) + return mockMetadataServiceClient +} + +func TestInitializeConnectorRegistry(t *testing.T) { + connectorClients := make(map[string]connectorPb.AsyncConnectorServiceClient) + connectorMetadataClients := make(map[string]connectorPb.ConnectorMetadataServiceClient) + client := &connectorMocks.AsyncConnectorServiceClient{} + connectorClients[defaultConnectorEndpoint] = client + connectorMetadataClients[defaultConnectorEndpoint] = getMockMetadataServiceClient() + + cs := &ClientSet{ + asyncConnectorClients: connectorClients, + connectorMetadataClients: connectorMetadataClients, + } + + cfg := defaultConfig + cfg.ConnectorDeployments = map[string]*Deployment{"custom_connector": {Endpoint: defaultConnectorEndpoint}} + cfg.ConnectorForTaskTypes = map[string]string{"task1": "connector-deployment-1", "task2": "connector-deployment-2"} + err := SetConfig(&cfg) + assert.NoError(t, err) + + connectorRegistry := getConnectorRegistry(context.Background(), cs) + connectorRegistryKeys := maps.Keys(connectorRegistry) + supportTaskTypes := []string{"task1", "task2", "task3", "task_type_3", "task_type_4"} + var expectedKeys []RegistryKey + for _, taskType := range supportTaskTypes { + expectedKeys = append(expectedKeys, RegistryKey{taskTypeName: taskType, taskTypeVersion: defaultTaskTypeVersion}) + } + + for _, key := range expectedKeys { + assert.Contains(t, connectorRegistryKeys, key) + } +} diff --git a/flyteplugins/go/tasks/testdata/config.yaml b/flyteplugins/go/tasks/testdata/config.yaml new file mode 100755 index 0000000000..59d6a99c96 --- /dev/null +++ b/flyteplugins/go/tasks/testdata/config.yaml @@ -0,0 +1,94 @@ +# Sample plugins config +plugins: + # All k8s plugins default configuration + k8s: + inject-finalizer: true + default-annotations: + - annotationKey1: annotationValue1 + - annotationKey2: annotationValue2 + default-labels: + - label1: labelValue1 + - label2: labelValue2 + resource-tolerations: + nvidia.com/gpu: + key: flyte/gpu + value: dedicated + operator: Equal + effect: NoSchedule + storage: + - key: storage + value: special + operator: Equal + effect: PreferNoSchedule + interruptible-node-selector: + - x/interruptible: "true" + interruptible-tolerations: + - key: x/flyte + value: interruptible + operator: Equal + effect: NoSchedule + default-env-vars: + - AWS_METADATA_SERVICE_TIMEOUT: 5 + - AWS_METADATA_SERVICE_NUM_ATTEMPTS: 20 + - FLYTE_AWS_ENDPOINT: "http://minio.flyte:9000" + - FLYTE_AWS_ACCESS_KEY_ID: minio + - FLYTE_AWS_SECRET_ACCESS_KEY: miniostorage + default-pod-security-context: + runAsUser: 1000 + runAsGroup: 3000 + fsGroup: 2000 + default-security-context: + allowPrivilegeEscalation: false + enable-host-networking-pod: true + default-pod-dns-config: + options: + - name: "ndots" + value: "1" + - name: "single-request-reopen" + - name: "timeout" + value: "1" + - name: "attempts" + value: "3" + nameservers: + - "8.8.8.8" + - "8.8.4.4" + searches: + - "ns1.svc.cluster-domain.example" + - "my.dns.search.suffix" + + # Spark Plugin configuration + spark: + spark-config-default: + - spark.hadoop.mapreduce.fileoutputcommitter.algorithm.version: "2" + - spark.kubernetes.allocation.batch.size: "50" + - spark.hadoop.fs.s3a.acl.default: "BucketOwnerFullControl" + - spark.hadoop.fs.s3n.impl: "org.apache.hadoop.fs.s3a.S3AFileSystem" + - spark.hadoop.fs.AbstractFileSystem.s3n.impl: "org.apache.hadoop.fs.s3a.S3A" + - spark.hadoop.fs.s3.impl: "org.apache.hadoop.fs.s3a.S3AFileSystem" + - spark.hadoop.fs.AbstractFileSystem.s3.impl: "org.apache.hadoop.fs.s3a.S3A" + - spark.hadoop.fs.s3a.impl: "org.apache.hadoop.fs.s3a.S3AFileSystem" + - spark.hadoop.fs.AbstractFileSystem.s3a.impl: "org.apache.hadoop.fs.s3a.S3A" + - spark.hadoop.fs.s3a.multipart.threshold: "536870912" + - spark.blacklist.enabled: "true" + - spark.blacklist.timeout: "5m" + features: + - name: "feature1" + spark-config: + - spark.hadoop.feature1: "true" + - spark.sql.feature1: "true" + - name: "feature2" + spark-config: + - spark.hadoop.feature2: "true" + - spark.sql.feature2: "true" + logs: + mixed: + kubernetes-enabled: true + kubernetes-url: "http://localhost:30082" + # Logging configuration + logs: + kubernetes-enabled: true + kubernetes-url: "http://localhost:30082" + azure-log-templates: + - displayName: "Test Azure Logs" + templateUris: + - "https://portal.azure.com#@TEST_AZURE_URI/q/" diff --git a/flyteplugins/go/tasks/testdata/incorrect-config.yaml b/flyteplugins/go/tasks/testdata/incorrect-config.yaml new file mode 100755 index 0000000000..719b6113d7 --- /dev/null +++ b/flyteplugins/go/tasks/testdata/incorrect-config.yaml @@ -0,0 +1,7 @@ +# Sample plugins config +plugins: + # Logging configuration + logs: + config: + kubernetes-enabled: true + kubernetes-url: "http://localhost:30082" diff --git a/flyteplugins/tests/end_to_end.go b/flyteplugins/tests/end_to_end.go new file mode 100644 index 0000000000..d6b48a31ee --- /dev/null +++ b/flyteplugins/tests/end_to_end.go @@ -0,0 +1,289 @@ +package tests + +import ( + "context" + "encoding/json" + "sync" + "sync/atomic" + "testing" + "time" + + "github.com/go-test/deep" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + v12 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + "k8s.io/apimachinery/pkg/util/rand" + + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/catalog" + catalogMocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/catalog/mocks" + pluginCore "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core" + coreMocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/core/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io" + ioMocks "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/io/mocks" + "github.com/flyteorg/flyte/v2/flyteplugins/go/tasks/pluginmachinery/workqueue" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + idlCore "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +func createSampleContainerTask() *idlCore.Container { + return &idlCore.Container{ + Command: []string{"cmd"}, + Args: []string{"{{$inputPrefix}}"}, + Image: "img1", + Config: []*idlCore.KeyValuePair{ + { + Key: "dynamic_queue", + Value: "queue1", + }, + }, + } +} + +func BuildTaskTemplate() *idlCore.TaskTemplate { + return &idlCore.TaskTemplate{ + Target: &idlCore.TaskTemplate_Container{ + Container: createSampleContainerTask(), + }, + } +} + +func RunPluginEndToEndTest(t *testing.T, executor pluginCore.Plugin, template *idlCore.TaskTemplate, + inputs *idlCore.LiteralMap, expectedOutputs *idlCore.LiteralMap, expectedFailure *idlCore.ExecutionError, + iterationUpdate func(ctx context.Context, tCtx pluginCore.TaskExecutionContext) error) pluginCore.PhaseInfo { + + ctx := context.Background() + + ds, err := storage.NewDataStore(&storage.Config{Type: storage.TypeMemory}, promutils.NewTestScope()) + assert.NoError(t, err) + + execID := rand.String(3) + + basePrefix := storage.DataReference("fake://bucket/prefix/" + execID) + assert.NoError(t, ds.WriteProtobuf(ctx, basePrefix+"/inputs.pb", storage.Options{}, inputs)) + + tr := &coreMocks.TaskReader{} + tr.EXPECT().Read(ctx).Return(template, nil) + + inputReader := &ioMocks.InputReader{} + inputReader.EXPECT().GetInputPrefixPath().Return(basePrefix) + inputReader.EXPECT().GetInputPath().Return(basePrefix + "/inputs.pb") + inputReader.EXPECT().Get(mock.Anything).Return(inputs, nil) + + outputWriter := &ioMocks.OutputWriter{} + outputWriter.EXPECT().GetRawOutputPrefix().Return("/sandbox/") + outputWriter.EXPECT().GetOutputPrefixPath().Return(basePrefix) + outputWriter.EXPECT().GetErrorPath().Return(basePrefix + "/error.pb") + outputWriter.EXPECT().GetOutputPath().Return(basePrefix + "/outputs.pb") + outputWriter.EXPECT().GetCheckpointPrefix().Return("/checkpoint") + outputWriter.EXPECT().GetPreviousCheckpointsPrefix().Return("/prev") + + outputWriter.EXPECT().Put(mock.Anything, mock.Anything).Return(nil).Run(func(ctx context.Context, reader io.OutputReader) { + literals, ee, err := reader.Read(ctx) + assert.NoError(t, err) + + if ee != nil { + assert.NoError(t, ds.WriteProtobuf(ctx, outputWriter.GetErrorPath(), storage.Options{}, ee)) + } + + if literals != nil { + assert.NoError(t, ds.WriteProtobuf(ctx, outputWriter.GetOutputPath(), storage.Options{}, literals)) + } + }) + + pluginStateWriter := &coreMocks.PluginStateWriter{} + latestKnownState := atomic.Value{} + pluginStateWriter.EXPECT().Put(mock.Anything, mock.Anything).Return(nil).Run(func(_ uint8, v interface{}) { + latestKnownState.Store(v) + }) + + pluginStateWriter.EXPECT().Reset().Return(nil).Run(func() { + latestKnownState.Store(nil) + }) + + pluginStateReader := &coreMocks.PluginStateReader{} + pluginStateReader.EXPECT().Get(mock.Anything).Return(0, nil).Run(func(state interface{}) { + x, err := json.Marshal(latestKnownState.Load()) + assert.NoError(t, err) + assert.NoError(t, json.Unmarshal(x, &state)) + }) + pluginStateReader.EXPECT().GetStateVersion().Return(0) + + tID := &coreMocks.TaskExecutionID{} + tID.EXPECT().GetGeneratedName().Return(execID + "-my-task-1") + tID.EXPECT().GetID().Return(idlCore.TaskExecutionIdentifier{ + TaskId: &idlCore.Identifier{ + ResourceType: idlCore.ResourceType_TASK, + Project: "a", + Domain: "d", + Name: "n", + Version: "abc", + }, + NodeExecutionId: &idlCore.NodeExecutionIdentifier{ + NodeId: "node1", + ExecutionId: &idlCore.WorkflowExecutionIdentifier{ + Project: "a", + Domain: "d", + Name: "exec", + }, + }, + RetryAttempt: 0, + }) + tID.EXPECT().GetUniqueNodeID().Return("unique-node-id") + + overrides := &coreMocks.TaskOverrides{} + overrides.EXPECT().GetConfigMap().Return(&v1.ConfigMap{Data: map[string]string{ + "dynamic-queue": "queue1", + }}) + overrides.EXPECT().GetResources().Return(&v1.ResourceRequirements{ + Requests: map[v1.ResourceName]resource.Quantity{}, + Limits: map[v1.ResourceName]resource.Quantity{}, + }) + overrides.EXPECT().GetExtendedResources().Return(&idlCore.ExtendedResources{}) + overrides.EXPECT().GetContainerImage().Return("") + overrides.EXPECT().GetPodTemplate().Return(nil) + + connections := map[string]pluginCore.ConnectionWrapper{ + "my-openai": { + Connection: idlCore.Connection{ + TaskType: "openai", + Secrets: map[string]string{"key": "value"}, + Configs: map[string]string{"key": "value"}, + }, + Source: common.AttributesSource_GLOBAL, + }, + } + + tMeta := &coreMocks.TaskExecutionMetadata{} + tMeta.EXPECT().GetTaskExecutionID().Return(tID) + tMeta.EXPECT().GetOverrides().Return(overrides) + tMeta.EXPECT().GetK8sServiceAccount().Return("s") + tMeta.EXPECT().GetNamespace().Return("fake-development") + tMeta.EXPECT().GetMaxAttempts().Return(2) + tMeta.EXPECT().GetSecurityContext().Return(idlCore.SecurityContext{ + RunAs: &idlCore.Identity{ + K8SServiceAccount: "s", + }, + }) + tMeta.EXPECT().GetLabels().Return(map[string]string{"organization": "flyte", "project": "flytesnacks", "domain": "development"}) + tMeta.EXPECT().GetAnnotations().Return(map[string]string{}) + tMeta.EXPECT().IsInterruptible().Return(true) + tMeta.EXPECT().GetOwnerReference().Return(v12.OwnerReference{}) + tMeta.EXPECT().GetOwnerID().Return(types.NamespacedName{ + Namespace: "fake-development", + Name: execID, + }) + tMeta.EXPECT().GetPlatformResources().Return(&v1.ResourceRequirements{}) + tMeta.EXPECT().GetInterruptibleFailureThreshold().Return(2) + tMeta.EXPECT().GetEnvironmentVariables().Return(nil) + tMeta.EXPECT().GetExternalResourceAttributes().Return(pluginCore.ExternalResourceAttributes{Connections: connections}) + tMeta.EXPECT().GetConsoleURL().Return("") + + catClient := &catalogMocks.Client{} + catData := sync.Map{} + catClient.On("Get", mock.Anything, mock.Anything).Return( + func(ctx context.Context, key catalog.Key) io.OutputReader { + data, found := catData.Load(key) + if !found { + return nil + } + + or := &ioMocks.OutputReader{} + or.EXPECT().Exists(mock.Anything).Return(true, nil) + or.EXPECT().IsError(mock.Anything).Return(false, nil) + or.EXPECT().Read(mock.Anything).Return(data.(*idlCore.LiteralMap), nil, nil) + return or + }, + func(ctx context.Context, key catalog.Key) error { + _, found := catData.Load(key) + if !found { + return status.Error(codes.NotFound, "No output found for key") + } + + return nil + }) + catClient.On(mock.Anything, mock.Anything, mock.Anything, mock.Anything). + Return(nil). + Run(func(args mock.Arguments) { + key := args.Get(1).(catalog.Key) + or := args.Get(2).(io.OutputReader) + o, ee, err := or.Read(ctx) + assert.NoError(t, err) + // TODO: Outputting error is not yet supported. + assert.Nil(t, ee) + catData.Store(key, o) + }) + cat, err := catalog.NewAsyncClient(catClient, catalog.Config{ + ReaderWorkqueueConfig: workqueue.Config{ + MaxRetries: 0, + Workers: 2, + IndexCacheMaxItems: 100, + }, + WriterWorkqueueConfig: workqueue.Config{ + MaxRetries: 0, + Workers: 2, + IndexCacheMaxItems: 100, + }, + }, promutils.NewTestScope()) + assert.NoError(t, err) + assert.NoError(t, cat.Start(ctx)) + + eRecorder := &coreMocks.EventsRecorder{} + eRecorder.EXPECT().RecordRaw(mock.Anything, mock.Anything).Return(nil) + + resourceManager := &coreMocks.ResourceManager{} + resourceManager.EXPECT().AllocateResource(mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(pluginCore.AllocationStatusGranted, nil) + resourceManager.EXPECT().ReleaseResource(mock.Anything, mock.Anything, mock.Anything).Return(nil) + + secretManager := &coreMocks.SecretManager{} + secretManager.EXPECT().Get(ctx, mock.Anything).Return("fake-token", nil) + + tCtx := &coreMocks.TaskExecutionContext{} + tCtx.EXPECT().InputReader().Return(inputReader) + tCtx.EXPECT().TaskRefreshIndicator().Return(func(ctx context.Context) {}) + tCtx.EXPECT().OutputWriter().Return(outputWriter) + tCtx.EXPECT().DataStore().Return(ds) + tCtx.EXPECT().TaskReader().Return(tr) + tCtx.EXPECT().PluginStateWriter().Return(pluginStateWriter) + tCtx.EXPECT().PluginStateReader().Return(pluginStateReader) + tCtx.EXPECT().TaskExecutionMetadata().Return(tMeta) + tCtx.EXPECT().Catalog().Return(cat) + tCtx.EXPECT().ResourceManager().Return(resourceManager) + tCtx.EXPECT().SecretManager().Return(secretManager) + + trns := pluginCore.DoTransition(pluginCore.PhaseInfoQueued(time.Now(), 0, "")) + for !trns.Info().Phase().IsTerminal() { + trns, err = executor.Handle(ctx, tCtx) + assert.NoError(t, err) + if iterationUpdate != nil { + assert.NoError(t, iterationUpdate(ctx, tCtx)) + } + } + + assert.NoError(t, err) + if expectedOutputs != nil { + assert.True(t, trns.Info().Phase().IsSuccess()) + actualOutputs := &idlCore.LiteralMap{} + assert.NoError(t, ds.ReadProtobuf(context.TODO(), outputWriter.GetOutputPath(), actualOutputs)) + + if diff := deep.Equal(expectedOutputs, actualOutputs); diff != nil { + t.Errorf("Expected != Actual. Diff: %v", diff) + } + } else if expectedFailure != nil { + assert.True(t, trns.Info().Phase().IsFailure()) + actualError := &idlCore.ExecutionError{} + assert.NoError(t, ds.ReadProtobuf(context.TODO(), outputWriter.GetErrorPath(), actualError)) + + if diff := deep.Equal(expectedFailure, actualError); diff != nil { + t.Errorf("Expected != Actual. Diff: %v", diff) + } + } + + return trns.Info() +} diff --git a/flytestdlib/.gitignore b/flytestdlib/.gitignore new file mode 100644 index 0000000000..117e214036 --- /dev/null +++ b/flytestdlib/.gitignore @@ -0,0 +1,119 @@ + +# Temporary Build Files +tmp/_output +tmp/_test + + +# Created by https://www.gitignore.io/api/go,vim,emacs,visualstudiocode + +### Emacs ### +# -*- mode: gitignore; -*- +*~ +\#*\# +/.emacs.desktop +/.emacs.desktop.lock +*.elc +auto-save-list +tramp +.\#* + +# Org-mode +.org-id-locations +*_archive + +# flymake-mode +*_flymake.* + +# eshell files +/eshell/history +/eshell/lastdir + +# elpa packages +/elpa/ + +# reftex files +*.rel + +# AUCTeX auto folder +/auto/ + +# cask packages +.cask/ +dist/ + +# Flycheck +flycheck_*.el + +# server auth directory +/server/ + +# projectiles files +.projectile +projectile-bookmarks.eld + +# directory configuration +.dir-locals.el + +# saveplace +places + +# url cache +url/cache/ + +# cedet +ede-projects.el + +# smex +smex-items + +# company-statistics +company-statistics-cache.el + +# anaconda-mode +anaconda-mode/ + +### Go ### +# Binaries for programs and plugins +*.exe +*.exe~ +*.dll +*.so +*.dylib +vendor/ +bin/ + +# Test binary, build with 'go test -c' +*.test + +# Output of the go coverage tool, specifically when used with LiteIDE +*.out + +### Vim ### +# swap +.sw[a-p] +.*.sw[a-p] +# session +Session.vim +# temporary +.netrwhist +# auto-generated tag files +tags + +### VisualStudioCode ### +.vscode/* +!.vscode/settings.json +!.vscode/tasks.json +!.vscode/launch.json +!.vscode/extensions.json +.history + +### GoLand ### +.idea/* + +### CodeCov ### +codecov_bash.sh +coverage.txt + +# End of https://www.gitignore.io/api/go,vim,emacs,visualstudiocode + +.vscode/* diff --git a/flytestdlib/.golangci.yml b/flytestdlib/.golangci.yml new file mode 100644 index 0000000000..4ae605454b --- /dev/null +++ b/flytestdlib/.golangci.yml @@ -0,0 +1,31 @@ +run: + skip-dirs: + - pkg/client +linters: + disable-all: true + enable: + - errcheck + - gosec + - gci + - goconst + - goimports + - gosimple + - govet + - ineffassign + - misspell + - nakedret + - staticcheck + - typecheck + - unconvert + - unused + - protogetter +linters-settings: + gci: + custom-order: true + sections: + - standard + - default + - prefix(github.com/flyteorg) + skip-generated: true + goconst: + ignore-tests: true diff --git a/flytestdlib/.goreleaser.yml b/flytestdlib/.goreleaser.yml new file mode 100644 index 0000000000..ee92bdce36 --- /dev/null +++ b/flytestdlib/.goreleaser.yml @@ -0,0 +1,69 @@ +before: + hooks: + - go mod download +builds: + - env: + - CGO_ENABLED=0 + main: ./cli/pflags/main.go + binary: pflags + goos: + - linux + - windows + - darwin + ldflags: + - -s -w -X github.com/flyteorg/flytestdlib/version.Version={{.Version}} -X github.com/flyteorg/flytestdlib/version.Build={{.ShortCommit}} -X github.com/flyteorg/flytestdlib/version.BuildTime={{.Date}} +archives: + - name_template: |- + flytestdlib_{{ .Tag }}_ + {{- if eq .Os "darwin" }}Darwin + {{- else if eq .Os "linux" }}Linux + {{- else if eq .Os "windows" }}Windows + {{- else }}{{ .Os }}{{ end }}_ + {{- if eq .Arch "amd64" }}x86_64 + {{- else if eq .Arch "386" }}i386 + {{- else }}{{ .Arch }}{{ end }} + {{- if .Arm }}v{{ .Arm }}{{ end }} + format_overrides: + - goos: windows + format: zip +checksum: + name_template: "checksums.txt" +snapshot: + name_template: "{{ .Tag }}-next" +changelog: + sort: asc + filters: + exclude: + - "^docs:" + - "^test:" +# scoop: +# # Default is "https://github.com///releases/download/{{ .Tag }}/{{ .ArtifactName }}" +# # url_template: "http://github.mycompany.com/foo/bar/releases/{{ .Tag }}/{{ .ArtifactName }}" + +# # Repository to push the app manifest to. +# bucket: +# owner: lyft +# name: flytestdlib + +# # Git author used to commit to the repository. +# # Defaults are shown. +# commit_author: +# name: goreleaserbot +# email: goreleaser@carlosbecker.com + +# # Your app's homepage. +# # Default is empty. +# homepage: "https://godoc.org/github.com/flyteorg/flytestdlib" + +# # Your app's description. +# # Default is empty. +# description: "Common Go utilities (Typed-Config, PFlags, Prometheus Metrics,... more)." + +# # Your app's license +# # Default is empty. +# license: Apache-2.0 + +# # Persist data between application updates +# persist: +# - "data" +# - "config.toml" diff --git a/flytestdlib/CODEOWNERS b/flytestdlib/CODEOWNERS new file mode 100644 index 0000000000..c05664d497 --- /dev/null +++ b/flytestdlib/CODEOWNERS @@ -0,0 +1,3 @@ +# These owners will be the default owners for everything in +# the repo. Unless a later match takes precedence. +* @EngHabu @katrogan @kumare3 @wild-endeavor diff --git a/flytestdlib/CODE_OF_CONDUCT.md b/flytestdlib/CODE_OF_CONDUCT.md new file mode 100644 index 0000000000..e12139d691 --- /dev/null +++ b/flytestdlib/CODE_OF_CONDUCT.md @@ -0,0 +1,2 @@ +This project is governed by LF AI Foundation's [code of conduct](https://lfprojects.org/policies/code-of-conduct/). +All contributors and participants agree to abide by its terms. diff --git a/flytestdlib/LICENSE b/flytestdlib/LICENSE new file mode 100644 index 0000000000..bed437514f --- /dev/null +++ b/flytestdlib/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2019 Lyft, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/flytestdlib/Makefile b/flytestdlib/Makefile new file mode 100644 index 0000000000..2e862291c7 --- /dev/null +++ b/flytestdlib/Makefile @@ -0,0 +1,31 @@ +export REPOSITORY=flytestdlib +export REPO_ROOT=.. +include ../boilerplate/flyte/golang_test_targets/Makefile + +.PHONY: update_boilerplate +update_boilerplate: + @curl https://raw.githubusercontent.com/flyteorg/boilerplate/master/boilerplate/update.sh -o boilerplate/update.sh + @boilerplate/update.sh + +# Generate golden files. Add test packages that generate golden files here. +golden: + go test ./cli/pflags/api -update + go test ./config -update + go test ./storage -update + go test ./tests -update + + +generate: + @echo "************************ go generate **********************************" + go generate ./... + +# This is the only target that should be overridden by the project. Get your binary into ${GOREPO}/bin +.PHONY: compile +compile: + mkdir -p ./bin + go build -o pflags ./cli/pflags/main.go && mv ./pflags ./bin + + +.PHONY: test_unit_codecov +test_unit_codecov: + go test ./... -race -coverprofile=coverage.txt -covermode=atomic diff --git a/flytestdlib/NOTICE b/flytestdlib/NOTICE new file mode 100644 index 0000000000..9316928ad6 --- /dev/null +++ b/flytestdlib/NOTICE @@ -0,0 +1,21 @@ +flytestdlib +Copyright 2019-2020 Lyft Inc. + +This product includes software developed at Lyft Inc. + +Notices for file(s): + promutils/workqueue.go contains work from https://github.com/kubernetes/kubernetes/ + under the Apache2 license. + +/* +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. +*/ diff --git a/flytestdlib/README.md b/flytestdlib/README.md new file mode 100644 index 0000000000..c3629f1d8c --- /dev/null +++ b/flytestdlib/README.md @@ -0,0 +1,110 @@ +Common Go Tools +===================== +[![Current Release](https://img.shields.io/github/release/flyteorg/flytestdlib.svg)](https://github.com/flyteorg/flytestdlib/releases/latest) +[![Build Status](https://github.com/flyteorg/flytestdlib/workflows/Master/badge.svg?branch=master)](https://github.com/flyteorg/flytestdlib/workflows/Master/badge.svg?branch=master) +[![GoDoc](https://godoc.org/github.com/flyteorg/flytestdlib?status.svg)](https://godoc.org/github.com/flyteorg/flytestdlib) +[![License](https://img.shields.io/badge/LICENSE-Apache2.0-ff69b4.svg)](http://www.apache.org/licenses/LICENSE-2.0.html) +[![CodeCoverage](https://img.shields.io/codecov/c/github/flyteorg/flytestdlib.svg)](https://codecov.io/gh/flyteorg/flytestdlib) +[![Go Report Card](https://goreportcard.com/badge/github.com/flyteorg/flytestdlib)](https://goreportcard.com/report/github.com/flyteorg/flytestdlib) +![Commit activity](https://img.shields.io/github/commit-activity/w/flyteorg/flytestdlib.svg?style=plastic) +![Commit since last releast](https://img.shields.io/github/commits-since/flyteorg/flytestdlib/latest.svg?style=plastic) +[![Slack](https://img.shields.io/badge/slack-join_chat-white.svg?logo=slack&style=social)](https://slack.flyte.org) + +Shared components we found ourselves building time and time again, so we collected them in one place! + +This library consists of: + +- config + + Enables strongly typed config throughout your application. Offers a way to represent config in go structs. takes care + of parsing, validating and watching for changes on config. + +- cli/pflags + + Tool to generate a pflags for all fields in a given struct. + + #### Install + + On POSIX systems, + run: `curl -sfL https://raw.githubusercontent.com/flyteorg/flytestdlib/godownloader/godownloader.sh | sh` + + On Windows: + + Install scoop: `iex (new-object net.webclient).downloadstring('https://get.scoop.sh')` + + Run: `scoop bucket add flytestdlib https://github.com/flyteorg/flytestdlib.git` + + Run: `scoop install pflags` + +- storage + + Abstract storage library that uses stow behind the scenes to connect to s3/azure/gcs but also offers configurable + factory, in-memory storage (for testing) as well as native protobuf support. + +- contextutils + + Wrapper around golang's context to set/get known keys. + +- logger + + Wrapper around logrus that's configurable, taggable and context-aware. + +- profutils + + Starts an http server that serves /metrics (exposes prometheus metrics), /healthcheck and /version endpoints. + +- promutils + + Exposes a Scope instance that's a more convenient way to construct prometheus metrics and scope them per component. + +- atomic + + Wrapper around sync.atomic library to offer AtomicInt32 and other convenient types. + +- sets + + Offers strongly types and convenient interface sets. + +- utils +- version + +Contributing +------------ + +## Versioning + +This repo follows [semantic versioning](https://semver.org/). + +## Releases + +This repository is hooked up with [goreleaser](https://goreleaser.com/). Maintainers are expected to create tags and let +goreleaser compose the release message and create a release. + +To create a new release, follow these steps: + +- Create a PR with your changes. + +- [Optional] Create an alpha tag on your branch and push that. + + - First get existing tags `git describe --abbrev=0 --tags` + + - Figure out the next alpha version (e.g. if tag is v1.2.3 then you should create a v1.2.4-alpha.0 tag) + + - Create a tag `git tag v1.2.4-alpha.0` + + - Push tag `git push --tags` + +- Merge your changes and checkout master branch `git checkout master && git pull` + +- Bump version tag and push to branch. + + - First get existing tags `git describe --abbrev=0 --tags` + + - Figure out the next release version (e.g. if tag is v1.2.3 then you should create a v1.2.4 tag or v1.3.0 or a + v2.0.0 depending on what has changed. Refer to [Semantic Versioning](https://semver.org/) for information about + when to bump each) + + - Create a tag `git tag v1.2.4` + + - Push tag `git push --tags` + diff --git a/flytestdlib/atomic/atomic.go b/flytestdlib/atomic/atomic.go new file mode 100644 index 0000000000..26d04ab721 --- /dev/null +++ b/flytestdlib/atomic/atomic.go @@ -0,0 +1,129 @@ +package atomic + +import "sync/atomic" + +// This file contains some simplified atomics primitives that Golang default library does not offer +// like, Boolean + +// Takes in a uint32 and converts to bool by checking whether the last bit is set to 1 +func toBool(n uint32) bool { + return n&1 == 1 +} + +// Takes in a bool and returns a uint32 representation +func toInt(b bool) uint32 { + if b { + return 1 + } + return 0 +} + +// Bool is an atomic Boolean. +// It stores the bool as a uint32 internally. This is to use the uint32 atomic functions available in golang +type Bool struct{ v uint32 } + +// NewBool creates a Bool. +func NewBool(initial bool) Bool { + return Bool{v: toInt(initial)} +} + +// Load atomically loads the Boolean. +func (b *Bool) Load() bool { + return toBool(atomic.LoadUint32(&b.v)) +} + +// CAS is an atomic compare-and-swap. +func (b *Bool) CompareAndSwap(old, new bool) bool { + return atomic.CompareAndSwapUint32(&b.v, toInt(old), toInt(new)) +} + +// Store atomically stores the passed value. +func (b *Bool) Store(new bool) { + atomic.StoreUint32(&b.v, toInt(new)) +} + +// Swap sets the given value and returns the previous value. +func (b *Bool) Swap(new bool) bool { + return toBool(atomic.SwapUint32(&b.v, toInt(new))) +} + +// Toggle atomically negates the Boolean and returns the previous value. +func (b *Bool) Toggle() bool { + return toBool(atomic.AddUint32(&b.v, 1) - 1) +} + +type Uint32 struct { + v uint32 +} + +// Returns a loaded uint32 value +func (u *Uint32) Load() uint32 { + return atomic.LoadUint32(&u.v) +} + +// CAS is an atomic compare-and-swap. +func (u *Uint32) CompareAndSwap(old, new uint32) bool { + return atomic.CompareAndSwapUint32(&u.v, old, new) +} + +// Add a delta to the number +func (u *Uint32) Add(delta uint32) uint32 { + return atomic.AddUint32(&u.v, delta) +} + +// Increment the value +func (u *Uint32) Inc() uint32 { + return atomic.AddUint32(&u.v, 1) +} + +// Set the value +func (u *Uint32) Store(v uint32) { + atomic.StoreUint32(&u.v, v) +} + +func NewUint32(v uint32) Uint32 { + return Uint32{v: v} +} + +type Int32 struct { + v int32 +} + +// Returns a loaded uint32 value +func (i *Int32) Load() int32 { + return atomic.LoadInt32(&i.v) +} + +// CAS is an atomic compare-and-swap. +func (i *Int32) CompareAndSwap(old, new int32) bool { + return atomic.CompareAndSwapInt32(&i.v, old, new) +} + +// Add a delta to the number +func (i *Int32) Add(delta int32) int32 { + return atomic.AddInt32(&i.v, delta) +} + +// Subtract a delta from the number +func (i *Int32) Sub(delta int32) int32 { + return atomic.AddInt32(&i.v, -delta) +} + +// Increment the value +func (i *Int32) Inc() int32 { + return atomic.AddInt32(&i.v, 1) +} + +// Decrement the value +func (i *Int32) Dec() int32 { + return atomic.AddInt32(&i.v, -1) +} + +// Set the value +func (i *Int32) Store(v int32) { + atomic.StoreInt32(&i.v, v) +} + +func NewInt32(v int32) Int32 { + return Int32{v: v} +} diff --git a/flytestdlib/atomic/atomic_test.go b/flytestdlib/atomic/atomic_test.go new file mode 100644 index 0000000000..c441a88993 --- /dev/null +++ b/flytestdlib/atomic/atomic_test.go @@ -0,0 +1,61 @@ +package atomic + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestBool(t *testing.T) { + atom := NewBool(false) + assert.False(t, atom.Toggle(), "Expected swap to return False.") + assert.True(t, atom.Load(), "Unexpected state after swap. Expected True") + + assert.True(t, atom.CompareAndSwap(true, true), "CAS should swap when old matches") + assert.True(t, atom.Load(), "previous swap should have no effect") + assert.True(t, atom.CompareAndSwap(true, false), "CAS should swap when old matches") + assert.False(t, atom.Load(), "Post swap the value should be true") + assert.False(t, atom.CompareAndSwap(true, false), "CAS should fail on old mismatch") + assert.False(t, atom.Load(), "CAS should not have modified the value") + + atom.Store(false) + assert.False(t, atom.Load(), "Unexpected state after store.") + + prev := atom.Swap(false) + assert.False(t, prev, "Expected Swap to return previous value.") + + prev = atom.Swap(true) + assert.False(t, prev, "Expected Swap to return previous value.") +} + +func TestInt32(t *testing.T) { + atom := NewInt32(2) + assert.False(t, atom.CompareAndSwap(3, 4), "Expected swap to return False.") + assert.Equal(t, int32(2), atom.Load(), "Unexpected state after swap. Expected True") + + assert.True(t, atom.CompareAndSwap(2, 2), "CAS should swap when old matches") + assert.Equal(t, int32(2), atom.Load(), "previous swap should have no effect") + assert.True(t, atom.CompareAndSwap(2, 4), "CAS should swap when old matches") + assert.Equal(t, int32(4), atom.Load(), "Post swap the value should be true") + assert.False(t, atom.CompareAndSwap(2, 3), "CAS should fail on old mismatch") + assert.Equal(t, int32(4), atom.Load(), "CAS should not have modified the value") + + atom.Store(5) + assert.Equal(t, int32(5), atom.Load(), "Unexpected state after store.") +} + +func TestUint32(t *testing.T) { + atom := NewUint32(2) + assert.False(t, atom.CompareAndSwap(3, 4), "Expected swap to return False.") + assert.Equal(t, uint32(2), atom.Load(), "Unexpected state after swap. Expected True") + + assert.True(t, atom.CompareAndSwap(2, 2), "CAS should swap when old matches") + assert.Equal(t, uint32(2), atom.Load(), "previous swap should have no effect") + assert.True(t, atom.CompareAndSwap(2, 4), "CAS should swap when old matches") + assert.Equal(t, uint32(4), atom.Load(), "Post swap the value should be true") + assert.False(t, atom.CompareAndSwap(2, 3), "CAS should fail on old mismatch") + assert.Equal(t, uint32(4), atom.Load(), "CAS should not have modified the value") + + atom.Store(5) + assert.Equal(t, uint32(5), atom.Load(), "Unexpected state after store.") +} diff --git a/flytestdlib/atomic/non_blocking_lock.go b/flytestdlib/atomic/non_blocking_lock.go new file mode 100644 index 0000000000..449841a960 --- /dev/null +++ b/flytestdlib/atomic/non_blocking_lock.go @@ -0,0 +1,23 @@ +package atomic + +// Lock that provides TryLock method instead of blocking lock +type NonBlockingLock interface { + TryLock() bool + Release() +} + +func NewNonBlockingLock() NonBlockingLock { + return &nonBlockingLock{lock: NewBool(false)} +} + +type nonBlockingLock struct { + lock Bool +} + +func (n *nonBlockingLock) TryLock() bool { + return n.lock.CompareAndSwap(false, true) +} + +func (n *nonBlockingLock) Release() { + n.lock.Store(false) +} diff --git a/flytestdlib/atomic/non_blocking_lock_test.go b/flytestdlib/atomic/non_blocking_lock_test.go new file mode 100644 index 0000000000..ddd0a2123d --- /dev/null +++ b/flytestdlib/atomic/non_blocking_lock_test.go @@ -0,0 +1,15 @@ +package atomic + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestNewNonBlockingLock(t *testing.T) { + lock := NewNonBlockingLock() + assert.True(t, lock.TryLock(), "Unexpected lock acquire failure") + assert.False(t, lock.TryLock(), "already-acquired lock acquired again") + lock.Release() + assert.True(t, lock.TryLock(), "Unexpected lock acquire failure") +} diff --git a/flytestdlib/autorefreshcache/auto_refresh.go b/flytestdlib/autorefreshcache/auto_refresh.go new file mode 100644 index 0000000000..9466a21f07 --- /dev/null +++ b/flytestdlib/autorefreshcache/auto_refresh.go @@ -0,0 +1,443 @@ +package autorefreshcache + +import ( + "context" + "fmt" + "runtime/debug" + "sync" + "time" + + lru "github.com/hashicorp/golang-lru" + "github.com/prometheus/client_golang/prometheus" + "k8s.io/client-go/util/workqueue" + "k8s.io/utils/clock" + + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +type ItemID = string +type Batch = []ItemWrapper + +const ( + ErrNotFound errors.ErrorCode = "NOT_FOUND" +) + +//go:generate mockery -all + +// AutoRefresh with regular GetOrCreate and Delete along with background asynchronous refresh. Caller provides +// callbacks for create, refresh and delete item. +// The cache doesn't provide apis to update items. +type AutoRefresh interface { + // Starts background refresh of items. To shutdown the cache, cancel the context. + Start(ctx context.Context) error + + // Get item by id. + Get(id ItemID) (Item, error) + + // Get object if exists else create it. + GetOrCreate(id ItemID, item Item) (Item, error) + + // DeleteDelayed queues an item for deletion. It Will get deleted as part of the next Sync cycle. Until the next sync + // cycle runs, Get and GetOrCreate will continue to return the Item in its previous state. + DeleteDelayed(id ItemID) error +} + +type AutoRefreshWithUpdate interface { + AutoRefresh + Update(id ItemID, item Item) (ok bool) +} + +type metrics struct { + SyncErrors prometheus.Counter + Evictions prometheus.Counter + SyncLatency promutils.StopWatch + CacheHit prometheus.Counter + CacheMiss prometheus.Counter + Size prometheus.Gauge + scope promutils.Scope +} + +type Item interface { + IsTerminal() bool +} + +// Items are wrapped inside an ItemWrapper to be stored in the cache. +type ItemWrapper interface { + GetID() ItemID + GetItem() Item +} + +// Represents the response for the sync func +type ItemSyncResponse struct { + ID ItemID + Item Item + Action SyncAction +} + +// Possible actions for the cache to take as a result of running the sync function on any given cache item +type SyncAction int + +const ( + Unchanged SyncAction = iota + + // The item returned has been updated and should be updated in the cache + Update +) + +// SyncFunc func type. Your implementation of this function for your cache instance is responsible for returning +// The new Item and what action should be taken. The sync function has no insight into your object, and needs to be +// told explicitly if the new item is different from the old one. +type SyncFunc func(ctx context.Context, batch Batch) ( + updatedBatch []ItemSyncResponse, err error) + +// CreateBatchesFunc is a func type. Your implementation of this function for your cache instance is responsible for +// subdividing the list of cache items into batches. +type CreateBatchesFunc func(ctx context.Context, snapshot []ItemWrapper) (batches []Batch, err error) + +type itemWrapper struct { + id ItemID + item Item +} + +func (i itemWrapper) GetID() ItemID { + return i.id +} + +func (i itemWrapper) GetItem() Item { + return i.item +} + +// Thread-safe general purpose auto-refresh cache that watches for updates asynchronously for the keys after they are added to +// the cache. An item can be inserted only once. +// +// Get reads from sync.map while refresh is invoked on a snapshot of keys. Cache eventually catches up on deleted items. +// +// Sync is run as a fixed-interval-scheduled-task, and is skipped if sync from previous cycle is still running. +type autoRefresh struct { + name string + metrics metrics + syncCb SyncFunc + createBatchesCb CreateBatchesFunc + lruMap *lru.Cache + // Items that are currently being processed are in the processing set. + // It will prevent the same item from being processed multiple times by different workers. + processing *sync.Map + toDelete *syncSet + syncPeriod time.Duration + workqueue workqueue.RateLimitingInterface + parallelizm int + lock sync.RWMutex + clock clock.Clock +} + +func getEvictionFunction(counter prometheus.Counter) func(key interface{}, value interface{}) { + return func(_ interface{}, _ interface{}) { + counter.Inc() + } +} + +func SingleItemBatches(_ context.Context, snapshot []ItemWrapper) (batches []Batch, err error) { + res := make([]Batch, 0, len(snapshot)) + for _, item := range snapshot { + res = append(res, Batch{item}) + } + + return res, nil +} + +func newMetrics(scope promutils.Scope) metrics { + return metrics{ + SyncErrors: scope.MustNewCounter("sync_errors", "Counter for sync errors."), + Evictions: scope.MustNewCounter("lru_evictions", "Counter for evictions from LRU."), + SyncLatency: scope.MustNewStopWatch("latency", "Latency for sync operations.", time.Millisecond), + CacheHit: scope.MustNewCounter("cache_hit", "Counter for cache hits."), + CacheMiss: scope.MustNewCounter("cache_miss", "Counter for cache misses."), + Size: scope.MustNewGauge("size", "Current size of the cache"), + scope: scope, + } +} + +func (w *autoRefresh) Start(ctx context.Context) error { + for i := 0; i < w.parallelizm; i++ { + go func(ctx context.Context) { + err := w.sync(ctx) + if err != nil { + logger.Errorf(ctx, "Failed to sync. Error: %v", err) + } + }(contextutils.WithGoroutineLabel(ctx, fmt.Sprintf("%v-worker-%v", w.name, i))) + } + + enqueueCtx := contextutils.WithGoroutineLabel(ctx, fmt.Sprintf("%v-enqueue", w.name)) + go w.enqueueLoop(enqueueCtx) + + return nil +} + +func (w *autoRefresh) enqueueLoop(ctx context.Context) { + timer := w.clock.NewTimer(w.syncPeriod) + defer timer.Stop() + + for { + select { + case <-ctx.Done(): + return + case <-timer.C(): + err := w.enqueueBatches(ctx) + if err != nil { + logger.Errorf(ctx, "Failed to enqueue. Error: %v", err) + } + timer.Reset(w.syncPeriod) + } + } +} + +// Update updates the item only if it exists in the cache and is not terminal, +// return true if we updated the item. +func (w *autoRefresh) Update(id ItemID, item Item) (ok bool) { + w.lock.Lock() + defer w.lock.Unlock() + val, ok := w.lruMap.Get(id) + if !ok || val.(Item).IsTerminal() { + return false + } + + w.lruMap.Add(id, item) + return true +} + +// Delete deletes the item from the cache if it exists. +func (w *autoRefresh) Delete(key interface{}) { + w.lock.Lock() + defer w.lock.Unlock() + w.toDelete.Remove(key) + w.lruMap.Remove(key) +} + +func (w *autoRefresh) Get(id ItemID) (Item, error) { + if val, ok := w.lruMap.Get(id); ok { + w.metrics.CacheHit.Inc() + return val.(Item), nil + } + + w.metrics.CacheMiss.Inc() + return nil, errors.Errorf(ErrNotFound, "Item with id [%v] not found.", id) +} + +// Return the item if exists else create it. +// Create should be invoked only once. recreating the object is not supported. +func (w *autoRefresh) GetOrCreate(id ItemID, item Item) (Item, error) { + if val, ok := w.lruMap.Get(id); ok { + w.metrics.CacheHit.Inc() + return val.(Item), nil + } + + w.lruMap.Add(id, item) + w.metrics.CacheMiss.Inc() + + // It fixes cold start issue in the AutoRefreshCache by adding the item to the workqueue when it is created. + // This way, the item will be processed without waiting for the next sync cycle (30s by default). + batch := make([]ItemWrapper, 0, 1) + batch = append(batch, itemWrapper{id: id, item: item}) + w.workqueue.AddRateLimited(&batch) + w.processing.Store(id, w.clock.Now()) + return item, nil +} + +// DeleteDelayed queues an item for deletion. It Will get deleted as part of the next Sync cycle. Until the next sync +// cycle runs, Get and GetOrCreate will continue to return the Item in its previous state. +func (w *autoRefresh) DeleteDelayed(id ItemID) error { + w.toDelete.Insert(id) + return nil +} + +// This function is called internally by its own timer. Roughly, it will list keys, create batches of keys based on +// createBatchesCb and, enqueue all the batches into the workqueue. +func (w *autoRefresh) enqueueBatches(ctx context.Context) error { + keys := w.lruMap.Keys() + w.metrics.Size.Set(float64(len(keys))) + + snapshot := make([]ItemWrapper, 0, len(keys)) + for _, k := range keys { + if w.toDelete.Contains(k) { + w.Delete(k) + continue + } + // If not ok, it means evicted between the item was evicted between getting the keys and this update loop + // which is fine, we can just ignore. + if value, ok := w.lruMap.Peek(k); ok { + if item, ok := value.(Item); !ok || (ok && !item.IsTerminal() && !w.inProcessing(k)) { + snapshot = append(snapshot, itemWrapper{ + id: k.(ItemID), + item: value.(Item), + }) + } + } + } + + batches, err := w.createBatchesCb(ctx, snapshot) + if err != nil { + return err + } + + for _, batch := range batches { + b := batch + w.workqueue.AddRateLimited(&b) + for i := 1; i < len(b); i++ { + w.processing.Store(b[i].GetID(), w.clock.Now()) + } + } + + return nil +} + +// There are w.parallelizm instances of this function running all the time, each one will: +// - Retrieve an item from the workqueue +// - For each batch of the keys, call syncCb, which tells us if the items have been updated +// -- If any has, then overwrite the item in the cache. +// +// What happens when the number of things that a user is trying to keep track of exceeds the size +// of the cache? Trivial case where the cache is size 1 and we're trying to keep track of two things. +// * Plugin asks for update on item 1 - cache evicts item 2, stores 1 and returns it unchanged +// * Plugin asks for update on item 2 - cache evicts item 1, stores 2 and returns it unchanged +// * Sync loop updates item 2, repeat +func (w *autoRefresh) sync(ctx context.Context) (err error) { + defer func() { + var isErr bool + rVal := recover() + if rVal == nil { + return + } + + if err, isErr = rVal.(error); isErr { + err = fmt.Errorf("worker panic'd and is shutting down. Error: %w with Stack: %v", err, string(debug.Stack())) + } else { + err = fmt.Errorf("worker panic'd and is shutting down. Panic value: %v with Stack: %v", rVal, string(debug.Stack())) + } + + logger.Error(ctx, err) + }() + + for { + select { + case <-ctx.Done(): + return nil + default: + batch, shutdown := w.workqueue.Get() + if shutdown { + logger.Debugf(ctx, "Shutting down worker") + return nil + } + // Since we create batches every time we sync, we will just remove the item from the queue here + // regardless of whether it succeeded the sync or not. + w.workqueue.Forget(batch) + w.workqueue.Done(batch) + + newBatch := make(Batch, 0, len(*batch.(*Batch))) + for _, b := range *batch.(*Batch) { + itemID := b.GetID() + w.processing.Delete(itemID) + item, ok := w.lruMap.Get(itemID) + if !ok { + logger.Debugf(ctx, "item with id [%v] not found in cache", itemID) + continue + } + if item.(Item).IsTerminal() { + logger.Debugf(ctx, "item with id [%v] is terminal", itemID) + continue + } + newBatch = append(newBatch, b) + } + if len(newBatch) == 0 { + continue + } + + t := w.metrics.SyncLatency.Start() + updatedBatch, err := w.syncCb(ctx, newBatch) + + if err != nil { + w.metrics.SyncErrors.Inc() + logger.Errorf(ctx, "failed to get latest copy of a batch. Error: %v", err) + t.Stop() + continue + } + + for _, item := range updatedBatch { + if item.Action == Update { + // Updates an existing item. + w.Update(item.ID, item.Item) + } + } + + w.toDelete.Range(func(key interface{}) bool { + w.Delete(key) + return true + }) + + t.Stop() + } + } +} + +// Checks if the item is currently being processed and returns false if the item has been in processing for too long +func (w *autoRefresh) inProcessing(key interface{}) bool { + item, found := w.processing.Load(key) + if found { + // handle potential race conditions where the item is in processing but not in the workqueue + if timeItem, ok := item.(time.Time); ok && w.clock.Since(timeItem) > (w.syncPeriod*5) { + w.processing.Delete(key) + return false + } + return true + } + return false +} + +// Instantiates a new AutoRefresh Cache that syncs items in batches. +func NewAutoRefreshBatchedCache(name string, createBatches CreateBatchesFunc, syncCb SyncFunc, syncRateLimiter workqueue.RateLimiter, + resyncPeriod time.Duration, parallelizm, size int, scope promutils.Scope) (AutoRefresh, error) { + return newAutoRefreshBatchedCacheWithClock(name, createBatches, syncCb, syncRateLimiter, resyncPeriod, parallelizm, size, scope, clock.RealClock{}) +} + +func newAutoRefreshBatchedCacheWithClock(name string, createBatches CreateBatchesFunc, syncCb SyncFunc, syncRateLimiter workqueue.RateLimiter, + resyncPeriod time.Duration, parallelizm, size int, scope promutils.Scope, clock clock.WithTicker) (AutoRefresh, error) { + + metrics := newMetrics(scope) + lruCache, err := lru.NewWithEvict(size, getEvictionFunction(metrics.Evictions)) + if err != nil { + return nil, err + } + + cache := &autoRefresh{ + name: name, + metrics: metrics, + parallelizm: parallelizm, + createBatchesCb: createBatches, + syncCb: syncCb, + lruMap: lruCache, + processing: &sync.Map{}, + toDelete: newSyncSet(), + syncPeriod: resyncPeriod, + workqueue: workqueue.NewRateLimitingQueueWithConfig(syncRateLimiter, workqueue.RateLimitingQueueConfig{ + Name: scope.CurrentScope(), + Clock: clock, + }), + clock: clock, + } + + return cache, nil +} + +// Instantiates a new AutoRefresh Cache that syncs items periodically. +func NewAutoRefreshCache(name string, syncCb SyncFunc, syncRateLimiter workqueue.RateLimiter, resyncPeriod time.Duration, + parallelizm, size int, scope promutils.Scope) (AutoRefresh, error) { + + return NewAutoRefreshBatchedCache(name, SingleItemBatches, syncCb, syncRateLimiter, resyncPeriod, parallelizm, size, scope) +} + +func newAutoRefreshCacheWithClock(name string, syncCb SyncFunc, syncRateLimiter workqueue.RateLimiter, resyncPeriod time.Duration, + parallelizm, size int, scope promutils.Scope, clock clock.WithTicker) (AutoRefresh, error) { + return newAutoRefreshBatchedCacheWithClock(name, SingleItemBatches, syncCb, syncRateLimiter, resyncPeriod, parallelizm, size, scope, clock) +} diff --git a/flytestdlib/autorefreshcache/auto_refresh_example_test.go b/flytestdlib/autorefreshcache/auto_refresh_example_test.go new file mode 100644 index 0000000000..cd8c0d94d7 --- /dev/null +++ b/flytestdlib/autorefreshcache/auto_refresh_example_test.go @@ -0,0 +1,129 @@ +package autorefreshcache + +import ( + "context" + "fmt" + "sync" + "time" + + "k8s.io/client-go/util/workqueue" + + "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +type ExampleItemStatus string + +const ( + ExampleStatusNotStarted ExampleItemStatus = "Not-started" + ExampleStatusStarted ExampleItemStatus = "Started" + ExampleStatusSucceeded ExampleItemStatus = "Completed" +) + +type ExampleCacheItem struct { + status ExampleItemStatus + id string +} + +func (e *ExampleCacheItem) IsTerminal() bool { + return e.status == ExampleStatusSucceeded +} + +func (e *ExampleCacheItem) ID() string { + return e.id +} + +type ExampleService struct { + jobStatus map[string]ExampleItemStatus + lock sync.RWMutex +} + +func newExampleService() *ExampleService { + return &ExampleService{ + jobStatus: make(map[string]ExampleItemStatus), + lock: sync.RWMutex{}, + } +} + +// advance the status to next, and return +func (f *ExampleService) getStatus(id string) *ExampleCacheItem { + f.lock.Lock() + defer f.lock.Unlock() + if _, ok := f.jobStatus[id]; !ok { + f.jobStatus[id] = ExampleStatusStarted + } + + f.jobStatus[id] = ExampleStatusSucceeded + return &ExampleCacheItem{f.jobStatus[id], id} +} + +func ExampleNewAutoRefreshCache() { + // This auto-refresh cache can be used for cases where keys are created by caller but processed by + // an external service and we want to asynchronously keep track of its progress. + exampleService := newExampleService() + + // define a sync method that the cache can use to auto-refresh in background + syncItemCb := func(ctx context.Context, batch []ItemWrapper) ([]ItemSyncResponse, error) { + updatedItems := make([]ItemSyncResponse, 0, len(batch)) + for _, obj := range batch { + oldItem := obj.GetItem().(*ExampleCacheItem) + newItem := exampleService.getStatus(oldItem.ID()) + if newItem.status != oldItem.status { + updatedItems = append(updatedItems, ItemSyncResponse{ + ID: oldItem.ID(), + Item: newItem, + Action: Update, + }) + } + } + + return updatedItems, nil + } + + // define resync period as time duration we want cache to refresh. We can go as low as we want but cache + // would still be constrained by time it takes to run Sync call for each item. + resyncPeriod := time.Millisecond + + // Since number of items in the cache is dynamic, rate limiter is our knob to control resources we spend on + // sync. + rateLimiter := workqueue.DefaultControllerRateLimiter() + + // since cache refreshes itself asynchronously, it may not notice that an object has been deleted immediately, + // so users of the cache should have the delete logic aware of this shortcoming (eg. not-exists may be a valid + // error during removal if based on status in cache). + cache, err := NewAutoRefreshCache("my-cache", syncItemCb, rateLimiter, resyncPeriod, 10, 100, promutils.NewTestScope()) + if err != nil { + panic(err) + } + + // start the cache with a context that would be to stop the cache by cancelling the context + ctx, cancel := context.WithCancel(context.Background()) + err = cache.Start(ctx) + if err != nil { + panic(err) + } + + // creating objects that go through a couple of state transitions to reach the final state. + item1 := &ExampleCacheItem{status: ExampleStatusNotStarted, id: "item1"} + item2 := &ExampleCacheItem{status: ExampleStatusNotStarted, id: "item2"} + _, err1 := cache.GetOrCreate(item1.id, item1) + _, err2 := cache.GetOrCreate(item2.id, item2) + if err1 != nil || err2 != nil { + fmt.Printf("unexpected error in create; err1: %v, err2: %v", err1, err2) + } + + // wait for the cache to go through a few refresh cycles and then check status + time.Sleep(resyncPeriod * 10) + item, err := cache.Get(item1.ID()) + if err != nil && errors.IsCausedBy(err, ErrNotFound) { + fmt.Printf("Item1 is no longer in the cache") + } else { + fmt.Printf("Current status for item1 is %v", item.(*ExampleCacheItem).status) + } + + // stop the cache + cancel() + + // Output: + // Current status for item1 is Completed +} diff --git a/flytestdlib/autorefreshcache/auto_refresh_test.go b/flytestdlib/autorefreshcache/auto_refresh_test.go new file mode 100644 index 0000000000..821aad4a74 --- /dev/null +++ b/flytestdlib/autorefreshcache/auto_refresh_test.go @@ -0,0 +1,283 @@ +package autorefreshcache + +import ( + "context" + "fmt" + "strconv" + "sync" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "k8s.io/client-go/util/workqueue" + testingclock "k8s.io/utils/clock/testing" + + "github.com/flyteorg/flyte/v2/flytestdlib/atomic" + "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +const fakeCacheItemValueLimit = 10 + +type fakeCacheItem struct { + val int + isTerminal bool +} + +func (f fakeCacheItem) IsTerminal() bool { + return f.isTerminal +} + +type terminalCacheItem struct { + val int +} + +func (t terminalCacheItem) IsTerminal() bool { + return true +} + +func syncFakeItem(_ context.Context, batch Batch) ([]ItemSyncResponse, error) { + items := make([]ItemSyncResponse, 0, len(batch)) + for _, obj := range batch { + item := obj.GetItem().(fakeCacheItem) + if item.val == fakeCacheItemValueLimit { + // After the item has gone through ten update cycles, leave it unchanged + continue + } + isTerminal := false + if item.val == fakeCacheItemValueLimit-1 { + isTerminal = true + } + items = append(items, ItemSyncResponse{ + ID: obj.GetID(), + Item: fakeCacheItem{ + val: item.val + 1, + isTerminal: isTerminal, + }, + Action: Update, + }) + } + + return items, nil +} + +func syncTerminalItem(_ context.Context, batch Batch) ([]ItemSyncResponse, error) { + panic("This should never be called") +} + +type panickingSyncer struct { + callCount atomic.Int32 +} + +func (p *panickingSyncer) sync(_ context.Context, _ Batch) ([]ItemSyncResponse, error) { + p.callCount.Inc() + panic("testing") +} + +func TestCacheFour(t *testing.T) { + testResyncPeriod := 5 * time.Second + rateLimiter := workqueue.DefaultControllerRateLimiter() + fakeClock := testingclock.NewFakeClock(time.Now()) + + t.Run("normal operation", func(t *testing.T) { + // the size of the cache is at least as large as the number of items we're storing + cache, err := newAutoRefreshCacheWithClock("fake1", syncFakeItem, rateLimiter, testResyncPeriod, 10, 10, promutils.NewTestScope(), fakeClock) + assert.NoError(t, err) + + ctx, cancel := context.WithCancel(context.Background()) + assert.NoError(t, cache.Start(ctx)) + + // Create ten items in the cache + for i := 1; i <= 10; i++ { + _, err := cache.GetOrCreate(fmt.Sprintf("%d", i), fakeCacheItem{ + val: 0, + }) + assert.NoError(t, err) + } + + assert.EventuallyWithT(t, func(c *assert.CollectT) { + // trigger periodic sync + fakeClock.Step(testResyncPeriod) + + for i := 1; i <= 10; i++ { + item, err := cache.Get(fmt.Sprintf("%d", i)) + assert.NoError(c, err) + assert.Equal(c, 10, item.(fakeCacheItem).val) + } + }, 3*time.Second, time.Millisecond) + cancel() + }) + + t.Run("Not Found", func(t *testing.T) { + // the size of the cache is at least as large as the number of items we're storing + cache, err := newAutoRefreshCacheWithClock("fake2", syncFakeItem, rateLimiter, testResyncPeriod, 10, 2, promutils.NewTestScope(), fakeClock) + assert.NoError(t, err) + + ctx, cancel := context.WithCancel(context.Background()) + assert.NoError(t, cache.Start(ctx)) + + // Create ten items in the cache + for i := 1; i <= 10; i++ { + _, err := cache.GetOrCreate(fmt.Sprintf("%d", i), fakeCacheItem{ + val: 0, + }) + assert.NoError(t, err) + } + + notFound := 0 + for i := 1; i <= 10; i++ { + _, err := cache.Get(fmt.Sprintf("%d", i)) + if err != nil && errors.IsCausedBy(err, ErrNotFound) { + notFound++ + } + } + + assert.Equal(t, 8, notFound) + + cancel() + }) + + t.Run("Enqueue nothing", func(t *testing.T) { + cache, err := newAutoRefreshCacheWithClock("fake3", syncTerminalItem, rateLimiter, testResyncPeriod, 10, 2, promutils.NewTestScope(), fakeClock) + assert.NoError(t, err) + + ctx, cancel := context.WithCancel(context.Background()) + assert.NoError(t, cache.Start(ctx)) + + // Create ten items in the cache + for i := 1; i <= 10; i++ { + _, err := cache.GetOrCreate(fmt.Sprintf("%d", i), terminalCacheItem{ + val: 0, + }) + assert.NoError(t, err) + } + + // Enqueue first batch + fakeClock.Step(testResyncPeriod) + // If the cache tries to enqueue the item, a panic will be thrown. + fakeClock.Step(testResyncPeriod) + + cancel() + }) + + t.Run("Test update and delete cache", func(t *testing.T) { + cache, err := newAutoRefreshCacheWithClock("fake3", syncTerminalItem, rateLimiter, testResyncPeriod, 10, 2, promutils.NewTestScope(), fakeClock) + assert.NoError(t, err) + + ctx, cancel := context.WithCancel(context.Background()) + assert.NoError(t, cache.Start(ctx)) + + itemID := "dummy_id" + _, err = cache.GetOrCreate(itemID, terminalCacheItem{ + val: 0, + }) + assert.NoError(t, err) + + // If the cache tries to enqueue the item, a panic will be thrown. + fakeClock.Step(testResyncPeriod) + + err = cache.DeleteDelayed(itemID) + assert.NoError(t, err) + + assert.EventuallyWithT(t, func(c *assert.CollectT) { + // trigger a sync + fakeClock.Step(testResyncPeriod) + + item, err := cache.Get(itemID) + assert.Nil(c, item) + assert.Error(c, err) + }, 3*time.Second, time.Millisecond) + + cancel() + }) + + t.Run("Test panic on sync and shutdown", func(t *testing.T) { + syncer := &panickingSyncer{} + cache, err := newAutoRefreshCacheWithClock("fake3", syncer.sync, rateLimiter, testResyncPeriod, 10, 2, promutils.NewTestScope(), fakeClock) + assert.NoError(t, err) + + ctx, cancel := context.WithCancel(context.Background()) + assert.NoError(t, cache.Start(ctx)) + + itemID := "dummy_id" + _, err = cache.GetOrCreate(itemID, fakeCacheItem{ + val: 0, + }) + assert.NoError(t, err) + + // wait for all workers to run + assert.Eventually(t, func() bool { + // trigger a sync + fakeClock.Step(testResyncPeriod) + + return syncer.callCount.Load() == int32(10) + }, 5*time.Second, time.Millisecond) + + cancel() + }) +} + +func TestQueueBuildUp(t *testing.T) { + testResyncPeriod := time.Hour + rateLimiter := workqueue.DefaultControllerRateLimiter() + fakeClock := testingclock.NewFakeClock(time.Now()) + + syncCount := atomic.NewInt32(0) + m := sync.Map{} + alwaysFailing := func(ctx context.Context, batch Batch) ( + updatedBatch []ItemSyncResponse, err error) { + assert.Len(t, batch, 1) + _, existing := m.LoadOrStore(batch[0].GetID(), 0) + assert.False(t, existing, "Saw %v before", batch[0].GetID()) + if existing { + t.FailNow() + } + + syncCount.Inc() + return nil, fmt.Errorf("expected error") + } + + size := 100 + cache, err := newAutoRefreshCacheWithClock("fake2", alwaysFailing, rateLimiter, testResyncPeriod, 10, size, promutils.NewTestScope(), fakeClock) + assert.NoError(t, err) + + ctx := context.Background() + ctx, cancelNow := context.WithCancel(ctx) + defer cancelNow() + + for i := 0; i < size; i++ { + _, err := cache.GetOrCreate(strconv.Itoa(i), fakeCacheItem{val: 3}) + assert.NoError(t, err) + } + + assert.NoError(t, cache.Start(ctx)) + + // wait for all workers to run + assert.Eventually(t, func() bool { + // trigger a sync and unlock the work queue + fakeClock.Step(time.Millisecond) + + return syncCount.Load() == int32(size) + }, 5*time.Second, time.Millisecond) +} + +func TestInProcessing(t *testing.T) { + + syncPeriod := time.Millisecond + fakeClock := testingclock.NewFakeClock(time.Now()) + cache := &autoRefresh{ + processing: &sync.Map{}, + syncPeriod: syncPeriod, + clock: fakeClock, + } + + assert.False(t, cache.inProcessing("test")) + + cache.processing.Store("test", time.Now()) + assert.True(t, cache.inProcessing("test")) + + cache.processing.Store("test1", time.Now().Add(syncPeriod*-11)) + assert.False(t, cache.inProcessing("test1")) + _, found := cache.processing.Load("test1") + assert.False(t, found) +} diff --git a/flytestdlib/autorefreshcache/mocks/AutoRefresh.go b/flytestdlib/autorefreshcache/mocks/AutoRefresh.go new file mode 100644 index 0000000000..ab6f5d8d20 --- /dev/null +++ b/flytestdlib/autorefreshcache/mocks/AutoRefresh.go @@ -0,0 +1,162 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + context "context" + + autorefreshcache "github.com/flyteorg/flyte/v2/flytestdlib/autorefreshcache" + + mock "github.com/stretchr/testify/mock" +) + +// AutoRefresh is an autogenerated mock type for the AutoRefresh type +type AutoRefresh struct { + mock.Mock +} + +type AutoRefresh_DeleteDelayed struct { + *mock.Call +} + +func (_m AutoRefresh_DeleteDelayed) Return(_a0 error) *AutoRefresh_DeleteDelayed { + return &AutoRefresh_DeleteDelayed{Call: _m.Call.Return(_a0)} +} + +func (_m *AutoRefresh) OnDeleteDelayed(id string) *AutoRefresh_DeleteDelayed { + c_call := _m.On("DeleteDelayed", id) + return &AutoRefresh_DeleteDelayed{Call: c_call} +} + +func (_m *AutoRefresh) OnDeleteDelayedMatch(matchers ...interface{}) *AutoRefresh_DeleteDelayed { + c_call := _m.On("DeleteDelayed", matchers...) + return &AutoRefresh_DeleteDelayed{Call: c_call} +} + +// DeleteDelayed provides a mock function with given fields: id +func (_m *AutoRefresh) DeleteDelayed(id string) error { + ret := _m.Called(id) + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(id) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +type AutoRefresh_Get struct { + *mock.Call +} + +func (_m AutoRefresh_Get) Return(_a0 autorefreshcache.Item, _a1 error) *AutoRefresh_Get { + return &AutoRefresh_Get{Call: _m.Call.Return(_a0, _a1)} +} + +func (_m *AutoRefresh) OnGet(id string) *AutoRefresh_Get { + c_call := _m.On("Get", id) + return &AutoRefresh_Get{Call: c_call} +} + +func (_m *AutoRefresh) OnGetMatch(matchers ...interface{}) *AutoRefresh_Get { + c_call := _m.On("Get", matchers...) + return &AutoRefresh_Get{Call: c_call} +} + +// Get provides a mock function with given fields: id +func (_m *AutoRefresh) Get(id string) (autorefreshcache.Item, error) { + ret := _m.Called(id) + + var r0 autorefreshcache.Item + if rf, ok := ret.Get(0).(func(string) autorefreshcache.Item); ok { + r0 = rf(id) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(autorefreshcache.Item) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(id) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +type AutoRefresh_GetOrCreate struct { + *mock.Call +} + +func (_m AutoRefresh_GetOrCreate) Return(_a0 autorefreshcache.Item, _a1 error) *AutoRefresh_GetOrCreate { + return &AutoRefresh_GetOrCreate{Call: _m.Call.Return(_a0, _a1)} +} + +func (_m *AutoRefresh) OnGetOrCreate(id string, item autorefreshcache.Item) *AutoRefresh_GetOrCreate { + c_call := _m.On("GetOrCreate", id, item) + return &AutoRefresh_GetOrCreate{Call: c_call} +} + +func (_m *AutoRefresh) OnGetOrCreateMatch(matchers ...interface{}) *AutoRefresh_GetOrCreate { + c_call := _m.On("GetOrCreate", matchers...) + return &AutoRefresh_GetOrCreate{Call: c_call} +} + +// GetOrCreate provides a mock function with given fields: id, item +func (_m *AutoRefresh) GetOrCreate(id string, item autorefreshcache.Item) (autorefreshcache.Item, error) { + ret := _m.Called(id, item) + + var r0 autorefreshcache.Item + if rf, ok := ret.Get(0).(func(string, autorefreshcache.Item) autorefreshcache.Item); ok { + r0 = rf(id, item) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(autorefreshcache.Item) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(string, autorefreshcache.Item) error); ok { + r1 = rf(id, item) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +type AutoRefresh_Start struct { + *mock.Call +} + +func (_m AutoRefresh_Start) Return(_a0 error) *AutoRefresh_Start { + return &AutoRefresh_Start{Call: _m.Call.Return(_a0)} +} + +func (_m *AutoRefresh) OnStart(ctx context.Context) *AutoRefresh_Start { + c_call := _m.On("Start", ctx) + return &AutoRefresh_Start{Call: c_call} +} + +func (_m *AutoRefresh) OnStartMatch(matchers ...interface{}) *AutoRefresh_Start { + c_call := _m.On("Start", matchers...) + return &AutoRefresh_Start{Call: c_call} +} + +// Start provides a mock function with given fields: ctx +func (_m *AutoRefresh) Start(ctx context.Context) error { + ret := _m.Called(ctx) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(ctx) + } else { + r0 = ret.Error(0) + } + + return r0 +} diff --git a/flytestdlib/autorefreshcache/mocks/AutoRefreshWithUpdate.go b/flytestdlib/autorefreshcache/mocks/AutoRefreshWithUpdate.go new file mode 100644 index 0000000000..7b0cf84185 --- /dev/null +++ b/flytestdlib/autorefreshcache/mocks/AutoRefreshWithUpdate.go @@ -0,0 +1,194 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + context "context" + + autorefreshcache "github.com/flyteorg/flyte/v2/flytestdlib/autorefreshcache" + + mock "github.com/stretchr/testify/mock" +) + +// AutoRefreshWithUpdate is an autogenerated mock type for the AutoRefreshWithUpdate type +type AutoRefreshWithUpdate struct { + mock.Mock +} + +type AutoRefreshWithUpdate_DeleteDelayed struct { + *mock.Call +} + +func (_m AutoRefreshWithUpdate_DeleteDelayed) Return(_a0 error) *AutoRefreshWithUpdate_DeleteDelayed { + return &AutoRefreshWithUpdate_DeleteDelayed{Call: _m.Call.Return(_a0)} +} + +func (_m *AutoRefreshWithUpdate) OnDeleteDelayed(id string) *AutoRefreshWithUpdate_DeleteDelayed { + c_call := _m.On("DeleteDelayed", id) + return &AutoRefreshWithUpdate_DeleteDelayed{Call: c_call} +} + +func (_m *AutoRefreshWithUpdate) OnDeleteDelayedMatch(matchers ...interface{}) *AutoRefreshWithUpdate_DeleteDelayed { + c_call := _m.On("DeleteDelayed", matchers...) + return &AutoRefreshWithUpdate_DeleteDelayed{Call: c_call} +} + +// DeleteDelayed provides a mock function with given fields: id +func (_m *AutoRefreshWithUpdate) DeleteDelayed(id string) error { + ret := _m.Called(id) + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(id) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +type AutoRefreshWithUpdate_Get struct { + *mock.Call +} + +func (_m AutoRefreshWithUpdate_Get) Return(_a0 autorefreshcache.Item, _a1 error) *AutoRefreshWithUpdate_Get { + return &AutoRefreshWithUpdate_Get{Call: _m.Call.Return(_a0, _a1)} +} + +func (_m *AutoRefreshWithUpdate) OnGet(id string) *AutoRefreshWithUpdate_Get { + c_call := _m.On("Get", id) + return &AutoRefreshWithUpdate_Get{Call: c_call} +} + +func (_m *AutoRefreshWithUpdate) OnGetMatch(matchers ...interface{}) *AutoRefreshWithUpdate_Get { + c_call := _m.On("Get", matchers...) + return &AutoRefreshWithUpdate_Get{Call: c_call} +} + +// Get provides a mock function with given fields: id +func (_m *AutoRefreshWithUpdate) Get(id string) (autorefreshcache.Item, error) { + ret := _m.Called(id) + + var r0 autorefreshcache.Item + if rf, ok := ret.Get(0).(func(string) autorefreshcache.Item); ok { + r0 = rf(id) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(autorefreshcache.Item) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(id) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +type AutoRefreshWithUpdate_GetOrCreate struct { + *mock.Call +} + +func (_m AutoRefreshWithUpdate_GetOrCreate) Return(_a0 autorefreshcache.Item, _a1 error) *AutoRefreshWithUpdate_GetOrCreate { + return &AutoRefreshWithUpdate_GetOrCreate{Call: _m.Call.Return(_a0, _a1)} +} + +func (_m *AutoRefreshWithUpdate) OnGetOrCreate(id string, item autorefreshcache.Item) *AutoRefreshWithUpdate_GetOrCreate { + c_call := _m.On("GetOrCreate", id, item) + return &AutoRefreshWithUpdate_GetOrCreate{Call: c_call} +} + +func (_m *AutoRefreshWithUpdate) OnGetOrCreateMatch(matchers ...interface{}) *AutoRefreshWithUpdate_GetOrCreate { + c_call := _m.On("GetOrCreate", matchers...) + return &AutoRefreshWithUpdate_GetOrCreate{Call: c_call} +} + +// GetOrCreate provides a mock function with given fields: id, item +func (_m *AutoRefreshWithUpdate) GetOrCreate(id string, item autorefreshcache.Item) (autorefreshcache.Item, error) { + ret := _m.Called(id, item) + + var r0 autorefreshcache.Item + if rf, ok := ret.Get(0).(func(string, autorefreshcache.Item) autorefreshcache.Item); ok { + r0 = rf(id, item) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(autorefreshcache.Item) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(string, autorefreshcache.Item) error); ok { + r1 = rf(id, item) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +type AutoRefreshWithUpdate_Start struct { + *mock.Call +} + +func (_m AutoRefreshWithUpdate_Start) Return(_a0 error) *AutoRefreshWithUpdate_Start { + return &AutoRefreshWithUpdate_Start{Call: _m.Call.Return(_a0)} +} + +func (_m *AutoRefreshWithUpdate) OnStart(ctx context.Context) *AutoRefreshWithUpdate_Start { + c_call := _m.On("Start", ctx) + return &AutoRefreshWithUpdate_Start{Call: c_call} +} + +func (_m *AutoRefreshWithUpdate) OnStartMatch(matchers ...interface{}) *AutoRefreshWithUpdate_Start { + c_call := _m.On("Start", matchers...) + return &AutoRefreshWithUpdate_Start{Call: c_call} +} + +// Start provides a mock function with given fields: ctx +func (_m *AutoRefreshWithUpdate) Start(ctx context.Context) error { + ret := _m.Called(ctx) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(ctx) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +type AutoRefreshWithUpdate_Update struct { + *mock.Call +} + +func (_m AutoRefreshWithUpdate_Update) Return(ok bool) *AutoRefreshWithUpdate_Update { + return &AutoRefreshWithUpdate_Update{Call: _m.Call.Return(ok)} +} + +func (_m *AutoRefreshWithUpdate) OnUpdate(id string, item autorefreshcache.Item) *AutoRefreshWithUpdate_Update { + c_call := _m.On("Update", id, item) + return &AutoRefreshWithUpdate_Update{Call: c_call} +} + +func (_m *AutoRefreshWithUpdate) OnUpdateMatch(matchers ...interface{}) *AutoRefreshWithUpdate_Update { + c_call := _m.On("Update", matchers...) + return &AutoRefreshWithUpdate_Update{Call: c_call} +} + +// Update provides a mock function with given fields: id, item +func (_m *AutoRefreshWithUpdate) Update(id string, item autorefreshcache.Item) bool { + ret := _m.Called(id, item) + + var r0 bool + if rf, ok := ret.Get(0).(func(string, autorefreshcache.Item) bool); ok { + r0 = rf(id, item) + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} diff --git a/flytestdlib/autorefreshcache/mocks/Item.go b/flytestdlib/autorefreshcache/mocks/Item.go new file mode 100644 index 0000000000..24dada6b4d --- /dev/null +++ b/flytestdlib/autorefreshcache/mocks/Item.go @@ -0,0 +1,42 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// Item is an autogenerated mock type for the Item type +type Item struct { + mock.Mock +} + +type Item_IsTerminal struct { + *mock.Call +} + +func (_m Item_IsTerminal) Return(_a0 bool) *Item_IsTerminal { + return &Item_IsTerminal{Call: _m.Call.Return(_a0)} +} + +func (_m *Item) OnIsTerminal() *Item_IsTerminal { + c_call := _m.On("IsTerminal") + return &Item_IsTerminal{Call: c_call} +} + +func (_m *Item) OnIsTerminalMatch(matchers ...interface{}) *Item_IsTerminal { + c_call := _m.On("IsTerminal", matchers...) + return &Item_IsTerminal{Call: c_call} +} + +// IsTerminal provides a mock function with given fields: +func (_m *Item) IsTerminal() bool { + ret := _m.Called() + + var r0 bool + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} diff --git a/flytestdlib/autorefreshcache/mocks/ItemWrapper.go b/flytestdlib/autorefreshcache/mocks/ItemWrapper.go new file mode 100644 index 0000000000..e86bd07ce8 --- /dev/null +++ b/flytestdlib/autorefreshcache/mocks/ItemWrapper.go @@ -0,0 +1,80 @@ +// Code generated by mockery v1.0.1. DO NOT EDIT. + +package mocks + +import ( + mock "github.com/stretchr/testify/mock" + + autorefreshcache "github.com/flyteorg/flyte/v2/flytestdlib/autorefreshcache" +) + +// ItemWrapper is an autogenerated mock type for the ItemWrapper type +type ItemWrapper struct { + mock.Mock +} + +type ItemWrapper_GetID struct { + *mock.Call +} + +func (_m ItemWrapper_GetID) Return(_a0 string) *ItemWrapper_GetID { + return &ItemWrapper_GetID{Call: _m.Call.Return(_a0)} +} + +func (_m *ItemWrapper) OnGetID() *ItemWrapper_GetID { + c_call := _m.On("GetID") + return &ItemWrapper_GetID{Call: c_call} +} + +func (_m *ItemWrapper) OnGetIDMatch(matchers ...interface{}) *ItemWrapper_GetID { + c_call := _m.On("GetID", matchers...) + return &ItemWrapper_GetID{Call: c_call} +} + +// GetID provides a mock function with given fields: +func (_m *ItemWrapper) GetID() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +type ItemWrapper_GetItem struct { + *mock.Call +} + +func (_m ItemWrapper_GetItem) Return(_a0 autorefreshcache.Item) *ItemWrapper_GetItem { + return &ItemWrapper_GetItem{Call: _m.Call.Return(_a0)} +} + +func (_m *ItemWrapper) OnGetItem() *ItemWrapper_GetItem { + c_call := _m.On("GetItem") + return &ItemWrapper_GetItem{Call: c_call} +} + +func (_m *ItemWrapper) OnGetItemMatch(matchers ...interface{}) *ItemWrapper_GetItem { + c_call := _m.On("GetItem", matchers...) + return &ItemWrapper_GetItem{Call: c_call} +} + +// GetItem provides a mock function with given fields: +func (_m *ItemWrapper) GetItem() autorefreshcache.Item { + ret := _m.Called() + + var r0 autorefreshcache.Item + if rf, ok := ret.Get(0).(func() autorefreshcache.Item); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(autorefreshcache.Item) + } + } + + return r0 +} diff --git a/flytestdlib/autorefreshcache/sync_set.go b/flytestdlib/autorefreshcache/sync_set.go new file mode 100644 index 0000000000..d30f0e847c --- /dev/null +++ b/flytestdlib/autorefreshcache/sync_set.go @@ -0,0 +1,40 @@ +package autorefreshcache + +import "sync" + +var emptyVal = struct{}{} + +// syncSet is a thread-safe Set. +type syncSet struct { + underlying sync.Map +} + +// Contains checks if the key is present in the set. +func (s *syncSet) Contains(key interface{}) bool { + _, found := s.underlying.Load(key) + return found +} + +// Insert adds a new key to the set if it doesn't already exist. +func (s *syncSet) Insert(key interface{}) { + s.underlying.Store(key, emptyVal) +} + +// Remove deletes a key from the set. +func (s *syncSet) Remove(key interface{}) { + s.underlying.Delete(key) +} + +// Range allows iterating over the set. Deleting the key while iterating is a supported operation. +func (s *syncSet) Range(callback func(key interface{}) bool) { + s.underlying.Range(func(key, value interface{}) bool { + return callback(key) + }) +} + +// newSyncSet initializes a new thread-safe set. +func newSyncSet() *syncSet { + return &syncSet{ + underlying: sync.Map{}, + } +} diff --git a/flytestdlib/autorefreshcache/sync_set_test.go b/flytestdlib/autorefreshcache/sync_set_test.go new file mode 100644 index 0000000000..7836bccb0f --- /dev/null +++ b/flytestdlib/autorefreshcache/sync_set_test.go @@ -0,0 +1,49 @@ +package autorefreshcache + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func rangeAndRemove(tb testing.TB, s *syncSet, count int) { + for i := 0; i < count; i++ { + s.Insert(i) + } + + s.Range(func(key interface{}) bool { + s.Remove(key) + return true + }) + + for i := 0; i < count; i++ { + assert.False(tb, s.Contains(i)) + } +} + +func TestSyncSet_Range(t *testing.T) { + s := newSyncSet() + rangeAndRemove(t, s, 1000) +} + +func BenchmarkSyncSet_Range(b *testing.B) { + s := newSyncSet() + rangeAndRemove(b, s, b.N) +} + +func TestSyncSet_Contains(t *testing.T) { + s := newSyncSet() + count := 1000 + for i := 0; i < count; i++ { + s.Insert(i) + } + + for i := 0; i < count; i++ { + assert.True(t, s.Contains(i)) + s.Remove(i) + } + + for i := 0; i < count; i++ { + assert.False(t, s.Contains(i)) + } +} diff --git a/flytestdlib/bitarray/bitset.go b/flytestdlib/bitarray/bitset.go new file mode 100644 index 0000000000..be957fecb3 --- /dev/null +++ b/flytestdlib/bitarray/bitset.go @@ -0,0 +1,80 @@ +package bitarray + +import ( + "unsafe" +) + +/* #nosec */ +const blockSize = uint(unsafe.Sizeof(Block(0))) * 8 + +type Block uint32 + +// BitSet is a set of bits that can be set, cleared and queried. +type BitSet []Block + +// Ensures that the given bit is set in the BitSet. +func (s *BitSet) Set(i uint) { + // #nosec G115 + if len(*s) < int(i/blockSize+1) { + *s = append(*s, make([]Block, i/blockSize+1)...) + } + + (*s)[i/blockSize] |= 1 << (i % blockSize) +} + +// Ensures that the given bit is cleared (unset) in the BitSet. +func (s *BitSet) Clear(i uint) { + // #nosec G115 + if len(*s) >= int(i/blockSize+1) { + (*s)[i/blockSize] &^= 1 << (i % blockSize) + } +} + +// Returns true if the given bit is set, false if it is cleared. +func (s *BitSet) IsSet(i uint) bool { + // #nosec G115 + if len(*s) < int(i/blockSize+1) { + return false + } + + return (*s)[i/blockSize]&(1<<(i%blockSize)) != 0 +} + +// Returns the number of blocks of the BitSet. +func (s *BitSet) BlockCount() int { + return len(*s) +} + +// Returns the length of the BitSet. +func (s *BitSet) Cap() uint { + return uint(s.BlockCount()) * blockSize // #nosec G115 + +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (s BitSet) DeepCopyInto(out *BitSet) { + in := &s + *out = make(BitSet, len(*in)) + copy(*out, *in) +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BitSet. +func (s BitSet) DeepCopy() BitSet { + if s == nil { + return nil + } + + out := new(BitSet) + s.DeepCopyInto(out) + return *out +} + +// Initializes a new BitSet of the specified size. +func NewBitSet(desiredCap uint) *BitSet { + size := desiredCap / blockSize + if desiredCap%blockSize != 0 { + size++ + } + a := make(BitSet, size) + return &a +} diff --git a/flytestdlib/bitarray/bitset_test.go b/flytestdlib/bitarray/bitset_test.go new file mode 100644 index 0000000000..60572fbe3c --- /dev/null +++ b/flytestdlib/bitarray/bitset_test.go @@ -0,0 +1,68 @@ +package bitarray + +import ( + "fmt" + "testing" + + "github.com/stretchr/testify/assert" +) + +func ExampleBitSet() { + s := new(BitSet) + s.Set(13) + s.Set(45) + s.Clear(13) + fmt.Printf("s.IsSet(13) = %t; s.IsSet(45) = %t; s.IsSet(30) = %t\n", + s.IsSet(13), s.IsSet(45), s.IsSet(30)) + // Output: s.IsSet(13) = false; s.IsSet(45) = true; s.IsSet(30) = false +} + +func TestBitSet_Set(t *testing.T) { + t.Run("Empty Set", func(t *testing.T) { + b := new(BitSet) + b.Set(5) + assert.True(t, b.IsSet(5)) + }) + + t.Run("Auto resize", func(t *testing.T) { + b := new(BitSet) + b.Set(2) + assert.Equal(t, 1, len(*b)) + assert.False(t, b.IsSet(500)) + b.Set(500) + assert.True(t, b.IsSet(2)) + assert.True(t, b.IsSet(500)) + }) +} + +func TestNewBitSet(t *testing.T) { + t.Run("Empty", func(t *testing.T) { + b := new(BitSet) + assert.Equal(t, 0, b.BlockCount()) + + b = NewBitSet(0) + assert.Equal(t, 0, b.BlockCount()) + }) + + t.Run("Block size", func(t *testing.T) { + b := NewBitSet(63) + assert.Equal(t, 2, b.BlockCount()) + }) + + t.Run("Bigger than block size", func(t *testing.T) { + b := NewBitSet(100) + assert.Equal(t, 4, b.BlockCount()) + }) +} + +func TestBitSet_Cap(t *testing.T) { + t.Run("Cap == size", func(t *testing.T) { + b := NewBitSet(blockSize * 5) + assert.Equal(t, int(blockSize*5), int(b.Cap())) // #nosec G115 + }) + + t.Run("Cap > size", func(t *testing.T) { + b := NewBitSet(blockSize*2 + 20) + assert.Equal(t, int(blockSize*3), int(b.Cap())) // #nosec G115 + }) +} diff --git a/flytestdlib/bitarray/compact_array.go b/flytestdlib/bitarray/compact_array.go new file mode 100644 index 0000000000..c16e4f8083 --- /dev/null +++ b/flytestdlib/bitarray/compact_array.go @@ -0,0 +1,136 @@ +// Contains efficient array that stores small-range values (up to uint64) in a bit array to optimize storage. +package bitarray + +import ( + "errors" + "fmt" + "math" + "unsafe" +) + +// The biggest Item size that can fit in CompactArray. +type Item = uint64 + +// Provides a wrapper on top of BitSet to store items of arbitrary size (up to 64 bits each) efficiently. +type CompactArray struct { + *BitSet `json:",inline"` + ItemSize uint `json:"item,omitempty"` + ItemsCount uint `json:"count,omitempty"` +} + +func bitsNeeded(maxValue Item) uint { + return uint(math.Ceil(math.Log2(float64(maxValue + 1)))) +} + +func (a *CompactArray) validateIndex(index int) { + if index < 0 || uint(index) >= a.ItemsCount { + panic(fmt.Sprintf("Attempt to access index [%v] in CompactArray of size [%v]", index, a.ItemsCount)) + } +} + +func (a *CompactArray) validateValue(value Item) { + maxValue := (uint64(1) << a.ItemSize) - 1 + if value > maxValue { + panic(fmt.Sprintf("Value [%v] is too big. Max value is [%v].", value, maxValue)) + } +} + +// Sets item at index to provided value. +func (a *CompactArray) SetItem(index int, value Item) { + a.validateIndex(index) + a.validateValue(value) + bitIndex := uint(index) * a.ItemSize // #nosec G115 + x := Item(1) + // #nosec G115 + for i := int(a.ItemSize - 1); i >= 0; i-- { + if x&value != 0 { + a.Set(bitIndex + uint(i)) // #nosec G115 + + } else { + a.Clear(bitIndex + uint(i)) // #nosec G115 + + } + + x <<= 1 + } +} + +// Gets Item at provided index. +func (a *CompactArray) GetItem(index int) Item { + a.validateIndex(index) + bitIndex := uint(index) * a.ItemSize // #nosec G115 + res := Item(0) + x := Item(1) + // #nosec G115 + for i := int(a.ItemSize - 1); i >= 0; i-- { + // #nosec G115 + if a.IsSet(bitIndex + uint(i)) { + res |= x + } + + x <<= 1 + } + + return res +} + +// Gets all items stored in the array. The size of the returned array matches the ItemsCount it was initialized with. +func (a CompactArray) GetItems() []Item { + res := make([]Item, 0, a.ItemsCount) + // #nosec G115 + for i := 0; i < int(a.ItemsCount); i++ { + res = append(res, a.GetItem(i)) // #nosec G115 + } + + return res +} + +// Gets a string representation of the array contents. This is a relatively expensive operation. +func (a CompactArray) String() string { + res := "[" + for _, item := range a.GetItems() { + res += fmt.Sprintf("%v, ", item) + } + + res += "]" + return res +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (a *CompactArray) DeepCopyInto(out *CompactArray) { + *out = *a + if a.BitSet != nil { + in, out := &a.BitSet, &out.BitSet + *out = new(BitSet) + if **in != nil { + in, out := *in, *out + *out = make([]Block, len(*in)) + copy(*out, *in) + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CompactArray. +func (a *CompactArray) DeepCopy() *CompactArray { + if a == nil { + return nil + } + out := new(CompactArray) + a.DeepCopyInto(out) + return out +} + +// Creates a new CompactArray of specified size. +func NewCompactArray(size uint, maxValue Item) (CompactArray, error) { + itemSize := bitsNeeded(maxValue) + /* #nosec */ + if uint64(itemSize) >= uint64(unsafe.Sizeof(Item(0))*8) { + return CompactArray{}, errors.New("invalid itemSize, must be less than the size of Item") + } + + return CompactArray{ + BitSet: NewBitSet(size), + ItemsCount: size, + ItemSize: itemSize, + }, nil +} diff --git a/flytestdlib/bitarray/compact_array_test.go b/flytestdlib/bitarray/compact_array_test.go new file mode 100644 index 0000000000..8d69f839d9 --- /dev/null +++ b/flytestdlib/bitarray/compact_array_test.go @@ -0,0 +1,157 @@ +package bitarray + +import ( + "crypto/rand" + "encoding/binary" + "encoding/json" + "fmt" + "math" + "testing" + + "github.com/stretchr/testify/assert" +) + +func getRandInt() uint64 { + c := 10 + b := make([]byte, c) + _, err := rand.Read(b) + if err != nil { + return 0 + } + + return binary.BigEndian.Uint64(b) +} + +func TestNewItemArray(t *testing.T) { + for itemSize := uint(1); itemSize < 60; itemSize++ { + t.Run(fmt.Sprintf("Item Size %v", itemSize), func(t *testing.T) { + maxItemValue := 1 << (itemSize - 1) + itemsCount := uint(math.Min(float64(200), float64(maxItemValue))) + expected := make([]Item, 0, itemsCount) + + arr, err := NewCompactArray(itemsCount, Item(1)<<(itemSize-1)) + assert.NoError(t, err) + + // #nosec G115 + for i := 0; i < int(itemsCount); i++ { + // Ensure inserted items is in the accepted range (0 -> 1< 1< 0 { + password, err := secretManager.Get(ctx, r.PasswordSecretName) + if err != nil { + return nil, errors.Wrapf(err, "failed to get password from secret manager for secret %s", r.PasswordSecretName) + } + + r.Password = password + } + + return &redis.Options{ + Network: r.Network, + Addr: r.Addr, + ClientName: r.ClientName, + Password: r.Password, + DB: r.DB, + MaxRetries: r.MaxRetries, + MinRetryBackoff: r.MinRetryBackoff.Duration, + MaxRetryBackoff: r.MaxRetryBackoff.Duration, + DialTimeout: r.DialTimeout.Duration, + ReadTimeout: r.ReadTimeout.Duration, + WriteTimeout: r.WriteTimeout.Duration, + ContextTimeoutEnabled: r.ContextTimeoutEnabled, + PoolFIFO: r.PoolFIFO, + PoolSize: r.PoolSize, + PoolTimeout: r.PoolTimeout.Duration, + MinIdleConns: r.MinIdleConns, + MaxIdleConns: r.MaxIdleConns, + MaxActiveConns: r.MaxActiveConns, + ConnMaxIdleTime: r.ConnMaxIdleTime.Duration, + ConnMaxLifetime: r.ConnMaxLifetime.Duration, + TLSConfig: r.TLSConfig, + DisableIndentity: r.DisableIndentity, + Username: r.Username, + }, nil +} + +func GetConfig() *Config { + return configSection.GetConfig().(*Config) +} + +func MustRegisterSubsection(name string, cfg config.Config) config.Section { + return configSection.MustRegisterSection(name, cfg) +} diff --git a/flytestdlib/cache/factory.go b/flytestdlib/cache/factory.go new file mode 100644 index 0000000000..520d728ec9 --- /dev/null +++ b/flytestdlib/cache/factory.go @@ -0,0 +1,120 @@ +// Package cache provides a cache implementation that wraps eko/gocache and provides a simple interface for caching +// in memory as well as through redis. Ideally we move all cache references/implementations to use this package. This way +// we can provide a single namespaced cache for all services and make it easier to add caching for new features. +// For the in-memory implementation, it uses freecache which is a simple in-memory cache that uses a fixed size memory +// pool. For redis, it uses the redis client from the redis/go-redis package. +// Future enhancements could include adding priority/cost per namespace to allow us to evict less important namespaces' +// cache entries when memory is low. rositto has this feature but it's not clear if it's worth the complexity. + +package cache + +import ( + "context" + "fmt" + "reflect" + + "github.com/coocood/freecache" + "github.com/eko/gocache/lib/v4/cache" + promMetrics "github.com/eko/gocache/lib/v4/metrics" + "github.com/eko/gocache/lib/v4/store" + freecacheStore "github.com/eko/gocache/store/freecache/v4" + redisStore "github.com/eko/gocache/store/redis/v4" + "github.com/prometheus/client_golang/prometheus" + "github.com/redis/go-redis/extra/redisprometheus/v9" + "github.com/redis/go-redis/v9" + "google.golang.org/protobuf/proto" + + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +type Factory struct { + cfg *Config + inMemoryCache store.StoreInterface + redisCacheStore store.StoreInterface +} + +type StringCache = cache.CacheInterface[string] +type UInt64Cache = cache.CacheInterface[uint64] + +func (f Factory) Type() Type { + return f.cfg.Type +} + +type SecretManager interface { + Get(ctx context.Context, key string) (string, error) +} + +// NewRedisClient initializes a new redis client with the given options. +func NewRedisClient(ctx context.Context, cfg RedisOptions, secretManager SecretManager, scope promutils.Scope) (*redis.Client, error) { + redisOptions, err := cfg.GetOptions(ctx, secretManager) + if err != nil { + return nil, fmt.Errorf("failed to get redis options: %w", err) + } + + redisClient := redis.NewClient(redisOptions) + redisClientScope := scope.NewSubScope("redis") + collector := redisprometheus.NewCollector(redisClientScope.CurrentScope(), "", redisClient) + prometheus.MustRegister(collector) + redisClient.AddHook(NewRedisInstrumentationHook(redisClientScope)) + + return redisClient, nil +} + +// NewFactory initializes a new cache factory that should be used whenever typed caches are created. +func NewFactory(ctx context.Context, c *Config, secretManager SecretManager, scope promutils.Scope) (Factory, error) { + f := Factory{ + cfg: c, + inMemoryCache: freecacheStore.NewFreecache(freecache.NewCache( + int(c.InMemoryFixedSize.Size.Value())), + store.WithExpiration(c.InMemoryFixedSize.DefaultExpiration.Duration)), + } + + switch c.Type { + case TypeInMemoryFixedSize: + case TypeRedis: + redisClient, err := NewRedisClient(ctx, c.Redis.Options, secretManager, scope) + if err != nil { + return Factory{}, fmt.Errorf("failed to create redis client: %w", err) + } + + f.redisCacheStore = redisStore.NewRedis( + redisClient, + store.WithExpiration(c.Redis.DefaultExpiration.Duration)) + } + + return f, nil +} + +// New creates a new cache with the given name and load function. +func New[T any](name string, cacheType Type, f Factory, loadFunc cache.LoadFunction[T], scope promutils.Scope) (cache.CacheInterface[T], error) { + scope = scope.NewSubScope(name) + var cacheManager cache.CacheInterface[any] + inMemoryStoreCache := cache.New[any](f.inMemoryCache) + + switch cacheType { + case TypeInMemoryFixedSize: + cacheManager = inMemoryStoreCache + case TypeRedis: + redisStoreCache := cache.New[any](f.redisCacheStore) + cacheManager = cache.NewChain[any](inMemoryStoreCache, redisStoreCache) + } + + promMetrics := promMetrics.NewPrometheus(name, + promMetrics.WithRegisterer(prometheus.DefaultRegisterer), + promMetrics.WithNamespace(scope.CurrentScope())) + cacheManager = cache.NewMetric[any](promMetrics, cacheManager) + + var marshalerCache *Marshaler + if reflect.TypeOf(new(T)).Elem().Implements(reflect.TypeOf((*proto.Message)(nil)).Elem()) { + marshalerCache = NewProtoMarshaler(cacheManager) + } else { + marshalerCache = NewMsgPackMarshaler(cacheManager) + } + + namespacedCache := NewNamespacedCache[T](name, NewTypedMarshaler[T](marshalerCache)) + if loadFunc != nil { + return cache.NewLoadable[T](loadFunc, namespacedCache), nil + } + + return namespacedCache, nil +} diff --git a/flytestdlib/cache/in_memory_auto_refresh.go b/flytestdlib/cache/in_memory_auto_refresh.go new file mode 100644 index 0000000000..16502f2e2a --- /dev/null +++ b/flytestdlib/cache/in_memory_auto_refresh.go @@ -0,0 +1,440 @@ +package cache + +import ( + "context" + "fmt" + "runtime/debug" + "sync" + "time" + + lru "github.com/hashicorp/golang-lru" + "github.com/prometheus/client_golang/prometheus" + "k8s.io/client-go/util/workqueue" + "k8s.io/utils/clock" + + "github.com/flyteorg/flyte/v2/flytestdlib/atomic" + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +type metrics struct { + SyncErrors prometheus.Counter + Evictions prometheus.Counter + SyncLatency promutils.StopWatch + CacheHit prometheus.Counter + CacheMiss prometheus.Counter + Size prometheus.Gauge + scope promutils.Scope +} + +func newMetrics(scope promutils.Scope) metrics { + return metrics{ + SyncErrors: scope.MustNewCounter("sync_errors", "Counter for sync errors."), + Evictions: scope.MustNewCounter("lru_evictions", "Counter for evictions from LRU."), + SyncLatency: scope.MustNewStopWatch("latency", "Latency for sync operations.", time.Millisecond), + CacheHit: scope.MustNewCounter("cache_hit", "Counter for cache hits."), + CacheMiss: scope.MustNewCounter("cache_miss", "Counter for cache misses."), + Size: scope.MustNewGauge("size", "Current size of the cache"), + scope: scope, + } +} + +func getEvictionFunction(counter prometheus.Counter) func(key interface{}, value interface{}) { + return func(_ interface{}, _ interface{}) { + counter.Inc() + } +} + +// Options are configurable options for the InMemoryAutoRefresh. +type Options struct { + clock clock.WithTicker + createBatchesCb CreateBatchesFunc + syncOnCreate bool +} + +// WithClock configures the clock to use for time related operations. Mainly used for unit testing. +func WithClock(clock clock.WithTicker) Option { + return func(mo *Options) { + mo.clock = clock + } +} + +// WithCreateBatchesFunc configures how cache items should be batched for refresh. Defaults to single item batching. +func WithCreateBatchesFunc(createBatchesCb CreateBatchesFunc) Option { + return func(mo *Options) { + mo.createBatchesCb = createBatchesCb + } +} + +// WithSyncOnCreate configures whether the cache will attempt to sync items upon creation or wait until the next +// sync interval. Disabling this can be useful when the cache is under high load and synchronization both frequently +// and in large batches. Defaults to true. +func WithSyncOnCreate(syncOnCreate bool) Option { + return func(mo *Options) { + mo.syncOnCreate = syncOnCreate + } +} + +func defaultOptions() *Options { + opts := &Options{} + WithClock(clock.RealClock{})(opts) + WithCreateBatchesFunc(SingleItemBatches)(opts) + WithSyncOnCreate(true)(opts) + return opts +} + +// Option for the KeyfuncProvider +type Option func(*Options) + +// InMemoryAutoRefresh is an in-memory implementation of the AutoRefresh interface. It is a thread-safe general +// purpose auto-refresh cache that watches for updates asynchronously for the keys after they are added to +// the cache. An item can be inserted only once. +// +// Get reads from sync.map while refresh is invoked on a snapshot of keys. Cache eventually catches up on deleted items. +// +// Sync is run as a fixed-interval-scheduled-task, and is skipped if sync from previous cycle is still running. +type InMemoryAutoRefresh struct { + name string + metrics metrics + syncCb SyncFunc + createBatchesCb CreateBatchesFunc + lruMap *lru.Cache + // Items that are currently being processed are in the processing set. + // It will prevent the same item from being processed multiple times by different workers. + processing *sync.Map + toDelete *syncSet + syncPeriod time.Duration + workqueue workqueue.RateLimitingInterface + parallelizm uint + lock sync.RWMutex + clock clock.Clock // pluggable clock for unit testing + syncCount atomic.Int32 // internal sync counter for unit testing + enqueueCount atomic.Int32 // internal enqueue counter for unit testing + enqueueLoopRunning atomic.Bool // internal bool to ensure goroutines are running + syncOnCreate bool +} + +// NewInMemoryAutoRefresh creates a new InMemoryAutoRefresh +func NewInMemoryAutoRefresh( + name string, + syncCb SyncFunc, + syncRateLimiter workqueue.RateLimiter, + resyncPeriod time.Duration, + parallelizm uint, + size uint, + scope promutils.Scope, + options ...Option, +) (*InMemoryAutoRefresh, error) { + opts := defaultOptions() + for _, option := range options { + option(opts) + } + + metrics := newMetrics(scope) + // #nosec G115 + lruCache, err := lru.NewWithEvict(int(size), getEvictionFunction(metrics.Evictions)) + if err != nil { + return nil, fmt.Errorf("creating LRU cache: %w", err) + } + + cache := &InMemoryAutoRefresh{ + name: name, + metrics: metrics, + parallelizm: parallelizm, + createBatchesCb: opts.createBatchesCb, + syncCb: syncCb, + lruMap: lruCache, + processing: &sync.Map{}, + toDelete: newSyncSet(), + syncPeriod: resyncPeriod, + workqueue: workqueue.NewRateLimitingQueueWithConfig(syncRateLimiter, workqueue.RateLimitingQueueConfig{ + Name: scope.CurrentScope(), + Clock: opts.clock, + }), + clock: opts.clock, + syncCount: atomic.NewInt32(0), + enqueueCount: atomic.NewInt32(0), + enqueueLoopRunning: atomic.NewBool(false), + syncOnCreate: opts.syncOnCreate, + } + + return cache, nil +} + +func (w *InMemoryAutoRefresh) Start(ctx context.Context) error { + for i := uint(0); i < w.parallelizm; i++ { + go func(ctx context.Context) { + err := w.sync(ctx) + if err != nil { + logger.Errorf(ctx, "Failed to sync. Error: %v", err) + } + }(contextutils.WithGoroutineLabel(ctx, fmt.Sprintf("%v-worker-%v", w.name, i))) + } + + enqueueCtx := contextutils.WithGoroutineLabel(ctx, fmt.Sprintf("%v-enqueue", w.name)) + go w.enqueueLoop(enqueueCtx) + + return nil +} + +func (w *InMemoryAutoRefresh) enqueueLoop(ctx context.Context) { + timer := w.clock.NewTimer(w.syncPeriod) + defer timer.Stop() + + w.enqueueLoopRunning.Store(true) + + for { + select { + case <-ctx.Done(): + return + case <-timer.C(): + err := w.enqueueBatches(ctx) + if err != nil { + logger.Errorf(ctx, "Failed to enqueue. Error: %v", err) + } + timer.Reset(w.syncPeriod) + } + } +} + +// Update updates the item only if it exists in the cache, return true if we updated the item. +func (w *InMemoryAutoRefresh) Update(id ItemID, item Item) (ok bool) { + w.lock.Lock() + defer w.lock.Unlock() + ok = w.lruMap.Contains(id) + if ok { + w.lruMap.Add(id, item) + } + return ok +} + +// Delete deletes the item from the cache if it exists. +func (w *InMemoryAutoRefresh) Delete(key interface{}) { + w.lock.Lock() + defer w.lock.Unlock() + w.toDelete.Remove(key) + w.lruMap.Remove(key) +} + +func (w *InMemoryAutoRefresh) Get(id ItemID) (Item, error) { + if val, ok := w.lruMap.Get(id); ok { + w.metrics.CacheHit.Inc() + return val.(Item), nil + } + + w.metrics.CacheMiss.Inc() + return nil, errors.Errorf(ErrNotFound, "Item with id [%v] not found.", id) +} + +// Return the item if exists else create it. +// Create should be invoked only once. recreating the object is not supported. +func (w *InMemoryAutoRefresh) GetOrCreate(id ItemID, item Item) (Item, error) { + if val, ok := w.lruMap.Get(id); ok { + w.metrics.CacheHit.Inc() + return val.(Item), nil + } + + w.lruMap.Add(id, item) + w.metrics.CacheMiss.Inc() + + // It fixes cold start issue in the AutoRefreshCache by adding the item to the workqueue when it is created. + // This way, the item will be processed without waiting for the next sync cycle (30s by default). + if w.syncOnCreate { + batch := make([]ItemWrapper, 0, 1) + batch = append(batch, itemWrapper{id: id, item: item}) + w.workqueue.AddRateLimited(&batch) + w.processing.Store(id, w.clock.Now()) + } + return item, nil +} + +// DeleteDelayed queues an item for deletion. It Will get deleted as part of the next Sync cycle. Until the next sync +// cycle runs, Get and GetOrCreate will continue to return the Item in its previous state. +func (w *InMemoryAutoRefresh) DeleteDelayed(id ItemID) error { + w.toDelete.Insert(id) + return nil +} + +// This function is called internally by its own timer. Roughly, it will list keys, create batches of keys based on +// createBatchesCb and, enqueue all the batches into the workqueue. +func (w *InMemoryAutoRefresh) enqueueBatches(ctx context.Context) error { + defer w.enqueueCount.Inc() + + keys := w.lruMap.Keys() + w.metrics.Size.Set(float64(len(keys))) + + snapshot := make([]ItemWrapper, 0, len(keys)) + for _, k := range keys { + if w.toDelete.Contains(k) { + w.Delete(k) + continue + } + // If not ok, it means evicted between the item was evicted between getting the keys and this update loop + // which is fine, we can just ignore. + if value, ok := w.lruMap.Peek(k); ok { + if item, ok := value.(Item); !ok || (ok && !item.IsTerminal() && !w.inProcessing(k)) { + snapshot = append(snapshot, itemWrapper{ + id: k.(ItemID), + item: value.(Item), + }) + } + } + } + + batches, err := w.createBatchesCb(ctx, snapshot) + if err != nil { + return err + } + + for _, batch := range batches { + b := batch + w.workqueue.AddRateLimited(&b) + for i := 1; i < len(b); i++ { + w.processing.Store(b[i].GetID(), w.clock.Now()) + } + } + + return nil +} + +// There are w.parallelizm instances of this function running all the time, each one will: +// - Retrieve an item from the workqueue +// - For each batch of the keys, call syncCb, which tells us if the items have been updated +// -- If any has, then overwrite the item in the cache. +// +// What happens when the number of things that a user is trying to keep track of exceeds the size +// of the cache? Trivial case where the cache is size 1 and we're trying to keep track of two things. +// * Plugin asks for update on item 1 - cache evicts item 2, stores 1 and returns it unchanged +// * Plugin asks for update on item 2 - cache evicts item 1, stores 2 and returns it unchanged +// * Sync loop updates item 2, repeat +func (w *InMemoryAutoRefresh) sync(ctx context.Context) (err error) { + defer func() { + var isErr bool + rVal := recover() + if rVal == nil { + return + } + + if err, isErr = rVal.(error); isErr { + err = fmt.Errorf("worker panic'd and is shutting down. Error: %w with Stack: %v", err, string(debug.Stack())) + } else { + err = fmt.Errorf("worker panic'd and is shutting down. Panic value: %v with Stack: %v", rVal, string(debug.Stack())) + } + + logger.Error(ctx, err) + }() + + for { + select { + case <-ctx.Done(): + return nil + default: + batch, shutdown := w.workqueue.Get() + if shutdown { + logger.Debugf(ctx, "Shutting down worker") + return nil + } + // Since we create batches every time we sync, we will just remove the item from the queue here + // regardless of whether it succeeded the sync or not. + w.workqueue.Forget(batch) + w.workqueue.Done(batch) + + newBatch := make(Batch, 0, len(*batch.(*Batch))) + for _, b := range *batch.(*Batch) { + itemID := b.GetID() + w.processing.Delete(itemID) + item, ok := w.lruMap.Get(itemID) + if !ok { + logger.Debugf(ctx, "item with id [%v] not found in cache", itemID) + continue + } + if item.(Item).IsTerminal() { + logger.Debugf(ctx, "item with id [%v] is terminal", itemID) + continue + } + newBatch = append(newBatch, b) + } + if len(newBatch) == 0 { + continue + } + + t := w.metrics.SyncLatency.Start() + updatedBatch, err := w.syncCb(ctx, newBatch) + + if err != nil { + w.metrics.SyncErrors.Inc() + logger.Errorf(ctx, "failed to get latest copy of a batch. Error: %v", err) + t.Stop() + continue + } + + for _, item := range updatedBatch { + if item.Action == Update { + // Updates an existing item. + w.Update(item.ID, item.Item) + } + } + + w.toDelete.Range(func(key interface{}) bool { + w.Delete(key) + return true + }) + + t.Stop() + } + + w.syncCount.Inc() + } +} + +// Checks if the item is currently being processed and returns false if the item has been in processing for too long +func (w *InMemoryAutoRefresh) inProcessing(key interface{}) bool { + item, found := w.processing.Load(key) + if found { + // handle potential race conditions where the item is in processing but not in the workqueue + if timeItem, ok := item.(time.Time); ok && w.clock.Since(timeItem) > (w.syncPeriod*5) { + w.processing.Delete(key) + return false + } + return true + } + return false +} + +// Instantiates a new AutoRefresh Cache that syncs items in batches. +func NewAutoRefreshBatchedCache(name string, createBatches CreateBatchesFunc, syncCb SyncFunc, syncRateLimiter workqueue.RateLimiter, + resyncPeriod time.Duration, parallelizm, size uint, scope promutils.Scope) (AutoRefresh, error) { + return NewInMemoryAutoRefresh(name, syncCb, syncRateLimiter, resyncPeriod, parallelizm, size, scope, WithCreateBatchesFunc(createBatches)) +} + +// Instantiates a new AutoRefresh Cache that syncs items periodically. +func NewAutoRefreshCache(name string, syncCb SyncFunc, syncRateLimiter workqueue.RateLimiter, resyncPeriod time.Duration, + parallelizm, size uint, scope promutils.Scope) (AutoRefresh, error) { + return NewAutoRefreshBatchedCache(name, SingleItemBatches, syncCb, syncRateLimiter, resyncPeriod, parallelizm, size, scope) +} + +// SingleItemBatches is a function that creates n batches of items, each with size 1 +func SingleItemBatches(_ context.Context, snapshot []ItemWrapper) (batches []Batch, err error) { + res := make([]Batch, 0, len(snapshot)) + for _, item := range snapshot { + res = append(res, Batch{item}) + } + + return res, nil +} + +// itemWrapper is an implementation of ItemWrapper +type itemWrapper struct { + id ItemID + item Item +} + +func (i itemWrapper) GetID() ItemID { + return i.id +} + +func (i itemWrapper) GetItem() Item { + return i.item +} diff --git a/flytestdlib/cache/in_memory_auto_refresh_test.go b/flytestdlib/cache/in_memory_auto_refresh_test.go new file mode 100644 index 0000000000..a320ec99d2 --- /dev/null +++ b/flytestdlib/cache/in_memory_auto_refresh_test.go @@ -0,0 +1,344 @@ +package cache + +import ( + "context" + "fmt" + "strconv" + "sync" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "k8s.io/client-go/util/workqueue" + testingclock "k8s.io/utils/clock/testing" + + "github.com/flyteorg/flyte/v2/flytestdlib/atomic" + "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +const fakeCacheItemValueLimit = 10 + +type fakeCacheItem struct { + val int + isTerminal bool +} + +func (f fakeCacheItem) IsTerminal() bool { + return f.isTerminal +} + +type terminalCacheItem struct { + val int +} + +func (t terminalCacheItem) IsTerminal() bool { + return true +} + +func syncFakeItem(_ context.Context, batch Batch) ([]ItemSyncResponse, error) { + items := make([]ItemSyncResponse, 0, len(batch)) + for _, obj := range batch { + item := obj.GetItem().(fakeCacheItem) + if item.val == fakeCacheItemValueLimit { + // After the item has gone through ten update cycles, leave it unchanged + continue + } + isTerminal := false + if item.val == fakeCacheItemValueLimit-1 { + isTerminal = true + } + items = append(items, ItemSyncResponse{ + ID: obj.GetID(), + Item: fakeCacheItem{ + val: item.val + 1, + isTerminal: isTerminal, + }, + Action: Update, + }) + } + + return items, nil +} + +func syncTerminalItem(_ context.Context, batch Batch) ([]ItemSyncResponse, error) { + panic("This should never be called") +} + +type panickingSyncer struct { + callCount atomic.Int32 +} + +func (p *panickingSyncer) sync(_ context.Context, _ Batch) ([]ItemSyncResponse, error) { + p.callCount.Inc() + panic("testing") +} + +func TestCacheFour(t *testing.T) { + testResyncPeriod := 5 * time.Second + rateLimiter := workqueue.DefaultControllerRateLimiter() + fakeClock := testingclock.NewFakeClock(time.Now()) + + t.Run("normal operation", func(t *testing.T) { + // the size of the cache is at least as large as the number of items we're storing + cache, err := NewInMemoryAutoRefresh("fake1", syncFakeItem, rateLimiter, testResyncPeriod, 10, 10, promutils.NewTestScope(), WithClock(fakeClock)) + assert.NoError(t, err) + + ctx, cancel := context.WithCancel(context.Background()) + assert.NoError(t, cache.Start(ctx)) + + // Create ten items in the cache + for i := 1; i <= 10; i++ { + _, err := cache.GetOrCreate(fmt.Sprintf("%d", i), fakeCacheItem{ + val: 0, + }) + assert.NoError(t, err) + } + + // Cache should be processing + assert.NotEmpty(t, cache.processing) + + assert.EventuallyWithT(t, func(c *assert.CollectT) { + // trigger periodic sync + fakeClock.Step(testResyncPeriod) + + for i := 1; i <= 10; i++ { + item, err := cache.Get(fmt.Sprintf("%d", i)) + assert.NoError(c, err) + assert.Equal(c, 10, item.(fakeCacheItem).val) + } + }, 3*time.Second, time.Millisecond) + cancel() + }) + + t.Run("disable sync on create", func(t *testing.T) { + cache, err := NewInMemoryAutoRefresh("fake1", syncFakeItem, rateLimiter, testResyncPeriod, 10, 10, promutils.NewTestScope(), WithClock(fakeClock), WithSyncOnCreate(false)) + assert.NoError(t, err) + + ctx, cancel := context.WithCancel(context.Background()) + assert.NoError(t, cache.Start(ctx)) + + // Create ten items in the cache + for i := 1; i <= 10; i++ { + _, err := cache.GetOrCreate(fmt.Sprintf("%d", i), fakeCacheItem{ + val: 0, + }) + assert.NoError(t, err) + } + + // Validate that none are processing since they aren't synced on creation + assert.Empty(t, cache.processing) + + assert.EventuallyWithT(t, func(c *assert.CollectT) { + // trigger periodic sync + fakeClock.Step(testResyncPeriod) + + for i := 1; i <= 10; i++ { + item, err := cache.Get(fmt.Sprintf("%d", i)) + assert.NoError(c, err) + assert.Equal(c, 10, item.(fakeCacheItem).val) + } + }, 3*time.Second, time.Millisecond) + cancel() + }) + + t.Run("Not Found", func(t *testing.T) { + // the size of the cache is at least as large as the number of items we're storing + cache, err := NewInMemoryAutoRefresh("fake2", syncFakeItem, rateLimiter, testResyncPeriod, 10, 2, promutils.NewTestScope(), WithClock(fakeClock)) + assert.NoError(t, err) + + ctx, cancel := context.WithCancel(context.Background()) + assert.NoError(t, cache.Start(ctx)) + + // Create ten items in the cache + for i := 1; i <= 10; i++ { + _, err := cache.GetOrCreate(fmt.Sprintf("%d", i), fakeCacheItem{ + val: 0, + }) + assert.NoError(t, err) + } + + notFound := 0 + for i := 1; i <= 10; i++ { + _, err := cache.Get(fmt.Sprintf("%d", i)) + if err != nil && errors.IsCausedBy(err, ErrNotFound) { + notFound++ + } + } + + assert.Equal(t, 8, notFound) + + cancel() + }) + + t.Run("Enqueue nothing", func(t *testing.T) { + cache, err := NewInMemoryAutoRefresh("fake3", syncTerminalItem, rateLimiter, testResyncPeriod, 10, 2, promutils.NewTestScope(), WithClock(fakeClock)) + assert.NoError(t, err) + + ctx, cancel := context.WithCancel(context.Background()) + assert.NoError(t, cache.Start(ctx)) + + // Wait for goroutines to run + assert.Eventually(t, func() bool { return cache.enqueueLoopRunning.Load() }, time.Second, time.Millisecond) + + // Create ten items in the cache + for i := 1; i <= 10; i++ { + _, err := cache.GetOrCreate(fmt.Sprintf("%d", i), terminalCacheItem{ + val: 0, + }) + assert.NoError(t, err) + } + + syncCount := cache.syncCount.Load() + enqueueCount := cache.enqueueCount.Load() + // Move time forwards and trigger the first batch + fakeClock.Step(testResyncPeriod) + // If the cache tries to enqueue the item, a panic will be thrown. + assert.Eventually(t, func() bool { return cache.enqueueCount.Load() > enqueueCount }, time.Second, time.Millisecond) + // Should not enqueue + assert.Equal(t, syncCount, cache.syncCount.Load()) + + syncCount = cache.syncCount.Load() + enqueueCount = cache.enqueueCount.Load() + // Move time forwards and trigger the first batch + fakeClock.Step(testResyncPeriod) + // If the cache tries to enqueue the item, a panic will be thrown. + assert.Eventually(t, func() bool { return cache.enqueueCount.Load() > enqueueCount }, time.Second, time.Millisecond) + // Should not enqueue + assert.Equal(t, syncCount, cache.syncCount.Load()) + + cancel() + }) + + t.Run("Test update and delete cache", func(t *testing.T) { + cache, err := NewInMemoryAutoRefresh("fake3", syncTerminalItem, rateLimiter, testResyncPeriod, 10, 2, promutils.NewTestScope(), WithClock(fakeClock)) + assert.NoError(t, err) + + ctx, cancel := context.WithCancel(context.Background()) + assert.NoError(t, cache.Start(ctx)) + + // Wait for goroutines to run + assert.Eventually(t, func() bool { return cache.enqueueLoopRunning.Load() }, time.Second, time.Millisecond) + + itemID := "dummy_id" + _, err = cache.GetOrCreate(itemID, terminalCacheItem{ + val: 0, + }) + assert.NoError(t, err) + + syncCount := cache.syncCount.Load() + enqueueCount := cache.enqueueCount.Load() + // Move time forwards and trigger the enqueue loop + fakeClock.Step(testResyncPeriod) + // If the cache tries to enqueue the item, a panic will be thrown. + assert.Eventually(t, func() bool { return cache.enqueueCount.Load() > enqueueCount }, time.Second, time.Millisecond) + // Should not enqueue + assert.Equal(t, syncCount, cache.syncCount.Load()) + + err = cache.DeleteDelayed(itemID) + assert.NoError(t, err) + + assert.EventuallyWithT(t, func(c *assert.CollectT) { + // trigger a sync + fakeClock.Step(testResyncPeriod) + + item, err := cache.Get(itemID) + assert.Nil(c, item) + assert.Error(c, err) + }, 3*time.Second, time.Millisecond) + + cancel() + }) + + t.Run("Test panic on sync and shutdown", func(t *testing.T) { + syncer := &panickingSyncer{} + cache, err := NewInMemoryAutoRefresh("fake3", syncer.sync, rateLimiter, testResyncPeriod, 10, 2, promutils.NewTestScope(), WithClock(fakeClock)) + assert.NoError(t, err) + + ctx, cancel := context.WithCancel(context.Background()) + assert.NoError(t, cache.Start(ctx)) + + itemID := "dummy_id" + _, err = cache.GetOrCreate(itemID, fakeCacheItem{ + val: 0, + }) + assert.NoError(t, err) + + // wait for all workers to run + assert.Eventually(t, func() bool { + // trigger a sync + fakeClock.Step(testResyncPeriod) + + return syncer.callCount.Load() == int32(10) + }, 5*time.Second, time.Millisecond) + + cancel() + }) +} + +func TestQueueBuildUp(t *testing.T) { + testResyncPeriod := time.Hour + rateLimiter := workqueue.DefaultControllerRateLimiter() + fakeClock := testingclock.NewFakeClock(time.Now()) + + syncCount := atomic.NewInt32(0) + m := sync.Map{} + alwaysFailing := func(ctx context.Context, batch Batch) ( + updatedBatch []ItemSyncResponse, err error) { + assert.Len(t, batch, 1) + _, existing := m.LoadOrStore(batch[0].GetID(), 0) + assert.False(t, existing, "Saw %v before", batch[0].GetID()) + if existing { + t.FailNow() + } + + syncCount.Inc() + return nil, fmt.Errorf("expected error") + } + + size := uint(100) + cache, err := NewInMemoryAutoRefresh("fake2", alwaysFailing, rateLimiter, testResyncPeriod, 10, size, promutils.NewTestScope(), WithClock(fakeClock)) + assert.NoError(t, err) + + ctx, cancel := context.WithCancel(context.Background()) + assert.NoError(t, cache.Start(ctx)) + defer cancel() + + for i := uint(0); i < size; i++ { + // #nosec G115 + _, err := cache.GetOrCreate(strconv.Itoa(int(i)), fakeCacheItem{val: 3}) + assert.NoError(t, err) + } + + // wait for all workers to run + assert.Eventually(t, func() bool { + // trigger a sync and unlock the work queue + fakeClock.Step(time.Millisecond) + + return syncCount.Load() == int32(size) // #nosec G115 + + }, 5*time.Second, time.Millisecond) +} + +func TestInProcessing(t *testing.T) { + syncer := &panickingSyncer{} + syncPeriod := time.Millisecond + rateLimiter := workqueue.DefaultControllerRateLimiter() + fakeClock := testingclock.NewFakeClock(time.Now()) + cache, err := NewInMemoryAutoRefresh("fake3", syncer.sync, rateLimiter, syncPeriod, 10, 2, promutils.NewTestScope(), WithClock(fakeClock)) + assert.NoError(t, err) + + ctx, cancel := context.WithCancel(context.Background()) + assert.NoError(t, cache.Start(ctx)) + defer cancel() + + assert.False(t, cache.inProcessing("test")) + + cache.processing.Store("test", time.Now()) + assert.True(t, cache.inProcessing("test")) + + cache.processing.Store("test1", time.Now().Add(syncPeriod*-11)) + assert.False(t, cache.inProcessing("test1")) + _, found := cache.processing.Load("test1") + assert.False(t, found) +} diff --git a/flytestdlib/cache/marshaler.go b/flytestdlib/cache/marshaler.go new file mode 100644 index 0000000000..52eed9d39d --- /dev/null +++ b/flytestdlib/cache/marshaler.go @@ -0,0 +1,79 @@ +package cache + +import ( + "context" + + "github.com/eko/gocache/lib/v4/cache" + "github.com/eko/gocache/lib/v4/store" + "github.com/vmihailenco/msgpack/v5" + "google.golang.org/protobuf/proto" +) + +// Marshaler is the struct that marshal and unmarshal cache values +type Marshaler struct { + cache.CacheInterface[any] + useProto bool +} + +// Get obtains a value from cache and unmarshal value with given object +func (c *Marshaler) Get(ctx context.Context, key any, returnObj any) (any, error) { + result, err := c.CacheInterface.Get(ctx, key) + if err != nil { + return nil, err + } + + var raw []byte + switch v := result.(type) { + case []byte: + raw = v + case string: + raw = []byte(v) + } + + if c.useProto { + err = proto.Unmarshal(raw, returnObj.(proto.Message)) + } else { + err = msgpack.Unmarshal(raw, returnObj) + } + + if err != nil { + return nil, err + } + + return returnObj, nil +} + +// Set sets a value in cache by marshaling value +func (c *Marshaler) Set(ctx context.Context, key, object any, options ...store.Option) (err error) { + var raw []byte + if c.useProto { + raw, err = proto.Marshal(object.(proto.Message)) + if err != nil { + return err + } + + } else { + raw, err = msgpack.Marshal(object) + if err != nil { + return err + } + } + + return c.CacheInterface.Set(ctx, key, raw, options...) +} + +// NewProtoMarshaler creates a new marshaler that marshals/unmarshals cache values using proto.Marshal. +func NewProtoMarshaler(cache cache.CacheInterface[any]) *Marshaler { + return &Marshaler{ + CacheInterface: cache, + useProto: true, + } +} + +// NewMsgPackMarshaler creates a new marshaler that marshals/unmarshals cache values using MsgPack. +func NewMsgPackMarshaler(cache cache.CacheInterface[any]) *Marshaler { + return &Marshaler{ + CacheInterface: cache, + useProto: false, + } +} diff --git a/flytestdlib/cache/mocks/Item.go b/flytestdlib/cache/mocks/Item.go new file mode 100644 index 0000000000..9d21dedb13 --- /dev/null +++ b/flytestdlib/cache/mocks/Item.go @@ -0,0 +1,77 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// Item is an autogenerated mock type for the Item type +type Item struct { + mock.Mock +} + +type Item_Expecter struct { + mock *mock.Mock +} + +func (_m *Item) EXPECT() *Item_Expecter { + return &Item_Expecter{mock: &_m.Mock} +} + +// IsTerminal provides a mock function with no fields +func (_m *Item) IsTerminal() bool { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for IsTerminal") + } + + var r0 bool + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// Item_IsTerminal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsTerminal' +type Item_IsTerminal_Call struct { + *mock.Call +} + +// IsTerminal is a helper method to define mock.On call +func (_e *Item_Expecter) IsTerminal() *Item_IsTerminal_Call { + return &Item_IsTerminal_Call{Call: _e.mock.On("IsTerminal")} +} + +func (_c *Item_IsTerminal_Call) Run(run func()) *Item_IsTerminal_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Item_IsTerminal_Call) Return(_a0 bool) *Item_IsTerminal_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Item_IsTerminal_Call) RunAndReturn(run func() bool) *Item_IsTerminal_Call { + _c.Call.Return(run) + return _c +} + +// NewItem creates a new instance of Item. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewItem(t interface { + mock.TestingT + Cleanup(func()) +}) *Item { + mock := &Item{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/cache/mocks/Option.go b/flytestdlib/cache/mocks/Option.go new file mode 100644 index 0000000000..8bb0d5164b --- /dev/null +++ b/flytestdlib/cache/mocks/Option.go @@ -0,0 +1,68 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + cache "github.com/flyteorg/flyte/v2/flytestdlib/cache" + mock "github.com/stretchr/testify/mock" +) + +// Option is an autogenerated mock type for the Option type +type Option struct { + mock.Mock +} + +type Option_Expecter struct { + mock *mock.Mock +} + +func (_m *Option) EXPECT() *Option_Expecter { + return &Option_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: _a0 +func (_m *Option) Execute(_a0 *cache.Options) { + _m.Called(_a0) +} + +// Option_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type Option_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - _a0 *cache.Options +func (_e *Option_Expecter) Execute(_a0 interface{}) *Option_Execute_Call { + return &Option_Execute_Call{Call: _e.mock.On("Execute", _a0)} +} + +func (_c *Option_Execute_Call) Run(run func(_a0 *cache.Options)) *Option_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*cache.Options)) + }) + return _c +} + +func (_c *Option_Execute_Call) Return() *Option_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *Option_Execute_Call) RunAndReturn(run func(*cache.Options)) *Option_Execute_Call { + _c.Run(run) + return _c +} + +// NewOption creates a new instance of Option. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewOption(t interface { + mock.TestingT + Cleanup(func()) +}) *Option { + mock := &Option{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/cache/mocks/auto_refresh.go b/flytestdlib/cache/mocks/auto_refresh.go new file mode 100644 index 0000000000..5b5cb1c696 --- /dev/null +++ b/flytestdlib/cache/mocks/auto_refresh.go @@ -0,0 +1,247 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + cache "github.com/flyteorg/flyte/v2/flytestdlib/cache" + + mock "github.com/stretchr/testify/mock" +) + +// AutoRefresh is an autogenerated mock type for the AutoRefresh type +type AutoRefresh struct { + mock.Mock +} + +type AutoRefresh_Expecter struct { + mock *mock.Mock +} + +func (_m *AutoRefresh) EXPECT() *AutoRefresh_Expecter { + return &AutoRefresh_Expecter{mock: &_m.Mock} +} + +// DeleteDelayed provides a mock function with given fields: id +func (_m *AutoRefresh) DeleteDelayed(id cache.ItemID) error { + ret := _m.Called(id) + + if len(ret) == 0 { + panic("no return value specified for DeleteDelayed") + } + + var r0 error + if rf, ok := ret.Get(0).(func(cache.ItemID) error); ok { + r0 = rf(id) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AutoRefresh_DeleteDelayed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteDelayed' +type AutoRefresh_DeleteDelayed_Call struct { + *mock.Call +} + +// DeleteDelayed is a helper method to define mock.On call +// - id cache.ItemID +func (_e *AutoRefresh_Expecter) DeleteDelayed(id interface{}) *AutoRefresh_DeleteDelayed_Call { + return &AutoRefresh_DeleteDelayed_Call{Call: _e.mock.On("DeleteDelayed", id)} +} + +func (_c *AutoRefresh_DeleteDelayed_Call) Run(run func(id cache.ItemID)) *AutoRefresh_DeleteDelayed_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(cache.ItemID)) + }) + return _c +} + +func (_c *AutoRefresh_DeleteDelayed_Call) Return(_a0 error) *AutoRefresh_DeleteDelayed_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AutoRefresh_DeleteDelayed_Call) RunAndReturn(run func(cache.ItemID) error) *AutoRefresh_DeleteDelayed_Call { + _c.Call.Return(run) + return _c +} + +// Get provides a mock function with given fields: id +func (_m *AutoRefresh) Get(id cache.ItemID) (cache.Item, error) { + ret := _m.Called(id) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 cache.Item + var r1 error + if rf, ok := ret.Get(0).(func(cache.ItemID) (cache.Item, error)); ok { + return rf(id) + } + if rf, ok := ret.Get(0).(func(cache.ItemID) cache.Item); ok { + r0 = rf(id) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(cache.Item) + } + } + + if rf, ok := ret.Get(1).(func(cache.ItemID) error); ok { + r1 = rf(id) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AutoRefresh_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type AutoRefresh_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - id cache.ItemID +func (_e *AutoRefresh_Expecter) Get(id interface{}) *AutoRefresh_Get_Call { + return &AutoRefresh_Get_Call{Call: _e.mock.On("Get", id)} +} + +func (_c *AutoRefresh_Get_Call) Run(run func(id cache.ItemID)) *AutoRefresh_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(cache.ItemID)) + }) + return _c +} + +func (_c *AutoRefresh_Get_Call) Return(_a0 cache.Item, _a1 error) *AutoRefresh_Get_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AutoRefresh_Get_Call) RunAndReturn(run func(cache.ItemID) (cache.Item, error)) *AutoRefresh_Get_Call { + _c.Call.Return(run) + return _c +} + +// GetOrCreate provides a mock function with given fields: id, item +func (_m *AutoRefresh) GetOrCreate(id cache.ItemID, item cache.Item) (cache.Item, error) { + ret := _m.Called(id, item) + + if len(ret) == 0 { + panic("no return value specified for GetOrCreate") + } + + var r0 cache.Item + var r1 error + if rf, ok := ret.Get(0).(func(cache.ItemID, cache.Item) (cache.Item, error)); ok { + return rf(id, item) + } + if rf, ok := ret.Get(0).(func(cache.ItemID, cache.Item) cache.Item); ok { + r0 = rf(id, item) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(cache.Item) + } + } + + if rf, ok := ret.Get(1).(func(cache.ItemID, cache.Item) error); ok { + r1 = rf(id, item) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AutoRefresh_GetOrCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrCreate' +type AutoRefresh_GetOrCreate_Call struct { + *mock.Call +} + +// GetOrCreate is a helper method to define mock.On call +// - id cache.ItemID +// - item cache.Item +func (_e *AutoRefresh_Expecter) GetOrCreate(id interface{}, item interface{}) *AutoRefresh_GetOrCreate_Call { + return &AutoRefresh_GetOrCreate_Call{Call: _e.mock.On("GetOrCreate", id, item)} +} + +func (_c *AutoRefresh_GetOrCreate_Call) Run(run func(id cache.ItemID, item cache.Item)) *AutoRefresh_GetOrCreate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(cache.ItemID), args[1].(cache.Item)) + }) + return _c +} + +func (_c *AutoRefresh_GetOrCreate_Call) Return(_a0 cache.Item, _a1 error) *AutoRefresh_GetOrCreate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AutoRefresh_GetOrCreate_Call) RunAndReturn(run func(cache.ItemID, cache.Item) (cache.Item, error)) *AutoRefresh_GetOrCreate_Call { + _c.Call.Return(run) + return _c +} + +// Start provides a mock function with given fields: ctx +func (_m *AutoRefresh) Start(ctx context.Context) error { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Start") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(ctx) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AutoRefresh_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start' +type AutoRefresh_Start_Call struct { + *mock.Call +} + +// Start is a helper method to define mock.On call +// - ctx context.Context +func (_e *AutoRefresh_Expecter) Start(ctx interface{}) *AutoRefresh_Start_Call { + return &AutoRefresh_Start_Call{Call: _e.mock.On("Start", ctx)} +} + +func (_c *AutoRefresh_Start_Call) Run(run func(ctx context.Context)) *AutoRefresh_Start_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *AutoRefresh_Start_Call) Return(_a0 error) *AutoRefresh_Start_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AutoRefresh_Start_Call) RunAndReturn(run func(context.Context) error) *AutoRefresh_Start_Call { + _c.Call.Return(run) + return _c +} + +// NewAutoRefresh creates a new instance of AutoRefresh. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAutoRefresh(t interface { + mock.TestingT + Cleanup(func()) +}) *AutoRefresh { + mock := &AutoRefresh{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/cache/mocks/create_batches_func.go b/flytestdlib/cache/mocks/create_batches_func.go new file mode 100644 index 0000000000..42c06383eb --- /dev/null +++ b/flytestdlib/cache/mocks/create_batches_func.go @@ -0,0 +1,97 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + cache "github.com/flyteorg/flyte/v2/flytestdlib/cache" + + mock "github.com/stretchr/testify/mock" +) + +// CreateBatchesFunc is an autogenerated mock type for the CreateBatchesFunc type +type CreateBatchesFunc struct { + mock.Mock +} + +type CreateBatchesFunc_Expecter struct { + mock *mock.Mock +} + +func (_m *CreateBatchesFunc) EXPECT() *CreateBatchesFunc_Expecter { + return &CreateBatchesFunc_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: ctx, snapshot +func (_m *CreateBatchesFunc) Execute(ctx context.Context, snapshot []cache.ItemWrapper) ([]cache.Batch, error) { + ret := _m.Called(ctx, snapshot) + + if len(ret) == 0 { + panic("no return value specified for Execute") + } + + var r0 []cache.Batch + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, []cache.ItemWrapper) ([]cache.Batch, error)); ok { + return rf(ctx, snapshot) + } + if rf, ok := ret.Get(0).(func(context.Context, []cache.ItemWrapper) []cache.Batch); ok { + r0 = rf(ctx, snapshot) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]cache.Batch) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, []cache.ItemWrapper) error); ok { + r1 = rf(ctx, snapshot) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// CreateBatchesFunc_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type CreateBatchesFunc_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - ctx context.Context +// - snapshot []cache.ItemWrapper +func (_e *CreateBatchesFunc_Expecter) Execute(ctx interface{}, snapshot interface{}) *CreateBatchesFunc_Execute_Call { + return &CreateBatchesFunc_Execute_Call{Call: _e.mock.On("Execute", ctx, snapshot)} +} + +func (_c *CreateBatchesFunc_Execute_Call) Run(run func(ctx context.Context, snapshot []cache.ItemWrapper)) *CreateBatchesFunc_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]cache.ItemWrapper)) + }) + return _c +} + +func (_c *CreateBatchesFunc_Execute_Call) Return(batches []cache.Batch, err error) *CreateBatchesFunc_Execute_Call { + _c.Call.Return(batches, err) + return _c +} + +func (_c *CreateBatchesFunc_Execute_Call) RunAndReturn(run func(context.Context, []cache.ItemWrapper) ([]cache.Batch, error)) *CreateBatchesFunc_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewCreateBatchesFunc creates a new instance of CreateBatchesFunc. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewCreateBatchesFunc(t interface { + mock.TestingT + Cleanup(func()) +}) *CreateBatchesFunc { + mock := &CreateBatchesFunc{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/cache/mocks/item_wrapper.go b/flytestdlib/cache/mocks/item_wrapper.go new file mode 100644 index 0000000000..1802b3da6f --- /dev/null +++ b/flytestdlib/cache/mocks/item_wrapper.go @@ -0,0 +1,127 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + cache "github.com/flyteorg/flyte/v2/flytestdlib/cache" + mock "github.com/stretchr/testify/mock" +) + +// ItemWrapper is an autogenerated mock type for the ItemWrapper type +type ItemWrapper struct { + mock.Mock +} + +type ItemWrapper_Expecter struct { + mock *mock.Mock +} + +func (_m *ItemWrapper) EXPECT() *ItemWrapper_Expecter { + return &ItemWrapper_Expecter{mock: &_m.Mock} +} + +// GetID provides a mock function with no fields +func (_m *ItemWrapper) GetID() cache.ItemID { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetID") + } + + var r0 cache.ItemID + if rf, ok := ret.Get(0).(func() cache.ItemID); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(cache.ItemID) + } + + return r0 +} + +// ItemWrapper_GetID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetID' +type ItemWrapper_GetID_Call struct { + *mock.Call +} + +// GetID is a helper method to define mock.On call +func (_e *ItemWrapper_Expecter) GetID() *ItemWrapper_GetID_Call { + return &ItemWrapper_GetID_Call{Call: _e.mock.On("GetID")} +} + +func (_c *ItemWrapper_GetID_Call) Run(run func()) *ItemWrapper_GetID_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ItemWrapper_GetID_Call) Return(_a0 cache.ItemID) *ItemWrapper_GetID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ItemWrapper_GetID_Call) RunAndReturn(run func() cache.ItemID) *ItemWrapper_GetID_Call { + _c.Call.Return(run) + return _c +} + +// GetItem provides a mock function with no fields +func (_m *ItemWrapper) GetItem() cache.Item { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetItem") + } + + var r0 cache.Item + if rf, ok := ret.Get(0).(func() cache.Item); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(cache.Item) + } + } + + return r0 +} + +// ItemWrapper_GetItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetItem' +type ItemWrapper_GetItem_Call struct { + *mock.Call +} + +// GetItem is a helper method to define mock.On call +func (_e *ItemWrapper_Expecter) GetItem() *ItemWrapper_GetItem_Call { + return &ItemWrapper_GetItem_Call{Call: _e.mock.On("GetItem")} +} + +func (_c *ItemWrapper_GetItem_Call) Run(run func()) *ItemWrapper_GetItem_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ItemWrapper_GetItem_Call) Return(_a0 cache.Item) *ItemWrapper_GetItem_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ItemWrapper_GetItem_Call) RunAndReturn(run func() cache.Item) *ItemWrapper_GetItem_Call { + _c.Call.Return(run) + return _c +} + +// NewItemWrapper creates a new instance of ItemWrapper. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewItemWrapper(t interface { + mock.TestingT + Cleanup(func()) +}) *ItemWrapper { + mock := &ItemWrapper{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/cache/mocks/secret_manager.go b/flytestdlib/cache/mocks/secret_manager.go new file mode 100644 index 0000000000..6505714ee6 --- /dev/null +++ b/flytestdlib/cache/mocks/secret_manager.go @@ -0,0 +1,93 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" +) + +// SecretManager is an autogenerated mock type for the SecretManager type +type SecretManager struct { + mock.Mock +} + +type SecretManager_Expecter struct { + mock *mock.Mock +} + +func (_m *SecretManager) EXPECT() *SecretManager_Expecter { + return &SecretManager_Expecter{mock: &_m.Mock} +} + +// Get provides a mock function with given fields: ctx, key +func (_m *SecretManager) Get(ctx context.Context, key string) (string, error) { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string) (string, error)); ok { + return rf(ctx, key) + } + if rf, ok := ret.Get(0).(func(context.Context, string) string); ok { + r0 = rf(ctx, key) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = rf(ctx, key) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SecretManager_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type SecretManager_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - key string +func (_e *SecretManager_Expecter) Get(ctx interface{}, key interface{}) *SecretManager_Get_Call { + return &SecretManager_Get_Call{Call: _e.mock.On("Get", ctx, key)} +} + +func (_c *SecretManager_Get_Call) Run(run func(ctx context.Context, key string)) *SecretManager_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *SecretManager_Get_Call) Return(_a0 string, _a1 error) *SecretManager_Get_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SecretManager_Get_Call) RunAndReturn(run func(context.Context, string) (string, error)) *SecretManager_Get_Call { + _c.Call.Return(run) + return _c +} + +// NewSecretManager creates a new instance of SecretManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewSecretManager(t interface { + mock.TestingT + Cleanup(func()) +}) *SecretManager { + mock := &SecretManager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/cache/mocks/string_cache.go b/flytestdlib/cache/mocks/string_cache.go new file mode 100644 index 0000000000..c01208f7ca --- /dev/null +++ b/flytestdlib/cache/mocks/string_cache.go @@ -0,0 +1,356 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + store "github.com/eko/gocache/lib/v4/store" + mock "github.com/stretchr/testify/mock" +) + +// StringCache is an autogenerated mock type for the StringCache type +type StringCache[T any] struct { + mock.Mock +} + +type StringCache_Expecter[T any] struct { + mock *mock.Mock +} + +func (_m *StringCache[T]) EXPECT() *StringCache_Expecter[T] { + return &StringCache_Expecter[T]{mock: &_m.Mock} +} + +// Clear provides a mock function with given fields: ctx +func (_m *StringCache[T]) Clear(ctx context.Context) error { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Clear") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(ctx) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// StringCache_Clear_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Clear' +type StringCache_Clear_Call[T any] struct { + *mock.Call +} + +// Clear is a helper method to define mock.On call +// - ctx context.Context +func (_e *StringCache_Expecter[T]) Clear(ctx interface{}) *StringCache_Clear_Call[T] { + return &StringCache_Clear_Call[T]{Call: _e.mock.On("Clear", ctx)} +} + +func (_c *StringCache_Clear_Call[T]) Run(run func(ctx context.Context)) *StringCache_Clear_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *StringCache_Clear_Call[T]) Return(_a0 error) *StringCache_Clear_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *StringCache_Clear_Call[T]) RunAndReturn(run func(context.Context) error) *StringCache_Clear_Call[T] { + _c.Call.Return(run) + return _c +} + +// Delete provides a mock function with given fields: ctx, key +func (_m *StringCache[T]) Delete(ctx context.Context, key any) error { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for Delete") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, any) error); ok { + r0 = rf(ctx, key) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// StringCache_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type StringCache_Delete_Call[T any] struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - ctx context.Context +// - key any +func (_e *StringCache_Expecter[T]) Delete(ctx interface{}, key interface{}) *StringCache_Delete_Call[T] { + return &StringCache_Delete_Call[T]{Call: _e.mock.On("Delete", ctx, key)} +} + +func (_c *StringCache_Delete_Call[T]) Run(run func(ctx context.Context, key any)) *StringCache_Delete_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(any)) + }) + return _c +} + +func (_c *StringCache_Delete_Call[T]) Return(_a0 error) *StringCache_Delete_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *StringCache_Delete_Call[T]) RunAndReturn(run func(context.Context, any) error) *StringCache_Delete_Call[T] { + _c.Call.Return(run) + return _c +} + +// Get provides a mock function with given fields: ctx, key +func (_m *StringCache[T]) Get(ctx context.Context, key any) (string, error) { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, any) (string, error)); ok { + return rf(ctx, key) + } + if rf, ok := ret.Get(0).(func(context.Context, any) string); ok { + r0 = rf(ctx, key) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(context.Context, any) error); ok { + r1 = rf(ctx, key) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StringCache_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type StringCache_Get_Call[T any] struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - key any +func (_e *StringCache_Expecter[T]) Get(ctx interface{}, key interface{}) *StringCache_Get_Call[T] { + return &StringCache_Get_Call[T]{Call: _e.mock.On("Get", ctx, key)} +} + +func (_c *StringCache_Get_Call[T]) Run(run func(ctx context.Context, key any)) *StringCache_Get_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(any)) + }) + return _c +} + +func (_c *StringCache_Get_Call[T]) Return(_a0 string, _a1 error) *StringCache_Get_Call[T] { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StringCache_Get_Call[T]) RunAndReturn(run func(context.Context, any) (string, error)) *StringCache_Get_Call[T] { + _c.Call.Return(run) + return _c +} + +// GetType provides a mock function with no fields +func (_m *StringCache[T]) GetType() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetType") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// StringCache_GetType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetType' +type StringCache_GetType_Call[T any] struct { + *mock.Call +} + +// GetType is a helper method to define mock.On call +func (_e *StringCache_Expecter[T]) GetType() *StringCache_GetType_Call[T] { + return &StringCache_GetType_Call[T]{Call: _e.mock.On("GetType")} +} + +func (_c *StringCache_GetType_Call[T]) Run(run func()) *StringCache_GetType_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *StringCache_GetType_Call[T]) Return(_a0 string) *StringCache_GetType_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *StringCache_GetType_Call[T]) RunAndReturn(run func() string) *StringCache_GetType_Call[T] { + _c.Call.Return(run) + return _c +} + +// Invalidate provides a mock function with given fields: ctx, options +func (_m *StringCache[T]) Invalidate(ctx context.Context, options ...store.InvalidateOption) error { + _va := make([]interface{}, len(options)) + for _i := range options { + _va[_i] = options[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Invalidate") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, ...store.InvalidateOption) error); ok { + r0 = rf(ctx, options...) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// StringCache_Invalidate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Invalidate' +type StringCache_Invalidate_Call[T any] struct { + *mock.Call +} + +// Invalidate is a helper method to define mock.On call +// - ctx context.Context +// - options ...store.InvalidateOption +func (_e *StringCache_Expecter[T]) Invalidate(ctx interface{}, options ...interface{}) *StringCache_Invalidate_Call[T] { + return &StringCache_Invalidate_Call[T]{Call: _e.mock.On("Invalidate", + append([]interface{}{ctx}, options...)...)} +} + +func (_c *StringCache_Invalidate_Call[T]) Run(run func(ctx context.Context, options ...store.InvalidateOption)) *StringCache_Invalidate_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]store.InvalidateOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(store.InvalidateOption) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *StringCache_Invalidate_Call[T]) Return(_a0 error) *StringCache_Invalidate_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *StringCache_Invalidate_Call[T]) RunAndReturn(run func(context.Context, ...store.InvalidateOption) error) *StringCache_Invalidate_Call[T] { + _c.Call.Return(run) + return _c +} + +// Set provides a mock function with given fields: ctx, key, object, options +func (_m *StringCache[T]) Set(ctx context.Context, key any, object string, options ...store.Option) error { + _va := make([]interface{}, len(options)) + for _i := range options { + _va[_i] = options[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key, object) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Set") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, any, string, ...store.Option) error); ok { + r0 = rf(ctx, key, object, options...) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// StringCache_Set_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Set' +type StringCache_Set_Call[T any] struct { + *mock.Call +} + +// Set is a helper method to define mock.On call +// - ctx context.Context +// - key any +// - object string +// - options ...store.Option +func (_e *StringCache_Expecter[T]) Set(ctx interface{}, key interface{}, object interface{}, options ...interface{}) *StringCache_Set_Call[T] { + return &StringCache_Set_Call[T]{Call: _e.mock.On("Set", + append([]interface{}{ctx, key, object}, options...)...)} +} + +func (_c *StringCache_Set_Call[T]) Run(run func(ctx context.Context, key any, object string, options ...store.Option)) *StringCache_Set_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]store.Option, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(store.Option) + } + } + run(args[0].(context.Context), args[1].(any), args[2].(string), variadicArgs...) + }) + return _c +} + +func (_c *StringCache_Set_Call[T]) Return(_a0 error) *StringCache_Set_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *StringCache_Set_Call[T]) RunAndReturn(run func(context.Context, any, string, ...store.Option) error) *StringCache_Set_Call[T] { + _c.Call.Return(run) + return _c +} + +// NewStringCache creates a new instance of StringCache. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewStringCache[T any](t interface { + mock.TestingT + Cleanup(func()) +}) *StringCache[T] { + mock := &StringCache[T]{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/cache/mocks/sync_func.go b/flytestdlib/cache/mocks/sync_func.go new file mode 100644 index 0000000000..49dea6844f --- /dev/null +++ b/flytestdlib/cache/mocks/sync_func.go @@ -0,0 +1,97 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + cache "github.com/flyteorg/flyte/v2/flytestdlib/cache" + + mock "github.com/stretchr/testify/mock" +) + +// SyncFunc is an autogenerated mock type for the SyncFunc type +type SyncFunc struct { + mock.Mock +} + +type SyncFunc_Expecter struct { + mock *mock.Mock +} + +func (_m *SyncFunc) EXPECT() *SyncFunc_Expecter { + return &SyncFunc_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: ctx, batch +func (_m *SyncFunc) Execute(ctx context.Context, batch cache.Batch) ([]cache.ItemSyncResponse, error) { + ret := _m.Called(ctx, batch) + + if len(ret) == 0 { + panic("no return value specified for Execute") + } + + var r0 []cache.ItemSyncResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, cache.Batch) ([]cache.ItemSyncResponse, error)); ok { + return rf(ctx, batch) + } + if rf, ok := ret.Get(0).(func(context.Context, cache.Batch) []cache.ItemSyncResponse); ok { + r0 = rf(ctx, batch) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]cache.ItemSyncResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, cache.Batch) error); ok { + r1 = rf(ctx, batch) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SyncFunc_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type SyncFunc_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - ctx context.Context +// - batch cache.Batch +func (_e *SyncFunc_Expecter) Execute(ctx interface{}, batch interface{}) *SyncFunc_Execute_Call { + return &SyncFunc_Execute_Call{Call: _e.mock.On("Execute", ctx, batch)} +} + +func (_c *SyncFunc_Execute_Call) Run(run func(ctx context.Context, batch cache.Batch)) *SyncFunc_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(cache.Batch)) + }) + return _c +} + +func (_c *SyncFunc_Execute_Call) Return(updatedBatch []cache.ItemSyncResponse, err error) *SyncFunc_Execute_Call { + _c.Call.Return(updatedBatch, err) + return _c +} + +func (_c *SyncFunc_Execute_Call) RunAndReturn(run func(context.Context, cache.Batch) ([]cache.ItemSyncResponse, error)) *SyncFunc_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewSyncFunc creates a new instance of SyncFunc. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewSyncFunc(t interface { + mock.TestingT + Cleanup(func()) +}) *SyncFunc { + mock := &SyncFunc{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/cache/mocks/u_int64_cache.go b/flytestdlib/cache/mocks/u_int64_cache.go new file mode 100644 index 0000000000..7cdc146e49 --- /dev/null +++ b/flytestdlib/cache/mocks/u_int64_cache.go @@ -0,0 +1,356 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + store "github.com/eko/gocache/lib/v4/store" + mock "github.com/stretchr/testify/mock" +) + +// UInt64Cache is an autogenerated mock type for the UInt64Cache type +type UInt64Cache[T any] struct { + mock.Mock +} + +type UInt64Cache_Expecter[T any] struct { + mock *mock.Mock +} + +func (_m *UInt64Cache[T]) EXPECT() *UInt64Cache_Expecter[T] { + return &UInt64Cache_Expecter[T]{mock: &_m.Mock} +} + +// Clear provides a mock function with given fields: ctx +func (_m *UInt64Cache[T]) Clear(ctx context.Context) error { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Clear") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(ctx) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// UInt64Cache_Clear_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Clear' +type UInt64Cache_Clear_Call[T any] struct { + *mock.Call +} + +// Clear is a helper method to define mock.On call +// - ctx context.Context +func (_e *UInt64Cache_Expecter[T]) Clear(ctx interface{}) *UInt64Cache_Clear_Call[T] { + return &UInt64Cache_Clear_Call[T]{Call: _e.mock.On("Clear", ctx)} +} + +func (_c *UInt64Cache_Clear_Call[T]) Run(run func(ctx context.Context)) *UInt64Cache_Clear_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *UInt64Cache_Clear_Call[T]) Return(_a0 error) *UInt64Cache_Clear_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *UInt64Cache_Clear_Call[T]) RunAndReturn(run func(context.Context) error) *UInt64Cache_Clear_Call[T] { + _c.Call.Return(run) + return _c +} + +// Delete provides a mock function with given fields: ctx, key +func (_m *UInt64Cache[T]) Delete(ctx context.Context, key any) error { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for Delete") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, any) error); ok { + r0 = rf(ctx, key) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// UInt64Cache_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type UInt64Cache_Delete_Call[T any] struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - ctx context.Context +// - key any +func (_e *UInt64Cache_Expecter[T]) Delete(ctx interface{}, key interface{}) *UInt64Cache_Delete_Call[T] { + return &UInt64Cache_Delete_Call[T]{Call: _e.mock.On("Delete", ctx, key)} +} + +func (_c *UInt64Cache_Delete_Call[T]) Run(run func(ctx context.Context, key any)) *UInt64Cache_Delete_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(any)) + }) + return _c +} + +func (_c *UInt64Cache_Delete_Call[T]) Return(_a0 error) *UInt64Cache_Delete_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *UInt64Cache_Delete_Call[T]) RunAndReturn(run func(context.Context, any) error) *UInt64Cache_Delete_Call[T] { + _c.Call.Return(run) + return _c +} + +// Get provides a mock function with given fields: ctx, key +func (_m *UInt64Cache[T]) Get(ctx context.Context, key any) (uint64, error) { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 uint64 + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, any) (uint64, error)); ok { + return rf(ctx, key) + } + if rf, ok := ret.Get(0).(func(context.Context, any) uint64); ok { + r0 = rf(ctx, key) + } else { + r0 = ret.Get(0).(uint64) + } + + if rf, ok := ret.Get(1).(func(context.Context, any) error); ok { + r1 = rf(ctx, key) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// UInt64Cache_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type UInt64Cache_Get_Call[T any] struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - key any +func (_e *UInt64Cache_Expecter[T]) Get(ctx interface{}, key interface{}) *UInt64Cache_Get_Call[T] { + return &UInt64Cache_Get_Call[T]{Call: _e.mock.On("Get", ctx, key)} +} + +func (_c *UInt64Cache_Get_Call[T]) Run(run func(ctx context.Context, key any)) *UInt64Cache_Get_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(any)) + }) + return _c +} + +func (_c *UInt64Cache_Get_Call[T]) Return(_a0 uint64, _a1 error) *UInt64Cache_Get_Call[T] { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *UInt64Cache_Get_Call[T]) RunAndReturn(run func(context.Context, any) (uint64, error)) *UInt64Cache_Get_Call[T] { + _c.Call.Return(run) + return _c +} + +// GetType provides a mock function with no fields +func (_m *UInt64Cache[T]) GetType() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetType") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// UInt64Cache_GetType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetType' +type UInt64Cache_GetType_Call[T any] struct { + *mock.Call +} + +// GetType is a helper method to define mock.On call +func (_e *UInt64Cache_Expecter[T]) GetType() *UInt64Cache_GetType_Call[T] { + return &UInt64Cache_GetType_Call[T]{Call: _e.mock.On("GetType")} +} + +func (_c *UInt64Cache_GetType_Call[T]) Run(run func()) *UInt64Cache_GetType_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UInt64Cache_GetType_Call[T]) Return(_a0 string) *UInt64Cache_GetType_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *UInt64Cache_GetType_Call[T]) RunAndReturn(run func() string) *UInt64Cache_GetType_Call[T] { + _c.Call.Return(run) + return _c +} + +// Invalidate provides a mock function with given fields: ctx, options +func (_m *UInt64Cache[T]) Invalidate(ctx context.Context, options ...store.InvalidateOption) error { + _va := make([]interface{}, len(options)) + for _i := range options { + _va[_i] = options[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Invalidate") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, ...store.InvalidateOption) error); ok { + r0 = rf(ctx, options...) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// UInt64Cache_Invalidate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Invalidate' +type UInt64Cache_Invalidate_Call[T any] struct { + *mock.Call +} + +// Invalidate is a helper method to define mock.On call +// - ctx context.Context +// - options ...store.InvalidateOption +func (_e *UInt64Cache_Expecter[T]) Invalidate(ctx interface{}, options ...interface{}) *UInt64Cache_Invalidate_Call[T] { + return &UInt64Cache_Invalidate_Call[T]{Call: _e.mock.On("Invalidate", + append([]interface{}{ctx}, options...)...)} +} + +func (_c *UInt64Cache_Invalidate_Call[T]) Run(run func(ctx context.Context, options ...store.InvalidateOption)) *UInt64Cache_Invalidate_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]store.InvalidateOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(store.InvalidateOption) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *UInt64Cache_Invalidate_Call[T]) Return(_a0 error) *UInt64Cache_Invalidate_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *UInt64Cache_Invalidate_Call[T]) RunAndReturn(run func(context.Context, ...store.InvalidateOption) error) *UInt64Cache_Invalidate_Call[T] { + _c.Call.Return(run) + return _c +} + +// Set provides a mock function with given fields: ctx, key, object, options +func (_m *UInt64Cache[T]) Set(ctx context.Context, key any, object uint64, options ...store.Option) error { + _va := make([]interface{}, len(options)) + for _i := range options { + _va[_i] = options[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, key, object) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Set") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, any, uint64, ...store.Option) error); ok { + r0 = rf(ctx, key, object, options...) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// UInt64Cache_Set_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Set' +type UInt64Cache_Set_Call[T any] struct { + *mock.Call +} + +// Set is a helper method to define mock.On call +// - ctx context.Context +// - key any +// - object uint64 +// - options ...store.Option +func (_e *UInt64Cache_Expecter[T]) Set(ctx interface{}, key interface{}, object interface{}, options ...interface{}) *UInt64Cache_Set_Call[T] { + return &UInt64Cache_Set_Call[T]{Call: _e.mock.On("Set", + append([]interface{}{ctx, key, object}, options...)...)} +} + +func (_c *UInt64Cache_Set_Call[T]) Run(run func(ctx context.Context, key any, object uint64, options ...store.Option)) *UInt64Cache_Set_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]store.Option, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(store.Option) + } + } + run(args[0].(context.Context), args[1].(any), args[2].(uint64), variadicArgs...) + }) + return _c +} + +func (_c *UInt64Cache_Set_Call[T]) Return(_a0 error) *UInt64Cache_Set_Call[T] { + _c.Call.Return(_a0) + return _c +} + +func (_c *UInt64Cache_Set_Call[T]) RunAndReturn(run func(context.Context, any, uint64, ...store.Option) error) *UInt64Cache_Set_Call[T] { + _c.Call.Return(run) + return _c +} + +// NewUInt64Cache creates a new instance of UInt64Cache. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewUInt64Cache[T any](t interface { + mock.TestingT + Cleanup(func()) +}) *UInt64Cache[T] { + mock := &UInt64Cache[T]{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/cache/namespaced.go b/flytestdlib/cache/namespaced.go new file mode 100644 index 0000000000..78f0bffbcb --- /dev/null +++ b/flytestdlib/cache/namespaced.go @@ -0,0 +1,42 @@ +package cache + +import ( + "context" + + "github.com/eko/gocache/lib/v4/cache" + "github.com/eko/gocache/lib/v4/store" +) + +// NamespacedCache is a wrapper around a cache that adds a namespace to all keys +type NamespacedCache[T any] struct { + cache.CacheInterface[T] + namespace string +} + +func (n NamespacedCache[T]) getNamespacedKey(key any) string { + return n.namespace + ":" + key.(string) +} + +func (n NamespacedCache[T]) Get(ctx context.Context, key any) (T, error) { + return n.CacheInterface.Get(ctx, n.getNamespacedKey(key)) +} + +func (n NamespacedCache[T]) Set(ctx context.Context, key any, object T, options ...store.Option) error { + return n.CacheInterface.Set(ctx, n.getNamespacedKey(key), object, options...) +} + +func (n NamespacedCache[T]) Delete(ctx context.Context, key any) error { + return n.CacheInterface.Delete(ctx, n.getNamespacedKey(key)) +} + +func (n NamespacedCache[T]) GetType() string { + return "namespaced" +} + +// NewNamespacedCache creates a new namespaced cache that prefixes any key with the given namespace +func NewNamespacedCache[T any](namespace string, underlying cache.CacheInterface[T]) NamespacedCache[T] { + return NamespacedCache[T]{ + CacheInterface: underlying, + namespace: namespace, + } +} diff --git a/flytestdlib/cache/redis_instrumentation.go b/flytestdlib/cache/redis_instrumentation.go new file mode 100644 index 0000000000..1269ee67bf --- /dev/null +++ b/flytestdlib/cache/redis_instrumentation.go @@ -0,0 +1,62 @@ +package cache + +import ( + "context" + "net" + + "github.com/redis/go-redis/v9" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + flyteMetrics "github.com/flyteorg/flyte/v2/flytestdlib/metrics" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +// A hook that adds metrics around redis operations. +// +// Usage: +// +// redisClient := redis.NewClient(...) +// redisClient.AddHook(NewRedisInstrumentationHook(scope.NewSubScope("redis_client"))) +type RedisInstrumentationHook struct { + operation flyteMetrics.Operation +} + +func (hook RedisInstrumentationHook) DialHook(next redis.DialHook) redis.DialHook { + return func(ctx context.Context, network, addr string) (_ net.Conn, err error) { + defer stopRedisTimer(ctx, hook.operation.Start("dial"), "dial", &err) + return next(ctx, network, addr) + } +} + +func (hook RedisInstrumentationHook) ProcessHook(next redis.ProcessHook) redis.ProcessHook { + return func(ctx context.Context, cmd redis.Cmder) (err error) { + defer stopRedisTimer(ctx, hook.operation.Start(cmd.Name()), cmd.Name(), &err) + return next(ctx, cmd) + } +} + +func (hook RedisInstrumentationHook) ProcessPipelineHook(next redis.ProcessPipelineHook) redis.ProcessPipelineHook { + return func(ctx context.Context, cmds []redis.Cmder) (err error) { + defer stopRedisTimer(ctx, hook.operation.Start("pipeline"), "pipeline", &err) + return next(ctx, cmds) + } +} + +func stopRedisTimer(ctx context.Context, timer flyteMetrics.OperationTimer, command string, err *error) { + realError := *err + if *err == redis.Nil { + realError = nil + } + + if realError != nil { + logger.Errorf(ctx, "redis command %q failed: %v", command, realError) + } + + timer.Stop(&realError) +} + +func NewRedisInstrumentationHook(scope promutils.Scope) *RedisInstrumentationHook { + return &RedisInstrumentationHook{ + operation: flyteMetrics.NewOperationHistogram(scope), + } +} diff --git a/flytestdlib/cache/sync_set.go b/flytestdlib/cache/sync_set.go new file mode 100644 index 0000000000..211b4f10ef --- /dev/null +++ b/flytestdlib/cache/sync_set.go @@ -0,0 +1,40 @@ +package cache + +import "sync" + +var emptyVal = struct{}{} + +// syncSet is a thread-safe Set. +type syncSet struct { + underlying sync.Map +} + +// Contains checks if the key is present in the set. +func (s *syncSet) Contains(key interface{}) bool { + _, found := s.underlying.Load(key) + return found +} + +// Insert adds a new key to the set if it doesn't already exist. +func (s *syncSet) Insert(key interface{}) { + s.underlying.Store(key, emptyVal) +} + +// Remove deletes a key from the set. +func (s *syncSet) Remove(key interface{}) { + s.underlying.Delete(key) +} + +// Range allows iterating over the set. Deleting the key while iterating is a supported operation. +func (s *syncSet) Range(callback func(key interface{}) bool) { + s.underlying.Range(func(key, value interface{}) bool { + return callback(key) + }) +} + +// newSyncSet initializes a new thread-safe set. +func newSyncSet() *syncSet { + return &syncSet{ + underlying: sync.Map{}, + } +} diff --git a/flytestdlib/cache/sync_set_test.go b/flytestdlib/cache/sync_set_test.go new file mode 100644 index 0000000000..5a80138d2c --- /dev/null +++ b/flytestdlib/cache/sync_set_test.go @@ -0,0 +1,49 @@ +package cache + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func rangeAndRemove(tb testing.TB, s *syncSet, count int) { + for i := 0; i < count; i++ { + s.Insert(i) + } + + s.Range(func(key interface{}) bool { + s.Remove(key) + return true + }) + + for i := 0; i < count; i++ { + assert.False(tb, s.Contains(i)) + } +} + +func TestSyncSet_Range(t *testing.T) { + s := newSyncSet() + rangeAndRemove(t, s, 1000) +} + +func BenchmarkSyncSet_Range(b *testing.B) { + s := newSyncSet() + rangeAndRemove(b, s, b.N) +} + +func TestSyncSet_Contains(t *testing.T) { + s := newSyncSet() + count := 1000 + for i := 0; i < count; i++ { + s.Insert(i) + } + + for i := 0; i < count; i++ { + assert.True(t, s.Contains(i)) + s.Remove(i) + } + + for i := 0; i < count; i++ { + assert.False(t, s.Contains(i)) + } +} diff --git a/flytestdlib/cache/type_enumer.go b/flytestdlib/cache/type_enumer.go new file mode 100644 index 0000000000..b56890032e --- /dev/null +++ b/flytestdlib/cache/type_enumer.go @@ -0,0 +1,84 @@ +// Code generated by "enumer --type=Type -json -yaml -trimprefix=Type"; DO NOT EDIT. + +package cache + +import ( + "encoding/json" + "fmt" +) + +const _TypeName = "InMemoryFixedSizeRedis" + +var _TypeIndex = [...]uint8{0, 17, 22} + +func (i Type) String() string { + if i >= Type(len(_TypeIndex)-1) { + return fmt.Sprintf("Type(%d)", i) + } + return _TypeName[_TypeIndex[i]:_TypeIndex[i+1]] +} + +var _TypeValues = []Type{0, 1} + +var _TypeNameToValueMap = map[string]Type{ + _TypeName[0:17]: 0, + _TypeName[17:22]: 1, +} + +// TypeString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func TypeString(s string) (Type, error) { + if val, ok := _TypeNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to Type values", s) +} + +// TypeValues returns all values of the enum +func TypeValues() []Type { + return _TypeValues +} + +// IsAType returns "true" if the value is listed in the enum definition. "false" otherwise +func (i Type) IsAType() bool { + for _, v := range _TypeValues { + if i == v { + return true + } + } + return false +} + +// MarshalJSON implements the json.Marshaler interface for Type +func (i Type) MarshalJSON() ([]byte, error) { + return json.Marshal(i.String()) +} + +// UnmarshalJSON implements the json.Unmarshaler interface for Type +func (i *Type) UnmarshalJSON(data []byte) error { + var s string + if err := json.Unmarshal(data, &s); err != nil { + return fmt.Errorf("Type should be a string, got %s", data) + } + + var err error + *i, err = TypeString(s) + return err +} + +// MarshalYAML implements a YAML Marshaler for Type +func (i Type) MarshalYAML() (interface{}, error) { + return i.String(), nil +} + +// UnmarshalYAML implements a YAML Unmarshaler for Type +func (i *Type) UnmarshalYAML(unmarshal func(interface{}) error) error { + var s string + if err := unmarshal(&s); err != nil { + return err + } + + var err error + *i, err = TypeString(s) + return err +} diff --git a/flytestdlib/cache/typed_marshaler.go b/flytestdlib/cache/typed_marshaler.go new file mode 100644 index 0000000000..6fe95bbf90 --- /dev/null +++ b/flytestdlib/cache/typed_marshaler.go @@ -0,0 +1,55 @@ +package cache + +import ( + "context" + "reflect" + + "github.com/eko/gocache/lib/v4/store" +) + +// TypedMarshaler is the struct that handles typed marshaling and unmarshaling +type TypedMarshaler[T any] struct { + *Marshaler + isPointerType bool + elemType reflect.Type +} + +func (t *TypedMarshaler[T]) Set(ctx context.Context, key any, object T, options ...store.Option) error { + return t.Marshaler.Set(ctx, key, object, options...) +} + +func (t *TypedMarshaler[T]) Get(ctx context.Context, key any) (T, error) { + if t.isPointerType { + justT := reflect.New(t.elemType).Interface().(T) + obj, err := t.Marshaler.Get(ctx, key, justT) + if err != nil { + return *new(T), err + } + + return obj.(T), nil + } + + obj, err := t.Marshaler.Get(ctx, key, new(T)) + if err != nil { + return *new(T), err + } + + return *(obj.(*T)), nil +} + +// NewTypedMarshaler creates a new typed marshaler. It takes a marshaler and a type T. +// It returns a typed marshaler that can be used to marshal and unmarshal values of type T. +// If T is a pointer type, it will unmarshal into a new instance of T. Otherwise, it will unmarshal into a new instance of *T. +func NewTypedMarshaler[T any](marshaler *Marshaler) *TypedMarshaler[T] { + isPointerType := reflect.TypeOf(new(T)).Elem().Kind() == reflect.Ptr + var elemType reflect.Type + if isPointerType { + elemType = reflect.TypeOf(new(T)).Elem().Elem() + } + + return &TypedMarshaler[T]{ + Marshaler: marshaler, + isPointerType: isPointerType, + elemType: elemType, + } +} diff --git a/flytestdlib/config/accessor.go b/flytestdlib/config/accessor.go new file mode 100644 index 0000000000..1b5a693316 --- /dev/null +++ b/flytestdlib/config/accessor.go @@ -0,0 +1,61 @@ +// A strongly-typed config library to parse configs from PFlags, Env Vars and Config files. +// Config package enables consumers to access (readonly for now) strongly typed configs without worrying about mismatching +// keys or casting to the wrong type. It supports basic types (e.g. int, string) as well as more complex structures through +// json encoding/decoding. +// +// Config package introduces the concept of Sections. Each section should be given a unique section key. The binary will +// not load if there is a conflict. Each section should be represented as a Go struct and registered at startup before +// config is loaded/parsed. +// +// Sections can be nested too. A new config section can be registered as a sub-section of an existing one. This allows +// dynamic grouping of sections while continuing to enforce strong-typed parsing of configs. +// +// Config data can be parsed from supported config file(s) (yaml, prop, toml), env vars, PFlags or a combination of these +// Precedence is (flags, env vars, config file, defaults). When data is read from config files, a file watcher is started +// to monitor for changes in those files. If the registrant of a section subscribes to changes then a handler is called +// when the relevant section has been updated. Sections within a single config file will be invoked after all sections +// from that particular config file are parsed. It follows that if there are inter-dependent sections (e.g. changing one +// MUST be followed by a change in another), then make sure those sections are placed in the same config file. +// +// A convenience tool is also provided in cli package (pflags) that generates an implementation for PFlagProvider interface +// based on json names of the fields. +package config + +import ( + "context" + "flag" + + "github.com/spf13/pflag" +) + +// Provides a simple config parser interface. +type Accessor interface { + // Gets a friendly identifier for the accessor. + ID() string + + // Initializes the config parser with golang's default flagset. + InitializeFlags(cmdFlags *flag.FlagSet) + + // Initializes the config parser with pflag's flagset. + InitializePflags(cmdFlags *pflag.FlagSet) + + // Parses and validates config file(s) discovered then updates the underlying config section with the results. + // Exercise caution when calling this because multiple invocations will overwrite each other's results. + UpdateConfig(ctx context.Context) error + + // Gets path(s) to the config file(s) used. + ConfigFilesUsed() []string +} + +// Options used to initialize a Config Accessor +type Options struct { + // Instructs parser to fail if any section/key in the config file read do not have a corresponding registered section. + StrictMode bool + + // Search paths to look for config file(s). If not specified, it searches for config.yaml under current directory as well + // as /etc/flyte/config directories. + SearchPaths []string + + // Defines the root section to use with the accessor. + RootSection Section +} diff --git a/flytestdlib/config/accessor_test.go b/flytestdlib/config/accessor_test.go new file mode 100644 index 0000000000..f386b30b9c --- /dev/null +++ b/flytestdlib/config/accessor_test.go @@ -0,0 +1,91 @@ +package config + +import ( + "context" + "fmt" + "path/filepath" +) + +func Example() { + // This example demonstrates basic usage of config sections. + + //go:generate pflags OtherComponentConfig + + type OtherComponentConfig struct { + DurationValue Duration `json:"duration-value"` + URLValue URL `json:"url-value"` + StringValue string `json:"string-value"` + } + + // Each component should register their section in package init() or as a package var + section := MustRegisterSection("other-component", &OtherComponentConfig{}) + + // Override configpath to look for a custom location. + configPath := filepath.Join("testdata", "config.yaml") + + // Initialize an accessor. + var accessor Accessor + // e.g. + // accessor = viper.NewAccessor(viper.Options{ + // StrictMode: true, + // SearchPaths: []string{configPath, configPath2}, + // }) + + // Optionally bind to Pflags. + // accessor.InitializePflags(flags) + + // Parse config from file or pass empty to rely on env variables and PFlags + err := accessor.UpdateConfig(context.Background()) + if err != nil { + fmt.Printf("Failed to validate config from [%v], error: %v", configPath, err) + return + } + + // Get parsed config value. + parsedConfig := section.GetConfig().(*OtherComponentConfig) + fmt.Printf("Config: %v", parsedConfig) +} + +func Example_nested() { + // This example demonstrates registering nested config sections dynamically. + + //go:generate pflags OtherComponentConfig + + type OtherComponentConfig struct { + DurationValue Duration `json:"duration-value"` + URLValue URL `json:"url-value"` + StringValue string `json:"string-value"` + } + + // Each component should register their section in package init() or as a package var + Section := MustRegisterSection("my-component", &MyComponentConfig{}) + + // Other packages can register their sections at the root level (like the above line) or as nested sections of other + // sections (like the below line) + NestedSection := Section.MustRegisterSection("nested", &OtherComponentConfig{}) + + // Override configpath to look for a custom location. + configPath := filepath.Join("testdata", "nested_config.yaml") + + // Initialize an accessor. + var accessor Accessor + // e.g. + // accessor = viper.NewAccessor(viper.Options{ + // StrictMode: true, + // SearchPaths: []string{configPath, configPath2}, + // }) + + // Optionally bind to Pflags. + // accessor.InitializePflags(flags) + + // Parse config from file or pass empty to rely on env variables and PFlags + err := accessor.UpdateConfig(context.Background()) + if err != nil { + fmt.Printf("Failed to validate config from [%v], error: %v", configPath, err) + return + } + + // Get parsed config value. + parsedConfig := NestedSection.GetConfig().(*OtherComponentConfig) + fmt.Printf("Config: %v", parsedConfig) +} diff --git a/flytestdlib/config/clouddeployment_enumer.go b/flytestdlib/config/clouddeployment_enumer.go new file mode 100644 index 0000000000..b4ee421c47 --- /dev/null +++ b/flytestdlib/config/clouddeployment_enumer.go @@ -0,0 +1,87 @@ +// Code generated by "enumer --type=CloudDeployment -json -yaml -trimprefix=CloudDeployment"; DO NOT EDIT. + +package config + +import ( + "encoding/json" + "fmt" +) + +const _CloudDeploymentName = "NoneAWSGCPSandboxLocal" + +var _CloudDeploymentIndex = [...]uint8{0, 4, 7, 10, 17, 22} + +func (i CloudDeployment) String() string { + if i >= CloudDeployment(len(_CloudDeploymentIndex)-1) { + return fmt.Sprintf("CloudDeployment(%d)", i) + } + return _CloudDeploymentName[_CloudDeploymentIndex[i]:_CloudDeploymentIndex[i+1]] +} + +var _CloudDeploymentValues = []CloudDeployment{0, 1, 2, 3, 4} + +var _CloudDeploymentNameToValueMap = map[string]CloudDeployment{ + _CloudDeploymentName[0:4]: 0, + _CloudDeploymentName[4:7]: 1, + _CloudDeploymentName[7:10]: 2, + _CloudDeploymentName[10:17]: 3, + _CloudDeploymentName[17:22]: 4, +} + +// CloudDeploymentString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func CloudDeploymentString(s string) (CloudDeployment, error) { + if val, ok := _CloudDeploymentNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to CloudDeployment values", s) +} + +// CloudDeploymentValues returns all values of the enum +func CloudDeploymentValues() []CloudDeployment { + return _CloudDeploymentValues +} + +// IsACloudDeployment returns "true" if the value is listed in the enum definition. "false" otherwise +func (i CloudDeployment) IsACloudDeployment() bool { + for _, v := range _CloudDeploymentValues { + if i == v { + return true + } + } + return false +} + +// MarshalJSON implements the json.Marshaler interface for CloudDeployment +func (i CloudDeployment) MarshalJSON() ([]byte, error) { + return json.Marshal(i.String()) +} + +// UnmarshalJSON implements the json.Unmarshaler interface for CloudDeployment +func (i *CloudDeployment) UnmarshalJSON(data []byte) error { + var s string + if err := json.Unmarshal(data, &s); err != nil { + return fmt.Errorf("CloudDeployment should be a string, got %s", data) + } + + var err error + *i, err = CloudDeploymentString(s) + return err +} + +// MarshalYAML implements a YAML Marshaler for CloudDeployment +func (i CloudDeployment) MarshalYAML() (interface{}, error) { + return i.String(), nil +} + +// UnmarshalYAML implements a YAML Unmarshaler for CloudDeployment +func (i *CloudDeployment) UnmarshalYAML(unmarshal func(interface{}) error) error { + var s string + if err := unmarshal(&s); err != nil { + return err + } + + var err error + *i, err = CloudDeploymentString(s) + return err +} diff --git a/flytestdlib/config/config_cmd.go b/flytestdlib/config/config_cmd.go new file mode 100644 index 0000000000..ea72aaebbf --- /dev/null +++ b/flytestdlib/config/config_cmd.go @@ -0,0 +1,325 @@ +package config + +import ( + "context" + "fmt" + "os" + "reflect" + "strings" + "unsafe" + + "github.com/fatih/color" + "github.com/ghodss/yaml" + "github.com/spf13/cobra" + "k8s.io/apimachinery/pkg/util/sets" +) + +const ( + PathFlag = "file" + StrictModeFlag = "strict" + CommandValidate = "validate" + CommandDiscover = "discover" + CommandDocs = "docs" + DocsSectionLength = 120 +) + +type AccessorProvider func(options Options) Accessor + +type printer interface { + Printf(format string, i ...interface{}) + Println(i ...interface{}) +} + +func NewConfigCommand(accessorProvider AccessorProvider) *cobra.Command { + opts := Options{} + rootCmd := &cobra.Command{ + Use: "config", + Short: "Runs various config commands, look at the help of this command to get a list of available commands..", + ValidArgs: []string{CommandValidate, CommandDiscover, CommandDocs}, + } + + validateCmd := &cobra.Command{ + Use: "validate", + Short: "Validates the loaded config.", + RunE: func(cmd *cobra.Command, args []string) error { + return validate(accessorProvider(opts), cmd) + }, + } + + discoverCmd := &cobra.Command{ + Use: "discover", + Short: "Searches for a config in one of the default search paths.", + RunE: func(cmd *cobra.Command, args []string) error { + return validate(accessorProvider(opts), cmd) + }, + } + + docsCmd := &cobra.Command{ + Use: "docs", + Short: "Generate configuration documentation in rst format", + RunE: func(cmd *cobra.Command, args []string) error { + sections := GetRootSection().GetSections() + orderedSectionKeys := sets.NewString() + for s := range sections { + orderedSectionKeys.Insert(s) + } + printToc(orderedSectionKeys) + visitedSection := map[string]bool{} + visitedType := map[reflect.Type]bool{} + for _, sectionKey := range orderedSectionKeys.List() { + if canPrint(sections[sectionKey].GetConfig()) { + printDocs(sectionKey, false, sections[sectionKey], visitedSection, visitedType) + } + } + return nil + }, + } + + // Configure Root Command + rootCmd.PersistentFlags().StringArrayVar(&opts.SearchPaths, PathFlag, []string{}, `Passes the config file to load. +If empty, it'll first search for the config file path then, if found, will load config from there.`) + + rootCmd.AddCommand(validateCmd) + rootCmd.AddCommand(discoverCmd) + rootCmd.AddCommand(docsCmd) + + // Configure Validate Command + validateCmd.Flags().BoolVar(&opts.StrictMode, StrictModeFlag, false, `Validates that all keys in loaded config +map to already registered sections.`) + + return rootCmd +} + +// Redirects Stdout to a string buffer until context is cancelled. +func redirectStdOut() (old, new *os.File) { + old = os.Stdout // keep backup of the real stdout + var err error + _, new, err = os.Pipe() + if err != nil { + panic(err) + } + + os.Stdout = new + + return +} + +func printDocs(title string, isSubsection bool, section Section, visitedSection map[string]bool, visitedType map[reflect.Type]bool) { + printTitle(title, isSubsection) + val := reflect.Indirect(reflect.ValueOf(section.GetConfig())) + if val.Kind() == reflect.Slice { + val = reflect.Indirect(reflect.ValueOf(val.Index(0).Interface())) + } + + subsections := make(map[string]interface{}) + for i := 0; i < val.Type().NumField(); i++ { + field := val.Type().Field(i) + tagType := field.Type + if tagType.Kind() == reflect.Ptr { + tagType = field.Type.Elem() + } + + fieldName := getFieldNameFromJSONTag(field) + fieldTypeString := getFieldTypeString(tagType) + fieldDefaultValue := getDefaultValue(fmt.Sprintf("%v", reflect.Indirect(val.Field(i)))) + fieldDescription := getFieldDescriptionFromPflag(field) + + subVal := val.Field(i) + if tagType.Kind() == reflect.Struct { + // In order to get value from unexported field in struct + if subVal.Kind() == reflect.Ptr { + subVal = reflect.NewAt(subVal.Type(), unsafe.Pointer(subVal.UnsafeAddr())).Elem() + } else { + subVal = reflect.NewAt(subVal.Type(), unsafe.Pointer(subVal.UnsafeAddr())) + } + } + + if tagType.Kind() == reflect.Map || tagType.Kind() == reflect.Slice || tagType.Kind() == reflect.Struct { + fieldDefaultValue = getDefaultValue(subVal.Interface()) + } + + if tagType.Kind() == reflect.Struct { + if canPrint(subVal.Interface()) { + addSubsection(subVal.Interface(), subsections, fieldName, &fieldTypeString, tagType, visitedSection, visitedType) + } + } + printSection(fieldName, fieldTypeString, fieldDefaultValue, fieldDescription, isSubsection) + } + + if section != nil { + sections := section.GetSections() + orderedSectionKeys := sets.NewString() + for s := range sections { + orderedSectionKeys.Insert(s) + } + for _, sectionKey := range orderedSectionKeys.List() { + fieldName := sectionKey + fieldType := reflect.TypeOf(sections[sectionKey].GetConfig()) + fieldTypeString := getFieldTypeString(fieldType) + fieldDefaultValue := getDefaultValue(sections[sectionKey].GetConfig()) + + addSubsection(sections[sectionKey].GetConfig(), subsections, fieldName, &fieldTypeString, fieldType, visitedSection, visitedType) + printSection(fieldName, fieldTypeString, fieldDefaultValue, "", isSubsection) + } + } + orderedSectionKeys := sets.NewString() + for s := range subsections { + orderedSectionKeys.Insert(s) + } + + for _, sectionKey := range orderedSectionKeys.List() { + printDocs(sectionKey, true, NewSection(subsections[sectionKey], nil), visitedSection, visitedType) + } +} + +// Print Table of contents +func printToc(orderedSectionKeys sets.String) { + for _, sectionKey := range orderedSectionKeys.List() { + fmt.Printf("- `%s <#section-%s>`_\n\n", sectionKey, sectionKey) + } +} + +func printTitle(title string, isSubsection bool) { + if isSubsection { + fmt.Println(title) + fmt.Println(strings.Repeat("^", DocsSectionLength)) + } else { + fmt.Println("Section:", title) + fmt.Println(strings.Repeat("=", DocsSectionLength)) + } + fmt.Println() +} + +func printSection(name string, dataType string, defaultValue string, description string, isSubsection bool) { + c := "-" + if isSubsection { + c = "\"" + } + + fmt.Printf("%s ", name) + fmt.Printf("(%s)\n", dataType) + fmt.Println(strings.Repeat(c, DocsSectionLength)) + fmt.Println() + if description != "" { + fmt.Printf("%s\n\n", description) + } + if defaultValue != "" { + val := strings.ReplaceAll(defaultValue, "\n", "\n ") + val = ".. code-block:: yaml\n\n " + val + fmt.Printf("**Default Value**: \n\n%s\n", val) + } + fmt.Println() +} + +func addSubsection(val interface{}, subsections map[string]interface{}, fieldName string, + fieldTypeString *string, fieldType reflect.Type, visitedSection map[string]bool, visitedType map[reflect.Type]bool) { + + if visitedSection[*fieldTypeString] { + if !visitedType[fieldType] { + // Some types have the same name, but they are different type. + // Add field name at the end to tell the difference between them. + *fieldTypeString = fmt.Sprintf("%s (%s)", *fieldTypeString, fieldName) + subsections[*fieldTypeString] = val + } + } else { + visitedSection[*fieldTypeString] = true + subsections[*fieldTypeString] = val + } + *fieldTypeString = fmt.Sprintf("`%s`_", *fieldTypeString) + visitedType[fieldType] = true +} + +func getDefaultValue(val interface{}) string { + defaultValue, err := yaml.Marshal(val) + if err != nil { + return "" + } + DefaultValue := string(defaultValue) + return DefaultValue +} + +func getFieldTypeString(tagType reflect.Type) string { + kind := tagType.Kind() + if kind == reflect.Ptr { + tagType = tagType.Elem() + kind = tagType.Kind() + } + + FieldTypeString := kind.String() + if kind == reflect.Map || kind == reflect.Slice || kind == reflect.Struct { + FieldTypeString = tagType.String() + } + return FieldTypeString +} + +func getFieldDescriptionFromPflag(field reflect.StructField) string { + if pFlag := field.Tag.Get("pflag"); len(pFlag) > 0 && !strings.HasPrefix(pFlag, "-") { + var commaIdx int + if commaIdx = strings.Index(pFlag, ","); commaIdx < 0 { + commaIdx = -1 + } + if strippedDescription := pFlag[commaIdx+1:]; len(strippedDescription) > 0 { + return strings.TrimPrefix(strippedDescription, " ") + } + } + return "" +} + +func getFieldNameFromJSONTag(field reflect.StructField) string { + if jsonTag := field.Tag.Get("json"); len(jsonTag) > 0 && !strings.HasPrefix(jsonTag, "-") { + var commaIdx int + if commaIdx = strings.Index(jsonTag, ","); commaIdx < 0 { + commaIdx = len(jsonTag) + } + if strippedName := jsonTag[:commaIdx]; len(strippedName) > 0 { + return strippedName + } + } + return field.Name +} + +// Print out config docs if and only if the section type is struct or slice +func canPrint(b interface{}) bool { + val := reflect.Indirect(reflect.ValueOf(b)) + if val.Kind() == reflect.Struct || val.Kind() == reflect.Slice { + return true + } + return false +} + +func validate(accessor Accessor, p printer) error { + // Redirect stdout + old, n := redirectStdOut() + defer func() { + err := n.Close() + if err != nil { + panic(err) + } + }() + defer func() { os.Stdout = old }() + + err := accessor.UpdateConfig(context.Background()) + + printInfo(p, accessor) + if err == nil { + green := color.New(color.FgGreen).SprintFunc() + p.Println(green("Validated config file successfully.")) + } else { + red := color.New(color.FgRed).SprintFunc() + p.Println(red("Failed to validate config file.")) + } + + return err +} + +func printInfo(p printer, v Accessor) { + cfgFile := v.ConfigFilesUsed() + if len(cfgFile) != 0 { + green := color.New(color.FgGreen).SprintFunc() + + p.Printf("Config file(s) found at: %v\n", green(strings.Join(cfgFile, "\n"))) + } else { + red := color.New(color.FgRed).SprintFunc() + p.Println(red("Couldn't find a config file.")) + } +} diff --git a/flytestdlib/config/config_cmd_test.go b/flytestdlib/config/config_cmd_test.go new file mode 100644 index 0000000000..0974ca3666 --- /dev/null +++ b/flytestdlib/config/config_cmd_test.go @@ -0,0 +1,123 @@ +package config + +import ( + "bytes" + "context" + "flag" + "reflect" + "testing" + + "github.com/spf13/cobra" + "github.com/spf13/pflag" + "github.com/stretchr/testify/assert" +) + +var redisConfig = "mockRedis" +var resourceManagerConfig = ResourceManagerConfig{"mockType", 100, &redisConfig, + []int{1, 2, 3}, InnerConfig{"hello"}, &InnerConfig{"world"}} + +type MockAccessor struct { +} + +func (MockAccessor) ID() string { + panic("implement me") +} + +func (MockAccessor) InitializeFlags(cmdFlags *flag.FlagSet) { +} + +func (MockAccessor) InitializePflags(cmdFlags *pflag.FlagSet) { +} + +func (MockAccessor) UpdateConfig(ctx context.Context) error { + return nil +} + +func (MockAccessor) ConfigFilesUsed() []string { + return []string{"test"} +} + +func (MockAccessor) RefreshFromConfig() error { + return nil +} + +func newMockAccessor(options Options) Accessor { + return MockAccessor{} +} + +func executeCommandC(root *cobra.Command, args ...string) (output string, err error) { + buf := new(bytes.Buffer) + root.SetOut(buf) + root.SetArgs(args) + + _, err = root.ExecuteC() + + return buf.String(), err +} + +func TestNewConfigCommand(t *testing.T) { + cmd := NewConfigCommand(newMockAccessor) + assert.NotNil(t, cmd) + + output, err := executeCommandC(cmd, CommandDiscover) + assert.NoError(t, err) + assert.Contains(t, output, "test") + + output, err = executeCommandC(cmd, CommandValidate) + assert.NoError(t, err) + assert.Contains(t, output, "test") + + section, err := GetRootSection().RegisterSection("root", &resourceManagerConfig) + assert.NoError(t, err) + section.MustRegisterSection("subsection", &resourceManagerConfig) + _, err = executeCommandC(cmd, CommandDocs) + assert.NoError(t, err) +} + +type InnerConfig struct { + InnerType string `json:"type" pflag:"noop,Which resource manager to use"` +} + +type ResourceManagerConfig struct { + Type string `json:"type" pflag:"noop,Which resource manager to use"` + ResourceMaxQuota int `json:"resourceMaxQuota" pflag:",Global limit for concurrent Qubole queries"` + RedisConfig *string `json:"" pflag:",Config for Redis resource manager."` + ListConfig []int `json:"" pflag:","` + InnerConfig InnerConfig + InnerConfig1 *InnerConfig +} + +func TestGetDefaultValue(t *testing.T) { + val := getDefaultValue(resourceManagerConfig) + res := "InnerConfig:\n type: hello\nInnerConfig1:\n type: world\nListConfig:\n- 1\n- 2\n- 3\nRedisConfig: mockRedis\nresourceMaxQuota: 100\ntype: mockType\n" + assert.Equal(t, res, val) +} + +func TestGetFieldTypeString(t *testing.T) { + val := reflect.ValueOf(resourceManagerConfig) + assert.Equal(t, "config.ResourceManagerConfig", getFieldTypeString(val.Type())) + assert.Equal(t, "string", getFieldTypeString(val.Field(0).Type())) + assert.Equal(t, "int", getFieldTypeString(val.Field(1).Type())) + assert.Equal(t, "string", getFieldTypeString(val.Field(2).Type())) +} + +func TestGetFieldDescriptionFromPflag(t *testing.T) { + val := reflect.ValueOf(resourceManagerConfig) + assert.Equal(t, "Which resource manager to use", getFieldDescriptionFromPflag(val.Type().Field(0))) + assert.Equal(t, "Global limit for concurrent Qubole queries", getFieldDescriptionFromPflag(val.Type().Field(1))) + assert.Equal(t, "Config for Redis resource manager.", getFieldDescriptionFromPflag(val.Type().Field(2))) +} + +func TestGetFieldNameFromJSONTag(t *testing.T) { + val := reflect.ValueOf(resourceManagerConfig) + assert.Equal(t, "type", getFieldNameFromJSONTag(val.Type().Field(0))) + assert.Equal(t, "resourceMaxQuota", getFieldNameFromJSONTag(val.Type().Field(1))) + assert.Equal(t, "RedisConfig", getFieldNameFromJSONTag(val.Type().Field(2))) +} + +func TestCanPrint(t *testing.T) { + assert.True(t, canPrint(resourceManagerConfig)) + assert.True(t, canPrint(&resourceManagerConfig)) + assert.True(t, canPrint([]ResourceManagerConfig{resourceManagerConfig})) + assert.False(t, canPrint(map[string]ResourceManagerConfig{"config": resourceManagerConfig})) +} diff --git a/flytestdlib/config/constants.go b/flytestdlib/config/constants.go new file mode 100644 index 0000000000..cf499ac23c --- /dev/null +++ b/flytestdlib/config/constants.go @@ -0,0 +1,12 @@ +package config + +//go:generate enumer --type=CloudDeployment -json -yaml -trimprefix=CloudDeployment +type CloudDeployment uint8 + +const ( + CloudDeploymentNone CloudDeployment = iota + CloudDeploymentAWS + CloudDeploymentGCP + CloudDeploymentSandbox + CloudDeploymentLocal +) diff --git a/flytestdlib/config/duration.go b/flytestdlib/config/duration.go new file mode 100644 index 0000000000..a86d61bbae --- /dev/null +++ b/flytestdlib/config/duration.go @@ -0,0 +1,59 @@ +package config + +import ( + "encoding/json" + "errors" + "time" +) + +// Duration is a wrapper around time.Duration that enables Json Marshalling capabilities +type Duration struct { + time.Duration +} + +func (d Duration) MarshalJSON() ([]byte, error) { + return json.Marshal(d.String()) +} + +func (d *Duration) UnmarshalJSON(b []byte) error { + if len(b) == 0 { + d.Duration = time.Duration(0) + return nil + } + + var v interface{} + if err := json.Unmarshal(b, &v); err != nil { + return err + } + switch value := v.(type) { + case float64: + d.Duration = time.Duration(value) + return nil + case string: + if len(value) == 0 { + d.Duration = time.Duration(0) + } else { + var err error + d.Duration, err = time.ParseDuration(value) + if err != nil { + return err + } + } + default: + return errors.New("invalid duration") + } + + return nil +} + +// Set implements PFlag's Value interface's set method to set the value of duration from string. +func (d *Duration) Set(val string) error { + var err error + d.Duration, err = time.ParseDuration(val) + return err +} + +// Type implements PFlag's Value interface's Type method to return the name of the type. +func (Duration) Type() string { + return "Duration" +} diff --git a/flytestdlib/config/duration_test.go b/flytestdlib/config/duration_test.go new file mode 100644 index 0000000000..8e411987ac --- /dev/null +++ b/flytestdlib/config/duration_test.go @@ -0,0 +1,66 @@ +package config + +import ( + "encoding/json" + "reflect" + "testing" + "time" + + "github.com/stretchr/testify/assert" +) + +func TestDuration_MarshalJSON(t *testing.T) { + t.Run("Valid", func(t *testing.T) { + expected := Duration{ + Duration: time.Second * 2, + } + + b, err := expected.MarshalJSON() + assert.NoError(t, err) + + actual := Duration{} + err = actual.UnmarshalJSON(b) + assert.NoError(t, err) + + assert.True(t, reflect.DeepEqual(expected, actual)) + }) +} + +func TestDuration_UnmarshalJSON(t *testing.T) { + t.Run("Empty", func(t *testing.T) { + actual := Duration{} + err := actual.UnmarshalJSON([]byte{}) + assert.NoError(t, err) + assert.Equal(t, time.Duration(0), actual.Duration) + }) + + t.Run("Invalid_string", func(t *testing.T) { + input := "blah" + raw, err := json.Marshal(input) + assert.NoError(t, err) + + actual := Duration{} + err = actual.UnmarshalJSON(raw) + assert.Error(t, err) + }) + + t.Run("Valid_float", func(t *testing.T) { + input := float64(12345) + raw, err := json.Marshal(input) + assert.NoError(t, err) + + actual := Duration{} + err = actual.UnmarshalJSON(raw) + assert.NoError(t, err) + }) + + t.Run("Invalid_bool", func(t *testing.T) { + input := true + raw, err := json.Marshal(input) + assert.NoError(t, err) + + actual := Duration{} + err = actual.UnmarshalJSON(raw) + assert.Error(t, err) + }) +} diff --git a/flytestdlib/config/errors.go b/flytestdlib/config/errors.go new file mode 100644 index 0000000000..1db207b8c1 --- /dev/null +++ b/flytestdlib/config/errors.go @@ -0,0 +1,8 @@ +package config + +import "fmt" + +var ( + ErrStrictModeValidation = fmt.Errorf("failed strict mode check") + ErrChildConfigOverridesConfig = fmt.Errorf("child config attempts to override an existing native config property") +) diff --git a/flytestdlib/config/files/finder.go b/flytestdlib/config/files/finder.go new file mode 100644 index 0000000000..e389d88306 --- /dev/null +++ b/flytestdlib/config/files/finder.go @@ -0,0 +1,83 @@ +package files + +import ( + "os" + "path/filepath" +) + +const ( + configFileType = "yaml" + configFileName = "config" +) + +var configLocations = [][]string{ + {"."}, + {"/etc", "flyte", "config"}, + {os.ExpandEnv("$GOPATH"), "src", "github.com", "lyft", "flytestdlib"}, +} + +// Check if File / Directory Exists +func exists(path string) (bool, error) { + _, err := os.Stat(path) + if err == nil { + return true, nil + } + + if os.IsNotExist(err) { + return false, nil + } + + return false, err +} + +func isFile(path string) (bool, error) { + s, err := os.Stat(path) + if err != nil { + return false, err + } + + return !s.IsDir(), nil +} + +func contains(slice []string, value string) bool { + for _, s := range slice { + if s == value { + return true + } + } + + return false +} + +// Finds config files in search paths. If searchPaths is empty, it'll look in default locations (see configLocations above) +// If searchPaths is not empty but no configs are found there, it'll still look into configLocations. +// If it found any config file in searchPaths, it'll stop the search. +// searchPaths can contain patterns to match (behavior is OS-dependent). And it'll try to Glob the pattern for any matching +// files. +func FindConfigFiles(searchPaths []string) []string { + res := make([]string, 0, 1) + + for _, location := range searchPaths { + matchedFiles, err := filepath.Glob(location) + if err != nil { + continue + } + + for _, matchedFile := range matchedFiles { + if file, err := isFile(matchedFile); err == nil && file && !contains(res, matchedFile) { + res = append(res, matchedFile) + } + } + } + + if len(res) == 0 { + for _, location := range configLocations { + pathToTest := filepath.Join(append(location, configFileName+"."+configFileType)...) + if b, err := exists(pathToTest); err == nil && b && !contains(res, pathToTest) { + res = append(res, pathToTest) + } + } + } + + return res +} diff --git a/flytestdlib/config/files/finder_test.go b/flytestdlib/config/files/finder_test.go new file mode 100644 index 0000000000..833ac461f1 --- /dev/null +++ b/flytestdlib/config/files/finder_test.go @@ -0,0 +1,28 @@ +package files + +import ( + "path/filepath" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestFindConfigFiles(t *testing.T) { + t.Run("Find config-* group", func(t *testing.T) { + files := FindConfigFiles([]string{filepath.Join("testdata", "config*.yaml")}) + assert.Equal(t, 2, len(files)) + }) + + t.Run("Find other-group-* group", func(t *testing.T) { + files := FindConfigFiles([]string{filepath.Join("testdata", "other-group*.yaml")}) + assert.Equal(t, 2, len(files)) + }) + + t.Run("Absolute path", func(t *testing.T) { + files := FindConfigFiles([]string{filepath.Join("testdata", "other-group-1.yaml")}) + assert.Equal(t, 1, len(files)) + + files = FindConfigFiles([]string{filepath.Join("testdata", "other-group-3.yaml")}) + assert.Equal(t, 0, len(files)) + }) +} diff --git a/flytestdlib/config/files/testdata/config-1.yaml b/flytestdlib/config/files/testdata/config-1.yaml new file mode 100644 index 0000000000..a5b6191d98 --- /dev/null +++ b/flytestdlib/config/files/testdata/config-1.yaml @@ -0,0 +1,9 @@ +other-component: + duration-value: 20s + int-val: 4 + string-value: Hey there! + strings: + - hello + - world + - '!' + url-value: http://something.com diff --git a/flytestdlib/config/files/testdata/config-2.yaml b/flytestdlib/config/files/testdata/config-2.yaml new file mode 100755 index 0000000000..5c28d00a09 --- /dev/null +++ b/flytestdlib/config/files/testdata/config-2.yaml @@ -0,0 +1,2 @@ +my-component: + str: Hello World diff --git a/flytestdlib/config/files/testdata/other-group-1.yaml b/flytestdlib/config/files/testdata/other-group-1.yaml new file mode 100644 index 0000000000..a5b6191d98 --- /dev/null +++ b/flytestdlib/config/files/testdata/other-group-1.yaml @@ -0,0 +1,9 @@ +other-component: + duration-value: 20s + int-val: 4 + string-value: Hey there! + strings: + - hello + - world + - '!' + url-value: http://something.com diff --git a/flytestdlib/config/files/testdata/other-group-2.yaml b/flytestdlib/config/files/testdata/other-group-2.yaml new file mode 100755 index 0000000000..5c28d00a09 --- /dev/null +++ b/flytestdlib/config/files/testdata/other-group-2.yaml @@ -0,0 +1,2 @@ +my-component: + str: Hello World diff --git a/flytestdlib/config/port.go b/flytestdlib/config/port.go new file mode 100644 index 0000000000..381a5e9a5e --- /dev/null +++ b/flytestdlib/config/port.go @@ -0,0 +1,76 @@ +package config + +import ( + "encoding/json" + "errors" + "fmt" + "strconv" +) + +// A common port struct that supports Json marshal/unmarshal into/from simple strings/floats. +type Port struct { + Port int `json:"port,omitempty"` +} + +func (p Port) String() string { + return strconv.Itoa(p.Port) +} + +func (p Port) MarshalJSON() ([]byte, error) { + return json.Marshal(p.Port) +} + +func (p *Port) UnmarshalJSON(b []byte) error { + var v interface{} + if err := json.Unmarshal(b, &v); err != nil { + return err + } + + switch value := v.(type) { + case string: + u, err := parsePortString(value) + if err != nil { + return err + } + + p.Port = u + return nil + case float64: + if !validPortRange(value) { + return fmt.Errorf("port must be a valid number between 0 and 65535, inclusive") + } + + p.Port = int(value) + return nil + default: + return errors.New("invalid port") + } +} + +func parsePortString(port string) (int, error) { + if portInt, err := strconv.Atoi(port); err == nil && validPortRange(float64(portInt)) { + return portInt, nil + } + + return 0, fmt.Errorf("port must be a valid number between 1 and 65535, inclusive") +} + +func validPortRange(port float64) bool { + return 0 <= port && port <= 65535 +} + +// Set implements PFlag's Value interface's set method to set the value of duration from string. +func (p *Port) Set(val string) error { + u, err := parsePortString(val) + if err != nil { + return err + } + + p.Port = u + return nil +} + +// Type implements PFlag's Value interface's Type method to return the name of the type. +func (Port) Type() string { + return "URL" +} diff --git a/flytestdlib/config/port_test.go b/flytestdlib/config/port_test.go new file mode 100644 index 0000000000..c69c09570d --- /dev/null +++ b/flytestdlib/config/port_test.go @@ -0,0 +1,81 @@ +package config + +import ( + "encoding/json" + "fmt" + "reflect" + "testing" + + "github.com/stretchr/testify/assert" +) + +type PortTestCase struct { + Expected Port + Input interface{} +} + +func TestPort_MarshalJSON(t *testing.T) { + validPorts := []PortTestCase{ + {Expected: Port{Port: 8080}, Input: 8080}, + {Expected: Port{Port: 1}, Input: 1}, + {Expected: Port{Port: 65535}, Input: "65535"}, + {Expected: Port{Port: 65535}, Input: 65535}, + } + + for i, validPort := range validPorts { + t.Run(fmt.Sprintf("Valid %v [%v]", i, validPort.Input), func(t *testing.T) { + b, err := json.Marshal(validPort.Input) + assert.NoError(t, err) + + actual := Port{} + err = actual.UnmarshalJSON(b) + assert.NoError(t, err) + + assert.True(t, reflect.DeepEqual(validPort.Expected, actual)) + }) + } +} + +func TestPort_UnmarshalJSON(t *testing.T) { + invalidValues := []interface{}{ + "%gh&%ij", + 1000000, + true, + } + + for i, invalidPort := range invalidValues { + t.Run(fmt.Sprintf("Invalid %v", i), func(t *testing.T) { + raw, err := json.Marshal(invalidPort) + assert.NoError(t, err) + + actual := URL{} + err = actual.UnmarshalJSON(raw) + assert.Error(t, err) + }) + } + + t.Run("Invalid json", func(t *testing.T) { + actual := Port{} + err := actual.UnmarshalJSON([]byte{}) + assert.Error(t, err) + }) + + t.Run("Invalid Range", func(t *testing.T) { + b, err := json.Marshal(float64(100000)) + assert.NoError(t, err) + + actual := Port{} + err = actual.UnmarshalJSON(b) + assert.Error(t, err) + }) + + t.Run("Unmarshal Empty", func(t *testing.T) { + p := Port{} + raw, err := json.Marshal(p) + assert.NoError(t, err) + + actual := Port{} + assert.NoError(t, actual.UnmarshalJSON(raw)) + assert.Equal(t, 0, actual.Port) + }) +} diff --git a/flytestdlib/config/regexp.go b/flytestdlib/config/regexp.go new file mode 100644 index 0000000000..bfb92ee5f9 --- /dev/null +++ b/flytestdlib/config/regexp.go @@ -0,0 +1,41 @@ +package config + +import ( + "encoding/json" + "errors" + "regexp" +) + +// A regexp.Regexp wrapper that can marshal and unmarshal into simple regexp string. +type Regexp struct { + regexp.Regexp +} + +func (r Regexp) MarshalJSON() ([]byte, error) { + return json.Marshal(r.String()) +} + +func (r *Regexp) UnmarshalJSON(b []byte) error { + if len(b) == 0 { + r.Regexp = regexp.Regexp{} + return nil + } + + var v interface{} + if err := json.Unmarshal(b, &v); err != nil { + return err + } + + switch value := v.(type) { + case string: + rc, err := regexp.Compile(value) + if err != nil { + return err + } + + r.Regexp = *rc + return nil + default: + return errors.New("invalid regexp") + } +} diff --git a/flytestdlib/config/regexp_test.go b/flytestdlib/config/regexp_test.go new file mode 100644 index 0000000000..6b6bb67c83 --- /dev/null +++ b/flytestdlib/config/regexp_test.go @@ -0,0 +1,62 @@ +package config + +import ( + "encoding/json" + "fmt" + "reflect" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/internal/utils" +) + +func TestRegexp_MarshalJSON(t *testing.T) { + validRegexps := []string{ + "", + ".*", + "^(?:[0-9]{1,3}\\.){3}[0-9]{1,3}$", + } + + for i, validRegexp := range validRegexps { + t.Run(fmt.Sprintf("Valid %v", i), func(t *testing.T) { + expected := Regexp{Regexp: utils.MustCompileRegexp(validRegexp)} + + b, err := expected.MarshalJSON() + assert.NoError(t, err) + + actual := Regexp{} + err = actual.UnmarshalJSON(b) + assert.NoError(t, err) + + assert.True(t, reflect.DeepEqual(expected, actual)) + }) + } +} + +func TestRegexp_UnmarshalJSON(t *testing.T) { + invalidValues := []interface{}{ + "^(", + 123, + true, + } + for i, invalidRegexp := range invalidValues { + t.Run(fmt.Sprintf("Invalid %v", i), func(t *testing.T) { + raw, err := json.Marshal(invalidRegexp) + assert.NoError(t, err) + + actual := Regexp{} + err = actual.UnmarshalJSON(raw) + assert.Error(t, err) + }) + } + + t.Run("Empty regexp", func(t *testing.T) { + expected := Regexp{} + + actual := Regexp{} + err := actual.UnmarshalJSON([]byte{}) + assert.NoError(t, err) + assert.True(t, reflect.DeepEqual(expected, actual)) + }) +} diff --git a/flytestdlib/config/section.go b/flytestdlib/config/section.go new file mode 100644 index 0000000000..22060d4bcf --- /dev/null +++ b/flytestdlib/config/section.go @@ -0,0 +1,234 @@ +package config + +import ( + "context" + "errors" + "fmt" + "reflect" + "strings" + "sync" + + "github.com/spf13/pflag" + + "github.com/flyteorg/flyte/v2/flytestdlib/atomic" +) + +type Section interface { + // Gets a cloned copy of the Config registered to this section. This config instance does not account for any child + // section registered. + GetConfig() Config + + // Gets a function pointer to call when the config has been updated. + GetConfigUpdatedHandler() SectionUpdated + + // Sets the config and sets a bit indicating whether the new config is different when compared to the existing value. + SetConfig(config Config) error + + // Gets a value indicating whether the config has changed since the last call to GetConfigChangedAndClear and clears + // the changed bit. This operation is atomic. + GetConfigChangedAndClear() bool + + // Retrieves the loaded values for section key if one exists, or nil otherwise. + GetSection(key SectionKey) Section + + // Gets all child config sections. + GetSections() SectionMap + + // Registers a section with the config manager. Section keys are case insensitive and must be unique. + // The section object must be passed by reference since it'll be used to unmarshal into. It must also support json + // marshaling. If the section registered gets updated at runtime, the updatesFn will be invoked to handle the propagation + // of changes. + RegisterSectionWithUpdates(key SectionKey, configSection Config, updatesFn SectionUpdated) (Section, error) + + // Registers a section with the config manager. Section keys are case insensitive and must be unique. + // The section object must be passed by reference since it'll be used to unmarshal into. It must also support json + // marshaling. If the section registered gets updated at runtime, the updatesFn will be invoked to handle the propagation + // of changes. + MustRegisterSectionWithUpdates(key SectionKey, configSection Config, updatesFn SectionUpdated) Section + + // Registers a section with the config manager. Section keys are case insensitive and must be unique. + // The section object must be passed by reference since it'll be used to unmarshal into. It must also support json + // marshaling. + RegisterSection(key SectionKey, configSection Config) (Section, error) + + // Registers a section with the config manager. Section keys are case insensitive and must be unique. + // The section object must be passed by reference since it'll be used to unmarshal into. It must also support json + // marshaling. + MustRegisterSection(key SectionKey, configSection Config) Section +} + +type Config = interface{} +type SectionKey = string +type SectionMap map[SectionKey]Section + +// A section can optionally implements this interface to add its fields as cmdline arguments. +type PFlagProvider interface { + GetPFlagSet(prefix string) *pflag.FlagSet +} + +type SectionUpdated func(ctx context.Context, newValue Config) + +// Global section to use with any root-level config sections registered. +var rootSection = NewRootSection() + +type section struct { + config Config + handler SectionUpdated + isDirty atomic.Bool + sections SectionMap + lockObj sync.RWMutex +} + +// Gets the global root section. +func GetRootSection() Section { + return rootSection +} + +func MustRegisterSection(key SectionKey, configSection Config) Section { + s, err := RegisterSection(key, configSection) + if err != nil { + panic(err) + } + + return s +} + +func (r *section) MustRegisterSection(key SectionKey, configSection Config) Section { + s, err := r.RegisterSection(key, configSection) + if err != nil { + panic(err) + } + + return s +} + +// Registers a section with the config manager. Section keys are case insensitive and must be unique. +// The section object must be passed by reference since it'll be used to unmarshal into. It must also support json +// marshaling. +func RegisterSection(key SectionKey, configSection Config) (Section, error) { + return rootSection.RegisterSection(key, configSection) +} + +func (r *section) RegisterSection(key SectionKey, configSection Config) (Section, error) { + return r.RegisterSectionWithUpdates(key, configSection, nil) +} + +func MustRegisterSectionWithUpdates(key SectionKey, configSection Config, updatesFn SectionUpdated) Section { + s, err := RegisterSectionWithUpdates(key, configSection, updatesFn) + if err != nil { + panic(err) + } + + return s +} + +func (r *section) MustRegisterSectionWithUpdates(key SectionKey, configSection Config, updatesFn SectionUpdated) Section { + s, err := r.RegisterSectionWithUpdates(key, configSection, updatesFn) + if err != nil { + panic(err) + } + + return s +} + +// Registers a section with the config manager. Section keys are case insensitive and must be unique. +// The section object must be passed by reference since it'll be used to unmarshal into. It must also support json +// marshaling. If the section registered gets updated at runtime, the updatesFn will be invoked to handle the propagation +// of changes. +func RegisterSectionWithUpdates(key SectionKey, configSection Config, updatesFn SectionUpdated) (Section, error) { + return rootSection.RegisterSectionWithUpdates(key, configSection, updatesFn) +} + +func (r *section) RegisterSectionWithUpdates(key SectionKey, configSection Config, updatesFn SectionUpdated) (Section, error) { + r.lockObj.Lock() + defer r.lockObj.Unlock() + + key = strings.ToLower(key) + + if len(key) == 0 { + return nil, errors.New("key must be a non-zero string") + } + + if configSection == nil { + return nil, fmt.Errorf("configSection must be a non-nil pointer. SectionKey: %v", key) + } + + if reflect.TypeOf(configSection).Kind() != reflect.Ptr { + return nil, fmt.Errorf("section must be a Pointer. SectionKey: %v", key) + } + + if _, alreadyExists := r.sections[key]; alreadyExists { + return nil, fmt.Errorf("key already exists [%v]", key) + } + + section := NewSection(configSection, updatesFn) + r.sections[key] = section + return section, nil +} + +// Retrieves the loaded values for section key if one exists, or nil otherwise. +func GetSection(key SectionKey) Section { + return rootSection.GetSection(key) +} + +func (r *section) GetSection(key SectionKey) Section { + r.lockObj.RLock() + defer r.lockObj.RUnlock() + + key = strings.ToLower(key) + + if section, alreadyExists := r.sections[key]; alreadyExists { + return section + } + + return nil +} + +func (r *section) GetSections() SectionMap { + return r.sections +} + +func (r *section) GetConfig() Config { + r.lockObj.RLock() + defer r.lockObj.RUnlock() + + return r.config +} + +func (r *section) SetConfig(c Config) error { + r.lockObj.Lock() + defer r.lockObj.Unlock() + + if reflect.TypeOf(c).Kind() != reflect.Ptr { + return fmt.Errorf("config must be a Pointer") + } + + if !DeepEqual(r.config, c) { + r.config = c + r.isDirty.Store(true) + } + + return nil +} + +func (r *section) GetConfigUpdatedHandler() SectionUpdated { + return r.handler +} + +func (r *section) GetConfigChangedAndClear() bool { + return r.isDirty.CompareAndSwap(true, false) +} + +func NewSection(configSection Config, updatesFn SectionUpdated) Section { + return §ion{ + config: configSection, + handler: updatesFn, + isDirty: atomic.NewBool(false), + sections: map[SectionKey]Section{}, + lockObj: sync.RWMutex{}, + } +} + +func NewRootSection() Section { + return NewSection(nil, nil) +} diff --git a/flytestdlib/config/section_test.go b/flytestdlib/config/section_test.go new file mode 100644 index 0000000000..1c291707bd --- /dev/null +++ b/flytestdlib/config/section_test.go @@ -0,0 +1,117 @@ +package config + +import ( + "flag" + "fmt" + "os" + "path/filepath" + "reflect" + "testing" + "time" + + "github.com/ghodss/yaml" + "github.com/spf13/pflag" + "github.com/stretchr/testify/assert" + "k8s.io/apimachinery/pkg/util/rand" + + "github.com/flyteorg/flyte/v2/flytestdlib/internal/utils" +) + +// Make sure existing config file(s) parse correctly before overriding them with this flag! +var update = flag.Bool("update", false, "Updates testdata") + +type MyComponentConfig struct { + StringValue string `json:"str"` +} + +type OtherComponentConfig struct { + DurationValue Duration `json:"duration-value"` + URLValue URL `json:"url-value"` + StringValue string `json:"string-value"` + IntValue int `json:"int-val"` + StringArray []string `json:"strings"` +} + +func (MyComponentConfig) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("MyComponentConfig", pflag.ExitOnError) + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "str"), "hello world", "life is short") + return cmdFlags +} + +func (OtherComponentConfig) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("MyComponentConfig", pflag.ExitOnError) + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "string-value"), "hello world", "life is short") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "duration-value"), "20s", "") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "int-val"), 4, "this is an important flag") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "url-value"), "http://blah.com", "Sets the type of storage to configure [s3/minio/local/mem].") + return cmdFlags +} + +type TestConfig struct { + MyComponentConfig MyComponentConfig `json:"my-component"` + OtherComponentConfig OtherComponentConfig `json:"other-component"` +} + +func TestMarshal(t *testing.T) { + expected := TestConfig{ + MyComponentConfig: MyComponentConfig{ + StringValue: "Hello World", + }, + OtherComponentConfig: OtherComponentConfig{ + StringValue: "Hey there!", + IntValue: 4, + URLValue: URL{URL: utils.MustParseURL("http://something.com")}, + DurationValue: Duration{Duration: time.Second * 20}, + StringArray: []string{"hello", "world", "!"}, + }, + } + + configPath := filepath.Join("testdata", "config.yaml") + if *update { + t.Log("Updating config file.") + raw, err := yaml.Marshal(expected) + assert.NoError(t, err) + assert.NoError(t, os.WriteFile(configPath, raw, os.ModePerm)) // #nosec G306 + } + + r := TestConfig{} + raw, err := os.ReadFile(configPath) + assert.NoError(t, err) + assert.NoError(t, yaml.Unmarshal(raw, &r)) + assert.True(t, reflect.DeepEqual(expected, r)) +} + +func TestRegisterSection(t *testing.T) { + t.Run("New Section", func(t *testing.T) { + _, err := RegisterSection(rand.String(6), &TestConfig{}) + assert.NoError(t, err) + }) + + t.Run("Duplicate", func(t *testing.T) { + s := rand.String(6) + _, err := RegisterSection(s, &TestConfig{}) + assert.NoError(t, err) + _, err = RegisterSection(s, &TestConfig{}) + assert.Error(t, err) + }) + + t.Run("Register Nested", func(t *testing.T) { + root := NewRootSection() + s := rand.String(6) + _, err := root.RegisterSection(s, &TestConfig{}) + assert.NoError(t, err) + _, err = root.RegisterSection(s, &TestConfig{}) + assert.Error(t, err) + }) +} + +func TestGetSection(t *testing.T) { + sectionName := rand.String(6) + actual1, err := RegisterSection(sectionName, &TestConfig{}) + assert.NoError(t, err) + assert.Equal(t, reflect.TypeOf(&TestConfig{}), reflect.TypeOf(actual1.GetConfig())) + + actual2 := GetSection(sectionName) + assert.NotNil(t, actual2) + assert.Equal(t, reflect.TypeOf(&TestConfig{}), reflect.TypeOf(actual2.GetConfig())) +} diff --git a/flytestdlib/config/testdata/config.yaml b/flytestdlib/config/testdata/config.yaml new file mode 100755 index 0000000000..2f20ad97b5 --- /dev/null +++ b/flytestdlib/config/testdata/config.yaml @@ -0,0 +1,11 @@ +my-component: + str: Hello World +other-component: + duration-value: 20s + int-val: 4 + string-value: Hey there! + strings: + - hello + - world + - '!' + url-value: http://something.com diff --git a/flytestdlib/config/tests/accessor_test.go b/flytestdlib/config/tests/accessor_test.go new file mode 100644 index 0000000000..179d59c81a --- /dev/null +++ b/flytestdlib/config/tests/accessor_test.go @@ -0,0 +1,689 @@ +package tests + +import ( + "context" + "crypto/rand" + "encoding/binary" + "fmt" + "io/ioutil" + "os" + "os/exec" + "path" + "path/filepath" + "reflect" + "runtime" + "strings" + "testing" + "time" + + "github.com/ghodss/yaml" + "github.com/spf13/pflag" + "github.com/stretchr/testify/assert" + k8sRand "k8s.io/apimachinery/pkg/util/rand" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/internal/utils" +) + +type accessorCreatorFn func(registry config.Section, configPath string) config.Accessor + +func getRandInt() uint64 { + c := 10 + b := make([]byte, c) + _, err := rand.Read(b) + if err != nil { + return 0 + } + + return binary.BigEndian.Uint64(b) +} + +func tempFileName(dir, pattern string) string { + // TODO: Remove this hack after we use Go1.11 everywhere: + // https://github.com/golang/go/commit/191efbc419d7e5dec842c20841f6f716da4b561d + + var prefix, suffix string + if pos := strings.LastIndex(pattern, "*"); pos != -1 { + prefix, suffix = pattern[:pos], pattern[pos+1:] + } else { + prefix = pattern + } + + if len(dir) == 0 { + dir = os.TempDir() + } + + return filepath.Join(dir, prefix+k8sRand.String(6)+suffix) +} + +func populateConfigData(configPath string) (TestConfig, error) { + expected := TestConfig{ + MyComponentConfig: MyComponentConfig{ + StringValue: fmt.Sprintf("Hello World %v", getRandInt()), + }, + OtherComponentConfig: OtherComponentConfig{ + StringValue: fmt.Sprintf("Hello World %v", getRandInt()), + URLValue: config.URL{URL: utils.MustParseURL("http://something.com")}, + DurationValue: config.Duration{Duration: time.Second * 20}, + }, + } + + raw, err := yaml.Marshal(expected) + if err != nil { + return TestConfig{}, err + } + + return expected, os.WriteFile(configPath, raw, os.ModePerm) // #nosec G306 +} + +func TestGetEmptySection(t *testing.T) { + t.Run("empty", func(t *testing.T) { + r := config.GetSection("Empty") + assert.Nil(t, r) + }) +} + +type ComplexType struct { + IntValue int `json:"int-val"` +} + +type ComplexTypeArray []ComplexType + +type ConfigWithLists struct { + ListOfStuff []ComplexType `json:"list"` + StringValue string `json:"string-val"` +} + +type ConfigWithMaps struct { + MapOfStuff map[string]ComplexType `json:"m"` + MapWithoutJSON map[string]ComplexType +} + +type ConfigWithJSONTypes struct { + Duration config.Duration `json:"duration"` +} + +func TestAccessor_InitializePflags(t *testing.T) { + for _, provider := range providers { + t.Run(fmt.Sprintf("[%v] Unused flag", provider(config.Options{}).ID()), func(t *testing.T) { + reg := config.NewRootSection() + _, err := reg.RegisterSection(MyComponentSectionKey, &MyComponentConfig{}) + assert.NoError(t, err) + v := provider(config.Options{ + SearchPaths: []string{filepath.Join("testdata", "config.yaml")}, + RootSection: reg, + }) + + set := pflag.NewFlagSet("test", pflag.ContinueOnError) + set.String("flag1", "123", "") + v.InitializePflags(set) + assert.NoError(t, v.UpdateConfig(context.TODO())) + }) + + t.Run(fmt.Sprintf("[%v] Override string value", provider(config.Options{}).ID()), func(t *testing.T) { + reg := config.NewRootSection() + _, err := reg.RegisterSection(MyComponentSectionKey, &MyComponentConfig{}) + assert.NoError(t, err) + + v := provider(config.Options{ + SearchPaths: []string{filepath.Join("testdata", "config.yaml")}, + RootSection: reg, + }) + + set := pflag.NewFlagSet("test", pflag.ContinueOnError) + v.InitializePflags(set) + key := "MY_COMPONENT.STR2" + assert.NoError(t, os.Setenv(key, "123")) + defer func() { assert.NoError(t, os.Unsetenv(key)) }() + assert.NoError(t, v.UpdateConfig(context.TODO())) + r := reg.GetSection(MyComponentSectionKey).GetConfig().(*MyComponentConfig) + assert.Equal(t, "123", r.StringValue2) + }) + + t.Run(fmt.Sprintf("[%v] Parse from config file", provider(config.Options{}).ID()), func(t *testing.T) { + reg := config.NewRootSection() + _, err := reg.RegisterSection(MyComponentSectionKey, &MyComponentConfig{}) + assert.NoError(t, err) + + _, err = reg.RegisterSection(OtherComponentSectionKey, &OtherComponentConfig{}) + assert.NoError(t, err) + + v := provider(config.Options{ + SearchPaths: []string{filepath.Join("testdata", "config.yaml")}, + RootSection: reg, + }) + + set := pflag.NewFlagSet("test", pflag.ExitOnError) + v.InitializePflags(set) + assert.NoError(t, v.UpdateConfig(context.TODO())) + r := reg.GetSection(MyComponentSectionKey).GetConfig().(*MyComponentConfig) + assert.Equal(t, "Hello World", r.StringValue) + otherC := reg.GetSection(OtherComponentSectionKey).GetConfig().(*OtherComponentConfig) + assert.Equal(t, 4, otherC.IntValue) + assert.Equal(t, []string{"default value"}, otherC.StringArrayWithDefaults) + assert.Equal(t, NamedTypeB, otherC.NamedType) + }) + + t.Run(fmt.Sprintf("[%v] Sub-sections", provider(config.Options{}).ID()), func(t *testing.T) { + reg := config.NewRootSection() + sec, err := reg.RegisterSection(MyComponentSectionKey, &MyComponentConfig{}) + assert.NoError(t, err) + + _, err = sec.RegisterSection("nested", &OtherComponentConfig{}) + assert.NoError(t, err) + + v := provider(config.Options{ + SearchPaths: []string{filepath.Join("testdata", "nested_config.yaml")}, + RootSection: reg, + }) + + set := pflag.NewFlagSet("test", pflag.ExitOnError) + v.InitializePflags(set) + assert.NoError(t, set.Parse([]string{"--my-component.nested.int-val=3"})) + assert.True(t, set.Parsed()) + + flagValue, err := set.GetInt("my-component.nested.int-val") + assert.NoError(t, err) + assert.Equal(t, 3, flagValue) + + assert.NoError(t, v.UpdateConfig(context.TODO())) + r := reg.GetSection(MyComponentSectionKey).GetConfig().(*MyComponentConfig) + assert.Equal(t, "Hello World", r.StringValue) + + nested := sec.GetSection("nested").GetConfig().(*OtherComponentConfig) + assert.Equal(t, 3, nested.IntValue) + }) + } +} + +func TestStrictAccessor(t *testing.T) { + for _, provider := range providers { + t.Run(fmt.Sprintf("[%v] Bad config", provider(config.Options{}).ID()), func(t *testing.T) { + reg := config.NewRootSection() + v := provider(config.Options{ + StrictMode: true, + SearchPaths: []string{filepath.Join("testdata", "bad_config.yaml")}, + RootSection: reg, + }) + + set := pflag.NewFlagSet("test", pflag.ExitOnError) + v.InitializePflags(set) + assert.Error(t, v.UpdateConfig(context.TODO())) + }) + + t.Run(fmt.Sprintf("[%v] flags defined outside", provider(config.Options{}).ID()), func(t *testing.T) { + reg := config.NewRootSection() + _, err := reg.RegisterSection(MyComponentSectionKey, &MyComponentConfig{}) + assert.NoError(t, err) + + _, err = reg.RegisterSection(OtherComponentSectionKey, &OtherComponentConfig{}) + assert.NoError(t, err) + v := provider(config.Options{ + StrictMode: true, + SearchPaths: []string{filepath.Join("testdata", "bad_config.yaml")}, + RootSection: reg, + }) + + set := pflag.NewFlagSet("test", pflag.ExitOnError) + set.StringP("unknown-key", "u", "", "") + v.InitializePflags(set) + assert.NoError(t, v.UpdateConfig(context.TODO())) + }) + + t.Run(fmt.Sprintf("[%v] Set through env", provider(config.Options{}).ID()), func(t *testing.T) { + reg := config.NewRootSection() + _, err := reg.RegisterSection(MyComponentSectionKey, &MyComponentConfig{}) + assert.NoError(t, err) + + _, err = reg.RegisterSection(OtherComponentSectionKey, &OtherComponentConfig{}) + assert.NoError(t, err) + + v := provider(config.Options{ + StrictMode: true, + SearchPaths: []string{filepath.Join("testdata", "config.yaml")}, + RootSection: reg, + }) + + set := pflag.NewFlagSet("other-component.string-value", pflag.ExitOnError) + v.InitializePflags(set) + + key := "OTHER_COMPONENT.STRING_VALUE" + assert.NoError(t, os.Setenv(key, "set from env")) + defer func() { assert.NoError(t, os.Unsetenv(key)) }() + assert.NoError(t, v.UpdateConfig(context.TODO())) + }) + } +} + +func TestAccessor_UpdateConfig(t *testing.T) { + for _, provider := range providers { + t.Run(fmt.Sprintf("[%v] Static File", provider(config.Options{}).ID()), func(t *testing.T) { + reg := config.NewRootSection() + _, err := reg.RegisterSection(MyComponentSectionKey, &MyComponentConfig{}) + assert.NoError(t, err) + + v := provider(config.Options{ + SearchPaths: []string{filepath.Join("testdata", "config.yaml")}, + RootSection: reg, + }) + + assert.NoError(t, v.UpdateConfig(context.TODO())) + r := reg.GetSection(MyComponentSectionKey).GetConfig().(*MyComponentConfig) + assert.Equal(t, "Hello World", r.StringValue) + }) + + t.Run(fmt.Sprintf("[%v] Nested", provider(config.Options{}).ID()), func(t *testing.T) { + root := config.NewRootSection() + section, err := root.RegisterSection(MyComponentSectionKey, &MyComponentConfig{}) + assert.NoError(t, err) + + _, err = section.RegisterSection("nested", &OtherComponentConfig{}) + assert.NoError(t, err) + + v := provider(config.Options{ + SearchPaths: []string{filepath.Join("testdata", "nested_config.yaml")}, + RootSection: root, + }) + + assert.NoError(t, v.UpdateConfig(context.TODO())) + r := root.GetSection(MyComponentSectionKey).GetConfig().(*MyComponentConfig) + assert.Equal(t, "Hello World", r.StringValue) + + nested := section.GetSection("nested").GetConfig().(*OtherComponentConfig) + assert.Equal(t, "Hey there!", nested.StringValue) + }) + + t.Run(fmt.Sprintf("[%v] Array Configs", provider(config.Options{}).ID()), func(t *testing.T) { + root := config.NewRootSection() + section, err := root.RegisterSection(MyComponentSectionKey, &MyComponentConfig{}) + assert.NoError(t, err) + + _, err = section.RegisterSection("nested", &ComplexTypeArray{}) + assert.NoError(t, err) + + _, err = root.RegisterSection("array-config", &ComplexTypeArray{}) + assert.NoError(t, err) + + v := provider(config.Options{ + SearchPaths: []string{filepath.Join("testdata", "array_configs.yaml")}, + RootSection: root, + }) + + assert.NoError(t, v.UpdateConfig(context.TODO())) + r := root.GetSection(MyComponentSectionKey).GetConfig().(*MyComponentConfig) + assert.Equal(t, "Hello World", r.StringValue) + + nested := section.GetSection("nested").GetConfig().(*ComplexTypeArray) + assert.Len(t, *nested, 1) + assert.Equal(t, 1, (*nested)[0].IntValue) + + topLevel := root.GetSection("array-config").GetConfig().(*ComplexTypeArray) + assert.Len(t, *topLevel, 2) + assert.Equal(t, 4, (*topLevel)[1].IntValue) + }) + + t.Run(fmt.Sprintf("[%v] Override default array config", provider(config.Options{}).ID()), func(t *testing.T) { + root := config.NewRootSection() + _, err := root.RegisterSection(MyComponentSectionKey, &ItemArray{ + Items: []Item{ + { + ID: "default_1", + Name: "default_Name", + }, + { + ID: "default_2", + Name: "default_2_Name", + }, + }, + OtherItem: Item{ + ID: "default_3", + Name: "default_3_name", + }, + }) + assert.NoError(t, err) + + v := provider(config.Options{ + SearchPaths: []string{filepath.Join("testdata", "array_config_2.yaml")}, + RootSection: root, + }) + + assert.NoError(t, v.UpdateConfig(context.TODO())) + r := root.GetSection(MyComponentSectionKey).GetConfig().(*ItemArray) + assert.Len(t, r.Items, 1) + assert.Equal(t, "abc", r.Items[0].ID) + assert.Equal(t, "default_3", r.OtherItem.ID) + }) + + t.Run(fmt.Sprintf("[%v] Override default map config", provider(config.Options{}).ID()), func(t *testing.T) { + t.Run("Simple", func(t *testing.T) { + root := config.NewRootSection() + _, err := root.RegisterSection(MyComponentSectionKey, &ItemMap{ + Items: map[string]Item{ + "1": { + ID: "default_1", + Name: "default_Name", + }, + "2": { + ID: "default_2", + Name: "default_2_Name", + }, + }, + }) + assert.NoError(t, err) + + v := provider(config.Options{ + SearchPaths: []string{filepath.Join("testdata", "map_config.yaml")}, + RootSection: root, + }) + + assert.NoError(t, v.UpdateConfig(context.TODO())) + r := root.GetSection(MyComponentSectionKey).GetConfig().(*ItemMap) + assert.Len(t, r.Items, 2) + assert.Equal(t, "abc", r.Items["1"].ID) + }) + + t.Run("NestedMaps", func(t *testing.T) { + root := config.NewRootSection() + _, err := root.RegisterSection(MyComponentSectionKey, &ItemMap{ + ItemsMap: map[string]map[string]Item{}, + }) + assert.NoError(t, err) + + v := provider(config.Options{ + SearchPaths: []string{filepath.Join("testdata", "map_config_nested.yaml")}, + RootSection: root, + }) + + assert.NoError(t, v.UpdateConfig(context.TODO())) + r := root.GetSection(MyComponentSectionKey).GetConfig().(*ItemMap) + assert.Len(t, r.ItemsMap, 2) + assert.Equal(t, "abc1", r.ItemsMap["itemA"]["itemAa"].ID) + assert.Equal(t, "hello world", r.ItemsMap["itemA"]["itemAa"].RandomValue) + assert.Equal(t, "abc2", r.ItemsMap["itemB"]["itemBa"].ID) + assert.Equal(t, "xyz1", r.ItemsMap["itemA"]["itemAb"].ID) + assert.Equal(t, "xyz2", r.ItemsMap["itemB"]["itemBb"].ID) + }) + }) + + t.Run(fmt.Sprintf("[%v] Override in Env Var", provider(config.Options{}).ID()), func(t *testing.T) { + reg := config.NewRootSection() + _, err := reg.RegisterSection(MyComponentSectionKey, &MyComponentConfig{}) + assert.NoError(t, err) + + v := provider(config.Options{ + SearchPaths: []string{filepath.Join("testdata", "config.yaml")}, + RootSection: reg, + }) + key := strings.ToUpper("my-component.str") + assert.NoError(t, os.Setenv(key, "Set From Env")) + defer func() { assert.NoError(t, os.Unsetenv(key)) }() + assert.NoError(t, v.UpdateConfig(context.TODO())) + r := reg.GetSection(MyComponentSectionKey).GetConfig().(*MyComponentConfig) + assert.Equal(t, "Set From Env", r.StringValue) + }) + + t.Run(fmt.Sprintf("[%v] Override in Env Var no config file", provider(config.Options{}).ID()), func(t *testing.T) { + reg := config.NewRootSection() + _, err := reg.RegisterSection(MyComponentSectionKey, &MyComponentConfig{}) + assert.NoError(t, err) + + v := provider(config.Options{RootSection: reg}) + key := strings.ToUpper("my-component.str3") + assert.NoError(t, os.Setenv(key, "Set From Env")) + defer func() { assert.NoError(t, os.Unsetenv(key)) }() + assert.NoError(t, v.UpdateConfig(context.TODO())) + r := reg.GetSection(MyComponentSectionKey).GetConfig().(*MyComponentConfig) + assert.Equal(t, "Set From Env", r.StringValue3) + }) + + t.Run(fmt.Sprintf("[%v] Change handler", provider(config.Options{}).ID()), func(t *testing.T) { + configFile := tempFileName("", "config-*.yaml") + defer func() { assert.NoError(t, os.Remove(configFile)) }() + cfg, err := populateConfigData(configFile) + assert.NoError(t, err) + + reg := config.NewRootSection() + called := false + _, err = reg.RegisterSectionWithUpdates(MyComponentSectionKey, &cfg.MyComponentConfig, + func(ctx context.Context, newValue config.Config) { + called = true + }) + assert.NoError(t, err) + + opts := config.Options{ + SearchPaths: []string{configFile}, + RootSection: reg, + } + v := provider(opts) + err = v.UpdateConfig(context.TODO()) + assert.NoError(t, err) + + assert.True(t, called) + }) + + t.Run(fmt.Sprintf("[%v] Change handler k8s configmaps", provider(config.Options{}).ID()), func(t *testing.T) { + reg := config.NewRootSection() + section, err := reg.RegisterSection(MyComponentSectionKey, &MyComponentConfig{}) + assert.NoError(t, err) + + var firstValue string + + // 1. Create Dir structure + watchDir, configFile, cleanup := newSymlinkedConfigFile(t) + defer cleanup() + + // 2. Start accessor with the symlink as config location + opts := config.Options{ + SearchPaths: []string{configFile}, + RootSection: reg, + } + v := provider(opts) + err = v.UpdateConfig(context.TODO()) + assert.NoError(t, err) + + r := section.GetConfig().(*MyComponentConfig) + firstValue = r.StringValue + t.Logf("First value: %v", firstValue) + + // 3. Now update /data symlink to point to data2 + dataDir2 := path.Join(watchDir, "data2") + err = os.Mkdir(dataDir2, os.ModePerm) + assert.NoError(t, err) + + configFile2 := path.Join(dataDir2, "config.yaml") + newData, err := populateConfigData(configFile2) + assert.NoError(t, err) + t.Logf("New value written to file: %v", newData.MyComponentConfig.StringValue) + + // change the symlink using the `ln -sfn` command + err = changeSymLink(dataDir2, path.Join(watchDir, "data")) + assert.NoError(t, err) + + t.Logf("New config Location: %v", configFile2) + + time.Sleep(5 * time.Second) + + r = section.GetConfig().(*MyComponentConfig) + secondValue := r.StringValue + // Make sure values have changed + assert.NotEqual(t, firstValue, secondValue) + }) + + t.Run(fmt.Sprintf("[%v] Default variables", provider(config.Options{}).ID()), func(t *testing.T) { + reg := config.NewRootSection() + _, err := reg.RegisterSection(MyComponentSectionKey, &MyComponentConfig{ + StringValue: "default value 1", + StringValue2: "default value 2", + }) + assert.NoError(t, err) + + v := provider(config.Options{ + SearchPaths: []string{filepath.Join("testdata", "config.yaml")}, + RootSection: reg, + }) + key := strings.ToUpper("my-component.str") + assert.NoError(t, os.Setenv(key, "Set From Env")) + defer func() { assert.NoError(t, os.Unsetenv(key)) }() + assert.NoError(t, v.UpdateConfig(context.TODO())) + r := reg.GetSection(MyComponentSectionKey).GetConfig().(*MyComponentConfig) + assert.Equal(t, "Set From Env", r.StringValue) + assert.Equal(t, "default value 2", r.StringValue2) + }) + } +} + +func changeSymLink(targetPath, symLink string) error { + tmpLink := tempFileName("", "temp-sym-link-*") + if runtime.GOOS == "windows" { + // #nosec G204 + err := exec.Command("mklink", filepath.Clean(tmpLink), filepath.Clean(targetPath)).Run() + if err != nil { + return err + } + + // #nosec G204 + err = exec.Command("copy", "/l", "/y", filepath.Clean(tmpLink), filepath.Clean(symLink)).Run() + if err != nil { + return err + } + + // #nosec G204 + return exec.Command("del", filepath.Clean(tmpLink)).Run() + } + + //// ln -sfn is not an atomic operation. Under the hood, it first calls the system unlink then symlink calls. During + //// that, there will be a brief moment when there is no symlink at all. + // #nosec G204 + return exec.Command("ln", "-sfn", filepath.Clean(targetPath), filepath.Clean(symLink)).Run() +} + +func newSymlinkedConfigFile(t *testing.T) (watchDir, configFile string, cleanup func()) { + // 1. Create Dir structure: + // |_ data1 + // |_ config.yaml + // |_ data (symlink for data1) + // |_ config.yaml (symlink for data/config.yaml -recursively a symlink of data1/config.yaml) + + watchDir, err := ioutil.TempDir("", "config-test-") + assert.NoError(t, err) + + dataDir1 := path.Join(watchDir, "data1") + err = os.Mkdir(dataDir1, os.ModePerm) + assert.NoError(t, err) + + realConfigFile := path.Join(dataDir1, "config.yaml") + t.Logf("Real config file location: %s\n", realConfigFile) + _, err = populateConfigData(realConfigFile) + assert.NoError(t, err) + + cleanup = func() { + t.Logf("Removing watchDir [%v]", watchDir) + assert.NoError(t, os.RemoveAll(watchDir)) + } + + // now, symlink the tm `data1` dir to `data` in the baseDir + assert.NoError(t, os.Symlink(dataDir1, path.Join(watchDir, "data"))) + + // and link the `/datadir1/config.yaml` to `/config.yaml` + configFile = path.Join(watchDir, "config.yaml") + assert.NoError(t, os.Symlink(path.Join(watchDir, "data", "config.yaml"), configFile)) + + t.Logf("Config file location: %s\n", path.Join(watchDir, "config.yaml")) + return watchDir, configFile, cleanup +} + +func testTypes(accessor accessorCreatorFn) func(t *testing.T) { + return func(t *testing.T) { + t.Run("ArrayConfigType", func(t *testing.T) { + expected := ComplexTypeArray{ + {IntValue: 1}, + {IntValue: 4}, + } + + runEqualTest(t, accessor, &expected, &ComplexTypeArray{}) + }) + + t.Run("Lists", func(t *testing.T) { + expected := ConfigWithLists{ + ListOfStuff: []ComplexType{ + {IntValue: 1}, + {IntValue: 4}, + }, + } + + runEqualTest(t, accessor, &expected, &ConfigWithLists{}) + }) + + t.Run("Maps", func(t *testing.T) { + expected := ConfigWithMaps{ + MapOfStuff: map[string]ComplexType{ + "item1": {IntValue: 1}, + "item2": {IntValue: 3}, + }, + MapWithoutJSON: map[string]ComplexType{ + "it-1": {IntValue: 5}, + }, + } + + runEqualTest(t, accessor, &expected, &ConfigWithMaps{}) + }) + + t.Run("JsonUnmarshalableTypes", func(t *testing.T) { + expected := ConfigWithJSONTypes{ + Duration: config.Duration{ + Duration: time.Second * 10, + }, + } + + runEqualTest(t, accessor, &expected, &ConfigWithJSONTypes{}) + }) + } +} + +func runEqualTest(t *testing.T, accessor accessorCreatorFn, expected interface{}, emptyType interface{}) { + assert.NotPanics(t, func() { + reflect.TypeOf(expected).Elem() + }, "expected must be a Pointer type. Instead, it was %v", reflect.TypeOf(expected)) + + assert.Equal(t, reflect.TypeOf(expected), reflect.TypeOf(emptyType)) + + rootSection := config.NewRootSection() + sectionKey := fmt.Sprintf("rand-key-%v", getRandInt()%2000) + _, err := rootSection.RegisterSection(sectionKey, emptyType) + assert.NoError(t, err) + + m := map[string]interface{}{ + sectionKey: expected, + } + + raw, err := yaml.Marshal(m) + assert.NoError(t, err) + f := tempFileName("", "test_type_*.yaml") + assert.NoError(t, err) + defer func() { assert.NoError(t, os.Remove(f)) }() + + assert.NoError(t, os.WriteFile(f, raw, os.ModePerm)) // #nosec G306 + t.Logf("Generated yaml: %v", string(raw)) + assert.NoError(t, accessor(rootSection, f).UpdateConfig(context.TODO())) + + res := rootSection.GetSection(sectionKey).GetConfig() + t.Logf("Expected: %+v", expected) + t.Logf("Actual: %+v", res) + assert.True(t, reflect.DeepEqual(res, expected)) +} + +func TestAccessor_Integration(t *testing.T) { + accessorsToTest := make([]accessorCreatorFn, 0, len(providers)) + for _, provider := range providers { + accessorsToTest = append(accessorsToTest, func(r config.Section, configPath string) config.Accessor { + return provider(config.Options{ + SearchPaths: []string{configPath}, + RootSection: r, + }) + }) + } + + for _, accessor := range accessorsToTest { + t.Run(fmt.Sprintf(testNameFormatter, accessor(nil, "").ID(), "Types"), testTypes(accessor)) + } +} diff --git a/flytestdlib/config/tests/config_cmd_test.go b/flytestdlib/config/tests/config_cmd_test.go new file mode 100644 index 0000000000..9c6949d8f2 --- /dev/null +++ b/flytestdlib/config/tests/config_cmd_test.go @@ -0,0 +1,92 @@ +package tests + +import ( + "bytes" + "fmt" + "os" + "testing" + + "github.com/spf13/cobra" + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" +) + +func executeCommand(root *cobra.Command, args ...string) (output string, err error) { + _, output, err = executeCommandC(root, args...) + return output, err +} + +func executeCommandC(root *cobra.Command, args ...string) (c *cobra.Command, output string, err error) { + buf := new(bytes.Buffer) + root.SetOutput(buf) + root.SetArgs(args) + + c, err = root.ExecuteC() + + return c, buf.String(), err +} + +func TestDiscoverCommand(t *testing.T) { + for _, provider := range providers { + t.Run(fmt.Sprintf(testNameFormatter, provider(config.Options{}).ID(), "No config file"), func(t *testing.T) { + cmd := config.NewConfigCommand(provider) + output, err := executeCommand(cmd, config.CommandDiscover) + assert.NoError(t, err) + assert.Contains(t, output, "Couldn't find a config file.") + }) + + t.Run(fmt.Sprintf(testNameFormatter, provider(config.Options{}).ID(), "Valid config file"), func(t *testing.T) { + dir, err := os.Getwd() + assert.NoError(t, err) + wd := os.ExpandEnv("$PWD/testdata") + err = os.Chdir(wd) + assert.NoError(t, err) + defer func() { assert.NoError(t, os.Chdir(dir)) }() + + cmd := config.NewConfigCommand(provider) + output, err := executeCommand(cmd, config.CommandDiscover) + assert.NoError(t, err) + assert.Contains(t, output, "Config") + }) + } +} + +func TestValidateCommand(t *testing.T) { + for _, provider := range providers { + t.Run(fmt.Sprintf(testNameFormatter, provider(config.Options{}).ID(), "No config file"), func(t *testing.T) { + cmd := config.NewConfigCommand(provider) + output, err := executeCommand(cmd, config.CommandValidate) + assert.NoError(t, err) + assert.Contains(t, output, "Couldn't find a config file.") + }) + + t.Run(fmt.Sprintf(testNameFormatter, provider(config.Options{}).ID(), "Invalid Config file"), func(t *testing.T) { + dir, err := os.Getwd() + assert.NoError(t, err) + wd := os.ExpandEnv("$PWD/testdata") + err = os.Chdir(wd) + assert.NoError(t, err) + defer func() { assert.NoError(t, os.Chdir(dir)) }() + + cmd := config.NewConfigCommand(provider) + output, err := executeCommand(cmd, config.CommandValidate, "--file=bad_config.yaml", "--strict") + assert.Error(t, err) + assert.Contains(t, output, "Failed") + }) + + t.Run(fmt.Sprintf(testNameFormatter, provider(config.Options{}).ID(), "Valid config file"), func(t *testing.T) { + dir, err := os.Getwd() + assert.NoError(t, err) + wd := os.ExpandEnv("$PWD/testdata") + err = os.Chdir(wd) + assert.NoError(t, err) + defer func() { assert.NoError(t, os.Chdir(dir)) }() + + cmd := config.NewConfigCommand(provider) + output, err := executeCommand(cmd, config.CommandValidate) + assert.NoError(t, err) + assert.Contains(t, output, "successfully") + }) + } +} diff --git a/flytestdlib/config/tests/testdata/array_config_2.yaml b/flytestdlib/config/tests/testdata/array_config_2.yaml new file mode 100644 index 0000000000..05aa2bb533 --- /dev/null +++ b/flytestdlib/config/tests/testdata/array_config_2.yaml @@ -0,0 +1,4 @@ +my-component: + items: + - id: abc + name: "A b c" \ No newline at end of file diff --git a/flytestdlib/config/tests/testdata/array_configs.yaml b/flytestdlib/config/tests/testdata/array_configs.yaml new file mode 100644 index 0000000000..6a02a280a6 --- /dev/null +++ b/flytestdlib/config/tests/testdata/array_configs.yaml @@ -0,0 +1,7 @@ +my-component: + str: Hello World + nested: + - int-val: 1 +array-config: + - int-val: 1 + - int-val: 4 diff --git a/flytestdlib/config/tests/testdata/bad_config.yaml b/flytestdlib/config/tests/testdata/bad_config.yaml new file mode 100644 index 0000000000..3e87c2a4e4 --- /dev/null +++ b/flytestdlib/config/tests/testdata/bad_config.yaml @@ -0,0 +1,13 @@ +my-component: + str: Hello World +other-component: + duration-value: 20s + int-val: 4 + string-value: Hey there! + strings: + - hello + - world + - '!' + url-value: http://something.com +unknown-key: "something" + diff --git a/flytestdlib/config/tests/testdata/config.yaml b/flytestdlib/config/tests/testdata/config.yaml new file mode 100755 index 0000000000..501b11eb95 --- /dev/null +++ b/flytestdlib/config/tests/testdata/config.yaml @@ -0,0 +1,13 @@ +my-component: + str: Hello World +other-component: + duration-value: 20s + int-val: 4 + string-value: Hey there! + strings: + - hello + - world + - '!' + url-value: http://something.com + myByteArray: JDJhJDA2JHB4czFBa0c4MUt2cmhwbWwxUWlMU09RYVRrOWVlUHJVLzdZYWI5eTA3aDN4MFRnbGJhb1Q2 + namedType: B diff --git a/flytestdlib/config/tests/testdata/map_config.yaml b/flytestdlib/config/tests/testdata/map_config.yaml new file mode 100644 index 0000000000..d388851d39 --- /dev/null +++ b/flytestdlib/config/tests/testdata/map_config.yaml @@ -0,0 +1,8 @@ +my-component: + items: + 1: + id: abc + name: "A b c" + 2: + id: xyz + name: "x y z" \ No newline at end of file diff --git a/flytestdlib/config/tests/testdata/map_config_nested.yaml b/flytestdlib/config/tests/testdata/map_config_nested.yaml new file mode 100644 index 0000000000..92de73e5d8 --- /dev/null +++ b/flytestdlib/config/tests/testdata/map_config_nested.yaml @@ -0,0 +1,17 @@ +my-component: + itemsMap: + - itemA: + - itemAa: + id: abc1 + name: "A b c" + randomValue: "hello world" + - itemAb: + id: xyz1 + name: "x y z" + - itemB: + - itemBa: + id: abc2 + name: "A b c" + - itemBb: + id: xyz2 + name: "x y z" \ No newline at end of file diff --git a/flytestdlib/config/tests/testdata/nested_config.yaml b/flytestdlib/config/tests/testdata/nested_config.yaml new file mode 100755 index 0000000000..321f563a42 --- /dev/null +++ b/flytestdlib/config/tests/testdata/nested_config.yaml @@ -0,0 +1,11 @@ +my-component: + str: Hello World + nested: + duration-value: 20s + int-val: 4 + string-value: Hey there! + strings: + - hello + - world + - '!' + url-value: http://something.com diff --git a/flytestdlib/config/tests/types_test.go b/flytestdlib/config/tests/types_test.go new file mode 100644 index 0000000000..9c765cb0fe --- /dev/null +++ b/flytestdlib/config/tests/types_test.go @@ -0,0 +1,159 @@ +package tests + +import ( + "encoding/json" + "fmt" + + "github.com/spf13/pflag" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/config/viper" +) + +const testNameFormatter = "[%v] %v" + +var providers = []config.AccessorProvider{viper.NewAccessor} + +type MyComponentConfig struct { + StringValue string `json:"str"` + StringValue2 string `json:"str2"` + StringValue3 string `json:"str3"` +} + +type NamedType int + +const ( + NamedTypeA NamedType = iota + NamedTypeB +) + +type OtherComponentConfig struct { + DurationValue config.Duration `json:"duration-value"` + URLValue config.URL `json:"url-value"` + StringValue string `json:"string-value"` + IntValue int `json:"int-val"` + StringArray []string `json:"strings"` + StringArrayWithDefaults []string `json:"strings-def"` + MyByteArray []byte `json:"myByteArray"` + NamedType NamedType `json:"namedType"` +} + +type Item struct { + ID string `json:"id"` + Name string `json:"name"` + RandomValue string `json:"randomValue"` +} + +type ItemArray struct { + Items []Item `json:"items"` + OtherItem Item `json:"otherItem"` +} + +type ItemMap struct { + Items map[string]Item `json:"items"` + ItemsMap map[string]map[string]Item `json:"itemsMap"` +} + +func (MyComponentConfig) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("MyComponentConfig", pflag.ExitOnError) + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "str"), "hello world", "life is short") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "str2"), "hello world", "life is short") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "str3"), "hello world", "life is short") + return cmdFlags +} + +var ( + DefaultOtherComponentConfig = &OtherComponentConfig{ + NamedType: NamedTypeA, + } +) + +func (OtherComponentConfig) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("MyComponentConfig", pflag.ExitOnError) + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "string-value"), "hello world", "life is short") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "duration-value"), "20s", "") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "int-val"), 4, "this is an important flag") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "url-value"), "http://blah.com", "Sets the type of storage to configure [s3/minio/local/mem].") + cmdFlags.StringSlice(fmt.Sprintf("%v%v", prefix, "strings-def"), []string{"default value"}, "Sets the type of storage to configure [s3/minio/local/mem].") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "namedType"), int(DefaultOtherComponentConfig.NamedType), "") + return cmdFlags +} + +type TestConfig struct { + MyComponentConfig MyComponentConfig `json:"my-component"` + OtherComponentConfig OtherComponentConfig `json:"other-component"` +} + +const ( + MyComponentSectionKey = "my-component" + OtherComponentSectionKey = "other-component" +) + +func init() { + if _, err := config.RegisterSection(MyComponentSectionKey, &MyComponentConfig{}); err != nil { + panic(err) + } + + if _, err := config.RegisterSection(OtherComponentSectionKey, &OtherComponentConfig{}); err != nil { + panic(err) + } +} + +const _NamedTypeName = "AB" + +var _NamedTypeIndex = [...]uint8{0, 1, 2} + +func (i NamedType) String() string { + if i < 0 || i >= NamedType(len(_NamedTypeIndex)-1) { + return fmt.Sprintf("NamedType(%d)", i) + } + return _NamedTypeName[_NamedTypeIndex[i]:_NamedTypeIndex[i+1]] +} + +var _NamedTypeValues = []NamedType{0, 1} + +var _NamedTypeNameToValueMap = map[string]NamedType{ + _NamedTypeName[0:1]: 0, + _NamedTypeName[1:2]: 1, +} + +// NamedTypeString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func NamedTypeString(s string) (NamedType, error) { + if val, ok := _NamedTypeNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to NamedType values", s) +} + +// NamedTypeValues returns all values of the enum +func NamedTypeValues() []NamedType { + return _NamedTypeValues +} + +// IsANamedType returns "true" if the value is listed in the enum definition. "false" otherwise +func (i NamedType) IsANamedType() bool { + for _, v := range _NamedTypeValues { + if i == v { + return true + } + } + return false +} + +// MarshalJSON implements the json.Marshaler interface for NamedType +func (i NamedType) MarshalJSON() ([]byte, error) { + return json.Marshal(i.String()) +} + +// UnmarshalJSON implements the json.Unmarshaler interface for NamedType +func (i *NamedType) UnmarshalJSON(data []byte) error { + var s string + if err := json.Unmarshal(data, &s); err != nil { + return fmt.Errorf("NamedType should be a string, got %s", data) + } + + var err error + *i, err = NamedTypeString(s) + return err +} diff --git a/flytestdlib/config/url.go b/flytestdlib/config/url.go new file mode 100644 index 0000000000..087ca8a510 --- /dev/null +++ b/flytestdlib/config/url.go @@ -0,0 +1,52 @@ +package config + +import ( + "encoding/json" + "errors" + "net/url" +) + +// A url.URL wrapper that can marshal and unmarshal into simple URL strings. +type URL struct { + url.URL +} + +func (d URL) MarshalJSON() ([]byte, error) { + return json.Marshal(d.String()) +} + +func (d *URL) UnmarshalJSON(b []byte) error { + var v interface{} + if err := json.Unmarshal(b, &v); err != nil { + return err + } + + switch value := v.(type) { + case string: + u, err := url.Parse(value) + if err != nil { + return err + } + + d.URL = *u + return nil + default: + return errors.New("invalid url") + } +} + +// Set implements PFlag's Value interface's set method to set the value of duration from string. +func (d *URL) Set(val string) error { + u, err := url.Parse(val) + if err != nil { + return err + } + + d.URL = *u + return nil +} + +// Type implements PFlag's Value interface's Type method to return the name of the type. +func (URL) Type() string { + return "URL" +} diff --git a/flytestdlib/config/url_test.go b/flytestdlib/config/url_test.go new file mode 100644 index 0000000000..7f6327d431 --- /dev/null +++ b/flytestdlib/config/url_test.go @@ -0,0 +1,59 @@ +package config + +import ( + "encoding/json" + "fmt" + "reflect" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/internal/utils" +) + +func TestURL_MarshalJSON(t *testing.T) { + validURLs := []string{ + "http://localhost:123", + "http://localhost", + "https://non-existent.com/path/to/something", + } + + for i, validURL := range validURLs { + t.Run(fmt.Sprintf("Valid %v", i), func(t *testing.T) { + expected := URL{URL: utils.MustParseURL(validURL)} + + b, err := expected.MarshalJSON() + assert.NoError(t, err) + + actual := URL{} + err = actual.UnmarshalJSON(b) + assert.NoError(t, err) + + assert.True(t, reflect.DeepEqual(expected, actual)) + }) + } +} + +func TestURL_UnmarshalJSON(t *testing.T) { + invalidValues := []interface{}{ + "%gh&%ij", + 123, + true, + } + for i, invalidURL := range invalidValues { + t.Run(fmt.Sprintf("Invalid %v", i), func(t *testing.T) { + raw, err := json.Marshal(invalidURL) + assert.NoError(t, err) + + actual := URL{} + err = actual.UnmarshalJSON(raw) + assert.Error(t, err) + }) + } + + t.Run("Invalid json", func(t *testing.T) { + actual := URL{} + err := actual.UnmarshalJSON([]byte{}) + assert.Error(t, err) + }) +} diff --git a/flytestdlib/config/utils.go b/flytestdlib/config/utils.go new file mode 100644 index 0000000000..d131543361 --- /dev/null +++ b/flytestdlib/config/utils.go @@ -0,0 +1,71 @@ +package config + +import ( + "encoding/json" + "fmt" + "reflect" + + "github.com/pkg/errors" + + stdLibErrs "github.com/flyteorg/flyte/v2/flytestdlib/errors" +) + +// Uses Json marshal/unmarshal to make a deep copy of a config object. +func DeepCopyConfig(config Config) (Config, error) { + raw, err := json.Marshal(config) + if err != nil { + return nil, err + } + + t := reflect.TypeOf(config) + ptrValue := reflect.New(t) + newObj := ptrValue.Interface() + if err = json.Unmarshal(raw, newObj); err != nil { + return nil, err + } + + return ptrValue.Elem().Interface(), nil +} + +func DeepEqual(config1, config2 Config) bool { + return reflect.DeepEqual(config1, config2) +} + +func toInterface(config Config) (interface{}, error) { + raw, err := json.Marshal(config) + if err != nil { + return nil, err + } + + var m interface{} + err = json.Unmarshal(raw, &m) + return m, err +} + +// Builds a generic map out of the root section config and its sub-sections configs. +func AllConfigsAsMap(root Section) (m map[string]interface{}, err error) { + errs := stdLibErrs.ErrorCollection{} + allConfigs := make(map[string]interface{}, len(root.GetSections())) + if root.GetConfig() != nil { + rootConfig, err := toInterface(root.GetConfig()) + if !errs.Append(err) { + if asMap, isCasted := rootConfig.(map[string]interface{}); isCasted { + allConfigs = asMap + } else { + allConfigs[""] = rootConfig + } + } + } + + for k, section := range root.GetSections() { + if _, alreadyExists := allConfigs[k]; alreadyExists { + errs.Append(errors.Wrap(ErrChildConfigOverridesConfig, + fmt.Sprintf("section key [%v] overrides an existing native config property", k))) + } + + allConfigs[k], err = AllConfigsAsMap(section) + errs.Append(err) + } + + return allConfigs, errs.ErrorOrDefault() +} diff --git a/flytestdlib/config/utils_test.go b/flytestdlib/config/utils_test.go new file mode 100644 index 0000000000..e5d7d02105 --- /dev/null +++ b/flytestdlib/config/utils_test.go @@ -0,0 +1,39 @@ +package config + +import ( + "reflect" + "strconv" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestDeepCopyConfig(t *testing.T) { + type pair struct { + first interface{} + second interface{} + } + + type fakeConfig struct { + I int + S string + Ptr *fakeConfig + } + + testCases := []pair{ + {3, 3}, + {"word", "word"}, + {fakeConfig{I: 4, S: "four", Ptr: &fakeConfig{I: 5, S: "five"}}, fakeConfig{I: 4, S: "four", Ptr: &fakeConfig{I: 5, S: "five"}}}, + {&fakeConfig{I: 4, S: "four", Ptr: &fakeConfig{I: 5, S: "five"}}, &fakeConfig{I: 4, S: "four", Ptr: &fakeConfig{I: 5, S: "five"}}}, + } + + for i, testCase := range testCases { + t.Run(strconv.Itoa(i), func(t *testing.T) { + input, expected := testCase.first, testCase.second + actual, err := DeepCopyConfig(input) + assert.NoError(t, err) + assert.Equal(t, reflect.TypeOf(expected).String(), reflect.TypeOf(actual).String()) + assert.Equal(t, expected, actual) + }) + } +} diff --git a/flytestdlib/config/viper/collection.go b/flytestdlib/config/viper/collection.go new file mode 100644 index 0000000000..eefb64613e --- /dev/null +++ b/flytestdlib/config/viper/collection.go @@ -0,0 +1,173 @@ +package viper + +import ( + "context" + "fmt" + "io" + "os" + "strings" + + "github.com/fsnotify/fsnotify" + "github.com/spf13/pflag" + viperLib "github.com/spf13/viper" + + "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +type Viper interface { + BindPFlags(flags *pflag.FlagSet) error + BindEnv(input ...string) error + AutomaticEnv() + ReadInConfig() error + OnConfigChange(run func(in fsnotify.Event)) + WatchConfig() + AllSettings() map[string]interface{} + ConfigFileUsed() string + MergeConfig(in io.Reader) error +} + +// A proxy object for a collection of Viper instances. +type CollectionProxy struct { + underlying []Viper + pflags *pflag.FlagSet + envVars [][]string + automaticEnv bool +} + +func (c *CollectionProxy) BindPFlags(flags *pflag.FlagSet) error { + err := errors.ErrorCollection{} + for _, v := range c.underlying { + err.Append(v.BindPFlags(flags)) + } + + c.pflags = flags + + return err.ErrorOrDefault() +} + +func (c *CollectionProxy) BindEnv(input ...string) error { + err := errors.ErrorCollection{} + for _, v := range c.underlying { + err.Append(v.BindEnv(input...)) + } + + if c.envVars == nil { + c.envVars = make([][]string, 0, 1) + } + + c.envVars = append(c.envVars, input) + + return err.ErrorOrDefault() +} + +func (c *CollectionProxy) AutomaticEnv() { + for _, v := range c.underlying { + v.AutomaticEnv() + } + + c.automaticEnv = true +} + +func (c CollectionProxy) ReadInConfig() error { + err := errors.ErrorCollection{} + for _, v := range c.underlying { + err.Append(v.ReadInConfig()) + } + + return err.ErrorOrDefault() +} + +func (c CollectionProxy) OnConfigChange(run func(in fsnotify.Event)) { + for _, v := range c.underlying { + v.OnConfigChange(run) + } +} + +func (c CollectionProxy) WatchConfig() { + for _, v := range c.underlying { + v.WatchConfig() + } +} + +func (c CollectionProxy) AllSettings() map[string]interface{} { + finalRes := map[string]interface{}{} + if len(c.underlying) == 0 { + return finalRes + } + + combinedConfig, err := c.MergeAllConfigs() + if err != nil { + logger.Warnf(context.TODO(), "Failed to merge config. Error: %v", err) + return finalRes + } + + return combinedConfig.AllSettings() +} + +func (c CollectionProxy) ConfigFileUsed() string { + return fmt.Sprintf("[%v]", strings.Join(c.ConfigFilesUsed(), ",")) +} + +func (c CollectionProxy) MergeConfig(in io.Reader) error { + panic("Not yet implemented.") +} + +func (c CollectionProxy) MergeAllConfigs() (all Viper, err error) { + combinedConfig := viperLib.New() + if c.envVars != nil { + for _, envConfig := range c.envVars { + err = combinedConfig.BindEnv(envConfig...) + if err != nil { + return nil, err + } + } + } + + if c.automaticEnv { + combinedConfig.AutomaticEnv() + } + + if c.pflags != nil { + err = combinedConfig.BindPFlags(c.pflags) + if err != nil { + return nil, err + } + } + + for _, v := range c.underlying { + if _, isCollection := v.(*CollectionProxy); isCollection { + return nil, fmt.Errorf("merging nested CollectionProxies is not yet supported") + } + + if len(v.ConfigFileUsed()) == 0 { + continue + } + + combinedConfig.SetConfigFile(v.ConfigFileUsed()) + + reader, err := os.Open(v.ConfigFileUsed()) + if err != nil { + return nil, err + } + + err = combinedConfig.MergeConfig(reader) + if err != nil { + return nil, err + } + } + + return combinedConfig, nil +} + +func (c CollectionProxy) ConfigFilesUsed() []string { + res := make([]string, 0, len(c.underlying)) + for _, v := range c.underlying { + filePath := v.ConfigFileUsed() + if len(filePath) > 0 { + res = append(res, filePath) + } + } + + return res +} diff --git a/flytestdlib/config/viper/viper.go b/flytestdlib/config/viper/viper.go new file mode 100644 index 0000000000..8f35a67643 --- /dev/null +++ b/flytestdlib/config/viper/viper.go @@ -0,0 +1,444 @@ +package viper + +import ( + "context" + "encoding/base64" + "encoding/json" + "flag" + "fmt" + "reflect" + "strings" + "sync" + + "github.com/fsnotify/fsnotify" + "github.com/mitchellh/mapstructure" + "github.com/pkg/errors" + "github.com/spf13/cobra" + "github.com/spf13/pflag" + viperLib "github.com/spf13/viper" + "k8s.io/apimachinery/pkg/util/sets" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/config/files" + stdLibErrs "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +const ( + keyDelim = "." +) + +var ( + dereferencableKinds = map[reflect.Kind]struct{}{ + reflect.Array: {}, reflect.Chan: {}, reflect.Map: {}, reflect.Ptr: {}, reflect.Slice: {}, + } +) + +type viperAccessor struct { + // Determines whether parsing config should fail if it contains un-registered sections. + strictMode bool + viper *CollectionProxy + rootConfig config.Section + // Ensures we initialize the file Watcher once. + watcherInitializer *sync.Once + existingFlagKeys sets.String +} + +func (viperAccessor) ID() string { + return "Viper" +} + +func (viperAccessor) InitializeFlags(cmdFlags *flag.FlagSet) { + // TODO: Implement? +} + +func (v *viperAccessor) InitializePflags(cmdFlags *pflag.FlagSet) { + existingFlagKeys := sets.NewString() + cmdFlags.VisitAll(func(f *pflag.Flag) { + existingFlagKeys.Insert(f.Name) + if len(f.Shorthand) > 0 { + existingFlagKeys.Insert(f.Shorthand) + } + }) + + v.existingFlagKeys = existingFlagKeys + + err := v.addSectionsPFlags(cmdFlags) + if err != nil { + panic(errors.Wrap(err, "error adding config PFlags to flag set")) + } + + // Allow viper to read the value of the flags + err = v.viper.BindPFlags(cmdFlags) + if err != nil { + panic(errors.Wrap(err, "error binding PFlags")) + } +} + +func (v viperAccessor) addSectionsPFlags(flags *pflag.FlagSet) (err error) { + return v.addSubsectionsPFlags(flags, "", v.rootConfig) +} + +func (v viperAccessor) addSubsectionsPFlags(flags *pflag.FlagSet, rootKey string, root config.Section) error { + for key, section := range root.GetSections() { + prefix := rootKey + key + keyDelim + if asPFlagProvider, ok := section.GetConfig().(config.PFlagProvider); ok { + flags.AddFlagSet(asPFlagProvider.GetPFlagSet(prefix)) + } + + if err := v.addSubsectionsPFlags(flags, prefix, section); err != nil { + return err + } + } + + return nil +} + +// Binds keys from all sections to viper env vars. This instructs viper to lookup those from env vars when we ask for +// viperLib.AllSettings() +func (v viperAccessor) bindViperConfigsFromEnv(root config.Section) (err error) { + allConfigs, err := config.AllConfigsAsMap(root) + if err != nil { + return err + } + + return v.bindViperConfigsEnvDepth(allConfigs, "") +} + +func (v viperAccessor) bindViperConfigsEnvDepth(m map[string]interface{}, prefix string) error { + errs := stdLibErrs.ErrorCollection{} + for key, val := range m { + subKey := prefix + key + if asMap, ok := val.(map[string]interface{}); ok { + errs.Append(v.bindViperConfigsEnvDepth(asMap, subKey+keyDelim)) + } else { + errs.Append(v.viper.BindEnv(subKey, strings.ToUpper(strings.ReplaceAll(subKey, "-", "_")))) + } + } + + return errs.ErrorOrDefault() +} + +func (v viperAccessor) updateConfig(ctx context.Context, r config.Section) error { + // Binds all keys to env vars. + err := v.bindViperConfigsFromEnv(r) + if err != nil { + return err + } + + v.viper.AutomaticEnv() // read in environment variables that match + + shouldWatchChanges := true + // If a config file is found, read it in. + if err = v.viper.ReadInConfig(); err == nil { + logger.Debugf(ctx, "Using config file: %+v", v.viper.ConfigFilesUsed()) + } else if asErrorCollection, ok := err.(stdLibErrs.ErrorCollection); ok { + shouldWatchChanges = false + for i, e := range asErrorCollection { + if _, isNotFound := errors.Cause(e).(viperLib.ConfigFileNotFoundError); isNotFound { + logger.Infof(ctx, "[%v] Couldn't find a config file [%v]. Relying on env vars and pflags.", + i, v.viper.underlying[i].ConfigFileUsed()) + } else { + return err + } + } + } else if reflect.TypeOf(err) == reflect.TypeOf(viperLib.ConfigFileNotFoundError{}) { + shouldWatchChanges = false + logger.Info(ctx, "Couldn't find a config file. Relying on env vars and pflags.") + } else { + return err + } + + if shouldWatchChanges { + v.watcherInitializer.Do(func() { + // Watch config files to pick up on file changes without requiring a full application restart. + // This call must occur after *all* config paths have been added. + v.viper.OnConfigChange(func(e fsnotify.Event) { + logger.Debugf(ctx, "Got a notification change for file [%v] \n", e.Name) + v.configChangeHandler() + }) + v.viper.WatchConfig() + }) + } + + return v.RefreshFromConfig(ctx, r, true) +} + +func (v viperAccessor) UpdateConfig(ctx context.Context) error { + return v.updateConfig(ctx, v.rootConfig) +} + +// Checks if t is a kind that can be dereferenced to get its underlying type. +func canGetElement(t reflect.Kind) bool { + _, exists := dereferencableKinds[t] + return exists +} + +// sliceToMapHook allows the conversion from slices to maps. This is used as a hack due to the lack of support of case +// sensitive keys in viper (see: https://github.com/spf13/viper#does-viper-support-case-sensitive-keys). The way we work +// around that is by filling in fields that should be maps as slices in yaml config files. This hook then takes care of +// reverting that process. +func sliceToMapHook(f reflect.Kind, t reflect.Kind, data interface{}) (interface{}, error) { + // Only handle slice -> map conversion + if f == reflect.Slice && t == reflect.Map { + // this will be the target result + res := map[interface{}]interface{}{} + // It's safe to convert data into a slice since we did the type assertion above. + asSlice := data.([]interface{}) + for _, item := range asSlice { + asMap, casted := item.(map[interface{}]interface{}) + if !casted { + return data, nil + } + + for key, value := range asMap { + res[key] = value + } + } + + return res, nil + } + + return data, nil +} + +// stringToByteArray allows the conversion from strings to []byte. mapstructure's default behavior involve converting +// each element as a uint8 before assembling the final []byte. +func stringToByteArray(f, t reflect.Type, data interface{}) (interface{}, error) { + // Only handle string -> []byte conversion + if t.Kind() != reflect.Slice || t.Elem().Kind() != reflect.Uint8 { + return data, nil + } + + asStr := "" + if f.Kind() == reflect.String { + asStr = data.(string) + } else if f.Kind() == reflect.Slice && f.Elem().Kind() == reflect.String { + asSlice := data.([]string) + if len(asSlice) == 0 { + return data, nil + } + + asStr = asSlice[0] + } + + b := make([]byte, base64.StdEncoding.DecodedLen(len(asStr))) + n, err := base64.StdEncoding.Decode(b, []byte(asStr)) + if err != nil { + return nil, err + } + + return b[:n], nil +} + +// This decoder hook tests types for json unmarshaling capability. If implemented, it uses json unmarshal to build the +// object. Otherwise, it'll just pass on the original data. +func jsonUnmarshallerHook(_, to reflect.Type, data interface{}) (interface{}, error) { + unmarshalerType := reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + if to.Implements(unmarshalerType) || reflect.PtrTo(to).Implements(unmarshalerType) || + (canGetElement(to.Kind()) && to.Elem().Implements(unmarshalerType)) { + + ctx := context.Background() + raw, err := json.Marshal(data) + if err != nil { + logger.Errorf(ctx, "Failed to marshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + res := reflect.New(to).Interface() + err = json.Unmarshal(raw, &res) + if err != nil { + logger.Errorf(ctx, "Failed to umarshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + return res, nil + } + + return data, nil +} + +// Parses RootType config from parsed Viper settings. This should be called after viper has parsed config file/pflags...etc. +func (v viperAccessor) parseViperConfig(root config.Section) error { + // We use AllSettings instead of AllKeys to get the root level keys folded. + return v.parseViperConfigRecursive(root, v.viper.AllSettings()) +} + +func (v viperAccessor) parseViperConfigRecursive(root config.Section, settings interface{}) error { + errs := stdLibErrs.ErrorCollection{} + var mine interface{} + myKeysCount := 0 + discoveredKeys := sets.NewString() + if asMap, casted := settings.(map[string]interface{}); casted { + myMap := map[string]interface{}{} + for childKey, childValue := range asMap { + if childSection, found := root.GetSections()[childKey]; found { + errs.Append(v.parseViperConfigRecursive(childSection, childValue)) + } else { + discoveredKeys.Insert(childKey) + myMap[childKey] = childValue + } + } + + mine = myMap + myKeysCount = len(myMap) + } else if asSlice, casted := settings.([]interface{}); casted { + mine = settings + myKeysCount = len(asSlice) + } else { + discoveredKeys.Insert(fmt.Sprintf("%v", mine)) + mine = settings + if settings != nil { + myKeysCount = 1 + } + } + + if root.GetConfig() != nil { + c, err := config.DeepCopyConfig(root.GetConfig()) + errs.Append(err) + if err != nil { + return errs.ErrorOrDefault() + } + + errs.Append(decode(mine, defaultDecoderConfig(c, v.decoderConfigs()...))) + errs.Append(root.SetConfig(c)) + + return errs.ErrorOrDefault() + } else if myKeysCount > 0 { + // There are keys set that are meant to be decoded but no config to receive them. Fail if strict mode is on. + if v.strictMode { + if newKeys := discoveredKeys.Difference(v.existingFlagKeys); newKeys.Len() > 0 { + errs.Append(errors.Wrap( + config.ErrStrictModeValidation, + fmt.Sprintf("strict mode is on but received keys [%+v] to decode with no config assigned to"+ + " receive them", newKeys))) + } + } + } + + return errs.ErrorOrDefault() +} + +// Adds any specific configs controlled by this viper accessor instance. +func (v viperAccessor) decoderConfigs() []viperLib.DecoderConfigOption { + return []viperLib.DecoderConfigOption{ + func(config *mapstructure.DecoderConfig) { + config.ErrorUnused = v.strictMode + }, + } +} + +// defaultDecoderConfig returns default mapsstructure.DecoderConfig with support +// of time.Duration values & string slices +func defaultDecoderConfig(output interface{}, opts ...viperLib.DecoderConfigOption) *mapstructure.DecoderConfig { + c := &mapstructure.DecoderConfig{ + Metadata: nil, + Result: output, + WeaklyTypedInput: true, + TagName: "json", + DecodeHook: mapstructure.ComposeDecodeHookFunc( + jsonUnmarshallerHook, + mapstructure.StringToTimeDurationHookFunc(), + mapstructure.StringToSliceHookFunc(","), + sliceToMapHook, + stringToByteArray, + ), + // Empty/zero fields before applying provided values. This avoids potentially undesired/unexpected merging logic. + ZeroFields: true, + } + + for _, opt := range opts { + opt(c) + } + + return c +} + +// A wrapper around mapstructure.Decode that mimics the WeakDecode functionality +func decode(input interface{}, config *mapstructure.DecoderConfig) error { + decoder, err := mapstructure.NewDecoder(config) + if err != nil { + return err + } + return decoder.Decode(input) +} + +func (v viperAccessor) configChangeHandler() { + ctx := context.Background() + err := v.RefreshFromConfig(ctx, v.rootConfig, false) + if err != nil { + // TODO: Retry? panic? + logger.Errorf(ctx, "Failed to update config. Error: %v", err) + } else { + logger.Infof(ctx, "Refreshed config in response to file(s) change.") + } +} + +func (v viperAccessor) RefreshFromConfig(ctx context.Context, r config.Section, forceSendUpdates bool) error { + err := v.parseViperConfig(r) + if err != nil { + return err + } + + v.sendUpdatedEvents(ctx, r, forceSendUpdates, "") + + return nil +} + +func (v viperAccessor) sendUpdatedEvents(ctx context.Context, root config.Section, forceSend bool, sectionKey config.SectionKey) { + for key, section := range root.GetSections() { + if !section.GetConfigChangedAndClear() && !forceSend { + logger.Debugf(ctx, "Config section [%v] hasn't changed.", sectionKey+key) + } else if section.GetConfigUpdatedHandler() == nil { + logger.Debugf(ctx, "Config section [%v] updated. No update handler registered.", sectionKey+key) + } else { + logger.Debugf(ctx, "Config section [%v] updated. Firing updated event.", sectionKey+key) + section.GetConfigUpdatedHandler()(ctx, section.GetConfig()) + } + + v.sendUpdatedEvents(ctx, section, forceSend, sectionKey+key+keyDelim) + } +} + +func (v viperAccessor) ConfigFilesUsed() []string { + return v.viper.ConfigFilesUsed() +} + +// Creates a config accessor that implements Accessor interface and uses viper to load configs. +func NewAccessor(opts config.Options) config.Accessor { + return newAccessor(opts) +} + +func newAccessor(opts config.Options) *viperAccessor { + vipers := make([]Viper, 0, 1) + configFiles := files.FindConfigFiles(opts.SearchPaths) + for _, configFile := range configFiles { + v := viperLib.New() + v.SetConfigFile(configFile) + + vipers = append(vipers, v) + } + + // Create a default viper even if we couldn't find any matching files + if len(configFiles) == 0 { + v := viperLib.New() + vipers = append(vipers, v) + } + + r := opts.RootSection + if r == nil { + r = config.GetRootSection() + } + + return &viperAccessor{ + strictMode: opts.StrictMode, + rootConfig: r, + viper: &CollectionProxy{underlying: vipers}, + watcherInitializer: &sync.Once{}, + } +} + +// Gets the root level command that can be added to any cobra-powered cli to get config* commands. +func GetConfigCommand() *cobra.Command { + return config.NewConfigCommand(NewAccessor) +} diff --git a/flytestdlib/config/viper/viper_test.go b/flytestdlib/config/viper/viper_test.go new file mode 100644 index 0000000000..881d4436f2 --- /dev/null +++ b/flytestdlib/config/viper/viper_test.go @@ -0,0 +1,54 @@ +package viper + +import ( + "encoding/base64" + "reflect" + "testing" + + "github.com/stretchr/testify/assert" +) + +func Test_stringToByteArray(t *testing.T) { + t.Run("Expected types", func(t *testing.T) { + input := "hello world" + base64Encoded := base64.StdEncoding.EncodeToString([]byte(input)) + res, err := stringToByteArray(reflect.TypeOf(base64Encoded), reflect.TypeOf([]byte{}), base64Encoded) + assert.NoError(t, err) + assert.Equal(t, []byte(input), res) + }) + + t.Run("Expected types - array string", func(t *testing.T) { + input := []string{"hello world"} + base64Encoded := base64.StdEncoding.EncodeToString([]byte(input[0])) + res, err := stringToByteArray(reflect.TypeOf(input), reflect.TypeOf([]byte{}), []string{base64Encoded}) + assert.NoError(t, err) + assert.Equal(t, []byte(input[0]), res) + }) + + t.Run("Expected types - invalid encoding", func(t *testing.T) { + input := []string{"hello world"} + _, err := stringToByteArray(reflect.TypeOf(input), reflect.TypeOf([]byte{}), []string{"invalid base64"}) + assert.Error(t, err) + }) + + t.Run("Expected types - empty array string", func(t *testing.T) { + input := []string{"hello world"} + res, err := stringToByteArray(reflect.TypeOf(input), reflect.TypeOf([]byte{}), []string{}) + assert.NoError(t, err) + assert.Equal(t, []string{}, res) + }) + + t.Run("Unexpected types", func(t *testing.T) { + input := 5 + res, err := stringToByteArray(reflect.TypeOf(input), reflect.TypeOf([]byte{}), input) + assert.NoError(t, err) + assert.NotEqual(t, []byte("hello"), res) + }) + + t.Run("Unexpected types", func(t *testing.T) { + input := 5 + res, err := stringToByteArray(reflect.TypeOf(input), reflect.TypeOf(""), input) + assert.NoError(t, err) + assert.NotEqual(t, []byte("hello"), res) + }) +} diff --git a/flytestdlib/contextutils/context.go b/flytestdlib/contextutils/context.go new file mode 100644 index 0000000000..504ce767e9 --- /dev/null +++ b/flytestdlib/contextutils/context.go @@ -0,0 +1,197 @@ +// Package contextutils contains common flyte context utils. +package contextutils + +import ( + "context" + "fmt" + "runtime/pprof" + + "google.golang.org/grpc/metadata" +) + +type Key string + +const ( + AppNameKey Key = "app_name" + NamespaceKey Key = "ns" + TaskTypeKey Key = "tasktype" + ProjectKey Key = "project" + DomainKey Key = "domain" + WorkflowIDKey Key = "wf" + NodeIDKey Key = "node" + TaskIDKey Key = "task" + // Adding the ExecIDKey label to a metric will cause higher cardinality. Use with caution. + ExecIDKey Key = "exec_id" + JobIDKey Key = "job_id" + PhaseKey Key = "phase" + RoutineLabelKey Key = "routine" + LaunchPlanIDKey Key = "lp" + ResourceVersionKey Key = "res_ver" + SignalIDKey Key = "signal" + RequestIDKey Key = "x-request-id" +) + +func (k Key) String() string { + return string(k) +} + +var logKeys = []Key{ + AppNameKey, + JobIDKey, + NamespaceKey, + ExecIDKey, + NodeIDKey, + WorkflowIDKey, + TaskTypeKey, + PhaseKey, + RoutineLabelKey, + LaunchPlanIDKey, + ResourceVersionKey, + RequestIDKey, +} + +// MetricKeysFromStrings is a convenience method to convert a slice of strings into a slice of Keys +func MetricKeysFromStrings(keys []string) []Key { + res := make([]Key, 0, len(keys)) + + for _, k := range keys { + res = append(res, Key(k)) + } + + return res +} + +// WithResourceVersion gets a new context with the resource version set. +func WithResourceVersion(ctx context.Context, resourceVersion string) context.Context { + return context.WithValue(ctx, ResourceVersionKey, resourceVersion) +} + +// WithNamespace gets a new context with namespace set. +func WithNamespace(ctx context.Context, namespace string) context.Context { + return context.WithValue(ctx, NamespaceKey, namespace) +} + +// WithJobID gets a new context with JobId set. If the existing context already has a job id, the new context will have +// / set as the job id. +func WithJobID(ctx context.Context, jobID string) context.Context { + existingJobID := ctx.Value(JobIDKey) + if existingJobID != nil { + jobID = fmt.Sprintf("%v/%v", existingJobID, jobID) + } + + return context.WithValue(ctx, JobIDKey, jobID) +} + +// WithAppName gets a new context with AppName set. +func WithAppName(ctx context.Context, appName string) context.Context { + return context.WithValue(ctx, AppNameKey, appName) +} + +// WithPhase gets a new context with Phase set. +func WithPhase(ctx context.Context, phase string) context.Context { + return context.WithValue(ctx, PhaseKey, phase) +} + +// WithExecutionID gets a new context with ExecutionID set. +func WithExecutionID(ctx context.Context, execID string) context.Context { + return context.WithValue(ctx, ExecIDKey, execID) +} + +// WithNodeID gets a new context with NodeID (nested) set. +func WithNodeID(ctx context.Context, nodeID string) context.Context { + existingNodeID := ctx.Value(NodeIDKey) + if existingNodeID != nil { + nodeID = fmt.Sprintf("%v/%v", existingNodeID, nodeID) + } + return context.WithValue(ctx, NodeIDKey, nodeID) +} + +// WithWorkflowID gets a new context with WorkflowName set. +func WithWorkflowID(ctx context.Context, workflow string) context.Context { + return context.WithValue(ctx, WorkflowIDKey, workflow) +} + +// WithLaunchPlanID gets a new context with a launch plan ID set. +func WithLaunchPlanID(ctx context.Context, launchPlan string) context.Context { + return context.WithValue(ctx, LaunchPlanIDKey, launchPlan) +} + +// WithProjectDomain gets new context with Project and Domain values set +func WithProjectDomain(ctx context.Context, project, domain string) context.Context { + c := context.WithValue(ctx, ProjectKey, project) + return context.WithValue(c, DomainKey, domain) +} + +// WithTaskID gets a new context with WorkflowName set. +func WithTaskID(ctx context.Context, taskID string) context.Context { + return context.WithValue(ctx, TaskIDKey, taskID) +} + +// WithTaskType gets a new context with TaskType set. +func WithTaskType(ctx context.Context, taskType string) context.Context { + return context.WithValue(ctx, TaskTypeKey, taskType) +} + +// WithSignalID gets a new context with SignalID set. +func WithSignalID(ctx context.Context, signalID string) context.Context { + return context.WithValue(ctx, SignalIDKey, signalID) +} + +// WithRequestID gets a new context with RequestID set. +func WithRequestID(ctx context.Context, requestID string) context.Context { + return metadata.AppendToOutgoingContext(context.WithValue(ctx, RequestIDKey, requestID), RequestIDKey.String(), requestID) +} + +// WithGoroutineLabel gets a new context with Go Routine label key set and a label assigned to the context using +// pprof.Labels. +// You can then call pprof.SetGoroutineLabels(ctx) to annotate the current go-routine and have that show up in +// pprof analysis. +func WithGoroutineLabel(ctx context.Context, routineLabel string) context.Context { + ctx = pprof.WithLabels(ctx, pprof.Labels(RoutineLabelKey.String(), routineLabel)) + return context.WithValue(ctx, RoutineLabelKey, routineLabel) +} + +func addFieldIfNotNil(ctx context.Context, m map[string]interface{}, fieldKey Key) { + val := ctx.Value(fieldKey) + if val != nil { + m[fieldKey.String()] = val + } +} + +func addStringFieldWithDefaults(ctx context.Context, m map[string]string, fieldKey Key) { + val := ctx.Value(fieldKey) + if val == nil { + val = "" + } + + m[fieldKey.String()] = val.(string) +} + +// GetLogFields gets a map of all known logKeys set on the context. logKeys are special and should be used in case, +// context fields are to be added to the log lines. +func GetLogFields(ctx context.Context) map[string]interface{} { + res := map[string]interface{}{} + for _, k := range logKeys { + addFieldIfNotNil(ctx, res, k) + } + + return res +} + +func Value(ctx context.Context, key Key) string { + val := ctx.Value(key) + if val != nil { + return val.(string) + } + + return "" +} + +func Values(ctx context.Context, keys ...Key) map[string]string { + res := map[string]string{} + for _, k := range keys { + addStringFieldWithDefaults(ctx, res, k) + } + + return res +} diff --git a/flytestdlib/contextutils/context_test.go b/flytestdlib/contextutils/context_test.go new file mode 100644 index 0000000000..976a2184be --- /dev/null +++ b/flytestdlib/contextutils/context_test.go @@ -0,0 +1,138 @@ +package contextutils + +import ( + "context" + "runtime/pprof" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestWithAppName(t *testing.T) { + ctx := context.Background() + assert.Nil(t, ctx.Value(AppNameKey)) + ctx = WithAppName(ctx, "application-name-123") + assert.Equal(t, "application-name-123", ctx.Value(AppNameKey)) + + ctx = WithAppName(ctx, "app-name-modified") + assert.Equal(t, "app-name-modified", ctx.Value(AppNameKey)) +} + +func TestWithPhase(t *testing.T) { + ctx := context.Background() + assert.Nil(t, ctx.Value(PhaseKey)) + ctx = WithPhase(ctx, "Running") + assert.Equal(t, "Running", ctx.Value(PhaseKey)) + + ctx = WithPhase(ctx, "Failed") + assert.Equal(t, "Failed", ctx.Value(PhaseKey)) +} + +func TestWithJobId(t *testing.T) { + ctx := context.Background() + assert.Nil(t, ctx.Value(JobIDKey)) + ctx = WithJobID(ctx, "job123") + assert.Equal(t, "job123", ctx.Value(JobIDKey)) + + ctx = WithJobID(ctx, "subtask") + assert.Equal(t, "job123/subtask", ctx.Value(JobIDKey)) +} + +func TestWithNamespace(t *testing.T) { + ctx := context.Background() + assert.Nil(t, ctx.Value(NamespaceKey)) + ctx = WithNamespace(ctx, "flyte") + assert.Equal(t, "flyte", ctx.Value(NamespaceKey)) + + ctx = WithNamespace(ctx, "flyte2") + assert.Equal(t, "flyte2", ctx.Value(NamespaceKey)) +} + +func TestWithExecutionID(t *testing.T) { + ctx := context.Background() + assert.Nil(t, ctx.Value(ExecIDKey)) + ctx = WithExecutionID(ctx, "job123") + assert.Equal(t, "job123", ctx.Value(ExecIDKey)) +} + +func TestWithTaskType(t *testing.T) { + ctx := context.Background() + assert.Nil(t, ctx.Value(TaskTypeKey)) + ctx = WithTaskType(ctx, "flyte") + assert.Equal(t, "flyte", ctx.Value(TaskTypeKey)) +} + +func TestWithWorkflowID(t *testing.T) { + ctx := context.Background() + assert.Nil(t, ctx.Value(WorkflowIDKey)) + ctx = WithWorkflowID(ctx, "flyte") + assert.Equal(t, "flyte", ctx.Value(WorkflowIDKey)) +} + +func TestWithLaunchPlanID(t *testing.T) { + ctx := context.Background() + assert.Nil(t, ctx.Value(LaunchPlanIDKey)) + ctx = WithLaunchPlanID(ctx, "flytelp") + assert.Equal(t, "flytelp", ctx.Value(LaunchPlanIDKey)) +} + +func TestWithNodeID(t *testing.T) { + ctx := context.Background() + assert.Nil(t, ctx.Value(NodeIDKey)) + ctx = WithNodeID(ctx, "n1") + assert.Equal(t, "n1", ctx.Value(NodeIDKey)) + + ctx = WithNodeID(ctx, "n2") + assert.Equal(t, "n1/n2", ctx.Value(NodeIDKey)) +} + +func TestWithProjectDomain(t *testing.T) { + ctx := context.Background() + assert.Nil(t, ctx.Value(ProjectKey)) + assert.Nil(t, ctx.Value(DomainKey)) + ctx = WithProjectDomain(ctx, "proj", "domain") + assert.Equal(t, "proj", ctx.Value(ProjectKey)) + assert.Equal(t, "domain", ctx.Value(DomainKey)) +} + +func TestWithTaskID(t *testing.T) { + ctx := context.Background() + assert.Nil(t, ctx.Value(TaskIDKey)) + ctx = WithTaskID(ctx, "task") + assert.Equal(t, "task", ctx.Value(TaskIDKey)) +} + +func TestWithSignalID(t *testing.T) { + ctx := context.Background() + assert.Nil(t, ctx.Value(SignalIDKey)) + ctx = WithSignalID(ctx, "signal") + assert.Equal(t, "signal", ctx.Value(SignalIDKey)) +} + +func TestGetFields(t *testing.T) { + ctx := context.Background() + ctx = WithRequestID(WithJobID(WithNamespace(ctx, "ns123"), "job123"), "req123") + m := GetLogFields(ctx) + assert.Equal(t, "ns123", m[NamespaceKey.String()]) + assert.Equal(t, "job123", m[JobIDKey.String()]) + assert.Equal(t, "req123", m[RequestIDKey.String()]) +} + +func TestValues(t *testing.T) { + ctx := context.Background() + ctx = WithWorkflowID(ctx, "flyte") + m := Values(ctx, ProjectKey, WorkflowIDKey) + assert.NotNil(t, m) + assert.Equal(t, 2, len(m)) + assert.Equal(t, "flyte", m[WorkflowIDKey.String()]) + assert.Equal(t, "", m[ProjectKey.String()]) +} + +func TestWithGoroutineLabel(t *testing.T) { + ctx := context.Background() + ctx = WithGoroutineLabel(ctx, "my_routine_123") + pprof.SetGoroutineLabels(ctx) + m := Values(ctx, RoutineLabelKey) + assert.Equal(t, 1, len(m)) + assert.Equal(t, "my_routine_123", m[RoutineLabelKey.String()]) +} diff --git a/flytestdlib/database/config.go b/flytestdlib/database/config.go new file mode 100644 index 0000000000..dbe4d616fc --- /dev/null +++ b/flytestdlib/database/config.go @@ -0,0 +1,118 @@ +package database + +import ( + "time" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" +) + +const ( + database = "database" + postgresStr = "postgres" +) + +//go:generate pflags DbConfig --default-var=defaultConfig + +var defaultConfig = &DbConfig{ + MaxIdleConnections: 10, + MaxOpenConnections: 100, + ConnMaxLifeTime: config.Duration{Duration: time.Hour}, + Postgres: PostgresConfig{ + // These values are suitable for local sandbox development + Host: "localhost", + ReadReplicaHost: "localhost", + Port: 30001, + DbName: postgresStr, + User: postgresStr, + Password: postgresStr, + ExtraOptions: "sslmode=disable", + }, +} +var configSection = config.MustRegisterSection(database, defaultConfig) + +// DbConfig is used to for initiating the database connection with the store that holds registered +// entities (e.g. workflows, tasks, launch plans...) +type DbConfig struct { + // deprecated: Please use Postgres.Host + DeprecatedHost string `json:"host" pflag:"-,deprecated"` + // deprecated: Please use Postgres.Port + DeprecatedPort int `json:"port" pflag:"-,deprecated"` + // deprecated: Please use Postgres.DbName + DeprecatedDbName string `json:"dbname" pflag:"-,deprecated"` + // deprecated: Please use Postgres.User + DeprecatedUser string `json:"username" pflag:"-,deprecated"` + // deprecated: Please use Postgres.Password + DeprecatedPassword string `json:"password" pflag:"-,deprecated"` + // deprecated: Please use Postgres.PasswordPath + DeprecatedPasswordPath string `json:"passwordPath" pflag:"-,deprecated"` + // deprecated: Please use Postgres.ExtraOptions + DeprecatedExtraOptions string `json:"options" pflag:"-,deprecated"` + // deprecated: Please use Postgres.Debug + DeprecatedDebug bool `json:"debug" pflag:"-,deprecated"` + + EnableForeignKeyConstraintWhenMigrating bool `json:"enableForeignKeyConstraintWhenMigrating" pflag:",Whether to enable gorm foreign keys when migrating the db"` + MaxIdleConnections int `json:"maxIdleConnections" pflag:",maxIdleConnections sets the maximum number of connections in the idle connection pool."` + MaxOpenConnections int `json:"maxOpenConnections" pflag:",maxOpenConnections sets the maximum number of open connections to the database."` + ConnMaxLifeTime config.Duration `json:"connMaxLifeTime" pflag:",sets the maximum amount of time a connection may be reused"` + Postgres PostgresConfig `json:"postgres,omitempty"` + SQLite SQLiteConfig `json:"sqlite,omitempty"` +} + +// SQLiteConfig can be used to configure +type SQLiteConfig struct { + File string `json:"file" pflag:",The path to the file (existing or new) where the DB should be created / stored. If existing, then this will be reused, else a new will be created"` +} + +// PostgresConfig includes specific config options for opening a connection to a postgres database. +type PostgresConfig struct { + Host string `json:"host" pflag:",The host name of the database server"` + ReadReplicaHost string `json:"readReplicaHost" pflag:",The host name of the read replica database server"` + Port int `json:"port" pflag:",The port name of the database server"` + DbName string `json:"dbname" pflag:",The database name"` + User string `json:"username" pflag:",The database user who is connecting to the server."` + // Either Password or PasswordPath must be set. + Password string `json:"password" pflag:",The database password."` + PasswordPath string `json:"passwordPath" pflag:",Points to the file containing the database password."` + ExtraOptions string `json:"options" pflag:",See http://gorm.io/docs/connecting_to_the_database.html for available options passed, in addition to the above."` + Debug bool `json:"debug" pflag:" Whether or not to start the database connection with debug mode enabled."` +} + +var emptySQLiteCfg = SQLiteConfig{} +var emptyPostgresConfig = PostgresConfig{} + +func (s SQLiteConfig) IsEmpty() bool { + return s == emptySQLiteCfg +} + +func (s PostgresConfig) IsEmpty() bool { + return s == emptyPostgresConfig +} + +func GetConfig() *DbConfig { + databaseConfig := configSection.GetConfig().(*DbConfig) + if len(databaseConfig.DeprecatedHost) > 0 { + databaseConfig.Postgres.Host = databaseConfig.DeprecatedHost + } + if databaseConfig.DeprecatedPort != 0 { + databaseConfig.Postgres.Port = databaseConfig.DeprecatedPort + } + if len(databaseConfig.DeprecatedDbName) > 0 { + databaseConfig.Postgres.DbName = databaseConfig.DeprecatedDbName + } + if len(databaseConfig.DeprecatedUser) > 0 { + databaseConfig.Postgres.User = databaseConfig.DeprecatedUser + } + if len(databaseConfig.DeprecatedPassword) > 0 { + databaseConfig.Postgres.Password = databaseConfig.DeprecatedPassword + } + if len(databaseConfig.DeprecatedPasswordPath) > 0 { + databaseConfig.Postgres.PasswordPath = databaseConfig.DeprecatedPasswordPath + } + if len(databaseConfig.DeprecatedExtraOptions) > 0 { + databaseConfig.Postgres.ExtraOptions = databaseConfig.DeprecatedExtraOptions + } + if databaseConfig.DeprecatedDebug { + databaseConfig.Postgres.Debug = databaseConfig.DeprecatedDebug + } + return databaseConfig +} diff --git a/flytestdlib/database/config_test.go b/flytestdlib/database/config_test.go new file mode 100644 index 0000000000..6145500741 --- /dev/null +++ b/flytestdlib/database/config_test.go @@ -0,0 +1,42 @@ +package database + +import ( + "context" + "path/filepath" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/config/viper" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +func TestParseDatabaseConfig(t *testing.T) { + assert.NoError(t, logger.SetConfig(&logger.Config{IncludeSourceCode: true})) + + accessor := viper.NewAccessor(config.Options{ + RootSection: configSection, + SearchPaths: []string{filepath.Join("testdata", "config.yaml")}, + }) + + assert.NoError(t, accessor.UpdateConfig(context.Background())) + + assert.Equal(t, false, GetConfig().EnableForeignKeyConstraintWhenMigrating) + assert.Equal(t, 100, GetConfig().MaxOpenConnections) + assert.Equal(t, 10, GetConfig().MaxIdleConnections) + assert.Equal(t, config.Duration{Duration: 3600000000000}, GetConfig().ConnMaxLifeTime) + + assert.Equal(t, false, GetConfig().Postgres.IsEmpty()) + assert.Equal(t, 5432, GetConfig().Postgres.Port) + assert.Equal(t, "postgres", GetConfig().Postgres.User) + assert.Equal(t, "postgres", GetConfig().Postgres.Host) + assert.Equal(t, "postgres", GetConfig().Postgres.DbName) + assert.Equal(t, "sslmode=disable", GetConfig().Postgres.ExtraOptions) + assert.Equal(t, "password", GetConfig().Postgres.Password) + assert.Equal(t, "/etc/secret", GetConfig().Postgres.PasswordPath) + assert.Equal(t, true, GetConfig().Postgres.Debug) + + assert.Equal(t, false, GetConfig().SQLite.IsEmpty()) + assert.Equal(t, "admin.db", GetConfig().SQLite.File) +} diff --git a/flytestdlib/database/db.go b/flytestdlib/database/db.go new file mode 100644 index 0000000000..17d2d979c4 --- /dev/null +++ b/flytestdlib/database/db.go @@ -0,0 +1,165 @@ +package database + +import ( + "context" + "fmt" + + "github.com/go-gormigrate/gormigrate/v2" + "gorm.io/driver/sqlite" + "gorm.io/gorm" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +// GetDB uses the dbConfig to create gorm DB object. If the db doesn't exist for the dbConfig then a new one is created +// using the default db for the provider. eg : postgres has default dbName as postgres +func GetDB(ctx context.Context, dbConfig *DbConfig, logConfig *logger.Config) ( + *gorm.DB, error) { + + if dbConfig == nil { + panic("Cannot initialize database repository from empty db config") + } + gormConfig := &gorm.Config{ + Logger: GetGormLogger(ctx, logConfig), + DisableForeignKeyConstraintWhenMigrating: false, + } + + var gormDb *gorm.DB + var err error + + switch { + case !(dbConfig.SQLite.IsEmpty()): + if dbConfig.SQLite.File == "" { + return nil, fmt.Errorf("illegal sqlite database configuration. `file` is a required parameter and should be a path") + } + gormDb, err = gorm.Open(sqlite.Open(dbConfig.SQLite.File), gormConfig) + if err != nil { + return nil, err + } + case !(dbConfig.Postgres.IsEmpty()): + gormDb, err = CreatePostgresDbIfNotExists(ctx, gormConfig, dbConfig.Postgres) + if err != nil { + return nil, err + } + + case len(dbConfig.DeprecatedHost) > 0 || len(dbConfig.DeprecatedUser) > 0 || len(dbConfig.DeprecatedDbName) > 0: + pgConfig := PostgresConfig{ + Host: dbConfig.DeprecatedHost, + Port: dbConfig.DeprecatedPort, + DbName: dbConfig.DeprecatedDbName, + User: dbConfig.DeprecatedUser, + Password: dbConfig.DeprecatedPassword, + PasswordPath: dbConfig.DeprecatedPasswordPath, + ExtraOptions: dbConfig.DeprecatedExtraOptions, + Debug: dbConfig.DeprecatedDebug, + } + gormDb, err = CreatePostgresDbIfNotExists(ctx, gormConfig, pgConfig) + if err != nil { + return nil, err + } + default: + return nil, fmt.Errorf("unrecognized database config, %v. Supported only postgres and sqlite", dbConfig) + } + + // Setup connection pool settings + return gormDb, setupDbConnectionPool(ctx, gormDb, dbConfig) +} + +// GetReadOnlyDB uses the dbConfig to create gorm DB object for the read replica passed via the config +func GetReadOnlyDB(ctx context.Context, dbConfig *DbConfig, logConfig *logger.Config) (*gorm.DB, error) { + if dbConfig == nil { + panic("Cannot initialize database repository from empty db config") + } + + if dbConfig.Postgres.IsEmpty() || dbConfig.Postgres.ReadReplicaHost == "" { + return nil, fmt.Errorf("read replica host not provided in db config") + } + + gormConfig := &gorm.Config{ + Logger: GetGormLogger(ctx, logConfig), + DisableForeignKeyConstraintWhenMigrating: false, + } + + var gormDb *gorm.DB + var err error + gormDb, err = CreatePostgresReadOnlyDbConnection(ctx, gormConfig, dbConfig.Postgres) + if err != nil { + return nil, err + } + + return gormDb, nil +} + +func setupDbConnectionPool(ctx context.Context, gormDb *gorm.DB, dbConfig *DbConfig) error { + genericDb, err := gormDb.DB() + if err != nil { + return err + } + genericDb.SetConnMaxLifetime(dbConfig.ConnMaxLifeTime.Duration) + genericDb.SetMaxIdleConns(dbConfig.MaxIdleConnections) + genericDb.SetMaxOpenConns(dbConfig.MaxOpenConnections) + logger.Infof(ctx, "Set connection pool values to [%+v]", genericDb.Stats()) + return nil +} + +func withDB(ctx context.Context, databaseConfig *DbConfig, do func(db *gorm.DB) error) error { + if databaseConfig == nil { + databaseConfig = GetConfig() + } + logConfig := logger.GetConfig() + + db, err := GetDB(ctx, databaseConfig, logConfig) + if err != nil { + logger.Fatal(ctx, err) + } + + sqlDB, err := db.DB() + if err != nil { + logger.Fatal(ctx, err) + } + + defer func(deferCtx context.Context) { + if err = sqlDB.Close(); err != nil { + logger.Fatal(deferCtx, err) + } + }(ctx) + + if err = sqlDB.Ping(); err != nil { + return err + } + + return do(db) +} + +// Migrate runs all configured migrations +func Migrate(ctx context.Context, databaseConfig *DbConfig, migrations []*gormigrate.Migration) error { + if len(migrations) == 0 { + logger.Infof(ctx, "No migrations to run") + return nil + } + return withDB(ctx, databaseConfig, func(db *gorm.DB) error { + m := gormigrate.New(db, gormigrate.DefaultOptions, migrations) + if err := m.Migrate(); err != nil { + return fmt.Errorf("database migration failed: %v", err) + } + logger.Infof(ctx, "Migration ran successfully") + return nil + }) +} + +// Rollback rolls back the last migration +func Rollback(ctx context.Context, databaseConfig *DbConfig, migrations []*gormigrate.Migration) error { + if len(migrations) == 0 { + logger.Infof(ctx, "No migrations to rollback") + return nil + } + return withDB(ctx, databaseConfig, func(db *gorm.DB) error { + m := gormigrate.New(db, gormigrate.DefaultOptions, migrations) + err := m.RollbackLast() + if err != nil { + return fmt.Errorf("could not rollback latest migration: %v", err) + } + logger.Infof(ctx, "Rolled back one migration successfully") + return nil + }) +} diff --git a/flytestdlib/database/dbconfig_flags.go b/flytestdlib/database/dbconfig_flags.go new file mode 100755 index 0000000000..ea3826606b --- /dev/null +++ b/flytestdlib/database/dbconfig_flags.go @@ -0,0 +1,68 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package database + +import ( + "encoding/json" + "reflect" + + "fmt" + + "github.com/spf13/pflag" +) + +// If v is a pointer, it will get its element value or the zero value of the element type. +// If v is not a pointer, it will return it as is. +func (DbConfig) elemValueOrNil(v interface{}) interface{} { + if t := reflect.TypeOf(v); t.Kind() == reflect.Ptr { + if reflect.ValueOf(v).IsNil() { + return reflect.Zero(t.Elem()).Interface() + } else { + return reflect.ValueOf(v).Interface() + } + } else if v == nil { + return reflect.Zero(t).Interface() + } + + return v +} + +func (DbConfig) mustJsonMarshal(v interface{}) string { + raw, err := json.Marshal(v) + if err != nil { + panic(err) + } + + return string(raw) +} + +func (DbConfig) mustMarshalJSON(v json.Marshaler) string { + raw, err := v.MarshalJSON() + if err != nil { + panic(err) + } + + return string(raw) +} + +// GetPFlagSet will return strongly types pflags for all fields in DbConfig and its nested types. The format of the +// flags is json-name.json-sub-name... etc. +func (cfg DbConfig) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("DbConfig", pflag.ExitOnError) + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "enableForeignKeyConstraintWhenMigrating"), defaultConfig.EnableForeignKeyConstraintWhenMigrating, "Whether to enable gorm foreign keys when migrating the db") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "maxIdleConnections"), defaultConfig.MaxIdleConnections, "maxIdleConnections sets the maximum number of connections in the idle connection pool.") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "maxOpenConnections"), defaultConfig.MaxOpenConnections, "maxOpenConnections sets the maximum number of open connections to the database.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "connMaxLifeTime"), defaultConfig.ConnMaxLifeTime.String(), "sets the maximum amount of time a connection may be reused") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "postgres.host"), defaultConfig.Postgres.Host, "The host name of the database server") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "postgres.readReplicaHost"), defaultConfig.Postgres.ReadReplicaHost, "The host name of the read replica database server") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "postgres.port"), defaultConfig.Postgres.Port, "The port name of the database server") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "postgres.dbname"), defaultConfig.Postgres.DbName, "The database name") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "postgres.username"), defaultConfig.Postgres.User, "The database user who is connecting to the server.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "postgres.password"), defaultConfig.Postgres.Password, "The database password.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "postgres.passwordPath"), defaultConfig.Postgres.PasswordPath, "Points to the file containing the database password.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "postgres.options"), defaultConfig.Postgres.ExtraOptions, "See http://gorm.io/docs/connecting_to_the_database.html for available options passed, in addition to the above.") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "postgres.debug"), defaultConfig.Postgres.Debug, "") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "sqlite.file"), defaultConfig.SQLite.File, "The path to the file (existing or new) where the DB should be created / stored. If existing, then this will be reused, else a new will be created") + return cmdFlags +} diff --git a/flytestdlib/database/dbconfig_flags_test.go b/flytestdlib/database/dbconfig_flags_test.go new file mode 100755 index 0000000000..fd49e69fd8 --- /dev/null +++ b/flytestdlib/database/dbconfig_flags_test.go @@ -0,0 +1,298 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package database + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "testing" + + "github.com/mitchellh/mapstructure" + "github.com/stretchr/testify/assert" +) + +var dereferencableKindsDbConfig = map[reflect.Kind]struct{}{ + reflect.Array: {}, reflect.Chan: {}, reflect.Map: {}, reflect.Ptr: {}, reflect.Slice: {}, +} + +// Checks if t is a kind that can be dereferenced to get its underlying type. +func canGetElementDbConfig(t reflect.Kind) bool { + _, exists := dereferencableKindsDbConfig[t] + return exists +} + +// This decoder hook tests types for json unmarshaling capability. If implemented, it uses json unmarshal to build the +// object. Otherwise, it'll just pass on the original data. +func jsonUnmarshalerHookDbConfig(_, to reflect.Type, data interface{}) (interface{}, error) { + unmarshalerType := reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + if to.Implements(unmarshalerType) || reflect.PtrTo(to).Implements(unmarshalerType) || + (canGetElementDbConfig(to.Kind()) && to.Elem().Implements(unmarshalerType)) { + + raw, err := json.Marshal(data) + if err != nil { + fmt.Printf("Failed to marshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + res := reflect.New(to).Interface() + err = json.Unmarshal(raw, &res) + if err != nil { + fmt.Printf("Failed to umarshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + return res, nil + } + + return data, nil +} + +func decode_DbConfig(input, result interface{}) error { + config := &mapstructure.DecoderConfig{ + TagName: "json", + WeaklyTypedInput: true, + Result: result, + DecodeHook: mapstructure.ComposeDecodeHookFunc( + mapstructure.StringToTimeDurationHookFunc(), + mapstructure.StringToSliceHookFunc(","), + jsonUnmarshalerHookDbConfig, + ), + } + + decoder, err := mapstructure.NewDecoder(config) + if err != nil { + return err + } + + return decoder.Decode(input) +} + +func join_DbConfig(arr interface{}, sep string) string { + listValue := reflect.ValueOf(arr) + strs := make([]string, 0, listValue.Len()) + for i := 0; i < listValue.Len(); i++ { + strs = append(strs, fmt.Sprintf("%v", listValue.Index(i))) + } + + return strings.Join(strs, sep) +} + +func testDecodeJson_DbConfig(t *testing.T, val, result interface{}) { + assert.NoError(t, decode_DbConfig(val, result)) +} + +func testDecodeRaw_DbConfig(t *testing.T, vStringSlice, result interface{}) { + assert.NoError(t, decode_DbConfig(vStringSlice, result)) +} + +func TestDbConfig_GetPFlagSet(t *testing.T) { + val := DbConfig{} + cmdFlags := val.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) +} + +func TestDbConfig_SetFlags(t *testing.T) { + actual := DbConfig{} + cmdFlags := actual.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) + + t.Run("Test_enableForeignKeyConstraintWhenMigrating", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("enableForeignKeyConstraintWhenMigrating", testValue) + if vBool, err := cmdFlags.GetBool("enableForeignKeyConstraintWhenMigrating"); err == nil { + testDecodeJson_DbConfig(t, fmt.Sprintf("%v", vBool), &actual.EnableForeignKeyConstraintWhenMigrating) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_maxIdleConnections", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("maxIdleConnections", testValue) + if vInt, err := cmdFlags.GetInt("maxIdleConnections"); err == nil { + testDecodeJson_DbConfig(t, fmt.Sprintf("%v", vInt), &actual.MaxIdleConnections) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_maxOpenConnections", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("maxOpenConnections", testValue) + if vInt, err := cmdFlags.GetInt("maxOpenConnections"); err == nil { + testDecodeJson_DbConfig(t, fmt.Sprintf("%v", vInt), &actual.MaxOpenConnections) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_connMaxLifeTime", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := defaultConfig.ConnMaxLifeTime.String() + + cmdFlags.Set("connMaxLifeTime", testValue) + if vString, err := cmdFlags.GetString("connMaxLifeTime"); err == nil { + testDecodeJson_DbConfig(t, fmt.Sprintf("%v", vString), &actual.ConnMaxLifeTime) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_postgres.host", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("postgres.host", testValue) + if vString, err := cmdFlags.GetString("postgres.host"); err == nil { + testDecodeJson_DbConfig(t, fmt.Sprintf("%v", vString), &actual.Postgres.Host) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_postgres.readReplicaHost", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("postgres.readReplicaHost", testValue) + if vString, err := cmdFlags.GetString("postgres.readReplicaHost"); err == nil { + testDecodeJson_DbConfig(t, fmt.Sprintf("%v", vString), &actual.Postgres.ReadReplicaHost) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_postgres.port", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("postgres.port", testValue) + if vInt, err := cmdFlags.GetInt("postgres.port"); err == nil { + testDecodeJson_DbConfig(t, fmt.Sprintf("%v", vInt), &actual.Postgres.Port) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_postgres.dbname", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("postgres.dbname", testValue) + if vString, err := cmdFlags.GetString("postgres.dbname"); err == nil { + testDecodeJson_DbConfig(t, fmt.Sprintf("%v", vString), &actual.Postgres.DbName) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_postgres.username", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("postgres.username", testValue) + if vString, err := cmdFlags.GetString("postgres.username"); err == nil { + testDecodeJson_DbConfig(t, fmt.Sprintf("%v", vString), &actual.Postgres.User) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_postgres.password", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("postgres.password", testValue) + if vString, err := cmdFlags.GetString("postgres.password"); err == nil { + testDecodeJson_DbConfig(t, fmt.Sprintf("%v", vString), &actual.Postgres.Password) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_postgres.passwordPath", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("postgres.passwordPath", testValue) + if vString, err := cmdFlags.GetString("postgres.passwordPath"); err == nil { + testDecodeJson_DbConfig(t, fmt.Sprintf("%v", vString), &actual.Postgres.PasswordPath) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_postgres.options", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("postgres.options", testValue) + if vString, err := cmdFlags.GetString("postgres.options"); err == nil { + testDecodeJson_DbConfig(t, fmt.Sprintf("%v", vString), &actual.Postgres.ExtraOptions) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_postgres.debug", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("postgres.debug", testValue) + if vBool, err := cmdFlags.GetBool("postgres.debug"); err == nil { + testDecodeJson_DbConfig(t, fmt.Sprintf("%v", vBool), &actual.Postgres.Debug) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_sqlite.file", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("sqlite.file", testValue) + if vString, err := cmdFlags.GetString("sqlite.file"); err == nil { + testDecodeJson_DbConfig(t, fmt.Sprintf("%v", vString), &actual.SQLite.File) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) +} diff --git a/flytestdlib/database/gorm.go b/flytestdlib/database/gorm.go new file mode 100644 index 0000000000..8370115347 --- /dev/null +++ b/flytestdlib/database/gorm.go @@ -0,0 +1,53 @@ +package database + +import ( + "context" + "log" + "os" + "time" + + gormLogger "gorm.io/gorm/logger" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +// GetGormLogger converts between the flytestdlib configured log level to the equivalent gorm log level and outputs +// a gorm/logger implementation accordingly configured. +func GetGormLogger(ctx context.Context, logConfig *logger.Config) gormLogger.Interface { + logConfigLevel := logger.ErrorLevel + if logConfig != nil { + logConfigLevel = logConfig.Level + } else { + logger.Debugf(ctx, "No log config block found, setting gorm db log level to: error") + } + var logLevel gormLogger.LogLevel + ignoreRecordNotFoundError := true + switch logConfigLevel { + case logger.PanicLevel: + fallthrough + case logger.FatalLevel: + fallthrough + case logger.ErrorLevel: + logLevel = gormLogger.Error + case logger.WarnLevel: + fallthrough + case logger.InfoLevel: + logLevel = gormLogger.Warn + case logger.DebugLevel: + logLevel = gormLogger.Info + ignoreRecordNotFoundError = false + default: + logLevel = gormLogger.Info + } + if logConfigLevel > logger.DebugLevel { + logLevel = gormLogger.Info + } + // Copied from gormLogger.Default initialization. The gormLogger interface only allows modifying the LogLevel + // and not IgnoreRecordNotFoundError. + return gormLogger.New(log.New(os.Stdout, "\r\n", log.LstdFlags), gormLogger.Config{ + SlowThreshold: 200 * time.Millisecond, + LogLevel: logLevel, + IgnoreRecordNotFoundError: ignoreRecordNotFoundError, + Colorful: true, + }) +} diff --git a/flytestdlib/database/postgres.go b/flytestdlib/database/postgres.go new file mode 100644 index 0000000000..3e898e3840 --- /dev/null +++ b/flytestdlib/database/postgres.go @@ -0,0 +1,133 @@ +package database + +import ( + "context" + "errors" + "fmt" + "io/ioutil" + "os" + "strings" + + oldPgConn "github.com/jackc/pgconn" + "github.com/jackc/pgx/v5/pgconn" + "gorm.io/driver/postgres" + "gorm.io/gorm" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +const PqInvalidDBCode = "3D000" +const PqDbAlreadyExistsCode = "42P04" +const PgDuplicatedForeignKey = "23503" +const PgDuplicatedKey = "23505" +const defaultDB = "postgres" + +// Resolves a password value from either a user-provided inline value or a filepath whose contents contain a password. +func resolvePassword(ctx context.Context, passwordVal, passwordPath string) string { + password := passwordVal + if len(passwordPath) > 0 { + if _, err := os.Stat(passwordPath); os.IsNotExist(err) { + logger.Fatalf(ctx, + "missing database password at specified path [%s]", passwordPath) + } + passwordVal, err := ioutil.ReadFile(passwordPath) + if err != nil { + logger.Fatalf(ctx, "failed to read database password from path [%s] with err: %v", + passwordPath, err) + } + // Passwords can contain special characters as long as they are percent encoded + // https://www.postgresql.org/docs/current/libpq-connect.html + password = strings.TrimSpace(string(passwordVal)) + } + return password +} + +// Produces the DSN (data source name) for opening a postgres db connection. +func getPostgresDsn(ctx context.Context, pgConfig PostgresConfig) string { + password := resolvePassword(ctx, pgConfig.Password, pgConfig.PasswordPath) + if len(password) == 0 { + // The password-less case is included for development environments. + return fmt.Sprintf("host=%s port=%d dbname=%s user=%s sslmode=disable", + pgConfig.Host, pgConfig.Port, pgConfig.DbName, pgConfig.User) + } + return fmt.Sprintf("host=%s port=%d dbname=%s user=%s password=%s %s", + pgConfig.Host, pgConfig.Port, pgConfig.DbName, pgConfig.User, password, pgConfig.ExtraOptions) +} + +// Produces the DSN (data source name) for the read replica for opening a postgres db connection. +func getPostgresReadDsn(ctx context.Context, pgConfig PostgresConfig) string { + password := resolvePassword(ctx, pgConfig.Password, pgConfig.PasswordPath) + if len(password) == 0 { + // The password-less case is included for development environments. + return fmt.Sprintf("host=%s port=%d dbname=%s user=%s sslmode=disable", + pgConfig.ReadReplicaHost, pgConfig.Port, pgConfig.DbName, pgConfig.User) + } + return fmt.Sprintf("host=%s port=%d dbname=%s user=%s password=%s %s", + pgConfig.ReadReplicaHost, pgConfig.Port, pgConfig.DbName, pgConfig.User, password, pgConfig.ExtraOptions) +} + +// CreatePostgresDbIfNotExists creates DB if it doesn't exist for the passed in config +func CreatePostgresDbIfNotExists(ctx context.Context, gormConfig *gorm.Config, pgConfig PostgresConfig) (*gorm.DB, error) { + dialector := postgres.Open(getPostgresDsn(ctx, pgConfig)) + gormDb, err := gorm.Open(dialector, gormConfig) + if err == nil { + return gormDb, nil + } + if !IsPgErrorWithCode(err, PqInvalidDBCode) { + logger.Errorf(ctx, "Unhandled error connecting to postgres, pg [%v], gorm [%v]: %v", pgConfig, gormConfig, err) + return nil, err + } + logger.Warningf(ctx, "Database [%v] does not exist", pgConfig.DbName) + + // Every postgres installation includes a 'postgres' database by default. We connect to that now in order to + // initialize the user-specified database. + defaultDbPgConfig := pgConfig + defaultDbPgConfig.DbName = defaultDB + defaultDBDialector := postgres.Open(getPostgresDsn(ctx, defaultDbPgConfig)) + gormDb, err = gorm.Open(defaultDBDialector, gormConfig) + if err != nil { + return nil, err + } + + // Because we asserted earlier that the db does not exist, we create it now. + logger.Infof(ctx, "Creating database %v", pgConfig.DbName) + + // NOTE: golang sql drivers do not support parameter injection for CREATE calls + createDBStatement := fmt.Sprintf("CREATE DATABASE %s", pgConfig.DbName) + result := gormDb.Exec(createDBStatement) + + if result.Error != nil { + if !IsPgErrorWithCode(result.Error, PqDbAlreadyExistsCode) { + return nil, result.Error + } + logger.Warningf(ctx, "Got DB already exists error for [%s], skipping...", pgConfig.DbName) + } + // Now try connecting to the db again + return gorm.Open(dialector, gormConfig) +} + +// CreatePostgresReadOnlyDbConnection creates readonly DB connection and returns the gorm.DB object and error +func CreatePostgresReadOnlyDbConnection(ctx context.Context, gormConfig *gorm.Config, pgConfig PostgresConfig) (*gorm.DB, error) { + dialector := postgres.Open(getPostgresReadDsn(ctx, pgConfig)) + return gorm.Open(dialector, gormConfig) +} + +func IsPgErrorWithCode(err error, code string) bool { + // Newer versions of the gorm postgres driver seem to use + // "github.com/jackc/pgx/v5/pgconn" + // See https://github.com/go-gorm/gorm/issues/4135 + // Let's just try both of them to make sure. + pgErr := &pgconn.PgError{} + if errors.As(err, &pgErr) { + // err chain does not contain a pgconn.PgError + return pgErr.Code == code + } + + oldPgErr := &oldPgConn.PgError{} + if errors.As(err, &oldPgErr) { + // err chain does not contain a pgconn.PgError + return oldPgErr.Code == code + } + + return false +} diff --git a/flytestdlib/database/postgres_test.go b/flytestdlib/database/postgres_test.go new file mode 100644 index 0000000000..eb22c6b3aa --- /dev/null +++ b/flytestdlib/database/postgres_test.go @@ -0,0 +1,197 @@ +package database + +import ( + "context" + "errors" + "io/ioutil" + "net" + "os" + "testing" + + "github.com/jackc/pgconn" + "github.com/stretchr/testify/assert" +) + +func TestResolvePassword(t *testing.T) { + password := "123abc" + tmpFile, err := os.CreateTemp("", "prefix") + if err != nil { + t.Errorf("Couldn't open temp file: %v", err) + } + defer tmpFile.Close() + if _, err = tmpFile.WriteString(password); err != nil { + t.Errorf("Couldn't write to temp file: %v", err) + } + resolvedPassword := resolvePassword(context.TODO(), "", tmpFile.Name()) + assert.Equal(t, resolvedPassword, password) +} + +func TestGetPostgresDsn(t *testing.T) { + pgConfig := PostgresConfig{ + Host: "localhost", + Port: 5432, + DbName: "postgres", + User: "postgres", + ExtraOptions: "sslmode=disable", + } + t.Run("no password", func(t *testing.T) { + dsn := getPostgresDsn(context.TODO(), pgConfig) + assert.Equal(t, "host=localhost port=5432 dbname=postgres user=postgres sslmode=disable", dsn) + }) + t.Run("with password", func(t *testing.T) { + pgConfig.Password = "pass" + dsn := getPostgresDsn(context.TODO(), pgConfig) + assert.Equal(t, "host=localhost port=5432 dbname=postgres user=postgres password=pass sslmode=disable", dsn) + + }) + t.Run("with password, no extra", func(t *testing.T) { + pgConfig.Password = "pass" + pgConfig.ExtraOptions = "" + dsn := getPostgresDsn(context.TODO(), pgConfig) + assert.Equal(t, "host=localhost port=5432 dbname=postgres user=postgres password=pass ", dsn) + }) + t.Run("with password path", func(t *testing.T) { + password := "123abc" + tmpFile, err := ioutil.TempFile("", "prefix") + if err != nil { + t.Errorf("Couldn't open temp file: %v", err) + } + defer tmpFile.Close() + if _, err = tmpFile.WriteString(password); err != nil { + t.Errorf("Couldn't write to temp file: %v", err) + } + pgConfig.PasswordPath = tmpFile.Name() + dsn := getPostgresDsn(context.TODO(), pgConfig) + assert.Equal(t, "host=localhost port=5432 dbname=postgres user=postgres password=123abc ", dsn) + }) +} + +func TestGetPostgresReadDsn(t *testing.T) { + pgConfig := PostgresConfig{ + Host: "localhost", + ReadReplicaHost: "readReplicaHost", + Port: 5432, + DbName: "postgres", + User: "postgres", + ExtraOptions: "sslmode=disable", + } + t.Run("no password", func(t *testing.T) { + dsn := getPostgresReadDsn(context.TODO(), pgConfig) + assert.Equal(t, "host=readReplicaHost port=5432 dbname=postgres user=postgres sslmode=disable", dsn) + }) + t.Run("with password", func(t *testing.T) { + pgConfig.Password = "passw" + dsn := getPostgresReadDsn(context.TODO(), pgConfig) + assert.Equal(t, "host=readReplicaHost port=5432 dbname=postgres user=postgres password=passw sslmode=disable", dsn) + + }) + t.Run("with password, no extra", func(t *testing.T) { + pgConfig.Password = "passwo" + pgConfig.ExtraOptions = "" + dsn := getPostgresReadDsn(context.TODO(), pgConfig) + assert.Equal(t, "host=readReplicaHost port=5432 dbname=postgres user=postgres password=passwo ", dsn) + }) + t.Run("with password path", func(t *testing.T) { + password := "1234abc" + tmpFile, err := ioutil.TempFile("", "prefix") + if err != nil { + t.Errorf("Couldn't open temp file: %v", err) + } + defer tmpFile.Close() + if _, err = tmpFile.WriteString(password); err != nil { + t.Errorf("Couldn't write to temp file: %v", err) + } + pgConfig.PasswordPath = tmpFile.Name() + dsn := getPostgresReadDsn(context.TODO(), pgConfig) + assert.Equal(t, "host=readReplicaHost port=5432 dbname=postgres user=postgres password=1234abc ", dsn) + }) +} + +type wrappedError struct { + err error +} + +func (e *wrappedError) Error() string { + return e.err.Error() +} + +func (e *wrappedError) Unwrap() error { + return e.err +} + +func TestIsInvalidDBPgError(t *testing.T) { + // wrap error with wrappedError when testing to ensure the function checks the whole error chain + + testCases := []struct { + Name string + Err error + ExpectedResult bool + }{ + { + Name: "nil error", + Err: nil, + ExpectedResult: false, + }, + { + Name: "not a PgError", + Err: &wrappedError{err: &net.OpError{Op: "connect", Err: errors.New("connection refused")}}, + ExpectedResult: false, + }, + { + Name: "PgError but not invalid DB", + Err: &wrappedError{&pgconn.PgError{Severity: "FATAL", Message: "out of memory", Code: "53200"}}, + ExpectedResult: false, + }, + { + Name: "PgError and is invalid DB", + Err: &wrappedError{&pgconn.PgError{Severity: "FATAL", Message: "database \"flyte\" does not exist", Code: "3D000"}}, + ExpectedResult: true, + }, + } + + for _, tc := range testCases { + tc := tc + + t.Run(tc.Name, func(t *testing.T) { + assert.Equal(t, tc.ExpectedResult, IsPgErrorWithCode(tc.Err, PqInvalidDBCode)) + }) + } +} + +func TestIsPgDbAlreadyExistsError(t *testing.T) { + // wrap error with wrappedError when testing to ensure the function checks the whole error chain + + testCases := []struct { + Name string + Err error + ExpectedResult bool + }{ + { + Name: "nil error", + Err: nil, + ExpectedResult: false, + }, + { + Name: "not a PgError", + Err: &wrappedError{err: &net.OpError{Op: "connect", Err: errors.New("connection refused")}}, + ExpectedResult: false, + }, + { + Name: "PgError but not already exists", + Err: &wrappedError{&pgconn.PgError{Severity: "FATAL", Message: "out of memory", Code: "53200"}}, + ExpectedResult: false, + }, + { + Name: "PgError and is already exists", + Err: &wrappedError{&pgconn.PgError{Severity: "FATAL", Message: "database \"flyte\" does not exist", Code: "42P04"}}, + ExpectedResult: true, + }, + } + + for _, tc := range testCases { + tc := tc + t.Run(tc.Name, func(t *testing.T) { + assert.Equal(t, tc.ExpectedResult, IsPgErrorWithCode(tc.Err, PqDbAlreadyExistsCode)) + }) + } +} diff --git a/flytestdlib/database/testdata/config.yaml b/flytestdlib/database/testdata/config.yaml new file mode 100644 index 0000000000..5eda985943 --- /dev/null +++ b/flytestdlib/database/testdata/config.yaml @@ -0,0 +1,16 @@ +port: 5432 +username: postgres +host: postgres +dbname: postgres +options: "sslmode=disable" +password: "password" +passwordPath: "/etc/secret" +debug: true +postgres: + port: 5432 + username: postgres + host: postgres + dbname: postgres + options: "sslmode=disable" +sqlite: + file: admin.db \ No newline at end of file diff --git a/flytestdlib/errors/error.go b/flytestdlib/errors/error.go new file mode 100644 index 0000000000..65947607b2 --- /dev/null +++ b/flytestdlib/errors/error.go @@ -0,0 +1,148 @@ +// Contains utilities to use to create and consume simple errors. +package errors + +import ( + "errors" + "fmt" + + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" +) + +// A generic error code type. +type ErrorCode = string + +type err struct { + code ErrorCode + message string +} + +func (e *err) Error() string { + return fmt.Sprintf("[%v] %v", e.code, e.message) +} + +func (e *err) Code() ErrorCode { + return e.code +} + +// Overrides Is to check for error code only. This enables the default package's errors.Is(). +func (e *err) Is(target error) bool { + eCode, found := GetErrorCode(target) + if !found { + return false + } + + return e.Code() == eCode +} + +type errorWithCause struct { + *err + cause error +} + +func (e *errorWithCause) Error() string { + return fmt.Sprintf("%v, caused by: %v", e.err.Error(), e.Cause()) +} + +func (e *errorWithCause) Cause() error { + return e.cause +} + +// Overrides Unwrap to retrieve the underlying error. This enables the default package's errors.Unwrap(). +func (e *errorWithCause) Unwrap() error { + return e.Cause() +} + +// Creates a new error using an error code and a message. +func Errorf(errorCode ErrorCode, msgFmt string, args ...interface{}) error { + return &err{ + code: errorCode, + message: fmt.Sprintf(msgFmt, args...), + } +} + +// Wraps a root cause error with another. This is useful to unify an error type in a package. +func Wrapf(code ErrorCode, cause error, msgFmt string, args ...interface{}) error { + return &errorWithCause{ + err: &err{ + code: code, + message: fmt.Sprintf(msgFmt, args...), + }, + cause: cause, + } +} + +// Gets the error code of the passed error if it has one. +func GetErrorCode(e error) (code ErrorCode, found bool) { + type coder interface { + Code() ErrorCode + } + + er, ok := e.(coder) + if ok { + return er.Code(), true + } + + return +} + +// Gets whether error is caused by another error with errCode. +func IsCausedBy(e error, errCode ErrorCode) bool { + type causer interface { + Cause() error + } + + type wrapped interface { + Unwrap() error + } + + for e != nil { + if code, found := GetErrorCode(e); found && code == errCode { + return true + } + + cause, ok := e.(causer) + if ok { + e = cause.Cause() + } else { + cause, ok := e.(wrapped) + if !ok { + break + } + + e = cause.Unwrap() + } + } + + return false +} + +func IsCausedByError(e, e2 error) bool { + type causer interface { + Cause() error + } + + for e != nil { + if errors.Is(e, e2) { + return true + } + + cause, ok := e.(causer) + if !ok { + break + } + + e = cause.Cause() + } + + return false +} + +func IsGrpcErrorWithCode(code codes.Code, err error) bool { + s, ok := status.FromError(err) + return ok && s.Code() == code +} + +func IsNotFound(err error) bool { + return IsGrpcErrorWithCode(codes.NotFound, err) +} diff --git a/flytestdlib/errors/error_test.go b/flytestdlib/errors/error_test.go new file mode 100644 index 0000000000..e22ce2f28e --- /dev/null +++ b/flytestdlib/errors/error_test.go @@ -0,0 +1,80 @@ +package errors + +import ( + "errors" + "fmt" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestErrorf(t *testing.T) { + e := Errorf("Code1", "msg") + assert.NotNil(t, e) + assert.Equal(t, "[Code1] msg", e.Error()) +} + +func TestWrapf(t *testing.T) { + e := Wrapf("Code1", fmt.Errorf("test error"), "msg") + assert.NotNil(t, e) + assert.Equal(t, "[Code1] msg, caused by: test error", e.Error()) +} + +func TestGetErrorCode(t *testing.T) { + e := Errorf("Code1", "msg") + assert.NotNil(t, e) + code, found := GetErrorCode(e) + assert.True(t, found) + assert.Equal(t, "Code1", code) +} + +func TestIsCausedBy(t *testing.T) { + e := Errorf("Code1", "msg") + assert.NotNil(t, e) + + e = Wrapf("Code2", e, "msg") + assert.True(t, IsCausedBy(e, "Code1")) + assert.True(t, IsCausedBy(e, "Code2")) + + e = fmt.Errorf("new err caused by: %w", e) + assert.True(t, IsCausedBy(e, "Code1")) + + e = fmt.Errorf("not sharing code err") + assert.False(t, IsCausedBy(e, "Code1")) +} + +func TestIsCausedByError(t *testing.T) { + eRoot := Errorf("Code1", "msg") + assert.NotNil(t, eRoot) + + e1 := Wrapf("Code2", eRoot, "msg") + assert.True(t, IsCausedByError(e1, eRoot)) + + e2 := Wrapf("Code3", e1, "msg") + assert.True(t, IsCausedByError(e2, eRoot)) + assert.True(t, IsCausedByError(e2, e1)) + + e3 := fmt.Errorf("default errors. caused by: %w", e2) + assert.True(t, IsCausedByError(e3, eRoot)) + assert.True(t, IsCausedByError(e3, e1)) +} + +func TestErrorsIs(t *testing.T) { + eRoot := Errorf("Code1", "msg") + assert.True(t, errors.Is(eRoot, Errorf("Code1", "different msg"))) + + e1 := Wrapf("Code2", eRoot, "Wrapped error") + assert.True(t, errors.Is(e1, Errorf("Code1", "different msg"))) +} + +func TestErrorsUnwrap(t *testing.T) { + eRoot := Errorf("Code1", "msg") + e1 := Wrapf("Code2", eRoot, "Wrapped error") + assert.True(t, errors.Is(e1, Errorf("Code1", "different msg"))) + + newErr := &err{} + assert.True(t, errors.As(e1, &newErr)) + assert.Equal(t, "Code1", newErr.Code()) + + assert.True(t, errors.Is(errors.Unwrap(e1), Errorf("Code1", "different msg"))) +} diff --git a/flytestdlib/errors/errors.go b/flytestdlib/errors/errors.go new file mode 100644 index 0000000000..c1c23c6511 --- /dev/null +++ b/flytestdlib/errors/errors.go @@ -0,0 +1,32 @@ +package errors + +import "fmt" + +// A helper object that collects errors. +type ErrorCollection []error + +func (e ErrorCollection) Error() string { + res := "" + for _, err := range e { + res = fmt.Sprintf("%v\n%v", res, err.Error()) + } + + return res +} + +func (e ErrorCollection) ErrorOrDefault() error { + if len(e) == 0 { + return nil + } + + return e +} + +func (e *ErrorCollection) Append(err error) bool { + if err != nil { + *e = append(*e, err) + return true + } + + return false +} diff --git a/flytestdlib/errors/errors_test.go b/flytestdlib/errors/errors_test.go new file mode 100644 index 0000000000..939cc79a4a --- /dev/null +++ b/flytestdlib/errors/errors_test.go @@ -0,0 +1,31 @@ +package errors + +import ( + "fmt" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestErrorCollection_ErrorOrDefault(t *testing.T) { + errs := ErrorCollection{} + assert.Error(t, errs) + assert.NoError(t, errs.ErrorOrDefault()) +} + +func TestErrorCollection_Append(t *testing.T) { + errs := ErrorCollection{} + errs.Append(nil) + errs.Append(fmt.Errorf("this is an actual error")) + assert.Error(t, errs.ErrorOrDefault()) + assert.Len(t, errs, 1) + assert.Len(t, errs.ErrorOrDefault(), 1) +} + +func TestErrorCollection_Error(t *testing.T) { + errs := ErrorCollection{} + errs.Append(nil) + errs.Append(fmt.Errorf("this is an actual error")) + assert.Error(t, errs.ErrorOrDefault()) + assert.Contains(t, errs.ErrorOrDefault().Error(), "this is an actual error") +} diff --git a/flytestdlib/fastcheck/doc.go b/flytestdlib/fastcheck/doc.go new file mode 100644 index 0000000000..1cdf28c587 --- /dev/null +++ b/flytestdlib/fastcheck/doc.go @@ -0,0 +1,11 @@ +// This package contains implementation for checking if an item has been seen previously. This is different from a bloom-filter +// as it prioritizes false-negatives (return absence even if the object was seen previously), instead of false-positives. +// A Bloom filter prioritizes false-positives (return presence even if the object was not seen previously) +// and thus is able to provide a high compression. +// This is similar to a cache, with the difference being that it does not store a value and can use other optimized +// representations to compress the keys and optimize for storage. +// The simplest implementation for the fastcheck.Filter is an LRU cache +// the package provides alternative implementations and is inspired by the code in +// https://github.com/jmhodges/opposite_of_a_bloom_filter/ and +// the related blog https://www.somethingsimilar.com/2012/05/21/the-opposite-of-a-bloom-filter/ +package fastcheck diff --git a/flytestdlib/fastcheck/fastcheck_test.go b/flytestdlib/fastcheck/fastcheck_test.go new file mode 100644 index 0000000000..f9aa37ff5b --- /dev/null +++ b/flytestdlib/fastcheck/fastcheck_test.go @@ -0,0 +1,174 @@ +package fastcheck + +import ( + "context" + "math/rand" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils/labeled" +) + +func TestFilter(t *testing.T) { + ctx := context.TODO() + + lru, err := NewLRUCacheFilter(2, promutils.NewTestScope()) + assert.NoError(t, err) + assert.NotNil(t, lru) + oppo, err := NewOppoBloomFilter(2, promutils.NewTestScope()) + assert.NoError(t, err) + assert.NotNil(t, oppo) + + twentyNineID := []byte{27, 28, 29} + thirtyID := []byte{27, 28, 30} + thirtyThreeID := []byte{27, 28, 33} + // the last 2 byte arrays have the same hash value + + assert.False(t, lru.Contains(ctx, twentyNineID)) + assert.False(t, oppo.Contains(ctx, twentyNineID)) + lru.Add(ctx, twentyNineID) + oppo.Add(ctx, twentyNineID) + assert.True(t, lru.Contains(ctx, twentyNineID)) + assert.True(t, oppo.Contains(ctx, twentyNineID)) + + assert.False(t, lru.Contains(ctx, thirtyID)) + assert.False(t, oppo.Contains(ctx, thirtyID)) + + assert.False(t, lru.Contains(ctx, thirtyThreeID)) + assert.False(t, oppo.Contains(ctx, thirtyThreeID)) + + // Now that they have the same hash value + lru.Add(ctx, thirtyID) + oppo.Add(ctx, thirtyID) + assert.True(t, lru.Contains(ctx, thirtyID)) + assert.True(t, oppo.Contains(ctx, thirtyID)) + // LRU should not contain it and oppo should also return false + assert.False(t, lru.Contains(ctx, thirtyThreeID)) + assert.False(t, oppo.Contains(ctx, thirtyThreeID)) + + lru.Add(ctx, thirtyThreeID) + oppo.Add(ctx, thirtyThreeID) + + // LRU will evict first entered, while oppo will evict matching hash + assert.True(t, lru.Contains(ctx, thirtyID)) + assert.False(t, oppo.Contains(ctx, thirtyID)) + +} + +func TestSizeRounding(t *testing.T) { + f, _ := NewOppoBloomFilter(3, promutils.NewTestScope()) + if len(f.array) != 4 { + t.Errorf("3 should round to 4") + } + f, _ = NewOppoBloomFilter(4, promutils.NewTestScope()) + if len(f.array) != 4 { + t.Errorf("4 should round to 4") + } + f, _ = NewOppoBloomFilter(129, promutils.NewTestScope()) + if len(f.array) != 256 { + t.Errorf("129 should round to 256") + } +} + +func TestTooLargeSize(t *testing.T) { + size := (1 << 30) + 1 + f, err := NewOppoBloomFilter(size, promutils.NewTestScope()) + if err != ErrSizeTooLarge { + t.Errorf("did not error out on a too-large filter size") + } + if f != nil { + t.Errorf("did not return nil on a too-large filter size") + } +} + +func TestTooSmallSize(t *testing.T) { + f, err := NewOppoBloomFilter(0, promutils.NewTestScope()) + if err != ErrSizeTooSmall { + t.Errorf("did not error out on a too small filter size") + } + if f != nil { + t.Errorf("did not return nil on a too small filter size") + } +} + +const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" +const ( + letterIdxBits = 6 // 6 bits to represent a letter index + letterIdxMask = 1<= 0; { //nolint:gosec + if remain == 0 { + cache, remain = rand.Int63(), letterIdxMax //nolint:gosec + } + if idx := int(cache & letterIdxMask); idx < len(letterBytes) { + b[i] = letterBytes[idx] + i-- + } + cache >>= letterIdxBits + remain-- + } + + return b +} + +// RandBytesSliceGenerator generates a slice of size m with random bytes of size n +func RandBytesSliceGenerator(n int, m int) [][]byte { + byteSlice := make([][]byte, 0, m) + for i := 0; i < m; i++ { + byteSlice = append(byteSlice, RandBytesGenerator(n)) + } + return byteSlice +} + +func benchmarkFilter(b *testing.B, ids [][]byte, f func(context.Context, []byte) bool, parallelism int) { + ctx := context.TODO() + b.SetParallelism(parallelism) + b.ResetTimer() + + b.RunParallel(func(pb *testing.PB) { + index := 0 + for pb.Next() { + index = (index + 1) % len(ids) + f(ctx, ids[index]) + } + }) +} + +func BenchmarkFilter(b *testing.B) { + parallelism := 10 + cacheSize := 5000 + + bf, err := NewOppoBloomFilter(cacheSize, promutils.NewTestScope()) + assert.NoError(b, err) + lf, err := NewLRUCacheFilter(cacheSize, promutils.NewTestScope()) + assert.NoError(b, err) + ids := RandBytesSliceGenerator(100, 100000) + + b.Run("oppoFilterContainsBenchmark", func(b *testing.B) { + benchmarkFilter(b, ids, bf.Contains, parallelism) + }) + + b.Run("oppoFilterAddBenchmark", func(b *testing.B) { + benchmarkFilter(b, ids, bf.Add, parallelism) + }) + + b.Run("lruCacheContainsBenchmark", func(b *testing.B) { + benchmarkFilter(b, ids, lf.Contains, parallelism) + }) + + b.Run("lruCacheAddBenchmark", func(b *testing.B) { + benchmarkFilter(b, ids, lf.Add, parallelism) + }) +} + +func init() { + labeled.SetMetricKeys(contextutils.MetricKeysFromStrings([]string{"test"})...) +} diff --git a/flytestdlib/fastcheck/iface.go b/flytestdlib/fastcheck/iface.go new file mode 100644 index 0000000000..3f86e7fa5b --- /dev/null +++ b/flytestdlib/fastcheck/iface.go @@ -0,0 +1,40 @@ +package fastcheck + +import ( + "context" + + "github.com/prometheus/client_golang/prometheus" + + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +// Filter provides an interface to check if a Key of type []byte was ever seen. +// The size of the cache is dependent on the id size and the initialization. It may also vary based on the implementation +// For example an LRU cache, may have an overhead because of the use of a HashMap with loading factor and collision +// resolution +// The Data-structure is thread-safe and can be accessed by multiple threads concurrently. + + +type Filter interface { + // Contains returns a True if the id was previously seen or false otherwise + // It may return a false, even if a item may have previously occurred. + Contains(ctx context.Context, id []byte) bool + + // Adds the element id to the Filter and returns if a previous object was evicted in the process + Add(ctx context.Context, id []byte) (evicted bool) +} + +// Every implementation of the Filter Interface provides these metrics +type Metrics struct { + // Indicates if the item was found in the cache + Hit prometheus.Counter + // Indicates if the item was not found in the cache + Miss prometheus.Counter +} + +func newMetrics(scope promutils.Scope) Metrics { + return Metrics{ + Hit: scope.MustNewCounter("cache_hit", "Indicates that the item was found in the cache"), + Miss: scope.MustNewCounter("cache_miss", "Indicates that the item was found in the cache"), + } +} diff --git a/flytestdlib/fastcheck/lru.go b/flytestdlib/fastcheck/lru.go new file mode 100644 index 0000000000..d42e9898f2 --- /dev/null +++ b/flytestdlib/fastcheck/lru.go @@ -0,0 +1,46 @@ +package fastcheck + +import ( + "context" + + cache "github.com/hashicorp/golang-lru" + + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +// validate that it conforms to the interface +var _ Filter = LRUCacheFilter{} + +// Implements the fastcheck.Filter interface using an underlying LRUCache from cache.Cache +// the underlying lru cache implementation is thread-safe +type LRUCacheFilter struct { + lru *cache.Cache + metrics Metrics +} + +// Simply uses Contains from the LRUCacheFilter +func (l LRUCacheFilter) Contains(_ context.Context, id []byte) bool { + v := l.lru.Contains(string(id)) + if v { + l.metrics.Hit.Inc() + return true + } + l.metrics.Miss.Inc() + return false +} + +func (l LRUCacheFilter) Add(_ context.Context, id []byte) bool { + return l.lru.Add(string(id), nil) +} + +// Create a new fastcheck.Filter using an LRU cache of type cache.Cache with a fixed size +func NewLRUCacheFilter(size int, scope promutils.Scope) (*LRUCacheFilter, error) { + c, err := cache.New(size) + if err != nil { + return nil, err + } + return &LRUCacheFilter{ + lru: c, + metrics: newMetrics(scope), + }, nil +} diff --git a/flytestdlib/fastcheck/mocks/filter.go b/flytestdlib/fastcheck/mocks/filter.go new file mode 100644 index 0000000000..f2250b7cf7 --- /dev/null +++ b/flytestdlib/fastcheck/mocks/filter.go @@ -0,0 +1,130 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" +) + +// Filter is an autogenerated mock type for the Filter type +type Filter struct { + mock.Mock +} + +type Filter_Expecter struct { + mock *mock.Mock +} + +func (_m *Filter) EXPECT() *Filter_Expecter { + return &Filter_Expecter{mock: &_m.Mock} +} + +// Add provides a mock function with given fields: ctx, id +func (_m *Filter) Add(ctx context.Context, id []byte) bool { + ret := _m.Called(ctx, id) + + if len(ret) == 0 { + panic("no return value specified for Add") + } + + var r0 bool + if rf, ok := ret.Get(0).(func(context.Context, []byte) bool); ok { + r0 = rf(ctx, id) + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// Filter_Add_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Add' +type Filter_Add_Call struct { + *mock.Call +} + +// Add is a helper method to define mock.On call +// - ctx context.Context +// - id []byte +func (_e *Filter_Expecter) Add(ctx interface{}, id interface{}) *Filter_Add_Call { + return &Filter_Add_Call{Call: _e.mock.On("Add", ctx, id)} +} + +func (_c *Filter_Add_Call) Run(run func(ctx context.Context, id []byte)) *Filter_Add_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]byte)) + }) + return _c +} + +func (_c *Filter_Add_Call) Return(evicted bool) *Filter_Add_Call { + _c.Call.Return(evicted) + return _c +} + +func (_c *Filter_Add_Call) RunAndReturn(run func(context.Context, []byte) bool) *Filter_Add_Call { + _c.Call.Return(run) + return _c +} + +// Contains provides a mock function with given fields: ctx, id +func (_m *Filter) Contains(ctx context.Context, id []byte) bool { + ret := _m.Called(ctx, id) + + if len(ret) == 0 { + panic("no return value specified for Contains") + } + + var r0 bool + if rf, ok := ret.Get(0).(func(context.Context, []byte) bool); ok { + r0 = rf(ctx, id) + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// Filter_Contains_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Contains' +type Filter_Contains_Call struct { + *mock.Call +} + +// Contains is a helper method to define mock.On call +// - ctx context.Context +// - id []byte +func (_e *Filter_Expecter) Contains(ctx interface{}, id interface{}) *Filter_Contains_Call { + return &Filter_Contains_Call{Call: _e.mock.On("Contains", ctx, id)} +} + +func (_c *Filter_Contains_Call) Run(run func(ctx context.Context, id []byte)) *Filter_Contains_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]byte)) + }) + return _c +} + +func (_c *Filter_Contains_Call) Return(_a0 bool) *Filter_Contains_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Filter_Contains_Call) RunAndReturn(run func(context.Context, []byte) bool) *Filter_Contains_Call { + _c.Call.Return(run) + return _c +} + +// NewFilter creates a new instance of Filter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewFilter(t interface { + mock.TestingT + Cleanup(func()) +}) *Filter { + mock := &Filter{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/fastcheck/oppobloom.go b/flytestdlib/fastcheck/oppobloom.go new file mode 100644 index 0000000000..d78103d3ff --- /dev/null +++ b/flytestdlib/fastcheck/oppobloom.go @@ -0,0 +1,121 @@ +// Copyright 2012 Jeff Hodges. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. +// Copyright FlyteAuthors. +// This code is liberally copied from the original implementation at https://github.com/jmhodges/opposite_of_a_bloom_filter/blob/master/go/oppobloom/oppobloom.go +// Package oppobloom implements a filter data structure that may report false negatives but no false positives. + +// the fastcheck.OppoBloomFilter provides two methods instead of one, a contains and an add. This makes it possible to +// check and then optionally add the value. It is possible that two threads may race and add it multiple times +package fastcheck + +import ( + "bytes" + "context" + "crypto/md5" //nolint:gosec + "errors" + "hash" + "math" + "sync/atomic" + "unsafe" + + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +var ErrSizeTooLarge = errors.New("oppobloom: size given too large to round to a power of 2") +var ErrSizeTooSmall = errors.New("oppobloom: filter cannot have a zero or negative size") +var MaxFilterSize = 1 << 30 + +// validate that it conforms to the interface +var _ Filter = &OppoBloomFilter{} + +type md5UintHash struct { + hash.Hash // a hack with knowledge of how md5 works +} + +func (m md5UintHash) Sum32() uint32 { + sum := m.Sum(nil) + x := uint32(sum[0]) + for _, val := range sum[1:3] { + x = x << 3 + x += uint32(val) + } + return x +} + +// Implementation of the oppoFilter proposed in https://github.com/jmhodges/opposite_of_a_bloom_filter/ and +// the related blog https://www.somethingsimilar.com/2012/05/21/the-opposite-of-a-bloom-filter/ +type OppoBloomFilter struct { + array []*[]byte + sizeMask uint32 + metrics Metrics +} + +// getIndex calculates the hashindex of the given id +func (f *OppoBloomFilter) getIndex(id []byte) int32 { + //nolint:gosec + h := md5UintHash{md5.New()} + h.Write(id) + uindex := h.Sum32() & f.sizeMask + return int32(uindex) // #nosec G115 +} + +func (f *OppoBloomFilter) Add(_ context.Context, id []byte) bool { + oldID := getAndSet(f.array, f.getIndex(id), id) + return !bytes.Equal(oldID, id) +} + +func (f *OppoBloomFilter) Contains(_ context.Context, id []byte) bool { + curr := get(f.array, f.getIndex(id)) + if curr != nil { + if bytes.Equal(id, *curr) { + f.metrics.Hit.Inc() + return true + } + } + f.metrics.Miss.Inc() + return false +} + +// Helper methods + +// get returns the actual value stored at the given index. If not found the value can be nil +func get(arr []*[]byte, index int32) *[]byte { + indexPtr := (*unsafe.Pointer)(unsafe.Pointer(&arr[index])) + return (*[]byte)(atomic.LoadPointer(indexPtr)) +} + +// getAndSet Returns the id that was in the slice at the given index after putting the +// new id in the slice at that index, atomically. +func getAndSet(arr []*[]byte, index int32, id []byte) []byte { + indexPtr := (*unsafe.Pointer)(unsafe.Pointer(&arr[index])) + idUnsafe := unsafe.Pointer(&id) + var oldID []byte + for { + oldIDUnsafe := atomic.LoadPointer(indexPtr) + if atomic.CompareAndSwapPointer(indexPtr, oldIDUnsafe, idUnsafe) { + oldIDPtr := (*[]byte)(oldIDUnsafe) + if oldIDPtr != nil { + oldID = *oldIDPtr + } + break + } + } + return oldID +} + +// NewOppoBloomFilter creates a new Opposite of Bloom filter proposed in https://github.com/jmhodges/opposite_of_a_bloom_filter/ and +// the related blog https://www.somethingsimilar.com/2012/05/21/the-opposite-of-a-bloom-filter/ +func NewOppoBloomFilter(size int, scope promutils.Scope) (*OppoBloomFilter, error) { + if size > MaxFilterSize { + return nil, ErrSizeTooLarge + } + if size <= 0 { + return nil, ErrSizeTooSmall + } + // round to the next largest power of two + size = int(math.Pow(2, math.Ceil(math.Log2(float64(size))))) + slice := make([]*[]byte, size) + sizeMask := uint32(size - 1) // #nosec G115 + return &OppoBloomFilter{slice, sizeMask, newMetrics(scope)}, nil +} diff --git a/flytestdlib/flytestdlib.json b/flytestdlib/flytestdlib.json new file mode 100644 index 0000000000..d981fa9c98 --- /dev/null +++ b/flytestdlib/flytestdlib.json @@ -0,0 +1,26 @@ +{ + "version": "0.3.9", + "architecture": { + "32bit": { + "url": "https://github.com/lyft/flytestdlib/releases/download/v0.3.9/flytestdlib_0.3.9_Windows_i386.zip", + "bin": [ + "pflags.exe" + ], + "hash": "941f2bedb122cd7af582a196870a8ef1a2857a0c3ac548448f901e5658d83b75" + }, + "64bit": { + "url": "https://github.com/lyft/flytestdlib/releases/download/v0.3.9/flytestdlib_0.3.9_Windows_x86_64.zip", + "bin": [ + "pflags.exe" + ], + "hash": "156cac855fa464b888b0fd41c991a7241e5ca4edc08bad2d2cc47bf5d24792e9" + } + }, + "homepage": "https://godoc.org/github.com/lyft/flytestdlib", + "license": "Apache-2.0", + "description": "Common Go utilities (Typed-Config, PFlags, Prometheus Metrics,... more).", + "persist": [ + "data", + "config.toml" + ] +} \ No newline at end of file diff --git a/flytestdlib/futures/future.go b/flytestdlib/futures/future.go new file mode 100644 index 0000000000..a023fb8cad --- /dev/null +++ b/flytestdlib/futures/future.go @@ -0,0 +1,109 @@ +// Package futures implements a simple Async Futures for golang +package futures + +import ( + "context" + "fmt" + "sync" +) + +// Provides a Future API for asynchronous completion of tasks +type Future interface { + // Returns true if the Future is ready and either a value or error is available. Once Ready returns True, Get should return immediately + Ready() bool + // Get is a potentially blocking call, that returns the asynchronously computed value or an error + // If Get is called before Ready() returns True, then it will block till the future has been completed + Get(ctx context.Context) (interface{}, error) +} + +// This is a synchronous future, where the values are available immediately on construction. This is used to maintain a synonymous API with both +// Async and Sync tasks +type SyncFuture struct { + // The actual value + val interface{} + // OR an error + err error +} + +// Always returns true +func (s SyncFuture) Ready() bool { + return true +} + +// returns the previously provided value / error +func (s *SyncFuture) Get(_ context.Context) (interface{}, error) { + return s.val, s.err +} + +// Creates a new "completed" future that matches the async computation api +func NewSyncFuture(val interface{}, err error) *SyncFuture { + return &SyncFuture{ + val: val, + err: err, + } +} + +// ErrAsyncFutureCanceled is returned when the async future is cancelled by invoking the cancel function on the context +var ErrAsyncFutureCanceled = fmt.Errorf("async future was canceled") + +// An asynchronously completing future +type AsyncFuture struct { + sync.Mutex + doneChannel chan bool + cancelFn context.CancelFunc + // The actual value + val interface{} + // Or an error + err error + ready bool +} + +func (f *AsyncFuture) set(val interface{}, err error) { + f.Lock() + defer f.Unlock() + f.val = val + f.err = err + f.ready = true + f.doneChannel <- true +} + +func (f *AsyncFuture) get() (interface{}, error) { + f.Lock() + defer f.Unlock() + return f.val, f.err +} + +// returns whether the future is completed +func (f *AsyncFuture) Ready() bool { + f.Lock() + defer f.Unlock() + return f.ready +} + +// Returns results (interface{} or an error) OR blocks till the results are available. +// If context is cancelled while waiting for results, an ErrAsyncFutureCanceled is returned +func (f *AsyncFuture) Get(ctx context.Context) (interface{}, error) { + select { + case <-ctx.Done(): + f.cancelFn() + return nil, ErrAsyncFutureCanceled + case <-f.doneChannel: + return f.get() + } +} + +// Creates a new Async future, that will call the method `closure` and return the results from the execution of +// this method +func NewAsyncFuture(ctx context.Context, closure func(context.Context) (interface{}, error)) *AsyncFuture { + childCtx, cancel := context.WithCancel(ctx) + f := &AsyncFuture{ + doneChannel: make(chan bool, 1), + cancelFn: cancel, + } + + go func(ctx2 context.Context, fut *AsyncFuture) { + val, err := closure(ctx2) + fut.set(val, err) + }(childCtx, f) + return f +} diff --git a/flytestdlib/futures/future_test.go b/flytestdlib/futures/future_test.go new file mode 100644 index 0000000000..83e23c664f --- /dev/null +++ b/flytestdlib/futures/future_test.go @@ -0,0 +1,97 @@ +package futures + +import ( + "context" + "fmt" + "runtime" + "testing" + "time" + + "github.com/stretchr/testify/assert" +) + +func Example() { + ctx := context.Background() + f := NewAsyncFuture(ctx, func(ctx2 context.Context) (interface{}, error) { + // can do large async / non-blocking work + time.Sleep(time.Second) + return "hello", nil + }) + + f.Ready() // can be checked for completion + _, _ = f.Get(ctx) // will block till the given sub-routine returns +} + +func TestNewSyncFuture(t *testing.T) { + type args struct { + val interface{} + err error + } + tests := []struct { + name string + args args + }{ + {"val", args{val: "val"}}, + {"nil-val", args{}}, + {"error", args{err: fmt.Errorf("err")}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := NewSyncFuture(tt.args.val, tt.args.err) + assert.NotNil(t, got) + assert.Equal(t, tt.args.val, got.val) + assert.Equal(t, tt.args.err, got.err) + assert.True(t, got.Ready()) + v, err := got.Get(context.TODO()) + assert.Equal(t, tt.args.val, v) + assert.Equal(t, tt.args.err, err) + }) + } +} + +func TestAsyncFuture(t *testing.T) { + + const val = "val" + t.Run("immediate-return-val", func(t *testing.T) { + v := val + err := fmt.Errorf("err") + af := NewAsyncFuture(context.TODO(), func(ctx context.Context) (interface{}, error) { + return v, err + }) + assert.NotNil(t, af) + rv, rerr := af.Get(context.TODO()) + assert.Equal(t, v, rv) + assert.Equal(t, err, rerr) + assert.True(t, af.Ready()) + }) + + t.Run("wait-return-val", func(t *testing.T) { + v := val + err := fmt.Errorf("err") + af := NewAsyncFuture(context.TODO(), func(ctx context.Context) (interface{}, error) { + time.Sleep(time.Second * 1) + return v, err + }) + runtime.Gosched() + assert.NotNil(t, af) + rv, rerr := af.Get(context.TODO()) + assert.Equal(t, v, rv) + assert.Equal(t, err, rerr) + assert.True(t, af.Ready()) + }) + + t.Run("timeout", func(t *testing.T) { + v := val + ctx := context.TODO() + af := NewAsyncFuture(ctx, func(ctx context.Context) (interface{}, error) { + time.Sleep(time.Second * 5) + return v, nil + }) + runtime.Gosched() + cctx, cancel := context.WithCancel(ctx) + cancel() + _, rerr := af.Get(cctx) + assert.Error(t, rerr) + assert.Equal(t, ErrAsyncFutureCanceled, rerr) + }) +} diff --git a/flytestdlib/godownloader.sh b/flytestdlib/godownloader.sh new file mode 100755 index 0000000000..44093b6d07 --- /dev/null +++ b/flytestdlib/godownloader.sh @@ -0,0 +1,403 @@ +#!/bin/sh +set -e +# Code generated by godownloader on 2019-04-24T17:57:45Z. DO NOT EDIT. +# + +usage() { + this=$1 + cat </dev/null +} +echoerr() { + echo "$@" 1>&2 +} +log_prefix() { + echo "$0" +} +_logp=6 +log_set_priority() { + _logp="$1" +} +log_priority() { + if test -z "$1"; then + echo "$_logp" + return + fi + [ "$1" -le "$_logp" ] +} +log_tag() { + case $1 in + 0) echo "emerg" ;; + 1) echo "alert" ;; + 2) echo "crit" ;; + 3) echo "err" ;; + 4) echo "warning" ;; + 5) echo "notice" ;; + 6) echo "info" ;; + 7) echo "debug" ;; + *) echo "$1" ;; + esac +} +log_debug() { + log_priority 7 || return 0 + echoerr "$(log_prefix)" "$(log_tag 7)" "$@" +} +log_info() { + log_priority 6 || return 0 + echoerr "$(log_prefix)" "$(log_tag 6)" "$@" +} +log_err() { + log_priority 3 || return 0 + echoerr "$(log_prefix)" "$(log_tag 3)" "$@" +} +log_crit() { + log_priority 2 || return 0 + echoerr "$(log_prefix)" "$(log_tag 2)" "$@" +} +uname_os() { + os=$(uname -s | tr '[:upper:]' '[:lower:]') + case "$os" in + msys_nt) os="windows" ;; + esac + echo "$os" +} +uname_arch() { + arch=$(uname -m) + case $arch in + x86_64) arch="x86_64" ;; + x86) arch="386" ;; + i686) arch="386" ;; + i386) arch="386" ;; + aarch64) arch="arm64" ;; + armv5*) arch="armv5" ;; + armv6*) arch="armv6" ;; + armv7*) arch="armv7" ;; + esac + echo ${arch} +} +uname_os_check() { + os=$(uname_os) + case "$os" in + darwin) return 0 ;; + dragonfly) return 0 ;; + freebsd) return 0 ;; + linux) return 0 ;; + android) return 0 ;; + nacl) return 0 ;; + netbsd) return 0 ;; + openbsd) return 0 ;; + plan9) return 0 ;; + solaris) return 0 ;; + windows) return 0 ;; + esac + log_crit "uname_os_check '$(uname -s)' got converted to '$os' which is not a GOOS value. Please file bug at https://github.com/client9/shlib" + return 1 +} +uname_arch_check() { + arch=$(uname_arch) + case "$arch" in + 386) return 0 ;; + amd64) return 0 ;; + arm64) return 0 ;; + armv5) return 0 ;; + armv6) return 0 ;; + armv7) return 0 ;; + ppc64) return 0 ;; + ppc64le) return 0 ;; + mips) return 0 ;; + mipsle) return 0 ;; + mips64) return 0 ;; + mips64le) return 0 ;; + s390x) return 0 ;; + amd64p32) return 0 ;; + x86_64) return 0 ;; + esac + log_crit "uname_arch_check '$(uname -m)' got converted to '$arch' which is not a GOARCH value. Please file bug report at https://github.com/client9/shlib" + return 1 +} +untar() { + tarball=$1 + case "${tarball}" in + *.tar.gz | *.tgz) tar -xzf "${tarball}" ;; + *.tar) tar -xf "${tarball}" ;; + *.zip) unzip "${tarball}" ;; + *) + log_err "untar unknown archive format for ${tarball}" + return 1 + ;; + esac +} +http_download_curl() { + local_file=$1 + source_url=$2 + header=$3 + if [ -z "$header" ]; then + code=$(curl -w '%{http_code}' -sL -o "$local_file" "$source_url") + else + code=$(curl -w '%{http_code}' -sL -H "$header" -o "$local_file" "$source_url") + fi + if [ "$code" != "200" ]; then + log_debug "http_download_curl received HTTP status $code" + return 1 + fi + return 0 +} +http_download_wget() { + local_file=$1 + source_url=$2 + header=$3 + if [ -z "$header" ]; then + wget -q -O "$local_file" "$source_url" + else + wget -q --header "$header" -O "$local_file" "$source_url" + fi +} +http_download() { + log_debug "http_download $2" + if is_command curl; then + http_download_curl "$@" + return + elif is_command wget; then + http_download_wget "$@" + return + fi + log_crit "http_download unable to find wget or curl" + return 1 +} +http_copy() { + tmp=$(mktemp) + http_download "${tmp}" "$1" "$2" || return 1 + body=$(cat "$tmp") + rm -f "${tmp}" + echo "$body" +} +github_release() { + owner_repo=$1 + version=$2 + test -z "$version" && version="latest" + giturl="https://github.com/${owner_repo}/releases/${version}" + json=$(http_copy "$giturl" "Accept:application/json") + test -z "$json" && return 1 + version=$(echo "$json" | tr -s '\n' ' ' | sed 's/.*"tag_name":"//' | sed 's/".*//') + test -z "$version" && return 1 + echo "$version" +} +hash_sha256() { + TARGET=${1:-/dev/stdin} + if is_command gsha256sum; then + hash=$(gsha256sum "$TARGET") || return 1 + echo "$hash" | cut -d ' ' -f 1 + elif is_command sha256sum; then + hash=$(sha256sum "$TARGET") || return 1 + echo "$hash" | cut -d ' ' -f 1 + elif is_command shasum; then + hash=$(shasum -a 256 "$TARGET" 2>/dev/null) || return 1 + echo "$hash" | cut -d ' ' -f 1 + elif is_command openssl; then + hash=$(openssl -dst openssl dgst -sha256 "$TARGET") || return 1 + echo "$hash" | cut -d ' ' -f a + else + log_crit "hash_sha256 unable to find command to compute sha-256 hash" + return 1 + fi +} +hash_sha256_verify() { + TARGET=$1 + checksums=$2 + if [ -z "$checksums" ]; then + log_err "hash_sha256_verify checksum file not specified in arg2" + return 1 + fi + BASENAME=${TARGET##*/} + want=$(grep "${BASENAME}" "${checksums}" 2>/dev/null | tr '\t' ' ' | cut -d ' ' -f 1) + if [ -z "$want" ]; then + log_err "hash_sha256_verify unable to find checksum for '${TARGET}' in '${checksums}'" + return 1 + fi + got=$(hash_sha256 "$TARGET") + if [ "$want" != "$got" ]; then + log_err "hash_sha256_verify checksum for '$TARGET' did not verify ${want} vs $got" + return 1 + fi +} +cat /dev/null <= 0 { + file = file[slash+1:] + } + } + + return fmt.Sprintf("%v:%v", file, line) +} + +func getLogger(ctx context.Context) logrus.FieldLogger { + cfg := GetConfig() + if cfg.Mute { + return noopLogger + } + + entry := logrus.WithFields(logrus.Fields(contextutils.GetLogFields(ctx))) + if cfg.IncludeSourceCode { + entry = entry.WithField(sourceCodeKey, getSourceLocation()) + } + + entry.Level = logrus.Level(cfg.Level) // #nosec G115 + + return entry +} + +// Returns a standard io.PipeWriter that logs using the same logger configurations in this package. +func GetLogWriter(ctx context.Context) *io.PipeWriter { + logger := getLogger(ctx) + return logger.(*logrus.Entry).Writer() +} + +func WithIndent(ctx context.Context, additionalIndent string) context.Context { + indentLevel := getIndent(ctx) + additionalIndent + return context.WithValue(ctx, indentLevelKey, indentLevel) +} + +func getIndent(ctx context.Context) string { + if existing := ctx.Value(indentLevelKey); existing != nil { + return existing.(string) + } + + return "" +} + +// Gets a value indicating whether logs at this level will be written to the logger. This is particularly useful to avoid +// computing log messages unnecessarily. +func IsLoggable(_ context.Context, level Level) bool { + return GetConfig().Level >= level +} + +// Debug logs a message at level Debug on the standard logger. +func Debug(ctx context.Context, args ...interface{}) { + getLogger(ctx).Debug(args...) +} + +// Print logs a message at level Info on the standard logger. +func Print(ctx context.Context, args ...interface{}) { + getLogger(ctx).Print(args...) +} + +// Info logs a message at level Info on the standard logger. +func Info(ctx context.Context, args ...interface{}) { + getLogger(ctx).Info(args...) +} + +// Warn logs a message at level Warn on the standard logger. +func Warn(ctx context.Context, args ...interface{}) { + getLogger(ctx).Warn(args...) +} + +// Warning logs a message at level Warn on the standard logger. +func Warning(ctx context.Context, args ...interface{}) { + getLogger(ctx).Warning(args...) +} + +// Error logs a message at level Error on the standard logger. +func Error(ctx context.Context, args ...interface{}) { + getLogger(ctx).Error(args...) +} + +// Panic logs a message at level Panic on the standard logger. +func Panic(ctx context.Context, args ...interface{}) { + getLogger(ctx).Panic(args...) +} + +// Fatal logs a message at level Fatal on the standard logger. +func Fatal(ctx context.Context, args ...interface{}) { + getLogger(ctx).Fatal(args...) +} + +// Debugf logs a message at level Debug on the standard logger. +func Debugf(ctx context.Context, format string, args ...interface{}) { + getLogger(ctx).Debugf(format, args...) +} + +// Printf logs a message at level Info on the standard logger. +func Printf(ctx context.Context, format string, args ...interface{}) { + getLogger(ctx).Printf(format, args...) +} + +// Infof logs a message at level Info on the standard logger. +func Infof(ctx context.Context, format string, args ...interface{}) { + getLogger(ctx).Infof(format, args...) +} + +// InfofNoCtx logs a formatted message without context. +func InfofNoCtx(format string, args ...interface{}) { + getLogger(context.TODO()).Infof(format, args...) +} + +// Warnf logs a message at level Warn on the standard logger. +func Warnf(ctx context.Context, format string, args ...interface{}) { + getLogger(ctx).Warnf(format, args...) +} + +// Warningf logs a message at level Warn on the standard logger. +func Warningf(ctx context.Context, format string, args ...interface{}) { + getLogger(ctx).Warningf(format, args...) +} + +// Errorf logs a message at level Error on the standard logger. +func Errorf(ctx context.Context, format string, args ...interface{}) { + getLogger(ctx).Errorf(format, args...) +} + +// Panicf logs a message at level Panic on the standard logger. +func Panicf(ctx context.Context, format string, args ...interface{}) { + getLogger(ctx).Panicf(format, args...) +} + +// Fatalf logs a message at level Fatal on the standard logger. +func Fatalf(ctx context.Context, format string, args ...interface{}) { + getLogger(ctx).Fatalf(format, args...) +} + +// Debugln logs a message at level Debug on the standard logger. +func Debugln(ctx context.Context, args ...interface{}) { + getLogger(ctx).Debugln(args...) +} + +// Println logs a message at level Info on the standard logger. +func Println(ctx context.Context, args ...interface{}) { + getLogger(ctx).Println(args...) +} + +// Infoln logs a message at level Info on the standard logger. +func Infoln(ctx context.Context, args ...interface{}) { + getLogger(ctx).Infoln(args...) +} + +// Warnln logs a message at level Warn on the standard logger. +func Warnln(ctx context.Context, args ...interface{}) { + getLogger(ctx).Warnln(args...) +} + +// Warningln logs a message at level Warn on the standard logger. +func Warningln(ctx context.Context, args ...interface{}) { + getLogger(ctx).Warningln(args...) +} + +// Errorln logs a message at level Error on the standard logger. +func Errorln(ctx context.Context, args ...interface{}) { + getLogger(ctx).Errorln(args...) +} + +// Panicln logs a message at level Panic on the standard logger. +func Panicln(ctx context.Context, args ...interface{}) { + getLogger(ctx).Panicln(args...) +} + +// Fatalln logs a message at level Fatal on the standard logger. +func Fatalln(ctx context.Context, args ...interface{}) { + getLogger(ctx).Fatalln(args...) +} + +type NoopLogger struct { +} + +func (NoopLogger) WithField(key string, value interface{}) *logrus.Entry { + return nil +} + +func (NoopLogger) WithFields(fields logrus.Fields) *logrus.Entry { + return nil +} + +func (NoopLogger) WithError(err error) *logrus.Entry { + return nil +} + +func (NoopLogger) Debugf(format string, args ...interface{}) { +} + +func (NoopLogger) Infof(format string, args ...interface{}) { +} + +func (NoopLogger) Warnf(format string, args ...interface{}) { +} + +func (NoopLogger) Warningf(format string, args ...interface{}) { +} + +func (NoopLogger) Errorf(format string, args ...interface{}) { +} + +func (NoopLogger) Debug(args ...interface{}) { +} + +func (NoopLogger) Info(args ...interface{}) { +} + +func (NoopLogger) Warn(args ...interface{}) { +} + +func (NoopLogger) Warning(args ...interface{}) { +} + +func (NoopLogger) Error(args ...interface{}) { +} + +func (NoopLogger) Debugln(args ...interface{}) { +} + +func (NoopLogger) Infoln(args ...interface{}) { +} + +func (NoopLogger) Warnln(args ...interface{}) { +} + +func (NoopLogger) Warningln(args ...interface{}) { +} + +func (NoopLogger) Errorln(args ...interface{}) { +} + +func (NoopLogger) Print(...interface{}) { +} + +func (NoopLogger) Printf(string, ...interface{}) { +} + +func (NoopLogger) Println(...interface{}) { +} + +func (NoopLogger) Fatal(...interface{}) { +} + +func (NoopLogger) Fatalf(string, ...interface{}) { +} + +func (NoopLogger) Fatalln(...interface{}) { +} + +func (NoopLogger) Panic(...interface{}) { +} + +func (NoopLogger) Panicf(string, ...interface{}) { +} + +func (NoopLogger) Panicln(...interface{}) { +} diff --git a/flytestdlib/logger/logger_test.go b/flytestdlib/logger/logger_test.go new file mode 100644 index 0000000000..54b21ea131 --- /dev/null +++ b/flytestdlib/logger/logger_test.go @@ -0,0 +1,622 @@ +// Defines global context-aware logger. +// The default implementation uses logrus. This package registers "logger" config section on init(). The structure of the +// config section is expected to be un-marshal-able to Config struct. +package logger + +import ( + "context" + "reflect" + "strings" + "testing" + + "github.com/sirupsen/logrus" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func init() { + initLogger() +} + +func initLogger() { + if err := SetConfig(&Config{ + Level: InfoLevel, + IncludeSourceCode: true, + }); err != nil { + panic(err) + } +} + +func TestIsLoggable(t *testing.T) { + type args struct { + ctx context.Context + level Level + } + tests := []struct { + name string + args args + want bool + }{ + {"Debug Is not loggable", args{ctx: context.TODO(), level: DebugLevel}, false}, + {"Info Is loggable", args{ctx: context.TODO(), level: InfoLevel}, true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := IsLoggable(tt.args.ctx, tt.args.level); got != tt.want { + t.Errorf("IsLoggable() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDebug(t *testing.T) { + type args struct { + ctx context.Context + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Debug(tt.args.ctx, tt.args.args...) + }) + } +} + +func TestPrint(t *testing.T) { + type args struct { + ctx context.Context + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Print(tt.args.ctx, tt.args.args...) + }) + } +} + +func TestInfo(t *testing.T) { + type args struct { + ctx context.Context + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Info(tt.args.ctx, tt.args.args...) + }) + } +} + +func TestWarn(t *testing.T) { + type args struct { + ctx context.Context + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Warn(tt.args.ctx, tt.args.args...) + }) + } +} + +func TestWarning(t *testing.T) { + type args struct { + ctx context.Context + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Warning(tt.args.ctx, tt.args.args...) + }) + } +} + +func TestError(t *testing.T) { + type args struct { + ctx context.Context + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Error(tt.args.ctx, tt.args.args...) + }) + } +} + +func TestPanic(t *testing.T) { + type args struct { + ctx context.Context + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.Panics(t, func() { + Panic(tt.args.ctx, tt.args.args...) + }) + }) + } +} + +func TestDebugf(t *testing.T) { + type args struct { + ctx context.Context + format string + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Debugf(tt.args.ctx, tt.args.format, tt.args.args...) + }) + } +} + +func TestPrintf(t *testing.T) { + type args struct { + ctx context.Context + format string + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Printf(tt.args.ctx, tt.args.format, tt.args.args...) + }) + } +} + +func TestInfof(t *testing.T) { + type args struct { + ctx context.Context + format string + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Infof(tt.args.ctx, tt.args.format, tt.args.args...) + }) + } +} + +func TestInfofNoCtx(t *testing.T) { + type args struct { + format string + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{format: "%v", args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + InfofNoCtx(tt.args.format, tt.args.args...) + }) + } +} + +func TestWarnf(t *testing.T) { + type args struct { + ctx context.Context + format string + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Warnf(tt.args.ctx, tt.args.format, tt.args.args...) + }) + } +} + +func TestWarningf(t *testing.T) { + type args struct { + ctx context.Context + format string + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Warningf(tt.args.ctx, tt.args.format, tt.args.args...) + }) + } +} + +func TestErrorf(t *testing.T) { + type args struct { + ctx context.Context + format string + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Errorf(tt.args.ctx, tt.args.format, tt.args.args...) + }) + } +} + +func TestPanicf(t *testing.T) { + type args struct { + ctx context.Context + format string + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.Panics(t, func() { + Panicf(tt.args.ctx, tt.args.format, tt.args.args...) + }) + }) + } +} + +func TestDebugln(t *testing.T) { + type args struct { + ctx context.Context + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Debugln(tt.args.ctx, tt.args.args...) + }) + } +} + +func TestPrintln(t *testing.T) { + type args struct { + ctx context.Context + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Println(tt.args.ctx, tt.args.args...) + }) + } +} + +func TestInfoln(t *testing.T) { + type args struct { + ctx context.Context + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Infoln(tt.args.ctx, tt.args.args...) + }) + } +} + +func TestWarnln(t *testing.T) { + type args struct { + ctx context.Context + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Warnln(tt.args.ctx, tt.args.args...) + }) + } +} + +func TestWarningln(t *testing.T) { + type args struct { + ctx context.Context + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Warningln(tt.args.ctx, tt.args.args...) + }) + } +} + +func TestErrorln(t *testing.T) { + type args struct { + ctx context.Context + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Errorln(tt.args.ctx, tt.args.args...) + }) + } +} + +func TestPanicln(t *testing.T) { + type args struct { + ctx context.Context + args []interface{} + } + tests := []struct { + name string + args args + }{ + {"test", args{ctx: context.TODO(), args: []interface{}{"arg"}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.Panics(t, func() { + Panicln(tt.args.ctx, tt.args.args...) + }) + }) + } +} + +func Test_getLogger(t *testing.T) { + type args struct { + ctx context.Context + } + tests := []struct { + name string + args args + want *logrus.Entry + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := getLogger(tt.args.ctx); !reflect.DeepEqual(got, tt.want) { + t.Errorf("getLogger() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestWithIndent(t *testing.T) { + type args struct { + ctx context.Context + additionalIndent string + } + tests := []struct { + name string + args args + want context.Context + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := WithIndent(tt.args.ctx, tt.args.additionalIndent); !reflect.DeepEqual(got, tt.want) { + t.Errorf("WithIndent() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_getIndent(t *testing.T) { + type args struct { + ctx context.Context + } + tests := []struct { + name string + args args + want string + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := getIndent(tt.args.ctx); got != tt.want { + t.Errorf("getIndent() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestFatal(t *testing.T) { + type args struct { + ctx context.Context + args []interface{} + } + tests := []struct { + name string + args args + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Fatal(tt.args.ctx, tt.args.args...) + }) + } +} + +func TestFatalf(t *testing.T) { + type args struct { + ctx context.Context + format string + args []interface{} + } + tests := []struct { + name string + args args + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Fatalf(tt.args.ctx, tt.args.format, tt.args.args...) + }) + } +} + +func TestFatalln(t *testing.T) { + type args struct { + ctx context.Context + args []interface{} + } + tests := []struct { + name string + args args + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + Fatalln(tt.args.ctx, tt.args.args...) + }) + } +} + +func Test_onConfigUpdated(t *testing.T) { + type args struct { + cfg Config + } + tests := []struct { + name string + args args + }{ + {"testtext", args{Config{Formatter: FormatterConfig{FormatterText}}}}, + {"testjson", args{Config{Formatter: FormatterConfig{FormatterJSON}}}}, + {"testgcp", args{Config{Formatter: FormatterConfig{FormatterGCP}}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + onConfigUpdated(tt.args.cfg) + }) + } + initLogger() +} + +type loggerHook struct { + messages []string +} + +func (h *loggerHook) Levels() []logrus.Level { + return logrus.AllLevels +} + +func (h *loggerHook) Fire(entry *logrus.Entry) error { + s, err := entry.String() + if err != nil { + panic(err) + } + h.messages = append(h.messages, s) + return nil +} + +func TestConfigFormatterJson_DontEscapeHTML(t *testing.T) { + ctx := context.TODO() + hook := &loggerHook{} + logrus.AddHook(hook) + + Info(ctx, "foo&bar") + require.Len(t, hook.messages, 1) + assert.True(t, strings.Contains(hook.messages[0], "foo&bar"), hook.messages[0]) +} diff --git a/flytestdlib/metrics/count.go b/flytestdlib/metrics/count.go new file mode 100644 index 0000000000..2482930f33 --- /dev/null +++ b/flytestdlib/metrics/count.go @@ -0,0 +1,47 @@ +package metrics + +import ( + "github.com/prometheus/client_golang/prometheus" + + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +type SuccessAndFailureCounter struct { + success prometheus.Counter + failure prometheus.Counter +} + +func (c SuccessAndFailureCounter) Inc(err *error) { + if err != nil && *err != nil { + c.failure.Inc() + } else { + c.success.Inc() + } +} + +func NewSuccessAndFailureCounter(scope promutils.Scope) SuccessAndFailureCounter { + return SuccessAndFailureCounter{ + success: scope.MustNewCounter("success", "Number of successful events handled"), + failure: scope.MustNewCounter("failure", "Number of failed events handled"), + } +} + +type SuccessAndFailureCounterVec struct { + success *prometheus.CounterVec + failure *prometheus.CounterVec +} + +func (c SuccessAndFailureCounterVec) Inc(err *error, labels prometheus.Labels) { + if err != nil && *err != nil { + c.failure.With(labels).Inc() + } else { + c.success.With(labels).Inc() + } +} + +func NewSuccessAndFailureCounterVec(scope promutils.Scope, labels ...string) SuccessAndFailureCounterVec { + return SuccessAndFailureCounterVec{ + success: scope.MustNewCounterVec("success", "Number of successful events handled", labels...), + failure: scope.MustNewCounterVec("failure", "Number of failed events handled", labels...), + } +} diff --git a/flytestdlib/metrics/crud.go b/flytestdlib/metrics/crud.go new file mode 100644 index 0000000000..d4b431a400 --- /dev/null +++ b/flytestdlib/metrics/crud.go @@ -0,0 +1,108 @@ +package metrics + +import ( + "context" + "time" + + "github.com/prometheus/client_golang/prometheus" + + "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils/labeled" +) + +type APITimer struct { + Success labeled.Timer + Failure labeled.Timer +} + +func (a APITimer) Stop(err *error) { + if err != nil && *err != nil && !errors.IsNotFound(*err) { + a.Failure.Stop() + } else { + a.Success.Stop() + } +} + +type API struct { + Success labeled.StopWatch + Failure labeled.StopWatch +} + +func (a API) Start(ctx context.Context) APITimer { + return APITimer{ + Success: a.Success.Start(ctx), + Failure: a.Failure.Start(ctx), + } +} + +type OperationTimer struct { + Start time.Time + Success prometheus.Observer + Failure prometheus.Observer +} + +func (o OperationTimer) Stop(err *error) { + seconds := time.Since(o.Start).Seconds() + if err != nil && *err != nil && !errors.IsNotFound(*err) { + o.Failure.Observe(seconds) + } else { + o.Success.Observe(seconds) + } +} + +type Operation struct { + Success *prometheus.HistogramVec + Failure *prometheus.HistogramVec +} + +func (o Operation) Start(values ...string) OperationTimer { + return OperationTimer{ + Start: time.Now(), + Success: o.Success.WithLabelValues(values...), + Failure: o.Failure.WithLabelValues(values...), + } +} + +type CRUD struct { + Create API + Read API + Update API + Delete API + Undelete API + List API + Count API +} + +func NewAPI(scope promutils.Scope) API { + return API{ + Success: labeled.NewStopWatch("success", "api succeeded", time.Millisecond, scope), + Failure: labeled.NewStopWatch("failure", "api failed", time.Millisecond, scope), + } +} + +// NewOperationHistogram creates 2 histogram metrics for tracking success & failure durations. +// +// The resulting operations requires len(labels) + 1 labels, where the last label is the respective "operation". +// +// Histograms have higher performance impact on Prometheus server when calculating quantiles: +// https://prometheus.io/docs/practices/histograms/#quantiles +func NewOperationHistogram(scope promutils.Scope, labels ...string) Operation { + labelSlice := append(labels, "operation") + return Operation{ + Success: scope.MustNewHistogramVec("success", "operation succeeded", labelSlice...), + Failure: scope.MustNewHistogramVec("failure", "operation failed", labelSlice...), + } +} + +func NewCRUD(scope promutils.Scope) CRUD { + return CRUD{ + Create: NewAPI(scope.NewSubScope("create")), + Read: NewAPI(scope.NewSubScope("read")), + Update: NewAPI(scope.NewSubScope("update")), + List: NewAPI(scope.NewSubScope("list")), + Delete: NewAPI(scope.NewSubScope("delete")), + Undelete: NewAPI(scope.NewSubScope("undelete")), + Count: NewAPI(scope.NewSubScope("count")), + } +} diff --git a/flytestdlib/otelutils/config.go b/flytestdlib/otelutils/config.go new file mode 100644 index 0000000000..25972e0c51 --- /dev/null +++ b/flytestdlib/otelutils/config.go @@ -0,0 +1,91 @@ +package otelutils + +import ( + "context" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +//go:generate pflags Config --default-var=defaultConfig + +const configSectionKey = "otel" + +type ExporterType = string + +const ( + NoopExporter ExporterType = "noop" + FileExporter ExporterType = "file" + JaegerExporter ExporterType = "jaeger" + OtlpGrpcExporter ExporterType = "otlpgrpc" + OtlpHttpExporter ExporterType = "otlphttp" // nolint:golint +) + +type SamplerType = string + +const ( + AlwaysSample SamplerType = "always" + TraceIDRatioBased SamplerType = "traceid" +) + +var ( + ConfigSection = config.MustRegisterSection(configSectionKey, defaultConfig) + defaultConfig = &Config{ + ExporterType: NoopExporter, + FileConfig: FileConfig{ + Filename: "/tmp/trace.txt", + }, + JaegerConfig: JaegerConfig{ + Endpoint: "http://localhost:14268/api/traces", + }, + OtlpGrpcConfig: OtlpGrpcConfig{ + Endpoint: "http://localhost:4317", + }, + OtlpHttpConfig: OtlpHttpConfig{ + Endpoint: "http://localhost:4318/v1/traces", + }, + SamplerConfig: SamplerConfig{ + ParentSampler: AlwaysSample, + TraceIDRatio: 0.01, + }, + } +) + +type Config struct { + ExporterType ExporterType `json:"type" pflag:",Sets the type of exporter to configure [noop/file/jaeger/otlpgrpc/otlphttp]."` + FileConfig FileConfig `json:"file" pflag:",Configuration for exporting telemetry traces to a file"` + JaegerConfig JaegerConfig `json:"jaeger" pflag:",Configuration for exporting telemetry traces to a jaeger"` + OtlpGrpcConfig OtlpGrpcConfig `json:"otlpgrpc" pflag:",Configuration for exporting telemetry traces to an OTLP gRPC collector"` + OtlpHttpConfig OtlpHttpConfig `json:"otlphttp" pflag:",Configuration for exporting telemetry traces to an OTLP HTTP collector"` // nolint:golint + SamplerConfig SamplerConfig `json:"sampler" pflag:",Configuration for the sampler to use for the tracer"` +} + +type FileConfig struct { + Filename string `json:"filename" pflag:",Filename to store exported telemetry traces"` +} + +type JaegerConfig struct { + Endpoint string `json:"endpoint" pflag:",Endpoint for the jaeger telemetry trace ingestor"` +} + +type OtlpGrpcConfig struct { + Endpoint string `json:"endpoint" pflag:",Endpoint for the OTLP telemetry trace collector"` +} + +type OtlpHttpConfig struct { // nolint:golint + Endpoint string `json:"endpoint" pflag:",Endpoint for the OTLP telemetry trace collector"` +} + +type SamplerConfig struct { + ParentSampler SamplerType `json:"parentSampler" pflag:",Sets the parent sampler to use for the tracer"` + TraceIDRatio float64 `json:"traceIdRatio" pflag:"-,Sets the trace id ratio for the TraceIdRatioBased sampler"` +} + +func GetConfig() *Config { + if c, ok := ConfigSection.GetConfig().(*Config); ok { + return c + } + + logger.Warnf(context.TODO(), "Failed to retrieve config section [%v].", configSectionKey) + return nil +} diff --git a/flytestdlib/otelutils/config_flags.go b/flytestdlib/otelutils/config_flags.go new file mode 100755 index 0000000000..03aede06b0 --- /dev/null +++ b/flytestdlib/otelutils/config_flags.go @@ -0,0 +1,60 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package otelutils + +import ( + "encoding/json" + "reflect" + + "fmt" + + "github.com/spf13/pflag" +) + +// If v is a pointer, it will get its element value or the zero value of the element type. +// If v is not a pointer, it will return it as is. +func (Config) elemValueOrNil(v interface{}) interface{} { + if t := reflect.TypeOf(v); t.Kind() == reflect.Ptr { + if reflect.ValueOf(v).IsNil() { + return reflect.Zero(t.Elem()).Interface() + } else { + return reflect.ValueOf(v).Interface() + } + } else if v == nil { + return reflect.Zero(t).Interface() + } + + return v +} + +func (Config) mustJsonMarshal(v interface{}) string { + raw, err := json.Marshal(v) + if err != nil { + panic(err) + } + + return string(raw) +} + +func (Config) mustMarshalJSON(v json.Marshaler) string { + raw, err := v.MarshalJSON() + if err != nil { + panic(err) + } + + return string(raw) +} + +// GetPFlagSet will return strongly types pflags for all fields in Config and its nested types. The format of the +// flags is json-name.json-sub-name... etc. +func (cfg Config) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("Config", pflag.ExitOnError) + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "type"), defaultConfig.ExporterType, "Sets the type of exporter to configure [noop/file/jaeger/otlpgrpc/otlphttp].") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "file.filename"), defaultConfig.FileConfig.Filename, "Filename to store exported telemetry traces") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "jaeger.endpoint"), defaultConfig.JaegerConfig.Endpoint, "Endpoint for the jaeger telemetry trace ingestor") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "otlpgrpc.endpoint"), defaultConfig.OtlpGrpcConfig.Endpoint, "Endpoint for the OTLP telemetry trace collector") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "otlphttp.endpoint"), defaultConfig.OtlpHttpConfig.Endpoint, "Endpoint for the OTLP telemetry trace collector") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "sampler.parentSampler"), defaultConfig.SamplerConfig.ParentSampler, "Sets the parent sampler to use for the tracer") + return cmdFlags +} diff --git a/flytestdlib/otelutils/config_flags_test.go b/flytestdlib/otelutils/config_flags_test.go new file mode 100755 index 0000000000..6435a88e54 --- /dev/null +++ b/flytestdlib/otelutils/config_flags_test.go @@ -0,0 +1,186 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package otelutils + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "testing" + + "github.com/mitchellh/mapstructure" + "github.com/stretchr/testify/assert" +) + +var dereferencableKindsConfig = map[reflect.Kind]struct{}{ + reflect.Array: {}, reflect.Chan: {}, reflect.Map: {}, reflect.Ptr: {}, reflect.Slice: {}, +} + +// Checks if t is a kind that can be dereferenced to get its underlying type. +func canGetElementConfig(t reflect.Kind) bool { + _, exists := dereferencableKindsConfig[t] + return exists +} + +// This decoder hook tests types for json unmarshaling capability. If implemented, it uses json unmarshal to build the +// object. Otherwise, it'll just pass on the original data. +func jsonUnmarshalerHookConfig(_, to reflect.Type, data interface{}) (interface{}, error) { + unmarshalerType := reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + if to.Implements(unmarshalerType) || reflect.PtrTo(to).Implements(unmarshalerType) || + (canGetElementConfig(to.Kind()) && to.Elem().Implements(unmarshalerType)) { + + raw, err := json.Marshal(data) + if err != nil { + fmt.Printf("Failed to marshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + res := reflect.New(to).Interface() + err = json.Unmarshal(raw, &res) + if err != nil { + fmt.Printf("Failed to umarshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + return res, nil + } + + return data, nil +} + +func decode_Config(input, result interface{}) error { + config := &mapstructure.DecoderConfig{ + TagName: "json", + WeaklyTypedInput: true, + Result: result, + DecodeHook: mapstructure.ComposeDecodeHookFunc( + mapstructure.StringToTimeDurationHookFunc(), + mapstructure.StringToSliceHookFunc(","), + jsonUnmarshalerHookConfig, + ), + } + + decoder, err := mapstructure.NewDecoder(config) + if err != nil { + return err + } + + return decoder.Decode(input) +} + +func join_Config(arr interface{}, sep string) string { + listValue := reflect.ValueOf(arr) + strs := make([]string, 0, listValue.Len()) + for i := 0; i < listValue.Len(); i++ { + strs = append(strs, fmt.Sprintf("%v", listValue.Index(i))) + } + + return strings.Join(strs, sep) +} + +func testDecodeJson_Config(t *testing.T, val, result interface{}) { + assert.NoError(t, decode_Config(val, result)) +} + +func testDecodeRaw_Config(t *testing.T, vStringSlice, result interface{}) { + assert.NoError(t, decode_Config(vStringSlice, result)) +} + +func TestConfig_GetPFlagSet(t *testing.T) { + val := Config{} + cmdFlags := val.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) +} + +func TestConfig_SetFlags(t *testing.T) { + actual := Config{} + cmdFlags := actual.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) + + t.Run("Test_type", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("type", testValue) + if vString, err := cmdFlags.GetString("type"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.ExporterType) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_file.filename", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("file.filename", testValue) + if vString, err := cmdFlags.GetString("file.filename"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.FileConfig.Filename) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_jaeger.endpoint", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("jaeger.endpoint", testValue) + if vString, err := cmdFlags.GetString("jaeger.endpoint"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.JaegerConfig.Endpoint) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_otlpgrpc.endpoint", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("otlpgrpc.endpoint", testValue) + if vString, err := cmdFlags.GetString("otlpgrpc.endpoint"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.OtlpGrpcConfig.Endpoint) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_otlphttp.endpoint", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("otlphttp.endpoint", testValue) + if vString, err := cmdFlags.GetString("otlphttp.endpoint"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.OtlpHttpConfig.Endpoint) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_sampler.parentSampler", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("sampler.parentSampler", testValue) + if vString, err := cmdFlags.GetString("sampler.parentSampler"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.SamplerConfig.ParentSampler) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) +} diff --git a/flytestdlib/otelutils/factory.go b/flytestdlib/otelutils/factory.go new file mode 100644 index 0000000000..5d910c141e --- /dev/null +++ b/flytestdlib/otelutils/factory.go @@ -0,0 +1,145 @@ +package otelutils + +import ( + "context" + "fmt" + "os" + + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/exporters/jaeger" // nolint:staticcheck + "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc" + "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp" + "go.opentelemetry.io/otel/exporters/stdout/stdouttrace" + "go.opentelemetry.io/otel/sdk/resource" + "go.opentelemetry.io/otel/sdk/trace" + semconv "go.opentelemetry.io/otel/semconv/v1.24.0" + rawtrace "go.opentelemetry.io/otel/trace" + "go.opentelemetry.io/otel/trace/noop" + + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/version" +) + +const ( + AdminClientTracer = "admin-client" + AdminGormTracer = "admin-gorm" + AdminServerTracer = "admin-server" + BlobstoreClientTracer = "blobstore-client" + DataCatalogClientTracer = "datacatalog-client" + DataCatalogGormTracer = "datacatalog-gorm" + DataCatalogServerTracer = "datacatalog-server" + FlytePropellerTracer = "flytepropeller" + K8sClientTracer = "k8s-client" +) + +var tracerProviders = make(map[string]*trace.TracerProvider) +var noopTracerProvider = noop.NewTracerProvider() + +// RegisterTracerProviderWithContext registers a tracer provider for the given service name. +func RegisterTracerProviderWithContext(ctx context.Context, serviceName string, config *Config) error { + if config == nil { + return nil + } + + var exporter trace.SpanExporter + var err error + switch config.ExporterType { + case NoopExporter: + return nil + case FileExporter: + // configure file exporter + f, err := os.Create(config.FileConfig.Filename) + if err != nil { + return err + } + + exporter, err = stdouttrace.New( + stdouttrace.WithWriter(f), + stdouttrace.WithPrettyPrint(), + ) + if err != nil { + return err + } + case JaegerExporter: + // configure jaeger exporter + exporter, err = jaeger.New( + jaeger.WithCollectorEndpoint( + jaeger.WithEndpoint(config.JaegerConfig.Endpoint), + ), + ) + if err != nil { + return err + } + case OtlpGrpcExporter: + exporter, err = otlptracegrpc.New( + ctx, + otlptracegrpc.WithEndpointURL(config.OtlpGrpcConfig.Endpoint), + ) + if err != nil { + return err + } + case OtlpHttpExporter: + exporter, err = otlptracehttp.New( + ctx, + otlptracehttp.WithEndpointURL(config.OtlpHttpConfig.Endpoint), + ) + if err != nil { + return err + } + default: + return fmt.Errorf("unknown otel exporter type [%v]", config.ExporterType) + } + + telemetryResource, err := resource.Merge( + resource.Default(), + resource.NewWithAttributes( + semconv.SchemaURL, + semconv.ServiceNameKey.String(serviceName), + semconv.ServiceVersionKey.String(version.Version), + ), + ) + if err != nil { + return err + } + + var sampler trace.Sampler + switch config.SamplerConfig.ParentSampler { + case AlwaysSample: + sampler = trace.ParentBased(trace.AlwaysSample()) + case TraceIDRatioBased: + sampler = trace.ParentBased(trace.TraceIDRatioBased(config.SamplerConfig.TraceIDRatio)) + default: + return fmt.Errorf("unknown otel sampler type [%v]", config.SamplerConfig.ParentSampler) + } + + opts := []trace.TracerProviderOption{ + trace.WithBatcher(exporter), + trace.WithResource(telemetryResource), + trace.WithSampler(sampler), + } + tracerProvider := trace.NewTracerProvider(opts...) + tracerProviders[serviceName] = tracerProvider + return nil +} + +// GetTracerProvider returns the tracer provider for the given service name. +func GetTracerProvider(serviceName string) rawtrace.TracerProvider { + if t, ok := tracerProviders[serviceName]; ok { + return t + } + + return noopTracerProvider +} + +// NewSpan creates a new span with the given service name and span name. +func NewSpan(ctx context.Context, serviceName string, spanName string) (context.Context, rawtrace.Span) { + var attributes []attribute.KeyValue + for key, value := range contextutils.GetLogFields(ctx) { + if value, ok := value.(string); ok { + attributes = append(attributes, attribute.String(key, value)) + } + } + + tracerProvider := GetTracerProvider(serviceName) + return tracerProvider.Tracer("default").Start(ctx, spanName, rawtrace.WithAttributes(attributes...)) +} diff --git a/flytestdlib/otelutils/factory_test.go b/flytestdlib/otelutils/factory_test.go new file mode 100644 index 0000000000..113bdf3793 --- /dev/null +++ b/flytestdlib/otelutils/factory_test.go @@ -0,0 +1,43 @@ +package otelutils + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestRegisterTracerProviderWithContext(t *testing.T) { + ctx := context.Background() + serviceName := "foo" + + // register tracer provider with no exporters + err := RegisterTracerProviderWithContext(ctx, serviceName, defaultConfig) + assert.Nil(t, err) + + // validate no tracerProviders are registered + assert.Len(t, tracerProviders, 0) + + // register tracer provider with all exporters + fullConfig := Config{ + ExporterType: FileExporter, + FileConfig: FileConfig{ + Filename: "/dev/null", + }, + JaegerConfig: JaegerConfig{}, + SamplerConfig: SamplerConfig{ + ParentSampler: AlwaysSample, + }, + } + err = RegisterTracerProviderWithContext(ctx, serviceName, &fullConfig) + assert.Nil(t, err) + + // validate tracerProvider is registered + assert.Len(t, tracerProviders, 1) +} + +func TestNewSpan(t *testing.T) { + ctx := context.TODO() + _, span := NewSpan(ctx, "bar", "baz/bat") + span.End() +} diff --git a/flytestdlib/otelutils/k8s.go b/flytestdlib/otelutils/k8s.go new file mode 100644 index 0000000000..13afee9308 --- /dev/null +++ b/flytestdlib/otelutils/k8s.go @@ -0,0 +1,103 @@ +package otelutils + +import ( + "context" + "fmt" + + "sigs.k8s.io/controller-runtime/pkg/cache" + "sigs.k8s.io/controller-runtime/pkg/client" +) + +const k8sSpanPathPrefix = "controller-runtime.pkg.client" + +type K8sCacheWrapper struct { + cache.Cache +} + +func WrapK8sCache(c cache.Cache) cache.Cache { + return &K8sCacheWrapper{c} +} + +func (c *K8sCacheWrapper) Get(ctx context.Context, key client.ObjectKey, obj client.Object, opts ...client.GetOption) error { + ctx, span := NewSpan(ctx, K8sClientTracer, fmt.Sprintf("%s.Cache/Get", k8sSpanPathPrefix)) + defer span.End() + return c.Cache.Get(ctx, key, obj, opts...) +} + +func (c *K8sCacheWrapper) List(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error { + ctx, span := NewSpan(ctx, K8sClientTracer, fmt.Sprintf("%s.Cache/List", k8sSpanPathPrefix)) + defer span.End() + return c.Cache.List(ctx, list, opts...) +} + +type K8sClientWrapper struct { + client.Client + + statusWriter *K8sStatusWriterWrapper +} + +func WrapK8sClient(c client.Client) client.Client { + return &K8sClientWrapper{c, &K8sStatusWriterWrapper{c.Status()}} +} + +func (c *K8sClientWrapper) Get(ctx context.Context, key client.ObjectKey, obj client.Object, opts ...client.GetOption) error { + ctx, span := NewSpan(ctx, K8sClientTracer, fmt.Sprintf("%s.Client/Get", k8sSpanPathPrefix)) + defer span.End() + return c.Client.Get(ctx, key, obj, opts...) +} + +func (c *K8sClientWrapper) List(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error { + ctx, span := NewSpan(ctx, K8sClientTracer, fmt.Sprintf("%s.Client/List", k8sSpanPathPrefix)) + defer span.End() + return c.Client.List(ctx, list, opts...) +} + +func (c *K8sClientWrapper) Create(ctx context.Context, obj client.Object, opts ...client.CreateOption) error { + ctx, span := NewSpan(ctx, K8sClientTracer, fmt.Sprintf("%s.Client/Create", k8sSpanPathPrefix)) + defer span.End() + return c.Client.Create(ctx, obj, opts...) +} + +func (c *K8sClientWrapper) Delete(ctx context.Context, obj client.Object, opts ...client.DeleteOption) error { + ctx, span := NewSpan(ctx, K8sClientTracer, fmt.Sprintf("%s.Client/Delete", k8sSpanPathPrefix)) + defer span.End() + return c.Client.Delete(ctx, obj, opts...) +} + +func (c *K8sClientWrapper) Update(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error { + ctx, span := NewSpan(ctx, K8sClientTracer, fmt.Sprintf("%s.Client/Update", k8sSpanPathPrefix)) + defer span.End() + return c.Client.Update(ctx, obj, opts...) +} + +func (c *K8sClientWrapper) Patch(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption) error { + ctx, span := NewSpan(ctx, K8sClientTracer, fmt.Sprintf("%s.Client/Patch", k8sSpanPathPrefix)) + defer span.End() + return c.Client.Patch(ctx, obj, patch, opts...) +} + +func (c *K8sClientWrapper) DeleteAllOf(ctx context.Context, obj client.Object, opts ...client.DeleteAllOfOption) error { + ctx, span := NewSpan(ctx, K8sClientTracer, fmt.Sprintf("%s.Client/DeleteAllOf", k8sSpanPathPrefix)) + defer span.End() + return c.Client.DeleteAllOf(ctx, obj, opts...) +} + +func (c *K8sClientWrapper) Status() client.StatusWriter { + return c.statusWriter +} + +type K8sStatusWriterWrapper struct { + client.StatusWriter +} + +func (s *K8sStatusWriterWrapper) Update(ctx context.Context, obj client.Object, opts ...client.SubResourceUpdateOption) error { + ctx, span := NewSpan(ctx, K8sClientTracer, fmt.Sprintf("%s.StatusWriter/Update", k8sSpanPathPrefix)) + defer span.End() + return s.StatusWriter.Update(ctx, obj, opts...) +} + +func (s *K8sStatusWriterWrapper) Patch(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.SubResourcePatchOption) error { + ctx, span := NewSpan(ctx, K8sClientTracer, fmt.Sprintf("%s.StatusWriter/Patch", k8sSpanPathPrefix)) + defer span.End() + return s.StatusWriter.Patch(ctx, obj, patch, opts...) +} diff --git a/flytestdlib/pbhash/pbhash.go b/flytestdlib/pbhash/pbhash.go new file mode 100644 index 0000000000..c21cc8a2d6 --- /dev/null +++ b/flytestdlib/pbhash/pbhash.go @@ -0,0 +1,57 @@ +// This is a package that provides hashing utilities for Protobuf objects. +package pbhash + +import ( + "context" + "encoding/base64" + + goObjectHash "github.com/benlaurie/objecthash/go/objecthash" + "github.com/golang/protobuf/jsonpb" + "github.com/golang/protobuf/proto" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +var marshaller = &jsonpb.Marshaler{} + +func fromHashToByteArray(input [32]byte) []byte { + output := make([]byte, 32) + copy(output, input[:]) + return output +} + +// ComputeHash generate a deterministic hash in bytes for the pb object +func ComputeHash(ctx context.Context, pb proto.Message) ([]byte, error) { + // We marshal the pb object to JSON first which should provide a consistent mapping of pb to json fields as stated + // here: https://developers.google.com/protocol-buffers/docs/proto3#json + // jsonpb marshalling includes: + // - sorting map values to provide a stable output + // - omitting empty values which supports backwards compatibility of old protobuf definitions + // We do not use protobuf marshalling because it does not guarantee stable output because of how it handles + // unknown fields and ordering of fields. https://github.com/protocolbuffers/protobuf/issues/2830 + pbJSON, err := marshaller.MarshalToString(pb) + if err != nil { + logger.Warning(ctx, "failed to marshal pb [%+v] to JSON with err %v", pb, err) + return nil, err + } + + // Deterministically hash the JSON object to a byte array. The library will sort the map keys of the JSON object + // so that we do not run into the issues from pb marshalling. + hash, err := goObjectHash.CommonJSONHash(pbJSON) + if err != nil { + logger.Warning(ctx, "failed to hash JSON for pb [%+v] with err %v", pb, err) + return nil, err + } + + return fromHashToByteArray(hash), err +} + +// Generate a deterministic hash as a base64 encoded string for the pb object. +func ComputeHashString(ctx context.Context, pb proto.Message) (string, error) { + hashBytes, err := ComputeHash(ctx, pb) + if err != nil { + return "", err + } + + return base64.StdEncoding.EncodeToString(hashBytes), nil +} diff --git a/flytestdlib/pbhash/pbhash_test.go b/flytestdlib/pbhash/pbhash_test.go new file mode 100644 index 0000000000..75735b4135 --- /dev/null +++ b/flytestdlib/pbhash/pbhash_test.go @@ -0,0 +1,145 @@ +package pbhash + +import ( + "context" + "testing" + "time" + + "github.com/golang/protobuf/proto" + "github.com/golang/protobuf/ptypes" + "github.com/golang/protobuf/ptypes/duration" + "github.com/golang/protobuf/ptypes/timestamp" + "github.com/stretchr/testify/assert" +) + +// Mock a Protobuf generated GO object +type mockProtoMessage struct { + Integer int64 `protobuf:"varint,1,opt,name=integer,proto3" json:"integer,omitempty"` + FloatValue float64 `protobuf:"fixed64,2,opt,name=float_value,json=floatValue,proto3" json:"float_value,omitempty"` + StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,proto3" json:"string_value,omitempty"` + Boolean bool `protobuf:"varint,4,opt,name=boolean,proto3" json:"boolean,omitempty"` + Datetime *timestamp.Timestamp `protobuf:"bytes,5,opt,name=datetime,proto3" json:"datetime,omitempty"` + Duration *duration.Duration `protobuf:"bytes,6,opt,name=duration,proto3" json:"duration,omitempty"` + MapValue map[string]string `protobuf:"bytes,7,rep,name=map_value,json=mapValue,proto3" json:"map_value,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + Collections []string `protobuf:"bytes,8,rep,name=collections,proto3" json:"collections,omitempty"` +} + +func (mockProtoMessage) Reset() { +} + +func (m mockProtoMessage) String() string { + return proto.CompactTextString(m) +} + +func (mockProtoMessage) ProtoMessage() { +} + +// Mock an older version of the above pb object that doesn't have some fields +type mockOlderProto struct { + Integer int64 `protobuf:"varint,1,opt,name=integer,proto3" json:"integer,omitempty"` + FloatValue float64 `protobuf:"fixed64,2,opt,name=float_value,json=floatValue,proto3" json:"float_value,omitempty"` + StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,proto3" json:"string_value,omitempty"` + Boolean bool `protobuf:"varint,4,opt,name=boolean,proto3" json:"boolean,omitempty"` +} + +func (mockOlderProto) Reset() { +} + +func (m mockOlderProto) String() string { + return proto.CompactTextString(m) +} + +func (mockOlderProto) ProtoMessage() { +} + +var sampleTime, _ = ptypes.TimestampProto( + time.Date(2019, 03, 29, 12, 0, 0, 0, time.UTC)) + +func TestProtoHash(t *testing.T) { + mockProto := &mockProtoMessage{ + Integer: 18, + FloatValue: 1.3, + StringValue: "lets test this", + Boolean: true, + Datetime: sampleTime, + Duration: ptypes.DurationProto(time.Millisecond), + MapValue: map[string]string{ + "z": "last", + "a": "first", + }, + Collections: []string{"1", "2", "3"}, + } + + expectedHashedMockProto := []byte{0x62, 0x95, 0xb2, 0x2c, 0x23, 0xf5, 0x35, 0x6d, 0x3, 0x56, 0x4d, 0xc7, 0x8f, 0xae, + 0x2d, 0x2b, 0xbd, 0x7, 0xff, 0xdb, 0x7e, 0xe5, 0xf4, 0x25, 0x8f, 0xbc, 0xb2, 0xc, 0xad, 0xa5, 0x48, 0x44} + expectedHashString := "YpWyLCP1NW0DVk3Hj64tK70H/9t+5fQlj7yyDK2lSEQ=" + + t.Run("TestFullProtoHash", func(t *testing.T) { + hashedBytes, err := ComputeHash(context.Background(), mockProto) + assert.Nil(t, err) + assert.Equal(t, expectedHashedMockProto, hashedBytes) + assert.Len(t, hashedBytes, 32) + + hashedString, err := ComputeHashString(context.Background(), mockProto) + assert.Nil(t, err) + assert.Equal(t, hashedString, expectedHashString) + }) + + t.Run("TestFullProtoHashReorderKeys", func(t *testing.T) { + mockProto.MapValue = map[string]string{"a": "first", "z": "last"} + hashedBytes, err := ComputeHash(context.Background(), mockProto) + assert.Nil(t, err) + assert.Equal(t, expectedHashedMockProto, hashedBytes) + assert.Len(t, hashedBytes, 32) + + hashedString, err := ComputeHashString(context.Background(), mockProto) + assert.Nil(t, err) + assert.Equal(t, hashedString, expectedHashString) + }) +} + +func TestPartialFilledProtoHash(t *testing.T) { + + mockProtoOmitEmpty := &mockProtoMessage{ + Integer: 18, + FloatValue: 1.3, + StringValue: "lets test this", + Boolean: true, + } + + expectedHashedMockProtoOmitEmpty := []byte{0x1a, 0x13, 0xcc, 0x4c, 0xab, 0xc9, 0x7d, 0x43, 0xc7, 0x2b, 0xc5, 0x37, + 0xbc, 0x49, 0xa8, 0x8b, 0xfc, 0x1d, 0x54, 0x1c, 0x7b, 0x21, 0x04, 0x8f, 0xab, 0x28, 0xc6, 0x5c, 0x06, 0x73, + 0xaa, 0xe2} + + expectedHashStringOmitEmpty := "GhPMTKvJfUPHK8U3vEmoi/wdVBx7IQSPqyjGXAZzquI=" + + t.Run("TestPartial", func(t *testing.T) { + hashedBytes, err := ComputeHash(context.Background(), mockProtoOmitEmpty) + assert.Nil(t, err) + assert.Equal(t, expectedHashedMockProtoOmitEmpty, hashedBytes) + assert.Len(t, hashedBytes, 32) + + hashedString, err := ComputeHashString(context.Background(), mockProtoOmitEmpty) + assert.Nil(t, err) + assert.Equal(t, hashedString, expectedHashStringOmitEmpty) + }) + + mockOldProtoMessage := &mockOlderProto{ + Integer: 18, + FloatValue: 1.3, + StringValue: "lets test this", + Boolean: true, + } + + t.Run("TestOlderProto", func(t *testing.T) { + hashedBytes, err := ComputeHash(context.Background(), mockOldProtoMessage) + assert.Nil(t, err) + assert.Equal(t, expectedHashedMockProtoOmitEmpty, hashedBytes) + assert.Len(t, hashedBytes, 32) + + hashedString, err := ComputeHashString(context.Background(), mockProtoOmitEmpty) + assert.Nil(t, err) + assert.Equal(t, hashedString, expectedHashStringOmitEmpty) + }) + +} diff --git a/flytestdlib/profutils/server.go b/flytestdlib/profutils/server.go new file mode 100644 index 0000000000..ed0aaf0f4e --- /dev/null +++ b/flytestdlib/profutils/server.go @@ -0,0 +1,141 @@ +package profutils + +import ( + "context" + "encoding/json" + "fmt" + "net/http" + _ "net/http/pprof" // #nosec G108 Import for pprof server + "time" + + "github.com/prometheus/client_golang/prometheus/promhttp" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/version" +) + +const ( + healthcheck = "/healthcheck" + metricsPath = "/metrics" + versionPath = "/version" + configPath = "/config" +) + +const ( + contentTypeHeader = "Content-Type" + contentTypeJSON = "application/json; charset=utf-8" +) + +type BuildVersion struct { + Build string `json:"build"` + Version string `json:"version"` + Timestamp string `json:"timestamp,string"` +} + +// Writes a string to the Http output stream +func WriteStringResponse(resp http.ResponseWriter, code int, body string) error { + resp.WriteHeader(code) + _, err := resp.Write([]byte(body)) + return err +} + +// Writes a JSON to the http output stream +func WriteJSONResponse(resp http.ResponseWriter, code int, body interface{}) error { + resp.Header().Set(contentTypeHeader, contentTypeJSON) + resp.WriteHeader(code) + j, err := json.Marshal(body) + if err != nil { + return WriteStringResponse(resp, http.StatusInternalServerError, err.Error()) + } + return WriteStringResponse(resp, http.StatusOK, string(j)) +} + +// Simple healthcheck module that returns OK and provides a simple L7 healthcheck +// TODO we may want to provide a simple function that returns a bool, where users could provide custom healthchecks +func healtcheckHandler(w http.ResponseWriter, req *http.Request) { + err := WriteStringResponse(w, http.StatusOK, http.StatusText(http.StatusOK)) + if err != nil { + panic(err) + } +} + +// Handler that returns a JSON response indicating the Build Version information (refer to #version module) +func versionHandler(w http.ResponseWriter, req *http.Request) { + err := WriteJSONResponse( + w, + http.StatusOK, + BuildVersion{ + Build: version.Build, + Version: version.Version, + Timestamp: version.BuildTime, + }) + if err != nil { + panic(err) + } +} + +// Provides a handler that dumps the config information as a string +func configHandler(w http.ResponseWriter, req *http.Request) { + m, err := config.AllConfigsAsMap(config.GetRootSection()) + if err != nil { + err = WriteStringResponse(w, http.StatusInternalServerError, err.Error()) + if err != nil { + logger.Errorf(context.TODO(), "Failed to write error response. Error: %v", err) + panic(err) + } + } + + if err := WriteJSONResponse(w, http.StatusOK, m); err != nil { + panic(err) + } +} + +// Starts an http server on the given port +func StartProfilingServer(ctx context.Context, pprofPort int) error { + logger.Infof(ctx, "Starting profiling server on port [%v]", pprofPort) + srv := &http.Server{ + ReadTimeout: 5 * time.Second, + WriteTimeout: 10 * time.Second, + Addr: fmt.Sprintf(":%d", pprofPort), + } + + go func() { + <-ctx.Done() + if err := srv.Shutdown(context.Background()); err != nil { + logger.Errorf(ctx, "Failed to gracefully shutdown profiling server. Error: %v", err) + } + }() + + return srv.ListenAndServe() +} + +func configureGlobalHTTPHandler(handlers map[string]http.Handler) error { + if handlers == nil { + handlers = map[string]http.Handler{} + } + handlers[metricsPath] = promhttp.Handler() + handlers[healthcheck] = http.HandlerFunc(healtcheckHandler) + handlers[versionPath] = http.HandlerFunc(versionHandler) + handlers[configPath] = http.HandlerFunc(configHandler) + + for p, h := range handlers { + http.Handle(p, h) + } + + return nil +} + +// Forwards the call to StartProfilingServer +// Also registers: +// 1. the prometheus HTTP handler on '/metrics' path shared with the profiling server. +// 2. A healthcheck (L7) handler on '/healthcheck'. +// 3. A version handler on '/version' provides information about the specific build. +// 4. A config handler on '/config' provides a dump of the currently loaded config. +func StartProfilingServerWithDefaultHandlers(ctx context.Context, pprofPort int, handlers map[string]http.Handler) error { + if err := configureGlobalHTTPHandler(handlers); err != nil { + return err + } + + return StartProfilingServer(ctx, pprofPort) +} diff --git a/flytestdlib/profutils/server_test.go b/flytestdlib/profutils/server_test.go new file mode 100644 index 0000000000..4210cad72f --- /dev/null +++ b/flytestdlib/profutils/server_test.go @@ -0,0 +1,112 @@ +package profutils + +import ( + "encoding/json" + "net/http" + "testing" + "time" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/internal/utils" + "github.com/flyteorg/flyte/v2/flytestdlib/version" +) + +type MockResponseWriter struct { + Status int + Headers http.Header + Body []byte +} + +func (m *MockResponseWriter) Write(b []byte) (int, error) { + m.Body = b + return 1, nil +} + +func (m *MockResponseWriter) WriteHeader(statusCode int) { + m.Status = statusCode +} + +func (m *MockResponseWriter) Header() http.Header { + return m.Headers +} + +type TestObj struct { + X int `json:"x"` +} + +func init() { + if err := configureGlobalHTTPHandler(nil); err != nil { + panic(err) + } +} + +func TestWriteJsonResponse(t *testing.T) { + m := &MockResponseWriter{Headers: http.Header{}} + assert.NoError(t, WriteJSONResponse(m, http.StatusOK, TestObj{10})) + assert.Equal(t, http.StatusOK, m.Status) + assert.Equal(t, http.Header{contentTypeHeader: []string{contentTypeJSON}}, m.Headers) + assert.Equal(t, `{"x":10}`, string(m.Body)) +} + +func TestWriteStringResponse(t *testing.T) { + m := &MockResponseWriter{Headers: http.Header{}} + assert.NoError(t, WriteStringResponse(m, http.StatusOK, "OK")) + assert.Equal(t, http.StatusOK, m.Status) + assert.Equal(t, "OK", string(m.Body)) +} + +func TestConfigHandler(t *testing.T) { + writer := &MockResponseWriter{Headers: http.Header{}} + testURL := utils.MustParseURL(configPath) + request := &http.Request{ + URL: &testURL, + } + + http.DefaultServeMux.ServeHTTP(writer, request) + assert.Equal(t, http.StatusOK, writer.Status) + + m := map[string]interface{}{} + assert.NoError(t, json.Unmarshal(writer.Body, &m)) + assert.Equal(t, map[string]interface{}{ + "logger": map[string]interface{}{ + "show-source": false, + "mute": false, + "level": float64(3), + "formatter": map[string]interface{}{ + "type": "json", + }, + }, + }, m) +} + +func TestVersionHandler(t *testing.T) { + writer := &MockResponseWriter{Headers: http.Header{}} + testURL := utils.MustParseURL(versionPath) + request := &http.Request{ + URL: &testURL, + } + + version.BuildTime = time.Now().String() + + http.DefaultServeMux.ServeHTTP(writer, request) + assert.Equal(t, http.StatusOK, writer.Status) + assert.NotNil(t, writer.Body) + bv := BuildVersion{} + assert.NoError(t, json.Unmarshal(writer.Body, &bv)) + assert.Equal(t, bv.Timestamp, version.BuildTime) + assert.Equal(t, bv.Build, version.Build) + assert.Equal(t, bv.Version, version.Version) +} + +func TestHealthcheckHandler(t *testing.T) { + writer := &MockResponseWriter{Headers: http.Header{}} + testURL := utils.MustParseURL(healthcheck) + request := &http.Request{ + URL: &testURL, + } + + http.DefaultServeMux.ServeHTTP(writer, request) + assert.Equal(t, http.StatusOK, writer.Status) + assert.Equal(t, `OK`, string(writer.Body)) +} diff --git a/flytestdlib/promutils/client.go b/flytestdlib/promutils/client.go new file mode 100644 index 0000000000..daefe41316 --- /dev/null +++ b/flytestdlib/promutils/client.go @@ -0,0 +1,76 @@ +package promutils + +import ( + "context" + "net/url" + "time" + + "github.com/prometheus/client_golang/prometheus" + "k8s.io/client-go/tools/metrics" +) + +func init() { + requestMetrics := newRequestMetricsProvider() + rateLimiterMetrics := newRateLimiterMetricsAdapter() + metrics.Register(metrics.RegisterOpts{ + RequestLatency: &requestMetrics, + RequestResult: &requestMetrics, + RateLimiterLatency: &rateLimiterMetrics, + }) +} + +var ( + scope = NewScope("v2") + latencyBuckets = []float64{.0005, .001, .005, .01, .025, .05, .1, .25, .5, 1, 2.5, 5, 10} +) + +type requestMetricsProvider struct { + requestLatency *prometheus.HistogramVec + requestResult *prometheus.CounterVec +} + +func (r *requestMetricsProvider) Observe(ctx context.Context, verb string, _ url.URL, latency time.Duration) { + r.requestLatency.WithLabelValues(verb).Observe(latency.Seconds()) +} + +func (r *requestMetricsProvider) Increment(ctx context.Context, code string, method string, _ string) { + r.requestResult.WithLabelValues(code, method).Inc() +} + +func newRequestMetricsProvider() requestMetricsProvider { + requestLatency := scope.MustNewHistogramVecWithOptions( + "k8s_client_request_latency", + "Kubernetes client request latency in seconds", + HistogramOptions{Buckets: latencyBuckets}, + "verb", + ) + requestResult := scope.MustNewCounterVec( + "k8s_client_request_total", + "Kubernetes client request total", + "code", "method", + ) + return requestMetricsProvider{ + requestLatency, + requestResult, + } +} + +type rateLimiterMetricsProvider struct { + rateLimiterLatency *prometheus.HistogramVec +} + +func (r *rateLimiterMetricsProvider) Observe(ctx context.Context, verb string, _ url.URL, latency time.Duration) { + r.rateLimiterLatency.WithLabelValues(verb).Observe(latency.Seconds()) +} + +func newRateLimiterMetricsAdapter() rateLimiterMetricsProvider { + rateLimiterLatency := scope.MustNewHistogramVecWithOptions( + "k8s_client_rate_limiter_latency", + "Kubernetes client rate limiter latency in seconds", + HistogramOptions{Buckets: latencyBuckets}, + "verb", + ) + return rateLimiterMetricsProvider{ + rateLimiterLatency, + } +} diff --git a/flytestdlib/promutils/labeled/counter.go b/flytestdlib/promutils/labeled/counter.go new file mode 100644 index 0000000000..01bfa2d504 --- /dev/null +++ b/flytestdlib/promutils/labeled/counter.go @@ -0,0 +1,80 @@ +package labeled + +import ( + "context" + + "github.com/prometheus/client_golang/prometheus" + "k8s.io/apimachinery/pkg/util/sets" + + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +// Counter represents a counter labeled with values from the context. See labeled.SetMetricsKeys for information about to +// configure that. +type Counter struct { + *prometheus.CounterVec + + prometheus.Counter + labels []contextutils.Key +} + +// Inc increments the counter by 1. Use Add to increment it by arbitrary non-negative values. The data point will be +// labeled with values from context. See labeled.SetMetricsKeys for information about how to configure that. +func (c Counter) Inc(ctx context.Context) { + counter, err := c.GetMetricWith(contextutils.Values(ctx, c.labels...)) + if err != nil { + panic(err.Error()) + } + counter.Inc() + + if c.Counter != nil { + c.Counter.Inc() + } +} + +// Add adds the given value to the counter. It panics if the value is < 0.. The data point will be labeled with values +// from context. See labeled.SetMetricsKeys for information about how to configure that. +func (c Counter) Add(ctx context.Context, v float64) { + counter, err := c.GetMetricWith(contextutils.Values(ctx, c.labels...)) + if err != nil { + panic(err.Error()) + } + counter.Add(v) + + if c.Counter != nil { + c.Counter.Add(v) + } +} + +// NewCounter creates a new labeled counter. Label keys must be set before instantiating a counter. See labeled.SetMetricsKeys for +// information about to configure that. +func NewCounter(name, description string, scope promutils.Scope, opts ...MetricOption) Counter { + if len(metricKeys) == 0 { + panic(ErrNeverSet) + } + + c := Counter{} + + name = promutils.SanitizeMetricName(name) + for _, opt := range opts { + if _, emitUnlabeledMetric := opt.(EmitUnlabeledMetricOption); emitUnlabeledMetric { + c.Counter = scope.MustNewCounter(GetUnlabeledMetricName(name), description) + } else if additionalLabels, casted := opt.(AdditionalLabelsOption); casted { + // compute unique labels + labelSet := sets.NewString(metricStringKeys...) + labelSet.Insert(additionalLabels.Labels...) + labels := labelSet.List() + + c.CounterVec = scope.MustNewCounterVec(name, description, labels...) + c.labels = contextutils.MetricKeysFromStrings(labels) + } + } + + if c.CounterVec == nil { + c.CounterVec = scope.MustNewCounterVec(name, description, metricStringKeys...) + c.labels = metricKeys + } + + return c +} diff --git a/flytestdlib/promutils/labeled/counter_test.go b/flytestdlib/promutils/labeled/counter_test.go new file mode 100644 index 0000000000..c74e06bc97 --- /dev/null +++ b/flytestdlib/promutils/labeled/counter_test.go @@ -0,0 +1,112 @@ +package labeled + +import ( + "context" + "strings" + "testing" + + "github.com/prometheus/client_golang/prometheus/testutil" + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +func TestLabeledCounter(t *testing.T) { + UnsetMetricKeys() + assert.NotPanics(t, func() { + SetMetricKeys(contextutils.ProjectKey, contextutils.DomainKey, contextutils.WorkflowIDKey, contextutils.TaskIDKey) + }) + + t.Run("Labeled", func(t *testing.T) { + scope := promutils.NewScope("testscope_counter") + c := NewCounter("c1", "some desc", scope) + assert.NotNil(t, c) + + ctx := context.TODO() + var header = ` + # HELP testscope_counter:c1 some desc + # TYPE testscope_counter:c1 counter + ` + + c.Inc(ctx) + c.Add(ctx, 1.0) + var expected = ` + testscope_counter:c1{domain="",project="",task="",wf=""} 2 + ` + err := testutil.CollectAndCompare(c.CounterVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + + ctx = contextutils.WithProjectDomain(ctx, "project", "domain") + c.Inc(ctx) + c.Add(ctx, 1.0) + expected = ` + testscope_counter:c1{domain="",project="",task="",wf=""} 2 + testscope_counter:c1{domain="domain",project="project",task="",wf=""} 2 + ` + err = testutil.CollectAndCompare(c.CounterVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + + ctx = contextutils.WithTaskID(ctx, "task") + c.Inc(ctx) + c.Add(ctx, 1.0) + expected = ` + testscope_counter:c1{domain="",project="",task="",wf=""} 2 + testscope_counter:c1{domain="domain",project="project",task="",wf=""} 2 + testscope_counter:c1{domain="domain",project="project",task="task",wf=""} 2 + ` + err = testutil.CollectAndCompare(c.CounterVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + }) + + t.Run("Unlabeled", func(t *testing.T) { + scope := promutils.NewScope("testscope_counter") + c := NewCounter("c2", "some desc", scope, EmitUnlabeledMetric) + assert.NotNil(t, c) + + ctx := context.TODO() + var header = ` + # HELP testscope_counter:c2_unlabeled some desc + # TYPE testscope_counter:c2_unlabeled counter + ` + + c.Inc(ctx) + c.Add(ctx, 1.0) + var expected = ` + testscope_counter:c2_unlabeled 2 + ` + err := testutil.CollectAndCompare(c.Counter, strings.NewReader(header+expected)) + assert.NoError(t, err) + }) + + t.Run("AdditionalLabels", func(t *testing.T) { + scope := promutils.NewScope("testscope_counter") + opts := AdditionalLabelsOption{Labels: []string{contextutils.ProjectKey.String(), contextutils.ExecIDKey.String()}} + c := NewCounter("c3", "some desc", scope, opts) + assert.NotNil(t, c) + + ctx := context.TODO() + var header = ` + # HELP testscope_counter:c3 some desc + # TYPE testscope_counter:c3 counter + ` + + c.Inc(ctx) + c.Add(ctx, 1.0) + var expected = ` + testscope_counter:c3{domain="",exec_id="",project="",task="",wf=""} 2 + ` + err := testutil.CollectAndCompare(c.CounterVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + + ctx = contextutils.WithExecutionID(ctx, "exec_id") + c.Inc(ctx) + c.Add(ctx, 1.0) + expected = ` + testscope_counter:c3{domain="",exec_id="",project="",task="",wf=""} 2 + testscope_counter:c3{domain="",exec_id="exec_id",project="",task="",wf=""} 2 + ` + err = testutil.CollectAndCompare(c.CounterVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + }) +} diff --git a/flytestdlib/promutils/labeled/gauge.go b/flytestdlib/promutils/labeled/gauge.go new file mode 100644 index 0000000000..bc4806dfd7 --- /dev/null +++ b/flytestdlib/promutils/labeled/gauge.go @@ -0,0 +1,134 @@ +package labeled + +import ( + "context" + + "github.com/prometheus/client_golang/prometheus" + "k8s.io/apimachinery/pkg/util/sets" + + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +// Gauge represents a gauge labeled with values from the context. See labeled.SetMetricsKeys for more information +type Gauge struct { + *prometheus.GaugeVec + + prometheus.Gauge + labels []contextutils.Key +} + +// Inc increments the gauge by 1. Use Add to increment by arbitrary values. The data point will be +// labeled with values from context. See labeled.SetMetricsKeys for information about how to configure that. +func (g Gauge) Inc(ctx context.Context) { + gauge, err := g.GetMetricWith(contextutils.Values(ctx, g.labels...)) + if err != nil { + panic(err.Error()) + } + gauge.Inc() + + if g.Gauge != nil { + g.Gauge.Inc() + } +} + +// Add adds the given value to the Gauge. (The value can be negative, resulting in a decrease of the Gauge.) +// The data point will be labeled with values from context. See labeled.SetMetricsKeys for information about how to configure that. +func (g Gauge) Add(ctx context.Context, v float64) { + gauge, err := g.GetMetricWith(contextutils.Values(ctx, g.labels...)) + if err != nil { + panic(err.Error()) + } + gauge.Add(v) + + if g.Gauge != nil { + g.Gauge.Add(v) + } +} + +// Set sets the Gauge to an arbitrary value. +// The data point will be labeled with values from context. See labeled.SetMetricsKeys for information about how to configure that. +func (g Gauge) Set(ctx context.Context, v float64) { + gauge, err := g.GetMetricWith(contextutils.Values(ctx, g.labels...)) + if err != nil { + panic(err.Error()) + } + gauge.Set(v) + + if g.Gauge != nil { + g.Gauge.Set(v) + } +} + +// Dec decrements the level by 1. Use Sub to decrement by arbitrary values. The data point will be +// labeled with values from context. See labeled.SetMetricsKeys for information about how to configure that. +func (g Gauge) Dec(ctx context.Context) { + gauge, err := g.GetMetricWith(contextutils.Values(ctx, g.labels...)) + if err != nil { + panic(err.Error()) + } + gauge.Dec() + + if g.Gauge != nil { + g.Gauge.Dec() + } +} + +// Sub adds the given value to the Gauge. The value can be negative, resulting in an increase of the Gauge. +// The data point will be labeled with values from context. See labeled.SetMetricsKeys for information about how to configure that. +func (g Gauge) Sub(ctx context.Context, v float64) { + gauge, err := g.GetMetricWith(contextutils.Values(ctx, g.labels...)) + if err != nil { + panic(err.Error()) + } + gauge.Sub(v) + + if g.Gauge != nil { + g.Gauge.Sub(v) + } +} + +// SetToCurrentTime sets the Gauge to the current Unix time in seconds. +func (g Gauge) SetToCurrentTime(ctx context.Context) { + gauge, err := g.GetMetricWith(contextutils.Values(ctx, metricKeys...)) + if err != nil { + panic(err.Error()) + } + gauge.SetToCurrentTime() + + if g.Gauge != nil { + g.Gauge.SetToCurrentTime() + } +} + +// NewGauge creates a new labeled gauge. Label keys must be set before instantiating. If the unlabeled option is given, +// this object will also instantiate and emit another gauge with the given name with an _unlabeled suffix. +// See labeled.SetMetricsKeys for information about how to configure that. +func NewGauge(name, description string, scope promutils.Scope, opts ...MetricOption) Gauge { + if len(metricKeys) == 0 { + panic(ErrNeverSet) + } + + g := Gauge{} + name = promutils.SanitizeMetricName(name) + for _, opt := range opts { + if _, emitUnlabeledMetric := opt.(EmitUnlabeledMetricOption); emitUnlabeledMetric { + g.Gauge = scope.MustNewGauge(GetUnlabeledMetricName(name), description) + } else if additionalLabels, casted := opt.(AdditionalLabelsOption); casted { + // compute unique labels + labelSet := sets.NewString(metricStringKeys...) + labelSet.Insert(additionalLabels.Labels...) + labels := labelSet.List() + + g.GaugeVec = scope.MustNewGaugeVec(name, description, labels...) + g.labels = contextutils.MetricKeysFromStrings(labels) + } + } + + if g.GaugeVec == nil { + g.GaugeVec = scope.MustNewGaugeVec(name, description, metricStringKeys...) + g.labels = metricKeys + } + + return g +} diff --git a/flytestdlib/promutils/labeled/gauge_test.go b/flytestdlib/promutils/labeled/gauge_test.go new file mode 100644 index 0000000000..12057d5494 --- /dev/null +++ b/flytestdlib/promutils/labeled/gauge_test.go @@ -0,0 +1,129 @@ +package labeled + +import ( + "context" + "strings" + "testing" + + "github.com/prometheus/client_golang/prometheus/testutil" + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +func TestLabeledGauge(t *testing.T) { + UnsetMetricKeys() + assert.NotPanics(t, func() { + SetMetricKeys(contextutils.ProjectKey, contextutils.DomainKey, contextutils.WorkflowIDKey, contextutils.TaskIDKey) + }) + + t.Run("Labeled", func(t *testing.T) { + scope := promutils.NewScope("testscope_gauge") + g := NewGauge("g1", "some desc", scope) + assert.NotNil(t, g) + + ctx := context.TODO() + const header = ` + # HELP testscope_gauge:g1 some desc + # TYPE testscope_gauge:g1 gauge + ` + + g.Inc(ctx) + var expected = ` + testscope_gauge:g1{domain="",project="",task="",wf=""} 1 + ` + err := testutil.CollectAndCompare(g.GaugeVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + + g.Dec(ctx) + expected = ` + testscope_gauge:g1{domain="",project="",task="",wf=""} 0 + ` + err = testutil.CollectAndCompare(g.GaugeVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + + ctx = contextutils.WithProjectDomain(ctx, "project", "domain") + g.Set(ctx, 42) + expected = ` + testscope_gauge:g1{domain="",project="",task="",wf=""} 0 + testscope_gauge:g1{domain="domain",project="project",task="",wf=""} 42 + ` + err = testutil.CollectAndCompare(g.GaugeVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + + ctx = contextutils.WithTaskID(ctx, "task") + g.Add(ctx, 1) + expected = ` + testscope_gauge:g1{domain="",project="",task="",wf=""} 0 + testscope_gauge:g1{domain="domain",project="project",task="",wf=""} 42 + testscope_gauge:g1{domain="domain",project="project",task="task",wf=""} 1 + ` + err = testutil.CollectAndCompare(g.GaugeVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + + g.Sub(ctx, 1) + expected = ` + testscope_gauge:g1{domain="",project="",task="",wf=""} 0 + testscope_gauge:g1{domain="domain",project="project",task="",wf=""} 42 + testscope_gauge:g1{domain="domain",project="project",task="task",wf=""} 0 + ` + err = testutil.CollectAndCompare(g.GaugeVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + }) + + t.Run("Unlabeled", func(t *testing.T) { + scope := promutils.NewScope("testscope_gauge") + g := NewGauge("g2", "some desc", scope, EmitUnlabeledMetric) + assert.NotNil(t, g) + + ctx := context.TODO() + const header = ` + # HELP testscope_gauge:g2_unlabeled some desc + # TYPE testscope_gauge:g2_unlabeled gauge + ` + + g.Inc(ctx) + var expected = ` + testscope_gauge:g2_unlabeled 1 + ` + err := testutil.CollectAndCompare(g.Gauge, strings.NewReader(header+expected)) + assert.NoError(t, err) + + g.Dec(ctx) + expected = ` + testscope_gauge:g2_unlabeled 0 + ` + err = testutil.CollectAndCompare(g.Gauge, strings.NewReader(header+expected)) + assert.NoError(t, err) + }) + + t.Run("AdditionalLabels", func(t *testing.T) { + scope := promutils.NewScope("testscope_gauge") + opts := AdditionalLabelsOption{Labels: []string{contextutils.ProjectKey.String(), contextutils.ExecIDKey.String()}} + g := NewGauge("g3", "some desc", scope, opts) + assert.NotNil(t, g) + + ctx := context.TODO() + const header = ` + # HELP testscope_gauge:g3 some desc + # TYPE testscope_gauge:g3 gauge + ` + + g.Inc(ctx) + var expected = ` + testscope_gauge:g3{domain="",exec_id="",project="",task="",wf=""} 1 + ` + err := testutil.CollectAndCompare(g.GaugeVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + + ctx = contextutils.WithExecutionID(ctx, "exec_id") + g.Inc(ctx) + expected = ` + testscope_gauge:g3{domain="",exec_id="",project="",task="",wf=""} 1 + testscope_gauge:g3{domain="",exec_id="exec_id",project="",task="",wf=""} 1 + ` + err = testutil.CollectAndCompare(g.GaugeVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + }) +} diff --git a/flytestdlib/promutils/labeled/histogram_stopwatch.go b/flytestdlib/promutils/labeled/histogram_stopwatch.go new file mode 100644 index 0000000000..dbd4e9a802 --- /dev/null +++ b/flytestdlib/promutils/labeled/histogram_stopwatch.go @@ -0,0 +1,92 @@ +package labeled + +import ( + "context" + "time" + + "k8s.io/apimachinery/pkg/util/sets" + + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +type HistogramStopWatch struct { + *promutils.HistogramStopWatchVec + promutils.HistogramStopWatch + + labels []contextutils.Key +} + +// Start creates a new Instance of the HistogramStopWatch called a Timer that is closeable/stoppable. +func (c HistogramStopWatch) Start(ctx context.Context) Timer { + w, err := c.GetMetricWith(contextutils.Values(ctx, c.labels...)) + if err != nil { + panic(err.Error()) + } + + if c.Observer == nil { + return w.Start() + } + + return timer{ + Timers: []Timer{ + w.Start(), + c.HistogramStopWatch.Start(), + }, + } +} + +// Observe observes specified duration between the start and end time. The data point will be labeled with values from context. +// See labeled.SetMetricsKeys for information about how to configure that. +func (c HistogramStopWatch) Observe(ctx context.Context, start, end time.Time) { + w, err := c.GetMetricWith(contextutils.Values(ctx, c.labels...)) + if err != nil { + panic(err.Error()) + } + w.Observe(start, end) + + if c.Observer != nil { + c.HistogramStopWatch.Observe(start, end) + } +} + +// Time observes the elapsed duration since the creation of the timer. The timer is created using a StopWatch. +// The data point will be labeled with values from context. See labeled.SetMetricsKeys for information about to +// configure that. +func (c HistogramStopWatch) Time(ctx context.Context, f func()) { + t := c.Start(ctx) + f() + t.Stop() +} + +// NewHistogramStopWatch creates a new labeled HistogramStopWatch. Label keys must be set before instantiating a counter. See labeled.SetMetricsKeys +// for information about how to configure that. +func NewHistogramStopWatch(name, description string, scope promutils.Scope, opts ...MetricOption) HistogramStopWatch { + if len(metricKeys) == 0 { + panic(ErrNeverSet) + } + + sw := HistogramStopWatch{} + + name = promutils.SanitizeMetricName(name) + for _, opt := range opts { + if _, emitUnableMetric := opt.(EmitUnlabeledMetricOption); emitUnableMetric { + sw.HistogramStopWatch = scope.MustNewHistogramStopWatch(GetUnlabeledMetricName(name), description) + } else if additionalLabels, casted := opt.(AdditionalLabelsOption); casted { + // compute unique labels + labelSet := sets.NewString(metricStringKeys...) + labelSet.Insert(additionalLabels.Labels...) + labels := labelSet.List() + + sw.HistogramStopWatchVec = scope.MustNewHistogramStopWatchVec(name, description, labels...) + sw.labels = contextutils.MetricKeysFromStrings(labels) + } + } + + if sw.HistogramStopWatchVec == nil { + sw.HistogramStopWatchVec = scope.MustNewHistogramStopWatchVec(name, description, metricStringKeys...) + sw.labels = metricKeys + } + + return sw +} diff --git a/flytestdlib/promutils/labeled/histogram_stopwatch_test.go b/flytestdlib/promutils/labeled/histogram_stopwatch_test.go new file mode 100644 index 0000000000..58c9722a7e --- /dev/null +++ b/flytestdlib/promutils/labeled/histogram_stopwatch_test.go @@ -0,0 +1,372 @@ +package labeled + +import ( + "context" + "strconv" + "strings" + "testing" + "time" + + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/testutil" + "github.com/prometheus/common/expfmt" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +func ExampleHistogramStopWatch_Start() { + ctx := context.Background() + stopWatch := NewHistogramStopWatch("test", "this is an example histogram stopwatch", promutils.NewTestScope()) + { + timer := stopWatch.Start(ctx) + defer timer.Stop() + + // An operation you want to measure the time for. + time.Sleep(time.Second) + } +} + +func TestLabeledHistogramStopWatch(t *testing.T) { + UnsetMetricKeys() + assert.NotPanics(t, func() { + SetMetricKeys(contextutils.ProjectKey, contextutils.DomainKey, contextutils.WorkflowIDKey, contextutils.TaskIDKey) + }) + + t.Run("Labeled", func(t *testing.T) { + scope := promutils.NewScope("testscope_hist_stopwatch") + s := NewHistogramStopWatch("s1", "some desc", scope) + assert.NotNil(t, s) + metricName := scope.CurrentScope() + "s1" + + ctx := context.TODO() + const header = ` + # HELP testscope_hist_stopwatch:s1 some desc + # TYPE testscope_hist_stopwatch:s1 histogram` + + w := s.Start(ctx) + w.Stop() + expectedMetrics := map[string]any{ + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.005"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.01"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.025"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.05"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.1"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.25"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.5"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="1"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="2.5"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="5"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="10"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="+Inf"}`: 1, + `testscope_hist_stopwatch:s1_sum{domain="",project="",task="",wf=""}`: 0.0, + `testscope_hist_stopwatch:s1_count{domain="",project="",task="",wf=""}`: 1, + } + assertMetrics(t, s.HistogramStopWatchVec, metricName, header, expectedMetrics) + + ctx = contextutils.WithProjectDomain(ctx, "project", "domain") + w = s.Start(ctx) + w.Stop() + + expectedMetrics = map[string]any{ + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.005"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.01"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.025"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.05"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.1"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.25"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.5"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="1"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="2.5"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="5"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="10"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="+Inf"}`: 1, + `testscope_hist_stopwatch:s1_sum{domain="",project="",task="",wf=""}`: 0.0, + `testscope_hist_stopwatch:s1_count{domain="",project="",task="",wf=""}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.005"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.01"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.025"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.05"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.1"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.25"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.5"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="1"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="2.5"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="5"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="10"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="+Inf"}`: 1, + `testscope_hist_stopwatch:s1_sum{domain="domain",project="project",task="",wf=""}`: 0.0, + `testscope_hist_stopwatch:s1_count{domain="domain",project="project",task="",wf=""}`: 1, + } + assertMetrics(t, s.HistogramStopWatchVec, metricName, header, expectedMetrics) + + now := time.Now() + s.Observe(ctx, now, now.Add(time.Minute)) + + expectedMetrics = map[string]any{ + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.005"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.01"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.025"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.05"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.1"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.25"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.5"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="1"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="2.5"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="5"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="10"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="+Inf"}`: 1, + `testscope_hist_stopwatch:s1_sum{domain="",project="",task="",wf=""}`: 0.0, + `testscope_hist_stopwatch:s1_count{domain="",project="",task="",wf=""}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.005"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.01"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.025"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.05"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.1"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.25"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.5"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="1"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="2.5"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="5"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="10"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="+Inf"}`: 2, + `testscope_hist_stopwatch:s1_sum{domain="domain",project="project",task="",wf=""}`: 60.0, + `testscope_hist_stopwatch:s1_count{domain="domain",project="project",task="",wf=""}`: 2, + } + assertMetrics(t, s.HistogramStopWatchVec, metricName, header, expectedMetrics) + + s.Time(ctx, func() { + // Do nothing + }) + + expectedMetrics = map[string]any{ + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.005"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.01"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.025"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.05"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.1"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.25"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="0.5"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="1"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="2.5"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="5"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="10"}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="",project="",task="",wf="",le="+Inf"}`: 1, + `testscope_hist_stopwatch:s1_sum{domain="",project="",task="",wf=""}`: 0.0, + `testscope_hist_stopwatch:s1_count{domain="",project="",task="",wf=""}`: 1, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.005"}`: 2, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.01"}`: 2, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.025"}`: 2, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.05"}`: 2, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.1"}`: 2, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.25"}`: 2, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="0.5"}`: 2, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="1"}`: 2, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="2.5"}`: 2, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="5"}`: 2, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="10"}`: 2, + `testscope_hist_stopwatch:s1_bucket{domain="domain",project="project",task="",wf="",le="+Inf"}`: 3, + `testscope_hist_stopwatch:s1_sum{domain="domain",project="project",task="",wf=""}`: 60.0, + `testscope_hist_stopwatch:s1_count{domain="domain",project="project",task="",wf=""}`: 3, + } + assertMetrics(t, s.HistogramStopWatchVec, metricName, header, expectedMetrics) + }) + + t.Run("Unlabeled", func(t *testing.T) { + scope := promutils.NewScope("testscope_hist_stopwatch") + s := NewHistogramStopWatch("s2", "some desc", scope, EmitUnlabeledMetric) + assert.NotNil(t, s) + + ctx := context.TODO() + const header = ` + # HELP testscope_hist_stopwatch:s2_unlabeled some desc + # TYPE testscope_hist_stopwatch:s2_unlabeled histogram` + + w := s.Start(ctx) + w.Stop() + expectedMetrics := map[string]any{ + `testscope_hist_stopwatch:s2_unlabeled_bucket{le="0.005"}`: 1, + `testscope_hist_stopwatch:s2_unlabeled_bucket{le="0.01"}`: 1, + `testscope_hist_stopwatch:s2_unlabeled_bucket{le="0.025"}`: 1, + `testscope_hist_stopwatch:s2_unlabeled_bucket{le="0.05"}`: 1, + `testscope_hist_stopwatch:s2_unlabeled_bucket{le="0.1"}`: 1, + `testscope_hist_stopwatch:s2_unlabeled_bucket{le="0.25"}`: 1, + `testscope_hist_stopwatch:s2_unlabeled_bucket{le="0.5"}`: 1, + `testscope_hist_stopwatch:s2_unlabeled_bucket{le="1"}`: 1, + `testscope_hist_stopwatch:s2_unlabeled_bucket{le="2.5"}`: 1, + `testscope_hist_stopwatch:s2_unlabeled_bucket{le="5"}`: 1, + `testscope_hist_stopwatch:s2_unlabeled_bucket{le="10"}`: 1, + `testscope_hist_stopwatch:s2_unlabeled_bucket{le="+Inf"}`: 1, + `testscope_hist_stopwatch:s2_unlabeled_sum`: 0.0, + `testscope_hist_stopwatch:s2_unlabeled_count`: 1, + } + assertMetrics(t, s.Observer.(prometheus.Histogram), "testscope_hist_stopwatch:s2_unlabeled", header, expectedMetrics) + }) + + t.Run("AdditionalLabels", func(t *testing.T) { + scope := promutils.NewScope("testscope_hist_stopwatch") + opts := AdditionalLabelsOption{Labels: []string{contextutils.ProjectKey.String(), contextutils.ExecIDKey.String()}} + s := NewHistogramStopWatch("s3", "some desc", scope, opts) + assert.NotNil(t, s) + metricName := scope.CurrentScope() + "s3" + + ctx := context.TODO() + const header = ` + # HELP testscope_hist_stopwatch:s3 some desc + # TYPE testscope_hist_stopwatch:s3 histogram` + + w := s.Start(ctx) + w.Stop() + expectedMetrics := map[string]any{ + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.005"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.01"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.025"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.05"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.1"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.25"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.5"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="1"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="2.5"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="5"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="10"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="+Inf"}`: 1, + `testscope_hist_stopwatch:s3_sum{domain="",exec_id="",project="",task="",wf=""}`: 0.0, + `testscope_hist_stopwatch:s3_count{domain="",exec_id="",project="",task="",wf=""}`: 1, + } + assertMetrics(t, s.HistogramStopWatchVec, metricName, header, expectedMetrics) + + ctx = contextutils.WithProjectDomain(ctx, "project", "domain") + w = s.Start(ctx) + w.Stop() + expectedMetrics = map[string]any{ + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.005"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.01"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.025"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.05"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.1"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.25"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.5"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="1"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="2.5"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="5"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="10"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="+Inf"}`: 1, + `testscope_hist_stopwatch:s3_sum{domain="",exec_id="",project="",task="",wf=""}`: 0.0, + `testscope_hist_stopwatch:s3_count{domain="",exec_id="",project="",task="",wf=""}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="0.005"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="0.01"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="0.025"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="0.05"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="0.1"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="0.25"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="0.5"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="1"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="2.5"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="5"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="10"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="+Inf"}`: 1, + `testscope_hist_stopwatch:s3_sum{domain="domain",exec_id="",project="project",task="",wf=""}`: 0.0, + `testscope_hist_stopwatch:s3_count{domain="domain",exec_id="",project="project",task="",wf=""}`: 1, + } + assertMetrics(t, s.HistogramStopWatchVec, metricName, header, expectedMetrics) + + ctx = contextutils.WithExecutionID(ctx, "exec_id") + w = s.Start(ctx) + w.Stop() + expectedMetrics = map[string]any{ + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.005"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.01"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.025"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.05"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.1"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.25"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="0.5"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="1"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="2.5"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="5"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="10"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="",exec_id="",project="",task="",wf="",le="+Inf"}`: 1, + `testscope_hist_stopwatch:s3_sum{domain="",exec_id="",project="",task="",wf=""}`: 0.0, + `testscope_hist_stopwatch:s3_count{domain="",exec_id="",project="",task="",wf=""}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="0.005"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="0.01"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="0.025"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="0.05"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="0.1"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="0.25"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="0.5"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="1"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="2.5"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="5"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="10"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="",project="project",task="",wf="",le="+Inf"}`: 1, + `testscope_hist_stopwatch:s3_sum{domain="domain",exec_id="",project="project",task="",wf=""}`: 0.0, + `testscope_hist_stopwatch:s3_count{domain="domain",exec_id="",project="project",task="",wf=""}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="exec_id",project="project",task="",wf="",le="0.005"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="exec_id",project="project",task="",wf="",le="0.01"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="exec_id",project="project",task="",wf="",le="0.025"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="exec_id",project="project",task="",wf="",le="0.05"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="exec_id",project="project",task="",wf="",le="0.1"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="exec_id",project="project",task="",wf="",le="0.25"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="exec_id",project="project",task="",wf="",le="0.5"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="exec_id",project="project",task="",wf="",le="1"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="exec_id",project="project",task="",wf="",le="2.5"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="exec_id",project="project",task="",wf="",le="5"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="exec_id",project="project",task="",wf="",le="10"}`: 1, + `testscope_hist_stopwatch:s3_bucket{domain="domain",exec_id="exec_id",project="project",task="",wf="",le="+Inf"}`: 1, + `testscope_hist_stopwatch:s3_sum{domain="domain",exec_id="exec_id",project="project",task="",wf=""}`: 0.0, + `testscope_hist_stopwatch:s3_count{domain="domain",exec_id="exec_id",project="project",task="",wf=""}`: 1, + } + assertMetrics(t, s.HistogramStopWatchVec, metricName, header, expectedMetrics) + }) +} + +func assertMetrics(t *testing.T, c prometheus.Collector, metricName, expectedHeader string, expectedMetrics map[string]any) { + t.Helper() + metricBytes, err := testutil.CollectAndFormat(c, expfmt.TypeTextPlain, metricName) + require.NoError(t, err) + require.NotEmptyf(t, metricBytes, "empty `%q` metric", metricName) + + actual := strings.Split(strings.TrimSpace(string(metricBytes)), "\n") + n := len(actual) + + expected := strings.Split(strings.TrimSpace(expectedHeader), "\n") + require.Len(t, expected, 2, "wrong number of expected header lines") + + for i := 0; i < n; i++ { + line := actual[i] + + if strings.HasPrefix(line, "#") { + if i != 0 && i != 1 { + require.Failf(t, "wrong format", "comment line %q on wrong place", line) + } + assert.Equal(t, strings.TrimSpace(expected[i]), actual[i]) + continue + } + + lineSplt := strings.Split(line, " ") + if len(lineSplt) != 2 { + require.Failf(t, "metric line has wrong format", "metric %s has line %q with wrong format", metricName, line) + } + + key := lineSplt[0] + expectedValue, ok := expectedMetrics[key] + require.Truef(t, ok, "missing expected %q metric", key) + + switch expectedValue.(type) { + case int, int8, int16, int32, int64: + actualValue, err := strconv.Atoi(lineSplt[1]) + require.NoError(t, err) + assert.Equal(t, expectedValue, actualValue) + case float32, float64: + actualValue, err := strconv.ParseFloat(lineSplt[1], 64) + require.NoError(t, err) + assert.InDeltaf(t, expectedValue, actualValue, 0.001, "metric %q has wrong value", key) + assert.Greaterf(t, actualValue, expectedValue, "actual value of %q should be slightly greater than expected", key) + default: + require.Fail(t, "unsupported expected value type") + } + } +} diff --git a/flytestdlib/promutils/labeled/keys.go b/flytestdlib/promutils/labeled/keys.go new file mode 100644 index 0000000000..87f951419d --- /dev/null +++ b/flytestdlib/promutils/labeled/keys.go @@ -0,0 +1,58 @@ +package labeled + +import ( + "fmt" + "reflect" + "sync" + + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" +) + +var ( + ErrAlreadySet = fmt.Errorf("cannot set metric keys more than once") + ErrEmpty = fmt.Errorf("cannot set metric keys to an empty set") + ErrNeverSet = fmt.Errorf("must call SetMetricKeys prior to using labeled package") + + // Metric Keys to label metrics with. These keys get pulled from context if they are present. Use contextutils to fill + // them in. + metricKeys []contextutils.Key + + // :(, we have to create a separate list to satisfy the MustNewCounterVec API as it accepts string only + metricStringKeys []string + metricKeysAreSet sync.Once +) + +// Sets keys to use with labeled metrics. The values of these keys will be pulled from context at runtime. +func SetMetricKeys(keys ...contextutils.Key) { + if len(keys) == 0 { + panic(ErrEmpty) + } + + ran := false + metricKeysAreSet.Do(func() { + ran = true + metricKeys = keys + for _, metricKey := range metricKeys { + metricStringKeys = append(metricStringKeys, metricKey.String()) + } + }) + + if !ran && !reflect.DeepEqual(keys, metricKeys) { + panic(ErrAlreadySet) + } +} + +func GetUnlabeledMetricName(metricName string) string { + return metricName + "_unlabeled" +} + +// Warning: This function is not thread safe and should be used for testing only outside of this package. +func UnsetMetricKeys() { + metricKeys = make([]contextutils.Key, 0) + metricStringKeys = make([]string, 0) + metricKeysAreSet = sync.Once{} +} + +func init() { + UnsetMetricKeys() +} diff --git a/flytestdlib/promutils/labeled/keys_test.go b/flytestdlib/promutils/labeled/keys_test.go new file mode 100644 index 0000000000..8f5ec0ab25 --- /dev/null +++ b/flytestdlib/promutils/labeled/keys_test.go @@ -0,0 +1,26 @@ +package labeled + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" +) + +func TestMetricKeys(t *testing.T) { + UnsetMetricKeys() + input := []contextutils.Key{ + contextutils.ProjectKey, contextutils.DomainKey, contextutils.WorkflowIDKey, contextutils.TaskIDKey, contextutils.LaunchPlanIDKey, + } + + assert.NotPanics(t, func() { SetMetricKeys(input...) }) + assert.Equal(t, input, metricKeys) + + for i, k := range metricKeys { + assert.Equal(t, k.String(), metricStringKeys[i]) + } + + assert.NotPanics(t, func() { SetMetricKeys(input...) }) + assert.Panics(t, func() { SetMetricKeys(contextutils.DomainKey) }) +} diff --git a/flytestdlib/promutils/labeled/metric_option.go b/flytestdlib/promutils/labeled/metric_option.go new file mode 100644 index 0000000000..458a2852da --- /dev/null +++ b/flytestdlib/promutils/labeled/metric_option.go @@ -0,0 +1,24 @@ +package labeled + +// Defines extra set of options to customize the emitted metric. +type MetricOption interface { + isMetricOption() +} + +// Instructs the metric to emit unlabeled metric (besides the labeled one). This is useful to get overall system +// performance. +type EmitUnlabeledMetricOption struct { +} + +func (EmitUnlabeledMetricOption) isMetricOption() {} + +var EmitUnlabeledMetric = EmitUnlabeledMetricOption{} + +// AdditionalLabelsOption instructs the labeled metric to expect additional labels scoped for this just this metric +// in the context passed. +type AdditionalLabelsOption struct { + // A collection of labels to look for in the passed context. + Labels []string +} + +func (AdditionalLabelsOption) isMetricOption() {} diff --git a/flytestdlib/promutils/labeled/metric_option_test.go b/flytestdlib/promutils/labeled/metric_option_test.go new file mode 100644 index 0000000000..dc0f680d5d --- /dev/null +++ b/flytestdlib/promutils/labeled/metric_option_test.go @@ -0,0 +1,9 @@ +package labeled + +import ( + "testing" +) + +func TestMetricOption(t *testing.T) { + var _ MetricOption = &EmitUnlabeledMetric +} diff --git a/flytestdlib/promutils/labeled/stopwatch.go b/flytestdlib/promutils/labeled/stopwatch.go new file mode 100644 index 0000000000..acccc4d8b1 --- /dev/null +++ b/flytestdlib/promutils/labeled/stopwatch.go @@ -0,0 +1,97 @@ +package labeled + +import ( + "context" + "time" + + "k8s.io/apimachinery/pkg/util/sets" + + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +type StopWatch struct { + *promutils.StopWatchVec + + // We use SummaryVec for emitting StopWatchVec, this computes percentiles per metric tags combination on the client- + // side. This makes it impossible to aggregate percentiles across tags (e.g. to have system-wide view). When enabled + // through a flag in the constructor, we initialize this additional untagged stopwatch to compute percentiles + // across tags. + promutils.StopWatch + + labels []contextutils.Key +} + +// Start creates a new Instance of the StopWatch called a Timer that is closeable/stoppable. +func (c StopWatch) Start(ctx context.Context) Timer { + w, err := c.GetMetricWith(contextutils.Values(ctx, c.labels...)) + if err != nil { + panic(err.Error()) + } + + if c.Observer == nil { + return w.Start() + } + + return timer{ + Timers: []Timer{ + w.Start(), + c.StopWatch.Start(), + }, + } +} + +// Observe observes specified duration between the start and end time. The data point will be labeled with values from context. +// See labeled.SetMetricsKeys for information about how to configure that. +func (c StopWatch) Observe(ctx context.Context, start, end time.Time) { + w, err := c.GetMetricWith(contextutils.Values(ctx, c.labels...)) + if err != nil { + panic(err.Error()) + } + w.Observe(start, end) + + if c.Observer != nil { + c.StopWatch.Observe(start, end) + } +} + +// Time observes the elapsed duration since the creation of the timer. The timer is created using a StopWatch. +// The data point will be labeled with values from context. See labeled.SetMetricsKeys for information about to +// configure that. +func (c StopWatch) Time(ctx context.Context, f func()) { + t := c.Start(ctx) + f() + t.Stop() +} + +// NewStopWatch creates a new labeled stopwatch. Label keys must be set before instantiating a counter. See labeled.SetMetricsKeys +// for information about how to configure that. +func NewStopWatch(name, description string, scale time.Duration, scope promutils.Scope, opts ...MetricOption) StopWatch { + if len(metricKeys) == 0 { + panic(ErrNeverSet) + } + + sw := StopWatch{} + + name = promutils.SanitizeMetricName(name) + for _, opt := range opts { + if _, emitUnableMetric := opt.(EmitUnlabeledMetricOption); emitUnableMetric { + sw.StopWatch = scope.MustNewStopWatch(GetUnlabeledMetricName(name), description, scale) + } else if additionalLabels, casted := opt.(AdditionalLabelsOption); casted { + // compute unique labels + labelSet := sets.NewString(metricStringKeys...) + labelSet.Insert(additionalLabels.Labels...) + labels := labelSet.List() + + sw.StopWatchVec = scope.MustNewStopWatchVec(name, description, scale, labels...) + sw.labels = contextutils.MetricKeysFromStrings(labels) + } + } + + if sw.StopWatchVec == nil { + sw.StopWatchVec = scope.MustNewStopWatchVec(name, description, scale, metricStringKeys...) + sw.labels = metricKeys + } + + return sw +} diff --git a/flytestdlib/promutils/labeled/stopwatch_test.go b/flytestdlib/promutils/labeled/stopwatch_test.go new file mode 100644 index 0000000000..234b41cf57 --- /dev/null +++ b/flytestdlib/promutils/labeled/stopwatch_test.go @@ -0,0 +1,192 @@ +package labeled + +import ( + "context" + "testing" + "time" + + "github.com/prometheus/client_golang/prometheus" + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +func ExampleStopWatch_Start() { + ctx := context.Background() + stopWatch := NewStopWatch("test", "this is an example stopwatch", time.Millisecond, promutils.NewTestScope()) + { + timer := stopWatch.Start(ctx) + defer timer.Stop() + + // An operation you want to measure the time for. + time.Sleep(time.Second) + } +} + +func TestLabeledStopWatch(t *testing.T) { + UnsetMetricKeys() + assert.NotPanics(t, func() { + SetMetricKeys(contextutils.ProjectKey, contextutils.DomainKey, contextutils.WorkflowIDKey, contextutils.TaskIDKey) + }) + + t.Run("Labeled", func(t *testing.T) { + scope := promutils.NewScope("testscope_stopwatch") + s := NewStopWatch("s1", "some desc", time.Minute, scope) + assert.NotNil(t, s) + metricName := scope.CurrentScope() + "s1_m" + + ctx := context.TODO() + const header = ` + # HELP testscope_stopwatch:s1_m some desc + # TYPE testscope_stopwatch:s1_m summary` + + w := s.Start(ctx) + w.Stop() + expectedMetrics := map[string]any{ + `testscope_stopwatch:s1_m{domain="",project="",task="",wf="",quantile="0.5"}`: 0.0, + `testscope_stopwatch:s1_m{domain="",project="",task="",wf="",quantile="0.9"}`: 0.0, + `testscope_stopwatch:s1_m{domain="",project="",task="",wf="",quantile="0.99"}`: 0.0, + `testscope_stopwatch:s1_m_sum{domain="",project="",task="",wf=""}`: 0.0, + `testscope_stopwatch:s1_m_count{domain="",project="",task="",wf=""}`: 1, + } + assertMetrics(t, s.StopWatchVec, metricName, header, expectedMetrics) + + ctx = contextutils.WithProjectDomain(ctx, "project", "domain") + w = s.Start(ctx) + w.Stop() + expectedMetrics = map[string]any{ + `testscope_stopwatch:s1_m{domain="",project="",task="",wf="",quantile="0.5"}`: 0.0, + `testscope_stopwatch:s1_m{domain="",project="",task="",wf="",quantile="0.9"}`: 0.0, + `testscope_stopwatch:s1_m{domain="",project="",task="",wf="",quantile="0.99"}`: 0.0, + `testscope_stopwatch:s1_m_sum{domain="",project="",task="",wf=""}`: 0.0, + `testscope_stopwatch:s1_m_count{domain="",project="",task="",wf=""}`: 1, + `testscope_stopwatch:s1_m{domain="domain",project="project",task="",wf="",quantile="0.5"}`: 0.0, + `testscope_stopwatch:s1_m{domain="domain",project="project",task="",wf="",quantile="0.9"}`: 0.0, + `testscope_stopwatch:s1_m{domain="domain",project="project",task="",wf="",quantile="0.99"}`: 0.0, + `testscope_stopwatch:s1_m_sum{domain="domain",project="project",task="",wf=""}`: 0.0, + `testscope_stopwatch:s1_m_count{domain="domain",project="project",task="",wf=""}`: 1, + } + assertMetrics(t, s.StopWatchVec, metricName, header, expectedMetrics) + + now := time.Now() + s.Observe(ctx, now, now.Add(time.Minute)) + expectedMetrics = map[string]any{ + `testscope_stopwatch:s1_m{domain="",project="",task="",wf="",quantile="0.5"}`: 0.0, + `testscope_stopwatch:s1_m{domain="",project="",task="",wf="",quantile="0.9"}`: 0.0, + `testscope_stopwatch:s1_m{domain="",project="",task="",wf="",quantile="0.99"}`: 0.0, + `testscope_stopwatch:s1_m_sum{domain="",project="",task="",wf=""}`: 0.0, + `testscope_stopwatch:s1_m_count{domain="",project="",task="",wf=""}`: 1, + `testscope_stopwatch:s1_m{domain="domain",project="project",task="",wf="",quantile="0.5"}`: 0.0, + `testscope_stopwatch:s1_m{domain="domain",project="project",task="",wf="",quantile="0.9"}`: 1, + `testscope_stopwatch:s1_m{domain="domain",project="project",task="",wf="",quantile="0.99"}`: 1, + `testscope_stopwatch:s1_m_sum{domain="domain",project="project",task="",wf=""}`: 1.0, + `testscope_stopwatch:s1_m_count{domain="domain",project="project",task="",wf=""}`: 2, + } + assertMetrics(t, s.StopWatchVec, metricName, header, expectedMetrics) + + s.Time(ctx, func() { + // Do nothing + }) + expectedMetrics = map[string]any{ + `testscope_stopwatch:s1_m{domain="",project="",task="",wf="",quantile="0.5"}`: 0.0, + `testscope_stopwatch:s1_m{domain="",project="",task="",wf="",quantile="0.9"}`: 0.0, + `testscope_stopwatch:s1_m{domain="",project="",task="",wf="",quantile="0.99"}`: 0.0, + `testscope_stopwatch:s1_m_sum{domain="",project="",task="",wf=""}`: 0.0, + `testscope_stopwatch:s1_m_count{domain="",project="",task="",wf=""}`: 1, + `testscope_stopwatch:s1_m{domain="domain",project="project",task="",wf="",quantile="0.5"}`: 0.0, + `testscope_stopwatch:s1_m{domain="domain",project="project",task="",wf="",quantile="0.9"}`: 1, + `testscope_stopwatch:s1_m{domain="domain",project="project",task="",wf="",quantile="0.99"}`: 1, + `testscope_stopwatch:s1_m_sum{domain="domain",project="project",task="",wf=""}`: 1.0, + `testscope_stopwatch:s1_m_count{domain="domain",project="project",task="",wf=""}`: 3, + } + assertMetrics(t, s.StopWatchVec, metricName, header, expectedMetrics) + }) + + t.Run("Unlabeled", func(t *testing.T) { + scope := promutils.NewScope("testscope_stopwatch") + s := NewStopWatch("s2", "some desc", time.Minute, scope, EmitUnlabeledMetric) + assert.NotNil(t, s) + + ctx := context.TODO() + const header = ` + # HELP testscope_stopwatch:s2_unlabeled_m some desc + # TYPE testscope_stopwatch:s2_unlabeled_m summary + ` + + w := s.Start(ctx) + w.Stop() + expectedMetrics := map[string]any{ + `testscope_stopwatch:s2_unlabeled_m{quantile="0.5"}`: 0.0, + `testscope_stopwatch:s2_unlabeled_m{quantile="0.9"}`: 0.0, + `testscope_stopwatch:s2_unlabeled_m{quantile="0.99"}`: 0.0, + `testscope_stopwatch:s2_unlabeled_m_sum`: 0.0, + `testscope_stopwatch:s2_unlabeled_m_count`: 1, + } + assertMetrics(t, s.Observer.(prometheus.Summary), "testscope_stopwatch:s2_unlabeled_m", header, expectedMetrics) + }) + + t.Run("AdditionalLabels", func(t *testing.T) { + scope := promutils.NewScope("testscope_stopwatch") + opts := AdditionalLabelsOption{Labels: []string{contextutils.ProjectKey.String(), contextutils.ExecIDKey.String()}} + s := NewStopWatch("s3", "some desc", time.Minute, scope, opts) + assert.NotNil(t, s) + metricName := scope.CurrentScope() + "s3_m" + + ctx := context.TODO() + const header = ` + # HELP testscope_stopwatch:s3_m some desc + # TYPE testscope_stopwatch:s3_m summary + ` + + w := s.Start(ctx) + w.Stop() + expectedMetrics := map[string]any{ + `testscope_stopwatch:s3_m{domain="",exec_id="",project="",task="",wf="",quantile="0.5"}`: 0.0, + `testscope_stopwatch:s3_m{domain="",exec_id="",project="",task="",wf="",quantile="0.9"}`: 0.0, + `testscope_stopwatch:s3_m{domain="",exec_id="",project="",task="",wf="",quantile="0.99"}`: 0.0, + `testscope_stopwatch:s3_m_sum{domain="",exec_id="",project="",task="",wf=""}`: 0.0, + `testscope_stopwatch:s3_m_count{domain="",exec_id="",project="",task="",wf=""}`: 1, + } + assertMetrics(t, s.StopWatchVec, metricName, header, expectedMetrics) + + ctx = contextutils.WithProjectDomain(ctx, "project", "domain") + w = s.Start(ctx) + w.Stop() + expectedMetrics = map[string]any{ + `testscope_stopwatch:s3_m{domain="",exec_id="",project="",task="",wf="",quantile="0.5"}`: 0.0, + `testscope_stopwatch:s3_m{domain="",exec_id="",project="",task="",wf="",quantile="0.9"}`: 0.0, + `testscope_stopwatch:s3_m{domain="",exec_id="",project="",task="",wf="",quantile="0.99"}`: 0.0, + `testscope_stopwatch:s3_m_sum{domain="",exec_id="",project="",task="",wf=""}`: 0.0, + `testscope_stopwatch:s3_m_count{domain="",exec_id="",project="",task="",wf=""}`: 1, + `testscope_stopwatch:s3_m{domain="domain",exec_id="",project="project",task="",wf="",quantile="0.5"}`: 0.0, + `testscope_stopwatch:s3_m{domain="domain",exec_id="",project="project",task="",wf="",quantile="0.9"}`: 0.0, + `testscope_stopwatch:s3_m{domain="domain",exec_id="",project="project",task="",wf="",quantile="0.99"}`: 0.0, + `testscope_stopwatch:s3_m_sum{domain="domain",exec_id="",project="project",task="",wf=""}`: 0.0, + `testscope_stopwatch:s3_m_count{domain="domain",exec_id="",project="project",task="",wf=""}`: 1, + } + assertMetrics(t, s.StopWatchVec, metricName, header, expectedMetrics) + + ctx = contextutils.WithExecutionID(ctx, "exec_id") + w = s.Start(ctx) + w.Stop() + expectedMetrics = map[string]any{ + `testscope_stopwatch:s3_m{domain="",exec_id="",project="",task="",wf="",quantile="0.5"}`: 0.0, + `testscope_stopwatch:s3_m{domain="",exec_id="",project="",task="",wf="",quantile="0.9"}`: 0.0, + `testscope_stopwatch:s3_m{domain="",exec_id="",project="",task="",wf="",quantile="0.99"}`: 0.0, + `testscope_stopwatch:s3_m_sum{domain="",exec_id="",project="",task="",wf=""}`: 0.0, + `testscope_stopwatch:s3_m_count{domain="",exec_id="",project="",task="",wf=""}`: 1, + `testscope_stopwatch:s3_m{domain="domain",exec_id="",project="project",task="",wf="",quantile="0.5"}`: 0.0, + `testscope_stopwatch:s3_m{domain="domain",exec_id="",project="project",task="",wf="",quantile="0.9"}`: 0.0, + `testscope_stopwatch:s3_m{domain="domain",exec_id="",project="project",task="",wf="",quantile="0.99"}`: 0.0, + `testscope_stopwatch:s3_m_sum{domain="domain",exec_id="",project="project",task="",wf=""}`: 0.0, + `testscope_stopwatch:s3_m_count{domain="domain",exec_id="",project="project",task="",wf=""}`: 1, + `testscope_stopwatch:s3_m{domain="domain",exec_id="exec_id",project="project",task="",wf="",quantile="0.5"}`: 0.0, + `testscope_stopwatch:s3_m{domain="domain",exec_id="exec_id",project="project",task="",wf="",quantile="0.9"}`: 0.0, + `testscope_stopwatch:s3_m{domain="domain",exec_id="exec_id",project="project",task="",wf="",quantile="0.99"}`: 0.0, + `testscope_stopwatch:s3_m_sum{domain="domain",exec_id="exec_id",project="project",task="",wf=""}`: 0.0, + `testscope_stopwatch:s3_m_count{domain="domain",exec_id="exec_id",project="project",task="",wf=""}`: 1, + } + assertMetrics(t, s.StopWatchVec, metricName, header, expectedMetrics) + }) +} diff --git a/flytestdlib/promutils/labeled/summary.go b/flytestdlib/promutils/labeled/summary.go new file mode 100644 index 0000000000..83aebaeeab --- /dev/null +++ b/flytestdlib/promutils/labeled/summary.go @@ -0,0 +1,64 @@ +package labeled + +import ( + "context" + + "github.com/prometheus/client_golang/prometheus" + "k8s.io/apimachinery/pkg/util/sets" + + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +// Summary represents a summary labeled with values from the context. See labeled.SetMetricsKeys for information about +// how to configure that. +type Summary struct { + *prometheus.SummaryVec + + prometheus.Summary + labels []contextutils.Key +} + +// Observe adds a single observation to the summary. +func (s Summary) Observe(ctx context.Context, v float64) { + summary, err := s.GetMetricWith(contextutils.Values(ctx, s.labels...)) + if err != nil { + panic(err.Error()) + } + summary.Observe(v) + + if s.Summary != nil { + s.Summary.Observe(v) + } +} + +// NewSummary creates a new labeled summary. Label keys must be set before instantiating. If the unlabeled option is +// given, this object will also instantiate and emit another summary with the given name with an _unlabeled suffix. +// See labeled.SetMetricsKeys for information about how to configure that. +func NewSummary(name, description string, scope promutils.Scope, opts ...MetricOption) Summary { + if len(metricKeys) == 0 { + panic(ErrNeverSet) + } + + s := Summary{} + for _, opt := range opts { + if _, emitUnlabeledMetric := opt.(EmitUnlabeledMetricOption); emitUnlabeledMetric { + s.Summary = scope.MustNewSummary(GetUnlabeledMetricName(name), description) + } else if additionalLabels, casted := opt.(AdditionalLabelsOption); casted { + // compute unique labels + labelSet := sets.NewString(metricStringKeys...) + labelSet.Insert(additionalLabels.Labels...) + labels := labelSet.List() + + s.SummaryVec = scope.MustNewSummaryVec(name, description, labels...) + s.labels = contextutils.MetricKeysFromStrings(labels) + } + } + + if s.SummaryVec == nil { + s.SummaryVec = scope.MustNewSummaryVec(name, description, metricStringKeys...) + s.labels = metricKeys + } + + return s +} diff --git a/flytestdlib/promutils/labeled/summary_test.go b/flytestdlib/promutils/labeled/summary_test.go new file mode 100644 index 0000000000..a051ac2e24 --- /dev/null +++ b/flytestdlib/promutils/labeled/summary_test.go @@ -0,0 +1,188 @@ +package labeled + +import ( + "context" + "strings" + "testing" + + "github.com/prometheus/client_golang/prometheus/testutil" + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +func TestLabeledSummary(t *testing.T) { + UnsetMetricKeys() + assert.NotPanics(t, func() { + SetMetricKeys(contextutils.ProjectKey, contextutils.DomainKey, contextutils.WorkflowIDKey, contextutils.TaskIDKey) + }) + + t.Run("Labeled", func(t *testing.T) { + scope := promutils.NewScope("testscope_summary") + s := NewSummary("s1", "some desc", scope) + assert.NotNil(t, s) + + ctx := context.TODO() + const header = ` + # HELP testscope_summary:s1 some desc + # TYPE testscope_summary:s1 summary + ` + + s.Observe(ctx, 10) + var expected = ` + testscope_summary:s1{domain="",project="",task="",wf="",quantile="0.5"} 10 + testscope_summary:s1{domain="",project="",task="",wf="",quantile="0.9"} 10 + testscope_summary:s1{domain="",project="",task="",wf="",quantile="0.99"} 10 + testscope_summary:s1_sum{domain="",project="",task="",wf=""} 10 + testscope_summary:s1_count{domain="",project="",task="",wf=""} 1 + ` + err := testutil.CollectAndCompare(s.SummaryVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + + s.Observe(ctx, 100) + s.Observe(ctx, 1000) + expected = ` + testscope_summary:s1{domain="",project="",task="",wf="",quantile="0.5"} 100 + testscope_summary:s1{domain="",project="",task="",wf="",quantile="0.9"} 1000 + testscope_summary:s1{domain="",project="",task="",wf="",quantile="0.99"} 1000 + testscope_summary:s1_sum{domain="",project="",task="",wf=""} 1110 + testscope_summary:s1_count{domain="",project="",task="",wf=""} 3 + ` + err = testutil.CollectAndCompare(s.SummaryVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + + ctx = contextutils.WithProjectDomain(ctx, "project", "domain") + s.Observe(ctx, 10) + expected = ` + testscope_summary:s1{domain="",project="",task="",wf="",quantile="0.5"} 100 + testscope_summary:s1{domain="",project="",task="",wf="",quantile="0.9"} 1000 + testscope_summary:s1{domain="",project="",task="",wf="",quantile="0.99"} 1000 + testscope_summary:s1_sum{domain="",project="",task="",wf=""} 1110 + testscope_summary:s1_count{domain="",project="",task="",wf=""} 3 + testscope_summary:s1{domain="domain",project="project",task="",wf="",quantile="0.5"} 10 + testscope_summary:s1{domain="domain",project="project",task="",wf="",quantile="0.9"} 10 + testscope_summary:s1{domain="domain",project="project",task="",wf="",quantile="0.99"} 10 + testscope_summary:s1_sum{domain="domain",project="project",task="",wf=""} 10 + testscope_summary:s1_count{domain="domain",project="project",task="",wf=""} 1 + ` + err = testutil.CollectAndCompare(s.SummaryVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + }) + + t.Run("Unlabeled", func(t *testing.T) { + scope := promutils.NewScope("testscope_summary") + s := NewSummary("s2", "some desc", scope, EmitUnlabeledMetric) + assert.NotNil(t, s) + + ctx := context.TODO() + const header = ` + # HELP testscope_summary:s2_unlabeled some desc + # TYPE testscope_summary:s2_unlabeled summary + ` + + s.Observe(ctx, 10) + var expected = ` + testscope_summary:s2_unlabeled{quantile="0.5"} 10 + testscope_summary:s2_unlabeled{quantile="0.9"} 10 + testscope_summary:s2_unlabeled{quantile="0.99"} 10 + testscope_summary:s2_unlabeled_sum 10 + testscope_summary:s2_unlabeled_count 1 + ` + err := testutil.CollectAndCompare(s.Summary, strings.NewReader(header+expected)) + assert.NoError(t, err) + }) + + /*t.Run("extra labels", func(t *testing.T) { + scope := promutils.NewScope("testscope_summary") + ctx := context.Background() + s := NewSummary("s12", "some desc", scope, AdditionalLabelsOption{Labels: []string{"method"}}) + assert.NotNil(t, s) + + methodKey := contextutils.Key("method") + s.Observe(context.WithValue(ctx, methodKey, "GET"), 10) + s.Observe(context.WithValue(ctx, methodKey, "POST"), 100) + + const header = ` + # HELP testscope_summary:s12 some desc + # TYPE testscope_summary:s12 summary + ` + var expected = ` + testscope_summary:s12{domain="",lp="",method="GET",project="",task="",wf="",quantile="0.5"} 10 + testscope_summary:s12{domain="",lp="",method="GET",project="",task="",wf="",quantile="0.9"} 10 + testscope_summary:s12{domain="",lp="",method="GET",project="",task="",wf="",quantile="0.99"} 10 + testscope_summary:s12_sum{domain="",lp="",method="GET",project="",task="",wf=""} 10 + testscope_summary:s12_count{domain="",lp="",method="GET",project="",task="",wf=""} 1 + testscope_summary:s12{domain="",lp="",method="POST",project="",task="",wf="",quantile="0.5"} 100 + testscope_summary:s12{domain="",lp="",method="POST",project="",task="",wf="",quantile="0.9"} 100 + testscope_summary:s12{domain="",lp="",method="POST",project="",task="",wf="",quantile="0.99"} 100 + testscope_summary:s12_sum{domain="",lp="",method="POST",project="",task="",wf=""} 100 + testscope_summary:s12_count{domain="",lp="",method="POST",project="",task="",wf=""} 1 + ` + err := testutil.CollectAndCompare(s.SummaryVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + })*/ + + t.Run("AdditionalLabels", func(t *testing.T) { + scope := promutils.NewScope("testscope_summary") + opts := AdditionalLabelsOption{Labels: []string{contextutils.ProjectKey.String(), contextutils.ExecIDKey.String()}} + s := NewSummary("s3", "some desc", scope, opts) + assert.NotNil(t, s) + + ctx := context.TODO() + const header = ` + # HELP testscope_summary:s3 some desc + # TYPE testscope_summary:s3 summary + ` + + s.Observe(ctx, 10) + var expected = ` + testscope_summary:s3{domain="",exec_id="",project="",task="",wf="",quantile="0.5"} 10 + testscope_summary:s3{domain="",exec_id="",project="",task="",wf="",quantile="0.9"} 10 + testscope_summary:s3{domain="",exec_id="",project="",task="",wf="",quantile="0.99"} 10 + testscope_summary:s3_sum{domain="",exec_id="",project="",task="",wf=""} 10 + testscope_summary:s3_count{domain="",exec_id="",project="",task="",wf=""} 1 + ` + err := testutil.CollectAndCompare(s.SummaryVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + + ctx = contextutils.WithProjectDomain(ctx, "project", "domain") + s.Observe(ctx, 10) + expected = ` + testscope_summary:s3{domain="",exec_id="",project="",task="",wf="",quantile="0.5"} 10 + testscope_summary:s3{domain="",exec_id="",project="",task="",wf="",quantile="0.9"} 10 + testscope_summary:s3{domain="",exec_id="",project="",task="",wf="",quantile="0.99"} 10 + testscope_summary:s3_sum{domain="",exec_id="",project="",task="",wf=""} 10 + testscope_summary:s3_count{domain="",exec_id="",project="",task="",wf=""} 1 + testscope_summary:s3{domain="domain",exec_id="",project="project",task="",wf="",quantile="0.5"} 10 + testscope_summary:s3{domain="domain",exec_id="",project="project",task="",wf="",quantile="0.9"} 10 + testscope_summary:s3{domain="domain",exec_id="",project="project",task="",wf="",quantile="0.99"} 10 + testscope_summary:s3_sum{domain="domain",exec_id="",project="project",task="",wf=""} 10 + testscope_summary:s3_count{domain="domain",exec_id="",project="project",task="",wf=""} 1 + ` + err = testutil.CollectAndCompare(s.SummaryVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + + ctx = contextutils.WithExecutionID(ctx, "exec_id") + s.Observe(ctx, 10) + expected = ` + testscope_summary:s3{domain="",exec_id="",project="",task="",wf="",quantile="0.5"} 10 + testscope_summary:s3{domain="",exec_id="",project="",task="",wf="",quantile="0.9"} 10 + testscope_summary:s3{domain="",exec_id="",project="",task="",wf="",quantile="0.99"} 10 + testscope_summary:s3_sum{domain="",exec_id="",project="",task="",wf=""} 10 + testscope_summary:s3_count{domain="",exec_id="",project="",task="",wf=""} 1 + testscope_summary:s3{domain="domain",exec_id="",project="project",task="",wf="",quantile="0.5"} 10 + testscope_summary:s3{domain="domain",exec_id="",project="project",task="",wf="",quantile="0.9"} 10 + testscope_summary:s3{domain="domain",exec_id="",project="project",task="",wf="",quantile="0.99"} 10 + testscope_summary:s3_sum{domain="domain",exec_id="",project="project",task="",wf=""} 10 + testscope_summary:s3_count{domain="domain",exec_id="",project="project",task="",wf=""} 1 + testscope_summary:s3{domain="domain",exec_id="exec_id",project="project",task="",wf="",quantile="0.5"} 10 + testscope_summary:s3{domain="domain",exec_id="exec_id",project="project",task="",wf="",quantile="0.9"} 10 + testscope_summary:s3{domain="domain",exec_id="exec_id",project="project",task="",wf="",quantile="0.99"} 10 + testscope_summary:s3_sum{domain="domain",exec_id="exec_id",project="project",task="",wf=""} 10 + testscope_summary:s3_count{domain="domain",exec_id="exec_id",project="project",task="",wf=""} 1 + ` + err = testutil.CollectAndCompare(s.SummaryVec, strings.NewReader(header+expected)) + assert.NoError(t, err) + }) +} diff --git a/flytestdlib/promutils/labeled/timer_wrapper.go b/flytestdlib/promutils/labeled/timer_wrapper.go new file mode 100644 index 0000000000..75aa4bee94 --- /dev/null +++ b/flytestdlib/promutils/labeled/timer_wrapper.go @@ -0,0 +1,20 @@ +package labeled + +// Defines a common interface for timers. +type Timer interface { + // Stops the timer and reports observation. + Stop() float64 +} + +type timer struct { + Timers []Timer +} + +func (t timer) Stop() float64 { + var res float64 + for _, timer := range t.Timers { + res = timer.Stop() + } + + return res +} diff --git a/flytestdlib/promutils/labeled/timer_wrapper_test.go b/flytestdlib/promutils/labeled/timer_wrapper_test.go new file mode 100644 index 0000000000..375836c557 --- /dev/null +++ b/flytestdlib/promutils/labeled/timer_wrapper_test.go @@ -0,0 +1,28 @@ +package labeled + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +type fakeTimer struct { + stopCount int +} + +func (f *fakeTimer) Stop() float64 { + f.stopCount++ + return 0 +} + +func TestTimerStop(t *testing.T) { + ft := &fakeTimer{} + tim := timer{ + Timers: []Timer{ + ft, ft, ft, + }, + } + + tim.Stop() + assert.Equal(t, 3, ft.stopCount) +} diff --git a/flytestdlib/promutils/scope.go b/flytestdlib/promutils/scope.go new file mode 100644 index 0000000000..1e3d027901 --- /dev/null +++ b/flytestdlib/promutils/scope.go @@ -0,0 +1,593 @@ +package promutils + +import ( + "strings" + "time" + + "github.com/prometheus/client_golang/prometheus" + "k8s.io/apimachinery/pkg/util/rand" +) + +const defaultScopeDelimiterStr = ":" +const defaultMetricDelimiterStr = "_" + +var ( + defaultObjectives = map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001} + defaultBuckets = []float64{.005, .01, .025, .05, .1, .25, .5, 1, 2.5, 5, 10} +) + +func panicIfError(err error) { + if err != nil { + panic("Failed to register metrics. Error: " + err.Error()) + } +} + +// StopWatch implements a stopwatch style interface that works with prometheus summary +// It will scale the output to match the expected time scale (milliseconds, seconds etc) +// NOTE: Do not create a StopWatch object by hand, use a Scope to get a new instance of the StopWatch object +type StopWatch struct { + prometheus.Observer + outputScale time.Duration +} + +// Start creates a new Instance of the StopWatch called a Timer that is closeable/stoppable. +// Common pattern to time a scope would be +func (s StopWatch) Start() Timer { + return Timer{ + start: time.Now(), + outputScale: s.outputScale, + timer: s.Observer, + } +} + +// Observe records a specified duration between the start and end time +func (s StopWatch) Observe(start, end time.Time) { + observed := end.Sub(start).Nanoseconds() + outputScaleDuration := s.outputScale.Nanoseconds() + if outputScaleDuration == 0 { + s.Observer.Observe(0) + return + } + scaled := float64(observed / outputScaleDuration) + s.Observer.Observe(scaled) +} + +// Time Observes/records the time to execute the given function synchronously +func (s StopWatch) Time(f func()) { + t := s.Start() + f() + t.Stop() +} + +// A Simple StopWatch that works with prometheus summary +// It will scale the output to match the expected time scale (milliseconds, seconds etc) +// NOTE: Do not create a StopWatch object by hand, use a Scope to get a new instance of the StopWatch object +type StopWatchVec struct { + *prometheus.SummaryVec + outputScale time.Duration +} + +// Gets a concrete StopWatch instance that can be used to start a timer and record observations. +func (s StopWatchVec) WithLabelValues(values ...string) StopWatch { + return StopWatch{ + Observer: s.SummaryVec.WithLabelValues(values...), + outputScale: s.outputScale, + } +} + +func (s StopWatchVec) GetMetricWith(labels prometheus.Labels) (StopWatch, error) { + sVec, err := s.SummaryVec.GetMetricWith(labels) + if err != nil { + return StopWatch{}, err + } + return StopWatch{ + Observer: sVec, + outputScale: s.outputScale, + }, nil +} + +// HistogramStopWatch implements a stopwatch style interface that works with prometheus histogram +// NOTE: Do not create a HistogramStopWatch object by hand, use a Scope to get a new instance of the StopWatch object +type HistogramStopWatch struct { + StopWatch +} + +// HistogramStopWatchVec implements a stopwatch style interface that works with prometheus histogram +// NOTE: Do not create a HistogramStopWatchVec object by hand, use a Scope to get a new instance of the StopWatch object +type HistogramStopWatchVec struct { + *prometheus.HistogramVec + outputScale time.Duration +} + +// Gets a concrete StopWatch instance that can be used to start a timer and record observations. +func (h HistogramStopWatchVec) WithLabelValues(values ...string) HistogramStopWatch { + return HistogramStopWatch{ + StopWatch: StopWatch{ + Observer: h.HistogramVec.WithLabelValues(values...), + outputScale: h.outputScale, + }, + } +} + +func (h HistogramStopWatchVec) GetMetricWith(labels prometheus.Labels) (HistogramStopWatch, error) { + hVec, err := h.HistogramVec.GetMetricWith(labels) + if err != nil { + return HistogramStopWatch{}, err + } + return HistogramStopWatch{ + StopWatch{ + Observer: hVec, + outputScale: h.outputScale, + }, + }, nil +} + +// Timer is a stoppable instance of a StopWatch or a Timer +// A Timer can only be stopped. On stopping it will output the elapsed duration to prometheus +type Timer struct { + start time.Time + outputScale time.Duration + timer prometheus.Observer +} + +// Stop observes the elapsed duration since the creation of the timer. The timer is created using a StopWatch +func (s Timer) Stop() float64 { + observed := time.Since(s.start).Nanoseconds() + outputScaleDuration := s.outputScale.Nanoseconds() + if outputScaleDuration == 0 { + s.timer.Observe(0) + return 0 + } + scaled := float64(observed) / float64(outputScaleDuration) + s.timer.Observe(scaled) + return scaled +} + +// A SummaryOptions represents a set of options that can be supplied when creating a new prometheus summary metric +type SummaryOptions struct { + // An Objectives defines the quantile rank estimates with their respective absolute errors. + // Refer to https://godoc.org/github.com/prometheus/client_golang/prometheus#SummaryOpts for details + Objectives map[float64]float64 +} + +// A HistogramOptions represent buckets to specify for a histogram vector when creating a new prometheus histogram +type HistogramOptions struct { + // Buckets is a list of pre-determined buckets for the histogram + Buckets []float64 +} + +// A Scope represents a prefix in Prometheus. It is nestable, thus every metric that is published does not need to +// provide a prefix, but just the name of the metric. As long as the Scope is used to create a new instance of the metric +// The prefix (or scope) is automatically set. +type Scope interface { + // NewGauge creates new prometheus.Gauge metric with the prefix as the CurrentScope + // Name is a string that follows prometheus conventions (mostly [_a-z]) + // Refer to https://prometheus.io/docs/concepts/metric_types/ for more information + NewGauge(name, description string) (prometheus.Gauge, error) + MustNewGauge(name, description string) prometheus.Gauge + + // NewGaugeVec creates new prometheus.GaugeVec metric with the prefix as the CurrentScope + // Refer to https://prometheus.io/docs/concepts/metric_types/ for more information + NewGaugeVec(name, description string, labelNames ...string) (*prometheus.GaugeVec, error) + MustNewGaugeVec(name, description string, labelNames ...string) *prometheus.GaugeVec + + // NewSummary creates new prometheus.Summary metric with the prefix as the CurrentScope + // Refer to https://prometheus.io/docs/concepts/metric_types/ for more information + NewSummary(name, description string) (prometheus.Summary, error) + MustNewSummary(name, description string) prometheus.Summary + + // NewSummaryWithOptions creates new prometheus.Summary metric with custom options, such as a custom set of objectives (i.e., target quantiles). + // Refer to https://prometheus.io/docs/concepts/metric_types/ for more information + NewSummaryWithOptions(name, description string, options SummaryOptions) (prometheus.Summary, error) + MustNewSummaryWithOptions(name, description string, options SummaryOptions) prometheus.Summary + + // NewSummaryVec creates new prometheus.SummaryVec metric with the prefix as the CurrentScope + // Refer to https://prometheus.io/docs/concepts/metric_types/ for more information + NewSummaryVec(name, description string, labelNames ...string) (*prometheus.SummaryVec, error) + MustNewSummaryVec(name, description string, labelNames ...string) *prometheus.SummaryVec + + // NewHistogram creates new prometheus.Histogram metric with the prefix as the CurrentScope + // Refer to https://prometheus.io/docs/concepts/metric_types/ for more information + NewHistogram(name, description string) (prometheus.Histogram, error) + MustNewHistogram(name, description string) prometheus.Histogram + + // NewHistogramVec creates new prometheus.HistogramVec metric with the prefix as the CurrentScope + // Refer to https://prometheus.io/docs/concepts/metric_types/ for more information + NewHistogramVec(name, description string, labelNames ...string) (*prometheus.HistogramVec, error) + MustNewHistogramVec(name, description string, labelNames ...string) *prometheus.HistogramVec + + // NewHistogramVecWithOptions creates new prometheus.HistogramVec metric with the prefix as the CurrentScope + // with a custom set of options, such as of buckets. + // Refer to https://prometheus.io/docs/concepts/metric_types/ for more information + NewHistogramVecWithOptions(name, description string, options HistogramOptions, labelNames ...string) (*prometheus.HistogramVec, error) + MustNewHistogramVecWithOptions(name, description string, options HistogramOptions, labelNames ...string) *prometheus.HistogramVec + + // NewCounter creates new prometheus.Counter metric with the prefix as the CurrentScope + // Refer to https://prometheus.io/docs/concepts/metric_types/ for more information + // Important to note, counters are not like typical counters. These are ever increasing and cumulative. + // So if you want to observe counters within buckets use Summary/Histogram + NewCounter(name, description string) (prometheus.Counter, error) + MustNewCounter(name, description string) prometheus.Counter + + // NewCounterVec creates new prometheus.GaugeVec metric with the prefix as the CurrentScope + // Refer to https://prometheus.io/docs/concepts/metric_types/ for more information + NewCounterVec(name, description string, labelNames ...string) (*prometheus.CounterVec, error) + MustNewCounterVec(name, description string, labelNames ...string) *prometheus.CounterVec + + // NewStopWatch is a custom wrapper to create a StopWatch object in the current Scope. + // Duration is to specify the scale of the Timer. For example if you are measuring times in milliseconds + // pass scale=times.Millisecond + // https://golang.org/pkg/time/#Duration + // The metric name is auto-suffixed with the right scale. Refer to DurationToString to understand + NewStopWatch(name, description string, scale time.Duration) (StopWatch, error) + MustNewStopWatch(name, description string, scale time.Duration) StopWatch + + // NewStopWatchVec is a custom wrapper to create a StopWatch object in the current Scope. + // Duration is to specify the scale of the Timer. For example if you are measuring times in milliseconds + // pass scale=times.Millisecond + // https://golang.org/pkg/time/#Duration + // The metric name is auto-suffixed with the right scale. Refer to DurationToString to understand + NewStopWatchVec(name, description string, scale time.Duration, labelNames ...string) (*StopWatchVec, error) + MustNewStopWatchVec(name, description string, scale time.Duration, labelNames ...string) *StopWatchVec + + // NewHistogramStopWatch is a custom wrapper to create a HistogramStopWatch object in the current Scope. + // Unlike a StopWatch, a HistogramStopWatch can be aggregated across instances. Quantiles are computed server side. + // See https://prometheus.io/docs/practices/histograms/#quantiles for tradeoffs. + // Scale is assumed to be seconds with buckets spanning 0.005s to 10s. + NewHistogramStopWatch(name, description string) (HistogramStopWatch, error) + MustNewHistogramStopWatch(name, description string) HistogramStopWatch + + // NewHistogramStopWatchVec is a custom wrapper to create a HistogramStopWatchVec object in the current Scope. + // Unlike a StopWatchVec, a HistogramStopWatchVec can be aggregated across instances. Quantiles are computed server side. + // See https://prometheus.io/docs/practices/histograms/#quantiles for tradeoffs. + // Scale is assumed to be seconds with buckets spanning 0.005s to 10s. + NewHistogramStopWatchVec(name, description string, labelNames ...string) (*HistogramStopWatchVec, error) + MustNewHistogramStopWatchVec(name, description string, labelNames ...string) *HistogramStopWatchVec + + // NewSubScope creates a new subScope in case nesting is desired for metrics. This is generally useful in creating + // Scoped and SubScoped metrics + NewSubScope(name string) Scope + + // CurrentScope returns the current ScopeName. Use for creating your own metrics + CurrentScope() string + + // NewScopedMetricName provides a scoped metric name. Can be used, if you want to directly create your own metric + NewScopedMetricName(name string) string +} + +type metricsScope struct { + scope string +} + +func (m metricsScope) NewGauge(name, description string) (prometheus.Gauge, error) { + g := prometheus.NewGauge( + prometheus.GaugeOpts{ + Name: m.NewScopedMetricName(name), + Help: description, + }, + ) + return g, prometheus.Register(g) +} + +func (m metricsScope) MustNewGauge(name, description string) prometheus.Gauge { + g, err := m.NewGauge(name, description) + panicIfError(err) + return g +} + +func (m metricsScope) NewGaugeVec(name, description string, labelNames ...string) (*prometheus.GaugeVec, error) { + g := prometheus.NewGaugeVec( + prometheus.GaugeOpts{ + Name: m.NewScopedMetricName(name), + Help: description, + }, + labelNames, + ) + return g, prometheus.Register(g) +} + +func (m metricsScope) MustNewGaugeVec(name, description string, labelNames ...string) *prometheus.GaugeVec { + g, err := m.NewGaugeVec(name, description, labelNames...) + panicIfError(err) + return g +} + +func (m metricsScope) NewSummary(name, description string) (prometheus.Summary, error) { + return m.NewSummaryWithOptions(name, description, SummaryOptions{Objectives: defaultObjectives}) +} + +func (m metricsScope) MustNewSummary(name, description string) prometheus.Summary { + s, err := m.NewSummary(name, description) + panicIfError(err) + return s +} + +func (m metricsScope) NewSummaryWithOptions(name, description string, options SummaryOptions) (prometheus.Summary, error) { + s := prometheus.NewSummary( + prometheus.SummaryOpts{ + Name: m.NewScopedMetricName(name), + Help: description, + Objectives: options.Objectives, + }, + ) + + return s, prometheus.Register(s) +} + +func (m metricsScope) MustNewSummaryWithOptions(name, description string, options SummaryOptions) prometheus.Summary { + s, err := m.NewSummaryWithOptions(name, description, options) + panicIfError(err) + return s +} + +func (m metricsScope) NewSummaryVec(name, description string, labelNames ...string) (*prometheus.SummaryVec, error) { + s := prometheus.NewSummaryVec( + prometheus.SummaryOpts{ + Name: m.NewScopedMetricName(name), + Help: description, + Objectives: defaultObjectives, + }, + labelNames, + ) + + return s, prometheus.Register(s) +} +func (m metricsScope) MustNewSummaryVec(name, description string, labelNames ...string) *prometheus.SummaryVec { + s, err := m.NewSummaryVec(name, description, labelNames...) + panicIfError(err) + return s +} + +func (m metricsScope) NewHistogram(name, description string) (prometheus.Histogram, error) { + h := prometheus.NewHistogram( + prometheus.HistogramOpts{ + Name: m.NewScopedMetricName(name), + Help: description, + Buckets: defaultBuckets, + }, + ) + return h, prometheus.Register(h) +} + +func (m metricsScope) MustNewHistogram(name, description string) prometheus.Histogram { + h, err := m.NewHistogram(name, description) + panicIfError(err) + return h +} + +func (m metricsScope) NewHistogramVec(name, description string, labelNames ...string) (*prometheus.HistogramVec, error) { + h := prometheus.NewHistogramVec( + prometheus.HistogramOpts{ + Name: m.NewScopedMetricName(name), + Help: description, + Buckets: defaultBuckets, + }, + labelNames, + ) + return h, prometheus.Register(h) +} + +func (m metricsScope) MustNewHistogramVec(name, description string, labelNames ...string) *prometheus.HistogramVec { + h, err := m.NewHistogramVec(name, description, labelNames...) + panicIfError(err) + return h +} + +func (m metricsScope) NewHistogramVecWithOptions(name, description string, options HistogramOptions, labelNames ...string) (*prometheus.HistogramVec, error) { + h := prometheus.NewHistogramVec( + prometheus.HistogramOpts{ + Name: m.NewScopedMetricName(name), + Help: description, + Buckets: options.Buckets, + }, + labelNames, + ) + + return h, prometheus.Register(h) +} + +func (m metricsScope) MustNewHistogramVecWithOptions(name, description string, options HistogramOptions, labelNames ...string) *prometheus.HistogramVec { + h, err := m.NewHistogramVecWithOptions(name, description, options, labelNames...) + panicIfError(err) + return h +} + +func (m metricsScope) NewCounter(name, description string) (prometheus.Counter, error) { + c := prometheus.NewCounter( + prometheus.CounterOpts{ + Name: m.NewScopedMetricName(name), + Help: description, + }, + ) + return c, prometheus.Register(c) +} + +func (m metricsScope) MustNewCounter(name, description string) prometheus.Counter { + c, err := m.NewCounter(name, description) + panicIfError(err) + return c +} + +func (m metricsScope) NewCounterVec(name, description string, labelNames ...string) (*prometheus.CounterVec, error) { + c := prometheus.NewCounterVec( + prometheus.CounterOpts{ + Name: m.NewScopedMetricName(name), + Help: description, + }, + labelNames, + ) + return c, prometheus.Register(c) +} + +func (m metricsScope) MustNewCounterVec(name, description string, labelNames ...string) *prometheus.CounterVec { + c, err := m.NewCounterVec(name, description, labelNames...) + panicIfError(err) + return c +} + +func (m metricsScope) NewStopWatch(name, description string, scale time.Duration) (StopWatch, error) { + if !strings.HasSuffix(name, defaultMetricDelimiterStr) { + name += defaultMetricDelimiterStr + } + name += DurationToString(scale) + s, err := m.NewSummary(name, description) + if err != nil { + return StopWatch{}, err + } + + return StopWatch{ + Observer: s, + outputScale: scale, + }, nil +} + +func (m metricsScope) MustNewStopWatch(name, description string, scale time.Duration) StopWatch { + s, err := m.NewStopWatch(name, description, scale) + panicIfError(err) + return s +} + +func (m metricsScope) NewStopWatchVec(name, description string, scale time.Duration, labelNames ...string) (*StopWatchVec, error) { + if !strings.HasSuffix(name, defaultMetricDelimiterStr) { + name += defaultMetricDelimiterStr + } + name += DurationToString(scale) + s, err := m.NewSummaryVec(name, description, labelNames...) + if err != nil { + return &StopWatchVec{}, err + } + + return &StopWatchVec{ + SummaryVec: s, + outputScale: scale, + }, nil +} + +func (m metricsScope) MustNewStopWatchVec(name, description string, scale time.Duration, labelNames ...string) *StopWatchVec { + s, err := m.NewStopWatchVec(name, description, scale, labelNames...) + panicIfError(err) + return s +} + +func (m metricsScope) NewHistogramStopWatch(name, description string) (HistogramStopWatch, error) { + h, err := m.NewHistogram(name, description) + if err != nil { + return HistogramStopWatch{}, err + } + + return HistogramStopWatch{ + StopWatch: StopWatch{ + Observer: h, + outputScale: time.Second, + }, + }, nil +} + +func (m metricsScope) MustNewHistogramStopWatch(name, description string) HistogramStopWatch { + s, err := m.NewHistogramStopWatch(name, description) + panicIfError(err) + return s +} + +func (m metricsScope) NewHistogramStopWatchVec(name, description string, labelNames ...string) (*HistogramStopWatchVec, error) { + h, err := m.NewHistogramVec(name, description, labelNames...) + if err != nil { + return &HistogramStopWatchVec{}, err + } + + return &HistogramStopWatchVec{ + HistogramVec: h, + outputScale: time.Second, + }, nil +} + +func (m metricsScope) MustNewHistogramStopWatchVec(name, description string, labelNames ...string) *HistogramStopWatchVec { + h, err := m.NewHistogramStopWatchVec(name, description, labelNames...) + panicIfError(err) + return h +} + +func (m metricsScope) CurrentScope() string { + return m.scope +} + +// NewScopedMetricName creates a metric name under the scope. Scope will always have a defaultScopeDelimiterRune as the +// last character +func (m metricsScope) NewScopedMetricName(name string) string { + if name == "" { + panic("metric name cannot be an empty string") + } + + return SanitizeMetricName(m.scope + name) +} + +func (m metricsScope) NewSubScope(subscopeName string) Scope { + if subscopeName == "" { + panic("scope name cannot be an empty string") + } + + // If the last character of the new subscope is already a defaultScopeDelimiterRune, do not add anything + if !strings.HasSuffix(subscopeName, defaultScopeDelimiterStr) { + subscopeName += defaultScopeDelimiterStr + } + + // Always add a new defaultScopeDelimiterRune to every scope name + return NewScope(m.scope + subscopeName) +} + +// NewScope creates a new scope in the format `name + defaultScopeDelimiterRune` +// If the last character is already a defaultScopeDelimiterRune, then it does not add it to the scope name +func NewScope(name string) Scope { + if name == "" { + panic("base scope for a metric cannot be an empty string") + } + + // If the last character of the new subscope is already a defaultScopeDelimiterRune, do not add anything + if !strings.HasSuffix(name, defaultScopeDelimiterStr) { + name += defaultScopeDelimiterStr + } + + return metricsScope{ + scope: SanitizeMetricName(name), + } +} + +// SanitizeMetricName ensures the generates metric name is compatible with the underlying prometheus library. +func SanitizeMetricName(name string) string { + out := strings.Builder{} + for i, b := range name { + if (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || b == '_' || b == ':' || (b >= '0' && b <= '9' && i > 0) { + out.WriteRune(b) + } else if b == '-' { + out.WriteRune('_') + } + } + + return out.String() +} + +// NewTestScope returns a randomly-named scope for use in tests. +// Prometheus requires that metric names begin with a single word, which is generated from the alphabetic testScopeNameCharset. +func NewTestScope() Scope { + return NewScope("test" + rand.String(6)) +} + +// DurationToString converts the duration to a string suffix that indicates the scale of the timer. +func DurationToString(duration time.Duration) string { + if duration >= time.Hour { + return "h" + } + if duration >= time.Minute { + return "m" + } + if duration >= time.Second { + return "s" + } + if duration >= time.Millisecond { + return "ms" + } + if duration >= time.Microsecond { + return "us" + } + return "ns" +} diff --git a/flytestdlib/promutils/scope_test.go b/flytestdlib/promutils/scope_test.go new file mode 100644 index 0000000000..6f5aff61bf --- /dev/null +++ b/flytestdlib/promutils/scope_test.go @@ -0,0 +1,213 @@ +package promutils + +import ( + "testing" + "time" + + "github.com/prometheus/client_golang/prometheus" + "github.com/stretchr/testify/assert" + "k8s.io/apimachinery/pkg/util/rand" +) + +func TestDurationToString(t *testing.T) { + assert.Equal(t, "m", DurationToString(time.Minute)) + assert.Equal(t, "m", DurationToString(time.Minute*10)) + assert.Equal(t, "h", DurationToString(time.Hour)) + assert.Equal(t, "h", DurationToString(time.Hour*10)) + assert.Equal(t, "s", DurationToString(time.Second)) + assert.Equal(t, "s", DurationToString(time.Second*10)) + assert.Equal(t, "us", DurationToString(time.Microsecond*10)) + assert.Equal(t, "us", DurationToString(time.Microsecond)) + assert.Equal(t, "ms", DurationToString(time.Millisecond*10)) + assert.Equal(t, "ms", DurationToString(time.Millisecond)) + assert.Equal(t, "ns", DurationToString(1)) +} + +func ExampleStopWatch_Start() { + scope := NewTestScope() + stopWatch, _ := scope.NewStopWatch("test", "This is a test stop watch", time.Millisecond) + + { + timer := stopWatch.Start() + defer timer.Stop() + + // Do the operation you want to measure + time.Sleep(time.Second) + } +} + +func TestNewScope(t *testing.T) { + assert.Panics(t, func() { + NewScope("") + }) + s := NewScope("test") + assert.Equal(t, "test:", s.CurrentScope()) + assert.Equal(t, "test:hello:", s.NewSubScope("hello").CurrentScope()) + assert.Panics(t, func() { + s.NewSubScope("") + }) + assert.Equal(t, "test:timer_x", s.NewScopedMetricName("timer_x")) + assert.Equal(t, "test:hello:timer:", s.NewSubScope("hello").NewSubScope("timer").CurrentScope()) + assert.Equal(t, "test:hello:timer:", s.NewSubScope("hello").NewSubScope("timer:").CurrentScope()) + assert.Equal(t, "test:k8s_array:test_1:", s.NewSubScope("k8s-array").NewSubScope("test-1:").CurrentScope()) +} + +func TestMetricsScope(t *testing.T) { + s := NewScope("test") + const description = "some x" + if !assert.NotNil(t, prometheus.DefaultRegisterer) { + assert.Fail(t, "Prometheus registrar failed") + } + t.Run("Counter", func(t *testing.T) { + m := s.MustNewCounter("xc", description) + assert.Equal(t, `Desc{fqName: "test:xc", help: "some x", constLabels: {}, variableLabels: {}}`, m.Desc().String()) + mv := s.MustNewCounterVec("xcv", description) + assert.NotNil(t, mv) + assert.Panics(t, func() { + _ = s.MustNewCounter("xc", description) + }) + assert.Panics(t, func() { + _ = s.MustNewCounterVec("xcv", description) + }) + }) + + t.Run("Histogram", func(t *testing.T) { + m := s.MustNewHistogram("xh", description) + assert.Equal(t, `Desc{fqName: "test:xh", help: "some x", constLabels: {}, variableLabels: {}}`, m.Desc().String()) + mv := s.MustNewHistogramVec("xhv", description) + assert.NotNil(t, mv) + assert.Panics(t, func() { + _ = s.MustNewHistogram("xh", description) + }) + assert.Panics(t, func() { + _ = s.MustNewHistogramVec("xhv", description) + }) + buckets := []float64{1.0, 2.0, 3.0, 4.0, 5.0, 6.0} + mvo := s.MustNewHistogramVecWithOptions("xho", description, HistogramOptions{Buckets: buckets}) + assert.NotNil(t, mvo) + assert.Panics(t, func() { + _ = s.MustNewHistogramVecWithOptions("xho", description, HistogramOptions{Buckets: buckets}) + }) + }) + + t.Run("Summary", func(t *testing.T) { + m := s.MustNewSummary("xs", description) + assert.Equal(t, `Desc{fqName: "test:xs", help: "some x", constLabels: {}, variableLabels: {}}`, m.Desc().String()) + mco, err := s.NewSummaryWithOptions("xsco", description, SummaryOptions{Objectives: map[float64]float64{0.5: 0.05, 1.0: 0.0}}) + assert.Nil(t, err) + assert.Equal(t, `Desc{fqName: "test:xsco", help: "some x", constLabels: {}, variableLabels: {}}`, mco.Desc().String()) + mv := s.MustNewSummaryVec("xsv", description) + assert.NotNil(t, mv) + assert.Panics(t, func() { + _ = s.MustNewSummary("xs", description) + }) + assert.Panics(t, func() { + _ = s.MustNewSummaryVec("xsv", description) + }) + }) + + t.Run("Gauge", func(t *testing.T) { + m := s.MustNewGauge("xg", description) + assert.Equal(t, `Desc{fqName: "test:xg", help: "some x", constLabels: {}, variableLabels: {}}`, m.Desc().String()) + mv := s.MustNewGaugeVec("xgv", description) + assert.NotNil(t, mv) + assert.Panics(t, func() { + m = s.MustNewGauge("xg", description) + }) + assert.Panics(t, func() { + _ = s.MustNewGaugeVec("xgv", description) + }) + }) + + t.Run("Timer", func(t *testing.T) { + m := s.MustNewStopWatch("xt", description, time.Second) + asDesc, ok := m.Observer.(prometheus.Metric) + assert.True(t, ok) + assert.Equal(t, `Desc{fqName: "test:xt_s", help: "some x", constLabels: {}, variableLabels: {}}`, asDesc.Desc().String()) + assert.Panics(t, func() { + _ = s.MustNewStopWatch("xt", description, time.Second) + }) + }) + +} + +func TestStopWatch_Start(t *testing.T) { + scope := NewTestScope() + s, e := scope.NewStopWatch("yt"+rand.String(3), "timer", time.Millisecond) + assert.NoError(t, e) + assert.Equal(t, time.Millisecond, s.outputScale) + i := s.Start() + assert.Equal(t, time.Millisecond, i.outputScale) + assert.NotNil(t, i.start) + i.Stop() +} + +func TestStopWatch_Observe(t *testing.T) { + scope := NewTestScope() + s, e := scope.NewStopWatch("yt"+rand.String(3), "timer", time.Millisecond) + assert.NoError(t, e) + assert.Equal(t, time.Millisecond, s.outputScale) + s.Observe(time.Now(), time.Now().Add(time.Second)) +} + +func TestStopWatch_Time(t *testing.T) { + scope := NewTestScope() + s, e := scope.NewStopWatch("yt"+rand.String(3), "timer", time.Millisecond) + assert.NoError(t, e) + assert.Equal(t, time.Millisecond, s.outputScale) + s.Time(func() { + }) +} + +func TestStopWatchVec_WithLabelValues(t *testing.T) { + scope := NewTestScope() + v, e := scope.NewStopWatchVec("yt"+rand.String(3), "timer", time.Millisecond, "workflow", "label") + assert.NoError(t, e) + assert.Equal(t, time.Millisecond, v.outputScale) + s := v.WithLabelValues("my_wf", "something") + assert.NotNil(t, s) + i := s.Start() + assert.Equal(t, time.Millisecond, i.outputScale) + assert.NotNil(t, i.start) + i.Stop() +} + +func TestHistogramStopWatch_Start(t *testing.T) { + scope := NewTestScope() + stopwatch, err := scope.NewHistogramStopWatch("yt"+rand.String(3), "timer") + assert.NoError(t, err) + assert.Equal(t, time.Second, stopwatch.outputScale) + timer := stopwatch.Start() + assert.Equal(t, time.Second, timer.outputScale) + assert.NotNil(t, timer.start) +} + +func TestHistogramStopWatch_Observe(t *testing.T) { + scope := NewTestScope() + stopwatch, err := scope.NewHistogramStopWatch("yt"+rand.String(3), "timer") + assert.NoError(t, err) + assert.Equal(t, time.Second, stopwatch.outputScale) + stopwatch.Observe(time.Now(), time.Now().Add(time.Second)) +} + +func TestHistogramStopWatch_Time(t *testing.T) { + scope := NewTestScope() + stopwatch, err := scope.NewHistogramStopWatch("yt"+rand.String(3), "timer") + assert.NoError(t, err) + assert.Equal(t, time.Second, stopwatch.outputScale) + stopwatch.Time(func() { + }) +} + +func TestHistogramStopWatchVec_WithLabelValues(t *testing.T) { + scope := NewTestScope() + vec, err := scope.NewHistogramStopWatchVec("yt"+rand.String(3), "timer", "workflow", "label") + assert.NoError(t, err) + assert.Equal(t, time.Second, vec.outputScale) + stopwatch := vec.WithLabelValues("my_wf", "something") + assert.NotNil(t, stopwatch) + i := stopwatch.Start() + assert.Equal(t, time.Second, i.outputScale) + assert.NotNil(t, i.start) + i.Stop() +} diff --git a/flytestdlib/promutils/workqueue.go b/flytestdlib/promutils/workqueue.go new file mode 100644 index 0000000000..509f7b5629 --- /dev/null +++ b/flytestdlib/promutils/workqueue.go @@ -0,0 +1,113 @@ +// Source: https://raw.githubusercontent.com/kubernetes/kubernetes/3dbbd0bdf44cb07fdde85aa392adf99ea7e95939/pkg/util/workqueue/prometheus/prometheus.go +/* +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 promutils + +import ( + "github.com/prometheus/client_golang/prometheus" + "k8s.io/client-go/util/workqueue" +) + +// Package prometheus sets the workqueue DefaultMetricsFactory to produce +// prometheus metrics. To use this package, you just have to import it. + +func init() { + provider := prometheusMetricsProvider{} + workqueue.SetProvider(provider) +} + +type prometheusMetricsProvider struct{} + +func (prometheusMetricsProvider) NewLongestRunningProcessorSecondsMetric(name string) workqueue.SettableGaugeMetric { + unfinishedWork := prometheus.NewGauge(prometheus.GaugeOpts{ + Subsystem: name, + Name: "longest_running_processor_s", + Help: "How many microseconds longest running processor from workqueue" + name + " takes.", + }) + + prometheus.MustRegister(unfinishedWork) + return unfinishedWork +} + +func (prometheusMetricsProvider) NewUnfinishedWorkSecondsMetric(name string) workqueue.SettableGaugeMetric { + unfinishedWork := prometheus.NewGauge(prometheus.GaugeOpts{ + Subsystem: name, + Name: "unfinished_work_s", + Help: "How many seconds of work in progress in workqueue: " + name, + }) + prometheus.MustRegister(unfinishedWork) + return unfinishedWork +} + +func (prometheusMetricsProvider) NewLongestRunningProcessorMicrosecondsMetric(name string) workqueue.SettableGaugeMetric { + unfinishedWork := prometheus.NewGauge(prometheus.GaugeOpts{ + Subsystem: name, + Name: "longest_running_processor_us", + Help: "How many microseconds longest running processor from workqueue" + name + " takes.", + }) + prometheus.MustRegister(unfinishedWork) + return unfinishedWork +} + +func (prometheusMetricsProvider) NewDepthMetric(name string) workqueue.GaugeMetric { + depth := prometheus.NewGauge(prometheus.GaugeOpts{ + Subsystem: name, + Name: "depth", + Help: "Current depth of workqueue: " + name, + }) + prometheus.MustRegister(depth) + return depth +} + +func (prometheusMetricsProvider) NewAddsMetric(name string) workqueue.CounterMetric { + adds := prometheus.NewCounter(prometheus.CounterOpts{ + Subsystem: name, + Name: "adds", + Help: "Total number of adds handled by workqueue: " + name, + }) + prometheus.MustRegister(adds) + return adds +} + +func (prometheusMetricsProvider) NewLatencyMetric(name string) workqueue.HistogramMetric { + latency := prometheus.NewHistogram(prometheus.HistogramOpts{ + Subsystem: name, + Name: "queue_latency_us", + Help: "How long an item stays in workqueue" + name + " before being requested.", + }) + prometheus.MustRegister(latency) + return latency +} + +func (prometheusMetricsProvider) NewWorkDurationMetric(name string) workqueue.HistogramMetric { + workDuration := prometheus.NewHistogram(prometheus.HistogramOpts{ + Subsystem: name, + Name: "work_duration_us", + Help: "How long processing an item from workqueue" + name + " takes.", + }) + prometheus.MustRegister(workDuration) + return workDuration +} + +func (prometheusMetricsProvider) NewRetriesMetric(name string) workqueue.CounterMetric { + retries := prometheus.NewCounter(prometheus.CounterOpts{ + Subsystem: name, + Name: "retries", + Help: "Total number of retries handled by workqueue: " + name, + }) + prometheus.MustRegister(retries) + return retries +} diff --git a/flytestdlib/promutils/workqueue_test.go b/flytestdlib/promutils/workqueue_test.go new file mode 100644 index 0000000000..bacf7a2fa8 --- /dev/null +++ b/flytestdlib/promutils/workqueue_test.go @@ -0,0 +1,60 @@ +package promutils + +import ( + "testing" + + "github.com/prometheus/client_golang/prometheus" + "github.com/stretchr/testify/assert" +) + +var provider = prometheusMetricsProvider{} + +func TestPrometheusMetricsProvider(t *testing.T) { + t.Run("Adds", func(t *testing.T) { + c := provider.NewAddsMetric("x") + _, ok := c.(prometheus.Counter) + assert.True(t, ok) + }) + + t.Run("Depth", func(t *testing.T) { + c := provider.NewDepthMetric("x") + _, ok := c.(prometheus.Gauge) + assert.True(t, ok) + }) + + t.Run("Latency", func(t *testing.T) { + c := provider.NewLatencyMetric("x") + _, ok := c.(prometheus.Summary) + assert.True(t, ok) + }) + + t.Run("Retries", func(t *testing.T) { + c := provider.NewRetriesMetric("x") + _, ok := c.(prometheus.Counter) + assert.True(t, ok) + }) + + t.Run("WorkDuration", func(t *testing.T) { + c := provider.NewWorkDurationMetric("x") + _, ok := c.(prometheus.Summary) + assert.True(t, ok) + }) + + t.Run("NewLongestRunningProcessorSecondsMetric", func(t *testing.T) { + c := provider.NewLongestRunningProcessorSecondsMetric("x") + _, ok := c.(prometheus.Gauge) + assert.True(t, ok) + }) + + t.Run("NewUnfinishedWorkSecondsMetric", func(t *testing.T) { + c := provider.NewUnfinishedWorkSecondsMetric("x") + _, ok := c.(prometheus.Gauge) + assert.True(t, ok) + }) + + t.Run("NewLongestRunningProcessorMicrosecondsMetric", func(t *testing.T) { + c := provider.NewLongestRunningProcessorMicrosecondsMetric("x") + _, ok := c.(prometheus.Gauge) + assert.True(t, ok) + }) +} diff --git a/flytestdlib/random/mocks/comparable.go b/flytestdlib/random/mocks/comparable.go new file mode 100644 index 0000000000..b1d1b43546 --- /dev/null +++ b/flytestdlib/random/mocks/comparable.go @@ -0,0 +1,81 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + random "github.com/flyteorg/flyte/v2/flytestdlib/random" + mock "github.com/stretchr/testify/mock" +) + +// Comparable is an autogenerated mock type for the Comparable type +type Comparable struct { + mock.Mock +} + +type Comparable_Expecter struct { + mock *mock.Mock +} + +func (_m *Comparable) EXPECT() *Comparable_Expecter { + return &Comparable_Expecter{mock: &_m.Mock} +} + +// Compare provides a mock function with given fields: to +func (_m *Comparable) Compare(to random.Comparable) bool { + ret := _m.Called(to) + + if len(ret) == 0 { + panic("no return value specified for Compare") + } + + var r0 bool + if rf, ok := ret.Get(0).(func(random.Comparable) bool); ok { + r0 = rf(to) + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// Comparable_Compare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Compare' +type Comparable_Compare_Call struct { + *mock.Call +} + +// Compare is a helper method to define mock.On call +// - to random.Comparable +func (_e *Comparable_Expecter) Compare(to interface{}) *Comparable_Compare_Call { + return &Comparable_Compare_Call{Call: _e.mock.On("Compare", to)} +} + +func (_c *Comparable_Compare_Call) Run(run func(to random.Comparable)) *Comparable_Compare_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(random.Comparable)) + }) + return _c +} + +func (_c *Comparable_Compare_Call) Return(_a0 bool) *Comparable_Compare_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Comparable_Compare_Call) RunAndReturn(run func(random.Comparable) bool) *Comparable_Compare_Call { + _c.Call.Return(run) + return _c +} + +// NewComparable creates a new instance of Comparable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewComparable(t interface { + mock.TestingT + Cleanup(func()) +}) *Comparable { + mock := &Comparable{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/random/mocks/weighted_random_list.go b/flytestdlib/random/mocks/weighted_random_list.go new file mode 100644 index 0000000000..89e8e3433d --- /dev/null +++ b/flytestdlib/random/mocks/weighted_random_list.go @@ -0,0 +1,235 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + rand "math/rand" + + mock "github.com/stretchr/testify/mock" + + random "github.com/flyteorg/flyte/v2/flytestdlib/random" +) + +// WeightedRandomList is an autogenerated mock type for the WeightedRandomList type +type WeightedRandomList struct { + mock.Mock +} + +type WeightedRandomList_Expecter struct { + mock *mock.Mock +} + +func (_m *WeightedRandomList) EXPECT() *WeightedRandomList_Expecter { + return &WeightedRandomList_Expecter{mock: &_m.Mock} +} + +// Get provides a mock function with no fields +func (_m *WeightedRandomList) Get() random.Comparable { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 random.Comparable + if rf, ok := ret.Get(0).(func() random.Comparable); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(random.Comparable) + } + } + + return r0 +} + +// WeightedRandomList_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type WeightedRandomList_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +func (_e *WeightedRandomList_Expecter) Get() *WeightedRandomList_Get_Call { + return &WeightedRandomList_Get_Call{Call: _e.mock.On("Get")} +} + +func (_c *WeightedRandomList_Get_Call) Run(run func()) *WeightedRandomList_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *WeightedRandomList_Get_Call) Return(_a0 random.Comparable) *WeightedRandomList_Get_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *WeightedRandomList_Get_Call) RunAndReturn(run func() random.Comparable) *WeightedRandomList_Get_Call { + _c.Call.Return(run) + return _c +} + +// GetWithSeed provides a mock function with given fields: seed +func (_m *WeightedRandomList) GetWithSeed(seed rand.Source) (random.Comparable, error) { + ret := _m.Called(seed) + + if len(ret) == 0 { + panic("no return value specified for GetWithSeed") + } + + var r0 random.Comparable + var r1 error + if rf, ok := ret.Get(0).(func(rand.Source) (random.Comparable, error)); ok { + return rf(seed) + } + if rf, ok := ret.Get(0).(func(rand.Source) random.Comparable); ok { + r0 = rf(seed) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(random.Comparable) + } + } + + if rf, ok := ret.Get(1).(func(rand.Source) error); ok { + r1 = rf(seed) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// WeightedRandomList_GetWithSeed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWithSeed' +type WeightedRandomList_GetWithSeed_Call struct { + *mock.Call +} + +// GetWithSeed is a helper method to define mock.On call +// - seed rand.Source +func (_e *WeightedRandomList_Expecter) GetWithSeed(seed interface{}) *WeightedRandomList_GetWithSeed_Call { + return &WeightedRandomList_GetWithSeed_Call{Call: _e.mock.On("GetWithSeed", seed)} +} + +func (_c *WeightedRandomList_GetWithSeed_Call) Run(run func(seed rand.Source)) *WeightedRandomList_GetWithSeed_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(rand.Source)) + }) + return _c +} + +func (_c *WeightedRandomList_GetWithSeed_Call) Return(_a0 random.Comparable, _a1 error) *WeightedRandomList_GetWithSeed_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *WeightedRandomList_GetWithSeed_Call) RunAndReturn(run func(rand.Source) (random.Comparable, error)) *WeightedRandomList_GetWithSeed_Call { + _c.Call.Return(run) + return _c +} + +// Len provides a mock function with no fields +func (_m *WeightedRandomList) Len() int { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Len") + } + + var r0 int + if rf, ok := ret.Get(0).(func() int); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int) + } + + return r0 +} + +// WeightedRandomList_Len_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Len' +type WeightedRandomList_Len_Call struct { + *mock.Call +} + +// Len is a helper method to define mock.On call +func (_e *WeightedRandomList_Expecter) Len() *WeightedRandomList_Len_Call { + return &WeightedRandomList_Len_Call{Call: _e.mock.On("Len")} +} + +func (_c *WeightedRandomList_Len_Call) Run(run func()) *WeightedRandomList_Len_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *WeightedRandomList_Len_Call) Return(_a0 int) *WeightedRandomList_Len_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *WeightedRandomList_Len_Call) RunAndReturn(run func() int) *WeightedRandomList_Len_Call { + _c.Call.Return(run) + return _c +} + +// List provides a mock function with no fields +func (_m *WeightedRandomList) List() []random.Comparable { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for List") + } + + var r0 []random.Comparable + if rf, ok := ret.Get(0).(func() []random.Comparable); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]random.Comparable) + } + } + + return r0 +} + +// WeightedRandomList_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List' +type WeightedRandomList_List_Call struct { + *mock.Call +} + +// List is a helper method to define mock.On call +func (_e *WeightedRandomList_Expecter) List() *WeightedRandomList_List_Call { + return &WeightedRandomList_List_Call{Call: _e.mock.On("List")} +} + +func (_c *WeightedRandomList_List_Call) Run(run func()) *WeightedRandomList_List_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *WeightedRandomList_List_Call) Return(_a0 []random.Comparable) *WeightedRandomList_List_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *WeightedRandomList_List_Call) RunAndReturn(run func() []random.Comparable) *WeightedRandomList_List_Call { + _c.Call.Return(run) + return _c +} + +// NewWeightedRandomList creates a new instance of WeightedRandomList. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewWeightedRandomList(t interface { + mock.TestingT + Cleanup(func()) +}) *WeightedRandomList { + mock := &WeightedRandomList{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/random/weighted_random_list.go b/flytestdlib/random/weighted_random_list.go new file mode 100644 index 0000000000..176e894fa2 --- /dev/null +++ b/flytestdlib/random/weighted_random_list.go @@ -0,0 +1,139 @@ +package random + +import ( + "context" + "fmt" + "math/rand" + "sort" + "time" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + + +// Interface to use the Weighted Random +type WeightedRandomList interface { + Get() Comparable + GetWithSeed(seed rand.Source) (Comparable, error) + List() []Comparable + Len() int +} + +// Interface for items that can be used along with WeightedRandomList +type Comparable interface { + Compare(to Comparable) bool +} + +// Structure of each entry to select from +type Entry struct { + Item Comparable + Weight float32 +} + +type internalEntry struct { + entry Entry + currentTotal float32 +} + +// WeightedRandomList selects elements randomly from the list taking into account individual weights. +// Weight has to be assigned between 0 and 1. +// Support deterministic results when given a particular seed source +type weightedRandomListImpl struct { + entries []internalEntry + totalWeight float32 +} + +func validateEntries(entries []Entry) error { + if len(entries) == 0 { + return fmt.Errorf("entries is empty") + } + for index, entry := range entries { + if entry.Item == nil { + return fmt.Errorf("invalid entry: nil, index %d", index) + } + if entry.Weight < 0 || entry.Weight > float32(1) { + return fmt.Errorf("invalid weight %f, index %d", entry.Weight, index) + } + } + return nil +} + +// Given a list of entries with weights, returns WeightedRandomList +func NewWeightedRandom(ctx context.Context, entries []Entry) (WeightedRandomList, error) { + err := validateEntries(entries) + if err != nil { + return nil, err + } + + sort.Slice(entries, func(i, j int) bool { + return entries[i].Item.Compare(entries[j].Item) + }) + var internalEntries []internalEntry + numberOfEntries := len(entries) + totalWeight := float32(0) + for _, e := range entries { + totalWeight += e.Weight + } + + currentTotal := float32(0) + for _, e := range entries { + if totalWeight == 0 { + // This indicates that none of the entries have weight assigned. + // We will assign equal weights to everyone + currentTotal += 1.0 / float32(numberOfEntries) + } else if e.Weight == 0 { + // Entries which have zero weight are ignored + logger.Debugf(ctx, "ignoring entry due to empty weight %v", e) + continue + } + + currentTotal += e.Weight + internalEntries = append(internalEntries, internalEntry{ + entry: e, + currentTotal: currentTotal, + }) + } + + return &weightedRandomListImpl{ + entries: internalEntries, + totalWeight: currentTotal, + }, nil +} + +func (w *weightedRandomListImpl) get(generator *rand.Rand) Comparable { + randomWeight := generator.Float32() * w.totalWeight + for _, e := range w.entries { + if e.currentTotal >= randomWeight && e.currentTotal > 0 { + return e.entry.Item + } + } + return w.entries[len(w.entries)-1].entry.Item +} + +// Returns a random entry based on the weights +func (w *weightedRandomListImpl) Get() Comparable { + /* #nosec */ + randGenerator := rand.New(rand.NewSource(time.Now().UTC().UnixNano())) + return w.get(randGenerator) +} + +// For a given seed, the same entry will be returned all the time. +func (w *weightedRandomListImpl) GetWithSeed(seed rand.Source) (Comparable, error) { + /* #nosec */ + randGenerator := rand.New(seed) + return w.get(randGenerator), nil +} + +// Lists all the entries that are eligible for selection +func (w *weightedRandomListImpl) List() []Comparable { + entries := make([]Comparable, len(w.entries)) + for index, indexedItem := range w.entries { + entries[index] = indexedItem.entry.Item + } + return entries +} + +// Gets the number of items that are being considered for selection. +func (w *weightedRandomListImpl) Len() int { + return len(w.entries) +} diff --git a/flytestdlib/random/weighted_random_list_test.go b/flytestdlib/random/weighted_random_list_test.go new file mode 100644 index 0000000000..dd47ff4258 --- /dev/null +++ b/flytestdlib/random/weighted_random_list_test.go @@ -0,0 +1,253 @@ +package random + +import ( + "context" + "math/rand" + "strings" + "testing" + + "github.com/stretchr/testify/assert" +) + +type testData struct { + key string + val int +} + +func (t testData) Compare(to Comparable) bool { + if strings.Contains(t.key, "sort") { + return t.key < to.(testData).key + } + return t.val < to.(testData).val +} + +func TestDeterministicWeightedRandomStr(t *testing.T) { + item1 := testData{ + key: "sort_key1", + val: 1, + } + item2 := testData{ + key: "sort_key2", + val: 2, + } + entries := []Entry{ + { + Item: item1, + Weight: 0.4, + }, + { + Item: item2, + Weight: 0.6, + }, + } + randWeight, err := NewWeightedRandom(context.Background(), entries) + assert.Nil(t, err) + retItem, err := randWeight.GetWithSeed(rand.NewSource(20)) + assert.Nil(t, err) + assert.Equal(t, item1, retItem) + + assert.Nil(t, err) + for i := 1; i <= 10; i++ { + retItem, err := randWeight.GetWithSeed(rand.NewSource(10)) + assert.Nil(t, err) + assert.Equal(t, item2, retItem) + } +} + +func TestDeterministicWeightedRandomInt(t *testing.T) { + item1 := testData{ + key: "key1", + val: 4, + } + item2 := testData{ + key: "key2", + val: 3, + } + entries := []Entry{ + { + Item: item1, + Weight: 0.4, + }, + { + Item: item2, + Weight: 0.6, + }, + } + randWeight, err := NewWeightedRandom(context.Background(), entries) + assert.Nil(t, err) + rand.NewSource(10) + retItem, err := randWeight.GetWithSeed(rand.NewSource(20)) + assert.Nil(t, err) + assert.Equal(t, item2, retItem) + + for i := 1; i <= 10; i++ { + retItem, err := randWeight.GetWithSeed(rand.NewSource(1)) + assert.Nil(t, err) + assert.Equal(t, item1, retItem) + } +} + +func TestDeterministicWeightedFewZeroWeight(t *testing.T) { + item1 := testData{ + key: "key1", + val: 4, + } + item2 := testData{ + key: "key2", + val: 3, + } + entries := []Entry{ + { + Item: item1, + Weight: 0.4, + }, + { + Item: item2, + }, + } + randWeight, err := NewWeightedRandom(context.Background(), entries) + assert.Nil(t, err) + retItem, err := randWeight.GetWithSeed(rand.NewSource(20)) + assert.Nil(t, err) + assert.Equal(t, item1, retItem) + + for i := 1; i <= 10; i++ { + retItem, err := randWeight.GetWithSeed(rand.NewSource(10)) + assert.Nil(t, err) + assert.Equal(t, item1, retItem) + } +} + +func TestDeterministicWeightedAllZeroWeights(t *testing.T) { + item1 := testData{ + key: "sort_key1", + val: 4, + } + item2 := testData{ + key: "sort_key2", + val: 3, + } + entries := []Entry{ + { + Item: item1, + }, + { + Item: item2, + }, + } + randWeight, err := NewWeightedRandom(context.Background(), entries) + assert.Nil(t, err) + retItem, err := randWeight.GetWithSeed(rand.NewSource(10)) + assert.Nil(t, err) + assert.Equal(t, item2, retItem) + + for i := 1; i <= 10; i++ { + retItem, err := randWeight.GetWithSeed(rand.NewSource(20)) + assert.Nil(t, err) + assert.Equal(t, item1, retItem) + } +} + +func TestDeterministicWeightList(t *testing.T) { + item1 := testData{ + key: "key1", + val: 4, + } + item2 := testData{ + key: "key2", + val: 3, + } + entries := []Entry{ + { + Item: item1, + Weight: 0.3, + }, + { + Item: item2, + }, + } + randWeight, err := NewWeightedRandom(context.Background(), entries) + assert.Nil(t, err) + assert.EqualValues(t, []Comparable{item1}, randWeight.List()) +} + +func TestDeterministicWeightListZeroWeights(t *testing.T) { + item1 := testData{ + key: "key1", + val: 4, + } + item2 := testData{ + key: "key2", + val: 3, + } + entries := []Entry{ + { + Item: item1, + }, + { + Item: item2, + }, + } + randWeight, err := NewWeightedRandom(context.Background(), entries) + assert.Nil(t, err) + assert.EqualValues(t, []Comparable{item2, item1}, randWeight.List()) +} + +func TestDeterministicWeightLen(t *testing.T) { + item1 := testData{ + key: "key1", + } + item2 := testData{ + key: "key2", + } + entries := []Entry{ + { + Item: item1, + }, + { + Item: item2, + }, + } + randWeight, err := NewWeightedRandom(context.Background(), entries) + assert.Nil(t, err) + assert.EqualValues(t, 2, randWeight.Len()) +} + +func TestDeterministicWeightInvalidWeights(t *testing.T) { + item1 := testData{ + key: "key1", + val: 4, + } + item2 := testData{ + key: "key2", + val: 3, + } + entries := []Entry{ + { + Item: item1, + Weight: -3.0, + }, + { + Item: item2, + }, + } + _, err := NewWeightedRandom(context.Background(), entries) + assert.NotNil(t, err) + assert.EqualError(t, err, "invalid weight -3.000000, index 0") +} + +func TestDeterministicWeightInvalidList(t *testing.T) { + item2 := testData{ + key: "key2", + val: 3, + } + entries := []Entry{ + {}, + { + Item: item2, + }, + } + _, err := NewWeightedRandom(context.Background(), entries) + assert.NotNil(t, err) + assert.EqualError(t, err, "invalid entry: nil, index 0") +} diff --git a/flytestdlib/resolver/k8s_resolver.go b/flytestdlib/resolver/k8s_resolver.go new file mode 100644 index 0000000000..c3ccf0f443 --- /dev/null +++ b/flytestdlib/resolver/k8s_resolver.go @@ -0,0 +1,193 @@ +package resolver + +import ( + "context" + "fmt" + "net" + "strings" + "sync" + + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/resolver" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/util/wait" + "k8s.io/client-go/kubernetes" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +const ( + Schema = "k8s" +) + +type targetInfo struct { + serviceName string + serviceNamespace string + port string +} + +func (t targetInfo) String() string { + return fmt.Sprintf("%s:///%s.%s:%s", Schema, t.serviceNamespace, t.serviceName, t.port) +} + +// NewBuilder creates a kubeBuilder which is used by grpc resolver. +func NewBuilder(ctx context.Context, client kubernetes.Interface, schema string) resolver.Builder { + return &kubeBuilder{ + ctx: ctx, + k8sClient: client, + schema: schema, + } +} + +type kubeBuilder struct { + ctx context.Context + k8sClient kubernetes.Interface + schema string +} + +func splitServicePortNamespace(hpn string) (service, port, namespace string) { + service = hpn + + colon := strings.LastIndexByte(service, ':') + if colon != -1 { + service, port = service[:colon], service[colon+1:] + } + + parts := strings.SplitN(service, ".", 3) + if len(parts) >= 2 { + service, namespace = parts[0], parts[1] + } + + return +} + +func parseResolverTarget(target resolver.Target) (targetInfo, error) { + var service, port, namespace string + if target.URL.Host == "" { + // k8s:///service.namespace:port + service, port, namespace = splitServicePortNamespace(target.Endpoint()) + } else if target.URL.Port() == "" && target.Endpoint() != "" { + // k8s://namespace/service:port + service, port, _ = splitServicePortNamespace(target.Endpoint()) + namespace = target.URL.Hostname() + } else { + // k8s://service.namespace:port + service, port, namespace = splitServicePortNamespace(target.URL.Host) + } + + if service == "" { + return targetInfo{}, fmt.Errorf("target %s must specify a service", &target.URL) + } + + return targetInfo{ + serviceName: service, + serviceNamespace: namespace, + port: port, + }, nil +} + +// Build creates a new resolver for the given target, e.g. k8s:///flyteagent:flyte:8000. +func (b *kubeBuilder) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOptions) (resolver.Resolver, error) { + ti, err := parseResolverTarget(target) + if err != nil { + return nil, err + } + + ctx, cancel := context.WithCancel(b.ctx) + r := &kResolver{ + target: ti, + ctx: ctx, + cancel: cancel, + cc: cc, + k8sClient: b.k8sClient, + } + go wait.Until(r.run, 0, ctx.Done()) + return r, nil +} + +// Scheme returns the scheme supported by this resolver. +// Scheme is defined at https://github.com/grpc/grpc/blob/master/doc/naming.md. +func (b *kubeBuilder) Scheme() string { + return b.schema +} + +type kResolver struct { + target targetInfo + ctx context.Context + cancel context.CancelFunc + cc resolver.ClientConn + k8sClient kubernetes.Interface + // wg is used to enforce Close() to return after the watcher() goroutine has finished. + wg sync.WaitGroup +} + +// ResolveNow is a no-op at this point. +func (k *kResolver) ResolveNow(resolver.ResolveNowOptions) {} + +// Close closes the resolver. +func (k *kResolver) Close() { + k.cancel() + k.wg.Wait() + logger.Infof(k.ctx, "k8s resolver: closed") +} + +func (k *kResolver) resolve(e *v1.Endpoints) { + var newAddrs []resolver.Address + for _, subset := range e.Subsets { + port := k.target.port + + for _, address := range subset.Addresses { + newAddrs = append(newAddrs, resolver.Address{ + Addr: net.JoinHostPort(address.IP, port), + ServerName: fmt.Sprintf("%s.%s", k.target.serviceName, k.target.serviceNamespace), + Metadata: nil, + }) + } + } + err := k.cc.UpdateState(resolver.State{Addresses: newAddrs}) + if err != nil { + grpclog.Errorf("k8s resolver: failed : %v", err) + } +} + +func (k *kResolver) run() { + k.wg.Add(1) + defer k.wg.Done() + + logger.Infof(k.ctx, "Starting k8s resolver for target: [%s], service namespace: [%s], service name: [%s]", k.target, k.target.serviceNamespace, k.target.serviceName) + + watcher, err := k.k8sClient.CoreV1().Endpoints(k.target.serviceNamespace).Watch(k.ctx, metav1.ListOptions{FieldSelector: "metadata.name=" + k.target.serviceName}) + if err != nil { + logger.Errorf( + k.ctx, + "k8s resolver: failed to create watcher for target [%s]: service namespace: [%s], service name: [%s], "+"error [%v]", + k.target, k.target.serviceNamespace, k.target.serviceName, err, + ) + if statusErr, ok := err.(*errors.StatusError); ok { + logger.Errorf(k.ctx, "k8s resolver: status error details: %v", statusErr.ErrStatus) + } + + logger.Infof(k.ctx, "k8s resolver: failed to create watcher: [%v]", err) + grpclog.Errorf("k8s resolver: failed to create watcher: %v", err) + return + } + + for { + select { + case <-k.ctx.Done(): + return + case event, ok := <-watcher.ResultChan(): + logger.Info(k.ctx, "k8s resolver watcher event response: [%v]", event) + if !ok { + logger.Debugf(k.ctx, "k8s resolver: watcher closed") + return + } + if event.Object == nil { + continue + } + k.resolve(event.Object.(*v1.Endpoints)) + } + } +} diff --git a/flytestdlib/resolver/k8s_resolver_test.go b/flytestdlib/resolver/k8s_resolver_test.go new file mode 100644 index 0000000000..18aa22c80a --- /dev/null +++ b/flytestdlib/resolver/k8s_resolver_test.go @@ -0,0 +1,177 @@ +package resolver + +import ( + "context" + "fmt" + "log" + "net/url" + "testing" + "time" + + "google.golang.org/grpc/resolver" + "google.golang.org/grpc/serviceconfig" + "gotest.tools/assert" + v1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + testclient "k8s.io/client-go/kubernetes/fake" +) + +func parseTarget(target string) resolver.Target { + u, err := url.Parse(target) + if err != nil { + panic(err) + } + + return resolver.Target{ + URL: *u, + } +} + +type fakeConn struct { + cmp chan struct{} + found []string +} + +func (fc *fakeConn) UpdateState(state resolver.State) error { + for _, a := range state.Addresses { + fc.found = append(fc.found, a.Addr) + } + fc.cmp <- struct{}{} + return nil +} + +func (fc *fakeConn) ReportError(e error) { + log.Println(e) +} + +func (fc *fakeConn) ParseServiceConfig(_ string) *serviceconfig.ParseResult { + return nil +} + +func (fc *fakeConn) NewAddress(_ []resolver.Address) {} + +func (*fakeConn) NewServiceConfig(serviceConfig string) { + fmt.Printf("serviceConfig: %s\n", serviceConfig) +} + +func TestBuilder(t *testing.T) { + k8sClient := testclient.NewSimpleClientset() + builder := NewBuilder(context.Background(), k8sClient, "test") + fc := &fakeConn{ + cmp: make(chan struct{}), + } + k8sResolver, err := builder.Build(parseTarget("test://flyteagent.flyte.svc.cluster.local:8000"), fc, resolver.BuildOptions{}) + if err != nil { + t.Fatal(err) + } + + // Make sure watcher is started before we create the endpoint + time.Sleep(2 * time.Second) + + _, err = k8sClient.CoreV1().Endpoints("flyte").Create(context.Background(), &v1.Endpoints{ + ObjectMeta: metav1.ObjectMeta{ + Name: "flyteagent", + Namespace: "flyte", + }, + Subsets: []v1.EndpointSubset{ + { + Addresses: []v1.EndpointAddress{ + { + IP: "10.0.0.1", + }, + }, + Ports: []v1.EndpointPort{ + { + Name: "grpc", + Port: 8000, + }, + }, + }, + }, + }, metav1.CreateOptions{}) + + <-fc.cmp + assert.NilError(t, err) + assert.Equal(t, len(fc.found), 1) + assert.Equal(t, fc.found[0], "10.0.0.1:8000") + + k8sResolver.Close() +} + +func TestParseResolverTargets(t *testing.T) { + for i, test := range []struct { + target string + want targetInfo + err bool + }{ + {"", targetInfo{}, true}, + {"k8s:///", targetInfo{}, true}, + {"k8s://a:30", targetInfo{"a", "", "30"}, false}, + {"k8s://a/", targetInfo{"a", "", ""}, false}, + {"k8s:///a", targetInfo{"a", "", ""}, false}, + {"k8s://a/b", targetInfo{"b", "a", ""}, false}, + {"k8s://a.b/", targetInfo{"a", "b", ""}, false}, + {"k8s:///a.b:80", targetInfo{"a", "b", "80"}, false}, + {"k8s:///a.b:port", targetInfo{"a", "b", "port"}, false}, + {"k8s:///a:port", targetInfo{"a", "", "port"}, false}, + {"k8s://x/a:port", targetInfo{"a", "x", "port"}, false}, + {"k8s://a.x:30/", targetInfo{"a", "x", "30"}, false}, + {"k8s://a.b.svc.cluster.local", targetInfo{"a", "b", ""}, false}, + {"k8s://a.b.svc.cluster.local:80", targetInfo{"a", "b", "80"}, false}, + {"k8s:///a.b.svc.cluster.local", targetInfo{"a", "b", ""}, false}, + {"k8s:///a.b.svc.cluster.local:80", targetInfo{"a", "b", "80"}, false}, + {"k8s:///a.b.svc.cluster.local:port", targetInfo{"a", "b", "port"}, false}, + } { + got, err := parseResolverTarget(parseTarget(test.target)) + if err == nil && test.err { + t.Errorf("case %d: want error but got nil", i) + continue + } + if err != nil && !test.err { + t.Errorf("case %d:got '%v' error but don't want an error", i, err) + continue + } + if got != test.want { + t.Errorf("case %d: parseTarget(%q) = %+v, want %+v", i, test.target, got, test.want) + } + } +} + +func TestParseTargets(t *testing.T) { + for i, test := range []struct { + target string + want targetInfo + err bool + }{ + {"", targetInfo{}, true}, + {"k8s:///", targetInfo{}, true}, + {"k8s://a:30", targetInfo{"a", "", "30"}, false}, + {"k8s://a/", targetInfo{"a", "", ""}, false}, + {"k8s:///a", targetInfo{"a", "", ""}, false}, + {"k8s://a/b", targetInfo{"b", "a", ""}, false}, + {"k8s://a.b/", targetInfo{"a", "b", ""}, false}, + {"k8s:///a.b:80", targetInfo{"a", "b", "80"}, false}, + {"k8s:///a.b:port", targetInfo{"a", "b", "port"}, false}, + {"k8s:///a:port", targetInfo{"a", "", "port"}, false}, + {"k8s://x/a:port", targetInfo{"a", "x", "port"}, false}, + {"k8s://a.x:30/", targetInfo{"a", "x", "30"}, false}, + {"k8s://a.b.svc.cluster.local", targetInfo{"a", "b", ""}, false}, + {"k8s://a.b.svc.cluster.local:80", targetInfo{"a", "b", "80"}, false}, + {"k8s:///a.b.svc.cluster.local", targetInfo{"a", "b", ""}, false}, + {"k8s:///a.b.svc.cluster.local:80", targetInfo{"a", "b", "80"}, false}, + {"k8s:///a.b.svc.cluster.local:port", targetInfo{"a", "b", "port"}, false}, + } { + got, err := parseResolverTarget(parseTarget(test.target)) + if err == nil && test.err { + t.Errorf("case %d: want error but got nil", i) + continue + } + if err != nil && !test.err { + t.Errorf("case %d:got '%v' error but don't want an error", i, err) + continue + } + if got != test.want { + t.Errorf("case %d: parseTarget(%q) = %+v, want %+v", i, test.target, got, test.want) + } + } +} diff --git a/flytestdlib/sandboxutils/processor.go b/flytestdlib/sandboxutils/processor.go new file mode 100644 index 0000000000..433e03fbe3 --- /dev/null +++ b/flytestdlib/sandboxutils/processor.go @@ -0,0 +1,71 @@ +package sandboxutils + +import ( + "context" + "fmt" + "sync" + "time" + + "github.com/golang/protobuf/proto" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +var MsgChan chan SandboxMessage +var once sync.Once + +func init() { + once.Do(func() { + MsgChan = make(chan SandboxMessage, 1000) + }) +} + +type SandboxMessage struct { + Msg proto.Message + Raw []byte + Topic string +} + +type CloudEventsSandboxOnlyPublisher struct { + subChan chan<- SandboxMessage +} + +func (z *CloudEventsSandboxOnlyPublisher) Publish(ctx context.Context, topic string, msg proto.Message) error { + logger.Debugf(ctx, "Sandbox cloud event publisher, sending to topic [%s]", topic) + sm := SandboxMessage{ + Msg: msg, + Topic: topic, + } + select { + case z.subChan <- sm: + return nil + case <-ctx.Done(): + return ctx.Err() + } +} + +// PublishRaw will publish a raw byte array as a message with context. +func (z *CloudEventsSandboxOnlyPublisher) PublishRaw(ctx context.Context, topic string, msgRaw []byte) error { + logger.Debugf(ctx, "Sandbox cloud event publisher, sending raw to topic [%s]", topic) + sm := SandboxMessage{ + Raw: msgRaw, + Topic: topic, + } + select { + case z.subChan <- sm: + // metric + logger.Debugf(ctx, "Sandbox publisher sent message to %s", topic) + return nil + case <-time.After(10000 * time.Millisecond): + // metric + logger.Errorf(context.Background(), "CloudEventsSandboxOnlyPublisher PublishRaw timed out") + return fmt.Errorf("CloudEventsSandboxOnlyPublisher PublishRaw timed out") + } + +} + +func NewCloudEventsPublisher() *CloudEventsSandboxOnlyPublisher { + return &CloudEventsSandboxOnlyPublisher{ + subChan: MsgChan, + } +} diff --git a/flytestdlib/sets/generic_set.go b/flytestdlib/sets/generic_set.go new file mode 100644 index 0000000000..abc739f8aa --- /dev/null +++ b/flytestdlib/sets/generic_set.go @@ -0,0 +1,195 @@ +package sets + +import ( + "sort" +) + +type SetObject interface { + GetID() string +} + +type Generic map[string]SetObject + +// New creates a Generic from a list of values. +func NewGeneric(items ...SetObject) Generic { + gs := Generic{} + gs.Insert(items...) + return gs +} + +// Insert adds items to the set. +func (g Generic) Insert(items ...SetObject) { + for _, item := range items { + g[item.GetID()] = item + } +} + +// Delete removes all items from the set. +func (g Generic) Delete(items ...SetObject) { + for _, item := range items { + delete(g, item.GetID()) + } +} + +// Has returns true if and only if item is contained in the set. +func (g Generic) Has(item SetObject) bool { + _, contained := g[item.GetID()] + return contained +} + +// HasAll returns true if and only if all items are contained in the set. +func (g Generic) HasAll(items ...SetObject) bool { + for _, item := range items { + if !g.Has(item) { + return false + } + } + return true +} + +// HasAny returns true if any items are contained in the set. +func (g Generic) HasAny(items ...SetObject) bool { + for _, item := range items { + if g.Has(item) { + return true + } + } + return false +} + +// Difference returns a set of objects that are not in s2 +// For example: +// s1 = {a1, a2, a3} +// s2 = {a1, a2, a4, a5} +// s1.Difference(s2) = {a3} +// s2.Difference(s1) = {a4, a5} +func (g Generic) Difference(g2 Generic) Generic { + result := NewGeneric() + for _, v := range g { + if !g2.Has(v) { + result.Insert(v) + } + } + return result +} + +// Union returns a new set which includes items in either s1 or s2. +// For example: +// s1 = {a1, a2} +// s2 = {a3, a4} +// s1.Union(s2) = {a1, a2, a3, a4} +// s2.Union(s1) = {a1, a2, a3, a4} +func (g Generic) Union(s2 Generic) Generic { + result := NewGeneric() + for _, v := range g { + result.Insert(v) + } + for _, v := range s2 { + result.Insert(v) + } + return result +} + +// Intersection returns a new set which includes the item in BOTH s1 and s2 +// For example: +// s1 = {a1, a2} +// s2 = {a2, a3} +// s1.Intersection(s2) = {a2} +func (g Generic) Intersection(s2 Generic) Generic { + var walk, other Generic + result := NewGeneric() + if g.Len() < s2.Len() { + walk = g + other = s2 + } else { + walk = s2 + other = g + } + for _, v := range walk { + if other.Has(v) { + result.Insert(v) + } + } + return result +} + +// IsSuperset returns true if and only if s1 is a superset of s2. +func (g Generic) IsSuperset(s2 Generic) bool { + for _, v := range s2 { + if !g.Has(v) { + return false + } + } + return true +} + +// Equal returns true if and only if s1 is equal (as a set) to s2. +// Two sets are equal if their membership is identical. +// (In practice, this means same elements, order doesn't matter) +func (g Generic) Equal(s2 Generic) bool { + return len(g) == len(s2) && g.IsSuperset(s2) +} + +type sortableSliceOfGeneric []string + +func (s sortableSliceOfGeneric) Len() int { return len(s) } +func (s sortableSliceOfGeneric) Less(i, j int) bool { return lessString(s[i], s[j]) } +func (s sortableSliceOfGeneric) Swap(i, j int) { s[i], s[j] = s[j], s[i] } + +// List returns the contents as a sorted string slice. +func (g Generic) ListKeys() []string { + res := make(sortableSliceOfGeneric, 0, len(g)) + for key := range g { + res = append(res, key) + } + sort.Sort(res) + return []string(res) +} + +// List returns the contents as a sorted string slice. +func (g Generic) List() []SetObject { + keys := g.ListKeys() + res := make([]SetObject, 0, len(keys)) + for _, k := range keys { + s := g[k] + res = append(res, s) + } + return res +} + +// UnsortedList returns the slice with contents in random order. +func (g Generic) UnsortedListKeys() []string { + res := make([]string, 0, len(g)) + for key := range g { + res = append(res, key) + } + return res +} + +// UnsortedList returns the slice with contents in random order. +func (g Generic) UnsortedList() []SetObject { + res := make([]SetObject, 0, len(g)) + for _, v := range g { + res = append(res, v) + } + return res +} + +// Returns a single element from the set. +func (g Generic) PopAny() (SetObject, bool) { + for _, v := range g { + g.Delete(v) + return v, true + } + var zeroValue SetObject + return zeroValue, false +} + +// Len returns the size of the set. +func (g Generic) Len() int { + return len(g) +} + +func lessString(lhs, rhs string) bool { + return lhs < rhs +} diff --git a/flytestdlib/sets/generic_set_test.go b/flytestdlib/sets/generic_set_test.go new file mode 100644 index 0000000000..ac95a64726 --- /dev/null +++ b/flytestdlib/sets/generic_set_test.go @@ -0,0 +1,124 @@ +package sets + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +type GenericVal string + +func (g GenericVal) GetID() string { + return string(g) +} + +func TestGenericSet(t *testing.T) { + assert.Equal(t, []string{"a", "b"}, NewGeneric(GenericVal("a"), GenericVal("b")).ListKeys()) + assert.Equal(t, []string{"a", "b"}, NewGeneric(GenericVal("a"), GenericVal("b"), GenericVal("a")).ListKeys()) + + { + g1 := NewGeneric(GenericVal("a"), GenericVal("b")) + g2 := NewGeneric(GenericVal("a"), GenericVal("b"), GenericVal("c")) + { + g := g1.Intersection(g2) + assert.Equal(t, []string{"a", "b"}, g.ListKeys()) + } + { + g := g2.Intersection(g1) + assert.Equal(t, []string{"a", "b"}, g.ListKeys()) + } + } + { + g1 := NewGeneric(GenericVal("a"), GenericVal("b")) + g2 := NewGeneric(GenericVal("a"), GenericVal("b"), GenericVal("c")) + g := g2.Difference(g1) + assert.Equal(t, []string{"c"}, g.ListKeys()) + } + { + g1 := NewGeneric(GenericVal("a"), GenericVal("b")) + g2 := NewGeneric(GenericVal("a"), GenericVal("b"), GenericVal("c")) + g := g1.Difference(g2) + assert.Equal(t, []string{}, g.ListKeys()) + } + { + g1 := NewGeneric(GenericVal("a"), GenericVal("b")) + assert.True(t, g1.Has(GenericVal("a"))) + assert.False(t, g1.Has(GenericVal("c"))) + } + { + g1 := NewGeneric(GenericVal("a"), GenericVal("b")) + assert.False(t, g1.HasAll(GenericVal("a"), GenericVal("b"), GenericVal("c"))) + assert.True(t, g1.HasAll(GenericVal("a"), GenericVal("b"))) + } + + { + g1 := NewGeneric(GenericVal("a"), GenericVal("b")) + g2 := NewGeneric(GenericVal("a"), GenericVal("b"), GenericVal("c")) + g := g1.Union(g2) + assert.Equal(t, []string{"a", "b", "c"}, g.ListKeys()) + } + + { + g1 := NewGeneric(GenericVal("a"), GenericVal("b")) + g2 := NewGeneric(GenericVal("a"), GenericVal("b"), GenericVal("c")) + assert.True(t, g2.IsSuperset(g1)) + assert.False(t, g1.IsSuperset(g2)) + } + { + g1 := NewGeneric(GenericVal("a"), GenericVal("b")) + g2 := g1.UnsortedListKeys() + assert.Equal(t, g1.Len(), len(g2)) + + for _, key := range g2 { + assert.True(t, g1.Has(GenericVal(key))) + } + } + { + g1 := NewGeneric(GenericVal("a"), GenericVal("b")) + assert.True(t, g1.Has(GenericVal("a"))) + assert.False(t, g1.Has(GenericVal("c"))) + assert.Equal(t, []SetObject{ + GenericVal("a"), + GenericVal("b"), + }, g1.List()) + g2 := NewGeneric(g1.UnsortedList()...) + assert.True(t, g1.Equal(g2)) + } + { + g1 := NewGeneric(GenericVal("a"), GenericVal("b")) + g2 := NewGeneric(GenericVal("a"), GenericVal("b"), GenericVal("c")) + g3 := NewGeneric(GenericVal("a"), GenericVal("b")) + assert.False(t, g1.Equal(g2)) + assert.True(t, g1.Equal(g3)) + + assert.Equal(t, 2, g1.Len()) + g1.Insert(GenericVal("b")) + assert.Equal(t, 2, g1.Len()) + assert.True(t, g1.Equal(g3)) + g1.Insert(GenericVal("c")) + assert.Equal(t, 3, g1.Len()) + assert.True(t, g1.Equal(g2)) + assert.True(t, g1.HasAny(GenericVal("a"), GenericVal("d"))) + assert.False(t, g1.HasAny(GenericVal("f"), GenericVal("d"))) + g1.Delete(GenericVal("f")) + assert.True(t, g1.Equal(g2)) + g1.Delete(GenericVal("c")) + assert.True(t, g1.Equal(g3)) + + { + p, ok := g1.PopAny() + assert.NotNil(t, p) + assert.True(t, ok) + } + { + p, ok := g1.PopAny() + assert.NotNil(t, p) + assert.True(t, ok) + } + { + p, ok := g1.PopAny() + assert.Nil(t, p) + assert.False(t, ok) + } + } +} diff --git a/flytestdlib/storage/cached_rawstore.go b/flytestdlib/storage/cached_rawstore.go new file mode 100644 index 0000000000..91d938cf4a --- /dev/null +++ b/flytestdlib/storage/cached_rawstore.go @@ -0,0 +1,146 @@ +package storage + +import ( + "bytes" + "context" + "io" + "runtime/debug" + "time" + + "github.com/coocood/freecache" + "github.com/prometheus/client_golang/prometheus" + + "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/ioutils" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/otelutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +const neverExpire = 0 + +// TODO Freecache has bunch of metrics it calculates. Lets write a prom collector to publish these metrics +type cacheMetrics struct { + CacheHit prometheus.Counter + CacheMiss prometheus.Counter + CacheWriteError prometheus.Counter + FetchLatency promutils.StopWatch +} + +type cachedRawStore struct { + RawStore + cache *freecache.Cache + metrics *cacheMetrics +} + +// Head gets metadata about the reference. This should generally be a lightweight operation. +func (s *cachedRawStore) Head(ctx context.Context, reference DataReference) (Metadata, error) { + ctx, span := otelutils.NewSpan(ctx, otelutils.BlobstoreClientTracer, "flytestdlib.storage.cachedRawStore/Head") + defer span.End() + + key := []byte(reference) + if oRaw, err := s.cache.Get(key); err == nil { + s.metrics.CacheHit.Inc() + // Found, Cache hit + size := int64(len(oRaw)) + // return size in metadata + return StowMetadata{exists: true, size: size}, nil + } + s.metrics.CacheMiss.Inc() + return s.RawStore.Head(ctx, reference) +} + +// ReadRaw retrieves a byte array from the Blob store or an error +func (s *cachedRawStore) ReadRaw(ctx context.Context, reference DataReference) (io.ReadCloser, error) { + ctx, span := otelutils.NewSpan(ctx, otelutils.BlobstoreClientTracer, "flytestdlib.storage.cachedRawStore/ReadRaw") + defer span.End() + + key := []byte(reference) + if oRaw, err := s.cache.Get(key); err == nil { + // Found, Cache hit + s.metrics.CacheHit.Inc() + return ioutils.NewBytesReadCloser(oRaw), nil + } + s.metrics.CacheMiss.Inc() + reader, err := s.RawStore.ReadRaw(ctx, reference) + if err != nil { + return nil, err + } + + defer func() { + err = reader.Close() + if err != nil { + logger.Warnf(ctx, "Failed to close reader [%v]. Error: %v", reference, err) + } + }() + + b, err := ioutils.ReadAll(reader, s.metrics.FetchLatency.Start()) + if err != nil { + return nil, err + } + + err = s.cache.Set(key, b, 0) + if err != nil { + logger.Debugf(ctx, "Failed to Cache the metadata") + err = errors.Wrapf(ErrFailedToWriteCache, err, "Failed to Cache the metadata") + } + + return ioutils.NewBytesReadCloser(b), err +} + +// WriteRaw stores a raw byte array. +func (s *cachedRawStore) WriteRaw(ctx context.Context, reference DataReference, size int64, opts Options, raw io.Reader) error { + ctx, span := otelutils.NewSpan(ctx, otelutils.BlobstoreClientTracer, "flytestdlib.storage.cachedRawStore/WriteRaw") + defer span.End() + + var buf bytes.Buffer + teeReader := io.TeeReader(raw, &buf) + err := s.RawStore.WriteRaw(ctx, reference, size, opts, teeReader) + if err != nil { + return err + } + + err = s.cache.Set([]byte(reference), buf.Bytes(), neverExpire) + if err != nil { + s.metrics.CacheWriteError.Inc() + err = errors.Wrapf(ErrFailedToWriteCache, err, "Failed to Cache the metadata") + } + + return err +} + +// Delete removes the referenced data from the cache as well as underlying store. +func (s *cachedRawStore) Delete(ctx context.Context, reference DataReference) error { + key := []byte(reference) + if deleted := s.cache.Del(key); deleted { + s.metrics.CacheHit.Inc() + } else { + s.metrics.CacheMiss.Inc() + } + + return s.RawStore.Delete(ctx, reference) +} + +func newCacheMetrics(scope promutils.Scope) *cacheMetrics { + return &cacheMetrics{ + FetchLatency: scope.MustNewStopWatch("remote_fetch", "Total Time to read from remote metastore", time.Millisecond), + CacheHit: scope.MustNewCounter("cache_hit", "Number of times metadata was found in cache"), + CacheMiss: scope.MustNewCounter("cache_miss", "Number of times metadata was not found in cache and remote fetch was required"), + CacheWriteError: scope.MustNewCounter("cache_write_err", "Failed to write to cache"), + } +} + +// Creates a CachedStore if Caching is enabled, otherwise returns a RawStore +func newCachedRawStore(cfg *Config, store RawStore, metrics *cacheMetrics) RawStore { + if cfg.Cache.MaxSizeMegabytes > 0 { + if cfg.Cache.TargetGCPercent > 0 { + debug.SetGCPercent(cfg.Cache.TargetGCPercent) + } + return &cachedRawStore{ + RawStore: store, + cache: freecache.NewCache(cfg.Cache.MaxSizeMegabytes * 1024 * 1024), + metrics: metrics, + } + } + return store +} diff --git a/flytestdlib/storage/cached_rawstore_test.go b/flytestdlib/storage/cached_rawstore_test.go new file mode 100644 index 0000000000..836047ebca --- /dev/null +++ b/flytestdlib/storage/cached_rawstore_test.go @@ -0,0 +1,229 @@ +package storage + +import ( + "bytes" + "context" + "fmt" + "io" + "io/ioutil" + "math/rand" + "runtime/debug" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/ioutils" +) + +func TestNewCachedStore(t *testing.T) { + t.Run("CachingDisabled", func(t *testing.T) { + cfg := &Config{} + assert.Nil(t, newCachedRawStore(cfg, nil, metrics.cacheMetrics)) + store, err := NewInMemoryRawStore(context.TODO(), cfg, metrics) + assert.NoError(t, err) + assert.Equal(t, store, newCachedRawStore(cfg, store, metrics.cacheMetrics)) + }) + + t.Run("CachingEnabled", func(t *testing.T) { + cfg := &Config{ + Cache: CachingConfig{ + MaxSizeMegabytes: 1, + TargetGCPercent: 20, + }, + } + store, err := NewInMemoryRawStore(context.TODO(), cfg, metrics) + assert.NoError(t, err) + cStore := newCachedRawStore(cfg, store, metrics.cacheMetrics) + assert.Equal(t, 20, debug.SetGCPercent(100)) + assert.NotNil(t, cStore) + assert.NotNil(t, cStore.(*cachedRawStore).cache) + }) +} + +func dummyCacheStore(t *testing.T, store RawStore, metrics *cacheMetrics) *cachedRawStore { + cfg := &Config{ + Cache: CachingConfig{ + MaxSizeMegabytes: 1, + TargetGCPercent: 20, + }, + } + cStore := newCachedRawStore(cfg, store, metrics) + assert.NotNil(t, cStore) + return cStore.(*cachedRawStore) +} + +type dummyStore struct { + copyImpl + HeadCb func(ctx context.Context, reference DataReference) (Metadata, error) + ReadRawCb func(ctx context.Context, reference DataReference) (io.ReadCloser, error) + WriteRawCb func(ctx context.Context, reference DataReference, size int64, opts Options, raw io.Reader) error + DeleteCb func(ctx context.Context, reference DataReference) error +} + +// CreateSignedURL creates a signed url with the provided properties. +func (d *dummyStore) CreateSignedURL(ctx context.Context, reference DataReference, properties SignedURLProperties) (SignedURLResponse, error) { + return SignedURLResponse{}, fmt.Errorf("unsupported") +} + +func (d *dummyStore) GetBaseContainerFQN(ctx context.Context) DataReference { + return "dummy" +} + +func (d *dummyStore) Head(ctx context.Context, reference DataReference) (Metadata, error) { + return d.HeadCb(ctx, reference) +} + +func (d *dummyStore) List(ctx context.Context, reference DataReference, maxItems int, cursor Cursor) ([]DataReference, Cursor, error) { + return nil, NewCursorAtEnd(), fmt.Errorf("Not implemented yet") +} + +func (d *dummyStore) ReadRaw(ctx context.Context, reference DataReference) (io.ReadCloser, error) { + return d.ReadRawCb(ctx, reference) +} + +func (d *dummyStore) WriteRaw(ctx context.Context, reference DataReference, size int64, opts Options, raw io.Reader) error { + return d.WriteRawCb(ctx, reference, size, opts, raw) +} + +func (d *dummyStore) Delete(ctx context.Context, reference DataReference) error { + return d.DeleteCb(ctx, reference) +} + +func TestCachedRawStore(t *testing.T) { + ctx := context.TODO() + k1 := DataReference("k1") + k2 := DataReference("k2") + bigK := DataReference("bigK") + d1 := []byte("abc") + d2 := []byte("xyz") + bigD := make([]byte, 1.5*1024*1024) + // #nosec G404 + _, err := rand.Read(bigD) + assert.NoError(t, err) + writeCalled := false + readCalled := false + store := &dummyStore{ + HeadCb: func(ctx context.Context, reference DataReference) (Metadata, error) { + if reference == "k1" { + return MemoryMetadata{exists: true, size: int64(len(d1))}, nil + } + return MemoryMetadata{}, fmt.Errorf("err") + }, + WriteRawCb: func(ctx context.Context, reference DataReference, size int64, opts Options, raw io.Reader) error { + if writeCalled { + assert.FailNow(t, "Should not be writeCalled") + } + writeCalled = true + switch reference { + case "k2": + b, err := ioutil.ReadAll(raw) + assert.NoError(t, err) + assert.Equal(t, d2, b) + return nil + case "bigK": + b, err := ioutil.ReadAll(raw) + assert.NoError(t, err) + assert.Equal(t, bigD, b) + return nil + } + return fmt.Errorf("err") + }, + ReadRawCb: func(ctx context.Context, reference DataReference) (io.ReadCloser, error) { + if readCalled { + assert.FailNow(t, "Should not be invoked again") + } + readCalled = true + switch reference { + case "k1": + return ioutils.NewBytesReadCloser(d1), nil + case "bigK": + return ioutils.NewBytesReadCloser(bigD), nil + } + return nil, fmt.Errorf("err") + }, + DeleteCb: func(ctx context.Context, reference DataReference) error { + if reference == "k1" { + return nil + } + return fmt.Errorf("err") + }, + } + + store.copyImpl = newCopyImpl(store, metrics.copyMetrics) + + cStore := dummyCacheStore(t, store, metrics.cacheMetrics) + + t.Run("HeadExists", func(t *testing.T) { + m, err := cStore.Head(ctx, k1) + assert.NoError(t, err) + assert.Equal(t, int64(len(d1)), m.Size()) + assert.True(t, m.Exists()) + }) + + t.Run("HeadNotExists", func(t *testing.T) { + m, err := cStore.Head(ctx, k2) + assert.Error(t, err) + assert.False(t, m.Exists()) + }) + + t.Run("ReadCachePopulate", func(t *testing.T) { + o, err := cStore.ReadRaw(ctx, k1) + assert.NoError(t, err) + b, err := ioutil.ReadAll(o) + assert.NoError(t, err) + assert.Equal(t, d1, b) + assert.True(t, readCalled) + readCalled = false + o, err = cStore.ReadRaw(ctx, k1) + assert.NoError(t, err) + b, err = ioutil.ReadAll(o) + assert.NoError(t, err) + assert.Equal(t, d1, b) + assert.False(t, readCalled) + }) + + t.Run("ReadFail", func(t *testing.T) { + readCalled = false + _, err := cStore.ReadRaw(ctx, k2) + assert.Error(t, err) + assert.True(t, readCalled) + }) + + t.Run("WriteAndRead", func(t *testing.T) { + readCalled = false + assert.NoError(t, cStore.WriteRaw(ctx, k2, int64(len(d2)), Options{}, bytes.NewReader(d2))) + assert.True(t, writeCalled) + + o, err := cStore.ReadRaw(ctx, k2) + assert.NoError(t, err) + b, err := ioutil.ReadAll(o) + assert.NoError(t, err) + assert.Equal(t, d2, b) + assert.False(t, readCalled) + }) + + t.Run("WriteAndReadBigData", func(t *testing.T) { + writeCalled = false + readCalled = false + err := cStore.WriteRaw(ctx, bigK, int64(len(bigD)), Options{}, bytes.NewReader(bigD)) + assert.True(t, writeCalled) + assert.True(t, IsFailedWriteToCache(err)) + + o, err := cStore.ReadRaw(ctx, bigK) + assert.True(t, IsFailedWriteToCache(err)) + b, err := ioutil.ReadAll(o) + assert.NoError(t, err) + assert.Equal(t, bigD, b) + assert.True(t, readCalled) + }) + + t.Run("DeleteExists", func(t *testing.T) { + err := cStore.Delete(ctx, k1) + assert.NoError(t, err) + }) + + t.Run("DeleteNotExists", func(t *testing.T) { + err := cStore.Delete(ctx, k2) + assert.Error(t, err) + }) +} diff --git a/flytestdlib/storage/config.go b/flytestdlib/storage/config.go new file mode 100644 index 0000000000..70709bfc88 --- /dev/null +++ b/flytestdlib/storage/config.go @@ -0,0 +1,123 @@ +package storage + +import ( + "context" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +//go:generate pflags Config --default-var=defaultConfig + +// Type defines the storage config type. +type Type = string + +// The reserved config section key for storage. +const configSectionKey = "Storage" + +const ( + TypeMemory Type = "mem" + TypeS3 Type = "s3" + TypeLocal Type = "local" + TypeMinio Type = "minio" + TypeStow Type = "stow" +) + +const ( + KiB int64 = 1024 + MiB int64 = 1024 * KiB +) + +var ( + ConfigSection = config.MustRegisterSection(configSectionKey, defaultConfig) + defaultConfig = &Config{ + Type: TypeS3, + Limits: LimitsConfig{ + GetLimitMegabytes: 2, + }, + Connection: ConnectionConfig{ + Region: "us-east-1", + AuthType: "iam", + }, + MultiContainerEnabled: false, + } +) + +// Config is a common storage config. +type Config struct { + Type Type `json:"type" pflag:",Sets the type of storage to configure [s3/minio/local/mem/stow]."` + // Deprecated: Please use StowConfig instead + Connection ConnectionConfig `json:"connection"` + Stow StowConfig `json:"stow,omitempty" pflag:",Storage config for stow backend."` + + // Container here is misleading, it refers to a Bucket (AWS S3) like blobstore entity. In some terms it could be a table + InitContainer string `json:"container" pflag:",Initial container (in s3 a bucket) to create -if it doesn't exist-.'"` + // By default if this is not enabled, multiple containers are not supported by the storage layer. Only the configured `container` InitContainer will be allowed to requests data from. But, if enabled then data will be loaded to written to any + // container specified in the DataReference. + MultiContainerEnabled bool `json:"enable-multicontainer" pflag:",If this is true, then the container argument is overlooked and redundant. This config will automatically open new connections to new containers/buckets as they are encountered"` + // Caching is recommended to improve the performance of underlying systems. It caches the metadata and resolving + // inputs is accelerated. The size of the cache is large so understand how to configure the cache. + // TODO provide some default config choices + // If this section is skipped, Caching is disabled + Cache CachingConfig `json:"cache"` + Limits LimitsConfig `json:"limits" pflag:",Sets limits for stores."` + DefaultHTTPClient HTTPClientConfig `json:"defaultHttpClient" pflag:",Sets the default http client config."` + SignedURL SignedURLConfig `json:"signedUrl" pflag:",Sets config for SignedURL."` +} + +// SignedURLConfig encapsulates configs specifically used for SignedURL behavior. +type SignedURLConfig struct { + StowConfigOverride map[string]string `json:"stowConfigOverride,omitempty" pflag:"-,Configuration for stow backend. Refer to github/flyteorg/stow"` +} + +// HTTPClientConfig encapsulates common settings that can be applied to an HTTP Client. +type HTTPClientConfig struct { + Headers map[string][]string `json:"headers" pflag:"-,Sets http headers to set on the http client."` + Timeout config.Duration `json:"timeout" pflag:",Sets time out on the http client."` +} + +// ConnectionConfig defines connection configurations. +type ConnectionConfig struct { + Endpoint config.URL `json:"endpoint" pflag:",URL for storage client to connect to."` + AuthType string `json:"auth-type" pflag:",Auth Type to use [iam,accesskey]."` + AccessKey string `json:"access-key" pflag:",Access key to use. Only required when authtype is set to accesskey."` + SecretKey string `json:"secret-key" pflag:",Secret to use when accesskey is set."` + Region string `json:"region" pflag:",Region to connect to."` + DisableSSL bool `json:"disable-ssl" pflag:",Disables SSL connection. Should only be used for development."` +} + +// StowConfig defines configs for stow as defined in github.com/flyteorg/stow +type StowConfig struct { + Kind string `json:"kind,omitempty" pflag:",Kind of Stow backend to use. Refer to github/flyteorg/stow"` + Config map[string]string `json:"config,omitempty" pflag:",Configuration for stow backend. Refer to github/flyteorg/stow"` +} + +type CachingConfig struct { + // Maximum size of the cache where the Blob store data is cached in-memory + // Refer to https://github.com/coocood/freecache to understand how to set the value + // If not specified or set to 0, cache is not used + // NOTE: if Object sizes are larger than 1/1024 of the cache size, the entry will not be written to the cache + // Also refer to https://github.com/coocood/freecache/issues/17 to understand how to set the cache + MaxSizeMegabytes int `json:"max_size_mbs" pflag:",Maximum size of the cache where the Blob store data is cached in-memory. If not specified or set to 0, cache is not used"` + // sets the garbage collection target percentage: + // a collection is triggered when the ratio of freshly allocated data + // to live data remaining after the previous collection reaches this percentage. + // refer to https://golang.org/pkg/runtime/debug/#SetGCPercent + // If not specified or set to 0, GC percent is not tweaked + TargetGCPercent int `json:"target_gc_percent" pflag:",Sets the garbage collection target percentage."` +} + +// LimitsConfig specifies limits for storage package. +type LimitsConfig struct { + GetLimitMegabytes int64 `json:"maxDownloadMBs" pflag:",Maximum allowed download size (in MBs) per call."` +} + +// GetConfig retrieve current global config for storage. +func GetConfig() *Config { + if c, ok := ConfigSection.GetConfig().(*Config); ok { + return c + } + + logger.Warnf(context.TODO(), "Failed to retrieve config section [%v].", configSectionKey) + return nil +} diff --git a/flytestdlib/storage/config_flags.go b/flytestdlib/storage/config_flags.go new file mode 100755 index 0000000000..63a41550c2 --- /dev/null +++ b/flytestdlib/storage/config_flags.go @@ -0,0 +1,69 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package storage + +import ( + "encoding/json" + "reflect" + + "fmt" + + "github.com/spf13/pflag" +) + +// If v is a pointer, it will get its element value or the zero value of the element type. +// If v is not a pointer, it will return it as is. +func (Config) elemValueOrNil(v interface{}) interface{} { + if t := reflect.TypeOf(v); t.Kind() == reflect.Ptr { + if reflect.ValueOf(v).IsNil() { + return reflect.Zero(t.Elem()).Interface() + } else { + return reflect.ValueOf(v).Interface() + } + } else if v == nil { + return reflect.Zero(t).Interface() + } + + return v +} + +func (Config) mustJsonMarshal(v interface{}) string { + raw, err := json.Marshal(v) + if err != nil { + panic(err) + } + + return string(raw) +} + +func (Config) mustMarshalJSON(v json.Marshaler) string { + raw, err := v.MarshalJSON() + if err != nil { + panic(err) + } + + return string(raw) +} + +// GetPFlagSet will return strongly types pflags for all fields in Config and its nested types. The format of the +// flags is json-name.json-sub-name... etc. +func (cfg Config) GetPFlagSet(prefix string) *pflag.FlagSet { + cmdFlags := pflag.NewFlagSet("Config", pflag.ExitOnError) + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "type"), defaultConfig.Type, "Sets the type of storage to configure [s3/minio/local/mem/stow].") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "connection.endpoint"), defaultConfig.Connection.Endpoint.String(), "URL for storage client to connect to.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "connection.auth-type"), defaultConfig.Connection.AuthType, "Auth Type to use [iam, accesskey].") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "connection.access-key"), defaultConfig.Connection.AccessKey, "Access key to use. Only required when authtype is set to accesskey.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "connection.secret-key"), defaultConfig.Connection.SecretKey, "Secret to use when accesskey is set.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "connection.region"), defaultConfig.Connection.Region, "Region to connect to.") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "connection.disable-ssl"), defaultConfig.Connection.DisableSSL, "Disables SSL connection. Should only be used for development.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "stow.kind"), defaultConfig.Stow.Kind, "Kind of Stow backend to use. Refer to github/flyteorg/stow") + cmdFlags.StringToString(fmt.Sprintf("%v%v", prefix, "stow.config"), defaultConfig.Stow.Config, "Configuration for stow backend. Refer to github/flyteorg/stow") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "container"), defaultConfig.InitContainer, "Initial container (in s3 a bucket) to create -if it doesn't exist-.'") + cmdFlags.Bool(fmt.Sprintf("%v%v", prefix, "enable-multicontainer"), defaultConfig.MultiContainerEnabled, "If this is true, then the container argument is overlooked and redundant. This config will automatically open new connections to new containers/buckets as they are encountered") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "cache.max_size_mbs"), defaultConfig.Cache.MaxSizeMegabytes, "Maximum size of the cache where the Blob store data is cached in-memory. If not specified or set to 0, cache is not used") + cmdFlags.Int(fmt.Sprintf("%v%v", prefix, "cache.target_gc_percent"), defaultConfig.Cache.TargetGCPercent, "Sets the garbage collection target percentage.") + cmdFlags.Int64(fmt.Sprintf("%v%v", prefix, "limits.maxDownloadMBs"), defaultConfig.Limits.GetLimitMegabytes, "Maximum allowed download size (in MBs) per call.") + cmdFlags.String(fmt.Sprintf("%v%v", prefix, "defaultHttpClient.timeout"), defaultConfig.DefaultHTTPClient.Timeout.String(), "Sets time out on the http client.") + return cmdFlags +} diff --git a/flytestdlib/storage/config_flags_test.go b/flytestdlib/storage/config_flags_test.go new file mode 100755 index 0000000000..c71a3e8f6d --- /dev/null +++ b/flytestdlib/storage/config_flags_test.go @@ -0,0 +1,312 @@ +// Code generated by go generate; DO NOT EDIT. +// This file was generated by robots. + +package storage + +import ( + "encoding/json" + "fmt" + "reflect" + "strings" + "testing" + + "github.com/mitchellh/mapstructure" + "github.com/stretchr/testify/assert" +) + +var dereferencableKindsConfig = map[reflect.Kind]struct{}{ + reflect.Array: {}, reflect.Chan: {}, reflect.Map: {}, reflect.Ptr: {}, reflect.Slice: {}, +} + +// Checks if t is a kind that can be dereferenced to get its underlying type. +func canGetElementConfig(t reflect.Kind) bool { + _, exists := dereferencableKindsConfig[t] + return exists +} + +// This decoder hook tests types for json unmarshaling capability. If implemented, it uses json unmarshal to build the +// object. Otherwise, it'll just pass on the original data. +func jsonUnmarshalerHookConfig(_, to reflect.Type, data interface{}) (interface{}, error) { + unmarshalerType := reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + if to.Implements(unmarshalerType) || reflect.PtrTo(to).Implements(unmarshalerType) || + (canGetElementConfig(to.Kind()) && to.Elem().Implements(unmarshalerType)) { + + raw, err := json.Marshal(data) + if err != nil { + fmt.Printf("Failed to marshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + res := reflect.New(to).Interface() + err = json.Unmarshal(raw, &res) + if err != nil { + fmt.Printf("Failed to umarshal Data: %v. Error: %v. Skipping jsonUnmarshalHook", data, err) + return data, nil + } + + return res, nil + } + + return data, nil +} + +func decode_Config(input, result interface{}) error { + config := &mapstructure.DecoderConfig{ + TagName: "json", + WeaklyTypedInput: true, + Result: result, + DecodeHook: mapstructure.ComposeDecodeHookFunc( + mapstructure.StringToTimeDurationHookFunc(), + mapstructure.StringToSliceHookFunc(","), + jsonUnmarshalerHookConfig, + ), + } + + decoder, err := mapstructure.NewDecoder(config) + if err != nil { + return err + } + + return decoder.Decode(input) +} + +func join_Config(arr interface{}, sep string) string { + listValue := reflect.ValueOf(arr) + strs := make([]string, 0, listValue.Len()) + for i := 0; i < listValue.Len(); i++ { + strs = append(strs, fmt.Sprintf("%v", listValue.Index(i))) + } + + return strings.Join(strs, sep) +} + +func testDecodeJson_Config(t *testing.T, val, result interface{}) { + assert.NoError(t, decode_Config(val, result)) +} + +func testDecodeRaw_Config(t *testing.T, vStringSlice, result interface{}) { + assert.NoError(t, decode_Config(vStringSlice, result)) +} + +func TestConfig_GetPFlagSet(t *testing.T) { + val := Config{} + cmdFlags := val.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) +} + +func TestConfig_SetFlags(t *testing.T) { + actual := Config{} + cmdFlags := actual.GetPFlagSet("") + assert.True(t, cmdFlags.HasFlags()) + + t.Run("Test_type", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("type", testValue) + if vString, err := cmdFlags.GetString("type"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.Type) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_connection.endpoint", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := defaultConfig.Connection.Endpoint.String() + + cmdFlags.Set("connection.endpoint", testValue) + if vString, err := cmdFlags.GetString("connection.endpoint"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.Connection.Endpoint) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_connection.auth-type", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("connection.auth-type", testValue) + if vString, err := cmdFlags.GetString("connection.auth-type"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.Connection.AuthType) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_connection.access-key", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("connection.access-key", testValue) + if vString, err := cmdFlags.GetString("connection.access-key"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.Connection.AccessKey) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_connection.secret-key", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("connection.secret-key", testValue) + if vString, err := cmdFlags.GetString("connection.secret-key"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.Connection.SecretKey) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_connection.region", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("connection.region", testValue) + if vString, err := cmdFlags.GetString("connection.region"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.Connection.Region) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_connection.disable-ssl", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("connection.disable-ssl", testValue) + if vBool, err := cmdFlags.GetBool("connection.disable-ssl"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.Connection.DisableSSL) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_stow.kind", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("stow.kind", testValue) + if vString, err := cmdFlags.GetString("stow.kind"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.Stow.Kind) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_stow.config", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "a=1,b=2" + + cmdFlags.Set("stow.config", testValue) + if vStringToString, err := cmdFlags.GetStringToString("stow.config"); err == nil { + testDecodeRaw_Config(t, vStringToString, &actual.Stow.Config) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_container", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("container", testValue) + if vString, err := cmdFlags.GetString("container"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.InitContainer) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_enable-multicontainer", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("enable-multicontainer", testValue) + if vBool, err := cmdFlags.GetBool("enable-multicontainer"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vBool), &actual.MultiContainerEnabled) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_cache.max_size_mbs", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("cache.max_size_mbs", testValue) + if vInt, err := cmdFlags.GetInt("cache.max_size_mbs"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vInt), &actual.Cache.MaxSizeMegabytes) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_cache.target_gc_percent", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("cache.target_gc_percent", testValue) + if vInt, err := cmdFlags.GetInt("cache.target_gc_percent"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vInt), &actual.Cache.TargetGCPercent) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_limits.maxDownloadMBs", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := "1" + + cmdFlags.Set("limits.maxDownloadMBs", testValue) + if vInt64, err := cmdFlags.GetInt64("limits.maxDownloadMBs"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vInt64), &actual.Limits.GetLimitMegabytes) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) + t.Run("Test_defaultHttpClient.timeout", func(t *testing.T) { + + t.Run("Override", func(t *testing.T) { + testValue := defaultConfig.DefaultHTTPClient.Timeout.String() + + cmdFlags.Set("defaultHttpClient.timeout", testValue) + if vString, err := cmdFlags.GetString("defaultHttpClient.timeout"); err == nil { + testDecodeJson_Config(t, fmt.Sprintf("%v", vString), &actual.DefaultHTTPClient.Timeout) + + } else { + assert.FailNow(t, err.Error()) + } + }) + }) +} diff --git a/flytestdlib/storage/config_test.go b/flytestdlib/storage/config_test.go new file mode 100644 index 0000000000..dacf9307ad --- /dev/null +++ b/flytestdlib/storage/config_test.go @@ -0,0 +1,45 @@ +package storage + +import ( + "flag" + "os" + "path/filepath" + "reflect" + "testing" + + "github.com/ghodss/yaml" + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/internal/utils" +) + +// Make sure existing config file(s) parse correctly before overriding them with this flag! +var update = flag.Bool("update", false, "Updates testdata") + +func TestMarshal(t *testing.T) { + expected := Config{ + Type: "s3", + Connection: ConnectionConfig{ + Endpoint: config.URL{URL: utils.MustParseURL("http://minio:9000")}, + AuthType: "accesskey", + AccessKey: "minio", + SecretKey: "miniostorage", + Region: "us-east-1", + DisableSSL: true, + }, + } + + if *update { + t.Log("Updating config file.") + raw, err := yaml.Marshal(expected) + assert.NoError(t, err) + assert.NoError(t, os.WriteFile(filepath.Join("testdata", "config.yaml"), raw, os.ModePerm)) // #nosec G306 + } + + actual := Config{} + raw, err := os.ReadFile(filepath.Join("testdata", "config.yaml")) + assert.NoError(t, err) + assert.NoError(t, yaml.Unmarshal(raw, &actual)) + assert.True(t, reflect.DeepEqual(expected, actual)) +} diff --git a/flytestdlib/storage/copy_impl.go b/flytestdlib/storage/copy_impl.go new file mode 100644 index 0000000000..d4c1f3a9eb --- /dev/null +++ b/flytestdlib/storage/copy_impl.go @@ -0,0 +1,81 @@ +package storage + +import ( + "context" + "fmt" + "io" + "time" + + errs "github.com/pkg/errors" + "github.com/prometheus/client_golang/prometheus" + + "github.com/flyteorg/flyte/v2/flytestdlib/ioutils" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils/labeled" +) + +type copyImpl struct { + rawStore RawStore + metrics *copyMetrics +} + +type copyMetrics struct { + CopyLatency labeled.StopWatch + ComputeLengthLatency labeled.StopWatch + WriteFailureUnrelatedToCache prometheus.Counter + ReadFailureUnrelatedToCache prometheus.Counter +} + +// CopyRaw is a naiive implementation for copy that reads all data locally then writes them to destination. +// TODO: We should upstream an API change to stow to implement copy more natively. E.g. Use s3 copy: +// https://docs.aws.amazon.com/AmazonS3/latest/dev/CopyingObjectUsingREST.html +func (c copyImpl) CopyRaw(ctx context.Context, source, destination DataReference, opts Options) error { + rc, err := c.rawStore.ReadRaw(ctx, source) + + if err != nil && !IsFailedWriteToCache(err) { + logger.Errorf(ctx, "Failed to read from the raw store when copying [%v] to [%v]. Error: %v", source, destination, err) + c.metrics.ReadFailureUnrelatedToCache.Inc() + return errs.Wrap(err, fmt.Sprintf("path:%v", destination)) + } + + length := int64(0) + if _, isSeeker := rc.(io.Seeker); !isSeeker { + // If the returned ReadCloser doesn't implement Seeker interface, then the underlying writer won't be able to + // calculate content length on its own. Some implementations (e.g. S3 Stow Store) will error if it can't. + var raw []byte + raw, err = ioutils.ReadAll(rc, c.metrics.ComputeLengthLatency.Start(ctx)) + if err != nil { + return err + } + + rc = ioutils.NewBytesReadCloser(raw) + length = int64(len(raw)) + } + + err = c.rawStore.WriteRaw(ctx, destination, length, Options{}, rc) + + if err != nil && !IsFailedWriteToCache(err) { + logger.Errorf(ctx, "Failed to write to the raw store when copying. Error: %v", err) + c.metrics.WriteFailureUnrelatedToCache.Inc() + return err + } + + return nil +} + +func newCopyMetrics(scope promutils.Scope) *copyMetrics { + return ©Metrics{ + CopyLatency: labeled.NewStopWatch("overall", "Overall copy latency", time.Millisecond, scope, labeled.EmitUnlabeledMetric), + ComputeLengthLatency: labeled.NewStopWatch("length", "Latency involved in computing length of content before writing.", time.Millisecond, scope, labeled.EmitUnlabeledMetric), + WriteFailureUnrelatedToCache: scope.MustNewCounter("write_failure_unrelated_to_cache", "Raw store write failures that are not caused by ErrFailedToWriteCache"), + ReadFailureUnrelatedToCache: scope.MustNewCounter("read_failure_unrelated_to_cache", "Raw store read failures that are not caused by ErrFailedToWriteCache"), + } +} + +func newCopyImpl(store RawStore, metrics *copyMetrics) copyImpl { + return copyImpl{ + rawStore: store, + metrics: metrics, + } +} diff --git a/flytestdlib/storage/copy_impl_test.go b/flytestdlib/storage/copy_impl_test.go new file mode 100644 index 0000000000..78103ceb4d --- /dev/null +++ b/flytestdlib/storage/copy_impl_test.go @@ -0,0 +1,143 @@ +package storage + +import ( + "context" + "fmt" + "io" + "math/rand" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/ioutils" +) + +type notSeekerReader struct { + bytesCount int +} + +func (notSeekerReader) Close() error { + return nil +} + +func (r *notSeekerReader) Read(p []byte) (n int, err error) { + if len(p) < 1 { + return 0, nil + } + + p[0] = byte(10) + + r.bytesCount-- + if r.bytesCount <= 0 { + return 0, io.EOF + } + + return 1, nil +} + +func newNotSeekerReader(bytesCount int) *notSeekerReader { + return ¬SeekerReader{ + bytesCount: bytesCount, + } +} + +func TestCopyRaw(t *testing.T) { + t.Run("Called", func(t *testing.T) { + readerCalled := false + writerCalled := false + store := dummyStore{ + ReadRawCb: func(ctx context.Context, reference DataReference) (closer io.ReadCloser, e error) { + readerCalled = true + return ioutils.NewBytesReadCloser([]byte{}), nil + }, + WriteRawCb: func(ctx context.Context, reference DataReference, size int64, opts Options, raw io.Reader) error { + writerCalled = true + return nil + }, + } + + copier := newCopyImpl(&store, metrics.copyMetrics) + assert.NoError(t, copier.CopyRaw(context.Background(), DataReference("source.pb"), DataReference("dest.pb"), Options{})) + assert.True(t, readerCalled) + assert.True(t, writerCalled) + }) + + t.Run("Not Seeker", func(t *testing.T) { + readerCalled := false + writerCalled := false + store := dummyStore{ + ReadRawCb: func(ctx context.Context, reference DataReference) (closer io.ReadCloser, e error) { + readerCalled = true + return newNotSeekerReader(10), nil + }, + WriteRawCb: func(ctx context.Context, reference DataReference, size int64, opts Options, raw io.Reader) error { + writerCalled = true + return nil + }, + } + + copier := newCopyImpl(&store, metrics.copyMetrics) + assert.NoError(t, copier.CopyRaw(context.Background(), DataReference("source.pb"), DataReference("dest.pb"), Options{})) + assert.True(t, readerCalled) + assert.True(t, writerCalled) + }) +} + +func TestCopyRaw_CachingErrorHandling(t *testing.T) { + t.Run("CopyRaw with Caching Error", func(t *testing.T) { + readerCalled := false + writerCalled := false + bigD := make([]byte, 1.5*1024*1024) + // #nosec G404 + _, err := rand.Read(bigD) + assert.NoError(t, err) + dummyErrorMsg := "Dummy caching error" + + store := dummyStore{ + ReadRawCb: func(ctx context.Context, reference DataReference) (closer io.ReadCloser, e error) { + readerCalled = true + //nolint:govet,staticcheck + return ioutils.NewBytesReadCloser(bigD), errors.Wrapf(ErrFailedToWriteCache, fmt.Errorf("%s", dummyErrorMsg), "Failed to Cache the metadata") + }, + WriteRawCb: func(ctx context.Context, reference DataReference, size int64, opts Options, raw io.Reader) error { + writerCalled = true + return errors.Wrapf(ErrFailedToWriteCache, fmt.Errorf("%s", dummyErrorMsg), "Failed to Cache the metadata") //nolint:govet,staticcheck + }, + } + + copier := newCopyImpl(&store, metrics.copyMetrics) + assert.NoError(t, copier.CopyRaw(context.Background(), DataReference("source.pb"), DataReference("dest.pb"), Options{})) + assert.True(t, readerCalled) + assert.True(t, writerCalled) + }) + + t.Run("CopyRaw with Hard Error", func(t *testing.T) { + readerCalled := false + writerCalled := false + bigD := make([]byte, 1.5*1024*1024) + // #nosec G404 + _, err := rand.Read(bigD) + assert.NoError(t, err) + dummyErrorMsg := "Dummy non-caching error" + + store := dummyStore{ + ReadRawCb: func(ctx context.Context, reference DataReference) (closer io.ReadCloser, e error) { + readerCalled = true + return ioutils.NewBytesReadCloser(bigD), fmt.Errorf("%s", dummyErrorMsg) //nolint:govet,staticcheck + }, + WriteRawCb: func(ctx context.Context, reference DataReference, size int64, opts Options, raw io.Reader) error { + writerCalled = true + return fmt.Errorf("%s", dummyErrorMsg) //nolint:govet,staticcheck + }, + } + + copier := newCopyImpl(&store, metrics.copyMetrics) + err = copier.CopyRaw(context.Background(), DataReference("source.pb"), DataReference("dest.pb"), Options{}) + assert.Error(t, err) + assert.True(t, readerCalled) + // writerCalled should be false because CopyRaw should error out right after c.rawstore.ReadRaw() when the underlying error is a hard error + assert.False(t, writerCalled) + assert.False(t, IsFailedWriteToCache(err)) + }) +} diff --git a/flytestdlib/storage/init_test.go b/flytestdlib/storage/init_test.go new file mode 100644 index 0000000000..ed67acbe21 --- /dev/null +++ b/flytestdlib/storage/init_test.go @@ -0,0 +1,15 @@ +package storage + +import ( + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils/labeled" +) + +var metrics *dataStoreMetrics + +func init() { + labeled.SetMetricKeys(contextutils.ProjectKey, contextutils.DomainKey, contextutils.WorkflowIDKey, contextutils.TaskIDKey) + scope := promutils.NewTestScope() + metrics = newDataStoreMetrics(scope) +} diff --git a/flytestdlib/storage/mem_store.go b/flytestdlib/storage/mem_store.go new file mode 100644 index 0000000000..540423a2a0 --- /dev/null +++ b/flytestdlib/storage/mem_store.go @@ -0,0 +1,143 @@ +package storage + +import ( + "bytes" + "context" + "crypto/md5" // #nosec + "encoding/hex" + "fmt" + "io" + "io/ioutil" + "os" + "strings" + "sync" +) + +type rawFile = []byte + +type InMemoryStore struct { + copyImpl + cache map[DataReference]rawFile + rwMutex sync.RWMutex +} + +type MemoryMetadata struct { + exists bool + size int64 + etag string + contentMD5 string +} + +func (m MemoryMetadata) Size() int64 { + return m.size +} + +func (m MemoryMetadata) Exists() bool { + return m.exists +} + +func (m MemoryMetadata) Etag() string { + return m.etag +} + +func (m MemoryMetadata) ContentMD5() string { + return m.contentMD5 +} + +func (s *InMemoryStore) Head(ctx context.Context, reference DataReference) (Metadata, error) { + s.rwMutex.RLock() + defer s.rwMutex.RUnlock() + + data, found := s.cache[reference] + var hash [md5.Size]byte + if found { + hash = md5.Sum(data) // #nosec + } + + return MemoryMetadata{ + exists: found, size: int64(len(data)), + etag: hex.EncodeToString(hash[:]), + }, nil +} + +func (s *InMemoryStore) List(ctx context.Context, reference DataReference, maxItems int, cursor Cursor) ([]DataReference, Cursor, error) { + var items []DataReference + prefix := strings.TrimSuffix(string(reference), "/") + "/" + + for ref := range s.cache { + if strings.HasPrefix(ref.String(), prefix) { + items = append(items, ref) + } + } + + if len(items) == 0 { + return nil, NewCursorAtEnd(), os.ErrNotExist + } + + return items, NewCursorAtEnd(), nil +} + +func (s *InMemoryStore) ReadRaw(ctx context.Context, reference DataReference) (io.ReadCloser, error) { + s.rwMutex.RLock() + defer s.rwMutex.RUnlock() + + if raw, found := s.cache[reference]; found { + return ioutil.NopCloser(bytes.NewReader(raw)), nil + } + + return nil, os.ErrNotExist +} + +// Delete removes the referenced data from the cache map. +func (s *InMemoryStore) Delete(ctx context.Context, reference DataReference) error { + s.rwMutex.Lock() + defer s.rwMutex.Unlock() + + if _, found := s.cache[reference]; !found { + return os.ErrNotExist + } + + delete(s.cache, reference) + + return nil +} + +func (s *InMemoryStore) WriteRaw(ctx context.Context, reference DataReference, size int64, opts Options, raw io.Reader) ( + err error) { + s.rwMutex.Lock() + defer s.rwMutex.Unlock() + + rawBytes, err := ioutil.ReadAll(raw) + if err != nil { + return err + } + + s.cache[reference] = rawBytes + return nil +} + +func (s *InMemoryStore) Clear(ctx context.Context) error { + s.rwMutex.Lock() + defer s.rwMutex.Unlock() + + s.cache = map[DataReference]rawFile{} + return nil +} + +func (s *InMemoryStore) GetBaseContainerFQN(ctx context.Context) DataReference { + return DataReference("") +} + +// CreateSignedURL creates a signed url with the provided properties. +func (s *InMemoryStore) CreateSignedURL(ctx context.Context, reference DataReference, properties SignedURLProperties) (SignedURLResponse, error) { + return SignedURLResponse{}, fmt.Errorf("unsupported") +} + +func NewInMemoryRawStore(_ context.Context, _ *Config, metrics *dataStoreMetrics) (RawStore, error) { + self := &InMemoryStore{ + cache: map[DataReference]rawFile{}, + } + + self.copyImpl = newCopyImpl(self, metrics.copyMetrics) + return self, nil +} diff --git a/flytestdlib/storage/mem_store_test.go b/flytestdlib/storage/mem_store_test.go new file mode 100644 index 0000000000..fc58ed1151 --- /dev/null +++ b/flytestdlib/storage/mem_store_test.go @@ -0,0 +1,94 @@ +package storage + +import ( + "bytes" + "context" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestInMemoryStore_Head(t *testing.T) { + t.Run("Empty store", func(t *testing.T) { + s, err := NewInMemoryRawStore(context.TODO(), &Config{}, metrics) + assert.NoError(t, err) + metadata, err := s.Head(context.TODO(), DataReference("hello")) + assert.NoError(t, err) + assert.False(t, metadata.Exists()) + }) + + t.Run("Existing Item", func(t *testing.T) { + s, err := NewInMemoryRawStore(context.TODO(), &Config{}, metrics) + assert.NoError(t, err) + err = s.WriteRaw(context.TODO(), DataReference("hello"), 0, Options{}, bytes.NewReader([]byte{})) + assert.NoError(t, err) + + metadata, err := s.Head(context.TODO(), DataReference("hello")) + assert.NoError(t, err) + assert.True(t, metadata.Exists()) + }) +} + +func TestInMemoryStore_ReadRaw(t *testing.T) { + t.Run("Empty store", func(t *testing.T) { + s, err := NewInMemoryRawStore(context.TODO(), &Config{}, metrics) + assert.NoError(t, err) + + raw, err := s.ReadRaw(context.TODO(), DataReference("hello")) + assert.Error(t, err) + assert.Nil(t, raw) + }) + + t.Run("Existing Item", func(t *testing.T) { + s, err := NewInMemoryRawStore(context.TODO(), &Config{}, metrics) + assert.NoError(t, err) + + err = s.WriteRaw(context.TODO(), DataReference("hello"), 0, Options{}, bytes.NewReader([]byte{})) + assert.NoError(t, err) + + _, err = s.ReadRaw(context.TODO(), DataReference("hello")) + assert.NoError(t, err) + }) +} + +func TestInMemoryStore_Clear(t *testing.T) { + m, err := NewInMemoryRawStore(context.TODO(), &Config{}, metrics) + assert.NoError(t, err) + + mStore := m.(*InMemoryStore) + err = m.WriteRaw(context.TODO(), DataReference("hello"), 0, Options{}, bytes.NewReader([]byte("world"))) + assert.NoError(t, err) + + _, err = m.ReadRaw(context.TODO(), DataReference("hello")) + assert.NoError(t, err) + + err = mStore.Clear(context.TODO()) + assert.NoError(t, err) + + _, err = m.ReadRaw(context.TODO(), DataReference("hello")) + assert.Error(t, err) + assert.True(t, IsNotFound(err)) +} + +func TestInMemoryStore_Delete(t *testing.T) { + m, err := NewInMemoryRawStore(context.TODO(), &Config{}, metrics) + assert.NoError(t, err) + + mStore := m.(*InMemoryStore) + err = m.WriteRaw(context.TODO(), DataReference("hello"), 0, Options{}, bytes.NewReader([]byte("world"))) + assert.NoError(t, err) + + _, err = m.ReadRaw(context.TODO(), DataReference("hello")) + assert.NoError(t, err) + + err = mStore.Delete(context.TODO(), DataReference("hello")) + assert.NoError(t, err) + + _, err = m.ReadRaw(context.TODO(), DataReference("hello")) + assert.Error(t, err) + assert.True(t, IsNotFound(err)) + + err = mStore.Delete(context.TODO(), DataReference("hello")) + assert.Error(t, err) + assert.True(t, IsNotFound(err)) +} diff --git a/flytestdlib/storage/mocks/composed_protobuf_store.go b/flytestdlib/storage/mocks/composed_protobuf_store.go new file mode 100644 index 0000000000..65fba6b1f9 --- /dev/null +++ b/flytestdlib/storage/mocks/composed_protobuf_store.go @@ -0,0 +1,574 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + io "io" + + mock "github.com/stretchr/testify/mock" + + proto "github.com/golang/protobuf/proto" + + storage "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + +// ComposedProtobufStore is an autogenerated mock type for the ComposedProtobufStore type +type ComposedProtobufStore struct { + mock.Mock +} + +type ComposedProtobufStore_Expecter struct { + mock *mock.Mock +} + +func (_m *ComposedProtobufStore) EXPECT() *ComposedProtobufStore_Expecter { + return &ComposedProtobufStore_Expecter{mock: &_m.Mock} +} + +// CopyRaw provides a mock function with given fields: ctx, source, destination, opts +func (_m *ComposedProtobufStore) CopyRaw(ctx context.Context, source storage.DataReference, destination storage.DataReference, opts storage.Options) error { + ret := _m.Called(ctx, source, destination, opts) + + if len(ret) == 0 { + panic("no return value specified for CopyRaw") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference, storage.DataReference, storage.Options) error); ok { + r0 = rf(ctx, source, destination, opts) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// ComposedProtobufStore_CopyRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyRaw' +type ComposedProtobufStore_CopyRaw_Call struct { + *mock.Call +} + +// CopyRaw is a helper method to define mock.On call +// - ctx context.Context +// - source storage.DataReference +// - destination storage.DataReference +// - opts storage.Options +func (_e *ComposedProtobufStore_Expecter) CopyRaw(ctx interface{}, source interface{}, destination interface{}, opts interface{}) *ComposedProtobufStore_CopyRaw_Call { + return &ComposedProtobufStore_CopyRaw_Call{Call: _e.mock.On("CopyRaw", ctx, source, destination, opts)} +} + +func (_c *ComposedProtobufStore_CopyRaw_Call) Run(run func(ctx context.Context, source storage.DataReference, destination storage.DataReference, opts storage.Options)) *ComposedProtobufStore_CopyRaw_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(storage.DataReference), args[2].(storage.DataReference), args[3].(storage.Options)) + }) + return _c +} + +func (_c *ComposedProtobufStore_CopyRaw_Call) Return(_a0 error) *ComposedProtobufStore_CopyRaw_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ComposedProtobufStore_CopyRaw_Call) RunAndReturn(run func(context.Context, storage.DataReference, storage.DataReference, storage.Options) error) *ComposedProtobufStore_CopyRaw_Call { + _c.Call.Return(run) + return _c +} + +// CreateSignedURL provides a mock function with given fields: ctx, reference, properties +func (_m *ComposedProtobufStore) CreateSignedURL(ctx context.Context, reference storage.DataReference, properties storage.SignedURLProperties) (storage.SignedURLResponse, error) { + ret := _m.Called(ctx, reference, properties) + + if len(ret) == 0 { + panic("no return value specified for CreateSignedURL") + } + + var r0 storage.SignedURLResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference, storage.SignedURLProperties) (storage.SignedURLResponse, error)); ok { + return rf(ctx, reference, properties) + } + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference, storage.SignedURLProperties) storage.SignedURLResponse); ok { + r0 = rf(ctx, reference, properties) + } else { + r0 = ret.Get(0).(storage.SignedURLResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, storage.DataReference, storage.SignedURLProperties) error); ok { + r1 = rf(ctx, reference, properties) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ComposedProtobufStore_CreateSignedURL_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSignedURL' +type ComposedProtobufStore_CreateSignedURL_Call struct { + *mock.Call +} + +// CreateSignedURL is a helper method to define mock.On call +// - ctx context.Context +// - reference storage.DataReference +// - properties storage.SignedURLProperties +func (_e *ComposedProtobufStore_Expecter) CreateSignedURL(ctx interface{}, reference interface{}, properties interface{}) *ComposedProtobufStore_CreateSignedURL_Call { + return &ComposedProtobufStore_CreateSignedURL_Call{Call: _e.mock.On("CreateSignedURL", ctx, reference, properties)} +} + +func (_c *ComposedProtobufStore_CreateSignedURL_Call) Run(run func(ctx context.Context, reference storage.DataReference, properties storage.SignedURLProperties)) *ComposedProtobufStore_CreateSignedURL_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(storage.DataReference), args[2].(storage.SignedURLProperties)) + }) + return _c +} + +func (_c *ComposedProtobufStore_CreateSignedURL_Call) Return(_a0 storage.SignedURLResponse, _a1 error) *ComposedProtobufStore_CreateSignedURL_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ComposedProtobufStore_CreateSignedURL_Call) RunAndReturn(run func(context.Context, storage.DataReference, storage.SignedURLProperties) (storage.SignedURLResponse, error)) *ComposedProtobufStore_CreateSignedURL_Call { + _c.Call.Return(run) + return _c +} + +// Delete provides a mock function with given fields: ctx, reference +func (_m *ComposedProtobufStore) Delete(ctx context.Context, reference storage.DataReference) error { + ret := _m.Called(ctx, reference) + + if len(ret) == 0 { + panic("no return value specified for Delete") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference) error); ok { + r0 = rf(ctx, reference) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// ComposedProtobufStore_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type ComposedProtobufStore_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - ctx context.Context +// - reference storage.DataReference +func (_e *ComposedProtobufStore_Expecter) Delete(ctx interface{}, reference interface{}) *ComposedProtobufStore_Delete_Call { + return &ComposedProtobufStore_Delete_Call{Call: _e.mock.On("Delete", ctx, reference)} +} + +func (_c *ComposedProtobufStore_Delete_Call) Run(run func(ctx context.Context, reference storage.DataReference)) *ComposedProtobufStore_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(storage.DataReference)) + }) + return _c +} + +func (_c *ComposedProtobufStore_Delete_Call) Return(_a0 error) *ComposedProtobufStore_Delete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ComposedProtobufStore_Delete_Call) RunAndReturn(run func(context.Context, storage.DataReference) error) *ComposedProtobufStore_Delete_Call { + _c.Call.Return(run) + return _c +} + +// GetBaseContainerFQN provides a mock function with given fields: ctx +func (_m *ComposedProtobufStore) GetBaseContainerFQN(ctx context.Context) storage.DataReference { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for GetBaseContainerFQN") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func(context.Context) storage.DataReference); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// ComposedProtobufStore_GetBaseContainerFQN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBaseContainerFQN' +type ComposedProtobufStore_GetBaseContainerFQN_Call struct { + *mock.Call +} + +// GetBaseContainerFQN is a helper method to define mock.On call +// - ctx context.Context +func (_e *ComposedProtobufStore_Expecter) GetBaseContainerFQN(ctx interface{}) *ComposedProtobufStore_GetBaseContainerFQN_Call { + return &ComposedProtobufStore_GetBaseContainerFQN_Call{Call: _e.mock.On("GetBaseContainerFQN", ctx)} +} + +func (_c *ComposedProtobufStore_GetBaseContainerFQN_Call) Run(run func(ctx context.Context)) *ComposedProtobufStore_GetBaseContainerFQN_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *ComposedProtobufStore_GetBaseContainerFQN_Call) Return(_a0 storage.DataReference) *ComposedProtobufStore_GetBaseContainerFQN_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ComposedProtobufStore_GetBaseContainerFQN_Call) RunAndReturn(run func(context.Context) storage.DataReference) *ComposedProtobufStore_GetBaseContainerFQN_Call { + _c.Call.Return(run) + return _c +} + +// Head provides a mock function with given fields: ctx, reference +func (_m *ComposedProtobufStore) Head(ctx context.Context, reference storage.DataReference) (storage.Metadata, error) { + ret := _m.Called(ctx, reference) + + if len(ret) == 0 { + panic("no return value specified for Head") + } + + var r0 storage.Metadata + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference) (storage.Metadata, error)); ok { + return rf(ctx, reference) + } + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference) storage.Metadata); ok { + r0 = rf(ctx, reference) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(storage.Metadata) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, storage.DataReference) error); ok { + r1 = rf(ctx, reference) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ComposedProtobufStore_Head_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Head' +type ComposedProtobufStore_Head_Call struct { + *mock.Call +} + +// Head is a helper method to define mock.On call +// - ctx context.Context +// - reference storage.DataReference +func (_e *ComposedProtobufStore_Expecter) Head(ctx interface{}, reference interface{}) *ComposedProtobufStore_Head_Call { + return &ComposedProtobufStore_Head_Call{Call: _e.mock.On("Head", ctx, reference)} +} + +func (_c *ComposedProtobufStore_Head_Call) Run(run func(ctx context.Context, reference storage.DataReference)) *ComposedProtobufStore_Head_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(storage.DataReference)) + }) + return _c +} + +func (_c *ComposedProtobufStore_Head_Call) Return(_a0 storage.Metadata, _a1 error) *ComposedProtobufStore_Head_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ComposedProtobufStore_Head_Call) RunAndReturn(run func(context.Context, storage.DataReference) (storage.Metadata, error)) *ComposedProtobufStore_Head_Call { + _c.Call.Return(run) + return _c +} + +// List provides a mock function with given fields: ctx, reference, maxItems, cursor +func (_m *ComposedProtobufStore) List(ctx context.Context, reference storage.DataReference, maxItems int, cursor storage.Cursor) ([]storage.DataReference, storage.Cursor, error) { + ret := _m.Called(ctx, reference, maxItems, cursor) + + if len(ret) == 0 { + panic("no return value specified for List") + } + + var r0 []storage.DataReference + var r1 storage.Cursor + var r2 error + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference, int, storage.Cursor) ([]storage.DataReference, storage.Cursor, error)); ok { + return rf(ctx, reference, maxItems, cursor) + } + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference, int, storage.Cursor) []storage.DataReference); ok { + r0 = rf(ctx, reference, maxItems, cursor) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]storage.DataReference) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, storage.DataReference, int, storage.Cursor) storage.Cursor); ok { + r1 = rf(ctx, reference, maxItems, cursor) + } else { + r1 = ret.Get(1).(storage.Cursor) + } + + if rf, ok := ret.Get(2).(func(context.Context, storage.DataReference, int, storage.Cursor) error); ok { + r2 = rf(ctx, reference, maxItems, cursor) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ComposedProtobufStore_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List' +type ComposedProtobufStore_List_Call struct { + *mock.Call +} + +// List is a helper method to define mock.On call +// - ctx context.Context +// - reference storage.DataReference +// - maxItems int +// - cursor storage.Cursor +func (_e *ComposedProtobufStore_Expecter) List(ctx interface{}, reference interface{}, maxItems interface{}, cursor interface{}) *ComposedProtobufStore_List_Call { + return &ComposedProtobufStore_List_Call{Call: _e.mock.On("List", ctx, reference, maxItems, cursor)} +} + +func (_c *ComposedProtobufStore_List_Call) Run(run func(ctx context.Context, reference storage.DataReference, maxItems int, cursor storage.Cursor)) *ComposedProtobufStore_List_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(storage.DataReference), args[2].(int), args[3].(storage.Cursor)) + }) + return _c +} + +func (_c *ComposedProtobufStore_List_Call) Return(_a0 []storage.DataReference, _a1 storage.Cursor, _a2 error) *ComposedProtobufStore_List_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ComposedProtobufStore_List_Call) RunAndReturn(run func(context.Context, storage.DataReference, int, storage.Cursor) ([]storage.DataReference, storage.Cursor, error)) *ComposedProtobufStore_List_Call { + _c.Call.Return(run) + return _c +} + +// ReadProtobuf provides a mock function with given fields: ctx, reference, msg +func (_m *ComposedProtobufStore) ReadProtobuf(ctx context.Context, reference storage.DataReference, msg proto.Message) error { + ret := _m.Called(ctx, reference, msg) + + if len(ret) == 0 { + panic("no return value specified for ReadProtobuf") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference, proto.Message) error); ok { + r0 = rf(ctx, reference, msg) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// ComposedProtobufStore_ReadProtobuf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadProtobuf' +type ComposedProtobufStore_ReadProtobuf_Call struct { + *mock.Call +} + +// ReadProtobuf is a helper method to define mock.On call +// - ctx context.Context +// - reference storage.DataReference +// - msg proto.Message +func (_e *ComposedProtobufStore_Expecter) ReadProtobuf(ctx interface{}, reference interface{}, msg interface{}) *ComposedProtobufStore_ReadProtobuf_Call { + return &ComposedProtobufStore_ReadProtobuf_Call{Call: _e.mock.On("ReadProtobuf", ctx, reference, msg)} +} + +func (_c *ComposedProtobufStore_ReadProtobuf_Call) Run(run func(ctx context.Context, reference storage.DataReference, msg proto.Message)) *ComposedProtobufStore_ReadProtobuf_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(storage.DataReference), args[2].(proto.Message)) + }) + return _c +} + +func (_c *ComposedProtobufStore_ReadProtobuf_Call) Return(_a0 error) *ComposedProtobufStore_ReadProtobuf_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ComposedProtobufStore_ReadProtobuf_Call) RunAndReturn(run func(context.Context, storage.DataReference, proto.Message) error) *ComposedProtobufStore_ReadProtobuf_Call { + _c.Call.Return(run) + return _c +} + +// ReadRaw provides a mock function with given fields: ctx, reference +func (_m *ComposedProtobufStore) ReadRaw(ctx context.Context, reference storage.DataReference) (io.ReadCloser, error) { + ret := _m.Called(ctx, reference) + + if len(ret) == 0 { + panic("no return value specified for ReadRaw") + } + + var r0 io.ReadCloser + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference) (io.ReadCloser, error)); ok { + return rf(ctx, reference) + } + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference) io.ReadCloser); ok { + r0 = rf(ctx, reference) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(io.ReadCloser) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, storage.DataReference) error); ok { + r1 = rf(ctx, reference) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ComposedProtobufStore_ReadRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadRaw' +type ComposedProtobufStore_ReadRaw_Call struct { + *mock.Call +} + +// ReadRaw is a helper method to define mock.On call +// - ctx context.Context +// - reference storage.DataReference +func (_e *ComposedProtobufStore_Expecter) ReadRaw(ctx interface{}, reference interface{}) *ComposedProtobufStore_ReadRaw_Call { + return &ComposedProtobufStore_ReadRaw_Call{Call: _e.mock.On("ReadRaw", ctx, reference)} +} + +func (_c *ComposedProtobufStore_ReadRaw_Call) Run(run func(ctx context.Context, reference storage.DataReference)) *ComposedProtobufStore_ReadRaw_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(storage.DataReference)) + }) + return _c +} + +func (_c *ComposedProtobufStore_ReadRaw_Call) Return(_a0 io.ReadCloser, _a1 error) *ComposedProtobufStore_ReadRaw_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ComposedProtobufStore_ReadRaw_Call) RunAndReturn(run func(context.Context, storage.DataReference) (io.ReadCloser, error)) *ComposedProtobufStore_ReadRaw_Call { + _c.Call.Return(run) + return _c +} + +// WriteProtobuf provides a mock function with given fields: ctx, reference, opts, msg +func (_m *ComposedProtobufStore) WriteProtobuf(ctx context.Context, reference storage.DataReference, opts storage.Options, msg proto.Message) error { + ret := _m.Called(ctx, reference, opts, msg) + + if len(ret) == 0 { + panic("no return value specified for WriteProtobuf") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference, storage.Options, proto.Message) error); ok { + r0 = rf(ctx, reference, opts, msg) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// ComposedProtobufStore_WriteProtobuf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteProtobuf' +type ComposedProtobufStore_WriteProtobuf_Call struct { + *mock.Call +} + +// WriteProtobuf is a helper method to define mock.On call +// - ctx context.Context +// - reference storage.DataReference +// - opts storage.Options +// - msg proto.Message +func (_e *ComposedProtobufStore_Expecter) WriteProtobuf(ctx interface{}, reference interface{}, opts interface{}, msg interface{}) *ComposedProtobufStore_WriteProtobuf_Call { + return &ComposedProtobufStore_WriteProtobuf_Call{Call: _e.mock.On("WriteProtobuf", ctx, reference, opts, msg)} +} + +func (_c *ComposedProtobufStore_WriteProtobuf_Call) Run(run func(ctx context.Context, reference storage.DataReference, opts storage.Options, msg proto.Message)) *ComposedProtobufStore_WriteProtobuf_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(storage.DataReference), args[2].(storage.Options), args[3].(proto.Message)) + }) + return _c +} + +func (_c *ComposedProtobufStore_WriteProtobuf_Call) Return(_a0 error) *ComposedProtobufStore_WriteProtobuf_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ComposedProtobufStore_WriteProtobuf_Call) RunAndReturn(run func(context.Context, storage.DataReference, storage.Options, proto.Message) error) *ComposedProtobufStore_WriteProtobuf_Call { + _c.Call.Return(run) + return _c +} + +// WriteRaw provides a mock function with given fields: ctx, reference, size, opts, raw +func (_m *ComposedProtobufStore) WriteRaw(ctx context.Context, reference storage.DataReference, size int64, opts storage.Options, raw io.Reader) error { + ret := _m.Called(ctx, reference, size, opts, raw) + + if len(ret) == 0 { + panic("no return value specified for WriteRaw") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference, int64, storage.Options, io.Reader) error); ok { + r0 = rf(ctx, reference, size, opts, raw) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// ComposedProtobufStore_WriteRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteRaw' +type ComposedProtobufStore_WriteRaw_Call struct { + *mock.Call +} + +// WriteRaw is a helper method to define mock.On call +// - ctx context.Context +// - reference storage.DataReference +// - size int64 +// - opts storage.Options +// - raw io.Reader +func (_e *ComposedProtobufStore_Expecter) WriteRaw(ctx interface{}, reference interface{}, size interface{}, opts interface{}, raw interface{}) *ComposedProtobufStore_WriteRaw_Call { + return &ComposedProtobufStore_WriteRaw_Call{Call: _e.mock.On("WriteRaw", ctx, reference, size, opts, raw)} +} + +func (_c *ComposedProtobufStore_WriteRaw_Call) Run(run func(ctx context.Context, reference storage.DataReference, size int64, opts storage.Options, raw io.Reader)) *ComposedProtobufStore_WriteRaw_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(storage.DataReference), args[2].(int64), args[3].(storage.Options), args[4].(io.Reader)) + }) + return _c +} + +func (_c *ComposedProtobufStore_WriteRaw_Call) Return(_a0 error) *ComposedProtobufStore_WriteRaw_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ComposedProtobufStore_WriteRaw_Call) RunAndReturn(run func(context.Context, storage.DataReference, int64, storage.Options, io.Reader) error) *ComposedProtobufStore_WriteRaw_Call { + _c.Call.Return(run) + return _c +} + +// NewComposedProtobufStore creates a new instance of ComposedProtobufStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewComposedProtobufStore(t interface { + mock.TestingT + Cleanup(func()) +}) *ComposedProtobufStore { + mock := &ComposedProtobufStore{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/storage/mocks/metadata.go b/flytestdlib/storage/mocks/metadata.go new file mode 100644 index 0000000000..28ff6cd416 --- /dev/null +++ b/flytestdlib/storage/mocks/metadata.go @@ -0,0 +1,212 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// Metadata is an autogenerated mock type for the Metadata type +type Metadata struct { + mock.Mock +} + +type Metadata_Expecter struct { + mock *mock.Mock +} + +func (_m *Metadata) EXPECT() *Metadata_Expecter { + return &Metadata_Expecter{mock: &_m.Mock} +} + +// ContentMD5 provides a mock function with no fields +func (_m *Metadata) ContentMD5() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for ContentMD5") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// Metadata_ContentMD5_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContentMD5' +type Metadata_ContentMD5_Call struct { + *mock.Call +} + +// ContentMD5 is a helper method to define mock.On call +func (_e *Metadata_Expecter) ContentMD5() *Metadata_ContentMD5_Call { + return &Metadata_ContentMD5_Call{Call: _e.mock.On("ContentMD5")} +} + +func (_c *Metadata_ContentMD5_Call) Run(run func()) *Metadata_ContentMD5_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Metadata_ContentMD5_Call) Return(_a0 string) *Metadata_ContentMD5_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Metadata_ContentMD5_Call) RunAndReturn(run func() string) *Metadata_ContentMD5_Call { + _c.Call.Return(run) + return _c +} + +// Etag provides a mock function with no fields +func (_m *Metadata) Etag() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Etag") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// Metadata_Etag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Etag' +type Metadata_Etag_Call struct { + *mock.Call +} + +// Etag is a helper method to define mock.On call +func (_e *Metadata_Expecter) Etag() *Metadata_Etag_Call { + return &Metadata_Etag_Call{Call: _e.mock.On("Etag")} +} + +func (_c *Metadata_Etag_Call) Run(run func()) *Metadata_Etag_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Metadata_Etag_Call) Return(_a0 string) *Metadata_Etag_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Metadata_Etag_Call) RunAndReturn(run func() string) *Metadata_Etag_Call { + _c.Call.Return(run) + return _c +} + +// Exists provides a mock function with no fields +func (_m *Metadata) Exists() bool { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Exists") + } + + var r0 bool + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// Metadata_Exists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exists' +type Metadata_Exists_Call struct { + *mock.Call +} + +// Exists is a helper method to define mock.On call +func (_e *Metadata_Expecter) Exists() *Metadata_Exists_Call { + return &Metadata_Exists_Call{Call: _e.mock.On("Exists")} +} + +func (_c *Metadata_Exists_Call) Run(run func()) *Metadata_Exists_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Metadata_Exists_Call) Return(_a0 bool) *Metadata_Exists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Metadata_Exists_Call) RunAndReturn(run func() bool) *Metadata_Exists_Call { + _c.Call.Return(run) + return _c +} + +// Size provides a mock function with no fields +func (_m *Metadata) Size() int64 { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Size") + } + + var r0 int64 + if rf, ok := ret.Get(0).(func() int64); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int64) + } + + return r0 +} + +// Metadata_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size' +type Metadata_Size_Call struct { + *mock.Call +} + +// Size is a helper method to define mock.On call +func (_e *Metadata_Expecter) Size() *Metadata_Size_Call { + return &Metadata_Size_Call{Call: _e.mock.On("Size")} +} + +func (_c *Metadata_Size_Call) Run(run func()) *Metadata_Size_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Metadata_Size_Call) Return(_a0 int64) *Metadata_Size_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Metadata_Size_Call) RunAndReturn(run func() int64) *Metadata_Size_Call { + _c.Call.Return(run) + return _c +} + +// NewMetadata creates a new instance of Metadata. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMetadata(t interface { + mock.TestingT + Cleanup(func()) +}) *Metadata { + mock := &Metadata{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/storage/mocks/raw_store.go b/flytestdlib/storage/mocks/raw_store.go new file mode 100644 index 0000000000..8e7a4a0580 --- /dev/null +++ b/flytestdlib/storage/mocks/raw_store.go @@ -0,0 +1,475 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + io "io" + + mock "github.com/stretchr/testify/mock" + + storage "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + +// RawStore is an autogenerated mock type for the RawStore type +type RawStore struct { + mock.Mock +} + +type RawStore_Expecter struct { + mock *mock.Mock +} + +func (_m *RawStore) EXPECT() *RawStore_Expecter { + return &RawStore_Expecter{mock: &_m.Mock} +} + +// CopyRaw provides a mock function with given fields: ctx, source, destination, opts +func (_m *RawStore) CopyRaw(ctx context.Context, source storage.DataReference, destination storage.DataReference, opts storage.Options) error { + ret := _m.Called(ctx, source, destination, opts) + + if len(ret) == 0 { + panic("no return value specified for CopyRaw") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference, storage.DataReference, storage.Options) error); ok { + r0 = rf(ctx, source, destination, opts) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RawStore_CopyRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyRaw' +type RawStore_CopyRaw_Call struct { + *mock.Call +} + +// CopyRaw is a helper method to define mock.On call +// - ctx context.Context +// - source storage.DataReference +// - destination storage.DataReference +// - opts storage.Options +func (_e *RawStore_Expecter) CopyRaw(ctx interface{}, source interface{}, destination interface{}, opts interface{}) *RawStore_CopyRaw_Call { + return &RawStore_CopyRaw_Call{Call: _e.mock.On("CopyRaw", ctx, source, destination, opts)} +} + +func (_c *RawStore_CopyRaw_Call) Run(run func(ctx context.Context, source storage.DataReference, destination storage.DataReference, opts storage.Options)) *RawStore_CopyRaw_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(storage.DataReference), args[2].(storage.DataReference), args[3].(storage.Options)) + }) + return _c +} + +func (_c *RawStore_CopyRaw_Call) Return(_a0 error) *RawStore_CopyRaw_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RawStore_CopyRaw_Call) RunAndReturn(run func(context.Context, storage.DataReference, storage.DataReference, storage.Options) error) *RawStore_CopyRaw_Call { + _c.Call.Return(run) + return _c +} + +// CreateSignedURL provides a mock function with given fields: ctx, reference, properties +func (_m *RawStore) CreateSignedURL(ctx context.Context, reference storage.DataReference, properties storage.SignedURLProperties) (storage.SignedURLResponse, error) { + ret := _m.Called(ctx, reference, properties) + + if len(ret) == 0 { + panic("no return value specified for CreateSignedURL") + } + + var r0 storage.SignedURLResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference, storage.SignedURLProperties) (storage.SignedURLResponse, error)); ok { + return rf(ctx, reference, properties) + } + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference, storage.SignedURLProperties) storage.SignedURLResponse); ok { + r0 = rf(ctx, reference, properties) + } else { + r0 = ret.Get(0).(storage.SignedURLResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, storage.DataReference, storage.SignedURLProperties) error); ok { + r1 = rf(ctx, reference, properties) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RawStore_CreateSignedURL_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSignedURL' +type RawStore_CreateSignedURL_Call struct { + *mock.Call +} + +// CreateSignedURL is a helper method to define mock.On call +// - ctx context.Context +// - reference storage.DataReference +// - properties storage.SignedURLProperties +func (_e *RawStore_Expecter) CreateSignedURL(ctx interface{}, reference interface{}, properties interface{}) *RawStore_CreateSignedURL_Call { + return &RawStore_CreateSignedURL_Call{Call: _e.mock.On("CreateSignedURL", ctx, reference, properties)} +} + +func (_c *RawStore_CreateSignedURL_Call) Run(run func(ctx context.Context, reference storage.DataReference, properties storage.SignedURLProperties)) *RawStore_CreateSignedURL_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(storage.DataReference), args[2].(storage.SignedURLProperties)) + }) + return _c +} + +func (_c *RawStore_CreateSignedURL_Call) Return(_a0 storage.SignedURLResponse, _a1 error) *RawStore_CreateSignedURL_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RawStore_CreateSignedURL_Call) RunAndReturn(run func(context.Context, storage.DataReference, storage.SignedURLProperties) (storage.SignedURLResponse, error)) *RawStore_CreateSignedURL_Call { + _c.Call.Return(run) + return _c +} + +// Delete provides a mock function with given fields: ctx, reference +func (_m *RawStore) Delete(ctx context.Context, reference storage.DataReference) error { + ret := _m.Called(ctx, reference) + + if len(ret) == 0 { + panic("no return value specified for Delete") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference) error); ok { + r0 = rf(ctx, reference) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RawStore_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type RawStore_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - ctx context.Context +// - reference storage.DataReference +func (_e *RawStore_Expecter) Delete(ctx interface{}, reference interface{}) *RawStore_Delete_Call { + return &RawStore_Delete_Call{Call: _e.mock.On("Delete", ctx, reference)} +} + +func (_c *RawStore_Delete_Call) Run(run func(ctx context.Context, reference storage.DataReference)) *RawStore_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(storage.DataReference)) + }) + return _c +} + +func (_c *RawStore_Delete_Call) Return(_a0 error) *RawStore_Delete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RawStore_Delete_Call) RunAndReturn(run func(context.Context, storage.DataReference) error) *RawStore_Delete_Call { + _c.Call.Return(run) + return _c +} + +// GetBaseContainerFQN provides a mock function with given fields: ctx +func (_m *RawStore) GetBaseContainerFQN(ctx context.Context) storage.DataReference { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for GetBaseContainerFQN") + } + + var r0 storage.DataReference + if rf, ok := ret.Get(0).(func(context.Context) storage.DataReference); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + return r0 +} + +// RawStore_GetBaseContainerFQN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBaseContainerFQN' +type RawStore_GetBaseContainerFQN_Call struct { + *mock.Call +} + +// GetBaseContainerFQN is a helper method to define mock.On call +// - ctx context.Context +func (_e *RawStore_Expecter) GetBaseContainerFQN(ctx interface{}) *RawStore_GetBaseContainerFQN_Call { + return &RawStore_GetBaseContainerFQN_Call{Call: _e.mock.On("GetBaseContainerFQN", ctx)} +} + +func (_c *RawStore_GetBaseContainerFQN_Call) Run(run func(ctx context.Context)) *RawStore_GetBaseContainerFQN_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *RawStore_GetBaseContainerFQN_Call) Return(_a0 storage.DataReference) *RawStore_GetBaseContainerFQN_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RawStore_GetBaseContainerFQN_Call) RunAndReturn(run func(context.Context) storage.DataReference) *RawStore_GetBaseContainerFQN_Call { + _c.Call.Return(run) + return _c +} + +// Head provides a mock function with given fields: ctx, reference +func (_m *RawStore) Head(ctx context.Context, reference storage.DataReference) (storage.Metadata, error) { + ret := _m.Called(ctx, reference) + + if len(ret) == 0 { + panic("no return value specified for Head") + } + + var r0 storage.Metadata + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference) (storage.Metadata, error)); ok { + return rf(ctx, reference) + } + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference) storage.Metadata); ok { + r0 = rf(ctx, reference) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(storage.Metadata) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, storage.DataReference) error); ok { + r1 = rf(ctx, reference) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RawStore_Head_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Head' +type RawStore_Head_Call struct { + *mock.Call +} + +// Head is a helper method to define mock.On call +// - ctx context.Context +// - reference storage.DataReference +func (_e *RawStore_Expecter) Head(ctx interface{}, reference interface{}) *RawStore_Head_Call { + return &RawStore_Head_Call{Call: _e.mock.On("Head", ctx, reference)} +} + +func (_c *RawStore_Head_Call) Run(run func(ctx context.Context, reference storage.DataReference)) *RawStore_Head_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(storage.DataReference)) + }) + return _c +} + +func (_c *RawStore_Head_Call) Return(_a0 storage.Metadata, _a1 error) *RawStore_Head_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RawStore_Head_Call) RunAndReturn(run func(context.Context, storage.DataReference) (storage.Metadata, error)) *RawStore_Head_Call { + _c.Call.Return(run) + return _c +} + +// List provides a mock function with given fields: ctx, reference, maxItems, cursor +func (_m *RawStore) List(ctx context.Context, reference storage.DataReference, maxItems int, cursor storage.Cursor) ([]storage.DataReference, storage.Cursor, error) { + ret := _m.Called(ctx, reference, maxItems, cursor) + + if len(ret) == 0 { + panic("no return value specified for List") + } + + var r0 []storage.DataReference + var r1 storage.Cursor + var r2 error + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference, int, storage.Cursor) ([]storage.DataReference, storage.Cursor, error)); ok { + return rf(ctx, reference, maxItems, cursor) + } + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference, int, storage.Cursor) []storage.DataReference); ok { + r0 = rf(ctx, reference, maxItems, cursor) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]storage.DataReference) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, storage.DataReference, int, storage.Cursor) storage.Cursor); ok { + r1 = rf(ctx, reference, maxItems, cursor) + } else { + r1 = ret.Get(1).(storage.Cursor) + } + + if rf, ok := ret.Get(2).(func(context.Context, storage.DataReference, int, storage.Cursor) error); ok { + r2 = rf(ctx, reference, maxItems, cursor) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// RawStore_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List' +type RawStore_List_Call struct { + *mock.Call +} + +// List is a helper method to define mock.On call +// - ctx context.Context +// - reference storage.DataReference +// - maxItems int +// - cursor storage.Cursor +func (_e *RawStore_Expecter) List(ctx interface{}, reference interface{}, maxItems interface{}, cursor interface{}) *RawStore_List_Call { + return &RawStore_List_Call{Call: _e.mock.On("List", ctx, reference, maxItems, cursor)} +} + +func (_c *RawStore_List_Call) Run(run func(ctx context.Context, reference storage.DataReference, maxItems int, cursor storage.Cursor)) *RawStore_List_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(storage.DataReference), args[2].(int), args[3].(storage.Cursor)) + }) + return _c +} + +func (_c *RawStore_List_Call) Return(_a0 []storage.DataReference, _a1 storage.Cursor, _a2 error) *RawStore_List_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *RawStore_List_Call) RunAndReturn(run func(context.Context, storage.DataReference, int, storage.Cursor) ([]storage.DataReference, storage.Cursor, error)) *RawStore_List_Call { + _c.Call.Return(run) + return _c +} + +// ReadRaw provides a mock function with given fields: ctx, reference +func (_m *RawStore) ReadRaw(ctx context.Context, reference storage.DataReference) (io.ReadCloser, error) { + ret := _m.Called(ctx, reference) + + if len(ret) == 0 { + panic("no return value specified for ReadRaw") + } + + var r0 io.ReadCloser + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference) (io.ReadCloser, error)); ok { + return rf(ctx, reference) + } + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference) io.ReadCloser); ok { + r0 = rf(ctx, reference) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(io.ReadCloser) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, storage.DataReference) error); ok { + r1 = rf(ctx, reference) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RawStore_ReadRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadRaw' +type RawStore_ReadRaw_Call struct { + *mock.Call +} + +// ReadRaw is a helper method to define mock.On call +// - ctx context.Context +// - reference storage.DataReference +func (_e *RawStore_Expecter) ReadRaw(ctx interface{}, reference interface{}) *RawStore_ReadRaw_Call { + return &RawStore_ReadRaw_Call{Call: _e.mock.On("ReadRaw", ctx, reference)} +} + +func (_c *RawStore_ReadRaw_Call) Run(run func(ctx context.Context, reference storage.DataReference)) *RawStore_ReadRaw_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(storage.DataReference)) + }) + return _c +} + +func (_c *RawStore_ReadRaw_Call) Return(_a0 io.ReadCloser, _a1 error) *RawStore_ReadRaw_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RawStore_ReadRaw_Call) RunAndReturn(run func(context.Context, storage.DataReference) (io.ReadCloser, error)) *RawStore_ReadRaw_Call { + _c.Call.Return(run) + return _c +} + +// WriteRaw provides a mock function with given fields: ctx, reference, size, opts, raw +func (_m *RawStore) WriteRaw(ctx context.Context, reference storage.DataReference, size int64, opts storage.Options, raw io.Reader) error { + ret := _m.Called(ctx, reference, size, opts, raw) + + if len(ret) == 0 { + panic("no return value specified for WriteRaw") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference, int64, storage.Options, io.Reader) error); ok { + r0 = rf(ctx, reference, size, opts, raw) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RawStore_WriteRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteRaw' +type RawStore_WriteRaw_Call struct { + *mock.Call +} + +// WriteRaw is a helper method to define mock.On call +// - ctx context.Context +// - reference storage.DataReference +// - size int64 +// - opts storage.Options +// - raw io.Reader +func (_e *RawStore_Expecter) WriteRaw(ctx interface{}, reference interface{}, size interface{}, opts interface{}, raw interface{}) *RawStore_WriteRaw_Call { + return &RawStore_WriteRaw_Call{Call: _e.mock.On("WriteRaw", ctx, reference, size, opts, raw)} +} + +func (_c *RawStore_WriteRaw_Call) Run(run func(ctx context.Context, reference storage.DataReference, size int64, opts storage.Options, raw io.Reader)) *RawStore_WriteRaw_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(storage.DataReference), args[2].(int64), args[3].(storage.Options), args[4].(io.Reader)) + }) + return _c +} + +func (_c *RawStore_WriteRaw_Call) Return(_a0 error) *RawStore_WriteRaw_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RawStore_WriteRaw_Call) RunAndReturn(run func(context.Context, storage.DataReference, int64, storage.Options, io.Reader) error) *RawStore_WriteRaw_Call { + _c.Call.Return(run) + return _c +} + +// NewRawStore creates a new instance of RawStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRawStore(t interface { + mock.TestingT + Cleanup(func()) +}) *RawStore { + mock := &RawStore{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/storage/mocks/reference_constructor.go b/flytestdlib/storage/mocks/reference_constructor.go new file mode 100644 index 0000000000..860b421b73 --- /dev/null +++ b/flytestdlib/storage/mocks/reference_constructor.go @@ -0,0 +1,109 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + storage "github.com/flyteorg/flyte/v2/flytestdlib/storage" + mock "github.com/stretchr/testify/mock" +) + +// ReferenceConstructor is an autogenerated mock type for the ReferenceConstructor type +type ReferenceConstructor struct { + mock.Mock +} + +type ReferenceConstructor_Expecter struct { + mock *mock.Mock +} + +func (_m *ReferenceConstructor) EXPECT() *ReferenceConstructor_Expecter { + return &ReferenceConstructor_Expecter{mock: &_m.Mock} +} + +// ConstructReference provides a mock function with given fields: ctx, reference, nestedKeys +func (_m *ReferenceConstructor) ConstructReference(ctx context.Context, reference storage.DataReference, nestedKeys ...string) (storage.DataReference, error) { + _va := make([]interface{}, len(nestedKeys)) + for _i := range nestedKeys { + _va[_i] = nestedKeys[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, reference) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ConstructReference") + } + + var r0 storage.DataReference + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference, ...string) (storage.DataReference, error)); ok { + return rf(ctx, reference, nestedKeys...) + } + if rf, ok := ret.Get(0).(func(context.Context, storage.DataReference, ...string) storage.DataReference); ok { + r0 = rf(ctx, reference, nestedKeys...) + } else { + r0 = ret.Get(0).(storage.DataReference) + } + + if rf, ok := ret.Get(1).(func(context.Context, storage.DataReference, ...string) error); ok { + r1 = rf(ctx, reference, nestedKeys...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ReferenceConstructor_ConstructReference_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConstructReference' +type ReferenceConstructor_ConstructReference_Call struct { + *mock.Call +} + +// ConstructReference is a helper method to define mock.On call +// - ctx context.Context +// - reference storage.DataReference +// - nestedKeys ...string +func (_e *ReferenceConstructor_Expecter) ConstructReference(ctx interface{}, reference interface{}, nestedKeys ...interface{}) *ReferenceConstructor_ConstructReference_Call { + return &ReferenceConstructor_ConstructReference_Call{Call: _e.mock.On("ConstructReference", + append([]interface{}{ctx, reference}, nestedKeys...)...)} +} + +func (_c *ReferenceConstructor_ConstructReference_Call) Run(run func(ctx context.Context, reference storage.DataReference, nestedKeys ...string)) *ReferenceConstructor_ConstructReference_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(storage.DataReference), variadicArgs...) + }) + return _c +} + +func (_c *ReferenceConstructor_ConstructReference_Call) Return(_a0 storage.DataReference, _a1 error) *ReferenceConstructor_ConstructReference_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ReferenceConstructor_ConstructReference_Call) RunAndReturn(run func(context.Context, storage.DataReference, ...string) (storage.DataReference, error)) *ReferenceConstructor_ConstructReference_Call { + _c.Call.Return(run) + return _c +} + +// NewReferenceConstructor creates a new instance of ReferenceConstructor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewReferenceConstructor(t interface { + mock.TestingT + Cleanup(func()) +}) *ReferenceConstructor { + mock := &ReferenceConstructor{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/storage/protobuf_store.go b/flytestdlib/storage/protobuf_store.go new file mode 100644 index 0000000000..59240122a1 --- /dev/null +++ b/flytestdlib/storage/protobuf_store.go @@ -0,0 +1,111 @@ +package storage + +import ( + "bytes" + "context" + "fmt" + "time" + + "github.com/golang/protobuf/proto" + errs "github.com/pkg/errors" + "github.com/prometheus/client_golang/prometheus" + + "github.com/flyteorg/flyte/v2/flytestdlib/ioutils" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/otelutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +type protoMetrics struct { + FetchLatency promutils.StopWatch + MarshalTime promutils.StopWatch + UnmarshalTime promutils.StopWatch + MarshalFailure prometheus.Counter + UnmarshalFailure prometheus.Counter + WriteFailureUnrelatedToCache prometheus.Counter + ReadFailureUnrelatedToCache prometheus.Counter +} + +// Implements ProtobufStore to marshal and unmarshal protobufs to/from a RawStore +type DefaultProtobufStore struct { + RawStore + metrics *protoMetrics +} + +func (s DefaultProtobufStore) ReadProtobuf(ctx context.Context, reference DataReference, msg proto.Message) error { + ctx, span := otelutils.NewSpan(ctx, otelutils.BlobstoreClientTracer, "flytestdlib.storage.DefaultProtobufStore/ReadProtobuf") + defer span.End() + + rc, err := s.ReadRaw(ctx, reference) + if err != nil && !IsFailedWriteToCache(err) { + logger.Errorf(ctx, "Failed to read from the raw store [%s] Error: %v", reference, err) + s.metrics.ReadFailureUnrelatedToCache.Inc() + return errs.Wrap(err, fmt.Sprintf("path:%v", reference)) + } + + defer func() { + err = rc.Close() + if err != nil { + logger.Warnf(ctx, "Failed to close reference [%v]. Error: %v", reference, err) + } + }() + + docContents, err := ioutils.ReadAll(rc, s.metrics.FetchLatency.Start()) + if err != nil { + return errs.Wrap(err, fmt.Sprintf("readAll: %v", reference)) + } + + t := s.metrics.UnmarshalTime.Start() + err = proto.Unmarshal(docContents, msg) + t.Stop() + if err != nil { + s.metrics.UnmarshalFailure.Inc() + return errs.Wrap(err, fmt.Sprintf("unmarshall: %v", reference)) + } + + return nil +} + +func (s DefaultProtobufStore) WriteProtobuf(ctx context.Context, reference DataReference, opts Options, msg proto.Message) error { + ctx, span := otelutils.NewSpan(ctx, otelutils.BlobstoreClientTracer, "flytestdlib.storage.DefaultProtobufStore/WriteProtobuf") + defer span.End() + + t := s.metrics.MarshalTime.Start() + raw, err := proto.Marshal(msg) + t.Stop() + if err != nil { + s.metrics.MarshalFailure.Inc() + return err + } + + err = s.WriteRaw(ctx, reference, int64(len(raw)), opts, bytes.NewReader(raw)) + if err != nil && !IsFailedWriteToCache(err) { + logger.Errorf(ctx, "Failed to write to the raw store [%s] Error: %v", reference, err) + s.metrics.WriteFailureUnrelatedToCache.Inc() + return err + } + return nil +} + +func newProtoMetrics(scope promutils.Scope) *protoMetrics { + return &protoMetrics{ + FetchLatency: scope.MustNewStopWatch("proto_fetch", "Time to read data before unmarshalling", time.Millisecond), + MarshalTime: scope.MustNewStopWatch("marshal", "Time incurred in marshalling data before writing", time.Millisecond), + UnmarshalTime: scope.MustNewStopWatch("unmarshal", "Time incurred in unmarshalling received data", time.Millisecond), + MarshalFailure: scope.MustNewCounter("marshal_failure", "Failures when marshalling"), + UnmarshalFailure: scope.MustNewCounter("unmarshal_failure", "Failures when unmarshalling"), + WriteFailureUnrelatedToCache: scope.MustNewCounter("write_failure_unrelated_to_cache", "Raw store write failures that are not caused by ErrFailedToWriteCache"), + ReadFailureUnrelatedToCache: scope.MustNewCounter("read_failure_unrelated_to_cache", "Raw store read failures that are not caused by ErrFailedToWriteCache"), + } +} + +func NewDefaultProtobufStore(store RawStore, scope promutils.Scope) DefaultProtobufStore { + return NewDefaultProtobufStoreWithMetrics(store, newProtoMetrics(scope)) +} + +func NewDefaultProtobufStoreWithMetrics(store RawStore, metrics *protoMetrics) DefaultProtobufStore { + return DefaultProtobufStore{ + RawStore: store, + metrics: metrics, + } +} diff --git a/flytestdlib/storage/protobuf_store_test.go b/flytestdlib/storage/protobuf_store_test.go new file mode 100644 index 0000000000..019c61e7d4 --- /dev/null +++ b/flytestdlib/storage/protobuf_store_test.go @@ -0,0 +1,173 @@ +package storage + +import ( + "context" + "fmt" + "io" + "math/rand" + "net/http" + "net/http/httptest" + "testing" + + "github.com/golang/protobuf/proto" + errs "github.com/pkg/errors" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/stow/s3" +) + +type mockProtoMessage struct { + X int64 `protobuf:"varint,2,opt,name=x,json=x,proto3" json:"x,omitempty"` +} + +type mockBigDataProtoMessage struct { + X []byte `protobuf:"bytes,1,opt,name=X,proto3" json:"X,omitempty"` +} + +func (mockProtoMessage) Reset() { +} + +func (m mockProtoMessage) String() string { + return proto.CompactTextString(m) +} + +func (mockProtoMessage) ProtoMessage() { +} + +func (mockBigDataProtoMessage) Reset() { +} + +func (m mockBigDataProtoMessage) String() string { + return proto.CompactTextString(m) +} + +func (mockBigDataProtoMessage) ProtoMessage() { +} + +func TestDefaultProtobufStore(t *testing.T) { + t.Run("Read after Write", func(t *testing.T) { + testScope := promutils.NewTestScope() + s, err := NewDataStore(&Config{Type: TypeMemory}, testScope) + assert.NoError(t, err) + + err = s.WriteProtobuf(context.TODO(), "hello", Options{}, &mockProtoMessage{X: 5}) + assert.NoError(t, err) + + m := &mockProtoMessage{} + err = s.ReadProtobuf(context.TODO(), "hello", m) + assert.NoError(t, err) + assert.Equal(t, int64(5), m.X) + }) + + t.Run("RefreshConfig", func(t *testing.T) { + testScope := promutils.NewTestScope() + s, err := NewDataStore(&Config{Type: TypeMemory}, testScope) + require.NoError(t, err) + require.IsType(t, DefaultProtobufStore{}, s.ComposedProtobufStore) + require.IsType(t, &InMemoryStore{}, s.ComposedProtobufStore.(DefaultProtobufStore).RawStore) + + oldMetrics := s.metrics + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + })) + defer server.Close() + + err = s.RefreshConfig(context.TODO(), &Config{ + Type: TypeMinio, + Stow: StowConfig{ + Kind: TypeS3, + Config: map[string]string{ + s3.ConfigAccessKeyID: "key", + s3.ConfigSecretKey: "sec", + s3.ConfigEndpoint: server.URL, + }}, + InitContainer: "b"}) + + assert.NoError(t, err) + require.IsType(t, DefaultProtobufStore{}, s.ComposedProtobufStore) + assert.IsType(t, &StowStore{}, s.ComposedProtobufStore.(DefaultProtobufStore).RawStore) + assert.Equal(t, oldMetrics, s.metrics) + }) + + t.Run("invalid type", func(t *testing.T) { + testScope := promutils.NewTestScope() + + _, err := NewDataStore(&Config{Type: "invalid"}, testScope) + + assert.EqualError(t, err, "type is of an invalid value [invalid]") + }) + + t.Run("coudln't create store", func(t *testing.T) { + testScope := promutils.NewTestScope() + + _, err := NewDataStore(&Config{Type: TypeS3}, testScope) + + assert.EqualError(t, err, "initContainer is required even with `enable-multicontainer`") + }) +} + +func TestDefaultProtobufStore_BigDataReadAfterWrite(t *testing.T) { + t.Run("Read after Write with Big Data", func(t *testing.T) { + testScope := promutils.NewTestScope() + + s, err := NewDataStore( + &Config{ + Type: TypeMemory, + Cache: CachingConfig{ + MaxSizeMegabytes: 1, + TargetGCPercent: 20, + }, + }, testScope) + assert.NoError(t, err) + + bigD := make([]byte, 1.5*1024*1024) + // #nosec G404 + _, err = rand.Read(bigD) + assert.NoError(t, err) + + mockMessage := &mockBigDataProtoMessage{X: bigD} + + err = s.WriteProtobuf(context.TODO(), DataReference("bigK"), Options{}, mockMessage) + assert.NoError(t, err) + + m := &mockBigDataProtoMessage{} + err = s.ReadProtobuf(context.TODO(), DataReference("bigK"), m) + assert.NoError(t, err) + assert.Equal(t, bigD, m.X) + + }) +} + +func TestDefaultProtobufStore_HardErrors(t *testing.T) { + ctx := context.TODO() + k1 := DataReference("k1") + dummyHeadErrorMsg := "Dummy head error" + dummyWriteErrorMsg := "Dummy write error" + dummyReadErrorMsg := "Dummy read error" + store := &dummyStore{ + HeadCb: func(ctx context.Context, reference DataReference) (Metadata, error) { + return MemoryMetadata{}, fmt.Errorf("%s", dummyHeadErrorMsg) //nolint:govet,staticcheck + }, + WriteRawCb: func(ctx context.Context, reference DataReference, size int64, opts Options, raw io.Reader) error { + return fmt.Errorf("%s", dummyWriteErrorMsg) //nolint:govet,staticcheck + }, + ReadRawCb: func(ctx context.Context, reference DataReference) (io.ReadCloser, error) { + return nil, fmt.Errorf("%s", dummyReadErrorMsg) //nolint:govet,staticcheck + }, + } + pbErroneousStore := NewDefaultProtobufStoreWithMetrics(store, metrics.protoMetrics) + t.Run("Test if hard write errors are handled correctly", func(t *testing.T) { + err := pbErroneousStore.WriteProtobuf(ctx, k1, Options{}, &mockProtoMessage{X: 5}) + assert.False(t, IsFailedWriteToCache(err)) + assert.Equal(t, dummyWriteErrorMsg, errs.Cause(err).Error()) + }) + + t.Run("Test if hard read errors are handled correctly", func(t *testing.T) { + m := &mockProtoMessage{} + err := pbErroneousStore.ReadProtobuf(ctx, k1, m) + assert.False(t, IsFailedWriteToCache(err)) + assert.Equal(t, dummyReadErrorMsg, errs.Cause(err).Error()) + }) +} diff --git a/flytestdlib/storage/rawstores.go b/flytestdlib/storage/rawstores.go new file mode 100644 index 0000000000..a8a222a103 --- /dev/null +++ b/flytestdlib/storage/rawstores.go @@ -0,0 +1,120 @@ +package storage + +import ( + "context" + "fmt" + "net/http" + + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +type dataStoreCreateFn func(ctx context.Context, cfg *Config, metrics *dataStoreMetrics) (RawStore, error) + +var stores = map[string]dataStoreCreateFn{ + TypeMemory: NewInMemoryRawStore, + TypeLocal: newStowRawStore, + TypeMinio: newStowRawStore, + TypeS3: newStowRawStore, + TypeStow: newStowRawStore, +} + +type proxyTransport struct { + http.RoundTripper + defaultHeaders map[string][]string +} + +func (p proxyTransport) RoundTrip(r *http.Request) (resp *http.Response, err error) { + applyDefaultHeaders(r, p.defaultHeaders) + return p.RoundTripper.RoundTrip(r) +} + +func applyDefaultHeaders(r *http.Request, headers map[string][]string) { + if r.Header == nil { + r.Header = http.Header{} + } + + for key, values := range headers { + for _, val := range values { + r.Header.Add(key, val) + } + } +} + +func createHTTPClient(cfg HTTPClientConfig) *http.Client { + c := &http.Client{ + Timeout: cfg.Timeout.Duration, + } + + if len(cfg.Headers) > 0 { + c.Transport = &proxyTransport{ + RoundTripper: http.DefaultTransport, + defaultHeaders: cfg.Headers, + } + } + + return c +} + +type dataStoreMetrics struct { + cacheMetrics *cacheMetrics + protoMetrics *protoMetrics + copyMetrics *copyMetrics + stowMetrics *stowMetrics +} + +// newDataStoreMetrics initialises all metrics required for DataStore +func newDataStoreMetrics(scope promutils.Scope) *dataStoreMetrics { + return &dataStoreMetrics{ + cacheMetrics: newCacheMetrics(scope), + protoMetrics: newProtoMetrics(scope), + copyMetrics: newCopyMetrics(scope.NewSubScope("copy")), + stowMetrics: newStowMetrics(scope), + } +} + +// NewDataStore creates a new Data Store with the supplied config. +func NewDataStore(cfg *Config, scope promutils.Scope) (s *DataStore, err error) { + return NewDataStoreWithContext(context.Background(), cfg, scope) +} + +// NewDataStoreWithContext creates a new Data Store with the supplied config and context. +func NewDataStoreWithContext(ctx context.Context, cfg *Config, scope promutils.Scope) (s *DataStore, err error) { + ds := &DataStore{metrics: newDataStoreMetrics(scope)} + return ds, ds.RefreshConfig(ctx, cfg) +} + +// NewCompositeDataStore composes a new DataStore. +func NewCompositeDataStore(refConstructor ReferenceConstructor, composedProtobufStore ComposedProtobufStore) *DataStore { + return &DataStore{ + ReferenceConstructor: refConstructor, + ComposedProtobufStore: composedProtobufStore, + } +} + +// RefreshConfig re-initialises the data store client leaving metrics untouched. +// This is NOT thread-safe! +func (ds *DataStore) RefreshConfig(ctx context.Context, cfg *Config) error { + defaultClient := http.DefaultClient + defer func() { + http.DefaultClient = defaultClient + }() + + http.DefaultClient = createHTTPClient(cfg.DefaultHTTPClient) + + fn, found := stores[cfg.Type] + if !found { + return fmt.Errorf("type is of an invalid value [%v]", cfg.Type) + } + + rawStore, err := fn(ctx, cfg, ds.metrics) + if err != nil { + return err + } + + rawStore = newCachedRawStore(cfg, rawStore, ds.metrics.cacheMetrics) + protoStore := NewDefaultProtobufStoreWithMetrics(rawStore, ds.metrics.protoMetrics) + newDS := NewCompositeDataStore(NewURLPathConstructor(), protoStore) + newDS.metrics = ds.metrics + *ds = *newDS + return nil +} diff --git a/flytestdlib/storage/rawstores_test.go b/flytestdlib/storage/rawstores_test.go new file mode 100644 index 0000000000..58628570a1 --- /dev/null +++ b/flytestdlib/storage/rawstores_test.go @@ -0,0 +1,60 @@ +package storage + +import ( + "net/http" + "testing" + "time" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" +) + +func Test_createHTTPClient(t *testing.T) { + t.Run("empty", func(t *testing.T) { + client := createHTTPClient(HTTPClientConfig{}) + assert.Nil(t, client.Transport) + }) + + t.Run("Some headers", func(t *testing.T) { + m := map[string][]string{ + "Header1": {"val1", "val2"}, + } + + client := createHTTPClient(HTTPClientConfig{ + Headers: m, + }) + + assert.NotNil(t, client.Transport) + proxyTransport, casted := client.Transport.(*proxyTransport) + assert.True(t, casted) + assert.Equal(t, m, proxyTransport.defaultHeaders) + }) + + t.Run("Set empty timeout", func(t *testing.T) { + client := createHTTPClient(HTTPClientConfig{ + Timeout: config.Duration{}, + }) + + assert.Zero(t, client.Timeout) + }) + + t.Run("Set timeout", func(t *testing.T) { + client := createHTTPClient(HTTPClientConfig{ + Timeout: config.Duration{Duration: 2 * time.Second}, + }) + + assert.Equal(t, 2*time.Second, client.Timeout) + }) +} + +func Test_applyDefaultHeaders(t *testing.T) { + input := map[string][]string{ + "Header1": {"val1", "val2"}, + } + + r := &http.Request{} + applyDefaultHeaders(r, input) + + assert.Equal(t, http.Header(input), r.Header) +} diff --git a/flytestdlib/storage/storage.go b/flytestdlib/storage/storage.go new file mode 100644 index 0000000000..5c1d8baa4b --- /dev/null +++ b/flytestdlib/storage/storage.go @@ -0,0 +1,180 @@ +// Package storage defines extensible storage interface. +// This package registers "storage" config section that maps to Config struct. Use NewDataStore(cfg) to initialize a +// DataStore with the provided config. The package provides default implementation to access local, S3 (and minio), +// and In-Memory storage. Use NewCompositeDataStore to swap any portions of the DataStore interface with an external +// implementation (e.g. a cached protobuf store). The underlying storage is provided by extensible "stow" library. You +// can use NewStowRawStore(cfg) to create a Raw store based on any other stow-supported configs (e.g. Azure Blob Storage) +package storage + +import ( + "context" + "fmt" + "io" + "net/url" + "strings" + "time" + + "github.com/golang/protobuf/proto" + + "github.com/flyteorg/stow" +) + +// DataReference defines a reference to data location. +type DataReference string + +var emptyStore = DataStore{} + +// Options holds storage options. It is used to pass Metadata (like headers for S3) and also tags or labels for +// objects +type Options struct { + Metadata map[string]interface{} +} + +// Metadata is a placeholder for data reference metadata. +type Metadata interface { + Exists() bool + Size() int64 + Etag() string + // ContentMD5 retrieves the value of a special metadata tag added by the system that + // contains the MD5 of the uploaded file. If there is no metadata attached + // or that `FlyteContentMD5` key isn't set, ContentMD5 will return empty. + ContentMD5() string +} + +type CursorState int + +const ( + // Enum representing state of the cursor + AtStartCursorState CursorState = 0 + AtEndCursorState CursorState = 1 + AtCustomPosCursorState CursorState = 2 +) + +type Cursor struct { + cursorState CursorState + customPosition string +} + +func NewCursorAtStart() Cursor { + return Cursor{ + cursorState: AtStartCursorState, + customPosition: "", + } +} + +func NewCursorAtEnd() Cursor { + return Cursor{ + cursorState: AtEndCursorState, + customPosition: "", + } +} + +func NewCursorFromCustomPosition(customPosition string) Cursor { + return Cursor{ + cursorState: AtCustomPosCursorState, + customPosition: customPosition, + } +} + +func IsCursorEnd(cursor Cursor) bool { + return cursor.cursorState == AtEndCursorState +} + +// DataStore is a simplified interface for accessing and storing data in one of the Cloud stores. +// Today we rely on Stow for multi-cloud support, but this interface abstracts that part +type DataStore struct { + ComposedProtobufStore + ReferenceConstructor + metrics *dataStoreMetrics +} + +// SignedURLProperties encapsulates properties about the signedURL operation. +type SignedURLProperties struct { + // Scope defines the permission level allowed for the generated URL. + Scope stow.ClientMethod + // ExpiresIn defines the expiration duration for the URL. It's strongly recommended setting it. + ExpiresIn time.Duration + // ContentMD5 defines the expected Base64-encoded 128-bit MD5 hash of the generated file. + // It's strongly recommended setting it.for data integrity checks on the storage backend. + ContentMD5 string + // AddContentMD5Metadata Add ContentMD5 to the metadata of signed URL if true. + AddContentMD5Metadata bool +} + +type SignedURLResponse struct { + URL url.URL + RequiredRequestHeaders map[string]string +} + + +// RawStore defines a low level interface for accessing and storing bytes. +type RawStore interface { + // GetBaseContainerFQN returns a FQN DataReference with the configured base init container + GetBaseContainerFQN(ctx context.Context) DataReference + + // CreateSignedURL creates a signed url with the provided properties. + CreateSignedURL(ctx context.Context, reference DataReference, properties SignedURLProperties) (SignedURLResponse, error) + + // Head gets metadata about the reference. This should generally be a light weight operation. + Head(ctx context.Context, reference DataReference) (Metadata, error) + + // List gets a list of items (relative path to the reference input) given a prefix, using a paginated API + List(ctx context.Context, reference DataReference, maxItems int, cursor Cursor) ([]DataReference, Cursor, error) + + // ReadRaw retrieves a byte array from the Blob store or an error + ReadRaw(ctx context.Context, reference DataReference) (io.ReadCloser, error) + + // WriteRaw stores a raw byte array. + WriteRaw(ctx context.Context, reference DataReference, size int64, opts Options, raw io.Reader) error + + // CopyRaw copies from source to destination. + CopyRaw(ctx context.Context, source, destination DataReference, opts Options) error + + // Delete removes the referenced data from the blob store. + Delete(ctx context.Context, reference DataReference) error +} + + +// ReferenceConstructor defines an interface for building data reference paths. +type ReferenceConstructor interface { + // ConstructReference creates a new dataReference that matches the storage structure. + ConstructReference(ctx context.Context, reference DataReference, nestedKeys ...string) (DataReference, error) + + // FromSignedURL constructs a data reference from a signed URL + //FromSignedURL(ctx context.Context, signedURL string) (DataReference, error) +} + +// ProtobufStore defines an interface for reading and writing protobuf messages +type ProtobufStore interface { + // ReadProtobuf retrieves the entire blob from blobstore and unmarshals it to the passed protobuf + ReadProtobuf(ctx context.Context, reference DataReference, msg proto.Message) error + + // WriteProtobuf serializes and stores the protobuf. + WriteProtobuf(ctx context.Context, reference DataReference, opts Options, msg proto.Message) error +} + + +// ComposedProtobufStore interface includes all the necessary data to allow a ProtobufStore to interact with storage +// through a RawStore. +type ComposedProtobufStore interface { + RawStore + ProtobufStore +} + +// Split splits the data reference into parts. +func (r DataReference) Split() (scheme, container, key string, err error) { + u, err := url.Parse(string(r)) + if err != nil { + return "", "", "", err + } + + return u.Scheme, u.Host, strings.Trim(u.Path, "/"), nil +} + +func (r DataReference) String() string { + return string(r) +} + +func NewDataReference(scheme string, container string, key string) DataReference { + return DataReference(fmt.Sprintf("%s://%s/%s", scheme, container, key)) +} diff --git a/flytestdlib/storage/storage_test.go b/flytestdlib/storage/storage_test.go new file mode 100644 index 0000000000..bc53ae0c5b --- /dev/null +++ b/flytestdlib/storage/storage_test.go @@ -0,0 +1,60 @@ +package storage + +import ( + "context" + "fmt" + "strings" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + +func TestDataReference_New(t *testing.T) { + scheme := "s3" + container := "container" + key := "path/to/file" + dataReference := NewDataReference(scheme, container, key) + assert.Equal(t, DataReference("s3://container/path/to/file"), dataReference) +} + +func TestDataReference_Split(t *testing.T) { + input := DataReference("s3://container/path/to/file") + scheme, container, key, err := input.Split() + + assert.NoError(t, err) + assert.Equal(t, "s3", scheme) + assert.Equal(t, "container", container) + assert.Equal(t, "path/to/file", key) +} + +func ExampleNewDataStore() { + testScope := promutils.NewTestScope() + ctx := context.Background() + fmt.Println("Creating in memory data store.") + store, err := NewDataStore(&Config{ + Type: TypeMemory, + }, testScope.NewSubScope("exp_new")) + + if err != nil { + fmt.Printf("Failed to create data store. Error: %v", err) + } + + ref, err := store.ConstructReference(ctx, DataReference("root"), "subkey", "subkey2") + if err != nil { + fmt.Printf("Failed to construct data reference. Error: %v", err) + } + + fmt.Printf("Constructed data reference [%v] and writing data to it.\n", ref) + + dataToStore := "hello world" + err = store.WriteRaw(ctx, ref, int64(len(dataToStore)), Options{}, strings.NewReader(dataToStore)) + if err != nil { + fmt.Printf("Failed to write data. Error: %v", err) + } + + // Output: + // Creating in memory data store. + // Constructed data reference [/root/subkey/subkey2] and writing data to it. +} diff --git a/flytestdlib/storage/stow_store.go b/flytestdlib/storage/stow_store.go new file mode 100644 index 0000000000..a967b68a53 --- /dev/null +++ b/flytestdlib/storage/stow_store.go @@ -0,0 +1,593 @@ +package storage + +import ( + "context" + "fmt" + "io" + "net/url" + "strconv" + "strings" + "sync" + "time" + + "github.com/aws/aws-sdk-go/aws/awserr" + s32 "github.com/aws/aws-sdk-go/service/s3" + errs "github.com/pkg/errors" + + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils/labeled" + "github.com/flyteorg/stow" + "github.com/flyteorg/stow/azure" + "github.com/flyteorg/stow/google" + "github.com/flyteorg/stow/local" + "github.com/flyteorg/stow/oracle" + "github.com/flyteorg/stow/s3" + "github.com/flyteorg/stow/swift" +) + +const FailureTypeLabel contextutils.Key = "failure_type" +const FlyteContentMD5 = "flyteContentMD5" + +var fQNFn = map[string]func(string) DataReference{ + s3.Kind: func(bucket string) DataReference { + return DataReference(fmt.Sprintf("s3://%s", bucket)) + }, + google.Kind: func(bucket string) DataReference { + return DataReference(fmt.Sprintf("gs://%s", bucket)) + }, + oracle.Kind: func(bucket string) DataReference { + return DataReference(fmt.Sprintf("os://%s", bucket)) + }, + swift.Kind: func(bucket string) DataReference { + return DataReference(fmt.Sprintf("sw://%s", bucket)) + }, + azure.Kind: func(bucket string) DataReference { + return DataReference(fmt.Sprintf("abfs://%s", bucket)) + }, + local.Kind: func(bucket string) DataReference { + return DataReference(fmt.Sprintf("file://%s", bucket)) + }, +} + +// RegisterStowKind registers a new kind of stow store. +func RegisterStowKind(kind string, f func(string) DataReference) error { + if _, ok := fQNFn[kind]; ok { + return fmt.Errorf("kind [%v] already registered", kind) + } + + fQNFn[kind] = f + return nil +} + +// Checks if the error is AWS S3 bucket not found error +func awsBucketIsNotFound(err error) bool { + if awsErr, errOk := errs.Cause(err).(awserr.Error); errOk { + return awsErr.Code() == s32.ErrCodeNoSuchBucket + } + + return false +} + +// Checks if the error is AWS S3 bucket already exists error. +func awsBucketAlreadyExists(err error) bool { + if IsExists(err) { + return true + } + + if awsErr, errOk := errs.Cause(err).(awserr.Error); errOk { + return awsErr.Code() == s32.ErrCodeBucketAlreadyOwnedByYou + } + + return false +} + +// Metrics for Stow store +type stowMetrics struct { + BadReference labeled.Counter + BadContainer labeled.Counter + + HeadFailure labeled.Counter + HeadLatency labeled.StopWatch + HeadLatencyHist labeled.HistogramStopWatch + + ListFailure labeled.Counter + ListLatency labeled.StopWatch + ListLatencyHist labeled.HistogramStopWatch + + ReadFailure labeled.Counter + ReadOpenLatency labeled.StopWatch + ReadOpenLatencyHist labeled.HistogramStopWatch + + WriteFailure labeled.Counter + WriteLatency labeled.StopWatch + WriteLatencyHist labeled.HistogramStopWatch + + DeleteFailure labeled.Counter + DeleteLatency labeled.StopWatch + DeleteLatencyHist labeled.HistogramStopWatch +} + +// StowMetadata that will be returned +type StowMetadata struct { + exists bool + size int64 + etag string + contentMD5 string +} + +func (s StowMetadata) Size() int64 { + return s.size +} + +func (s StowMetadata) Exists() bool { + return s.exists +} + +func (s StowMetadata) Etag() string { + return s.etag +} + +func (s StowMetadata) ContentMD5() string { + return s.contentMD5 +} + +// Implements DataStore to talk to stow location store. +type StowStore struct { + copyImpl + loc stow.Location + signedURLLoc stow.Location + // This is a default configured container. + baseContainer stow.Container + // If dynamic container loading is enabled, then for any new container that is not the base container + // stowstore will dynamically load the given container + enableDynamicContainerLoading bool + // all dynamically loaded containers will be recorded in this map. It is possible that we may load the same container concurrently multiple times + dynamicContainerMap sync.Map + metrics *stowMetrics + baseContainerFQN DataReference +} + +func (s *StowStore) CreateContainer(ctx context.Context, container string) (stow.Container, error) { + return s.createContainer(ctx, locationIDMain, container) +} + +func (s *StowStore) createContainer(ctx context.Context, locID locationID, container string) (stow.Container, error) { + logger.Infof(ctx, "Attempting to create container [%s]", container) + c, err := s.getLocation(locID).CreateContainer(container) + if err != nil && !awsBucketAlreadyExists(err) && !IsExists(err) { + return nil, fmt.Errorf("unable to initialize container [%v]. Error: %v", container, err) + } + return c, nil +} + +func (s *StowStore) LoadContainer(ctx context.Context, container string, createIfNotFound bool) (stow.Container, error) { + return s.loadContainer(ctx, locationIDMain, container, createIfNotFound) +} + +func (s *StowStore) loadContainer(ctx context.Context, locID locationID, container string, createIfNotFound bool) (stow.Container, error) { + c, err := s.getLocation(locID).Container(container) + if err != nil { + // IsNotFound is not always guaranteed to be returned if the underlying container doesn't exist! + // As of stow v0.2.6, the call to get container elides the lookup when a bucket region is set for S3 containers. + if IsNotFound(err) && createIfNotFound { + c, err = s.createContainer(ctx, locID, container) + if err != nil { + logger.Errorf(ctx, "Call to create container [%s] failed. Error %s", container, err) + return nil, err + } + } else { + logger.Errorf(ctx, "Container [%s] lookup failed. Error %s", container, err) + return nil, err + } + } + + return c, nil +} + +func (s *StowStore) getContainer(ctx context.Context, locID locationID, container string) (c stow.Container, err error) { + if s.baseContainer != nil && s.baseContainer.Name() == container && locID == locationIDMain { + return s.baseContainer, nil + } + + if !s.enableDynamicContainerLoading && locID == locationIDMain { + s.metrics.BadContainer.Inc(ctx) + return nil, errs.Wrapf(stow.ErrNotFound, "Conf container:%v != Passed Container:%v. Dynamic loading is disabled", s.baseContainer.Name(), container) + } + + containerID := locID.String() + container + iface, ok := s.dynamicContainerMap.Load(containerID) + if !ok { + c, err := s.loadContainer(ctx, locID, container, false) + if err != nil { + logger.Errorf(ctx, "failed to load container [%s] dynamically, error %s", container, err) + return nil, err + } + + s.dynamicContainerMap.Store(containerID, c) + return c, nil + } + + return iface.(stow.Container), nil +} + +func (s *StowStore) Head(ctx context.Context, reference DataReference) (Metadata, error) { + _, c, k, err := reference.Split() + if err != nil { + s.metrics.BadReference.Inc(ctx) + return nil, err + } + + container, err := s.getContainer(ctx, locationIDMain, c) + if err != nil { + return nil, err + } + + t1 := s.metrics.HeadLatency.Start(ctx) + t2 := s.metrics.HeadLatencyHist.Start(ctx) + item, err := container.Item(k) + t1.Stop() + t2.Stop() + + if err == nil { + if _, err = item.Metadata(); err != nil { + // Err will be caught below + } else if size, err := item.Size(); err != nil { + // Err will be caught below + } else if etag, err := item.ETag(); err != nil { + // Err will be caught below + } else if metadata, err := item.Metadata(); err != nil { + // Err will be caught below + } else { + contentMD5, ok := metadata[strings.ToLower(FlyteContentMD5)].(string) + if !ok { + logger.Infof(ctx, "Failed to cast contentMD5 [%v] to string", contentMD5) + } + return StowMetadata{ + exists: true, + size: size, + etag: etag, + contentMD5: contentMD5, + }, nil + } + } + + if IsNotFound(err) || awsBucketIsNotFound(err) { + return StowMetadata{exists: false}, nil + } + + incFailureCounterForError(ctx, s.metrics.HeadFailure, err) + return StowMetadata{exists: false}, errs.Wrapf(err, "path:%v", k) +} + +func (s *StowStore) List(ctx context.Context, reference DataReference, maxItems int, cursor Cursor) ([]DataReference, Cursor, error) { + _, containerName, key, err := reference.Split() + if err != nil { + s.metrics.BadReference.Inc(ctx) + return nil, NewCursorAtEnd(), err + } + + container, err := s.getContainer(ctx, locationIDMain, containerName) + if err != nil { + return nil, NewCursorAtEnd(), err + } + + t1 := s.metrics.ListLatency.Start(ctx) + t2 := s.metrics.ListLatencyHist.Start(ctx) + var stowCursor string + switch cursor.cursorState { + case AtStartCursorState: + stowCursor = stow.CursorStart + case AtEndCursorState: + return nil, NewCursorAtEnd(), fmt.Errorf("Cursor cannot be at end for the List call") + default: + stowCursor = cursor.customPosition + } + items, stowCursor, err := container.Items(key, stowCursor, maxItems) + t1.Stop() + t2.Stop() + + if err == nil { + results := make([]DataReference, len(items)) + for index, item := range items { + logger.Debugf(ctx, "Stow store appending k=%s url=[%v]", key, item.URL()) + urlPath := item.URL().Path + if strings.HasPrefix(urlPath, "http") { + results[index] = DataReference(urlPath) + } else { + if item.URL().Scheme == "google" { + results[index] = DataReference("https://" + item.URL().Host + "/" + item.URL().Path) + } else { + results[index] = DataReference(item.URL().String()) + } + } + } + if stow.IsCursorEnd(stowCursor) { + cursor = NewCursorAtEnd() + } else { + cursor = NewCursorFromCustomPosition(stowCursor) + } + return results, cursor, nil + } + + incFailureCounterForError(ctx, s.metrics.ListFailure, err) + return nil, NewCursorAtEnd(), errs.Wrapf(err, "path:%v", key) +} + +func (s *StowStore) ReadRaw(ctx context.Context, reference DataReference) (io.ReadCloser, error) { + _, c, k, err := reference.Split() + if err != nil { + s.metrics.BadReference.Inc(ctx) + return nil, err + } + + container, err := s.getContainer(ctx, locationIDMain, c) + if err != nil { + return nil, err + } + + t1 := s.metrics.ReadOpenLatency.Start(ctx) + t2 := s.metrics.ReadOpenLatencyHist.Start(ctx) + item, err := container.Item(k) + t1.Stop() + t2.Stop() + + if err != nil { + incFailureCounterForError(ctx, s.metrics.ReadFailure, err) + return nil, err + } + + sizeBytes, err := item.Size() + if err != nil { + return nil, err + } + + if GetConfig().Limits.GetLimitMegabytes != 0 { + if sizeBytes > GetConfig().Limits.GetLimitMegabytes*MiB { + return nil, errors.Errorf(ErrExceedsLimit, "limit exceeded. %.6fmb > %vmb. You can increase the limit by setting maxDownloadMBs.", float64(sizeBytes)/float64(MiB), GetConfig().Limits.GetLimitMegabytes) + } + } + + return item.Open() +} + +func (s *StowStore) WriteRaw(ctx context.Context, reference DataReference, size int64, opts Options, raw io.Reader) error { + _, c, k, err := reference.Split() + if err != nil { + s.metrics.BadReference.Inc(ctx) + return err + } + + container, err := s.getContainer(ctx, locationIDMain, c) + if err != nil { + return err + } + + t1 := s.metrics.WriteLatency.Start(ctx) + t2 := s.metrics.WriteLatencyHist.Start(ctx) + _, err = container.Put(k, raw, size, opts.Metadata) + t1.Stop() + t2.Stop() + + if err != nil { + // If this error is due to the bucket not existing, first attempt to create it and retry the getContainer call. + if IsNotFound(err) || awsBucketIsNotFound(err) { + container, err = s.CreateContainer(ctx, c) + if err == nil { + s.dynamicContainerMap.Store(container, c) + } + } + if err != nil { + incFailureCounterForError(ctx, s.metrics.WriteFailure, err) + return errs.Wrapf(err, "Failed to write data [%vb] to path [%v].", size, k) + } + } + + return nil +} + +// Delete removes the referenced data from the blob store. +func (s *StowStore) Delete(ctx context.Context, reference DataReference) error { + _, c, k, err := reference.Split() + if err != nil { + s.metrics.BadReference.Inc(ctx) + return err + } + + container, err := s.getContainer(ctx, locationIDMain, c) + if err != nil { + return err + } + + defer s.metrics.DeleteLatency.Start(ctx).Stop() + defer s.metrics.DeleteLatencyHist.Start(ctx).Stop() + + if err := container.RemoveItem(k); err != nil { + incFailureCounterForError(ctx, s.metrics.DeleteFailure, err) + return errs.Wrapf(err, "failed to remove item at path %q from container", k) + } + + return nil +} + +func (s *StowStore) GetBaseContainerFQN(ctx context.Context) DataReference { + return s.baseContainerFQN +} + +func (s *StowStore) CreateSignedURL(ctx context.Context, reference DataReference, properties SignedURLProperties) (SignedURLResponse, error) { + _, container, key, err := reference.Split() + if err != nil { + return SignedURLResponse{}, err + } + + c, err := s.getContainer(ctx, locationIDSignedURL, container) + if err != nil { + return SignedURLResponse{}, err + } + + res, err := c.PreSignRequest(ctx, properties.Scope, key, stow.PresignRequestParams{ + ExpiresIn: properties.ExpiresIn, + ContentMD5: properties.ContentMD5, + AddContentMD5Metadata: properties.AddContentMD5Metadata, + }) + + if err != nil { + return SignedURLResponse{}, err + } + + urlVal, err := url.Parse(res.Url) + if err != nil { + return SignedURLResponse{}, err + } + + return SignedURLResponse{ + URL: *urlVal, + RequiredRequestHeaders: res.RequiredRequestHeaders, + }, nil +} + +type locationID uint + +const ( + locationIDMain locationID = iota + locationIDSignedURL +) + +func (l locationID) String() string { + return strconv.Itoa(int(l)) // #nosec G115 + +} + +func (s *StowStore) getLocation(id locationID) stow.Location { + switch id { + case locationIDSignedURL: + if s.signedURLLoc != nil { + return s.signedURLLoc + } + + fallthrough + default: + return s.loc + } +} + +func NewStowRawStore(baseContainerFQN DataReference, loc, signedURLLoc stow.Location, enableDynamicContainerLoading bool, metrics *dataStoreMetrics) (*StowStore, error) { + self := &StowStore{ + loc: loc, + signedURLLoc: signedURLLoc, + baseContainerFQN: baseContainerFQN, + enableDynamicContainerLoading: enableDynamicContainerLoading, + dynamicContainerMap: sync.Map{}, + metrics: metrics.stowMetrics, + } + + self.copyImpl = newCopyImpl(self, metrics.copyMetrics) + _, c, _, err := baseContainerFQN.Split() + if err != nil { + return nil, err + } + container, err := self.LoadContainer(context.TODO(), c, true) + if err != nil { + return nil, err + } + self.baseContainer = container + return self, nil +} + +func newStowMetrics(scope promutils.Scope) *stowMetrics { + failureTypeOption := labeled.AdditionalLabelsOption{Labels: []string{FailureTypeLabel.String()}} + return &stowMetrics{ + BadReference: labeled.NewCounter("bad_key", "Indicates the provided storage reference/key is incorrectly formatted", scope, labeled.EmitUnlabeledMetric), + BadContainer: labeled.NewCounter("bad_container", "Indicates request for a container that has not been initialized", scope, labeled.EmitUnlabeledMetric), + + HeadFailure: labeled.NewCounter("head_failure", "Indicates failure in HEAD for a given reference", scope, labeled.EmitUnlabeledMetric), + HeadLatency: labeled.NewStopWatch("head", "Indicates time to fetch metadata using the Head API", time.Millisecond, scope, labeled.EmitUnlabeledMetric), + HeadLatencyHist: labeled.NewHistogramStopWatch("head", "Indicates time to fetch metadata using the Head API", scope, labeled.EmitUnlabeledMetric), + + ListFailure: labeled.NewCounter("list_failure", "Indicates failure in item listing for a given reference", scope, labeled.EmitUnlabeledMetric), + ListLatency: labeled.NewStopWatch("list", "Indicates time to fetch item listing using the List API", time.Millisecond, scope, labeled.EmitUnlabeledMetric), + ListLatencyHist: labeled.NewHistogramStopWatch("list", "Indicates time to fetch item listing using the List API", scope, labeled.EmitUnlabeledMetric), + + ReadFailure: labeled.NewCounter("read_failure", "Indicates failure in GET for a given reference", scope, labeled.EmitUnlabeledMetric, failureTypeOption), + ReadOpenLatency: labeled.NewStopWatch("read_open", "Indicates time to first byte when reading", time.Millisecond, scope, labeled.EmitUnlabeledMetric), + ReadOpenLatencyHist: labeled.NewHistogramStopWatch("read_open", "Indicates time to first byte when reading", scope, labeled.EmitUnlabeledMetric), + + WriteFailure: labeled.NewCounter("write_failure", "Indicates failure in storing/PUT for a given reference", scope, labeled.EmitUnlabeledMetric, failureTypeOption), + WriteLatency: labeled.NewStopWatch("write", "Time to write an object irrespective of size", time.Millisecond, scope, labeled.EmitUnlabeledMetric), + WriteLatencyHist: labeled.NewHistogramStopWatch("write", "Time to write an object irrespective of size", scope, labeled.EmitUnlabeledMetric), + + DeleteFailure: labeled.NewCounter("delete_failure", "Indicates failure in removing/DELETE for a given reference", scope, labeled.EmitUnlabeledMetric, failureTypeOption), + DeleteLatency: labeled.NewStopWatch("delete", "Time to delete an object irrespective of size", time.Millisecond, scope, labeled.EmitUnlabeledMetric), + DeleteLatencyHist: labeled.NewHistogramStopWatch("delete", "Time to delete an object irrespective of size", scope, labeled.EmitUnlabeledMetric), + } +} + +// Constructor for the StowRawStore +func newStowRawStore(_ context.Context, cfg *Config, metrics *dataStoreMetrics) (RawStore, error) { + if cfg.InitContainer == "" { + return nil, fmt.Errorf("initContainer is required even with `enable-multicontainer`") + } + + var cfgMap stow.ConfigMap + var kind string + if len(cfg.Stow.Kind) > 0 && len(cfg.Stow.Config) > 0 { + kind = cfg.Stow.Kind + cfgMap = cfg.Stow.Config + } else { + logger.Warnf(context.TODO(), "stow configuration section missing, defaulting to legacy s3/minio connection config") + // This is for supporting legacy configurations which configure S3 via connection config + kind = s3.Kind + cfgMap = legacyS3ConfigMap(cfg.Connection) + } + + fn, ok := fQNFn[kind] + if !ok { + return nil, errs.Errorf("unsupported stow.kind [%s], add support in flytestdlib?", kind) + } + + loc, err := stow.Dial(kind, cfgMap) + if err != nil { + return emptyStore, fmt.Errorf("unable to configure the storage for %s. Error: %v", kind, err) + } + + var signedURLLoc stow.Location + if len(cfg.SignedURL.StowConfigOverride) > 0 { + var newCfg stow.ConfigMap = make(map[string]string, len(cfgMap)) + MergeMaps(newCfg, cfgMap, cfg.SignedURL.StowConfigOverride) + signedURLLoc, err = stow.Dial(kind, newCfg) + if err != nil { + return emptyStore, fmt.Errorf("unable to configure the storage for %s. Error: %v", kind, err) + } + } + + return NewStowRawStore(fn(cfg.InitContainer), loc, signedURLLoc, cfg.MultiContainerEnabled, metrics) +} + +func legacyS3ConfigMap(cfg ConnectionConfig) stow.ConfigMap { + // Non-nullable fields + stowConfig := stow.ConfigMap{ + s3.ConfigAuthType: cfg.AuthType, + s3.ConfigRegion: cfg.Region, + } + + // Fields that differ between minio and real S3 + if endpoint := cfg.Endpoint.String(); endpoint != "" { + stowConfig[s3.ConfigEndpoint] = endpoint + } + + if accessKey := cfg.AccessKey; accessKey != "" { + stowConfig[s3.ConfigAccessKeyID] = accessKey + } + + if secretKey := cfg.SecretKey; secretKey != "" { + stowConfig[s3.ConfigSecretKey] = secretKey + } + + if disableSsl := cfg.DisableSSL; disableSsl { + stowConfig[s3.ConfigDisableSSL] = "True" + } + + return stowConfig +} diff --git a/flytestdlib/storage/stow_store_test.go b/flytestdlib/storage/stow_store_test.go new file mode 100644 index 0000000000..86ab45640b --- /dev/null +++ b/flytestdlib/storage/stow_store_test.go @@ -0,0 +1,903 @@ +package storage + +import ( + "bytes" + "context" + errors2 "errors" + "fmt" + "io" + "io/ioutil" + "net/url" + "os" + "path/filepath" + "sort" + "strconv" + "testing" + "time" + + "github.com/aws/aws-sdk-go/aws/awserr" + s32 "github.com/aws/aws-sdk-go/service/s3" + "github.com/pkg/errors" + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/internal/utils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils/labeled" + "github.com/flyteorg/stow" + "github.com/flyteorg/stow/azure" + "github.com/flyteorg/stow/google" + "github.com/flyteorg/stow/local" + "github.com/flyteorg/stow/oracle" + "github.com/flyteorg/stow/s3" + "github.com/flyteorg/stow/swift" +) + +type mockStowLoc struct { + stow.Location + ContainerCb func(id string) (stow.Container, error) + CreateContainerCb func(name string) (stow.Container, error) +} + +func (m mockStowLoc) Container(id string) (stow.Container, error) { + return m.ContainerCb(id) +} + +func (m mockStowLoc) CreateContainer(name string) (stow.Container, error) { + return m.CreateContainerCb(name) +} + +type mockStowContainer struct { + id string + items map[string]mockStowItem + putCB func(name string, r io.Reader, size int64, metadata map[string]interface{}) (stow.Item, error) +} + +// CreateSignedURL creates a signed url with the provided properties. +func (m mockStowContainer) PreSignRequest(_ context.Context, _ stow.ClientMethod, s string, + _ stow.PresignRequestParams) (response stow.PresignResponse, err error) { + return stow.PresignResponse{Url: s}, nil +} + +func (m mockStowContainer) ID() string { + return m.id +} + +func (m mockStowContainer) Name() string { + return m.id +} + +func (m mockStowContainer) Item(id string) (stow.Item, error) { + if item, found := m.items[id]; found { + return item, nil + } + + return nil, stow.ErrNotFound +} + +func (m mockStowContainer) Items(prefix, cursor string, count int) ([]stow.Item, string, error) { + startIndex := 0 + if cursor != "" { + index, err := strconv.Atoi(cursor) + if err != nil { + return nil, "", fmt.Errorf("Invalid cursor '%s'", cursor) + } + startIndex = index + } + endIndexExc := min(len(m.items), startIndex+count) + + itemKeys := make([]string, len(m.items)) + index := 0 + for key := range m.items { + itemKeys[index] = key + index++ + } + sort.Strings(itemKeys) + + numItems := endIndexExc - startIndex + results := make([]stow.Item, numItems) + for index, itemKey := range itemKeys[startIndex:endIndexExc] { + url := fmt.Sprintf("s3://%s/%s", m.id, m.items[itemKey].url) + results[index] = mockStowItem{url: url, size: m.items[itemKey].size} + } + + if endIndexExc == len(m.items) { + cursor = "" + } else { + cursor = fmt.Sprintf("%d", endIndexExc) + } + return results, cursor, nil +} + +func (m mockStowContainer) RemoveItem(id string) error { + if _, found := m.items[id]; !found { + return stow.ErrNotFound + } + + delete(m.items, id) + + return nil +} + +func (m *mockStowContainer) Put(name string, r io.Reader, size int64, metadata map[string]interface{}) (stow.Item, error) { + if m.putCB != nil { + return m.putCB(name, r, size, metadata) + } + item := mockStowItem{url: name, size: size} + m.items[name] = item + return item, nil +} + +func newMockStowContainer(id string) *mockStowContainer { + return &mockStowContainer{ + id: id, + items: map[string]mockStowItem{}, + } +} + +type mockStowItem struct { + url string + size int64 +} + +func (m mockStowItem) ID() string { + return m.url +} + +func (m mockStowItem) Name() string { + return m.url +} + +func (m mockStowItem) URL() *url.URL { + u, err := url.Parse(m.url) + if err != nil { + panic(err) + } + + return u +} + +func (m mockStowItem) Size() (int64, error) { + return m.size, nil +} + +func (mockStowItem) Open() (io.ReadCloser, error) { + return ioutil.NopCloser(bytes.NewReader([]byte{})), nil +} + +func (mockStowItem) ETag() (string, error) { + return "", nil +} + +func (mockStowItem) LastMod() (time.Time, error) { + return time.Now(), nil +} + +func (mockStowItem) Metadata() (map[string]interface{}, error) { + return map[string]interface{}{}, nil +} + +func TestAwsBucketIsNotFound(t *testing.T) { + t.Run("detect is not found", func(t *testing.T) { + err := awserr.New(s32.ErrCodeNoSuchBucket, "foo", errors2.New("foo")) + assert.True(t, awsBucketIsNotFound(err)) + }) + t.Run("do not detect random errors", func(t *testing.T) { + err := awserr.New(s32.ErrCodeInvalidObjectState, "foo", errors2.New("foo")) + assert.False(t, awsBucketIsNotFound(err)) + }) +} + +func TestStowStore_CreateSignedURL(t *testing.T) { + const container = "container" + t.Run("Happy Path", func(t *testing.T) { + fn := fQNFn["s3"] + s, err := NewStowRawStore(fn(container), &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + if id == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + CreateContainerCb: func(name string) (stow.Container, error) { + if name == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + }, nil, false, metrics) + assert.NoError(t, err) + + actual, err := s.CreateSignedURL(context.TODO(), DataReference("https://container/path"), SignedURLProperties{}) + assert.NoError(t, err) + assert.Equal(t, "path", actual.URL.String()) + }) + + t.Run("Invalid URL", func(t *testing.T) { + fn := fQNFn["s3"] + s, err := NewStowRawStore(fn(container), &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + if id == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + CreateContainerCb: func(name string) (stow.Container, error) { + if name == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + }, nil, false, metrics) + assert.NoError(t, err) + + _, err = s.CreateSignedURL(context.TODO(), DataReference("://container/path"), SignedURLProperties{}) + assert.Error(t, err) + }) + + t.Run("Non existing container", func(t *testing.T) { + fn := fQNFn["s3"] + s, err := NewStowRawStore(fn(container), &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + if id == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + CreateContainerCb: func(name string) (stow.Container, error) { + if name == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + }, nil, false, metrics) + assert.NoError(t, err) + + _, err = s.CreateSignedURL(context.TODO(), DataReference("s3://container2/path"), SignedURLProperties{}) + assert.Error(t, err) + }) +} + +func TestStowStore_ReadRaw(t *testing.T) { + const container = "container" + t.Run("Happy Path", func(t *testing.T) { + ctx := context.Background() + fn := fQNFn["s3"] + s, err := NewStowRawStore(fn(container), &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + if id == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + CreateContainerCb: func(name string) (stow.Container, error) { + if name == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + }, nil, false, metrics) + assert.NoError(t, err) + dataReference := writeTestFile(ctx, t, s, "s3://container/path") + raw, err := s.ReadRaw(ctx, dataReference) + assert.NoError(t, err) + rawBytes, err := ioutil.ReadAll(raw) + assert.NoError(t, err) + assert.Equal(t, 0, len(rawBytes)) + assert.Equal(t, DataReference("s3://container"), s.GetBaseContainerFQN(context.TODO())) + }) + + t.Run("Exceeds limit", func(t *testing.T) { + ctx := context.Background() + fn := fQNFn["s3"] + + s, err := NewStowRawStore(fn(container), &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + if id == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + CreateContainerCb: func(name string) (stow.Container, error) { + if name == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + }, nil, false, metrics) + assert.NoError(t, err) + dataReference := writeTestFileWithSize(ctx, t, s, "s3://container/path", 2*MiB+1) + _, err = s.ReadRaw(ctx, dataReference) + assert.Error(t, err) + assert.True(t, IsExceedsLimit(err)) + assert.NotNil(t, errors.Cause(err)) + }) + + t.Run("No Limit", func(t *testing.T) { + ctx := context.Background() + fn := fQNFn["s3"] + GetConfig().Limits.GetLimitMegabytes = 0 + + s, err := NewStowRawStore(fn(container), &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + if id == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + CreateContainerCb: func(name string) (stow.Container, error) { + if name == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + }, nil, false, metrics) + assert.NoError(t, err) + dataReference := writeTestFileWithSize(ctx, t, s, "s3://container/path", 3*MiB) + _, err = s.ReadRaw(ctx, dataReference) + assert.Nil(t, err) + }) + + t.Run("Happy Path multi-container enabled", func(t *testing.T) { + ctx := context.Background() + fn := fQNFn["s3"] + s, err := NewStowRawStore(fn(container), &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + switch id { + case container: + return newMockStowContainer(container), nil + case "bad-container": + return newMockStowContainer("bad-container"), nil + } + return nil, fmt.Errorf("container is not supported") + }, + CreateContainerCb: func(name string) (stow.Container, error) { + if name == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + }, nil, true, metrics) + assert.NoError(t, err) + dataReference := writeTestFile(ctx, t, s, "s3://bad-container/path") + raw, err := s.ReadRaw(context.TODO(), dataReference) + assert.NoError(t, err) + rawBytes, err := ioutil.ReadAll(raw) + assert.NoError(t, err) + assert.Equal(t, 0, len(rawBytes)) + assert.Equal(t, DataReference("s3://container"), s.GetBaseContainerFQN(context.TODO())) + }) + + t.Run("Happy Path multi-container bad", func(t *testing.T) { + fn := fQNFn["s3"] + s, err := NewStowRawStore(fn(container), &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + if id == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + CreateContainerCb: func(name string) (stow.Container, error) { + if name == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + }, nil, true, metrics) + assert.NoError(t, err) + err = s.WriteRaw(context.TODO(), "s3://bad-container/path", 0, Options{}, bytes.NewReader([]byte{})) + assert.Error(t, err) + _, err = s.Head(context.TODO(), "s3://bad-container/path") + assert.Error(t, err) + _, err = s.ReadRaw(context.TODO(), "s3://bad-container/path") + assert.Error(t, err) + }) +} + +func TestStowStore_List(t *testing.T) { + const container = "container" + t.Run("Listing", func(t *testing.T) { + ctx := context.Background() + fn := fQNFn["s3"] + s, err := NewStowRawStore(fn(container), &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + if id == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + CreateContainerCb: func(name string) (stow.Container, error) { + if name == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + }, nil, false, metrics) + assert.NoError(t, err) + writeTestFile(ctx, t, s, "s3://container/a/1") + writeTestFile(ctx, t, s, "s3://container/a/2") + var maxResults = 10 + var dataReference DataReference = "s3://container/a" + items, cursor, err := s.List(ctx, dataReference, maxResults, NewCursorAtStart()) + assert.NoError(t, err) + assert.Equal(t, NewCursorAtEnd(), cursor) + assert.Equal(t, []DataReference{"s3://container/a/1", "s3://container/a/2"}, items) + }) + + t.Run("Listing with pagination", func(t *testing.T) { + ctx := context.Background() + fn := fQNFn["s3"] + s, err := NewStowRawStore(fn(container), &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + if id == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + CreateContainerCb: func(name string) (stow.Container, error) { + if name == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + }, nil, false, metrics) + assert.NoError(t, err) + writeTestFile(ctx, t, s, "s3://container/a/1") + writeTestFile(ctx, t, s, "s3://container/a/2") + var maxResults = 1 + var dataReference DataReference = "s3://container/a" + items, cursor, err := s.List(ctx, dataReference, maxResults, NewCursorAtStart()) + assert.NoError(t, err) + assert.Equal(t, []DataReference{"s3://container/a/1"}, items) + items, _, err = s.List(ctx, dataReference, maxResults, cursor) + assert.NoError(t, err) + assert.Equal(t, []DataReference{"s3://container/a/2"}, items) + }) +} + +func TestNewLocalStore(t *testing.T) { + labeled.SetMetricKeys(contextutils.ProjectKey, contextutils.DomainKey, contextutils.WorkflowIDKey, contextutils.TaskIDKey) + t.Run("Valid config", func(t *testing.T) { + store, err := newStowRawStore(context.TODO(), &Config{ + Stow: StowConfig{ + Kind: local.Kind, + Config: map[string]string{ + local.ConfigKeyPath: "./", + }, + }, + InitContainer: "testdata", + }, metrics) + + assert.NoError(t, err) + assert.NotNil(t, store) + + // Stow local store expects the full path after the container portion (looks like a bug to me) + rc, err := store.ReadRaw(context.TODO(), DataReference("file://testdata/config.yaml")) + assert.NoError(t, err) + if assert.NotNil(t, rc) { + assert.NoError(t, rc.Close()) + } + }) + + t.Run("Invalid config", func(t *testing.T) { + _, err := newStowRawStore(context.TODO(), &Config{}, metrics) + assert.Error(t, err) + }) + + t.Run("Initialize container", func(t *testing.T) { + tmpDir, err := ioutil.TempDir("", "stdlib_local") + assert.NoError(t, err) + + stats, err := os.Stat(tmpDir) + assert.NoError(t, err) + assert.NotNil(t, stats) + + store, err := newStowRawStore(context.TODO(), &Config{ + Stow: StowConfig{ + Kind: local.Kind, + Config: map[string]string{ + local.ConfigKeyPath: tmpDir, + }, + }, + InitContainer: "tmp", + }, metrics) + + assert.NoError(t, err) + assert.NotNil(t, store) + + stats, err = os.Stat(filepath.Join(tmpDir, "tmp")) + assert.NoError(t, err) + if assert.NotNil(t, stats) { + assert.True(t, stats.IsDir()) + } + }) + + t.Run("missing init container", func(t *testing.T) { + tmpDir, err := ioutil.TempDir("", "stdlib_local") + assert.NoError(t, err) + + stats, err := os.Stat(tmpDir) + assert.NoError(t, err) + assert.NotNil(t, stats) + + store, err := newStowRawStore(context.TODO(), &Config{ + Stow: StowConfig{ + Kind: local.Kind, + Config: map[string]string{ + local.ConfigKeyPath: tmpDir, + }, + }, + }, metrics) + + assert.Error(t, err) + assert.Nil(t, store) + }) + + t.Run("multi-container enabled", func(t *testing.T) { + tmpDir, err := ioutil.TempDir("", "stdlib_local") + assert.NoError(t, err) + + stats, err := os.Stat(tmpDir) + assert.NoError(t, err) + assert.NotNil(t, stats) + + store, err := newStowRawStore(context.TODO(), &Config{ + Stow: StowConfig{ + Kind: local.Kind, + Config: map[string]string{ + local.ConfigKeyPath: tmpDir, + }, + }, + InitContainer: "tmp", + MultiContainerEnabled: true, + }, metrics) + + assert.NoError(t, err) + assert.NotNil(t, store) + + stats, err = os.Stat(filepath.Join(tmpDir, "tmp")) + assert.NoError(t, err) + if assert.NotNil(t, stats) { + assert.True(t, stats.IsDir()) + } + }) +} + +func Test_newStowRawStore(t *testing.T) { + type args struct { + cfg *Config + } + tests := []struct { + name string + args args + wantErr bool + }{ + {"fail", args{&Config{}}, true}, + {"google", args{&Config{ + InitContainer: "flyte", + Stow: StowConfig{ + Kind: google.Kind, + Config: map[string]string{ + google.ConfigProjectId: "x", + google.ConfigScopes: "y", + }, + }, + }}, true}, + {"minio", args{&Config{ + Type: TypeMinio, + InitContainer: "some-container", + Connection: ConnectionConfig{ + Endpoint: config.URL{URL: utils.MustParseURL("http://minio:9000")}, + }, + }}, true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := newStowRawStore(context.TODO(), tt.args.cfg, metrics) + if tt.wantErr { + assert.Error(t, err, "newStowRawStore() error = %v, wantErr %v", err, tt.wantErr) + return + } + assert.NotNil(t, got, "Expected rawstore, found nil!") + }) + } +} + +func TestLoadContainer(t *testing.T) { + container := "container" + t.Run("Create if not found", func(t *testing.T) { + stowStore := StowStore{ + loc: &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + if id == container { + return newMockStowContainer(container), stow.ErrNotFound + } + return nil, fmt.Errorf("container is not supported") + }, + CreateContainerCb: func(name string) (stow.Container, error) { + if name == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + }, + } + stowContainer, err := stowStore.LoadContainer(context.Background(), "container", true) + assert.NoError(t, err) + assert.Equal(t, container, stowContainer.ID()) + }) + t.Run("Create if not found with error", func(t *testing.T) { + stowStore := StowStore{ + loc: &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + return nil, stow.ErrNotFound + }, + CreateContainerCb: func(name string) (stow.Container, error) { + if name == container { + return nil, fmt.Errorf("foo") + } + return nil, fmt.Errorf("container is not supported") + }, + }, + } + _, err := stowStore.LoadContainer(context.TODO(), "container", true) + assert.EqualError(t, err, "unable to initialize container [container]. Error: foo") + }) + t.Run("No create if not found", func(t *testing.T) { + stowStore := StowStore{ + loc: &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + if id == container { + return newMockStowContainer(container), stow.ErrNotFound + } + return nil, fmt.Errorf("container is not supported") + }, + }, + } + _, err := stowStore.LoadContainer(context.TODO(), "container", false) + assert.EqualError(t, err, stow.ErrNotFound.Error()) + }) +} + +func TestStowStore_WriteRaw(t *testing.T) { + labeled.SetMetricKeys(contextutils.ProjectKey, contextutils.DomainKey, contextutils.WorkflowIDKey, contextutils.TaskIDKey) + const container = "container" + fn := fQNFn["s3"] + t.Run("create container when not found", func(t *testing.T) { + var createCalled bool + s, err := NewStowRawStore(fn(container), &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + if id == container { + mockStowContainer := newMockStowContainer(container) + mockStowContainer.putCB = func(name string, r io.Reader, size int64, metadata map[string]interface{}) (stow.Item, error) { + return nil, awserr.New(s32.ErrCodeNoSuchBucket, "foo", errors2.New("foo")) + } + return mockStowContainer, nil + } + return nil, fmt.Errorf("container is not supported") + }, + CreateContainerCb: func(name string) (stow.Container, error) { + createCalled = true + if name == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + }, nil, true, metrics) + assert.NoError(t, err) + err = s.WriteRaw(context.TODO(), DataReference("s3://container/path"), 0, Options{}, bytes.NewReader([]byte{})) + assert.NoError(t, err) + assert.True(t, createCalled) + var containerStoredInDynamicContainerMap bool + s.dynamicContainerMap.Range(func(key, value interface{}) bool { + if value == container { + containerStoredInDynamicContainerMap = true + return true + } + return false + }) + assert.True(t, containerStoredInDynamicContainerMap) + }) + t.Run("bubble up generic put errors", func(t *testing.T) { + s, err := NewStowRawStore(fn(container), &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + if id == container { + mockStowContainer := newMockStowContainer(container) + mockStowContainer.putCB = func(name string, r io.Reader, size int64, metadata map[string]interface{}) (stow.Item, error) { + return nil, errors2.New("foo") + } + return mockStowContainer, nil + } + return nil, fmt.Errorf("container is not supported") + }, + }, nil, true, metrics) + assert.NoError(t, err) + err = s.WriteRaw(context.TODO(), DataReference("s3://container/path"), 0, Options{}, bytes.NewReader([]byte{})) + assert.EqualError(t, err, "Failed to write data [0b] to path [path].: foo") + }) +} + +func TestStowStore_fQNFn(t *testing.T) { + assert.Equal(t, DataReference("s3://bucket"), fQNFn[s3.Kind]("bucket")) + assert.Equal(t, DataReference("gs://bucket"), fQNFn[google.Kind]("bucket")) + assert.Equal(t, DataReference("os://bucket"), fQNFn[oracle.Kind]("bucket")) + assert.Equal(t, DataReference("sw://bucket"), fQNFn[swift.Kind]("bucket")) + assert.Equal(t, DataReference("abfs://bucket"), fQNFn[azure.Kind]("bucket")) + assert.Equal(t, DataReference("file://bucket"), fQNFn[local.Kind]("bucket")) +} + +func TestStowStore_Delete(t *testing.T) { + const container = "container" + + t.Run("Happy Path", func(t *testing.T) { + ctx := context.TODO() + fn := fQNFn["s3"] + + s, err := NewStowRawStore(fn(container), &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + if id == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + CreateContainerCb: func(name string) (stow.Container, error) { + if name == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + }, nil, false, metrics) + assert.NoError(t, err) + + dataReference := writeTestFile(ctx, t, s, "s3://container/path") + + err = s.Delete(ctx, dataReference) + assert.NoError(t, err) + + metadata, err := s.Head(ctx, dataReference) + assert.NoError(t, err) + assert.False(t, metadata.Exists()) + }) + + t.Run("Happy Path multi-container enabled", func(t *testing.T) { + ctx := context.TODO() + fn := fQNFn["s3"] + + s, err := NewStowRawStore(fn(container), &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + switch id { + case container: + return newMockStowContainer(container), nil + case "bad-container": + return newMockStowContainer("bad-container"), nil + } + return nil, fmt.Errorf("container is not supported") + }, + CreateContainerCb: func(name string) (stow.Container, error) { + if name == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + }, nil, true, metrics) + assert.NoError(t, err) + + dataReference := writeTestFile(ctx, t, s, "s3://container/path") + dataReference2 := writeTestFile(ctx, t, s, "s3://bad-container/path") + + err = s.Delete(ctx, dataReference) + assert.NoError(t, err) + err = s.Delete(ctx, dataReference2) + assert.NoError(t, err) + + metadata, err := s.Head(ctx, dataReference) + assert.NoError(t, err) + assert.False(t, metadata.Exists()) + metadata, err = s.Head(ctx, dataReference2) + assert.NoError(t, err) + assert.False(t, metadata.Exists()) + }) + + t.Run("Unknown item", func(t *testing.T) { + ctx := context.TODO() + fn := fQNFn["s3"] + + s, err := NewStowRawStore(fn(container), &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + if id == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + CreateContainerCb: func(name string) (stow.Container, error) { + if name == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + }, nil, false, metrics) + assert.NoError(t, err) + + dataReference := writeTestFile(ctx, t, s, "s3://container/path") + + err = s.Delete(ctx, DataReference("s3://container/bad-path")) + assert.Error(t, err) + assert.True(t, errors.Is(err, stow.ErrNotFound)) + + metadata, err := s.Head(ctx, dataReference) + assert.NoError(t, err) + assert.True(t, metadata.Exists()) + }) + + t.Run("Unknown container", func(t *testing.T) { + ctx := context.TODO() + fn := fQNFn["s3"] + + s, err := NewStowRawStore(fn(container), &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + if id == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + CreateContainerCb: func(name string) (stow.Container, error) { + if name == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + }, nil, false, metrics) + assert.NoError(t, err) + + dataReference := writeTestFile(ctx, t, s, "s3://container/path") + + err = s.Delete(ctx, DataReference("s3://bad-container/path")) + assert.Error(t, err) + assert.True(t, errors.Is(err, stow.ErrNotFound)) + + metadata, err := s.Head(ctx, dataReference) + assert.NoError(t, err) + assert.True(t, metadata.Exists()) + }) + + t.Run("Invalid data reference", func(t *testing.T) { + ctx := context.TODO() + fn := fQNFn["s3"] + + s, err := NewStowRawStore(fn(container), &mockStowLoc{ + ContainerCb: func(id string) (stow.Container, error) { + if id == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + CreateContainerCb: func(name string) (stow.Container, error) { + if name == container { + return newMockStowContainer(container), nil + } + return nil, fmt.Errorf("container is not supported") + }, + }, nil, false, metrics) + assert.NoError(t, err) + + err = s.Delete(ctx, DataReference("://bad-container/path")) + assert.Error(t, err) + }) +} + +func writeTestFile(ctx context.Context, t *testing.T, s *StowStore, path string) DataReference { + return writeTestFileWithSize(ctx, t, s, path, 0) +} + +func writeTestFileWithSize(ctx context.Context, t *testing.T, s *StowStore, path string, size int64) DataReference { + reference := DataReference(path) + + err := s.WriteRaw(ctx, reference, size, Options{}, bytes.NewReader([]byte{})) + assert.NoError(t, err) + + metadata, err := s.Head(ctx, reference) + assert.NoError(t, err) + assert.True(t, metadata.Exists()) + + return reference +} diff --git a/flytestdlib/storage/testdata/config.yaml b/flytestdlib/storage/testdata/config.yaml new file mode 100755 index 0000000000..84810ab38a --- /dev/null +++ b/flytestdlib/storage/testdata/config.yaml @@ -0,0 +1,17 @@ +cache: + max_size_mbs: 0 + target_gc_percent: 0 +connection: + access-key: minio + auth-type: accesskey + disable-ssl: true + endpoint: http://minio:9000 + region: us-east-1 + secret-key: miniostorage +container: "" +defaultHttpClient: + headers: null + timeout: 0s +limits: + maxDownloadMBs: 0 +type: s3 diff --git a/flytestdlib/storage/url_path.go b/flytestdlib/storage/url_path.go new file mode 100644 index 0000000000..2c7ba3c49a --- /dev/null +++ b/flytestdlib/storage/url_path.go @@ -0,0 +1,52 @@ +package storage + +import ( + "context" + "fmt" + "net/url" + "strings" + + "github.com/pkg/errors" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +const ( + separator = "/" +) + +// URLPathConstructor implements ReferenceConstructor that assumes paths are URL-compatible. +type URLPathConstructor struct { +} + +func ensureEndingPathSeparator(path DataReference) DataReference { + if len(path) > 0 && path[len(path)-1] == separator[0] { + return path + } + + return path + separator +} + +func (URLPathConstructor) ConstructReference(ctx context.Context, reference DataReference, nestedKeys ...string) (DataReference, error) { + u, err := url.Parse(string(ensureEndingPathSeparator(reference))) + if err != nil { + logger.Errorf(ctx, "Failed to parse prefix: %v", reference) + return "", errors.Wrap(err, fmt.Sprintf("Reference is of an invalid format [%v]", reference)) + } + + rel, err := url.Parse(strings.Join(MapStrings(func(s string) string { + return strings.Trim(s, separator) + }, nestedKeys...), separator)) + if err != nil { + logger.Errorf(ctx, "Failed to parse nested keys: %v", reference) + return "", errors.Wrap(err, fmt.Sprintf("Reference is of an invalid format [%v]", reference)) + } + + u = u.ResolveReference(rel) + + return DataReference(u.String()), nil +} + +func NewURLPathConstructor() URLPathConstructor { + return URLPathConstructor{} +} diff --git a/flytestdlib/storage/url_path_test.go b/flytestdlib/storage/url_path_test.go new file mode 100644 index 0000000000..c933b8274e --- /dev/null +++ b/flytestdlib/storage/url_path_test.go @@ -0,0 +1,27 @@ +package storage + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestUrlPathConstructor_ConstructReference(t *testing.T) { + s := URLPathConstructor{} + t.Run("happy path", func(t *testing.T) { + r, err := s.ConstructReference(context.TODO(), DataReference("hello"), "key1", "key2/", "key3") + assert.NoError(t, err) + assert.Equal(t, "/hello/key1/key2/key3", r.String()) + }) + + t.Run("failed to parse base path", func(t *testing.T) { + _, err := s.ConstructReference(context.TODO(), DataReference("*&^#&$@:%//"), "key1", "key2/", "key3") + assert.Error(t, err) + }) + + t.Run("failed to parse nestedKeys", func(t *testing.T) { + _, err := s.ConstructReference(context.TODO(), DataReference("*&^#&$@://"), "key1%", "key2/", "key3") + assert.Error(t, err) + }) +} diff --git a/flytestdlib/storage/utils.go b/flytestdlib/storage/utils.go new file mode 100644 index 0000000000..f3cf25288f --- /dev/null +++ b/flytestdlib/storage/utils.go @@ -0,0 +1,88 @@ +package storage + +import ( + "context" + "os" + + "github.com/pkg/errors" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + stdErrs "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils/labeled" + "github.com/flyteorg/stow" +) + +var ( + ErrExceedsLimit stdErrs.ErrorCode = "LIMIT_EXCEEDED" + ErrFailedToWriteCache stdErrs.ErrorCode = "CACHE_WRITE_FAILED" +) + +const ( + genericFailureTypeLabel = "Generic" +) + +// IsNotFound gets a value indicating whether the underlying error is a Not Found error. +func IsNotFound(err error) bool { + if root := errors.Cause(err); os.IsNotExist(root) { + return true + } + + if stdErrs.IsCausedByError(err, stow.ErrNotFound) { + return true + } + + if status.Code(err) == codes.NotFound { + return true + } + + return false +} + +// IsExists gets a value indicating whether the underlying error is "already exists" error. +func IsExists(err error) bool { + if root := errors.Cause(err); os.IsExist(root) { + return true + } + + return false +} + +// IsExceedsLimit gets a value indicating whether the root cause of error is a "limit exceeded" error. +func IsExceedsLimit(err error) bool { + return stdErrs.IsCausedBy(err, ErrExceedsLimit) +} + +func IsFailedWriteToCache(err error) bool { + return stdErrs.IsCausedBy(err, ErrFailedToWriteCache) +} + +func MapStrings(mapper func(string) string, strings ...string) []string { + if strings == nil { + return []string{} + } + + for i, str := range strings { + strings[i] = mapper(str) + } + + return strings +} + +// MergeMaps merges all src maps into dst in order. +func MergeMaps(dst map[string]string, src ...map[string]string) { + for _, m := range src { + for k, v := range m { + dst[k] = v + } + } +} + +func incFailureCounterForError(ctx context.Context, counter labeled.Counter, err error) { + errCode, found := stdErrs.GetErrorCode(err) + if found { + counter.Inc(context.WithValue(ctx, FailureTypeLabel, errCode)) + } else { + counter.Inc(context.WithValue(ctx, FailureTypeLabel, genericFailureTypeLabel)) + } +} diff --git a/flytestdlib/storage/utils_test.go b/flytestdlib/storage/utils_test.go new file mode 100644 index 0000000000..f0ee551568 --- /dev/null +++ b/flytestdlib/storage/utils_test.go @@ -0,0 +1,76 @@ +package storage + +import ( + "os" + "syscall" + "testing" + + "github.com/pkg/errors" + "github.com/stretchr/testify/assert" + + flyteerrors "github.com/flyteorg/flyte/v2/flytestdlib/errors" + "github.com/flyteorg/stow" +) + +func TestIsNotFound(t *testing.T) { + sysError := &os.PathError{Err: syscall.ENOENT} + assert.True(t, IsNotFound(sysError)) + flyteError := errors.Wrap(sysError, "Wrapping \"system not found\" error") + assert.True(t, IsNotFound(flyteError)) + secondLevelError := errors.Wrap(flyteError, "Higher level error") + assert.True(t, IsNotFound(secondLevelError)) + + // more for stow errors + stowNotFoundError := stow.ErrNotFound + assert.True(t, IsNotFound(stowNotFoundError)) + flyteError = errors.Wrap(stowNotFoundError, "Wrapping stow.ErrNotFound") + assert.True(t, IsNotFound(flyteError)) + secondLevelError = errors.Wrap(flyteError, "Higher level error wrapper of the stow.ErrNotFound error") + assert.True(t, IsNotFound(secondLevelError)) +} + +func TestIsExceedsLimit(t *testing.T) { + sysError := &os.PathError{Err: syscall.ENOENT} + exceedsLimitError := flyteerrors.Wrapf(ErrExceedsLimit, sysError, "An error wrapped in ErrExceedsLimits") + failedToWriteCacheError := flyteerrors.Wrapf(ErrFailedToWriteCache, sysError, "An error wrapped in ErrFailedToWriteCache") + + assert.True(t, IsExceedsLimit(exceedsLimitError)) + assert.False(t, IsExceedsLimit(failedToWriteCacheError)) + assert.False(t, IsExceedsLimit(sysError)) +} + +func TestIsFailedWriteToCache(t *testing.T) { + sysError := &os.PathError{Err: syscall.ENOENT} + exceedsLimitError := flyteerrors.Wrapf(ErrExceedsLimit, sysError, "An error wrapped in ErrExceedsLimits") + failedToWriteCacheError := flyteerrors.Wrapf(ErrFailedToWriteCache, sysError, "An error wrapped in ErrFailedToWriteCache") + + assert.False(t, IsFailedWriteToCache(exceedsLimitError)) + assert.True(t, IsFailedWriteToCache(failedToWriteCacheError)) + assert.False(t, IsFailedWriteToCache(sysError)) +} + +func TestMapStrings(t *testing.T) { + t.Run("nothing", func(t *testing.T) { + assert.Equal(t, []string{}, MapStrings(func(s string) string { + return s + })) + }) + + t.Run("one item", func(t *testing.T) { + assert.Equal(t, []string{"item"}, MapStrings(func(s string) string { + return s + }, "item")) + }) + + t.Run("const", func(t *testing.T) { + assert.Equal(t, []string{"something"}, MapStrings(func(s string) string { + return "something" + }, "item")) + }) + + t.Run("half string", func(t *testing.T) { + assert.Equal(t, []string{"thing", "some"}, MapStrings(func(s string) string { + return s[len(s)/2:] + }, "something", "somesome")) + }) +} diff --git a/flytestdlib/tests/config_test.go b/flytestdlib/tests/config_test.go new file mode 100644 index 0000000000..b6eb724af2 --- /dev/null +++ b/flytestdlib/tests/config_test.go @@ -0,0 +1,77 @@ +package tests + +import ( + "context" + "flag" + "os" + "path/filepath" + "reflect" + "testing" + + "github.com/ghodss/yaml" + "github.com/stretchr/testify/assert" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/config/viper" + "github.com/flyteorg/flyte/v2/flytestdlib/internal/utils" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" +) + +// Make sure existing config file(s) parse correctly before overriding them with this flag! +var update = flag.Bool("update", false, "Updates testdata") + +func TestStorageAndLoggerConfig(t *testing.T) { + type CompositeConfig struct { + Storage storage.Config `json:"storage"` + Logger logger.Config `json:"logger"` + } + + expected := CompositeConfig{ + Storage: storage.Config{ + Type: "s3", + Connection: storage.ConnectionConfig{ + Endpoint: config.URL{URL: utils.MustParseURL("http://minio:9000")}, + AuthType: "accesskey", + AccessKey: "minio", + SecretKey: "miniostorage", + Region: "us-east-1", + DisableSSL: true, + }, + }, + Logger: logger.Config{ + Level: logger.DebugLevel, + }, + } + + configPath := filepath.Join("testdata", "combined.yaml") + if *update { + t.Log("Updating golden files.") + raw, err := yaml.Marshal(expected) + assert.NoError(t, err) + assert.NoError(t, os.WriteFile(configPath, raw, os.ModePerm)) // #nosec G306 + } + + actual := CompositeConfig{} + /* #nosec */ + raw, err := os.ReadFile(configPath) + assert.NoError(t, err) + assert.NoError(t, yaml.Unmarshal(raw, &actual)) + assert.True(t, reflect.DeepEqual(expected, actual)) +} + +func TestParseExistingConfig(t *testing.T) { + accessor := viper.NewAccessor(config.Options{ + SearchPaths: []string{filepath.Join("testdata", "combined.yaml")}, + }) + + assert.NoError(t, accessor.UpdateConfig(context.TODO())) + + assert.NotNil(t, storage.ConfigSection) + + if _, ok := storage.ConfigSection.GetConfig().(*storage.Config); ok { + assert.True(t, ok) + } else { + assert.FailNow(t, "Retrieved section is not of type storage.") + } +} diff --git a/flytestdlib/tests/testdata/combined.yaml b/flytestdlib/tests/testdata/combined.yaml new file mode 100755 index 0000000000..59be6d7abd --- /dev/null +++ b/flytestdlib/tests/testdata/combined.yaml @@ -0,0 +1,24 @@ +logger: + formatter: + type: "" + level: 5 + mute: false + show-source: false +storage: + cache: + max_size_mbs: 0 + target_gc_percent: 0 + connection: + access-key: minio + auth-type: accesskey + disable-ssl: true + endpoint: http://minio:9000 + region: us-east-1 + secret-key: miniostorage + container: "" + defaultHttpClient: + headers: null + timeout: 0s + limits: + maxDownloadMBs: 0 + type: s3 diff --git a/flytestdlib/utils/auto_refresh_cache.go b/flytestdlib/utils/auto_refresh_cache.go new file mode 100644 index 0000000000..2dd9ad8ec6 --- /dev/null +++ b/flytestdlib/utils/auto_refresh_cache.go @@ -0,0 +1,153 @@ +package utils + +import ( + "context" + "time" + + lru "github.com/hashicorp/golang-lru" + "github.com/prometheus/client_golang/prometheus" + "k8s.io/apimachinery/pkg/util/wait" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" +) + + +// AutoRefreshCache with regular GetOrCreate and Delete along with background asynchronous refresh. Caller provides +// callbacks for create, refresh and delete item. +// The cache doesn't provide apis to update items. +// Deprecated: This utility is deprecated, it has been refactored and moved into `cache` package. +type AutoRefreshCache interface { + // starts background refresh of items + Start(ctx context.Context) + + // Get item by id if exists else null + Get(id string) CacheItem + + // Get object if exists else create it + GetOrCreate(item CacheItem) (CacheItem, error) +} + +// Deprecated: This utility is deprecated, it has been refactored and moved into `cache` package. +type CacheItem interface { + ID() string +} + +// Possible actions for the cache to take as a result of running the sync function on any given cache item +// Deprecated: This utility is deprecated, it has been refactored and moved into `cache` package. +type CacheSyncAction int + +const ( + Unchanged CacheSyncAction = iota + + // The item returned has been updated and should be updated in the cache + Update + + // The item should be removed from the cache + Delete +) + +// CacheSyncItem is a func type. Your implementation of this function for your cache instance is responsible for returning +// The new CacheItem what action should be taken. The sync function has no insight into your object, and needs to be +// told explicitly if the new item is different from the old one. +// Deprecated: This utility is deprecated, it has been refactored and moved into `cache` package. +type CacheSyncItem func(ctx context.Context, obj CacheItem) ( + newItem CacheItem, result CacheSyncAction, err error) + +func getEvictionFunction(counter prometheus.Counter) func(key interface{}, value interface{}) { + return func(_ interface{}, _ interface{}) { + counter.Inc() + } +} + +// Deprecated: This utility is deprecated, it has been refactored and moved into `cache` package. +func NewAutoRefreshCache(syncCb CacheSyncItem, syncRateLimiter RateLimiter, resyncPeriod time.Duration, + size int, scope promutils.Scope) (AutoRefreshCache, error) { + + // If a scope is specified, we'll add a function to log a metric when an object gets evicted + var evictionFunction func(key interface{}, value interface{}) + if scope != nil { + counter := scope.MustNewCounter("lru_evictions", "Counter for evictions from LRU") + evictionFunction = getEvictionFunction(counter) + } + lruCache, err := lru.NewWithEvict(size, evictionFunction) + if err != nil { + return nil, err + } + + cache := &autoRefreshCache{ + syncCb: syncCb, + lruMap: lruCache, + syncRateLimiter: syncRateLimiter, + resyncPeriod: resyncPeriod, + scope: scope, + } + + return cache, nil +} + +// Thread-safe general purpose auto-refresh cache that watches for updates asynchronously for the keys after they are added to +// the cache. An item can be inserted only once. +// +// Get reads from sync.map while refresh is invoked on a snapshot of keys. Cache eventually catches up on deleted items. +// +// Sync is run as a fixed-interval-scheduled-task, and is skipped if sync from previous cycle is still running. +type autoRefreshCache struct { + syncCb CacheSyncItem + lruMap *lru.Cache + syncRateLimiter RateLimiter + resyncPeriod time.Duration + scope promutils.Scope +} + +func (w *autoRefreshCache) Start(ctx context.Context) { + go wait.Until(func() { w.sync(ctx) }, w.resyncPeriod, ctx.Done()) +} + +func (w *autoRefreshCache) Get(id string) CacheItem { + if val, ok := w.lruMap.Get(id); ok { + return val.(CacheItem) + } + return nil +} + +// Return the item if exists else create it. +// Create should be invoked only once. recreating the object is not supported. +func (w *autoRefreshCache) GetOrCreate(item CacheItem) (CacheItem, error) { + if val, ok := w.lruMap.Get(item.ID()); ok { + return val.(CacheItem), nil + } + + w.lruMap.Add(item.ID(), item) + return item, nil +} + +// This function is called internally by its own timer. Roughly, it will list keys and for each of the keys, call +// syncCb, which tells us if the item has been updated. If it has, then do a remove followed by an add. We can get away +// with this because it is guaranteed that this loop will run to completion before the next one begins. +// +// What happens when the number of things that a user is trying to keep track of exceeds the size +// of the cache? Trivial case where the cache is size 1 and we're trying to keep track of two things. +// * Plugin asks for update on item 1 - cache evicts item 2, stores 1 and returns it unchanged +// * Plugin asks for update on item 2 - cache evicts item 1, stores 2 and returns it unchanged +// * Sync loop updates item 2, repeat +func (w *autoRefreshCache) sync(ctx context.Context) { + keys := w.lruMap.Keys() + for _, k := range keys { + // If not ok, it means evicted between the item was evicted between getting the keys and this update loop + // which is fine, we can just ignore. + if value, ok := w.lruMap.Peek(k); ok { + newItem, result, err := w.syncCb(ctx, value.(CacheItem)) + if err != nil { + logger.Errorf(ctx, "failed to get latest copy of the item %v, error: %s", k, err) + } + + switch result { + case Update: + w.lruMap.Add(k, newItem) + case Delete: + w.lruMap.Remove(k) + } + } + } +} diff --git a/flytestdlib/utils/auto_refresh_cache_test.go b/flytestdlib/utils/auto_refresh_cache_test.go new file mode 100644 index 0000000000..c30dcde769 --- /dev/null +++ b/flytestdlib/utils/auto_refresh_cache_test.go @@ -0,0 +1,92 @@ +package utils + +import ( + "context" + "fmt" + "testing" + "time" + + "github.com/stretchr/testify/assert" +) + +const fakeCacheItemValueLimit = 10 + +type fakeCacheItem struct { + id string + val int +} + +func (f fakeCacheItem) ID() string { + return f.id +} + +func syncFakeItem(_ context.Context, obj CacheItem) (CacheItem, CacheSyncAction, error) { + item := obj.(fakeCacheItem) + if item.val == fakeCacheItemValueLimit { + // After the item has gone through ten update cycles, leave it unchanged + return obj, Unchanged, nil + } + + return fakeCacheItem{id: item.ID(), val: item.val + 1}, Update, nil +} + +func syncFakeItemAlwaysDelete(_ context.Context, obj CacheItem) (CacheItem, CacheSyncAction, error) { + return obj, Delete, nil +} + +func TestCacheTwo(t *testing.T) { + testResyncPeriod := time.Millisecond + rateLimiter := NewRateLimiter("mockLimiter", 100, 1) + + t.Run("normal operation", func(t *testing.T) { + // the size of the cache is at least as large as the number of items we're storing + cache, err := NewAutoRefreshCache(syncFakeItem, rateLimiter, testResyncPeriod, 10, nil) + assert.NoError(t, err) + + ctx, cancel := context.WithCancel(context.Background()) + cache.Start(ctx) + + // Create ten items in the cache + for i := 1; i <= 10; i++ { + _, err := cache.GetOrCreate(fakeCacheItem{ + id: fmt.Sprintf("%d", i), + val: 0, + }) + assert.NoError(t, err) + } + + // Wait half a second for all resync periods to complete + time.Sleep(500 * time.Millisecond) + for i := 1; i <= 10; i++ { + item := cache.Get(fmt.Sprintf("%d", i)) + assert.Equal(t, 10, item.(fakeCacheItem).val) + } + cancel() + }) + + t.Run("deleting objects from cache", func(t *testing.T) { + // the size of the cache is at least as large as the number of items we're storing + cache, err := NewAutoRefreshCache(syncFakeItemAlwaysDelete, rateLimiter, testResyncPeriod, 10, nil) + assert.NoError(t, err) + + ctx, cancel := context.WithCancel(context.Background()) + cache.Start(ctx) + + // Create ten items in the cache + for i := 1; i <= 10; i++ { + _, err = cache.GetOrCreate(fakeCacheItem{ + id: fmt.Sprintf("%d", i), + val: 0, + }) + assert.NoError(t, err) + } + + // Wait for all resync periods to complete + time.Sleep(50 * time.Millisecond) + for i := 1; i <= 10; i++ { + obj := cache.Get(fmt.Sprintf("%d", i)) + assert.Nil(t, obj) + } + cancel() + }) +} diff --git a/flytestdlib/utils/auto_refresh_example_test.go b/flytestdlib/utils/auto_refresh_example_test.go new file mode 100644 index 0000000000..b01ef65a1f --- /dev/null +++ b/flytestdlib/utils/auto_refresh_example_test.go @@ -0,0 +1,96 @@ +package utils + +import ( + "context" + "fmt" + "time" +) + +type ExampleItemStatus string + +const ( + ExampleStatusNotStarted ExampleItemStatus = "Not-started" + ExampleStatusStarted ExampleItemStatus = "Started" + ExampleStatusSucceeded ExampleItemStatus = "Completed" +) + +type ExampleCacheItem struct { + status ExampleItemStatus + id string +} + +func (e *ExampleCacheItem) ID() string { + return e.id +} + +type ExampleService struct { + jobStatus map[string]ExampleItemStatus +} + +func newExampleService() *ExampleService { + return &ExampleService{jobStatus: make(map[string]ExampleItemStatus)} +} + +// advance the status to next, and return +func (f *ExampleService) getStatus(id string) *ExampleCacheItem { + if _, ok := f.jobStatus[id]; !ok { + f.jobStatus[id] = ExampleStatusStarted + } + f.jobStatus[id] = ExampleStatusSucceeded + return &ExampleCacheItem{f.jobStatus[id], id} +} + +func ExampleNewAutoRefreshCache() { + // This auto-refresh cache can be used for cases where keys are created by caller but processed by + // an external service and we want to asynchronously keep track of its progress. + exampleService := newExampleService() + + // define a sync method that the cache can use to auto-refresh in background + syncItemCb := func(ctx context.Context, obj CacheItem) (CacheItem, CacheSyncAction, error) { + oldItem := obj.(*ExampleCacheItem) + newItem := exampleService.getStatus(oldItem.ID()) + if newItem.status != oldItem.status { + return newItem, Update, nil + } + return newItem, Unchanged, nil + } + + // define resync period as time duration we want cache to refresh. We can go as low as we want but cache + // would still be constrained by time it takes to run Sync call for each item. + resyncPeriod := time.Millisecond + + // Since number of items in the cache is dynamic, rate limiter is our knob to control resources we spend on + // sync. + rateLimiter := NewRateLimiter("ExampleRateLimiter", 10000, 1) + + // since cache refreshes itself asynchronously, it may not notice that an object has been deleted immediately, + // so users of the cache should have the delete logic aware of this shortcoming (eg. not-exists may be a valid + // error during removal if based on status in cache). + cache, err := NewAutoRefreshCache(syncItemCb, rateLimiter, resyncPeriod, 100, nil) + if err != nil { + panic(err) + } + + // start the cache with a context that would be to stop the cache by cancelling the context + ctx, cancel := context.WithCancel(context.Background()) + cache.Start(ctx) + + // creating objects that go through a couple of state transitions to reach the final state. + item1 := &ExampleCacheItem{status: ExampleStatusNotStarted, id: "item1"} + item2 := &ExampleCacheItem{status: ExampleStatusNotStarted, id: "item2"} + _, err1 := cache.GetOrCreate(item1) + _, err2 := cache.GetOrCreate(item2) + if err1 != nil || err2 != nil { + fmt.Printf("unexpected error in create; err1: %v, err2: %v", err1, err2) + } + + // wait for the cache to go through a few refresh cycles and then check status + time.Sleep(resyncPeriod * 10) + fmt.Printf("Current status for item1 is %v", cache.Get(item1.ID()).(*ExampleCacheItem).status) + + // stop the cache + cancel() + + // Output: + // Current status for item1 is Completed +} diff --git a/flytestdlib/utils/constants.go b/flytestdlib/utils/constants.go new file mode 100644 index 0000000000..3c604abcb5 --- /dev/null +++ b/flytestdlib/utils/constants.go @@ -0,0 +1,3 @@ +package utils + +const MaxUniqueIDLength = 30 diff --git a/flytestdlib/utils/marshal_utils.go b/flytestdlib/utils/marshal_utils.go new file mode 100644 index 0000000000..58cf3bdec5 --- /dev/null +++ b/flytestdlib/utils/marshal_utils.go @@ -0,0 +1,123 @@ +package utils + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + + "github.com/golang/protobuf/jsonpb" + "github.com/golang/protobuf/proto" + structpb "github.com/golang/protobuf/ptypes/struct" + "github.com/pkg/errors" +) + +var jsonPbMarshaler = jsonpb.Marshaler{} +var jsonPbUnmarshaler = jsonpb.Unmarshaler{ + AllowUnknownFields: true, +} + +// UnmarshalStructToPb unmarshals a proto struct into a proto message using jsonPb marshaler. +func UnmarshalStructToPb(structObj *structpb.Struct, msg proto.Message) error { + if structObj == nil { + return fmt.Errorf("nil Struct object passed") + } + + if msg == nil { + return fmt.Errorf("nil proto.Message object passed") + } + + jsonObj, err := jsonPbMarshaler.MarshalToString(structObj) + if err != nil { + return errors.WithMessage(err, "Failed to marshal strcutObj input") + } + + if err = UnmarshalStringToPb(jsonObj, msg); err != nil { + return errors.WithMessage(err, "Failed to unmarshal json obj into proto") + } + + return nil +} + +// MarshalPbToStruct marshals a proto message into proto Struct using jsonPb marshaler. +func MarshalPbToStruct(in proto.Message) (out *structpb.Struct, err error) { + if in == nil { + return nil, fmt.Errorf("nil proto message passed") + } + + var buf bytes.Buffer + if err := jsonPbMarshaler.Marshal(&buf, in); err != nil { + return nil, errors.WithMessage(err, "Failed to marshal input proto message") + } + + out = &structpb.Struct{} + if err = UnmarshalBytesToPb(buf.Bytes(), out); err != nil { + return nil, errors.WithMessage(err, "Failed to unmarshal json object into struct") + } + + return out, nil +} + +// MarshalPbToString marshals a proto message using jsonPb marshaler to string. +func MarshalPbToString(msg proto.Message) (string, error) { + return jsonPbMarshaler.MarshalToString(msg) +} + +// UnmarshalStringToPb unmarshals a string to a proto message +func UnmarshalStringToPb(s string, msg proto.Message) error { + return jsonPbUnmarshaler.Unmarshal(strings.NewReader(s), msg) +} + +// MarshalPbToBytes marshals a proto message to a byte slice +func MarshalPbToBytes(msg proto.Message) ([]byte, error) { + var buf bytes.Buffer + err := jsonPbMarshaler.Marshal(&buf, msg) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} + +// UnmarshalBytesToPb unmarshals a byte slice to a proto message +func UnmarshalBytesToPb(b []byte, msg proto.Message) error { + return jsonPbUnmarshaler.Unmarshal(bytes.NewReader(b), msg) +} + +// MarshalObjToStruct marshals obj into a struct. Will use jsonPb if input is a proto message, otherwise, it'll use json +// marshaler. +func MarshalObjToStruct(input interface{}) (*structpb.Struct, error) { + if p, casted := input.(proto.Message); casted { + return MarshalPbToStruct(p) + } + + b, err := json.Marshal(input) + if err != nil { + return nil, errors.WithMessage(err, "Failed to marshal input proto message") + } + + // Turn JSON into a protobuf struct + structObj := &structpb.Struct{} + if err := UnmarshalBytesToPb(b, structObj); err != nil { + return nil, errors.WithMessage(err, "Failed to unmarshal json object into struct") + } + + return structObj, nil +} + +// UnmarshalStructToObj unmarshals a struct to the passed obj. Don't use this if the unmarshalled obj is a proto message. +func UnmarshalStructToObj(structObj *structpb.Struct, obj interface{}) error { + if structObj == nil { + return fmt.Errorf("nil Struct Object passed") + } + + jsonObj, err := json.Marshal(structObj) + if err != nil { + return err + } + + if err = json.Unmarshal(jsonObj, obj); err != nil { + return err + } + + return nil +} diff --git a/flytestdlib/utils/marshal_utils_test.go b/flytestdlib/utils/marshal_utils_test.go new file mode 100644 index 0000000000..3ac0c3f339 --- /dev/null +++ b/flytestdlib/utils/marshal_utils_test.go @@ -0,0 +1,239 @@ +package utils + +import ( + "testing" + + "github.com/go-test/deep" + "github.com/golang/protobuf/proto" + structpb "github.com/golang/protobuf/ptypes/struct" + "github.com/stretchr/testify/assert" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/util/json" + + "github.com/flyteorg/flyte/v2/flytestdlib/utils/prototest" +) + +type SimpleType struct { + StringValue string `json:"string_value,omitempty"` +} + +func TestMarshalPbToString(t *testing.T) { + type args struct { + msg proto.Message + } + tests := []struct { + name string + args args + want string + wantErr bool + }{ + {"empty", args{msg: &prototest.TestProto{}}, "{}", false}, + {"has value", args{msg: &prototest.TestProto{StringValue: "hello"}}, `{"stringValue":"hello"}`, false}, + {"nil input", args{msg: nil}, "", true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := MarshalPbToString(tt.args.msg) + if (err != nil) != tt.wantErr { + t.Errorf("MarshalToString() error = %v, wantErr %v", err, tt.wantErr) + return + } + if got != tt.want { + t.Errorf("MarshalToString() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestMarshalObjToStruct(t *testing.T) { + type args struct { + input interface{} + } + tests := []struct { + name string + args args + want *structpb.Struct + wantErr bool + }{ + {"has proto value", args{input: &prototest.TestProto{StringValue: "hello"}}, &structpb.Struct{Fields: map[string]*structpb.Value{ + "stringValue": {Kind: &structpb.Value_StringValue{StringValue: "hello"}}, + }}, false}, + {"has struct value", args{input: SimpleType{StringValue: "hello"}}, &structpb.Struct{Fields: map[string]*structpb.Value{ + "string_value": {Kind: &structpb.Value_StringValue{StringValue: "hello"}}, + }}, false}, + {"has string value", args{input: "hello"}, nil, true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := MarshalObjToStruct(tt.args.input) + if (err != nil) != tt.wantErr { + t.Errorf("MarshalObjToStruct() error = %v, wantErr %v", err, tt.wantErr) + return + } + + if diff := deep.Equal(got, tt.want); diff != nil { + t.Errorf("MarshalObjToStruct() = %v, want %v, diff: %v", got, tt.want, diff) + } + }) + } +} + +func TestUnmarshalStructToPb(t *testing.T) { + type args struct { + structObj *structpb.Struct + msg proto.Message + } + tests := []struct { + name string + args args + expected proto.Message + wantErr bool + }{ + {"empty", args{structObj: &structpb.Struct{Fields: map[string]*structpb.Value{}}, msg: &prototest.TestProto{}}, &prototest.TestProto{}, false}, + {"has value", args{structObj: &structpb.Struct{Fields: map[string]*structpb.Value{ + "stringValue": {Kind: &structpb.Value_StringValue{StringValue: "hello"}}, + }}, msg: &prototest.TestProto{}}, &prototest.TestProto{StringValue: "hello"}, false}, + {"nil input", args{structObj: nil}, nil, true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if err := UnmarshalStructToPb(tt.args.structObj, tt.args.msg); (err != nil) != tt.wantErr { + t.Errorf("UnmarshalStructToPb() error = %v, wantErr %v", err, tt.wantErr) + } else if tt.expected == nil { + assert.Nil(t, tt.args.msg) + } else { + assert.Equal(t, (tt.expected.(*prototest.TestProto)).GetStringValue(), (tt.args.msg.(*prototest.TestProto)).GetStringValue()) + } + }) + } +} + +func TestMarshalPbToStruct(t *testing.T) { + type args struct { + in proto.Message + } + tests := []struct { + name string + args args + expected *structpb.Struct + wantErr bool + }{ + {"empty", args{in: &prototest.TestProto{}}, &structpb.Struct{Fields: map[string]*structpb.Value{}}, false}, + {"has value", + args{ + in: &prototest.TestProto{StringValue: "hello"}, + }, + &structpb.Struct{ + Fields: map[string]*structpb.Value{ + "stringValue": {Kind: &structpb.Value_StringValue{StringValue: "hello"}}, + }, + }, false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got, err := MarshalPbToStruct(tt.args.in); (err != nil) != tt.wantErr { + t.Errorf("MarshalPbToStruct() error = %v, wantErr %v", err, tt.wantErr) + } else if len(tt.expected.GetFields()) == 0 { + assert.Empty(t, got.GetFields()) + } else { + assert.Equal(t, tt.expected.GetFields()["stringValue"].GetKind(), got.GetFields()["stringValue"].GetKind()) + } + }) + } +} + +func TestUnmarshalStructToObj(t *testing.T) { + t.Run("no nil structs allowed", func(t *testing.T) { + var podSpec v1.PodSpec + err := UnmarshalStructToObj(nil, &podSpec) + assert.EqualError(t, err, "nil Struct Object passed") + }) + podSpec := v1.PodSpec{ + Containers: []v1.Container{ + { + Name: "a container", + }, + { + Name: "another container", + }, + }, + } + + b, err := json.Marshal(podSpec) + if err != nil { + t.Fatal(err) + } + + structObj := &structpb.Struct{} + if err := json.Unmarshal(b, structObj); err != nil { + t.Fatal(err) + } + + t.Run("no nil pointers as obj allowed", func(t *testing.T) { + var nilPodspec *v1.PodSpec + err := UnmarshalStructToObj(structObj, nilPodspec) + assert.EqualError(t, err, "json: Unmarshal(nil *v1.PodSpec)") + }) + + t.Run("happy case", func(t *testing.T) { + var podSpecObj v1.PodSpec + err := UnmarshalStructToObj(structObj, &podSpecObj) + assert.NoError(t, err) + if diff := deep.Equal(podSpecObj, podSpec); diff != nil { + t.Errorf("UnmarshalStructToObj() got = %v, want %v, diff: %v", podSpecObj, podSpec, diff) + } + }) +} + +func TestMarshalPbToBytes(t *testing.T) { + type args struct { + msg proto.Message + } + tests := []struct { + name string + args args + want []byte + wantErr bool + }{ + {"empty", args{msg: &prototest.TestProto{}}, []byte("{}"), false}, + {"has value", args{msg: &prototest.TestProto{StringValue: "hello"}}, []byte(`{"stringValue":"hello"}`), false}, + {"nil input", args{msg: nil}, []byte(nil), true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := MarshalPbToBytes(tt.args.msg) + if (err != nil) != tt.wantErr { + t.Errorf("MarshalPbToBytes() error = %v, wantErr %v", err, tt.wantErr) + return + } + assert.Equal(t, tt.want, got, "MarshalPbToBytes() = %v, want %v", got, tt.want) + }) + } +} + +func TestUnmarshalBytesToPb(t *testing.T) { + type args struct { + b []byte + } + tests := []struct { + name string + args args + want proto.Message + wantErr bool + }{ + {"empty", args{b: []byte("{}")}, &prototest.TestProto{}, false}, + {"has value", args{b: []byte(`{"stringValue":"hello"}`)}, &prototest.TestProto{StringValue: "hello"}, false}, + {"nil input", args{b: []byte(nil)}, &prototest.TestProto{}, true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + m := &prototest.TestProto{} + err := UnmarshalBytesToPb(tt.args.b, m) + if (err != nil) != tt.wantErr { + t.Errorf("UnmarshalBytesToPb() error = %v, wantErr %v", err, tt.wantErr) + return + } + assert.True(t, proto.Equal(tt.want, m), "UnmarshalBytesToPb() = %v, want %v", m, tt.want) + }) + } +} diff --git a/flytestdlib/utils/mocks/auto_refresh_cache.go b/flytestdlib/utils/mocks/auto_refresh_cache.go new file mode 100644 index 0000000000..252c3546aa --- /dev/null +++ b/flytestdlib/utils/mocks/auto_refresh_cache.go @@ -0,0 +1,176 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + utils "github.com/flyteorg/flyte/v2/flytestdlib/utils" + mock "github.com/stretchr/testify/mock" +) + +// AutoRefreshCache is an autogenerated mock type for the AutoRefreshCache type +type AutoRefreshCache struct { + mock.Mock +} + +type AutoRefreshCache_Expecter struct { + mock *mock.Mock +} + +func (_m *AutoRefreshCache) EXPECT() *AutoRefreshCache_Expecter { + return &AutoRefreshCache_Expecter{mock: &_m.Mock} +} + +// Get provides a mock function with given fields: id +func (_m *AutoRefreshCache) Get(id string) utils.CacheItem { + ret := _m.Called(id) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 utils.CacheItem + if rf, ok := ret.Get(0).(func(string) utils.CacheItem); ok { + r0 = rf(id) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(utils.CacheItem) + } + } + + return r0 +} + +// AutoRefreshCache_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type AutoRefreshCache_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - id string +func (_e *AutoRefreshCache_Expecter) Get(id interface{}) *AutoRefreshCache_Get_Call { + return &AutoRefreshCache_Get_Call{Call: _e.mock.On("Get", id)} +} + +func (_c *AutoRefreshCache_Get_Call) Run(run func(id string)) *AutoRefreshCache_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *AutoRefreshCache_Get_Call) Return(_a0 utils.CacheItem) *AutoRefreshCache_Get_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AutoRefreshCache_Get_Call) RunAndReturn(run func(string) utils.CacheItem) *AutoRefreshCache_Get_Call { + _c.Call.Return(run) + return _c +} + +// GetOrCreate provides a mock function with given fields: item +func (_m *AutoRefreshCache) GetOrCreate(item utils.CacheItem) (utils.CacheItem, error) { + ret := _m.Called(item) + + if len(ret) == 0 { + panic("no return value specified for GetOrCreate") + } + + var r0 utils.CacheItem + var r1 error + if rf, ok := ret.Get(0).(func(utils.CacheItem) (utils.CacheItem, error)); ok { + return rf(item) + } + if rf, ok := ret.Get(0).(func(utils.CacheItem) utils.CacheItem); ok { + r0 = rf(item) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(utils.CacheItem) + } + } + + if rf, ok := ret.Get(1).(func(utils.CacheItem) error); ok { + r1 = rf(item) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AutoRefreshCache_GetOrCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrCreate' +type AutoRefreshCache_GetOrCreate_Call struct { + *mock.Call +} + +// GetOrCreate is a helper method to define mock.On call +// - item utils.CacheItem +func (_e *AutoRefreshCache_Expecter) GetOrCreate(item interface{}) *AutoRefreshCache_GetOrCreate_Call { + return &AutoRefreshCache_GetOrCreate_Call{Call: _e.mock.On("GetOrCreate", item)} +} + +func (_c *AutoRefreshCache_GetOrCreate_Call) Run(run func(item utils.CacheItem)) *AutoRefreshCache_GetOrCreate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(utils.CacheItem)) + }) + return _c +} + +func (_c *AutoRefreshCache_GetOrCreate_Call) Return(_a0 utils.CacheItem, _a1 error) *AutoRefreshCache_GetOrCreate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AutoRefreshCache_GetOrCreate_Call) RunAndReturn(run func(utils.CacheItem) (utils.CacheItem, error)) *AutoRefreshCache_GetOrCreate_Call { + _c.Call.Return(run) + return _c +} + +// Start provides a mock function with given fields: ctx +func (_m *AutoRefreshCache) Start(ctx context.Context) { + _m.Called(ctx) +} + +// AutoRefreshCache_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start' +type AutoRefreshCache_Start_Call struct { + *mock.Call +} + +// Start is a helper method to define mock.On call +// - ctx context.Context +func (_e *AutoRefreshCache_Expecter) Start(ctx interface{}) *AutoRefreshCache_Start_Call { + return &AutoRefreshCache_Start_Call{Call: _e.mock.On("Start", ctx)} +} + +func (_c *AutoRefreshCache_Start_Call) Run(run func(ctx context.Context)) *AutoRefreshCache_Start_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *AutoRefreshCache_Start_Call) Return() *AutoRefreshCache_Start_Call { + _c.Call.Return() + return _c +} + +func (_c *AutoRefreshCache_Start_Call) RunAndReturn(run func(context.Context)) *AutoRefreshCache_Start_Call { + _c.Run(run) + return _c +} + +// NewAutoRefreshCache creates a new instance of AutoRefreshCache. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAutoRefreshCache(t interface { + mock.TestingT + Cleanup(func()) +}) *AutoRefreshCache { + mock := &AutoRefreshCache{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/utils/mocks/cache_item.go b/flytestdlib/utils/mocks/cache_item.go new file mode 100644 index 0000000000..a3c365b79f --- /dev/null +++ b/flytestdlib/utils/mocks/cache_item.go @@ -0,0 +1,77 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// CacheItem is an autogenerated mock type for the CacheItem type +type CacheItem struct { + mock.Mock +} + +type CacheItem_Expecter struct { + mock *mock.Mock +} + +func (_m *CacheItem) EXPECT() *CacheItem_Expecter { + return &CacheItem_Expecter{mock: &_m.Mock} +} + +// ID provides a mock function with no fields +func (_m *CacheItem) ID() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for ID") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// CacheItem_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID' +type CacheItem_ID_Call struct { + *mock.Call +} + +// ID is a helper method to define mock.On call +func (_e *CacheItem_Expecter) ID() *CacheItem_ID_Call { + return &CacheItem_ID_Call{Call: _e.mock.On("ID")} +} + +func (_c *CacheItem_ID_Call) Run(run func()) *CacheItem_ID_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *CacheItem_ID_Call) Return(_a0 string) *CacheItem_ID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CacheItem_ID_Call) RunAndReturn(run func() string) *CacheItem_ID_Call { + _c.Call.Return(run) + return _c +} + +// NewCacheItem creates a new instance of CacheItem. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewCacheItem(t interface { + mock.TestingT + Cleanup(func()) +}) *CacheItem { + mock := &CacheItem{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/utils/mocks/cache_sync_item.go b/flytestdlib/utils/mocks/cache_sync_item.go new file mode 100644 index 0000000000..1794b5c2dd --- /dev/null +++ b/flytestdlib/utils/mocks/cache_sync_item.go @@ -0,0 +1,103 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + utils "github.com/flyteorg/flyte/v2/flytestdlib/utils" + mock "github.com/stretchr/testify/mock" +) + +// CacheSyncItem is an autogenerated mock type for the CacheSyncItem type +type CacheSyncItem struct { + mock.Mock +} + +type CacheSyncItem_Expecter struct { + mock *mock.Mock +} + +func (_m *CacheSyncItem) EXPECT() *CacheSyncItem_Expecter { + return &CacheSyncItem_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: ctx, obj +func (_m *CacheSyncItem) Execute(ctx context.Context, obj utils.CacheItem) (utils.CacheItem, utils.CacheSyncAction, error) { + ret := _m.Called(ctx, obj) + + if len(ret) == 0 { + panic("no return value specified for Execute") + } + + var r0 utils.CacheItem + var r1 utils.CacheSyncAction + var r2 error + if rf, ok := ret.Get(0).(func(context.Context, utils.CacheItem) (utils.CacheItem, utils.CacheSyncAction, error)); ok { + return rf(ctx, obj) + } + if rf, ok := ret.Get(0).(func(context.Context, utils.CacheItem) utils.CacheItem); ok { + r0 = rf(ctx, obj) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(utils.CacheItem) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, utils.CacheItem) utils.CacheSyncAction); ok { + r1 = rf(ctx, obj) + } else { + r1 = ret.Get(1).(utils.CacheSyncAction) + } + + if rf, ok := ret.Get(2).(func(context.Context, utils.CacheItem) error); ok { + r2 = rf(ctx, obj) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CacheSyncItem_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type CacheSyncItem_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - ctx context.Context +// - obj utils.CacheItem +func (_e *CacheSyncItem_Expecter) Execute(ctx interface{}, obj interface{}) *CacheSyncItem_Execute_Call { + return &CacheSyncItem_Execute_Call{Call: _e.mock.On("Execute", ctx, obj)} +} + +func (_c *CacheSyncItem_Execute_Call) Run(run func(ctx context.Context, obj utils.CacheItem)) *CacheSyncItem_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(utils.CacheItem)) + }) + return _c +} + +func (_c *CacheSyncItem_Execute_Call) Return(newItem utils.CacheItem, result utils.CacheSyncAction, err error) *CacheSyncItem_Execute_Call { + _c.Call.Return(newItem, result, err) + return _c +} + +func (_c *CacheSyncItem_Execute_Call) RunAndReturn(run func(context.Context, utils.CacheItem) (utils.CacheItem, utils.CacheSyncAction, error)) *CacheSyncItem_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewCacheSyncItem creates a new instance of CacheSyncItem. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewCacheSyncItem(t interface { + mock.TestingT + Cleanup(func()) +}) *CacheSyncItem { + mock := &CacheSyncItem{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/utils/mocks/rate_limiter.go b/flytestdlib/utils/mocks/rate_limiter.go new file mode 100644 index 0000000000..3958244701 --- /dev/null +++ b/flytestdlib/utils/mocks/rate_limiter.go @@ -0,0 +1,82 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" +) + +// RateLimiter is an autogenerated mock type for the RateLimiter type +type RateLimiter struct { + mock.Mock +} + +type RateLimiter_Expecter struct { + mock *mock.Mock +} + +func (_m *RateLimiter) EXPECT() *RateLimiter_Expecter { + return &RateLimiter_Expecter{mock: &_m.Mock} +} + +// Wait provides a mock function with given fields: ctx +func (_m *RateLimiter) Wait(ctx context.Context) error { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Wait") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(ctx) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RateLimiter_Wait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Wait' +type RateLimiter_Wait_Call struct { + *mock.Call +} + +// Wait is a helper method to define mock.On call +// - ctx context.Context +func (_e *RateLimiter_Expecter) Wait(ctx interface{}) *RateLimiter_Wait_Call { + return &RateLimiter_Wait_Call{Call: _e.mock.On("Wait", ctx)} +} + +func (_c *RateLimiter_Wait_Call) Run(run func(ctx context.Context)) *RateLimiter_Wait_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *RateLimiter_Wait_Call) Return(_a0 error) *RateLimiter_Wait_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RateLimiter_Wait_Call) RunAndReturn(run func(context.Context) error) *RateLimiter_Wait_Call { + _c.Call.Return(run) + return _c +} + +// NewRateLimiter creates a new instance of RateLimiter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRateLimiter(t interface { + mock.TestingT + Cleanup(func()) +}) *RateLimiter { + mock := &RateLimiter{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/utils/mocks/sequencer.go b/flytestdlib/utils/mocks/sequencer.go new file mode 100644 index 0000000000..8f520f8d5f --- /dev/null +++ b/flytestdlib/utils/mocks/sequencer.go @@ -0,0 +1,122 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// Sequencer is an autogenerated mock type for the Sequencer type +type Sequencer struct { + mock.Mock +} + +type Sequencer_Expecter struct { + mock *mock.Mock +} + +func (_m *Sequencer) EXPECT() *Sequencer_Expecter { + return &Sequencer_Expecter{mock: &_m.Mock} +} + +// GetCur provides a mock function with no fields +func (_m *Sequencer) GetCur() uint64 { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetCur") + } + + var r0 uint64 + if rf, ok := ret.Get(0).(func() uint64); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(uint64) + } + + return r0 +} + +// Sequencer_GetCur_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCur' +type Sequencer_GetCur_Call struct { + *mock.Call +} + +// GetCur is a helper method to define mock.On call +func (_e *Sequencer_Expecter) GetCur() *Sequencer_GetCur_Call { + return &Sequencer_GetCur_Call{Call: _e.mock.On("GetCur")} +} + +func (_c *Sequencer_GetCur_Call) Run(run func()) *Sequencer_GetCur_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Sequencer_GetCur_Call) Return(_a0 uint64) *Sequencer_GetCur_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Sequencer_GetCur_Call) RunAndReturn(run func() uint64) *Sequencer_GetCur_Call { + _c.Call.Return(run) + return _c +} + +// GetNext provides a mock function with no fields +func (_m *Sequencer) GetNext() uint64 { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetNext") + } + + var r0 uint64 + if rf, ok := ret.Get(0).(func() uint64); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(uint64) + } + + return r0 +} + +// Sequencer_GetNext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNext' +type Sequencer_GetNext_Call struct { + *mock.Call +} + +// GetNext is a helper method to define mock.On call +func (_e *Sequencer_Expecter) GetNext() *Sequencer_GetNext_Call { + return &Sequencer_GetNext_Call{Call: _e.mock.On("GetNext")} +} + +func (_c *Sequencer_GetNext_Call) Run(run func()) *Sequencer_GetNext_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Sequencer_GetNext_Call) Return(_a0 uint64) *Sequencer_GetNext_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Sequencer_GetNext_Call) RunAndReturn(run func() uint64) *Sequencer_GetNext_Call { + _c.Call.Return(run) + return _c +} + +// NewSequencer creates a new instance of Sequencer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewSequencer(t interface { + mock.TestingT + Cleanup(func()) +}) *Sequencer { + mock := &Sequencer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/flytestdlib/utils/proto_asserts.go b/flytestdlib/utils/proto_asserts.go new file mode 100644 index 0000000000..c29c8b7b9c --- /dev/null +++ b/flytestdlib/utils/proto_asserts.go @@ -0,0 +1,16 @@ +package utils + +import ( + "regexp" + "testing" + + "github.com/stretchr/testify/assert" +) + +// This regex is used to sanitize representations of protobufs in tests. +var sanitizeProtoRegex = regexp.MustCompile(`\s+`) + +// This function is used to sanitize representations of protobufs in tests. +func AssertEqualWithSanitizedRegex(t *testing.T, expected string, actual string) { + assert.Equal(t, sanitizeProtoRegex.ReplaceAllString(expected, ""), sanitizeProtoRegex.ReplaceAllString(actual, "")) +} diff --git a/flytestdlib/utils/prototest/test_type.pb.go b/flytestdlib/utils/prototest/test_type.pb.go new file mode 100644 index 0000000000..7495748680 --- /dev/null +++ b/flytestdlib/utils/prototest/test_type.pb.go @@ -0,0 +1,151 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.25.0 +// protoc v3.14.0 +// source: test_type.proto + +package prototest + +import ( + reflect "reflect" + sync "sync" + + proto "github.com/golang/protobuf/proto" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// This is a compile-time assertion that a sufficiently up-to-date version +// of the legacy proto package is being used. +const _ = proto.ProtoPackageIsVersion4 + +type TestProto struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + StringValue string `protobuf:"bytes,1,opt,name=string_value,json=stringValue,proto3" json:"string_value,omitempty"` +} + +func (x *TestProto) Reset() { + *x = TestProto{} + if protoimpl.UnsafeEnabled { + mi := &file_test_type_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestProto) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestProto) ProtoMessage() {} + +func (x *TestProto) ProtoReflect() protoreflect.Message { + mi := &file_test_type_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TestProto.ProtoReflect.Descriptor instead. +func (*TestProto) Descriptor() ([]byte, []int) { + return file_test_type_proto_rawDescGZIP(), []int{0} +} + +func (x *TestProto) GetStringValue() string { + if x != nil { + return x.StringValue + } + return "" +} + +var File_test_type_proto protoreflect.FileDescriptor + +var file_test_type_proto_rawDesc = []byte{ + 0x0a, 0x0f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x0d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x22, 0x2e, 0x0a, 0x09, 0x54, 0x65, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x21, 0x0a, + 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x42, 0x2d, 0x5a, 0x2b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6c, + 0x79, 0x66, 0x74, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x73, 0x74, 0x64, 0x6c, 0x69, 0x62, 0x2f, + 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x65, 0x73, 0x74, 0x62, + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_test_type_proto_rawDescOnce sync.Once + file_test_type_proto_rawDescData = file_test_type_proto_rawDesc +) + +func file_test_type_proto_rawDescGZIP() []byte { + file_test_type_proto_rawDescOnce.Do(func() { + file_test_type_proto_rawDescData = protoimpl.X.CompressGZIP(file_test_type_proto_rawDescData) + }) + return file_test_type_proto_rawDescData +} + +var file_test_type_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_test_type_proto_goTypes = []interface{}{ + (*TestProto)(nil), // 0: flyteidl.core.TestProto +} +var file_test_type_proto_depIdxs = []int32{ + 0, // [0:0] is the sub-list for method output_type + 0, // [0:0] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_test_type_proto_init() } +func file_test_type_proto_init() { + if File_test_type_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_test_type_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestProto); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_test_type_proto_rawDesc, + NumEnums: 0, + NumMessages: 1, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_test_type_proto_goTypes, + DependencyIndexes: file_test_type_proto_depIdxs, + MessageInfos: file_test_type_proto_msgTypes, + }.Build() + File_test_type_proto = out.File + file_test_type_proto_rawDesc = nil + file_test_type_proto_goTypes = nil + file_test_type_proto_depIdxs = nil +} diff --git a/flytestdlib/utils/prototest/test_type.proto b/flytestdlib/utils/prototest/test_type.proto new file mode 100644 index 0000000000..447cfa13a4 --- /dev/null +++ b/flytestdlib/utils/prototest/test_type.proto @@ -0,0 +1,9 @@ +syntax = "proto3"; + +package flyteidl.core; + +option go_package = "github.com/flyteorg/flytestdlib/utils/prototest"; + +message TestProto { + string string_value = 1; +} diff --git a/flytestdlib/utils/rate_limiter.go b/flytestdlib/utils/rate_limiter.go new file mode 100644 index 0000000000..197552b64e --- /dev/null +++ b/flytestdlib/utils/rate_limiter.go @@ -0,0 +1,36 @@ +package utils + +import ( + "context" + + "golang.org/x/time/rate" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" +) + +// Interface to use rate limiter +type RateLimiter interface { + Wait(ctx context.Context) error +} + +type rateLimiter struct { + name string + limiter rate.Limiter +} + +// Blocking method which waits for the next token as per the tps and burst values defined +func (r *rateLimiter) Wait(ctx context.Context) error { + logger.Debugf(ctx, "Waiting for a token from rate limiter %s", r.name) + if err := r.limiter.Wait(ctx); err != nil { + return err + } + return nil +} + +// Create a new rate-limiter with the tps and burst values +func NewRateLimiter(rateLimiterName string, tps float64, burst int) RateLimiter { + return &rateLimiter{ + name: rateLimiterName, + limiter: *rate.NewLimiter(rate.Limit(tps), burst), + } +} diff --git a/flytestdlib/utils/rate_limiter_test.go b/flytestdlib/utils/rate_limiter_test.go new file mode 100644 index 0000000000..3aaf1df522 --- /dev/null +++ b/flytestdlib/utils/rate_limiter_test.go @@ -0,0 +1,39 @@ +package utils + +import ( + "context" + "math" + "testing" + "time" + + "github.com/stretchr/testify/assert" +) + +func TestInfiniteRateLimiter(t *testing.T) { + infRateLimiter := NewRateLimiter("test_rate_limiter", math.MaxFloat64, 0) + start := time.Now() + + for i := 0; i < 100; i++ { + err := infRateLimiter.Wait(context.Background()) + assert.NoError(t, err, "unexpected failure in wait") + } + assert.True(t, time.Since(start) < 100*time.Millisecond) +} + +func TestRateLimiter(t *testing.T) { + rateLimiter := NewRateLimiter("test_rate_limiter", 1, 1) + start := time.Now() + + for i := 0; i < 5; i++ { + err := rateLimiter.Wait(context.Background()) + assert.Nil(t, err) + } + assert.True(t, time.Since(start) > 3*time.Second) + assert.True(t, time.Since(start) < 5*time.Second) +} + +func TestInvalidRateLimitConfig(t *testing.T) { + rateLimiter := NewRateLimiter("test_rate_limiter", 1, 0) + err := rateLimiter.Wait(context.Background()) + assert.NotNil(t, err) +} diff --git a/flytestdlib/utils/sequencer.go b/flytestdlib/utils/sequencer.go new file mode 100644 index 0000000000..1d41dde367 --- /dev/null +++ b/flytestdlib/utils/sequencer.go @@ -0,0 +1,39 @@ +package utils + +import ( + "sync" + "sync/atomic" +) + +// Sequencer is a thread-safe incremental integer counter. Note that it is a singleton, so +// GetSequencer.GetNext may not always start at 0. +type Sequencer interface { + GetNext() uint64 + GetCur() uint64 +} + +type sequencer struct { + val *uint64 +} + +var once sync.Once +var instance Sequencer + +func GetSequencer() Sequencer { + once.Do(func() { + val := uint64(0) + instance = &sequencer{val: &val} + }) + return instance +} + +// Get the next sequence number, 1 higher than the last and set it as the current one +func (s sequencer) GetNext() uint64 { + x := atomic.AddUint64(s.val, 1) + return x +} + +// Get the current sequence number +func (s sequencer) GetCur() uint64 { + return *s.val +} diff --git a/flytestdlib/utils/sequencer_test.go b/flytestdlib/utils/sequencer_test.go new file mode 100644 index 0000000000..a7699a8c03 --- /dev/null +++ b/flytestdlib/utils/sequencer_test.go @@ -0,0 +1,53 @@ +package utils + +import ( + "fmt" + "sync" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestSequencer(t *testing.T) { + size := uint64(3) + sequencer := GetSequencer() + curVal := sequencer.GetCur() + 1 + // sum = n(a0 + aN) / 2 + expectedSum := size * (curVal + curVal + size - 1) / 2 + numbers := make(chan uint64, size) + + var wg sync.WaitGroup + wg.Add(int(size)) + + iter := uint64(0) + for iter < size { + go func() { + number := sequencer.GetNext() + fmt.Printf("list value: %d", number) + numbers <- number + wg.Done() + }() + iter++ + } + wg.Wait() + close(numbers) + + unique, sum := uniqueAndSum(numbers) + assert.True(t, unique, "sequencer generated duplicate numbers") + assert.Equal(t, expectedSum, sum, "sequencer generated sequence numbers with gap %d %d", expectedSum, sum) +} + +func uniqueAndSum(list chan uint64) (bool, uint64) { + set := make(map[uint64]struct{}) + var sum uint64 + + for elem := range list { + fmt.Printf("list value: %d\n", elem) + if _, ok := set[elem]; ok { + return false, sum + } + set[elem] = struct{}{} + sum += elem + } + return true, sum +} diff --git a/flytestdlib/version/version.go b/flytestdlib/version/version.go new file mode 100644 index 0000000000..edddc4c421 --- /dev/null +++ b/flytestdlib/version/version.go @@ -0,0 +1,36 @@ +package version + +import ( + "fmt" + "time" + + "github.com/sirupsen/logrus" +) + +// This module provides the ability to inject Build (git sha) and Version information at compile time. +// To set these values invoke go build as follows +// go build -ldflags โ€œ-X github.com/lyft/flytestdlib/version.Build=xyz -X github.com/lyft/flytestdlib/version.Version=1.2.3" +// NOTE: If the version is set and server.StartProfilingServerWithDefaultHandlers are initialized then, `/version` +// will provide the build and version information +var ( + // Specifies the GIT sha of the build + Build = "unknown" + // Version for the build, should follow a semver + Version = "unknown" + // Build timestamp + BuildTime = time.Now().String() + // Git branch that was used to build the binary + GitBranch = "" +) + +// Use this method to log the build information for the current app. The app name should be provided. To inject the build +// and version information refer to the top-level comment in this file +func LogBuildInformation(appName string) { + logrus.Info("------------------------------------------------------------------------") + msg := fmt.Sprintf("App [%s], Version [%s], BuildSHA [%s], BuildTS [%s]", appName, Version, Build, BuildTime) + if GitBranch != "" { + msg += fmt.Sprintf(", Git Branch [%s]", GitBranch) + } + logrus.Info(msg) + logrus.Info("------------------------------------------------------------------------") +} diff --git a/flytestdlib/version/version_test.go b/flytestdlib/version/version_test.go new file mode 100644 index 0000000000..933507567c --- /dev/null +++ b/flytestdlib/version/version_test.go @@ -0,0 +1,30 @@ +package version + +import ( + "bytes" + "fmt" + "testing" + "time" + + "github.com/magiconair/properties/assert" + "github.com/sirupsen/logrus" +) + +type dFormat struct { +} + +func (dFormat) Format(e *logrus.Entry) ([]byte, error) { + return []byte(e.Message), nil +} + +func TestLogBuildInformation(t *testing.T) { + + n := time.Now() + BuildTime = n.String() + GitBranch = "main" + buf := bytes.NewBufferString("") + logrus.SetFormatter(dFormat{}) + logrus.SetOutput(buf) + LogBuildInformation("hello") + assert.Equal(t, buf.String(), fmt.Sprintf("------------------------------------------------------------------------App [hello], Version [unknown], BuildSHA [unknown], BuildTS [%s], Git Branch [main]------------------------------------------------------------------------", n.String())) +} diff --git a/flytestdlib/yamlutils/yaml_json.go b/flytestdlib/yamlutils/yaml_json.go new file mode 100644 index 0000000000..152c6ce5f4 --- /dev/null +++ b/flytestdlib/yamlutils/yaml_json.go @@ -0,0 +1,17 @@ +package yamlutils + +import ( + "io/ioutil" + "path/filepath" + + "github.com/ghodss/yaml" +) + +func ReadYamlFileAsJSON(path string) ([]byte, error) { + r, err := ioutil.ReadFile(filepath.Clean(path)) + if err != nil { + return nil, err + } + + return yaml.YAMLToJSON(r) +} diff --git a/gen.Dockerfile b/gen.Dockerfile new file mode 100644 index 0000000000..067b0f24b2 --- /dev/null +++ b/gen.Dockerfile @@ -0,0 +1,130 @@ +# Flyte CI/Development Docker Image +# This image provides a consistent environment for both CI and local development +# Multi-stage build for parallel downloads and optimized caching + +# Get target architecture from buildx +ARG TARGETARCH +ARG TARGETOS + +# Set versions for all tools +ARG GO_VERSION=1.24.6 +ARG PYTHON_VERSION=3.12.9 +ARG NODE_VERSION=20.18.3 +ARG RUST_VERSION=1.84.0 +ARG UV_VERSION=0.8.4 +ARG BUF_VERSION=1.58.0 +ARG MOCKERY_VERSION=2.53.5 + +# Stage 1: Download Go (parallel) +FROM golang:${GO_VERSION}-alpine AS go-source +# Just copy from official image + +# Stage 2: Download Node.js (parallel) +FROM node:${NODE_VERSION}-bookworm-slim AS node-source +# Using Debian-based image for glibc compatibility with Ubuntu +RUN npm install -g pnpm + +# Stage 3: Download uv and Python (parallel) +FROM ubuntu:24.04 AS python-installer +ARG TARGETARCH +ARG UV_VERSION +ARG PYTHON_VERSION +ENV DEBIAN_FRONTEND=noninteractive +RUN apt-get update && apt-get install -y curl ca-certificates && rm -rf /var/lib/apt/lists/* +RUN curl -LsSf "https://astral.sh/uv/${UV_VERSION}/install.sh" | sh +ENV PATH="/root/.local/bin:${PATH}" +RUN uv python install ${PYTHON_VERSION} + +# Stage 4: Download Buf (parallel) +FROM alpine:latest AS buf-downloader +ARG TARGETARCH +ARG BUF_VERSION +RUN apk add --no-cache curl tar +RUN BUFARCH=$(case ${TARGETARCH} in amd64) echo "x86_64" ;; arm64) echo "aarch64" ;; *) echo "x86_64" ;; esac) && \ + curl -fsSL "https://github.com/bufbuild/buf/releases/download/v${BUF_VERSION}/buf-Linux-${BUFARCH}.tar.gz" | \ + tar -xzC /tmp + +# Stage 5: Final image +FROM ubuntu:24.04 + +# Prevent interactive prompts during package installation +ENV DEBIAN_FRONTEND=noninteractive + +# Set versions again for reference +ARG GO_VERSION +ARG PYTHON_VERSION +ARG NODE_VERSION +ARG RUST_VERSION +ARG UV_VERSION +ARG MOCKERY_VERSION + +# Install system dependencies with cache mount +RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \ + --mount=type=cache,target=/var/lib/apt,sharing=locked \ + apt-get update && apt-get install -y \ + # Basic tools + curl \ + wget \ + git \ + make \ + build-essential \ + ca-certificates \ + gnupg \ + lsb-release \ + unzip \ + xz-utils \ + jq \ + # Minimal Python build deps (most come from official Python) + libssl-dev \ + zlib1g-dev \ + && rm -rf /var/lib/apt/lists/* + +# Copy Go from official image +COPY --from=go-source /usr/local/go /usr/local/go +ENV PATH="/usr/local/go/bin:/root/go/bin:${PATH}" +ENV GOPATH="/root/go" + +# Copy uv and Python from installer stage +COPY --from=python-installer /root/.local /root/.local +COPY --from=python-installer /root/.local/share/uv /root/.local/share/uv +ENV PATH="/root/.local/bin:${PATH}" +RUN UV_PYTHON=$(uv python find ${PYTHON_VERSION}) && \ + ln -sf ${UV_PYTHON} /usr/local/bin/python3 && \ + ln -sf ${UV_PYTHON} /usr/local/bin/python + +# Copy Node.js from official image (using Debian-based for glibc compatibility) +# Copy the entire /usr/local structure to preserve npm/pnpm directory layout +COPY --from=node-source /usr/local /usr/local + +# Install Rust (still need to run installer for architecture detection) +RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain ${RUST_VERSION} --profile minimal +ENV PATH="/root/.cargo/bin:${PATH}" + +# Copy Buf from downloader stage +COPY --from=buf-downloader /tmp/buf/bin/buf /usr/local/bin/buf +COPY --from=buf-downloader /tmp/buf/bin/protoc-gen-buf-breaking /usr/local/bin/protoc-gen-buf-breaking +COPY --from=buf-downloader /tmp/buf/bin/protoc-gen-buf-lint /usr/local/bin/protoc-gen-buf-lint + +# Install Go tools with cache mount +RUN --mount=type=cache,target=/root/go/pkg/mod \ + --mount=type=cache,target=/root/.cache/go-build \ + go install "github.com/vektra/mockery/v2@v${MOCKERY_VERSION}" + +# Set working directory +WORKDIR /workspace + +# Verify installations & print versions +RUN echo "=== Tool Versions ===" && \ + echo "Go: $(go version)" && \ + echo "Python: $(python --version)" && \ + echo "uv: $(uv --version)" && \ + echo "Node: $(node --version)" && \ + echo "npm: $(npm --version)" && \ + echo "pnpm: $(pnpm --version)" && \ + echo "Rust: $(rustc --version)" && \ + echo "Cargo: $(cargo --version)" && \ + echo "Buf: $(buf --version)" && \ + echo "Mockery: $(mockery --version)" + +# Set default command +CMD ["/bin/bash"] diff --git a/gen/go/flyteidl2/app/app_definition.pb.go b/gen/go/flyteidl2/app/app_definition.pb.go new file mode 100644 index 0000000000..472705496b --- /dev/null +++ b/gen/go/flyteidl2/app/app_definition.pb.go @@ -0,0 +1,2865 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/app/app_definition.proto + +package app + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + durationpb "google.golang.org/protobuf/types/known/durationpb" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Enum for deployment status of the app. +type Status_DeploymentStatus int32 + +const ( + // Unspecified deployment status. + Status_DEPLOYMENT_STATUS_UNSPECIFIED Status_DeploymentStatus = 0 + // Deployment is enabled but hasn't been assigned to a cluster yet. + Status_DEPLOYMENT_STATUS_UNASSIGNED Status_DeploymentStatus = 1 + // Deployment is assigned to a cluster but hasn't been acknowledged yet. + Status_DEPLOYMENT_STATUS_ASSIGNED Status_DeploymentStatus = 2 + // Deployment is picked up by a cluster but is awaiting deployment. + Status_DEPLOYMENT_STATUS_PENDING Status_DeploymentStatus = 3 + // Deployment is disabled. + Status_DEPLOYMENT_STATUS_STOPPED Status_DeploymentStatus = 4 + // Deployment is completed. Please use DEPLOYMENT_STATUS_ACTIVE instead. + // + // Deprecated: Marked as deprecated in flyteidl2/app/app_definition.proto. + Status_DEPLOYMENT_STATUS_STARTED Status_DeploymentStatus = 5 + // Deployment has failed. + Status_DEPLOYMENT_STATUS_FAILED Status_DeploymentStatus = 6 + // Deployment is completed. + Status_DEPLOYMENT_STATUS_ACTIVE Status_DeploymentStatus = 7 + // Triggered in response to desired app replicas > actual app replicas + Status_DEPLOYMENT_STATUS_SCALING_UP Status_DeploymentStatus = 8 + // Triggered in response to desired app replicas < actual app replicas + Status_DEPLOYMENT_STATUS_SCALING_DOWN Status_DeploymentStatus = 9 + // Triggered in response to the latest app spec changing + Status_DEPLOYMENT_STATUS_DEPLOYING Status_DeploymentStatus = 10 +) + +// Enum value maps for Status_DeploymentStatus. +var ( + Status_DeploymentStatus_name = map[int32]string{ + 0: "DEPLOYMENT_STATUS_UNSPECIFIED", + 1: "DEPLOYMENT_STATUS_UNASSIGNED", + 2: "DEPLOYMENT_STATUS_ASSIGNED", + 3: "DEPLOYMENT_STATUS_PENDING", + 4: "DEPLOYMENT_STATUS_STOPPED", + 5: "DEPLOYMENT_STATUS_STARTED", + 6: "DEPLOYMENT_STATUS_FAILED", + 7: "DEPLOYMENT_STATUS_ACTIVE", + 8: "DEPLOYMENT_STATUS_SCALING_UP", + 9: "DEPLOYMENT_STATUS_SCALING_DOWN", + 10: "DEPLOYMENT_STATUS_DEPLOYING", + } + Status_DeploymentStatus_value = map[string]int32{ + "DEPLOYMENT_STATUS_UNSPECIFIED": 0, + "DEPLOYMENT_STATUS_UNASSIGNED": 1, + "DEPLOYMENT_STATUS_ASSIGNED": 2, + "DEPLOYMENT_STATUS_PENDING": 3, + "DEPLOYMENT_STATUS_STOPPED": 4, + "DEPLOYMENT_STATUS_STARTED": 5, + "DEPLOYMENT_STATUS_FAILED": 6, + "DEPLOYMENT_STATUS_ACTIVE": 7, + "DEPLOYMENT_STATUS_SCALING_UP": 8, + "DEPLOYMENT_STATUS_SCALING_DOWN": 9, + "DEPLOYMENT_STATUS_DEPLOYING": 10, + } +) + +func (x Status_DeploymentStatus) Enum() *Status_DeploymentStatus { + p := new(Status_DeploymentStatus) + *p = x + return p +} + +func (x Status_DeploymentStatus) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Status_DeploymentStatus) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_app_app_definition_proto_enumTypes[0].Descriptor() +} + +func (Status_DeploymentStatus) Type() protoreflect.EnumType { + return &file_flyteidl2_app_app_definition_proto_enumTypes[0] +} + +func (x Status_DeploymentStatus) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Status_DeploymentStatus.Descriptor instead. +func (Status_DeploymentStatus) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{5, 0} +} + +// Enum for deployment status of the app. +type Spec_DesiredState int32 + +const ( + // Unspecified state + Spec_DESIRED_STATE_UNSPECIFIED Spec_DesiredState = 0 + // Deployment is disabled. + Spec_DESIRED_STATE_STOPPED Spec_DesiredState = 1 + // Deployment is completed. Please use DESIRED_STATE_ACTIVE instead. + // + // Deprecated: Marked as deprecated in flyteidl2/app/app_definition.proto. + Spec_DESIRED_STATE_STARTED Spec_DesiredState = 2 + // Deployment is completed. + Spec_DESIRED_STATE_ACTIVE Spec_DesiredState = 3 +) + +// Enum value maps for Spec_DesiredState. +var ( + Spec_DesiredState_name = map[int32]string{ + 0: "DESIRED_STATE_UNSPECIFIED", + 1: "DESIRED_STATE_STOPPED", + 2: "DESIRED_STATE_STARTED", + 3: "DESIRED_STATE_ACTIVE", + } + Spec_DesiredState_value = map[string]int32{ + "DESIRED_STATE_UNSPECIFIED": 0, + "DESIRED_STATE_STOPPED": 1, + "DESIRED_STATE_STARTED": 2, + "DESIRED_STATE_ACTIVE": 3, + } +) + +func (x Spec_DesiredState) Enum() *Spec_DesiredState { + p := new(Spec_DesiredState) + *p = x + return p +} + +func (x Spec_DesiredState) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Spec_DesiredState) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_app_app_definition_proto_enumTypes[1].Descriptor() +} + +func (Spec_DesiredState) Type() protoreflect.EnumType { + return &file_flyteidl2_app_app_definition_proto_enumTypes[1] +} + +func (x Spec_DesiredState) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Spec_DesiredState.Descriptor instead. +func (Spec_DesiredState) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{8, 0} +} + +type Identifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Org that the app belongs to. + Org string `protobuf:"bytes,1,opt,name=org,proto3" json:"org,omitempty"` + // Project that the app belongs to. + Project string `protobuf:"bytes,2,opt,name=project,proto3" json:"project,omitempty"` + // Domain that the app belongs to. + Domain string `protobuf:"bytes,3,opt,name=domain,proto3" json:"domain,omitempty"` + // Name that the user provided for the app. + Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *Identifier) Reset() { + *x = Identifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Identifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Identifier) ProtoMessage() {} + +func (x *Identifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Identifier.ProtoReflect.Descriptor instead. +func (*Identifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{0} +} + +func (x *Identifier) GetOrg() string { + if x != nil { + return x.Org + } + return "" +} + +func (x *Identifier) GetProject() string { + if x != nil { + return x.Project + } + return "" +} + +func (x *Identifier) GetDomain() string { + if x != nil { + return x.Domain + } + return "" +} + +func (x *Identifier) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type Meta struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // ID of the app. + Id *Identifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // Revision of the app object. + Revision uint64 `protobuf:"varint,2,opt,name=revision,proto3" json:"revision,omitempty"` + // Labels for the app. + Labels map[string]string `protobuf:"bytes,3,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *Meta) Reset() { + *x = Meta{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Meta) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Meta) ProtoMessage() {} + +func (x *Meta) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Meta.ProtoReflect.Descriptor instead. +func (*Meta) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{1} +} + +func (x *Meta) GetId() *Identifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *Meta) GetRevision() uint64 { + if x != nil { + return x.Revision + } + return 0 +} + +func (x *Meta) GetLabels() map[string]string { + if x != nil { + return x.Labels + } + return nil +} + +// For internal usage only. This message is used to wrap the app message with the host. +type AppWrapper struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Host string `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"` + // Types that are assignable to Payload: + // + // *AppWrapper_App + // *AppWrapper_AppId + Payload isAppWrapper_Payload `protobuf_oneof:"payload"` +} + +func (x *AppWrapper) Reset() { + *x = AppWrapper{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AppWrapper) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AppWrapper) ProtoMessage() {} + +func (x *AppWrapper) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AppWrapper.ProtoReflect.Descriptor instead. +func (*AppWrapper) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{2} +} + +func (x *AppWrapper) GetHost() string { + if x != nil { + return x.Host + } + return "" +} + +func (m *AppWrapper) GetPayload() isAppWrapper_Payload { + if m != nil { + return m.Payload + } + return nil +} + +func (x *AppWrapper) GetApp() *App { + if x, ok := x.GetPayload().(*AppWrapper_App); ok { + return x.App + } + return nil +} + +func (x *AppWrapper) GetAppId() *Identifier { + if x, ok := x.GetPayload().(*AppWrapper_AppId); ok { + return x.AppId + } + return nil +} + +type isAppWrapper_Payload interface { + isAppWrapper_Payload() +} + +type AppWrapper_App struct { + App *App `protobuf:"bytes,2,opt,name=app,proto3,oneof"` +} + +type AppWrapper_AppId struct { + AppId *Identifier `protobuf:"bytes,3,opt,name=app_id,json=appId,proto3,oneof"` +} + +func (*AppWrapper_App) isAppWrapper_Payload() {} + +func (*AppWrapper_AppId) isAppWrapper_Payload() {} + +// Represents an app with its specification and status. +type App struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Metadata of the app. + Metadata *Meta `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` + // Specification of the app. + Spec *Spec `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"` + // Status of the app. + Status *Status `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"` +} + +func (x *App) Reset() { + *x = App{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *App) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*App) ProtoMessage() {} + +func (x *App) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use App.ProtoReflect.Descriptor instead. +func (*App) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{3} +} + +func (x *App) GetMetadata() *Meta { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *App) GetSpec() *Spec { + if x != nil { + return x.Spec + } + return nil +} + +func (x *App) GetStatus() *Status { + if x != nil { + return x.Status + } + return nil +} + +// Represents the condition of an app. +type Condition struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Last transition time of the condition. + LastTransitionTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=last_transition_time,json=lastTransitionTime,proto3" json:"last_transition_time,omitempty"` + // Deployment status of the app. + DeploymentStatus Status_DeploymentStatus `protobuf:"varint,2,opt,name=deployment_status,json=deploymentStatus,proto3,enum=flyteidl2.app.Status_DeploymentStatus" json:"deployment_status,omitempty"` + // Message for the condition. + Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"` + // Revision the Condition applies to. This can be used by consumers + // to introspect and visualize which revisions are up. + Revision uint64 `protobuf:"varint,4,opt,name=revision,proto3" json:"revision,omitempty"` + // Actor is the principal that caused the condition. + Actor *common.EnrichedIdentity `protobuf:"bytes,5,opt,name=actor,proto3" json:"actor,omitempty"` +} + +func (x *Condition) Reset() { + *x = Condition{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Condition) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Condition) ProtoMessage() {} + +func (x *Condition) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Condition.ProtoReflect.Descriptor instead. +func (*Condition) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{4} +} + +func (x *Condition) GetLastTransitionTime() *timestamppb.Timestamp { + if x != nil { + return x.LastTransitionTime + } + return nil +} + +func (x *Condition) GetDeploymentStatus() Status_DeploymentStatus { + if x != nil { + return x.DeploymentStatus + } + return Status_DEPLOYMENT_STATUS_UNSPECIFIED +} + +func (x *Condition) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +func (x *Condition) GetRevision() uint64 { + if x != nil { + return x.Revision + } + return 0 +} + +func (x *Condition) GetActor() *common.EnrichedIdentity { + if x != nil { + return x.Actor + } + return nil +} + +// Represents the status of an app. +type Status struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AssignedCluster string `protobuf:"bytes,1,opt,name=assigned_cluster,json=assignedCluster,proto3" json:"assigned_cluster,omitempty"` + // Current number of replicas. + CurrentReplicas uint32 `protobuf:"varint,2,opt,name=current_replicas,json=currentReplicas,proto3" json:"current_replicas,omitempty"` + // List of public URLs for the app. + Ingress *Ingress `protobuf:"bytes,3,opt,name=ingress,proto3" json:"ingress,omitempty"` + // CreatedAt is the time when the app was first created + CreatedAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` + // LastUpdatedAt is the time when the app was last updated + LastUpdatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=last_updated_at,json=lastUpdatedAt,proto3" json:"last_updated_at,omitempty"` + // Conditions for the app. + Conditions []*Condition `protobuf:"bytes,6,rep,name=conditions,proto3" json:"conditions,omitempty"` + // LeaseExpiration refers to how long the app is leased to a cluster for it to start processing it. If the lease + // period expires, the cluster will no longer be allowed to update this app and another cluster can pick it up. + LeaseExpiration *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=lease_expiration,json=leaseExpiration,proto3" json:"lease_expiration,omitempty"` + // K8sMetadata contains metadata about the app in the K8s cluster. + K8SMetadata *K8SMetadata `protobuf:"bytes,8,opt,name=k8s_metadata,json=k8sMetadata,proto3" json:"k8s_metadata,omitempty"` + MaterializedInputs *MaterializedInputs `protobuf:"bytes,9,opt,name=materialized_inputs,json=materializedInputs,proto3" json:"materialized_inputs,omitempty"` +} + +func (x *Status) Reset() { + *x = Status{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Status) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Status) ProtoMessage() {} + +func (x *Status) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Status.ProtoReflect.Descriptor instead. +func (*Status) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{5} +} + +func (x *Status) GetAssignedCluster() string { + if x != nil { + return x.AssignedCluster + } + return "" +} + +func (x *Status) GetCurrentReplicas() uint32 { + if x != nil { + return x.CurrentReplicas + } + return 0 +} + +func (x *Status) GetIngress() *Ingress { + if x != nil { + return x.Ingress + } + return nil +} + +func (x *Status) GetCreatedAt() *timestamppb.Timestamp { + if x != nil { + return x.CreatedAt + } + return nil +} + +func (x *Status) GetLastUpdatedAt() *timestamppb.Timestamp { + if x != nil { + return x.LastUpdatedAt + } + return nil +} + +func (x *Status) GetConditions() []*Condition { + if x != nil { + return x.Conditions + } + return nil +} + +func (x *Status) GetLeaseExpiration() *timestamppb.Timestamp { + if x != nil { + return x.LeaseExpiration + } + return nil +} + +func (x *Status) GetK8SMetadata() *K8SMetadata { + if x != nil { + return x.K8SMetadata + } + return nil +} + +func (x *Status) GetMaterializedInputs() *MaterializedInputs { + if x != nil { + return x.MaterializedInputs + } + return nil +} + +type K8SMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Namespace points to the namespace the app is deployed in. + Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"` +} + +func (x *K8SMetadata) Reset() { + *x = K8SMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *K8SMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*K8SMetadata) ProtoMessage() {} + +func (x *K8SMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use K8SMetadata.ProtoReflect.Descriptor instead. +func (*K8SMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{6} +} + +func (x *K8SMetadata) GetNamespace() string { + if x != nil { + return x.Namespace + } + return "" +} + +type Ingress struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Public URL of the app. + PublicUrl string `protobuf:"bytes,1,opt,name=public_url,json=publicUrl,proto3" json:"public_url,omitempty"` + // Canonical name (CNAME) URL of the app. + CnameUrl string `protobuf:"bytes,2,opt,name=cname_url,json=cnameUrl,proto3" json:"cname_url,omitempty"` + // VPC URL of the app. + VpcUrl string `protobuf:"bytes,3,opt,name=vpc_url,json=vpcUrl,proto3" json:"vpc_url,omitempty"` +} + +func (x *Ingress) Reset() { + *x = Ingress{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Ingress) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Ingress) ProtoMessage() {} + +func (x *Ingress) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Ingress.ProtoReflect.Descriptor instead. +func (*Ingress) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{7} +} + +func (x *Ingress) GetPublicUrl() string { + if x != nil { + return x.PublicUrl + } + return "" +} + +func (x *Ingress) GetCnameUrl() string { + if x != nil { + return x.CnameUrl + } + return "" +} + +func (x *Ingress) GetVpcUrl() string { + if x != nil { + return x.VpcUrl + } + return "" +} + +// Represents the specification of an app. +type Spec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Payload of the app, which can be either a container or a K8s pod. + // + // Types that are assignable to AppPayload: + // + // *Spec_Container + // *Spec_Pod + AppPayload isSpec_AppPayload `protobuf_oneof:"app_payload"` + // Autoscaling configuration for the app. + Autoscaling *AutoscalingConfig `protobuf:"bytes,3,opt,name=autoscaling,proto3" json:"autoscaling,omitempty"` + // Ingress configuration for the app. + Ingress *IngressConfig `protobuf:"bytes,4,opt,name=ingress,proto3" json:"ingress,omitempty"` + // Deployment status of the app. + DesiredState Spec_DesiredState `protobuf:"varint,5,opt,name=desired_state,json=desiredState,proto3,enum=flyteidl2.app.Spec_DesiredState" json:"desired_state,omitempty"` + // ClusterPool to place this app on. By default it'll use the default cluster pool. + ClusterPool string `protobuf:"bytes,6,opt,name=cluster_pool,json=clusterPool,proto3" json:"cluster_pool,omitempty"` + // Set of image specifications for the app. + Images *ImageSpecSet `protobuf:"bytes,7,opt,name=images,proto3" json:"images,omitempty"` + // security_context encapsulates security attributes requested to run this task. + SecurityContext *SecurityContext `protobuf:"bytes,8,opt,name=security_context,json=securityContext,proto3" json:"security_context,omitempty"` + // Encapsulates all non-standard resources, not captured by + // v1.ResourceRequirements, to allocate to a task. + ExtendedResources *core.ExtendedResources `protobuf:"bytes,9,opt,name=extended_resources,json=extendedResources,proto3" json:"extended_resources,omitempty"` + // Runtime metadata for the app. + RuntimeMetadata *common.RuntimeMetadata `protobuf:"bytes,10,opt,name=runtime_metadata,json=runtimeMetadata,proto3" json:"runtime_metadata,omitempty"` + // Profile of the app. + Profile *Profile `protobuf:"bytes,11,opt,name=profile,proto3" json:"profile,omitempty"` + // Creator of the app is the first principal that provisioned this app. Other principals may + // interact with the app by updating its spec or stopping/starting it. + Creator *common.EnrichedIdentity `protobuf:"bytes,12,opt,name=creator,proto3" json:"creator,omitempty"` + // Inputs of the app. + Inputs *InputList `protobuf:"bytes,13,opt,name=inputs,proto3" json:"inputs,omitempty"` + Links []*Link `protobuf:"bytes,14,rep,name=links,proto3" json:"links,omitempty"` + // Timeout configuration for the app. + Timeouts *TimeoutConfig `protobuf:"bytes,15,opt,name=timeouts,proto3" json:"timeouts,omitempty"` +} + +func (x *Spec) Reset() { + *x = Spec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Spec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Spec) ProtoMessage() {} + +func (x *Spec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Spec.ProtoReflect.Descriptor instead. +func (*Spec) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{8} +} + +func (m *Spec) GetAppPayload() isSpec_AppPayload { + if m != nil { + return m.AppPayload + } + return nil +} + +func (x *Spec) GetContainer() *core.Container { + if x, ok := x.GetAppPayload().(*Spec_Container); ok { + return x.Container + } + return nil +} + +func (x *Spec) GetPod() *core.K8SPod { + if x, ok := x.GetAppPayload().(*Spec_Pod); ok { + return x.Pod + } + return nil +} + +func (x *Spec) GetAutoscaling() *AutoscalingConfig { + if x != nil { + return x.Autoscaling + } + return nil +} + +func (x *Spec) GetIngress() *IngressConfig { + if x != nil { + return x.Ingress + } + return nil +} + +func (x *Spec) GetDesiredState() Spec_DesiredState { + if x != nil { + return x.DesiredState + } + return Spec_DESIRED_STATE_UNSPECIFIED +} + +func (x *Spec) GetClusterPool() string { + if x != nil { + return x.ClusterPool + } + return "" +} + +func (x *Spec) GetImages() *ImageSpecSet { + if x != nil { + return x.Images + } + return nil +} + +func (x *Spec) GetSecurityContext() *SecurityContext { + if x != nil { + return x.SecurityContext + } + return nil +} + +func (x *Spec) GetExtendedResources() *core.ExtendedResources { + if x != nil { + return x.ExtendedResources + } + return nil +} + +func (x *Spec) GetRuntimeMetadata() *common.RuntimeMetadata { + if x != nil { + return x.RuntimeMetadata + } + return nil +} + +func (x *Spec) GetProfile() *Profile { + if x != nil { + return x.Profile + } + return nil +} + +func (x *Spec) GetCreator() *common.EnrichedIdentity { + if x != nil { + return x.Creator + } + return nil +} + +func (x *Spec) GetInputs() *InputList { + if x != nil { + return x.Inputs + } + return nil +} + +func (x *Spec) GetLinks() []*Link { + if x != nil { + return x.Links + } + return nil +} + +func (x *Spec) GetTimeouts() *TimeoutConfig { + if x != nil { + return x.Timeouts + } + return nil +} + +type isSpec_AppPayload interface { + isSpec_AppPayload() +} + +type Spec_Container struct { + // Container payload. + Container *core.Container `protobuf:"bytes,1,opt,name=container,proto3,oneof"` +} + +type Spec_Pod struct { + // K8s pod payload. + Pod *core.K8SPod `protobuf:"bytes,2,opt,name=pod,proto3,oneof"` +} + +func (*Spec_Container) isSpec_AppPayload() {} + +func (*Spec_Pod) isSpec_AppPayload() {} + +// Represents a link to an external resource (Arize project link, W&B dashboard, etc) +type Link struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // URL of the external service. + // This can be an absolute or relative path. + Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` + // Human readable name of the external service. + Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"` + // Whether the path is absolute (default) or relative. + IsRelative bool `protobuf:"varint,3,opt,name=is_relative,json=isRelative,proto3" json:"is_relative,omitempty"` +} + +func (x *Link) Reset() { + *x = Link{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Link) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Link) ProtoMessage() {} + +func (x *Link) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Link.ProtoReflect.Descriptor instead. +func (*Link) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{9} +} + +func (x *Link) GetPath() string { + if x != nil { + return x.Path + } + return "" +} + +func (x *Link) GetTitle() string { + if x != nil { + return x.Title + } + return "" +} + +func (x *Link) GetIsRelative() bool { + if x != nil { + return x.IsRelative + } + return false +} + +type Input struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Name is a unique identifier of the input within the list of inputs of the app + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Types that are assignable to Value: + // + // *Input_StringValue + // *Input_ArtifactQuery + // *Input_ArtifactId + // *Input_AppId + Value isInput_Value `protobuf_oneof:"value"` +} + +func (x *Input) Reset() { + *x = Input{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Input) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Input) ProtoMessage() {} + +func (x *Input) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Input.ProtoReflect.Descriptor instead. +func (*Input) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{10} +} + +func (x *Input) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (m *Input) GetValue() isInput_Value { + if m != nil { + return m.Value + } + return nil +} + +func (x *Input) GetStringValue() string { + if x, ok := x.GetValue().(*Input_StringValue); ok { + return x.StringValue + } + return "" +} + +func (x *Input) GetArtifactQuery() *core.ArtifactQuery { + if x, ok := x.GetValue().(*Input_ArtifactQuery); ok { + return x.ArtifactQuery + } + return nil +} + +func (x *Input) GetArtifactId() *core.ArtifactID { + if x, ok := x.GetValue().(*Input_ArtifactId); ok { + return x.ArtifactId + } + return nil +} + +func (x *Input) GetAppId() *Identifier { + if x, ok := x.GetValue().(*Input_AppId); ok { + return x.AppId + } + return nil +} + +type isInput_Value interface { + isInput_Value() +} + +type Input_StringValue struct { + // StringValue is a plain string value for the input + StringValue string `protobuf:"bytes,2,opt,name=string_value,json=stringValue,proto3,oneof"` +} + +type Input_ArtifactQuery struct { + // ArtifactQuery is that should result in a single artifact that will be used as the input to the app at runtime. + // The artifact will be pinned at the time of the app creation. + ArtifactQuery *core.ArtifactQuery `protobuf:"bytes,3,opt,name=artifact_query,json=artifactQuery,proto3,oneof"` +} + +type Input_ArtifactId struct { + // ArtifactId is an identifier of an artifact that will be used as the input to the app at runtime. + ArtifactId *core.ArtifactID `protobuf:"bytes,4,opt,name=artifact_id,json=artifactId,proto3,oneof"` +} + +type Input_AppId struct { + // ID of the app. + AppId *Identifier `protobuf:"bytes,5,opt,name=app_id,json=appId,proto3,oneof"` +} + +func (*Input_StringValue) isInput_Value() {} + +func (*Input_ArtifactQuery) isInput_Value() {} + +func (*Input_ArtifactId) isInput_Value() {} + +func (*Input_AppId) isInput_Value() {} + +type MaterializedInputs struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Items []*MaterializedInput `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + // Revision of the app object that we materialized the input for. + Revision uint64 `protobuf:"varint,2,opt,name=revision,proto3" json:"revision,omitempty"` +} + +func (x *MaterializedInputs) Reset() { + *x = MaterializedInputs{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MaterializedInputs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MaterializedInputs) ProtoMessage() {} + +func (x *MaterializedInputs) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MaterializedInputs.ProtoReflect.Descriptor instead. +func (*MaterializedInputs) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{11} +} + +func (x *MaterializedInputs) GetItems() []*MaterializedInput { + if x != nil { + return x.Items + } + return nil +} + +func (x *MaterializedInputs) GetRevision() uint64 { + if x != nil { + return x.Revision + } + return 0 +} + +type MaterializedInput struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Name is a unique identifier of the input within the list of inputs of the app + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Types that are assignable to Value: + // + // *MaterializedInput_ArtifactId + Value isMaterializedInput_Value `protobuf_oneof:"value"` +} + +func (x *MaterializedInput) Reset() { + *x = MaterializedInput{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MaterializedInput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MaterializedInput) ProtoMessage() {} + +func (x *MaterializedInput) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MaterializedInput.ProtoReflect.Descriptor instead. +func (*MaterializedInput) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{12} +} + +func (x *MaterializedInput) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (m *MaterializedInput) GetValue() isMaterializedInput_Value { + if m != nil { + return m.Value + } + return nil +} + +func (x *MaterializedInput) GetArtifactId() *core.ArtifactID { + if x, ok := x.GetValue().(*MaterializedInput_ArtifactId); ok { + return x.ArtifactId + } + return nil +} + +type isMaterializedInput_Value interface { + isMaterializedInput_Value() +} + +type MaterializedInput_ArtifactId struct { + // ArtifactId is an identifier of an artifact that will be used as the input to the app at runtime. + ArtifactId *core.ArtifactID `protobuf:"bytes,2,opt,name=artifact_id,json=artifactId,proto3,oneof"` +} + +func (*MaterializedInput_ArtifactId) isMaterializedInput_Value() {} + +// InputList is a list of dependencies for the app. +type InputList struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Items is the list of inputs to fulfil for the app. + Items []*Input `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +} + +func (x *InputList) Reset() { + *x = InputList{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *InputList) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InputList) ProtoMessage() {} + +func (x *InputList) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use InputList.ProtoReflect.Descriptor instead. +func (*InputList) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{13} +} + +func (x *InputList) GetItems() []*Input { + if x != nil { + return x.Items + } + return nil +} + +type Profile struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // App Type (e.g. FastAPI, Flask, VLLM, NIM etc.) + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + // Friendly name of the app. + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + // Short description of the app. + ShortDescription string `protobuf:"bytes,3,opt,name=short_description,json=shortDescription,proto3" json:"short_description,omitempty"` + // Icon URL of the app. + IconUrl string `protobuf:"bytes,4,opt,name=icon_url,json=iconUrl,proto3" json:"icon_url,omitempty"` +} + +func (x *Profile) Reset() { + *x = Profile{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Profile) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Profile) ProtoMessage() {} + +func (x *Profile) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Profile.ProtoReflect.Descriptor instead. +func (*Profile) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{14} +} + +func (x *Profile) GetType() string { + if x != nil { + return x.Type + } + return "" +} + +func (x *Profile) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Profile) GetShortDescription() string { + if x != nil { + return x.ShortDescription + } + return "" +} + +func (x *Profile) GetIconUrl() string { + if x != nil { + return x.IconUrl + } + return "" +} + +// SecurityContext holds security attributes that apply to tasks. +type SecurityContext struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // run_as encapsulates the identity a pod should run as. If the task fills in multiple fields here, it'll be up to the + // backend plugin to choose the appropriate identity for the execution engine the task will run on. + RunAs *core.Identity `protobuf:"bytes,1,opt,name=run_as,json=runAs,proto3" json:"run_as,omitempty"` + // secrets indicate the list of secrets the task needs in order to proceed. Secrets will be mounted/passed to the + // pod as it starts. If the plugin responsible for kicking of the task will not run it on a flyte cluster (e.g. AWS + // Batch), it's the responsibility of the plugin to fetch the secret (which means propeller identity will need access + // to the secret) and to pass it to the remote execution engine. + Secrets []*core.Secret `protobuf:"bytes,2,rep,name=secrets,proto3" json:"secrets,omitempty"` + // AllowAnonymous indicates if the app should be accessible without authentication. This assumes the app will handle + // its own authentication or that it's a public app. + AllowAnonymous bool `protobuf:"varint,5,opt,name=allow_anonymous,json=allowAnonymous,proto3" json:"allow_anonymous,omitempty"` +} + +func (x *SecurityContext) Reset() { + *x = SecurityContext{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SecurityContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SecurityContext) ProtoMessage() {} + +func (x *SecurityContext) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SecurityContext.ProtoReflect.Descriptor instead. +func (*SecurityContext) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{15} +} + +func (x *SecurityContext) GetRunAs() *core.Identity { + if x != nil { + return x.RunAs + } + return nil +} + +func (x *SecurityContext) GetSecrets() []*core.Secret { + if x != nil { + return x.Secrets + } + return nil +} + +func (x *SecurityContext) GetAllowAnonymous() bool { + if x != nil { + return x.AllowAnonymous + } + return false +} + +type ImageSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Tag of the image. + Tag string `protobuf:"bytes,1,opt,name=tag,proto3" json:"tag,omitempty"` + // URL of the build job for the image. + BuildJobUrl string `protobuf:"bytes,2,opt,name=build_job_url,json=buildJobUrl,proto3" json:"build_job_url,omitempty"` +} + +func (x *ImageSpec) Reset() { + *x = ImageSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ImageSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ImageSpec) ProtoMessage() {} + +func (x *ImageSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[16] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ImageSpec.ProtoReflect.Descriptor instead. +func (*ImageSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{16} +} + +func (x *ImageSpec) GetTag() string { + if x != nil { + return x.Tag + } + return "" +} + +func (x *ImageSpec) GetBuildJobUrl() string { + if x != nil { + return x.BuildJobUrl + } + return "" +} + +type ImageSpecSet struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // List of image specifications. + Images []*ImageSpec `protobuf:"bytes,1,rep,name=images,proto3" json:"images,omitempty"` +} + +func (x *ImageSpecSet) Reset() { + *x = ImageSpecSet{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ImageSpecSet) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ImageSpecSet) ProtoMessage() {} + +func (x *ImageSpecSet) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ImageSpecSet.ProtoReflect.Descriptor instead. +func (*ImageSpecSet) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{17} +} + +func (x *ImageSpecSet) GetImages() []*ImageSpec { + if x != nil { + return x.Images + } + return nil +} + +// Represents the ingress configuration of an app. +type IngressConfig struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Indicates if the app should be private. + Private bool `protobuf:"varint,1,opt,name=private,proto3" json:"private,omitempty"` + // Subdomain for the app. If not specified, a random subdomain will be generated. + Subdomain string `protobuf:"bytes,2,opt,name=subdomain,proto3" json:"subdomain,omitempty"` + // Canonical name (CNAME) for the app. + Cname string `protobuf:"bytes,3,opt,name=cname,proto3" json:"cname,omitempty"` +} + +func (x *IngressConfig) Reset() { + *x = IngressConfig{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *IngressConfig) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IngressConfig) ProtoMessage() {} + +func (x *IngressConfig) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[18] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use IngressConfig.ProtoReflect.Descriptor instead. +func (*IngressConfig) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{18} +} + +func (x *IngressConfig) GetPrivate() bool { + if x != nil { + return x.Private + } + return false +} + +func (x *IngressConfig) GetSubdomain() string { + if x != nil { + return x.Subdomain + } + return "" +} + +func (x *IngressConfig) GetCname() string { + if x != nil { + return x.Cname + } + return "" +} + +// Represents the autoscaling configuration of an app. +type AutoscalingConfig struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Configuration for the number of replicas. + Replicas *Replicas `protobuf:"bytes,1,opt,name=replicas,proto3" json:"replicas,omitempty"` + // The period for scaling down the object. + ScaledownPeriod *durationpb.Duration `protobuf:"bytes,2,opt,name=scaledown_period,json=scaledownPeriod,proto3" json:"scaledown_period,omitempty"` + // Metric for scaling the app. + ScalingMetric *ScalingMetric `protobuf:"bytes,3,opt,name=scaling_metric,json=scalingMetric,proto3" json:"scaling_metric,omitempty"` +} + +func (x *AutoscalingConfig) Reset() { + *x = AutoscalingConfig{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AutoscalingConfig) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AutoscalingConfig) ProtoMessage() {} + +func (x *AutoscalingConfig) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[19] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AutoscalingConfig.ProtoReflect.Descriptor instead. +func (*AutoscalingConfig) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{19} +} + +func (x *AutoscalingConfig) GetReplicas() *Replicas { + if x != nil { + return x.Replicas + } + return nil +} + +func (x *AutoscalingConfig) GetScaledownPeriod() *durationpb.Duration { + if x != nil { + return x.ScaledownPeriod + } + return nil +} + +func (x *AutoscalingConfig) GetScalingMetric() *ScalingMetric { + if x != nil { + return x.ScalingMetric + } + return nil +} + +// ScalingMetric allows different scaling strategies for the app. +// See: https://knative.dev/docs/serving/autoscaling/autoscaling-metrics/ +type ScalingMetric struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Metric: + // + // *ScalingMetric_RequestRate + // *ScalingMetric_Concurrency + Metric isScalingMetric_Metric `protobuf_oneof:"metric"` +} + +func (x *ScalingMetric) Reset() { + *x = ScalingMetric{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ScalingMetric) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ScalingMetric) ProtoMessage() {} + +func (x *ScalingMetric) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[20] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ScalingMetric.ProtoReflect.Descriptor instead. +func (*ScalingMetric) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{20} +} + +func (m *ScalingMetric) GetMetric() isScalingMetric_Metric { + if m != nil { + return m.Metric + } + return nil +} + +func (x *ScalingMetric) GetRequestRate() *RequestRate { + if x, ok := x.GetMetric().(*ScalingMetric_RequestRate); ok { + return x.RequestRate + } + return nil +} + +func (x *ScalingMetric) GetConcurrency() *Concurrency { + if x, ok := x.GetMetric().(*ScalingMetric_Concurrency); ok { + return x.Concurrency + } + return nil +} + +type isScalingMetric_Metric interface { + isScalingMetric_Metric() +} + +type ScalingMetric_RequestRate struct { + // Configuration for scaling based on request rate. + RequestRate *RequestRate `protobuf:"bytes,1,opt,name=request_rate,json=requestRate,proto3,oneof"` +} + +type ScalingMetric_Concurrency struct { + // Configuration for scaling based on concurrency. + Concurrency *Concurrency `protobuf:"bytes,2,opt,name=concurrency,proto3,oneof"` +} + +func (*ScalingMetric_RequestRate) isScalingMetric_Metric() {} + +func (*ScalingMetric_Concurrency) isScalingMetric_Metric() {} + +// This section enables scaling based on the request concurrency. Concurrency calculates how many +// requests are being processed at the same time. This is useful for apps that take longer to process +// requests (e.g. seconds) +// The autoscaler has a default window of 60 seconds to calculate the concurrency value. However, it has +// panic mode that kicks in if the request rate jumps to 2x its value within 6 seconds. If that's +// triggered, it'll start scaling up immediately instead of waiting for the full 60 seconds. +type Concurrency struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // This is the target value for the scaling configuration. + // default=100 + TargetValue uint32 `protobuf:"varint,1,opt,name=target_value,json=targetValue,proto3" json:"target_value,omitempty"` +} + +func (x *Concurrency) Reset() { + *x = Concurrency{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Concurrency) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Concurrency) ProtoMessage() {} + +func (x *Concurrency) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[21] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Concurrency.ProtoReflect.Descriptor instead. +func (*Concurrency) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{21} +} + +func (x *Concurrency) GetTargetValue() uint32 { + if x != nil { + return x.TargetValue + } + return 0 +} + +// RequestRate enables scaling based on the request rate. Request rate calculates how many requests +// the app is receiving per second. +// The autoscaler has a default window of 60 seconds to calculate the request rate. However, it has +// panic mode that kicks in if the request rate jumps to 2x its value within 6 seconds. If that's +// triggered, it'll start scaling up immediately instead of waiting for the full 60 seconds. +type RequestRate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // This is the target value for the scaling configuration. + // default=100 + TargetValue uint32 `protobuf:"varint,1,opt,name=target_value,json=targetValue,proto3" json:"target_value,omitempty"` +} + +func (x *RequestRate) Reset() { + *x = RequestRate{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RequestRate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequestRate) ProtoMessage() {} + +func (x *RequestRate) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[22] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequestRate.ProtoReflect.Descriptor instead. +func (*RequestRate) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{22} +} + +func (x *RequestRate) GetTargetValue() uint32 { + if x != nil { + return x.TargetValue + } + return 0 +} + +// Represents the configuration for the number of replicas. +type Replicas struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Minimum number of replicas. + Min uint32 `protobuf:"varint,1,opt,name=min,proto3" json:"min,omitempty"` + // Maximum number of replicas. + Max uint32 `protobuf:"varint,2,opt,name=max,proto3" json:"max,omitempty"` +} + +func (x *Replicas) Reset() { + *x = Replicas{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Replicas) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Replicas) ProtoMessage() {} + +func (x *Replicas) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[23] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Replicas.ProtoReflect.Descriptor instead. +func (*Replicas) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{23} +} + +func (x *Replicas) GetMin() uint32 { + if x != nil { + return x.Min + } + return 0 +} + +func (x *Replicas) GetMax() uint32 { + if x != nil { + return x.Max + } + return 0 +} + +type TimeoutConfig struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // This is the maximum duration that the request instance + // is allowed to respond to a request. If unspecified, a system default will + // be provided. + // default=300s + RequestTimeout *durationpb.Duration `protobuf:"bytes,1,opt,name=request_timeout,json=requestTimeout,proto3" json:"request_timeout,omitempty"` +} + +func (x *TimeoutConfig) Reset() { + *x = TimeoutConfig{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TimeoutConfig) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TimeoutConfig) ProtoMessage() {} + +func (x *TimeoutConfig) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_definition_proto_msgTypes[24] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TimeoutConfig.ProtoReflect.Descriptor instead. +func (*TimeoutConfig) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_definition_proto_rawDescGZIP(), []int{24} +} + +func (x *TimeoutConfig) GetRequestTimeout() *durationpb.Duration { + if x != nil { + return x.RequestTimeout + } + return nil +} + +var File_flyteidl2_app_app_definition_proto protoreflect.FileDescriptor + +var file_flyteidl2_app_app_definition_proto_rawDesc = []byte{ + 0x0a, 0x22, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, + 0x61, 0x70, 0x70, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x61, 0x70, 0x70, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, + 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x26, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2f, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, + 0x63, 0x74, 0x5f, 0x69, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x73, 0x65, 0x63, 0x75, + 0x72, 0x69, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xb2, 0x01, 0x0a, 0x0a, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x21, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, + 0x10, 0x01, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, 0x0a, 0x06, 0x64, + 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, + 0x72, 0x02, 0x10, 0x01, 0x52, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x4e, 0x0a, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x3a, 0xba, 0x48, 0x37, 0x72, + 0x35, 0x10, 0x01, 0x18, 0x1e, 0x32, 0x2f, 0x5e, 0x5b, 0x41, 0x2d, 0x5a, 0x61, 0x2d, 0x7a, 0x30, + 0x2d, 0x39, 0x5d, 0x28, 0x3f, 0x3a, 0x5b, 0x41, 0x2d, 0x5a, 0x61, 0x2d, 0x7a, 0x30, 0x2d, 0x39, + 0x2d, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x31, 0x7d, 0x5b, 0x41, 0x2d, 0x5a, 0x61, 0x2d, 0x7a, 0x30, + 0x2d, 0x39, 0x5d, 0x29, 0x3f, 0x24, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0xd2, 0x01, 0x0a, + 0x04, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x31, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, + 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0x23, 0x0a, 0x08, 0x72, 0x65, 0x76, 0x69, + 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x42, 0x07, 0xba, 0x48, 0x04, 0x32, + 0x02, 0x28, 0x00, 0x52, 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x37, 0x0a, + 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x4d, 0x65, + 0x74, 0x61, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, + 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x1a, 0x39, 0x0a, 0x0b, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, + 0x01, 0x22, 0x87, 0x01, 0x0a, 0x0a, 0x41, 0x70, 0x70, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, + 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x68, 0x6f, 0x73, 0x74, 0x12, 0x26, 0x0a, 0x03, 0x61, 0x70, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x2e, 0x41, 0x70, 0x70, 0x48, 0x00, 0x52, 0x03, 0x61, 0x70, 0x70, 0x12, 0x32, 0x0a, 0x06, + 0x61, 0x70, 0x70, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x05, 0x61, 0x70, 0x70, 0x49, 0x64, + 0x42, 0x09, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x9e, 0x01, 0x0a, 0x03, + 0x41, 0x70, 0x70, 0x12, 0x37, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, + 0x01, 0x01, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x2f, 0x0a, 0x04, + 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x53, 0x70, 0x65, 0x63, 0x42, + 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x04, 0x73, 0x70, 0x65, 0x63, 0x12, 0x2d, 0x0a, + 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0xa7, 0x02, 0x0a, + 0x09, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x4c, 0x0a, 0x14, 0x6c, 0x61, + 0x73, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x53, 0x0a, 0x11, 0x64, 0x65, 0x70, 0x6c, + 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x61, 0x70, 0x70, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x44, 0x65, 0x70, 0x6c, 0x6f, + 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x10, 0x64, 0x65, 0x70, + 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, + 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x23, 0x0a, 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, + 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x42, 0x07, 0xba, 0x48, 0x04, 0x32, 0x02, + 0x28, 0x00, 0x52, 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x38, 0x0a, 0x05, + 0x61, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x45, + 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, + 0x05, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x22, 0xaa, 0x07, 0x0a, 0x06, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x12, 0x29, 0x0a, 0x10, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x63, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x61, 0x73, 0x73, + 0x69, 0x67, 0x6e, 0x65, 0x64, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, 0x32, 0x0a, 0x10, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, 0x02, 0x28, 0x00, 0x52, + 0x0f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, + 0x12, 0x30, 0x0a, 0x07, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x2e, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x52, 0x07, 0x69, 0x6e, 0x67, 0x72, 0x65, + 0x73, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x42, 0x0a, + 0x0f, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x52, 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, + 0x74, 0x12, 0x38, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, + 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x45, 0x0a, 0x10, 0x6c, + 0x65, 0x61, 0x73, 0x65, 0x5f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, + 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x52, 0x0f, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x45, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x3d, 0x0a, 0x0c, 0x6b, 0x38, 0x73, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x4b, 0x38, 0x73, 0x4d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x52, 0x0b, 0x6b, 0x38, 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x12, 0x52, 0x0a, 0x13, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, + 0x64, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x4d, + 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x49, 0x6e, 0x70, 0x75, 0x74, + 0x73, 0x52, 0x12, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x49, + 0x6e, 0x70, 0x75, 0x74, 0x73, 0x22, 0xfb, 0x02, 0x0a, 0x10, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, + 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x21, 0x0a, 0x1d, 0x44, 0x45, + 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, + 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x20, 0x0a, + 0x1c, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, + 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x45, 0x44, 0x10, 0x01, 0x12, + 0x1e, 0x0a, 0x1a, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x53, 0x54, + 0x41, 0x54, 0x55, 0x53, 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x45, 0x44, 0x10, 0x02, 0x12, + 0x1d, 0x0a, 0x19, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x53, 0x54, + 0x41, 0x54, 0x55, 0x53, 0x5f, 0x50, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x03, 0x12, 0x1d, + 0x0a, 0x19, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x53, 0x54, 0x41, + 0x54, 0x55, 0x53, 0x5f, 0x53, 0x54, 0x4f, 0x50, 0x50, 0x45, 0x44, 0x10, 0x04, 0x12, 0x21, 0x0a, + 0x19, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, + 0x55, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x52, 0x54, 0x45, 0x44, 0x10, 0x05, 0x1a, 0x02, 0x08, 0x01, + 0x12, 0x1c, 0x0a, 0x18, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x53, + 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x10, 0x06, 0x12, 0x1c, + 0x0a, 0x18, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x53, 0x54, 0x41, + 0x54, 0x55, 0x53, 0x5f, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x10, 0x07, 0x12, 0x20, 0x0a, 0x1c, + 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, + 0x53, 0x5f, 0x53, 0x43, 0x41, 0x4c, 0x49, 0x4e, 0x47, 0x5f, 0x55, 0x50, 0x10, 0x08, 0x12, 0x22, + 0x0a, 0x1e, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x53, 0x54, 0x41, + 0x54, 0x55, 0x53, 0x5f, 0x53, 0x43, 0x41, 0x4c, 0x49, 0x4e, 0x47, 0x5f, 0x44, 0x4f, 0x57, 0x4e, + 0x10, 0x09, 0x12, 0x1f, 0x0a, 0x1b, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, + 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x49, 0x4e, + 0x47, 0x10, 0x0a, 0x22, 0x2b, 0x0a, 0x0b, 0x4b, 0x38, 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, + 0x22, 0x85, 0x01, 0x0a, 0x07, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x12, 0x2a, 0x0a, 0x0a, + 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x42, 0x0b, 0xba, 0x48, 0x08, 0xd8, 0x01, 0x01, 0x72, 0x03, 0x88, 0x01, 0x01, 0x52, 0x09, 0x70, + 0x75, 0x62, 0x6c, 0x69, 0x63, 0x55, 0x72, 0x6c, 0x12, 0x28, 0x0a, 0x09, 0x63, 0x6e, 0x61, 0x6d, + 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0b, 0xba, 0x48, 0x08, + 0xd8, 0x01, 0x01, 0x72, 0x03, 0x88, 0x01, 0x01, 0x52, 0x08, 0x63, 0x6e, 0x61, 0x6d, 0x65, 0x55, + 0x72, 0x6c, 0x12, 0x24, 0x0a, 0x07, 0x76, 0x70, 0x63, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x42, 0x0b, 0xba, 0x48, 0x08, 0xd8, 0x01, 0x01, 0x72, 0x03, 0x88, 0x01, 0x01, + 0x52, 0x06, 0x76, 0x70, 0x63, 0x55, 0x72, 0x6c, 0x22, 0x94, 0x08, 0x0a, 0x04, 0x53, 0x70, 0x65, + 0x63, 0x12, 0x39, 0x0a, 0x09, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x48, + 0x00, 0x52, 0x09, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x12, 0x2a, 0x0a, 0x03, + 0x70, 0x6f, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x38, 0x73, 0x50, 0x6f, + 0x64, 0x48, 0x00, 0x52, 0x03, 0x70, 0x6f, 0x64, 0x12, 0x42, 0x0a, 0x0b, 0x61, 0x75, 0x74, 0x6f, + 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x41, 0x75, + 0x74, 0x6f, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, + 0x0b, 0x61, 0x75, 0x74, 0x6f, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x12, 0x36, 0x0a, 0x07, + 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x49, 0x6e, + 0x67, 0x72, 0x65, 0x73, 0x73, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x07, 0x69, 0x6e, 0x67, + 0x72, 0x65, 0x73, 0x73, 0x12, 0x45, 0x0a, 0x0d, 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x5f, + 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x53, 0x70, 0x65, 0x63, + 0x2e, 0x44, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x0c, 0x64, + 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x63, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x70, 0x6f, 0x6f, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x50, 0x6f, 0x6f, 0x6c, 0x12, 0x33, + 0x0a, 0x06, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x49, + 0x6d, 0x61, 0x67, 0x65, 0x53, 0x70, 0x65, 0x63, 0x53, 0x65, 0x74, 0x52, 0x06, 0x69, 0x6d, 0x61, + 0x67, 0x65, 0x73, 0x12, 0x49, 0x0a, 0x10, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x5f, + 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x53, 0x65, + 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, 0x0f, 0x73, + 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x50, + 0x0a, 0x12, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x45, 0x78, 0x74, 0x65, + 0x6e, 0x64, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x52, 0x11, 0x65, + 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, + 0x12, 0x4c, 0x0a, 0x10, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x75, + 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x0f, 0x72, + 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x30, + 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, + 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, + 0x12, 0x3c, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x0c, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x30, + 0x0a, 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x49, + 0x6e, 0x70, 0x75, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, + 0x12, 0x29, 0x0a, 0x05, 0x6c, 0x69, 0x6e, 0x6b, 0x73, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x13, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, + 0x4c, 0x69, 0x6e, 0x6b, 0x52, 0x05, 0x6c, 0x69, 0x6e, 0x6b, 0x73, 0x12, 0x38, 0x0a, 0x08, 0x74, + 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x54, 0x69, + 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x08, 0x74, 0x69, 0x6d, + 0x65, 0x6f, 0x75, 0x74, 0x73, 0x22, 0x81, 0x01, 0x0a, 0x0c, 0x44, 0x65, 0x73, 0x69, 0x72, 0x65, + 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x1d, 0x0a, 0x19, 0x44, 0x45, 0x53, 0x49, 0x52, 0x45, + 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, + 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x19, 0x0a, 0x15, 0x44, 0x45, 0x53, 0x49, 0x52, 0x45, 0x44, + 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x54, 0x4f, 0x50, 0x50, 0x45, 0x44, 0x10, 0x01, + 0x12, 0x1d, 0x0a, 0x15, 0x44, 0x45, 0x53, 0x49, 0x52, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, + 0x45, 0x5f, 0x53, 0x54, 0x41, 0x52, 0x54, 0x45, 0x44, 0x10, 0x02, 0x1a, 0x02, 0x08, 0x01, 0x12, + 0x18, 0x0a, 0x14, 0x44, 0x45, 0x53, 0x49, 0x52, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, + 0x5f, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x10, 0x03, 0x42, 0x14, 0x0a, 0x0b, 0x61, 0x70, 0x70, + 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, + 0x5a, 0x0a, 0x04, 0x4c, 0x69, 0x6e, 0x6b, 0x12, 0x1b, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, + 0x70, 0x61, 0x74, 0x68, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x73, + 0x5f, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x0a, 0x69, 0x73, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x22, 0x9d, 0x02, 0x0a, 0x05, + 0x49, 0x6e, 0x70, 0x75, 0x74, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x12, 0x2c, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, + 0x01, 0x48, 0x00, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x12, 0x46, 0x0a, 0x0e, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x71, 0x75, 0x65, + 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, + 0x63, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x48, 0x00, 0x52, 0x0d, 0x61, 0x72, 0x74, 0x69, 0x66, + 0x61, 0x63, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x3d, 0x0a, 0x0b, 0x61, 0x72, 0x74, 0x69, + 0x66, 0x61, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, + 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x44, 0x48, 0x00, 0x52, 0x0a, 0x61, 0x72, 0x74, + 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x64, 0x12, 0x32, 0x0a, 0x06, 0x61, 0x70, 0x70, 0x5f, 0x69, + 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x48, 0x00, 0x52, 0x05, 0x61, 0x70, 0x70, 0x49, 0x64, 0x42, 0x0e, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, 0x71, 0x0a, 0x12, 0x4d, + 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x49, 0x6e, 0x70, 0x75, 0x74, + 0x73, 0x12, 0x36, 0x0a, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, + 0x2e, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x49, 0x6e, 0x70, + 0x75, 0x74, 0x52, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x12, 0x23, 0x0a, 0x08, 0x72, 0x65, 0x76, + 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x42, 0x07, 0xba, 0x48, 0x04, + 0x32, 0x02, 0x28, 0x00, 0x52, 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x7f, + 0x0a, 0x11, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x49, 0x6e, + 0x70, 0x75, 0x74, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x12, 0x3d, 0x0a, 0x0b, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, + 0x44, 0x48, 0x00, 0x52, 0x0a, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x64, 0x42, + 0x0e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, + 0x37, 0x0a, 0x09, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x2a, 0x0a, 0x05, + 0x69, 0x74, 0x65, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x49, 0x6e, 0x70, 0x75, + 0x74, 0x52, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x82, 0x01, 0x0a, 0x07, 0x50, 0x72, 0x6f, + 0x66, 0x69, 0x6c, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x34, 0x0a, 0x11, + 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x18, 0x64, + 0x52, 0x10, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x19, 0x0a, 0x08, 0x69, 0x63, 0x6f, 0x6e, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x69, 0x63, 0x6f, 0x6e, 0x55, 0x72, 0x6c, 0x22, 0xa9, 0x01, + 0x0a, 0x0f, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, + 0x74, 0x12, 0x2f, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x05, 0x72, 0x75, 0x6e, + 0x41, 0x73, 0x12, 0x30, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x07, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x61, 0x6e, + 0x6f, 0x6e, 0x79, 0x6d, 0x6f, 0x75, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x61, + 0x6c, 0x6c, 0x6f, 0x77, 0x41, 0x6e, 0x6f, 0x6e, 0x79, 0x6d, 0x6f, 0x75, 0x73, 0x4a, 0x04, 0x08, + 0x03, 0x10, 0x04, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x22, 0x41, 0x0a, 0x09, 0x49, 0x6d, 0x61, + 0x67, 0x65, 0x53, 0x70, 0x65, 0x63, 0x12, 0x10, 0x0a, 0x03, 0x74, 0x61, 0x67, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x74, 0x61, 0x67, 0x12, 0x22, 0x0a, 0x0d, 0x62, 0x75, 0x69, 0x6c, + 0x64, 0x5f, 0x6a, 0x6f, 0x62, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0b, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x4a, 0x6f, 0x62, 0x55, 0x72, 0x6c, 0x22, 0x40, 0x0a, 0x0c, + 0x49, 0x6d, 0x61, 0x67, 0x65, 0x53, 0x70, 0x65, 0x63, 0x53, 0x65, 0x74, 0x12, 0x30, 0x0a, 0x06, + 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x49, 0x6d, 0x61, + 0x67, 0x65, 0x53, 0x70, 0x65, 0x63, 0x52, 0x06, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x22, 0x5d, + 0x0a, 0x0d, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, + 0x18, 0x0a, 0x07, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x07, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x75, 0x62, + 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x75, + 0x62, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0xd3, 0x01, + 0x0a, 0x11, 0x41, 0x75, 0x74, 0x6f, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x12, 0x33, 0x0a, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x52, 0x08, + 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x44, 0x0a, 0x10, 0x73, 0x63, 0x61, 0x6c, + 0x65, 0x64, 0x6f, 0x77, 0x6e, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0f, 0x73, + 0x63, 0x61, 0x6c, 0x65, 0x64, 0x6f, 0x77, 0x6e, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x43, + 0x0a, 0x0e, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x53, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x4d, 0x65, + 0x74, 0x72, 0x69, 0x63, 0x52, 0x0d, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x4d, 0x65, 0x74, + 0x72, 0x69, 0x63, 0x22, 0xa1, 0x01, 0x0a, 0x0d, 0x53, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x4d, + 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x3f, 0x0a, 0x0c, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x52, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x52, 0x61, 0x74, 0x65, 0x12, 0x3e, 0x0a, 0x0b, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x43, 0x6f, 0x6e, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x48, 0x00, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x42, 0x0f, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, + 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, 0x39, 0x0a, 0x0b, 0x43, 0x6f, 0x6e, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x2a, 0x0a, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, + 0x04, 0x2a, 0x02, 0x20, 0x00, 0x52, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x22, 0x39, 0x0a, 0x0b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x61, 0x74, + 0x65, 0x12, 0x2a, 0x0a, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, 0x02, 0x28, 0x00, + 0x52, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x40, 0x0a, + 0x08, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x19, 0x0a, 0x03, 0x6d, 0x69, 0x6e, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, 0x02, 0x28, 0x00, 0x52, + 0x03, 0x6d, 0x69, 0x6e, 0x12, 0x19, 0x0a, 0x03, 0x6d, 0x61, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, 0x02, 0x28, 0x00, 0x52, 0x03, 0x6d, 0x61, 0x78, 0x22, + 0x62, 0x0a, 0x0d, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 0x12, 0x51, 0x0a, 0x0f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, + 0x6f, 0x75, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x0d, 0xba, 0x48, 0x0a, 0xaa, 0x01, 0x07, 0x22, 0x03, 0x08, 0x90, + 0x1c, 0x32, 0x00, 0x52, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x54, 0x69, 0x6d, 0x65, + 0x6f, 0x75, 0x74, 0x42, 0xb1, 0x01, 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x42, 0x12, 0x41, 0x70, 0x70, 0x44, 0x65, + 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, + 0x01, 0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, + 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x61, 0x70, 0x70, 0xa2, 0x02, 0x03, 0x46, 0x41, 0x58, 0xaa, 0x02, 0x0d, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x41, 0x70, 0x70, 0xca, 0x02, 0x0d, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, 0xe2, 0x02, 0x19, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x3a, 0x3a, 0x41, 0x70, 0x70, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_app_app_definition_proto_rawDescOnce sync.Once + file_flyteidl2_app_app_definition_proto_rawDescData = file_flyteidl2_app_app_definition_proto_rawDesc +) + +func file_flyteidl2_app_app_definition_proto_rawDescGZIP() []byte { + file_flyteidl2_app_app_definition_proto_rawDescOnce.Do(func() { + file_flyteidl2_app_app_definition_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_app_app_definition_proto_rawDescData) + }) + return file_flyteidl2_app_app_definition_proto_rawDescData +} + +var file_flyteidl2_app_app_definition_proto_enumTypes = make([]protoimpl.EnumInfo, 2) +var file_flyteidl2_app_app_definition_proto_msgTypes = make([]protoimpl.MessageInfo, 26) +var file_flyteidl2_app_app_definition_proto_goTypes = []interface{}{ + (Status_DeploymentStatus)(0), // 0: flyteidl2.app.Status.DeploymentStatus + (Spec_DesiredState)(0), // 1: flyteidl2.app.Spec.DesiredState + (*Identifier)(nil), // 2: flyteidl2.app.Identifier + (*Meta)(nil), // 3: flyteidl2.app.Meta + (*AppWrapper)(nil), // 4: flyteidl2.app.AppWrapper + (*App)(nil), // 5: flyteidl2.app.App + (*Condition)(nil), // 6: flyteidl2.app.Condition + (*Status)(nil), // 7: flyteidl2.app.Status + (*K8SMetadata)(nil), // 8: flyteidl2.app.K8sMetadata + (*Ingress)(nil), // 9: flyteidl2.app.Ingress + (*Spec)(nil), // 10: flyteidl2.app.Spec + (*Link)(nil), // 11: flyteidl2.app.Link + (*Input)(nil), // 12: flyteidl2.app.Input + (*MaterializedInputs)(nil), // 13: flyteidl2.app.MaterializedInputs + (*MaterializedInput)(nil), // 14: flyteidl2.app.MaterializedInput + (*InputList)(nil), // 15: flyteidl2.app.InputList + (*Profile)(nil), // 16: flyteidl2.app.Profile + (*SecurityContext)(nil), // 17: flyteidl2.app.SecurityContext + (*ImageSpec)(nil), // 18: flyteidl2.app.ImageSpec + (*ImageSpecSet)(nil), // 19: flyteidl2.app.ImageSpecSet + (*IngressConfig)(nil), // 20: flyteidl2.app.IngressConfig + (*AutoscalingConfig)(nil), // 21: flyteidl2.app.AutoscalingConfig + (*ScalingMetric)(nil), // 22: flyteidl2.app.ScalingMetric + (*Concurrency)(nil), // 23: flyteidl2.app.Concurrency + (*RequestRate)(nil), // 24: flyteidl2.app.RequestRate + (*Replicas)(nil), // 25: flyteidl2.app.Replicas + (*TimeoutConfig)(nil), // 26: flyteidl2.app.TimeoutConfig + nil, // 27: flyteidl2.app.Meta.LabelsEntry + (*timestamppb.Timestamp)(nil), // 28: google.protobuf.Timestamp + (*common.EnrichedIdentity)(nil), // 29: flyteidl2.common.EnrichedIdentity + (*core.Container)(nil), // 30: flyteidl2.core.Container + (*core.K8SPod)(nil), // 31: flyteidl2.core.K8sPod + (*core.ExtendedResources)(nil), // 32: flyteidl2.core.ExtendedResources + (*common.RuntimeMetadata)(nil), // 33: flyteidl2.common.RuntimeMetadata + (*core.ArtifactQuery)(nil), // 34: flyteidl2.core.ArtifactQuery + (*core.ArtifactID)(nil), // 35: flyteidl2.core.ArtifactID + (*core.Identity)(nil), // 36: flyteidl2.core.Identity + (*core.Secret)(nil), // 37: flyteidl2.core.Secret + (*durationpb.Duration)(nil), // 38: google.protobuf.Duration +} +var file_flyteidl2_app_app_definition_proto_depIdxs = []int32{ + 2, // 0: flyteidl2.app.Meta.id:type_name -> flyteidl2.app.Identifier + 27, // 1: flyteidl2.app.Meta.labels:type_name -> flyteidl2.app.Meta.LabelsEntry + 5, // 2: flyteidl2.app.AppWrapper.app:type_name -> flyteidl2.app.App + 2, // 3: flyteidl2.app.AppWrapper.app_id:type_name -> flyteidl2.app.Identifier + 3, // 4: flyteidl2.app.App.metadata:type_name -> flyteidl2.app.Meta + 10, // 5: flyteidl2.app.App.spec:type_name -> flyteidl2.app.Spec + 7, // 6: flyteidl2.app.App.status:type_name -> flyteidl2.app.Status + 28, // 7: flyteidl2.app.Condition.last_transition_time:type_name -> google.protobuf.Timestamp + 0, // 8: flyteidl2.app.Condition.deployment_status:type_name -> flyteidl2.app.Status.DeploymentStatus + 29, // 9: flyteidl2.app.Condition.actor:type_name -> flyteidl2.common.EnrichedIdentity + 9, // 10: flyteidl2.app.Status.ingress:type_name -> flyteidl2.app.Ingress + 28, // 11: flyteidl2.app.Status.created_at:type_name -> google.protobuf.Timestamp + 28, // 12: flyteidl2.app.Status.last_updated_at:type_name -> google.protobuf.Timestamp + 6, // 13: flyteidl2.app.Status.conditions:type_name -> flyteidl2.app.Condition + 28, // 14: flyteidl2.app.Status.lease_expiration:type_name -> google.protobuf.Timestamp + 8, // 15: flyteidl2.app.Status.k8s_metadata:type_name -> flyteidl2.app.K8sMetadata + 13, // 16: flyteidl2.app.Status.materialized_inputs:type_name -> flyteidl2.app.MaterializedInputs + 30, // 17: flyteidl2.app.Spec.container:type_name -> flyteidl2.core.Container + 31, // 18: flyteidl2.app.Spec.pod:type_name -> flyteidl2.core.K8sPod + 21, // 19: flyteidl2.app.Spec.autoscaling:type_name -> flyteidl2.app.AutoscalingConfig + 20, // 20: flyteidl2.app.Spec.ingress:type_name -> flyteidl2.app.IngressConfig + 1, // 21: flyteidl2.app.Spec.desired_state:type_name -> flyteidl2.app.Spec.DesiredState + 19, // 22: flyteidl2.app.Spec.images:type_name -> flyteidl2.app.ImageSpecSet + 17, // 23: flyteidl2.app.Spec.security_context:type_name -> flyteidl2.app.SecurityContext + 32, // 24: flyteidl2.app.Spec.extended_resources:type_name -> flyteidl2.core.ExtendedResources + 33, // 25: flyteidl2.app.Spec.runtime_metadata:type_name -> flyteidl2.common.RuntimeMetadata + 16, // 26: flyteidl2.app.Spec.profile:type_name -> flyteidl2.app.Profile + 29, // 27: flyteidl2.app.Spec.creator:type_name -> flyteidl2.common.EnrichedIdentity + 15, // 28: flyteidl2.app.Spec.inputs:type_name -> flyteidl2.app.InputList + 11, // 29: flyteidl2.app.Spec.links:type_name -> flyteidl2.app.Link + 26, // 30: flyteidl2.app.Spec.timeouts:type_name -> flyteidl2.app.TimeoutConfig + 34, // 31: flyteidl2.app.Input.artifact_query:type_name -> flyteidl2.core.ArtifactQuery + 35, // 32: flyteidl2.app.Input.artifact_id:type_name -> flyteidl2.core.ArtifactID + 2, // 33: flyteidl2.app.Input.app_id:type_name -> flyteidl2.app.Identifier + 14, // 34: flyteidl2.app.MaterializedInputs.items:type_name -> flyteidl2.app.MaterializedInput + 35, // 35: flyteidl2.app.MaterializedInput.artifact_id:type_name -> flyteidl2.core.ArtifactID + 12, // 36: flyteidl2.app.InputList.items:type_name -> flyteidl2.app.Input + 36, // 37: flyteidl2.app.SecurityContext.run_as:type_name -> flyteidl2.core.Identity + 37, // 38: flyteidl2.app.SecurityContext.secrets:type_name -> flyteidl2.core.Secret + 18, // 39: flyteidl2.app.ImageSpecSet.images:type_name -> flyteidl2.app.ImageSpec + 25, // 40: flyteidl2.app.AutoscalingConfig.replicas:type_name -> flyteidl2.app.Replicas + 38, // 41: flyteidl2.app.AutoscalingConfig.scaledown_period:type_name -> google.protobuf.Duration + 22, // 42: flyteidl2.app.AutoscalingConfig.scaling_metric:type_name -> flyteidl2.app.ScalingMetric + 24, // 43: flyteidl2.app.ScalingMetric.request_rate:type_name -> flyteidl2.app.RequestRate + 23, // 44: flyteidl2.app.ScalingMetric.concurrency:type_name -> flyteidl2.app.Concurrency + 38, // 45: flyteidl2.app.TimeoutConfig.request_timeout:type_name -> google.protobuf.Duration + 46, // [46:46] is the sub-list for method output_type + 46, // [46:46] is the sub-list for method input_type + 46, // [46:46] is the sub-list for extension type_name + 46, // [46:46] is the sub-list for extension extendee + 0, // [0:46] is the sub-list for field type_name +} + +func init() { file_flyteidl2_app_app_definition_proto_init() } +func file_flyteidl2_app_app_definition_proto_init() { + if File_flyteidl2_app_app_definition_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_app_app_definition_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Identifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Meta); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AppWrapper); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*App); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Condition); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Status); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*K8SMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Ingress); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Spec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Link); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Input); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MaterializedInputs); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MaterializedInput); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*InputList); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Profile); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SecurityContext); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ImageSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ImageSpecSet); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*IngressConfig); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AutoscalingConfig); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ScalingMetric); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Concurrency); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RequestRate); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Replicas); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TimeoutConfig); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_app_app_definition_proto_msgTypes[2].OneofWrappers = []interface{}{ + (*AppWrapper_App)(nil), + (*AppWrapper_AppId)(nil), + } + file_flyteidl2_app_app_definition_proto_msgTypes[8].OneofWrappers = []interface{}{ + (*Spec_Container)(nil), + (*Spec_Pod)(nil), + } + file_flyteidl2_app_app_definition_proto_msgTypes[10].OneofWrappers = []interface{}{ + (*Input_StringValue)(nil), + (*Input_ArtifactQuery)(nil), + (*Input_ArtifactId)(nil), + (*Input_AppId)(nil), + } + file_flyteidl2_app_app_definition_proto_msgTypes[12].OneofWrappers = []interface{}{ + (*MaterializedInput_ArtifactId)(nil), + } + file_flyteidl2_app_app_definition_proto_msgTypes[20].OneofWrappers = []interface{}{ + (*ScalingMetric_RequestRate)(nil), + (*ScalingMetric_Concurrency)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_app_app_definition_proto_rawDesc, + NumEnums: 2, + NumMessages: 26, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_app_app_definition_proto_goTypes, + DependencyIndexes: file_flyteidl2_app_app_definition_proto_depIdxs, + EnumInfos: file_flyteidl2_app_app_definition_proto_enumTypes, + MessageInfos: file_flyteidl2_app_app_definition_proto_msgTypes, + }.Build() + File_flyteidl2_app_app_definition_proto = out.File + file_flyteidl2_app_app_definition_proto_rawDesc = nil + file_flyteidl2_app_app_definition_proto_goTypes = nil + file_flyteidl2_app_app_definition_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/app/app_definition.pb.validate.go b/gen/go/flyteidl2/app/app_definition.pb.validate.go new file mode 100644 index 0000000000..8bc676d936 --- /dev/null +++ b/gen/go/flyteidl2/app/app_definition.pb.validate.go @@ -0,0 +1,4026 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/app/app_definition.proto + +package app + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on Identifier with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Identifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Identifier with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in IdentifierMultiError, or +// nil if none found. +func (m *Identifier) ValidateAll() error { + return m.validate(true) +} + +func (m *Identifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Org + + // no validation rules for Project + + // no validation rules for Domain + + // no validation rules for Name + + if len(errors) > 0 { + return IdentifierMultiError(errors) + } + + return nil +} + +// IdentifierMultiError is an error wrapping multiple validation errors +// returned by Identifier.ValidateAll() if the designated constraints aren't met. +type IdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m IdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m IdentifierMultiError) AllErrors() []error { return m } + +// IdentifierValidationError is the validation error returned by +// Identifier.Validate if the designated constraints aren't met. +type IdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e IdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e IdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e IdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e IdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e IdentifierValidationError) ErrorName() string { return "IdentifierValidationError" } + +// Error satisfies the builtin error interface +func (e IdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = IdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = IdentifierValidationError{} + +// Validate checks the field values on Meta with the rules defined in the proto +// definition for this message. If any rules are violated, the first error +// encountered is returned, or nil if there are no violations. +func (m *Meta) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Meta with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in MetaMultiError, or nil if none found. +func (m *Meta) ValidateAll() error { + return m.validate(true) +} + +func (m *Meta) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, MetaValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, MetaValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return MetaValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Revision + + // no validation rules for Labels + + if len(errors) > 0 { + return MetaMultiError(errors) + } + + return nil +} + +// MetaMultiError is an error wrapping multiple validation errors returned by +// Meta.ValidateAll() if the designated constraints aren't met. +type MetaMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m MetaMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m MetaMultiError) AllErrors() []error { return m } + +// MetaValidationError is the validation error returned by Meta.Validate if the +// designated constraints aren't met. +type MetaValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e MetaValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e MetaValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e MetaValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e MetaValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e MetaValidationError) ErrorName() string { return "MetaValidationError" } + +// Error satisfies the builtin error interface +func (e MetaValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sMeta.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = MetaValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = MetaValidationError{} + +// Validate checks the field values on AppWrapper with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *AppWrapper) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on AppWrapper with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in AppWrapperMultiError, or +// nil if none found. +func (m *AppWrapper) ValidateAll() error { + return m.validate(true) +} + +func (m *AppWrapper) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Host + + switch v := m.Payload.(type) { + case *AppWrapper_App: + if v == nil { + err := AppWrapperValidationError{ + field: "Payload", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetApp()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, AppWrapperValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, AppWrapperValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetApp()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return AppWrapperValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *AppWrapper_AppId: + if v == nil { + err := AppWrapperValidationError{ + field: "Payload", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetAppId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, AppWrapperValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, AppWrapperValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAppId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return AppWrapperValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return AppWrapperMultiError(errors) + } + + return nil +} + +// AppWrapperMultiError is an error wrapping multiple validation errors +// returned by AppWrapper.ValidateAll() if the designated constraints aren't met. +type AppWrapperMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m AppWrapperMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m AppWrapperMultiError) AllErrors() []error { return m } + +// AppWrapperValidationError is the validation error returned by +// AppWrapper.Validate if the designated constraints aren't met. +type AppWrapperValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e AppWrapperValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e AppWrapperValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e AppWrapperValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e AppWrapperValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e AppWrapperValidationError) ErrorName() string { return "AppWrapperValidationError" } + +// Error satisfies the builtin error interface +func (e AppWrapperValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sAppWrapper.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = AppWrapperValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = AppWrapperValidationError{} + +// Validate checks the field values on App with the rules defined in the proto +// definition for this message. If any rules are violated, the first error +// encountered is returned, or nil if there are no violations. +func (m *App) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on App with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in AppMultiError, or nil if none found. +func (m *App) ValidateAll() error { + return m.validate(true) +} + +func (m *App) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, AppValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, AppValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return AppValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, AppValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, AppValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return AppValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetStatus()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, AppValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, AppValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStatus()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return AppValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return AppMultiError(errors) + } + + return nil +} + +// AppMultiError is an error wrapping multiple validation errors returned by +// App.ValidateAll() if the designated constraints aren't met. +type AppMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m AppMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m AppMultiError) AllErrors() []error { return m } + +// AppValidationError is the validation error returned by App.Validate if the +// designated constraints aren't met. +type AppValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e AppValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e AppValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e AppValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e AppValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e AppValidationError) ErrorName() string { return "AppValidationError" } + +// Error satisfies the builtin error interface +func (e AppValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sApp.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = AppValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = AppValidationError{} + +// Validate checks the field values on Condition with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Condition) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Condition with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ConditionMultiError, or nil +// if none found. +func (m *Condition) ValidateAll() error { + return m.validate(true) +} + +func (m *Condition) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetLastTransitionTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ConditionValidationError{ + field: "LastTransitionTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ConditionValidationError{ + field: "LastTransitionTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLastTransitionTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ConditionValidationError{ + field: "LastTransitionTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for DeploymentStatus + + // no validation rules for Message + + // no validation rules for Revision + + if all { + switch v := interface{}(m.GetActor()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ConditionValidationError{ + field: "Actor", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ConditionValidationError{ + field: "Actor", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetActor()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ConditionValidationError{ + field: "Actor", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ConditionMultiError(errors) + } + + return nil +} + +// ConditionMultiError is an error wrapping multiple validation errors returned +// by Condition.ValidateAll() if the designated constraints aren't met. +type ConditionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ConditionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ConditionMultiError) AllErrors() []error { return m } + +// ConditionValidationError is the validation error returned by +// Condition.Validate if the designated constraints aren't met. +type ConditionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ConditionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ConditionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ConditionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ConditionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ConditionValidationError) ErrorName() string { return "ConditionValidationError" } + +// Error satisfies the builtin error interface +func (e ConditionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCondition.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ConditionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ConditionValidationError{} + +// Validate checks the field values on Status with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Status) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Status with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in StatusMultiError, or nil if none found. +func (m *Status) ValidateAll() error { + return m.validate(true) +} + +func (m *Status) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for AssignedCluster + + // no validation rules for CurrentReplicas + + if all { + switch v := interface{}(m.GetIngress()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, StatusValidationError{ + field: "Ingress", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, StatusValidationError{ + field: "Ingress", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetIngress()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return StatusValidationError{ + field: "Ingress", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetCreatedAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, StatusValidationError{ + field: "CreatedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, StatusValidationError{ + field: "CreatedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCreatedAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return StatusValidationError{ + field: "CreatedAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetLastUpdatedAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, StatusValidationError{ + field: "LastUpdatedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, StatusValidationError{ + field: "LastUpdatedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLastUpdatedAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return StatusValidationError{ + field: "LastUpdatedAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetConditions() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, StatusValidationError{ + field: fmt.Sprintf("Conditions[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, StatusValidationError{ + field: fmt.Sprintf("Conditions[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return StatusValidationError{ + field: fmt.Sprintf("Conditions[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if all { + switch v := interface{}(m.GetLeaseExpiration()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, StatusValidationError{ + field: "LeaseExpiration", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, StatusValidationError{ + field: "LeaseExpiration", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLeaseExpiration()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return StatusValidationError{ + field: "LeaseExpiration", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetK8SMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, StatusValidationError{ + field: "K8SMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, StatusValidationError{ + field: "K8SMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetK8SMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return StatusValidationError{ + field: "K8SMetadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetMaterializedInputs()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, StatusValidationError{ + field: "MaterializedInputs", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, StatusValidationError{ + field: "MaterializedInputs", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMaterializedInputs()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return StatusValidationError{ + field: "MaterializedInputs", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return StatusMultiError(errors) + } + + return nil +} + +// StatusMultiError is an error wrapping multiple validation errors returned by +// Status.ValidateAll() if the designated constraints aren't met. +type StatusMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m StatusMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m StatusMultiError) AllErrors() []error { return m } + +// StatusValidationError is the validation error returned by Status.Validate if +// the designated constraints aren't met. +type StatusValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e StatusValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e StatusValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e StatusValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e StatusValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e StatusValidationError) ErrorName() string { return "StatusValidationError" } + +// Error satisfies the builtin error interface +func (e StatusValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sStatus.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = StatusValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = StatusValidationError{} + +// Validate checks the field values on K8SMetadata with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *K8SMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on K8SMetadata with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in K8SMetadataMultiError, or +// nil if none found. +func (m *K8SMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *K8SMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Namespace + + if len(errors) > 0 { + return K8SMetadataMultiError(errors) + } + + return nil +} + +// K8SMetadataMultiError is an error wrapping multiple validation errors +// returned by K8SMetadata.ValidateAll() if the designated constraints aren't met. +type K8SMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m K8SMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m K8SMetadataMultiError) AllErrors() []error { return m } + +// K8SMetadataValidationError is the validation error returned by +// K8SMetadata.Validate if the designated constraints aren't met. +type K8SMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e K8SMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e K8SMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e K8SMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e K8SMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e K8SMetadataValidationError) ErrorName() string { return "K8SMetadataValidationError" } + +// Error satisfies the builtin error interface +func (e K8SMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sK8SMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = K8SMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = K8SMetadataValidationError{} + +// Validate checks the field values on Ingress with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Ingress) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Ingress with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in IngressMultiError, or nil if none found. +func (m *Ingress) ValidateAll() error { + return m.validate(true) +} + +func (m *Ingress) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for PublicUrl + + // no validation rules for CnameUrl + + // no validation rules for VpcUrl + + if len(errors) > 0 { + return IngressMultiError(errors) + } + + return nil +} + +// IngressMultiError is an error wrapping multiple validation errors returned +// by Ingress.ValidateAll() if the designated constraints aren't met. +type IngressMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m IngressMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m IngressMultiError) AllErrors() []error { return m } + +// IngressValidationError is the validation error returned by Ingress.Validate +// if the designated constraints aren't met. +type IngressValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e IngressValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e IngressValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e IngressValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e IngressValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e IngressValidationError) ErrorName() string { return "IngressValidationError" } + +// Error satisfies the builtin error interface +func (e IngressValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sIngress.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = IngressValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = IngressValidationError{} + +// Validate checks the field values on Spec with the rules defined in the proto +// definition for this message. If any rules are violated, the first error +// encountered is returned, or nil if there are no violations. +func (m *Spec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Spec with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in SpecMultiError, or nil if none found. +func (m *Spec) ValidateAll() error { + return m.validate(true) +} + +func (m *Spec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetAutoscaling()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SpecValidationError{ + field: "Autoscaling", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SpecValidationError{ + field: "Autoscaling", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAutoscaling()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SpecValidationError{ + field: "Autoscaling", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetIngress()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SpecValidationError{ + field: "Ingress", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SpecValidationError{ + field: "Ingress", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetIngress()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SpecValidationError{ + field: "Ingress", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for DesiredState + + // no validation rules for ClusterPool + + if all { + switch v := interface{}(m.GetImages()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SpecValidationError{ + field: "Images", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SpecValidationError{ + field: "Images", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetImages()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SpecValidationError{ + field: "Images", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetSecurityContext()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SpecValidationError{ + field: "SecurityContext", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SpecValidationError{ + field: "SecurityContext", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSecurityContext()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SpecValidationError{ + field: "SecurityContext", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetExtendedResources()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SpecValidationError{ + field: "ExtendedResources", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SpecValidationError{ + field: "ExtendedResources", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetExtendedResources()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SpecValidationError{ + field: "ExtendedResources", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetRuntimeMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SpecValidationError{ + field: "RuntimeMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SpecValidationError{ + field: "RuntimeMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRuntimeMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SpecValidationError{ + field: "RuntimeMetadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetProfile()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SpecValidationError{ + field: "Profile", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SpecValidationError{ + field: "Profile", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetProfile()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SpecValidationError{ + field: "Profile", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetCreator()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SpecValidationError{ + field: "Creator", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SpecValidationError{ + field: "Creator", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCreator()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SpecValidationError{ + field: "Creator", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetInputs()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SpecValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SpecValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetInputs()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SpecValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetLinks() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SpecValidationError{ + field: fmt.Sprintf("Links[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SpecValidationError{ + field: fmt.Sprintf("Links[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SpecValidationError{ + field: fmt.Sprintf("Links[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if all { + switch v := interface{}(m.GetTimeouts()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SpecValidationError{ + field: "Timeouts", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SpecValidationError{ + field: "Timeouts", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTimeouts()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SpecValidationError{ + field: "Timeouts", + reason: "embedded message failed validation", + cause: err, + } + } + } + + switch v := m.AppPayload.(type) { + case *Spec_Container: + if v == nil { + err := SpecValidationError{ + field: "AppPayload", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetContainer()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SpecValidationError{ + field: "Container", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SpecValidationError{ + field: "Container", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetContainer()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SpecValidationError{ + field: "Container", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Spec_Pod: + if v == nil { + err := SpecValidationError{ + field: "AppPayload", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetPod()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SpecValidationError{ + field: "Pod", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SpecValidationError{ + field: "Pod", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetPod()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SpecValidationError{ + field: "Pod", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return SpecMultiError(errors) + } + + return nil +} + +// SpecMultiError is an error wrapping multiple validation errors returned by +// Spec.ValidateAll() if the designated constraints aren't met. +type SpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SpecMultiError) AllErrors() []error { return m } + +// SpecValidationError is the validation error returned by Spec.Validate if the +// designated constraints aren't met. +type SpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SpecValidationError) ErrorName() string { return "SpecValidationError" } + +// Error satisfies the builtin error interface +func (e SpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SpecValidationError{} + +// Validate checks the field values on Link with the rules defined in the proto +// definition for this message. If any rules are violated, the first error +// encountered is returned, or nil if there are no violations. +func (m *Link) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Link with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in LinkMultiError, or nil if none found. +func (m *Link) ValidateAll() error { + return m.validate(true) +} + +func (m *Link) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Path + + // no validation rules for Title + + // no validation rules for IsRelative + + if len(errors) > 0 { + return LinkMultiError(errors) + } + + return nil +} + +// LinkMultiError is an error wrapping multiple validation errors returned by +// Link.ValidateAll() if the designated constraints aren't met. +type LinkMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LinkMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LinkMultiError) AllErrors() []error { return m } + +// LinkValidationError is the validation error returned by Link.Validate if the +// designated constraints aren't met. +type LinkValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LinkValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LinkValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LinkValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LinkValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LinkValidationError) ErrorName() string { return "LinkValidationError" } + +// Error satisfies the builtin error interface +func (e LinkValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLink.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LinkValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LinkValidationError{} + +// Validate checks the field values on Input with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Input) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Input with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in InputMultiError, or nil if none found. +func (m *Input) ValidateAll() error { + return m.validate(true) +} + +func (m *Input) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + switch v := m.Value.(type) { + case *Input_StringValue: + if v == nil { + err := InputValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for StringValue + case *Input_ArtifactQuery: + if v == nil { + err := InputValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetArtifactQuery()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, InputValidationError{ + field: "ArtifactQuery", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, InputValidationError{ + field: "ArtifactQuery", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetArtifactQuery()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return InputValidationError{ + field: "ArtifactQuery", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Input_ArtifactId: + if v == nil { + err := InputValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetArtifactId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, InputValidationError{ + field: "ArtifactId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, InputValidationError{ + field: "ArtifactId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetArtifactId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return InputValidationError{ + field: "ArtifactId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Input_AppId: + if v == nil { + err := InputValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetAppId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, InputValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, InputValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAppId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return InputValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return InputMultiError(errors) + } + + return nil +} + +// InputMultiError is an error wrapping multiple validation errors returned by +// Input.ValidateAll() if the designated constraints aren't met. +type InputMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m InputMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m InputMultiError) AllErrors() []error { return m } + +// InputValidationError is the validation error returned by Input.Validate if +// the designated constraints aren't met. +type InputValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e InputValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e InputValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e InputValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e InputValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e InputValidationError) ErrorName() string { return "InputValidationError" } + +// Error satisfies the builtin error interface +func (e InputValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sInput.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = InputValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = InputValidationError{} + +// Validate checks the field values on MaterializedInputs with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *MaterializedInputs) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on MaterializedInputs with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// MaterializedInputsMultiError, or nil if none found. +func (m *MaterializedInputs) ValidateAll() error { + return m.validate(true) +} + +func (m *MaterializedInputs) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetItems() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, MaterializedInputsValidationError{ + field: fmt.Sprintf("Items[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, MaterializedInputsValidationError{ + field: fmt.Sprintf("Items[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return MaterializedInputsValidationError{ + field: fmt.Sprintf("Items[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Revision + + if len(errors) > 0 { + return MaterializedInputsMultiError(errors) + } + + return nil +} + +// MaterializedInputsMultiError is an error wrapping multiple validation errors +// returned by MaterializedInputs.ValidateAll() if the designated constraints +// aren't met. +type MaterializedInputsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m MaterializedInputsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m MaterializedInputsMultiError) AllErrors() []error { return m } + +// MaterializedInputsValidationError is the validation error returned by +// MaterializedInputs.Validate if the designated constraints aren't met. +type MaterializedInputsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e MaterializedInputsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e MaterializedInputsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e MaterializedInputsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e MaterializedInputsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e MaterializedInputsValidationError) ErrorName() string { + return "MaterializedInputsValidationError" +} + +// Error satisfies the builtin error interface +func (e MaterializedInputsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sMaterializedInputs.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = MaterializedInputsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = MaterializedInputsValidationError{} + +// Validate checks the field values on MaterializedInput with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *MaterializedInput) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on MaterializedInput with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// MaterializedInputMultiError, or nil if none found. +func (m *MaterializedInput) ValidateAll() error { + return m.validate(true) +} + +func (m *MaterializedInput) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + switch v := m.Value.(type) { + case *MaterializedInput_ArtifactId: + if v == nil { + err := MaterializedInputValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetArtifactId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, MaterializedInputValidationError{ + field: "ArtifactId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, MaterializedInputValidationError{ + field: "ArtifactId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetArtifactId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return MaterializedInputValidationError{ + field: "ArtifactId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return MaterializedInputMultiError(errors) + } + + return nil +} + +// MaterializedInputMultiError is an error wrapping multiple validation errors +// returned by MaterializedInput.ValidateAll() if the designated constraints +// aren't met. +type MaterializedInputMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m MaterializedInputMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m MaterializedInputMultiError) AllErrors() []error { return m } + +// MaterializedInputValidationError is the validation error returned by +// MaterializedInput.Validate if the designated constraints aren't met. +type MaterializedInputValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e MaterializedInputValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e MaterializedInputValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e MaterializedInputValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e MaterializedInputValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e MaterializedInputValidationError) ErrorName() string { + return "MaterializedInputValidationError" +} + +// Error satisfies the builtin error interface +func (e MaterializedInputValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sMaterializedInput.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = MaterializedInputValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = MaterializedInputValidationError{} + +// Validate checks the field values on InputList with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *InputList) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on InputList with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in InputListMultiError, or nil +// if none found. +func (m *InputList) ValidateAll() error { + return m.validate(true) +} + +func (m *InputList) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetItems() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, InputListValidationError{ + field: fmt.Sprintf("Items[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, InputListValidationError{ + field: fmt.Sprintf("Items[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return InputListValidationError{ + field: fmt.Sprintf("Items[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return InputListMultiError(errors) + } + + return nil +} + +// InputListMultiError is an error wrapping multiple validation errors returned +// by InputList.ValidateAll() if the designated constraints aren't met. +type InputListMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m InputListMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m InputListMultiError) AllErrors() []error { return m } + +// InputListValidationError is the validation error returned by +// InputList.Validate if the designated constraints aren't met. +type InputListValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e InputListValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e InputListValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e InputListValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e InputListValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e InputListValidationError) ErrorName() string { return "InputListValidationError" } + +// Error satisfies the builtin error interface +func (e InputListValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sInputList.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = InputListValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = InputListValidationError{} + +// Validate checks the field values on Profile with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Profile) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Profile with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in ProfileMultiError, or nil if none found. +func (m *Profile) ValidateAll() error { + return m.validate(true) +} + +func (m *Profile) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Type + + // no validation rules for Name + + // no validation rules for ShortDescription + + // no validation rules for IconUrl + + if len(errors) > 0 { + return ProfileMultiError(errors) + } + + return nil +} + +// ProfileMultiError is an error wrapping multiple validation errors returned +// by Profile.ValidateAll() if the designated constraints aren't met. +type ProfileMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ProfileMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ProfileMultiError) AllErrors() []error { return m } + +// ProfileValidationError is the validation error returned by Profile.Validate +// if the designated constraints aren't met. +type ProfileValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ProfileValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ProfileValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ProfileValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ProfileValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ProfileValidationError) ErrorName() string { return "ProfileValidationError" } + +// Error satisfies the builtin error interface +func (e ProfileValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sProfile.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ProfileValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ProfileValidationError{} + +// Validate checks the field values on SecurityContext with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *SecurityContext) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on SecurityContext with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// SecurityContextMultiError, or nil if none found. +func (m *SecurityContext) ValidateAll() error { + return m.validate(true) +} + +func (m *SecurityContext) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRunAs()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SecurityContextValidationError{ + field: "RunAs", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SecurityContextValidationError{ + field: "RunAs", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunAs()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SecurityContextValidationError{ + field: "RunAs", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetSecrets() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SecurityContextValidationError{ + field: fmt.Sprintf("Secrets[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SecurityContextValidationError{ + field: fmt.Sprintf("Secrets[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SecurityContextValidationError{ + field: fmt.Sprintf("Secrets[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for AllowAnonymous + + if len(errors) > 0 { + return SecurityContextMultiError(errors) + } + + return nil +} + +// SecurityContextMultiError is an error wrapping multiple validation errors +// returned by SecurityContext.ValidateAll() if the designated constraints +// aren't met. +type SecurityContextMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SecurityContextMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SecurityContextMultiError) AllErrors() []error { return m } + +// SecurityContextValidationError is the validation error returned by +// SecurityContext.Validate if the designated constraints aren't met. +type SecurityContextValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SecurityContextValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SecurityContextValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SecurityContextValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SecurityContextValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SecurityContextValidationError) ErrorName() string { return "SecurityContextValidationError" } + +// Error satisfies the builtin error interface +func (e SecurityContextValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSecurityContext.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SecurityContextValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SecurityContextValidationError{} + +// Validate checks the field values on ImageSpec with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ImageSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ImageSpec with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ImageSpecMultiError, or nil +// if none found. +func (m *ImageSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *ImageSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Tag + + // no validation rules for BuildJobUrl + + if len(errors) > 0 { + return ImageSpecMultiError(errors) + } + + return nil +} + +// ImageSpecMultiError is an error wrapping multiple validation errors returned +// by ImageSpec.ValidateAll() if the designated constraints aren't met. +type ImageSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ImageSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ImageSpecMultiError) AllErrors() []error { return m } + +// ImageSpecValidationError is the validation error returned by +// ImageSpec.Validate if the designated constraints aren't met. +type ImageSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ImageSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ImageSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ImageSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ImageSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ImageSpecValidationError) ErrorName() string { return "ImageSpecValidationError" } + +// Error satisfies the builtin error interface +func (e ImageSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sImageSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ImageSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ImageSpecValidationError{} + +// Validate checks the field values on ImageSpecSet with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ImageSpecSet) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ImageSpecSet with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ImageSpecSetMultiError, or +// nil if none found. +func (m *ImageSpecSet) ValidateAll() error { + return m.validate(true) +} + +func (m *ImageSpecSet) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetImages() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ImageSpecSetValidationError{ + field: fmt.Sprintf("Images[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ImageSpecSetValidationError{ + field: fmt.Sprintf("Images[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ImageSpecSetValidationError{ + field: fmt.Sprintf("Images[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return ImageSpecSetMultiError(errors) + } + + return nil +} + +// ImageSpecSetMultiError is an error wrapping multiple validation errors +// returned by ImageSpecSet.ValidateAll() if the designated constraints aren't met. +type ImageSpecSetMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ImageSpecSetMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ImageSpecSetMultiError) AllErrors() []error { return m } + +// ImageSpecSetValidationError is the validation error returned by +// ImageSpecSet.Validate if the designated constraints aren't met. +type ImageSpecSetValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ImageSpecSetValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ImageSpecSetValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ImageSpecSetValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ImageSpecSetValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ImageSpecSetValidationError) ErrorName() string { return "ImageSpecSetValidationError" } + +// Error satisfies the builtin error interface +func (e ImageSpecSetValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sImageSpecSet.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ImageSpecSetValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ImageSpecSetValidationError{} + +// Validate checks the field values on IngressConfig with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *IngressConfig) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on IngressConfig with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in IngressConfigMultiError, or +// nil if none found. +func (m *IngressConfig) ValidateAll() error { + return m.validate(true) +} + +func (m *IngressConfig) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Private + + // no validation rules for Subdomain + + // no validation rules for Cname + + if len(errors) > 0 { + return IngressConfigMultiError(errors) + } + + return nil +} + +// IngressConfigMultiError is an error wrapping multiple validation errors +// returned by IngressConfig.ValidateAll() if the designated constraints +// aren't met. +type IngressConfigMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m IngressConfigMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m IngressConfigMultiError) AllErrors() []error { return m } + +// IngressConfigValidationError is the validation error returned by +// IngressConfig.Validate if the designated constraints aren't met. +type IngressConfigValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e IngressConfigValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e IngressConfigValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e IngressConfigValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e IngressConfigValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e IngressConfigValidationError) ErrorName() string { return "IngressConfigValidationError" } + +// Error satisfies the builtin error interface +func (e IngressConfigValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sIngressConfig.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = IngressConfigValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = IngressConfigValidationError{} + +// Validate checks the field values on AutoscalingConfig with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *AutoscalingConfig) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on AutoscalingConfig with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// AutoscalingConfigMultiError, or nil if none found. +func (m *AutoscalingConfig) ValidateAll() error { + return m.validate(true) +} + +func (m *AutoscalingConfig) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetReplicas()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, AutoscalingConfigValidationError{ + field: "Replicas", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, AutoscalingConfigValidationError{ + field: "Replicas", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetReplicas()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return AutoscalingConfigValidationError{ + field: "Replicas", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetScaledownPeriod()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, AutoscalingConfigValidationError{ + field: "ScaledownPeriod", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, AutoscalingConfigValidationError{ + field: "ScaledownPeriod", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetScaledownPeriod()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return AutoscalingConfigValidationError{ + field: "ScaledownPeriod", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetScalingMetric()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, AutoscalingConfigValidationError{ + field: "ScalingMetric", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, AutoscalingConfigValidationError{ + field: "ScalingMetric", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetScalingMetric()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return AutoscalingConfigValidationError{ + field: "ScalingMetric", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return AutoscalingConfigMultiError(errors) + } + + return nil +} + +// AutoscalingConfigMultiError is an error wrapping multiple validation errors +// returned by AutoscalingConfig.ValidateAll() if the designated constraints +// aren't met. +type AutoscalingConfigMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m AutoscalingConfigMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m AutoscalingConfigMultiError) AllErrors() []error { return m } + +// AutoscalingConfigValidationError is the validation error returned by +// AutoscalingConfig.Validate if the designated constraints aren't met. +type AutoscalingConfigValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e AutoscalingConfigValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e AutoscalingConfigValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e AutoscalingConfigValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e AutoscalingConfigValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e AutoscalingConfigValidationError) ErrorName() string { + return "AutoscalingConfigValidationError" +} + +// Error satisfies the builtin error interface +func (e AutoscalingConfigValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sAutoscalingConfig.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = AutoscalingConfigValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = AutoscalingConfigValidationError{} + +// Validate checks the field values on ScalingMetric with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ScalingMetric) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ScalingMetric with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ScalingMetricMultiError, or +// nil if none found. +func (m *ScalingMetric) ValidateAll() error { + return m.validate(true) +} + +func (m *ScalingMetric) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Metric.(type) { + case *ScalingMetric_RequestRate: + if v == nil { + err := ScalingMetricValidationError{ + field: "Metric", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetRequestRate()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ScalingMetricValidationError{ + field: "RequestRate", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ScalingMetricValidationError{ + field: "RequestRate", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRequestRate()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ScalingMetricValidationError{ + field: "RequestRate", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *ScalingMetric_Concurrency: + if v == nil { + err := ScalingMetricValidationError{ + field: "Metric", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetConcurrency()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ScalingMetricValidationError{ + field: "Concurrency", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ScalingMetricValidationError{ + field: "Concurrency", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetConcurrency()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ScalingMetricValidationError{ + field: "Concurrency", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return ScalingMetricMultiError(errors) + } + + return nil +} + +// ScalingMetricMultiError is an error wrapping multiple validation errors +// returned by ScalingMetric.ValidateAll() if the designated constraints +// aren't met. +type ScalingMetricMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ScalingMetricMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ScalingMetricMultiError) AllErrors() []error { return m } + +// ScalingMetricValidationError is the validation error returned by +// ScalingMetric.Validate if the designated constraints aren't met. +type ScalingMetricValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ScalingMetricValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ScalingMetricValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ScalingMetricValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ScalingMetricValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ScalingMetricValidationError) ErrorName() string { return "ScalingMetricValidationError" } + +// Error satisfies the builtin error interface +func (e ScalingMetricValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sScalingMetric.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ScalingMetricValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ScalingMetricValidationError{} + +// Validate checks the field values on Concurrency with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Concurrency) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Concurrency with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ConcurrencyMultiError, or +// nil if none found. +func (m *Concurrency) ValidateAll() error { + return m.validate(true) +} + +func (m *Concurrency) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for TargetValue + + if len(errors) > 0 { + return ConcurrencyMultiError(errors) + } + + return nil +} + +// ConcurrencyMultiError is an error wrapping multiple validation errors +// returned by Concurrency.ValidateAll() if the designated constraints aren't met. +type ConcurrencyMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ConcurrencyMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ConcurrencyMultiError) AllErrors() []error { return m } + +// ConcurrencyValidationError is the validation error returned by +// Concurrency.Validate if the designated constraints aren't met. +type ConcurrencyValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ConcurrencyValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ConcurrencyValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ConcurrencyValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ConcurrencyValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ConcurrencyValidationError) ErrorName() string { return "ConcurrencyValidationError" } + +// Error satisfies the builtin error interface +func (e ConcurrencyValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sConcurrency.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ConcurrencyValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ConcurrencyValidationError{} + +// Validate checks the field values on RequestRate with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *RequestRate) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on RequestRate with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in RequestRateMultiError, or +// nil if none found. +func (m *RequestRate) ValidateAll() error { + return m.validate(true) +} + +func (m *RequestRate) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for TargetValue + + if len(errors) > 0 { + return RequestRateMultiError(errors) + } + + return nil +} + +// RequestRateMultiError is an error wrapping multiple validation errors +// returned by RequestRate.ValidateAll() if the designated constraints aren't met. +type RequestRateMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m RequestRateMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m RequestRateMultiError) AllErrors() []error { return m } + +// RequestRateValidationError is the validation error returned by +// RequestRate.Validate if the designated constraints aren't met. +type RequestRateValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e RequestRateValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e RequestRateValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e RequestRateValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e RequestRateValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e RequestRateValidationError) ErrorName() string { return "RequestRateValidationError" } + +// Error satisfies the builtin error interface +func (e RequestRateValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sRequestRate.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = RequestRateValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = RequestRateValidationError{} + +// Validate checks the field values on Replicas with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Replicas) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Replicas with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ReplicasMultiError, or nil +// if none found. +func (m *Replicas) ValidateAll() error { + return m.validate(true) +} + +func (m *Replicas) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Min + + // no validation rules for Max + + if len(errors) > 0 { + return ReplicasMultiError(errors) + } + + return nil +} + +// ReplicasMultiError is an error wrapping multiple validation errors returned +// by Replicas.ValidateAll() if the designated constraints aren't met. +type ReplicasMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ReplicasMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ReplicasMultiError) AllErrors() []error { return m } + +// ReplicasValidationError is the validation error returned by +// Replicas.Validate if the designated constraints aren't met. +type ReplicasValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ReplicasValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ReplicasValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ReplicasValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ReplicasValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ReplicasValidationError) ErrorName() string { return "ReplicasValidationError" } + +// Error satisfies the builtin error interface +func (e ReplicasValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sReplicas.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ReplicasValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ReplicasValidationError{} + +// Validate checks the field values on TimeoutConfig with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TimeoutConfig) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TimeoutConfig with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TimeoutConfigMultiError, or +// nil if none found. +func (m *TimeoutConfig) ValidateAll() error { + return m.validate(true) +} + +func (m *TimeoutConfig) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRequestTimeout()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TimeoutConfigValidationError{ + field: "RequestTimeout", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TimeoutConfigValidationError{ + field: "RequestTimeout", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRequestTimeout()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TimeoutConfigValidationError{ + field: "RequestTimeout", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return TimeoutConfigMultiError(errors) + } + + return nil +} + +// TimeoutConfigMultiError is an error wrapping multiple validation errors +// returned by TimeoutConfig.ValidateAll() if the designated constraints +// aren't met. +type TimeoutConfigMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TimeoutConfigMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TimeoutConfigMultiError) AllErrors() []error { return m } + +// TimeoutConfigValidationError is the validation error returned by +// TimeoutConfig.Validate if the designated constraints aren't met. +type TimeoutConfigValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TimeoutConfigValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TimeoutConfigValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TimeoutConfigValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TimeoutConfigValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TimeoutConfigValidationError) ErrorName() string { return "TimeoutConfigValidationError" } + +// Error satisfies the builtin error interface +func (e TimeoutConfigValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTimeoutConfig.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TimeoutConfigValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TimeoutConfigValidationError{} diff --git a/gen/go/flyteidl2/app/app_logs_payload.pb.go b/gen/go/flyteidl2/app/app_logs_payload.pb.go new file mode 100644 index 0000000000..09f7c0de7e --- /dev/null +++ b/gen/go/flyteidl2/app/app_logs_payload.pb.go @@ -0,0 +1,583 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/app/app_logs_payload.proto + +package app + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + dataplane "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/logs/dataplane" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type TailLogsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Target: + // + // *TailLogsRequest_AppId + // *TailLogsRequest_ReplicaId + Target isTailLogsRequest_Target `protobuf_oneof:"target"` +} + +func (x *TailLogsRequest) Reset() { + *x = TailLogsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_logs_payload_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TailLogsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TailLogsRequest) ProtoMessage() {} + +func (x *TailLogsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_logs_payload_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TailLogsRequest.ProtoReflect.Descriptor instead. +func (*TailLogsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_logs_payload_proto_rawDescGZIP(), []int{0} +} + +func (m *TailLogsRequest) GetTarget() isTailLogsRequest_Target { + if m != nil { + return m.Target + } + return nil +} + +func (x *TailLogsRequest) GetAppId() *Identifier { + if x, ok := x.GetTarget().(*TailLogsRequest_AppId); ok { + return x.AppId + } + return nil +} + +func (x *TailLogsRequest) GetReplicaId() *ReplicaIdentifier { + if x, ok := x.GetTarget().(*TailLogsRequest_ReplicaId); ok { + return x.ReplicaId + } + return nil +} + +type isTailLogsRequest_Target interface { + isTailLogsRequest_Target() +} + +type TailLogsRequest_AppId struct { + // Identifier of the application to get logs for. + AppId *Identifier `protobuf:"bytes,1,opt,name=app_id,json=appId,proto3,oneof"` +} + +type TailLogsRequest_ReplicaId struct { + // Identifier of the replica to get logs for. + ReplicaId *ReplicaIdentifier `protobuf:"bytes,2,opt,name=replica_id,json=replicaId,proto3,oneof"` +} + +func (*TailLogsRequest_AppId) isTailLogsRequest_Target() {} + +func (*TailLogsRequest_ReplicaId) isTailLogsRequest_Target() {} + +type ReplicaIdentifierList struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Replicas []*ReplicaIdentifier `protobuf:"bytes,1,rep,name=replicas,proto3" json:"replicas,omitempty"` +} + +func (x *ReplicaIdentifierList) Reset() { + *x = ReplicaIdentifierList{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_logs_payload_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ReplicaIdentifierList) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReplicaIdentifierList) ProtoMessage() {} + +func (x *ReplicaIdentifierList) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_logs_payload_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReplicaIdentifierList.ProtoReflect.Descriptor instead. +func (*ReplicaIdentifierList) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_logs_payload_proto_rawDescGZIP(), []int{1} +} + +func (x *ReplicaIdentifierList) GetReplicas() []*ReplicaIdentifier { + if x != nil { + return x.Replicas + } + return nil +} + +type LogLines struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Deprecated: Marked as deprecated in flyteidl2/app/app_logs_payload.proto. + Lines []string `protobuf:"bytes,1,rep,name=lines,proto3" json:"lines,omitempty"` + ReplicaId *ReplicaIdentifier `protobuf:"bytes,2,opt,name=replica_id,json=replicaId,proto3" json:"replica_id,omitempty"` + StructuredLines []*dataplane.LogLine `protobuf:"bytes,3,rep,name=structured_lines,json=structuredLines,proto3" json:"structured_lines,omitempty"` +} + +func (x *LogLines) Reset() { + *x = LogLines{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_logs_payload_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LogLines) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LogLines) ProtoMessage() {} + +func (x *LogLines) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_logs_payload_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LogLines.ProtoReflect.Descriptor instead. +func (*LogLines) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_logs_payload_proto_rawDescGZIP(), []int{2} +} + +// Deprecated: Marked as deprecated in flyteidl2/app/app_logs_payload.proto. +func (x *LogLines) GetLines() []string { + if x != nil { + return x.Lines + } + return nil +} + +func (x *LogLines) GetReplicaId() *ReplicaIdentifier { + if x != nil { + return x.ReplicaId + } + return nil +} + +func (x *LogLines) GetStructuredLines() []*dataplane.LogLine { + if x != nil { + return x.StructuredLines + } + return nil +} + +type LogLinesBatch struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Logs []*LogLines `protobuf:"bytes,1,rep,name=logs,proto3" json:"logs,omitempty"` +} + +func (x *LogLinesBatch) Reset() { + *x = LogLinesBatch{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_logs_payload_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LogLinesBatch) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LogLinesBatch) ProtoMessage() {} + +func (x *LogLinesBatch) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_logs_payload_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LogLinesBatch.ProtoReflect.Descriptor instead. +func (*LogLinesBatch) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_logs_payload_proto_rawDescGZIP(), []int{3} +} + +func (x *LogLinesBatch) GetLogs() []*LogLines { + if x != nil { + return x.Logs + } + return nil +} + +type TailLogsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Resp: + // + // *TailLogsResponse_Replicas + // *TailLogsResponse_LogLines + // *TailLogsResponse_Batches + Resp isTailLogsResponse_Resp `protobuf_oneof:"resp"` +} + +func (x *TailLogsResponse) Reset() { + *x = TailLogsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_logs_payload_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TailLogsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TailLogsResponse) ProtoMessage() {} + +func (x *TailLogsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_logs_payload_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TailLogsResponse.ProtoReflect.Descriptor instead. +func (*TailLogsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_logs_payload_proto_rawDescGZIP(), []int{4} +} + +func (m *TailLogsResponse) GetResp() isTailLogsResponse_Resp { + if m != nil { + return m.Resp + } + return nil +} + +func (x *TailLogsResponse) GetReplicas() *ReplicaIdentifierList { + if x, ok := x.GetResp().(*TailLogsResponse_Replicas); ok { + return x.Replicas + } + return nil +} + +// Deprecated: Marked as deprecated in flyteidl2/app/app_logs_payload.proto. +func (x *TailLogsResponse) GetLogLines() *dataplane.LogLines { + if x, ok := x.GetResp().(*TailLogsResponse_LogLines); ok { + return x.LogLines + } + return nil +} + +func (x *TailLogsResponse) GetBatches() *LogLinesBatch { + if x, ok := x.GetResp().(*TailLogsResponse_Batches); ok { + return x.Batches + } + return nil +} + +type isTailLogsResponse_Resp interface { + isTailLogsResponse_Resp() +} + +type TailLogsResponse_Replicas struct { + // Replicas lists the replicas that the logs are being tailed for. This is expected to be the first + // message to be sent in the stream but also can be sent at any later time to update the list of + // replicas being tailed. + Replicas *ReplicaIdentifierList `protobuf:"bytes,1,opt,name=replicas,proto3,oneof"` +} + +type TailLogsResponse_LogLines struct { + // The latest log lines for the application. + // Deprecated, use batches instead. + // + // Deprecated: Marked as deprecated in flyteidl2/app/app_logs_payload.proto. + LogLines *dataplane.LogLines `protobuf:"bytes,2,opt,name=log_lines,json=logLines,proto3,oneof"` +} + +type TailLogsResponse_Batches struct { + // The latest log lines for the application. + Batches *LogLinesBatch `protobuf:"bytes,3,opt,name=batches,proto3,oneof"` +} + +func (*TailLogsResponse_Replicas) isTailLogsResponse_Resp() {} + +func (*TailLogsResponse_LogLines) isTailLogsResponse_Resp() {} + +func (*TailLogsResponse_Batches) isTailLogsResponse_Resp() {} + +var File_flyteidl2_app_app_logs_payload_proto protoreflect.FileDescriptor + +var file_flyteidl2_app_app_logs_payload_proto_rawDesc = []byte{ + 0x0a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, + 0x61, 0x70, 0x70, 0x5f, 0x6c, 0x6f, 0x67, 0x73, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x61, 0x70, 0x70, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x22, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, + 0x70, 0x2f, 0x61, 0x70, 0x70, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x26, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x26, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x6c, 0x6f, 0x67, 0x73, 0x2f, 0x64, + 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x99, 0x01, 0x0a, 0x0f, 0x54, 0x61, 0x69, 0x6c, 0x4c, + 0x6f, 0x67, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x32, 0x0a, 0x06, 0x61, 0x70, + 0x70, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x05, 0x61, 0x70, 0x70, 0x49, 0x64, 0x12, 0x41, + 0x0a, 0x0a, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, + 0x70, 0x70, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x09, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, + 0x64, 0x42, 0x0f, 0x0a, 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x05, 0xba, 0x48, 0x02, + 0x08, 0x01, 0x22, 0x55, 0x0a, 0x15, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x3c, 0x0a, 0x08, 0x72, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x52, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, + 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x22, 0xbb, 0x01, 0x0a, 0x08, 0x4c, 0x6f, + 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x73, 0x12, 0x18, 0x0a, 0x05, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x05, 0x6c, 0x69, 0x6e, 0x65, 0x73, + 0x12, 0x47, 0x0a, 0x0a, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x69, 0x64, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x09, + 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x64, 0x12, 0x4c, 0x0a, 0x10, 0x73, 0x74, 0x72, + 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x18, 0x03, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2e, 0x4c, + 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x52, 0x0f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, + 0x65, 0x64, 0x4c, 0x69, 0x6e, 0x65, 0x73, 0x22, 0x3c, 0x0a, 0x0d, 0x4c, 0x6f, 0x67, 0x4c, 0x69, + 0x6e, 0x65, 0x73, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x2b, 0x0a, 0x04, 0x6c, 0x6f, 0x67, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x4c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x73, 0x52, + 0x04, 0x6c, 0x6f, 0x67, 0x73, 0x22, 0xe6, 0x01, 0x0a, 0x10, 0x54, 0x61, 0x69, 0x6c, 0x4c, 0x6f, + 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x08, 0x72, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x52, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x4c, 0x69, + 0x73, 0x74, 0x48, 0x00, 0x52, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x45, + 0x0a, 0x09, 0x6c, 0x6f, 0x67, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x6c, 0x6f, + 0x67, 0x73, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2e, 0x4c, 0x6f, 0x67, + 0x4c, 0x69, 0x6e, 0x65, 0x73, 0x42, 0x02, 0x18, 0x01, 0x48, 0x00, 0x52, 0x08, 0x6c, 0x6f, 0x67, + 0x4c, 0x69, 0x6e, 0x65, 0x73, 0x12, 0x38, 0x0a, 0x07, 0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x4c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x73, 0x42, + 0x61, 0x74, 0x63, 0x68, 0x48, 0x00, 0x52, 0x07, 0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x42, + 0x0d, 0x0a, 0x04, 0x72, 0x65, 0x73, 0x70, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x42, 0xb2, + 0x01, 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x61, 0x70, 0x70, 0x42, 0x13, 0x41, 0x70, 0x70, 0x4c, 0x6f, 0x67, 0x73, 0x50, 0x61, 0x79, + 0x6c, 0x6f, 0x61, 0x64, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x31, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, + 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, + 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, + 0xa2, 0x02, 0x03, 0x46, 0x41, 0x58, 0xaa, 0x02, 0x0d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x41, 0x70, 0x70, 0xca, 0x02, 0x0d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, 0xe2, 0x02, 0x19, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, + 0x41, 0x70, 0x70, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_app_app_logs_payload_proto_rawDescOnce sync.Once + file_flyteidl2_app_app_logs_payload_proto_rawDescData = file_flyteidl2_app_app_logs_payload_proto_rawDesc +) + +func file_flyteidl2_app_app_logs_payload_proto_rawDescGZIP() []byte { + file_flyteidl2_app_app_logs_payload_proto_rawDescOnce.Do(func() { + file_flyteidl2_app_app_logs_payload_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_app_app_logs_payload_proto_rawDescData) + }) + return file_flyteidl2_app_app_logs_payload_proto_rawDescData +} + +var file_flyteidl2_app_app_logs_payload_proto_msgTypes = make([]protoimpl.MessageInfo, 5) +var file_flyteidl2_app_app_logs_payload_proto_goTypes = []interface{}{ + (*TailLogsRequest)(nil), // 0: flyteidl2.app.TailLogsRequest + (*ReplicaIdentifierList)(nil), // 1: flyteidl2.app.ReplicaIdentifierList + (*LogLines)(nil), // 2: flyteidl2.app.LogLines + (*LogLinesBatch)(nil), // 3: flyteidl2.app.LogLinesBatch + (*TailLogsResponse)(nil), // 4: flyteidl2.app.TailLogsResponse + (*Identifier)(nil), // 5: flyteidl2.app.Identifier + (*ReplicaIdentifier)(nil), // 6: flyteidl2.app.ReplicaIdentifier + (*dataplane.LogLine)(nil), // 7: flyteidl2.logs.dataplane.LogLine + (*dataplane.LogLines)(nil), // 8: flyteidl2.logs.dataplane.LogLines +} +var file_flyteidl2_app_app_logs_payload_proto_depIdxs = []int32{ + 5, // 0: flyteidl2.app.TailLogsRequest.app_id:type_name -> flyteidl2.app.Identifier + 6, // 1: flyteidl2.app.TailLogsRequest.replica_id:type_name -> flyteidl2.app.ReplicaIdentifier + 6, // 2: flyteidl2.app.ReplicaIdentifierList.replicas:type_name -> flyteidl2.app.ReplicaIdentifier + 6, // 3: flyteidl2.app.LogLines.replica_id:type_name -> flyteidl2.app.ReplicaIdentifier + 7, // 4: flyteidl2.app.LogLines.structured_lines:type_name -> flyteidl2.logs.dataplane.LogLine + 2, // 5: flyteidl2.app.LogLinesBatch.logs:type_name -> flyteidl2.app.LogLines + 1, // 6: flyteidl2.app.TailLogsResponse.replicas:type_name -> flyteidl2.app.ReplicaIdentifierList + 8, // 7: flyteidl2.app.TailLogsResponse.log_lines:type_name -> flyteidl2.logs.dataplane.LogLines + 3, // 8: flyteidl2.app.TailLogsResponse.batches:type_name -> flyteidl2.app.LogLinesBatch + 9, // [9:9] is the sub-list for method output_type + 9, // [9:9] is the sub-list for method input_type + 9, // [9:9] is the sub-list for extension type_name + 9, // [9:9] is the sub-list for extension extendee + 0, // [0:9] is the sub-list for field type_name +} + +func init() { file_flyteidl2_app_app_logs_payload_proto_init() } +func file_flyteidl2_app_app_logs_payload_proto_init() { + if File_flyteidl2_app_app_logs_payload_proto != nil { + return + } + file_flyteidl2_app_app_definition_proto_init() + file_flyteidl2_app_replica_definition_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_app_app_logs_payload_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TailLogsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_logs_payload_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ReplicaIdentifierList); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_logs_payload_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LogLines); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_logs_payload_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LogLinesBatch); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_logs_payload_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TailLogsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_app_app_logs_payload_proto_msgTypes[0].OneofWrappers = []interface{}{ + (*TailLogsRequest_AppId)(nil), + (*TailLogsRequest_ReplicaId)(nil), + } + file_flyteidl2_app_app_logs_payload_proto_msgTypes[4].OneofWrappers = []interface{}{ + (*TailLogsResponse_Replicas)(nil), + (*TailLogsResponse_LogLines)(nil), + (*TailLogsResponse_Batches)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_app_app_logs_payload_proto_rawDesc, + NumEnums: 0, + NumMessages: 5, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_app_app_logs_payload_proto_goTypes, + DependencyIndexes: file_flyteidl2_app_app_logs_payload_proto_depIdxs, + MessageInfos: file_flyteidl2_app_app_logs_payload_proto_msgTypes, + }.Build() + File_flyteidl2_app_app_logs_payload_proto = out.File + file_flyteidl2_app_app_logs_payload_proto_rawDesc = nil + file_flyteidl2_app_app_logs_payload_proto_goTypes = nil + file_flyteidl2_app_app_logs_payload_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/app/app_logs_payload.pb.validate.go b/gen/go/flyteidl2/app/app_logs_payload.pb.validate.go new file mode 100644 index 0000000000..c0cc9df400 --- /dev/null +++ b/gen/go/flyteidl2/app/app_logs_payload.pb.validate.go @@ -0,0 +1,883 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/app/app_logs_payload.proto + +package app + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on TailLogsRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *TailLogsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TailLogsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TailLogsRequestMultiError, or nil if none found. +func (m *TailLogsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *TailLogsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Target.(type) { + case *TailLogsRequest_AppId: + if v == nil { + err := TailLogsRequestValidationError{ + field: "Target", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetAppId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TailLogsRequestValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TailLogsRequestValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAppId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TailLogsRequestValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *TailLogsRequest_ReplicaId: + if v == nil { + err := TailLogsRequestValidationError{ + field: "Target", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetReplicaId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TailLogsRequestValidationError{ + field: "ReplicaId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TailLogsRequestValidationError{ + field: "ReplicaId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetReplicaId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TailLogsRequestValidationError{ + field: "ReplicaId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return TailLogsRequestMultiError(errors) + } + + return nil +} + +// TailLogsRequestMultiError is an error wrapping multiple validation errors +// returned by TailLogsRequest.ValidateAll() if the designated constraints +// aren't met. +type TailLogsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TailLogsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TailLogsRequestMultiError) AllErrors() []error { return m } + +// TailLogsRequestValidationError is the validation error returned by +// TailLogsRequest.Validate if the designated constraints aren't met. +type TailLogsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TailLogsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TailLogsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TailLogsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TailLogsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TailLogsRequestValidationError) ErrorName() string { return "TailLogsRequestValidationError" } + +// Error satisfies the builtin error interface +func (e TailLogsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTailLogsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TailLogsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TailLogsRequestValidationError{} + +// Validate checks the field values on ReplicaIdentifierList with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ReplicaIdentifierList) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ReplicaIdentifierList with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ReplicaIdentifierListMultiError, or nil if none found. +func (m *ReplicaIdentifierList) ValidateAll() error { + return m.validate(true) +} + +func (m *ReplicaIdentifierList) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetReplicas() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ReplicaIdentifierListValidationError{ + field: fmt.Sprintf("Replicas[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ReplicaIdentifierListValidationError{ + field: fmt.Sprintf("Replicas[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ReplicaIdentifierListValidationError{ + field: fmt.Sprintf("Replicas[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return ReplicaIdentifierListMultiError(errors) + } + + return nil +} + +// ReplicaIdentifierListMultiError is an error wrapping multiple validation +// errors returned by ReplicaIdentifierList.ValidateAll() if the designated +// constraints aren't met. +type ReplicaIdentifierListMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ReplicaIdentifierListMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ReplicaIdentifierListMultiError) AllErrors() []error { return m } + +// ReplicaIdentifierListValidationError is the validation error returned by +// ReplicaIdentifierList.Validate if the designated constraints aren't met. +type ReplicaIdentifierListValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ReplicaIdentifierListValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ReplicaIdentifierListValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ReplicaIdentifierListValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ReplicaIdentifierListValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ReplicaIdentifierListValidationError) ErrorName() string { + return "ReplicaIdentifierListValidationError" +} + +// Error satisfies the builtin error interface +func (e ReplicaIdentifierListValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sReplicaIdentifierList.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ReplicaIdentifierListValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ReplicaIdentifierListValidationError{} + +// Validate checks the field values on LogLines with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *LogLines) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LogLines with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in LogLinesMultiError, or nil +// if none found. +func (m *LogLines) ValidateAll() error { + return m.validate(true) +} + +func (m *LogLines) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetReplicaId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LogLinesValidationError{ + field: "ReplicaId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LogLinesValidationError{ + field: "ReplicaId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetReplicaId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LogLinesValidationError{ + field: "ReplicaId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetStructuredLines() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LogLinesValidationError{ + field: fmt.Sprintf("StructuredLines[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LogLinesValidationError{ + field: fmt.Sprintf("StructuredLines[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LogLinesValidationError{ + field: fmt.Sprintf("StructuredLines[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return LogLinesMultiError(errors) + } + + return nil +} + +// LogLinesMultiError is an error wrapping multiple validation errors returned +// by LogLines.ValidateAll() if the designated constraints aren't met. +type LogLinesMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LogLinesMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LogLinesMultiError) AllErrors() []error { return m } + +// LogLinesValidationError is the validation error returned by +// LogLines.Validate if the designated constraints aren't met. +type LogLinesValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LogLinesValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LogLinesValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LogLinesValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LogLinesValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LogLinesValidationError) ErrorName() string { return "LogLinesValidationError" } + +// Error satisfies the builtin error interface +func (e LogLinesValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLogLines.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LogLinesValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LogLinesValidationError{} + +// Validate checks the field values on LogLinesBatch with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *LogLinesBatch) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LogLinesBatch with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in LogLinesBatchMultiError, or +// nil if none found. +func (m *LogLinesBatch) ValidateAll() error { + return m.validate(true) +} + +func (m *LogLinesBatch) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetLogs() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LogLinesBatchValidationError{ + field: fmt.Sprintf("Logs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LogLinesBatchValidationError{ + field: fmt.Sprintf("Logs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LogLinesBatchValidationError{ + field: fmt.Sprintf("Logs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return LogLinesBatchMultiError(errors) + } + + return nil +} + +// LogLinesBatchMultiError is an error wrapping multiple validation errors +// returned by LogLinesBatch.ValidateAll() if the designated constraints +// aren't met. +type LogLinesBatchMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LogLinesBatchMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LogLinesBatchMultiError) AllErrors() []error { return m } + +// LogLinesBatchValidationError is the validation error returned by +// LogLinesBatch.Validate if the designated constraints aren't met. +type LogLinesBatchValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LogLinesBatchValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LogLinesBatchValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LogLinesBatchValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LogLinesBatchValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LogLinesBatchValidationError) ErrorName() string { return "LogLinesBatchValidationError" } + +// Error satisfies the builtin error interface +func (e LogLinesBatchValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLogLinesBatch.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LogLinesBatchValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LogLinesBatchValidationError{} + +// Validate checks the field values on TailLogsResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *TailLogsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TailLogsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TailLogsResponseMultiError, or nil if none found. +func (m *TailLogsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *TailLogsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Resp.(type) { + case *TailLogsResponse_Replicas: + if v == nil { + err := TailLogsResponseValidationError{ + field: "Resp", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetReplicas()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TailLogsResponseValidationError{ + field: "Replicas", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TailLogsResponseValidationError{ + field: "Replicas", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetReplicas()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TailLogsResponseValidationError{ + field: "Replicas", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *TailLogsResponse_LogLines: + if v == nil { + err := TailLogsResponseValidationError{ + field: "Resp", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetLogLines()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TailLogsResponseValidationError{ + field: "LogLines", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TailLogsResponseValidationError{ + field: "LogLines", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLogLines()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TailLogsResponseValidationError{ + field: "LogLines", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *TailLogsResponse_Batches: + if v == nil { + err := TailLogsResponseValidationError{ + field: "Resp", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetBatches()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TailLogsResponseValidationError{ + field: "Batches", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TailLogsResponseValidationError{ + field: "Batches", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetBatches()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TailLogsResponseValidationError{ + field: "Batches", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return TailLogsResponseMultiError(errors) + } + + return nil +} + +// TailLogsResponseMultiError is an error wrapping multiple validation errors +// returned by TailLogsResponse.ValidateAll() if the designated constraints +// aren't met. +type TailLogsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TailLogsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TailLogsResponseMultiError) AllErrors() []error { return m } + +// TailLogsResponseValidationError is the validation error returned by +// TailLogsResponse.Validate if the designated constraints aren't met. +type TailLogsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TailLogsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TailLogsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TailLogsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TailLogsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TailLogsResponseValidationError) ErrorName() string { return "TailLogsResponseValidationError" } + +// Error satisfies the builtin error interface +func (e TailLogsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTailLogsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TailLogsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TailLogsResponseValidationError{} diff --git a/gen/go/flyteidl2/app/app_logs_service.pb.go b/gen/go/flyteidl2/app/app_logs_service.pb.go new file mode 100644 index 0000000000..f1e813be56 --- /dev/null +++ b/gen/go/flyteidl2/app/app_logs_service.pb.go @@ -0,0 +1,88 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/app/app_logs_service.proto + +package app + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +var File_flyteidl2_app_app_logs_service_proto protoreflect.FileDescriptor + +var file_flyteidl2_app_app_logs_service_proto_rawDesc = []byte{ + 0x0a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, + 0x61, 0x70, 0x70, 0x5f, 0x6c, 0x6f, 0x67, 0x73, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x61, 0x70, 0x70, 0x1a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x61, 0x70, 0x70, 0x5f, 0x6c, 0x6f, 0x67, 0x73, 0x5f, 0x70, 0x61, + 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x64, 0x0a, 0x0e, 0x41, + 0x70, 0x70, 0x4c, 0x6f, 0x67, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x52, 0x0a, + 0x08, 0x54, 0x61, 0x69, 0x6c, 0x4c, 0x6f, 0x67, 0x73, 0x12, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x54, 0x61, 0x69, 0x6c, 0x4c, 0x6f, + 0x67, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x54, 0x61, 0x69, 0x6c, 0x4c, 0x6f, + 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x30, + 0x01, 0x42, 0xb2, 0x01, 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x42, 0x13, 0x41, 0x70, 0x70, 0x4c, 0x6f, 0x67, 0x73, + 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, + 0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, + 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x61, 0x70, 0x70, 0xa2, 0x02, 0x03, 0x46, 0x41, 0x58, 0xaa, 0x02, 0x0d, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x41, 0x70, 0x70, 0xca, 0x02, 0x0d, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, 0xe2, 0x02, 0x19, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x3a, 0x3a, 0x41, 0x70, 0x70, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var file_flyteidl2_app_app_logs_service_proto_goTypes = []interface{}{ + (*TailLogsRequest)(nil), // 0: flyteidl2.app.TailLogsRequest + (*TailLogsResponse)(nil), // 1: flyteidl2.app.TailLogsResponse +} +var file_flyteidl2_app_app_logs_service_proto_depIdxs = []int32{ + 0, // 0: flyteidl2.app.AppLogsService.TailLogs:input_type -> flyteidl2.app.TailLogsRequest + 1, // 1: flyteidl2.app.AppLogsService.TailLogs:output_type -> flyteidl2.app.TailLogsResponse + 1, // [1:2] is the sub-list for method output_type + 0, // [0:1] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_flyteidl2_app_app_logs_service_proto_init() } +func file_flyteidl2_app_app_logs_service_proto_init() { + if File_flyteidl2_app_app_logs_service_proto != nil { + return + } + file_flyteidl2_app_app_logs_payload_proto_init() + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_app_app_logs_service_proto_rawDesc, + NumEnums: 0, + NumMessages: 0, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_flyteidl2_app_app_logs_service_proto_goTypes, + DependencyIndexes: file_flyteidl2_app_app_logs_service_proto_depIdxs, + }.Build() + File_flyteidl2_app_app_logs_service_proto = out.File + file_flyteidl2_app_app_logs_service_proto_rawDesc = nil + file_flyteidl2_app_app_logs_service_proto_goTypes = nil + file_flyteidl2_app_app_logs_service_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/app/app_logs_service.pb.validate.go b/gen/go/flyteidl2/app/app_logs_service.pb.validate.go new file mode 100644 index 0000000000..7277ce10b8 --- /dev/null +++ b/gen/go/flyteidl2/app/app_logs_service.pb.validate.go @@ -0,0 +1,36 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/app/app_logs_service.proto + +package app + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) diff --git a/gen/go/flyteidl2/app/app_logs_service_grpc.pb.go b/gen/go/flyteidl2/app/app_logs_service_grpc.pb.go new file mode 100644 index 0000000000..dcc0d33276 --- /dev/null +++ b/gen/go/flyteidl2/app/app_logs_service_grpc.pb.go @@ -0,0 +1,134 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: flyteidl2/app/app_logs_service.proto + +package app + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + AppLogsService_TailLogs_FullMethodName = "/flyteidl2.app.AppLogsService/TailLogs" +) + +// AppLogsServiceClient is the client API for AppLogsService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type AppLogsServiceClient interface { + TailLogs(ctx context.Context, in *TailLogsRequest, opts ...grpc.CallOption) (AppLogsService_TailLogsClient, error) +} + +type appLogsServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewAppLogsServiceClient(cc grpc.ClientConnInterface) AppLogsServiceClient { + return &appLogsServiceClient{cc} +} + +func (c *appLogsServiceClient) TailLogs(ctx context.Context, in *TailLogsRequest, opts ...grpc.CallOption) (AppLogsService_TailLogsClient, error) { + stream, err := c.cc.NewStream(ctx, &AppLogsService_ServiceDesc.Streams[0], AppLogsService_TailLogs_FullMethodName, opts...) + if err != nil { + return nil, err + } + x := &appLogsServiceTailLogsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type AppLogsService_TailLogsClient interface { + Recv() (*TailLogsResponse, error) + grpc.ClientStream +} + +type appLogsServiceTailLogsClient struct { + grpc.ClientStream +} + +func (x *appLogsServiceTailLogsClient) Recv() (*TailLogsResponse, error) { + m := new(TailLogsResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// AppLogsServiceServer is the server API for AppLogsService service. +// All implementations should embed UnimplementedAppLogsServiceServer +// for forward compatibility +type AppLogsServiceServer interface { + TailLogs(*TailLogsRequest, AppLogsService_TailLogsServer) error +} + +// UnimplementedAppLogsServiceServer should be embedded to have forward compatible implementations. +type UnimplementedAppLogsServiceServer struct { +} + +func (UnimplementedAppLogsServiceServer) TailLogs(*TailLogsRequest, AppLogsService_TailLogsServer) error { + return status.Errorf(codes.Unimplemented, "method TailLogs not implemented") +} + +// UnsafeAppLogsServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to AppLogsServiceServer will +// result in compilation errors. +type UnsafeAppLogsServiceServer interface { + mustEmbedUnimplementedAppLogsServiceServer() +} + +func RegisterAppLogsServiceServer(s grpc.ServiceRegistrar, srv AppLogsServiceServer) { + s.RegisterService(&AppLogsService_ServiceDesc, srv) +} + +func _AppLogsService_TailLogs_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(TailLogsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(AppLogsServiceServer).TailLogs(m, &appLogsServiceTailLogsServer{stream}) +} + +type AppLogsService_TailLogsServer interface { + Send(*TailLogsResponse) error + grpc.ServerStream +} + +type appLogsServiceTailLogsServer struct { + grpc.ServerStream +} + +func (x *appLogsServiceTailLogsServer) Send(m *TailLogsResponse) error { + return x.ServerStream.SendMsg(m) +} + +// AppLogsService_ServiceDesc is the grpc.ServiceDesc for AppLogsService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var AppLogsService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.app.AppLogsService", + HandlerType: (*AppLogsServiceServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{ + { + StreamName: "TailLogs", + Handler: _AppLogsService_TailLogs_Handler, + ServerStreams: true, + }, + }, + Metadata: "flyteidl2/app/app_logs_service.proto", +} diff --git a/gen/go/flyteidl2/app/app_payload.pb.go b/gen/go/flyteidl2/app/app_payload.pb.go new file mode 100644 index 0000000000..2cf0cf3f80 --- /dev/null +++ b/gen/go/flyteidl2/app/app_payload.pb.go @@ -0,0 +1,1675 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/app/app_payload.proto + +package app + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Request message for creating an app. +type CreateRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The app to be created. + App *App `protobuf:"bytes,1,opt,name=app,proto3" json:"app,omitempty"` +} + +func (x *CreateRequest) Reset() { + *x = CreateRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CreateRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateRequest) ProtoMessage() {} + +func (x *CreateRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateRequest.ProtoReflect.Descriptor instead. +func (*CreateRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{0} +} + +func (x *CreateRequest) GetApp() *App { + if x != nil { + return x.App + } + return nil +} + +// Response message for creating an app. +type CreateResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The created app. + App *App `protobuf:"bytes,1,opt,name=app,proto3" json:"app,omitempty"` +} + +func (x *CreateResponse) Reset() { + *x = CreateResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CreateResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateResponse) ProtoMessage() {} + +func (x *CreateResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateResponse.ProtoReflect.Descriptor instead. +func (*CreateResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{1} +} + +func (x *CreateResponse) GetApp() *App { + if x != nil { + return x.App + } + return nil +} + +// Request message for retrieving an app. +type GetRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Identifier: + // + // *GetRequest_AppId + // *GetRequest_Ingress + Identifier isGetRequest_Identifier `protobuf_oneof:"identifier"` +} + +func (x *GetRequest) Reset() { + *x = GetRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetRequest) ProtoMessage() {} + +func (x *GetRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetRequest.ProtoReflect.Descriptor instead. +func (*GetRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{2} +} + +func (m *GetRequest) GetIdentifier() isGetRequest_Identifier { + if m != nil { + return m.Identifier + } + return nil +} + +func (x *GetRequest) GetAppId() *Identifier { + if x, ok := x.GetIdentifier().(*GetRequest_AppId); ok { + return x.AppId + } + return nil +} + +func (x *GetRequest) GetIngress() *Ingress { + if x, ok := x.GetIdentifier().(*GetRequest_Ingress); ok { + return x.Ingress + } + return nil +} + +type isGetRequest_Identifier interface { + isGetRequest_Identifier() +} + +type GetRequest_AppId struct { + // Identifier of the app to be retrieved. + AppId *Identifier `protobuf:"bytes,1,opt,name=app_id,json=appId,proto3,oneof"` +} + +type GetRequest_Ingress struct { + // Ingress of the app to be retrieved. Only one field need to be set. + // If multiple fields are set, they must resolve into the same app. + // Otherwise, an error is returned. + Ingress *Ingress `protobuf:"bytes,2,opt,name=ingress,proto3,oneof"` +} + +func (*GetRequest_AppId) isGetRequest_Identifier() {} + +func (*GetRequest_Ingress) isGetRequest_Identifier() {} + +// Response message for retrieving an app. +type GetResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The retrieved app. + App *App `protobuf:"bytes,1,opt,name=app,proto3" json:"app,omitempty"` +} + +func (x *GetResponse) Reset() { + *x = GetResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetResponse) ProtoMessage() {} + +func (x *GetResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetResponse.ProtoReflect.Descriptor instead. +func (*GetResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{3} +} + +func (x *GetResponse) GetApp() *App { + if x != nil { + return x.App + } + return nil +} + +// Request message for updating an app. +type UpdateRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The app to be updated. + App *App `protobuf:"bytes,1,opt,name=app,proto3" json:"app,omitempty"` + Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"` +} + +func (x *UpdateRequest) Reset() { + *x = UpdateRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UpdateRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateRequest) ProtoMessage() {} + +func (x *UpdateRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateRequest.ProtoReflect.Descriptor instead. +func (*UpdateRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{4} +} + +func (x *UpdateRequest) GetApp() *App { + if x != nil { + return x.App + } + return nil +} + +func (x *UpdateRequest) GetReason() string { + if x != nil { + return x.Reason + } + return "" +} + +// Response message for updating an app. +type UpdateResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The updated app. + App *App `protobuf:"bytes,1,opt,name=app,proto3" json:"app,omitempty"` +} + +func (x *UpdateResponse) Reset() { + *x = UpdateResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UpdateResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateResponse) ProtoMessage() {} + +func (x *UpdateResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateResponse.ProtoReflect.Descriptor instead. +func (*UpdateResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{5} +} + +func (x *UpdateResponse) GetApp() *App { + if x != nil { + return x.App + } + return nil +} + +// Request message for deleting an app. +type DeleteRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Identifier of the app to be deleted. + AppId *Identifier `protobuf:"bytes,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty"` +} + +func (x *DeleteRequest) Reset() { + *x = DeleteRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteRequest) ProtoMessage() {} + +func (x *DeleteRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteRequest.ProtoReflect.Descriptor instead. +func (*DeleteRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{6} +} + +func (x *DeleteRequest) GetAppId() *Identifier { + if x != nil { + return x.AppId + } + return nil +} + +// Response message for deleting an app. +type DeleteResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *DeleteResponse) Reset() { + *x = DeleteResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteResponse) ProtoMessage() {} + +func (x *DeleteResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteResponse.ProtoReflect.Descriptor instead. +func (*DeleteResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{7} +} + +// Request message for listing apps. +type ListRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Common list request parameters. + Request *common.ListRequest `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"` + // Types that are assignable to FilterBy: + // + // *ListRequest_Org + // *ListRequest_ClusterId + // *ListRequest_Project + FilterBy isListRequest_FilterBy `protobuf_oneof:"filter_by"` +} + +func (x *ListRequest) Reset() { + *x = ListRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListRequest) ProtoMessage() {} + +func (x *ListRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListRequest.ProtoReflect.Descriptor instead. +func (*ListRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{8} +} + +func (x *ListRequest) GetRequest() *common.ListRequest { + if x != nil { + return x.Request + } + return nil +} + +func (m *ListRequest) GetFilterBy() isListRequest_FilterBy { + if m != nil { + return m.FilterBy + } + return nil +} + +func (x *ListRequest) GetOrg() string { + if x, ok := x.GetFilterBy().(*ListRequest_Org); ok { + return x.Org + } + return "" +} + +func (x *ListRequest) GetClusterId() *common.ClusterIdentifier { + if x, ok := x.GetFilterBy().(*ListRequest_ClusterId); ok { + return x.ClusterId + } + return nil +} + +func (x *ListRequest) GetProject() *common.ProjectIdentifier { + if x, ok := x.GetFilterBy().(*ListRequest_Project); ok { + return x.Project + } + return nil +} + +type isListRequest_FilterBy interface { + isListRequest_FilterBy() +} + +type ListRequest_Org struct { + // Organization name for filtering apps. + Org string `protobuf:"bytes,2,opt,name=org,proto3,oneof"` +} + +type ListRequest_ClusterId struct { + // Cluster identifier for filtering apps. + ClusterId *common.ClusterIdentifier `protobuf:"bytes,3,opt,name=cluster_id,json=clusterId,proto3,oneof"` +} + +type ListRequest_Project struct { + // Project identifier for filtering apps. + Project *common.ProjectIdentifier `protobuf:"bytes,4,opt,name=project,proto3,oneof"` +} + +func (*ListRequest_Org) isListRequest_FilterBy() {} + +func (*ListRequest_ClusterId) isListRequest_FilterBy() {} + +func (*ListRequest_Project) isListRequest_FilterBy() {} + +// Response message for listing apps. +type ListResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // List of apps. + Apps []*App `protobuf:"bytes,1,rep,name=apps,proto3" json:"apps,omitempty"` + // Token for fetching the next page of results, if any. + Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"` +} + +func (x *ListResponse) Reset() { + *x = ListResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListResponse) ProtoMessage() {} + +func (x *ListResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListResponse.ProtoReflect.Descriptor instead. +func (*ListResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{9} +} + +func (x *ListResponse) GetApps() []*App { + if x != nil { + return x.Apps + } + return nil +} + +func (x *ListResponse) GetToken() string { + if x != nil { + return x.Token + } + return "" +} + +// Request message for watching app events. +type WatchRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Target: + // + // *WatchRequest_Org + // *WatchRequest_ClusterId + // *WatchRequest_Project + // *WatchRequest_AppId + Target isWatchRequest_Target `protobuf_oneof:"target"` +} + +func (x *WatchRequest) Reset() { + *x = WatchRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchRequest) ProtoMessage() {} + +func (x *WatchRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchRequest.ProtoReflect.Descriptor instead. +func (*WatchRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{10} +} + +func (m *WatchRequest) GetTarget() isWatchRequest_Target { + if m != nil { + return m.Target + } + return nil +} + +func (x *WatchRequest) GetOrg() string { + if x, ok := x.GetTarget().(*WatchRequest_Org); ok { + return x.Org + } + return "" +} + +func (x *WatchRequest) GetClusterId() *common.ClusterIdentifier { + if x, ok := x.GetTarget().(*WatchRequest_ClusterId); ok { + return x.ClusterId + } + return nil +} + +func (x *WatchRequest) GetProject() *common.ProjectIdentifier { + if x, ok := x.GetTarget().(*WatchRequest_Project); ok { + return x.Project + } + return nil +} + +func (x *WatchRequest) GetAppId() *Identifier { + if x, ok := x.GetTarget().(*WatchRequest_AppId); ok { + return x.AppId + } + return nil +} + +type isWatchRequest_Target interface { + isWatchRequest_Target() +} + +type WatchRequest_Org struct { + // Organization name for filtering events. + Org string `protobuf:"bytes,1,opt,name=org,proto3,oneof"` +} + +type WatchRequest_ClusterId struct { + // Cluster identifier for filtering events. + ClusterId *common.ClusterIdentifier `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3,oneof"` +} + +type WatchRequest_Project struct { + // Project identifier for filtering events. + Project *common.ProjectIdentifier `protobuf:"bytes,3,opt,name=project,proto3,oneof"` +} + +type WatchRequest_AppId struct { + // App identifier for filtering events. + AppId *Identifier `protobuf:"bytes,4,opt,name=app_id,json=appId,proto3,oneof"` +} + +func (*WatchRequest_Org) isWatchRequest_Target() {} + +func (*WatchRequest_ClusterId) isWatchRequest_Target() {} + +func (*WatchRequest_Project) isWatchRequest_Target() {} + +func (*WatchRequest_AppId) isWatchRequest_Target() {} + +// Event message for app creation. +type CreateEvent struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The created app. + App *App `protobuf:"bytes,1,opt,name=app,proto3" json:"app,omitempty"` +} + +func (x *CreateEvent) Reset() { + *x = CreateEvent{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CreateEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateEvent) ProtoMessage() {} + +func (x *CreateEvent) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateEvent.ProtoReflect.Descriptor instead. +func (*CreateEvent) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{11} +} + +func (x *CreateEvent) GetApp() *App { + if x != nil { + return x.App + } + return nil +} + +// Event message for app update. +type UpdateEvent struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The updated app. + UpdatedApp *App `protobuf:"bytes,1,opt,name=updated_app,json=updatedApp,proto3" json:"updated_app,omitempty"` + // The old app before the update. + OldApp *App `protobuf:"bytes,2,opt,name=old_app,json=oldApp,proto3" json:"old_app,omitempty"` +} + +func (x *UpdateEvent) Reset() { + *x = UpdateEvent{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UpdateEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateEvent) ProtoMessage() {} + +func (x *UpdateEvent) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateEvent.ProtoReflect.Descriptor instead. +func (*UpdateEvent) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{12} +} + +func (x *UpdateEvent) GetUpdatedApp() *App { + if x != nil { + return x.UpdatedApp + } + return nil +} + +func (x *UpdateEvent) GetOldApp() *App { + if x != nil { + return x.OldApp + } + return nil +} + +// Event message for app deletion. +type DeleteEvent struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The deleted app. + App *App `protobuf:"bytes,1,opt,name=app,proto3" json:"app,omitempty"` +} + +func (x *DeleteEvent) Reset() { + *x = DeleteEvent{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteEvent) ProtoMessage() {} + +func (x *DeleteEvent) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteEvent.ProtoReflect.Descriptor instead. +func (*DeleteEvent) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{13} +} + +func (x *DeleteEvent) GetApp() *App { + if x != nil { + return x.App + } + return nil +} + +// Response message for watching app events. +type WatchResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Event: + // + // *WatchResponse_CreateEvent + // *WatchResponse_UpdateEvent + // *WatchResponse_DeleteEvent + Event isWatchResponse_Event `protobuf_oneof:"event"` +} + +func (x *WatchResponse) Reset() { + *x = WatchResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchResponse) ProtoMessage() {} + +func (x *WatchResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchResponse.ProtoReflect.Descriptor instead. +func (*WatchResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{14} +} + +func (m *WatchResponse) GetEvent() isWatchResponse_Event { + if m != nil { + return m.Event + } + return nil +} + +func (x *WatchResponse) GetCreateEvent() *CreateEvent { + if x, ok := x.GetEvent().(*WatchResponse_CreateEvent); ok { + return x.CreateEvent + } + return nil +} + +func (x *WatchResponse) GetUpdateEvent() *UpdateEvent { + if x, ok := x.GetEvent().(*WatchResponse_UpdateEvent); ok { + return x.UpdateEvent + } + return nil +} + +func (x *WatchResponse) GetDeleteEvent() *DeleteEvent { + if x, ok := x.GetEvent().(*WatchResponse_DeleteEvent); ok { + return x.DeleteEvent + } + return nil +} + +type isWatchResponse_Event interface { + isWatchResponse_Event() +} + +type WatchResponse_CreateEvent struct { + // Event for app creation. + CreateEvent *CreateEvent `protobuf:"bytes,1,opt,name=create_event,json=createEvent,proto3,oneof"` +} + +type WatchResponse_UpdateEvent struct { + // Event for app update. + UpdateEvent *UpdateEvent `protobuf:"bytes,2,opt,name=update_event,json=updateEvent,proto3,oneof"` +} + +type WatchResponse_DeleteEvent struct { + // Event for app deletion. + DeleteEvent *DeleteEvent `protobuf:"bytes,3,opt,name=delete_event,json=deleteEvent,proto3,oneof"` +} + +func (*WatchResponse_CreateEvent) isWatchResponse_Event() {} + +func (*WatchResponse_UpdateEvent) isWatchResponse_Event() {} + +func (*WatchResponse_DeleteEvent) isWatchResponse_Event() {} + +// Request message for updating app status. +type UpdateStatusRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The app with updated status. + App *App `protobuf:"bytes,1,opt,name=app,proto3" json:"app,omitempty"` +} + +func (x *UpdateStatusRequest) Reset() { + *x = UpdateStatusRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UpdateStatusRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateStatusRequest) ProtoMessage() {} + +func (x *UpdateStatusRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateStatusRequest.ProtoReflect.Descriptor instead. +func (*UpdateStatusRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{15} +} + +func (x *UpdateStatusRequest) GetApp() *App { + if x != nil { + return x.App + } + return nil +} + +// Response message for updating app status. +type UpdateStatusResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The app with updated status. + App *App `protobuf:"bytes,1,opt,name=app,proto3" json:"app,omitempty"` +} + +func (x *UpdateStatusResponse) Reset() { + *x = UpdateStatusResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UpdateStatusResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateStatusResponse) ProtoMessage() {} + +func (x *UpdateStatusResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[16] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateStatusResponse.ProtoReflect.Descriptor instead. +func (*UpdateStatusResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{16} +} + +func (x *UpdateStatusResponse) GetApp() *App { + if x != nil { + return x.App + } + return nil +} + +// Request message for leasing apps. +type LeaseRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Cluster identifier for leasing apps. + Id *common.ClusterIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` +} + +func (x *LeaseRequest) Reset() { + *x = LeaseRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LeaseRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LeaseRequest) ProtoMessage() {} + +func (x *LeaseRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LeaseRequest.ProtoReflect.Descriptor instead. +func (*LeaseRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{17} +} + +func (x *LeaseRequest) GetId() *common.ClusterIdentifier { + if x != nil { + return x.Id + } + return nil +} + +// Response message for leasing apps. +type LeaseResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // List of leased apps. + Apps []*App `protobuf:"bytes,1,rep,name=apps,proto3" json:"apps,omitempty"` +} + +func (x *LeaseResponse) Reset() { + *x = LeaseResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LeaseResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LeaseResponse) ProtoMessage() {} + +func (x *LeaseResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_app_payload_proto_msgTypes[18] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LeaseResponse.ProtoReflect.Descriptor instead. +func (*LeaseResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_app_payload_proto_rawDescGZIP(), []int{18} +} + +func (x *LeaseResponse) GetApps() []*App { + if x != nil { + return x.Apps + } + return nil +} + +var File_flyteidl2_app_app_payload_proto protoreflect.FileDescriptor + +var file_flyteidl2_app_app_payload_proto_rawDesc = []byte{ + 0x0a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, + 0x61, 0x70, 0x70, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x0d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, + 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x22, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x61, 0x70, 0x70, + 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x22, 0x3d, 0x0a, 0x0d, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x2c, 0x0a, 0x03, 0x61, 0x70, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, + 0x41, 0x70, 0x70, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x03, 0x61, 0x70, 0x70, + 0x22, 0x36, 0x0a, 0x0e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x24, 0x0a, 0x03, 0x61, 0x70, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, + 0x41, 0x70, 0x70, 0x52, 0x03, 0x61, 0x70, 0x70, 0x22, 0x89, 0x01, 0x0a, 0x0a, 0x47, 0x65, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x32, 0x0a, 0x06, 0x61, 0x70, 0x70, 0x5f, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x48, 0x00, 0x52, 0x05, 0x61, 0x70, 0x70, 0x49, 0x64, 0x12, 0x32, 0x0a, 0x07, 0x69, + 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x49, 0x6e, 0x67, + 0x72, 0x65, 0x73, 0x73, 0x48, 0x00, 0x52, 0x07, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x42, + 0x13, 0x0a, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x05, 0xba, + 0x48, 0x02, 0x08, 0x01, 0x22, 0x33, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x24, 0x0a, 0x03, 0x61, 0x70, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, + 0x2e, 0x41, 0x70, 0x70, 0x52, 0x03, 0x61, 0x70, 0x70, 0x22, 0x5e, 0x0a, 0x0d, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2c, 0x0a, 0x03, 0x61, 0x70, + 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x41, 0x70, 0x70, 0x42, 0x06, 0xba, 0x48, 0x03, + 0xc8, 0x01, 0x01, 0x52, 0x03, 0x61, 0x70, 0x70, 0x12, 0x1f, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, + 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x18, + 0x64, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x22, 0x36, 0x0a, 0x0e, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x24, 0x0a, 0x03, 0x61, + 0x70, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x41, 0x70, 0x70, 0x52, 0x03, 0x61, 0x70, + 0x70, 0x22, 0x49, 0x0a, 0x0d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x38, 0x0a, 0x06, 0x61, 0x70, 0x70, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, + 0x70, 0x70, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, + 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x05, 0x61, 0x70, 0x70, 0x49, 0x64, 0x22, 0x10, 0x0a, 0x0e, + 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xfe, + 0x01, 0x0a, 0x0b, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x37, + 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x07, + 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, + 0x03, 0x6f, 0x72, 0x67, 0x12, 0x44, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, + 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x43, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, + 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x3f, 0x0a, 0x07, 0x70, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x50, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x48, 0x00, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x42, 0x12, 0x0a, 0x09, 0x66, + 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x62, 0x79, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, + 0x4c, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x26, 0x0a, 0x04, 0x61, 0x70, 0x70, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x41, 0x70, + 0x70, 0x52, 0x04, 0x61, 0x70, 0x70, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0xf7, 0x01, + 0x0a, 0x0c, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, + 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, + 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x44, 0x0a, 0x0a, 0x63, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, + 0x64, 0x12, 0x3f, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x12, 0x32, 0x0a, 0x06, 0x61, 0x70, 0x70, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, + 0x70, 0x70, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, + 0x05, 0x61, 0x70, 0x70, 0x49, 0x64, 0x42, 0x0f, 0x0a, 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, 0x33, 0x0a, 0x0b, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x24, 0x0a, 0x03, 0x61, 0x70, 0x70, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x61, 0x70, 0x70, 0x2e, 0x41, 0x70, 0x70, 0x52, 0x03, 0x61, 0x70, 0x70, 0x22, 0x6f, 0x0a, 0x0b, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x33, 0x0a, 0x0b, 0x75, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x70, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, + 0x2e, 0x41, 0x70, 0x70, 0x52, 0x0a, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x70, 0x70, + 0x12, 0x2b, 0x0a, 0x07, 0x6f, 0x6c, 0x64, 0x5f, 0x61, 0x70, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x2e, 0x41, 0x70, 0x70, 0x52, 0x06, 0x6f, 0x6c, 0x64, 0x41, 0x70, 0x70, 0x22, 0x33, 0x0a, + 0x0b, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x24, 0x0a, 0x03, + 0x61, 0x70, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x41, 0x70, 0x70, 0x52, 0x03, 0x61, + 0x70, 0x70, 0x22, 0xdb, 0x01, 0x0a, 0x0d, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x0c, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x5f, 0x65, + 0x76, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x0b, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x3f, 0x0a, 0x0c, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, + 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x55, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x0b, 0x75, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x3f, 0x0a, 0x0c, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x44, 0x65, 0x6c, + 0x65, 0x74, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x0b, 0x64, 0x65, 0x6c, 0x65, + 0x74, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x42, 0x07, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, + 0x22, 0x43, 0x0a, 0x13, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2c, 0x0a, 0x03, 0x61, 0x70, 0x70, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x41, 0x70, 0x70, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, + 0x52, 0x03, 0x61, 0x70, 0x70, 0x22, 0x3c, 0x0a, 0x14, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x24, 0x0a, + 0x03, 0x61, 0x70, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x41, 0x70, 0x70, 0x52, 0x03, + 0x61, 0x70, 0x70, 0x22, 0x4b, 0x0a, 0x0c, 0x4c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x3b, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, + 0x22, 0x37, 0x0a, 0x0d, 0x4c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x26, 0x0a, 0x04, 0x61, 0x70, 0x70, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, + 0x41, 0x70, 0x70, 0x52, 0x04, 0x61, 0x70, 0x70, 0x73, 0x42, 0xae, 0x01, 0x0a, 0x11, 0x63, 0x6f, + 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x42, + 0x0f, 0x41, 0x70, 0x70, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x50, 0x72, 0x6f, 0x74, 0x6f, + 0x48, 0x02, 0x50, 0x01, 0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, + 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, + 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0xa2, 0x02, 0x03, 0x46, 0x41, 0x58, 0xaa, 0x02, 0x0d, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x41, 0x70, 0x70, 0xca, 0x02, 0x0d, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, 0xe2, 0x02, 0x19, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, 0x5c, 0x47, 0x50, + 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x41, 0x70, 0x70, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x33, +} + +var ( + file_flyteidl2_app_app_payload_proto_rawDescOnce sync.Once + file_flyteidl2_app_app_payload_proto_rawDescData = file_flyteidl2_app_app_payload_proto_rawDesc +) + +func file_flyteidl2_app_app_payload_proto_rawDescGZIP() []byte { + file_flyteidl2_app_app_payload_proto_rawDescOnce.Do(func() { + file_flyteidl2_app_app_payload_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_app_app_payload_proto_rawDescData) + }) + return file_flyteidl2_app_app_payload_proto_rawDescData +} + +var file_flyteidl2_app_app_payload_proto_msgTypes = make([]protoimpl.MessageInfo, 19) +var file_flyteidl2_app_app_payload_proto_goTypes = []interface{}{ + (*CreateRequest)(nil), // 0: flyteidl2.app.CreateRequest + (*CreateResponse)(nil), // 1: flyteidl2.app.CreateResponse + (*GetRequest)(nil), // 2: flyteidl2.app.GetRequest + (*GetResponse)(nil), // 3: flyteidl2.app.GetResponse + (*UpdateRequest)(nil), // 4: flyteidl2.app.UpdateRequest + (*UpdateResponse)(nil), // 5: flyteidl2.app.UpdateResponse + (*DeleteRequest)(nil), // 6: flyteidl2.app.DeleteRequest + (*DeleteResponse)(nil), // 7: flyteidl2.app.DeleteResponse + (*ListRequest)(nil), // 8: flyteidl2.app.ListRequest + (*ListResponse)(nil), // 9: flyteidl2.app.ListResponse + (*WatchRequest)(nil), // 10: flyteidl2.app.WatchRequest + (*CreateEvent)(nil), // 11: flyteidl2.app.CreateEvent + (*UpdateEvent)(nil), // 12: flyteidl2.app.UpdateEvent + (*DeleteEvent)(nil), // 13: flyteidl2.app.DeleteEvent + (*WatchResponse)(nil), // 14: flyteidl2.app.WatchResponse + (*UpdateStatusRequest)(nil), // 15: flyteidl2.app.UpdateStatusRequest + (*UpdateStatusResponse)(nil), // 16: flyteidl2.app.UpdateStatusResponse + (*LeaseRequest)(nil), // 17: flyteidl2.app.LeaseRequest + (*LeaseResponse)(nil), // 18: flyteidl2.app.LeaseResponse + (*App)(nil), // 19: flyteidl2.app.App + (*Identifier)(nil), // 20: flyteidl2.app.Identifier + (*Ingress)(nil), // 21: flyteidl2.app.Ingress + (*common.ListRequest)(nil), // 22: flyteidl2.common.ListRequest + (*common.ClusterIdentifier)(nil), // 23: flyteidl2.common.ClusterIdentifier + (*common.ProjectIdentifier)(nil), // 24: flyteidl2.common.ProjectIdentifier +} +var file_flyteidl2_app_app_payload_proto_depIdxs = []int32{ + 19, // 0: flyteidl2.app.CreateRequest.app:type_name -> flyteidl2.app.App + 19, // 1: flyteidl2.app.CreateResponse.app:type_name -> flyteidl2.app.App + 20, // 2: flyteidl2.app.GetRequest.app_id:type_name -> flyteidl2.app.Identifier + 21, // 3: flyteidl2.app.GetRequest.ingress:type_name -> flyteidl2.app.Ingress + 19, // 4: flyteidl2.app.GetResponse.app:type_name -> flyteidl2.app.App + 19, // 5: flyteidl2.app.UpdateRequest.app:type_name -> flyteidl2.app.App + 19, // 6: flyteidl2.app.UpdateResponse.app:type_name -> flyteidl2.app.App + 20, // 7: flyteidl2.app.DeleteRequest.app_id:type_name -> flyteidl2.app.Identifier + 22, // 8: flyteidl2.app.ListRequest.request:type_name -> flyteidl2.common.ListRequest + 23, // 9: flyteidl2.app.ListRequest.cluster_id:type_name -> flyteidl2.common.ClusterIdentifier + 24, // 10: flyteidl2.app.ListRequest.project:type_name -> flyteidl2.common.ProjectIdentifier + 19, // 11: flyteidl2.app.ListResponse.apps:type_name -> flyteidl2.app.App + 23, // 12: flyteidl2.app.WatchRequest.cluster_id:type_name -> flyteidl2.common.ClusterIdentifier + 24, // 13: flyteidl2.app.WatchRequest.project:type_name -> flyteidl2.common.ProjectIdentifier + 20, // 14: flyteidl2.app.WatchRequest.app_id:type_name -> flyteidl2.app.Identifier + 19, // 15: flyteidl2.app.CreateEvent.app:type_name -> flyteidl2.app.App + 19, // 16: flyteidl2.app.UpdateEvent.updated_app:type_name -> flyteidl2.app.App + 19, // 17: flyteidl2.app.UpdateEvent.old_app:type_name -> flyteidl2.app.App + 19, // 18: flyteidl2.app.DeleteEvent.app:type_name -> flyteidl2.app.App + 11, // 19: flyteidl2.app.WatchResponse.create_event:type_name -> flyteidl2.app.CreateEvent + 12, // 20: flyteidl2.app.WatchResponse.update_event:type_name -> flyteidl2.app.UpdateEvent + 13, // 21: flyteidl2.app.WatchResponse.delete_event:type_name -> flyteidl2.app.DeleteEvent + 19, // 22: flyteidl2.app.UpdateStatusRequest.app:type_name -> flyteidl2.app.App + 19, // 23: flyteidl2.app.UpdateStatusResponse.app:type_name -> flyteidl2.app.App + 23, // 24: flyteidl2.app.LeaseRequest.id:type_name -> flyteidl2.common.ClusterIdentifier + 19, // 25: flyteidl2.app.LeaseResponse.apps:type_name -> flyteidl2.app.App + 26, // [26:26] is the sub-list for method output_type + 26, // [26:26] is the sub-list for method input_type + 26, // [26:26] is the sub-list for extension type_name + 26, // [26:26] is the sub-list for extension extendee + 0, // [0:26] is the sub-list for field type_name +} + +func init() { file_flyteidl2_app_app_payload_proto_init() } +func file_flyteidl2_app_app_payload_proto_init() { + if File_flyteidl2_app_app_payload_proto != nil { + return + } + file_flyteidl2_app_app_definition_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_app_app_payload_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CreateRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CreateResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UpdateRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UpdateResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CreateEvent); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UpdateEvent); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteEvent); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UpdateStatusRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UpdateStatusResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LeaseRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LeaseResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_app_app_payload_proto_msgTypes[2].OneofWrappers = []interface{}{ + (*GetRequest_AppId)(nil), + (*GetRequest_Ingress)(nil), + } + file_flyteidl2_app_app_payload_proto_msgTypes[8].OneofWrappers = []interface{}{ + (*ListRequest_Org)(nil), + (*ListRequest_ClusterId)(nil), + (*ListRequest_Project)(nil), + } + file_flyteidl2_app_app_payload_proto_msgTypes[10].OneofWrappers = []interface{}{ + (*WatchRequest_Org)(nil), + (*WatchRequest_ClusterId)(nil), + (*WatchRequest_Project)(nil), + (*WatchRequest_AppId)(nil), + } + file_flyteidl2_app_app_payload_proto_msgTypes[14].OneofWrappers = []interface{}{ + (*WatchResponse_CreateEvent)(nil), + (*WatchResponse_UpdateEvent)(nil), + (*WatchResponse_DeleteEvent)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_app_app_payload_proto_rawDesc, + NumEnums: 0, + NumMessages: 19, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_app_app_payload_proto_goTypes, + DependencyIndexes: file_flyteidl2_app_app_payload_proto_depIdxs, + MessageInfos: file_flyteidl2_app_app_payload_proto_msgTypes, + }.Build() + File_flyteidl2_app_app_payload_proto = out.File + file_flyteidl2_app_app_payload_proto_rawDesc = nil + file_flyteidl2_app_app_payload_proto_goTypes = nil + file_flyteidl2_app_app_payload_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/app/app_payload.pb.validate.go b/gen/go/flyteidl2/app/app_payload.pb.validate.go new file mode 100644 index 0000000000..6c4433d1bc --- /dev/null +++ b/gen/go/flyteidl2/app/app_payload.pb.validate.go @@ -0,0 +1,2863 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/app/app_payload.proto + +package app + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on CreateRequest with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *CreateRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CreateRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in CreateRequestMultiError, or +// nil if none found. +func (m *CreateRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *CreateRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetApp()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateRequestValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateRequestValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetApp()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateRequestValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return CreateRequestMultiError(errors) + } + + return nil +} + +// CreateRequestMultiError is an error wrapping multiple validation errors +// returned by CreateRequest.ValidateAll() if the designated constraints +// aren't met. +type CreateRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CreateRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CreateRequestMultiError) AllErrors() []error { return m } + +// CreateRequestValidationError is the validation error returned by +// CreateRequest.Validate if the designated constraints aren't met. +type CreateRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CreateRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CreateRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CreateRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CreateRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CreateRequestValidationError) ErrorName() string { return "CreateRequestValidationError" } + +// Error satisfies the builtin error interface +func (e CreateRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCreateRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CreateRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CreateRequestValidationError{} + +// Validate checks the field values on CreateResponse with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *CreateResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CreateResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in CreateResponseMultiError, +// or nil if none found. +func (m *CreateResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *CreateResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetApp()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateResponseValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateResponseValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetApp()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateResponseValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return CreateResponseMultiError(errors) + } + + return nil +} + +// CreateResponseMultiError is an error wrapping multiple validation errors +// returned by CreateResponse.ValidateAll() if the designated constraints +// aren't met. +type CreateResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CreateResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CreateResponseMultiError) AllErrors() []error { return m } + +// CreateResponseValidationError is the validation error returned by +// CreateResponse.Validate if the designated constraints aren't met. +type CreateResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CreateResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CreateResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CreateResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CreateResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CreateResponseValidationError) ErrorName() string { return "CreateResponseValidationError" } + +// Error satisfies the builtin error interface +func (e CreateResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCreateResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CreateResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CreateResponseValidationError{} + +// Validate checks the field values on GetRequest with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *GetRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetRequest with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in GetRequestMultiError, or +// nil if none found. +func (m *GetRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Identifier.(type) { + case *GetRequest_AppId: + if v == nil { + err := GetRequestValidationError{ + field: "Identifier", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetAppId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetRequestValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetRequestValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAppId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetRequestValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *GetRequest_Ingress: + if v == nil { + err := GetRequestValidationError{ + field: "Identifier", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetIngress()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetRequestValidationError{ + field: "Ingress", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetRequestValidationError{ + field: "Ingress", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetIngress()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetRequestValidationError{ + field: "Ingress", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return GetRequestMultiError(errors) + } + + return nil +} + +// GetRequestMultiError is an error wrapping multiple validation errors +// returned by GetRequest.ValidateAll() if the designated constraints aren't met. +type GetRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetRequestMultiError) AllErrors() []error { return m } + +// GetRequestValidationError is the validation error returned by +// GetRequest.Validate if the designated constraints aren't met. +type GetRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetRequestValidationError) ErrorName() string { return "GetRequestValidationError" } + +// Error satisfies the builtin error interface +func (e GetRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetRequestValidationError{} + +// Validate checks the field values on GetResponse with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *GetResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetResponse with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in GetResponseMultiError, or +// nil if none found. +func (m *GetResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetApp()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetResponseValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetResponseValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetApp()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetResponseValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetResponseMultiError(errors) + } + + return nil +} + +// GetResponseMultiError is an error wrapping multiple validation errors +// returned by GetResponse.ValidateAll() if the designated constraints aren't met. +type GetResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetResponseMultiError) AllErrors() []error { return m } + +// GetResponseValidationError is the validation error returned by +// GetResponse.Validate if the designated constraints aren't met. +type GetResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetResponseValidationError) ErrorName() string { return "GetResponseValidationError" } + +// Error satisfies the builtin error interface +func (e GetResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetResponseValidationError{} + +// Validate checks the field values on UpdateRequest with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *UpdateRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on UpdateRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in UpdateRequestMultiError, or +// nil if none found. +func (m *UpdateRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *UpdateRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetApp()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UpdateRequestValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UpdateRequestValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetApp()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UpdateRequestValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Reason + + if len(errors) > 0 { + return UpdateRequestMultiError(errors) + } + + return nil +} + +// UpdateRequestMultiError is an error wrapping multiple validation errors +// returned by UpdateRequest.ValidateAll() if the designated constraints +// aren't met. +type UpdateRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UpdateRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UpdateRequestMultiError) AllErrors() []error { return m } + +// UpdateRequestValidationError is the validation error returned by +// UpdateRequest.Validate if the designated constraints aren't met. +type UpdateRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UpdateRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UpdateRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UpdateRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UpdateRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UpdateRequestValidationError) ErrorName() string { return "UpdateRequestValidationError" } + +// Error satisfies the builtin error interface +func (e UpdateRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUpdateRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UpdateRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UpdateRequestValidationError{} + +// Validate checks the field values on UpdateResponse with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *UpdateResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on UpdateResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in UpdateResponseMultiError, +// or nil if none found. +func (m *UpdateResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *UpdateResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetApp()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UpdateResponseValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UpdateResponseValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetApp()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UpdateResponseValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return UpdateResponseMultiError(errors) + } + + return nil +} + +// UpdateResponseMultiError is an error wrapping multiple validation errors +// returned by UpdateResponse.ValidateAll() if the designated constraints +// aren't met. +type UpdateResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UpdateResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UpdateResponseMultiError) AllErrors() []error { return m } + +// UpdateResponseValidationError is the validation error returned by +// UpdateResponse.Validate if the designated constraints aren't met. +type UpdateResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UpdateResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UpdateResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UpdateResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UpdateResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UpdateResponseValidationError) ErrorName() string { return "UpdateResponseValidationError" } + +// Error satisfies the builtin error interface +func (e UpdateResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUpdateResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UpdateResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UpdateResponseValidationError{} + +// Validate checks the field values on DeleteRequest with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *DeleteRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DeleteRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in DeleteRequestMultiError, or +// nil if none found. +func (m *DeleteRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *DeleteRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetAppId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DeleteRequestValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DeleteRequestValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAppId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DeleteRequestValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DeleteRequestMultiError(errors) + } + + return nil +} + +// DeleteRequestMultiError is an error wrapping multiple validation errors +// returned by DeleteRequest.ValidateAll() if the designated constraints +// aren't met. +type DeleteRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DeleteRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DeleteRequestMultiError) AllErrors() []error { return m } + +// DeleteRequestValidationError is the validation error returned by +// DeleteRequest.Validate if the designated constraints aren't met. +type DeleteRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DeleteRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DeleteRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DeleteRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DeleteRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DeleteRequestValidationError) ErrorName() string { return "DeleteRequestValidationError" } + +// Error satisfies the builtin error interface +func (e DeleteRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDeleteRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DeleteRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DeleteRequestValidationError{} + +// Validate checks the field values on DeleteResponse with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *DeleteResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DeleteResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in DeleteResponseMultiError, +// or nil if none found. +func (m *DeleteResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *DeleteResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return DeleteResponseMultiError(errors) + } + + return nil +} + +// DeleteResponseMultiError is an error wrapping multiple validation errors +// returned by DeleteResponse.ValidateAll() if the designated constraints +// aren't met. +type DeleteResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DeleteResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DeleteResponseMultiError) AllErrors() []error { return m } + +// DeleteResponseValidationError is the validation error returned by +// DeleteResponse.Validate if the designated constraints aren't met. +type DeleteResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DeleteResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DeleteResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DeleteResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DeleteResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DeleteResponseValidationError) ErrorName() string { return "DeleteResponseValidationError" } + +// Error satisfies the builtin error interface +func (e DeleteResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDeleteResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DeleteResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DeleteResponseValidationError{} + +// Validate checks the field values on ListRequest with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ListRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListRequest with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ListRequestMultiError, or +// nil if none found. +func (m *ListRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *ListRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRequest()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRequest()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + } + } + } + + switch v := m.FilterBy.(type) { + case *ListRequest_Org: + if v == nil { + err := ListRequestValidationError{ + field: "FilterBy", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for Org + case *ListRequest_ClusterId: + if v == nil { + err := ListRequestValidationError{ + field: "FilterBy", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetClusterId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListRequestValidationError{ + field: "ClusterId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListRequestValidationError{ + field: "ClusterId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetClusterId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListRequestValidationError{ + field: "ClusterId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *ListRequest_Project: + if v == nil { + err := ListRequestValidationError{ + field: "FilterBy", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetProject()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListRequestValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListRequestValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetProject()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListRequestValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return ListRequestMultiError(errors) + } + + return nil +} + +// ListRequestMultiError is an error wrapping multiple validation errors +// returned by ListRequest.ValidateAll() if the designated constraints aren't met. +type ListRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListRequestMultiError) AllErrors() []error { return m } + +// ListRequestValidationError is the validation error returned by +// ListRequest.Validate if the designated constraints aren't met. +type ListRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListRequestValidationError) ErrorName() string { return "ListRequestValidationError" } + +// Error satisfies the builtin error interface +func (e ListRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListRequestValidationError{} + +// Validate checks the field values on ListResponse with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ListResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ListResponseMultiError, or +// nil if none found. +func (m *ListResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *ListResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetApps() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListResponseValidationError{ + field: fmt.Sprintf("Apps[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListResponseValidationError{ + field: fmt.Sprintf("Apps[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListResponseValidationError{ + field: fmt.Sprintf("Apps[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Token + + if len(errors) > 0 { + return ListResponseMultiError(errors) + } + + return nil +} + +// ListResponseMultiError is an error wrapping multiple validation errors +// returned by ListResponse.ValidateAll() if the designated constraints aren't met. +type ListResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListResponseMultiError) AllErrors() []error { return m } + +// ListResponseValidationError is the validation error returned by +// ListResponse.Validate if the designated constraints aren't met. +type ListResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListResponseValidationError) ErrorName() string { return "ListResponseValidationError" } + +// Error satisfies the builtin error interface +func (e ListResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListResponseValidationError{} + +// Validate checks the field values on WatchRequest with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *WatchRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WatchRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in WatchRequestMultiError, or +// nil if none found. +func (m *WatchRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *WatchRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Target.(type) { + case *WatchRequest_Org: + if v == nil { + err := WatchRequestValidationError{ + field: "Target", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for Org + case *WatchRequest_ClusterId: + if v == nil { + err := WatchRequestValidationError{ + field: "Target", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetClusterId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchRequestValidationError{ + field: "ClusterId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchRequestValidationError{ + field: "ClusterId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetClusterId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchRequestValidationError{ + field: "ClusterId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *WatchRequest_Project: + if v == nil { + err := WatchRequestValidationError{ + field: "Target", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetProject()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchRequestValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchRequestValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetProject()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchRequestValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *WatchRequest_AppId: + if v == nil { + err := WatchRequestValidationError{ + field: "Target", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetAppId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchRequestValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchRequestValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAppId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchRequestValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return WatchRequestMultiError(errors) + } + + return nil +} + +// WatchRequestMultiError is an error wrapping multiple validation errors +// returned by WatchRequest.ValidateAll() if the designated constraints aren't met. +type WatchRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WatchRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WatchRequestMultiError) AllErrors() []error { return m } + +// WatchRequestValidationError is the validation error returned by +// WatchRequest.Validate if the designated constraints aren't met. +type WatchRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WatchRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WatchRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WatchRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WatchRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WatchRequestValidationError) ErrorName() string { return "WatchRequestValidationError" } + +// Error satisfies the builtin error interface +func (e WatchRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWatchRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WatchRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WatchRequestValidationError{} + +// Validate checks the field values on CreateEvent with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *CreateEvent) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CreateEvent with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in CreateEventMultiError, or +// nil if none found. +func (m *CreateEvent) ValidateAll() error { + return m.validate(true) +} + +func (m *CreateEvent) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetApp()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateEventValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateEventValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetApp()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateEventValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return CreateEventMultiError(errors) + } + + return nil +} + +// CreateEventMultiError is an error wrapping multiple validation errors +// returned by CreateEvent.ValidateAll() if the designated constraints aren't met. +type CreateEventMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CreateEventMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CreateEventMultiError) AllErrors() []error { return m } + +// CreateEventValidationError is the validation error returned by +// CreateEvent.Validate if the designated constraints aren't met. +type CreateEventValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CreateEventValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CreateEventValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CreateEventValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CreateEventValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CreateEventValidationError) ErrorName() string { return "CreateEventValidationError" } + +// Error satisfies the builtin error interface +func (e CreateEventValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCreateEvent.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CreateEventValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CreateEventValidationError{} + +// Validate checks the field values on UpdateEvent with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *UpdateEvent) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on UpdateEvent with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in UpdateEventMultiError, or +// nil if none found. +func (m *UpdateEvent) ValidateAll() error { + return m.validate(true) +} + +func (m *UpdateEvent) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetUpdatedApp()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UpdateEventValidationError{ + field: "UpdatedApp", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UpdateEventValidationError{ + field: "UpdatedApp", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetUpdatedApp()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UpdateEventValidationError{ + field: "UpdatedApp", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetOldApp()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UpdateEventValidationError{ + field: "OldApp", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UpdateEventValidationError{ + field: "OldApp", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOldApp()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UpdateEventValidationError{ + field: "OldApp", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return UpdateEventMultiError(errors) + } + + return nil +} + +// UpdateEventMultiError is an error wrapping multiple validation errors +// returned by UpdateEvent.ValidateAll() if the designated constraints aren't met. +type UpdateEventMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UpdateEventMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UpdateEventMultiError) AllErrors() []error { return m } + +// UpdateEventValidationError is the validation error returned by +// UpdateEvent.Validate if the designated constraints aren't met. +type UpdateEventValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UpdateEventValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UpdateEventValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UpdateEventValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UpdateEventValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UpdateEventValidationError) ErrorName() string { return "UpdateEventValidationError" } + +// Error satisfies the builtin error interface +func (e UpdateEventValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUpdateEvent.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UpdateEventValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UpdateEventValidationError{} + +// Validate checks the field values on DeleteEvent with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *DeleteEvent) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DeleteEvent with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in DeleteEventMultiError, or +// nil if none found. +func (m *DeleteEvent) ValidateAll() error { + return m.validate(true) +} + +func (m *DeleteEvent) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetApp()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DeleteEventValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DeleteEventValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetApp()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DeleteEventValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DeleteEventMultiError(errors) + } + + return nil +} + +// DeleteEventMultiError is an error wrapping multiple validation errors +// returned by DeleteEvent.ValidateAll() if the designated constraints aren't met. +type DeleteEventMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DeleteEventMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DeleteEventMultiError) AllErrors() []error { return m } + +// DeleteEventValidationError is the validation error returned by +// DeleteEvent.Validate if the designated constraints aren't met. +type DeleteEventValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DeleteEventValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DeleteEventValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DeleteEventValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DeleteEventValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DeleteEventValidationError) ErrorName() string { return "DeleteEventValidationError" } + +// Error satisfies the builtin error interface +func (e DeleteEventValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDeleteEvent.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DeleteEventValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DeleteEventValidationError{} + +// Validate checks the field values on WatchResponse with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *WatchResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WatchResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in WatchResponseMultiError, or +// nil if none found. +func (m *WatchResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *WatchResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Event.(type) { + case *WatchResponse_CreateEvent: + if v == nil { + err := WatchResponseValidationError{ + field: "Event", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetCreateEvent()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchResponseValidationError{ + field: "CreateEvent", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchResponseValidationError{ + field: "CreateEvent", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCreateEvent()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchResponseValidationError{ + field: "CreateEvent", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *WatchResponse_UpdateEvent: + if v == nil { + err := WatchResponseValidationError{ + field: "Event", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetUpdateEvent()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchResponseValidationError{ + field: "UpdateEvent", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchResponseValidationError{ + field: "UpdateEvent", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetUpdateEvent()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchResponseValidationError{ + field: "UpdateEvent", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *WatchResponse_DeleteEvent: + if v == nil { + err := WatchResponseValidationError{ + field: "Event", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetDeleteEvent()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchResponseValidationError{ + field: "DeleteEvent", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchResponseValidationError{ + field: "DeleteEvent", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDeleteEvent()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchResponseValidationError{ + field: "DeleteEvent", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return WatchResponseMultiError(errors) + } + + return nil +} + +// WatchResponseMultiError is an error wrapping multiple validation errors +// returned by WatchResponse.ValidateAll() if the designated constraints +// aren't met. +type WatchResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WatchResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WatchResponseMultiError) AllErrors() []error { return m } + +// WatchResponseValidationError is the validation error returned by +// WatchResponse.Validate if the designated constraints aren't met. +type WatchResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WatchResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WatchResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WatchResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WatchResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WatchResponseValidationError) ErrorName() string { return "WatchResponseValidationError" } + +// Error satisfies the builtin error interface +func (e WatchResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWatchResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WatchResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WatchResponseValidationError{} + +// Validate checks the field values on UpdateStatusRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *UpdateStatusRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on UpdateStatusRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// UpdateStatusRequestMultiError, or nil if none found. +func (m *UpdateStatusRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *UpdateStatusRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetApp()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UpdateStatusRequestValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UpdateStatusRequestValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetApp()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UpdateStatusRequestValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return UpdateStatusRequestMultiError(errors) + } + + return nil +} + +// UpdateStatusRequestMultiError is an error wrapping multiple validation +// errors returned by UpdateStatusRequest.ValidateAll() if the designated +// constraints aren't met. +type UpdateStatusRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UpdateStatusRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UpdateStatusRequestMultiError) AllErrors() []error { return m } + +// UpdateStatusRequestValidationError is the validation error returned by +// UpdateStatusRequest.Validate if the designated constraints aren't met. +type UpdateStatusRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UpdateStatusRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UpdateStatusRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UpdateStatusRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UpdateStatusRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UpdateStatusRequestValidationError) ErrorName() string { + return "UpdateStatusRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e UpdateStatusRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUpdateStatusRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UpdateStatusRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UpdateStatusRequestValidationError{} + +// Validate checks the field values on UpdateStatusResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *UpdateStatusResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on UpdateStatusResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// UpdateStatusResponseMultiError, or nil if none found. +func (m *UpdateStatusResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *UpdateStatusResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetApp()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UpdateStatusResponseValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UpdateStatusResponseValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetApp()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UpdateStatusResponseValidationError{ + field: "App", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return UpdateStatusResponseMultiError(errors) + } + + return nil +} + +// UpdateStatusResponseMultiError is an error wrapping multiple validation +// errors returned by UpdateStatusResponse.ValidateAll() if the designated +// constraints aren't met. +type UpdateStatusResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UpdateStatusResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UpdateStatusResponseMultiError) AllErrors() []error { return m } + +// UpdateStatusResponseValidationError is the validation error returned by +// UpdateStatusResponse.Validate if the designated constraints aren't met. +type UpdateStatusResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UpdateStatusResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UpdateStatusResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UpdateStatusResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UpdateStatusResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UpdateStatusResponseValidationError) ErrorName() string { + return "UpdateStatusResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e UpdateStatusResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUpdateStatusResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UpdateStatusResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UpdateStatusResponseValidationError{} + +// Validate checks the field values on LeaseRequest with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *LeaseRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LeaseRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in LeaseRequestMultiError, or +// nil if none found. +func (m *LeaseRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *LeaseRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LeaseRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LeaseRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LeaseRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return LeaseRequestMultiError(errors) + } + + return nil +} + +// LeaseRequestMultiError is an error wrapping multiple validation errors +// returned by LeaseRequest.ValidateAll() if the designated constraints aren't met. +type LeaseRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LeaseRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LeaseRequestMultiError) AllErrors() []error { return m } + +// LeaseRequestValidationError is the validation error returned by +// LeaseRequest.Validate if the designated constraints aren't met. +type LeaseRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LeaseRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LeaseRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LeaseRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LeaseRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LeaseRequestValidationError) ErrorName() string { return "LeaseRequestValidationError" } + +// Error satisfies the builtin error interface +func (e LeaseRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLeaseRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LeaseRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LeaseRequestValidationError{} + +// Validate checks the field values on LeaseResponse with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *LeaseResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LeaseResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in LeaseResponseMultiError, or +// nil if none found. +func (m *LeaseResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *LeaseResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetApps() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LeaseResponseValidationError{ + field: fmt.Sprintf("Apps[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LeaseResponseValidationError{ + field: fmt.Sprintf("Apps[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LeaseResponseValidationError{ + field: fmt.Sprintf("Apps[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return LeaseResponseMultiError(errors) + } + + return nil +} + +// LeaseResponseMultiError is an error wrapping multiple validation errors +// returned by LeaseResponse.ValidateAll() if the designated constraints +// aren't met. +type LeaseResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LeaseResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LeaseResponseMultiError) AllErrors() []error { return m } + +// LeaseResponseValidationError is the validation error returned by +// LeaseResponse.Validate if the designated constraints aren't met. +type LeaseResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LeaseResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LeaseResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LeaseResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LeaseResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LeaseResponseValidationError) ErrorName() string { return "LeaseResponseValidationError" } + +// Error satisfies the builtin error interface +func (e LeaseResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLeaseResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LeaseResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LeaseResponseValidationError{} diff --git a/gen/go/flyteidl2/app/app_service.pb.go b/gen/go/flyteidl2/app/app_service.pb.go new file mode 100644 index 0000000000..de8cb932b7 --- /dev/null +++ b/gen/go/flyteidl2/app/app_service.pb.go @@ -0,0 +1,147 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/app/app_service.proto + +package app + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +var File_flyteidl2_app_app_service_proto protoreflect.FileDescriptor + +var file_flyteidl2_app_app_service_proto_rawDesc = []byte{ + 0x0a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, + 0x61, 0x70, 0x70, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x0d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, + 0x1a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, + 0x61, 0x70, 0x70, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x32, 0xde, 0x04, 0x0a, 0x0a, 0x41, 0x70, 0x70, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x12, 0x47, 0x0a, 0x06, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x1c, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x41, 0x0a, 0x03, 0x47, 0x65, 0x74, + 0x12, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, + 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x47, 0x0a, 0x06, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x59, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, + 0x12, 0x47, 0x0a, 0x06, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x1c, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x44, 0x0a, 0x04, 0x4c, 0x69, 0x73, + 0x74, 0x12, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x4c, 0x69, + 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, + 0x49, 0x0a, 0x05, 0x57, 0x61, 0x74, 0x63, 0x68, 0x12, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x30, 0x01, 0x12, 0x46, 0x0a, 0x05, 0x4c, 0x65, + 0x61, 0x73, 0x65, 0x12, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x61, 0x70, 0x70, 0x2e, 0x4c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, + 0x2e, 0x4c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, + 0x30, 0x01, 0x42, 0xae, 0x01, 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x42, 0x0f, 0x41, 0x70, 0x70, 0x53, 0x65, 0x72, + 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x31, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, + 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, + 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, + 0xa2, 0x02, 0x03, 0x46, 0x41, 0x58, 0xaa, 0x02, 0x0d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x41, 0x70, 0x70, 0xca, 0x02, 0x0d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, 0xe2, 0x02, 0x19, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, + 0x41, 0x70, 0x70, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var file_flyteidl2_app_app_service_proto_goTypes = []interface{}{ + (*CreateRequest)(nil), // 0: flyteidl2.app.CreateRequest + (*GetRequest)(nil), // 1: flyteidl2.app.GetRequest + (*UpdateRequest)(nil), // 2: flyteidl2.app.UpdateRequest + (*UpdateStatusRequest)(nil), // 3: flyteidl2.app.UpdateStatusRequest + (*DeleteRequest)(nil), // 4: flyteidl2.app.DeleteRequest + (*ListRequest)(nil), // 5: flyteidl2.app.ListRequest + (*WatchRequest)(nil), // 6: flyteidl2.app.WatchRequest + (*LeaseRequest)(nil), // 7: flyteidl2.app.LeaseRequest + (*CreateResponse)(nil), // 8: flyteidl2.app.CreateResponse + (*GetResponse)(nil), // 9: flyteidl2.app.GetResponse + (*UpdateResponse)(nil), // 10: flyteidl2.app.UpdateResponse + (*UpdateStatusResponse)(nil), // 11: flyteidl2.app.UpdateStatusResponse + (*DeleteResponse)(nil), // 12: flyteidl2.app.DeleteResponse + (*ListResponse)(nil), // 13: flyteidl2.app.ListResponse + (*WatchResponse)(nil), // 14: flyteidl2.app.WatchResponse + (*LeaseResponse)(nil), // 15: flyteidl2.app.LeaseResponse +} +var file_flyteidl2_app_app_service_proto_depIdxs = []int32{ + 0, // 0: flyteidl2.app.AppService.Create:input_type -> flyteidl2.app.CreateRequest + 1, // 1: flyteidl2.app.AppService.Get:input_type -> flyteidl2.app.GetRequest + 2, // 2: flyteidl2.app.AppService.Update:input_type -> flyteidl2.app.UpdateRequest + 3, // 3: flyteidl2.app.AppService.UpdateStatus:input_type -> flyteidl2.app.UpdateStatusRequest + 4, // 4: flyteidl2.app.AppService.Delete:input_type -> flyteidl2.app.DeleteRequest + 5, // 5: flyteidl2.app.AppService.List:input_type -> flyteidl2.app.ListRequest + 6, // 6: flyteidl2.app.AppService.Watch:input_type -> flyteidl2.app.WatchRequest + 7, // 7: flyteidl2.app.AppService.Lease:input_type -> flyteidl2.app.LeaseRequest + 8, // 8: flyteidl2.app.AppService.Create:output_type -> flyteidl2.app.CreateResponse + 9, // 9: flyteidl2.app.AppService.Get:output_type -> flyteidl2.app.GetResponse + 10, // 10: flyteidl2.app.AppService.Update:output_type -> flyteidl2.app.UpdateResponse + 11, // 11: flyteidl2.app.AppService.UpdateStatus:output_type -> flyteidl2.app.UpdateStatusResponse + 12, // 12: flyteidl2.app.AppService.Delete:output_type -> flyteidl2.app.DeleteResponse + 13, // 13: flyteidl2.app.AppService.List:output_type -> flyteidl2.app.ListResponse + 14, // 14: flyteidl2.app.AppService.Watch:output_type -> flyteidl2.app.WatchResponse + 15, // 15: flyteidl2.app.AppService.Lease:output_type -> flyteidl2.app.LeaseResponse + 8, // [8:16] is the sub-list for method output_type + 0, // [0:8] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_flyteidl2_app_app_service_proto_init() } +func file_flyteidl2_app_app_service_proto_init() { + if File_flyteidl2_app_app_service_proto != nil { + return + } + file_flyteidl2_app_app_payload_proto_init() + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_app_app_service_proto_rawDesc, + NumEnums: 0, + NumMessages: 0, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_flyteidl2_app_app_service_proto_goTypes, + DependencyIndexes: file_flyteidl2_app_app_service_proto_depIdxs, + }.Build() + File_flyteidl2_app_app_service_proto = out.File + file_flyteidl2_app_app_service_proto_rawDesc = nil + file_flyteidl2_app_app_service_proto_goTypes = nil + file_flyteidl2_app_app_service_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/app/app_service.pb.validate.go b/gen/go/flyteidl2/app/app_service.pb.validate.go new file mode 100644 index 0000000000..eac99ed1d1 --- /dev/null +++ b/gen/go/flyteidl2/app/app_service.pb.validate.go @@ -0,0 +1,36 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/app/app_service.proto + +package app + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) diff --git a/gen/go/flyteidl2/app/app_service_grpc.pb.go b/gen/go/flyteidl2/app/app_service_grpc.pb.go new file mode 100644 index 0000000000..e06c972870 --- /dev/null +++ b/gen/go/flyteidl2/app/app_service_grpc.pb.go @@ -0,0 +1,437 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: flyteidl2/app/app_service.proto + +package app + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + AppService_Create_FullMethodName = "/flyteidl2.app.AppService/Create" + AppService_Get_FullMethodName = "/flyteidl2.app.AppService/Get" + AppService_Update_FullMethodName = "/flyteidl2.app.AppService/Update" + AppService_UpdateStatus_FullMethodName = "/flyteidl2.app.AppService/UpdateStatus" + AppService_Delete_FullMethodName = "/flyteidl2.app.AppService/Delete" + AppService_List_FullMethodName = "/flyteidl2.app.AppService/List" + AppService_Watch_FullMethodName = "/flyteidl2.app.AppService/Watch" + AppService_Lease_FullMethodName = "/flyteidl2.app.AppService/Lease" +) + +// AppServiceClient is the client API for AppService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type AppServiceClient interface { + // Create creates a new app. + Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error) + // Get retrieves an app by its identifier. + Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) + // Update updates an existing app. + Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error) + // UpdateStatus updates the status of an existing app. + UpdateStatus(ctx context.Context, in *UpdateStatusRequest, opts ...grpc.CallOption) (*UpdateStatusResponse, error) + // Delete deletes an app by its identifier. + Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error) + // List lists all apps with optional filtering. + List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error) + // Watch watches for app events. + Watch(ctx context.Context, in *WatchRequest, opts ...grpc.CallOption) (AppService_WatchClient, error) + // Lease leases apps. + Lease(ctx context.Context, in *LeaseRequest, opts ...grpc.CallOption) (AppService_LeaseClient, error) +} + +type appServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewAppServiceClient(cc grpc.ClientConnInterface) AppServiceClient { + return &appServiceClient{cc} +} + +func (c *appServiceClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error) { + out := new(CreateResponse) + err := c.cc.Invoke(ctx, AppService_Create_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *appServiceClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) { + out := new(GetResponse) + err := c.cc.Invoke(ctx, AppService_Get_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *appServiceClient) Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error) { + out := new(UpdateResponse) + err := c.cc.Invoke(ctx, AppService_Update_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *appServiceClient) UpdateStatus(ctx context.Context, in *UpdateStatusRequest, opts ...grpc.CallOption) (*UpdateStatusResponse, error) { + out := new(UpdateStatusResponse) + err := c.cc.Invoke(ctx, AppService_UpdateStatus_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *appServiceClient) Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error) { + out := new(DeleteResponse) + err := c.cc.Invoke(ctx, AppService_Delete_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *appServiceClient) List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error) { + out := new(ListResponse) + err := c.cc.Invoke(ctx, AppService_List_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *appServiceClient) Watch(ctx context.Context, in *WatchRequest, opts ...grpc.CallOption) (AppService_WatchClient, error) { + stream, err := c.cc.NewStream(ctx, &AppService_ServiceDesc.Streams[0], AppService_Watch_FullMethodName, opts...) + if err != nil { + return nil, err + } + x := &appServiceWatchClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type AppService_WatchClient interface { + Recv() (*WatchResponse, error) + grpc.ClientStream +} + +type appServiceWatchClient struct { + grpc.ClientStream +} + +func (x *appServiceWatchClient) Recv() (*WatchResponse, error) { + m := new(WatchResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *appServiceClient) Lease(ctx context.Context, in *LeaseRequest, opts ...grpc.CallOption) (AppService_LeaseClient, error) { + stream, err := c.cc.NewStream(ctx, &AppService_ServiceDesc.Streams[1], AppService_Lease_FullMethodName, opts...) + if err != nil { + return nil, err + } + x := &appServiceLeaseClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type AppService_LeaseClient interface { + Recv() (*LeaseResponse, error) + grpc.ClientStream +} + +type appServiceLeaseClient struct { + grpc.ClientStream +} + +func (x *appServiceLeaseClient) Recv() (*LeaseResponse, error) { + m := new(LeaseResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// AppServiceServer is the server API for AppService service. +// All implementations should embed UnimplementedAppServiceServer +// for forward compatibility +type AppServiceServer interface { + // Create creates a new app. + Create(context.Context, *CreateRequest) (*CreateResponse, error) + // Get retrieves an app by its identifier. + Get(context.Context, *GetRequest) (*GetResponse, error) + // Update updates an existing app. + Update(context.Context, *UpdateRequest) (*UpdateResponse, error) + // UpdateStatus updates the status of an existing app. + UpdateStatus(context.Context, *UpdateStatusRequest) (*UpdateStatusResponse, error) + // Delete deletes an app by its identifier. + Delete(context.Context, *DeleteRequest) (*DeleteResponse, error) + // List lists all apps with optional filtering. + List(context.Context, *ListRequest) (*ListResponse, error) + // Watch watches for app events. + Watch(*WatchRequest, AppService_WatchServer) error + // Lease leases apps. + Lease(*LeaseRequest, AppService_LeaseServer) error +} + +// UnimplementedAppServiceServer should be embedded to have forward compatible implementations. +type UnimplementedAppServiceServer struct { +} + +func (UnimplementedAppServiceServer) Create(context.Context, *CreateRequest) (*CreateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Create not implemented") +} +func (UnimplementedAppServiceServer) Get(context.Context, *GetRequest) (*GetResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Get not implemented") +} +func (UnimplementedAppServiceServer) Update(context.Context, *UpdateRequest) (*UpdateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Update not implemented") +} +func (UnimplementedAppServiceServer) UpdateStatus(context.Context, *UpdateStatusRequest) (*UpdateStatusResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateStatus not implemented") +} +func (UnimplementedAppServiceServer) Delete(context.Context, *DeleteRequest) (*DeleteResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented") +} +func (UnimplementedAppServiceServer) List(context.Context, *ListRequest) (*ListResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method List not implemented") +} +func (UnimplementedAppServiceServer) Watch(*WatchRequest, AppService_WatchServer) error { + return status.Errorf(codes.Unimplemented, "method Watch not implemented") +} +func (UnimplementedAppServiceServer) Lease(*LeaseRequest, AppService_LeaseServer) error { + return status.Errorf(codes.Unimplemented, "method Lease not implemented") +} + +// UnsafeAppServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to AppServiceServer will +// result in compilation errors. +type UnsafeAppServiceServer interface { + mustEmbedUnimplementedAppServiceServer() +} + +func RegisterAppServiceServer(s grpc.ServiceRegistrar, srv AppServiceServer) { + s.RegisterService(&AppService_ServiceDesc, srv) +} + +func _AppService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CreateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AppServiceServer).Create(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AppService_Create_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AppServiceServer).Create(ctx, req.(*CreateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AppService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AppServiceServer).Get(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AppService_Get_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AppServiceServer).Get(ctx, req.(*GetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AppService_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AppServiceServer).Update(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AppService_Update_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AppServiceServer).Update(ctx, req.(*UpdateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AppService_UpdateStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateStatusRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AppServiceServer).UpdateStatus(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AppService_UpdateStatus_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AppServiceServer).UpdateStatus(ctx, req.(*UpdateStatusRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AppService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AppServiceServer).Delete(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AppService_Delete_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AppServiceServer).Delete(ctx, req.(*DeleteRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AppService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AppServiceServer).List(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AppService_List_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AppServiceServer).List(ctx, req.(*ListRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AppService_Watch_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(WatchRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(AppServiceServer).Watch(m, &appServiceWatchServer{stream}) +} + +type AppService_WatchServer interface { + Send(*WatchResponse) error + grpc.ServerStream +} + +type appServiceWatchServer struct { + grpc.ServerStream +} + +func (x *appServiceWatchServer) Send(m *WatchResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _AppService_Lease_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(LeaseRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(AppServiceServer).Lease(m, &appServiceLeaseServer{stream}) +} + +type AppService_LeaseServer interface { + Send(*LeaseResponse) error + grpc.ServerStream +} + +type appServiceLeaseServer struct { + grpc.ServerStream +} + +func (x *appServiceLeaseServer) Send(m *LeaseResponse) error { + return x.ServerStream.SendMsg(m) +} + +// AppService_ServiceDesc is the grpc.ServiceDesc for AppService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var AppService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.app.AppService", + HandlerType: (*AppServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Create", + Handler: _AppService_Create_Handler, + }, + { + MethodName: "Get", + Handler: _AppService_Get_Handler, + }, + { + MethodName: "Update", + Handler: _AppService_Update_Handler, + }, + { + MethodName: "UpdateStatus", + Handler: _AppService_UpdateStatus_Handler, + }, + { + MethodName: "Delete", + Handler: _AppService_Delete_Handler, + }, + { + MethodName: "List", + Handler: _AppService_List_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "Watch", + Handler: _AppService_Watch_Handler, + ServerStreams: true, + }, + { + StreamName: "Lease", + Handler: _AppService_Lease_Handler, + ServerStreams: true, + }, + }, + Metadata: "flyteidl2/app/app_service.proto", +} diff --git a/gen/go/flyteidl2/app/appconnect/app_logs_service.connect.go b/gen/go/flyteidl2/app/appconnect/app_logs_service.connect.go new file mode 100644 index 0000000000..8092801508 --- /dev/null +++ b/gen/go/flyteidl2/app/appconnect/app_logs_service.connect.go @@ -0,0 +1,114 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: flyteidl2/app/app_logs_service.proto + +package appconnect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + app "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // AppLogsServiceName is the fully-qualified name of the AppLogsService service. + AppLogsServiceName = "flyteidl2.app.AppLogsService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // AppLogsServiceTailLogsProcedure is the fully-qualified name of the AppLogsService's TailLogs RPC. + AppLogsServiceTailLogsProcedure = "/flyteidl2.app.AppLogsService/TailLogs" +) + +// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. +var ( + appLogsServiceServiceDescriptor = app.File_flyteidl2_app_app_logs_service_proto.Services().ByName("AppLogsService") + appLogsServiceTailLogsMethodDescriptor = appLogsServiceServiceDescriptor.Methods().ByName("TailLogs") +) + +// AppLogsServiceClient is a client for the flyteidl2.app.AppLogsService service. +type AppLogsServiceClient interface { + TailLogs(context.Context, *connect.Request[app.TailLogsRequest]) (*connect.ServerStreamForClient[app.TailLogsResponse], error) +} + +// NewAppLogsServiceClient constructs a client for the flyteidl2.app.AppLogsService service. By +// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, +// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the +// connect.WithGRPC() or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewAppLogsServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) AppLogsServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &appLogsServiceClient{ + tailLogs: connect.NewClient[app.TailLogsRequest, app.TailLogsResponse]( + httpClient, + baseURL+AppLogsServiceTailLogsProcedure, + connect.WithSchema(appLogsServiceTailLogsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + } +} + +// appLogsServiceClient implements AppLogsServiceClient. +type appLogsServiceClient struct { + tailLogs *connect.Client[app.TailLogsRequest, app.TailLogsResponse] +} + +// TailLogs calls flyteidl2.app.AppLogsService.TailLogs. +func (c *appLogsServiceClient) TailLogs(ctx context.Context, req *connect.Request[app.TailLogsRequest]) (*connect.ServerStreamForClient[app.TailLogsResponse], error) { + return c.tailLogs.CallServerStream(ctx, req) +} + +// AppLogsServiceHandler is an implementation of the flyteidl2.app.AppLogsService service. +type AppLogsServiceHandler interface { + TailLogs(context.Context, *connect.Request[app.TailLogsRequest], *connect.ServerStream[app.TailLogsResponse]) error +} + +// NewAppLogsServiceHandler builds an HTTP handler from the service implementation. It returns the +// path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewAppLogsServiceHandler(svc AppLogsServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + appLogsServiceTailLogsHandler := connect.NewServerStreamHandler( + AppLogsServiceTailLogsProcedure, + svc.TailLogs, + connect.WithSchema(appLogsServiceTailLogsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.app.AppLogsService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case AppLogsServiceTailLogsProcedure: + appLogsServiceTailLogsHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedAppLogsServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedAppLogsServiceHandler struct{} + +func (UnimplementedAppLogsServiceHandler) TailLogs(context.Context, *connect.Request[app.TailLogsRequest], *connect.ServerStream[app.TailLogsResponse]) error { + return connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.app.AppLogsService.TailLogs is not implemented")) +} diff --git a/gen/go/flyteidl2/app/appconnect/app_service.connect.go b/gen/go/flyteidl2/app/appconnect/app_service.connect.go new file mode 100644 index 0000000000..d5e4757e6c --- /dev/null +++ b/gen/go/flyteidl2/app/appconnect/app_service.connect.go @@ -0,0 +1,337 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: flyteidl2/app/app_service.proto + +package appconnect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + app "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // AppServiceName is the fully-qualified name of the AppService service. + AppServiceName = "flyteidl2.app.AppService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // AppServiceCreateProcedure is the fully-qualified name of the AppService's Create RPC. + AppServiceCreateProcedure = "/flyteidl2.app.AppService/Create" + // AppServiceGetProcedure is the fully-qualified name of the AppService's Get RPC. + AppServiceGetProcedure = "/flyteidl2.app.AppService/Get" + // AppServiceUpdateProcedure is the fully-qualified name of the AppService's Update RPC. + AppServiceUpdateProcedure = "/flyteidl2.app.AppService/Update" + // AppServiceUpdateStatusProcedure is the fully-qualified name of the AppService's UpdateStatus RPC. + AppServiceUpdateStatusProcedure = "/flyteidl2.app.AppService/UpdateStatus" + // AppServiceDeleteProcedure is the fully-qualified name of the AppService's Delete RPC. + AppServiceDeleteProcedure = "/flyteidl2.app.AppService/Delete" + // AppServiceListProcedure is the fully-qualified name of the AppService's List RPC. + AppServiceListProcedure = "/flyteidl2.app.AppService/List" + // AppServiceWatchProcedure is the fully-qualified name of the AppService's Watch RPC. + AppServiceWatchProcedure = "/flyteidl2.app.AppService/Watch" + // AppServiceLeaseProcedure is the fully-qualified name of the AppService's Lease RPC. + AppServiceLeaseProcedure = "/flyteidl2.app.AppService/Lease" +) + +// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. +var ( + appServiceServiceDescriptor = app.File_flyteidl2_app_app_service_proto.Services().ByName("AppService") + appServiceCreateMethodDescriptor = appServiceServiceDescriptor.Methods().ByName("Create") + appServiceGetMethodDescriptor = appServiceServiceDescriptor.Methods().ByName("Get") + appServiceUpdateMethodDescriptor = appServiceServiceDescriptor.Methods().ByName("Update") + appServiceUpdateStatusMethodDescriptor = appServiceServiceDescriptor.Methods().ByName("UpdateStatus") + appServiceDeleteMethodDescriptor = appServiceServiceDescriptor.Methods().ByName("Delete") + appServiceListMethodDescriptor = appServiceServiceDescriptor.Methods().ByName("List") + appServiceWatchMethodDescriptor = appServiceServiceDescriptor.Methods().ByName("Watch") + appServiceLeaseMethodDescriptor = appServiceServiceDescriptor.Methods().ByName("Lease") +) + +// AppServiceClient is a client for the flyteidl2.app.AppService service. +type AppServiceClient interface { + // Create creates a new app. + Create(context.Context, *connect.Request[app.CreateRequest]) (*connect.Response[app.CreateResponse], error) + // Get retrieves an app by its identifier. + Get(context.Context, *connect.Request[app.GetRequest]) (*connect.Response[app.GetResponse], error) + // Update updates an existing app. + Update(context.Context, *connect.Request[app.UpdateRequest]) (*connect.Response[app.UpdateResponse], error) + // UpdateStatus updates the status of an existing app. + UpdateStatus(context.Context, *connect.Request[app.UpdateStatusRequest]) (*connect.Response[app.UpdateStatusResponse], error) + // Delete deletes an app by its identifier. + Delete(context.Context, *connect.Request[app.DeleteRequest]) (*connect.Response[app.DeleteResponse], error) + // List lists all apps with optional filtering. + List(context.Context, *connect.Request[app.ListRequest]) (*connect.Response[app.ListResponse], error) + // Watch watches for app events. + Watch(context.Context, *connect.Request[app.WatchRequest]) (*connect.ServerStreamForClient[app.WatchResponse], error) + // Lease leases apps. + Lease(context.Context, *connect.Request[app.LeaseRequest]) (*connect.ServerStreamForClient[app.LeaseResponse], error) +} + +// NewAppServiceClient constructs a client for the flyteidl2.app.AppService service. By default, it +// uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and sends +// uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or +// connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewAppServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) AppServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &appServiceClient{ + create: connect.NewClient[app.CreateRequest, app.CreateResponse]( + httpClient, + baseURL+AppServiceCreateProcedure, + connect.WithSchema(appServiceCreateMethodDescriptor), + connect.WithClientOptions(opts...), + ), + get: connect.NewClient[app.GetRequest, app.GetResponse]( + httpClient, + baseURL+AppServiceGetProcedure, + connect.WithSchema(appServiceGetMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + update: connect.NewClient[app.UpdateRequest, app.UpdateResponse]( + httpClient, + baseURL+AppServiceUpdateProcedure, + connect.WithSchema(appServiceUpdateMethodDescriptor), + connect.WithClientOptions(opts...), + ), + updateStatus: connect.NewClient[app.UpdateStatusRequest, app.UpdateStatusResponse]( + httpClient, + baseURL+AppServiceUpdateStatusProcedure, + connect.WithSchema(appServiceUpdateStatusMethodDescriptor), + connect.WithClientOptions(opts...), + ), + delete: connect.NewClient[app.DeleteRequest, app.DeleteResponse]( + httpClient, + baseURL+AppServiceDeleteProcedure, + connect.WithSchema(appServiceDeleteMethodDescriptor), + connect.WithClientOptions(opts...), + ), + list: connect.NewClient[app.ListRequest, app.ListResponse]( + httpClient, + baseURL+AppServiceListProcedure, + connect.WithSchema(appServiceListMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + watch: connect.NewClient[app.WatchRequest, app.WatchResponse]( + httpClient, + baseURL+AppServiceWatchProcedure, + connect.WithSchema(appServiceWatchMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + lease: connect.NewClient[app.LeaseRequest, app.LeaseResponse]( + httpClient, + baseURL+AppServiceLeaseProcedure, + connect.WithSchema(appServiceLeaseMethodDescriptor), + connect.WithClientOptions(opts...), + ), + } +} + +// appServiceClient implements AppServiceClient. +type appServiceClient struct { + create *connect.Client[app.CreateRequest, app.CreateResponse] + get *connect.Client[app.GetRequest, app.GetResponse] + update *connect.Client[app.UpdateRequest, app.UpdateResponse] + updateStatus *connect.Client[app.UpdateStatusRequest, app.UpdateStatusResponse] + delete *connect.Client[app.DeleteRequest, app.DeleteResponse] + list *connect.Client[app.ListRequest, app.ListResponse] + watch *connect.Client[app.WatchRequest, app.WatchResponse] + lease *connect.Client[app.LeaseRequest, app.LeaseResponse] +} + +// Create calls flyteidl2.app.AppService.Create. +func (c *appServiceClient) Create(ctx context.Context, req *connect.Request[app.CreateRequest]) (*connect.Response[app.CreateResponse], error) { + return c.create.CallUnary(ctx, req) +} + +// Get calls flyteidl2.app.AppService.Get. +func (c *appServiceClient) Get(ctx context.Context, req *connect.Request[app.GetRequest]) (*connect.Response[app.GetResponse], error) { + return c.get.CallUnary(ctx, req) +} + +// Update calls flyteidl2.app.AppService.Update. +func (c *appServiceClient) Update(ctx context.Context, req *connect.Request[app.UpdateRequest]) (*connect.Response[app.UpdateResponse], error) { + return c.update.CallUnary(ctx, req) +} + +// UpdateStatus calls flyteidl2.app.AppService.UpdateStatus. +func (c *appServiceClient) UpdateStatus(ctx context.Context, req *connect.Request[app.UpdateStatusRequest]) (*connect.Response[app.UpdateStatusResponse], error) { + return c.updateStatus.CallUnary(ctx, req) +} + +// Delete calls flyteidl2.app.AppService.Delete. +func (c *appServiceClient) Delete(ctx context.Context, req *connect.Request[app.DeleteRequest]) (*connect.Response[app.DeleteResponse], error) { + return c.delete.CallUnary(ctx, req) +} + +// List calls flyteidl2.app.AppService.List. +func (c *appServiceClient) List(ctx context.Context, req *connect.Request[app.ListRequest]) (*connect.Response[app.ListResponse], error) { + return c.list.CallUnary(ctx, req) +} + +// Watch calls flyteidl2.app.AppService.Watch. +func (c *appServiceClient) Watch(ctx context.Context, req *connect.Request[app.WatchRequest]) (*connect.ServerStreamForClient[app.WatchResponse], error) { + return c.watch.CallServerStream(ctx, req) +} + +// Lease calls flyteidl2.app.AppService.Lease. +func (c *appServiceClient) Lease(ctx context.Context, req *connect.Request[app.LeaseRequest]) (*connect.ServerStreamForClient[app.LeaseResponse], error) { + return c.lease.CallServerStream(ctx, req) +} + +// AppServiceHandler is an implementation of the flyteidl2.app.AppService service. +type AppServiceHandler interface { + // Create creates a new app. + Create(context.Context, *connect.Request[app.CreateRequest]) (*connect.Response[app.CreateResponse], error) + // Get retrieves an app by its identifier. + Get(context.Context, *connect.Request[app.GetRequest]) (*connect.Response[app.GetResponse], error) + // Update updates an existing app. + Update(context.Context, *connect.Request[app.UpdateRequest]) (*connect.Response[app.UpdateResponse], error) + // UpdateStatus updates the status of an existing app. + UpdateStatus(context.Context, *connect.Request[app.UpdateStatusRequest]) (*connect.Response[app.UpdateStatusResponse], error) + // Delete deletes an app by its identifier. + Delete(context.Context, *connect.Request[app.DeleteRequest]) (*connect.Response[app.DeleteResponse], error) + // List lists all apps with optional filtering. + List(context.Context, *connect.Request[app.ListRequest]) (*connect.Response[app.ListResponse], error) + // Watch watches for app events. + Watch(context.Context, *connect.Request[app.WatchRequest], *connect.ServerStream[app.WatchResponse]) error + // Lease leases apps. + Lease(context.Context, *connect.Request[app.LeaseRequest], *connect.ServerStream[app.LeaseResponse]) error +} + +// NewAppServiceHandler builds an HTTP handler from the service implementation. It returns the path +// on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewAppServiceHandler(svc AppServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + appServiceCreateHandler := connect.NewUnaryHandler( + AppServiceCreateProcedure, + svc.Create, + connect.WithSchema(appServiceCreateMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + appServiceGetHandler := connect.NewUnaryHandler( + AppServiceGetProcedure, + svc.Get, + connect.WithSchema(appServiceGetMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + appServiceUpdateHandler := connect.NewUnaryHandler( + AppServiceUpdateProcedure, + svc.Update, + connect.WithSchema(appServiceUpdateMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + appServiceUpdateStatusHandler := connect.NewUnaryHandler( + AppServiceUpdateStatusProcedure, + svc.UpdateStatus, + connect.WithSchema(appServiceUpdateStatusMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + appServiceDeleteHandler := connect.NewUnaryHandler( + AppServiceDeleteProcedure, + svc.Delete, + connect.WithSchema(appServiceDeleteMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + appServiceListHandler := connect.NewUnaryHandler( + AppServiceListProcedure, + svc.List, + connect.WithSchema(appServiceListMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + appServiceWatchHandler := connect.NewServerStreamHandler( + AppServiceWatchProcedure, + svc.Watch, + connect.WithSchema(appServiceWatchMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + appServiceLeaseHandler := connect.NewServerStreamHandler( + AppServiceLeaseProcedure, + svc.Lease, + connect.WithSchema(appServiceLeaseMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.app.AppService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case AppServiceCreateProcedure: + appServiceCreateHandler.ServeHTTP(w, r) + case AppServiceGetProcedure: + appServiceGetHandler.ServeHTTP(w, r) + case AppServiceUpdateProcedure: + appServiceUpdateHandler.ServeHTTP(w, r) + case AppServiceUpdateStatusProcedure: + appServiceUpdateStatusHandler.ServeHTTP(w, r) + case AppServiceDeleteProcedure: + appServiceDeleteHandler.ServeHTTP(w, r) + case AppServiceListProcedure: + appServiceListHandler.ServeHTTP(w, r) + case AppServiceWatchProcedure: + appServiceWatchHandler.ServeHTTP(w, r) + case AppServiceLeaseProcedure: + appServiceLeaseHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedAppServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedAppServiceHandler struct{} + +func (UnimplementedAppServiceHandler) Create(context.Context, *connect.Request[app.CreateRequest]) (*connect.Response[app.CreateResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.app.AppService.Create is not implemented")) +} + +func (UnimplementedAppServiceHandler) Get(context.Context, *connect.Request[app.GetRequest]) (*connect.Response[app.GetResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.app.AppService.Get is not implemented")) +} + +func (UnimplementedAppServiceHandler) Update(context.Context, *connect.Request[app.UpdateRequest]) (*connect.Response[app.UpdateResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.app.AppService.Update is not implemented")) +} + +func (UnimplementedAppServiceHandler) UpdateStatus(context.Context, *connect.Request[app.UpdateStatusRequest]) (*connect.Response[app.UpdateStatusResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.app.AppService.UpdateStatus is not implemented")) +} + +func (UnimplementedAppServiceHandler) Delete(context.Context, *connect.Request[app.DeleteRequest]) (*connect.Response[app.DeleteResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.app.AppService.Delete is not implemented")) +} + +func (UnimplementedAppServiceHandler) List(context.Context, *connect.Request[app.ListRequest]) (*connect.Response[app.ListResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.app.AppService.List is not implemented")) +} + +func (UnimplementedAppServiceHandler) Watch(context.Context, *connect.Request[app.WatchRequest], *connect.ServerStream[app.WatchResponse]) error { + return connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.app.AppService.Watch is not implemented")) +} + +func (UnimplementedAppServiceHandler) Lease(context.Context, *connect.Request[app.LeaseRequest], *connect.ServerStream[app.LeaseResponse]) error { + return connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.app.AppService.Lease is not implemented")) +} diff --git a/gen/go/flyteidl2/app/mocks/app_logs_service_client.go b/gen/go/flyteidl2/app/mocks/app_logs_service_client.go new file mode 100644 index 0000000000..7353f83608 --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/app_logs_service_client.go @@ -0,0 +1,114 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + app "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app" + + grpc "google.golang.org/grpc" + + mock "github.com/stretchr/testify/mock" +) + +// AppLogsServiceClient is an autogenerated mock type for the AppLogsServiceClient type +type AppLogsServiceClient struct { + mock.Mock +} + +type AppLogsServiceClient_Expecter struct { + mock *mock.Mock +} + +func (_m *AppLogsServiceClient) EXPECT() *AppLogsServiceClient_Expecter { + return &AppLogsServiceClient_Expecter{mock: &_m.Mock} +} + +// TailLogs provides a mock function with given fields: ctx, in, opts +func (_m *AppLogsServiceClient) TailLogs(ctx context.Context, in *app.TailLogsRequest, opts ...grpc.CallOption) (app.AppLogsService_TailLogsClient, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for TailLogs") + } + + var r0 app.AppLogsService_TailLogsClient + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *app.TailLogsRequest, ...grpc.CallOption) (app.AppLogsService_TailLogsClient, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *app.TailLogsRequest, ...grpc.CallOption) app.AppLogsService_TailLogsClient); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(app.AppLogsService_TailLogsClient) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *app.TailLogsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppLogsServiceClient_TailLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TailLogs' +type AppLogsServiceClient_TailLogs_Call struct { + *mock.Call +} + +// TailLogs is a helper method to define mock.On call +// - ctx context.Context +// - in *app.TailLogsRequest +// - opts ...grpc.CallOption +func (_e *AppLogsServiceClient_Expecter) TailLogs(ctx interface{}, in interface{}, opts ...interface{}) *AppLogsServiceClient_TailLogs_Call { + return &AppLogsServiceClient_TailLogs_Call{Call: _e.mock.On("TailLogs", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *AppLogsServiceClient_TailLogs_Call) Run(run func(ctx context.Context, in *app.TailLogsRequest, opts ...grpc.CallOption)) *AppLogsServiceClient_TailLogs_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*app.TailLogsRequest), variadicArgs...) + }) + return _c +} + +func (_c *AppLogsServiceClient_TailLogs_Call) Return(_a0 app.AppLogsService_TailLogsClient, _a1 error) *AppLogsServiceClient_TailLogs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppLogsServiceClient_TailLogs_Call) RunAndReturn(run func(context.Context, *app.TailLogsRequest, ...grpc.CallOption) (app.AppLogsService_TailLogsClient, error)) *AppLogsServiceClient_TailLogs_Call { + _c.Call.Return(run) + return _c +} + +// NewAppLogsServiceClient creates a new instance of AppLogsServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAppLogsServiceClient(t interface { + mock.TestingT + Cleanup(func()) +}) *AppLogsServiceClient { + mock := &AppLogsServiceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/app_logs_service_server.go b/gen/go/flyteidl2/app/mocks/app_logs_service_server.go new file mode 100644 index 0000000000..b440b4460f --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/app_logs_service_server.go @@ -0,0 +1,82 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + app "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app" + mock "github.com/stretchr/testify/mock" +) + +// AppLogsServiceServer is an autogenerated mock type for the AppLogsServiceServer type +type AppLogsServiceServer struct { + mock.Mock +} + +type AppLogsServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *AppLogsServiceServer) EXPECT() *AppLogsServiceServer_Expecter { + return &AppLogsServiceServer_Expecter{mock: &_m.Mock} +} + +// TailLogs provides a mock function with given fields: _a0, _a1 +func (_m *AppLogsServiceServer) TailLogs(_a0 *app.TailLogsRequest, _a1 app.AppLogsService_TailLogsServer) error { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for TailLogs") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*app.TailLogsRequest, app.AppLogsService_TailLogsServer) error); ok { + r0 = rf(_a0, _a1) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppLogsServiceServer_TailLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TailLogs' +type AppLogsServiceServer_TailLogs_Call struct { + *mock.Call +} + +// TailLogs is a helper method to define mock.On call +// - _a0 *app.TailLogsRequest +// - _a1 app.AppLogsService_TailLogsServer +func (_e *AppLogsServiceServer_Expecter) TailLogs(_a0 interface{}, _a1 interface{}) *AppLogsServiceServer_TailLogs_Call { + return &AppLogsServiceServer_TailLogs_Call{Call: _e.mock.On("TailLogs", _a0, _a1)} +} + +func (_c *AppLogsServiceServer_TailLogs_Call) Run(run func(_a0 *app.TailLogsRequest, _a1 app.AppLogsService_TailLogsServer)) *AppLogsServiceServer_TailLogs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*app.TailLogsRequest), args[1].(app.AppLogsService_TailLogsServer)) + }) + return _c +} + +func (_c *AppLogsServiceServer_TailLogs_Call) Return(_a0 error) *AppLogsServiceServer_TailLogs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppLogsServiceServer_TailLogs_Call) RunAndReturn(run func(*app.TailLogsRequest, app.AppLogsService_TailLogsServer) error) *AppLogsServiceServer_TailLogs_Call { + _c.Call.Return(run) + return _c +} + +// NewAppLogsServiceServer creates a new instance of AppLogsServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAppLogsServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *AppLogsServiceServer { + mock := &AppLogsServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/app_logs_service_tail_logs_client.go b/gen/go/flyteidl2/app/mocks/app_logs_service_tail_logs_client.go new file mode 100644 index 0000000000..7f3ab47874 --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/app_logs_service_tail_logs_client.go @@ -0,0 +1,385 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + app "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app" + + metadata "google.golang.org/grpc/metadata" + + mock "github.com/stretchr/testify/mock" +) + +// AppLogsService_TailLogsClient is an autogenerated mock type for the AppLogsService_TailLogsClient type +type AppLogsService_TailLogsClient struct { + mock.Mock +} + +type AppLogsService_TailLogsClient_Expecter struct { + mock *mock.Mock +} + +func (_m *AppLogsService_TailLogsClient) EXPECT() *AppLogsService_TailLogsClient_Expecter { + return &AppLogsService_TailLogsClient_Expecter{mock: &_m.Mock} +} + +// CloseSend provides a mock function with no fields +func (_m *AppLogsService_TailLogsClient) CloseSend() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for CloseSend") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppLogsService_TailLogsClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend' +type AppLogsService_TailLogsClient_CloseSend_Call struct { + *mock.Call +} + +// CloseSend is a helper method to define mock.On call +func (_e *AppLogsService_TailLogsClient_Expecter) CloseSend() *AppLogsService_TailLogsClient_CloseSend_Call { + return &AppLogsService_TailLogsClient_CloseSend_Call{Call: _e.mock.On("CloseSend")} +} + +func (_c *AppLogsService_TailLogsClient_CloseSend_Call) Run(run func()) *AppLogsService_TailLogsClient_CloseSend_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AppLogsService_TailLogsClient_CloseSend_Call) Return(_a0 error) *AppLogsService_TailLogsClient_CloseSend_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppLogsService_TailLogsClient_CloseSend_Call) RunAndReturn(run func() error) *AppLogsService_TailLogsClient_CloseSend_Call { + _c.Call.Return(run) + return _c +} + +// Context provides a mock function with no fields +func (_m *AppLogsService_TailLogsClient) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// AppLogsService_TailLogsClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type AppLogsService_TailLogsClient_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *AppLogsService_TailLogsClient_Expecter) Context() *AppLogsService_TailLogsClient_Context_Call { + return &AppLogsService_TailLogsClient_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *AppLogsService_TailLogsClient_Context_Call) Run(run func()) *AppLogsService_TailLogsClient_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AppLogsService_TailLogsClient_Context_Call) Return(_a0 context.Context) *AppLogsService_TailLogsClient_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppLogsService_TailLogsClient_Context_Call) RunAndReturn(run func() context.Context) *AppLogsService_TailLogsClient_Context_Call { + _c.Call.Return(run) + return _c +} + +// Header provides a mock function with no fields +func (_m *AppLogsService_TailLogsClient) Header() (metadata.MD, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Header") + } + + var r0 metadata.MD + var r1 error + if rf, ok := ret.Get(0).(func() (metadata.MD, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppLogsService_TailLogsClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header' +type AppLogsService_TailLogsClient_Header_Call struct { + *mock.Call +} + +// Header is a helper method to define mock.On call +func (_e *AppLogsService_TailLogsClient_Expecter) Header() *AppLogsService_TailLogsClient_Header_Call { + return &AppLogsService_TailLogsClient_Header_Call{Call: _e.mock.On("Header")} +} + +func (_c *AppLogsService_TailLogsClient_Header_Call) Run(run func()) *AppLogsService_TailLogsClient_Header_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AppLogsService_TailLogsClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *AppLogsService_TailLogsClient_Header_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppLogsService_TailLogsClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *AppLogsService_TailLogsClient_Header_Call { + _c.Call.Return(run) + return _c +} + +// Recv provides a mock function with no fields +func (_m *AppLogsService_TailLogsClient) Recv() (*app.TailLogsResponse, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Recv") + } + + var r0 *app.TailLogsResponse + var r1 error + if rf, ok := ret.Get(0).(func() (*app.TailLogsResponse, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() *app.TailLogsResponse); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*app.TailLogsResponse) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppLogsService_TailLogsClient_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv' +type AppLogsService_TailLogsClient_Recv_Call struct { + *mock.Call +} + +// Recv is a helper method to define mock.On call +func (_e *AppLogsService_TailLogsClient_Expecter) Recv() *AppLogsService_TailLogsClient_Recv_Call { + return &AppLogsService_TailLogsClient_Recv_Call{Call: _e.mock.On("Recv")} +} + +func (_c *AppLogsService_TailLogsClient_Recv_Call) Run(run func()) *AppLogsService_TailLogsClient_Recv_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AppLogsService_TailLogsClient_Recv_Call) Return(_a0 *app.TailLogsResponse, _a1 error) *AppLogsService_TailLogsClient_Recv_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppLogsService_TailLogsClient_Recv_Call) RunAndReturn(run func() (*app.TailLogsResponse, error)) *AppLogsService_TailLogsClient_Recv_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *AppLogsService_TailLogsClient) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppLogsService_TailLogsClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type AppLogsService_TailLogsClient_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *AppLogsService_TailLogsClient_Expecter) RecvMsg(m interface{}) *AppLogsService_TailLogsClient_RecvMsg_Call { + return &AppLogsService_TailLogsClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *AppLogsService_TailLogsClient_RecvMsg_Call) Run(run func(m any)) *AppLogsService_TailLogsClient_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *AppLogsService_TailLogsClient_RecvMsg_Call) Return(_a0 error) *AppLogsService_TailLogsClient_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppLogsService_TailLogsClient_RecvMsg_Call) RunAndReturn(run func(any) error) *AppLogsService_TailLogsClient_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *AppLogsService_TailLogsClient) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppLogsService_TailLogsClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type AppLogsService_TailLogsClient_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *AppLogsService_TailLogsClient_Expecter) SendMsg(m interface{}) *AppLogsService_TailLogsClient_SendMsg_Call { + return &AppLogsService_TailLogsClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *AppLogsService_TailLogsClient_SendMsg_Call) Run(run func(m any)) *AppLogsService_TailLogsClient_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *AppLogsService_TailLogsClient_SendMsg_Call) Return(_a0 error) *AppLogsService_TailLogsClient_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppLogsService_TailLogsClient_SendMsg_Call) RunAndReturn(run func(any) error) *AppLogsService_TailLogsClient_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// Trailer provides a mock function with no fields +func (_m *AppLogsService_TailLogsClient) Trailer() metadata.MD { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Trailer") + } + + var r0 metadata.MD + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + return r0 +} + +// AppLogsService_TailLogsClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer' +type AppLogsService_TailLogsClient_Trailer_Call struct { + *mock.Call +} + +// Trailer is a helper method to define mock.On call +func (_e *AppLogsService_TailLogsClient_Expecter) Trailer() *AppLogsService_TailLogsClient_Trailer_Call { + return &AppLogsService_TailLogsClient_Trailer_Call{Call: _e.mock.On("Trailer")} +} + +func (_c *AppLogsService_TailLogsClient_Trailer_Call) Run(run func()) *AppLogsService_TailLogsClient_Trailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AppLogsService_TailLogsClient_Trailer_Call) Return(_a0 metadata.MD) *AppLogsService_TailLogsClient_Trailer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppLogsService_TailLogsClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *AppLogsService_TailLogsClient_Trailer_Call { + _c.Call.Return(run) + return _c +} + +// NewAppLogsService_TailLogsClient creates a new instance of AppLogsService_TailLogsClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAppLogsService_TailLogsClient(t interface { + mock.TestingT + Cleanup(func()) +}) *AppLogsService_TailLogsClient { + mock := &AppLogsService_TailLogsClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/app_logs_service_tail_logs_server.go b/gen/go/flyteidl2/app/mocks/app_logs_service_tail_logs_server.go new file mode 100644 index 0000000000..74fb5485b8 --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/app_logs_service_tail_logs_server.go @@ -0,0 +1,350 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + app "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app" + + metadata "google.golang.org/grpc/metadata" + + mock "github.com/stretchr/testify/mock" +) + +// AppLogsService_TailLogsServer is an autogenerated mock type for the AppLogsService_TailLogsServer type +type AppLogsService_TailLogsServer struct { + mock.Mock +} + +type AppLogsService_TailLogsServer_Expecter struct { + mock *mock.Mock +} + +func (_m *AppLogsService_TailLogsServer) EXPECT() *AppLogsService_TailLogsServer_Expecter { + return &AppLogsService_TailLogsServer_Expecter{mock: &_m.Mock} +} + +// Context provides a mock function with no fields +func (_m *AppLogsService_TailLogsServer) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// AppLogsService_TailLogsServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type AppLogsService_TailLogsServer_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *AppLogsService_TailLogsServer_Expecter) Context() *AppLogsService_TailLogsServer_Context_Call { + return &AppLogsService_TailLogsServer_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *AppLogsService_TailLogsServer_Context_Call) Run(run func()) *AppLogsService_TailLogsServer_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AppLogsService_TailLogsServer_Context_Call) Return(_a0 context.Context) *AppLogsService_TailLogsServer_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppLogsService_TailLogsServer_Context_Call) RunAndReturn(run func() context.Context) *AppLogsService_TailLogsServer_Context_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *AppLogsService_TailLogsServer) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppLogsService_TailLogsServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type AppLogsService_TailLogsServer_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *AppLogsService_TailLogsServer_Expecter) RecvMsg(m interface{}) *AppLogsService_TailLogsServer_RecvMsg_Call { + return &AppLogsService_TailLogsServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *AppLogsService_TailLogsServer_RecvMsg_Call) Run(run func(m any)) *AppLogsService_TailLogsServer_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *AppLogsService_TailLogsServer_RecvMsg_Call) Return(_a0 error) *AppLogsService_TailLogsServer_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppLogsService_TailLogsServer_RecvMsg_Call) RunAndReturn(run func(any) error) *AppLogsService_TailLogsServer_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// Send provides a mock function with given fields: _a0 +func (_m *AppLogsService_TailLogsServer) Send(_a0 *app.TailLogsResponse) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for Send") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*app.TailLogsResponse) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppLogsService_TailLogsServer_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send' +type AppLogsService_TailLogsServer_Send_Call struct { + *mock.Call +} + +// Send is a helper method to define mock.On call +// - _a0 *app.TailLogsResponse +func (_e *AppLogsService_TailLogsServer_Expecter) Send(_a0 interface{}) *AppLogsService_TailLogsServer_Send_Call { + return &AppLogsService_TailLogsServer_Send_Call{Call: _e.mock.On("Send", _a0)} +} + +func (_c *AppLogsService_TailLogsServer_Send_Call) Run(run func(_a0 *app.TailLogsResponse)) *AppLogsService_TailLogsServer_Send_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*app.TailLogsResponse)) + }) + return _c +} + +func (_c *AppLogsService_TailLogsServer_Send_Call) Return(_a0 error) *AppLogsService_TailLogsServer_Send_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppLogsService_TailLogsServer_Send_Call) RunAndReturn(run func(*app.TailLogsResponse) error) *AppLogsService_TailLogsServer_Send_Call { + _c.Call.Return(run) + return _c +} + +// SendHeader provides a mock function with given fields: _a0 +func (_m *AppLogsService_TailLogsServer) SendHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SendHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppLogsService_TailLogsServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader' +type AppLogsService_TailLogsServer_SendHeader_Call struct { + *mock.Call +} + +// SendHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *AppLogsService_TailLogsServer_Expecter) SendHeader(_a0 interface{}) *AppLogsService_TailLogsServer_SendHeader_Call { + return &AppLogsService_TailLogsServer_SendHeader_Call{Call: _e.mock.On("SendHeader", _a0)} +} + +func (_c *AppLogsService_TailLogsServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *AppLogsService_TailLogsServer_SendHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *AppLogsService_TailLogsServer_SendHeader_Call) Return(_a0 error) *AppLogsService_TailLogsServer_SendHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppLogsService_TailLogsServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *AppLogsService_TailLogsServer_SendHeader_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *AppLogsService_TailLogsServer) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppLogsService_TailLogsServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type AppLogsService_TailLogsServer_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *AppLogsService_TailLogsServer_Expecter) SendMsg(m interface{}) *AppLogsService_TailLogsServer_SendMsg_Call { + return &AppLogsService_TailLogsServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *AppLogsService_TailLogsServer_SendMsg_Call) Run(run func(m any)) *AppLogsService_TailLogsServer_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *AppLogsService_TailLogsServer_SendMsg_Call) Return(_a0 error) *AppLogsService_TailLogsServer_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppLogsService_TailLogsServer_SendMsg_Call) RunAndReturn(run func(any) error) *AppLogsService_TailLogsServer_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// SetHeader provides a mock function with given fields: _a0 +func (_m *AppLogsService_TailLogsServer) SetHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SetHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppLogsService_TailLogsServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader' +type AppLogsService_TailLogsServer_SetHeader_Call struct { + *mock.Call +} + +// SetHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *AppLogsService_TailLogsServer_Expecter) SetHeader(_a0 interface{}) *AppLogsService_TailLogsServer_SetHeader_Call { + return &AppLogsService_TailLogsServer_SetHeader_Call{Call: _e.mock.On("SetHeader", _a0)} +} + +func (_c *AppLogsService_TailLogsServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *AppLogsService_TailLogsServer_SetHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *AppLogsService_TailLogsServer_SetHeader_Call) Return(_a0 error) *AppLogsService_TailLogsServer_SetHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppLogsService_TailLogsServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *AppLogsService_TailLogsServer_SetHeader_Call { + _c.Call.Return(run) + return _c +} + +// SetTrailer provides a mock function with given fields: _a0 +func (_m *AppLogsService_TailLogsServer) SetTrailer(_a0 metadata.MD) { + _m.Called(_a0) +} + +// AppLogsService_TailLogsServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer' +type AppLogsService_TailLogsServer_SetTrailer_Call struct { + *mock.Call +} + +// SetTrailer is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *AppLogsService_TailLogsServer_Expecter) SetTrailer(_a0 interface{}) *AppLogsService_TailLogsServer_SetTrailer_Call { + return &AppLogsService_TailLogsServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", _a0)} +} + +func (_c *AppLogsService_TailLogsServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *AppLogsService_TailLogsServer_SetTrailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *AppLogsService_TailLogsServer_SetTrailer_Call) Return() *AppLogsService_TailLogsServer_SetTrailer_Call { + _c.Call.Return() + return _c +} + +func (_c *AppLogsService_TailLogsServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *AppLogsService_TailLogsServer_SetTrailer_Call { + _c.Run(run) + return _c +} + +// NewAppLogsService_TailLogsServer creates a new instance of AppLogsService_TailLogsServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAppLogsService_TailLogsServer(t interface { + mock.TestingT + Cleanup(func()) +}) *AppLogsService_TailLogsServer { + mock := &AppLogsService_TailLogsServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/app_service_client.go b/gen/go/flyteidl2/app/mocks/app_service_client.go new file mode 100644 index 0000000000..224f285fd3 --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/app_service_client.go @@ -0,0 +1,632 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + app "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app" + + grpc "google.golang.org/grpc" + + mock "github.com/stretchr/testify/mock" +) + +// AppServiceClient is an autogenerated mock type for the AppServiceClient type +type AppServiceClient struct { + mock.Mock +} + +type AppServiceClient_Expecter struct { + mock *mock.Mock +} + +func (_m *AppServiceClient) EXPECT() *AppServiceClient_Expecter { + return &AppServiceClient_Expecter{mock: &_m.Mock} +} + +// Create provides a mock function with given fields: ctx, in, opts +func (_m *AppServiceClient) Create(ctx context.Context, in *app.CreateRequest, opts ...grpc.CallOption) (*app.CreateResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Create") + } + + var r0 *app.CreateResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *app.CreateRequest, ...grpc.CallOption) (*app.CreateResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *app.CreateRequest, ...grpc.CallOption) *app.CreateResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*app.CreateResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *app.CreateRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppServiceClient_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create' +type AppServiceClient_Create_Call struct { + *mock.Call +} + +// Create is a helper method to define mock.On call +// - ctx context.Context +// - in *app.CreateRequest +// - opts ...grpc.CallOption +func (_e *AppServiceClient_Expecter) Create(ctx interface{}, in interface{}, opts ...interface{}) *AppServiceClient_Create_Call { + return &AppServiceClient_Create_Call{Call: _e.mock.On("Create", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *AppServiceClient_Create_Call) Run(run func(ctx context.Context, in *app.CreateRequest, opts ...grpc.CallOption)) *AppServiceClient_Create_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*app.CreateRequest), variadicArgs...) + }) + return _c +} + +func (_c *AppServiceClient_Create_Call) Return(_a0 *app.CreateResponse, _a1 error) *AppServiceClient_Create_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppServiceClient_Create_Call) RunAndReturn(run func(context.Context, *app.CreateRequest, ...grpc.CallOption) (*app.CreateResponse, error)) *AppServiceClient_Create_Call { + _c.Call.Return(run) + return _c +} + +// Delete provides a mock function with given fields: ctx, in, opts +func (_m *AppServiceClient) Delete(ctx context.Context, in *app.DeleteRequest, opts ...grpc.CallOption) (*app.DeleteResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Delete") + } + + var r0 *app.DeleteResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *app.DeleteRequest, ...grpc.CallOption) (*app.DeleteResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *app.DeleteRequest, ...grpc.CallOption) *app.DeleteResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*app.DeleteResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *app.DeleteRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppServiceClient_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type AppServiceClient_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - ctx context.Context +// - in *app.DeleteRequest +// - opts ...grpc.CallOption +func (_e *AppServiceClient_Expecter) Delete(ctx interface{}, in interface{}, opts ...interface{}) *AppServiceClient_Delete_Call { + return &AppServiceClient_Delete_Call{Call: _e.mock.On("Delete", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *AppServiceClient_Delete_Call) Run(run func(ctx context.Context, in *app.DeleteRequest, opts ...grpc.CallOption)) *AppServiceClient_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*app.DeleteRequest), variadicArgs...) + }) + return _c +} + +func (_c *AppServiceClient_Delete_Call) Return(_a0 *app.DeleteResponse, _a1 error) *AppServiceClient_Delete_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppServiceClient_Delete_Call) RunAndReturn(run func(context.Context, *app.DeleteRequest, ...grpc.CallOption) (*app.DeleteResponse, error)) *AppServiceClient_Delete_Call { + _c.Call.Return(run) + return _c +} + +// Get provides a mock function with given fields: ctx, in, opts +func (_m *AppServiceClient) Get(ctx context.Context, in *app.GetRequest, opts ...grpc.CallOption) (*app.GetResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 *app.GetResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *app.GetRequest, ...grpc.CallOption) (*app.GetResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *app.GetRequest, ...grpc.CallOption) *app.GetResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*app.GetResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *app.GetRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppServiceClient_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type AppServiceClient_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - in *app.GetRequest +// - opts ...grpc.CallOption +func (_e *AppServiceClient_Expecter) Get(ctx interface{}, in interface{}, opts ...interface{}) *AppServiceClient_Get_Call { + return &AppServiceClient_Get_Call{Call: _e.mock.On("Get", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *AppServiceClient_Get_Call) Run(run func(ctx context.Context, in *app.GetRequest, opts ...grpc.CallOption)) *AppServiceClient_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*app.GetRequest), variadicArgs...) + }) + return _c +} + +func (_c *AppServiceClient_Get_Call) Return(_a0 *app.GetResponse, _a1 error) *AppServiceClient_Get_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppServiceClient_Get_Call) RunAndReturn(run func(context.Context, *app.GetRequest, ...grpc.CallOption) (*app.GetResponse, error)) *AppServiceClient_Get_Call { + _c.Call.Return(run) + return _c +} + +// Lease provides a mock function with given fields: ctx, in, opts +func (_m *AppServiceClient) Lease(ctx context.Context, in *app.LeaseRequest, opts ...grpc.CallOption) (app.AppService_LeaseClient, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Lease") + } + + var r0 app.AppService_LeaseClient + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *app.LeaseRequest, ...grpc.CallOption) (app.AppService_LeaseClient, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *app.LeaseRequest, ...grpc.CallOption) app.AppService_LeaseClient); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(app.AppService_LeaseClient) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *app.LeaseRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppServiceClient_Lease_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Lease' +type AppServiceClient_Lease_Call struct { + *mock.Call +} + +// Lease is a helper method to define mock.On call +// - ctx context.Context +// - in *app.LeaseRequest +// - opts ...grpc.CallOption +func (_e *AppServiceClient_Expecter) Lease(ctx interface{}, in interface{}, opts ...interface{}) *AppServiceClient_Lease_Call { + return &AppServiceClient_Lease_Call{Call: _e.mock.On("Lease", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *AppServiceClient_Lease_Call) Run(run func(ctx context.Context, in *app.LeaseRequest, opts ...grpc.CallOption)) *AppServiceClient_Lease_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*app.LeaseRequest), variadicArgs...) + }) + return _c +} + +func (_c *AppServiceClient_Lease_Call) Return(_a0 app.AppService_LeaseClient, _a1 error) *AppServiceClient_Lease_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppServiceClient_Lease_Call) RunAndReturn(run func(context.Context, *app.LeaseRequest, ...grpc.CallOption) (app.AppService_LeaseClient, error)) *AppServiceClient_Lease_Call { + _c.Call.Return(run) + return _c +} + +// List provides a mock function with given fields: ctx, in, opts +func (_m *AppServiceClient) List(ctx context.Context, in *app.ListRequest, opts ...grpc.CallOption) (*app.ListResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for List") + } + + var r0 *app.ListResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *app.ListRequest, ...grpc.CallOption) (*app.ListResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *app.ListRequest, ...grpc.CallOption) *app.ListResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*app.ListResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *app.ListRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppServiceClient_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List' +type AppServiceClient_List_Call struct { + *mock.Call +} + +// List is a helper method to define mock.On call +// - ctx context.Context +// - in *app.ListRequest +// - opts ...grpc.CallOption +func (_e *AppServiceClient_Expecter) List(ctx interface{}, in interface{}, opts ...interface{}) *AppServiceClient_List_Call { + return &AppServiceClient_List_Call{Call: _e.mock.On("List", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *AppServiceClient_List_Call) Run(run func(ctx context.Context, in *app.ListRequest, opts ...grpc.CallOption)) *AppServiceClient_List_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*app.ListRequest), variadicArgs...) + }) + return _c +} + +func (_c *AppServiceClient_List_Call) Return(_a0 *app.ListResponse, _a1 error) *AppServiceClient_List_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppServiceClient_List_Call) RunAndReturn(run func(context.Context, *app.ListRequest, ...grpc.CallOption) (*app.ListResponse, error)) *AppServiceClient_List_Call { + _c.Call.Return(run) + return _c +} + +// Update provides a mock function with given fields: ctx, in, opts +func (_m *AppServiceClient) Update(ctx context.Context, in *app.UpdateRequest, opts ...grpc.CallOption) (*app.UpdateResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Update") + } + + var r0 *app.UpdateResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *app.UpdateRequest, ...grpc.CallOption) (*app.UpdateResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *app.UpdateRequest, ...grpc.CallOption) *app.UpdateResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*app.UpdateResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *app.UpdateRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppServiceClient_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update' +type AppServiceClient_Update_Call struct { + *mock.Call +} + +// Update is a helper method to define mock.On call +// - ctx context.Context +// - in *app.UpdateRequest +// - opts ...grpc.CallOption +func (_e *AppServiceClient_Expecter) Update(ctx interface{}, in interface{}, opts ...interface{}) *AppServiceClient_Update_Call { + return &AppServiceClient_Update_Call{Call: _e.mock.On("Update", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *AppServiceClient_Update_Call) Run(run func(ctx context.Context, in *app.UpdateRequest, opts ...grpc.CallOption)) *AppServiceClient_Update_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*app.UpdateRequest), variadicArgs...) + }) + return _c +} + +func (_c *AppServiceClient_Update_Call) Return(_a0 *app.UpdateResponse, _a1 error) *AppServiceClient_Update_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppServiceClient_Update_Call) RunAndReturn(run func(context.Context, *app.UpdateRequest, ...grpc.CallOption) (*app.UpdateResponse, error)) *AppServiceClient_Update_Call { + _c.Call.Return(run) + return _c +} + +// UpdateStatus provides a mock function with given fields: ctx, in, opts +func (_m *AppServiceClient) UpdateStatus(ctx context.Context, in *app.UpdateStatusRequest, opts ...grpc.CallOption) (*app.UpdateStatusResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpdateStatus") + } + + var r0 *app.UpdateStatusResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *app.UpdateStatusRequest, ...grpc.CallOption) (*app.UpdateStatusResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *app.UpdateStatusRequest, ...grpc.CallOption) *app.UpdateStatusResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*app.UpdateStatusResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *app.UpdateStatusRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppServiceClient_UpdateStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateStatus' +type AppServiceClient_UpdateStatus_Call struct { + *mock.Call +} + +// UpdateStatus is a helper method to define mock.On call +// - ctx context.Context +// - in *app.UpdateStatusRequest +// - opts ...grpc.CallOption +func (_e *AppServiceClient_Expecter) UpdateStatus(ctx interface{}, in interface{}, opts ...interface{}) *AppServiceClient_UpdateStatus_Call { + return &AppServiceClient_UpdateStatus_Call{Call: _e.mock.On("UpdateStatus", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *AppServiceClient_UpdateStatus_Call) Run(run func(ctx context.Context, in *app.UpdateStatusRequest, opts ...grpc.CallOption)) *AppServiceClient_UpdateStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*app.UpdateStatusRequest), variadicArgs...) + }) + return _c +} + +func (_c *AppServiceClient_UpdateStatus_Call) Return(_a0 *app.UpdateStatusResponse, _a1 error) *AppServiceClient_UpdateStatus_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppServiceClient_UpdateStatus_Call) RunAndReturn(run func(context.Context, *app.UpdateStatusRequest, ...grpc.CallOption) (*app.UpdateStatusResponse, error)) *AppServiceClient_UpdateStatus_Call { + _c.Call.Return(run) + return _c +} + +// Watch provides a mock function with given fields: ctx, in, opts +func (_m *AppServiceClient) Watch(ctx context.Context, in *app.WatchRequest, opts ...grpc.CallOption) (app.AppService_WatchClient, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Watch") + } + + var r0 app.AppService_WatchClient + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *app.WatchRequest, ...grpc.CallOption) (app.AppService_WatchClient, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *app.WatchRequest, ...grpc.CallOption) app.AppService_WatchClient); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(app.AppService_WatchClient) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *app.WatchRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppServiceClient_Watch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Watch' +type AppServiceClient_Watch_Call struct { + *mock.Call +} + +// Watch is a helper method to define mock.On call +// - ctx context.Context +// - in *app.WatchRequest +// - opts ...grpc.CallOption +func (_e *AppServiceClient_Expecter) Watch(ctx interface{}, in interface{}, opts ...interface{}) *AppServiceClient_Watch_Call { + return &AppServiceClient_Watch_Call{Call: _e.mock.On("Watch", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *AppServiceClient_Watch_Call) Run(run func(ctx context.Context, in *app.WatchRequest, opts ...grpc.CallOption)) *AppServiceClient_Watch_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*app.WatchRequest), variadicArgs...) + }) + return _c +} + +func (_c *AppServiceClient_Watch_Call) Return(_a0 app.AppService_WatchClient, _a1 error) *AppServiceClient_Watch_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppServiceClient_Watch_Call) RunAndReturn(run func(context.Context, *app.WatchRequest, ...grpc.CallOption) (app.AppService_WatchClient, error)) *AppServiceClient_Watch_Call { + _c.Call.Return(run) + return _c +} + +// NewAppServiceClient creates a new instance of AppServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAppServiceClient(t interface { + mock.TestingT + Cleanup(func()) +}) *AppServiceClient { + mock := &AppServiceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/app_service_lease_client.go b/gen/go/flyteidl2/app/mocks/app_service_lease_client.go new file mode 100644 index 0000000000..7fa990390c --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/app_service_lease_client.go @@ -0,0 +1,385 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + app "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app" + + metadata "google.golang.org/grpc/metadata" + + mock "github.com/stretchr/testify/mock" +) + +// AppService_LeaseClient is an autogenerated mock type for the AppService_LeaseClient type +type AppService_LeaseClient struct { + mock.Mock +} + +type AppService_LeaseClient_Expecter struct { + mock *mock.Mock +} + +func (_m *AppService_LeaseClient) EXPECT() *AppService_LeaseClient_Expecter { + return &AppService_LeaseClient_Expecter{mock: &_m.Mock} +} + +// CloseSend provides a mock function with no fields +func (_m *AppService_LeaseClient) CloseSend() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for CloseSend") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppService_LeaseClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend' +type AppService_LeaseClient_CloseSend_Call struct { + *mock.Call +} + +// CloseSend is a helper method to define mock.On call +func (_e *AppService_LeaseClient_Expecter) CloseSend() *AppService_LeaseClient_CloseSend_Call { + return &AppService_LeaseClient_CloseSend_Call{Call: _e.mock.On("CloseSend")} +} + +func (_c *AppService_LeaseClient_CloseSend_Call) Run(run func()) *AppService_LeaseClient_CloseSend_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AppService_LeaseClient_CloseSend_Call) Return(_a0 error) *AppService_LeaseClient_CloseSend_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_LeaseClient_CloseSend_Call) RunAndReturn(run func() error) *AppService_LeaseClient_CloseSend_Call { + _c.Call.Return(run) + return _c +} + +// Context provides a mock function with no fields +func (_m *AppService_LeaseClient) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// AppService_LeaseClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type AppService_LeaseClient_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *AppService_LeaseClient_Expecter) Context() *AppService_LeaseClient_Context_Call { + return &AppService_LeaseClient_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *AppService_LeaseClient_Context_Call) Run(run func()) *AppService_LeaseClient_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AppService_LeaseClient_Context_Call) Return(_a0 context.Context) *AppService_LeaseClient_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_LeaseClient_Context_Call) RunAndReturn(run func() context.Context) *AppService_LeaseClient_Context_Call { + _c.Call.Return(run) + return _c +} + +// Header provides a mock function with no fields +func (_m *AppService_LeaseClient) Header() (metadata.MD, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Header") + } + + var r0 metadata.MD + var r1 error + if rf, ok := ret.Get(0).(func() (metadata.MD, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppService_LeaseClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header' +type AppService_LeaseClient_Header_Call struct { + *mock.Call +} + +// Header is a helper method to define mock.On call +func (_e *AppService_LeaseClient_Expecter) Header() *AppService_LeaseClient_Header_Call { + return &AppService_LeaseClient_Header_Call{Call: _e.mock.On("Header")} +} + +func (_c *AppService_LeaseClient_Header_Call) Run(run func()) *AppService_LeaseClient_Header_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AppService_LeaseClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *AppService_LeaseClient_Header_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppService_LeaseClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *AppService_LeaseClient_Header_Call { + _c.Call.Return(run) + return _c +} + +// Recv provides a mock function with no fields +func (_m *AppService_LeaseClient) Recv() (*app.LeaseResponse, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Recv") + } + + var r0 *app.LeaseResponse + var r1 error + if rf, ok := ret.Get(0).(func() (*app.LeaseResponse, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() *app.LeaseResponse); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*app.LeaseResponse) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppService_LeaseClient_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv' +type AppService_LeaseClient_Recv_Call struct { + *mock.Call +} + +// Recv is a helper method to define mock.On call +func (_e *AppService_LeaseClient_Expecter) Recv() *AppService_LeaseClient_Recv_Call { + return &AppService_LeaseClient_Recv_Call{Call: _e.mock.On("Recv")} +} + +func (_c *AppService_LeaseClient_Recv_Call) Run(run func()) *AppService_LeaseClient_Recv_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AppService_LeaseClient_Recv_Call) Return(_a0 *app.LeaseResponse, _a1 error) *AppService_LeaseClient_Recv_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppService_LeaseClient_Recv_Call) RunAndReturn(run func() (*app.LeaseResponse, error)) *AppService_LeaseClient_Recv_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *AppService_LeaseClient) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppService_LeaseClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type AppService_LeaseClient_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *AppService_LeaseClient_Expecter) RecvMsg(m interface{}) *AppService_LeaseClient_RecvMsg_Call { + return &AppService_LeaseClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *AppService_LeaseClient_RecvMsg_Call) Run(run func(m any)) *AppService_LeaseClient_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *AppService_LeaseClient_RecvMsg_Call) Return(_a0 error) *AppService_LeaseClient_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_LeaseClient_RecvMsg_Call) RunAndReturn(run func(any) error) *AppService_LeaseClient_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *AppService_LeaseClient) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppService_LeaseClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type AppService_LeaseClient_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *AppService_LeaseClient_Expecter) SendMsg(m interface{}) *AppService_LeaseClient_SendMsg_Call { + return &AppService_LeaseClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *AppService_LeaseClient_SendMsg_Call) Run(run func(m any)) *AppService_LeaseClient_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *AppService_LeaseClient_SendMsg_Call) Return(_a0 error) *AppService_LeaseClient_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_LeaseClient_SendMsg_Call) RunAndReturn(run func(any) error) *AppService_LeaseClient_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// Trailer provides a mock function with no fields +func (_m *AppService_LeaseClient) Trailer() metadata.MD { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Trailer") + } + + var r0 metadata.MD + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + return r0 +} + +// AppService_LeaseClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer' +type AppService_LeaseClient_Trailer_Call struct { + *mock.Call +} + +// Trailer is a helper method to define mock.On call +func (_e *AppService_LeaseClient_Expecter) Trailer() *AppService_LeaseClient_Trailer_Call { + return &AppService_LeaseClient_Trailer_Call{Call: _e.mock.On("Trailer")} +} + +func (_c *AppService_LeaseClient_Trailer_Call) Run(run func()) *AppService_LeaseClient_Trailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AppService_LeaseClient_Trailer_Call) Return(_a0 metadata.MD) *AppService_LeaseClient_Trailer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_LeaseClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *AppService_LeaseClient_Trailer_Call { + _c.Call.Return(run) + return _c +} + +// NewAppService_LeaseClient creates a new instance of AppService_LeaseClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAppService_LeaseClient(t interface { + mock.TestingT + Cleanup(func()) +}) *AppService_LeaseClient { + mock := &AppService_LeaseClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/app_service_lease_server.go b/gen/go/flyteidl2/app/mocks/app_service_lease_server.go new file mode 100644 index 0000000000..2e9549de1e --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/app_service_lease_server.go @@ -0,0 +1,350 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + app "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app" + + metadata "google.golang.org/grpc/metadata" + + mock "github.com/stretchr/testify/mock" +) + +// AppService_LeaseServer is an autogenerated mock type for the AppService_LeaseServer type +type AppService_LeaseServer struct { + mock.Mock +} + +type AppService_LeaseServer_Expecter struct { + mock *mock.Mock +} + +func (_m *AppService_LeaseServer) EXPECT() *AppService_LeaseServer_Expecter { + return &AppService_LeaseServer_Expecter{mock: &_m.Mock} +} + +// Context provides a mock function with no fields +func (_m *AppService_LeaseServer) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// AppService_LeaseServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type AppService_LeaseServer_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *AppService_LeaseServer_Expecter) Context() *AppService_LeaseServer_Context_Call { + return &AppService_LeaseServer_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *AppService_LeaseServer_Context_Call) Run(run func()) *AppService_LeaseServer_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AppService_LeaseServer_Context_Call) Return(_a0 context.Context) *AppService_LeaseServer_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_LeaseServer_Context_Call) RunAndReturn(run func() context.Context) *AppService_LeaseServer_Context_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *AppService_LeaseServer) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppService_LeaseServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type AppService_LeaseServer_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *AppService_LeaseServer_Expecter) RecvMsg(m interface{}) *AppService_LeaseServer_RecvMsg_Call { + return &AppService_LeaseServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *AppService_LeaseServer_RecvMsg_Call) Run(run func(m any)) *AppService_LeaseServer_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *AppService_LeaseServer_RecvMsg_Call) Return(_a0 error) *AppService_LeaseServer_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_LeaseServer_RecvMsg_Call) RunAndReturn(run func(any) error) *AppService_LeaseServer_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// Send provides a mock function with given fields: _a0 +func (_m *AppService_LeaseServer) Send(_a0 *app.LeaseResponse) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for Send") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*app.LeaseResponse) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppService_LeaseServer_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send' +type AppService_LeaseServer_Send_Call struct { + *mock.Call +} + +// Send is a helper method to define mock.On call +// - _a0 *app.LeaseResponse +func (_e *AppService_LeaseServer_Expecter) Send(_a0 interface{}) *AppService_LeaseServer_Send_Call { + return &AppService_LeaseServer_Send_Call{Call: _e.mock.On("Send", _a0)} +} + +func (_c *AppService_LeaseServer_Send_Call) Run(run func(_a0 *app.LeaseResponse)) *AppService_LeaseServer_Send_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*app.LeaseResponse)) + }) + return _c +} + +func (_c *AppService_LeaseServer_Send_Call) Return(_a0 error) *AppService_LeaseServer_Send_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_LeaseServer_Send_Call) RunAndReturn(run func(*app.LeaseResponse) error) *AppService_LeaseServer_Send_Call { + _c.Call.Return(run) + return _c +} + +// SendHeader provides a mock function with given fields: _a0 +func (_m *AppService_LeaseServer) SendHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SendHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppService_LeaseServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader' +type AppService_LeaseServer_SendHeader_Call struct { + *mock.Call +} + +// SendHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *AppService_LeaseServer_Expecter) SendHeader(_a0 interface{}) *AppService_LeaseServer_SendHeader_Call { + return &AppService_LeaseServer_SendHeader_Call{Call: _e.mock.On("SendHeader", _a0)} +} + +func (_c *AppService_LeaseServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *AppService_LeaseServer_SendHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *AppService_LeaseServer_SendHeader_Call) Return(_a0 error) *AppService_LeaseServer_SendHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_LeaseServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *AppService_LeaseServer_SendHeader_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *AppService_LeaseServer) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppService_LeaseServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type AppService_LeaseServer_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *AppService_LeaseServer_Expecter) SendMsg(m interface{}) *AppService_LeaseServer_SendMsg_Call { + return &AppService_LeaseServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *AppService_LeaseServer_SendMsg_Call) Run(run func(m any)) *AppService_LeaseServer_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *AppService_LeaseServer_SendMsg_Call) Return(_a0 error) *AppService_LeaseServer_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_LeaseServer_SendMsg_Call) RunAndReturn(run func(any) error) *AppService_LeaseServer_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// SetHeader provides a mock function with given fields: _a0 +func (_m *AppService_LeaseServer) SetHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SetHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppService_LeaseServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader' +type AppService_LeaseServer_SetHeader_Call struct { + *mock.Call +} + +// SetHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *AppService_LeaseServer_Expecter) SetHeader(_a0 interface{}) *AppService_LeaseServer_SetHeader_Call { + return &AppService_LeaseServer_SetHeader_Call{Call: _e.mock.On("SetHeader", _a0)} +} + +func (_c *AppService_LeaseServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *AppService_LeaseServer_SetHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *AppService_LeaseServer_SetHeader_Call) Return(_a0 error) *AppService_LeaseServer_SetHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_LeaseServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *AppService_LeaseServer_SetHeader_Call { + _c.Call.Return(run) + return _c +} + +// SetTrailer provides a mock function with given fields: _a0 +func (_m *AppService_LeaseServer) SetTrailer(_a0 metadata.MD) { + _m.Called(_a0) +} + +// AppService_LeaseServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer' +type AppService_LeaseServer_SetTrailer_Call struct { + *mock.Call +} + +// SetTrailer is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *AppService_LeaseServer_Expecter) SetTrailer(_a0 interface{}) *AppService_LeaseServer_SetTrailer_Call { + return &AppService_LeaseServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", _a0)} +} + +func (_c *AppService_LeaseServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *AppService_LeaseServer_SetTrailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *AppService_LeaseServer_SetTrailer_Call) Return() *AppService_LeaseServer_SetTrailer_Call { + _c.Call.Return() + return _c +} + +func (_c *AppService_LeaseServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *AppService_LeaseServer_SetTrailer_Call { + _c.Run(run) + return _c +} + +// NewAppService_LeaseServer creates a new instance of AppService_LeaseServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAppService_LeaseServer(t interface { + mock.TestingT + Cleanup(func()) +}) *AppService_LeaseServer { + mock := &AppService_LeaseServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/app_service_server.go b/gen/go/flyteidl2/app/mocks/app_service_server.go new file mode 100644 index 0000000000..21dce0514f --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/app_service_server.go @@ -0,0 +1,486 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + app "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app" + + mock "github.com/stretchr/testify/mock" +) + +// AppServiceServer is an autogenerated mock type for the AppServiceServer type +type AppServiceServer struct { + mock.Mock +} + +type AppServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *AppServiceServer) EXPECT() *AppServiceServer_Expecter { + return &AppServiceServer_Expecter{mock: &_m.Mock} +} + +// Create provides a mock function with given fields: _a0, _a1 +func (_m *AppServiceServer) Create(_a0 context.Context, _a1 *app.CreateRequest) (*app.CreateResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for Create") + } + + var r0 *app.CreateResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *app.CreateRequest) (*app.CreateResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *app.CreateRequest) *app.CreateResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*app.CreateResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *app.CreateRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppServiceServer_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create' +type AppServiceServer_Create_Call struct { + *mock.Call +} + +// Create is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *app.CreateRequest +func (_e *AppServiceServer_Expecter) Create(_a0 interface{}, _a1 interface{}) *AppServiceServer_Create_Call { + return &AppServiceServer_Create_Call{Call: _e.mock.On("Create", _a0, _a1)} +} + +func (_c *AppServiceServer_Create_Call) Run(run func(_a0 context.Context, _a1 *app.CreateRequest)) *AppServiceServer_Create_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*app.CreateRequest)) + }) + return _c +} + +func (_c *AppServiceServer_Create_Call) Return(_a0 *app.CreateResponse, _a1 error) *AppServiceServer_Create_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppServiceServer_Create_Call) RunAndReturn(run func(context.Context, *app.CreateRequest) (*app.CreateResponse, error)) *AppServiceServer_Create_Call { + _c.Call.Return(run) + return _c +} + +// Delete provides a mock function with given fields: _a0, _a1 +func (_m *AppServiceServer) Delete(_a0 context.Context, _a1 *app.DeleteRequest) (*app.DeleteResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for Delete") + } + + var r0 *app.DeleteResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *app.DeleteRequest) (*app.DeleteResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *app.DeleteRequest) *app.DeleteResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*app.DeleteResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *app.DeleteRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppServiceServer_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type AppServiceServer_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *app.DeleteRequest +func (_e *AppServiceServer_Expecter) Delete(_a0 interface{}, _a1 interface{}) *AppServiceServer_Delete_Call { + return &AppServiceServer_Delete_Call{Call: _e.mock.On("Delete", _a0, _a1)} +} + +func (_c *AppServiceServer_Delete_Call) Run(run func(_a0 context.Context, _a1 *app.DeleteRequest)) *AppServiceServer_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*app.DeleteRequest)) + }) + return _c +} + +func (_c *AppServiceServer_Delete_Call) Return(_a0 *app.DeleteResponse, _a1 error) *AppServiceServer_Delete_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppServiceServer_Delete_Call) RunAndReturn(run func(context.Context, *app.DeleteRequest) (*app.DeleteResponse, error)) *AppServiceServer_Delete_Call { + _c.Call.Return(run) + return _c +} + +// Get provides a mock function with given fields: _a0, _a1 +func (_m *AppServiceServer) Get(_a0 context.Context, _a1 *app.GetRequest) (*app.GetResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 *app.GetResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *app.GetRequest) (*app.GetResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *app.GetRequest) *app.GetResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*app.GetResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *app.GetRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppServiceServer_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type AppServiceServer_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *app.GetRequest +func (_e *AppServiceServer_Expecter) Get(_a0 interface{}, _a1 interface{}) *AppServiceServer_Get_Call { + return &AppServiceServer_Get_Call{Call: _e.mock.On("Get", _a0, _a1)} +} + +func (_c *AppServiceServer_Get_Call) Run(run func(_a0 context.Context, _a1 *app.GetRequest)) *AppServiceServer_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*app.GetRequest)) + }) + return _c +} + +func (_c *AppServiceServer_Get_Call) Return(_a0 *app.GetResponse, _a1 error) *AppServiceServer_Get_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppServiceServer_Get_Call) RunAndReturn(run func(context.Context, *app.GetRequest) (*app.GetResponse, error)) *AppServiceServer_Get_Call { + _c.Call.Return(run) + return _c +} + +// Lease provides a mock function with given fields: _a0, _a1 +func (_m *AppServiceServer) Lease(_a0 *app.LeaseRequest, _a1 app.AppService_LeaseServer) error { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for Lease") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*app.LeaseRequest, app.AppService_LeaseServer) error); ok { + r0 = rf(_a0, _a1) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppServiceServer_Lease_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Lease' +type AppServiceServer_Lease_Call struct { + *mock.Call +} + +// Lease is a helper method to define mock.On call +// - _a0 *app.LeaseRequest +// - _a1 app.AppService_LeaseServer +func (_e *AppServiceServer_Expecter) Lease(_a0 interface{}, _a1 interface{}) *AppServiceServer_Lease_Call { + return &AppServiceServer_Lease_Call{Call: _e.mock.On("Lease", _a0, _a1)} +} + +func (_c *AppServiceServer_Lease_Call) Run(run func(_a0 *app.LeaseRequest, _a1 app.AppService_LeaseServer)) *AppServiceServer_Lease_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*app.LeaseRequest), args[1].(app.AppService_LeaseServer)) + }) + return _c +} + +func (_c *AppServiceServer_Lease_Call) Return(_a0 error) *AppServiceServer_Lease_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppServiceServer_Lease_Call) RunAndReturn(run func(*app.LeaseRequest, app.AppService_LeaseServer) error) *AppServiceServer_Lease_Call { + _c.Call.Return(run) + return _c +} + +// List provides a mock function with given fields: _a0, _a1 +func (_m *AppServiceServer) List(_a0 context.Context, _a1 *app.ListRequest) (*app.ListResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for List") + } + + var r0 *app.ListResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *app.ListRequest) (*app.ListResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *app.ListRequest) *app.ListResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*app.ListResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *app.ListRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppServiceServer_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List' +type AppServiceServer_List_Call struct { + *mock.Call +} + +// List is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *app.ListRequest +func (_e *AppServiceServer_Expecter) List(_a0 interface{}, _a1 interface{}) *AppServiceServer_List_Call { + return &AppServiceServer_List_Call{Call: _e.mock.On("List", _a0, _a1)} +} + +func (_c *AppServiceServer_List_Call) Run(run func(_a0 context.Context, _a1 *app.ListRequest)) *AppServiceServer_List_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*app.ListRequest)) + }) + return _c +} + +func (_c *AppServiceServer_List_Call) Return(_a0 *app.ListResponse, _a1 error) *AppServiceServer_List_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppServiceServer_List_Call) RunAndReturn(run func(context.Context, *app.ListRequest) (*app.ListResponse, error)) *AppServiceServer_List_Call { + _c.Call.Return(run) + return _c +} + +// Update provides a mock function with given fields: _a0, _a1 +func (_m *AppServiceServer) Update(_a0 context.Context, _a1 *app.UpdateRequest) (*app.UpdateResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for Update") + } + + var r0 *app.UpdateResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *app.UpdateRequest) (*app.UpdateResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *app.UpdateRequest) *app.UpdateResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*app.UpdateResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *app.UpdateRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppServiceServer_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update' +type AppServiceServer_Update_Call struct { + *mock.Call +} + +// Update is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *app.UpdateRequest +func (_e *AppServiceServer_Expecter) Update(_a0 interface{}, _a1 interface{}) *AppServiceServer_Update_Call { + return &AppServiceServer_Update_Call{Call: _e.mock.On("Update", _a0, _a1)} +} + +func (_c *AppServiceServer_Update_Call) Run(run func(_a0 context.Context, _a1 *app.UpdateRequest)) *AppServiceServer_Update_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*app.UpdateRequest)) + }) + return _c +} + +func (_c *AppServiceServer_Update_Call) Return(_a0 *app.UpdateResponse, _a1 error) *AppServiceServer_Update_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppServiceServer_Update_Call) RunAndReturn(run func(context.Context, *app.UpdateRequest) (*app.UpdateResponse, error)) *AppServiceServer_Update_Call { + _c.Call.Return(run) + return _c +} + +// UpdateStatus provides a mock function with given fields: _a0, _a1 +func (_m *AppServiceServer) UpdateStatus(_a0 context.Context, _a1 *app.UpdateStatusRequest) (*app.UpdateStatusResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for UpdateStatus") + } + + var r0 *app.UpdateStatusResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *app.UpdateStatusRequest) (*app.UpdateStatusResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *app.UpdateStatusRequest) *app.UpdateStatusResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*app.UpdateStatusResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *app.UpdateStatusRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppServiceServer_UpdateStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateStatus' +type AppServiceServer_UpdateStatus_Call struct { + *mock.Call +} + +// UpdateStatus is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *app.UpdateStatusRequest +func (_e *AppServiceServer_Expecter) UpdateStatus(_a0 interface{}, _a1 interface{}) *AppServiceServer_UpdateStatus_Call { + return &AppServiceServer_UpdateStatus_Call{Call: _e.mock.On("UpdateStatus", _a0, _a1)} +} + +func (_c *AppServiceServer_UpdateStatus_Call) Run(run func(_a0 context.Context, _a1 *app.UpdateStatusRequest)) *AppServiceServer_UpdateStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*app.UpdateStatusRequest)) + }) + return _c +} + +func (_c *AppServiceServer_UpdateStatus_Call) Return(_a0 *app.UpdateStatusResponse, _a1 error) *AppServiceServer_UpdateStatus_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppServiceServer_UpdateStatus_Call) RunAndReturn(run func(context.Context, *app.UpdateStatusRequest) (*app.UpdateStatusResponse, error)) *AppServiceServer_UpdateStatus_Call { + _c.Call.Return(run) + return _c +} + +// Watch provides a mock function with given fields: _a0, _a1 +func (_m *AppServiceServer) Watch(_a0 *app.WatchRequest, _a1 app.AppService_WatchServer) error { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for Watch") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*app.WatchRequest, app.AppService_WatchServer) error); ok { + r0 = rf(_a0, _a1) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppServiceServer_Watch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Watch' +type AppServiceServer_Watch_Call struct { + *mock.Call +} + +// Watch is a helper method to define mock.On call +// - _a0 *app.WatchRequest +// - _a1 app.AppService_WatchServer +func (_e *AppServiceServer_Expecter) Watch(_a0 interface{}, _a1 interface{}) *AppServiceServer_Watch_Call { + return &AppServiceServer_Watch_Call{Call: _e.mock.On("Watch", _a0, _a1)} +} + +func (_c *AppServiceServer_Watch_Call) Run(run func(_a0 *app.WatchRequest, _a1 app.AppService_WatchServer)) *AppServiceServer_Watch_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*app.WatchRequest), args[1].(app.AppService_WatchServer)) + }) + return _c +} + +func (_c *AppServiceServer_Watch_Call) Return(_a0 error) *AppServiceServer_Watch_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppServiceServer_Watch_Call) RunAndReturn(run func(*app.WatchRequest, app.AppService_WatchServer) error) *AppServiceServer_Watch_Call { + _c.Call.Return(run) + return _c +} + +// NewAppServiceServer creates a new instance of AppServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAppServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *AppServiceServer { + mock := &AppServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/app_service_watch_client.go b/gen/go/flyteidl2/app/mocks/app_service_watch_client.go new file mode 100644 index 0000000000..77dfe5edf1 --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/app_service_watch_client.go @@ -0,0 +1,385 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + app "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app" + + metadata "google.golang.org/grpc/metadata" + + mock "github.com/stretchr/testify/mock" +) + +// AppService_WatchClient is an autogenerated mock type for the AppService_WatchClient type +type AppService_WatchClient struct { + mock.Mock +} + +type AppService_WatchClient_Expecter struct { + mock *mock.Mock +} + +func (_m *AppService_WatchClient) EXPECT() *AppService_WatchClient_Expecter { + return &AppService_WatchClient_Expecter{mock: &_m.Mock} +} + +// CloseSend provides a mock function with no fields +func (_m *AppService_WatchClient) CloseSend() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for CloseSend") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppService_WatchClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend' +type AppService_WatchClient_CloseSend_Call struct { + *mock.Call +} + +// CloseSend is a helper method to define mock.On call +func (_e *AppService_WatchClient_Expecter) CloseSend() *AppService_WatchClient_CloseSend_Call { + return &AppService_WatchClient_CloseSend_Call{Call: _e.mock.On("CloseSend")} +} + +func (_c *AppService_WatchClient_CloseSend_Call) Run(run func()) *AppService_WatchClient_CloseSend_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AppService_WatchClient_CloseSend_Call) Return(_a0 error) *AppService_WatchClient_CloseSend_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_WatchClient_CloseSend_Call) RunAndReturn(run func() error) *AppService_WatchClient_CloseSend_Call { + _c.Call.Return(run) + return _c +} + +// Context provides a mock function with no fields +func (_m *AppService_WatchClient) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// AppService_WatchClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type AppService_WatchClient_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *AppService_WatchClient_Expecter) Context() *AppService_WatchClient_Context_Call { + return &AppService_WatchClient_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *AppService_WatchClient_Context_Call) Run(run func()) *AppService_WatchClient_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AppService_WatchClient_Context_Call) Return(_a0 context.Context) *AppService_WatchClient_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_WatchClient_Context_Call) RunAndReturn(run func() context.Context) *AppService_WatchClient_Context_Call { + _c.Call.Return(run) + return _c +} + +// Header provides a mock function with no fields +func (_m *AppService_WatchClient) Header() (metadata.MD, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Header") + } + + var r0 metadata.MD + var r1 error + if rf, ok := ret.Get(0).(func() (metadata.MD, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppService_WatchClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header' +type AppService_WatchClient_Header_Call struct { + *mock.Call +} + +// Header is a helper method to define mock.On call +func (_e *AppService_WatchClient_Expecter) Header() *AppService_WatchClient_Header_Call { + return &AppService_WatchClient_Header_Call{Call: _e.mock.On("Header")} +} + +func (_c *AppService_WatchClient_Header_Call) Run(run func()) *AppService_WatchClient_Header_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AppService_WatchClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *AppService_WatchClient_Header_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppService_WatchClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *AppService_WatchClient_Header_Call { + _c.Call.Return(run) + return _c +} + +// Recv provides a mock function with no fields +func (_m *AppService_WatchClient) Recv() (*app.WatchResponse, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Recv") + } + + var r0 *app.WatchResponse + var r1 error + if rf, ok := ret.Get(0).(func() (*app.WatchResponse, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() *app.WatchResponse); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*app.WatchResponse) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AppService_WatchClient_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv' +type AppService_WatchClient_Recv_Call struct { + *mock.Call +} + +// Recv is a helper method to define mock.On call +func (_e *AppService_WatchClient_Expecter) Recv() *AppService_WatchClient_Recv_Call { + return &AppService_WatchClient_Recv_Call{Call: _e.mock.On("Recv")} +} + +func (_c *AppService_WatchClient_Recv_Call) Run(run func()) *AppService_WatchClient_Recv_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AppService_WatchClient_Recv_Call) Return(_a0 *app.WatchResponse, _a1 error) *AppService_WatchClient_Recv_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AppService_WatchClient_Recv_Call) RunAndReturn(run func() (*app.WatchResponse, error)) *AppService_WatchClient_Recv_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *AppService_WatchClient) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppService_WatchClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type AppService_WatchClient_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *AppService_WatchClient_Expecter) RecvMsg(m interface{}) *AppService_WatchClient_RecvMsg_Call { + return &AppService_WatchClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *AppService_WatchClient_RecvMsg_Call) Run(run func(m any)) *AppService_WatchClient_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *AppService_WatchClient_RecvMsg_Call) Return(_a0 error) *AppService_WatchClient_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_WatchClient_RecvMsg_Call) RunAndReturn(run func(any) error) *AppService_WatchClient_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *AppService_WatchClient) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppService_WatchClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type AppService_WatchClient_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *AppService_WatchClient_Expecter) SendMsg(m interface{}) *AppService_WatchClient_SendMsg_Call { + return &AppService_WatchClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *AppService_WatchClient_SendMsg_Call) Run(run func(m any)) *AppService_WatchClient_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *AppService_WatchClient_SendMsg_Call) Return(_a0 error) *AppService_WatchClient_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_WatchClient_SendMsg_Call) RunAndReturn(run func(any) error) *AppService_WatchClient_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// Trailer provides a mock function with no fields +func (_m *AppService_WatchClient) Trailer() metadata.MD { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Trailer") + } + + var r0 metadata.MD + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + return r0 +} + +// AppService_WatchClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer' +type AppService_WatchClient_Trailer_Call struct { + *mock.Call +} + +// Trailer is a helper method to define mock.On call +func (_e *AppService_WatchClient_Expecter) Trailer() *AppService_WatchClient_Trailer_Call { + return &AppService_WatchClient_Trailer_Call{Call: _e.mock.On("Trailer")} +} + +func (_c *AppService_WatchClient_Trailer_Call) Run(run func()) *AppService_WatchClient_Trailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AppService_WatchClient_Trailer_Call) Return(_a0 metadata.MD) *AppService_WatchClient_Trailer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_WatchClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *AppService_WatchClient_Trailer_Call { + _c.Call.Return(run) + return _c +} + +// NewAppService_WatchClient creates a new instance of AppService_WatchClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAppService_WatchClient(t interface { + mock.TestingT + Cleanup(func()) +}) *AppService_WatchClient { + mock := &AppService_WatchClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/app_service_watch_server.go b/gen/go/flyteidl2/app/mocks/app_service_watch_server.go new file mode 100644 index 0000000000..768e469adc --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/app_service_watch_server.go @@ -0,0 +1,350 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + app "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app" + + metadata "google.golang.org/grpc/metadata" + + mock "github.com/stretchr/testify/mock" +) + +// AppService_WatchServer is an autogenerated mock type for the AppService_WatchServer type +type AppService_WatchServer struct { + mock.Mock +} + +type AppService_WatchServer_Expecter struct { + mock *mock.Mock +} + +func (_m *AppService_WatchServer) EXPECT() *AppService_WatchServer_Expecter { + return &AppService_WatchServer_Expecter{mock: &_m.Mock} +} + +// Context provides a mock function with no fields +func (_m *AppService_WatchServer) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// AppService_WatchServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type AppService_WatchServer_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *AppService_WatchServer_Expecter) Context() *AppService_WatchServer_Context_Call { + return &AppService_WatchServer_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *AppService_WatchServer_Context_Call) Run(run func()) *AppService_WatchServer_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AppService_WatchServer_Context_Call) Return(_a0 context.Context) *AppService_WatchServer_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_WatchServer_Context_Call) RunAndReturn(run func() context.Context) *AppService_WatchServer_Context_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *AppService_WatchServer) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppService_WatchServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type AppService_WatchServer_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *AppService_WatchServer_Expecter) RecvMsg(m interface{}) *AppService_WatchServer_RecvMsg_Call { + return &AppService_WatchServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *AppService_WatchServer_RecvMsg_Call) Run(run func(m any)) *AppService_WatchServer_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *AppService_WatchServer_RecvMsg_Call) Return(_a0 error) *AppService_WatchServer_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_WatchServer_RecvMsg_Call) RunAndReturn(run func(any) error) *AppService_WatchServer_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// Send provides a mock function with given fields: _a0 +func (_m *AppService_WatchServer) Send(_a0 *app.WatchResponse) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for Send") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*app.WatchResponse) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppService_WatchServer_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send' +type AppService_WatchServer_Send_Call struct { + *mock.Call +} + +// Send is a helper method to define mock.On call +// - _a0 *app.WatchResponse +func (_e *AppService_WatchServer_Expecter) Send(_a0 interface{}) *AppService_WatchServer_Send_Call { + return &AppService_WatchServer_Send_Call{Call: _e.mock.On("Send", _a0)} +} + +func (_c *AppService_WatchServer_Send_Call) Run(run func(_a0 *app.WatchResponse)) *AppService_WatchServer_Send_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*app.WatchResponse)) + }) + return _c +} + +func (_c *AppService_WatchServer_Send_Call) Return(_a0 error) *AppService_WatchServer_Send_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_WatchServer_Send_Call) RunAndReturn(run func(*app.WatchResponse) error) *AppService_WatchServer_Send_Call { + _c.Call.Return(run) + return _c +} + +// SendHeader provides a mock function with given fields: _a0 +func (_m *AppService_WatchServer) SendHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SendHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppService_WatchServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader' +type AppService_WatchServer_SendHeader_Call struct { + *mock.Call +} + +// SendHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *AppService_WatchServer_Expecter) SendHeader(_a0 interface{}) *AppService_WatchServer_SendHeader_Call { + return &AppService_WatchServer_SendHeader_Call{Call: _e.mock.On("SendHeader", _a0)} +} + +func (_c *AppService_WatchServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *AppService_WatchServer_SendHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *AppService_WatchServer_SendHeader_Call) Return(_a0 error) *AppService_WatchServer_SendHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_WatchServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *AppService_WatchServer_SendHeader_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *AppService_WatchServer) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppService_WatchServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type AppService_WatchServer_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *AppService_WatchServer_Expecter) SendMsg(m interface{}) *AppService_WatchServer_SendMsg_Call { + return &AppService_WatchServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *AppService_WatchServer_SendMsg_Call) Run(run func(m any)) *AppService_WatchServer_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *AppService_WatchServer_SendMsg_Call) Return(_a0 error) *AppService_WatchServer_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_WatchServer_SendMsg_Call) RunAndReturn(run func(any) error) *AppService_WatchServer_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// SetHeader provides a mock function with given fields: _a0 +func (_m *AppService_WatchServer) SetHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SetHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AppService_WatchServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader' +type AppService_WatchServer_SetHeader_Call struct { + *mock.Call +} + +// SetHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *AppService_WatchServer_Expecter) SetHeader(_a0 interface{}) *AppService_WatchServer_SetHeader_Call { + return &AppService_WatchServer_SetHeader_Call{Call: _e.mock.On("SetHeader", _a0)} +} + +func (_c *AppService_WatchServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *AppService_WatchServer_SetHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *AppService_WatchServer_SetHeader_Call) Return(_a0 error) *AppService_WatchServer_SetHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AppService_WatchServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *AppService_WatchServer_SetHeader_Call { + _c.Call.Return(run) + return _c +} + +// SetTrailer provides a mock function with given fields: _a0 +func (_m *AppService_WatchServer) SetTrailer(_a0 metadata.MD) { + _m.Called(_a0) +} + +// AppService_WatchServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer' +type AppService_WatchServer_SetTrailer_Call struct { + *mock.Call +} + +// SetTrailer is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *AppService_WatchServer_Expecter) SetTrailer(_a0 interface{}) *AppService_WatchServer_SetTrailer_Call { + return &AppService_WatchServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", _a0)} +} + +func (_c *AppService_WatchServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *AppService_WatchServer_SetTrailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *AppService_WatchServer_SetTrailer_Call) Return() *AppService_WatchServer_SetTrailer_Call { + _c.Call.Return() + return _c +} + +func (_c *AppService_WatchServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *AppService_WatchServer_SetTrailer_Call { + _c.Run(run) + return _c +} + +// NewAppService_WatchServer creates a new instance of AppService_WatchServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAppService_WatchServer(t interface { + mock.TestingT + Cleanup(func()) +}) *AppService_WatchServer { + mock := &AppService_WatchServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/is_app_wrapper_payload.go b/gen/go/flyteidl2/app/mocks/is_app_wrapper_payload.go new file mode 100644 index 0000000000..e0e89ede54 --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/is_app_wrapper_payload.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isAppWrapper_Payload is an autogenerated mock type for the isAppWrapper_Payload type +type isAppWrapper_Payload struct { + mock.Mock +} + +type isAppWrapper_Payload_Expecter struct { + mock *mock.Mock +} + +func (_m *isAppWrapper_Payload) EXPECT() *isAppWrapper_Payload_Expecter { + return &isAppWrapper_Payload_Expecter{mock: &_m.Mock} +} + +// isAppWrapper_Payload provides a mock function with no fields +func (_m *isAppWrapper_Payload) isAppWrapper_Payload() { + _m.Called() +} + +// isAppWrapper_Payload_isAppWrapper_Payload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isAppWrapper_Payload' +type isAppWrapper_Payload_isAppWrapper_Payload_Call struct { + *mock.Call +} + +// isAppWrapper_Payload is a helper method to define mock.On call +func (_e *isAppWrapper_Payload_Expecter) isAppWrapper_Payload() *isAppWrapper_Payload_isAppWrapper_Payload_Call { + return &isAppWrapper_Payload_isAppWrapper_Payload_Call{Call: _e.mock.On("isAppWrapper_Payload")} +} + +func (_c *isAppWrapper_Payload_isAppWrapper_Payload_Call) Run(run func()) *isAppWrapper_Payload_isAppWrapper_Payload_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isAppWrapper_Payload_isAppWrapper_Payload_Call) Return() *isAppWrapper_Payload_isAppWrapper_Payload_Call { + _c.Call.Return() + return _c +} + +func (_c *isAppWrapper_Payload_isAppWrapper_Payload_Call) RunAndReturn(run func()) *isAppWrapper_Payload_isAppWrapper_Payload_Call { + _c.Run(run) + return _c +} + +// newIsAppWrapper_Payload creates a new instance of isAppWrapper_Payload. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsAppWrapper_Payload(t interface { + mock.TestingT + Cleanup(func()) +}) *isAppWrapper_Payload { + mock := &isAppWrapper_Payload{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/is_get_request_identifier.go b/gen/go/flyteidl2/app/mocks/is_get_request_identifier.go new file mode 100644 index 0000000000..97d9e1f57e --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/is_get_request_identifier.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isGetRequest_Identifier is an autogenerated mock type for the isGetRequest_Identifier type +type isGetRequest_Identifier struct { + mock.Mock +} + +type isGetRequest_Identifier_Expecter struct { + mock *mock.Mock +} + +func (_m *isGetRequest_Identifier) EXPECT() *isGetRequest_Identifier_Expecter { + return &isGetRequest_Identifier_Expecter{mock: &_m.Mock} +} + +// isGetRequest_Identifier provides a mock function with no fields +func (_m *isGetRequest_Identifier) isGetRequest_Identifier() { + _m.Called() +} + +// isGetRequest_Identifier_isGetRequest_Identifier_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isGetRequest_Identifier' +type isGetRequest_Identifier_isGetRequest_Identifier_Call struct { + *mock.Call +} + +// isGetRequest_Identifier is a helper method to define mock.On call +func (_e *isGetRequest_Identifier_Expecter) isGetRequest_Identifier() *isGetRequest_Identifier_isGetRequest_Identifier_Call { + return &isGetRequest_Identifier_isGetRequest_Identifier_Call{Call: _e.mock.On("isGetRequest_Identifier")} +} + +func (_c *isGetRequest_Identifier_isGetRequest_Identifier_Call) Run(run func()) *isGetRequest_Identifier_isGetRequest_Identifier_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isGetRequest_Identifier_isGetRequest_Identifier_Call) Return() *isGetRequest_Identifier_isGetRequest_Identifier_Call { + _c.Call.Return() + return _c +} + +func (_c *isGetRequest_Identifier_isGetRequest_Identifier_Call) RunAndReturn(run func()) *isGetRequest_Identifier_isGetRequest_Identifier_Call { + _c.Run(run) + return _c +} + +// newIsGetRequest_Identifier creates a new instance of isGetRequest_Identifier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsGetRequest_Identifier(t interface { + mock.TestingT + Cleanup(func()) +}) *isGetRequest_Identifier { + mock := &isGetRequest_Identifier{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/is_input_value.go b/gen/go/flyteidl2/app/mocks/is_input_value.go new file mode 100644 index 0000000000..1b35652769 --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/is_input_value.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isInput_Value is an autogenerated mock type for the isInput_Value type +type isInput_Value struct { + mock.Mock +} + +type isInput_Value_Expecter struct { + mock *mock.Mock +} + +func (_m *isInput_Value) EXPECT() *isInput_Value_Expecter { + return &isInput_Value_Expecter{mock: &_m.Mock} +} + +// isInput_Value provides a mock function with no fields +func (_m *isInput_Value) isInput_Value() { + _m.Called() +} + +// isInput_Value_isInput_Value_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isInput_Value' +type isInput_Value_isInput_Value_Call struct { + *mock.Call +} + +// isInput_Value is a helper method to define mock.On call +func (_e *isInput_Value_Expecter) isInput_Value() *isInput_Value_isInput_Value_Call { + return &isInput_Value_isInput_Value_Call{Call: _e.mock.On("isInput_Value")} +} + +func (_c *isInput_Value_isInput_Value_Call) Run(run func()) *isInput_Value_isInput_Value_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isInput_Value_isInput_Value_Call) Return() *isInput_Value_isInput_Value_Call { + _c.Call.Return() + return _c +} + +func (_c *isInput_Value_isInput_Value_Call) RunAndReturn(run func()) *isInput_Value_isInput_Value_Call { + _c.Run(run) + return _c +} + +// newIsInput_Value creates a new instance of isInput_Value. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsInput_Value(t interface { + mock.TestingT + Cleanup(func()) +}) *isInput_Value { + mock := &isInput_Value{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/is_list_request_filter_by.go b/gen/go/flyteidl2/app/mocks/is_list_request_filter_by.go new file mode 100644 index 0000000000..e7a4338f72 --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/is_list_request_filter_by.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isListRequest_FilterBy is an autogenerated mock type for the isListRequest_FilterBy type +type isListRequest_FilterBy struct { + mock.Mock +} + +type isListRequest_FilterBy_Expecter struct { + mock *mock.Mock +} + +func (_m *isListRequest_FilterBy) EXPECT() *isListRequest_FilterBy_Expecter { + return &isListRequest_FilterBy_Expecter{mock: &_m.Mock} +} + +// isListRequest_FilterBy provides a mock function with no fields +func (_m *isListRequest_FilterBy) isListRequest_FilterBy() { + _m.Called() +} + +// isListRequest_FilterBy_isListRequest_FilterBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isListRequest_FilterBy' +type isListRequest_FilterBy_isListRequest_FilterBy_Call struct { + *mock.Call +} + +// isListRequest_FilterBy is a helper method to define mock.On call +func (_e *isListRequest_FilterBy_Expecter) isListRequest_FilterBy() *isListRequest_FilterBy_isListRequest_FilterBy_Call { + return &isListRequest_FilterBy_isListRequest_FilterBy_Call{Call: _e.mock.On("isListRequest_FilterBy")} +} + +func (_c *isListRequest_FilterBy_isListRequest_FilterBy_Call) Run(run func()) *isListRequest_FilterBy_isListRequest_FilterBy_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isListRequest_FilterBy_isListRequest_FilterBy_Call) Return() *isListRequest_FilterBy_isListRequest_FilterBy_Call { + _c.Call.Return() + return _c +} + +func (_c *isListRequest_FilterBy_isListRequest_FilterBy_Call) RunAndReturn(run func()) *isListRequest_FilterBy_isListRequest_FilterBy_Call { + _c.Run(run) + return _c +} + +// newIsListRequest_FilterBy creates a new instance of isListRequest_FilterBy. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsListRequest_FilterBy(t interface { + mock.TestingT + Cleanup(func()) +}) *isListRequest_FilterBy { + mock := &isListRequest_FilterBy{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/is_materialized_input_value.go b/gen/go/flyteidl2/app/mocks/is_materialized_input_value.go new file mode 100644 index 0000000000..d675633122 --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/is_materialized_input_value.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isMaterializedInput_Value is an autogenerated mock type for the isMaterializedInput_Value type +type isMaterializedInput_Value struct { + mock.Mock +} + +type isMaterializedInput_Value_Expecter struct { + mock *mock.Mock +} + +func (_m *isMaterializedInput_Value) EXPECT() *isMaterializedInput_Value_Expecter { + return &isMaterializedInput_Value_Expecter{mock: &_m.Mock} +} + +// isMaterializedInput_Value provides a mock function with no fields +func (_m *isMaterializedInput_Value) isMaterializedInput_Value() { + _m.Called() +} + +// isMaterializedInput_Value_isMaterializedInput_Value_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isMaterializedInput_Value' +type isMaterializedInput_Value_isMaterializedInput_Value_Call struct { + *mock.Call +} + +// isMaterializedInput_Value is a helper method to define mock.On call +func (_e *isMaterializedInput_Value_Expecter) isMaterializedInput_Value() *isMaterializedInput_Value_isMaterializedInput_Value_Call { + return &isMaterializedInput_Value_isMaterializedInput_Value_Call{Call: _e.mock.On("isMaterializedInput_Value")} +} + +func (_c *isMaterializedInput_Value_isMaterializedInput_Value_Call) Run(run func()) *isMaterializedInput_Value_isMaterializedInput_Value_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isMaterializedInput_Value_isMaterializedInput_Value_Call) Return() *isMaterializedInput_Value_isMaterializedInput_Value_Call { + _c.Call.Return() + return _c +} + +func (_c *isMaterializedInput_Value_isMaterializedInput_Value_Call) RunAndReturn(run func()) *isMaterializedInput_Value_isMaterializedInput_Value_Call { + _c.Run(run) + return _c +} + +// newIsMaterializedInput_Value creates a new instance of isMaterializedInput_Value. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsMaterializedInput_Value(t interface { + mock.TestingT + Cleanup(func()) +}) *isMaterializedInput_Value { + mock := &isMaterializedInput_Value{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/is_scaling_metric_metric.go b/gen/go/flyteidl2/app/mocks/is_scaling_metric_metric.go new file mode 100644 index 0000000000..48714d4161 --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/is_scaling_metric_metric.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isScalingMetric_Metric is an autogenerated mock type for the isScalingMetric_Metric type +type isScalingMetric_Metric struct { + mock.Mock +} + +type isScalingMetric_Metric_Expecter struct { + mock *mock.Mock +} + +func (_m *isScalingMetric_Metric) EXPECT() *isScalingMetric_Metric_Expecter { + return &isScalingMetric_Metric_Expecter{mock: &_m.Mock} +} + +// isScalingMetric_Metric provides a mock function with no fields +func (_m *isScalingMetric_Metric) isScalingMetric_Metric() { + _m.Called() +} + +// isScalingMetric_Metric_isScalingMetric_Metric_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isScalingMetric_Metric' +type isScalingMetric_Metric_isScalingMetric_Metric_Call struct { + *mock.Call +} + +// isScalingMetric_Metric is a helper method to define mock.On call +func (_e *isScalingMetric_Metric_Expecter) isScalingMetric_Metric() *isScalingMetric_Metric_isScalingMetric_Metric_Call { + return &isScalingMetric_Metric_isScalingMetric_Metric_Call{Call: _e.mock.On("isScalingMetric_Metric")} +} + +func (_c *isScalingMetric_Metric_isScalingMetric_Metric_Call) Run(run func()) *isScalingMetric_Metric_isScalingMetric_Metric_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isScalingMetric_Metric_isScalingMetric_Metric_Call) Return() *isScalingMetric_Metric_isScalingMetric_Metric_Call { + _c.Call.Return() + return _c +} + +func (_c *isScalingMetric_Metric_isScalingMetric_Metric_Call) RunAndReturn(run func()) *isScalingMetric_Metric_isScalingMetric_Metric_Call { + _c.Run(run) + return _c +} + +// newIsScalingMetric_Metric creates a new instance of isScalingMetric_Metric. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsScalingMetric_Metric(t interface { + mock.TestingT + Cleanup(func()) +}) *isScalingMetric_Metric { + mock := &isScalingMetric_Metric{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/is_spec_app_payload.go b/gen/go/flyteidl2/app/mocks/is_spec_app_payload.go new file mode 100644 index 0000000000..dc39f4caf6 --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/is_spec_app_payload.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isSpec_AppPayload is an autogenerated mock type for the isSpec_AppPayload type +type isSpec_AppPayload struct { + mock.Mock +} + +type isSpec_AppPayload_Expecter struct { + mock *mock.Mock +} + +func (_m *isSpec_AppPayload) EXPECT() *isSpec_AppPayload_Expecter { + return &isSpec_AppPayload_Expecter{mock: &_m.Mock} +} + +// isSpec_AppPayload provides a mock function with no fields +func (_m *isSpec_AppPayload) isSpec_AppPayload() { + _m.Called() +} + +// isSpec_AppPayload_isSpec_AppPayload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isSpec_AppPayload' +type isSpec_AppPayload_isSpec_AppPayload_Call struct { + *mock.Call +} + +// isSpec_AppPayload is a helper method to define mock.On call +func (_e *isSpec_AppPayload_Expecter) isSpec_AppPayload() *isSpec_AppPayload_isSpec_AppPayload_Call { + return &isSpec_AppPayload_isSpec_AppPayload_Call{Call: _e.mock.On("isSpec_AppPayload")} +} + +func (_c *isSpec_AppPayload_isSpec_AppPayload_Call) Run(run func()) *isSpec_AppPayload_isSpec_AppPayload_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isSpec_AppPayload_isSpec_AppPayload_Call) Return() *isSpec_AppPayload_isSpec_AppPayload_Call { + _c.Call.Return() + return _c +} + +func (_c *isSpec_AppPayload_isSpec_AppPayload_Call) RunAndReturn(run func()) *isSpec_AppPayload_isSpec_AppPayload_Call { + _c.Run(run) + return _c +} + +// newIsSpec_AppPayload creates a new instance of isSpec_AppPayload. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsSpec_AppPayload(t interface { + mock.TestingT + Cleanup(func()) +}) *isSpec_AppPayload { + mock := &isSpec_AppPayload{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/is_tail_logs_request_target.go b/gen/go/flyteidl2/app/mocks/is_tail_logs_request_target.go new file mode 100644 index 0000000000..df827517a4 --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/is_tail_logs_request_target.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isTailLogsRequest_Target is an autogenerated mock type for the isTailLogsRequest_Target type +type isTailLogsRequest_Target struct { + mock.Mock +} + +type isTailLogsRequest_Target_Expecter struct { + mock *mock.Mock +} + +func (_m *isTailLogsRequest_Target) EXPECT() *isTailLogsRequest_Target_Expecter { + return &isTailLogsRequest_Target_Expecter{mock: &_m.Mock} +} + +// isTailLogsRequest_Target provides a mock function with no fields +func (_m *isTailLogsRequest_Target) isTailLogsRequest_Target() { + _m.Called() +} + +// isTailLogsRequest_Target_isTailLogsRequest_Target_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isTailLogsRequest_Target' +type isTailLogsRequest_Target_isTailLogsRequest_Target_Call struct { + *mock.Call +} + +// isTailLogsRequest_Target is a helper method to define mock.On call +func (_e *isTailLogsRequest_Target_Expecter) isTailLogsRequest_Target() *isTailLogsRequest_Target_isTailLogsRequest_Target_Call { + return &isTailLogsRequest_Target_isTailLogsRequest_Target_Call{Call: _e.mock.On("isTailLogsRequest_Target")} +} + +func (_c *isTailLogsRequest_Target_isTailLogsRequest_Target_Call) Run(run func()) *isTailLogsRequest_Target_isTailLogsRequest_Target_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isTailLogsRequest_Target_isTailLogsRequest_Target_Call) Return() *isTailLogsRequest_Target_isTailLogsRequest_Target_Call { + _c.Call.Return() + return _c +} + +func (_c *isTailLogsRequest_Target_isTailLogsRequest_Target_Call) RunAndReturn(run func()) *isTailLogsRequest_Target_isTailLogsRequest_Target_Call { + _c.Run(run) + return _c +} + +// newIsTailLogsRequest_Target creates a new instance of isTailLogsRequest_Target. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsTailLogsRequest_Target(t interface { + mock.TestingT + Cleanup(func()) +}) *isTailLogsRequest_Target { + mock := &isTailLogsRequest_Target{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/is_tail_logs_response_resp.go b/gen/go/flyteidl2/app/mocks/is_tail_logs_response_resp.go new file mode 100644 index 0000000000..cfbf0a6da0 --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/is_tail_logs_response_resp.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isTailLogsResponse_Resp is an autogenerated mock type for the isTailLogsResponse_Resp type +type isTailLogsResponse_Resp struct { + mock.Mock +} + +type isTailLogsResponse_Resp_Expecter struct { + mock *mock.Mock +} + +func (_m *isTailLogsResponse_Resp) EXPECT() *isTailLogsResponse_Resp_Expecter { + return &isTailLogsResponse_Resp_Expecter{mock: &_m.Mock} +} + +// isTailLogsResponse_Resp provides a mock function with no fields +func (_m *isTailLogsResponse_Resp) isTailLogsResponse_Resp() { + _m.Called() +} + +// isTailLogsResponse_Resp_isTailLogsResponse_Resp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isTailLogsResponse_Resp' +type isTailLogsResponse_Resp_isTailLogsResponse_Resp_Call struct { + *mock.Call +} + +// isTailLogsResponse_Resp is a helper method to define mock.On call +func (_e *isTailLogsResponse_Resp_Expecter) isTailLogsResponse_Resp() *isTailLogsResponse_Resp_isTailLogsResponse_Resp_Call { + return &isTailLogsResponse_Resp_isTailLogsResponse_Resp_Call{Call: _e.mock.On("isTailLogsResponse_Resp")} +} + +func (_c *isTailLogsResponse_Resp_isTailLogsResponse_Resp_Call) Run(run func()) *isTailLogsResponse_Resp_isTailLogsResponse_Resp_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isTailLogsResponse_Resp_isTailLogsResponse_Resp_Call) Return() *isTailLogsResponse_Resp_isTailLogsResponse_Resp_Call { + _c.Call.Return() + return _c +} + +func (_c *isTailLogsResponse_Resp_isTailLogsResponse_Resp_Call) RunAndReturn(run func()) *isTailLogsResponse_Resp_isTailLogsResponse_Resp_Call { + _c.Run(run) + return _c +} + +// newIsTailLogsResponse_Resp creates a new instance of isTailLogsResponse_Resp. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsTailLogsResponse_Resp(t interface { + mock.TestingT + Cleanup(func()) +}) *isTailLogsResponse_Resp { + mock := &isTailLogsResponse_Resp{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/is_watch_request_target.go b/gen/go/flyteidl2/app/mocks/is_watch_request_target.go new file mode 100644 index 0000000000..3fe6583429 --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/is_watch_request_target.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isWatchRequest_Target is an autogenerated mock type for the isWatchRequest_Target type +type isWatchRequest_Target struct { + mock.Mock +} + +type isWatchRequest_Target_Expecter struct { + mock *mock.Mock +} + +func (_m *isWatchRequest_Target) EXPECT() *isWatchRequest_Target_Expecter { + return &isWatchRequest_Target_Expecter{mock: &_m.Mock} +} + +// isWatchRequest_Target provides a mock function with no fields +func (_m *isWatchRequest_Target) isWatchRequest_Target() { + _m.Called() +} + +// isWatchRequest_Target_isWatchRequest_Target_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isWatchRequest_Target' +type isWatchRequest_Target_isWatchRequest_Target_Call struct { + *mock.Call +} + +// isWatchRequest_Target is a helper method to define mock.On call +func (_e *isWatchRequest_Target_Expecter) isWatchRequest_Target() *isWatchRequest_Target_isWatchRequest_Target_Call { + return &isWatchRequest_Target_isWatchRequest_Target_Call{Call: _e.mock.On("isWatchRequest_Target")} +} + +func (_c *isWatchRequest_Target_isWatchRequest_Target_Call) Run(run func()) *isWatchRequest_Target_isWatchRequest_Target_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isWatchRequest_Target_isWatchRequest_Target_Call) Return() *isWatchRequest_Target_isWatchRequest_Target_Call { + _c.Call.Return() + return _c +} + +func (_c *isWatchRequest_Target_isWatchRequest_Target_Call) RunAndReturn(run func()) *isWatchRequest_Target_isWatchRequest_Target_Call { + _c.Run(run) + return _c +} + +// newIsWatchRequest_Target creates a new instance of isWatchRequest_Target. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsWatchRequest_Target(t interface { + mock.TestingT + Cleanup(func()) +}) *isWatchRequest_Target { + mock := &isWatchRequest_Target{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/is_watch_response_event.go b/gen/go/flyteidl2/app/mocks/is_watch_response_event.go new file mode 100644 index 0000000000..42e896092b --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/is_watch_response_event.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isWatchResponse_Event is an autogenerated mock type for the isWatchResponse_Event type +type isWatchResponse_Event struct { + mock.Mock +} + +type isWatchResponse_Event_Expecter struct { + mock *mock.Mock +} + +func (_m *isWatchResponse_Event) EXPECT() *isWatchResponse_Event_Expecter { + return &isWatchResponse_Event_Expecter{mock: &_m.Mock} +} + +// isWatchResponse_Event provides a mock function with no fields +func (_m *isWatchResponse_Event) isWatchResponse_Event() { + _m.Called() +} + +// isWatchResponse_Event_isWatchResponse_Event_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isWatchResponse_Event' +type isWatchResponse_Event_isWatchResponse_Event_Call struct { + *mock.Call +} + +// isWatchResponse_Event is a helper method to define mock.On call +func (_e *isWatchResponse_Event_Expecter) isWatchResponse_Event() *isWatchResponse_Event_isWatchResponse_Event_Call { + return &isWatchResponse_Event_isWatchResponse_Event_Call{Call: _e.mock.On("isWatchResponse_Event")} +} + +func (_c *isWatchResponse_Event_isWatchResponse_Event_Call) Run(run func()) *isWatchResponse_Event_isWatchResponse_Event_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isWatchResponse_Event_isWatchResponse_Event_Call) Return() *isWatchResponse_Event_isWatchResponse_Event_Call { + _c.Call.Return() + return _c +} + +func (_c *isWatchResponse_Event_isWatchResponse_Event_Call) RunAndReturn(run func()) *isWatchResponse_Event_isWatchResponse_Event_Call { + _c.Run(run) + return _c +} + +// newIsWatchResponse_Event creates a new instance of isWatchResponse_Event. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsWatchResponse_Event(t interface { + mock.TestingT + Cleanup(func()) +}) *isWatchResponse_Event { + mock := &isWatchResponse_Event{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/unsafe_app_logs_service_server.go b/gen/go/flyteidl2/app/mocks/unsafe_app_logs_service_server.go new file mode 100644 index 0000000000..a4411d1a3f --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/unsafe_app_logs_service_server.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// UnsafeAppLogsServiceServer is an autogenerated mock type for the UnsafeAppLogsServiceServer type +type UnsafeAppLogsServiceServer struct { + mock.Mock +} + +type UnsafeAppLogsServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *UnsafeAppLogsServiceServer) EXPECT() *UnsafeAppLogsServiceServer_Expecter { + return &UnsafeAppLogsServiceServer_Expecter{mock: &_m.Mock} +} + +// mustEmbedUnimplementedAppLogsServiceServer provides a mock function with no fields +func (_m *UnsafeAppLogsServiceServer) mustEmbedUnimplementedAppLogsServiceServer() { + _m.Called() +} + +// UnsafeAppLogsServiceServer_mustEmbedUnimplementedAppLogsServiceServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'mustEmbedUnimplementedAppLogsServiceServer' +type UnsafeAppLogsServiceServer_mustEmbedUnimplementedAppLogsServiceServer_Call struct { + *mock.Call +} + +// mustEmbedUnimplementedAppLogsServiceServer is a helper method to define mock.On call +func (_e *UnsafeAppLogsServiceServer_Expecter) mustEmbedUnimplementedAppLogsServiceServer() *UnsafeAppLogsServiceServer_mustEmbedUnimplementedAppLogsServiceServer_Call { + return &UnsafeAppLogsServiceServer_mustEmbedUnimplementedAppLogsServiceServer_Call{Call: _e.mock.On("mustEmbedUnimplementedAppLogsServiceServer")} +} + +func (_c *UnsafeAppLogsServiceServer_mustEmbedUnimplementedAppLogsServiceServer_Call) Run(run func()) *UnsafeAppLogsServiceServer_mustEmbedUnimplementedAppLogsServiceServer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UnsafeAppLogsServiceServer_mustEmbedUnimplementedAppLogsServiceServer_Call) Return() *UnsafeAppLogsServiceServer_mustEmbedUnimplementedAppLogsServiceServer_Call { + _c.Call.Return() + return _c +} + +func (_c *UnsafeAppLogsServiceServer_mustEmbedUnimplementedAppLogsServiceServer_Call) RunAndReturn(run func()) *UnsafeAppLogsServiceServer_mustEmbedUnimplementedAppLogsServiceServer_Call { + _c.Run(run) + return _c +} + +// NewUnsafeAppLogsServiceServer creates a new instance of UnsafeAppLogsServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewUnsafeAppLogsServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *UnsafeAppLogsServiceServer { + mock := &UnsafeAppLogsServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/mocks/unsafe_app_service_server.go b/gen/go/flyteidl2/app/mocks/unsafe_app_service_server.go new file mode 100644 index 0000000000..032cb44f87 --- /dev/null +++ b/gen/go/flyteidl2/app/mocks/unsafe_app_service_server.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// UnsafeAppServiceServer is an autogenerated mock type for the UnsafeAppServiceServer type +type UnsafeAppServiceServer struct { + mock.Mock +} + +type UnsafeAppServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *UnsafeAppServiceServer) EXPECT() *UnsafeAppServiceServer_Expecter { + return &UnsafeAppServiceServer_Expecter{mock: &_m.Mock} +} + +// mustEmbedUnimplementedAppServiceServer provides a mock function with no fields +func (_m *UnsafeAppServiceServer) mustEmbedUnimplementedAppServiceServer() { + _m.Called() +} + +// UnsafeAppServiceServer_mustEmbedUnimplementedAppServiceServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'mustEmbedUnimplementedAppServiceServer' +type UnsafeAppServiceServer_mustEmbedUnimplementedAppServiceServer_Call struct { + *mock.Call +} + +// mustEmbedUnimplementedAppServiceServer is a helper method to define mock.On call +func (_e *UnsafeAppServiceServer_Expecter) mustEmbedUnimplementedAppServiceServer() *UnsafeAppServiceServer_mustEmbedUnimplementedAppServiceServer_Call { + return &UnsafeAppServiceServer_mustEmbedUnimplementedAppServiceServer_Call{Call: _e.mock.On("mustEmbedUnimplementedAppServiceServer")} +} + +func (_c *UnsafeAppServiceServer_mustEmbedUnimplementedAppServiceServer_Call) Run(run func()) *UnsafeAppServiceServer_mustEmbedUnimplementedAppServiceServer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UnsafeAppServiceServer_mustEmbedUnimplementedAppServiceServer_Call) Return() *UnsafeAppServiceServer_mustEmbedUnimplementedAppServiceServer_Call { + _c.Call.Return() + return _c +} + +func (_c *UnsafeAppServiceServer_mustEmbedUnimplementedAppServiceServer_Call) RunAndReturn(run func()) *UnsafeAppServiceServer_mustEmbedUnimplementedAppServiceServer_Call { + _c.Run(run) + return _c +} + +// NewUnsafeAppServiceServer creates a new instance of UnsafeAppServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewUnsafeAppServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *UnsafeAppServiceServer { + mock := &UnsafeAppServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/app/replica_definition.pb.go b/gen/go/flyteidl2/app/replica_definition.pb.go new file mode 100644 index 0000000000..006c3ee665 --- /dev/null +++ b/gen/go/flyteidl2/app/replica_definition.pb.go @@ -0,0 +1,475 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/app/replica_definition.proto + +package app + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type ReplicaIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // ID of the app. + AppId *Identifier `protobuf:"bytes,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *ReplicaIdentifier) Reset() { + *x = ReplicaIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_replica_definition_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ReplicaIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReplicaIdentifier) ProtoMessage() {} + +func (x *ReplicaIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_replica_definition_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReplicaIdentifier.ProtoReflect.Descriptor instead. +func (*ReplicaIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_replica_definition_proto_rawDescGZIP(), []int{0} +} + +func (x *ReplicaIdentifier) GetAppId() *Identifier { + if x != nil { + return x.AppId + } + return nil +} + +func (x *ReplicaIdentifier) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type ReplicaMeta struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // ID of the replica. + Id *ReplicaIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // Revision of the replica object. + Revision uint64 `protobuf:"varint,2,opt,name=revision,proto3" json:"revision,omitempty"` +} + +func (x *ReplicaMeta) Reset() { + *x = ReplicaMeta{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_replica_definition_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ReplicaMeta) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReplicaMeta) ProtoMessage() {} + +func (x *ReplicaMeta) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_replica_definition_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReplicaMeta.ProtoReflect.Descriptor instead. +func (*ReplicaMeta) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_replica_definition_proto_rawDescGZIP(), []int{1} +} + +func (x *ReplicaMeta) GetId() *ReplicaIdentifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *ReplicaMeta) GetRevision() uint64 { + if x != nil { + return x.Revision + } + return 0 +} + +type ReplicaList struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // List of replicas. + Items []*Replica `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` +} + +func (x *ReplicaList) Reset() { + *x = ReplicaList{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_replica_definition_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ReplicaList) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReplicaList) ProtoMessage() {} + +func (x *ReplicaList) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_replica_definition_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReplicaList.ProtoReflect.Descriptor instead. +func (*ReplicaList) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_replica_definition_proto_rawDescGZIP(), []int{2} +} + +func (x *ReplicaList) GetItems() []*Replica { + if x != nil { + return x.Items + } + return nil +} + +// Represents a replica of an app with its specification and status. +type Replica struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Metadata of the app. + Metadata *ReplicaMeta `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` + // Status of the app. + Status *ReplicaStatus `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"` +} + +func (x *Replica) Reset() { + *x = Replica{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_replica_definition_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Replica) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Replica) ProtoMessage() {} + +func (x *Replica) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_replica_definition_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Replica.ProtoReflect.Descriptor instead. +func (*Replica) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_replica_definition_proto_rawDescGZIP(), []int{3} +} + +func (x *Replica) GetMetadata() *ReplicaMeta { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *Replica) GetStatus() *ReplicaStatus { + if x != nil { + return x.Status + } + return nil +} + +// Represents the status of the replica. +type ReplicaStatus struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Current deployment status of the replica. + DeploymentStatus string `protobuf:"bytes,1,opt,name=deployment_status,json=deploymentStatus,proto3" json:"deployment_status,omitempty"` + Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"` +} + +func (x *ReplicaStatus) Reset() { + *x = ReplicaStatus{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_app_replica_definition_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ReplicaStatus) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReplicaStatus) ProtoMessage() {} + +func (x *ReplicaStatus) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_app_replica_definition_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReplicaStatus.ProtoReflect.Descriptor instead. +func (*ReplicaStatus) Descriptor() ([]byte, []int) { + return file_flyteidl2_app_replica_definition_proto_rawDescGZIP(), []int{4} +} + +func (x *ReplicaStatus) GetDeploymentStatus() string { + if x != nil { + return x.DeploymentStatus + } + return "" +} + +func (x *ReplicaStatus) GetReason() string { + if x != nil { + return x.Reason + } + return "" +} + +var File_flyteidl2_app_replica_definition_proto protoreflect.FileDescriptor + +var file_flyteidl2_app_replica_definition_proto_rawDesc = []byte{ + 0x0a, 0x26, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, + 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x22, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x61, 0x70, 0x70, 0x2f, 0x61, 0x70, 0x70, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x6a, 0x0a, 0x11, 0x52, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x38, 0x0a, + 0x06, 0x61, 0x70, 0x70, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, + 0x52, 0x05, 0x61, 0x70, 0x70, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x63, 0x0a, 0x0b, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x4d, + 0x65, 0x74, 0x61, 0x12, 0x38, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, + 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1a, 0x0a, + 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, + 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x3b, 0x0a, 0x0b, 0x52, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x2c, 0x0a, 0x05, 0x69, 0x74, 0x65, 0x6d, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x52, + 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x7f, 0x0a, 0x07, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x12, 0x3e, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x61, 0x70, 0x70, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x4d, 0x65, 0x74, 0x61, 0x42, + 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x12, 0x34, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, + 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x54, 0x0a, 0x0d, 0x52, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x64, 0x65, 0x70, 0x6c, + 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x10, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x42, 0xb5, 0x01, + 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x61, 0x70, 0x70, 0x42, 0x16, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x44, 0x65, 0x66, 0x69, + 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, + 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, + 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, + 0x70, 0x70, 0xa2, 0x02, 0x03, 0x46, 0x41, 0x58, 0xaa, 0x02, 0x0d, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x41, 0x70, 0x70, 0xca, 0x02, 0x0d, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, 0xe2, 0x02, 0x19, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x3a, 0x3a, 0x41, 0x70, 0x70, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_app_replica_definition_proto_rawDescOnce sync.Once + file_flyteidl2_app_replica_definition_proto_rawDescData = file_flyteidl2_app_replica_definition_proto_rawDesc +) + +func file_flyteidl2_app_replica_definition_proto_rawDescGZIP() []byte { + file_flyteidl2_app_replica_definition_proto_rawDescOnce.Do(func() { + file_flyteidl2_app_replica_definition_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_app_replica_definition_proto_rawDescData) + }) + return file_flyteidl2_app_replica_definition_proto_rawDescData +} + +var file_flyteidl2_app_replica_definition_proto_msgTypes = make([]protoimpl.MessageInfo, 5) +var file_flyteidl2_app_replica_definition_proto_goTypes = []interface{}{ + (*ReplicaIdentifier)(nil), // 0: flyteidl2.app.ReplicaIdentifier + (*ReplicaMeta)(nil), // 1: flyteidl2.app.ReplicaMeta + (*ReplicaList)(nil), // 2: flyteidl2.app.ReplicaList + (*Replica)(nil), // 3: flyteidl2.app.Replica + (*ReplicaStatus)(nil), // 4: flyteidl2.app.ReplicaStatus + (*Identifier)(nil), // 5: flyteidl2.app.Identifier +} +var file_flyteidl2_app_replica_definition_proto_depIdxs = []int32{ + 5, // 0: flyteidl2.app.ReplicaIdentifier.app_id:type_name -> flyteidl2.app.Identifier + 0, // 1: flyteidl2.app.ReplicaMeta.id:type_name -> flyteidl2.app.ReplicaIdentifier + 3, // 2: flyteidl2.app.ReplicaList.items:type_name -> flyteidl2.app.Replica + 1, // 3: flyteidl2.app.Replica.metadata:type_name -> flyteidl2.app.ReplicaMeta + 4, // 4: flyteidl2.app.Replica.status:type_name -> flyteidl2.app.ReplicaStatus + 5, // [5:5] is the sub-list for method output_type + 5, // [5:5] is the sub-list for method input_type + 5, // [5:5] is the sub-list for extension type_name + 5, // [5:5] is the sub-list for extension extendee + 0, // [0:5] is the sub-list for field type_name +} + +func init() { file_flyteidl2_app_replica_definition_proto_init() } +func file_flyteidl2_app_replica_definition_proto_init() { + if File_flyteidl2_app_replica_definition_proto != nil { + return + } + file_flyteidl2_app_app_definition_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_app_replica_definition_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ReplicaIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_replica_definition_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ReplicaMeta); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_replica_definition_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ReplicaList); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_replica_definition_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Replica); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_app_replica_definition_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ReplicaStatus); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_app_replica_definition_proto_rawDesc, + NumEnums: 0, + NumMessages: 5, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_app_replica_definition_proto_goTypes, + DependencyIndexes: file_flyteidl2_app_replica_definition_proto_depIdxs, + MessageInfos: file_flyteidl2_app_replica_definition_proto_msgTypes, + }.Build() + File_flyteidl2_app_replica_definition_proto = out.File + file_flyteidl2_app_replica_definition_proto_rawDesc = nil + file_flyteidl2_app_replica_definition_proto_goTypes = nil + file_flyteidl2_app_replica_definition_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/app/replica_definition.pb.validate.go b/gen/go/flyteidl2/app/replica_definition.pb.validate.go new file mode 100644 index 0000000000..197b0c4a06 --- /dev/null +++ b/gen/go/flyteidl2/app/replica_definition.pb.validate.go @@ -0,0 +1,692 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/app/replica_definition.proto + +package app + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on ReplicaIdentifier with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *ReplicaIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ReplicaIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ReplicaIdentifierMultiError, or nil if none found. +func (m *ReplicaIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *ReplicaIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetAppId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ReplicaIdentifierValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ReplicaIdentifierValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAppId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ReplicaIdentifierValidationError{ + field: "AppId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Name + + if len(errors) > 0 { + return ReplicaIdentifierMultiError(errors) + } + + return nil +} + +// ReplicaIdentifierMultiError is an error wrapping multiple validation errors +// returned by ReplicaIdentifier.ValidateAll() if the designated constraints +// aren't met. +type ReplicaIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ReplicaIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ReplicaIdentifierMultiError) AllErrors() []error { return m } + +// ReplicaIdentifierValidationError is the validation error returned by +// ReplicaIdentifier.Validate if the designated constraints aren't met. +type ReplicaIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ReplicaIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ReplicaIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ReplicaIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ReplicaIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ReplicaIdentifierValidationError) ErrorName() string { + return "ReplicaIdentifierValidationError" +} + +// Error satisfies the builtin error interface +func (e ReplicaIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sReplicaIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ReplicaIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ReplicaIdentifierValidationError{} + +// Validate checks the field values on ReplicaMeta with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ReplicaMeta) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ReplicaMeta with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ReplicaMetaMultiError, or +// nil if none found. +func (m *ReplicaMeta) ValidateAll() error { + return m.validate(true) +} + +func (m *ReplicaMeta) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ReplicaMetaValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ReplicaMetaValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ReplicaMetaValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Revision + + if len(errors) > 0 { + return ReplicaMetaMultiError(errors) + } + + return nil +} + +// ReplicaMetaMultiError is an error wrapping multiple validation errors +// returned by ReplicaMeta.ValidateAll() if the designated constraints aren't met. +type ReplicaMetaMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ReplicaMetaMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ReplicaMetaMultiError) AllErrors() []error { return m } + +// ReplicaMetaValidationError is the validation error returned by +// ReplicaMeta.Validate if the designated constraints aren't met. +type ReplicaMetaValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ReplicaMetaValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ReplicaMetaValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ReplicaMetaValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ReplicaMetaValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ReplicaMetaValidationError) ErrorName() string { return "ReplicaMetaValidationError" } + +// Error satisfies the builtin error interface +func (e ReplicaMetaValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sReplicaMeta.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ReplicaMetaValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ReplicaMetaValidationError{} + +// Validate checks the field values on ReplicaList with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ReplicaList) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ReplicaList with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ReplicaListMultiError, or +// nil if none found. +func (m *ReplicaList) ValidateAll() error { + return m.validate(true) +} + +func (m *ReplicaList) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetItems() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ReplicaListValidationError{ + field: fmt.Sprintf("Items[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ReplicaListValidationError{ + field: fmt.Sprintf("Items[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ReplicaListValidationError{ + field: fmt.Sprintf("Items[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return ReplicaListMultiError(errors) + } + + return nil +} + +// ReplicaListMultiError is an error wrapping multiple validation errors +// returned by ReplicaList.ValidateAll() if the designated constraints aren't met. +type ReplicaListMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ReplicaListMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ReplicaListMultiError) AllErrors() []error { return m } + +// ReplicaListValidationError is the validation error returned by +// ReplicaList.Validate if the designated constraints aren't met. +type ReplicaListValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ReplicaListValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ReplicaListValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ReplicaListValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ReplicaListValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ReplicaListValidationError) ErrorName() string { return "ReplicaListValidationError" } + +// Error satisfies the builtin error interface +func (e ReplicaListValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sReplicaList.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ReplicaListValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ReplicaListValidationError{} + +// Validate checks the field values on Replica with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Replica) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Replica with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in ReplicaMultiError, or nil if none found. +func (m *Replica) ValidateAll() error { + return m.validate(true) +} + +func (m *Replica) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ReplicaValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ReplicaValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ReplicaValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetStatus()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ReplicaValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ReplicaValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStatus()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ReplicaValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ReplicaMultiError(errors) + } + + return nil +} + +// ReplicaMultiError is an error wrapping multiple validation errors returned +// by Replica.ValidateAll() if the designated constraints aren't met. +type ReplicaMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ReplicaMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ReplicaMultiError) AllErrors() []error { return m } + +// ReplicaValidationError is the validation error returned by Replica.Validate +// if the designated constraints aren't met. +type ReplicaValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ReplicaValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ReplicaValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ReplicaValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ReplicaValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ReplicaValidationError) ErrorName() string { return "ReplicaValidationError" } + +// Error satisfies the builtin error interface +func (e ReplicaValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sReplica.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ReplicaValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ReplicaValidationError{} + +// Validate checks the field values on ReplicaStatus with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ReplicaStatus) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ReplicaStatus with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ReplicaStatusMultiError, or +// nil if none found. +func (m *ReplicaStatus) ValidateAll() error { + return m.validate(true) +} + +func (m *ReplicaStatus) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for DeploymentStatus + + // no validation rules for Reason + + if len(errors) > 0 { + return ReplicaStatusMultiError(errors) + } + + return nil +} + +// ReplicaStatusMultiError is an error wrapping multiple validation errors +// returned by ReplicaStatus.ValidateAll() if the designated constraints +// aren't met. +type ReplicaStatusMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ReplicaStatusMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ReplicaStatusMultiError) AllErrors() []error { return m } + +// ReplicaStatusValidationError is the validation error returned by +// ReplicaStatus.Validate if the designated constraints aren't met. +type ReplicaStatusValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ReplicaStatusValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ReplicaStatusValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ReplicaStatusValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ReplicaStatusValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ReplicaStatusValidationError) ErrorName() string { return "ReplicaStatusValidationError" } + +// Error satisfies the builtin error interface +func (e ReplicaStatusValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sReplicaStatus.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ReplicaStatusValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ReplicaStatusValidationError{} diff --git a/gen/go/flyteidl2/auth/auth_service.pb.go b/gen/go/flyteidl2/auth/auth_service.pb.go new file mode 100644 index 0000000000..f52407c9c6 --- /dev/null +++ b/gen/go/flyteidl2/auth/auth_service.pb.go @@ -0,0 +1,526 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/auth/auth_service.proto + +package auth + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type GetOAuth2MetadataRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *GetOAuth2MetadataRequest) Reset() { + *x = GetOAuth2MetadataRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_auth_auth_service_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOAuth2MetadataRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOAuth2MetadataRequest) ProtoMessage() {} + +func (x *GetOAuth2MetadataRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_auth_auth_service_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetOAuth2MetadataRequest.ProtoReflect.Descriptor instead. +func (*GetOAuth2MetadataRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_auth_auth_service_proto_rawDescGZIP(), []int{0} +} + +// OAuth2MetadataResponse defines an RFC-Compliant response for /.well-known/oauth-authorization-server metadata +// as defined in https://tools.ietf.org/html/rfc8414 +type GetOAuth2MetadataResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Defines the issuer string in all JWT tokens this server issues. The issuer can be admin itself or an external + // issuer. + Issuer string `protobuf:"bytes,1,opt,name=issuer,proto3" json:"issuer,omitempty"` + // URL of the authorization server's authorization endpoint [RFC6749]. This is REQUIRED unless no grant types are + // supported that use the authorization endpoint. + AuthorizationEndpoint string `protobuf:"bytes,2,opt,name=authorization_endpoint,json=authorizationEndpoint,proto3" json:"authorization_endpoint,omitempty"` + // URL of the authorization server's token endpoint [RFC6749]. + TokenEndpoint string `protobuf:"bytes,3,opt,name=token_endpoint,json=tokenEndpoint,proto3" json:"token_endpoint,omitempty"` + // Array containing a list of the OAuth 2.0 response_type values that this authorization server supports. + ResponseTypesSupported []string `protobuf:"bytes,4,rep,name=response_types_supported,json=responseTypesSupported,proto3" json:"response_types_supported,omitempty"` + // JSON array containing a list of the OAuth 2.0 [RFC6749] scope values that this authorization server supports. + ScopesSupported []string `protobuf:"bytes,5,rep,name=scopes_supported,json=scopesSupported,proto3" json:"scopes_supported,omitempty"` + // JSON array containing a list of client authentication methods supported by this token endpoint. + TokenEndpointAuthMethodsSupported []string `protobuf:"bytes,6,rep,name=token_endpoint_auth_methods_supported,json=tokenEndpointAuthMethodsSupported,proto3" json:"token_endpoint_auth_methods_supported,omitempty"` + // URL of the authorization server's JWK Set [JWK] document. The referenced document contains the signing key(s) the + // client uses to validate signatures from the authorization server. + JwksUri string `protobuf:"bytes,7,opt,name=jwks_uri,json=jwksUri,proto3" json:"jwks_uri,omitempty"` + // JSON array containing a list of Proof Key for Code Exchange (PKCE) [RFC7636] code challenge methods supported by + // this authorization server. + CodeChallengeMethodsSupported []string `protobuf:"bytes,8,rep,name=code_challenge_methods_supported,json=codeChallengeMethodsSupported,proto3" json:"code_challenge_methods_supported,omitempty"` + // JSON array containing a list of the OAuth 2.0 grant type values that this authorization server supports. + GrantTypesSupported []string `protobuf:"bytes,9,rep,name=grant_types_supported,json=grantTypesSupported,proto3" json:"grant_types_supported,omitempty"` + // URL of the authorization server's device authorization endpoint, as defined in Section 3.1 of [RFC8628] + DeviceAuthorizationEndpoint string `protobuf:"bytes,10,opt,name=device_authorization_endpoint,json=deviceAuthorizationEndpoint,proto3" json:"device_authorization_endpoint,omitempty"` +} + +func (x *GetOAuth2MetadataResponse) Reset() { + *x = GetOAuth2MetadataResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_auth_auth_service_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOAuth2MetadataResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOAuth2MetadataResponse) ProtoMessage() {} + +func (x *GetOAuth2MetadataResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_auth_auth_service_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetOAuth2MetadataResponse.ProtoReflect.Descriptor instead. +func (*GetOAuth2MetadataResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_auth_auth_service_proto_rawDescGZIP(), []int{1} +} + +func (x *GetOAuth2MetadataResponse) GetIssuer() string { + if x != nil { + return x.Issuer + } + return "" +} + +func (x *GetOAuth2MetadataResponse) GetAuthorizationEndpoint() string { + if x != nil { + return x.AuthorizationEndpoint + } + return "" +} + +func (x *GetOAuth2MetadataResponse) GetTokenEndpoint() string { + if x != nil { + return x.TokenEndpoint + } + return "" +} + +func (x *GetOAuth2MetadataResponse) GetResponseTypesSupported() []string { + if x != nil { + return x.ResponseTypesSupported + } + return nil +} + +func (x *GetOAuth2MetadataResponse) GetScopesSupported() []string { + if x != nil { + return x.ScopesSupported + } + return nil +} + +func (x *GetOAuth2MetadataResponse) GetTokenEndpointAuthMethodsSupported() []string { + if x != nil { + return x.TokenEndpointAuthMethodsSupported + } + return nil +} + +func (x *GetOAuth2MetadataResponse) GetJwksUri() string { + if x != nil { + return x.JwksUri + } + return "" +} + +func (x *GetOAuth2MetadataResponse) GetCodeChallengeMethodsSupported() []string { + if x != nil { + return x.CodeChallengeMethodsSupported + } + return nil +} + +func (x *GetOAuth2MetadataResponse) GetGrantTypesSupported() []string { + if x != nil { + return x.GrantTypesSupported + } + return nil +} + +func (x *GetOAuth2MetadataResponse) GetDeviceAuthorizationEndpoint() string { + if x != nil { + return x.DeviceAuthorizationEndpoint + } + return "" +} + +type GetPublicClientConfigRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *GetPublicClientConfigRequest) Reset() { + *x = GetPublicClientConfigRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_auth_auth_service_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetPublicClientConfigRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetPublicClientConfigRequest) ProtoMessage() {} + +func (x *GetPublicClientConfigRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_auth_auth_service_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetPublicClientConfigRequest.ProtoReflect.Descriptor instead. +func (*GetPublicClientConfigRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_auth_auth_service_proto_rawDescGZIP(), []int{2} +} + +// FlyteClientResponse encapsulates public information that flyte clients (CLIs... etc.) can use to authenticate users. +type GetPublicClientConfigResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // client_id to use when initiating OAuth2 authorization requests. + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + // redirect uri to use when initiating OAuth2 authorization requests. + RedirectUri string `protobuf:"bytes,2,opt,name=redirect_uri,json=redirectUri,proto3" json:"redirect_uri,omitempty"` + // scopes to request when initiating OAuth2 authorization requests. + Scopes []string `protobuf:"bytes,3,rep,name=scopes,proto3" json:"scopes,omitempty"` + // Authorization Header to use when passing Access Tokens to the server. If not provided, the client should use the + // default http `Authorization` header. + AuthorizationMetadataKey string `protobuf:"bytes,4,opt,name=authorization_metadata_key,json=authorizationMetadataKey,proto3" json:"authorization_metadata_key,omitempty"` + // ServiceHttpEndpoint points to the http endpoint for the backend. If empty, clients can assume the endpoint used + // to configure the gRPC connection can be used for the http one respecting the insecure flag to choose between + // SSL or no SSL connections. + ServiceHttpEndpoint string `protobuf:"bytes,5,opt,name=service_http_endpoint,json=serviceHttpEndpoint,proto3" json:"service_http_endpoint,omitempty"` + // audience to use when initiating OAuth2 authorization requests. + Audience string `protobuf:"bytes,6,opt,name=audience,proto3" json:"audience,omitempty"` +} + +func (x *GetPublicClientConfigResponse) Reset() { + *x = GetPublicClientConfigResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_auth_auth_service_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetPublicClientConfigResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetPublicClientConfigResponse) ProtoMessage() {} + +func (x *GetPublicClientConfigResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_auth_auth_service_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetPublicClientConfigResponse.ProtoReflect.Descriptor instead. +func (*GetPublicClientConfigResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_auth_auth_service_proto_rawDescGZIP(), []int{3} +} + +func (x *GetPublicClientConfigResponse) GetClientId() string { + if x != nil { + return x.ClientId + } + return "" +} + +func (x *GetPublicClientConfigResponse) GetRedirectUri() string { + if x != nil { + return x.RedirectUri + } + return "" +} + +func (x *GetPublicClientConfigResponse) GetScopes() []string { + if x != nil { + return x.Scopes + } + return nil +} + +func (x *GetPublicClientConfigResponse) GetAuthorizationMetadataKey() string { + if x != nil { + return x.AuthorizationMetadataKey + } + return "" +} + +func (x *GetPublicClientConfigResponse) GetServiceHttpEndpoint() string { + if x != nil { + return x.ServiceHttpEndpoint + } + return "" +} + +func (x *GetPublicClientConfigResponse) GetAudience() string { + if x != nil { + return x.Audience + } + return "" +} + +var File_flyteidl2_auth_auth_service_proto protoreflect.FileDescriptor + +var file_flyteidl2_auth_auth_service_proto_rawDesc = []byte{ + 0x0a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x75, 0x74, 0x68, + 0x2f, 0x61, 0x75, 0x74, 0x68, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, + 0x75, 0x74, 0x68, 0x22, 0x1a, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, + 0xa4, 0x04, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, + 0x06, 0x69, 0x73, 0x73, 0x75, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x69, + 0x73, 0x73, 0x75, 0x65, 0x72, 0x12, 0x35, 0x0a, 0x16, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, + 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x15, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x25, 0x0a, 0x0e, + 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x45, 0x6e, 0x64, 0x70, 0x6f, + 0x69, 0x6e, 0x74, 0x12, 0x38, 0x0a, 0x18, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x5f, + 0x74, 0x79, 0x70, 0x65, 0x73, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x18, + 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x16, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x54, + 0x79, 0x70, 0x65, 0x73, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x12, 0x29, 0x0a, + 0x10, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x73, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0f, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x73, 0x53, + 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x12, 0x50, 0x0a, 0x25, 0x74, 0x6f, 0x6b, 0x65, + 0x6e, 0x5f, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x5f, 0x61, 0x75, 0x74, 0x68, 0x5f, + 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x21, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x45, 0x6e, + 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x41, 0x75, 0x74, 0x68, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, + 0x73, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x6a, 0x77, + 0x6b, 0x73, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6a, 0x77, + 0x6b, 0x73, 0x55, 0x72, 0x69, 0x12, 0x47, 0x0a, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x63, 0x68, + 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x5f, + 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, + 0x1d, 0x63, 0x6f, 0x64, 0x65, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x4d, 0x65, + 0x74, 0x68, 0x6f, 0x64, 0x73, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x12, 0x32, + 0x0a, 0x15, 0x67, 0x72, 0x61, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x5f, 0x73, 0x75, + 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x18, 0x09, 0x20, 0x03, 0x28, 0x09, 0x52, 0x13, 0x67, + 0x72, 0x61, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x73, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, + 0x65, 0x64, 0x12, 0x42, 0x0a, 0x1d, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x61, 0x75, 0x74, + 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x6e, 0x64, 0x70, 0x6f, + 0x69, 0x6e, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x1b, 0x64, 0x65, 0x76, 0x69, 0x63, + 0x65, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, + 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x22, 0x1e, 0x0a, 0x1c, 0x47, 0x65, 0x74, 0x50, 0x75, 0x62, + 0x6c, 0x69, 0x63, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x85, 0x02, 0x0a, 0x1d, 0x47, 0x65, 0x74, 0x50, 0x75, + 0x62, 0x6c, 0x69, 0x63, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, + 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x72, 0x65, 0x64, + 0x69, 0x72, 0x65, 0x63, 0x74, 0x55, 0x72, 0x69, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x63, 0x6f, 0x70, + 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x73, + 0x12, 0x3c, 0x0a, 0x1a, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x18, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x4b, 0x65, 0x79, 0x12, 0x32, + 0x0a, 0x15, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x68, 0x74, 0x74, 0x70, 0x5f, 0x65, + 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x73, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x48, 0x74, 0x74, 0x70, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, + 0x6e, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x61, 0x75, 0x64, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x61, 0x75, 0x64, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x32, 0xff, + 0x01, 0x0a, 0x13, 0x41, 0x75, 0x74, 0x68, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x53, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x6d, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x4f, 0x41, 0x75, + 0x74, 0x68, 0x32, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x28, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x2e, 0x47, 0x65, 0x74, + 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x79, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, + 0x69, 0x63, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x2c, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x2e, + 0x47, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x2e, 0x47, 0x65, + 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, + 0x42, 0xb5, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x42, 0x10, 0x41, 0x75, 0x74, 0x68, 0x53, 0x65, 0x72, + 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x32, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, + 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, + 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x75, 0x74, + 0x68, 0xa2, 0x02, 0x03, 0x46, 0x41, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x41, 0x75, 0x74, 0x68, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x75, 0x74, 0x68, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x75, 0x74, 0x68, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x3a, 0x3a, 0x41, 0x75, 0x74, 0x68, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_auth_auth_service_proto_rawDescOnce sync.Once + file_flyteidl2_auth_auth_service_proto_rawDescData = file_flyteidl2_auth_auth_service_proto_rawDesc +) + +func file_flyteidl2_auth_auth_service_proto_rawDescGZIP() []byte { + file_flyteidl2_auth_auth_service_proto_rawDescOnce.Do(func() { + file_flyteidl2_auth_auth_service_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_auth_auth_service_proto_rawDescData) + }) + return file_flyteidl2_auth_auth_service_proto_rawDescData +} + +var file_flyteidl2_auth_auth_service_proto_msgTypes = make([]protoimpl.MessageInfo, 4) +var file_flyteidl2_auth_auth_service_proto_goTypes = []interface{}{ + (*GetOAuth2MetadataRequest)(nil), // 0: flyteidl2.auth.GetOAuth2MetadataRequest + (*GetOAuth2MetadataResponse)(nil), // 1: flyteidl2.auth.GetOAuth2MetadataResponse + (*GetPublicClientConfigRequest)(nil), // 2: flyteidl2.auth.GetPublicClientConfigRequest + (*GetPublicClientConfigResponse)(nil), // 3: flyteidl2.auth.GetPublicClientConfigResponse +} +var file_flyteidl2_auth_auth_service_proto_depIdxs = []int32{ + 0, // 0: flyteidl2.auth.AuthMetadataService.GetOAuth2Metadata:input_type -> flyteidl2.auth.GetOAuth2MetadataRequest + 2, // 1: flyteidl2.auth.AuthMetadataService.GetPublicClientConfig:input_type -> flyteidl2.auth.GetPublicClientConfigRequest + 1, // 2: flyteidl2.auth.AuthMetadataService.GetOAuth2Metadata:output_type -> flyteidl2.auth.GetOAuth2MetadataResponse + 3, // 3: flyteidl2.auth.AuthMetadataService.GetPublicClientConfig:output_type -> flyteidl2.auth.GetPublicClientConfigResponse + 2, // [2:4] is the sub-list for method output_type + 0, // [0:2] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_flyteidl2_auth_auth_service_proto_init() } +func file_flyteidl2_auth_auth_service_proto_init() { + if File_flyteidl2_auth_auth_service_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_auth_auth_service_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOAuth2MetadataRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_auth_auth_service_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOAuth2MetadataResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_auth_auth_service_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetPublicClientConfigRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_auth_auth_service_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetPublicClientConfigResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_auth_auth_service_proto_rawDesc, + NumEnums: 0, + NumMessages: 4, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_flyteidl2_auth_auth_service_proto_goTypes, + DependencyIndexes: file_flyteidl2_auth_auth_service_proto_depIdxs, + MessageInfos: file_flyteidl2_auth_auth_service_proto_msgTypes, + }.Build() + File_flyteidl2_auth_auth_service_proto = out.File + file_flyteidl2_auth_auth_service_proto_rawDesc = nil + file_flyteidl2_auth_auth_service_proto_goTypes = nil + file_flyteidl2_auth_auth_service_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/auth/auth_service.pb.validate.go b/gen/go/flyteidl2/auth/auth_service.pb.validate.go new file mode 100644 index 0000000000..afbbb393f5 --- /dev/null +++ b/gen/go/flyteidl2/auth/auth_service.pb.validate.go @@ -0,0 +1,466 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/auth/auth_service.proto + +package auth + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on GetOAuth2MetadataRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetOAuth2MetadataRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetOAuth2MetadataRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetOAuth2MetadataRequestMultiError, or nil if none found. +func (m *GetOAuth2MetadataRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetOAuth2MetadataRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return GetOAuth2MetadataRequestMultiError(errors) + } + + return nil +} + +// GetOAuth2MetadataRequestMultiError is an error wrapping multiple validation +// errors returned by GetOAuth2MetadataRequest.ValidateAll() if the designated +// constraints aren't met. +type GetOAuth2MetadataRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetOAuth2MetadataRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetOAuth2MetadataRequestMultiError) AllErrors() []error { return m } + +// GetOAuth2MetadataRequestValidationError is the validation error returned by +// GetOAuth2MetadataRequest.Validate if the designated constraints aren't met. +type GetOAuth2MetadataRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetOAuth2MetadataRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetOAuth2MetadataRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetOAuth2MetadataRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetOAuth2MetadataRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetOAuth2MetadataRequestValidationError) ErrorName() string { + return "GetOAuth2MetadataRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e GetOAuth2MetadataRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetOAuth2MetadataRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetOAuth2MetadataRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetOAuth2MetadataRequestValidationError{} + +// Validate checks the field values on GetOAuth2MetadataResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetOAuth2MetadataResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetOAuth2MetadataResponse with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetOAuth2MetadataResponseMultiError, or nil if none found. +func (m *GetOAuth2MetadataResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetOAuth2MetadataResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Issuer + + // no validation rules for AuthorizationEndpoint + + // no validation rules for TokenEndpoint + + // no validation rules for JwksUri + + // no validation rules for DeviceAuthorizationEndpoint + + if len(errors) > 0 { + return GetOAuth2MetadataResponseMultiError(errors) + } + + return nil +} + +// GetOAuth2MetadataResponseMultiError is an error wrapping multiple validation +// errors returned by GetOAuth2MetadataResponse.ValidateAll() if the +// designated constraints aren't met. +type GetOAuth2MetadataResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetOAuth2MetadataResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetOAuth2MetadataResponseMultiError) AllErrors() []error { return m } + +// GetOAuth2MetadataResponseValidationError is the validation error returned by +// GetOAuth2MetadataResponse.Validate if the designated constraints aren't met. +type GetOAuth2MetadataResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetOAuth2MetadataResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetOAuth2MetadataResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetOAuth2MetadataResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetOAuth2MetadataResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetOAuth2MetadataResponseValidationError) ErrorName() string { + return "GetOAuth2MetadataResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e GetOAuth2MetadataResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetOAuth2MetadataResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetOAuth2MetadataResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetOAuth2MetadataResponseValidationError{} + +// Validate checks the field values on GetPublicClientConfigRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetPublicClientConfigRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetPublicClientConfigRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetPublicClientConfigRequestMultiError, or nil if none found. +func (m *GetPublicClientConfigRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetPublicClientConfigRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return GetPublicClientConfigRequestMultiError(errors) + } + + return nil +} + +// GetPublicClientConfigRequestMultiError is an error wrapping multiple +// validation errors returned by GetPublicClientConfigRequest.ValidateAll() if +// the designated constraints aren't met. +type GetPublicClientConfigRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetPublicClientConfigRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetPublicClientConfigRequestMultiError) AllErrors() []error { return m } + +// GetPublicClientConfigRequestValidationError is the validation error returned +// by GetPublicClientConfigRequest.Validate if the designated constraints +// aren't met. +type GetPublicClientConfigRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetPublicClientConfigRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetPublicClientConfigRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetPublicClientConfigRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetPublicClientConfigRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetPublicClientConfigRequestValidationError) ErrorName() string { + return "GetPublicClientConfigRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e GetPublicClientConfigRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetPublicClientConfigRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetPublicClientConfigRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetPublicClientConfigRequestValidationError{} + +// Validate checks the field values on GetPublicClientConfigResponse with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetPublicClientConfigResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetPublicClientConfigResponse with +// the rules defined in the proto definition for this message. If any rules +// are violated, the result is a list of violation errors wrapped in +// GetPublicClientConfigResponseMultiError, or nil if none found. +func (m *GetPublicClientConfigResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetPublicClientConfigResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ClientId + + // no validation rules for RedirectUri + + // no validation rules for AuthorizationMetadataKey + + // no validation rules for ServiceHttpEndpoint + + // no validation rules for Audience + + if len(errors) > 0 { + return GetPublicClientConfigResponseMultiError(errors) + } + + return nil +} + +// GetPublicClientConfigResponseMultiError is an error wrapping multiple +// validation errors returned by GetPublicClientConfigResponse.ValidateAll() +// if the designated constraints aren't met. +type GetPublicClientConfigResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetPublicClientConfigResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetPublicClientConfigResponseMultiError) AllErrors() []error { return m } + +// GetPublicClientConfigResponseValidationError is the validation error +// returned by GetPublicClientConfigResponse.Validate if the designated +// constraints aren't met. +type GetPublicClientConfigResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetPublicClientConfigResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetPublicClientConfigResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetPublicClientConfigResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetPublicClientConfigResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetPublicClientConfigResponseValidationError) ErrorName() string { + return "GetPublicClientConfigResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e GetPublicClientConfigResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetPublicClientConfigResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetPublicClientConfigResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetPublicClientConfigResponseValidationError{} diff --git a/gen/go/flyteidl2/auth/auth_service_grpc.pb.go b/gen/go/flyteidl2/auth/auth_service_grpc.pb.go new file mode 100644 index 0000000000..13916702ef --- /dev/null +++ b/gen/go/flyteidl2/auth/auth_service_grpc.pb.go @@ -0,0 +1,150 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: flyteidl2/auth/auth_service.proto + +package auth + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + AuthMetadataService_GetOAuth2Metadata_FullMethodName = "/flyteidl2.auth.AuthMetadataService/GetOAuth2Metadata" + AuthMetadataService_GetPublicClientConfig_FullMethodName = "/flyteidl2.auth.AuthMetadataService/GetPublicClientConfig" +) + +// AuthMetadataServiceClient is the client API for AuthMetadataService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type AuthMetadataServiceClient interface { + // Anonymously accessible. Retrieves local or external oauth authorization server metadata. + GetOAuth2Metadata(ctx context.Context, in *GetOAuth2MetadataRequest, opts ...grpc.CallOption) (*GetOAuth2MetadataResponse, error) + // Anonymously accessible. Retrieves the client information clients should use when initiating OAuth2 authorization + // requests. + GetPublicClientConfig(ctx context.Context, in *GetPublicClientConfigRequest, opts ...grpc.CallOption) (*GetPublicClientConfigResponse, error) +} + +type authMetadataServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewAuthMetadataServiceClient(cc grpc.ClientConnInterface) AuthMetadataServiceClient { + return &authMetadataServiceClient{cc} +} + +func (c *authMetadataServiceClient) GetOAuth2Metadata(ctx context.Context, in *GetOAuth2MetadataRequest, opts ...grpc.CallOption) (*GetOAuth2MetadataResponse, error) { + out := new(GetOAuth2MetadataResponse) + err := c.cc.Invoke(ctx, AuthMetadataService_GetOAuth2Metadata_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authMetadataServiceClient) GetPublicClientConfig(ctx context.Context, in *GetPublicClientConfigRequest, opts ...grpc.CallOption) (*GetPublicClientConfigResponse, error) { + out := new(GetPublicClientConfigResponse) + err := c.cc.Invoke(ctx, AuthMetadataService_GetPublicClientConfig_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// AuthMetadataServiceServer is the server API for AuthMetadataService service. +// All implementations should embed UnimplementedAuthMetadataServiceServer +// for forward compatibility +type AuthMetadataServiceServer interface { + // Anonymously accessible. Retrieves local or external oauth authorization server metadata. + GetOAuth2Metadata(context.Context, *GetOAuth2MetadataRequest) (*GetOAuth2MetadataResponse, error) + // Anonymously accessible. Retrieves the client information clients should use when initiating OAuth2 authorization + // requests. + GetPublicClientConfig(context.Context, *GetPublicClientConfigRequest) (*GetPublicClientConfigResponse, error) +} + +// UnimplementedAuthMetadataServiceServer should be embedded to have forward compatible implementations. +type UnimplementedAuthMetadataServiceServer struct { +} + +func (UnimplementedAuthMetadataServiceServer) GetOAuth2Metadata(context.Context, *GetOAuth2MetadataRequest) (*GetOAuth2MetadataResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetOAuth2Metadata not implemented") +} +func (UnimplementedAuthMetadataServiceServer) GetPublicClientConfig(context.Context, *GetPublicClientConfigRequest) (*GetPublicClientConfigResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetPublicClientConfig not implemented") +} + +// UnsafeAuthMetadataServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to AuthMetadataServiceServer will +// result in compilation errors. +type UnsafeAuthMetadataServiceServer interface { + mustEmbedUnimplementedAuthMetadataServiceServer() +} + +func RegisterAuthMetadataServiceServer(s grpc.ServiceRegistrar, srv AuthMetadataServiceServer) { + s.RegisterService(&AuthMetadataService_ServiceDesc, srv) +} + +func _AuthMetadataService_GetOAuth2Metadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetOAuth2MetadataRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthMetadataServiceServer).GetOAuth2Metadata(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AuthMetadataService_GetOAuth2Metadata_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthMetadataServiceServer).GetOAuth2Metadata(ctx, req.(*GetOAuth2MetadataRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AuthMetadataService_GetPublicClientConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetPublicClientConfigRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthMetadataServiceServer).GetPublicClientConfig(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AuthMetadataService_GetPublicClientConfig_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthMetadataServiceServer).GetPublicClientConfig(ctx, req.(*GetPublicClientConfigRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// AuthMetadataService_ServiceDesc is the grpc.ServiceDesc for AuthMetadataService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var AuthMetadataService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.auth.AuthMetadataService", + HandlerType: (*AuthMetadataServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "GetOAuth2Metadata", + Handler: _AuthMetadataService_GetOAuth2Metadata_Handler, + }, + { + MethodName: "GetPublicClientConfig", + Handler: _AuthMetadataService_GetPublicClientConfig_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "flyteidl2/auth/auth_service.proto", +} diff --git a/gen/go/flyteidl2/auth/authconnect/auth_service.connect.go b/gen/go/flyteidl2/auth/authconnect/auth_service.connect.go new file mode 100644 index 0000000000..5276bb365c --- /dev/null +++ b/gen/go/flyteidl2/auth/authconnect/auth_service.connect.go @@ -0,0 +1,154 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: flyteidl2/auth/auth_service.proto + +package authconnect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + auth "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/auth" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // AuthMetadataServiceName is the fully-qualified name of the AuthMetadataService service. + AuthMetadataServiceName = "flyteidl2.auth.AuthMetadataService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // AuthMetadataServiceGetOAuth2MetadataProcedure is the fully-qualified name of the + // AuthMetadataService's GetOAuth2Metadata RPC. + AuthMetadataServiceGetOAuth2MetadataProcedure = "/flyteidl2.auth.AuthMetadataService/GetOAuth2Metadata" + // AuthMetadataServiceGetPublicClientConfigProcedure is the fully-qualified name of the + // AuthMetadataService's GetPublicClientConfig RPC. + AuthMetadataServiceGetPublicClientConfigProcedure = "/flyteidl2.auth.AuthMetadataService/GetPublicClientConfig" +) + +// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. +var ( + authMetadataServiceServiceDescriptor = auth.File_flyteidl2_auth_auth_service_proto.Services().ByName("AuthMetadataService") + authMetadataServiceGetOAuth2MetadataMethodDescriptor = authMetadataServiceServiceDescriptor.Methods().ByName("GetOAuth2Metadata") + authMetadataServiceGetPublicClientConfigMethodDescriptor = authMetadataServiceServiceDescriptor.Methods().ByName("GetPublicClientConfig") +) + +// AuthMetadataServiceClient is a client for the flyteidl2.auth.AuthMetadataService service. +type AuthMetadataServiceClient interface { + // Anonymously accessible. Retrieves local or external oauth authorization server metadata. + GetOAuth2Metadata(context.Context, *connect.Request[auth.GetOAuth2MetadataRequest]) (*connect.Response[auth.GetOAuth2MetadataResponse], error) + // Anonymously accessible. Retrieves the client information clients should use when initiating OAuth2 authorization + // requests. + GetPublicClientConfig(context.Context, *connect.Request[auth.GetPublicClientConfigRequest]) (*connect.Response[auth.GetPublicClientConfigResponse], error) +} + +// NewAuthMetadataServiceClient constructs a client for the flyteidl2.auth.AuthMetadataService +// service. By default, it uses the Connect protocol with the binary Protobuf Codec, asks for +// gzipped responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply +// the connect.WithGRPC() or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewAuthMetadataServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) AuthMetadataServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &authMetadataServiceClient{ + getOAuth2Metadata: connect.NewClient[auth.GetOAuth2MetadataRequest, auth.GetOAuth2MetadataResponse]( + httpClient, + baseURL+AuthMetadataServiceGetOAuth2MetadataProcedure, + connect.WithSchema(authMetadataServiceGetOAuth2MetadataMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + getPublicClientConfig: connect.NewClient[auth.GetPublicClientConfigRequest, auth.GetPublicClientConfigResponse]( + httpClient, + baseURL+AuthMetadataServiceGetPublicClientConfigProcedure, + connect.WithSchema(authMetadataServiceGetPublicClientConfigMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + } +} + +// authMetadataServiceClient implements AuthMetadataServiceClient. +type authMetadataServiceClient struct { + getOAuth2Metadata *connect.Client[auth.GetOAuth2MetadataRequest, auth.GetOAuth2MetadataResponse] + getPublicClientConfig *connect.Client[auth.GetPublicClientConfigRequest, auth.GetPublicClientConfigResponse] +} + +// GetOAuth2Metadata calls flyteidl2.auth.AuthMetadataService.GetOAuth2Metadata. +func (c *authMetadataServiceClient) GetOAuth2Metadata(ctx context.Context, req *connect.Request[auth.GetOAuth2MetadataRequest]) (*connect.Response[auth.GetOAuth2MetadataResponse], error) { + return c.getOAuth2Metadata.CallUnary(ctx, req) +} + +// GetPublicClientConfig calls flyteidl2.auth.AuthMetadataService.GetPublicClientConfig. +func (c *authMetadataServiceClient) GetPublicClientConfig(ctx context.Context, req *connect.Request[auth.GetPublicClientConfigRequest]) (*connect.Response[auth.GetPublicClientConfigResponse], error) { + return c.getPublicClientConfig.CallUnary(ctx, req) +} + +// AuthMetadataServiceHandler is an implementation of the flyteidl2.auth.AuthMetadataService +// service. +type AuthMetadataServiceHandler interface { + // Anonymously accessible. Retrieves local or external oauth authorization server metadata. + GetOAuth2Metadata(context.Context, *connect.Request[auth.GetOAuth2MetadataRequest]) (*connect.Response[auth.GetOAuth2MetadataResponse], error) + // Anonymously accessible. Retrieves the client information clients should use when initiating OAuth2 authorization + // requests. + GetPublicClientConfig(context.Context, *connect.Request[auth.GetPublicClientConfigRequest]) (*connect.Response[auth.GetPublicClientConfigResponse], error) +} + +// NewAuthMetadataServiceHandler builds an HTTP handler from the service implementation. It returns +// the path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewAuthMetadataServiceHandler(svc AuthMetadataServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + authMetadataServiceGetOAuth2MetadataHandler := connect.NewUnaryHandler( + AuthMetadataServiceGetOAuth2MetadataProcedure, + svc.GetOAuth2Metadata, + connect.WithSchema(authMetadataServiceGetOAuth2MetadataMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + authMetadataServiceGetPublicClientConfigHandler := connect.NewUnaryHandler( + AuthMetadataServiceGetPublicClientConfigProcedure, + svc.GetPublicClientConfig, + connect.WithSchema(authMetadataServiceGetPublicClientConfigMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.auth.AuthMetadataService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case AuthMetadataServiceGetOAuth2MetadataProcedure: + authMetadataServiceGetOAuth2MetadataHandler.ServeHTTP(w, r) + case AuthMetadataServiceGetPublicClientConfigProcedure: + authMetadataServiceGetPublicClientConfigHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedAuthMetadataServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedAuthMetadataServiceHandler struct{} + +func (UnimplementedAuthMetadataServiceHandler) GetOAuth2Metadata(context.Context, *connect.Request[auth.GetOAuth2MetadataRequest]) (*connect.Response[auth.GetOAuth2MetadataResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.auth.AuthMetadataService.GetOAuth2Metadata is not implemented")) +} + +func (UnimplementedAuthMetadataServiceHandler) GetPublicClientConfig(context.Context, *connect.Request[auth.GetPublicClientConfigRequest]) (*connect.Response[auth.GetPublicClientConfigResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.auth.AuthMetadataService.GetPublicClientConfig is not implemented")) +} diff --git a/gen/go/flyteidl2/auth/authconnect/identity.connect.go b/gen/go/flyteidl2/auth/authconnect/identity.connect.go new file mode 100644 index 0000000000..9c4b530b48 --- /dev/null +++ b/gen/go/flyteidl2/auth/authconnect/identity.connect.go @@ -0,0 +1,115 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: flyteidl2/auth/identity.proto + +package authconnect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + auth "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/auth" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // IdentityServiceName is the fully-qualified name of the IdentityService service. + IdentityServiceName = "flyteidl2.auth.IdentityService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // IdentityServiceUserInfoProcedure is the fully-qualified name of the IdentityService's UserInfo + // RPC. + IdentityServiceUserInfoProcedure = "/flyteidl2.auth.IdentityService/UserInfo" +) + +// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. +var ( + identityServiceServiceDescriptor = auth.File_flyteidl2_auth_identity_proto.Services().ByName("IdentityService") + identityServiceUserInfoMethodDescriptor = identityServiceServiceDescriptor.Methods().ByName("UserInfo") +) + +// IdentityServiceClient is a client for the flyteidl2.auth.IdentityService service. +type IdentityServiceClient interface { + // Retrieves user information about the currently logged in user. + UserInfo(context.Context, *connect.Request[auth.UserInfoRequest]) (*connect.Response[auth.UserInfoResponse], error) +} + +// NewIdentityServiceClient constructs a client for the flyteidl2.auth.IdentityService service. By +// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, +// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the +// connect.WithGRPC() or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewIdentityServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) IdentityServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &identityServiceClient{ + userInfo: connect.NewClient[auth.UserInfoRequest, auth.UserInfoResponse]( + httpClient, + baseURL+IdentityServiceUserInfoProcedure, + connect.WithSchema(identityServiceUserInfoMethodDescriptor), + connect.WithClientOptions(opts...), + ), + } +} + +// identityServiceClient implements IdentityServiceClient. +type identityServiceClient struct { + userInfo *connect.Client[auth.UserInfoRequest, auth.UserInfoResponse] +} + +// UserInfo calls flyteidl2.auth.IdentityService.UserInfo. +func (c *identityServiceClient) UserInfo(ctx context.Context, req *connect.Request[auth.UserInfoRequest]) (*connect.Response[auth.UserInfoResponse], error) { + return c.userInfo.CallUnary(ctx, req) +} + +// IdentityServiceHandler is an implementation of the flyteidl2.auth.IdentityService service. +type IdentityServiceHandler interface { + // Retrieves user information about the currently logged in user. + UserInfo(context.Context, *connect.Request[auth.UserInfoRequest]) (*connect.Response[auth.UserInfoResponse], error) +} + +// NewIdentityServiceHandler builds an HTTP handler from the service implementation. It returns the +// path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewIdentityServiceHandler(svc IdentityServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + identityServiceUserInfoHandler := connect.NewUnaryHandler( + IdentityServiceUserInfoProcedure, + svc.UserInfo, + connect.WithSchema(identityServiceUserInfoMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.auth.IdentityService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case IdentityServiceUserInfoProcedure: + identityServiceUserInfoHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedIdentityServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedIdentityServiceHandler struct{} + +func (UnimplementedIdentityServiceHandler) UserInfo(context.Context, *connect.Request[auth.UserInfoRequest]) (*connect.Response[auth.UserInfoResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.auth.IdentityService.UserInfo is not implemented")) +} diff --git a/gen/go/flyteidl2/auth/identity.pb.go b/gen/go/flyteidl2/auth/identity.pb.go new file mode 100644 index 0000000000..c33eb40f59 --- /dev/null +++ b/gen/go/flyteidl2/auth/identity.pb.go @@ -0,0 +1,301 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/auth/identity.proto + +package auth + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + structpb "google.golang.org/protobuf/types/known/structpb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type UserInfoRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *UserInfoRequest) Reset() { + *x = UserInfoRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_auth_identity_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UserInfoRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UserInfoRequest) ProtoMessage() {} + +func (x *UserInfoRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_auth_identity_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UserInfoRequest.ProtoReflect.Descriptor instead. +func (*UserInfoRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_auth_identity_proto_rawDescGZIP(), []int{0} +} + +// See the OpenID Connect spec at https://openid.net/specs/openid-connect-core-1_0.html#UserInfoResponse for more information. +type UserInfoResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Locally unique and never reassigned identifier within the Issuer for the End-User, which is intended to be consumed + // by the Client. + Subject string `protobuf:"bytes,1,opt,name=subject,proto3" json:"subject,omitempty"` + // Full name + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + // Shorthand name by which the End-User wishes to be referred to + PreferredUsername string `protobuf:"bytes,3,opt,name=preferred_username,json=preferredUsername,proto3" json:"preferred_username,omitempty"` + // Given name(s) or first name(s) + GivenName string `protobuf:"bytes,4,opt,name=given_name,json=givenName,proto3" json:"given_name,omitempty"` + // Surname(s) or last name(s) + FamilyName string `protobuf:"bytes,5,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"` + // Preferred e-mail address + Email string `protobuf:"bytes,6,opt,name=email,proto3" json:"email,omitempty"` + // Profile picture URL + Picture string `protobuf:"bytes,7,opt,name=picture,proto3" json:"picture,omitempty"` + // Additional claims + AdditionalClaims *structpb.Struct `protobuf:"bytes,8,opt,name=additional_claims,json=additionalClaims,proto3" json:"additional_claims,omitempty"` +} + +func (x *UserInfoResponse) Reset() { + *x = UserInfoResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_auth_identity_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UserInfoResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UserInfoResponse) ProtoMessage() {} + +func (x *UserInfoResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_auth_identity_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UserInfoResponse.ProtoReflect.Descriptor instead. +func (*UserInfoResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_auth_identity_proto_rawDescGZIP(), []int{1} +} + +func (x *UserInfoResponse) GetSubject() string { + if x != nil { + return x.Subject + } + return "" +} + +func (x *UserInfoResponse) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *UserInfoResponse) GetPreferredUsername() string { + if x != nil { + return x.PreferredUsername + } + return "" +} + +func (x *UserInfoResponse) GetGivenName() string { + if x != nil { + return x.GivenName + } + return "" +} + +func (x *UserInfoResponse) GetFamilyName() string { + if x != nil { + return x.FamilyName + } + return "" +} + +func (x *UserInfoResponse) GetEmail() string { + if x != nil { + return x.Email + } + return "" +} + +func (x *UserInfoResponse) GetPicture() string { + if x != nil { + return x.Picture + } + return "" +} + +func (x *UserInfoResponse) GetAdditionalClaims() *structpb.Struct { + if x != nil { + return x.AdditionalClaims + } + return nil +} + +var File_flyteidl2_auth_identity_proto protoreflect.FileDescriptor + +var file_flyteidl2_auth_identity_proto_rawDesc = []byte{ + 0x0a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x75, 0x74, 0x68, + 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, + 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x1a, + 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x11, 0x0a, + 0x0f, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x22, 0xa5, 0x02, 0x0a, 0x10, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, + 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x12, 0x2d, 0x0a, 0x12, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, + 0x5f, 0x75, 0x73, 0x65, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x11, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x55, 0x73, 0x65, 0x72, 0x6e, 0x61, + 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x4e, 0x61, 0x6d, + 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x4e, 0x61, + 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x69, 0x63, 0x74, + 0x75, 0x72, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x69, 0x63, 0x74, 0x75, + 0x72, 0x65, 0x12, 0x44, 0x0a, 0x11, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x5f, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x10, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x6c, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x73, 0x32, 0x62, 0x0a, 0x0f, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x4f, 0x0a, 0x08, 0x55, + 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, + 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, + 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0xb2, 0x01, 0x0a, + 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, + 0x75, 0x74, 0x68, 0x42, 0x0d, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x50, 0x72, 0x6f, + 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x75, 0x74, 0x68, 0xa2, 0x02, 0x03, 0x46, 0x41, 0x58, + 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x41, 0x75, 0x74, + 0x68, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x75, + 0x74, 0x68, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, + 0x75, 0x74, 0x68, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, + 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x41, 0x75, 0x74, + 0x68, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_auth_identity_proto_rawDescOnce sync.Once + file_flyteidl2_auth_identity_proto_rawDescData = file_flyteidl2_auth_identity_proto_rawDesc +) + +func file_flyteidl2_auth_identity_proto_rawDescGZIP() []byte { + file_flyteidl2_auth_identity_proto_rawDescOnce.Do(func() { + file_flyteidl2_auth_identity_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_auth_identity_proto_rawDescData) + }) + return file_flyteidl2_auth_identity_proto_rawDescData +} + +var file_flyteidl2_auth_identity_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_flyteidl2_auth_identity_proto_goTypes = []interface{}{ + (*UserInfoRequest)(nil), // 0: flyteidl2.auth.UserInfoRequest + (*UserInfoResponse)(nil), // 1: flyteidl2.auth.UserInfoResponse + (*structpb.Struct)(nil), // 2: google.protobuf.Struct +} +var file_flyteidl2_auth_identity_proto_depIdxs = []int32{ + 2, // 0: flyteidl2.auth.UserInfoResponse.additional_claims:type_name -> google.protobuf.Struct + 0, // 1: flyteidl2.auth.IdentityService.UserInfo:input_type -> flyteidl2.auth.UserInfoRequest + 1, // 2: flyteidl2.auth.IdentityService.UserInfo:output_type -> flyteidl2.auth.UserInfoResponse + 2, // [2:3] is the sub-list for method output_type + 1, // [1:2] is the sub-list for method input_type + 1, // [1:1] is the sub-list for extension type_name + 1, // [1:1] is the sub-list for extension extendee + 0, // [0:1] is the sub-list for field type_name +} + +func init() { file_flyteidl2_auth_identity_proto_init() } +func file_flyteidl2_auth_identity_proto_init() { + if File_flyteidl2_auth_identity_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_auth_identity_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UserInfoRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_auth_identity_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UserInfoResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_auth_identity_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_flyteidl2_auth_identity_proto_goTypes, + DependencyIndexes: file_flyteidl2_auth_identity_proto_depIdxs, + MessageInfos: file_flyteidl2_auth_identity_proto_msgTypes, + }.Build() + File_flyteidl2_auth_identity_proto = out.File + file_flyteidl2_auth_identity_proto_rawDesc = nil + file_flyteidl2_auth_identity_proto_goTypes = nil + file_flyteidl2_auth_identity_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/auth/identity.pb.validate.go b/gen/go/flyteidl2/auth/identity.pb.validate.go new file mode 100644 index 0000000000..84e73a78aa --- /dev/null +++ b/gen/go/flyteidl2/auth/identity.pb.validate.go @@ -0,0 +1,279 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/auth/identity.proto + +package auth + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on UserInfoRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *UserInfoRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on UserInfoRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// UserInfoRequestMultiError, or nil if none found. +func (m *UserInfoRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *UserInfoRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return UserInfoRequestMultiError(errors) + } + + return nil +} + +// UserInfoRequestMultiError is an error wrapping multiple validation errors +// returned by UserInfoRequest.ValidateAll() if the designated constraints +// aren't met. +type UserInfoRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UserInfoRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UserInfoRequestMultiError) AllErrors() []error { return m } + +// UserInfoRequestValidationError is the validation error returned by +// UserInfoRequest.Validate if the designated constraints aren't met. +type UserInfoRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UserInfoRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UserInfoRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UserInfoRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UserInfoRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UserInfoRequestValidationError) ErrorName() string { return "UserInfoRequestValidationError" } + +// Error satisfies the builtin error interface +func (e UserInfoRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUserInfoRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UserInfoRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UserInfoRequestValidationError{} + +// Validate checks the field values on UserInfoResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *UserInfoResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on UserInfoResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// UserInfoResponseMultiError, or nil if none found. +func (m *UserInfoResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *UserInfoResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Subject + + // no validation rules for Name + + // no validation rules for PreferredUsername + + // no validation rules for GivenName + + // no validation rules for FamilyName + + // no validation rules for Email + + // no validation rules for Picture + + if all { + switch v := interface{}(m.GetAdditionalClaims()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UserInfoResponseValidationError{ + field: "AdditionalClaims", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UserInfoResponseValidationError{ + field: "AdditionalClaims", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAdditionalClaims()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UserInfoResponseValidationError{ + field: "AdditionalClaims", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return UserInfoResponseMultiError(errors) + } + + return nil +} + +// UserInfoResponseMultiError is an error wrapping multiple validation errors +// returned by UserInfoResponse.ValidateAll() if the designated constraints +// aren't met. +type UserInfoResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UserInfoResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UserInfoResponseMultiError) AllErrors() []error { return m } + +// UserInfoResponseValidationError is the validation error returned by +// UserInfoResponse.Validate if the designated constraints aren't met. +type UserInfoResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UserInfoResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UserInfoResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UserInfoResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UserInfoResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UserInfoResponseValidationError) ErrorName() string { return "UserInfoResponseValidationError" } + +// Error satisfies the builtin error interface +func (e UserInfoResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUserInfoResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UserInfoResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UserInfoResponseValidationError{} diff --git a/gen/go/flyteidl2/auth/identity_grpc.pb.go b/gen/go/flyteidl2/auth/identity_grpc.pb.go new file mode 100644 index 0000000000..f71abd17dd --- /dev/null +++ b/gen/go/flyteidl2/auth/identity_grpc.pb.go @@ -0,0 +1,109 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: flyteidl2/auth/identity.proto + +package auth + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + IdentityService_UserInfo_FullMethodName = "/flyteidl2.auth.IdentityService/UserInfo" +) + +// IdentityServiceClient is the client API for IdentityService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type IdentityServiceClient interface { + // Retrieves user information about the currently logged in user. + UserInfo(ctx context.Context, in *UserInfoRequest, opts ...grpc.CallOption) (*UserInfoResponse, error) +} + +type identityServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewIdentityServiceClient(cc grpc.ClientConnInterface) IdentityServiceClient { + return &identityServiceClient{cc} +} + +func (c *identityServiceClient) UserInfo(ctx context.Context, in *UserInfoRequest, opts ...grpc.CallOption) (*UserInfoResponse, error) { + out := new(UserInfoResponse) + err := c.cc.Invoke(ctx, IdentityService_UserInfo_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// IdentityServiceServer is the server API for IdentityService service. +// All implementations should embed UnimplementedIdentityServiceServer +// for forward compatibility +type IdentityServiceServer interface { + // Retrieves user information about the currently logged in user. + UserInfo(context.Context, *UserInfoRequest) (*UserInfoResponse, error) +} + +// UnimplementedIdentityServiceServer should be embedded to have forward compatible implementations. +type UnimplementedIdentityServiceServer struct { +} + +func (UnimplementedIdentityServiceServer) UserInfo(context.Context, *UserInfoRequest) (*UserInfoResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UserInfo not implemented") +} + +// UnsafeIdentityServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to IdentityServiceServer will +// result in compilation errors. +type UnsafeIdentityServiceServer interface { + mustEmbedUnimplementedIdentityServiceServer() +} + +func RegisterIdentityServiceServer(s grpc.ServiceRegistrar, srv IdentityServiceServer) { + s.RegisterService(&IdentityService_ServiceDesc, srv) +} + +func _IdentityService_UserInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UserInfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(IdentityServiceServer).UserInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: IdentityService_UserInfo_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(IdentityServiceServer).UserInfo(ctx, req.(*UserInfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// IdentityService_ServiceDesc is the grpc.ServiceDesc for IdentityService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var IdentityService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.auth.IdentityService", + HandlerType: (*IdentityServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "UserInfo", + Handler: _IdentityService_UserInfo_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "flyteidl2/auth/identity.proto", +} diff --git a/gen/go/flyteidl2/cacheservice/cacheservice.pb.go b/gen/go/flyteidl2/cacheservice/cacheservice.pb.go new file mode 100644 index 0000000000..0704287268 --- /dev/null +++ b/gen/go/flyteidl2/cacheservice/cacheservice.pb.go @@ -0,0 +1,1314 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/cacheservice/cacheservice.proto + +package cacheservice + +import ( + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + durationpb "google.golang.org/protobuf/types/known/durationpb" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Additional metadata as key-value pairs +type KeyMapMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Values map[string]string `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Additional metadata as key-value pairs +} + +func (x *KeyMapMetadata) Reset() { + *x = KeyMapMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *KeyMapMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*KeyMapMetadata) ProtoMessage() {} + +func (x *KeyMapMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use KeyMapMetadata.ProtoReflect.Descriptor instead. +func (*KeyMapMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_cacheservice_proto_rawDescGZIP(), []int{0} +} + +func (x *KeyMapMetadata) GetValues() map[string]string { + if x != nil { + return x.Values + } + return nil +} + +// Metadata for cached outputs, including the source identifier and timestamps. +type Metadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SourceIdentifier *core.Identifier `protobuf:"bytes,1,opt,name=source_identifier,json=sourceIdentifier,proto3" json:"source_identifier,omitempty"` // Source task or workflow identifier + KeyMap *KeyMapMetadata `protobuf:"bytes,2,opt,name=key_map,json=keyMap,proto3" json:"key_map,omitempty"` // Additional metadata as key-value pairs + CreatedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` // Creation timestamp + LastUpdatedAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=last_updated_at,json=lastUpdatedAt,proto3" json:"last_updated_at,omitempty"` // Last update timestamp +} + +func (x *Metadata) Reset() { + *x = Metadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Metadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Metadata) ProtoMessage() {} + +func (x *Metadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Metadata.ProtoReflect.Descriptor instead. +func (*Metadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_cacheservice_proto_rawDescGZIP(), []int{1} +} + +func (x *Metadata) GetSourceIdentifier() *core.Identifier { + if x != nil { + return x.SourceIdentifier + } + return nil +} + +func (x *Metadata) GetKeyMap() *KeyMapMetadata { + if x != nil { + return x.KeyMap + } + return nil +} + +func (x *Metadata) GetCreatedAt() *timestamppb.Timestamp { + if x != nil { + return x.CreatedAt + } + return nil +} + +func (x *Metadata) GetLastUpdatedAt() *timestamppb.Timestamp { + if x != nil { + return x.LastUpdatedAt + } + return nil +} + +// Represents cached output, either as literals or an URI, with associated metadata. +type CachedOutput struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Output: + // + // *CachedOutput_OutputLiterals + // *CachedOutput_OutputUri + Output isCachedOutput_Output `protobuf_oneof:"output"` + Metadata *Metadata `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"` // Associated metadata +} + +func (x *CachedOutput) Reset() { + *x = CachedOutput{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CachedOutput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CachedOutput) ProtoMessage() {} + +func (x *CachedOutput) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CachedOutput.ProtoReflect.Descriptor instead. +func (*CachedOutput) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_cacheservice_proto_rawDescGZIP(), []int{2} +} + +func (m *CachedOutput) GetOutput() isCachedOutput_Output { + if m != nil { + return m.Output + } + return nil +} + +func (x *CachedOutput) GetOutputLiterals() *core.LiteralMap { + if x, ok := x.GetOutput().(*CachedOutput_OutputLiterals); ok { + return x.OutputLiterals + } + return nil +} + +func (x *CachedOutput) GetOutputUri() string { + if x, ok := x.GetOutput().(*CachedOutput_OutputUri); ok { + return x.OutputUri + } + return "" +} + +func (x *CachedOutput) GetMetadata() *Metadata { + if x != nil { + return x.Metadata + } + return nil +} + +type isCachedOutput_Output interface { + isCachedOutput_Output() +} + +type CachedOutput_OutputLiterals struct { + OutputLiterals *core.LiteralMap `protobuf:"bytes,1,opt,name=output_literals,json=outputLiterals,proto3,oneof"` // Output literals +} + +type CachedOutput_OutputUri struct { + OutputUri string `protobuf:"bytes,2,opt,name=output_uri,json=outputUri,proto3,oneof"` // URI to output data +} + +func (*CachedOutput_OutputLiterals) isCachedOutput_Output() {} + +func (*CachedOutput_OutputUri) isCachedOutput_Output() {} + +// Request to retrieve cached data by key. +type GetCacheRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` // Cache key +} + +func (x *GetCacheRequest) Reset() { + *x = GetCacheRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetCacheRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetCacheRequest) ProtoMessage() {} + +func (x *GetCacheRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetCacheRequest.ProtoReflect.Descriptor instead. +func (*GetCacheRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_cacheservice_proto_rawDescGZIP(), []int{3} +} + +func (x *GetCacheRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +// Response with cached data for a given key. +type GetCacheResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Output *CachedOutput `protobuf:"bytes,1,opt,name=output,proto3" json:"output,omitempty"` // Cached output +} + +func (x *GetCacheResponse) Reset() { + *x = GetCacheResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetCacheResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetCacheResponse) ProtoMessage() {} + +func (x *GetCacheResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetCacheResponse.ProtoReflect.Descriptor instead. +func (*GetCacheResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_cacheservice_proto_rawDescGZIP(), []int{4} +} + +func (x *GetCacheResponse) GetOutput() *CachedOutput { + if x != nil { + return x.Output + } + return nil +} + +type OverwriteOutput struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Overwrite bool `protobuf:"varint,1,opt,name=overwrite,proto3" json:"overwrite,omitempty"` // Overwrite flag + DeleteBlob bool `protobuf:"varint,2,opt,name=delete_blob,json=deleteBlob,proto3" json:"delete_blob,omitempty"` // Delete existing blob + MaxAge *durationpb.Duration `protobuf:"bytes,3,opt,name=max_age,json=maxAge,proto3" json:"max_age,omitempty"` // Maximum age of the cached output since last update +} + +func (x *OverwriteOutput) Reset() { + *x = OverwriteOutput{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OverwriteOutput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OverwriteOutput) ProtoMessage() {} + +func (x *OverwriteOutput) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OverwriteOutput.ProtoReflect.Descriptor instead. +func (*OverwriteOutput) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_cacheservice_proto_rawDescGZIP(), []int{5} +} + +func (x *OverwriteOutput) GetOverwrite() bool { + if x != nil { + return x.Overwrite + } + return false +} + +func (x *OverwriteOutput) GetDeleteBlob() bool { + if x != nil { + return x.DeleteBlob + } + return false +} + +func (x *OverwriteOutput) GetMaxAge() *durationpb.Duration { + if x != nil { + return x.MaxAge + } + return nil +} + +// Request to store/update cached data by key. +type PutCacheRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` // Cache key + Output *CachedOutput `protobuf:"bytes,2,opt,name=output,proto3" json:"output,omitempty"` // Output to cache + Overwrite *OverwriteOutput `protobuf:"bytes,3,opt,name=overwrite,proto3" json:"overwrite,omitempty"` // Overwrite flag if exists +} + +func (x *PutCacheRequest) Reset() { + *x = PutCacheRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PutCacheRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PutCacheRequest) ProtoMessage() {} + +func (x *PutCacheRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PutCacheRequest.ProtoReflect.Descriptor instead. +func (*PutCacheRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_cacheservice_proto_rawDescGZIP(), []int{6} +} + +func (x *PutCacheRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *PutCacheRequest) GetOutput() *CachedOutput { + if x != nil { + return x.Output + } + return nil +} + +func (x *PutCacheRequest) GetOverwrite() *OverwriteOutput { + if x != nil { + return x.Overwrite + } + return nil +} + +// Response message of cache store/update operation. +type PutCacheResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *PutCacheResponse) Reset() { + *x = PutCacheResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PutCacheResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PutCacheResponse) ProtoMessage() {} + +func (x *PutCacheResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PutCacheResponse.ProtoReflect.Descriptor instead. +func (*PutCacheResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_cacheservice_proto_rawDescGZIP(), []int{7} +} + +// Request to delete cached data by key. +type DeleteCacheRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` // Cache key +} + +func (x *DeleteCacheRequest) Reset() { + *x = DeleteCacheRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteCacheRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteCacheRequest) ProtoMessage() {} + +func (x *DeleteCacheRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteCacheRequest.ProtoReflect.Descriptor instead. +func (*DeleteCacheRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_cacheservice_proto_rawDescGZIP(), []int{8} +} + +func (x *DeleteCacheRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +// Response message of cache deletion operation. +type DeleteCacheResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *DeleteCacheResponse) Reset() { + *x = DeleteCacheResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteCacheResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteCacheResponse) ProtoMessage() {} + +func (x *DeleteCacheResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteCacheResponse.ProtoReflect.Descriptor instead. +func (*DeleteCacheResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_cacheservice_proto_rawDescGZIP(), []int{9} +} + +// A reservation including owner, heartbeat interval, expiration timestamp, and various metadata. +type Reservation struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` // The unique ID for the reservation - same as the cache key + OwnerId string `protobuf:"bytes,2,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"` // The unique ID of the owner for the reservation + HeartbeatInterval *durationpb.Duration `protobuf:"bytes,3,opt,name=heartbeat_interval,json=heartbeatInterval,proto3" json:"heartbeat_interval,omitempty"` // Requested reservation extension heartbeat interval + ExpiresAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=expires_at,json=expiresAt,proto3" json:"expires_at,omitempty"` // Expiration timestamp of this reservation +} + +func (x *Reservation) Reset() { + *x = Reservation{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Reservation) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Reservation) ProtoMessage() {} + +func (x *Reservation) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Reservation.ProtoReflect.Descriptor instead. +func (*Reservation) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_cacheservice_proto_rawDescGZIP(), []int{10} +} + +func (x *Reservation) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *Reservation) GetOwnerId() string { + if x != nil { + return x.OwnerId + } + return "" +} + +func (x *Reservation) GetHeartbeatInterval() *durationpb.Duration { + if x != nil { + return x.HeartbeatInterval + } + return nil +} + +func (x *Reservation) GetExpiresAt() *timestamppb.Timestamp { + if x != nil { + return x.ExpiresAt + } + return nil +} + +// Request to get or extend a reservation for a cache key +type GetOrExtendReservationRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` // The unique ID for the reservation - same as the cache key + OwnerId string `protobuf:"bytes,2,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"` // The unique ID of the owner for the reservation + HeartbeatInterval *durationpb.Duration `protobuf:"bytes,3,opt,name=heartbeat_interval,json=heartbeatInterval,proto3" json:"heartbeat_interval,omitempty"` // Requested reservation extension heartbeat interval +} + +func (x *GetOrExtendReservationRequest) Reset() { + *x = GetOrExtendReservationRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOrExtendReservationRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOrExtendReservationRequest) ProtoMessage() {} + +func (x *GetOrExtendReservationRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetOrExtendReservationRequest.ProtoReflect.Descriptor instead. +func (*GetOrExtendReservationRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_cacheservice_proto_rawDescGZIP(), []int{11} +} + +func (x *GetOrExtendReservationRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *GetOrExtendReservationRequest) GetOwnerId() string { + if x != nil { + return x.OwnerId + } + return "" +} + +func (x *GetOrExtendReservationRequest) GetHeartbeatInterval() *durationpb.Duration { + if x != nil { + return x.HeartbeatInterval + } + return nil +} + +// Request to get or extend a reservation for a cache key +type GetOrExtendReservationResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Reservation *Reservation `protobuf:"bytes,1,opt,name=reservation,proto3" json:"reservation,omitempty"` // The reservation that was created or extended +} + +func (x *GetOrExtendReservationResponse) Reset() { + *x = GetOrExtendReservationResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOrExtendReservationResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOrExtendReservationResponse) ProtoMessage() {} + +func (x *GetOrExtendReservationResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetOrExtendReservationResponse.ProtoReflect.Descriptor instead. +func (*GetOrExtendReservationResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_cacheservice_proto_rawDescGZIP(), []int{12} +} + +func (x *GetOrExtendReservationResponse) GetReservation() *Reservation { + if x != nil { + return x.Reservation + } + return nil +} + +// Request to release the reservation for a cache key +type ReleaseReservationRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` // The unique ID for the reservation - same as the cache key + OwnerId string `protobuf:"bytes,2,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"` // The unique ID of the owner for the reservation +} + +func (x *ReleaseReservationRequest) Reset() { + *x = ReleaseReservationRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ReleaseReservationRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReleaseReservationRequest) ProtoMessage() {} + +func (x *ReleaseReservationRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReleaseReservationRequest.ProtoReflect.Descriptor instead. +func (*ReleaseReservationRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_cacheservice_proto_rawDescGZIP(), []int{13} +} + +func (x *ReleaseReservationRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *ReleaseReservationRequest) GetOwnerId() string { + if x != nil { + return x.OwnerId + } + return "" +} + +// Response message of release reservation operation. +type ReleaseReservationResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *ReleaseReservationResponse) Reset() { + *x = ReleaseReservationResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ReleaseReservationResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReleaseReservationResponse) ProtoMessage() {} + +func (x *ReleaseReservationResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReleaseReservationResponse.ProtoReflect.Descriptor instead. +func (*ReleaseReservationResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_cacheservice_proto_rawDescGZIP(), []int{14} +} + +var File_flyteidl2_cacheservice_cacheservice_proto protoreflect.FileDescriptor + +var file_flyteidl2_cacheservice_cacheservice_proto_rawDesc = []byte{ + 0x0a, 0x29, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x61, 0x63, 0x68, + 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2f, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x16, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x1a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, + 0x6f, 0x72, 0x65, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x97, 0x01, 0x0a, 0x0e, 0x4b, 0x65, 0x79, 0x4d, 0x61, 0x70, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x4a, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x2e, 0x4b, 0x65, 0x79, 0x4d, 0x61, 0x70, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x1a, 0x39, 0x0a, 0x0b, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x93, + 0x02, 0x0a, 0x08, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x47, 0x0a, 0x11, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x52, 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x12, 0x3f, 0x0a, 0x07, 0x6b, 0x65, 0x79, 0x5f, 0x6d, 0x61, 0x70, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x4b, + 0x65, 0x79, 0x4d, 0x61, 0x70, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x06, 0x6b, + 0x65, 0x79, 0x4d, 0x61, 0x70, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, + 0x5f, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, + 0x12, 0x42, 0x0a, 0x0f, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, + 0x5f, 0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x64, 0x41, 0x74, 0x22, 0xbe, 0x01, 0x0a, 0x0c, 0x43, 0x61, 0x63, 0x68, 0x65, 0x64, 0x4f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x45, 0x0a, 0x0f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, + 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, 0x70, 0x48, 0x00, 0x52, 0x0e, 0x6f, 0x75, + 0x74, 0x70, 0x75, 0x74, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x12, 0x1f, 0x0a, 0x0a, + 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x48, 0x00, 0x52, 0x09, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x55, 0x72, 0x69, 0x12, 0x3c, 0x0a, + 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, + 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x42, 0x08, 0x0a, 0x06, 0x6f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x22, 0x23, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x43, 0x61, 0x63, 0x68, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x22, 0x50, 0x0a, 0x10, 0x47, 0x65, + 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3c, + 0x0a, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x43, 0x61, 0x63, 0x68, 0x65, 0x64, 0x4f, 0x75, + 0x74, 0x70, 0x75, 0x74, 0x52, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x22, 0x84, 0x01, 0x0a, + 0x0f, 0x4f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, + 0x12, 0x1c, 0x0a, 0x09, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x09, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x12, 0x1f, + 0x0a, 0x0b, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x5f, 0x62, 0x6c, 0x6f, 0x62, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x42, 0x6c, 0x6f, 0x62, 0x12, + 0x32, 0x0a, 0x07, 0x6d, 0x61, 0x78, 0x5f, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x06, 0x6d, 0x61, 0x78, + 0x41, 0x67, 0x65, 0x22, 0xa8, 0x01, 0x0a, 0x0f, 0x50, 0x75, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x3c, 0x0a, 0x06, 0x6f, 0x75, 0x74, + 0x70, 0x75, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x2e, 0x43, 0x61, 0x63, 0x68, 0x65, 0x64, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x52, + 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x45, 0x0a, 0x09, 0x6f, 0x76, 0x65, 0x72, 0x77, + 0x72, 0x69, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x2e, 0x4f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x4f, 0x75, 0x74, + 0x70, 0x75, 0x74, 0x52, 0x09, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x22, 0x12, + 0x0a, 0x10, 0x50, 0x75, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x26, 0x0a, 0x12, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x61, 0x63, 0x68, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x22, 0x15, 0x0a, 0x13, 0x44, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0xbf, 0x01, 0x0a, 0x0b, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, + 0x6b, 0x65, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x49, 0x64, 0x12, 0x48, + 0x0a, 0x12, 0x68, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x65, + 0x72, 0x76, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x11, 0x68, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, + 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x39, 0x0a, 0x0a, 0x65, 0x78, 0x70, 0x69, + 0x72, 0x65, 0x73, 0x5f, 0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x65, 0x78, 0x70, 0x69, 0x72, 0x65, + 0x73, 0x41, 0x74, 0x22, 0x96, 0x01, 0x0a, 0x1d, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x45, 0x78, 0x74, + 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, + 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x77, 0x6e, 0x65, 0x72, + 0x49, 0x64, 0x12, 0x48, 0x0a, 0x12, 0x68, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, 0x5f, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x11, 0x68, 0x65, 0x61, 0x72, 0x74, + 0x62, 0x65, 0x61, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x22, 0x67, 0x0a, 0x1e, + 0x47, 0x65, 0x74, 0x4f, 0x72, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x65, 0x72, + 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x45, + 0x0a, 0x0b, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x52, 0x65, 0x73, + 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x48, 0x0a, 0x19, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, + 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x03, 0x6b, 0x65, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, 0x69, 0x64, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x49, 0x64, 0x22, + 0x1c, 0x0a, 0x1a, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0xac, 0x04, + 0x0a, 0x0c, 0x43, 0x61, 0x63, 0x68, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x58, + 0x0a, 0x03, 0x47, 0x65, 0x74, 0x12, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x47, + 0x65, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x03, 0x50, 0x75, 0x74, 0x12, + 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, + 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x50, 0x75, 0x74, 0x43, 0x61, 0x63, 0x68, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x2e, 0x50, 0x75, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x61, 0x0a, 0x06, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x2a, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x61, 0x63, 0x68, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x87, 0x01, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x45, + 0x78, 0x74, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x35, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, + 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x45, + 0x78, 0x74, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x36, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x65, + 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x7b, 0x0a, 0x12, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x31, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x52, + 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x2e, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0xe6, 0x01, 0x0a, + 0x1a, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x42, 0x11, 0x43, 0x61, 0x63, + 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, + 0x50, 0x01, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, + 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0xa2, 0x02, + 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x16, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0xca, 0x02, 0x16, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0xe2, 0x02, 0x22, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5c, + 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x17, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_cacheservice_cacheservice_proto_rawDescOnce sync.Once + file_flyteidl2_cacheservice_cacheservice_proto_rawDescData = file_flyteidl2_cacheservice_cacheservice_proto_rawDesc +) + +func file_flyteidl2_cacheservice_cacheservice_proto_rawDescGZIP() []byte { + file_flyteidl2_cacheservice_cacheservice_proto_rawDescOnce.Do(func() { + file_flyteidl2_cacheservice_cacheservice_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_cacheservice_cacheservice_proto_rawDescData) + }) + return file_flyteidl2_cacheservice_cacheservice_proto_rawDescData +} + +var file_flyteidl2_cacheservice_cacheservice_proto_msgTypes = make([]protoimpl.MessageInfo, 16) +var file_flyteidl2_cacheservice_cacheservice_proto_goTypes = []interface{}{ + (*KeyMapMetadata)(nil), // 0: flyteidl2.cacheservice.KeyMapMetadata + (*Metadata)(nil), // 1: flyteidl2.cacheservice.Metadata + (*CachedOutput)(nil), // 2: flyteidl2.cacheservice.CachedOutput + (*GetCacheRequest)(nil), // 3: flyteidl2.cacheservice.GetCacheRequest + (*GetCacheResponse)(nil), // 4: flyteidl2.cacheservice.GetCacheResponse + (*OverwriteOutput)(nil), // 5: flyteidl2.cacheservice.OverwriteOutput + (*PutCacheRequest)(nil), // 6: flyteidl2.cacheservice.PutCacheRequest + (*PutCacheResponse)(nil), // 7: flyteidl2.cacheservice.PutCacheResponse + (*DeleteCacheRequest)(nil), // 8: flyteidl2.cacheservice.DeleteCacheRequest + (*DeleteCacheResponse)(nil), // 9: flyteidl2.cacheservice.DeleteCacheResponse + (*Reservation)(nil), // 10: flyteidl2.cacheservice.Reservation + (*GetOrExtendReservationRequest)(nil), // 11: flyteidl2.cacheservice.GetOrExtendReservationRequest + (*GetOrExtendReservationResponse)(nil), // 12: flyteidl2.cacheservice.GetOrExtendReservationResponse + (*ReleaseReservationRequest)(nil), // 13: flyteidl2.cacheservice.ReleaseReservationRequest + (*ReleaseReservationResponse)(nil), // 14: flyteidl2.cacheservice.ReleaseReservationResponse + nil, // 15: flyteidl2.cacheservice.KeyMapMetadata.ValuesEntry + (*core.Identifier)(nil), // 16: flyteidl2.core.Identifier + (*timestamppb.Timestamp)(nil), // 17: google.protobuf.Timestamp + (*core.LiteralMap)(nil), // 18: flyteidl2.core.LiteralMap + (*durationpb.Duration)(nil), // 19: google.protobuf.Duration +} +var file_flyteidl2_cacheservice_cacheservice_proto_depIdxs = []int32{ + 15, // 0: flyteidl2.cacheservice.KeyMapMetadata.values:type_name -> flyteidl2.cacheservice.KeyMapMetadata.ValuesEntry + 16, // 1: flyteidl2.cacheservice.Metadata.source_identifier:type_name -> flyteidl2.core.Identifier + 0, // 2: flyteidl2.cacheservice.Metadata.key_map:type_name -> flyteidl2.cacheservice.KeyMapMetadata + 17, // 3: flyteidl2.cacheservice.Metadata.created_at:type_name -> google.protobuf.Timestamp + 17, // 4: flyteidl2.cacheservice.Metadata.last_updated_at:type_name -> google.protobuf.Timestamp + 18, // 5: flyteidl2.cacheservice.CachedOutput.output_literals:type_name -> flyteidl2.core.LiteralMap + 1, // 6: flyteidl2.cacheservice.CachedOutput.metadata:type_name -> flyteidl2.cacheservice.Metadata + 2, // 7: flyteidl2.cacheservice.GetCacheResponse.output:type_name -> flyteidl2.cacheservice.CachedOutput + 19, // 8: flyteidl2.cacheservice.OverwriteOutput.max_age:type_name -> google.protobuf.Duration + 2, // 9: flyteidl2.cacheservice.PutCacheRequest.output:type_name -> flyteidl2.cacheservice.CachedOutput + 5, // 10: flyteidl2.cacheservice.PutCacheRequest.overwrite:type_name -> flyteidl2.cacheservice.OverwriteOutput + 19, // 11: flyteidl2.cacheservice.Reservation.heartbeat_interval:type_name -> google.protobuf.Duration + 17, // 12: flyteidl2.cacheservice.Reservation.expires_at:type_name -> google.protobuf.Timestamp + 19, // 13: flyteidl2.cacheservice.GetOrExtendReservationRequest.heartbeat_interval:type_name -> google.protobuf.Duration + 10, // 14: flyteidl2.cacheservice.GetOrExtendReservationResponse.reservation:type_name -> flyteidl2.cacheservice.Reservation + 3, // 15: flyteidl2.cacheservice.CacheService.Get:input_type -> flyteidl2.cacheservice.GetCacheRequest + 6, // 16: flyteidl2.cacheservice.CacheService.Put:input_type -> flyteidl2.cacheservice.PutCacheRequest + 8, // 17: flyteidl2.cacheservice.CacheService.Delete:input_type -> flyteidl2.cacheservice.DeleteCacheRequest + 11, // 18: flyteidl2.cacheservice.CacheService.GetOrExtendReservation:input_type -> flyteidl2.cacheservice.GetOrExtendReservationRequest + 13, // 19: flyteidl2.cacheservice.CacheService.ReleaseReservation:input_type -> flyteidl2.cacheservice.ReleaseReservationRequest + 4, // 20: flyteidl2.cacheservice.CacheService.Get:output_type -> flyteidl2.cacheservice.GetCacheResponse + 7, // 21: flyteidl2.cacheservice.CacheService.Put:output_type -> flyteidl2.cacheservice.PutCacheResponse + 9, // 22: flyteidl2.cacheservice.CacheService.Delete:output_type -> flyteidl2.cacheservice.DeleteCacheResponse + 12, // 23: flyteidl2.cacheservice.CacheService.GetOrExtendReservation:output_type -> flyteidl2.cacheservice.GetOrExtendReservationResponse + 14, // 24: flyteidl2.cacheservice.CacheService.ReleaseReservation:output_type -> flyteidl2.cacheservice.ReleaseReservationResponse + 20, // [20:25] is the sub-list for method output_type + 15, // [15:20] is the sub-list for method input_type + 15, // [15:15] is the sub-list for extension type_name + 15, // [15:15] is the sub-list for extension extendee + 0, // [0:15] is the sub-list for field type_name +} + +func init() { file_flyteidl2_cacheservice_cacheservice_proto_init() } +func file_flyteidl2_cacheservice_cacheservice_proto_init() { + if File_flyteidl2_cacheservice_cacheservice_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*KeyMapMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Metadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CachedOutput); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetCacheRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetCacheResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OverwriteOutput); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PutCacheRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PutCacheResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteCacheRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteCacheResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Reservation); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOrExtendReservationRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOrExtendReservationResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ReleaseReservationRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ReleaseReservationResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_cacheservice_cacheservice_proto_msgTypes[2].OneofWrappers = []interface{}{ + (*CachedOutput_OutputLiterals)(nil), + (*CachedOutput_OutputUri)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_cacheservice_cacheservice_proto_rawDesc, + NumEnums: 0, + NumMessages: 16, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_flyteidl2_cacheservice_cacheservice_proto_goTypes, + DependencyIndexes: file_flyteidl2_cacheservice_cacheservice_proto_depIdxs, + MessageInfos: file_flyteidl2_cacheservice_cacheservice_proto_msgTypes, + }.Build() + File_flyteidl2_cacheservice_cacheservice_proto = out.File + file_flyteidl2_cacheservice_cacheservice_proto_rawDesc = nil + file_flyteidl2_cacheservice_cacheservice_proto_goTypes = nil + file_flyteidl2_cacheservice_cacheservice_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/cacheservice/cacheservice.pb.validate.go b/gen/go/flyteidl2/cacheservice/cacheservice.pb.validate.go new file mode 100644 index 0000000000..f00005cad4 --- /dev/null +++ b/gen/go/flyteidl2/cacheservice/cacheservice.pb.validate.go @@ -0,0 +1,2006 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/cacheservice/cacheservice.proto + +package cacheservice + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on KeyMapMetadata with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *KeyMapMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on KeyMapMetadata with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in KeyMapMetadataMultiError, +// or nil if none found. +func (m *KeyMapMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *KeyMapMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Values + + if len(errors) > 0 { + return KeyMapMetadataMultiError(errors) + } + + return nil +} + +// KeyMapMetadataMultiError is an error wrapping multiple validation errors +// returned by KeyMapMetadata.ValidateAll() if the designated constraints +// aren't met. +type KeyMapMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m KeyMapMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m KeyMapMetadataMultiError) AllErrors() []error { return m } + +// KeyMapMetadataValidationError is the validation error returned by +// KeyMapMetadata.Validate if the designated constraints aren't met. +type KeyMapMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e KeyMapMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e KeyMapMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e KeyMapMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e KeyMapMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e KeyMapMetadataValidationError) ErrorName() string { return "KeyMapMetadataValidationError" } + +// Error satisfies the builtin error interface +func (e KeyMapMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sKeyMapMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = KeyMapMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = KeyMapMetadataValidationError{} + +// Validate checks the field values on Metadata with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Metadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Metadata with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in MetadataMultiError, or nil +// if none found. +func (m *Metadata) ValidateAll() error { + return m.validate(true) +} + +func (m *Metadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetSourceIdentifier()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, MetadataValidationError{ + field: "SourceIdentifier", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, MetadataValidationError{ + field: "SourceIdentifier", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSourceIdentifier()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return MetadataValidationError{ + field: "SourceIdentifier", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetKeyMap()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, MetadataValidationError{ + field: "KeyMap", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, MetadataValidationError{ + field: "KeyMap", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetKeyMap()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return MetadataValidationError{ + field: "KeyMap", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetCreatedAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, MetadataValidationError{ + field: "CreatedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, MetadataValidationError{ + field: "CreatedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCreatedAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return MetadataValidationError{ + field: "CreatedAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetLastUpdatedAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, MetadataValidationError{ + field: "LastUpdatedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, MetadataValidationError{ + field: "LastUpdatedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLastUpdatedAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return MetadataValidationError{ + field: "LastUpdatedAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return MetadataMultiError(errors) + } + + return nil +} + +// MetadataMultiError is an error wrapping multiple validation errors returned +// by Metadata.ValidateAll() if the designated constraints aren't met. +type MetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m MetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m MetadataMultiError) AllErrors() []error { return m } + +// MetadataValidationError is the validation error returned by +// Metadata.Validate if the designated constraints aren't met. +type MetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e MetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e MetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e MetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e MetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e MetadataValidationError) ErrorName() string { return "MetadataValidationError" } + +// Error satisfies the builtin error interface +func (e MetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = MetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = MetadataValidationError{} + +// Validate checks the field values on CachedOutput with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *CachedOutput) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CachedOutput with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in CachedOutputMultiError, or +// nil if none found. +func (m *CachedOutput) ValidateAll() error { + return m.validate(true) +} + +func (m *CachedOutput) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CachedOutputValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CachedOutputValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CachedOutputValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + switch v := m.Output.(type) { + case *CachedOutput_OutputLiterals: + if v == nil { + err := CachedOutputValidationError{ + field: "Output", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetOutputLiterals()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CachedOutputValidationError{ + field: "OutputLiterals", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CachedOutputValidationError{ + field: "OutputLiterals", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOutputLiterals()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CachedOutputValidationError{ + field: "OutputLiterals", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *CachedOutput_OutputUri: + if v == nil { + err := CachedOutputValidationError{ + field: "Output", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for OutputUri + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return CachedOutputMultiError(errors) + } + + return nil +} + +// CachedOutputMultiError is an error wrapping multiple validation errors +// returned by CachedOutput.ValidateAll() if the designated constraints aren't met. +type CachedOutputMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CachedOutputMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CachedOutputMultiError) AllErrors() []error { return m } + +// CachedOutputValidationError is the validation error returned by +// CachedOutput.Validate if the designated constraints aren't met. +type CachedOutputValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CachedOutputValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CachedOutputValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CachedOutputValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CachedOutputValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CachedOutputValidationError) ErrorName() string { return "CachedOutputValidationError" } + +// Error satisfies the builtin error interface +func (e CachedOutputValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCachedOutput.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CachedOutputValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CachedOutputValidationError{} + +// Validate checks the field values on GetCacheRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *GetCacheRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetCacheRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetCacheRequestMultiError, or nil if none found. +func (m *GetCacheRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetCacheRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Key + + if len(errors) > 0 { + return GetCacheRequestMultiError(errors) + } + + return nil +} + +// GetCacheRequestMultiError is an error wrapping multiple validation errors +// returned by GetCacheRequest.ValidateAll() if the designated constraints +// aren't met. +type GetCacheRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetCacheRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetCacheRequestMultiError) AllErrors() []error { return m } + +// GetCacheRequestValidationError is the validation error returned by +// GetCacheRequest.Validate if the designated constraints aren't met. +type GetCacheRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetCacheRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetCacheRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetCacheRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetCacheRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetCacheRequestValidationError) ErrorName() string { return "GetCacheRequestValidationError" } + +// Error satisfies the builtin error interface +func (e GetCacheRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetCacheRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetCacheRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetCacheRequestValidationError{} + +// Validate checks the field values on GetCacheResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *GetCacheResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetCacheResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetCacheResponseMultiError, or nil if none found. +func (m *GetCacheResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetCacheResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetOutput()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetCacheResponseValidationError{ + field: "Output", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetCacheResponseValidationError{ + field: "Output", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOutput()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetCacheResponseValidationError{ + field: "Output", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetCacheResponseMultiError(errors) + } + + return nil +} + +// GetCacheResponseMultiError is an error wrapping multiple validation errors +// returned by GetCacheResponse.ValidateAll() if the designated constraints +// aren't met. +type GetCacheResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetCacheResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetCacheResponseMultiError) AllErrors() []error { return m } + +// GetCacheResponseValidationError is the validation error returned by +// GetCacheResponse.Validate if the designated constraints aren't met. +type GetCacheResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetCacheResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetCacheResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetCacheResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetCacheResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetCacheResponseValidationError) ErrorName() string { return "GetCacheResponseValidationError" } + +// Error satisfies the builtin error interface +func (e GetCacheResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetCacheResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetCacheResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetCacheResponseValidationError{} + +// Validate checks the field values on OverwriteOutput with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *OverwriteOutput) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on OverwriteOutput with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// OverwriteOutputMultiError, or nil if none found. +func (m *OverwriteOutput) ValidateAll() error { + return m.validate(true) +} + +func (m *OverwriteOutput) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Overwrite + + // no validation rules for DeleteBlob + + if all { + switch v := interface{}(m.GetMaxAge()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, OverwriteOutputValidationError{ + field: "MaxAge", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, OverwriteOutputValidationError{ + field: "MaxAge", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMaxAge()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return OverwriteOutputValidationError{ + field: "MaxAge", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return OverwriteOutputMultiError(errors) + } + + return nil +} + +// OverwriteOutputMultiError is an error wrapping multiple validation errors +// returned by OverwriteOutput.ValidateAll() if the designated constraints +// aren't met. +type OverwriteOutputMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m OverwriteOutputMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m OverwriteOutputMultiError) AllErrors() []error { return m } + +// OverwriteOutputValidationError is the validation error returned by +// OverwriteOutput.Validate if the designated constraints aren't met. +type OverwriteOutputValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e OverwriteOutputValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e OverwriteOutputValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e OverwriteOutputValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e OverwriteOutputValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e OverwriteOutputValidationError) ErrorName() string { return "OverwriteOutputValidationError" } + +// Error satisfies the builtin error interface +func (e OverwriteOutputValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sOverwriteOutput.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = OverwriteOutputValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = OverwriteOutputValidationError{} + +// Validate checks the field values on PutCacheRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *PutCacheRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on PutCacheRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// PutCacheRequestMultiError, or nil if none found. +func (m *PutCacheRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *PutCacheRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Key + + if all { + switch v := interface{}(m.GetOutput()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PutCacheRequestValidationError{ + field: "Output", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PutCacheRequestValidationError{ + field: "Output", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOutput()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PutCacheRequestValidationError{ + field: "Output", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetOverwrite()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PutCacheRequestValidationError{ + field: "Overwrite", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PutCacheRequestValidationError{ + field: "Overwrite", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOverwrite()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PutCacheRequestValidationError{ + field: "Overwrite", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return PutCacheRequestMultiError(errors) + } + + return nil +} + +// PutCacheRequestMultiError is an error wrapping multiple validation errors +// returned by PutCacheRequest.ValidateAll() if the designated constraints +// aren't met. +type PutCacheRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PutCacheRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PutCacheRequestMultiError) AllErrors() []error { return m } + +// PutCacheRequestValidationError is the validation error returned by +// PutCacheRequest.Validate if the designated constraints aren't met. +type PutCacheRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PutCacheRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PutCacheRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PutCacheRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PutCacheRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PutCacheRequestValidationError) ErrorName() string { return "PutCacheRequestValidationError" } + +// Error satisfies the builtin error interface +func (e PutCacheRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPutCacheRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PutCacheRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PutCacheRequestValidationError{} + +// Validate checks the field values on PutCacheResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *PutCacheResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on PutCacheResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// PutCacheResponseMultiError, or nil if none found. +func (m *PutCacheResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *PutCacheResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return PutCacheResponseMultiError(errors) + } + + return nil +} + +// PutCacheResponseMultiError is an error wrapping multiple validation errors +// returned by PutCacheResponse.ValidateAll() if the designated constraints +// aren't met. +type PutCacheResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PutCacheResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PutCacheResponseMultiError) AllErrors() []error { return m } + +// PutCacheResponseValidationError is the validation error returned by +// PutCacheResponse.Validate if the designated constraints aren't met. +type PutCacheResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PutCacheResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PutCacheResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PutCacheResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PutCacheResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PutCacheResponseValidationError) ErrorName() string { return "PutCacheResponseValidationError" } + +// Error satisfies the builtin error interface +func (e PutCacheResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPutCacheResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PutCacheResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PutCacheResponseValidationError{} + +// Validate checks the field values on DeleteCacheRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *DeleteCacheRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DeleteCacheRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// DeleteCacheRequestMultiError, or nil if none found. +func (m *DeleteCacheRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *DeleteCacheRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Key + + if len(errors) > 0 { + return DeleteCacheRequestMultiError(errors) + } + + return nil +} + +// DeleteCacheRequestMultiError is an error wrapping multiple validation errors +// returned by DeleteCacheRequest.ValidateAll() if the designated constraints +// aren't met. +type DeleteCacheRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DeleteCacheRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DeleteCacheRequestMultiError) AllErrors() []error { return m } + +// DeleteCacheRequestValidationError is the validation error returned by +// DeleteCacheRequest.Validate if the designated constraints aren't met. +type DeleteCacheRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DeleteCacheRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DeleteCacheRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DeleteCacheRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DeleteCacheRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DeleteCacheRequestValidationError) ErrorName() string { + return "DeleteCacheRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e DeleteCacheRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDeleteCacheRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DeleteCacheRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DeleteCacheRequestValidationError{} + +// Validate checks the field values on DeleteCacheResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *DeleteCacheResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DeleteCacheResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// DeleteCacheResponseMultiError, or nil if none found. +func (m *DeleteCacheResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *DeleteCacheResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return DeleteCacheResponseMultiError(errors) + } + + return nil +} + +// DeleteCacheResponseMultiError is an error wrapping multiple validation +// errors returned by DeleteCacheResponse.ValidateAll() if the designated +// constraints aren't met. +type DeleteCacheResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DeleteCacheResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DeleteCacheResponseMultiError) AllErrors() []error { return m } + +// DeleteCacheResponseValidationError is the validation error returned by +// DeleteCacheResponse.Validate if the designated constraints aren't met. +type DeleteCacheResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DeleteCacheResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DeleteCacheResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DeleteCacheResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DeleteCacheResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DeleteCacheResponseValidationError) ErrorName() string { + return "DeleteCacheResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e DeleteCacheResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDeleteCacheResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DeleteCacheResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DeleteCacheResponseValidationError{} + +// Validate checks the field values on Reservation with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Reservation) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Reservation with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ReservationMultiError, or +// nil if none found. +func (m *Reservation) ValidateAll() error { + return m.validate(true) +} + +func (m *Reservation) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Key + + // no validation rules for OwnerId + + if all { + switch v := interface{}(m.GetHeartbeatInterval()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ReservationValidationError{ + field: "HeartbeatInterval", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ReservationValidationError{ + field: "HeartbeatInterval", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetHeartbeatInterval()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ReservationValidationError{ + field: "HeartbeatInterval", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetExpiresAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ReservationValidationError{ + field: "ExpiresAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ReservationValidationError{ + field: "ExpiresAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetExpiresAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ReservationValidationError{ + field: "ExpiresAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ReservationMultiError(errors) + } + + return nil +} + +// ReservationMultiError is an error wrapping multiple validation errors +// returned by Reservation.ValidateAll() if the designated constraints aren't met. +type ReservationMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ReservationMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ReservationMultiError) AllErrors() []error { return m } + +// ReservationValidationError is the validation error returned by +// Reservation.Validate if the designated constraints aren't met. +type ReservationValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ReservationValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ReservationValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ReservationValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ReservationValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ReservationValidationError) ErrorName() string { return "ReservationValidationError" } + +// Error satisfies the builtin error interface +func (e ReservationValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sReservation.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ReservationValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ReservationValidationError{} + +// Validate checks the field values on GetOrExtendReservationRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetOrExtendReservationRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetOrExtendReservationRequest with +// the rules defined in the proto definition for this message. If any rules +// are violated, the result is a list of violation errors wrapped in +// GetOrExtendReservationRequestMultiError, or nil if none found. +func (m *GetOrExtendReservationRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetOrExtendReservationRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Key + + // no validation rules for OwnerId + + if all { + switch v := interface{}(m.GetHeartbeatInterval()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetOrExtendReservationRequestValidationError{ + field: "HeartbeatInterval", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetOrExtendReservationRequestValidationError{ + field: "HeartbeatInterval", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetHeartbeatInterval()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetOrExtendReservationRequestValidationError{ + field: "HeartbeatInterval", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetOrExtendReservationRequestMultiError(errors) + } + + return nil +} + +// GetOrExtendReservationRequestMultiError is an error wrapping multiple +// validation errors returned by GetOrExtendReservationRequest.ValidateAll() +// if the designated constraints aren't met. +type GetOrExtendReservationRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetOrExtendReservationRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetOrExtendReservationRequestMultiError) AllErrors() []error { return m } + +// GetOrExtendReservationRequestValidationError is the validation error +// returned by GetOrExtendReservationRequest.Validate if the designated +// constraints aren't met. +type GetOrExtendReservationRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetOrExtendReservationRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetOrExtendReservationRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetOrExtendReservationRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetOrExtendReservationRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetOrExtendReservationRequestValidationError) ErrorName() string { + return "GetOrExtendReservationRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e GetOrExtendReservationRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetOrExtendReservationRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetOrExtendReservationRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetOrExtendReservationRequestValidationError{} + +// Validate checks the field values on GetOrExtendReservationResponse with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetOrExtendReservationResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetOrExtendReservationResponse with +// the rules defined in the proto definition for this message. If any rules +// are violated, the result is a list of violation errors wrapped in +// GetOrExtendReservationResponseMultiError, or nil if none found. +func (m *GetOrExtendReservationResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetOrExtendReservationResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetReservation()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetOrExtendReservationResponseValidationError{ + field: "Reservation", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetOrExtendReservationResponseValidationError{ + field: "Reservation", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetReservation()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetOrExtendReservationResponseValidationError{ + field: "Reservation", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetOrExtendReservationResponseMultiError(errors) + } + + return nil +} + +// GetOrExtendReservationResponseMultiError is an error wrapping multiple +// validation errors returned by GetOrExtendReservationResponse.ValidateAll() +// if the designated constraints aren't met. +type GetOrExtendReservationResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetOrExtendReservationResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetOrExtendReservationResponseMultiError) AllErrors() []error { return m } + +// GetOrExtendReservationResponseValidationError is the validation error +// returned by GetOrExtendReservationResponse.Validate if the designated +// constraints aren't met. +type GetOrExtendReservationResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetOrExtendReservationResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetOrExtendReservationResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetOrExtendReservationResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetOrExtendReservationResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetOrExtendReservationResponseValidationError) ErrorName() string { + return "GetOrExtendReservationResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e GetOrExtendReservationResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetOrExtendReservationResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetOrExtendReservationResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetOrExtendReservationResponseValidationError{} + +// Validate checks the field values on ReleaseReservationRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ReleaseReservationRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ReleaseReservationRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ReleaseReservationRequestMultiError, or nil if none found. +func (m *ReleaseReservationRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *ReleaseReservationRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Key + + // no validation rules for OwnerId + + if len(errors) > 0 { + return ReleaseReservationRequestMultiError(errors) + } + + return nil +} + +// ReleaseReservationRequestMultiError is an error wrapping multiple validation +// errors returned by ReleaseReservationRequest.ValidateAll() if the +// designated constraints aren't met. +type ReleaseReservationRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ReleaseReservationRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ReleaseReservationRequestMultiError) AllErrors() []error { return m } + +// ReleaseReservationRequestValidationError is the validation error returned by +// ReleaseReservationRequest.Validate if the designated constraints aren't met. +type ReleaseReservationRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ReleaseReservationRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ReleaseReservationRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ReleaseReservationRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ReleaseReservationRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ReleaseReservationRequestValidationError) ErrorName() string { + return "ReleaseReservationRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e ReleaseReservationRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sReleaseReservationRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ReleaseReservationRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ReleaseReservationRequestValidationError{} + +// Validate checks the field values on ReleaseReservationResponse with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ReleaseReservationResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ReleaseReservationResponse with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ReleaseReservationResponseMultiError, or nil if none found. +func (m *ReleaseReservationResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *ReleaseReservationResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return ReleaseReservationResponseMultiError(errors) + } + + return nil +} + +// ReleaseReservationResponseMultiError is an error wrapping multiple +// validation errors returned by ReleaseReservationResponse.ValidateAll() if +// the designated constraints aren't met. +type ReleaseReservationResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ReleaseReservationResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ReleaseReservationResponseMultiError) AllErrors() []error { return m } + +// ReleaseReservationResponseValidationError is the validation error returned +// by ReleaseReservationResponse.Validate if the designated constraints aren't met. +type ReleaseReservationResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ReleaseReservationResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ReleaseReservationResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ReleaseReservationResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ReleaseReservationResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ReleaseReservationResponseValidationError) ErrorName() string { + return "ReleaseReservationResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e ReleaseReservationResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sReleaseReservationResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ReleaseReservationResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ReleaseReservationResponseValidationError{} diff --git a/gen/go/flyteidl2/cacheservice/cacheservice_grpc.pb.go b/gen/go/flyteidl2/cacheservice/cacheservice_grpc.pb.go new file mode 100644 index 0000000000..dcf1587e3e --- /dev/null +++ b/gen/go/flyteidl2/cacheservice/cacheservice_grpc.pb.go @@ -0,0 +1,265 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: flyteidl2/cacheservice/cacheservice.proto + +package cacheservice + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + CacheService_Get_FullMethodName = "/flyteidl2.cacheservice.CacheService/Get" + CacheService_Put_FullMethodName = "/flyteidl2.cacheservice.CacheService/Put" + CacheService_Delete_FullMethodName = "/flyteidl2.cacheservice.CacheService/Delete" + CacheService_GetOrExtendReservation_FullMethodName = "/flyteidl2.cacheservice.CacheService/GetOrExtendReservation" + CacheService_ReleaseReservation_FullMethodName = "/flyteidl2.cacheservice.CacheService/ReleaseReservation" +) + +// CacheServiceClient is the client API for CacheService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type CacheServiceClient interface { + // Retrieves cached data by key. + Get(ctx context.Context, in *GetCacheRequest, opts ...grpc.CallOption) (*GetCacheResponse, error) + // Stores or updates cached data by key. + Put(ctx context.Context, in *PutCacheRequest, opts ...grpc.CallOption) (*PutCacheResponse, error) + // Deletes cached data by key. + Delete(ctx context.Context, in *DeleteCacheRequest, opts ...grpc.CallOption) (*DeleteCacheResponse, error) + // Get or extend a reservation for a cache key + GetOrExtendReservation(ctx context.Context, in *GetOrExtendReservationRequest, opts ...grpc.CallOption) (*GetOrExtendReservationResponse, error) + // Release the reservation for a cache key + ReleaseReservation(ctx context.Context, in *ReleaseReservationRequest, opts ...grpc.CallOption) (*ReleaseReservationResponse, error) +} + +type cacheServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewCacheServiceClient(cc grpc.ClientConnInterface) CacheServiceClient { + return &cacheServiceClient{cc} +} + +func (c *cacheServiceClient) Get(ctx context.Context, in *GetCacheRequest, opts ...grpc.CallOption) (*GetCacheResponse, error) { + out := new(GetCacheResponse) + err := c.cc.Invoke(ctx, CacheService_Get_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cacheServiceClient) Put(ctx context.Context, in *PutCacheRequest, opts ...grpc.CallOption) (*PutCacheResponse, error) { + out := new(PutCacheResponse) + err := c.cc.Invoke(ctx, CacheService_Put_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cacheServiceClient) Delete(ctx context.Context, in *DeleteCacheRequest, opts ...grpc.CallOption) (*DeleteCacheResponse, error) { + out := new(DeleteCacheResponse) + err := c.cc.Invoke(ctx, CacheService_Delete_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cacheServiceClient) GetOrExtendReservation(ctx context.Context, in *GetOrExtendReservationRequest, opts ...grpc.CallOption) (*GetOrExtendReservationResponse, error) { + out := new(GetOrExtendReservationResponse) + err := c.cc.Invoke(ctx, CacheService_GetOrExtendReservation_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cacheServiceClient) ReleaseReservation(ctx context.Context, in *ReleaseReservationRequest, opts ...grpc.CallOption) (*ReleaseReservationResponse, error) { + out := new(ReleaseReservationResponse) + err := c.cc.Invoke(ctx, CacheService_ReleaseReservation_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// CacheServiceServer is the server API for CacheService service. +// All implementations should embed UnimplementedCacheServiceServer +// for forward compatibility +type CacheServiceServer interface { + // Retrieves cached data by key. + Get(context.Context, *GetCacheRequest) (*GetCacheResponse, error) + // Stores or updates cached data by key. + Put(context.Context, *PutCacheRequest) (*PutCacheResponse, error) + // Deletes cached data by key. + Delete(context.Context, *DeleteCacheRequest) (*DeleteCacheResponse, error) + // Get or extend a reservation for a cache key + GetOrExtendReservation(context.Context, *GetOrExtendReservationRequest) (*GetOrExtendReservationResponse, error) + // Release the reservation for a cache key + ReleaseReservation(context.Context, *ReleaseReservationRequest) (*ReleaseReservationResponse, error) +} + +// UnimplementedCacheServiceServer should be embedded to have forward compatible implementations. +type UnimplementedCacheServiceServer struct { +} + +func (UnimplementedCacheServiceServer) Get(context.Context, *GetCacheRequest) (*GetCacheResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Get not implemented") +} +func (UnimplementedCacheServiceServer) Put(context.Context, *PutCacheRequest) (*PutCacheResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Put not implemented") +} +func (UnimplementedCacheServiceServer) Delete(context.Context, *DeleteCacheRequest) (*DeleteCacheResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented") +} +func (UnimplementedCacheServiceServer) GetOrExtendReservation(context.Context, *GetOrExtendReservationRequest) (*GetOrExtendReservationResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetOrExtendReservation not implemented") +} +func (UnimplementedCacheServiceServer) ReleaseReservation(context.Context, *ReleaseReservationRequest) (*ReleaseReservationResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ReleaseReservation not implemented") +} + +// UnsafeCacheServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to CacheServiceServer will +// result in compilation errors. +type UnsafeCacheServiceServer interface { + mustEmbedUnimplementedCacheServiceServer() +} + +func RegisterCacheServiceServer(s grpc.ServiceRegistrar, srv CacheServiceServer) { + s.RegisterService(&CacheService_ServiceDesc, srv) +} + +func _CacheService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetCacheRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CacheServiceServer).Get(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: CacheService_Get_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CacheServiceServer).Get(ctx, req.(*GetCacheRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _CacheService_Put_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PutCacheRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CacheServiceServer).Put(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: CacheService_Put_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CacheServiceServer).Put(ctx, req.(*PutCacheRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _CacheService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteCacheRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CacheServiceServer).Delete(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: CacheService_Delete_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CacheServiceServer).Delete(ctx, req.(*DeleteCacheRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _CacheService_GetOrExtendReservation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetOrExtendReservationRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CacheServiceServer).GetOrExtendReservation(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: CacheService_GetOrExtendReservation_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CacheServiceServer).GetOrExtendReservation(ctx, req.(*GetOrExtendReservationRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _CacheService_ReleaseReservation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ReleaseReservationRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CacheServiceServer).ReleaseReservation(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: CacheService_ReleaseReservation_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CacheServiceServer).ReleaseReservation(ctx, req.(*ReleaseReservationRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// CacheService_ServiceDesc is the grpc.ServiceDesc for CacheService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var CacheService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.cacheservice.CacheService", + HandlerType: (*CacheServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Get", + Handler: _CacheService_Get_Handler, + }, + { + MethodName: "Put", + Handler: _CacheService_Put_Handler, + }, + { + MethodName: "Delete", + Handler: _CacheService_Delete_Handler, + }, + { + MethodName: "GetOrExtendReservation", + Handler: _CacheService_GetOrExtendReservation_Handler, + }, + { + MethodName: "ReleaseReservation", + Handler: _CacheService_ReleaseReservation_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "flyteidl2/cacheservice/cacheservice.proto", +} diff --git a/gen/go/flyteidl2/cacheservice/cacheserviceconnect/cacheservice.connect.go b/gen/go/flyteidl2/cacheservice/cacheserviceconnect/cacheservice.connect.go new file mode 100644 index 0000000000..ca9ca381dc --- /dev/null +++ b/gen/go/flyteidl2/cacheservice/cacheserviceconnect/cacheservice.connect.go @@ -0,0 +1,240 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: flyteidl2/cacheservice/cacheservice.proto + +package cacheserviceconnect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + cacheservice "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/cacheservice" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // CacheServiceName is the fully-qualified name of the CacheService service. + CacheServiceName = "flyteidl2.cacheservice.CacheService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // CacheServiceGetProcedure is the fully-qualified name of the CacheService's Get RPC. + CacheServiceGetProcedure = "/flyteidl2.cacheservice.CacheService/Get" + // CacheServicePutProcedure is the fully-qualified name of the CacheService's Put RPC. + CacheServicePutProcedure = "/flyteidl2.cacheservice.CacheService/Put" + // CacheServiceDeleteProcedure is the fully-qualified name of the CacheService's Delete RPC. + CacheServiceDeleteProcedure = "/flyteidl2.cacheservice.CacheService/Delete" + // CacheServiceGetOrExtendReservationProcedure is the fully-qualified name of the CacheService's + // GetOrExtendReservation RPC. + CacheServiceGetOrExtendReservationProcedure = "/flyteidl2.cacheservice.CacheService/GetOrExtendReservation" + // CacheServiceReleaseReservationProcedure is the fully-qualified name of the CacheService's + // ReleaseReservation RPC. + CacheServiceReleaseReservationProcedure = "/flyteidl2.cacheservice.CacheService/ReleaseReservation" +) + +// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. +var ( + cacheServiceServiceDescriptor = cacheservice.File_flyteidl2_cacheservice_cacheservice_proto.Services().ByName("CacheService") + cacheServiceGetMethodDescriptor = cacheServiceServiceDescriptor.Methods().ByName("Get") + cacheServicePutMethodDescriptor = cacheServiceServiceDescriptor.Methods().ByName("Put") + cacheServiceDeleteMethodDescriptor = cacheServiceServiceDescriptor.Methods().ByName("Delete") + cacheServiceGetOrExtendReservationMethodDescriptor = cacheServiceServiceDescriptor.Methods().ByName("GetOrExtendReservation") + cacheServiceReleaseReservationMethodDescriptor = cacheServiceServiceDescriptor.Methods().ByName("ReleaseReservation") +) + +// CacheServiceClient is a client for the flyteidl2.cacheservice.CacheService service. +type CacheServiceClient interface { + // Retrieves cached data by key. + Get(context.Context, *connect.Request[cacheservice.GetCacheRequest]) (*connect.Response[cacheservice.GetCacheResponse], error) + // Stores or updates cached data by key. + Put(context.Context, *connect.Request[cacheservice.PutCacheRequest]) (*connect.Response[cacheservice.PutCacheResponse], error) + // Deletes cached data by key. + Delete(context.Context, *connect.Request[cacheservice.DeleteCacheRequest]) (*connect.Response[cacheservice.DeleteCacheResponse], error) + // Get or extend a reservation for a cache key + GetOrExtendReservation(context.Context, *connect.Request[cacheservice.GetOrExtendReservationRequest]) (*connect.Response[cacheservice.GetOrExtendReservationResponse], error) + // Release the reservation for a cache key + ReleaseReservation(context.Context, *connect.Request[cacheservice.ReleaseReservationRequest]) (*connect.Response[cacheservice.ReleaseReservationResponse], error) +} + +// NewCacheServiceClient constructs a client for the flyteidl2.cacheservice.CacheService service. By +// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, +// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the +// connect.WithGRPC() or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewCacheServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) CacheServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &cacheServiceClient{ + get: connect.NewClient[cacheservice.GetCacheRequest, cacheservice.GetCacheResponse]( + httpClient, + baseURL+CacheServiceGetProcedure, + connect.WithSchema(cacheServiceGetMethodDescriptor), + connect.WithClientOptions(opts...), + ), + put: connect.NewClient[cacheservice.PutCacheRequest, cacheservice.PutCacheResponse]( + httpClient, + baseURL+CacheServicePutProcedure, + connect.WithSchema(cacheServicePutMethodDescriptor), + connect.WithClientOptions(opts...), + ), + delete: connect.NewClient[cacheservice.DeleteCacheRequest, cacheservice.DeleteCacheResponse]( + httpClient, + baseURL+CacheServiceDeleteProcedure, + connect.WithSchema(cacheServiceDeleteMethodDescriptor), + connect.WithClientOptions(opts...), + ), + getOrExtendReservation: connect.NewClient[cacheservice.GetOrExtendReservationRequest, cacheservice.GetOrExtendReservationResponse]( + httpClient, + baseURL+CacheServiceGetOrExtendReservationProcedure, + connect.WithSchema(cacheServiceGetOrExtendReservationMethodDescriptor), + connect.WithClientOptions(opts...), + ), + releaseReservation: connect.NewClient[cacheservice.ReleaseReservationRequest, cacheservice.ReleaseReservationResponse]( + httpClient, + baseURL+CacheServiceReleaseReservationProcedure, + connect.WithSchema(cacheServiceReleaseReservationMethodDescriptor), + connect.WithClientOptions(opts...), + ), + } +} + +// cacheServiceClient implements CacheServiceClient. +type cacheServiceClient struct { + get *connect.Client[cacheservice.GetCacheRequest, cacheservice.GetCacheResponse] + put *connect.Client[cacheservice.PutCacheRequest, cacheservice.PutCacheResponse] + delete *connect.Client[cacheservice.DeleteCacheRequest, cacheservice.DeleteCacheResponse] + getOrExtendReservation *connect.Client[cacheservice.GetOrExtendReservationRequest, cacheservice.GetOrExtendReservationResponse] + releaseReservation *connect.Client[cacheservice.ReleaseReservationRequest, cacheservice.ReleaseReservationResponse] +} + +// Get calls flyteidl2.cacheservice.CacheService.Get. +func (c *cacheServiceClient) Get(ctx context.Context, req *connect.Request[cacheservice.GetCacheRequest]) (*connect.Response[cacheservice.GetCacheResponse], error) { + return c.get.CallUnary(ctx, req) +} + +// Put calls flyteidl2.cacheservice.CacheService.Put. +func (c *cacheServiceClient) Put(ctx context.Context, req *connect.Request[cacheservice.PutCacheRequest]) (*connect.Response[cacheservice.PutCacheResponse], error) { + return c.put.CallUnary(ctx, req) +} + +// Delete calls flyteidl2.cacheservice.CacheService.Delete. +func (c *cacheServiceClient) Delete(ctx context.Context, req *connect.Request[cacheservice.DeleteCacheRequest]) (*connect.Response[cacheservice.DeleteCacheResponse], error) { + return c.delete.CallUnary(ctx, req) +} + +// GetOrExtendReservation calls flyteidl2.cacheservice.CacheService.GetOrExtendReservation. +func (c *cacheServiceClient) GetOrExtendReservation(ctx context.Context, req *connect.Request[cacheservice.GetOrExtendReservationRequest]) (*connect.Response[cacheservice.GetOrExtendReservationResponse], error) { + return c.getOrExtendReservation.CallUnary(ctx, req) +} + +// ReleaseReservation calls flyteidl2.cacheservice.CacheService.ReleaseReservation. +func (c *cacheServiceClient) ReleaseReservation(ctx context.Context, req *connect.Request[cacheservice.ReleaseReservationRequest]) (*connect.Response[cacheservice.ReleaseReservationResponse], error) { + return c.releaseReservation.CallUnary(ctx, req) +} + +// CacheServiceHandler is an implementation of the flyteidl2.cacheservice.CacheService service. +type CacheServiceHandler interface { + // Retrieves cached data by key. + Get(context.Context, *connect.Request[cacheservice.GetCacheRequest]) (*connect.Response[cacheservice.GetCacheResponse], error) + // Stores or updates cached data by key. + Put(context.Context, *connect.Request[cacheservice.PutCacheRequest]) (*connect.Response[cacheservice.PutCacheResponse], error) + // Deletes cached data by key. + Delete(context.Context, *connect.Request[cacheservice.DeleteCacheRequest]) (*connect.Response[cacheservice.DeleteCacheResponse], error) + // Get or extend a reservation for a cache key + GetOrExtendReservation(context.Context, *connect.Request[cacheservice.GetOrExtendReservationRequest]) (*connect.Response[cacheservice.GetOrExtendReservationResponse], error) + // Release the reservation for a cache key + ReleaseReservation(context.Context, *connect.Request[cacheservice.ReleaseReservationRequest]) (*connect.Response[cacheservice.ReleaseReservationResponse], error) +} + +// NewCacheServiceHandler builds an HTTP handler from the service implementation. It returns the +// path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewCacheServiceHandler(svc CacheServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + cacheServiceGetHandler := connect.NewUnaryHandler( + CacheServiceGetProcedure, + svc.Get, + connect.WithSchema(cacheServiceGetMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + cacheServicePutHandler := connect.NewUnaryHandler( + CacheServicePutProcedure, + svc.Put, + connect.WithSchema(cacheServicePutMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + cacheServiceDeleteHandler := connect.NewUnaryHandler( + CacheServiceDeleteProcedure, + svc.Delete, + connect.WithSchema(cacheServiceDeleteMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + cacheServiceGetOrExtendReservationHandler := connect.NewUnaryHandler( + CacheServiceGetOrExtendReservationProcedure, + svc.GetOrExtendReservation, + connect.WithSchema(cacheServiceGetOrExtendReservationMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + cacheServiceReleaseReservationHandler := connect.NewUnaryHandler( + CacheServiceReleaseReservationProcedure, + svc.ReleaseReservation, + connect.WithSchema(cacheServiceReleaseReservationMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.cacheservice.CacheService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case CacheServiceGetProcedure: + cacheServiceGetHandler.ServeHTTP(w, r) + case CacheServicePutProcedure: + cacheServicePutHandler.ServeHTTP(w, r) + case CacheServiceDeleteProcedure: + cacheServiceDeleteHandler.ServeHTTP(w, r) + case CacheServiceGetOrExtendReservationProcedure: + cacheServiceGetOrExtendReservationHandler.ServeHTTP(w, r) + case CacheServiceReleaseReservationProcedure: + cacheServiceReleaseReservationHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedCacheServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedCacheServiceHandler struct{} + +func (UnimplementedCacheServiceHandler) Get(context.Context, *connect.Request[cacheservice.GetCacheRequest]) (*connect.Response[cacheservice.GetCacheResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.cacheservice.CacheService.Get is not implemented")) +} + +func (UnimplementedCacheServiceHandler) Put(context.Context, *connect.Request[cacheservice.PutCacheRequest]) (*connect.Response[cacheservice.PutCacheResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.cacheservice.CacheService.Put is not implemented")) +} + +func (UnimplementedCacheServiceHandler) Delete(context.Context, *connect.Request[cacheservice.DeleteCacheRequest]) (*connect.Response[cacheservice.DeleteCacheResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.cacheservice.CacheService.Delete is not implemented")) +} + +func (UnimplementedCacheServiceHandler) GetOrExtendReservation(context.Context, *connect.Request[cacheservice.GetOrExtendReservationRequest]) (*connect.Response[cacheservice.GetOrExtendReservationResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.cacheservice.CacheService.GetOrExtendReservation is not implemented")) +} + +func (UnimplementedCacheServiceHandler) ReleaseReservation(context.Context, *connect.Request[cacheservice.ReleaseReservationRequest]) (*connect.Response[cacheservice.ReleaseReservationResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.cacheservice.CacheService.ReleaseReservation is not implemented")) +} diff --git a/gen/go/flyteidl2/cacheservice/v2/cacheservice.pb.go b/gen/go/flyteidl2/cacheservice/v2/cacheservice.pb.go new file mode 100644 index 0000000000..f64f140af1 --- /dev/null +++ b/gen/go/flyteidl2/cacheservice/v2/cacheservice.pb.go @@ -0,0 +1,658 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/cacheservice/v2/cacheservice.proto + +package v2 + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + cacheservice "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/cacheservice" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Identifier for cache operations, including org, project, and domain. +// This is used to scope cache operations to specific organizational contexts. +type Identifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Org string `protobuf:"bytes,1,opt,name=org,proto3" json:"org,omitempty"` // Organization identifier + Project string `protobuf:"bytes,2,opt,name=project,proto3" json:"project,omitempty"` // Project identifier + Domain string `protobuf:"bytes,3,opt,name=domain,proto3" json:"domain,omitempty"` // Domain identifier +} + +func (x *Identifier) Reset() { + *x = Identifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Identifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Identifier) ProtoMessage() {} + +func (x *Identifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Identifier.ProtoReflect.Descriptor instead. +func (*Identifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_v2_cacheservice_proto_rawDescGZIP(), []int{0} +} + +func (x *Identifier) GetOrg() string { + if x != nil { + return x.Org + } + return "" +} + +func (x *Identifier) GetProject() string { + if x != nil { + return x.Project + } + return "" +} + +func (x *Identifier) GetDomain() string { + if x != nil { + return x.Domain + } + return "" +} + +// Request to retrieve cached data by key. +type GetCacheRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + BaseRequest *cacheservice.GetCacheRequest `protobuf:"bytes,1,opt,name=base_request,json=baseRequest,proto3" json:"base_request,omitempty"` + Identifier *Identifier `protobuf:"bytes,2,opt,name=identifier,proto3" json:"identifier,omitempty"` // Identifier for the cache operation +} + +func (x *GetCacheRequest) Reset() { + *x = GetCacheRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetCacheRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetCacheRequest) ProtoMessage() {} + +func (x *GetCacheRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetCacheRequest.ProtoReflect.Descriptor instead. +func (*GetCacheRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_v2_cacheservice_proto_rawDescGZIP(), []int{1} +} + +func (x *GetCacheRequest) GetBaseRequest() *cacheservice.GetCacheRequest { + if x != nil { + return x.BaseRequest + } + return nil +} + +func (x *GetCacheRequest) GetIdentifier() *Identifier { + if x != nil { + return x.Identifier + } + return nil +} + +// Request to store/update cached data by key. +type PutCacheRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + BaseRequest *cacheservice.PutCacheRequest `protobuf:"bytes,1,opt,name=base_request,json=baseRequest,proto3" json:"base_request,omitempty"` + Identifier *Identifier `protobuf:"bytes,2,opt,name=identifier,proto3" json:"identifier,omitempty"` // Identifier for the cache operation +} + +func (x *PutCacheRequest) Reset() { + *x = PutCacheRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PutCacheRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PutCacheRequest) ProtoMessage() {} + +func (x *PutCacheRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PutCacheRequest.ProtoReflect.Descriptor instead. +func (*PutCacheRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_v2_cacheservice_proto_rawDescGZIP(), []int{2} +} + +func (x *PutCacheRequest) GetBaseRequest() *cacheservice.PutCacheRequest { + if x != nil { + return x.BaseRequest + } + return nil +} + +func (x *PutCacheRequest) GetIdentifier() *Identifier { + if x != nil { + return x.Identifier + } + return nil +} + +// Request to delete cached data by key. +type DeleteCacheRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + BaseRequest *cacheservice.DeleteCacheRequest `protobuf:"bytes,1,opt,name=base_request,json=baseRequest,proto3" json:"base_request,omitempty"` + Identifier *Identifier `protobuf:"bytes,2,opt,name=identifier,proto3" json:"identifier,omitempty"` // Identifier for the cache operation +} + +func (x *DeleteCacheRequest) Reset() { + *x = DeleteCacheRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteCacheRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteCacheRequest) ProtoMessage() {} + +func (x *DeleteCacheRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteCacheRequest.ProtoReflect.Descriptor instead. +func (*DeleteCacheRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_v2_cacheservice_proto_rawDescGZIP(), []int{3} +} + +func (x *DeleteCacheRequest) GetBaseRequest() *cacheservice.DeleteCacheRequest { + if x != nil { + return x.BaseRequest + } + return nil +} + +func (x *DeleteCacheRequest) GetIdentifier() *Identifier { + if x != nil { + return x.Identifier + } + return nil +} + +// Request to get or extend a reservation for a cache key +type GetOrExtendReservationRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + BaseRequest *cacheservice.GetOrExtendReservationRequest `protobuf:"bytes,1,opt,name=base_request,json=baseRequest,proto3" json:"base_request,omitempty"` + Identifier *Identifier `protobuf:"bytes,2,opt,name=identifier,proto3" json:"identifier,omitempty"` // Identifier for the cache operation +} + +func (x *GetOrExtendReservationRequest) Reset() { + *x = GetOrExtendReservationRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOrExtendReservationRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOrExtendReservationRequest) ProtoMessage() {} + +func (x *GetOrExtendReservationRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetOrExtendReservationRequest.ProtoReflect.Descriptor instead. +func (*GetOrExtendReservationRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_v2_cacheservice_proto_rawDescGZIP(), []int{4} +} + +func (x *GetOrExtendReservationRequest) GetBaseRequest() *cacheservice.GetOrExtendReservationRequest { + if x != nil { + return x.BaseRequest + } + return nil +} + +func (x *GetOrExtendReservationRequest) GetIdentifier() *Identifier { + if x != nil { + return x.Identifier + } + return nil +} + +// Request to release the reservation for a cache key +type ReleaseReservationRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + BaseRequest *cacheservice.ReleaseReservationRequest `protobuf:"bytes,1,opt,name=base_request,json=baseRequest,proto3" json:"base_request,omitempty"` + Identifier *Identifier `protobuf:"bytes,2,opt,name=identifier,proto3" json:"identifier,omitempty"` // Identifier for the cache operation +} + +func (x *ReleaseReservationRequest) Reset() { + *x = ReleaseReservationRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ReleaseReservationRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReleaseReservationRequest) ProtoMessage() {} + +func (x *ReleaseReservationRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReleaseReservationRequest.ProtoReflect.Descriptor instead. +func (*ReleaseReservationRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_cacheservice_v2_cacheservice_proto_rawDescGZIP(), []int{5} +} + +func (x *ReleaseReservationRequest) GetBaseRequest() *cacheservice.ReleaseReservationRequest { + if x != nil { + return x.BaseRequest + } + return nil +} + +func (x *ReleaseReservationRequest) GetIdentifier() *Identifier { + if x != nil { + return x.Identifier + } + return nil +} + +var File_flyteidl2_cacheservice_v2_cacheservice_proto protoreflect.FileDescriptor + +var file_flyteidl2_cacheservice_v2_cacheservice_proto_rawDesc = []byte{ + 0x0a, 0x2c, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x61, 0x63, 0x68, + 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x63, 0x61, 0x63, 0x68, + 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x19, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x76, 0x32, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x29, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2f, 0x63, + 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x22, 0x6b, 0x0a, 0x0a, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, + 0x19, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, + 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x21, 0x0a, 0x07, 0x70, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, + 0x72, 0x02, 0x10, 0x01, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, 0x0a, + 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, + 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x22, 0xac, + 0x01, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x4a, 0x0a, 0x0c, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x52, 0x0b, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x4d, + 0x0a, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, + 0x01, 0x52, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x22, 0xac, 0x01, + 0x0a, 0x0f, 0x50, 0x75, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x4a, 0x0a, 0x0c, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x2e, 0x50, 0x75, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x52, 0x0b, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x4d, 0x0a, + 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, + 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, + 0x52, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x22, 0xb2, 0x01, 0x0a, + 0x12, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x4d, 0x0a, 0x0c, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x72, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0b, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x4d, 0x0a, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, + 0x76, 0x32, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, + 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x22, 0xc8, 0x01, 0x0a, 0x1d, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x45, 0x78, 0x74, 0x65, 0x6e, + 0x64, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x58, 0x0a, 0x0c, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x72, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x52, 0x65, + 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x52, 0x0b, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x4d, 0x0a, + 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, + 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, + 0x52, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x22, 0xc0, 0x01, 0x0a, + 0x19, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x54, 0x0a, 0x0c, 0x62, 0x61, + 0x73, 0x65, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x31, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, + 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, + 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x52, 0x0b, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x4d, 0x0a, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x76, 0x32, + 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, + 0xc8, 0x01, 0x01, 0x52, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x32, + 0xbb, 0x04, 0x0a, 0x0c, 0x43, 0x61, 0x63, 0x68, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x12, 0x5b, 0x0a, 0x03, 0x47, 0x65, 0x74, 0x12, 0x2a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x2e, 0x76, 0x32, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x47, 0x65, 0x74, + 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5b, 0x0a, + 0x03, 0x50, 0x75, 0x74, 0x12, 0x2a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x76, 0x32, + 0x2e, 0x50, 0x75, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, + 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x50, 0x75, 0x74, 0x43, 0x61, 0x63, + 0x68, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x64, 0x0a, 0x06, 0x44, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x12, 0x2d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x76, 0x32, + 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x6c, + 0x65, 0x74, 0x65, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x8a, 0x01, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, + 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x38, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, + 0x76, 0x69, 0x63, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x45, 0x78, 0x74, + 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x36, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x47, + 0x65, 0x74, 0x4f, 0x72, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7e, 0x0a, + 0x12, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x34, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x76, 0x32, 0x2e, + 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x2e, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0xf9, 0x01, + 0x0a, 0x1d, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x76, 0x32, 0x42, + 0x11, 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, + 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x3d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x2f, 0x76, 0x32, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x19, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, + 0x76, 0x69, 0x63, 0x65, 0x2e, 0x56, 0x32, 0xca, 0x02, 0x19, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x5c, 0x56, 0x32, 0xe2, 0x02, 0x25, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, + 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5c, 0x56, 0x32, 0x5c, + 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1b, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x3a, 0x3a, 0x56, 0x32, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, +} + +var ( + file_flyteidl2_cacheservice_v2_cacheservice_proto_rawDescOnce sync.Once + file_flyteidl2_cacheservice_v2_cacheservice_proto_rawDescData = file_flyteidl2_cacheservice_v2_cacheservice_proto_rawDesc +) + +func file_flyteidl2_cacheservice_v2_cacheservice_proto_rawDescGZIP() []byte { + file_flyteidl2_cacheservice_v2_cacheservice_proto_rawDescOnce.Do(func() { + file_flyteidl2_cacheservice_v2_cacheservice_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_cacheservice_v2_cacheservice_proto_rawDescData) + }) + return file_flyteidl2_cacheservice_v2_cacheservice_proto_rawDescData +} + +var file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes = make([]protoimpl.MessageInfo, 6) +var file_flyteidl2_cacheservice_v2_cacheservice_proto_goTypes = []interface{}{ + (*Identifier)(nil), // 0: flyteidl2.cacheservice.v2.Identifier + (*GetCacheRequest)(nil), // 1: flyteidl2.cacheservice.v2.GetCacheRequest + (*PutCacheRequest)(nil), // 2: flyteidl2.cacheservice.v2.PutCacheRequest + (*DeleteCacheRequest)(nil), // 3: flyteidl2.cacheservice.v2.DeleteCacheRequest + (*GetOrExtendReservationRequest)(nil), // 4: flyteidl2.cacheservice.v2.GetOrExtendReservationRequest + (*ReleaseReservationRequest)(nil), // 5: flyteidl2.cacheservice.v2.ReleaseReservationRequest + (*cacheservice.GetCacheRequest)(nil), // 6: flyteidl2.cacheservice.GetCacheRequest + (*cacheservice.PutCacheRequest)(nil), // 7: flyteidl2.cacheservice.PutCacheRequest + (*cacheservice.DeleteCacheRequest)(nil), // 8: flyteidl2.cacheservice.DeleteCacheRequest + (*cacheservice.GetOrExtendReservationRequest)(nil), // 9: flyteidl2.cacheservice.GetOrExtendReservationRequest + (*cacheservice.ReleaseReservationRequest)(nil), // 10: flyteidl2.cacheservice.ReleaseReservationRequest + (*cacheservice.GetCacheResponse)(nil), // 11: flyteidl2.cacheservice.GetCacheResponse + (*cacheservice.PutCacheResponse)(nil), // 12: flyteidl2.cacheservice.PutCacheResponse + (*cacheservice.DeleteCacheResponse)(nil), // 13: flyteidl2.cacheservice.DeleteCacheResponse + (*cacheservice.GetOrExtendReservationResponse)(nil), // 14: flyteidl2.cacheservice.GetOrExtendReservationResponse + (*cacheservice.ReleaseReservationResponse)(nil), // 15: flyteidl2.cacheservice.ReleaseReservationResponse +} +var file_flyteidl2_cacheservice_v2_cacheservice_proto_depIdxs = []int32{ + 6, // 0: flyteidl2.cacheservice.v2.GetCacheRequest.base_request:type_name -> flyteidl2.cacheservice.GetCacheRequest + 0, // 1: flyteidl2.cacheservice.v2.GetCacheRequest.identifier:type_name -> flyteidl2.cacheservice.v2.Identifier + 7, // 2: flyteidl2.cacheservice.v2.PutCacheRequest.base_request:type_name -> flyteidl2.cacheservice.PutCacheRequest + 0, // 3: flyteidl2.cacheservice.v2.PutCacheRequest.identifier:type_name -> flyteidl2.cacheservice.v2.Identifier + 8, // 4: flyteidl2.cacheservice.v2.DeleteCacheRequest.base_request:type_name -> flyteidl2.cacheservice.DeleteCacheRequest + 0, // 5: flyteidl2.cacheservice.v2.DeleteCacheRequest.identifier:type_name -> flyteidl2.cacheservice.v2.Identifier + 9, // 6: flyteidl2.cacheservice.v2.GetOrExtendReservationRequest.base_request:type_name -> flyteidl2.cacheservice.GetOrExtendReservationRequest + 0, // 7: flyteidl2.cacheservice.v2.GetOrExtendReservationRequest.identifier:type_name -> flyteidl2.cacheservice.v2.Identifier + 10, // 8: flyteidl2.cacheservice.v2.ReleaseReservationRequest.base_request:type_name -> flyteidl2.cacheservice.ReleaseReservationRequest + 0, // 9: flyteidl2.cacheservice.v2.ReleaseReservationRequest.identifier:type_name -> flyteidl2.cacheservice.v2.Identifier + 1, // 10: flyteidl2.cacheservice.v2.CacheService.Get:input_type -> flyteidl2.cacheservice.v2.GetCacheRequest + 2, // 11: flyteidl2.cacheservice.v2.CacheService.Put:input_type -> flyteidl2.cacheservice.v2.PutCacheRequest + 3, // 12: flyteidl2.cacheservice.v2.CacheService.Delete:input_type -> flyteidl2.cacheservice.v2.DeleteCacheRequest + 4, // 13: flyteidl2.cacheservice.v2.CacheService.GetOrExtendReservation:input_type -> flyteidl2.cacheservice.v2.GetOrExtendReservationRequest + 5, // 14: flyteidl2.cacheservice.v2.CacheService.ReleaseReservation:input_type -> flyteidl2.cacheservice.v2.ReleaseReservationRequest + 11, // 15: flyteidl2.cacheservice.v2.CacheService.Get:output_type -> flyteidl2.cacheservice.GetCacheResponse + 12, // 16: flyteidl2.cacheservice.v2.CacheService.Put:output_type -> flyteidl2.cacheservice.PutCacheResponse + 13, // 17: flyteidl2.cacheservice.v2.CacheService.Delete:output_type -> flyteidl2.cacheservice.DeleteCacheResponse + 14, // 18: flyteidl2.cacheservice.v2.CacheService.GetOrExtendReservation:output_type -> flyteidl2.cacheservice.GetOrExtendReservationResponse + 15, // 19: flyteidl2.cacheservice.v2.CacheService.ReleaseReservation:output_type -> flyteidl2.cacheservice.ReleaseReservationResponse + 15, // [15:20] is the sub-list for method output_type + 10, // [10:15] is the sub-list for method input_type + 10, // [10:10] is the sub-list for extension type_name + 10, // [10:10] is the sub-list for extension extendee + 0, // [0:10] is the sub-list for field type_name +} + +func init() { file_flyteidl2_cacheservice_v2_cacheservice_proto_init() } +func file_flyteidl2_cacheservice_v2_cacheservice_proto_init() { + if File_flyteidl2_cacheservice_v2_cacheservice_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Identifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetCacheRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PutCacheRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteCacheRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOrExtendReservationRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ReleaseReservationRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_cacheservice_v2_cacheservice_proto_rawDesc, + NumEnums: 0, + NumMessages: 6, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_flyteidl2_cacheservice_v2_cacheservice_proto_goTypes, + DependencyIndexes: file_flyteidl2_cacheservice_v2_cacheservice_proto_depIdxs, + MessageInfos: file_flyteidl2_cacheservice_v2_cacheservice_proto_msgTypes, + }.Build() + File_flyteidl2_cacheservice_v2_cacheservice_proto = out.File + file_flyteidl2_cacheservice_v2_cacheservice_proto_rawDesc = nil + file_flyteidl2_cacheservice_v2_cacheservice_proto_goTypes = nil + file_flyteidl2_cacheservice_v2_cacheservice_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/cacheservice/v2/cacheservice.pb.validate.go b/gen/go/flyteidl2/cacheservice/v2/cacheservice.pb.validate.go new file mode 100644 index 0000000000..d0209a063b --- /dev/null +++ b/gen/go/flyteidl2/cacheservice/v2/cacheservice.pb.validate.go @@ -0,0 +1,938 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/cacheservice/v2/cacheservice.proto + +package v2 + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on Identifier with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Identifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Identifier with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in IdentifierMultiError, or +// nil if none found. +func (m *Identifier) ValidateAll() error { + return m.validate(true) +} + +func (m *Identifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Org + + // no validation rules for Project + + // no validation rules for Domain + + if len(errors) > 0 { + return IdentifierMultiError(errors) + } + + return nil +} + +// IdentifierMultiError is an error wrapping multiple validation errors +// returned by Identifier.ValidateAll() if the designated constraints aren't met. +type IdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m IdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m IdentifierMultiError) AllErrors() []error { return m } + +// IdentifierValidationError is the validation error returned by +// Identifier.Validate if the designated constraints aren't met. +type IdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e IdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e IdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e IdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e IdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e IdentifierValidationError) ErrorName() string { return "IdentifierValidationError" } + +// Error satisfies the builtin error interface +func (e IdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = IdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = IdentifierValidationError{} + +// Validate checks the field values on GetCacheRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *GetCacheRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetCacheRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetCacheRequestMultiError, or nil if none found. +func (m *GetCacheRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetCacheRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetBaseRequest()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetCacheRequestValidationError{ + field: "BaseRequest", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetCacheRequestValidationError{ + field: "BaseRequest", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetBaseRequest()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetCacheRequestValidationError{ + field: "BaseRequest", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetIdentifier()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetCacheRequestValidationError{ + field: "Identifier", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetCacheRequestValidationError{ + field: "Identifier", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetIdentifier()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetCacheRequestValidationError{ + field: "Identifier", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetCacheRequestMultiError(errors) + } + + return nil +} + +// GetCacheRequestMultiError is an error wrapping multiple validation errors +// returned by GetCacheRequest.ValidateAll() if the designated constraints +// aren't met. +type GetCacheRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetCacheRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetCacheRequestMultiError) AllErrors() []error { return m } + +// GetCacheRequestValidationError is the validation error returned by +// GetCacheRequest.Validate if the designated constraints aren't met. +type GetCacheRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetCacheRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetCacheRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetCacheRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetCacheRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetCacheRequestValidationError) ErrorName() string { return "GetCacheRequestValidationError" } + +// Error satisfies the builtin error interface +func (e GetCacheRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetCacheRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetCacheRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetCacheRequestValidationError{} + +// Validate checks the field values on PutCacheRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *PutCacheRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on PutCacheRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// PutCacheRequestMultiError, or nil if none found. +func (m *PutCacheRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *PutCacheRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetBaseRequest()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PutCacheRequestValidationError{ + field: "BaseRequest", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PutCacheRequestValidationError{ + field: "BaseRequest", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetBaseRequest()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PutCacheRequestValidationError{ + field: "BaseRequest", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetIdentifier()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PutCacheRequestValidationError{ + field: "Identifier", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PutCacheRequestValidationError{ + field: "Identifier", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetIdentifier()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PutCacheRequestValidationError{ + field: "Identifier", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return PutCacheRequestMultiError(errors) + } + + return nil +} + +// PutCacheRequestMultiError is an error wrapping multiple validation errors +// returned by PutCacheRequest.ValidateAll() if the designated constraints +// aren't met. +type PutCacheRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PutCacheRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PutCacheRequestMultiError) AllErrors() []error { return m } + +// PutCacheRequestValidationError is the validation error returned by +// PutCacheRequest.Validate if the designated constraints aren't met. +type PutCacheRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PutCacheRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PutCacheRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PutCacheRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PutCacheRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PutCacheRequestValidationError) ErrorName() string { return "PutCacheRequestValidationError" } + +// Error satisfies the builtin error interface +func (e PutCacheRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPutCacheRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PutCacheRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PutCacheRequestValidationError{} + +// Validate checks the field values on DeleteCacheRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *DeleteCacheRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DeleteCacheRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// DeleteCacheRequestMultiError, or nil if none found. +func (m *DeleteCacheRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *DeleteCacheRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetBaseRequest()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DeleteCacheRequestValidationError{ + field: "BaseRequest", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DeleteCacheRequestValidationError{ + field: "BaseRequest", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetBaseRequest()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DeleteCacheRequestValidationError{ + field: "BaseRequest", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetIdentifier()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DeleteCacheRequestValidationError{ + field: "Identifier", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DeleteCacheRequestValidationError{ + field: "Identifier", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetIdentifier()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DeleteCacheRequestValidationError{ + field: "Identifier", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DeleteCacheRequestMultiError(errors) + } + + return nil +} + +// DeleteCacheRequestMultiError is an error wrapping multiple validation errors +// returned by DeleteCacheRequest.ValidateAll() if the designated constraints +// aren't met. +type DeleteCacheRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DeleteCacheRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DeleteCacheRequestMultiError) AllErrors() []error { return m } + +// DeleteCacheRequestValidationError is the validation error returned by +// DeleteCacheRequest.Validate if the designated constraints aren't met. +type DeleteCacheRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DeleteCacheRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DeleteCacheRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DeleteCacheRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DeleteCacheRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DeleteCacheRequestValidationError) ErrorName() string { + return "DeleteCacheRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e DeleteCacheRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDeleteCacheRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DeleteCacheRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DeleteCacheRequestValidationError{} + +// Validate checks the field values on GetOrExtendReservationRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetOrExtendReservationRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetOrExtendReservationRequest with +// the rules defined in the proto definition for this message. If any rules +// are violated, the result is a list of violation errors wrapped in +// GetOrExtendReservationRequestMultiError, or nil if none found. +func (m *GetOrExtendReservationRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetOrExtendReservationRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetBaseRequest()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetOrExtendReservationRequestValidationError{ + field: "BaseRequest", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetOrExtendReservationRequestValidationError{ + field: "BaseRequest", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetBaseRequest()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetOrExtendReservationRequestValidationError{ + field: "BaseRequest", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetIdentifier()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetOrExtendReservationRequestValidationError{ + field: "Identifier", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetOrExtendReservationRequestValidationError{ + field: "Identifier", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetIdentifier()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetOrExtendReservationRequestValidationError{ + field: "Identifier", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetOrExtendReservationRequestMultiError(errors) + } + + return nil +} + +// GetOrExtendReservationRequestMultiError is an error wrapping multiple +// validation errors returned by GetOrExtendReservationRequest.ValidateAll() +// if the designated constraints aren't met. +type GetOrExtendReservationRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetOrExtendReservationRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetOrExtendReservationRequestMultiError) AllErrors() []error { return m } + +// GetOrExtendReservationRequestValidationError is the validation error +// returned by GetOrExtendReservationRequest.Validate if the designated +// constraints aren't met. +type GetOrExtendReservationRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetOrExtendReservationRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetOrExtendReservationRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetOrExtendReservationRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetOrExtendReservationRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetOrExtendReservationRequestValidationError) ErrorName() string { + return "GetOrExtendReservationRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e GetOrExtendReservationRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetOrExtendReservationRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetOrExtendReservationRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetOrExtendReservationRequestValidationError{} + +// Validate checks the field values on ReleaseReservationRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ReleaseReservationRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ReleaseReservationRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ReleaseReservationRequestMultiError, or nil if none found. +func (m *ReleaseReservationRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *ReleaseReservationRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetBaseRequest()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ReleaseReservationRequestValidationError{ + field: "BaseRequest", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ReleaseReservationRequestValidationError{ + field: "BaseRequest", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetBaseRequest()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ReleaseReservationRequestValidationError{ + field: "BaseRequest", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetIdentifier()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ReleaseReservationRequestValidationError{ + field: "Identifier", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ReleaseReservationRequestValidationError{ + field: "Identifier", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetIdentifier()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ReleaseReservationRequestValidationError{ + field: "Identifier", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ReleaseReservationRequestMultiError(errors) + } + + return nil +} + +// ReleaseReservationRequestMultiError is an error wrapping multiple validation +// errors returned by ReleaseReservationRequest.ValidateAll() if the +// designated constraints aren't met. +type ReleaseReservationRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ReleaseReservationRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ReleaseReservationRequestMultiError) AllErrors() []error { return m } + +// ReleaseReservationRequestValidationError is the validation error returned by +// ReleaseReservationRequest.Validate if the designated constraints aren't met. +type ReleaseReservationRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ReleaseReservationRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ReleaseReservationRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ReleaseReservationRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ReleaseReservationRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ReleaseReservationRequestValidationError) ErrorName() string { + return "ReleaseReservationRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e ReleaseReservationRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sReleaseReservationRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ReleaseReservationRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ReleaseReservationRequestValidationError{} diff --git a/gen/go/flyteidl2/cacheservice/v2/cacheservice_grpc.pb.go b/gen/go/flyteidl2/cacheservice/v2/cacheservice_grpc.pb.go new file mode 100644 index 0000000000..0396cdee0a --- /dev/null +++ b/gen/go/flyteidl2/cacheservice/v2/cacheservice_grpc.pb.go @@ -0,0 +1,266 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: flyteidl2/cacheservice/v2/cacheservice.proto + +package v2 + +import ( + context "context" + cacheservice "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/cacheservice" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + CacheService_Get_FullMethodName = "/flyteidl2.cacheservice.v2.CacheService/Get" + CacheService_Put_FullMethodName = "/flyteidl2.cacheservice.v2.CacheService/Put" + CacheService_Delete_FullMethodName = "/flyteidl2.cacheservice.v2.CacheService/Delete" + CacheService_GetOrExtendReservation_FullMethodName = "/flyteidl2.cacheservice.v2.CacheService/GetOrExtendReservation" + CacheService_ReleaseReservation_FullMethodName = "/flyteidl2.cacheservice.v2.CacheService/ReleaseReservation" +) + +// CacheServiceClient is the client API for CacheService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type CacheServiceClient interface { + // Retrieves cached data by key. + Get(ctx context.Context, in *GetCacheRequest, opts ...grpc.CallOption) (*cacheservice.GetCacheResponse, error) + // Stores or updates cached data by key. + Put(ctx context.Context, in *PutCacheRequest, opts ...grpc.CallOption) (*cacheservice.PutCacheResponse, error) + // Deletes cached data by key. + Delete(ctx context.Context, in *DeleteCacheRequest, opts ...grpc.CallOption) (*cacheservice.DeleteCacheResponse, error) + // Get or extend a reservation for a cache key + GetOrExtendReservation(ctx context.Context, in *GetOrExtendReservationRequest, opts ...grpc.CallOption) (*cacheservice.GetOrExtendReservationResponse, error) + // Release the reservation for a cache key + ReleaseReservation(ctx context.Context, in *ReleaseReservationRequest, opts ...grpc.CallOption) (*cacheservice.ReleaseReservationResponse, error) +} + +type cacheServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewCacheServiceClient(cc grpc.ClientConnInterface) CacheServiceClient { + return &cacheServiceClient{cc} +} + +func (c *cacheServiceClient) Get(ctx context.Context, in *GetCacheRequest, opts ...grpc.CallOption) (*cacheservice.GetCacheResponse, error) { + out := new(cacheservice.GetCacheResponse) + err := c.cc.Invoke(ctx, CacheService_Get_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cacheServiceClient) Put(ctx context.Context, in *PutCacheRequest, opts ...grpc.CallOption) (*cacheservice.PutCacheResponse, error) { + out := new(cacheservice.PutCacheResponse) + err := c.cc.Invoke(ctx, CacheService_Put_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cacheServiceClient) Delete(ctx context.Context, in *DeleteCacheRequest, opts ...grpc.CallOption) (*cacheservice.DeleteCacheResponse, error) { + out := new(cacheservice.DeleteCacheResponse) + err := c.cc.Invoke(ctx, CacheService_Delete_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cacheServiceClient) GetOrExtendReservation(ctx context.Context, in *GetOrExtendReservationRequest, opts ...grpc.CallOption) (*cacheservice.GetOrExtendReservationResponse, error) { + out := new(cacheservice.GetOrExtendReservationResponse) + err := c.cc.Invoke(ctx, CacheService_GetOrExtendReservation_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cacheServiceClient) ReleaseReservation(ctx context.Context, in *ReleaseReservationRequest, opts ...grpc.CallOption) (*cacheservice.ReleaseReservationResponse, error) { + out := new(cacheservice.ReleaseReservationResponse) + err := c.cc.Invoke(ctx, CacheService_ReleaseReservation_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// CacheServiceServer is the server API for CacheService service. +// All implementations should embed UnimplementedCacheServiceServer +// for forward compatibility +type CacheServiceServer interface { + // Retrieves cached data by key. + Get(context.Context, *GetCacheRequest) (*cacheservice.GetCacheResponse, error) + // Stores or updates cached data by key. + Put(context.Context, *PutCacheRequest) (*cacheservice.PutCacheResponse, error) + // Deletes cached data by key. + Delete(context.Context, *DeleteCacheRequest) (*cacheservice.DeleteCacheResponse, error) + // Get or extend a reservation for a cache key + GetOrExtendReservation(context.Context, *GetOrExtendReservationRequest) (*cacheservice.GetOrExtendReservationResponse, error) + // Release the reservation for a cache key + ReleaseReservation(context.Context, *ReleaseReservationRequest) (*cacheservice.ReleaseReservationResponse, error) +} + +// UnimplementedCacheServiceServer should be embedded to have forward compatible implementations. +type UnimplementedCacheServiceServer struct { +} + +func (UnimplementedCacheServiceServer) Get(context.Context, *GetCacheRequest) (*cacheservice.GetCacheResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Get not implemented") +} +func (UnimplementedCacheServiceServer) Put(context.Context, *PutCacheRequest) (*cacheservice.PutCacheResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Put not implemented") +} +func (UnimplementedCacheServiceServer) Delete(context.Context, *DeleteCacheRequest) (*cacheservice.DeleteCacheResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented") +} +func (UnimplementedCacheServiceServer) GetOrExtendReservation(context.Context, *GetOrExtendReservationRequest) (*cacheservice.GetOrExtendReservationResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetOrExtendReservation not implemented") +} +func (UnimplementedCacheServiceServer) ReleaseReservation(context.Context, *ReleaseReservationRequest) (*cacheservice.ReleaseReservationResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ReleaseReservation not implemented") +} + +// UnsafeCacheServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to CacheServiceServer will +// result in compilation errors. +type UnsafeCacheServiceServer interface { + mustEmbedUnimplementedCacheServiceServer() +} + +func RegisterCacheServiceServer(s grpc.ServiceRegistrar, srv CacheServiceServer) { + s.RegisterService(&CacheService_ServiceDesc, srv) +} + +func _CacheService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetCacheRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CacheServiceServer).Get(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: CacheService_Get_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CacheServiceServer).Get(ctx, req.(*GetCacheRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _CacheService_Put_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PutCacheRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CacheServiceServer).Put(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: CacheService_Put_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CacheServiceServer).Put(ctx, req.(*PutCacheRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _CacheService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteCacheRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CacheServiceServer).Delete(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: CacheService_Delete_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CacheServiceServer).Delete(ctx, req.(*DeleteCacheRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _CacheService_GetOrExtendReservation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetOrExtendReservationRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CacheServiceServer).GetOrExtendReservation(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: CacheService_GetOrExtendReservation_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CacheServiceServer).GetOrExtendReservation(ctx, req.(*GetOrExtendReservationRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _CacheService_ReleaseReservation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ReleaseReservationRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CacheServiceServer).ReleaseReservation(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: CacheService_ReleaseReservation_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CacheServiceServer).ReleaseReservation(ctx, req.(*ReleaseReservationRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// CacheService_ServiceDesc is the grpc.ServiceDesc for CacheService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var CacheService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.cacheservice.v2.CacheService", + HandlerType: (*CacheServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Get", + Handler: _CacheService_Get_Handler, + }, + { + MethodName: "Put", + Handler: _CacheService_Put_Handler, + }, + { + MethodName: "Delete", + Handler: _CacheService_Delete_Handler, + }, + { + MethodName: "GetOrExtendReservation", + Handler: _CacheService_GetOrExtendReservation_Handler, + }, + { + MethodName: "ReleaseReservation", + Handler: _CacheService_ReleaseReservation_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "flyteidl2/cacheservice/v2/cacheservice.proto", +} diff --git a/gen/go/flyteidl2/cacheservice/v2/v2connect/cacheservice.connect.go b/gen/go/flyteidl2/cacheservice/v2/v2connect/cacheservice.connect.go new file mode 100644 index 0000000000..32e46d5181 --- /dev/null +++ b/gen/go/flyteidl2/cacheservice/v2/v2connect/cacheservice.connect.go @@ -0,0 +1,241 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: flyteidl2/cacheservice/v2/cacheservice.proto + +package v2connect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + cacheservice "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/cacheservice" + v2 "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/cacheservice/v2" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // CacheServiceName is the fully-qualified name of the CacheService service. + CacheServiceName = "flyteidl2.cacheservice.v2.CacheService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // CacheServiceGetProcedure is the fully-qualified name of the CacheService's Get RPC. + CacheServiceGetProcedure = "/flyteidl2.cacheservice.v2.CacheService/Get" + // CacheServicePutProcedure is the fully-qualified name of the CacheService's Put RPC. + CacheServicePutProcedure = "/flyteidl2.cacheservice.v2.CacheService/Put" + // CacheServiceDeleteProcedure is the fully-qualified name of the CacheService's Delete RPC. + CacheServiceDeleteProcedure = "/flyteidl2.cacheservice.v2.CacheService/Delete" + // CacheServiceGetOrExtendReservationProcedure is the fully-qualified name of the CacheService's + // GetOrExtendReservation RPC. + CacheServiceGetOrExtendReservationProcedure = "/flyteidl2.cacheservice.v2.CacheService/GetOrExtendReservation" + // CacheServiceReleaseReservationProcedure is the fully-qualified name of the CacheService's + // ReleaseReservation RPC. + CacheServiceReleaseReservationProcedure = "/flyteidl2.cacheservice.v2.CacheService/ReleaseReservation" +) + +// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. +var ( + cacheServiceServiceDescriptor = v2.File_flyteidl2_cacheservice_v2_cacheservice_proto.Services().ByName("CacheService") + cacheServiceGetMethodDescriptor = cacheServiceServiceDescriptor.Methods().ByName("Get") + cacheServicePutMethodDescriptor = cacheServiceServiceDescriptor.Methods().ByName("Put") + cacheServiceDeleteMethodDescriptor = cacheServiceServiceDescriptor.Methods().ByName("Delete") + cacheServiceGetOrExtendReservationMethodDescriptor = cacheServiceServiceDescriptor.Methods().ByName("GetOrExtendReservation") + cacheServiceReleaseReservationMethodDescriptor = cacheServiceServiceDescriptor.Methods().ByName("ReleaseReservation") +) + +// CacheServiceClient is a client for the flyteidl2.cacheservice.v2.CacheService service. +type CacheServiceClient interface { + // Retrieves cached data by key. + Get(context.Context, *connect.Request[v2.GetCacheRequest]) (*connect.Response[cacheservice.GetCacheResponse], error) + // Stores or updates cached data by key. + Put(context.Context, *connect.Request[v2.PutCacheRequest]) (*connect.Response[cacheservice.PutCacheResponse], error) + // Deletes cached data by key. + Delete(context.Context, *connect.Request[v2.DeleteCacheRequest]) (*connect.Response[cacheservice.DeleteCacheResponse], error) + // Get or extend a reservation for a cache key + GetOrExtendReservation(context.Context, *connect.Request[v2.GetOrExtendReservationRequest]) (*connect.Response[cacheservice.GetOrExtendReservationResponse], error) + // Release the reservation for a cache key + ReleaseReservation(context.Context, *connect.Request[v2.ReleaseReservationRequest]) (*connect.Response[cacheservice.ReleaseReservationResponse], error) +} + +// NewCacheServiceClient constructs a client for the flyteidl2.cacheservice.v2.CacheService service. +// By default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped +// responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the +// connect.WithGRPC() or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewCacheServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) CacheServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &cacheServiceClient{ + get: connect.NewClient[v2.GetCacheRequest, cacheservice.GetCacheResponse]( + httpClient, + baseURL+CacheServiceGetProcedure, + connect.WithSchema(cacheServiceGetMethodDescriptor), + connect.WithClientOptions(opts...), + ), + put: connect.NewClient[v2.PutCacheRequest, cacheservice.PutCacheResponse]( + httpClient, + baseURL+CacheServicePutProcedure, + connect.WithSchema(cacheServicePutMethodDescriptor), + connect.WithClientOptions(opts...), + ), + delete: connect.NewClient[v2.DeleteCacheRequest, cacheservice.DeleteCacheResponse]( + httpClient, + baseURL+CacheServiceDeleteProcedure, + connect.WithSchema(cacheServiceDeleteMethodDescriptor), + connect.WithClientOptions(opts...), + ), + getOrExtendReservation: connect.NewClient[v2.GetOrExtendReservationRequest, cacheservice.GetOrExtendReservationResponse]( + httpClient, + baseURL+CacheServiceGetOrExtendReservationProcedure, + connect.WithSchema(cacheServiceGetOrExtendReservationMethodDescriptor), + connect.WithClientOptions(opts...), + ), + releaseReservation: connect.NewClient[v2.ReleaseReservationRequest, cacheservice.ReleaseReservationResponse]( + httpClient, + baseURL+CacheServiceReleaseReservationProcedure, + connect.WithSchema(cacheServiceReleaseReservationMethodDescriptor), + connect.WithClientOptions(opts...), + ), + } +} + +// cacheServiceClient implements CacheServiceClient. +type cacheServiceClient struct { + get *connect.Client[v2.GetCacheRequest, cacheservice.GetCacheResponse] + put *connect.Client[v2.PutCacheRequest, cacheservice.PutCacheResponse] + delete *connect.Client[v2.DeleteCacheRequest, cacheservice.DeleteCacheResponse] + getOrExtendReservation *connect.Client[v2.GetOrExtendReservationRequest, cacheservice.GetOrExtendReservationResponse] + releaseReservation *connect.Client[v2.ReleaseReservationRequest, cacheservice.ReleaseReservationResponse] +} + +// Get calls flyteidl2.cacheservice.v2.CacheService.Get. +func (c *cacheServiceClient) Get(ctx context.Context, req *connect.Request[v2.GetCacheRequest]) (*connect.Response[cacheservice.GetCacheResponse], error) { + return c.get.CallUnary(ctx, req) +} + +// Put calls flyteidl2.cacheservice.v2.CacheService.Put. +func (c *cacheServiceClient) Put(ctx context.Context, req *connect.Request[v2.PutCacheRequest]) (*connect.Response[cacheservice.PutCacheResponse], error) { + return c.put.CallUnary(ctx, req) +} + +// Delete calls flyteidl2.cacheservice.v2.CacheService.Delete. +func (c *cacheServiceClient) Delete(ctx context.Context, req *connect.Request[v2.DeleteCacheRequest]) (*connect.Response[cacheservice.DeleteCacheResponse], error) { + return c.delete.CallUnary(ctx, req) +} + +// GetOrExtendReservation calls flyteidl2.cacheservice.v2.CacheService.GetOrExtendReservation. +func (c *cacheServiceClient) GetOrExtendReservation(ctx context.Context, req *connect.Request[v2.GetOrExtendReservationRequest]) (*connect.Response[cacheservice.GetOrExtendReservationResponse], error) { + return c.getOrExtendReservation.CallUnary(ctx, req) +} + +// ReleaseReservation calls flyteidl2.cacheservice.v2.CacheService.ReleaseReservation. +func (c *cacheServiceClient) ReleaseReservation(ctx context.Context, req *connect.Request[v2.ReleaseReservationRequest]) (*connect.Response[cacheservice.ReleaseReservationResponse], error) { + return c.releaseReservation.CallUnary(ctx, req) +} + +// CacheServiceHandler is an implementation of the flyteidl2.cacheservice.v2.CacheService service. +type CacheServiceHandler interface { + // Retrieves cached data by key. + Get(context.Context, *connect.Request[v2.GetCacheRequest]) (*connect.Response[cacheservice.GetCacheResponse], error) + // Stores or updates cached data by key. + Put(context.Context, *connect.Request[v2.PutCacheRequest]) (*connect.Response[cacheservice.PutCacheResponse], error) + // Deletes cached data by key. + Delete(context.Context, *connect.Request[v2.DeleteCacheRequest]) (*connect.Response[cacheservice.DeleteCacheResponse], error) + // Get or extend a reservation for a cache key + GetOrExtendReservation(context.Context, *connect.Request[v2.GetOrExtendReservationRequest]) (*connect.Response[cacheservice.GetOrExtendReservationResponse], error) + // Release the reservation for a cache key + ReleaseReservation(context.Context, *connect.Request[v2.ReleaseReservationRequest]) (*connect.Response[cacheservice.ReleaseReservationResponse], error) +} + +// NewCacheServiceHandler builds an HTTP handler from the service implementation. It returns the +// path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewCacheServiceHandler(svc CacheServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + cacheServiceGetHandler := connect.NewUnaryHandler( + CacheServiceGetProcedure, + svc.Get, + connect.WithSchema(cacheServiceGetMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + cacheServicePutHandler := connect.NewUnaryHandler( + CacheServicePutProcedure, + svc.Put, + connect.WithSchema(cacheServicePutMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + cacheServiceDeleteHandler := connect.NewUnaryHandler( + CacheServiceDeleteProcedure, + svc.Delete, + connect.WithSchema(cacheServiceDeleteMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + cacheServiceGetOrExtendReservationHandler := connect.NewUnaryHandler( + CacheServiceGetOrExtendReservationProcedure, + svc.GetOrExtendReservation, + connect.WithSchema(cacheServiceGetOrExtendReservationMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + cacheServiceReleaseReservationHandler := connect.NewUnaryHandler( + CacheServiceReleaseReservationProcedure, + svc.ReleaseReservation, + connect.WithSchema(cacheServiceReleaseReservationMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.cacheservice.v2.CacheService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case CacheServiceGetProcedure: + cacheServiceGetHandler.ServeHTTP(w, r) + case CacheServicePutProcedure: + cacheServicePutHandler.ServeHTTP(w, r) + case CacheServiceDeleteProcedure: + cacheServiceDeleteHandler.ServeHTTP(w, r) + case CacheServiceGetOrExtendReservationProcedure: + cacheServiceGetOrExtendReservationHandler.ServeHTTP(w, r) + case CacheServiceReleaseReservationProcedure: + cacheServiceReleaseReservationHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedCacheServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedCacheServiceHandler struct{} + +func (UnimplementedCacheServiceHandler) Get(context.Context, *connect.Request[v2.GetCacheRequest]) (*connect.Response[cacheservice.GetCacheResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.cacheservice.v2.CacheService.Get is not implemented")) +} + +func (UnimplementedCacheServiceHandler) Put(context.Context, *connect.Request[v2.PutCacheRequest]) (*connect.Response[cacheservice.PutCacheResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.cacheservice.v2.CacheService.Put is not implemented")) +} + +func (UnimplementedCacheServiceHandler) Delete(context.Context, *connect.Request[v2.DeleteCacheRequest]) (*connect.Response[cacheservice.DeleteCacheResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.cacheservice.v2.CacheService.Delete is not implemented")) +} + +func (UnimplementedCacheServiceHandler) GetOrExtendReservation(context.Context, *connect.Request[v2.GetOrExtendReservationRequest]) (*connect.Response[cacheservice.GetOrExtendReservationResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.cacheservice.v2.CacheService.GetOrExtendReservation is not implemented")) +} + +func (UnimplementedCacheServiceHandler) ReleaseReservation(context.Context, *connect.Request[v2.ReleaseReservationRequest]) (*connect.Response[cacheservice.ReleaseReservationResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.cacheservice.v2.CacheService.ReleaseReservation is not implemented")) +} diff --git a/gen/go/flyteidl2/common/authorization.pb.go b/gen/go/flyteidl2/common/authorization.pb.go new file mode 100644 index 0000000000..1a0296ba16 --- /dev/null +++ b/gen/go/flyteidl2/common/authorization.pb.go @@ -0,0 +1,875 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/common/authorization.proto + +package common + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type Action int32 + +const ( + Action_ACTION_NONE Action = 0 + // Deprecated: Marked as deprecated in flyteidl2/common/authorization.proto. + Action_ACTION_CREATE Action = 1 + // Deprecated: Marked as deprecated in flyteidl2/common/authorization.proto. + Action_ACTION_READ Action = 2 + // Deprecated: Marked as deprecated in flyteidl2/common/authorization.proto. + Action_ACTION_UPDATE Action = 3 + // Deprecated: Marked as deprecated in flyteidl2/common/authorization.proto. + Action_ACTION_DELETE Action = 4 + // Read Flyte workflows, tasks and launch plans + Action_ACTION_VIEW_FLYTE_INVENTORY Action = 5 + // View Flyte executions + Action_ACTION_VIEW_FLYTE_EXECUTIONS Action = 6 + // Register new versions of Flyte workflows, tasks and launch plans + Action_ACTION_REGISTER_FLYTE_INVENTORY Action = 7 + // Create new Flyte workflow and task executions + Action_ACTION_CREATE_FLYTE_EXECUTIONS Action = 8 + // Create new projects and update project descriptions + Action_ACTION_ADMINISTER_PROJECT Action = 9 + // Add users, roles and update role assignments. + Action_ACTION_MANAGE_PERMISSIONS Action = 10 + // Manage billing, account-wide settings + Action_ACTION_ADMINISTER_ACCOUNT Action = 11 + // Operations for clusters + Action_ACTION_MANAGE_CLUSTER Action = 12 + // Edit execution related attributes, including TASK_RESOURCE, WORKFLOW_EXECUTION_CONFIG, and EXTERNAL_RESOURCE + Action_ACTION_EDIT_EXECUTION_RELATED_ATTRIBUTES Action = 13 + // Edit cluster related attributes, including CLUSTER_RESOURCE and CLUSTER_ASSIGNMENT + Action_ACTION_EDIT_CLUSTER_RELATED_ATTRIBUTES Action = 14 + // Edit unused attributes, including EXECUTION_QUEUE, EXECUTION_CLUSTER_LABEL, QUALITY_OF_SERVICE_SPECIFICATION, and PLUGIN_OVERRIDE + Action_ACTION_EDIT_UNUSED_ATTRIBUTES Action = 15 + // View system logs + Action_ACTION_SUPPORT_SYSTEM_LOGS Action = 16 +) + +// Enum value maps for Action. +var ( + Action_name = map[int32]string{ + 0: "ACTION_NONE", + 1: "ACTION_CREATE", + 2: "ACTION_READ", + 3: "ACTION_UPDATE", + 4: "ACTION_DELETE", + 5: "ACTION_VIEW_FLYTE_INVENTORY", + 6: "ACTION_VIEW_FLYTE_EXECUTIONS", + 7: "ACTION_REGISTER_FLYTE_INVENTORY", + 8: "ACTION_CREATE_FLYTE_EXECUTIONS", + 9: "ACTION_ADMINISTER_PROJECT", + 10: "ACTION_MANAGE_PERMISSIONS", + 11: "ACTION_ADMINISTER_ACCOUNT", + 12: "ACTION_MANAGE_CLUSTER", + 13: "ACTION_EDIT_EXECUTION_RELATED_ATTRIBUTES", + 14: "ACTION_EDIT_CLUSTER_RELATED_ATTRIBUTES", + 15: "ACTION_EDIT_UNUSED_ATTRIBUTES", + 16: "ACTION_SUPPORT_SYSTEM_LOGS", + } + Action_value = map[string]int32{ + "ACTION_NONE": 0, + "ACTION_CREATE": 1, + "ACTION_READ": 2, + "ACTION_UPDATE": 3, + "ACTION_DELETE": 4, + "ACTION_VIEW_FLYTE_INVENTORY": 5, + "ACTION_VIEW_FLYTE_EXECUTIONS": 6, + "ACTION_REGISTER_FLYTE_INVENTORY": 7, + "ACTION_CREATE_FLYTE_EXECUTIONS": 8, + "ACTION_ADMINISTER_PROJECT": 9, + "ACTION_MANAGE_PERMISSIONS": 10, + "ACTION_ADMINISTER_ACCOUNT": 11, + "ACTION_MANAGE_CLUSTER": 12, + "ACTION_EDIT_EXECUTION_RELATED_ATTRIBUTES": 13, + "ACTION_EDIT_CLUSTER_RELATED_ATTRIBUTES": 14, + "ACTION_EDIT_UNUSED_ATTRIBUTES": 15, + "ACTION_SUPPORT_SYSTEM_LOGS": 16, + } +) + +func (x Action) Enum() *Action { + p := new(Action) + *p = x + return p +} + +func (x Action) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Action) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_common_authorization_proto_enumTypes[0].Descriptor() +} + +func (Action) Type() protoreflect.EnumType { + return &file_flyteidl2_common_authorization_proto_enumTypes[0] +} + +func (x Action) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Action.Descriptor instead. +func (Action) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_common_authorization_proto_rawDescGZIP(), []int{0} +} + +type Organization struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *Organization) Reset() { + *x = Organization{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_authorization_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Organization) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Organization) ProtoMessage() {} + +func (x *Organization) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_authorization_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Organization.ProtoReflect.Descriptor instead. +func (*Organization) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_authorization_proto_rawDescGZIP(), []int{0} +} + +func (x *Organization) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type Domain struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Organization *Organization `protobuf:"bytes,2,opt,name=organization,proto3" json:"organization,omitempty"` +} + +func (x *Domain) Reset() { + *x = Domain{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_authorization_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Domain) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Domain) ProtoMessage() {} + +func (x *Domain) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_authorization_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Domain.ProtoReflect.Descriptor instead. +func (*Domain) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_authorization_proto_rawDescGZIP(), []int{1} +} + +func (x *Domain) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Domain) GetOrganization() *Organization { + if x != nil { + return x.Organization + } + return nil +} + +type Project struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Domain *Domain `protobuf:"bytes,2,opt,name=domain,proto3" json:"domain,omitempty"` +} + +func (x *Project) Reset() { + *x = Project{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_authorization_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Project) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Project) ProtoMessage() {} + +func (x *Project) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_authorization_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Project.ProtoReflect.Descriptor instead. +func (*Project) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_authorization_proto_rawDescGZIP(), []int{2} +} + +func (x *Project) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Project) GetDomain() *Domain { + if x != nil { + return x.Domain + } + return nil +} + +type Workflow struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Project *Project `protobuf:"bytes,2,opt,name=project,proto3" json:"project,omitempty"` +} + +func (x *Workflow) Reset() { + *x = Workflow{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_authorization_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Workflow) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Workflow) ProtoMessage() {} + +func (x *Workflow) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_authorization_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Workflow.ProtoReflect.Descriptor instead. +func (*Workflow) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_authorization_proto_rawDescGZIP(), []int{3} +} + +func (x *Workflow) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Workflow) GetProject() *Project { + if x != nil { + return x.Project + } + return nil +} + +type LaunchPlan struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Project *Project `protobuf:"bytes,2,opt,name=project,proto3" json:"project,omitempty"` +} + +func (x *LaunchPlan) Reset() { + *x = LaunchPlan{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_authorization_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LaunchPlan) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LaunchPlan) ProtoMessage() {} + +func (x *LaunchPlan) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_authorization_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LaunchPlan.ProtoReflect.Descriptor instead. +func (*LaunchPlan) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_authorization_proto_rawDescGZIP(), []int{4} +} + +func (x *LaunchPlan) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *LaunchPlan) GetProject() *Project { + if x != nil { + return x.Project + } + return nil +} + +type Resource struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Resource: + // + // *Resource_Organization + // *Resource_Domain + // *Resource_Project + // *Resource_Workflow + // *Resource_LaunchPlan + // *Resource_Cluster + Resource isResource_Resource `protobuf_oneof:"resource"` +} + +func (x *Resource) Reset() { + *x = Resource{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_authorization_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Resource) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Resource) ProtoMessage() {} + +func (x *Resource) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_authorization_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Resource.ProtoReflect.Descriptor instead. +func (*Resource) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_authorization_proto_rawDescGZIP(), []int{5} +} + +func (m *Resource) GetResource() isResource_Resource { + if m != nil { + return m.Resource + } + return nil +} + +func (x *Resource) GetOrganization() *Organization { + if x, ok := x.GetResource().(*Resource_Organization); ok { + return x.Organization + } + return nil +} + +func (x *Resource) GetDomain() *Domain { + if x, ok := x.GetResource().(*Resource_Domain); ok { + return x.Domain + } + return nil +} + +func (x *Resource) GetProject() *Project { + if x, ok := x.GetResource().(*Resource_Project); ok { + return x.Project + } + return nil +} + +func (x *Resource) GetWorkflow() *Workflow { + if x, ok := x.GetResource().(*Resource_Workflow); ok { + return x.Workflow + } + return nil +} + +func (x *Resource) GetLaunchPlan() *LaunchPlan { + if x, ok := x.GetResource().(*Resource_LaunchPlan); ok { + return x.LaunchPlan + } + return nil +} + +func (x *Resource) GetCluster() *ClusterIdentifier { + if x, ok := x.GetResource().(*Resource_Cluster); ok { + return x.Cluster + } + return nil +} + +type isResource_Resource interface { + isResource_Resource() +} + +type Resource_Organization struct { + Organization *Organization `protobuf:"bytes,1,opt,name=organization,proto3,oneof"` +} + +type Resource_Domain struct { + Domain *Domain `protobuf:"bytes,2,opt,name=domain,proto3,oneof"` +} + +type Resource_Project struct { + Project *Project `protobuf:"bytes,3,opt,name=project,proto3,oneof"` +} + +type Resource_Workflow struct { + Workflow *Workflow `protobuf:"bytes,4,opt,name=workflow,proto3,oneof"` +} + +type Resource_LaunchPlan struct { + LaunchPlan *LaunchPlan `protobuf:"bytes,5,opt,name=launch_plan,json=launchPlan,proto3,oneof"` +} + +type Resource_Cluster struct { + Cluster *ClusterIdentifier `protobuf:"bytes,6,opt,name=cluster,proto3,oneof"` +} + +func (*Resource_Organization) isResource_Resource() {} + +func (*Resource_Domain) isResource_Resource() {} + +func (*Resource_Project) isResource_Resource() {} + +func (*Resource_Workflow) isResource_Resource() {} + +func (*Resource_LaunchPlan) isResource_Resource() {} + +func (*Resource_Cluster) isResource_Resource() {} + +// Defines a set of allowed actions on a specific authorization resource. +type Permission struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Resource *Resource `protobuf:"bytes,1,opt,name=resource,proto3" json:"resource,omitempty"` + Actions []Action `protobuf:"varint,2,rep,packed,name=actions,proto3,enum=flyteidl2.common.Action" json:"actions,omitempty"` +} + +func (x *Permission) Reset() { + *x = Permission{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_authorization_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Permission) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Permission) ProtoMessage() {} + +func (x *Permission) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_authorization_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Permission.ProtoReflect.Descriptor instead. +func (*Permission) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_authorization_proto_rawDescGZIP(), []int{6} +} + +func (x *Permission) GetResource() *Resource { + if x != nil { + return x.Resource + } + return nil +} + +func (x *Permission) GetActions() []Action { + if x != nil { + return x.Actions + } + return nil +} + +var File_flyteidl2_common_authorization_proto protoreflect.FileDescriptor + +var file_flyteidl2_common_authorization_proto_rawDesc = []byte{ + 0x0a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x2b, 0x0a, 0x0c, 0x4f, 0x72, 0x67, 0x61, + 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x68, 0x0a, 0x06, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, + 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x12, 0x4a, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4f, 0x72, 0x67, + 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, + 0x01, 0x52, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, + 0x60, 0x0a, 0x07, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, + 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x38, 0x0a, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, + 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, + 0x6e, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, + 0x6e, 0x22, 0x64, 0x0a, 0x08, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x1b, 0x0a, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, + 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3b, 0x0a, 0x07, 0x70, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x50, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x07, + 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x66, 0x0a, 0x0a, 0x4c, 0x61, 0x75, 0x6e, 0x63, + 0x68, 0x50, 0x6c, 0x61, 0x6e, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x12, 0x3b, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x42, 0x06, + 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x22, + 0x83, 0x03, 0x0a, 0x08, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x44, 0x0a, 0x0c, + 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x32, 0x0a, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x48, 0x00, 0x52, 0x06, + 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x35, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x48, 0x00, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x38, 0x0a, + 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x48, 0x00, 0x52, 0x08, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x3f, 0x0a, 0x0b, 0x6c, 0x61, 0x75, 0x6e, 0x63, + 0x68, 0x5f, 0x70, 0x6c, 0x61, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x50, 0x6c, 0x61, 0x6e, 0x48, 0x00, 0x52, 0x0a, 0x6c, 0x61, + 0x75, 0x6e, 0x63, 0x68, 0x50, 0x6c, 0x61, 0x6e, 0x12, 0x3f, 0x0a, 0x07, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x43, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, + 0x52, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x42, 0x0a, 0x0a, 0x08, 0x72, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x22, 0x78, 0x0a, 0x0a, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, + 0x69, 0x6f, 0x6e, 0x12, 0x36, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x52, 0x08, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x32, 0x0a, 0x07, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x18, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2a, + 0x94, 0x04, 0x0a, 0x06, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x0f, 0x0a, 0x0b, 0x41, 0x43, + 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x00, 0x12, 0x15, 0x0a, 0x0d, 0x41, + 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x01, 0x1a, 0x02, + 0x08, 0x01, 0x12, 0x13, 0x0a, 0x0b, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x41, + 0x44, 0x10, 0x02, 0x1a, 0x02, 0x08, 0x01, 0x12, 0x15, 0x0a, 0x0d, 0x41, 0x43, 0x54, 0x49, 0x4f, + 0x4e, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x03, 0x1a, 0x02, 0x08, 0x01, 0x12, 0x15, + 0x0a, 0x0d, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, + 0x04, 0x1a, 0x02, 0x08, 0x01, 0x12, 0x1f, 0x0a, 0x1b, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, + 0x56, 0x49, 0x45, 0x57, 0x5f, 0x46, 0x4c, 0x59, 0x54, 0x45, 0x5f, 0x49, 0x4e, 0x56, 0x45, 0x4e, + 0x54, 0x4f, 0x52, 0x59, 0x10, 0x05, 0x12, 0x20, 0x0a, 0x1c, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, + 0x5f, 0x56, 0x49, 0x45, 0x57, 0x5f, 0x46, 0x4c, 0x59, 0x54, 0x45, 0x5f, 0x45, 0x58, 0x45, 0x43, + 0x55, 0x54, 0x49, 0x4f, 0x4e, 0x53, 0x10, 0x06, 0x12, 0x23, 0x0a, 0x1f, 0x41, 0x43, 0x54, 0x49, + 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x47, 0x49, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x46, 0x4c, 0x59, 0x54, + 0x45, 0x5f, 0x49, 0x4e, 0x56, 0x45, 0x4e, 0x54, 0x4f, 0x52, 0x59, 0x10, 0x07, 0x12, 0x22, 0x0a, + 0x1e, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x5f, 0x46, + 0x4c, 0x59, 0x54, 0x45, 0x5f, 0x45, 0x58, 0x45, 0x43, 0x55, 0x54, 0x49, 0x4f, 0x4e, 0x53, 0x10, + 0x08, 0x12, 0x1d, 0x0a, 0x19, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x44, 0x4d, 0x49, + 0x4e, 0x49, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, 0x10, 0x09, + 0x12, 0x1d, 0x0a, 0x19, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x4d, 0x41, 0x4e, 0x41, 0x47, + 0x45, 0x5f, 0x50, 0x45, 0x52, 0x4d, 0x49, 0x53, 0x53, 0x49, 0x4f, 0x4e, 0x53, 0x10, 0x0a, 0x12, + 0x1d, 0x0a, 0x19, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x44, 0x4d, 0x49, 0x4e, 0x49, + 0x53, 0x54, 0x45, 0x52, 0x5f, 0x41, 0x43, 0x43, 0x4f, 0x55, 0x4e, 0x54, 0x10, 0x0b, 0x12, 0x19, + 0x0a, 0x15, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x4d, 0x41, 0x4e, 0x41, 0x47, 0x45, 0x5f, + 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x10, 0x0c, 0x12, 0x2c, 0x0a, 0x28, 0x41, 0x43, 0x54, + 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x44, 0x49, 0x54, 0x5f, 0x45, 0x58, 0x45, 0x43, 0x55, 0x54, 0x49, + 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x41, 0x54, 0x54, 0x52, 0x49, + 0x42, 0x55, 0x54, 0x45, 0x53, 0x10, 0x0d, 0x12, 0x2a, 0x0a, 0x26, 0x41, 0x43, 0x54, 0x49, 0x4f, + 0x4e, 0x5f, 0x45, 0x44, 0x49, 0x54, 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x52, + 0x45, 0x4c, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x41, 0x54, 0x54, 0x52, 0x49, 0x42, 0x55, 0x54, 0x45, + 0x53, 0x10, 0x0e, 0x12, 0x21, 0x0a, 0x1d, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x44, + 0x49, 0x54, 0x5f, 0x55, 0x4e, 0x55, 0x53, 0x45, 0x44, 0x5f, 0x41, 0x54, 0x54, 0x52, 0x49, 0x42, + 0x55, 0x54, 0x45, 0x53, 0x10, 0x0f, 0x12, 0x1e, 0x0a, 0x1a, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, + 0x5f, 0x53, 0x55, 0x50, 0x50, 0x4f, 0x52, 0x54, 0x5f, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x5f, + 0x4c, 0x4f, 0x47, 0x53, 0x10, 0x10, 0x42, 0xc3, 0x01, 0x0a, 0x14, 0x63, 0x6f, 0x6d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x42, + 0x12, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xa2, 0x02, 0x03, + 0x46, 0x43, 0x58, 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xca, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xe2, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x5c, 0x47, 0x50, 0x42, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x62, 0x06, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_common_authorization_proto_rawDescOnce sync.Once + file_flyteidl2_common_authorization_proto_rawDescData = file_flyteidl2_common_authorization_proto_rawDesc +) + +func file_flyteidl2_common_authorization_proto_rawDescGZIP() []byte { + file_flyteidl2_common_authorization_proto_rawDescOnce.Do(func() { + file_flyteidl2_common_authorization_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_common_authorization_proto_rawDescData) + }) + return file_flyteidl2_common_authorization_proto_rawDescData +} + +var file_flyteidl2_common_authorization_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_flyteidl2_common_authorization_proto_msgTypes = make([]protoimpl.MessageInfo, 7) +var file_flyteidl2_common_authorization_proto_goTypes = []interface{}{ + (Action)(0), // 0: flyteidl2.common.Action + (*Organization)(nil), // 1: flyteidl2.common.Organization + (*Domain)(nil), // 2: flyteidl2.common.Domain + (*Project)(nil), // 3: flyteidl2.common.Project + (*Workflow)(nil), // 4: flyteidl2.common.Workflow + (*LaunchPlan)(nil), // 5: flyteidl2.common.LaunchPlan + (*Resource)(nil), // 6: flyteidl2.common.Resource + (*Permission)(nil), // 7: flyteidl2.common.Permission + (*ClusterIdentifier)(nil), // 8: flyteidl2.common.ClusterIdentifier +} +var file_flyteidl2_common_authorization_proto_depIdxs = []int32{ + 1, // 0: flyteidl2.common.Domain.organization:type_name -> flyteidl2.common.Organization + 2, // 1: flyteidl2.common.Project.domain:type_name -> flyteidl2.common.Domain + 3, // 2: flyteidl2.common.Workflow.project:type_name -> flyteidl2.common.Project + 3, // 3: flyteidl2.common.LaunchPlan.project:type_name -> flyteidl2.common.Project + 1, // 4: flyteidl2.common.Resource.organization:type_name -> flyteidl2.common.Organization + 2, // 5: flyteidl2.common.Resource.domain:type_name -> flyteidl2.common.Domain + 3, // 6: flyteidl2.common.Resource.project:type_name -> flyteidl2.common.Project + 4, // 7: flyteidl2.common.Resource.workflow:type_name -> flyteidl2.common.Workflow + 5, // 8: flyteidl2.common.Resource.launch_plan:type_name -> flyteidl2.common.LaunchPlan + 8, // 9: flyteidl2.common.Resource.cluster:type_name -> flyteidl2.common.ClusterIdentifier + 6, // 10: flyteidl2.common.Permission.resource:type_name -> flyteidl2.common.Resource + 0, // 11: flyteidl2.common.Permission.actions:type_name -> flyteidl2.common.Action + 12, // [12:12] is the sub-list for method output_type + 12, // [12:12] is the sub-list for method input_type + 12, // [12:12] is the sub-list for extension type_name + 12, // [12:12] is the sub-list for extension extendee + 0, // [0:12] is the sub-list for field type_name +} + +func init() { file_flyteidl2_common_authorization_proto_init() } +func file_flyteidl2_common_authorization_proto_init() { + if File_flyteidl2_common_authorization_proto != nil { + return + } + file_flyteidl2_common_identifier_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_common_authorization_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Organization); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_authorization_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Domain); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_authorization_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Project); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_authorization_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Workflow); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_authorization_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LaunchPlan); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_authorization_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Resource); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_authorization_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Permission); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_common_authorization_proto_msgTypes[5].OneofWrappers = []interface{}{ + (*Resource_Organization)(nil), + (*Resource_Domain)(nil), + (*Resource_Project)(nil), + (*Resource_Workflow)(nil), + (*Resource_LaunchPlan)(nil), + (*Resource_Cluster)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_common_authorization_proto_rawDesc, + NumEnums: 1, + NumMessages: 7, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_common_authorization_proto_goTypes, + DependencyIndexes: file_flyteidl2_common_authorization_proto_depIdxs, + EnumInfos: file_flyteidl2_common_authorization_proto_enumTypes, + MessageInfos: file_flyteidl2_common_authorization_proto_msgTypes, + }.Build() + File_flyteidl2_common_authorization_proto = out.File + file_flyteidl2_common_authorization_proto_rawDesc = nil + file_flyteidl2_common_authorization_proto_goTypes = nil + file_flyteidl2_common_authorization_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/common/authorization.pb.validate.go b/gen/go/flyteidl2/common/authorization.pb.validate.go new file mode 100644 index 0000000000..20eb7c85b2 --- /dev/null +++ b/gen/go/flyteidl2/common/authorization.pb.validate.go @@ -0,0 +1,1133 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/common/authorization.proto + +package common + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on Organization with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Organization) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Organization with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in OrganizationMultiError, or +// nil if none found. +func (m *Organization) ValidateAll() error { + return m.validate(true) +} + +func (m *Organization) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + if len(errors) > 0 { + return OrganizationMultiError(errors) + } + + return nil +} + +// OrganizationMultiError is an error wrapping multiple validation errors +// returned by Organization.ValidateAll() if the designated constraints aren't met. +type OrganizationMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m OrganizationMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m OrganizationMultiError) AllErrors() []error { return m } + +// OrganizationValidationError is the validation error returned by +// Organization.Validate if the designated constraints aren't met. +type OrganizationValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e OrganizationValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e OrganizationValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e OrganizationValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e OrganizationValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e OrganizationValidationError) ErrorName() string { return "OrganizationValidationError" } + +// Error satisfies the builtin error interface +func (e OrganizationValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sOrganization.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = OrganizationValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = OrganizationValidationError{} + +// Validate checks the field values on Domain with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Domain) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Domain with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in DomainMultiError, or nil if none found. +func (m *Domain) ValidateAll() error { + return m.validate(true) +} + +func (m *Domain) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + if all { + switch v := interface{}(m.GetOrganization()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DomainValidationError{ + field: "Organization", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DomainValidationError{ + field: "Organization", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOrganization()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DomainValidationError{ + field: "Organization", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DomainMultiError(errors) + } + + return nil +} + +// DomainMultiError is an error wrapping multiple validation errors returned by +// Domain.ValidateAll() if the designated constraints aren't met. +type DomainMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DomainMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DomainMultiError) AllErrors() []error { return m } + +// DomainValidationError is the validation error returned by Domain.Validate if +// the designated constraints aren't met. +type DomainValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DomainValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DomainValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DomainValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DomainValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DomainValidationError) ErrorName() string { return "DomainValidationError" } + +// Error satisfies the builtin error interface +func (e DomainValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDomain.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DomainValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DomainValidationError{} + +// Validate checks the field values on Project with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Project) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Project with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in ProjectMultiError, or nil if none found. +func (m *Project) ValidateAll() error { + return m.validate(true) +} + +func (m *Project) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + if all { + switch v := interface{}(m.GetDomain()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ProjectValidationError{ + field: "Domain", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ProjectValidationError{ + field: "Domain", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDomain()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ProjectValidationError{ + field: "Domain", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ProjectMultiError(errors) + } + + return nil +} + +// ProjectMultiError is an error wrapping multiple validation errors returned +// by Project.ValidateAll() if the designated constraints aren't met. +type ProjectMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ProjectMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ProjectMultiError) AllErrors() []error { return m } + +// ProjectValidationError is the validation error returned by Project.Validate +// if the designated constraints aren't met. +type ProjectValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ProjectValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ProjectValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ProjectValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ProjectValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ProjectValidationError) ErrorName() string { return "ProjectValidationError" } + +// Error satisfies the builtin error interface +func (e ProjectValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sProject.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ProjectValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ProjectValidationError{} + +// Validate checks the field values on Workflow with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Workflow) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Workflow with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in WorkflowMultiError, or nil +// if none found. +func (m *Workflow) ValidateAll() error { + return m.validate(true) +} + +func (m *Workflow) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + if all { + switch v := interface{}(m.GetProject()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WorkflowValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WorkflowValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetProject()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WorkflowValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return WorkflowMultiError(errors) + } + + return nil +} + +// WorkflowMultiError is an error wrapping multiple validation errors returned +// by Workflow.ValidateAll() if the designated constraints aren't met. +type WorkflowMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WorkflowMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WorkflowMultiError) AllErrors() []error { return m } + +// WorkflowValidationError is the validation error returned by +// Workflow.Validate if the designated constraints aren't met. +type WorkflowValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WorkflowValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WorkflowValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WorkflowValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WorkflowValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WorkflowValidationError) ErrorName() string { return "WorkflowValidationError" } + +// Error satisfies the builtin error interface +func (e WorkflowValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWorkflow.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WorkflowValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WorkflowValidationError{} + +// Validate checks the field values on LaunchPlan with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *LaunchPlan) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LaunchPlan with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in LaunchPlanMultiError, or +// nil if none found. +func (m *LaunchPlan) ValidateAll() error { + return m.validate(true) +} + +func (m *LaunchPlan) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + if all { + switch v := interface{}(m.GetProject()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LaunchPlanValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LaunchPlanValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetProject()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LaunchPlanValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return LaunchPlanMultiError(errors) + } + + return nil +} + +// LaunchPlanMultiError is an error wrapping multiple validation errors +// returned by LaunchPlan.ValidateAll() if the designated constraints aren't met. +type LaunchPlanMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LaunchPlanMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LaunchPlanMultiError) AllErrors() []error { return m } + +// LaunchPlanValidationError is the validation error returned by +// LaunchPlan.Validate if the designated constraints aren't met. +type LaunchPlanValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LaunchPlanValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LaunchPlanValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LaunchPlanValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LaunchPlanValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LaunchPlanValidationError) ErrorName() string { return "LaunchPlanValidationError" } + +// Error satisfies the builtin error interface +func (e LaunchPlanValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLaunchPlan.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LaunchPlanValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LaunchPlanValidationError{} + +// Validate checks the field values on Resource with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Resource) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Resource with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ResourceMultiError, or nil +// if none found. +func (m *Resource) ValidateAll() error { + return m.validate(true) +} + +func (m *Resource) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Resource.(type) { + case *Resource_Organization: + if v == nil { + err := ResourceValidationError{ + field: "Resource", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetOrganization()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ResourceValidationError{ + field: "Organization", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ResourceValidationError{ + field: "Organization", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOrganization()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ResourceValidationError{ + field: "Organization", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Resource_Domain: + if v == nil { + err := ResourceValidationError{ + field: "Resource", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetDomain()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ResourceValidationError{ + field: "Domain", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ResourceValidationError{ + field: "Domain", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDomain()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ResourceValidationError{ + field: "Domain", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Resource_Project: + if v == nil { + err := ResourceValidationError{ + field: "Resource", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetProject()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ResourceValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ResourceValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetProject()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ResourceValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Resource_Workflow: + if v == nil { + err := ResourceValidationError{ + field: "Resource", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetWorkflow()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ResourceValidationError{ + field: "Workflow", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ResourceValidationError{ + field: "Workflow", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetWorkflow()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ResourceValidationError{ + field: "Workflow", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Resource_LaunchPlan: + if v == nil { + err := ResourceValidationError{ + field: "Resource", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetLaunchPlan()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ResourceValidationError{ + field: "LaunchPlan", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ResourceValidationError{ + field: "LaunchPlan", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLaunchPlan()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ResourceValidationError{ + field: "LaunchPlan", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Resource_Cluster: + if v == nil { + err := ResourceValidationError{ + field: "Resource", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetCluster()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ResourceValidationError{ + field: "Cluster", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ResourceValidationError{ + field: "Cluster", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCluster()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ResourceValidationError{ + field: "Cluster", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return ResourceMultiError(errors) + } + + return nil +} + +// ResourceMultiError is an error wrapping multiple validation errors returned +// by Resource.ValidateAll() if the designated constraints aren't met. +type ResourceMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ResourceMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ResourceMultiError) AllErrors() []error { return m } + +// ResourceValidationError is the validation error returned by +// Resource.Validate if the designated constraints aren't met. +type ResourceValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ResourceValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ResourceValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ResourceValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ResourceValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ResourceValidationError) ErrorName() string { return "ResourceValidationError" } + +// Error satisfies the builtin error interface +func (e ResourceValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sResource.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ResourceValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ResourceValidationError{} + +// Validate checks the field values on Permission with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Permission) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Permission with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in PermissionMultiError, or +// nil if none found. +func (m *Permission) ValidateAll() error { + return m.validate(true) +} + +func (m *Permission) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetResource()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PermissionValidationError{ + field: "Resource", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PermissionValidationError{ + field: "Resource", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetResource()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PermissionValidationError{ + field: "Resource", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return PermissionMultiError(errors) + } + + return nil +} + +// PermissionMultiError is an error wrapping multiple validation errors +// returned by Permission.ValidateAll() if the designated constraints aren't met. +type PermissionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PermissionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PermissionMultiError) AllErrors() []error { return m } + +// PermissionValidationError is the validation error returned by +// Permission.Validate if the designated constraints aren't met. +type PermissionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PermissionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PermissionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PermissionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PermissionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PermissionValidationError) ErrorName() string { return "PermissionValidationError" } + +// Error satisfies the builtin error interface +func (e PermissionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPermission.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PermissionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PermissionValidationError{} diff --git a/gen/go/flyteidl2/common/configuration.pb.go b/gen/go/flyteidl2/common/configuration.pb.go new file mode 100644 index 0000000000..f7e5eec149 --- /dev/null +++ b/gen/go/flyteidl2/common/configuration.pb.go @@ -0,0 +1,164 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/common/configuration.proto + +package common + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// The source of an attribute. We may have other sources in the future. +type AttributesSource int32 + +const ( + // The source is unspecified. + AttributesSource_SOURCE_UNSPECIFIED AttributesSource = 0 + // The configuration is a global configuration. + AttributesSource_GLOBAL AttributesSource = 1 + // The configuration is a domain configuration. + AttributesSource_DOMAIN AttributesSource = 2 + // The configuration is a project configuration. + AttributesSource_PROJECT AttributesSource = 3 + // The configuration is a project-domain configuration. + AttributesSource_PROJECT_DOMAIN AttributesSource = 4 + // The configuration is a org configuration. + AttributesSource_ORG AttributesSource = 5 +) + +// Enum value maps for AttributesSource. +var ( + AttributesSource_name = map[int32]string{ + 0: "SOURCE_UNSPECIFIED", + 1: "GLOBAL", + 2: "DOMAIN", + 3: "PROJECT", + 4: "PROJECT_DOMAIN", + 5: "ORG", + } + AttributesSource_value = map[string]int32{ + "SOURCE_UNSPECIFIED": 0, + "GLOBAL": 1, + "DOMAIN": 2, + "PROJECT": 3, + "PROJECT_DOMAIN": 4, + "ORG": 5, + } +) + +func (x AttributesSource) Enum() *AttributesSource { + p := new(AttributesSource) + *p = x + return p +} + +func (x AttributesSource) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (AttributesSource) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_common_configuration_proto_enumTypes[0].Descriptor() +} + +func (AttributesSource) Type() protoreflect.EnumType { + return &file_flyteidl2_common_configuration_proto_enumTypes[0] +} + +func (x AttributesSource) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use AttributesSource.Descriptor instead. +func (AttributesSource) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_common_configuration_proto_rawDescGZIP(), []int{0} +} + +var File_flyteidl2_common_configuration_proto protoreflect.FileDescriptor + +var file_flyteidl2_common_configuration_proto_rawDesc = []byte{ + 0x0a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2a, 0x6c, 0x0a, 0x10, 0x41, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x12, + 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, + 0x45, 0x44, 0x10, 0x00, 0x12, 0x0a, 0x0a, 0x06, 0x47, 0x4c, 0x4f, 0x42, 0x41, 0x4c, 0x10, 0x01, + 0x12, 0x0a, 0x0a, 0x06, 0x44, 0x4f, 0x4d, 0x41, 0x49, 0x4e, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, + 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x50, 0x52, 0x4f, + 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x44, 0x4f, 0x4d, 0x41, 0x49, 0x4e, 0x10, 0x04, 0x12, 0x07, 0x0a, + 0x03, 0x4f, 0x52, 0x47, 0x10, 0x05, 0x42, 0xc3, 0x01, 0x0a, 0x14, 0x63, 0x6f, 0x6d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x42, + 0x12, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xa2, 0x02, 0x03, + 0x46, 0x43, 0x58, 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xca, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xe2, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x5c, 0x47, 0x50, 0x42, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x62, 0x06, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_common_configuration_proto_rawDescOnce sync.Once + file_flyteidl2_common_configuration_proto_rawDescData = file_flyteidl2_common_configuration_proto_rawDesc +) + +func file_flyteidl2_common_configuration_proto_rawDescGZIP() []byte { + file_flyteidl2_common_configuration_proto_rawDescOnce.Do(func() { + file_flyteidl2_common_configuration_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_common_configuration_proto_rawDescData) + }) + return file_flyteidl2_common_configuration_proto_rawDescData +} + +var file_flyteidl2_common_configuration_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_flyteidl2_common_configuration_proto_goTypes = []interface{}{ + (AttributesSource)(0), // 0: flyteidl2.common.AttributesSource +} +var file_flyteidl2_common_configuration_proto_depIdxs = []int32{ + 0, // [0:0] is the sub-list for method output_type + 0, // [0:0] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_flyteidl2_common_configuration_proto_init() } +func file_flyteidl2_common_configuration_proto_init() { + if File_flyteidl2_common_configuration_proto != nil { + return + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_common_configuration_proto_rawDesc, + NumEnums: 1, + NumMessages: 0, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_common_configuration_proto_goTypes, + DependencyIndexes: file_flyteidl2_common_configuration_proto_depIdxs, + EnumInfos: file_flyteidl2_common_configuration_proto_enumTypes, + }.Build() + File_flyteidl2_common_configuration_proto = out.File + file_flyteidl2_common_configuration_proto_rawDesc = nil + file_flyteidl2_common_configuration_proto_goTypes = nil + file_flyteidl2_common_configuration_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/common/configuration.pb.validate.go b/gen/go/flyteidl2/common/configuration.pb.validate.go new file mode 100644 index 0000000000..e0e600242c --- /dev/null +++ b/gen/go/flyteidl2/common/configuration.pb.validate.go @@ -0,0 +1,36 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/common/configuration.proto + +package common + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) diff --git a/gen/go/flyteidl2/common/identifier.pb.go b/gen/go/flyteidl2/common/identifier.pb.go new file mode 100644 index 0000000000..aaad64757d --- /dev/null +++ b/gen/go/flyteidl2/common/identifier.pb.go @@ -0,0 +1,1345 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/common/identifier.proto + +package common + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type ProjectIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Organization string `protobuf:"bytes,1,opt,name=organization,proto3" json:"organization,omitempty"` + Domain string `protobuf:"bytes,2,opt,name=domain,proto3" json:"domain,omitempty"` + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *ProjectIdentifier) Reset() { + *x = ProjectIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ProjectIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProjectIdentifier) ProtoMessage() {} + +func (x *ProjectIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProjectIdentifier.ProtoReflect.Descriptor instead. +func (*ProjectIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identifier_proto_rawDescGZIP(), []int{0} +} + +func (x *ProjectIdentifier) GetOrganization() string { + if x != nil { + return x.Organization + } + return "" +} + +func (x *ProjectIdentifier) GetDomain() string { + if x != nil { + return x.Domain + } + return "" +} + +func (x *ProjectIdentifier) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type ClusterIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Organization string `protobuf:"bytes,1,opt,name=organization,proto3" json:"organization,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *ClusterIdentifier) Reset() { + *x = ClusterIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ClusterIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ClusterIdentifier) ProtoMessage() {} + +func (x *ClusterIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ClusterIdentifier.ProtoReflect.Descriptor instead. +func (*ClusterIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identifier_proto_rawDescGZIP(), []int{1} +} + +func (x *ClusterIdentifier) GetOrganization() string { + if x != nil { + return x.Organization + } + return "" +} + +func (x *ClusterIdentifier) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type ClusterPoolIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Organization string `protobuf:"bytes,1,opt,name=organization,proto3" json:"organization,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *ClusterPoolIdentifier) Reset() { + *x = ClusterPoolIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ClusterPoolIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ClusterPoolIdentifier) ProtoMessage() {} + +func (x *ClusterPoolIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ClusterPoolIdentifier.ProtoReflect.Descriptor instead. +func (*ClusterPoolIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identifier_proto_rawDescGZIP(), []int{2} +} + +func (x *ClusterPoolIdentifier) GetOrganization() string { + if x != nil { + return x.Organization + } + return "" +} + +func (x *ClusterPoolIdentifier) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type ClusterConfigIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Organization string `protobuf:"bytes,1,opt,name=organization,proto3" json:"organization,omitempty"` + Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` +} + +func (x *ClusterConfigIdentifier) Reset() { + *x = ClusterConfigIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ClusterConfigIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ClusterConfigIdentifier) ProtoMessage() {} + +func (x *ClusterConfigIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ClusterConfigIdentifier.ProtoReflect.Descriptor instead. +func (*ClusterConfigIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identifier_proto_rawDescGZIP(), []int{3} +} + +func (x *ClusterConfigIdentifier) GetOrganization() string { + if x != nil { + return x.Organization + } + return "" +} + +func (x *ClusterConfigIdentifier) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +type ClusterNodepoolIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Organization string `protobuf:"bytes,1,opt,name=organization,proto3" json:"organization,omitempty"` + ClusterName string `protobuf:"bytes,2,opt,name=cluster_name,json=clusterName,proto3" json:"cluster_name,omitempty"` + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *ClusterNodepoolIdentifier) Reset() { + *x = ClusterNodepoolIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ClusterNodepoolIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ClusterNodepoolIdentifier) ProtoMessage() {} + +func (x *ClusterNodepoolIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ClusterNodepoolIdentifier.ProtoReflect.Descriptor instead. +func (*ClusterNodepoolIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identifier_proto_rawDescGZIP(), []int{4} +} + +func (x *ClusterNodepoolIdentifier) GetOrganization() string { + if x != nil { + return x.Organization + } + return "" +} + +func (x *ClusterNodepoolIdentifier) GetClusterName() string { + if x != nil { + return x.ClusterName + } + return "" +} + +func (x *ClusterNodepoolIdentifier) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type UserIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Subject string `protobuf:"bytes,1,opt,name=subject,proto3" json:"subject,omitempty"` +} + +func (x *UserIdentifier) Reset() { + *x = UserIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UserIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UserIdentifier) ProtoMessage() {} + +func (x *UserIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UserIdentifier.ProtoReflect.Descriptor instead. +func (*UserIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identifier_proto_rawDescGZIP(), []int{5} +} + +func (x *UserIdentifier) GetSubject() string { + if x != nil { + return x.Subject + } + return "" +} + +type ApplicationIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Subject string `protobuf:"bytes,1,opt,name=subject,proto3" json:"subject,omitempty"` +} + +func (x *ApplicationIdentifier) Reset() { + *x = ApplicationIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ApplicationIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ApplicationIdentifier) ProtoMessage() {} + +func (x *ApplicationIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ApplicationIdentifier.ProtoReflect.Descriptor instead. +func (*ApplicationIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identifier_proto_rawDescGZIP(), []int{6} +} + +func (x *ApplicationIdentifier) GetSubject() string { + if x != nil { + return x.Subject + } + return "" +} + +type RoleIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Organization string `protobuf:"bytes,1,opt,name=organization,proto3" json:"organization,omitempty"` + // Unique name for this role within the organization + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *RoleIdentifier) Reset() { + *x = RoleIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RoleIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RoleIdentifier) ProtoMessage() {} + +func (x *RoleIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RoleIdentifier.ProtoReflect.Descriptor instead. +func (*RoleIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identifier_proto_rawDescGZIP(), []int{7} +} + +func (x *RoleIdentifier) GetOrganization() string { + if x != nil { + return x.Organization + } + return "" +} + +func (x *RoleIdentifier) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type OrgIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *OrgIdentifier) Reset() { + *x = OrgIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OrgIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OrgIdentifier) ProtoMessage() {} + +func (x *OrgIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OrgIdentifier.ProtoReflect.Descriptor instead. +func (*OrgIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identifier_proto_rawDescGZIP(), []int{8} +} + +func (x *OrgIdentifier) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type ManagedClusterIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Org *OrgIdentifier `protobuf:"bytes,3,opt,name=org,proto3" json:"org,omitempty"` +} + +func (x *ManagedClusterIdentifier) Reset() { + *x = ManagedClusterIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ManagedClusterIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ManagedClusterIdentifier) ProtoMessage() {} + +func (x *ManagedClusterIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ManagedClusterIdentifier.ProtoReflect.Descriptor instead. +func (*ManagedClusterIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identifier_proto_rawDescGZIP(), []int{9} +} + +func (x *ManagedClusterIdentifier) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *ManagedClusterIdentifier) GetOrg() *OrgIdentifier { + if x != nil { + return x.Org + } + return nil +} + +type PolicyIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Organization string `protobuf:"bytes,1,opt,name=organization,proto3" json:"organization,omitempty"` + // Unique name for this policy within the organization + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *PolicyIdentifier) Reset() { + *x = PolicyIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PolicyIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PolicyIdentifier) ProtoMessage() {} + +func (x *PolicyIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PolicyIdentifier.ProtoReflect.Descriptor instead. +func (*PolicyIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identifier_proto_rawDescGZIP(), []int{10} +} + +func (x *PolicyIdentifier) GetOrganization() string { + if x != nil { + return x.Organization + } + return "" +} + +func (x *PolicyIdentifier) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +// Unique identifier of a run. +type RunIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Org this run belongs to. + Org string `protobuf:"bytes,1,opt,name=org,proto3" json:"org,omitempty"` + // Project this run belongs to. + Project string `protobuf:"bytes,2,opt,name=project,proto3" json:"project,omitempty"` + // Domain this run belongs to. + Domain string `protobuf:"bytes,3,opt,name=domain,proto3" json:"domain,omitempty"` + // Name of the run. Must be unique across all runs in this org, project, and domain pairing. + Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *RunIdentifier) Reset() { + *x = RunIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RunIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RunIdentifier) ProtoMessage() {} + +func (x *RunIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RunIdentifier.ProtoReflect.Descriptor instead. +func (*RunIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identifier_proto_rawDescGZIP(), []int{11} +} + +func (x *RunIdentifier) GetOrg() string { + if x != nil { + return x.Org + } + return "" +} + +func (x *RunIdentifier) GetProject() string { + if x != nil { + return x.Project + } + return "" +} + +func (x *RunIdentifier) GetDomain() string { + if x != nil { + return x.Domain + } + return "" +} + +func (x *RunIdentifier) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +// Unique identifier of an action. +type ActionIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Identifier for the run. + Run *RunIdentifier `protobuf:"bytes,1,opt,name=run,proto3" json:"run,omitempty"` + // Name of the action. Must be unique within the run. + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *ActionIdentifier) Reset() { + *x = ActionIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ActionIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ActionIdentifier) ProtoMessage() {} + +func (x *ActionIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ActionIdentifier.ProtoReflect.Descriptor instead. +func (*ActionIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identifier_proto_rawDescGZIP(), []int{12} +} + +func (x *ActionIdentifier) GetRun() *RunIdentifier { + if x != nil { + return x.Run + } + return nil +} + +func (x *ActionIdentifier) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +// Unique identifier of a single action attempt +type ActionAttemptIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ActionId *ActionIdentifier `protobuf:"bytes,1,opt,name=action_id,json=actionId,proto3" json:"action_id,omitempty"` + Attempt uint32 `protobuf:"varint,2,opt,name=attempt,proto3" json:"attempt,omitempty"` +} + +func (x *ActionAttemptIdentifier) Reset() { + *x = ActionAttemptIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ActionAttemptIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ActionAttemptIdentifier) ProtoMessage() {} + +func (x *ActionAttemptIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ActionAttemptIdentifier.ProtoReflect.Descriptor instead. +func (*ActionAttemptIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identifier_proto_rawDescGZIP(), []int{13} +} + +func (x *ActionAttemptIdentifier) GetActionId() *ActionIdentifier { + if x != nil { + return x.ActionId + } + return nil +} + +func (x *ActionAttemptIdentifier) GetAttempt() uint32 { + if x != nil { + return x.Attempt + } + return 0 +} + +// Identifies trigger within an org, project and domain +type TriggerName struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Org this trigger belongs to. + Org string `protobuf:"bytes,1,opt,name=org,proto3" json:"org,omitempty"` + // Project this trigger belongs to. + Project string `protobuf:"bytes,2,opt,name=project,proto3" json:"project,omitempty"` + // Domain this trigger belongs to. + Domain string `protobuf:"bytes,3,opt,name=domain,proto3" json:"domain,omitempty"` + // Unique name of the trigger. + Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"` + TaskName string `protobuf:"bytes,5,opt,name=task_name,json=taskName,proto3" json:"task_name,omitempty"` +} + +func (x *TriggerName) Reset() { + *x = TriggerName{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TriggerName) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TriggerName) ProtoMessage() {} + +func (x *TriggerName) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TriggerName.ProtoReflect.Descriptor instead. +func (*TriggerName) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identifier_proto_rawDescGZIP(), []int{14} +} + +func (x *TriggerName) GetOrg() string { + if x != nil { + return x.Org + } + return "" +} + +func (x *TriggerName) GetProject() string { + if x != nil { + return x.Project + } + return "" +} + +func (x *TriggerName) GetDomain() string { + if x != nil { + return x.Domain + } + return "" +} + +func (x *TriggerName) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *TriggerName) GetTaskName() string { + if x != nil { + return x.TaskName + } + return "" +} + +// Identifies a trigger revision within an org, project and domain +type TriggerIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name *TriggerName `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Revision of the trigger. + Revision uint64 `protobuf:"varint,2,opt,name=revision,proto3" json:"revision,omitempty"` +} + +func (x *TriggerIdentifier) Reset() { + *x = TriggerIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TriggerIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TriggerIdentifier) ProtoMessage() {} + +func (x *TriggerIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identifier_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TriggerIdentifier.ProtoReflect.Descriptor instead. +func (*TriggerIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identifier_proto_rawDescGZIP(), []int{15} +} + +func (x *TriggerIdentifier) GetName() *TriggerName { + if x != nil { + return x.Name + } + return nil +} + +func (x *TriggerIdentifier) GetRevision() uint64 { + if x != nil { + return x.Revision + } + return 0 +} + +var File_flyteidl2_common_identifier_proto protoreflect.FileDescriptor + +var file_flyteidl2_common_identifier_proto_rawDesc = []byte{ + 0x0a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x22, 0x7e, 0x0a, 0x11, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x2b, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, + 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, + 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1f, 0x0a, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x06, 0x64, + 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x22, 0x54, 0x0a, 0x11, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x22, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, + 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, + 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, + 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x4f, 0x0a, 0x15, 0x43, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x50, 0x6f, 0x6f, 0x6c, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x12, 0x22, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x5f, 0x0a, 0x17, 0x43, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x12, 0x2b, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, + 0x02, 0x10, 0x01, 0x52, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x17, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, + 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x02, 0x69, 0x64, 0x22, 0x88, 0x01, 0x0a, 0x19, 0x43, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x70, 0x6f, 0x6f, 0x6c, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x22, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, + 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, + 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2a, 0x0a, 0x0c, + 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x0b, 0x63, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x33, 0x0a, 0x0e, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x21, 0x0a, 0x07, 0x73, 0x75, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, + 0x01, 0x52, 0x07, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x3a, 0x0a, 0x15, 0x41, 0x70, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x12, 0x21, 0x0a, 0x07, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x07, 0x73, + 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x51, 0x0a, 0x0e, 0x52, 0x6f, 0x6c, 0x65, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x22, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, + 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, + 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, + 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x4f, 0x0a, 0x0d, 0x4f, 0x72, 0x67, + 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x3e, 0x0a, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x2a, 0xba, 0x48, 0x27, 0x72, 0x25, 0x10, + 0x01, 0x18, 0x3f, 0x32, 0x1f, 0x5e, 0x5b, 0x61, 0x2d, 0x7a, 0x30, 0x2d, 0x39, 0x5d, 0x28, 0x5b, + 0x2d, 0x61, 0x2d, 0x7a, 0x30, 0x2d, 0x39, 0x5d, 0x2a, 0x5b, 0x61, 0x2d, 0x7a, 0x30, 0x2d, 0x39, + 0x5d, 0x29, 0x3f, 0x24, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x78, 0x0a, 0x18, 0x4d, 0x61, + 0x6e, 0x61, 0x67, 0x65, 0x64, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x12, 0x39, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x4f, 0x72, 0x67, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x4a, 0x04, + 0x08, 0x01, 0x10, 0x02, 0x22, 0x53, 0x0a, 0x10, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x22, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, + 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, + 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, + 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x93, 0x01, 0x0a, 0x0d, 0x52, 0x75, + 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x1b, 0x0a, 0x03, 0x6f, + 0x72, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, + 0x01, 0x18, 0x3f, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x23, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, + 0x10, 0x01, 0x18, 0x3f, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x21, 0x0a, + 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, + 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x3f, 0x52, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, + 0x12, 0x1d, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, + 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x1e, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, + 0x6c, 0x0a, 0x10, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x12, 0x39, 0x0a, 0x03, 0x72, 0x75, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x75, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x03, 0x72, 0x75, 0x6e, 0x12, 0x1d, + 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, + 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x1e, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x85, 0x01, + 0x0a, 0x17, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x64, 0x12, 0x21, 0x0a, 0x07, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, 0x02, 0x20, 0x00, 0x52, 0x07, 0x61, 0x74, + 0x74, 0x65, 0x6d, 0x70, 0x74, 0x22, 0xbb, 0x01, 0x0a, 0x0b, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1b, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x3f, 0x52, 0x03, 0x6f, + 0x72, 0x67, 0x12, 0x23, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x3f, 0x52, 0x07, + 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x21, 0x0a, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, + 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, + 0x18, 0x3f, 0x52, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x1e, 0x0a, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0a, 0xba, 0x48, 0x07, 0x72, 0x05, 0x10, + 0x01, 0x18, 0xff, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x27, 0x0a, 0x09, 0x74, 0x61, + 0x73, 0x6b, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0a, 0xba, + 0x48, 0x07, 0x72, 0x05, 0x10, 0x01, 0x18, 0xff, 0x01, 0x52, 0x08, 0x74, 0x61, 0x73, 0x6b, 0x4e, + 0x61, 0x6d, 0x65, 0x22, 0x73, 0x0a, 0x11, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x39, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x04, 0x42, 0x07, 0xba, 0x48, 0x04, 0x32, 0x02, 0x20, 0x00, 0x52, 0x08, + 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0xc0, 0x01, 0x0a, 0x14, 0x63, 0x6f, 0x6d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x42, 0x0f, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x50, 0x72, 0x6f, + 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xa2, 0x02, 0x03, 0x46, + 0x43, 0x58, 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xca, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xe2, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x5c, 0x47, 0x50, 0x42, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_common_identifier_proto_rawDescOnce sync.Once + file_flyteidl2_common_identifier_proto_rawDescData = file_flyteidl2_common_identifier_proto_rawDesc +) + +func file_flyteidl2_common_identifier_proto_rawDescGZIP() []byte { + file_flyteidl2_common_identifier_proto_rawDescOnce.Do(func() { + file_flyteidl2_common_identifier_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_common_identifier_proto_rawDescData) + }) + return file_flyteidl2_common_identifier_proto_rawDescData +} + +var file_flyteidl2_common_identifier_proto_msgTypes = make([]protoimpl.MessageInfo, 16) +var file_flyteidl2_common_identifier_proto_goTypes = []interface{}{ + (*ProjectIdentifier)(nil), // 0: flyteidl2.common.ProjectIdentifier + (*ClusterIdentifier)(nil), // 1: flyteidl2.common.ClusterIdentifier + (*ClusterPoolIdentifier)(nil), // 2: flyteidl2.common.ClusterPoolIdentifier + (*ClusterConfigIdentifier)(nil), // 3: flyteidl2.common.ClusterConfigIdentifier + (*ClusterNodepoolIdentifier)(nil), // 4: flyteidl2.common.ClusterNodepoolIdentifier + (*UserIdentifier)(nil), // 5: flyteidl2.common.UserIdentifier + (*ApplicationIdentifier)(nil), // 6: flyteidl2.common.ApplicationIdentifier + (*RoleIdentifier)(nil), // 7: flyteidl2.common.RoleIdentifier + (*OrgIdentifier)(nil), // 8: flyteidl2.common.OrgIdentifier + (*ManagedClusterIdentifier)(nil), // 9: flyteidl2.common.ManagedClusterIdentifier + (*PolicyIdentifier)(nil), // 10: flyteidl2.common.PolicyIdentifier + (*RunIdentifier)(nil), // 11: flyteidl2.common.RunIdentifier + (*ActionIdentifier)(nil), // 12: flyteidl2.common.ActionIdentifier + (*ActionAttemptIdentifier)(nil), // 13: flyteidl2.common.ActionAttemptIdentifier + (*TriggerName)(nil), // 14: flyteidl2.common.TriggerName + (*TriggerIdentifier)(nil), // 15: flyteidl2.common.TriggerIdentifier +} +var file_flyteidl2_common_identifier_proto_depIdxs = []int32{ + 8, // 0: flyteidl2.common.ManagedClusterIdentifier.org:type_name -> flyteidl2.common.OrgIdentifier + 11, // 1: flyteidl2.common.ActionIdentifier.run:type_name -> flyteidl2.common.RunIdentifier + 12, // 2: flyteidl2.common.ActionAttemptIdentifier.action_id:type_name -> flyteidl2.common.ActionIdentifier + 14, // 3: flyteidl2.common.TriggerIdentifier.name:type_name -> flyteidl2.common.TriggerName + 4, // [4:4] is the sub-list for method output_type + 4, // [4:4] is the sub-list for method input_type + 4, // [4:4] is the sub-list for extension type_name + 4, // [4:4] is the sub-list for extension extendee + 0, // [0:4] is the sub-list for field type_name +} + +func init() { file_flyteidl2_common_identifier_proto_init() } +func file_flyteidl2_common_identifier_proto_init() { + if File_flyteidl2_common_identifier_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_common_identifier_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ProjectIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identifier_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ClusterIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identifier_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ClusterPoolIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identifier_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ClusterConfigIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identifier_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ClusterNodepoolIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identifier_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UserIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identifier_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ApplicationIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identifier_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RoleIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identifier_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OrgIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identifier_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ManagedClusterIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identifier_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PolicyIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identifier_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RunIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identifier_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ActionIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identifier_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ActionAttemptIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identifier_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TriggerName); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identifier_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TriggerIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_common_identifier_proto_rawDesc, + NumEnums: 0, + NumMessages: 16, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_common_identifier_proto_goTypes, + DependencyIndexes: file_flyteidl2_common_identifier_proto_depIdxs, + MessageInfos: file_flyteidl2_common_identifier_proto_msgTypes, + }.Build() + File_flyteidl2_common_identifier_proto = out.File + file_flyteidl2_common_identifier_proto_rawDesc = nil + file_flyteidl2_common_identifier_proto_goTypes = nil + file_flyteidl2_common_identifier_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/common/identifier.pb.validate.go b/gen/go/flyteidl2/common/identifier.pb.validate.go new file mode 100644 index 0000000000..30ffa68b4d --- /dev/null +++ b/gen/go/flyteidl2/common/identifier.pb.validate.go @@ -0,0 +1,1833 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/common/identifier.proto + +package common + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on ProjectIdentifier with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *ProjectIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ProjectIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ProjectIdentifierMultiError, or nil if none found. +func (m *ProjectIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *ProjectIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Organization + + // no validation rules for Domain + + // no validation rules for Name + + if len(errors) > 0 { + return ProjectIdentifierMultiError(errors) + } + + return nil +} + +// ProjectIdentifierMultiError is an error wrapping multiple validation errors +// returned by ProjectIdentifier.ValidateAll() if the designated constraints +// aren't met. +type ProjectIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ProjectIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ProjectIdentifierMultiError) AllErrors() []error { return m } + +// ProjectIdentifierValidationError is the validation error returned by +// ProjectIdentifier.Validate if the designated constraints aren't met. +type ProjectIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ProjectIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ProjectIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ProjectIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ProjectIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ProjectIdentifierValidationError) ErrorName() string { + return "ProjectIdentifierValidationError" +} + +// Error satisfies the builtin error interface +func (e ProjectIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sProjectIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ProjectIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ProjectIdentifierValidationError{} + +// Validate checks the field values on ClusterIdentifier with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *ClusterIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ClusterIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ClusterIdentifierMultiError, or nil if none found. +func (m *ClusterIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *ClusterIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Organization + + // no validation rules for Name + + if len(errors) > 0 { + return ClusterIdentifierMultiError(errors) + } + + return nil +} + +// ClusterIdentifierMultiError is an error wrapping multiple validation errors +// returned by ClusterIdentifier.ValidateAll() if the designated constraints +// aren't met. +type ClusterIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ClusterIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ClusterIdentifierMultiError) AllErrors() []error { return m } + +// ClusterIdentifierValidationError is the validation error returned by +// ClusterIdentifier.Validate if the designated constraints aren't met. +type ClusterIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ClusterIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ClusterIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ClusterIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ClusterIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ClusterIdentifierValidationError) ErrorName() string { + return "ClusterIdentifierValidationError" +} + +// Error satisfies the builtin error interface +func (e ClusterIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sClusterIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ClusterIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ClusterIdentifierValidationError{} + +// Validate checks the field values on ClusterPoolIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ClusterPoolIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ClusterPoolIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ClusterPoolIdentifierMultiError, or nil if none found. +func (m *ClusterPoolIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *ClusterPoolIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Organization + + // no validation rules for Name + + if len(errors) > 0 { + return ClusterPoolIdentifierMultiError(errors) + } + + return nil +} + +// ClusterPoolIdentifierMultiError is an error wrapping multiple validation +// errors returned by ClusterPoolIdentifier.ValidateAll() if the designated +// constraints aren't met. +type ClusterPoolIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ClusterPoolIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ClusterPoolIdentifierMultiError) AllErrors() []error { return m } + +// ClusterPoolIdentifierValidationError is the validation error returned by +// ClusterPoolIdentifier.Validate if the designated constraints aren't met. +type ClusterPoolIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ClusterPoolIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ClusterPoolIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ClusterPoolIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ClusterPoolIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ClusterPoolIdentifierValidationError) ErrorName() string { + return "ClusterPoolIdentifierValidationError" +} + +// Error satisfies the builtin error interface +func (e ClusterPoolIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sClusterPoolIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ClusterPoolIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ClusterPoolIdentifierValidationError{} + +// Validate checks the field values on ClusterConfigIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ClusterConfigIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ClusterConfigIdentifier with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ClusterConfigIdentifierMultiError, or nil if none found. +func (m *ClusterConfigIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *ClusterConfigIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Organization + + // no validation rules for Id + + if len(errors) > 0 { + return ClusterConfigIdentifierMultiError(errors) + } + + return nil +} + +// ClusterConfigIdentifierMultiError is an error wrapping multiple validation +// errors returned by ClusterConfigIdentifier.ValidateAll() if the designated +// constraints aren't met. +type ClusterConfigIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ClusterConfigIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ClusterConfigIdentifierMultiError) AllErrors() []error { return m } + +// ClusterConfigIdentifierValidationError is the validation error returned by +// ClusterConfigIdentifier.Validate if the designated constraints aren't met. +type ClusterConfigIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ClusterConfigIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ClusterConfigIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ClusterConfigIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ClusterConfigIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ClusterConfigIdentifierValidationError) ErrorName() string { + return "ClusterConfigIdentifierValidationError" +} + +// Error satisfies the builtin error interface +func (e ClusterConfigIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sClusterConfigIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ClusterConfigIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ClusterConfigIdentifierValidationError{} + +// Validate checks the field values on ClusterNodepoolIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ClusterNodepoolIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ClusterNodepoolIdentifier with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ClusterNodepoolIdentifierMultiError, or nil if none found. +func (m *ClusterNodepoolIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *ClusterNodepoolIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Organization + + // no validation rules for ClusterName + + // no validation rules for Name + + if len(errors) > 0 { + return ClusterNodepoolIdentifierMultiError(errors) + } + + return nil +} + +// ClusterNodepoolIdentifierMultiError is an error wrapping multiple validation +// errors returned by ClusterNodepoolIdentifier.ValidateAll() if the +// designated constraints aren't met. +type ClusterNodepoolIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ClusterNodepoolIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ClusterNodepoolIdentifierMultiError) AllErrors() []error { return m } + +// ClusterNodepoolIdentifierValidationError is the validation error returned by +// ClusterNodepoolIdentifier.Validate if the designated constraints aren't met. +type ClusterNodepoolIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ClusterNodepoolIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ClusterNodepoolIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ClusterNodepoolIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ClusterNodepoolIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ClusterNodepoolIdentifierValidationError) ErrorName() string { + return "ClusterNodepoolIdentifierValidationError" +} + +// Error satisfies the builtin error interface +func (e ClusterNodepoolIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sClusterNodepoolIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ClusterNodepoolIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ClusterNodepoolIdentifierValidationError{} + +// Validate checks the field values on UserIdentifier with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *UserIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on UserIdentifier with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in UserIdentifierMultiError, +// or nil if none found. +func (m *UserIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *UserIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Subject + + if len(errors) > 0 { + return UserIdentifierMultiError(errors) + } + + return nil +} + +// UserIdentifierMultiError is an error wrapping multiple validation errors +// returned by UserIdentifier.ValidateAll() if the designated constraints +// aren't met. +type UserIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UserIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UserIdentifierMultiError) AllErrors() []error { return m } + +// UserIdentifierValidationError is the validation error returned by +// UserIdentifier.Validate if the designated constraints aren't met. +type UserIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UserIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UserIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UserIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UserIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UserIdentifierValidationError) ErrorName() string { return "UserIdentifierValidationError" } + +// Error satisfies the builtin error interface +func (e UserIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUserIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UserIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UserIdentifierValidationError{} + +// Validate checks the field values on ApplicationIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ApplicationIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ApplicationIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ApplicationIdentifierMultiError, or nil if none found. +func (m *ApplicationIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *ApplicationIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Subject + + if len(errors) > 0 { + return ApplicationIdentifierMultiError(errors) + } + + return nil +} + +// ApplicationIdentifierMultiError is an error wrapping multiple validation +// errors returned by ApplicationIdentifier.ValidateAll() if the designated +// constraints aren't met. +type ApplicationIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ApplicationIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ApplicationIdentifierMultiError) AllErrors() []error { return m } + +// ApplicationIdentifierValidationError is the validation error returned by +// ApplicationIdentifier.Validate if the designated constraints aren't met. +type ApplicationIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ApplicationIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ApplicationIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ApplicationIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ApplicationIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ApplicationIdentifierValidationError) ErrorName() string { + return "ApplicationIdentifierValidationError" +} + +// Error satisfies the builtin error interface +func (e ApplicationIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sApplicationIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ApplicationIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ApplicationIdentifierValidationError{} + +// Validate checks the field values on RoleIdentifier with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *RoleIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on RoleIdentifier with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in RoleIdentifierMultiError, +// or nil if none found. +func (m *RoleIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *RoleIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Organization + + // no validation rules for Name + + if len(errors) > 0 { + return RoleIdentifierMultiError(errors) + } + + return nil +} + +// RoleIdentifierMultiError is an error wrapping multiple validation errors +// returned by RoleIdentifier.ValidateAll() if the designated constraints +// aren't met. +type RoleIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m RoleIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m RoleIdentifierMultiError) AllErrors() []error { return m } + +// RoleIdentifierValidationError is the validation error returned by +// RoleIdentifier.Validate if the designated constraints aren't met. +type RoleIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e RoleIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e RoleIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e RoleIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e RoleIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e RoleIdentifierValidationError) ErrorName() string { return "RoleIdentifierValidationError" } + +// Error satisfies the builtin error interface +func (e RoleIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sRoleIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = RoleIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = RoleIdentifierValidationError{} + +// Validate checks the field values on OrgIdentifier with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *OrgIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on OrgIdentifier with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in OrgIdentifierMultiError, or +// nil if none found. +func (m *OrgIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *OrgIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + if len(errors) > 0 { + return OrgIdentifierMultiError(errors) + } + + return nil +} + +// OrgIdentifierMultiError is an error wrapping multiple validation errors +// returned by OrgIdentifier.ValidateAll() if the designated constraints +// aren't met. +type OrgIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m OrgIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m OrgIdentifierMultiError) AllErrors() []error { return m } + +// OrgIdentifierValidationError is the validation error returned by +// OrgIdentifier.Validate if the designated constraints aren't met. +type OrgIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e OrgIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e OrgIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e OrgIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e OrgIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e OrgIdentifierValidationError) ErrorName() string { return "OrgIdentifierValidationError" } + +// Error satisfies the builtin error interface +func (e OrgIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sOrgIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = OrgIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = OrgIdentifierValidationError{} + +// Validate checks the field values on ManagedClusterIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ManagedClusterIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ManagedClusterIdentifier with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ManagedClusterIdentifierMultiError, or nil if none found. +func (m *ManagedClusterIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *ManagedClusterIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + if all { + switch v := interface{}(m.GetOrg()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ManagedClusterIdentifierValidationError{ + field: "Org", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ManagedClusterIdentifierValidationError{ + field: "Org", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOrg()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ManagedClusterIdentifierValidationError{ + field: "Org", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ManagedClusterIdentifierMultiError(errors) + } + + return nil +} + +// ManagedClusterIdentifierMultiError is an error wrapping multiple validation +// errors returned by ManagedClusterIdentifier.ValidateAll() if the designated +// constraints aren't met. +type ManagedClusterIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ManagedClusterIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ManagedClusterIdentifierMultiError) AllErrors() []error { return m } + +// ManagedClusterIdentifierValidationError is the validation error returned by +// ManagedClusterIdentifier.Validate if the designated constraints aren't met. +type ManagedClusterIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ManagedClusterIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ManagedClusterIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ManagedClusterIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ManagedClusterIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ManagedClusterIdentifierValidationError) ErrorName() string { + return "ManagedClusterIdentifierValidationError" +} + +// Error satisfies the builtin error interface +func (e ManagedClusterIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sManagedClusterIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ManagedClusterIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ManagedClusterIdentifierValidationError{} + +// Validate checks the field values on PolicyIdentifier with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *PolicyIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on PolicyIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// PolicyIdentifierMultiError, or nil if none found. +func (m *PolicyIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *PolicyIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Organization + + // no validation rules for Name + + if len(errors) > 0 { + return PolicyIdentifierMultiError(errors) + } + + return nil +} + +// PolicyIdentifierMultiError is an error wrapping multiple validation errors +// returned by PolicyIdentifier.ValidateAll() if the designated constraints +// aren't met. +type PolicyIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PolicyIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PolicyIdentifierMultiError) AllErrors() []error { return m } + +// PolicyIdentifierValidationError is the validation error returned by +// PolicyIdentifier.Validate if the designated constraints aren't met. +type PolicyIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PolicyIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PolicyIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PolicyIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PolicyIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PolicyIdentifierValidationError) ErrorName() string { return "PolicyIdentifierValidationError" } + +// Error satisfies the builtin error interface +func (e PolicyIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPolicyIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PolicyIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PolicyIdentifierValidationError{} + +// Validate checks the field values on RunIdentifier with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *RunIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on RunIdentifier with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in RunIdentifierMultiError, or +// nil if none found. +func (m *RunIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *RunIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Org + + // no validation rules for Project + + // no validation rules for Domain + + // no validation rules for Name + + if len(errors) > 0 { + return RunIdentifierMultiError(errors) + } + + return nil +} + +// RunIdentifierMultiError is an error wrapping multiple validation errors +// returned by RunIdentifier.ValidateAll() if the designated constraints +// aren't met. +type RunIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m RunIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m RunIdentifierMultiError) AllErrors() []error { return m } + +// RunIdentifierValidationError is the validation error returned by +// RunIdentifier.Validate if the designated constraints aren't met. +type RunIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e RunIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e RunIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e RunIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e RunIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e RunIdentifierValidationError) ErrorName() string { return "RunIdentifierValidationError" } + +// Error satisfies the builtin error interface +func (e RunIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sRunIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = RunIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = RunIdentifierValidationError{} + +// Validate checks the field values on ActionIdentifier with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *ActionIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ActionIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ActionIdentifierMultiError, or nil if none found. +func (m *ActionIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *ActionIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRun()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionIdentifierValidationError{ + field: "Run", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionIdentifierValidationError{ + field: "Run", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRun()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionIdentifierValidationError{ + field: "Run", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Name + + if len(errors) > 0 { + return ActionIdentifierMultiError(errors) + } + + return nil +} + +// ActionIdentifierMultiError is an error wrapping multiple validation errors +// returned by ActionIdentifier.ValidateAll() if the designated constraints +// aren't met. +type ActionIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ActionIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ActionIdentifierMultiError) AllErrors() []error { return m } + +// ActionIdentifierValidationError is the validation error returned by +// ActionIdentifier.Validate if the designated constraints aren't met. +type ActionIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ActionIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ActionIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ActionIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ActionIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ActionIdentifierValidationError) ErrorName() string { return "ActionIdentifierValidationError" } + +// Error satisfies the builtin error interface +func (e ActionIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sActionIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ActionIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ActionIdentifierValidationError{} + +// Validate checks the field values on ActionAttemptIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ActionAttemptIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ActionAttemptIdentifier with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ActionAttemptIdentifierMultiError, or nil if none found. +func (m *ActionAttemptIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *ActionAttemptIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetActionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionAttemptIdentifierValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionAttemptIdentifierValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetActionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionAttemptIdentifierValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Attempt + + if len(errors) > 0 { + return ActionAttemptIdentifierMultiError(errors) + } + + return nil +} + +// ActionAttemptIdentifierMultiError is an error wrapping multiple validation +// errors returned by ActionAttemptIdentifier.ValidateAll() if the designated +// constraints aren't met. +type ActionAttemptIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ActionAttemptIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ActionAttemptIdentifierMultiError) AllErrors() []error { return m } + +// ActionAttemptIdentifierValidationError is the validation error returned by +// ActionAttemptIdentifier.Validate if the designated constraints aren't met. +type ActionAttemptIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ActionAttemptIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ActionAttemptIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ActionAttemptIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ActionAttemptIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ActionAttemptIdentifierValidationError) ErrorName() string { + return "ActionAttemptIdentifierValidationError" +} + +// Error satisfies the builtin error interface +func (e ActionAttemptIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sActionAttemptIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ActionAttemptIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ActionAttemptIdentifierValidationError{} + +// Validate checks the field values on TriggerName with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TriggerName) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TriggerName with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TriggerNameMultiError, or +// nil if none found. +func (m *TriggerName) ValidateAll() error { + return m.validate(true) +} + +func (m *TriggerName) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Org + + // no validation rules for Project + + // no validation rules for Domain + + // no validation rules for Name + + // no validation rules for TaskName + + if len(errors) > 0 { + return TriggerNameMultiError(errors) + } + + return nil +} + +// TriggerNameMultiError is an error wrapping multiple validation errors +// returned by TriggerName.ValidateAll() if the designated constraints aren't met. +type TriggerNameMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TriggerNameMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TriggerNameMultiError) AllErrors() []error { return m } + +// TriggerNameValidationError is the validation error returned by +// TriggerName.Validate if the designated constraints aren't met. +type TriggerNameValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TriggerNameValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TriggerNameValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TriggerNameValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TriggerNameValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TriggerNameValidationError) ErrorName() string { return "TriggerNameValidationError" } + +// Error satisfies the builtin error interface +func (e TriggerNameValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTriggerName.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TriggerNameValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TriggerNameValidationError{} + +// Validate checks the field values on TriggerIdentifier with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *TriggerIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TriggerIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TriggerIdentifierMultiError, or nil if none found. +func (m *TriggerIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *TriggerIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetName()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerIdentifierValidationError{ + field: "Name", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerIdentifierValidationError{ + field: "Name", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetName()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerIdentifierValidationError{ + field: "Name", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Revision + + if len(errors) > 0 { + return TriggerIdentifierMultiError(errors) + } + + return nil +} + +// TriggerIdentifierMultiError is an error wrapping multiple validation errors +// returned by TriggerIdentifier.ValidateAll() if the designated constraints +// aren't met. +type TriggerIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TriggerIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TriggerIdentifierMultiError) AllErrors() []error { return m } + +// TriggerIdentifierValidationError is the validation error returned by +// TriggerIdentifier.Validate if the designated constraints aren't met. +type TriggerIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TriggerIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TriggerIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TriggerIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TriggerIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TriggerIdentifierValidationError) ErrorName() string { + return "TriggerIdentifierValidationError" +} + +// Error satisfies the builtin error interface +func (e TriggerIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTriggerIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TriggerIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TriggerIdentifierValidationError{} diff --git a/gen/go/flyteidl2/common/identity.pb.go b/gen/go/flyteidl2/common/identity.pb.go new file mode 100644 index 0000000000..3ad3094b49 --- /dev/null +++ b/gen/go/flyteidl2/common/identity.pb.go @@ -0,0 +1,704 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/common/identity.proto + +package common + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Encapsulates user profile details for a member of an organization. +type User struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id *UserIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Spec *UserSpec `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"` + // Deprecated: Marked as deprecated in flyteidl2/common/identity.proto. + Roles []*Role `protobuf:"bytes,3,rep,name=roles,proto3" json:"roles,omitempty"` + Policies []*Policy `protobuf:"bytes,4,rep,name=policies,proto3" json:"policies,omitempty"` +} + +func (x *User) Reset() { + *x = User{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identity_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *User) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*User) ProtoMessage() {} + +func (x *User) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identity_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use User.ProtoReflect.Descriptor instead. +func (*User) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identity_proto_rawDescGZIP(), []int{0} +} + +func (x *User) GetId() *UserIdentifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *User) GetSpec() *UserSpec { + if x != nil { + return x.Spec + } + return nil +} + +// Deprecated: Marked as deprecated in flyteidl2/common/identity.proto. +func (x *User) GetRoles() []*Role { + if x != nil { + return x.Roles + } + return nil +} + +func (x *User) GetPolicies() []*Policy { + if x != nil { + return x.Policies + } + return nil +} + +type UserSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + FirstName string `protobuf:"bytes,1,opt,name=first_name,json=firstName,proto3" json:"first_name,omitempty"` + LastName string `protobuf:"bytes,2,opt,name=last_name,json=lastName,proto3" json:"last_name,omitempty"` + Email string `protobuf:"bytes,3,opt,name=email,proto3" json:"email,omitempty"` + Organization string `protobuf:"bytes,4,opt,name=organization,proto3" json:"organization,omitempty"` + UserHandle string `protobuf:"bytes,5,opt,name=user_handle,json=userHandle,proto3" json:"user_handle,omitempty"` + Groups []string `protobuf:"bytes,6,rep,name=groups,proto3" json:"groups,omitempty"` + PhotoUrl string `protobuf:"bytes,7,opt,name=photo_url,json=photoUrl,proto3" json:"photo_url,omitempty"` +} + +func (x *UserSpec) Reset() { + *x = UserSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identity_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UserSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UserSpec) ProtoMessage() {} + +func (x *UserSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identity_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UserSpec.ProtoReflect.Descriptor instead. +func (*UserSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identity_proto_rawDescGZIP(), []int{1} +} + +func (x *UserSpec) GetFirstName() string { + if x != nil { + return x.FirstName + } + return "" +} + +func (x *UserSpec) GetLastName() string { + if x != nil { + return x.LastName + } + return "" +} + +func (x *UserSpec) GetEmail() string { + if x != nil { + return x.Email + } + return "" +} + +func (x *UserSpec) GetOrganization() string { + if x != nil { + return x.Organization + } + return "" +} + +func (x *UserSpec) GetUserHandle() string { + if x != nil { + return x.UserHandle + } + return "" +} + +func (x *UserSpec) GetGroups() []string { + if x != nil { + return x.Groups + } + return nil +} + +func (x *UserSpec) GetPhotoUrl() string { + if x != nil { + return x.PhotoUrl + } + return "" +} + +type Application struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id *ApplicationIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Spec *AppSpec `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"` +} + +func (x *Application) Reset() { + *x = Application{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identity_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Application) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Application) ProtoMessage() {} + +func (x *Application) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identity_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Application.ProtoReflect.Descriptor instead. +func (*Application) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identity_proto_rawDescGZIP(), []int{2} +} + +func (x *Application) GetId() *ApplicationIdentifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *Application) GetSpec() *AppSpec { + if x != nil { + return x.Spec + } + return nil +} + +type AppSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Organization string `protobuf:"bytes,2,opt,name=organization,proto3" json:"organization,omitempty"` +} + +func (x *AppSpec) Reset() { + *x = AppSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identity_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AppSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AppSpec) ProtoMessage() {} + +func (x *AppSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identity_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AppSpec.ProtoReflect.Descriptor instead. +func (*AppSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identity_proto_rawDescGZIP(), []int{3} +} + +func (x *AppSpec) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *AppSpec) GetOrganization() string { + if x != nil { + return x.Organization + } + return "" +} + +type EnrichedIdentity struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Principal: + // + // *EnrichedIdentity_User + // *EnrichedIdentity_Application + Principal isEnrichedIdentity_Principal `protobuf_oneof:"principal"` +} + +func (x *EnrichedIdentity) Reset() { + *x = EnrichedIdentity{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identity_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EnrichedIdentity) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EnrichedIdentity) ProtoMessage() {} + +func (x *EnrichedIdentity) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identity_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EnrichedIdentity.ProtoReflect.Descriptor instead. +func (*EnrichedIdentity) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identity_proto_rawDescGZIP(), []int{4} +} + +func (m *EnrichedIdentity) GetPrincipal() isEnrichedIdentity_Principal { + if m != nil { + return m.Principal + } + return nil +} + +func (x *EnrichedIdentity) GetUser() *User { + if x, ok := x.GetPrincipal().(*EnrichedIdentity_User); ok { + return x.User + } + return nil +} + +func (x *EnrichedIdentity) GetApplication() *Application { + if x, ok := x.GetPrincipal().(*EnrichedIdentity_Application); ok { + return x.Application + } + return nil +} + +type isEnrichedIdentity_Principal interface { + isEnrichedIdentity_Principal() +} + +type EnrichedIdentity_User struct { + User *User `protobuf:"bytes,1,opt,name=user,proto3,oneof"` +} + +type EnrichedIdentity_Application struct { + Application *Application `protobuf:"bytes,2,opt,name=application,proto3,oneof"` +} + +func (*EnrichedIdentity_User) isEnrichedIdentity_Principal() {} + +func (*EnrichedIdentity_Application) isEnrichedIdentity_Principal() {} + +type Identity struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Principal: + // + // *Identity_UserId + // *Identity_ApplicationId + Principal isIdentity_Principal `protobuf_oneof:"principal"` +} + +func (x *Identity) Reset() { + *x = Identity{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_identity_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Identity) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Identity) ProtoMessage() {} + +func (x *Identity) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_identity_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Identity.ProtoReflect.Descriptor instead. +func (*Identity) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_identity_proto_rawDescGZIP(), []int{5} +} + +func (m *Identity) GetPrincipal() isIdentity_Principal { + if m != nil { + return m.Principal + } + return nil +} + +func (x *Identity) GetUserId() *UserIdentifier { + if x, ok := x.GetPrincipal().(*Identity_UserId); ok { + return x.UserId + } + return nil +} + +func (x *Identity) GetApplicationId() *ApplicationIdentifier { + if x, ok := x.GetPrincipal().(*Identity_ApplicationId); ok { + return x.ApplicationId + } + return nil +} + +type isIdentity_Principal interface { + isIdentity_Principal() +} + +type Identity_UserId struct { + UserId *UserIdentifier `protobuf:"bytes,1,opt,name=user_id,json=userId,proto3,oneof"` +} + +type Identity_ApplicationId struct { + ApplicationId *ApplicationIdentifier `protobuf:"bytes,2,opt,name=application_id,json=applicationId,proto3,oneof"` +} + +func (*Identity_UserId) isIdentity_Principal() {} + +func (*Identity_ApplicationId) isIdentity_Principal() {} + +var File_flyteidl2_common_identity_proto protoreflect.FileDescriptor + +var file_flyteidl2_common_identity_proto_rawDesc = []byte{ + 0x0a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x10, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, + 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x72, 0x6f, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, + 0xd0, 0x01, 0x0a, 0x04, 0x55, 0x73, 0x65, 0x72, 0x12, 0x30, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x02, 0x69, 0x64, 0x12, 0x2e, 0x0a, 0x04, 0x73, 0x70, + 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x55, 0x73, 0x65, 0x72, + 0x53, 0x70, 0x65, 0x63, 0x52, 0x04, 0x73, 0x70, 0x65, 0x63, 0x12, 0x30, 0x0a, 0x05, 0x72, 0x6f, + 0x6c, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x6f, 0x6c, + 0x65, 0x42, 0x02, 0x18, 0x01, 0x52, 0x05, 0x72, 0x6f, 0x6c, 0x65, 0x73, 0x12, 0x34, 0x0a, 0x08, + 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x08, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x69, + 0x65, 0x73, 0x22, 0xd6, 0x01, 0x0a, 0x08, 0x55, 0x73, 0x65, 0x72, 0x53, 0x70, 0x65, 0x63, 0x12, + 0x1d, 0x0a, 0x0a, 0x66, 0x69, 0x72, 0x73, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x72, 0x73, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1b, + 0x0a, 0x09, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x08, 0x6c, 0x61, 0x73, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, + 0x6d, 0x61, 0x69, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x6d, 0x61, 0x69, + 0x6c, 0x12, 0x22, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x75, 0x73, 0x65, 0x72, 0x5f, 0x68, 0x61, + 0x6e, 0x64, 0x6c, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x75, 0x73, 0x65, 0x72, + 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, + 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x12, 0x1b, + 0x0a, 0x09, 0x70, 0x68, 0x6f, 0x74, 0x6f, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x08, 0x70, 0x68, 0x6f, 0x74, 0x6f, 0x55, 0x72, 0x6c, 0x22, 0x75, 0x0a, 0x0b, 0x41, + 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x37, 0x0a, 0x02, 0x69, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, + 0x02, 0x69, 0x64, 0x12, 0x2d, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x70, 0x70, 0x53, 0x70, 0x65, 0x63, 0x52, 0x04, 0x73, 0x70, + 0x65, 0x63, 0x22, 0x41, 0x0a, 0x07, 0x41, 0x70, 0x70, 0x53, 0x70, 0x65, 0x63, 0x12, 0x12, 0x0a, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x12, 0x22, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x97, 0x01, 0x0a, 0x10, 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, + 0x65, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x2c, 0x0a, 0x04, 0x75, 0x73, + 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x55, 0x73, 0x65, 0x72, + 0x48, 0x00, 0x52, 0x04, 0x75, 0x73, 0x65, 0x72, 0x12, 0x41, 0x0a, 0x0b, 0x61, 0x70, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0b, + 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x12, 0x0a, 0x09, 0x70, + 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, + 0xa6, 0x01, 0x0a, 0x08, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x3b, 0x0a, 0x07, + 0x75, 0x73, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, + 0x00, 0x52, 0x06, 0x75, 0x73, 0x65, 0x72, 0x49, 0x64, 0x12, 0x50, 0x0a, 0x0e, 0x61, 0x70, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x0d, 0x61, 0x70, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x42, 0x0b, 0x0a, 0x09, 0x70, + 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x42, 0xbe, 0x01, 0x0a, 0x14, 0x63, 0x6f, 0x6d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x42, 0x0d, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, + 0x48, 0x02, 0x50, 0x01, 0x5a, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, + 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, + 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, + 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0xca, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, + 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xe2, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, +} + +var ( + file_flyteidl2_common_identity_proto_rawDescOnce sync.Once + file_flyteidl2_common_identity_proto_rawDescData = file_flyteidl2_common_identity_proto_rawDesc +) + +func file_flyteidl2_common_identity_proto_rawDescGZIP() []byte { + file_flyteidl2_common_identity_proto_rawDescOnce.Do(func() { + file_flyteidl2_common_identity_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_common_identity_proto_rawDescData) + }) + return file_flyteidl2_common_identity_proto_rawDescData +} + +var file_flyteidl2_common_identity_proto_msgTypes = make([]protoimpl.MessageInfo, 6) +var file_flyteidl2_common_identity_proto_goTypes = []interface{}{ + (*User)(nil), // 0: flyteidl2.common.User + (*UserSpec)(nil), // 1: flyteidl2.common.UserSpec + (*Application)(nil), // 2: flyteidl2.common.Application + (*AppSpec)(nil), // 3: flyteidl2.common.AppSpec + (*EnrichedIdentity)(nil), // 4: flyteidl2.common.EnrichedIdentity + (*Identity)(nil), // 5: flyteidl2.common.Identity + (*UserIdentifier)(nil), // 6: flyteidl2.common.UserIdentifier + (*Role)(nil), // 7: flyteidl2.common.Role + (*Policy)(nil), // 8: flyteidl2.common.Policy + (*ApplicationIdentifier)(nil), // 9: flyteidl2.common.ApplicationIdentifier +} +var file_flyteidl2_common_identity_proto_depIdxs = []int32{ + 6, // 0: flyteidl2.common.User.id:type_name -> flyteidl2.common.UserIdentifier + 1, // 1: flyteidl2.common.User.spec:type_name -> flyteidl2.common.UserSpec + 7, // 2: flyteidl2.common.User.roles:type_name -> flyteidl2.common.Role + 8, // 3: flyteidl2.common.User.policies:type_name -> flyteidl2.common.Policy + 9, // 4: flyteidl2.common.Application.id:type_name -> flyteidl2.common.ApplicationIdentifier + 3, // 5: flyteidl2.common.Application.spec:type_name -> flyteidl2.common.AppSpec + 0, // 6: flyteidl2.common.EnrichedIdentity.user:type_name -> flyteidl2.common.User + 2, // 7: flyteidl2.common.EnrichedIdentity.application:type_name -> flyteidl2.common.Application + 6, // 8: flyteidl2.common.Identity.user_id:type_name -> flyteidl2.common.UserIdentifier + 9, // 9: flyteidl2.common.Identity.application_id:type_name -> flyteidl2.common.ApplicationIdentifier + 10, // [10:10] is the sub-list for method output_type + 10, // [10:10] is the sub-list for method input_type + 10, // [10:10] is the sub-list for extension type_name + 10, // [10:10] is the sub-list for extension extendee + 0, // [0:10] is the sub-list for field type_name +} + +func init() { file_flyteidl2_common_identity_proto_init() } +func file_flyteidl2_common_identity_proto_init() { + if File_flyteidl2_common_identity_proto != nil { + return + } + file_flyteidl2_common_identifier_proto_init() + file_flyteidl2_common_policy_proto_init() + file_flyteidl2_common_role_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_common_identity_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*User); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identity_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UserSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identity_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Application); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identity_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AppSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identity_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EnrichedIdentity); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_identity_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Identity); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_common_identity_proto_msgTypes[4].OneofWrappers = []interface{}{ + (*EnrichedIdentity_User)(nil), + (*EnrichedIdentity_Application)(nil), + } + file_flyteidl2_common_identity_proto_msgTypes[5].OneofWrappers = []interface{}{ + (*Identity_UserId)(nil), + (*Identity_ApplicationId)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_common_identity_proto_rawDesc, + NumEnums: 0, + NumMessages: 6, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_common_identity_proto_goTypes, + DependencyIndexes: file_flyteidl2_common_identity_proto_depIdxs, + MessageInfos: file_flyteidl2_common_identity_proto_msgTypes, + }.Build() + File_flyteidl2_common_identity_proto = out.File + file_flyteidl2_common_identity_proto_rawDesc = nil + file_flyteidl2_common_identity_proto_goTypes = nil + file_flyteidl2_common_identity_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/common/identity.pb.validate.go b/gen/go/flyteidl2/common/identity.pb.validate.go new file mode 100644 index 0000000000..b8b78604e5 --- /dev/null +++ b/gen/go/flyteidl2/common/identity.pb.validate.go @@ -0,0 +1,1003 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/common/identity.proto + +package common + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on User with the rules defined in the proto +// definition for this message. If any rules are violated, the first error +// encountered is returned, or nil if there are no violations. +func (m *User) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on User with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in UserMultiError, or nil if none found. +func (m *User) ValidateAll() error { + return m.validate(true) +} + +func (m *User) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UserValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UserValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UserValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UserValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UserValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UserValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetRoles() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UserValidationError{ + field: fmt.Sprintf("Roles[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UserValidationError{ + field: fmt.Sprintf("Roles[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UserValidationError{ + field: fmt.Sprintf("Roles[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + for idx, item := range m.GetPolicies() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UserValidationError{ + field: fmt.Sprintf("Policies[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UserValidationError{ + field: fmt.Sprintf("Policies[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UserValidationError{ + field: fmt.Sprintf("Policies[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return UserMultiError(errors) + } + + return nil +} + +// UserMultiError is an error wrapping multiple validation errors returned by +// User.ValidateAll() if the designated constraints aren't met. +type UserMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UserMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UserMultiError) AllErrors() []error { return m } + +// UserValidationError is the validation error returned by User.Validate if the +// designated constraints aren't met. +type UserValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UserValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UserValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UserValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UserValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UserValidationError) ErrorName() string { return "UserValidationError" } + +// Error satisfies the builtin error interface +func (e UserValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUser.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UserValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UserValidationError{} + +// Validate checks the field values on UserSpec with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *UserSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on UserSpec with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in UserSpecMultiError, or nil +// if none found. +func (m *UserSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *UserSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for FirstName + + // no validation rules for LastName + + // no validation rules for Email + + // no validation rules for Organization + + // no validation rules for UserHandle + + // no validation rules for PhotoUrl + + if len(errors) > 0 { + return UserSpecMultiError(errors) + } + + return nil +} + +// UserSpecMultiError is an error wrapping multiple validation errors returned +// by UserSpec.ValidateAll() if the designated constraints aren't met. +type UserSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UserSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UserSpecMultiError) AllErrors() []error { return m } + +// UserSpecValidationError is the validation error returned by +// UserSpec.Validate if the designated constraints aren't met. +type UserSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UserSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UserSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UserSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UserSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UserSpecValidationError) ErrorName() string { return "UserSpecValidationError" } + +// Error satisfies the builtin error interface +func (e UserSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUserSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UserSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UserSpecValidationError{} + +// Validate checks the field values on Application with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Application) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Application with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ApplicationMultiError, or +// nil if none found. +func (m *Application) ValidateAll() error { + return m.validate(true) +} + +func (m *Application) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ApplicationValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ApplicationValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ApplicationValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ApplicationValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ApplicationValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ApplicationValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ApplicationMultiError(errors) + } + + return nil +} + +// ApplicationMultiError is an error wrapping multiple validation errors +// returned by Application.ValidateAll() if the designated constraints aren't met. +type ApplicationMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ApplicationMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ApplicationMultiError) AllErrors() []error { return m } + +// ApplicationValidationError is the validation error returned by +// Application.Validate if the designated constraints aren't met. +type ApplicationValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ApplicationValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ApplicationValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ApplicationValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ApplicationValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ApplicationValidationError) ErrorName() string { return "ApplicationValidationError" } + +// Error satisfies the builtin error interface +func (e ApplicationValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sApplication.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ApplicationValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ApplicationValidationError{} + +// Validate checks the field values on AppSpec with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *AppSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on AppSpec with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in AppSpecMultiError, or nil if none found. +func (m *AppSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *AppSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + // no validation rules for Organization + + if len(errors) > 0 { + return AppSpecMultiError(errors) + } + + return nil +} + +// AppSpecMultiError is an error wrapping multiple validation errors returned +// by AppSpec.ValidateAll() if the designated constraints aren't met. +type AppSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m AppSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m AppSpecMultiError) AllErrors() []error { return m } + +// AppSpecValidationError is the validation error returned by AppSpec.Validate +// if the designated constraints aren't met. +type AppSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e AppSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e AppSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e AppSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e AppSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e AppSpecValidationError) ErrorName() string { return "AppSpecValidationError" } + +// Error satisfies the builtin error interface +func (e AppSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sAppSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = AppSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = AppSpecValidationError{} + +// Validate checks the field values on EnrichedIdentity with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *EnrichedIdentity) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on EnrichedIdentity with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// EnrichedIdentityMultiError, or nil if none found. +func (m *EnrichedIdentity) ValidateAll() error { + return m.validate(true) +} + +func (m *EnrichedIdentity) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Principal.(type) { + case *EnrichedIdentity_User: + if v == nil { + err := EnrichedIdentityValidationError{ + field: "Principal", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetUser()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, EnrichedIdentityValidationError{ + field: "User", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, EnrichedIdentityValidationError{ + field: "User", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetUser()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return EnrichedIdentityValidationError{ + field: "User", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *EnrichedIdentity_Application: + if v == nil { + err := EnrichedIdentityValidationError{ + field: "Principal", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetApplication()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, EnrichedIdentityValidationError{ + field: "Application", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, EnrichedIdentityValidationError{ + field: "Application", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetApplication()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return EnrichedIdentityValidationError{ + field: "Application", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return EnrichedIdentityMultiError(errors) + } + + return nil +} + +// EnrichedIdentityMultiError is an error wrapping multiple validation errors +// returned by EnrichedIdentity.ValidateAll() if the designated constraints +// aren't met. +type EnrichedIdentityMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m EnrichedIdentityMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m EnrichedIdentityMultiError) AllErrors() []error { return m } + +// EnrichedIdentityValidationError is the validation error returned by +// EnrichedIdentity.Validate if the designated constraints aren't met. +type EnrichedIdentityValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e EnrichedIdentityValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e EnrichedIdentityValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e EnrichedIdentityValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e EnrichedIdentityValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e EnrichedIdentityValidationError) ErrorName() string { return "EnrichedIdentityValidationError" } + +// Error satisfies the builtin error interface +func (e EnrichedIdentityValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sEnrichedIdentity.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = EnrichedIdentityValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = EnrichedIdentityValidationError{} + +// Validate checks the field values on Identity with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Identity) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Identity with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in IdentityMultiError, or nil +// if none found. +func (m *Identity) ValidateAll() error { + return m.validate(true) +} + +func (m *Identity) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Principal.(type) { + case *Identity_UserId: + if v == nil { + err := IdentityValidationError{ + field: "Principal", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetUserId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, IdentityValidationError{ + field: "UserId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, IdentityValidationError{ + field: "UserId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetUserId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return IdentityValidationError{ + field: "UserId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Identity_ApplicationId: + if v == nil { + err := IdentityValidationError{ + field: "Principal", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetApplicationId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, IdentityValidationError{ + field: "ApplicationId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, IdentityValidationError{ + field: "ApplicationId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetApplicationId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return IdentityValidationError{ + field: "ApplicationId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return IdentityMultiError(errors) + } + + return nil +} + +// IdentityMultiError is an error wrapping multiple validation errors returned +// by Identity.ValidateAll() if the designated constraints aren't met. +type IdentityMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m IdentityMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m IdentityMultiError) AllErrors() []error { return m } + +// IdentityValidationError is the validation error returned by +// Identity.Validate if the designated constraints aren't met. +type IdentityValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e IdentityValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e IdentityValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e IdentityValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e IdentityValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e IdentityValidationError) ErrorName() string { return "IdentityValidationError" } + +// Error satisfies the builtin error interface +func (e IdentityValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sIdentity.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = IdentityValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = IdentityValidationError{} diff --git a/gen/go/flyteidl2/common/list.pb.go b/gen/go/flyteidl2/common/list.pb.go new file mode 100644 index 0000000000..30b5ad4996 --- /dev/null +++ b/gen/go/flyteidl2/common/list.pb.go @@ -0,0 +1,535 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/common/list.proto + +package common + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type Sort_Direction int32 + +const ( + // By default, fields are sorted in descending order. + Sort_DESCENDING Sort_Direction = 0 + Sort_ASCENDING Sort_Direction = 1 +) + +// Enum value maps for Sort_Direction. +var ( + Sort_Direction_name = map[int32]string{ + 0: "DESCENDING", + 1: "ASCENDING", + } + Sort_Direction_value = map[string]int32{ + "DESCENDING": 0, + "ASCENDING": 1, + } +) + +func (x Sort_Direction) Enum() *Sort_Direction { + p := new(Sort_Direction) + *p = x + return p +} + +func (x Sort_Direction) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Sort_Direction) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_common_list_proto_enumTypes[0].Descriptor() +} + +func (Sort_Direction) Type() protoreflect.EnumType { + return &file_flyteidl2_common_list_proto_enumTypes[0] +} + +func (x Sort_Direction) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Sort_Direction.Descriptor instead. +func (Sort_Direction) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_common_list_proto_rawDescGZIP(), []int{0, 0} +} + +type Filter_Function int32 + +const ( + Filter_EQUAL Filter_Function = 0 + Filter_NOT_EQUAL Filter_Function = 1 + Filter_GREATER_THAN Filter_Function = 2 + Filter_GREATER_THAN_OR_EQUAL Filter_Function = 3 + Filter_LESS_THAN Filter_Function = 4 + Filter_LESS_THAN_OR_EQUAL Filter_Function = 5 + Filter_CONTAINS Filter_Function = 6 // Case sensitive contains function. + Filter_VALUE_IN Filter_Function = 7 + Filter_ENDS_WITH Filter_Function = 12 + Filter_NOT_ENDS_WITH Filter_Function = 13 + Filter_CONTAINS_CASE_INSENSITIVE Filter_Function = 14 // Case insensitive contains function. +) + +// Enum value maps for Filter_Function. +var ( + Filter_Function_name = map[int32]string{ + 0: "EQUAL", + 1: "NOT_EQUAL", + 2: "GREATER_THAN", + 3: "GREATER_THAN_OR_EQUAL", + 4: "LESS_THAN", + 5: "LESS_THAN_OR_EQUAL", + 6: "CONTAINS", + 7: "VALUE_IN", + 12: "ENDS_WITH", + 13: "NOT_ENDS_WITH", + 14: "CONTAINS_CASE_INSENSITIVE", + } + Filter_Function_value = map[string]int32{ + "EQUAL": 0, + "NOT_EQUAL": 1, + "GREATER_THAN": 2, + "GREATER_THAN_OR_EQUAL": 3, + "LESS_THAN": 4, + "LESS_THAN_OR_EQUAL": 5, + "CONTAINS": 6, + "VALUE_IN": 7, + "ENDS_WITH": 12, + "NOT_ENDS_WITH": 13, + "CONTAINS_CASE_INSENSITIVE": 14, + } +) + +func (x Filter_Function) Enum() *Filter_Function { + p := new(Filter_Function) + *p = x + return p +} + +func (x Filter_Function) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Filter_Function) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_common_list_proto_enumTypes[1].Descriptor() +} + +func (Filter_Function) Type() protoreflect.EnumType { + return &file_flyteidl2_common_list_proto_enumTypes[1] +} + +func (x Filter_Function) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Filter_Function.Descriptor instead. +func (Filter_Function) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_common_list_proto_rawDescGZIP(), []int{2, 0} +} + +// Specifies sort ordering in a list request. +type Sort struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Indicates an attribute to sort the response values. + // +required + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + // Indicates the direction to apply sort key for response values. + // +optional + Direction Sort_Direction `protobuf:"varint,2,opt,name=direction,proto3,enum=flyteidl2.common.Sort_Direction" json:"direction,omitempty"` +} + +func (x *Sort) Reset() { + *x = Sort{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_list_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Sort) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Sort) ProtoMessage() {} + +func (x *Sort) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_list_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Sort.ProtoReflect.Descriptor instead. +func (*Sort) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_list_proto_rawDescGZIP(), []int{0} +} + +func (x *Sort) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *Sort) GetDirection() Sort_Direction { + if x != nil { + return x.Direction + } + return Sort_DESCENDING +} + +type ListRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Indicates the number of resources to be returned. + // +required + Limit uint32 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"` + // In the case of multiple pages of results, the server-provided token can be used to fetch the next page + // in a query. + // +optional + Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"` + // Deprecated, use sort_by_fields instead. + // Specifies how listed entities should be sorted in the response. + // +optional + // + // Deprecated: Marked as deprecated in flyteidl2/common/list.proto. + SortBy *Sort `protobuf:"bytes,3,opt,name=sort_by,json=sortBy,proto3" json:"sort_by,omitempty"` + // Indicates a list of filters. This field is used for grpc get requests. + // +optional + Filters []*Filter `protobuf:"bytes,4,rep,name=filters,proto3" json:"filters,omitempty"` + // Indicates a raw list of filters passed as string.This field is used for REST get requests + // +optional + RawFilters []string `protobuf:"bytes,5,rep,name=raw_filters,json=rawFilters,proto3" json:"raw_filters,omitempty"` + // Specifies how listed entities should be sorted in the response. + // Sort fields are applied in order. + // +optional + SortByFields []*Sort `protobuf:"bytes,6,rep,name=sort_by_fields,json=sortByFields,proto3" json:"sort_by_fields,omitempty"` +} + +func (x *ListRequest) Reset() { + *x = ListRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_list_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListRequest) ProtoMessage() {} + +func (x *ListRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_list_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListRequest.ProtoReflect.Descriptor instead. +func (*ListRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_list_proto_rawDescGZIP(), []int{1} +} + +func (x *ListRequest) GetLimit() uint32 { + if x != nil { + return x.Limit + } + return 0 +} + +func (x *ListRequest) GetToken() string { + if x != nil { + return x.Token + } + return "" +} + +// Deprecated: Marked as deprecated in flyteidl2/common/list.proto. +func (x *ListRequest) GetSortBy() *Sort { + if x != nil { + return x.SortBy + } + return nil +} + +func (x *ListRequest) GetFilters() []*Filter { + if x != nil { + return x.Filters + } + return nil +} + +func (x *ListRequest) GetRawFilters() []string { + if x != nil { + return x.RawFilters + } + return nil +} + +func (x *ListRequest) GetSortByFields() []*Sort { + if x != nil { + return x.SortByFields + } + return nil +} + +type Filter struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Function Filter_Function `protobuf:"varint,1,opt,name=function,proto3,enum=flyteidl2.common.Filter_Function" json:"function,omitempty"` + // e.g. name or version + Field string `protobuf:"bytes,2,opt,name=field,proto3" json:"field,omitempty"` + // Only in the case of a VALUE_IN function, values may contain multiple entries. + Values []string `protobuf:"bytes,3,rep,name=values,proto3" json:"values,omitempty"` +} + +func (x *Filter) Reset() { + *x = Filter{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_list_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Filter) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Filter) ProtoMessage() {} + +func (x *Filter) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_list_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Filter.ProtoReflect.Descriptor instead. +func (*Filter) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_list_proto_rawDescGZIP(), []int{2} +} + +func (x *Filter) GetFunction() Filter_Function { + if x != nil { + return x.Function + } + return Filter_EQUAL +} + +func (x *Filter) GetField() string { + if x != nil { + return x.Field + } + return "" +} + +func (x *Filter) GetValues() []string { + if x != nil { + return x.Values + } + return nil +} + +var File_flyteidl2_common_list_proto protoreflect.FileDescriptor + +var file_flyteidl2_common_list_proto_rawDesc = []byte{ + 0x0a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2f, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x22, + 0x84, 0x01, 0x0a, 0x04, 0x53, 0x6f, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x3e, 0x0a, 0x09, 0x64, 0x69, + 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x53, 0x6f, 0x72, 0x74, 0x2e, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2a, 0x0a, 0x09, 0x44, 0x69, + 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x0e, 0x0a, 0x0a, 0x44, 0x45, 0x53, 0x43, 0x45, + 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x41, 0x53, 0x43, 0x45, 0x4e, + 0x44, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x22, 0x81, 0x02, 0x0a, 0x0b, 0x4c, 0x69, 0x73, 0x74, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x14, 0x0a, 0x05, + 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, + 0x65, 0x6e, 0x12, 0x33, 0x0a, 0x07, 0x73, 0x6f, 0x72, 0x74, 0x5f, 0x62, 0x79, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x6f, 0x72, 0x74, 0x42, 0x02, 0x18, 0x01, 0x52, + 0x06, 0x73, 0x6f, 0x72, 0x74, 0x42, 0x79, 0x12, 0x32, 0x0a, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, + 0x72, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x46, 0x69, 0x6c, 0x74, + 0x65, 0x72, 0x52, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x72, + 0x61, 0x77, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, + 0x52, 0x0a, 0x72, 0x61, 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x12, 0x3c, 0x0a, 0x0e, + 0x73, 0x6f, 0x72, 0x74, 0x5f, 0x62, 0x79, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x18, 0x06, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x6f, 0x72, 0x74, 0x52, 0x0c, 0x73, 0x6f, + 0x72, 0x74, 0x42, 0x79, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x22, 0xcd, 0x02, 0x0a, 0x06, 0x46, + 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x3d, 0x0a, 0x08, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x46, 0x69, 0x6c, 0x74, 0x65, + 0x72, 0x2e, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x08, 0x66, 0x75, 0x6e, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x73, 0x22, 0xd5, 0x01, 0x0a, 0x08, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x09, 0x0a, 0x05, 0x45, 0x51, 0x55, 0x41, 0x4c, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x4e, 0x4f, + 0x54, 0x5f, 0x45, 0x51, 0x55, 0x41, 0x4c, 0x10, 0x01, 0x12, 0x10, 0x0a, 0x0c, 0x47, 0x52, 0x45, + 0x41, 0x54, 0x45, 0x52, 0x5f, 0x54, 0x48, 0x41, 0x4e, 0x10, 0x02, 0x12, 0x19, 0x0a, 0x15, 0x47, + 0x52, 0x45, 0x41, 0x54, 0x45, 0x52, 0x5f, 0x54, 0x48, 0x41, 0x4e, 0x5f, 0x4f, 0x52, 0x5f, 0x45, + 0x51, 0x55, 0x41, 0x4c, 0x10, 0x03, 0x12, 0x0d, 0x0a, 0x09, 0x4c, 0x45, 0x53, 0x53, 0x5f, 0x54, + 0x48, 0x41, 0x4e, 0x10, 0x04, 0x12, 0x16, 0x0a, 0x12, 0x4c, 0x45, 0x53, 0x53, 0x5f, 0x54, 0x48, + 0x41, 0x4e, 0x5f, 0x4f, 0x52, 0x5f, 0x45, 0x51, 0x55, 0x41, 0x4c, 0x10, 0x05, 0x12, 0x0c, 0x0a, + 0x08, 0x43, 0x4f, 0x4e, 0x54, 0x41, 0x49, 0x4e, 0x53, 0x10, 0x06, 0x12, 0x0c, 0x0a, 0x08, 0x56, + 0x41, 0x4c, 0x55, 0x45, 0x5f, 0x49, 0x4e, 0x10, 0x07, 0x12, 0x0d, 0x0a, 0x09, 0x45, 0x4e, 0x44, + 0x53, 0x5f, 0x57, 0x49, 0x54, 0x48, 0x10, 0x0c, 0x12, 0x11, 0x0a, 0x0d, 0x4e, 0x4f, 0x54, 0x5f, + 0x45, 0x4e, 0x44, 0x53, 0x5f, 0x57, 0x49, 0x54, 0x48, 0x10, 0x0d, 0x12, 0x1d, 0x0a, 0x19, 0x43, + 0x4f, 0x4e, 0x54, 0x41, 0x49, 0x4e, 0x53, 0x5f, 0x43, 0x41, 0x53, 0x45, 0x5f, 0x49, 0x4e, 0x53, + 0x45, 0x4e, 0x53, 0x49, 0x54, 0x49, 0x56, 0x45, 0x10, 0x0e, 0x42, 0xba, 0x01, 0x0a, 0x14, 0x63, + 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x42, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, + 0x50, 0x01, 0x5a, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, + 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, + 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0xca, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0xe2, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0xea, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, + 0x3a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_common_list_proto_rawDescOnce sync.Once + file_flyteidl2_common_list_proto_rawDescData = file_flyteidl2_common_list_proto_rawDesc +) + +func file_flyteidl2_common_list_proto_rawDescGZIP() []byte { + file_flyteidl2_common_list_proto_rawDescOnce.Do(func() { + file_flyteidl2_common_list_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_common_list_proto_rawDescData) + }) + return file_flyteidl2_common_list_proto_rawDescData +} + +var file_flyteidl2_common_list_proto_enumTypes = make([]protoimpl.EnumInfo, 2) +var file_flyteidl2_common_list_proto_msgTypes = make([]protoimpl.MessageInfo, 3) +var file_flyteidl2_common_list_proto_goTypes = []interface{}{ + (Sort_Direction)(0), // 0: flyteidl2.common.Sort.Direction + (Filter_Function)(0), // 1: flyteidl2.common.Filter.Function + (*Sort)(nil), // 2: flyteidl2.common.Sort + (*ListRequest)(nil), // 3: flyteidl2.common.ListRequest + (*Filter)(nil), // 4: flyteidl2.common.Filter +} +var file_flyteidl2_common_list_proto_depIdxs = []int32{ + 0, // 0: flyteidl2.common.Sort.direction:type_name -> flyteidl2.common.Sort.Direction + 2, // 1: flyteidl2.common.ListRequest.sort_by:type_name -> flyteidl2.common.Sort + 4, // 2: flyteidl2.common.ListRequest.filters:type_name -> flyteidl2.common.Filter + 2, // 3: flyteidl2.common.ListRequest.sort_by_fields:type_name -> flyteidl2.common.Sort + 1, // 4: flyteidl2.common.Filter.function:type_name -> flyteidl2.common.Filter.Function + 5, // [5:5] is the sub-list for method output_type + 5, // [5:5] is the sub-list for method input_type + 5, // [5:5] is the sub-list for extension type_name + 5, // [5:5] is the sub-list for extension extendee + 0, // [0:5] is the sub-list for field type_name +} + +func init() { file_flyteidl2_common_list_proto_init() } +func file_flyteidl2_common_list_proto_init() { + if File_flyteidl2_common_list_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_common_list_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Sort); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_list_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_list_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Filter); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_common_list_proto_rawDesc, + NumEnums: 2, + NumMessages: 3, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_common_list_proto_goTypes, + DependencyIndexes: file_flyteidl2_common_list_proto_depIdxs, + EnumInfos: file_flyteidl2_common_list_proto_enumTypes, + MessageInfos: file_flyteidl2_common_list_proto_msgTypes, + }.Build() + File_flyteidl2_common_list_proto = out.File + file_flyteidl2_common_list_proto_rawDesc = nil + file_flyteidl2_common_list_proto_goTypes = nil + file_flyteidl2_common_list_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/common/list.pb.validate.go b/gen/go/flyteidl2/common/list.pb.validate.go new file mode 100644 index 0000000000..6df98682d7 --- /dev/null +++ b/gen/go/flyteidl2/common/list.pb.validate.go @@ -0,0 +1,440 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/common/list.proto + +package common + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on Sort with the rules defined in the proto +// definition for this message. If any rules are violated, the first error +// encountered is returned, or nil if there are no violations. +func (m *Sort) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Sort with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in SortMultiError, or nil if none found. +func (m *Sort) ValidateAll() error { + return m.validate(true) +} + +func (m *Sort) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Key + + // no validation rules for Direction + + if len(errors) > 0 { + return SortMultiError(errors) + } + + return nil +} + +// SortMultiError is an error wrapping multiple validation errors returned by +// Sort.ValidateAll() if the designated constraints aren't met. +type SortMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SortMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SortMultiError) AllErrors() []error { return m } + +// SortValidationError is the validation error returned by Sort.Validate if the +// designated constraints aren't met. +type SortValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SortValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SortValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SortValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SortValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SortValidationError) ErrorName() string { return "SortValidationError" } + +// Error satisfies the builtin error interface +func (e SortValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSort.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SortValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SortValidationError{} + +// Validate checks the field values on ListRequest with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ListRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListRequest with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ListRequestMultiError, or +// nil if none found. +func (m *ListRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *ListRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Limit + + // no validation rules for Token + + if all { + switch v := interface{}(m.GetSortBy()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListRequestValidationError{ + field: "SortBy", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListRequestValidationError{ + field: "SortBy", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSortBy()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListRequestValidationError{ + field: "SortBy", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetFilters() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListRequestValidationError{ + field: fmt.Sprintf("Filters[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListRequestValidationError{ + field: fmt.Sprintf("Filters[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListRequestValidationError{ + field: fmt.Sprintf("Filters[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + for idx, item := range m.GetSortByFields() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListRequestValidationError{ + field: fmt.Sprintf("SortByFields[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListRequestValidationError{ + field: fmt.Sprintf("SortByFields[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListRequestValidationError{ + field: fmt.Sprintf("SortByFields[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return ListRequestMultiError(errors) + } + + return nil +} + +// ListRequestMultiError is an error wrapping multiple validation errors +// returned by ListRequest.ValidateAll() if the designated constraints aren't met. +type ListRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListRequestMultiError) AllErrors() []error { return m } + +// ListRequestValidationError is the validation error returned by +// ListRequest.Validate if the designated constraints aren't met. +type ListRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListRequestValidationError) ErrorName() string { return "ListRequestValidationError" } + +// Error satisfies the builtin error interface +func (e ListRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListRequestValidationError{} + +// Validate checks the field values on Filter with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Filter) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Filter with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in FilterMultiError, or nil if none found. +func (m *Filter) ValidateAll() error { + return m.validate(true) +} + +func (m *Filter) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Function + + // no validation rules for Field + + if len(errors) > 0 { + return FilterMultiError(errors) + } + + return nil +} + +// FilterMultiError is an error wrapping multiple validation errors returned by +// Filter.ValidateAll() if the designated constraints aren't met. +type FilterMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m FilterMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m FilterMultiError) AllErrors() []error { return m } + +// FilterValidationError is the validation error returned by Filter.Validate if +// the designated constraints aren't met. +type FilterValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e FilterValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e FilterValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e FilterValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e FilterValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e FilterValidationError) ErrorName() string { return "FilterValidationError" } + +// Error satisfies the builtin error interface +func (e FilterValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sFilter.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = FilterValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = FilterValidationError{} diff --git a/gen/go/flyteidl2/common/mocks/is_enriched_identity_principal.go b/gen/go/flyteidl2/common/mocks/is_enriched_identity_principal.go new file mode 100644 index 0000000000..4f5acca8b2 --- /dev/null +++ b/gen/go/flyteidl2/common/mocks/is_enriched_identity_principal.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isEnrichedIdentity_Principal is an autogenerated mock type for the isEnrichedIdentity_Principal type +type isEnrichedIdentity_Principal struct { + mock.Mock +} + +type isEnrichedIdentity_Principal_Expecter struct { + mock *mock.Mock +} + +func (_m *isEnrichedIdentity_Principal) EXPECT() *isEnrichedIdentity_Principal_Expecter { + return &isEnrichedIdentity_Principal_Expecter{mock: &_m.Mock} +} + +// isEnrichedIdentity_Principal provides a mock function with no fields +func (_m *isEnrichedIdentity_Principal) isEnrichedIdentity_Principal() { + _m.Called() +} + +// isEnrichedIdentity_Principal_isEnrichedIdentity_Principal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isEnrichedIdentity_Principal' +type isEnrichedIdentity_Principal_isEnrichedIdentity_Principal_Call struct { + *mock.Call +} + +// isEnrichedIdentity_Principal is a helper method to define mock.On call +func (_e *isEnrichedIdentity_Principal_Expecter) isEnrichedIdentity_Principal() *isEnrichedIdentity_Principal_isEnrichedIdentity_Principal_Call { + return &isEnrichedIdentity_Principal_isEnrichedIdentity_Principal_Call{Call: _e.mock.On("isEnrichedIdentity_Principal")} +} + +func (_c *isEnrichedIdentity_Principal_isEnrichedIdentity_Principal_Call) Run(run func()) *isEnrichedIdentity_Principal_isEnrichedIdentity_Principal_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isEnrichedIdentity_Principal_isEnrichedIdentity_Principal_Call) Return() *isEnrichedIdentity_Principal_isEnrichedIdentity_Principal_Call { + _c.Call.Return() + return _c +} + +func (_c *isEnrichedIdentity_Principal_isEnrichedIdentity_Principal_Call) RunAndReturn(run func()) *isEnrichedIdentity_Principal_isEnrichedIdentity_Principal_Call { + _c.Run(run) + return _c +} + +// newIsEnrichedIdentity_Principal creates a new instance of isEnrichedIdentity_Principal. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsEnrichedIdentity_Principal(t interface { + mock.TestingT + Cleanup(func()) +}) *isEnrichedIdentity_Principal { + mock := &isEnrichedIdentity_Principal{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/common/mocks/is_identity_principal.go b/gen/go/flyteidl2/common/mocks/is_identity_principal.go new file mode 100644 index 0000000000..8e7aec45f9 --- /dev/null +++ b/gen/go/flyteidl2/common/mocks/is_identity_principal.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isIdentity_Principal is an autogenerated mock type for the isIdentity_Principal type +type isIdentity_Principal struct { + mock.Mock +} + +type isIdentity_Principal_Expecter struct { + mock *mock.Mock +} + +func (_m *isIdentity_Principal) EXPECT() *isIdentity_Principal_Expecter { + return &isIdentity_Principal_Expecter{mock: &_m.Mock} +} + +// isIdentity_Principal provides a mock function with no fields +func (_m *isIdentity_Principal) isIdentity_Principal() { + _m.Called() +} + +// isIdentity_Principal_isIdentity_Principal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isIdentity_Principal' +type isIdentity_Principal_isIdentity_Principal_Call struct { + *mock.Call +} + +// isIdentity_Principal is a helper method to define mock.On call +func (_e *isIdentity_Principal_Expecter) isIdentity_Principal() *isIdentity_Principal_isIdentity_Principal_Call { + return &isIdentity_Principal_isIdentity_Principal_Call{Call: _e.mock.On("isIdentity_Principal")} +} + +func (_c *isIdentity_Principal_isIdentity_Principal_Call) Run(run func()) *isIdentity_Principal_isIdentity_Principal_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isIdentity_Principal_isIdentity_Principal_Call) Return() *isIdentity_Principal_isIdentity_Principal_Call { + _c.Call.Return() + return _c +} + +func (_c *isIdentity_Principal_isIdentity_Principal_Call) RunAndReturn(run func()) *isIdentity_Principal_isIdentity_Principal_Call { + _c.Run(run) + return _c +} + +// newIsIdentity_Principal creates a new instance of isIdentity_Principal. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsIdentity_Principal(t interface { + mock.TestingT + Cleanup(func()) +}) *isIdentity_Principal { + mock := &isIdentity_Principal{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/common/mocks/is_resource_resource.go b/gen/go/flyteidl2/common/mocks/is_resource_resource.go new file mode 100644 index 0000000000..87909825da --- /dev/null +++ b/gen/go/flyteidl2/common/mocks/is_resource_resource.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isResource_Resource is an autogenerated mock type for the isResource_Resource type +type isResource_Resource struct { + mock.Mock +} + +type isResource_Resource_Expecter struct { + mock *mock.Mock +} + +func (_m *isResource_Resource) EXPECT() *isResource_Resource_Expecter { + return &isResource_Resource_Expecter{mock: &_m.Mock} +} + +// isResource_Resource provides a mock function with no fields +func (_m *isResource_Resource) isResource_Resource() { + _m.Called() +} + +// isResource_Resource_isResource_Resource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isResource_Resource' +type isResource_Resource_isResource_Resource_Call struct { + *mock.Call +} + +// isResource_Resource is a helper method to define mock.On call +func (_e *isResource_Resource_Expecter) isResource_Resource() *isResource_Resource_isResource_Resource_Call { + return &isResource_Resource_isResource_Resource_Call{Call: _e.mock.On("isResource_Resource")} +} + +func (_c *isResource_Resource_isResource_Resource_Call) Run(run func()) *isResource_Resource_isResource_Resource_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isResource_Resource_isResource_Resource_Call) Return() *isResource_Resource_isResource_Resource_Call { + _c.Call.Return() + return _c +} + +func (_c *isResource_Resource_isResource_Resource_Call) RunAndReturn(run func()) *isResource_Resource_isResource_Resource_Call { + _c.Run(run) + return _c +} + +// newIsResource_Resource creates a new instance of isResource_Resource. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsResource_Resource(t interface { + mock.TestingT + Cleanup(func()) +}) *isResource_Resource { + mock := &isResource_Resource{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/common/phase.pb.go b/gen/go/flyteidl2/common/phase.pb.go new file mode 100644 index 0000000000..e074df9558 --- /dev/null +++ b/gen/go/flyteidl2/common/phase.pb.go @@ -0,0 +1,188 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/common/phase.proto + +package common + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// ActionPhase represents the execution state of an action. +// +// Phase transitions follow this typical flow: +// QUEUED -> WAITING_FOR_RESOURCES -> INITIALIZING -> RUNNING -> {SUCCEEDED|FAILED|ABORTED|TIMED_OUT} +type ActionPhase int32 + +const ( + // Default/unknown phase + ActionPhase_ACTION_PHASE_UNSPECIFIED ActionPhase = 0 + // Action has been accepted and is waiting to be scheduled + ActionPhase_ACTION_PHASE_QUEUED ActionPhase = 1 + // Action is scheduled but waiting for compute resources to become available + ActionPhase_ACTION_PHASE_WAITING_FOR_RESOURCES ActionPhase = 2 + // Resources have been allocated and the action is being set up + ActionPhase_ACTION_PHASE_INITIALIZING ActionPhase = 3 + // Action is actively executing + ActionPhase_ACTION_PHASE_RUNNING ActionPhase = 4 + // Action completed successfully + ActionPhase_ACTION_PHASE_SUCCEEDED ActionPhase = 5 + // Action failed during execution + ActionPhase_ACTION_PHASE_FAILED ActionPhase = 6 + // Action was manually terminated or cancelled + ActionPhase_ACTION_PHASE_ABORTED ActionPhase = 7 + // Action exceeded its execution time limit + ActionPhase_ACTION_PHASE_TIMED_OUT ActionPhase = 8 +) + +// Enum value maps for ActionPhase. +var ( + ActionPhase_name = map[int32]string{ + 0: "ACTION_PHASE_UNSPECIFIED", + 1: "ACTION_PHASE_QUEUED", + 2: "ACTION_PHASE_WAITING_FOR_RESOURCES", + 3: "ACTION_PHASE_INITIALIZING", + 4: "ACTION_PHASE_RUNNING", + 5: "ACTION_PHASE_SUCCEEDED", + 6: "ACTION_PHASE_FAILED", + 7: "ACTION_PHASE_ABORTED", + 8: "ACTION_PHASE_TIMED_OUT", + } + ActionPhase_value = map[string]int32{ + "ACTION_PHASE_UNSPECIFIED": 0, + "ACTION_PHASE_QUEUED": 1, + "ACTION_PHASE_WAITING_FOR_RESOURCES": 2, + "ACTION_PHASE_INITIALIZING": 3, + "ACTION_PHASE_RUNNING": 4, + "ACTION_PHASE_SUCCEEDED": 5, + "ACTION_PHASE_FAILED": 6, + "ACTION_PHASE_ABORTED": 7, + "ACTION_PHASE_TIMED_OUT": 8, + } +) + +func (x ActionPhase) Enum() *ActionPhase { + p := new(ActionPhase) + *p = x + return p +} + +func (x ActionPhase) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ActionPhase) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_common_phase_proto_enumTypes[0].Descriptor() +} + +func (ActionPhase) Type() protoreflect.EnumType { + return &file_flyteidl2_common_phase_proto_enumTypes[0] +} + +func (x ActionPhase) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use ActionPhase.Descriptor instead. +func (ActionPhase) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_common_phase_proto_rawDescGZIP(), []int{0} +} + +var File_flyteidl2_common_phase_proto protoreflect.FileDescriptor + +var file_flyteidl2_common_phase_proto_rawDesc = []byte{ + 0x0a, 0x1c, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2f, 0x70, 0x68, 0x61, 0x73, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2a, 0x90, 0x02, 0x0a, 0x0b, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x68, 0x61, 0x73, 0x65, + 0x12, 0x1c, 0x0a, 0x18, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x48, 0x41, 0x53, 0x45, + 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x17, + 0x0a, 0x13, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x48, 0x41, 0x53, 0x45, 0x5f, 0x51, + 0x55, 0x45, 0x55, 0x45, 0x44, 0x10, 0x01, 0x12, 0x26, 0x0a, 0x22, 0x41, 0x43, 0x54, 0x49, 0x4f, + 0x4e, 0x5f, 0x50, 0x48, 0x41, 0x53, 0x45, 0x5f, 0x57, 0x41, 0x49, 0x54, 0x49, 0x4e, 0x47, 0x5f, + 0x46, 0x4f, 0x52, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x53, 0x10, 0x02, 0x12, + 0x1d, 0x0a, 0x19, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x48, 0x41, 0x53, 0x45, 0x5f, + 0x49, 0x4e, 0x49, 0x54, 0x49, 0x41, 0x4c, 0x49, 0x5a, 0x49, 0x4e, 0x47, 0x10, 0x03, 0x12, 0x18, + 0x0a, 0x14, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x48, 0x41, 0x53, 0x45, 0x5f, 0x52, + 0x55, 0x4e, 0x4e, 0x49, 0x4e, 0x47, 0x10, 0x04, 0x12, 0x1a, 0x0a, 0x16, 0x41, 0x43, 0x54, 0x49, + 0x4f, 0x4e, 0x5f, 0x50, 0x48, 0x41, 0x53, 0x45, 0x5f, 0x53, 0x55, 0x43, 0x43, 0x45, 0x45, 0x44, + 0x45, 0x44, 0x10, 0x05, 0x12, 0x17, 0x0a, 0x13, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, + 0x48, 0x41, 0x53, 0x45, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x10, 0x06, 0x12, 0x18, 0x0a, + 0x14, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x48, 0x41, 0x53, 0x45, 0x5f, 0x41, 0x42, + 0x4f, 0x52, 0x54, 0x45, 0x44, 0x10, 0x07, 0x12, 0x1a, 0x0a, 0x16, 0x41, 0x43, 0x54, 0x49, 0x4f, + 0x4e, 0x5f, 0x50, 0x48, 0x41, 0x53, 0x45, 0x5f, 0x54, 0x49, 0x4d, 0x45, 0x44, 0x5f, 0x4f, 0x55, + 0x54, 0x10, 0x08, 0x42, 0xbb, 0x01, 0x0a, 0x14, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x42, 0x0a, 0x50, 0x68, + 0x61, 0x73, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x34, 0x67, 0x69, + 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, + 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, + 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xca, 0x02, 0x10, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xe2, 0x02, + 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x11, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_common_phase_proto_rawDescOnce sync.Once + file_flyteidl2_common_phase_proto_rawDescData = file_flyteidl2_common_phase_proto_rawDesc +) + +func file_flyteidl2_common_phase_proto_rawDescGZIP() []byte { + file_flyteidl2_common_phase_proto_rawDescOnce.Do(func() { + file_flyteidl2_common_phase_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_common_phase_proto_rawDescData) + }) + return file_flyteidl2_common_phase_proto_rawDescData +} + +var file_flyteidl2_common_phase_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_flyteidl2_common_phase_proto_goTypes = []interface{}{ + (ActionPhase)(0), // 0: flyteidl2.common.ActionPhase +} +var file_flyteidl2_common_phase_proto_depIdxs = []int32{ + 0, // [0:0] is the sub-list for method output_type + 0, // [0:0] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_flyteidl2_common_phase_proto_init() } +func file_flyteidl2_common_phase_proto_init() { + if File_flyteidl2_common_phase_proto != nil { + return + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_common_phase_proto_rawDesc, + NumEnums: 1, + NumMessages: 0, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_common_phase_proto_goTypes, + DependencyIndexes: file_flyteidl2_common_phase_proto_depIdxs, + EnumInfos: file_flyteidl2_common_phase_proto_enumTypes, + }.Build() + File_flyteidl2_common_phase_proto = out.File + file_flyteidl2_common_phase_proto_rawDesc = nil + file_flyteidl2_common_phase_proto_goTypes = nil + file_flyteidl2_common_phase_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/common/phase.pb.validate.go b/gen/go/flyteidl2/common/phase.pb.validate.go new file mode 100644 index 0000000000..b77dde980d --- /dev/null +++ b/gen/go/flyteidl2/common/phase.pb.validate.go @@ -0,0 +1,36 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/common/phase.proto + +package common + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) diff --git a/gen/go/flyteidl2/common/policy.pb.go b/gen/go/flyteidl2/common/policy.pb.go new file mode 100644 index 0000000000..2eaa85920a --- /dev/null +++ b/gen/go/flyteidl2/common/policy.pb.go @@ -0,0 +1,276 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/common/policy.proto + +package common + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// A policy is a collection of roles bound to a resource. +type Policy struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id *PolicyIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Bindings []*PolicyBinding `protobuf:"bytes,2,rep,name=bindings,proto3" json:"bindings,omitempty"` + // Optional: human readable description + Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` +} + +func (x *Policy) Reset() { + *x = Policy{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_policy_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Policy) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Policy) ProtoMessage() {} + +func (x *Policy) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_policy_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Policy.ProtoReflect.Descriptor instead. +func (*Policy) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_policy_proto_rawDescGZIP(), []int{0} +} + +func (x *Policy) GetId() *PolicyIdentifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *Policy) GetBindings() []*PolicyBinding { + if x != nil { + return x.Bindings + } + return nil +} + +func (x *Policy) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +// A policy binding represents a role (a set of actions) defined on a resource. +type PolicyBinding struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The role designates the permitted set of actions which can be applied to the resource. + RoleId *RoleIdentifier `protobuf:"bytes,1,opt,name=role_id,json=roleId,proto3" json:"role_id,omitempty"` + Resource *Resource `protobuf:"bytes,2,opt,name=resource,proto3" json:"resource,omitempty"` +} + +func (x *PolicyBinding) Reset() { + *x = PolicyBinding{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_policy_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PolicyBinding) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PolicyBinding) ProtoMessage() {} + +func (x *PolicyBinding) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_policy_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PolicyBinding.ProtoReflect.Descriptor instead. +func (*PolicyBinding) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_policy_proto_rawDescGZIP(), []int{1} +} + +func (x *PolicyBinding) GetRoleId() *RoleIdentifier { + if x != nil { + return x.RoleId + } + return nil +} + +func (x *PolicyBinding) GetResource() *Resource { + if x != nil { + return x.Resource + } + return nil +} + +var File_flyteidl2_common_policy_proto protoreflect.FileDescriptor + +var file_flyteidl2_common_policy_proto_rawDesc = []byte{ + 0x0a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, + 0x10, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2f, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa3, 0x01, 0x0a, 0x06, 0x50, 0x6f, 0x6c, 0x69, + 0x63, 0x79, 0x12, 0x3a, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3b, + 0x0a, 0x08, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, + 0x67, 0x52, 0x08, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x64, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x92, 0x01, + 0x0a, 0x0d, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x12, + 0x41, 0x0a, 0x07, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x06, 0x72, 0x6f, 0x6c, 0x65, + 0x49, 0x64, 0x12, 0x3e, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x42, 0xbc, 0x01, 0x0a, 0x14, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x42, 0x0b, 0x50, 0x6f, 0x6c, + 0x69, 0x63, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x34, 0x67, 0x69, + 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, + 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, + 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xca, 0x02, 0x10, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xe2, 0x02, + 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x11, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_common_policy_proto_rawDescOnce sync.Once + file_flyteidl2_common_policy_proto_rawDescData = file_flyteidl2_common_policy_proto_rawDesc +) + +func file_flyteidl2_common_policy_proto_rawDescGZIP() []byte { + file_flyteidl2_common_policy_proto_rawDescOnce.Do(func() { + file_flyteidl2_common_policy_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_common_policy_proto_rawDescData) + }) + return file_flyteidl2_common_policy_proto_rawDescData +} + +var file_flyteidl2_common_policy_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_flyteidl2_common_policy_proto_goTypes = []interface{}{ + (*Policy)(nil), // 0: flyteidl2.common.Policy + (*PolicyBinding)(nil), // 1: flyteidl2.common.PolicyBinding + (*PolicyIdentifier)(nil), // 2: flyteidl2.common.PolicyIdentifier + (*RoleIdentifier)(nil), // 3: flyteidl2.common.RoleIdentifier + (*Resource)(nil), // 4: flyteidl2.common.Resource +} +var file_flyteidl2_common_policy_proto_depIdxs = []int32{ + 2, // 0: flyteidl2.common.Policy.id:type_name -> flyteidl2.common.PolicyIdentifier + 1, // 1: flyteidl2.common.Policy.bindings:type_name -> flyteidl2.common.PolicyBinding + 3, // 2: flyteidl2.common.PolicyBinding.role_id:type_name -> flyteidl2.common.RoleIdentifier + 4, // 3: flyteidl2.common.PolicyBinding.resource:type_name -> flyteidl2.common.Resource + 4, // [4:4] is the sub-list for method output_type + 4, // [4:4] is the sub-list for method input_type + 4, // [4:4] is the sub-list for extension type_name + 4, // [4:4] is the sub-list for extension extendee + 0, // [0:4] is the sub-list for field type_name +} + +func init() { file_flyteidl2_common_policy_proto_init() } +func file_flyteidl2_common_policy_proto_init() { + if File_flyteidl2_common_policy_proto != nil { + return + } + file_flyteidl2_common_authorization_proto_init() + file_flyteidl2_common_identifier_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_common_policy_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Policy); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_policy_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PolicyBinding); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_common_policy_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_common_policy_proto_goTypes, + DependencyIndexes: file_flyteidl2_common_policy_proto_depIdxs, + MessageInfos: file_flyteidl2_common_policy_proto_msgTypes, + }.Build() + File_flyteidl2_common_policy_proto = out.File + file_flyteidl2_common_policy_proto_rawDesc = nil + file_flyteidl2_common_policy_proto_goTypes = nil + file_flyteidl2_common_policy_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/common/policy.pb.validate.go b/gen/go/flyteidl2/common/policy.pb.validate.go new file mode 100644 index 0000000000..69d7344e28 --- /dev/null +++ b/gen/go/flyteidl2/common/policy.pb.validate.go @@ -0,0 +1,357 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/common/policy.proto + +package common + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on Policy with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Policy) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Policy with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in PolicyMultiError, or nil if none found. +func (m *Policy) ValidateAll() error { + return m.validate(true) +} + +func (m *Policy) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PolicyValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PolicyValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PolicyValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetBindings() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PolicyValidationError{ + field: fmt.Sprintf("Bindings[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PolicyValidationError{ + field: fmt.Sprintf("Bindings[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PolicyValidationError{ + field: fmt.Sprintf("Bindings[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Description + + if len(errors) > 0 { + return PolicyMultiError(errors) + } + + return nil +} + +// PolicyMultiError is an error wrapping multiple validation errors returned by +// Policy.ValidateAll() if the designated constraints aren't met. +type PolicyMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PolicyMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PolicyMultiError) AllErrors() []error { return m } + +// PolicyValidationError is the validation error returned by Policy.Validate if +// the designated constraints aren't met. +type PolicyValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PolicyValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PolicyValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PolicyValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PolicyValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PolicyValidationError) ErrorName() string { return "PolicyValidationError" } + +// Error satisfies the builtin error interface +func (e PolicyValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPolicy.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PolicyValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PolicyValidationError{} + +// Validate checks the field values on PolicyBinding with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *PolicyBinding) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on PolicyBinding with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in PolicyBindingMultiError, or +// nil if none found. +func (m *PolicyBinding) ValidateAll() error { + return m.validate(true) +} + +func (m *PolicyBinding) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRoleId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PolicyBindingValidationError{ + field: "RoleId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PolicyBindingValidationError{ + field: "RoleId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRoleId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PolicyBindingValidationError{ + field: "RoleId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetResource()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PolicyBindingValidationError{ + field: "Resource", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PolicyBindingValidationError{ + field: "Resource", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetResource()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PolicyBindingValidationError{ + field: "Resource", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return PolicyBindingMultiError(errors) + } + + return nil +} + +// PolicyBindingMultiError is an error wrapping multiple validation errors +// returned by PolicyBinding.ValidateAll() if the designated constraints +// aren't met. +type PolicyBindingMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PolicyBindingMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PolicyBindingMultiError) AllErrors() []error { return m } + +// PolicyBindingValidationError is the validation error returned by +// PolicyBinding.Validate if the designated constraints aren't met. +type PolicyBindingValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PolicyBindingValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PolicyBindingValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PolicyBindingValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PolicyBindingValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PolicyBindingValidationError) ErrorName() string { return "PolicyBindingValidationError" } + +// Error satisfies the builtin error interface +func (e PolicyBindingValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPolicyBinding.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PolicyBindingValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PolicyBindingValidationError{} diff --git a/gen/go/flyteidl2/common/role.pb.go b/gen/go/flyteidl2/common/role.pb.go new file mode 100644 index 0000000000..b7a4193faa --- /dev/null +++ b/gen/go/flyteidl2/common/role.pb.go @@ -0,0 +1,390 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/common/role.proto + +package common + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// A role type is a short-hand for understanding the permissions associated with a role. +// Boilerplate role types include a conventional collection of permissions +// Custom role types include a user-defined collection of permissions +type RoleType int32 + +const ( + // Default group. Not used in practice. + RoleType_ROLE_TYPE_NONE RoleType = 0 + // The admin role has a collective set of permissions to do everything + RoleType_ROLE_TYPE_ADMIN RoleType = 1 + // The contributor role has a collective set of permissions to view inventory, view executions, write inventory and create executions + RoleType_ROLE_TYPE_CONTRIBUTOR RoleType = 2 + // The viewer role has a collective set of permissions to view inventory and view executions + RoleType_ROLE_TYPE_VIEWER RoleType = 3 + // Represent a role with user-defined sets of permissions. + RoleType_ROLE_TYPE_CUSTOM RoleType = 4 + // The role with permissions to administer a specific customer cluster. + RoleType_ROLE_TYPE_CLUSTER_MANAGER RoleType = 5 + // Role with permissions specific to administer flyte project(s). + RoleType_ROLE_TYPE_FLYTE_PROJECT_ADMIN RoleType = 6 + // The viewer role for serverless + RoleType_ROLE_TYPE_SERVERLESS_VIEWER RoleType = 7 + // The contributor role for serverless + RoleType_ROLE_TYPE_SERVERLESS_CONTRIBUTOR RoleType = 8 + // The support role would have contributor permissions plus the access to support endpoints + RoleType_ROLE_TYPE_SUPPORT RoleType = 9 +) + +// Enum value maps for RoleType. +var ( + RoleType_name = map[int32]string{ + 0: "ROLE_TYPE_NONE", + 1: "ROLE_TYPE_ADMIN", + 2: "ROLE_TYPE_CONTRIBUTOR", + 3: "ROLE_TYPE_VIEWER", + 4: "ROLE_TYPE_CUSTOM", + 5: "ROLE_TYPE_CLUSTER_MANAGER", + 6: "ROLE_TYPE_FLYTE_PROJECT_ADMIN", + 7: "ROLE_TYPE_SERVERLESS_VIEWER", + 8: "ROLE_TYPE_SERVERLESS_CONTRIBUTOR", + 9: "ROLE_TYPE_SUPPORT", + } + RoleType_value = map[string]int32{ + "ROLE_TYPE_NONE": 0, + "ROLE_TYPE_ADMIN": 1, + "ROLE_TYPE_CONTRIBUTOR": 2, + "ROLE_TYPE_VIEWER": 3, + "ROLE_TYPE_CUSTOM": 4, + "ROLE_TYPE_CLUSTER_MANAGER": 5, + "ROLE_TYPE_FLYTE_PROJECT_ADMIN": 6, + "ROLE_TYPE_SERVERLESS_VIEWER": 7, + "ROLE_TYPE_SERVERLESS_CONTRIBUTOR": 8, + "ROLE_TYPE_SUPPORT": 9, + } +) + +func (x RoleType) Enum() *RoleType { + p := new(RoleType) + *p = x + return p +} + +func (x RoleType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (RoleType) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_common_role_proto_enumTypes[0].Descriptor() +} + +func (RoleType) Type() protoreflect.EnumType { + return &file_flyteidl2_common_role_proto_enumTypes[0] +} + +func (x RoleType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use RoleType.Descriptor instead. +func (RoleType) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_common_role_proto_rawDescGZIP(), []int{0} +} + +type Role struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id *RoleIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // Deprecated: Marked as deprecated in flyteidl2/common/role.proto. + Permissions []*Permission `protobuf:"bytes,2,rep,name=permissions,proto3" json:"permissions,omitempty"` + RoleSpec *RoleSpec `protobuf:"bytes,3,opt,name=role_spec,json=roleSpec,proto3" json:"role_spec,omitempty"` + RoleType RoleType `protobuf:"varint,4,opt,name=role_type,json=roleType,proto3,enum=flyteidl2.common.RoleType" json:"role_type,omitempty"` + Actions []Action `protobuf:"varint,5,rep,packed,name=actions,proto3,enum=flyteidl2.common.Action" json:"actions,omitempty"` +} + +func (x *Role) Reset() { + *x = Role{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_role_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Role) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Role) ProtoMessage() {} + +func (x *Role) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_role_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Role.ProtoReflect.Descriptor instead. +func (*Role) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_role_proto_rawDescGZIP(), []int{0} +} + +func (x *Role) GetId() *RoleIdentifier { + if x != nil { + return x.Id + } + return nil +} + +// Deprecated: Marked as deprecated in flyteidl2/common/role.proto. +func (x *Role) GetPermissions() []*Permission { + if x != nil { + return x.Permissions + } + return nil +} + +func (x *Role) GetRoleSpec() *RoleSpec { + if x != nil { + return x.RoleSpec + } + return nil +} + +func (x *Role) GetRoleType() RoleType { + if x != nil { + return x.RoleType + } + return RoleType_ROLE_TYPE_NONE +} + +func (x *Role) GetActions() []Action { + if x != nil { + return x.Actions + } + return nil +} + +type RoleSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Optional, human readable description for this role. + Description string `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"` +} + +func (x *RoleSpec) Reset() { + *x = RoleSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_role_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RoleSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RoleSpec) ProtoMessage() {} + +func (x *RoleSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_role_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RoleSpec.ProtoReflect.Descriptor instead. +func (*RoleSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_role_proto_rawDescGZIP(), []int{1} +} + +func (x *RoleSpec) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +var File_flyteidl2_common_role_proto protoreflect.FileDescriptor + +var file_flyteidl2_common_role_proto_rawDesc = []byte{ + 0x0a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2f, 0x72, 0x6f, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x1a, + 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x61, + 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xaa, 0x02, 0x0a, 0x04, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x38, + 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x6f, + 0x6c, 0x65, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, + 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0x42, 0x0a, 0x0b, 0x70, 0x65, 0x72, 0x6d, + 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x02, 0x18, 0x01, 0x52, + 0x0b, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x37, 0x0a, 0x09, + 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x53, 0x70, 0x65, 0x63, 0x52, 0x08, 0x72, 0x6f, 0x6c, + 0x65, 0x53, 0x70, 0x65, 0x63, 0x12, 0x37, 0x0a, 0x09, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x74, 0x79, + 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x6f, 0x6c, 0x65, + 0x54, 0x79, 0x70, 0x65, 0x52, 0x08, 0x72, 0x6f, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x32, + 0x0a, 0x07, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0e, 0x32, + 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x22, 0x2c, 0x0a, 0x08, 0x52, 0x6f, 0x6c, 0x65, 0x53, 0x70, 0x65, 0x63, 0x12, 0x20, + 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x2a, 0x9a, 0x02, 0x0a, 0x08, 0x52, 0x6f, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, + 0x0e, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, + 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x41, + 0x44, 0x4d, 0x49, 0x4e, 0x10, 0x01, 0x12, 0x19, 0x0a, 0x15, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x43, 0x4f, 0x4e, 0x54, 0x52, 0x49, 0x42, 0x55, 0x54, 0x4f, 0x52, 0x10, + 0x02, 0x12, 0x14, 0x0a, 0x10, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x56, + 0x49, 0x45, 0x57, 0x45, 0x52, 0x10, 0x03, 0x12, 0x14, 0x0a, 0x10, 0x52, 0x4f, 0x4c, 0x45, 0x5f, + 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, 0x55, 0x53, 0x54, 0x4f, 0x4d, 0x10, 0x04, 0x12, 0x1d, 0x0a, + 0x19, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, + 0x45, 0x52, 0x5f, 0x4d, 0x41, 0x4e, 0x41, 0x47, 0x45, 0x52, 0x10, 0x05, 0x12, 0x21, 0x0a, 0x1d, + 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46, 0x4c, 0x59, 0x54, 0x45, 0x5f, + 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x41, 0x44, 0x4d, 0x49, 0x4e, 0x10, 0x06, 0x12, + 0x1f, 0x0a, 0x1b, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x45, 0x52, + 0x56, 0x45, 0x52, 0x4c, 0x45, 0x53, 0x53, 0x5f, 0x56, 0x49, 0x45, 0x57, 0x45, 0x52, 0x10, 0x07, + 0x12, 0x24, 0x0a, 0x20, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x45, + 0x52, 0x56, 0x45, 0x52, 0x4c, 0x45, 0x53, 0x53, 0x5f, 0x43, 0x4f, 0x4e, 0x54, 0x52, 0x49, 0x42, + 0x55, 0x54, 0x4f, 0x52, 0x10, 0x08, 0x12, 0x15, 0x0a, 0x11, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x53, 0x55, 0x50, 0x50, 0x4f, 0x52, 0x54, 0x10, 0x09, 0x42, 0xba, 0x01, + 0x0a, 0x14, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x42, 0x09, 0x52, 0x6f, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x74, + 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, + 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xa2, 0x02, 0x03, 0x46, 0x43, + 0x58, 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0xca, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xe2, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x33, +} + +var ( + file_flyteidl2_common_role_proto_rawDescOnce sync.Once + file_flyteidl2_common_role_proto_rawDescData = file_flyteidl2_common_role_proto_rawDesc +) + +func file_flyteidl2_common_role_proto_rawDescGZIP() []byte { + file_flyteidl2_common_role_proto_rawDescOnce.Do(func() { + file_flyteidl2_common_role_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_common_role_proto_rawDescData) + }) + return file_flyteidl2_common_role_proto_rawDescData +} + +var file_flyteidl2_common_role_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_flyteidl2_common_role_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_flyteidl2_common_role_proto_goTypes = []interface{}{ + (RoleType)(0), // 0: flyteidl2.common.RoleType + (*Role)(nil), // 1: flyteidl2.common.Role + (*RoleSpec)(nil), // 2: flyteidl2.common.RoleSpec + (*RoleIdentifier)(nil), // 3: flyteidl2.common.RoleIdentifier + (*Permission)(nil), // 4: flyteidl2.common.Permission + (Action)(0), // 5: flyteidl2.common.Action +} +var file_flyteidl2_common_role_proto_depIdxs = []int32{ + 3, // 0: flyteidl2.common.Role.id:type_name -> flyteidl2.common.RoleIdentifier + 4, // 1: flyteidl2.common.Role.permissions:type_name -> flyteidl2.common.Permission + 2, // 2: flyteidl2.common.Role.role_spec:type_name -> flyteidl2.common.RoleSpec + 0, // 3: flyteidl2.common.Role.role_type:type_name -> flyteidl2.common.RoleType + 5, // 4: flyteidl2.common.Role.actions:type_name -> flyteidl2.common.Action + 5, // [5:5] is the sub-list for method output_type + 5, // [5:5] is the sub-list for method input_type + 5, // [5:5] is the sub-list for extension type_name + 5, // [5:5] is the sub-list for extension extendee + 0, // [0:5] is the sub-list for field type_name +} + +func init() { file_flyteidl2_common_role_proto_init() } +func file_flyteidl2_common_role_proto_init() { + if File_flyteidl2_common_role_proto != nil { + return + } + file_flyteidl2_common_authorization_proto_init() + file_flyteidl2_common_identifier_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_common_role_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Role); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_common_role_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RoleSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_common_role_proto_rawDesc, + NumEnums: 1, + NumMessages: 2, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_common_role_proto_goTypes, + DependencyIndexes: file_flyteidl2_common_role_proto_depIdxs, + EnumInfos: file_flyteidl2_common_role_proto_enumTypes, + MessageInfos: file_flyteidl2_common_role_proto_msgTypes, + }.Build() + File_flyteidl2_common_role_proto = out.File + file_flyteidl2_common_role_proto_rawDesc = nil + file_flyteidl2_common_role_proto_goTypes = nil + file_flyteidl2_common_role_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/common/role.pb.validate.go b/gen/go/flyteidl2/common/role.pb.validate.go new file mode 100644 index 0000000000..b5e0c1f244 --- /dev/null +++ b/gen/go/flyteidl2/common/role.pb.validate.go @@ -0,0 +1,329 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/common/role.proto + +package common + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on Role with the rules defined in the proto +// definition for this message. If any rules are violated, the first error +// encountered is returned, or nil if there are no violations. +func (m *Role) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Role with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in RoleMultiError, or nil if none found. +func (m *Role) ValidateAll() error { + return m.validate(true) +} + +func (m *Role) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, RoleValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, RoleValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return RoleValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetPermissions() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, RoleValidationError{ + field: fmt.Sprintf("Permissions[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, RoleValidationError{ + field: fmt.Sprintf("Permissions[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return RoleValidationError{ + field: fmt.Sprintf("Permissions[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if all { + switch v := interface{}(m.GetRoleSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, RoleValidationError{ + field: "RoleSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, RoleValidationError{ + field: "RoleSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRoleSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return RoleValidationError{ + field: "RoleSpec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for RoleType + + if len(errors) > 0 { + return RoleMultiError(errors) + } + + return nil +} + +// RoleMultiError is an error wrapping multiple validation errors returned by +// Role.ValidateAll() if the designated constraints aren't met. +type RoleMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m RoleMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m RoleMultiError) AllErrors() []error { return m } + +// RoleValidationError is the validation error returned by Role.Validate if the +// designated constraints aren't met. +type RoleValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e RoleValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e RoleValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e RoleValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e RoleValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e RoleValidationError) ErrorName() string { return "RoleValidationError" } + +// Error satisfies the builtin error interface +func (e RoleValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sRole.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = RoleValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = RoleValidationError{} + +// Validate checks the field values on RoleSpec with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *RoleSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on RoleSpec with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in RoleSpecMultiError, or nil +// if none found. +func (m *RoleSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *RoleSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Description + + if len(errors) > 0 { + return RoleSpecMultiError(errors) + } + + return nil +} + +// RoleSpecMultiError is an error wrapping multiple validation errors returned +// by RoleSpec.ValidateAll() if the designated constraints aren't met. +type RoleSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m RoleSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m RoleSpecMultiError) AllErrors() []error { return m } + +// RoleSpecValidationError is the validation error returned by +// RoleSpec.Validate if the designated constraints aren't met. +type RoleSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e RoleSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e RoleSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e RoleSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e RoleSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e RoleSpecValidationError) ErrorName() string { return "RoleSpecValidationError" } + +// Error satisfies the builtin error interface +func (e RoleSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sRoleSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = RoleSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = RoleSpecValidationError{} diff --git a/gen/go/flyteidl2/common/runtime_version.pb.go b/gen/go/flyteidl2/common/runtime_version.pb.go new file mode 100644 index 0000000000..9cec040e25 --- /dev/null +++ b/gen/go/flyteidl2/common/runtime_version.pb.go @@ -0,0 +1,239 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/common/runtime_version.proto + +package common + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type RuntimeMetadata_RuntimeType int32 + +const ( + RuntimeMetadata_OTHER RuntimeMetadata_RuntimeType = 0 + RuntimeMetadata_FLYTE_SDK RuntimeMetadata_RuntimeType = 1 + RuntimeMetadata_UNION_SDK RuntimeMetadata_RuntimeType = 2 +) + +// Enum value maps for RuntimeMetadata_RuntimeType. +var ( + RuntimeMetadata_RuntimeType_name = map[int32]string{ + 0: "OTHER", + 1: "FLYTE_SDK", + 2: "UNION_SDK", + } + RuntimeMetadata_RuntimeType_value = map[string]int32{ + "OTHER": 0, + "FLYTE_SDK": 1, + "UNION_SDK": 2, + } +) + +func (x RuntimeMetadata_RuntimeType) Enum() *RuntimeMetadata_RuntimeType { + p := new(RuntimeMetadata_RuntimeType) + *p = x + return p +} + +func (x RuntimeMetadata_RuntimeType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (RuntimeMetadata_RuntimeType) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_common_runtime_version_proto_enumTypes[0].Descriptor() +} + +func (RuntimeMetadata_RuntimeType) Type() protoreflect.EnumType { + return &file_flyteidl2_common_runtime_version_proto_enumTypes[0] +} + +func (x RuntimeMetadata_RuntimeType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use RuntimeMetadata_RuntimeType.Descriptor instead. +func (RuntimeMetadata_RuntimeType) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_common_runtime_version_proto_rawDescGZIP(), []int{0, 0} +} + +// Runtime information. This is loosely defined to allow for extensibility. +type RuntimeMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Type of runtime. + Type RuntimeMetadata_RuntimeType `protobuf:"varint,1,opt,name=type,proto3,enum=flyteidl2.common.RuntimeMetadata_RuntimeType" json:"type,omitempty"` + // Version of the runtime. All versions should be backward compatible. However, certain cases call for version + // checks to ensure tighter validation or setting expectations. + Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"` + // +optional It can be used to provide extra information about the runtime (e.g. python, golang... etc.). + Flavor string `protobuf:"bytes,3,opt,name=flavor,proto3" json:"flavor,omitempty"` +} + +func (x *RuntimeMetadata) Reset() { + *x = RuntimeMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_common_runtime_version_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RuntimeMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RuntimeMetadata) ProtoMessage() {} + +func (x *RuntimeMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_common_runtime_version_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RuntimeMetadata.ProtoReflect.Descriptor instead. +func (*RuntimeMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_common_runtime_version_proto_rawDescGZIP(), []int{0} +} + +func (x *RuntimeMetadata) GetType() RuntimeMetadata_RuntimeType { + if x != nil { + return x.Type + } + return RuntimeMetadata_OTHER +} + +func (x *RuntimeMetadata) GetVersion() string { + if x != nil { + return x.Version + } + return "" +} + +func (x *RuntimeMetadata) GetFlavor() string { + if x != nil { + return x.Flavor + } + return "" +} + +var File_flyteidl2_common_runtime_version_proto protoreflect.FileDescriptor + +var file_flyteidl2_common_runtime_version_proto_rawDesc = []byte{ + 0x0a, 0x26, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2f, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x22, 0xbe, 0x01, 0x0a, 0x0f, 0x52, + 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x41, + 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, + 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x66, + 0x6c, 0x61, 0x76, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, 0x6c, 0x61, + 0x76, 0x6f, 0x72, 0x22, 0x36, 0x0a, 0x0b, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x09, 0x0a, 0x05, 0x4f, 0x54, 0x48, 0x45, 0x52, 0x10, 0x00, 0x12, 0x0d, 0x0a, + 0x09, 0x46, 0x4c, 0x59, 0x54, 0x45, 0x5f, 0x53, 0x44, 0x4b, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, + 0x55, 0x4e, 0x49, 0x4f, 0x4e, 0x5f, 0x53, 0x44, 0x4b, 0x10, 0x02, 0x42, 0xc4, 0x01, 0x0a, 0x14, + 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x42, 0x13, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x56, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x34, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, + 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, + 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xca, 0x02, 0x10, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xe2, + 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, + 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_common_runtime_version_proto_rawDescOnce sync.Once + file_flyteidl2_common_runtime_version_proto_rawDescData = file_flyteidl2_common_runtime_version_proto_rawDesc +) + +func file_flyteidl2_common_runtime_version_proto_rawDescGZIP() []byte { + file_flyteidl2_common_runtime_version_proto_rawDescOnce.Do(func() { + file_flyteidl2_common_runtime_version_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_common_runtime_version_proto_rawDescData) + }) + return file_flyteidl2_common_runtime_version_proto_rawDescData +} + +var file_flyteidl2_common_runtime_version_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_flyteidl2_common_runtime_version_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_flyteidl2_common_runtime_version_proto_goTypes = []interface{}{ + (RuntimeMetadata_RuntimeType)(0), // 0: flyteidl2.common.RuntimeMetadata.RuntimeType + (*RuntimeMetadata)(nil), // 1: flyteidl2.common.RuntimeMetadata +} +var file_flyteidl2_common_runtime_version_proto_depIdxs = []int32{ + 0, // 0: flyteidl2.common.RuntimeMetadata.type:type_name -> flyteidl2.common.RuntimeMetadata.RuntimeType + 1, // [1:1] is the sub-list for method output_type + 1, // [1:1] is the sub-list for method input_type + 1, // [1:1] is the sub-list for extension type_name + 1, // [1:1] is the sub-list for extension extendee + 0, // [0:1] is the sub-list for field type_name +} + +func init() { file_flyteidl2_common_runtime_version_proto_init() } +func file_flyteidl2_common_runtime_version_proto_init() { + if File_flyteidl2_common_runtime_version_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_common_runtime_version_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RuntimeMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_common_runtime_version_proto_rawDesc, + NumEnums: 1, + NumMessages: 1, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_common_runtime_version_proto_goTypes, + DependencyIndexes: file_flyteidl2_common_runtime_version_proto_depIdxs, + EnumInfos: file_flyteidl2_common_runtime_version_proto_enumTypes, + MessageInfos: file_flyteidl2_common_runtime_version_proto_msgTypes, + }.Build() + File_flyteidl2_common_runtime_version_proto = out.File + file_flyteidl2_common_runtime_version_proto_rawDesc = nil + file_flyteidl2_common_runtime_version_proto_goTypes = nil + file_flyteidl2_common_runtime_version_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/common/runtime_version.pb.validate.go b/gen/go/flyteidl2/common/runtime_version.pb.validate.go new file mode 100644 index 0000000000..23c11b67d6 --- /dev/null +++ b/gen/go/flyteidl2/common/runtime_version.pb.validate.go @@ -0,0 +1,142 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/common/runtime_version.proto + +package common + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on RuntimeMetadata with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *RuntimeMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on RuntimeMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// RuntimeMetadataMultiError, or nil if none found. +func (m *RuntimeMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *RuntimeMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Type + + // no validation rules for Version + + // no validation rules for Flavor + + if len(errors) > 0 { + return RuntimeMetadataMultiError(errors) + } + + return nil +} + +// RuntimeMetadataMultiError is an error wrapping multiple validation errors +// returned by RuntimeMetadata.ValidateAll() if the designated constraints +// aren't met. +type RuntimeMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m RuntimeMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m RuntimeMetadataMultiError) AllErrors() []error { return m } + +// RuntimeMetadataValidationError is the validation error returned by +// RuntimeMetadata.Validate if the designated constraints aren't met. +type RuntimeMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e RuntimeMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e RuntimeMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e RuntimeMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e RuntimeMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e RuntimeMetadataValidationError) ErrorName() string { return "RuntimeMetadataValidationError" } + +// Error satisfies the builtin error interface +func (e RuntimeMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sRuntimeMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = RuntimeMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = RuntimeMetadataValidationError{} diff --git a/gen/go/flyteidl2/connector/connector.pb.go b/gen/go/flyteidl2/connector/connector.pb.go new file mode 100644 index 0000000000..ec464946d1 --- /dev/null +++ b/gen/go/flyteidl2/connector/connector.pb.go @@ -0,0 +1,2046 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/connector/connector.proto + +package connector + +import ( + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + task "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + durationpb "google.golang.org/protobuf/types/known/durationpb" + structpb "google.golang.org/protobuf/types/known/structpb" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Represents a subset of runtime task execution metadata that are relevant to external plugins. +type TaskExecutionMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TaskExecutionId *core.TaskExecutionIdentifier `protobuf:"bytes,1,opt,name=task_execution_id,json=taskExecutionId,proto3" json:"task_execution_id,omitempty"` + // k8s namespace where the task is executed in + Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"` + // Labels attached to the task execution + Labels map[string]string `protobuf:"bytes,3,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // Annotations attached to the task execution + Annotations map[string]string `protobuf:"bytes,4,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // k8s service account associated with the task execution + K8SServiceAccount string `protobuf:"bytes,5,opt,name=k8s_service_account,json=k8sServiceAccount,proto3" json:"k8s_service_account,omitempty"` + // Environment variables attached to the task execution + EnvironmentVariables map[string]string `protobuf:"bytes,6,rep,name=environment_variables,json=environmentVariables,proto3" json:"environment_variables,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // Represents the maximum number of attempts allowed for a task. + // If a task fails, it can be retried up to this maximum number of attempts. + MaxAttempts int32 `protobuf:"varint,7,opt,name=max_attempts,json=maxAttempts,proto3" json:"max_attempts,omitempty"` + // Indicates whether the task execution can be interrupted. + // If set to true, the task can be stopped before completion. + Interruptible bool `protobuf:"varint,8,opt,name=interruptible,proto3" json:"interruptible,omitempty"` + // Specifies the threshold for failure count at which the interruptible property + // will take effect. If the number of consecutive task failures exceeds this threshold, + // interruptible behavior will be activated. + InterruptibleFailureThreshold int32 `protobuf:"varint,9,opt,name=interruptible_failure_threshold,json=interruptibleFailureThreshold,proto3" json:"interruptible_failure_threshold,omitempty"` + // Identity of user running this task execution + Identity *core.Identity `protobuf:"bytes,11,opt,name=identity,proto3" json:"identity,omitempty"` +} + +func (x *TaskExecutionMetadata) Reset() { + *x = TaskExecutionMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskExecutionMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskExecutionMetadata) ProtoMessage() {} + +func (x *TaskExecutionMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskExecutionMetadata.ProtoReflect.Descriptor instead. +func (*TaskExecutionMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{0} +} + +func (x *TaskExecutionMetadata) GetTaskExecutionId() *core.TaskExecutionIdentifier { + if x != nil { + return x.TaskExecutionId + } + return nil +} + +func (x *TaskExecutionMetadata) GetNamespace() string { + if x != nil { + return x.Namespace + } + return "" +} + +func (x *TaskExecutionMetadata) GetLabels() map[string]string { + if x != nil { + return x.Labels + } + return nil +} + +func (x *TaskExecutionMetadata) GetAnnotations() map[string]string { + if x != nil { + return x.Annotations + } + return nil +} + +func (x *TaskExecutionMetadata) GetK8SServiceAccount() string { + if x != nil { + return x.K8SServiceAccount + } + return "" +} + +func (x *TaskExecutionMetadata) GetEnvironmentVariables() map[string]string { + if x != nil { + return x.EnvironmentVariables + } + return nil +} + +func (x *TaskExecutionMetadata) GetMaxAttempts() int32 { + if x != nil { + return x.MaxAttempts + } + return 0 +} + +func (x *TaskExecutionMetadata) GetInterruptible() bool { + if x != nil { + return x.Interruptible + } + return false +} + +func (x *TaskExecutionMetadata) GetInterruptibleFailureThreshold() int32 { + if x != nil { + return x.InterruptibleFailureThreshold + } + return 0 +} + +func (x *TaskExecutionMetadata) GetIdentity() *core.Identity { + if x != nil { + return x.Identity + } + return nil +} + +// Represents a request structure to create task. +type CreateTaskRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The inputs required to start the execution. All required inputs must be + // included in this map. If not required and not provided, defaults apply. + // +optional + Inputs *task.Inputs `protobuf:"bytes,1,opt,name=inputs,proto3" json:"inputs,omitempty"` + // Template of the task that encapsulates all the metadata of the task. + Template *core.TaskTemplate `protobuf:"bytes,2,opt,name=template,proto3" json:"template,omitempty"` + // Prefix for where task output data will be written. (e.g. s3://my-bucket/randomstring) + OutputPrefix string `protobuf:"bytes,3,opt,name=output_prefix,json=outputPrefix,proto3" json:"output_prefix,omitempty"` + // subset of runtime task execution metadata. + TaskExecutionMetadata *TaskExecutionMetadata `protobuf:"bytes,4,opt,name=task_execution_metadata,json=taskExecutionMetadata,proto3" json:"task_execution_metadata,omitempty"` + // Connection (secret and config) required by the connector. + // Connector will use the secret and config in the taskTemplate if it's None. + // +optional + Connection *core.Connection `protobuf:"bytes,5,opt,name=connection,proto3" json:"connection,omitempty"` +} + +func (x *CreateTaskRequest) Reset() { + *x = CreateTaskRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CreateTaskRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateTaskRequest) ProtoMessage() {} + +func (x *CreateTaskRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateTaskRequest.ProtoReflect.Descriptor instead. +func (*CreateTaskRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{1} +} + +func (x *CreateTaskRequest) GetInputs() *task.Inputs { + if x != nil { + return x.Inputs + } + return nil +} + +func (x *CreateTaskRequest) GetTemplate() *core.TaskTemplate { + if x != nil { + return x.Template + } + return nil +} + +func (x *CreateTaskRequest) GetOutputPrefix() string { + if x != nil { + return x.OutputPrefix + } + return "" +} + +func (x *CreateTaskRequest) GetTaskExecutionMetadata() *TaskExecutionMetadata { + if x != nil { + return x.TaskExecutionMetadata + } + return nil +} + +func (x *CreateTaskRequest) GetConnection() *core.Connection { + if x != nil { + return x.Connection + } + return nil +} + +// Represents a create response structure. +type CreateTaskResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // ResourceMeta is created by the connector. It could be a string (jobId) or a dict (more complex metadata). + ResourceMeta []byte `protobuf:"bytes,1,opt,name=resource_meta,json=resourceMeta,proto3" json:"resource_meta,omitempty"` +} + +func (x *CreateTaskResponse) Reset() { + *x = CreateTaskResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CreateTaskResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateTaskResponse) ProtoMessage() {} + +func (x *CreateTaskResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateTaskResponse.ProtoReflect.Descriptor instead. +func (*CreateTaskResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{2} +} + +func (x *CreateTaskResponse) GetResourceMeta() []byte { + if x != nil { + return x.ResourceMeta + } + return nil +} + +type CreateRequestHeader struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Template of the task that encapsulates all the metadata of the task. + Template *core.TaskTemplate `protobuf:"bytes,1,opt,name=template,proto3" json:"template,omitempty"` + // Prefix for where task output data will be written. (e.g. s3://my-bucket/randomstring) + OutputPrefix string `protobuf:"bytes,2,opt,name=output_prefix,json=outputPrefix,proto3" json:"output_prefix,omitempty"` + // subset of runtime task execution metadata. + TaskExecutionMetadata *TaskExecutionMetadata `protobuf:"bytes,3,opt,name=task_execution_metadata,json=taskExecutionMetadata,proto3" json:"task_execution_metadata,omitempty"` + // MaxDatasetSizeBytes is the maximum size of the dataset that can be generated by the task. + MaxDatasetSizeBytes int64 `protobuf:"varint,4,opt,name=max_dataset_size_bytes,json=maxDatasetSizeBytes,proto3" json:"max_dataset_size_bytes,omitempty"` + // Connection (secret and config) required by the connector. + // Connector will use the secret and config in the taskTemplate if it's None. + // +optional + Connection *core.Connection `protobuf:"bytes,5,opt,name=connection,proto3" json:"connection,omitempty"` +} + +func (x *CreateRequestHeader) Reset() { + *x = CreateRequestHeader{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CreateRequestHeader) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateRequestHeader) ProtoMessage() {} + +func (x *CreateRequestHeader) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateRequestHeader.ProtoReflect.Descriptor instead. +func (*CreateRequestHeader) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{3} +} + +func (x *CreateRequestHeader) GetTemplate() *core.TaskTemplate { + if x != nil { + return x.Template + } + return nil +} + +func (x *CreateRequestHeader) GetOutputPrefix() string { + if x != nil { + return x.OutputPrefix + } + return "" +} + +func (x *CreateRequestHeader) GetTaskExecutionMetadata() *TaskExecutionMetadata { + if x != nil { + return x.TaskExecutionMetadata + } + return nil +} + +func (x *CreateRequestHeader) GetMaxDatasetSizeBytes() int64 { + if x != nil { + return x.MaxDatasetSizeBytes + } + return 0 +} + +func (x *CreateRequestHeader) GetConnection() *core.Connection { + if x != nil { + return x.Connection + } + return nil +} + +// A message used to fetch a job resource from flyte connector server. +type GetTaskRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Metadata about the resource to be pass to the connector. + ResourceMeta []byte `protobuf:"bytes,2,opt,name=resource_meta,json=resourceMeta,proto3" json:"resource_meta,omitempty"` + // A predefined yet extensible Task type identifier. + TaskCategory *TaskCategory `protobuf:"bytes,3,opt,name=task_category,json=taskCategory,proto3" json:"task_category,omitempty"` + // Prefix for where task output data will be written. (e.g. s3://my-bucket/randomstring) + OutputPrefix string `protobuf:"bytes,4,opt,name=output_prefix,json=outputPrefix,proto3" json:"output_prefix,omitempty"` + // Connection (secret and config) required by the connector. + // Connector will use the secret and config in the taskTemplate if it's None. + // +optional + Connection *core.Connection `protobuf:"bytes,5,opt,name=connection,proto3" json:"connection,omitempty"` +} + +func (x *GetTaskRequest) Reset() { + *x = GetTaskRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTaskRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTaskRequest) ProtoMessage() {} + +func (x *GetTaskRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetTaskRequest.ProtoReflect.Descriptor instead. +func (*GetTaskRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{4} +} + +func (x *GetTaskRequest) GetResourceMeta() []byte { + if x != nil { + return x.ResourceMeta + } + return nil +} + +func (x *GetTaskRequest) GetTaskCategory() *TaskCategory { + if x != nil { + return x.TaskCategory + } + return nil +} + +func (x *GetTaskRequest) GetOutputPrefix() string { + if x != nil { + return x.OutputPrefix + } + return "" +} + +func (x *GetTaskRequest) GetConnection() *core.Connection { + if x != nil { + return x.Connection + } + return nil +} + +// Response to get an individual task resource. +type GetTaskResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Resource *Resource `protobuf:"bytes,1,opt,name=resource,proto3" json:"resource,omitempty"` +} + +func (x *GetTaskResponse) Reset() { + *x = GetTaskResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTaskResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTaskResponse) ProtoMessage() {} + +func (x *GetTaskResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetTaskResponse.ProtoReflect.Descriptor instead. +func (*GetTaskResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{5} +} + +func (x *GetTaskResponse) GetResource() *Resource { + if x != nil { + return x.Resource + } + return nil +} + +type Resource struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The outputs of the execution. It's typically used by sql task. connector service will create a + // Structured dataset pointing to the query result table. + // +optional + Outputs *task.Outputs `protobuf:"bytes,2,opt,name=outputs,proto3" json:"outputs,omitempty"` + // A descriptive message for the current state. e.g. waiting for cluster. + Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"` + // log information for the task execution. + LogLinks []*core.TaskLog `protobuf:"bytes,4,rep,name=log_links,json=logLinks,proto3" json:"log_links,omitempty"` + // The phase of the execution is used to determine the phase of the plugin's execution. + Phase core.TaskExecution_Phase `protobuf:"varint,5,opt,name=phase,proto3,enum=flyteidl2.core.TaskExecution_Phase" json:"phase,omitempty"` + // Custom data specific to the connector. + CustomInfo *structpb.Struct `protobuf:"bytes,6,opt,name=custom_info,json=customInfo,proto3" json:"custom_info,omitempty"` +} + +func (x *Resource) Reset() { + *x = Resource{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Resource) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Resource) ProtoMessage() {} + +func (x *Resource) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Resource.ProtoReflect.Descriptor instead. +func (*Resource) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{6} +} + +func (x *Resource) GetOutputs() *task.Outputs { + if x != nil { + return x.Outputs + } + return nil +} + +func (x *Resource) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +func (x *Resource) GetLogLinks() []*core.TaskLog { + if x != nil { + return x.LogLinks + } + return nil +} + +func (x *Resource) GetPhase() core.TaskExecution_Phase { + if x != nil { + return x.Phase + } + return core.TaskExecution_Phase(0) +} + +func (x *Resource) GetCustomInfo() *structpb.Struct { + if x != nil { + return x.CustomInfo + } + return nil +} + +// A message used to delete a task. +type DeleteTaskRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Metadata about the resource to be pass to the connector. + ResourceMeta []byte `protobuf:"bytes,2,opt,name=resource_meta,json=resourceMeta,proto3" json:"resource_meta,omitempty"` + // A predefined yet extensible Task type identifier. + TaskCategory *TaskCategory `protobuf:"bytes,3,opt,name=task_category,json=taskCategory,proto3" json:"task_category,omitempty"` + // Connection (secret and config) required by the connector. + // Connector will use the secret and config in the taskTemplate if it's None. + // +optional + Connection *core.Connection `protobuf:"bytes,5,opt,name=connection,proto3" json:"connection,omitempty"` +} + +func (x *DeleteTaskRequest) Reset() { + *x = DeleteTaskRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteTaskRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteTaskRequest) ProtoMessage() {} + +func (x *DeleteTaskRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteTaskRequest.ProtoReflect.Descriptor instead. +func (*DeleteTaskRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{7} +} + +func (x *DeleteTaskRequest) GetResourceMeta() []byte { + if x != nil { + return x.ResourceMeta + } + return nil +} + +func (x *DeleteTaskRequest) GetTaskCategory() *TaskCategory { + if x != nil { + return x.TaskCategory + } + return nil +} + +func (x *DeleteTaskRequest) GetConnection() *core.Connection { + if x != nil { + return x.Connection + } + return nil +} + +// Response to delete a task. +type DeleteTaskResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *DeleteTaskResponse) Reset() { + *x = DeleteTaskResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteTaskResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteTaskResponse) ProtoMessage() {} + +func (x *DeleteTaskResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteTaskResponse.ProtoReflect.Descriptor instead. +func (*DeleteTaskResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{8} +} + +// A message containing the connector metadata. +type Connector struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Name is the developer-assigned name of the connector. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Supported_task_categories are the categories of the tasks that the connector can handle. + SupportedTaskCategories []*TaskCategory `protobuf:"bytes,4,rep,name=supported_task_categories,json=supportedTaskCategories,proto3" json:"supported_task_categories,omitempty"` +} + +func (x *Connector) Reset() { + *x = Connector{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Connector) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Connector) ProtoMessage() {} + +func (x *Connector) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Connector.ProtoReflect.Descriptor instead. +func (*Connector) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{9} +} + +func (x *Connector) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Connector) GetSupportedTaskCategories() []*TaskCategory { + if x != nil { + return x.SupportedTaskCategories + } + return nil +} + +type TaskCategory struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The name of the task type. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // The version of the task type. + Version int32 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"` +} + +func (x *TaskCategory) Reset() { + *x = TaskCategory{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskCategory) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskCategory) ProtoMessage() {} + +func (x *TaskCategory) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskCategory.ProtoReflect.Descriptor instead. +func (*TaskCategory) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{10} +} + +func (x *TaskCategory) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *TaskCategory) GetVersion() int32 { + if x != nil { + return x.Version + } + return 0 +} + +// A request to get an connector. +type GetConnectorRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The name of the connector. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *GetConnectorRequest) Reset() { + *x = GetConnectorRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetConnectorRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetConnectorRequest) ProtoMessage() {} + +func (x *GetConnectorRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetConnectorRequest.ProtoReflect.Descriptor instead. +func (*GetConnectorRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{11} +} + +func (x *GetConnectorRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +// A response containing an connector. +type GetConnectorResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Connector *Connector `protobuf:"bytes,1,opt,name=connector,proto3" json:"connector,omitempty"` +} + +func (x *GetConnectorResponse) Reset() { + *x = GetConnectorResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetConnectorResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetConnectorResponse) ProtoMessage() {} + +func (x *GetConnectorResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetConnectorResponse.ProtoReflect.Descriptor instead. +func (*GetConnectorResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{12} +} + +func (x *GetConnectorResponse) GetConnector() *Connector { + if x != nil { + return x.Connector + } + return nil +} + +// A request to list all connectors. +type ListConnectorsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *ListConnectorsRequest) Reset() { + *x = ListConnectorsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListConnectorsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListConnectorsRequest) ProtoMessage() {} + +func (x *ListConnectorsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListConnectorsRequest.ProtoReflect.Descriptor instead. +func (*ListConnectorsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{13} +} + +// A response containing a list of connectors. +type ListConnectorsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Connectors []*Connector `protobuf:"bytes,1,rep,name=connectors,proto3" json:"connectors,omitempty"` +} + +func (x *ListConnectorsResponse) Reset() { + *x = ListConnectorsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListConnectorsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListConnectorsResponse) ProtoMessage() {} + +func (x *ListConnectorsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListConnectorsResponse.ProtoReflect.Descriptor instead. +func (*ListConnectorsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{14} +} + +func (x *ListConnectorsResponse) GetConnectors() []*Connector { + if x != nil { + return x.Connectors + } + return nil +} + +// A request to get the metrics from a task execution. +type GetTaskMetricsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Metadata is created by the connector. It could be a string (jobId) or a dict (more complex metadata). + ResourceMeta []byte `protobuf:"bytes,2,opt,name=resource_meta,json=resourceMeta,proto3" json:"resource_meta,omitempty"` + // The metrics to query. If empty, will return a default set of metrics. + // e.g. EXECUTION_METRIC_USED_CPU_AVG or EXECUTION_METRIC_USED_MEMORY_BYTES_AVG + Queries []string `protobuf:"bytes,3,rep,name=queries,proto3" json:"queries,omitempty"` + // Start timestamp, inclusive. + StartTime *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` + // End timestamp, inclusive.. + EndTime *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"` + // Query resolution step width in duration format or float number of seconds. + Step *durationpb.Duration `protobuf:"bytes,6,opt,name=step,proto3" json:"step,omitempty"` + // A predefined yet extensible Task type identifier. + TaskCategory *TaskCategory `protobuf:"bytes,7,opt,name=task_category,json=taskCategory,proto3" json:"task_category,omitempty"` +} + +func (x *GetTaskMetricsRequest) Reset() { + *x = GetTaskMetricsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTaskMetricsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTaskMetricsRequest) ProtoMessage() {} + +func (x *GetTaskMetricsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetTaskMetricsRequest.ProtoReflect.Descriptor instead. +func (*GetTaskMetricsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{15} +} + +func (x *GetTaskMetricsRequest) GetResourceMeta() []byte { + if x != nil { + return x.ResourceMeta + } + return nil +} + +func (x *GetTaskMetricsRequest) GetQueries() []string { + if x != nil { + return x.Queries + } + return nil +} + +func (x *GetTaskMetricsRequest) GetStartTime() *timestamppb.Timestamp { + if x != nil { + return x.StartTime + } + return nil +} + +func (x *GetTaskMetricsRequest) GetEndTime() *timestamppb.Timestamp { + if x != nil { + return x.EndTime + } + return nil +} + +func (x *GetTaskMetricsRequest) GetStep() *durationpb.Duration { + if x != nil { + return x.Step + } + return nil +} + +func (x *GetTaskMetricsRequest) GetTaskCategory() *TaskCategory { + if x != nil { + return x.TaskCategory + } + return nil +} + +// A response containing a list of metrics for a task execution. +type GetTaskMetricsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The execution metric results. + Results []*core.ExecutionMetricResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"` +} + +func (x *GetTaskMetricsResponse) Reset() { + *x = GetTaskMetricsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTaskMetricsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTaskMetricsResponse) ProtoMessage() {} + +func (x *GetTaskMetricsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[16] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetTaskMetricsResponse.ProtoReflect.Descriptor instead. +func (*GetTaskMetricsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{16} +} + +func (x *GetTaskMetricsResponse) GetResults() []*core.ExecutionMetricResult { + if x != nil { + return x.Results + } + return nil +} + +// A request to get the log from a task execution. +type GetTaskLogsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Metadata is created by the connector. It could be a string (jobId) or a dict (more complex metadata). + ResourceMeta []byte `protobuf:"bytes,2,opt,name=resource_meta,json=resourceMeta,proto3" json:"resource_meta,omitempty"` + // Number of lines to return. + Lines uint64 `protobuf:"varint,3,opt,name=lines,proto3" json:"lines,omitempty"` + // In the case of multiple pages of results, the server-provided token can be used to fetch the next page + // in a query. If there are no more results, this value will be empty. + Token string `protobuf:"bytes,4,opt,name=token,proto3" json:"token,omitempty"` + // A predefined yet extensible Task type identifier. + TaskCategory *TaskCategory `protobuf:"bytes,5,opt,name=task_category,json=taskCategory,proto3" json:"task_category,omitempty"` +} + +func (x *GetTaskLogsRequest) Reset() { + *x = GetTaskLogsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTaskLogsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTaskLogsRequest) ProtoMessage() {} + +func (x *GetTaskLogsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetTaskLogsRequest.ProtoReflect.Descriptor instead. +func (*GetTaskLogsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{17} +} + +func (x *GetTaskLogsRequest) GetResourceMeta() []byte { + if x != nil { + return x.ResourceMeta + } + return nil +} + +func (x *GetTaskLogsRequest) GetLines() uint64 { + if x != nil { + return x.Lines + } + return 0 +} + +func (x *GetTaskLogsRequest) GetToken() string { + if x != nil { + return x.Token + } + return "" +} + +func (x *GetTaskLogsRequest) GetTaskCategory() *TaskCategory { + if x != nil { + return x.TaskCategory + } + return nil +} + +type GetTaskLogsResponseHeader struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // In the case of multiple pages of results, the server-provided token can be used to fetch the next page + // in a query. If there are no more results, this value will be empty. + Token string `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"` +} + +func (x *GetTaskLogsResponseHeader) Reset() { + *x = GetTaskLogsResponseHeader{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTaskLogsResponseHeader) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTaskLogsResponseHeader) ProtoMessage() {} + +func (x *GetTaskLogsResponseHeader) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[18] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetTaskLogsResponseHeader.ProtoReflect.Descriptor instead. +func (*GetTaskLogsResponseHeader) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{18} +} + +func (x *GetTaskLogsResponseHeader) GetToken() string { + if x != nil { + return x.Token + } + return "" +} + +type GetTaskLogsResponseBody struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The execution log results. + Results []string `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"` +} + +func (x *GetTaskLogsResponseBody) Reset() { + *x = GetTaskLogsResponseBody{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTaskLogsResponseBody) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTaskLogsResponseBody) ProtoMessage() {} + +func (x *GetTaskLogsResponseBody) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[19] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetTaskLogsResponseBody.ProtoReflect.Descriptor instead. +func (*GetTaskLogsResponseBody) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{19} +} + +func (x *GetTaskLogsResponseBody) GetResults() []string { + if x != nil { + return x.Results + } + return nil +} + +// A response containing the logs for a task execution. +type GetTaskLogsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Part: + // + // *GetTaskLogsResponse_Header + // *GetTaskLogsResponse_Body + Part isGetTaskLogsResponse_Part `protobuf_oneof:"part"` +} + +func (x *GetTaskLogsResponse) Reset() { + *x = GetTaskLogsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTaskLogsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTaskLogsResponse) ProtoMessage() {} + +func (x *GetTaskLogsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_connector_connector_proto_msgTypes[20] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetTaskLogsResponse.ProtoReflect.Descriptor instead. +func (*GetTaskLogsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_connector_connector_proto_rawDescGZIP(), []int{20} +} + +func (m *GetTaskLogsResponse) GetPart() isGetTaskLogsResponse_Part { + if m != nil { + return m.Part + } + return nil +} + +func (x *GetTaskLogsResponse) GetHeader() *GetTaskLogsResponseHeader { + if x, ok := x.GetPart().(*GetTaskLogsResponse_Header); ok { + return x.Header + } + return nil +} + +func (x *GetTaskLogsResponse) GetBody() *GetTaskLogsResponseBody { + if x, ok := x.GetPart().(*GetTaskLogsResponse_Body); ok { + return x.Body + } + return nil +} + +type isGetTaskLogsResponse_Part interface { + isGetTaskLogsResponse_Part() +} + +type GetTaskLogsResponse_Header struct { + Header *GetTaskLogsResponseHeader `protobuf:"bytes,1,opt,name=header,proto3,oneof"` +} + +type GetTaskLogsResponse_Body struct { + Body *GetTaskLogsResponseBody `protobuf:"bytes,2,opt,name=body,proto3,oneof"` +} + +func (*GetTaskLogsResponse_Header) isGetTaskLogsResponse_Part() {} + +func (*GetTaskLogsResponse_Body) isGetTaskLogsResponse_Part() {} + +var File_flyteidl2_connector_connector_proto protoreflect.FileDescriptor + +var file_flyteidl2_connector_connector_proto_rawDesc = []byte{ + 0x0a, 0x23, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x13, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x6d, 0x65, 0x74, 0x72, + 0x69, 0x63, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, + 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, + 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x22, 0xef, 0x06, 0x0a, 0x15, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x53, 0x0a, 0x11, 0x74, 0x61, + 0x73, 0x6b, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x0f, + 0x74, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, + 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x4e, 0x0a, + 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x12, 0x5d, 0x0a, + 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x3b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x41, + 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, + 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2e, 0x0a, 0x13, + 0x6b, 0x38, 0x73, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x61, 0x63, 0x63, 0x6f, + 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x6b, 0x38, 0x73, 0x53, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x79, 0x0a, 0x15, + 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x72, 0x69, + 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x44, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x45, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, + 0x65, 0x6e, 0x74, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x52, 0x14, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x56, 0x61, + 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x61, 0x78, 0x5f, 0x61, + 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, + 0x61, 0x78, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x12, 0x24, 0x0a, 0x0d, 0x69, 0x6e, + 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x0d, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, + 0x12, 0x46, 0x0a, 0x1f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, + 0x65, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, + 0x6f, 0x6c, 0x64, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x1d, 0x69, 0x6e, 0x74, 0x65, 0x72, + 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x54, + 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x34, 0x0a, 0x08, 0x69, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x52, 0x08, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x1a, 0x39, + 0x0a, 0x0b, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, + 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, + 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3e, 0x0a, 0x10, 0x41, 0x6e, 0x6e, + 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, + 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, + 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x47, 0x0a, 0x19, 0x45, 0x6e, 0x76, + 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, + 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x22, 0xc2, 0x02, 0x0a, 0x11, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x61, 0x73, + 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2e, 0x0a, 0x06, 0x69, 0x6e, 0x70, 0x75, + 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, + 0x52, 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x12, 0x38, 0x0a, 0x08, 0x74, 0x65, 0x6d, 0x70, + 0x6c, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, + 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x08, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, + 0x74, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x70, 0x72, 0x65, + 0x66, 0x69, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x62, 0x0a, 0x17, 0x74, 0x61, 0x73, 0x6b, 0x5f, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x54, + 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x52, 0x15, 0x74, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x3a, 0x0a, 0x0a, 0x63, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x39, 0x0a, 0x12, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x23, 0x0a, + 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, + 0x74, 0x61, 0x22, 0xc9, 0x02, 0x0a, 0x13, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x38, 0x0a, 0x08, 0x74, 0x65, + 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, + 0x73, 0x6b, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x08, 0x74, 0x65, 0x6d, 0x70, + 0x6c, 0x61, 0x74, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x70, + 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, 0x75, 0x74, + 0x70, 0x75, 0x74, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x62, 0x0a, 0x17, 0x74, 0x61, 0x73, + 0x6b, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x15, 0x74, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x33, 0x0a, + 0x16, 0x6d, 0x61, 0x78, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x5f, 0x73, 0x69, 0x7a, + 0x65, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x6d, + 0x61, 0x78, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x53, 0x69, 0x7a, 0x65, 0x42, 0x79, 0x74, + 0x65, 0x73, 0x12, 0x3a, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xde, + 0x01, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, + 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x46, 0x0a, 0x0d, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, + 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, + 0x52, 0x0c, 0x74, 0x61, 0x73, 0x6b, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x12, 0x23, + 0x0a, 0x0d, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x50, 0x72, 0x65, + 0x66, 0x69, 0x78, 0x12, 0x3a, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, + 0x4c, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x39, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x52, 0x08, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x22, 0x82, 0x02, + 0x0a, 0x08, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x31, 0x0a, 0x07, 0x6f, 0x75, + 0x74, 0x70, 0x75, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4f, 0x75, 0x74, + 0x70, 0x75, 0x74, 0x73, 0x52, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x12, 0x18, 0x0a, + 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x34, 0x0a, 0x09, 0x6c, 0x6f, 0x67, 0x5f, 0x6c, + 0x69, 0x6e, 0x6b, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, + 0x4c, 0x6f, 0x67, 0x52, 0x08, 0x6c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x6b, 0x73, 0x12, 0x39, 0x0a, + 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, + 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x50, 0x68, 0x61, 0x73, + 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x38, 0x0a, 0x0b, 0x63, 0x75, 0x73, 0x74, + 0x6f, 0x6d, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x0a, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x49, 0x6e, + 0x66, 0x6f, 0x22, 0xbc, 0x01, 0x0a, 0x11, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x61, 0x73, + 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x0c, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x46, 0x0a, + 0x0d, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x43, + 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x52, 0x0c, 0x74, 0x61, 0x73, 0x6b, 0x43, 0x61, 0x74, + 0x65, 0x67, 0x6f, 0x72, 0x79, 0x12, 0x3a, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x22, 0x14, 0x0a, 0x12, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x61, 0x73, 0x6b, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x7e, 0x0a, 0x09, 0x43, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x5d, 0x0a, 0x19, 0x73, 0x75, 0x70, 0x70, + 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, + 0x6f, 0x72, 0x69, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x52, 0x17, + 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x54, 0x61, 0x73, 0x6b, 0x43, 0x61, 0x74, + 0x65, 0x67, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x22, 0x3c, 0x0a, 0x0c, 0x54, 0x61, 0x73, 0x6b, 0x43, + 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x76, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x29, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x22, 0x54, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3c, 0x0a, 0x09, 0x63, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x09, 0x63, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x22, 0x17, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6f, + 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, + 0x58, 0x0a, 0x16, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x0a, 0x63, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x22, 0xbf, 0x02, 0x0a, 0x15, 0x47, 0x65, + 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, + 0x6d, 0x65, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x18, 0x0a, 0x07, 0x71, 0x75, 0x65, 0x72, + 0x69, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x71, 0x75, 0x65, 0x72, 0x69, + 0x65, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x35, 0x0a, + 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x07, 0x65, 0x6e, 0x64, + 0x54, 0x69, 0x6d, 0x65, 0x12, 0x2d, 0x0a, 0x04, 0x73, 0x74, 0x65, 0x70, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x04, 0x73, + 0x74, 0x65, 0x70, 0x12, 0x46, 0x0a, 0x0d, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, 0x74, 0x65, + 0x67, 0x6f, 0x72, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x52, 0x0c, 0x74, + 0x61, 0x73, 0x6b, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x22, 0x59, 0x0a, 0x16, 0x47, + 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x07, 0x72, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0xad, 0x01, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x54, 0x61, + 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, + 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, + 0x74, 0x61, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x05, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, + 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x46, + 0x0a, 0x0d, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x54, 0x61, 0x73, 0x6b, + 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x52, 0x0c, 0x74, 0x61, 0x73, 0x6b, 0x43, 0x61, + 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x22, 0x31, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, + 0x6b, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x65, 0x61, + 0x64, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x33, 0x0a, 0x17, 0x47, 0x65, 0x74, + 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x42, 0x6f, 0x64, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0xab, + 0x01, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x48, 0x0a, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x47, 0x65, 0x74, + 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x48, 0x00, 0x52, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, + 0x12, 0x42, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x6f, 0x64, 0x79, 0x48, 0x00, 0x52, 0x04, + 0x62, 0x6f, 0x64, 0x79, 0x42, 0x06, 0x0a, 0x04, 0x70, 0x61, 0x72, 0x74, 0x42, 0xd1, 0x01, 0x0a, + 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x42, 0x0e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x37, 0x67, 0x69, + 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, + 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, + 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x6f, 0x72, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x13, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0xca, 0x02, 0x13, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, + 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0xe2, 0x02, 0x1f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5c, 0x47, 0x50, + 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_connector_connector_proto_rawDescOnce sync.Once + file_flyteidl2_connector_connector_proto_rawDescData = file_flyteidl2_connector_connector_proto_rawDesc +) + +func file_flyteidl2_connector_connector_proto_rawDescGZIP() []byte { + file_flyteidl2_connector_connector_proto_rawDescOnce.Do(func() { + file_flyteidl2_connector_connector_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_connector_connector_proto_rawDescData) + }) + return file_flyteidl2_connector_connector_proto_rawDescData +} + +var file_flyteidl2_connector_connector_proto_msgTypes = make([]protoimpl.MessageInfo, 24) +var file_flyteidl2_connector_connector_proto_goTypes = []interface{}{ + (*TaskExecutionMetadata)(nil), // 0: flyteidl2.connector.TaskExecutionMetadata + (*CreateTaskRequest)(nil), // 1: flyteidl2.connector.CreateTaskRequest + (*CreateTaskResponse)(nil), // 2: flyteidl2.connector.CreateTaskResponse + (*CreateRequestHeader)(nil), // 3: flyteidl2.connector.CreateRequestHeader + (*GetTaskRequest)(nil), // 4: flyteidl2.connector.GetTaskRequest + (*GetTaskResponse)(nil), // 5: flyteidl2.connector.GetTaskResponse + (*Resource)(nil), // 6: flyteidl2.connector.Resource + (*DeleteTaskRequest)(nil), // 7: flyteidl2.connector.DeleteTaskRequest + (*DeleteTaskResponse)(nil), // 8: flyteidl2.connector.DeleteTaskResponse + (*Connector)(nil), // 9: flyteidl2.connector.Connector + (*TaskCategory)(nil), // 10: flyteidl2.connector.TaskCategory + (*GetConnectorRequest)(nil), // 11: flyteidl2.connector.GetConnectorRequest + (*GetConnectorResponse)(nil), // 12: flyteidl2.connector.GetConnectorResponse + (*ListConnectorsRequest)(nil), // 13: flyteidl2.connector.ListConnectorsRequest + (*ListConnectorsResponse)(nil), // 14: flyteidl2.connector.ListConnectorsResponse + (*GetTaskMetricsRequest)(nil), // 15: flyteidl2.connector.GetTaskMetricsRequest + (*GetTaskMetricsResponse)(nil), // 16: flyteidl2.connector.GetTaskMetricsResponse + (*GetTaskLogsRequest)(nil), // 17: flyteidl2.connector.GetTaskLogsRequest + (*GetTaskLogsResponseHeader)(nil), // 18: flyteidl2.connector.GetTaskLogsResponseHeader + (*GetTaskLogsResponseBody)(nil), // 19: flyteidl2.connector.GetTaskLogsResponseBody + (*GetTaskLogsResponse)(nil), // 20: flyteidl2.connector.GetTaskLogsResponse + nil, // 21: flyteidl2.connector.TaskExecutionMetadata.LabelsEntry + nil, // 22: flyteidl2.connector.TaskExecutionMetadata.AnnotationsEntry + nil, // 23: flyteidl2.connector.TaskExecutionMetadata.EnvironmentVariablesEntry + (*core.TaskExecutionIdentifier)(nil), // 24: flyteidl2.core.TaskExecutionIdentifier + (*core.Identity)(nil), // 25: flyteidl2.core.Identity + (*task.Inputs)(nil), // 26: flyteidl2.task.Inputs + (*core.TaskTemplate)(nil), // 27: flyteidl2.core.TaskTemplate + (*core.Connection)(nil), // 28: flyteidl2.core.Connection + (*task.Outputs)(nil), // 29: flyteidl2.task.Outputs + (*core.TaskLog)(nil), // 30: flyteidl2.core.TaskLog + (core.TaskExecution_Phase)(0), // 31: flyteidl2.core.TaskExecution.Phase + (*structpb.Struct)(nil), // 32: google.protobuf.Struct + (*timestamppb.Timestamp)(nil), // 33: google.protobuf.Timestamp + (*durationpb.Duration)(nil), // 34: google.protobuf.Duration + (*core.ExecutionMetricResult)(nil), // 35: flyteidl2.core.ExecutionMetricResult +} +var file_flyteidl2_connector_connector_proto_depIdxs = []int32{ + 24, // 0: flyteidl2.connector.TaskExecutionMetadata.task_execution_id:type_name -> flyteidl2.core.TaskExecutionIdentifier + 21, // 1: flyteidl2.connector.TaskExecutionMetadata.labels:type_name -> flyteidl2.connector.TaskExecutionMetadata.LabelsEntry + 22, // 2: flyteidl2.connector.TaskExecutionMetadata.annotations:type_name -> flyteidl2.connector.TaskExecutionMetadata.AnnotationsEntry + 23, // 3: flyteidl2.connector.TaskExecutionMetadata.environment_variables:type_name -> flyteidl2.connector.TaskExecutionMetadata.EnvironmentVariablesEntry + 25, // 4: flyteidl2.connector.TaskExecutionMetadata.identity:type_name -> flyteidl2.core.Identity + 26, // 5: flyteidl2.connector.CreateTaskRequest.inputs:type_name -> flyteidl2.task.Inputs + 27, // 6: flyteidl2.connector.CreateTaskRequest.template:type_name -> flyteidl2.core.TaskTemplate + 0, // 7: flyteidl2.connector.CreateTaskRequest.task_execution_metadata:type_name -> flyteidl2.connector.TaskExecutionMetadata + 28, // 8: flyteidl2.connector.CreateTaskRequest.connection:type_name -> flyteidl2.core.Connection + 27, // 9: flyteidl2.connector.CreateRequestHeader.template:type_name -> flyteidl2.core.TaskTemplate + 0, // 10: flyteidl2.connector.CreateRequestHeader.task_execution_metadata:type_name -> flyteidl2.connector.TaskExecutionMetadata + 28, // 11: flyteidl2.connector.CreateRequestHeader.connection:type_name -> flyteidl2.core.Connection + 10, // 12: flyteidl2.connector.GetTaskRequest.task_category:type_name -> flyteidl2.connector.TaskCategory + 28, // 13: flyteidl2.connector.GetTaskRequest.connection:type_name -> flyteidl2.core.Connection + 6, // 14: flyteidl2.connector.GetTaskResponse.resource:type_name -> flyteidl2.connector.Resource + 29, // 15: flyteidl2.connector.Resource.outputs:type_name -> flyteidl2.task.Outputs + 30, // 16: flyteidl2.connector.Resource.log_links:type_name -> flyteidl2.core.TaskLog + 31, // 17: flyteidl2.connector.Resource.phase:type_name -> flyteidl2.core.TaskExecution.Phase + 32, // 18: flyteidl2.connector.Resource.custom_info:type_name -> google.protobuf.Struct + 10, // 19: flyteidl2.connector.DeleteTaskRequest.task_category:type_name -> flyteidl2.connector.TaskCategory + 28, // 20: flyteidl2.connector.DeleteTaskRequest.connection:type_name -> flyteidl2.core.Connection + 10, // 21: flyteidl2.connector.Connector.supported_task_categories:type_name -> flyteidl2.connector.TaskCategory + 9, // 22: flyteidl2.connector.GetConnectorResponse.connector:type_name -> flyteidl2.connector.Connector + 9, // 23: flyteidl2.connector.ListConnectorsResponse.connectors:type_name -> flyteidl2.connector.Connector + 33, // 24: flyteidl2.connector.GetTaskMetricsRequest.start_time:type_name -> google.protobuf.Timestamp + 33, // 25: flyteidl2.connector.GetTaskMetricsRequest.end_time:type_name -> google.protobuf.Timestamp + 34, // 26: flyteidl2.connector.GetTaskMetricsRequest.step:type_name -> google.protobuf.Duration + 10, // 27: flyteidl2.connector.GetTaskMetricsRequest.task_category:type_name -> flyteidl2.connector.TaskCategory + 35, // 28: flyteidl2.connector.GetTaskMetricsResponse.results:type_name -> flyteidl2.core.ExecutionMetricResult + 10, // 29: flyteidl2.connector.GetTaskLogsRequest.task_category:type_name -> flyteidl2.connector.TaskCategory + 18, // 30: flyteidl2.connector.GetTaskLogsResponse.header:type_name -> flyteidl2.connector.GetTaskLogsResponseHeader + 19, // 31: flyteidl2.connector.GetTaskLogsResponse.body:type_name -> flyteidl2.connector.GetTaskLogsResponseBody + 32, // [32:32] is the sub-list for method output_type + 32, // [32:32] is the sub-list for method input_type + 32, // [32:32] is the sub-list for extension type_name + 32, // [32:32] is the sub-list for extension extendee + 0, // [0:32] is the sub-list for field type_name +} + +func init() { file_flyteidl2_connector_connector_proto_init() } +func file_flyteidl2_connector_connector_proto_init() { + if File_flyteidl2_connector_connector_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_connector_connector_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskExecutionMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CreateTaskRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CreateTaskResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CreateRequestHeader); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTaskRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTaskResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Resource); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteTaskRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteTaskResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Connector); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskCategory); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetConnectorRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetConnectorResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListConnectorsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListConnectorsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTaskMetricsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTaskMetricsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTaskLogsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTaskLogsResponseHeader); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTaskLogsResponseBody); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_connector_connector_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTaskLogsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_connector_connector_proto_msgTypes[20].OneofWrappers = []interface{}{ + (*GetTaskLogsResponse_Header)(nil), + (*GetTaskLogsResponse_Body)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_connector_connector_proto_rawDesc, + NumEnums: 0, + NumMessages: 24, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_connector_connector_proto_goTypes, + DependencyIndexes: file_flyteidl2_connector_connector_proto_depIdxs, + MessageInfos: file_flyteidl2_connector_connector_proto_msgTypes, + }.Build() + File_flyteidl2_connector_connector_proto = out.File + file_flyteidl2_connector_connector_proto_rawDesc = nil + file_flyteidl2_connector_connector_proto_goTypes = nil + file_flyteidl2_connector_connector_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/connector/connector.pb.validate.go b/gen/go/flyteidl2/connector/connector.pb.validate.go new file mode 100644 index 0000000000..cfe0122071 --- /dev/null +++ b/gen/go/flyteidl2/connector/connector.pb.validate.go @@ -0,0 +1,3082 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/connector/connector.proto + +package connector + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" + + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort + + _ = core.TaskExecution_Phase(0) +) + +// Validate checks the field values on TaskExecutionMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *TaskExecutionMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskExecutionMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TaskExecutionMetadataMultiError, or nil if none found. +func (m *TaskExecutionMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskExecutionMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetTaskExecutionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskExecutionMetadataValidationError{ + field: "TaskExecutionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskExecutionMetadataValidationError{ + field: "TaskExecutionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskExecutionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskExecutionMetadataValidationError{ + field: "TaskExecutionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Namespace + + // no validation rules for Labels + + // no validation rules for Annotations + + // no validation rules for K8SServiceAccount + + // no validation rules for EnvironmentVariables + + // no validation rules for MaxAttempts + + // no validation rules for Interruptible + + // no validation rules for InterruptibleFailureThreshold + + if all { + switch v := interface{}(m.GetIdentity()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskExecutionMetadataValidationError{ + field: "Identity", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskExecutionMetadataValidationError{ + field: "Identity", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetIdentity()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskExecutionMetadataValidationError{ + field: "Identity", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return TaskExecutionMetadataMultiError(errors) + } + + return nil +} + +// TaskExecutionMetadataMultiError is an error wrapping multiple validation +// errors returned by TaskExecutionMetadata.ValidateAll() if the designated +// constraints aren't met. +type TaskExecutionMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskExecutionMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskExecutionMetadataMultiError) AllErrors() []error { return m } + +// TaskExecutionMetadataValidationError is the validation error returned by +// TaskExecutionMetadata.Validate if the designated constraints aren't met. +type TaskExecutionMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskExecutionMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskExecutionMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskExecutionMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskExecutionMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskExecutionMetadataValidationError) ErrorName() string { + return "TaskExecutionMetadataValidationError" +} + +// Error satisfies the builtin error interface +func (e TaskExecutionMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskExecutionMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskExecutionMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskExecutionMetadataValidationError{} + +// Validate checks the field values on CreateTaskRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *CreateTaskRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CreateTaskRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CreateTaskRequestMultiError, or nil if none found. +func (m *CreateTaskRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *CreateTaskRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetInputs()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateTaskRequestValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateTaskRequestValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetInputs()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateTaskRequestValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetTemplate()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateTaskRequestValidationError{ + field: "Template", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateTaskRequestValidationError{ + field: "Template", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTemplate()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateTaskRequestValidationError{ + field: "Template", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for OutputPrefix + + if all { + switch v := interface{}(m.GetTaskExecutionMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateTaskRequestValidationError{ + field: "TaskExecutionMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateTaskRequestValidationError{ + field: "TaskExecutionMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskExecutionMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateTaskRequestValidationError{ + field: "TaskExecutionMetadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetConnection()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateTaskRequestValidationError{ + field: "Connection", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateTaskRequestValidationError{ + field: "Connection", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetConnection()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateTaskRequestValidationError{ + field: "Connection", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return CreateTaskRequestMultiError(errors) + } + + return nil +} + +// CreateTaskRequestMultiError is an error wrapping multiple validation errors +// returned by CreateTaskRequest.ValidateAll() if the designated constraints +// aren't met. +type CreateTaskRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CreateTaskRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CreateTaskRequestMultiError) AllErrors() []error { return m } + +// CreateTaskRequestValidationError is the validation error returned by +// CreateTaskRequest.Validate if the designated constraints aren't met. +type CreateTaskRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CreateTaskRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CreateTaskRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CreateTaskRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CreateTaskRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CreateTaskRequestValidationError) ErrorName() string { + return "CreateTaskRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e CreateTaskRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCreateTaskRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CreateTaskRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CreateTaskRequestValidationError{} + +// Validate checks the field values on CreateTaskResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *CreateTaskResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CreateTaskResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CreateTaskResponseMultiError, or nil if none found. +func (m *CreateTaskResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *CreateTaskResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ResourceMeta + + if len(errors) > 0 { + return CreateTaskResponseMultiError(errors) + } + + return nil +} + +// CreateTaskResponseMultiError is an error wrapping multiple validation errors +// returned by CreateTaskResponse.ValidateAll() if the designated constraints +// aren't met. +type CreateTaskResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CreateTaskResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CreateTaskResponseMultiError) AllErrors() []error { return m } + +// CreateTaskResponseValidationError is the validation error returned by +// CreateTaskResponse.Validate if the designated constraints aren't met. +type CreateTaskResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CreateTaskResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CreateTaskResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CreateTaskResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CreateTaskResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CreateTaskResponseValidationError) ErrorName() string { + return "CreateTaskResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e CreateTaskResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCreateTaskResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CreateTaskResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CreateTaskResponseValidationError{} + +// Validate checks the field values on CreateRequestHeader with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *CreateRequestHeader) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CreateRequestHeader with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CreateRequestHeaderMultiError, or nil if none found. +func (m *CreateRequestHeader) ValidateAll() error { + return m.validate(true) +} + +func (m *CreateRequestHeader) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetTemplate()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateRequestHeaderValidationError{ + field: "Template", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateRequestHeaderValidationError{ + field: "Template", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTemplate()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateRequestHeaderValidationError{ + field: "Template", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for OutputPrefix + + if all { + switch v := interface{}(m.GetTaskExecutionMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateRequestHeaderValidationError{ + field: "TaskExecutionMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateRequestHeaderValidationError{ + field: "TaskExecutionMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskExecutionMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateRequestHeaderValidationError{ + field: "TaskExecutionMetadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for MaxDatasetSizeBytes + + if all { + switch v := interface{}(m.GetConnection()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateRequestHeaderValidationError{ + field: "Connection", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateRequestHeaderValidationError{ + field: "Connection", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetConnection()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateRequestHeaderValidationError{ + field: "Connection", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return CreateRequestHeaderMultiError(errors) + } + + return nil +} + +// CreateRequestHeaderMultiError is an error wrapping multiple validation +// errors returned by CreateRequestHeader.ValidateAll() if the designated +// constraints aren't met. +type CreateRequestHeaderMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CreateRequestHeaderMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CreateRequestHeaderMultiError) AllErrors() []error { return m } + +// CreateRequestHeaderValidationError is the validation error returned by +// CreateRequestHeader.Validate if the designated constraints aren't met. +type CreateRequestHeaderValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CreateRequestHeaderValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CreateRequestHeaderValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CreateRequestHeaderValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CreateRequestHeaderValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CreateRequestHeaderValidationError) ErrorName() string { + return "CreateRequestHeaderValidationError" +} + +// Error satisfies the builtin error interface +func (e CreateRequestHeaderValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCreateRequestHeader.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CreateRequestHeaderValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CreateRequestHeaderValidationError{} + +// Validate checks the field values on GetTaskRequest with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *GetTaskRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetTaskRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in GetTaskRequestMultiError, +// or nil if none found. +func (m *GetTaskRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetTaskRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ResourceMeta + + if all { + switch v := interface{}(m.GetTaskCategory()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTaskRequestValidationError{ + field: "TaskCategory", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTaskRequestValidationError{ + field: "TaskCategory", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskCategory()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTaskRequestValidationError{ + field: "TaskCategory", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for OutputPrefix + + if all { + switch v := interface{}(m.GetConnection()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTaskRequestValidationError{ + field: "Connection", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTaskRequestValidationError{ + field: "Connection", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetConnection()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTaskRequestValidationError{ + field: "Connection", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetTaskRequestMultiError(errors) + } + + return nil +} + +// GetTaskRequestMultiError is an error wrapping multiple validation errors +// returned by GetTaskRequest.ValidateAll() if the designated constraints +// aren't met. +type GetTaskRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetTaskRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetTaskRequestMultiError) AllErrors() []error { return m } + +// GetTaskRequestValidationError is the validation error returned by +// GetTaskRequest.Validate if the designated constraints aren't met. +type GetTaskRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetTaskRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetTaskRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetTaskRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetTaskRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetTaskRequestValidationError) ErrorName() string { return "GetTaskRequestValidationError" } + +// Error satisfies the builtin error interface +func (e GetTaskRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetTaskRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetTaskRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetTaskRequestValidationError{} + +// Validate checks the field values on GetTaskResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *GetTaskResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetTaskResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetTaskResponseMultiError, or nil if none found. +func (m *GetTaskResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetTaskResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetResource()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTaskResponseValidationError{ + field: "Resource", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTaskResponseValidationError{ + field: "Resource", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetResource()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTaskResponseValidationError{ + field: "Resource", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetTaskResponseMultiError(errors) + } + + return nil +} + +// GetTaskResponseMultiError is an error wrapping multiple validation errors +// returned by GetTaskResponse.ValidateAll() if the designated constraints +// aren't met. +type GetTaskResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetTaskResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetTaskResponseMultiError) AllErrors() []error { return m } + +// GetTaskResponseValidationError is the validation error returned by +// GetTaskResponse.Validate if the designated constraints aren't met. +type GetTaskResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetTaskResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetTaskResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetTaskResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetTaskResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetTaskResponseValidationError) ErrorName() string { return "GetTaskResponseValidationError" } + +// Error satisfies the builtin error interface +func (e GetTaskResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetTaskResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetTaskResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetTaskResponseValidationError{} + +// Validate checks the field values on Resource with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Resource) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Resource with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ResourceMultiError, or nil +// if none found. +func (m *Resource) ValidateAll() error { + return m.validate(true) +} + +func (m *Resource) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetOutputs()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ResourceValidationError{ + field: "Outputs", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ResourceValidationError{ + field: "Outputs", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOutputs()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ResourceValidationError{ + field: "Outputs", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Message + + for idx, item := range m.GetLogLinks() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ResourceValidationError{ + field: fmt.Sprintf("LogLinks[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ResourceValidationError{ + field: fmt.Sprintf("LogLinks[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ResourceValidationError{ + field: fmt.Sprintf("LogLinks[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Phase + + if all { + switch v := interface{}(m.GetCustomInfo()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ResourceValidationError{ + field: "CustomInfo", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ResourceValidationError{ + field: "CustomInfo", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCustomInfo()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ResourceValidationError{ + field: "CustomInfo", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ResourceMultiError(errors) + } + + return nil +} + +// ResourceMultiError is an error wrapping multiple validation errors returned +// by Resource.ValidateAll() if the designated constraints aren't met. +type ResourceMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ResourceMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ResourceMultiError) AllErrors() []error { return m } + +// ResourceValidationError is the validation error returned by +// Resource.Validate if the designated constraints aren't met. +type ResourceValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ResourceValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ResourceValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ResourceValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ResourceValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ResourceValidationError) ErrorName() string { return "ResourceValidationError" } + +// Error satisfies the builtin error interface +func (e ResourceValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sResource.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ResourceValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ResourceValidationError{} + +// Validate checks the field values on DeleteTaskRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *DeleteTaskRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DeleteTaskRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// DeleteTaskRequestMultiError, or nil if none found. +func (m *DeleteTaskRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *DeleteTaskRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ResourceMeta + + if all { + switch v := interface{}(m.GetTaskCategory()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DeleteTaskRequestValidationError{ + field: "TaskCategory", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DeleteTaskRequestValidationError{ + field: "TaskCategory", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskCategory()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DeleteTaskRequestValidationError{ + field: "TaskCategory", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetConnection()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DeleteTaskRequestValidationError{ + field: "Connection", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DeleteTaskRequestValidationError{ + field: "Connection", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetConnection()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DeleteTaskRequestValidationError{ + field: "Connection", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DeleteTaskRequestMultiError(errors) + } + + return nil +} + +// DeleteTaskRequestMultiError is an error wrapping multiple validation errors +// returned by DeleteTaskRequest.ValidateAll() if the designated constraints +// aren't met. +type DeleteTaskRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DeleteTaskRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DeleteTaskRequestMultiError) AllErrors() []error { return m } + +// DeleteTaskRequestValidationError is the validation error returned by +// DeleteTaskRequest.Validate if the designated constraints aren't met. +type DeleteTaskRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DeleteTaskRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DeleteTaskRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DeleteTaskRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DeleteTaskRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DeleteTaskRequestValidationError) ErrorName() string { + return "DeleteTaskRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e DeleteTaskRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDeleteTaskRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DeleteTaskRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DeleteTaskRequestValidationError{} + +// Validate checks the field values on DeleteTaskResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *DeleteTaskResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DeleteTaskResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// DeleteTaskResponseMultiError, or nil if none found. +func (m *DeleteTaskResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *DeleteTaskResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return DeleteTaskResponseMultiError(errors) + } + + return nil +} + +// DeleteTaskResponseMultiError is an error wrapping multiple validation errors +// returned by DeleteTaskResponse.ValidateAll() if the designated constraints +// aren't met. +type DeleteTaskResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DeleteTaskResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DeleteTaskResponseMultiError) AllErrors() []error { return m } + +// DeleteTaskResponseValidationError is the validation error returned by +// DeleteTaskResponse.Validate if the designated constraints aren't met. +type DeleteTaskResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DeleteTaskResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DeleteTaskResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DeleteTaskResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DeleteTaskResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DeleteTaskResponseValidationError) ErrorName() string { + return "DeleteTaskResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e DeleteTaskResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDeleteTaskResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DeleteTaskResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DeleteTaskResponseValidationError{} + +// Validate checks the field values on Connector with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Connector) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Connector with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ConnectorMultiError, or nil +// if none found. +func (m *Connector) ValidateAll() error { + return m.validate(true) +} + +func (m *Connector) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + for idx, item := range m.GetSupportedTaskCategories() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ConnectorValidationError{ + field: fmt.Sprintf("SupportedTaskCategories[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ConnectorValidationError{ + field: fmt.Sprintf("SupportedTaskCategories[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ConnectorValidationError{ + field: fmt.Sprintf("SupportedTaskCategories[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return ConnectorMultiError(errors) + } + + return nil +} + +// ConnectorMultiError is an error wrapping multiple validation errors returned +// by Connector.ValidateAll() if the designated constraints aren't met. +type ConnectorMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ConnectorMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ConnectorMultiError) AllErrors() []error { return m } + +// ConnectorValidationError is the validation error returned by +// Connector.Validate if the designated constraints aren't met. +type ConnectorValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ConnectorValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ConnectorValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ConnectorValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ConnectorValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ConnectorValidationError) ErrorName() string { return "ConnectorValidationError" } + +// Error satisfies the builtin error interface +func (e ConnectorValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sConnector.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ConnectorValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ConnectorValidationError{} + +// Validate checks the field values on TaskCategory with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TaskCategory) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskCategory with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TaskCategoryMultiError, or +// nil if none found. +func (m *TaskCategory) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskCategory) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + // no validation rules for Version + + if len(errors) > 0 { + return TaskCategoryMultiError(errors) + } + + return nil +} + +// TaskCategoryMultiError is an error wrapping multiple validation errors +// returned by TaskCategory.ValidateAll() if the designated constraints aren't met. +type TaskCategoryMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskCategoryMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskCategoryMultiError) AllErrors() []error { return m } + +// TaskCategoryValidationError is the validation error returned by +// TaskCategory.Validate if the designated constraints aren't met. +type TaskCategoryValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskCategoryValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskCategoryValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskCategoryValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskCategoryValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskCategoryValidationError) ErrorName() string { return "TaskCategoryValidationError" } + +// Error satisfies the builtin error interface +func (e TaskCategoryValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskCategory.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskCategoryValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskCategoryValidationError{} + +// Validate checks the field values on GetConnectorRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetConnectorRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetConnectorRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetConnectorRequestMultiError, or nil if none found. +func (m *GetConnectorRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetConnectorRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + if len(errors) > 0 { + return GetConnectorRequestMultiError(errors) + } + + return nil +} + +// GetConnectorRequestMultiError is an error wrapping multiple validation +// errors returned by GetConnectorRequest.ValidateAll() if the designated +// constraints aren't met. +type GetConnectorRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetConnectorRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetConnectorRequestMultiError) AllErrors() []error { return m } + +// GetConnectorRequestValidationError is the validation error returned by +// GetConnectorRequest.Validate if the designated constraints aren't met. +type GetConnectorRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetConnectorRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetConnectorRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetConnectorRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetConnectorRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetConnectorRequestValidationError) ErrorName() string { + return "GetConnectorRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e GetConnectorRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetConnectorRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetConnectorRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetConnectorRequestValidationError{} + +// Validate checks the field values on GetConnectorResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetConnectorResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetConnectorResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetConnectorResponseMultiError, or nil if none found. +func (m *GetConnectorResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetConnectorResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetConnector()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetConnectorResponseValidationError{ + field: "Connector", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetConnectorResponseValidationError{ + field: "Connector", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetConnector()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetConnectorResponseValidationError{ + field: "Connector", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetConnectorResponseMultiError(errors) + } + + return nil +} + +// GetConnectorResponseMultiError is an error wrapping multiple validation +// errors returned by GetConnectorResponse.ValidateAll() if the designated +// constraints aren't met. +type GetConnectorResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetConnectorResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetConnectorResponseMultiError) AllErrors() []error { return m } + +// GetConnectorResponseValidationError is the validation error returned by +// GetConnectorResponse.Validate if the designated constraints aren't met. +type GetConnectorResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetConnectorResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetConnectorResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetConnectorResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetConnectorResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetConnectorResponseValidationError) ErrorName() string { + return "GetConnectorResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e GetConnectorResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetConnectorResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetConnectorResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetConnectorResponseValidationError{} + +// Validate checks the field values on ListConnectorsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ListConnectorsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListConnectorsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ListConnectorsRequestMultiError, or nil if none found. +func (m *ListConnectorsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *ListConnectorsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return ListConnectorsRequestMultiError(errors) + } + + return nil +} + +// ListConnectorsRequestMultiError is an error wrapping multiple validation +// errors returned by ListConnectorsRequest.ValidateAll() if the designated +// constraints aren't met. +type ListConnectorsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListConnectorsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListConnectorsRequestMultiError) AllErrors() []error { return m } + +// ListConnectorsRequestValidationError is the validation error returned by +// ListConnectorsRequest.Validate if the designated constraints aren't met. +type ListConnectorsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListConnectorsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListConnectorsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListConnectorsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListConnectorsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListConnectorsRequestValidationError) ErrorName() string { + return "ListConnectorsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e ListConnectorsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListConnectorsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListConnectorsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListConnectorsRequestValidationError{} + +// Validate checks the field values on ListConnectorsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ListConnectorsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListConnectorsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ListConnectorsResponseMultiError, or nil if none found. +func (m *ListConnectorsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *ListConnectorsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetConnectors() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListConnectorsResponseValidationError{ + field: fmt.Sprintf("Connectors[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListConnectorsResponseValidationError{ + field: fmt.Sprintf("Connectors[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListConnectorsResponseValidationError{ + field: fmt.Sprintf("Connectors[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return ListConnectorsResponseMultiError(errors) + } + + return nil +} + +// ListConnectorsResponseMultiError is an error wrapping multiple validation +// errors returned by ListConnectorsResponse.ValidateAll() if the designated +// constraints aren't met. +type ListConnectorsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListConnectorsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListConnectorsResponseMultiError) AllErrors() []error { return m } + +// ListConnectorsResponseValidationError is the validation error returned by +// ListConnectorsResponse.Validate if the designated constraints aren't met. +type ListConnectorsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListConnectorsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListConnectorsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListConnectorsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListConnectorsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListConnectorsResponseValidationError) ErrorName() string { + return "ListConnectorsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e ListConnectorsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListConnectorsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListConnectorsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListConnectorsResponseValidationError{} + +// Validate checks the field values on GetTaskMetricsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetTaskMetricsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetTaskMetricsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetTaskMetricsRequestMultiError, or nil if none found. +func (m *GetTaskMetricsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetTaskMetricsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ResourceMeta + + if all { + switch v := interface{}(m.GetStartTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTaskMetricsRequestValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTaskMetricsRequestValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStartTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTaskMetricsRequestValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetEndTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTaskMetricsRequestValidationError{ + field: "EndTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTaskMetricsRequestValidationError{ + field: "EndTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetEndTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTaskMetricsRequestValidationError{ + field: "EndTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetStep()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTaskMetricsRequestValidationError{ + field: "Step", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTaskMetricsRequestValidationError{ + field: "Step", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStep()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTaskMetricsRequestValidationError{ + field: "Step", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetTaskCategory()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTaskMetricsRequestValidationError{ + field: "TaskCategory", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTaskMetricsRequestValidationError{ + field: "TaskCategory", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskCategory()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTaskMetricsRequestValidationError{ + field: "TaskCategory", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetTaskMetricsRequestMultiError(errors) + } + + return nil +} + +// GetTaskMetricsRequestMultiError is an error wrapping multiple validation +// errors returned by GetTaskMetricsRequest.ValidateAll() if the designated +// constraints aren't met. +type GetTaskMetricsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetTaskMetricsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetTaskMetricsRequestMultiError) AllErrors() []error { return m } + +// GetTaskMetricsRequestValidationError is the validation error returned by +// GetTaskMetricsRequest.Validate if the designated constraints aren't met. +type GetTaskMetricsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetTaskMetricsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetTaskMetricsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetTaskMetricsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetTaskMetricsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetTaskMetricsRequestValidationError) ErrorName() string { + return "GetTaskMetricsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e GetTaskMetricsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetTaskMetricsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetTaskMetricsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetTaskMetricsRequestValidationError{} + +// Validate checks the field values on GetTaskMetricsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetTaskMetricsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetTaskMetricsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetTaskMetricsResponseMultiError, or nil if none found. +func (m *GetTaskMetricsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetTaskMetricsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetResults() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTaskMetricsResponseValidationError{ + field: fmt.Sprintf("Results[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTaskMetricsResponseValidationError{ + field: fmt.Sprintf("Results[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTaskMetricsResponseValidationError{ + field: fmt.Sprintf("Results[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return GetTaskMetricsResponseMultiError(errors) + } + + return nil +} + +// GetTaskMetricsResponseMultiError is an error wrapping multiple validation +// errors returned by GetTaskMetricsResponse.ValidateAll() if the designated +// constraints aren't met. +type GetTaskMetricsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetTaskMetricsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetTaskMetricsResponseMultiError) AllErrors() []error { return m } + +// GetTaskMetricsResponseValidationError is the validation error returned by +// GetTaskMetricsResponse.Validate if the designated constraints aren't met. +type GetTaskMetricsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetTaskMetricsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetTaskMetricsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetTaskMetricsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetTaskMetricsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetTaskMetricsResponseValidationError) ErrorName() string { + return "GetTaskMetricsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e GetTaskMetricsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetTaskMetricsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetTaskMetricsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetTaskMetricsResponseValidationError{} + +// Validate checks the field values on GetTaskLogsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetTaskLogsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetTaskLogsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetTaskLogsRequestMultiError, or nil if none found. +func (m *GetTaskLogsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetTaskLogsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ResourceMeta + + // no validation rules for Lines + + // no validation rules for Token + + if all { + switch v := interface{}(m.GetTaskCategory()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTaskLogsRequestValidationError{ + field: "TaskCategory", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTaskLogsRequestValidationError{ + field: "TaskCategory", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskCategory()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTaskLogsRequestValidationError{ + field: "TaskCategory", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetTaskLogsRequestMultiError(errors) + } + + return nil +} + +// GetTaskLogsRequestMultiError is an error wrapping multiple validation errors +// returned by GetTaskLogsRequest.ValidateAll() if the designated constraints +// aren't met. +type GetTaskLogsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetTaskLogsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetTaskLogsRequestMultiError) AllErrors() []error { return m } + +// GetTaskLogsRequestValidationError is the validation error returned by +// GetTaskLogsRequest.Validate if the designated constraints aren't met. +type GetTaskLogsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetTaskLogsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetTaskLogsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetTaskLogsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetTaskLogsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetTaskLogsRequestValidationError) ErrorName() string { + return "GetTaskLogsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e GetTaskLogsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetTaskLogsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetTaskLogsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetTaskLogsRequestValidationError{} + +// Validate checks the field values on GetTaskLogsResponseHeader with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetTaskLogsResponseHeader) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetTaskLogsResponseHeader with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetTaskLogsResponseHeaderMultiError, or nil if none found. +func (m *GetTaskLogsResponseHeader) ValidateAll() error { + return m.validate(true) +} + +func (m *GetTaskLogsResponseHeader) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Token + + if len(errors) > 0 { + return GetTaskLogsResponseHeaderMultiError(errors) + } + + return nil +} + +// GetTaskLogsResponseHeaderMultiError is an error wrapping multiple validation +// errors returned by GetTaskLogsResponseHeader.ValidateAll() if the +// designated constraints aren't met. +type GetTaskLogsResponseHeaderMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetTaskLogsResponseHeaderMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetTaskLogsResponseHeaderMultiError) AllErrors() []error { return m } + +// GetTaskLogsResponseHeaderValidationError is the validation error returned by +// GetTaskLogsResponseHeader.Validate if the designated constraints aren't met. +type GetTaskLogsResponseHeaderValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetTaskLogsResponseHeaderValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetTaskLogsResponseHeaderValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetTaskLogsResponseHeaderValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetTaskLogsResponseHeaderValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetTaskLogsResponseHeaderValidationError) ErrorName() string { + return "GetTaskLogsResponseHeaderValidationError" +} + +// Error satisfies the builtin error interface +func (e GetTaskLogsResponseHeaderValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetTaskLogsResponseHeader.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetTaskLogsResponseHeaderValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetTaskLogsResponseHeaderValidationError{} + +// Validate checks the field values on GetTaskLogsResponseBody with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetTaskLogsResponseBody) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetTaskLogsResponseBody with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetTaskLogsResponseBodyMultiError, or nil if none found. +func (m *GetTaskLogsResponseBody) ValidateAll() error { + return m.validate(true) +} + +func (m *GetTaskLogsResponseBody) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return GetTaskLogsResponseBodyMultiError(errors) + } + + return nil +} + +// GetTaskLogsResponseBodyMultiError is an error wrapping multiple validation +// errors returned by GetTaskLogsResponseBody.ValidateAll() if the designated +// constraints aren't met. +type GetTaskLogsResponseBodyMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetTaskLogsResponseBodyMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetTaskLogsResponseBodyMultiError) AllErrors() []error { return m } + +// GetTaskLogsResponseBodyValidationError is the validation error returned by +// GetTaskLogsResponseBody.Validate if the designated constraints aren't met. +type GetTaskLogsResponseBodyValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetTaskLogsResponseBodyValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetTaskLogsResponseBodyValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetTaskLogsResponseBodyValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetTaskLogsResponseBodyValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetTaskLogsResponseBodyValidationError) ErrorName() string { + return "GetTaskLogsResponseBodyValidationError" +} + +// Error satisfies the builtin error interface +func (e GetTaskLogsResponseBodyValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetTaskLogsResponseBody.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetTaskLogsResponseBodyValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetTaskLogsResponseBodyValidationError{} + +// Validate checks the field values on GetTaskLogsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetTaskLogsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetTaskLogsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetTaskLogsResponseMultiError, or nil if none found. +func (m *GetTaskLogsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetTaskLogsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Part.(type) { + case *GetTaskLogsResponse_Header: + if v == nil { + err := GetTaskLogsResponseValidationError{ + field: "Part", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetHeader()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTaskLogsResponseValidationError{ + field: "Header", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTaskLogsResponseValidationError{ + field: "Header", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetHeader()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTaskLogsResponseValidationError{ + field: "Header", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *GetTaskLogsResponse_Body: + if v == nil { + err := GetTaskLogsResponseValidationError{ + field: "Part", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetBody()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTaskLogsResponseValidationError{ + field: "Body", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTaskLogsResponseValidationError{ + field: "Body", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetBody()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTaskLogsResponseValidationError{ + field: "Body", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return GetTaskLogsResponseMultiError(errors) + } + + return nil +} + +// GetTaskLogsResponseMultiError is an error wrapping multiple validation +// errors returned by GetTaskLogsResponse.ValidateAll() if the designated +// constraints aren't met. +type GetTaskLogsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetTaskLogsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetTaskLogsResponseMultiError) AllErrors() []error { return m } + +// GetTaskLogsResponseValidationError is the validation error returned by +// GetTaskLogsResponse.Validate if the designated constraints aren't met. +type GetTaskLogsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetTaskLogsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetTaskLogsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetTaskLogsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetTaskLogsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetTaskLogsResponseValidationError) ErrorName() string { + return "GetTaskLogsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e GetTaskLogsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetTaskLogsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetTaskLogsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetTaskLogsResponseValidationError{} diff --git a/gen/go/flyteidl2/connector/connectorconnect/service.connect.go b/gen/go/flyteidl2/connector/connectorconnect/service.connect.go new file mode 100644 index 0000000000..cd67de5a84 --- /dev/null +++ b/gen/go/flyteidl2/connector/connectorconnect/service.connect.go @@ -0,0 +1,365 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: flyteidl2/connector/service.proto + +package connectorconnect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + connector "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // AsyncConnectorServiceName is the fully-qualified name of the AsyncConnectorService service. + AsyncConnectorServiceName = "flyteidl2.connector.AsyncConnectorService" + // ConnectorMetadataServiceName is the fully-qualified name of the ConnectorMetadataService service. + ConnectorMetadataServiceName = "flyteidl2.connector.ConnectorMetadataService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // AsyncConnectorServiceCreateTaskProcedure is the fully-qualified name of the + // AsyncConnectorService's CreateTask RPC. + AsyncConnectorServiceCreateTaskProcedure = "/flyteidl2.connector.AsyncConnectorService/CreateTask" + // AsyncConnectorServiceGetTaskProcedure is the fully-qualified name of the AsyncConnectorService's + // GetTask RPC. + AsyncConnectorServiceGetTaskProcedure = "/flyteidl2.connector.AsyncConnectorService/GetTask" + // AsyncConnectorServiceDeleteTaskProcedure is the fully-qualified name of the + // AsyncConnectorService's DeleteTask RPC. + AsyncConnectorServiceDeleteTaskProcedure = "/flyteidl2.connector.AsyncConnectorService/DeleteTask" + // AsyncConnectorServiceGetTaskMetricsProcedure is the fully-qualified name of the + // AsyncConnectorService's GetTaskMetrics RPC. + AsyncConnectorServiceGetTaskMetricsProcedure = "/flyteidl2.connector.AsyncConnectorService/GetTaskMetrics" + // AsyncConnectorServiceGetTaskLogsProcedure is the fully-qualified name of the + // AsyncConnectorService's GetTaskLogs RPC. + AsyncConnectorServiceGetTaskLogsProcedure = "/flyteidl2.connector.AsyncConnectorService/GetTaskLogs" + // ConnectorMetadataServiceGetConnectorProcedure is the fully-qualified name of the + // ConnectorMetadataService's GetConnector RPC. + ConnectorMetadataServiceGetConnectorProcedure = "/flyteidl2.connector.ConnectorMetadataService/GetConnector" + // ConnectorMetadataServiceListConnectorsProcedure is the fully-qualified name of the + // ConnectorMetadataService's ListConnectors RPC. + ConnectorMetadataServiceListConnectorsProcedure = "/flyteidl2.connector.ConnectorMetadataService/ListConnectors" +) + +// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. +var ( + asyncConnectorServiceServiceDescriptor = connector.File_flyteidl2_connector_service_proto.Services().ByName("AsyncConnectorService") + asyncConnectorServiceCreateTaskMethodDescriptor = asyncConnectorServiceServiceDescriptor.Methods().ByName("CreateTask") + asyncConnectorServiceGetTaskMethodDescriptor = asyncConnectorServiceServiceDescriptor.Methods().ByName("GetTask") + asyncConnectorServiceDeleteTaskMethodDescriptor = asyncConnectorServiceServiceDescriptor.Methods().ByName("DeleteTask") + asyncConnectorServiceGetTaskMetricsMethodDescriptor = asyncConnectorServiceServiceDescriptor.Methods().ByName("GetTaskMetrics") + asyncConnectorServiceGetTaskLogsMethodDescriptor = asyncConnectorServiceServiceDescriptor.Methods().ByName("GetTaskLogs") + connectorMetadataServiceServiceDescriptor = connector.File_flyteidl2_connector_service_proto.Services().ByName("ConnectorMetadataService") + connectorMetadataServiceGetConnectorMethodDescriptor = connectorMetadataServiceServiceDescriptor.Methods().ByName("GetConnector") + connectorMetadataServiceListConnectorsMethodDescriptor = connectorMetadataServiceServiceDescriptor.Methods().ByName("ListConnectors") +) + +// AsyncConnectorServiceClient is a client for the flyteidl2.connector.AsyncConnectorService +// service. +type AsyncConnectorServiceClient interface { + // CreateTask sends a task create request to the connector service. + CreateTask(context.Context, *connect.Request[connector.CreateTaskRequest]) (*connect.Response[connector.CreateTaskResponse], error) + // Get job status. + GetTask(context.Context, *connect.Request[connector.GetTaskRequest]) (*connect.Response[connector.GetTaskResponse], error) + // Delete the task resource. + DeleteTask(context.Context, *connect.Request[connector.DeleteTaskRequest]) (*connect.Response[connector.DeleteTaskResponse], error) + // GetTaskMetrics returns one or more task execution metrics, if available. + // + // Errors include + // - OutOfRange if metrics are not available for the specified task time range + // - various other errors + GetTaskMetrics(context.Context, *connect.Request[connector.GetTaskMetricsRequest]) (*connect.Response[connector.GetTaskMetricsResponse], error) + // GetTaskLogs returns task execution logs, if available. + GetTaskLogs(context.Context, *connect.Request[connector.GetTaskLogsRequest]) (*connect.ServerStreamForClient[connector.GetTaskLogsResponse], error) +} + +// NewAsyncConnectorServiceClient constructs a client for the +// flyteidl2.connector.AsyncConnectorService service. By default, it uses the Connect protocol with +// the binary Protobuf Codec, asks for gzipped responses, and sends uncompressed requests. To use +// the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewAsyncConnectorServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) AsyncConnectorServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &asyncConnectorServiceClient{ + createTask: connect.NewClient[connector.CreateTaskRequest, connector.CreateTaskResponse]( + httpClient, + baseURL+AsyncConnectorServiceCreateTaskProcedure, + connect.WithSchema(asyncConnectorServiceCreateTaskMethodDescriptor), + connect.WithClientOptions(opts...), + ), + getTask: connect.NewClient[connector.GetTaskRequest, connector.GetTaskResponse]( + httpClient, + baseURL+AsyncConnectorServiceGetTaskProcedure, + connect.WithSchema(asyncConnectorServiceGetTaskMethodDescriptor), + connect.WithClientOptions(opts...), + ), + deleteTask: connect.NewClient[connector.DeleteTaskRequest, connector.DeleteTaskResponse]( + httpClient, + baseURL+AsyncConnectorServiceDeleteTaskProcedure, + connect.WithSchema(asyncConnectorServiceDeleteTaskMethodDescriptor), + connect.WithClientOptions(opts...), + ), + getTaskMetrics: connect.NewClient[connector.GetTaskMetricsRequest, connector.GetTaskMetricsResponse]( + httpClient, + baseURL+AsyncConnectorServiceGetTaskMetricsProcedure, + connect.WithSchema(asyncConnectorServiceGetTaskMetricsMethodDescriptor), + connect.WithClientOptions(opts...), + ), + getTaskLogs: connect.NewClient[connector.GetTaskLogsRequest, connector.GetTaskLogsResponse]( + httpClient, + baseURL+AsyncConnectorServiceGetTaskLogsProcedure, + connect.WithSchema(asyncConnectorServiceGetTaskLogsMethodDescriptor), + connect.WithClientOptions(opts...), + ), + } +} + +// asyncConnectorServiceClient implements AsyncConnectorServiceClient. +type asyncConnectorServiceClient struct { + createTask *connect.Client[connector.CreateTaskRequest, connector.CreateTaskResponse] + getTask *connect.Client[connector.GetTaskRequest, connector.GetTaskResponse] + deleteTask *connect.Client[connector.DeleteTaskRequest, connector.DeleteTaskResponse] + getTaskMetrics *connect.Client[connector.GetTaskMetricsRequest, connector.GetTaskMetricsResponse] + getTaskLogs *connect.Client[connector.GetTaskLogsRequest, connector.GetTaskLogsResponse] +} + +// CreateTask calls flyteidl2.connector.AsyncConnectorService.CreateTask. +func (c *asyncConnectorServiceClient) CreateTask(ctx context.Context, req *connect.Request[connector.CreateTaskRequest]) (*connect.Response[connector.CreateTaskResponse], error) { + return c.createTask.CallUnary(ctx, req) +} + +// GetTask calls flyteidl2.connector.AsyncConnectorService.GetTask. +func (c *asyncConnectorServiceClient) GetTask(ctx context.Context, req *connect.Request[connector.GetTaskRequest]) (*connect.Response[connector.GetTaskResponse], error) { + return c.getTask.CallUnary(ctx, req) +} + +// DeleteTask calls flyteidl2.connector.AsyncConnectorService.DeleteTask. +func (c *asyncConnectorServiceClient) DeleteTask(ctx context.Context, req *connect.Request[connector.DeleteTaskRequest]) (*connect.Response[connector.DeleteTaskResponse], error) { + return c.deleteTask.CallUnary(ctx, req) +} + +// GetTaskMetrics calls flyteidl2.connector.AsyncConnectorService.GetTaskMetrics. +func (c *asyncConnectorServiceClient) GetTaskMetrics(ctx context.Context, req *connect.Request[connector.GetTaskMetricsRequest]) (*connect.Response[connector.GetTaskMetricsResponse], error) { + return c.getTaskMetrics.CallUnary(ctx, req) +} + +// GetTaskLogs calls flyteidl2.connector.AsyncConnectorService.GetTaskLogs. +func (c *asyncConnectorServiceClient) GetTaskLogs(ctx context.Context, req *connect.Request[connector.GetTaskLogsRequest]) (*connect.ServerStreamForClient[connector.GetTaskLogsResponse], error) { + return c.getTaskLogs.CallServerStream(ctx, req) +} + +// AsyncConnectorServiceHandler is an implementation of the +// flyteidl2.connector.AsyncConnectorService service. +type AsyncConnectorServiceHandler interface { + // CreateTask sends a task create request to the connector service. + CreateTask(context.Context, *connect.Request[connector.CreateTaskRequest]) (*connect.Response[connector.CreateTaskResponse], error) + // Get job status. + GetTask(context.Context, *connect.Request[connector.GetTaskRequest]) (*connect.Response[connector.GetTaskResponse], error) + // Delete the task resource. + DeleteTask(context.Context, *connect.Request[connector.DeleteTaskRequest]) (*connect.Response[connector.DeleteTaskResponse], error) + // GetTaskMetrics returns one or more task execution metrics, if available. + // + // Errors include + // - OutOfRange if metrics are not available for the specified task time range + // - various other errors + GetTaskMetrics(context.Context, *connect.Request[connector.GetTaskMetricsRequest]) (*connect.Response[connector.GetTaskMetricsResponse], error) + // GetTaskLogs returns task execution logs, if available. + GetTaskLogs(context.Context, *connect.Request[connector.GetTaskLogsRequest], *connect.ServerStream[connector.GetTaskLogsResponse]) error +} + +// NewAsyncConnectorServiceHandler builds an HTTP handler from the service implementation. It +// returns the path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewAsyncConnectorServiceHandler(svc AsyncConnectorServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + asyncConnectorServiceCreateTaskHandler := connect.NewUnaryHandler( + AsyncConnectorServiceCreateTaskProcedure, + svc.CreateTask, + connect.WithSchema(asyncConnectorServiceCreateTaskMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + asyncConnectorServiceGetTaskHandler := connect.NewUnaryHandler( + AsyncConnectorServiceGetTaskProcedure, + svc.GetTask, + connect.WithSchema(asyncConnectorServiceGetTaskMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + asyncConnectorServiceDeleteTaskHandler := connect.NewUnaryHandler( + AsyncConnectorServiceDeleteTaskProcedure, + svc.DeleteTask, + connect.WithSchema(asyncConnectorServiceDeleteTaskMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + asyncConnectorServiceGetTaskMetricsHandler := connect.NewUnaryHandler( + AsyncConnectorServiceGetTaskMetricsProcedure, + svc.GetTaskMetrics, + connect.WithSchema(asyncConnectorServiceGetTaskMetricsMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + asyncConnectorServiceGetTaskLogsHandler := connect.NewServerStreamHandler( + AsyncConnectorServiceGetTaskLogsProcedure, + svc.GetTaskLogs, + connect.WithSchema(asyncConnectorServiceGetTaskLogsMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.connector.AsyncConnectorService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case AsyncConnectorServiceCreateTaskProcedure: + asyncConnectorServiceCreateTaskHandler.ServeHTTP(w, r) + case AsyncConnectorServiceGetTaskProcedure: + asyncConnectorServiceGetTaskHandler.ServeHTTP(w, r) + case AsyncConnectorServiceDeleteTaskProcedure: + asyncConnectorServiceDeleteTaskHandler.ServeHTTP(w, r) + case AsyncConnectorServiceGetTaskMetricsProcedure: + asyncConnectorServiceGetTaskMetricsHandler.ServeHTTP(w, r) + case AsyncConnectorServiceGetTaskLogsProcedure: + asyncConnectorServiceGetTaskLogsHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedAsyncConnectorServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedAsyncConnectorServiceHandler struct{} + +func (UnimplementedAsyncConnectorServiceHandler) CreateTask(context.Context, *connect.Request[connector.CreateTaskRequest]) (*connect.Response[connector.CreateTaskResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.connector.AsyncConnectorService.CreateTask is not implemented")) +} + +func (UnimplementedAsyncConnectorServiceHandler) GetTask(context.Context, *connect.Request[connector.GetTaskRequest]) (*connect.Response[connector.GetTaskResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.connector.AsyncConnectorService.GetTask is not implemented")) +} + +func (UnimplementedAsyncConnectorServiceHandler) DeleteTask(context.Context, *connect.Request[connector.DeleteTaskRequest]) (*connect.Response[connector.DeleteTaskResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.connector.AsyncConnectorService.DeleteTask is not implemented")) +} + +func (UnimplementedAsyncConnectorServiceHandler) GetTaskMetrics(context.Context, *connect.Request[connector.GetTaskMetricsRequest]) (*connect.Response[connector.GetTaskMetricsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.connector.AsyncConnectorService.GetTaskMetrics is not implemented")) +} + +func (UnimplementedAsyncConnectorServiceHandler) GetTaskLogs(context.Context, *connect.Request[connector.GetTaskLogsRequest], *connect.ServerStream[connector.GetTaskLogsResponse]) error { + return connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.connector.AsyncConnectorService.GetTaskLogs is not implemented")) +} + +// ConnectorMetadataServiceClient is a client for the flyteidl2.connector.ConnectorMetadataService +// service. +type ConnectorMetadataServiceClient interface { + // Fetch a :ref:`ref_flyteidl2.plugins.Connector` definition. + GetConnector(context.Context, *connect.Request[connector.GetConnectorRequest]) (*connect.Response[connector.GetConnectorResponse], error) + // Fetch a list of :ref:`ref_flyteidl2.plugins.Connector` definitions. + ListConnectors(context.Context, *connect.Request[connector.ListConnectorsRequest]) (*connect.Response[connector.ListConnectorsResponse], error) +} + +// NewConnectorMetadataServiceClient constructs a client for the +// flyteidl2.connector.ConnectorMetadataService service. By default, it uses the Connect protocol +// with the binary Protobuf Codec, asks for gzipped responses, and sends uncompressed requests. To +// use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or connect.WithGRPCWeb() +// options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewConnectorMetadataServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) ConnectorMetadataServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &connectorMetadataServiceClient{ + getConnector: connect.NewClient[connector.GetConnectorRequest, connector.GetConnectorResponse]( + httpClient, + baseURL+ConnectorMetadataServiceGetConnectorProcedure, + connect.WithSchema(connectorMetadataServiceGetConnectorMethodDescriptor), + connect.WithClientOptions(opts...), + ), + listConnectors: connect.NewClient[connector.ListConnectorsRequest, connector.ListConnectorsResponse]( + httpClient, + baseURL+ConnectorMetadataServiceListConnectorsProcedure, + connect.WithSchema(connectorMetadataServiceListConnectorsMethodDescriptor), + connect.WithClientOptions(opts...), + ), + } +} + +// connectorMetadataServiceClient implements ConnectorMetadataServiceClient. +type connectorMetadataServiceClient struct { + getConnector *connect.Client[connector.GetConnectorRequest, connector.GetConnectorResponse] + listConnectors *connect.Client[connector.ListConnectorsRequest, connector.ListConnectorsResponse] +} + +// GetConnector calls flyteidl2.connector.ConnectorMetadataService.GetConnector. +func (c *connectorMetadataServiceClient) GetConnector(ctx context.Context, req *connect.Request[connector.GetConnectorRequest]) (*connect.Response[connector.GetConnectorResponse], error) { + return c.getConnector.CallUnary(ctx, req) +} + +// ListConnectors calls flyteidl2.connector.ConnectorMetadataService.ListConnectors. +func (c *connectorMetadataServiceClient) ListConnectors(ctx context.Context, req *connect.Request[connector.ListConnectorsRequest]) (*connect.Response[connector.ListConnectorsResponse], error) { + return c.listConnectors.CallUnary(ctx, req) +} + +// ConnectorMetadataServiceHandler is an implementation of the +// flyteidl2.connector.ConnectorMetadataService service. +type ConnectorMetadataServiceHandler interface { + // Fetch a :ref:`ref_flyteidl2.plugins.Connector` definition. + GetConnector(context.Context, *connect.Request[connector.GetConnectorRequest]) (*connect.Response[connector.GetConnectorResponse], error) + // Fetch a list of :ref:`ref_flyteidl2.plugins.Connector` definitions. + ListConnectors(context.Context, *connect.Request[connector.ListConnectorsRequest]) (*connect.Response[connector.ListConnectorsResponse], error) +} + +// NewConnectorMetadataServiceHandler builds an HTTP handler from the service implementation. It +// returns the path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewConnectorMetadataServiceHandler(svc ConnectorMetadataServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + connectorMetadataServiceGetConnectorHandler := connect.NewUnaryHandler( + ConnectorMetadataServiceGetConnectorProcedure, + svc.GetConnector, + connect.WithSchema(connectorMetadataServiceGetConnectorMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + connectorMetadataServiceListConnectorsHandler := connect.NewUnaryHandler( + ConnectorMetadataServiceListConnectorsProcedure, + svc.ListConnectors, + connect.WithSchema(connectorMetadataServiceListConnectorsMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.connector.ConnectorMetadataService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case ConnectorMetadataServiceGetConnectorProcedure: + connectorMetadataServiceGetConnectorHandler.ServeHTTP(w, r) + case ConnectorMetadataServiceListConnectorsProcedure: + connectorMetadataServiceListConnectorsHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedConnectorMetadataServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedConnectorMetadataServiceHandler struct{} + +func (UnimplementedConnectorMetadataServiceHandler) GetConnector(context.Context, *connect.Request[connector.GetConnectorRequest]) (*connect.Response[connector.GetConnectorResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.connector.ConnectorMetadataService.GetConnector is not implemented")) +} + +func (UnimplementedConnectorMetadataServiceHandler) ListConnectors(context.Context, *connect.Request[connector.ListConnectorsRequest]) (*connect.Response[connector.ListConnectorsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.connector.ConnectorMetadataService.ListConnectors is not implemented")) +} diff --git a/gen/go/flyteidl2/connector/mocks/async_connector_service_client.go b/gen/go/flyteidl2/connector/mocks/async_connector_service_client.go new file mode 100644 index 0000000000..06159304d1 --- /dev/null +++ b/gen/go/flyteidl2/connector/mocks/async_connector_service_client.go @@ -0,0 +1,410 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + connector "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector" + + grpc "google.golang.org/grpc" + + mock "github.com/stretchr/testify/mock" +) + +// AsyncConnectorServiceClient is an autogenerated mock type for the AsyncConnectorServiceClient type +type AsyncConnectorServiceClient struct { + mock.Mock +} + +type AsyncConnectorServiceClient_Expecter struct { + mock *mock.Mock +} + +func (_m *AsyncConnectorServiceClient) EXPECT() *AsyncConnectorServiceClient_Expecter { + return &AsyncConnectorServiceClient_Expecter{mock: &_m.Mock} +} + +// CreateTask provides a mock function with given fields: ctx, in, opts +func (_m *AsyncConnectorServiceClient) CreateTask(ctx context.Context, in *connector.CreateTaskRequest, opts ...grpc.CallOption) (*connector.CreateTaskResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateTask") + } + + var r0 *connector.CreateTaskResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connector.CreateTaskRequest, ...grpc.CallOption) (*connector.CreateTaskResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *connector.CreateTaskRequest, ...grpc.CallOption) *connector.CreateTaskResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connector.CreateTaskResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connector.CreateTaskRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AsyncConnectorServiceClient_CreateTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTask' +type AsyncConnectorServiceClient_CreateTask_Call struct { + *mock.Call +} + +// CreateTask is a helper method to define mock.On call +// - ctx context.Context +// - in *connector.CreateTaskRequest +// - opts ...grpc.CallOption +func (_e *AsyncConnectorServiceClient_Expecter) CreateTask(ctx interface{}, in interface{}, opts ...interface{}) *AsyncConnectorServiceClient_CreateTask_Call { + return &AsyncConnectorServiceClient_CreateTask_Call{Call: _e.mock.On("CreateTask", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *AsyncConnectorServiceClient_CreateTask_Call) Run(run func(ctx context.Context, in *connector.CreateTaskRequest, opts ...grpc.CallOption)) *AsyncConnectorServiceClient_CreateTask_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*connector.CreateTaskRequest), variadicArgs...) + }) + return _c +} + +func (_c *AsyncConnectorServiceClient_CreateTask_Call) Return(_a0 *connector.CreateTaskResponse, _a1 error) *AsyncConnectorServiceClient_CreateTask_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AsyncConnectorServiceClient_CreateTask_Call) RunAndReturn(run func(context.Context, *connector.CreateTaskRequest, ...grpc.CallOption) (*connector.CreateTaskResponse, error)) *AsyncConnectorServiceClient_CreateTask_Call { + _c.Call.Return(run) + return _c +} + +// DeleteTask provides a mock function with given fields: ctx, in, opts +func (_m *AsyncConnectorServiceClient) DeleteTask(ctx context.Context, in *connector.DeleteTaskRequest, opts ...grpc.CallOption) (*connector.DeleteTaskResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteTask") + } + + var r0 *connector.DeleteTaskResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connector.DeleteTaskRequest, ...grpc.CallOption) (*connector.DeleteTaskResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *connector.DeleteTaskRequest, ...grpc.CallOption) *connector.DeleteTaskResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connector.DeleteTaskResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connector.DeleteTaskRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AsyncConnectorServiceClient_DeleteTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTask' +type AsyncConnectorServiceClient_DeleteTask_Call struct { + *mock.Call +} + +// DeleteTask is a helper method to define mock.On call +// - ctx context.Context +// - in *connector.DeleteTaskRequest +// - opts ...grpc.CallOption +func (_e *AsyncConnectorServiceClient_Expecter) DeleteTask(ctx interface{}, in interface{}, opts ...interface{}) *AsyncConnectorServiceClient_DeleteTask_Call { + return &AsyncConnectorServiceClient_DeleteTask_Call{Call: _e.mock.On("DeleteTask", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *AsyncConnectorServiceClient_DeleteTask_Call) Run(run func(ctx context.Context, in *connector.DeleteTaskRequest, opts ...grpc.CallOption)) *AsyncConnectorServiceClient_DeleteTask_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*connector.DeleteTaskRequest), variadicArgs...) + }) + return _c +} + +func (_c *AsyncConnectorServiceClient_DeleteTask_Call) Return(_a0 *connector.DeleteTaskResponse, _a1 error) *AsyncConnectorServiceClient_DeleteTask_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AsyncConnectorServiceClient_DeleteTask_Call) RunAndReturn(run func(context.Context, *connector.DeleteTaskRequest, ...grpc.CallOption) (*connector.DeleteTaskResponse, error)) *AsyncConnectorServiceClient_DeleteTask_Call { + _c.Call.Return(run) + return _c +} + +// GetTask provides a mock function with given fields: ctx, in, opts +func (_m *AsyncConnectorServiceClient) GetTask(ctx context.Context, in *connector.GetTaskRequest, opts ...grpc.CallOption) (*connector.GetTaskResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetTask") + } + + var r0 *connector.GetTaskResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connector.GetTaskRequest, ...grpc.CallOption) (*connector.GetTaskResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *connector.GetTaskRequest, ...grpc.CallOption) *connector.GetTaskResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connector.GetTaskResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connector.GetTaskRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AsyncConnectorServiceClient_GetTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTask' +type AsyncConnectorServiceClient_GetTask_Call struct { + *mock.Call +} + +// GetTask is a helper method to define mock.On call +// - ctx context.Context +// - in *connector.GetTaskRequest +// - opts ...grpc.CallOption +func (_e *AsyncConnectorServiceClient_Expecter) GetTask(ctx interface{}, in interface{}, opts ...interface{}) *AsyncConnectorServiceClient_GetTask_Call { + return &AsyncConnectorServiceClient_GetTask_Call{Call: _e.mock.On("GetTask", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *AsyncConnectorServiceClient_GetTask_Call) Run(run func(ctx context.Context, in *connector.GetTaskRequest, opts ...grpc.CallOption)) *AsyncConnectorServiceClient_GetTask_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*connector.GetTaskRequest), variadicArgs...) + }) + return _c +} + +func (_c *AsyncConnectorServiceClient_GetTask_Call) Return(_a0 *connector.GetTaskResponse, _a1 error) *AsyncConnectorServiceClient_GetTask_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AsyncConnectorServiceClient_GetTask_Call) RunAndReturn(run func(context.Context, *connector.GetTaskRequest, ...grpc.CallOption) (*connector.GetTaskResponse, error)) *AsyncConnectorServiceClient_GetTask_Call { + _c.Call.Return(run) + return _c +} + +// GetTaskLogs provides a mock function with given fields: ctx, in, opts +func (_m *AsyncConnectorServiceClient) GetTaskLogs(ctx context.Context, in *connector.GetTaskLogsRequest, opts ...grpc.CallOption) (connector.AsyncConnectorService_GetTaskLogsClient, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetTaskLogs") + } + + var r0 connector.AsyncConnectorService_GetTaskLogsClient + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connector.GetTaskLogsRequest, ...grpc.CallOption) (connector.AsyncConnectorService_GetTaskLogsClient, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *connector.GetTaskLogsRequest, ...grpc.CallOption) connector.AsyncConnectorService_GetTaskLogsClient); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(connector.AsyncConnectorService_GetTaskLogsClient) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connector.GetTaskLogsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AsyncConnectorServiceClient_GetTaskLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTaskLogs' +type AsyncConnectorServiceClient_GetTaskLogs_Call struct { + *mock.Call +} + +// GetTaskLogs is a helper method to define mock.On call +// - ctx context.Context +// - in *connector.GetTaskLogsRequest +// - opts ...grpc.CallOption +func (_e *AsyncConnectorServiceClient_Expecter) GetTaskLogs(ctx interface{}, in interface{}, opts ...interface{}) *AsyncConnectorServiceClient_GetTaskLogs_Call { + return &AsyncConnectorServiceClient_GetTaskLogs_Call{Call: _e.mock.On("GetTaskLogs", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *AsyncConnectorServiceClient_GetTaskLogs_Call) Run(run func(ctx context.Context, in *connector.GetTaskLogsRequest, opts ...grpc.CallOption)) *AsyncConnectorServiceClient_GetTaskLogs_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*connector.GetTaskLogsRequest), variadicArgs...) + }) + return _c +} + +func (_c *AsyncConnectorServiceClient_GetTaskLogs_Call) Return(_a0 connector.AsyncConnectorService_GetTaskLogsClient, _a1 error) *AsyncConnectorServiceClient_GetTaskLogs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AsyncConnectorServiceClient_GetTaskLogs_Call) RunAndReturn(run func(context.Context, *connector.GetTaskLogsRequest, ...grpc.CallOption) (connector.AsyncConnectorService_GetTaskLogsClient, error)) *AsyncConnectorServiceClient_GetTaskLogs_Call { + _c.Call.Return(run) + return _c +} + +// GetTaskMetrics provides a mock function with given fields: ctx, in, opts +func (_m *AsyncConnectorServiceClient) GetTaskMetrics(ctx context.Context, in *connector.GetTaskMetricsRequest, opts ...grpc.CallOption) (*connector.GetTaskMetricsResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetTaskMetrics") + } + + var r0 *connector.GetTaskMetricsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connector.GetTaskMetricsRequest, ...grpc.CallOption) (*connector.GetTaskMetricsResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *connector.GetTaskMetricsRequest, ...grpc.CallOption) *connector.GetTaskMetricsResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connector.GetTaskMetricsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connector.GetTaskMetricsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AsyncConnectorServiceClient_GetTaskMetrics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTaskMetrics' +type AsyncConnectorServiceClient_GetTaskMetrics_Call struct { + *mock.Call +} + +// GetTaskMetrics is a helper method to define mock.On call +// - ctx context.Context +// - in *connector.GetTaskMetricsRequest +// - opts ...grpc.CallOption +func (_e *AsyncConnectorServiceClient_Expecter) GetTaskMetrics(ctx interface{}, in interface{}, opts ...interface{}) *AsyncConnectorServiceClient_GetTaskMetrics_Call { + return &AsyncConnectorServiceClient_GetTaskMetrics_Call{Call: _e.mock.On("GetTaskMetrics", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *AsyncConnectorServiceClient_GetTaskMetrics_Call) Run(run func(ctx context.Context, in *connector.GetTaskMetricsRequest, opts ...grpc.CallOption)) *AsyncConnectorServiceClient_GetTaskMetrics_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*connector.GetTaskMetricsRequest), variadicArgs...) + }) + return _c +} + +func (_c *AsyncConnectorServiceClient_GetTaskMetrics_Call) Return(_a0 *connector.GetTaskMetricsResponse, _a1 error) *AsyncConnectorServiceClient_GetTaskMetrics_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AsyncConnectorServiceClient_GetTaskMetrics_Call) RunAndReturn(run func(context.Context, *connector.GetTaskMetricsRequest, ...grpc.CallOption) (*connector.GetTaskMetricsResponse, error)) *AsyncConnectorServiceClient_GetTaskMetrics_Call { + _c.Call.Return(run) + return _c +} + +// NewAsyncConnectorServiceClient creates a new instance of AsyncConnectorServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAsyncConnectorServiceClient(t interface { + mock.TestingT + Cleanup(func()) +}) *AsyncConnectorServiceClient { + mock := &AsyncConnectorServiceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/connector/mocks/async_connector_service_get_task_logs_client.go b/gen/go/flyteidl2/connector/mocks/async_connector_service_get_task_logs_client.go new file mode 100644 index 0000000000..367d622886 --- /dev/null +++ b/gen/go/flyteidl2/connector/mocks/async_connector_service_get_task_logs_client.go @@ -0,0 +1,385 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + connector "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector" + + metadata "google.golang.org/grpc/metadata" + + mock "github.com/stretchr/testify/mock" +) + +// AsyncConnectorService_GetTaskLogsClient is an autogenerated mock type for the AsyncConnectorService_GetTaskLogsClient type +type AsyncConnectorService_GetTaskLogsClient struct { + mock.Mock +} + +type AsyncConnectorService_GetTaskLogsClient_Expecter struct { + mock *mock.Mock +} + +func (_m *AsyncConnectorService_GetTaskLogsClient) EXPECT() *AsyncConnectorService_GetTaskLogsClient_Expecter { + return &AsyncConnectorService_GetTaskLogsClient_Expecter{mock: &_m.Mock} +} + +// CloseSend provides a mock function with no fields +func (_m *AsyncConnectorService_GetTaskLogsClient) CloseSend() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for CloseSend") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AsyncConnectorService_GetTaskLogsClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend' +type AsyncConnectorService_GetTaskLogsClient_CloseSend_Call struct { + *mock.Call +} + +// CloseSend is a helper method to define mock.On call +func (_e *AsyncConnectorService_GetTaskLogsClient_Expecter) CloseSend() *AsyncConnectorService_GetTaskLogsClient_CloseSend_Call { + return &AsyncConnectorService_GetTaskLogsClient_CloseSend_Call{Call: _e.mock.On("CloseSend")} +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_CloseSend_Call) Run(run func()) *AsyncConnectorService_GetTaskLogsClient_CloseSend_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_CloseSend_Call) Return(_a0 error) *AsyncConnectorService_GetTaskLogsClient_CloseSend_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_CloseSend_Call) RunAndReturn(run func() error) *AsyncConnectorService_GetTaskLogsClient_CloseSend_Call { + _c.Call.Return(run) + return _c +} + +// Context provides a mock function with no fields +func (_m *AsyncConnectorService_GetTaskLogsClient) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// AsyncConnectorService_GetTaskLogsClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type AsyncConnectorService_GetTaskLogsClient_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *AsyncConnectorService_GetTaskLogsClient_Expecter) Context() *AsyncConnectorService_GetTaskLogsClient_Context_Call { + return &AsyncConnectorService_GetTaskLogsClient_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_Context_Call) Run(run func()) *AsyncConnectorService_GetTaskLogsClient_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_Context_Call) Return(_a0 context.Context) *AsyncConnectorService_GetTaskLogsClient_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_Context_Call) RunAndReturn(run func() context.Context) *AsyncConnectorService_GetTaskLogsClient_Context_Call { + _c.Call.Return(run) + return _c +} + +// Header provides a mock function with no fields +func (_m *AsyncConnectorService_GetTaskLogsClient) Header() (metadata.MD, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Header") + } + + var r0 metadata.MD + var r1 error + if rf, ok := ret.Get(0).(func() (metadata.MD, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AsyncConnectorService_GetTaskLogsClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header' +type AsyncConnectorService_GetTaskLogsClient_Header_Call struct { + *mock.Call +} + +// Header is a helper method to define mock.On call +func (_e *AsyncConnectorService_GetTaskLogsClient_Expecter) Header() *AsyncConnectorService_GetTaskLogsClient_Header_Call { + return &AsyncConnectorService_GetTaskLogsClient_Header_Call{Call: _e.mock.On("Header")} +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_Header_Call) Run(run func()) *AsyncConnectorService_GetTaskLogsClient_Header_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *AsyncConnectorService_GetTaskLogsClient_Header_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *AsyncConnectorService_GetTaskLogsClient_Header_Call { + _c.Call.Return(run) + return _c +} + +// Recv provides a mock function with no fields +func (_m *AsyncConnectorService_GetTaskLogsClient) Recv() (*connector.GetTaskLogsResponse, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Recv") + } + + var r0 *connector.GetTaskLogsResponse + var r1 error + if rf, ok := ret.Get(0).(func() (*connector.GetTaskLogsResponse, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() *connector.GetTaskLogsResponse); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connector.GetTaskLogsResponse) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AsyncConnectorService_GetTaskLogsClient_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv' +type AsyncConnectorService_GetTaskLogsClient_Recv_Call struct { + *mock.Call +} + +// Recv is a helper method to define mock.On call +func (_e *AsyncConnectorService_GetTaskLogsClient_Expecter) Recv() *AsyncConnectorService_GetTaskLogsClient_Recv_Call { + return &AsyncConnectorService_GetTaskLogsClient_Recv_Call{Call: _e.mock.On("Recv")} +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_Recv_Call) Run(run func()) *AsyncConnectorService_GetTaskLogsClient_Recv_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_Recv_Call) Return(_a0 *connector.GetTaskLogsResponse, _a1 error) *AsyncConnectorService_GetTaskLogsClient_Recv_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_Recv_Call) RunAndReturn(run func() (*connector.GetTaskLogsResponse, error)) *AsyncConnectorService_GetTaskLogsClient_Recv_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *AsyncConnectorService_GetTaskLogsClient) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AsyncConnectorService_GetTaskLogsClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type AsyncConnectorService_GetTaskLogsClient_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *AsyncConnectorService_GetTaskLogsClient_Expecter) RecvMsg(m interface{}) *AsyncConnectorService_GetTaskLogsClient_RecvMsg_Call { + return &AsyncConnectorService_GetTaskLogsClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_RecvMsg_Call) Run(run func(m any)) *AsyncConnectorService_GetTaskLogsClient_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_RecvMsg_Call) Return(_a0 error) *AsyncConnectorService_GetTaskLogsClient_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_RecvMsg_Call) RunAndReturn(run func(any) error) *AsyncConnectorService_GetTaskLogsClient_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *AsyncConnectorService_GetTaskLogsClient) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AsyncConnectorService_GetTaskLogsClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type AsyncConnectorService_GetTaskLogsClient_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *AsyncConnectorService_GetTaskLogsClient_Expecter) SendMsg(m interface{}) *AsyncConnectorService_GetTaskLogsClient_SendMsg_Call { + return &AsyncConnectorService_GetTaskLogsClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_SendMsg_Call) Run(run func(m any)) *AsyncConnectorService_GetTaskLogsClient_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_SendMsg_Call) Return(_a0 error) *AsyncConnectorService_GetTaskLogsClient_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_SendMsg_Call) RunAndReturn(run func(any) error) *AsyncConnectorService_GetTaskLogsClient_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// Trailer provides a mock function with no fields +func (_m *AsyncConnectorService_GetTaskLogsClient) Trailer() metadata.MD { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Trailer") + } + + var r0 metadata.MD + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + return r0 +} + +// AsyncConnectorService_GetTaskLogsClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer' +type AsyncConnectorService_GetTaskLogsClient_Trailer_Call struct { + *mock.Call +} + +// Trailer is a helper method to define mock.On call +func (_e *AsyncConnectorService_GetTaskLogsClient_Expecter) Trailer() *AsyncConnectorService_GetTaskLogsClient_Trailer_Call { + return &AsyncConnectorService_GetTaskLogsClient_Trailer_Call{Call: _e.mock.On("Trailer")} +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_Trailer_Call) Run(run func()) *AsyncConnectorService_GetTaskLogsClient_Trailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_Trailer_Call) Return(_a0 metadata.MD) *AsyncConnectorService_GetTaskLogsClient_Trailer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *AsyncConnectorService_GetTaskLogsClient_Trailer_Call { + _c.Call.Return(run) + return _c +} + +// NewAsyncConnectorService_GetTaskLogsClient creates a new instance of AsyncConnectorService_GetTaskLogsClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAsyncConnectorService_GetTaskLogsClient(t interface { + mock.TestingT + Cleanup(func()) +}) *AsyncConnectorService_GetTaskLogsClient { + mock := &AsyncConnectorService_GetTaskLogsClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/connector/mocks/async_connector_service_get_task_logs_server.go b/gen/go/flyteidl2/connector/mocks/async_connector_service_get_task_logs_server.go new file mode 100644 index 0000000000..f17c292fb9 --- /dev/null +++ b/gen/go/flyteidl2/connector/mocks/async_connector_service_get_task_logs_server.go @@ -0,0 +1,350 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + connector "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector" + + metadata "google.golang.org/grpc/metadata" + + mock "github.com/stretchr/testify/mock" +) + +// AsyncConnectorService_GetTaskLogsServer is an autogenerated mock type for the AsyncConnectorService_GetTaskLogsServer type +type AsyncConnectorService_GetTaskLogsServer struct { + mock.Mock +} + +type AsyncConnectorService_GetTaskLogsServer_Expecter struct { + mock *mock.Mock +} + +func (_m *AsyncConnectorService_GetTaskLogsServer) EXPECT() *AsyncConnectorService_GetTaskLogsServer_Expecter { + return &AsyncConnectorService_GetTaskLogsServer_Expecter{mock: &_m.Mock} +} + +// Context provides a mock function with no fields +func (_m *AsyncConnectorService_GetTaskLogsServer) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// AsyncConnectorService_GetTaskLogsServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type AsyncConnectorService_GetTaskLogsServer_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *AsyncConnectorService_GetTaskLogsServer_Expecter) Context() *AsyncConnectorService_GetTaskLogsServer_Context_Call { + return &AsyncConnectorService_GetTaskLogsServer_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_Context_Call) Run(run func()) *AsyncConnectorService_GetTaskLogsServer_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_Context_Call) Return(_a0 context.Context) *AsyncConnectorService_GetTaskLogsServer_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_Context_Call) RunAndReturn(run func() context.Context) *AsyncConnectorService_GetTaskLogsServer_Context_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *AsyncConnectorService_GetTaskLogsServer) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AsyncConnectorService_GetTaskLogsServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type AsyncConnectorService_GetTaskLogsServer_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *AsyncConnectorService_GetTaskLogsServer_Expecter) RecvMsg(m interface{}) *AsyncConnectorService_GetTaskLogsServer_RecvMsg_Call { + return &AsyncConnectorService_GetTaskLogsServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_RecvMsg_Call) Run(run func(m any)) *AsyncConnectorService_GetTaskLogsServer_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_RecvMsg_Call) Return(_a0 error) *AsyncConnectorService_GetTaskLogsServer_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_RecvMsg_Call) RunAndReturn(run func(any) error) *AsyncConnectorService_GetTaskLogsServer_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// Send provides a mock function with given fields: _a0 +func (_m *AsyncConnectorService_GetTaskLogsServer) Send(_a0 *connector.GetTaskLogsResponse) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for Send") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*connector.GetTaskLogsResponse) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AsyncConnectorService_GetTaskLogsServer_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send' +type AsyncConnectorService_GetTaskLogsServer_Send_Call struct { + *mock.Call +} + +// Send is a helper method to define mock.On call +// - _a0 *connector.GetTaskLogsResponse +func (_e *AsyncConnectorService_GetTaskLogsServer_Expecter) Send(_a0 interface{}) *AsyncConnectorService_GetTaskLogsServer_Send_Call { + return &AsyncConnectorService_GetTaskLogsServer_Send_Call{Call: _e.mock.On("Send", _a0)} +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_Send_Call) Run(run func(_a0 *connector.GetTaskLogsResponse)) *AsyncConnectorService_GetTaskLogsServer_Send_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*connector.GetTaskLogsResponse)) + }) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_Send_Call) Return(_a0 error) *AsyncConnectorService_GetTaskLogsServer_Send_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_Send_Call) RunAndReturn(run func(*connector.GetTaskLogsResponse) error) *AsyncConnectorService_GetTaskLogsServer_Send_Call { + _c.Call.Return(run) + return _c +} + +// SendHeader provides a mock function with given fields: _a0 +func (_m *AsyncConnectorService_GetTaskLogsServer) SendHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SendHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AsyncConnectorService_GetTaskLogsServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader' +type AsyncConnectorService_GetTaskLogsServer_SendHeader_Call struct { + *mock.Call +} + +// SendHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *AsyncConnectorService_GetTaskLogsServer_Expecter) SendHeader(_a0 interface{}) *AsyncConnectorService_GetTaskLogsServer_SendHeader_Call { + return &AsyncConnectorService_GetTaskLogsServer_SendHeader_Call{Call: _e.mock.On("SendHeader", _a0)} +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *AsyncConnectorService_GetTaskLogsServer_SendHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_SendHeader_Call) Return(_a0 error) *AsyncConnectorService_GetTaskLogsServer_SendHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *AsyncConnectorService_GetTaskLogsServer_SendHeader_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *AsyncConnectorService_GetTaskLogsServer) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AsyncConnectorService_GetTaskLogsServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type AsyncConnectorService_GetTaskLogsServer_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *AsyncConnectorService_GetTaskLogsServer_Expecter) SendMsg(m interface{}) *AsyncConnectorService_GetTaskLogsServer_SendMsg_Call { + return &AsyncConnectorService_GetTaskLogsServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_SendMsg_Call) Run(run func(m any)) *AsyncConnectorService_GetTaskLogsServer_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_SendMsg_Call) Return(_a0 error) *AsyncConnectorService_GetTaskLogsServer_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_SendMsg_Call) RunAndReturn(run func(any) error) *AsyncConnectorService_GetTaskLogsServer_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// SetHeader provides a mock function with given fields: _a0 +func (_m *AsyncConnectorService_GetTaskLogsServer) SetHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SetHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AsyncConnectorService_GetTaskLogsServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader' +type AsyncConnectorService_GetTaskLogsServer_SetHeader_Call struct { + *mock.Call +} + +// SetHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *AsyncConnectorService_GetTaskLogsServer_Expecter) SetHeader(_a0 interface{}) *AsyncConnectorService_GetTaskLogsServer_SetHeader_Call { + return &AsyncConnectorService_GetTaskLogsServer_SetHeader_Call{Call: _e.mock.On("SetHeader", _a0)} +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *AsyncConnectorService_GetTaskLogsServer_SetHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_SetHeader_Call) Return(_a0 error) *AsyncConnectorService_GetTaskLogsServer_SetHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *AsyncConnectorService_GetTaskLogsServer_SetHeader_Call { + _c.Call.Return(run) + return _c +} + +// SetTrailer provides a mock function with given fields: _a0 +func (_m *AsyncConnectorService_GetTaskLogsServer) SetTrailer(_a0 metadata.MD) { + _m.Called(_a0) +} + +// AsyncConnectorService_GetTaskLogsServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer' +type AsyncConnectorService_GetTaskLogsServer_SetTrailer_Call struct { + *mock.Call +} + +// SetTrailer is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *AsyncConnectorService_GetTaskLogsServer_Expecter) SetTrailer(_a0 interface{}) *AsyncConnectorService_GetTaskLogsServer_SetTrailer_Call { + return &AsyncConnectorService_GetTaskLogsServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", _a0)} +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *AsyncConnectorService_GetTaskLogsServer_SetTrailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_SetTrailer_Call) Return() *AsyncConnectorService_GetTaskLogsServer_SetTrailer_Call { + _c.Call.Return() + return _c +} + +func (_c *AsyncConnectorService_GetTaskLogsServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *AsyncConnectorService_GetTaskLogsServer_SetTrailer_Call { + _c.Run(run) + return _c +} + +// NewAsyncConnectorService_GetTaskLogsServer creates a new instance of AsyncConnectorService_GetTaskLogsServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAsyncConnectorService_GetTaskLogsServer(t interface { + mock.TestingT + Cleanup(func()) +}) *AsyncConnectorService_GetTaskLogsServer { + mock := &AsyncConnectorService_GetTaskLogsServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/connector/mocks/async_connector_service_server.go b/gen/go/flyteidl2/connector/mocks/async_connector_service_server.go new file mode 100644 index 0000000000..3d9029d581 --- /dev/null +++ b/gen/go/flyteidl2/connector/mocks/async_connector_service_server.go @@ -0,0 +1,321 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + connector "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector" + + mock "github.com/stretchr/testify/mock" +) + +// AsyncConnectorServiceServer is an autogenerated mock type for the AsyncConnectorServiceServer type +type AsyncConnectorServiceServer struct { + mock.Mock +} + +type AsyncConnectorServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *AsyncConnectorServiceServer) EXPECT() *AsyncConnectorServiceServer_Expecter { + return &AsyncConnectorServiceServer_Expecter{mock: &_m.Mock} +} + +// CreateTask provides a mock function with given fields: _a0, _a1 +func (_m *AsyncConnectorServiceServer) CreateTask(_a0 context.Context, _a1 *connector.CreateTaskRequest) (*connector.CreateTaskResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for CreateTask") + } + + var r0 *connector.CreateTaskResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connector.CreateTaskRequest) (*connector.CreateTaskResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connector.CreateTaskRequest) *connector.CreateTaskResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connector.CreateTaskResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connector.CreateTaskRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AsyncConnectorServiceServer_CreateTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTask' +type AsyncConnectorServiceServer_CreateTask_Call struct { + *mock.Call +} + +// CreateTask is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connector.CreateTaskRequest +func (_e *AsyncConnectorServiceServer_Expecter) CreateTask(_a0 interface{}, _a1 interface{}) *AsyncConnectorServiceServer_CreateTask_Call { + return &AsyncConnectorServiceServer_CreateTask_Call{Call: _e.mock.On("CreateTask", _a0, _a1)} +} + +func (_c *AsyncConnectorServiceServer_CreateTask_Call) Run(run func(_a0 context.Context, _a1 *connector.CreateTaskRequest)) *AsyncConnectorServiceServer_CreateTask_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connector.CreateTaskRequest)) + }) + return _c +} + +func (_c *AsyncConnectorServiceServer_CreateTask_Call) Return(_a0 *connector.CreateTaskResponse, _a1 error) *AsyncConnectorServiceServer_CreateTask_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AsyncConnectorServiceServer_CreateTask_Call) RunAndReturn(run func(context.Context, *connector.CreateTaskRequest) (*connector.CreateTaskResponse, error)) *AsyncConnectorServiceServer_CreateTask_Call { + _c.Call.Return(run) + return _c +} + +// DeleteTask provides a mock function with given fields: _a0, _a1 +func (_m *AsyncConnectorServiceServer) DeleteTask(_a0 context.Context, _a1 *connector.DeleteTaskRequest) (*connector.DeleteTaskResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for DeleteTask") + } + + var r0 *connector.DeleteTaskResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connector.DeleteTaskRequest) (*connector.DeleteTaskResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connector.DeleteTaskRequest) *connector.DeleteTaskResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connector.DeleteTaskResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connector.DeleteTaskRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AsyncConnectorServiceServer_DeleteTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTask' +type AsyncConnectorServiceServer_DeleteTask_Call struct { + *mock.Call +} + +// DeleteTask is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connector.DeleteTaskRequest +func (_e *AsyncConnectorServiceServer_Expecter) DeleteTask(_a0 interface{}, _a1 interface{}) *AsyncConnectorServiceServer_DeleteTask_Call { + return &AsyncConnectorServiceServer_DeleteTask_Call{Call: _e.mock.On("DeleteTask", _a0, _a1)} +} + +func (_c *AsyncConnectorServiceServer_DeleteTask_Call) Run(run func(_a0 context.Context, _a1 *connector.DeleteTaskRequest)) *AsyncConnectorServiceServer_DeleteTask_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connector.DeleteTaskRequest)) + }) + return _c +} + +func (_c *AsyncConnectorServiceServer_DeleteTask_Call) Return(_a0 *connector.DeleteTaskResponse, _a1 error) *AsyncConnectorServiceServer_DeleteTask_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AsyncConnectorServiceServer_DeleteTask_Call) RunAndReturn(run func(context.Context, *connector.DeleteTaskRequest) (*connector.DeleteTaskResponse, error)) *AsyncConnectorServiceServer_DeleteTask_Call { + _c.Call.Return(run) + return _c +} + +// GetTask provides a mock function with given fields: _a0, _a1 +func (_m *AsyncConnectorServiceServer) GetTask(_a0 context.Context, _a1 *connector.GetTaskRequest) (*connector.GetTaskResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetTask") + } + + var r0 *connector.GetTaskResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connector.GetTaskRequest) (*connector.GetTaskResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connector.GetTaskRequest) *connector.GetTaskResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connector.GetTaskResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connector.GetTaskRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AsyncConnectorServiceServer_GetTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTask' +type AsyncConnectorServiceServer_GetTask_Call struct { + *mock.Call +} + +// GetTask is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connector.GetTaskRequest +func (_e *AsyncConnectorServiceServer_Expecter) GetTask(_a0 interface{}, _a1 interface{}) *AsyncConnectorServiceServer_GetTask_Call { + return &AsyncConnectorServiceServer_GetTask_Call{Call: _e.mock.On("GetTask", _a0, _a1)} +} + +func (_c *AsyncConnectorServiceServer_GetTask_Call) Run(run func(_a0 context.Context, _a1 *connector.GetTaskRequest)) *AsyncConnectorServiceServer_GetTask_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connector.GetTaskRequest)) + }) + return _c +} + +func (_c *AsyncConnectorServiceServer_GetTask_Call) Return(_a0 *connector.GetTaskResponse, _a1 error) *AsyncConnectorServiceServer_GetTask_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AsyncConnectorServiceServer_GetTask_Call) RunAndReturn(run func(context.Context, *connector.GetTaskRequest) (*connector.GetTaskResponse, error)) *AsyncConnectorServiceServer_GetTask_Call { + _c.Call.Return(run) + return _c +} + +// GetTaskLogs provides a mock function with given fields: _a0, _a1 +func (_m *AsyncConnectorServiceServer) GetTaskLogs(_a0 *connector.GetTaskLogsRequest, _a1 connector.AsyncConnectorService_GetTaskLogsServer) error { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetTaskLogs") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*connector.GetTaskLogsRequest, connector.AsyncConnectorService_GetTaskLogsServer) error); ok { + r0 = rf(_a0, _a1) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AsyncConnectorServiceServer_GetTaskLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTaskLogs' +type AsyncConnectorServiceServer_GetTaskLogs_Call struct { + *mock.Call +} + +// GetTaskLogs is a helper method to define mock.On call +// - _a0 *connector.GetTaskLogsRequest +// - _a1 connector.AsyncConnectorService_GetTaskLogsServer +func (_e *AsyncConnectorServiceServer_Expecter) GetTaskLogs(_a0 interface{}, _a1 interface{}) *AsyncConnectorServiceServer_GetTaskLogs_Call { + return &AsyncConnectorServiceServer_GetTaskLogs_Call{Call: _e.mock.On("GetTaskLogs", _a0, _a1)} +} + +func (_c *AsyncConnectorServiceServer_GetTaskLogs_Call) Run(run func(_a0 *connector.GetTaskLogsRequest, _a1 connector.AsyncConnectorService_GetTaskLogsServer)) *AsyncConnectorServiceServer_GetTaskLogs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*connector.GetTaskLogsRequest), args[1].(connector.AsyncConnectorService_GetTaskLogsServer)) + }) + return _c +} + +func (_c *AsyncConnectorServiceServer_GetTaskLogs_Call) Return(_a0 error) *AsyncConnectorServiceServer_GetTaskLogs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AsyncConnectorServiceServer_GetTaskLogs_Call) RunAndReturn(run func(*connector.GetTaskLogsRequest, connector.AsyncConnectorService_GetTaskLogsServer) error) *AsyncConnectorServiceServer_GetTaskLogs_Call { + _c.Call.Return(run) + return _c +} + +// GetTaskMetrics provides a mock function with given fields: _a0, _a1 +func (_m *AsyncConnectorServiceServer) GetTaskMetrics(_a0 context.Context, _a1 *connector.GetTaskMetricsRequest) (*connector.GetTaskMetricsResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetTaskMetrics") + } + + var r0 *connector.GetTaskMetricsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connector.GetTaskMetricsRequest) (*connector.GetTaskMetricsResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connector.GetTaskMetricsRequest) *connector.GetTaskMetricsResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connector.GetTaskMetricsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connector.GetTaskMetricsRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AsyncConnectorServiceServer_GetTaskMetrics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTaskMetrics' +type AsyncConnectorServiceServer_GetTaskMetrics_Call struct { + *mock.Call +} + +// GetTaskMetrics is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connector.GetTaskMetricsRequest +func (_e *AsyncConnectorServiceServer_Expecter) GetTaskMetrics(_a0 interface{}, _a1 interface{}) *AsyncConnectorServiceServer_GetTaskMetrics_Call { + return &AsyncConnectorServiceServer_GetTaskMetrics_Call{Call: _e.mock.On("GetTaskMetrics", _a0, _a1)} +} + +func (_c *AsyncConnectorServiceServer_GetTaskMetrics_Call) Run(run func(_a0 context.Context, _a1 *connector.GetTaskMetricsRequest)) *AsyncConnectorServiceServer_GetTaskMetrics_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connector.GetTaskMetricsRequest)) + }) + return _c +} + +func (_c *AsyncConnectorServiceServer_GetTaskMetrics_Call) Return(_a0 *connector.GetTaskMetricsResponse, _a1 error) *AsyncConnectorServiceServer_GetTaskMetrics_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AsyncConnectorServiceServer_GetTaskMetrics_Call) RunAndReturn(run func(context.Context, *connector.GetTaskMetricsRequest) (*connector.GetTaskMetricsResponse, error)) *AsyncConnectorServiceServer_GetTaskMetrics_Call { + _c.Call.Return(run) + return _c +} + +// NewAsyncConnectorServiceServer creates a new instance of AsyncConnectorServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAsyncConnectorServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *AsyncConnectorServiceServer { + mock := &AsyncConnectorServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/connector/mocks/connector_metadata_service_client.go b/gen/go/flyteidl2/connector/mocks/connector_metadata_service_client.go new file mode 100644 index 0000000000..fd02129bcc --- /dev/null +++ b/gen/go/flyteidl2/connector/mocks/connector_metadata_service_client.go @@ -0,0 +1,188 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + connector "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector" + + grpc "google.golang.org/grpc" + + mock "github.com/stretchr/testify/mock" +) + +// ConnectorMetadataServiceClient is an autogenerated mock type for the ConnectorMetadataServiceClient type +type ConnectorMetadataServiceClient struct { + mock.Mock +} + +type ConnectorMetadataServiceClient_Expecter struct { + mock *mock.Mock +} + +func (_m *ConnectorMetadataServiceClient) EXPECT() *ConnectorMetadataServiceClient_Expecter { + return &ConnectorMetadataServiceClient_Expecter{mock: &_m.Mock} +} + +// GetConnector provides a mock function with given fields: ctx, in, opts +func (_m *ConnectorMetadataServiceClient) GetConnector(ctx context.Context, in *connector.GetConnectorRequest, opts ...grpc.CallOption) (*connector.GetConnectorResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetConnector") + } + + var r0 *connector.GetConnectorResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connector.GetConnectorRequest, ...grpc.CallOption) (*connector.GetConnectorResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *connector.GetConnectorRequest, ...grpc.CallOption) *connector.GetConnectorResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connector.GetConnectorResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connector.GetConnectorRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ConnectorMetadataServiceClient_GetConnector_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConnector' +type ConnectorMetadataServiceClient_GetConnector_Call struct { + *mock.Call +} + +// GetConnector is a helper method to define mock.On call +// - ctx context.Context +// - in *connector.GetConnectorRequest +// - opts ...grpc.CallOption +func (_e *ConnectorMetadataServiceClient_Expecter) GetConnector(ctx interface{}, in interface{}, opts ...interface{}) *ConnectorMetadataServiceClient_GetConnector_Call { + return &ConnectorMetadataServiceClient_GetConnector_Call{Call: _e.mock.On("GetConnector", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *ConnectorMetadataServiceClient_GetConnector_Call) Run(run func(ctx context.Context, in *connector.GetConnectorRequest, opts ...grpc.CallOption)) *ConnectorMetadataServiceClient_GetConnector_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*connector.GetConnectorRequest), variadicArgs...) + }) + return _c +} + +func (_c *ConnectorMetadataServiceClient_GetConnector_Call) Return(_a0 *connector.GetConnectorResponse, _a1 error) *ConnectorMetadataServiceClient_GetConnector_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ConnectorMetadataServiceClient_GetConnector_Call) RunAndReturn(run func(context.Context, *connector.GetConnectorRequest, ...grpc.CallOption) (*connector.GetConnectorResponse, error)) *ConnectorMetadataServiceClient_GetConnector_Call { + _c.Call.Return(run) + return _c +} + +// ListConnectors provides a mock function with given fields: ctx, in, opts +func (_m *ConnectorMetadataServiceClient) ListConnectors(ctx context.Context, in *connector.ListConnectorsRequest, opts ...grpc.CallOption) (*connector.ListConnectorsResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListConnectors") + } + + var r0 *connector.ListConnectorsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connector.ListConnectorsRequest, ...grpc.CallOption) (*connector.ListConnectorsResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *connector.ListConnectorsRequest, ...grpc.CallOption) *connector.ListConnectorsResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connector.ListConnectorsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connector.ListConnectorsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ConnectorMetadataServiceClient_ListConnectors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListConnectors' +type ConnectorMetadataServiceClient_ListConnectors_Call struct { + *mock.Call +} + +// ListConnectors is a helper method to define mock.On call +// - ctx context.Context +// - in *connector.ListConnectorsRequest +// - opts ...grpc.CallOption +func (_e *ConnectorMetadataServiceClient_Expecter) ListConnectors(ctx interface{}, in interface{}, opts ...interface{}) *ConnectorMetadataServiceClient_ListConnectors_Call { + return &ConnectorMetadataServiceClient_ListConnectors_Call{Call: _e.mock.On("ListConnectors", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *ConnectorMetadataServiceClient_ListConnectors_Call) Run(run func(ctx context.Context, in *connector.ListConnectorsRequest, opts ...grpc.CallOption)) *ConnectorMetadataServiceClient_ListConnectors_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*connector.ListConnectorsRequest), variadicArgs...) + }) + return _c +} + +func (_c *ConnectorMetadataServiceClient_ListConnectors_Call) Return(_a0 *connector.ListConnectorsResponse, _a1 error) *ConnectorMetadataServiceClient_ListConnectors_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ConnectorMetadataServiceClient_ListConnectors_Call) RunAndReturn(run func(context.Context, *connector.ListConnectorsRequest, ...grpc.CallOption) (*connector.ListConnectorsResponse, error)) *ConnectorMetadataServiceClient_ListConnectors_Call { + _c.Call.Return(run) + return _c +} + +// NewConnectorMetadataServiceClient creates a new instance of ConnectorMetadataServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewConnectorMetadataServiceClient(t interface { + mock.TestingT + Cleanup(func()) +}) *ConnectorMetadataServiceClient { + mock := &ConnectorMetadataServiceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/connector/mocks/connector_metadata_service_server.go b/gen/go/flyteidl2/connector/mocks/connector_metadata_service_server.go new file mode 100644 index 0000000000..09cccc38a8 --- /dev/null +++ b/gen/go/flyteidl2/connector/mocks/connector_metadata_service_server.go @@ -0,0 +1,156 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + connector "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector" + + mock "github.com/stretchr/testify/mock" +) + +// ConnectorMetadataServiceServer is an autogenerated mock type for the ConnectorMetadataServiceServer type +type ConnectorMetadataServiceServer struct { + mock.Mock +} + +type ConnectorMetadataServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *ConnectorMetadataServiceServer) EXPECT() *ConnectorMetadataServiceServer_Expecter { + return &ConnectorMetadataServiceServer_Expecter{mock: &_m.Mock} +} + +// GetConnector provides a mock function with given fields: _a0, _a1 +func (_m *ConnectorMetadataServiceServer) GetConnector(_a0 context.Context, _a1 *connector.GetConnectorRequest) (*connector.GetConnectorResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetConnector") + } + + var r0 *connector.GetConnectorResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connector.GetConnectorRequest) (*connector.GetConnectorResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connector.GetConnectorRequest) *connector.GetConnectorResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connector.GetConnectorResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connector.GetConnectorRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ConnectorMetadataServiceServer_GetConnector_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConnector' +type ConnectorMetadataServiceServer_GetConnector_Call struct { + *mock.Call +} + +// GetConnector is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connector.GetConnectorRequest +func (_e *ConnectorMetadataServiceServer_Expecter) GetConnector(_a0 interface{}, _a1 interface{}) *ConnectorMetadataServiceServer_GetConnector_Call { + return &ConnectorMetadataServiceServer_GetConnector_Call{Call: _e.mock.On("GetConnector", _a0, _a1)} +} + +func (_c *ConnectorMetadataServiceServer_GetConnector_Call) Run(run func(_a0 context.Context, _a1 *connector.GetConnectorRequest)) *ConnectorMetadataServiceServer_GetConnector_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connector.GetConnectorRequest)) + }) + return _c +} + +func (_c *ConnectorMetadataServiceServer_GetConnector_Call) Return(_a0 *connector.GetConnectorResponse, _a1 error) *ConnectorMetadataServiceServer_GetConnector_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ConnectorMetadataServiceServer_GetConnector_Call) RunAndReturn(run func(context.Context, *connector.GetConnectorRequest) (*connector.GetConnectorResponse, error)) *ConnectorMetadataServiceServer_GetConnector_Call { + _c.Call.Return(run) + return _c +} + +// ListConnectors provides a mock function with given fields: _a0, _a1 +func (_m *ConnectorMetadataServiceServer) ListConnectors(_a0 context.Context, _a1 *connector.ListConnectorsRequest) (*connector.ListConnectorsResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for ListConnectors") + } + + var r0 *connector.ListConnectorsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connector.ListConnectorsRequest) (*connector.ListConnectorsResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connector.ListConnectorsRequest) *connector.ListConnectorsResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connector.ListConnectorsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connector.ListConnectorsRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ConnectorMetadataServiceServer_ListConnectors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListConnectors' +type ConnectorMetadataServiceServer_ListConnectors_Call struct { + *mock.Call +} + +// ListConnectors is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connector.ListConnectorsRequest +func (_e *ConnectorMetadataServiceServer_Expecter) ListConnectors(_a0 interface{}, _a1 interface{}) *ConnectorMetadataServiceServer_ListConnectors_Call { + return &ConnectorMetadataServiceServer_ListConnectors_Call{Call: _e.mock.On("ListConnectors", _a0, _a1)} +} + +func (_c *ConnectorMetadataServiceServer_ListConnectors_Call) Run(run func(_a0 context.Context, _a1 *connector.ListConnectorsRequest)) *ConnectorMetadataServiceServer_ListConnectors_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connector.ListConnectorsRequest)) + }) + return _c +} + +func (_c *ConnectorMetadataServiceServer_ListConnectors_Call) Return(_a0 *connector.ListConnectorsResponse, _a1 error) *ConnectorMetadataServiceServer_ListConnectors_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ConnectorMetadataServiceServer_ListConnectors_Call) RunAndReturn(run func(context.Context, *connector.ListConnectorsRequest) (*connector.ListConnectorsResponse, error)) *ConnectorMetadataServiceServer_ListConnectors_Call { + _c.Call.Return(run) + return _c +} + +// NewConnectorMetadataServiceServer creates a new instance of ConnectorMetadataServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewConnectorMetadataServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *ConnectorMetadataServiceServer { + mock := &ConnectorMetadataServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/connector/mocks/is_get_task_logs_response_part.go b/gen/go/flyteidl2/connector/mocks/is_get_task_logs_response_part.go new file mode 100644 index 0000000000..7f4f4fdd09 --- /dev/null +++ b/gen/go/flyteidl2/connector/mocks/is_get_task_logs_response_part.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isGetTaskLogsResponse_Part is an autogenerated mock type for the isGetTaskLogsResponse_Part type +type isGetTaskLogsResponse_Part struct { + mock.Mock +} + +type isGetTaskLogsResponse_Part_Expecter struct { + mock *mock.Mock +} + +func (_m *isGetTaskLogsResponse_Part) EXPECT() *isGetTaskLogsResponse_Part_Expecter { + return &isGetTaskLogsResponse_Part_Expecter{mock: &_m.Mock} +} + +// isGetTaskLogsResponse_Part provides a mock function with no fields +func (_m *isGetTaskLogsResponse_Part) isGetTaskLogsResponse_Part() { + _m.Called() +} + +// isGetTaskLogsResponse_Part_isGetTaskLogsResponse_Part_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isGetTaskLogsResponse_Part' +type isGetTaskLogsResponse_Part_isGetTaskLogsResponse_Part_Call struct { + *mock.Call +} + +// isGetTaskLogsResponse_Part is a helper method to define mock.On call +func (_e *isGetTaskLogsResponse_Part_Expecter) isGetTaskLogsResponse_Part() *isGetTaskLogsResponse_Part_isGetTaskLogsResponse_Part_Call { + return &isGetTaskLogsResponse_Part_isGetTaskLogsResponse_Part_Call{Call: _e.mock.On("isGetTaskLogsResponse_Part")} +} + +func (_c *isGetTaskLogsResponse_Part_isGetTaskLogsResponse_Part_Call) Run(run func()) *isGetTaskLogsResponse_Part_isGetTaskLogsResponse_Part_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isGetTaskLogsResponse_Part_isGetTaskLogsResponse_Part_Call) Return() *isGetTaskLogsResponse_Part_isGetTaskLogsResponse_Part_Call { + _c.Call.Return() + return _c +} + +func (_c *isGetTaskLogsResponse_Part_isGetTaskLogsResponse_Part_Call) RunAndReturn(run func()) *isGetTaskLogsResponse_Part_isGetTaskLogsResponse_Part_Call { + _c.Run(run) + return _c +} + +// newIsGetTaskLogsResponse_Part creates a new instance of isGetTaskLogsResponse_Part. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsGetTaskLogsResponse_Part(t interface { + mock.TestingT + Cleanup(func()) +}) *isGetTaskLogsResponse_Part { + mock := &isGetTaskLogsResponse_Part{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/connector/mocks/unsafe_async_connector_service_server.go b/gen/go/flyteidl2/connector/mocks/unsafe_async_connector_service_server.go new file mode 100644 index 0000000000..9c8455d3b9 --- /dev/null +++ b/gen/go/flyteidl2/connector/mocks/unsafe_async_connector_service_server.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// UnsafeAsyncConnectorServiceServer is an autogenerated mock type for the UnsafeAsyncConnectorServiceServer type +type UnsafeAsyncConnectorServiceServer struct { + mock.Mock +} + +type UnsafeAsyncConnectorServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *UnsafeAsyncConnectorServiceServer) EXPECT() *UnsafeAsyncConnectorServiceServer_Expecter { + return &UnsafeAsyncConnectorServiceServer_Expecter{mock: &_m.Mock} +} + +// mustEmbedUnimplementedAsyncConnectorServiceServer provides a mock function with no fields +func (_m *UnsafeAsyncConnectorServiceServer) mustEmbedUnimplementedAsyncConnectorServiceServer() { + _m.Called() +} + +// UnsafeAsyncConnectorServiceServer_mustEmbedUnimplementedAsyncConnectorServiceServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'mustEmbedUnimplementedAsyncConnectorServiceServer' +type UnsafeAsyncConnectorServiceServer_mustEmbedUnimplementedAsyncConnectorServiceServer_Call struct { + *mock.Call +} + +// mustEmbedUnimplementedAsyncConnectorServiceServer is a helper method to define mock.On call +func (_e *UnsafeAsyncConnectorServiceServer_Expecter) mustEmbedUnimplementedAsyncConnectorServiceServer() *UnsafeAsyncConnectorServiceServer_mustEmbedUnimplementedAsyncConnectorServiceServer_Call { + return &UnsafeAsyncConnectorServiceServer_mustEmbedUnimplementedAsyncConnectorServiceServer_Call{Call: _e.mock.On("mustEmbedUnimplementedAsyncConnectorServiceServer")} +} + +func (_c *UnsafeAsyncConnectorServiceServer_mustEmbedUnimplementedAsyncConnectorServiceServer_Call) Run(run func()) *UnsafeAsyncConnectorServiceServer_mustEmbedUnimplementedAsyncConnectorServiceServer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UnsafeAsyncConnectorServiceServer_mustEmbedUnimplementedAsyncConnectorServiceServer_Call) Return() *UnsafeAsyncConnectorServiceServer_mustEmbedUnimplementedAsyncConnectorServiceServer_Call { + _c.Call.Return() + return _c +} + +func (_c *UnsafeAsyncConnectorServiceServer_mustEmbedUnimplementedAsyncConnectorServiceServer_Call) RunAndReturn(run func()) *UnsafeAsyncConnectorServiceServer_mustEmbedUnimplementedAsyncConnectorServiceServer_Call { + _c.Run(run) + return _c +} + +// NewUnsafeAsyncConnectorServiceServer creates a new instance of UnsafeAsyncConnectorServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewUnsafeAsyncConnectorServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *UnsafeAsyncConnectorServiceServer { + mock := &UnsafeAsyncConnectorServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/connector/mocks/unsafe_connector_metadata_service_server.go b/gen/go/flyteidl2/connector/mocks/unsafe_connector_metadata_service_server.go new file mode 100644 index 0000000000..6126de237c --- /dev/null +++ b/gen/go/flyteidl2/connector/mocks/unsafe_connector_metadata_service_server.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// UnsafeConnectorMetadataServiceServer is an autogenerated mock type for the UnsafeConnectorMetadataServiceServer type +type UnsafeConnectorMetadataServiceServer struct { + mock.Mock +} + +type UnsafeConnectorMetadataServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *UnsafeConnectorMetadataServiceServer) EXPECT() *UnsafeConnectorMetadataServiceServer_Expecter { + return &UnsafeConnectorMetadataServiceServer_Expecter{mock: &_m.Mock} +} + +// mustEmbedUnimplementedConnectorMetadataServiceServer provides a mock function with no fields +func (_m *UnsafeConnectorMetadataServiceServer) mustEmbedUnimplementedConnectorMetadataServiceServer() { + _m.Called() +} + +// UnsafeConnectorMetadataServiceServer_mustEmbedUnimplementedConnectorMetadataServiceServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'mustEmbedUnimplementedConnectorMetadataServiceServer' +type UnsafeConnectorMetadataServiceServer_mustEmbedUnimplementedConnectorMetadataServiceServer_Call struct { + *mock.Call +} + +// mustEmbedUnimplementedConnectorMetadataServiceServer is a helper method to define mock.On call +func (_e *UnsafeConnectorMetadataServiceServer_Expecter) mustEmbedUnimplementedConnectorMetadataServiceServer() *UnsafeConnectorMetadataServiceServer_mustEmbedUnimplementedConnectorMetadataServiceServer_Call { + return &UnsafeConnectorMetadataServiceServer_mustEmbedUnimplementedConnectorMetadataServiceServer_Call{Call: _e.mock.On("mustEmbedUnimplementedConnectorMetadataServiceServer")} +} + +func (_c *UnsafeConnectorMetadataServiceServer_mustEmbedUnimplementedConnectorMetadataServiceServer_Call) Run(run func()) *UnsafeConnectorMetadataServiceServer_mustEmbedUnimplementedConnectorMetadataServiceServer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UnsafeConnectorMetadataServiceServer_mustEmbedUnimplementedConnectorMetadataServiceServer_Call) Return() *UnsafeConnectorMetadataServiceServer_mustEmbedUnimplementedConnectorMetadataServiceServer_Call { + _c.Call.Return() + return _c +} + +func (_c *UnsafeConnectorMetadataServiceServer_mustEmbedUnimplementedConnectorMetadataServiceServer_Call) RunAndReturn(run func()) *UnsafeConnectorMetadataServiceServer_mustEmbedUnimplementedConnectorMetadataServiceServer_Call { + _c.Run(run) + return _c +} + +// NewUnsafeConnectorMetadataServiceServer creates a new instance of UnsafeConnectorMetadataServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewUnsafeConnectorMetadataServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *UnsafeConnectorMetadataServiceServer { + mock := &UnsafeConnectorMetadataServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/connector/service.pb.go b/gen/go/flyteidl2/connector/service.pb.go new file mode 100644 index 0000000000..e5168e85cd --- /dev/null +++ b/gen/go/flyteidl2/connector/service.pb.go @@ -0,0 +1,189 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/connector/service.proto + +package connector + +import ( + _ "google.golang.org/genproto/googleapis/api/annotations" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +var File_flyteidl2_connector_service_proto protoreflect.FileDescriptor + +var file_flyteidl2_connector_service_proto_rawDesc = []byte{ + 0x0a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x13, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x1a, 0x23, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2f, 0x63, 0x6f, + 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0xae, 0x07, 0x0a, 0x15, + 0x41, 0x73, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x53, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x80, 0x01, 0x0a, 0x0a, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x54, 0x61, 0x73, 0x6b, 0x12, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, + 0x6f, 0x72, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1b, 0x3a, 0x01, 0x2a, + 0x22, 0x16, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x12, 0xb1, 0x01, 0x0a, 0x07, 0x47, 0x65, 0x74, + 0x54, 0x61, 0x73, 0x6b, 0x12, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x61, + 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, + 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x5b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x55, 0x12, 0x53, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, + 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, + 0x7b, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x2e, 0x6e, + 0x61, 0x6d, 0x65, 0x7d, 0x2f, 0x7b, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, + 0x6f, 0x72, 0x79, 0x2e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x7d, 0x2f, 0x7b, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x7d, 0x12, 0xc5, 0x01, 0x0a, + 0x0a, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x26, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x66, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x60, 0x2a, 0x5e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, + 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x7b, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, + 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x2f, 0x7b, 0x74, 0x61, + 0x73, 0x6b, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x2e, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x7d, 0x2f, 0x7b, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, + 0x65, 0x74, 0x61, 0x7d, 0x12, 0xce, 0x01, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, + 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x2a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x47, 0x65, + 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, + 0x6b, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x63, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x5d, 0x12, 0x5b, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, + 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2f, 0x74, 0x61, 0x73, 0x6b, + 0x2f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x2f, 0x7b, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, + 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x2f, 0x7b, 0x74, + 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x2e, 0x76, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x7d, 0x2f, 0x7b, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, + 0x6d, 0x65, 0x74, 0x61, 0x7d, 0x12, 0xc4, 0x01, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, + 0x6b, 0x4c, 0x6f, 0x67, 0x73, 0x12, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, + 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x60, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x5a, + 0x12, 0x58, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x6c, 0x6f, 0x67, 0x73, 0x2f, 0x7b, 0x74, + 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x2e, 0x6e, 0x61, 0x6d, + 0x65, 0x7d, 0x2f, 0x7b, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, + 0x79, 0x2e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x7d, 0x2f, 0x7b, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x7d, 0x30, 0x01, 0x32, 0xaa, 0x02, 0x0a, + 0x18, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x85, 0x01, 0x0a, 0x0c, 0x47, 0x65, + 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x28, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, + 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, + 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, + 0x7d, 0x12, 0x85, 0x01, 0x0a, 0x0e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x73, 0x12, 0x2a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x12, 0x12, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x63, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x42, 0xcf, 0x01, 0x0a, 0x17, 0x63, 0x6f, + 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x6f, 0x72, 0x42, 0x0c, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x37, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x13, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0xca, 0x02, 0x13, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, + 0x6f, 0x72, 0xe2, 0x02, 0x1f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x3a, 0x3a, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, +} + +var file_flyteidl2_connector_service_proto_goTypes = []interface{}{ + (*CreateTaskRequest)(nil), // 0: flyteidl2.connector.CreateTaskRequest + (*GetTaskRequest)(nil), // 1: flyteidl2.connector.GetTaskRequest + (*DeleteTaskRequest)(nil), // 2: flyteidl2.connector.DeleteTaskRequest + (*GetTaskMetricsRequest)(nil), // 3: flyteidl2.connector.GetTaskMetricsRequest + (*GetTaskLogsRequest)(nil), // 4: flyteidl2.connector.GetTaskLogsRequest + (*GetConnectorRequest)(nil), // 5: flyteidl2.connector.GetConnectorRequest + (*ListConnectorsRequest)(nil), // 6: flyteidl2.connector.ListConnectorsRequest + (*CreateTaskResponse)(nil), // 7: flyteidl2.connector.CreateTaskResponse + (*GetTaskResponse)(nil), // 8: flyteidl2.connector.GetTaskResponse + (*DeleteTaskResponse)(nil), // 9: flyteidl2.connector.DeleteTaskResponse + (*GetTaskMetricsResponse)(nil), // 10: flyteidl2.connector.GetTaskMetricsResponse + (*GetTaskLogsResponse)(nil), // 11: flyteidl2.connector.GetTaskLogsResponse + (*GetConnectorResponse)(nil), // 12: flyteidl2.connector.GetConnectorResponse + (*ListConnectorsResponse)(nil), // 13: flyteidl2.connector.ListConnectorsResponse +} +var file_flyteidl2_connector_service_proto_depIdxs = []int32{ + 0, // 0: flyteidl2.connector.AsyncConnectorService.CreateTask:input_type -> flyteidl2.connector.CreateTaskRequest + 1, // 1: flyteidl2.connector.AsyncConnectorService.GetTask:input_type -> flyteidl2.connector.GetTaskRequest + 2, // 2: flyteidl2.connector.AsyncConnectorService.DeleteTask:input_type -> flyteidl2.connector.DeleteTaskRequest + 3, // 3: flyteidl2.connector.AsyncConnectorService.GetTaskMetrics:input_type -> flyteidl2.connector.GetTaskMetricsRequest + 4, // 4: flyteidl2.connector.AsyncConnectorService.GetTaskLogs:input_type -> flyteidl2.connector.GetTaskLogsRequest + 5, // 5: flyteidl2.connector.ConnectorMetadataService.GetConnector:input_type -> flyteidl2.connector.GetConnectorRequest + 6, // 6: flyteidl2.connector.ConnectorMetadataService.ListConnectors:input_type -> flyteidl2.connector.ListConnectorsRequest + 7, // 7: flyteidl2.connector.AsyncConnectorService.CreateTask:output_type -> flyteidl2.connector.CreateTaskResponse + 8, // 8: flyteidl2.connector.AsyncConnectorService.GetTask:output_type -> flyteidl2.connector.GetTaskResponse + 9, // 9: flyteidl2.connector.AsyncConnectorService.DeleteTask:output_type -> flyteidl2.connector.DeleteTaskResponse + 10, // 10: flyteidl2.connector.AsyncConnectorService.GetTaskMetrics:output_type -> flyteidl2.connector.GetTaskMetricsResponse + 11, // 11: flyteidl2.connector.AsyncConnectorService.GetTaskLogs:output_type -> flyteidl2.connector.GetTaskLogsResponse + 12, // 12: flyteidl2.connector.ConnectorMetadataService.GetConnector:output_type -> flyteidl2.connector.GetConnectorResponse + 13, // 13: flyteidl2.connector.ConnectorMetadataService.ListConnectors:output_type -> flyteidl2.connector.ListConnectorsResponse + 7, // [7:14] is the sub-list for method output_type + 0, // [0:7] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_flyteidl2_connector_service_proto_init() } +func file_flyteidl2_connector_service_proto_init() { + if File_flyteidl2_connector_service_proto != nil { + return + } + file_flyteidl2_connector_connector_proto_init() + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_connector_service_proto_rawDesc, + NumEnums: 0, + NumMessages: 0, + NumExtensions: 0, + NumServices: 2, + }, + GoTypes: file_flyteidl2_connector_service_proto_goTypes, + DependencyIndexes: file_flyteidl2_connector_service_proto_depIdxs, + }.Build() + File_flyteidl2_connector_service_proto = out.File + file_flyteidl2_connector_service_proto_rawDesc = nil + file_flyteidl2_connector_service_proto_goTypes = nil + file_flyteidl2_connector_service_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/connector/service.pb.validate.go b/gen/go/flyteidl2/connector/service.pb.validate.go new file mode 100644 index 0000000000..273a0257ff --- /dev/null +++ b/gen/go/flyteidl2/connector/service.pb.validate.go @@ -0,0 +1,36 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/connector/service.proto + +package connector + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) diff --git a/gen/go/flyteidl2/connector/service_grpc.pb.go b/gen/go/flyteidl2/connector/service_grpc.pb.go new file mode 100644 index 0000000000..e950135d71 --- /dev/null +++ b/gen/go/flyteidl2/connector/service_grpc.pb.go @@ -0,0 +1,430 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: flyteidl2/connector/service.proto + +package connector + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + AsyncConnectorService_CreateTask_FullMethodName = "/flyteidl2.connector.AsyncConnectorService/CreateTask" + AsyncConnectorService_GetTask_FullMethodName = "/flyteidl2.connector.AsyncConnectorService/GetTask" + AsyncConnectorService_DeleteTask_FullMethodName = "/flyteidl2.connector.AsyncConnectorService/DeleteTask" + AsyncConnectorService_GetTaskMetrics_FullMethodName = "/flyteidl2.connector.AsyncConnectorService/GetTaskMetrics" + AsyncConnectorService_GetTaskLogs_FullMethodName = "/flyteidl2.connector.AsyncConnectorService/GetTaskLogs" +) + +// AsyncConnectorServiceClient is the client API for AsyncConnectorService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type AsyncConnectorServiceClient interface { + // CreateTask sends a task create request to the connector service. + CreateTask(ctx context.Context, in *CreateTaskRequest, opts ...grpc.CallOption) (*CreateTaskResponse, error) + // Get job status. + GetTask(ctx context.Context, in *GetTaskRequest, opts ...grpc.CallOption) (*GetTaskResponse, error) + // Delete the task resource. + DeleteTask(ctx context.Context, in *DeleteTaskRequest, opts ...grpc.CallOption) (*DeleteTaskResponse, error) + // GetTaskMetrics returns one or more task execution metrics, if available. + // + // Errors include + // - OutOfRange if metrics are not available for the specified task time range + // - various other errors + GetTaskMetrics(ctx context.Context, in *GetTaskMetricsRequest, opts ...grpc.CallOption) (*GetTaskMetricsResponse, error) + // GetTaskLogs returns task execution logs, if available. + GetTaskLogs(ctx context.Context, in *GetTaskLogsRequest, opts ...grpc.CallOption) (AsyncConnectorService_GetTaskLogsClient, error) +} + +type asyncConnectorServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewAsyncConnectorServiceClient(cc grpc.ClientConnInterface) AsyncConnectorServiceClient { + return &asyncConnectorServiceClient{cc} +} + +func (c *asyncConnectorServiceClient) CreateTask(ctx context.Context, in *CreateTaskRequest, opts ...grpc.CallOption) (*CreateTaskResponse, error) { + out := new(CreateTaskResponse) + err := c.cc.Invoke(ctx, AsyncConnectorService_CreateTask_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *asyncConnectorServiceClient) GetTask(ctx context.Context, in *GetTaskRequest, opts ...grpc.CallOption) (*GetTaskResponse, error) { + out := new(GetTaskResponse) + err := c.cc.Invoke(ctx, AsyncConnectorService_GetTask_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *asyncConnectorServiceClient) DeleteTask(ctx context.Context, in *DeleteTaskRequest, opts ...grpc.CallOption) (*DeleteTaskResponse, error) { + out := new(DeleteTaskResponse) + err := c.cc.Invoke(ctx, AsyncConnectorService_DeleteTask_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *asyncConnectorServiceClient) GetTaskMetrics(ctx context.Context, in *GetTaskMetricsRequest, opts ...grpc.CallOption) (*GetTaskMetricsResponse, error) { + out := new(GetTaskMetricsResponse) + err := c.cc.Invoke(ctx, AsyncConnectorService_GetTaskMetrics_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *asyncConnectorServiceClient) GetTaskLogs(ctx context.Context, in *GetTaskLogsRequest, opts ...grpc.CallOption) (AsyncConnectorService_GetTaskLogsClient, error) { + stream, err := c.cc.NewStream(ctx, &AsyncConnectorService_ServiceDesc.Streams[0], AsyncConnectorService_GetTaskLogs_FullMethodName, opts...) + if err != nil { + return nil, err + } + x := &asyncConnectorServiceGetTaskLogsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type AsyncConnectorService_GetTaskLogsClient interface { + Recv() (*GetTaskLogsResponse, error) + grpc.ClientStream +} + +type asyncConnectorServiceGetTaskLogsClient struct { + grpc.ClientStream +} + +func (x *asyncConnectorServiceGetTaskLogsClient) Recv() (*GetTaskLogsResponse, error) { + m := new(GetTaskLogsResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// AsyncConnectorServiceServer is the server API for AsyncConnectorService service. +// All implementations should embed UnimplementedAsyncConnectorServiceServer +// for forward compatibility +type AsyncConnectorServiceServer interface { + // CreateTask sends a task create request to the connector service. + CreateTask(context.Context, *CreateTaskRequest) (*CreateTaskResponse, error) + // Get job status. + GetTask(context.Context, *GetTaskRequest) (*GetTaskResponse, error) + // Delete the task resource. + DeleteTask(context.Context, *DeleteTaskRequest) (*DeleteTaskResponse, error) + // GetTaskMetrics returns one or more task execution metrics, if available. + // + // Errors include + // - OutOfRange if metrics are not available for the specified task time range + // - various other errors + GetTaskMetrics(context.Context, *GetTaskMetricsRequest) (*GetTaskMetricsResponse, error) + // GetTaskLogs returns task execution logs, if available. + GetTaskLogs(*GetTaskLogsRequest, AsyncConnectorService_GetTaskLogsServer) error +} + +// UnimplementedAsyncConnectorServiceServer should be embedded to have forward compatible implementations. +type UnimplementedAsyncConnectorServiceServer struct { +} + +func (UnimplementedAsyncConnectorServiceServer) CreateTask(context.Context, *CreateTaskRequest) (*CreateTaskResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CreateTask not implemented") +} +func (UnimplementedAsyncConnectorServiceServer) GetTask(context.Context, *GetTaskRequest) (*GetTaskResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetTask not implemented") +} +func (UnimplementedAsyncConnectorServiceServer) DeleteTask(context.Context, *DeleteTaskRequest) (*DeleteTaskResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeleteTask not implemented") +} +func (UnimplementedAsyncConnectorServiceServer) GetTaskMetrics(context.Context, *GetTaskMetricsRequest) (*GetTaskMetricsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetTaskMetrics not implemented") +} +func (UnimplementedAsyncConnectorServiceServer) GetTaskLogs(*GetTaskLogsRequest, AsyncConnectorService_GetTaskLogsServer) error { + return status.Errorf(codes.Unimplemented, "method GetTaskLogs not implemented") +} + +// UnsafeAsyncConnectorServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to AsyncConnectorServiceServer will +// result in compilation errors. +type UnsafeAsyncConnectorServiceServer interface { + mustEmbedUnimplementedAsyncConnectorServiceServer() +} + +func RegisterAsyncConnectorServiceServer(s grpc.ServiceRegistrar, srv AsyncConnectorServiceServer) { + s.RegisterService(&AsyncConnectorService_ServiceDesc, srv) +} + +func _AsyncConnectorService_CreateTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CreateTaskRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AsyncConnectorServiceServer).CreateTask(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AsyncConnectorService_CreateTask_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AsyncConnectorServiceServer).CreateTask(ctx, req.(*CreateTaskRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AsyncConnectorService_GetTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetTaskRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AsyncConnectorServiceServer).GetTask(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AsyncConnectorService_GetTask_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AsyncConnectorServiceServer).GetTask(ctx, req.(*GetTaskRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AsyncConnectorService_DeleteTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteTaskRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AsyncConnectorServiceServer).DeleteTask(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AsyncConnectorService_DeleteTask_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AsyncConnectorServiceServer).DeleteTask(ctx, req.(*DeleteTaskRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AsyncConnectorService_GetTaskMetrics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetTaskMetricsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AsyncConnectorServiceServer).GetTaskMetrics(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AsyncConnectorService_GetTaskMetrics_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AsyncConnectorServiceServer).GetTaskMetrics(ctx, req.(*GetTaskMetricsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AsyncConnectorService_GetTaskLogs_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(GetTaskLogsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(AsyncConnectorServiceServer).GetTaskLogs(m, &asyncConnectorServiceGetTaskLogsServer{stream}) +} + +type AsyncConnectorService_GetTaskLogsServer interface { + Send(*GetTaskLogsResponse) error + grpc.ServerStream +} + +type asyncConnectorServiceGetTaskLogsServer struct { + grpc.ServerStream +} + +func (x *asyncConnectorServiceGetTaskLogsServer) Send(m *GetTaskLogsResponse) error { + return x.ServerStream.SendMsg(m) +} + +// AsyncConnectorService_ServiceDesc is the grpc.ServiceDesc for AsyncConnectorService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var AsyncConnectorService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.connector.AsyncConnectorService", + HandlerType: (*AsyncConnectorServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "CreateTask", + Handler: _AsyncConnectorService_CreateTask_Handler, + }, + { + MethodName: "GetTask", + Handler: _AsyncConnectorService_GetTask_Handler, + }, + { + MethodName: "DeleteTask", + Handler: _AsyncConnectorService_DeleteTask_Handler, + }, + { + MethodName: "GetTaskMetrics", + Handler: _AsyncConnectorService_GetTaskMetrics_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "GetTaskLogs", + Handler: _AsyncConnectorService_GetTaskLogs_Handler, + ServerStreams: true, + }, + }, + Metadata: "flyteidl2/connector/service.proto", +} + +const ( + ConnectorMetadataService_GetConnector_FullMethodName = "/flyteidl2.connector.ConnectorMetadataService/GetConnector" + ConnectorMetadataService_ListConnectors_FullMethodName = "/flyteidl2.connector.ConnectorMetadataService/ListConnectors" +) + +// ConnectorMetadataServiceClient is the client API for ConnectorMetadataService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type ConnectorMetadataServiceClient interface { + // Fetch a :ref:`ref_flyteidl2.plugins.Connector` definition. + GetConnector(ctx context.Context, in *GetConnectorRequest, opts ...grpc.CallOption) (*GetConnectorResponse, error) + // Fetch a list of :ref:`ref_flyteidl2.plugins.Connector` definitions. + ListConnectors(ctx context.Context, in *ListConnectorsRequest, opts ...grpc.CallOption) (*ListConnectorsResponse, error) +} + +type connectorMetadataServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewConnectorMetadataServiceClient(cc grpc.ClientConnInterface) ConnectorMetadataServiceClient { + return &connectorMetadataServiceClient{cc} +} + +func (c *connectorMetadataServiceClient) GetConnector(ctx context.Context, in *GetConnectorRequest, opts ...grpc.CallOption) (*GetConnectorResponse, error) { + out := new(GetConnectorResponse) + err := c.cc.Invoke(ctx, ConnectorMetadataService_GetConnector_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *connectorMetadataServiceClient) ListConnectors(ctx context.Context, in *ListConnectorsRequest, opts ...grpc.CallOption) (*ListConnectorsResponse, error) { + out := new(ListConnectorsResponse) + err := c.cc.Invoke(ctx, ConnectorMetadataService_ListConnectors_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// ConnectorMetadataServiceServer is the server API for ConnectorMetadataService service. +// All implementations should embed UnimplementedConnectorMetadataServiceServer +// for forward compatibility +type ConnectorMetadataServiceServer interface { + // Fetch a :ref:`ref_flyteidl2.plugins.Connector` definition. + GetConnector(context.Context, *GetConnectorRequest) (*GetConnectorResponse, error) + // Fetch a list of :ref:`ref_flyteidl2.plugins.Connector` definitions. + ListConnectors(context.Context, *ListConnectorsRequest) (*ListConnectorsResponse, error) +} + +// UnimplementedConnectorMetadataServiceServer should be embedded to have forward compatible implementations. +type UnimplementedConnectorMetadataServiceServer struct { +} + +func (UnimplementedConnectorMetadataServiceServer) GetConnector(context.Context, *GetConnectorRequest) (*GetConnectorResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetConnector not implemented") +} +func (UnimplementedConnectorMetadataServiceServer) ListConnectors(context.Context, *ListConnectorsRequest) (*ListConnectorsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ListConnectors not implemented") +} + +// UnsafeConnectorMetadataServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to ConnectorMetadataServiceServer will +// result in compilation errors. +type UnsafeConnectorMetadataServiceServer interface { + mustEmbedUnimplementedConnectorMetadataServiceServer() +} + +func RegisterConnectorMetadataServiceServer(s grpc.ServiceRegistrar, srv ConnectorMetadataServiceServer) { + s.RegisterService(&ConnectorMetadataService_ServiceDesc, srv) +} + +func _ConnectorMetadataService_GetConnector_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetConnectorRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ConnectorMetadataServiceServer).GetConnector(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ConnectorMetadataService_GetConnector_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ConnectorMetadataServiceServer).GetConnector(ctx, req.(*GetConnectorRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ConnectorMetadataService_ListConnectors_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListConnectorsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ConnectorMetadataServiceServer).ListConnectors(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ConnectorMetadataService_ListConnectors_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ConnectorMetadataServiceServer).ListConnectors(ctx, req.(*ListConnectorsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// ConnectorMetadataService_ServiceDesc is the grpc.ServiceDesc for ConnectorMetadataService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var ConnectorMetadataService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.connector.ConnectorMetadataService", + HandlerType: (*ConnectorMetadataServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "GetConnector", + Handler: _ConnectorMetadataService_GetConnector_Handler, + }, + { + MethodName: "ListConnectors", + Handler: _ConnectorMetadataService_ListConnectors_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "flyteidl2/connector/service.proto", +} diff --git a/gen/go/flyteidl2/core/artifact_id.pb.go b/gen/go/flyteidl2/core/artifact_id.pb.go new file mode 100644 index 0000000000..ba854db8ef --- /dev/null +++ b/gen/go/flyteidl2/core/artifact_id.pb.go @@ -0,0 +1,1271 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/core/artifact_id.proto + +package core + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type Granularity int32 + +const ( + Granularity_UNSET Granularity = 0 + Granularity_MINUTE Granularity = 1 + Granularity_HOUR Granularity = 2 + Granularity_DAY Granularity = 3 // default + Granularity_MONTH Granularity = 4 +) + +// Enum value maps for Granularity. +var ( + Granularity_name = map[int32]string{ + 0: "UNSET", + 1: "MINUTE", + 2: "HOUR", + 3: "DAY", + 4: "MONTH", + } + Granularity_value = map[string]int32{ + "UNSET": 0, + "MINUTE": 1, + "HOUR": 2, + "DAY": 3, + "MONTH": 4, + } +) + +func (x Granularity) Enum() *Granularity { + p := new(Granularity) + *p = x + return p +} + +func (x Granularity) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Granularity) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_artifact_id_proto_enumTypes[0].Descriptor() +} + +func (Granularity) Type() protoreflect.EnumType { + return &file_flyteidl2_core_artifact_id_proto_enumTypes[0] +} + +func (x Granularity) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Granularity.Descriptor instead. +func (Granularity) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_artifact_id_proto_rawDescGZIP(), []int{0} +} + +type Operator int32 + +const ( + Operator_MINUS Operator = 0 + Operator_PLUS Operator = 1 +) + +// Enum value maps for Operator. +var ( + Operator_name = map[int32]string{ + 0: "MINUS", + 1: "PLUS", + } + Operator_value = map[string]int32{ + "MINUS": 0, + "PLUS": 1, + } +) + +func (x Operator) Enum() *Operator { + p := new(Operator) + *p = x + return p +} + +func (x Operator) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Operator) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_artifact_id_proto_enumTypes[1].Descriptor() +} + +func (Operator) Type() protoreflect.EnumType { + return &file_flyteidl2_core_artifact_id_proto_enumTypes[1] +} + +func (x Operator) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Operator.Descriptor instead. +func (Operator) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_artifact_id_proto_rawDescGZIP(), []int{1} +} + +type ArtifactKey struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Project and domain and suffix needs to be unique across a given artifact store. + Project string `protobuf:"bytes,1,opt,name=project,proto3" json:"project,omitempty"` + Domain string `protobuf:"bytes,2,opt,name=domain,proto3" json:"domain,omitempty"` + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` + Org string `protobuf:"bytes,4,opt,name=org,proto3" json:"org,omitempty"` +} + +func (x *ArtifactKey) Reset() { + *x = ArtifactKey{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ArtifactKey) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ArtifactKey) ProtoMessage() {} + +func (x *ArtifactKey) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ArtifactKey.ProtoReflect.Descriptor instead. +func (*ArtifactKey) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_artifact_id_proto_rawDescGZIP(), []int{0} +} + +func (x *ArtifactKey) GetProject() string { + if x != nil { + return x.Project + } + return "" +} + +func (x *ArtifactKey) GetDomain() string { + if x != nil { + return x.Domain + } + return "" +} + +func (x *ArtifactKey) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *ArtifactKey) GetOrg() string { + if x != nil { + return x.Org + } + return "" +} + +// Only valid for triggers +type ArtifactBindingData struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // These two fields are only relevant in the partition value case + // + // Types that are assignable to PartitionData: + // + // *ArtifactBindingData_PartitionKey + // *ArtifactBindingData_BindToTimePartition + PartitionData isArtifactBindingData_PartitionData `protobuf_oneof:"partition_data"` + // This is only relevant in the time partition case + TimeTransform *TimeTransform `protobuf:"bytes,7,opt,name=time_transform,json=timeTransform,proto3" json:"time_transform,omitempty"` +} + +func (x *ArtifactBindingData) Reset() { + *x = ArtifactBindingData{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ArtifactBindingData) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ArtifactBindingData) ProtoMessage() {} + +func (x *ArtifactBindingData) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ArtifactBindingData.ProtoReflect.Descriptor instead. +func (*ArtifactBindingData) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_artifact_id_proto_rawDescGZIP(), []int{1} +} + +func (m *ArtifactBindingData) GetPartitionData() isArtifactBindingData_PartitionData { + if m != nil { + return m.PartitionData + } + return nil +} + +func (x *ArtifactBindingData) GetPartitionKey() string { + if x, ok := x.GetPartitionData().(*ArtifactBindingData_PartitionKey); ok { + return x.PartitionKey + } + return "" +} + +func (x *ArtifactBindingData) GetBindToTimePartition() bool { + if x, ok := x.GetPartitionData().(*ArtifactBindingData_BindToTimePartition); ok { + return x.BindToTimePartition + } + return false +} + +func (x *ArtifactBindingData) GetTimeTransform() *TimeTransform { + if x != nil { + return x.TimeTransform + } + return nil +} + +type isArtifactBindingData_PartitionData interface { + isArtifactBindingData_PartitionData() +} + +type ArtifactBindingData_PartitionKey struct { + PartitionKey string `protobuf:"bytes,5,opt,name=partition_key,json=partitionKey,proto3,oneof"` +} + +type ArtifactBindingData_BindToTimePartition struct { + BindToTimePartition bool `protobuf:"varint,6,opt,name=bind_to_time_partition,json=bindToTimePartition,proto3,oneof"` +} + +func (*ArtifactBindingData_PartitionKey) isArtifactBindingData_PartitionData() {} + +func (*ArtifactBindingData_BindToTimePartition) isArtifactBindingData_PartitionData() {} + +type TimeTransform struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Transform string `protobuf:"bytes,1,opt,name=transform,proto3" json:"transform,omitempty"` + Op Operator `protobuf:"varint,2,opt,name=op,proto3,enum=flyteidl2.core.Operator" json:"op,omitempty"` +} + +func (x *TimeTransform) Reset() { + *x = TimeTransform{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TimeTransform) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TimeTransform) ProtoMessage() {} + +func (x *TimeTransform) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TimeTransform.ProtoReflect.Descriptor instead. +func (*TimeTransform) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_artifact_id_proto_rawDescGZIP(), []int{2} +} + +func (x *TimeTransform) GetTransform() string { + if x != nil { + return x.Transform + } + return "" +} + +func (x *TimeTransform) GetOp() Operator { + if x != nil { + return x.Op + } + return Operator_MINUS +} + +type InputBindingData struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Var string `protobuf:"bytes,1,opt,name=var,proto3" json:"var,omitempty"` +} + +func (x *InputBindingData) Reset() { + *x = InputBindingData{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *InputBindingData) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InputBindingData) ProtoMessage() {} + +func (x *InputBindingData) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use InputBindingData.ProtoReflect.Descriptor instead. +func (*InputBindingData) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_artifact_id_proto_rawDescGZIP(), []int{3} +} + +func (x *InputBindingData) GetVar() string { + if x != nil { + return x.Var + } + return "" +} + +type RuntimeBinding struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *RuntimeBinding) Reset() { + *x = RuntimeBinding{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RuntimeBinding) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RuntimeBinding) ProtoMessage() {} + +func (x *RuntimeBinding) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RuntimeBinding.ProtoReflect.Descriptor instead. +func (*RuntimeBinding) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_artifact_id_proto_rawDescGZIP(), []int{4} +} + +type LabelValue struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Value: + // + // *LabelValue_StaticValue + // *LabelValue_TimeValue + // *LabelValue_TriggeredBinding + // *LabelValue_InputBinding + // *LabelValue_RuntimeBinding + Value isLabelValue_Value `protobuf_oneof:"value"` +} + +func (x *LabelValue) Reset() { + *x = LabelValue{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LabelValue) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LabelValue) ProtoMessage() {} + +func (x *LabelValue) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LabelValue.ProtoReflect.Descriptor instead. +func (*LabelValue) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_artifact_id_proto_rawDescGZIP(), []int{5} +} + +func (m *LabelValue) GetValue() isLabelValue_Value { + if m != nil { + return m.Value + } + return nil +} + +func (x *LabelValue) GetStaticValue() string { + if x, ok := x.GetValue().(*LabelValue_StaticValue); ok { + return x.StaticValue + } + return "" +} + +func (x *LabelValue) GetTimeValue() *timestamppb.Timestamp { + if x, ok := x.GetValue().(*LabelValue_TimeValue); ok { + return x.TimeValue + } + return nil +} + +func (x *LabelValue) GetTriggeredBinding() *ArtifactBindingData { + if x, ok := x.GetValue().(*LabelValue_TriggeredBinding); ok { + return x.TriggeredBinding + } + return nil +} + +func (x *LabelValue) GetInputBinding() *InputBindingData { + if x, ok := x.GetValue().(*LabelValue_InputBinding); ok { + return x.InputBinding + } + return nil +} + +func (x *LabelValue) GetRuntimeBinding() *RuntimeBinding { + if x, ok := x.GetValue().(*LabelValue_RuntimeBinding); ok { + return x.RuntimeBinding + } + return nil +} + +type isLabelValue_Value interface { + isLabelValue_Value() +} + +type LabelValue_StaticValue struct { + // The string static value is for use in the Partitions object + StaticValue string `protobuf:"bytes,1,opt,name=static_value,json=staticValue,proto3,oneof"` +} + +type LabelValue_TimeValue struct { + // The time value is for use in the TimePartition case + TimeValue *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=time_value,json=timeValue,proto3,oneof"` +} + +type LabelValue_TriggeredBinding struct { + TriggeredBinding *ArtifactBindingData `protobuf:"bytes,3,opt,name=triggered_binding,json=triggeredBinding,proto3,oneof"` +} + +type LabelValue_InputBinding struct { + InputBinding *InputBindingData `protobuf:"bytes,4,opt,name=input_binding,json=inputBinding,proto3,oneof"` +} + +type LabelValue_RuntimeBinding struct { + RuntimeBinding *RuntimeBinding `protobuf:"bytes,5,opt,name=runtime_binding,json=runtimeBinding,proto3,oneof"` +} + +func (*LabelValue_StaticValue) isLabelValue_Value() {} + +func (*LabelValue_TimeValue) isLabelValue_Value() {} + +func (*LabelValue_TriggeredBinding) isLabelValue_Value() {} + +func (*LabelValue_InputBinding) isLabelValue_Value() {} + +func (*LabelValue_RuntimeBinding) isLabelValue_Value() {} + +type Partitions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Value map[string]*LabelValue `protobuf:"bytes,1,rep,name=value,proto3" json:"value,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *Partitions) Reset() { + *x = Partitions{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Partitions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Partitions) ProtoMessage() {} + +func (x *Partitions) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Partitions.ProtoReflect.Descriptor instead. +func (*Partitions) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_artifact_id_proto_rawDescGZIP(), []int{6} +} + +func (x *Partitions) GetValue() map[string]*LabelValue { + if x != nil { + return x.Value + } + return nil +} + +type TimePartition struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Value *LabelValue `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + Granularity Granularity `protobuf:"varint,2,opt,name=granularity,proto3,enum=flyteidl2.core.Granularity" json:"granularity,omitempty"` +} + +func (x *TimePartition) Reset() { + *x = TimePartition{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TimePartition) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TimePartition) ProtoMessage() {} + +func (x *TimePartition) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TimePartition.ProtoReflect.Descriptor instead. +func (*TimePartition) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_artifact_id_proto_rawDescGZIP(), []int{7} +} + +func (x *TimePartition) GetValue() *LabelValue { + if x != nil { + return x.Value + } + return nil +} + +func (x *TimePartition) GetGranularity() Granularity { + if x != nil { + return x.Granularity + } + return Granularity_UNSET +} + +type ArtifactID struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ArtifactKey *ArtifactKey `protobuf:"bytes,1,opt,name=artifact_key,json=artifactKey,proto3" json:"artifact_key,omitempty"` + Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"` + // Think of a partition as a tag on an Artifact, except it's a key-value pair. + // Different partitions naturally have different versions (execution ids). + Partitions *Partitions `protobuf:"bytes,3,opt,name=partitions,proto3" json:"partitions,omitempty"` + // There is no such thing as an empty time partition - if it's not set, then there is no time partition. + TimePartition *TimePartition `protobuf:"bytes,4,opt,name=time_partition,json=timePartition,proto3" json:"time_partition,omitempty"` +} + +func (x *ArtifactID) Reset() { + *x = ArtifactID{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ArtifactID) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ArtifactID) ProtoMessage() {} + +func (x *ArtifactID) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ArtifactID.ProtoReflect.Descriptor instead. +func (*ArtifactID) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_artifact_id_proto_rawDescGZIP(), []int{8} +} + +func (x *ArtifactID) GetArtifactKey() *ArtifactKey { + if x != nil { + return x.ArtifactKey + } + return nil +} + +func (x *ArtifactID) GetVersion() string { + if x != nil { + return x.Version + } + return "" +} + +func (x *ArtifactID) GetPartitions() *Partitions { + if x != nil { + return x.Partitions + } + return nil +} + +func (x *ArtifactID) GetTimePartition() *TimePartition { + if x != nil { + return x.TimePartition + } + return nil +} + +type ArtifactTag struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ArtifactKey *ArtifactKey `protobuf:"bytes,1,opt,name=artifact_key,json=artifactKey,proto3" json:"artifact_key,omitempty"` + Value *LabelValue `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` +} + +func (x *ArtifactTag) Reset() { + *x = ArtifactTag{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ArtifactTag) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ArtifactTag) ProtoMessage() {} + +func (x *ArtifactTag) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ArtifactTag.ProtoReflect.Descriptor instead. +func (*ArtifactTag) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_artifact_id_proto_rawDescGZIP(), []int{9} +} + +func (x *ArtifactTag) GetArtifactKey() *ArtifactKey { + if x != nil { + return x.ArtifactKey + } + return nil +} + +func (x *ArtifactTag) GetValue() *LabelValue { + if x != nil { + return x.Value + } + return nil +} + +// Uniqueness constraints for Artifacts +// - project, domain, name, version, partitions +// +// Option 2 (tags are standalone, point to an individual artifact id): +// - project, domain, name, alias (points to one partition if partitioned) +// - project, domain, name, partition key, partition value +type ArtifactQuery struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Identifier: + // + // *ArtifactQuery_ArtifactId + // *ArtifactQuery_ArtifactTag + // *ArtifactQuery_Uri + // *ArtifactQuery_Binding + Identifier isArtifactQuery_Identifier `protobuf_oneof:"identifier"` +} + +func (x *ArtifactQuery) Reset() { + *x = ArtifactQuery{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ArtifactQuery) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ArtifactQuery) ProtoMessage() {} + +func (x *ArtifactQuery) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_artifact_id_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ArtifactQuery.ProtoReflect.Descriptor instead. +func (*ArtifactQuery) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_artifact_id_proto_rawDescGZIP(), []int{10} +} + +func (m *ArtifactQuery) GetIdentifier() isArtifactQuery_Identifier { + if m != nil { + return m.Identifier + } + return nil +} + +func (x *ArtifactQuery) GetArtifactId() *ArtifactID { + if x, ok := x.GetIdentifier().(*ArtifactQuery_ArtifactId); ok { + return x.ArtifactId + } + return nil +} + +func (x *ArtifactQuery) GetArtifactTag() *ArtifactTag { + if x, ok := x.GetIdentifier().(*ArtifactQuery_ArtifactTag); ok { + return x.ArtifactTag + } + return nil +} + +func (x *ArtifactQuery) GetUri() string { + if x, ok := x.GetIdentifier().(*ArtifactQuery_Uri); ok { + return x.Uri + } + return "" +} + +func (x *ArtifactQuery) GetBinding() *ArtifactBindingData { + if x, ok := x.GetIdentifier().(*ArtifactQuery_Binding); ok { + return x.Binding + } + return nil +} + +type isArtifactQuery_Identifier interface { + isArtifactQuery_Identifier() +} + +type ArtifactQuery_ArtifactId struct { + ArtifactId *ArtifactID `protobuf:"bytes,1,opt,name=artifact_id,json=artifactId,proto3,oneof"` +} + +type ArtifactQuery_ArtifactTag struct { + ArtifactTag *ArtifactTag `protobuf:"bytes,2,opt,name=artifact_tag,json=artifactTag,proto3,oneof"` +} + +type ArtifactQuery_Uri struct { + Uri string `protobuf:"bytes,3,opt,name=uri,proto3,oneof"` +} + +type ArtifactQuery_Binding struct { + // This is used in the trigger case, where a user specifies a value for an input that is one of the triggering + // artifacts, or a partition value derived from a triggering artifact. + Binding *ArtifactBindingData `protobuf:"bytes,4,opt,name=binding,proto3,oneof"` +} + +func (*ArtifactQuery_ArtifactId) isArtifactQuery_Identifier() {} + +func (*ArtifactQuery_ArtifactTag) isArtifactQuery_Identifier() {} + +func (*ArtifactQuery_Uri) isArtifactQuery_Identifier() {} + +func (*ArtifactQuery_Binding) isArtifactQuery_Identifier() {} + +var File_flyteidl2_core_artifact_id_proto protoreflect.FileDescriptor + +var file_flyteidl2_core_artifact_id_proto_rawDesc = []byte{ + 0x0a, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x22, 0x65, 0x0a, 0x0b, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x4b, + 0x65, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x16, 0x0a, 0x06, + 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x64, 0x6f, + 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x22, 0xd1, 0x01, 0x0a, 0x13, 0x41, + 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, + 0x74, 0x61, 0x12, 0x25, 0x0a, 0x0d, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x6b, 0x65, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0c, 0x70, 0x61, 0x72, + 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x12, 0x35, 0x0a, 0x16, 0x62, 0x69, 0x6e, + 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x13, 0x62, 0x69, 0x6e, + 0x64, 0x54, 0x6f, 0x54, 0x69, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x44, 0x0a, 0x0e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, + 0x72, 0x6d, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x72, + 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x52, 0x0d, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x72, 0x61, + 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x42, 0x10, 0x0a, 0x0e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x4a, 0x04, 0x08, 0x01, 0x10, 0x05, 0x22, 0x57, + 0x0a, 0x0d, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x12, + 0x1c, 0x0a, 0x09, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x09, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x12, 0x28, 0x0a, + 0x02, 0x6f, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x6f, 0x72, 0x52, 0x02, 0x6f, 0x70, 0x22, 0x24, 0x0a, 0x10, 0x49, 0x6e, 0x70, 0x75, 0x74, + 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x12, 0x10, 0x0a, 0x03, 0x76, + 0x61, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x76, 0x61, 0x72, 0x22, 0x10, 0x0a, + 0x0e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, + 0xdf, 0x02, 0x0a, 0x0a, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23, + 0x0a, 0x0c, 0x73, 0x74, 0x61, 0x74, 0x69, 0x63, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x73, 0x74, 0x61, 0x74, 0x69, 0x63, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x12, 0x3b, 0x0a, 0x0a, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x48, 0x00, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x12, 0x52, 0x0a, 0x11, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x65, 0x64, 0x5f, 0x62, 0x69, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, + 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, + 0x48, 0x00, 0x52, 0x10, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x65, 0x64, 0x42, 0x69, 0x6e, + 0x64, 0x69, 0x6e, 0x67, 0x12, 0x47, 0x0a, 0x0d, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x62, 0x69, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x6e, 0x70, + 0x75, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, + 0x0c, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x49, 0x0a, + 0x0f, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x42, + 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x48, 0x00, 0x52, 0x0e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, + 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x42, 0x07, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x22, 0x9f, 0x01, 0x0a, 0x0a, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x12, 0x3b, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x1a, 0x54, 0x0a, + 0x0a, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, + 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x30, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x61, + 0x62, 0x65, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, + 0x02, 0x38, 0x01, 0x22, 0x80, 0x01, 0x0a, 0x0d, 0x54, 0x69, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x30, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x3d, 0x0a, 0x0b, 0x67, 0x72, 0x61, 0x6e, 0x75, + 0x6c, 0x61, 0x72, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x47, 0x72, + 0x61, 0x6e, 0x75, 0x6c, 0x61, 0x72, 0x69, 0x74, 0x79, 0x52, 0x0b, 0x67, 0x72, 0x61, 0x6e, 0x75, + 0x6c, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0xe8, 0x01, 0x0a, 0x0a, 0x41, 0x72, 0x74, 0x69, 0x66, + 0x61, 0x63, 0x74, 0x49, 0x44, 0x12, 0x3e, 0x0a, 0x0c, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, + 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, + 0x69, 0x66, 0x61, 0x63, 0x74, 0x4b, 0x65, 0x79, 0x52, 0x0b, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, + 0x63, 0x74, 0x4b, 0x65, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, + 0x3a, 0x0a, 0x0a, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, + 0x0a, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x44, 0x0a, 0x0e, 0x74, + 0x69, 0x6d, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x0d, 0x74, 0x69, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x22, 0x7f, 0x0a, 0x0b, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x54, 0x61, 0x67, + 0x12, 0x3e, 0x0a, 0x0c, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, + 0x4b, 0x65, 0x79, 0x52, 0x0b, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x4b, 0x65, 0x79, + 0x12, 0x30, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x22, 0xf3, 0x01, 0x0a, 0x0d, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x12, 0x3d, 0x0a, 0x0b, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, + 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x66, + 0x61, 0x63, 0x74, 0x49, 0x44, 0x48, 0x00, 0x52, 0x0a, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, + 0x74, 0x49, 0x64, 0x12, 0x40, 0x0a, 0x0c, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, + 0x74, 0x61, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x66, + 0x61, 0x63, 0x74, 0x54, 0x61, 0x67, 0x48, 0x00, 0x52, 0x0b, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, + 0x63, 0x74, 0x54, 0x61, 0x67, 0x12, 0x12, 0x0a, 0x03, 0x75, 0x72, 0x69, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x48, 0x00, 0x52, 0x03, 0x75, 0x72, 0x69, 0x12, 0x3f, 0x0a, 0x07, 0x62, 0x69, 0x6e, + 0x64, 0x69, 0x6e, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, 0x69, + 0x66, 0x61, 0x63, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x48, + 0x00, 0x52, 0x07, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x42, 0x0c, 0x0a, 0x0a, 0x69, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2a, 0x42, 0x0a, 0x0b, 0x47, 0x72, 0x61, 0x6e, + 0x75, 0x6c, 0x61, 0x72, 0x69, 0x74, 0x79, 0x12, 0x09, 0x0a, 0x05, 0x55, 0x4e, 0x53, 0x45, 0x54, + 0x10, 0x00, 0x12, 0x0a, 0x0a, 0x06, 0x4d, 0x49, 0x4e, 0x55, 0x54, 0x45, 0x10, 0x01, 0x12, 0x08, + 0x0a, 0x04, 0x48, 0x4f, 0x55, 0x52, 0x10, 0x02, 0x12, 0x07, 0x0a, 0x03, 0x44, 0x41, 0x59, 0x10, + 0x03, 0x12, 0x09, 0x0a, 0x05, 0x4d, 0x4f, 0x4e, 0x54, 0x48, 0x10, 0x04, 0x2a, 0x1f, 0x0a, 0x08, + 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x09, 0x0a, 0x05, 0x4d, 0x49, 0x4e, 0x55, + 0x53, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x50, 0x4c, 0x55, 0x53, 0x10, 0x01, 0x42, 0xb4, 0x01, + 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x42, 0x0f, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x64, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0xa2, 0x02, 0x03, + 0x46, 0x43, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x43, 0x6f, 0x72, 0x65, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x43, 0x6f, 0x72, 0x65, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, + 0x43, 0x6f, 0x72, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_core_artifact_id_proto_rawDescOnce sync.Once + file_flyteidl2_core_artifact_id_proto_rawDescData = file_flyteidl2_core_artifact_id_proto_rawDesc +) + +func file_flyteidl2_core_artifact_id_proto_rawDescGZIP() []byte { + file_flyteidl2_core_artifact_id_proto_rawDescOnce.Do(func() { + file_flyteidl2_core_artifact_id_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_core_artifact_id_proto_rawDescData) + }) + return file_flyteidl2_core_artifact_id_proto_rawDescData +} + +var file_flyteidl2_core_artifact_id_proto_enumTypes = make([]protoimpl.EnumInfo, 2) +var file_flyteidl2_core_artifact_id_proto_msgTypes = make([]protoimpl.MessageInfo, 12) +var file_flyteidl2_core_artifact_id_proto_goTypes = []interface{}{ + (Granularity)(0), // 0: flyteidl2.core.Granularity + (Operator)(0), // 1: flyteidl2.core.Operator + (*ArtifactKey)(nil), // 2: flyteidl2.core.ArtifactKey + (*ArtifactBindingData)(nil), // 3: flyteidl2.core.ArtifactBindingData + (*TimeTransform)(nil), // 4: flyteidl2.core.TimeTransform + (*InputBindingData)(nil), // 5: flyteidl2.core.InputBindingData + (*RuntimeBinding)(nil), // 6: flyteidl2.core.RuntimeBinding + (*LabelValue)(nil), // 7: flyteidl2.core.LabelValue + (*Partitions)(nil), // 8: flyteidl2.core.Partitions + (*TimePartition)(nil), // 9: flyteidl2.core.TimePartition + (*ArtifactID)(nil), // 10: flyteidl2.core.ArtifactID + (*ArtifactTag)(nil), // 11: flyteidl2.core.ArtifactTag + (*ArtifactQuery)(nil), // 12: flyteidl2.core.ArtifactQuery + nil, // 13: flyteidl2.core.Partitions.ValueEntry + (*timestamppb.Timestamp)(nil), // 14: google.protobuf.Timestamp +} +var file_flyteidl2_core_artifact_id_proto_depIdxs = []int32{ + 4, // 0: flyteidl2.core.ArtifactBindingData.time_transform:type_name -> flyteidl2.core.TimeTransform + 1, // 1: flyteidl2.core.TimeTransform.op:type_name -> flyteidl2.core.Operator + 14, // 2: flyteidl2.core.LabelValue.time_value:type_name -> google.protobuf.Timestamp + 3, // 3: flyteidl2.core.LabelValue.triggered_binding:type_name -> flyteidl2.core.ArtifactBindingData + 5, // 4: flyteidl2.core.LabelValue.input_binding:type_name -> flyteidl2.core.InputBindingData + 6, // 5: flyteidl2.core.LabelValue.runtime_binding:type_name -> flyteidl2.core.RuntimeBinding + 13, // 6: flyteidl2.core.Partitions.value:type_name -> flyteidl2.core.Partitions.ValueEntry + 7, // 7: flyteidl2.core.TimePartition.value:type_name -> flyteidl2.core.LabelValue + 0, // 8: flyteidl2.core.TimePartition.granularity:type_name -> flyteidl2.core.Granularity + 2, // 9: flyteidl2.core.ArtifactID.artifact_key:type_name -> flyteidl2.core.ArtifactKey + 8, // 10: flyteidl2.core.ArtifactID.partitions:type_name -> flyteidl2.core.Partitions + 9, // 11: flyteidl2.core.ArtifactID.time_partition:type_name -> flyteidl2.core.TimePartition + 2, // 12: flyteidl2.core.ArtifactTag.artifact_key:type_name -> flyteidl2.core.ArtifactKey + 7, // 13: flyteidl2.core.ArtifactTag.value:type_name -> flyteidl2.core.LabelValue + 10, // 14: flyteidl2.core.ArtifactQuery.artifact_id:type_name -> flyteidl2.core.ArtifactID + 11, // 15: flyteidl2.core.ArtifactQuery.artifact_tag:type_name -> flyteidl2.core.ArtifactTag + 3, // 16: flyteidl2.core.ArtifactQuery.binding:type_name -> flyteidl2.core.ArtifactBindingData + 7, // 17: flyteidl2.core.Partitions.ValueEntry.value:type_name -> flyteidl2.core.LabelValue + 18, // [18:18] is the sub-list for method output_type + 18, // [18:18] is the sub-list for method input_type + 18, // [18:18] is the sub-list for extension type_name + 18, // [18:18] is the sub-list for extension extendee + 0, // [0:18] is the sub-list for field type_name +} + +func init() { file_flyteidl2_core_artifact_id_proto_init() } +func file_flyteidl2_core_artifact_id_proto_init() { + if File_flyteidl2_core_artifact_id_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_core_artifact_id_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ArtifactKey); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_artifact_id_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ArtifactBindingData); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_artifact_id_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TimeTransform); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_artifact_id_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*InputBindingData); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_artifact_id_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RuntimeBinding); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_artifact_id_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LabelValue); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_artifact_id_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Partitions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_artifact_id_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TimePartition); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_artifact_id_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ArtifactID); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_artifact_id_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ArtifactTag); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_artifact_id_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ArtifactQuery); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_core_artifact_id_proto_msgTypes[1].OneofWrappers = []interface{}{ + (*ArtifactBindingData_PartitionKey)(nil), + (*ArtifactBindingData_BindToTimePartition)(nil), + } + file_flyteidl2_core_artifact_id_proto_msgTypes[5].OneofWrappers = []interface{}{ + (*LabelValue_StaticValue)(nil), + (*LabelValue_TimeValue)(nil), + (*LabelValue_TriggeredBinding)(nil), + (*LabelValue_InputBinding)(nil), + (*LabelValue_RuntimeBinding)(nil), + } + file_flyteidl2_core_artifact_id_proto_msgTypes[10].OneofWrappers = []interface{}{ + (*ArtifactQuery_ArtifactId)(nil), + (*ArtifactQuery_ArtifactTag)(nil), + (*ArtifactQuery_Uri)(nil), + (*ArtifactQuery_Binding)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_core_artifact_id_proto_rawDesc, + NumEnums: 2, + NumMessages: 12, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_core_artifact_id_proto_goTypes, + DependencyIndexes: file_flyteidl2_core_artifact_id_proto_depIdxs, + EnumInfos: file_flyteidl2_core_artifact_id_proto_enumTypes, + MessageInfos: file_flyteidl2_core_artifact_id_proto_msgTypes, + }.Build() + File_flyteidl2_core_artifact_id_proto = out.File + file_flyteidl2_core_artifact_id_proto_rawDesc = nil + file_flyteidl2_core_artifact_id_proto_goTypes = nil + file_flyteidl2_core_artifact_id_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/core/artifact_id.pb.validate.go b/gen/go/flyteidl2/core/artifact_id.pb.validate.go new file mode 100644 index 0000000000..7c8091dae1 --- /dev/null +++ b/gen/go/flyteidl2/core/artifact_id.pb.validate.go @@ -0,0 +1,1750 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/core/artifact_id.proto + +package core + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on ArtifactKey with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ArtifactKey) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ArtifactKey with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ArtifactKeyMultiError, or +// nil if none found. +func (m *ArtifactKey) ValidateAll() error { + return m.validate(true) +} + +func (m *ArtifactKey) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Project + + // no validation rules for Domain + + // no validation rules for Name + + // no validation rules for Org + + if len(errors) > 0 { + return ArtifactKeyMultiError(errors) + } + + return nil +} + +// ArtifactKeyMultiError is an error wrapping multiple validation errors +// returned by ArtifactKey.ValidateAll() if the designated constraints aren't met. +type ArtifactKeyMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ArtifactKeyMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ArtifactKeyMultiError) AllErrors() []error { return m } + +// ArtifactKeyValidationError is the validation error returned by +// ArtifactKey.Validate if the designated constraints aren't met. +type ArtifactKeyValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ArtifactKeyValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ArtifactKeyValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ArtifactKeyValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ArtifactKeyValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ArtifactKeyValidationError) ErrorName() string { return "ArtifactKeyValidationError" } + +// Error satisfies the builtin error interface +func (e ArtifactKeyValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sArtifactKey.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ArtifactKeyValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ArtifactKeyValidationError{} + +// Validate checks the field values on ArtifactBindingData with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ArtifactBindingData) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ArtifactBindingData with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ArtifactBindingDataMultiError, or nil if none found. +func (m *ArtifactBindingData) ValidateAll() error { + return m.validate(true) +} + +func (m *ArtifactBindingData) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetTimeTransform()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ArtifactBindingDataValidationError{ + field: "TimeTransform", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ArtifactBindingDataValidationError{ + field: "TimeTransform", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTimeTransform()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ArtifactBindingDataValidationError{ + field: "TimeTransform", + reason: "embedded message failed validation", + cause: err, + } + } + } + + switch v := m.PartitionData.(type) { + case *ArtifactBindingData_PartitionKey: + if v == nil { + err := ArtifactBindingDataValidationError{ + field: "PartitionData", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for PartitionKey + case *ArtifactBindingData_BindToTimePartition: + if v == nil { + err := ArtifactBindingDataValidationError{ + field: "PartitionData", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for BindToTimePartition + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return ArtifactBindingDataMultiError(errors) + } + + return nil +} + +// ArtifactBindingDataMultiError is an error wrapping multiple validation +// errors returned by ArtifactBindingData.ValidateAll() if the designated +// constraints aren't met. +type ArtifactBindingDataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ArtifactBindingDataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ArtifactBindingDataMultiError) AllErrors() []error { return m } + +// ArtifactBindingDataValidationError is the validation error returned by +// ArtifactBindingData.Validate if the designated constraints aren't met. +type ArtifactBindingDataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ArtifactBindingDataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ArtifactBindingDataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ArtifactBindingDataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ArtifactBindingDataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ArtifactBindingDataValidationError) ErrorName() string { + return "ArtifactBindingDataValidationError" +} + +// Error satisfies the builtin error interface +func (e ArtifactBindingDataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sArtifactBindingData.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ArtifactBindingDataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ArtifactBindingDataValidationError{} + +// Validate checks the field values on TimeTransform with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TimeTransform) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TimeTransform with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TimeTransformMultiError, or +// nil if none found. +func (m *TimeTransform) ValidateAll() error { + return m.validate(true) +} + +func (m *TimeTransform) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Transform + + // no validation rules for Op + + if len(errors) > 0 { + return TimeTransformMultiError(errors) + } + + return nil +} + +// TimeTransformMultiError is an error wrapping multiple validation errors +// returned by TimeTransform.ValidateAll() if the designated constraints +// aren't met. +type TimeTransformMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TimeTransformMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TimeTransformMultiError) AllErrors() []error { return m } + +// TimeTransformValidationError is the validation error returned by +// TimeTransform.Validate if the designated constraints aren't met. +type TimeTransformValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TimeTransformValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TimeTransformValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TimeTransformValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TimeTransformValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TimeTransformValidationError) ErrorName() string { return "TimeTransformValidationError" } + +// Error satisfies the builtin error interface +func (e TimeTransformValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTimeTransform.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TimeTransformValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TimeTransformValidationError{} + +// Validate checks the field values on InputBindingData with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *InputBindingData) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on InputBindingData with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// InputBindingDataMultiError, or nil if none found. +func (m *InputBindingData) ValidateAll() error { + return m.validate(true) +} + +func (m *InputBindingData) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Var + + if len(errors) > 0 { + return InputBindingDataMultiError(errors) + } + + return nil +} + +// InputBindingDataMultiError is an error wrapping multiple validation errors +// returned by InputBindingData.ValidateAll() if the designated constraints +// aren't met. +type InputBindingDataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m InputBindingDataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m InputBindingDataMultiError) AllErrors() []error { return m } + +// InputBindingDataValidationError is the validation error returned by +// InputBindingData.Validate if the designated constraints aren't met. +type InputBindingDataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e InputBindingDataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e InputBindingDataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e InputBindingDataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e InputBindingDataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e InputBindingDataValidationError) ErrorName() string { return "InputBindingDataValidationError" } + +// Error satisfies the builtin error interface +func (e InputBindingDataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sInputBindingData.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = InputBindingDataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = InputBindingDataValidationError{} + +// Validate checks the field values on RuntimeBinding with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *RuntimeBinding) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on RuntimeBinding with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in RuntimeBindingMultiError, +// or nil if none found. +func (m *RuntimeBinding) ValidateAll() error { + return m.validate(true) +} + +func (m *RuntimeBinding) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return RuntimeBindingMultiError(errors) + } + + return nil +} + +// RuntimeBindingMultiError is an error wrapping multiple validation errors +// returned by RuntimeBinding.ValidateAll() if the designated constraints +// aren't met. +type RuntimeBindingMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m RuntimeBindingMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m RuntimeBindingMultiError) AllErrors() []error { return m } + +// RuntimeBindingValidationError is the validation error returned by +// RuntimeBinding.Validate if the designated constraints aren't met. +type RuntimeBindingValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e RuntimeBindingValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e RuntimeBindingValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e RuntimeBindingValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e RuntimeBindingValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e RuntimeBindingValidationError) ErrorName() string { return "RuntimeBindingValidationError" } + +// Error satisfies the builtin error interface +func (e RuntimeBindingValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sRuntimeBinding.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = RuntimeBindingValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = RuntimeBindingValidationError{} + +// Validate checks the field values on LabelValue with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *LabelValue) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LabelValue with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in LabelValueMultiError, or +// nil if none found. +func (m *LabelValue) ValidateAll() error { + return m.validate(true) +} + +func (m *LabelValue) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Value.(type) { + case *LabelValue_StaticValue: + if v == nil { + err := LabelValueValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for StaticValue + case *LabelValue_TimeValue: + if v == nil { + err := LabelValueValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTimeValue()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LabelValueValidationError{ + field: "TimeValue", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LabelValueValidationError{ + field: "TimeValue", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTimeValue()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LabelValueValidationError{ + field: "TimeValue", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *LabelValue_TriggeredBinding: + if v == nil { + err := LabelValueValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTriggeredBinding()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LabelValueValidationError{ + field: "TriggeredBinding", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LabelValueValidationError{ + field: "TriggeredBinding", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTriggeredBinding()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LabelValueValidationError{ + field: "TriggeredBinding", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *LabelValue_InputBinding: + if v == nil { + err := LabelValueValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetInputBinding()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LabelValueValidationError{ + field: "InputBinding", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LabelValueValidationError{ + field: "InputBinding", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetInputBinding()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LabelValueValidationError{ + field: "InputBinding", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *LabelValue_RuntimeBinding: + if v == nil { + err := LabelValueValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetRuntimeBinding()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LabelValueValidationError{ + field: "RuntimeBinding", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LabelValueValidationError{ + field: "RuntimeBinding", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRuntimeBinding()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LabelValueValidationError{ + field: "RuntimeBinding", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return LabelValueMultiError(errors) + } + + return nil +} + +// LabelValueMultiError is an error wrapping multiple validation errors +// returned by LabelValue.ValidateAll() if the designated constraints aren't met. +type LabelValueMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LabelValueMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LabelValueMultiError) AllErrors() []error { return m } + +// LabelValueValidationError is the validation error returned by +// LabelValue.Validate if the designated constraints aren't met. +type LabelValueValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LabelValueValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LabelValueValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LabelValueValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LabelValueValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LabelValueValidationError) ErrorName() string { return "LabelValueValidationError" } + +// Error satisfies the builtin error interface +func (e LabelValueValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLabelValue.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LabelValueValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LabelValueValidationError{} + +// Validate checks the field values on Partitions with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Partitions) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Partitions with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in PartitionsMultiError, or +// nil if none found. +func (m *Partitions) ValidateAll() error { + return m.validate(true) +} + +func (m *Partitions) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + { + sorted_keys := make([]string, len(m.GetValue())) + i := 0 + for key := range m.GetValue() { + sorted_keys[i] = key + i++ + } + sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] }) + for _, key := range sorted_keys { + val := m.GetValue()[key] + _ = val + + // no validation rules for Value[key] + + if all { + switch v := interface{}(val).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PartitionsValidationError{ + field: fmt.Sprintf("Value[%v]", key), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PartitionsValidationError{ + field: fmt.Sprintf("Value[%v]", key), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(val).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PartitionsValidationError{ + field: fmt.Sprintf("Value[%v]", key), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + } + + if len(errors) > 0 { + return PartitionsMultiError(errors) + } + + return nil +} + +// PartitionsMultiError is an error wrapping multiple validation errors +// returned by Partitions.ValidateAll() if the designated constraints aren't met. +type PartitionsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PartitionsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PartitionsMultiError) AllErrors() []error { return m } + +// PartitionsValidationError is the validation error returned by +// Partitions.Validate if the designated constraints aren't met. +type PartitionsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PartitionsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PartitionsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PartitionsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PartitionsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PartitionsValidationError) ErrorName() string { return "PartitionsValidationError" } + +// Error satisfies the builtin error interface +func (e PartitionsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPartitions.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PartitionsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PartitionsValidationError{} + +// Validate checks the field values on TimePartition with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TimePartition) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TimePartition with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TimePartitionMultiError, or +// nil if none found. +func (m *TimePartition) ValidateAll() error { + return m.validate(true) +} + +func (m *TimePartition) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetValue()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TimePartitionValidationError{ + field: "Value", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TimePartitionValidationError{ + field: "Value", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetValue()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TimePartitionValidationError{ + field: "Value", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Granularity + + if len(errors) > 0 { + return TimePartitionMultiError(errors) + } + + return nil +} + +// TimePartitionMultiError is an error wrapping multiple validation errors +// returned by TimePartition.ValidateAll() if the designated constraints +// aren't met. +type TimePartitionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TimePartitionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TimePartitionMultiError) AllErrors() []error { return m } + +// TimePartitionValidationError is the validation error returned by +// TimePartition.Validate if the designated constraints aren't met. +type TimePartitionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TimePartitionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TimePartitionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TimePartitionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TimePartitionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TimePartitionValidationError) ErrorName() string { return "TimePartitionValidationError" } + +// Error satisfies the builtin error interface +func (e TimePartitionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTimePartition.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TimePartitionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TimePartitionValidationError{} + +// Validate checks the field values on ArtifactID with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ArtifactID) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ArtifactID with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ArtifactIDMultiError, or +// nil if none found. +func (m *ArtifactID) ValidateAll() error { + return m.validate(true) +} + +func (m *ArtifactID) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetArtifactKey()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ArtifactIDValidationError{ + field: "ArtifactKey", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ArtifactIDValidationError{ + field: "ArtifactKey", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetArtifactKey()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ArtifactIDValidationError{ + field: "ArtifactKey", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Version + + if all { + switch v := interface{}(m.GetPartitions()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ArtifactIDValidationError{ + field: "Partitions", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ArtifactIDValidationError{ + field: "Partitions", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetPartitions()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ArtifactIDValidationError{ + field: "Partitions", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetTimePartition()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ArtifactIDValidationError{ + field: "TimePartition", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ArtifactIDValidationError{ + field: "TimePartition", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTimePartition()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ArtifactIDValidationError{ + field: "TimePartition", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ArtifactIDMultiError(errors) + } + + return nil +} + +// ArtifactIDMultiError is an error wrapping multiple validation errors +// returned by ArtifactID.ValidateAll() if the designated constraints aren't met. +type ArtifactIDMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ArtifactIDMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ArtifactIDMultiError) AllErrors() []error { return m } + +// ArtifactIDValidationError is the validation error returned by +// ArtifactID.Validate if the designated constraints aren't met. +type ArtifactIDValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ArtifactIDValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ArtifactIDValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ArtifactIDValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ArtifactIDValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ArtifactIDValidationError) ErrorName() string { return "ArtifactIDValidationError" } + +// Error satisfies the builtin error interface +func (e ArtifactIDValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sArtifactID.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ArtifactIDValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ArtifactIDValidationError{} + +// Validate checks the field values on ArtifactTag with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ArtifactTag) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ArtifactTag with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ArtifactTagMultiError, or +// nil if none found. +func (m *ArtifactTag) ValidateAll() error { + return m.validate(true) +} + +func (m *ArtifactTag) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetArtifactKey()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ArtifactTagValidationError{ + field: "ArtifactKey", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ArtifactTagValidationError{ + field: "ArtifactKey", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetArtifactKey()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ArtifactTagValidationError{ + field: "ArtifactKey", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetValue()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ArtifactTagValidationError{ + field: "Value", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ArtifactTagValidationError{ + field: "Value", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetValue()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ArtifactTagValidationError{ + field: "Value", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ArtifactTagMultiError(errors) + } + + return nil +} + +// ArtifactTagMultiError is an error wrapping multiple validation errors +// returned by ArtifactTag.ValidateAll() if the designated constraints aren't met. +type ArtifactTagMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ArtifactTagMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ArtifactTagMultiError) AllErrors() []error { return m } + +// ArtifactTagValidationError is the validation error returned by +// ArtifactTag.Validate if the designated constraints aren't met. +type ArtifactTagValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ArtifactTagValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ArtifactTagValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ArtifactTagValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ArtifactTagValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ArtifactTagValidationError) ErrorName() string { return "ArtifactTagValidationError" } + +// Error satisfies the builtin error interface +func (e ArtifactTagValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sArtifactTag.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ArtifactTagValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ArtifactTagValidationError{} + +// Validate checks the field values on ArtifactQuery with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ArtifactQuery) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ArtifactQuery with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ArtifactQueryMultiError, or +// nil if none found. +func (m *ArtifactQuery) ValidateAll() error { + return m.validate(true) +} + +func (m *ArtifactQuery) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Identifier.(type) { + case *ArtifactQuery_ArtifactId: + if v == nil { + err := ArtifactQueryValidationError{ + field: "Identifier", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetArtifactId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ArtifactQueryValidationError{ + field: "ArtifactId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ArtifactQueryValidationError{ + field: "ArtifactId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetArtifactId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ArtifactQueryValidationError{ + field: "ArtifactId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *ArtifactQuery_ArtifactTag: + if v == nil { + err := ArtifactQueryValidationError{ + field: "Identifier", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetArtifactTag()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ArtifactQueryValidationError{ + field: "ArtifactTag", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ArtifactQueryValidationError{ + field: "ArtifactTag", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetArtifactTag()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ArtifactQueryValidationError{ + field: "ArtifactTag", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *ArtifactQuery_Uri: + if v == nil { + err := ArtifactQueryValidationError{ + field: "Identifier", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for Uri + case *ArtifactQuery_Binding: + if v == nil { + err := ArtifactQueryValidationError{ + field: "Identifier", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetBinding()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ArtifactQueryValidationError{ + field: "Binding", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ArtifactQueryValidationError{ + field: "Binding", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetBinding()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ArtifactQueryValidationError{ + field: "Binding", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return ArtifactQueryMultiError(errors) + } + + return nil +} + +// ArtifactQueryMultiError is an error wrapping multiple validation errors +// returned by ArtifactQuery.ValidateAll() if the designated constraints +// aren't met. +type ArtifactQueryMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ArtifactQueryMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ArtifactQueryMultiError) AllErrors() []error { return m } + +// ArtifactQueryValidationError is the validation error returned by +// ArtifactQuery.Validate if the designated constraints aren't met. +type ArtifactQueryValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ArtifactQueryValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ArtifactQueryValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ArtifactQueryValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ArtifactQueryValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ArtifactQueryValidationError) ErrorName() string { return "ArtifactQueryValidationError" } + +// Error satisfies the builtin error interface +func (e ArtifactQueryValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sArtifactQuery.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ArtifactQueryValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ArtifactQueryValidationError{} diff --git a/gen/go/flyteidl2/core/catalog.pb.go b/gen/go/flyteidl2/core/catalog.pb.go new file mode 100644 index 0000000000..c6b82dedcb --- /dev/null +++ b/gen/go/flyteidl2/core/catalog.pb.go @@ -0,0 +1,506 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/core/catalog.proto + +package core + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Indicates the status of CatalogCaching. The reason why this is not embedded in TaskNodeMetadata is, that we may use for other types of nodes as well in the future +type CatalogCacheStatus int32 + +const ( + // Used to indicate that caching was disabled + CatalogCacheStatus_CACHE_DISABLED CatalogCacheStatus = 0 + // Used to indicate that the cache lookup resulted in no matches + CatalogCacheStatus_CACHE_MISS CatalogCacheStatus = 1 + // used to indicate that the associated artifact was a result of a previous execution + CatalogCacheStatus_CACHE_HIT CatalogCacheStatus = 2 + // used to indicate that the resultant artifact was added to the cache + CatalogCacheStatus_CACHE_POPULATED CatalogCacheStatus = 3 + // Used to indicate that cache lookup failed because of an error + CatalogCacheStatus_CACHE_LOOKUP_FAILURE CatalogCacheStatus = 4 + // Used to indicate that cache lookup failed because of an error + CatalogCacheStatus_CACHE_PUT_FAILURE CatalogCacheStatus = 5 + // Used to indicate the cache lookup was skipped + CatalogCacheStatus_CACHE_SKIPPED CatalogCacheStatus = 6 + // Used to indicate that the cache was evicted + CatalogCacheStatus_CACHE_EVICTED CatalogCacheStatus = 7 +) + +// Enum value maps for CatalogCacheStatus. +var ( + CatalogCacheStatus_name = map[int32]string{ + 0: "CACHE_DISABLED", + 1: "CACHE_MISS", + 2: "CACHE_HIT", + 3: "CACHE_POPULATED", + 4: "CACHE_LOOKUP_FAILURE", + 5: "CACHE_PUT_FAILURE", + 6: "CACHE_SKIPPED", + 7: "CACHE_EVICTED", + } + CatalogCacheStatus_value = map[string]int32{ + "CACHE_DISABLED": 0, + "CACHE_MISS": 1, + "CACHE_HIT": 2, + "CACHE_POPULATED": 3, + "CACHE_LOOKUP_FAILURE": 4, + "CACHE_PUT_FAILURE": 5, + "CACHE_SKIPPED": 6, + "CACHE_EVICTED": 7, + } +) + +func (x CatalogCacheStatus) Enum() *CatalogCacheStatus { + p := new(CatalogCacheStatus) + *p = x + return p +} + +func (x CatalogCacheStatus) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (CatalogCacheStatus) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_catalog_proto_enumTypes[0].Descriptor() +} + +func (CatalogCacheStatus) Type() protoreflect.EnumType { + return &file_flyteidl2_core_catalog_proto_enumTypes[0] +} + +func (x CatalogCacheStatus) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use CatalogCacheStatus.Descriptor instead. +func (CatalogCacheStatus) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_catalog_proto_rawDescGZIP(), []int{0} +} + +// Indicates the status of a catalog reservation operation. +type CatalogReservation_Status int32 + +const ( + // Used to indicate that reservations are disabled + CatalogReservation_RESERVATION_DISABLED CatalogReservation_Status = 0 + // Used to indicate that a reservation was successfully acquired or extended + CatalogReservation_RESERVATION_ACQUIRED CatalogReservation_Status = 1 + // Used to indicate that an active reservation currently exists + CatalogReservation_RESERVATION_EXISTS CatalogReservation_Status = 2 + // Used to indicate that the reservation has been successfully released + CatalogReservation_RESERVATION_RELEASED CatalogReservation_Status = 3 + // Used to indicate that a reservation operation resulted in failure + CatalogReservation_RESERVATION_FAILURE CatalogReservation_Status = 4 +) + +// Enum value maps for CatalogReservation_Status. +var ( + CatalogReservation_Status_name = map[int32]string{ + 0: "RESERVATION_DISABLED", + 1: "RESERVATION_ACQUIRED", + 2: "RESERVATION_EXISTS", + 3: "RESERVATION_RELEASED", + 4: "RESERVATION_FAILURE", + } + CatalogReservation_Status_value = map[string]int32{ + "RESERVATION_DISABLED": 0, + "RESERVATION_ACQUIRED": 1, + "RESERVATION_EXISTS": 2, + "RESERVATION_RELEASED": 3, + "RESERVATION_FAILURE": 4, + } +) + +func (x CatalogReservation_Status) Enum() *CatalogReservation_Status { + p := new(CatalogReservation_Status) + *p = x + return p +} + +func (x CatalogReservation_Status) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (CatalogReservation_Status) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_catalog_proto_enumTypes[1].Descriptor() +} + +func (CatalogReservation_Status) Type() protoreflect.EnumType { + return &file_flyteidl2_core_catalog_proto_enumTypes[1] +} + +func (x CatalogReservation_Status) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use CatalogReservation_Status.Descriptor instead. +func (CatalogReservation_Status) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_catalog_proto_rawDescGZIP(), []int{2, 0} +} + +type CatalogArtifactTag struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Artifact ID is generated name + ArtifactId string `protobuf:"bytes,1,opt,name=artifact_id,json=artifactId,proto3" json:"artifact_id,omitempty"` + // Flyte computes the tag automatically, as the hash of the values + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *CatalogArtifactTag) Reset() { + *x = CatalogArtifactTag{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_catalog_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CatalogArtifactTag) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CatalogArtifactTag) ProtoMessage() {} + +func (x *CatalogArtifactTag) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_catalog_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CatalogArtifactTag.ProtoReflect.Descriptor instead. +func (*CatalogArtifactTag) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_catalog_proto_rawDescGZIP(), []int{0} +} + +func (x *CatalogArtifactTag) GetArtifactId() string { + if x != nil { + return x.ArtifactId + } + return "" +} + +func (x *CatalogArtifactTag) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +// Catalog artifact information with specific metadata +type CatalogMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Dataset ID in the catalog + DatasetId *Identifier `protobuf:"bytes,1,opt,name=dataset_id,json=datasetId,proto3" json:"dataset_id,omitempty"` + // Artifact tag in the catalog + ArtifactTag *CatalogArtifactTag `protobuf:"bytes,2,opt,name=artifact_tag,json=artifactTag,proto3" json:"artifact_tag,omitempty"` + // Optional: Source Execution identifier, if this dataset was generated by another execution in Flyte. This is a one-of field and will depend on the caching context + // + // Types that are assignable to SourceExecution: + // + // *CatalogMetadata_SourceTaskExecution + SourceExecution isCatalogMetadata_SourceExecution `protobuf_oneof:"source_execution"` +} + +func (x *CatalogMetadata) Reset() { + *x = CatalogMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_catalog_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CatalogMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CatalogMetadata) ProtoMessage() {} + +func (x *CatalogMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_catalog_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CatalogMetadata.ProtoReflect.Descriptor instead. +func (*CatalogMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_catalog_proto_rawDescGZIP(), []int{1} +} + +func (x *CatalogMetadata) GetDatasetId() *Identifier { + if x != nil { + return x.DatasetId + } + return nil +} + +func (x *CatalogMetadata) GetArtifactTag() *CatalogArtifactTag { + if x != nil { + return x.ArtifactTag + } + return nil +} + +func (m *CatalogMetadata) GetSourceExecution() isCatalogMetadata_SourceExecution { + if m != nil { + return m.SourceExecution + } + return nil +} + +func (x *CatalogMetadata) GetSourceTaskExecution() *TaskExecutionIdentifier { + if x, ok := x.GetSourceExecution().(*CatalogMetadata_SourceTaskExecution); ok { + return x.SourceTaskExecution + } + return nil +} + +type isCatalogMetadata_SourceExecution interface { + isCatalogMetadata_SourceExecution() +} + +type CatalogMetadata_SourceTaskExecution struct { + // Today we only support TaskExecutionIdentifier as a source, as catalog caching only works for task executions + SourceTaskExecution *TaskExecutionIdentifier `protobuf:"bytes,3,opt,name=source_task_execution,json=sourceTaskExecution,proto3,oneof"` +} + +func (*CatalogMetadata_SourceTaskExecution) isCatalogMetadata_SourceExecution() {} + +type CatalogReservation struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *CatalogReservation) Reset() { + *x = CatalogReservation{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_catalog_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CatalogReservation) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CatalogReservation) ProtoMessage() {} + +func (x *CatalogReservation) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_catalog_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CatalogReservation.ProtoReflect.Descriptor instead. +func (*CatalogReservation) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_catalog_proto_rawDescGZIP(), []int{2} +} + +var File_flyteidl2_core_catalog_proto protoreflect.FileDescriptor + +var file_flyteidl2_core_catalog_proto_rawDesc = []byte{ + 0x0a, 0x1c, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x1a, 0x1f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, + 0x49, 0x0a, 0x12, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, + 0x63, 0x74, 0x54, 0x61, 0x67, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, + 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x72, 0x74, 0x69, + 0x66, 0x61, 0x63, 0x74, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x86, 0x02, 0x0a, 0x0f, 0x43, + 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x39, + 0x0a, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x09, + 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x49, 0x64, 0x12, 0x45, 0x0a, 0x0c, 0x61, 0x72, 0x74, + 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x74, 0x61, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, + 0x54, 0x61, 0x67, 0x52, 0x0b, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x54, 0x61, 0x67, + 0x12, 0x5d, 0x0a, 0x15, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x74, 0x61, 0x73, 0x6b, 0x5f, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x13, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x42, + 0x12, 0x0a, 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x22, 0x9e, 0x01, 0x0a, 0x12, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x52, + 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x87, 0x01, 0x0a, 0x06, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x14, 0x52, 0x45, 0x53, 0x45, 0x52, 0x56, 0x41, + 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x49, 0x53, 0x41, 0x42, 0x4c, 0x45, 0x44, 0x10, 0x00, 0x12, + 0x18, 0x0a, 0x14, 0x52, 0x45, 0x53, 0x45, 0x52, 0x56, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, + 0x43, 0x51, 0x55, 0x49, 0x52, 0x45, 0x44, 0x10, 0x01, 0x12, 0x16, 0x0a, 0x12, 0x52, 0x45, 0x53, + 0x45, 0x52, 0x56, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x58, 0x49, 0x53, 0x54, 0x53, 0x10, + 0x02, 0x12, 0x18, 0x0a, 0x14, 0x52, 0x45, 0x53, 0x45, 0x52, 0x56, 0x41, 0x54, 0x49, 0x4f, 0x4e, + 0x5f, 0x52, 0x45, 0x4c, 0x45, 0x41, 0x53, 0x45, 0x44, 0x10, 0x03, 0x12, 0x17, 0x0a, 0x13, 0x52, + 0x45, 0x53, 0x45, 0x52, 0x56, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, + 0x52, 0x45, 0x10, 0x04, 0x2a, 0xb3, 0x01, 0x0a, 0x12, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, + 0x43, 0x61, 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x12, 0x0a, 0x0e, 0x43, + 0x41, 0x43, 0x48, 0x45, 0x5f, 0x44, 0x49, 0x53, 0x41, 0x42, 0x4c, 0x45, 0x44, 0x10, 0x00, 0x12, + 0x0e, 0x0a, 0x0a, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x4d, 0x49, 0x53, 0x53, 0x10, 0x01, 0x12, + 0x0d, 0x0a, 0x09, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x48, 0x49, 0x54, 0x10, 0x02, 0x12, 0x13, + 0x0a, 0x0f, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x50, 0x4f, 0x50, 0x55, 0x4c, 0x41, 0x54, 0x45, + 0x44, 0x10, 0x03, 0x12, 0x18, 0x0a, 0x14, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x4c, 0x4f, 0x4f, + 0x4b, 0x55, 0x50, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x10, 0x04, 0x12, 0x15, 0x0a, + 0x11, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x50, 0x55, 0x54, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, + 0x52, 0x45, 0x10, 0x05, 0x12, 0x11, 0x0a, 0x0d, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x53, 0x4b, + 0x49, 0x50, 0x50, 0x45, 0x44, 0x10, 0x06, 0x12, 0x11, 0x0a, 0x0d, 0x43, 0x41, 0x43, 0x48, 0x45, + 0x5f, 0x45, 0x56, 0x49, 0x43, 0x54, 0x45, 0x44, 0x10, 0x07, 0x42, 0xb1, 0x01, 0x0a, 0x12, 0x63, + 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x42, 0x0c, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, + 0x02, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, + 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x0e, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0xca, 0x02, + 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0xe2, + 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_core_catalog_proto_rawDescOnce sync.Once + file_flyteidl2_core_catalog_proto_rawDescData = file_flyteidl2_core_catalog_proto_rawDesc +) + +func file_flyteidl2_core_catalog_proto_rawDescGZIP() []byte { + file_flyteidl2_core_catalog_proto_rawDescOnce.Do(func() { + file_flyteidl2_core_catalog_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_core_catalog_proto_rawDescData) + }) + return file_flyteidl2_core_catalog_proto_rawDescData +} + +var file_flyteidl2_core_catalog_proto_enumTypes = make([]protoimpl.EnumInfo, 2) +var file_flyteidl2_core_catalog_proto_msgTypes = make([]protoimpl.MessageInfo, 3) +var file_flyteidl2_core_catalog_proto_goTypes = []interface{}{ + (CatalogCacheStatus)(0), // 0: flyteidl2.core.CatalogCacheStatus + (CatalogReservation_Status)(0), // 1: flyteidl2.core.CatalogReservation.Status + (*CatalogArtifactTag)(nil), // 2: flyteidl2.core.CatalogArtifactTag + (*CatalogMetadata)(nil), // 3: flyteidl2.core.CatalogMetadata + (*CatalogReservation)(nil), // 4: flyteidl2.core.CatalogReservation + (*Identifier)(nil), // 5: flyteidl2.core.Identifier + (*TaskExecutionIdentifier)(nil), // 6: flyteidl2.core.TaskExecutionIdentifier +} +var file_flyteidl2_core_catalog_proto_depIdxs = []int32{ + 5, // 0: flyteidl2.core.CatalogMetadata.dataset_id:type_name -> flyteidl2.core.Identifier + 2, // 1: flyteidl2.core.CatalogMetadata.artifact_tag:type_name -> flyteidl2.core.CatalogArtifactTag + 6, // 2: flyteidl2.core.CatalogMetadata.source_task_execution:type_name -> flyteidl2.core.TaskExecutionIdentifier + 3, // [3:3] is the sub-list for method output_type + 3, // [3:3] is the sub-list for method input_type + 3, // [3:3] is the sub-list for extension type_name + 3, // [3:3] is the sub-list for extension extendee + 0, // [0:3] is the sub-list for field type_name +} + +func init() { file_flyteidl2_core_catalog_proto_init() } +func file_flyteidl2_core_catalog_proto_init() { + if File_flyteidl2_core_catalog_proto != nil { + return + } + file_flyteidl2_core_identifier_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_core_catalog_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CatalogArtifactTag); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_catalog_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CatalogMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_catalog_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CatalogReservation); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_core_catalog_proto_msgTypes[1].OneofWrappers = []interface{}{ + (*CatalogMetadata_SourceTaskExecution)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_core_catalog_proto_rawDesc, + NumEnums: 2, + NumMessages: 3, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_core_catalog_proto_goTypes, + DependencyIndexes: file_flyteidl2_core_catalog_proto_depIdxs, + EnumInfos: file_flyteidl2_core_catalog_proto_enumTypes, + MessageInfos: file_flyteidl2_core_catalog_proto_msgTypes, + }.Build() + File_flyteidl2_core_catalog_proto = out.File + file_flyteidl2_core_catalog_proto_rawDesc = nil + file_flyteidl2_core_catalog_proto_goTypes = nil + file_flyteidl2_core_catalog_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/core/catalog.pb.validate.go b/gen/go/flyteidl2/core/catalog.pb.validate.go new file mode 100644 index 0000000000..21c94f0c68 --- /dev/null +++ b/gen/go/flyteidl2/core/catalog.pb.validate.go @@ -0,0 +1,448 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/core/catalog.proto + +package core + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on CatalogArtifactTag with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *CatalogArtifactTag) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CatalogArtifactTag with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CatalogArtifactTagMultiError, or nil if none found. +func (m *CatalogArtifactTag) ValidateAll() error { + return m.validate(true) +} + +func (m *CatalogArtifactTag) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ArtifactId + + // no validation rules for Name + + if len(errors) > 0 { + return CatalogArtifactTagMultiError(errors) + } + + return nil +} + +// CatalogArtifactTagMultiError is an error wrapping multiple validation errors +// returned by CatalogArtifactTag.ValidateAll() if the designated constraints +// aren't met. +type CatalogArtifactTagMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CatalogArtifactTagMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CatalogArtifactTagMultiError) AllErrors() []error { return m } + +// CatalogArtifactTagValidationError is the validation error returned by +// CatalogArtifactTag.Validate if the designated constraints aren't met. +type CatalogArtifactTagValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CatalogArtifactTagValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CatalogArtifactTagValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CatalogArtifactTagValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CatalogArtifactTagValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CatalogArtifactTagValidationError) ErrorName() string { + return "CatalogArtifactTagValidationError" +} + +// Error satisfies the builtin error interface +func (e CatalogArtifactTagValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCatalogArtifactTag.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CatalogArtifactTagValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CatalogArtifactTagValidationError{} + +// Validate checks the field values on CatalogMetadata with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *CatalogMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CatalogMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CatalogMetadataMultiError, or nil if none found. +func (m *CatalogMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *CatalogMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetDatasetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CatalogMetadataValidationError{ + field: "DatasetId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CatalogMetadataValidationError{ + field: "DatasetId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDatasetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CatalogMetadataValidationError{ + field: "DatasetId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetArtifactTag()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CatalogMetadataValidationError{ + field: "ArtifactTag", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CatalogMetadataValidationError{ + field: "ArtifactTag", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetArtifactTag()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CatalogMetadataValidationError{ + field: "ArtifactTag", + reason: "embedded message failed validation", + cause: err, + } + } + } + + switch v := m.SourceExecution.(type) { + case *CatalogMetadata_SourceTaskExecution: + if v == nil { + err := CatalogMetadataValidationError{ + field: "SourceExecution", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetSourceTaskExecution()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CatalogMetadataValidationError{ + field: "SourceTaskExecution", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CatalogMetadataValidationError{ + field: "SourceTaskExecution", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSourceTaskExecution()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CatalogMetadataValidationError{ + field: "SourceTaskExecution", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return CatalogMetadataMultiError(errors) + } + + return nil +} + +// CatalogMetadataMultiError is an error wrapping multiple validation errors +// returned by CatalogMetadata.ValidateAll() if the designated constraints +// aren't met. +type CatalogMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CatalogMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CatalogMetadataMultiError) AllErrors() []error { return m } + +// CatalogMetadataValidationError is the validation error returned by +// CatalogMetadata.Validate if the designated constraints aren't met. +type CatalogMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CatalogMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CatalogMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CatalogMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CatalogMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CatalogMetadataValidationError) ErrorName() string { return "CatalogMetadataValidationError" } + +// Error satisfies the builtin error interface +func (e CatalogMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCatalogMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CatalogMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CatalogMetadataValidationError{} + +// Validate checks the field values on CatalogReservation with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *CatalogReservation) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CatalogReservation with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CatalogReservationMultiError, or nil if none found. +func (m *CatalogReservation) ValidateAll() error { + return m.validate(true) +} + +func (m *CatalogReservation) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return CatalogReservationMultiError(errors) + } + + return nil +} + +// CatalogReservationMultiError is an error wrapping multiple validation errors +// returned by CatalogReservation.ValidateAll() if the designated constraints +// aren't met. +type CatalogReservationMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CatalogReservationMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CatalogReservationMultiError) AllErrors() []error { return m } + +// CatalogReservationValidationError is the validation error returned by +// CatalogReservation.Validate if the designated constraints aren't met. +type CatalogReservationValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CatalogReservationValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CatalogReservationValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CatalogReservationValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CatalogReservationValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CatalogReservationValidationError) ErrorName() string { + return "CatalogReservationValidationError" +} + +// Error satisfies the builtin error interface +func (e CatalogReservationValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCatalogReservation.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CatalogReservationValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CatalogReservationValidationError{} diff --git a/gen/go/flyteidl2/core/errors.pb.go b/gen/go/flyteidl2/core/errors.pb.go new file mode 100644 index 0000000000..a9eedf30a5 --- /dev/null +++ b/gen/go/flyteidl2/core/errors.pb.go @@ -0,0 +1,320 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/core/errors.proto + +package core + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Defines a generic error type that dictates the behavior of the retry strategy. +type ContainerError_Kind int32 + +const ( + ContainerError_NON_RECOVERABLE ContainerError_Kind = 0 + ContainerError_RECOVERABLE ContainerError_Kind = 1 +) + +// Enum value maps for ContainerError_Kind. +var ( + ContainerError_Kind_name = map[int32]string{ + 0: "NON_RECOVERABLE", + 1: "RECOVERABLE", + } + ContainerError_Kind_value = map[string]int32{ + "NON_RECOVERABLE": 0, + "RECOVERABLE": 1, + } +) + +func (x ContainerError_Kind) Enum() *ContainerError_Kind { + p := new(ContainerError_Kind) + *p = x + return p +} + +func (x ContainerError_Kind) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ContainerError_Kind) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_errors_proto_enumTypes[0].Descriptor() +} + +func (ContainerError_Kind) Type() protoreflect.EnumType { + return &file_flyteidl2_core_errors_proto_enumTypes[0] +} + +func (x ContainerError_Kind) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use ContainerError_Kind.Descriptor instead. +func (ContainerError_Kind) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_errors_proto_rawDescGZIP(), []int{0, 0} +} + +// Error message to propagate detailed errors from container executions to the execution +// engine. +type ContainerError struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // A simplified code for errors, so that we can provide a glossary of all possible errors. + Code string `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"` + // A detailed error message. + Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` + // An abstract error kind for this error. Defaults to Non_Recoverable if not specified. + Kind ContainerError_Kind `protobuf:"varint,3,opt,name=kind,proto3,enum=flyteidl2.core.ContainerError_Kind" json:"kind,omitempty"` + // Defines the origin of the error (system, user, unknown). + Origin ExecutionError_ErrorKind `protobuf:"varint,4,opt,name=origin,proto3,enum=flyteidl2.core.ExecutionError_ErrorKind" json:"origin,omitempty"` +} + +func (x *ContainerError) Reset() { + *x = ContainerError{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_errors_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ContainerError) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ContainerError) ProtoMessage() {} + +func (x *ContainerError) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_errors_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ContainerError.ProtoReflect.Descriptor instead. +func (*ContainerError) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_errors_proto_rawDescGZIP(), []int{0} +} + +func (x *ContainerError) GetCode() string { + if x != nil { + return x.Code + } + return "" +} + +func (x *ContainerError) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +func (x *ContainerError) GetKind() ContainerError_Kind { + if x != nil { + return x.Kind + } + return ContainerError_NON_RECOVERABLE +} + +func (x *ContainerError) GetOrigin() ExecutionError_ErrorKind { + if x != nil { + return x.Origin + } + return ExecutionError_UNKNOWN +} + +// Defines the errors.pb file format the container can produce to communicate +// failure reasons to the execution engine. +type ErrorDocument struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The error raised during execution. + Error *ContainerError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` +} + +func (x *ErrorDocument) Reset() { + *x = ErrorDocument{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_errors_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ErrorDocument) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ErrorDocument) ProtoMessage() {} + +func (x *ErrorDocument) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_errors_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ErrorDocument.ProtoReflect.Descriptor instead. +func (*ErrorDocument) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_errors_proto_rawDescGZIP(), []int{1} +} + +func (x *ErrorDocument) GetError() *ContainerError { + if x != nil { + return x.Error + } + return nil +} + +var File_flyteidl2_core_errors_proto protoreflect.FileDescriptor + +var file_flyteidl2_core_errors_proto_rawDesc = []byte{ + 0x0a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x1a, 0x1e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xe7, 0x01, + 0x0a, 0x0e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x45, 0x72, 0x72, 0x6f, 0x72, + 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x63, 0x6f, 0x64, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x37, + 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x2e, 0x4b, 0x69, 0x6e, + 0x64, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x40, 0x0a, 0x06, 0x6f, 0x72, 0x69, 0x67, 0x69, + 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x4b, 0x69, 0x6e, + 0x64, 0x52, 0x06, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x22, 0x2c, 0x0a, 0x04, 0x4b, 0x69, 0x6e, + 0x64, 0x12, 0x13, 0x0a, 0x0f, 0x4e, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x43, 0x4f, 0x56, 0x45, 0x52, + 0x41, 0x42, 0x4c, 0x45, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x52, 0x45, 0x43, 0x4f, 0x56, 0x45, + 0x52, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x01, 0x22, 0x45, 0x0a, 0x0d, 0x45, 0x72, 0x72, 0x6f, 0x72, + 0x44, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x34, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, + 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x65, 0x72, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x42, 0xb0, + 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x42, 0x0b, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x50, 0x72, 0x6f, + 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, + 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x72, + 0x65, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, + 0x72, 0x65, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, + 0x6f, 0x72, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, + 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x72, + 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_core_errors_proto_rawDescOnce sync.Once + file_flyteidl2_core_errors_proto_rawDescData = file_flyteidl2_core_errors_proto_rawDesc +) + +func file_flyteidl2_core_errors_proto_rawDescGZIP() []byte { + file_flyteidl2_core_errors_proto_rawDescOnce.Do(func() { + file_flyteidl2_core_errors_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_core_errors_proto_rawDescData) + }) + return file_flyteidl2_core_errors_proto_rawDescData +} + +var file_flyteidl2_core_errors_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_flyteidl2_core_errors_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_flyteidl2_core_errors_proto_goTypes = []interface{}{ + (ContainerError_Kind)(0), // 0: flyteidl2.core.ContainerError.Kind + (*ContainerError)(nil), // 1: flyteidl2.core.ContainerError + (*ErrorDocument)(nil), // 2: flyteidl2.core.ErrorDocument + (ExecutionError_ErrorKind)(0), // 3: flyteidl2.core.ExecutionError.ErrorKind +} +var file_flyteidl2_core_errors_proto_depIdxs = []int32{ + 0, // 0: flyteidl2.core.ContainerError.kind:type_name -> flyteidl2.core.ContainerError.Kind + 3, // 1: flyteidl2.core.ContainerError.origin:type_name -> flyteidl2.core.ExecutionError.ErrorKind + 1, // 2: flyteidl2.core.ErrorDocument.error:type_name -> flyteidl2.core.ContainerError + 3, // [3:3] is the sub-list for method output_type + 3, // [3:3] is the sub-list for method input_type + 3, // [3:3] is the sub-list for extension type_name + 3, // [3:3] is the sub-list for extension extendee + 0, // [0:3] is the sub-list for field type_name +} + +func init() { file_flyteidl2_core_errors_proto_init() } +func file_flyteidl2_core_errors_proto_init() { + if File_flyteidl2_core_errors_proto != nil { + return + } + file_flyteidl2_core_execution_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_core_errors_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ContainerError); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_errors_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ErrorDocument); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_core_errors_proto_rawDesc, + NumEnums: 1, + NumMessages: 2, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_core_errors_proto_goTypes, + DependencyIndexes: file_flyteidl2_core_errors_proto_depIdxs, + EnumInfos: file_flyteidl2_core_errors_proto_enumTypes, + MessageInfos: file_flyteidl2_core_errors_proto_msgTypes, + }.Build() + File_flyteidl2_core_errors_proto = out.File + file_flyteidl2_core_errors_proto_rawDesc = nil + file_flyteidl2_core_errors_proto_goTypes = nil + file_flyteidl2_core_errors_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/core/errors.pb.validate.go b/gen/go/flyteidl2/core/errors.pb.validate.go new file mode 100644 index 0000000000..2b525ca42c --- /dev/null +++ b/gen/go/flyteidl2/core/errors.pb.validate.go @@ -0,0 +1,273 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/core/errors.proto + +package core + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on ContainerError with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ContainerError) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ContainerError with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ContainerErrorMultiError, +// or nil if none found. +func (m *ContainerError) ValidateAll() error { + return m.validate(true) +} + +func (m *ContainerError) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Code + + // no validation rules for Message + + // no validation rules for Kind + + // no validation rules for Origin + + if len(errors) > 0 { + return ContainerErrorMultiError(errors) + } + + return nil +} + +// ContainerErrorMultiError is an error wrapping multiple validation errors +// returned by ContainerError.ValidateAll() if the designated constraints +// aren't met. +type ContainerErrorMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ContainerErrorMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ContainerErrorMultiError) AllErrors() []error { return m } + +// ContainerErrorValidationError is the validation error returned by +// ContainerError.Validate if the designated constraints aren't met. +type ContainerErrorValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ContainerErrorValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ContainerErrorValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ContainerErrorValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ContainerErrorValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ContainerErrorValidationError) ErrorName() string { return "ContainerErrorValidationError" } + +// Error satisfies the builtin error interface +func (e ContainerErrorValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sContainerError.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ContainerErrorValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ContainerErrorValidationError{} + +// Validate checks the field values on ErrorDocument with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ErrorDocument) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ErrorDocument with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ErrorDocumentMultiError, or +// nil if none found. +func (m *ErrorDocument) ValidateAll() error { + return m.validate(true) +} + +func (m *ErrorDocument) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetError()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ErrorDocumentValidationError{ + field: "Error", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ErrorDocumentValidationError{ + field: "Error", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetError()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ErrorDocumentValidationError{ + field: "Error", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ErrorDocumentMultiError(errors) + } + + return nil +} + +// ErrorDocumentMultiError is an error wrapping multiple validation errors +// returned by ErrorDocument.ValidateAll() if the designated constraints +// aren't met. +type ErrorDocumentMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ErrorDocumentMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ErrorDocumentMultiError) AllErrors() []error { return m } + +// ErrorDocumentValidationError is the validation error returned by +// ErrorDocument.Validate if the designated constraints aren't met. +type ErrorDocumentValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ErrorDocumentValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ErrorDocumentValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ErrorDocumentValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ErrorDocumentValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ErrorDocumentValidationError) ErrorName() string { return "ErrorDocumentValidationError" } + +// Error satisfies the builtin error interface +func (e ErrorDocumentValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sErrorDocument.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ErrorDocumentValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ErrorDocumentValidationError{} diff --git a/gen/go/flyteidl2/core/execution.pb.go b/gen/go/flyteidl2/core/execution.pb.go new file mode 100644 index 0000000000..66949d25b6 --- /dev/null +++ b/gen/go/flyteidl2/core/execution.pb.go @@ -0,0 +1,1532 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/core/execution.proto + +package core + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + durationpb "google.golang.org/protobuf/types/known/durationpb" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type WorkflowExecution_Phase int32 + +const ( + WorkflowExecution_UNDEFINED WorkflowExecution_Phase = 0 + WorkflowExecution_QUEUED WorkflowExecution_Phase = 1 + WorkflowExecution_RUNNING WorkflowExecution_Phase = 2 + WorkflowExecution_SUCCEEDING WorkflowExecution_Phase = 3 + WorkflowExecution_SUCCEEDED WorkflowExecution_Phase = 4 + WorkflowExecution_FAILING WorkflowExecution_Phase = 5 + WorkflowExecution_FAILED WorkflowExecution_Phase = 6 + WorkflowExecution_ABORTED WorkflowExecution_Phase = 7 + WorkflowExecution_TIMED_OUT WorkflowExecution_Phase = 8 + WorkflowExecution_ABORTING WorkflowExecution_Phase = 9 +) + +// Enum value maps for WorkflowExecution_Phase. +var ( + WorkflowExecution_Phase_name = map[int32]string{ + 0: "UNDEFINED", + 1: "QUEUED", + 2: "RUNNING", + 3: "SUCCEEDING", + 4: "SUCCEEDED", + 5: "FAILING", + 6: "FAILED", + 7: "ABORTED", + 8: "TIMED_OUT", + 9: "ABORTING", + } + WorkflowExecution_Phase_value = map[string]int32{ + "UNDEFINED": 0, + "QUEUED": 1, + "RUNNING": 2, + "SUCCEEDING": 3, + "SUCCEEDED": 4, + "FAILING": 5, + "FAILED": 6, + "ABORTED": 7, + "TIMED_OUT": 8, + "ABORTING": 9, + } +) + +func (x WorkflowExecution_Phase) Enum() *WorkflowExecution_Phase { + p := new(WorkflowExecution_Phase) + *p = x + return p +} + +func (x WorkflowExecution_Phase) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (WorkflowExecution_Phase) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_execution_proto_enumTypes[0].Descriptor() +} + +func (WorkflowExecution_Phase) Type() protoreflect.EnumType { + return &file_flyteidl2_core_execution_proto_enumTypes[0] +} + +func (x WorkflowExecution_Phase) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use WorkflowExecution_Phase.Descriptor instead. +func (WorkflowExecution_Phase) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_execution_proto_rawDescGZIP(), []int{0, 0} +} + +type NodeExecution_Phase int32 + +const ( + NodeExecution_UNDEFINED NodeExecution_Phase = 0 + NodeExecution_QUEUED NodeExecution_Phase = 1 + NodeExecution_RUNNING NodeExecution_Phase = 2 + NodeExecution_SUCCEEDED NodeExecution_Phase = 3 + NodeExecution_FAILING NodeExecution_Phase = 4 + NodeExecution_FAILED NodeExecution_Phase = 5 + NodeExecution_ABORTED NodeExecution_Phase = 6 + NodeExecution_SKIPPED NodeExecution_Phase = 7 + NodeExecution_TIMED_OUT NodeExecution_Phase = 8 + NodeExecution_DYNAMIC_RUNNING NodeExecution_Phase = 9 + NodeExecution_RECOVERED NodeExecution_Phase = 10 +) + +// Enum value maps for NodeExecution_Phase. +var ( + NodeExecution_Phase_name = map[int32]string{ + 0: "UNDEFINED", + 1: "QUEUED", + 2: "RUNNING", + 3: "SUCCEEDED", + 4: "FAILING", + 5: "FAILED", + 6: "ABORTED", + 7: "SKIPPED", + 8: "TIMED_OUT", + 9: "DYNAMIC_RUNNING", + 10: "RECOVERED", + } + NodeExecution_Phase_value = map[string]int32{ + "UNDEFINED": 0, + "QUEUED": 1, + "RUNNING": 2, + "SUCCEEDED": 3, + "FAILING": 4, + "FAILED": 5, + "ABORTED": 6, + "SKIPPED": 7, + "TIMED_OUT": 8, + "DYNAMIC_RUNNING": 9, + "RECOVERED": 10, + } +) + +func (x NodeExecution_Phase) Enum() *NodeExecution_Phase { + p := new(NodeExecution_Phase) + *p = x + return p +} + +func (x NodeExecution_Phase) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (NodeExecution_Phase) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_execution_proto_enumTypes[1].Descriptor() +} + +func (NodeExecution_Phase) Type() protoreflect.EnumType { + return &file_flyteidl2_core_execution_proto_enumTypes[1] +} + +func (x NodeExecution_Phase) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use NodeExecution_Phase.Descriptor instead. +func (NodeExecution_Phase) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_execution_proto_rawDescGZIP(), []int{1, 0} +} + +type TaskExecution_Phase int32 + +const ( + TaskExecution_UNDEFINED TaskExecution_Phase = 0 + TaskExecution_QUEUED TaskExecution_Phase = 1 + TaskExecution_RUNNING TaskExecution_Phase = 2 + TaskExecution_SUCCEEDED TaskExecution_Phase = 3 + TaskExecution_ABORTED TaskExecution_Phase = 4 + TaskExecution_FAILED TaskExecution_Phase = 5 + // To indicate cases where task is initializing, like: ErrImagePull, ContainerCreating, PodInitializing + TaskExecution_INITIALIZING TaskExecution_Phase = 6 + // To address cases, where underlying resource is not available: Backoff error, Resource quota exceeded + TaskExecution_WAITING_FOR_RESOURCES TaskExecution_Phase = 7 + TaskExecution_RETRYABLE_FAILED TaskExecution_Phase = 8 +) + +// Enum value maps for TaskExecution_Phase. +var ( + TaskExecution_Phase_name = map[int32]string{ + 0: "UNDEFINED", + 1: "QUEUED", + 2: "RUNNING", + 3: "SUCCEEDED", + 4: "ABORTED", + 5: "FAILED", + 6: "INITIALIZING", + 7: "WAITING_FOR_RESOURCES", + 8: "RETRYABLE_FAILED", + } + TaskExecution_Phase_value = map[string]int32{ + "UNDEFINED": 0, + "QUEUED": 1, + "RUNNING": 2, + "SUCCEEDED": 3, + "ABORTED": 4, + "FAILED": 5, + "INITIALIZING": 6, + "WAITING_FOR_RESOURCES": 7, + "RETRYABLE_FAILED": 8, + } +) + +func (x TaskExecution_Phase) Enum() *TaskExecution_Phase { + p := new(TaskExecution_Phase) + *p = x + return p +} + +func (x TaskExecution_Phase) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (TaskExecution_Phase) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_execution_proto_enumTypes[2].Descriptor() +} + +func (TaskExecution_Phase) Type() protoreflect.EnumType { + return &file_flyteidl2_core_execution_proto_enumTypes[2] +} + +func (x TaskExecution_Phase) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use TaskExecution_Phase.Descriptor instead. +func (TaskExecution_Phase) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_execution_proto_rawDescGZIP(), []int{2, 0} +} + +// Error type: System or User +type ExecutionError_ErrorKind int32 + +const ( + ExecutionError_UNKNOWN ExecutionError_ErrorKind = 0 + ExecutionError_USER ExecutionError_ErrorKind = 1 + ExecutionError_SYSTEM ExecutionError_ErrorKind = 2 +) + +// Enum value maps for ExecutionError_ErrorKind. +var ( + ExecutionError_ErrorKind_name = map[int32]string{ + 0: "UNKNOWN", + 1: "USER", + 2: "SYSTEM", + } + ExecutionError_ErrorKind_value = map[string]int32{ + "UNKNOWN": 0, + "USER": 1, + "SYSTEM": 2, + } +) + +func (x ExecutionError_ErrorKind) Enum() *ExecutionError_ErrorKind { + p := new(ExecutionError_ErrorKind) + *p = x + return p +} + +func (x ExecutionError_ErrorKind) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ExecutionError_ErrorKind) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_execution_proto_enumTypes[3].Descriptor() +} + +func (ExecutionError_ErrorKind) Type() protoreflect.EnumType { + return &file_flyteidl2_core_execution_proto_enumTypes[3] +} + +func (x ExecutionError_ErrorKind) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use ExecutionError_ErrorKind.Descriptor instead. +func (ExecutionError_ErrorKind) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_execution_proto_rawDescGZIP(), []int{3, 0} +} + +type TaskLog_MessageFormat int32 + +const ( + TaskLog_UNKNOWN TaskLog_MessageFormat = 0 + TaskLog_CSV TaskLog_MessageFormat = 1 + TaskLog_JSON TaskLog_MessageFormat = 2 +) + +// Enum value maps for TaskLog_MessageFormat. +var ( + TaskLog_MessageFormat_name = map[int32]string{ + 0: "UNKNOWN", + 1: "CSV", + 2: "JSON", + } + TaskLog_MessageFormat_value = map[string]int32{ + "UNKNOWN": 0, + "CSV": 1, + "JSON": 2, + } +) + +func (x TaskLog_MessageFormat) Enum() *TaskLog_MessageFormat { + p := new(TaskLog_MessageFormat) + *p = x + return p +} + +func (x TaskLog_MessageFormat) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (TaskLog_MessageFormat) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_execution_proto_enumTypes[4].Descriptor() +} + +func (TaskLog_MessageFormat) Type() protoreflect.EnumType { + return &file_flyteidl2_core_execution_proto_enumTypes[4] +} + +func (x TaskLog_MessageFormat) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use TaskLog_MessageFormat.Descriptor instead. +func (TaskLog_MessageFormat) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_execution_proto_rawDescGZIP(), []int{4, 0} +} + +type TaskLog_LinkType int32 + +const ( + // The link for task log. For example, the aws cloudwatch logs, gcp stackdriver logs, etc. + TaskLog_EXTERNAL TaskLog_LinkType = 0 + // The link for spark UI, ray dashboard, etc. + TaskLog_DASHBOARD TaskLog_LinkType = 1 + // The link for vscode or other IDEs. + TaskLog_IDE TaskLog_LinkType = 2 +) + +// Enum value maps for TaskLog_LinkType. +var ( + TaskLog_LinkType_name = map[int32]string{ + 0: "EXTERNAL", + 1: "DASHBOARD", + 2: "IDE", + } + TaskLog_LinkType_value = map[string]int32{ + "EXTERNAL": 0, + "DASHBOARD": 1, + "IDE": 2, + } +) + +func (x TaskLog_LinkType) Enum() *TaskLog_LinkType { + p := new(TaskLog_LinkType) + *p = x + return p +} + +func (x TaskLog_LinkType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (TaskLog_LinkType) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_execution_proto_enumTypes[5].Descriptor() +} + +func (TaskLog_LinkType) Type() protoreflect.EnumType { + return &file_flyteidl2_core_execution_proto_enumTypes[5] +} + +func (x TaskLog_LinkType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use TaskLog_LinkType.Descriptor instead. +func (TaskLog_LinkType) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_execution_proto_rawDescGZIP(), []int{4, 1} +} + +type QualityOfService_Tier int32 + +const ( + // Default: no quality of service specified. + QualityOfService_UNDEFINED QualityOfService_Tier = 0 + QualityOfService_HIGH QualityOfService_Tier = 1 + QualityOfService_MEDIUM QualityOfService_Tier = 2 + QualityOfService_LOW QualityOfService_Tier = 3 +) + +// Enum value maps for QualityOfService_Tier. +var ( + QualityOfService_Tier_name = map[int32]string{ + 0: "UNDEFINED", + 1: "HIGH", + 2: "MEDIUM", + 3: "LOW", + } + QualityOfService_Tier_value = map[string]int32{ + "UNDEFINED": 0, + "HIGH": 1, + "MEDIUM": 2, + "LOW": 3, + } +) + +func (x QualityOfService_Tier) Enum() *QualityOfService_Tier { + p := new(QualityOfService_Tier) + *p = x + return p +} + +func (x QualityOfService_Tier) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (QualityOfService_Tier) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_execution_proto_enumTypes[6].Descriptor() +} + +func (QualityOfService_Tier) Type() protoreflect.EnumType { + return &file_flyteidl2_core_execution_proto_enumTypes[6] +} + +func (x QualityOfService_Tier) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use QualityOfService_Tier.Descriptor instead. +func (QualityOfService_Tier) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_execution_proto_rawDescGZIP(), []int{9, 0} +} + +// Indicates various phases of Workflow Execution +type WorkflowExecution struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *WorkflowExecution) Reset() { + *x = WorkflowExecution{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_execution_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WorkflowExecution) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorkflowExecution) ProtoMessage() {} + +func (x *WorkflowExecution) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_execution_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorkflowExecution.ProtoReflect.Descriptor instead. +func (*WorkflowExecution) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_execution_proto_rawDescGZIP(), []int{0} +} + +// Indicates various phases of Node Execution that only include the time spent to run the nodes/workflows +type NodeExecution struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *NodeExecution) Reset() { + *x = NodeExecution{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_execution_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NodeExecution) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NodeExecution) ProtoMessage() {} + +func (x *NodeExecution) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_execution_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NodeExecution.ProtoReflect.Descriptor instead. +func (*NodeExecution) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_execution_proto_rawDescGZIP(), []int{1} +} + +// Phases that task plugins can go through. Not all phases may be applicable to a specific plugin task, +// but this is the cumulative list that customers may want to know about for their task. +type TaskExecution struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *TaskExecution) Reset() { + *x = TaskExecution{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_execution_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskExecution) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskExecution) ProtoMessage() {} + +func (x *TaskExecution) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_execution_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskExecution.ProtoReflect.Descriptor instead. +func (*TaskExecution) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_execution_proto_rawDescGZIP(), []int{2} +} + +// Represents the error message from the execution. +type ExecutionError struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Error code indicates a grouping of a type of error. + // More Info: + Code string `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"` + // Detailed description of the error - including stack trace. + Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` + // Full error contents accessible via a URI + ErrorUri string `protobuf:"bytes,3,opt,name=error_uri,json=errorUri,proto3" json:"error_uri,omitempty"` + Kind ExecutionError_ErrorKind `protobuf:"varint,4,opt,name=kind,proto3,enum=flyteidl2.core.ExecutionError_ErrorKind" json:"kind,omitempty"` + // Timestamp of the error + Timestamp *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + // Worker that generated the error + Worker string `protobuf:"bytes,6,opt,name=worker,proto3" json:"worker,omitempty"` +} + +func (x *ExecutionError) Reset() { + *x = ExecutionError{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_execution_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ExecutionError) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExecutionError) ProtoMessage() {} + +func (x *ExecutionError) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_execution_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExecutionError.ProtoReflect.Descriptor instead. +func (*ExecutionError) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_execution_proto_rawDescGZIP(), []int{3} +} + +func (x *ExecutionError) GetCode() string { + if x != nil { + return x.Code + } + return "" +} + +func (x *ExecutionError) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +func (x *ExecutionError) GetErrorUri() string { + if x != nil { + return x.ErrorUri + } + return "" +} + +func (x *ExecutionError) GetKind() ExecutionError_ErrorKind { + if x != nil { + return x.Kind + } + return ExecutionError_UNKNOWN +} + +func (x *ExecutionError) GetTimestamp() *timestamppb.Timestamp { + if x != nil { + return x.Timestamp + } + return nil +} + +func (x *ExecutionError) GetWorker() string { + if x != nil { + return x.Worker + } + return "" +} + +// Log information for the task that is specific to a log sink +// When our log story is flushed out, we may have more metadata here like log link expiry +type TaskLog struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Uri string `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + MessageFormat TaskLog_MessageFormat `protobuf:"varint,3,opt,name=message_format,json=messageFormat,proto3,enum=flyteidl2.core.TaskLog_MessageFormat" json:"message_format,omitempty"` + Ttl *durationpb.Duration `protobuf:"bytes,4,opt,name=ttl,proto3" json:"ttl,omitempty"` + ShowWhilePending bool `protobuf:"varint,5,opt,name=ShowWhilePending,proto3" json:"ShowWhilePending,omitempty"` + HideOnceFinished bool `protobuf:"varint,6,opt,name=HideOnceFinished,proto3" json:"HideOnceFinished,omitempty"` + LinkType TaskLog_LinkType `protobuf:"varint,7,opt,name=link_type,json=linkType,proto3,enum=flyteidl2.core.TaskLog_LinkType" json:"link_type,omitempty"` + Ready bool `protobuf:"varint,8,opt,name=ready,proto3" json:"ready,omitempty"` + IconUri string `protobuf:"bytes,9,opt,name=icon_uri,json=iconUri,proto3" json:"icon_uri,omitempty"` +} + +func (x *TaskLog) Reset() { + *x = TaskLog{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_execution_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskLog) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskLog) ProtoMessage() {} + +func (x *TaskLog) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_execution_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskLog.ProtoReflect.Descriptor instead. +func (*TaskLog) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_execution_proto_rawDescGZIP(), []int{4} +} + +func (x *TaskLog) GetUri() string { + if x != nil { + return x.Uri + } + return "" +} + +func (x *TaskLog) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *TaskLog) GetMessageFormat() TaskLog_MessageFormat { + if x != nil { + return x.MessageFormat + } + return TaskLog_UNKNOWN +} + +func (x *TaskLog) GetTtl() *durationpb.Duration { + if x != nil { + return x.Ttl + } + return nil +} + +func (x *TaskLog) GetShowWhilePending() bool { + if x != nil { + return x.ShowWhilePending + } + return false +} + +func (x *TaskLog) GetHideOnceFinished() bool { + if x != nil { + return x.HideOnceFinished + } + return false +} + +func (x *TaskLog) GetLinkType() TaskLog_LinkType { + if x != nil { + return x.LinkType + } + return TaskLog_EXTERNAL +} + +func (x *TaskLog) GetReady() bool { + if x != nil { + return x.Ready + } + return false +} + +func (x *TaskLog) GetIconUri() string { + if x != nil { + return x.IconUri + } + return "" +} + +// Contains metadata required to identify logs produces by a set of pods +type LogContext struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Pods []*PodLogContext `protobuf:"bytes,1,rep,name=pods,proto3" json:"pods,omitempty"` + PrimaryPodName string `protobuf:"bytes,2,opt,name=primary_pod_name,json=primaryPodName,proto3" json:"primary_pod_name,omitempty"` +} + +func (x *LogContext) Reset() { + *x = LogContext{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_execution_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LogContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LogContext) ProtoMessage() {} + +func (x *LogContext) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_execution_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LogContext.ProtoReflect.Descriptor instead. +func (*LogContext) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_execution_proto_rawDescGZIP(), []int{5} +} + +func (x *LogContext) GetPods() []*PodLogContext { + if x != nil { + return x.Pods + } + return nil +} + +func (x *LogContext) GetPrimaryPodName() string { + if x != nil { + return x.PrimaryPodName + } + return "" +} + +// Contains metadata required to identify logs produces by a single pod +type PodLogContext struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"` + PodName string `protobuf:"bytes,2,opt,name=pod_name,json=podName,proto3" json:"pod_name,omitempty"` + Containers []*ContainerContext `protobuf:"bytes,3,rep,name=containers,proto3" json:"containers,omitempty"` + PrimaryContainerName string `protobuf:"bytes,4,opt,name=primary_container_name,json=primaryContainerName,proto3" json:"primary_container_name,omitempty"` + InitContainers []*ContainerContext `protobuf:"bytes,5,rep,name=init_containers,json=initContainers,proto3" json:"init_containers,omitempty"` +} + +func (x *PodLogContext) Reset() { + *x = PodLogContext{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_execution_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PodLogContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PodLogContext) ProtoMessage() {} + +func (x *PodLogContext) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_execution_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PodLogContext.ProtoReflect.Descriptor instead. +func (*PodLogContext) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_execution_proto_rawDescGZIP(), []int{6} +} + +func (x *PodLogContext) GetNamespace() string { + if x != nil { + return x.Namespace + } + return "" +} + +func (x *PodLogContext) GetPodName() string { + if x != nil { + return x.PodName + } + return "" +} + +func (x *PodLogContext) GetContainers() []*ContainerContext { + if x != nil { + return x.Containers + } + return nil +} + +func (x *PodLogContext) GetPrimaryContainerName() string { + if x != nil { + return x.PrimaryContainerName + } + return "" +} + +func (x *PodLogContext) GetInitContainers() []*ContainerContext { + if x != nil { + return x.InitContainers + } + return nil +} + +// Contains metadata required to identify logs produces by a single container +type ContainerContext struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ContainerName string `protobuf:"bytes,1,opt,name=container_name,json=containerName,proto3" json:"container_name,omitempty"` + Process *ContainerContext_ProcessContext `protobuf:"bytes,2,opt,name=process,proto3" json:"process,omitempty"` +} + +func (x *ContainerContext) Reset() { + *x = ContainerContext{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_execution_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ContainerContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ContainerContext) ProtoMessage() {} + +func (x *ContainerContext) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_execution_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ContainerContext.ProtoReflect.Descriptor instead. +func (*ContainerContext) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_execution_proto_rawDescGZIP(), []int{7} +} + +func (x *ContainerContext) GetContainerName() string { + if x != nil { + return x.ContainerName + } + return "" +} + +func (x *ContainerContext) GetProcess() *ContainerContext_ProcessContext { + if x != nil { + return x.Process + } + return nil +} + +// Represents customized execution run-time attributes. +type QualityOfServiceSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Indicates how much queueing delay an execution can tolerate. + QueueingBudget *durationpb.Duration `protobuf:"bytes,1,opt,name=queueing_budget,json=queueingBudget,proto3" json:"queueing_budget,omitempty"` +} + +func (x *QualityOfServiceSpec) Reset() { + *x = QualityOfServiceSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_execution_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QualityOfServiceSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QualityOfServiceSpec) ProtoMessage() {} + +func (x *QualityOfServiceSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_execution_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use QualityOfServiceSpec.ProtoReflect.Descriptor instead. +func (*QualityOfServiceSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_execution_proto_rawDescGZIP(), []int{8} +} + +func (x *QualityOfServiceSpec) GetQueueingBudget() *durationpb.Duration { + if x != nil { + return x.QueueingBudget + } + return nil +} + +// Indicates the priority of an execution. +type QualityOfService struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Designation: + // + // *QualityOfService_Tier_ + // *QualityOfService_Spec + Designation isQualityOfService_Designation `protobuf_oneof:"designation"` +} + +func (x *QualityOfService) Reset() { + *x = QualityOfService{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_execution_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QualityOfService) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QualityOfService) ProtoMessage() {} + +func (x *QualityOfService) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_execution_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use QualityOfService.ProtoReflect.Descriptor instead. +func (*QualityOfService) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_execution_proto_rawDescGZIP(), []int{9} +} + +func (m *QualityOfService) GetDesignation() isQualityOfService_Designation { + if m != nil { + return m.Designation + } + return nil +} + +func (x *QualityOfService) GetTier() QualityOfService_Tier { + if x, ok := x.GetDesignation().(*QualityOfService_Tier_); ok { + return x.Tier + } + return QualityOfService_UNDEFINED +} + +func (x *QualityOfService) GetSpec() *QualityOfServiceSpec { + if x, ok := x.GetDesignation().(*QualityOfService_Spec); ok { + return x.Spec + } + return nil +} + +type isQualityOfService_Designation interface { + isQualityOfService_Designation() +} + +type QualityOfService_Tier_ struct { + Tier QualityOfService_Tier `protobuf:"varint,1,opt,name=tier,proto3,enum=flyteidl2.core.QualityOfService_Tier,oneof"` +} + +type QualityOfService_Spec struct { + Spec *QualityOfServiceSpec `protobuf:"bytes,2,opt,name=spec,proto3,oneof"` +} + +func (*QualityOfService_Tier_) isQualityOfService_Designation() {} + +func (*QualityOfService_Spec) isQualityOfService_Designation() {} + +// Contains metadata required to identify logs produces by a single light-weight process that was run inside a container +type ContainerContext_ProcessContext struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ContainerStartTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=container_start_time,json=containerStartTime,proto3" json:"container_start_time,omitempty"` + ContainerEndTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=container_end_time,json=containerEndTime,proto3" json:"container_end_time,omitempty"` +} + +func (x *ContainerContext_ProcessContext) Reset() { + *x = ContainerContext_ProcessContext{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_execution_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ContainerContext_ProcessContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ContainerContext_ProcessContext) ProtoMessage() {} + +func (x *ContainerContext_ProcessContext) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_execution_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ContainerContext_ProcessContext.ProtoReflect.Descriptor instead. +func (*ContainerContext_ProcessContext) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_execution_proto_rawDescGZIP(), []int{7, 0} +} + +func (x *ContainerContext_ProcessContext) GetContainerStartTime() *timestamppb.Timestamp { + if x != nil { + return x.ContainerStartTime + } + return nil +} + +func (x *ContainerContext_ProcessContext) GetContainerEndTime() *timestamppb.Timestamp { + if x != nil { + return x.ContainerEndTime + } + return nil +} + +var File_flyteidl2_core_execution_proto protoreflect.FileDescriptor + +var file_flyteidl2_core_execution_proto_rawDesc = []byte{ + 0x0a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x12, 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x22, 0xa7, 0x01, 0x0a, 0x11, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x91, 0x01, 0x0a, 0x05, 0x50, 0x68, 0x61, 0x73, + 0x65, 0x12, 0x0d, 0x0a, 0x09, 0x55, 0x4e, 0x44, 0x45, 0x46, 0x49, 0x4e, 0x45, 0x44, 0x10, 0x00, + 0x12, 0x0a, 0x0a, 0x06, 0x51, 0x55, 0x45, 0x55, 0x45, 0x44, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, + 0x52, 0x55, 0x4e, 0x4e, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a, 0x53, 0x55, 0x43, + 0x43, 0x45, 0x45, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x03, 0x12, 0x0d, 0x0a, 0x09, 0x53, 0x55, 0x43, + 0x43, 0x45, 0x45, 0x44, 0x45, 0x44, 0x10, 0x04, 0x12, 0x0b, 0x0a, 0x07, 0x46, 0x41, 0x49, 0x4c, + 0x49, 0x4e, 0x47, 0x10, 0x05, 0x12, 0x0a, 0x0a, 0x06, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x10, + 0x06, 0x12, 0x0b, 0x0a, 0x07, 0x41, 0x42, 0x4f, 0x52, 0x54, 0x45, 0x44, 0x10, 0x07, 0x12, 0x0d, + 0x0a, 0x09, 0x54, 0x49, 0x4d, 0x45, 0x44, 0x5f, 0x4f, 0x55, 0x54, 0x10, 0x08, 0x12, 0x0c, 0x0a, + 0x08, 0x41, 0x42, 0x4f, 0x52, 0x54, 0x49, 0x4e, 0x47, 0x10, 0x09, 0x22, 0xb6, 0x01, 0x0a, 0x0d, + 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xa4, 0x01, + 0x0a, 0x05, 0x50, 0x68, 0x61, 0x73, 0x65, 0x12, 0x0d, 0x0a, 0x09, 0x55, 0x4e, 0x44, 0x45, 0x46, + 0x49, 0x4e, 0x45, 0x44, 0x10, 0x00, 0x12, 0x0a, 0x0a, 0x06, 0x51, 0x55, 0x45, 0x55, 0x45, 0x44, + 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x52, 0x55, 0x4e, 0x4e, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x12, + 0x0d, 0x0a, 0x09, 0x53, 0x55, 0x43, 0x43, 0x45, 0x45, 0x44, 0x45, 0x44, 0x10, 0x03, 0x12, 0x0b, + 0x0a, 0x07, 0x46, 0x41, 0x49, 0x4c, 0x49, 0x4e, 0x47, 0x10, 0x04, 0x12, 0x0a, 0x0a, 0x06, 0x46, + 0x41, 0x49, 0x4c, 0x45, 0x44, 0x10, 0x05, 0x12, 0x0b, 0x0a, 0x07, 0x41, 0x42, 0x4f, 0x52, 0x54, + 0x45, 0x44, 0x10, 0x06, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x4b, 0x49, 0x50, 0x50, 0x45, 0x44, 0x10, + 0x07, 0x12, 0x0d, 0x0a, 0x09, 0x54, 0x49, 0x4d, 0x45, 0x44, 0x5f, 0x4f, 0x55, 0x54, 0x10, 0x08, + 0x12, 0x13, 0x0a, 0x0f, 0x44, 0x59, 0x4e, 0x41, 0x4d, 0x49, 0x43, 0x5f, 0x52, 0x55, 0x4e, 0x4e, + 0x49, 0x4e, 0x47, 0x10, 0x09, 0x12, 0x0d, 0x0a, 0x09, 0x52, 0x45, 0x43, 0x4f, 0x56, 0x45, 0x52, + 0x45, 0x44, 0x10, 0x0a, 0x22, 0xac, 0x01, 0x0a, 0x0d, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x9a, 0x01, 0x0a, 0x05, 0x50, 0x68, 0x61, 0x73, 0x65, + 0x12, 0x0d, 0x0a, 0x09, 0x55, 0x4e, 0x44, 0x45, 0x46, 0x49, 0x4e, 0x45, 0x44, 0x10, 0x00, 0x12, + 0x0a, 0x0a, 0x06, 0x51, 0x55, 0x45, 0x55, 0x45, 0x44, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x52, + 0x55, 0x4e, 0x4e, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x12, 0x0d, 0x0a, 0x09, 0x53, 0x55, 0x43, 0x43, + 0x45, 0x45, 0x44, 0x45, 0x44, 0x10, 0x03, 0x12, 0x0b, 0x0a, 0x07, 0x41, 0x42, 0x4f, 0x52, 0x54, + 0x45, 0x44, 0x10, 0x04, 0x12, 0x0a, 0x0a, 0x06, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x10, 0x05, + 0x12, 0x10, 0x0a, 0x0c, 0x49, 0x4e, 0x49, 0x54, 0x49, 0x41, 0x4c, 0x49, 0x5a, 0x49, 0x4e, 0x47, + 0x10, 0x06, 0x12, 0x19, 0x0a, 0x15, 0x57, 0x41, 0x49, 0x54, 0x49, 0x4e, 0x47, 0x5f, 0x46, 0x4f, + 0x52, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x53, 0x10, 0x07, 0x12, 0x14, 0x0a, + 0x10, 0x52, 0x45, 0x54, 0x52, 0x59, 0x41, 0x42, 0x4c, 0x45, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x45, + 0x44, 0x10, 0x08, 0x22, 0x9b, 0x02, 0x0a, 0x0e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x75, 0x72, + 0x69, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x55, 0x72, + 0x69, 0x12, 0x3c, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x2e, + 0x45, 0x72, 0x72, 0x6f, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, + 0x38, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, + 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x16, 0x0a, 0x06, 0x77, 0x6f, 0x72, + 0x6b, 0x65, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x77, 0x6f, 0x72, 0x6b, 0x65, + 0x72, 0x22, 0x2e, 0x0a, 0x09, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x0b, + 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x55, + 0x53, 0x45, 0x52, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x10, + 0x02, 0x22, 0xd5, 0x03, 0x0a, 0x07, 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x12, 0x10, 0x0a, + 0x03, 0x75, 0x72, 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x69, 0x12, + 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x12, 0x4c, 0x0a, 0x0e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x66, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, + 0x6b, 0x4c, 0x6f, 0x67, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, + 0x61, 0x74, 0x52, 0x0d, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, + 0x74, 0x12, 0x2b, 0x0a, 0x03, 0x74, 0x74, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x03, 0x74, 0x74, 0x6c, 0x12, 0x2a, + 0x0a, 0x10, 0x53, 0x68, 0x6f, 0x77, 0x57, 0x68, 0x69, 0x6c, 0x65, 0x50, 0x65, 0x6e, 0x64, 0x69, + 0x6e, 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x53, 0x68, 0x6f, 0x77, 0x57, 0x68, + 0x69, 0x6c, 0x65, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x2a, 0x0a, 0x10, 0x48, 0x69, + 0x64, 0x65, 0x4f, 0x6e, 0x63, 0x65, 0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x48, 0x69, 0x64, 0x65, 0x4f, 0x6e, 0x63, 0x65, 0x46, 0x69, + 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x12, 0x3d, 0x0a, 0x09, 0x6c, 0x69, 0x6e, 0x6b, 0x5f, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x4c, + 0x6f, 0x67, 0x2e, 0x4c, 0x69, 0x6e, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x52, 0x08, 0x6c, 0x69, 0x6e, + 0x6b, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x72, 0x65, 0x61, 0x64, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x69, + 0x63, 0x6f, 0x6e, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x69, + 0x63, 0x6f, 0x6e, 0x55, 0x72, 0x69, 0x22, 0x2f, 0x0a, 0x0d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, + 0x57, 0x4e, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x43, 0x53, 0x56, 0x10, 0x01, 0x12, 0x08, 0x0a, + 0x04, 0x4a, 0x53, 0x4f, 0x4e, 0x10, 0x02, 0x22, 0x30, 0x0a, 0x08, 0x4c, 0x69, 0x6e, 0x6b, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x0c, 0x0a, 0x08, 0x45, 0x58, 0x54, 0x45, 0x52, 0x4e, 0x41, 0x4c, 0x10, + 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x44, 0x41, 0x53, 0x48, 0x42, 0x4f, 0x41, 0x52, 0x44, 0x10, 0x01, + 0x12, 0x07, 0x0a, 0x03, 0x49, 0x44, 0x45, 0x10, 0x02, 0x22, 0x69, 0x0a, 0x0a, 0x4c, 0x6f, 0x67, + 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x31, 0x0a, 0x04, 0x70, 0x6f, 0x64, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x50, 0x6f, 0x64, 0x4c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, + 0x74, 0x65, 0x78, 0x74, 0x52, 0x04, 0x70, 0x6f, 0x64, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x70, 0x72, + 0x69, 0x6d, 0x61, 0x72, 0x79, 0x5f, 0x70, 0x6f, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x50, 0x6f, 0x64, + 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x8b, 0x02, 0x0a, 0x0d, 0x50, 0x6f, 0x64, 0x4c, 0x6f, 0x67, 0x43, + 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x70, 0x6f, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x6f, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x12, + 0x40, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x03, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x43, 0x6f, + 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x73, 0x12, 0x34, 0x0a, 0x16, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x5f, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x14, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x49, 0x0a, 0x0f, 0x69, 0x6e, 0x69, 0x74, 0x5f, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x74, 0x65, + 0x78, 0x74, 0x52, 0x0e, 0x69, 0x6e, 0x69, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, + 0x72, 0x73, 0x22, 0xaf, 0x02, 0x0a, 0x10, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x49, + 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x2f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, + 0x74, 0x2e, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, + 0x52, 0x07, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x1a, 0xa8, 0x01, 0x0a, 0x0e, 0x50, 0x72, + 0x6f, 0x63, 0x65, 0x73, 0x73, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x4c, 0x0a, 0x14, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, + 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x12, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, + 0x72, 0x53, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x48, 0x0a, 0x12, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x52, 0x10, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x45, 0x6e, 0x64, + 0x54, 0x69, 0x6d, 0x65, 0x22, 0x5a, 0x0a, 0x14, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x4f, + 0x66, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x53, 0x70, 0x65, 0x63, 0x12, 0x42, 0x0a, 0x0f, + 0x71, 0x75, 0x65, 0x75, 0x65, 0x69, 0x6e, 0x67, 0x5f, 0x62, 0x75, 0x64, 0x67, 0x65, 0x74, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x0e, 0x71, 0x75, 0x65, 0x75, 0x65, 0x69, 0x6e, 0x67, 0x42, 0x75, 0x64, 0x67, 0x65, 0x74, + 0x22, 0xd0, 0x01, 0x0a, 0x10, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x4f, 0x66, 0x53, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x3b, 0x0a, 0x04, 0x74, 0x69, 0x65, 0x72, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x4f, 0x66, 0x53, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x54, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x04, 0x74, 0x69, + 0x65, 0x72, 0x12, 0x3a, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x4f, 0x66, 0x53, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x53, 0x70, 0x65, 0x63, 0x48, 0x00, 0x52, 0x04, 0x73, 0x70, 0x65, 0x63, 0x22, 0x34, + 0x0a, 0x04, 0x54, 0x69, 0x65, 0x72, 0x12, 0x0d, 0x0a, 0x09, 0x55, 0x4e, 0x44, 0x45, 0x46, 0x49, + 0x4e, 0x45, 0x44, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x48, 0x49, 0x47, 0x48, 0x10, 0x01, 0x12, + 0x0a, 0x0a, 0x06, 0x4d, 0x45, 0x44, 0x49, 0x55, 0x4d, 0x10, 0x02, 0x12, 0x07, 0x0a, 0x03, 0x4c, + 0x4f, 0x57, 0x10, 0x03, 0x42, 0x0d, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x42, 0xb3, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x42, 0x0e, 0x45, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x32, + 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, + 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, + 0x72, 0x65, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, +} + +var ( + file_flyteidl2_core_execution_proto_rawDescOnce sync.Once + file_flyteidl2_core_execution_proto_rawDescData = file_flyteidl2_core_execution_proto_rawDesc +) + +func file_flyteidl2_core_execution_proto_rawDescGZIP() []byte { + file_flyteidl2_core_execution_proto_rawDescOnce.Do(func() { + file_flyteidl2_core_execution_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_core_execution_proto_rawDescData) + }) + return file_flyteidl2_core_execution_proto_rawDescData +} + +var file_flyteidl2_core_execution_proto_enumTypes = make([]protoimpl.EnumInfo, 7) +var file_flyteidl2_core_execution_proto_msgTypes = make([]protoimpl.MessageInfo, 11) +var file_flyteidl2_core_execution_proto_goTypes = []interface{}{ + (WorkflowExecution_Phase)(0), // 0: flyteidl2.core.WorkflowExecution.Phase + (NodeExecution_Phase)(0), // 1: flyteidl2.core.NodeExecution.Phase + (TaskExecution_Phase)(0), // 2: flyteidl2.core.TaskExecution.Phase + (ExecutionError_ErrorKind)(0), // 3: flyteidl2.core.ExecutionError.ErrorKind + (TaskLog_MessageFormat)(0), // 4: flyteidl2.core.TaskLog.MessageFormat + (TaskLog_LinkType)(0), // 5: flyteidl2.core.TaskLog.LinkType + (QualityOfService_Tier)(0), // 6: flyteidl2.core.QualityOfService.Tier + (*WorkflowExecution)(nil), // 7: flyteidl2.core.WorkflowExecution + (*NodeExecution)(nil), // 8: flyteidl2.core.NodeExecution + (*TaskExecution)(nil), // 9: flyteidl2.core.TaskExecution + (*ExecutionError)(nil), // 10: flyteidl2.core.ExecutionError + (*TaskLog)(nil), // 11: flyteidl2.core.TaskLog + (*LogContext)(nil), // 12: flyteidl2.core.LogContext + (*PodLogContext)(nil), // 13: flyteidl2.core.PodLogContext + (*ContainerContext)(nil), // 14: flyteidl2.core.ContainerContext + (*QualityOfServiceSpec)(nil), // 15: flyteidl2.core.QualityOfServiceSpec + (*QualityOfService)(nil), // 16: flyteidl2.core.QualityOfService + (*ContainerContext_ProcessContext)(nil), // 17: flyteidl2.core.ContainerContext.ProcessContext + (*timestamppb.Timestamp)(nil), // 18: google.protobuf.Timestamp + (*durationpb.Duration)(nil), // 19: google.protobuf.Duration +} +var file_flyteidl2_core_execution_proto_depIdxs = []int32{ + 3, // 0: flyteidl2.core.ExecutionError.kind:type_name -> flyteidl2.core.ExecutionError.ErrorKind + 18, // 1: flyteidl2.core.ExecutionError.timestamp:type_name -> google.protobuf.Timestamp + 4, // 2: flyteidl2.core.TaskLog.message_format:type_name -> flyteidl2.core.TaskLog.MessageFormat + 19, // 3: flyteidl2.core.TaskLog.ttl:type_name -> google.protobuf.Duration + 5, // 4: flyteidl2.core.TaskLog.link_type:type_name -> flyteidl2.core.TaskLog.LinkType + 13, // 5: flyteidl2.core.LogContext.pods:type_name -> flyteidl2.core.PodLogContext + 14, // 6: flyteidl2.core.PodLogContext.containers:type_name -> flyteidl2.core.ContainerContext + 14, // 7: flyteidl2.core.PodLogContext.init_containers:type_name -> flyteidl2.core.ContainerContext + 17, // 8: flyteidl2.core.ContainerContext.process:type_name -> flyteidl2.core.ContainerContext.ProcessContext + 19, // 9: flyteidl2.core.QualityOfServiceSpec.queueing_budget:type_name -> google.protobuf.Duration + 6, // 10: flyteidl2.core.QualityOfService.tier:type_name -> flyteidl2.core.QualityOfService.Tier + 15, // 11: flyteidl2.core.QualityOfService.spec:type_name -> flyteidl2.core.QualityOfServiceSpec + 18, // 12: flyteidl2.core.ContainerContext.ProcessContext.container_start_time:type_name -> google.protobuf.Timestamp + 18, // 13: flyteidl2.core.ContainerContext.ProcessContext.container_end_time:type_name -> google.protobuf.Timestamp + 14, // [14:14] is the sub-list for method output_type + 14, // [14:14] is the sub-list for method input_type + 14, // [14:14] is the sub-list for extension type_name + 14, // [14:14] is the sub-list for extension extendee + 0, // [0:14] is the sub-list for field type_name +} + +func init() { file_flyteidl2_core_execution_proto_init() } +func file_flyteidl2_core_execution_proto_init() { + if File_flyteidl2_core_execution_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_core_execution_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WorkflowExecution); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_execution_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*NodeExecution); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_execution_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskExecution); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_execution_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ExecutionError); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_execution_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskLog); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_execution_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LogContext); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_execution_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PodLogContext); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_execution_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ContainerContext); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_execution_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QualityOfServiceSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_execution_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QualityOfService); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_execution_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ContainerContext_ProcessContext); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_core_execution_proto_msgTypes[9].OneofWrappers = []interface{}{ + (*QualityOfService_Tier_)(nil), + (*QualityOfService_Spec)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_core_execution_proto_rawDesc, + NumEnums: 7, + NumMessages: 11, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_core_execution_proto_goTypes, + DependencyIndexes: file_flyteidl2_core_execution_proto_depIdxs, + EnumInfos: file_flyteidl2_core_execution_proto_enumTypes, + MessageInfos: file_flyteidl2_core_execution_proto_msgTypes, + }.Build() + File_flyteidl2_core_execution_proto = out.File + file_flyteidl2_core_execution_proto_rawDesc = nil + file_flyteidl2_core_execution_proto_goTypes = nil + file_flyteidl2_core_execution_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/core/execution.pb.validate.go b/gen/go/flyteidl2/core/execution.pb.validate.go new file mode 100644 index 0000000000..4c4d6982c7 --- /dev/null +++ b/gen/go/flyteidl2/core/execution.pb.validate.go @@ -0,0 +1,1510 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/core/execution.proto + +package core + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on WorkflowExecution with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *WorkflowExecution) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WorkflowExecution with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// WorkflowExecutionMultiError, or nil if none found. +func (m *WorkflowExecution) ValidateAll() error { + return m.validate(true) +} + +func (m *WorkflowExecution) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return WorkflowExecutionMultiError(errors) + } + + return nil +} + +// WorkflowExecutionMultiError is an error wrapping multiple validation errors +// returned by WorkflowExecution.ValidateAll() if the designated constraints +// aren't met. +type WorkflowExecutionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WorkflowExecutionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WorkflowExecutionMultiError) AllErrors() []error { return m } + +// WorkflowExecutionValidationError is the validation error returned by +// WorkflowExecution.Validate if the designated constraints aren't met. +type WorkflowExecutionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WorkflowExecutionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WorkflowExecutionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WorkflowExecutionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WorkflowExecutionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WorkflowExecutionValidationError) ErrorName() string { + return "WorkflowExecutionValidationError" +} + +// Error satisfies the builtin error interface +func (e WorkflowExecutionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWorkflowExecution.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WorkflowExecutionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WorkflowExecutionValidationError{} + +// Validate checks the field values on NodeExecution with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *NodeExecution) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on NodeExecution with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in NodeExecutionMultiError, or +// nil if none found. +func (m *NodeExecution) ValidateAll() error { + return m.validate(true) +} + +func (m *NodeExecution) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return NodeExecutionMultiError(errors) + } + + return nil +} + +// NodeExecutionMultiError is an error wrapping multiple validation errors +// returned by NodeExecution.ValidateAll() if the designated constraints +// aren't met. +type NodeExecutionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m NodeExecutionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m NodeExecutionMultiError) AllErrors() []error { return m } + +// NodeExecutionValidationError is the validation error returned by +// NodeExecution.Validate if the designated constraints aren't met. +type NodeExecutionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e NodeExecutionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e NodeExecutionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e NodeExecutionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e NodeExecutionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e NodeExecutionValidationError) ErrorName() string { return "NodeExecutionValidationError" } + +// Error satisfies the builtin error interface +func (e NodeExecutionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sNodeExecution.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = NodeExecutionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = NodeExecutionValidationError{} + +// Validate checks the field values on TaskExecution with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TaskExecution) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskExecution with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TaskExecutionMultiError, or +// nil if none found. +func (m *TaskExecution) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskExecution) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return TaskExecutionMultiError(errors) + } + + return nil +} + +// TaskExecutionMultiError is an error wrapping multiple validation errors +// returned by TaskExecution.ValidateAll() if the designated constraints +// aren't met. +type TaskExecutionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskExecutionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskExecutionMultiError) AllErrors() []error { return m } + +// TaskExecutionValidationError is the validation error returned by +// TaskExecution.Validate if the designated constraints aren't met. +type TaskExecutionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskExecutionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskExecutionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskExecutionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskExecutionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskExecutionValidationError) ErrorName() string { return "TaskExecutionValidationError" } + +// Error satisfies the builtin error interface +func (e TaskExecutionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskExecution.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskExecutionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskExecutionValidationError{} + +// Validate checks the field values on ExecutionError with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ExecutionError) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ExecutionError with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ExecutionErrorMultiError, +// or nil if none found. +func (m *ExecutionError) ValidateAll() error { + return m.validate(true) +} + +func (m *ExecutionError) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Code + + // no validation rules for Message + + // no validation rules for ErrorUri + + // no validation rules for Kind + + if all { + switch v := interface{}(m.GetTimestamp()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ExecutionErrorValidationError{ + field: "Timestamp", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ExecutionErrorValidationError{ + field: "Timestamp", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTimestamp()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ExecutionErrorValidationError{ + field: "Timestamp", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Worker + + if len(errors) > 0 { + return ExecutionErrorMultiError(errors) + } + + return nil +} + +// ExecutionErrorMultiError is an error wrapping multiple validation errors +// returned by ExecutionError.ValidateAll() if the designated constraints +// aren't met. +type ExecutionErrorMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ExecutionErrorMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ExecutionErrorMultiError) AllErrors() []error { return m } + +// ExecutionErrorValidationError is the validation error returned by +// ExecutionError.Validate if the designated constraints aren't met. +type ExecutionErrorValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ExecutionErrorValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ExecutionErrorValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ExecutionErrorValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ExecutionErrorValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ExecutionErrorValidationError) ErrorName() string { return "ExecutionErrorValidationError" } + +// Error satisfies the builtin error interface +func (e ExecutionErrorValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sExecutionError.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ExecutionErrorValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ExecutionErrorValidationError{} + +// Validate checks the field values on TaskLog with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TaskLog) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskLog with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in TaskLogMultiError, or nil if none found. +func (m *TaskLog) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskLog) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Uri + + // no validation rules for Name + + // no validation rules for MessageFormat + + if all { + switch v := interface{}(m.GetTtl()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskLogValidationError{ + field: "Ttl", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskLogValidationError{ + field: "Ttl", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTtl()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskLogValidationError{ + field: "Ttl", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for ShowWhilePending + + // no validation rules for HideOnceFinished + + // no validation rules for LinkType + + // no validation rules for Ready + + // no validation rules for IconUri + + if len(errors) > 0 { + return TaskLogMultiError(errors) + } + + return nil +} + +// TaskLogMultiError is an error wrapping multiple validation errors returned +// by TaskLog.ValidateAll() if the designated constraints aren't met. +type TaskLogMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskLogMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskLogMultiError) AllErrors() []error { return m } + +// TaskLogValidationError is the validation error returned by TaskLog.Validate +// if the designated constraints aren't met. +type TaskLogValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskLogValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskLogValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskLogValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskLogValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskLogValidationError) ErrorName() string { return "TaskLogValidationError" } + +// Error satisfies the builtin error interface +func (e TaskLogValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskLog.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskLogValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskLogValidationError{} + +// Validate checks the field values on LogContext with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *LogContext) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LogContext with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in LogContextMultiError, or +// nil if none found. +func (m *LogContext) ValidateAll() error { + return m.validate(true) +} + +func (m *LogContext) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetPods() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LogContextValidationError{ + field: fmt.Sprintf("Pods[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LogContextValidationError{ + field: fmt.Sprintf("Pods[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LogContextValidationError{ + field: fmt.Sprintf("Pods[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for PrimaryPodName + + if len(errors) > 0 { + return LogContextMultiError(errors) + } + + return nil +} + +// LogContextMultiError is an error wrapping multiple validation errors +// returned by LogContext.ValidateAll() if the designated constraints aren't met. +type LogContextMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LogContextMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LogContextMultiError) AllErrors() []error { return m } + +// LogContextValidationError is the validation error returned by +// LogContext.Validate if the designated constraints aren't met. +type LogContextValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LogContextValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LogContextValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LogContextValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LogContextValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LogContextValidationError) ErrorName() string { return "LogContextValidationError" } + +// Error satisfies the builtin error interface +func (e LogContextValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLogContext.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LogContextValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LogContextValidationError{} + +// Validate checks the field values on PodLogContext with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *PodLogContext) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on PodLogContext with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in PodLogContextMultiError, or +// nil if none found. +func (m *PodLogContext) ValidateAll() error { + return m.validate(true) +} + +func (m *PodLogContext) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Namespace + + // no validation rules for PodName + + for idx, item := range m.GetContainers() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PodLogContextValidationError{ + field: fmt.Sprintf("Containers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PodLogContextValidationError{ + field: fmt.Sprintf("Containers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PodLogContextValidationError{ + field: fmt.Sprintf("Containers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for PrimaryContainerName + + for idx, item := range m.GetInitContainers() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PodLogContextValidationError{ + field: fmt.Sprintf("InitContainers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PodLogContextValidationError{ + field: fmt.Sprintf("InitContainers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PodLogContextValidationError{ + field: fmt.Sprintf("InitContainers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return PodLogContextMultiError(errors) + } + + return nil +} + +// PodLogContextMultiError is an error wrapping multiple validation errors +// returned by PodLogContext.ValidateAll() if the designated constraints +// aren't met. +type PodLogContextMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PodLogContextMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PodLogContextMultiError) AllErrors() []error { return m } + +// PodLogContextValidationError is the validation error returned by +// PodLogContext.Validate if the designated constraints aren't met. +type PodLogContextValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PodLogContextValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PodLogContextValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PodLogContextValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PodLogContextValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PodLogContextValidationError) ErrorName() string { return "PodLogContextValidationError" } + +// Error satisfies the builtin error interface +func (e PodLogContextValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPodLogContext.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PodLogContextValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PodLogContextValidationError{} + +// Validate checks the field values on ContainerContext with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *ContainerContext) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ContainerContext with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ContainerContextMultiError, or nil if none found. +func (m *ContainerContext) ValidateAll() error { + return m.validate(true) +} + +func (m *ContainerContext) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ContainerName + + if all { + switch v := interface{}(m.GetProcess()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ContainerContextValidationError{ + field: "Process", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ContainerContextValidationError{ + field: "Process", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetProcess()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ContainerContextValidationError{ + field: "Process", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ContainerContextMultiError(errors) + } + + return nil +} + +// ContainerContextMultiError is an error wrapping multiple validation errors +// returned by ContainerContext.ValidateAll() if the designated constraints +// aren't met. +type ContainerContextMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ContainerContextMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ContainerContextMultiError) AllErrors() []error { return m } + +// ContainerContextValidationError is the validation error returned by +// ContainerContext.Validate if the designated constraints aren't met. +type ContainerContextValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ContainerContextValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ContainerContextValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ContainerContextValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ContainerContextValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ContainerContextValidationError) ErrorName() string { return "ContainerContextValidationError" } + +// Error satisfies the builtin error interface +func (e ContainerContextValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sContainerContext.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ContainerContextValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ContainerContextValidationError{} + +// Validate checks the field values on QualityOfServiceSpec with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *QualityOfServiceSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on QualityOfServiceSpec with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// QualityOfServiceSpecMultiError, or nil if none found. +func (m *QualityOfServiceSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *QualityOfServiceSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetQueueingBudget()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, QualityOfServiceSpecValidationError{ + field: "QueueingBudget", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, QualityOfServiceSpecValidationError{ + field: "QueueingBudget", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetQueueingBudget()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return QualityOfServiceSpecValidationError{ + field: "QueueingBudget", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return QualityOfServiceSpecMultiError(errors) + } + + return nil +} + +// QualityOfServiceSpecMultiError is an error wrapping multiple validation +// errors returned by QualityOfServiceSpec.ValidateAll() if the designated +// constraints aren't met. +type QualityOfServiceSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m QualityOfServiceSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m QualityOfServiceSpecMultiError) AllErrors() []error { return m } + +// QualityOfServiceSpecValidationError is the validation error returned by +// QualityOfServiceSpec.Validate if the designated constraints aren't met. +type QualityOfServiceSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e QualityOfServiceSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e QualityOfServiceSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e QualityOfServiceSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e QualityOfServiceSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e QualityOfServiceSpecValidationError) ErrorName() string { + return "QualityOfServiceSpecValidationError" +} + +// Error satisfies the builtin error interface +func (e QualityOfServiceSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sQualityOfServiceSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = QualityOfServiceSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = QualityOfServiceSpecValidationError{} + +// Validate checks the field values on QualityOfService with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *QualityOfService) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on QualityOfService with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// QualityOfServiceMultiError, or nil if none found. +func (m *QualityOfService) ValidateAll() error { + return m.validate(true) +} + +func (m *QualityOfService) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Designation.(type) { + case *QualityOfService_Tier_: + if v == nil { + err := QualityOfServiceValidationError{ + field: "Designation", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for Tier + case *QualityOfService_Spec: + if v == nil { + err := QualityOfServiceValidationError{ + field: "Designation", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, QualityOfServiceValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, QualityOfServiceValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return QualityOfServiceValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return QualityOfServiceMultiError(errors) + } + + return nil +} + +// QualityOfServiceMultiError is an error wrapping multiple validation errors +// returned by QualityOfService.ValidateAll() if the designated constraints +// aren't met. +type QualityOfServiceMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m QualityOfServiceMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m QualityOfServiceMultiError) AllErrors() []error { return m } + +// QualityOfServiceValidationError is the validation error returned by +// QualityOfService.Validate if the designated constraints aren't met. +type QualityOfServiceValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e QualityOfServiceValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e QualityOfServiceValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e QualityOfServiceValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e QualityOfServiceValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e QualityOfServiceValidationError) ErrorName() string { return "QualityOfServiceValidationError" } + +// Error satisfies the builtin error interface +func (e QualityOfServiceValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sQualityOfService.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = QualityOfServiceValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = QualityOfServiceValidationError{} + +// Validate checks the field values on ContainerContext_ProcessContext with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ContainerContext_ProcessContext) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ContainerContext_ProcessContext with +// the rules defined in the proto definition for this message. If any rules +// are violated, the result is a list of violation errors wrapped in +// ContainerContext_ProcessContextMultiError, or nil if none found. +func (m *ContainerContext_ProcessContext) ValidateAll() error { + return m.validate(true) +} + +func (m *ContainerContext_ProcessContext) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetContainerStartTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ContainerContext_ProcessContextValidationError{ + field: "ContainerStartTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ContainerContext_ProcessContextValidationError{ + field: "ContainerStartTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetContainerStartTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ContainerContext_ProcessContextValidationError{ + field: "ContainerStartTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetContainerEndTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ContainerContext_ProcessContextValidationError{ + field: "ContainerEndTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ContainerContext_ProcessContextValidationError{ + field: "ContainerEndTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetContainerEndTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ContainerContext_ProcessContextValidationError{ + field: "ContainerEndTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ContainerContext_ProcessContextMultiError(errors) + } + + return nil +} + +// ContainerContext_ProcessContextMultiError is an error wrapping multiple +// validation errors returned by ContainerContext_ProcessContext.ValidateAll() +// if the designated constraints aren't met. +type ContainerContext_ProcessContextMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ContainerContext_ProcessContextMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ContainerContext_ProcessContextMultiError) AllErrors() []error { return m } + +// ContainerContext_ProcessContextValidationError is the validation error +// returned by ContainerContext_ProcessContext.Validate if the designated +// constraints aren't met. +type ContainerContext_ProcessContextValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ContainerContext_ProcessContextValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ContainerContext_ProcessContextValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ContainerContext_ProcessContextValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ContainerContext_ProcessContextValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ContainerContext_ProcessContextValidationError) ErrorName() string { + return "ContainerContext_ProcessContextValidationError" +} + +// Error satisfies the builtin error interface +func (e ContainerContext_ProcessContextValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sContainerContext_ProcessContext.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ContainerContext_ProcessContextValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ContainerContext_ProcessContextValidationError{} diff --git a/gen/go/flyteidl2/core/identifier.pb.go b/gen/go/flyteidl2/core/identifier.pb.go new file mode 100644 index 0000000000..30bf70d800 --- /dev/null +++ b/gen/go/flyteidl2/core/identifier.pb.go @@ -0,0 +1,628 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/core/identifier.proto + +package core + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Indicates a resource type within Flyte. +type ResourceType int32 + +const ( + ResourceType_UNSPECIFIED ResourceType = 0 + ResourceType_TASK ResourceType = 1 + ResourceType_WORKFLOW ResourceType = 2 + ResourceType_LAUNCH_PLAN ResourceType = 3 + // A dataset represents an entity modeled in Flyte DataCatalog. A Dataset is also a versioned entity and can be a compilation of multiple individual objects. + // Eventually all Catalog objects should be modeled similar to Flyte Objects. The Dataset entities makes it possible for the UI and CLI to act on the objects + // in a similar manner to other Flyte objects + ResourceType_DATASET ResourceType = 4 +) + +// Enum value maps for ResourceType. +var ( + ResourceType_name = map[int32]string{ + 0: "UNSPECIFIED", + 1: "TASK", + 2: "WORKFLOW", + 3: "LAUNCH_PLAN", + 4: "DATASET", + } + ResourceType_value = map[string]int32{ + "UNSPECIFIED": 0, + "TASK": 1, + "WORKFLOW": 2, + "LAUNCH_PLAN": 3, + "DATASET": 4, + } +) + +func (x ResourceType) Enum() *ResourceType { + p := new(ResourceType) + *p = x + return p +} + +func (x ResourceType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ResourceType) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_identifier_proto_enumTypes[0].Descriptor() +} + +func (ResourceType) Type() protoreflect.EnumType { + return &file_flyteidl2_core_identifier_proto_enumTypes[0] +} + +func (x ResourceType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use ResourceType.Descriptor instead. +func (ResourceType) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_identifier_proto_rawDescGZIP(), []int{0} +} + +// Encapsulation of fields that uniquely identifies a Flyte resource. +type Identifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Identifies the specific type of resource that this identifier corresponds to. + ResourceType ResourceType `protobuf:"varint,1,opt,name=resource_type,json=resourceType,proto3,enum=flyteidl2.core.ResourceType" json:"resource_type,omitempty"` + // Name of the project the resource belongs to. + Project string `protobuf:"bytes,2,opt,name=project,proto3" json:"project,omitempty"` + // Name of the domain the resource belongs to. + // A domain can be considered as a subset within a specific project. + Domain string `protobuf:"bytes,3,opt,name=domain,proto3" json:"domain,omitempty"` + // User provided value for the resource. + Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"` + // Specific version of the resource. + Version string `protobuf:"bytes,5,opt,name=version,proto3" json:"version,omitempty"` + // Optional, org key applied to the resource. + Org string `protobuf:"bytes,6,opt,name=org,proto3" json:"org,omitempty"` +} + +func (x *Identifier) Reset() { + *x = Identifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_identifier_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Identifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Identifier) ProtoMessage() {} + +func (x *Identifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_identifier_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Identifier.ProtoReflect.Descriptor instead. +func (*Identifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_identifier_proto_rawDescGZIP(), []int{0} +} + +func (x *Identifier) GetResourceType() ResourceType { + if x != nil { + return x.ResourceType + } + return ResourceType_UNSPECIFIED +} + +func (x *Identifier) GetProject() string { + if x != nil { + return x.Project + } + return "" +} + +func (x *Identifier) GetDomain() string { + if x != nil { + return x.Domain + } + return "" +} + +func (x *Identifier) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Identifier) GetVersion() string { + if x != nil { + return x.Version + } + return "" +} + +func (x *Identifier) GetOrg() string { + if x != nil { + return x.Org + } + return "" +} + +// Encapsulation of fields that uniquely identifies a Flyte workflow execution +type WorkflowExecutionIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Name of the project the resource belongs to. + Project string `protobuf:"bytes,1,opt,name=project,proto3" json:"project,omitempty"` + // Name of the domain the resource belongs to. + // A domain can be considered as a subset within a specific project. + Domain string `protobuf:"bytes,2,opt,name=domain,proto3" json:"domain,omitempty"` + // User or system provided value for the resource. + Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"` + // Optional, org key applied to the resource. + Org string `protobuf:"bytes,5,opt,name=org,proto3" json:"org,omitempty"` +} + +func (x *WorkflowExecutionIdentifier) Reset() { + *x = WorkflowExecutionIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_identifier_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WorkflowExecutionIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorkflowExecutionIdentifier) ProtoMessage() {} + +func (x *WorkflowExecutionIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_identifier_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorkflowExecutionIdentifier.ProtoReflect.Descriptor instead. +func (*WorkflowExecutionIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_identifier_proto_rawDescGZIP(), []int{1} +} + +func (x *WorkflowExecutionIdentifier) GetProject() string { + if x != nil { + return x.Project + } + return "" +} + +func (x *WorkflowExecutionIdentifier) GetDomain() string { + if x != nil { + return x.Domain + } + return "" +} + +func (x *WorkflowExecutionIdentifier) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *WorkflowExecutionIdentifier) GetOrg() string { + if x != nil { + return x.Org + } + return "" +} + +// Encapsulation of fields that identify a Flyte node execution entity. +type NodeExecutionIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + NodeId string `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"` + ExecutionId *WorkflowExecutionIdentifier `protobuf:"bytes,2,opt,name=execution_id,json=executionId,proto3" json:"execution_id,omitempty"` +} + +func (x *NodeExecutionIdentifier) Reset() { + *x = NodeExecutionIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_identifier_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NodeExecutionIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NodeExecutionIdentifier) ProtoMessage() {} + +func (x *NodeExecutionIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_identifier_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NodeExecutionIdentifier.ProtoReflect.Descriptor instead. +func (*NodeExecutionIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_identifier_proto_rawDescGZIP(), []int{2} +} + +func (x *NodeExecutionIdentifier) GetNodeId() string { + if x != nil { + return x.NodeId + } + return "" +} + +func (x *NodeExecutionIdentifier) GetExecutionId() *WorkflowExecutionIdentifier { + if x != nil { + return x.ExecutionId + } + return nil +} + +// Encapsulation of fields that identify a Flyte task execution entity. +type TaskExecutionIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TaskId *Identifier `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"` + NodeExecutionId *NodeExecutionIdentifier `protobuf:"bytes,2,opt,name=node_execution_id,json=nodeExecutionId,proto3" json:"node_execution_id,omitempty"` + RetryAttempt uint32 `protobuf:"varint,3,opt,name=retry_attempt,json=retryAttempt,proto3" json:"retry_attempt,omitempty"` +} + +func (x *TaskExecutionIdentifier) Reset() { + *x = TaskExecutionIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_identifier_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskExecutionIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskExecutionIdentifier) ProtoMessage() {} + +func (x *TaskExecutionIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_identifier_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskExecutionIdentifier.ProtoReflect.Descriptor instead. +func (*TaskExecutionIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_identifier_proto_rawDescGZIP(), []int{3} +} + +func (x *TaskExecutionIdentifier) GetTaskId() *Identifier { + if x != nil { + return x.TaskId + } + return nil +} + +func (x *TaskExecutionIdentifier) GetNodeExecutionId() *NodeExecutionIdentifier { + if x != nil { + return x.NodeExecutionId + } + return nil +} + +func (x *TaskExecutionIdentifier) GetRetryAttempt() uint32 { + if x != nil { + return x.RetryAttempt + } + return 0 +} + +// Encapsulation of fields the uniquely identify a signal. +type SignalIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Unique identifier for a signal. + SignalId string `protobuf:"bytes,1,opt,name=signal_id,json=signalId,proto3" json:"signal_id,omitempty"` + // Identifies the Flyte workflow execution this signal belongs to. + ExecutionId *WorkflowExecutionIdentifier `protobuf:"bytes,2,opt,name=execution_id,json=executionId,proto3" json:"execution_id,omitempty"` +} + +func (x *SignalIdentifier) Reset() { + *x = SignalIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_identifier_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SignalIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SignalIdentifier) ProtoMessage() {} + +func (x *SignalIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_identifier_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SignalIdentifier.ProtoReflect.Descriptor instead. +func (*SignalIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_identifier_proto_rawDescGZIP(), []int{4} +} + +func (x *SignalIdentifier) GetSignalId() string { + if x != nil { + return x.SignalId + } + return "" +} + +func (x *SignalIdentifier) GetExecutionId() *WorkflowExecutionIdentifier { + if x != nil { + return x.ExecutionId + } + return nil +} + +var File_flyteidl2_core_identifier_proto protoreflect.FileDescriptor + +var file_flyteidl2_core_identifier_proto_rawDesc = []byte{ + 0x0a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x22, 0xc1, 0x01, 0x0a, 0x0a, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x12, 0x41, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x74, 0x79, 0x70, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x16, 0x0a, + 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x64, + 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x6f, 0x72, 0x67, 0x22, 0x75, 0x0a, 0x1b, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x16, + 0x0a, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6f, 0x72, + 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x22, 0x82, 0x01, 0x0a, + 0x17, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, + 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, + 0x64, 0x12, 0x4e, 0x0a, 0x0c, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, + 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x52, 0x0b, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, + 0x64, 0x22, 0xc8, 0x01, 0x0a, 0x17, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x33, 0x0a, + 0x07, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, + 0x49, 0x64, 0x12, 0x53, 0x0a, 0x11, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4e, + 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x74, 0x72, 0x79, + 0x5f, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, + 0x72, 0x65, 0x74, 0x72, 0x79, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x22, 0x7f, 0x0a, 0x10, + 0x53, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x4e, 0x0a, + 0x0c, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x52, 0x0b, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x2a, 0x55, 0x0a, + 0x0c, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0f, 0x0a, + 0x0b, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x08, + 0x0a, 0x04, 0x54, 0x41, 0x53, 0x4b, 0x10, 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x57, 0x4f, 0x52, 0x4b, + 0x46, 0x4c, 0x4f, 0x57, 0x10, 0x02, 0x12, 0x0f, 0x0a, 0x0b, 0x4c, 0x41, 0x55, 0x4e, 0x43, 0x48, + 0x5f, 0x50, 0x4c, 0x41, 0x4e, 0x10, 0x03, 0x12, 0x0b, 0x0a, 0x07, 0x44, 0x41, 0x54, 0x41, 0x53, + 0x45, 0x54, 0x10, 0x04, 0x42, 0xb4, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x42, 0x0f, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, + 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, + 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x63, 0x6f, 0x72, 0x65, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0xca, 0x02, 0x0e, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0xe2, 0x02, 0x1a, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x47, 0x50, + 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_core_identifier_proto_rawDescOnce sync.Once + file_flyteidl2_core_identifier_proto_rawDescData = file_flyteidl2_core_identifier_proto_rawDesc +) + +func file_flyteidl2_core_identifier_proto_rawDescGZIP() []byte { + file_flyteidl2_core_identifier_proto_rawDescOnce.Do(func() { + file_flyteidl2_core_identifier_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_core_identifier_proto_rawDescData) + }) + return file_flyteidl2_core_identifier_proto_rawDescData +} + +var file_flyteidl2_core_identifier_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_flyteidl2_core_identifier_proto_msgTypes = make([]protoimpl.MessageInfo, 5) +var file_flyteidl2_core_identifier_proto_goTypes = []interface{}{ + (ResourceType)(0), // 0: flyteidl2.core.ResourceType + (*Identifier)(nil), // 1: flyteidl2.core.Identifier + (*WorkflowExecutionIdentifier)(nil), // 2: flyteidl2.core.WorkflowExecutionIdentifier + (*NodeExecutionIdentifier)(nil), // 3: flyteidl2.core.NodeExecutionIdentifier + (*TaskExecutionIdentifier)(nil), // 4: flyteidl2.core.TaskExecutionIdentifier + (*SignalIdentifier)(nil), // 5: flyteidl2.core.SignalIdentifier +} +var file_flyteidl2_core_identifier_proto_depIdxs = []int32{ + 0, // 0: flyteidl2.core.Identifier.resource_type:type_name -> flyteidl2.core.ResourceType + 2, // 1: flyteidl2.core.NodeExecutionIdentifier.execution_id:type_name -> flyteidl2.core.WorkflowExecutionIdentifier + 1, // 2: flyteidl2.core.TaskExecutionIdentifier.task_id:type_name -> flyteidl2.core.Identifier + 3, // 3: flyteidl2.core.TaskExecutionIdentifier.node_execution_id:type_name -> flyteidl2.core.NodeExecutionIdentifier + 2, // 4: flyteidl2.core.SignalIdentifier.execution_id:type_name -> flyteidl2.core.WorkflowExecutionIdentifier + 5, // [5:5] is the sub-list for method output_type + 5, // [5:5] is the sub-list for method input_type + 5, // [5:5] is the sub-list for extension type_name + 5, // [5:5] is the sub-list for extension extendee + 0, // [0:5] is the sub-list for field type_name +} + +func init() { file_flyteidl2_core_identifier_proto_init() } +func file_flyteidl2_core_identifier_proto_init() { + if File_flyteidl2_core_identifier_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_core_identifier_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Identifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_identifier_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WorkflowExecutionIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_identifier_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*NodeExecutionIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_identifier_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskExecutionIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_identifier_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SignalIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_core_identifier_proto_rawDesc, + NumEnums: 1, + NumMessages: 5, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_core_identifier_proto_goTypes, + DependencyIndexes: file_flyteidl2_core_identifier_proto_depIdxs, + EnumInfos: file_flyteidl2_core_identifier_proto_enumTypes, + MessageInfos: file_flyteidl2_core_identifier_proto_msgTypes, + }.Build() + File_flyteidl2_core_identifier_proto = out.File + file_flyteidl2_core_identifier_proto_rawDesc = nil + file_flyteidl2_core_identifier_proto_goTypes = nil + file_flyteidl2_core_identifier_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/core/identifier.pb.validate.go b/gen/go/flyteidl2/core/identifier.pb.validate.go new file mode 100644 index 0000000000..0c9553b651 --- /dev/null +++ b/gen/go/flyteidl2/core/identifier.pb.validate.go @@ -0,0 +1,684 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/core/identifier.proto + +package core + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on Identifier with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Identifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Identifier with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in IdentifierMultiError, or +// nil if none found. +func (m *Identifier) ValidateAll() error { + return m.validate(true) +} + +func (m *Identifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ResourceType + + // no validation rules for Project + + // no validation rules for Domain + + // no validation rules for Name + + // no validation rules for Version + + // no validation rules for Org + + if len(errors) > 0 { + return IdentifierMultiError(errors) + } + + return nil +} + +// IdentifierMultiError is an error wrapping multiple validation errors +// returned by Identifier.ValidateAll() if the designated constraints aren't met. +type IdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m IdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m IdentifierMultiError) AllErrors() []error { return m } + +// IdentifierValidationError is the validation error returned by +// Identifier.Validate if the designated constraints aren't met. +type IdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e IdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e IdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e IdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e IdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e IdentifierValidationError) ErrorName() string { return "IdentifierValidationError" } + +// Error satisfies the builtin error interface +func (e IdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = IdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = IdentifierValidationError{} + +// Validate checks the field values on WorkflowExecutionIdentifier with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *WorkflowExecutionIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WorkflowExecutionIdentifier with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// WorkflowExecutionIdentifierMultiError, or nil if none found. +func (m *WorkflowExecutionIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *WorkflowExecutionIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Project + + // no validation rules for Domain + + // no validation rules for Name + + // no validation rules for Org + + if len(errors) > 0 { + return WorkflowExecutionIdentifierMultiError(errors) + } + + return nil +} + +// WorkflowExecutionIdentifierMultiError is an error wrapping multiple +// validation errors returned by WorkflowExecutionIdentifier.ValidateAll() if +// the designated constraints aren't met. +type WorkflowExecutionIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WorkflowExecutionIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WorkflowExecutionIdentifierMultiError) AllErrors() []error { return m } + +// WorkflowExecutionIdentifierValidationError is the validation error returned +// by WorkflowExecutionIdentifier.Validate if the designated constraints +// aren't met. +type WorkflowExecutionIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WorkflowExecutionIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WorkflowExecutionIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WorkflowExecutionIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WorkflowExecutionIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WorkflowExecutionIdentifierValidationError) ErrorName() string { + return "WorkflowExecutionIdentifierValidationError" +} + +// Error satisfies the builtin error interface +func (e WorkflowExecutionIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWorkflowExecutionIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WorkflowExecutionIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WorkflowExecutionIdentifierValidationError{} + +// Validate checks the field values on NodeExecutionIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *NodeExecutionIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on NodeExecutionIdentifier with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// NodeExecutionIdentifierMultiError, or nil if none found. +func (m *NodeExecutionIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *NodeExecutionIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for NodeId + + if all { + switch v := interface{}(m.GetExecutionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, NodeExecutionIdentifierValidationError{ + field: "ExecutionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, NodeExecutionIdentifierValidationError{ + field: "ExecutionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetExecutionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return NodeExecutionIdentifierValidationError{ + field: "ExecutionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return NodeExecutionIdentifierMultiError(errors) + } + + return nil +} + +// NodeExecutionIdentifierMultiError is an error wrapping multiple validation +// errors returned by NodeExecutionIdentifier.ValidateAll() if the designated +// constraints aren't met. +type NodeExecutionIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m NodeExecutionIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m NodeExecutionIdentifierMultiError) AllErrors() []error { return m } + +// NodeExecutionIdentifierValidationError is the validation error returned by +// NodeExecutionIdentifier.Validate if the designated constraints aren't met. +type NodeExecutionIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e NodeExecutionIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e NodeExecutionIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e NodeExecutionIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e NodeExecutionIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e NodeExecutionIdentifierValidationError) ErrorName() string { + return "NodeExecutionIdentifierValidationError" +} + +// Error satisfies the builtin error interface +func (e NodeExecutionIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sNodeExecutionIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = NodeExecutionIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = NodeExecutionIdentifierValidationError{} + +// Validate checks the field values on TaskExecutionIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *TaskExecutionIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskExecutionIdentifier with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TaskExecutionIdentifierMultiError, or nil if none found. +func (m *TaskExecutionIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskExecutionIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetTaskId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskExecutionIdentifierValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskExecutionIdentifierValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskExecutionIdentifierValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetNodeExecutionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskExecutionIdentifierValidationError{ + field: "NodeExecutionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskExecutionIdentifierValidationError{ + field: "NodeExecutionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetNodeExecutionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskExecutionIdentifierValidationError{ + field: "NodeExecutionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for RetryAttempt + + if len(errors) > 0 { + return TaskExecutionIdentifierMultiError(errors) + } + + return nil +} + +// TaskExecutionIdentifierMultiError is an error wrapping multiple validation +// errors returned by TaskExecutionIdentifier.ValidateAll() if the designated +// constraints aren't met. +type TaskExecutionIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskExecutionIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskExecutionIdentifierMultiError) AllErrors() []error { return m } + +// TaskExecutionIdentifierValidationError is the validation error returned by +// TaskExecutionIdentifier.Validate if the designated constraints aren't met. +type TaskExecutionIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskExecutionIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskExecutionIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskExecutionIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskExecutionIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskExecutionIdentifierValidationError) ErrorName() string { + return "TaskExecutionIdentifierValidationError" +} + +// Error satisfies the builtin error interface +func (e TaskExecutionIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskExecutionIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskExecutionIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskExecutionIdentifierValidationError{} + +// Validate checks the field values on SignalIdentifier with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *SignalIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on SignalIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// SignalIdentifierMultiError, or nil if none found. +func (m *SignalIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *SignalIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for SignalId + + if all { + switch v := interface{}(m.GetExecutionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SignalIdentifierValidationError{ + field: "ExecutionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SignalIdentifierValidationError{ + field: "ExecutionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetExecutionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SignalIdentifierValidationError{ + field: "ExecutionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return SignalIdentifierMultiError(errors) + } + + return nil +} + +// SignalIdentifierMultiError is an error wrapping multiple validation errors +// returned by SignalIdentifier.ValidateAll() if the designated constraints +// aren't met. +type SignalIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SignalIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SignalIdentifierMultiError) AllErrors() []error { return m } + +// SignalIdentifierValidationError is the validation error returned by +// SignalIdentifier.Validate if the designated constraints aren't met. +type SignalIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SignalIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SignalIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SignalIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SignalIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SignalIdentifierValidationError) ErrorName() string { return "SignalIdentifierValidationError" } + +// Error satisfies the builtin error interface +func (e SignalIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSignalIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SignalIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SignalIdentifierValidationError{} diff --git a/gen/go/flyteidl2/core/interface.pb.go b/gen/go/flyteidl2/core/interface.pb.go new file mode 100644 index 0000000000..697c44ae0b --- /dev/null +++ b/gen/go/flyteidl2/core/interface.pb.go @@ -0,0 +1,610 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/core/interface.proto + +package core + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Defines a strongly typed variable. +type Variable struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Variable literal type. + Type *LiteralType `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + // +optional string describing input variable + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + // +optional This object allows the user to specify how Artifacts are created. + // name, tag, partitions can be specified. The other fields (version and project/domain) are ignored. + ArtifactPartialId *ArtifactID `protobuf:"bytes,3,opt,name=artifact_partial_id,json=artifactPartialId,proto3" json:"artifact_partial_id,omitempty"` + ArtifactTag *ArtifactTag `protobuf:"bytes,4,opt,name=artifact_tag,json=artifactTag,proto3" json:"artifact_tag,omitempty"` +} + +func (x *Variable) Reset() { + *x = Variable{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_interface_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Variable) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Variable) ProtoMessage() {} + +func (x *Variable) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_interface_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Variable.ProtoReflect.Descriptor instead. +func (*Variable) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_interface_proto_rawDescGZIP(), []int{0} +} + +func (x *Variable) GetType() *LiteralType { + if x != nil { + return x.Type + } + return nil +} + +func (x *Variable) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +func (x *Variable) GetArtifactPartialId() *ArtifactID { + if x != nil { + return x.ArtifactPartialId + } + return nil +} + +func (x *Variable) GetArtifactTag() *ArtifactTag { + if x != nil { + return x.ArtifactTag + } + return nil +} + +// A map of Variables +type VariableMap struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Defines a map of variable names to variables. + Variables map[string]*Variable `protobuf:"bytes,1,rep,name=variables,proto3" json:"variables,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *VariableMap) Reset() { + *x = VariableMap{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_interface_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VariableMap) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VariableMap) ProtoMessage() {} + +func (x *VariableMap) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_interface_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VariableMap.ProtoReflect.Descriptor instead. +func (*VariableMap) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_interface_proto_rawDescGZIP(), []int{1} +} + +func (x *VariableMap) GetVariables() map[string]*Variable { + if x != nil { + return x.Variables + } + return nil +} + +// Defines strongly typed inputs and outputs. +type TypedInterface struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Inputs *VariableMap `protobuf:"bytes,1,opt,name=inputs,proto3" json:"inputs,omitempty"` + Outputs *VariableMap `protobuf:"bytes,2,opt,name=outputs,proto3" json:"outputs,omitempty"` +} + +func (x *TypedInterface) Reset() { + *x = TypedInterface{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_interface_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TypedInterface) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TypedInterface) ProtoMessage() {} + +func (x *TypedInterface) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_interface_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TypedInterface.ProtoReflect.Descriptor instead. +func (*TypedInterface) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_interface_proto_rawDescGZIP(), []int{2} +} + +func (x *TypedInterface) GetInputs() *VariableMap { + if x != nil { + return x.Inputs + } + return nil +} + +func (x *TypedInterface) GetOutputs() *VariableMap { + if x != nil { + return x.Outputs + } + return nil +} + +// A parameter is used as input to a launch plan and has +// the special ability to have a default value or mark itself as required. +type Parameter struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // +required Variable. Defines the type of the variable backing this parameter. + Var *Variable `protobuf:"bytes,1,opt,name=var,proto3" json:"var,omitempty"` + // +optional + // + // Types that are assignable to Behavior: + // + // *Parameter_Default + // *Parameter_Required + // *Parameter_ArtifactQuery + // *Parameter_ArtifactId + Behavior isParameter_Behavior `protobuf_oneof:"behavior"` +} + +func (x *Parameter) Reset() { + *x = Parameter{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_interface_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Parameter) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Parameter) ProtoMessage() {} + +func (x *Parameter) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_interface_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Parameter.ProtoReflect.Descriptor instead. +func (*Parameter) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_interface_proto_rawDescGZIP(), []int{3} +} + +func (x *Parameter) GetVar() *Variable { + if x != nil { + return x.Var + } + return nil +} + +func (m *Parameter) GetBehavior() isParameter_Behavior { + if m != nil { + return m.Behavior + } + return nil +} + +func (x *Parameter) GetDefault() *Literal { + if x, ok := x.GetBehavior().(*Parameter_Default); ok { + return x.Default + } + return nil +} + +func (x *Parameter) GetRequired() bool { + if x, ok := x.GetBehavior().(*Parameter_Required); ok { + return x.Required + } + return false +} + +func (x *Parameter) GetArtifactQuery() *ArtifactQuery { + if x, ok := x.GetBehavior().(*Parameter_ArtifactQuery); ok { + return x.ArtifactQuery + } + return nil +} + +func (x *Parameter) GetArtifactId() *ArtifactID { + if x, ok := x.GetBehavior().(*Parameter_ArtifactId); ok { + return x.ArtifactId + } + return nil +} + +type isParameter_Behavior interface { + isParameter_Behavior() +} + +type Parameter_Default struct { + // Defines a default value that has to match the variable type defined. + Default *Literal `protobuf:"bytes,2,opt,name=default,proto3,oneof"` +} + +type Parameter_Required struct { + // +optional, is this value required to be filled. + Required bool `protobuf:"varint,3,opt,name=required,proto3,oneof"` +} + +type Parameter_ArtifactQuery struct { + // This is an execution time search basically that should result in exactly one Artifact with a Type that + // matches the type of the variable. + ArtifactQuery *ArtifactQuery `protobuf:"bytes,4,opt,name=artifact_query,json=artifactQuery,proto3,oneof"` +} + +type Parameter_ArtifactId struct { + ArtifactId *ArtifactID `protobuf:"bytes,5,opt,name=artifact_id,json=artifactId,proto3,oneof"` +} + +func (*Parameter_Default) isParameter_Behavior() {} + +func (*Parameter_Required) isParameter_Behavior() {} + +func (*Parameter_ArtifactQuery) isParameter_Behavior() {} + +func (*Parameter_ArtifactId) isParameter_Behavior() {} + +// A map of Parameters. +type ParameterMap struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Defines a map of parameter names to parameters. + Parameters map[string]*Parameter `protobuf:"bytes,1,rep,name=parameters,proto3" json:"parameters,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *ParameterMap) Reset() { + *x = ParameterMap{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_interface_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ParameterMap) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ParameterMap) ProtoMessage() {} + +func (x *ParameterMap) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_interface_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ParameterMap.ProtoReflect.Descriptor instead. +func (*ParameterMap) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_interface_proto_rawDescGZIP(), []int{4} +} + +func (x *ParameterMap) GetParameters() map[string]*Parameter { + if x != nil { + return x.Parameters + } + return nil +} + +var File_flyteidl2_core_interface_proto protoreflect.FileDescriptor + +var file_flyteidl2_core_interface_proto_rawDesc = []byte{ + 0x0a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x12, 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x1a, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, + 0x72, 0x65, 0x2f, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, + 0x65, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xe9, 0x01, + 0x0a, 0x08, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x2f, 0x0a, 0x04, 0x74, 0x79, + 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, + 0x6c, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x4a, 0x0a, + 0x13, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, + 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, 0x69, + 0x66, 0x61, 0x63, 0x74, 0x49, 0x44, 0x52, 0x11, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, + 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x3e, 0x0a, 0x0c, 0x61, 0x72, 0x74, + 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x74, 0x61, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x54, 0x61, 0x67, 0x52, 0x0b, 0x61, 0x72, + 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x54, 0x61, 0x67, 0x22, 0xaf, 0x01, 0x0a, 0x0b, 0x56, 0x61, + 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x4d, 0x61, 0x70, 0x12, 0x48, 0x0a, 0x09, 0x76, 0x61, 0x72, + 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x56, 0x61, + 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x4d, 0x61, 0x70, 0x2e, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, + 0x6c, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x09, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, + 0x6c, 0x65, 0x73, 0x1a, 0x56, 0x0a, 0x0e, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x7c, 0x0a, 0x0e, 0x54, + 0x79, 0x70, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x12, 0x33, 0x0a, + 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x56, + 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x4d, 0x61, 0x70, 0x52, 0x06, 0x69, 0x6e, 0x70, 0x75, + 0x74, 0x73, 0x12, 0x35, 0x0a, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x4d, 0x61, 0x70, + 0x52, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x22, 0x9d, 0x02, 0x0a, 0x09, 0x50, 0x61, + 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x12, 0x2a, 0x0a, 0x03, 0x76, 0x61, 0x72, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x03, + 0x76, 0x61, 0x72, 0x12, 0x33, 0x0a, 0x07, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x48, 0x00, 0x52, + 0x07, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x12, 0x1c, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, + 0x69, 0x72, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x08, 0x72, 0x65, + 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x12, 0x46, 0x0a, 0x0e, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, + 0x63, 0x74, 0x5f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x48, 0x00, 0x52, + 0x0d, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x3d, + 0x0a, 0x0b, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x44, 0x48, + 0x00, 0x52, 0x0a, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x64, 0x42, 0x0a, 0x0a, + 0x08, 0x62, 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x22, 0xb6, 0x01, 0x0a, 0x0c, 0x50, 0x61, + 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x4d, 0x61, 0x70, 0x12, 0x4c, 0x0a, 0x0a, 0x70, 0x61, + 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x4d, 0x61, 0x70, 0x2e, 0x50, 0x61, 0x72, + 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x70, 0x61, + 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x1a, 0x58, 0x0a, 0x0f, 0x50, 0x61, 0x72, 0x61, + 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, + 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2f, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x50, 0x61, + 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x42, 0xb3, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x42, 0x0e, 0x49, 0x6e, 0x74, 0x65, 0x72, + 0x66, 0x61, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x32, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, + 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, + 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, + 0x65, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_core_interface_proto_rawDescOnce sync.Once + file_flyteidl2_core_interface_proto_rawDescData = file_flyteidl2_core_interface_proto_rawDesc +) + +func file_flyteidl2_core_interface_proto_rawDescGZIP() []byte { + file_flyteidl2_core_interface_proto_rawDescOnce.Do(func() { + file_flyteidl2_core_interface_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_core_interface_proto_rawDescData) + }) + return file_flyteidl2_core_interface_proto_rawDescData +} + +var file_flyteidl2_core_interface_proto_msgTypes = make([]protoimpl.MessageInfo, 7) +var file_flyteidl2_core_interface_proto_goTypes = []interface{}{ + (*Variable)(nil), // 0: flyteidl2.core.Variable + (*VariableMap)(nil), // 1: flyteidl2.core.VariableMap + (*TypedInterface)(nil), // 2: flyteidl2.core.TypedInterface + (*Parameter)(nil), // 3: flyteidl2.core.Parameter + (*ParameterMap)(nil), // 4: flyteidl2.core.ParameterMap + nil, // 5: flyteidl2.core.VariableMap.VariablesEntry + nil, // 6: flyteidl2.core.ParameterMap.ParametersEntry + (*LiteralType)(nil), // 7: flyteidl2.core.LiteralType + (*ArtifactID)(nil), // 8: flyteidl2.core.ArtifactID + (*ArtifactTag)(nil), // 9: flyteidl2.core.ArtifactTag + (*Literal)(nil), // 10: flyteidl2.core.Literal + (*ArtifactQuery)(nil), // 11: flyteidl2.core.ArtifactQuery +} +var file_flyteidl2_core_interface_proto_depIdxs = []int32{ + 7, // 0: flyteidl2.core.Variable.type:type_name -> flyteidl2.core.LiteralType + 8, // 1: flyteidl2.core.Variable.artifact_partial_id:type_name -> flyteidl2.core.ArtifactID + 9, // 2: flyteidl2.core.Variable.artifact_tag:type_name -> flyteidl2.core.ArtifactTag + 5, // 3: flyteidl2.core.VariableMap.variables:type_name -> flyteidl2.core.VariableMap.VariablesEntry + 1, // 4: flyteidl2.core.TypedInterface.inputs:type_name -> flyteidl2.core.VariableMap + 1, // 5: flyteidl2.core.TypedInterface.outputs:type_name -> flyteidl2.core.VariableMap + 0, // 6: flyteidl2.core.Parameter.var:type_name -> flyteidl2.core.Variable + 10, // 7: flyteidl2.core.Parameter.default:type_name -> flyteidl2.core.Literal + 11, // 8: flyteidl2.core.Parameter.artifact_query:type_name -> flyteidl2.core.ArtifactQuery + 8, // 9: flyteidl2.core.Parameter.artifact_id:type_name -> flyteidl2.core.ArtifactID + 6, // 10: flyteidl2.core.ParameterMap.parameters:type_name -> flyteidl2.core.ParameterMap.ParametersEntry + 0, // 11: flyteidl2.core.VariableMap.VariablesEntry.value:type_name -> flyteidl2.core.Variable + 3, // 12: flyteidl2.core.ParameterMap.ParametersEntry.value:type_name -> flyteidl2.core.Parameter + 13, // [13:13] is the sub-list for method output_type + 13, // [13:13] is the sub-list for method input_type + 13, // [13:13] is the sub-list for extension type_name + 13, // [13:13] is the sub-list for extension extendee + 0, // [0:13] is the sub-list for field type_name +} + +func init() { file_flyteidl2_core_interface_proto_init() } +func file_flyteidl2_core_interface_proto_init() { + if File_flyteidl2_core_interface_proto != nil { + return + } + file_flyteidl2_core_artifact_id_proto_init() + file_flyteidl2_core_literals_proto_init() + file_flyteidl2_core_types_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_core_interface_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Variable); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_interface_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VariableMap); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_interface_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TypedInterface); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_interface_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Parameter); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_interface_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ParameterMap); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_core_interface_proto_msgTypes[3].OneofWrappers = []interface{}{ + (*Parameter_Default)(nil), + (*Parameter_Required)(nil), + (*Parameter_ArtifactQuery)(nil), + (*Parameter_ArtifactId)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_core_interface_proto_rawDesc, + NumEnums: 0, + NumMessages: 7, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_core_interface_proto_goTypes, + DependencyIndexes: file_flyteidl2_core_interface_proto_depIdxs, + MessageInfos: file_flyteidl2_core_interface_proto_msgTypes, + }.Build() + File_flyteidl2_core_interface_proto = out.File + file_flyteidl2_core_interface_proto_rawDesc = nil + file_flyteidl2_core_interface_proto_goTypes = nil + file_flyteidl2_core_interface_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/core/interface.pb.validate.go b/gen/go/flyteidl2/core/interface.pb.validate.go new file mode 100644 index 0000000000..614090c8b1 --- /dev/null +++ b/gen/go/flyteidl2/core/interface.pb.validate.go @@ -0,0 +1,940 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/core/interface.proto + +package core + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on Variable with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Variable) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Variable with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in VariableMultiError, or nil +// if none found. +func (m *Variable) ValidateAll() error { + return m.validate(true) +} + +func (m *Variable) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetType()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, VariableValidationError{ + field: "Type", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, VariableValidationError{ + field: "Type", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetType()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return VariableValidationError{ + field: "Type", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Description + + if all { + switch v := interface{}(m.GetArtifactPartialId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, VariableValidationError{ + field: "ArtifactPartialId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, VariableValidationError{ + field: "ArtifactPartialId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetArtifactPartialId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return VariableValidationError{ + field: "ArtifactPartialId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetArtifactTag()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, VariableValidationError{ + field: "ArtifactTag", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, VariableValidationError{ + field: "ArtifactTag", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetArtifactTag()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return VariableValidationError{ + field: "ArtifactTag", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return VariableMultiError(errors) + } + + return nil +} + +// VariableMultiError is an error wrapping multiple validation errors returned +// by Variable.ValidateAll() if the designated constraints aren't met. +type VariableMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m VariableMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m VariableMultiError) AllErrors() []error { return m } + +// VariableValidationError is the validation error returned by +// Variable.Validate if the designated constraints aren't met. +type VariableValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e VariableValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e VariableValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e VariableValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e VariableValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e VariableValidationError) ErrorName() string { return "VariableValidationError" } + +// Error satisfies the builtin error interface +func (e VariableValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sVariable.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = VariableValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = VariableValidationError{} + +// Validate checks the field values on VariableMap with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *VariableMap) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on VariableMap with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in VariableMapMultiError, or +// nil if none found. +func (m *VariableMap) ValidateAll() error { + return m.validate(true) +} + +func (m *VariableMap) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + { + sorted_keys := make([]string, len(m.GetVariables())) + i := 0 + for key := range m.GetVariables() { + sorted_keys[i] = key + i++ + } + sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] }) + for _, key := range sorted_keys { + val := m.GetVariables()[key] + _ = val + + // no validation rules for Variables[key] + + if all { + switch v := interface{}(val).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, VariableMapValidationError{ + field: fmt.Sprintf("Variables[%v]", key), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, VariableMapValidationError{ + field: fmt.Sprintf("Variables[%v]", key), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(val).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return VariableMapValidationError{ + field: fmt.Sprintf("Variables[%v]", key), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + } + + if len(errors) > 0 { + return VariableMapMultiError(errors) + } + + return nil +} + +// VariableMapMultiError is an error wrapping multiple validation errors +// returned by VariableMap.ValidateAll() if the designated constraints aren't met. +type VariableMapMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m VariableMapMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m VariableMapMultiError) AllErrors() []error { return m } + +// VariableMapValidationError is the validation error returned by +// VariableMap.Validate if the designated constraints aren't met. +type VariableMapValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e VariableMapValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e VariableMapValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e VariableMapValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e VariableMapValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e VariableMapValidationError) ErrorName() string { return "VariableMapValidationError" } + +// Error satisfies the builtin error interface +func (e VariableMapValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sVariableMap.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = VariableMapValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = VariableMapValidationError{} + +// Validate checks the field values on TypedInterface with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TypedInterface) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TypedInterface with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TypedInterfaceMultiError, +// or nil if none found. +func (m *TypedInterface) ValidateAll() error { + return m.validate(true) +} + +func (m *TypedInterface) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetInputs()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TypedInterfaceValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TypedInterfaceValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetInputs()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TypedInterfaceValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetOutputs()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TypedInterfaceValidationError{ + field: "Outputs", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TypedInterfaceValidationError{ + field: "Outputs", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOutputs()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TypedInterfaceValidationError{ + field: "Outputs", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return TypedInterfaceMultiError(errors) + } + + return nil +} + +// TypedInterfaceMultiError is an error wrapping multiple validation errors +// returned by TypedInterface.ValidateAll() if the designated constraints +// aren't met. +type TypedInterfaceMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TypedInterfaceMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TypedInterfaceMultiError) AllErrors() []error { return m } + +// TypedInterfaceValidationError is the validation error returned by +// TypedInterface.Validate if the designated constraints aren't met. +type TypedInterfaceValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TypedInterfaceValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TypedInterfaceValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TypedInterfaceValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TypedInterfaceValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TypedInterfaceValidationError) ErrorName() string { return "TypedInterfaceValidationError" } + +// Error satisfies the builtin error interface +func (e TypedInterfaceValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTypedInterface.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TypedInterfaceValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TypedInterfaceValidationError{} + +// Validate checks the field values on Parameter with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Parameter) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Parameter with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ParameterMultiError, or nil +// if none found. +func (m *Parameter) ValidateAll() error { + return m.validate(true) +} + +func (m *Parameter) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetVar()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ParameterValidationError{ + field: "Var", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ParameterValidationError{ + field: "Var", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetVar()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ParameterValidationError{ + field: "Var", + reason: "embedded message failed validation", + cause: err, + } + } + } + + switch v := m.Behavior.(type) { + case *Parameter_Default: + if v == nil { + err := ParameterValidationError{ + field: "Behavior", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetDefault()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ParameterValidationError{ + field: "Default", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ParameterValidationError{ + field: "Default", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDefault()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ParameterValidationError{ + field: "Default", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Parameter_Required: + if v == nil { + err := ParameterValidationError{ + field: "Behavior", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for Required + case *Parameter_ArtifactQuery: + if v == nil { + err := ParameterValidationError{ + field: "Behavior", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetArtifactQuery()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ParameterValidationError{ + field: "ArtifactQuery", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ParameterValidationError{ + field: "ArtifactQuery", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetArtifactQuery()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ParameterValidationError{ + field: "ArtifactQuery", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Parameter_ArtifactId: + if v == nil { + err := ParameterValidationError{ + field: "Behavior", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetArtifactId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ParameterValidationError{ + field: "ArtifactId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ParameterValidationError{ + field: "ArtifactId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetArtifactId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ParameterValidationError{ + field: "ArtifactId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return ParameterMultiError(errors) + } + + return nil +} + +// ParameterMultiError is an error wrapping multiple validation errors returned +// by Parameter.ValidateAll() if the designated constraints aren't met. +type ParameterMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ParameterMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ParameterMultiError) AllErrors() []error { return m } + +// ParameterValidationError is the validation error returned by +// Parameter.Validate if the designated constraints aren't met. +type ParameterValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ParameterValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ParameterValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ParameterValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ParameterValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ParameterValidationError) ErrorName() string { return "ParameterValidationError" } + +// Error satisfies the builtin error interface +func (e ParameterValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sParameter.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ParameterValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ParameterValidationError{} + +// Validate checks the field values on ParameterMap with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ParameterMap) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ParameterMap with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ParameterMapMultiError, or +// nil if none found. +func (m *ParameterMap) ValidateAll() error { + return m.validate(true) +} + +func (m *ParameterMap) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + { + sorted_keys := make([]string, len(m.GetParameters())) + i := 0 + for key := range m.GetParameters() { + sorted_keys[i] = key + i++ + } + sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] }) + for _, key := range sorted_keys { + val := m.GetParameters()[key] + _ = val + + // no validation rules for Parameters[key] + + if all { + switch v := interface{}(val).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ParameterMapValidationError{ + field: fmt.Sprintf("Parameters[%v]", key), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ParameterMapValidationError{ + field: fmt.Sprintf("Parameters[%v]", key), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(val).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ParameterMapValidationError{ + field: fmt.Sprintf("Parameters[%v]", key), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + } + + if len(errors) > 0 { + return ParameterMapMultiError(errors) + } + + return nil +} + +// ParameterMapMultiError is an error wrapping multiple validation errors +// returned by ParameterMap.ValidateAll() if the designated constraints aren't met. +type ParameterMapMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ParameterMapMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ParameterMapMultiError) AllErrors() []error { return m } + +// ParameterMapValidationError is the validation error returned by +// ParameterMap.Validate if the designated constraints aren't met. +type ParameterMapValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ParameterMapValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ParameterMapValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ParameterMapValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ParameterMapValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ParameterMapValidationError) ErrorName() string { return "ParameterMapValidationError" } + +// Error satisfies the builtin error interface +func (e ParameterMapValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sParameterMap.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ParameterMapValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ParameterMapValidationError{} diff --git a/gen/go/flyteidl2/core/literals.pb.go b/gen/go/flyteidl2/core/literals.pb.go new file mode 100644 index 0000000000..ab4b78cdcf --- /dev/null +++ b/gen/go/flyteidl2/core/literals.pb.go @@ -0,0 +1,2145 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/core/literals.proto + +package core + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + durationpb "google.golang.org/protobuf/types/known/durationpb" + structpb "google.golang.org/protobuf/types/known/structpb" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Primitive Types +type Primitive struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Defines one of simple primitive types. These types will get translated into different programming languages as + // described in https://developers.google.com/protocol-buffers/docs/proto#scalar. + // + // Types that are assignable to Value: + // + // *Primitive_Integer + // *Primitive_FloatValue + // *Primitive_StringValue + // *Primitive_Boolean + // *Primitive_Datetime + // *Primitive_Duration + Value isPrimitive_Value `protobuf_oneof:"value"` +} + +func (x *Primitive) Reset() { + *x = Primitive{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Primitive) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Primitive) ProtoMessage() {} + +func (x *Primitive) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Primitive.ProtoReflect.Descriptor instead. +func (*Primitive) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{0} +} + +func (m *Primitive) GetValue() isPrimitive_Value { + if m != nil { + return m.Value + } + return nil +} + +func (x *Primitive) GetInteger() int64 { + if x, ok := x.GetValue().(*Primitive_Integer); ok { + return x.Integer + } + return 0 +} + +func (x *Primitive) GetFloatValue() float64 { + if x, ok := x.GetValue().(*Primitive_FloatValue); ok { + return x.FloatValue + } + return 0 +} + +func (x *Primitive) GetStringValue() string { + if x, ok := x.GetValue().(*Primitive_StringValue); ok { + return x.StringValue + } + return "" +} + +func (x *Primitive) GetBoolean() bool { + if x, ok := x.GetValue().(*Primitive_Boolean); ok { + return x.Boolean + } + return false +} + +func (x *Primitive) GetDatetime() *timestamppb.Timestamp { + if x, ok := x.GetValue().(*Primitive_Datetime); ok { + return x.Datetime + } + return nil +} + +func (x *Primitive) GetDuration() *durationpb.Duration { + if x, ok := x.GetValue().(*Primitive_Duration); ok { + return x.Duration + } + return nil +} + +type isPrimitive_Value interface { + isPrimitive_Value() +} + +type Primitive_Integer struct { + Integer int64 `protobuf:"varint,1,opt,name=integer,proto3,oneof"` +} + +type Primitive_FloatValue struct { + FloatValue float64 `protobuf:"fixed64,2,opt,name=float_value,json=floatValue,proto3,oneof"` +} + +type Primitive_StringValue struct { + StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,proto3,oneof"` +} + +type Primitive_Boolean struct { + Boolean bool `protobuf:"varint,4,opt,name=boolean,proto3,oneof"` +} + +type Primitive_Datetime struct { + Datetime *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=datetime,proto3,oneof"` +} + +type Primitive_Duration struct { + Duration *durationpb.Duration `protobuf:"bytes,6,opt,name=duration,proto3,oneof"` +} + +func (*Primitive_Integer) isPrimitive_Value() {} + +func (*Primitive_FloatValue) isPrimitive_Value() {} + +func (*Primitive_StringValue) isPrimitive_Value() {} + +func (*Primitive_Boolean) isPrimitive_Value() {} + +func (*Primitive_Datetime) isPrimitive_Value() {} + +func (*Primitive_Duration) isPrimitive_Value() {} + +// Used to denote a nil/null/None assignment to a scalar value. The underlying LiteralType for Void is intentionally +// undefined since it can be assigned to a scalar of any LiteralType. +type Void struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *Void) Reset() { + *x = Void{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Void) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Void) ProtoMessage() {} + +func (x *Void) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Void.ProtoReflect.Descriptor instead. +func (*Void) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{1} +} + +// Refers to an offloaded set of files. It encapsulates the type of the store and a unique uri for where the data is. +// There are no restrictions on how the uri is formatted since it will depend on how to interact with the store. +type Blob struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Metadata *BlobMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` + Uri string `protobuf:"bytes,3,opt,name=uri,proto3" json:"uri,omitempty"` +} + +func (x *Blob) Reset() { + *x = Blob{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Blob) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Blob) ProtoMessage() {} + +func (x *Blob) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Blob.ProtoReflect.Descriptor instead. +func (*Blob) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{2} +} + +func (x *Blob) GetMetadata() *BlobMetadata { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *Blob) GetUri() string { + if x != nil { + return x.Uri + } + return "" +} + +type BlobMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Type *BlobType `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` +} + +func (x *BlobMetadata) Reset() { + *x = BlobMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BlobMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BlobMetadata) ProtoMessage() {} + +func (x *BlobMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BlobMetadata.ProtoReflect.Descriptor instead. +func (*BlobMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{3} +} + +func (x *BlobMetadata) GetType() *BlobType { + if x != nil { + return x.Type + } + return nil +} + +// A simple byte array with a tag to help different parts of the system communicate about what is in the byte array. +// It's strongly advisable that consumers of this type define a unique tag and validate the tag before parsing the data. +type Binary struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` // Serialized data (MessagePack) for supported types like Dataclass, Pydantic BaseModel, and untyped dict. + Tag string `protobuf:"bytes,2,opt,name=tag,proto3" json:"tag,omitempty"` // The serialization format identifier (e.g., MessagePack). Consumers must define unique tags and validate them before deserialization. +} + +func (x *Binary) Reset() { + *x = Binary{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Binary) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Binary) ProtoMessage() {} + +func (x *Binary) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Binary.ProtoReflect.Descriptor instead. +func (*Binary) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{4} +} + +func (x *Binary) GetValue() []byte { + if x != nil { + return x.Value + } + return nil +} + +func (x *Binary) GetTag() string { + if x != nil { + return x.Tag + } + return "" +} + +// A strongly typed schema that defines the interface of data retrieved from the underlying storage medium. +type Schema struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Uri string `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"` + Type *SchemaType `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"` +} + +func (x *Schema) Reset() { + *x = Schema{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Schema) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Schema) ProtoMessage() {} + +func (x *Schema) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Schema.ProtoReflect.Descriptor instead. +func (*Schema) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{5} +} + +func (x *Schema) GetUri() string { + if x != nil { + return x.Uri + } + return "" +} + +func (x *Schema) GetType() *SchemaType { + if x != nil { + return x.Type + } + return nil +} + +// The runtime representation of a tagged union value. See `UnionType` for more details. +type Union struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Value *Literal `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + Type *LiteralType `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"` +} + +func (x *Union) Reset() { + *x = Union{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Union) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Union) ProtoMessage() {} + +func (x *Union) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Union.ProtoReflect.Descriptor instead. +func (*Union) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{6} +} + +func (x *Union) GetValue() *Literal { + if x != nil { + return x.Value + } + return nil +} + +func (x *Union) GetType() *LiteralType { + if x != nil { + return x.Type + } + return nil +} + +type StructuredDatasetMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Bundle the type information along with the literal. + // This is here because StructuredDatasets can often be more defined at run time than at compile time. + // That is, at compile time you might only declare a task to return a pandas dataframe or a StructuredDataset, + // without any column information, but at run time, you might have that column information. + // flytekit python will copy this type information into the literal, from the type information, if not provided by + // the various plugins (encoders). + // Since this field is run time generated, it's not used for any type checking. + StructuredDatasetType *StructuredDatasetType `protobuf:"bytes,1,opt,name=structured_dataset_type,json=structuredDatasetType,proto3" json:"structured_dataset_type,omitempty"` +} + +func (x *StructuredDatasetMetadata) Reset() { + *x = StructuredDatasetMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *StructuredDatasetMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StructuredDatasetMetadata) ProtoMessage() {} + +func (x *StructuredDatasetMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use StructuredDatasetMetadata.ProtoReflect.Descriptor instead. +func (*StructuredDatasetMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{7} +} + +func (x *StructuredDatasetMetadata) GetStructuredDatasetType() *StructuredDatasetType { + if x != nil { + return x.StructuredDatasetType + } + return nil +} + +type StructuredDataset struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // String location uniquely identifying where the data is. + // Should start with the storage location (e.g. s3://, gs://, bq://, etc.) + Uri string `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"` + Metadata *StructuredDatasetMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"` +} + +func (x *StructuredDataset) Reset() { + *x = StructuredDataset{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *StructuredDataset) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StructuredDataset) ProtoMessage() {} + +func (x *StructuredDataset) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use StructuredDataset.ProtoReflect.Descriptor instead. +func (*StructuredDataset) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{8} +} + +func (x *StructuredDataset) GetUri() string { + if x != nil { + return x.Uri + } + return "" +} + +func (x *StructuredDataset) GetMetadata() *StructuredDatasetMetadata { + if x != nil { + return x.Metadata + } + return nil +} + +type Scalar struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Value: + // + // *Scalar_Primitive + // *Scalar_Blob + // *Scalar_Binary + // *Scalar_Schema + // *Scalar_NoneType + // *Scalar_Error + // *Scalar_Generic + // *Scalar_StructuredDataset + // *Scalar_Union + Value isScalar_Value `protobuf_oneof:"value"` +} + +func (x *Scalar) Reset() { + *x = Scalar{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Scalar) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Scalar) ProtoMessage() {} + +func (x *Scalar) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Scalar.ProtoReflect.Descriptor instead. +func (*Scalar) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{9} +} + +func (m *Scalar) GetValue() isScalar_Value { + if m != nil { + return m.Value + } + return nil +} + +func (x *Scalar) GetPrimitive() *Primitive { + if x, ok := x.GetValue().(*Scalar_Primitive); ok { + return x.Primitive + } + return nil +} + +func (x *Scalar) GetBlob() *Blob { + if x, ok := x.GetValue().(*Scalar_Blob); ok { + return x.Blob + } + return nil +} + +func (x *Scalar) GetBinary() *Binary { + if x, ok := x.GetValue().(*Scalar_Binary); ok { + return x.Binary + } + return nil +} + +func (x *Scalar) GetSchema() *Schema { + if x, ok := x.GetValue().(*Scalar_Schema); ok { + return x.Schema + } + return nil +} + +func (x *Scalar) GetNoneType() *Void { + if x, ok := x.GetValue().(*Scalar_NoneType); ok { + return x.NoneType + } + return nil +} + +func (x *Scalar) GetError() *Error { + if x, ok := x.GetValue().(*Scalar_Error); ok { + return x.Error + } + return nil +} + +func (x *Scalar) GetGeneric() *structpb.Struct { + if x, ok := x.GetValue().(*Scalar_Generic); ok { + return x.Generic + } + return nil +} + +func (x *Scalar) GetStructuredDataset() *StructuredDataset { + if x, ok := x.GetValue().(*Scalar_StructuredDataset); ok { + return x.StructuredDataset + } + return nil +} + +func (x *Scalar) GetUnion() *Union { + if x, ok := x.GetValue().(*Scalar_Union); ok { + return x.Union + } + return nil +} + +type isScalar_Value interface { + isScalar_Value() +} + +type Scalar_Primitive struct { + Primitive *Primitive `protobuf:"bytes,1,opt,name=primitive,proto3,oneof"` +} + +type Scalar_Blob struct { + Blob *Blob `protobuf:"bytes,2,opt,name=blob,proto3,oneof"` +} + +type Scalar_Binary struct { + Binary *Binary `protobuf:"bytes,3,opt,name=binary,proto3,oneof"` +} + +type Scalar_Schema struct { + Schema *Schema `protobuf:"bytes,4,opt,name=schema,proto3,oneof"` +} + +type Scalar_NoneType struct { + NoneType *Void `protobuf:"bytes,5,opt,name=none_type,json=noneType,proto3,oneof"` +} + +type Scalar_Error struct { + Error *Error `protobuf:"bytes,6,opt,name=error,proto3,oneof"` +} + +type Scalar_Generic struct { + Generic *structpb.Struct `protobuf:"bytes,7,opt,name=generic,proto3,oneof"` +} + +type Scalar_StructuredDataset struct { + StructuredDataset *StructuredDataset `protobuf:"bytes,8,opt,name=structured_dataset,json=structuredDataset,proto3,oneof"` +} + +type Scalar_Union struct { + Union *Union `protobuf:"bytes,9,opt,name=union,proto3,oneof"` +} + +func (*Scalar_Primitive) isScalar_Value() {} + +func (*Scalar_Blob) isScalar_Value() {} + +func (*Scalar_Binary) isScalar_Value() {} + +func (*Scalar_Schema) isScalar_Value() {} + +func (*Scalar_NoneType) isScalar_Value() {} + +func (*Scalar_Error) isScalar_Value() {} + +func (*Scalar_Generic) isScalar_Value() {} + +func (*Scalar_StructuredDataset) isScalar_Value() {} + +func (*Scalar_Union) isScalar_Value() {} + +// A simple value. This supports any level of nesting (e.g. array of array of array of Blobs) as well as simple primitives. +type Literal struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Value: + // + // *Literal_Scalar + // *Literal_Collection + // *Literal_Map + // *Literal_OffloadedMetadata + Value isLiteral_Value `protobuf_oneof:"value"` + // A hash representing this literal. + // This is used for caching purposes. For more details refer to RFC 1893 + // (https://github.com/flyteorg/flyte/blob/master/rfc/system/1893-caching-of-offloaded-objects.md) + Hash string `protobuf:"bytes,4,opt,name=hash,proto3" json:"hash,omitempty"` + // Additional metadata for literals. + Metadata map[string]string `protobuf:"bytes,5,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *Literal) Reset() { + *x = Literal{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Literal) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Literal) ProtoMessage() {} + +func (x *Literal) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Literal.ProtoReflect.Descriptor instead. +func (*Literal) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{10} +} + +func (m *Literal) GetValue() isLiteral_Value { + if m != nil { + return m.Value + } + return nil +} + +func (x *Literal) GetScalar() *Scalar { + if x, ok := x.GetValue().(*Literal_Scalar); ok { + return x.Scalar + } + return nil +} + +func (x *Literal) GetCollection() *LiteralCollection { + if x, ok := x.GetValue().(*Literal_Collection); ok { + return x.Collection + } + return nil +} + +func (x *Literal) GetMap() *LiteralMap { + if x, ok := x.GetValue().(*Literal_Map); ok { + return x.Map + } + return nil +} + +func (x *Literal) GetOffloadedMetadata() *LiteralOffloadedMetadata { + if x, ok := x.GetValue().(*Literal_OffloadedMetadata); ok { + return x.OffloadedMetadata + } + return nil +} + +func (x *Literal) GetHash() string { + if x != nil { + return x.Hash + } + return "" +} + +func (x *Literal) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +type isLiteral_Value interface { + isLiteral_Value() +} + +type Literal_Scalar struct { + // A simple value. + Scalar *Scalar `protobuf:"bytes,1,opt,name=scalar,proto3,oneof"` +} + +type Literal_Collection struct { + // A collection of literals to allow nesting. + Collection *LiteralCollection `protobuf:"bytes,2,opt,name=collection,proto3,oneof"` +} + +type Literal_Map struct { + // A map of strings to literals. + Map *LiteralMap `protobuf:"bytes,3,opt,name=map,proto3,oneof"` +} + +type Literal_OffloadedMetadata struct { + // Offloaded literal metadata + // When you deserialize the offloaded metadata, it would be of Literal and its type would be defined by LiteralType stored in offloaded_metadata. + OffloadedMetadata *LiteralOffloadedMetadata `protobuf:"bytes,8,opt,name=offloaded_metadata,json=offloadedMetadata,proto3,oneof"` +} + +func (*Literal_Scalar) isLiteral_Value() {} + +func (*Literal_Collection) isLiteral_Value() {} + +func (*Literal_Map) isLiteral_Value() {} + +func (*Literal_OffloadedMetadata) isLiteral_Value() {} + +// A message that contains the metadata of the offloaded data. +type LiteralOffloadedMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The location of the offloaded core.Literal. + Uri string `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"` + // The size of the offloaded data. + SizeBytes uint64 `protobuf:"varint,2,opt,name=size_bytes,json=sizeBytes,proto3" json:"size_bytes,omitempty"` + // The inferred literal type of the offloaded data. + InferredType *LiteralType `protobuf:"bytes,3,opt,name=inferred_type,json=inferredType,proto3" json:"inferred_type,omitempty"` +} + +func (x *LiteralOffloadedMetadata) Reset() { + *x = LiteralOffloadedMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LiteralOffloadedMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LiteralOffloadedMetadata) ProtoMessage() {} + +func (x *LiteralOffloadedMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LiteralOffloadedMetadata.ProtoReflect.Descriptor instead. +func (*LiteralOffloadedMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{11} +} + +func (x *LiteralOffloadedMetadata) GetUri() string { + if x != nil { + return x.Uri + } + return "" +} + +func (x *LiteralOffloadedMetadata) GetSizeBytes() uint64 { + if x != nil { + return x.SizeBytes + } + return 0 +} + +func (x *LiteralOffloadedMetadata) GetInferredType() *LiteralType { + if x != nil { + return x.InferredType + } + return nil +} + +// A collection of literals. This is a workaround since oneofs in proto messages cannot contain a repeated field. +type LiteralCollection struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Literals []*Literal `protobuf:"bytes,1,rep,name=literals,proto3" json:"literals,omitempty"` +} + +func (x *LiteralCollection) Reset() { + *x = LiteralCollection{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LiteralCollection) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LiteralCollection) ProtoMessage() {} + +func (x *LiteralCollection) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LiteralCollection.ProtoReflect.Descriptor instead. +func (*LiteralCollection) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{12} +} + +func (x *LiteralCollection) GetLiterals() []*Literal { + if x != nil { + return x.Literals + } + return nil +} + +// A map of literals. This is a workaround since oneofs in proto messages cannot contain a repeated field. +type LiteralMap struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Literals map[string]*Literal `protobuf:"bytes,1,rep,name=literals,proto3" json:"literals,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *LiteralMap) Reset() { + *x = LiteralMap{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LiteralMap) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LiteralMap) ProtoMessage() {} + +func (x *LiteralMap) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LiteralMap.ProtoReflect.Descriptor instead. +func (*LiteralMap) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{13} +} + +func (x *LiteralMap) GetLiterals() map[string]*Literal { + if x != nil { + return x.Literals + } + return nil +} + +// A collection of BindingData items. +type BindingDataCollection struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Bindings []*BindingData `protobuf:"bytes,1,rep,name=bindings,proto3" json:"bindings,omitempty"` +} + +func (x *BindingDataCollection) Reset() { + *x = BindingDataCollection{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BindingDataCollection) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BindingDataCollection) ProtoMessage() {} + +func (x *BindingDataCollection) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BindingDataCollection.ProtoReflect.Descriptor instead. +func (*BindingDataCollection) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{14} +} + +func (x *BindingDataCollection) GetBindings() []*BindingData { + if x != nil { + return x.Bindings + } + return nil +} + +// A map of BindingData items. +type BindingDataMap struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Bindings map[string]*BindingData `protobuf:"bytes,1,rep,name=bindings,proto3" json:"bindings,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *BindingDataMap) Reset() { + *x = BindingDataMap{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BindingDataMap) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BindingDataMap) ProtoMessage() {} + +func (x *BindingDataMap) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BindingDataMap.ProtoReflect.Descriptor instead. +func (*BindingDataMap) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{15} +} + +func (x *BindingDataMap) GetBindings() map[string]*BindingData { + if x != nil { + return x.Bindings + } + return nil +} + +type UnionInfo struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TargetType *LiteralType `protobuf:"bytes,1,opt,name=targetType,proto3" json:"targetType,omitempty"` +} + +func (x *UnionInfo) Reset() { + *x = UnionInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UnionInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UnionInfo) ProtoMessage() {} + +func (x *UnionInfo) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[16] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UnionInfo.ProtoReflect.Descriptor instead. +func (*UnionInfo) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{16} +} + +func (x *UnionInfo) GetTargetType() *LiteralType { + if x != nil { + return x.TargetType + } + return nil +} + +// Specifies either a simple value or a reference to another output. +type BindingData struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Value: + // + // *BindingData_Scalar + // *BindingData_Collection + // *BindingData_Promise + // *BindingData_Map + // *BindingData_OffloadedMetadata + Value isBindingData_Value `protobuf_oneof:"value"` + Union *UnionInfo `protobuf:"bytes,5,opt,name=union,proto3" json:"union,omitempty"` +} + +func (x *BindingData) Reset() { + *x = BindingData{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BindingData) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BindingData) ProtoMessage() {} + +func (x *BindingData) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BindingData.ProtoReflect.Descriptor instead. +func (*BindingData) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{17} +} + +func (m *BindingData) GetValue() isBindingData_Value { + if m != nil { + return m.Value + } + return nil +} + +func (x *BindingData) GetScalar() *Scalar { + if x, ok := x.GetValue().(*BindingData_Scalar); ok { + return x.Scalar + } + return nil +} + +func (x *BindingData) GetCollection() *BindingDataCollection { + if x, ok := x.GetValue().(*BindingData_Collection); ok { + return x.Collection + } + return nil +} + +func (x *BindingData) GetPromise() *OutputReference { + if x, ok := x.GetValue().(*BindingData_Promise); ok { + return x.Promise + } + return nil +} + +func (x *BindingData) GetMap() *BindingDataMap { + if x, ok := x.GetValue().(*BindingData_Map); ok { + return x.Map + } + return nil +} + +func (x *BindingData) GetOffloadedMetadata() *LiteralOffloadedMetadata { + if x, ok := x.GetValue().(*BindingData_OffloadedMetadata); ok { + return x.OffloadedMetadata + } + return nil +} + +func (x *BindingData) GetUnion() *UnionInfo { + if x != nil { + return x.Union + } + return nil +} + +type isBindingData_Value interface { + isBindingData_Value() +} + +type BindingData_Scalar struct { + // A simple scalar value. + Scalar *Scalar `protobuf:"bytes,1,opt,name=scalar,proto3,oneof"` +} + +type BindingData_Collection struct { + // A collection of binding data. This allows nesting of binding data to any number + // of levels. + Collection *BindingDataCollection `protobuf:"bytes,2,opt,name=collection,proto3,oneof"` +} + +type BindingData_Promise struct { + // References an output promised by another node. + Promise *OutputReference `protobuf:"bytes,3,opt,name=promise,proto3,oneof"` +} + +type BindingData_Map struct { + // A map of bindings. The key is always a string. + Map *BindingDataMap `protobuf:"bytes,4,opt,name=map,proto3,oneof"` +} + +type BindingData_OffloadedMetadata struct { + // Offloaded literal metadata + // When you deserialize the offloaded metadata, it would be of Literal and its type would be defined by LiteralType stored in offloaded_metadata. + // Used for nodes that don't have promises from upstream nodes such as ArrayNode subNodes. + OffloadedMetadata *LiteralOffloadedMetadata `protobuf:"bytes,6,opt,name=offloaded_metadata,json=offloadedMetadata,proto3,oneof"` +} + +func (*BindingData_Scalar) isBindingData_Value() {} + +func (*BindingData_Collection) isBindingData_Value() {} + +func (*BindingData_Promise) isBindingData_Value() {} + +func (*BindingData_Map) isBindingData_Value() {} + +func (*BindingData_OffloadedMetadata) isBindingData_Value() {} + +// An input/output binding of a variable to either static value or a node output. +type Binding struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Variable name must match an input/output variable of the node. + Var string `protobuf:"bytes,1,opt,name=var,proto3" json:"var,omitempty"` + // Data to use to bind this variable. + Binding *BindingData `protobuf:"bytes,2,opt,name=binding,proto3" json:"binding,omitempty"` +} + +func (x *Binding) Reset() { + *x = Binding{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Binding) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Binding) ProtoMessage() {} + +func (x *Binding) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[18] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Binding.ProtoReflect.Descriptor instead. +func (*Binding) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{18} +} + +func (x *Binding) GetVar() string { + if x != nil { + return x.Var + } + return "" +} + +func (x *Binding) GetBinding() *BindingData { + if x != nil { + return x.Binding + } + return nil +} + +// A generic key value pair. +type KeyValuePair struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // required. + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + // +optional. + Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` +} + +func (x *KeyValuePair) Reset() { + *x = KeyValuePair{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *KeyValuePair) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*KeyValuePair) ProtoMessage() {} + +func (x *KeyValuePair) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[19] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use KeyValuePair.ProtoReflect.Descriptor instead. +func (*KeyValuePair) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{19} +} + +func (x *KeyValuePair) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *KeyValuePair) GetValue() string { + if x != nil { + return x.Value + } + return "" +} + +// Retry strategy associated with an executable unit. +type RetryStrategy struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Number of retries. Retries will be consumed when the job fails with a recoverable error. + // The number of retries must be less than or equals to 10. + Retries uint32 `protobuf:"varint,5,opt,name=retries,proto3" json:"retries,omitempty"` +} + +func (x *RetryStrategy) Reset() { + *x = RetryStrategy{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_literals_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RetryStrategy) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RetryStrategy) ProtoMessage() {} + +func (x *RetryStrategy) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_literals_proto_msgTypes[20] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RetryStrategy.ProtoReflect.Descriptor instead. +func (*RetryStrategy) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_literals_proto_rawDescGZIP(), []int{20} +} + +func (x *RetryStrategy) GetRetries() uint32 { + if x != nil { + return x.Retries + } + return 0 +} + +var File_flyteidl2_core_literals_proto protoreflect.FileDescriptor + +var file_flyteidl2_core_literals_proto_rawDesc = []byte{ + 0x0a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, + 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x1a, + 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, + 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x73, 0x74, 0x72, + 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x87, 0x02, 0x0a, 0x09, 0x50, + 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x12, 0x1a, 0x0a, 0x07, 0x69, 0x6e, 0x74, 0x65, + 0x67, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x07, 0x69, 0x6e, 0x74, + 0x65, 0x67, 0x65, 0x72, 0x12, 0x21, 0x0a, 0x0b, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x5f, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, 0x0a, 0x66, 0x6c, 0x6f, + 0x61, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, + 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, + 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1a, 0x0a, 0x07, + 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, + 0x07, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x12, 0x38, 0x0a, 0x08, 0x64, 0x61, 0x74, 0x65, + 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x48, 0x00, 0x52, 0x08, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, + 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x08, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, + 0x00, 0x52, 0x08, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x07, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x22, 0x06, 0x0a, 0x04, 0x56, 0x6f, 0x69, 0x64, 0x22, 0x52, 0x0a, 0x04, + 0x42, 0x6c, 0x6f, 0x62, 0x12, 0x38, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x42, 0x6c, 0x6f, 0x62, 0x4d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x10, + 0x0a, 0x03, 0x75, 0x72, 0x69, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x69, + 0x22, 0x3c, 0x0a, 0x0c, 0x42, 0x6c, 0x6f, 0x62, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x12, 0x2c, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x42, 0x6c, 0x6f, 0x62, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x30, + 0x0a, 0x06, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x10, + 0x0a, 0x03, 0x74, 0x61, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x74, 0x61, 0x67, + 0x22, 0x4a, 0x0a, 0x06, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, + 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x69, 0x12, 0x2e, 0x0a, 0x04, + 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x63, 0x68, 0x65, + 0x6d, 0x61, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x67, 0x0a, 0x05, + 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x12, 0x2d, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2f, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x52, + 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x7a, 0x0a, 0x19, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, + 0x72, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x12, 0x5d, 0x0a, 0x17, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, + 0x5f, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x44, + 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x15, 0x73, 0x74, 0x72, 0x75, + 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, + 0x65, 0x22, 0x6c, 0x0a, 0x11, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x44, + 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x69, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x69, 0x12, 0x45, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x74, 0x72, 0x75, + 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x22, + 0xf8, 0x03, 0x0a, 0x06, 0x53, 0x63, 0x61, 0x6c, 0x61, 0x72, 0x12, 0x39, 0x0a, 0x09, 0x70, 0x72, + 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x50, + 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x48, 0x00, 0x52, 0x09, 0x70, 0x72, 0x69, 0x6d, + 0x69, 0x74, 0x69, 0x76, 0x65, 0x12, 0x2a, 0x0a, 0x04, 0x62, 0x6c, 0x6f, 0x62, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x42, 0x6c, 0x6f, 0x62, 0x48, 0x00, 0x52, 0x04, 0x62, 0x6c, 0x6f, + 0x62, 0x12, 0x30, 0x0a, 0x06, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x48, 0x00, 0x52, 0x06, 0x62, 0x69, 0x6e, + 0x61, 0x72, 0x79, 0x12, 0x30, 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x48, 0x00, 0x52, 0x06, 0x73, + 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x33, 0x0a, 0x09, 0x6e, 0x6f, 0x6e, 0x65, 0x5f, 0x74, 0x79, + 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x56, 0x6f, 0x69, 0x64, 0x48, 0x00, + 0x52, 0x08, 0x6e, 0x6f, 0x6e, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2d, 0x0a, 0x05, 0x65, 0x72, + 0x72, 0x6f, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, + 0x48, 0x00, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x33, 0x0a, 0x07, 0x67, 0x65, 0x6e, + 0x65, 0x72, 0x69, 0x63, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, + 0x75, 0x63, 0x74, 0x48, 0x00, 0x52, 0x07, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x12, 0x52, + 0x0a, 0x12, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x5f, 0x64, 0x61, 0x74, + 0x61, 0x73, 0x65, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x74, 0x72, 0x75, + 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x48, 0x00, 0x52, + 0x11, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, 0x73, + 0x65, 0x74, 0x12, 0x2d, 0x0a, 0x05, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x15, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x05, 0x75, 0x6e, 0x69, 0x6f, + 0x6e, 0x42, 0x07, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0xb4, 0x03, 0x0a, 0x07, 0x4c, + 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x30, 0x0a, 0x06, 0x73, 0x63, 0x61, 0x6c, 0x61, 0x72, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x63, 0x61, 0x6c, 0x61, 0x72, 0x48, 0x00, + 0x52, 0x06, 0x73, 0x63, 0x61, 0x6c, 0x61, 0x72, 0x12, 0x43, 0x0a, 0x0a, 0x63, 0x6f, 0x6c, 0x6c, + 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, + 0x74, 0x65, 0x72, 0x61, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, + 0x00, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2e, 0x0a, + 0x03, 0x6d, 0x61, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, + 0x72, 0x61, 0x6c, 0x4d, 0x61, 0x70, 0x48, 0x00, 0x52, 0x03, 0x6d, 0x61, 0x70, 0x12, 0x59, 0x0a, + 0x12, 0x6f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, + 0x61, 0x6c, 0x4f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, 0x11, 0x6f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x61, 0x73, 0x68, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x61, 0x73, 0x68, 0x12, 0x41, 0x0a, 0x08, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, + 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, + 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0x07, 0x0a, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x4a, 0x04, 0x08, 0x06, 0x10, 0x07, 0x4a, 0x04, 0x08, 0x07, 0x10, + 0x08, 0x22, 0x8d, 0x01, 0x0a, 0x18, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4f, 0x66, 0x66, + 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x10, + 0x0a, 0x03, 0x75, 0x72, 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x69, + 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x73, 0x69, 0x7a, 0x65, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, + 0x40, 0x0a, 0x0d, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, + 0x79, 0x70, 0x65, 0x52, 0x0c, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x54, 0x79, 0x70, + 0x65, 0x22, 0x48, 0x0a, 0x11, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, + 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x33, 0x0a, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, + 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, + 0x6c, 0x52, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x22, 0xa8, 0x01, 0x0a, 0x0a, + 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, 0x70, 0x12, 0x44, 0x0a, 0x08, 0x6c, 0x69, + 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, + 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, 0x70, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, + 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, + 0x1a, 0x54, 0x0a, 0x0d, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, + 0x6b, 0x65, 0x79, 0x12, 0x2d, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x50, 0x0a, 0x15, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, + 0x67, 0x44, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x37, 0x0a, 0x08, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x52, 0x08, + 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x22, 0xb4, 0x01, 0x0a, 0x0e, 0x42, 0x69, 0x6e, + 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x4d, 0x61, 0x70, 0x12, 0x48, 0x0a, 0x08, 0x62, + 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x42, + 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x4d, 0x61, 0x70, 0x2e, 0x42, 0x69, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x62, 0x69, 0x6e, + 0x64, 0x69, 0x6e, 0x67, 0x73, 0x1a, 0x58, 0x0a, 0x0d, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, + 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x31, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, + 0x44, 0x61, 0x74, 0x61, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, + 0x48, 0x0a, 0x09, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3b, 0x0a, 0x0a, + 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, 0x74, + 0x61, 0x72, 0x67, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x8e, 0x03, 0x0a, 0x0b, 0x42, 0x69, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x12, 0x30, 0x0a, 0x06, 0x73, 0x63, 0x61, + 0x6c, 0x61, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x63, 0x61, 0x6c, 0x61, + 0x72, 0x48, 0x00, 0x52, 0x06, 0x73, 0x63, 0x61, 0x6c, 0x61, 0x72, 0x12, 0x47, 0x0a, 0x0a, 0x63, + 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6c, 0x6c, + 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3b, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6d, 0x69, 0x73, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x52, 0x65, 0x66, + 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x48, 0x00, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6d, 0x69, 0x73, + 0x65, 0x12, 0x32, 0x0a, 0x03, 0x6d, 0x61, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x4d, 0x61, 0x70, 0x48, 0x00, + 0x52, 0x03, 0x6d, 0x61, 0x70, 0x12, 0x59, 0x0a, 0x12, 0x6f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, + 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4f, 0x66, 0x66, 0x6c, 0x6f, 0x61, + 0x64, 0x65, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, 0x11, 0x6f, + 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x12, 0x2f, 0x0a, 0x05, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x75, 0x6e, 0x69, 0x6f, + 0x6e, 0x42, 0x07, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x52, 0x0a, 0x07, 0x42, 0x69, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x10, 0x0a, 0x03, 0x76, 0x61, 0x72, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x76, 0x61, 0x72, 0x12, 0x35, 0x0a, 0x07, 0x62, 0x69, 0x6e, 0x64, 0x69, + 0x6e, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, + 0x67, 0x44, 0x61, 0x74, 0x61, 0x52, 0x07, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x36, + 0x0a, 0x0c, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x61, 0x69, 0x72, 0x12, 0x10, + 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, + 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x29, 0x0a, 0x0d, 0x52, 0x65, 0x74, 0x72, 0x79, 0x53, + 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x74, 0x72, 0x69, + 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, + 0x73, 0x42, 0xb2, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x42, 0x0d, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, + 0x6c, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, + 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, + 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, + 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0xa2, + 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_core_literals_proto_rawDescOnce sync.Once + file_flyteidl2_core_literals_proto_rawDescData = file_flyteidl2_core_literals_proto_rawDesc +) + +func file_flyteidl2_core_literals_proto_rawDescGZIP() []byte { + file_flyteidl2_core_literals_proto_rawDescOnce.Do(func() { + file_flyteidl2_core_literals_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_core_literals_proto_rawDescData) + }) + return file_flyteidl2_core_literals_proto_rawDescData +} + +var file_flyteidl2_core_literals_proto_msgTypes = make([]protoimpl.MessageInfo, 24) +var file_flyteidl2_core_literals_proto_goTypes = []interface{}{ + (*Primitive)(nil), // 0: flyteidl2.core.Primitive + (*Void)(nil), // 1: flyteidl2.core.Void + (*Blob)(nil), // 2: flyteidl2.core.Blob + (*BlobMetadata)(nil), // 3: flyteidl2.core.BlobMetadata + (*Binary)(nil), // 4: flyteidl2.core.Binary + (*Schema)(nil), // 5: flyteidl2.core.Schema + (*Union)(nil), // 6: flyteidl2.core.Union + (*StructuredDatasetMetadata)(nil), // 7: flyteidl2.core.StructuredDatasetMetadata + (*StructuredDataset)(nil), // 8: flyteidl2.core.StructuredDataset + (*Scalar)(nil), // 9: flyteidl2.core.Scalar + (*Literal)(nil), // 10: flyteidl2.core.Literal + (*LiteralOffloadedMetadata)(nil), // 11: flyteidl2.core.LiteralOffloadedMetadata + (*LiteralCollection)(nil), // 12: flyteidl2.core.LiteralCollection + (*LiteralMap)(nil), // 13: flyteidl2.core.LiteralMap + (*BindingDataCollection)(nil), // 14: flyteidl2.core.BindingDataCollection + (*BindingDataMap)(nil), // 15: flyteidl2.core.BindingDataMap + (*UnionInfo)(nil), // 16: flyteidl2.core.UnionInfo + (*BindingData)(nil), // 17: flyteidl2.core.BindingData + (*Binding)(nil), // 18: flyteidl2.core.Binding + (*KeyValuePair)(nil), // 19: flyteidl2.core.KeyValuePair + (*RetryStrategy)(nil), // 20: flyteidl2.core.RetryStrategy + nil, // 21: flyteidl2.core.Literal.MetadataEntry + nil, // 22: flyteidl2.core.LiteralMap.LiteralsEntry + nil, // 23: flyteidl2.core.BindingDataMap.BindingsEntry + (*timestamppb.Timestamp)(nil), // 24: google.protobuf.Timestamp + (*durationpb.Duration)(nil), // 25: google.protobuf.Duration + (*BlobType)(nil), // 26: flyteidl2.core.BlobType + (*SchemaType)(nil), // 27: flyteidl2.core.SchemaType + (*LiteralType)(nil), // 28: flyteidl2.core.LiteralType + (*StructuredDatasetType)(nil), // 29: flyteidl2.core.StructuredDatasetType + (*Error)(nil), // 30: flyteidl2.core.Error + (*structpb.Struct)(nil), // 31: google.protobuf.Struct + (*OutputReference)(nil), // 32: flyteidl2.core.OutputReference +} +var file_flyteidl2_core_literals_proto_depIdxs = []int32{ + 24, // 0: flyteidl2.core.Primitive.datetime:type_name -> google.protobuf.Timestamp + 25, // 1: flyteidl2.core.Primitive.duration:type_name -> google.protobuf.Duration + 3, // 2: flyteidl2.core.Blob.metadata:type_name -> flyteidl2.core.BlobMetadata + 26, // 3: flyteidl2.core.BlobMetadata.type:type_name -> flyteidl2.core.BlobType + 27, // 4: flyteidl2.core.Schema.type:type_name -> flyteidl2.core.SchemaType + 10, // 5: flyteidl2.core.Union.value:type_name -> flyteidl2.core.Literal + 28, // 6: flyteidl2.core.Union.type:type_name -> flyteidl2.core.LiteralType + 29, // 7: flyteidl2.core.StructuredDatasetMetadata.structured_dataset_type:type_name -> flyteidl2.core.StructuredDatasetType + 7, // 8: flyteidl2.core.StructuredDataset.metadata:type_name -> flyteidl2.core.StructuredDatasetMetadata + 0, // 9: flyteidl2.core.Scalar.primitive:type_name -> flyteidl2.core.Primitive + 2, // 10: flyteidl2.core.Scalar.blob:type_name -> flyteidl2.core.Blob + 4, // 11: flyteidl2.core.Scalar.binary:type_name -> flyteidl2.core.Binary + 5, // 12: flyteidl2.core.Scalar.schema:type_name -> flyteidl2.core.Schema + 1, // 13: flyteidl2.core.Scalar.none_type:type_name -> flyteidl2.core.Void + 30, // 14: flyteidl2.core.Scalar.error:type_name -> flyteidl2.core.Error + 31, // 15: flyteidl2.core.Scalar.generic:type_name -> google.protobuf.Struct + 8, // 16: flyteidl2.core.Scalar.structured_dataset:type_name -> flyteidl2.core.StructuredDataset + 6, // 17: flyteidl2.core.Scalar.union:type_name -> flyteidl2.core.Union + 9, // 18: flyteidl2.core.Literal.scalar:type_name -> flyteidl2.core.Scalar + 12, // 19: flyteidl2.core.Literal.collection:type_name -> flyteidl2.core.LiteralCollection + 13, // 20: flyteidl2.core.Literal.map:type_name -> flyteidl2.core.LiteralMap + 11, // 21: flyteidl2.core.Literal.offloaded_metadata:type_name -> flyteidl2.core.LiteralOffloadedMetadata + 21, // 22: flyteidl2.core.Literal.metadata:type_name -> flyteidl2.core.Literal.MetadataEntry + 28, // 23: flyteidl2.core.LiteralOffloadedMetadata.inferred_type:type_name -> flyteidl2.core.LiteralType + 10, // 24: flyteidl2.core.LiteralCollection.literals:type_name -> flyteidl2.core.Literal + 22, // 25: flyteidl2.core.LiteralMap.literals:type_name -> flyteidl2.core.LiteralMap.LiteralsEntry + 17, // 26: flyteidl2.core.BindingDataCollection.bindings:type_name -> flyteidl2.core.BindingData + 23, // 27: flyteidl2.core.BindingDataMap.bindings:type_name -> flyteidl2.core.BindingDataMap.BindingsEntry + 28, // 28: flyteidl2.core.UnionInfo.targetType:type_name -> flyteidl2.core.LiteralType + 9, // 29: flyteidl2.core.BindingData.scalar:type_name -> flyteidl2.core.Scalar + 14, // 30: flyteidl2.core.BindingData.collection:type_name -> flyteidl2.core.BindingDataCollection + 32, // 31: flyteidl2.core.BindingData.promise:type_name -> flyteidl2.core.OutputReference + 15, // 32: flyteidl2.core.BindingData.map:type_name -> flyteidl2.core.BindingDataMap + 11, // 33: flyteidl2.core.BindingData.offloaded_metadata:type_name -> flyteidl2.core.LiteralOffloadedMetadata + 16, // 34: flyteidl2.core.BindingData.union:type_name -> flyteidl2.core.UnionInfo + 17, // 35: flyteidl2.core.Binding.binding:type_name -> flyteidl2.core.BindingData + 10, // 36: flyteidl2.core.LiteralMap.LiteralsEntry.value:type_name -> flyteidl2.core.Literal + 17, // 37: flyteidl2.core.BindingDataMap.BindingsEntry.value:type_name -> flyteidl2.core.BindingData + 38, // [38:38] is the sub-list for method output_type + 38, // [38:38] is the sub-list for method input_type + 38, // [38:38] is the sub-list for extension type_name + 38, // [38:38] is the sub-list for extension extendee + 0, // [0:38] is the sub-list for field type_name +} + +func init() { file_flyteidl2_core_literals_proto_init() } +func file_flyteidl2_core_literals_proto_init() { + if File_flyteidl2_core_literals_proto != nil { + return + } + file_flyteidl2_core_types_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_core_literals_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Primitive); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Void); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Blob); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BlobMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Binary); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Schema); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Union); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*StructuredDatasetMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*StructuredDataset); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Scalar); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Literal); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LiteralOffloadedMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LiteralCollection); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LiteralMap); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BindingDataCollection); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BindingDataMap); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UnionInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BindingData); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Binding); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*KeyValuePair); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_literals_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RetryStrategy); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_core_literals_proto_msgTypes[0].OneofWrappers = []interface{}{ + (*Primitive_Integer)(nil), + (*Primitive_FloatValue)(nil), + (*Primitive_StringValue)(nil), + (*Primitive_Boolean)(nil), + (*Primitive_Datetime)(nil), + (*Primitive_Duration)(nil), + } + file_flyteidl2_core_literals_proto_msgTypes[9].OneofWrappers = []interface{}{ + (*Scalar_Primitive)(nil), + (*Scalar_Blob)(nil), + (*Scalar_Binary)(nil), + (*Scalar_Schema)(nil), + (*Scalar_NoneType)(nil), + (*Scalar_Error)(nil), + (*Scalar_Generic)(nil), + (*Scalar_StructuredDataset)(nil), + (*Scalar_Union)(nil), + } + file_flyteidl2_core_literals_proto_msgTypes[10].OneofWrappers = []interface{}{ + (*Literal_Scalar)(nil), + (*Literal_Collection)(nil), + (*Literal_Map)(nil), + (*Literal_OffloadedMetadata)(nil), + } + file_flyteidl2_core_literals_proto_msgTypes[17].OneofWrappers = []interface{}{ + (*BindingData_Scalar)(nil), + (*BindingData_Collection)(nil), + (*BindingData_Promise)(nil), + (*BindingData_Map)(nil), + (*BindingData_OffloadedMetadata)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_core_literals_proto_rawDesc, + NumEnums: 0, + NumMessages: 24, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_core_literals_proto_goTypes, + DependencyIndexes: file_flyteidl2_core_literals_proto_depIdxs, + MessageInfos: file_flyteidl2_core_literals_proto_msgTypes, + }.Build() + File_flyteidl2_core_literals_proto = out.File + file_flyteidl2_core_literals_proto_rawDesc = nil + file_flyteidl2_core_literals_proto_goTypes = nil + file_flyteidl2_core_literals_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/core/literals.pb.validate.go b/gen/go/flyteidl2/core/literals.pb.validate.go new file mode 100644 index 0000000000..bc06dd8505 --- /dev/null +++ b/gen/go/flyteidl2/core/literals.pb.validate.go @@ -0,0 +1,3517 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/core/literals.proto + +package core + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on Primitive with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Primitive) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Primitive with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in PrimitiveMultiError, or nil +// if none found. +func (m *Primitive) ValidateAll() error { + return m.validate(true) +} + +func (m *Primitive) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Value.(type) { + case *Primitive_Integer: + if v == nil { + err := PrimitiveValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for Integer + case *Primitive_FloatValue: + if v == nil { + err := PrimitiveValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for FloatValue + case *Primitive_StringValue: + if v == nil { + err := PrimitiveValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for StringValue + case *Primitive_Boolean: + if v == nil { + err := PrimitiveValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for Boolean + case *Primitive_Datetime: + if v == nil { + err := PrimitiveValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetDatetime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PrimitiveValidationError{ + field: "Datetime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PrimitiveValidationError{ + field: "Datetime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDatetime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PrimitiveValidationError{ + field: "Datetime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Primitive_Duration: + if v == nil { + err := PrimitiveValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetDuration()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PrimitiveValidationError{ + field: "Duration", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PrimitiveValidationError{ + field: "Duration", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDuration()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PrimitiveValidationError{ + field: "Duration", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return PrimitiveMultiError(errors) + } + + return nil +} + +// PrimitiveMultiError is an error wrapping multiple validation errors returned +// by Primitive.ValidateAll() if the designated constraints aren't met. +type PrimitiveMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PrimitiveMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PrimitiveMultiError) AllErrors() []error { return m } + +// PrimitiveValidationError is the validation error returned by +// Primitive.Validate if the designated constraints aren't met. +type PrimitiveValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PrimitiveValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PrimitiveValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PrimitiveValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PrimitiveValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PrimitiveValidationError) ErrorName() string { return "PrimitiveValidationError" } + +// Error satisfies the builtin error interface +func (e PrimitiveValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPrimitive.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PrimitiveValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PrimitiveValidationError{} + +// Validate checks the field values on Void with the rules defined in the proto +// definition for this message. If any rules are violated, the first error +// encountered is returned, or nil if there are no violations. +func (m *Void) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Void with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in VoidMultiError, or nil if none found. +func (m *Void) ValidateAll() error { + return m.validate(true) +} + +func (m *Void) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return VoidMultiError(errors) + } + + return nil +} + +// VoidMultiError is an error wrapping multiple validation errors returned by +// Void.ValidateAll() if the designated constraints aren't met. +type VoidMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m VoidMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m VoidMultiError) AllErrors() []error { return m } + +// VoidValidationError is the validation error returned by Void.Validate if the +// designated constraints aren't met. +type VoidValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e VoidValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e VoidValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e VoidValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e VoidValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e VoidValidationError) ErrorName() string { return "VoidValidationError" } + +// Error satisfies the builtin error interface +func (e VoidValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sVoid.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = VoidValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = VoidValidationError{} + +// Validate checks the field values on Blob with the rules defined in the proto +// definition for this message. If any rules are violated, the first error +// encountered is returned, or nil if there are no violations. +func (m *Blob) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Blob with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in BlobMultiError, or nil if none found. +func (m *Blob) ValidateAll() error { + return m.validate(true) +} + +func (m *Blob) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, BlobValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, BlobValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return BlobValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Uri + + if len(errors) > 0 { + return BlobMultiError(errors) + } + + return nil +} + +// BlobMultiError is an error wrapping multiple validation errors returned by +// Blob.ValidateAll() if the designated constraints aren't met. +type BlobMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m BlobMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m BlobMultiError) AllErrors() []error { return m } + +// BlobValidationError is the validation error returned by Blob.Validate if the +// designated constraints aren't met. +type BlobValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e BlobValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e BlobValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e BlobValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e BlobValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e BlobValidationError) ErrorName() string { return "BlobValidationError" } + +// Error satisfies the builtin error interface +func (e BlobValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sBlob.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = BlobValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = BlobValidationError{} + +// Validate checks the field values on BlobMetadata with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *BlobMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on BlobMetadata with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in BlobMetadataMultiError, or +// nil if none found. +func (m *BlobMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *BlobMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetType()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, BlobMetadataValidationError{ + field: "Type", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, BlobMetadataValidationError{ + field: "Type", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetType()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return BlobMetadataValidationError{ + field: "Type", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return BlobMetadataMultiError(errors) + } + + return nil +} + +// BlobMetadataMultiError is an error wrapping multiple validation errors +// returned by BlobMetadata.ValidateAll() if the designated constraints aren't met. +type BlobMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m BlobMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m BlobMetadataMultiError) AllErrors() []error { return m } + +// BlobMetadataValidationError is the validation error returned by +// BlobMetadata.Validate if the designated constraints aren't met. +type BlobMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e BlobMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e BlobMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e BlobMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e BlobMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e BlobMetadataValidationError) ErrorName() string { return "BlobMetadataValidationError" } + +// Error satisfies the builtin error interface +func (e BlobMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sBlobMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = BlobMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = BlobMetadataValidationError{} + +// Validate checks the field values on Binary with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Binary) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Binary with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in BinaryMultiError, or nil if none found. +func (m *Binary) ValidateAll() error { + return m.validate(true) +} + +func (m *Binary) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Value + + // no validation rules for Tag + + if len(errors) > 0 { + return BinaryMultiError(errors) + } + + return nil +} + +// BinaryMultiError is an error wrapping multiple validation errors returned by +// Binary.ValidateAll() if the designated constraints aren't met. +type BinaryMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m BinaryMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m BinaryMultiError) AllErrors() []error { return m } + +// BinaryValidationError is the validation error returned by Binary.Validate if +// the designated constraints aren't met. +type BinaryValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e BinaryValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e BinaryValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e BinaryValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e BinaryValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e BinaryValidationError) ErrorName() string { return "BinaryValidationError" } + +// Error satisfies the builtin error interface +func (e BinaryValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sBinary.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = BinaryValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = BinaryValidationError{} + +// Validate checks the field values on Schema with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Schema) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Schema with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in SchemaMultiError, or nil if none found. +func (m *Schema) ValidateAll() error { + return m.validate(true) +} + +func (m *Schema) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Uri + + if all { + switch v := interface{}(m.GetType()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SchemaValidationError{ + field: "Type", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SchemaValidationError{ + field: "Type", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetType()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SchemaValidationError{ + field: "Type", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return SchemaMultiError(errors) + } + + return nil +} + +// SchemaMultiError is an error wrapping multiple validation errors returned by +// Schema.ValidateAll() if the designated constraints aren't met. +type SchemaMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SchemaMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SchemaMultiError) AllErrors() []error { return m } + +// SchemaValidationError is the validation error returned by Schema.Validate if +// the designated constraints aren't met. +type SchemaValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SchemaValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SchemaValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SchemaValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SchemaValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SchemaValidationError) ErrorName() string { return "SchemaValidationError" } + +// Error satisfies the builtin error interface +func (e SchemaValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSchema.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SchemaValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SchemaValidationError{} + +// Validate checks the field values on Union with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Union) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Union with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in UnionMultiError, or nil if none found. +func (m *Union) ValidateAll() error { + return m.validate(true) +} + +func (m *Union) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetValue()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UnionValidationError{ + field: "Value", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UnionValidationError{ + field: "Value", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetValue()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UnionValidationError{ + field: "Value", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetType()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UnionValidationError{ + field: "Type", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UnionValidationError{ + field: "Type", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetType()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UnionValidationError{ + field: "Type", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return UnionMultiError(errors) + } + + return nil +} + +// UnionMultiError is an error wrapping multiple validation errors returned by +// Union.ValidateAll() if the designated constraints aren't met. +type UnionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UnionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UnionMultiError) AllErrors() []error { return m } + +// UnionValidationError is the validation error returned by Union.Validate if +// the designated constraints aren't met. +type UnionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UnionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UnionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UnionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UnionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UnionValidationError) ErrorName() string { return "UnionValidationError" } + +// Error satisfies the builtin error interface +func (e UnionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUnion.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UnionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UnionValidationError{} + +// Validate checks the field values on StructuredDatasetMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *StructuredDatasetMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on StructuredDatasetMetadata with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// StructuredDatasetMetadataMultiError, or nil if none found. +func (m *StructuredDatasetMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *StructuredDatasetMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetStructuredDatasetType()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, StructuredDatasetMetadataValidationError{ + field: "StructuredDatasetType", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, StructuredDatasetMetadataValidationError{ + field: "StructuredDatasetType", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStructuredDatasetType()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return StructuredDatasetMetadataValidationError{ + field: "StructuredDatasetType", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return StructuredDatasetMetadataMultiError(errors) + } + + return nil +} + +// StructuredDatasetMetadataMultiError is an error wrapping multiple validation +// errors returned by StructuredDatasetMetadata.ValidateAll() if the +// designated constraints aren't met. +type StructuredDatasetMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m StructuredDatasetMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m StructuredDatasetMetadataMultiError) AllErrors() []error { return m } + +// StructuredDatasetMetadataValidationError is the validation error returned by +// StructuredDatasetMetadata.Validate if the designated constraints aren't met. +type StructuredDatasetMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e StructuredDatasetMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e StructuredDatasetMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e StructuredDatasetMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e StructuredDatasetMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e StructuredDatasetMetadataValidationError) ErrorName() string { + return "StructuredDatasetMetadataValidationError" +} + +// Error satisfies the builtin error interface +func (e StructuredDatasetMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sStructuredDatasetMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = StructuredDatasetMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = StructuredDatasetMetadataValidationError{} + +// Validate checks the field values on StructuredDataset with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *StructuredDataset) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on StructuredDataset with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// StructuredDatasetMultiError, or nil if none found. +func (m *StructuredDataset) ValidateAll() error { + return m.validate(true) +} + +func (m *StructuredDataset) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Uri + + if all { + switch v := interface{}(m.GetMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, StructuredDatasetValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, StructuredDatasetValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return StructuredDatasetValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return StructuredDatasetMultiError(errors) + } + + return nil +} + +// StructuredDatasetMultiError is an error wrapping multiple validation errors +// returned by StructuredDataset.ValidateAll() if the designated constraints +// aren't met. +type StructuredDatasetMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m StructuredDatasetMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m StructuredDatasetMultiError) AllErrors() []error { return m } + +// StructuredDatasetValidationError is the validation error returned by +// StructuredDataset.Validate if the designated constraints aren't met. +type StructuredDatasetValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e StructuredDatasetValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e StructuredDatasetValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e StructuredDatasetValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e StructuredDatasetValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e StructuredDatasetValidationError) ErrorName() string { + return "StructuredDatasetValidationError" +} + +// Error satisfies the builtin error interface +func (e StructuredDatasetValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sStructuredDataset.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = StructuredDatasetValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = StructuredDatasetValidationError{} + +// Validate checks the field values on Scalar with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Scalar) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Scalar with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in ScalarMultiError, or nil if none found. +func (m *Scalar) ValidateAll() error { + return m.validate(true) +} + +func (m *Scalar) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Value.(type) { + case *Scalar_Primitive: + if v == nil { + err := ScalarValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetPrimitive()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ScalarValidationError{ + field: "Primitive", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ScalarValidationError{ + field: "Primitive", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetPrimitive()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ScalarValidationError{ + field: "Primitive", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Scalar_Blob: + if v == nil { + err := ScalarValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetBlob()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ScalarValidationError{ + field: "Blob", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ScalarValidationError{ + field: "Blob", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetBlob()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ScalarValidationError{ + field: "Blob", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Scalar_Binary: + if v == nil { + err := ScalarValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetBinary()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ScalarValidationError{ + field: "Binary", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ScalarValidationError{ + field: "Binary", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetBinary()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ScalarValidationError{ + field: "Binary", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Scalar_Schema: + if v == nil { + err := ScalarValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetSchema()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ScalarValidationError{ + field: "Schema", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ScalarValidationError{ + field: "Schema", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSchema()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ScalarValidationError{ + field: "Schema", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Scalar_NoneType: + if v == nil { + err := ScalarValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetNoneType()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ScalarValidationError{ + field: "NoneType", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ScalarValidationError{ + field: "NoneType", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetNoneType()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ScalarValidationError{ + field: "NoneType", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Scalar_Error: + if v == nil { + err := ScalarValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetError()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ScalarValidationError{ + field: "Error", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ScalarValidationError{ + field: "Error", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetError()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ScalarValidationError{ + field: "Error", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Scalar_Generic: + if v == nil { + err := ScalarValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetGeneric()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ScalarValidationError{ + field: "Generic", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ScalarValidationError{ + field: "Generic", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetGeneric()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ScalarValidationError{ + field: "Generic", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Scalar_StructuredDataset: + if v == nil { + err := ScalarValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetStructuredDataset()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ScalarValidationError{ + field: "StructuredDataset", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ScalarValidationError{ + field: "StructuredDataset", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStructuredDataset()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ScalarValidationError{ + field: "StructuredDataset", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Scalar_Union: + if v == nil { + err := ScalarValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetUnion()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ScalarValidationError{ + field: "Union", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ScalarValidationError{ + field: "Union", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetUnion()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ScalarValidationError{ + field: "Union", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return ScalarMultiError(errors) + } + + return nil +} + +// ScalarMultiError is an error wrapping multiple validation errors returned by +// Scalar.ValidateAll() if the designated constraints aren't met. +type ScalarMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ScalarMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ScalarMultiError) AllErrors() []error { return m } + +// ScalarValidationError is the validation error returned by Scalar.Validate if +// the designated constraints aren't met. +type ScalarValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ScalarValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ScalarValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ScalarValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ScalarValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ScalarValidationError) ErrorName() string { return "ScalarValidationError" } + +// Error satisfies the builtin error interface +func (e ScalarValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sScalar.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ScalarValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ScalarValidationError{} + +// Validate checks the field values on Literal with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Literal) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Literal with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in LiteralMultiError, or nil if none found. +func (m *Literal) ValidateAll() error { + return m.validate(true) +} + +func (m *Literal) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Hash + + // no validation rules for Metadata + + switch v := m.Value.(type) { + case *Literal_Scalar: + if v == nil { + err := LiteralValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetScalar()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralValidationError{ + field: "Scalar", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralValidationError{ + field: "Scalar", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetScalar()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralValidationError{ + field: "Scalar", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Literal_Collection: + if v == nil { + err := LiteralValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetCollection()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralValidationError{ + field: "Collection", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralValidationError{ + field: "Collection", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCollection()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralValidationError{ + field: "Collection", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Literal_Map: + if v == nil { + err := LiteralValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetMap()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralValidationError{ + field: "Map", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralValidationError{ + field: "Map", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMap()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralValidationError{ + field: "Map", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Literal_OffloadedMetadata: + if v == nil { + err := LiteralValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetOffloadedMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralValidationError{ + field: "OffloadedMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralValidationError{ + field: "OffloadedMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOffloadedMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralValidationError{ + field: "OffloadedMetadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return LiteralMultiError(errors) + } + + return nil +} + +// LiteralMultiError is an error wrapping multiple validation errors returned +// by Literal.ValidateAll() if the designated constraints aren't met. +type LiteralMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LiteralMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LiteralMultiError) AllErrors() []error { return m } + +// LiteralValidationError is the validation error returned by Literal.Validate +// if the designated constraints aren't met. +type LiteralValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LiteralValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LiteralValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LiteralValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LiteralValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LiteralValidationError) ErrorName() string { return "LiteralValidationError" } + +// Error satisfies the builtin error interface +func (e LiteralValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLiteral.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LiteralValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LiteralValidationError{} + +// Validate checks the field values on LiteralOffloadedMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *LiteralOffloadedMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LiteralOffloadedMetadata with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// LiteralOffloadedMetadataMultiError, or nil if none found. +func (m *LiteralOffloadedMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *LiteralOffloadedMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Uri + + // no validation rules for SizeBytes + + if all { + switch v := interface{}(m.GetInferredType()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralOffloadedMetadataValidationError{ + field: "InferredType", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralOffloadedMetadataValidationError{ + field: "InferredType", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetInferredType()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralOffloadedMetadataValidationError{ + field: "InferredType", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return LiteralOffloadedMetadataMultiError(errors) + } + + return nil +} + +// LiteralOffloadedMetadataMultiError is an error wrapping multiple validation +// errors returned by LiteralOffloadedMetadata.ValidateAll() if the designated +// constraints aren't met. +type LiteralOffloadedMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LiteralOffloadedMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LiteralOffloadedMetadataMultiError) AllErrors() []error { return m } + +// LiteralOffloadedMetadataValidationError is the validation error returned by +// LiteralOffloadedMetadata.Validate if the designated constraints aren't met. +type LiteralOffloadedMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LiteralOffloadedMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LiteralOffloadedMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LiteralOffloadedMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LiteralOffloadedMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LiteralOffloadedMetadataValidationError) ErrorName() string { + return "LiteralOffloadedMetadataValidationError" +} + +// Error satisfies the builtin error interface +func (e LiteralOffloadedMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLiteralOffloadedMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LiteralOffloadedMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LiteralOffloadedMetadataValidationError{} + +// Validate checks the field values on LiteralCollection with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *LiteralCollection) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LiteralCollection with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// LiteralCollectionMultiError, or nil if none found. +func (m *LiteralCollection) ValidateAll() error { + return m.validate(true) +} + +func (m *LiteralCollection) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetLiterals() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralCollectionValidationError{ + field: fmt.Sprintf("Literals[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralCollectionValidationError{ + field: fmt.Sprintf("Literals[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralCollectionValidationError{ + field: fmt.Sprintf("Literals[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return LiteralCollectionMultiError(errors) + } + + return nil +} + +// LiteralCollectionMultiError is an error wrapping multiple validation errors +// returned by LiteralCollection.ValidateAll() if the designated constraints +// aren't met. +type LiteralCollectionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LiteralCollectionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LiteralCollectionMultiError) AllErrors() []error { return m } + +// LiteralCollectionValidationError is the validation error returned by +// LiteralCollection.Validate if the designated constraints aren't met. +type LiteralCollectionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LiteralCollectionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LiteralCollectionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LiteralCollectionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LiteralCollectionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LiteralCollectionValidationError) ErrorName() string { + return "LiteralCollectionValidationError" +} + +// Error satisfies the builtin error interface +func (e LiteralCollectionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLiteralCollection.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LiteralCollectionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LiteralCollectionValidationError{} + +// Validate checks the field values on LiteralMap with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *LiteralMap) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LiteralMap with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in LiteralMapMultiError, or +// nil if none found. +func (m *LiteralMap) ValidateAll() error { + return m.validate(true) +} + +func (m *LiteralMap) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + { + sorted_keys := make([]string, len(m.GetLiterals())) + i := 0 + for key := range m.GetLiterals() { + sorted_keys[i] = key + i++ + } + sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] }) + for _, key := range sorted_keys { + val := m.GetLiterals()[key] + _ = val + + // no validation rules for Literals[key] + + if all { + switch v := interface{}(val).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralMapValidationError{ + field: fmt.Sprintf("Literals[%v]", key), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralMapValidationError{ + field: fmt.Sprintf("Literals[%v]", key), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(val).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralMapValidationError{ + field: fmt.Sprintf("Literals[%v]", key), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + } + + if len(errors) > 0 { + return LiteralMapMultiError(errors) + } + + return nil +} + +// LiteralMapMultiError is an error wrapping multiple validation errors +// returned by LiteralMap.ValidateAll() if the designated constraints aren't met. +type LiteralMapMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LiteralMapMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LiteralMapMultiError) AllErrors() []error { return m } + +// LiteralMapValidationError is the validation error returned by +// LiteralMap.Validate if the designated constraints aren't met. +type LiteralMapValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LiteralMapValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LiteralMapValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LiteralMapValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LiteralMapValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LiteralMapValidationError) ErrorName() string { return "LiteralMapValidationError" } + +// Error satisfies the builtin error interface +func (e LiteralMapValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLiteralMap.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LiteralMapValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LiteralMapValidationError{} + +// Validate checks the field values on BindingDataCollection with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *BindingDataCollection) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on BindingDataCollection with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// BindingDataCollectionMultiError, or nil if none found. +func (m *BindingDataCollection) ValidateAll() error { + return m.validate(true) +} + +func (m *BindingDataCollection) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetBindings() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, BindingDataCollectionValidationError{ + field: fmt.Sprintf("Bindings[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, BindingDataCollectionValidationError{ + field: fmt.Sprintf("Bindings[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return BindingDataCollectionValidationError{ + field: fmt.Sprintf("Bindings[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return BindingDataCollectionMultiError(errors) + } + + return nil +} + +// BindingDataCollectionMultiError is an error wrapping multiple validation +// errors returned by BindingDataCollection.ValidateAll() if the designated +// constraints aren't met. +type BindingDataCollectionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m BindingDataCollectionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m BindingDataCollectionMultiError) AllErrors() []error { return m } + +// BindingDataCollectionValidationError is the validation error returned by +// BindingDataCollection.Validate if the designated constraints aren't met. +type BindingDataCollectionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e BindingDataCollectionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e BindingDataCollectionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e BindingDataCollectionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e BindingDataCollectionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e BindingDataCollectionValidationError) ErrorName() string { + return "BindingDataCollectionValidationError" +} + +// Error satisfies the builtin error interface +func (e BindingDataCollectionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sBindingDataCollection.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = BindingDataCollectionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = BindingDataCollectionValidationError{} + +// Validate checks the field values on BindingDataMap with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *BindingDataMap) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on BindingDataMap with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in BindingDataMapMultiError, +// or nil if none found. +func (m *BindingDataMap) ValidateAll() error { + return m.validate(true) +} + +func (m *BindingDataMap) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + { + sorted_keys := make([]string, len(m.GetBindings())) + i := 0 + for key := range m.GetBindings() { + sorted_keys[i] = key + i++ + } + sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] }) + for _, key := range sorted_keys { + val := m.GetBindings()[key] + _ = val + + // no validation rules for Bindings[key] + + if all { + switch v := interface{}(val).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, BindingDataMapValidationError{ + field: fmt.Sprintf("Bindings[%v]", key), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, BindingDataMapValidationError{ + field: fmt.Sprintf("Bindings[%v]", key), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(val).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return BindingDataMapValidationError{ + field: fmt.Sprintf("Bindings[%v]", key), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + } + + if len(errors) > 0 { + return BindingDataMapMultiError(errors) + } + + return nil +} + +// BindingDataMapMultiError is an error wrapping multiple validation errors +// returned by BindingDataMap.ValidateAll() if the designated constraints +// aren't met. +type BindingDataMapMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m BindingDataMapMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m BindingDataMapMultiError) AllErrors() []error { return m } + +// BindingDataMapValidationError is the validation error returned by +// BindingDataMap.Validate if the designated constraints aren't met. +type BindingDataMapValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e BindingDataMapValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e BindingDataMapValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e BindingDataMapValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e BindingDataMapValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e BindingDataMapValidationError) ErrorName() string { return "BindingDataMapValidationError" } + +// Error satisfies the builtin error interface +func (e BindingDataMapValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sBindingDataMap.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = BindingDataMapValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = BindingDataMapValidationError{} + +// Validate checks the field values on UnionInfo with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *UnionInfo) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on UnionInfo with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in UnionInfoMultiError, or nil +// if none found. +func (m *UnionInfo) ValidateAll() error { + return m.validate(true) +} + +func (m *UnionInfo) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetTargetType()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UnionInfoValidationError{ + field: "TargetType", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UnionInfoValidationError{ + field: "TargetType", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTargetType()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UnionInfoValidationError{ + field: "TargetType", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return UnionInfoMultiError(errors) + } + + return nil +} + +// UnionInfoMultiError is an error wrapping multiple validation errors returned +// by UnionInfo.ValidateAll() if the designated constraints aren't met. +type UnionInfoMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UnionInfoMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UnionInfoMultiError) AllErrors() []error { return m } + +// UnionInfoValidationError is the validation error returned by +// UnionInfo.Validate if the designated constraints aren't met. +type UnionInfoValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UnionInfoValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UnionInfoValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UnionInfoValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UnionInfoValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UnionInfoValidationError) ErrorName() string { return "UnionInfoValidationError" } + +// Error satisfies the builtin error interface +func (e UnionInfoValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUnionInfo.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UnionInfoValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UnionInfoValidationError{} + +// Validate checks the field values on BindingData with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *BindingData) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on BindingData with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in BindingDataMultiError, or +// nil if none found. +func (m *BindingData) ValidateAll() error { + return m.validate(true) +} + +func (m *BindingData) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetUnion()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, BindingDataValidationError{ + field: "Union", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, BindingDataValidationError{ + field: "Union", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetUnion()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return BindingDataValidationError{ + field: "Union", + reason: "embedded message failed validation", + cause: err, + } + } + } + + switch v := m.Value.(type) { + case *BindingData_Scalar: + if v == nil { + err := BindingDataValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetScalar()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, BindingDataValidationError{ + field: "Scalar", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, BindingDataValidationError{ + field: "Scalar", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetScalar()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return BindingDataValidationError{ + field: "Scalar", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *BindingData_Collection: + if v == nil { + err := BindingDataValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetCollection()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, BindingDataValidationError{ + field: "Collection", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, BindingDataValidationError{ + field: "Collection", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCollection()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return BindingDataValidationError{ + field: "Collection", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *BindingData_Promise: + if v == nil { + err := BindingDataValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetPromise()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, BindingDataValidationError{ + field: "Promise", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, BindingDataValidationError{ + field: "Promise", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetPromise()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return BindingDataValidationError{ + field: "Promise", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *BindingData_Map: + if v == nil { + err := BindingDataValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetMap()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, BindingDataValidationError{ + field: "Map", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, BindingDataValidationError{ + field: "Map", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMap()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return BindingDataValidationError{ + field: "Map", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *BindingData_OffloadedMetadata: + if v == nil { + err := BindingDataValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetOffloadedMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, BindingDataValidationError{ + field: "OffloadedMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, BindingDataValidationError{ + field: "OffloadedMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOffloadedMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return BindingDataValidationError{ + field: "OffloadedMetadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return BindingDataMultiError(errors) + } + + return nil +} + +// BindingDataMultiError is an error wrapping multiple validation errors +// returned by BindingData.ValidateAll() if the designated constraints aren't met. +type BindingDataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m BindingDataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m BindingDataMultiError) AllErrors() []error { return m } + +// BindingDataValidationError is the validation error returned by +// BindingData.Validate if the designated constraints aren't met. +type BindingDataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e BindingDataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e BindingDataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e BindingDataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e BindingDataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e BindingDataValidationError) ErrorName() string { return "BindingDataValidationError" } + +// Error satisfies the builtin error interface +func (e BindingDataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sBindingData.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = BindingDataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = BindingDataValidationError{} + +// Validate checks the field values on Binding with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Binding) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Binding with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in BindingMultiError, or nil if none found. +func (m *Binding) ValidateAll() error { + return m.validate(true) +} + +func (m *Binding) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Var + + if all { + switch v := interface{}(m.GetBinding()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, BindingValidationError{ + field: "Binding", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, BindingValidationError{ + field: "Binding", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetBinding()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return BindingValidationError{ + field: "Binding", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return BindingMultiError(errors) + } + + return nil +} + +// BindingMultiError is an error wrapping multiple validation errors returned +// by Binding.ValidateAll() if the designated constraints aren't met. +type BindingMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m BindingMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m BindingMultiError) AllErrors() []error { return m } + +// BindingValidationError is the validation error returned by Binding.Validate +// if the designated constraints aren't met. +type BindingValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e BindingValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e BindingValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e BindingValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e BindingValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e BindingValidationError) ErrorName() string { return "BindingValidationError" } + +// Error satisfies the builtin error interface +func (e BindingValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sBinding.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = BindingValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = BindingValidationError{} + +// Validate checks the field values on KeyValuePair with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *KeyValuePair) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on KeyValuePair with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in KeyValuePairMultiError, or +// nil if none found. +func (m *KeyValuePair) ValidateAll() error { + return m.validate(true) +} + +func (m *KeyValuePair) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Key + + // no validation rules for Value + + if len(errors) > 0 { + return KeyValuePairMultiError(errors) + } + + return nil +} + +// KeyValuePairMultiError is an error wrapping multiple validation errors +// returned by KeyValuePair.ValidateAll() if the designated constraints aren't met. +type KeyValuePairMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m KeyValuePairMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m KeyValuePairMultiError) AllErrors() []error { return m } + +// KeyValuePairValidationError is the validation error returned by +// KeyValuePair.Validate if the designated constraints aren't met. +type KeyValuePairValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e KeyValuePairValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e KeyValuePairValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e KeyValuePairValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e KeyValuePairValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e KeyValuePairValidationError) ErrorName() string { return "KeyValuePairValidationError" } + +// Error satisfies the builtin error interface +func (e KeyValuePairValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sKeyValuePair.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = KeyValuePairValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = KeyValuePairValidationError{} + +// Validate checks the field values on RetryStrategy with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *RetryStrategy) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on RetryStrategy with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in RetryStrategyMultiError, or +// nil if none found. +func (m *RetryStrategy) ValidateAll() error { + return m.validate(true) +} + +func (m *RetryStrategy) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Retries + + if len(errors) > 0 { + return RetryStrategyMultiError(errors) + } + + return nil +} + +// RetryStrategyMultiError is an error wrapping multiple validation errors +// returned by RetryStrategy.ValidateAll() if the designated constraints +// aren't met. +type RetryStrategyMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m RetryStrategyMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m RetryStrategyMultiError) AllErrors() []error { return m } + +// RetryStrategyValidationError is the validation error returned by +// RetryStrategy.Validate if the designated constraints aren't met. +type RetryStrategyValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e RetryStrategyValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e RetryStrategyValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e RetryStrategyValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e RetryStrategyValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e RetryStrategyValidationError) ErrorName() string { return "RetryStrategyValidationError" } + +// Error satisfies the builtin error interface +func (e RetryStrategyValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sRetryStrategy.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = RetryStrategyValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = RetryStrategyValidationError{} diff --git a/gen/go/flyteidl2/core/metrics.pb.go b/gen/go/flyteidl2/core/metrics.pb.go new file mode 100644 index 0000000000..54d19c8777 --- /dev/null +++ b/gen/go/flyteidl2/core/metrics.pb.go @@ -0,0 +1,177 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/core/metrics.proto + +package core + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + structpb "google.golang.org/protobuf/types/known/structpb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// ExecutionMetrics is a collection of metrics that are collected during the execution of a Flyte task. +type ExecutionMetricResult struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The metric this data represents. e.g. EXECUTION_METRIC_USED_CPU_AVG or EXECUTION_METRIC_USED_MEMORY_BYTES_AVG. + Metric string `protobuf:"bytes,1,opt,name=metric,proto3" json:"metric,omitempty"` + // The result data in prometheus range query result format + // https://prometheus.io/docs/prometheus/latest/querying/api/#expression-query-result-formats. + // This may include multiple time series, differentiated by their metric labels. + // Start time is greater of (execution attempt start, 48h ago) + // End time is lesser of (execution attempt end, now) + Data *structpb.Struct `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` +} + +func (x *ExecutionMetricResult) Reset() { + *x = ExecutionMetricResult{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_metrics_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ExecutionMetricResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExecutionMetricResult) ProtoMessage() {} + +func (x *ExecutionMetricResult) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_metrics_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExecutionMetricResult.ProtoReflect.Descriptor instead. +func (*ExecutionMetricResult) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_metrics_proto_rawDescGZIP(), []int{0} +} + +func (x *ExecutionMetricResult) GetMetric() string { + if x != nil { + return x.Metric + } + return "" +} + +func (x *ExecutionMetricResult) GetData() *structpb.Struct { + if x != nil { + return x.Data + } + return nil +} + +var File_flyteidl2_core_metrics_proto protoreflect.FileDescriptor + +var file_flyteidl2_core_metrics_proto_rawDesc = []byte{ + 0x0a, 0x1c, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x1a, 0x1c, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, + 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x5c, 0x0a, 0x15, + 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x52, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x2b, 0x0a, + 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, + 0x72, 0x75, 0x63, 0x74, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x42, 0xb1, 0x01, 0x0a, 0x12, 0x63, + 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x42, 0x0c, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, + 0x02, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, + 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x0e, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0xca, 0x02, + 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0xe2, + 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_core_metrics_proto_rawDescOnce sync.Once + file_flyteidl2_core_metrics_proto_rawDescData = file_flyteidl2_core_metrics_proto_rawDesc +) + +func file_flyteidl2_core_metrics_proto_rawDescGZIP() []byte { + file_flyteidl2_core_metrics_proto_rawDescOnce.Do(func() { + file_flyteidl2_core_metrics_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_core_metrics_proto_rawDescData) + }) + return file_flyteidl2_core_metrics_proto_rawDescData +} + +var file_flyteidl2_core_metrics_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_flyteidl2_core_metrics_proto_goTypes = []interface{}{ + (*ExecutionMetricResult)(nil), // 0: flyteidl2.core.ExecutionMetricResult + (*structpb.Struct)(nil), // 1: google.protobuf.Struct +} +var file_flyteidl2_core_metrics_proto_depIdxs = []int32{ + 1, // 0: flyteidl2.core.ExecutionMetricResult.data:type_name -> google.protobuf.Struct + 1, // [1:1] is the sub-list for method output_type + 1, // [1:1] is the sub-list for method input_type + 1, // [1:1] is the sub-list for extension type_name + 1, // [1:1] is the sub-list for extension extendee + 0, // [0:1] is the sub-list for field type_name +} + +func init() { file_flyteidl2_core_metrics_proto_init() } +func file_flyteidl2_core_metrics_proto_init() { + if File_flyteidl2_core_metrics_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_core_metrics_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ExecutionMetricResult); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_core_metrics_proto_rawDesc, + NumEnums: 0, + NumMessages: 1, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_core_metrics_proto_goTypes, + DependencyIndexes: file_flyteidl2_core_metrics_proto_depIdxs, + MessageInfos: file_flyteidl2_core_metrics_proto_msgTypes, + }.Build() + File_flyteidl2_core_metrics_proto = out.File + file_flyteidl2_core_metrics_proto_rawDesc = nil + file_flyteidl2_core_metrics_proto_goTypes = nil + file_flyteidl2_core_metrics_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/core/metrics.pb.validate.go b/gen/go/flyteidl2/core/metrics.pb.validate.go new file mode 100644 index 0000000000..49ec89eca9 --- /dev/null +++ b/gen/go/flyteidl2/core/metrics.pb.validate.go @@ -0,0 +1,169 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/core/metrics.proto + +package core + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on ExecutionMetricResult with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ExecutionMetricResult) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ExecutionMetricResult with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ExecutionMetricResultMultiError, or nil if none found. +func (m *ExecutionMetricResult) ValidateAll() error { + return m.validate(true) +} + +func (m *ExecutionMetricResult) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Metric + + if all { + switch v := interface{}(m.GetData()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ExecutionMetricResultValidationError{ + field: "Data", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ExecutionMetricResultValidationError{ + field: "Data", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetData()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ExecutionMetricResultValidationError{ + field: "Data", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ExecutionMetricResultMultiError(errors) + } + + return nil +} + +// ExecutionMetricResultMultiError is an error wrapping multiple validation +// errors returned by ExecutionMetricResult.ValidateAll() if the designated +// constraints aren't met. +type ExecutionMetricResultMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ExecutionMetricResultMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ExecutionMetricResultMultiError) AllErrors() []error { return m } + +// ExecutionMetricResultValidationError is the validation error returned by +// ExecutionMetricResult.Validate if the designated constraints aren't met. +type ExecutionMetricResultValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ExecutionMetricResultValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ExecutionMetricResultValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ExecutionMetricResultValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ExecutionMetricResultValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ExecutionMetricResultValidationError) ErrorName() string { + return "ExecutionMetricResultValidationError" +} + +// Error satisfies the builtin error interface +func (e ExecutionMetricResultValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sExecutionMetricResult.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ExecutionMetricResultValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ExecutionMetricResultValidationError{} diff --git a/gen/go/flyteidl2/core/security.pb.go b/gen/go/flyteidl2/core/security.pb.go new file mode 100644 index 0000000000..cb083f7354 --- /dev/null +++ b/gen/go/flyteidl2/core/security.pb.go @@ -0,0 +1,845 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/core/security.proto + +package core + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type Secret_MountType int32 + +const ( + // Default case, indicates the client can tolerate either mounting options. + Secret_ANY Secret_MountType = 0 + // ENV_VAR indicates the secret needs to be mounted as an environment variable. + Secret_ENV_VAR Secret_MountType = 1 + // FILE indicates the secret needs to be mounted as a file. + Secret_FILE Secret_MountType = 2 +) + +// Enum value maps for Secret_MountType. +var ( + Secret_MountType_name = map[int32]string{ + 0: "ANY", + 1: "ENV_VAR", + 2: "FILE", + } + Secret_MountType_value = map[string]int32{ + "ANY": 0, + "ENV_VAR": 1, + "FILE": 2, + } +) + +func (x Secret_MountType) Enum() *Secret_MountType { + p := new(Secret_MountType) + *p = x + return p +} + +func (x Secret_MountType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Secret_MountType) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_security_proto_enumTypes[0].Descriptor() +} + +func (Secret_MountType) Type() protoreflect.EnumType { + return &file_flyteidl2_core_security_proto_enumTypes[0] +} + +func (x Secret_MountType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Secret_MountType.Descriptor instead. +func (Secret_MountType) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_security_proto_rawDescGZIP(), []int{0, 0} +} + +// Type of the token requested. +type OAuth2TokenRequest_Type int32 + +const ( + // CLIENT_CREDENTIALS indicates a 2-legged OAuth token requested using client credentials. + OAuth2TokenRequest_CLIENT_CREDENTIALS OAuth2TokenRequest_Type = 0 +) + +// Enum value maps for OAuth2TokenRequest_Type. +var ( + OAuth2TokenRequest_Type_name = map[int32]string{ + 0: "CLIENT_CREDENTIALS", + } + OAuth2TokenRequest_Type_value = map[string]int32{ + "CLIENT_CREDENTIALS": 0, + } +) + +func (x OAuth2TokenRequest_Type) Enum() *OAuth2TokenRequest_Type { + p := new(OAuth2TokenRequest_Type) + *p = x + return p +} + +func (x OAuth2TokenRequest_Type) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (OAuth2TokenRequest_Type) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_security_proto_enumTypes[1].Descriptor() +} + +func (OAuth2TokenRequest_Type) Type() protoreflect.EnumType { + return &file_flyteidl2_core_security_proto_enumTypes[1] +} + +func (x OAuth2TokenRequest_Type) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use OAuth2TokenRequest_Type.Descriptor instead. +func (OAuth2TokenRequest_Type) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_security_proto_rawDescGZIP(), []int{4, 0} +} + +// Secret encapsulates information about the secret a task needs to proceed. An environment variable +// FLYTE_SECRETS_ENV_PREFIX will be passed to indicate the prefix of the environment variables that will be present if +// secrets are passed through environment variables. +// FLYTE_SECRETS_DEFAULT_DIR will be passed to indicate the prefix of the path where secrets will be mounted if secrets +// are passed through file mounts. +type Secret struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The name of the secret group where to find the key referenced below. For K8s secrets, this should be the name of + // the v1/secret object. For Confidant, this should be the Credential name. For Vault, this should be the secret name. + // For AWS Secret Manager, this should be the name of the secret. + // +required + Group string `protobuf:"bytes,1,opt,name=group,proto3" json:"group,omitempty"` + // The group version to fetch. This is not supported in all secret management systems. It'll be ignored for the ones + // that do not support it. + // +optional + GroupVersion string `protobuf:"bytes,2,opt,name=group_version,json=groupVersion,proto3" json:"group_version,omitempty"` + // The name of the secret to mount. This has to match an existing secret in the system. It's up to the implementation + // of the secret management system to require case sensitivity. For K8s secrets, Confidant and Vault, this should + // match one of the keys inside the secret. For AWS Secret Manager, it's ignored. + // +optional + Key string `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"` + // mount_requirement is optional. Indicates where the secret has to be mounted. If provided, the execution will fail + // if the underlying key management system cannot satisfy that requirement. If not provided, the default location + // will depend on the key management system. + // +optional + MountRequirement Secret_MountType `protobuf:"varint,4,opt,name=mount_requirement,json=mountRequirement,proto3,enum=flyteidl2.core.Secret_MountType" json:"mount_requirement,omitempty"` + // env_var is optional. Custom environment variable to set the value of the secret. If mount_requirement is ENV_VAR, + // then the value is the secret itself. If mount_requirement is FILE, then the value is the path to the secret file. + // +optional + EnvVar string `protobuf:"bytes,5,opt,name=env_var,json=envVar,proto3" json:"env_var,omitempty"` +} + +func (x *Secret) Reset() { + *x = Secret{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_security_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Secret) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Secret) ProtoMessage() {} + +func (x *Secret) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_security_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Secret.ProtoReflect.Descriptor instead. +func (*Secret) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_security_proto_rawDescGZIP(), []int{0} +} + +func (x *Secret) GetGroup() string { + if x != nil { + return x.Group + } + return "" +} + +func (x *Secret) GetGroupVersion() string { + if x != nil { + return x.GroupVersion + } + return "" +} + +func (x *Secret) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *Secret) GetMountRequirement() Secret_MountType { + if x != nil { + return x.MountRequirement + } + return Secret_ANY +} + +func (x *Secret) GetEnvVar() string { + if x != nil { + return x.EnvVar + } + return "" +} + +type Connection struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The task type that the connection is used for. + TaskType string `protobuf:"bytes,1,opt,name=task_type,json=taskType,proto3" json:"task_type,omitempty"` + // The credentials to use for the connection, such as API keys, OAuth2 tokens, etc. + // The key is the name of the secret, and it's defined in the flytekit. + // flytekit uses the key to locate the desired secret within the map. + Secrets map[string]string `protobuf:"bytes,2,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // The configuration to use for the connection, such as the endpoint, account name, etc. + // The key is the name of the config, and it's defined in the flytekit. + Configs map[string]string `protobuf:"bytes,3,rep,name=configs,proto3" json:"configs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *Connection) Reset() { + *x = Connection{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_security_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Connection) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Connection) ProtoMessage() {} + +func (x *Connection) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_security_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Connection.ProtoReflect.Descriptor instead. +func (*Connection) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_security_proto_rawDescGZIP(), []int{1} +} + +func (x *Connection) GetTaskType() string { + if x != nil { + return x.TaskType + } + return "" +} + +func (x *Connection) GetSecrets() map[string]string { + if x != nil { + return x.Secrets + } + return nil +} + +func (x *Connection) GetConfigs() map[string]string { + if x != nil { + return x.Configs + } + return nil +} + +// OAuth2Client encapsulates OAuth2 Client Credentials to be used when making calls on behalf of that task. +type OAuth2Client struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // client_id is the public id for the client to use. The system will not perform any pre-auth validation that the + // secret requested matches the client_id indicated here. + // +required + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + // client_secret is a reference to the secret used to authenticate the OAuth2 client. + // +required + ClientSecret *Secret `protobuf:"bytes,2,opt,name=client_secret,json=clientSecret,proto3" json:"client_secret,omitempty"` +} + +func (x *OAuth2Client) Reset() { + *x = OAuth2Client{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_security_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OAuth2Client) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OAuth2Client) ProtoMessage() {} + +func (x *OAuth2Client) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_security_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OAuth2Client.ProtoReflect.Descriptor instead. +func (*OAuth2Client) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_security_proto_rawDescGZIP(), []int{2} +} + +func (x *OAuth2Client) GetClientId() string { + if x != nil { + return x.ClientId + } + return "" +} + +func (x *OAuth2Client) GetClientSecret() *Secret { + if x != nil { + return x.ClientSecret + } + return nil +} + +// Identity encapsulates the various security identities a task can run as. It's up to the underlying plugin to pick the +// right identity for the execution environment. +type Identity struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // iam_role references the fully qualified name of Identity & Access Management role to impersonate. + IamRole string `protobuf:"bytes,1,opt,name=iam_role,json=iamRole,proto3" json:"iam_role,omitempty"` + // k8s_service_account references a kubernetes service account to impersonate. + K8SServiceAccount string `protobuf:"bytes,2,opt,name=k8s_service_account,json=k8sServiceAccount,proto3" json:"k8s_service_account,omitempty"` + // oauth2_client references an oauth2 client. Backend plugins can use this information to impersonate the client when + // making external calls. + Oauth2Client *OAuth2Client `protobuf:"bytes,3,opt,name=oauth2_client,json=oauth2Client,proto3" json:"oauth2_client,omitempty"` + // execution_identity references the subject who makes the execution + ExecutionIdentity string `protobuf:"bytes,4,opt,name=execution_identity,json=executionIdentity,proto3" json:"execution_identity,omitempty"` +} + +func (x *Identity) Reset() { + *x = Identity{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_security_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Identity) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Identity) ProtoMessage() {} + +func (x *Identity) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_security_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Identity.ProtoReflect.Descriptor instead. +func (*Identity) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_security_proto_rawDescGZIP(), []int{3} +} + +func (x *Identity) GetIamRole() string { + if x != nil { + return x.IamRole + } + return "" +} + +func (x *Identity) GetK8SServiceAccount() string { + if x != nil { + return x.K8SServiceAccount + } + return "" +} + +func (x *Identity) GetOauth2Client() *OAuth2Client { + if x != nil { + return x.Oauth2Client + } + return nil +} + +func (x *Identity) GetExecutionIdentity() string { + if x != nil { + return x.ExecutionIdentity + } + return "" +} + +// OAuth2TokenRequest encapsulates information needed to request an OAuth2 token. +// FLYTE_TOKENS_ENV_PREFIX will be passed to indicate the prefix of the environment variables that will be present if +// tokens are passed through environment variables. +// FLYTE_TOKENS_PATH_PREFIX will be passed to indicate the prefix of the path where secrets will be mounted if tokens +// are passed through file mounts. +type OAuth2TokenRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // name indicates a unique id for the token request within this task token requests. It'll be used as a suffix for + // environment variables and as a filename for mounting tokens as files. + // +required + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // type indicates the type of the request to make. Defaults to CLIENT_CREDENTIALS. + // +required + Type OAuth2TokenRequest_Type `protobuf:"varint,2,opt,name=type,proto3,enum=flyteidl2.core.OAuth2TokenRequest_Type" json:"type,omitempty"` + // client references the client_id/secret to use to request the OAuth2 token. + // +required + Client *OAuth2Client `protobuf:"bytes,3,opt,name=client,proto3" json:"client,omitempty"` + // idp_discovery_endpoint references the discovery endpoint used to retrieve token endpoint and other related + // information. + // +optional + IdpDiscoveryEndpoint string `protobuf:"bytes,4,opt,name=idp_discovery_endpoint,json=idpDiscoveryEndpoint,proto3" json:"idp_discovery_endpoint,omitempty"` + // token_endpoint references the token issuance endpoint. If idp_discovery_endpoint is not provided, this parameter is + // mandatory. + // +optional + TokenEndpoint string `protobuf:"bytes,5,opt,name=token_endpoint,json=tokenEndpoint,proto3" json:"token_endpoint,omitempty"` +} + +func (x *OAuth2TokenRequest) Reset() { + *x = OAuth2TokenRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_security_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OAuth2TokenRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OAuth2TokenRequest) ProtoMessage() {} + +func (x *OAuth2TokenRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_security_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OAuth2TokenRequest.ProtoReflect.Descriptor instead. +func (*OAuth2TokenRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_security_proto_rawDescGZIP(), []int{4} +} + +func (x *OAuth2TokenRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *OAuth2TokenRequest) GetType() OAuth2TokenRequest_Type { + if x != nil { + return x.Type + } + return OAuth2TokenRequest_CLIENT_CREDENTIALS +} + +func (x *OAuth2TokenRequest) GetClient() *OAuth2Client { + if x != nil { + return x.Client + } + return nil +} + +func (x *OAuth2TokenRequest) GetIdpDiscoveryEndpoint() string { + if x != nil { + return x.IdpDiscoveryEndpoint + } + return "" +} + +func (x *OAuth2TokenRequest) GetTokenEndpoint() string { + if x != nil { + return x.TokenEndpoint + } + return "" +} + +// SecurityContext holds security attributes that apply to tasks. +type SecurityContext struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // run_as encapsulates the identity a pod should run as. If the task fills in multiple fields here, it'll be up to the + // backend plugin to choose the appropriate identity for the execution engine the task will run on. + RunAs *Identity `protobuf:"bytes,1,opt,name=run_as,json=runAs,proto3" json:"run_as,omitempty"` + // secrets indicate the list of secrets the task needs in order to proceed. Secrets will be mounted/passed to the + // pod as it starts. If the plugin responsible for kicking of the task will not run it on a flyte cluster (e.g. AWS + // Batch), it's the responsibility of the plugin to fetch the secret (which means propeller identity will need access + // to the secret) and to pass it to the remote execution engine. + Secrets []*Secret `protobuf:"bytes,2,rep,name=secrets,proto3" json:"secrets,omitempty"` + // tokens indicate the list of token requests the task needs in order to proceed. Tokens will be mounted/passed to the + // pod as it starts. If the plugin responsible for kicking of the task will not run it on a flyte cluster (e.g. AWS + // Batch), it's the responsibility of the plugin to fetch the secret (which means propeller identity will need access + // to the secret) and to pass it to the remote execution engine. + Tokens []*OAuth2TokenRequest `protobuf:"bytes,3,rep,name=tokens,proto3" json:"tokens,omitempty"` +} + +func (x *SecurityContext) Reset() { + *x = SecurityContext{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_security_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SecurityContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SecurityContext) ProtoMessage() {} + +func (x *SecurityContext) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_security_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SecurityContext.ProtoReflect.Descriptor instead. +func (*SecurityContext) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_security_proto_rawDescGZIP(), []int{5} +} + +func (x *SecurityContext) GetRunAs() *Identity { + if x != nil { + return x.RunAs + } + return nil +} + +func (x *SecurityContext) GetSecrets() []*Secret { + if x != nil { + return x.Secrets + } + return nil +} + +func (x *SecurityContext) GetTokens() []*OAuth2TokenRequest { + if x != nil { + return x.Tokens + } + return nil +} + +var File_flyteidl2_core_security_proto protoreflect.FileDescriptor + +var file_flyteidl2_core_security_proto_rawDesc = []byte{ + 0x0a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, + 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x22, + 0xea, 0x01, 0x0a, 0x06, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x67, 0x72, + 0x6f, 0x75, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x12, 0x23, 0x0a, 0x0d, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x4d, 0x0a, 0x11, 0x6d, 0x6f, 0x75, 0x6e, 0x74, + 0x5f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x4d, 0x6f, 0x75, 0x6e, 0x74, + 0x54, 0x79, 0x70, 0x65, 0x52, 0x10, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69, + 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x65, 0x6e, 0x76, 0x5f, 0x76, 0x61, + 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x65, 0x6e, 0x76, 0x56, 0x61, 0x72, 0x22, + 0x2b, 0x0a, 0x09, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x07, 0x0a, 0x03, + 0x41, 0x4e, 0x59, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x45, 0x4e, 0x56, 0x5f, 0x56, 0x41, 0x52, + 0x10, 0x01, 0x12, 0x08, 0x0a, 0x04, 0x46, 0x49, 0x4c, 0x45, 0x10, 0x02, 0x22, 0xa7, 0x02, 0x0a, + 0x0a, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x09, 0x74, + 0x61, 0x73, 0x6b, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x74, 0x61, 0x73, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x12, 0x41, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x41, 0x0a, 0x07, 0x63, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, + 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x1a, 0x3a, + 0x0a, 0x0c, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, + 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, + 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3a, 0x0a, 0x0c, 0x43, 0x6f, + 0x6e, 0x66, 0x69, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, + 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x68, 0x0a, 0x0c, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, + 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x49, 0x64, 0x12, 0x3b, 0x0a, 0x0d, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x52, 0x0c, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x22, 0xc7, 0x01, 0x0a, 0x08, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x19, 0x0a, + 0x08, 0x69, 0x61, 0x6d, 0x5f, 0x72, 0x6f, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x07, 0x69, 0x61, 0x6d, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x6b, 0x38, 0x73, 0x5f, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x6b, 0x38, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x41, 0x0a, 0x0d, 0x6f, 0x61, 0x75, 0x74, + 0x68, 0x32, 0x5f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x52, 0x0c, 0x6f, + 0x61, 0x75, 0x74, 0x68, 0x32, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x2d, 0x0a, 0x12, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x22, 0x98, 0x02, 0x0a, 0x12, 0x4f, + 0x41, 0x75, 0x74, 0x68, 0x32, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3b, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x54, 0x6f, 0x6b, 0x65, 0x6e, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, + 0x70, 0x65, 0x12, 0x34, 0x0a, 0x06, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x52, 0x06, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x34, 0x0a, 0x16, 0x69, 0x64, 0x70, 0x5f, + 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x5f, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, + 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x14, 0x69, 0x64, 0x70, 0x44, 0x69, 0x73, + 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x25, + 0x0a, 0x0e, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x45, 0x6e, 0x64, + 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x22, 0x1e, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, + 0x12, 0x43, 0x4c, 0x49, 0x45, 0x4e, 0x54, 0x5f, 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, 0x49, + 0x41, 0x4c, 0x53, 0x10, 0x00, 0x22, 0xb0, 0x01, 0x0a, 0x0f, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, + 0x74, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x2f, 0x0a, 0x06, 0x72, 0x75, 0x6e, + 0x5f, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x52, 0x05, 0x72, 0x75, 0x6e, 0x41, 0x73, 0x12, 0x30, 0x0a, 0x07, 0x73, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x3a, 0x0a, 0x06, + 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4f, 0x41, + 0x75, 0x74, 0x68, 0x32, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x52, 0x06, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x42, 0xb2, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x42, + 0x0d, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, + 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, + 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x0e, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0xca, 0x02, 0x0e, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0xe2, 0x02, + 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, + 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x62, 0x06, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_core_security_proto_rawDescOnce sync.Once + file_flyteidl2_core_security_proto_rawDescData = file_flyteidl2_core_security_proto_rawDesc +) + +func file_flyteidl2_core_security_proto_rawDescGZIP() []byte { + file_flyteidl2_core_security_proto_rawDescOnce.Do(func() { + file_flyteidl2_core_security_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_core_security_proto_rawDescData) + }) + return file_flyteidl2_core_security_proto_rawDescData +} + +var file_flyteidl2_core_security_proto_enumTypes = make([]protoimpl.EnumInfo, 2) +var file_flyteidl2_core_security_proto_msgTypes = make([]protoimpl.MessageInfo, 8) +var file_flyteidl2_core_security_proto_goTypes = []interface{}{ + (Secret_MountType)(0), // 0: flyteidl2.core.Secret.MountType + (OAuth2TokenRequest_Type)(0), // 1: flyteidl2.core.OAuth2TokenRequest.Type + (*Secret)(nil), // 2: flyteidl2.core.Secret + (*Connection)(nil), // 3: flyteidl2.core.Connection + (*OAuth2Client)(nil), // 4: flyteidl2.core.OAuth2Client + (*Identity)(nil), // 5: flyteidl2.core.Identity + (*OAuth2TokenRequest)(nil), // 6: flyteidl2.core.OAuth2TokenRequest + (*SecurityContext)(nil), // 7: flyteidl2.core.SecurityContext + nil, // 8: flyteidl2.core.Connection.SecretsEntry + nil, // 9: flyteidl2.core.Connection.ConfigsEntry +} +var file_flyteidl2_core_security_proto_depIdxs = []int32{ + 0, // 0: flyteidl2.core.Secret.mount_requirement:type_name -> flyteidl2.core.Secret.MountType + 8, // 1: flyteidl2.core.Connection.secrets:type_name -> flyteidl2.core.Connection.SecretsEntry + 9, // 2: flyteidl2.core.Connection.configs:type_name -> flyteidl2.core.Connection.ConfigsEntry + 2, // 3: flyteidl2.core.OAuth2Client.client_secret:type_name -> flyteidl2.core.Secret + 4, // 4: flyteidl2.core.Identity.oauth2_client:type_name -> flyteidl2.core.OAuth2Client + 1, // 5: flyteidl2.core.OAuth2TokenRequest.type:type_name -> flyteidl2.core.OAuth2TokenRequest.Type + 4, // 6: flyteidl2.core.OAuth2TokenRequest.client:type_name -> flyteidl2.core.OAuth2Client + 5, // 7: flyteidl2.core.SecurityContext.run_as:type_name -> flyteidl2.core.Identity + 2, // 8: flyteidl2.core.SecurityContext.secrets:type_name -> flyteidl2.core.Secret + 6, // 9: flyteidl2.core.SecurityContext.tokens:type_name -> flyteidl2.core.OAuth2TokenRequest + 10, // [10:10] is the sub-list for method output_type + 10, // [10:10] is the sub-list for method input_type + 10, // [10:10] is the sub-list for extension type_name + 10, // [10:10] is the sub-list for extension extendee + 0, // [0:10] is the sub-list for field type_name +} + +func init() { file_flyteidl2_core_security_proto_init() } +func file_flyteidl2_core_security_proto_init() { + if File_flyteidl2_core_security_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_core_security_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Secret); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_security_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Connection); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_security_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OAuth2Client); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_security_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Identity); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_security_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OAuth2TokenRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_security_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SecurityContext); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_core_security_proto_rawDesc, + NumEnums: 2, + NumMessages: 8, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_core_security_proto_goTypes, + DependencyIndexes: file_flyteidl2_core_security_proto_depIdxs, + EnumInfos: file_flyteidl2_core_security_proto_enumTypes, + MessageInfos: file_flyteidl2_core_security_proto_msgTypes, + }.Build() + File_flyteidl2_core_security_proto = out.File + file_flyteidl2_core_security_proto_rawDesc = nil + file_flyteidl2_core_security_proto_goTypes = nil + file_flyteidl2_core_security_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/core/security.pb.validate.go b/gen/go/flyteidl2/core/security.pb.validate.go new file mode 100644 index 0000000000..7bf0ac7950 --- /dev/null +++ b/gen/go/flyteidl2/core/security.pb.validate.go @@ -0,0 +1,849 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/core/security.proto + +package core + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on Secret with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Secret) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Secret with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in SecretMultiError, or nil if none found. +func (m *Secret) ValidateAll() error { + return m.validate(true) +} + +func (m *Secret) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Group + + // no validation rules for GroupVersion + + // no validation rules for Key + + // no validation rules for MountRequirement + + // no validation rules for EnvVar + + if len(errors) > 0 { + return SecretMultiError(errors) + } + + return nil +} + +// SecretMultiError is an error wrapping multiple validation errors returned by +// Secret.ValidateAll() if the designated constraints aren't met. +type SecretMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SecretMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SecretMultiError) AllErrors() []error { return m } + +// SecretValidationError is the validation error returned by Secret.Validate if +// the designated constraints aren't met. +type SecretValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SecretValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SecretValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SecretValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SecretValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SecretValidationError) ErrorName() string { return "SecretValidationError" } + +// Error satisfies the builtin error interface +func (e SecretValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSecret.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SecretValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SecretValidationError{} + +// Validate checks the field values on Connection with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Connection) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Connection with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ConnectionMultiError, or +// nil if none found. +func (m *Connection) ValidateAll() error { + return m.validate(true) +} + +func (m *Connection) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for TaskType + + // no validation rules for Secrets + + // no validation rules for Configs + + if len(errors) > 0 { + return ConnectionMultiError(errors) + } + + return nil +} + +// ConnectionMultiError is an error wrapping multiple validation errors +// returned by Connection.ValidateAll() if the designated constraints aren't met. +type ConnectionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ConnectionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ConnectionMultiError) AllErrors() []error { return m } + +// ConnectionValidationError is the validation error returned by +// Connection.Validate if the designated constraints aren't met. +type ConnectionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ConnectionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ConnectionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ConnectionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ConnectionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ConnectionValidationError) ErrorName() string { return "ConnectionValidationError" } + +// Error satisfies the builtin error interface +func (e ConnectionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sConnection.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ConnectionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ConnectionValidationError{} + +// Validate checks the field values on OAuth2Client with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *OAuth2Client) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on OAuth2Client with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in OAuth2ClientMultiError, or +// nil if none found. +func (m *OAuth2Client) ValidateAll() error { + return m.validate(true) +} + +func (m *OAuth2Client) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ClientId + + if all { + switch v := interface{}(m.GetClientSecret()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, OAuth2ClientValidationError{ + field: "ClientSecret", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, OAuth2ClientValidationError{ + field: "ClientSecret", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetClientSecret()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return OAuth2ClientValidationError{ + field: "ClientSecret", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return OAuth2ClientMultiError(errors) + } + + return nil +} + +// OAuth2ClientMultiError is an error wrapping multiple validation errors +// returned by OAuth2Client.ValidateAll() if the designated constraints aren't met. +type OAuth2ClientMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m OAuth2ClientMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m OAuth2ClientMultiError) AllErrors() []error { return m } + +// OAuth2ClientValidationError is the validation error returned by +// OAuth2Client.Validate if the designated constraints aren't met. +type OAuth2ClientValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e OAuth2ClientValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e OAuth2ClientValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e OAuth2ClientValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e OAuth2ClientValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e OAuth2ClientValidationError) ErrorName() string { return "OAuth2ClientValidationError" } + +// Error satisfies the builtin error interface +func (e OAuth2ClientValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sOAuth2Client.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = OAuth2ClientValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = OAuth2ClientValidationError{} + +// Validate checks the field values on Identity with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Identity) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Identity with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in IdentityMultiError, or nil +// if none found. +func (m *Identity) ValidateAll() error { + return m.validate(true) +} + +func (m *Identity) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for IamRole + + // no validation rules for K8SServiceAccount + + if all { + switch v := interface{}(m.GetOauth2Client()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, IdentityValidationError{ + field: "Oauth2Client", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, IdentityValidationError{ + field: "Oauth2Client", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOauth2Client()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return IdentityValidationError{ + field: "Oauth2Client", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for ExecutionIdentity + + if len(errors) > 0 { + return IdentityMultiError(errors) + } + + return nil +} + +// IdentityMultiError is an error wrapping multiple validation errors returned +// by Identity.ValidateAll() if the designated constraints aren't met. +type IdentityMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m IdentityMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m IdentityMultiError) AllErrors() []error { return m } + +// IdentityValidationError is the validation error returned by +// Identity.Validate if the designated constraints aren't met. +type IdentityValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e IdentityValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e IdentityValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e IdentityValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e IdentityValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e IdentityValidationError) ErrorName() string { return "IdentityValidationError" } + +// Error satisfies the builtin error interface +func (e IdentityValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sIdentity.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = IdentityValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = IdentityValidationError{} + +// Validate checks the field values on OAuth2TokenRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *OAuth2TokenRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on OAuth2TokenRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// OAuth2TokenRequestMultiError, or nil if none found. +func (m *OAuth2TokenRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *OAuth2TokenRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + // no validation rules for Type + + if all { + switch v := interface{}(m.GetClient()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, OAuth2TokenRequestValidationError{ + field: "Client", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, OAuth2TokenRequestValidationError{ + field: "Client", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetClient()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return OAuth2TokenRequestValidationError{ + field: "Client", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for IdpDiscoveryEndpoint + + // no validation rules for TokenEndpoint + + if len(errors) > 0 { + return OAuth2TokenRequestMultiError(errors) + } + + return nil +} + +// OAuth2TokenRequestMultiError is an error wrapping multiple validation errors +// returned by OAuth2TokenRequest.ValidateAll() if the designated constraints +// aren't met. +type OAuth2TokenRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m OAuth2TokenRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m OAuth2TokenRequestMultiError) AllErrors() []error { return m } + +// OAuth2TokenRequestValidationError is the validation error returned by +// OAuth2TokenRequest.Validate if the designated constraints aren't met. +type OAuth2TokenRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e OAuth2TokenRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e OAuth2TokenRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e OAuth2TokenRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e OAuth2TokenRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e OAuth2TokenRequestValidationError) ErrorName() string { + return "OAuth2TokenRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e OAuth2TokenRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sOAuth2TokenRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = OAuth2TokenRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = OAuth2TokenRequestValidationError{} + +// Validate checks the field values on SecurityContext with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *SecurityContext) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on SecurityContext with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// SecurityContextMultiError, or nil if none found. +func (m *SecurityContext) ValidateAll() error { + return m.validate(true) +} + +func (m *SecurityContext) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRunAs()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SecurityContextValidationError{ + field: "RunAs", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SecurityContextValidationError{ + field: "RunAs", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunAs()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SecurityContextValidationError{ + field: "RunAs", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetSecrets() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SecurityContextValidationError{ + field: fmt.Sprintf("Secrets[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SecurityContextValidationError{ + field: fmt.Sprintf("Secrets[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SecurityContextValidationError{ + field: fmt.Sprintf("Secrets[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + for idx, item := range m.GetTokens() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SecurityContextValidationError{ + field: fmt.Sprintf("Tokens[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SecurityContextValidationError{ + field: fmt.Sprintf("Tokens[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SecurityContextValidationError{ + field: fmt.Sprintf("Tokens[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return SecurityContextMultiError(errors) + } + + return nil +} + +// SecurityContextMultiError is an error wrapping multiple validation errors +// returned by SecurityContext.ValidateAll() if the designated constraints +// aren't met. +type SecurityContextMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SecurityContextMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SecurityContextMultiError) AllErrors() []error { return m } + +// SecurityContextValidationError is the validation error returned by +// SecurityContext.Validate if the designated constraints aren't met. +type SecurityContextValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SecurityContextValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SecurityContextValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SecurityContextValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SecurityContextValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SecurityContextValidationError) ErrorName() string { return "SecurityContextValidationError" } + +// Error satisfies the builtin error interface +func (e SecurityContextValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSecurityContext.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SecurityContextValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SecurityContextValidationError{} diff --git a/gen/go/flyteidl2/core/tasks.pb.go b/gen/go/flyteidl2/core/tasks.pb.go new file mode 100644 index 0000000000..5e74816d11 --- /dev/null +++ b/gen/go/flyteidl2/core/tasks.pb.go @@ -0,0 +1,2495 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/core/tasks.proto + +package core + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + durationpb "google.golang.org/protobuf/types/known/durationpb" + structpb "google.golang.org/protobuf/types/known/structpb" + wrapperspb "google.golang.org/protobuf/types/known/wrapperspb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Known resource names. +type Resources_ResourceName int32 + +const ( + Resources_UNKNOWN Resources_ResourceName = 0 + Resources_CPU Resources_ResourceName = 1 + Resources_GPU Resources_ResourceName = 2 + Resources_MEMORY Resources_ResourceName = 3 + Resources_STORAGE Resources_ResourceName = 4 + // For Kubernetes-based deployments, pods use ephemeral local storage for scratch space, caching, and for logs. + Resources_EPHEMERAL_STORAGE Resources_ResourceName = 5 +) + +// Enum value maps for Resources_ResourceName. +var ( + Resources_ResourceName_name = map[int32]string{ + 0: "UNKNOWN", + 1: "CPU", + 2: "GPU", + 3: "MEMORY", + 4: "STORAGE", + 5: "EPHEMERAL_STORAGE", + } + Resources_ResourceName_value = map[string]int32{ + "UNKNOWN": 0, + "CPU": 1, + "GPU": 2, + "MEMORY": 3, + "STORAGE": 4, + "EPHEMERAL_STORAGE": 5, + } +) + +func (x Resources_ResourceName) Enum() *Resources_ResourceName { + p := new(Resources_ResourceName) + *p = x + return p +} + +func (x Resources_ResourceName) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Resources_ResourceName) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_tasks_proto_enumTypes[0].Descriptor() +} + +func (Resources_ResourceName) Type() protoreflect.EnumType { + return &file_flyteidl2_core_tasks_proto_enumTypes[0] +} + +func (x Resources_ResourceName) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Resources_ResourceName.Descriptor instead. +func (Resources_ResourceName) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{0, 0} +} + +// Specifies the class of accelerator device. +type GPUAccelerator_DeviceClass int32 + +const ( + // NVIDIA GPU devices (default for backward compatibility) + GPUAccelerator_NVIDIA_GPU GPUAccelerator_DeviceClass = 0 + // Google TPU devices + GPUAccelerator_GOOGLE_TPU GPUAccelerator_DeviceClass = 1 + // Amazon Neuron devices + GPUAccelerator_AMAZON_NEURON GPUAccelerator_DeviceClass = 2 + // AMD GPU devices + GPUAccelerator_AMD_GPU GPUAccelerator_DeviceClass = 3 + // Habana Gaudi devices + GPUAccelerator_HABANA_GAUDI GPUAccelerator_DeviceClass = 4 +) + +// Enum value maps for GPUAccelerator_DeviceClass. +var ( + GPUAccelerator_DeviceClass_name = map[int32]string{ + 0: "NVIDIA_GPU", + 1: "GOOGLE_TPU", + 2: "AMAZON_NEURON", + 3: "AMD_GPU", + 4: "HABANA_GAUDI", + } + GPUAccelerator_DeviceClass_value = map[string]int32{ + "NVIDIA_GPU": 0, + "GOOGLE_TPU": 1, + "AMAZON_NEURON": 2, + "AMD_GPU": 3, + "HABANA_GAUDI": 4, + } +) + +func (x GPUAccelerator_DeviceClass) Enum() *GPUAccelerator_DeviceClass { + p := new(GPUAccelerator_DeviceClass) + *p = x + return p +} + +func (x GPUAccelerator_DeviceClass) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (GPUAccelerator_DeviceClass) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_tasks_proto_enumTypes[1].Descriptor() +} + +func (GPUAccelerator_DeviceClass) Type() protoreflect.EnumType { + return &file_flyteidl2_core_tasks_proto_enumTypes[1] +} + +func (x GPUAccelerator_DeviceClass) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use GPUAccelerator_DeviceClass.Descriptor instead. +func (GPUAccelerator_DeviceClass) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{1, 0} +} + +type RuntimeMetadata_RuntimeType int32 + +const ( + RuntimeMetadata_OTHER RuntimeMetadata_RuntimeType = 0 + RuntimeMetadata_FLYTE_SDK RuntimeMetadata_RuntimeType = 1 +) + +// Enum value maps for RuntimeMetadata_RuntimeType. +var ( + RuntimeMetadata_RuntimeType_name = map[int32]string{ + 0: "OTHER", + 1: "FLYTE_SDK", + } + RuntimeMetadata_RuntimeType_value = map[string]int32{ + "OTHER": 0, + "FLYTE_SDK": 1, + } +) + +func (x RuntimeMetadata_RuntimeType) Enum() *RuntimeMetadata_RuntimeType { + p := new(RuntimeMetadata_RuntimeType) + *p = x + return p +} + +func (x RuntimeMetadata_RuntimeType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (RuntimeMetadata_RuntimeType) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_tasks_proto_enumTypes[2].Descriptor() +} + +func (RuntimeMetadata_RuntimeType) Type() protoreflect.EnumType { + return &file_flyteidl2_core_tasks_proto_enumTypes[2] +} + +func (x RuntimeMetadata_RuntimeType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use RuntimeMetadata_RuntimeType.Descriptor instead. +func (RuntimeMetadata_RuntimeType) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{4, 0} +} + +// Architecture-type the container image supports. +type Container_Architecture int32 + +const ( + Container_UNKNOWN Container_Architecture = 0 + Container_AMD64 Container_Architecture = 1 + Container_ARM64 Container_Architecture = 2 + Container_ARM_V6 Container_Architecture = 3 + Container_ARM_V7 Container_Architecture = 4 +) + +// Enum value maps for Container_Architecture. +var ( + Container_Architecture_name = map[int32]string{ + 0: "UNKNOWN", + 1: "AMD64", + 2: "ARM64", + 3: "ARM_V6", + 4: "ARM_V7", + } + Container_Architecture_value = map[string]int32{ + "UNKNOWN": 0, + "AMD64": 1, + "ARM64": 2, + "ARM_V6": 3, + "ARM_V7": 4, + } +) + +func (x Container_Architecture) Enum() *Container_Architecture { + p := new(Container_Architecture) + *p = x + return p +} + +func (x Container_Architecture) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Container_Architecture) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_tasks_proto_enumTypes[3].Descriptor() +} + +func (Container_Architecture) Type() protoreflect.EnumType { + return &file_flyteidl2_core_tasks_proto_enumTypes[3] +} + +func (x Container_Architecture) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Container_Architecture.Descriptor instead. +func (Container_Architecture) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{8, 0} +} + +// Mode to use for downloading +type IOStrategy_DownloadMode int32 + +const ( + // All data will be downloaded before the main container is executed + IOStrategy_DOWNLOAD_EAGER IOStrategy_DownloadMode = 0 + // Data will be downloaded as a stream and an End-Of-Stream marker will be written to indicate all data has been downloaded. Refer to protocol for details + IOStrategy_DOWNLOAD_STREAM IOStrategy_DownloadMode = 1 + // Large objects (offloaded) will not be downloaded + IOStrategy_DO_NOT_DOWNLOAD IOStrategy_DownloadMode = 2 +) + +// Enum value maps for IOStrategy_DownloadMode. +var ( + IOStrategy_DownloadMode_name = map[int32]string{ + 0: "DOWNLOAD_EAGER", + 1: "DOWNLOAD_STREAM", + 2: "DO_NOT_DOWNLOAD", + } + IOStrategy_DownloadMode_value = map[string]int32{ + "DOWNLOAD_EAGER": 0, + "DOWNLOAD_STREAM": 1, + "DO_NOT_DOWNLOAD": 2, + } +) + +func (x IOStrategy_DownloadMode) Enum() *IOStrategy_DownloadMode { + p := new(IOStrategy_DownloadMode) + *p = x + return p +} + +func (x IOStrategy_DownloadMode) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (IOStrategy_DownloadMode) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_tasks_proto_enumTypes[4].Descriptor() +} + +func (IOStrategy_DownloadMode) Type() protoreflect.EnumType { + return &file_flyteidl2_core_tasks_proto_enumTypes[4] +} + +func (x IOStrategy_DownloadMode) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use IOStrategy_DownloadMode.Descriptor instead. +func (IOStrategy_DownloadMode) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{9, 0} +} + +// Mode to use for uploading +type IOStrategy_UploadMode int32 + +const ( + // All data will be uploaded after the main container exits + IOStrategy_UPLOAD_ON_EXIT IOStrategy_UploadMode = 0 + // Data will be uploaded as it appears. Refer to protocol specification for details + IOStrategy_UPLOAD_EAGER IOStrategy_UploadMode = 1 + // Data will not be uploaded, only references will be written + IOStrategy_DO_NOT_UPLOAD IOStrategy_UploadMode = 2 +) + +// Enum value maps for IOStrategy_UploadMode. +var ( + IOStrategy_UploadMode_name = map[int32]string{ + 0: "UPLOAD_ON_EXIT", + 1: "UPLOAD_EAGER", + 2: "DO_NOT_UPLOAD", + } + IOStrategy_UploadMode_value = map[string]int32{ + "UPLOAD_ON_EXIT": 0, + "UPLOAD_EAGER": 1, + "DO_NOT_UPLOAD": 2, + } +) + +func (x IOStrategy_UploadMode) Enum() *IOStrategy_UploadMode { + p := new(IOStrategy_UploadMode) + *p = x + return p +} + +func (x IOStrategy_UploadMode) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (IOStrategy_UploadMode) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_tasks_proto_enumTypes[5].Descriptor() +} + +func (IOStrategy_UploadMode) Type() protoreflect.EnumType { + return &file_flyteidl2_core_tasks_proto_enumTypes[5] +} + +func (x IOStrategy_UploadMode) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use IOStrategy_UploadMode.Descriptor instead. +func (IOStrategy_UploadMode) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{9, 1} +} + +// LiteralMapFormat decides the encoding format in which the input metadata should be made available to the containers. +// If the user has access to the protocol buffer definitions, it is recommended to use the PROTO format. +// JSON and YAML do not need any protobuf definitions to read it +// All remote references in core.LiteralMap are replaced with local filesystem references (the data is downloaded to local filesystem) +type DataLoadingConfig_LiteralMapFormat int32 + +const ( + // JSON / YAML for the metadata (which contains inlined primitive values). The representation is inline with the standard json specification as specified - https://www.json.org/json-en.html + DataLoadingConfig_JSON DataLoadingConfig_LiteralMapFormat = 0 + DataLoadingConfig_YAML DataLoadingConfig_LiteralMapFormat = 1 + // Proto is a serialized binary of `core.LiteralMap` defined in flyteidl/core + DataLoadingConfig_PROTO DataLoadingConfig_LiteralMapFormat = 2 +) + +// Enum value maps for DataLoadingConfig_LiteralMapFormat. +var ( + DataLoadingConfig_LiteralMapFormat_name = map[int32]string{ + 0: "JSON", + 1: "YAML", + 2: "PROTO", + } + DataLoadingConfig_LiteralMapFormat_value = map[string]int32{ + "JSON": 0, + "YAML": 1, + "PROTO": 2, + } +) + +func (x DataLoadingConfig_LiteralMapFormat) Enum() *DataLoadingConfig_LiteralMapFormat { + p := new(DataLoadingConfig_LiteralMapFormat) + *p = x + return p +} + +func (x DataLoadingConfig_LiteralMapFormat) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (DataLoadingConfig_LiteralMapFormat) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_tasks_proto_enumTypes[6].Descriptor() +} + +func (DataLoadingConfig_LiteralMapFormat) Type() protoreflect.EnumType { + return &file_flyteidl2_core_tasks_proto_enumTypes[6] +} + +func (x DataLoadingConfig_LiteralMapFormat) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use DataLoadingConfig_LiteralMapFormat.Descriptor instead. +func (DataLoadingConfig_LiteralMapFormat) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{10, 0} +} + +// The dialect of the SQL statement. This is used to validate and parse SQL statements at compilation time to avoid +// expensive runtime operations. If set to an unsupported dialect, no validation will be done on the statement. +// We support the following dialect: ansi, hive. +type Sql_Dialect int32 + +const ( + Sql_UNDEFINED Sql_Dialect = 0 + Sql_ANSI Sql_Dialect = 1 + Sql_HIVE Sql_Dialect = 2 + Sql_OTHER Sql_Dialect = 3 +) + +// Enum value maps for Sql_Dialect. +var ( + Sql_Dialect_name = map[int32]string{ + 0: "UNDEFINED", + 1: "ANSI", + 2: "HIVE", + 3: "OTHER", + } + Sql_Dialect_value = map[string]int32{ + "UNDEFINED": 0, + "ANSI": 1, + "HIVE": 2, + "OTHER": 3, + } +) + +func (x Sql_Dialect) Enum() *Sql_Dialect { + p := new(Sql_Dialect) + *p = x + return p +} + +func (x Sql_Dialect) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Sql_Dialect) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_tasks_proto_enumTypes[7].Descriptor() +} + +func (Sql_Dialect) Type() protoreflect.EnumType { + return &file_flyteidl2_core_tasks_proto_enumTypes[7] +} + +func (x Sql_Dialect) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Sql_Dialect.Descriptor instead. +func (Sql_Dialect) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{13, 0} +} + +// A customizable interface to convey resources requested for a container. This can be interpreted differently for different +// container engines. +type Resources struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The desired set of resources requested. ResourceNames must be unique within the list. + Requests []*Resources_ResourceEntry `protobuf:"bytes,1,rep,name=requests,proto3" json:"requests,omitempty"` + // Defines a set of bounds (e.g. min/max) within which the task can reliably run. ResourceNames must be unique + // within the list. + Limits []*Resources_ResourceEntry `protobuf:"bytes,2,rep,name=limits,proto3" json:"limits,omitempty"` +} + +func (x *Resources) Reset() { + *x = Resources{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Resources) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Resources) ProtoMessage() {} + +func (x *Resources) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Resources.ProtoReflect.Descriptor instead. +func (*Resources) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{0} +} + +func (x *Resources) GetRequests() []*Resources_ResourceEntry { + if x != nil { + return x.Requests + } + return nil +} + +func (x *Resources) GetLimits() []*Resources_ResourceEntry { + if x != nil { + return x.Limits + } + return nil +} + +// Metadata associated with the GPU accelerator to allocate to a task. Contains +// information about device type, and for multi-instance GPUs, the partition size to +// use. +type GPUAccelerator struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // This can be any arbitrary string, and should be informed by the labels or taints + // associated with the nodes in question. Default cloud provider labels typically + // use the following values: `nvidia-tesla-t4`, `nvidia-tesla-a100`, etc. + Device string `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"` + // Types that are assignable to PartitionSizeValue: + // + // *GPUAccelerator_Unpartitioned + // *GPUAccelerator_PartitionSize + PartitionSizeValue isGPUAccelerator_PartitionSizeValue `protobuf_oneof:"partition_size_value"` + // The class of accelerator device. Defaults to NVIDIA_GPU if not specified. + DeviceClass GPUAccelerator_DeviceClass `protobuf:"varint,4,opt,name=device_class,json=deviceClass,proto3,enum=flyteidl2.core.GPUAccelerator_DeviceClass" json:"device_class,omitempty"` +} + +func (x *GPUAccelerator) Reset() { + *x = GPUAccelerator{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GPUAccelerator) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GPUAccelerator) ProtoMessage() {} + +func (x *GPUAccelerator) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GPUAccelerator.ProtoReflect.Descriptor instead. +func (*GPUAccelerator) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{1} +} + +func (x *GPUAccelerator) GetDevice() string { + if x != nil { + return x.Device + } + return "" +} + +func (m *GPUAccelerator) GetPartitionSizeValue() isGPUAccelerator_PartitionSizeValue { + if m != nil { + return m.PartitionSizeValue + } + return nil +} + +func (x *GPUAccelerator) GetUnpartitioned() bool { + if x, ok := x.GetPartitionSizeValue().(*GPUAccelerator_Unpartitioned); ok { + return x.Unpartitioned + } + return false +} + +func (x *GPUAccelerator) GetPartitionSize() string { + if x, ok := x.GetPartitionSizeValue().(*GPUAccelerator_PartitionSize); ok { + return x.PartitionSize + } + return "" +} + +func (x *GPUAccelerator) GetDeviceClass() GPUAccelerator_DeviceClass { + if x != nil { + return x.DeviceClass + } + return GPUAccelerator_NVIDIA_GPU +} + +type isGPUAccelerator_PartitionSizeValue interface { + isGPUAccelerator_PartitionSizeValue() +} + +type GPUAccelerator_Unpartitioned struct { + Unpartitioned bool `protobuf:"varint,2,opt,name=unpartitioned,proto3,oneof"` +} + +type GPUAccelerator_PartitionSize struct { + // Like `device`, this can be any arbitrary string, and should be informed by + // the labels or taints associated with the nodes in question. Default cloud + // provider labels typically use the following values: `1g.5gb`, `2g.10gb`, etc. + PartitionSize string `protobuf:"bytes,3,opt,name=partition_size,json=partitionSize,proto3,oneof"` +} + +func (*GPUAccelerator_Unpartitioned) isGPUAccelerator_PartitionSizeValue() {} + +func (*GPUAccelerator_PartitionSize) isGPUAccelerator_PartitionSizeValue() {} + +// Metadata associated with configuring a shared memory volume for a task. +type SharedMemory struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Mount path to place in container + MountPath string `protobuf:"bytes,1,opt,name=mount_path,json=mountPath,proto3" json:"mount_path,omitempty"` + // Name for volume + MountName string `protobuf:"bytes,2,opt,name=mount_name,json=mountName,proto3" json:"mount_name,omitempty"` + // Size limit for shared memory. If not set, then the shared memory is equal + // to the allocated memory. + // +optional + SizeLimit string `protobuf:"bytes,3,opt,name=size_limit,json=sizeLimit,proto3" json:"size_limit,omitempty"` +} + +func (x *SharedMemory) Reset() { + *x = SharedMemory{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SharedMemory) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SharedMemory) ProtoMessage() {} + +func (x *SharedMemory) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SharedMemory.ProtoReflect.Descriptor instead. +func (*SharedMemory) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{2} +} + +func (x *SharedMemory) GetMountPath() string { + if x != nil { + return x.MountPath + } + return "" +} + +func (x *SharedMemory) GetMountName() string { + if x != nil { + return x.MountName + } + return "" +} + +func (x *SharedMemory) GetSizeLimit() string { + if x != nil { + return x.SizeLimit + } + return "" +} + +// Encapsulates all non-standard resources, not captured by v1.ResourceRequirements, to +// allocate to a task. +type ExtendedResources struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // GPU accelerator to select for task. Contains information about device type, and + // for multi-instance GPUs, the partition size to use. + GpuAccelerator *GPUAccelerator `protobuf:"bytes,1,opt,name=gpu_accelerator,json=gpuAccelerator,proto3" json:"gpu_accelerator,omitempty"` + SharedMemory *SharedMemory `protobuf:"bytes,2,opt,name=shared_memory,json=sharedMemory,proto3" json:"shared_memory,omitempty"` +} + +func (x *ExtendedResources) Reset() { + *x = ExtendedResources{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ExtendedResources) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExtendedResources) ProtoMessage() {} + +func (x *ExtendedResources) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExtendedResources.ProtoReflect.Descriptor instead. +func (*ExtendedResources) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{3} +} + +func (x *ExtendedResources) GetGpuAccelerator() *GPUAccelerator { + if x != nil { + return x.GpuAccelerator + } + return nil +} + +func (x *ExtendedResources) GetSharedMemory() *SharedMemory { + if x != nil { + return x.SharedMemory + } + return nil +} + +// Runtime information. This is loosely defined to allow for extensibility. +type RuntimeMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Type of runtime. + Type RuntimeMetadata_RuntimeType `protobuf:"varint,1,opt,name=type,proto3,enum=flyteidl2.core.RuntimeMetadata_RuntimeType" json:"type,omitempty"` + // Version of the runtime. All versions should be backward compatible. However, certain cases call for version + // checks to ensure tighter validation or setting expectations. + Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"` + // +optional It can be used to provide extra information about the runtime (e.g. python, golang... etc.). + Flavor string `protobuf:"bytes,3,opt,name=flavor,proto3" json:"flavor,omitempty"` +} + +func (x *RuntimeMetadata) Reset() { + *x = RuntimeMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RuntimeMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RuntimeMetadata) ProtoMessage() {} + +func (x *RuntimeMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RuntimeMetadata.ProtoReflect.Descriptor instead. +func (*RuntimeMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{4} +} + +func (x *RuntimeMetadata) GetType() RuntimeMetadata_RuntimeType { + if x != nil { + return x.Type + } + return RuntimeMetadata_OTHER +} + +func (x *RuntimeMetadata) GetVersion() string { + if x != nil { + return x.Version + } + return "" +} + +func (x *RuntimeMetadata) GetFlavor() string { + if x != nil { + return x.Flavor + } + return "" +} + +// Task Metadata +type TaskMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Indicates whether the system should attempt to lookup this task's output to avoid duplication of work. + Discoverable bool `protobuf:"varint,1,opt,name=discoverable,proto3" json:"discoverable,omitempty"` + // Runtime information about the task. + Runtime *RuntimeMetadata `protobuf:"bytes,2,opt,name=runtime,proto3" json:"runtime,omitempty"` + // The overall timeout of a task including user-triggered retries. + Timeout *durationpb.Duration `protobuf:"bytes,4,opt,name=timeout,proto3" json:"timeout,omitempty"` + // Number of retries per task. + Retries *RetryStrategy `protobuf:"bytes,5,opt,name=retries,proto3" json:"retries,omitempty"` + // Indicates a logical version to apply to this task for the purpose of discovery. + DiscoveryVersion string `protobuf:"bytes,6,opt,name=discovery_version,json=discoveryVersion,proto3" json:"discovery_version,omitempty"` + // If set, this indicates that this task is deprecated. This will enable owners of tasks to notify consumers + // of the ending of support for a given task. + DeprecatedErrorMessage string `protobuf:"bytes,7,opt,name=deprecated_error_message,json=deprecatedErrorMessage,proto3" json:"deprecated_error_message,omitempty"` + // Identify whether task is interruptible + // + // Types that are assignable to InterruptibleValue: + // + // *TaskMetadata_Interruptible + InterruptibleValue isTaskMetadata_InterruptibleValue `protobuf_oneof:"interruptible_value"` + // Indicates whether the system should attempt to execute discoverable instances in serial to avoid duplicate work + CacheSerializable bool `protobuf:"varint,9,opt,name=cache_serializable,json=cacheSerializable,proto3" json:"cache_serializable,omitempty"` + // Arbitrary tags that allow users and the platform to store small but arbitrary labels + Tags map[string]string `protobuf:"bytes,11,rep,name=tags,proto3" json:"tags,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // pod_template_name is the unique name of a PodTemplate k8s resource to be used as the base configuration if this + // task creates a k8s Pod. If this value is set, the specified PodTemplate will be used instead of, but applied + // identically as, the default PodTemplate configured in FlytePropeller. + PodTemplateName string `protobuf:"bytes,12,opt,name=pod_template_name,json=podTemplateName,proto3" json:"pod_template_name,omitempty"` + // cache_ignore_input_vars is the input variables that should not be included when calculating hash for cache. + CacheIgnoreInputVars []string `protobuf:"bytes,13,rep,name=cache_ignore_input_vars,json=cacheIgnoreInputVars,proto3" json:"cache_ignore_input_vars,omitempty"` + // is_eager indicates whether the task is eager or not. + // This would be used by CreateTask endpoint. + IsEager bool `protobuf:"varint,14,opt,name=is_eager,json=isEager,proto3" json:"is_eager,omitempty"` + // Indicates whether the task will generate a deck when it finishes executing. + // The BoolValue can have three states: + // - nil: The value is not set. + // - true: The task will generate a deck. + // - false: The task will not generate a deck. + GeneratesDeck *wrapperspb.BoolValue `protobuf:"bytes,15,opt,name=generates_deck,json=generatesDeck,proto3" json:"generates_deck,omitempty"` + // Metadata applied to task pods or task CR objects. + // In flytekit, labels and annotations resulting in this metadata field + // are provided via `@task(labels=..., annotations=...)`. + // For tasks backed by pods like PythonFunctionTask, these take precedence + // over the metadata provided via `@task(pod_template=PodTemplate(labels=...))` which are transported + // in the K8sPod message. For tasks backed by CRDs, this metadata is applied to + // the CR object itself while the metadata in the pod template/K8sPod is applied + // to the pod template spec of the CR object. + Metadata *K8SObjectMetadata `protobuf:"bytes,16,opt,name=metadata,proto3" json:"metadata,omitempty"` + // Whether the task is able to run the debugger (vscode server) inside the task container. + Debuggable bool `protobuf:"varint,17,opt,name=debuggable,proto3" json:"debuggable,omitempty"` + // Log links associated with this task. + LogLinks []*TaskLog `protobuf:"bytes,18,rep,name=log_links,json=logLinks,proto3" json:"log_links,omitempty"` +} + +func (x *TaskMetadata) Reset() { + *x = TaskMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskMetadata) ProtoMessage() {} + +func (x *TaskMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskMetadata.ProtoReflect.Descriptor instead. +func (*TaskMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{5} +} + +func (x *TaskMetadata) GetDiscoverable() bool { + if x != nil { + return x.Discoverable + } + return false +} + +func (x *TaskMetadata) GetRuntime() *RuntimeMetadata { + if x != nil { + return x.Runtime + } + return nil +} + +func (x *TaskMetadata) GetTimeout() *durationpb.Duration { + if x != nil { + return x.Timeout + } + return nil +} + +func (x *TaskMetadata) GetRetries() *RetryStrategy { + if x != nil { + return x.Retries + } + return nil +} + +func (x *TaskMetadata) GetDiscoveryVersion() string { + if x != nil { + return x.DiscoveryVersion + } + return "" +} + +func (x *TaskMetadata) GetDeprecatedErrorMessage() string { + if x != nil { + return x.DeprecatedErrorMessage + } + return "" +} + +func (m *TaskMetadata) GetInterruptibleValue() isTaskMetadata_InterruptibleValue { + if m != nil { + return m.InterruptibleValue + } + return nil +} + +func (x *TaskMetadata) GetInterruptible() bool { + if x, ok := x.GetInterruptibleValue().(*TaskMetadata_Interruptible); ok { + return x.Interruptible + } + return false +} + +func (x *TaskMetadata) GetCacheSerializable() bool { + if x != nil { + return x.CacheSerializable + } + return false +} + +func (x *TaskMetadata) GetTags() map[string]string { + if x != nil { + return x.Tags + } + return nil +} + +func (x *TaskMetadata) GetPodTemplateName() string { + if x != nil { + return x.PodTemplateName + } + return "" +} + +func (x *TaskMetadata) GetCacheIgnoreInputVars() []string { + if x != nil { + return x.CacheIgnoreInputVars + } + return nil +} + +func (x *TaskMetadata) GetIsEager() bool { + if x != nil { + return x.IsEager + } + return false +} + +func (x *TaskMetadata) GetGeneratesDeck() *wrapperspb.BoolValue { + if x != nil { + return x.GeneratesDeck + } + return nil +} + +func (x *TaskMetadata) GetMetadata() *K8SObjectMetadata { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *TaskMetadata) GetDebuggable() bool { + if x != nil { + return x.Debuggable + } + return false +} + +func (x *TaskMetadata) GetLogLinks() []*TaskLog { + if x != nil { + return x.LogLinks + } + return nil +} + +type isTaskMetadata_InterruptibleValue interface { + isTaskMetadata_InterruptibleValue() +} + +type TaskMetadata_Interruptible struct { + Interruptible bool `protobuf:"varint,8,opt,name=interruptible,proto3,oneof"` +} + +func (*TaskMetadata_Interruptible) isTaskMetadata_InterruptibleValue() {} + +// A Task structure that uniquely identifies a task in the system +// Tasks are registered as a first step in the system. +type TaskTemplate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Auto generated taskId by the system. Task Id uniquely identifies this task globally. + Id *Identifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // A predefined yet extensible Task type identifier. This can be used to customize any of the components. If no + // extensions are provided in the system, Flyte will resolve the this task to its TaskCategory and default the + // implementation registered for the TaskCategory. + Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"` + // Extra metadata about the task. + Metadata *TaskMetadata `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"` + // A strongly typed interface for the task. This enables others to use this task within a workflow and guarantees + // compile-time validation of the workflow to avoid costly runtime failures. + Interface *TypedInterface `protobuf:"bytes,4,opt,name=interface,proto3" json:"interface,omitempty"` + // Custom data about the task. This is extensible to allow various plugins in the system. + Custom *structpb.Struct `protobuf:"bytes,5,opt,name=custom,proto3" json:"custom,omitempty"` + // Known target types that the system will guarantee plugins for. Custom SDK plugins are allowed to set these if needed. + // If no corresponding execution-layer plugins are found, the system will default to handling these using built-in + // handlers. + // + // Types that are assignable to Target: + // + // *TaskTemplate_Container + // *TaskTemplate_K8SPod + // *TaskTemplate_Sql + Target isTaskTemplate_Target `protobuf_oneof:"target"` + // This can be used to customize task handling at execution time for the same task type. + TaskTypeVersion int32 `protobuf:"varint,7,opt,name=task_type_version,json=taskTypeVersion,proto3" json:"task_type_version,omitempty"` + // security_context encapsulates security attributes requested to run this task. + SecurityContext *SecurityContext `protobuf:"bytes,8,opt,name=security_context,json=securityContext,proto3" json:"security_context,omitempty"` + // Encapsulates all non-standard resources, not captured by + // v1.ResourceRequirements, to allocate to a task. + ExtendedResources *ExtendedResources `protobuf:"bytes,9,opt,name=extended_resources,json=extendedResources,proto3" json:"extended_resources,omitempty"` + // Metadata about the custom defined for this task. This is extensible to allow various plugins in the system + // to use as required. + // reserve the field numbers 1 through 15 for very frequently occurring message elements + Config map[string]string `protobuf:"bytes,16,rep,name=config,proto3" json:"config,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *TaskTemplate) Reset() { + *x = TaskTemplate{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskTemplate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskTemplate) ProtoMessage() {} + +func (x *TaskTemplate) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskTemplate.ProtoReflect.Descriptor instead. +func (*TaskTemplate) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{6} +} + +func (x *TaskTemplate) GetId() *Identifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *TaskTemplate) GetType() string { + if x != nil { + return x.Type + } + return "" +} + +func (x *TaskTemplate) GetMetadata() *TaskMetadata { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *TaskTemplate) GetInterface() *TypedInterface { + if x != nil { + return x.Interface + } + return nil +} + +func (x *TaskTemplate) GetCustom() *structpb.Struct { + if x != nil { + return x.Custom + } + return nil +} + +func (m *TaskTemplate) GetTarget() isTaskTemplate_Target { + if m != nil { + return m.Target + } + return nil +} + +func (x *TaskTemplate) GetContainer() *Container { + if x, ok := x.GetTarget().(*TaskTemplate_Container); ok { + return x.Container + } + return nil +} + +func (x *TaskTemplate) GetK8SPod() *K8SPod { + if x, ok := x.GetTarget().(*TaskTemplate_K8SPod); ok { + return x.K8SPod + } + return nil +} + +func (x *TaskTemplate) GetSql() *Sql { + if x, ok := x.GetTarget().(*TaskTemplate_Sql); ok { + return x.Sql + } + return nil +} + +func (x *TaskTemplate) GetTaskTypeVersion() int32 { + if x != nil { + return x.TaskTypeVersion + } + return 0 +} + +func (x *TaskTemplate) GetSecurityContext() *SecurityContext { + if x != nil { + return x.SecurityContext + } + return nil +} + +func (x *TaskTemplate) GetExtendedResources() *ExtendedResources { + if x != nil { + return x.ExtendedResources + } + return nil +} + +func (x *TaskTemplate) GetConfig() map[string]string { + if x != nil { + return x.Config + } + return nil +} + +type isTaskTemplate_Target interface { + isTaskTemplate_Target() +} + +type TaskTemplate_Container struct { + Container *Container `protobuf:"bytes,6,opt,name=container,proto3,oneof"` +} + +type TaskTemplate_K8SPod struct { + K8SPod *K8SPod `protobuf:"bytes,17,opt,name=k8s_pod,json=k8sPod,proto3,oneof"` +} + +type TaskTemplate_Sql struct { + Sql *Sql `protobuf:"bytes,18,opt,name=sql,proto3,oneof"` +} + +func (*TaskTemplate_Container) isTaskTemplate_Target() {} + +func (*TaskTemplate_K8SPod) isTaskTemplate_Target() {} + +func (*TaskTemplate_Sql) isTaskTemplate_Target() {} + +// Defines port properties for a container. +type ContainerPort struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Number of port to expose on the pod's IP address. + // This must be a valid port number, 0 < x < 65536. + ContainerPort uint32 `protobuf:"varint,1,opt,name=container_port,json=containerPort,proto3" json:"container_port,omitempty"` + // Name of the port to expose on the pod's IP address. + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *ContainerPort) Reset() { + *x = ContainerPort{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ContainerPort) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ContainerPort) ProtoMessage() {} + +func (x *ContainerPort) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ContainerPort.ProtoReflect.Descriptor instead. +func (*ContainerPort) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{7} +} + +func (x *ContainerPort) GetContainerPort() uint32 { + if x != nil { + return x.ContainerPort + } + return 0 +} + +func (x *ContainerPort) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type Container struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Container image url. Eg: docker/redis:latest + Image string `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"` + // Command to be executed, if not provided, the default entrypoint in the container image will be used. + Command []string `protobuf:"bytes,2,rep,name=command,proto3" json:"command,omitempty"` + // These will default to Flyte given paths. If provided, the system will not append known paths. If the task still + // needs flyte's inputs and outputs path, add $(FLYTE_INPUT_FILE), $(FLYTE_OUTPUT_FILE) wherever makes sense and the + // system will populate these before executing the container. + Args []string `protobuf:"bytes,3,rep,name=args,proto3" json:"args,omitempty"` + // Container resources requirement as specified by the container engine. + Resources *Resources `protobuf:"bytes,4,opt,name=resources,proto3" json:"resources,omitempty"` + // Environment variables will be set as the container is starting up. + Env []*KeyValuePair `protobuf:"bytes,5,rep,name=env,proto3" json:"env,omitempty"` + // Allows extra configs to be available for the container. + // TODO: elaborate on how configs will become available. + // Deprecated, please use TaskTemplate.config instead. + // + // Deprecated: Marked as deprecated in flyteidl2/core/tasks.proto. + Config []*KeyValuePair `protobuf:"bytes,6,rep,name=config,proto3" json:"config,omitempty"` + // Ports to open in the container. This feature is not supported by all execution engines. (e.g. supported on K8s but + // not supported on AWS Batch) + // Only K8s + Ports []*ContainerPort `protobuf:"bytes,7,rep,name=ports,proto3" json:"ports,omitempty"` + // BETA: Optional configuration for DataLoading. If not specified, then default values are used. + // This makes it possible to to run a completely portable container, that uses inputs and outputs + // only from the local file-system and without having any reference to flyteidl. This is supported only on K8s at the moment. + // If data loading is enabled, then data will be mounted in accompanying directories specified in the DataLoadingConfig. If the directories + // are not specified, inputs will be mounted onto and outputs will be uploaded from a pre-determined file-system path. Refer to the documentation + // to understand the default paths. + // Only K8s + DataConfig *DataLoadingConfig `protobuf:"bytes,9,opt,name=data_config,json=dataConfig,proto3" json:"data_config,omitempty"` + Architecture Container_Architecture `protobuf:"varint,10,opt,name=architecture,proto3,enum=flyteidl2.core.Container_Architecture" json:"architecture,omitempty"` +} + +func (x *Container) Reset() { + *x = Container{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Container) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Container) ProtoMessage() {} + +func (x *Container) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Container.ProtoReflect.Descriptor instead. +func (*Container) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{8} +} + +func (x *Container) GetImage() string { + if x != nil { + return x.Image + } + return "" +} + +func (x *Container) GetCommand() []string { + if x != nil { + return x.Command + } + return nil +} + +func (x *Container) GetArgs() []string { + if x != nil { + return x.Args + } + return nil +} + +func (x *Container) GetResources() *Resources { + if x != nil { + return x.Resources + } + return nil +} + +func (x *Container) GetEnv() []*KeyValuePair { + if x != nil { + return x.Env + } + return nil +} + +// Deprecated: Marked as deprecated in flyteidl2/core/tasks.proto. +func (x *Container) GetConfig() []*KeyValuePair { + if x != nil { + return x.Config + } + return nil +} + +func (x *Container) GetPorts() []*ContainerPort { + if x != nil { + return x.Ports + } + return nil +} + +func (x *Container) GetDataConfig() *DataLoadingConfig { + if x != nil { + return x.DataConfig + } + return nil +} + +func (x *Container) GetArchitecture() Container_Architecture { + if x != nil { + return x.Architecture + } + return Container_UNKNOWN +} + +// Strategy to use when dealing with Blob, Schema, or multipart blob data (large datasets) +type IOStrategy struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Mode to use to manage downloads + DownloadMode IOStrategy_DownloadMode `protobuf:"varint,1,opt,name=download_mode,json=downloadMode,proto3,enum=flyteidl2.core.IOStrategy_DownloadMode" json:"download_mode,omitempty"` + // Mode to use to manage uploads + UploadMode IOStrategy_UploadMode `protobuf:"varint,2,opt,name=upload_mode,json=uploadMode,proto3,enum=flyteidl2.core.IOStrategy_UploadMode" json:"upload_mode,omitempty"` +} + +func (x *IOStrategy) Reset() { + *x = IOStrategy{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *IOStrategy) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IOStrategy) ProtoMessage() {} + +func (x *IOStrategy) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use IOStrategy.ProtoReflect.Descriptor instead. +func (*IOStrategy) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{9} +} + +func (x *IOStrategy) GetDownloadMode() IOStrategy_DownloadMode { + if x != nil { + return x.DownloadMode + } + return IOStrategy_DOWNLOAD_EAGER +} + +func (x *IOStrategy) GetUploadMode() IOStrategy_UploadMode { + if x != nil { + return x.UploadMode + } + return IOStrategy_UPLOAD_ON_EXIT +} + +// This configuration allows executing raw containers in Flyte using the Flyte CoPilot system. +// Flyte CoPilot, eliminates the needs of flytekit or sdk inside the container. Any inputs required by the users container are side-loaded in the input_path +// Any outputs generated by the user container - within output_path are automatically uploaded. +type DataLoadingConfig struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Flag enables DataLoading Config. If this is not set, data loading will not be used! + Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"` + // File system path (start at root). This folder will contain all the inputs exploded to a separate file. + // Example, if the input interface needs (x: int, y: blob, z: multipart_blob) and the input path is '/var/flyte/inputs', then the file system will look like + // /var/flyte/inputs/inputs. .pb .json .yaml> -> Format as defined previously. The Blob and Multipart blob will reference local filesystem instead of remote locations + // /var/flyte/inputs/x -> X is a file that contains the value of x (integer) in string format + // /var/flyte/inputs/y -> Y is a file in Binary format + // /var/flyte/inputs/z/... -> Note Z itself is a directory + // More information about the protocol - refer to docs #TODO reference docs here + InputPath string `protobuf:"bytes,2,opt,name=input_path,json=inputPath,proto3" json:"input_path,omitempty"` + // File system path (start at root). This folder should contain all the outputs for the task as individual files and/or an error text file + OutputPath string `protobuf:"bytes,3,opt,name=output_path,json=outputPath,proto3" json:"output_path,omitempty"` + // In the inputs folder, there will be an additional summary/metadata file that contains references to all files or inlined primitive values. + // This format decides the actual encoding for the data. Refer to the encoding to understand the specifics of the contents and the encoding + Format DataLoadingConfig_LiteralMapFormat `protobuf:"varint,4,opt,name=format,proto3,enum=flyteidl2.core.DataLoadingConfig_LiteralMapFormat" json:"format,omitempty"` + IoStrategy *IOStrategy `protobuf:"bytes,5,opt,name=io_strategy,json=ioStrategy,proto3" json:"io_strategy,omitempty"` +} + +func (x *DataLoadingConfig) Reset() { + *x = DataLoadingConfig{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DataLoadingConfig) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DataLoadingConfig) ProtoMessage() {} + +func (x *DataLoadingConfig) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DataLoadingConfig.ProtoReflect.Descriptor instead. +func (*DataLoadingConfig) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{10} +} + +func (x *DataLoadingConfig) GetEnabled() bool { + if x != nil { + return x.Enabled + } + return false +} + +func (x *DataLoadingConfig) GetInputPath() string { + if x != nil { + return x.InputPath + } + return "" +} + +func (x *DataLoadingConfig) GetOutputPath() string { + if x != nil { + return x.OutputPath + } + return "" +} + +func (x *DataLoadingConfig) GetFormat() DataLoadingConfig_LiteralMapFormat { + if x != nil { + return x.Format + } + return DataLoadingConfig_JSON +} + +func (x *DataLoadingConfig) GetIoStrategy() *IOStrategy { + if x != nil { + return x.IoStrategy + } + return nil +} + +// Defines a pod spec and additional pod metadata that is created when a task is executed. +type K8SPod struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Contains additional metadata for building a kubernetes pod. + Metadata *K8SObjectMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` + // Defines the primary pod spec created when a task is executed. + // This should be a JSON-marshalled pod spec, which can be defined in + // - go, using: https://github.com/kubernetes/api/blob/release-1.21/core/v1/types.go#L2936 + // - python: using https://github.com/kubernetes-client/python/blob/release-19.0/kubernetes/client/models/v1_pod_spec.py + PodSpec *structpb.Struct `protobuf:"bytes,2,opt,name=pod_spec,json=podSpec,proto3" json:"pod_spec,omitempty"` + // BETA: Optional configuration for DataLoading. If not specified, then default values are used. + // This makes it possible to to run a completely portable container, that uses inputs and outputs + // only from the local file-system and without having any reference to flytekit. This is supported only on K8s at the moment. + // If data loading is enabled, then data will be mounted in accompanying directories specified in the DataLoadingConfig. If the directories + // are not specified, inputs will be mounted onto and outputs will be uploaded from a pre-determined file-system path. Refer to the documentation + // to understand the default paths. + // Only K8s + DataConfig *DataLoadingConfig `protobuf:"bytes,3,opt,name=data_config,json=dataConfig,proto3" json:"data_config,omitempty"` + // Defines the primary container name when pod template override is executed. + PrimaryContainerName string `protobuf:"bytes,4,opt,name=primary_container_name,json=primaryContainerName,proto3" json:"primary_container_name,omitempty"` +} + +func (x *K8SPod) Reset() { + *x = K8SPod{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *K8SPod) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*K8SPod) ProtoMessage() {} + +func (x *K8SPod) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use K8SPod.ProtoReflect.Descriptor instead. +func (*K8SPod) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{11} +} + +func (x *K8SPod) GetMetadata() *K8SObjectMetadata { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *K8SPod) GetPodSpec() *structpb.Struct { + if x != nil { + return x.PodSpec + } + return nil +} + +func (x *K8SPod) GetDataConfig() *DataLoadingConfig { + if x != nil { + return x.DataConfig + } + return nil +} + +func (x *K8SPod) GetPrimaryContainerName() string { + if x != nil { + return x.PrimaryContainerName + } + return "" +} + +// Metadata for building a kubernetes object when a task is executed. +type K8SObjectMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Optional labels to add to the pod definition. + Labels map[string]string `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // Optional annotations to add to the pod definition. + Annotations map[string]string `protobuf:"bytes,2,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *K8SObjectMetadata) Reset() { + *x = K8SObjectMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *K8SObjectMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*K8SObjectMetadata) ProtoMessage() {} + +func (x *K8SObjectMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use K8SObjectMetadata.ProtoReflect.Descriptor instead. +func (*K8SObjectMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{12} +} + +func (x *K8SObjectMetadata) GetLabels() map[string]string { + if x != nil { + return x.Labels + } + return nil +} + +func (x *K8SObjectMetadata) GetAnnotations() map[string]string { + if x != nil { + return x.Annotations + } + return nil +} + +// Sql represents a generic sql workload with a statement and dialect. +type Sql struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The actual query to run, the query can have templated parameters. + // We use Flyte's Golang templating format for Query templating. + // For example, + // insert overwrite directory '{{ .rawOutputDataPrefix }}' stored as parquet + // select * + // from my_table + // where ds = '{{ .Inputs.ds }}' + Statement string `protobuf:"bytes,1,opt,name=statement,proto3" json:"statement,omitempty"` + Dialect Sql_Dialect `protobuf:"varint,2,opt,name=dialect,proto3,enum=flyteidl2.core.Sql_Dialect" json:"dialect,omitempty"` +} + +func (x *Sql) Reset() { + *x = Sql{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Sql) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Sql) ProtoMessage() {} + +func (x *Sql) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Sql.ProtoReflect.Descriptor instead. +func (*Sql) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{13} +} + +func (x *Sql) GetStatement() string { + if x != nil { + return x.Statement + } + return "" +} + +func (x *Sql) GetDialect() Sql_Dialect { + if x != nil { + return x.Dialect + } + return Sql_UNDEFINED +} + +// Encapsulates a resource name and value. +type Resources_ResourceEntry struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Resource name. + Name Resources_ResourceName `protobuf:"varint,1,opt,name=name,proto3,enum=flyteidl2.core.Resources_ResourceName" json:"name,omitempty"` + // Value must be a valid k8s quantity. See + // https://github.com/kubernetes/apimachinery/blob/master/pkg/api/resource/quantity.go#L30-L80 + Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` +} + +func (x *Resources_ResourceEntry) Reset() { + *x = Resources_ResourceEntry{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Resources_ResourceEntry) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Resources_ResourceEntry) ProtoMessage() {} + +func (x *Resources_ResourceEntry) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_tasks_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Resources_ResourceEntry.ProtoReflect.Descriptor instead. +func (*Resources_ResourceEntry) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_tasks_proto_rawDescGZIP(), []int{0, 0} +} + +func (x *Resources_ResourceEntry) GetName() Resources_ResourceName { + if x != nil { + return x.Name + } + return Resources_UNKNOWN +} + +func (x *Resources_ResourceEntry) GetValue() string { + if x != nil { + return x.Value + } + return "" +} + +var File_flyteidl2_core_tasks_proto protoreflect.FileDescriptor + +var file_flyteidl2_core_tasks_proto_rawDesc = []byte{ + 0x0a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x1a, 0x1e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, 0x6e, + 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x6c, 0x69, + 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x73, 0x65, 0x63, + 0x75, 0x72, 0x69, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x73, 0x74, 0x72, + 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, + 0x65, 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xd3, 0x02, 0x0a, 0x09, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x12, 0x43, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x73, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x08, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x12, 0x3f, 0x0a, 0x06, + 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x1a, 0x61, 0x0a, + 0x0d, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x3a, + 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x22, 0x5d, 0x0a, 0x0c, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, + 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x07, 0x0a, + 0x03, 0x43, 0x50, 0x55, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x47, 0x50, 0x55, 0x10, 0x02, 0x12, + 0x0a, 0x0a, 0x06, 0x4d, 0x45, 0x4d, 0x4f, 0x52, 0x59, 0x10, 0x03, 0x12, 0x0b, 0x0a, 0x07, 0x53, + 0x54, 0x4f, 0x52, 0x41, 0x47, 0x45, 0x10, 0x04, 0x12, 0x15, 0x0a, 0x11, 0x45, 0x50, 0x48, 0x45, + 0x4d, 0x45, 0x52, 0x41, 0x4c, 0x5f, 0x53, 0x54, 0x4f, 0x52, 0x41, 0x47, 0x45, 0x10, 0x05, 0x22, + 0xc1, 0x02, 0x0a, 0x0e, 0x47, 0x50, 0x55, 0x41, 0x63, 0x63, 0x65, 0x6c, 0x65, 0x72, 0x61, 0x74, + 0x6f, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x06, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x12, 0x26, 0x0a, 0x0d, 0x75, 0x6e, + 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x08, 0x48, 0x00, 0x52, 0x0d, 0x75, 0x6e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x65, 0x64, 0x12, 0x27, 0x0a, 0x0e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x73, 0x69, 0x7a, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0d, 0x70, 0x61, + 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x4d, 0x0a, 0x0c, 0x64, + 0x65, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0e, 0x32, 0x2a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x47, 0x50, 0x55, 0x41, 0x63, 0x63, 0x65, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x6f, + 0x72, 0x2e, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x52, 0x0b, 0x64, + 0x65, 0x76, 0x69, 0x63, 0x65, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x22, 0x5f, 0x0a, 0x0b, 0x44, 0x65, + 0x76, 0x69, 0x63, 0x65, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x0e, 0x0a, 0x0a, 0x4e, 0x56, 0x49, + 0x44, 0x49, 0x41, 0x5f, 0x47, 0x50, 0x55, 0x10, 0x00, 0x12, 0x0e, 0x0a, 0x0a, 0x47, 0x4f, 0x4f, + 0x47, 0x4c, 0x45, 0x5f, 0x54, 0x50, 0x55, 0x10, 0x01, 0x12, 0x11, 0x0a, 0x0d, 0x41, 0x4d, 0x41, + 0x5a, 0x4f, 0x4e, 0x5f, 0x4e, 0x45, 0x55, 0x52, 0x4f, 0x4e, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, + 0x41, 0x4d, 0x44, 0x5f, 0x47, 0x50, 0x55, 0x10, 0x03, 0x12, 0x10, 0x0a, 0x0c, 0x48, 0x41, 0x42, + 0x41, 0x4e, 0x41, 0x5f, 0x47, 0x41, 0x55, 0x44, 0x49, 0x10, 0x04, 0x42, 0x16, 0x0a, 0x14, 0x70, + 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x22, 0x6b, 0x0a, 0x0c, 0x53, 0x68, 0x61, 0x72, 0x65, 0x64, 0x4d, 0x65, 0x6d, + 0x6f, 0x72, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x70, 0x61, 0x74, + 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x61, + 0x74, 0x68, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x4e, 0x61, 0x6d, + 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x69, 0x7a, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, + 0x22, 0x9f, 0x01, 0x0a, 0x11, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x52, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x12, 0x47, 0x0a, 0x0f, 0x67, 0x70, 0x75, 0x5f, 0x61, 0x63, + 0x63, 0x65, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x47, 0x50, 0x55, 0x41, 0x63, 0x63, 0x65, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x52, + 0x0e, 0x67, 0x70, 0x75, 0x41, 0x63, 0x63, 0x65, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, + 0x41, 0x0a, 0x0d, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x65, 0x64, 0x4d, 0x65, + 0x6d, 0x6f, 0x72, 0x79, 0x52, 0x0c, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x4d, 0x65, 0x6d, 0x6f, + 0x72, 0x79, 0x22, 0xad, 0x01, 0x0a, 0x0f, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x3f, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, + 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x6c, 0x61, 0x76, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x06, 0x66, 0x6c, 0x61, 0x76, 0x6f, 0x72, 0x22, 0x27, 0x0a, 0x0b, 0x52, 0x75, 0x6e, + 0x74, 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x09, 0x0a, 0x05, 0x4f, 0x54, 0x48, 0x45, + 0x52, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x46, 0x4c, 0x59, 0x54, 0x45, 0x5f, 0x53, 0x44, 0x4b, + 0x10, 0x01, 0x22, 0x81, 0x07, 0x0a, 0x0c, 0x54, 0x61, 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x12, 0x22, 0x0a, 0x0c, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x61, + 0x62, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x64, 0x69, 0x73, 0x63, 0x6f, + 0x76, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x39, 0x0a, 0x07, 0x72, 0x75, 0x6e, 0x74, 0x69, + 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, + 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x07, 0x72, 0x75, 0x6e, 0x74, 0x69, + 0x6d, 0x65, 0x12, 0x33, 0x0a, 0x07, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, + 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x12, 0x37, 0x0a, 0x07, 0x72, 0x65, 0x74, 0x72, 0x69, + 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x53, + 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x52, 0x07, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73, + 0x12, 0x2b, 0x0a, 0x11, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x5f, 0x76, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x64, 0x69, 0x73, + 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x38, 0x0a, + 0x18, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x72, 0x72, 0x6f, + 0x72, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x16, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x45, 0x72, 0x72, 0x6f, 0x72, + 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x26, 0x0a, 0x0d, 0x69, 0x6e, 0x74, 0x65, 0x72, + 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, + 0x52, 0x0d, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x12, + 0x2d, 0x0a, 0x12, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, + 0x7a, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x11, 0x63, 0x61, 0x63, + 0x68, 0x65, 0x53, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x3a, + 0x0a, 0x04, 0x74, 0x61, 0x67, 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, + 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x67, 0x73, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x70, 0x6f, + 0x64, 0x5f, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x70, 0x6f, 0x64, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, + 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x17, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, + 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x76, 0x61, 0x72, + 0x73, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x09, 0x52, 0x14, 0x63, 0x61, 0x63, 0x68, 0x65, 0x49, 0x67, + 0x6e, 0x6f, 0x72, 0x65, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x56, 0x61, 0x72, 0x73, 0x12, 0x19, 0x0a, + 0x08, 0x69, 0x73, 0x5f, 0x65, 0x61, 0x67, 0x65, 0x72, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x07, 0x69, 0x73, 0x45, 0x61, 0x67, 0x65, 0x72, 0x12, 0x41, 0x0a, 0x0e, 0x67, 0x65, 0x6e, 0x65, + 0x72, 0x61, 0x74, 0x65, 0x73, 0x5f, 0x64, 0x65, 0x63, 0x6b, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0d, 0x67, 0x65, + 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x73, 0x44, 0x65, 0x63, 0x6b, 0x12, 0x3d, 0x0a, 0x08, 0x6d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, + 0x38, 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1e, 0x0a, 0x0a, 0x64, 0x65, + 0x62, 0x75, 0x67, 0x67, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, + 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x34, 0x0a, 0x09, 0x6c, 0x6f, + 0x67, 0x5f, 0x6c, 0x69, 0x6e, 0x6b, 0x73, 0x18, 0x12, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, + 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x52, 0x08, 0x6c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x6b, 0x73, + 0x1a, 0x37, 0x0a, 0x09, 0x54, 0x61, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, + 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, + 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0x15, 0x0a, 0x13, 0x69, 0x6e, 0x74, + 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x4a, 0x04, 0x08, 0x0a, 0x10, 0x0b, 0x22, 0xdf, 0x05, 0x0a, 0x0c, 0x54, 0x61, 0x73, 0x6b, 0x54, + 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x12, 0x2a, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, + 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x38, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x12, 0x3c, 0x0a, 0x09, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x65, 0x72, + 0x66, 0x61, 0x63, 0x65, 0x52, 0x09, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x12, + 0x2f, 0x0a, 0x06, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x06, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, + 0x12, 0x39, 0x0a, 0x09, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x48, 0x00, + 0x52, 0x09, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x12, 0x31, 0x0a, 0x07, 0x6b, + 0x38, 0x73, 0x5f, 0x70, 0x6f, 0x64, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x38, + 0x73, 0x50, 0x6f, 0x64, 0x48, 0x00, 0x52, 0x06, 0x6b, 0x38, 0x73, 0x50, 0x6f, 0x64, 0x12, 0x27, + 0x0a, 0x03, 0x73, 0x71, 0x6c, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x71, 0x6c, + 0x48, 0x00, 0x52, 0x03, 0x73, 0x71, 0x6c, 0x12, 0x2a, 0x0a, 0x11, 0x74, 0x61, 0x73, 0x6b, 0x5f, + 0x74, 0x79, 0x70, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x0f, 0x74, 0x61, 0x73, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x12, 0x4a, 0x0a, 0x10, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x5f, + 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, + 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, 0x0f, + 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, + 0x50, 0x0a, 0x12, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x45, 0x78, 0x74, + 0x65, 0x6e, 0x64, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x52, 0x11, + 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x73, 0x12, 0x40, 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x10, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x2e, + 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x63, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x1a, 0x39, 0x0a, 0x0b, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0x08, + 0x0a, 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x22, 0x4a, 0x0a, 0x0d, 0x43, 0x6f, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x65, 0x72, 0x50, 0x6f, 0x72, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x50, 0x6f, 0x72, 0x74, + 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x82, 0x04, 0x0a, 0x09, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6d, 0x6d, + 0x61, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x61, + 0x6e, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x61, 0x72, 0x67, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, + 0x52, 0x04, 0x61, 0x72, 0x67, 0x73, 0x12, 0x37, 0x0a, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x73, 0x52, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x12, + 0x2e, 0x0a, 0x03, 0x65, 0x6e, 0x76, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x65, + 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x61, 0x69, 0x72, 0x52, 0x03, 0x65, 0x6e, 0x76, 0x12, + 0x38, 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x61, 0x69, 0x72, 0x42, 0x02, 0x18, + 0x01, 0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x33, 0x0a, 0x05, 0x70, 0x6f, 0x72, + 0x74, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x50, 0x6f, 0x72, 0x74, 0x52, 0x05, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x12, 0x42, + 0x0a, 0x0b, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x09, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x4c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67, + 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x12, 0x4a, 0x0a, 0x0c, 0x61, 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, + 0x72, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x2e, 0x41, 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, 0x72, 0x65, + 0x52, 0x0c, 0x61, 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, 0x72, 0x65, 0x22, 0x49, + 0x0a, 0x0c, 0x41, 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, 0x72, 0x65, 0x12, 0x0b, + 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x41, + 0x4d, 0x44, 0x36, 0x34, 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05, 0x41, 0x52, 0x4d, 0x36, 0x34, 0x10, + 0x02, 0x12, 0x0a, 0x0a, 0x06, 0x41, 0x52, 0x4d, 0x5f, 0x56, 0x36, 0x10, 0x03, 0x12, 0x0a, 0x0a, + 0x06, 0x41, 0x52, 0x4d, 0x5f, 0x56, 0x37, 0x10, 0x04, 0x22, 0xb7, 0x02, 0x0a, 0x0a, 0x49, 0x4f, + 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x12, 0x4c, 0x0a, 0x0d, 0x64, 0x6f, 0x77, 0x6e, + 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x49, 0x4f, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x2e, 0x44, 0x6f, 0x77, 0x6e, + 0x6c, 0x6f, 0x61, 0x64, 0x4d, 0x6f, 0x64, 0x65, 0x52, 0x0c, 0x64, 0x6f, 0x77, 0x6e, 0x6c, 0x6f, + 0x61, 0x64, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x46, 0x0a, 0x0b, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, + 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x4f, 0x53, + 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x2e, 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x4d, 0x6f, + 0x64, 0x65, 0x52, 0x0a, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x4d, 0x6f, 0x64, 0x65, 0x22, 0x4c, + 0x0a, 0x0c, 0x44, 0x6f, 0x77, 0x6e, 0x6c, 0x6f, 0x61, 0x64, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x12, + 0x0a, 0x0e, 0x44, 0x4f, 0x57, 0x4e, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x45, 0x41, 0x47, 0x45, 0x52, + 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x44, 0x4f, 0x57, 0x4e, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x53, + 0x54, 0x52, 0x45, 0x41, 0x4d, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x44, 0x4f, 0x5f, 0x4e, 0x4f, + 0x54, 0x5f, 0x44, 0x4f, 0x57, 0x4e, 0x4c, 0x4f, 0x41, 0x44, 0x10, 0x02, 0x22, 0x45, 0x0a, 0x0a, + 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x12, 0x0a, 0x0e, 0x55, 0x50, + 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x4f, 0x4e, 0x5f, 0x45, 0x58, 0x49, 0x54, 0x10, 0x00, 0x12, 0x10, + 0x0a, 0x0c, 0x55, 0x50, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x45, 0x41, 0x47, 0x45, 0x52, 0x10, 0x01, + 0x12, 0x11, 0x0a, 0x0d, 0x44, 0x4f, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x55, 0x50, 0x4c, 0x4f, 0x41, + 0x44, 0x10, 0x02, 0x22, 0xa9, 0x02, 0x0a, 0x11, 0x44, 0x61, 0x74, 0x61, 0x4c, 0x6f, 0x61, 0x64, + 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, 0x61, + 0x62, 0x6c, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x65, 0x6e, 0x61, 0x62, + 0x6c, 0x65, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x70, 0x61, 0x74, + 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x50, 0x61, + 0x74, 0x68, 0x12, 0x1f, 0x0a, 0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x70, 0x61, 0x74, + 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x50, + 0x61, 0x74, 0x68, 0x12, 0x4a, 0x0a, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x32, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x4c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67, + 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, + 0x70, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, + 0x3b, 0x0a, 0x0b, 0x69, 0x6f, 0x5f, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x4f, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, + 0x52, 0x0a, 0x69, 0x6f, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x22, 0x31, 0x0a, 0x10, + 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, 0x70, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, + 0x12, 0x08, 0x0a, 0x04, 0x4a, 0x53, 0x4f, 0x4e, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x59, 0x41, + 0x4d, 0x4c, 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x10, 0x02, 0x22, + 0xf5, 0x01, 0x0a, 0x06, 0x4b, 0x38, 0x73, 0x50, 0x6f, 0x64, 0x12, 0x3d, 0x0a, 0x08, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x38, + 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, + 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x32, 0x0a, 0x08, 0x70, 0x6f, 0x64, + 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, + 0x72, 0x75, 0x63, 0x74, 0x52, 0x07, 0x70, 0x6f, 0x64, 0x53, 0x70, 0x65, 0x63, 0x12, 0x42, 0x0a, + 0x0b, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x4c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x43, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x12, 0x34, 0x0a, 0x16, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x5f, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x14, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0xab, 0x02, 0x0a, 0x11, 0x4b, 0x38, 0x73, 0x4f, + 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x45, 0x0a, + 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, + 0x38, 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x6c, 0x61, + 0x62, 0x65, 0x6c, 0x73, 0x12, 0x54, 0x0a, 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x38, 0x73, 0x4f, 0x62, + 0x6a, 0x65, 0x63, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x41, 0x6e, 0x6e, + 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x61, + 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x39, 0x0a, 0x0b, 0x4c, 0x61, + 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3e, 0x0a, 0x10, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x93, 0x01, 0x0a, 0x03, 0x53, 0x71, 0x6c, 0x12, 0x1c, 0x0a, + 0x09, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x35, 0x0a, 0x07, 0x64, + 0x69, 0x61, 0x6c, 0x65, 0x63, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x71, + 0x6c, 0x2e, 0x44, 0x69, 0x61, 0x6c, 0x65, 0x63, 0x74, 0x52, 0x07, 0x64, 0x69, 0x61, 0x6c, 0x65, + 0x63, 0x74, 0x22, 0x37, 0x0a, 0x07, 0x44, 0x69, 0x61, 0x6c, 0x65, 0x63, 0x74, 0x12, 0x0d, 0x0a, + 0x09, 0x55, 0x4e, 0x44, 0x45, 0x46, 0x49, 0x4e, 0x45, 0x44, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, + 0x41, 0x4e, 0x53, 0x49, 0x10, 0x01, 0x12, 0x08, 0x0a, 0x04, 0x48, 0x49, 0x56, 0x45, 0x10, 0x02, + 0x12, 0x09, 0x0a, 0x05, 0x4f, 0x54, 0x48, 0x45, 0x52, 0x10, 0x03, 0x42, 0xaf, 0x01, 0x0a, 0x12, + 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x42, 0x0a, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, + 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, + 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x0e, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0xca, 0x02, 0x0e, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0xe2, 0x02, + 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, + 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x62, 0x06, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_core_tasks_proto_rawDescOnce sync.Once + file_flyteidl2_core_tasks_proto_rawDescData = file_flyteidl2_core_tasks_proto_rawDesc +) + +func file_flyteidl2_core_tasks_proto_rawDescGZIP() []byte { + file_flyteidl2_core_tasks_proto_rawDescOnce.Do(func() { + file_flyteidl2_core_tasks_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_core_tasks_proto_rawDescData) + }) + return file_flyteidl2_core_tasks_proto_rawDescData +} + +var file_flyteidl2_core_tasks_proto_enumTypes = make([]protoimpl.EnumInfo, 8) +var file_flyteidl2_core_tasks_proto_msgTypes = make([]protoimpl.MessageInfo, 19) +var file_flyteidl2_core_tasks_proto_goTypes = []interface{}{ + (Resources_ResourceName)(0), // 0: flyteidl2.core.Resources.ResourceName + (GPUAccelerator_DeviceClass)(0), // 1: flyteidl2.core.GPUAccelerator.DeviceClass + (RuntimeMetadata_RuntimeType)(0), // 2: flyteidl2.core.RuntimeMetadata.RuntimeType + (Container_Architecture)(0), // 3: flyteidl2.core.Container.Architecture + (IOStrategy_DownloadMode)(0), // 4: flyteidl2.core.IOStrategy.DownloadMode + (IOStrategy_UploadMode)(0), // 5: flyteidl2.core.IOStrategy.UploadMode + (DataLoadingConfig_LiteralMapFormat)(0), // 6: flyteidl2.core.DataLoadingConfig.LiteralMapFormat + (Sql_Dialect)(0), // 7: flyteidl2.core.Sql.Dialect + (*Resources)(nil), // 8: flyteidl2.core.Resources + (*GPUAccelerator)(nil), // 9: flyteidl2.core.GPUAccelerator + (*SharedMemory)(nil), // 10: flyteidl2.core.SharedMemory + (*ExtendedResources)(nil), // 11: flyteidl2.core.ExtendedResources + (*RuntimeMetadata)(nil), // 12: flyteidl2.core.RuntimeMetadata + (*TaskMetadata)(nil), // 13: flyteidl2.core.TaskMetadata + (*TaskTemplate)(nil), // 14: flyteidl2.core.TaskTemplate + (*ContainerPort)(nil), // 15: flyteidl2.core.ContainerPort + (*Container)(nil), // 16: flyteidl2.core.Container + (*IOStrategy)(nil), // 17: flyteidl2.core.IOStrategy + (*DataLoadingConfig)(nil), // 18: flyteidl2.core.DataLoadingConfig + (*K8SPod)(nil), // 19: flyteidl2.core.K8sPod + (*K8SObjectMetadata)(nil), // 20: flyteidl2.core.K8sObjectMetadata + (*Sql)(nil), // 21: flyteidl2.core.Sql + (*Resources_ResourceEntry)(nil), // 22: flyteidl2.core.Resources.ResourceEntry + nil, // 23: flyteidl2.core.TaskMetadata.TagsEntry + nil, // 24: flyteidl2.core.TaskTemplate.ConfigEntry + nil, // 25: flyteidl2.core.K8sObjectMetadata.LabelsEntry + nil, // 26: flyteidl2.core.K8sObjectMetadata.AnnotationsEntry + (*durationpb.Duration)(nil), // 27: google.protobuf.Duration + (*RetryStrategy)(nil), // 28: flyteidl2.core.RetryStrategy + (*wrapperspb.BoolValue)(nil), // 29: google.protobuf.BoolValue + (*TaskLog)(nil), // 30: flyteidl2.core.TaskLog + (*Identifier)(nil), // 31: flyteidl2.core.Identifier + (*TypedInterface)(nil), // 32: flyteidl2.core.TypedInterface + (*structpb.Struct)(nil), // 33: google.protobuf.Struct + (*SecurityContext)(nil), // 34: flyteidl2.core.SecurityContext + (*KeyValuePair)(nil), // 35: flyteidl2.core.KeyValuePair +} +var file_flyteidl2_core_tasks_proto_depIdxs = []int32{ + 22, // 0: flyteidl2.core.Resources.requests:type_name -> flyteidl2.core.Resources.ResourceEntry + 22, // 1: flyteidl2.core.Resources.limits:type_name -> flyteidl2.core.Resources.ResourceEntry + 1, // 2: flyteidl2.core.GPUAccelerator.device_class:type_name -> flyteidl2.core.GPUAccelerator.DeviceClass + 9, // 3: flyteidl2.core.ExtendedResources.gpu_accelerator:type_name -> flyteidl2.core.GPUAccelerator + 10, // 4: flyteidl2.core.ExtendedResources.shared_memory:type_name -> flyteidl2.core.SharedMemory + 2, // 5: flyteidl2.core.RuntimeMetadata.type:type_name -> flyteidl2.core.RuntimeMetadata.RuntimeType + 12, // 6: flyteidl2.core.TaskMetadata.runtime:type_name -> flyteidl2.core.RuntimeMetadata + 27, // 7: flyteidl2.core.TaskMetadata.timeout:type_name -> google.protobuf.Duration + 28, // 8: flyteidl2.core.TaskMetadata.retries:type_name -> flyteidl2.core.RetryStrategy + 23, // 9: flyteidl2.core.TaskMetadata.tags:type_name -> flyteidl2.core.TaskMetadata.TagsEntry + 29, // 10: flyteidl2.core.TaskMetadata.generates_deck:type_name -> google.protobuf.BoolValue + 20, // 11: flyteidl2.core.TaskMetadata.metadata:type_name -> flyteidl2.core.K8sObjectMetadata + 30, // 12: flyteidl2.core.TaskMetadata.log_links:type_name -> flyteidl2.core.TaskLog + 31, // 13: flyteidl2.core.TaskTemplate.id:type_name -> flyteidl2.core.Identifier + 13, // 14: flyteidl2.core.TaskTemplate.metadata:type_name -> flyteidl2.core.TaskMetadata + 32, // 15: flyteidl2.core.TaskTemplate.interface:type_name -> flyteidl2.core.TypedInterface + 33, // 16: flyteidl2.core.TaskTemplate.custom:type_name -> google.protobuf.Struct + 16, // 17: flyteidl2.core.TaskTemplate.container:type_name -> flyteidl2.core.Container + 19, // 18: flyteidl2.core.TaskTemplate.k8s_pod:type_name -> flyteidl2.core.K8sPod + 21, // 19: flyteidl2.core.TaskTemplate.sql:type_name -> flyteidl2.core.Sql + 34, // 20: flyteidl2.core.TaskTemplate.security_context:type_name -> flyteidl2.core.SecurityContext + 11, // 21: flyteidl2.core.TaskTemplate.extended_resources:type_name -> flyteidl2.core.ExtendedResources + 24, // 22: flyteidl2.core.TaskTemplate.config:type_name -> flyteidl2.core.TaskTemplate.ConfigEntry + 8, // 23: flyteidl2.core.Container.resources:type_name -> flyteidl2.core.Resources + 35, // 24: flyteidl2.core.Container.env:type_name -> flyteidl2.core.KeyValuePair + 35, // 25: flyteidl2.core.Container.config:type_name -> flyteidl2.core.KeyValuePair + 15, // 26: flyteidl2.core.Container.ports:type_name -> flyteidl2.core.ContainerPort + 18, // 27: flyteidl2.core.Container.data_config:type_name -> flyteidl2.core.DataLoadingConfig + 3, // 28: flyteidl2.core.Container.architecture:type_name -> flyteidl2.core.Container.Architecture + 4, // 29: flyteidl2.core.IOStrategy.download_mode:type_name -> flyteidl2.core.IOStrategy.DownloadMode + 5, // 30: flyteidl2.core.IOStrategy.upload_mode:type_name -> flyteidl2.core.IOStrategy.UploadMode + 6, // 31: flyteidl2.core.DataLoadingConfig.format:type_name -> flyteidl2.core.DataLoadingConfig.LiteralMapFormat + 17, // 32: flyteidl2.core.DataLoadingConfig.io_strategy:type_name -> flyteidl2.core.IOStrategy + 20, // 33: flyteidl2.core.K8sPod.metadata:type_name -> flyteidl2.core.K8sObjectMetadata + 33, // 34: flyteidl2.core.K8sPod.pod_spec:type_name -> google.protobuf.Struct + 18, // 35: flyteidl2.core.K8sPod.data_config:type_name -> flyteidl2.core.DataLoadingConfig + 25, // 36: flyteidl2.core.K8sObjectMetadata.labels:type_name -> flyteidl2.core.K8sObjectMetadata.LabelsEntry + 26, // 37: flyteidl2.core.K8sObjectMetadata.annotations:type_name -> flyteidl2.core.K8sObjectMetadata.AnnotationsEntry + 7, // 38: flyteidl2.core.Sql.dialect:type_name -> flyteidl2.core.Sql.Dialect + 0, // 39: flyteidl2.core.Resources.ResourceEntry.name:type_name -> flyteidl2.core.Resources.ResourceName + 40, // [40:40] is the sub-list for method output_type + 40, // [40:40] is the sub-list for method input_type + 40, // [40:40] is the sub-list for extension type_name + 40, // [40:40] is the sub-list for extension extendee + 0, // [0:40] is the sub-list for field type_name +} + +func init() { file_flyteidl2_core_tasks_proto_init() } +func file_flyteidl2_core_tasks_proto_init() { + if File_flyteidl2_core_tasks_proto != nil { + return + } + file_flyteidl2_core_execution_proto_init() + file_flyteidl2_core_identifier_proto_init() + file_flyteidl2_core_interface_proto_init() + file_flyteidl2_core_literals_proto_init() + file_flyteidl2_core_security_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_core_tasks_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Resources); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_tasks_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GPUAccelerator); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_tasks_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SharedMemory); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_tasks_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ExtendedResources); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_tasks_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RuntimeMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_tasks_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_tasks_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskTemplate); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_tasks_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ContainerPort); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_tasks_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Container); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_tasks_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*IOStrategy); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_tasks_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DataLoadingConfig); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_tasks_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*K8SPod); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_tasks_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*K8SObjectMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_tasks_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Sql); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_tasks_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Resources_ResourceEntry); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_core_tasks_proto_msgTypes[1].OneofWrappers = []interface{}{ + (*GPUAccelerator_Unpartitioned)(nil), + (*GPUAccelerator_PartitionSize)(nil), + } + file_flyteidl2_core_tasks_proto_msgTypes[5].OneofWrappers = []interface{}{ + (*TaskMetadata_Interruptible)(nil), + } + file_flyteidl2_core_tasks_proto_msgTypes[6].OneofWrappers = []interface{}{ + (*TaskTemplate_Container)(nil), + (*TaskTemplate_K8SPod)(nil), + (*TaskTemplate_Sql)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_core_tasks_proto_rawDesc, + NumEnums: 8, + NumMessages: 19, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_core_tasks_proto_goTypes, + DependencyIndexes: file_flyteidl2_core_tasks_proto_depIdxs, + EnumInfos: file_flyteidl2_core_tasks_proto_enumTypes, + MessageInfos: file_flyteidl2_core_tasks_proto_msgTypes, + }.Build() + File_flyteidl2_core_tasks_proto = out.File + file_flyteidl2_core_tasks_proto_rawDesc = nil + file_flyteidl2_core_tasks_proto_goTypes = nil + file_flyteidl2_core_tasks_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/core/tasks.pb.validate.go b/gen/go/flyteidl2/core/tasks.pb.validate.go new file mode 100644 index 0000000000..c81f6afbe4 --- /dev/null +++ b/gen/go/flyteidl2/core/tasks.pb.validate.go @@ -0,0 +1,2535 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/core/tasks.proto + +package core + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on Resources with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Resources) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Resources with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ResourcesMultiError, or nil +// if none found. +func (m *Resources) ValidateAll() error { + return m.validate(true) +} + +func (m *Resources) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetRequests() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ResourcesValidationError{ + field: fmt.Sprintf("Requests[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ResourcesValidationError{ + field: fmt.Sprintf("Requests[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ResourcesValidationError{ + field: fmt.Sprintf("Requests[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + for idx, item := range m.GetLimits() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ResourcesValidationError{ + field: fmt.Sprintf("Limits[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ResourcesValidationError{ + field: fmt.Sprintf("Limits[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ResourcesValidationError{ + field: fmt.Sprintf("Limits[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return ResourcesMultiError(errors) + } + + return nil +} + +// ResourcesMultiError is an error wrapping multiple validation errors returned +// by Resources.ValidateAll() if the designated constraints aren't met. +type ResourcesMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ResourcesMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ResourcesMultiError) AllErrors() []error { return m } + +// ResourcesValidationError is the validation error returned by +// Resources.Validate if the designated constraints aren't met. +type ResourcesValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ResourcesValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ResourcesValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ResourcesValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ResourcesValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ResourcesValidationError) ErrorName() string { return "ResourcesValidationError" } + +// Error satisfies the builtin error interface +func (e ResourcesValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sResources.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ResourcesValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ResourcesValidationError{} + +// Validate checks the field values on GPUAccelerator with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *GPUAccelerator) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GPUAccelerator with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in GPUAcceleratorMultiError, +// or nil if none found. +func (m *GPUAccelerator) ValidateAll() error { + return m.validate(true) +} + +func (m *GPUAccelerator) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Device + + // no validation rules for DeviceClass + + switch v := m.PartitionSizeValue.(type) { + case *GPUAccelerator_Unpartitioned: + if v == nil { + err := GPUAcceleratorValidationError{ + field: "PartitionSizeValue", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for Unpartitioned + case *GPUAccelerator_PartitionSize: + if v == nil { + err := GPUAcceleratorValidationError{ + field: "PartitionSizeValue", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for PartitionSize + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return GPUAcceleratorMultiError(errors) + } + + return nil +} + +// GPUAcceleratorMultiError is an error wrapping multiple validation errors +// returned by GPUAccelerator.ValidateAll() if the designated constraints +// aren't met. +type GPUAcceleratorMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GPUAcceleratorMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GPUAcceleratorMultiError) AllErrors() []error { return m } + +// GPUAcceleratorValidationError is the validation error returned by +// GPUAccelerator.Validate if the designated constraints aren't met. +type GPUAcceleratorValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GPUAcceleratorValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GPUAcceleratorValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GPUAcceleratorValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GPUAcceleratorValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GPUAcceleratorValidationError) ErrorName() string { return "GPUAcceleratorValidationError" } + +// Error satisfies the builtin error interface +func (e GPUAcceleratorValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGPUAccelerator.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GPUAcceleratorValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GPUAcceleratorValidationError{} + +// Validate checks the field values on SharedMemory with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *SharedMemory) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on SharedMemory with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in SharedMemoryMultiError, or +// nil if none found. +func (m *SharedMemory) ValidateAll() error { + return m.validate(true) +} + +func (m *SharedMemory) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for MountPath + + // no validation rules for MountName + + // no validation rules for SizeLimit + + if len(errors) > 0 { + return SharedMemoryMultiError(errors) + } + + return nil +} + +// SharedMemoryMultiError is an error wrapping multiple validation errors +// returned by SharedMemory.ValidateAll() if the designated constraints aren't met. +type SharedMemoryMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SharedMemoryMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SharedMemoryMultiError) AllErrors() []error { return m } + +// SharedMemoryValidationError is the validation error returned by +// SharedMemory.Validate if the designated constraints aren't met. +type SharedMemoryValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SharedMemoryValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SharedMemoryValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SharedMemoryValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SharedMemoryValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SharedMemoryValidationError) ErrorName() string { return "SharedMemoryValidationError" } + +// Error satisfies the builtin error interface +func (e SharedMemoryValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSharedMemory.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SharedMemoryValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SharedMemoryValidationError{} + +// Validate checks the field values on ExtendedResources with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *ExtendedResources) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ExtendedResources with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ExtendedResourcesMultiError, or nil if none found. +func (m *ExtendedResources) ValidateAll() error { + return m.validate(true) +} + +func (m *ExtendedResources) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetGpuAccelerator()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ExtendedResourcesValidationError{ + field: "GpuAccelerator", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ExtendedResourcesValidationError{ + field: "GpuAccelerator", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetGpuAccelerator()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ExtendedResourcesValidationError{ + field: "GpuAccelerator", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetSharedMemory()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ExtendedResourcesValidationError{ + field: "SharedMemory", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ExtendedResourcesValidationError{ + field: "SharedMemory", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSharedMemory()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ExtendedResourcesValidationError{ + field: "SharedMemory", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ExtendedResourcesMultiError(errors) + } + + return nil +} + +// ExtendedResourcesMultiError is an error wrapping multiple validation errors +// returned by ExtendedResources.ValidateAll() if the designated constraints +// aren't met. +type ExtendedResourcesMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ExtendedResourcesMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ExtendedResourcesMultiError) AllErrors() []error { return m } + +// ExtendedResourcesValidationError is the validation error returned by +// ExtendedResources.Validate if the designated constraints aren't met. +type ExtendedResourcesValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ExtendedResourcesValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ExtendedResourcesValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ExtendedResourcesValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ExtendedResourcesValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ExtendedResourcesValidationError) ErrorName() string { + return "ExtendedResourcesValidationError" +} + +// Error satisfies the builtin error interface +func (e ExtendedResourcesValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sExtendedResources.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ExtendedResourcesValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ExtendedResourcesValidationError{} + +// Validate checks the field values on RuntimeMetadata with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *RuntimeMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on RuntimeMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// RuntimeMetadataMultiError, or nil if none found. +func (m *RuntimeMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *RuntimeMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Type + + // no validation rules for Version + + // no validation rules for Flavor + + if len(errors) > 0 { + return RuntimeMetadataMultiError(errors) + } + + return nil +} + +// RuntimeMetadataMultiError is an error wrapping multiple validation errors +// returned by RuntimeMetadata.ValidateAll() if the designated constraints +// aren't met. +type RuntimeMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m RuntimeMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m RuntimeMetadataMultiError) AllErrors() []error { return m } + +// RuntimeMetadataValidationError is the validation error returned by +// RuntimeMetadata.Validate if the designated constraints aren't met. +type RuntimeMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e RuntimeMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e RuntimeMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e RuntimeMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e RuntimeMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e RuntimeMetadataValidationError) ErrorName() string { return "RuntimeMetadataValidationError" } + +// Error satisfies the builtin error interface +func (e RuntimeMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sRuntimeMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = RuntimeMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = RuntimeMetadataValidationError{} + +// Validate checks the field values on TaskMetadata with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TaskMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskMetadata with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TaskMetadataMultiError, or +// nil if none found. +func (m *TaskMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Discoverable + + if all { + switch v := interface{}(m.GetRuntime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskMetadataValidationError{ + field: "Runtime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskMetadataValidationError{ + field: "Runtime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRuntime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskMetadataValidationError{ + field: "Runtime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetTimeout()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskMetadataValidationError{ + field: "Timeout", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskMetadataValidationError{ + field: "Timeout", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTimeout()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskMetadataValidationError{ + field: "Timeout", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetRetries()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskMetadataValidationError{ + field: "Retries", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskMetadataValidationError{ + field: "Retries", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRetries()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskMetadataValidationError{ + field: "Retries", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for DiscoveryVersion + + // no validation rules for DeprecatedErrorMessage + + // no validation rules for CacheSerializable + + // no validation rules for Tags + + // no validation rules for PodTemplateName + + // no validation rules for IsEager + + if all { + switch v := interface{}(m.GetGeneratesDeck()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskMetadataValidationError{ + field: "GeneratesDeck", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskMetadataValidationError{ + field: "GeneratesDeck", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetGeneratesDeck()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskMetadataValidationError{ + field: "GeneratesDeck", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskMetadataValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskMetadataValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskMetadataValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Debuggable + + for idx, item := range m.GetLogLinks() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskMetadataValidationError{ + field: fmt.Sprintf("LogLinks[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskMetadataValidationError{ + field: fmt.Sprintf("LogLinks[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskMetadataValidationError{ + field: fmt.Sprintf("LogLinks[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + switch v := m.InterruptibleValue.(type) { + case *TaskMetadata_Interruptible: + if v == nil { + err := TaskMetadataValidationError{ + field: "InterruptibleValue", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for Interruptible + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return TaskMetadataMultiError(errors) + } + + return nil +} + +// TaskMetadataMultiError is an error wrapping multiple validation errors +// returned by TaskMetadata.ValidateAll() if the designated constraints aren't met. +type TaskMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskMetadataMultiError) AllErrors() []error { return m } + +// TaskMetadataValidationError is the validation error returned by +// TaskMetadata.Validate if the designated constraints aren't met. +type TaskMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskMetadataValidationError) ErrorName() string { return "TaskMetadataValidationError" } + +// Error satisfies the builtin error interface +func (e TaskMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskMetadataValidationError{} + +// Validate checks the field values on TaskTemplate with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TaskTemplate) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskTemplate with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TaskTemplateMultiError, or +// nil if none found. +func (m *TaskTemplate) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskTemplate) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskTemplateValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskTemplateValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskTemplateValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Type + + if all { + switch v := interface{}(m.GetMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskTemplateValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskTemplateValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskTemplateValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetInterface()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskTemplateValidationError{ + field: "Interface", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskTemplateValidationError{ + field: "Interface", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetInterface()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskTemplateValidationError{ + field: "Interface", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetCustom()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskTemplateValidationError{ + field: "Custom", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskTemplateValidationError{ + field: "Custom", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCustom()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskTemplateValidationError{ + field: "Custom", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for TaskTypeVersion + + if all { + switch v := interface{}(m.GetSecurityContext()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskTemplateValidationError{ + field: "SecurityContext", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskTemplateValidationError{ + field: "SecurityContext", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSecurityContext()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskTemplateValidationError{ + field: "SecurityContext", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetExtendedResources()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskTemplateValidationError{ + field: "ExtendedResources", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskTemplateValidationError{ + field: "ExtendedResources", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetExtendedResources()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskTemplateValidationError{ + field: "ExtendedResources", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Config + + switch v := m.Target.(type) { + case *TaskTemplate_Container: + if v == nil { + err := TaskTemplateValidationError{ + field: "Target", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetContainer()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskTemplateValidationError{ + field: "Container", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskTemplateValidationError{ + field: "Container", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetContainer()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskTemplateValidationError{ + field: "Container", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *TaskTemplate_K8SPod: + if v == nil { + err := TaskTemplateValidationError{ + field: "Target", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetK8SPod()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskTemplateValidationError{ + field: "K8SPod", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskTemplateValidationError{ + field: "K8SPod", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetK8SPod()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskTemplateValidationError{ + field: "K8SPod", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *TaskTemplate_Sql: + if v == nil { + err := TaskTemplateValidationError{ + field: "Target", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetSql()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskTemplateValidationError{ + field: "Sql", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskTemplateValidationError{ + field: "Sql", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSql()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskTemplateValidationError{ + field: "Sql", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return TaskTemplateMultiError(errors) + } + + return nil +} + +// TaskTemplateMultiError is an error wrapping multiple validation errors +// returned by TaskTemplate.ValidateAll() if the designated constraints aren't met. +type TaskTemplateMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskTemplateMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskTemplateMultiError) AllErrors() []error { return m } + +// TaskTemplateValidationError is the validation error returned by +// TaskTemplate.Validate if the designated constraints aren't met. +type TaskTemplateValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskTemplateValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskTemplateValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskTemplateValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskTemplateValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskTemplateValidationError) ErrorName() string { return "TaskTemplateValidationError" } + +// Error satisfies the builtin error interface +func (e TaskTemplateValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskTemplate.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskTemplateValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskTemplateValidationError{} + +// Validate checks the field values on ContainerPort with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ContainerPort) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ContainerPort with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ContainerPortMultiError, or +// nil if none found. +func (m *ContainerPort) ValidateAll() error { + return m.validate(true) +} + +func (m *ContainerPort) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ContainerPort + + // no validation rules for Name + + if len(errors) > 0 { + return ContainerPortMultiError(errors) + } + + return nil +} + +// ContainerPortMultiError is an error wrapping multiple validation errors +// returned by ContainerPort.ValidateAll() if the designated constraints +// aren't met. +type ContainerPortMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ContainerPortMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ContainerPortMultiError) AllErrors() []error { return m } + +// ContainerPortValidationError is the validation error returned by +// ContainerPort.Validate if the designated constraints aren't met. +type ContainerPortValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ContainerPortValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ContainerPortValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ContainerPortValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ContainerPortValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ContainerPortValidationError) ErrorName() string { return "ContainerPortValidationError" } + +// Error satisfies the builtin error interface +func (e ContainerPortValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sContainerPort.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ContainerPortValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ContainerPortValidationError{} + +// Validate checks the field values on Container with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Container) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Container with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ContainerMultiError, or nil +// if none found. +func (m *Container) ValidateAll() error { + return m.validate(true) +} + +func (m *Container) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Image + + if all { + switch v := interface{}(m.GetResources()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ContainerValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ContainerValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetResources()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ContainerValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetEnv() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ContainerValidationError{ + field: fmt.Sprintf("Env[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ContainerValidationError{ + field: fmt.Sprintf("Env[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ContainerValidationError{ + field: fmt.Sprintf("Env[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + for idx, item := range m.GetConfig() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ContainerValidationError{ + field: fmt.Sprintf("Config[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ContainerValidationError{ + field: fmt.Sprintf("Config[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ContainerValidationError{ + field: fmt.Sprintf("Config[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + for idx, item := range m.GetPorts() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ContainerValidationError{ + field: fmt.Sprintf("Ports[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ContainerValidationError{ + field: fmt.Sprintf("Ports[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ContainerValidationError{ + field: fmt.Sprintf("Ports[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if all { + switch v := interface{}(m.GetDataConfig()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ContainerValidationError{ + field: "DataConfig", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ContainerValidationError{ + field: "DataConfig", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDataConfig()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ContainerValidationError{ + field: "DataConfig", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Architecture + + if len(errors) > 0 { + return ContainerMultiError(errors) + } + + return nil +} + +// ContainerMultiError is an error wrapping multiple validation errors returned +// by Container.ValidateAll() if the designated constraints aren't met. +type ContainerMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ContainerMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ContainerMultiError) AllErrors() []error { return m } + +// ContainerValidationError is the validation error returned by +// Container.Validate if the designated constraints aren't met. +type ContainerValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ContainerValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ContainerValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ContainerValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ContainerValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ContainerValidationError) ErrorName() string { return "ContainerValidationError" } + +// Error satisfies the builtin error interface +func (e ContainerValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sContainer.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ContainerValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ContainerValidationError{} + +// Validate checks the field values on IOStrategy with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *IOStrategy) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on IOStrategy with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in IOStrategyMultiError, or +// nil if none found. +func (m *IOStrategy) ValidateAll() error { + return m.validate(true) +} + +func (m *IOStrategy) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for DownloadMode + + // no validation rules for UploadMode + + if len(errors) > 0 { + return IOStrategyMultiError(errors) + } + + return nil +} + +// IOStrategyMultiError is an error wrapping multiple validation errors +// returned by IOStrategy.ValidateAll() if the designated constraints aren't met. +type IOStrategyMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m IOStrategyMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m IOStrategyMultiError) AllErrors() []error { return m } + +// IOStrategyValidationError is the validation error returned by +// IOStrategy.Validate if the designated constraints aren't met. +type IOStrategyValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e IOStrategyValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e IOStrategyValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e IOStrategyValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e IOStrategyValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e IOStrategyValidationError) ErrorName() string { return "IOStrategyValidationError" } + +// Error satisfies the builtin error interface +func (e IOStrategyValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sIOStrategy.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = IOStrategyValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = IOStrategyValidationError{} + +// Validate checks the field values on DataLoadingConfig with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *DataLoadingConfig) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DataLoadingConfig with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// DataLoadingConfigMultiError, or nil if none found. +func (m *DataLoadingConfig) ValidateAll() error { + return m.validate(true) +} + +func (m *DataLoadingConfig) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Enabled + + // no validation rules for InputPath + + // no validation rules for OutputPath + + // no validation rules for Format + + if all { + switch v := interface{}(m.GetIoStrategy()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DataLoadingConfigValidationError{ + field: "IoStrategy", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DataLoadingConfigValidationError{ + field: "IoStrategy", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetIoStrategy()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DataLoadingConfigValidationError{ + field: "IoStrategy", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DataLoadingConfigMultiError(errors) + } + + return nil +} + +// DataLoadingConfigMultiError is an error wrapping multiple validation errors +// returned by DataLoadingConfig.ValidateAll() if the designated constraints +// aren't met. +type DataLoadingConfigMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DataLoadingConfigMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DataLoadingConfigMultiError) AllErrors() []error { return m } + +// DataLoadingConfigValidationError is the validation error returned by +// DataLoadingConfig.Validate if the designated constraints aren't met. +type DataLoadingConfigValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DataLoadingConfigValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DataLoadingConfigValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DataLoadingConfigValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DataLoadingConfigValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DataLoadingConfigValidationError) ErrorName() string { + return "DataLoadingConfigValidationError" +} + +// Error satisfies the builtin error interface +func (e DataLoadingConfigValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDataLoadingConfig.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DataLoadingConfigValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DataLoadingConfigValidationError{} + +// Validate checks the field values on K8SPod with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *K8SPod) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on K8SPod with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in K8SPodMultiError, or nil if none found. +func (m *K8SPod) ValidateAll() error { + return m.validate(true) +} + +func (m *K8SPod) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, K8SPodValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, K8SPodValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return K8SPodValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetPodSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, K8SPodValidationError{ + field: "PodSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, K8SPodValidationError{ + field: "PodSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetPodSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return K8SPodValidationError{ + field: "PodSpec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetDataConfig()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, K8SPodValidationError{ + field: "DataConfig", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, K8SPodValidationError{ + field: "DataConfig", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDataConfig()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return K8SPodValidationError{ + field: "DataConfig", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for PrimaryContainerName + + if len(errors) > 0 { + return K8SPodMultiError(errors) + } + + return nil +} + +// K8SPodMultiError is an error wrapping multiple validation errors returned by +// K8SPod.ValidateAll() if the designated constraints aren't met. +type K8SPodMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m K8SPodMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m K8SPodMultiError) AllErrors() []error { return m } + +// K8SPodValidationError is the validation error returned by K8SPod.Validate if +// the designated constraints aren't met. +type K8SPodValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e K8SPodValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e K8SPodValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e K8SPodValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e K8SPodValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e K8SPodValidationError) ErrorName() string { return "K8SPodValidationError" } + +// Error satisfies the builtin error interface +func (e K8SPodValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sK8SPod.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = K8SPodValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = K8SPodValidationError{} + +// Validate checks the field values on K8SObjectMetadata with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *K8SObjectMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on K8SObjectMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// K8SObjectMetadataMultiError, or nil if none found. +func (m *K8SObjectMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *K8SObjectMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Labels + + // no validation rules for Annotations + + if len(errors) > 0 { + return K8SObjectMetadataMultiError(errors) + } + + return nil +} + +// K8SObjectMetadataMultiError is an error wrapping multiple validation errors +// returned by K8SObjectMetadata.ValidateAll() if the designated constraints +// aren't met. +type K8SObjectMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m K8SObjectMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m K8SObjectMetadataMultiError) AllErrors() []error { return m } + +// K8SObjectMetadataValidationError is the validation error returned by +// K8SObjectMetadata.Validate if the designated constraints aren't met. +type K8SObjectMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e K8SObjectMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e K8SObjectMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e K8SObjectMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e K8SObjectMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e K8SObjectMetadataValidationError) ErrorName() string { + return "K8SObjectMetadataValidationError" +} + +// Error satisfies the builtin error interface +func (e K8SObjectMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sK8SObjectMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = K8SObjectMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = K8SObjectMetadataValidationError{} + +// Validate checks the field values on Sql with the rules defined in the proto +// definition for this message. If any rules are violated, the first error +// encountered is returned, or nil if there are no violations. +func (m *Sql) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Sql with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in SqlMultiError, or nil if none found. +func (m *Sql) ValidateAll() error { + return m.validate(true) +} + +func (m *Sql) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Statement + + // no validation rules for Dialect + + if len(errors) > 0 { + return SqlMultiError(errors) + } + + return nil +} + +// SqlMultiError is an error wrapping multiple validation errors returned by +// Sql.ValidateAll() if the designated constraints aren't met. +type SqlMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SqlMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SqlMultiError) AllErrors() []error { return m } + +// SqlValidationError is the validation error returned by Sql.Validate if the +// designated constraints aren't met. +type SqlValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SqlValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SqlValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SqlValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SqlValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SqlValidationError) ErrorName() string { return "SqlValidationError" } + +// Error satisfies the builtin error interface +func (e SqlValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSql.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SqlValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SqlValidationError{} + +// Validate checks the field values on Resources_ResourceEntry with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *Resources_ResourceEntry) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Resources_ResourceEntry with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// Resources_ResourceEntryMultiError, or nil if none found. +func (m *Resources_ResourceEntry) ValidateAll() error { + return m.validate(true) +} + +func (m *Resources_ResourceEntry) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + // no validation rules for Value + + if len(errors) > 0 { + return Resources_ResourceEntryMultiError(errors) + } + + return nil +} + +// Resources_ResourceEntryMultiError is an error wrapping multiple validation +// errors returned by Resources_ResourceEntry.ValidateAll() if the designated +// constraints aren't met. +type Resources_ResourceEntryMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m Resources_ResourceEntryMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m Resources_ResourceEntryMultiError) AllErrors() []error { return m } + +// Resources_ResourceEntryValidationError is the validation error returned by +// Resources_ResourceEntry.Validate if the designated constraints aren't met. +type Resources_ResourceEntryValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e Resources_ResourceEntryValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e Resources_ResourceEntryValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e Resources_ResourceEntryValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e Resources_ResourceEntryValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e Resources_ResourceEntryValidationError) ErrorName() string { + return "Resources_ResourceEntryValidationError" +} + +// Error satisfies the builtin error interface +func (e Resources_ResourceEntryValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sResources_ResourceEntry.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = Resources_ResourceEntryValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = Resources_ResourceEntryValidationError{} diff --git a/gen/go/flyteidl2/core/types.pb.go b/gen/go/flyteidl2/core/types.pb.go new file mode 100644 index 0000000000..3d39605d9c --- /dev/null +++ b/gen/go/flyteidl2/core/types.pb.go @@ -0,0 +1,1560 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/core/types.proto + +package core + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + structpb "google.golang.org/protobuf/types/known/structpb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Define a set of simple types. +type SimpleType int32 + +const ( + SimpleType_NONE SimpleType = 0 + SimpleType_INTEGER SimpleType = 1 + SimpleType_FLOAT SimpleType = 2 + SimpleType_STRING SimpleType = 3 + SimpleType_BOOLEAN SimpleType = 4 + SimpleType_DATETIME SimpleType = 5 + SimpleType_DURATION SimpleType = 6 + SimpleType_BINARY SimpleType = 7 + SimpleType_ERROR SimpleType = 8 + SimpleType_STRUCT SimpleType = 9 +) + +// Enum value maps for SimpleType. +var ( + SimpleType_name = map[int32]string{ + 0: "NONE", + 1: "INTEGER", + 2: "FLOAT", + 3: "STRING", + 4: "BOOLEAN", + 5: "DATETIME", + 6: "DURATION", + 7: "BINARY", + 8: "ERROR", + 9: "STRUCT", + } + SimpleType_value = map[string]int32{ + "NONE": 0, + "INTEGER": 1, + "FLOAT": 2, + "STRING": 3, + "BOOLEAN": 4, + "DATETIME": 5, + "DURATION": 6, + "BINARY": 7, + "ERROR": 8, + "STRUCT": 9, + } +) + +func (x SimpleType) Enum() *SimpleType { + p := new(SimpleType) + *p = x + return p +} + +func (x SimpleType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (SimpleType) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_types_proto_enumTypes[0].Descriptor() +} + +func (SimpleType) Type() protoreflect.EnumType { + return &file_flyteidl2_core_types_proto_enumTypes[0] +} + +func (x SimpleType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use SimpleType.Descriptor instead. +func (SimpleType) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_types_proto_rawDescGZIP(), []int{0} +} + +type SchemaType_SchemaColumn_SchemaColumnType int32 + +const ( + SchemaType_SchemaColumn_INTEGER SchemaType_SchemaColumn_SchemaColumnType = 0 + SchemaType_SchemaColumn_FLOAT SchemaType_SchemaColumn_SchemaColumnType = 1 + SchemaType_SchemaColumn_STRING SchemaType_SchemaColumn_SchemaColumnType = 2 + SchemaType_SchemaColumn_BOOLEAN SchemaType_SchemaColumn_SchemaColumnType = 3 + SchemaType_SchemaColumn_DATETIME SchemaType_SchemaColumn_SchemaColumnType = 4 + SchemaType_SchemaColumn_DURATION SchemaType_SchemaColumn_SchemaColumnType = 5 +) + +// Enum value maps for SchemaType_SchemaColumn_SchemaColumnType. +var ( + SchemaType_SchemaColumn_SchemaColumnType_name = map[int32]string{ + 0: "INTEGER", + 1: "FLOAT", + 2: "STRING", + 3: "BOOLEAN", + 4: "DATETIME", + 5: "DURATION", + } + SchemaType_SchemaColumn_SchemaColumnType_value = map[string]int32{ + "INTEGER": 0, + "FLOAT": 1, + "STRING": 2, + "BOOLEAN": 3, + "DATETIME": 4, + "DURATION": 5, + } +) + +func (x SchemaType_SchemaColumn_SchemaColumnType) Enum() *SchemaType_SchemaColumn_SchemaColumnType { + p := new(SchemaType_SchemaColumn_SchemaColumnType) + *p = x + return p +} + +func (x SchemaType_SchemaColumn_SchemaColumnType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (SchemaType_SchemaColumn_SchemaColumnType) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_types_proto_enumTypes[1].Descriptor() +} + +func (SchemaType_SchemaColumn_SchemaColumnType) Type() protoreflect.EnumType { + return &file_flyteidl2_core_types_proto_enumTypes[1] +} + +func (x SchemaType_SchemaColumn_SchemaColumnType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use SchemaType_SchemaColumn_SchemaColumnType.Descriptor instead. +func (SchemaType_SchemaColumn_SchemaColumnType) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_types_proto_rawDescGZIP(), []int{0, 0, 0} +} + +type BlobType_BlobDimensionality int32 + +const ( + BlobType_SINGLE BlobType_BlobDimensionality = 0 + BlobType_MULTIPART BlobType_BlobDimensionality = 1 +) + +// Enum value maps for BlobType_BlobDimensionality. +var ( + BlobType_BlobDimensionality_name = map[int32]string{ + 0: "SINGLE", + 1: "MULTIPART", + } + BlobType_BlobDimensionality_value = map[string]int32{ + "SINGLE": 0, + "MULTIPART": 1, + } +) + +func (x BlobType_BlobDimensionality) Enum() *BlobType_BlobDimensionality { + p := new(BlobType_BlobDimensionality) + *p = x + return p +} + +func (x BlobType_BlobDimensionality) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (BlobType_BlobDimensionality) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_core_types_proto_enumTypes[2].Descriptor() +} + +func (BlobType_BlobDimensionality) Type() protoreflect.EnumType { + return &file_flyteidl2_core_types_proto_enumTypes[2] +} + +func (x BlobType_BlobDimensionality) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use BlobType_BlobDimensionality.Descriptor instead. +func (BlobType_BlobDimensionality) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_core_types_proto_rawDescGZIP(), []int{2, 0} +} + +// Defines schema columns and types to strongly type-validate schemas interoperability. +type SchemaType struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // A list of ordered columns this schema comprises of. + Columns []*SchemaType_SchemaColumn `protobuf:"bytes,3,rep,name=columns,proto3" json:"columns,omitempty"` +} + +func (x *SchemaType) Reset() { + *x = SchemaType{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_types_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SchemaType) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SchemaType) ProtoMessage() {} + +func (x *SchemaType) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_types_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SchemaType.ProtoReflect.Descriptor instead. +func (*SchemaType) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_types_proto_rawDescGZIP(), []int{0} +} + +func (x *SchemaType) GetColumns() []*SchemaType_SchemaColumn { + if x != nil { + return x.Columns + } + return nil +} + +type StructuredDatasetType struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // A list of ordered columns this schema comprises of. + Columns []*StructuredDatasetType_DatasetColumn `protobuf:"bytes,1,rep,name=columns,proto3" json:"columns,omitempty"` + // This is the storage format, the format of the bits at rest + // parquet, feather, csv, etc. + // For two types to be compatible, the format will need to be an exact match. + Format string `protobuf:"bytes,2,opt,name=format,proto3" json:"format,omitempty"` + // This is a string representing the type that the bytes in external_schema_bytes are formatted in. + // This is an optional field that will not be used for type checking. + ExternalSchemaType string `protobuf:"bytes,3,opt,name=external_schema_type,json=externalSchemaType,proto3" json:"external_schema_type,omitempty"` + // The serialized bytes of a third-party schema library like Arrow. + // This is an optional field that will not be used for type checking. + ExternalSchemaBytes []byte `protobuf:"bytes,4,opt,name=external_schema_bytes,json=externalSchemaBytes,proto3" json:"external_schema_bytes,omitempty"` +} + +func (x *StructuredDatasetType) Reset() { + *x = StructuredDatasetType{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_types_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *StructuredDatasetType) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StructuredDatasetType) ProtoMessage() {} + +func (x *StructuredDatasetType) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_types_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use StructuredDatasetType.ProtoReflect.Descriptor instead. +func (*StructuredDatasetType) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_types_proto_rawDescGZIP(), []int{1} +} + +func (x *StructuredDatasetType) GetColumns() []*StructuredDatasetType_DatasetColumn { + if x != nil { + return x.Columns + } + return nil +} + +func (x *StructuredDatasetType) GetFormat() string { + if x != nil { + return x.Format + } + return "" +} + +func (x *StructuredDatasetType) GetExternalSchemaType() string { + if x != nil { + return x.ExternalSchemaType + } + return "" +} + +func (x *StructuredDatasetType) GetExternalSchemaBytes() []byte { + if x != nil { + return x.ExternalSchemaBytes + } + return nil +} + +// Defines type behavior for blob objects +type BlobType struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Format can be a free form string understood by SDK/UI etc like + // csv, parquet etc + Format string `protobuf:"bytes,1,opt,name=format,proto3" json:"format,omitempty"` + Dimensionality BlobType_BlobDimensionality `protobuf:"varint,2,opt,name=dimensionality,proto3,enum=flyteidl2.core.BlobType_BlobDimensionality" json:"dimensionality,omitempty"` +} + +func (x *BlobType) Reset() { + *x = BlobType{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_types_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BlobType) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BlobType) ProtoMessage() {} + +func (x *BlobType) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_types_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BlobType.ProtoReflect.Descriptor instead. +func (*BlobType) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_types_proto_rawDescGZIP(), []int{2} +} + +func (x *BlobType) GetFormat() string { + if x != nil { + return x.Format + } + return "" +} + +func (x *BlobType) GetDimensionality() BlobType_BlobDimensionality { + if x != nil { + return x.Dimensionality + } + return BlobType_SINGLE +} + +// Enables declaring enum types, with predefined string values +// For len(values) > 0, the first value in the ordered list is regarded as the default value. If you wish +// To provide no defaults, make the first value as undefined. +type EnumType struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Predefined set of enum values. + Values []string `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"` +} + +func (x *EnumType) Reset() { + *x = EnumType{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_types_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EnumType) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EnumType) ProtoMessage() {} + +func (x *EnumType) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_types_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EnumType.ProtoReflect.Descriptor instead. +func (*EnumType) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_types_proto_rawDescGZIP(), []int{3} +} + +func (x *EnumType) GetValues() []string { + if x != nil { + return x.Values + } + return nil +} + +// Defines a tagged union type, also known as a variant (and formally as the sum type). +// +// A sum type S is defined by a sequence of types (A, B, C, ...), each tagged by a string tag +// A value of type S is constructed from a value of any of the variant types. The specific choice of type is recorded by +// storing the varaint's tag with the literal value and can be examined in runtime. +// +// Type S is typically written as +// S := Apple A | Banana B | Cantaloupe C | ... +// +// Notably, a nullable (optional) type is a sum type between some type X and the singleton type representing a null-value: +// Optional X := X | Null +// +// See also: https://en.wikipedia.org/wiki/Tagged_union +type UnionType struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Predefined set of variants in union. + Variants []*LiteralType `protobuf:"bytes,1,rep,name=variants,proto3" json:"variants,omitempty"` +} + +func (x *UnionType) Reset() { + *x = UnionType{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_types_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UnionType) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UnionType) ProtoMessage() {} + +func (x *UnionType) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_types_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UnionType.ProtoReflect.Descriptor instead. +func (*UnionType) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_types_proto_rawDescGZIP(), []int{4} +} + +func (x *UnionType) GetVariants() []*LiteralType { + if x != nil { + return x.Variants + } + return nil +} + +// Hints to improve type matching +// e.g. allows distinguishing output from custom type transformers +// even if the underlying IDL serialization matches. +type TypeStructure struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Must exactly match for types to be castable + Tag string `protobuf:"bytes,1,opt,name=tag,proto3" json:"tag,omitempty"` + // dataclass_type only exists for dataclasses. + // This is used to resolve the type of the fields of dataclass + // The key is the field name, and the value is the literal type of the field + // e.g. For dataclass Foo, with fields a, and a is a string + // Foo.a will be resolved as a literal type of string from dataclass_type + DataclassType map[string]*LiteralType `protobuf:"bytes,2,rep,name=dataclass_type,json=dataclassType,proto3" json:"dataclass_type,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *TypeStructure) Reset() { + *x = TypeStructure{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_types_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TypeStructure) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TypeStructure) ProtoMessage() {} + +func (x *TypeStructure) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_types_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TypeStructure.ProtoReflect.Descriptor instead. +func (*TypeStructure) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_types_proto_rawDescGZIP(), []int{5} +} + +func (x *TypeStructure) GetTag() string { + if x != nil { + return x.Tag + } + return "" +} + +func (x *TypeStructure) GetDataclassType() map[string]*LiteralType { + if x != nil { + return x.DataclassType + } + return nil +} + +// TypeAnnotation encapsulates registration time information about a type. This can be used for various control-plane operations. TypeAnnotation will not be available at runtime when a task runs. +type TypeAnnotation struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // A arbitrary JSON payload to describe a type. + Annotations *structpb.Struct `protobuf:"bytes,1,opt,name=annotations,proto3" json:"annotations,omitempty"` +} + +func (x *TypeAnnotation) Reset() { + *x = TypeAnnotation{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_types_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TypeAnnotation) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TypeAnnotation) ProtoMessage() {} + +func (x *TypeAnnotation) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_types_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TypeAnnotation.ProtoReflect.Descriptor instead. +func (*TypeAnnotation) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_types_proto_rawDescGZIP(), []int{6} +} + +func (x *TypeAnnotation) GetAnnotations() *structpb.Struct { + if x != nil { + return x.Annotations + } + return nil +} + +// Defines a strong type to allow type checking between interfaces. +type LiteralType struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Type: + // + // *LiteralType_Simple + // *LiteralType_Schema + // *LiteralType_CollectionType + // *LiteralType_MapValueType + // *LiteralType_Blob + // *LiteralType_EnumType + // *LiteralType_StructuredDatasetType + // *LiteralType_UnionType + Type isLiteralType_Type `protobuf_oneof:"type"` + // This field contains type metadata that is descriptive of the type, but is NOT considered in type-checking. This might be used by + // consumers to identify special behavior or display extended information for the type. + Metadata *structpb.Struct `protobuf:"bytes,6,opt,name=metadata,proto3" json:"metadata,omitempty"` + // This field contains arbitrary data that might have special semantic + // meaning for the client but does not effect internal flyte behavior. + Annotation *TypeAnnotation `protobuf:"bytes,9,opt,name=annotation,proto3" json:"annotation,omitempty"` + // Hints to improve type matching. + Structure *TypeStructure `protobuf:"bytes,11,opt,name=structure,proto3" json:"structure,omitempty"` +} + +func (x *LiteralType) Reset() { + *x = LiteralType{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_types_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LiteralType) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LiteralType) ProtoMessage() {} + +func (x *LiteralType) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_types_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LiteralType.ProtoReflect.Descriptor instead. +func (*LiteralType) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_types_proto_rawDescGZIP(), []int{7} +} + +func (m *LiteralType) GetType() isLiteralType_Type { + if m != nil { + return m.Type + } + return nil +} + +func (x *LiteralType) GetSimple() SimpleType { + if x, ok := x.GetType().(*LiteralType_Simple); ok { + return x.Simple + } + return SimpleType_NONE +} + +func (x *LiteralType) GetSchema() *SchemaType { + if x, ok := x.GetType().(*LiteralType_Schema); ok { + return x.Schema + } + return nil +} + +func (x *LiteralType) GetCollectionType() *LiteralType { + if x, ok := x.GetType().(*LiteralType_CollectionType); ok { + return x.CollectionType + } + return nil +} + +func (x *LiteralType) GetMapValueType() *LiteralType { + if x, ok := x.GetType().(*LiteralType_MapValueType); ok { + return x.MapValueType + } + return nil +} + +func (x *LiteralType) GetBlob() *BlobType { + if x, ok := x.GetType().(*LiteralType_Blob); ok { + return x.Blob + } + return nil +} + +func (x *LiteralType) GetEnumType() *EnumType { + if x, ok := x.GetType().(*LiteralType_EnumType); ok { + return x.EnumType + } + return nil +} + +func (x *LiteralType) GetStructuredDatasetType() *StructuredDatasetType { + if x, ok := x.GetType().(*LiteralType_StructuredDatasetType); ok { + return x.StructuredDatasetType + } + return nil +} + +func (x *LiteralType) GetUnionType() *UnionType { + if x, ok := x.GetType().(*LiteralType_UnionType); ok { + return x.UnionType + } + return nil +} + +func (x *LiteralType) GetMetadata() *structpb.Struct { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *LiteralType) GetAnnotation() *TypeAnnotation { + if x != nil { + return x.Annotation + } + return nil +} + +func (x *LiteralType) GetStructure() *TypeStructure { + if x != nil { + return x.Structure + } + return nil +} + +type isLiteralType_Type interface { + isLiteralType_Type() +} + +type LiteralType_Simple struct { + // A simple type that can be compared one-to-one with another. + Simple SimpleType `protobuf:"varint,1,opt,name=simple,proto3,enum=flyteidl2.core.SimpleType,oneof"` +} + +type LiteralType_Schema struct { + // A complex type that requires matching of inner fields. + Schema *SchemaType `protobuf:"bytes,2,opt,name=schema,proto3,oneof"` +} + +type LiteralType_CollectionType struct { + // Defines the type of the value of a collection. Only homogeneous collections are allowed. + CollectionType *LiteralType `protobuf:"bytes,3,opt,name=collection_type,json=collectionType,proto3,oneof"` +} + +type LiteralType_MapValueType struct { + // Defines the type of the value of a map type. The type of the key is always a string. + MapValueType *LiteralType `protobuf:"bytes,4,opt,name=map_value_type,json=mapValueType,proto3,oneof"` +} + +type LiteralType_Blob struct { + // A blob might have specialized implementation details depending on associated metadata. + Blob *BlobType `protobuf:"bytes,5,opt,name=blob,proto3,oneof"` +} + +type LiteralType_EnumType struct { + // Defines an enum with pre-defined string values. + EnumType *EnumType `protobuf:"bytes,7,opt,name=enum_type,json=enumType,proto3,oneof"` +} + +type LiteralType_StructuredDatasetType struct { + // Generalized schema support + StructuredDatasetType *StructuredDatasetType `protobuf:"bytes,8,opt,name=structured_dataset_type,json=structuredDatasetType,proto3,oneof"` +} + +type LiteralType_UnionType struct { + // Defines an union type with pre-defined LiteralTypes. + UnionType *UnionType `protobuf:"bytes,10,opt,name=union_type,json=unionType,proto3,oneof"` +} + +func (*LiteralType_Simple) isLiteralType_Type() {} + +func (*LiteralType_Schema) isLiteralType_Type() {} + +func (*LiteralType_CollectionType) isLiteralType_Type() {} + +func (*LiteralType_MapValueType) isLiteralType_Type() {} + +func (*LiteralType_Blob) isLiteralType_Type() {} + +func (*LiteralType_EnumType) isLiteralType_Type() {} + +func (*LiteralType_StructuredDatasetType) isLiteralType_Type() {} + +func (*LiteralType_UnionType) isLiteralType_Type() {} + +// A reference to an output produced by a node. The type can be retrieved -and validated- from +// the underlying interface of the node. +type OutputReference struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Node id must exist at the graph layer. + NodeId string `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"` + // Variable name must refer to an output variable for the node. + Var string `protobuf:"bytes,2,opt,name=var,proto3" json:"var,omitempty"` + AttrPath []*PromiseAttribute `protobuf:"bytes,3,rep,name=attr_path,json=attrPath,proto3" json:"attr_path,omitempty"` +} + +func (x *OutputReference) Reset() { + *x = OutputReference{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_types_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OutputReference) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OutputReference) ProtoMessage() {} + +func (x *OutputReference) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_types_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OutputReference.ProtoReflect.Descriptor instead. +func (*OutputReference) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_types_proto_rawDescGZIP(), []int{8} +} + +func (x *OutputReference) GetNodeId() string { + if x != nil { + return x.NodeId + } + return "" +} + +func (x *OutputReference) GetVar() string { + if x != nil { + return x.Var + } + return "" +} + +func (x *OutputReference) GetAttrPath() []*PromiseAttribute { + if x != nil { + return x.AttrPath + } + return nil +} + +type PromiseAttribute struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Value: + // + // *PromiseAttribute_StringValue + // *PromiseAttribute_IntValue + Value isPromiseAttribute_Value `protobuf_oneof:"value"` +} + +func (x *PromiseAttribute) Reset() { + *x = PromiseAttribute{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_types_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PromiseAttribute) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PromiseAttribute) ProtoMessage() {} + +func (x *PromiseAttribute) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_types_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PromiseAttribute.ProtoReflect.Descriptor instead. +func (*PromiseAttribute) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_types_proto_rawDescGZIP(), []int{9} +} + +func (m *PromiseAttribute) GetValue() isPromiseAttribute_Value { + if m != nil { + return m.Value + } + return nil +} + +func (x *PromiseAttribute) GetStringValue() string { + if x, ok := x.GetValue().(*PromiseAttribute_StringValue); ok { + return x.StringValue + } + return "" +} + +func (x *PromiseAttribute) GetIntValue() int32 { + if x, ok := x.GetValue().(*PromiseAttribute_IntValue); ok { + return x.IntValue + } + return 0 +} + +type isPromiseAttribute_Value interface { + isPromiseAttribute_Value() +} + +type PromiseAttribute_StringValue struct { + StringValue string `protobuf:"bytes,1,opt,name=string_value,json=stringValue,proto3,oneof"` +} + +type PromiseAttribute_IntValue struct { + IntValue int32 `protobuf:"varint,2,opt,name=int_value,json=intValue,proto3,oneof"` +} + +func (*PromiseAttribute_StringValue) isPromiseAttribute_Value() {} + +func (*PromiseAttribute_IntValue) isPromiseAttribute_Value() {} + +// Represents an error thrown from a node. +type Error struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The node id that threw the error. + FailedNodeId string `protobuf:"bytes,1,opt,name=failed_node_id,json=failedNodeId,proto3" json:"failed_node_id,omitempty"` + // Error message thrown. + Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` +} + +func (x *Error) Reset() { + *x = Error{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_types_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Error) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Error) ProtoMessage() {} + +func (x *Error) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_types_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Error.ProtoReflect.Descriptor instead. +func (*Error) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_types_proto_rawDescGZIP(), []int{10} +} + +func (x *Error) GetFailedNodeId() string { + if x != nil { + return x.FailedNodeId + } + return "" +} + +func (x *Error) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +type SchemaType_SchemaColumn struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // A unique name -within the schema type- for the column + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // The column type. This allows a limited set of types currently. + Type SchemaType_SchemaColumn_SchemaColumnType `protobuf:"varint,2,opt,name=type,proto3,enum=flyteidl2.core.SchemaType_SchemaColumn_SchemaColumnType" json:"type,omitempty"` +} + +func (x *SchemaType_SchemaColumn) Reset() { + *x = SchemaType_SchemaColumn{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_types_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SchemaType_SchemaColumn) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SchemaType_SchemaColumn) ProtoMessage() {} + +func (x *SchemaType_SchemaColumn) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_types_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SchemaType_SchemaColumn.ProtoReflect.Descriptor instead. +func (*SchemaType_SchemaColumn) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_types_proto_rawDescGZIP(), []int{0, 0} +} + +func (x *SchemaType_SchemaColumn) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *SchemaType_SchemaColumn) GetType() SchemaType_SchemaColumn_SchemaColumnType { + if x != nil { + return x.Type + } + return SchemaType_SchemaColumn_INTEGER +} + +type StructuredDatasetType_DatasetColumn struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // A unique name within the schema type for the column. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // The column type. + LiteralType *LiteralType `protobuf:"bytes,2,opt,name=literal_type,json=literalType,proto3" json:"literal_type,omitempty"` +} + +func (x *StructuredDatasetType_DatasetColumn) Reset() { + *x = StructuredDatasetType_DatasetColumn{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_core_types_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *StructuredDatasetType_DatasetColumn) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StructuredDatasetType_DatasetColumn) ProtoMessage() {} + +func (x *StructuredDatasetType_DatasetColumn) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_core_types_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use StructuredDatasetType_DatasetColumn.ProtoReflect.Descriptor instead. +func (*StructuredDatasetType_DatasetColumn) Descriptor() ([]byte, []int) { + return file_flyteidl2_core_types_proto_rawDescGZIP(), []int{1, 0} +} + +func (x *StructuredDatasetType_DatasetColumn) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *StructuredDatasetType_DatasetColumn) GetLiteralType() *LiteralType { + if x != nil { + return x.LiteralType + } + return nil +} + +var File_flyteidl2_core_types_proto protoreflect.FileDescriptor + +var file_flyteidl2_core_types_proto_rawDesc = []byte{ + 0x0a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x1a, 0x1c, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x73, 0x74, + 0x72, 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa3, 0x02, 0x0a, 0x0a, 0x53, + 0x63, 0x68, 0x65, 0x6d, 0x61, 0x54, 0x79, 0x70, 0x65, 0x12, 0x41, 0x0a, 0x07, 0x63, 0x6f, 0x6c, + 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x63, 0x68, 0x65, + 0x6d, 0x61, 0x54, 0x79, 0x70, 0x65, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x43, 0x6f, 0x6c, + 0x75, 0x6d, 0x6e, 0x52, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x1a, 0xd1, 0x01, 0x0a, + 0x0c, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x12, 0x0a, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x12, 0x4c, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x38, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x54, 0x79, 0x70, 0x65, 0x2e, 0x53, 0x63, 0x68, 0x65, + 0x6d, 0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x43, + 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, + 0x5f, 0x0a, 0x10, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, 0x52, 0x10, 0x00, + 0x12, 0x09, 0x0a, 0x05, 0x46, 0x4c, 0x4f, 0x41, 0x54, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x53, + 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, 0x42, 0x4f, 0x4f, 0x4c, 0x45, + 0x41, 0x4e, 0x10, 0x03, 0x12, 0x0c, 0x0a, 0x08, 0x44, 0x41, 0x54, 0x45, 0x54, 0x49, 0x4d, 0x45, + 0x10, 0x04, 0x12, 0x0c, 0x0a, 0x08, 0x44, 0x55, 0x52, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x05, + 0x22, 0xc9, 0x02, 0x0a, 0x15, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x44, + 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x4d, 0x0a, 0x07, 0x63, 0x6f, + 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x74, 0x72, + 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x54, 0x79, + 0x70, 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, + 0x52, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x6f, 0x72, + 0x6d, 0x61, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, + 0x74, 0x12, 0x30, 0x0a, 0x14, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x63, + 0x68, 0x65, 0x6d, 0x61, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x12, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x32, 0x0a, 0x15, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, + 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x13, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x53, 0x63, 0x68, 0x65, + 0x6d, 0x61, 0x42, 0x79, 0x74, 0x65, 0x73, 0x1a, 0x63, 0x0a, 0x0d, 0x44, 0x61, 0x74, 0x61, 0x73, + 0x65, 0x74, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3e, 0x0a, 0x0c, + 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x52, + 0x0b, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x22, 0xa8, 0x01, 0x0a, + 0x08, 0x42, 0x6c, 0x6f, 0x62, 0x54, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x6f, 0x72, + 0x6d, 0x61, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, + 0x74, 0x12, 0x53, 0x0a, 0x0e, 0x64, 0x69, 0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x42, 0x6c, 0x6f, 0x62, 0x54, + 0x79, 0x70, 0x65, 0x2e, 0x42, 0x6c, 0x6f, 0x62, 0x44, 0x69, 0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f, + 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x0e, 0x64, 0x69, 0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f, + 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x22, 0x2f, 0x0a, 0x12, 0x42, 0x6c, 0x6f, 0x62, 0x44, 0x69, + 0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x12, 0x0a, 0x0a, 0x06, + 0x53, 0x49, 0x4e, 0x47, 0x4c, 0x45, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x4d, 0x55, 0x4c, 0x54, + 0x49, 0x50, 0x41, 0x52, 0x54, 0x10, 0x01, 0x22, 0x22, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x09, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x22, 0x44, 0x0a, 0x09, 0x55, + 0x6e, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x37, 0x0a, 0x08, 0x76, 0x61, 0x72, 0x69, + 0x61, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, + 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x52, 0x08, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74, + 0x73, 0x22, 0xd9, 0x01, 0x0a, 0x0d, 0x54, 0x79, 0x70, 0x65, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, + 0x75, 0x72, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x74, 0x61, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x74, 0x61, 0x67, 0x12, 0x57, 0x0a, 0x0e, 0x64, 0x61, 0x74, 0x61, 0x63, 0x6c, 0x61, + 0x73, 0x73, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x30, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, + 0x79, 0x70, 0x65, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x44, 0x61, 0x74, + 0x61, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x79, 0x70, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, + 0x0d, 0x64, 0x61, 0x74, 0x61, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x79, 0x70, 0x65, 0x1a, 0x5d, + 0x0a, 0x12, 0x44, 0x61, 0x74, 0x61, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x79, 0x70, 0x65, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x31, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, + 0x70, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x4b, 0x0a, + 0x0e, 0x54, 0x79, 0x70, 0x65, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x39, 0x0a, 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x0b, 0x61, + 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xc6, 0x05, 0x0a, 0x0b, 0x4c, + 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x12, 0x34, 0x0a, 0x06, 0x73, 0x69, + 0x6d, 0x70, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x69, 0x6d, 0x70, + 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x06, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, + 0x12, 0x34, 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x06, + 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x46, 0x0a, 0x0f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0e, + 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x43, + 0x0a, 0x0e, 0x6d, 0x61, 0x70, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, + 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x6d, 0x61, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x2e, 0x0a, 0x04, 0x62, 0x6c, 0x6f, 0x62, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x42, 0x6c, 0x6f, 0x62, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x04, 0x62, + 0x6c, 0x6f, 0x62, 0x12, 0x37, 0x0a, 0x09, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, + 0x48, 0x00, 0x52, 0x08, 0x65, 0x6e, 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x12, 0x5f, 0x0a, 0x17, + 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x73, + 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, + 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, + 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x15, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, + 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3a, 0x0a, + 0x0a, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x09, + 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x33, 0x0a, 0x08, 0x6d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, + 0x72, 0x75, 0x63, 0x74, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x3e, + 0x0a, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x09, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3b, + 0x0a, 0x09, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, + 0x52, 0x09, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x42, 0x06, 0x0a, 0x04, 0x74, + 0x79, 0x70, 0x65, 0x22, 0x7b, 0x0a, 0x0f, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x52, 0x65, 0x66, + 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, + 0x10, 0x0a, 0x03, 0x76, 0x61, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x76, 0x61, + 0x72, 0x12, 0x3d, 0x0a, 0x09, 0x61, 0x74, 0x74, 0x72, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x6d, 0x69, 0x73, 0x65, 0x41, 0x74, 0x74, + 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52, 0x08, 0x61, 0x74, 0x74, 0x72, 0x50, 0x61, 0x74, 0x68, + 0x22, 0x5f, 0x0a, 0x10, 0x50, 0x72, 0x6f, 0x6d, 0x69, 0x73, 0x65, 0x41, 0x74, 0x74, 0x72, 0x69, + 0x62, 0x75, 0x74, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x73, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1d, 0x0a, 0x09, 0x69, 0x6e, 0x74, + 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x08, + 0x69, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x07, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x22, 0x47, 0x0a, 0x05, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x24, 0x0a, 0x0e, 0x66, 0x61, + 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0c, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x64, + 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2a, 0x86, 0x01, 0x0a, 0x0a, 0x53, + 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x08, 0x0a, 0x04, 0x4e, 0x4f, 0x4e, + 0x45, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, 0x52, 0x10, 0x01, + 0x12, 0x09, 0x0a, 0x05, 0x46, 0x4c, 0x4f, 0x41, 0x54, 0x10, 0x02, 0x12, 0x0a, 0x0a, 0x06, 0x53, + 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x03, 0x12, 0x0b, 0x0a, 0x07, 0x42, 0x4f, 0x4f, 0x4c, 0x45, + 0x41, 0x4e, 0x10, 0x04, 0x12, 0x0c, 0x0a, 0x08, 0x44, 0x41, 0x54, 0x45, 0x54, 0x49, 0x4d, 0x45, + 0x10, 0x05, 0x12, 0x0c, 0x0a, 0x08, 0x44, 0x55, 0x52, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x06, + 0x12, 0x0a, 0x0a, 0x06, 0x42, 0x49, 0x4e, 0x41, 0x52, 0x59, 0x10, 0x07, 0x12, 0x09, 0x0a, 0x05, + 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x08, 0x12, 0x0a, 0x0a, 0x06, 0x53, 0x54, 0x52, 0x55, 0x43, + 0x54, 0x10, 0x09, 0x42, 0xaf, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x42, 0x0a, 0x54, 0x79, 0x70, 0x65, + 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, + 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0xa2, 0x02, + 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x43, 0x6f, 0x72, 0x65, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, + 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_core_types_proto_rawDescOnce sync.Once + file_flyteidl2_core_types_proto_rawDescData = file_flyteidl2_core_types_proto_rawDesc +) + +func file_flyteidl2_core_types_proto_rawDescGZIP() []byte { + file_flyteidl2_core_types_proto_rawDescOnce.Do(func() { + file_flyteidl2_core_types_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_core_types_proto_rawDescData) + }) + return file_flyteidl2_core_types_proto_rawDescData +} + +var file_flyteidl2_core_types_proto_enumTypes = make([]protoimpl.EnumInfo, 3) +var file_flyteidl2_core_types_proto_msgTypes = make([]protoimpl.MessageInfo, 14) +var file_flyteidl2_core_types_proto_goTypes = []interface{}{ + (SimpleType)(0), // 0: flyteidl2.core.SimpleType + (SchemaType_SchemaColumn_SchemaColumnType)(0), // 1: flyteidl2.core.SchemaType.SchemaColumn.SchemaColumnType + (BlobType_BlobDimensionality)(0), // 2: flyteidl2.core.BlobType.BlobDimensionality + (*SchemaType)(nil), // 3: flyteidl2.core.SchemaType + (*StructuredDatasetType)(nil), // 4: flyteidl2.core.StructuredDatasetType + (*BlobType)(nil), // 5: flyteidl2.core.BlobType + (*EnumType)(nil), // 6: flyteidl2.core.EnumType + (*UnionType)(nil), // 7: flyteidl2.core.UnionType + (*TypeStructure)(nil), // 8: flyteidl2.core.TypeStructure + (*TypeAnnotation)(nil), // 9: flyteidl2.core.TypeAnnotation + (*LiteralType)(nil), // 10: flyteidl2.core.LiteralType + (*OutputReference)(nil), // 11: flyteidl2.core.OutputReference + (*PromiseAttribute)(nil), // 12: flyteidl2.core.PromiseAttribute + (*Error)(nil), // 13: flyteidl2.core.Error + (*SchemaType_SchemaColumn)(nil), // 14: flyteidl2.core.SchemaType.SchemaColumn + (*StructuredDatasetType_DatasetColumn)(nil), // 15: flyteidl2.core.StructuredDatasetType.DatasetColumn + nil, // 16: flyteidl2.core.TypeStructure.DataclassTypeEntry + (*structpb.Struct)(nil), // 17: google.protobuf.Struct +} +var file_flyteidl2_core_types_proto_depIdxs = []int32{ + 14, // 0: flyteidl2.core.SchemaType.columns:type_name -> flyteidl2.core.SchemaType.SchemaColumn + 15, // 1: flyteidl2.core.StructuredDatasetType.columns:type_name -> flyteidl2.core.StructuredDatasetType.DatasetColumn + 2, // 2: flyteidl2.core.BlobType.dimensionality:type_name -> flyteidl2.core.BlobType.BlobDimensionality + 10, // 3: flyteidl2.core.UnionType.variants:type_name -> flyteidl2.core.LiteralType + 16, // 4: flyteidl2.core.TypeStructure.dataclass_type:type_name -> flyteidl2.core.TypeStructure.DataclassTypeEntry + 17, // 5: flyteidl2.core.TypeAnnotation.annotations:type_name -> google.protobuf.Struct + 0, // 6: flyteidl2.core.LiteralType.simple:type_name -> flyteidl2.core.SimpleType + 3, // 7: flyteidl2.core.LiteralType.schema:type_name -> flyteidl2.core.SchemaType + 10, // 8: flyteidl2.core.LiteralType.collection_type:type_name -> flyteidl2.core.LiteralType + 10, // 9: flyteidl2.core.LiteralType.map_value_type:type_name -> flyteidl2.core.LiteralType + 5, // 10: flyteidl2.core.LiteralType.blob:type_name -> flyteidl2.core.BlobType + 6, // 11: flyteidl2.core.LiteralType.enum_type:type_name -> flyteidl2.core.EnumType + 4, // 12: flyteidl2.core.LiteralType.structured_dataset_type:type_name -> flyteidl2.core.StructuredDatasetType + 7, // 13: flyteidl2.core.LiteralType.union_type:type_name -> flyteidl2.core.UnionType + 17, // 14: flyteidl2.core.LiteralType.metadata:type_name -> google.protobuf.Struct + 9, // 15: flyteidl2.core.LiteralType.annotation:type_name -> flyteidl2.core.TypeAnnotation + 8, // 16: flyteidl2.core.LiteralType.structure:type_name -> flyteidl2.core.TypeStructure + 12, // 17: flyteidl2.core.OutputReference.attr_path:type_name -> flyteidl2.core.PromiseAttribute + 1, // 18: flyteidl2.core.SchemaType.SchemaColumn.type:type_name -> flyteidl2.core.SchemaType.SchemaColumn.SchemaColumnType + 10, // 19: flyteidl2.core.StructuredDatasetType.DatasetColumn.literal_type:type_name -> flyteidl2.core.LiteralType + 10, // 20: flyteidl2.core.TypeStructure.DataclassTypeEntry.value:type_name -> flyteidl2.core.LiteralType + 21, // [21:21] is the sub-list for method output_type + 21, // [21:21] is the sub-list for method input_type + 21, // [21:21] is the sub-list for extension type_name + 21, // [21:21] is the sub-list for extension extendee + 0, // [0:21] is the sub-list for field type_name +} + +func init() { file_flyteidl2_core_types_proto_init() } +func file_flyteidl2_core_types_proto_init() { + if File_flyteidl2_core_types_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_core_types_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SchemaType); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_types_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*StructuredDatasetType); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_types_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BlobType); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_types_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EnumType); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_types_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UnionType); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_types_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TypeStructure); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_types_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TypeAnnotation); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_types_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LiteralType); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_types_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OutputReference); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_types_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PromiseAttribute); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_types_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Error); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_types_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SchemaType_SchemaColumn); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_core_types_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*StructuredDatasetType_DatasetColumn); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_core_types_proto_msgTypes[7].OneofWrappers = []interface{}{ + (*LiteralType_Simple)(nil), + (*LiteralType_Schema)(nil), + (*LiteralType_CollectionType)(nil), + (*LiteralType_MapValueType)(nil), + (*LiteralType_Blob)(nil), + (*LiteralType_EnumType)(nil), + (*LiteralType_StructuredDatasetType)(nil), + (*LiteralType_UnionType)(nil), + } + file_flyteidl2_core_types_proto_msgTypes[9].OneofWrappers = []interface{}{ + (*PromiseAttribute_StringValue)(nil), + (*PromiseAttribute_IntValue)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_core_types_proto_rawDesc, + NumEnums: 3, + NumMessages: 14, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_core_types_proto_goTypes, + DependencyIndexes: file_flyteidl2_core_types_proto_depIdxs, + EnumInfos: file_flyteidl2_core_types_proto_enumTypes, + MessageInfos: file_flyteidl2_core_types_proto_msgTypes, + }.Build() + File_flyteidl2_core_types_proto = out.File + file_flyteidl2_core_types_proto_rawDesc = nil + file_flyteidl2_core_types_proto_goTypes = nil + file_flyteidl2_core_types_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/core/types.pb.validate.go b/gen/go/flyteidl2/core/types.pb.validate.go new file mode 100644 index 0000000000..b19be491cc --- /dev/null +++ b/gen/go/flyteidl2/core/types.pb.validate.go @@ -0,0 +1,2024 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/core/types.proto + +package core + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on SchemaType with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *SchemaType) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on SchemaType with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in SchemaTypeMultiError, or +// nil if none found. +func (m *SchemaType) ValidateAll() error { + return m.validate(true) +} + +func (m *SchemaType) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetColumns() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SchemaTypeValidationError{ + field: fmt.Sprintf("Columns[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SchemaTypeValidationError{ + field: fmt.Sprintf("Columns[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SchemaTypeValidationError{ + field: fmt.Sprintf("Columns[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return SchemaTypeMultiError(errors) + } + + return nil +} + +// SchemaTypeMultiError is an error wrapping multiple validation errors +// returned by SchemaType.ValidateAll() if the designated constraints aren't met. +type SchemaTypeMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SchemaTypeMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SchemaTypeMultiError) AllErrors() []error { return m } + +// SchemaTypeValidationError is the validation error returned by +// SchemaType.Validate if the designated constraints aren't met. +type SchemaTypeValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SchemaTypeValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SchemaTypeValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SchemaTypeValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SchemaTypeValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SchemaTypeValidationError) ErrorName() string { return "SchemaTypeValidationError" } + +// Error satisfies the builtin error interface +func (e SchemaTypeValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSchemaType.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SchemaTypeValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SchemaTypeValidationError{} + +// Validate checks the field values on StructuredDatasetType with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *StructuredDatasetType) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on StructuredDatasetType with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// StructuredDatasetTypeMultiError, or nil if none found. +func (m *StructuredDatasetType) ValidateAll() error { + return m.validate(true) +} + +func (m *StructuredDatasetType) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetColumns() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, StructuredDatasetTypeValidationError{ + field: fmt.Sprintf("Columns[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, StructuredDatasetTypeValidationError{ + field: fmt.Sprintf("Columns[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return StructuredDatasetTypeValidationError{ + field: fmt.Sprintf("Columns[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Format + + // no validation rules for ExternalSchemaType + + // no validation rules for ExternalSchemaBytes + + if len(errors) > 0 { + return StructuredDatasetTypeMultiError(errors) + } + + return nil +} + +// StructuredDatasetTypeMultiError is an error wrapping multiple validation +// errors returned by StructuredDatasetType.ValidateAll() if the designated +// constraints aren't met. +type StructuredDatasetTypeMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m StructuredDatasetTypeMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m StructuredDatasetTypeMultiError) AllErrors() []error { return m } + +// StructuredDatasetTypeValidationError is the validation error returned by +// StructuredDatasetType.Validate if the designated constraints aren't met. +type StructuredDatasetTypeValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e StructuredDatasetTypeValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e StructuredDatasetTypeValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e StructuredDatasetTypeValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e StructuredDatasetTypeValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e StructuredDatasetTypeValidationError) ErrorName() string { + return "StructuredDatasetTypeValidationError" +} + +// Error satisfies the builtin error interface +func (e StructuredDatasetTypeValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sStructuredDatasetType.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = StructuredDatasetTypeValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = StructuredDatasetTypeValidationError{} + +// Validate checks the field values on BlobType with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *BlobType) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on BlobType with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in BlobTypeMultiError, or nil +// if none found. +func (m *BlobType) ValidateAll() error { + return m.validate(true) +} + +func (m *BlobType) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Format + + // no validation rules for Dimensionality + + if len(errors) > 0 { + return BlobTypeMultiError(errors) + } + + return nil +} + +// BlobTypeMultiError is an error wrapping multiple validation errors returned +// by BlobType.ValidateAll() if the designated constraints aren't met. +type BlobTypeMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m BlobTypeMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m BlobTypeMultiError) AllErrors() []error { return m } + +// BlobTypeValidationError is the validation error returned by +// BlobType.Validate if the designated constraints aren't met. +type BlobTypeValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e BlobTypeValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e BlobTypeValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e BlobTypeValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e BlobTypeValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e BlobTypeValidationError) ErrorName() string { return "BlobTypeValidationError" } + +// Error satisfies the builtin error interface +func (e BlobTypeValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sBlobType.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = BlobTypeValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = BlobTypeValidationError{} + +// Validate checks the field values on EnumType with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *EnumType) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on EnumType with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in EnumTypeMultiError, or nil +// if none found. +func (m *EnumType) ValidateAll() error { + return m.validate(true) +} + +func (m *EnumType) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return EnumTypeMultiError(errors) + } + + return nil +} + +// EnumTypeMultiError is an error wrapping multiple validation errors returned +// by EnumType.ValidateAll() if the designated constraints aren't met. +type EnumTypeMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m EnumTypeMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m EnumTypeMultiError) AllErrors() []error { return m } + +// EnumTypeValidationError is the validation error returned by +// EnumType.Validate if the designated constraints aren't met. +type EnumTypeValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e EnumTypeValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e EnumTypeValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e EnumTypeValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e EnumTypeValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e EnumTypeValidationError) ErrorName() string { return "EnumTypeValidationError" } + +// Error satisfies the builtin error interface +func (e EnumTypeValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sEnumType.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = EnumTypeValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = EnumTypeValidationError{} + +// Validate checks the field values on UnionType with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *UnionType) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on UnionType with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in UnionTypeMultiError, or nil +// if none found. +func (m *UnionType) ValidateAll() error { + return m.validate(true) +} + +func (m *UnionType) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetVariants() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UnionTypeValidationError{ + field: fmt.Sprintf("Variants[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UnionTypeValidationError{ + field: fmt.Sprintf("Variants[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UnionTypeValidationError{ + field: fmt.Sprintf("Variants[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return UnionTypeMultiError(errors) + } + + return nil +} + +// UnionTypeMultiError is an error wrapping multiple validation errors returned +// by UnionType.ValidateAll() if the designated constraints aren't met. +type UnionTypeMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UnionTypeMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UnionTypeMultiError) AllErrors() []error { return m } + +// UnionTypeValidationError is the validation error returned by +// UnionType.Validate if the designated constraints aren't met. +type UnionTypeValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UnionTypeValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UnionTypeValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UnionTypeValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UnionTypeValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UnionTypeValidationError) ErrorName() string { return "UnionTypeValidationError" } + +// Error satisfies the builtin error interface +func (e UnionTypeValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUnionType.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UnionTypeValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UnionTypeValidationError{} + +// Validate checks the field values on TypeStructure with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TypeStructure) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TypeStructure with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TypeStructureMultiError, or +// nil if none found. +func (m *TypeStructure) ValidateAll() error { + return m.validate(true) +} + +func (m *TypeStructure) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Tag + + { + sorted_keys := make([]string, len(m.GetDataclassType())) + i := 0 + for key := range m.GetDataclassType() { + sorted_keys[i] = key + i++ + } + sort.Slice(sorted_keys, func(i, j int) bool { return sorted_keys[i] < sorted_keys[j] }) + for _, key := range sorted_keys { + val := m.GetDataclassType()[key] + _ = val + + // no validation rules for DataclassType[key] + + if all { + switch v := interface{}(val).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TypeStructureValidationError{ + field: fmt.Sprintf("DataclassType[%v]", key), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TypeStructureValidationError{ + field: fmt.Sprintf("DataclassType[%v]", key), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(val).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TypeStructureValidationError{ + field: fmt.Sprintf("DataclassType[%v]", key), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + } + + if len(errors) > 0 { + return TypeStructureMultiError(errors) + } + + return nil +} + +// TypeStructureMultiError is an error wrapping multiple validation errors +// returned by TypeStructure.ValidateAll() if the designated constraints +// aren't met. +type TypeStructureMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TypeStructureMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TypeStructureMultiError) AllErrors() []error { return m } + +// TypeStructureValidationError is the validation error returned by +// TypeStructure.Validate if the designated constraints aren't met. +type TypeStructureValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TypeStructureValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TypeStructureValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TypeStructureValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TypeStructureValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TypeStructureValidationError) ErrorName() string { return "TypeStructureValidationError" } + +// Error satisfies the builtin error interface +func (e TypeStructureValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTypeStructure.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TypeStructureValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TypeStructureValidationError{} + +// Validate checks the field values on TypeAnnotation with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TypeAnnotation) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TypeAnnotation with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TypeAnnotationMultiError, +// or nil if none found. +func (m *TypeAnnotation) ValidateAll() error { + return m.validate(true) +} + +func (m *TypeAnnotation) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetAnnotations()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TypeAnnotationValidationError{ + field: "Annotations", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TypeAnnotationValidationError{ + field: "Annotations", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAnnotations()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TypeAnnotationValidationError{ + field: "Annotations", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return TypeAnnotationMultiError(errors) + } + + return nil +} + +// TypeAnnotationMultiError is an error wrapping multiple validation errors +// returned by TypeAnnotation.ValidateAll() if the designated constraints +// aren't met. +type TypeAnnotationMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TypeAnnotationMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TypeAnnotationMultiError) AllErrors() []error { return m } + +// TypeAnnotationValidationError is the validation error returned by +// TypeAnnotation.Validate if the designated constraints aren't met. +type TypeAnnotationValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TypeAnnotationValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TypeAnnotationValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TypeAnnotationValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TypeAnnotationValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TypeAnnotationValidationError) ErrorName() string { return "TypeAnnotationValidationError" } + +// Error satisfies the builtin error interface +func (e TypeAnnotationValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTypeAnnotation.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TypeAnnotationValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TypeAnnotationValidationError{} + +// Validate checks the field values on LiteralType with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *LiteralType) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LiteralType with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in LiteralTypeMultiError, or +// nil if none found. +func (m *LiteralType) ValidateAll() error { + return m.validate(true) +} + +func (m *LiteralType) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralTypeValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetAnnotation()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "Annotation", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "Annotation", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAnnotation()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralTypeValidationError{ + field: "Annotation", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetStructure()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "Structure", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "Structure", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStructure()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralTypeValidationError{ + field: "Structure", + reason: "embedded message failed validation", + cause: err, + } + } + } + + switch v := m.Type.(type) { + case *LiteralType_Simple: + if v == nil { + err := LiteralTypeValidationError{ + field: "Type", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for Simple + case *LiteralType_Schema: + if v == nil { + err := LiteralTypeValidationError{ + field: "Type", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetSchema()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "Schema", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "Schema", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSchema()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralTypeValidationError{ + field: "Schema", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *LiteralType_CollectionType: + if v == nil { + err := LiteralTypeValidationError{ + field: "Type", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetCollectionType()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "CollectionType", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "CollectionType", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCollectionType()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralTypeValidationError{ + field: "CollectionType", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *LiteralType_MapValueType: + if v == nil { + err := LiteralTypeValidationError{ + field: "Type", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetMapValueType()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "MapValueType", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "MapValueType", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMapValueType()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralTypeValidationError{ + field: "MapValueType", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *LiteralType_Blob: + if v == nil { + err := LiteralTypeValidationError{ + field: "Type", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetBlob()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "Blob", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "Blob", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetBlob()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralTypeValidationError{ + field: "Blob", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *LiteralType_EnumType: + if v == nil { + err := LiteralTypeValidationError{ + field: "Type", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetEnumType()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "EnumType", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "EnumType", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetEnumType()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralTypeValidationError{ + field: "EnumType", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *LiteralType_StructuredDatasetType: + if v == nil { + err := LiteralTypeValidationError{ + field: "Type", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetStructuredDatasetType()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "StructuredDatasetType", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "StructuredDatasetType", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStructuredDatasetType()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralTypeValidationError{ + field: "StructuredDatasetType", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *LiteralType_UnionType: + if v == nil { + err := LiteralTypeValidationError{ + field: "Type", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetUnionType()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "UnionType", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralTypeValidationError{ + field: "UnionType", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetUnionType()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralTypeValidationError{ + field: "UnionType", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return LiteralTypeMultiError(errors) + } + + return nil +} + +// LiteralTypeMultiError is an error wrapping multiple validation errors +// returned by LiteralType.ValidateAll() if the designated constraints aren't met. +type LiteralTypeMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LiteralTypeMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LiteralTypeMultiError) AllErrors() []error { return m } + +// LiteralTypeValidationError is the validation error returned by +// LiteralType.Validate if the designated constraints aren't met. +type LiteralTypeValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LiteralTypeValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LiteralTypeValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LiteralTypeValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LiteralTypeValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LiteralTypeValidationError) ErrorName() string { return "LiteralTypeValidationError" } + +// Error satisfies the builtin error interface +func (e LiteralTypeValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLiteralType.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LiteralTypeValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LiteralTypeValidationError{} + +// Validate checks the field values on OutputReference with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *OutputReference) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on OutputReference with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// OutputReferenceMultiError, or nil if none found. +func (m *OutputReference) ValidateAll() error { + return m.validate(true) +} + +func (m *OutputReference) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for NodeId + + // no validation rules for Var + + for idx, item := range m.GetAttrPath() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, OutputReferenceValidationError{ + field: fmt.Sprintf("AttrPath[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, OutputReferenceValidationError{ + field: fmt.Sprintf("AttrPath[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return OutputReferenceValidationError{ + field: fmt.Sprintf("AttrPath[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return OutputReferenceMultiError(errors) + } + + return nil +} + +// OutputReferenceMultiError is an error wrapping multiple validation errors +// returned by OutputReference.ValidateAll() if the designated constraints +// aren't met. +type OutputReferenceMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m OutputReferenceMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m OutputReferenceMultiError) AllErrors() []error { return m } + +// OutputReferenceValidationError is the validation error returned by +// OutputReference.Validate if the designated constraints aren't met. +type OutputReferenceValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e OutputReferenceValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e OutputReferenceValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e OutputReferenceValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e OutputReferenceValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e OutputReferenceValidationError) ErrorName() string { return "OutputReferenceValidationError" } + +// Error satisfies the builtin error interface +func (e OutputReferenceValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sOutputReference.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = OutputReferenceValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = OutputReferenceValidationError{} + +// Validate checks the field values on PromiseAttribute with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *PromiseAttribute) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on PromiseAttribute with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// PromiseAttributeMultiError, or nil if none found. +func (m *PromiseAttribute) ValidateAll() error { + return m.validate(true) +} + +func (m *PromiseAttribute) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Value.(type) { + case *PromiseAttribute_StringValue: + if v == nil { + err := PromiseAttributeValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for StringValue + case *PromiseAttribute_IntValue: + if v == nil { + err := PromiseAttributeValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for IntValue + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return PromiseAttributeMultiError(errors) + } + + return nil +} + +// PromiseAttributeMultiError is an error wrapping multiple validation errors +// returned by PromiseAttribute.ValidateAll() if the designated constraints +// aren't met. +type PromiseAttributeMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PromiseAttributeMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PromiseAttributeMultiError) AllErrors() []error { return m } + +// PromiseAttributeValidationError is the validation error returned by +// PromiseAttribute.Validate if the designated constraints aren't met. +type PromiseAttributeValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PromiseAttributeValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PromiseAttributeValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PromiseAttributeValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PromiseAttributeValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PromiseAttributeValidationError) ErrorName() string { return "PromiseAttributeValidationError" } + +// Error satisfies the builtin error interface +func (e PromiseAttributeValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPromiseAttribute.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PromiseAttributeValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PromiseAttributeValidationError{} + +// Validate checks the field values on Error with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Error) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Error with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in ErrorMultiError, or nil if none found. +func (m *Error) ValidateAll() error { + return m.validate(true) +} + +func (m *Error) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for FailedNodeId + + // no validation rules for Message + + if len(errors) > 0 { + return ErrorMultiError(errors) + } + + return nil +} + +// ErrorMultiError is an error wrapping multiple validation errors returned by +// Error.ValidateAll() if the designated constraints aren't met. +type ErrorMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ErrorMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ErrorMultiError) AllErrors() []error { return m } + +// ErrorValidationError is the validation error returned by Error.Validate if +// the designated constraints aren't met. +type ErrorValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ErrorValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ErrorValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ErrorValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ErrorValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ErrorValidationError) ErrorName() string { return "ErrorValidationError" } + +// Error satisfies the builtin error interface +func (e ErrorValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sError.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ErrorValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ErrorValidationError{} + +// Validate checks the field values on SchemaType_SchemaColumn with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *SchemaType_SchemaColumn) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on SchemaType_SchemaColumn with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// SchemaType_SchemaColumnMultiError, or nil if none found. +func (m *SchemaType_SchemaColumn) ValidateAll() error { + return m.validate(true) +} + +func (m *SchemaType_SchemaColumn) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + // no validation rules for Type + + if len(errors) > 0 { + return SchemaType_SchemaColumnMultiError(errors) + } + + return nil +} + +// SchemaType_SchemaColumnMultiError is an error wrapping multiple validation +// errors returned by SchemaType_SchemaColumn.ValidateAll() if the designated +// constraints aren't met. +type SchemaType_SchemaColumnMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SchemaType_SchemaColumnMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SchemaType_SchemaColumnMultiError) AllErrors() []error { return m } + +// SchemaType_SchemaColumnValidationError is the validation error returned by +// SchemaType_SchemaColumn.Validate if the designated constraints aren't met. +type SchemaType_SchemaColumnValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SchemaType_SchemaColumnValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SchemaType_SchemaColumnValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SchemaType_SchemaColumnValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SchemaType_SchemaColumnValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SchemaType_SchemaColumnValidationError) ErrorName() string { + return "SchemaType_SchemaColumnValidationError" +} + +// Error satisfies the builtin error interface +func (e SchemaType_SchemaColumnValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSchemaType_SchemaColumn.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SchemaType_SchemaColumnValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SchemaType_SchemaColumnValidationError{} + +// Validate checks the field values on StructuredDatasetType_DatasetColumn with +// the rules defined in the proto definition for this message. If any rules +// are violated, the first error encountered is returned, or nil if there are +// no violations. +func (m *StructuredDatasetType_DatasetColumn) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on StructuredDatasetType_DatasetColumn +// with the rules defined in the proto definition for this message. If any +// rules are violated, the result is a list of violation errors wrapped in +// StructuredDatasetType_DatasetColumnMultiError, or nil if none found. +func (m *StructuredDatasetType_DatasetColumn) ValidateAll() error { + return m.validate(true) +} + +func (m *StructuredDatasetType_DatasetColumn) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + if all { + switch v := interface{}(m.GetLiteralType()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, StructuredDatasetType_DatasetColumnValidationError{ + field: "LiteralType", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, StructuredDatasetType_DatasetColumnValidationError{ + field: "LiteralType", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLiteralType()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return StructuredDatasetType_DatasetColumnValidationError{ + field: "LiteralType", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return StructuredDatasetType_DatasetColumnMultiError(errors) + } + + return nil +} + +// StructuredDatasetType_DatasetColumnMultiError is an error wrapping multiple +// validation errors returned by +// StructuredDatasetType_DatasetColumn.ValidateAll() if the designated +// constraints aren't met. +type StructuredDatasetType_DatasetColumnMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m StructuredDatasetType_DatasetColumnMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m StructuredDatasetType_DatasetColumnMultiError) AllErrors() []error { return m } + +// StructuredDatasetType_DatasetColumnValidationError is the validation error +// returned by StructuredDatasetType_DatasetColumn.Validate if the designated +// constraints aren't met. +type StructuredDatasetType_DatasetColumnValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e StructuredDatasetType_DatasetColumnValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e StructuredDatasetType_DatasetColumnValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e StructuredDatasetType_DatasetColumnValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e StructuredDatasetType_DatasetColumnValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e StructuredDatasetType_DatasetColumnValidationError) ErrorName() string { + return "StructuredDatasetType_DatasetColumnValidationError" +} + +// Error satisfies the builtin error interface +func (e StructuredDatasetType_DatasetColumnValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sStructuredDatasetType_DatasetColumn.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = StructuredDatasetType_DatasetColumnValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = StructuredDatasetType_DatasetColumnValidationError{} diff --git a/gen/go/flyteidl2/dataproxy/dataproxy_service.pb.go b/gen/go/flyteidl2/dataproxy/dataproxy_service.pb.go new file mode 100644 index 0000000000..18b97871be --- /dev/null +++ b/gen/go/flyteidl2/dataproxy/dataproxy_service.pb.go @@ -0,0 +1,424 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/dataproxy/dataproxy_service.proto + +package dataproxy + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + _ "github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2/options" + _ "google.golang.org/genproto/googleapis/api/annotations" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + durationpb "google.golang.org/protobuf/types/known/durationpb" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// CreateUploadLocationRequest specifies the request for the CreateUploadLocation API. +// The data proxy service will generate a storage location with server-side configured prefixes. +// The generated path follows one of these patterns: +// - project/domain/(deterministic hash of content_md5)/filename (if filename is present); OR +// - project/domain/filename_root/filename (if filename_root and filename are present). +type CreateUploadLocationRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Project to create the upload location for. + // +required + Project string `protobuf:"bytes,1,opt,name=project,proto3" json:"project,omitempty"` + // Domain to create the upload location for. + // +required + Domain string `protobuf:"bytes,2,opt,name=domain,proto3" json:"domain,omitempty"` + // Filename specifies the desired suffix for the generated location. E.g. `file.py` or `pre/fix/file.zip`. + // +optional. By default, the service generates a consistent name based on the default filename length provided in the global config.. + Filename string `protobuf:"bytes,3,opt,name=filename,proto3" json:"filename,omitempty"` + // ExpiresIn defines the requested expiration duration for the generated URL. The request will be rejected if this + // exceeds the platform's configured maximum. + // +optional. The default value comes from the global config. + ExpiresIn *durationpb.Duration `protobuf:"bytes,4,opt,name=expires_in,json=expiresIn,proto3" json:"expires_in,omitempty"` + // ContentMD5 restricts the upload location to the specific MD5 provided. The MD5 hash will also appear in the + // generated path for verification. + // +required + ContentMd5 []byte `protobuf:"bytes,5,opt,name=content_md5,json=contentMd5,proto3" json:"content_md5,omitempty"` + // FilenameRoot, if present, will be used instead of the MD5 hash in the path. When combined with filename, + // this makes the upload location deterministic. The native URL will still be prefixed by the upload location prefix + // configured in the data proxy. This option is useful when uploading multiple related files. + // +optional + FilenameRoot string `protobuf:"bytes,6,opt,name=filename_root,json=filenameRoot,proto3" json:"filename_root,omitempty"` + // If true, the data proxy will add content_md5 to the Signed URL requirements, + // forcing clients to send this checksum with the object. + // This is required to enforce data integrity on backends like GCP, ensuring that + // the uploaded file matches the hash. + AddContentMd5Metadata bool `protobuf:"varint,7,opt,name=add_content_md5_metadata,json=addContentMd5Metadata,proto3" json:"add_content_md5_metadata,omitempty"` + // Org is the organization key applied to the resource. + // +optional + Org string `protobuf:"bytes,8,opt,name=org,proto3" json:"org,omitempty"` + // ContentLength specifies the size of the content to be uploaded in bytes. + // This is validated against the platform's maximum upload size if provided. + // +optional + ContentLength int64 `protobuf:"varint,9,opt,name=content_length,json=contentLength,proto3" json:"content_length,omitempty"` +} + +func (x *CreateUploadLocationRequest) Reset() { + *x = CreateUploadLocationRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_dataproxy_dataproxy_service_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CreateUploadLocationRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateUploadLocationRequest) ProtoMessage() {} + +func (x *CreateUploadLocationRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_dataproxy_dataproxy_service_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateUploadLocationRequest.ProtoReflect.Descriptor instead. +func (*CreateUploadLocationRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_dataproxy_dataproxy_service_proto_rawDescGZIP(), []int{0} +} + +func (x *CreateUploadLocationRequest) GetProject() string { + if x != nil { + return x.Project + } + return "" +} + +func (x *CreateUploadLocationRequest) GetDomain() string { + if x != nil { + return x.Domain + } + return "" +} + +func (x *CreateUploadLocationRequest) GetFilename() string { + if x != nil { + return x.Filename + } + return "" +} + +func (x *CreateUploadLocationRequest) GetExpiresIn() *durationpb.Duration { + if x != nil { + return x.ExpiresIn + } + return nil +} + +func (x *CreateUploadLocationRequest) GetContentMd5() []byte { + if x != nil { + return x.ContentMd5 + } + return nil +} + +func (x *CreateUploadLocationRequest) GetFilenameRoot() string { + if x != nil { + return x.FilenameRoot + } + return "" +} + +func (x *CreateUploadLocationRequest) GetAddContentMd5Metadata() bool { + if x != nil { + return x.AddContentMd5Metadata + } + return false +} + +func (x *CreateUploadLocationRequest) GetOrg() string { + if x != nil { + return x.Org + } + return "" +} + +func (x *CreateUploadLocationRequest) GetContentLength() int64 { + if x != nil { + return x.ContentLength + } + return 0 +} + +// CreateUploadLocationResponse specifies the response for the CreateUploadLocation API. +type CreateUploadLocationResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // SignedUrl is the URL to use for uploading content (e.g. https://my-bucket.s3.amazonaws.com/randomstring/suffix.tar?X-...). + SignedUrl string `protobuf:"bytes,1,opt,name=signed_url,json=signedUrl,proto3" json:"signed_url,omitempty"` + // NativeUrl is the URL in the format of the configured storage provider (e.g. s3://my-bucket/randomstring/suffix.tar). + NativeUrl string `protobuf:"bytes,2,opt,name=native_url,json=nativeUrl,proto3" json:"native_url,omitempty"` + // ExpiresAt defines when the signed URL will expire. + ExpiresAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=expires_at,json=expiresAt,proto3" json:"expires_at,omitempty"` + // Headers are generated by the data proxy for the client. Clients must include these headers in the upload request. + Headers map[string]string `protobuf:"bytes,4,rep,name=headers,proto3" json:"headers,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *CreateUploadLocationResponse) Reset() { + *x = CreateUploadLocationResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_dataproxy_dataproxy_service_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CreateUploadLocationResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateUploadLocationResponse) ProtoMessage() {} + +func (x *CreateUploadLocationResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_dataproxy_dataproxy_service_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateUploadLocationResponse.ProtoReflect.Descriptor instead. +func (*CreateUploadLocationResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_dataproxy_dataproxy_service_proto_rawDescGZIP(), []int{1} +} + +func (x *CreateUploadLocationResponse) GetSignedUrl() string { + if x != nil { + return x.SignedUrl + } + return "" +} + +func (x *CreateUploadLocationResponse) GetNativeUrl() string { + if x != nil { + return x.NativeUrl + } + return "" +} + +func (x *CreateUploadLocationResponse) GetExpiresAt() *timestamppb.Timestamp { + if x != nil { + return x.ExpiresAt + } + return nil +} + +func (x *CreateUploadLocationResponse) GetHeaders() map[string]string { + if x != nil { + return x.Headers + } + return nil +} + +var File_flyteidl2_dataproxy_dataproxy_service_proto protoreflect.FileDescriptor + +var file_flyteidl2_dataproxy_dataproxy_service_proto_rawDesc = []byte{ + 0x0a, 0x2b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x64, 0x61, 0x74, 0x61, + 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2f, 0x64, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x5f, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x13, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, + 0x78, 0x79, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, + 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, + 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, + 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, + 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x6f, 0x70, 0x65, 0x6e, 0x61, + 0x70, 0x69, 0x76, 0x32, 0x2f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x61, 0x6e, 0x6e, + 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xf8, + 0x02, 0x0a, 0x1b, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x4c, + 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, + 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, + 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x12, 0x1f, 0x0a, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x06, 0x64, 0x6f, 0x6d, 0x61, + 0x69, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x38, + 0x0a, 0x0a, 0x65, 0x78, 0x70, 0x69, 0x72, 0x65, 0x73, 0x5f, 0x69, 0x6e, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x09, 0x65, + 0x78, 0x70, 0x69, 0x72, 0x65, 0x73, 0x49, 0x6e, 0x12, 0x28, 0x0a, 0x0b, 0x63, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x5f, 0x6d, 0x64, 0x35, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x07, 0xba, + 0x48, 0x04, 0x7a, 0x02, 0x68, 0x10, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x4d, + 0x64, 0x35, 0x12, 0x23, 0x0a, 0x0d, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x72, + 0x6f, 0x6f, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x66, 0x69, 0x6c, 0x65, 0x6e, + 0x61, 0x6d, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x37, 0x0a, 0x18, 0x61, 0x64, 0x64, 0x5f, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x6d, 0x64, 0x35, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x61, 0x64, 0x64, 0x43, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x4d, 0x64, 0x35, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x12, 0x10, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6f, + 0x72, 0x67, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x6c, 0x65, + 0x6e, 0x67, 0x74, 0x68, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x63, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x22, 0xad, 0x02, 0x0a, 0x1c, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x69, + 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x55, 0x72, 0x6c, 0x12, 0x1d, 0x0a, 0x0a, 0x6e, 0x61, 0x74, + 0x69, 0x76, 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, + 0x61, 0x74, 0x69, 0x76, 0x65, 0x55, 0x72, 0x6c, 0x12, 0x39, 0x0a, 0x0a, 0x65, 0x78, 0x70, 0x69, + 0x72, 0x65, 0x73, 0x5f, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x65, 0x78, 0x70, 0x69, 0x72, 0x65, + 0x73, 0x41, 0x74, 0x12, 0x58, 0x0a, 0x07, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x18, 0x04, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x1a, 0x3a, 0x0a, + 0x0c, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, + 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, + 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x32, 0xb5, 0x02, 0x0a, 0x10, 0x44, 0x61, + 0x74, 0x61, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0xa0, + 0x02, 0x0a, 0x14, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x4c, + 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x30, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2e, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2e, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x4c, 0x6f, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xa2, 0x01, 0x92, + 0x41, 0x4d, 0x1a, 0x4b, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x77, 0x72, + 0x69, 0x74, 0x65, 0x2d, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x68, 0x74, 0x74, 0x70, 0x20, 0x6c, 0x6f, + 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, + 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x61, + 0x73, 0x6b, 0x73, 0x20, 0x61, 0x74, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x4c, 0x3a, 0x01, 0x2a, 0x5a, 0x27, 0x3a, 0x01, 0x2a, 0x22, 0x22, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6f, 0x72, 0x67, 0x2f, 0x64, 0x61, 0x74, 0x61, 0x70, + 0x72, 0x6f, 0x78, 0x79, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x75, 0x72, + 0x6e, 0x22, 0x1e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x64, 0x61, 0x74, 0x61, 0x70, + 0x72, 0x6f, 0x78, 0x79, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x75, 0x72, + 0x6e, 0x42, 0xd8, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x42, 0x15, 0x44, + 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x37, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, + 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x64, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, + 0x79, 0xa2, 0x02, 0x03, 0x46, 0x44, 0x58, 0xaa, 0x02, 0x13, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, 0xca, 0x02, 0x13, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x44, 0x61, 0x74, 0x61, 0x70, 0x72, + 0x6f, 0x78, 0x79, 0xe2, 0x02, 0x1f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, + 0x44, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x3a, 0x3a, 0x44, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x62, 0x06, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_dataproxy_dataproxy_service_proto_rawDescOnce sync.Once + file_flyteidl2_dataproxy_dataproxy_service_proto_rawDescData = file_flyteidl2_dataproxy_dataproxy_service_proto_rawDesc +) + +func file_flyteidl2_dataproxy_dataproxy_service_proto_rawDescGZIP() []byte { + file_flyteidl2_dataproxy_dataproxy_service_proto_rawDescOnce.Do(func() { + file_flyteidl2_dataproxy_dataproxy_service_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_dataproxy_dataproxy_service_proto_rawDescData) + }) + return file_flyteidl2_dataproxy_dataproxy_service_proto_rawDescData +} + +var file_flyteidl2_dataproxy_dataproxy_service_proto_msgTypes = make([]protoimpl.MessageInfo, 3) +var file_flyteidl2_dataproxy_dataproxy_service_proto_goTypes = []interface{}{ + (*CreateUploadLocationRequest)(nil), // 0: flyteidl2.dataproxy.CreateUploadLocationRequest + (*CreateUploadLocationResponse)(nil), // 1: flyteidl2.dataproxy.CreateUploadLocationResponse + nil, // 2: flyteidl2.dataproxy.CreateUploadLocationResponse.HeadersEntry + (*durationpb.Duration)(nil), // 3: google.protobuf.Duration + (*timestamppb.Timestamp)(nil), // 4: google.protobuf.Timestamp +} +var file_flyteidl2_dataproxy_dataproxy_service_proto_depIdxs = []int32{ + 3, // 0: flyteidl2.dataproxy.CreateUploadLocationRequest.expires_in:type_name -> google.protobuf.Duration + 4, // 1: flyteidl2.dataproxy.CreateUploadLocationResponse.expires_at:type_name -> google.protobuf.Timestamp + 2, // 2: flyteidl2.dataproxy.CreateUploadLocationResponse.headers:type_name -> flyteidl2.dataproxy.CreateUploadLocationResponse.HeadersEntry + 0, // 3: flyteidl2.dataproxy.DataProxyService.CreateUploadLocation:input_type -> flyteidl2.dataproxy.CreateUploadLocationRequest + 1, // 4: flyteidl2.dataproxy.DataProxyService.CreateUploadLocation:output_type -> flyteidl2.dataproxy.CreateUploadLocationResponse + 4, // [4:5] is the sub-list for method output_type + 3, // [3:4] is the sub-list for method input_type + 3, // [3:3] is the sub-list for extension type_name + 3, // [3:3] is the sub-list for extension extendee + 0, // [0:3] is the sub-list for field type_name +} + +func init() { file_flyteidl2_dataproxy_dataproxy_service_proto_init() } +func file_flyteidl2_dataproxy_dataproxy_service_proto_init() { + if File_flyteidl2_dataproxy_dataproxy_service_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_dataproxy_dataproxy_service_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CreateUploadLocationRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_dataproxy_dataproxy_service_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CreateUploadLocationResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_dataproxy_dataproxy_service_proto_rawDesc, + NumEnums: 0, + NumMessages: 3, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_flyteidl2_dataproxy_dataproxy_service_proto_goTypes, + DependencyIndexes: file_flyteidl2_dataproxy_dataproxy_service_proto_depIdxs, + MessageInfos: file_flyteidl2_dataproxy_dataproxy_service_proto_msgTypes, + }.Build() + File_flyteidl2_dataproxy_dataproxy_service_proto = out.File + file_flyteidl2_dataproxy_dataproxy_service_proto_rawDesc = nil + file_flyteidl2_dataproxy_dataproxy_service_proto_goTypes = nil + file_flyteidl2_dataproxy_dataproxy_service_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/dataproxy/dataproxy_service.pb.validate.go b/gen/go/flyteidl2/dataproxy/dataproxy_service.pb.validate.go new file mode 100644 index 0000000000..669539b459 --- /dev/null +++ b/gen/go/flyteidl2/dataproxy/dataproxy_service.pb.validate.go @@ -0,0 +1,322 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/dataproxy/dataproxy_service.proto + +package dataproxy + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on CreateUploadLocationRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *CreateUploadLocationRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CreateUploadLocationRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CreateUploadLocationRequestMultiError, or nil if none found. +func (m *CreateUploadLocationRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *CreateUploadLocationRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Project + + // no validation rules for Domain + + // no validation rules for Filename + + if all { + switch v := interface{}(m.GetExpiresIn()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateUploadLocationRequestValidationError{ + field: "ExpiresIn", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateUploadLocationRequestValidationError{ + field: "ExpiresIn", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetExpiresIn()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateUploadLocationRequestValidationError{ + field: "ExpiresIn", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for ContentMd5 + + // no validation rules for FilenameRoot + + // no validation rules for AddContentMd5Metadata + + // no validation rules for Org + + // no validation rules for ContentLength + + if len(errors) > 0 { + return CreateUploadLocationRequestMultiError(errors) + } + + return nil +} + +// CreateUploadLocationRequestMultiError is an error wrapping multiple +// validation errors returned by CreateUploadLocationRequest.ValidateAll() if +// the designated constraints aren't met. +type CreateUploadLocationRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CreateUploadLocationRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CreateUploadLocationRequestMultiError) AllErrors() []error { return m } + +// CreateUploadLocationRequestValidationError is the validation error returned +// by CreateUploadLocationRequest.Validate if the designated constraints +// aren't met. +type CreateUploadLocationRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CreateUploadLocationRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CreateUploadLocationRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CreateUploadLocationRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CreateUploadLocationRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CreateUploadLocationRequestValidationError) ErrorName() string { + return "CreateUploadLocationRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e CreateUploadLocationRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCreateUploadLocationRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CreateUploadLocationRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CreateUploadLocationRequestValidationError{} + +// Validate checks the field values on CreateUploadLocationResponse with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *CreateUploadLocationResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CreateUploadLocationResponse with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CreateUploadLocationResponseMultiError, or nil if none found. +func (m *CreateUploadLocationResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *CreateUploadLocationResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for SignedUrl + + // no validation rules for NativeUrl + + if all { + switch v := interface{}(m.GetExpiresAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateUploadLocationResponseValidationError{ + field: "ExpiresAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateUploadLocationResponseValidationError{ + field: "ExpiresAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetExpiresAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateUploadLocationResponseValidationError{ + field: "ExpiresAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Headers + + if len(errors) > 0 { + return CreateUploadLocationResponseMultiError(errors) + } + + return nil +} + +// CreateUploadLocationResponseMultiError is an error wrapping multiple +// validation errors returned by CreateUploadLocationResponse.ValidateAll() if +// the designated constraints aren't met. +type CreateUploadLocationResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CreateUploadLocationResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CreateUploadLocationResponseMultiError) AllErrors() []error { return m } + +// CreateUploadLocationResponseValidationError is the validation error returned +// by CreateUploadLocationResponse.Validate if the designated constraints +// aren't met. +type CreateUploadLocationResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CreateUploadLocationResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CreateUploadLocationResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CreateUploadLocationResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CreateUploadLocationResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CreateUploadLocationResponseValidationError) ErrorName() string { + return "CreateUploadLocationResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e CreateUploadLocationResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCreateUploadLocationResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CreateUploadLocationResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CreateUploadLocationResponseValidationError{} diff --git a/gen/go/flyteidl2/dataproxy/dataproxy_service_grpc.pb.go b/gen/go/flyteidl2/dataproxy/dataproxy_service_grpc.pb.go new file mode 100644 index 0000000000..788f60a0f5 --- /dev/null +++ b/gen/go/flyteidl2/dataproxy/dataproxy_service_grpc.pb.go @@ -0,0 +1,109 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: flyteidl2/dataproxy/dataproxy_service.proto + +package dataproxy + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + DataProxyService_CreateUploadLocation_FullMethodName = "/flyteidl2.dataproxy.DataProxyService/CreateUploadLocation" +) + +// DataProxyServiceClient is the client API for DataProxyService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type DataProxyServiceClient interface { + // CreateUploadLocation generates a signed URL for uploading data to the configured storage backend. + CreateUploadLocation(ctx context.Context, in *CreateUploadLocationRequest, opts ...grpc.CallOption) (*CreateUploadLocationResponse, error) +} + +type dataProxyServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewDataProxyServiceClient(cc grpc.ClientConnInterface) DataProxyServiceClient { + return &dataProxyServiceClient{cc} +} + +func (c *dataProxyServiceClient) CreateUploadLocation(ctx context.Context, in *CreateUploadLocationRequest, opts ...grpc.CallOption) (*CreateUploadLocationResponse, error) { + out := new(CreateUploadLocationResponse) + err := c.cc.Invoke(ctx, DataProxyService_CreateUploadLocation_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// DataProxyServiceServer is the server API for DataProxyService service. +// All implementations should embed UnimplementedDataProxyServiceServer +// for forward compatibility +type DataProxyServiceServer interface { + // CreateUploadLocation generates a signed URL for uploading data to the configured storage backend. + CreateUploadLocation(context.Context, *CreateUploadLocationRequest) (*CreateUploadLocationResponse, error) +} + +// UnimplementedDataProxyServiceServer should be embedded to have forward compatible implementations. +type UnimplementedDataProxyServiceServer struct { +} + +func (UnimplementedDataProxyServiceServer) CreateUploadLocation(context.Context, *CreateUploadLocationRequest) (*CreateUploadLocationResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CreateUploadLocation not implemented") +} + +// UnsafeDataProxyServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to DataProxyServiceServer will +// result in compilation errors. +type UnsafeDataProxyServiceServer interface { + mustEmbedUnimplementedDataProxyServiceServer() +} + +func RegisterDataProxyServiceServer(s grpc.ServiceRegistrar, srv DataProxyServiceServer) { + s.RegisterService(&DataProxyService_ServiceDesc, srv) +} + +func _DataProxyService_CreateUploadLocation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CreateUploadLocationRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DataProxyServiceServer).CreateUploadLocation(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: DataProxyService_CreateUploadLocation_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DataProxyServiceServer).CreateUploadLocation(ctx, req.(*CreateUploadLocationRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// DataProxyService_ServiceDesc is the grpc.ServiceDesc for DataProxyService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var DataProxyService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.dataproxy.DataProxyService", + HandlerType: (*DataProxyServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "CreateUploadLocation", + Handler: _DataProxyService_CreateUploadLocation_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "flyteidl2/dataproxy/dataproxy_service.proto", +} diff --git a/gen/go/flyteidl2/dataproxy/dataproxyconnect/dataproxy_service.connect.go b/gen/go/flyteidl2/dataproxy/dataproxyconnect/dataproxy_service.connect.go new file mode 100644 index 0000000000..9a77fb8576 --- /dev/null +++ b/gen/go/flyteidl2/dataproxy/dataproxyconnect/dataproxy_service.connect.go @@ -0,0 +1,115 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: flyteidl2/dataproxy/dataproxy_service.proto + +package dataproxyconnect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + dataproxy "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/dataproxy" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // DataProxyServiceName is the fully-qualified name of the DataProxyService service. + DataProxyServiceName = "flyteidl2.dataproxy.DataProxyService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // DataProxyServiceCreateUploadLocationProcedure is the fully-qualified name of the + // DataProxyService's CreateUploadLocation RPC. + DataProxyServiceCreateUploadLocationProcedure = "/flyteidl2.dataproxy.DataProxyService/CreateUploadLocation" +) + +// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. +var ( + dataProxyServiceServiceDescriptor = dataproxy.File_flyteidl2_dataproxy_dataproxy_service_proto.Services().ByName("DataProxyService") + dataProxyServiceCreateUploadLocationMethodDescriptor = dataProxyServiceServiceDescriptor.Methods().ByName("CreateUploadLocation") +) + +// DataProxyServiceClient is a client for the flyteidl2.dataproxy.DataProxyService service. +type DataProxyServiceClient interface { + // CreateUploadLocation generates a signed URL for uploading data to the configured storage backend. + CreateUploadLocation(context.Context, *connect.Request[dataproxy.CreateUploadLocationRequest]) (*connect.Response[dataproxy.CreateUploadLocationResponse], error) +} + +// NewDataProxyServiceClient constructs a client for the flyteidl2.dataproxy.DataProxyService +// service. By default, it uses the Connect protocol with the binary Protobuf Codec, asks for +// gzipped responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply +// the connect.WithGRPC() or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewDataProxyServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) DataProxyServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &dataProxyServiceClient{ + createUploadLocation: connect.NewClient[dataproxy.CreateUploadLocationRequest, dataproxy.CreateUploadLocationResponse]( + httpClient, + baseURL+DataProxyServiceCreateUploadLocationProcedure, + connect.WithSchema(dataProxyServiceCreateUploadLocationMethodDescriptor), + connect.WithClientOptions(opts...), + ), + } +} + +// dataProxyServiceClient implements DataProxyServiceClient. +type dataProxyServiceClient struct { + createUploadLocation *connect.Client[dataproxy.CreateUploadLocationRequest, dataproxy.CreateUploadLocationResponse] +} + +// CreateUploadLocation calls flyteidl2.dataproxy.DataProxyService.CreateUploadLocation. +func (c *dataProxyServiceClient) CreateUploadLocation(ctx context.Context, req *connect.Request[dataproxy.CreateUploadLocationRequest]) (*connect.Response[dataproxy.CreateUploadLocationResponse], error) { + return c.createUploadLocation.CallUnary(ctx, req) +} + +// DataProxyServiceHandler is an implementation of the flyteidl2.dataproxy.DataProxyService service. +type DataProxyServiceHandler interface { + // CreateUploadLocation generates a signed URL for uploading data to the configured storage backend. + CreateUploadLocation(context.Context, *connect.Request[dataproxy.CreateUploadLocationRequest]) (*connect.Response[dataproxy.CreateUploadLocationResponse], error) +} + +// NewDataProxyServiceHandler builds an HTTP handler from the service implementation. It returns the +// path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewDataProxyServiceHandler(svc DataProxyServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + dataProxyServiceCreateUploadLocationHandler := connect.NewUnaryHandler( + DataProxyServiceCreateUploadLocationProcedure, + svc.CreateUploadLocation, + connect.WithSchema(dataProxyServiceCreateUploadLocationMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.dataproxy.DataProxyService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case DataProxyServiceCreateUploadLocationProcedure: + dataProxyServiceCreateUploadLocationHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedDataProxyServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedDataProxyServiceHandler struct{} + +func (UnimplementedDataProxyServiceHandler) CreateUploadLocation(context.Context, *connect.Request[dataproxy.CreateUploadLocationRequest]) (*connect.Response[dataproxy.CreateUploadLocationResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.dataproxy.DataProxyService.CreateUploadLocation is not implemented")) +} diff --git a/gen/go/flyteidl2/event/cloudevents.pb.go b/gen/go/flyteidl2/event/cloudevents.pb.go new file mode 100644 index 0000000000..0266bb6336 --- /dev/null +++ b/gen/go/flyteidl2/event/cloudevents.pb.go @@ -0,0 +1,644 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/event/cloudevents.proto + +package event + +import ( + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// This is the cloud event parallel to the raw WorkflowExecutionEvent message. It's filled in with additional +// information that downstream consumers may find useful. +type CloudEventWorkflowExecution struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RawEvent *WorkflowExecutionEvent `protobuf:"bytes,1,opt,name=raw_event,json=rawEvent,proto3" json:"raw_event,omitempty"` + OutputInterface *core.TypedInterface `protobuf:"bytes,2,opt,name=output_interface,json=outputInterface,proto3" json:"output_interface,omitempty"` + // The following are ExecutionMetadata fields + // We can't have the ExecutionMetadata object directly because of import cycle + ArtifactIds []*core.ArtifactID `protobuf:"bytes,3,rep,name=artifact_ids,json=artifactIds,proto3" json:"artifact_ids,omitempty"` + ReferenceExecution *core.WorkflowExecutionIdentifier `protobuf:"bytes,4,opt,name=reference_execution,json=referenceExecution,proto3" json:"reference_execution,omitempty"` + Principal string `protobuf:"bytes,5,opt,name=principal,proto3" json:"principal,omitempty"` + // The ID of the LP that generated the execution that generated the Artifact. + // Here for provenance information. + // Launch plan IDs are easier to get than workflow IDs so we'll use these for now. + LaunchPlanId *core.Identifier `protobuf:"bytes,6,opt,name=launch_plan_id,json=launchPlanId,proto3" json:"launch_plan_id,omitempty"` + // We can't have the ExecutionMetadata object directly because of import cycle + Labels map[string]string `protobuf:"bytes,7,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *CloudEventWorkflowExecution) Reset() { + *x = CloudEventWorkflowExecution{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_event_cloudevents_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CloudEventWorkflowExecution) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CloudEventWorkflowExecution) ProtoMessage() {} + +func (x *CloudEventWorkflowExecution) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_event_cloudevents_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CloudEventWorkflowExecution.ProtoReflect.Descriptor instead. +func (*CloudEventWorkflowExecution) Descriptor() ([]byte, []int) { + return file_flyteidl2_event_cloudevents_proto_rawDescGZIP(), []int{0} +} + +func (x *CloudEventWorkflowExecution) GetRawEvent() *WorkflowExecutionEvent { + if x != nil { + return x.RawEvent + } + return nil +} + +func (x *CloudEventWorkflowExecution) GetOutputInterface() *core.TypedInterface { + if x != nil { + return x.OutputInterface + } + return nil +} + +func (x *CloudEventWorkflowExecution) GetArtifactIds() []*core.ArtifactID { + if x != nil { + return x.ArtifactIds + } + return nil +} + +func (x *CloudEventWorkflowExecution) GetReferenceExecution() *core.WorkflowExecutionIdentifier { + if x != nil { + return x.ReferenceExecution + } + return nil +} + +func (x *CloudEventWorkflowExecution) GetPrincipal() string { + if x != nil { + return x.Principal + } + return "" +} + +func (x *CloudEventWorkflowExecution) GetLaunchPlanId() *core.Identifier { + if x != nil { + return x.LaunchPlanId + } + return nil +} + +func (x *CloudEventWorkflowExecution) GetLabels() map[string]string { + if x != nil { + return x.Labels + } + return nil +} + +type CloudEventNodeExecution struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RawEvent *NodeExecutionEvent `protobuf:"bytes,1,opt,name=raw_event,json=rawEvent,proto3" json:"raw_event,omitempty"` + // The relevant task execution if applicable + TaskExecId *core.TaskExecutionIdentifier `protobuf:"bytes,2,opt,name=task_exec_id,json=taskExecId,proto3" json:"task_exec_id,omitempty"` + // The typed interface for the task that produced the event. + OutputInterface *core.TypedInterface `protobuf:"bytes,3,opt,name=output_interface,json=outputInterface,proto3" json:"output_interface,omitempty"` + // The following are ExecutionMetadata fields + // We can't have the ExecutionMetadata object directly because of import cycle + ArtifactIds []*core.ArtifactID `protobuf:"bytes,4,rep,name=artifact_ids,json=artifactIds,proto3" json:"artifact_ids,omitempty"` + Principal string `protobuf:"bytes,5,opt,name=principal,proto3" json:"principal,omitempty"` + // The ID of the LP that generated the execution that generated the Artifact. + // Here for provenance information. + // Launch plan IDs are easier to get than workflow IDs so we'll use these for now. + LaunchPlanId *core.Identifier `protobuf:"bytes,6,opt,name=launch_plan_id,json=launchPlanId,proto3" json:"launch_plan_id,omitempty"` + // We can't have the ExecutionMetadata object directly because of import cycle + Labels map[string]string `protobuf:"bytes,7,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *CloudEventNodeExecution) Reset() { + *x = CloudEventNodeExecution{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_event_cloudevents_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CloudEventNodeExecution) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CloudEventNodeExecution) ProtoMessage() {} + +func (x *CloudEventNodeExecution) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_event_cloudevents_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CloudEventNodeExecution.ProtoReflect.Descriptor instead. +func (*CloudEventNodeExecution) Descriptor() ([]byte, []int) { + return file_flyteidl2_event_cloudevents_proto_rawDescGZIP(), []int{1} +} + +func (x *CloudEventNodeExecution) GetRawEvent() *NodeExecutionEvent { + if x != nil { + return x.RawEvent + } + return nil +} + +func (x *CloudEventNodeExecution) GetTaskExecId() *core.TaskExecutionIdentifier { + if x != nil { + return x.TaskExecId + } + return nil +} + +func (x *CloudEventNodeExecution) GetOutputInterface() *core.TypedInterface { + if x != nil { + return x.OutputInterface + } + return nil +} + +func (x *CloudEventNodeExecution) GetArtifactIds() []*core.ArtifactID { + if x != nil { + return x.ArtifactIds + } + return nil +} + +func (x *CloudEventNodeExecution) GetPrincipal() string { + if x != nil { + return x.Principal + } + return "" +} + +func (x *CloudEventNodeExecution) GetLaunchPlanId() *core.Identifier { + if x != nil { + return x.LaunchPlanId + } + return nil +} + +func (x *CloudEventNodeExecution) GetLabels() map[string]string { + if x != nil { + return x.Labels + } + return nil +} + +type CloudEventTaskExecution struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RawEvent *TaskExecutionEvent `protobuf:"bytes,1,opt,name=raw_event,json=rawEvent,proto3" json:"raw_event,omitempty"` + // We can't have the ExecutionMetadata object directly because of import cycle + Labels map[string]string `protobuf:"bytes,2,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *CloudEventTaskExecution) Reset() { + *x = CloudEventTaskExecution{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_event_cloudevents_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CloudEventTaskExecution) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CloudEventTaskExecution) ProtoMessage() {} + +func (x *CloudEventTaskExecution) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_event_cloudevents_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CloudEventTaskExecution.ProtoReflect.Descriptor instead. +func (*CloudEventTaskExecution) Descriptor() ([]byte, []int) { + return file_flyteidl2_event_cloudevents_proto_rawDescGZIP(), []int{2} +} + +func (x *CloudEventTaskExecution) GetRawEvent() *TaskExecutionEvent { + if x != nil { + return x.RawEvent + } + return nil +} + +func (x *CloudEventTaskExecution) GetLabels() map[string]string { + if x != nil { + return x.Labels + } + return nil +} + +// This event is to be sent by Admin after it creates an execution. +type CloudEventExecutionStart struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The execution created. + ExecutionId *core.WorkflowExecutionIdentifier `protobuf:"bytes,1,opt,name=execution_id,json=executionId,proto3" json:"execution_id,omitempty"` + // The launch plan used. + LaunchPlanId *core.Identifier `protobuf:"bytes,2,opt,name=launch_plan_id,json=launchPlanId,proto3" json:"launch_plan_id,omitempty"` + WorkflowId *core.Identifier `protobuf:"bytes,3,opt,name=workflow_id,json=workflowId,proto3" json:"workflow_id,omitempty"` + // Artifact inputs to the workflow execution for which we have the full Artifact ID. These are likely the result of artifact queries that are run. + ArtifactIds []*core.ArtifactID `protobuf:"bytes,4,rep,name=artifact_ids,json=artifactIds,proto3" json:"artifact_ids,omitempty"` + // Artifact inputs to the workflow execution for which we only have the tracking bit that's installed into the Literal's metadata by the Artifact service. + ArtifactTrackers []string `protobuf:"bytes,5,rep,name=artifact_trackers,json=artifactTrackers,proto3" json:"artifact_trackers,omitempty"` + Principal string `protobuf:"bytes,6,opt,name=principal,proto3" json:"principal,omitempty"` +} + +func (x *CloudEventExecutionStart) Reset() { + *x = CloudEventExecutionStart{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_event_cloudevents_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CloudEventExecutionStart) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CloudEventExecutionStart) ProtoMessage() {} + +func (x *CloudEventExecutionStart) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_event_cloudevents_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CloudEventExecutionStart.ProtoReflect.Descriptor instead. +func (*CloudEventExecutionStart) Descriptor() ([]byte, []int) { + return file_flyteidl2_event_cloudevents_proto_rawDescGZIP(), []int{3} +} + +func (x *CloudEventExecutionStart) GetExecutionId() *core.WorkflowExecutionIdentifier { + if x != nil { + return x.ExecutionId + } + return nil +} + +func (x *CloudEventExecutionStart) GetLaunchPlanId() *core.Identifier { + if x != nil { + return x.LaunchPlanId + } + return nil +} + +func (x *CloudEventExecutionStart) GetWorkflowId() *core.Identifier { + if x != nil { + return x.WorkflowId + } + return nil +} + +func (x *CloudEventExecutionStart) GetArtifactIds() []*core.ArtifactID { + if x != nil { + return x.ArtifactIds + } + return nil +} + +func (x *CloudEventExecutionStart) GetArtifactTrackers() []string { + if x != nil { + return x.ArtifactTrackers + } + return nil +} + +func (x *CloudEventExecutionStart) GetPrincipal() string { + if x != nil { + return x.Principal + } + return "" +} + +var File_flyteidl2_event_cloudevents_proto protoreflect.FileDescriptor + +var file_flyteidl2_event_cloudevents_proto_rawDesc = []byte{ + 0x0a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x2f, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x0f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, + 0x76, 0x65, 0x6e, 0x74, 0x1a, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x69, 0x64, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xb8, 0x04, 0x0a, 0x1b, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x45, 0x76, + 0x65, 0x6e, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x44, 0x0a, 0x09, 0x72, 0x61, 0x77, 0x5f, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x76, 0x65, 0x6e, 0x74, + 0x52, 0x08, 0x72, 0x61, 0x77, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x49, 0x0a, 0x10, 0x6f, 0x75, + 0x74, 0x70, 0x75, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x65, 0x72, + 0x66, 0x61, 0x63, 0x65, 0x52, 0x0f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x49, 0x6e, 0x74, 0x65, + 0x72, 0x66, 0x61, 0x63, 0x65, 0x12, 0x3d, 0x0a, 0x0c, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, + 0x74, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, + 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x44, 0x52, 0x0b, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, + 0x74, 0x49, 0x64, 0x73, 0x12, 0x5c, 0x0a, 0x13, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, + 0x65, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x12, + 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, + 0x12, 0x40, 0x0a, 0x0e, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x70, 0x6c, 0x61, 0x6e, 0x5f, + 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x52, 0x0c, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x50, 0x6c, 0x61, 0x6e, + 0x49, 0x64, 0x12, 0x50, 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x07, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, + 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x57, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x6c, 0x61, + 0x62, 0x65, 0x6c, 0x73, 0x1a, 0x39, 0x0a, 0x0b, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, + 0x99, 0x04, 0x0a, 0x17, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x4e, 0x6f, + 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x40, 0x0a, 0x09, 0x72, + 0x61, 0x77, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, + 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x76, + 0x65, 0x6e, 0x74, 0x52, 0x08, 0x72, 0x61, 0x77, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x49, 0x0a, + 0x0c, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x0a, 0x74, 0x61, + 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x49, 0x64, 0x12, 0x49, 0x0a, 0x10, 0x6f, 0x75, 0x74, 0x70, + 0x75, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, + 0x63, 0x65, 0x52, 0x0f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, + 0x61, 0x63, 0x65, 0x12, 0x3d, 0x0a, 0x0c, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, + 0x69, 0x64, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x66, + 0x61, 0x63, 0x74, 0x49, 0x44, 0x52, 0x0b, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, + 0x64, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, + 0x12, 0x40, 0x0a, 0x0e, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x70, 0x6c, 0x61, 0x6e, 0x5f, + 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x52, 0x0c, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x50, 0x6c, 0x61, 0x6e, + 0x49, 0x64, 0x12, 0x4c, 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x07, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, + 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x4e, + 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x4c, 0x61, 0x62, + 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, + 0x1a, 0x39, 0x0a, 0x0b, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, + 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, + 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xe4, 0x01, 0x0a, 0x17, + 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x40, 0x0a, 0x09, 0x72, 0x61, 0x77, 0x5f, 0x65, + 0x76, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x54, 0x61, 0x73, + 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, + 0x08, 0x72, 0x61, 0x77, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x4c, 0x0a, 0x06, 0x6c, 0x61, 0x62, + 0x65, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x43, 0x6c, 0x6f, 0x75, + 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, + 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x1a, 0x39, 0x0a, 0x0b, 0x4c, 0x61, 0x62, 0x65, 0x6c, + 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x22, 0xf3, 0x02, 0x0a, 0x18, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x45, 0x76, 0x65, 0x6e, + 0x74, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x72, 0x74, 0x12, + 0x4e, 0x0a, 0x0c, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x52, 0x0b, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, + 0x40, 0x0a, 0x0e, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x70, 0x6c, 0x61, 0x6e, 0x5f, 0x69, + 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x52, 0x0c, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x50, 0x6c, 0x61, 0x6e, 0x49, + 0x64, 0x12, 0x3b, 0x0a, 0x0b, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x69, 0x64, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x52, 0x0a, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x49, 0x64, 0x12, 0x3d, + 0x0a, 0x0c, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x04, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x44, + 0x52, 0x0b, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x64, 0x73, 0x12, 0x2b, 0x0a, + 0x11, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x65, + 0x72, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x10, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, + 0x63, 0x74, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x72, + 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, + 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x42, 0xbb, 0x01, 0x0a, 0x13, 0x63, 0x6f, 0x6d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, + 0x42, 0x10, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x50, 0x72, 0x6f, + 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0xa2, 0x02, 0x03, 0x46, 0x45, + 0x58, 0xaa, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x45, 0x76, + 0x65, 0x6e, 0x74, 0xca, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, + 0x45, 0x76, 0x65, 0x6e, 0x74, 0xe2, 0x02, 0x1b, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x5c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0xea, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, + 0x3a, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_event_cloudevents_proto_rawDescOnce sync.Once + file_flyteidl2_event_cloudevents_proto_rawDescData = file_flyteidl2_event_cloudevents_proto_rawDesc +) + +func file_flyteidl2_event_cloudevents_proto_rawDescGZIP() []byte { + file_flyteidl2_event_cloudevents_proto_rawDescOnce.Do(func() { + file_flyteidl2_event_cloudevents_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_event_cloudevents_proto_rawDescData) + }) + return file_flyteidl2_event_cloudevents_proto_rawDescData +} + +var file_flyteidl2_event_cloudevents_proto_msgTypes = make([]protoimpl.MessageInfo, 7) +var file_flyteidl2_event_cloudevents_proto_goTypes = []interface{}{ + (*CloudEventWorkflowExecution)(nil), // 0: flyteidl2.event.CloudEventWorkflowExecution + (*CloudEventNodeExecution)(nil), // 1: flyteidl2.event.CloudEventNodeExecution + (*CloudEventTaskExecution)(nil), // 2: flyteidl2.event.CloudEventTaskExecution + (*CloudEventExecutionStart)(nil), // 3: flyteidl2.event.CloudEventExecutionStart + nil, // 4: flyteidl2.event.CloudEventWorkflowExecution.LabelsEntry + nil, // 5: flyteidl2.event.CloudEventNodeExecution.LabelsEntry + nil, // 6: flyteidl2.event.CloudEventTaskExecution.LabelsEntry + (*WorkflowExecutionEvent)(nil), // 7: flyteidl2.event.WorkflowExecutionEvent + (*core.TypedInterface)(nil), // 8: flyteidl2.core.TypedInterface + (*core.ArtifactID)(nil), // 9: flyteidl2.core.ArtifactID + (*core.WorkflowExecutionIdentifier)(nil), // 10: flyteidl2.core.WorkflowExecutionIdentifier + (*core.Identifier)(nil), // 11: flyteidl2.core.Identifier + (*NodeExecutionEvent)(nil), // 12: flyteidl2.event.NodeExecutionEvent + (*core.TaskExecutionIdentifier)(nil), // 13: flyteidl2.core.TaskExecutionIdentifier + (*TaskExecutionEvent)(nil), // 14: flyteidl2.event.TaskExecutionEvent +} +var file_flyteidl2_event_cloudevents_proto_depIdxs = []int32{ + 7, // 0: flyteidl2.event.CloudEventWorkflowExecution.raw_event:type_name -> flyteidl2.event.WorkflowExecutionEvent + 8, // 1: flyteidl2.event.CloudEventWorkflowExecution.output_interface:type_name -> flyteidl2.core.TypedInterface + 9, // 2: flyteidl2.event.CloudEventWorkflowExecution.artifact_ids:type_name -> flyteidl2.core.ArtifactID + 10, // 3: flyteidl2.event.CloudEventWorkflowExecution.reference_execution:type_name -> flyteidl2.core.WorkflowExecutionIdentifier + 11, // 4: flyteidl2.event.CloudEventWorkflowExecution.launch_plan_id:type_name -> flyteidl2.core.Identifier + 4, // 5: flyteidl2.event.CloudEventWorkflowExecution.labels:type_name -> flyteidl2.event.CloudEventWorkflowExecution.LabelsEntry + 12, // 6: flyteidl2.event.CloudEventNodeExecution.raw_event:type_name -> flyteidl2.event.NodeExecutionEvent + 13, // 7: flyteidl2.event.CloudEventNodeExecution.task_exec_id:type_name -> flyteidl2.core.TaskExecutionIdentifier + 8, // 8: flyteidl2.event.CloudEventNodeExecution.output_interface:type_name -> flyteidl2.core.TypedInterface + 9, // 9: flyteidl2.event.CloudEventNodeExecution.artifact_ids:type_name -> flyteidl2.core.ArtifactID + 11, // 10: flyteidl2.event.CloudEventNodeExecution.launch_plan_id:type_name -> flyteidl2.core.Identifier + 5, // 11: flyteidl2.event.CloudEventNodeExecution.labels:type_name -> flyteidl2.event.CloudEventNodeExecution.LabelsEntry + 14, // 12: flyteidl2.event.CloudEventTaskExecution.raw_event:type_name -> flyteidl2.event.TaskExecutionEvent + 6, // 13: flyteidl2.event.CloudEventTaskExecution.labels:type_name -> flyteidl2.event.CloudEventTaskExecution.LabelsEntry + 10, // 14: flyteidl2.event.CloudEventExecutionStart.execution_id:type_name -> flyteidl2.core.WorkflowExecutionIdentifier + 11, // 15: flyteidl2.event.CloudEventExecutionStart.launch_plan_id:type_name -> flyteidl2.core.Identifier + 11, // 16: flyteidl2.event.CloudEventExecutionStart.workflow_id:type_name -> flyteidl2.core.Identifier + 9, // 17: flyteidl2.event.CloudEventExecutionStart.artifact_ids:type_name -> flyteidl2.core.ArtifactID + 18, // [18:18] is the sub-list for method output_type + 18, // [18:18] is the sub-list for method input_type + 18, // [18:18] is the sub-list for extension type_name + 18, // [18:18] is the sub-list for extension extendee + 0, // [0:18] is the sub-list for field type_name +} + +func init() { file_flyteidl2_event_cloudevents_proto_init() } +func file_flyteidl2_event_cloudevents_proto_init() { + if File_flyteidl2_event_cloudevents_proto != nil { + return + } + file_flyteidl2_event_event_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_event_cloudevents_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CloudEventWorkflowExecution); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_event_cloudevents_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CloudEventNodeExecution); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_event_cloudevents_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CloudEventTaskExecution); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_event_cloudevents_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CloudEventExecutionStart); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_event_cloudevents_proto_rawDesc, + NumEnums: 0, + NumMessages: 7, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_event_cloudevents_proto_goTypes, + DependencyIndexes: file_flyteidl2_event_cloudevents_proto_depIdxs, + MessageInfos: file_flyteidl2_event_cloudevents_proto_msgTypes, + }.Build() + File_flyteidl2_event_cloudevents_proto = out.File + file_flyteidl2_event_cloudevents_proto_rawDesc = nil + file_flyteidl2_event_cloudevents_proto_goTypes = nil + file_flyteidl2_event_cloudevents_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/event/cloudevents.pb.validate.go b/gen/go/flyteidl2/event/cloudevents.pb.validate.go new file mode 100644 index 0000000000..f00519e83f --- /dev/null +++ b/gen/go/flyteidl2/event/cloudevents.pb.validate.go @@ -0,0 +1,907 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/event/cloudevents.proto + +package event + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on CloudEventWorkflowExecution with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *CloudEventWorkflowExecution) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CloudEventWorkflowExecution with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CloudEventWorkflowExecutionMultiError, or nil if none found. +func (m *CloudEventWorkflowExecution) ValidateAll() error { + return m.validate(true) +} + +func (m *CloudEventWorkflowExecution) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRawEvent()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CloudEventWorkflowExecutionValidationError{ + field: "RawEvent", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CloudEventWorkflowExecutionValidationError{ + field: "RawEvent", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRawEvent()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CloudEventWorkflowExecutionValidationError{ + field: "RawEvent", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetOutputInterface()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CloudEventWorkflowExecutionValidationError{ + field: "OutputInterface", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CloudEventWorkflowExecutionValidationError{ + field: "OutputInterface", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOutputInterface()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CloudEventWorkflowExecutionValidationError{ + field: "OutputInterface", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetArtifactIds() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CloudEventWorkflowExecutionValidationError{ + field: fmt.Sprintf("ArtifactIds[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CloudEventWorkflowExecutionValidationError{ + field: fmt.Sprintf("ArtifactIds[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CloudEventWorkflowExecutionValidationError{ + field: fmt.Sprintf("ArtifactIds[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if all { + switch v := interface{}(m.GetReferenceExecution()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CloudEventWorkflowExecutionValidationError{ + field: "ReferenceExecution", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CloudEventWorkflowExecutionValidationError{ + field: "ReferenceExecution", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetReferenceExecution()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CloudEventWorkflowExecutionValidationError{ + field: "ReferenceExecution", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Principal + + if all { + switch v := interface{}(m.GetLaunchPlanId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CloudEventWorkflowExecutionValidationError{ + field: "LaunchPlanId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CloudEventWorkflowExecutionValidationError{ + field: "LaunchPlanId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLaunchPlanId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CloudEventWorkflowExecutionValidationError{ + field: "LaunchPlanId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Labels + + if len(errors) > 0 { + return CloudEventWorkflowExecutionMultiError(errors) + } + + return nil +} + +// CloudEventWorkflowExecutionMultiError is an error wrapping multiple +// validation errors returned by CloudEventWorkflowExecution.ValidateAll() if +// the designated constraints aren't met. +type CloudEventWorkflowExecutionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CloudEventWorkflowExecutionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CloudEventWorkflowExecutionMultiError) AllErrors() []error { return m } + +// CloudEventWorkflowExecutionValidationError is the validation error returned +// by CloudEventWorkflowExecution.Validate if the designated constraints +// aren't met. +type CloudEventWorkflowExecutionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CloudEventWorkflowExecutionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CloudEventWorkflowExecutionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CloudEventWorkflowExecutionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CloudEventWorkflowExecutionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CloudEventWorkflowExecutionValidationError) ErrorName() string { + return "CloudEventWorkflowExecutionValidationError" +} + +// Error satisfies the builtin error interface +func (e CloudEventWorkflowExecutionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCloudEventWorkflowExecution.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CloudEventWorkflowExecutionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CloudEventWorkflowExecutionValidationError{} + +// Validate checks the field values on CloudEventNodeExecution with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *CloudEventNodeExecution) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CloudEventNodeExecution with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CloudEventNodeExecutionMultiError, or nil if none found. +func (m *CloudEventNodeExecution) ValidateAll() error { + return m.validate(true) +} + +func (m *CloudEventNodeExecution) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRawEvent()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CloudEventNodeExecutionValidationError{ + field: "RawEvent", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CloudEventNodeExecutionValidationError{ + field: "RawEvent", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRawEvent()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CloudEventNodeExecutionValidationError{ + field: "RawEvent", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetTaskExecId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CloudEventNodeExecutionValidationError{ + field: "TaskExecId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CloudEventNodeExecutionValidationError{ + field: "TaskExecId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskExecId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CloudEventNodeExecutionValidationError{ + field: "TaskExecId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetOutputInterface()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CloudEventNodeExecutionValidationError{ + field: "OutputInterface", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CloudEventNodeExecutionValidationError{ + field: "OutputInterface", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOutputInterface()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CloudEventNodeExecutionValidationError{ + field: "OutputInterface", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetArtifactIds() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CloudEventNodeExecutionValidationError{ + field: fmt.Sprintf("ArtifactIds[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CloudEventNodeExecutionValidationError{ + field: fmt.Sprintf("ArtifactIds[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CloudEventNodeExecutionValidationError{ + field: fmt.Sprintf("ArtifactIds[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Principal + + if all { + switch v := interface{}(m.GetLaunchPlanId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CloudEventNodeExecutionValidationError{ + field: "LaunchPlanId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CloudEventNodeExecutionValidationError{ + field: "LaunchPlanId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLaunchPlanId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CloudEventNodeExecutionValidationError{ + field: "LaunchPlanId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Labels + + if len(errors) > 0 { + return CloudEventNodeExecutionMultiError(errors) + } + + return nil +} + +// CloudEventNodeExecutionMultiError is an error wrapping multiple validation +// errors returned by CloudEventNodeExecution.ValidateAll() if the designated +// constraints aren't met. +type CloudEventNodeExecutionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CloudEventNodeExecutionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CloudEventNodeExecutionMultiError) AllErrors() []error { return m } + +// CloudEventNodeExecutionValidationError is the validation error returned by +// CloudEventNodeExecution.Validate if the designated constraints aren't met. +type CloudEventNodeExecutionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CloudEventNodeExecutionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CloudEventNodeExecutionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CloudEventNodeExecutionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CloudEventNodeExecutionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CloudEventNodeExecutionValidationError) ErrorName() string { + return "CloudEventNodeExecutionValidationError" +} + +// Error satisfies the builtin error interface +func (e CloudEventNodeExecutionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCloudEventNodeExecution.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CloudEventNodeExecutionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CloudEventNodeExecutionValidationError{} + +// Validate checks the field values on CloudEventTaskExecution with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *CloudEventTaskExecution) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CloudEventTaskExecution with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CloudEventTaskExecutionMultiError, or nil if none found. +func (m *CloudEventTaskExecution) ValidateAll() error { + return m.validate(true) +} + +func (m *CloudEventTaskExecution) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRawEvent()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CloudEventTaskExecutionValidationError{ + field: "RawEvent", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CloudEventTaskExecutionValidationError{ + field: "RawEvent", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRawEvent()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CloudEventTaskExecutionValidationError{ + field: "RawEvent", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Labels + + if len(errors) > 0 { + return CloudEventTaskExecutionMultiError(errors) + } + + return nil +} + +// CloudEventTaskExecutionMultiError is an error wrapping multiple validation +// errors returned by CloudEventTaskExecution.ValidateAll() if the designated +// constraints aren't met. +type CloudEventTaskExecutionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CloudEventTaskExecutionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CloudEventTaskExecutionMultiError) AllErrors() []error { return m } + +// CloudEventTaskExecutionValidationError is the validation error returned by +// CloudEventTaskExecution.Validate if the designated constraints aren't met. +type CloudEventTaskExecutionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CloudEventTaskExecutionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CloudEventTaskExecutionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CloudEventTaskExecutionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CloudEventTaskExecutionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CloudEventTaskExecutionValidationError) ErrorName() string { + return "CloudEventTaskExecutionValidationError" +} + +// Error satisfies the builtin error interface +func (e CloudEventTaskExecutionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCloudEventTaskExecution.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CloudEventTaskExecutionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CloudEventTaskExecutionValidationError{} + +// Validate checks the field values on CloudEventExecutionStart with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *CloudEventExecutionStart) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CloudEventExecutionStart with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CloudEventExecutionStartMultiError, or nil if none found. +func (m *CloudEventExecutionStart) ValidateAll() error { + return m.validate(true) +} + +func (m *CloudEventExecutionStart) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetExecutionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CloudEventExecutionStartValidationError{ + field: "ExecutionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CloudEventExecutionStartValidationError{ + field: "ExecutionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetExecutionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CloudEventExecutionStartValidationError{ + field: "ExecutionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetLaunchPlanId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CloudEventExecutionStartValidationError{ + field: "LaunchPlanId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CloudEventExecutionStartValidationError{ + field: "LaunchPlanId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLaunchPlanId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CloudEventExecutionStartValidationError{ + field: "LaunchPlanId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetWorkflowId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CloudEventExecutionStartValidationError{ + field: "WorkflowId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CloudEventExecutionStartValidationError{ + field: "WorkflowId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetWorkflowId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CloudEventExecutionStartValidationError{ + field: "WorkflowId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetArtifactIds() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CloudEventExecutionStartValidationError{ + field: fmt.Sprintf("ArtifactIds[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CloudEventExecutionStartValidationError{ + field: fmt.Sprintf("ArtifactIds[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CloudEventExecutionStartValidationError{ + field: fmt.Sprintf("ArtifactIds[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Principal + + if len(errors) > 0 { + return CloudEventExecutionStartMultiError(errors) + } + + return nil +} + +// CloudEventExecutionStartMultiError is an error wrapping multiple validation +// errors returned by CloudEventExecutionStart.ValidateAll() if the designated +// constraints aren't met. +type CloudEventExecutionStartMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CloudEventExecutionStartMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CloudEventExecutionStartMultiError) AllErrors() []error { return m } + +// CloudEventExecutionStartValidationError is the validation error returned by +// CloudEventExecutionStart.Validate if the designated constraints aren't met. +type CloudEventExecutionStartValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CloudEventExecutionStartValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CloudEventExecutionStartValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CloudEventExecutionStartValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CloudEventExecutionStartValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CloudEventExecutionStartValidationError) ErrorName() string { + return "CloudEventExecutionStartValidationError" +} + +// Error satisfies the builtin error interface +func (e CloudEventExecutionStartValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCloudEventExecutionStart.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CloudEventExecutionStartValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CloudEventExecutionStartValidationError{} diff --git a/gen/go/flyteidl2/event/event.pb.go b/gen/go/flyteidl2/event/event.pb.go new file mode 100644 index 0000000000..2edec2a5bf --- /dev/null +++ b/gen/go/flyteidl2/event/event.pb.go @@ -0,0 +1,2042 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/event/event.proto + +package event + +import ( + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + structpb "google.golang.org/protobuf/types/known/structpb" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Includes the broad category of machine used for this specific task execution. +type TaskExecutionMetadata_InstanceClass int32 + +const ( + // The default instance class configured for the flyte application platform. + TaskExecutionMetadata_DEFAULT TaskExecutionMetadata_InstanceClass = 0 + // The instance class configured for interruptible tasks. + TaskExecutionMetadata_INTERRUPTIBLE TaskExecutionMetadata_InstanceClass = 1 +) + +// Enum value maps for TaskExecutionMetadata_InstanceClass. +var ( + TaskExecutionMetadata_InstanceClass_name = map[int32]string{ + 0: "DEFAULT", + 1: "INTERRUPTIBLE", + } + TaskExecutionMetadata_InstanceClass_value = map[string]int32{ + "DEFAULT": 0, + "INTERRUPTIBLE": 1, + } +) + +func (x TaskExecutionMetadata_InstanceClass) Enum() *TaskExecutionMetadata_InstanceClass { + p := new(TaskExecutionMetadata_InstanceClass) + *p = x + return p +} + +func (x TaskExecutionMetadata_InstanceClass) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (TaskExecutionMetadata_InstanceClass) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_event_event_proto_enumTypes[0].Descriptor() +} + +func (TaskExecutionMetadata_InstanceClass) Type() protoreflect.EnumType { + return &file_flyteidl2_event_event_proto_enumTypes[0] +} + +func (x TaskExecutionMetadata_InstanceClass) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use TaskExecutionMetadata_InstanceClass.Descriptor instead. +func (TaskExecutionMetadata_InstanceClass) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_event_event_proto_rawDescGZIP(), []int{10, 0} +} + +type WorkflowExecutionEvent struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Workflow execution id + ExecutionId *core.WorkflowExecutionIdentifier `protobuf:"bytes,1,opt,name=execution_id,json=executionId,proto3" json:"execution_id,omitempty"` + // the id of the originator (Propeller) of the event + ProducerId string `protobuf:"bytes,2,opt,name=producer_id,json=producerId,proto3" json:"producer_id,omitempty"` + Phase core.WorkflowExecution_Phase `protobuf:"varint,3,opt,name=phase,proto3,enum=flyteidl2.core.WorkflowExecution_Phase" json:"phase,omitempty"` + // This timestamp represents when the original event occurred, it is generated + // by the executor of the workflow. + OccurredAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=occurred_at,json=occurredAt,proto3" json:"occurred_at,omitempty"` + // Types that are assignable to OutputResult: + // + // *WorkflowExecutionEvent_OutputUri + // *WorkflowExecutionEvent_Error + // *WorkflowExecutionEvent_OutputData + OutputResult isWorkflowExecutionEvent_OutputResult `protobuf_oneof:"output_result"` +} + +func (x *WorkflowExecutionEvent) Reset() { + *x = WorkflowExecutionEvent{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_event_event_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WorkflowExecutionEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorkflowExecutionEvent) ProtoMessage() {} + +func (x *WorkflowExecutionEvent) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_event_event_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorkflowExecutionEvent.ProtoReflect.Descriptor instead. +func (*WorkflowExecutionEvent) Descriptor() ([]byte, []int) { + return file_flyteidl2_event_event_proto_rawDescGZIP(), []int{0} +} + +func (x *WorkflowExecutionEvent) GetExecutionId() *core.WorkflowExecutionIdentifier { + if x != nil { + return x.ExecutionId + } + return nil +} + +func (x *WorkflowExecutionEvent) GetProducerId() string { + if x != nil { + return x.ProducerId + } + return "" +} + +func (x *WorkflowExecutionEvent) GetPhase() core.WorkflowExecution_Phase { + if x != nil { + return x.Phase + } + return core.WorkflowExecution_Phase(0) +} + +func (x *WorkflowExecutionEvent) GetOccurredAt() *timestamppb.Timestamp { + if x != nil { + return x.OccurredAt + } + return nil +} + +func (m *WorkflowExecutionEvent) GetOutputResult() isWorkflowExecutionEvent_OutputResult { + if m != nil { + return m.OutputResult + } + return nil +} + +func (x *WorkflowExecutionEvent) GetOutputUri() string { + if x, ok := x.GetOutputResult().(*WorkflowExecutionEvent_OutputUri); ok { + return x.OutputUri + } + return "" +} + +func (x *WorkflowExecutionEvent) GetError() *core.ExecutionError { + if x, ok := x.GetOutputResult().(*WorkflowExecutionEvent_Error); ok { + return x.Error + } + return nil +} + +func (x *WorkflowExecutionEvent) GetOutputData() *core.LiteralMap { + if x, ok := x.GetOutputResult().(*WorkflowExecutionEvent_OutputData); ok { + return x.OutputData + } + return nil +} + +type isWorkflowExecutionEvent_OutputResult interface { + isWorkflowExecutionEvent_OutputResult() +} + +type WorkflowExecutionEvent_OutputUri struct { + // URL to the output of the execution, it encodes all the information + // including Cloud source provider. ie., s3://... + OutputUri string `protobuf:"bytes,5,opt,name=output_uri,json=outputUri,proto3,oneof"` +} + +type WorkflowExecutionEvent_Error struct { + // Error information for the execution + Error *core.ExecutionError `protobuf:"bytes,6,opt,name=error,proto3,oneof"` +} + +type WorkflowExecutionEvent_OutputData struct { + // Raw output data produced by this workflow execution. + OutputData *core.LiteralMap `protobuf:"bytes,7,opt,name=output_data,json=outputData,proto3,oneof"` +} + +func (*WorkflowExecutionEvent_OutputUri) isWorkflowExecutionEvent_OutputResult() {} + +func (*WorkflowExecutionEvent_Error) isWorkflowExecutionEvent_OutputResult() {} + +func (*WorkflowExecutionEvent_OutputData) isWorkflowExecutionEvent_OutputResult() {} + +type NodeExecutionEvent struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Unique identifier for this node execution + Id *core.NodeExecutionIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // the id of the originator (Propeller) of the event + ProducerId string `protobuf:"bytes,2,opt,name=producer_id,json=producerId,proto3" json:"producer_id,omitempty"` + Phase core.NodeExecution_Phase `protobuf:"varint,3,opt,name=phase,proto3,enum=flyteidl2.core.NodeExecution_Phase" json:"phase,omitempty"` + // This timestamp represents when the original event occurred, it is generated + // by the executor of the node. + OccurredAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=occurred_at,json=occurredAt,proto3" json:"occurred_at,omitempty"` + // Types that are assignable to InputValue: + // + // *NodeExecutionEvent_InputUri + // *NodeExecutionEvent_InputData + InputValue isNodeExecutionEvent_InputValue `protobuf_oneof:"input_value"` + // Types that are assignable to OutputResult: + // + // *NodeExecutionEvent_OutputUri + // *NodeExecutionEvent_Error + // *NodeExecutionEvent_OutputData + OutputResult isNodeExecutionEvent_OutputResult `protobuf_oneof:"output_result"` + // Additional metadata to do with this event's node target based + // on the node type + // + // Types that are assignable to TargetMetadata: + // + // *NodeExecutionEvent_WorkflowNodeMetadata + // *NodeExecutionEvent_TaskNodeMetadata + TargetMetadata isNodeExecutionEvent_TargetMetadata `protobuf_oneof:"target_metadata"` + // [To be deprecated] Specifies which task (if any) launched this node. + ParentTaskMetadata *ParentTaskExecutionMetadata `protobuf:"bytes,9,opt,name=parent_task_metadata,json=parentTaskMetadata,proto3" json:"parent_task_metadata,omitempty"` + // Specifies the parent node of the current node execution. Node executions at level zero will not have a parent node. + ParentNodeMetadata *ParentNodeExecutionMetadata `protobuf:"bytes,10,opt,name=parent_node_metadata,json=parentNodeMetadata,proto3" json:"parent_node_metadata,omitempty"` + // Retry group to indicate grouping of nodes by retries + RetryGroup string `protobuf:"bytes,11,opt,name=retry_group,json=retryGroup,proto3" json:"retry_group,omitempty"` + // Identifier of the node in the original workflow/graph + // This maps to value of WorkflowTemplate.nodes[X].id + SpecNodeId string `protobuf:"bytes,12,opt,name=spec_node_id,json=specNodeId,proto3" json:"spec_node_id,omitempty"` + // Friendly readable name for the node + NodeName string `protobuf:"bytes,13,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"` + EventVersion int32 `protobuf:"varint,16,opt,name=event_version,json=eventVersion,proto3" json:"event_version,omitempty"` + // Whether this node launched a subworkflow. + IsParent bool `protobuf:"varint,17,opt,name=is_parent,json=isParent,proto3" json:"is_parent,omitempty"` + // Whether this node yielded a dynamic workflow. + IsDynamic bool `protobuf:"varint,18,opt,name=is_dynamic,json=isDynamic,proto3" json:"is_dynamic,omitempty"` + // String location uniquely identifying where the deck HTML file is + // NativeUrl specifies the url in the format of the configured storage provider (e.g. s3://my-bucket/randomstring/suffix.tar) + DeckUri string `protobuf:"bytes,19,opt,name=deck_uri,json=deckUri,proto3" json:"deck_uri,omitempty"` + // This timestamp represents the instant when the event was reported by the executing framework. For example, + // when first processing a node the `occurred_at` timestamp should be the instant propeller makes progress, so when + // literal inputs are initially copied. The event however will not be sent until after the copy completes. + // Extracting both of these timestamps facilitates a more accurate portrayal of the evaluation time-series. + ReportedAt *timestamppb.Timestamp `protobuf:"bytes,21,opt,name=reported_at,json=reportedAt,proto3" json:"reported_at,omitempty"` + // Indicates if this node is an ArrayNode. + IsArray bool `protobuf:"varint,22,opt,name=is_array,json=isArray,proto3" json:"is_array,omitempty"` + // So that Admin doesn't have to rebuild the node execution graph to find the target entity, propeller will fill this + // in optionally - currently this is only filled in for subworkflows. This is the ID of the subworkflow corresponding + // to this node execution. It is difficult to find because Admin only sees one node at a time. A subworkflow could be + // nested multiple layers deep, and you'd need to access the correct workflow template to know the target subworkflow. + TargetEntity *core.Identifier `protobuf:"bytes,23,opt,name=target_entity,json=targetEntity,proto3" json:"target_entity,omitempty"` + // Tasks and subworkflows (but not launch plans) that are run within a dynamic task are effectively independent of + // the tasks that are registered in Admin's db. Confusingly, they are often identical, but sometimes they are not + // even registered at all. Similar to the target_entity field, at the time Admin receives this event, it has no idea + // if the relevant execution entity is was registered, or dynamic. This field indicates that the target_entity ID, + // as well as task IDs in any corresponding Task Executions, should not be used to looked up the task in Admin's db. + IsInDynamicChain bool `protobuf:"varint,24,opt,name=is_in_dynamic_chain,json=isInDynamicChain,proto3" json:"is_in_dynamic_chain,omitempty"` + // Whether this node launched an eager task. + IsEager bool `protobuf:"varint,25,opt,name=is_eager,json=isEager,proto3" json:"is_eager,omitempty"` +} + +func (x *NodeExecutionEvent) Reset() { + *x = NodeExecutionEvent{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_event_event_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NodeExecutionEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NodeExecutionEvent) ProtoMessage() {} + +func (x *NodeExecutionEvent) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_event_event_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NodeExecutionEvent.ProtoReflect.Descriptor instead. +func (*NodeExecutionEvent) Descriptor() ([]byte, []int) { + return file_flyteidl2_event_event_proto_rawDescGZIP(), []int{1} +} + +func (x *NodeExecutionEvent) GetId() *core.NodeExecutionIdentifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *NodeExecutionEvent) GetProducerId() string { + if x != nil { + return x.ProducerId + } + return "" +} + +func (x *NodeExecutionEvent) GetPhase() core.NodeExecution_Phase { + if x != nil { + return x.Phase + } + return core.NodeExecution_Phase(0) +} + +func (x *NodeExecutionEvent) GetOccurredAt() *timestamppb.Timestamp { + if x != nil { + return x.OccurredAt + } + return nil +} + +func (m *NodeExecutionEvent) GetInputValue() isNodeExecutionEvent_InputValue { + if m != nil { + return m.InputValue + } + return nil +} + +func (x *NodeExecutionEvent) GetInputUri() string { + if x, ok := x.GetInputValue().(*NodeExecutionEvent_InputUri); ok { + return x.InputUri + } + return "" +} + +func (x *NodeExecutionEvent) GetInputData() *core.LiteralMap { + if x, ok := x.GetInputValue().(*NodeExecutionEvent_InputData); ok { + return x.InputData + } + return nil +} + +func (m *NodeExecutionEvent) GetOutputResult() isNodeExecutionEvent_OutputResult { + if m != nil { + return m.OutputResult + } + return nil +} + +func (x *NodeExecutionEvent) GetOutputUri() string { + if x, ok := x.GetOutputResult().(*NodeExecutionEvent_OutputUri); ok { + return x.OutputUri + } + return "" +} + +func (x *NodeExecutionEvent) GetError() *core.ExecutionError { + if x, ok := x.GetOutputResult().(*NodeExecutionEvent_Error); ok { + return x.Error + } + return nil +} + +func (x *NodeExecutionEvent) GetOutputData() *core.LiteralMap { + if x, ok := x.GetOutputResult().(*NodeExecutionEvent_OutputData); ok { + return x.OutputData + } + return nil +} + +func (m *NodeExecutionEvent) GetTargetMetadata() isNodeExecutionEvent_TargetMetadata { + if m != nil { + return m.TargetMetadata + } + return nil +} + +func (x *NodeExecutionEvent) GetWorkflowNodeMetadata() *WorkflowNodeMetadata { + if x, ok := x.GetTargetMetadata().(*NodeExecutionEvent_WorkflowNodeMetadata); ok { + return x.WorkflowNodeMetadata + } + return nil +} + +func (x *NodeExecutionEvent) GetTaskNodeMetadata() *TaskNodeMetadata { + if x, ok := x.GetTargetMetadata().(*NodeExecutionEvent_TaskNodeMetadata); ok { + return x.TaskNodeMetadata + } + return nil +} + +func (x *NodeExecutionEvent) GetParentTaskMetadata() *ParentTaskExecutionMetadata { + if x != nil { + return x.ParentTaskMetadata + } + return nil +} + +func (x *NodeExecutionEvent) GetParentNodeMetadata() *ParentNodeExecutionMetadata { + if x != nil { + return x.ParentNodeMetadata + } + return nil +} + +func (x *NodeExecutionEvent) GetRetryGroup() string { + if x != nil { + return x.RetryGroup + } + return "" +} + +func (x *NodeExecutionEvent) GetSpecNodeId() string { + if x != nil { + return x.SpecNodeId + } + return "" +} + +func (x *NodeExecutionEvent) GetNodeName() string { + if x != nil { + return x.NodeName + } + return "" +} + +func (x *NodeExecutionEvent) GetEventVersion() int32 { + if x != nil { + return x.EventVersion + } + return 0 +} + +func (x *NodeExecutionEvent) GetIsParent() bool { + if x != nil { + return x.IsParent + } + return false +} + +func (x *NodeExecutionEvent) GetIsDynamic() bool { + if x != nil { + return x.IsDynamic + } + return false +} + +func (x *NodeExecutionEvent) GetDeckUri() string { + if x != nil { + return x.DeckUri + } + return "" +} + +func (x *NodeExecutionEvent) GetReportedAt() *timestamppb.Timestamp { + if x != nil { + return x.ReportedAt + } + return nil +} + +func (x *NodeExecutionEvent) GetIsArray() bool { + if x != nil { + return x.IsArray + } + return false +} + +func (x *NodeExecutionEvent) GetTargetEntity() *core.Identifier { + if x != nil { + return x.TargetEntity + } + return nil +} + +func (x *NodeExecutionEvent) GetIsInDynamicChain() bool { + if x != nil { + return x.IsInDynamicChain + } + return false +} + +func (x *NodeExecutionEvent) GetIsEager() bool { + if x != nil { + return x.IsEager + } + return false +} + +type isNodeExecutionEvent_InputValue interface { + isNodeExecutionEvent_InputValue() +} + +type NodeExecutionEvent_InputUri struct { + InputUri string `protobuf:"bytes,5,opt,name=input_uri,json=inputUri,proto3,oneof"` +} + +type NodeExecutionEvent_InputData struct { + // Raw input data consumed by this node execution. + InputData *core.LiteralMap `protobuf:"bytes,20,opt,name=input_data,json=inputData,proto3,oneof"` +} + +func (*NodeExecutionEvent_InputUri) isNodeExecutionEvent_InputValue() {} + +func (*NodeExecutionEvent_InputData) isNodeExecutionEvent_InputValue() {} + +type isNodeExecutionEvent_OutputResult interface { + isNodeExecutionEvent_OutputResult() +} + +type NodeExecutionEvent_OutputUri struct { + // URL to the output of the execution, it encodes all the information + // including Cloud source provider. ie., s3://... + OutputUri string `protobuf:"bytes,6,opt,name=output_uri,json=outputUri,proto3,oneof"` +} + +type NodeExecutionEvent_Error struct { + // Error information for the execution + Error *core.ExecutionError `protobuf:"bytes,7,opt,name=error,proto3,oneof"` +} + +type NodeExecutionEvent_OutputData struct { + // Raw output data produced by this node execution. + OutputData *core.LiteralMap `protobuf:"bytes,15,opt,name=output_data,json=outputData,proto3,oneof"` +} + +func (*NodeExecutionEvent_OutputUri) isNodeExecutionEvent_OutputResult() {} + +func (*NodeExecutionEvent_Error) isNodeExecutionEvent_OutputResult() {} + +func (*NodeExecutionEvent_OutputData) isNodeExecutionEvent_OutputResult() {} + +type isNodeExecutionEvent_TargetMetadata interface { + isNodeExecutionEvent_TargetMetadata() +} + +type NodeExecutionEvent_WorkflowNodeMetadata struct { + WorkflowNodeMetadata *WorkflowNodeMetadata `protobuf:"bytes,8,opt,name=workflow_node_metadata,json=workflowNodeMetadata,proto3,oneof"` +} + +type NodeExecutionEvent_TaskNodeMetadata struct { + TaskNodeMetadata *TaskNodeMetadata `protobuf:"bytes,14,opt,name=task_node_metadata,json=taskNodeMetadata,proto3,oneof"` +} + +func (*NodeExecutionEvent_WorkflowNodeMetadata) isNodeExecutionEvent_TargetMetadata() {} + +func (*NodeExecutionEvent_TaskNodeMetadata) isNodeExecutionEvent_TargetMetadata() {} + +// For Workflow Nodes we need to send information about the workflow that's launched +type WorkflowNodeMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ExecutionId *core.WorkflowExecutionIdentifier `protobuf:"bytes,1,opt,name=execution_id,json=executionId,proto3" json:"execution_id,omitempty"` +} + +func (x *WorkflowNodeMetadata) Reset() { + *x = WorkflowNodeMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_event_event_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WorkflowNodeMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorkflowNodeMetadata) ProtoMessage() {} + +func (x *WorkflowNodeMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_event_event_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorkflowNodeMetadata.ProtoReflect.Descriptor instead. +func (*WorkflowNodeMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_event_event_proto_rawDescGZIP(), []int{2} +} + +func (x *WorkflowNodeMetadata) GetExecutionId() *core.WorkflowExecutionIdentifier { + if x != nil { + return x.ExecutionId + } + return nil +} + +type TaskNodeMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Captures the status of caching for this execution. + CacheStatus core.CatalogCacheStatus `protobuf:"varint,1,opt,name=cache_status,json=cacheStatus,proto3,enum=flyteidl2.core.CatalogCacheStatus" json:"cache_status,omitempty"` + // This structure carries the catalog artifact information + CatalogKey *core.CatalogMetadata `protobuf:"bytes,2,opt,name=catalog_key,json=catalogKey,proto3" json:"catalog_key,omitempty"` + // Captures the status of cache reservations for this execution. + ReservationStatus core.CatalogReservation_Status `protobuf:"varint,3,opt,name=reservation_status,json=reservationStatus,proto3,enum=flyteidl2.core.CatalogReservation_Status" json:"reservation_status,omitempty"` + // The latest checkpoint location + CheckpointUri string `protobuf:"bytes,4,opt,name=checkpoint_uri,json=checkpointUri,proto3" json:"checkpoint_uri,omitempty"` +} + +func (x *TaskNodeMetadata) Reset() { + *x = TaskNodeMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_event_event_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskNodeMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskNodeMetadata) ProtoMessage() {} + +func (x *TaskNodeMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_event_event_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskNodeMetadata.ProtoReflect.Descriptor instead. +func (*TaskNodeMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_event_event_proto_rawDescGZIP(), []int{3} +} + +func (x *TaskNodeMetadata) GetCacheStatus() core.CatalogCacheStatus { + if x != nil { + return x.CacheStatus + } + return core.CatalogCacheStatus(0) +} + +func (x *TaskNodeMetadata) GetCatalogKey() *core.CatalogMetadata { + if x != nil { + return x.CatalogKey + } + return nil +} + +func (x *TaskNodeMetadata) GetReservationStatus() core.CatalogReservation_Status { + if x != nil { + return x.ReservationStatus + } + return core.CatalogReservation_Status(0) +} + +func (x *TaskNodeMetadata) GetCheckpointUri() string { + if x != nil { + return x.CheckpointUri + } + return "" +} + +type ParentTaskExecutionMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id *core.TaskExecutionIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` +} + +func (x *ParentTaskExecutionMetadata) Reset() { + *x = ParentTaskExecutionMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_event_event_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ParentTaskExecutionMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ParentTaskExecutionMetadata) ProtoMessage() {} + +func (x *ParentTaskExecutionMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_event_event_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ParentTaskExecutionMetadata.ProtoReflect.Descriptor instead. +func (*ParentTaskExecutionMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_event_event_proto_rawDescGZIP(), []int{4} +} + +func (x *ParentTaskExecutionMetadata) GetId() *core.TaskExecutionIdentifier { + if x != nil { + return x.Id + } + return nil +} + +type ParentNodeExecutionMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Unique identifier of the parent node id within the execution + // This is value of core.NodeExecutionIdentifier.node_id of the parent node + NodeId string `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"` +} + +func (x *ParentNodeExecutionMetadata) Reset() { + *x = ParentNodeExecutionMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_event_event_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ParentNodeExecutionMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ParentNodeExecutionMetadata) ProtoMessage() {} + +func (x *ParentNodeExecutionMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_event_event_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ParentNodeExecutionMetadata.ProtoReflect.Descriptor instead. +func (*ParentNodeExecutionMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_event_event_proto_rawDescGZIP(), []int{5} +} + +func (x *ParentNodeExecutionMetadata) GetNodeId() string { + if x != nil { + return x.NodeId + } + return "" +} + +type EventReason struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // An explanation for this event + Reason string `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"` + // The time this reason occurred + OccurredAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=occurred_at,json=occurredAt,proto3" json:"occurred_at,omitempty"` +} + +func (x *EventReason) Reset() { + *x = EventReason{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_event_event_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EventReason) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EventReason) ProtoMessage() {} + +func (x *EventReason) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_event_event_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EventReason.ProtoReflect.Descriptor instead. +func (*EventReason) Descriptor() ([]byte, []int) { + return file_flyteidl2_event_event_proto_rawDescGZIP(), []int{6} +} + +func (x *EventReason) GetReason() string { + if x != nil { + return x.Reason + } + return "" +} + +func (x *EventReason) GetOccurredAt() *timestamppb.Timestamp { + if x != nil { + return x.OccurredAt + } + return nil +} + +// Plugin specific execution event information. For tasks like Python, Hive, Spark, DynamicJob. +type TaskExecutionEvent struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // ID of the task. In combination with the retryAttempt this will indicate + // the task execution uniquely for a given parent node execution. + TaskId *core.Identifier `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"` + // A task execution is always kicked off by a node execution, the event consumer + // will use the parent_id to relate the task to it's parent node execution + ParentNodeExecutionId *core.NodeExecutionIdentifier `protobuf:"bytes,2,opt,name=parent_node_execution_id,json=parentNodeExecutionId,proto3" json:"parent_node_execution_id,omitempty"` + // retry attempt number for this task, ie., 2 for the second attempt + RetryAttempt uint32 `protobuf:"varint,3,opt,name=retry_attempt,json=retryAttempt,proto3" json:"retry_attempt,omitempty"` + // Phase associated with the event + Phase core.TaskExecution_Phase `protobuf:"varint,4,opt,name=phase,proto3,enum=flyteidl2.core.TaskExecution_Phase" json:"phase,omitempty"` + // id of the process that sent this event, mainly for trace debugging + ProducerId string `protobuf:"bytes,5,opt,name=producer_id,json=producerId,proto3" json:"producer_id,omitempty"` + // log information for the task execution + Logs []*core.TaskLog `protobuf:"bytes,6,rep,name=logs,proto3" json:"logs,omitempty"` + // This timestamp represents when the original event occurred, it is generated + // by the executor of the task. + OccurredAt *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=occurred_at,json=occurredAt,proto3" json:"occurred_at,omitempty"` + // Types that are assignable to InputValue: + // + // *TaskExecutionEvent_InputUri + // *TaskExecutionEvent_InputData + InputValue isTaskExecutionEvent_InputValue `protobuf_oneof:"input_value"` + // Types that are assignable to OutputResult: + // + // *TaskExecutionEvent_OutputUri + // *TaskExecutionEvent_Error + // *TaskExecutionEvent_OutputData + OutputResult isTaskExecutionEvent_OutputResult `protobuf_oneof:"output_result"` + // Custom data that the task plugin sends back. This is extensible to allow various plugins in the system. + CustomInfo *structpb.Struct `protobuf:"bytes,11,opt,name=custom_info,json=customInfo,proto3" json:"custom_info,omitempty"` + // Some phases, like RUNNING, can send multiple events with changed metadata (new logs, additional custom_info, etc) + // that should be recorded regardless of the lack of phase change. + // The version field should be incremented when metadata changes across the duration of an individual phase. + PhaseVersion uint32 `protobuf:"varint,12,opt,name=phase_version,json=phaseVersion,proto3" json:"phase_version,omitempty"` + // An optional explanation for the phase transition. + // Deprecated: Use reasons instead. + // + // Deprecated: Marked as deprecated in flyteidl2/event/event.proto. + Reason string `protobuf:"bytes,13,opt,name=reason,proto3" json:"reason,omitempty"` + // An optional list of explanations for the phase transition. + Reasons []*EventReason `protobuf:"bytes,21,rep,name=reasons,proto3" json:"reasons,omitempty"` + // A predefined yet extensible Task type identifier. If the task definition is already registered in flyte admin + // this type will be identical, but not all task executions necessarily use pre-registered definitions and this + // type is useful to render the task in the UI, filter task executions, etc. + TaskType string `protobuf:"bytes,14,opt,name=task_type,json=taskType,proto3" json:"task_type,omitempty"` + // Metadata around how a task was executed. + Metadata *TaskExecutionMetadata `protobuf:"bytes,16,opt,name=metadata,proto3" json:"metadata,omitempty"` + // The event version is used to indicate versioned changes in how data is reported using this + // proto message. For example, event_verison > 0 means that maps tasks report logs using the + // TaskExecutionMetadata ExternalResourceInfo fields for each subtask rather than the TaskLog + // in this message. + EventVersion int32 `protobuf:"varint,18,opt,name=event_version,json=eventVersion,proto3" json:"event_version,omitempty"` + // This timestamp represents the instant when the event was reported by the executing framework. For example, a k8s + // pod task may be marked completed at (ie. `occurred_at`) the instant the container running user code completes, + // but this event will not be reported until the pod is marked as completed. Extracting both of these timestamps + // facilitates a more accurate portrayal of the evaluation time-series. + ReportedAt *timestamppb.Timestamp `protobuf:"bytes,20,opt,name=reported_at,json=reportedAt,proto3" json:"reported_at,omitempty"` + // Contains metadata required to identify logs related to this task execution + LogContext *core.LogContext `protobuf:"bytes,22,opt,name=log_context,json=logContext,proto3" json:"log_context,omitempty"` +} + +func (x *TaskExecutionEvent) Reset() { + *x = TaskExecutionEvent{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_event_event_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskExecutionEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskExecutionEvent) ProtoMessage() {} + +func (x *TaskExecutionEvent) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_event_event_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskExecutionEvent.ProtoReflect.Descriptor instead. +func (*TaskExecutionEvent) Descriptor() ([]byte, []int) { + return file_flyteidl2_event_event_proto_rawDescGZIP(), []int{7} +} + +func (x *TaskExecutionEvent) GetTaskId() *core.Identifier { + if x != nil { + return x.TaskId + } + return nil +} + +func (x *TaskExecutionEvent) GetParentNodeExecutionId() *core.NodeExecutionIdentifier { + if x != nil { + return x.ParentNodeExecutionId + } + return nil +} + +func (x *TaskExecutionEvent) GetRetryAttempt() uint32 { + if x != nil { + return x.RetryAttempt + } + return 0 +} + +func (x *TaskExecutionEvent) GetPhase() core.TaskExecution_Phase { + if x != nil { + return x.Phase + } + return core.TaskExecution_Phase(0) +} + +func (x *TaskExecutionEvent) GetProducerId() string { + if x != nil { + return x.ProducerId + } + return "" +} + +func (x *TaskExecutionEvent) GetLogs() []*core.TaskLog { + if x != nil { + return x.Logs + } + return nil +} + +func (x *TaskExecutionEvent) GetOccurredAt() *timestamppb.Timestamp { + if x != nil { + return x.OccurredAt + } + return nil +} + +func (m *TaskExecutionEvent) GetInputValue() isTaskExecutionEvent_InputValue { + if m != nil { + return m.InputValue + } + return nil +} + +func (x *TaskExecutionEvent) GetInputUri() string { + if x, ok := x.GetInputValue().(*TaskExecutionEvent_InputUri); ok { + return x.InputUri + } + return "" +} + +func (x *TaskExecutionEvent) GetInputData() *core.LiteralMap { + if x, ok := x.GetInputValue().(*TaskExecutionEvent_InputData); ok { + return x.InputData + } + return nil +} + +func (m *TaskExecutionEvent) GetOutputResult() isTaskExecutionEvent_OutputResult { + if m != nil { + return m.OutputResult + } + return nil +} + +func (x *TaskExecutionEvent) GetOutputUri() string { + if x, ok := x.GetOutputResult().(*TaskExecutionEvent_OutputUri); ok { + return x.OutputUri + } + return "" +} + +func (x *TaskExecutionEvent) GetError() *core.ExecutionError { + if x, ok := x.GetOutputResult().(*TaskExecutionEvent_Error); ok { + return x.Error + } + return nil +} + +func (x *TaskExecutionEvent) GetOutputData() *core.LiteralMap { + if x, ok := x.GetOutputResult().(*TaskExecutionEvent_OutputData); ok { + return x.OutputData + } + return nil +} + +func (x *TaskExecutionEvent) GetCustomInfo() *structpb.Struct { + if x != nil { + return x.CustomInfo + } + return nil +} + +func (x *TaskExecutionEvent) GetPhaseVersion() uint32 { + if x != nil { + return x.PhaseVersion + } + return 0 +} + +// Deprecated: Marked as deprecated in flyteidl2/event/event.proto. +func (x *TaskExecutionEvent) GetReason() string { + if x != nil { + return x.Reason + } + return "" +} + +func (x *TaskExecutionEvent) GetReasons() []*EventReason { + if x != nil { + return x.Reasons + } + return nil +} + +func (x *TaskExecutionEvent) GetTaskType() string { + if x != nil { + return x.TaskType + } + return "" +} + +func (x *TaskExecutionEvent) GetMetadata() *TaskExecutionMetadata { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *TaskExecutionEvent) GetEventVersion() int32 { + if x != nil { + return x.EventVersion + } + return 0 +} + +func (x *TaskExecutionEvent) GetReportedAt() *timestamppb.Timestamp { + if x != nil { + return x.ReportedAt + } + return nil +} + +func (x *TaskExecutionEvent) GetLogContext() *core.LogContext { + if x != nil { + return x.LogContext + } + return nil +} + +type isTaskExecutionEvent_InputValue interface { + isTaskExecutionEvent_InputValue() +} + +type TaskExecutionEvent_InputUri struct { + // URI of the input file, it encodes all the information + // including Cloud source provider. ie., s3://... + InputUri string `protobuf:"bytes,8,opt,name=input_uri,json=inputUri,proto3,oneof"` +} + +type TaskExecutionEvent_InputData struct { + // Raw input data consumed by this task execution. + InputData *core.LiteralMap `protobuf:"bytes,19,opt,name=input_data,json=inputData,proto3,oneof"` +} + +func (*TaskExecutionEvent_InputUri) isTaskExecutionEvent_InputValue() {} + +func (*TaskExecutionEvent_InputData) isTaskExecutionEvent_InputValue() {} + +type isTaskExecutionEvent_OutputResult interface { + isTaskExecutionEvent_OutputResult() +} + +type TaskExecutionEvent_OutputUri struct { + // URI to the output of the execution, it will be in a format that encodes all the information + // including Cloud source provider. ie., s3://... + OutputUri string `protobuf:"bytes,9,opt,name=output_uri,json=outputUri,proto3,oneof"` +} + +type TaskExecutionEvent_Error struct { + // Error information for the execution + Error *core.ExecutionError `protobuf:"bytes,10,opt,name=error,proto3,oneof"` +} + +type TaskExecutionEvent_OutputData struct { + // Raw output data produced by this task execution. + OutputData *core.LiteralMap `protobuf:"bytes,17,opt,name=output_data,json=outputData,proto3,oneof"` +} + +func (*TaskExecutionEvent_OutputUri) isTaskExecutionEvent_OutputResult() {} + +func (*TaskExecutionEvent_Error) isTaskExecutionEvent_OutputResult() {} + +func (*TaskExecutionEvent_OutputData) isTaskExecutionEvent_OutputResult() {} + +// This message contains metadata about external resources produced or used by a specific task execution. +type ExternalResourceInfo struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Identifier for an external resource created by this task execution, for example Qubole query ID or presto query ids. + ExternalId string `protobuf:"bytes,1,opt,name=external_id,json=externalId,proto3" json:"external_id,omitempty"` + // A unique index for the external resource with respect to all external resources for this task. Although the + // identifier may change between task reporting events or retries, this will remain the same to enable aggregating + // information from multiple reports. + Index uint32 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"` + // Retry attempt number for this external resource, ie., 2 for the second attempt + RetryAttempt uint32 `protobuf:"varint,3,opt,name=retry_attempt,json=retryAttempt,proto3" json:"retry_attempt,omitempty"` + // Phase associated with the external resource + Phase core.TaskExecution_Phase `protobuf:"varint,4,opt,name=phase,proto3,enum=flyteidl2.core.TaskExecution_Phase" json:"phase,omitempty"` + // Captures the status of caching for this external resource execution. + CacheStatus core.CatalogCacheStatus `protobuf:"varint,5,opt,name=cache_status,json=cacheStatus,proto3,enum=flyteidl2.core.CatalogCacheStatus" json:"cache_status,omitempty"` + // log information for the external resource execution + Logs []*core.TaskLog `protobuf:"bytes,6,rep,name=logs,proto3" json:"logs,omitempty"` + // Additional metadata to do with this event's node target based on the node type. We are + // explicitly not including the task_node_metadata here because it is not clear if it is needed. + // If we decide to include in the future, we should deprecate the cache_status field. + // + // Types that are assignable to TargetMetadata: + // + // *ExternalResourceInfo_WorkflowNodeMetadata + TargetMetadata isExternalResourceInfo_TargetMetadata `protobuf_oneof:"target_metadata"` + // Extensible field for custom, plugin-specific info + CustomInfo *structpb.Struct `protobuf:"bytes,8,opt,name=custom_info,json=customInfo,proto3" json:"custom_info,omitempty"` + // Contains metadata required to identify logs related to this task execution + LogContext *core.LogContext `protobuf:"bytes,9,opt,name=log_context,json=logContext,proto3" json:"log_context,omitempty"` +} + +func (x *ExternalResourceInfo) Reset() { + *x = ExternalResourceInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_event_event_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ExternalResourceInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExternalResourceInfo) ProtoMessage() {} + +func (x *ExternalResourceInfo) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_event_event_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExternalResourceInfo.ProtoReflect.Descriptor instead. +func (*ExternalResourceInfo) Descriptor() ([]byte, []int) { + return file_flyteidl2_event_event_proto_rawDescGZIP(), []int{8} +} + +func (x *ExternalResourceInfo) GetExternalId() string { + if x != nil { + return x.ExternalId + } + return "" +} + +func (x *ExternalResourceInfo) GetIndex() uint32 { + if x != nil { + return x.Index + } + return 0 +} + +func (x *ExternalResourceInfo) GetRetryAttempt() uint32 { + if x != nil { + return x.RetryAttempt + } + return 0 +} + +func (x *ExternalResourceInfo) GetPhase() core.TaskExecution_Phase { + if x != nil { + return x.Phase + } + return core.TaskExecution_Phase(0) +} + +func (x *ExternalResourceInfo) GetCacheStatus() core.CatalogCacheStatus { + if x != nil { + return x.CacheStatus + } + return core.CatalogCacheStatus(0) +} + +func (x *ExternalResourceInfo) GetLogs() []*core.TaskLog { + if x != nil { + return x.Logs + } + return nil +} + +func (m *ExternalResourceInfo) GetTargetMetadata() isExternalResourceInfo_TargetMetadata { + if m != nil { + return m.TargetMetadata + } + return nil +} + +func (x *ExternalResourceInfo) GetWorkflowNodeMetadata() *WorkflowNodeMetadata { + if x, ok := x.GetTargetMetadata().(*ExternalResourceInfo_WorkflowNodeMetadata); ok { + return x.WorkflowNodeMetadata + } + return nil +} + +func (x *ExternalResourceInfo) GetCustomInfo() *structpb.Struct { + if x != nil { + return x.CustomInfo + } + return nil +} + +func (x *ExternalResourceInfo) GetLogContext() *core.LogContext { + if x != nil { + return x.LogContext + } + return nil +} + +type isExternalResourceInfo_TargetMetadata interface { + isExternalResourceInfo_TargetMetadata() +} + +type ExternalResourceInfo_WorkflowNodeMetadata struct { + WorkflowNodeMetadata *WorkflowNodeMetadata `protobuf:"bytes,7,opt,name=workflow_node_metadata,json=workflowNodeMetadata,proto3,oneof"` +} + +func (*ExternalResourceInfo_WorkflowNodeMetadata) isExternalResourceInfo_TargetMetadata() {} + +// This message holds task execution metadata specific to resource allocation used to manage concurrent +// executions for a project namespace. +type ResourcePoolInfo struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Unique resource ID used to identify this execution when allocating a token. + AllocationToken string `protobuf:"bytes,1,opt,name=allocation_token,json=allocationToken,proto3" json:"allocation_token,omitempty"` + // Namespace under which this task execution requested an allocation token. + Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"` +} + +func (x *ResourcePoolInfo) Reset() { + *x = ResourcePoolInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_event_event_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ResourcePoolInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResourcePoolInfo) ProtoMessage() {} + +func (x *ResourcePoolInfo) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_event_event_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResourcePoolInfo.ProtoReflect.Descriptor instead. +func (*ResourcePoolInfo) Descriptor() ([]byte, []int) { + return file_flyteidl2_event_event_proto_rawDescGZIP(), []int{9} +} + +func (x *ResourcePoolInfo) GetAllocationToken() string { + if x != nil { + return x.AllocationToken + } + return "" +} + +func (x *ResourcePoolInfo) GetNamespace() string { + if x != nil { + return x.Namespace + } + return "" +} + +// Holds metadata around how a task was executed. +// As a task transitions across event phases during execution some attributes, such its generated name, generated external resources, +// and more may grow in size but not change necessarily based on the phase transition that sparked the event update. +// Metadata is a container for these attributes across the task execution lifecycle. +type TaskExecutionMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Unique, generated name for this task execution used by the backend. + GeneratedName string `protobuf:"bytes,1,opt,name=generated_name,json=generatedName,proto3" json:"generated_name,omitempty"` + // Additional data on external resources on other back-ends or platforms (e.g. Hive, Qubole, etc) launched by this task execution. + ExternalResources []*ExternalResourceInfo `protobuf:"bytes,2,rep,name=external_resources,json=externalResources,proto3" json:"external_resources,omitempty"` + // Includes additional data on concurrent resource management used during execution.. + // This is a repeated field because a plugin can request multiple resource allocations during execution. + ResourcePoolInfo []*ResourcePoolInfo `protobuf:"bytes,3,rep,name=resource_pool_info,json=resourcePoolInfo,proto3" json:"resource_pool_info,omitempty"` + // The identifier of the plugin used to execute this task. + PluginIdentifier string `protobuf:"bytes,4,opt,name=plugin_identifier,json=pluginIdentifier,proto3" json:"plugin_identifier,omitempty"` + InstanceClass TaskExecutionMetadata_InstanceClass `protobuf:"varint,16,opt,name=instance_class,json=instanceClass,proto3,enum=flyteidl2.event.TaskExecutionMetadata_InstanceClass" json:"instance_class,omitempty"` +} + +func (x *TaskExecutionMetadata) Reset() { + *x = TaskExecutionMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_event_event_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskExecutionMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskExecutionMetadata) ProtoMessage() {} + +func (x *TaskExecutionMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_event_event_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskExecutionMetadata.ProtoReflect.Descriptor instead. +func (*TaskExecutionMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_event_event_proto_rawDescGZIP(), []int{10} +} + +func (x *TaskExecutionMetadata) GetGeneratedName() string { + if x != nil { + return x.GeneratedName + } + return "" +} + +func (x *TaskExecutionMetadata) GetExternalResources() []*ExternalResourceInfo { + if x != nil { + return x.ExternalResources + } + return nil +} + +func (x *TaskExecutionMetadata) GetResourcePoolInfo() []*ResourcePoolInfo { + if x != nil { + return x.ResourcePoolInfo + } + return nil +} + +func (x *TaskExecutionMetadata) GetPluginIdentifier() string { + if x != nil { + return x.PluginIdentifier + } + return "" +} + +func (x *TaskExecutionMetadata) GetInstanceClass() TaskExecutionMetadata_InstanceClass { + if x != nil { + return x.InstanceClass + } + return TaskExecutionMetadata_DEFAULT +} + +var File_flyteidl2_event_event_proto protoreflect.FileDescriptor + +var file_flyteidl2_event_event_proto_rawDesc = []byte{ + 0x0a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x2f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x1a, 0x1c, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x63, + 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x6c, 0x69, + 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x73, 0x74, + 0x72, 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xae, 0x03, 0x0a, 0x16, + 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x4e, 0x0a, 0x0c, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x57, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x0b, 0x65, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, + 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x72, 0x6f, + 0x64, 0x75, 0x63, 0x65, 0x72, 0x49, 0x64, 0x12, 0x3d, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x50, 0x68, 0x61, 0x73, 0x65, 0x52, + 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x0b, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, + 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0a, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x64, 0x41, 0x74, 0x12, 0x1f, 0x0a, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x75, 0x72, + 0x69, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x09, 0x6f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x55, 0x72, 0x69, 0x12, 0x36, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, + 0x72, 0x6f, 0x72, 0x48, 0x00, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x3d, 0x0a, 0x0b, + 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x07, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, 0x70, 0x48, 0x00, 0x52, + 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x44, 0x61, 0x74, 0x61, 0x42, 0x0f, 0x0a, 0x0d, 0x6f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0xbe, 0x0a, 0x0a, + 0x12, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x76, + 0x65, 0x6e, 0x74, 0x12, 0x37, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1f, 0x0a, 0x0b, + 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x72, 0x49, 0x64, 0x12, 0x39, 0x0a, + 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4e, 0x6f, + 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x50, 0x68, 0x61, 0x73, + 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x0b, 0x6f, 0x63, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0a, 0x6f, 0x63, 0x63, 0x75, 0x72, + 0x72, 0x65, 0x64, 0x41, 0x74, 0x12, 0x1d, 0x0a, 0x09, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x75, + 0x72, 0x69, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x08, 0x69, 0x6e, 0x70, 0x75, + 0x74, 0x55, 0x72, 0x69, 0x12, 0x3b, 0x0a, 0x0a, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x64, 0x61, + 0x74, 0x61, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, + 0x6c, 0x4d, 0x61, 0x70, 0x48, 0x00, 0x52, 0x09, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x44, 0x61, 0x74, + 0x61, 0x12, 0x1f, 0x0a, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x09, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x55, + 0x72, 0x69, 0x12, 0x36, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x07, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, + 0x72, 0x48, 0x01, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x3d, 0x0a, 0x0b, 0x6f, 0x75, + 0x74, 0x70, 0x75, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, 0x70, 0x48, 0x01, 0x52, 0x0a, 0x6f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x5d, 0x0a, 0x16, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x57, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x48, 0x02, 0x52, 0x14, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x4e, 0x6f, 0x64, 0x65, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x51, 0x0a, 0x12, 0x74, 0x61, 0x73, 0x6b, + 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x0e, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x4e, 0x6f, 0x64, 0x65, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x48, 0x02, 0x52, 0x10, 0x74, 0x61, 0x73, 0x6b, 0x4e, + 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x5e, 0x0a, 0x14, 0x70, + 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x72, 0x65, + 0x6e, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x12, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x54, + 0x61, 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x5e, 0x0a, 0x14, 0x70, + 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x72, 0x65, + 0x6e, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x12, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x4e, + 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1f, 0x0a, 0x0b, 0x72, + 0x65, 0x74, 0x72, 0x79, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0a, 0x72, 0x65, 0x74, 0x72, 0x79, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x20, 0x0a, 0x0c, + 0x73, 0x70, 0x65, 0x63, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x0c, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0a, 0x73, 0x70, 0x65, 0x63, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x1b, + 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x65, + 0x76, 0x65, 0x6e, 0x74, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x10, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x0c, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x12, 0x1b, 0x0a, 0x09, 0x69, 0x73, 0x5f, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x18, 0x11, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x08, 0x69, 0x73, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x12, 0x1d, 0x0a, + 0x0a, 0x69, 0x73, 0x5f, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x18, 0x12, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x09, 0x69, 0x73, 0x44, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x12, 0x19, 0x0a, 0x08, + 0x64, 0x65, 0x63, 0x6b, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x13, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x64, 0x65, 0x63, 0x6b, 0x55, 0x72, 0x69, 0x12, 0x3b, 0x0a, 0x0b, 0x72, 0x65, 0x70, 0x6f, 0x72, + 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0a, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, + 0x65, 0x64, 0x41, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x69, 0x73, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, + 0x18, 0x16, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x69, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, + 0x3f, 0x0a, 0x0d, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, + 0x18, 0x17, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x52, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, + 0x12, 0x2d, 0x0a, 0x13, 0x69, 0x73, 0x5f, 0x69, 0x6e, 0x5f, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, + 0x63, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x18, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x69, + 0x73, 0x49, 0x6e, 0x44, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, + 0x19, 0x0a, 0x08, 0x69, 0x73, 0x5f, 0x65, 0x61, 0x67, 0x65, 0x72, 0x18, 0x19, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x07, 0x69, 0x73, 0x45, 0x61, 0x67, 0x65, 0x72, 0x42, 0x0d, 0x0a, 0x0b, 0x69, 0x6e, + 0x70, 0x75, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x0f, 0x0a, 0x0d, 0x6f, 0x75, 0x74, + 0x70, 0x75, 0x74, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x42, 0x11, 0x0a, 0x0f, 0x74, 0x61, + 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0x66, 0x0a, + 0x14, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x4e, 0x0a, 0x0c, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x57, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x0b, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x9c, 0x02, 0x0a, 0x10, 0x54, 0x61, 0x73, 0x6b, 0x4e, 0x6f, + 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x45, 0x0a, 0x0c, 0x63, 0x61, + 0x63, 0x68, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x43, 0x61, 0x63, 0x68, 0x65, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x52, 0x0b, 0x63, 0x61, 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x12, 0x40, 0x0a, 0x0b, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x5f, 0x6b, 0x65, 0x79, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x0a, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, + 0x4b, 0x65, 0x79, 0x12, 0x58, 0x0a, 0x12, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x11, 0x72, 0x65, 0x73, 0x65, + 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x25, 0x0a, + 0x0e, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, + 0x74, 0x55, 0x72, 0x69, 0x22, 0x56, 0x0a, 0x1b, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x54, 0x61, + 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x12, 0x37, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x02, 0x69, 0x64, 0x22, 0x36, 0x0a, 0x1b, + 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x17, 0x0a, 0x07, 0x6e, + 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, + 0x64, 0x65, 0x49, 0x64, 0x22, 0x62, 0x0a, 0x0b, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x61, + 0x73, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x3b, 0x0a, 0x0b, 0x6f, + 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0a, 0x6f, 0x63, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x41, 0x74, 0x22, 0xdd, 0x08, 0x0a, 0x12, 0x54, 0x61, 0x73, + 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, + 0x33, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x06, 0x74, 0x61, + 0x73, 0x6b, 0x49, 0x64, 0x12, 0x60, 0x0a, 0x18, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x6e, + 0x6f, 0x64, 0x65, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, + 0x15, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x74, 0x72, 0x79, 0x5f, + 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x72, + 0x65, 0x74, 0x72, 0x79, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x12, 0x39, 0x0a, 0x05, 0x70, + 0x68, 0x61, 0x73, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, + 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x50, 0x68, 0x61, 0x73, 0x65, 0x52, + 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, + 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x72, 0x6f, + 0x64, 0x75, 0x63, 0x65, 0x72, 0x49, 0x64, 0x12, 0x2b, 0x0a, 0x04, 0x6c, 0x6f, 0x67, 0x73, 0x18, + 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x52, 0x04, + 0x6c, 0x6f, 0x67, 0x73, 0x12, 0x3b, 0x0a, 0x0b, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, + 0x5f, 0x61, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0a, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x41, + 0x74, 0x12, 0x1d, 0x0a, 0x09, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x08, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x55, 0x72, 0x69, + 0x12, 0x3b, 0x0a, 0x0a, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x13, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, 0x70, + 0x48, 0x00, 0x52, 0x09, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x1f, 0x0a, + 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x09, 0x20, 0x01, 0x28, + 0x09, 0x48, 0x01, 0x52, 0x09, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x55, 0x72, 0x69, 0x12, 0x36, + 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x45, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x48, 0x01, 0x52, + 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x3d, 0x0a, 0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, + 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, + 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, 0x70, 0x48, 0x01, 0x52, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x38, 0x0a, 0x0b, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x5f, + 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, + 0x75, 0x63, 0x74, 0x52, 0x0a, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x12, + 0x23, 0x0a, 0x0d, 0x70, 0x68, 0x61, 0x73, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x70, 0x68, 0x61, 0x73, 0x65, 0x56, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x0d, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, + 0x12, 0x36, 0x0a, 0x07, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x73, 0x18, 0x15, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, + 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x52, + 0x07, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x61, 0x73, 0x6b, + 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x74, 0x61, 0x73, + 0x6b, 0x54, 0x79, 0x70, 0x65, 0x12, 0x42, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, + 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x76, 0x65, + 0x6e, 0x74, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x12, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x0c, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x3b, + 0x0a, 0x0b, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x14, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, + 0x0a, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x3b, 0x0a, 0x0b, 0x6c, + 0x6f, 0x67, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x4c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, 0x0a, 0x6c, 0x6f, + 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x42, 0x0d, 0x0a, 0x0b, 0x69, 0x6e, 0x70, 0x75, + 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x0f, 0x0a, 0x0d, 0x6f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x8a, 0x04, 0x0a, 0x14, 0x45, 0x78, 0x74, + 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, + 0x6f, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, + 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x74, 0x72, + 0x79, 0x5f, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, + 0x0c, 0x72, 0x65, 0x74, 0x72, 0x79, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x12, 0x39, 0x0a, + 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, + 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x50, 0x68, 0x61, 0x73, + 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x63, 0x61, 0x63, 0x68, + 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x43, 0x61, 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x52, 0x0b, 0x63, 0x61, 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, + 0x2b, 0x0a, 0x04, 0x6c, 0x6f, 0x67, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, + 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x52, 0x04, 0x6c, 0x6f, 0x67, 0x73, 0x12, 0x5d, 0x0a, 0x16, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x57, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, 0x14, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x4e, + 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x38, 0x0a, 0x0b, 0x63, + 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x0a, 0x63, 0x75, 0x73, 0x74, 0x6f, + 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3b, 0x0a, 0x0b, 0x6c, 0x6f, 0x67, 0x5f, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x78, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x6f, 0x67, 0x43, + 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, 0x0a, 0x6c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x65, + 0x78, 0x74, 0x42, 0x11, 0x0a, 0x0f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0x5b, 0x0a, 0x10, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x50, 0x6f, 0x6f, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x29, 0x0a, 0x10, 0x61, 0x6c, 0x6c, + 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0f, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, + 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, + 0x63, 0x65, 0x22, 0xa0, 0x03, 0x0a, 0x15, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x25, 0x0a, 0x0e, + 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x4e, + 0x61, 0x6d, 0x65, 0x12, 0x54, 0x0a, 0x12, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x11, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, + 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x12, 0x4f, 0x0a, 0x12, 0x72, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x70, 0x6f, 0x6f, 0x6c, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, + 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x50, 0x6f, 0x6f, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x10, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x50, 0x6f, 0x6f, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2b, 0x0a, 0x11, 0x70, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x5b, 0x0a, 0x0e, 0x69, 0x6e, 0x73, 0x74, 0x61, + 0x6e, 0x63, 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x34, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, + 0x43, 0x6c, 0x61, 0x73, 0x73, 0x52, 0x0d, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x43, + 0x6c, 0x61, 0x73, 0x73, 0x22, 0x2f, 0x0a, 0x0d, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, + 0x43, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x0b, 0x0a, 0x07, 0x44, 0x45, 0x46, 0x41, 0x55, 0x4c, 0x54, + 0x10, 0x00, 0x12, 0x11, 0x0a, 0x0d, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x52, 0x55, 0x50, 0x54, 0x49, + 0x42, 0x4c, 0x45, 0x10, 0x01, 0x42, 0xb5, 0x01, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x42, 0x0a, 0x45, + 0x76, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x33, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, + 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, + 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x65, 0x76, 0x65, + 0x6e, 0x74, 0xa2, 0x02, 0x03, 0x46, 0x45, 0x58, 0xaa, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0xca, 0x02, 0x0f, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0xe2, 0x02, 0x1b, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x5c, 0x47, + 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x10, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x62, 0x06, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_event_event_proto_rawDescOnce sync.Once + file_flyteidl2_event_event_proto_rawDescData = file_flyteidl2_event_event_proto_rawDesc +) + +func file_flyteidl2_event_event_proto_rawDescGZIP() []byte { + file_flyteidl2_event_event_proto_rawDescOnce.Do(func() { + file_flyteidl2_event_event_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_event_event_proto_rawDescData) + }) + return file_flyteidl2_event_event_proto_rawDescData +} + +var file_flyteidl2_event_event_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_flyteidl2_event_event_proto_msgTypes = make([]protoimpl.MessageInfo, 11) +var file_flyteidl2_event_event_proto_goTypes = []interface{}{ + (TaskExecutionMetadata_InstanceClass)(0), // 0: flyteidl2.event.TaskExecutionMetadata.InstanceClass + (*WorkflowExecutionEvent)(nil), // 1: flyteidl2.event.WorkflowExecutionEvent + (*NodeExecutionEvent)(nil), // 2: flyteidl2.event.NodeExecutionEvent + (*WorkflowNodeMetadata)(nil), // 3: flyteidl2.event.WorkflowNodeMetadata + (*TaskNodeMetadata)(nil), // 4: flyteidl2.event.TaskNodeMetadata + (*ParentTaskExecutionMetadata)(nil), // 5: flyteidl2.event.ParentTaskExecutionMetadata + (*ParentNodeExecutionMetadata)(nil), // 6: flyteidl2.event.ParentNodeExecutionMetadata + (*EventReason)(nil), // 7: flyteidl2.event.EventReason + (*TaskExecutionEvent)(nil), // 8: flyteidl2.event.TaskExecutionEvent + (*ExternalResourceInfo)(nil), // 9: flyteidl2.event.ExternalResourceInfo + (*ResourcePoolInfo)(nil), // 10: flyteidl2.event.ResourcePoolInfo + (*TaskExecutionMetadata)(nil), // 11: flyteidl2.event.TaskExecutionMetadata + (*core.WorkflowExecutionIdentifier)(nil), // 12: flyteidl2.core.WorkflowExecutionIdentifier + (core.WorkflowExecution_Phase)(0), // 13: flyteidl2.core.WorkflowExecution.Phase + (*timestamppb.Timestamp)(nil), // 14: google.protobuf.Timestamp + (*core.ExecutionError)(nil), // 15: flyteidl2.core.ExecutionError + (*core.LiteralMap)(nil), // 16: flyteidl2.core.LiteralMap + (*core.NodeExecutionIdentifier)(nil), // 17: flyteidl2.core.NodeExecutionIdentifier + (core.NodeExecution_Phase)(0), // 18: flyteidl2.core.NodeExecution.Phase + (*core.Identifier)(nil), // 19: flyteidl2.core.Identifier + (core.CatalogCacheStatus)(0), // 20: flyteidl2.core.CatalogCacheStatus + (*core.CatalogMetadata)(nil), // 21: flyteidl2.core.CatalogMetadata + (core.CatalogReservation_Status)(0), // 22: flyteidl2.core.CatalogReservation.Status + (*core.TaskExecutionIdentifier)(nil), // 23: flyteidl2.core.TaskExecutionIdentifier + (core.TaskExecution_Phase)(0), // 24: flyteidl2.core.TaskExecution.Phase + (*core.TaskLog)(nil), // 25: flyteidl2.core.TaskLog + (*structpb.Struct)(nil), // 26: google.protobuf.Struct + (*core.LogContext)(nil), // 27: flyteidl2.core.LogContext +} +var file_flyteidl2_event_event_proto_depIdxs = []int32{ + 12, // 0: flyteidl2.event.WorkflowExecutionEvent.execution_id:type_name -> flyteidl2.core.WorkflowExecutionIdentifier + 13, // 1: flyteidl2.event.WorkflowExecutionEvent.phase:type_name -> flyteidl2.core.WorkflowExecution.Phase + 14, // 2: flyteidl2.event.WorkflowExecutionEvent.occurred_at:type_name -> google.protobuf.Timestamp + 15, // 3: flyteidl2.event.WorkflowExecutionEvent.error:type_name -> flyteidl2.core.ExecutionError + 16, // 4: flyteidl2.event.WorkflowExecutionEvent.output_data:type_name -> flyteidl2.core.LiteralMap + 17, // 5: flyteidl2.event.NodeExecutionEvent.id:type_name -> flyteidl2.core.NodeExecutionIdentifier + 18, // 6: flyteidl2.event.NodeExecutionEvent.phase:type_name -> flyteidl2.core.NodeExecution.Phase + 14, // 7: flyteidl2.event.NodeExecutionEvent.occurred_at:type_name -> google.protobuf.Timestamp + 16, // 8: flyteidl2.event.NodeExecutionEvent.input_data:type_name -> flyteidl2.core.LiteralMap + 15, // 9: flyteidl2.event.NodeExecutionEvent.error:type_name -> flyteidl2.core.ExecutionError + 16, // 10: flyteidl2.event.NodeExecutionEvent.output_data:type_name -> flyteidl2.core.LiteralMap + 3, // 11: flyteidl2.event.NodeExecutionEvent.workflow_node_metadata:type_name -> flyteidl2.event.WorkflowNodeMetadata + 4, // 12: flyteidl2.event.NodeExecutionEvent.task_node_metadata:type_name -> flyteidl2.event.TaskNodeMetadata + 5, // 13: flyteidl2.event.NodeExecutionEvent.parent_task_metadata:type_name -> flyteidl2.event.ParentTaskExecutionMetadata + 6, // 14: flyteidl2.event.NodeExecutionEvent.parent_node_metadata:type_name -> flyteidl2.event.ParentNodeExecutionMetadata + 14, // 15: flyteidl2.event.NodeExecutionEvent.reported_at:type_name -> google.protobuf.Timestamp + 19, // 16: flyteidl2.event.NodeExecutionEvent.target_entity:type_name -> flyteidl2.core.Identifier + 12, // 17: flyteidl2.event.WorkflowNodeMetadata.execution_id:type_name -> flyteidl2.core.WorkflowExecutionIdentifier + 20, // 18: flyteidl2.event.TaskNodeMetadata.cache_status:type_name -> flyteidl2.core.CatalogCacheStatus + 21, // 19: flyteidl2.event.TaskNodeMetadata.catalog_key:type_name -> flyteidl2.core.CatalogMetadata + 22, // 20: flyteidl2.event.TaskNodeMetadata.reservation_status:type_name -> flyteidl2.core.CatalogReservation.Status + 23, // 21: flyteidl2.event.ParentTaskExecutionMetadata.id:type_name -> flyteidl2.core.TaskExecutionIdentifier + 14, // 22: flyteidl2.event.EventReason.occurred_at:type_name -> google.protobuf.Timestamp + 19, // 23: flyteidl2.event.TaskExecutionEvent.task_id:type_name -> flyteidl2.core.Identifier + 17, // 24: flyteidl2.event.TaskExecutionEvent.parent_node_execution_id:type_name -> flyteidl2.core.NodeExecutionIdentifier + 24, // 25: flyteidl2.event.TaskExecutionEvent.phase:type_name -> flyteidl2.core.TaskExecution.Phase + 25, // 26: flyteidl2.event.TaskExecutionEvent.logs:type_name -> flyteidl2.core.TaskLog + 14, // 27: flyteidl2.event.TaskExecutionEvent.occurred_at:type_name -> google.protobuf.Timestamp + 16, // 28: flyteidl2.event.TaskExecutionEvent.input_data:type_name -> flyteidl2.core.LiteralMap + 15, // 29: flyteidl2.event.TaskExecutionEvent.error:type_name -> flyteidl2.core.ExecutionError + 16, // 30: flyteidl2.event.TaskExecutionEvent.output_data:type_name -> flyteidl2.core.LiteralMap + 26, // 31: flyteidl2.event.TaskExecutionEvent.custom_info:type_name -> google.protobuf.Struct + 7, // 32: flyteidl2.event.TaskExecutionEvent.reasons:type_name -> flyteidl2.event.EventReason + 11, // 33: flyteidl2.event.TaskExecutionEvent.metadata:type_name -> flyteidl2.event.TaskExecutionMetadata + 14, // 34: flyteidl2.event.TaskExecutionEvent.reported_at:type_name -> google.protobuf.Timestamp + 27, // 35: flyteidl2.event.TaskExecutionEvent.log_context:type_name -> flyteidl2.core.LogContext + 24, // 36: flyteidl2.event.ExternalResourceInfo.phase:type_name -> flyteidl2.core.TaskExecution.Phase + 20, // 37: flyteidl2.event.ExternalResourceInfo.cache_status:type_name -> flyteidl2.core.CatalogCacheStatus + 25, // 38: flyteidl2.event.ExternalResourceInfo.logs:type_name -> flyteidl2.core.TaskLog + 3, // 39: flyteidl2.event.ExternalResourceInfo.workflow_node_metadata:type_name -> flyteidl2.event.WorkflowNodeMetadata + 26, // 40: flyteidl2.event.ExternalResourceInfo.custom_info:type_name -> google.protobuf.Struct + 27, // 41: flyteidl2.event.ExternalResourceInfo.log_context:type_name -> flyteidl2.core.LogContext + 9, // 42: flyteidl2.event.TaskExecutionMetadata.external_resources:type_name -> flyteidl2.event.ExternalResourceInfo + 10, // 43: flyteidl2.event.TaskExecutionMetadata.resource_pool_info:type_name -> flyteidl2.event.ResourcePoolInfo + 0, // 44: flyteidl2.event.TaskExecutionMetadata.instance_class:type_name -> flyteidl2.event.TaskExecutionMetadata.InstanceClass + 45, // [45:45] is the sub-list for method output_type + 45, // [45:45] is the sub-list for method input_type + 45, // [45:45] is the sub-list for extension type_name + 45, // [45:45] is the sub-list for extension extendee + 0, // [0:45] is the sub-list for field type_name +} + +func init() { file_flyteidl2_event_event_proto_init() } +func file_flyteidl2_event_event_proto_init() { + if File_flyteidl2_event_event_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_event_event_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WorkflowExecutionEvent); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_event_event_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*NodeExecutionEvent); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_event_event_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WorkflowNodeMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_event_event_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskNodeMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_event_event_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ParentTaskExecutionMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_event_event_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ParentNodeExecutionMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_event_event_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EventReason); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_event_event_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskExecutionEvent); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_event_event_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ExternalResourceInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_event_event_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ResourcePoolInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_event_event_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskExecutionMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_event_event_proto_msgTypes[0].OneofWrappers = []interface{}{ + (*WorkflowExecutionEvent_OutputUri)(nil), + (*WorkflowExecutionEvent_Error)(nil), + (*WorkflowExecutionEvent_OutputData)(nil), + } + file_flyteidl2_event_event_proto_msgTypes[1].OneofWrappers = []interface{}{ + (*NodeExecutionEvent_InputUri)(nil), + (*NodeExecutionEvent_InputData)(nil), + (*NodeExecutionEvent_OutputUri)(nil), + (*NodeExecutionEvent_Error)(nil), + (*NodeExecutionEvent_OutputData)(nil), + (*NodeExecutionEvent_WorkflowNodeMetadata)(nil), + (*NodeExecutionEvent_TaskNodeMetadata)(nil), + } + file_flyteidl2_event_event_proto_msgTypes[7].OneofWrappers = []interface{}{ + (*TaskExecutionEvent_InputUri)(nil), + (*TaskExecutionEvent_InputData)(nil), + (*TaskExecutionEvent_OutputUri)(nil), + (*TaskExecutionEvent_Error)(nil), + (*TaskExecutionEvent_OutputData)(nil), + } + file_flyteidl2_event_event_proto_msgTypes[8].OneofWrappers = []interface{}{ + (*ExternalResourceInfo_WorkflowNodeMetadata)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_event_event_proto_rawDesc, + NumEnums: 1, + NumMessages: 11, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_event_event_proto_goTypes, + DependencyIndexes: file_flyteidl2_event_event_proto_depIdxs, + EnumInfos: file_flyteidl2_event_event_proto_enumTypes, + MessageInfos: file_flyteidl2_event_event_proto_msgTypes, + }.Build() + File_flyteidl2_event_event_proto = out.File + file_flyteidl2_event_event_proto_rawDesc = nil + file_flyteidl2_event_event_proto_goTypes = nil + file_flyteidl2_event_event_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/event/event.pb.validate.go b/gen/go/flyteidl2/event/event.pb.validate.go new file mode 100644 index 0000000000..47f06d139b --- /dev/null +++ b/gen/go/flyteidl2/event/event.pb.validate.go @@ -0,0 +1,2551 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/event/event.proto + +package event + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" + + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort + + _ = core.WorkflowExecution_Phase(0) +) + +// Validate checks the field values on WorkflowExecutionEvent with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *WorkflowExecutionEvent) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WorkflowExecutionEvent with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// WorkflowExecutionEventMultiError, or nil if none found. +func (m *WorkflowExecutionEvent) ValidateAll() error { + return m.validate(true) +} + +func (m *WorkflowExecutionEvent) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetExecutionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WorkflowExecutionEventValidationError{ + field: "ExecutionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WorkflowExecutionEventValidationError{ + field: "ExecutionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetExecutionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WorkflowExecutionEventValidationError{ + field: "ExecutionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for ProducerId + + // no validation rules for Phase + + if all { + switch v := interface{}(m.GetOccurredAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WorkflowExecutionEventValidationError{ + field: "OccurredAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WorkflowExecutionEventValidationError{ + field: "OccurredAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOccurredAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WorkflowExecutionEventValidationError{ + field: "OccurredAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + switch v := m.OutputResult.(type) { + case *WorkflowExecutionEvent_OutputUri: + if v == nil { + err := WorkflowExecutionEventValidationError{ + field: "OutputResult", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for OutputUri + case *WorkflowExecutionEvent_Error: + if v == nil { + err := WorkflowExecutionEventValidationError{ + field: "OutputResult", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetError()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WorkflowExecutionEventValidationError{ + field: "Error", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WorkflowExecutionEventValidationError{ + field: "Error", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetError()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WorkflowExecutionEventValidationError{ + field: "Error", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *WorkflowExecutionEvent_OutputData: + if v == nil { + err := WorkflowExecutionEventValidationError{ + field: "OutputResult", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetOutputData()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WorkflowExecutionEventValidationError{ + field: "OutputData", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WorkflowExecutionEventValidationError{ + field: "OutputData", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOutputData()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WorkflowExecutionEventValidationError{ + field: "OutputData", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return WorkflowExecutionEventMultiError(errors) + } + + return nil +} + +// WorkflowExecutionEventMultiError is an error wrapping multiple validation +// errors returned by WorkflowExecutionEvent.ValidateAll() if the designated +// constraints aren't met. +type WorkflowExecutionEventMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WorkflowExecutionEventMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WorkflowExecutionEventMultiError) AllErrors() []error { return m } + +// WorkflowExecutionEventValidationError is the validation error returned by +// WorkflowExecutionEvent.Validate if the designated constraints aren't met. +type WorkflowExecutionEventValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WorkflowExecutionEventValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WorkflowExecutionEventValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WorkflowExecutionEventValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WorkflowExecutionEventValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WorkflowExecutionEventValidationError) ErrorName() string { + return "WorkflowExecutionEventValidationError" +} + +// Error satisfies the builtin error interface +func (e WorkflowExecutionEventValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWorkflowExecutionEvent.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WorkflowExecutionEventValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WorkflowExecutionEventValidationError{} + +// Validate checks the field values on NodeExecutionEvent with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *NodeExecutionEvent) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on NodeExecutionEvent with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// NodeExecutionEventMultiError, or nil if none found. +func (m *NodeExecutionEvent) ValidateAll() error { + return m.validate(true) +} + +func (m *NodeExecutionEvent) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return NodeExecutionEventValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for ProducerId + + // no validation rules for Phase + + if all { + switch v := interface{}(m.GetOccurredAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "OccurredAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "OccurredAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOccurredAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return NodeExecutionEventValidationError{ + field: "OccurredAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetParentTaskMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "ParentTaskMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "ParentTaskMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetParentTaskMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return NodeExecutionEventValidationError{ + field: "ParentTaskMetadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetParentNodeMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "ParentNodeMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "ParentNodeMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetParentNodeMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return NodeExecutionEventValidationError{ + field: "ParentNodeMetadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for RetryGroup + + // no validation rules for SpecNodeId + + // no validation rules for NodeName + + // no validation rules for EventVersion + + // no validation rules for IsParent + + // no validation rules for IsDynamic + + // no validation rules for DeckUri + + if all { + switch v := interface{}(m.GetReportedAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "ReportedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "ReportedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetReportedAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return NodeExecutionEventValidationError{ + field: "ReportedAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for IsArray + + if all { + switch v := interface{}(m.GetTargetEntity()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "TargetEntity", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "TargetEntity", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTargetEntity()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return NodeExecutionEventValidationError{ + field: "TargetEntity", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for IsInDynamicChain + + // no validation rules for IsEager + + switch v := m.InputValue.(type) { + case *NodeExecutionEvent_InputUri: + if v == nil { + err := NodeExecutionEventValidationError{ + field: "InputValue", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for InputUri + case *NodeExecutionEvent_InputData: + if v == nil { + err := NodeExecutionEventValidationError{ + field: "InputValue", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetInputData()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "InputData", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "InputData", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetInputData()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return NodeExecutionEventValidationError{ + field: "InputData", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + switch v := m.OutputResult.(type) { + case *NodeExecutionEvent_OutputUri: + if v == nil { + err := NodeExecutionEventValidationError{ + field: "OutputResult", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for OutputUri + case *NodeExecutionEvent_Error: + if v == nil { + err := NodeExecutionEventValidationError{ + field: "OutputResult", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetError()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "Error", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "Error", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetError()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return NodeExecutionEventValidationError{ + field: "Error", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *NodeExecutionEvent_OutputData: + if v == nil { + err := NodeExecutionEventValidationError{ + field: "OutputResult", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetOutputData()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "OutputData", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "OutputData", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOutputData()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return NodeExecutionEventValidationError{ + field: "OutputData", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + switch v := m.TargetMetadata.(type) { + case *NodeExecutionEvent_WorkflowNodeMetadata: + if v == nil { + err := NodeExecutionEventValidationError{ + field: "TargetMetadata", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetWorkflowNodeMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "WorkflowNodeMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "WorkflowNodeMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetWorkflowNodeMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return NodeExecutionEventValidationError{ + field: "WorkflowNodeMetadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *NodeExecutionEvent_TaskNodeMetadata: + if v == nil { + err := NodeExecutionEventValidationError{ + field: "TargetMetadata", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTaskNodeMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "TaskNodeMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, NodeExecutionEventValidationError{ + field: "TaskNodeMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskNodeMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return NodeExecutionEventValidationError{ + field: "TaskNodeMetadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return NodeExecutionEventMultiError(errors) + } + + return nil +} + +// NodeExecutionEventMultiError is an error wrapping multiple validation errors +// returned by NodeExecutionEvent.ValidateAll() if the designated constraints +// aren't met. +type NodeExecutionEventMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m NodeExecutionEventMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m NodeExecutionEventMultiError) AllErrors() []error { return m } + +// NodeExecutionEventValidationError is the validation error returned by +// NodeExecutionEvent.Validate if the designated constraints aren't met. +type NodeExecutionEventValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e NodeExecutionEventValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e NodeExecutionEventValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e NodeExecutionEventValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e NodeExecutionEventValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e NodeExecutionEventValidationError) ErrorName() string { + return "NodeExecutionEventValidationError" +} + +// Error satisfies the builtin error interface +func (e NodeExecutionEventValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sNodeExecutionEvent.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = NodeExecutionEventValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = NodeExecutionEventValidationError{} + +// Validate checks the field values on WorkflowNodeMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *WorkflowNodeMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WorkflowNodeMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// WorkflowNodeMetadataMultiError, or nil if none found. +func (m *WorkflowNodeMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *WorkflowNodeMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetExecutionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WorkflowNodeMetadataValidationError{ + field: "ExecutionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WorkflowNodeMetadataValidationError{ + field: "ExecutionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetExecutionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WorkflowNodeMetadataValidationError{ + field: "ExecutionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return WorkflowNodeMetadataMultiError(errors) + } + + return nil +} + +// WorkflowNodeMetadataMultiError is an error wrapping multiple validation +// errors returned by WorkflowNodeMetadata.ValidateAll() if the designated +// constraints aren't met. +type WorkflowNodeMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WorkflowNodeMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WorkflowNodeMetadataMultiError) AllErrors() []error { return m } + +// WorkflowNodeMetadataValidationError is the validation error returned by +// WorkflowNodeMetadata.Validate if the designated constraints aren't met. +type WorkflowNodeMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WorkflowNodeMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WorkflowNodeMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WorkflowNodeMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WorkflowNodeMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WorkflowNodeMetadataValidationError) ErrorName() string { + return "WorkflowNodeMetadataValidationError" +} + +// Error satisfies the builtin error interface +func (e WorkflowNodeMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWorkflowNodeMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WorkflowNodeMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WorkflowNodeMetadataValidationError{} + +// Validate checks the field values on TaskNodeMetadata with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *TaskNodeMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskNodeMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TaskNodeMetadataMultiError, or nil if none found. +func (m *TaskNodeMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskNodeMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for CacheStatus + + if all { + switch v := interface{}(m.GetCatalogKey()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskNodeMetadataValidationError{ + field: "CatalogKey", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskNodeMetadataValidationError{ + field: "CatalogKey", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCatalogKey()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskNodeMetadataValidationError{ + field: "CatalogKey", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for ReservationStatus + + // no validation rules for CheckpointUri + + if len(errors) > 0 { + return TaskNodeMetadataMultiError(errors) + } + + return nil +} + +// TaskNodeMetadataMultiError is an error wrapping multiple validation errors +// returned by TaskNodeMetadata.ValidateAll() if the designated constraints +// aren't met. +type TaskNodeMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskNodeMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskNodeMetadataMultiError) AllErrors() []error { return m } + +// TaskNodeMetadataValidationError is the validation error returned by +// TaskNodeMetadata.Validate if the designated constraints aren't met. +type TaskNodeMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskNodeMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskNodeMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskNodeMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskNodeMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskNodeMetadataValidationError) ErrorName() string { return "TaskNodeMetadataValidationError" } + +// Error satisfies the builtin error interface +func (e TaskNodeMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskNodeMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskNodeMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskNodeMetadataValidationError{} + +// Validate checks the field values on ParentTaskExecutionMetadata with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ParentTaskExecutionMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ParentTaskExecutionMetadata with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ParentTaskExecutionMetadataMultiError, or nil if none found. +func (m *ParentTaskExecutionMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *ParentTaskExecutionMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ParentTaskExecutionMetadataValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ParentTaskExecutionMetadataValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ParentTaskExecutionMetadataValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ParentTaskExecutionMetadataMultiError(errors) + } + + return nil +} + +// ParentTaskExecutionMetadataMultiError is an error wrapping multiple +// validation errors returned by ParentTaskExecutionMetadata.ValidateAll() if +// the designated constraints aren't met. +type ParentTaskExecutionMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ParentTaskExecutionMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ParentTaskExecutionMetadataMultiError) AllErrors() []error { return m } + +// ParentTaskExecutionMetadataValidationError is the validation error returned +// by ParentTaskExecutionMetadata.Validate if the designated constraints +// aren't met. +type ParentTaskExecutionMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ParentTaskExecutionMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ParentTaskExecutionMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ParentTaskExecutionMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ParentTaskExecutionMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ParentTaskExecutionMetadataValidationError) ErrorName() string { + return "ParentTaskExecutionMetadataValidationError" +} + +// Error satisfies the builtin error interface +func (e ParentTaskExecutionMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sParentTaskExecutionMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ParentTaskExecutionMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ParentTaskExecutionMetadataValidationError{} + +// Validate checks the field values on ParentNodeExecutionMetadata with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ParentNodeExecutionMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ParentNodeExecutionMetadata with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ParentNodeExecutionMetadataMultiError, or nil if none found. +func (m *ParentNodeExecutionMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *ParentNodeExecutionMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for NodeId + + if len(errors) > 0 { + return ParentNodeExecutionMetadataMultiError(errors) + } + + return nil +} + +// ParentNodeExecutionMetadataMultiError is an error wrapping multiple +// validation errors returned by ParentNodeExecutionMetadata.ValidateAll() if +// the designated constraints aren't met. +type ParentNodeExecutionMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ParentNodeExecutionMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ParentNodeExecutionMetadataMultiError) AllErrors() []error { return m } + +// ParentNodeExecutionMetadataValidationError is the validation error returned +// by ParentNodeExecutionMetadata.Validate if the designated constraints +// aren't met. +type ParentNodeExecutionMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ParentNodeExecutionMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ParentNodeExecutionMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ParentNodeExecutionMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ParentNodeExecutionMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ParentNodeExecutionMetadataValidationError) ErrorName() string { + return "ParentNodeExecutionMetadataValidationError" +} + +// Error satisfies the builtin error interface +func (e ParentNodeExecutionMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sParentNodeExecutionMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ParentNodeExecutionMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ParentNodeExecutionMetadataValidationError{} + +// Validate checks the field values on EventReason with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *EventReason) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on EventReason with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in EventReasonMultiError, or +// nil if none found. +func (m *EventReason) ValidateAll() error { + return m.validate(true) +} + +func (m *EventReason) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Reason + + if all { + switch v := interface{}(m.GetOccurredAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, EventReasonValidationError{ + field: "OccurredAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, EventReasonValidationError{ + field: "OccurredAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOccurredAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return EventReasonValidationError{ + field: "OccurredAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return EventReasonMultiError(errors) + } + + return nil +} + +// EventReasonMultiError is an error wrapping multiple validation errors +// returned by EventReason.ValidateAll() if the designated constraints aren't met. +type EventReasonMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m EventReasonMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m EventReasonMultiError) AllErrors() []error { return m } + +// EventReasonValidationError is the validation error returned by +// EventReason.Validate if the designated constraints aren't met. +type EventReasonValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e EventReasonValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e EventReasonValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e EventReasonValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e EventReasonValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e EventReasonValidationError) ErrorName() string { return "EventReasonValidationError" } + +// Error satisfies the builtin error interface +func (e EventReasonValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sEventReason.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = EventReasonValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = EventReasonValidationError{} + +// Validate checks the field values on TaskExecutionEvent with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *TaskExecutionEvent) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskExecutionEvent with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TaskExecutionEventMultiError, or nil if none found. +func (m *TaskExecutionEvent) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskExecutionEvent) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetTaskId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskExecutionEventValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetParentNodeExecutionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "ParentNodeExecutionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "ParentNodeExecutionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetParentNodeExecutionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskExecutionEventValidationError{ + field: "ParentNodeExecutionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for RetryAttempt + + // no validation rules for Phase + + // no validation rules for ProducerId + + for idx, item := range m.GetLogs() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: fmt.Sprintf("Logs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: fmt.Sprintf("Logs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskExecutionEventValidationError{ + field: fmt.Sprintf("Logs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if all { + switch v := interface{}(m.GetOccurredAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "OccurredAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "OccurredAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOccurredAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskExecutionEventValidationError{ + field: "OccurredAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetCustomInfo()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "CustomInfo", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "CustomInfo", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCustomInfo()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskExecutionEventValidationError{ + field: "CustomInfo", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for PhaseVersion + + // no validation rules for Reason + + for idx, item := range m.GetReasons() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: fmt.Sprintf("Reasons[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: fmt.Sprintf("Reasons[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskExecutionEventValidationError{ + field: fmt.Sprintf("Reasons[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for TaskType + + if all { + switch v := interface{}(m.GetMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskExecutionEventValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for EventVersion + + if all { + switch v := interface{}(m.GetReportedAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "ReportedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "ReportedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetReportedAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskExecutionEventValidationError{ + field: "ReportedAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetLogContext()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "LogContext", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "LogContext", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLogContext()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskExecutionEventValidationError{ + field: "LogContext", + reason: "embedded message failed validation", + cause: err, + } + } + } + + switch v := m.InputValue.(type) { + case *TaskExecutionEvent_InputUri: + if v == nil { + err := TaskExecutionEventValidationError{ + field: "InputValue", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for InputUri + case *TaskExecutionEvent_InputData: + if v == nil { + err := TaskExecutionEventValidationError{ + field: "InputValue", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetInputData()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "InputData", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "InputData", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetInputData()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskExecutionEventValidationError{ + field: "InputData", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + switch v := m.OutputResult.(type) { + case *TaskExecutionEvent_OutputUri: + if v == nil { + err := TaskExecutionEventValidationError{ + field: "OutputResult", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for OutputUri + case *TaskExecutionEvent_Error: + if v == nil { + err := TaskExecutionEventValidationError{ + field: "OutputResult", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetError()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "Error", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "Error", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetError()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskExecutionEventValidationError{ + field: "Error", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *TaskExecutionEvent_OutputData: + if v == nil { + err := TaskExecutionEventValidationError{ + field: "OutputResult", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetOutputData()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "OutputData", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskExecutionEventValidationError{ + field: "OutputData", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOutputData()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskExecutionEventValidationError{ + field: "OutputData", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return TaskExecutionEventMultiError(errors) + } + + return nil +} + +// TaskExecutionEventMultiError is an error wrapping multiple validation errors +// returned by TaskExecutionEvent.ValidateAll() if the designated constraints +// aren't met. +type TaskExecutionEventMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskExecutionEventMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskExecutionEventMultiError) AllErrors() []error { return m } + +// TaskExecutionEventValidationError is the validation error returned by +// TaskExecutionEvent.Validate if the designated constraints aren't met. +type TaskExecutionEventValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskExecutionEventValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskExecutionEventValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskExecutionEventValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskExecutionEventValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskExecutionEventValidationError) ErrorName() string { + return "TaskExecutionEventValidationError" +} + +// Error satisfies the builtin error interface +func (e TaskExecutionEventValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskExecutionEvent.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskExecutionEventValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskExecutionEventValidationError{} + +// Validate checks the field values on ExternalResourceInfo with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ExternalResourceInfo) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ExternalResourceInfo with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ExternalResourceInfoMultiError, or nil if none found. +func (m *ExternalResourceInfo) ValidateAll() error { + return m.validate(true) +} + +func (m *ExternalResourceInfo) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ExternalId + + // no validation rules for Index + + // no validation rules for RetryAttempt + + // no validation rules for Phase + + // no validation rules for CacheStatus + + for idx, item := range m.GetLogs() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ExternalResourceInfoValidationError{ + field: fmt.Sprintf("Logs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ExternalResourceInfoValidationError{ + field: fmt.Sprintf("Logs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ExternalResourceInfoValidationError{ + field: fmt.Sprintf("Logs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if all { + switch v := interface{}(m.GetCustomInfo()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ExternalResourceInfoValidationError{ + field: "CustomInfo", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ExternalResourceInfoValidationError{ + field: "CustomInfo", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCustomInfo()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ExternalResourceInfoValidationError{ + field: "CustomInfo", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetLogContext()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ExternalResourceInfoValidationError{ + field: "LogContext", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ExternalResourceInfoValidationError{ + field: "LogContext", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLogContext()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ExternalResourceInfoValidationError{ + field: "LogContext", + reason: "embedded message failed validation", + cause: err, + } + } + } + + switch v := m.TargetMetadata.(type) { + case *ExternalResourceInfo_WorkflowNodeMetadata: + if v == nil { + err := ExternalResourceInfoValidationError{ + field: "TargetMetadata", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetWorkflowNodeMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ExternalResourceInfoValidationError{ + field: "WorkflowNodeMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ExternalResourceInfoValidationError{ + field: "WorkflowNodeMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetWorkflowNodeMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ExternalResourceInfoValidationError{ + field: "WorkflowNodeMetadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return ExternalResourceInfoMultiError(errors) + } + + return nil +} + +// ExternalResourceInfoMultiError is an error wrapping multiple validation +// errors returned by ExternalResourceInfo.ValidateAll() if the designated +// constraints aren't met. +type ExternalResourceInfoMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ExternalResourceInfoMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ExternalResourceInfoMultiError) AllErrors() []error { return m } + +// ExternalResourceInfoValidationError is the validation error returned by +// ExternalResourceInfo.Validate if the designated constraints aren't met. +type ExternalResourceInfoValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ExternalResourceInfoValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ExternalResourceInfoValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ExternalResourceInfoValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ExternalResourceInfoValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ExternalResourceInfoValidationError) ErrorName() string { + return "ExternalResourceInfoValidationError" +} + +// Error satisfies the builtin error interface +func (e ExternalResourceInfoValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sExternalResourceInfo.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ExternalResourceInfoValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ExternalResourceInfoValidationError{} + +// Validate checks the field values on ResourcePoolInfo with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *ResourcePoolInfo) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ResourcePoolInfo with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ResourcePoolInfoMultiError, or nil if none found. +func (m *ResourcePoolInfo) ValidateAll() error { + return m.validate(true) +} + +func (m *ResourcePoolInfo) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for AllocationToken + + // no validation rules for Namespace + + if len(errors) > 0 { + return ResourcePoolInfoMultiError(errors) + } + + return nil +} + +// ResourcePoolInfoMultiError is an error wrapping multiple validation errors +// returned by ResourcePoolInfo.ValidateAll() if the designated constraints +// aren't met. +type ResourcePoolInfoMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ResourcePoolInfoMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ResourcePoolInfoMultiError) AllErrors() []error { return m } + +// ResourcePoolInfoValidationError is the validation error returned by +// ResourcePoolInfo.Validate if the designated constraints aren't met. +type ResourcePoolInfoValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ResourcePoolInfoValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ResourcePoolInfoValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ResourcePoolInfoValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ResourcePoolInfoValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ResourcePoolInfoValidationError) ErrorName() string { return "ResourcePoolInfoValidationError" } + +// Error satisfies the builtin error interface +func (e ResourcePoolInfoValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sResourcePoolInfo.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ResourcePoolInfoValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ResourcePoolInfoValidationError{} + +// Validate checks the field values on TaskExecutionMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *TaskExecutionMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskExecutionMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TaskExecutionMetadataMultiError, or nil if none found. +func (m *TaskExecutionMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskExecutionMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for GeneratedName + + for idx, item := range m.GetExternalResources() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskExecutionMetadataValidationError{ + field: fmt.Sprintf("ExternalResources[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskExecutionMetadataValidationError{ + field: fmt.Sprintf("ExternalResources[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskExecutionMetadataValidationError{ + field: fmt.Sprintf("ExternalResources[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + for idx, item := range m.GetResourcePoolInfo() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskExecutionMetadataValidationError{ + field: fmt.Sprintf("ResourcePoolInfo[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskExecutionMetadataValidationError{ + field: fmt.Sprintf("ResourcePoolInfo[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskExecutionMetadataValidationError{ + field: fmt.Sprintf("ResourcePoolInfo[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for PluginIdentifier + + // no validation rules for InstanceClass + + if len(errors) > 0 { + return TaskExecutionMetadataMultiError(errors) + } + + return nil +} + +// TaskExecutionMetadataMultiError is an error wrapping multiple validation +// errors returned by TaskExecutionMetadata.ValidateAll() if the designated +// constraints aren't met. +type TaskExecutionMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskExecutionMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskExecutionMetadataMultiError) AllErrors() []error { return m } + +// TaskExecutionMetadataValidationError is the validation error returned by +// TaskExecutionMetadata.Validate if the designated constraints aren't met. +type TaskExecutionMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskExecutionMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskExecutionMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskExecutionMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskExecutionMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskExecutionMetadataValidationError) ErrorName() string { + return "TaskExecutionMetadataValidationError" +} + +// Error satisfies the builtin error interface +func (e TaskExecutionMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskExecutionMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskExecutionMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskExecutionMetadataValidationError{} diff --git a/gen/go/flyteidl2/imagebuilder/definition.pb.go b/gen/go/flyteidl2/imagebuilder/definition.pb.go new file mode 100644 index 0000000000..c9487af513 --- /dev/null +++ b/gen/go/flyteidl2/imagebuilder/definition.pb.go @@ -0,0 +1,1561 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/imagebuilder/definition.proto + +package imagebuilder + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// ImageIdentifier is how to identify an image +type ImageIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *ImageIdentifier) Reset() { + *x = ImageIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ImageIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ImageIdentifier) ProtoMessage() {} + +func (x *ImageIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ImageIdentifier.ProtoReflect.Descriptor instead. +func (*ImageIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_imagebuilder_definition_proto_rawDescGZIP(), []int{0} +} + +func (x *ImageIdentifier) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +// Simple container to surface if image exists +type Image struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id *ImageIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // Fully qualified, pullable, image name + Fqin string `protobuf:"bytes,2,opt,name=fqin,proto3" json:"fqin,omitempty"` +} + +func (x *Image) Reset() { + *x = Image{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Image) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Image) ProtoMessage() {} + +func (x *Image) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Image.ProtoReflect.Descriptor instead. +func (*Image) Descriptor() ([]byte, []int) { + return file_flyteidl2_imagebuilder_definition_proto_rawDescGZIP(), []int{1} +} + +func (x *Image) GetId() *ImageIdentifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *Image) GetFqin() string { + if x != nil { + return x.Fqin + } + return "" +} + +// AptPackages defines a list of apt packages to install in the image. +type AptPackages struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // List of apt packages to install + Packages []string `protobuf:"bytes,1,rep,name=packages,proto3" json:"packages,omitempty"` + SecretMounts []*core.Secret `protobuf:"bytes,2,rep,name=secret_mounts,json=secretMounts,proto3" json:"secret_mounts,omitempty"` +} + +func (x *AptPackages) Reset() { + *x = AptPackages{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AptPackages) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AptPackages) ProtoMessage() {} + +func (x *AptPackages) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AptPackages.ProtoReflect.Descriptor instead. +func (*AptPackages) Descriptor() ([]byte, []int) { + return file_flyteidl2_imagebuilder_definition_proto_rawDescGZIP(), []int{2} +} + +func (x *AptPackages) GetPackages() []string { + if x != nil { + return x.Packages + } + return nil +} + +func (x *AptPackages) GetSecretMounts() []*core.Secret { + if x != nil { + return x.SecretMounts + } + return nil +} + +// PipOptions defines options for pip packages to install in the image. +type PipOptions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Optional index URL for pip packages + IndexUrl string `protobuf:"bytes,2,opt,name=index_url,json=indexUrl,proto3" json:"index_url,omitempty"` + // Optional list of extra index URLs for pip packages + ExtraIndexUrls []string `protobuf:"bytes,3,rep,name=extra_index_urls,json=extraIndexUrls,proto3" json:"extra_index_urls,omitempty"` + // Optional pre-release flag for pip packages + Pre bool `protobuf:"varint,4,opt,name=pre,proto3" json:"pre,omitempty"` + // Optional extra arguments for pip install command + ExtraArgs string `protobuf:"bytes,5,opt,name=extra_args,json=extraArgs,proto3" json:"extra_args,omitempty"` +} + +func (x *PipOptions) Reset() { + *x = PipOptions{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PipOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PipOptions) ProtoMessage() {} + +func (x *PipOptions) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PipOptions.ProtoReflect.Descriptor instead. +func (*PipOptions) Descriptor() ([]byte, []int) { + return file_flyteidl2_imagebuilder_definition_proto_rawDescGZIP(), []int{3} +} + +func (x *PipOptions) GetIndexUrl() string { + if x != nil { + return x.IndexUrl + } + return "" +} + +func (x *PipOptions) GetExtraIndexUrls() []string { + if x != nil { + return x.ExtraIndexUrls + } + return nil +} + +func (x *PipOptions) GetPre() bool { + if x != nil { + return x.Pre + } + return false +} + +func (x *PipOptions) GetExtraArgs() string { + if x != nil { + return x.ExtraArgs + } + return "" +} + +// PipPackages defines a list of pip packages to install in the image. +type PipPackages struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // List of pip packages to install + Packages []string `protobuf:"bytes,1,rep,name=packages,proto3" json:"packages,omitempty"` + // Options for pip packages. + Options *PipOptions `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"` + SecretMounts []*core.Secret `protobuf:"bytes,3,rep,name=secret_mounts,json=secretMounts,proto3" json:"secret_mounts,omitempty"` +} + +func (x *PipPackages) Reset() { + *x = PipPackages{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PipPackages) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PipPackages) ProtoMessage() {} + +func (x *PipPackages) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PipPackages.ProtoReflect.Descriptor instead. +func (*PipPackages) Descriptor() ([]byte, []int) { + return file_flyteidl2_imagebuilder_definition_proto_rawDescGZIP(), []int{4} +} + +func (x *PipPackages) GetPackages() []string { + if x != nil { + return x.Packages + } + return nil +} + +func (x *PipPackages) GetOptions() *PipOptions { + if x != nil { + return x.Options + } + return nil +} + +func (x *PipPackages) GetSecretMounts() []*core.Secret { + if x != nil { + return x.SecretMounts + } + return nil +} + +// Requirements defines a python requirements file to use in the image. +type Requirements struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The requirements file to use. + File string `protobuf:"bytes,1,opt,name=file,proto3" json:"file,omitempty"` + // Options for pip packages. + Options *PipOptions `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"` + SecretMounts []*core.Secret `protobuf:"bytes,3,rep,name=secret_mounts,json=secretMounts,proto3" json:"secret_mounts,omitempty"` +} + +func (x *Requirements) Reset() { + *x = Requirements{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Requirements) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Requirements) ProtoMessage() {} + +func (x *Requirements) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Requirements.ProtoReflect.Descriptor instead. +func (*Requirements) Descriptor() ([]byte, []int) { + return file_flyteidl2_imagebuilder_definition_proto_rawDescGZIP(), []int{5} +} + +func (x *Requirements) GetFile() string { + if x != nil { + return x.File + } + return "" +} + +func (x *Requirements) GetOptions() *PipOptions { + if x != nil { + return x.Options + } + return nil +} + +func (x *Requirements) GetSecretMounts() []*core.Secret { + if x != nil { + return x.SecretMounts + } + return nil +} + +type PythonWheels struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The directory containing Python wheel files. + Dir string `protobuf:"bytes,1,opt,name=dir,proto3" json:"dir,omitempty"` + // Options for pip packages. + Options *PipOptions `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"` + SecretMounts []*core.Secret `protobuf:"bytes,3,rep,name=secret_mounts,json=secretMounts,proto3" json:"secret_mounts,omitempty"` +} + +func (x *PythonWheels) Reset() { + *x = PythonWheels{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PythonWheels) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PythonWheels) ProtoMessage() {} + +func (x *PythonWheels) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PythonWheels.ProtoReflect.Descriptor instead. +func (*PythonWheels) Descriptor() ([]byte, []int) { + return file_flyteidl2_imagebuilder_definition_proto_rawDescGZIP(), []int{6} +} + +func (x *PythonWheels) GetDir() string { + if x != nil { + return x.Dir + } + return "" +} + +func (x *PythonWheels) GetOptions() *PipOptions { + if x != nil { + return x.Options + } + return nil +} + +func (x *PythonWheels) GetSecretMounts() []*core.Secret { + if x != nil { + return x.SecretMounts + } + return nil +} + +// UVProject defines a UV project configuration, which includes +// a pyproject.toml file and a uvlock file. +type UVProject struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Pyproject string `protobuf:"bytes,1,opt,name=pyproject,proto3" json:"pyproject,omitempty"` + Uvlock string `protobuf:"bytes,2,opt,name=uvlock,proto3" json:"uvlock,omitempty"` + // Options for pip packages. + Options *PipOptions `protobuf:"bytes,3,opt,name=options,proto3" json:"options,omitempty"` + SecretMounts []*core.Secret `protobuf:"bytes,4,rep,name=secret_mounts,json=secretMounts,proto3" json:"secret_mounts,omitempty"` +} + +func (x *UVProject) Reset() { + *x = UVProject{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UVProject) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UVProject) ProtoMessage() {} + +func (x *UVProject) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UVProject.ProtoReflect.Descriptor instead. +func (*UVProject) Descriptor() ([]byte, []int) { + return file_flyteidl2_imagebuilder_definition_proto_rawDescGZIP(), []int{7} +} + +func (x *UVProject) GetPyproject() string { + if x != nil { + return x.Pyproject + } + return "" +} + +func (x *UVProject) GetUvlock() string { + if x != nil { + return x.Uvlock + } + return "" +} + +func (x *UVProject) GetOptions() *PipOptions { + if x != nil { + return x.Options + } + return nil +} + +func (x *UVProject) GetSecretMounts() []*core.Secret { + if x != nil { + return x.SecretMounts + } + return nil +} + +// Commands defines a list of commands to run in the image. +type Commands struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The command to run. + Cmd []string `protobuf:"bytes,2,rep,name=cmd,proto3" json:"cmd,omitempty"` + SecretMounts []*core.Secret `protobuf:"bytes,3,rep,name=secret_mounts,json=secretMounts,proto3" json:"secret_mounts,omitempty"` +} + +func (x *Commands) Reset() { + *x = Commands{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Commands) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Commands) ProtoMessage() {} + +func (x *Commands) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Commands.ProtoReflect.Descriptor instead. +func (*Commands) Descriptor() ([]byte, []int) { + return file_flyteidl2_imagebuilder_definition_proto_rawDescGZIP(), []int{8} +} + +func (x *Commands) GetCmd() []string { + if x != nil { + return x.Cmd + } + return nil +} + +func (x *Commands) GetSecretMounts() []*core.Secret { + if x != nil { + return x.SecretMounts + } + return nil +} + +// WorkDir defines the working directory to set in the image. +type WorkDir struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The working directory to use. + Workdir string `protobuf:"bytes,1,opt,name=workdir,proto3" json:"workdir,omitempty"` +} + +func (x *WorkDir) Reset() { + *x = WorkDir{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WorkDir) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorkDir) ProtoMessage() {} + +func (x *WorkDir) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorkDir.ProtoReflect.Descriptor instead. +func (*WorkDir) Descriptor() ([]byte, []int) { + return file_flyteidl2_imagebuilder_definition_proto_rawDescGZIP(), []int{9} +} + +func (x *WorkDir) GetWorkdir() string { + if x != nil { + return x.Workdir + } + return "" +} + +// CopyConfig defines a configuration for copying files/directories into the image. +type CopyConfig struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The source directory to copy from. + Src string `protobuf:"bytes,1,opt,name=src,proto3" json:"src,omitempty"` + // The destination directory to copy to. + Dst string `protobuf:"bytes,2,opt,name=dst,proto3" json:"dst,omitempty"` +} + +func (x *CopyConfig) Reset() { + *x = CopyConfig{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CopyConfig) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CopyConfig) ProtoMessage() {} + +func (x *CopyConfig) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CopyConfig.ProtoReflect.Descriptor instead. +func (*CopyConfig) Descriptor() ([]byte, []int) { + return file_flyteidl2_imagebuilder_definition_proto_rawDescGZIP(), []int{10} +} + +func (x *CopyConfig) GetSrc() string { + if x != nil { + return x.Src + } + return "" +} + +func (x *CopyConfig) GetDst() string { + if x != nil { + return x.Dst + } + return "" +} + +// Env defines environment to set in the image. +type Env struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Environment variables to set in the image. + EnvVariables map[string]string `protobuf:"bytes,1,rep,name=env_variables,json=envVariables,proto3" json:"env_variables,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *Env) Reset() { + *x = Env{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Env) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Env) ProtoMessage() {} + +func (x *Env) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Env.ProtoReflect.Descriptor instead. +func (*Env) Descriptor() ([]byte, []int) { + return file_flyteidl2_imagebuilder_definition_proto_rawDescGZIP(), []int{11} +} + +func (x *Env) GetEnvVariables() map[string]string { + if x != nil { + return x.EnvVariables + } + return nil +} + +type PoetryProject struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Pyproject string `protobuf:"bytes,1,opt,name=pyproject,proto3" json:"pyproject,omitempty"` + PoetryLock string `protobuf:"bytes,2,opt,name=poetry_lock,json=poetryLock,proto3" json:"poetry_lock,omitempty"` + // Optional extra arguments for poetry install command + ExtraArgs string `protobuf:"bytes,3,opt,name=extra_args,json=extraArgs,proto3" json:"extra_args,omitempty"` + SecretMounts []*core.Secret `protobuf:"bytes,4,rep,name=secret_mounts,json=secretMounts,proto3" json:"secret_mounts,omitempty"` +} + +func (x *PoetryProject) Reset() { + *x = PoetryProject{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PoetryProject) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PoetryProject) ProtoMessage() {} + +func (x *PoetryProject) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PoetryProject.ProtoReflect.Descriptor instead. +func (*PoetryProject) Descriptor() ([]byte, []int) { + return file_flyteidl2_imagebuilder_definition_proto_rawDescGZIP(), []int{12} +} + +func (x *PoetryProject) GetPyproject() string { + if x != nil { + return x.Pyproject + } + return "" +} + +func (x *PoetryProject) GetPoetryLock() string { + if x != nil { + return x.PoetryLock + } + return "" +} + +func (x *PoetryProject) GetExtraArgs() string { + if x != nil { + return x.ExtraArgs + } + return "" +} + +func (x *PoetryProject) GetSecretMounts() []*core.Secret { + if x != nil { + return x.SecretMounts + } + return nil +} + +// Layer defines a layer in the image, which can be one of several types. +type Layer struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Layer: + // + // *Layer_AptPackages + // *Layer_PipPackages + // *Layer_Commands + // *Layer_Requirements + // *Layer_PythonWheels + // *Layer_Workdir + // *Layer_CopyConfig + // *Layer_UvProject + // *Layer_Env + // *Layer_PoetryProject + Layer isLayer_Layer `protobuf_oneof:"layer"` +} + +func (x *Layer) Reset() { + *x = Layer{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Layer) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Layer) ProtoMessage() {} + +func (x *Layer) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Layer.ProtoReflect.Descriptor instead. +func (*Layer) Descriptor() ([]byte, []int) { + return file_flyteidl2_imagebuilder_definition_proto_rawDescGZIP(), []int{13} +} + +func (m *Layer) GetLayer() isLayer_Layer { + if m != nil { + return m.Layer + } + return nil +} + +func (x *Layer) GetAptPackages() *AptPackages { + if x, ok := x.GetLayer().(*Layer_AptPackages); ok { + return x.AptPackages + } + return nil +} + +func (x *Layer) GetPipPackages() *PipPackages { + if x, ok := x.GetLayer().(*Layer_PipPackages); ok { + return x.PipPackages + } + return nil +} + +func (x *Layer) GetCommands() *Commands { + if x, ok := x.GetLayer().(*Layer_Commands); ok { + return x.Commands + } + return nil +} + +func (x *Layer) GetRequirements() *Requirements { + if x, ok := x.GetLayer().(*Layer_Requirements); ok { + return x.Requirements + } + return nil +} + +func (x *Layer) GetPythonWheels() *PythonWheels { + if x, ok := x.GetLayer().(*Layer_PythonWheels); ok { + return x.PythonWheels + } + return nil +} + +func (x *Layer) GetWorkdir() *WorkDir { + if x, ok := x.GetLayer().(*Layer_Workdir); ok { + return x.Workdir + } + return nil +} + +func (x *Layer) GetCopyConfig() *CopyConfig { + if x, ok := x.GetLayer().(*Layer_CopyConfig); ok { + return x.CopyConfig + } + return nil +} + +func (x *Layer) GetUvProject() *UVProject { + if x, ok := x.GetLayer().(*Layer_UvProject); ok { + return x.UvProject + } + return nil +} + +func (x *Layer) GetEnv() *Env { + if x, ok := x.GetLayer().(*Layer_Env); ok { + return x.Env + } + return nil +} + +func (x *Layer) GetPoetryProject() *PoetryProject { + if x, ok := x.GetLayer().(*Layer_PoetryProject); ok { + return x.PoetryProject + } + return nil +} + +type isLayer_Layer interface { + isLayer_Layer() +} + +type Layer_AptPackages struct { + // Apt packages to install. + AptPackages *AptPackages `protobuf:"bytes,1,opt,name=apt_packages,json=aptPackages,proto3,oneof"` +} + +type Layer_PipPackages struct { + // Python packages to install. + PipPackages *PipPackages `protobuf:"bytes,2,opt,name=pip_packages,json=pipPackages,proto3,oneof"` +} + +type Layer_Commands struct { + // Custom command to run. + Commands *Commands `protobuf:"bytes,3,opt,name=commands,proto3,oneof"` +} + +type Layer_Requirements struct { + // Requirements file to use. + Requirements *Requirements `protobuf:"bytes,4,opt,name=requirements,proto3,oneof"` +} + +type Layer_PythonWheels struct { + // Python wheel file to use. + PythonWheels *PythonWheels `protobuf:"bytes,5,opt,name=python_wheels,json=pythonWheels,proto3,oneof"` +} + +type Layer_Workdir struct { + // Working directory to set. + Workdir *WorkDir `protobuf:"bytes,6,opt,name=workdir,proto3,oneof"` +} + +type Layer_CopyConfig struct { + // Copy files/directories into the image. + CopyConfig *CopyConfig `protobuf:"bytes,7,opt,name=copy_config,json=copyConfig,proto3,oneof"` +} + +type Layer_UvProject struct { + // UV project configuration. + UvProject *UVProject `protobuf:"bytes,8,opt,name=uv_project,json=uvProject,proto3,oneof"` +} + +type Layer_Env struct { + // Environment variables to set. + Env *Env `protobuf:"bytes,9,opt,name=env,proto3,oneof"` +} + +type Layer_PoetryProject struct { + // Poetry project configuration + PoetryProject *PoetryProject `protobuf:"bytes,10,opt,name=poetry_project,json=poetryProject,proto3,oneof"` +} + +func (*Layer_AptPackages) isLayer_Layer() {} + +func (*Layer_PipPackages) isLayer_Layer() {} + +func (*Layer_Commands) isLayer_Layer() {} + +func (*Layer_Requirements) isLayer_Layer() {} + +func (*Layer_PythonWheels) isLayer_Layer() {} + +func (*Layer_Workdir) isLayer_Layer() {} + +func (*Layer_CopyConfig) isLayer_Layer() {} + +func (*Layer_UvProject) isLayer_Layer() {} + +func (*Layer_Env) isLayer_Layer() {} + +func (*Layer_PoetryProject) isLayer_Layer() {} + +// Image definition defined in the sdk. +type ImageSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Identifier for the base image. + BaseImage string `protobuf:"bytes,1,opt,name=base_image,json=baseImage,proto3" json:"base_image,omitempty"` + // python version to use in the image. + PythonVersion string `protobuf:"bytes,2,opt,name=python_version,json=pythonVersion,proto3" json:"python_version,omitempty"` + // List of layers to apply to the image. + Layers []*Layer `protobuf:"bytes,3,rep,name=layers,proto3" json:"layers,omitempty"` + // List of platforms to build the image for. + Platform []string `protobuf:"bytes,4,rep,name=platform,proto3" json:"platform,omitempty"` +} + +func (x *ImageSpec) Reset() { + *x = ImageSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ImageSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ImageSpec) ProtoMessage() {} + +func (x *ImageSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_imagebuilder_definition_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ImageSpec.ProtoReflect.Descriptor instead. +func (*ImageSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_imagebuilder_definition_proto_rawDescGZIP(), []int{14} +} + +func (x *ImageSpec) GetBaseImage() string { + if x != nil { + return x.BaseImage + } + return "" +} + +func (x *ImageSpec) GetPythonVersion() string { + if x != nil { + return x.PythonVersion + } + return "" +} + +func (x *ImageSpec) GetLayers() []*Layer { + if x != nil { + return x.Layers + } + return nil +} + +func (x *ImageSpec) GetPlatform() []string { + if x != nil { + return x.Platform + } + return nil +} + +var File_flyteidl2_imagebuilder_definition_proto protoreflect.FileDescriptor + +var file_flyteidl2_imagebuilder_definition_proto_rawDesc = []byte{ + 0x0a, 0x27, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x16, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, + 0x72, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1d, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x73, + 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x2e, 0x0a, + 0x0f, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, + 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x54, 0x0a, + 0x05, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x37, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, + 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x49, 0x6d, 0x61, 0x67, + 0x65, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x02, 0x69, 0x64, 0x12, + 0x12, 0x0a, 0x04, 0x66, 0x71, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x66, + 0x71, 0x69, 0x6e, 0x22, 0x66, 0x0a, 0x0b, 0x41, 0x70, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, + 0x65, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x12, 0x3b, + 0x0a, 0x0d, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x0c, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0x84, 0x01, 0x0a, 0x0a, + 0x50, 0x69, 0x70, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x69, 0x6e, + 0x64, 0x65, 0x78, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x69, + 0x6e, 0x64, 0x65, 0x78, 0x55, 0x72, 0x6c, 0x12, 0x28, 0x0a, 0x10, 0x65, 0x78, 0x74, 0x72, 0x61, + 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x75, 0x72, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x0e, 0x65, 0x78, 0x74, 0x72, 0x61, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x55, 0x72, 0x6c, + 0x73, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x72, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x03, + 0x70, 0x72, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x65, 0x78, 0x74, 0x72, 0x61, 0x5f, 0x61, 0x72, 0x67, + 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x65, 0x78, 0x74, 0x72, 0x61, 0x41, 0x72, + 0x67, 0x73, 0x22, 0xa4, 0x01, 0x0a, 0x0b, 0x50, 0x69, 0x70, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, + 0x65, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x12, 0x3c, + 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x50, 0x69, 0x70, 0x4f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3b, 0x0a, 0x0d, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x0c, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0x9d, 0x01, 0x0a, 0x0c, 0x52, 0x65, + 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x69, + 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x3c, + 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x50, 0x69, 0x70, 0x4f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3b, 0x0a, 0x0d, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x0c, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0x9b, 0x01, 0x0a, 0x0c, 0x50, 0x79, + 0x74, 0x68, 0x6f, 0x6e, 0x57, 0x68, 0x65, 0x65, 0x6c, 0x73, 0x12, 0x10, 0x0a, 0x03, 0x64, 0x69, + 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x64, 0x69, 0x72, 0x12, 0x3c, 0x0a, 0x07, + 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, + 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x50, 0x69, 0x70, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3b, 0x0a, 0x0d, 0x73, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x5f, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x0c, 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0xbc, 0x01, 0x0a, 0x09, 0x55, 0x56, 0x50, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x79, 0x70, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, 0x79, 0x70, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x75, 0x76, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x75, 0x76, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x3c, 0x0a, 0x07, 0x6f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, + 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x50, 0x69, 0x70, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3b, 0x0a, 0x0d, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x5f, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x0c, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0x59, 0x0a, 0x08, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, + 0x64, 0x73, 0x12, 0x10, 0x0a, 0x03, 0x63, 0x6d, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, + 0x03, 0x63, 0x6d, 0x64, 0x12, 0x3b, 0x0a, 0x0d, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, 0x6d, + 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x52, 0x0c, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4d, 0x6f, 0x75, 0x6e, 0x74, + 0x73, 0x22, 0x23, 0x0a, 0x07, 0x57, 0x6f, 0x72, 0x6b, 0x44, 0x69, 0x72, 0x12, 0x18, 0x0a, 0x07, + 0x77, 0x6f, 0x72, 0x6b, 0x64, 0x69, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x77, + 0x6f, 0x72, 0x6b, 0x64, 0x69, 0x72, 0x22, 0x30, 0x0a, 0x0a, 0x43, 0x6f, 0x70, 0x79, 0x43, 0x6f, + 0x6e, 0x66, 0x69, 0x67, 0x12, 0x10, 0x0a, 0x03, 0x73, 0x72, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x03, 0x73, 0x72, 0x63, 0x12, 0x10, 0x0a, 0x03, 0x64, 0x73, 0x74, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x64, 0x73, 0x74, 0x22, 0x9a, 0x01, 0x0a, 0x03, 0x45, 0x6e, 0x76, + 0x12, 0x52, 0x0a, 0x0d, 0x65, 0x6e, 0x76, 0x5f, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, + 0x2e, 0x45, 0x6e, 0x76, 0x2e, 0x45, 0x6e, 0x76, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, + 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x65, 0x6e, 0x76, 0x56, 0x61, 0x72, 0x69, 0x61, + 0x62, 0x6c, 0x65, 0x73, 0x1a, 0x3f, 0x0a, 0x11, 0x45, 0x6e, 0x76, 0x56, 0x61, 0x72, 0x69, 0x61, + 0x62, 0x6c, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xaa, 0x01, 0x0a, 0x0d, 0x50, 0x6f, 0x65, 0x74, 0x72, 0x79, + 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x79, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, 0x79, 0x70, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x6f, 0x65, 0x74, 0x72, 0x79, 0x5f, + 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x6f, 0x65, 0x74, + 0x72, 0x79, 0x4c, 0x6f, 0x63, 0x6b, 0x12, 0x1d, 0x0a, 0x0a, 0x65, 0x78, 0x74, 0x72, 0x61, 0x5f, + 0x61, 0x72, 0x67, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x65, 0x78, 0x74, 0x72, + 0x61, 0x41, 0x72, 0x67, 0x73, 0x12, 0x3b, 0x0a, 0x0d, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, + 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x52, 0x0c, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4d, 0x6f, 0x75, 0x6e, + 0x74, 0x73, 0x22, 0xc6, 0x05, 0x0a, 0x05, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x12, 0x48, 0x0a, 0x0c, + 0x61, 0x70, 0x74, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, + 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x41, 0x70, 0x74, 0x50, + 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x48, 0x00, 0x52, 0x0b, 0x61, 0x70, 0x74, 0x50, 0x61, + 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x12, 0x48, 0x0a, 0x0c, 0x70, 0x69, 0x70, 0x5f, 0x70, 0x61, + 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, + 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x50, 0x69, 0x70, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, + 0x73, 0x48, 0x00, 0x52, 0x0b, 0x70, 0x69, 0x70, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, + 0x12, 0x3e, 0x0a, 0x08, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x73, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, + 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, + 0x61, 0x6e, 0x64, 0x73, 0x48, 0x00, 0x52, 0x08, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x73, + 0x12, 0x4a, 0x0a, 0x0c, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, + 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x48, 0x00, 0x52, 0x0c, + 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x4b, 0x0a, 0x0d, + 0x70, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x5f, 0x77, 0x68, 0x65, 0x65, 0x6c, 0x73, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x50, 0x79, 0x74, + 0x68, 0x6f, 0x6e, 0x57, 0x68, 0x65, 0x65, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x0c, 0x70, 0x79, 0x74, + 0x68, 0x6f, 0x6e, 0x57, 0x68, 0x65, 0x65, 0x6c, 0x73, 0x12, 0x3b, 0x0a, 0x07, 0x77, 0x6f, 0x72, + 0x6b, 0x64, 0x69, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, + 0x64, 0x65, 0x72, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x44, 0x69, 0x72, 0x48, 0x00, 0x52, 0x07, 0x77, + 0x6f, 0x72, 0x6b, 0x64, 0x69, 0x72, 0x12, 0x45, 0x0a, 0x0b, 0x63, 0x6f, 0x70, 0x79, 0x5f, 0x63, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, + 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x43, 0x6f, 0x70, 0x79, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x48, + 0x00, 0x52, 0x0a, 0x63, 0x6f, 0x70, 0x79, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x42, 0x0a, + 0x0a, 0x75, 0x76, 0x5f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, + 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x55, 0x56, 0x50, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x48, 0x00, 0x52, 0x09, 0x75, 0x76, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x12, 0x2f, 0x0a, 0x03, 0x65, 0x6e, 0x76, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, + 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x45, 0x6e, 0x76, 0x48, 0x00, 0x52, 0x03, 0x65, + 0x6e, 0x76, 0x12, 0x4e, 0x0a, 0x0e, 0x70, 0x6f, 0x65, 0x74, 0x72, 0x79, 0x5f, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, + 0x64, 0x65, 0x72, 0x2e, 0x50, 0x6f, 0x65, 0x74, 0x72, 0x79, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x48, 0x00, 0x52, 0x0d, 0x70, 0x6f, 0x65, 0x74, 0x72, 0x79, 0x50, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x42, 0x07, 0x0a, 0x05, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x22, 0xa4, 0x01, 0x0a, 0x09, + 0x49, 0x6d, 0x61, 0x67, 0x65, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x61, 0x73, + 0x65, 0x5f, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x62, + 0x61, 0x73, 0x65, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x70, 0x79, 0x74, 0x68, + 0x6f, 0x6e, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0d, 0x70, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, + 0x35, 0x0a, 0x06, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x52, 0x06, + 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x42, 0xe4, 0x01, 0x0a, 0x1a, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, + 0x72, 0x42, 0x0f, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, + 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, + 0x65, 0x72, 0xa2, 0x02, 0x03, 0x46, 0x49, 0x58, 0xaa, 0x02, 0x16, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, + 0x72, 0xca, 0x02, 0x16, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x49, 0x6d, + 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0xe2, 0x02, 0x22, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, + 0x64, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, + 0x02, 0x17, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x49, 0x6d, 0x61, + 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, +} + +var ( + file_flyteidl2_imagebuilder_definition_proto_rawDescOnce sync.Once + file_flyteidl2_imagebuilder_definition_proto_rawDescData = file_flyteidl2_imagebuilder_definition_proto_rawDesc +) + +func file_flyteidl2_imagebuilder_definition_proto_rawDescGZIP() []byte { + file_flyteidl2_imagebuilder_definition_proto_rawDescOnce.Do(func() { + file_flyteidl2_imagebuilder_definition_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_imagebuilder_definition_proto_rawDescData) + }) + return file_flyteidl2_imagebuilder_definition_proto_rawDescData +} + +var file_flyteidl2_imagebuilder_definition_proto_msgTypes = make([]protoimpl.MessageInfo, 16) +var file_flyteidl2_imagebuilder_definition_proto_goTypes = []interface{}{ + (*ImageIdentifier)(nil), // 0: flyteidl2.imagebuilder.ImageIdentifier + (*Image)(nil), // 1: flyteidl2.imagebuilder.Image + (*AptPackages)(nil), // 2: flyteidl2.imagebuilder.AptPackages + (*PipOptions)(nil), // 3: flyteidl2.imagebuilder.PipOptions + (*PipPackages)(nil), // 4: flyteidl2.imagebuilder.PipPackages + (*Requirements)(nil), // 5: flyteidl2.imagebuilder.Requirements + (*PythonWheels)(nil), // 6: flyteidl2.imagebuilder.PythonWheels + (*UVProject)(nil), // 7: flyteidl2.imagebuilder.UVProject + (*Commands)(nil), // 8: flyteidl2.imagebuilder.Commands + (*WorkDir)(nil), // 9: flyteidl2.imagebuilder.WorkDir + (*CopyConfig)(nil), // 10: flyteidl2.imagebuilder.CopyConfig + (*Env)(nil), // 11: flyteidl2.imagebuilder.Env + (*PoetryProject)(nil), // 12: flyteidl2.imagebuilder.PoetryProject + (*Layer)(nil), // 13: flyteidl2.imagebuilder.Layer + (*ImageSpec)(nil), // 14: flyteidl2.imagebuilder.ImageSpec + nil, // 15: flyteidl2.imagebuilder.Env.EnvVariablesEntry + (*core.Secret)(nil), // 16: flyteidl2.core.Secret +} +var file_flyteidl2_imagebuilder_definition_proto_depIdxs = []int32{ + 0, // 0: flyteidl2.imagebuilder.Image.id:type_name -> flyteidl2.imagebuilder.ImageIdentifier + 16, // 1: flyteidl2.imagebuilder.AptPackages.secret_mounts:type_name -> flyteidl2.core.Secret + 3, // 2: flyteidl2.imagebuilder.PipPackages.options:type_name -> flyteidl2.imagebuilder.PipOptions + 16, // 3: flyteidl2.imagebuilder.PipPackages.secret_mounts:type_name -> flyteidl2.core.Secret + 3, // 4: flyteidl2.imagebuilder.Requirements.options:type_name -> flyteidl2.imagebuilder.PipOptions + 16, // 5: flyteidl2.imagebuilder.Requirements.secret_mounts:type_name -> flyteidl2.core.Secret + 3, // 6: flyteidl2.imagebuilder.PythonWheels.options:type_name -> flyteidl2.imagebuilder.PipOptions + 16, // 7: flyteidl2.imagebuilder.PythonWheels.secret_mounts:type_name -> flyteidl2.core.Secret + 3, // 8: flyteidl2.imagebuilder.UVProject.options:type_name -> flyteidl2.imagebuilder.PipOptions + 16, // 9: flyteidl2.imagebuilder.UVProject.secret_mounts:type_name -> flyteidl2.core.Secret + 16, // 10: flyteidl2.imagebuilder.Commands.secret_mounts:type_name -> flyteidl2.core.Secret + 15, // 11: flyteidl2.imagebuilder.Env.env_variables:type_name -> flyteidl2.imagebuilder.Env.EnvVariablesEntry + 16, // 12: flyteidl2.imagebuilder.PoetryProject.secret_mounts:type_name -> flyteidl2.core.Secret + 2, // 13: flyteidl2.imagebuilder.Layer.apt_packages:type_name -> flyteidl2.imagebuilder.AptPackages + 4, // 14: flyteidl2.imagebuilder.Layer.pip_packages:type_name -> flyteidl2.imagebuilder.PipPackages + 8, // 15: flyteidl2.imagebuilder.Layer.commands:type_name -> flyteidl2.imagebuilder.Commands + 5, // 16: flyteidl2.imagebuilder.Layer.requirements:type_name -> flyteidl2.imagebuilder.Requirements + 6, // 17: flyteidl2.imagebuilder.Layer.python_wheels:type_name -> flyteidl2.imagebuilder.PythonWheels + 9, // 18: flyteidl2.imagebuilder.Layer.workdir:type_name -> flyteidl2.imagebuilder.WorkDir + 10, // 19: flyteidl2.imagebuilder.Layer.copy_config:type_name -> flyteidl2.imagebuilder.CopyConfig + 7, // 20: flyteidl2.imagebuilder.Layer.uv_project:type_name -> flyteidl2.imagebuilder.UVProject + 11, // 21: flyteidl2.imagebuilder.Layer.env:type_name -> flyteidl2.imagebuilder.Env + 12, // 22: flyteidl2.imagebuilder.Layer.poetry_project:type_name -> flyteidl2.imagebuilder.PoetryProject + 13, // 23: flyteidl2.imagebuilder.ImageSpec.layers:type_name -> flyteidl2.imagebuilder.Layer + 24, // [24:24] is the sub-list for method output_type + 24, // [24:24] is the sub-list for method input_type + 24, // [24:24] is the sub-list for extension type_name + 24, // [24:24] is the sub-list for extension extendee + 0, // [0:24] is the sub-list for field type_name +} + +func init() { file_flyteidl2_imagebuilder_definition_proto_init() } +func file_flyteidl2_imagebuilder_definition_proto_init() { + if File_flyteidl2_imagebuilder_definition_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_imagebuilder_definition_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ImageIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_imagebuilder_definition_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Image); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_imagebuilder_definition_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AptPackages); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_imagebuilder_definition_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PipOptions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_imagebuilder_definition_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PipPackages); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_imagebuilder_definition_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Requirements); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_imagebuilder_definition_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PythonWheels); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_imagebuilder_definition_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UVProject); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_imagebuilder_definition_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Commands); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_imagebuilder_definition_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WorkDir); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_imagebuilder_definition_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CopyConfig); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_imagebuilder_definition_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Env); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_imagebuilder_definition_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PoetryProject); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_imagebuilder_definition_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Layer); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_imagebuilder_definition_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ImageSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_imagebuilder_definition_proto_msgTypes[13].OneofWrappers = []interface{}{ + (*Layer_AptPackages)(nil), + (*Layer_PipPackages)(nil), + (*Layer_Commands)(nil), + (*Layer_Requirements)(nil), + (*Layer_PythonWheels)(nil), + (*Layer_Workdir)(nil), + (*Layer_CopyConfig)(nil), + (*Layer_UvProject)(nil), + (*Layer_Env)(nil), + (*Layer_PoetryProject)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_imagebuilder_definition_proto_rawDesc, + NumEnums: 0, + NumMessages: 16, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_imagebuilder_definition_proto_goTypes, + DependencyIndexes: file_flyteidl2_imagebuilder_definition_proto_depIdxs, + MessageInfos: file_flyteidl2_imagebuilder_definition_proto_msgTypes, + }.Build() + File_flyteidl2_imagebuilder_definition_proto = out.File + file_flyteidl2_imagebuilder_definition_proto_rawDesc = nil + file_flyteidl2_imagebuilder_definition_proto_goTypes = nil + file_flyteidl2_imagebuilder_definition_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/imagebuilder/definition.pb.validate.go b/gen/go/flyteidl2/imagebuilder/definition.pb.validate.go new file mode 100644 index 0000000000..d15fa241b9 --- /dev/null +++ b/gen/go/flyteidl2/imagebuilder/definition.pb.validate.go @@ -0,0 +1,2387 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/imagebuilder/definition.proto + +package imagebuilder + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on ImageIdentifier with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *ImageIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ImageIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ImageIdentifierMultiError, or nil if none found. +func (m *ImageIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *ImageIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + if len(errors) > 0 { + return ImageIdentifierMultiError(errors) + } + + return nil +} + +// ImageIdentifierMultiError is an error wrapping multiple validation errors +// returned by ImageIdentifier.ValidateAll() if the designated constraints +// aren't met. +type ImageIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ImageIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ImageIdentifierMultiError) AllErrors() []error { return m } + +// ImageIdentifierValidationError is the validation error returned by +// ImageIdentifier.Validate if the designated constraints aren't met. +type ImageIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ImageIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ImageIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ImageIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ImageIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ImageIdentifierValidationError) ErrorName() string { return "ImageIdentifierValidationError" } + +// Error satisfies the builtin error interface +func (e ImageIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sImageIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ImageIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ImageIdentifierValidationError{} + +// Validate checks the field values on Image with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Image) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Image with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in ImageMultiError, or nil if none found. +func (m *Image) ValidateAll() error { + return m.validate(true) +} + +func (m *Image) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ImageValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ImageValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ImageValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Fqin + + if len(errors) > 0 { + return ImageMultiError(errors) + } + + return nil +} + +// ImageMultiError is an error wrapping multiple validation errors returned by +// Image.ValidateAll() if the designated constraints aren't met. +type ImageMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ImageMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ImageMultiError) AllErrors() []error { return m } + +// ImageValidationError is the validation error returned by Image.Validate if +// the designated constraints aren't met. +type ImageValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ImageValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ImageValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ImageValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ImageValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ImageValidationError) ErrorName() string { return "ImageValidationError" } + +// Error satisfies the builtin error interface +func (e ImageValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sImage.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ImageValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ImageValidationError{} + +// Validate checks the field values on AptPackages with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *AptPackages) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on AptPackages with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in AptPackagesMultiError, or +// nil if none found. +func (m *AptPackages) ValidateAll() error { + return m.validate(true) +} + +func (m *AptPackages) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetSecretMounts() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, AptPackagesValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, AptPackagesValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return AptPackagesValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return AptPackagesMultiError(errors) + } + + return nil +} + +// AptPackagesMultiError is an error wrapping multiple validation errors +// returned by AptPackages.ValidateAll() if the designated constraints aren't met. +type AptPackagesMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m AptPackagesMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m AptPackagesMultiError) AllErrors() []error { return m } + +// AptPackagesValidationError is the validation error returned by +// AptPackages.Validate if the designated constraints aren't met. +type AptPackagesValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e AptPackagesValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e AptPackagesValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e AptPackagesValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e AptPackagesValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e AptPackagesValidationError) ErrorName() string { return "AptPackagesValidationError" } + +// Error satisfies the builtin error interface +func (e AptPackagesValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sAptPackages.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = AptPackagesValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = AptPackagesValidationError{} + +// Validate checks the field values on PipOptions with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *PipOptions) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on PipOptions with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in PipOptionsMultiError, or +// nil if none found. +func (m *PipOptions) ValidateAll() error { + return m.validate(true) +} + +func (m *PipOptions) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for IndexUrl + + // no validation rules for Pre + + // no validation rules for ExtraArgs + + if len(errors) > 0 { + return PipOptionsMultiError(errors) + } + + return nil +} + +// PipOptionsMultiError is an error wrapping multiple validation errors +// returned by PipOptions.ValidateAll() if the designated constraints aren't met. +type PipOptionsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PipOptionsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PipOptionsMultiError) AllErrors() []error { return m } + +// PipOptionsValidationError is the validation error returned by +// PipOptions.Validate if the designated constraints aren't met. +type PipOptionsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PipOptionsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PipOptionsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PipOptionsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PipOptionsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PipOptionsValidationError) ErrorName() string { return "PipOptionsValidationError" } + +// Error satisfies the builtin error interface +func (e PipOptionsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPipOptions.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PipOptionsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PipOptionsValidationError{} + +// Validate checks the field values on PipPackages with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *PipPackages) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on PipPackages with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in PipPackagesMultiError, or +// nil if none found. +func (m *PipPackages) ValidateAll() error { + return m.validate(true) +} + +func (m *PipPackages) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetOptions()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PipPackagesValidationError{ + field: "Options", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PipPackagesValidationError{ + field: "Options", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOptions()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PipPackagesValidationError{ + field: "Options", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetSecretMounts() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PipPackagesValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PipPackagesValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PipPackagesValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return PipPackagesMultiError(errors) + } + + return nil +} + +// PipPackagesMultiError is an error wrapping multiple validation errors +// returned by PipPackages.ValidateAll() if the designated constraints aren't met. +type PipPackagesMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PipPackagesMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PipPackagesMultiError) AllErrors() []error { return m } + +// PipPackagesValidationError is the validation error returned by +// PipPackages.Validate if the designated constraints aren't met. +type PipPackagesValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PipPackagesValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PipPackagesValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PipPackagesValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PipPackagesValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PipPackagesValidationError) ErrorName() string { return "PipPackagesValidationError" } + +// Error satisfies the builtin error interface +func (e PipPackagesValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPipPackages.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PipPackagesValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PipPackagesValidationError{} + +// Validate checks the field values on Requirements with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Requirements) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Requirements with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in RequirementsMultiError, or +// nil if none found. +func (m *Requirements) ValidateAll() error { + return m.validate(true) +} + +func (m *Requirements) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for File + + if all { + switch v := interface{}(m.GetOptions()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, RequirementsValidationError{ + field: "Options", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, RequirementsValidationError{ + field: "Options", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOptions()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return RequirementsValidationError{ + field: "Options", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetSecretMounts() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, RequirementsValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, RequirementsValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return RequirementsValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return RequirementsMultiError(errors) + } + + return nil +} + +// RequirementsMultiError is an error wrapping multiple validation errors +// returned by Requirements.ValidateAll() if the designated constraints aren't met. +type RequirementsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m RequirementsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m RequirementsMultiError) AllErrors() []error { return m } + +// RequirementsValidationError is the validation error returned by +// Requirements.Validate if the designated constraints aren't met. +type RequirementsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e RequirementsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e RequirementsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e RequirementsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e RequirementsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e RequirementsValidationError) ErrorName() string { return "RequirementsValidationError" } + +// Error satisfies the builtin error interface +func (e RequirementsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sRequirements.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = RequirementsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = RequirementsValidationError{} + +// Validate checks the field values on PythonWheels with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *PythonWheels) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on PythonWheels with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in PythonWheelsMultiError, or +// nil if none found. +func (m *PythonWheels) ValidateAll() error { + return m.validate(true) +} + +func (m *PythonWheels) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Dir + + if all { + switch v := interface{}(m.GetOptions()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PythonWheelsValidationError{ + field: "Options", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PythonWheelsValidationError{ + field: "Options", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOptions()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PythonWheelsValidationError{ + field: "Options", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetSecretMounts() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PythonWheelsValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PythonWheelsValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PythonWheelsValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return PythonWheelsMultiError(errors) + } + + return nil +} + +// PythonWheelsMultiError is an error wrapping multiple validation errors +// returned by PythonWheels.ValidateAll() if the designated constraints aren't met. +type PythonWheelsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PythonWheelsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PythonWheelsMultiError) AllErrors() []error { return m } + +// PythonWheelsValidationError is the validation error returned by +// PythonWheels.Validate if the designated constraints aren't met. +type PythonWheelsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PythonWheelsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PythonWheelsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PythonWheelsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PythonWheelsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PythonWheelsValidationError) ErrorName() string { return "PythonWheelsValidationError" } + +// Error satisfies the builtin error interface +func (e PythonWheelsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPythonWheels.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PythonWheelsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PythonWheelsValidationError{} + +// Validate checks the field values on UVProject with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *UVProject) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on UVProject with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in UVProjectMultiError, or nil +// if none found. +func (m *UVProject) ValidateAll() error { + return m.validate(true) +} + +func (m *UVProject) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Pyproject + + // no validation rules for Uvlock + + if all { + switch v := interface{}(m.GetOptions()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UVProjectValidationError{ + field: "Options", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UVProjectValidationError{ + field: "Options", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOptions()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UVProjectValidationError{ + field: "Options", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetSecretMounts() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UVProjectValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UVProjectValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UVProjectValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return UVProjectMultiError(errors) + } + + return nil +} + +// UVProjectMultiError is an error wrapping multiple validation errors returned +// by UVProject.ValidateAll() if the designated constraints aren't met. +type UVProjectMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UVProjectMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UVProjectMultiError) AllErrors() []error { return m } + +// UVProjectValidationError is the validation error returned by +// UVProject.Validate if the designated constraints aren't met. +type UVProjectValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UVProjectValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UVProjectValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UVProjectValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UVProjectValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UVProjectValidationError) ErrorName() string { return "UVProjectValidationError" } + +// Error satisfies the builtin error interface +func (e UVProjectValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUVProject.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UVProjectValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UVProjectValidationError{} + +// Validate checks the field values on Commands with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Commands) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Commands with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in CommandsMultiError, or nil +// if none found. +func (m *Commands) ValidateAll() error { + return m.validate(true) +} + +func (m *Commands) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetSecretMounts() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CommandsValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CommandsValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CommandsValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return CommandsMultiError(errors) + } + + return nil +} + +// CommandsMultiError is an error wrapping multiple validation errors returned +// by Commands.ValidateAll() if the designated constraints aren't met. +type CommandsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CommandsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CommandsMultiError) AllErrors() []error { return m } + +// CommandsValidationError is the validation error returned by +// Commands.Validate if the designated constraints aren't met. +type CommandsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CommandsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CommandsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CommandsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CommandsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CommandsValidationError) ErrorName() string { return "CommandsValidationError" } + +// Error satisfies the builtin error interface +func (e CommandsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCommands.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CommandsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CommandsValidationError{} + +// Validate checks the field values on WorkDir with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *WorkDir) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WorkDir with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in WorkDirMultiError, or nil if none found. +func (m *WorkDir) ValidateAll() error { + return m.validate(true) +} + +func (m *WorkDir) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Workdir + + if len(errors) > 0 { + return WorkDirMultiError(errors) + } + + return nil +} + +// WorkDirMultiError is an error wrapping multiple validation errors returned +// by WorkDir.ValidateAll() if the designated constraints aren't met. +type WorkDirMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WorkDirMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WorkDirMultiError) AllErrors() []error { return m } + +// WorkDirValidationError is the validation error returned by WorkDir.Validate +// if the designated constraints aren't met. +type WorkDirValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WorkDirValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WorkDirValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WorkDirValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WorkDirValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WorkDirValidationError) ErrorName() string { return "WorkDirValidationError" } + +// Error satisfies the builtin error interface +func (e WorkDirValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWorkDir.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WorkDirValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WorkDirValidationError{} + +// Validate checks the field values on CopyConfig with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *CopyConfig) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CopyConfig with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in CopyConfigMultiError, or +// nil if none found. +func (m *CopyConfig) ValidateAll() error { + return m.validate(true) +} + +func (m *CopyConfig) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Src + + // no validation rules for Dst + + if len(errors) > 0 { + return CopyConfigMultiError(errors) + } + + return nil +} + +// CopyConfigMultiError is an error wrapping multiple validation errors +// returned by CopyConfig.ValidateAll() if the designated constraints aren't met. +type CopyConfigMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CopyConfigMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CopyConfigMultiError) AllErrors() []error { return m } + +// CopyConfigValidationError is the validation error returned by +// CopyConfig.Validate if the designated constraints aren't met. +type CopyConfigValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CopyConfigValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CopyConfigValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CopyConfigValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CopyConfigValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CopyConfigValidationError) ErrorName() string { return "CopyConfigValidationError" } + +// Error satisfies the builtin error interface +func (e CopyConfigValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCopyConfig.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CopyConfigValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CopyConfigValidationError{} + +// Validate checks the field values on Env with the rules defined in the proto +// definition for this message. If any rules are violated, the first error +// encountered is returned, or nil if there are no violations. +func (m *Env) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Env with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in EnvMultiError, or nil if none found. +func (m *Env) ValidateAll() error { + return m.validate(true) +} + +func (m *Env) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for EnvVariables + + if len(errors) > 0 { + return EnvMultiError(errors) + } + + return nil +} + +// EnvMultiError is an error wrapping multiple validation errors returned by +// Env.ValidateAll() if the designated constraints aren't met. +type EnvMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m EnvMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m EnvMultiError) AllErrors() []error { return m } + +// EnvValidationError is the validation error returned by Env.Validate if the +// designated constraints aren't met. +type EnvValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e EnvValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e EnvValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e EnvValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e EnvValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e EnvValidationError) ErrorName() string { return "EnvValidationError" } + +// Error satisfies the builtin error interface +func (e EnvValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sEnv.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = EnvValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = EnvValidationError{} + +// Validate checks the field values on PoetryProject with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *PoetryProject) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on PoetryProject with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in PoetryProjectMultiError, or +// nil if none found. +func (m *PoetryProject) ValidateAll() error { + return m.validate(true) +} + +func (m *PoetryProject) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Pyproject + + // no validation rules for PoetryLock + + // no validation rules for ExtraArgs + + for idx, item := range m.GetSecretMounts() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PoetryProjectValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PoetryProjectValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PoetryProjectValidationError{ + field: fmt.Sprintf("SecretMounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return PoetryProjectMultiError(errors) + } + + return nil +} + +// PoetryProjectMultiError is an error wrapping multiple validation errors +// returned by PoetryProject.ValidateAll() if the designated constraints +// aren't met. +type PoetryProjectMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PoetryProjectMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PoetryProjectMultiError) AllErrors() []error { return m } + +// PoetryProjectValidationError is the validation error returned by +// PoetryProject.Validate if the designated constraints aren't met. +type PoetryProjectValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PoetryProjectValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PoetryProjectValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PoetryProjectValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PoetryProjectValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PoetryProjectValidationError) ErrorName() string { return "PoetryProjectValidationError" } + +// Error satisfies the builtin error interface +func (e PoetryProjectValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPoetryProject.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PoetryProjectValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PoetryProjectValidationError{} + +// Validate checks the field values on Layer with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Layer) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Layer with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in LayerMultiError, or nil if none found. +func (m *Layer) ValidateAll() error { + return m.validate(true) +} + +func (m *Layer) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Layer.(type) { + case *Layer_AptPackages: + if v == nil { + err := LayerValidationError{ + field: "Layer", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetAptPackages()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LayerValidationError{ + field: "AptPackages", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LayerValidationError{ + field: "AptPackages", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAptPackages()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LayerValidationError{ + field: "AptPackages", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Layer_PipPackages: + if v == nil { + err := LayerValidationError{ + field: "Layer", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetPipPackages()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LayerValidationError{ + field: "PipPackages", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LayerValidationError{ + field: "PipPackages", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetPipPackages()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LayerValidationError{ + field: "PipPackages", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Layer_Commands: + if v == nil { + err := LayerValidationError{ + field: "Layer", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetCommands()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LayerValidationError{ + field: "Commands", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LayerValidationError{ + field: "Commands", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCommands()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LayerValidationError{ + field: "Commands", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Layer_Requirements: + if v == nil { + err := LayerValidationError{ + field: "Layer", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetRequirements()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LayerValidationError{ + field: "Requirements", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LayerValidationError{ + field: "Requirements", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRequirements()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LayerValidationError{ + field: "Requirements", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Layer_PythonWheels: + if v == nil { + err := LayerValidationError{ + field: "Layer", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetPythonWheels()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LayerValidationError{ + field: "PythonWheels", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LayerValidationError{ + field: "PythonWheels", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetPythonWheels()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LayerValidationError{ + field: "PythonWheels", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Layer_Workdir: + if v == nil { + err := LayerValidationError{ + field: "Layer", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetWorkdir()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LayerValidationError{ + field: "Workdir", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LayerValidationError{ + field: "Workdir", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetWorkdir()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LayerValidationError{ + field: "Workdir", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Layer_CopyConfig: + if v == nil { + err := LayerValidationError{ + field: "Layer", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetCopyConfig()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LayerValidationError{ + field: "CopyConfig", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LayerValidationError{ + field: "CopyConfig", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCopyConfig()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LayerValidationError{ + field: "CopyConfig", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Layer_UvProject: + if v == nil { + err := LayerValidationError{ + field: "Layer", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetUvProject()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LayerValidationError{ + field: "UvProject", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LayerValidationError{ + field: "UvProject", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetUvProject()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LayerValidationError{ + field: "UvProject", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Layer_Env: + if v == nil { + err := LayerValidationError{ + field: "Layer", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetEnv()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LayerValidationError{ + field: "Env", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LayerValidationError{ + field: "Env", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetEnv()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LayerValidationError{ + field: "Env", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Layer_PoetryProject: + if v == nil { + err := LayerValidationError{ + field: "Layer", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetPoetryProject()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LayerValidationError{ + field: "PoetryProject", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LayerValidationError{ + field: "PoetryProject", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetPoetryProject()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LayerValidationError{ + field: "PoetryProject", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return LayerMultiError(errors) + } + + return nil +} + +// LayerMultiError is an error wrapping multiple validation errors returned by +// Layer.ValidateAll() if the designated constraints aren't met. +type LayerMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LayerMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LayerMultiError) AllErrors() []error { return m } + +// LayerValidationError is the validation error returned by Layer.Validate if +// the designated constraints aren't met. +type LayerValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LayerValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LayerValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LayerValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LayerValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LayerValidationError) ErrorName() string { return "LayerValidationError" } + +// Error satisfies the builtin error interface +func (e LayerValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLayer.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LayerValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LayerValidationError{} + +// Validate checks the field values on ImageSpec with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ImageSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ImageSpec with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ImageSpecMultiError, or nil +// if none found. +func (m *ImageSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *ImageSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for BaseImage + + // no validation rules for PythonVersion + + for idx, item := range m.GetLayers() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ImageSpecValidationError{ + field: fmt.Sprintf("Layers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ImageSpecValidationError{ + field: fmt.Sprintf("Layers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ImageSpecValidationError{ + field: fmt.Sprintf("Layers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return ImageSpecMultiError(errors) + } + + return nil +} + +// ImageSpecMultiError is an error wrapping multiple validation errors returned +// by ImageSpec.ValidateAll() if the designated constraints aren't met. +type ImageSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ImageSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ImageSpecMultiError) AllErrors() []error { return m } + +// ImageSpecValidationError is the validation error returned by +// ImageSpec.Validate if the designated constraints aren't met. +type ImageSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ImageSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ImageSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ImageSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ImageSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ImageSpecValidationError) ErrorName() string { return "ImageSpecValidationError" } + +// Error satisfies the builtin error interface +func (e ImageSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sImageSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ImageSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ImageSpecValidationError{} diff --git a/gen/go/flyteidl2/imagebuilder/imagebuilderconnect/service.connect.go b/gen/go/flyteidl2/imagebuilder/imagebuilderconnect/service.connect.go new file mode 100644 index 0000000000..5921ef9e47 --- /dev/null +++ b/gen/go/flyteidl2/imagebuilder/imagebuilderconnect/service.connect.go @@ -0,0 +1,114 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: flyteidl2/imagebuilder/service.proto + +package imagebuilderconnect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + imagebuilder "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/imagebuilder" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // ImageServiceName is the fully-qualified name of the ImageService service. + ImageServiceName = "flyteidl2.imagebuilder.ImageService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // ImageServiceGetImageProcedure is the fully-qualified name of the ImageService's GetImage RPC. + ImageServiceGetImageProcedure = "/flyteidl2.imagebuilder.ImageService/GetImage" +) + +// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. +var ( + imageServiceServiceDescriptor = imagebuilder.File_flyteidl2_imagebuilder_service_proto.Services().ByName("ImageService") + imageServiceGetImageMethodDescriptor = imageServiceServiceDescriptor.Methods().ByName("GetImage") +) + +// ImageServiceClient is a client for the flyteidl2.imagebuilder.ImageService service. +type ImageServiceClient interface { + GetImage(context.Context, *connect.Request[imagebuilder.GetImageRequest]) (*connect.Response[imagebuilder.GetImageResponse], error) +} + +// NewImageServiceClient constructs a client for the flyteidl2.imagebuilder.ImageService service. By +// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, +// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the +// connect.WithGRPC() or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewImageServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) ImageServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &imageServiceClient{ + getImage: connect.NewClient[imagebuilder.GetImageRequest, imagebuilder.GetImageResponse]( + httpClient, + baseURL+ImageServiceGetImageProcedure, + connect.WithSchema(imageServiceGetImageMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + } +} + +// imageServiceClient implements ImageServiceClient. +type imageServiceClient struct { + getImage *connect.Client[imagebuilder.GetImageRequest, imagebuilder.GetImageResponse] +} + +// GetImage calls flyteidl2.imagebuilder.ImageService.GetImage. +func (c *imageServiceClient) GetImage(ctx context.Context, req *connect.Request[imagebuilder.GetImageRequest]) (*connect.Response[imagebuilder.GetImageResponse], error) { + return c.getImage.CallUnary(ctx, req) +} + +// ImageServiceHandler is an implementation of the flyteidl2.imagebuilder.ImageService service. +type ImageServiceHandler interface { + GetImage(context.Context, *connect.Request[imagebuilder.GetImageRequest]) (*connect.Response[imagebuilder.GetImageResponse], error) +} + +// NewImageServiceHandler builds an HTTP handler from the service implementation. It returns the +// path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewImageServiceHandler(svc ImageServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + imageServiceGetImageHandler := connect.NewUnaryHandler( + ImageServiceGetImageProcedure, + svc.GetImage, + connect.WithSchema(imageServiceGetImageMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.imagebuilder.ImageService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case ImageServiceGetImageProcedure: + imageServiceGetImageHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedImageServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedImageServiceHandler struct{} + +func (UnimplementedImageServiceHandler) GetImage(context.Context, *connect.Request[imagebuilder.GetImageRequest]) (*connect.Response[imagebuilder.GetImageResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.imagebuilder.ImageService.GetImage is not implemented")) +} diff --git a/gen/go/flyteidl2/imagebuilder/mocks/image_service_client.go b/gen/go/flyteidl2/imagebuilder/mocks/image_service_client.go new file mode 100644 index 0000000000..20759b0384 --- /dev/null +++ b/gen/go/flyteidl2/imagebuilder/mocks/image_service_client.go @@ -0,0 +1,114 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + grpc "google.golang.org/grpc" + + imagebuilder "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/imagebuilder" + + mock "github.com/stretchr/testify/mock" +) + +// ImageServiceClient is an autogenerated mock type for the ImageServiceClient type +type ImageServiceClient struct { + mock.Mock +} + +type ImageServiceClient_Expecter struct { + mock *mock.Mock +} + +func (_m *ImageServiceClient) EXPECT() *ImageServiceClient_Expecter { + return &ImageServiceClient_Expecter{mock: &_m.Mock} +} + +// GetImage provides a mock function with given fields: ctx, in, opts +func (_m *ImageServiceClient) GetImage(ctx context.Context, in *imagebuilder.GetImageRequest, opts ...grpc.CallOption) (*imagebuilder.GetImageResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetImage") + } + + var r0 *imagebuilder.GetImageResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *imagebuilder.GetImageRequest, ...grpc.CallOption) (*imagebuilder.GetImageResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *imagebuilder.GetImageRequest, ...grpc.CallOption) *imagebuilder.GetImageResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*imagebuilder.GetImageResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *imagebuilder.GetImageRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ImageServiceClient_GetImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetImage' +type ImageServiceClient_GetImage_Call struct { + *mock.Call +} + +// GetImage is a helper method to define mock.On call +// - ctx context.Context +// - in *imagebuilder.GetImageRequest +// - opts ...grpc.CallOption +func (_e *ImageServiceClient_Expecter) GetImage(ctx interface{}, in interface{}, opts ...interface{}) *ImageServiceClient_GetImage_Call { + return &ImageServiceClient_GetImage_Call{Call: _e.mock.On("GetImage", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *ImageServiceClient_GetImage_Call) Run(run func(ctx context.Context, in *imagebuilder.GetImageRequest, opts ...grpc.CallOption)) *ImageServiceClient_GetImage_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*imagebuilder.GetImageRequest), variadicArgs...) + }) + return _c +} + +func (_c *ImageServiceClient_GetImage_Call) Return(_a0 *imagebuilder.GetImageResponse, _a1 error) *ImageServiceClient_GetImage_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ImageServiceClient_GetImage_Call) RunAndReturn(run func(context.Context, *imagebuilder.GetImageRequest, ...grpc.CallOption) (*imagebuilder.GetImageResponse, error)) *ImageServiceClient_GetImage_Call { + _c.Call.Return(run) + return _c +} + +// NewImageServiceClient creates a new instance of ImageServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewImageServiceClient(t interface { + mock.TestingT + Cleanup(func()) +}) *ImageServiceClient { + mock := &ImageServiceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/imagebuilder/mocks/image_service_server.go b/gen/go/flyteidl2/imagebuilder/mocks/image_service_server.go new file mode 100644 index 0000000000..883e087be5 --- /dev/null +++ b/gen/go/flyteidl2/imagebuilder/mocks/image_service_server.go @@ -0,0 +1,96 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + imagebuilder "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/imagebuilder" + mock "github.com/stretchr/testify/mock" +) + +// ImageServiceServer is an autogenerated mock type for the ImageServiceServer type +type ImageServiceServer struct { + mock.Mock +} + +type ImageServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *ImageServiceServer) EXPECT() *ImageServiceServer_Expecter { + return &ImageServiceServer_Expecter{mock: &_m.Mock} +} + +// GetImage provides a mock function with given fields: _a0, _a1 +func (_m *ImageServiceServer) GetImage(_a0 context.Context, _a1 *imagebuilder.GetImageRequest) (*imagebuilder.GetImageResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetImage") + } + + var r0 *imagebuilder.GetImageResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *imagebuilder.GetImageRequest) (*imagebuilder.GetImageResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *imagebuilder.GetImageRequest) *imagebuilder.GetImageResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*imagebuilder.GetImageResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *imagebuilder.GetImageRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ImageServiceServer_GetImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetImage' +type ImageServiceServer_GetImage_Call struct { + *mock.Call +} + +// GetImage is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *imagebuilder.GetImageRequest +func (_e *ImageServiceServer_Expecter) GetImage(_a0 interface{}, _a1 interface{}) *ImageServiceServer_GetImage_Call { + return &ImageServiceServer_GetImage_Call{Call: _e.mock.On("GetImage", _a0, _a1)} +} + +func (_c *ImageServiceServer_GetImage_Call) Run(run func(_a0 context.Context, _a1 *imagebuilder.GetImageRequest)) *ImageServiceServer_GetImage_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*imagebuilder.GetImageRequest)) + }) + return _c +} + +func (_c *ImageServiceServer_GetImage_Call) Return(_a0 *imagebuilder.GetImageResponse, _a1 error) *ImageServiceServer_GetImage_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ImageServiceServer_GetImage_Call) RunAndReturn(run func(context.Context, *imagebuilder.GetImageRequest) (*imagebuilder.GetImageResponse, error)) *ImageServiceServer_GetImage_Call { + _c.Call.Return(run) + return _c +} + +// NewImageServiceServer creates a new instance of ImageServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewImageServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *ImageServiceServer { + mock := &ImageServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/imagebuilder/mocks/is_layer_layer.go b/gen/go/flyteidl2/imagebuilder/mocks/is_layer_layer.go new file mode 100644 index 0000000000..32bb278511 --- /dev/null +++ b/gen/go/flyteidl2/imagebuilder/mocks/is_layer_layer.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isLayer_Layer is an autogenerated mock type for the isLayer_Layer type +type isLayer_Layer struct { + mock.Mock +} + +type isLayer_Layer_Expecter struct { + mock *mock.Mock +} + +func (_m *isLayer_Layer) EXPECT() *isLayer_Layer_Expecter { + return &isLayer_Layer_Expecter{mock: &_m.Mock} +} + +// isLayer_Layer provides a mock function with no fields +func (_m *isLayer_Layer) isLayer_Layer() { + _m.Called() +} + +// isLayer_Layer_isLayer_Layer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isLayer_Layer' +type isLayer_Layer_isLayer_Layer_Call struct { + *mock.Call +} + +// isLayer_Layer is a helper method to define mock.On call +func (_e *isLayer_Layer_Expecter) isLayer_Layer() *isLayer_Layer_isLayer_Layer_Call { + return &isLayer_Layer_isLayer_Layer_Call{Call: _e.mock.On("isLayer_Layer")} +} + +func (_c *isLayer_Layer_isLayer_Layer_Call) Run(run func()) *isLayer_Layer_isLayer_Layer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isLayer_Layer_isLayer_Layer_Call) Return() *isLayer_Layer_isLayer_Layer_Call { + _c.Call.Return() + return _c +} + +func (_c *isLayer_Layer_isLayer_Layer_Call) RunAndReturn(run func()) *isLayer_Layer_isLayer_Layer_Call { + _c.Run(run) + return _c +} + +// newIsLayer_Layer creates a new instance of isLayer_Layer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsLayer_Layer(t interface { + mock.TestingT + Cleanup(func()) +}) *isLayer_Layer { + mock := &isLayer_Layer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/imagebuilder/mocks/unsafe_image_service_server.go b/gen/go/flyteidl2/imagebuilder/mocks/unsafe_image_service_server.go new file mode 100644 index 0000000000..b669768057 --- /dev/null +++ b/gen/go/flyteidl2/imagebuilder/mocks/unsafe_image_service_server.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// UnsafeImageServiceServer is an autogenerated mock type for the UnsafeImageServiceServer type +type UnsafeImageServiceServer struct { + mock.Mock +} + +type UnsafeImageServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *UnsafeImageServiceServer) EXPECT() *UnsafeImageServiceServer_Expecter { + return &UnsafeImageServiceServer_Expecter{mock: &_m.Mock} +} + +// mustEmbedUnimplementedImageServiceServer provides a mock function with no fields +func (_m *UnsafeImageServiceServer) mustEmbedUnimplementedImageServiceServer() { + _m.Called() +} + +// UnsafeImageServiceServer_mustEmbedUnimplementedImageServiceServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'mustEmbedUnimplementedImageServiceServer' +type UnsafeImageServiceServer_mustEmbedUnimplementedImageServiceServer_Call struct { + *mock.Call +} + +// mustEmbedUnimplementedImageServiceServer is a helper method to define mock.On call +func (_e *UnsafeImageServiceServer_Expecter) mustEmbedUnimplementedImageServiceServer() *UnsafeImageServiceServer_mustEmbedUnimplementedImageServiceServer_Call { + return &UnsafeImageServiceServer_mustEmbedUnimplementedImageServiceServer_Call{Call: _e.mock.On("mustEmbedUnimplementedImageServiceServer")} +} + +func (_c *UnsafeImageServiceServer_mustEmbedUnimplementedImageServiceServer_Call) Run(run func()) *UnsafeImageServiceServer_mustEmbedUnimplementedImageServiceServer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UnsafeImageServiceServer_mustEmbedUnimplementedImageServiceServer_Call) Return() *UnsafeImageServiceServer_mustEmbedUnimplementedImageServiceServer_Call { + _c.Call.Return() + return _c +} + +func (_c *UnsafeImageServiceServer_mustEmbedUnimplementedImageServiceServer_Call) RunAndReturn(run func()) *UnsafeImageServiceServer_mustEmbedUnimplementedImageServiceServer_Call { + _c.Run(run) + return _c +} + +// NewUnsafeImageServiceServer creates a new instance of UnsafeImageServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewUnsafeImageServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *UnsafeImageServiceServer { + mock := &UnsafeImageServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/imagebuilder/payload.pb.go b/gen/go/flyteidl2/imagebuilder/payload.pb.go new file mode 100644 index 0000000000..438fe24a37 --- /dev/null +++ b/gen/go/flyteidl2/imagebuilder/payload.pb.go @@ -0,0 +1,273 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/imagebuilder/payload.proto + +package imagebuilder + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type GetImageRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Image ID + Id *ImageIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // Optional organization that dictates which dataplane registry to reference + // Deprecated, please use the full ProjectIdentifier instead + // + // Deprecated: Marked as deprecated in flyteidl2/imagebuilder/payload.proto. + Organization string `protobuf:"bytes,2,opt,name=organization,proto3" json:"organization,omitempty"` + // The scope in which to look for the image. Images maybe accessible in different project-domain pairs through + // different container registries (i.e. different image FQDNs) + // TODO: This scope will be made required after updating all clients/servers to respect it. + ProjectId *common.ProjectIdentifier `protobuf:"bytes,3,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"` +} + +func (x *GetImageRequest) Reset() { + *x = GetImageRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_imagebuilder_payload_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetImageRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetImageRequest) ProtoMessage() {} + +func (x *GetImageRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_imagebuilder_payload_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetImageRequest.ProtoReflect.Descriptor instead. +func (*GetImageRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_imagebuilder_payload_proto_rawDescGZIP(), []int{0} +} + +func (x *GetImageRequest) GetId() *ImageIdentifier { + if x != nil { + return x.Id + } + return nil +} + +// Deprecated: Marked as deprecated in flyteidl2/imagebuilder/payload.proto. +func (x *GetImageRequest) GetOrganization() string { + if x != nil { + return x.Organization + } + return "" +} + +func (x *GetImageRequest) GetProjectId() *common.ProjectIdentifier { + if x != nil { + return x.ProjectId + } + return nil +} + +// GetSecretProxyResponse returns the looked up secret from the secret service +type GetImageResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Image *Image `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"` +} + +func (x *GetImageResponse) Reset() { + *x = GetImageResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_imagebuilder_payload_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetImageResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetImageResponse) ProtoMessage() {} + +func (x *GetImageResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_imagebuilder_payload_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetImageResponse.ProtoReflect.Descriptor instead. +func (*GetImageResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_imagebuilder_payload_proto_rawDescGZIP(), []int{1} +} + +func (x *GetImageResponse) GetImage() *Image { + if x != nil { + return x.Image + } + return nil +} + +var File_flyteidl2_imagebuilder_payload_proto protoreflect.FileDescriptor + +var file_flyteidl2_imagebuilder_payload_proto_rawDesc = []byte{ + 0x0a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x16, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x1a, 0x1b, + 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x27, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, + 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xbe, 0x01, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x49, + 0x6d, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3f, 0x0a, 0x02, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, + 0x2e, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0x26, 0x0a, 0x0c, + 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x42, 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, + 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x50, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x09, 0x70, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x22, 0x47, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x49, + 0x6d, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x05, + 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, + 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x52, 0x05, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x42, 0xe1, 0x01, 0x0a, 0x1a, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, + 0x42, 0x0c, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, + 0x50, 0x01, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, + 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0xa2, 0x02, + 0x03, 0x46, 0x49, 0x58, 0xaa, 0x02, 0x16, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0xca, 0x02, 0x16, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x62, + 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0xe2, 0x02, 0x22, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x5c, + 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x17, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, + 0x69, 0x6c, 0x64, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_imagebuilder_payload_proto_rawDescOnce sync.Once + file_flyteidl2_imagebuilder_payload_proto_rawDescData = file_flyteidl2_imagebuilder_payload_proto_rawDesc +) + +func file_flyteidl2_imagebuilder_payload_proto_rawDescGZIP() []byte { + file_flyteidl2_imagebuilder_payload_proto_rawDescOnce.Do(func() { + file_flyteidl2_imagebuilder_payload_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_imagebuilder_payload_proto_rawDescData) + }) + return file_flyteidl2_imagebuilder_payload_proto_rawDescData +} + +var file_flyteidl2_imagebuilder_payload_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_flyteidl2_imagebuilder_payload_proto_goTypes = []interface{}{ + (*GetImageRequest)(nil), // 0: flyteidl2.imagebuilder.GetImageRequest + (*GetImageResponse)(nil), // 1: flyteidl2.imagebuilder.GetImageResponse + (*ImageIdentifier)(nil), // 2: flyteidl2.imagebuilder.ImageIdentifier + (*common.ProjectIdentifier)(nil), // 3: flyteidl2.common.ProjectIdentifier + (*Image)(nil), // 4: flyteidl2.imagebuilder.Image +} +var file_flyteidl2_imagebuilder_payload_proto_depIdxs = []int32{ + 2, // 0: flyteidl2.imagebuilder.GetImageRequest.id:type_name -> flyteidl2.imagebuilder.ImageIdentifier + 3, // 1: flyteidl2.imagebuilder.GetImageRequest.project_id:type_name -> flyteidl2.common.ProjectIdentifier + 4, // 2: flyteidl2.imagebuilder.GetImageResponse.image:type_name -> flyteidl2.imagebuilder.Image + 3, // [3:3] is the sub-list for method output_type + 3, // [3:3] is the sub-list for method input_type + 3, // [3:3] is the sub-list for extension type_name + 3, // [3:3] is the sub-list for extension extendee + 0, // [0:3] is the sub-list for field type_name +} + +func init() { file_flyteidl2_imagebuilder_payload_proto_init() } +func file_flyteidl2_imagebuilder_payload_proto_init() { + if File_flyteidl2_imagebuilder_payload_proto != nil { + return + } + file_flyteidl2_imagebuilder_definition_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_imagebuilder_payload_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetImageRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_imagebuilder_payload_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetImageResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_imagebuilder_payload_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_imagebuilder_payload_proto_goTypes, + DependencyIndexes: file_flyteidl2_imagebuilder_payload_proto_depIdxs, + MessageInfos: file_flyteidl2_imagebuilder_payload_proto_msgTypes, + }.Build() + File_flyteidl2_imagebuilder_payload_proto = out.File + file_flyteidl2_imagebuilder_payload_proto_rawDesc = nil + file_flyteidl2_imagebuilder_payload_proto_goTypes = nil + file_flyteidl2_imagebuilder_payload_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/imagebuilder/payload.pb.validate.go b/gen/go/flyteidl2/imagebuilder/payload.pb.validate.go new file mode 100644 index 0000000000..b2e439d8e1 --- /dev/null +++ b/gen/go/flyteidl2/imagebuilder/payload.pb.validate.go @@ -0,0 +1,325 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/imagebuilder/payload.proto + +package imagebuilder + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on GetImageRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *GetImageRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetImageRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetImageRequestMultiError, or nil if none found. +func (m *GetImageRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetImageRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetImageRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetImageRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetImageRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Organization + + if all { + switch v := interface{}(m.GetProjectId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetImageRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetImageRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetProjectId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetImageRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetImageRequestMultiError(errors) + } + + return nil +} + +// GetImageRequestMultiError is an error wrapping multiple validation errors +// returned by GetImageRequest.ValidateAll() if the designated constraints +// aren't met. +type GetImageRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetImageRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetImageRequestMultiError) AllErrors() []error { return m } + +// GetImageRequestValidationError is the validation error returned by +// GetImageRequest.Validate if the designated constraints aren't met. +type GetImageRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetImageRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetImageRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetImageRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetImageRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetImageRequestValidationError) ErrorName() string { return "GetImageRequestValidationError" } + +// Error satisfies the builtin error interface +func (e GetImageRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetImageRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetImageRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetImageRequestValidationError{} + +// Validate checks the field values on GetImageResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *GetImageResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetImageResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetImageResponseMultiError, or nil if none found. +func (m *GetImageResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetImageResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetImage()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetImageResponseValidationError{ + field: "Image", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetImageResponseValidationError{ + field: "Image", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetImage()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetImageResponseValidationError{ + field: "Image", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetImageResponseMultiError(errors) + } + + return nil +} + +// GetImageResponseMultiError is an error wrapping multiple validation errors +// returned by GetImageResponse.ValidateAll() if the designated constraints +// aren't met. +type GetImageResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetImageResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetImageResponseMultiError) AllErrors() []error { return m } + +// GetImageResponseValidationError is the validation error returned by +// GetImageResponse.Validate if the designated constraints aren't met. +type GetImageResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetImageResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetImageResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetImageResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetImageResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetImageResponseValidationError) ErrorName() string { return "GetImageResponseValidationError" } + +// Error satisfies the builtin error interface +func (e GetImageResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetImageResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetImageResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetImageResponseValidationError{} diff --git a/gen/go/flyteidl2/imagebuilder/service.pb.go b/gen/go/flyteidl2/imagebuilder/service.pb.go new file mode 100644 index 0000000000..35ff32f45a --- /dev/null +++ b/gen/go/flyteidl2/imagebuilder/service.pb.go @@ -0,0 +1,93 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/imagebuilder/service.proto + +package imagebuilder + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +var File_flyteidl2_imagebuilder_service_proto protoreflect.FileDescriptor + +var file_flyteidl2_imagebuilder_service_proto_rawDesc = []byte{ + 0x0a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x16, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x1a, 0x24, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, + 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x72, 0x0a, 0x0c, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x53, 0x65, 0x72, + 0x76, 0x69, 0x63, 0x65, 0x12, 0x62, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x49, 0x6d, 0x61, 0x67, 0x65, + 0x12, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, + 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6d, 0x61, + 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, + 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x42, 0xe1, 0x01, 0x0a, 0x1a, 0x63, 0x6f, 0x6d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, + 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x42, 0x0c, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, + 0x69, 0x6c, 0x64, 0x65, 0x72, 0xa2, 0x02, 0x03, 0x46, 0x49, 0x58, 0xaa, 0x02, 0x16, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, + 0x6c, 0x64, 0x65, 0x72, 0xca, 0x02, 0x16, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0xe2, 0x02, 0x22, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x62, + 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x17, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, + 0x49, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x33, +} + +var file_flyteidl2_imagebuilder_service_proto_goTypes = []interface{}{ + (*GetImageRequest)(nil), // 0: flyteidl2.imagebuilder.GetImageRequest + (*GetImageResponse)(nil), // 1: flyteidl2.imagebuilder.GetImageResponse +} +var file_flyteidl2_imagebuilder_service_proto_depIdxs = []int32{ + 0, // 0: flyteidl2.imagebuilder.ImageService.GetImage:input_type -> flyteidl2.imagebuilder.GetImageRequest + 1, // 1: flyteidl2.imagebuilder.ImageService.GetImage:output_type -> flyteidl2.imagebuilder.GetImageResponse + 1, // [1:2] is the sub-list for method output_type + 0, // [0:1] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_flyteidl2_imagebuilder_service_proto_init() } +func file_flyteidl2_imagebuilder_service_proto_init() { + if File_flyteidl2_imagebuilder_service_proto != nil { + return + } + file_flyteidl2_imagebuilder_payload_proto_init() + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_imagebuilder_service_proto_rawDesc, + NumEnums: 0, + NumMessages: 0, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_flyteidl2_imagebuilder_service_proto_goTypes, + DependencyIndexes: file_flyteidl2_imagebuilder_service_proto_depIdxs, + }.Build() + File_flyteidl2_imagebuilder_service_proto = out.File + file_flyteidl2_imagebuilder_service_proto_rawDesc = nil + file_flyteidl2_imagebuilder_service_proto_goTypes = nil + file_flyteidl2_imagebuilder_service_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/imagebuilder/service.pb.validate.go b/gen/go/flyteidl2/imagebuilder/service.pb.validate.go new file mode 100644 index 0000000000..e0a179120e --- /dev/null +++ b/gen/go/flyteidl2/imagebuilder/service.pb.validate.go @@ -0,0 +1,36 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/imagebuilder/service.proto + +package imagebuilder + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) diff --git a/gen/go/flyteidl2/imagebuilder/service_grpc.pb.go b/gen/go/flyteidl2/imagebuilder/service_grpc.pb.go new file mode 100644 index 0000000000..f6302f8759 --- /dev/null +++ b/gen/go/flyteidl2/imagebuilder/service_grpc.pb.go @@ -0,0 +1,107 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: flyteidl2/imagebuilder/service.proto + +package imagebuilder + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + ImageService_GetImage_FullMethodName = "/flyteidl2.imagebuilder.ImageService/GetImage" +) + +// ImageServiceClient is the client API for ImageService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type ImageServiceClient interface { + GetImage(ctx context.Context, in *GetImageRequest, opts ...grpc.CallOption) (*GetImageResponse, error) +} + +type imageServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewImageServiceClient(cc grpc.ClientConnInterface) ImageServiceClient { + return &imageServiceClient{cc} +} + +func (c *imageServiceClient) GetImage(ctx context.Context, in *GetImageRequest, opts ...grpc.CallOption) (*GetImageResponse, error) { + out := new(GetImageResponse) + err := c.cc.Invoke(ctx, ImageService_GetImage_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// ImageServiceServer is the server API for ImageService service. +// All implementations should embed UnimplementedImageServiceServer +// for forward compatibility +type ImageServiceServer interface { + GetImage(context.Context, *GetImageRequest) (*GetImageResponse, error) +} + +// UnimplementedImageServiceServer should be embedded to have forward compatible implementations. +type UnimplementedImageServiceServer struct { +} + +func (UnimplementedImageServiceServer) GetImage(context.Context, *GetImageRequest) (*GetImageResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetImage not implemented") +} + +// UnsafeImageServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to ImageServiceServer will +// result in compilation errors. +type UnsafeImageServiceServer interface { + mustEmbedUnimplementedImageServiceServer() +} + +func RegisterImageServiceServer(s grpc.ServiceRegistrar, srv ImageServiceServer) { + s.RegisterService(&ImageService_ServiceDesc, srv) +} + +func _ImageService_GetImage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetImageRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ImageServiceServer).GetImage(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ImageService_GetImage_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ImageServiceServer).GetImage(ctx, req.(*GetImageRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// ImageService_ServiceDesc is the grpc.ServiceDesc for ImageService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var ImageService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.imagebuilder.ImageService", + HandlerType: (*ImageServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "GetImage", + Handler: _ImageService_GetImage_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "flyteidl2/imagebuilder/service.proto", +} diff --git a/gen/go/flyteidl2/logs/dataplane/payload.pb.go b/gen/go/flyteidl2/logs/dataplane/payload.pb.go new file mode 100644 index 0000000000..ca86f593e0 --- /dev/null +++ b/gen/go/flyteidl2/logs/dataplane/payload.pb.go @@ -0,0 +1,1099 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/logs/dataplane/payload.proto + +package dataplane + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type LogLineOriginator int32 + +const ( + // The originator of the log line is unknown. + LogLineOriginator_UNKNOWN LogLineOriginator = 0 + // The originator of the log line is the user application. + LogLineOriginator_USER LogLineOriginator = 1 + // The originator of the log line is the system. + LogLineOriginator_SYSTEM LogLineOriginator = 2 +) + +// Enum value maps for LogLineOriginator. +var ( + LogLineOriginator_name = map[int32]string{ + 0: "UNKNOWN", + 1: "USER", + 2: "SYSTEM", + } + LogLineOriginator_value = map[string]int32{ + "UNKNOWN": 0, + "USER": 1, + "SYSTEM": 2, + } +) + +func (x LogLineOriginator) Enum() *LogLineOriginator { + p := new(LogLineOriginator) + *p = x + return p +} + +func (x LogLineOriginator) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (LogLineOriginator) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_logs_dataplane_payload_proto_enumTypes[0].Descriptor() +} + +func (LogLineOriginator) Type() protoreflect.EnumType { + return &file_flyteidl2_logs_dataplane_payload_proto_enumTypes[0] +} + +func (x LogLineOriginator) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use LogLineOriginator.Descriptor instead. +func (LogLineOriginator) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_logs_dataplane_payload_proto_rawDescGZIP(), []int{0} +} + +type LogsSource int32 + +const ( + // Return live logs and fall back to persisted if not available. + LogsSource_LIVE_OR_PERSISTED LogsSource = 0 + // Return live logs only or error if pod is no longer around. + LogsSource_LIVE_ONLY LogsSource = 1 + // Return persisted logs only. + LogsSource_PERSISTED_ONLY LogsSource = 2 +) + +// Enum value maps for LogsSource. +var ( + LogsSource_name = map[int32]string{ + 0: "LIVE_OR_PERSISTED", + 1: "LIVE_ONLY", + 2: "PERSISTED_ONLY", + } + LogsSource_value = map[string]int32{ + "LIVE_OR_PERSISTED": 0, + "LIVE_ONLY": 1, + "PERSISTED_ONLY": 2, + } +) + +func (x LogsSource) Enum() *LogsSource { + p := new(LogsSource) + *p = x + return p +} + +func (x LogsSource) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (LogsSource) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_logs_dataplane_payload_proto_enumTypes[1].Descriptor() +} + +func (LogsSource) Type() protoreflect.EnumType { + return &file_flyteidl2_logs_dataplane_payload_proto_enumTypes[1] +} + +func (x LogsSource) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use LogsSource.Descriptor instead. +func (LogsSource) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_logs_dataplane_payload_proto_rawDescGZIP(), []int{1} +} + +type PodResource struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The namespace of the pod. + Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"` + // The pod name. + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + // The container name. If not provided, attempt to find the primary container, else assume the first container. + // +optional + Container string `protobuf:"bytes,3,opt,name=container,proto3" json:"container,omitempty"` +} + +func (x *PodResource) Reset() { + *x = PodResource{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_logs_dataplane_payload_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PodResource) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PodResource) ProtoMessage() {} + +func (x *PodResource) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_logs_dataplane_payload_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PodResource.ProtoReflect.Descriptor instead. +func (*PodResource) Descriptor() ([]byte, []int) { + return file_flyteidl2_logs_dataplane_payload_proto_rawDescGZIP(), []int{0} +} + +func (x *PodResource) GetNamespace() string { + if x != nil { + return x.Namespace + } + return "" +} + +func (x *PodResource) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *PodResource) GetContainer() string { + if x != nil { + return x.Container + } + return "" +} + +// Parameters of environment in which logs were collected. Should contain everything +// necessary to identify location of task execution logs in cloud providers. +type LoggingContext struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ClusterName string `protobuf:"bytes,3,opt,name=cluster_name,json=clusterName,proto3" json:"cluster_name,omitempty"` + KubernetesNamespace string `protobuf:"bytes,4,opt,name=kubernetes_namespace,json=kubernetesNamespace,proto3" json:"kubernetes_namespace,omitempty"` + KubernetesPodName string `protobuf:"bytes,5,opt,name=kubernetes_pod_name,json=kubernetesPodName,proto3" json:"kubernetes_pod_name,omitempty"` + KubernetesContainerName string `protobuf:"bytes,6,opt,name=kubernetes_container_name,json=kubernetesContainerName,proto3" json:"kubernetes_container_name,omitempty"` + ExecutionAttemptStartTime *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=execution_attempt_start_time,json=executionAttemptStartTime,proto3" json:"execution_attempt_start_time,omitempty"` + ExecutionAttemptEndTime *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=execution_attempt_end_time,json=executionAttemptEndTime,proto3" json:"execution_attempt_end_time,omitempty"` + KubernetesPodLabels map[string]string `protobuf:"bytes,9,rep,name=kubernetes_pod_labels,json=kubernetesPodLabels,proto3" json:"kubernetes_pod_labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *LoggingContext) Reset() { + *x = LoggingContext{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_logs_dataplane_payload_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LoggingContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LoggingContext) ProtoMessage() {} + +func (x *LoggingContext) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_logs_dataplane_payload_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LoggingContext.ProtoReflect.Descriptor instead. +func (*LoggingContext) Descriptor() ([]byte, []int) { + return file_flyteidl2_logs_dataplane_payload_proto_rawDescGZIP(), []int{1} +} + +func (x *LoggingContext) GetClusterName() string { + if x != nil { + return x.ClusterName + } + return "" +} + +func (x *LoggingContext) GetKubernetesNamespace() string { + if x != nil { + return x.KubernetesNamespace + } + return "" +} + +func (x *LoggingContext) GetKubernetesPodName() string { + if x != nil { + return x.KubernetesPodName + } + return "" +} + +func (x *LoggingContext) GetKubernetesContainerName() string { + if x != nil { + return x.KubernetesContainerName + } + return "" +} + +func (x *LoggingContext) GetExecutionAttemptStartTime() *timestamppb.Timestamp { + if x != nil { + return x.ExecutionAttemptStartTime + } + return nil +} + +func (x *LoggingContext) GetExecutionAttemptEndTime() *timestamppb.Timestamp { + if x != nil { + return x.ExecutionAttemptEndTime + } + return nil +} + +func (x *LoggingContext) GetKubernetesPodLabels() map[string]string { + if x != nil { + return x.KubernetesPodLabels + } + return nil +} + +// Parameters of environment in which logs were collected. Should contain everything +// necessary to identify location of task execution logs in cloud providers. +type ContainerIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The name of the cluster. + ClusterName string `protobuf:"bytes,1,opt,name=cluster_name,json=clusterName,proto3" json:"cluster_name,omitempty"` + // The namespace in Kubernetes. + KubernetesNamespace string `protobuf:"bytes,2,opt,name=kubernetes_namespace,json=kubernetesNamespace,proto3" json:"kubernetes_namespace,omitempty"` + // The name of the pod in Kubernetes. + KubernetesPodName string `protobuf:"bytes,3,opt,name=kubernetes_pod_name,json=kubernetesPodName,proto3" json:"kubernetes_pod_name,omitempty"` + // The name of the container in Kubernetes. + KubernetesContainerName string `protobuf:"bytes,4,opt,name=kubernetes_container_name,json=kubernetesContainerName,proto3" json:"kubernetes_container_name,omitempty"` +} + +func (x *ContainerIdentifier) Reset() { + *x = ContainerIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_logs_dataplane_payload_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ContainerIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ContainerIdentifier) ProtoMessage() {} + +func (x *ContainerIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_logs_dataplane_payload_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ContainerIdentifier.ProtoReflect.Descriptor instead. +func (*ContainerIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_logs_dataplane_payload_proto_rawDescGZIP(), []int{2} +} + +func (x *ContainerIdentifier) GetClusterName() string { + if x != nil { + return x.ClusterName + } + return "" +} + +func (x *ContainerIdentifier) GetKubernetesNamespace() string { + if x != nil { + return x.KubernetesNamespace + } + return "" +} + +func (x *ContainerIdentifier) GetKubernetesPodName() string { + if x != nil { + return x.KubernetesPodName + } + return "" +} + +func (x *ContainerIdentifier) GetKubernetesContainerName() string { + if x != nil { + return x.KubernetesContainerName + } + return "" +} + +type ContainerSelector struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The name of the cluster. + ClusterName string `protobuf:"bytes,1,opt,name=cluster_name,json=clusterName,proto3" json:"cluster_name,omitempty"` + // The namespace in Kubernetes. + KubernetesNamespace string `protobuf:"bytes,2,opt,name=kubernetes_namespace,json=kubernetesNamespace,proto3" json:"kubernetes_namespace,omitempty"` + // The prefix of the name of the pod in Kubernetes. This will only apply to persisted pods' logs because listing by + // prefix is the supported way to filter pods. + KubernetesPodNamePrefix string `protobuf:"bytes,3,opt,name=kubernetes_pod_name_prefix,json=kubernetesPodNamePrefix,proto3" json:"kubernetes_pod_name_prefix,omitempty"` + // The name of the container in Kubernetes. If not specified, logs for all containers + // will be streamed. + KubernetesContainerName string `protobuf:"bytes,4,opt,name=kubernetes_container_name,json=kubernetesContainerName,proto3" json:"kubernetes_container_name,omitempty"` + // The label selector to filter pods. This will only apply to live pods' logs because Listing by prefix + // isn't supported. + KubernetesPodLabelSelector string `protobuf:"bytes,5,opt,name=kubernetes_pod_label_selector,json=kubernetesPodLabelSelector,proto3" json:"kubernetes_pod_label_selector,omitempty"` +} + +func (x *ContainerSelector) Reset() { + *x = ContainerSelector{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_logs_dataplane_payload_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ContainerSelector) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ContainerSelector) ProtoMessage() {} + +func (x *ContainerSelector) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_logs_dataplane_payload_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ContainerSelector.ProtoReflect.Descriptor instead. +func (*ContainerSelector) Descriptor() ([]byte, []int) { + return file_flyteidl2_logs_dataplane_payload_proto_rawDescGZIP(), []int{3} +} + +func (x *ContainerSelector) GetClusterName() string { + if x != nil { + return x.ClusterName + } + return "" +} + +func (x *ContainerSelector) GetKubernetesNamespace() string { + if x != nil { + return x.KubernetesNamespace + } + return "" +} + +func (x *ContainerSelector) GetKubernetesPodNamePrefix() string { + if x != nil { + return x.KubernetesPodNamePrefix + } + return "" +} + +func (x *ContainerSelector) GetKubernetesContainerName() string { + if x != nil { + return x.KubernetesContainerName + } + return "" +} + +func (x *ContainerSelector) GetKubernetesPodLabelSelector() string { + if x != nil { + return x.KubernetesPodLabelSelector + } + return "" +} + +type LiveLogsOptions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // LogPodStatus indicates whether to log the pod status along with the logs. + LogPodStatus bool `protobuf:"varint,1,opt,name=log_pod_status,json=logPodStatus,proto3" json:"log_pod_status,omitempty"` + // LogTimestamps indicates whether to log the timestamps along with the logs. It prepends RFC3339 or RFC3339Nano + // format in the beginning of each log line. + LogTimestamps bool `protobuf:"varint,2,opt,name=log_timestamps,json=logTimestamps,proto3" json:"log_timestamps,omitempty"` +} + +func (x *LiveLogsOptions) Reset() { + *x = LiveLogsOptions{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_logs_dataplane_payload_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LiveLogsOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LiveLogsOptions) ProtoMessage() {} + +func (x *LiveLogsOptions) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_logs_dataplane_payload_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LiveLogsOptions.ProtoReflect.Descriptor instead. +func (*LiveLogsOptions) Descriptor() ([]byte, []int) { + return file_flyteidl2_logs_dataplane_payload_proto_rawDescGZIP(), []int{4} +} + +func (x *LiveLogsOptions) GetLogPodStatus() bool { + if x != nil { + return x.LogPodStatus + } + return false +} + +func (x *LiveLogsOptions) GetLogTimestamps() bool { + if x != nil { + return x.LogTimestamps + } + return false +} + +type LogLine struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Timestamp *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + // Each line is separated by either CRLF, CR or LF, which are included + // at the ends of the lines. This lets clients know whether log emitter + // wanted to overwrite the previous line (LF) or append a new line (CRLF). + Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` + Originator LogLineOriginator `protobuf:"varint,3,opt,name=originator,proto3,enum=flyteidl2.logs.dataplane.LogLineOriginator" json:"originator,omitempty"` +} + +func (x *LogLine) Reset() { + *x = LogLine{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_logs_dataplane_payload_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LogLine) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LogLine) ProtoMessage() {} + +func (x *LogLine) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_logs_dataplane_payload_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LogLine.ProtoReflect.Descriptor instead. +func (*LogLine) Descriptor() ([]byte, []int) { + return file_flyteidl2_logs_dataplane_payload_proto_rawDescGZIP(), []int{5} +} + +func (x *LogLine) GetTimestamp() *timestamppb.Timestamp { + if x != nil { + return x.Timestamp + } + return nil +} + +func (x *LogLine) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +func (x *LogLine) GetOriginator() LogLineOriginator { + if x != nil { + return x.Originator + } + return LogLineOriginator_UNKNOWN +} + +type LogLines struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Each line is separated by either CRLF, CR or LF, which are included + // at the ends of the lines. This lets clients know whether log emitter + // wanted to overwrite the previous line (LF) or append a new line (CRLF). + // + // Deprecated: Marked as deprecated in flyteidl2/logs/dataplane/payload.proto. + Lines []string `protobuf:"bytes,1,rep,name=lines,proto3" json:"lines,omitempty"` + // The index of the container in the list of containers. If the request was made with a single container identifier, + // this value will always be 0. Otherwise, it'll be an index into the last list of containers sent in the stream. + ContainerIndex uint32 `protobuf:"varint,2,opt,name=container_index,json=containerIndex,proto3" json:"container_index,omitempty"` + // The container identifier. + Container *ContainerIdentifier `protobuf:"bytes,3,opt,name=container,proto3" json:"container,omitempty"` + // Each line is separated by either CRLF, CR or LF, which are included + // at the ends of the lines. This lets clients know whether log emitter + // wanted to overwrite the previous line (LF) or append a new line (CRLF). + StructuredLines []*LogLine `protobuf:"bytes,4,rep,name=structured_lines,json=structuredLines,proto3" json:"structured_lines,omitempty"` +} + +func (x *LogLines) Reset() { + *x = LogLines{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_logs_dataplane_payload_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LogLines) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LogLines) ProtoMessage() {} + +func (x *LogLines) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_logs_dataplane_payload_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LogLines.ProtoReflect.Descriptor instead. +func (*LogLines) Descriptor() ([]byte, []int) { + return file_flyteidl2_logs_dataplane_payload_proto_rawDescGZIP(), []int{6} +} + +// Deprecated: Marked as deprecated in flyteidl2/logs/dataplane/payload.proto. +func (x *LogLines) GetLines() []string { + if x != nil { + return x.Lines + } + return nil +} + +func (x *LogLines) GetContainerIndex() uint32 { + if x != nil { + return x.ContainerIndex + } + return 0 +} + +func (x *LogLines) GetContainer() *ContainerIdentifier { + if x != nil { + return x.Container + } + return nil +} + +func (x *LogLines) GetStructuredLines() []*LogLine { + if x != nil { + return x.StructuredLines + } + return nil +} + +type LogContainersList struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Containers []*ContainerIdentifier `protobuf:"bytes,1,rep,name=containers,proto3" json:"containers,omitempty"` +} + +func (x *LogContainersList) Reset() { + *x = LogContainersList{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_logs_dataplane_payload_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LogContainersList) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LogContainersList) ProtoMessage() {} + +func (x *LogContainersList) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_logs_dataplane_payload_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LogContainersList.ProtoReflect.Descriptor instead. +func (*LogContainersList) Descriptor() ([]byte, []int) { + return file_flyteidl2_logs_dataplane_payload_proto_rawDescGZIP(), []int{7} +} + +func (x *LogContainersList) GetContainers() []*ContainerIdentifier { + if x != nil { + return x.Containers + } + return nil +} + +type LogLinesBatch struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Logs []*LogLines `protobuf:"bytes,1,rep,name=logs,proto3" json:"logs,omitempty"` +} + +func (x *LogLinesBatch) Reset() { + *x = LogLinesBatch{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_logs_dataplane_payload_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LogLinesBatch) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LogLinesBatch) ProtoMessage() {} + +func (x *LogLinesBatch) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_logs_dataplane_payload_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LogLinesBatch.ProtoReflect.Descriptor instead. +func (*LogLinesBatch) Descriptor() ([]byte, []int) { + return file_flyteidl2_logs_dataplane_payload_proto_rawDescGZIP(), []int{8} +} + +func (x *LogLinesBatch) GetLogs() []*LogLines { + if x != nil { + return x.Logs + } + return nil +} + +var File_flyteidl2_logs_dataplane_payload_proto protoreflect.FileDescriptor + +var file_flyteidl2_logs_dataplane_payload_proto_rawDesc = []byte{ + 0x0a, 0x26, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x6c, 0x6f, 0x67, 0x73, + 0x2f, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2f, 0x70, 0x61, 0x79, 0x6c, 0x6f, + 0x61, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, + 0x6e, 0x65, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, + 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, + 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x22, 0x6f, 0x0a, 0x0b, 0x50, 0x6f, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, + 0x25, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x09, 0x6e, 0x61, 0x6d, + 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, + 0x72, 0x22, 0xf7, 0x04, 0x0a, 0x0e, 0x4c, 0x6f, 0x67, 0x67, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, + 0x74, 0x65, 0x78, 0x74, 0x12, 0x2a, 0x0a, 0x0c, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, + 0x02, 0x10, 0x01, 0x52, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, + 0x12, 0x3a, 0x0a, 0x14, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x5f, 0x6e, + 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, + 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x13, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, + 0x74, 0x65, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x37, 0x0a, 0x13, + 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x5f, 0x70, 0x6f, 0x64, 0x5f, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, + 0x10, 0x01, 0x52, 0x11, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x50, 0x6f, + 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x43, 0x0a, 0x19, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, + 0x74, 0x65, 0x73, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, + 0x01, 0x52, 0x17, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x43, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x5b, 0x0a, 0x1c, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x5f, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x19, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x53, 0x74, + 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x57, 0x0a, 0x1a, 0x65, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x5f, 0x65, 0x6e, 0x64, + 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x17, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x45, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, + 0x12, 0x75, 0x0a, 0x15, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x5f, 0x70, + 0x6f, 0x64, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x41, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x6c, 0x6f, 0x67, 0x73, + 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2e, 0x4c, 0x6f, 0x67, 0x67, 0x69, + 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2e, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, + 0x65, 0x74, 0x65, 0x73, 0x50, 0x6f, 0x64, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x13, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x50, 0x6f, + 0x64, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x1a, 0x46, 0x0a, 0x18, 0x4b, 0x75, 0x62, 0x65, 0x72, + 0x6e, 0x65, 0x74, 0x65, 0x73, 0x50, 0x6f, 0x64, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x4a, + 0x04, 0x08, 0x01, 0x10, 0x02, 0x4a, 0x04, 0x08, 0x02, 0x10, 0x03, 0x22, 0xf2, 0x01, 0x0a, 0x13, + 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x12, 0x2a, 0x0a, 0x0c, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, + 0x10, 0x01, 0x52, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, + 0x3a, 0x0a, 0x14, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x5f, 0x6e, 0x61, + 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, + 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x13, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, + 0x65, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x37, 0x0a, 0x13, 0x6b, + 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x5f, 0x70, 0x6f, 0x64, 0x5f, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, + 0x01, 0x52, 0x11, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x50, 0x6f, 0x64, + 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x3a, 0x0a, 0x19, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, + 0x65, 0x73, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x17, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, + 0x74, 0x65, 0x73, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, + 0x22, 0xb7, 0x02, 0x0a, 0x11, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x53, 0x65, + 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x2a, 0x0a, 0x0c, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, + 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, + 0x6d, 0x65, 0x12, 0x3a, 0x0a, 0x14, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x13, 0x6b, 0x75, 0x62, 0x65, 0x72, + 0x6e, 0x65, 0x74, 0x65, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x3b, + 0x0a, 0x1a, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x5f, 0x70, 0x6f, 0x64, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x17, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x50, 0x6f, + 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x3a, 0x0a, 0x19, 0x6b, + 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x17, + 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x41, 0x0a, 0x1d, 0x6b, 0x75, 0x62, 0x65, 0x72, + 0x6e, 0x65, 0x74, 0x65, 0x73, 0x5f, 0x70, 0x6f, 0x64, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x5f, + 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x1a, + 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x50, 0x6f, 0x64, 0x4c, 0x61, 0x62, + 0x65, 0x6c, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x22, 0x5e, 0x0a, 0x0f, 0x4c, 0x69, + 0x76, 0x65, 0x4c, 0x6f, 0x67, 0x73, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x24, 0x0a, + 0x0e, 0x6c, 0x6f, 0x67, 0x5f, 0x70, 0x6f, 0x64, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x6c, 0x6f, 0x67, 0x50, 0x6f, 0x64, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x6c, 0x6f, 0x67, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x6c, 0x6f, 0x67, + 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x73, 0x22, 0xaa, 0x01, 0x0a, 0x07, 0x4c, + 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x12, 0x38, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x4b, 0x0a, 0x0a, 0x6f, 0x72, + 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x6c, 0x6f, 0x67, 0x73, 0x2e, + 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2e, 0x4c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, + 0x65, 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x0a, 0x6f, 0x72, 0x69, + 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x22, 0xf0, 0x01, 0x0a, 0x08, 0x4c, 0x6f, 0x67, 0x4c, + 0x69, 0x6e, 0x65, 0x73, 0x12, 0x18, 0x0a, 0x05, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x05, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x12, 0x27, + 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x64, 0x65, + 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x65, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x53, 0x0a, 0x09, 0x63, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x64, 0x61, 0x74, 0x61, + 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, + 0x01, 0x52, 0x09, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x12, 0x4c, 0x0a, 0x10, + 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, + 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, + 0x65, 0x2e, 0x4c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x52, 0x0f, 0x73, 0x74, 0x72, 0x75, 0x63, + 0x74, 0x75, 0x72, 0x65, 0x64, 0x4c, 0x69, 0x6e, 0x65, 0x73, 0x22, 0x62, 0x0a, 0x11, 0x4c, 0x6f, + 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x12, + 0x4d, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2e, 0x43, + 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x22, 0x47, + 0x0a, 0x0d, 0x4c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x73, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, + 0x36, 0x0a, 0x04, 0x6c, 0x6f, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x64, + 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2e, 0x4c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x65, + 0x73, 0x52, 0x04, 0x6c, 0x6f, 0x67, 0x73, 0x2a, 0x36, 0x0a, 0x11, 0x4c, 0x6f, 0x67, 0x4c, 0x69, + 0x6e, 0x65, 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x0b, 0x0a, 0x07, + 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x55, 0x53, 0x45, + 0x52, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x10, 0x02, 0x2a, + 0x46, 0x0a, 0x0a, 0x4c, 0x6f, 0x67, 0x73, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x15, 0x0a, + 0x11, 0x4c, 0x49, 0x56, 0x45, 0x5f, 0x4f, 0x52, 0x5f, 0x50, 0x45, 0x52, 0x53, 0x49, 0x53, 0x54, + 0x45, 0x44, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x4c, 0x49, 0x56, 0x45, 0x5f, 0x4f, 0x4e, 0x4c, + 0x59, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x50, 0x45, 0x52, 0x53, 0x49, 0x53, 0x54, 0x45, 0x44, + 0x5f, 0x4f, 0x4e, 0x4c, 0x59, 0x10, 0x02, 0x42, 0xee, 0x01, 0x0a, 0x1c, 0x63, 0x6f, 0x6d, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x64, + 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x42, 0x0c, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, + 0x64, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x3c, 0x67, 0x69, 0x74, 0x68, + 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x6c, 0x6f, 0x67, 0x73, 0x2f, 0x64, + 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0xa2, 0x02, 0x03, 0x46, 0x4c, 0x44, 0xaa, 0x02, + 0x18, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x4c, 0x6f, 0x67, 0x73, 0x2e, + 0x44, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0xca, 0x02, 0x18, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x4c, 0x6f, 0x67, 0x73, 0x5c, 0x44, 0x61, 0x74, 0x61, 0x70, + 0x6c, 0x61, 0x6e, 0x65, 0xe2, 0x02, 0x24, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x4c, 0x6f, 0x67, 0x73, 0x5c, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x5c, + 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1a, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x4c, 0x6f, 0x67, 0x73, 0x3a, 0x3a, 0x44, + 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_logs_dataplane_payload_proto_rawDescOnce sync.Once + file_flyteidl2_logs_dataplane_payload_proto_rawDescData = file_flyteidl2_logs_dataplane_payload_proto_rawDesc +) + +func file_flyteidl2_logs_dataplane_payload_proto_rawDescGZIP() []byte { + file_flyteidl2_logs_dataplane_payload_proto_rawDescOnce.Do(func() { + file_flyteidl2_logs_dataplane_payload_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_logs_dataplane_payload_proto_rawDescData) + }) + return file_flyteidl2_logs_dataplane_payload_proto_rawDescData +} + +var file_flyteidl2_logs_dataplane_payload_proto_enumTypes = make([]protoimpl.EnumInfo, 2) +var file_flyteidl2_logs_dataplane_payload_proto_msgTypes = make([]protoimpl.MessageInfo, 10) +var file_flyteidl2_logs_dataplane_payload_proto_goTypes = []interface{}{ + (LogLineOriginator)(0), // 0: flyteidl2.logs.dataplane.LogLineOriginator + (LogsSource)(0), // 1: flyteidl2.logs.dataplane.LogsSource + (*PodResource)(nil), // 2: flyteidl2.logs.dataplane.PodResource + (*LoggingContext)(nil), // 3: flyteidl2.logs.dataplane.LoggingContext + (*ContainerIdentifier)(nil), // 4: flyteidl2.logs.dataplane.ContainerIdentifier + (*ContainerSelector)(nil), // 5: flyteidl2.logs.dataplane.ContainerSelector + (*LiveLogsOptions)(nil), // 6: flyteidl2.logs.dataplane.LiveLogsOptions + (*LogLine)(nil), // 7: flyteidl2.logs.dataplane.LogLine + (*LogLines)(nil), // 8: flyteidl2.logs.dataplane.LogLines + (*LogContainersList)(nil), // 9: flyteidl2.logs.dataplane.LogContainersList + (*LogLinesBatch)(nil), // 10: flyteidl2.logs.dataplane.LogLinesBatch + nil, // 11: flyteidl2.logs.dataplane.LoggingContext.KubernetesPodLabelsEntry + (*timestamppb.Timestamp)(nil), // 12: google.protobuf.Timestamp +} +var file_flyteidl2_logs_dataplane_payload_proto_depIdxs = []int32{ + 12, // 0: flyteidl2.logs.dataplane.LoggingContext.execution_attempt_start_time:type_name -> google.protobuf.Timestamp + 12, // 1: flyteidl2.logs.dataplane.LoggingContext.execution_attempt_end_time:type_name -> google.protobuf.Timestamp + 11, // 2: flyteidl2.logs.dataplane.LoggingContext.kubernetes_pod_labels:type_name -> flyteidl2.logs.dataplane.LoggingContext.KubernetesPodLabelsEntry + 12, // 3: flyteidl2.logs.dataplane.LogLine.timestamp:type_name -> google.protobuf.Timestamp + 0, // 4: flyteidl2.logs.dataplane.LogLine.originator:type_name -> flyteidl2.logs.dataplane.LogLineOriginator + 4, // 5: flyteidl2.logs.dataplane.LogLines.container:type_name -> flyteidl2.logs.dataplane.ContainerIdentifier + 7, // 6: flyteidl2.logs.dataplane.LogLines.structured_lines:type_name -> flyteidl2.logs.dataplane.LogLine + 4, // 7: flyteidl2.logs.dataplane.LogContainersList.containers:type_name -> flyteidl2.logs.dataplane.ContainerIdentifier + 8, // 8: flyteidl2.logs.dataplane.LogLinesBatch.logs:type_name -> flyteidl2.logs.dataplane.LogLines + 9, // [9:9] is the sub-list for method output_type + 9, // [9:9] is the sub-list for method input_type + 9, // [9:9] is the sub-list for extension type_name + 9, // [9:9] is the sub-list for extension extendee + 0, // [0:9] is the sub-list for field type_name +} + +func init() { file_flyteidl2_logs_dataplane_payload_proto_init() } +func file_flyteidl2_logs_dataplane_payload_proto_init() { + if File_flyteidl2_logs_dataplane_payload_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_logs_dataplane_payload_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PodResource); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_logs_dataplane_payload_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LoggingContext); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_logs_dataplane_payload_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ContainerIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_logs_dataplane_payload_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ContainerSelector); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_logs_dataplane_payload_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LiveLogsOptions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_logs_dataplane_payload_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LogLine); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_logs_dataplane_payload_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LogLines); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_logs_dataplane_payload_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LogContainersList); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_logs_dataplane_payload_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LogLinesBatch); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_logs_dataplane_payload_proto_rawDesc, + NumEnums: 2, + NumMessages: 10, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_logs_dataplane_payload_proto_goTypes, + DependencyIndexes: file_flyteidl2_logs_dataplane_payload_proto_depIdxs, + EnumInfos: file_flyteidl2_logs_dataplane_payload_proto_enumTypes, + MessageInfos: file_flyteidl2_logs_dataplane_payload_proto_msgTypes, + }.Build() + File_flyteidl2_logs_dataplane_payload_proto = out.File + file_flyteidl2_logs_dataplane_payload_proto_rawDesc = nil + file_flyteidl2_logs_dataplane_payload_proto_goTypes = nil + file_flyteidl2_logs_dataplane_payload_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/logs/dataplane/payload.pb.validate.go b/gen/go/flyteidl2/logs/dataplane/payload.pb.validate.go new file mode 100644 index 0000000000..06637863f2 --- /dev/null +++ b/gen/go/flyteidl2/logs/dataplane/payload.pb.validate.go @@ -0,0 +1,1200 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/logs/dataplane/payload.proto + +package dataplane + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on PodResource with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *PodResource) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on PodResource with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in PodResourceMultiError, or +// nil if none found. +func (m *PodResource) ValidateAll() error { + return m.validate(true) +} + +func (m *PodResource) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Namespace + + // no validation rules for Name + + // no validation rules for Container + + if len(errors) > 0 { + return PodResourceMultiError(errors) + } + + return nil +} + +// PodResourceMultiError is an error wrapping multiple validation errors +// returned by PodResource.ValidateAll() if the designated constraints aren't met. +type PodResourceMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PodResourceMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PodResourceMultiError) AllErrors() []error { return m } + +// PodResourceValidationError is the validation error returned by +// PodResource.Validate if the designated constraints aren't met. +type PodResourceValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PodResourceValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PodResourceValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PodResourceValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PodResourceValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PodResourceValidationError) ErrorName() string { return "PodResourceValidationError" } + +// Error satisfies the builtin error interface +func (e PodResourceValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPodResource.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PodResourceValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PodResourceValidationError{} + +// Validate checks the field values on LoggingContext with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *LoggingContext) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LoggingContext with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in LoggingContextMultiError, +// or nil if none found. +func (m *LoggingContext) ValidateAll() error { + return m.validate(true) +} + +func (m *LoggingContext) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ClusterName + + // no validation rules for KubernetesNamespace + + // no validation rules for KubernetesPodName + + // no validation rules for KubernetesContainerName + + if all { + switch v := interface{}(m.GetExecutionAttemptStartTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LoggingContextValidationError{ + field: "ExecutionAttemptStartTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LoggingContextValidationError{ + field: "ExecutionAttemptStartTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetExecutionAttemptStartTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LoggingContextValidationError{ + field: "ExecutionAttemptStartTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetExecutionAttemptEndTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LoggingContextValidationError{ + field: "ExecutionAttemptEndTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LoggingContextValidationError{ + field: "ExecutionAttemptEndTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetExecutionAttemptEndTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LoggingContextValidationError{ + field: "ExecutionAttemptEndTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for KubernetesPodLabels + + if len(errors) > 0 { + return LoggingContextMultiError(errors) + } + + return nil +} + +// LoggingContextMultiError is an error wrapping multiple validation errors +// returned by LoggingContext.ValidateAll() if the designated constraints +// aren't met. +type LoggingContextMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LoggingContextMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LoggingContextMultiError) AllErrors() []error { return m } + +// LoggingContextValidationError is the validation error returned by +// LoggingContext.Validate if the designated constraints aren't met. +type LoggingContextValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LoggingContextValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LoggingContextValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LoggingContextValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LoggingContextValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LoggingContextValidationError) ErrorName() string { return "LoggingContextValidationError" } + +// Error satisfies the builtin error interface +func (e LoggingContextValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLoggingContext.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LoggingContextValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LoggingContextValidationError{} + +// Validate checks the field values on ContainerIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ContainerIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ContainerIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ContainerIdentifierMultiError, or nil if none found. +func (m *ContainerIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *ContainerIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ClusterName + + // no validation rules for KubernetesNamespace + + // no validation rules for KubernetesPodName + + // no validation rules for KubernetesContainerName + + if len(errors) > 0 { + return ContainerIdentifierMultiError(errors) + } + + return nil +} + +// ContainerIdentifierMultiError is an error wrapping multiple validation +// errors returned by ContainerIdentifier.ValidateAll() if the designated +// constraints aren't met. +type ContainerIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ContainerIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ContainerIdentifierMultiError) AllErrors() []error { return m } + +// ContainerIdentifierValidationError is the validation error returned by +// ContainerIdentifier.Validate if the designated constraints aren't met. +type ContainerIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ContainerIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ContainerIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ContainerIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ContainerIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ContainerIdentifierValidationError) ErrorName() string { + return "ContainerIdentifierValidationError" +} + +// Error satisfies the builtin error interface +func (e ContainerIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sContainerIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ContainerIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ContainerIdentifierValidationError{} + +// Validate checks the field values on ContainerSelector with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *ContainerSelector) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ContainerSelector with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ContainerSelectorMultiError, or nil if none found. +func (m *ContainerSelector) ValidateAll() error { + return m.validate(true) +} + +func (m *ContainerSelector) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ClusterName + + // no validation rules for KubernetesNamespace + + // no validation rules for KubernetesPodNamePrefix + + // no validation rules for KubernetesContainerName + + // no validation rules for KubernetesPodLabelSelector + + if len(errors) > 0 { + return ContainerSelectorMultiError(errors) + } + + return nil +} + +// ContainerSelectorMultiError is an error wrapping multiple validation errors +// returned by ContainerSelector.ValidateAll() if the designated constraints +// aren't met. +type ContainerSelectorMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ContainerSelectorMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ContainerSelectorMultiError) AllErrors() []error { return m } + +// ContainerSelectorValidationError is the validation error returned by +// ContainerSelector.Validate if the designated constraints aren't met. +type ContainerSelectorValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ContainerSelectorValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ContainerSelectorValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ContainerSelectorValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ContainerSelectorValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ContainerSelectorValidationError) ErrorName() string { + return "ContainerSelectorValidationError" +} + +// Error satisfies the builtin error interface +func (e ContainerSelectorValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sContainerSelector.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ContainerSelectorValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ContainerSelectorValidationError{} + +// Validate checks the field values on LiveLogsOptions with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *LiveLogsOptions) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LiveLogsOptions with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// LiveLogsOptionsMultiError, or nil if none found. +func (m *LiveLogsOptions) ValidateAll() error { + return m.validate(true) +} + +func (m *LiveLogsOptions) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for LogPodStatus + + // no validation rules for LogTimestamps + + if len(errors) > 0 { + return LiveLogsOptionsMultiError(errors) + } + + return nil +} + +// LiveLogsOptionsMultiError is an error wrapping multiple validation errors +// returned by LiveLogsOptions.ValidateAll() if the designated constraints +// aren't met. +type LiveLogsOptionsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LiveLogsOptionsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LiveLogsOptionsMultiError) AllErrors() []error { return m } + +// LiveLogsOptionsValidationError is the validation error returned by +// LiveLogsOptions.Validate if the designated constraints aren't met. +type LiveLogsOptionsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LiveLogsOptionsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LiveLogsOptionsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LiveLogsOptionsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LiveLogsOptionsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LiveLogsOptionsValidationError) ErrorName() string { return "LiveLogsOptionsValidationError" } + +// Error satisfies the builtin error interface +func (e LiveLogsOptionsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLiveLogsOptions.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LiveLogsOptionsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LiveLogsOptionsValidationError{} + +// Validate checks the field values on LogLine with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *LogLine) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LogLine with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in LogLineMultiError, or nil if none found. +func (m *LogLine) ValidateAll() error { + return m.validate(true) +} + +func (m *LogLine) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetTimestamp()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LogLineValidationError{ + field: "Timestamp", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LogLineValidationError{ + field: "Timestamp", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTimestamp()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LogLineValidationError{ + field: "Timestamp", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Message + + // no validation rules for Originator + + if len(errors) > 0 { + return LogLineMultiError(errors) + } + + return nil +} + +// LogLineMultiError is an error wrapping multiple validation errors returned +// by LogLine.ValidateAll() if the designated constraints aren't met. +type LogLineMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LogLineMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LogLineMultiError) AllErrors() []error { return m } + +// LogLineValidationError is the validation error returned by LogLine.Validate +// if the designated constraints aren't met. +type LogLineValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LogLineValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LogLineValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LogLineValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LogLineValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LogLineValidationError) ErrorName() string { return "LogLineValidationError" } + +// Error satisfies the builtin error interface +func (e LogLineValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLogLine.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LogLineValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LogLineValidationError{} + +// Validate checks the field values on LogLines with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *LogLines) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LogLines with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in LogLinesMultiError, or nil +// if none found. +func (m *LogLines) ValidateAll() error { + return m.validate(true) +} + +func (m *LogLines) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ContainerIndex + + if all { + switch v := interface{}(m.GetContainer()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LogLinesValidationError{ + field: "Container", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LogLinesValidationError{ + field: "Container", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetContainer()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LogLinesValidationError{ + field: "Container", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetStructuredLines() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LogLinesValidationError{ + field: fmt.Sprintf("StructuredLines[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LogLinesValidationError{ + field: fmt.Sprintf("StructuredLines[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LogLinesValidationError{ + field: fmt.Sprintf("StructuredLines[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return LogLinesMultiError(errors) + } + + return nil +} + +// LogLinesMultiError is an error wrapping multiple validation errors returned +// by LogLines.ValidateAll() if the designated constraints aren't met. +type LogLinesMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LogLinesMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LogLinesMultiError) AllErrors() []error { return m } + +// LogLinesValidationError is the validation error returned by +// LogLines.Validate if the designated constraints aren't met. +type LogLinesValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LogLinesValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LogLinesValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LogLinesValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LogLinesValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LogLinesValidationError) ErrorName() string { return "LogLinesValidationError" } + +// Error satisfies the builtin error interface +func (e LogLinesValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLogLines.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LogLinesValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LogLinesValidationError{} + +// Validate checks the field values on LogContainersList with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *LogContainersList) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LogContainersList with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// LogContainersListMultiError, or nil if none found. +func (m *LogContainersList) ValidateAll() error { + return m.validate(true) +} + +func (m *LogContainersList) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetContainers() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LogContainersListValidationError{ + field: fmt.Sprintf("Containers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LogContainersListValidationError{ + field: fmt.Sprintf("Containers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LogContainersListValidationError{ + field: fmt.Sprintf("Containers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return LogContainersListMultiError(errors) + } + + return nil +} + +// LogContainersListMultiError is an error wrapping multiple validation errors +// returned by LogContainersList.ValidateAll() if the designated constraints +// aren't met. +type LogContainersListMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LogContainersListMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LogContainersListMultiError) AllErrors() []error { return m } + +// LogContainersListValidationError is the validation error returned by +// LogContainersList.Validate if the designated constraints aren't met. +type LogContainersListValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LogContainersListValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LogContainersListValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LogContainersListValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LogContainersListValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LogContainersListValidationError) ErrorName() string { + return "LogContainersListValidationError" +} + +// Error satisfies the builtin error interface +func (e LogContainersListValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLogContainersList.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LogContainersListValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LogContainersListValidationError{} + +// Validate checks the field values on LogLinesBatch with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *LogLinesBatch) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LogLinesBatch with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in LogLinesBatchMultiError, or +// nil if none found. +func (m *LogLinesBatch) ValidateAll() error { + return m.validate(true) +} + +func (m *LogLinesBatch) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetLogs() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LogLinesBatchValidationError{ + field: fmt.Sprintf("Logs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LogLinesBatchValidationError{ + field: fmt.Sprintf("Logs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LogLinesBatchValidationError{ + field: fmt.Sprintf("Logs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return LogLinesBatchMultiError(errors) + } + + return nil +} + +// LogLinesBatchMultiError is an error wrapping multiple validation errors +// returned by LogLinesBatch.ValidateAll() if the designated constraints +// aren't met. +type LogLinesBatchMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LogLinesBatchMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LogLinesBatchMultiError) AllErrors() []error { return m } + +// LogLinesBatchValidationError is the validation error returned by +// LogLinesBatch.Validate if the designated constraints aren't met. +type LogLinesBatchValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LogLinesBatchValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LogLinesBatchValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LogLinesBatchValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LogLinesBatchValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LogLinesBatchValidationError) ErrorName() string { return "LogLinesBatchValidationError" } + +// Error satisfies the builtin error interface +func (e LogLinesBatchValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLogLinesBatch.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LogLinesBatchValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LogLinesBatchValidationError{} diff --git a/gen/go/flyteidl2/plugins/common.pb.go b/gen/go/flyteidl2/plugins/common.pb.go new file mode 100644 index 0000000000..f57ffc6d14 --- /dev/null +++ b/gen/go/flyteidl2/plugins/common.pb.go @@ -0,0 +1,257 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/plugins/common.proto + +package plugins + +import ( + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type RestartPolicy int32 + +const ( + RestartPolicy_RESTART_POLICY_NEVER RestartPolicy = 0 + RestartPolicy_RESTART_POLICY_ON_FAILURE RestartPolicy = 1 + RestartPolicy_RESTART_POLICY_ALWAYS RestartPolicy = 2 +) + +// Enum value maps for RestartPolicy. +var ( + RestartPolicy_name = map[int32]string{ + 0: "RESTART_POLICY_NEVER", + 1: "RESTART_POLICY_ON_FAILURE", + 2: "RESTART_POLICY_ALWAYS", + } + RestartPolicy_value = map[string]int32{ + "RESTART_POLICY_NEVER": 0, + "RESTART_POLICY_ON_FAILURE": 1, + "RESTART_POLICY_ALWAYS": 2, + } +) + +func (x RestartPolicy) Enum() *RestartPolicy { + p := new(RestartPolicy) + *p = x + return p +} + +func (x RestartPolicy) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (RestartPolicy) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_plugins_common_proto_enumTypes[0].Descriptor() +} + +func (RestartPolicy) Type() protoreflect.EnumType { + return &file_flyteidl2_plugins_common_proto_enumTypes[0] +} + +func (x RestartPolicy) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use RestartPolicy.Descriptor instead. +func (RestartPolicy) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_plugins_common_proto_rawDescGZIP(), []int{0} +} + +type CommonReplicaSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Number of replicas + Replicas int32 `protobuf:"varint,1,opt,name=replicas,proto3" json:"replicas,omitempty"` + // Image used for the replica group + Image string `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"` + // Resources required for the replica group + Resources *core.Resources `protobuf:"bytes,3,opt,name=resources,proto3" json:"resources,omitempty"` + // RestartPolicy determines whether pods will be restarted when they exit + RestartPolicy RestartPolicy `protobuf:"varint,4,opt,name=restart_policy,json=restartPolicy,proto3,enum=flyteidl2.plugins.RestartPolicy" json:"restart_policy,omitempty"` +} + +func (x *CommonReplicaSpec) Reset() { + *x = CommonReplicaSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_common_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CommonReplicaSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CommonReplicaSpec) ProtoMessage() {} + +func (x *CommonReplicaSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_common_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CommonReplicaSpec.ProtoReflect.Descriptor instead. +func (*CommonReplicaSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_common_proto_rawDescGZIP(), []int{0} +} + +func (x *CommonReplicaSpec) GetReplicas() int32 { + if x != nil { + return x.Replicas + } + return 0 +} + +func (x *CommonReplicaSpec) GetImage() string { + if x != nil { + return x.Image + } + return "" +} + +func (x *CommonReplicaSpec) GetResources() *core.Resources { + if x != nil { + return x.Resources + } + return nil +} + +func (x *CommonReplicaSpec) GetRestartPolicy() RestartPolicy { + if x != nil { + return x.RestartPolicy + } + return RestartPolicy_RESTART_POLICY_NEVER +} + +var File_flyteidl2_plugins_common_proto protoreflect.FileDescriptor + +var file_flyteidl2_plugins_common_proto_rawDesc = []byte{ + 0x0a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x12, 0x11, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, + 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, + 0xc7, 0x01, 0x0a, 0x11, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x73, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x37, 0x0a, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x73, 0x52, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, + 0x12, 0x47, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x70, 0x6f, 0x6c, 0x69, + 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x52, 0x65, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2a, 0x63, 0x0a, 0x0d, 0x52, 0x65, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x18, 0x0a, 0x14, 0x52, 0x45, + 0x53, 0x54, 0x41, 0x52, 0x54, 0x5f, 0x50, 0x4f, 0x4c, 0x49, 0x43, 0x59, 0x5f, 0x4e, 0x45, 0x56, + 0x45, 0x52, 0x10, 0x00, 0x12, 0x1d, 0x0a, 0x19, 0x52, 0x45, 0x53, 0x54, 0x41, 0x52, 0x54, 0x5f, + 0x50, 0x4f, 0x4c, 0x49, 0x43, 0x59, 0x5f, 0x4f, 0x4e, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, + 0x45, 0x10, 0x01, 0x12, 0x19, 0x0a, 0x15, 0x52, 0x45, 0x53, 0x54, 0x41, 0x52, 0x54, 0x5f, 0x50, + 0x4f, 0x4c, 0x49, 0x43, 0x59, 0x5f, 0x41, 0x4c, 0x57, 0x41, 0x59, 0x53, 0x10, 0x02, 0x42, 0xc2, + 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x42, 0x0b, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0xa2, 0x02, 0x03, 0x46, 0x50, 0x58, 0xaa, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xca, 0x02, 0x11, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xe2, 0x02, + 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, + 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x50, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_plugins_common_proto_rawDescOnce sync.Once + file_flyteidl2_plugins_common_proto_rawDescData = file_flyteidl2_plugins_common_proto_rawDesc +) + +func file_flyteidl2_plugins_common_proto_rawDescGZIP() []byte { + file_flyteidl2_plugins_common_proto_rawDescOnce.Do(func() { + file_flyteidl2_plugins_common_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_plugins_common_proto_rawDescData) + }) + return file_flyteidl2_plugins_common_proto_rawDescData +} + +var file_flyteidl2_plugins_common_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_flyteidl2_plugins_common_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_flyteidl2_plugins_common_proto_goTypes = []interface{}{ + (RestartPolicy)(0), // 0: flyteidl2.plugins.RestartPolicy + (*CommonReplicaSpec)(nil), // 1: flyteidl2.plugins.CommonReplicaSpec + (*core.Resources)(nil), // 2: flyteidl2.core.Resources +} +var file_flyteidl2_plugins_common_proto_depIdxs = []int32{ + 2, // 0: flyteidl2.plugins.CommonReplicaSpec.resources:type_name -> flyteidl2.core.Resources + 0, // 1: flyteidl2.plugins.CommonReplicaSpec.restart_policy:type_name -> flyteidl2.plugins.RestartPolicy + 2, // [2:2] is the sub-list for method output_type + 2, // [2:2] is the sub-list for method input_type + 2, // [2:2] is the sub-list for extension type_name + 2, // [2:2] is the sub-list for extension extendee + 0, // [0:2] is the sub-list for field type_name +} + +func init() { file_flyteidl2_plugins_common_proto_init() } +func file_flyteidl2_plugins_common_proto_init() { + if File_flyteidl2_plugins_common_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_plugins_common_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CommonReplicaSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_plugins_common_proto_rawDesc, + NumEnums: 1, + NumMessages: 1, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_plugins_common_proto_goTypes, + DependencyIndexes: file_flyteidl2_plugins_common_proto_depIdxs, + EnumInfos: file_flyteidl2_plugins_common_proto_enumTypes, + MessageInfos: file_flyteidl2_plugins_common_proto_msgTypes, + }.Build() + File_flyteidl2_plugins_common_proto = out.File + file_flyteidl2_plugins_common_proto_rawDesc = nil + file_flyteidl2_plugins_common_proto_goTypes = nil + file_flyteidl2_plugins_common_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/plugins/common.pb.validate.go b/gen/go/flyteidl2/plugins/common.pb.validate.go new file mode 100644 index 0000000000..77b315809a --- /dev/null +++ b/gen/go/flyteidl2/plugins/common.pb.validate.go @@ -0,0 +1,173 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/plugins/common.proto + +package plugins + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on CommonReplicaSpec with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *CommonReplicaSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CommonReplicaSpec with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CommonReplicaSpecMultiError, or nil if none found. +func (m *CommonReplicaSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *CommonReplicaSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Replicas + + // no validation rules for Image + + if all { + switch v := interface{}(m.GetResources()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CommonReplicaSpecValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CommonReplicaSpecValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetResources()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CommonReplicaSpecValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for RestartPolicy + + if len(errors) > 0 { + return CommonReplicaSpecMultiError(errors) + } + + return nil +} + +// CommonReplicaSpecMultiError is an error wrapping multiple validation errors +// returned by CommonReplicaSpec.ValidateAll() if the designated constraints +// aren't met. +type CommonReplicaSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CommonReplicaSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CommonReplicaSpecMultiError) AllErrors() []error { return m } + +// CommonReplicaSpecValidationError is the validation error returned by +// CommonReplicaSpec.Validate if the designated constraints aren't met. +type CommonReplicaSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CommonReplicaSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CommonReplicaSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CommonReplicaSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CommonReplicaSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CommonReplicaSpecValidationError) ErrorName() string { + return "CommonReplicaSpecValidationError" +} + +// Error satisfies the builtin error interface +func (e CommonReplicaSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCommonReplicaSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CommonReplicaSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CommonReplicaSpecValidationError{} diff --git a/gen/go/flyteidl2/plugins/dask.pb.go b/gen/go/flyteidl2/plugins/dask.pb.go new file mode 100644 index 0000000000..b33e3475fb --- /dev/null +++ b/gen/go/flyteidl2/plugins/dask.pb.go @@ -0,0 +1,349 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/plugins/dask.proto + +package plugins + +import ( + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Custom Proto for Dask Plugin. +type DaskJob struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Spec for the scheduler pod. + Scheduler *DaskScheduler `protobuf:"bytes,1,opt,name=scheduler,proto3" json:"scheduler,omitempty"` + // Spec of the default worker group. + Workers *DaskWorkerGroup `protobuf:"bytes,2,opt,name=workers,proto3" json:"workers,omitempty"` +} + +func (x *DaskJob) Reset() { + *x = DaskJob{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_dask_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DaskJob) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DaskJob) ProtoMessage() {} + +func (x *DaskJob) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_dask_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DaskJob.ProtoReflect.Descriptor instead. +func (*DaskJob) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_dask_proto_rawDescGZIP(), []int{0} +} + +func (x *DaskJob) GetScheduler() *DaskScheduler { + if x != nil { + return x.Scheduler + } + return nil +} + +func (x *DaskJob) GetWorkers() *DaskWorkerGroup { + if x != nil { + return x.Workers + } + return nil +} + +// Specification for the scheduler pod. +type DaskScheduler struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Optional image to use. If unset, will use the default image. + Image string `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"` + // Resources assigned to the scheduler pod. + Resources *core.Resources `protobuf:"bytes,2,opt,name=resources,proto3" json:"resources,omitempty"` +} + +func (x *DaskScheduler) Reset() { + *x = DaskScheduler{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_dask_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DaskScheduler) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DaskScheduler) ProtoMessage() {} + +func (x *DaskScheduler) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_dask_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DaskScheduler.ProtoReflect.Descriptor instead. +func (*DaskScheduler) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_dask_proto_rawDescGZIP(), []int{1} +} + +func (x *DaskScheduler) GetImage() string { + if x != nil { + return x.Image + } + return "" +} + +func (x *DaskScheduler) GetResources() *core.Resources { + if x != nil { + return x.Resources + } + return nil +} + +type DaskWorkerGroup struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Number of workers in the group. + NumberOfWorkers uint32 `protobuf:"varint,1,opt,name=number_of_workers,json=numberOfWorkers,proto3" json:"number_of_workers,omitempty"` + // Optional image to use for the pods of the worker group. If unset, will use the default image. + Image string `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"` + // Resources assigned to the all pods of the worker group. + // As per https://kubernetes.dask.org/en/latest/kubecluster.html?highlight=limit#best-practices + // it is advised to only set limits. If requests are not explicitly set, the plugin will make + // sure to set requests==limits. + // The plugin sets ` --memory-limit` as well as `--nthreads` for the workers according to the limit. + Resources *core.Resources `protobuf:"bytes,3,opt,name=resources,proto3" json:"resources,omitempty"` +} + +func (x *DaskWorkerGroup) Reset() { + *x = DaskWorkerGroup{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_dask_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DaskWorkerGroup) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DaskWorkerGroup) ProtoMessage() {} + +func (x *DaskWorkerGroup) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_dask_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DaskWorkerGroup.ProtoReflect.Descriptor instead. +func (*DaskWorkerGroup) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_dask_proto_rawDescGZIP(), []int{2} +} + +func (x *DaskWorkerGroup) GetNumberOfWorkers() uint32 { + if x != nil { + return x.NumberOfWorkers + } + return 0 +} + +func (x *DaskWorkerGroup) GetImage() string { + if x != nil { + return x.Image + } + return "" +} + +func (x *DaskWorkerGroup) GetResources() *core.Resources { + if x != nil { + return x.Resources + } + return nil +} + +var File_flyteidl2_plugins_dask_proto protoreflect.FileDescriptor + +var file_flyteidl2_plugins_dask_proto_rawDesc = []byte{ + 0x0a, 0x1c, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2f, 0x64, 0x61, 0x73, 0x6b, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x11, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, + 0x65, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x87, 0x01, + 0x0a, 0x07, 0x44, 0x61, 0x73, 0x6b, 0x4a, 0x6f, 0x62, 0x12, 0x3e, 0x0a, 0x09, 0x73, 0x63, 0x68, + 0x65, 0x64, 0x75, 0x6c, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0x2e, 0x44, 0x61, 0x73, 0x6b, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x72, 0x52, 0x09, + 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x72, 0x12, 0x3c, 0x0a, 0x07, 0x77, 0x6f, 0x72, + 0x6b, 0x65, 0x72, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x44, + 0x61, 0x73, 0x6b, 0x57, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x07, + 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x73, 0x22, 0x5e, 0x0a, 0x0d, 0x44, 0x61, 0x73, 0x6b, 0x53, + 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x37, + 0x0a, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x52, 0x09, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x22, 0x8c, 0x01, 0x0a, 0x0f, 0x44, 0x61, 0x73, 0x6b, + 0x57, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x2a, 0x0a, 0x11, 0x6e, + 0x75, 0x6d, 0x62, 0x65, 0x72, 0x5f, 0x6f, 0x66, 0x5f, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x73, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x4f, 0x66, + 0x57, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x37, 0x0a, + 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x52, 0x09, 0x72, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x42, 0xc0, 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0x42, 0x09, 0x44, 0x61, 0x73, 0x6b, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, + 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, + 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x58, 0xaa, 0x02, 0x11, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0xca, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x73, 0xe2, 0x02, 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x3a, 0x3a, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, +} + +var ( + file_flyteidl2_plugins_dask_proto_rawDescOnce sync.Once + file_flyteidl2_plugins_dask_proto_rawDescData = file_flyteidl2_plugins_dask_proto_rawDesc +) + +func file_flyteidl2_plugins_dask_proto_rawDescGZIP() []byte { + file_flyteidl2_plugins_dask_proto_rawDescOnce.Do(func() { + file_flyteidl2_plugins_dask_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_plugins_dask_proto_rawDescData) + }) + return file_flyteidl2_plugins_dask_proto_rawDescData +} + +var file_flyteidl2_plugins_dask_proto_msgTypes = make([]protoimpl.MessageInfo, 3) +var file_flyteidl2_plugins_dask_proto_goTypes = []interface{}{ + (*DaskJob)(nil), // 0: flyteidl2.plugins.DaskJob + (*DaskScheduler)(nil), // 1: flyteidl2.plugins.DaskScheduler + (*DaskWorkerGroup)(nil), // 2: flyteidl2.plugins.DaskWorkerGroup + (*core.Resources)(nil), // 3: flyteidl2.core.Resources +} +var file_flyteidl2_plugins_dask_proto_depIdxs = []int32{ + 1, // 0: flyteidl2.plugins.DaskJob.scheduler:type_name -> flyteidl2.plugins.DaskScheduler + 2, // 1: flyteidl2.plugins.DaskJob.workers:type_name -> flyteidl2.plugins.DaskWorkerGroup + 3, // 2: flyteidl2.plugins.DaskScheduler.resources:type_name -> flyteidl2.core.Resources + 3, // 3: flyteidl2.plugins.DaskWorkerGroup.resources:type_name -> flyteidl2.core.Resources + 4, // [4:4] is the sub-list for method output_type + 4, // [4:4] is the sub-list for method input_type + 4, // [4:4] is the sub-list for extension type_name + 4, // [4:4] is the sub-list for extension extendee + 0, // [0:4] is the sub-list for field type_name +} + +func init() { file_flyteidl2_plugins_dask_proto_init() } +func file_flyteidl2_plugins_dask_proto_init() { + if File_flyteidl2_plugins_dask_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_plugins_dask_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DaskJob); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_plugins_dask_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DaskScheduler); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_plugins_dask_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DaskWorkerGroup); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_plugins_dask_proto_rawDesc, + NumEnums: 0, + NumMessages: 3, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_plugins_dask_proto_goTypes, + DependencyIndexes: file_flyteidl2_plugins_dask_proto_depIdxs, + MessageInfos: file_flyteidl2_plugins_dask_proto_msgTypes, + }.Build() + File_flyteidl2_plugins_dask_proto = out.File + file_flyteidl2_plugins_dask_proto_rawDesc = nil + file_flyteidl2_plugins_dask_proto_goTypes = nil + file_flyteidl2_plugins_dask_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/plugins/dask.pb.validate.go b/gen/go/flyteidl2/plugins/dask.pb.validate.go new file mode 100644 index 0000000000..c6d0a40607 --- /dev/null +++ b/gen/go/flyteidl2/plugins/dask.pb.validate.go @@ -0,0 +1,456 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/plugins/dask.proto + +package plugins + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on DaskJob with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *DaskJob) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DaskJob with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in DaskJobMultiError, or nil if none found. +func (m *DaskJob) ValidateAll() error { + return m.validate(true) +} + +func (m *DaskJob) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetScheduler()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DaskJobValidationError{ + field: "Scheduler", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DaskJobValidationError{ + field: "Scheduler", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetScheduler()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DaskJobValidationError{ + field: "Scheduler", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetWorkers()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DaskJobValidationError{ + field: "Workers", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DaskJobValidationError{ + field: "Workers", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetWorkers()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DaskJobValidationError{ + field: "Workers", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DaskJobMultiError(errors) + } + + return nil +} + +// DaskJobMultiError is an error wrapping multiple validation errors returned +// by DaskJob.ValidateAll() if the designated constraints aren't met. +type DaskJobMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DaskJobMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DaskJobMultiError) AllErrors() []error { return m } + +// DaskJobValidationError is the validation error returned by DaskJob.Validate +// if the designated constraints aren't met. +type DaskJobValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DaskJobValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DaskJobValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DaskJobValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DaskJobValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DaskJobValidationError) ErrorName() string { return "DaskJobValidationError" } + +// Error satisfies the builtin error interface +func (e DaskJobValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDaskJob.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DaskJobValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DaskJobValidationError{} + +// Validate checks the field values on DaskScheduler with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *DaskScheduler) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DaskScheduler with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in DaskSchedulerMultiError, or +// nil if none found. +func (m *DaskScheduler) ValidateAll() error { + return m.validate(true) +} + +func (m *DaskScheduler) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Image + + if all { + switch v := interface{}(m.GetResources()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DaskSchedulerValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DaskSchedulerValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetResources()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DaskSchedulerValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DaskSchedulerMultiError(errors) + } + + return nil +} + +// DaskSchedulerMultiError is an error wrapping multiple validation errors +// returned by DaskScheduler.ValidateAll() if the designated constraints +// aren't met. +type DaskSchedulerMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DaskSchedulerMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DaskSchedulerMultiError) AllErrors() []error { return m } + +// DaskSchedulerValidationError is the validation error returned by +// DaskScheduler.Validate if the designated constraints aren't met. +type DaskSchedulerValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DaskSchedulerValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DaskSchedulerValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DaskSchedulerValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DaskSchedulerValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DaskSchedulerValidationError) ErrorName() string { return "DaskSchedulerValidationError" } + +// Error satisfies the builtin error interface +func (e DaskSchedulerValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDaskScheduler.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DaskSchedulerValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DaskSchedulerValidationError{} + +// Validate checks the field values on DaskWorkerGroup with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *DaskWorkerGroup) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DaskWorkerGroup with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// DaskWorkerGroupMultiError, or nil if none found. +func (m *DaskWorkerGroup) ValidateAll() error { + return m.validate(true) +} + +func (m *DaskWorkerGroup) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for NumberOfWorkers + + // no validation rules for Image + + if all { + switch v := interface{}(m.GetResources()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DaskWorkerGroupValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DaskWorkerGroupValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetResources()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DaskWorkerGroupValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DaskWorkerGroupMultiError(errors) + } + + return nil +} + +// DaskWorkerGroupMultiError is an error wrapping multiple validation errors +// returned by DaskWorkerGroup.ValidateAll() if the designated constraints +// aren't met. +type DaskWorkerGroupMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DaskWorkerGroupMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DaskWorkerGroupMultiError) AllErrors() []error { return m } + +// DaskWorkerGroupValidationError is the validation error returned by +// DaskWorkerGroup.Validate if the designated constraints aren't met. +type DaskWorkerGroupValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DaskWorkerGroupValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DaskWorkerGroupValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DaskWorkerGroupValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DaskWorkerGroupValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DaskWorkerGroupValidationError) ErrorName() string { return "DaskWorkerGroupValidationError" } + +// Error satisfies the builtin error interface +func (e DaskWorkerGroupValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDaskWorkerGroup.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DaskWorkerGroupValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DaskWorkerGroupValidationError{} diff --git a/gen/go/flyteidl2/plugins/kubeflow/common.pb.go b/gen/go/flyteidl2/plugins/kubeflow/common.pb.go new file mode 100644 index 0000000000..7f73a0ac83 --- /dev/null +++ b/gen/go/flyteidl2/plugins/kubeflow/common.pb.go @@ -0,0 +1,261 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/plugins/kubeflow/common.proto + +package kubeflow + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type CleanPodPolicy int32 + +const ( + CleanPodPolicy_CLEANPOD_POLICY_NONE CleanPodPolicy = 0 + CleanPodPolicy_CLEANPOD_POLICY_RUNNING CleanPodPolicy = 1 + CleanPodPolicy_CLEANPOD_POLICY_ALL CleanPodPolicy = 2 +) + +// Enum value maps for CleanPodPolicy. +var ( + CleanPodPolicy_name = map[int32]string{ + 0: "CLEANPOD_POLICY_NONE", + 1: "CLEANPOD_POLICY_RUNNING", + 2: "CLEANPOD_POLICY_ALL", + } + CleanPodPolicy_value = map[string]int32{ + "CLEANPOD_POLICY_NONE": 0, + "CLEANPOD_POLICY_RUNNING": 1, + "CLEANPOD_POLICY_ALL": 2, + } +) + +func (x CleanPodPolicy) Enum() *CleanPodPolicy { + p := new(CleanPodPolicy) + *p = x + return p +} + +func (x CleanPodPolicy) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (CleanPodPolicy) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_plugins_kubeflow_common_proto_enumTypes[0].Descriptor() +} + +func (CleanPodPolicy) Type() protoreflect.EnumType { + return &file_flyteidl2_plugins_kubeflow_common_proto_enumTypes[0] +} + +func (x CleanPodPolicy) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use CleanPodPolicy.Descriptor instead. +func (CleanPodPolicy) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_plugins_kubeflow_common_proto_rawDescGZIP(), []int{0} +} + +type RunPolicy struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Defines the policy to kill pods after the job completes. Default to None. + CleanPodPolicy CleanPodPolicy `protobuf:"varint,1,opt,name=clean_pod_policy,json=cleanPodPolicy,proto3,enum=flyteidl2.plugins.kubeflow.CleanPodPolicy" json:"clean_pod_policy,omitempty"` + // TTL to clean up jobs. Default to infinite. + TtlSecondsAfterFinished int32 `protobuf:"varint,2,opt,name=ttl_seconds_after_finished,json=ttlSecondsAfterFinished,proto3" json:"ttl_seconds_after_finished,omitempty"` + // Specifies the duration in seconds relative to the startTime that the job may be active + // before the system tries to terminate it; value must be positive integer. + ActiveDeadlineSeconds int32 `protobuf:"varint,3,opt,name=active_deadline_seconds,json=activeDeadlineSeconds,proto3" json:"active_deadline_seconds,omitempty"` + // Number of retries before marking this job failed. + BackoffLimit int32 `protobuf:"varint,4,opt,name=backoff_limit,json=backoffLimit,proto3" json:"backoff_limit,omitempty"` +} + +func (x *RunPolicy) Reset() { + *x = RunPolicy{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_kubeflow_common_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RunPolicy) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RunPolicy) ProtoMessage() {} + +func (x *RunPolicy) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_kubeflow_common_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RunPolicy.ProtoReflect.Descriptor instead. +func (*RunPolicy) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_kubeflow_common_proto_rawDescGZIP(), []int{0} +} + +func (x *RunPolicy) GetCleanPodPolicy() CleanPodPolicy { + if x != nil { + return x.CleanPodPolicy + } + return CleanPodPolicy_CLEANPOD_POLICY_NONE +} + +func (x *RunPolicy) GetTtlSecondsAfterFinished() int32 { + if x != nil { + return x.TtlSecondsAfterFinished + } + return 0 +} + +func (x *RunPolicy) GetActiveDeadlineSeconds() int32 { + if x != nil { + return x.ActiveDeadlineSeconds + } + return 0 +} + +func (x *RunPolicy) GetBackoffLimit() int32 { + if x != nil { + return x.BackoffLimit + } + return 0 +} + +var File_flyteidl2_plugins_kubeflow_common_proto protoreflect.FileDescriptor + +var file_flyteidl2_plugins_kubeflow_common_proto_rawDesc = []byte{ + 0x0a, 0x27, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, + 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x22, 0xfb, 0x01, 0x0a, 0x09, 0x52, 0x75, 0x6e, 0x50, 0x6f, 0x6c, + 0x69, 0x63, 0x79, 0x12, 0x54, 0x0a, 0x10, 0x63, 0x6c, 0x65, 0x61, 0x6e, 0x5f, 0x70, 0x6f, 0x64, + 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2a, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x43, 0x6c, 0x65, 0x61, 0x6e, + 0x50, 0x6f, 0x64, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x0e, 0x63, 0x6c, 0x65, 0x61, 0x6e, + 0x50, 0x6f, 0x64, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x3b, 0x0a, 0x1a, 0x74, 0x74, 0x6c, + 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x5f, 0x61, 0x66, 0x74, 0x65, 0x72, 0x5f, 0x66, + 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x17, 0x74, + 0x74, 0x6c, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x41, 0x66, 0x74, 0x65, 0x72, 0x46, 0x69, + 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x12, 0x36, 0x0a, 0x17, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, + 0x5f, 0x64, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, + 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x15, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x44, + 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x23, + 0x0a, 0x0d, 0x62, 0x61, 0x63, 0x6b, 0x6f, 0x66, 0x66, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x62, 0x61, 0x63, 0x6b, 0x6f, 0x66, 0x66, 0x4c, 0x69, + 0x6d, 0x69, 0x74, 0x2a, 0x60, 0x0a, 0x0e, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x50, 0x6f, 0x64, 0x50, + 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x18, 0x0a, 0x14, 0x43, 0x4c, 0x45, 0x41, 0x4e, 0x50, 0x4f, + 0x44, 0x5f, 0x50, 0x4f, 0x4c, 0x49, 0x43, 0x59, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x00, 0x12, + 0x1b, 0x0a, 0x17, 0x43, 0x4c, 0x45, 0x41, 0x4e, 0x50, 0x4f, 0x44, 0x5f, 0x50, 0x4f, 0x4c, 0x49, + 0x43, 0x59, 0x5f, 0x52, 0x55, 0x4e, 0x4e, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x17, 0x0a, 0x13, + 0x43, 0x4c, 0x45, 0x41, 0x4e, 0x50, 0x4f, 0x44, 0x5f, 0x50, 0x4f, 0x4c, 0x49, 0x43, 0x59, 0x5f, + 0x41, 0x4c, 0x4c, 0x10, 0x02, 0x42, 0xf9, 0x01, 0x0a, 0x1e, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, + 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x0b, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x3e, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x4b, 0xaa, + 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2e, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xca, 0x02, 0x1a, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0x5c, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xe2, 0x02, 0x26, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x4b, 0x75, + 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, + 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x3a, 0x3a, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, + 0x77, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_plugins_kubeflow_common_proto_rawDescOnce sync.Once + file_flyteidl2_plugins_kubeflow_common_proto_rawDescData = file_flyteidl2_plugins_kubeflow_common_proto_rawDesc +) + +func file_flyteidl2_plugins_kubeflow_common_proto_rawDescGZIP() []byte { + file_flyteidl2_plugins_kubeflow_common_proto_rawDescOnce.Do(func() { + file_flyteidl2_plugins_kubeflow_common_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_plugins_kubeflow_common_proto_rawDescData) + }) + return file_flyteidl2_plugins_kubeflow_common_proto_rawDescData +} + +var file_flyteidl2_plugins_kubeflow_common_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_flyteidl2_plugins_kubeflow_common_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_flyteidl2_plugins_kubeflow_common_proto_goTypes = []interface{}{ + (CleanPodPolicy)(0), // 0: flyteidl2.plugins.kubeflow.CleanPodPolicy + (*RunPolicy)(nil), // 1: flyteidl2.plugins.kubeflow.RunPolicy +} +var file_flyteidl2_plugins_kubeflow_common_proto_depIdxs = []int32{ + 0, // 0: flyteidl2.plugins.kubeflow.RunPolicy.clean_pod_policy:type_name -> flyteidl2.plugins.kubeflow.CleanPodPolicy + 1, // [1:1] is the sub-list for method output_type + 1, // [1:1] is the sub-list for method input_type + 1, // [1:1] is the sub-list for extension type_name + 1, // [1:1] is the sub-list for extension extendee + 0, // [0:1] is the sub-list for field type_name +} + +func init() { file_flyteidl2_plugins_kubeflow_common_proto_init() } +func file_flyteidl2_plugins_kubeflow_common_proto_init() { + if File_flyteidl2_plugins_kubeflow_common_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_plugins_kubeflow_common_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RunPolicy); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_plugins_kubeflow_common_proto_rawDesc, + NumEnums: 1, + NumMessages: 1, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_plugins_kubeflow_common_proto_goTypes, + DependencyIndexes: file_flyteidl2_plugins_kubeflow_common_proto_depIdxs, + EnumInfos: file_flyteidl2_plugins_kubeflow_common_proto_enumTypes, + MessageInfos: file_flyteidl2_plugins_kubeflow_common_proto_msgTypes, + }.Build() + File_flyteidl2_plugins_kubeflow_common_proto = out.File + file_flyteidl2_plugins_kubeflow_common_proto_rawDesc = nil + file_flyteidl2_plugins_kubeflow_common_proto_goTypes = nil + file_flyteidl2_plugins_kubeflow_common_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/plugins/kubeflow/common.pb.validate.go b/gen/go/flyteidl2/plugins/kubeflow/common.pb.validate.go new file mode 100644 index 0000000000..0a84bcec04 --- /dev/null +++ b/gen/go/flyteidl2/plugins/kubeflow/common.pb.validate.go @@ -0,0 +1,143 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/plugins/kubeflow/common.proto + +package kubeflow + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on RunPolicy with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *RunPolicy) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on RunPolicy with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in RunPolicyMultiError, or nil +// if none found. +func (m *RunPolicy) ValidateAll() error { + return m.validate(true) +} + +func (m *RunPolicy) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for CleanPodPolicy + + // no validation rules for TtlSecondsAfterFinished + + // no validation rules for ActiveDeadlineSeconds + + // no validation rules for BackoffLimit + + if len(errors) > 0 { + return RunPolicyMultiError(errors) + } + + return nil +} + +// RunPolicyMultiError is an error wrapping multiple validation errors returned +// by RunPolicy.ValidateAll() if the designated constraints aren't met. +type RunPolicyMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m RunPolicyMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m RunPolicyMultiError) AllErrors() []error { return m } + +// RunPolicyValidationError is the validation error returned by +// RunPolicy.Validate if the designated constraints aren't met. +type RunPolicyValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e RunPolicyValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e RunPolicyValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e RunPolicyValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e RunPolicyValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e RunPolicyValidationError) ErrorName() string { return "RunPolicyValidationError" } + +// Error satisfies the builtin error interface +func (e RunPolicyValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sRunPolicy.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = RunPolicyValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = RunPolicyValidationError{} diff --git a/gen/go/flyteidl2/plugins/kubeflow/mpi.pb.go b/gen/go/flyteidl2/plugins/kubeflow/mpi.pb.go new file mode 100644 index 0000000000..34d4042e43 --- /dev/null +++ b/gen/go/flyteidl2/plugins/kubeflow/mpi.pb.go @@ -0,0 +1,368 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/plugins/kubeflow/mpi.proto + +package kubeflow + +import ( + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + plugins "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Proto for plugin that enables distributed training using https://github.com/kubeflow/mpi-operator +type DistributedMPITrainingTask struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Worker replicas spec + WorkerReplicas *DistributedMPITrainingReplicaSpec `protobuf:"bytes,1,opt,name=worker_replicas,json=workerReplicas,proto3" json:"worker_replicas,omitempty"` + // Master replicas spec + LauncherReplicas *DistributedMPITrainingReplicaSpec `protobuf:"bytes,2,opt,name=launcher_replicas,json=launcherReplicas,proto3" json:"launcher_replicas,omitempty"` + // RunPolicy encapsulates various runtime policies of the distributed training + // job, for example how to clean up resources and how long the job can stay + // active. + RunPolicy *RunPolicy `protobuf:"bytes,3,opt,name=run_policy,json=runPolicy,proto3" json:"run_policy,omitempty"` + // Number of slots per worker + Slots int32 `protobuf:"varint,4,opt,name=slots,proto3" json:"slots,omitempty"` +} + +func (x *DistributedMPITrainingTask) Reset() { + *x = DistributedMPITrainingTask{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_kubeflow_mpi_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DistributedMPITrainingTask) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DistributedMPITrainingTask) ProtoMessage() {} + +func (x *DistributedMPITrainingTask) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_kubeflow_mpi_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DistributedMPITrainingTask.ProtoReflect.Descriptor instead. +func (*DistributedMPITrainingTask) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_kubeflow_mpi_proto_rawDescGZIP(), []int{0} +} + +func (x *DistributedMPITrainingTask) GetWorkerReplicas() *DistributedMPITrainingReplicaSpec { + if x != nil { + return x.WorkerReplicas + } + return nil +} + +func (x *DistributedMPITrainingTask) GetLauncherReplicas() *DistributedMPITrainingReplicaSpec { + if x != nil { + return x.LauncherReplicas + } + return nil +} + +func (x *DistributedMPITrainingTask) GetRunPolicy() *RunPolicy { + if x != nil { + return x.RunPolicy + } + return nil +} + +func (x *DistributedMPITrainingTask) GetSlots() int32 { + if x != nil { + return x.Slots + } + return 0 +} + +// Replica specification for distributed MPI training +type DistributedMPITrainingReplicaSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // 1~4 deprecated. Use common instead. + // Number of replicas + // + // Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/mpi.proto. + Replicas int32 `protobuf:"varint,1,opt,name=replicas,proto3" json:"replicas,omitempty"` + // Image used for the replica group + // + // Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/mpi.proto. + Image string `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"` + // Resources required for the replica group + // + // Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/mpi.proto. + Resources *core.Resources `protobuf:"bytes,3,opt,name=resources,proto3" json:"resources,omitempty"` + // Restart policy determines whether pods will be restarted when they exit + // + // Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/mpi.proto. + RestartPolicy plugins.RestartPolicy `protobuf:"varint,4,opt,name=restart_policy,json=restartPolicy,proto3,enum=flyteidl2.plugins.RestartPolicy" json:"restart_policy,omitempty"` + // MPI sometimes requires different command set for different replica groups + Command []string `protobuf:"bytes,5,rep,name=command,proto3" json:"command,omitempty"` + // The common replica spec + Common *plugins.CommonReplicaSpec `protobuf:"bytes,6,opt,name=common,proto3" json:"common,omitempty"` +} + +func (x *DistributedMPITrainingReplicaSpec) Reset() { + *x = DistributedMPITrainingReplicaSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_kubeflow_mpi_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DistributedMPITrainingReplicaSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DistributedMPITrainingReplicaSpec) ProtoMessage() {} + +func (x *DistributedMPITrainingReplicaSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_kubeflow_mpi_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DistributedMPITrainingReplicaSpec.ProtoReflect.Descriptor instead. +func (*DistributedMPITrainingReplicaSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_kubeflow_mpi_proto_rawDescGZIP(), []int{1} +} + +// Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/mpi.proto. +func (x *DistributedMPITrainingReplicaSpec) GetReplicas() int32 { + if x != nil { + return x.Replicas + } + return 0 +} + +// Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/mpi.proto. +func (x *DistributedMPITrainingReplicaSpec) GetImage() string { + if x != nil { + return x.Image + } + return "" +} + +// Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/mpi.proto. +func (x *DistributedMPITrainingReplicaSpec) GetResources() *core.Resources { + if x != nil { + return x.Resources + } + return nil +} + +// Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/mpi.proto. +func (x *DistributedMPITrainingReplicaSpec) GetRestartPolicy() plugins.RestartPolicy { + if x != nil { + return x.RestartPolicy + } + return plugins.RestartPolicy(0) +} + +func (x *DistributedMPITrainingReplicaSpec) GetCommand() []string { + if x != nil { + return x.Command + } + return nil +} + +func (x *DistributedMPITrainingReplicaSpec) GetCommon() *plugins.CommonReplicaSpec { + if x != nil { + return x.Common + } + return nil +} + +var File_flyteidl2_plugins_kubeflow_mpi_proto protoreflect.FileDescriptor + +var file_flyteidl2_plugins_kubeflow_mpi_proto_rawDesc = []byte{ + 0x0a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x6d, 0x70, 0x69, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, + 0x6f, 0x77, 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, + 0x72, 0x65, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x27, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xcc, 0x02, 0x0a, 0x1a, 0x44, 0x69, 0x73, 0x74, + 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x4d, 0x50, 0x49, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, + 0x6e, 0x67, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x66, 0x0a, 0x0f, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, + 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x3d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x44, 0x69, 0x73, + 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x4d, 0x50, 0x49, 0x54, 0x72, 0x61, 0x69, 0x6e, + 0x69, 0x6e, 0x67, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0e, + 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x6a, + 0x0a, 0x11, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x3d, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, + 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, + 0x65, 0x64, 0x4d, 0x50, 0x49, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x52, 0x10, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, + 0x65, 0x72, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x44, 0x0a, 0x0a, 0x72, 0x75, + 0x6e, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x50, + 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x09, 0x72, 0x75, 0x6e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, + 0x12, 0x14, 0x0a, 0x05, 0x73, 0x6c, 0x6f, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x05, 0x73, 0x6c, 0x6f, 0x74, 0x73, 0x22, 0xbf, 0x02, 0x0a, 0x21, 0x44, 0x69, 0x73, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x4d, 0x50, 0x49, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, + 0x67, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1e, 0x0a, 0x08, + 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x42, 0x02, + 0x18, 0x01, 0x52, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x18, 0x0a, 0x05, + 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, + 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x3b, 0x0a, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x73, 0x42, 0x02, 0x18, 0x01, 0x52, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x73, 0x12, 0x4b, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x70, + 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, + 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x42, 0x02, 0x18, + 0x01, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, + 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x12, 0x3c, 0x0a, 0x06, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x43, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, + 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x42, 0xf6, 0x01, 0x0a, 0x1e, 0x63, 0x6f, 0x6d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x08, 0x4d, 0x70, 0x69, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x3e, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x4b, 0xaa, + 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2e, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xca, 0x02, 0x1a, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0x5c, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xe2, 0x02, 0x26, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x4b, 0x75, + 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, + 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x3a, 0x3a, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, + 0x77, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_plugins_kubeflow_mpi_proto_rawDescOnce sync.Once + file_flyteidl2_plugins_kubeflow_mpi_proto_rawDescData = file_flyteidl2_plugins_kubeflow_mpi_proto_rawDesc +) + +func file_flyteidl2_plugins_kubeflow_mpi_proto_rawDescGZIP() []byte { + file_flyteidl2_plugins_kubeflow_mpi_proto_rawDescOnce.Do(func() { + file_flyteidl2_plugins_kubeflow_mpi_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_plugins_kubeflow_mpi_proto_rawDescData) + }) + return file_flyteidl2_plugins_kubeflow_mpi_proto_rawDescData +} + +var file_flyteidl2_plugins_kubeflow_mpi_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_flyteidl2_plugins_kubeflow_mpi_proto_goTypes = []interface{}{ + (*DistributedMPITrainingTask)(nil), // 0: flyteidl2.plugins.kubeflow.DistributedMPITrainingTask + (*DistributedMPITrainingReplicaSpec)(nil), // 1: flyteidl2.plugins.kubeflow.DistributedMPITrainingReplicaSpec + (*RunPolicy)(nil), // 2: flyteidl2.plugins.kubeflow.RunPolicy + (*core.Resources)(nil), // 3: flyteidl2.core.Resources + (plugins.RestartPolicy)(0), // 4: flyteidl2.plugins.RestartPolicy + (*plugins.CommonReplicaSpec)(nil), // 5: flyteidl2.plugins.CommonReplicaSpec +} +var file_flyteidl2_plugins_kubeflow_mpi_proto_depIdxs = []int32{ + 1, // 0: flyteidl2.plugins.kubeflow.DistributedMPITrainingTask.worker_replicas:type_name -> flyteidl2.plugins.kubeflow.DistributedMPITrainingReplicaSpec + 1, // 1: flyteidl2.plugins.kubeflow.DistributedMPITrainingTask.launcher_replicas:type_name -> flyteidl2.plugins.kubeflow.DistributedMPITrainingReplicaSpec + 2, // 2: flyteidl2.plugins.kubeflow.DistributedMPITrainingTask.run_policy:type_name -> flyteidl2.plugins.kubeflow.RunPolicy + 3, // 3: flyteidl2.plugins.kubeflow.DistributedMPITrainingReplicaSpec.resources:type_name -> flyteidl2.core.Resources + 4, // 4: flyteidl2.plugins.kubeflow.DistributedMPITrainingReplicaSpec.restart_policy:type_name -> flyteidl2.plugins.RestartPolicy + 5, // 5: flyteidl2.plugins.kubeflow.DistributedMPITrainingReplicaSpec.common:type_name -> flyteidl2.plugins.CommonReplicaSpec + 6, // [6:6] is the sub-list for method output_type + 6, // [6:6] is the sub-list for method input_type + 6, // [6:6] is the sub-list for extension type_name + 6, // [6:6] is the sub-list for extension extendee + 0, // [0:6] is the sub-list for field type_name +} + +func init() { file_flyteidl2_plugins_kubeflow_mpi_proto_init() } +func file_flyteidl2_plugins_kubeflow_mpi_proto_init() { + if File_flyteidl2_plugins_kubeflow_mpi_proto != nil { + return + } + file_flyteidl2_plugins_kubeflow_common_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_plugins_kubeflow_mpi_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DistributedMPITrainingTask); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_plugins_kubeflow_mpi_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DistributedMPITrainingReplicaSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_plugins_kubeflow_mpi_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_plugins_kubeflow_mpi_proto_goTypes, + DependencyIndexes: file_flyteidl2_plugins_kubeflow_mpi_proto_depIdxs, + MessageInfos: file_flyteidl2_plugins_kubeflow_mpi_proto_msgTypes, + }.Build() + File_flyteidl2_plugins_kubeflow_mpi_proto = out.File + file_flyteidl2_plugins_kubeflow_mpi_proto_rawDesc = nil + file_flyteidl2_plugins_kubeflow_mpi_proto_goTypes = nil + file_flyteidl2_plugins_kubeflow_mpi_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/plugins/kubeflow/mpi.pb.validate.go b/gen/go/flyteidl2/plugins/kubeflow/mpi.pb.validate.go new file mode 100644 index 0000000000..766d07b14f --- /dev/null +++ b/gen/go/flyteidl2/plugins/kubeflow/mpi.pb.validate.go @@ -0,0 +1,400 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/plugins/kubeflow/mpi.proto + +package kubeflow + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" + + plugins "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort + + _ = plugins.RestartPolicy(0) +) + +// Validate checks the field values on DistributedMPITrainingTask with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *DistributedMPITrainingTask) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DistributedMPITrainingTask with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// DistributedMPITrainingTaskMultiError, or nil if none found. +func (m *DistributedMPITrainingTask) ValidateAll() error { + return m.validate(true) +} + +func (m *DistributedMPITrainingTask) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetWorkerReplicas()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedMPITrainingTaskValidationError{ + field: "WorkerReplicas", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedMPITrainingTaskValidationError{ + field: "WorkerReplicas", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetWorkerReplicas()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedMPITrainingTaskValidationError{ + field: "WorkerReplicas", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetLauncherReplicas()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedMPITrainingTaskValidationError{ + field: "LauncherReplicas", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedMPITrainingTaskValidationError{ + field: "LauncherReplicas", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLauncherReplicas()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedMPITrainingTaskValidationError{ + field: "LauncherReplicas", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetRunPolicy()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedMPITrainingTaskValidationError{ + field: "RunPolicy", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedMPITrainingTaskValidationError{ + field: "RunPolicy", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunPolicy()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedMPITrainingTaskValidationError{ + field: "RunPolicy", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Slots + + if len(errors) > 0 { + return DistributedMPITrainingTaskMultiError(errors) + } + + return nil +} + +// DistributedMPITrainingTaskMultiError is an error wrapping multiple +// validation errors returned by DistributedMPITrainingTask.ValidateAll() if +// the designated constraints aren't met. +type DistributedMPITrainingTaskMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DistributedMPITrainingTaskMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DistributedMPITrainingTaskMultiError) AllErrors() []error { return m } + +// DistributedMPITrainingTaskValidationError is the validation error returned +// by DistributedMPITrainingTask.Validate if the designated constraints aren't met. +type DistributedMPITrainingTaskValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DistributedMPITrainingTaskValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DistributedMPITrainingTaskValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DistributedMPITrainingTaskValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DistributedMPITrainingTaskValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DistributedMPITrainingTaskValidationError) ErrorName() string { + return "DistributedMPITrainingTaskValidationError" +} + +// Error satisfies the builtin error interface +func (e DistributedMPITrainingTaskValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDistributedMPITrainingTask.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DistributedMPITrainingTaskValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DistributedMPITrainingTaskValidationError{} + +// Validate checks the field values on DistributedMPITrainingReplicaSpec with +// the rules defined in the proto definition for this message. If any rules +// are violated, the first error encountered is returned, or nil if there are +// no violations. +func (m *DistributedMPITrainingReplicaSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DistributedMPITrainingReplicaSpec +// with the rules defined in the proto definition for this message. If any +// rules are violated, the result is a list of violation errors wrapped in +// DistributedMPITrainingReplicaSpecMultiError, or nil if none found. +func (m *DistributedMPITrainingReplicaSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *DistributedMPITrainingReplicaSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Replicas + + // no validation rules for Image + + if all { + switch v := interface{}(m.GetResources()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedMPITrainingReplicaSpecValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedMPITrainingReplicaSpecValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetResources()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedMPITrainingReplicaSpecValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for RestartPolicy + + if all { + switch v := interface{}(m.GetCommon()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedMPITrainingReplicaSpecValidationError{ + field: "Common", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedMPITrainingReplicaSpecValidationError{ + field: "Common", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCommon()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedMPITrainingReplicaSpecValidationError{ + field: "Common", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DistributedMPITrainingReplicaSpecMultiError(errors) + } + + return nil +} + +// DistributedMPITrainingReplicaSpecMultiError is an error wrapping multiple +// validation errors returned by +// DistributedMPITrainingReplicaSpec.ValidateAll() if the designated +// constraints aren't met. +type DistributedMPITrainingReplicaSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DistributedMPITrainingReplicaSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DistributedMPITrainingReplicaSpecMultiError) AllErrors() []error { return m } + +// DistributedMPITrainingReplicaSpecValidationError is the validation error +// returned by DistributedMPITrainingReplicaSpec.Validate if the designated +// constraints aren't met. +type DistributedMPITrainingReplicaSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DistributedMPITrainingReplicaSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DistributedMPITrainingReplicaSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DistributedMPITrainingReplicaSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DistributedMPITrainingReplicaSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DistributedMPITrainingReplicaSpecValidationError) ErrorName() string { + return "DistributedMPITrainingReplicaSpecValidationError" +} + +// Error satisfies the builtin error interface +func (e DistributedMPITrainingReplicaSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDistributedMPITrainingReplicaSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DistributedMPITrainingReplicaSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DistributedMPITrainingReplicaSpecValidationError{} diff --git a/gen/go/flyteidl2/plugins/kubeflow/pytorch.pb.go b/gen/go/flyteidl2/plugins/kubeflow/pytorch.pb.go new file mode 100644 index 0000000000..d011795e90 --- /dev/null +++ b/gen/go/flyteidl2/plugins/kubeflow/pytorch.pb.go @@ -0,0 +1,469 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/plugins/kubeflow/pytorch.proto + +package kubeflow + +import ( + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + plugins "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Custom proto for torch elastic config for distributed training using +// https://github.com/kubeflow/training-operator/blob/master/pkg/apis/kubeflow.org/v1/pytorch_types.go +type ElasticConfig struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RdzvBackend string `protobuf:"bytes,1,opt,name=rdzv_backend,json=rdzvBackend,proto3" json:"rdzv_backend,omitempty"` + MinReplicas int32 `protobuf:"varint,2,opt,name=min_replicas,json=minReplicas,proto3" json:"min_replicas,omitempty"` + MaxReplicas int32 `protobuf:"varint,3,opt,name=max_replicas,json=maxReplicas,proto3" json:"max_replicas,omitempty"` + NprocPerNode int32 `protobuf:"varint,4,opt,name=nproc_per_node,json=nprocPerNode,proto3" json:"nproc_per_node,omitempty"` + MaxRestarts int32 `protobuf:"varint,5,opt,name=max_restarts,json=maxRestarts,proto3" json:"max_restarts,omitempty"` +} + +func (x *ElasticConfig) Reset() { + *x = ElasticConfig{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_kubeflow_pytorch_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ElasticConfig) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ElasticConfig) ProtoMessage() {} + +func (x *ElasticConfig) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_kubeflow_pytorch_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ElasticConfig.ProtoReflect.Descriptor instead. +func (*ElasticConfig) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_kubeflow_pytorch_proto_rawDescGZIP(), []int{0} +} + +func (x *ElasticConfig) GetRdzvBackend() string { + if x != nil { + return x.RdzvBackend + } + return "" +} + +func (x *ElasticConfig) GetMinReplicas() int32 { + if x != nil { + return x.MinReplicas + } + return 0 +} + +func (x *ElasticConfig) GetMaxReplicas() int32 { + if x != nil { + return x.MaxReplicas + } + return 0 +} + +func (x *ElasticConfig) GetNprocPerNode() int32 { + if x != nil { + return x.NprocPerNode + } + return 0 +} + +func (x *ElasticConfig) GetMaxRestarts() int32 { + if x != nil { + return x.MaxRestarts + } + return 0 +} + +// Proto for plugin that enables distributed training using https://github.com/kubeflow/pytorch-operator +type DistributedPyTorchTrainingTask struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Worker replicas spec + WorkerReplicas *DistributedPyTorchTrainingReplicaSpec `protobuf:"bytes,1,opt,name=worker_replicas,json=workerReplicas,proto3" json:"worker_replicas,omitempty"` + // Master replicas spec, master replicas can only have 1 replica + MasterReplicas *DistributedPyTorchTrainingReplicaSpec `protobuf:"bytes,2,opt,name=master_replicas,json=masterReplicas,proto3" json:"master_replicas,omitempty"` + // RunPolicy encapsulates various runtime policies of the distributed training + // job, for example how to clean up resources and how long the job can stay + // active. + RunPolicy *RunPolicy `protobuf:"bytes,3,opt,name=run_policy,json=runPolicy,proto3" json:"run_policy,omitempty"` + // config for an elastic pytorch job + ElasticConfig *ElasticConfig `protobuf:"bytes,4,opt,name=elastic_config,json=elasticConfig,proto3" json:"elastic_config,omitempty"` +} + +func (x *DistributedPyTorchTrainingTask) Reset() { + *x = DistributedPyTorchTrainingTask{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_kubeflow_pytorch_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DistributedPyTorchTrainingTask) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DistributedPyTorchTrainingTask) ProtoMessage() {} + +func (x *DistributedPyTorchTrainingTask) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_kubeflow_pytorch_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DistributedPyTorchTrainingTask.ProtoReflect.Descriptor instead. +func (*DistributedPyTorchTrainingTask) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_kubeflow_pytorch_proto_rawDescGZIP(), []int{1} +} + +func (x *DistributedPyTorchTrainingTask) GetWorkerReplicas() *DistributedPyTorchTrainingReplicaSpec { + if x != nil { + return x.WorkerReplicas + } + return nil +} + +func (x *DistributedPyTorchTrainingTask) GetMasterReplicas() *DistributedPyTorchTrainingReplicaSpec { + if x != nil { + return x.MasterReplicas + } + return nil +} + +func (x *DistributedPyTorchTrainingTask) GetRunPolicy() *RunPolicy { + if x != nil { + return x.RunPolicy + } + return nil +} + +func (x *DistributedPyTorchTrainingTask) GetElasticConfig() *ElasticConfig { + if x != nil { + return x.ElasticConfig + } + return nil +} + +type DistributedPyTorchTrainingReplicaSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // 1~4 deprecated. Use common instead. + // Number of replicas + // + // Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/pytorch.proto. + Replicas int32 `protobuf:"varint,1,opt,name=replicas,proto3" json:"replicas,omitempty"` + // Image used for the replica group + // + // Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/pytorch.proto. + Image string `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"` + // Resources required for the replica group + // + // Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/pytorch.proto. + Resources *core.Resources `protobuf:"bytes,3,opt,name=resources,proto3" json:"resources,omitempty"` + // Restart policy determines whether pods will be restarted when they exit + // + // Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/pytorch.proto. + RestartPolicy plugins.RestartPolicy `protobuf:"varint,4,opt,name=restart_policy,json=restartPolicy,proto3,enum=flyteidl2.plugins.RestartPolicy" json:"restart_policy,omitempty"` + // The common replica spec + Common *plugins.CommonReplicaSpec `protobuf:"bytes,5,opt,name=common,proto3" json:"common,omitempty"` +} + +func (x *DistributedPyTorchTrainingReplicaSpec) Reset() { + *x = DistributedPyTorchTrainingReplicaSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_kubeflow_pytorch_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DistributedPyTorchTrainingReplicaSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DistributedPyTorchTrainingReplicaSpec) ProtoMessage() {} + +func (x *DistributedPyTorchTrainingReplicaSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_kubeflow_pytorch_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DistributedPyTorchTrainingReplicaSpec.ProtoReflect.Descriptor instead. +func (*DistributedPyTorchTrainingReplicaSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_kubeflow_pytorch_proto_rawDescGZIP(), []int{2} +} + +// Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/pytorch.proto. +func (x *DistributedPyTorchTrainingReplicaSpec) GetReplicas() int32 { + if x != nil { + return x.Replicas + } + return 0 +} + +// Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/pytorch.proto. +func (x *DistributedPyTorchTrainingReplicaSpec) GetImage() string { + if x != nil { + return x.Image + } + return "" +} + +// Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/pytorch.proto. +func (x *DistributedPyTorchTrainingReplicaSpec) GetResources() *core.Resources { + if x != nil { + return x.Resources + } + return nil +} + +// Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/pytorch.proto. +func (x *DistributedPyTorchTrainingReplicaSpec) GetRestartPolicy() plugins.RestartPolicy { + if x != nil { + return x.RestartPolicy + } + return plugins.RestartPolicy(0) +} + +func (x *DistributedPyTorchTrainingReplicaSpec) GetCommon() *plugins.CommonReplicaSpec { + if x != nil { + return x.Common + } + return nil +} + +var File_flyteidl2_plugins_kubeflow_pytorch_proto protoreflect.FileDescriptor + +var file_flyteidl2_plugins_kubeflow_pytorch_proto_rawDesc = []byte{ + 0x0a, 0x28, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x70, 0x79, 0x74, + 0x6f, 0x72, 0x63, 0x68, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, + 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x27, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc1, 0x01, 0x0a, 0x0d, + 0x45, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x21, 0x0a, + 0x0c, 0x72, 0x64, 0x7a, 0x76, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0b, 0x72, 0x64, 0x7a, 0x76, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, + 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x69, 0x6e, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x69, 0x6e, 0x52, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x61, 0x78, 0x52, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x24, 0x0a, 0x0e, 0x6e, 0x70, 0x72, 0x6f, 0x63, 0x5f, + 0x70, 0x65, 0x72, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, + 0x6e, 0x70, 0x72, 0x6f, 0x63, 0x50, 0x65, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x21, 0x0a, 0x0c, + 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x73, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x61, 0x78, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x73, 0x22, + 0x90, 0x03, 0x0a, 0x1e, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x50, + 0x79, 0x54, 0x6f, 0x72, 0x63, 0x68, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x54, 0x61, + 0x73, 0x6b, 0x12, 0x6a, 0x0a, 0x0f, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x5f, 0x72, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x41, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, + 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x64, 0x50, 0x79, 0x54, 0x6f, 0x72, 0x63, 0x68, 0x54, 0x72, 0x61, 0x69, 0x6e, + 0x69, 0x6e, 0x67, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0e, + 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x6a, + 0x0a, 0x0f, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x41, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, + 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, + 0x50, 0x79, 0x54, 0x6f, 0x72, 0x63, 0x68, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x52, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0e, 0x6d, 0x61, 0x73, 0x74, + 0x65, 0x72, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x44, 0x0a, 0x0a, 0x72, 0x75, + 0x6e, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x50, + 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x09, 0x72, 0x75, 0x6e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, + 0x12, 0x50, 0x0a, 0x0e, 0x65, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x5f, 0x63, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, + 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x45, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x52, 0x0d, 0x65, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x43, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x22, 0xa9, 0x02, 0x0a, 0x25, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, + 0x65, 0x64, 0x50, 0x79, 0x54, 0x6f, 0x72, 0x63, 0x68, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, + 0x67, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1e, 0x0a, 0x08, + 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x42, 0x02, + 0x18, 0x01, 0x52, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x18, 0x0a, 0x05, + 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, + 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x3b, 0x0a, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x73, 0x42, 0x02, 0x18, 0x01, 0x52, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x73, 0x12, 0x4b, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x70, + 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, + 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x42, 0x02, 0x18, + 0x01, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, + 0x12, 0x3c, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x42, 0xfa, + 0x01, 0x0a, 0x1e, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, + 0x77, 0x42, 0x0c, 0x50, 0x79, 0x74, 0x6f, 0x72, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, + 0x02, 0x50, 0x01, 0x5a, 0x3e, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, + 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, + 0x6c, 0x6f, 0x77, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x4b, 0xaa, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x4b, 0x75, + 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xca, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x4b, 0x75, 0x62, 0x65, 0x66, + 0x6c, 0x6f, 0x77, 0xe2, 0x02, 0x26, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, + 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1c, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0x3a, 0x3a, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_plugins_kubeflow_pytorch_proto_rawDescOnce sync.Once + file_flyteidl2_plugins_kubeflow_pytorch_proto_rawDescData = file_flyteidl2_plugins_kubeflow_pytorch_proto_rawDesc +) + +func file_flyteidl2_plugins_kubeflow_pytorch_proto_rawDescGZIP() []byte { + file_flyteidl2_plugins_kubeflow_pytorch_proto_rawDescOnce.Do(func() { + file_flyteidl2_plugins_kubeflow_pytorch_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_plugins_kubeflow_pytorch_proto_rawDescData) + }) + return file_flyteidl2_plugins_kubeflow_pytorch_proto_rawDescData +} + +var file_flyteidl2_plugins_kubeflow_pytorch_proto_msgTypes = make([]protoimpl.MessageInfo, 3) +var file_flyteidl2_plugins_kubeflow_pytorch_proto_goTypes = []interface{}{ + (*ElasticConfig)(nil), // 0: flyteidl2.plugins.kubeflow.ElasticConfig + (*DistributedPyTorchTrainingTask)(nil), // 1: flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingTask + (*DistributedPyTorchTrainingReplicaSpec)(nil), // 2: flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingReplicaSpec + (*RunPolicy)(nil), // 3: flyteidl2.plugins.kubeflow.RunPolicy + (*core.Resources)(nil), // 4: flyteidl2.core.Resources + (plugins.RestartPolicy)(0), // 5: flyteidl2.plugins.RestartPolicy + (*plugins.CommonReplicaSpec)(nil), // 6: flyteidl2.plugins.CommonReplicaSpec +} +var file_flyteidl2_plugins_kubeflow_pytorch_proto_depIdxs = []int32{ + 2, // 0: flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingTask.worker_replicas:type_name -> flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingReplicaSpec + 2, // 1: flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingTask.master_replicas:type_name -> flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingReplicaSpec + 3, // 2: flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingTask.run_policy:type_name -> flyteidl2.plugins.kubeflow.RunPolicy + 0, // 3: flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingTask.elastic_config:type_name -> flyteidl2.plugins.kubeflow.ElasticConfig + 4, // 4: flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingReplicaSpec.resources:type_name -> flyteidl2.core.Resources + 5, // 5: flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingReplicaSpec.restart_policy:type_name -> flyteidl2.plugins.RestartPolicy + 6, // 6: flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingReplicaSpec.common:type_name -> flyteidl2.plugins.CommonReplicaSpec + 7, // [7:7] is the sub-list for method output_type + 7, // [7:7] is the sub-list for method input_type + 7, // [7:7] is the sub-list for extension type_name + 7, // [7:7] is the sub-list for extension extendee + 0, // [0:7] is the sub-list for field type_name +} + +func init() { file_flyteidl2_plugins_kubeflow_pytorch_proto_init() } +func file_flyteidl2_plugins_kubeflow_pytorch_proto_init() { + if File_flyteidl2_plugins_kubeflow_pytorch_proto != nil { + return + } + file_flyteidl2_plugins_kubeflow_common_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_plugins_kubeflow_pytorch_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ElasticConfig); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_plugins_kubeflow_pytorch_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DistributedPyTorchTrainingTask); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_plugins_kubeflow_pytorch_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DistributedPyTorchTrainingReplicaSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_plugins_kubeflow_pytorch_proto_rawDesc, + NumEnums: 0, + NumMessages: 3, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_plugins_kubeflow_pytorch_proto_goTypes, + DependencyIndexes: file_flyteidl2_plugins_kubeflow_pytorch_proto_depIdxs, + MessageInfos: file_flyteidl2_plugins_kubeflow_pytorch_proto_msgTypes, + }.Build() + File_flyteidl2_plugins_kubeflow_pytorch_proto = out.File + file_flyteidl2_plugins_kubeflow_pytorch_proto_rawDesc = nil + file_flyteidl2_plugins_kubeflow_pytorch_proto_goTypes = nil + file_flyteidl2_plugins_kubeflow_pytorch_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/plugins/kubeflow/pytorch.pb.validate.go b/gen/go/flyteidl2/plugins/kubeflow/pytorch.pb.validate.go new file mode 100644 index 0000000000..254a30603a --- /dev/null +++ b/gen/go/flyteidl2/plugins/kubeflow/pytorch.pb.validate.go @@ -0,0 +1,538 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/plugins/kubeflow/pytorch.proto + +package kubeflow + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" + + plugins "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort + + _ = plugins.RestartPolicy(0) +) + +// Validate checks the field values on ElasticConfig with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ElasticConfig) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ElasticConfig with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ElasticConfigMultiError, or +// nil if none found. +func (m *ElasticConfig) ValidateAll() error { + return m.validate(true) +} + +func (m *ElasticConfig) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for RdzvBackend + + // no validation rules for MinReplicas + + // no validation rules for MaxReplicas + + // no validation rules for NprocPerNode + + // no validation rules for MaxRestarts + + if len(errors) > 0 { + return ElasticConfigMultiError(errors) + } + + return nil +} + +// ElasticConfigMultiError is an error wrapping multiple validation errors +// returned by ElasticConfig.ValidateAll() if the designated constraints +// aren't met. +type ElasticConfigMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ElasticConfigMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ElasticConfigMultiError) AllErrors() []error { return m } + +// ElasticConfigValidationError is the validation error returned by +// ElasticConfig.Validate if the designated constraints aren't met. +type ElasticConfigValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ElasticConfigValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ElasticConfigValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ElasticConfigValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ElasticConfigValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ElasticConfigValidationError) ErrorName() string { return "ElasticConfigValidationError" } + +// Error satisfies the builtin error interface +func (e ElasticConfigValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sElasticConfig.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ElasticConfigValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ElasticConfigValidationError{} + +// Validate checks the field values on DistributedPyTorchTrainingTask with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *DistributedPyTorchTrainingTask) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DistributedPyTorchTrainingTask with +// the rules defined in the proto definition for this message. If any rules +// are violated, the result is a list of violation errors wrapped in +// DistributedPyTorchTrainingTaskMultiError, or nil if none found. +func (m *DistributedPyTorchTrainingTask) ValidateAll() error { + return m.validate(true) +} + +func (m *DistributedPyTorchTrainingTask) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetWorkerReplicas()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedPyTorchTrainingTaskValidationError{ + field: "WorkerReplicas", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedPyTorchTrainingTaskValidationError{ + field: "WorkerReplicas", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetWorkerReplicas()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedPyTorchTrainingTaskValidationError{ + field: "WorkerReplicas", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetMasterReplicas()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedPyTorchTrainingTaskValidationError{ + field: "MasterReplicas", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedPyTorchTrainingTaskValidationError{ + field: "MasterReplicas", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMasterReplicas()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedPyTorchTrainingTaskValidationError{ + field: "MasterReplicas", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetRunPolicy()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedPyTorchTrainingTaskValidationError{ + field: "RunPolicy", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedPyTorchTrainingTaskValidationError{ + field: "RunPolicy", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunPolicy()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedPyTorchTrainingTaskValidationError{ + field: "RunPolicy", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetElasticConfig()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedPyTorchTrainingTaskValidationError{ + field: "ElasticConfig", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedPyTorchTrainingTaskValidationError{ + field: "ElasticConfig", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetElasticConfig()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedPyTorchTrainingTaskValidationError{ + field: "ElasticConfig", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DistributedPyTorchTrainingTaskMultiError(errors) + } + + return nil +} + +// DistributedPyTorchTrainingTaskMultiError is an error wrapping multiple +// validation errors returned by DistributedPyTorchTrainingTask.ValidateAll() +// if the designated constraints aren't met. +type DistributedPyTorchTrainingTaskMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DistributedPyTorchTrainingTaskMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DistributedPyTorchTrainingTaskMultiError) AllErrors() []error { return m } + +// DistributedPyTorchTrainingTaskValidationError is the validation error +// returned by DistributedPyTorchTrainingTask.Validate if the designated +// constraints aren't met. +type DistributedPyTorchTrainingTaskValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DistributedPyTorchTrainingTaskValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DistributedPyTorchTrainingTaskValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DistributedPyTorchTrainingTaskValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DistributedPyTorchTrainingTaskValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DistributedPyTorchTrainingTaskValidationError) ErrorName() string { + return "DistributedPyTorchTrainingTaskValidationError" +} + +// Error satisfies the builtin error interface +func (e DistributedPyTorchTrainingTaskValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDistributedPyTorchTrainingTask.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DistributedPyTorchTrainingTaskValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DistributedPyTorchTrainingTaskValidationError{} + +// Validate checks the field values on DistributedPyTorchTrainingReplicaSpec +// with the rules defined in the proto definition for this message. If any +// rules are violated, the first error encountered is returned, or nil if +// there are no violations. +func (m *DistributedPyTorchTrainingReplicaSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DistributedPyTorchTrainingReplicaSpec +// with the rules defined in the proto definition for this message. If any +// rules are violated, the result is a list of violation errors wrapped in +// DistributedPyTorchTrainingReplicaSpecMultiError, or nil if none found. +func (m *DistributedPyTorchTrainingReplicaSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *DistributedPyTorchTrainingReplicaSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Replicas + + // no validation rules for Image + + if all { + switch v := interface{}(m.GetResources()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedPyTorchTrainingReplicaSpecValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedPyTorchTrainingReplicaSpecValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetResources()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedPyTorchTrainingReplicaSpecValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for RestartPolicy + + if all { + switch v := interface{}(m.GetCommon()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedPyTorchTrainingReplicaSpecValidationError{ + field: "Common", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedPyTorchTrainingReplicaSpecValidationError{ + field: "Common", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCommon()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedPyTorchTrainingReplicaSpecValidationError{ + field: "Common", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DistributedPyTorchTrainingReplicaSpecMultiError(errors) + } + + return nil +} + +// DistributedPyTorchTrainingReplicaSpecMultiError is an error wrapping +// multiple validation errors returned by +// DistributedPyTorchTrainingReplicaSpec.ValidateAll() if the designated +// constraints aren't met. +type DistributedPyTorchTrainingReplicaSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DistributedPyTorchTrainingReplicaSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DistributedPyTorchTrainingReplicaSpecMultiError) AllErrors() []error { return m } + +// DistributedPyTorchTrainingReplicaSpecValidationError is the validation error +// returned by DistributedPyTorchTrainingReplicaSpec.Validate if the +// designated constraints aren't met. +type DistributedPyTorchTrainingReplicaSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DistributedPyTorchTrainingReplicaSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DistributedPyTorchTrainingReplicaSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DistributedPyTorchTrainingReplicaSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DistributedPyTorchTrainingReplicaSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DistributedPyTorchTrainingReplicaSpecValidationError) ErrorName() string { + return "DistributedPyTorchTrainingReplicaSpecValidationError" +} + +// Error satisfies the builtin error interface +func (e DistributedPyTorchTrainingReplicaSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDistributedPyTorchTrainingReplicaSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DistributedPyTorchTrainingReplicaSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DistributedPyTorchTrainingReplicaSpecValidationError{} diff --git a/gen/go/flyteidl2/plugins/kubeflow/tensorflow.pb.go b/gen/go/flyteidl2/plugins/kubeflow/tensorflow.pb.go new file mode 100644 index 0000000000..c75b58fda1 --- /dev/null +++ b/gen/go/flyteidl2/plugins/kubeflow/tensorflow.pb.go @@ -0,0 +1,382 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/plugins/kubeflow/tensorflow.proto + +package kubeflow + +import ( + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + plugins "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Proto for plugin that enables distributed training using https://github.com/kubeflow/tf-operator +type DistributedTensorflowTrainingTask struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Worker replicas spec + WorkerReplicas *DistributedTensorflowTrainingReplicaSpec `protobuf:"bytes,1,opt,name=worker_replicas,json=workerReplicas,proto3" json:"worker_replicas,omitempty"` + // Parameter server replicas spec + PsReplicas *DistributedTensorflowTrainingReplicaSpec `protobuf:"bytes,2,opt,name=ps_replicas,json=psReplicas,proto3" json:"ps_replicas,omitempty"` + // Chief replicas spec + ChiefReplicas *DistributedTensorflowTrainingReplicaSpec `protobuf:"bytes,3,opt,name=chief_replicas,json=chiefReplicas,proto3" json:"chief_replicas,omitempty"` + // RunPolicy encapsulates various runtime policies of the distributed training + // job, for example how to clean up resources and how long the job can stay + // active. + RunPolicy *RunPolicy `protobuf:"bytes,4,opt,name=run_policy,json=runPolicy,proto3" json:"run_policy,omitempty"` + // Evaluator replicas spec + EvaluatorReplicas *DistributedTensorflowTrainingReplicaSpec `protobuf:"bytes,5,opt,name=evaluator_replicas,json=evaluatorReplicas,proto3" json:"evaluator_replicas,omitempty"` +} + +func (x *DistributedTensorflowTrainingTask) Reset() { + *x = DistributedTensorflowTrainingTask{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_kubeflow_tensorflow_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DistributedTensorflowTrainingTask) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DistributedTensorflowTrainingTask) ProtoMessage() {} + +func (x *DistributedTensorflowTrainingTask) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_kubeflow_tensorflow_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DistributedTensorflowTrainingTask.ProtoReflect.Descriptor instead. +func (*DistributedTensorflowTrainingTask) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_kubeflow_tensorflow_proto_rawDescGZIP(), []int{0} +} + +func (x *DistributedTensorflowTrainingTask) GetWorkerReplicas() *DistributedTensorflowTrainingReplicaSpec { + if x != nil { + return x.WorkerReplicas + } + return nil +} + +func (x *DistributedTensorflowTrainingTask) GetPsReplicas() *DistributedTensorflowTrainingReplicaSpec { + if x != nil { + return x.PsReplicas + } + return nil +} + +func (x *DistributedTensorflowTrainingTask) GetChiefReplicas() *DistributedTensorflowTrainingReplicaSpec { + if x != nil { + return x.ChiefReplicas + } + return nil +} + +func (x *DistributedTensorflowTrainingTask) GetRunPolicy() *RunPolicy { + if x != nil { + return x.RunPolicy + } + return nil +} + +func (x *DistributedTensorflowTrainingTask) GetEvaluatorReplicas() *DistributedTensorflowTrainingReplicaSpec { + if x != nil { + return x.EvaluatorReplicas + } + return nil +} + +type DistributedTensorflowTrainingReplicaSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // 1~4 deprecated. Use common instead. + // Number of replicas + // + // Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/tensorflow.proto. + Replicas int32 `protobuf:"varint,1,opt,name=replicas,proto3" json:"replicas,omitempty"` + // Image used for the replica group + // + // Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/tensorflow.proto. + Image string `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"` + // Resources required for the replica group + // + // Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/tensorflow.proto. + Resources *core.Resources `protobuf:"bytes,3,opt,name=resources,proto3" json:"resources,omitempty"` + // Restart policy determines whether pods will be restarted when they exit + // + // Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/tensorflow.proto. + RestartPolicy plugins.RestartPolicy `protobuf:"varint,4,opt,name=restart_policy,json=restartPolicy,proto3,enum=flyteidl2.plugins.RestartPolicy" json:"restart_policy,omitempty"` + // The common replica spec + Common *plugins.CommonReplicaSpec `protobuf:"bytes,5,opt,name=common,proto3" json:"common,omitempty"` +} + +func (x *DistributedTensorflowTrainingReplicaSpec) Reset() { + *x = DistributedTensorflowTrainingReplicaSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_kubeflow_tensorflow_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DistributedTensorflowTrainingReplicaSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DistributedTensorflowTrainingReplicaSpec) ProtoMessage() {} + +func (x *DistributedTensorflowTrainingReplicaSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_kubeflow_tensorflow_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DistributedTensorflowTrainingReplicaSpec.ProtoReflect.Descriptor instead. +func (*DistributedTensorflowTrainingReplicaSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_kubeflow_tensorflow_proto_rawDescGZIP(), []int{1} +} + +// Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/tensorflow.proto. +func (x *DistributedTensorflowTrainingReplicaSpec) GetReplicas() int32 { + if x != nil { + return x.Replicas + } + return 0 +} + +// Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/tensorflow.proto. +func (x *DistributedTensorflowTrainingReplicaSpec) GetImage() string { + if x != nil { + return x.Image + } + return "" +} + +// Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/tensorflow.proto. +func (x *DistributedTensorflowTrainingReplicaSpec) GetResources() *core.Resources { + if x != nil { + return x.Resources + } + return nil +} + +// Deprecated: Marked as deprecated in flyteidl2/plugins/kubeflow/tensorflow.proto. +func (x *DistributedTensorflowTrainingReplicaSpec) GetRestartPolicy() plugins.RestartPolicy { + if x != nil { + return x.RestartPolicy + } + return plugins.RestartPolicy(0) +} + +func (x *DistributedTensorflowTrainingReplicaSpec) GetCommon() *plugins.CommonReplicaSpec { + if x != nil { + return x.Common + } + return nil +} + +var File_flyteidl2_plugins_kubeflow_tensorflow_proto protoreflect.FileDescriptor + +var file_flyteidl2_plugins_kubeflow_tensorflow_proto_rawDesc = []byte{ + 0x0a, 0x2b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x74, 0x65, 0x6e, + 0x73, 0x6f, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x27, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, + 0x77, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa1, + 0x04, 0x0a, 0x21, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x54, 0x65, + 0x6e, 0x73, 0x6f, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, + 0x54, 0x61, 0x73, 0x6b, 0x12, 0x6d, 0x0a, 0x0f, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x5f, 0x72, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x44, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x44, 0x69, 0x73, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x54, 0x65, 0x6e, 0x73, 0x6f, 0x72, 0x66, 0x6c, 0x6f, 0x77, + 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, + 0x70, 0x65, 0x63, 0x52, 0x0e, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x73, 0x12, 0x65, 0x0a, 0x0b, 0x70, 0x73, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x44, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, + 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, + 0x64, 0x54, 0x65, 0x6e, 0x73, 0x6f, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x72, 0x61, 0x69, 0x6e, + 0x69, 0x6e, 0x67, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0a, + 0x70, 0x73, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x6b, 0x0a, 0x0e, 0x63, 0x68, + 0x69, 0x65, 0x66, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x44, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, + 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x54, 0x65, 0x6e, 0x73, 0x6f, + 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0d, 0x63, 0x68, 0x69, 0x65, 0x66, 0x52, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x44, 0x0a, 0x0a, 0x72, 0x75, 0x6e, 0x5f, 0x70, + 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, + 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x50, 0x6f, 0x6c, 0x69, + 0x63, 0x79, 0x52, 0x09, 0x72, 0x75, 0x6e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x73, 0x0a, + 0x12, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x44, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, + 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, + 0x65, 0x64, 0x54, 0x65, 0x6e, 0x73, 0x6f, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x72, 0x61, 0x69, + 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x52, + 0x11, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x73, 0x22, 0xac, 0x02, 0x0a, 0x28, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, + 0x65, 0x64, 0x54, 0x65, 0x6e, 0x73, 0x6f, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x72, 0x61, 0x69, + 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x12, + 0x1e, 0x0a, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x05, 0x42, 0x02, 0x18, 0x01, 0x52, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, + 0x18, 0x0a, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, + 0x18, 0x01, 0x52, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x3b, 0x0a, 0x09, 0x72, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x42, 0x02, 0x18, 0x01, 0x52, 0x09, 0x72, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x12, 0x4b, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x73, 0x2e, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, + 0x42, 0x02, 0x18, 0x01, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, + 0x69, 0x63, 0x79, 0x12, 0x3c, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x42, 0xfd, 0x01, 0x0a, 0x1e, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, + 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x0f, 0x54, 0x65, 0x6e, 0x73, 0x6f, 0x72, 0x66, 0x6c, 0x6f, 0x77, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x3e, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x4b, 0xaa, + 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2e, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xca, 0x02, 0x1a, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0x5c, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xe2, 0x02, 0x26, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x4b, 0x75, + 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, + 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x3a, 0x3a, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, + 0x77, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_plugins_kubeflow_tensorflow_proto_rawDescOnce sync.Once + file_flyteidl2_plugins_kubeflow_tensorflow_proto_rawDescData = file_flyteidl2_plugins_kubeflow_tensorflow_proto_rawDesc +) + +func file_flyteidl2_plugins_kubeflow_tensorflow_proto_rawDescGZIP() []byte { + file_flyteidl2_plugins_kubeflow_tensorflow_proto_rawDescOnce.Do(func() { + file_flyteidl2_plugins_kubeflow_tensorflow_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_plugins_kubeflow_tensorflow_proto_rawDescData) + }) + return file_flyteidl2_plugins_kubeflow_tensorflow_proto_rawDescData +} + +var file_flyteidl2_plugins_kubeflow_tensorflow_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_flyteidl2_plugins_kubeflow_tensorflow_proto_goTypes = []interface{}{ + (*DistributedTensorflowTrainingTask)(nil), // 0: flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingTask + (*DistributedTensorflowTrainingReplicaSpec)(nil), // 1: flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpec + (*RunPolicy)(nil), // 2: flyteidl2.plugins.kubeflow.RunPolicy + (*core.Resources)(nil), // 3: flyteidl2.core.Resources + (plugins.RestartPolicy)(0), // 4: flyteidl2.plugins.RestartPolicy + (*plugins.CommonReplicaSpec)(nil), // 5: flyteidl2.plugins.CommonReplicaSpec +} +var file_flyteidl2_plugins_kubeflow_tensorflow_proto_depIdxs = []int32{ + 1, // 0: flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingTask.worker_replicas:type_name -> flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpec + 1, // 1: flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingTask.ps_replicas:type_name -> flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpec + 1, // 2: flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingTask.chief_replicas:type_name -> flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpec + 2, // 3: flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingTask.run_policy:type_name -> flyteidl2.plugins.kubeflow.RunPolicy + 1, // 4: flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingTask.evaluator_replicas:type_name -> flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpec + 3, // 5: flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpec.resources:type_name -> flyteidl2.core.Resources + 4, // 6: flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpec.restart_policy:type_name -> flyteidl2.plugins.RestartPolicy + 5, // 7: flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpec.common:type_name -> flyteidl2.plugins.CommonReplicaSpec + 8, // [8:8] is the sub-list for method output_type + 8, // [8:8] is the sub-list for method input_type + 8, // [8:8] is the sub-list for extension type_name + 8, // [8:8] is the sub-list for extension extendee + 0, // [0:8] is the sub-list for field type_name +} + +func init() { file_flyteidl2_plugins_kubeflow_tensorflow_proto_init() } +func file_flyteidl2_plugins_kubeflow_tensorflow_proto_init() { + if File_flyteidl2_plugins_kubeflow_tensorflow_proto != nil { + return + } + file_flyteidl2_plugins_kubeflow_common_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_plugins_kubeflow_tensorflow_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DistributedTensorflowTrainingTask); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_plugins_kubeflow_tensorflow_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DistributedTensorflowTrainingReplicaSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_plugins_kubeflow_tensorflow_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_plugins_kubeflow_tensorflow_proto_goTypes, + DependencyIndexes: file_flyteidl2_plugins_kubeflow_tensorflow_proto_depIdxs, + MessageInfos: file_flyteidl2_plugins_kubeflow_tensorflow_proto_msgTypes, + }.Build() + File_flyteidl2_plugins_kubeflow_tensorflow_proto = out.File + file_flyteidl2_plugins_kubeflow_tensorflow_proto_rawDesc = nil + file_flyteidl2_plugins_kubeflow_tensorflow_proto_goTypes = nil + file_flyteidl2_plugins_kubeflow_tensorflow_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/plugins/kubeflow/tensorflow.pb.validate.go b/gen/go/flyteidl2/plugins/kubeflow/tensorflow.pb.validate.go new file mode 100644 index 0000000000..eece03600b --- /dev/null +++ b/gen/go/flyteidl2/plugins/kubeflow/tensorflow.pb.validate.go @@ -0,0 +1,460 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/plugins/kubeflow/tensorflow.proto + +package kubeflow + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" + + plugins "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort + + _ = plugins.RestartPolicy(0) +) + +// Validate checks the field values on DistributedTensorflowTrainingTask with +// the rules defined in the proto definition for this message. If any rules +// are violated, the first error encountered is returned, or nil if there are +// no violations. +func (m *DistributedTensorflowTrainingTask) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DistributedTensorflowTrainingTask +// with the rules defined in the proto definition for this message. If any +// rules are violated, the result is a list of violation errors wrapped in +// DistributedTensorflowTrainingTaskMultiError, or nil if none found. +func (m *DistributedTensorflowTrainingTask) ValidateAll() error { + return m.validate(true) +} + +func (m *DistributedTensorflowTrainingTask) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetWorkerReplicas()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedTensorflowTrainingTaskValidationError{ + field: "WorkerReplicas", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedTensorflowTrainingTaskValidationError{ + field: "WorkerReplicas", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetWorkerReplicas()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedTensorflowTrainingTaskValidationError{ + field: "WorkerReplicas", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetPsReplicas()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedTensorflowTrainingTaskValidationError{ + field: "PsReplicas", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedTensorflowTrainingTaskValidationError{ + field: "PsReplicas", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetPsReplicas()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedTensorflowTrainingTaskValidationError{ + field: "PsReplicas", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetChiefReplicas()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedTensorflowTrainingTaskValidationError{ + field: "ChiefReplicas", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedTensorflowTrainingTaskValidationError{ + field: "ChiefReplicas", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetChiefReplicas()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedTensorflowTrainingTaskValidationError{ + field: "ChiefReplicas", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetRunPolicy()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedTensorflowTrainingTaskValidationError{ + field: "RunPolicy", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedTensorflowTrainingTaskValidationError{ + field: "RunPolicy", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunPolicy()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedTensorflowTrainingTaskValidationError{ + field: "RunPolicy", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetEvaluatorReplicas()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedTensorflowTrainingTaskValidationError{ + field: "EvaluatorReplicas", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedTensorflowTrainingTaskValidationError{ + field: "EvaluatorReplicas", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetEvaluatorReplicas()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedTensorflowTrainingTaskValidationError{ + field: "EvaluatorReplicas", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DistributedTensorflowTrainingTaskMultiError(errors) + } + + return nil +} + +// DistributedTensorflowTrainingTaskMultiError is an error wrapping multiple +// validation errors returned by +// DistributedTensorflowTrainingTask.ValidateAll() if the designated +// constraints aren't met. +type DistributedTensorflowTrainingTaskMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DistributedTensorflowTrainingTaskMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DistributedTensorflowTrainingTaskMultiError) AllErrors() []error { return m } + +// DistributedTensorflowTrainingTaskValidationError is the validation error +// returned by DistributedTensorflowTrainingTask.Validate if the designated +// constraints aren't met. +type DistributedTensorflowTrainingTaskValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DistributedTensorflowTrainingTaskValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DistributedTensorflowTrainingTaskValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DistributedTensorflowTrainingTaskValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DistributedTensorflowTrainingTaskValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DistributedTensorflowTrainingTaskValidationError) ErrorName() string { + return "DistributedTensorflowTrainingTaskValidationError" +} + +// Error satisfies the builtin error interface +func (e DistributedTensorflowTrainingTaskValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDistributedTensorflowTrainingTask.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DistributedTensorflowTrainingTaskValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DistributedTensorflowTrainingTaskValidationError{} + +// Validate checks the field values on DistributedTensorflowTrainingReplicaSpec +// with the rules defined in the proto definition for this message. If any +// rules are violated, the first error encountered is returned, or nil if +// there are no violations. +func (m *DistributedTensorflowTrainingReplicaSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on +// DistributedTensorflowTrainingReplicaSpec with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in +// DistributedTensorflowTrainingReplicaSpecMultiError, or nil if none found. +func (m *DistributedTensorflowTrainingReplicaSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *DistributedTensorflowTrainingReplicaSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Replicas + + // no validation rules for Image + + if all { + switch v := interface{}(m.GetResources()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedTensorflowTrainingReplicaSpecValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedTensorflowTrainingReplicaSpecValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetResources()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedTensorflowTrainingReplicaSpecValidationError{ + field: "Resources", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for RestartPolicy + + if all { + switch v := interface{}(m.GetCommon()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedTensorflowTrainingReplicaSpecValidationError{ + field: "Common", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedTensorflowTrainingReplicaSpecValidationError{ + field: "Common", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCommon()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedTensorflowTrainingReplicaSpecValidationError{ + field: "Common", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DistributedTensorflowTrainingReplicaSpecMultiError(errors) + } + + return nil +} + +// DistributedTensorflowTrainingReplicaSpecMultiError is an error wrapping +// multiple validation errors returned by +// DistributedTensorflowTrainingReplicaSpec.ValidateAll() if the designated +// constraints aren't met. +type DistributedTensorflowTrainingReplicaSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DistributedTensorflowTrainingReplicaSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DistributedTensorflowTrainingReplicaSpecMultiError) AllErrors() []error { return m } + +// DistributedTensorflowTrainingReplicaSpecValidationError is the validation +// error returned by DistributedTensorflowTrainingReplicaSpec.Validate if the +// designated constraints aren't met. +type DistributedTensorflowTrainingReplicaSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DistributedTensorflowTrainingReplicaSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DistributedTensorflowTrainingReplicaSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DistributedTensorflowTrainingReplicaSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DistributedTensorflowTrainingReplicaSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DistributedTensorflowTrainingReplicaSpecValidationError) ErrorName() string { + return "DistributedTensorflowTrainingReplicaSpecValidationError" +} + +// Error satisfies the builtin error interface +func (e DistributedTensorflowTrainingReplicaSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDistributedTensorflowTrainingReplicaSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DistributedTensorflowTrainingReplicaSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DistributedTensorflowTrainingReplicaSpecValidationError{} diff --git a/gen/go/flyteidl2/plugins/mpi.pb.go b/gen/go/flyteidl2/plugins/mpi.pb.go new file mode 100644 index 0000000000..33dd0c8f51 --- /dev/null +++ b/gen/go/flyteidl2/plugins/mpi.pb.go @@ -0,0 +1,184 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/plugins/mpi.proto + +package plugins + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// MPI operator proposal https://github.com/kubeflow/community/blob/master/proposals/mpi-operator-proposal.md +// Custom proto for plugin that enables distributed training using https://github.com/kubeflow/mpi-operator +type DistributedMPITrainingTask struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // number of worker spawned in the cluster for this job + NumWorkers int32 `protobuf:"varint,1,opt,name=num_workers,json=numWorkers,proto3" json:"num_workers,omitempty"` + // number of launcher replicas spawned in the cluster for this job + // The launcher pod invokes mpirun and communicates with worker pods through MPI. + NumLauncherReplicas int32 `protobuf:"varint,2,opt,name=num_launcher_replicas,json=numLauncherReplicas,proto3" json:"num_launcher_replicas,omitempty"` + // number of slots per worker used in hostfile. + // The available slots (GPUs) in each pod. + Slots int32 `protobuf:"varint,3,opt,name=slots,proto3" json:"slots,omitempty"` +} + +func (x *DistributedMPITrainingTask) Reset() { + *x = DistributedMPITrainingTask{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_mpi_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DistributedMPITrainingTask) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DistributedMPITrainingTask) ProtoMessage() {} + +func (x *DistributedMPITrainingTask) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_mpi_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DistributedMPITrainingTask.ProtoReflect.Descriptor instead. +func (*DistributedMPITrainingTask) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_mpi_proto_rawDescGZIP(), []int{0} +} + +func (x *DistributedMPITrainingTask) GetNumWorkers() int32 { + if x != nil { + return x.NumWorkers + } + return 0 +} + +func (x *DistributedMPITrainingTask) GetNumLauncherReplicas() int32 { + if x != nil { + return x.NumLauncherReplicas + } + return 0 +} + +func (x *DistributedMPITrainingTask) GetSlots() int32 { + if x != nil { + return x.Slots + } + return 0 +} + +var File_flyteidl2_plugins_mpi_proto protoreflect.FileDescriptor + +var file_flyteidl2_plugins_mpi_proto_rawDesc = []byte{ + 0x0a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2f, 0x6d, 0x70, 0x69, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0x22, 0x87, 0x01, 0x0a, 0x1a, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, + 0x4d, 0x50, 0x49, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x73, 0x6b, 0x12, + 0x1f, 0x0a, 0x0b, 0x6e, 0x75, 0x6d, 0x5f, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x73, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x6e, 0x75, 0x6d, 0x57, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x73, + 0x12, 0x32, 0x0a, 0x15, 0x6e, 0x75, 0x6d, 0x5f, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, + 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x13, 0x6e, 0x75, 0x6d, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x6c, 0x6f, 0x74, 0x73, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x6c, 0x6f, 0x74, 0x73, 0x42, 0xbf, 0x01, 0x0a, 0x15, 0x63, + 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x73, 0x42, 0x08, 0x4d, 0x70, 0x69, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, + 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, + 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x58, 0xaa, + 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0xca, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, + 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xe2, 0x02, 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x62, 0x06, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_plugins_mpi_proto_rawDescOnce sync.Once + file_flyteidl2_plugins_mpi_proto_rawDescData = file_flyteidl2_plugins_mpi_proto_rawDesc +) + +func file_flyteidl2_plugins_mpi_proto_rawDescGZIP() []byte { + file_flyteidl2_plugins_mpi_proto_rawDescOnce.Do(func() { + file_flyteidl2_plugins_mpi_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_plugins_mpi_proto_rawDescData) + }) + return file_flyteidl2_plugins_mpi_proto_rawDescData +} + +var file_flyteidl2_plugins_mpi_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_flyteidl2_plugins_mpi_proto_goTypes = []interface{}{ + (*DistributedMPITrainingTask)(nil), // 0: flyteidl2.plugins.DistributedMPITrainingTask +} +var file_flyteidl2_plugins_mpi_proto_depIdxs = []int32{ + 0, // [0:0] is the sub-list for method output_type + 0, // [0:0] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_flyteidl2_plugins_mpi_proto_init() } +func file_flyteidl2_plugins_mpi_proto_init() { + if File_flyteidl2_plugins_mpi_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_plugins_mpi_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DistributedMPITrainingTask); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_plugins_mpi_proto_rawDesc, + NumEnums: 0, + NumMessages: 1, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_plugins_mpi_proto_goTypes, + DependencyIndexes: file_flyteidl2_plugins_mpi_proto_depIdxs, + MessageInfos: file_flyteidl2_plugins_mpi_proto_msgTypes, + }.Build() + File_flyteidl2_plugins_mpi_proto = out.File + file_flyteidl2_plugins_mpi_proto_rawDesc = nil + file_flyteidl2_plugins_mpi_proto_goTypes = nil + file_flyteidl2_plugins_mpi_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/plugins/mpi.pb.validate.go b/gen/go/flyteidl2/plugins/mpi.pb.validate.go new file mode 100644 index 0000000000..a00f4d991d --- /dev/null +++ b/gen/go/flyteidl2/plugins/mpi.pb.validate.go @@ -0,0 +1,144 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/plugins/mpi.proto + +package plugins + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on DistributedMPITrainingTask with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *DistributedMPITrainingTask) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DistributedMPITrainingTask with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// DistributedMPITrainingTaskMultiError, or nil if none found. +func (m *DistributedMPITrainingTask) ValidateAll() error { + return m.validate(true) +} + +func (m *DistributedMPITrainingTask) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for NumWorkers + + // no validation rules for NumLauncherReplicas + + // no validation rules for Slots + + if len(errors) > 0 { + return DistributedMPITrainingTaskMultiError(errors) + } + + return nil +} + +// DistributedMPITrainingTaskMultiError is an error wrapping multiple +// validation errors returned by DistributedMPITrainingTask.ValidateAll() if +// the designated constraints aren't met. +type DistributedMPITrainingTaskMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DistributedMPITrainingTaskMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DistributedMPITrainingTaskMultiError) AllErrors() []error { return m } + +// DistributedMPITrainingTaskValidationError is the validation error returned +// by DistributedMPITrainingTask.Validate if the designated constraints aren't met. +type DistributedMPITrainingTaskValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DistributedMPITrainingTaskValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DistributedMPITrainingTaskValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DistributedMPITrainingTaskValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DistributedMPITrainingTaskValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DistributedMPITrainingTaskValidationError) ErrorName() string { + return "DistributedMPITrainingTaskValidationError" +} + +// Error satisfies the builtin error interface +func (e DistributedMPITrainingTaskValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDistributedMPITrainingTask.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DistributedMPITrainingTaskValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DistributedMPITrainingTaskValidationError{} diff --git a/gen/go/flyteidl2/plugins/presto.pb.go b/gen/go/flyteidl2/plugins/presto.pb.go new file mode 100644 index 0000000000..f3ddacbc3b --- /dev/null +++ b/gen/go/flyteidl2/plugins/presto.pb.go @@ -0,0 +1,187 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/plugins/presto.proto + +package plugins + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// This message works with the 'presto' task type in the SDK and is the object that will be in the 'custom' field +// of a Presto task's TaskTemplate +type PrestoQuery struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RoutingGroup string `protobuf:"bytes,1,opt,name=routing_group,json=routingGroup,proto3" json:"routing_group,omitempty"` + Catalog string `protobuf:"bytes,2,opt,name=catalog,proto3" json:"catalog,omitempty"` + Schema string `protobuf:"bytes,3,opt,name=schema,proto3" json:"schema,omitempty"` + Statement string `protobuf:"bytes,4,opt,name=statement,proto3" json:"statement,omitempty"` +} + +func (x *PrestoQuery) Reset() { + *x = PrestoQuery{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_presto_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PrestoQuery) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PrestoQuery) ProtoMessage() {} + +func (x *PrestoQuery) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_presto_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PrestoQuery.ProtoReflect.Descriptor instead. +func (*PrestoQuery) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_presto_proto_rawDescGZIP(), []int{0} +} + +func (x *PrestoQuery) GetRoutingGroup() string { + if x != nil { + return x.RoutingGroup + } + return "" +} + +func (x *PrestoQuery) GetCatalog() string { + if x != nil { + return x.Catalog + } + return "" +} + +func (x *PrestoQuery) GetSchema() string { + if x != nil { + return x.Schema + } + return "" +} + +func (x *PrestoQuery) GetStatement() string { + if x != nil { + return x.Statement + } + return "" +} + +var File_flyteidl2_plugins_presto_proto protoreflect.FileDescriptor + +var file_flyteidl2_plugins_presto_proto_rawDesc = []byte{ + 0x0a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2f, 0x70, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x12, 0x11, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x22, 0x82, 0x01, 0x0a, 0x0b, 0x50, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x51, 0x75, + 0x65, 0x72, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x67, + 0x72, 0x6f, 0x75, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x6f, 0x75, 0x74, + 0x69, 0x6e, 0x67, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x61, 0x74, 0x61, + 0x6c, 0x6f, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x61, 0x74, 0x61, 0x6c, + 0x6f, 0x67, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x74, + 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, + 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x42, 0xc2, 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x73, 0x42, 0x0b, 0x50, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, + 0x02, 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, + 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x58, + 0xaa, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x73, 0xca, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xe2, 0x02, 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x47, 0x50, 0x42, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x62, 0x06, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_plugins_presto_proto_rawDescOnce sync.Once + file_flyteidl2_plugins_presto_proto_rawDescData = file_flyteidl2_plugins_presto_proto_rawDesc +) + +func file_flyteidl2_plugins_presto_proto_rawDescGZIP() []byte { + file_flyteidl2_plugins_presto_proto_rawDescOnce.Do(func() { + file_flyteidl2_plugins_presto_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_plugins_presto_proto_rawDescData) + }) + return file_flyteidl2_plugins_presto_proto_rawDescData +} + +var file_flyteidl2_plugins_presto_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_flyteidl2_plugins_presto_proto_goTypes = []interface{}{ + (*PrestoQuery)(nil), // 0: flyteidl2.plugins.PrestoQuery +} +var file_flyteidl2_plugins_presto_proto_depIdxs = []int32{ + 0, // [0:0] is the sub-list for method output_type + 0, // [0:0] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_flyteidl2_plugins_presto_proto_init() } +func file_flyteidl2_plugins_presto_proto_init() { + if File_flyteidl2_plugins_presto_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_plugins_presto_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PrestoQuery); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_plugins_presto_proto_rawDesc, + NumEnums: 0, + NumMessages: 1, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_plugins_presto_proto_goTypes, + DependencyIndexes: file_flyteidl2_plugins_presto_proto_depIdxs, + MessageInfos: file_flyteidl2_plugins_presto_proto_msgTypes, + }.Build() + File_flyteidl2_plugins_presto_proto = out.File + file_flyteidl2_plugins_presto_proto_rawDesc = nil + file_flyteidl2_plugins_presto_proto_goTypes = nil + file_flyteidl2_plugins_presto_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/plugins/presto.pb.validate.go b/gen/go/flyteidl2/plugins/presto.pb.validate.go new file mode 100644 index 0000000000..5f3a87353e --- /dev/null +++ b/gen/go/flyteidl2/plugins/presto.pb.validate.go @@ -0,0 +1,143 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/plugins/presto.proto + +package plugins + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on PrestoQuery with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *PrestoQuery) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on PrestoQuery with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in PrestoQueryMultiError, or +// nil if none found. +func (m *PrestoQuery) ValidateAll() error { + return m.validate(true) +} + +func (m *PrestoQuery) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for RoutingGroup + + // no validation rules for Catalog + + // no validation rules for Schema + + // no validation rules for Statement + + if len(errors) > 0 { + return PrestoQueryMultiError(errors) + } + + return nil +} + +// PrestoQueryMultiError is an error wrapping multiple validation errors +// returned by PrestoQuery.ValidateAll() if the designated constraints aren't met. +type PrestoQueryMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PrestoQueryMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PrestoQueryMultiError) AllErrors() []error { return m } + +// PrestoQueryValidationError is the validation error returned by +// PrestoQuery.Validate if the designated constraints aren't met. +type PrestoQueryValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PrestoQueryValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PrestoQueryValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PrestoQueryValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PrestoQueryValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PrestoQueryValidationError) ErrorName() string { return "PrestoQueryValidationError" } + +// Error satisfies the builtin error interface +func (e PrestoQueryValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPrestoQuery.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PrestoQueryValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PrestoQueryValidationError{} diff --git a/gen/go/flyteidl2/plugins/pytorch.pb.go b/gen/go/flyteidl2/plugins/pytorch.pb.go new file mode 100644 index 0000000000..278926fbe4 --- /dev/null +++ b/gen/go/flyteidl2/plugins/pytorch.pb.go @@ -0,0 +1,279 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/plugins/pytorch.proto + +package plugins + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Custom proto for torch elastic config for distributed training using +// https://github.com/kubeflow/trainer/blob/e31d11faa9f6ce5111b60c01079d39295589e0ef/pkg/apis/kubeflow.org/v1/pytorch_types.go#L98 +type ElasticConfig struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RdzvBackend string `protobuf:"bytes,1,opt,name=rdzv_backend,json=rdzvBackend,proto3" json:"rdzv_backend,omitempty"` + MinReplicas int32 `protobuf:"varint,2,opt,name=min_replicas,json=minReplicas,proto3" json:"min_replicas,omitempty"` + MaxReplicas int32 `protobuf:"varint,3,opt,name=max_replicas,json=maxReplicas,proto3" json:"max_replicas,omitempty"` + NprocPerNode int32 `protobuf:"varint,4,opt,name=nproc_per_node,json=nprocPerNode,proto3" json:"nproc_per_node,omitempty"` + MaxRestarts int32 `protobuf:"varint,5,opt,name=max_restarts,json=maxRestarts,proto3" json:"max_restarts,omitempty"` +} + +func (x *ElasticConfig) Reset() { + *x = ElasticConfig{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_pytorch_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ElasticConfig) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ElasticConfig) ProtoMessage() {} + +func (x *ElasticConfig) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_pytorch_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ElasticConfig.ProtoReflect.Descriptor instead. +func (*ElasticConfig) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_pytorch_proto_rawDescGZIP(), []int{0} +} + +func (x *ElasticConfig) GetRdzvBackend() string { + if x != nil { + return x.RdzvBackend + } + return "" +} + +func (x *ElasticConfig) GetMinReplicas() int32 { + if x != nil { + return x.MinReplicas + } + return 0 +} + +func (x *ElasticConfig) GetMaxReplicas() int32 { + if x != nil { + return x.MaxReplicas + } + return 0 +} + +func (x *ElasticConfig) GetNprocPerNode() int32 { + if x != nil { + return x.NprocPerNode + } + return 0 +} + +func (x *ElasticConfig) GetMaxRestarts() int32 { + if x != nil { + return x.MaxRestarts + } + return 0 +} + +// Custom proto for plugin that enables distributed training using https://github.com/kubeflow/trainer +type DistributedPyTorchTrainingTask struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // number of worker replicas spawned in the cluster for this job + Workers int32 `protobuf:"varint,1,opt,name=workers,proto3" json:"workers,omitempty"` + // config for an elastic pytorch job + ElasticConfig *ElasticConfig `protobuf:"bytes,2,opt,name=elastic_config,json=elasticConfig,proto3" json:"elastic_config,omitempty"` +} + +func (x *DistributedPyTorchTrainingTask) Reset() { + *x = DistributedPyTorchTrainingTask{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_pytorch_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DistributedPyTorchTrainingTask) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DistributedPyTorchTrainingTask) ProtoMessage() {} + +func (x *DistributedPyTorchTrainingTask) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_pytorch_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DistributedPyTorchTrainingTask.ProtoReflect.Descriptor instead. +func (*DistributedPyTorchTrainingTask) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_pytorch_proto_rawDescGZIP(), []int{1} +} + +func (x *DistributedPyTorchTrainingTask) GetWorkers() int32 { + if x != nil { + return x.Workers + } + return 0 +} + +func (x *DistributedPyTorchTrainingTask) GetElasticConfig() *ElasticConfig { + if x != nil { + return x.ElasticConfig + } + return nil +} + +var File_flyteidl2_plugins_pytorch_proto protoreflect.FileDescriptor + +var file_flyteidl2_plugins_pytorch_proto_rawDesc = []byte{ + 0x0a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2f, 0x70, 0x79, 0x74, 0x6f, 0x72, 0x63, 0x68, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x11, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x73, 0x22, 0xc1, 0x01, 0x0a, 0x0d, 0x45, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, + 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x64, 0x7a, 0x76, 0x5f, 0x62, + 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x72, 0x64, + 0x7a, 0x76, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x69, 0x6e, + 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x0b, 0x6d, 0x69, 0x6e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x21, 0x0a, 0x0c, + 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x61, 0x78, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, + 0x24, 0x0a, 0x0e, 0x6e, 0x70, 0x72, 0x6f, 0x63, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x6e, 0x6f, 0x64, + 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x6e, 0x70, 0x72, 0x6f, 0x63, 0x50, 0x65, + 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x61, 0x78, + 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x73, 0x22, 0x83, 0x01, 0x0a, 0x1e, 0x44, 0x69, 0x73, + 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x50, 0x79, 0x54, 0x6f, 0x72, 0x63, 0x68, 0x54, + 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x18, 0x0a, 0x07, 0x77, + 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x77, 0x6f, + 0x72, 0x6b, 0x65, 0x72, 0x73, 0x12, 0x47, 0x0a, 0x0e, 0x65, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, + 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0x2e, 0x45, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, + 0x0d, 0x65, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x42, 0xc3, + 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x42, 0x0c, 0x50, 0x79, 0x74, 0x6f, 0x72, 0x63, + 0x68, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, + 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x58, 0xaa, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xca, 0x02, 0x11, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xe2, + 0x02, 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, + 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x50, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_plugins_pytorch_proto_rawDescOnce sync.Once + file_flyteidl2_plugins_pytorch_proto_rawDescData = file_flyteidl2_plugins_pytorch_proto_rawDesc +) + +func file_flyteidl2_plugins_pytorch_proto_rawDescGZIP() []byte { + file_flyteidl2_plugins_pytorch_proto_rawDescOnce.Do(func() { + file_flyteidl2_plugins_pytorch_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_plugins_pytorch_proto_rawDescData) + }) + return file_flyteidl2_plugins_pytorch_proto_rawDescData +} + +var file_flyteidl2_plugins_pytorch_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_flyteidl2_plugins_pytorch_proto_goTypes = []interface{}{ + (*ElasticConfig)(nil), // 0: flyteidl2.plugins.ElasticConfig + (*DistributedPyTorchTrainingTask)(nil), // 1: flyteidl2.plugins.DistributedPyTorchTrainingTask +} +var file_flyteidl2_plugins_pytorch_proto_depIdxs = []int32{ + 0, // 0: flyteidl2.plugins.DistributedPyTorchTrainingTask.elastic_config:type_name -> flyteidl2.plugins.ElasticConfig + 1, // [1:1] is the sub-list for method output_type + 1, // [1:1] is the sub-list for method input_type + 1, // [1:1] is the sub-list for extension type_name + 1, // [1:1] is the sub-list for extension extendee + 0, // [0:1] is the sub-list for field type_name +} + +func init() { file_flyteidl2_plugins_pytorch_proto_init() } +func file_flyteidl2_plugins_pytorch_proto_init() { + if File_flyteidl2_plugins_pytorch_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_plugins_pytorch_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ElasticConfig); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_plugins_pytorch_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DistributedPyTorchTrainingTask); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_plugins_pytorch_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_plugins_pytorch_proto_goTypes, + DependencyIndexes: file_flyteidl2_plugins_pytorch_proto_depIdxs, + MessageInfos: file_flyteidl2_plugins_pytorch_proto_msgTypes, + }.Build() + File_flyteidl2_plugins_pytorch_proto = out.File + file_flyteidl2_plugins_pytorch_proto_rawDesc = nil + file_flyteidl2_plugins_pytorch_proto_goTypes = nil + file_flyteidl2_plugins_pytorch_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/plugins/pytorch.pb.validate.go b/gen/go/flyteidl2/plugins/pytorch.pb.validate.go new file mode 100644 index 0000000000..23b1c837c6 --- /dev/null +++ b/gen/go/flyteidl2/plugins/pytorch.pb.validate.go @@ -0,0 +1,280 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/plugins/pytorch.proto + +package plugins + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on ElasticConfig with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ElasticConfig) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ElasticConfig with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ElasticConfigMultiError, or +// nil if none found. +func (m *ElasticConfig) ValidateAll() error { + return m.validate(true) +} + +func (m *ElasticConfig) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for RdzvBackend + + // no validation rules for MinReplicas + + // no validation rules for MaxReplicas + + // no validation rules for NprocPerNode + + // no validation rules for MaxRestarts + + if len(errors) > 0 { + return ElasticConfigMultiError(errors) + } + + return nil +} + +// ElasticConfigMultiError is an error wrapping multiple validation errors +// returned by ElasticConfig.ValidateAll() if the designated constraints +// aren't met. +type ElasticConfigMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ElasticConfigMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ElasticConfigMultiError) AllErrors() []error { return m } + +// ElasticConfigValidationError is the validation error returned by +// ElasticConfig.Validate if the designated constraints aren't met. +type ElasticConfigValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ElasticConfigValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ElasticConfigValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ElasticConfigValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ElasticConfigValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ElasticConfigValidationError) ErrorName() string { return "ElasticConfigValidationError" } + +// Error satisfies the builtin error interface +func (e ElasticConfigValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sElasticConfig.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ElasticConfigValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ElasticConfigValidationError{} + +// Validate checks the field values on DistributedPyTorchTrainingTask with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *DistributedPyTorchTrainingTask) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DistributedPyTorchTrainingTask with +// the rules defined in the proto definition for this message. If any rules +// are violated, the result is a list of violation errors wrapped in +// DistributedPyTorchTrainingTaskMultiError, or nil if none found. +func (m *DistributedPyTorchTrainingTask) ValidateAll() error { + return m.validate(true) +} + +func (m *DistributedPyTorchTrainingTask) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Workers + + if all { + switch v := interface{}(m.GetElasticConfig()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DistributedPyTorchTrainingTaskValidationError{ + field: "ElasticConfig", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DistributedPyTorchTrainingTaskValidationError{ + field: "ElasticConfig", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetElasticConfig()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DistributedPyTorchTrainingTaskValidationError{ + field: "ElasticConfig", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DistributedPyTorchTrainingTaskMultiError(errors) + } + + return nil +} + +// DistributedPyTorchTrainingTaskMultiError is an error wrapping multiple +// validation errors returned by DistributedPyTorchTrainingTask.ValidateAll() +// if the designated constraints aren't met. +type DistributedPyTorchTrainingTaskMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DistributedPyTorchTrainingTaskMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DistributedPyTorchTrainingTaskMultiError) AllErrors() []error { return m } + +// DistributedPyTorchTrainingTaskValidationError is the validation error +// returned by DistributedPyTorchTrainingTask.Validate if the designated +// constraints aren't met. +type DistributedPyTorchTrainingTaskValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DistributedPyTorchTrainingTaskValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DistributedPyTorchTrainingTaskValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DistributedPyTorchTrainingTaskValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DistributedPyTorchTrainingTaskValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DistributedPyTorchTrainingTaskValidationError) ErrorName() string { + return "DistributedPyTorchTrainingTaskValidationError" +} + +// Error satisfies the builtin error interface +func (e DistributedPyTorchTrainingTaskValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDistributedPyTorchTrainingTask.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DistributedPyTorchTrainingTaskValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DistributedPyTorchTrainingTaskValidationError{} diff --git a/gen/go/flyteidl2/plugins/qubole.pb.go b/gen/go/flyteidl2/plugins/qubole.pb.go new file mode 100644 index 0000000000..fa182c16cf --- /dev/null +++ b/gen/go/flyteidl2/plugins/qubole.pb.go @@ -0,0 +1,346 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/plugins/qubole.proto + +package plugins + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Defines a query to execute on a hive cluster. +type HiveQuery struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Query string `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"` + TimeoutSec uint32 `protobuf:"varint,2,opt,name=timeout_sec,json=timeoutSec,proto3" json:"timeout_sec,omitempty"` + RetryCount uint32 `protobuf:"varint,3,opt,name=retryCount,proto3" json:"retryCount,omitempty"` +} + +func (x *HiveQuery) Reset() { + *x = HiveQuery{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_qubole_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *HiveQuery) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HiveQuery) ProtoMessage() {} + +func (x *HiveQuery) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_qubole_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HiveQuery.ProtoReflect.Descriptor instead. +func (*HiveQuery) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_qubole_proto_rawDescGZIP(), []int{0} +} + +func (x *HiveQuery) GetQuery() string { + if x != nil { + return x.Query + } + return "" +} + +func (x *HiveQuery) GetTimeoutSec() uint32 { + if x != nil { + return x.TimeoutSec + } + return 0 +} + +func (x *HiveQuery) GetRetryCount() uint32 { + if x != nil { + return x.RetryCount + } + return 0 +} + +// Defines a collection of hive queries. +type HiveQueryCollection struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Queries []*HiveQuery `protobuf:"bytes,2,rep,name=queries,proto3" json:"queries,omitempty"` +} + +func (x *HiveQueryCollection) Reset() { + *x = HiveQueryCollection{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_qubole_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *HiveQueryCollection) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HiveQueryCollection) ProtoMessage() {} + +func (x *HiveQueryCollection) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_qubole_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HiveQueryCollection.ProtoReflect.Descriptor instead. +func (*HiveQueryCollection) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_qubole_proto_rawDescGZIP(), []int{1} +} + +func (x *HiveQueryCollection) GetQueries() []*HiveQuery { + if x != nil { + return x.Queries + } + return nil +} + +// This message works with the 'hive' task type in the SDK and is the object that will be in the 'custom' field +// of a hive task's TaskTemplate +type QuboleHiveJob struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ClusterLabel string `protobuf:"bytes,1,opt,name=cluster_label,json=clusterLabel,proto3" json:"cluster_label,omitempty"` + // Deprecated: Marked as deprecated in flyteidl2/plugins/qubole.proto. + QueryCollection *HiveQueryCollection `protobuf:"bytes,2,opt,name=query_collection,json=queryCollection,proto3" json:"query_collection,omitempty"` + Tags []string `protobuf:"bytes,3,rep,name=tags,proto3" json:"tags,omitempty"` + Query *HiveQuery `protobuf:"bytes,4,opt,name=query,proto3" json:"query,omitempty"` +} + +func (x *QuboleHiveJob) Reset() { + *x = QuboleHiveJob{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_qubole_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QuboleHiveJob) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QuboleHiveJob) ProtoMessage() {} + +func (x *QuboleHiveJob) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_qubole_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use QuboleHiveJob.ProtoReflect.Descriptor instead. +func (*QuboleHiveJob) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_qubole_proto_rawDescGZIP(), []int{2} +} + +func (x *QuboleHiveJob) GetClusterLabel() string { + if x != nil { + return x.ClusterLabel + } + return "" +} + +// Deprecated: Marked as deprecated in flyteidl2/plugins/qubole.proto. +func (x *QuboleHiveJob) GetQueryCollection() *HiveQueryCollection { + if x != nil { + return x.QueryCollection + } + return nil +} + +func (x *QuboleHiveJob) GetTags() []string { + if x != nil { + return x.Tags + } + return nil +} + +func (x *QuboleHiveJob) GetQuery() *HiveQuery { + if x != nil { + return x.Query + } + return nil +} + +var File_flyteidl2_plugins_qubole_proto protoreflect.FileDescriptor + +var file_flyteidl2_plugins_qubole_proto_rawDesc = []byte{ + 0x0a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2f, 0x71, 0x75, 0x62, 0x6f, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x12, 0x11, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x22, 0x62, 0x0a, 0x09, 0x48, 0x69, 0x76, 0x65, 0x51, 0x75, 0x65, 0x72, 0x79, + 0x12, 0x14, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, + 0x74, 0x5f, 0x73, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x74, 0x69, 0x6d, + 0x65, 0x6f, 0x75, 0x74, 0x53, 0x65, 0x63, 0x12, 0x1e, 0x0a, 0x0a, 0x72, 0x65, 0x74, 0x72, 0x79, + 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x72, 0x65, 0x74, + 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x4d, 0x0a, 0x13, 0x48, 0x69, 0x76, 0x65, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x36, + 0x0a, 0x07, 0x71, 0x75, 0x65, 0x72, 0x69, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2e, 0x48, 0x69, 0x76, 0x65, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x07, 0x71, + 0x75, 0x65, 0x72, 0x69, 0x65, 0x73, 0x22, 0xd3, 0x01, 0x0a, 0x0d, 0x51, 0x75, 0x62, 0x6f, 0x6c, + 0x65, 0x48, 0x69, 0x76, 0x65, 0x4a, 0x6f, 0x62, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0c, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x55, 0x0a, + 0x10, 0x71, 0x75, 0x65, 0x72, 0x79, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x48, 0x69, 0x76, 0x65, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x42, + 0x02, 0x18, 0x01, 0x52, 0x0f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x61, 0x67, 0x73, 0x18, 0x03, 0x20, 0x03, + 0x28, 0x09, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, 0x12, 0x32, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x72, + 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x48, 0x69, 0x76, 0x65, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x42, 0xc2, 0x01, 0x0a, + 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x42, 0x0b, 0x51, 0x75, 0x62, 0x6f, 0x6c, 0x65, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xa2, 0x02, + 0x03, 0x46, 0x50, 0x58, 0xaa, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xca, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xe2, 0x02, 0x1d, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x12, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_plugins_qubole_proto_rawDescOnce sync.Once + file_flyteidl2_plugins_qubole_proto_rawDescData = file_flyteidl2_plugins_qubole_proto_rawDesc +) + +func file_flyteidl2_plugins_qubole_proto_rawDescGZIP() []byte { + file_flyteidl2_plugins_qubole_proto_rawDescOnce.Do(func() { + file_flyteidl2_plugins_qubole_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_plugins_qubole_proto_rawDescData) + }) + return file_flyteidl2_plugins_qubole_proto_rawDescData +} + +var file_flyteidl2_plugins_qubole_proto_msgTypes = make([]protoimpl.MessageInfo, 3) +var file_flyteidl2_plugins_qubole_proto_goTypes = []interface{}{ + (*HiveQuery)(nil), // 0: flyteidl2.plugins.HiveQuery + (*HiveQueryCollection)(nil), // 1: flyteidl2.plugins.HiveQueryCollection + (*QuboleHiveJob)(nil), // 2: flyteidl2.plugins.QuboleHiveJob +} +var file_flyteidl2_plugins_qubole_proto_depIdxs = []int32{ + 0, // 0: flyteidl2.plugins.HiveQueryCollection.queries:type_name -> flyteidl2.plugins.HiveQuery + 1, // 1: flyteidl2.plugins.QuboleHiveJob.query_collection:type_name -> flyteidl2.plugins.HiveQueryCollection + 0, // 2: flyteidl2.plugins.QuboleHiveJob.query:type_name -> flyteidl2.plugins.HiveQuery + 3, // [3:3] is the sub-list for method output_type + 3, // [3:3] is the sub-list for method input_type + 3, // [3:3] is the sub-list for extension type_name + 3, // [3:3] is the sub-list for extension extendee + 0, // [0:3] is the sub-list for field type_name +} + +func init() { file_flyteidl2_plugins_qubole_proto_init() } +func file_flyteidl2_plugins_qubole_proto_init() { + if File_flyteidl2_plugins_qubole_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_plugins_qubole_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*HiveQuery); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_plugins_qubole_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*HiveQueryCollection); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_plugins_qubole_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QuboleHiveJob); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_plugins_qubole_proto_rawDesc, + NumEnums: 0, + NumMessages: 3, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_plugins_qubole_proto_goTypes, + DependencyIndexes: file_flyteidl2_plugins_qubole_proto_depIdxs, + MessageInfos: file_flyteidl2_plugins_qubole_proto_msgTypes, + }.Build() + File_flyteidl2_plugins_qubole_proto = out.File + file_flyteidl2_plugins_qubole_proto_rawDesc = nil + file_flyteidl2_plugins_qubole_proto_goTypes = nil + file_flyteidl2_plugins_qubole_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/plugins/qubole.pb.validate.go b/gen/go/flyteidl2/plugins/qubole.pb.validate.go new file mode 100644 index 0000000000..aaf7ffbc51 --- /dev/null +++ b/gen/go/flyteidl2/plugins/qubole.pb.validate.go @@ -0,0 +1,437 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/plugins/qubole.proto + +package plugins + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on HiveQuery with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *HiveQuery) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on HiveQuery with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in HiveQueryMultiError, or nil +// if none found. +func (m *HiveQuery) ValidateAll() error { + return m.validate(true) +} + +func (m *HiveQuery) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Query + + // no validation rules for TimeoutSec + + // no validation rules for RetryCount + + if len(errors) > 0 { + return HiveQueryMultiError(errors) + } + + return nil +} + +// HiveQueryMultiError is an error wrapping multiple validation errors returned +// by HiveQuery.ValidateAll() if the designated constraints aren't met. +type HiveQueryMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m HiveQueryMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m HiveQueryMultiError) AllErrors() []error { return m } + +// HiveQueryValidationError is the validation error returned by +// HiveQuery.Validate if the designated constraints aren't met. +type HiveQueryValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e HiveQueryValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e HiveQueryValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e HiveQueryValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e HiveQueryValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e HiveQueryValidationError) ErrorName() string { return "HiveQueryValidationError" } + +// Error satisfies the builtin error interface +func (e HiveQueryValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sHiveQuery.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = HiveQueryValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = HiveQueryValidationError{} + +// Validate checks the field values on HiveQueryCollection with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *HiveQueryCollection) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on HiveQueryCollection with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// HiveQueryCollectionMultiError, or nil if none found. +func (m *HiveQueryCollection) ValidateAll() error { + return m.validate(true) +} + +func (m *HiveQueryCollection) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetQueries() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, HiveQueryCollectionValidationError{ + field: fmt.Sprintf("Queries[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, HiveQueryCollectionValidationError{ + field: fmt.Sprintf("Queries[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return HiveQueryCollectionValidationError{ + field: fmt.Sprintf("Queries[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return HiveQueryCollectionMultiError(errors) + } + + return nil +} + +// HiveQueryCollectionMultiError is an error wrapping multiple validation +// errors returned by HiveQueryCollection.ValidateAll() if the designated +// constraints aren't met. +type HiveQueryCollectionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m HiveQueryCollectionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m HiveQueryCollectionMultiError) AllErrors() []error { return m } + +// HiveQueryCollectionValidationError is the validation error returned by +// HiveQueryCollection.Validate if the designated constraints aren't met. +type HiveQueryCollectionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e HiveQueryCollectionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e HiveQueryCollectionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e HiveQueryCollectionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e HiveQueryCollectionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e HiveQueryCollectionValidationError) ErrorName() string { + return "HiveQueryCollectionValidationError" +} + +// Error satisfies the builtin error interface +func (e HiveQueryCollectionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sHiveQueryCollection.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = HiveQueryCollectionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = HiveQueryCollectionValidationError{} + +// Validate checks the field values on QuboleHiveJob with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *QuboleHiveJob) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on QuboleHiveJob with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in QuboleHiveJobMultiError, or +// nil if none found. +func (m *QuboleHiveJob) ValidateAll() error { + return m.validate(true) +} + +func (m *QuboleHiveJob) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ClusterLabel + + if all { + switch v := interface{}(m.GetQueryCollection()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, QuboleHiveJobValidationError{ + field: "QueryCollection", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, QuboleHiveJobValidationError{ + field: "QueryCollection", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetQueryCollection()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return QuboleHiveJobValidationError{ + field: "QueryCollection", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetQuery()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, QuboleHiveJobValidationError{ + field: "Query", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, QuboleHiveJobValidationError{ + field: "Query", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetQuery()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return QuboleHiveJobValidationError{ + field: "Query", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return QuboleHiveJobMultiError(errors) + } + + return nil +} + +// QuboleHiveJobMultiError is an error wrapping multiple validation errors +// returned by QuboleHiveJob.ValidateAll() if the designated constraints +// aren't met. +type QuboleHiveJobMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m QuboleHiveJobMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m QuboleHiveJobMultiError) AllErrors() []error { return m } + +// QuboleHiveJobValidationError is the validation error returned by +// QuboleHiveJob.Validate if the designated constraints aren't met. +type QuboleHiveJobValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e QuboleHiveJobValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e QuboleHiveJobValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e QuboleHiveJobValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e QuboleHiveJobValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e QuboleHiveJobValidationError) ErrorName() string { return "QuboleHiveJobValidationError" } + +// Error satisfies the builtin error interface +func (e QuboleHiveJobValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sQuboleHiveJob.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = QuboleHiveJobValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = QuboleHiveJobValidationError{} diff --git a/gen/go/flyteidl2/plugins/ray.pb.go b/gen/go/flyteidl2/plugins/ray.pb.go new file mode 100644 index 0000000000..cc1ce572eb --- /dev/null +++ b/gen/go/flyteidl2/plugins/ray.pb.go @@ -0,0 +1,536 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/plugins/ray.proto + +package plugins + +import ( + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// RayJobSpec defines the desired state of RayJob +type RayJob struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // RayClusterSpec is the cluster template to run the job + RayCluster *RayCluster `protobuf:"bytes,1,opt,name=ray_cluster,json=rayCluster,proto3" json:"ray_cluster,omitempty"` + // runtime_env is base64 encoded. + // Ray runtime environments: https://docs.ray.io/en/latest/ray-core/handling-dependencies.html#runtime-environments + // + // Deprecated: Marked as deprecated in flyteidl2/plugins/ray.proto. + RuntimeEnv string `protobuf:"bytes,2,opt,name=runtime_env,json=runtimeEnv,proto3" json:"runtime_env,omitempty"` + // shutdown_after_job_finishes specifies whether the RayCluster should be deleted after the RayJob finishes. + ShutdownAfterJobFinishes bool `protobuf:"varint,3,opt,name=shutdown_after_job_finishes,json=shutdownAfterJobFinishes,proto3" json:"shutdown_after_job_finishes,omitempty"` + // ttl_seconds_after_finished specifies the number of seconds after which the RayCluster will be deleted after the RayJob finishes. + TtlSecondsAfterFinished int32 `protobuf:"varint,4,opt,name=ttl_seconds_after_finished,json=ttlSecondsAfterFinished,proto3" json:"ttl_seconds_after_finished,omitempty"` + // RuntimeEnvYAML represents the runtime environment configuration + // provided as a multi-line YAML string. + RuntimeEnvYaml string `protobuf:"bytes,5,opt,name=runtime_env_yaml,json=runtimeEnvYaml,proto3" json:"runtime_env_yaml,omitempty"` +} + +func (x *RayJob) Reset() { + *x = RayJob{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_ray_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RayJob) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RayJob) ProtoMessage() {} + +func (x *RayJob) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_ray_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RayJob.ProtoReflect.Descriptor instead. +func (*RayJob) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_ray_proto_rawDescGZIP(), []int{0} +} + +func (x *RayJob) GetRayCluster() *RayCluster { + if x != nil { + return x.RayCluster + } + return nil +} + +// Deprecated: Marked as deprecated in flyteidl2/plugins/ray.proto. +func (x *RayJob) GetRuntimeEnv() string { + if x != nil { + return x.RuntimeEnv + } + return "" +} + +func (x *RayJob) GetShutdownAfterJobFinishes() bool { + if x != nil { + return x.ShutdownAfterJobFinishes + } + return false +} + +func (x *RayJob) GetTtlSecondsAfterFinished() int32 { + if x != nil { + return x.TtlSecondsAfterFinished + } + return 0 +} + +func (x *RayJob) GetRuntimeEnvYaml() string { + if x != nil { + return x.RuntimeEnvYaml + } + return "" +} + +// Define Ray cluster defines the desired state of RayCluster +type RayCluster struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // HeadGroupSpecs are the spec for the head pod + HeadGroupSpec *HeadGroupSpec `protobuf:"bytes,1,opt,name=head_group_spec,json=headGroupSpec,proto3" json:"head_group_spec,omitempty"` + // WorkerGroupSpecs are the specs for the worker pods + WorkerGroupSpec []*WorkerGroupSpec `protobuf:"bytes,2,rep,name=worker_group_spec,json=workerGroupSpec,proto3" json:"worker_group_spec,omitempty"` + // Whether to enable autoscaling. + EnableAutoscaling bool `protobuf:"varint,3,opt,name=enable_autoscaling,json=enableAutoscaling,proto3" json:"enable_autoscaling,omitempty"` +} + +func (x *RayCluster) Reset() { + *x = RayCluster{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_ray_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RayCluster) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RayCluster) ProtoMessage() {} + +func (x *RayCluster) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_ray_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RayCluster.ProtoReflect.Descriptor instead. +func (*RayCluster) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_ray_proto_rawDescGZIP(), []int{1} +} + +func (x *RayCluster) GetHeadGroupSpec() *HeadGroupSpec { + if x != nil { + return x.HeadGroupSpec + } + return nil +} + +func (x *RayCluster) GetWorkerGroupSpec() []*WorkerGroupSpec { + if x != nil { + return x.WorkerGroupSpec + } + return nil +} + +func (x *RayCluster) GetEnableAutoscaling() bool { + if x != nil { + return x.EnableAutoscaling + } + return false +} + +// HeadGroupSpec are the spec for the head pod +type HeadGroupSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Optional. RayStartParams are the params of the start command: address, object-store-memory. + // Refer to https://docs.ray.io/en/latest/ray-core/package-ref.html#ray-start + RayStartParams map[string]string `protobuf:"bytes,1,rep,name=ray_start_params,json=rayStartParams,proto3" json:"ray_start_params,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // Pod Spec for the ray head pod + K8SPod *core.K8SPod `protobuf:"bytes,2,opt,name=k8s_pod,json=k8sPod,proto3" json:"k8s_pod,omitempty"` +} + +func (x *HeadGroupSpec) Reset() { + *x = HeadGroupSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_ray_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *HeadGroupSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HeadGroupSpec) ProtoMessage() {} + +func (x *HeadGroupSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_ray_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HeadGroupSpec.ProtoReflect.Descriptor instead. +func (*HeadGroupSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_ray_proto_rawDescGZIP(), []int{2} +} + +func (x *HeadGroupSpec) GetRayStartParams() map[string]string { + if x != nil { + return x.RayStartParams + } + return nil +} + +func (x *HeadGroupSpec) GetK8SPod() *core.K8SPod { + if x != nil { + return x.K8SPod + } + return nil +} + +// WorkerGroupSpec are the specs for the worker pods +type WorkerGroupSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Required. RayCluster can have multiple worker groups, and it distinguishes them by name + GroupName string `protobuf:"bytes,1,opt,name=group_name,json=groupName,proto3" json:"group_name,omitempty"` + // Required. Desired replicas of the worker group. Defaults to 1. + Replicas int32 `protobuf:"varint,2,opt,name=replicas,proto3" json:"replicas,omitempty"` + // Optional. Min replicas of the worker group. MinReplicas defaults to 1. + MinReplicas int32 `protobuf:"varint,3,opt,name=min_replicas,json=minReplicas,proto3" json:"min_replicas,omitempty"` + // Optional. Max replicas of the worker group. MaxReplicas defaults to maxInt32 + MaxReplicas int32 `protobuf:"varint,4,opt,name=max_replicas,json=maxReplicas,proto3" json:"max_replicas,omitempty"` + // Optional. RayStartParams are the params of the start command: address, object-store-memory. + // Refer to https://docs.ray.io/en/latest/ray-core/package-ref.html#ray-start + RayStartParams map[string]string `protobuf:"bytes,5,rep,name=ray_start_params,json=rayStartParams,proto3" json:"ray_start_params,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // Pod Spec for ray worker pods + K8SPod *core.K8SPod `protobuf:"bytes,6,opt,name=k8s_pod,json=k8sPod,proto3" json:"k8s_pod,omitempty"` +} + +func (x *WorkerGroupSpec) Reset() { + *x = WorkerGroupSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_ray_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WorkerGroupSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorkerGroupSpec) ProtoMessage() {} + +func (x *WorkerGroupSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_ray_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorkerGroupSpec.ProtoReflect.Descriptor instead. +func (*WorkerGroupSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_ray_proto_rawDescGZIP(), []int{3} +} + +func (x *WorkerGroupSpec) GetGroupName() string { + if x != nil { + return x.GroupName + } + return "" +} + +func (x *WorkerGroupSpec) GetReplicas() int32 { + if x != nil { + return x.Replicas + } + return 0 +} + +func (x *WorkerGroupSpec) GetMinReplicas() int32 { + if x != nil { + return x.MinReplicas + } + return 0 +} + +func (x *WorkerGroupSpec) GetMaxReplicas() int32 { + if x != nil { + return x.MaxReplicas + } + return 0 +} + +func (x *WorkerGroupSpec) GetRayStartParams() map[string]string { + if x != nil { + return x.RayStartParams + } + return nil +} + +func (x *WorkerGroupSpec) GetK8SPod() *core.K8SPod { + if x != nil { + return x.K8SPod + } + return nil +} + +var File_flyteidl2_plugins_ray_proto protoreflect.FileDescriptor + +var file_flyteidl2_plugins_ray_proto_rawDesc = []byte{ + 0x0a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2f, 0x72, 0x61, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x93, 0x02, 0x0a, + 0x06, 0x52, 0x61, 0x79, 0x4a, 0x6f, 0x62, 0x12, 0x3e, 0x0a, 0x0b, 0x72, 0x61, 0x79, 0x5f, 0x63, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0x2e, 0x52, 0x61, 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x0a, 0x72, 0x61, 0x79, + 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, 0x23, 0x0a, 0x0b, 0x72, 0x75, 0x6e, 0x74, 0x69, + 0x6d, 0x65, 0x5f, 0x65, 0x6e, 0x76, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, + 0x52, 0x0a, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x45, 0x6e, 0x76, 0x12, 0x3d, 0x0a, 0x1b, + 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x5f, 0x61, 0x66, 0x74, 0x65, 0x72, 0x5f, 0x6a, + 0x6f, 0x62, 0x5f, 0x66, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x18, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x41, 0x66, 0x74, 0x65, 0x72, + 0x4a, 0x6f, 0x62, 0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x73, 0x12, 0x3b, 0x0a, 0x1a, 0x74, + 0x74, 0x6c, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x5f, 0x61, 0x66, 0x74, 0x65, 0x72, + 0x5f, 0x66, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x17, 0x74, 0x74, 0x6c, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x41, 0x66, 0x74, 0x65, 0x72, + 0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x12, 0x28, 0x0a, 0x10, 0x72, 0x75, 0x6e, 0x74, + 0x69, 0x6d, 0x65, 0x5f, 0x65, 0x6e, 0x76, 0x5f, 0x79, 0x61, 0x6d, 0x6c, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x45, 0x6e, 0x76, 0x59, 0x61, + 0x6d, 0x6c, 0x22, 0xd5, 0x01, 0x0a, 0x0a, 0x52, 0x61, 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x12, 0x48, 0x0a, 0x0f, 0x68, 0x65, 0x61, 0x64, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, + 0x73, 0x70, 0x65, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x48, + 0x65, 0x61, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0d, 0x68, 0x65, + 0x61, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x70, 0x65, 0x63, 0x12, 0x4e, 0x0a, 0x11, 0x77, + 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x73, 0x70, 0x65, 0x63, + 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x65, + 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0f, 0x77, 0x6f, 0x72, 0x6b, + 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x70, 0x65, 0x63, 0x12, 0x2d, 0x0a, 0x12, 0x65, + 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x61, 0x75, 0x74, 0x6f, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, + 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x11, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x41, + 0x75, 0x74, 0x6f, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x22, 0xe3, 0x01, 0x0a, 0x0d, 0x48, + 0x65, 0x61, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x70, 0x65, 0x63, 0x12, 0x5e, 0x0a, 0x10, + 0x72, 0x61, 0x79, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x53, 0x70, 0x65, 0x63, 0x2e, 0x52, 0x61, 0x79, 0x53, 0x74, 0x61, 0x72, + 0x74, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x72, 0x61, + 0x79, 0x53, 0x74, 0x61, 0x72, 0x74, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x2f, 0x0a, 0x07, + 0x6b, 0x38, 0x73, 0x5f, 0x70, 0x6f, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, + 0x38, 0x73, 0x50, 0x6f, 0x64, 0x52, 0x06, 0x6b, 0x38, 0x73, 0x50, 0x6f, 0x64, 0x1a, 0x41, 0x0a, + 0x13, 0x52, 0x61, 0x79, 0x53, 0x74, 0x61, 0x72, 0x74, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, + 0x22, 0xe8, 0x02, 0x0a, 0x0f, 0x57, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x53, 0x70, 0x65, 0x63, 0x12, 0x1d, 0x0a, 0x0a, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4e, + 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, + 0x21, 0x0a, 0x0c, 0x6d, 0x69, 0x6e, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x69, 0x6e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x61, 0x78, 0x52, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x60, 0x0a, 0x10, 0x72, 0x61, 0x79, 0x5f, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x36, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, + 0x70, 0x65, 0x63, 0x2e, 0x52, 0x61, 0x79, 0x53, 0x74, 0x61, 0x72, 0x74, 0x50, 0x61, 0x72, 0x61, + 0x6d, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x72, 0x61, 0x79, 0x53, 0x74, 0x61, 0x72, + 0x74, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x2f, 0x0a, 0x07, 0x6b, 0x38, 0x73, 0x5f, 0x70, + 0x6f, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x38, 0x73, 0x50, 0x6f, 0x64, + 0x52, 0x06, 0x6b, 0x38, 0x73, 0x50, 0x6f, 0x64, 0x1a, 0x41, 0x0a, 0x13, 0x52, 0x61, 0x79, 0x53, + 0x74, 0x61, 0x72, 0x74, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, + 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, + 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0xbf, 0x01, 0x0a, 0x15, + 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x73, 0x42, 0x08, 0x52, 0x61, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, + 0x02, 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, + 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x58, + 0xaa, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x73, 0xca, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xe2, 0x02, 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x47, 0x50, 0x42, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x62, 0x06, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_plugins_ray_proto_rawDescOnce sync.Once + file_flyteidl2_plugins_ray_proto_rawDescData = file_flyteidl2_plugins_ray_proto_rawDesc +) + +func file_flyteidl2_plugins_ray_proto_rawDescGZIP() []byte { + file_flyteidl2_plugins_ray_proto_rawDescOnce.Do(func() { + file_flyteidl2_plugins_ray_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_plugins_ray_proto_rawDescData) + }) + return file_flyteidl2_plugins_ray_proto_rawDescData +} + +var file_flyteidl2_plugins_ray_proto_msgTypes = make([]protoimpl.MessageInfo, 6) +var file_flyteidl2_plugins_ray_proto_goTypes = []interface{}{ + (*RayJob)(nil), // 0: flyteidl2.plugins.RayJob + (*RayCluster)(nil), // 1: flyteidl2.plugins.RayCluster + (*HeadGroupSpec)(nil), // 2: flyteidl2.plugins.HeadGroupSpec + (*WorkerGroupSpec)(nil), // 3: flyteidl2.plugins.WorkerGroupSpec + nil, // 4: flyteidl2.plugins.HeadGroupSpec.RayStartParamsEntry + nil, // 5: flyteidl2.plugins.WorkerGroupSpec.RayStartParamsEntry + (*core.K8SPod)(nil), // 6: flyteidl2.core.K8sPod +} +var file_flyteidl2_plugins_ray_proto_depIdxs = []int32{ + 1, // 0: flyteidl2.plugins.RayJob.ray_cluster:type_name -> flyteidl2.plugins.RayCluster + 2, // 1: flyteidl2.plugins.RayCluster.head_group_spec:type_name -> flyteidl2.plugins.HeadGroupSpec + 3, // 2: flyteidl2.plugins.RayCluster.worker_group_spec:type_name -> flyteidl2.plugins.WorkerGroupSpec + 4, // 3: flyteidl2.plugins.HeadGroupSpec.ray_start_params:type_name -> flyteidl2.plugins.HeadGroupSpec.RayStartParamsEntry + 6, // 4: flyteidl2.plugins.HeadGroupSpec.k8s_pod:type_name -> flyteidl2.core.K8sPod + 5, // 5: flyteidl2.plugins.WorkerGroupSpec.ray_start_params:type_name -> flyteidl2.plugins.WorkerGroupSpec.RayStartParamsEntry + 6, // 6: flyteidl2.plugins.WorkerGroupSpec.k8s_pod:type_name -> flyteidl2.core.K8sPod + 7, // [7:7] is the sub-list for method output_type + 7, // [7:7] is the sub-list for method input_type + 7, // [7:7] is the sub-list for extension type_name + 7, // [7:7] is the sub-list for extension extendee + 0, // [0:7] is the sub-list for field type_name +} + +func init() { file_flyteidl2_plugins_ray_proto_init() } +func file_flyteidl2_plugins_ray_proto_init() { + if File_flyteidl2_plugins_ray_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_plugins_ray_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RayJob); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_plugins_ray_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RayCluster); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_plugins_ray_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*HeadGroupSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_plugins_ray_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WorkerGroupSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_plugins_ray_proto_rawDesc, + NumEnums: 0, + NumMessages: 6, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_plugins_ray_proto_goTypes, + DependencyIndexes: file_flyteidl2_plugins_ray_proto_depIdxs, + MessageInfos: file_flyteidl2_plugins_ray_proto_msgTypes, + }.Build() + File_flyteidl2_plugins_ray_proto = out.File + file_flyteidl2_plugins_ray_proto_rawDesc = nil + file_flyteidl2_plugins_ray_proto_goTypes = nil + file_flyteidl2_plugins_ray_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/plugins/ray.pb.validate.go b/gen/go/flyteidl2/plugins/ray.pb.validate.go new file mode 100644 index 0000000000..3b8b7fb794 --- /dev/null +++ b/gen/go/flyteidl2/plugins/ray.pb.validate.go @@ -0,0 +1,605 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/plugins/ray.proto + +package plugins + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on RayJob with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *RayJob) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on RayJob with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in RayJobMultiError, or nil if none found. +func (m *RayJob) ValidateAll() error { + return m.validate(true) +} + +func (m *RayJob) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRayCluster()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, RayJobValidationError{ + field: "RayCluster", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, RayJobValidationError{ + field: "RayCluster", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRayCluster()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return RayJobValidationError{ + field: "RayCluster", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for RuntimeEnv + + // no validation rules for ShutdownAfterJobFinishes + + // no validation rules for TtlSecondsAfterFinished + + // no validation rules for RuntimeEnvYaml + + if len(errors) > 0 { + return RayJobMultiError(errors) + } + + return nil +} + +// RayJobMultiError is an error wrapping multiple validation errors returned by +// RayJob.ValidateAll() if the designated constraints aren't met. +type RayJobMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m RayJobMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m RayJobMultiError) AllErrors() []error { return m } + +// RayJobValidationError is the validation error returned by RayJob.Validate if +// the designated constraints aren't met. +type RayJobValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e RayJobValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e RayJobValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e RayJobValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e RayJobValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e RayJobValidationError) ErrorName() string { return "RayJobValidationError" } + +// Error satisfies the builtin error interface +func (e RayJobValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sRayJob.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = RayJobValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = RayJobValidationError{} + +// Validate checks the field values on RayCluster with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *RayCluster) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on RayCluster with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in RayClusterMultiError, or +// nil if none found. +func (m *RayCluster) ValidateAll() error { + return m.validate(true) +} + +func (m *RayCluster) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetHeadGroupSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, RayClusterValidationError{ + field: "HeadGroupSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, RayClusterValidationError{ + field: "HeadGroupSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetHeadGroupSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return RayClusterValidationError{ + field: "HeadGroupSpec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetWorkerGroupSpec() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, RayClusterValidationError{ + field: fmt.Sprintf("WorkerGroupSpec[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, RayClusterValidationError{ + field: fmt.Sprintf("WorkerGroupSpec[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return RayClusterValidationError{ + field: fmt.Sprintf("WorkerGroupSpec[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for EnableAutoscaling + + if len(errors) > 0 { + return RayClusterMultiError(errors) + } + + return nil +} + +// RayClusterMultiError is an error wrapping multiple validation errors +// returned by RayCluster.ValidateAll() if the designated constraints aren't met. +type RayClusterMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m RayClusterMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m RayClusterMultiError) AllErrors() []error { return m } + +// RayClusterValidationError is the validation error returned by +// RayCluster.Validate if the designated constraints aren't met. +type RayClusterValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e RayClusterValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e RayClusterValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e RayClusterValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e RayClusterValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e RayClusterValidationError) ErrorName() string { return "RayClusterValidationError" } + +// Error satisfies the builtin error interface +func (e RayClusterValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sRayCluster.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = RayClusterValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = RayClusterValidationError{} + +// Validate checks the field values on HeadGroupSpec with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *HeadGroupSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on HeadGroupSpec with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in HeadGroupSpecMultiError, or +// nil if none found. +func (m *HeadGroupSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *HeadGroupSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for RayStartParams + + if all { + switch v := interface{}(m.GetK8SPod()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, HeadGroupSpecValidationError{ + field: "K8SPod", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, HeadGroupSpecValidationError{ + field: "K8SPod", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetK8SPod()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return HeadGroupSpecValidationError{ + field: "K8SPod", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return HeadGroupSpecMultiError(errors) + } + + return nil +} + +// HeadGroupSpecMultiError is an error wrapping multiple validation errors +// returned by HeadGroupSpec.ValidateAll() if the designated constraints +// aren't met. +type HeadGroupSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m HeadGroupSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m HeadGroupSpecMultiError) AllErrors() []error { return m } + +// HeadGroupSpecValidationError is the validation error returned by +// HeadGroupSpec.Validate if the designated constraints aren't met. +type HeadGroupSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e HeadGroupSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e HeadGroupSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e HeadGroupSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e HeadGroupSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e HeadGroupSpecValidationError) ErrorName() string { return "HeadGroupSpecValidationError" } + +// Error satisfies the builtin error interface +func (e HeadGroupSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sHeadGroupSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = HeadGroupSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = HeadGroupSpecValidationError{} + +// Validate checks the field values on WorkerGroupSpec with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *WorkerGroupSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WorkerGroupSpec with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// WorkerGroupSpecMultiError, or nil if none found. +func (m *WorkerGroupSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *WorkerGroupSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for GroupName + + // no validation rules for Replicas + + // no validation rules for MinReplicas + + // no validation rules for MaxReplicas + + // no validation rules for RayStartParams + + if all { + switch v := interface{}(m.GetK8SPod()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WorkerGroupSpecValidationError{ + field: "K8SPod", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WorkerGroupSpecValidationError{ + field: "K8SPod", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetK8SPod()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WorkerGroupSpecValidationError{ + field: "K8SPod", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return WorkerGroupSpecMultiError(errors) + } + + return nil +} + +// WorkerGroupSpecMultiError is an error wrapping multiple validation errors +// returned by WorkerGroupSpec.ValidateAll() if the designated constraints +// aren't met. +type WorkerGroupSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WorkerGroupSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WorkerGroupSpecMultiError) AllErrors() []error { return m } + +// WorkerGroupSpecValidationError is the validation error returned by +// WorkerGroupSpec.Validate if the designated constraints aren't met. +type WorkerGroupSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WorkerGroupSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WorkerGroupSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WorkerGroupSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WorkerGroupSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WorkerGroupSpecValidationError) ErrorName() string { return "WorkerGroupSpecValidationError" } + +// Error satisfies the builtin error interface +func (e WorkerGroupSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWorkerGroupSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WorkerGroupSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WorkerGroupSpecValidationError{} diff --git a/gen/go/flyteidl2/plugins/spark.pb.go b/gen/go/flyteidl2/plugins/spark.pb.go new file mode 100644 index 0000000000..d129c3f214 --- /dev/null +++ b/gen/go/flyteidl2/plugins/spark.pb.go @@ -0,0 +1,414 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/plugins/spark.proto + +package plugins + +import ( + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + structpb "google.golang.org/protobuf/types/known/structpb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type SparkApplication_Type int32 + +const ( + SparkApplication_PYTHON SparkApplication_Type = 0 + SparkApplication_JAVA SparkApplication_Type = 1 + SparkApplication_SCALA SparkApplication_Type = 2 + SparkApplication_R SparkApplication_Type = 3 +) + +// Enum value maps for SparkApplication_Type. +var ( + SparkApplication_Type_name = map[int32]string{ + 0: "PYTHON", + 1: "JAVA", + 2: "SCALA", + 3: "R", + } + SparkApplication_Type_value = map[string]int32{ + "PYTHON": 0, + "JAVA": 1, + "SCALA": 2, + "R": 3, + } +) + +func (x SparkApplication_Type) Enum() *SparkApplication_Type { + p := new(SparkApplication_Type) + *p = x + return p +} + +func (x SparkApplication_Type) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (SparkApplication_Type) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_plugins_spark_proto_enumTypes[0].Descriptor() +} + +func (SparkApplication_Type) Type() protoreflect.EnumType { + return &file_flyteidl2_plugins_spark_proto_enumTypes[0] +} + +func (x SparkApplication_Type) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use SparkApplication_Type.Descriptor instead. +func (SparkApplication_Type) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_plugins_spark_proto_rawDescGZIP(), []int{0, 0} +} + +type SparkApplication struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *SparkApplication) Reset() { + *x = SparkApplication{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_spark_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SparkApplication) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SparkApplication) ProtoMessage() {} + +func (x *SparkApplication) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_spark_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SparkApplication.ProtoReflect.Descriptor instead. +func (*SparkApplication) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_spark_proto_rawDescGZIP(), []int{0} +} + +// Custom Proto for Spark Plugin. +type SparkJob struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ApplicationType SparkApplication_Type `protobuf:"varint,1,opt,name=applicationType,proto3,enum=flyteidl2.plugins.SparkApplication_Type" json:"applicationType,omitempty"` + MainApplicationFile string `protobuf:"bytes,2,opt,name=mainApplicationFile,proto3" json:"mainApplicationFile,omitempty"` + MainClass string `protobuf:"bytes,3,opt,name=mainClass,proto3" json:"mainClass,omitempty"` + SparkConf map[string]string `protobuf:"bytes,4,rep,name=sparkConf,proto3" json:"sparkConf,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + HadoopConf map[string]string `protobuf:"bytes,5,rep,name=hadoopConf,proto3" json:"hadoopConf,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + ExecutorPath string `protobuf:"bytes,6,opt,name=executorPath,proto3" json:"executorPath,omitempty"` // Executor path for Python jobs. + // Databricks job configuration. + // Config structure can be found here. https://docs.databricks.com/dev-tools/api/2.0/jobs.html#request-structure. + DatabricksConf *structpb.Struct `protobuf:"bytes,7,opt,name=databricksConf,proto3" json:"databricksConf,omitempty"` + // Databricks access token. https://docs.databricks.com/dev-tools/api/latest/authentication.html + // This token can be set in either flytepropeller or flytekit. + DatabricksToken string `protobuf:"bytes,8,opt,name=databricksToken,proto3" json:"databricksToken,omitempty"` + // Domain name of your deployment. Use the form .cloud.databricks.com. + // This instance name can be set in either flytepropeller or flytekit. + DatabricksInstance string `protobuf:"bytes,9,opt,name=databricksInstance,proto3" json:"databricksInstance,omitempty"` + // Pod Spec for the Spark driver pod + DriverPod *core.K8SPod `protobuf:"bytes,10,opt,name=driverPod,proto3" json:"driverPod,omitempty"` + // Pod Spec for the Spark executor pod + ExecutorPod *core.K8SPod `protobuf:"bytes,11,opt,name=executorPod,proto3" json:"executorPod,omitempty"` +} + +func (x *SparkJob) Reset() { + *x = SparkJob{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_spark_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SparkJob) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SparkJob) ProtoMessage() {} + +func (x *SparkJob) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_spark_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SparkJob.ProtoReflect.Descriptor instead. +func (*SparkJob) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_spark_proto_rawDescGZIP(), []int{1} +} + +func (x *SparkJob) GetApplicationType() SparkApplication_Type { + if x != nil { + return x.ApplicationType + } + return SparkApplication_PYTHON +} + +func (x *SparkJob) GetMainApplicationFile() string { + if x != nil { + return x.MainApplicationFile + } + return "" +} + +func (x *SparkJob) GetMainClass() string { + if x != nil { + return x.MainClass + } + return "" +} + +func (x *SparkJob) GetSparkConf() map[string]string { + if x != nil { + return x.SparkConf + } + return nil +} + +func (x *SparkJob) GetHadoopConf() map[string]string { + if x != nil { + return x.HadoopConf + } + return nil +} + +func (x *SparkJob) GetExecutorPath() string { + if x != nil { + return x.ExecutorPath + } + return "" +} + +func (x *SparkJob) GetDatabricksConf() *structpb.Struct { + if x != nil { + return x.DatabricksConf + } + return nil +} + +func (x *SparkJob) GetDatabricksToken() string { + if x != nil { + return x.DatabricksToken + } + return "" +} + +func (x *SparkJob) GetDatabricksInstance() string { + if x != nil { + return x.DatabricksInstance + } + return "" +} + +func (x *SparkJob) GetDriverPod() *core.K8SPod { + if x != nil { + return x.DriverPod + } + return nil +} + +func (x *SparkJob) GetExecutorPod() *core.K8SPod { + if x != nil { + return x.ExecutorPod + } + return nil +} + +var File_flyteidl2_plugins_spark_proto protoreflect.FileDescriptor + +var file_flyteidl2_plugins_spark_proto_rawDesc = []byte{ + 0x0a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2f, 0x73, 0x70, 0x61, 0x72, 0x6b, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, + 0x11, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x73, 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, + 0x72, 0x65, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, + 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x42, 0x0a, 0x10, + 0x53, 0x70, 0x61, 0x72, 0x6b, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x22, 0x2e, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0a, 0x0a, 0x06, 0x50, 0x59, 0x54, 0x48, + 0x4f, 0x4e, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x4a, 0x41, 0x56, 0x41, 0x10, 0x01, 0x12, 0x09, + 0x0a, 0x05, 0x53, 0x43, 0x41, 0x4c, 0x41, 0x10, 0x02, 0x12, 0x05, 0x0a, 0x01, 0x52, 0x10, 0x03, + 0x22, 0xf1, 0x05, 0x0a, 0x08, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x4a, 0x6f, 0x62, 0x12, 0x52, 0x0a, + 0x0f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x53, 0x70, 0x61, 0x72, 0x6b, + 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x54, 0x79, 0x70, 0x65, + 0x52, 0x0f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, + 0x65, 0x12, 0x30, 0x0a, 0x13, 0x6d, 0x61, 0x69, 0x6e, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, + 0x6d, 0x61, 0x69, 0x6e, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, + 0x69, 0x6c, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x6d, 0x61, 0x69, 0x6e, 0x43, 0x6c, 0x61, 0x73, 0x73, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x61, 0x69, 0x6e, 0x43, 0x6c, 0x61, 0x73, + 0x73, 0x12, 0x48, 0x0a, 0x09, 0x73, 0x70, 0x61, 0x72, 0x6b, 0x43, 0x6f, 0x6e, 0x66, 0x18, 0x04, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x4a, 0x6f, + 0x62, 0x2e, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x43, 0x6f, 0x6e, 0x66, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x52, 0x09, 0x73, 0x70, 0x61, 0x72, 0x6b, 0x43, 0x6f, 0x6e, 0x66, 0x12, 0x4b, 0x0a, 0x0a, 0x68, + 0x61, 0x64, 0x6f, 0x6f, 0x70, 0x43, 0x6f, 0x6e, 0x66, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2e, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x4a, 0x6f, 0x62, 0x2e, 0x48, 0x61, 0x64, + 0x6f, 0x6f, 0x70, 0x43, 0x6f, 0x6e, 0x66, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x68, 0x61, + 0x64, 0x6f, 0x6f, 0x70, 0x43, 0x6f, 0x6e, 0x66, 0x12, 0x22, 0x0a, 0x0c, 0x65, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x6f, 0x72, 0x50, 0x61, 0x74, 0x68, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x50, 0x61, 0x74, 0x68, 0x12, 0x3f, 0x0a, 0x0e, + 0x64, 0x61, 0x74, 0x61, 0x62, 0x72, 0x69, 0x63, 0x6b, 0x73, 0x43, 0x6f, 0x6e, 0x66, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x0e, 0x64, + 0x61, 0x74, 0x61, 0x62, 0x72, 0x69, 0x63, 0x6b, 0x73, 0x43, 0x6f, 0x6e, 0x66, 0x12, 0x28, 0x0a, + 0x0f, 0x64, 0x61, 0x74, 0x61, 0x62, 0x72, 0x69, 0x63, 0x6b, 0x73, 0x54, 0x6f, 0x6b, 0x65, 0x6e, + 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x64, 0x61, 0x74, 0x61, 0x62, 0x72, 0x69, 0x63, + 0x6b, 0x73, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x2e, 0x0a, 0x12, 0x64, 0x61, 0x74, 0x61, 0x62, + 0x72, 0x69, 0x63, 0x6b, 0x73, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x09, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x12, 0x64, 0x61, 0x74, 0x61, 0x62, 0x72, 0x69, 0x63, 0x6b, 0x73, 0x49, + 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x34, 0x0a, 0x09, 0x64, 0x72, 0x69, 0x76, 0x65, + 0x72, 0x50, 0x6f, 0x64, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x38, 0x73, 0x50, + 0x6f, 0x64, 0x52, 0x09, 0x64, 0x72, 0x69, 0x76, 0x65, 0x72, 0x50, 0x6f, 0x64, 0x12, 0x38, 0x0a, + 0x0b, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x50, 0x6f, 0x64, 0x18, 0x0b, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x38, 0x73, 0x50, 0x6f, 0x64, 0x52, 0x0b, 0x65, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x6f, 0x72, 0x50, 0x6f, 0x64, 0x1a, 0x3c, 0x0a, 0x0e, 0x53, 0x70, 0x61, 0x72, 0x6b, + 0x43, 0x6f, 0x6e, 0x66, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3d, 0x0a, 0x0f, 0x48, 0x61, 0x64, 0x6f, 0x6f, 0x70, 0x43, + 0x6f, 0x6e, 0x66, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x3a, 0x02, 0x38, 0x01, 0x42, 0xc1, 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x42, 0x0a, + 0x53, 0x70, 0x61, 0x72, 0x6b, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x35, + 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, + 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x73, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x58, 0xaa, 0x02, 0x11, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xca, + 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0xe2, 0x02, 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, + 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0xea, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, + 0x3a, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_plugins_spark_proto_rawDescOnce sync.Once + file_flyteidl2_plugins_spark_proto_rawDescData = file_flyteidl2_plugins_spark_proto_rawDesc +) + +func file_flyteidl2_plugins_spark_proto_rawDescGZIP() []byte { + file_flyteidl2_plugins_spark_proto_rawDescOnce.Do(func() { + file_flyteidl2_plugins_spark_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_plugins_spark_proto_rawDescData) + }) + return file_flyteidl2_plugins_spark_proto_rawDescData +} + +var file_flyteidl2_plugins_spark_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_flyteidl2_plugins_spark_proto_msgTypes = make([]protoimpl.MessageInfo, 4) +var file_flyteidl2_plugins_spark_proto_goTypes = []interface{}{ + (SparkApplication_Type)(0), // 0: flyteidl2.plugins.SparkApplication.Type + (*SparkApplication)(nil), // 1: flyteidl2.plugins.SparkApplication + (*SparkJob)(nil), // 2: flyteidl2.plugins.SparkJob + nil, // 3: flyteidl2.plugins.SparkJob.SparkConfEntry + nil, // 4: flyteidl2.plugins.SparkJob.HadoopConfEntry + (*structpb.Struct)(nil), // 5: google.protobuf.Struct + (*core.K8SPod)(nil), // 6: flyteidl2.core.K8sPod +} +var file_flyteidl2_plugins_spark_proto_depIdxs = []int32{ + 0, // 0: flyteidl2.plugins.SparkJob.applicationType:type_name -> flyteidl2.plugins.SparkApplication.Type + 3, // 1: flyteidl2.plugins.SparkJob.sparkConf:type_name -> flyteidl2.plugins.SparkJob.SparkConfEntry + 4, // 2: flyteidl2.plugins.SparkJob.hadoopConf:type_name -> flyteidl2.plugins.SparkJob.HadoopConfEntry + 5, // 3: flyteidl2.plugins.SparkJob.databricksConf:type_name -> google.protobuf.Struct + 6, // 4: flyteidl2.plugins.SparkJob.driverPod:type_name -> flyteidl2.core.K8sPod + 6, // 5: flyteidl2.plugins.SparkJob.executorPod:type_name -> flyteidl2.core.K8sPod + 6, // [6:6] is the sub-list for method output_type + 6, // [6:6] is the sub-list for method input_type + 6, // [6:6] is the sub-list for extension type_name + 6, // [6:6] is the sub-list for extension extendee + 0, // [0:6] is the sub-list for field type_name +} + +func init() { file_flyteidl2_plugins_spark_proto_init() } +func file_flyteidl2_plugins_spark_proto_init() { + if File_flyteidl2_plugins_spark_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_plugins_spark_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SparkApplication); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_plugins_spark_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SparkJob); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_plugins_spark_proto_rawDesc, + NumEnums: 1, + NumMessages: 4, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_plugins_spark_proto_goTypes, + DependencyIndexes: file_flyteidl2_plugins_spark_proto_depIdxs, + EnumInfos: file_flyteidl2_plugins_spark_proto_enumTypes, + MessageInfos: file_flyteidl2_plugins_spark_proto_msgTypes, + }.Build() + File_flyteidl2_plugins_spark_proto = out.File + file_flyteidl2_plugins_spark_proto_rawDesc = nil + file_flyteidl2_plugins_spark_proto_goTypes = nil + file_flyteidl2_plugins_spark_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/plugins/spark.pb.validate.go b/gen/go/flyteidl2/plugins/spark.pb.validate.go new file mode 100644 index 0000000000..e55c1d3828 --- /dev/null +++ b/gen/go/flyteidl2/plugins/spark.pb.validate.go @@ -0,0 +1,338 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/plugins/spark.proto + +package plugins + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on SparkApplication with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *SparkApplication) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on SparkApplication with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// SparkApplicationMultiError, or nil if none found. +func (m *SparkApplication) ValidateAll() error { + return m.validate(true) +} + +func (m *SparkApplication) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return SparkApplicationMultiError(errors) + } + + return nil +} + +// SparkApplicationMultiError is an error wrapping multiple validation errors +// returned by SparkApplication.ValidateAll() if the designated constraints +// aren't met. +type SparkApplicationMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SparkApplicationMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SparkApplicationMultiError) AllErrors() []error { return m } + +// SparkApplicationValidationError is the validation error returned by +// SparkApplication.Validate if the designated constraints aren't met. +type SparkApplicationValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SparkApplicationValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SparkApplicationValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SparkApplicationValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SparkApplicationValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SparkApplicationValidationError) ErrorName() string { return "SparkApplicationValidationError" } + +// Error satisfies the builtin error interface +func (e SparkApplicationValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSparkApplication.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SparkApplicationValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SparkApplicationValidationError{} + +// Validate checks the field values on SparkJob with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *SparkJob) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on SparkJob with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in SparkJobMultiError, or nil +// if none found. +func (m *SparkJob) ValidateAll() error { + return m.validate(true) +} + +func (m *SparkJob) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ApplicationType + + // no validation rules for MainApplicationFile + + // no validation rules for MainClass + + // no validation rules for SparkConf + + // no validation rules for HadoopConf + + // no validation rules for ExecutorPath + + if all { + switch v := interface{}(m.GetDatabricksConf()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SparkJobValidationError{ + field: "DatabricksConf", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SparkJobValidationError{ + field: "DatabricksConf", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDatabricksConf()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SparkJobValidationError{ + field: "DatabricksConf", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for DatabricksToken + + // no validation rules for DatabricksInstance + + if all { + switch v := interface{}(m.GetDriverPod()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SparkJobValidationError{ + field: "DriverPod", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SparkJobValidationError{ + field: "DriverPod", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDriverPod()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SparkJobValidationError{ + field: "DriverPod", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetExecutorPod()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SparkJobValidationError{ + field: "ExecutorPod", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SparkJobValidationError{ + field: "ExecutorPod", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetExecutorPod()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SparkJobValidationError{ + field: "ExecutorPod", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return SparkJobMultiError(errors) + } + + return nil +} + +// SparkJobMultiError is an error wrapping multiple validation errors returned +// by SparkJob.ValidateAll() if the designated constraints aren't met. +type SparkJobMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SparkJobMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SparkJobMultiError) AllErrors() []error { return m } + +// SparkJobValidationError is the validation error returned by +// SparkJob.Validate if the designated constraints aren't met. +type SparkJobValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SparkJobValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SparkJobValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SparkJobValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SparkJobValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SparkJobValidationError) ErrorName() string { return "SparkJobValidationError" } + +// Error satisfies the builtin error interface +func (e SparkJobValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSparkJob.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SparkJobValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SparkJobValidationError{} diff --git a/gen/go/flyteidl2/plugins/tensorflow.pb.go b/gen/go/flyteidl2/plugins/tensorflow.pb.go new file mode 100644 index 0000000000..1d76275d01 --- /dev/null +++ b/gen/go/flyteidl2/plugins/tensorflow.pb.go @@ -0,0 +1,194 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/plugins/tensorflow.proto + +package plugins + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Custom proto for plugin that enables distributed training using https://github.com/kubeflow/tf-operator +type DistributedTensorflowTrainingTask struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // number of worker replicas spawned in the cluster for this job + Workers int32 `protobuf:"varint,1,opt,name=workers,proto3" json:"workers,omitempty"` + // PS -> Parameter server + // number of ps replicas spawned in the cluster for this job + PsReplicas int32 `protobuf:"varint,2,opt,name=ps_replicas,json=psReplicas,proto3" json:"ps_replicas,omitempty"` + // number of chief replicas spawned in the cluster for this job + ChiefReplicas int32 `protobuf:"varint,3,opt,name=chief_replicas,json=chiefReplicas,proto3" json:"chief_replicas,omitempty"` + // number of evaluator replicas spawned in the cluster for this job + EvaluatorReplicas int32 `protobuf:"varint,4,opt,name=evaluator_replicas,json=evaluatorReplicas,proto3" json:"evaluator_replicas,omitempty"` +} + +func (x *DistributedTensorflowTrainingTask) Reset() { + *x = DistributedTensorflowTrainingTask{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_plugins_tensorflow_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DistributedTensorflowTrainingTask) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DistributedTensorflowTrainingTask) ProtoMessage() {} + +func (x *DistributedTensorflowTrainingTask) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_plugins_tensorflow_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DistributedTensorflowTrainingTask.ProtoReflect.Descriptor instead. +func (*DistributedTensorflowTrainingTask) Descriptor() ([]byte, []int) { + return file_flyteidl2_plugins_tensorflow_proto_rawDescGZIP(), []int{0} +} + +func (x *DistributedTensorflowTrainingTask) GetWorkers() int32 { + if x != nil { + return x.Workers + } + return 0 +} + +func (x *DistributedTensorflowTrainingTask) GetPsReplicas() int32 { + if x != nil { + return x.PsReplicas + } + return 0 +} + +func (x *DistributedTensorflowTrainingTask) GetChiefReplicas() int32 { + if x != nil { + return x.ChiefReplicas + } + return 0 +} + +func (x *DistributedTensorflowTrainingTask) GetEvaluatorReplicas() int32 { + if x != nil { + return x.EvaluatorReplicas + } + return 0 +} + +var File_flyteidl2_plugins_tensorflow_proto protoreflect.FileDescriptor + +var file_flyteidl2_plugins_tensorflow_proto_rawDesc = []byte{ + 0x0a, 0x22, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2f, 0x74, 0x65, 0x6e, 0x73, 0x6f, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x22, 0xb4, 0x01, 0x0a, 0x21, 0x44, 0x69, 0x73, 0x74, + 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x54, 0x65, 0x6e, 0x73, 0x6f, 0x72, 0x66, 0x6c, 0x6f, + 0x77, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x18, 0x0a, + 0x07, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, + 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x73, 0x5f, 0x72, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x70, 0x73, + 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x68, 0x69, 0x65, + 0x66, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x0d, 0x63, 0x68, 0x69, 0x65, 0x66, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, + 0x2d, 0x0a, 0x12, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x72, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x11, 0x65, 0x76, 0x61, + 0x6c, 0x75, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x42, 0xc6, + 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x42, 0x0f, 0x54, 0x65, 0x6e, 0x73, 0x6f, 0x72, + 0x66, 0x6c, 0x6f, 0x77, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x35, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, + 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, + 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x73, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x58, 0xaa, 0x02, 0x11, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xca, 0x02, + 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x73, 0xe2, 0x02, 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, + 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_plugins_tensorflow_proto_rawDescOnce sync.Once + file_flyteidl2_plugins_tensorflow_proto_rawDescData = file_flyteidl2_plugins_tensorflow_proto_rawDesc +) + +func file_flyteidl2_plugins_tensorflow_proto_rawDescGZIP() []byte { + file_flyteidl2_plugins_tensorflow_proto_rawDescOnce.Do(func() { + file_flyteidl2_plugins_tensorflow_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_plugins_tensorflow_proto_rawDescData) + }) + return file_flyteidl2_plugins_tensorflow_proto_rawDescData +} + +var file_flyteidl2_plugins_tensorflow_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_flyteidl2_plugins_tensorflow_proto_goTypes = []interface{}{ + (*DistributedTensorflowTrainingTask)(nil), // 0: flyteidl2.plugins.DistributedTensorflowTrainingTask +} +var file_flyteidl2_plugins_tensorflow_proto_depIdxs = []int32{ + 0, // [0:0] is the sub-list for method output_type + 0, // [0:0] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_flyteidl2_plugins_tensorflow_proto_init() } +func file_flyteidl2_plugins_tensorflow_proto_init() { + if File_flyteidl2_plugins_tensorflow_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_plugins_tensorflow_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DistributedTensorflowTrainingTask); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_plugins_tensorflow_proto_rawDesc, + NumEnums: 0, + NumMessages: 1, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_plugins_tensorflow_proto_goTypes, + DependencyIndexes: file_flyteidl2_plugins_tensorflow_proto_depIdxs, + MessageInfos: file_flyteidl2_plugins_tensorflow_proto_msgTypes, + }.Build() + File_flyteidl2_plugins_tensorflow_proto = out.File + file_flyteidl2_plugins_tensorflow_proto_rawDesc = nil + file_flyteidl2_plugins_tensorflow_proto_goTypes = nil + file_flyteidl2_plugins_tensorflow_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/plugins/tensorflow.pb.validate.go b/gen/go/flyteidl2/plugins/tensorflow.pb.validate.go new file mode 100644 index 0000000000..2a77a24097 --- /dev/null +++ b/gen/go/flyteidl2/plugins/tensorflow.pb.validate.go @@ -0,0 +1,149 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/plugins/tensorflow.proto + +package plugins + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on DistributedTensorflowTrainingTask with +// the rules defined in the proto definition for this message. If any rules +// are violated, the first error encountered is returned, or nil if there are +// no violations. +func (m *DistributedTensorflowTrainingTask) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DistributedTensorflowTrainingTask +// with the rules defined in the proto definition for this message. If any +// rules are violated, the result is a list of violation errors wrapped in +// DistributedTensorflowTrainingTaskMultiError, or nil if none found. +func (m *DistributedTensorflowTrainingTask) ValidateAll() error { + return m.validate(true) +} + +func (m *DistributedTensorflowTrainingTask) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Workers + + // no validation rules for PsReplicas + + // no validation rules for ChiefReplicas + + // no validation rules for EvaluatorReplicas + + if len(errors) > 0 { + return DistributedTensorflowTrainingTaskMultiError(errors) + } + + return nil +} + +// DistributedTensorflowTrainingTaskMultiError is an error wrapping multiple +// validation errors returned by +// DistributedTensorflowTrainingTask.ValidateAll() if the designated +// constraints aren't met. +type DistributedTensorflowTrainingTaskMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DistributedTensorflowTrainingTaskMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DistributedTensorflowTrainingTaskMultiError) AllErrors() []error { return m } + +// DistributedTensorflowTrainingTaskValidationError is the validation error +// returned by DistributedTensorflowTrainingTask.Validate if the designated +// constraints aren't met. +type DistributedTensorflowTrainingTaskValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DistributedTensorflowTrainingTaskValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DistributedTensorflowTrainingTaskValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DistributedTensorflowTrainingTaskValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DistributedTensorflowTrainingTaskValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DistributedTensorflowTrainingTaskValidationError) ErrorName() string { + return "DistributedTensorflowTrainingTaskValidationError" +} + +// Error satisfies the builtin error interface +func (e DistributedTensorflowTrainingTaskValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDistributedTensorflowTrainingTask.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DistributedTensorflowTrainingTaskValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DistributedTensorflowTrainingTaskValidationError{} diff --git a/gen/go/flyteidl2/project/project_service.pb.go b/gen/go/flyteidl2/project/project_service.pb.go new file mode 100644 index 0000000000..cb47730bdd --- /dev/null +++ b/gen/go/flyteidl2/project/project_service.pb.go @@ -0,0 +1,1057 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/project/project_service.proto + +package project + +import ( + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + task "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// The state of the project is used to control its visibility in the UI and validity. +type ProjectState int32 + +const ( + // By default, all projects are considered active. + ProjectState_PROJECT_STATE_ACTIVE ProjectState = 0 + // Archived projects are no longer visible in the UI and no longer valid. + ProjectState_PROJECT_STATE_ARCHIVED ProjectState = 1 + // System generated projects that aren't explicitly created or managed by a user. + ProjectState_PROJECT_STATE_SYSTEM_GENERATED ProjectState = 2 + // System archived projects that aren't explicitly archived by a user. + ProjectState_PROJECT_STATE_SYSTEM_ARCHIVED ProjectState = 3 +) + +// Enum value maps for ProjectState. +var ( + ProjectState_name = map[int32]string{ + 0: "PROJECT_STATE_ACTIVE", + 1: "PROJECT_STATE_ARCHIVED", + 2: "PROJECT_STATE_SYSTEM_GENERATED", + 3: "PROJECT_STATE_SYSTEM_ARCHIVED", + } + ProjectState_value = map[string]int32{ + "PROJECT_STATE_ACTIVE": 0, + "PROJECT_STATE_ARCHIVED": 1, + "PROJECT_STATE_SYSTEM_GENERATED": 2, + "PROJECT_STATE_SYSTEM_ARCHIVED": 3, + } +) + +func (x ProjectState) Enum() *ProjectState { + p := new(ProjectState) + *p = x + return p +} + +func (x ProjectState) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ProjectState) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_project_project_service_proto_enumTypes[0].Descriptor() +} + +func (ProjectState) Type() protoreflect.EnumType { + return &file_flyteidl2_project_project_service_proto_enumTypes[0] +} + +func (x ProjectState) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use ProjectState.Descriptor instead. +func (ProjectState) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_project_project_service_proto_rawDescGZIP(), []int{0} +} + +// Namespace within a project commonly used to differentiate between different service instances. +// e.g. "production", "development", etc. +type Domain struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Globally unique domain name. + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // Display name. + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *Domain) Reset() { + *x = Domain{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Domain) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Domain) ProtoMessage() {} + +func (x *Domain) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Domain.ProtoReflect.Descriptor instead. +func (*Domain) Descriptor() ([]byte, []int) { + return file_flyteidl2_project_project_service_proto_rawDescGZIP(), []int{0} +} + +func (x *Domain) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *Domain) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type Project struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Globally unique project name. + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // Display name. + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Domains []*Domain `protobuf:"bytes,3,rep,name=domains,proto3" json:"domains,omitempty"` + Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` + // Leverage Labels from flyteidl.admin.common.proto to + // tag projects with ownership information. + Labels *task.Labels `protobuf:"bytes,5,opt,name=labels,proto3" json:"labels,omitempty"` + State ProjectState `protobuf:"varint,6,opt,name=state,proto3,enum=flyteidl2.project.ProjectState" json:"state,omitempty"` + // Optional, org key applied to the resource. + Org string `protobuf:"bytes,7,opt,name=org,proto3" json:"org,omitempty"` +} + +func (x *Project) Reset() { + *x = Project{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Project) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Project) ProtoMessage() {} + +func (x *Project) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Project.ProtoReflect.Descriptor instead. +func (*Project) Descriptor() ([]byte, []int) { + return file_flyteidl2_project_project_service_proto_rawDescGZIP(), []int{1} +} + +func (x *Project) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *Project) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Project) GetDomains() []*Domain { + if x != nil { + return x.Domains + } + return nil +} + +func (x *Project) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +func (x *Project) GetLabels() *task.Labels { + if x != nil { + return x.Labels + } + return nil +} + +func (x *Project) GetState() ProjectState { + if x != nil { + return x.State + } + return ProjectState_PROJECT_STATE_ACTIVE +} + +func (x *Project) GetOrg() string { + if x != nil { + return x.Org + } + return "" +} + +// Represents a list of projects. +// See :ref:`ref_flyteidl.admin.Project` for more details +type Projects struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Projects []*Project `protobuf:"bytes,1,rep,name=projects,proto3" json:"projects,omitempty"` + // In the case of multiple pages of results, the server-provided token can be used to fetch the next page + // in a query. If there are no more results, this value will be empty. + Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"` +} + +func (x *Projects) Reset() { + *x = Projects{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Projects) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Projects) ProtoMessage() {} + +func (x *Projects) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Projects.ProtoReflect.Descriptor instead. +func (*Projects) Descriptor() ([]byte, []int) { + return file_flyteidl2_project_project_service_proto_rawDescGZIP(), []int{2} +} + +func (x *Projects) GetProjects() []*Project { + if x != nil { + return x.Projects + } + return nil +} + +func (x *Projects) GetToken() string { + if x != nil { + return x.Token + } + return "" +} + +// Adds a new user-project within the Flyte deployment. +// See :ref:`ref_flyteidl.admin.Project` for more details +type CreateProjectRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // +required + Project *Project `protobuf:"bytes,1,opt,name=project,proto3" json:"project,omitempty"` +} + +func (x *CreateProjectRequest) Reset() { + *x = CreateProjectRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CreateProjectRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateProjectRequest) ProtoMessage() {} + +func (x *CreateProjectRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateProjectRequest.ProtoReflect.Descriptor instead. +func (*CreateProjectRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_project_project_service_proto_rawDescGZIP(), []int{3} +} + +func (x *CreateProjectRequest) GetProject() *Project { + if x != nil { + return x.Project + } + return nil +} + +// Purposefully empty, may be updated in the future. +type CreateProjectResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *CreateProjectResponse) Reset() { + *x = CreateProjectResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CreateProjectResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateProjectResponse) ProtoMessage() {} + +func (x *CreateProjectResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateProjectResponse.ProtoReflect.Descriptor instead. +func (*CreateProjectResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_project_project_service_proto_rawDescGZIP(), []int{4} +} + +type UpdateProjectRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // +required + Project *Project `protobuf:"bytes,1,opt,name=project,proto3" json:"project,omitempty"` +} + +func (x *UpdateProjectRequest) Reset() { + *x = UpdateProjectRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UpdateProjectRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateProjectRequest) ProtoMessage() {} + +func (x *UpdateProjectRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateProjectRequest.ProtoReflect.Descriptor instead. +func (*UpdateProjectRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_project_project_service_proto_rawDescGZIP(), []int{5} +} + +func (x *UpdateProjectRequest) GetProject() *Project { + if x != nil { + return x.Project + } + return nil +} + +// Purposefully empty, may be updated in the future. +type UpdateProjectResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *UpdateProjectResponse) Reset() { + *x = UpdateProjectResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UpdateProjectResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateProjectResponse) ProtoMessage() {} + +func (x *UpdateProjectResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateProjectResponse.ProtoReflect.Descriptor instead. +func (*UpdateProjectResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_project_project_service_proto_rawDescGZIP(), []int{6} +} + +type GetProjectRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Indicates a unique project. + // +required + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // Optional, org key applied to the resource. + Org string `protobuf:"bytes,2,opt,name=org,proto3" json:"org,omitempty"` +} + +func (x *GetProjectRequest) Reset() { + *x = GetProjectRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetProjectRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetProjectRequest) ProtoMessage() {} + +func (x *GetProjectRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetProjectRequest.ProtoReflect.Descriptor instead. +func (*GetProjectRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_project_project_service_proto_rawDescGZIP(), []int{7} +} + +func (x *GetProjectRequest) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *GetProjectRequest) GetOrg() string { + if x != nil { + return x.Org + } + return "" +} + +type GetProjectResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // +required + Project *Project `protobuf:"bytes,1,opt,name=project,proto3" json:"project,omitempty"` +} + +func (x *GetProjectResponse) Reset() { + *x = GetProjectResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetProjectResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetProjectResponse) ProtoMessage() {} + +func (x *GetProjectResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetProjectResponse.ProtoReflect.Descriptor instead. +func (*GetProjectResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_project_project_service_proto_rawDescGZIP(), []int{8} +} + +func (x *GetProjectResponse) GetProject() *Project { + if x != nil { + return x.Project + } + return nil +} + +// Request to retrieve a list of projects matching specified filters. +// See :ref:`ref_flyteidl.admin.Project` for more details +type ListProjectsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Indicates the number of projects to be returned. + // +required + Limit uint32 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"` + // In the case of multiple pages of results, this server-provided token can be used to fetch the next page + // in a query. + // +optional + Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"` + // Indicates a list of filters passed as string. + // More info on constructing filters : + // +optional + Filters string `protobuf:"bytes,3,opt,name=filters,proto3" json:"filters,omitempty"` + // Sort ordering. + // +optional + SortBy *common.Sort `protobuf:"bytes,4,opt,name=sort_by,json=sortBy,proto3" json:"sort_by,omitempty"` + // Optional, org filter applied to list project requests. + Org string `protobuf:"bytes,5,opt,name=org,proto3" json:"org,omitempty"` +} + +func (x *ListProjectsRequest) Reset() { + *x = ListProjectsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListProjectsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListProjectsRequest) ProtoMessage() {} + +func (x *ListProjectsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListProjectsRequest.ProtoReflect.Descriptor instead. +func (*ListProjectsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_project_project_service_proto_rawDescGZIP(), []int{9} +} + +func (x *ListProjectsRequest) GetLimit() uint32 { + if x != nil { + return x.Limit + } + return 0 +} + +func (x *ListProjectsRequest) GetToken() string { + if x != nil { + return x.Token + } + return "" +} + +func (x *ListProjectsRequest) GetFilters() string { + if x != nil { + return x.Filters + } + return "" +} + +func (x *ListProjectsRequest) GetSortBy() *common.Sort { + if x != nil { + return x.SortBy + } + return nil +} + +func (x *ListProjectsRequest) GetOrg() string { + if x != nil { + return x.Org + } + return "" +} + +type ListProjectsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // +required + Projects *Projects `protobuf:"bytes,1,opt,name=projects,proto3" json:"projects,omitempty"` +} + +func (x *ListProjectsResponse) Reset() { + *x = ListProjectsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListProjectsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListProjectsResponse) ProtoMessage() {} + +func (x *ListProjectsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_project_project_service_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListProjectsResponse.ProtoReflect.Descriptor instead. +func (*ListProjectsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_project_project_service_proto_rawDescGZIP(), []int{10} +} + +func (x *ListProjectsResponse) GetProjects() *Projects { + if x != nil { + return x.Projects + } + return nil +} + +var File_flyteidl2_project_project_service_proto protoreflect.FileDescriptor + +var file_flyteidl2_project_project_service_proto_rawDesc = []byte{ + 0x0a, 0x27, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x73, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x1a, 0x1b, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x6c, + 0x69, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x18, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x72, 0x75, 0x6e, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x22, 0x2c, 0x0a, 0x06, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x0e, 0x0a, + 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x22, 0xfd, 0x01, 0x0a, 0x07, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x0e, 0x0a, + 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x12, 0x33, 0x0a, 0x07, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x52, 0x07, 0x64, + 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2e, 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, + 0x6c, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, + 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x12, 0x35, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, + 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x50, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, + 0x10, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6f, 0x72, + 0x67, 0x22, 0x58, 0x0a, 0x08, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x36, 0x0a, + 0x08, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x08, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x4c, 0x0a, 0x14, 0x43, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x34, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x17, 0x0a, 0x15, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x4c, 0x0a, 0x14, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x34, 0x0a, 0x07, 0x70, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, + 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x22, 0x17, 0x0a, 0x15, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0x0a, 0x11, 0x47, 0x65, 0x74, + 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, + 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x10, + 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6f, 0x72, 0x67, + 0x22, 0x4a, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x50, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x9e, 0x01, 0x0a, + 0x13, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, + 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x12, 0x2f, 0x0a, 0x07, 0x73, 0x6f, + 0x72, 0x74, 0x5f, 0x62, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, + 0x6f, 0x72, 0x74, 0x52, 0x06, 0x73, 0x6f, 0x72, 0x74, 0x42, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6f, + 0x72, 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x22, 0x4f, 0x0a, + 0x14, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x37, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x50, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x73, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2a, 0x8b, + 0x01, 0x0a, 0x0c, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, + 0x18, 0x0a, 0x14, 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, + 0x5f, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x10, 0x00, 0x12, 0x1a, 0x0a, 0x16, 0x50, 0x52, 0x4f, + 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x41, 0x52, 0x43, 0x48, 0x49, + 0x56, 0x45, 0x44, 0x10, 0x01, 0x12, 0x22, 0x0a, 0x1e, 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, + 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x5f, 0x47, 0x45, + 0x4e, 0x45, 0x52, 0x41, 0x54, 0x45, 0x44, 0x10, 0x02, 0x12, 0x21, 0x0a, 0x1d, 0x50, 0x52, 0x4f, + 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x59, 0x53, 0x54, 0x45, + 0x4d, 0x5f, 0x41, 0x52, 0x43, 0x48, 0x49, 0x56, 0x45, 0x44, 0x10, 0x03, 0x32, 0x9f, 0x03, 0x0a, + 0x0e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, + 0x64, 0x0a, 0x0d, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x12, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x64, 0x0a, 0x0d, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5e, 0x0a, 0x0a, 0x47, + 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x47, 0x65, + 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x61, 0x0a, 0x0c, 0x4c, + 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x26, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, + 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0xca, + 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x42, 0x13, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, + 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, + 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x58, 0xaa, 0x02, + 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0xca, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0xe2, 0x02, 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x3a, 0x3a, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_project_project_service_proto_rawDescOnce sync.Once + file_flyteidl2_project_project_service_proto_rawDescData = file_flyteidl2_project_project_service_proto_rawDesc +) + +func file_flyteidl2_project_project_service_proto_rawDescGZIP() []byte { + file_flyteidl2_project_project_service_proto_rawDescOnce.Do(func() { + file_flyteidl2_project_project_service_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_project_project_service_proto_rawDescData) + }) + return file_flyteidl2_project_project_service_proto_rawDescData +} + +var file_flyteidl2_project_project_service_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_flyteidl2_project_project_service_proto_msgTypes = make([]protoimpl.MessageInfo, 11) +var file_flyteidl2_project_project_service_proto_goTypes = []interface{}{ + (ProjectState)(0), // 0: flyteidl2.project.ProjectState + (*Domain)(nil), // 1: flyteidl2.project.Domain + (*Project)(nil), // 2: flyteidl2.project.Project + (*Projects)(nil), // 3: flyteidl2.project.Projects + (*CreateProjectRequest)(nil), // 4: flyteidl2.project.CreateProjectRequest + (*CreateProjectResponse)(nil), // 5: flyteidl2.project.CreateProjectResponse + (*UpdateProjectRequest)(nil), // 6: flyteidl2.project.UpdateProjectRequest + (*UpdateProjectResponse)(nil), // 7: flyteidl2.project.UpdateProjectResponse + (*GetProjectRequest)(nil), // 8: flyteidl2.project.GetProjectRequest + (*GetProjectResponse)(nil), // 9: flyteidl2.project.GetProjectResponse + (*ListProjectsRequest)(nil), // 10: flyteidl2.project.ListProjectsRequest + (*ListProjectsResponse)(nil), // 11: flyteidl2.project.ListProjectsResponse + (*task.Labels)(nil), // 12: flyteidl2.task.Labels + (*common.Sort)(nil), // 13: flyteidl2.common.Sort +} +var file_flyteidl2_project_project_service_proto_depIdxs = []int32{ + 1, // 0: flyteidl2.project.Project.domains:type_name -> flyteidl2.project.Domain + 12, // 1: flyteidl2.project.Project.labels:type_name -> flyteidl2.task.Labels + 0, // 2: flyteidl2.project.Project.state:type_name -> flyteidl2.project.ProjectState + 2, // 3: flyteidl2.project.Projects.projects:type_name -> flyteidl2.project.Project + 2, // 4: flyteidl2.project.CreateProjectRequest.project:type_name -> flyteidl2.project.Project + 2, // 5: flyteidl2.project.UpdateProjectRequest.project:type_name -> flyteidl2.project.Project + 2, // 6: flyteidl2.project.GetProjectResponse.project:type_name -> flyteidl2.project.Project + 13, // 7: flyteidl2.project.ListProjectsRequest.sort_by:type_name -> flyteidl2.common.Sort + 3, // 8: flyteidl2.project.ListProjectsResponse.projects:type_name -> flyteidl2.project.Projects + 4, // 9: flyteidl2.project.ProjectService.CreateProject:input_type -> flyteidl2.project.CreateProjectRequest + 6, // 10: flyteidl2.project.ProjectService.UpdateProject:input_type -> flyteidl2.project.UpdateProjectRequest + 8, // 11: flyteidl2.project.ProjectService.GetProject:input_type -> flyteidl2.project.GetProjectRequest + 10, // 12: flyteidl2.project.ProjectService.ListProjects:input_type -> flyteidl2.project.ListProjectsRequest + 5, // 13: flyteidl2.project.ProjectService.CreateProject:output_type -> flyteidl2.project.CreateProjectResponse + 7, // 14: flyteidl2.project.ProjectService.UpdateProject:output_type -> flyteidl2.project.UpdateProjectResponse + 9, // 15: flyteidl2.project.ProjectService.GetProject:output_type -> flyteidl2.project.GetProjectResponse + 11, // 16: flyteidl2.project.ProjectService.ListProjects:output_type -> flyteidl2.project.ListProjectsResponse + 13, // [13:17] is the sub-list for method output_type + 9, // [9:13] is the sub-list for method input_type + 9, // [9:9] is the sub-list for extension type_name + 9, // [9:9] is the sub-list for extension extendee + 0, // [0:9] is the sub-list for field type_name +} + +func init() { file_flyteidl2_project_project_service_proto_init() } +func file_flyteidl2_project_project_service_proto_init() { + if File_flyteidl2_project_project_service_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_project_project_service_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Domain); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_project_project_service_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Project); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_project_project_service_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Projects); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_project_project_service_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CreateProjectRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_project_project_service_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CreateProjectResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_project_project_service_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UpdateProjectRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_project_project_service_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UpdateProjectResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_project_project_service_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetProjectRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_project_project_service_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetProjectResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_project_project_service_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListProjectsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_project_project_service_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListProjectsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_project_project_service_proto_rawDesc, + NumEnums: 1, + NumMessages: 11, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_flyteidl2_project_project_service_proto_goTypes, + DependencyIndexes: file_flyteidl2_project_project_service_proto_depIdxs, + EnumInfos: file_flyteidl2_project_project_service_proto_enumTypes, + MessageInfos: file_flyteidl2_project_project_service_proto_msgTypes, + }.Build() + File_flyteidl2_project_project_service_proto = out.File + file_flyteidl2_project_project_service_proto_rawDesc = nil + file_flyteidl2_project_project_service_proto_goTypes = nil + file_flyteidl2_project_project_service_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/project/project_service.pb.validate.go b/gen/go/flyteidl2/project/project_service.pb.validate.go new file mode 100644 index 0000000000..31ea6f63f8 --- /dev/null +++ b/gen/go/flyteidl2/project/project_service.pb.validate.go @@ -0,0 +1,1417 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/project/project_service.proto + +package project + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on Domain with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Domain) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Domain with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in DomainMultiError, or nil if none found. +func (m *Domain) ValidateAll() error { + return m.validate(true) +} + +func (m *Domain) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Id + + // no validation rules for Name + + if len(errors) > 0 { + return DomainMultiError(errors) + } + + return nil +} + +// DomainMultiError is an error wrapping multiple validation errors returned by +// Domain.ValidateAll() if the designated constraints aren't met. +type DomainMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DomainMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DomainMultiError) AllErrors() []error { return m } + +// DomainValidationError is the validation error returned by Domain.Validate if +// the designated constraints aren't met. +type DomainValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DomainValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DomainValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DomainValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DomainValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DomainValidationError) ErrorName() string { return "DomainValidationError" } + +// Error satisfies the builtin error interface +func (e DomainValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDomain.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DomainValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DomainValidationError{} + +// Validate checks the field values on Project with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Project) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Project with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in ProjectMultiError, or nil if none found. +func (m *Project) ValidateAll() error { + return m.validate(true) +} + +func (m *Project) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Id + + // no validation rules for Name + + for idx, item := range m.GetDomains() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ProjectValidationError{ + field: fmt.Sprintf("Domains[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ProjectValidationError{ + field: fmt.Sprintf("Domains[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ProjectValidationError{ + field: fmt.Sprintf("Domains[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Description + + if all { + switch v := interface{}(m.GetLabels()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ProjectValidationError{ + field: "Labels", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ProjectValidationError{ + field: "Labels", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLabels()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ProjectValidationError{ + field: "Labels", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for State + + // no validation rules for Org + + if len(errors) > 0 { + return ProjectMultiError(errors) + } + + return nil +} + +// ProjectMultiError is an error wrapping multiple validation errors returned +// by Project.ValidateAll() if the designated constraints aren't met. +type ProjectMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ProjectMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ProjectMultiError) AllErrors() []error { return m } + +// ProjectValidationError is the validation error returned by Project.Validate +// if the designated constraints aren't met. +type ProjectValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ProjectValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ProjectValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ProjectValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ProjectValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ProjectValidationError) ErrorName() string { return "ProjectValidationError" } + +// Error satisfies the builtin error interface +func (e ProjectValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sProject.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ProjectValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ProjectValidationError{} + +// Validate checks the field values on Projects with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Projects) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Projects with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ProjectsMultiError, or nil +// if none found. +func (m *Projects) ValidateAll() error { + return m.validate(true) +} + +func (m *Projects) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetProjects() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ProjectsValidationError{ + field: fmt.Sprintf("Projects[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ProjectsValidationError{ + field: fmt.Sprintf("Projects[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ProjectsValidationError{ + field: fmt.Sprintf("Projects[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Token + + if len(errors) > 0 { + return ProjectsMultiError(errors) + } + + return nil +} + +// ProjectsMultiError is an error wrapping multiple validation errors returned +// by Projects.ValidateAll() if the designated constraints aren't met. +type ProjectsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ProjectsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ProjectsMultiError) AllErrors() []error { return m } + +// ProjectsValidationError is the validation error returned by +// Projects.Validate if the designated constraints aren't met. +type ProjectsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ProjectsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ProjectsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ProjectsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ProjectsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ProjectsValidationError) ErrorName() string { return "ProjectsValidationError" } + +// Error satisfies the builtin error interface +func (e ProjectsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sProjects.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ProjectsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ProjectsValidationError{} + +// Validate checks the field values on CreateProjectRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *CreateProjectRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CreateProjectRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CreateProjectRequestMultiError, or nil if none found. +func (m *CreateProjectRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *CreateProjectRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetProject()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateProjectRequestValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateProjectRequestValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetProject()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateProjectRequestValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return CreateProjectRequestMultiError(errors) + } + + return nil +} + +// CreateProjectRequestMultiError is an error wrapping multiple validation +// errors returned by CreateProjectRequest.ValidateAll() if the designated +// constraints aren't met. +type CreateProjectRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CreateProjectRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CreateProjectRequestMultiError) AllErrors() []error { return m } + +// CreateProjectRequestValidationError is the validation error returned by +// CreateProjectRequest.Validate if the designated constraints aren't met. +type CreateProjectRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CreateProjectRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CreateProjectRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CreateProjectRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CreateProjectRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CreateProjectRequestValidationError) ErrorName() string { + return "CreateProjectRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e CreateProjectRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCreateProjectRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CreateProjectRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CreateProjectRequestValidationError{} + +// Validate checks the field values on CreateProjectResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *CreateProjectResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CreateProjectResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CreateProjectResponseMultiError, or nil if none found. +func (m *CreateProjectResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *CreateProjectResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return CreateProjectResponseMultiError(errors) + } + + return nil +} + +// CreateProjectResponseMultiError is an error wrapping multiple validation +// errors returned by CreateProjectResponse.ValidateAll() if the designated +// constraints aren't met. +type CreateProjectResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CreateProjectResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CreateProjectResponseMultiError) AllErrors() []error { return m } + +// CreateProjectResponseValidationError is the validation error returned by +// CreateProjectResponse.Validate if the designated constraints aren't met. +type CreateProjectResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CreateProjectResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CreateProjectResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CreateProjectResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CreateProjectResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CreateProjectResponseValidationError) ErrorName() string { + return "CreateProjectResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e CreateProjectResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCreateProjectResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CreateProjectResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CreateProjectResponseValidationError{} + +// Validate checks the field values on UpdateProjectRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *UpdateProjectRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on UpdateProjectRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// UpdateProjectRequestMultiError, or nil if none found. +func (m *UpdateProjectRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *UpdateProjectRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetProject()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UpdateProjectRequestValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UpdateProjectRequestValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetProject()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UpdateProjectRequestValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return UpdateProjectRequestMultiError(errors) + } + + return nil +} + +// UpdateProjectRequestMultiError is an error wrapping multiple validation +// errors returned by UpdateProjectRequest.ValidateAll() if the designated +// constraints aren't met. +type UpdateProjectRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UpdateProjectRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UpdateProjectRequestMultiError) AllErrors() []error { return m } + +// UpdateProjectRequestValidationError is the validation error returned by +// UpdateProjectRequest.Validate if the designated constraints aren't met. +type UpdateProjectRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UpdateProjectRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UpdateProjectRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UpdateProjectRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UpdateProjectRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UpdateProjectRequestValidationError) ErrorName() string { + return "UpdateProjectRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e UpdateProjectRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUpdateProjectRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UpdateProjectRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UpdateProjectRequestValidationError{} + +// Validate checks the field values on UpdateProjectResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *UpdateProjectResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on UpdateProjectResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// UpdateProjectResponseMultiError, or nil if none found. +func (m *UpdateProjectResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *UpdateProjectResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return UpdateProjectResponseMultiError(errors) + } + + return nil +} + +// UpdateProjectResponseMultiError is an error wrapping multiple validation +// errors returned by UpdateProjectResponse.ValidateAll() if the designated +// constraints aren't met. +type UpdateProjectResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UpdateProjectResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UpdateProjectResponseMultiError) AllErrors() []error { return m } + +// UpdateProjectResponseValidationError is the validation error returned by +// UpdateProjectResponse.Validate if the designated constraints aren't met. +type UpdateProjectResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UpdateProjectResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UpdateProjectResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UpdateProjectResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UpdateProjectResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UpdateProjectResponseValidationError) ErrorName() string { + return "UpdateProjectResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e UpdateProjectResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUpdateProjectResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UpdateProjectResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UpdateProjectResponseValidationError{} + +// Validate checks the field values on GetProjectRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *GetProjectRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetProjectRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetProjectRequestMultiError, or nil if none found. +func (m *GetProjectRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetProjectRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Id + + // no validation rules for Org + + if len(errors) > 0 { + return GetProjectRequestMultiError(errors) + } + + return nil +} + +// GetProjectRequestMultiError is an error wrapping multiple validation errors +// returned by GetProjectRequest.ValidateAll() if the designated constraints +// aren't met. +type GetProjectRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetProjectRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetProjectRequestMultiError) AllErrors() []error { return m } + +// GetProjectRequestValidationError is the validation error returned by +// GetProjectRequest.Validate if the designated constraints aren't met. +type GetProjectRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetProjectRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetProjectRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetProjectRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetProjectRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetProjectRequestValidationError) ErrorName() string { + return "GetProjectRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e GetProjectRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetProjectRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetProjectRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetProjectRequestValidationError{} + +// Validate checks the field values on GetProjectResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetProjectResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetProjectResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetProjectResponseMultiError, or nil if none found. +func (m *GetProjectResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetProjectResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetProject()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetProjectResponseValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetProjectResponseValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetProject()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetProjectResponseValidationError{ + field: "Project", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetProjectResponseMultiError(errors) + } + + return nil +} + +// GetProjectResponseMultiError is an error wrapping multiple validation errors +// returned by GetProjectResponse.ValidateAll() if the designated constraints +// aren't met. +type GetProjectResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetProjectResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetProjectResponseMultiError) AllErrors() []error { return m } + +// GetProjectResponseValidationError is the validation error returned by +// GetProjectResponse.Validate if the designated constraints aren't met. +type GetProjectResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetProjectResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetProjectResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetProjectResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetProjectResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetProjectResponseValidationError) ErrorName() string { + return "GetProjectResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e GetProjectResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetProjectResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetProjectResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetProjectResponseValidationError{} + +// Validate checks the field values on ListProjectsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ListProjectsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListProjectsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ListProjectsRequestMultiError, or nil if none found. +func (m *ListProjectsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *ListProjectsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Limit + + // no validation rules for Token + + // no validation rules for Filters + + if all { + switch v := interface{}(m.GetSortBy()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListProjectsRequestValidationError{ + field: "SortBy", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListProjectsRequestValidationError{ + field: "SortBy", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSortBy()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListProjectsRequestValidationError{ + field: "SortBy", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Org + + if len(errors) > 0 { + return ListProjectsRequestMultiError(errors) + } + + return nil +} + +// ListProjectsRequestMultiError is an error wrapping multiple validation +// errors returned by ListProjectsRequest.ValidateAll() if the designated +// constraints aren't met. +type ListProjectsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListProjectsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListProjectsRequestMultiError) AllErrors() []error { return m } + +// ListProjectsRequestValidationError is the validation error returned by +// ListProjectsRequest.Validate if the designated constraints aren't met. +type ListProjectsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListProjectsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListProjectsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListProjectsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListProjectsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListProjectsRequestValidationError) ErrorName() string { + return "ListProjectsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e ListProjectsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListProjectsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListProjectsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListProjectsRequestValidationError{} + +// Validate checks the field values on ListProjectsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ListProjectsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListProjectsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ListProjectsResponseMultiError, or nil if none found. +func (m *ListProjectsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *ListProjectsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetProjects()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListProjectsResponseValidationError{ + field: "Projects", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListProjectsResponseValidationError{ + field: "Projects", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetProjects()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListProjectsResponseValidationError{ + field: "Projects", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ListProjectsResponseMultiError(errors) + } + + return nil +} + +// ListProjectsResponseMultiError is an error wrapping multiple validation +// errors returned by ListProjectsResponse.ValidateAll() if the designated +// constraints aren't met. +type ListProjectsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListProjectsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListProjectsResponseMultiError) AllErrors() []error { return m } + +// ListProjectsResponseValidationError is the validation error returned by +// ListProjectsResponse.Validate if the designated constraints aren't met. +type ListProjectsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListProjectsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListProjectsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListProjectsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListProjectsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListProjectsResponseValidationError) ErrorName() string { + return "ListProjectsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e ListProjectsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListProjectsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListProjectsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListProjectsResponseValidationError{} diff --git a/gen/go/flyteidl2/project/project_service_grpc.pb.go b/gen/go/flyteidl2/project/project_service_grpc.pb.go new file mode 100644 index 0000000000..636a1247a4 --- /dev/null +++ b/gen/go/flyteidl2/project/project_service_grpc.pb.go @@ -0,0 +1,220 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: flyteidl2/project/project_service.proto + +package project + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + ProjectService_CreateProject_FullMethodName = "/flyteidl2.project.ProjectService/CreateProject" + ProjectService_UpdateProject_FullMethodName = "/flyteidl2.project.ProjectService/UpdateProject" + ProjectService_GetProject_FullMethodName = "/flyteidl2.project.ProjectService/GetProject" + ProjectService_ListProjects_FullMethodName = "/flyteidl2.project.ProjectService/ListProjects" +) + +// ProjectServiceClient is the client API for ProjectService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type ProjectServiceClient interface { + CreateProject(ctx context.Context, in *CreateProjectRequest, opts ...grpc.CallOption) (*CreateProjectResponse, error) + // it will be ignored in the handler as domains cannot be updated via this API. + UpdateProject(ctx context.Context, in *UpdateProjectRequest, opts ...grpc.CallOption) (*UpdateProjectResponse, error) + GetProject(ctx context.Context, in *GetProjectRequest, opts ...grpc.CallOption) (*GetProjectResponse, error) + ListProjects(ctx context.Context, in *ListProjectsRequest, opts ...grpc.CallOption) (*ListProjectsResponse, error) +} + +type projectServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewProjectServiceClient(cc grpc.ClientConnInterface) ProjectServiceClient { + return &projectServiceClient{cc} +} + +func (c *projectServiceClient) CreateProject(ctx context.Context, in *CreateProjectRequest, opts ...grpc.CallOption) (*CreateProjectResponse, error) { + out := new(CreateProjectResponse) + err := c.cc.Invoke(ctx, ProjectService_CreateProject_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *projectServiceClient) UpdateProject(ctx context.Context, in *UpdateProjectRequest, opts ...grpc.CallOption) (*UpdateProjectResponse, error) { + out := new(UpdateProjectResponse) + err := c.cc.Invoke(ctx, ProjectService_UpdateProject_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *projectServiceClient) GetProject(ctx context.Context, in *GetProjectRequest, opts ...grpc.CallOption) (*GetProjectResponse, error) { + out := new(GetProjectResponse) + err := c.cc.Invoke(ctx, ProjectService_GetProject_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *projectServiceClient) ListProjects(ctx context.Context, in *ListProjectsRequest, opts ...grpc.CallOption) (*ListProjectsResponse, error) { + out := new(ListProjectsResponse) + err := c.cc.Invoke(ctx, ProjectService_ListProjects_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// ProjectServiceServer is the server API for ProjectService service. +// All implementations should embed UnimplementedProjectServiceServer +// for forward compatibility +type ProjectServiceServer interface { + CreateProject(context.Context, *CreateProjectRequest) (*CreateProjectResponse, error) + // it will be ignored in the handler as domains cannot be updated via this API. + UpdateProject(context.Context, *UpdateProjectRequest) (*UpdateProjectResponse, error) + GetProject(context.Context, *GetProjectRequest) (*GetProjectResponse, error) + ListProjects(context.Context, *ListProjectsRequest) (*ListProjectsResponse, error) +} + +// UnimplementedProjectServiceServer should be embedded to have forward compatible implementations. +type UnimplementedProjectServiceServer struct { +} + +func (UnimplementedProjectServiceServer) CreateProject(context.Context, *CreateProjectRequest) (*CreateProjectResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CreateProject not implemented") +} +func (UnimplementedProjectServiceServer) UpdateProject(context.Context, *UpdateProjectRequest) (*UpdateProjectResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateProject not implemented") +} +func (UnimplementedProjectServiceServer) GetProject(context.Context, *GetProjectRequest) (*GetProjectResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetProject not implemented") +} +func (UnimplementedProjectServiceServer) ListProjects(context.Context, *ListProjectsRequest) (*ListProjectsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ListProjects not implemented") +} + +// UnsafeProjectServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to ProjectServiceServer will +// result in compilation errors. +type UnsafeProjectServiceServer interface { + mustEmbedUnimplementedProjectServiceServer() +} + +func RegisterProjectServiceServer(s grpc.ServiceRegistrar, srv ProjectServiceServer) { + s.RegisterService(&ProjectService_ServiceDesc, srv) +} + +func _ProjectService_CreateProject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CreateProjectRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProjectServiceServer).CreateProject(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProjectService_CreateProject_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProjectServiceServer).CreateProject(ctx, req.(*CreateProjectRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ProjectService_UpdateProject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateProjectRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProjectServiceServer).UpdateProject(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProjectService_UpdateProject_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProjectServiceServer).UpdateProject(ctx, req.(*UpdateProjectRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ProjectService_GetProject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetProjectRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProjectServiceServer).GetProject(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProjectService_GetProject_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProjectServiceServer).GetProject(ctx, req.(*GetProjectRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ProjectService_ListProjects_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListProjectsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProjectServiceServer).ListProjects(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProjectService_ListProjects_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProjectServiceServer).ListProjects(ctx, req.(*ListProjectsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// ProjectService_ServiceDesc is the grpc.ServiceDesc for ProjectService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var ProjectService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.project.ProjectService", + HandlerType: (*ProjectServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "CreateProject", + Handler: _ProjectService_CreateProject_Handler, + }, + { + MethodName: "UpdateProject", + Handler: _ProjectService_UpdateProject_Handler, + }, + { + MethodName: "GetProject", + Handler: _ProjectService_GetProject_Handler, + }, + { + MethodName: "ListProjects", + Handler: _ProjectService_ListProjects_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "flyteidl2/project/project_service.proto", +} diff --git a/gen/go/flyteidl2/project/projectconnect/project_service.connect.go b/gen/go/flyteidl2/project/projectconnect/project_service.connect.go new file mode 100644 index 0000000000..60ad763f24 --- /dev/null +++ b/gen/go/flyteidl2/project/projectconnect/project_service.connect.go @@ -0,0 +1,207 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: flyteidl2/project/project_service.proto + +package projectconnect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + project "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/project" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // ProjectServiceName is the fully-qualified name of the ProjectService service. + ProjectServiceName = "flyteidl2.project.ProjectService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // ProjectServiceCreateProjectProcedure is the fully-qualified name of the ProjectService's + // CreateProject RPC. + ProjectServiceCreateProjectProcedure = "/flyteidl2.project.ProjectService/CreateProject" + // ProjectServiceUpdateProjectProcedure is the fully-qualified name of the ProjectService's + // UpdateProject RPC. + ProjectServiceUpdateProjectProcedure = "/flyteidl2.project.ProjectService/UpdateProject" + // ProjectServiceGetProjectProcedure is the fully-qualified name of the ProjectService's GetProject + // RPC. + ProjectServiceGetProjectProcedure = "/flyteidl2.project.ProjectService/GetProject" + // ProjectServiceListProjectsProcedure is the fully-qualified name of the ProjectService's + // ListProjects RPC. + ProjectServiceListProjectsProcedure = "/flyteidl2.project.ProjectService/ListProjects" +) + +// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. +var ( + projectServiceServiceDescriptor = project.File_flyteidl2_project_project_service_proto.Services().ByName("ProjectService") + projectServiceCreateProjectMethodDescriptor = projectServiceServiceDescriptor.Methods().ByName("CreateProject") + projectServiceUpdateProjectMethodDescriptor = projectServiceServiceDescriptor.Methods().ByName("UpdateProject") + projectServiceGetProjectMethodDescriptor = projectServiceServiceDescriptor.Methods().ByName("GetProject") + projectServiceListProjectsMethodDescriptor = projectServiceServiceDescriptor.Methods().ByName("ListProjects") +) + +// ProjectServiceClient is a client for the flyteidl2.project.ProjectService service. +type ProjectServiceClient interface { + CreateProject(context.Context, *connect.Request[project.CreateProjectRequest]) (*connect.Response[project.CreateProjectResponse], error) + // it will be ignored in the handler as domains cannot be updated via this API. + UpdateProject(context.Context, *connect.Request[project.UpdateProjectRequest]) (*connect.Response[project.UpdateProjectResponse], error) + GetProject(context.Context, *connect.Request[project.GetProjectRequest]) (*connect.Response[project.GetProjectResponse], error) + ListProjects(context.Context, *connect.Request[project.ListProjectsRequest]) (*connect.Response[project.ListProjectsResponse], error) +} + +// NewProjectServiceClient constructs a client for the flyteidl2.project.ProjectService service. By +// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, +// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the +// connect.WithGRPC() or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewProjectServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) ProjectServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &projectServiceClient{ + createProject: connect.NewClient[project.CreateProjectRequest, project.CreateProjectResponse]( + httpClient, + baseURL+ProjectServiceCreateProjectProcedure, + connect.WithSchema(projectServiceCreateProjectMethodDescriptor), + connect.WithClientOptions(opts...), + ), + updateProject: connect.NewClient[project.UpdateProjectRequest, project.UpdateProjectResponse]( + httpClient, + baseURL+ProjectServiceUpdateProjectProcedure, + connect.WithSchema(projectServiceUpdateProjectMethodDescriptor), + connect.WithClientOptions(opts...), + ), + getProject: connect.NewClient[project.GetProjectRequest, project.GetProjectResponse]( + httpClient, + baseURL+ProjectServiceGetProjectProcedure, + connect.WithSchema(projectServiceGetProjectMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + listProjects: connect.NewClient[project.ListProjectsRequest, project.ListProjectsResponse]( + httpClient, + baseURL+ProjectServiceListProjectsProcedure, + connect.WithSchema(projectServiceListProjectsMethodDescriptor), + connect.WithClientOptions(opts...), + ), + } +} + +// projectServiceClient implements ProjectServiceClient. +type projectServiceClient struct { + createProject *connect.Client[project.CreateProjectRequest, project.CreateProjectResponse] + updateProject *connect.Client[project.UpdateProjectRequest, project.UpdateProjectResponse] + getProject *connect.Client[project.GetProjectRequest, project.GetProjectResponse] + listProjects *connect.Client[project.ListProjectsRequest, project.ListProjectsResponse] +} + +// CreateProject calls flyteidl2.project.ProjectService.CreateProject. +func (c *projectServiceClient) CreateProject(ctx context.Context, req *connect.Request[project.CreateProjectRequest]) (*connect.Response[project.CreateProjectResponse], error) { + return c.createProject.CallUnary(ctx, req) +} + +// UpdateProject calls flyteidl2.project.ProjectService.UpdateProject. +func (c *projectServiceClient) UpdateProject(ctx context.Context, req *connect.Request[project.UpdateProjectRequest]) (*connect.Response[project.UpdateProjectResponse], error) { + return c.updateProject.CallUnary(ctx, req) +} + +// GetProject calls flyteidl2.project.ProjectService.GetProject. +func (c *projectServiceClient) GetProject(ctx context.Context, req *connect.Request[project.GetProjectRequest]) (*connect.Response[project.GetProjectResponse], error) { + return c.getProject.CallUnary(ctx, req) +} + +// ListProjects calls flyteidl2.project.ProjectService.ListProjects. +func (c *projectServiceClient) ListProjects(ctx context.Context, req *connect.Request[project.ListProjectsRequest]) (*connect.Response[project.ListProjectsResponse], error) { + return c.listProjects.CallUnary(ctx, req) +} + +// ProjectServiceHandler is an implementation of the flyteidl2.project.ProjectService service. +type ProjectServiceHandler interface { + CreateProject(context.Context, *connect.Request[project.CreateProjectRequest]) (*connect.Response[project.CreateProjectResponse], error) + // it will be ignored in the handler as domains cannot be updated via this API. + UpdateProject(context.Context, *connect.Request[project.UpdateProjectRequest]) (*connect.Response[project.UpdateProjectResponse], error) + GetProject(context.Context, *connect.Request[project.GetProjectRequest]) (*connect.Response[project.GetProjectResponse], error) + ListProjects(context.Context, *connect.Request[project.ListProjectsRequest]) (*connect.Response[project.ListProjectsResponse], error) +} + +// NewProjectServiceHandler builds an HTTP handler from the service implementation. It returns the +// path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewProjectServiceHandler(svc ProjectServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + projectServiceCreateProjectHandler := connect.NewUnaryHandler( + ProjectServiceCreateProjectProcedure, + svc.CreateProject, + connect.WithSchema(projectServiceCreateProjectMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + projectServiceUpdateProjectHandler := connect.NewUnaryHandler( + ProjectServiceUpdateProjectProcedure, + svc.UpdateProject, + connect.WithSchema(projectServiceUpdateProjectMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + projectServiceGetProjectHandler := connect.NewUnaryHandler( + ProjectServiceGetProjectProcedure, + svc.GetProject, + connect.WithSchema(projectServiceGetProjectMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + projectServiceListProjectsHandler := connect.NewUnaryHandler( + ProjectServiceListProjectsProcedure, + svc.ListProjects, + connect.WithSchema(projectServiceListProjectsMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.project.ProjectService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case ProjectServiceCreateProjectProcedure: + projectServiceCreateProjectHandler.ServeHTTP(w, r) + case ProjectServiceUpdateProjectProcedure: + projectServiceUpdateProjectHandler.ServeHTTP(w, r) + case ProjectServiceGetProjectProcedure: + projectServiceGetProjectHandler.ServeHTTP(w, r) + case ProjectServiceListProjectsProcedure: + projectServiceListProjectsHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedProjectServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedProjectServiceHandler struct{} + +func (UnimplementedProjectServiceHandler) CreateProject(context.Context, *connect.Request[project.CreateProjectRequest]) (*connect.Response[project.CreateProjectResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.project.ProjectService.CreateProject is not implemented")) +} + +func (UnimplementedProjectServiceHandler) UpdateProject(context.Context, *connect.Request[project.UpdateProjectRequest]) (*connect.Response[project.UpdateProjectResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.project.ProjectService.UpdateProject is not implemented")) +} + +func (UnimplementedProjectServiceHandler) GetProject(context.Context, *connect.Request[project.GetProjectRequest]) (*connect.Response[project.GetProjectResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.project.ProjectService.GetProject is not implemented")) +} + +func (UnimplementedProjectServiceHandler) ListProjects(context.Context, *connect.Request[project.ListProjectsRequest]) (*connect.Response[project.ListProjectsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.project.ProjectService.ListProjects is not implemented")) +} diff --git a/gen/go/flyteidl2/secret/definition.pb.go b/gen/go/flyteidl2/secret/definition.pb.go new file mode 100644 index 0000000000..bd362ce80e --- /dev/null +++ b/gen/go/flyteidl2/secret/definition.pb.go @@ -0,0 +1,838 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/secret/definition.proto + +package secret + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type SecretType int32 + +const ( + // Default, unspecified secret type. Assumed to be generic and no type specific handling required. + SecretType_SECRET_TYPE_GENERIC SecretType = 0 + // Secret used specifically for pulling images from a container registry. + SecretType_SECRET_TYPE_IMAGE_PULL_SECRET SecretType = 1 +) + +// Enum value maps for SecretType. +var ( + SecretType_name = map[int32]string{ + 0: "SECRET_TYPE_GENERIC", + 1: "SECRET_TYPE_IMAGE_PULL_SECRET", + } + SecretType_value = map[string]int32{ + "SECRET_TYPE_GENERIC": 0, + "SECRET_TYPE_IMAGE_PULL_SECRET": 1, + } +) + +func (x SecretType) Enum() *SecretType { + p := new(SecretType) + *p = x + return p +} + +func (x SecretType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (SecretType) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_secret_definition_proto_enumTypes[0].Descriptor() +} + +func (SecretType) Type() protoreflect.EnumType { + return &file_flyteidl2_secret_definition_proto_enumTypes[0] +} + +func (x SecretType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use SecretType.Descriptor instead. +func (SecretType) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_secret_definition_proto_rawDescGZIP(), []int{0} +} + +type OverallStatus int32 + +const ( + OverallStatus_UNSPECIFIED OverallStatus = 0 + OverallStatus_PARTIALLY_PRESENT OverallStatus = 1 // Exists in some cluster + OverallStatus_FULLY_PRESENT OverallStatus = 2 // Exists in all enabled clusters + OverallStatus_UNKNOWN_STATUS OverallStatus = 3 // Status is unknown +) + +// Enum value maps for OverallStatus. +var ( + OverallStatus_name = map[int32]string{ + 0: "UNSPECIFIED", + 1: "PARTIALLY_PRESENT", + 2: "FULLY_PRESENT", + 3: "UNKNOWN_STATUS", + } + OverallStatus_value = map[string]int32{ + "UNSPECIFIED": 0, + "PARTIALLY_PRESENT": 1, + "FULLY_PRESENT": 2, + "UNKNOWN_STATUS": 3, + } +) + +func (x OverallStatus) Enum() *OverallStatus { + p := new(OverallStatus) + *p = x + return p +} + +func (x OverallStatus) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (OverallStatus) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_secret_definition_proto_enumTypes[1].Descriptor() +} + +func (OverallStatus) Type() protoreflect.EnumType { + return &file_flyteidl2_secret_definition_proto_enumTypes[1] +} + +func (x OverallStatus) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use OverallStatus.Descriptor instead. +func (OverallStatus) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_secret_definition_proto_rawDescGZIP(), []int{1} +} + +type SecretPresenceStatus int32 + +const ( + SecretPresenceStatus_UNKNOWN SecretPresenceStatus = 0 + SecretPresenceStatus_MISSING SecretPresenceStatus = 1 // Secret is missing in the cluster + SecretPresenceStatus_PRESENT SecretPresenceStatus = 2 // Secret is present in the cluster +) + +// Enum value maps for SecretPresenceStatus. +var ( + SecretPresenceStatus_name = map[int32]string{ + 0: "UNKNOWN", + 1: "MISSING", + 2: "PRESENT", + } + SecretPresenceStatus_value = map[string]int32{ + "UNKNOWN": 0, + "MISSING": 1, + "PRESENT": 2, + } +) + +func (x SecretPresenceStatus) Enum() *SecretPresenceStatus { + p := new(SecretPresenceStatus) + *p = x + return p +} + +func (x SecretPresenceStatus) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (SecretPresenceStatus) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_secret_definition_proto_enumTypes[2].Descriptor() +} + +func (SecretPresenceStatus) Type() protoreflect.EnumType { + return &file_flyteidl2_secret_definition_proto_enumTypes[2] +} + +func (x SecretPresenceStatus) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use SecretPresenceStatus.Descriptor instead. +func (SecretPresenceStatus) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_secret_definition_proto_rawDescGZIP(), []int{2} +} + +// SecretSpec contains information used for creating/updating the secret. +// Mainly it contains the value of the secret +// In future we could add meta info like tags, rotation config, whether stored secret has any binary format etc for storage/retrieval. +type SecretSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Value: + // + // *SecretSpec_StringValue + // *SecretSpec_BinaryValue + Value isSecretSpec_Value `protobuf_oneof:"value"` + // The secret type + Type SecretType `protobuf:"varint,3,opt,name=type,proto3,enum=flyteidl2.secret.SecretType" json:"type,omitempty"` +} + +func (x *SecretSpec) Reset() { + *x = SecretSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_secret_definition_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SecretSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SecretSpec) ProtoMessage() {} + +func (x *SecretSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_secret_definition_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SecretSpec.ProtoReflect.Descriptor instead. +func (*SecretSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_secret_definition_proto_rawDescGZIP(), []int{0} +} + +func (m *SecretSpec) GetValue() isSecretSpec_Value { + if m != nil { + return m.Value + } + return nil +} + +func (x *SecretSpec) GetStringValue() string { + if x, ok := x.GetValue().(*SecretSpec_StringValue); ok { + return x.StringValue + } + return "" +} + +func (x *SecretSpec) GetBinaryValue() []byte { + if x, ok := x.GetValue().(*SecretSpec_BinaryValue); ok { + return x.BinaryValue + } + return nil +} + +func (x *SecretSpec) GetType() SecretType { + if x != nil { + return x.Type + } + return SecretType_SECRET_TYPE_GENERIC +} + +type isSecretSpec_Value interface { + isSecretSpec_Value() +} + +type SecretSpec_StringValue struct { + StringValue string `protobuf:"bytes,1,opt,name=string_value,json=stringValue,proto3,oneof"` +} + +type SecretSpec_BinaryValue struct { + BinaryValue []byte `protobuf:"bytes,2,opt,name=binary_value,json=binaryValue,proto3,oneof"` +} + +func (*SecretSpec_StringValue) isSecretSpec_Value() {} + +func (*SecretSpec_BinaryValue) isSecretSpec_Value() {} + +// SecretIdentifier contains the uniquely identifiable way of storing or retrieving the secret +// Name and scope combination are used for defining the format for storage and retrieval of the secret +// For eg : for org scope secrets +// storage format org::name:secret-name +type SecretIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Only org scoped resources are supported right now + Organization string `protobuf:"bytes,2,opt,name=organization,proto3" json:"organization,omitempty"` + // domain scoped secret + Domain string `protobuf:"bytes,3,opt,name=domain,proto3" json:"domain,omitempty"` + // Project-domain scoped secret + Project string `protobuf:"bytes,4,opt,name=project,proto3" json:"project,omitempty"` +} + +func (x *SecretIdentifier) Reset() { + *x = SecretIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_secret_definition_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SecretIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SecretIdentifier) ProtoMessage() {} + +func (x *SecretIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_secret_definition_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SecretIdentifier.ProtoReflect.Descriptor instead. +func (*SecretIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_secret_definition_proto_rawDescGZIP(), []int{1} +} + +func (x *SecretIdentifier) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *SecretIdentifier) GetOrganization() string { + if x != nil { + return x.Organization + } + return "" +} + +func (x *SecretIdentifier) GetDomain() string { + if x != nil { + return x.Domain + } + return "" +} + +func (x *SecretIdentifier) GetProject() string { + if x != nil { + return x.Project + } + return "" +} + +// SecretMetadata contain meta info about the secret +type SecretMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // created_time of the secret. + CreatedTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=created_time,json=createdTime,proto3" json:"created_time,omitempty"` + // secret_status reports the overall status of the secret across all the clusters. + // This relies on number of clusters queried which relies on there enabled state. + SecretStatus *SecretStatus `protobuf:"bytes,2,opt,name=secret_status,json=secretStatus,proto3" json:"secret_status,omitempty"` + // The secret type + Type SecretType `protobuf:"varint,3,opt,name=type,proto3,enum=flyteidl2.secret.SecretType" json:"type,omitempty"` +} + +func (x *SecretMetadata) Reset() { + *x = SecretMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_secret_definition_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SecretMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SecretMetadata) ProtoMessage() {} + +func (x *SecretMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_secret_definition_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SecretMetadata.ProtoReflect.Descriptor instead. +func (*SecretMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_secret_definition_proto_rawDescGZIP(), []int{2} +} + +func (x *SecretMetadata) GetCreatedTime() *timestamppb.Timestamp { + if x != nil { + return x.CreatedTime + } + return nil +} + +func (x *SecretMetadata) GetSecretStatus() *SecretStatus { + if x != nil { + return x.SecretStatus + } + return nil +} + +func (x *SecretMetadata) GetType() SecretType { + if x != nil { + return x.Type + } + return SecretType_SECRET_TYPE_GENERIC +} + +// SecretStatus contains the status of the secret across all the clusters +type SecretStatus struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // overall_status reports the overall status of the secret across all the clusters. + OverallStatus OverallStatus `protobuf:"varint,1,opt,name=overall_status,json=overallStatus,proto3,enum=flyteidl2.secret.OverallStatus" json:"overall_status,omitempty"` + // cluster_status reports the status of the secret in each cluster + ClusterStatus []*ClusterSecretStatus `protobuf:"bytes,2,rep,name=cluster_status,json=clusterStatus,proto3" json:"cluster_status,omitempty"` +} + +func (x *SecretStatus) Reset() { + *x = SecretStatus{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_secret_definition_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SecretStatus) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SecretStatus) ProtoMessage() {} + +func (x *SecretStatus) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_secret_definition_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SecretStatus.ProtoReflect.Descriptor instead. +func (*SecretStatus) Descriptor() ([]byte, []int) { + return file_flyteidl2_secret_definition_proto_rawDescGZIP(), []int{3} +} + +func (x *SecretStatus) GetOverallStatus() OverallStatus { + if x != nil { + return x.OverallStatus + } + return OverallStatus_UNSPECIFIED +} + +func (x *SecretStatus) GetClusterStatus() []*ClusterSecretStatus { + if x != nil { + return x.ClusterStatus + } + return nil +} + +// ClusterSecretStatus contains the status of the secret in a cluster +type ClusterSecretStatus struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Cluster *common.ClusterIdentifier `protobuf:"bytes,1,opt,name=cluster,proto3" json:"cluster,omitempty"` + // presence_status reports the status of the secret in the cluster + PresenceStatus SecretPresenceStatus `protobuf:"varint,2,opt,name=presence_status,json=presenceStatus,proto3,enum=flyteidl2.secret.SecretPresenceStatus" json:"presence_status,omitempty"` +} + +func (x *ClusterSecretStatus) Reset() { + *x = ClusterSecretStatus{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_secret_definition_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ClusterSecretStatus) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ClusterSecretStatus) ProtoMessage() {} + +func (x *ClusterSecretStatus) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_secret_definition_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ClusterSecretStatus.ProtoReflect.Descriptor instead. +func (*ClusterSecretStatus) Descriptor() ([]byte, []int) { + return file_flyteidl2_secret_definition_proto_rawDescGZIP(), []int{4} +} + +func (x *ClusterSecretStatus) GetCluster() *common.ClusterIdentifier { + if x != nil { + return x.Cluster + } + return nil +} + +func (x *ClusterSecretStatus) GetPresenceStatus() SecretPresenceStatus { + if x != nil { + return x.PresenceStatus + } + return SecretPresenceStatus_UNKNOWN +} + +// Secret is the returned object for Get and List calls which returns the identifier of the secret along with +// meta information in future about the creation data, update date, tags etc +// This doesn't contain the value of the secret +type Secret struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id *SecretIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + SecretMetadata *SecretMetadata `protobuf:"bytes,2,opt,name=secret_metadata,json=secretMetadata,proto3" json:"secret_metadata,omitempty"` +} + +func (x *Secret) Reset() { + *x = Secret{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_secret_definition_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Secret) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Secret) ProtoMessage() {} + +func (x *Secret) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_secret_definition_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Secret.ProtoReflect.Descriptor instead. +func (*Secret) Descriptor() ([]byte, []int) { + return file_flyteidl2_secret_definition_proto_rawDescGZIP(), []int{5} +} + +func (x *Secret) GetId() *SecretIdentifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *Secret) GetSecretMetadata() *SecretMetadata { + if x != nil { + return x.SecretMetadata + } + return nil +} + +var File_flyteidl2_secret_definition_proto protoreflect.FileDescriptor + +var file_flyteidl2_secret_definition_proto_rawDesc = []byte{ + 0x0a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x2f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x98, 0x01, 0x0a, 0x0a, 0x53, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x53, 0x70, 0x65, 0x63, 0x12, 0x23, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x73, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x62, 0x69, + 0x6e, 0x61, 0x72, 0x79, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, + 0x48, 0x00, 0x52, 0x0b, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, + 0x30, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, + 0x65, 0x42, 0x0e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, + 0x01, 0x22, 0x97, 0x01, 0x0a, 0x10, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x2d, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x19, 0xba, 0x48, 0x16, 0x72, 0x14, 0x10, 0x01, 0x32, 0x10, 0x5e, + 0x5b, 0x2d, 0x61, 0x2d, 0x7a, 0x41, 0x2d, 0x5a, 0x30, 0x2d, 0x39, 0x5f, 0x5d, 0x2b, 0x24, 0x52, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x22, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, 0x72, 0x67, + 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x6f, 0x6d, + 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, + 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x22, 0xc6, 0x01, 0x0a, 0x0e, + 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x3d, + 0x0a, 0x0c, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x52, 0x0b, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x43, 0x0a, + 0x0d, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x52, 0x0c, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x12, 0x30, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, + 0x74, 0x79, 0x70, 0x65, 0x22, 0xa4, 0x01, 0x0a, 0x0c, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x46, 0x0a, 0x0e, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x6c, + 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1f, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x2e, 0x4f, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x0d, + 0x6f, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x4c, 0x0a, + 0x0e, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x0d, 0x63, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0xa5, 0x01, 0x0a, 0x13, + 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x12, 0x3d, 0x0a, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x12, 0x4f, 0x0a, 0x0f, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x53, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x52, 0x0e, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x22, 0x87, 0x01, 0x0a, 0x06, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x12, 0x32, + 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x53, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x02, + 0x69, 0x64, 0x12, 0x49, 0x0a, 0x0f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, 0x6d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x53, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x0e, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2a, 0x48, 0x0a, + 0x0a, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x17, 0x0a, 0x13, 0x53, + 0x45, 0x43, 0x52, 0x45, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x47, 0x45, 0x4e, 0x45, 0x52, + 0x49, 0x43, 0x10, 0x00, 0x12, 0x21, 0x0a, 0x1d, 0x53, 0x45, 0x43, 0x52, 0x45, 0x54, 0x5f, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4d, 0x41, 0x47, 0x45, 0x5f, 0x50, 0x55, 0x4c, 0x4c, 0x5f, 0x53, + 0x45, 0x43, 0x52, 0x45, 0x54, 0x10, 0x01, 0x2a, 0x5e, 0x0a, 0x0d, 0x4f, 0x76, 0x65, 0x72, 0x61, + 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0f, 0x0a, 0x0b, 0x55, 0x4e, 0x53, 0x50, + 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x15, 0x0a, 0x11, 0x50, 0x41, 0x52, + 0x54, 0x49, 0x41, 0x4c, 0x4c, 0x59, 0x5f, 0x50, 0x52, 0x45, 0x53, 0x45, 0x4e, 0x54, 0x10, 0x01, + 0x12, 0x11, 0x0a, 0x0d, 0x46, 0x55, 0x4c, 0x4c, 0x59, 0x5f, 0x50, 0x52, 0x45, 0x53, 0x45, 0x4e, + 0x54, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x5f, 0x53, + 0x54, 0x41, 0x54, 0x55, 0x53, 0x10, 0x03, 0x2a, 0x3d, 0x0a, 0x14, 0x53, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, + 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, + 0x4d, 0x49, 0x53, 0x53, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x50, 0x52, 0x45, + 0x53, 0x45, 0x4e, 0x54, 0x10, 0x02, 0x42, 0xc0, 0x01, 0x0a, 0x14, 0x63, 0x6f, 0x6d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x42, + 0x0f, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, + 0x48, 0x02, 0x50, 0x01, 0x5a, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, + 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, + 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0xa2, 0x02, 0x03, 0x46, 0x53, 0x58, + 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x53, 0x65, 0x63, + 0x72, 0x65, 0x74, 0xca, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, + 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0xe2, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x3a, 0x3a, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, +} + +var ( + file_flyteidl2_secret_definition_proto_rawDescOnce sync.Once + file_flyteidl2_secret_definition_proto_rawDescData = file_flyteidl2_secret_definition_proto_rawDesc +) + +func file_flyteidl2_secret_definition_proto_rawDescGZIP() []byte { + file_flyteidl2_secret_definition_proto_rawDescOnce.Do(func() { + file_flyteidl2_secret_definition_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_secret_definition_proto_rawDescData) + }) + return file_flyteidl2_secret_definition_proto_rawDescData +} + +var file_flyteidl2_secret_definition_proto_enumTypes = make([]protoimpl.EnumInfo, 3) +var file_flyteidl2_secret_definition_proto_msgTypes = make([]protoimpl.MessageInfo, 6) +var file_flyteidl2_secret_definition_proto_goTypes = []interface{}{ + (SecretType)(0), // 0: flyteidl2.secret.SecretType + (OverallStatus)(0), // 1: flyteidl2.secret.OverallStatus + (SecretPresenceStatus)(0), // 2: flyteidl2.secret.SecretPresenceStatus + (*SecretSpec)(nil), // 3: flyteidl2.secret.SecretSpec + (*SecretIdentifier)(nil), // 4: flyteidl2.secret.SecretIdentifier + (*SecretMetadata)(nil), // 5: flyteidl2.secret.SecretMetadata + (*SecretStatus)(nil), // 6: flyteidl2.secret.SecretStatus + (*ClusterSecretStatus)(nil), // 7: flyteidl2.secret.ClusterSecretStatus + (*Secret)(nil), // 8: flyteidl2.secret.Secret + (*timestamppb.Timestamp)(nil), // 9: google.protobuf.Timestamp + (*common.ClusterIdentifier)(nil), // 10: flyteidl2.common.ClusterIdentifier +} +var file_flyteidl2_secret_definition_proto_depIdxs = []int32{ + 0, // 0: flyteidl2.secret.SecretSpec.type:type_name -> flyteidl2.secret.SecretType + 9, // 1: flyteidl2.secret.SecretMetadata.created_time:type_name -> google.protobuf.Timestamp + 6, // 2: flyteidl2.secret.SecretMetadata.secret_status:type_name -> flyteidl2.secret.SecretStatus + 0, // 3: flyteidl2.secret.SecretMetadata.type:type_name -> flyteidl2.secret.SecretType + 1, // 4: flyteidl2.secret.SecretStatus.overall_status:type_name -> flyteidl2.secret.OverallStatus + 7, // 5: flyteidl2.secret.SecretStatus.cluster_status:type_name -> flyteidl2.secret.ClusterSecretStatus + 10, // 6: flyteidl2.secret.ClusterSecretStatus.cluster:type_name -> flyteidl2.common.ClusterIdentifier + 2, // 7: flyteidl2.secret.ClusterSecretStatus.presence_status:type_name -> flyteidl2.secret.SecretPresenceStatus + 4, // 8: flyteidl2.secret.Secret.id:type_name -> flyteidl2.secret.SecretIdentifier + 5, // 9: flyteidl2.secret.Secret.secret_metadata:type_name -> flyteidl2.secret.SecretMetadata + 10, // [10:10] is the sub-list for method output_type + 10, // [10:10] is the sub-list for method input_type + 10, // [10:10] is the sub-list for extension type_name + 10, // [10:10] is the sub-list for extension extendee + 0, // [0:10] is the sub-list for field type_name +} + +func init() { file_flyteidl2_secret_definition_proto_init() } +func file_flyteidl2_secret_definition_proto_init() { + if File_flyteidl2_secret_definition_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_secret_definition_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SecretSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_secret_definition_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SecretIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_secret_definition_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SecretMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_secret_definition_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SecretStatus); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_secret_definition_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ClusterSecretStatus); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_secret_definition_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Secret); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_secret_definition_proto_msgTypes[0].OneofWrappers = []interface{}{ + (*SecretSpec_StringValue)(nil), + (*SecretSpec_BinaryValue)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_secret_definition_proto_rawDesc, + NumEnums: 3, + NumMessages: 6, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_secret_definition_proto_goTypes, + DependencyIndexes: file_flyteidl2_secret_definition_proto_depIdxs, + EnumInfos: file_flyteidl2_secret_definition_proto_enumTypes, + MessageInfos: file_flyteidl2_secret_definition_proto_msgTypes, + }.Build() + File_flyteidl2_secret_definition_proto = out.File + file_flyteidl2_secret_definition_proto_rawDesc = nil + file_flyteidl2_secret_definition_proto_goTypes = nil + file_flyteidl2_secret_definition_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/secret/definition.pb.validate.go b/gen/go/flyteidl2/secret/definition.pb.validate.go new file mode 100644 index 0000000000..1c36249eeb --- /dev/null +++ b/gen/go/flyteidl2/secret/definition.pb.validate.go @@ -0,0 +1,858 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/secret/definition.proto + +package secret + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on SecretSpec with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *SecretSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on SecretSpec with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in SecretSpecMultiError, or +// nil if none found. +func (m *SecretSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *SecretSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Type + + switch v := m.Value.(type) { + case *SecretSpec_StringValue: + if v == nil { + err := SecretSpecValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for StringValue + case *SecretSpec_BinaryValue: + if v == nil { + err := SecretSpecValidationError{ + field: "Value", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for BinaryValue + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return SecretSpecMultiError(errors) + } + + return nil +} + +// SecretSpecMultiError is an error wrapping multiple validation errors +// returned by SecretSpec.ValidateAll() if the designated constraints aren't met. +type SecretSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SecretSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SecretSpecMultiError) AllErrors() []error { return m } + +// SecretSpecValidationError is the validation error returned by +// SecretSpec.Validate if the designated constraints aren't met. +type SecretSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SecretSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SecretSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SecretSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SecretSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SecretSpecValidationError) ErrorName() string { return "SecretSpecValidationError" } + +// Error satisfies the builtin error interface +func (e SecretSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSecretSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SecretSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SecretSpecValidationError{} + +// Validate checks the field values on SecretIdentifier with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *SecretIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on SecretIdentifier with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// SecretIdentifierMultiError, or nil if none found. +func (m *SecretIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *SecretIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + // no validation rules for Organization + + // no validation rules for Domain + + // no validation rules for Project + + if len(errors) > 0 { + return SecretIdentifierMultiError(errors) + } + + return nil +} + +// SecretIdentifierMultiError is an error wrapping multiple validation errors +// returned by SecretIdentifier.ValidateAll() if the designated constraints +// aren't met. +type SecretIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SecretIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SecretIdentifierMultiError) AllErrors() []error { return m } + +// SecretIdentifierValidationError is the validation error returned by +// SecretIdentifier.Validate if the designated constraints aren't met. +type SecretIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SecretIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SecretIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SecretIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SecretIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SecretIdentifierValidationError) ErrorName() string { return "SecretIdentifierValidationError" } + +// Error satisfies the builtin error interface +func (e SecretIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSecretIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SecretIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SecretIdentifierValidationError{} + +// Validate checks the field values on SecretMetadata with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *SecretMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on SecretMetadata with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in SecretMetadataMultiError, +// or nil if none found. +func (m *SecretMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *SecretMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetCreatedTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SecretMetadataValidationError{ + field: "CreatedTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SecretMetadataValidationError{ + field: "CreatedTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCreatedTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SecretMetadataValidationError{ + field: "CreatedTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetSecretStatus()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SecretMetadataValidationError{ + field: "SecretStatus", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SecretMetadataValidationError{ + field: "SecretStatus", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSecretStatus()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SecretMetadataValidationError{ + field: "SecretStatus", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Type + + if len(errors) > 0 { + return SecretMetadataMultiError(errors) + } + + return nil +} + +// SecretMetadataMultiError is an error wrapping multiple validation errors +// returned by SecretMetadata.ValidateAll() if the designated constraints +// aren't met. +type SecretMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SecretMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SecretMetadataMultiError) AllErrors() []error { return m } + +// SecretMetadataValidationError is the validation error returned by +// SecretMetadata.Validate if the designated constraints aren't met. +type SecretMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SecretMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SecretMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SecretMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SecretMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SecretMetadataValidationError) ErrorName() string { return "SecretMetadataValidationError" } + +// Error satisfies the builtin error interface +func (e SecretMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSecretMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SecretMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SecretMetadataValidationError{} + +// Validate checks the field values on SecretStatus with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *SecretStatus) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on SecretStatus with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in SecretStatusMultiError, or +// nil if none found. +func (m *SecretStatus) ValidateAll() error { + return m.validate(true) +} + +func (m *SecretStatus) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for OverallStatus + + for idx, item := range m.GetClusterStatus() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SecretStatusValidationError{ + field: fmt.Sprintf("ClusterStatus[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SecretStatusValidationError{ + field: fmt.Sprintf("ClusterStatus[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SecretStatusValidationError{ + field: fmt.Sprintf("ClusterStatus[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return SecretStatusMultiError(errors) + } + + return nil +} + +// SecretStatusMultiError is an error wrapping multiple validation errors +// returned by SecretStatus.ValidateAll() if the designated constraints aren't met. +type SecretStatusMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SecretStatusMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SecretStatusMultiError) AllErrors() []error { return m } + +// SecretStatusValidationError is the validation error returned by +// SecretStatus.Validate if the designated constraints aren't met. +type SecretStatusValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SecretStatusValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SecretStatusValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SecretStatusValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SecretStatusValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SecretStatusValidationError) ErrorName() string { return "SecretStatusValidationError" } + +// Error satisfies the builtin error interface +func (e SecretStatusValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSecretStatus.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SecretStatusValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SecretStatusValidationError{} + +// Validate checks the field values on ClusterSecretStatus with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ClusterSecretStatus) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ClusterSecretStatus with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ClusterSecretStatusMultiError, or nil if none found. +func (m *ClusterSecretStatus) ValidateAll() error { + return m.validate(true) +} + +func (m *ClusterSecretStatus) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetCluster()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ClusterSecretStatusValidationError{ + field: "Cluster", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ClusterSecretStatusValidationError{ + field: "Cluster", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCluster()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ClusterSecretStatusValidationError{ + field: "Cluster", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for PresenceStatus + + if len(errors) > 0 { + return ClusterSecretStatusMultiError(errors) + } + + return nil +} + +// ClusterSecretStatusMultiError is an error wrapping multiple validation +// errors returned by ClusterSecretStatus.ValidateAll() if the designated +// constraints aren't met. +type ClusterSecretStatusMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ClusterSecretStatusMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ClusterSecretStatusMultiError) AllErrors() []error { return m } + +// ClusterSecretStatusValidationError is the validation error returned by +// ClusterSecretStatus.Validate if the designated constraints aren't met. +type ClusterSecretStatusValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ClusterSecretStatusValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ClusterSecretStatusValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ClusterSecretStatusValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ClusterSecretStatusValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ClusterSecretStatusValidationError) ErrorName() string { + return "ClusterSecretStatusValidationError" +} + +// Error satisfies the builtin error interface +func (e ClusterSecretStatusValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sClusterSecretStatus.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ClusterSecretStatusValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ClusterSecretStatusValidationError{} + +// Validate checks the field values on Secret with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Secret) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Secret with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in SecretMultiError, or nil if none found. +func (m *Secret) ValidateAll() error { + return m.validate(true) +} + +func (m *Secret) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SecretValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SecretValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SecretValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetSecretMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, SecretValidationError{ + field: "SecretMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, SecretValidationError{ + field: "SecretMetadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSecretMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return SecretValidationError{ + field: "SecretMetadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return SecretMultiError(errors) + } + + return nil +} + +// SecretMultiError is an error wrapping multiple validation errors returned by +// Secret.ValidateAll() if the designated constraints aren't met. +type SecretMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SecretMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SecretMultiError) AllErrors() []error { return m } + +// SecretValidationError is the validation error returned by Secret.Validate if +// the designated constraints aren't met. +type SecretValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SecretValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SecretValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SecretValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SecretValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SecretValidationError) ErrorName() string { return "SecretValidationError" } + +// Error satisfies the builtin error interface +func (e SecretValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSecret.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SecretValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SecretValidationError{} diff --git a/gen/go/flyteidl2/secret/mocks/is_secret_spec_value.go b/gen/go/flyteidl2/secret/mocks/is_secret_spec_value.go new file mode 100644 index 0000000000..f4d266f0e5 --- /dev/null +++ b/gen/go/flyteidl2/secret/mocks/is_secret_spec_value.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isSecretSpec_Value is an autogenerated mock type for the isSecretSpec_Value type +type isSecretSpec_Value struct { + mock.Mock +} + +type isSecretSpec_Value_Expecter struct { + mock *mock.Mock +} + +func (_m *isSecretSpec_Value) EXPECT() *isSecretSpec_Value_Expecter { + return &isSecretSpec_Value_Expecter{mock: &_m.Mock} +} + +// isSecretSpec_Value provides a mock function with no fields +func (_m *isSecretSpec_Value) isSecretSpec_Value() { + _m.Called() +} + +// isSecretSpec_Value_isSecretSpec_Value_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isSecretSpec_Value' +type isSecretSpec_Value_isSecretSpec_Value_Call struct { + *mock.Call +} + +// isSecretSpec_Value is a helper method to define mock.On call +func (_e *isSecretSpec_Value_Expecter) isSecretSpec_Value() *isSecretSpec_Value_isSecretSpec_Value_Call { + return &isSecretSpec_Value_isSecretSpec_Value_Call{Call: _e.mock.On("isSecretSpec_Value")} +} + +func (_c *isSecretSpec_Value_isSecretSpec_Value_Call) Run(run func()) *isSecretSpec_Value_isSecretSpec_Value_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isSecretSpec_Value_isSecretSpec_Value_Call) Return() *isSecretSpec_Value_isSecretSpec_Value_Call { + _c.Call.Return() + return _c +} + +func (_c *isSecretSpec_Value_isSecretSpec_Value_Call) RunAndReturn(run func()) *isSecretSpec_Value_isSecretSpec_Value_Call { + _c.Run(run) + return _c +} + +// newIsSecretSpec_Value creates a new instance of isSecretSpec_Value. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsSecretSpec_Value(t interface { + mock.TestingT + Cleanup(func()) +}) *isSecretSpec_Value { + mock := &isSecretSpec_Value{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/secret/mocks/secret_service_client.go b/gen/go/flyteidl2/secret/mocks/secret_service_client.go new file mode 100644 index 0000000000..b2db2f844b --- /dev/null +++ b/gen/go/flyteidl2/secret/mocks/secret_service_client.go @@ -0,0 +1,410 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + grpc "google.golang.org/grpc" + + mock "github.com/stretchr/testify/mock" + + secret "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/secret" +) + +// SecretServiceClient is an autogenerated mock type for the SecretServiceClient type +type SecretServiceClient struct { + mock.Mock +} + +type SecretServiceClient_Expecter struct { + mock *mock.Mock +} + +func (_m *SecretServiceClient) EXPECT() *SecretServiceClient_Expecter { + return &SecretServiceClient_Expecter{mock: &_m.Mock} +} + +// CreateSecret provides a mock function with given fields: ctx, in, opts +func (_m *SecretServiceClient) CreateSecret(ctx context.Context, in *secret.CreateSecretRequest, opts ...grpc.CallOption) (*secret.CreateSecretResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateSecret") + } + + var r0 *secret.CreateSecretResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *secret.CreateSecretRequest, ...grpc.CallOption) (*secret.CreateSecretResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *secret.CreateSecretRequest, ...grpc.CallOption) *secret.CreateSecretResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret.CreateSecretResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *secret.CreateSecretRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SecretServiceClient_CreateSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSecret' +type SecretServiceClient_CreateSecret_Call struct { + *mock.Call +} + +// CreateSecret is a helper method to define mock.On call +// - ctx context.Context +// - in *secret.CreateSecretRequest +// - opts ...grpc.CallOption +func (_e *SecretServiceClient_Expecter) CreateSecret(ctx interface{}, in interface{}, opts ...interface{}) *SecretServiceClient_CreateSecret_Call { + return &SecretServiceClient_CreateSecret_Call{Call: _e.mock.On("CreateSecret", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *SecretServiceClient_CreateSecret_Call) Run(run func(ctx context.Context, in *secret.CreateSecretRequest, opts ...grpc.CallOption)) *SecretServiceClient_CreateSecret_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*secret.CreateSecretRequest), variadicArgs...) + }) + return _c +} + +func (_c *SecretServiceClient_CreateSecret_Call) Return(_a0 *secret.CreateSecretResponse, _a1 error) *SecretServiceClient_CreateSecret_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SecretServiceClient_CreateSecret_Call) RunAndReturn(run func(context.Context, *secret.CreateSecretRequest, ...grpc.CallOption) (*secret.CreateSecretResponse, error)) *SecretServiceClient_CreateSecret_Call { + _c.Call.Return(run) + return _c +} + +// DeleteSecret provides a mock function with given fields: ctx, in, opts +func (_m *SecretServiceClient) DeleteSecret(ctx context.Context, in *secret.DeleteSecretRequest, opts ...grpc.CallOption) (*secret.DeleteSecretResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteSecret") + } + + var r0 *secret.DeleteSecretResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *secret.DeleteSecretRequest, ...grpc.CallOption) (*secret.DeleteSecretResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *secret.DeleteSecretRequest, ...grpc.CallOption) *secret.DeleteSecretResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret.DeleteSecretResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *secret.DeleteSecretRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SecretServiceClient_DeleteSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSecret' +type SecretServiceClient_DeleteSecret_Call struct { + *mock.Call +} + +// DeleteSecret is a helper method to define mock.On call +// - ctx context.Context +// - in *secret.DeleteSecretRequest +// - opts ...grpc.CallOption +func (_e *SecretServiceClient_Expecter) DeleteSecret(ctx interface{}, in interface{}, opts ...interface{}) *SecretServiceClient_DeleteSecret_Call { + return &SecretServiceClient_DeleteSecret_Call{Call: _e.mock.On("DeleteSecret", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *SecretServiceClient_DeleteSecret_Call) Run(run func(ctx context.Context, in *secret.DeleteSecretRequest, opts ...grpc.CallOption)) *SecretServiceClient_DeleteSecret_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*secret.DeleteSecretRequest), variadicArgs...) + }) + return _c +} + +func (_c *SecretServiceClient_DeleteSecret_Call) Return(_a0 *secret.DeleteSecretResponse, _a1 error) *SecretServiceClient_DeleteSecret_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SecretServiceClient_DeleteSecret_Call) RunAndReturn(run func(context.Context, *secret.DeleteSecretRequest, ...grpc.CallOption) (*secret.DeleteSecretResponse, error)) *SecretServiceClient_DeleteSecret_Call { + _c.Call.Return(run) + return _c +} + +// GetSecret provides a mock function with given fields: ctx, in, opts +func (_m *SecretServiceClient) GetSecret(ctx context.Context, in *secret.GetSecretRequest, opts ...grpc.CallOption) (*secret.GetSecretResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetSecret") + } + + var r0 *secret.GetSecretResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *secret.GetSecretRequest, ...grpc.CallOption) (*secret.GetSecretResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *secret.GetSecretRequest, ...grpc.CallOption) *secret.GetSecretResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret.GetSecretResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *secret.GetSecretRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SecretServiceClient_GetSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSecret' +type SecretServiceClient_GetSecret_Call struct { + *mock.Call +} + +// GetSecret is a helper method to define mock.On call +// - ctx context.Context +// - in *secret.GetSecretRequest +// - opts ...grpc.CallOption +func (_e *SecretServiceClient_Expecter) GetSecret(ctx interface{}, in interface{}, opts ...interface{}) *SecretServiceClient_GetSecret_Call { + return &SecretServiceClient_GetSecret_Call{Call: _e.mock.On("GetSecret", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *SecretServiceClient_GetSecret_Call) Run(run func(ctx context.Context, in *secret.GetSecretRequest, opts ...grpc.CallOption)) *SecretServiceClient_GetSecret_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*secret.GetSecretRequest), variadicArgs...) + }) + return _c +} + +func (_c *SecretServiceClient_GetSecret_Call) Return(_a0 *secret.GetSecretResponse, _a1 error) *SecretServiceClient_GetSecret_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SecretServiceClient_GetSecret_Call) RunAndReturn(run func(context.Context, *secret.GetSecretRequest, ...grpc.CallOption) (*secret.GetSecretResponse, error)) *SecretServiceClient_GetSecret_Call { + _c.Call.Return(run) + return _c +} + +// ListSecrets provides a mock function with given fields: ctx, in, opts +func (_m *SecretServiceClient) ListSecrets(ctx context.Context, in *secret.ListSecretsRequest, opts ...grpc.CallOption) (*secret.ListSecretsResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListSecrets") + } + + var r0 *secret.ListSecretsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *secret.ListSecretsRequest, ...grpc.CallOption) (*secret.ListSecretsResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *secret.ListSecretsRequest, ...grpc.CallOption) *secret.ListSecretsResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret.ListSecretsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *secret.ListSecretsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SecretServiceClient_ListSecrets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSecrets' +type SecretServiceClient_ListSecrets_Call struct { + *mock.Call +} + +// ListSecrets is a helper method to define mock.On call +// - ctx context.Context +// - in *secret.ListSecretsRequest +// - opts ...grpc.CallOption +func (_e *SecretServiceClient_Expecter) ListSecrets(ctx interface{}, in interface{}, opts ...interface{}) *SecretServiceClient_ListSecrets_Call { + return &SecretServiceClient_ListSecrets_Call{Call: _e.mock.On("ListSecrets", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *SecretServiceClient_ListSecrets_Call) Run(run func(ctx context.Context, in *secret.ListSecretsRequest, opts ...grpc.CallOption)) *SecretServiceClient_ListSecrets_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*secret.ListSecretsRequest), variadicArgs...) + }) + return _c +} + +func (_c *SecretServiceClient_ListSecrets_Call) Return(_a0 *secret.ListSecretsResponse, _a1 error) *SecretServiceClient_ListSecrets_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SecretServiceClient_ListSecrets_Call) RunAndReturn(run func(context.Context, *secret.ListSecretsRequest, ...grpc.CallOption) (*secret.ListSecretsResponse, error)) *SecretServiceClient_ListSecrets_Call { + _c.Call.Return(run) + return _c +} + +// UpdateSecret provides a mock function with given fields: ctx, in, opts +func (_m *SecretServiceClient) UpdateSecret(ctx context.Context, in *secret.UpdateSecretRequest, opts ...grpc.CallOption) (*secret.UpdateSecretResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpdateSecret") + } + + var r0 *secret.UpdateSecretResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *secret.UpdateSecretRequest, ...grpc.CallOption) (*secret.UpdateSecretResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *secret.UpdateSecretRequest, ...grpc.CallOption) *secret.UpdateSecretResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret.UpdateSecretResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *secret.UpdateSecretRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SecretServiceClient_UpdateSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSecret' +type SecretServiceClient_UpdateSecret_Call struct { + *mock.Call +} + +// UpdateSecret is a helper method to define mock.On call +// - ctx context.Context +// - in *secret.UpdateSecretRequest +// - opts ...grpc.CallOption +func (_e *SecretServiceClient_Expecter) UpdateSecret(ctx interface{}, in interface{}, opts ...interface{}) *SecretServiceClient_UpdateSecret_Call { + return &SecretServiceClient_UpdateSecret_Call{Call: _e.mock.On("UpdateSecret", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *SecretServiceClient_UpdateSecret_Call) Run(run func(ctx context.Context, in *secret.UpdateSecretRequest, opts ...grpc.CallOption)) *SecretServiceClient_UpdateSecret_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*secret.UpdateSecretRequest), variadicArgs...) + }) + return _c +} + +func (_c *SecretServiceClient_UpdateSecret_Call) Return(_a0 *secret.UpdateSecretResponse, _a1 error) *SecretServiceClient_UpdateSecret_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SecretServiceClient_UpdateSecret_Call) RunAndReturn(run func(context.Context, *secret.UpdateSecretRequest, ...grpc.CallOption) (*secret.UpdateSecretResponse, error)) *SecretServiceClient_UpdateSecret_Call { + _c.Call.Return(run) + return _c +} + +// NewSecretServiceClient creates a new instance of SecretServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewSecretServiceClient(t interface { + mock.TestingT + Cleanup(func()) +}) *SecretServiceClient { + mock := &SecretServiceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/secret/mocks/secret_service_server.go b/gen/go/flyteidl2/secret/mocks/secret_service_server.go new file mode 100644 index 0000000000..7a45a8ebc1 --- /dev/null +++ b/gen/go/flyteidl2/secret/mocks/secret_service_server.go @@ -0,0 +1,332 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + secret "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/secret" + mock "github.com/stretchr/testify/mock" +) + +// SecretServiceServer is an autogenerated mock type for the SecretServiceServer type +type SecretServiceServer struct { + mock.Mock +} + +type SecretServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *SecretServiceServer) EXPECT() *SecretServiceServer_Expecter { + return &SecretServiceServer_Expecter{mock: &_m.Mock} +} + +// CreateSecret provides a mock function with given fields: _a0, _a1 +func (_m *SecretServiceServer) CreateSecret(_a0 context.Context, _a1 *secret.CreateSecretRequest) (*secret.CreateSecretResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for CreateSecret") + } + + var r0 *secret.CreateSecretResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *secret.CreateSecretRequest) (*secret.CreateSecretResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *secret.CreateSecretRequest) *secret.CreateSecretResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret.CreateSecretResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *secret.CreateSecretRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SecretServiceServer_CreateSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSecret' +type SecretServiceServer_CreateSecret_Call struct { + *mock.Call +} + +// CreateSecret is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *secret.CreateSecretRequest +func (_e *SecretServiceServer_Expecter) CreateSecret(_a0 interface{}, _a1 interface{}) *SecretServiceServer_CreateSecret_Call { + return &SecretServiceServer_CreateSecret_Call{Call: _e.mock.On("CreateSecret", _a0, _a1)} +} + +func (_c *SecretServiceServer_CreateSecret_Call) Run(run func(_a0 context.Context, _a1 *secret.CreateSecretRequest)) *SecretServiceServer_CreateSecret_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*secret.CreateSecretRequest)) + }) + return _c +} + +func (_c *SecretServiceServer_CreateSecret_Call) Return(_a0 *secret.CreateSecretResponse, _a1 error) *SecretServiceServer_CreateSecret_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SecretServiceServer_CreateSecret_Call) RunAndReturn(run func(context.Context, *secret.CreateSecretRequest) (*secret.CreateSecretResponse, error)) *SecretServiceServer_CreateSecret_Call { + _c.Call.Return(run) + return _c +} + +// DeleteSecret provides a mock function with given fields: _a0, _a1 +func (_m *SecretServiceServer) DeleteSecret(_a0 context.Context, _a1 *secret.DeleteSecretRequest) (*secret.DeleteSecretResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for DeleteSecret") + } + + var r0 *secret.DeleteSecretResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *secret.DeleteSecretRequest) (*secret.DeleteSecretResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *secret.DeleteSecretRequest) *secret.DeleteSecretResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret.DeleteSecretResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *secret.DeleteSecretRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SecretServiceServer_DeleteSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSecret' +type SecretServiceServer_DeleteSecret_Call struct { + *mock.Call +} + +// DeleteSecret is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *secret.DeleteSecretRequest +func (_e *SecretServiceServer_Expecter) DeleteSecret(_a0 interface{}, _a1 interface{}) *SecretServiceServer_DeleteSecret_Call { + return &SecretServiceServer_DeleteSecret_Call{Call: _e.mock.On("DeleteSecret", _a0, _a1)} +} + +func (_c *SecretServiceServer_DeleteSecret_Call) Run(run func(_a0 context.Context, _a1 *secret.DeleteSecretRequest)) *SecretServiceServer_DeleteSecret_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*secret.DeleteSecretRequest)) + }) + return _c +} + +func (_c *SecretServiceServer_DeleteSecret_Call) Return(_a0 *secret.DeleteSecretResponse, _a1 error) *SecretServiceServer_DeleteSecret_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SecretServiceServer_DeleteSecret_Call) RunAndReturn(run func(context.Context, *secret.DeleteSecretRequest) (*secret.DeleteSecretResponse, error)) *SecretServiceServer_DeleteSecret_Call { + _c.Call.Return(run) + return _c +} + +// GetSecret provides a mock function with given fields: _a0, _a1 +func (_m *SecretServiceServer) GetSecret(_a0 context.Context, _a1 *secret.GetSecretRequest) (*secret.GetSecretResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetSecret") + } + + var r0 *secret.GetSecretResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *secret.GetSecretRequest) (*secret.GetSecretResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *secret.GetSecretRequest) *secret.GetSecretResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret.GetSecretResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *secret.GetSecretRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SecretServiceServer_GetSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSecret' +type SecretServiceServer_GetSecret_Call struct { + *mock.Call +} + +// GetSecret is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *secret.GetSecretRequest +func (_e *SecretServiceServer_Expecter) GetSecret(_a0 interface{}, _a1 interface{}) *SecretServiceServer_GetSecret_Call { + return &SecretServiceServer_GetSecret_Call{Call: _e.mock.On("GetSecret", _a0, _a1)} +} + +func (_c *SecretServiceServer_GetSecret_Call) Run(run func(_a0 context.Context, _a1 *secret.GetSecretRequest)) *SecretServiceServer_GetSecret_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*secret.GetSecretRequest)) + }) + return _c +} + +func (_c *SecretServiceServer_GetSecret_Call) Return(_a0 *secret.GetSecretResponse, _a1 error) *SecretServiceServer_GetSecret_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SecretServiceServer_GetSecret_Call) RunAndReturn(run func(context.Context, *secret.GetSecretRequest) (*secret.GetSecretResponse, error)) *SecretServiceServer_GetSecret_Call { + _c.Call.Return(run) + return _c +} + +// ListSecrets provides a mock function with given fields: _a0, _a1 +func (_m *SecretServiceServer) ListSecrets(_a0 context.Context, _a1 *secret.ListSecretsRequest) (*secret.ListSecretsResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for ListSecrets") + } + + var r0 *secret.ListSecretsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *secret.ListSecretsRequest) (*secret.ListSecretsResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *secret.ListSecretsRequest) *secret.ListSecretsResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret.ListSecretsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *secret.ListSecretsRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SecretServiceServer_ListSecrets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSecrets' +type SecretServiceServer_ListSecrets_Call struct { + *mock.Call +} + +// ListSecrets is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *secret.ListSecretsRequest +func (_e *SecretServiceServer_Expecter) ListSecrets(_a0 interface{}, _a1 interface{}) *SecretServiceServer_ListSecrets_Call { + return &SecretServiceServer_ListSecrets_Call{Call: _e.mock.On("ListSecrets", _a0, _a1)} +} + +func (_c *SecretServiceServer_ListSecrets_Call) Run(run func(_a0 context.Context, _a1 *secret.ListSecretsRequest)) *SecretServiceServer_ListSecrets_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*secret.ListSecretsRequest)) + }) + return _c +} + +func (_c *SecretServiceServer_ListSecrets_Call) Return(_a0 *secret.ListSecretsResponse, _a1 error) *SecretServiceServer_ListSecrets_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SecretServiceServer_ListSecrets_Call) RunAndReturn(run func(context.Context, *secret.ListSecretsRequest) (*secret.ListSecretsResponse, error)) *SecretServiceServer_ListSecrets_Call { + _c.Call.Return(run) + return _c +} + +// UpdateSecret provides a mock function with given fields: _a0, _a1 +func (_m *SecretServiceServer) UpdateSecret(_a0 context.Context, _a1 *secret.UpdateSecretRequest) (*secret.UpdateSecretResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for UpdateSecret") + } + + var r0 *secret.UpdateSecretResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *secret.UpdateSecretRequest) (*secret.UpdateSecretResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *secret.UpdateSecretRequest) *secret.UpdateSecretResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret.UpdateSecretResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *secret.UpdateSecretRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SecretServiceServer_UpdateSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSecret' +type SecretServiceServer_UpdateSecret_Call struct { + *mock.Call +} + +// UpdateSecret is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *secret.UpdateSecretRequest +func (_e *SecretServiceServer_Expecter) UpdateSecret(_a0 interface{}, _a1 interface{}) *SecretServiceServer_UpdateSecret_Call { + return &SecretServiceServer_UpdateSecret_Call{Call: _e.mock.On("UpdateSecret", _a0, _a1)} +} + +func (_c *SecretServiceServer_UpdateSecret_Call) Run(run func(_a0 context.Context, _a1 *secret.UpdateSecretRequest)) *SecretServiceServer_UpdateSecret_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*secret.UpdateSecretRequest)) + }) + return _c +} + +func (_c *SecretServiceServer_UpdateSecret_Call) Return(_a0 *secret.UpdateSecretResponse, _a1 error) *SecretServiceServer_UpdateSecret_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SecretServiceServer_UpdateSecret_Call) RunAndReturn(run func(context.Context, *secret.UpdateSecretRequest) (*secret.UpdateSecretResponse, error)) *SecretServiceServer_UpdateSecret_Call { + _c.Call.Return(run) + return _c +} + +// NewSecretServiceServer creates a new instance of SecretServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewSecretServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *SecretServiceServer { + mock := &SecretServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/secret/mocks/unsafe_secret_service_server.go b/gen/go/flyteidl2/secret/mocks/unsafe_secret_service_server.go new file mode 100644 index 0000000000..67d20df0ac --- /dev/null +++ b/gen/go/flyteidl2/secret/mocks/unsafe_secret_service_server.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// UnsafeSecretServiceServer is an autogenerated mock type for the UnsafeSecretServiceServer type +type UnsafeSecretServiceServer struct { + mock.Mock +} + +type UnsafeSecretServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *UnsafeSecretServiceServer) EXPECT() *UnsafeSecretServiceServer_Expecter { + return &UnsafeSecretServiceServer_Expecter{mock: &_m.Mock} +} + +// mustEmbedUnimplementedSecretServiceServer provides a mock function with no fields +func (_m *UnsafeSecretServiceServer) mustEmbedUnimplementedSecretServiceServer() { + _m.Called() +} + +// UnsafeSecretServiceServer_mustEmbedUnimplementedSecretServiceServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'mustEmbedUnimplementedSecretServiceServer' +type UnsafeSecretServiceServer_mustEmbedUnimplementedSecretServiceServer_Call struct { + *mock.Call +} + +// mustEmbedUnimplementedSecretServiceServer is a helper method to define mock.On call +func (_e *UnsafeSecretServiceServer_Expecter) mustEmbedUnimplementedSecretServiceServer() *UnsafeSecretServiceServer_mustEmbedUnimplementedSecretServiceServer_Call { + return &UnsafeSecretServiceServer_mustEmbedUnimplementedSecretServiceServer_Call{Call: _e.mock.On("mustEmbedUnimplementedSecretServiceServer")} +} + +func (_c *UnsafeSecretServiceServer_mustEmbedUnimplementedSecretServiceServer_Call) Run(run func()) *UnsafeSecretServiceServer_mustEmbedUnimplementedSecretServiceServer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UnsafeSecretServiceServer_mustEmbedUnimplementedSecretServiceServer_Call) Return() *UnsafeSecretServiceServer_mustEmbedUnimplementedSecretServiceServer_Call { + _c.Call.Return() + return _c +} + +func (_c *UnsafeSecretServiceServer_mustEmbedUnimplementedSecretServiceServer_Call) RunAndReturn(run func()) *UnsafeSecretServiceServer_mustEmbedUnimplementedSecretServiceServer_Call { + _c.Run(run) + return _c +} + +// NewUnsafeSecretServiceServer creates a new instance of UnsafeSecretServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewUnsafeSecretServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *UnsafeSecretServiceServer { + mock := &UnsafeSecretServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/secret/payload.pb.go b/gen/go/flyteidl2/secret/payload.pb.go new file mode 100644 index 0000000000..850a9227bc --- /dev/null +++ b/gen/go/flyteidl2/secret/payload.pb.go @@ -0,0 +1,860 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/secret/payload.proto + +package secret + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// CreateSecretProxyRequest contains the spec and identifier used for secret creation +type CreateSecretRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id *SecretIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + SecretSpec *SecretSpec `protobuf:"bytes,2,opt,name=secret_spec,json=secretSpec,proto3" json:"secret_spec,omitempty"` +} + +func (x *CreateSecretRequest) Reset() { + *x = CreateSecretRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CreateSecretRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateSecretRequest) ProtoMessage() {} + +func (x *CreateSecretRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateSecretRequest.ProtoReflect.Descriptor instead. +func (*CreateSecretRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_secret_payload_proto_rawDescGZIP(), []int{0} +} + +func (x *CreateSecretRequest) GetId() *SecretIdentifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *CreateSecretRequest) GetSecretSpec() *SecretSpec { + if x != nil { + return x.SecretSpec + } + return nil +} + +// CreateSecretResponse +type CreateSecretResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *CreateSecretResponse) Reset() { + *x = CreateSecretResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CreateSecretResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateSecretResponse) ProtoMessage() {} + +func (x *CreateSecretResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateSecretResponse.ProtoReflect.Descriptor instead. +func (*CreateSecretResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_secret_payload_proto_rawDescGZIP(), []int{1} +} + +// UpdateSecretProxyRequest contains the spec and identifier used for secret updation +type UpdateSecretRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id *SecretIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + SecretSpec *SecretSpec `protobuf:"bytes,2,opt,name=secret_spec,json=secretSpec,proto3" json:"secret_spec,omitempty"` +} + +func (x *UpdateSecretRequest) Reset() { + *x = UpdateSecretRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UpdateSecretRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateSecretRequest) ProtoMessage() {} + +func (x *UpdateSecretRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateSecretRequest.ProtoReflect.Descriptor instead. +func (*UpdateSecretRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_secret_payload_proto_rawDescGZIP(), []int{2} +} + +func (x *UpdateSecretRequest) GetId() *SecretIdentifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *UpdateSecretRequest) GetSecretSpec() *SecretSpec { + if x != nil { + return x.SecretSpec + } + return nil +} + +// UpdateSecretResponse returns an empty response if the secret is successfully updated +type UpdateSecretResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *UpdateSecretResponse) Reset() { + *x = UpdateSecretResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UpdateSecretResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateSecretResponse) ProtoMessage() {} + +func (x *UpdateSecretResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateSecretResponse.ProtoReflect.Descriptor instead. +func (*UpdateSecretResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_secret_payload_proto_rawDescGZIP(), []int{3} +} + +// GetSecretRequest contains the identifier used for looking up the secret +type GetSecretRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id *SecretIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` +} + +func (x *GetSecretRequest) Reset() { + *x = GetSecretRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetSecretRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSecretRequest) ProtoMessage() {} + +func (x *GetSecretRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSecretRequest.ProtoReflect.Descriptor instead. +func (*GetSecretRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_secret_payload_proto_rawDescGZIP(), []int{4} +} + +func (x *GetSecretRequest) GetId() *SecretIdentifier { + if x != nil { + return x.Id + } + return nil +} + +// GetSecretProxyResponse returns the looked up secret from the secret service +type GetSecretResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Secret *Secret `protobuf:"bytes,1,opt,name=secret,proto3" json:"secret,omitempty"` +} + +func (x *GetSecretResponse) Reset() { + *x = GetSecretResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetSecretResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSecretResponse) ProtoMessage() {} + +func (x *GetSecretResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSecretResponse.ProtoReflect.Descriptor instead. +func (*GetSecretResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_secret_payload_proto_rawDescGZIP(), []int{5} +} + +func (x *GetSecretResponse) GetSecret() *Secret { + if x != nil { + return x.Secret + } + return nil +} + +// DeleteSecretRequest contains the identifier used for looking up the secret for deletion +type DeleteSecretRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // name to be used for looking up the secret + Id *SecretIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` +} + +func (x *DeleteSecretRequest) Reset() { + *x = DeleteSecretRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteSecretRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteSecretRequest) ProtoMessage() {} + +func (x *DeleteSecretRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteSecretRequest.ProtoReflect.Descriptor instead. +func (*DeleteSecretRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_secret_payload_proto_rawDescGZIP(), []int{6} +} + +func (x *DeleteSecretRequest) GetId() *SecretIdentifier { + if x != nil { + return x.Id + } + return nil +} + +// DeleteSecretResponse is an empty response right now on successfully deleting the secret. +type DeleteSecretResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *DeleteSecretResponse) Reset() { + *x = DeleteSecretResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteSecretResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteSecretResponse) ProtoMessage() {} + +func (x *DeleteSecretResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteSecretResponse.ProtoReflect.Descriptor instead. +func (*DeleteSecretResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_secret_payload_proto_rawDescGZIP(), []int{7} +} + +// ListSecretsRequest is used for listing all the secrets accessible to the user at the passed in scope. +// With org scope, user is given all secrets at org, domain, project-domain level etc +// And returns paginated results +type ListSecretsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Only org scoped resources are supported right now + Organization string `protobuf:"bytes,1,opt,name=organization,proto3" json:"organization,omitempty"` + // domain scoped secret + Domain string `protobuf:"bytes,2,opt,name=domain,proto3" json:"domain,omitempty"` + // Project-domain scoped secret + Project string `protobuf:"bytes,3,opt,name=project,proto3" json:"project,omitempty"` + // Max page results + Limit int32 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"` + // Leave this empty if you are getting the first set of results. The next_token would be set in the response that can be used to fetch the next set of results. + Token string `protobuf:"bytes,5,opt,name=token,proto3" json:"token,omitempty"` + // Per cluster token. This allows the service to return paginated results per cluster. + // Service collates the results from all clusters and returns the next token for each cluster. + // The client can use the next token for each cluster to fetch the next page of results. + // In multi cluster, inorder to page through next set of results, client needs to send this token in the next request + PerClusterTokens map[string]string `protobuf:"bytes,6,rep,name=per_cluster_tokens,json=perClusterTokens,proto3" json:"per_cluster_tokens,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *ListSecretsRequest) Reset() { + *x = ListSecretsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListSecretsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListSecretsRequest) ProtoMessage() {} + +func (x *ListSecretsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListSecretsRequest.ProtoReflect.Descriptor instead. +func (*ListSecretsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_secret_payload_proto_rawDescGZIP(), []int{8} +} + +func (x *ListSecretsRequest) GetOrganization() string { + if x != nil { + return x.Organization + } + return "" +} + +func (x *ListSecretsRequest) GetDomain() string { + if x != nil { + return x.Domain + } + return "" +} + +func (x *ListSecretsRequest) GetProject() string { + if x != nil { + return x.Project + } + return "" +} + +func (x *ListSecretsRequest) GetLimit() int32 { + if x != nil { + return x.Limit + } + return 0 +} + +func (x *ListSecretsRequest) GetToken() string { + if x != nil { + return x.Token + } + return "" +} + +func (x *ListSecretsRequest) GetPerClusterTokens() map[string]string { + if x != nil { + return x.PerClusterTokens + } + return nil +} + +// ListSecretsResponse returns paginated results of the accessible secrets at the scope defined in the request. +type ListSecretsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Secrets []*Secret `protobuf:"bytes,1,rep,name=secrets,proto3" json:"secrets,omitempty"` + // next token to use for fetching new page results. + Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"` + // Per cluster token. This allows the service to return paginated results per cluster. + // Service collates the results from all clusters and returns the next token for each cluster. + // The client can use the next token for each cluster to fetch the next page of results. + // In multi cluster, inorder to page through next set of results, client needs to send this token in the next request + PerClusterTokens map[string]string `protobuf:"bytes,3,rep,name=per_cluster_tokens,json=perClusterTokens,proto3" json:"per_cluster_tokens,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *ListSecretsResponse) Reset() { + *x = ListSecretsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListSecretsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListSecretsResponse) ProtoMessage() {} + +func (x *ListSecretsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_secret_payload_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListSecretsResponse.ProtoReflect.Descriptor instead. +func (*ListSecretsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_secret_payload_proto_rawDescGZIP(), []int{9} +} + +func (x *ListSecretsResponse) GetSecrets() []*Secret { + if x != nil { + return x.Secrets + } + return nil +} + +func (x *ListSecretsResponse) GetToken() string { + if x != nil { + return x.Token + } + return "" +} + +func (x *ListSecretsResponse) GetPerClusterTokens() map[string]string { + if x != nil { + return x.PerClusterTokens + } + return nil +} + +var File_flyteidl2_secret_payload_proto protoreflect.FileDescriptor + +var file_flyteidl2_secret_payload_proto_rawDesc = []byte{ + 0x0a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x2f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x12, 0x10, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, + 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, + 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x2f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x22, 0x90, 0x01, 0x0a, 0x13, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3a, 0x0a, 0x02, 0x69, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, + 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3d, 0x0a, 0x0b, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x53, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0a, 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x53, 0x70, 0x65, 0x63, 0x22, 0x16, 0x0a, 0x14, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x90, 0x01, + 0x0a, 0x13, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3a, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, + 0x64, 0x12, 0x3d, 0x0a, 0x0b, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, 0x73, 0x70, 0x65, 0x63, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x53, 0x70, 0x65, 0x63, 0x52, 0x0a, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x53, 0x70, 0x65, 0x63, + 0x22, 0x16, 0x0a, 0x14, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4e, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x53, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3a, 0x0a, 0x02, + 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, + 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x22, 0x45, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x53, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x30, 0x0a, + 0x06, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x06, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x22, + 0x51, 0x0a, 0x13, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3a, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, + 0x69, 0x64, 0x22, 0x16, 0x0a, 0x14, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xc5, 0x02, 0x0a, 0x12, 0x4c, + 0x69, 0x73, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x22, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x18, 0x0a, + 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x14, 0x0a, + 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x12, 0x68, 0x0a, 0x12, 0x70, 0x65, 0x72, 0x5f, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x3a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x50, 0x65, 0x72, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, 0x70, 0x65, 0x72, + 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x1a, 0x43, 0x0a, + 0x15, 0x50, 0x65, 0x72, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, + 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x22, 0x8f, 0x02, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x32, 0x0a, 0x07, 0x73, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x53, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x14, + 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, + 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x69, 0x0a, 0x12, 0x70, 0x65, 0x72, 0x5f, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x3b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x50, 0x65, 0x72, 0x43, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, 0x70, + 0x65, 0x72, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x1a, + 0x43, 0x0a, 0x15, 0x50, 0x65, 0x72, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x54, 0x6f, 0x6b, + 0x65, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x3a, 0x02, 0x38, 0x01, 0x42, 0xbd, 0x01, 0x0a, 0x14, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x42, 0x0c, 0x50, + 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, + 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, + 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74, 0xa2, 0x02, 0x03, 0x46, 0x53, 0x58, 0xaa, 0x02, 0x10, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0xca, 0x02, + 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x53, 0x65, 0x63, 0x72, 0x65, + 0x74, 0xe2, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x53, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0xea, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x53, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_secret_payload_proto_rawDescOnce sync.Once + file_flyteidl2_secret_payload_proto_rawDescData = file_flyteidl2_secret_payload_proto_rawDesc +) + +func file_flyteidl2_secret_payload_proto_rawDescGZIP() []byte { + file_flyteidl2_secret_payload_proto_rawDescOnce.Do(func() { + file_flyteidl2_secret_payload_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_secret_payload_proto_rawDescData) + }) + return file_flyteidl2_secret_payload_proto_rawDescData +} + +var file_flyteidl2_secret_payload_proto_msgTypes = make([]protoimpl.MessageInfo, 12) +var file_flyteidl2_secret_payload_proto_goTypes = []interface{}{ + (*CreateSecretRequest)(nil), // 0: flyteidl2.secret.CreateSecretRequest + (*CreateSecretResponse)(nil), // 1: flyteidl2.secret.CreateSecretResponse + (*UpdateSecretRequest)(nil), // 2: flyteidl2.secret.UpdateSecretRequest + (*UpdateSecretResponse)(nil), // 3: flyteidl2.secret.UpdateSecretResponse + (*GetSecretRequest)(nil), // 4: flyteidl2.secret.GetSecretRequest + (*GetSecretResponse)(nil), // 5: flyteidl2.secret.GetSecretResponse + (*DeleteSecretRequest)(nil), // 6: flyteidl2.secret.DeleteSecretRequest + (*DeleteSecretResponse)(nil), // 7: flyteidl2.secret.DeleteSecretResponse + (*ListSecretsRequest)(nil), // 8: flyteidl2.secret.ListSecretsRequest + (*ListSecretsResponse)(nil), // 9: flyteidl2.secret.ListSecretsResponse + nil, // 10: flyteidl2.secret.ListSecretsRequest.PerClusterTokensEntry + nil, // 11: flyteidl2.secret.ListSecretsResponse.PerClusterTokensEntry + (*SecretIdentifier)(nil), // 12: flyteidl2.secret.SecretIdentifier + (*SecretSpec)(nil), // 13: flyteidl2.secret.SecretSpec + (*Secret)(nil), // 14: flyteidl2.secret.Secret +} +var file_flyteidl2_secret_payload_proto_depIdxs = []int32{ + 12, // 0: flyteidl2.secret.CreateSecretRequest.id:type_name -> flyteidl2.secret.SecretIdentifier + 13, // 1: flyteidl2.secret.CreateSecretRequest.secret_spec:type_name -> flyteidl2.secret.SecretSpec + 12, // 2: flyteidl2.secret.UpdateSecretRequest.id:type_name -> flyteidl2.secret.SecretIdentifier + 13, // 3: flyteidl2.secret.UpdateSecretRequest.secret_spec:type_name -> flyteidl2.secret.SecretSpec + 12, // 4: flyteidl2.secret.GetSecretRequest.id:type_name -> flyteidl2.secret.SecretIdentifier + 14, // 5: flyteidl2.secret.GetSecretResponse.secret:type_name -> flyteidl2.secret.Secret + 12, // 6: flyteidl2.secret.DeleteSecretRequest.id:type_name -> flyteidl2.secret.SecretIdentifier + 10, // 7: flyteidl2.secret.ListSecretsRequest.per_cluster_tokens:type_name -> flyteidl2.secret.ListSecretsRequest.PerClusterTokensEntry + 14, // 8: flyteidl2.secret.ListSecretsResponse.secrets:type_name -> flyteidl2.secret.Secret + 11, // 9: flyteidl2.secret.ListSecretsResponse.per_cluster_tokens:type_name -> flyteidl2.secret.ListSecretsResponse.PerClusterTokensEntry + 10, // [10:10] is the sub-list for method output_type + 10, // [10:10] is the sub-list for method input_type + 10, // [10:10] is the sub-list for extension type_name + 10, // [10:10] is the sub-list for extension extendee + 0, // [0:10] is the sub-list for field type_name +} + +func init() { file_flyteidl2_secret_payload_proto_init() } +func file_flyteidl2_secret_payload_proto_init() { + if File_flyteidl2_secret_payload_proto != nil { + return + } + file_flyteidl2_secret_definition_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_secret_payload_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CreateSecretRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_secret_payload_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CreateSecretResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_secret_payload_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UpdateSecretRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_secret_payload_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UpdateSecretResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_secret_payload_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetSecretRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_secret_payload_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetSecretResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_secret_payload_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteSecretRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_secret_payload_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteSecretResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_secret_payload_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListSecretsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_secret_payload_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListSecretsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_secret_payload_proto_rawDesc, + NumEnums: 0, + NumMessages: 12, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_secret_payload_proto_goTypes, + DependencyIndexes: file_flyteidl2_secret_payload_proto_depIdxs, + MessageInfos: file_flyteidl2_secret_payload_proto_msgTypes, + }.Build() + File_flyteidl2_secret_payload_proto = out.File + file_flyteidl2_secret_payload_proto_rawDesc = nil + file_flyteidl2_secret_payload_proto_goTypes = nil + file_flyteidl2_secret_payload_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/secret/payload.pb.validate.go b/gen/go/flyteidl2/secret/payload.pb.validate.go new file mode 100644 index 0000000000..4b90be3747 --- /dev/null +++ b/gen/go/flyteidl2/secret/payload.pb.validate.go @@ -0,0 +1,1307 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/secret/payload.proto + +package secret + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on CreateSecretRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *CreateSecretRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CreateSecretRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CreateSecretRequestMultiError, or nil if none found. +func (m *CreateSecretRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *CreateSecretRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateSecretRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateSecretRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateSecretRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetSecretSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateSecretRequestValidationError{ + field: "SecretSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateSecretRequestValidationError{ + field: "SecretSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSecretSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateSecretRequestValidationError{ + field: "SecretSpec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return CreateSecretRequestMultiError(errors) + } + + return nil +} + +// CreateSecretRequestMultiError is an error wrapping multiple validation +// errors returned by CreateSecretRequest.ValidateAll() if the designated +// constraints aren't met. +type CreateSecretRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CreateSecretRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CreateSecretRequestMultiError) AllErrors() []error { return m } + +// CreateSecretRequestValidationError is the validation error returned by +// CreateSecretRequest.Validate if the designated constraints aren't met. +type CreateSecretRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CreateSecretRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CreateSecretRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CreateSecretRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CreateSecretRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CreateSecretRequestValidationError) ErrorName() string { + return "CreateSecretRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e CreateSecretRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCreateSecretRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CreateSecretRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CreateSecretRequestValidationError{} + +// Validate checks the field values on CreateSecretResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *CreateSecretResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CreateSecretResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CreateSecretResponseMultiError, or nil if none found. +func (m *CreateSecretResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *CreateSecretResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return CreateSecretResponseMultiError(errors) + } + + return nil +} + +// CreateSecretResponseMultiError is an error wrapping multiple validation +// errors returned by CreateSecretResponse.ValidateAll() if the designated +// constraints aren't met. +type CreateSecretResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CreateSecretResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CreateSecretResponseMultiError) AllErrors() []error { return m } + +// CreateSecretResponseValidationError is the validation error returned by +// CreateSecretResponse.Validate if the designated constraints aren't met. +type CreateSecretResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CreateSecretResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CreateSecretResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CreateSecretResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CreateSecretResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CreateSecretResponseValidationError) ErrorName() string { + return "CreateSecretResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e CreateSecretResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCreateSecretResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CreateSecretResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CreateSecretResponseValidationError{} + +// Validate checks the field values on UpdateSecretRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *UpdateSecretRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on UpdateSecretRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// UpdateSecretRequestMultiError, or nil if none found. +func (m *UpdateSecretRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *UpdateSecretRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UpdateSecretRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UpdateSecretRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UpdateSecretRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetSecretSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UpdateSecretRequestValidationError{ + field: "SecretSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UpdateSecretRequestValidationError{ + field: "SecretSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSecretSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UpdateSecretRequestValidationError{ + field: "SecretSpec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return UpdateSecretRequestMultiError(errors) + } + + return nil +} + +// UpdateSecretRequestMultiError is an error wrapping multiple validation +// errors returned by UpdateSecretRequest.ValidateAll() if the designated +// constraints aren't met. +type UpdateSecretRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UpdateSecretRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UpdateSecretRequestMultiError) AllErrors() []error { return m } + +// UpdateSecretRequestValidationError is the validation error returned by +// UpdateSecretRequest.Validate if the designated constraints aren't met. +type UpdateSecretRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UpdateSecretRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UpdateSecretRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UpdateSecretRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UpdateSecretRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UpdateSecretRequestValidationError) ErrorName() string { + return "UpdateSecretRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e UpdateSecretRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUpdateSecretRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UpdateSecretRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UpdateSecretRequestValidationError{} + +// Validate checks the field values on UpdateSecretResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *UpdateSecretResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on UpdateSecretResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// UpdateSecretResponseMultiError, or nil if none found. +func (m *UpdateSecretResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *UpdateSecretResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return UpdateSecretResponseMultiError(errors) + } + + return nil +} + +// UpdateSecretResponseMultiError is an error wrapping multiple validation +// errors returned by UpdateSecretResponse.ValidateAll() if the designated +// constraints aren't met. +type UpdateSecretResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UpdateSecretResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UpdateSecretResponseMultiError) AllErrors() []error { return m } + +// UpdateSecretResponseValidationError is the validation error returned by +// UpdateSecretResponse.Validate if the designated constraints aren't met. +type UpdateSecretResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UpdateSecretResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UpdateSecretResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UpdateSecretResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UpdateSecretResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UpdateSecretResponseValidationError) ErrorName() string { + return "UpdateSecretResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e UpdateSecretResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUpdateSecretResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UpdateSecretResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UpdateSecretResponseValidationError{} + +// Validate checks the field values on GetSecretRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *GetSecretRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetSecretRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetSecretRequestMultiError, or nil if none found. +func (m *GetSecretRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetSecretRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetSecretRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetSecretRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetSecretRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetSecretRequestMultiError(errors) + } + + return nil +} + +// GetSecretRequestMultiError is an error wrapping multiple validation errors +// returned by GetSecretRequest.ValidateAll() if the designated constraints +// aren't met. +type GetSecretRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetSecretRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetSecretRequestMultiError) AllErrors() []error { return m } + +// GetSecretRequestValidationError is the validation error returned by +// GetSecretRequest.Validate if the designated constraints aren't met. +type GetSecretRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetSecretRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetSecretRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetSecretRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetSecretRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetSecretRequestValidationError) ErrorName() string { return "GetSecretRequestValidationError" } + +// Error satisfies the builtin error interface +func (e GetSecretRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetSecretRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetSecretRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetSecretRequestValidationError{} + +// Validate checks the field values on GetSecretResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *GetSecretResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetSecretResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetSecretResponseMultiError, or nil if none found. +func (m *GetSecretResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetSecretResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetSecret()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetSecretResponseValidationError{ + field: "Secret", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetSecretResponseValidationError{ + field: "Secret", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSecret()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetSecretResponseValidationError{ + field: "Secret", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetSecretResponseMultiError(errors) + } + + return nil +} + +// GetSecretResponseMultiError is an error wrapping multiple validation errors +// returned by GetSecretResponse.ValidateAll() if the designated constraints +// aren't met. +type GetSecretResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetSecretResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetSecretResponseMultiError) AllErrors() []error { return m } + +// GetSecretResponseValidationError is the validation error returned by +// GetSecretResponse.Validate if the designated constraints aren't met. +type GetSecretResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetSecretResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetSecretResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetSecretResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetSecretResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetSecretResponseValidationError) ErrorName() string { + return "GetSecretResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e GetSecretResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetSecretResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetSecretResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetSecretResponseValidationError{} + +// Validate checks the field values on DeleteSecretRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *DeleteSecretRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DeleteSecretRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// DeleteSecretRequestMultiError, or nil if none found. +func (m *DeleteSecretRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *DeleteSecretRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DeleteSecretRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DeleteSecretRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DeleteSecretRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DeleteSecretRequestMultiError(errors) + } + + return nil +} + +// DeleteSecretRequestMultiError is an error wrapping multiple validation +// errors returned by DeleteSecretRequest.ValidateAll() if the designated +// constraints aren't met. +type DeleteSecretRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DeleteSecretRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DeleteSecretRequestMultiError) AllErrors() []error { return m } + +// DeleteSecretRequestValidationError is the validation error returned by +// DeleteSecretRequest.Validate if the designated constraints aren't met. +type DeleteSecretRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DeleteSecretRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DeleteSecretRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DeleteSecretRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DeleteSecretRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DeleteSecretRequestValidationError) ErrorName() string { + return "DeleteSecretRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e DeleteSecretRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDeleteSecretRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DeleteSecretRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DeleteSecretRequestValidationError{} + +// Validate checks the field values on DeleteSecretResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *DeleteSecretResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DeleteSecretResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// DeleteSecretResponseMultiError, or nil if none found. +func (m *DeleteSecretResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *DeleteSecretResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return DeleteSecretResponseMultiError(errors) + } + + return nil +} + +// DeleteSecretResponseMultiError is an error wrapping multiple validation +// errors returned by DeleteSecretResponse.ValidateAll() if the designated +// constraints aren't met. +type DeleteSecretResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DeleteSecretResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DeleteSecretResponseMultiError) AllErrors() []error { return m } + +// DeleteSecretResponseValidationError is the validation error returned by +// DeleteSecretResponse.Validate if the designated constraints aren't met. +type DeleteSecretResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DeleteSecretResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DeleteSecretResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DeleteSecretResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DeleteSecretResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DeleteSecretResponseValidationError) ErrorName() string { + return "DeleteSecretResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e DeleteSecretResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDeleteSecretResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DeleteSecretResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DeleteSecretResponseValidationError{} + +// Validate checks the field values on ListSecretsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ListSecretsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListSecretsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ListSecretsRequestMultiError, or nil if none found. +func (m *ListSecretsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *ListSecretsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Organization + + // no validation rules for Domain + + // no validation rules for Project + + // no validation rules for Limit + + // no validation rules for Token + + // no validation rules for PerClusterTokens + + if len(errors) > 0 { + return ListSecretsRequestMultiError(errors) + } + + return nil +} + +// ListSecretsRequestMultiError is an error wrapping multiple validation errors +// returned by ListSecretsRequest.ValidateAll() if the designated constraints +// aren't met. +type ListSecretsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListSecretsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListSecretsRequestMultiError) AllErrors() []error { return m } + +// ListSecretsRequestValidationError is the validation error returned by +// ListSecretsRequest.Validate if the designated constraints aren't met. +type ListSecretsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListSecretsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListSecretsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListSecretsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListSecretsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListSecretsRequestValidationError) ErrorName() string { + return "ListSecretsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e ListSecretsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListSecretsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListSecretsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListSecretsRequestValidationError{} + +// Validate checks the field values on ListSecretsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ListSecretsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListSecretsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ListSecretsResponseMultiError, or nil if none found. +func (m *ListSecretsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *ListSecretsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetSecrets() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListSecretsResponseValidationError{ + field: fmt.Sprintf("Secrets[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListSecretsResponseValidationError{ + field: fmt.Sprintf("Secrets[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListSecretsResponseValidationError{ + field: fmt.Sprintf("Secrets[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Token + + // no validation rules for PerClusterTokens + + if len(errors) > 0 { + return ListSecretsResponseMultiError(errors) + } + + return nil +} + +// ListSecretsResponseMultiError is an error wrapping multiple validation +// errors returned by ListSecretsResponse.ValidateAll() if the designated +// constraints aren't met. +type ListSecretsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListSecretsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListSecretsResponseMultiError) AllErrors() []error { return m } + +// ListSecretsResponseValidationError is the validation error returned by +// ListSecretsResponse.Validate if the designated constraints aren't met. +type ListSecretsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListSecretsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListSecretsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListSecretsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListSecretsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListSecretsResponseValidationError) ErrorName() string { + return "ListSecretsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e ListSecretsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListSecretsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListSecretsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListSecretsResponseValidationError{} diff --git a/gen/go/flyteidl2/secret/secret.pb.go b/gen/go/flyteidl2/secret/secret.pb.go new file mode 100644 index 0000000000..5813df0018 --- /dev/null +++ b/gen/go/flyteidl2/secret/secret.pb.go @@ -0,0 +1,142 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/secret/secret.proto + +package secret + +import ( + _ "google.golang.org/genproto/googleapis/api/annotations" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +var File_flyteidl2_secret_secret_proto protoreflect.FileDescriptor + +var file_flyteidl2_secret_secret_proto_rawDesc = []byte{ + 0x0a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, + 0x10, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x2f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, + 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, + 0x90, 0x05, 0x0a, 0x0d, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x12, 0x79, 0x0a, 0x0c, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x12, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x43, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x1a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x3a, 0x01, 0x2a, 0x22, 0x0f, 0x2f, 0x73, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x73, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x12, 0x88, 0x01, 0x0a, + 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x12, 0x25, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x29, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x23, 0x3a, 0x01, 0x2a, 0x1a, 0x1e, 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x73, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x69, + 0x64, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, 0x7c, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x53, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x12, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x47, 0x65, 0x74, 0x53, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x20, 0x12, 0x1e, 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x2e, + 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, 0x85, 0x01, 0x0a, 0x0c, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x12, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x20, 0x2a, 0x1e, 0x2f, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6e, + 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, 0x73, 0x0a, + 0x0b, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x24, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, + 0x4c, 0x69, 0x73, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x11, 0x12, 0x0f, 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x42, 0xbc, 0x01, 0x0a, 0x14, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x42, 0x0b, 0x53, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x34, 0x67, 0x69, + 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, + 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, + 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0xa2, 0x02, 0x03, 0x46, 0x53, 0x58, 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0xca, 0x02, 0x10, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0xe2, 0x02, + 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x53, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x11, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x53, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var file_flyteidl2_secret_secret_proto_goTypes = []interface{}{ + (*CreateSecretRequest)(nil), // 0: flyteidl2.secret.CreateSecretRequest + (*UpdateSecretRequest)(nil), // 1: flyteidl2.secret.UpdateSecretRequest + (*GetSecretRequest)(nil), // 2: flyteidl2.secret.GetSecretRequest + (*DeleteSecretRequest)(nil), // 3: flyteidl2.secret.DeleteSecretRequest + (*ListSecretsRequest)(nil), // 4: flyteidl2.secret.ListSecretsRequest + (*CreateSecretResponse)(nil), // 5: flyteidl2.secret.CreateSecretResponse + (*UpdateSecretResponse)(nil), // 6: flyteidl2.secret.UpdateSecretResponse + (*GetSecretResponse)(nil), // 7: flyteidl2.secret.GetSecretResponse + (*DeleteSecretResponse)(nil), // 8: flyteidl2.secret.DeleteSecretResponse + (*ListSecretsResponse)(nil), // 9: flyteidl2.secret.ListSecretsResponse +} +var file_flyteidl2_secret_secret_proto_depIdxs = []int32{ + 0, // 0: flyteidl2.secret.SecretService.CreateSecret:input_type -> flyteidl2.secret.CreateSecretRequest + 1, // 1: flyteidl2.secret.SecretService.UpdateSecret:input_type -> flyteidl2.secret.UpdateSecretRequest + 2, // 2: flyteidl2.secret.SecretService.GetSecret:input_type -> flyteidl2.secret.GetSecretRequest + 3, // 3: flyteidl2.secret.SecretService.DeleteSecret:input_type -> flyteidl2.secret.DeleteSecretRequest + 4, // 4: flyteidl2.secret.SecretService.ListSecrets:input_type -> flyteidl2.secret.ListSecretsRequest + 5, // 5: flyteidl2.secret.SecretService.CreateSecret:output_type -> flyteidl2.secret.CreateSecretResponse + 6, // 6: flyteidl2.secret.SecretService.UpdateSecret:output_type -> flyteidl2.secret.UpdateSecretResponse + 7, // 7: flyteidl2.secret.SecretService.GetSecret:output_type -> flyteidl2.secret.GetSecretResponse + 8, // 8: flyteidl2.secret.SecretService.DeleteSecret:output_type -> flyteidl2.secret.DeleteSecretResponse + 9, // 9: flyteidl2.secret.SecretService.ListSecrets:output_type -> flyteidl2.secret.ListSecretsResponse + 5, // [5:10] is the sub-list for method output_type + 0, // [0:5] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_flyteidl2_secret_secret_proto_init() } +func file_flyteidl2_secret_secret_proto_init() { + if File_flyteidl2_secret_secret_proto != nil { + return + } + file_flyteidl2_secret_payload_proto_init() + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_secret_secret_proto_rawDesc, + NumEnums: 0, + NumMessages: 0, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_flyteidl2_secret_secret_proto_goTypes, + DependencyIndexes: file_flyteidl2_secret_secret_proto_depIdxs, + }.Build() + File_flyteidl2_secret_secret_proto = out.File + file_flyteidl2_secret_secret_proto_rawDesc = nil + file_flyteidl2_secret_secret_proto_goTypes = nil + file_flyteidl2_secret_secret_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/secret/secret.pb.validate.go b/gen/go/flyteidl2/secret/secret.pb.validate.go new file mode 100644 index 0000000000..9b18be727f --- /dev/null +++ b/gen/go/flyteidl2/secret/secret.pb.validate.go @@ -0,0 +1,36 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/secret/secret.proto + +package secret + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) diff --git a/gen/go/flyteidl2/secret/secret_grpc.pb.go b/gen/go/flyteidl2/secret/secret_grpc.pb.go new file mode 100644 index 0000000000..6c00d9c397 --- /dev/null +++ b/gen/go/flyteidl2/secret/secret_grpc.pb.go @@ -0,0 +1,255 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: flyteidl2/secret/secret.proto + +package secret + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + SecretService_CreateSecret_FullMethodName = "/flyteidl2.secret.SecretService/CreateSecret" + SecretService_UpdateSecret_FullMethodName = "/flyteidl2.secret.SecretService/UpdateSecret" + SecretService_GetSecret_FullMethodName = "/flyteidl2.secret.SecretService/GetSecret" + SecretService_DeleteSecret_FullMethodName = "/flyteidl2.secret.SecretService/DeleteSecret" + SecretService_ListSecrets_FullMethodName = "/flyteidl2.secret.SecretService/ListSecrets" +) + +// SecretServiceClient is the client API for SecretService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type SecretServiceClient interface { + CreateSecret(ctx context.Context, in *CreateSecretRequest, opts ...grpc.CallOption) (*CreateSecretResponse, error) + UpdateSecret(ctx context.Context, in *UpdateSecretRequest, opts ...grpc.CallOption) (*UpdateSecretResponse, error) + GetSecret(ctx context.Context, in *GetSecretRequest, opts ...grpc.CallOption) (*GetSecretResponse, error) + DeleteSecret(ctx context.Context, in *DeleteSecretRequest, opts ...grpc.CallOption) (*DeleteSecretResponse, error) + ListSecrets(ctx context.Context, in *ListSecretsRequest, opts ...grpc.CallOption) (*ListSecretsResponse, error) +} + +type secretServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewSecretServiceClient(cc grpc.ClientConnInterface) SecretServiceClient { + return &secretServiceClient{cc} +} + +func (c *secretServiceClient) CreateSecret(ctx context.Context, in *CreateSecretRequest, opts ...grpc.CallOption) (*CreateSecretResponse, error) { + out := new(CreateSecretResponse) + err := c.cc.Invoke(ctx, SecretService_CreateSecret_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *secretServiceClient) UpdateSecret(ctx context.Context, in *UpdateSecretRequest, opts ...grpc.CallOption) (*UpdateSecretResponse, error) { + out := new(UpdateSecretResponse) + err := c.cc.Invoke(ctx, SecretService_UpdateSecret_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *secretServiceClient) GetSecret(ctx context.Context, in *GetSecretRequest, opts ...grpc.CallOption) (*GetSecretResponse, error) { + out := new(GetSecretResponse) + err := c.cc.Invoke(ctx, SecretService_GetSecret_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *secretServiceClient) DeleteSecret(ctx context.Context, in *DeleteSecretRequest, opts ...grpc.CallOption) (*DeleteSecretResponse, error) { + out := new(DeleteSecretResponse) + err := c.cc.Invoke(ctx, SecretService_DeleteSecret_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *secretServiceClient) ListSecrets(ctx context.Context, in *ListSecretsRequest, opts ...grpc.CallOption) (*ListSecretsResponse, error) { + out := new(ListSecretsResponse) + err := c.cc.Invoke(ctx, SecretService_ListSecrets_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// SecretServiceServer is the server API for SecretService service. +// All implementations should embed UnimplementedSecretServiceServer +// for forward compatibility +type SecretServiceServer interface { + CreateSecret(context.Context, *CreateSecretRequest) (*CreateSecretResponse, error) + UpdateSecret(context.Context, *UpdateSecretRequest) (*UpdateSecretResponse, error) + GetSecret(context.Context, *GetSecretRequest) (*GetSecretResponse, error) + DeleteSecret(context.Context, *DeleteSecretRequest) (*DeleteSecretResponse, error) + ListSecrets(context.Context, *ListSecretsRequest) (*ListSecretsResponse, error) +} + +// UnimplementedSecretServiceServer should be embedded to have forward compatible implementations. +type UnimplementedSecretServiceServer struct { +} + +func (UnimplementedSecretServiceServer) CreateSecret(context.Context, *CreateSecretRequest) (*CreateSecretResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CreateSecret not implemented") +} +func (UnimplementedSecretServiceServer) UpdateSecret(context.Context, *UpdateSecretRequest) (*UpdateSecretResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateSecret not implemented") +} +func (UnimplementedSecretServiceServer) GetSecret(context.Context, *GetSecretRequest) (*GetSecretResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetSecret not implemented") +} +func (UnimplementedSecretServiceServer) DeleteSecret(context.Context, *DeleteSecretRequest) (*DeleteSecretResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeleteSecret not implemented") +} +func (UnimplementedSecretServiceServer) ListSecrets(context.Context, *ListSecretsRequest) (*ListSecretsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ListSecrets not implemented") +} + +// UnsafeSecretServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to SecretServiceServer will +// result in compilation errors. +type UnsafeSecretServiceServer interface { + mustEmbedUnimplementedSecretServiceServer() +} + +func RegisterSecretServiceServer(s grpc.ServiceRegistrar, srv SecretServiceServer) { + s.RegisterService(&SecretService_ServiceDesc, srv) +} + +func _SecretService_CreateSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CreateSecretRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SecretServiceServer).CreateSecret(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SecretService_CreateSecret_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SecretServiceServer).CreateSecret(ctx, req.(*CreateSecretRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SecretService_UpdateSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateSecretRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SecretServiceServer).UpdateSecret(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SecretService_UpdateSecret_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SecretServiceServer).UpdateSecret(ctx, req.(*UpdateSecretRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SecretService_GetSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetSecretRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SecretServiceServer).GetSecret(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SecretService_GetSecret_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SecretServiceServer).GetSecret(ctx, req.(*GetSecretRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SecretService_DeleteSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteSecretRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SecretServiceServer).DeleteSecret(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SecretService_DeleteSecret_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SecretServiceServer).DeleteSecret(ctx, req.(*DeleteSecretRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SecretService_ListSecrets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListSecretsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SecretServiceServer).ListSecrets(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SecretService_ListSecrets_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SecretServiceServer).ListSecrets(ctx, req.(*ListSecretsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// SecretService_ServiceDesc is the grpc.ServiceDesc for SecretService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var SecretService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.secret.SecretService", + HandlerType: (*SecretServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "CreateSecret", + Handler: _SecretService_CreateSecret_Handler, + }, + { + MethodName: "UpdateSecret", + Handler: _SecretService_UpdateSecret_Handler, + }, + { + MethodName: "GetSecret", + Handler: _SecretService_GetSecret_Handler, + }, + { + MethodName: "DeleteSecret", + Handler: _SecretService_DeleteSecret_Handler, + }, + { + MethodName: "ListSecrets", + Handler: _SecretService_ListSecrets_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "flyteidl2/secret/secret.proto", +} diff --git a/gen/go/flyteidl2/secret/secretconnect/secret.connect.go b/gen/go/flyteidl2/secret/secretconnect/secret.connect.go new file mode 100644 index 0000000000..4eabec2ebc --- /dev/null +++ b/gen/go/flyteidl2/secret/secretconnect/secret.connect.go @@ -0,0 +1,232 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: flyteidl2/secret/secret.proto + +package secretconnect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + secret "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/secret" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // SecretServiceName is the fully-qualified name of the SecretService service. + SecretServiceName = "flyteidl2.secret.SecretService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // SecretServiceCreateSecretProcedure is the fully-qualified name of the SecretService's + // CreateSecret RPC. + SecretServiceCreateSecretProcedure = "/flyteidl2.secret.SecretService/CreateSecret" + // SecretServiceUpdateSecretProcedure is the fully-qualified name of the SecretService's + // UpdateSecret RPC. + SecretServiceUpdateSecretProcedure = "/flyteidl2.secret.SecretService/UpdateSecret" + // SecretServiceGetSecretProcedure is the fully-qualified name of the SecretService's GetSecret RPC. + SecretServiceGetSecretProcedure = "/flyteidl2.secret.SecretService/GetSecret" + // SecretServiceDeleteSecretProcedure is the fully-qualified name of the SecretService's + // DeleteSecret RPC. + SecretServiceDeleteSecretProcedure = "/flyteidl2.secret.SecretService/DeleteSecret" + // SecretServiceListSecretsProcedure is the fully-qualified name of the SecretService's ListSecrets + // RPC. + SecretServiceListSecretsProcedure = "/flyteidl2.secret.SecretService/ListSecrets" +) + +// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. +var ( + secretServiceServiceDescriptor = secret.File_flyteidl2_secret_secret_proto.Services().ByName("SecretService") + secretServiceCreateSecretMethodDescriptor = secretServiceServiceDescriptor.Methods().ByName("CreateSecret") + secretServiceUpdateSecretMethodDescriptor = secretServiceServiceDescriptor.Methods().ByName("UpdateSecret") + secretServiceGetSecretMethodDescriptor = secretServiceServiceDescriptor.Methods().ByName("GetSecret") + secretServiceDeleteSecretMethodDescriptor = secretServiceServiceDescriptor.Methods().ByName("DeleteSecret") + secretServiceListSecretsMethodDescriptor = secretServiceServiceDescriptor.Methods().ByName("ListSecrets") +) + +// SecretServiceClient is a client for the flyteidl2.secret.SecretService service. +type SecretServiceClient interface { + CreateSecret(context.Context, *connect.Request[secret.CreateSecretRequest]) (*connect.Response[secret.CreateSecretResponse], error) + UpdateSecret(context.Context, *connect.Request[secret.UpdateSecretRequest]) (*connect.Response[secret.UpdateSecretResponse], error) + GetSecret(context.Context, *connect.Request[secret.GetSecretRequest]) (*connect.Response[secret.GetSecretResponse], error) + DeleteSecret(context.Context, *connect.Request[secret.DeleteSecretRequest]) (*connect.Response[secret.DeleteSecretResponse], error) + ListSecrets(context.Context, *connect.Request[secret.ListSecretsRequest]) (*connect.Response[secret.ListSecretsResponse], error) +} + +// NewSecretServiceClient constructs a client for the flyteidl2.secret.SecretService service. By +// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, +// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the +// connect.WithGRPC() or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewSecretServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) SecretServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &secretServiceClient{ + createSecret: connect.NewClient[secret.CreateSecretRequest, secret.CreateSecretResponse]( + httpClient, + baseURL+SecretServiceCreateSecretProcedure, + connect.WithSchema(secretServiceCreateSecretMethodDescriptor), + connect.WithClientOptions(opts...), + ), + updateSecret: connect.NewClient[secret.UpdateSecretRequest, secret.UpdateSecretResponse]( + httpClient, + baseURL+SecretServiceUpdateSecretProcedure, + connect.WithSchema(secretServiceUpdateSecretMethodDescriptor), + connect.WithClientOptions(opts...), + ), + getSecret: connect.NewClient[secret.GetSecretRequest, secret.GetSecretResponse]( + httpClient, + baseURL+SecretServiceGetSecretProcedure, + connect.WithSchema(secretServiceGetSecretMethodDescriptor), + connect.WithClientOptions(opts...), + ), + deleteSecret: connect.NewClient[secret.DeleteSecretRequest, secret.DeleteSecretResponse]( + httpClient, + baseURL+SecretServiceDeleteSecretProcedure, + connect.WithSchema(secretServiceDeleteSecretMethodDescriptor), + connect.WithClientOptions(opts...), + ), + listSecrets: connect.NewClient[secret.ListSecretsRequest, secret.ListSecretsResponse]( + httpClient, + baseURL+SecretServiceListSecretsProcedure, + connect.WithSchema(secretServiceListSecretsMethodDescriptor), + connect.WithClientOptions(opts...), + ), + } +} + +// secretServiceClient implements SecretServiceClient. +type secretServiceClient struct { + createSecret *connect.Client[secret.CreateSecretRequest, secret.CreateSecretResponse] + updateSecret *connect.Client[secret.UpdateSecretRequest, secret.UpdateSecretResponse] + getSecret *connect.Client[secret.GetSecretRequest, secret.GetSecretResponse] + deleteSecret *connect.Client[secret.DeleteSecretRequest, secret.DeleteSecretResponse] + listSecrets *connect.Client[secret.ListSecretsRequest, secret.ListSecretsResponse] +} + +// CreateSecret calls flyteidl2.secret.SecretService.CreateSecret. +func (c *secretServiceClient) CreateSecret(ctx context.Context, req *connect.Request[secret.CreateSecretRequest]) (*connect.Response[secret.CreateSecretResponse], error) { + return c.createSecret.CallUnary(ctx, req) +} + +// UpdateSecret calls flyteidl2.secret.SecretService.UpdateSecret. +func (c *secretServiceClient) UpdateSecret(ctx context.Context, req *connect.Request[secret.UpdateSecretRequest]) (*connect.Response[secret.UpdateSecretResponse], error) { + return c.updateSecret.CallUnary(ctx, req) +} + +// GetSecret calls flyteidl2.secret.SecretService.GetSecret. +func (c *secretServiceClient) GetSecret(ctx context.Context, req *connect.Request[secret.GetSecretRequest]) (*connect.Response[secret.GetSecretResponse], error) { + return c.getSecret.CallUnary(ctx, req) +} + +// DeleteSecret calls flyteidl2.secret.SecretService.DeleteSecret. +func (c *secretServiceClient) DeleteSecret(ctx context.Context, req *connect.Request[secret.DeleteSecretRequest]) (*connect.Response[secret.DeleteSecretResponse], error) { + return c.deleteSecret.CallUnary(ctx, req) +} + +// ListSecrets calls flyteidl2.secret.SecretService.ListSecrets. +func (c *secretServiceClient) ListSecrets(ctx context.Context, req *connect.Request[secret.ListSecretsRequest]) (*connect.Response[secret.ListSecretsResponse], error) { + return c.listSecrets.CallUnary(ctx, req) +} + +// SecretServiceHandler is an implementation of the flyteidl2.secret.SecretService service. +type SecretServiceHandler interface { + CreateSecret(context.Context, *connect.Request[secret.CreateSecretRequest]) (*connect.Response[secret.CreateSecretResponse], error) + UpdateSecret(context.Context, *connect.Request[secret.UpdateSecretRequest]) (*connect.Response[secret.UpdateSecretResponse], error) + GetSecret(context.Context, *connect.Request[secret.GetSecretRequest]) (*connect.Response[secret.GetSecretResponse], error) + DeleteSecret(context.Context, *connect.Request[secret.DeleteSecretRequest]) (*connect.Response[secret.DeleteSecretResponse], error) + ListSecrets(context.Context, *connect.Request[secret.ListSecretsRequest]) (*connect.Response[secret.ListSecretsResponse], error) +} + +// NewSecretServiceHandler builds an HTTP handler from the service implementation. It returns the +// path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewSecretServiceHandler(svc SecretServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + secretServiceCreateSecretHandler := connect.NewUnaryHandler( + SecretServiceCreateSecretProcedure, + svc.CreateSecret, + connect.WithSchema(secretServiceCreateSecretMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + secretServiceUpdateSecretHandler := connect.NewUnaryHandler( + SecretServiceUpdateSecretProcedure, + svc.UpdateSecret, + connect.WithSchema(secretServiceUpdateSecretMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + secretServiceGetSecretHandler := connect.NewUnaryHandler( + SecretServiceGetSecretProcedure, + svc.GetSecret, + connect.WithSchema(secretServiceGetSecretMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + secretServiceDeleteSecretHandler := connect.NewUnaryHandler( + SecretServiceDeleteSecretProcedure, + svc.DeleteSecret, + connect.WithSchema(secretServiceDeleteSecretMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + secretServiceListSecretsHandler := connect.NewUnaryHandler( + SecretServiceListSecretsProcedure, + svc.ListSecrets, + connect.WithSchema(secretServiceListSecretsMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.secret.SecretService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case SecretServiceCreateSecretProcedure: + secretServiceCreateSecretHandler.ServeHTTP(w, r) + case SecretServiceUpdateSecretProcedure: + secretServiceUpdateSecretHandler.ServeHTTP(w, r) + case SecretServiceGetSecretProcedure: + secretServiceGetSecretHandler.ServeHTTP(w, r) + case SecretServiceDeleteSecretProcedure: + secretServiceDeleteSecretHandler.ServeHTTP(w, r) + case SecretServiceListSecretsProcedure: + secretServiceListSecretsHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedSecretServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedSecretServiceHandler struct{} + +func (UnimplementedSecretServiceHandler) CreateSecret(context.Context, *connect.Request[secret.CreateSecretRequest]) (*connect.Response[secret.CreateSecretResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.secret.SecretService.CreateSecret is not implemented")) +} + +func (UnimplementedSecretServiceHandler) UpdateSecret(context.Context, *connect.Request[secret.UpdateSecretRequest]) (*connect.Response[secret.UpdateSecretResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.secret.SecretService.UpdateSecret is not implemented")) +} + +func (UnimplementedSecretServiceHandler) GetSecret(context.Context, *connect.Request[secret.GetSecretRequest]) (*connect.Response[secret.GetSecretResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.secret.SecretService.GetSecret is not implemented")) +} + +func (UnimplementedSecretServiceHandler) DeleteSecret(context.Context, *connect.Request[secret.DeleteSecretRequest]) (*connect.Response[secret.DeleteSecretResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.secret.SecretService.DeleteSecret is not implemented")) +} + +func (UnimplementedSecretServiceHandler) ListSecrets(context.Context, *connect.Request[secret.ListSecretsRequest]) (*connect.Response[secret.ListSecretsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.secret.SecretService.ListSecrets is not implemented")) +} diff --git a/gen/go/flyteidl2/task/common.pb.go b/gen/go/flyteidl2/task/common.pb.go new file mode 100644 index 0000000000..4c130d0d86 --- /dev/null +++ b/gen/go/flyteidl2/task/common.pb.go @@ -0,0 +1,1020 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/task/common.proto + +package task + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Represents a frequency at which to run a schedule. +type FixedRateUnit int32 + +const ( + FixedRateUnit_FIXED_RATE_UNIT_UNSPECIFIED FixedRateUnit = 0 + FixedRateUnit_FIXED_RATE_UNIT_MINUTE FixedRateUnit = 1 + FixedRateUnit_FIXED_RATE_UNIT_HOUR FixedRateUnit = 2 + FixedRateUnit_FIXED_RATE_UNIT_DAY FixedRateUnit = 3 +) + +// Enum value maps for FixedRateUnit. +var ( + FixedRateUnit_name = map[int32]string{ + 0: "FIXED_RATE_UNIT_UNSPECIFIED", + 1: "FIXED_RATE_UNIT_MINUTE", + 2: "FIXED_RATE_UNIT_HOUR", + 3: "FIXED_RATE_UNIT_DAY", + } + FixedRateUnit_value = map[string]int32{ + "FIXED_RATE_UNIT_UNSPECIFIED": 0, + "FIXED_RATE_UNIT_MINUTE": 1, + "FIXED_RATE_UNIT_HOUR": 2, + "FIXED_RATE_UNIT_DAY": 3, + } +) + +func (x FixedRateUnit) Enum() *FixedRateUnit { + p := new(FixedRateUnit) + *p = x + return p +} + +func (x FixedRateUnit) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (FixedRateUnit) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_task_common_proto_enumTypes[0].Descriptor() +} + +func (FixedRateUnit) Type() protoreflect.EnumType { + return &file_flyteidl2_task_common_proto_enumTypes[0] +} + +func (x FixedRateUnit) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use FixedRateUnit.Descriptor instead. +func (FixedRateUnit) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_task_common_proto_rawDescGZIP(), []int{0} +} + +type TriggerAutomationSpecType int32 + +const ( + TriggerAutomationSpecType_TYPE_UNSPECIFIED TriggerAutomationSpecType = 0 + TriggerAutomationSpecType_TYPE_NONE TriggerAutomationSpecType = 1 + TriggerAutomationSpecType_TYPE_SCHEDULE TriggerAutomationSpecType = 2 +) + +// Enum value maps for TriggerAutomationSpecType. +var ( + TriggerAutomationSpecType_name = map[int32]string{ + 0: "TYPE_UNSPECIFIED", + 1: "TYPE_NONE", + 2: "TYPE_SCHEDULE", + } + TriggerAutomationSpecType_value = map[string]int32{ + "TYPE_UNSPECIFIED": 0, + "TYPE_NONE": 1, + "TYPE_SCHEDULE": 2, + } +) + +func (x TriggerAutomationSpecType) Enum() *TriggerAutomationSpecType { + p := new(TriggerAutomationSpecType) + *p = x + return p +} + +func (x TriggerAutomationSpecType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (TriggerAutomationSpecType) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_task_common_proto_enumTypes[1].Descriptor() +} + +func (TriggerAutomationSpecType) Type() protoreflect.EnumType { + return &file_flyteidl2_task_common_proto_enumTypes[1] +} + +func (x TriggerAutomationSpecType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use TriggerAutomationSpecType.Descriptor instead. +func (TriggerAutomationSpecType) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_task_common_proto_rawDescGZIP(), []int{1} +} + +type NamedParameter struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Parameter *core.Parameter `protobuf:"bytes,2,opt,name=parameter,proto3" json:"parameter,omitempty"` +} + +func (x *NamedParameter) Reset() { + *x = NamedParameter{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_common_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NamedParameter) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NamedParameter) ProtoMessage() {} + +func (x *NamedParameter) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_common_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NamedParameter.ProtoReflect.Descriptor instead. +func (*NamedParameter) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_common_proto_rawDescGZIP(), []int{0} +} + +func (x *NamedParameter) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *NamedParameter) GetParameter() *core.Parameter { + if x != nil { + return x.Parameter + } + return nil +} + +// Option for schedules run at a certain frequency e.g. every 2 minutes. +type FixedRate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Value uint32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` + Unit FixedRateUnit `protobuf:"varint,2,opt,name=unit,proto3,enum=flyteidl2.task.FixedRateUnit" json:"unit,omitempty"` + // Optional, timestamp after which rate should be calculated. Can be only in future. + // E.g. We create a rate schedule "every 5 minutes" with start_time="12:00" inactive. + // Activate it at "12:04". + // Trigger should fire at "12:05" as it adds 5 minutes to start_time="12:00". + StartTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` +} + +func (x *FixedRate) Reset() { + *x = FixedRate{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_common_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FixedRate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FixedRate) ProtoMessage() {} + +func (x *FixedRate) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_common_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FixedRate.ProtoReflect.Descriptor instead. +func (*FixedRate) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_common_proto_rawDescGZIP(), []int{1} +} + +func (x *FixedRate) GetValue() uint32 { + if x != nil { + return x.Value + } + return 0 +} + +func (x *FixedRate) GetUnit() FixedRateUnit { + if x != nil { + return x.Unit + } + return FixedRateUnit_FIXED_RATE_UNIT_UNSPECIFIED +} + +func (x *FixedRate) GetStartTime() *timestamppb.Timestamp { + if x != nil { + return x.StartTime + } + return nil +} + +type Cron struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Uses AWS syntax: Minutes Hours Day-of-month Month Day-of-week Year + // e.g. for a schedule that runs every 15 minutes: 0/15 * * * ? * + Expression string `protobuf:"bytes,1,opt,name=expression,proto3" json:"expression,omitempty"` + Timezone string `protobuf:"bytes,2,opt,name=timezone,proto3" json:"timezone,omitempty"` // default is UTC +} + +func (x *Cron) Reset() { + *x = Cron{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_common_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Cron) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Cron) ProtoMessage() {} + +func (x *Cron) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_common_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Cron.ProtoReflect.Descriptor instead. +func (*Cron) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_common_proto_rawDescGZIP(), []int{2} +} + +func (x *Cron) GetExpression() string { + if x != nil { + return x.Expression + } + return "" +} + +func (x *Cron) GetTimezone() string { + if x != nil { + return x.Timezone + } + return "" +} + +// Defines complete set of information required to trigger an execution on a schedule. +type Schedule struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Expression: + // + // *Schedule_Rate + // *Schedule_CronExpression + // *Schedule_Cron + Expression isSchedule_Expression `protobuf_oneof:"expression"` + // Name of the input variable that the kickoff time will be supplied to when the workflow is kicked off. + KickoffTimeInputArg string `protobuf:"bytes,3,opt,name=kickoff_time_input_arg,json=kickoffTimeInputArg,proto3" json:"kickoff_time_input_arg,omitempty"` +} + +func (x *Schedule) Reset() { + *x = Schedule{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_common_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Schedule) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Schedule) ProtoMessage() {} + +func (x *Schedule) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_common_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Schedule.ProtoReflect.Descriptor instead. +func (*Schedule) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_common_proto_rawDescGZIP(), []int{3} +} + +func (m *Schedule) GetExpression() isSchedule_Expression { + if m != nil { + return m.Expression + } + return nil +} + +func (x *Schedule) GetRate() *FixedRate { + if x, ok := x.GetExpression().(*Schedule_Rate); ok { + return x.Rate + } + return nil +} + +// Deprecated: Marked as deprecated in flyteidl2/task/common.proto. +func (x *Schedule) GetCronExpression() string { + if x, ok := x.GetExpression().(*Schedule_CronExpression); ok { + return x.CronExpression + } + return "" +} + +func (x *Schedule) GetCron() *Cron { + if x, ok := x.GetExpression().(*Schedule_Cron); ok { + return x.Cron + } + return nil +} + +func (x *Schedule) GetKickoffTimeInputArg() string { + if x != nil { + return x.KickoffTimeInputArg + } + return "" +} + +type isSchedule_Expression interface { + isSchedule_Expression() +} + +type Schedule_Rate struct { + Rate *FixedRate `protobuf:"bytes,1,opt,name=rate,proto3,oneof"` +} + +type Schedule_CronExpression struct { + // Deprecated: Marked as deprecated in flyteidl2/task/common.proto. + CronExpression string `protobuf:"bytes,2,opt,name=cron_expression,json=cronExpression,proto3,oneof"` +} + +type Schedule_Cron struct { + Cron *Cron `protobuf:"bytes,4,opt,name=cron,proto3,oneof"` +} + +func (*Schedule_Rate) isSchedule_Expression() {} + +func (*Schedule_CronExpression) isSchedule_Expression() {} + +func (*Schedule_Cron) isSchedule_Expression() {} + +type TriggerAutomationSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Explicitly defines trigger automation type. + Type TriggerAutomationSpecType `protobuf:"varint,1,opt,name=type,proto3,enum=flyteidl2.task.TriggerAutomationSpecType" json:"type,omitempty"` + // Types that are assignable to Automation: + // + // *TriggerAutomationSpec_Schedule + Automation isTriggerAutomationSpec_Automation `protobuf_oneof:"automation"` +} + +func (x *TriggerAutomationSpec) Reset() { + *x = TriggerAutomationSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_common_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TriggerAutomationSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TriggerAutomationSpec) ProtoMessage() {} + +func (x *TriggerAutomationSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_common_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TriggerAutomationSpec.ProtoReflect.Descriptor instead. +func (*TriggerAutomationSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_common_proto_rawDescGZIP(), []int{4} +} + +func (x *TriggerAutomationSpec) GetType() TriggerAutomationSpecType { + if x != nil { + return x.Type + } + return TriggerAutomationSpecType_TYPE_UNSPECIFIED +} + +func (m *TriggerAutomationSpec) GetAutomation() isTriggerAutomationSpec_Automation { + if m != nil { + return m.Automation + } + return nil +} + +func (x *TriggerAutomationSpec) GetSchedule() *Schedule { + if x, ok := x.GetAutomation().(*TriggerAutomationSpec_Schedule); ok { + return x.Schedule + } + return nil +} + +type isTriggerAutomationSpec_Automation interface { + isTriggerAutomationSpec_Automation() +} + +type TriggerAutomationSpec_Schedule struct { + Schedule *Schedule `protobuf:"bytes,2,opt,name=schedule,proto3,oneof"` +} + +func (*TriggerAutomationSpec_Schedule) isTriggerAutomationSpec_Automation() {} + +// Named literal value. +type NamedLiteral struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Name of the literal. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Literal value. + Value *core.Literal `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` +} + +func (x *NamedLiteral) Reset() { + *x = NamedLiteral{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_common_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NamedLiteral) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NamedLiteral) ProtoMessage() {} + +func (x *NamedLiteral) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_common_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NamedLiteral.ProtoReflect.Descriptor instead. +func (*NamedLiteral) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_common_proto_rawDescGZIP(), []int{5} +} + +func (x *NamedLiteral) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *NamedLiteral) GetValue() *core.Literal { + if x != nil { + return x.Value + } + return nil +} + +// Output references. +type OutputReferences struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The output uri. + OutputUri string `protobuf:"bytes,1,opt,name=output_uri,json=outputUri,proto3" json:"output_uri,omitempty"` + // Native URI to HTML report + ReportUri string `protobuf:"bytes,2,opt,name=report_uri,json=reportUri,proto3" json:"report_uri,omitempty"` +} + +func (x *OutputReferences) Reset() { + *x = OutputReferences{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_common_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OutputReferences) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OutputReferences) ProtoMessage() {} + +func (x *OutputReferences) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_common_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OutputReferences.ProtoReflect.Descriptor instead. +func (*OutputReferences) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_common_proto_rawDescGZIP(), []int{6} +} + +func (x *OutputReferences) GetOutputUri() string { + if x != nil { + return x.OutputUri + } + return "" +} + +func (x *OutputReferences) GetReportUri() string { + if x != nil { + return x.ReportUri + } + return "" +} + +// Input payload for an action. +type Inputs struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Ordered inputs. THIS FIELD MUST REMAIN FIRST as this would break Run service assumptions if it were to move. + Literals []*NamedLiteral `protobuf:"bytes,1,rep,name=literals,proto3" json:"literals,omitempty"` + // Context for the action. If an action receives context, it'll automatically pass it to any actions it spawns. + // Context will not be used for cache key computation. + // Examples for context include: + // - User-provided metadata that is not part of the action's inputs. + // - Information about the environment the action is running in (e.g. cluster, region, etc.) + // - Tracing information about the action + Context []*core.KeyValuePair `protobuf:"bytes,2,rep,name=context,proto3" json:"context,omitempty"` +} + +func (x *Inputs) Reset() { + *x = Inputs{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_common_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Inputs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Inputs) ProtoMessage() {} + +func (x *Inputs) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_common_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Inputs.ProtoReflect.Descriptor instead. +func (*Inputs) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_common_proto_rawDescGZIP(), []int{7} +} + +func (x *Inputs) GetLiterals() []*NamedLiteral { + if x != nil { + return x.Literals + } + return nil +} + +func (x *Inputs) GetContext() []*core.KeyValuePair { + if x != nil { + return x.Context + } + return nil +} + +// Output payload for an action. +type Outputs struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Ordered outputs. THIS FIELD MUST REMAIN FIRST as this would break Run service assumptions if it were to move. + Literals []*NamedLiteral `protobuf:"bytes,1,rep,name=literals,proto3" json:"literals,omitempty"` +} + +func (x *Outputs) Reset() { + *x = Outputs{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_common_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Outputs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Outputs) ProtoMessage() {} + +func (x *Outputs) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_common_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Outputs.ProtoReflect.Descriptor instead. +func (*Outputs) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_common_proto_rawDescGZIP(), []int{8} +} + +func (x *Outputs) GetLiterals() []*NamedLiteral { + if x != nil { + return x.Literals + } + return nil +} + +var File_flyteidl2_task_common_proto protoreflect.FileDescriptor + +var file_flyteidl2_task_common_proto_rawDesc = []byte{ + 0x0a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, + 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x1a, 0x1b, 0x62, + 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, + 0x66, 0x61, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x6c, 0x69, 0x74, 0x65, 0x72, + 0x61, 0x6c, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x5d, 0x0a, 0x0e, 0x4e, 0x61, + 0x6d, 0x65, 0x64, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x12, 0x37, 0x0a, 0x09, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x52, 0x09, + 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x22, 0xa2, 0x01, 0x0a, 0x09, 0x46, 0x69, + 0x78, 0x65, 0x64, 0x52, 0x61, 0x74, 0x65, 0x12, 0x1d, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, 0x02, 0x20, 0x00, 0x52, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x3b, 0x0a, 0x04, 0x75, 0x6e, 0x69, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x46, 0x69, 0x78, 0x65, 0x64, 0x52, 0x61, 0x74, 0x65, 0x55, + 0x6e, 0x69, 0x74, 0x42, 0x08, 0xba, 0x48, 0x05, 0x82, 0x01, 0x02, 0x20, 0x00, 0x52, 0x04, 0x75, + 0x6e, 0x69, 0x74, 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x4b, + 0x0a, 0x04, 0x43, 0x72, 0x6f, 0x6e, 0x12, 0x27, 0x0a, 0x0a, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, + 0x02, 0x10, 0x01, 0x52, 0x0a, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, + 0x1a, 0x0a, 0x08, 0x74, 0x69, 0x6d, 0x65, 0x7a, 0x6f, 0x6e, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x08, 0x74, 0x69, 0x6d, 0x65, 0x7a, 0x6f, 0x6e, 0x65, 0x22, 0xe0, 0x01, 0x0a, 0x08, + 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x12, 0x2f, 0x0a, 0x04, 0x72, 0x61, 0x74, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x46, 0x69, 0x78, 0x65, 0x64, 0x52, 0x61, 0x74, + 0x65, 0x48, 0x00, 0x52, 0x04, 0x72, 0x61, 0x74, 0x65, 0x12, 0x2d, 0x0a, 0x0f, 0x63, 0x72, 0x6f, + 0x6e, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x48, 0x00, 0x52, 0x0e, 0x63, 0x72, 0x6f, 0x6e, 0x45, 0x78, + 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x2a, 0x0a, 0x04, 0x63, 0x72, 0x6f, 0x6e, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x43, 0x72, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x04, + 0x63, 0x72, 0x6f, 0x6e, 0x12, 0x33, 0x0a, 0x16, 0x6b, 0x69, 0x63, 0x6b, 0x6f, 0x66, 0x66, 0x5f, + 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x61, 0x72, 0x67, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x6b, 0x69, 0x63, 0x6b, 0x6f, 0x66, 0x66, 0x54, 0x69, 0x6d, + 0x65, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x41, 0x72, 0x67, 0x42, 0x13, 0x0a, 0x0a, 0x65, 0x78, 0x70, + 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, 0xa6, + 0x01, 0x0a, 0x15, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x41, 0x75, 0x74, 0x6f, 0x6d, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x12, 0x47, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x41, + 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x54, 0x79, 0x70, + 0x65, 0x42, 0x08, 0xba, 0x48, 0x05, 0x82, 0x01, 0x02, 0x20, 0x00, 0x52, 0x04, 0x74, 0x79, 0x70, + 0x65, 0x12, 0x36, 0x0a, 0x08, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x48, 0x00, 0x52, + 0x08, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x42, 0x0c, 0x0a, 0x0a, 0x61, 0x75, 0x74, + 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x51, 0x0a, 0x0c, 0x4e, 0x61, 0x6d, 0x65, 0x64, + 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2d, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, + 0x72, 0x61, 0x6c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x50, 0x0a, 0x10, 0x4f, 0x75, + 0x74, 0x70, 0x75, 0x74, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x1d, + 0x0a, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x09, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x55, 0x72, 0x69, 0x12, 0x1d, 0x0a, + 0x0a, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x09, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x55, 0x72, 0x69, 0x22, 0x7a, 0x0a, 0x06, + 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x12, 0x38, 0x0a, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, + 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x64, 0x4c, + 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, + 0x12, 0x36, 0x0a, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x61, 0x69, 0x72, 0x52, + 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x22, 0x43, 0x0a, 0x07, 0x4f, 0x75, 0x74, 0x70, + 0x75, 0x74, 0x73, 0x12, 0x38, 0x0a, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x64, 0x4c, 0x69, 0x74, 0x65, + 0x72, 0x61, 0x6c, 0x52, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x2a, 0x7f, 0x0a, + 0x0d, 0x46, 0x69, 0x78, 0x65, 0x64, 0x52, 0x61, 0x74, 0x65, 0x55, 0x6e, 0x69, 0x74, 0x12, 0x1f, + 0x0a, 0x1b, 0x46, 0x49, 0x58, 0x45, 0x44, 0x5f, 0x52, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x49, + 0x54, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, + 0x1a, 0x0a, 0x16, 0x46, 0x49, 0x58, 0x45, 0x44, 0x5f, 0x52, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, + 0x49, 0x54, 0x5f, 0x4d, 0x49, 0x4e, 0x55, 0x54, 0x45, 0x10, 0x01, 0x12, 0x18, 0x0a, 0x14, 0x46, + 0x49, 0x58, 0x45, 0x44, 0x5f, 0x52, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x49, 0x54, 0x5f, 0x48, + 0x4f, 0x55, 0x52, 0x10, 0x02, 0x12, 0x17, 0x0a, 0x13, 0x46, 0x49, 0x58, 0x45, 0x44, 0x5f, 0x52, + 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x49, 0x54, 0x5f, 0x44, 0x41, 0x59, 0x10, 0x03, 0x2a, 0x53, + 0x0a, 0x19, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x41, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x10, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, + 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x01, + 0x12, 0x11, 0x0a, 0x0d, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x43, 0x48, 0x45, 0x44, 0x55, 0x4c, + 0x45, 0x10, 0x02, 0x42, 0xb0, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x42, 0x0b, 0x43, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, + 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, + 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, + 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0xa2, + 0x02, 0x03, 0x46, 0x54, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x54, 0x61, 0x73, 0x6b, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x61, 0x73, 0x6b, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x3a, 0x3a, 0x54, 0x61, 0x73, 0x6b, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_task_common_proto_rawDescOnce sync.Once + file_flyteidl2_task_common_proto_rawDescData = file_flyteidl2_task_common_proto_rawDesc +) + +func file_flyteidl2_task_common_proto_rawDescGZIP() []byte { + file_flyteidl2_task_common_proto_rawDescOnce.Do(func() { + file_flyteidl2_task_common_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_task_common_proto_rawDescData) + }) + return file_flyteidl2_task_common_proto_rawDescData +} + +var file_flyteidl2_task_common_proto_enumTypes = make([]protoimpl.EnumInfo, 2) +var file_flyteidl2_task_common_proto_msgTypes = make([]protoimpl.MessageInfo, 9) +var file_flyteidl2_task_common_proto_goTypes = []interface{}{ + (FixedRateUnit)(0), // 0: flyteidl2.task.FixedRateUnit + (TriggerAutomationSpecType)(0), // 1: flyteidl2.task.TriggerAutomationSpecType + (*NamedParameter)(nil), // 2: flyteidl2.task.NamedParameter + (*FixedRate)(nil), // 3: flyteidl2.task.FixedRate + (*Cron)(nil), // 4: flyteidl2.task.Cron + (*Schedule)(nil), // 5: flyteidl2.task.Schedule + (*TriggerAutomationSpec)(nil), // 6: flyteidl2.task.TriggerAutomationSpec + (*NamedLiteral)(nil), // 7: flyteidl2.task.NamedLiteral + (*OutputReferences)(nil), // 8: flyteidl2.task.OutputReferences + (*Inputs)(nil), // 9: flyteidl2.task.Inputs + (*Outputs)(nil), // 10: flyteidl2.task.Outputs + (*core.Parameter)(nil), // 11: flyteidl2.core.Parameter + (*timestamppb.Timestamp)(nil), // 12: google.protobuf.Timestamp + (*core.Literal)(nil), // 13: flyteidl2.core.Literal + (*core.KeyValuePair)(nil), // 14: flyteidl2.core.KeyValuePair +} +var file_flyteidl2_task_common_proto_depIdxs = []int32{ + 11, // 0: flyteidl2.task.NamedParameter.parameter:type_name -> flyteidl2.core.Parameter + 0, // 1: flyteidl2.task.FixedRate.unit:type_name -> flyteidl2.task.FixedRateUnit + 12, // 2: flyteidl2.task.FixedRate.start_time:type_name -> google.protobuf.Timestamp + 3, // 3: flyteidl2.task.Schedule.rate:type_name -> flyteidl2.task.FixedRate + 4, // 4: flyteidl2.task.Schedule.cron:type_name -> flyteidl2.task.Cron + 1, // 5: flyteidl2.task.TriggerAutomationSpec.type:type_name -> flyteidl2.task.TriggerAutomationSpecType + 5, // 6: flyteidl2.task.TriggerAutomationSpec.schedule:type_name -> flyteidl2.task.Schedule + 13, // 7: flyteidl2.task.NamedLiteral.value:type_name -> flyteidl2.core.Literal + 7, // 8: flyteidl2.task.Inputs.literals:type_name -> flyteidl2.task.NamedLiteral + 14, // 9: flyteidl2.task.Inputs.context:type_name -> flyteidl2.core.KeyValuePair + 7, // 10: flyteidl2.task.Outputs.literals:type_name -> flyteidl2.task.NamedLiteral + 11, // [11:11] is the sub-list for method output_type + 11, // [11:11] is the sub-list for method input_type + 11, // [11:11] is the sub-list for extension type_name + 11, // [11:11] is the sub-list for extension extendee + 0, // [0:11] is the sub-list for field type_name +} + +func init() { file_flyteidl2_task_common_proto_init() } +func file_flyteidl2_task_common_proto_init() { + if File_flyteidl2_task_common_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_task_common_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*NamedParameter); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_common_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FixedRate); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_common_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Cron); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_common_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Schedule); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_common_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TriggerAutomationSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_common_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*NamedLiteral); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_common_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OutputReferences); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_common_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Inputs); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_common_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Outputs); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_task_common_proto_msgTypes[3].OneofWrappers = []interface{}{ + (*Schedule_Rate)(nil), + (*Schedule_CronExpression)(nil), + (*Schedule_Cron)(nil), + } + file_flyteidl2_task_common_proto_msgTypes[4].OneofWrappers = []interface{}{ + (*TriggerAutomationSpec_Schedule)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_task_common_proto_rawDesc, + NumEnums: 2, + NumMessages: 9, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_task_common_proto_goTypes, + DependencyIndexes: file_flyteidl2_task_common_proto_depIdxs, + EnumInfos: file_flyteidl2_task_common_proto_enumTypes, + MessageInfos: file_flyteidl2_task_common_proto_msgTypes, + }.Build() + File_flyteidl2_task_common_proto = out.File + file_flyteidl2_task_common_proto_rawDesc = nil + file_flyteidl2_task_common_proto_goTypes = nil + file_flyteidl2_task_common_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/task/common.pb.validate.go b/gen/go/flyteidl2/task/common.pb.validate.go new file mode 100644 index 0000000000..9b648f89e8 --- /dev/null +++ b/gen/go/flyteidl2/task/common.pb.validate.go @@ -0,0 +1,1283 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/task/common.proto + +package task + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on NamedParameter with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *NamedParameter) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on NamedParameter with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in NamedParameterMultiError, +// or nil if none found. +func (m *NamedParameter) ValidateAll() error { + return m.validate(true) +} + +func (m *NamedParameter) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + if all { + switch v := interface{}(m.GetParameter()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, NamedParameterValidationError{ + field: "Parameter", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, NamedParameterValidationError{ + field: "Parameter", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetParameter()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return NamedParameterValidationError{ + field: "Parameter", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return NamedParameterMultiError(errors) + } + + return nil +} + +// NamedParameterMultiError is an error wrapping multiple validation errors +// returned by NamedParameter.ValidateAll() if the designated constraints +// aren't met. +type NamedParameterMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m NamedParameterMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m NamedParameterMultiError) AllErrors() []error { return m } + +// NamedParameterValidationError is the validation error returned by +// NamedParameter.Validate if the designated constraints aren't met. +type NamedParameterValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e NamedParameterValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e NamedParameterValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e NamedParameterValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e NamedParameterValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e NamedParameterValidationError) ErrorName() string { return "NamedParameterValidationError" } + +// Error satisfies the builtin error interface +func (e NamedParameterValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sNamedParameter.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = NamedParameterValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = NamedParameterValidationError{} + +// Validate checks the field values on FixedRate with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *FixedRate) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on FixedRate with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in FixedRateMultiError, or nil +// if none found. +func (m *FixedRate) ValidateAll() error { + return m.validate(true) +} + +func (m *FixedRate) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Value + + // no validation rules for Unit + + if all { + switch v := interface{}(m.GetStartTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, FixedRateValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, FixedRateValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStartTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return FixedRateValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return FixedRateMultiError(errors) + } + + return nil +} + +// FixedRateMultiError is an error wrapping multiple validation errors returned +// by FixedRate.ValidateAll() if the designated constraints aren't met. +type FixedRateMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m FixedRateMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m FixedRateMultiError) AllErrors() []error { return m } + +// FixedRateValidationError is the validation error returned by +// FixedRate.Validate if the designated constraints aren't met. +type FixedRateValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e FixedRateValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e FixedRateValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e FixedRateValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e FixedRateValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e FixedRateValidationError) ErrorName() string { return "FixedRateValidationError" } + +// Error satisfies the builtin error interface +func (e FixedRateValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sFixedRate.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = FixedRateValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = FixedRateValidationError{} + +// Validate checks the field values on Cron with the rules defined in the proto +// definition for this message. If any rules are violated, the first error +// encountered is returned, or nil if there are no violations. +func (m *Cron) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Cron with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in CronMultiError, or nil if none found. +func (m *Cron) ValidateAll() error { + return m.validate(true) +} + +func (m *Cron) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Expression + + // no validation rules for Timezone + + if len(errors) > 0 { + return CronMultiError(errors) + } + + return nil +} + +// CronMultiError is an error wrapping multiple validation errors returned by +// Cron.ValidateAll() if the designated constraints aren't met. +type CronMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CronMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CronMultiError) AllErrors() []error { return m } + +// CronValidationError is the validation error returned by Cron.Validate if the +// designated constraints aren't met. +type CronValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CronValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CronValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CronValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CronValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CronValidationError) ErrorName() string { return "CronValidationError" } + +// Error satisfies the builtin error interface +func (e CronValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCron.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CronValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CronValidationError{} + +// Validate checks the field values on Schedule with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Schedule) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Schedule with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ScheduleMultiError, or nil +// if none found. +func (m *Schedule) ValidateAll() error { + return m.validate(true) +} + +func (m *Schedule) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for KickoffTimeInputArg + + switch v := m.Expression.(type) { + case *Schedule_Rate: + if v == nil { + err := ScheduleValidationError{ + field: "Expression", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetRate()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ScheduleValidationError{ + field: "Rate", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ScheduleValidationError{ + field: "Rate", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRate()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ScheduleValidationError{ + field: "Rate", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *Schedule_CronExpression: + if v == nil { + err := ScheduleValidationError{ + field: "Expression", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for CronExpression + case *Schedule_Cron: + if v == nil { + err := ScheduleValidationError{ + field: "Expression", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetCron()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ScheduleValidationError{ + field: "Cron", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ScheduleValidationError{ + field: "Cron", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCron()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ScheduleValidationError{ + field: "Cron", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return ScheduleMultiError(errors) + } + + return nil +} + +// ScheduleMultiError is an error wrapping multiple validation errors returned +// by Schedule.ValidateAll() if the designated constraints aren't met. +type ScheduleMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ScheduleMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ScheduleMultiError) AllErrors() []error { return m } + +// ScheduleValidationError is the validation error returned by +// Schedule.Validate if the designated constraints aren't met. +type ScheduleValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ScheduleValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ScheduleValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ScheduleValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ScheduleValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ScheduleValidationError) ErrorName() string { return "ScheduleValidationError" } + +// Error satisfies the builtin error interface +func (e ScheduleValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSchedule.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ScheduleValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ScheduleValidationError{} + +// Validate checks the field values on TriggerAutomationSpec with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *TriggerAutomationSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TriggerAutomationSpec with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TriggerAutomationSpecMultiError, or nil if none found. +func (m *TriggerAutomationSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *TriggerAutomationSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Type + + switch v := m.Automation.(type) { + case *TriggerAutomationSpec_Schedule: + if v == nil { + err := TriggerAutomationSpecValidationError{ + field: "Automation", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetSchedule()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerAutomationSpecValidationError{ + field: "Schedule", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerAutomationSpecValidationError{ + field: "Schedule", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSchedule()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerAutomationSpecValidationError{ + field: "Schedule", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return TriggerAutomationSpecMultiError(errors) + } + + return nil +} + +// TriggerAutomationSpecMultiError is an error wrapping multiple validation +// errors returned by TriggerAutomationSpec.ValidateAll() if the designated +// constraints aren't met. +type TriggerAutomationSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TriggerAutomationSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TriggerAutomationSpecMultiError) AllErrors() []error { return m } + +// TriggerAutomationSpecValidationError is the validation error returned by +// TriggerAutomationSpec.Validate if the designated constraints aren't met. +type TriggerAutomationSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TriggerAutomationSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TriggerAutomationSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TriggerAutomationSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TriggerAutomationSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TriggerAutomationSpecValidationError) ErrorName() string { + return "TriggerAutomationSpecValidationError" +} + +// Error satisfies the builtin error interface +func (e TriggerAutomationSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTriggerAutomationSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TriggerAutomationSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TriggerAutomationSpecValidationError{} + +// Validate checks the field values on NamedLiteral with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *NamedLiteral) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on NamedLiteral with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in NamedLiteralMultiError, or +// nil if none found. +func (m *NamedLiteral) ValidateAll() error { + return m.validate(true) +} + +func (m *NamedLiteral) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + if all { + switch v := interface{}(m.GetValue()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, NamedLiteralValidationError{ + field: "Value", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, NamedLiteralValidationError{ + field: "Value", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetValue()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return NamedLiteralValidationError{ + field: "Value", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return NamedLiteralMultiError(errors) + } + + return nil +} + +// NamedLiteralMultiError is an error wrapping multiple validation errors +// returned by NamedLiteral.ValidateAll() if the designated constraints aren't met. +type NamedLiteralMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m NamedLiteralMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m NamedLiteralMultiError) AllErrors() []error { return m } + +// NamedLiteralValidationError is the validation error returned by +// NamedLiteral.Validate if the designated constraints aren't met. +type NamedLiteralValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e NamedLiteralValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e NamedLiteralValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e NamedLiteralValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e NamedLiteralValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e NamedLiteralValidationError) ErrorName() string { return "NamedLiteralValidationError" } + +// Error satisfies the builtin error interface +func (e NamedLiteralValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sNamedLiteral.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = NamedLiteralValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = NamedLiteralValidationError{} + +// Validate checks the field values on OutputReferences with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *OutputReferences) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on OutputReferences with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// OutputReferencesMultiError, or nil if none found. +func (m *OutputReferences) ValidateAll() error { + return m.validate(true) +} + +func (m *OutputReferences) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for OutputUri + + // no validation rules for ReportUri + + if len(errors) > 0 { + return OutputReferencesMultiError(errors) + } + + return nil +} + +// OutputReferencesMultiError is an error wrapping multiple validation errors +// returned by OutputReferences.ValidateAll() if the designated constraints +// aren't met. +type OutputReferencesMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m OutputReferencesMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m OutputReferencesMultiError) AllErrors() []error { return m } + +// OutputReferencesValidationError is the validation error returned by +// OutputReferences.Validate if the designated constraints aren't met. +type OutputReferencesValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e OutputReferencesValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e OutputReferencesValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e OutputReferencesValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e OutputReferencesValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e OutputReferencesValidationError) ErrorName() string { return "OutputReferencesValidationError" } + +// Error satisfies the builtin error interface +func (e OutputReferencesValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sOutputReferences.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = OutputReferencesValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = OutputReferencesValidationError{} + +// Validate checks the field values on Inputs with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Inputs) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Inputs with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in InputsMultiError, or nil if none found. +func (m *Inputs) ValidateAll() error { + return m.validate(true) +} + +func (m *Inputs) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetLiterals() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, InputsValidationError{ + field: fmt.Sprintf("Literals[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, InputsValidationError{ + field: fmt.Sprintf("Literals[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return InputsValidationError{ + field: fmt.Sprintf("Literals[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + for idx, item := range m.GetContext() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, InputsValidationError{ + field: fmt.Sprintf("Context[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, InputsValidationError{ + field: fmt.Sprintf("Context[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return InputsValidationError{ + field: fmt.Sprintf("Context[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return InputsMultiError(errors) + } + + return nil +} + +// InputsMultiError is an error wrapping multiple validation errors returned by +// Inputs.ValidateAll() if the designated constraints aren't met. +type InputsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m InputsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m InputsMultiError) AllErrors() []error { return m } + +// InputsValidationError is the validation error returned by Inputs.Validate if +// the designated constraints aren't met. +type InputsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e InputsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e InputsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e InputsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e InputsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e InputsValidationError) ErrorName() string { return "InputsValidationError" } + +// Error satisfies the builtin error interface +func (e InputsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sInputs.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = InputsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = InputsValidationError{} + +// Validate checks the field values on Outputs with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Outputs) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Outputs with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in OutputsMultiError, or nil if none found. +func (m *Outputs) ValidateAll() error { + return m.validate(true) +} + +func (m *Outputs) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetLiterals() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, OutputsValidationError{ + field: fmt.Sprintf("Literals[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, OutputsValidationError{ + field: fmt.Sprintf("Literals[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return OutputsValidationError{ + field: fmt.Sprintf("Literals[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return OutputsMultiError(errors) + } + + return nil +} + +// OutputsMultiError is an error wrapping multiple validation errors returned +// by Outputs.ValidateAll() if the designated constraints aren't met. +type OutputsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m OutputsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m OutputsMultiError) AllErrors() []error { return m } + +// OutputsValidationError is the validation error returned by Outputs.Validate +// if the designated constraints aren't met. +type OutputsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e OutputsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e OutputsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e OutputsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e OutputsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e OutputsValidationError) ErrorName() string { return "OutputsValidationError" } + +// Error satisfies the builtin error interface +func (e OutputsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sOutputs.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = OutputsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = OutputsValidationError{} diff --git a/gen/go/flyteidl2/task/environment.pb.go b/gen/go/flyteidl2/task/environment.pb.go new file mode 100644 index 0000000000..8a8bbeaee5 --- /dev/null +++ b/gen/go/flyteidl2/task/environment.pb.go @@ -0,0 +1,171 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/task/environment.proto + +package task + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Environment for a task. +type Environment struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Name of the environment. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Description of environment + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` +} + +func (x *Environment) Reset() { + *x = Environment{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_environment_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Environment) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Environment) ProtoMessage() {} + +func (x *Environment) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_environment_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Environment.ProtoReflect.Descriptor instead. +func (*Environment) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_environment_proto_rawDescGZIP(), []int{0} +} + +func (x *Environment) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Environment) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +var File_flyteidl2_task_environment_proto protoreflect.FileDescriptor + +var file_flyteidl2_task_environment_proto_rawDesc = []byte{ + 0x0a, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, + 0x2f, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, + 0x73, 0x6b, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, + 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, + 0x58, 0x0a, 0x0b, 0x45, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x1d, + 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, + 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x3f, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2a, 0x0a, + 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x42, 0x08, 0xba, 0x48, 0x05, 0x72, 0x03, 0x18, 0xff, 0x01, 0x52, 0x0b, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0xb5, 0x01, 0x0a, 0x12, 0x63, 0x6f, + 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, + 0x42, 0x10, 0x45, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x6f, + 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0xa2, 0x02, 0x03, 0x46, 0x54, 0x58, + 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x54, 0x61, 0x73, + 0x6b, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x61, + 0x73, 0x6b, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, + 0x61, 0x73, 0x6b, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, + 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x54, 0x61, 0x73, + 0x6b, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_task_environment_proto_rawDescOnce sync.Once + file_flyteidl2_task_environment_proto_rawDescData = file_flyteidl2_task_environment_proto_rawDesc +) + +func file_flyteidl2_task_environment_proto_rawDescGZIP() []byte { + file_flyteidl2_task_environment_proto_rawDescOnce.Do(func() { + file_flyteidl2_task_environment_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_task_environment_proto_rawDescData) + }) + return file_flyteidl2_task_environment_proto_rawDescData +} + +var file_flyteidl2_task_environment_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_flyteidl2_task_environment_proto_goTypes = []interface{}{ + (*Environment)(nil), // 0: flyteidl2.task.Environment +} +var file_flyteidl2_task_environment_proto_depIdxs = []int32{ + 0, // [0:0] is the sub-list for method output_type + 0, // [0:0] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_flyteidl2_task_environment_proto_init() } +func file_flyteidl2_task_environment_proto_init() { + if File_flyteidl2_task_environment_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_task_environment_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Environment); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_task_environment_proto_rawDesc, + NumEnums: 0, + NumMessages: 1, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_task_environment_proto_goTypes, + DependencyIndexes: file_flyteidl2_task_environment_proto_depIdxs, + MessageInfos: file_flyteidl2_task_environment_proto_msgTypes, + }.Build() + File_flyteidl2_task_environment_proto = out.File + file_flyteidl2_task_environment_proto_rawDesc = nil + file_flyteidl2_task_environment_proto_goTypes = nil + file_flyteidl2_task_environment_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/task/environment.pb.validate.go b/gen/go/flyteidl2/task/environment.pb.validate.go new file mode 100644 index 0000000000..5fb3bb4671 --- /dev/null +++ b/gen/go/flyteidl2/task/environment.pb.validate.go @@ -0,0 +1,139 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/task/environment.proto + +package task + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on Environment with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Environment) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Environment with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in EnvironmentMultiError, or +// nil if none found. +func (m *Environment) ValidateAll() error { + return m.validate(true) +} + +func (m *Environment) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + // no validation rules for Description + + if len(errors) > 0 { + return EnvironmentMultiError(errors) + } + + return nil +} + +// EnvironmentMultiError is an error wrapping multiple validation errors +// returned by Environment.ValidateAll() if the designated constraints aren't met. +type EnvironmentMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m EnvironmentMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m EnvironmentMultiError) AllErrors() []error { return m } + +// EnvironmentValidationError is the validation error returned by +// Environment.Validate if the designated constraints aren't met. +type EnvironmentValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e EnvironmentValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e EnvironmentValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e EnvironmentValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e EnvironmentValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e EnvironmentValidationError) ErrorName() string { return "EnvironmentValidationError" } + +// Error satisfies the builtin error interface +func (e EnvironmentValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sEnvironment.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = EnvironmentValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = EnvironmentValidationError{} diff --git a/gen/go/flyteidl2/task/mocks/is_list_tasks_request_known_filter_filter_by.go b/gen/go/flyteidl2/task/mocks/is_list_tasks_request_known_filter_filter_by.go new file mode 100644 index 0000000000..6a212544a9 --- /dev/null +++ b/gen/go/flyteidl2/task/mocks/is_list_tasks_request_known_filter_filter_by.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isListTasksRequest_KnownFilter_FilterBy is an autogenerated mock type for the isListTasksRequest_KnownFilter_FilterBy type +type isListTasksRequest_KnownFilter_FilterBy struct { + mock.Mock +} + +type isListTasksRequest_KnownFilter_FilterBy_Expecter struct { + mock *mock.Mock +} + +func (_m *isListTasksRequest_KnownFilter_FilterBy) EXPECT() *isListTasksRequest_KnownFilter_FilterBy_Expecter { + return &isListTasksRequest_KnownFilter_FilterBy_Expecter{mock: &_m.Mock} +} + +// isListTasksRequest_KnownFilter_FilterBy provides a mock function with no fields +func (_m *isListTasksRequest_KnownFilter_FilterBy) isListTasksRequest_KnownFilter_FilterBy() { + _m.Called() +} + +// isListTasksRequest_KnownFilter_FilterBy_isListTasksRequest_KnownFilter_FilterBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isListTasksRequest_KnownFilter_FilterBy' +type isListTasksRequest_KnownFilter_FilterBy_isListTasksRequest_KnownFilter_FilterBy_Call struct { + *mock.Call +} + +// isListTasksRequest_KnownFilter_FilterBy is a helper method to define mock.On call +func (_e *isListTasksRequest_KnownFilter_FilterBy_Expecter) isListTasksRequest_KnownFilter_FilterBy() *isListTasksRequest_KnownFilter_FilterBy_isListTasksRequest_KnownFilter_FilterBy_Call { + return &isListTasksRequest_KnownFilter_FilterBy_isListTasksRequest_KnownFilter_FilterBy_Call{Call: _e.mock.On("isListTasksRequest_KnownFilter_FilterBy")} +} + +func (_c *isListTasksRequest_KnownFilter_FilterBy_isListTasksRequest_KnownFilter_FilterBy_Call) Run(run func()) *isListTasksRequest_KnownFilter_FilterBy_isListTasksRequest_KnownFilter_FilterBy_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isListTasksRequest_KnownFilter_FilterBy_isListTasksRequest_KnownFilter_FilterBy_Call) Return() *isListTasksRequest_KnownFilter_FilterBy_isListTasksRequest_KnownFilter_FilterBy_Call { + _c.Call.Return() + return _c +} + +func (_c *isListTasksRequest_KnownFilter_FilterBy_isListTasksRequest_KnownFilter_FilterBy_Call) RunAndReturn(run func()) *isListTasksRequest_KnownFilter_FilterBy_isListTasksRequest_KnownFilter_FilterBy_Call { + _c.Run(run) + return _c +} + +// newIsListTasksRequest_KnownFilter_FilterBy creates a new instance of isListTasksRequest_KnownFilter_FilterBy. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsListTasksRequest_KnownFilter_FilterBy(t interface { + mock.TestingT + Cleanup(func()) +}) *isListTasksRequest_KnownFilter_FilterBy { + mock := &isListTasksRequest_KnownFilter_FilterBy{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/task/mocks/is_list_tasks_request_scope_by.go b/gen/go/flyteidl2/task/mocks/is_list_tasks_request_scope_by.go new file mode 100644 index 0000000000..93f6afaca4 --- /dev/null +++ b/gen/go/flyteidl2/task/mocks/is_list_tasks_request_scope_by.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isListTasksRequest_ScopeBy is an autogenerated mock type for the isListTasksRequest_ScopeBy type +type isListTasksRequest_ScopeBy struct { + mock.Mock +} + +type isListTasksRequest_ScopeBy_Expecter struct { + mock *mock.Mock +} + +func (_m *isListTasksRequest_ScopeBy) EXPECT() *isListTasksRequest_ScopeBy_Expecter { + return &isListTasksRequest_ScopeBy_Expecter{mock: &_m.Mock} +} + +// isListTasksRequest_ScopeBy provides a mock function with no fields +func (_m *isListTasksRequest_ScopeBy) isListTasksRequest_ScopeBy() { + _m.Called() +} + +// isListTasksRequest_ScopeBy_isListTasksRequest_ScopeBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isListTasksRequest_ScopeBy' +type isListTasksRequest_ScopeBy_isListTasksRequest_ScopeBy_Call struct { + *mock.Call +} + +// isListTasksRequest_ScopeBy is a helper method to define mock.On call +func (_e *isListTasksRequest_ScopeBy_Expecter) isListTasksRequest_ScopeBy() *isListTasksRequest_ScopeBy_isListTasksRequest_ScopeBy_Call { + return &isListTasksRequest_ScopeBy_isListTasksRequest_ScopeBy_Call{Call: _e.mock.On("isListTasksRequest_ScopeBy")} +} + +func (_c *isListTasksRequest_ScopeBy_isListTasksRequest_ScopeBy_Call) Run(run func()) *isListTasksRequest_ScopeBy_isListTasksRequest_ScopeBy_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isListTasksRequest_ScopeBy_isListTasksRequest_ScopeBy_Call) Return() *isListTasksRequest_ScopeBy_isListTasksRequest_ScopeBy_Call { + _c.Call.Return() + return _c +} + +func (_c *isListTasksRequest_ScopeBy_isListTasksRequest_ScopeBy_Call) RunAndReturn(run func()) *isListTasksRequest_ScopeBy_isListTasksRequest_ScopeBy_Call { + _c.Run(run) + return _c +} + +// newIsListTasksRequest_ScopeBy creates a new instance of isListTasksRequest_ScopeBy. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsListTasksRequest_ScopeBy(t interface { + mock.TestingT + Cleanup(func()) +}) *isListTasksRequest_ScopeBy { + mock := &isListTasksRequest_ScopeBy{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/task/mocks/is_schedule_expression.go b/gen/go/flyteidl2/task/mocks/is_schedule_expression.go new file mode 100644 index 0000000000..5fdc63f984 --- /dev/null +++ b/gen/go/flyteidl2/task/mocks/is_schedule_expression.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isSchedule_Expression is an autogenerated mock type for the isSchedule_Expression type +type isSchedule_Expression struct { + mock.Mock +} + +type isSchedule_Expression_Expecter struct { + mock *mock.Mock +} + +func (_m *isSchedule_Expression) EXPECT() *isSchedule_Expression_Expecter { + return &isSchedule_Expression_Expecter{mock: &_m.Mock} +} + +// isSchedule_Expression provides a mock function with no fields +func (_m *isSchedule_Expression) isSchedule_Expression() { + _m.Called() +} + +// isSchedule_Expression_isSchedule_Expression_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isSchedule_Expression' +type isSchedule_Expression_isSchedule_Expression_Call struct { + *mock.Call +} + +// isSchedule_Expression is a helper method to define mock.On call +func (_e *isSchedule_Expression_Expecter) isSchedule_Expression() *isSchedule_Expression_isSchedule_Expression_Call { + return &isSchedule_Expression_isSchedule_Expression_Call{Call: _e.mock.On("isSchedule_Expression")} +} + +func (_c *isSchedule_Expression_isSchedule_Expression_Call) Run(run func()) *isSchedule_Expression_isSchedule_Expression_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isSchedule_Expression_isSchedule_Expression_Call) Return() *isSchedule_Expression_isSchedule_Expression_Call { + _c.Call.Return() + return _c +} + +func (_c *isSchedule_Expression_isSchedule_Expression_Call) RunAndReturn(run func()) *isSchedule_Expression_isSchedule_Expression_Call { + _c.Run(run) + return _c +} + +// newIsSchedule_Expression creates a new instance of isSchedule_Expression. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsSchedule_Expression(t interface { + mock.TestingT + Cleanup(func()) +}) *isSchedule_Expression { + mock := &isSchedule_Expression{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/task/mocks/is_task_triggers_summary_summary.go b/gen/go/flyteidl2/task/mocks/is_task_triggers_summary_summary.go new file mode 100644 index 0000000000..a9e75d16a4 --- /dev/null +++ b/gen/go/flyteidl2/task/mocks/is_task_triggers_summary_summary.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isTaskTriggersSummary_Summary is an autogenerated mock type for the isTaskTriggersSummary_Summary type +type isTaskTriggersSummary_Summary struct { + mock.Mock +} + +type isTaskTriggersSummary_Summary_Expecter struct { + mock *mock.Mock +} + +func (_m *isTaskTriggersSummary_Summary) EXPECT() *isTaskTriggersSummary_Summary_Expecter { + return &isTaskTriggersSummary_Summary_Expecter{mock: &_m.Mock} +} + +// isTaskTriggersSummary_Summary provides a mock function with no fields +func (_m *isTaskTriggersSummary_Summary) isTaskTriggersSummary_Summary() { + _m.Called() +} + +// isTaskTriggersSummary_Summary_isTaskTriggersSummary_Summary_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isTaskTriggersSummary_Summary' +type isTaskTriggersSummary_Summary_isTaskTriggersSummary_Summary_Call struct { + *mock.Call +} + +// isTaskTriggersSummary_Summary is a helper method to define mock.On call +func (_e *isTaskTriggersSummary_Summary_Expecter) isTaskTriggersSummary_Summary() *isTaskTriggersSummary_Summary_isTaskTriggersSummary_Summary_Call { + return &isTaskTriggersSummary_Summary_isTaskTriggersSummary_Summary_Call{Call: _e.mock.On("isTaskTriggersSummary_Summary")} +} + +func (_c *isTaskTriggersSummary_Summary_isTaskTriggersSummary_Summary_Call) Run(run func()) *isTaskTriggersSummary_Summary_isTaskTriggersSummary_Summary_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isTaskTriggersSummary_Summary_isTaskTriggersSummary_Summary_Call) Return() *isTaskTriggersSummary_Summary_isTaskTriggersSummary_Summary_Call { + _c.Call.Return() + return _c +} + +func (_c *isTaskTriggersSummary_Summary_isTaskTriggersSummary_Summary_Call) RunAndReturn(run func()) *isTaskTriggersSummary_Summary_isTaskTriggersSummary_Summary_Call { + _c.Run(run) + return _c +} + +// newIsTaskTriggersSummary_Summary creates a new instance of isTaskTriggersSummary_Summary. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsTaskTriggersSummary_Summary(t interface { + mock.TestingT + Cleanup(func()) +}) *isTaskTriggersSummary_Summary { + mock := &isTaskTriggersSummary_Summary{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/task/mocks/is_trigger_automation_spec_automation.go b/gen/go/flyteidl2/task/mocks/is_trigger_automation_spec_automation.go new file mode 100644 index 0000000000..a3b066e377 --- /dev/null +++ b/gen/go/flyteidl2/task/mocks/is_trigger_automation_spec_automation.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isTriggerAutomationSpec_Automation is an autogenerated mock type for the isTriggerAutomationSpec_Automation type +type isTriggerAutomationSpec_Automation struct { + mock.Mock +} + +type isTriggerAutomationSpec_Automation_Expecter struct { + mock *mock.Mock +} + +func (_m *isTriggerAutomationSpec_Automation) EXPECT() *isTriggerAutomationSpec_Automation_Expecter { + return &isTriggerAutomationSpec_Automation_Expecter{mock: &_m.Mock} +} + +// isTriggerAutomationSpec_Automation provides a mock function with no fields +func (_m *isTriggerAutomationSpec_Automation) isTriggerAutomationSpec_Automation() { + _m.Called() +} + +// isTriggerAutomationSpec_Automation_isTriggerAutomationSpec_Automation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isTriggerAutomationSpec_Automation' +type isTriggerAutomationSpec_Automation_isTriggerAutomationSpec_Automation_Call struct { + *mock.Call +} + +// isTriggerAutomationSpec_Automation is a helper method to define mock.On call +func (_e *isTriggerAutomationSpec_Automation_Expecter) isTriggerAutomationSpec_Automation() *isTriggerAutomationSpec_Automation_isTriggerAutomationSpec_Automation_Call { + return &isTriggerAutomationSpec_Automation_isTriggerAutomationSpec_Automation_Call{Call: _e.mock.On("isTriggerAutomationSpec_Automation")} +} + +func (_c *isTriggerAutomationSpec_Automation_isTriggerAutomationSpec_Automation_Call) Run(run func()) *isTriggerAutomationSpec_Automation_isTriggerAutomationSpec_Automation_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isTriggerAutomationSpec_Automation_isTriggerAutomationSpec_Automation_Call) Return() *isTriggerAutomationSpec_Automation_isTriggerAutomationSpec_Automation_Call { + _c.Call.Return() + return _c +} + +func (_c *isTriggerAutomationSpec_Automation_isTriggerAutomationSpec_Automation_Call) RunAndReturn(run func()) *isTriggerAutomationSpec_Automation_isTriggerAutomationSpec_Automation_Call { + _c.Run(run) + return _c +} + +// newIsTriggerAutomationSpec_Automation creates a new instance of isTriggerAutomationSpec_Automation. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsTriggerAutomationSpec_Automation(t interface { + mock.TestingT + Cleanup(func()) +}) *isTriggerAutomationSpec_Automation { + mock := &isTriggerAutomationSpec_Automation{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/task/mocks/task_service_client.go b/gen/go/flyteidl2/task/mocks/task_service_client.go new file mode 100644 index 0000000000..7818ec712f --- /dev/null +++ b/gen/go/flyteidl2/task/mocks/task_service_client.go @@ -0,0 +1,336 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + grpc "google.golang.org/grpc" + + mock "github.com/stretchr/testify/mock" + + task "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" +) + +// TaskServiceClient is an autogenerated mock type for the TaskServiceClient type +type TaskServiceClient struct { + mock.Mock +} + +type TaskServiceClient_Expecter struct { + mock *mock.Mock +} + +func (_m *TaskServiceClient) EXPECT() *TaskServiceClient_Expecter { + return &TaskServiceClient_Expecter{mock: &_m.Mock} +} + +// DeployTask provides a mock function with given fields: ctx, in, opts +func (_m *TaskServiceClient) DeployTask(ctx context.Context, in *task.DeployTaskRequest, opts ...grpc.CallOption) (*task.DeployTaskResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeployTask") + } + + var r0 *task.DeployTaskResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *task.DeployTaskRequest, ...grpc.CallOption) (*task.DeployTaskResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *task.DeployTaskRequest, ...grpc.CallOption) *task.DeployTaskResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*task.DeployTaskResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *task.DeployTaskRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TaskServiceClient_DeployTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeployTask' +type TaskServiceClient_DeployTask_Call struct { + *mock.Call +} + +// DeployTask is a helper method to define mock.On call +// - ctx context.Context +// - in *task.DeployTaskRequest +// - opts ...grpc.CallOption +func (_e *TaskServiceClient_Expecter) DeployTask(ctx interface{}, in interface{}, opts ...interface{}) *TaskServiceClient_DeployTask_Call { + return &TaskServiceClient_DeployTask_Call{Call: _e.mock.On("DeployTask", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *TaskServiceClient_DeployTask_Call) Run(run func(ctx context.Context, in *task.DeployTaskRequest, opts ...grpc.CallOption)) *TaskServiceClient_DeployTask_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*task.DeployTaskRequest), variadicArgs...) + }) + return _c +} + +func (_c *TaskServiceClient_DeployTask_Call) Return(_a0 *task.DeployTaskResponse, _a1 error) *TaskServiceClient_DeployTask_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TaskServiceClient_DeployTask_Call) RunAndReturn(run func(context.Context, *task.DeployTaskRequest, ...grpc.CallOption) (*task.DeployTaskResponse, error)) *TaskServiceClient_DeployTask_Call { + _c.Call.Return(run) + return _c +} + +// GetTaskDetails provides a mock function with given fields: ctx, in, opts +func (_m *TaskServiceClient) GetTaskDetails(ctx context.Context, in *task.GetTaskDetailsRequest, opts ...grpc.CallOption) (*task.GetTaskDetailsResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetTaskDetails") + } + + var r0 *task.GetTaskDetailsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *task.GetTaskDetailsRequest, ...grpc.CallOption) (*task.GetTaskDetailsResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *task.GetTaskDetailsRequest, ...grpc.CallOption) *task.GetTaskDetailsResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*task.GetTaskDetailsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *task.GetTaskDetailsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TaskServiceClient_GetTaskDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTaskDetails' +type TaskServiceClient_GetTaskDetails_Call struct { + *mock.Call +} + +// GetTaskDetails is a helper method to define mock.On call +// - ctx context.Context +// - in *task.GetTaskDetailsRequest +// - opts ...grpc.CallOption +func (_e *TaskServiceClient_Expecter) GetTaskDetails(ctx interface{}, in interface{}, opts ...interface{}) *TaskServiceClient_GetTaskDetails_Call { + return &TaskServiceClient_GetTaskDetails_Call{Call: _e.mock.On("GetTaskDetails", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *TaskServiceClient_GetTaskDetails_Call) Run(run func(ctx context.Context, in *task.GetTaskDetailsRequest, opts ...grpc.CallOption)) *TaskServiceClient_GetTaskDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*task.GetTaskDetailsRequest), variadicArgs...) + }) + return _c +} + +func (_c *TaskServiceClient_GetTaskDetails_Call) Return(_a0 *task.GetTaskDetailsResponse, _a1 error) *TaskServiceClient_GetTaskDetails_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TaskServiceClient_GetTaskDetails_Call) RunAndReturn(run func(context.Context, *task.GetTaskDetailsRequest, ...grpc.CallOption) (*task.GetTaskDetailsResponse, error)) *TaskServiceClient_GetTaskDetails_Call { + _c.Call.Return(run) + return _c +} + +// ListTasks provides a mock function with given fields: ctx, in, opts +func (_m *TaskServiceClient) ListTasks(ctx context.Context, in *task.ListTasksRequest, opts ...grpc.CallOption) (*task.ListTasksResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListTasks") + } + + var r0 *task.ListTasksResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *task.ListTasksRequest, ...grpc.CallOption) (*task.ListTasksResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *task.ListTasksRequest, ...grpc.CallOption) *task.ListTasksResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*task.ListTasksResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *task.ListTasksRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TaskServiceClient_ListTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTasks' +type TaskServiceClient_ListTasks_Call struct { + *mock.Call +} + +// ListTasks is a helper method to define mock.On call +// - ctx context.Context +// - in *task.ListTasksRequest +// - opts ...grpc.CallOption +func (_e *TaskServiceClient_Expecter) ListTasks(ctx interface{}, in interface{}, opts ...interface{}) *TaskServiceClient_ListTasks_Call { + return &TaskServiceClient_ListTasks_Call{Call: _e.mock.On("ListTasks", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *TaskServiceClient_ListTasks_Call) Run(run func(ctx context.Context, in *task.ListTasksRequest, opts ...grpc.CallOption)) *TaskServiceClient_ListTasks_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*task.ListTasksRequest), variadicArgs...) + }) + return _c +} + +func (_c *TaskServiceClient_ListTasks_Call) Return(_a0 *task.ListTasksResponse, _a1 error) *TaskServiceClient_ListTasks_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TaskServiceClient_ListTasks_Call) RunAndReturn(run func(context.Context, *task.ListTasksRequest, ...grpc.CallOption) (*task.ListTasksResponse, error)) *TaskServiceClient_ListTasks_Call { + _c.Call.Return(run) + return _c +} + +// ListVersions provides a mock function with given fields: ctx, in, opts +func (_m *TaskServiceClient) ListVersions(ctx context.Context, in *task.ListVersionsRequest, opts ...grpc.CallOption) (*task.ListVersionsResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListVersions") + } + + var r0 *task.ListVersionsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *task.ListVersionsRequest, ...grpc.CallOption) (*task.ListVersionsResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *task.ListVersionsRequest, ...grpc.CallOption) *task.ListVersionsResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*task.ListVersionsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *task.ListVersionsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TaskServiceClient_ListVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVersions' +type TaskServiceClient_ListVersions_Call struct { + *mock.Call +} + +// ListVersions is a helper method to define mock.On call +// - ctx context.Context +// - in *task.ListVersionsRequest +// - opts ...grpc.CallOption +func (_e *TaskServiceClient_Expecter) ListVersions(ctx interface{}, in interface{}, opts ...interface{}) *TaskServiceClient_ListVersions_Call { + return &TaskServiceClient_ListVersions_Call{Call: _e.mock.On("ListVersions", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *TaskServiceClient_ListVersions_Call) Run(run func(ctx context.Context, in *task.ListVersionsRequest, opts ...grpc.CallOption)) *TaskServiceClient_ListVersions_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*task.ListVersionsRequest), variadicArgs...) + }) + return _c +} + +func (_c *TaskServiceClient_ListVersions_Call) Return(_a0 *task.ListVersionsResponse, _a1 error) *TaskServiceClient_ListVersions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TaskServiceClient_ListVersions_Call) RunAndReturn(run func(context.Context, *task.ListVersionsRequest, ...grpc.CallOption) (*task.ListVersionsResponse, error)) *TaskServiceClient_ListVersions_Call { + _c.Call.Return(run) + return _c +} + +// NewTaskServiceClient creates a new instance of TaskServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTaskServiceClient(t interface { + mock.TestingT + Cleanup(func()) +}) *TaskServiceClient { + mock := &TaskServiceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/task/mocks/task_service_server.go b/gen/go/flyteidl2/task/mocks/task_service_server.go new file mode 100644 index 0000000000..85e811bd96 --- /dev/null +++ b/gen/go/flyteidl2/task/mocks/task_service_server.go @@ -0,0 +1,273 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + task "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + mock "github.com/stretchr/testify/mock" +) + +// TaskServiceServer is an autogenerated mock type for the TaskServiceServer type +type TaskServiceServer struct { + mock.Mock +} + +type TaskServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *TaskServiceServer) EXPECT() *TaskServiceServer_Expecter { + return &TaskServiceServer_Expecter{mock: &_m.Mock} +} + +// DeployTask provides a mock function with given fields: _a0, _a1 +func (_m *TaskServiceServer) DeployTask(_a0 context.Context, _a1 *task.DeployTaskRequest) (*task.DeployTaskResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for DeployTask") + } + + var r0 *task.DeployTaskResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *task.DeployTaskRequest) (*task.DeployTaskResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *task.DeployTaskRequest) *task.DeployTaskResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*task.DeployTaskResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *task.DeployTaskRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TaskServiceServer_DeployTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeployTask' +type TaskServiceServer_DeployTask_Call struct { + *mock.Call +} + +// DeployTask is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *task.DeployTaskRequest +func (_e *TaskServiceServer_Expecter) DeployTask(_a0 interface{}, _a1 interface{}) *TaskServiceServer_DeployTask_Call { + return &TaskServiceServer_DeployTask_Call{Call: _e.mock.On("DeployTask", _a0, _a1)} +} + +func (_c *TaskServiceServer_DeployTask_Call) Run(run func(_a0 context.Context, _a1 *task.DeployTaskRequest)) *TaskServiceServer_DeployTask_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*task.DeployTaskRequest)) + }) + return _c +} + +func (_c *TaskServiceServer_DeployTask_Call) Return(_a0 *task.DeployTaskResponse, _a1 error) *TaskServiceServer_DeployTask_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TaskServiceServer_DeployTask_Call) RunAndReturn(run func(context.Context, *task.DeployTaskRequest) (*task.DeployTaskResponse, error)) *TaskServiceServer_DeployTask_Call { + _c.Call.Return(run) + return _c +} + +// GetTaskDetails provides a mock function with given fields: _a0, _a1 +func (_m *TaskServiceServer) GetTaskDetails(_a0 context.Context, _a1 *task.GetTaskDetailsRequest) (*task.GetTaskDetailsResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetTaskDetails") + } + + var r0 *task.GetTaskDetailsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *task.GetTaskDetailsRequest) (*task.GetTaskDetailsResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *task.GetTaskDetailsRequest) *task.GetTaskDetailsResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*task.GetTaskDetailsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *task.GetTaskDetailsRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TaskServiceServer_GetTaskDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTaskDetails' +type TaskServiceServer_GetTaskDetails_Call struct { + *mock.Call +} + +// GetTaskDetails is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *task.GetTaskDetailsRequest +func (_e *TaskServiceServer_Expecter) GetTaskDetails(_a0 interface{}, _a1 interface{}) *TaskServiceServer_GetTaskDetails_Call { + return &TaskServiceServer_GetTaskDetails_Call{Call: _e.mock.On("GetTaskDetails", _a0, _a1)} +} + +func (_c *TaskServiceServer_GetTaskDetails_Call) Run(run func(_a0 context.Context, _a1 *task.GetTaskDetailsRequest)) *TaskServiceServer_GetTaskDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*task.GetTaskDetailsRequest)) + }) + return _c +} + +func (_c *TaskServiceServer_GetTaskDetails_Call) Return(_a0 *task.GetTaskDetailsResponse, _a1 error) *TaskServiceServer_GetTaskDetails_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TaskServiceServer_GetTaskDetails_Call) RunAndReturn(run func(context.Context, *task.GetTaskDetailsRequest) (*task.GetTaskDetailsResponse, error)) *TaskServiceServer_GetTaskDetails_Call { + _c.Call.Return(run) + return _c +} + +// ListTasks provides a mock function with given fields: _a0, _a1 +func (_m *TaskServiceServer) ListTasks(_a0 context.Context, _a1 *task.ListTasksRequest) (*task.ListTasksResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for ListTasks") + } + + var r0 *task.ListTasksResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *task.ListTasksRequest) (*task.ListTasksResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *task.ListTasksRequest) *task.ListTasksResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*task.ListTasksResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *task.ListTasksRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TaskServiceServer_ListTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTasks' +type TaskServiceServer_ListTasks_Call struct { + *mock.Call +} + +// ListTasks is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *task.ListTasksRequest +func (_e *TaskServiceServer_Expecter) ListTasks(_a0 interface{}, _a1 interface{}) *TaskServiceServer_ListTasks_Call { + return &TaskServiceServer_ListTasks_Call{Call: _e.mock.On("ListTasks", _a0, _a1)} +} + +func (_c *TaskServiceServer_ListTasks_Call) Run(run func(_a0 context.Context, _a1 *task.ListTasksRequest)) *TaskServiceServer_ListTasks_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*task.ListTasksRequest)) + }) + return _c +} + +func (_c *TaskServiceServer_ListTasks_Call) Return(_a0 *task.ListTasksResponse, _a1 error) *TaskServiceServer_ListTasks_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TaskServiceServer_ListTasks_Call) RunAndReturn(run func(context.Context, *task.ListTasksRequest) (*task.ListTasksResponse, error)) *TaskServiceServer_ListTasks_Call { + _c.Call.Return(run) + return _c +} + +// ListVersions provides a mock function with given fields: _a0, _a1 +func (_m *TaskServiceServer) ListVersions(_a0 context.Context, _a1 *task.ListVersionsRequest) (*task.ListVersionsResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for ListVersions") + } + + var r0 *task.ListVersionsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *task.ListVersionsRequest) (*task.ListVersionsResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *task.ListVersionsRequest) *task.ListVersionsResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*task.ListVersionsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *task.ListVersionsRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TaskServiceServer_ListVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVersions' +type TaskServiceServer_ListVersions_Call struct { + *mock.Call +} + +// ListVersions is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *task.ListVersionsRequest +func (_e *TaskServiceServer_Expecter) ListVersions(_a0 interface{}, _a1 interface{}) *TaskServiceServer_ListVersions_Call { + return &TaskServiceServer_ListVersions_Call{Call: _e.mock.On("ListVersions", _a0, _a1)} +} + +func (_c *TaskServiceServer_ListVersions_Call) Run(run func(_a0 context.Context, _a1 *task.ListVersionsRequest)) *TaskServiceServer_ListVersions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*task.ListVersionsRequest)) + }) + return _c +} + +func (_c *TaskServiceServer_ListVersions_Call) Return(_a0 *task.ListVersionsResponse, _a1 error) *TaskServiceServer_ListVersions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TaskServiceServer_ListVersions_Call) RunAndReturn(run func(context.Context, *task.ListVersionsRequest) (*task.ListVersionsResponse, error)) *TaskServiceServer_ListVersions_Call { + _c.Call.Return(run) + return _c +} + +// NewTaskServiceServer creates a new instance of TaskServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTaskServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *TaskServiceServer { + mock := &TaskServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/task/mocks/unsafe_task_service_server.go b/gen/go/flyteidl2/task/mocks/unsafe_task_service_server.go new file mode 100644 index 0000000000..1118d29731 --- /dev/null +++ b/gen/go/flyteidl2/task/mocks/unsafe_task_service_server.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// UnsafeTaskServiceServer is an autogenerated mock type for the UnsafeTaskServiceServer type +type UnsafeTaskServiceServer struct { + mock.Mock +} + +type UnsafeTaskServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *UnsafeTaskServiceServer) EXPECT() *UnsafeTaskServiceServer_Expecter { + return &UnsafeTaskServiceServer_Expecter{mock: &_m.Mock} +} + +// mustEmbedUnimplementedTaskServiceServer provides a mock function with no fields +func (_m *UnsafeTaskServiceServer) mustEmbedUnimplementedTaskServiceServer() { + _m.Called() +} + +// UnsafeTaskServiceServer_mustEmbedUnimplementedTaskServiceServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'mustEmbedUnimplementedTaskServiceServer' +type UnsafeTaskServiceServer_mustEmbedUnimplementedTaskServiceServer_Call struct { + *mock.Call +} + +// mustEmbedUnimplementedTaskServiceServer is a helper method to define mock.On call +func (_e *UnsafeTaskServiceServer_Expecter) mustEmbedUnimplementedTaskServiceServer() *UnsafeTaskServiceServer_mustEmbedUnimplementedTaskServiceServer_Call { + return &UnsafeTaskServiceServer_mustEmbedUnimplementedTaskServiceServer_Call{Call: _e.mock.On("mustEmbedUnimplementedTaskServiceServer")} +} + +func (_c *UnsafeTaskServiceServer_mustEmbedUnimplementedTaskServiceServer_Call) Run(run func()) *UnsafeTaskServiceServer_mustEmbedUnimplementedTaskServiceServer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UnsafeTaskServiceServer_mustEmbedUnimplementedTaskServiceServer_Call) Return() *UnsafeTaskServiceServer_mustEmbedUnimplementedTaskServiceServer_Call { + _c.Call.Return() + return _c +} + +func (_c *UnsafeTaskServiceServer_mustEmbedUnimplementedTaskServiceServer_Call) RunAndReturn(run func()) *UnsafeTaskServiceServer_mustEmbedUnimplementedTaskServiceServer_Call { + _c.Run(run) + return _c +} + +// NewUnsafeTaskServiceServer creates a new instance of UnsafeTaskServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewUnsafeTaskServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *UnsafeTaskServiceServer { + mock := &UnsafeTaskServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/task/run.pb.go b/gen/go/flyteidl2/task/run.pb.go new file mode 100644 index 0000000000..2cc31e9bf9 --- /dev/null +++ b/gen/go/flyteidl2/task/run.pb.go @@ -0,0 +1,711 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/task/run.proto + +package task + +import ( + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb "google.golang.org/protobuf/types/known/wrapperspb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type CacheLookupScope int32 + +const ( + // CACHE_LOOKUP_SCOPE_UNSPECIFIED instructs cache lookup to follow the default behavior (global unless configured + // otherwise) + CacheLookupScope_CACHE_LOOKUP_SCOPE_UNSPECIFIED CacheLookupScope = 0 + // CACHE_LOOKUP_SCOPE_GLOBAL instructs cache lookups to do a global lookup (unless overridden by a system config). + // This has traditionally been the default behavior. It requires all workloads running in all projects/domains + // to have access to the same artifacts/buckets. Otherwise it risks runtime failures. + CacheLookupScope_CACHE_LOOKUP_SCOPE_GLOBAL CacheLookupScope = 1 + // CACHE_LOOKUP_SCOPE_PROJECT_DOMAIN instructs cache lookups to do a project-domain scoped lookup. This ensures + // data access success at the expense of potentially more cache misses and recomputation happening. This should not + // be considered a security enforcement (that can happen through the system-wide config). + CacheLookupScope_CACHE_LOOKUP_SCOPE_PROJECT_DOMAIN CacheLookupScope = 2 +) + +// Enum value maps for CacheLookupScope. +var ( + CacheLookupScope_name = map[int32]string{ + 0: "CACHE_LOOKUP_SCOPE_UNSPECIFIED", + 1: "CACHE_LOOKUP_SCOPE_GLOBAL", + 2: "CACHE_LOOKUP_SCOPE_PROJECT_DOMAIN", + } + CacheLookupScope_value = map[string]int32{ + "CACHE_LOOKUP_SCOPE_UNSPECIFIED": 0, + "CACHE_LOOKUP_SCOPE_GLOBAL": 1, + "CACHE_LOOKUP_SCOPE_PROJECT_DOMAIN": 2, + } +) + +func (x CacheLookupScope) Enum() *CacheLookupScope { + p := new(CacheLookupScope) + *p = x + return p +} + +func (x CacheLookupScope) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (CacheLookupScope) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_task_run_proto_enumTypes[0].Descriptor() +} + +func (CacheLookupScope) Type() protoreflect.EnumType { + return &file_flyteidl2_task_run_proto_enumTypes[0] +} + +func (x CacheLookupScope) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use CacheLookupScope.Descriptor instead. +func (CacheLookupScope) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_task_run_proto_rawDescGZIP(), []int{0} +} + +// Label values to be applied to an execution resource. +// In the future a mode (e.g. OVERRIDE, APPEND, etc) can be defined +// to specify how to merge labels defined at registration and execution time. +type Labels struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Map of custom labels to be applied to the execution resource. + Values map[string]string `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *Labels) Reset() { + *x = Labels{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_run_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Labels) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Labels) ProtoMessage() {} + +func (x *Labels) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_run_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Labels.ProtoReflect.Descriptor instead. +func (*Labels) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_run_proto_rawDescGZIP(), []int{0} +} + +func (x *Labels) GetValues() map[string]string { + if x != nil { + return x.Values + } + return nil +} + +// Annotation values to be applied to an execution resource. +// In the future a mode (e.g. OVERRIDE, APPEND, etc) can be defined +// to specify how to merge annotations defined at registration and execution time. +type Annotations struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Map of custom annotations to be applied to the execution resource. + Values map[string]string `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *Annotations) Reset() { + *x = Annotations{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_run_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Annotations) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Annotations) ProtoMessage() {} + +func (x *Annotations) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_run_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Annotations.ProtoReflect.Descriptor instead. +func (*Annotations) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_run_proto_rawDescGZIP(), []int{1} +} + +func (x *Annotations) GetValues() map[string]string { + if x != nil { + return x.Values + } + return nil +} + +// Environment variable values to be applied to an execution resource. +// In the future a mode (e.g. OVERRIDE, APPEND, etc) can be defined +// to specify how to merge environment variables defined at registration and execution time. +type Envs struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Map of custom environment variables to be applied to the execution resource. + Values []*core.KeyValuePair `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"` +} + +func (x *Envs) Reset() { + *x = Envs{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_run_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Envs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Envs) ProtoMessage() {} + +func (x *Envs) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_run_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Envs.ProtoReflect.Descriptor instead. +func (*Envs) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_run_proto_rawDescGZIP(), []int{2} +} + +func (x *Envs) GetValues() []*core.KeyValuePair { + if x != nil { + return x.Values + } + return nil +} + +type RawDataStorage struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Prefix for where offloaded data from user actions will be written + // e.g. s3://bucket/key or s3://bucket/ + RawDataPrefix string `protobuf:"bytes,1,opt,name=raw_data_prefix,json=rawDataPrefix,proto3" json:"raw_data_prefix,omitempty"` +} + +func (x *RawDataStorage) Reset() { + *x = RawDataStorage{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_run_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RawDataStorage) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RawDataStorage) ProtoMessage() {} + +func (x *RawDataStorage) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_run_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RawDataStorage.ProtoReflect.Descriptor instead. +func (*RawDataStorage) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_run_proto_rawDescGZIP(), []int{3} +} + +func (x *RawDataStorage) GetRawDataPrefix() string { + if x != nil { + return x.RawDataPrefix + } + return "" +} + +// CacheConfig contains configurations that influence the behavior of cache reads and writes +type CacheConfig struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // If true, recompute outputs for this run and overwrite any existing cache. + OverwriteCache bool `protobuf:"varint,1,opt,name=overwrite_cache,json=overwriteCache,proto3" json:"overwrite_cache,omitempty"` + // CacheLookupScope defines the cache lookup behavior. If left unspecified, the default value from the system config + // will be used (global unless configured otherwise). + CacheLookupScope CacheLookupScope `protobuf:"varint,2,opt,name=cache_lookup_scope,json=cacheLookupScope,proto3,enum=flyteidl2.task.CacheLookupScope" json:"cache_lookup_scope,omitempty"` +} + +func (x *CacheConfig) Reset() { + *x = CacheConfig{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_run_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CacheConfig) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CacheConfig) ProtoMessage() {} + +func (x *CacheConfig) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_run_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CacheConfig.ProtoReflect.Descriptor instead. +func (*CacheConfig) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_run_proto_rawDescGZIP(), []int{4} +} + +func (x *CacheConfig) GetOverwriteCache() bool { + if x != nil { + return x.OverwriteCache + } + return false +} + +func (x *CacheConfig) GetCacheLookupScope() CacheLookupScope { + if x != nil { + return x.CacheLookupScope + } + return CacheLookupScope_CACHE_LOOKUP_SCOPE_UNSPECIFIED +} + +type RunSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Labels to apply to the run. + Labels *Labels `protobuf:"bytes,1,opt,name=labels,proto3" json:"labels,omitempty"` + // Annotations to apply to the run. + Annotations *Annotations `protobuf:"bytes,2,opt,name=annotations,proto3" json:"annotations,omitempty"` + // Envs to apply to the run. + Envs *Envs `protobuf:"bytes,3,opt,name=envs,proto3" json:"envs,omitempty"` + // Explicit override for executing this run as interruptible or not. If not set, use the default. + Interruptible *wrapperspb.BoolValue `protobuf:"bytes,4,opt,name=interruptible,proto3" json:"interruptible,omitempty"` + // If true, recompute outputs for this run and overwrite any existing cache. + // Deprecated, please use CacheConfig.OverwriteCache instead + // + // Deprecated: Marked as deprecated in flyteidl2/task/run.proto. + OverwriteCache bool `protobuf:"varint,5,opt,name=overwrite_cache,json=overwriteCache,proto3" json:"overwrite_cache,omitempty"` + // the specific cluster that this action should be executed on. this value will be used as the + // default for all actions in the run unless overridden. + Cluster string `protobuf:"bytes,6,opt,name=cluster,proto3" json:"cluster,omitempty"` + // Encapsulates user settings pertaining to offloaded data (i.e. Blobs, Schema, query data, etc.). + RawDataStorage *RawDataStorage `protobuf:"bytes,7,opt,name=raw_data_storage,json=rawDataStorage,proto3" json:"raw_data_storage,omitempty"` + // SecurityContext holds security attributes that apply to tasks. + SecurityContext *core.SecurityContext `protobuf:"bytes,8,opt,name=security_context,json=securityContext,proto3" json:"security_context,omitempty"` + // CacheConfig contains configurations that influence the behavior of cache reads and writes + CacheConfig *CacheConfig `protobuf:"bytes,9,opt,name=cache_config,json=cacheConfig,proto3" json:"cache_config,omitempty"` +} + +func (x *RunSpec) Reset() { + *x = RunSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_run_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RunSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RunSpec) ProtoMessage() {} + +func (x *RunSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_run_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RunSpec.ProtoReflect.Descriptor instead. +func (*RunSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_run_proto_rawDescGZIP(), []int{5} +} + +func (x *RunSpec) GetLabels() *Labels { + if x != nil { + return x.Labels + } + return nil +} + +func (x *RunSpec) GetAnnotations() *Annotations { + if x != nil { + return x.Annotations + } + return nil +} + +func (x *RunSpec) GetEnvs() *Envs { + if x != nil { + return x.Envs + } + return nil +} + +func (x *RunSpec) GetInterruptible() *wrapperspb.BoolValue { + if x != nil { + return x.Interruptible + } + return nil +} + +// Deprecated: Marked as deprecated in flyteidl2/task/run.proto. +func (x *RunSpec) GetOverwriteCache() bool { + if x != nil { + return x.OverwriteCache + } + return false +} + +func (x *RunSpec) GetCluster() string { + if x != nil { + return x.Cluster + } + return "" +} + +func (x *RunSpec) GetRawDataStorage() *RawDataStorage { + if x != nil { + return x.RawDataStorage + } + return nil +} + +func (x *RunSpec) GetSecurityContext() *core.SecurityContext { + if x != nil { + return x.SecurityContext + } + return nil +} + +func (x *RunSpec) GetCacheConfig() *CacheConfig { + if x != nil { + return x.CacheConfig + } + return nil +} + +var File_flyteidl2_task_run_proto protoreflect.FileDescriptor + +var file_flyteidl2_task_run_proto_rawDesc = []byte{ + 0x0a, 0x18, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, + 0x2f, 0x72, 0x75, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x1a, 0x1d, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x6c, 0x69, 0x74, 0x65, 0x72, + 0x61, 0x6c, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, + 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, + 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x7f, 0x0a, 0x06, 0x4c, 0x61, 0x62, 0x65, + 0x6c, 0x73, 0x12, 0x3a, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, + 0x61, 0x73, 0x6b, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x1a, 0x39, + 0x0a, 0x0b, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, + 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, + 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x89, 0x01, 0x0a, 0x0b, 0x41, 0x6e, + 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3f, 0x0a, 0x06, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x41, 0x6e, 0x6e, 0x6f, 0x74, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x1a, 0x39, 0x0a, 0x0b, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x3c, 0x0a, 0x04, 0x45, 0x6e, 0x76, 0x73, 0x12, 0x34, 0x0a, + 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, + 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x61, 0x69, 0x72, 0x52, 0x06, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x22, 0x38, 0x0a, 0x0e, 0x52, 0x61, 0x77, 0x44, 0x61, 0x74, 0x61, 0x53, 0x74, + 0x6f, 0x72, 0x61, 0x67, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x72, 0x61, 0x77, 0x5f, 0x64, 0x61, 0x74, + 0x61, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, + 0x72, 0x61, 0x77, 0x44, 0x61, 0x74, 0x61, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x22, 0x86, 0x01, + 0x0a, 0x0b, 0x43, 0x61, 0x63, 0x68, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x27, 0x0a, + 0x0f, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x5f, 0x63, 0x61, 0x63, 0x68, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, + 0x65, 0x43, 0x61, 0x63, 0x68, 0x65, 0x12, 0x4e, 0x0a, 0x12, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, + 0x6c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x5f, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, + 0x61, 0x73, 0x6b, 0x2e, 0x43, 0x61, 0x63, 0x68, 0x65, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x53, + 0x63, 0x6f, 0x70, 0x65, 0x52, 0x10, 0x63, 0x61, 0x63, 0x68, 0x65, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, + 0x70, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x22, 0x81, 0x04, 0x0a, 0x07, 0x52, 0x75, 0x6e, 0x53, 0x70, + 0x65, 0x63, 0x12, 0x2e, 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, + 0x61, 0x73, 0x6b, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, + 0x6c, 0x73, 0x12, 0x3d, 0x0a, 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x12, 0x28, 0x0a, 0x04, 0x65, 0x6e, 0x76, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x14, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, + 0x2e, 0x45, 0x6e, 0x76, 0x73, 0x52, 0x04, 0x65, 0x6e, 0x76, 0x73, 0x12, 0x40, 0x0a, 0x0d, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0d, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x12, 0x2b, 0x0a, + 0x0f, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x5f, 0x63, 0x61, 0x63, 0x68, 0x65, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0e, 0x6f, 0x76, 0x65, 0x72, + 0x77, 0x72, 0x69, 0x74, 0x65, 0x43, 0x61, 0x63, 0x68, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x12, 0x48, 0x0a, 0x10, 0x72, 0x61, 0x77, 0x5f, 0x64, 0x61, 0x74, 0x61, + 0x5f, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x52, 0x61, 0x77, 0x44, 0x61, 0x74, 0x61, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x52, 0x0e, + 0x72, 0x61, 0x77, 0x44, 0x61, 0x74, 0x61, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x12, 0x4a, + 0x0a, 0x10, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, + 0x78, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, + 0x74, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, 0x0f, 0x73, 0x65, 0x63, 0x75, 0x72, + 0x69, 0x74, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x3e, 0x0a, 0x0c, 0x63, 0x61, + 0x63, 0x68, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, + 0x6b, 0x2e, 0x43, 0x61, 0x63, 0x68, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0b, 0x63, + 0x61, 0x63, 0x68, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2a, 0x7c, 0x0a, 0x10, 0x43, 0x61, + 0x63, 0x68, 0x65, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x22, + 0x0a, 0x1e, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x4c, 0x4f, 0x4f, 0x4b, 0x55, 0x50, 0x5f, 0x53, + 0x43, 0x4f, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, + 0x10, 0x00, 0x12, 0x1d, 0x0a, 0x19, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x4c, 0x4f, 0x4f, 0x4b, + 0x55, 0x50, 0x5f, 0x53, 0x43, 0x4f, 0x50, 0x45, 0x5f, 0x47, 0x4c, 0x4f, 0x42, 0x41, 0x4c, 0x10, + 0x01, 0x12, 0x25, 0x0a, 0x21, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x4c, 0x4f, 0x4f, 0x4b, 0x55, + 0x50, 0x5f, 0x53, 0x43, 0x4f, 0x50, 0x45, 0x5f, 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, 0x5f, + 0x44, 0x4f, 0x4d, 0x41, 0x49, 0x4e, 0x10, 0x02, 0x42, 0xad, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x42, + 0x08, 0x52, 0x75, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x32, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, + 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, + 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, + 0x6b, 0xa2, 0x02, 0x03, 0x46, 0x54, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x61, 0x73, 0x6b, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x61, 0x73, 0x6b, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x3a, 0x3a, 0x54, 0x61, 0x73, 0x6b, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_task_run_proto_rawDescOnce sync.Once + file_flyteidl2_task_run_proto_rawDescData = file_flyteidl2_task_run_proto_rawDesc +) + +func file_flyteidl2_task_run_proto_rawDescGZIP() []byte { + file_flyteidl2_task_run_proto_rawDescOnce.Do(func() { + file_flyteidl2_task_run_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_task_run_proto_rawDescData) + }) + return file_flyteidl2_task_run_proto_rawDescData +} + +var file_flyteidl2_task_run_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_flyteidl2_task_run_proto_msgTypes = make([]protoimpl.MessageInfo, 8) +var file_flyteidl2_task_run_proto_goTypes = []interface{}{ + (CacheLookupScope)(0), // 0: flyteidl2.task.CacheLookupScope + (*Labels)(nil), // 1: flyteidl2.task.Labels + (*Annotations)(nil), // 2: flyteidl2.task.Annotations + (*Envs)(nil), // 3: flyteidl2.task.Envs + (*RawDataStorage)(nil), // 4: flyteidl2.task.RawDataStorage + (*CacheConfig)(nil), // 5: flyteidl2.task.CacheConfig + (*RunSpec)(nil), // 6: flyteidl2.task.RunSpec + nil, // 7: flyteidl2.task.Labels.ValuesEntry + nil, // 8: flyteidl2.task.Annotations.ValuesEntry + (*core.KeyValuePair)(nil), // 9: flyteidl2.core.KeyValuePair + (*wrapperspb.BoolValue)(nil), // 10: google.protobuf.BoolValue + (*core.SecurityContext)(nil), // 11: flyteidl2.core.SecurityContext +} +var file_flyteidl2_task_run_proto_depIdxs = []int32{ + 7, // 0: flyteidl2.task.Labels.values:type_name -> flyteidl2.task.Labels.ValuesEntry + 8, // 1: flyteidl2.task.Annotations.values:type_name -> flyteidl2.task.Annotations.ValuesEntry + 9, // 2: flyteidl2.task.Envs.values:type_name -> flyteidl2.core.KeyValuePair + 0, // 3: flyteidl2.task.CacheConfig.cache_lookup_scope:type_name -> flyteidl2.task.CacheLookupScope + 1, // 4: flyteidl2.task.RunSpec.labels:type_name -> flyteidl2.task.Labels + 2, // 5: flyteidl2.task.RunSpec.annotations:type_name -> flyteidl2.task.Annotations + 3, // 6: flyteidl2.task.RunSpec.envs:type_name -> flyteidl2.task.Envs + 10, // 7: flyteidl2.task.RunSpec.interruptible:type_name -> google.protobuf.BoolValue + 4, // 8: flyteidl2.task.RunSpec.raw_data_storage:type_name -> flyteidl2.task.RawDataStorage + 11, // 9: flyteidl2.task.RunSpec.security_context:type_name -> flyteidl2.core.SecurityContext + 5, // 10: flyteidl2.task.RunSpec.cache_config:type_name -> flyteidl2.task.CacheConfig + 11, // [11:11] is the sub-list for method output_type + 11, // [11:11] is the sub-list for method input_type + 11, // [11:11] is the sub-list for extension type_name + 11, // [11:11] is the sub-list for extension extendee + 0, // [0:11] is the sub-list for field type_name +} + +func init() { file_flyteidl2_task_run_proto_init() } +func file_flyteidl2_task_run_proto_init() { + if File_flyteidl2_task_run_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_task_run_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Labels); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_run_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Annotations); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_run_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Envs); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_run_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RawDataStorage); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_run_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CacheConfig); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_run_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RunSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_task_run_proto_rawDesc, + NumEnums: 1, + NumMessages: 8, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_task_run_proto_goTypes, + DependencyIndexes: file_flyteidl2_task_run_proto_depIdxs, + EnumInfos: file_flyteidl2_task_run_proto_enumTypes, + MessageInfos: file_flyteidl2_task_run_proto_msgTypes, + }.Build() + File_flyteidl2_task_run_proto = out.File + file_flyteidl2_task_run_proto_rawDesc = nil + file_flyteidl2_task_run_proto_goTypes = nil + file_flyteidl2_task_run_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/task/run.pb.validate.go b/gen/go/flyteidl2/task/run.pb.validate.go new file mode 100644 index 0000000000..bd3fba7e93 --- /dev/null +++ b/gen/go/flyteidl2/task/run.pb.validate.go @@ -0,0 +1,879 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/task/run.proto + +package task + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on Labels with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Labels) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Labels with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in LabelsMultiError, or nil if none found. +func (m *Labels) ValidateAll() error { + return m.validate(true) +} + +func (m *Labels) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Values + + if len(errors) > 0 { + return LabelsMultiError(errors) + } + + return nil +} + +// LabelsMultiError is an error wrapping multiple validation errors returned by +// Labels.ValidateAll() if the designated constraints aren't met. +type LabelsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LabelsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LabelsMultiError) AllErrors() []error { return m } + +// LabelsValidationError is the validation error returned by Labels.Validate if +// the designated constraints aren't met. +type LabelsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LabelsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LabelsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LabelsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LabelsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LabelsValidationError) ErrorName() string { return "LabelsValidationError" } + +// Error satisfies the builtin error interface +func (e LabelsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLabels.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LabelsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LabelsValidationError{} + +// Validate checks the field values on Annotations with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Annotations) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Annotations with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in AnnotationsMultiError, or +// nil if none found. +func (m *Annotations) ValidateAll() error { + return m.validate(true) +} + +func (m *Annotations) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Values + + if len(errors) > 0 { + return AnnotationsMultiError(errors) + } + + return nil +} + +// AnnotationsMultiError is an error wrapping multiple validation errors +// returned by Annotations.ValidateAll() if the designated constraints aren't met. +type AnnotationsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m AnnotationsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m AnnotationsMultiError) AllErrors() []error { return m } + +// AnnotationsValidationError is the validation error returned by +// Annotations.Validate if the designated constraints aren't met. +type AnnotationsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e AnnotationsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e AnnotationsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e AnnotationsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e AnnotationsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e AnnotationsValidationError) ErrorName() string { return "AnnotationsValidationError" } + +// Error satisfies the builtin error interface +func (e AnnotationsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sAnnotations.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = AnnotationsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = AnnotationsValidationError{} + +// Validate checks the field values on Envs with the rules defined in the proto +// definition for this message. If any rules are violated, the first error +// encountered is returned, or nil if there are no violations. +func (m *Envs) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Envs with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in EnvsMultiError, or nil if none found. +func (m *Envs) ValidateAll() error { + return m.validate(true) +} + +func (m *Envs) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetValues() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, EnvsValidationError{ + field: fmt.Sprintf("Values[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, EnvsValidationError{ + field: fmt.Sprintf("Values[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return EnvsValidationError{ + field: fmt.Sprintf("Values[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return EnvsMultiError(errors) + } + + return nil +} + +// EnvsMultiError is an error wrapping multiple validation errors returned by +// Envs.ValidateAll() if the designated constraints aren't met. +type EnvsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m EnvsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m EnvsMultiError) AllErrors() []error { return m } + +// EnvsValidationError is the validation error returned by Envs.Validate if the +// designated constraints aren't met. +type EnvsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e EnvsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e EnvsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e EnvsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e EnvsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e EnvsValidationError) ErrorName() string { return "EnvsValidationError" } + +// Error satisfies the builtin error interface +func (e EnvsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sEnvs.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = EnvsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = EnvsValidationError{} + +// Validate checks the field values on RawDataStorage with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *RawDataStorage) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on RawDataStorage with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in RawDataStorageMultiError, +// or nil if none found. +func (m *RawDataStorage) ValidateAll() error { + return m.validate(true) +} + +func (m *RawDataStorage) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for RawDataPrefix + + if len(errors) > 0 { + return RawDataStorageMultiError(errors) + } + + return nil +} + +// RawDataStorageMultiError is an error wrapping multiple validation errors +// returned by RawDataStorage.ValidateAll() if the designated constraints +// aren't met. +type RawDataStorageMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m RawDataStorageMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m RawDataStorageMultiError) AllErrors() []error { return m } + +// RawDataStorageValidationError is the validation error returned by +// RawDataStorage.Validate if the designated constraints aren't met. +type RawDataStorageValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e RawDataStorageValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e RawDataStorageValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e RawDataStorageValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e RawDataStorageValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e RawDataStorageValidationError) ErrorName() string { return "RawDataStorageValidationError" } + +// Error satisfies the builtin error interface +func (e RawDataStorageValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sRawDataStorage.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = RawDataStorageValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = RawDataStorageValidationError{} + +// Validate checks the field values on CacheConfig with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *CacheConfig) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CacheConfig with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in CacheConfigMultiError, or +// nil if none found. +func (m *CacheConfig) ValidateAll() error { + return m.validate(true) +} + +func (m *CacheConfig) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for OverwriteCache + + // no validation rules for CacheLookupScope + + if len(errors) > 0 { + return CacheConfigMultiError(errors) + } + + return nil +} + +// CacheConfigMultiError is an error wrapping multiple validation errors +// returned by CacheConfig.ValidateAll() if the designated constraints aren't met. +type CacheConfigMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CacheConfigMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CacheConfigMultiError) AllErrors() []error { return m } + +// CacheConfigValidationError is the validation error returned by +// CacheConfig.Validate if the designated constraints aren't met. +type CacheConfigValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CacheConfigValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CacheConfigValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CacheConfigValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CacheConfigValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CacheConfigValidationError) ErrorName() string { return "CacheConfigValidationError" } + +// Error satisfies the builtin error interface +func (e CacheConfigValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCacheConfig.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CacheConfigValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CacheConfigValidationError{} + +// Validate checks the field values on RunSpec with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *RunSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on RunSpec with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in RunSpecMultiError, or nil if none found. +func (m *RunSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *RunSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetLabels()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, RunSpecValidationError{ + field: "Labels", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, RunSpecValidationError{ + field: "Labels", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLabels()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return RunSpecValidationError{ + field: "Labels", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetAnnotations()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, RunSpecValidationError{ + field: "Annotations", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, RunSpecValidationError{ + field: "Annotations", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAnnotations()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return RunSpecValidationError{ + field: "Annotations", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetEnvs()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, RunSpecValidationError{ + field: "Envs", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, RunSpecValidationError{ + field: "Envs", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetEnvs()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return RunSpecValidationError{ + field: "Envs", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetInterruptible()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, RunSpecValidationError{ + field: "Interruptible", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, RunSpecValidationError{ + field: "Interruptible", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetInterruptible()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return RunSpecValidationError{ + field: "Interruptible", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for OverwriteCache + + // no validation rules for Cluster + + if all { + switch v := interface{}(m.GetRawDataStorage()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, RunSpecValidationError{ + field: "RawDataStorage", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, RunSpecValidationError{ + field: "RawDataStorage", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRawDataStorage()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return RunSpecValidationError{ + field: "RawDataStorage", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetSecurityContext()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, RunSpecValidationError{ + field: "SecurityContext", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, RunSpecValidationError{ + field: "SecurityContext", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSecurityContext()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return RunSpecValidationError{ + field: "SecurityContext", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetCacheConfig()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, RunSpecValidationError{ + field: "CacheConfig", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, RunSpecValidationError{ + field: "CacheConfig", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCacheConfig()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return RunSpecValidationError{ + field: "CacheConfig", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return RunSpecMultiError(errors) + } + + return nil +} + +// RunSpecMultiError is an error wrapping multiple validation errors returned +// by RunSpec.ValidateAll() if the designated constraints aren't met. +type RunSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m RunSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m RunSpecMultiError) AllErrors() []error { return m } + +// RunSpecValidationError is the validation error returned by RunSpec.Validate +// if the designated constraints aren't met. +type RunSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e RunSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e RunSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e RunSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e RunSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e RunSpecValidationError) ErrorName() string { return "RunSpecValidationError" } + +// Error satisfies the builtin error interface +func (e RunSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sRunSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = RunSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = RunSpecValidationError{} diff --git a/gen/go/flyteidl2/task/task_definition.pb.go b/gen/go/flyteidl2/task/task_definition.pb.go new file mode 100644 index 0000000000..cd226adb01 --- /dev/null +++ b/gen/go/flyteidl2/task/task_definition.pb.go @@ -0,0 +1,1654 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/task/task_definition.proto + +package task + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Name of a task. It may have multiple versions deployed. +type TaskName struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Org this task belongs to. + Org string `protobuf:"bytes,1,opt,name=org,proto3" json:"org,omitempty"` + // Project this task belongs to. + Project string `protobuf:"bytes,2,opt,name=project,proto3" json:"project,omitempty"` + // Domain this task belongs to. + Domain string `protobuf:"bytes,3,opt,name=domain,proto3" json:"domain,omitempty"` + // Unique name of the task. Should not be interpreted/parsed. Use `short_name` and `environment_name` for user facing names. + Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *TaskName) Reset() { + *x = TaskName{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskName) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskName) ProtoMessage() {} + +func (x *TaskName) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskName.ProtoReflect.Descriptor instead. +func (*TaskName) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_definition_proto_rawDescGZIP(), []int{0} +} + +func (x *TaskName) GetOrg() string { + if x != nil { + return x.Org + } + return "" +} + +func (x *TaskName) GetProject() string { + if x != nil { + return x.Project + } + return "" +} + +func (x *TaskName) GetDomain() string { + if x != nil { + return x.Domain + } + return "" +} + +func (x *TaskName) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +// TaskIdentifier is the unique identifier for a task. +type TaskIdentifier struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Org this task belongs to. + Org string `protobuf:"bytes,1,opt,name=org,proto3" json:"org,omitempty"` + // Project this task belongs to. + Project string `protobuf:"bytes,2,opt,name=project,proto3" json:"project,omitempty"` + // Domain this task belongs to. + Domain string `protobuf:"bytes,3,opt,name=domain,proto3" json:"domain,omitempty"` + // Unique name of the task. Should not be interpreted/parsed. Use `short_name` and `environment_name` for user facing names. + Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"` + // Version of the task. + Version string `protobuf:"bytes,5,opt,name=version,proto3" json:"version,omitempty"` +} + +func (x *TaskIdentifier) Reset() { + *x = TaskIdentifier{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskIdentifier) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskIdentifier) ProtoMessage() {} + +func (x *TaskIdentifier) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskIdentifier.ProtoReflect.Descriptor instead. +func (*TaskIdentifier) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_definition_proto_rawDescGZIP(), []int{1} +} + +func (x *TaskIdentifier) GetOrg() string { + if x != nil { + return x.Org + } + return "" +} + +func (x *TaskIdentifier) GetProject() string { + if x != nil { + return x.Project + } + return "" +} + +func (x *TaskIdentifier) GetDomain() string { + if x != nil { + return x.Domain + } + return "" +} + +func (x *TaskIdentifier) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *TaskIdentifier) GetVersion() string { + if x != nil { + return x.Version + } + return "" +} + +type TaskTriggersSummary struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Summary: + // + // *TaskTriggersSummary_Details + // *TaskTriggersSummary_Stats + Summary isTaskTriggersSummary_Summary `protobuf_oneof:"summary"` +} + +func (x *TaskTriggersSummary) Reset() { + *x = TaskTriggersSummary{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskTriggersSummary) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskTriggersSummary) ProtoMessage() {} + +func (x *TaskTriggersSummary) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskTriggersSummary.ProtoReflect.Descriptor instead. +func (*TaskTriggersSummary) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_definition_proto_rawDescGZIP(), []int{2} +} + +func (m *TaskTriggersSummary) GetSummary() isTaskTriggersSummary_Summary { + if m != nil { + return m.Summary + } + return nil +} + +func (x *TaskTriggersSummary) GetDetails() *TaskTriggersSummary_TriggerDetails { + if x, ok := x.GetSummary().(*TaskTriggersSummary_Details); ok { + return x.Details + } + return nil +} + +func (x *TaskTriggersSummary) GetStats() *TaskTriggersSummary_TriggerStats { + if x, ok := x.GetSummary().(*TaskTriggersSummary_Stats); ok { + return x.Stats + } + return nil +} + +type isTaskTriggersSummary_Summary interface { + isTaskTriggersSummary_Summary() +} + +type TaskTriggersSummary_Details struct { + Details *TaskTriggersSummary_TriggerDetails `protobuf:"bytes,3,opt,name=details,proto3,oneof"` +} + +type TaskTriggersSummary_Stats struct { + Stats *TaskTriggersSummary_TriggerStats `protobuf:"bytes,2,opt,name=stats,proto3,oneof"` +} + +func (*TaskTriggersSummary_Details) isTaskTriggersSummary_Summary() {} + +func (*TaskTriggersSummary_Stats) isTaskTriggersSummary_Summary() {} + +// LatestRunSummary contains minimal information about the most recent run of a task. +// This is a lightweight summary that avoids circular dependencies with workflow package. +type LatestRunSummary struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Run identifier + RunId *common.RunIdentifier `protobuf:"bytes,1,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"` + // Last run time + RunTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=run_time,json=runTime,proto3" json:"run_time,omitempty"` + // Phase of the last run + Phase common.ActionPhase `protobuf:"varint,3,opt,name=phase,proto3,enum=flyteidl2.common.ActionPhase" json:"phase,omitempty"` + // Name of the root task of the last run (env.task name) + RootTaskName string `protobuf:"bytes,4,opt,name=root_task_name,json=rootTaskName,proto3" json:"root_task_name,omitempty"` +} + +func (x *LatestRunSummary) Reset() { + *x = LatestRunSummary{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LatestRunSummary) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LatestRunSummary) ProtoMessage() {} + +func (x *LatestRunSummary) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LatestRunSummary.ProtoReflect.Descriptor instead. +func (*LatestRunSummary) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_definition_proto_rawDescGZIP(), []int{3} +} + +func (x *LatestRunSummary) GetRunId() *common.RunIdentifier { + if x != nil { + return x.RunId + } + return nil +} + +func (x *LatestRunSummary) GetRunTime() *timestamppb.Timestamp { + if x != nil { + return x.RunTime + } + return nil +} + +func (x *LatestRunSummary) GetPhase() common.ActionPhase { + if x != nil { + return x.Phase + } + return common.ActionPhase(0) +} + +func (x *LatestRunSummary) GetRootTaskName() string { + if x != nil { + return x.RootTaskName + } + return "" +} + +// TaskMetadata is static, lightweight metadata about a task. +type TaskMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Identity that deployed the task. + DeployedBy *common.EnrichedIdentity `protobuf:"bytes,1,opt,name=deployed_by,json=deployedBy,proto3" json:"deployed_by,omitempty"` + // The short name for this task + ShortName string `protobuf:"bytes,2,opt,name=short_name,json=shortName,proto3" json:"short_name,omitempty"` + // The time the task was deployed + DeployedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=deployed_at,json=deployedAt,proto3" json:"deployed_at,omitempty"` + // The environment name for this task, if present. + EnvironmentName string `protobuf:"bytes,4,opt,name=environment_name,json=environmentName,proto3" json:"environment_name,omitempty"` + // Brief overview of attached triggers if any. + TriggersSummary *TaskTriggersSummary `protobuf:"bytes,5,opt,name=triggers_summary,json=triggersSummary,proto3" json:"triggers_summary,omitempty"` + // The short description for this task + ShortDescription string `protobuf:"bytes,6,opt,name=short_description,json=shortDescription,proto3" json:"short_description,omitempty"` +} + +func (x *TaskMetadata) Reset() { + *x = TaskMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskMetadata) ProtoMessage() {} + +func (x *TaskMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskMetadata.ProtoReflect.Descriptor instead. +func (*TaskMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_definition_proto_rawDescGZIP(), []int{4} +} + +func (x *TaskMetadata) GetDeployedBy() *common.EnrichedIdentity { + if x != nil { + return x.DeployedBy + } + return nil +} + +func (x *TaskMetadata) GetShortName() string { + if x != nil { + return x.ShortName + } + return "" +} + +func (x *TaskMetadata) GetDeployedAt() *timestamppb.Timestamp { + if x != nil { + return x.DeployedAt + } + return nil +} + +func (x *TaskMetadata) GetEnvironmentName() string { + if x != nil { + return x.EnvironmentName + } + return "" +} + +func (x *TaskMetadata) GetTriggersSummary() *TaskTriggersSummary { + if x != nil { + return x.TriggersSummary + } + return nil +} + +func (x *TaskMetadata) GetShortDescription() string { + if x != nil { + return x.ShortDescription + } + return "" +} + +type TaskSummary struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Summary of the latest run for this task, if any + LatestRun *LatestRunSummary `protobuf:"bytes,1,opt,name=latest_run,json=latestRun,proto3,oneof" json:"latest_run,omitempty"` +} + +func (x *TaskSummary) Reset() { + *x = TaskSummary{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskSummary) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskSummary) ProtoMessage() {} + +func (x *TaskSummary) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskSummary.ProtoReflect.Descriptor instead. +func (*TaskSummary) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_definition_proto_rawDescGZIP(), []int{5} +} + +func (x *TaskSummary) GetLatestRun() *LatestRunSummary { + if x != nil { + return x.LatestRun + } + return nil +} + +// Lightweight representation of a task. +type Task struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Id for this task. + TaskId *TaskIdentifier `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"` + // Metadata for this task. + Metadata *TaskMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"` + // Summary for this task. + TaskSummary *TaskSummary `protobuf:"bytes,3,opt,name=task_summary,json=taskSummary,proto3,oneof" json:"task_summary,omitempty"` +} + +func (x *Task) Reset() { + *x = Task{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Task) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Task) ProtoMessage() {} + +func (x *Task) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Task.ProtoReflect.Descriptor instead. +func (*Task) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_definition_proto_rawDescGZIP(), []int{6} +} + +func (x *Task) GetTaskId() *TaskIdentifier { + if x != nil { + return x.TaskId + } + return nil +} + +func (x *Task) GetMetadata() *TaskMetadata { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *Task) GetTaskSummary() *TaskSummary { + if x != nil { + return x.TaskSummary + } + return nil +} + +// Link to source code used to define this entity +type SourceCode struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Link string `protobuf:"bytes,1,opt,name=link,proto3" json:"link,omitempty"` +} + +func (x *SourceCode) Reset() { + *x = SourceCode{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SourceCode) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SourceCode) ProtoMessage() {} + +func (x *SourceCode) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SourceCode.ProtoReflect.Descriptor instead. +func (*SourceCode) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_definition_proto_rawDescGZIP(), []int{7} +} + +func (x *SourceCode) GetLink() string { + if x != nil { + return x.Link + } + return "" +} + +type DocumentationEntity struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // One-liner overview of the entity. + ShortDescription string `protobuf:"bytes,1,opt,name=short_description,json=shortDescription,proto3" json:"short_description,omitempty"` + // Full user description with formatting preserved. + LongDescription string `protobuf:"bytes,2,opt,name=long_description,json=longDescription,proto3" json:"long_description,omitempty"` + // Optional link to source code used to define this entity. + SourceCode *SourceCode `protobuf:"bytes,3,opt,name=source_code,json=sourceCode,proto3" json:"source_code,omitempty"` +} + +func (x *DocumentationEntity) Reset() { + *x = DocumentationEntity{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DocumentationEntity) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DocumentationEntity) ProtoMessage() {} + +func (x *DocumentationEntity) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DocumentationEntity.ProtoReflect.Descriptor instead. +func (*DocumentationEntity) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_definition_proto_rawDescGZIP(), []int{8} +} + +func (x *DocumentationEntity) GetShortDescription() string { + if x != nil { + return x.ShortDescription + } + return "" +} + +func (x *DocumentationEntity) GetLongDescription() string { + if x != nil { + return x.LongDescription + } + return "" +} + +func (x *DocumentationEntity) GetSourceCode() *SourceCode { + if x != nil { + return x.SourceCode + } + return nil +} + +// Specification for a task. +type TaskSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The template for this task. + TaskTemplate *core.TaskTemplate `protobuf:"bytes,1,opt,name=task_template,json=taskTemplate,proto3" json:"task_template,omitempty"` + // Ordered default inputs. + // These can be overridden when an run is created. + // Client should not send required=true flag in underlying flyteidl2.core.Parameter. + DefaultInputs []*NamedParameter `protobuf:"bytes,2,rep,name=default_inputs,json=defaultInputs,proto3" json:"default_inputs,omitempty"` + // User facing display name for this task. Not required to be unique. + // This is passed in via the SDK when the task is created and is either a user defined override or the name of the task. + ShortName string `protobuf:"bytes,3,opt,name=short_name,json=shortName,proto3" json:"short_name,omitempty"` + // Optional environment for this task. Note, some tasks may not be run in the context of an environment. + Environment *Environment `protobuf:"bytes,4,opt,name=environment,proto3" json:"environment,omitempty"` + // The documentation entity for the task + Documentation *DocumentationEntity `protobuf:"bytes,5,opt,name=documentation,proto3" json:"documentation,omitempty"` +} + +func (x *TaskSpec) Reset() { + *x = TaskSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskSpec) ProtoMessage() {} + +func (x *TaskSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskSpec.ProtoReflect.Descriptor instead. +func (*TaskSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_definition_proto_rawDescGZIP(), []int{9} +} + +func (x *TaskSpec) GetTaskTemplate() *core.TaskTemplate { + if x != nil { + return x.TaskTemplate + } + return nil +} + +func (x *TaskSpec) GetDefaultInputs() []*NamedParameter { + if x != nil { + return x.DefaultInputs + } + return nil +} + +func (x *TaskSpec) GetShortName() string { + if x != nil { + return x.ShortName + } + return "" +} + +func (x *TaskSpec) GetEnvironment() *Environment { + if x != nil { + return x.Environment + } + return nil +} + +func (x *TaskSpec) GetDocumentation() *DocumentationEntity { + if x != nil { + return x.Documentation + } + return nil +} + +// Specification for a trace action. +type TraceSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // A strongly typed interface for the trace. + Interface *core.TypedInterface `protobuf:"bytes,1,opt,name=interface,proto3" json:"interface,omitempty"` +} + +func (x *TraceSpec) Reset() { + *x = TraceSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TraceSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TraceSpec) ProtoMessage() {} + +func (x *TraceSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TraceSpec.ProtoReflect.Descriptor instead. +func (*TraceSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_definition_proto_rawDescGZIP(), []int{10} +} + +func (x *TraceSpec) GetInterface() *core.TypedInterface { + if x != nil { + return x.Interface + } + return nil +} + +// Detailed information about a task. +type TaskDetails struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Id for this task. + TaskId *TaskIdentifier `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"` + // Metadata for this task. + Metadata *TaskMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"` + // Specification for this task. + Spec *TaskSpec `protobuf:"bytes,3,opt,name=spec,proto3" json:"spec,omitempty"` +} + +func (x *TaskDetails) Reset() { + *x = TaskDetails{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskDetails) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskDetails) ProtoMessage() {} + +func (x *TaskDetails) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskDetails.ProtoReflect.Descriptor instead. +func (*TaskDetails) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_definition_proto_rawDescGZIP(), []int{11} +} + +func (x *TaskDetails) GetTaskId() *TaskIdentifier { + if x != nil { + return x.TaskId + } + return nil +} + +func (x *TaskDetails) GetMetadata() *TaskMetadata { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *TaskDetails) GetSpec() *TaskSpec { + if x != nil { + return x.Spec + } + return nil +} + +// Contains details about a single trigger attached to a task. Should only be used in DeployTask endpoint. +type TaskTrigger struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Spec *TaskTriggerSpec `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"` + // Optional automation spec. + AutomationSpec *TriggerAutomationSpec `protobuf:"bytes,3,opt,name=automation_spec,json=automationSpec,proto3" json:"automation_spec,omitempty"` +} + +func (x *TaskTrigger) Reset() { + *x = TaskTrigger{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskTrigger) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskTrigger) ProtoMessage() {} + +func (x *TaskTrigger) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskTrigger.ProtoReflect.Descriptor instead. +func (*TaskTrigger) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_definition_proto_rawDescGZIP(), []int{12} +} + +func (x *TaskTrigger) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *TaskTrigger) GetSpec() *TaskTriggerSpec { + if x != nil { + return x.Spec + } + return nil +} + +func (x *TaskTrigger) GetAutomationSpec() *TriggerAutomationSpec { + if x != nil { + return x.AutomationSpec + } + return nil +} + +// TaskTriggerSpec this is a copy of TriggerSpec without mandatory 'task_version' field. +// This is supposed to be used only in DeployTask endpoint where 'task_version' is already provided in task_id. +type TaskTriggerSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Whether trigger is active + Active bool `protobuf:"varint,1,opt,name=active,proto3" json:"active,omitempty"` + // Inputs for triggered task. + Inputs *Inputs `protobuf:"bytes,2,opt,name=inputs,proto3" json:"inputs,omitempty"` + // The run spec for triggered task. + RunSpec *RunSpec `protobuf:"bytes,3,opt,name=run_spec,json=runSpec,proto3" json:"run_spec,omitempty"` + // Optional description + Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` +} + +func (x *TaskTriggerSpec) Reset() { + *x = TaskTriggerSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskTriggerSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskTriggerSpec) ProtoMessage() {} + +func (x *TaskTriggerSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskTriggerSpec.ProtoReflect.Descriptor instead. +func (*TaskTriggerSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_definition_proto_rawDescGZIP(), []int{13} +} + +func (x *TaskTriggerSpec) GetActive() bool { + if x != nil { + return x.Active + } + return false +} + +func (x *TaskTriggerSpec) GetInputs() *Inputs { + if x != nil { + return x.Inputs + } + return nil +} + +func (x *TaskTriggerSpec) GetRunSpec() *RunSpec { + if x != nil { + return x.RunSpec + } + return nil +} + +func (x *TaskTriggerSpec) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +type TaskTriggersSummary_TriggerDetails struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Active bool `protobuf:"varint,2,opt,name=active,proto3" json:"active,omitempty"` + AutomationSpec *TriggerAutomationSpec `protobuf:"bytes,3,opt,name=automation_spec,json=automationSpec,proto3" json:"automation_spec,omitempty"` +} + +func (x *TaskTriggersSummary_TriggerDetails) Reset() { + *x = TaskTriggersSummary_TriggerDetails{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskTriggersSummary_TriggerDetails) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskTriggersSummary_TriggerDetails) ProtoMessage() {} + +func (x *TaskTriggersSummary_TriggerDetails) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskTriggersSummary_TriggerDetails.ProtoReflect.Descriptor instead. +func (*TaskTriggersSummary_TriggerDetails) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_definition_proto_rawDescGZIP(), []int{2, 0} +} + +func (x *TaskTriggersSummary_TriggerDetails) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *TaskTriggersSummary_TriggerDetails) GetActive() bool { + if x != nil { + return x.Active + } + return false +} + +func (x *TaskTriggersSummary_TriggerDetails) GetAutomationSpec() *TriggerAutomationSpec { + if x != nil { + return x.AutomationSpec + } + return nil +} + +type TaskTriggersSummary_TriggerStats struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Total uint32 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"` + Active uint32 `protobuf:"varint,2,opt,name=active,proto3" json:"active,omitempty"` +} + +func (x *TaskTriggersSummary_TriggerStats) Reset() { + *x = TaskTriggersSummary_TriggerStats{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskTriggersSummary_TriggerStats) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskTriggersSummary_TriggerStats) ProtoMessage() {} + +func (x *TaskTriggersSummary_TriggerStats) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_definition_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskTriggersSummary_TriggerStats.ProtoReflect.Descriptor instead. +func (*TaskTriggersSummary_TriggerStats) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_definition_proto_rawDescGZIP(), []int{2, 1} +} + +func (x *TaskTriggersSummary_TriggerStats) GetTotal() uint32 { + if x != nil { + return x.Total + } + return 0 +} + +func (x *TaskTriggersSummary_TriggerStats) GetActive() uint32 { + if x != nil { + return x.Active + } + return 0 +} + +var File_flyteidl2_task_task_definition_proto protoreflect.FileDescriptor + +var file_flyteidl2_task_task_definition_proto_rawDesc = []byte{ + 0x0a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, + 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x70, 0x68, 0x61, 0x73, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, + 0x6b, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x65, + 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x18, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, + 0x2f, 0x72, 0x75, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x8f, 0x01, 0x0a, 0x08, + 0x54, 0x61, 0x73, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1b, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x3f, + 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x23, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, + 0x3f, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x21, 0x0a, 0x06, 0x64, 0x6f, + 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, + 0x04, 0x10, 0x01, 0x18, 0x3f, 0x52, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x1e, 0x0a, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0a, 0xba, 0x48, 0x07, + 0x72, 0x05, 0x10, 0x01, 0x18, 0xff, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0xba, 0x01, + 0x0a, 0x0e, 0x54, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x12, 0x1b, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, + 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x3f, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x23, 0x0a, + 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, + 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x3f, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x12, 0x21, 0x0a, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x3f, 0x52, 0x06, 0x64, + 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x1e, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x09, 0x42, 0x0a, 0xba, 0x48, 0x07, 0x72, 0x05, 0x10, 0x01, 0x18, 0xff, 0x01, 0x52, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, + 0x3f, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x8d, 0x03, 0x0a, 0x13, 0x54, + 0x61, 0x73, 0x6b, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x53, 0x75, 0x6d, 0x6d, 0x61, + 0x72, 0x79, 0x12, 0x4e, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x73, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x12, 0x48, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x30, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, + 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x53, + 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, 0x74, + 0x61, 0x74, 0x73, 0x48, 0x00, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x73, 0x1a, 0x8c, 0x01, 0x0a, + 0x0e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, + 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x12, 0x4e, 0x0a, 0x0f, 0x61, + 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x41, 0x75, 0x74, + 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0e, 0x61, 0x75, 0x74, + 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x1a, 0x3c, 0x0a, 0x0c, 0x54, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, + 0x6f, 0x74, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x74, 0x6f, 0x74, 0x61, + 0x6c, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x42, 0x09, 0x0a, 0x07, 0x73, 0x75, 0x6d, + 0x6d, 0x61, 0x72, 0x79, 0x4a, 0x04, 0x08, 0x01, 0x10, 0x02, 0x22, 0xdc, 0x01, 0x0a, 0x10, 0x4c, + 0x61, 0x74, 0x65, 0x73, 0x74, 0x52, 0x75, 0x6e, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, + 0x36, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x52, 0x75, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x52, 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x12, 0x35, 0x0a, 0x08, 0x72, 0x75, 0x6e, 0x5f, 0x74, + 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x07, 0x72, 0x75, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x33, + 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x68, 0x61, 0x73, 0x65, 0x52, 0x05, 0x70, 0x68, + 0x61, 0x73, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x74, 0x61, 0x73, 0x6b, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x6f, 0x6f, + 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0xe7, 0x02, 0x0a, 0x0c, 0x54, 0x61, + 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x4b, 0x0a, 0x0b, 0x64, 0x65, + 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x0a, 0x64, 0x65, 0x70, + 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x42, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x68, 0x6f, 0x72, 0x74, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x68, 0x6f, + 0x72, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x43, 0x0a, 0x0b, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, + 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, + 0x0a, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x41, 0x74, 0x12, 0x29, 0x0a, 0x10, 0x65, + 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, + 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x4e, 0x0a, 0x10, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x73, 0x5f, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, + 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x53, 0x75, + 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x0f, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x53, + 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x10, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x22, 0x62, 0x0a, 0x0b, 0x54, 0x61, 0x73, 0x6b, 0x53, 0x75, 0x6d, 0x6d, 0x61, + 0x72, 0x79, 0x12, 0x44, 0x0a, 0x0a, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x72, 0x75, 0x6e, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x52, 0x75, + 0x6e, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x48, 0x00, 0x52, 0x09, 0x6c, 0x61, 0x74, 0x65, + 0x73, 0x74, 0x52, 0x75, 0x6e, 0x88, 0x01, 0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x6c, 0x61, 0x74, + 0x65, 0x73, 0x74, 0x5f, 0x72, 0x75, 0x6e, 0x22, 0xdf, 0x01, 0x0a, 0x04, 0x54, 0x61, 0x73, 0x6b, + 0x12, 0x3f, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, + 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, + 0x64, 0x12, 0x40, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x12, 0x43, 0x0a, 0x0c, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x73, 0x75, 0x6d, 0x6d, + 0x61, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x53, + 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x48, 0x00, 0x52, 0x0b, 0x74, 0x61, 0x73, 0x6b, 0x53, 0x75, + 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x88, 0x01, 0x01, 0x42, 0x0f, 0x0a, 0x0d, 0x5f, 0x74, 0x61, 0x73, + 0x6b, 0x5f, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x20, 0x0a, 0x0a, 0x53, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6c, 0x69, 0x6e, 0x6b, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6c, 0x69, 0x6e, 0x6b, 0x22, 0xbe, 0x01, 0x0a, 0x13, + 0x44, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x12, 0x35, 0x0a, 0x11, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x64, 0x65, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x08, + 0xba, 0x48, 0x05, 0x72, 0x03, 0x18, 0xff, 0x01, 0x52, 0x10, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x44, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x33, 0x0a, 0x10, 0x6c, 0x6f, + 0x6e, 0x67, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x08, 0xba, 0x48, 0x05, 0x72, 0x03, 0x18, 0x80, 0x10, 0x52, 0x0f, + 0x6c, 0x6f, 0x6e, 0x67, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x3b, 0x0a, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, + 0x52, 0x0a, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x22, 0xce, 0x02, 0x0a, + 0x08, 0x54, 0x61, 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x12, 0x49, 0x0a, 0x0d, 0x74, 0x61, 0x73, + 0x6b, 0x5f, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x42, 0x06, + 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x0c, 0x74, 0x61, 0x73, 0x6b, 0x54, 0x65, 0x6d, 0x70, + 0x6c, 0x61, 0x74, 0x65, 0x12, 0x45, 0x0a, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, + 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4e, 0x61, + 0x6d, 0x65, 0x64, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x52, 0x0d, 0x64, 0x65, + 0x66, 0x61, 0x75, 0x6c, 0x74, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x12, 0x26, 0x0a, 0x0a, 0x73, + 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, + 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x18, 0x3f, 0x52, 0x09, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x4e, + 0x61, 0x6d, 0x65, 0x12, 0x3d, 0x0a, 0x0b, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, + 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x45, 0x6e, 0x76, 0x69, 0x72, 0x6f, + 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x0b, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, + 0x6e, 0x74, 0x12, 0x49, 0x0a, 0x0d, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x44, 0x6f, 0x63, 0x75, 0x6d, + 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x0d, + 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x49, 0x0a, + 0x09, 0x54, 0x72, 0x61, 0x63, 0x65, 0x53, 0x70, 0x65, 0x63, 0x12, 0x3c, 0x0a, 0x09, 0x69, 0x6e, + 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, + 0x79, 0x70, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x52, 0x09, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x22, 0xc6, 0x01, 0x0a, 0x0b, 0x54, 0x61, 0x73, + 0x6b, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x3f, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, + 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, + 0x01, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x12, 0x40, 0x0a, 0x08, 0x6d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, + 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, + 0x01, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x34, 0x0a, 0x04, 0x73, + 0x70, 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x53, + 0x70, 0x65, 0x63, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x04, 0x73, 0x70, 0x65, + 0x63, 0x22, 0xba, 0x01, 0x0a, 0x0b, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x12, 0x1e, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, + 0x0a, 0xba, 0x48, 0x07, 0x72, 0x05, 0x10, 0x01, 0x18, 0xff, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x12, 0x3b, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, + 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, 0x70, 0x65, 0x63, + 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x04, 0x73, 0x70, 0x65, 0x63, 0x12, 0x4e, + 0x0a, 0x0f, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x70, 0x65, + 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x41, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0e, + 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x22, 0xaf, + 0x01, 0x0a, 0x0f, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, 0x70, + 0x65, 0x63, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x12, 0x2e, 0x0a, 0x06, 0x69, 0x6e, + 0x70, 0x75, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x49, 0x6e, 0x70, 0x75, + 0x74, 0x73, 0x52, 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x12, 0x32, 0x0a, 0x08, 0x72, 0x75, + 0x6e, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x52, 0x75, + 0x6e, 0x53, 0x70, 0x65, 0x63, 0x52, 0x07, 0x72, 0x75, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x12, 0x20, + 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x42, 0xb8, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x42, 0x13, 0x54, 0x61, 0x73, 0x6b, 0x44, 0x65, 0x66, + 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, + 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, + 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x74, 0x61, 0x73, 0x6b, 0xa2, 0x02, 0x03, 0x46, 0x54, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0xca, 0x02, 0x0e, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x61, 0x73, 0x6b, 0xe2, 0x02, 0x1a, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x61, 0x73, 0x6b, 0x5c, 0x47, 0x50, + 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x54, 0x61, 0x73, 0x6b, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_task_task_definition_proto_rawDescOnce sync.Once + file_flyteidl2_task_task_definition_proto_rawDescData = file_flyteidl2_task_task_definition_proto_rawDesc +) + +func file_flyteidl2_task_task_definition_proto_rawDescGZIP() []byte { + file_flyteidl2_task_task_definition_proto_rawDescOnce.Do(func() { + file_flyteidl2_task_task_definition_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_task_task_definition_proto_rawDescData) + }) + return file_flyteidl2_task_task_definition_proto_rawDescData +} + +var file_flyteidl2_task_task_definition_proto_msgTypes = make([]protoimpl.MessageInfo, 16) +var file_flyteidl2_task_task_definition_proto_goTypes = []interface{}{ + (*TaskName)(nil), // 0: flyteidl2.task.TaskName + (*TaskIdentifier)(nil), // 1: flyteidl2.task.TaskIdentifier + (*TaskTriggersSummary)(nil), // 2: flyteidl2.task.TaskTriggersSummary + (*LatestRunSummary)(nil), // 3: flyteidl2.task.LatestRunSummary + (*TaskMetadata)(nil), // 4: flyteidl2.task.TaskMetadata + (*TaskSummary)(nil), // 5: flyteidl2.task.TaskSummary + (*Task)(nil), // 6: flyteidl2.task.Task + (*SourceCode)(nil), // 7: flyteidl2.task.SourceCode + (*DocumentationEntity)(nil), // 8: flyteidl2.task.DocumentationEntity + (*TaskSpec)(nil), // 9: flyteidl2.task.TaskSpec + (*TraceSpec)(nil), // 10: flyteidl2.task.TraceSpec + (*TaskDetails)(nil), // 11: flyteidl2.task.TaskDetails + (*TaskTrigger)(nil), // 12: flyteidl2.task.TaskTrigger + (*TaskTriggerSpec)(nil), // 13: flyteidl2.task.TaskTriggerSpec + (*TaskTriggersSummary_TriggerDetails)(nil), // 14: flyteidl2.task.TaskTriggersSummary.TriggerDetails + (*TaskTriggersSummary_TriggerStats)(nil), // 15: flyteidl2.task.TaskTriggersSummary.TriggerStats + (*common.RunIdentifier)(nil), // 16: flyteidl2.common.RunIdentifier + (*timestamppb.Timestamp)(nil), // 17: google.protobuf.Timestamp + (common.ActionPhase)(0), // 18: flyteidl2.common.ActionPhase + (*common.EnrichedIdentity)(nil), // 19: flyteidl2.common.EnrichedIdentity + (*core.TaskTemplate)(nil), // 20: flyteidl2.core.TaskTemplate + (*NamedParameter)(nil), // 21: flyteidl2.task.NamedParameter + (*Environment)(nil), // 22: flyteidl2.task.Environment + (*core.TypedInterface)(nil), // 23: flyteidl2.core.TypedInterface + (*TriggerAutomationSpec)(nil), // 24: flyteidl2.task.TriggerAutomationSpec + (*Inputs)(nil), // 25: flyteidl2.task.Inputs + (*RunSpec)(nil), // 26: flyteidl2.task.RunSpec +} +var file_flyteidl2_task_task_definition_proto_depIdxs = []int32{ + 14, // 0: flyteidl2.task.TaskTriggersSummary.details:type_name -> flyteidl2.task.TaskTriggersSummary.TriggerDetails + 15, // 1: flyteidl2.task.TaskTriggersSummary.stats:type_name -> flyteidl2.task.TaskTriggersSummary.TriggerStats + 16, // 2: flyteidl2.task.LatestRunSummary.run_id:type_name -> flyteidl2.common.RunIdentifier + 17, // 3: flyteidl2.task.LatestRunSummary.run_time:type_name -> google.protobuf.Timestamp + 18, // 4: flyteidl2.task.LatestRunSummary.phase:type_name -> flyteidl2.common.ActionPhase + 19, // 5: flyteidl2.task.TaskMetadata.deployed_by:type_name -> flyteidl2.common.EnrichedIdentity + 17, // 6: flyteidl2.task.TaskMetadata.deployed_at:type_name -> google.protobuf.Timestamp + 2, // 7: flyteidl2.task.TaskMetadata.triggers_summary:type_name -> flyteidl2.task.TaskTriggersSummary + 3, // 8: flyteidl2.task.TaskSummary.latest_run:type_name -> flyteidl2.task.LatestRunSummary + 1, // 9: flyteidl2.task.Task.task_id:type_name -> flyteidl2.task.TaskIdentifier + 4, // 10: flyteidl2.task.Task.metadata:type_name -> flyteidl2.task.TaskMetadata + 5, // 11: flyteidl2.task.Task.task_summary:type_name -> flyteidl2.task.TaskSummary + 7, // 12: flyteidl2.task.DocumentationEntity.source_code:type_name -> flyteidl2.task.SourceCode + 20, // 13: flyteidl2.task.TaskSpec.task_template:type_name -> flyteidl2.core.TaskTemplate + 21, // 14: flyteidl2.task.TaskSpec.default_inputs:type_name -> flyteidl2.task.NamedParameter + 22, // 15: flyteidl2.task.TaskSpec.environment:type_name -> flyteidl2.task.Environment + 8, // 16: flyteidl2.task.TaskSpec.documentation:type_name -> flyteidl2.task.DocumentationEntity + 23, // 17: flyteidl2.task.TraceSpec.interface:type_name -> flyteidl2.core.TypedInterface + 1, // 18: flyteidl2.task.TaskDetails.task_id:type_name -> flyteidl2.task.TaskIdentifier + 4, // 19: flyteidl2.task.TaskDetails.metadata:type_name -> flyteidl2.task.TaskMetadata + 9, // 20: flyteidl2.task.TaskDetails.spec:type_name -> flyteidl2.task.TaskSpec + 13, // 21: flyteidl2.task.TaskTrigger.spec:type_name -> flyteidl2.task.TaskTriggerSpec + 24, // 22: flyteidl2.task.TaskTrigger.automation_spec:type_name -> flyteidl2.task.TriggerAutomationSpec + 25, // 23: flyteidl2.task.TaskTriggerSpec.inputs:type_name -> flyteidl2.task.Inputs + 26, // 24: flyteidl2.task.TaskTriggerSpec.run_spec:type_name -> flyteidl2.task.RunSpec + 24, // 25: flyteidl2.task.TaskTriggersSummary.TriggerDetails.automation_spec:type_name -> flyteidl2.task.TriggerAutomationSpec + 26, // [26:26] is the sub-list for method output_type + 26, // [26:26] is the sub-list for method input_type + 26, // [26:26] is the sub-list for extension type_name + 26, // [26:26] is the sub-list for extension extendee + 0, // [0:26] is the sub-list for field type_name +} + +func init() { file_flyteidl2_task_task_definition_proto_init() } +func file_flyteidl2_task_task_definition_proto_init() { + if File_flyteidl2_task_task_definition_proto != nil { + return + } + file_flyteidl2_task_common_proto_init() + file_flyteidl2_task_environment_proto_init() + file_flyteidl2_task_run_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_task_task_definition_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskName); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_definition_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskIdentifier); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_definition_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskTriggersSummary); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_definition_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LatestRunSummary); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_definition_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_definition_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskSummary); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_definition_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Task); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_definition_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SourceCode); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_definition_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DocumentationEntity); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_definition_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_definition_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TraceSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_definition_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskDetails); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_definition_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskTrigger); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_definition_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskTriggerSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_definition_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskTriggersSummary_TriggerDetails); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_definition_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskTriggersSummary_TriggerStats); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_task_task_definition_proto_msgTypes[2].OneofWrappers = []interface{}{ + (*TaskTriggersSummary_Details)(nil), + (*TaskTriggersSummary_Stats)(nil), + } + file_flyteidl2_task_task_definition_proto_msgTypes[5].OneofWrappers = []interface{}{} + file_flyteidl2_task_task_definition_proto_msgTypes[6].OneofWrappers = []interface{}{} + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_task_task_definition_proto_rawDesc, + NumEnums: 0, + NumMessages: 16, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_task_task_definition_proto_goTypes, + DependencyIndexes: file_flyteidl2_task_task_definition_proto_depIdxs, + MessageInfos: file_flyteidl2_task_task_definition_proto_msgTypes, + }.Build() + File_flyteidl2_task_task_definition_proto = out.File + file_flyteidl2_task_task_definition_proto_rawDesc = nil + file_flyteidl2_task_task_definition_proto_goTypes = nil + file_flyteidl2_task_task_definition_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/task/task_definition.pb.validate.go b/gen/go/flyteidl2/task/task_definition.pb.validate.go new file mode 100644 index 0000000000..b85daf43c8 --- /dev/null +++ b/gen/go/flyteidl2/task/task_definition.pb.validate.go @@ -0,0 +1,2461 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/task/task_definition.proto + +package task + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" + + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort + + _ = common.ActionPhase(0) +) + +// Validate checks the field values on TaskName with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TaskName) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskName with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TaskNameMultiError, or nil +// if none found. +func (m *TaskName) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskName) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Org + + // no validation rules for Project + + // no validation rules for Domain + + // no validation rules for Name + + if len(errors) > 0 { + return TaskNameMultiError(errors) + } + + return nil +} + +// TaskNameMultiError is an error wrapping multiple validation errors returned +// by TaskName.ValidateAll() if the designated constraints aren't met. +type TaskNameMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskNameMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskNameMultiError) AllErrors() []error { return m } + +// TaskNameValidationError is the validation error returned by +// TaskName.Validate if the designated constraints aren't met. +type TaskNameValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskNameValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskNameValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskNameValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskNameValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskNameValidationError) ErrorName() string { return "TaskNameValidationError" } + +// Error satisfies the builtin error interface +func (e TaskNameValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskName.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskNameValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskNameValidationError{} + +// Validate checks the field values on TaskIdentifier with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TaskIdentifier) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskIdentifier with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TaskIdentifierMultiError, +// or nil if none found. +func (m *TaskIdentifier) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskIdentifier) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Org + + // no validation rules for Project + + // no validation rules for Domain + + // no validation rules for Name + + // no validation rules for Version + + if len(errors) > 0 { + return TaskIdentifierMultiError(errors) + } + + return nil +} + +// TaskIdentifierMultiError is an error wrapping multiple validation errors +// returned by TaskIdentifier.ValidateAll() if the designated constraints +// aren't met. +type TaskIdentifierMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskIdentifierMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskIdentifierMultiError) AllErrors() []error { return m } + +// TaskIdentifierValidationError is the validation error returned by +// TaskIdentifier.Validate if the designated constraints aren't met. +type TaskIdentifierValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskIdentifierValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskIdentifierValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskIdentifierValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskIdentifierValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskIdentifierValidationError) ErrorName() string { return "TaskIdentifierValidationError" } + +// Error satisfies the builtin error interface +func (e TaskIdentifierValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskIdentifier.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskIdentifierValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskIdentifierValidationError{} + +// Validate checks the field values on TaskTriggersSummary with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *TaskTriggersSummary) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskTriggersSummary with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TaskTriggersSummaryMultiError, or nil if none found. +func (m *TaskTriggersSummary) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskTriggersSummary) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Summary.(type) { + case *TaskTriggersSummary_Details: + if v == nil { + err := TaskTriggersSummaryValidationError{ + field: "Summary", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetDetails()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskTriggersSummaryValidationError{ + field: "Details", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskTriggersSummaryValidationError{ + field: "Details", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDetails()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskTriggersSummaryValidationError{ + field: "Details", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *TaskTriggersSummary_Stats: + if v == nil { + err := TaskTriggersSummaryValidationError{ + field: "Summary", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetStats()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskTriggersSummaryValidationError{ + field: "Stats", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskTriggersSummaryValidationError{ + field: "Stats", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStats()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskTriggersSummaryValidationError{ + field: "Stats", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return TaskTriggersSummaryMultiError(errors) + } + + return nil +} + +// TaskTriggersSummaryMultiError is an error wrapping multiple validation +// errors returned by TaskTriggersSummary.ValidateAll() if the designated +// constraints aren't met. +type TaskTriggersSummaryMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskTriggersSummaryMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskTriggersSummaryMultiError) AllErrors() []error { return m } + +// TaskTriggersSummaryValidationError is the validation error returned by +// TaskTriggersSummary.Validate if the designated constraints aren't met. +type TaskTriggersSummaryValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskTriggersSummaryValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskTriggersSummaryValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskTriggersSummaryValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskTriggersSummaryValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskTriggersSummaryValidationError) ErrorName() string { + return "TaskTriggersSummaryValidationError" +} + +// Error satisfies the builtin error interface +func (e TaskTriggersSummaryValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskTriggersSummary.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskTriggersSummaryValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskTriggersSummaryValidationError{} + +// Validate checks the field values on LatestRunSummary with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *LatestRunSummary) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LatestRunSummary with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// LatestRunSummaryMultiError, or nil if none found. +func (m *LatestRunSummary) ValidateAll() error { + return m.validate(true) +} + +func (m *LatestRunSummary) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRunId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LatestRunSummaryValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LatestRunSummaryValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LatestRunSummaryValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetRunTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LatestRunSummaryValidationError{ + field: "RunTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LatestRunSummaryValidationError{ + field: "RunTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LatestRunSummaryValidationError{ + field: "RunTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Phase + + // no validation rules for RootTaskName + + if len(errors) > 0 { + return LatestRunSummaryMultiError(errors) + } + + return nil +} + +// LatestRunSummaryMultiError is an error wrapping multiple validation errors +// returned by LatestRunSummary.ValidateAll() if the designated constraints +// aren't met. +type LatestRunSummaryMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LatestRunSummaryMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LatestRunSummaryMultiError) AllErrors() []error { return m } + +// LatestRunSummaryValidationError is the validation error returned by +// LatestRunSummary.Validate if the designated constraints aren't met. +type LatestRunSummaryValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LatestRunSummaryValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LatestRunSummaryValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LatestRunSummaryValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LatestRunSummaryValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LatestRunSummaryValidationError) ErrorName() string { return "LatestRunSummaryValidationError" } + +// Error satisfies the builtin error interface +func (e LatestRunSummaryValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLatestRunSummary.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LatestRunSummaryValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LatestRunSummaryValidationError{} + +// Validate checks the field values on TaskMetadata with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TaskMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskMetadata with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TaskMetadataMultiError, or +// nil if none found. +func (m *TaskMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetDeployedBy()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskMetadataValidationError{ + field: "DeployedBy", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskMetadataValidationError{ + field: "DeployedBy", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDeployedBy()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskMetadataValidationError{ + field: "DeployedBy", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for ShortName + + if all { + switch v := interface{}(m.GetDeployedAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskMetadataValidationError{ + field: "DeployedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskMetadataValidationError{ + field: "DeployedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDeployedAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskMetadataValidationError{ + field: "DeployedAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for EnvironmentName + + if all { + switch v := interface{}(m.GetTriggersSummary()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskMetadataValidationError{ + field: "TriggersSummary", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskMetadataValidationError{ + field: "TriggersSummary", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTriggersSummary()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskMetadataValidationError{ + field: "TriggersSummary", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for ShortDescription + + if len(errors) > 0 { + return TaskMetadataMultiError(errors) + } + + return nil +} + +// TaskMetadataMultiError is an error wrapping multiple validation errors +// returned by TaskMetadata.ValidateAll() if the designated constraints aren't met. +type TaskMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskMetadataMultiError) AllErrors() []error { return m } + +// TaskMetadataValidationError is the validation error returned by +// TaskMetadata.Validate if the designated constraints aren't met. +type TaskMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskMetadataValidationError) ErrorName() string { return "TaskMetadataValidationError" } + +// Error satisfies the builtin error interface +func (e TaskMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskMetadataValidationError{} + +// Validate checks the field values on TaskSummary with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TaskSummary) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskSummary with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TaskSummaryMultiError, or +// nil if none found. +func (m *TaskSummary) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskSummary) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if m.LatestRun != nil { + + if all { + switch v := interface{}(m.GetLatestRun()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskSummaryValidationError{ + field: "LatestRun", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskSummaryValidationError{ + field: "LatestRun", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLatestRun()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskSummaryValidationError{ + field: "LatestRun", + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return TaskSummaryMultiError(errors) + } + + return nil +} + +// TaskSummaryMultiError is an error wrapping multiple validation errors +// returned by TaskSummary.ValidateAll() if the designated constraints aren't met. +type TaskSummaryMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskSummaryMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskSummaryMultiError) AllErrors() []error { return m } + +// TaskSummaryValidationError is the validation error returned by +// TaskSummary.Validate if the designated constraints aren't met. +type TaskSummaryValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskSummaryValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskSummaryValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskSummaryValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskSummaryValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskSummaryValidationError) ErrorName() string { return "TaskSummaryValidationError" } + +// Error satisfies the builtin error interface +func (e TaskSummaryValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskSummary.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskSummaryValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskSummaryValidationError{} + +// Validate checks the field values on Task with the rules defined in the proto +// definition for this message. If any rules are violated, the first error +// encountered is returned, or nil if there are no violations. +func (m *Task) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Task with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in TaskMultiError, or nil if none found. +func (m *Task) ValidateAll() error { + return m.validate(true) +} + +func (m *Task) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetTaskId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if m.TaskSummary != nil { + + if all { + switch v := interface{}(m.GetTaskSummary()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskValidationError{ + field: "TaskSummary", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskValidationError{ + field: "TaskSummary", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskSummary()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskValidationError{ + field: "TaskSummary", + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return TaskMultiError(errors) + } + + return nil +} + +// TaskMultiError is an error wrapping multiple validation errors returned by +// Task.ValidateAll() if the designated constraints aren't met. +type TaskMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskMultiError) AllErrors() []error { return m } + +// TaskValidationError is the validation error returned by Task.Validate if the +// designated constraints aren't met. +type TaskValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskValidationError) ErrorName() string { return "TaskValidationError" } + +// Error satisfies the builtin error interface +func (e TaskValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTask.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskValidationError{} + +// Validate checks the field values on SourceCode with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *SourceCode) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on SourceCode with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in SourceCodeMultiError, or +// nil if none found. +func (m *SourceCode) ValidateAll() error { + return m.validate(true) +} + +func (m *SourceCode) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Link + + if len(errors) > 0 { + return SourceCodeMultiError(errors) + } + + return nil +} + +// SourceCodeMultiError is an error wrapping multiple validation errors +// returned by SourceCode.ValidateAll() if the designated constraints aren't met. +type SourceCodeMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m SourceCodeMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m SourceCodeMultiError) AllErrors() []error { return m } + +// SourceCodeValidationError is the validation error returned by +// SourceCode.Validate if the designated constraints aren't met. +type SourceCodeValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e SourceCodeValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e SourceCodeValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e SourceCodeValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e SourceCodeValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e SourceCodeValidationError) ErrorName() string { return "SourceCodeValidationError" } + +// Error satisfies the builtin error interface +func (e SourceCodeValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sSourceCode.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = SourceCodeValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = SourceCodeValidationError{} + +// Validate checks the field values on DocumentationEntity with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *DocumentationEntity) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DocumentationEntity with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// DocumentationEntityMultiError, or nil if none found. +func (m *DocumentationEntity) ValidateAll() error { + return m.validate(true) +} + +func (m *DocumentationEntity) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for ShortDescription + + // no validation rules for LongDescription + + if all { + switch v := interface{}(m.GetSourceCode()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DocumentationEntityValidationError{ + field: "SourceCode", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DocumentationEntityValidationError{ + field: "SourceCode", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSourceCode()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DocumentationEntityValidationError{ + field: "SourceCode", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DocumentationEntityMultiError(errors) + } + + return nil +} + +// DocumentationEntityMultiError is an error wrapping multiple validation +// errors returned by DocumentationEntity.ValidateAll() if the designated +// constraints aren't met. +type DocumentationEntityMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DocumentationEntityMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DocumentationEntityMultiError) AllErrors() []error { return m } + +// DocumentationEntityValidationError is the validation error returned by +// DocumentationEntity.Validate if the designated constraints aren't met. +type DocumentationEntityValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DocumentationEntityValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DocumentationEntityValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DocumentationEntityValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DocumentationEntityValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DocumentationEntityValidationError) ErrorName() string { + return "DocumentationEntityValidationError" +} + +// Error satisfies the builtin error interface +func (e DocumentationEntityValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDocumentationEntity.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DocumentationEntityValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DocumentationEntityValidationError{} + +// Validate checks the field values on TaskSpec with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TaskSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskSpec with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TaskSpecMultiError, or nil +// if none found. +func (m *TaskSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetTaskTemplate()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskSpecValidationError{ + field: "TaskTemplate", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskSpecValidationError{ + field: "TaskTemplate", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskTemplate()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskSpecValidationError{ + field: "TaskTemplate", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetDefaultInputs() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskSpecValidationError{ + field: fmt.Sprintf("DefaultInputs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskSpecValidationError{ + field: fmt.Sprintf("DefaultInputs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskSpecValidationError{ + field: fmt.Sprintf("DefaultInputs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for ShortName + + if all { + switch v := interface{}(m.GetEnvironment()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskSpecValidationError{ + field: "Environment", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskSpecValidationError{ + field: "Environment", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetEnvironment()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskSpecValidationError{ + field: "Environment", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetDocumentation()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskSpecValidationError{ + field: "Documentation", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskSpecValidationError{ + field: "Documentation", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDocumentation()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskSpecValidationError{ + field: "Documentation", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return TaskSpecMultiError(errors) + } + + return nil +} + +// TaskSpecMultiError is an error wrapping multiple validation errors returned +// by TaskSpec.ValidateAll() if the designated constraints aren't met. +type TaskSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskSpecMultiError) AllErrors() []error { return m } + +// TaskSpecValidationError is the validation error returned by +// TaskSpec.Validate if the designated constraints aren't met. +type TaskSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskSpecValidationError) ErrorName() string { return "TaskSpecValidationError" } + +// Error satisfies the builtin error interface +func (e TaskSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskSpecValidationError{} + +// Validate checks the field values on TraceSpec with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TraceSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TraceSpec with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TraceSpecMultiError, or nil +// if none found. +func (m *TraceSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *TraceSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetInterface()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TraceSpecValidationError{ + field: "Interface", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TraceSpecValidationError{ + field: "Interface", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetInterface()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TraceSpecValidationError{ + field: "Interface", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return TraceSpecMultiError(errors) + } + + return nil +} + +// TraceSpecMultiError is an error wrapping multiple validation errors returned +// by TraceSpec.ValidateAll() if the designated constraints aren't met. +type TraceSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TraceSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TraceSpecMultiError) AllErrors() []error { return m } + +// TraceSpecValidationError is the validation error returned by +// TraceSpec.Validate if the designated constraints aren't met. +type TraceSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TraceSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TraceSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TraceSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TraceSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TraceSpecValidationError) ErrorName() string { return "TraceSpecValidationError" } + +// Error satisfies the builtin error interface +func (e TraceSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTraceSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TraceSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TraceSpecValidationError{} + +// Validate checks the field values on TaskDetails with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TaskDetails) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskDetails with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TaskDetailsMultiError, or +// nil if none found. +func (m *TaskDetails) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskDetails) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetTaskId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskDetailsValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskDetailsValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskDetailsValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskDetailsValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskDetailsValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskDetailsValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskDetailsValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskDetailsValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskDetailsValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return TaskDetailsMultiError(errors) + } + + return nil +} + +// TaskDetailsMultiError is an error wrapping multiple validation errors +// returned by TaskDetails.ValidateAll() if the designated constraints aren't met. +type TaskDetailsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskDetailsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskDetailsMultiError) AllErrors() []error { return m } + +// TaskDetailsValidationError is the validation error returned by +// TaskDetails.Validate if the designated constraints aren't met. +type TaskDetailsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskDetailsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskDetailsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskDetailsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskDetailsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskDetailsValidationError) ErrorName() string { return "TaskDetailsValidationError" } + +// Error satisfies the builtin error interface +func (e TaskDetailsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskDetails.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskDetailsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskDetailsValidationError{} + +// Validate checks the field values on TaskTrigger with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TaskTrigger) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskTrigger with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TaskTriggerMultiError, or +// nil if none found. +func (m *TaskTrigger) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskTrigger) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + if all { + switch v := interface{}(m.GetSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskTriggerValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskTriggerValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskTriggerValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetAutomationSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskTriggerValidationError{ + field: "AutomationSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskTriggerValidationError{ + field: "AutomationSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAutomationSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskTriggerValidationError{ + field: "AutomationSpec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return TaskTriggerMultiError(errors) + } + + return nil +} + +// TaskTriggerMultiError is an error wrapping multiple validation errors +// returned by TaskTrigger.ValidateAll() if the designated constraints aren't met. +type TaskTriggerMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskTriggerMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskTriggerMultiError) AllErrors() []error { return m } + +// TaskTriggerValidationError is the validation error returned by +// TaskTrigger.Validate if the designated constraints aren't met. +type TaskTriggerValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskTriggerValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskTriggerValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskTriggerValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskTriggerValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskTriggerValidationError) ErrorName() string { return "TaskTriggerValidationError" } + +// Error satisfies the builtin error interface +func (e TaskTriggerValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskTrigger.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskTriggerValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskTriggerValidationError{} + +// Validate checks the field values on TaskTriggerSpec with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *TaskTriggerSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskTriggerSpec with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TaskTriggerSpecMultiError, or nil if none found. +func (m *TaskTriggerSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskTriggerSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Active + + if all { + switch v := interface{}(m.GetInputs()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskTriggerSpecValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskTriggerSpecValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetInputs()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskTriggerSpecValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetRunSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskTriggerSpecValidationError{ + field: "RunSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskTriggerSpecValidationError{ + field: "RunSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskTriggerSpecValidationError{ + field: "RunSpec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Description + + if len(errors) > 0 { + return TaskTriggerSpecMultiError(errors) + } + + return nil +} + +// TaskTriggerSpecMultiError is an error wrapping multiple validation errors +// returned by TaskTriggerSpec.ValidateAll() if the designated constraints +// aren't met. +type TaskTriggerSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskTriggerSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskTriggerSpecMultiError) AllErrors() []error { return m } + +// TaskTriggerSpecValidationError is the validation error returned by +// TaskTriggerSpec.Validate if the designated constraints aren't met. +type TaskTriggerSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskTriggerSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskTriggerSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskTriggerSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskTriggerSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskTriggerSpecValidationError) ErrorName() string { return "TaskTriggerSpecValidationError" } + +// Error satisfies the builtin error interface +func (e TaskTriggerSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskTriggerSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskTriggerSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskTriggerSpecValidationError{} + +// Validate checks the field values on TaskTriggersSummary_TriggerDetails with +// the rules defined in the proto definition for this message. If any rules +// are violated, the first error encountered is returned, or nil if there are +// no violations. +func (m *TaskTriggersSummary_TriggerDetails) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskTriggersSummary_TriggerDetails +// with the rules defined in the proto definition for this message. If any +// rules are violated, the result is a list of violation errors wrapped in +// TaskTriggersSummary_TriggerDetailsMultiError, or nil if none found. +func (m *TaskTriggersSummary_TriggerDetails) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskTriggersSummary_TriggerDetails) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + // no validation rules for Active + + if all { + switch v := interface{}(m.GetAutomationSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskTriggersSummary_TriggerDetailsValidationError{ + field: "AutomationSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskTriggersSummary_TriggerDetailsValidationError{ + field: "AutomationSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAutomationSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskTriggersSummary_TriggerDetailsValidationError{ + field: "AutomationSpec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return TaskTriggersSummary_TriggerDetailsMultiError(errors) + } + + return nil +} + +// TaskTriggersSummary_TriggerDetailsMultiError is an error wrapping multiple +// validation errors returned by +// TaskTriggersSummary_TriggerDetails.ValidateAll() if the designated +// constraints aren't met. +type TaskTriggersSummary_TriggerDetailsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskTriggersSummary_TriggerDetailsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskTriggersSummary_TriggerDetailsMultiError) AllErrors() []error { return m } + +// TaskTriggersSummary_TriggerDetailsValidationError is the validation error +// returned by TaskTriggersSummary_TriggerDetails.Validate if the designated +// constraints aren't met. +type TaskTriggersSummary_TriggerDetailsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskTriggersSummary_TriggerDetailsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskTriggersSummary_TriggerDetailsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskTriggersSummary_TriggerDetailsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskTriggersSummary_TriggerDetailsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskTriggersSummary_TriggerDetailsValidationError) ErrorName() string { + return "TaskTriggersSummary_TriggerDetailsValidationError" +} + +// Error satisfies the builtin error interface +func (e TaskTriggersSummary_TriggerDetailsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskTriggersSummary_TriggerDetails.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskTriggersSummary_TriggerDetailsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskTriggersSummary_TriggerDetailsValidationError{} + +// Validate checks the field values on TaskTriggersSummary_TriggerStats with +// the rules defined in the proto definition for this message. If any rules +// are violated, the first error encountered is returned, or nil if there are +// no violations. +func (m *TaskTriggersSummary_TriggerStats) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskTriggersSummary_TriggerStats with +// the rules defined in the proto definition for this message. If any rules +// are violated, the result is a list of violation errors wrapped in +// TaskTriggersSummary_TriggerStatsMultiError, or nil if none found. +func (m *TaskTriggersSummary_TriggerStats) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskTriggersSummary_TriggerStats) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Total + + // no validation rules for Active + + if len(errors) > 0 { + return TaskTriggersSummary_TriggerStatsMultiError(errors) + } + + return nil +} + +// TaskTriggersSummary_TriggerStatsMultiError is an error wrapping multiple +// validation errors returned by +// TaskTriggersSummary_TriggerStats.ValidateAll() if the designated +// constraints aren't met. +type TaskTriggersSummary_TriggerStatsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskTriggersSummary_TriggerStatsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskTriggersSummary_TriggerStatsMultiError) AllErrors() []error { return m } + +// TaskTriggersSummary_TriggerStatsValidationError is the validation error +// returned by TaskTriggersSummary_TriggerStats.Validate if the designated +// constraints aren't met. +type TaskTriggersSummary_TriggerStatsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskTriggersSummary_TriggerStatsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskTriggersSummary_TriggerStatsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskTriggersSummary_TriggerStatsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskTriggersSummary_TriggerStatsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskTriggersSummary_TriggerStatsValidationError) ErrorName() string { + return "TaskTriggersSummary_TriggerStatsValidationError" +} + +// Error satisfies the builtin error interface +func (e TaskTriggersSummary_TriggerStatsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskTriggersSummary_TriggerStats.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskTriggersSummary_TriggerStatsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskTriggersSummary_TriggerStatsValidationError{} diff --git a/gen/go/flyteidl2/task/task_service.pb.go b/gen/go/flyteidl2/task/task_service.pb.go new file mode 100644 index 0000000000..589c8bc81a --- /dev/null +++ b/gen/go/flyteidl2/task/task_service.pb.go @@ -0,0 +1,1064 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/task/task_service.proto + +package task + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Request message for deploying a task. +type DeployTaskRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The user provided task id. + TaskId *TaskIdentifier `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"` + // Specification for the task. + Spec *TaskSpec `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"` + // Optional, set of triggers for a given task. Replaces previous set of triggers entirely if any. + Triggers []*TaskTrigger `protobuf:"bytes,3,rep,name=triggers,proto3" json:"triggers,omitempty"` +} + +func (x *DeployTaskRequest) Reset() { + *x = DeployTaskRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeployTaskRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeployTaskRequest) ProtoMessage() {} + +func (x *DeployTaskRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeployTaskRequest.ProtoReflect.Descriptor instead. +func (*DeployTaskRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_service_proto_rawDescGZIP(), []int{0} +} + +func (x *DeployTaskRequest) GetTaskId() *TaskIdentifier { + if x != nil { + return x.TaskId + } + return nil +} + +func (x *DeployTaskRequest) GetSpec() *TaskSpec { + if x != nil { + return x.Spec + } + return nil +} + +func (x *DeployTaskRequest) GetTriggers() []*TaskTrigger { + if x != nil { + return x.Triggers + } + return nil +} + +// Response message for deploying a task. +type DeployTaskResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *DeployTaskResponse) Reset() { + *x = DeployTaskResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeployTaskResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeployTaskResponse) ProtoMessage() {} + +func (x *DeployTaskResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeployTaskResponse.ProtoReflect.Descriptor instead. +func (*DeployTaskResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_service_proto_rawDescGZIP(), []int{1} +} + +// Request message for getting detailed information about a task. +type GetTaskDetailsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Id of the task. + TaskId *TaskIdentifier `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"` +} + +func (x *GetTaskDetailsRequest) Reset() { + *x = GetTaskDetailsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTaskDetailsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTaskDetailsRequest) ProtoMessage() {} + +func (x *GetTaskDetailsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetTaskDetailsRequest.ProtoReflect.Descriptor instead. +func (*GetTaskDetailsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_service_proto_rawDescGZIP(), []int{2} +} + +func (x *GetTaskDetailsRequest) GetTaskId() *TaskIdentifier { + if x != nil { + return x.TaskId + } + return nil +} + +// Response message for deploying a task. +type GetTaskDetailsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Detailed information about the task. + Details *TaskDetails `protobuf:"bytes,1,opt,name=details,proto3" json:"details,omitempty"` +} + +func (x *GetTaskDetailsResponse) Reset() { + *x = GetTaskDetailsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTaskDetailsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTaskDetailsResponse) ProtoMessage() {} + +func (x *GetTaskDetailsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetTaskDetailsResponse.ProtoReflect.Descriptor instead. +func (*GetTaskDetailsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_service_proto_rawDescGZIP(), []int{3} +} + +func (x *GetTaskDetailsResponse) GetDetails() *TaskDetails { + if x != nil { + return x.Details + } + return nil +} + +type ListTasksRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Common list request parameters. + Request *common.ListRequest `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"` + // Types that are assignable to ScopeBy: + // + // *ListTasksRequest_Org + // *ListTasksRequest_ProjectId + ScopeBy isListTasksRequest_ScopeBy `protobuf_oneof:"scope_by"` + // Known filters for listing tasks. + KnownFilters []*ListTasksRequest_KnownFilter `protobuf:"bytes,4,rep,name=known_filters,json=knownFilters,proto3" json:"known_filters,omitempty"` +} + +func (x *ListTasksRequest) Reset() { + *x = ListTasksRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListTasksRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListTasksRequest) ProtoMessage() {} + +func (x *ListTasksRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListTasksRequest.ProtoReflect.Descriptor instead. +func (*ListTasksRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_service_proto_rawDescGZIP(), []int{4} +} + +func (x *ListTasksRequest) GetRequest() *common.ListRequest { + if x != nil { + return x.Request + } + return nil +} + +func (m *ListTasksRequest) GetScopeBy() isListTasksRequest_ScopeBy { + if m != nil { + return m.ScopeBy + } + return nil +} + +func (x *ListTasksRequest) GetOrg() string { + if x, ok := x.GetScopeBy().(*ListTasksRequest_Org); ok { + return x.Org + } + return "" +} + +func (x *ListTasksRequest) GetProjectId() *common.ProjectIdentifier { + if x, ok := x.GetScopeBy().(*ListTasksRequest_ProjectId); ok { + return x.ProjectId + } + return nil +} + +func (x *ListTasksRequest) GetKnownFilters() []*ListTasksRequest_KnownFilter { + if x != nil { + return x.KnownFilters + } + return nil +} + +type isListTasksRequest_ScopeBy interface { + isListTasksRequest_ScopeBy() +} + +type ListTasksRequest_Org struct { + // Organization name for filtering. + Org string `protobuf:"bytes,2,opt,name=org,proto3,oneof"` +} + +type ListTasksRequest_ProjectId struct { + // Project identifier for filtering. + ProjectId *common.ProjectIdentifier `protobuf:"bytes,3,opt,name=project_id,json=projectId,proto3,oneof"` +} + +func (*ListTasksRequest_Org) isListTasksRequest_ScopeBy() {} + +func (*ListTasksRequest_ProjectId) isListTasksRequest_ScopeBy() {} + +type ListTasksResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Tasks []*Task `protobuf:"bytes,1,rep,name=tasks,proto3" json:"tasks,omitempty"` + // Pagination token for the next page of tasks. + Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"` + // Metadata for the ListTasksResponse + Metadata *ListTasksResponse_ListTasksMetadata `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"` +} + +func (x *ListTasksResponse) Reset() { + *x = ListTasksResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListTasksResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListTasksResponse) ProtoMessage() {} + +func (x *ListTasksResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListTasksResponse.ProtoReflect.Descriptor instead. +func (*ListTasksResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_service_proto_rawDescGZIP(), []int{5} +} + +func (x *ListTasksResponse) GetTasks() []*Task { + if x != nil { + return x.Tasks + } + return nil +} + +func (x *ListTasksResponse) GetToken() string { + if x != nil { + return x.Token + } + return "" +} + +func (x *ListTasksResponse) GetMetadata() *ListTasksResponse_ListTasksMetadata { + if x != nil { + return x.Metadata + } + return nil +} + +// Request message for listing versions for a task. +type ListVersionsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Common list request parameters. + Request *common.ListRequest `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"` + // Id of the task. + TaskName *TaskName `protobuf:"bytes,2,opt,name=task_name,json=taskName,proto3" json:"task_name,omitempty"` +} + +func (x *ListVersionsRequest) Reset() { + *x = ListVersionsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListVersionsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListVersionsRequest) ProtoMessage() {} + +func (x *ListVersionsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListVersionsRequest.ProtoReflect.Descriptor instead. +func (*ListVersionsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_service_proto_rawDescGZIP(), []int{6} +} + +func (x *ListVersionsRequest) GetRequest() *common.ListRequest { + if x != nil { + return x.Request + } + return nil +} + +func (x *ListVersionsRequest) GetTaskName() *TaskName { + if x != nil { + return x.TaskName + } + return nil +} + +// Response message for listing versions. +type ListVersionsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Version with deployed_at + Versions []*ListVersionsResponse_VersionResponse `protobuf:"bytes,1,rep,name=versions,proto3" json:"versions,omitempty"` + // Pagination token for the next page of versions. + Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"` +} + +func (x *ListVersionsResponse) Reset() { + *x = ListVersionsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListVersionsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListVersionsResponse) ProtoMessage() {} + +func (x *ListVersionsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListVersionsResponse.ProtoReflect.Descriptor instead. +func (*ListVersionsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_service_proto_rawDescGZIP(), []int{7} +} + +func (x *ListVersionsResponse) GetVersions() []*ListVersionsResponse_VersionResponse { + if x != nil { + return x.Versions + } + return nil +} + +func (x *ListVersionsResponse) GetToken() string { + if x != nil { + return x.Token + } + return "" +} + +type ListTasksRequest_KnownFilter struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to FilterBy: + // + // *ListTasksRequest_KnownFilter_DeployedBy + FilterBy isListTasksRequest_KnownFilter_FilterBy `protobuf_oneof:"filter_by"` +} + +func (x *ListTasksRequest_KnownFilter) Reset() { + *x = ListTasksRequest_KnownFilter{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListTasksRequest_KnownFilter) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListTasksRequest_KnownFilter) ProtoMessage() {} + +func (x *ListTasksRequest_KnownFilter) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListTasksRequest_KnownFilter.ProtoReflect.Descriptor instead. +func (*ListTasksRequest_KnownFilter) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_service_proto_rawDescGZIP(), []int{4, 0} +} + +func (m *ListTasksRequest_KnownFilter) GetFilterBy() isListTasksRequest_KnownFilter_FilterBy { + if m != nil { + return m.FilterBy + } + return nil +} + +func (x *ListTasksRequest_KnownFilter) GetDeployedBy() string { + if x, ok := x.GetFilterBy().(*ListTasksRequest_KnownFilter_DeployedBy); ok { + return x.DeployedBy + } + return "" +} + +type isListTasksRequest_KnownFilter_FilterBy interface { + isListTasksRequest_KnownFilter_FilterBy() +} + +type ListTasksRequest_KnownFilter_DeployedBy struct { + // Filter by user + DeployedBy string `protobuf:"bytes,1,opt,name=deployed_by,json=deployedBy,proto3,oneof"` +} + +func (*ListTasksRequest_KnownFilter_DeployedBy) isListTasksRequest_KnownFilter_FilterBy() {} + +type ListTasksResponse_ListTasksMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Total number of tasks without filters applied + Total uint32 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"` + // Total number of tasks matching the applied filters. + FilteredTotal uint32 `protobuf:"varint,2,opt,name=filtered_total,json=filteredTotal,proto3" json:"filtered_total,omitempty"` +} + +func (x *ListTasksResponse_ListTasksMetadata) Reset() { + *x = ListTasksResponse_ListTasksMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListTasksResponse_ListTasksMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListTasksResponse_ListTasksMetadata) ProtoMessage() {} + +func (x *ListTasksResponse_ListTasksMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListTasksResponse_ListTasksMetadata.ProtoReflect.Descriptor instead. +func (*ListTasksResponse_ListTasksMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_service_proto_rawDescGZIP(), []int{5, 0} +} + +func (x *ListTasksResponse_ListTasksMetadata) GetTotal() uint32 { + if x != nil { + return x.Total + } + return 0 +} + +func (x *ListTasksResponse_ListTasksMetadata) GetFilteredTotal() uint32 { + if x != nil { + return x.FilteredTotal + } + return 0 +} + +type ListVersionsResponse_VersionResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"` + // The time the task version was deployed + DeployedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=deployed_at,json=deployedAt,proto3" json:"deployed_at,omitempty"` +} + +func (x *ListVersionsResponse_VersionResponse) Reset() { + *x = ListVersionsResponse_VersionResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListVersionsResponse_VersionResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListVersionsResponse_VersionResponse) ProtoMessage() {} + +func (x *ListVersionsResponse_VersionResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_task_task_service_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListVersionsResponse_VersionResponse.ProtoReflect.Descriptor instead. +func (*ListVersionsResponse_VersionResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_task_task_service_proto_rawDescGZIP(), []int{7, 0} +} + +func (x *ListVersionsResponse_VersionResponse) GetVersion() string { + if x != nil { + return x.Version + } + return "" +} + +func (x *ListVersionsResponse_VersionResponse) GetDeployedAt() *timestamppb.Timestamp { + if x != nil { + return x.DeployedAt + } + return nil +} + +var File_flyteidl2_task_task_service_proto protoreflect.FileDescriptor + +var file_flyteidl2_task_task_service_proto_rawDesc = []byte{ + 0x0a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, + 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, + 0x61, 0x73, 0x6b, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, + 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, + 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc3, 0x01, 0x0a, 0x11, 0x44, 0x65, 0x70, 0x6c, + 0x6f, 0x79, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3f, 0x0a, + 0x07, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x54, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, + 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x12, 0x34, + 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, + 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x04, + 0x73, 0x70, 0x65, 0x63, 0x12, 0x37, 0x0a, 0x08, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, + 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x52, 0x08, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x22, 0x14, 0x0a, + 0x12, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x58, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x44, 0x65, + 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3f, 0x0a, 0x07, + 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, + 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, + 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x22, 0x4f, 0x0a, + 0x16, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x44, 0x65, + 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0xd3, + 0x02, 0x0a, 0x10, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x37, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x03, + 0x6f, 0x72, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, + 0x10, 0x01, 0x48, 0x00, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x44, 0x0a, 0x0a, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x48, 0x00, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x12, + 0x51, 0x0a, 0x0d, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, + 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x73, 0x6b, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x46, 0x69, + 0x6c, 0x74, 0x65, 0x72, 0x52, 0x0c, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x46, 0x69, 0x6c, 0x74, 0x65, + 0x72, 0x73, 0x1a, 0x3d, 0x0a, 0x0b, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x46, 0x69, 0x6c, 0x74, 0x65, + 0x72, 0x12, 0x21, 0x0a, 0x0b, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x5f, 0x62, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, + 0x65, 0x64, 0x42, 0x79, 0x42, 0x0b, 0x0a, 0x09, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x62, + 0x79, 0x42, 0x11, 0x0a, 0x08, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x5f, 0x62, 0x79, 0x12, 0x05, 0xba, + 0x48, 0x02, 0x08, 0x01, 0x22, 0xf8, 0x01, 0x0a, 0x11, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x73, + 0x6b, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x05, 0x74, 0x61, + 0x73, 0x6b, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x52, + 0x05, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x4f, 0x0a, 0x08, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x33, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x50, 0x0a, + 0x11, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x05, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x12, 0x25, 0x0a, 0x0e, 0x66, 0x69, 0x6c, 0x74, + 0x65, 0x72, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, + 0x52, 0x0d, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x65, 0x64, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x22, + 0x8d, 0x01, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x37, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4c, 0x69, 0x73, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x3d, 0x0a, 0x09, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x42, 0x06, 0xba, + 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x74, 0x61, 0x73, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x22, + 0xf0, 0x01, 0x0a, 0x14, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x50, 0x0a, 0x08, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4c, 0x69, 0x73, 0x74, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x52, 0x08, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, + 0x1a, 0x70, 0x0a, 0x0f, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x43, 0x0a, + 0x0b, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x06, + 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, + 0x41, 0x74, 0x32, 0x81, 0x03, 0x0a, 0x0b, 0x54, 0x61, 0x73, 0x6b, 0x53, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x12, 0x55, 0x0a, 0x0a, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x54, 0x61, 0x73, 0x6b, + 0x12, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, + 0x6b, 0x2e, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x54, 0x61, 0x73, 0x6b, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x64, 0x0a, 0x0e, 0x47, 0x65, 0x74, + 0x54, 0x61, 0x73, 0x6b, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x25, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x47, 0x65, 0x74, + 0x54, 0x61, 0x73, 0x6b, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, + 0x61, 0x73, 0x6b, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x44, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, + 0x55, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x12, 0x20, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4c, 0x69, + 0x73, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x5e, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4c, 0x69, 0x73, + 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x42, 0xb5, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x42, 0x10, 0x54, + 0x61, 0x73, 0x6b, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, + 0x02, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, + 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0xa2, 0x02, 0x03, 0x46, 0x54, 0x58, 0xaa, 0x02, 0x0e, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0xca, 0x02, + 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x61, 0x73, 0x6b, 0xe2, + 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x61, 0x73, 0x6b, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x54, 0x61, 0x73, 0x6b, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_task_task_service_proto_rawDescOnce sync.Once + file_flyteidl2_task_task_service_proto_rawDescData = file_flyteidl2_task_task_service_proto_rawDesc +) + +func file_flyteidl2_task_task_service_proto_rawDescGZIP() []byte { + file_flyteidl2_task_task_service_proto_rawDescOnce.Do(func() { + file_flyteidl2_task_task_service_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_task_task_service_proto_rawDescData) + }) + return file_flyteidl2_task_task_service_proto_rawDescData +} + +var file_flyteidl2_task_task_service_proto_msgTypes = make([]protoimpl.MessageInfo, 11) +var file_flyteidl2_task_task_service_proto_goTypes = []interface{}{ + (*DeployTaskRequest)(nil), // 0: flyteidl2.task.DeployTaskRequest + (*DeployTaskResponse)(nil), // 1: flyteidl2.task.DeployTaskResponse + (*GetTaskDetailsRequest)(nil), // 2: flyteidl2.task.GetTaskDetailsRequest + (*GetTaskDetailsResponse)(nil), // 3: flyteidl2.task.GetTaskDetailsResponse + (*ListTasksRequest)(nil), // 4: flyteidl2.task.ListTasksRequest + (*ListTasksResponse)(nil), // 5: flyteidl2.task.ListTasksResponse + (*ListVersionsRequest)(nil), // 6: flyteidl2.task.ListVersionsRequest + (*ListVersionsResponse)(nil), // 7: flyteidl2.task.ListVersionsResponse + (*ListTasksRequest_KnownFilter)(nil), // 8: flyteidl2.task.ListTasksRequest.KnownFilter + (*ListTasksResponse_ListTasksMetadata)(nil), // 9: flyteidl2.task.ListTasksResponse.ListTasksMetadata + (*ListVersionsResponse_VersionResponse)(nil), // 10: flyteidl2.task.ListVersionsResponse.VersionResponse + (*TaskIdentifier)(nil), // 11: flyteidl2.task.TaskIdentifier + (*TaskSpec)(nil), // 12: flyteidl2.task.TaskSpec + (*TaskTrigger)(nil), // 13: flyteidl2.task.TaskTrigger + (*TaskDetails)(nil), // 14: flyteidl2.task.TaskDetails + (*common.ListRequest)(nil), // 15: flyteidl2.common.ListRequest + (*common.ProjectIdentifier)(nil), // 16: flyteidl2.common.ProjectIdentifier + (*Task)(nil), // 17: flyteidl2.task.Task + (*TaskName)(nil), // 18: flyteidl2.task.TaskName + (*timestamppb.Timestamp)(nil), // 19: google.protobuf.Timestamp +} +var file_flyteidl2_task_task_service_proto_depIdxs = []int32{ + 11, // 0: flyteidl2.task.DeployTaskRequest.task_id:type_name -> flyteidl2.task.TaskIdentifier + 12, // 1: flyteidl2.task.DeployTaskRequest.spec:type_name -> flyteidl2.task.TaskSpec + 13, // 2: flyteidl2.task.DeployTaskRequest.triggers:type_name -> flyteidl2.task.TaskTrigger + 11, // 3: flyteidl2.task.GetTaskDetailsRequest.task_id:type_name -> flyteidl2.task.TaskIdentifier + 14, // 4: flyteidl2.task.GetTaskDetailsResponse.details:type_name -> flyteidl2.task.TaskDetails + 15, // 5: flyteidl2.task.ListTasksRequest.request:type_name -> flyteidl2.common.ListRequest + 16, // 6: flyteidl2.task.ListTasksRequest.project_id:type_name -> flyteidl2.common.ProjectIdentifier + 8, // 7: flyteidl2.task.ListTasksRequest.known_filters:type_name -> flyteidl2.task.ListTasksRequest.KnownFilter + 17, // 8: flyteidl2.task.ListTasksResponse.tasks:type_name -> flyteidl2.task.Task + 9, // 9: flyteidl2.task.ListTasksResponse.metadata:type_name -> flyteidl2.task.ListTasksResponse.ListTasksMetadata + 15, // 10: flyteidl2.task.ListVersionsRequest.request:type_name -> flyteidl2.common.ListRequest + 18, // 11: flyteidl2.task.ListVersionsRequest.task_name:type_name -> flyteidl2.task.TaskName + 10, // 12: flyteidl2.task.ListVersionsResponse.versions:type_name -> flyteidl2.task.ListVersionsResponse.VersionResponse + 19, // 13: flyteidl2.task.ListVersionsResponse.VersionResponse.deployed_at:type_name -> google.protobuf.Timestamp + 0, // 14: flyteidl2.task.TaskService.DeployTask:input_type -> flyteidl2.task.DeployTaskRequest + 2, // 15: flyteidl2.task.TaskService.GetTaskDetails:input_type -> flyteidl2.task.GetTaskDetailsRequest + 4, // 16: flyteidl2.task.TaskService.ListTasks:input_type -> flyteidl2.task.ListTasksRequest + 6, // 17: flyteidl2.task.TaskService.ListVersions:input_type -> flyteidl2.task.ListVersionsRequest + 1, // 18: flyteidl2.task.TaskService.DeployTask:output_type -> flyteidl2.task.DeployTaskResponse + 3, // 19: flyteidl2.task.TaskService.GetTaskDetails:output_type -> flyteidl2.task.GetTaskDetailsResponse + 5, // 20: flyteidl2.task.TaskService.ListTasks:output_type -> flyteidl2.task.ListTasksResponse + 7, // 21: flyteidl2.task.TaskService.ListVersions:output_type -> flyteidl2.task.ListVersionsResponse + 18, // [18:22] is the sub-list for method output_type + 14, // [14:18] is the sub-list for method input_type + 14, // [14:14] is the sub-list for extension type_name + 14, // [14:14] is the sub-list for extension extendee + 0, // [0:14] is the sub-list for field type_name +} + +func init() { file_flyteidl2_task_task_service_proto_init() } +func file_flyteidl2_task_task_service_proto_init() { + if File_flyteidl2_task_task_service_proto != nil { + return + } + file_flyteidl2_task_task_definition_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_task_task_service_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeployTaskRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_service_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeployTaskResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_service_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTaskDetailsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_service_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTaskDetailsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_service_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListTasksRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_service_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListTasksResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_service_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListVersionsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_service_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListVersionsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_service_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListTasksRequest_KnownFilter); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_service_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListTasksResponse_ListTasksMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_task_task_service_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListVersionsResponse_VersionResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_task_task_service_proto_msgTypes[4].OneofWrappers = []interface{}{ + (*ListTasksRequest_Org)(nil), + (*ListTasksRequest_ProjectId)(nil), + } + file_flyteidl2_task_task_service_proto_msgTypes[8].OneofWrappers = []interface{}{ + (*ListTasksRequest_KnownFilter_DeployedBy)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_task_task_service_proto_rawDesc, + NumEnums: 0, + NumMessages: 11, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_flyteidl2_task_task_service_proto_goTypes, + DependencyIndexes: file_flyteidl2_task_task_service_proto_depIdxs, + MessageInfos: file_flyteidl2_task_task_service_proto_msgTypes, + }.Build() + File_flyteidl2_task_task_service_proto = out.File + file_flyteidl2_task_task_service_proto_rawDesc = nil + file_flyteidl2_task_task_service_proto_goTypes = nil + file_flyteidl2_task_task_service_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/task/task_service.pb.validate.go b/gen/go/flyteidl2/task/task_service.pb.validate.go new file mode 100644 index 0000000000..41cf8d55c0 --- /dev/null +++ b/gen/go/flyteidl2/task/task_service.pb.validate.go @@ -0,0 +1,1645 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/task/task_service.proto + +package task + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on DeployTaskRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *DeployTaskRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DeployTaskRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// DeployTaskRequestMultiError, or nil if none found. +func (m *DeployTaskRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *DeployTaskRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetTaskId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DeployTaskRequestValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DeployTaskRequestValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DeployTaskRequestValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DeployTaskRequestValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DeployTaskRequestValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DeployTaskRequestValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetTriggers() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DeployTaskRequestValidationError{ + field: fmt.Sprintf("Triggers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DeployTaskRequestValidationError{ + field: fmt.Sprintf("Triggers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DeployTaskRequestValidationError{ + field: fmt.Sprintf("Triggers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return DeployTaskRequestMultiError(errors) + } + + return nil +} + +// DeployTaskRequestMultiError is an error wrapping multiple validation errors +// returned by DeployTaskRequest.ValidateAll() if the designated constraints +// aren't met. +type DeployTaskRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DeployTaskRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DeployTaskRequestMultiError) AllErrors() []error { return m } + +// DeployTaskRequestValidationError is the validation error returned by +// DeployTaskRequest.Validate if the designated constraints aren't met. +type DeployTaskRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DeployTaskRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DeployTaskRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DeployTaskRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DeployTaskRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DeployTaskRequestValidationError) ErrorName() string { + return "DeployTaskRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e DeployTaskRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDeployTaskRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DeployTaskRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DeployTaskRequestValidationError{} + +// Validate checks the field values on DeployTaskResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *DeployTaskResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DeployTaskResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// DeployTaskResponseMultiError, or nil if none found. +func (m *DeployTaskResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *DeployTaskResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return DeployTaskResponseMultiError(errors) + } + + return nil +} + +// DeployTaskResponseMultiError is an error wrapping multiple validation errors +// returned by DeployTaskResponse.ValidateAll() if the designated constraints +// aren't met. +type DeployTaskResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DeployTaskResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DeployTaskResponseMultiError) AllErrors() []error { return m } + +// DeployTaskResponseValidationError is the validation error returned by +// DeployTaskResponse.Validate if the designated constraints aren't met. +type DeployTaskResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DeployTaskResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DeployTaskResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DeployTaskResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DeployTaskResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DeployTaskResponseValidationError) ErrorName() string { + return "DeployTaskResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e DeployTaskResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDeployTaskResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DeployTaskResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DeployTaskResponseValidationError{} + +// Validate checks the field values on GetTaskDetailsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetTaskDetailsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetTaskDetailsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetTaskDetailsRequestMultiError, or nil if none found. +func (m *GetTaskDetailsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetTaskDetailsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetTaskId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTaskDetailsRequestValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTaskDetailsRequestValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTaskDetailsRequestValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetTaskDetailsRequestMultiError(errors) + } + + return nil +} + +// GetTaskDetailsRequestMultiError is an error wrapping multiple validation +// errors returned by GetTaskDetailsRequest.ValidateAll() if the designated +// constraints aren't met. +type GetTaskDetailsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetTaskDetailsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetTaskDetailsRequestMultiError) AllErrors() []error { return m } + +// GetTaskDetailsRequestValidationError is the validation error returned by +// GetTaskDetailsRequest.Validate if the designated constraints aren't met. +type GetTaskDetailsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetTaskDetailsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetTaskDetailsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetTaskDetailsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetTaskDetailsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetTaskDetailsRequestValidationError) ErrorName() string { + return "GetTaskDetailsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e GetTaskDetailsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetTaskDetailsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetTaskDetailsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetTaskDetailsRequestValidationError{} + +// Validate checks the field values on GetTaskDetailsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetTaskDetailsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetTaskDetailsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetTaskDetailsResponseMultiError, or nil if none found. +func (m *GetTaskDetailsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetTaskDetailsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetDetails()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTaskDetailsResponseValidationError{ + field: "Details", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTaskDetailsResponseValidationError{ + field: "Details", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDetails()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTaskDetailsResponseValidationError{ + field: "Details", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetTaskDetailsResponseMultiError(errors) + } + + return nil +} + +// GetTaskDetailsResponseMultiError is an error wrapping multiple validation +// errors returned by GetTaskDetailsResponse.ValidateAll() if the designated +// constraints aren't met. +type GetTaskDetailsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetTaskDetailsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetTaskDetailsResponseMultiError) AllErrors() []error { return m } + +// GetTaskDetailsResponseValidationError is the validation error returned by +// GetTaskDetailsResponse.Validate if the designated constraints aren't met. +type GetTaskDetailsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetTaskDetailsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetTaskDetailsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetTaskDetailsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetTaskDetailsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetTaskDetailsResponseValidationError) ErrorName() string { + return "GetTaskDetailsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e GetTaskDetailsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetTaskDetailsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetTaskDetailsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetTaskDetailsResponseValidationError{} + +// Validate checks the field values on ListTasksRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *ListTasksRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListTasksRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ListTasksRequestMultiError, or nil if none found. +func (m *ListTasksRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *ListTasksRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRequest()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListTasksRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListTasksRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRequest()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListTasksRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetKnownFilters() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListTasksRequestValidationError{ + field: fmt.Sprintf("KnownFilters[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListTasksRequestValidationError{ + field: fmt.Sprintf("KnownFilters[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListTasksRequestValidationError{ + field: fmt.Sprintf("KnownFilters[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + switch v := m.ScopeBy.(type) { + case *ListTasksRequest_Org: + if v == nil { + err := ListTasksRequestValidationError{ + field: "ScopeBy", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for Org + case *ListTasksRequest_ProjectId: + if v == nil { + err := ListTasksRequestValidationError{ + field: "ScopeBy", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetProjectId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListTasksRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListTasksRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetProjectId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListTasksRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return ListTasksRequestMultiError(errors) + } + + return nil +} + +// ListTasksRequestMultiError is an error wrapping multiple validation errors +// returned by ListTasksRequest.ValidateAll() if the designated constraints +// aren't met. +type ListTasksRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListTasksRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListTasksRequestMultiError) AllErrors() []error { return m } + +// ListTasksRequestValidationError is the validation error returned by +// ListTasksRequest.Validate if the designated constraints aren't met. +type ListTasksRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListTasksRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListTasksRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListTasksRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListTasksRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListTasksRequestValidationError) ErrorName() string { return "ListTasksRequestValidationError" } + +// Error satisfies the builtin error interface +func (e ListTasksRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListTasksRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListTasksRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListTasksRequestValidationError{} + +// Validate checks the field values on ListTasksResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *ListTasksResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListTasksResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ListTasksResponseMultiError, or nil if none found. +func (m *ListTasksResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *ListTasksResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetTasks() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListTasksResponseValidationError{ + field: fmt.Sprintf("Tasks[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListTasksResponseValidationError{ + field: fmt.Sprintf("Tasks[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListTasksResponseValidationError{ + field: fmt.Sprintf("Tasks[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Token + + if all { + switch v := interface{}(m.GetMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListTasksResponseValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListTasksResponseValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListTasksResponseValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ListTasksResponseMultiError(errors) + } + + return nil +} + +// ListTasksResponseMultiError is an error wrapping multiple validation errors +// returned by ListTasksResponse.ValidateAll() if the designated constraints +// aren't met. +type ListTasksResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListTasksResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListTasksResponseMultiError) AllErrors() []error { return m } + +// ListTasksResponseValidationError is the validation error returned by +// ListTasksResponse.Validate if the designated constraints aren't met. +type ListTasksResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListTasksResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListTasksResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListTasksResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListTasksResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListTasksResponseValidationError) ErrorName() string { + return "ListTasksResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e ListTasksResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListTasksResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListTasksResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListTasksResponseValidationError{} + +// Validate checks the field values on ListVersionsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ListVersionsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListVersionsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ListVersionsRequestMultiError, or nil if none found. +func (m *ListVersionsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *ListVersionsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRequest()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListVersionsRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListVersionsRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRequest()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListVersionsRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetTaskName()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListVersionsRequestValidationError{ + field: "TaskName", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListVersionsRequestValidationError{ + field: "TaskName", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskName()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListVersionsRequestValidationError{ + field: "TaskName", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ListVersionsRequestMultiError(errors) + } + + return nil +} + +// ListVersionsRequestMultiError is an error wrapping multiple validation +// errors returned by ListVersionsRequest.ValidateAll() if the designated +// constraints aren't met. +type ListVersionsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListVersionsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListVersionsRequestMultiError) AllErrors() []error { return m } + +// ListVersionsRequestValidationError is the validation error returned by +// ListVersionsRequest.Validate if the designated constraints aren't met. +type ListVersionsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListVersionsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListVersionsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListVersionsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListVersionsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListVersionsRequestValidationError) ErrorName() string { + return "ListVersionsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e ListVersionsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListVersionsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListVersionsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListVersionsRequestValidationError{} + +// Validate checks the field values on ListVersionsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ListVersionsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListVersionsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ListVersionsResponseMultiError, or nil if none found. +func (m *ListVersionsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *ListVersionsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetVersions() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListVersionsResponseValidationError{ + field: fmt.Sprintf("Versions[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListVersionsResponseValidationError{ + field: fmt.Sprintf("Versions[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListVersionsResponseValidationError{ + field: fmt.Sprintf("Versions[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Token + + if len(errors) > 0 { + return ListVersionsResponseMultiError(errors) + } + + return nil +} + +// ListVersionsResponseMultiError is an error wrapping multiple validation +// errors returned by ListVersionsResponse.ValidateAll() if the designated +// constraints aren't met. +type ListVersionsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListVersionsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListVersionsResponseMultiError) AllErrors() []error { return m } + +// ListVersionsResponseValidationError is the validation error returned by +// ListVersionsResponse.Validate if the designated constraints aren't met. +type ListVersionsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListVersionsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListVersionsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListVersionsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListVersionsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListVersionsResponseValidationError) ErrorName() string { + return "ListVersionsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e ListVersionsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListVersionsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListVersionsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListVersionsResponseValidationError{} + +// Validate checks the field values on ListTasksRequest_KnownFilter with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ListTasksRequest_KnownFilter) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListTasksRequest_KnownFilter with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ListTasksRequest_KnownFilterMultiError, or nil if none found. +func (m *ListTasksRequest_KnownFilter) ValidateAll() error { + return m.validate(true) +} + +func (m *ListTasksRequest_KnownFilter) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.FilterBy.(type) { + case *ListTasksRequest_KnownFilter_DeployedBy: + if v == nil { + err := ListTasksRequest_KnownFilterValidationError{ + field: "FilterBy", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for DeployedBy + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return ListTasksRequest_KnownFilterMultiError(errors) + } + + return nil +} + +// ListTasksRequest_KnownFilterMultiError is an error wrapping multiple +// validation errors returned by ListTasksRequest_KnownFilter.ValidateAll() if +// the designated constraints aren't met. +type ListTasksRequest_KnownFilterMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListTasksRequest_KnownFilterMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListTasksRequest_KnownFilterMultiError) AllErrors() []error { return m } + +// ListTasksRequest_KnownFilterValidationError is the validation error returned +// by ListTasksRequest_KnownFilter.Validate if the designated constraints +// aren't met. +type ListTasksRequest_KnownFilterValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListTasksRequest_KnownFilterValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListTasksRequest_KnownFilterValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListTasksRequest_KnownFilterValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListTasksRequest_KnownFilterValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListTasksRequest_KnownFilterValidationError) ErrorName() string { + return "ListTasksRequest_KnownFilterValidationError" +} + +// Error satisfies the builtin error interface +func (e ListTasksRequest_KnownFilterValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListTasksRequest_KnownFilter.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListTasksRequest_KnownFilterValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListTasksRequest_KnownFilterValidationError{} + +// Validate checks the field values on ListTasksResponse_ListTasksMetadata with +// the rules defined in the proto definition for this message. If any rules +// are violated, the first error encountered is returned, or nil if there are +// no violations. +func (m *ListTasksResponse_ListTasksMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListTasksResponse_ListTasksMetadata +// with the rules defined in the proto definition for this message. If any +// rules are violated, the result is a list of violation errors wrapped in +// ListTasksResponse_ListTasksMetadataMultiError, or nil if none found. +func (m *ListTasksResponse_ListTasksMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *ListTasksResponse_ListTasksMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Total + + // no validation rules for FilteredTotal + + if len(errors) > 0 { + return ListTasksResponse_ListTasksMetadataMultiError(errors) + } + + return nil +} + +// ListTasksResponse_ListTasksMetadataMultiError is an error wrapping multiple +// validation errors returned by +// ListTasksResponse_ListTasksMetadata.ValidateAll() if the designated +// constraints aren't met. +type ListTasksResponse_ListTasksMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListTasksResponse_ListTasksMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListTasksResponse_ListTasksMetadataMultiError) AllErrors() []error { return m } + +// ListTasksResponse_ListTasksMetadataValidationError is the validation error +// returned by ListTasksResponse_ListTasksMetadata.Validate if the designated +// constraints aren't met. +type ListTasksResponse_ListTasksMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListTasksResponse_ListTasksMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListTasksResponse_ListTasksMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListTasksResponse_ListTasksMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListTasksResponse_ListTasksMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListTasksResponse_ListTasksMetadataValidationError) ErrorName() string { + return "ListTasksResponse_ListTasksMetadataValidationError" +} + +// Error satisfies the builtin error interface +func (e ListTasksResponse_ListTasksMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListTasksResponse_ListTasksMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListTasksResponse_ListTasksMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListTasksResponse_ListTasksMetadataValidationError{} + +// Validate checks the field values on ListVersionsResponse_VersionResponse +// with the rules defined in the proto definition for this message. If any +// rules are violated, the first error encountered is returned, or nil if +// there are no violations. +func (m *ListVersionsResponse_VersionResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListVersionsResponse_VersionResponse +// with the rules defined in the proto definition for this message. If any +// rules are violated, the result is a list of violation errors wrapped in +// ListVersionsResponse_VersionResponseMultiError, or nil if none found. +func (m *ListVersionsResponse_VersionResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *ListVersionsResponse_VersionResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Version + + if all { + switch v := interface{}(m.GetDeployedAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListVersionsResponse_VersionResponseValidationError{ + field: "DeployedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListVersionsResponse_VersionResponseValidationError{ + field: "DeployedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDeployedAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListVersionsResponse_VersionResponseValidationError{ + field: "DeployedAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ListVersionsResponse_VersionResponseMultiError(errors) + } + + return nil +} + +// ListVersionsResponse_VersionResponseMultiError is an error wrapping multiple +// validation errors returned by +// ListVersionsResponse_VersionResponse.ValidateAll() if the designated +// constraints aren't met. +type ListVersionsResponse_VersionResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListVersionsResponse_VersionResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListVersionsResponse_VersionResponseMultiError) AllErrors() []error { return m } + +// ListVersionsResponse_VersionResponseValidationError is the validation error +// returned by ListVersionsResponse_VersionResponse.Validate if the designated +// constraints aren't met. +type ListVersionsResponse_VersionResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListVersionsResponse_VersionResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListVersionsResponse_VersionResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListVersionsResponse_VersionResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListVersionsResponse_VersionResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListVersionsResponse_VersionResponseValidationError) ErrorName() string { + return "ListVersionsResponse_VersionResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e ListVersionsResponse_VersionResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListVersionsResponse_VersionResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListVersionsResponse_VersionResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListVersionsResponse_VersionResponseValidationError{} diff --git a/gen/go/flyteidl2/task/task_service_grpc.pb.go b/gen/go/flyteidl2/task/task_service_grpc.pb.go new file mode 100644 index 0000000000..d34e75cfcc --- /dev/null +++ b/gen/go/flyteidl2/task/task_service_grpc.pb.go @@ -0,0 +1,226 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: flyteidl2/task/task_service.proto + +package task + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + TaskService_DeployTask_FullMethodName = "/flyteidl2.task.TaskService/DeployTask" + TaskService_GetTaskDetails_FullMethodName = "/flyteidl2.task.TaskService/GetTaskDetails" + TaskService_ListTasks_FullMethodName = "/flyteidl2.task.TaskService/ListTasks" + TaskService_ListVersions_FullMethodName = "/flyteidl2.task.TaskService/ListVersions" +) + +// TaskServiceClient is the client API for TaskService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type TaskServiceClient interface { + // Deploy a task. + DeployTask(ctx context.Context, in *DeployTaskRequest, opts ...grpc.CallOption) (*DeployTaskResponse, error) + // Get detailed information about a task. + GetTaskDetails(ctx context.Context, in *GetTaskDetailsRequest, opts ...grpc.CallOption) (*GetTaskDetailsResponse, error) + // Lists tasks, one per task name, returning the latest version and who it was deployed by. + ListTasks(ctx context.Context, in *ListTasksRequest, opts ...grpc.CallOption) (*ListTasksResponse, error) + // Lists all versions for a task. + ListVersions(ctx context.Context, in *ListVersionsRequest, opts ...grpc.CallOption) (*ListVersionsResponse, error) +} + +type taskServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewTaskServiceClient(cc grpc.ClientConnInterface) TaskServiceClient { + return &taskServiceClient{cc} +} + +func (c *taskServiceClient) DeployTask(ctx context.Context, in *DeployTaskRequest, opts ...grpc.CallOption) (*DeployTaskResponse, error) { + out := new(DeployTaskResponse) + err := c.cc.Invoke(ctx, TaskService_DeployTask_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *taskServiceClient) GetTaskDetails(ctx context.Context, in *GetTaskDetailsRequest, opts ...grpc.CallOption) (*GetTaskDetailsResponse, error) { + out := new(GetTaskDetailsResponse) + err := c.cc.Invoke(ctx, TaskService_GetTaskDetails_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *taskServiceClient) ListTasks(ctx context.Context, in *ListTasksRequest, opts ...grpc.CallOption) (*ListTasksResponse, error) { + out := new(ListTasksResponse) + err := c.cc.Invoke(ctx, TaskService_ListTasks_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *taskServiceClient) ListVersions(ctx context.Context, in *ListVersionsRequest, opts ...grpc.CallOption) (*ListVersionsResponse, error) { + out := new(ListVersionsResponse) + err := c.cc.Invoke(ctx, TaskService_ListVersions_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// TaskServiceServer is the server API for TaskService service. +// All implementations should embed UnimplementedTaskServiceServer +// for forward compatibility +type TaskServiceServer interface { + // Deploy a task. + DeployTask(context.Context, *DeployTaskRequest) (*DeployTaskResponse, error) + // Get detailed information about a task. + GetTaskDetails(context.Context, *GetTaskDetailsRequest) (*GetTaskDetailsResponse, error) + // Lists tasks, one per task name, returning the latest version and who it was deployed by. + ListTasks(context.Context, *ListTasksRequest) (*ListTasksResponse, error) + // Lists all versions for a task. + ListVersions(context.Context, *ListVersionsRequest) (*ListVersionsResponse, error) +} + +// UnimplementedTaskServiceServer should be embedded to have forward compatible implementations. +type UnimplementedTaskServiceServer struct { +} + +func (UnimplementedTaskServiceServer) DeployTask(context.Context, *DeployTaskRequest) (*DeployTaskResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeployTask not implemented") +} +func (UnimplementedTaskServiceServer) GetTaskDetails(context.Context, *GetTaskDetailsRequest) (*GetTaskDetailsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetTaskDetails not implemented") +} +func (UnimplementedTaskServiceServer) ListTasks(context.Context, *ListTasksRequest) (*ListTasksResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ListTasks not implemented") +} +func (UnimplementedTaskServiceServer) ListVersions(context.Context, *ListVersionsRequest) (*ListVersionsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ListVersions not implemented") +} + +// UnsafeTaskServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to TaskServiceServer will +// result in compilation errors. +type UnsafeTaskServiceServer interface { + mustEmbedUnimplementedTaskServiceServer() +} + +func RegisterTaskServiceServer(s grpc.ServiceRegistrar, srv TaskServiceServer) { + s.RegisterService(&TaskService_ServiceDesc, srv) +} + +func _TaskService_DeployTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeployTaskRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TaskServiceServer).DeployTask(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: TaskService_DeployTask_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TaskServiceServer).DeployTask(ctx, req.(*DeployTaskRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _TaskService_GetTaskDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetTaskDetailsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TaskServiceServer).GetTaskDetails(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: TaskService_GetTaskDetails_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TaskServiceServer).GetTaskDetails(ctx, req.(*GetTaskDetailsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _TaskService_ListTasks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListTasksRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TaskServiceServer).ListTasks(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: TaskService_ListTasks_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TaskServiceServer).ListTasks(ctx, req.(*ListTasksRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _TaskService_ListVersions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListVersionsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TaskServiceServer).ListVersions(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: TaskService_ListVersions_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TaskServiceServer).ListVersions(ctx, req.(*ListVersionsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// TaskService_ServiceDesc is the grpc.ServiceDesc for TaskService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var TaskService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.task.TaskService", + HandlerType: (*TaskServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "DeployTask", + Handler: _TaskService_DeployTask_Handler, + }, + { + MethodName: "GetTaskDetails", + Handler: _TaskService_GetTaskDetails_Handler, + }, + { + MethodName: "ListTasks", + Handler: _TaskService_ListTasks_Handler, + }, + { + MethodName: "ListVersions", + Handler: _TaskService_ListVersions_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "flyteidl2/task/task_service.proto", +} diff --git a/gen/go/flyteidl2/task/taskconnect/task_service.connect.go b/gen/go/flyteidl2/task/taskconnect/task_service.connect.go new file mode 100644 index 0000000000..101789d4e8 --- /dev/null +++ b/gen/go/flyteidl2/task/taskconnect/task_service.connect.go @@ -0,0 +1,215 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: flyteidl2/task/task_service.proto + +package taskconnect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + task "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // TaskServiceName is the fully-qualified name of the TaskService service. + TaskServiceName = "flyteidl2.task.TaskService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // TaskServiceDeployTaskProcedure is the fully-qualified name of the TaskService's DeployTask RPC. + TaskServiceDeployTaskProcedure = "/flyteidl2.task.TaskService/DeployTask" + // TaskServiceGetTaskDetailsProcedure is the fully-qualified name of the TaskService's + // GetTaskDetails RPC. + TaskServiceGetTaskDetailsProcedure = "/flyteidl2.task.TaskService/GetTaskDetails" + // TaskServiceListTasksProcedure is the fully-qualified name of the TaskService's ListTasks RPC. + TaskServiceListTasksProcedure = "/flyteidl2.task.TaskService/ListTasks" + // TaskServiceListVersionsProcedure is the fully-qualified name of the TaskService's ListVersions + // RPC. + TaskServiceListVersionsProcedure = "/flyteidl2.task.TaskService/ListVersions" +) + +// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. +var ( + taskServiceServiceDescriptor = task.File_flyteidl2_task_task_service_proto.Services().ByName("TaskService") + taskServiceDeployTaskMethodDescriptor = taskServiceServiceDescriptor.Methods().ByName("DeployTask") + taskServiceGetTaskDetailsMethodDescriptor = taskServiceServiceDescriptor.Methods().ByName("GetTaskDetails") + taskServiceListTasksMethodDescriptor = taskServiceServiceDescriptor.Methods().ByName("ListTasks") + taskServiceListVersionsMethodDescriptor = taskServiceServiceDescriptor.Methods().ByName("ListVersions") +) + +// TaskServiceClient is a client for the flyteidl2.task.TaskService service. +type TaskServiceClient interface { + // Deploy a task. + DeployTask(context.Context, *connect.Request[task.DeployTaskRequest]) (*connect.Response[task.DeployTaskResponse], error) + // Get detailed information about a task. + GetTaskDetails(context.Context, *connect.Request[task.GetTaskDetailsRequest]) (*connect.Response[task.GetTaskDetailsResponse], error) + // Lists tasks, one per task name, returning the latest version and who it was deployed by. + ListTasks(context.Context, *connect.Request[task.ListTasksRequest]) (*connect.Response[task.ListTasksResponse], error) + // Lists all versions for a task. + ListVersions(context.Context, *connect.Request[task.ListVersionsRequest]) (*connect.Response[task.ListVersionsResponse], error) +} + +// NewTaskServiceClient constructs a client for the flyteidl2.task.TaskService service. By default, +// it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and +// sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() +// or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewTaskServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) TaskServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &taskServiceClient{ + deployTask: connect.NewClient[task.DeployTaskRequest, task.DeployTaskResponse]( + httpClient, + baseURL+TaskServiceDeployTaskProcedure, + connect.WithSchema(taskServiceDeployTaskMethodDescriptor), + connect.WithClientOptions(opts...), + ), + getTaskDetails: connect.NewClient[task.GetTaskDetailsRequest, task.GetTaskDetailsResponse]( + httpClient, + baseURL+TaskServiceGetTaskDetailsProcedure, + connect.WithSchema(taskServiceGetTaskDetailsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + listTasks: connect.NewClient[task.ListTasksRequest, task.ListTasksResponse]( + httpClient, + baseURL+TaskServiceListTasksProcedure, + connect.WithSchema(taskServiceListTasksMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + listVersions: connect.NewClient[task.ListVersionsRequest, task.ListVersionsResponse]( + httpClient, + baseURL+TaskServiceListVersionsProcedure, + connect.WithSchema(taskServiceListVersionsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + } +} + +// taskServiceClient implements TaskServiceClient. +type taskServiceClient struct { + deployTask *connect.Client[task.DeployTaskRequest, task.DeployTaskResponse] + getTaskDetails *connect.Client[task.GetTaskDetailsRequest, task.GetTaskDetailsResponse] + listTasks *connect.Client[task.ListTasksRequest, task.ListTasksResponse] + listVersions *connect.Client[task.ListVersionsRequest, task.ListVersionsResponse] +} + +// DeployTask calls flyteidl2.task.TaskService.DeployTask. +func (c *taskServiceClient) DeployTask(ctx context.Context, req *connect.Request[task.DeployTaskRequest]) (*connect.Response[task.DeployTaskResponse], error) { + return c.deployTask.CallUnary(ctx, req) +} + +// GetTaskDetails calls flyteidl2.task.TaskService.GetTaskDetails. +func (c *taskServiceClient) GetTaskDetails(ctx context.Context, req *connect.Request[task.GetTaskDetailsRequest]) (*connect.Response[task.GetTaskDetailsResponse], error) { + return c.getTaskDetails.CallUnary(ctx, req) +} + +// ListTasks calls flyteidl2.task.TaskService.ListTasks. +func (c *taskServiceClient) ListTasks(ctx context.Context, req *connect.Request[task.ListTasksRequest]) (*connect.Response[task.ListTasksResponse], error) { + return c.listTasks.CallUnary(ctx, req) +} + +// ListVersions calls flyteidl2.task.TaskService.ListVersions. +func (c *taskServiceClient) ListVersions(ctx context.Context, req *connect.Request[task.ListVersionsRequest]) (*connect.Response[task.ListVersionsResponse], error) { + return c.listVersions.CallUnary(ctx, req) +} + +// TaskServiceHandler is an implementation of the flyteidl2.task.TaskService service. +type TaskServiceHandler interface { + // Deploy a task. + DeployTask(context.Context, *connect.Request[task.DeployTaskRequest]) (*connect.Response[task.DeployTaskResponse], error) + // Get detailed information about a task. + GetTaskDetails(context.Context, *connect.Request[task.GetTaskDetailsRequest]) (*connect.Response[task.GetTaskDetailsResponse], error) + // Lists tasks, one per task name, returning the latest version and who it was deployed by. + ListTasks(context.Context, *connect.Request[task.ListTasksRequest]) (*connect.Response[task.ListTasksResponse], error) + // Lists all versions for a task. + ListVersions(context.Context, *connect.Request[task.ListVersionsRequest]) (*connect.Response[task.ListVersionsResponse], error) +} + +// NewTaskServiceHandler builds an HTTP handler from the service implementation. It returns the path +// on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewTaskServiceHandler(svc TaskServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + taskServiceDeployTaskHandler := connect.NewUnaryHandler( + TaskServiceDeployTaskProcedure, + svc.DeployTask, + connect.WithSchema(taskServiceDeployTaskMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + taskServiceGetTaskDetailsHandler := connect.NewUnaryHandler( + TaskServiceGetTaskDetailsProcedure, + svc.GetTaskDetails, + connect.WithSchema(taskServiceGetTaskDetailsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + taskServiceListTasksHandler := connect.NewUnaryHandler( + TaskServiceListTasksProcedure, + svc.ListTasks, + connect.WithSchema(taskServiceListTasksMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + taskServiceListVersionsHandler := connect.NewUnaryHandler( + TaskServiceListVersionsProcedure, + svc.ListVersions, + connect.WithSchema(taskServiceListVersionsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.task.TaskService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case TaskServiceDeployTaskProcedure: + taskServiceDeployTaskHandler.ServeHTTP(w, r) + case TaskServiceGetTaskDetailsProcedure: + taskServiceGetTaskDetailsHandler.ServeHTTP(w, r) + case TaskServiceListTasksProcedure: + taskServiceListTasksHandler.ServeHTTP(w, r) + case TaskServiceListVersionsProcedure: + taskServiceListVersionsHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedTaskServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedTaskServiceHandler struct{} + +func (UnimplementedTaskServiceHandler) DeployTask(context.Context, *connect.Request[task.DeployTaskRequest]) (*connect.Response[task.DeployTaskResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.task.TaskService.DeployTask is not implemented")) +} + +func (UnimplementedTaskServiceHandler) GetTaskDetails(context.Context, *connect.Request[task.GetTaskDetailsRequest]) (*connect.Response[task.GetTaskDetailsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.task.TaskService.GetTaskDetails is not implemented")) +} + +func (UnimplementedTaskServiceHandler) ListTasks(context.Context, *connect.Request[task.ListTasksRequest]) (*connect.Response[task.ListTasksResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.task.TaskService.ListTasks is not implemented")) +} + +func (UnimplementedTaskServiceHandler) ListVersions(context.Context, *connect.Request[task.ListVersionsRequest]) (*connect.Response[task.ListVersionsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.task.TaskService.ListVersions is not implemented")) +} diff --git a/gen/go/flyteidl2/trigger/trigger_definition.pb.go b/gen/go/flyteidl2/trigger/trigger_definition.pb.go new file mode 100644 index 0000000000..136edba593 --- /dev/null +++ b/gen/go/flyteidl2/trigger/trigger_definition.pb.go @@ -0,0 +1,862 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/trigger/trigger_definition.proto + +package trigger + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + task "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Stores human- and machine-friendly explanation of what changed in the revision +type TriggerRevisionAction int32 + +const ( + TriggerRevisionAction_TRIGGER_REVISION_ACTION_UNSPECIFIED TriggerRevisionAction = 0 + TriggerRevisionAction_TRIGGER_REVISION_ACTION_DEPLOY TriggerRevisionAction = 1 + TriggerRevisionAction_TRIGGER_REVISION_ACTION_ACTIVATE TriggerRevisionAction = 2 + TriggerRevisionAction_TRIGGER_REVISION_ACTION_DEACTIVATE TriggerRevisionAction = 3 + TriggerRevisionAction_TRIGGER_REVISION_ACTION_DELETE TriggerRevisionAction = 4 +) + +// Enum value maps for TriggerRevisionAction. +var ( + TriggerRevisionAction_name = map[int32]string{ + 0: "TRIGGER_REVISION_ACTION_UNSPECIFIED", + 1: "TRIGGER_REVISION_ACTION_DEPLOY", + 2: "TRIGGER_REVISION_ACTION_ACTIVATE", + 3: "TRIGGER_REVISION_ACTION_DEACTIVATE", + 4: "TRIGGER_REVISION_ACTION_DELETE", + } + TriggerRevisionAction_value = map[string]int32{ + "TRIGGER_REVISION_ACTION_UNSPECIFIED": 0, + "TRIGGER_REVISION_ACTION_DEPLOY": 1, + "TRIGGER_REVISION_ACTION_ACTIVATE": 2, + "TRIGGER_REVISION_ACTION_DEACTIVATE": 3, + "TRIGGER_REVISION_ACTION_DELETE": 4, + } +) + +func (x TriggerRevisionAction) Enum() *TriggerRevisionAction { + p := new(TriggerRevisionAction) + *p = x + return p +} + +func (x TriggerRevisionAction) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (TriggerRevisionAction) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_trigger_trigger_definition_proto_enumTypes[0].Descriptor() +} + +func (TriggerRevisionAction) Type() protoreflect.EnumType { + return &file_flyteidl2_trigger_trigger_definition_proto_enumTypes[0] +} + +func (x TriggerRevisionAction) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use TriggerRevisionAction.Descriptor instead. +func (TriggerRevisionAction) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_definition_proto_rawDescGZIP(), []int{0} +} + +type TriggerMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Identity that last deployed the trigger + DeployedBy *common.EnrichedIdentity `protobuf:"bytes,1,opt,name=deployed_by,json=deployedBy,proto3" json:"deployed_by,omitempty"` + // Identity that last activated or deactivated the trigger + UpdatedBy *common.EnrichedIdentity `protobuf:"bytes,2,opt,name=updated_by,json=updatedBy,proto3" json:"updated_by,omitempty"` +} + +func (x *TriggerMetadata) Reset() { + *x = TriggerMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_definition_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TriggerMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TriggerMetadata) ProtoMessage() {} + +func (x *TriggerMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_definition_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TriggerMetadata.ProtoReflect.Descriptor instead. +func (*TriggerMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_definition_proto_rawDescGZIP(), []int{0} +} + +func (x *TriggerMetadata) GetDeployedBy() *common.EnrichedIdentity { + if x != nil { + return x.DeployedBy + } + return nil +} + +func (x *TriggerMetadata) GetUpdatedBy() *common.EnrichedIdentity { + if x != nil { + return x.UpdatedBy + } + return nil +} + +type TriggerSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Inputs for triggered task. + Inputs *task.Inputs `protobuf:"bytes,2,opt,name=inputs,proto3" json:"inputs,omitempty"` + // The run spec for triggered task. + RunSpec *task.RunSpec `protobuf:"bytes,3,opt,name=run_spec,json=runSpec,proto3" json:"run_spec,omitempty"` + // Whether trigger is active + Active bool `protobuf:"varint,4,opt,name=active,proto3" json:"active,omitempty"` + // Task version together with trigger name will give us the unique task id + TaskVersion string `protobuf:"bytes,5,opt,name=task_version,json=taskVersion,proto3" json:"task_version,omitempty"` + // Optional description + Description string `protobuf:"bytes,6,opt,name=description,proto3" json:"description,omitempty"` +} + +func (x *TriggerSpec) Reset() { + *x = TriggerSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_definition_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TriggerSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TriggerSpec) ProtoMessage() {} + +func (x *TriggerSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_definition_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TriggerSpec.ProtoReflect.Descriptor instead. +func (*TriggerSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_definition_proto_rawDescGZIP(), []int{1} +} + +func (x *TriggerSpec) GetInputs() *task.Inputs { + if x != nil { + return x.Inputs + } + return nil +} + +func (x *TriggerSpec) GetRunSpec() *task.RunSpec { + if x != nil { + return x.RunSpec + } + return nil +} + +func (x *TriggerSpec) GetActive() bool { + if x != nil { + return x.Active + } + return false +} + +func (x *TriggerSpec) GetTaskVersion() string { + if x != nil { + return x.TaskVersion + } + return "" +} + +func (x *TriggerSpec) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +type TriggerStatus struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The first time trigger was deployed. + DeployedAt *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=deployed_at,json=deployedAt,proto3" json:"deployed_at,omitempty"` + // The last time the trigger was updated. + UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"` + // The last time the trigger fired. + TriggeredAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=triggered_at,json=triggeredAt,proto3" json:"triggered_at,omitempty"` + // The time trigger was deleted. + DeletedAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=deleted_at,json=deletedAt,proto3" json:"deleted_at,omitempty"` +} + +func (x *TriggerStatus) Reset() { + *x = TriggerStatus{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_definition_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TriggerStatus) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TriggerStatus) ProtoMessage() {} + +func (x *TriggerStatus) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_definition_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TriggerStatus.ProtoReflect.Descriptor instead. +func (*TriggerStatus) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_definition_proto_rawDescGZIP(), []int{2} +} + +func (x *TriggerStatus) GetDeployedAt() *timestamppb.Timestamp { + if x != nil { + return x.DeployedAt + } + return nil +} + +func (x *TriggerStatus) GetUpdatedAt() *timestamppb.Timestamp { + if x != nil { + return x.UpdatedAt + } + return nil +} + +func (x *TriggerStatus) GetTriggeredAt() *timestamppb.Timestamp { + if x != nil { + return x.TriggeredAt + } + return nil +} + +func (x *TriggerStatus) GetDeletedAt() *timestamppb.Timestamp { + if x != nil { + return x.DeletedAt + } + return nil +} + +// Light-weight information about a single trigger revision +type TriggerRevision struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id *common.TriggerIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Metadata *TriggerMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"` + Status *TriggerStatus `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"` + Action TriggerRevisionAction `protobuf:"varint,4,opt,name=action,proto3,enum=flyteidl2.trigger.TriggerRevisionAction" json:"action,omitempty"` + // Timestamp at which given revision was created. + CreatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` +} + +func (x *TriggerRevision) Reset() { + *x = TriggerRevision{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_definition_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TriggerRevision) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TriggerRevision) ProtoMessage() {} + +func (x *TriggerRevision) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_definition_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TriggerRevision.ProtoReflect.Descriptor instead. +func (*TriggerRevision) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_definition_proto_rawDescGZIP(), []int{3} +} + +func (x *TriggerRevision) GetId() *common.TriggerIdentifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *TriggerRevision) GetMetadata() *TriggerMetadata { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *TriggerRevision) GetStatus() *TriggerStatus { + if x != nil { + return x.Status + } + return nil +} + +func (x *TriggerRevision) GetAction() TriggerRevisionAction { + if x != nil { + return x.Action + } + return TriggerRevisionAction_TRIGGER_REVISION_ACTION_UNSPECIFIED +} + +func (x *TriggerRevision) GetCreatedAt() *timestamppb.Timestamp { + if x != nil { + return x.CreatedAt + } + return nil +} + +// Full details about a trigger stored in DB +type TriggerDetails struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id *common.TriggerIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Metadata *TriggerMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"` + Spec *TriggerSpec `protobuf:"bytes,3,opt,name=spec,proto3" json:"spec,omitempty"` + Status *TriggerStatus `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty"` + // Optional automation spec. + AutomationSpec *task.TriggerAutomationSpec `protobuf:"bytes,5,opt,name=automation_spec,json=automationSpec,proto3" json:"automation_spec,omitempty"` + // Trigger description + Description *string `protobuf:"bytes,6,opt,name=description,proto3,oneof" json:"description,omitempty"` +} + +func (x *TriggerDetails) Reset() { + *x = TriggerDetails{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_definition_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TriggerDetails) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TriggerDetails) ProtoMessage() {} + +func (x *TriggerDetails) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_definition_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TriggerDetails.ProtoReflect.Descriptor instead. +func (*TriggerDetails) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_definition_proto_rawDescGZIP(), []int{4} +} + +func (x *TriggerDetails) GetId() *common.TriggerIdentifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *TriggerDetails) GetMetadata() *TriggerMetadata { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *TriggerDetails) GetSpec() *TriggerSpec { + if x != nil { + return x.Spec + } + return nil +} + +func (x *TriggerDetails) GetStatus() *TriggerStatus { + if x != nil { + return x.Status + } + return nil +} + +func (x *TriggerDetails) GetAutomationSpec() *task.TriggerAutomationSpec { + if x != nil { + return x.AutomationSpec + } + return nil +} + +func (x *TriggerDetails) GetDescription() string { + if x != nil && x.Description != nil { + return *x.Description + } + return "" +} + +// Light-weight information about trigger for a list view +type Trigger struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id *common.TriggerIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Metadata *TriggerMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"` + Status *TriggerStatus `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"` + Active bool `protobuf:"varint,5,opt,name=active,proto3" json:"active,omitempty"` + AutomationSpec *task.TriggerAutomationSpec `protobuf:"bytes,6,opt,name=automation_spec,json=automationSpec,proto3" json:"automation_spec,omitempty"` +} + +func (x *Trigger) Reset() { + *x = Trigger{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_definition_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Trigger) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Trigger) ProtoMessage() {} + +func (x *Trigger) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_definition_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Trigger.ProtoReflect.Descriptor instead. +func (*Trigger) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_definition_proto_rawDescGZIP(), []int{5} +} + +func (x *Trigger) GetId() *common.TriggerIdentifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *Trigger) GetMetadata() *TriggerMetadata { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *Trigger) GetStatus() *TriggerStatus { + if x != nil { + return x.Status + } + return nil +} + +func (x *Trigger) GetActive() bool { + if x != nil { + return x.Active + } + return false +} + +func (x *Trigger) GetAutomationSpec() *task.TriggerAutomationSpec { + if x != nil { + return x.AutomationSpec + } + return nil +} + +var File_flyteidl2_trigger_trigger_definition_proto protoreflect.FileDescriptor + +var file_flyteidl2_trigger_trigger_definition_proto_rawDesc = []byte{ + 0x0a, 0x2a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x2f, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x5f, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x1a, + 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, + 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, + 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x18, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x72, 0x75, + 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa9, 0x01, 0x0a, 0x0f, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x4b, 0x0a, 0x0b, + 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x0a, 0x64, + 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x42, 0x79, 0x12, 0x49, 0x0a, 0x0a, 0x75, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x09, 0x75, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x64, 0x42, 0x79, 0x22, 0xdf, 0x01, 0x0a, 0x0b, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x53, 0x70, 0x65, 0x63, 0x12, 0x2e, 0x0a, 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x52, 0x06, 0x69, 0x6e, + 0x70, 0x75, 0x74, 0x73, 0x12, 0x32, 0x0a, 0x08, 0x72, 0x75, 0x6e, 0x5f, 0x73, 0x70, 0x65, 0x63, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x52, 0x75, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x52, + 0x07, 0x72, 0x75, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, + 0x76, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, + 0x12, 0x2c, 0x0a, 0x0c, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, + 0x3f, 0x52, 0x0b, 0x74, 0x61, 0x73, 0x6b, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x20, + 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x4a, 0x04, 0x08, 0x01, 0x10, 0x02, 0x22, 0x91, 0x02, 0x0a, 0x0d, 0x54, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x43, 0x0a, 0x0b, 0x64, 0x65, 0x70, 0x6c, + 0x6f, 0x79, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, + 0x01, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x41, 0x74, 0x12, 0x41, 0x0a, + 0x0a, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x06, 0xba, + 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x09, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, + 0x12, 0x3d, 0x0a, 0x0c, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x65, 0x64, 0x5f, 0x61, 0x74, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x52, 0x0b, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x65, 0x64, 0x41, 0x74, 0x12, + 0x39, 0x0a, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, + 0x09, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x41, 0x74, 0x22, 0xbd, 0x02, 0x0a, 0x0f, 0x54, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x33, + 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, + 0x02, 0x69, 0x64, 0x12, 0x3e, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x12, 0x38, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x40, 0x0a, + 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x28, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, + 0x6e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, + 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x22, 0x94, 0x03, 0x0a, 0x0e, 0x54, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x3b, 0x0a, + 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, + 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3e, 0x0a, 0x08, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x3a, 0x0a, 0x04, 0x73, 0x70, + 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x53, 0x70, 0x65, 0x63, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, + 0x52, 0x04, 0x73, 0x70, 0x65, 0x63, 0x12, 0x38, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x12, 0x4e, 0x0a, 0x0f, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, + 0x70, 0x65, 0x63, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x41, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, + 0x52, 0x0e, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, + 0x12, 0x2f, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x09, 0x42, 0x08, 0xba, 0x48, 0x05, 0x72, 0x03, 0x18, 0xff, 0x01, 0x48, + 0x00, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x88, 0x01, + 0x01, 0x42, 0x0e, 0x0a, 0x0c, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x22, 0xa6, 0x02, 0x0a, 0x07, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x12, 0x33, 0x0a, + 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x02, + 0x69, 0x64, 0x12, 0x3e, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x12, 0x38, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, + 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x61, 0x63, + 0x74, 0x69, 0x76, 0x65, 0x12, 0x4e, 0x0a, 0x0f, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x41, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x53, 0x70, 0x65, 0x63, 0x52, 0x0e, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x53, 0x70, 0x65, 0x63, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x2a, 0xd6, 0x01, 0x0a, 0x15, 0x54, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x27, 0x0a, 0x23, 0x54, 0x52, 0x49, 0x47, 0x47, 0x45, 0x52, 0x5f, + 0x52, 0x45, 0x56, 0x49, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, + 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x22, 0x0a, + 0x1e, 0x54, 0x52, 0x49, 0x47, 0x47, 0x45, 0x52, 0x5f, 0x52, 0x45, 0x56, 0x49, 0x53, 0x49, 0x4f, + 0x4e, 0x5f, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x10, + 0x01, 0x12, 0x24, 0x0a, 0x20, 0x54, 0x52, 0x49, 0x47, 0x47, 0x45, 0x52, 0x5f, 0x52, 0x45, 0x56, + 0x49, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x43, 0x54, + 0x49, 0x56, 0x41, 0x54, 0x45, 0x10, 0x02, 0x12, 0x26, 0x0a, 0x22, 0x54, 0x52, 0x49, 0x47, 0x47, + 0x45, 0x52, 0x5f, 0x52, 0x45, 0x56, 0x49, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x43, 0x54, 0x49, + 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x41, 0x43, 0x54, 0x49, 0x56, 0x41, 0x54, 0x45, 0x10, 0x03, 0x12, + 0x22, 0x0a, 0x1e, 0x54, 0x52, 0x49, 0x47, 0x47, 0x45, 0x52, 0x5f, 0x52, 0x45, 0x56, 0x49, 0x53, + 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, + 0x45, 0x10, 0x04, 0x42, 0xcd, 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x42, 0x16, 0x54, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0xa2, 0x02, 0x03, 0x46, 0x54, 0x58, 0xaa, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0xca, 0x02, 0x11, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0xe2, 0x02, + 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, + 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x54, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_trigger_trigger_definition_proto_rawDescOnce sync.Once + file_flyteidl2_trigger_trigger_definition_proto_rawDescData = file_flyteidl2_trigger_trigger_definition_proto_rawDesc +) + +func file_flyteidl2_trigger_trigger_definition_proto_rawDescGZIP() []byte { + file_flyteidl2_trigger_trigger_definition_proto_rawDescOnce.Do(func() { + file_flyteidl2_trigger_trigger_definition_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_trigger_trigger_definition_proto_rawDescData) + }) + return file_flyteidl2_trigger_trigger_definition_proto_rawDescData +} + +var file_flyteidl2_trigger_trigger_definition_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_flyteidl2_trigger_trigger_definition_proto_msgTypes = make([]protoimpl.MessageInfo, 6) +var file_flyteidl2_trigger_trigger_definition_proto_goTypes = []interface{}{ + (TriggerRevisionAction)(0), // 0: flyteidl2.trigger.TriggerRevisionAction + (*TriggerMetadata)(nil), // 1: flyteidl2.trigger.TriggerMetadata + (*TriggerSpec)(nil), // 2: flyteidl2.trigger.TriggerSpec + (*TriggerStatus)(nil), // 3: flyteidl2.trigger.TriggerStatus + (*TriggerRevision)(nil), // 4: flyteidl2.trigger.TriggerRevision + (*TriggerDetails)(nil), // 5: flyteidl2.trigger.TriggerDetails + (*Trigger)(nil), // 6: flyteidl2.trigger.Trigger + (*common.EnrichedIdentity)(nil), // 7: flyteidl2.common.EnrichedIdentity + (*task.Inputs)(nil), // 8: flyteidl2.task.Inputs + (*task.RunSpec)(nil), // 9: flyteidl2.task.RunSpec + (*timestamppb.Timestamp)(nil), // 10: google.protobuf.Timestamp + (*common.TriggerIdentifier)(nil), // 11: flyteidl2.common.TriggerIdentifier + (*task.TriggerAutomationSpec)(nil), // 12: flyteidl2.task.TriggerAutomationSpec +} +var file_flyteidl2_trigger_trigger_definition_proto_depIdxs = []int32{ + 7, // 0: flyteidl2.trigger.TriggerMetadata.deployed_by:type_name -> flyteidl2.common.EnrichedIdentity + 7, // 1: flyteidl2.trigger.TriggerMetadata.updated_by:type_name -> flyteidl2.common.EnrichedIdentity + 8, // 2: flyteidl2.trigger.TriggerSpec.inputs:type_name -> flyteidl2.task.Inputs + 9, // 3: flyteidl2.trigger.TriggerSpec.run_spec:type_name -> flyteidl2.task.RunSpec + 10, // 4: flyteidl2.trigger.TriggerStatus.deployed_at:type_name -> google.protobuf.Timestamp + 10, // 5: flyteidl2.trigger.TriggerStatus.updated_at:type_name -> google.protobuf.Timestamp + 10, // 6: flyteidl2.trigger.TriggerStatus.triggered_at:type_name -> google.protobuf.Timestamp + 10, // 7: flyteidl2.trigger.TriggerStatus.deleted_at:type_name -> google.protobuf.Timestamp + 11, // 8: flyteidl2.trigger.TriggerRevision.id:type_name -> flyteidl2.common.TriggerIdentifier + 1, // 9: flyteidl2.trigger.TriggerRevision.metadata:type_name -> flyteidl2.trigger.TriggerMetadata + 3, // 10: flyteidl2.trigger.TriggerRevision.status:type_name -> flyteidl2.trigger.TriggerStatus + 0, // 11: flyteidl2.trigger.TriggerRevision.action:type_name -> flyteidl2.trigger.TriggerRevisionAction + 10, // 12: flyteidl2.trigger.TriggerRevision.created_at:type_name -> google.protobuf.Timestamp + 11, // 13: flyteidl2.trigger.TriggerDetails.id:type_name -> flyteidl2.common.TriggerIdentifier + 1, // 14: flyteidl2.trigger.TriggerDetails.metadata:type_name -> flyteidl2.trigger.TriggerMetadata + 2, // 15: flyteidl2.trigger.TriggerDetails.spec:type_name -> flyteidl2.trigger.TriggerSpec + 3, // 16: flyteidl2.trigger.TriggerDetails.status:type_name -> flyteidl2.trigger.TriggerStatus + 12, // 17: flyteidl2.trigger.TriggerDetails.automation_spec:type_name -> flyteidl2.task.TriggerAutomationSpec + 11, // 18: flyteidl2.trigger.Trigger.id:type_name -> flyteidl2.common.TriggerIdentifier + 1, // 19: flyteidl2.trigger.Trigger.metadata:type_name -> flyteidl2.trigger.TriggerMetadata + 3, // 20: flyteidl2.trigger.Trigger.status:type_name -> flyteidl2.trigger.TriggerStatus + 12, // 21: flyteidl2.trigger.Trigger.automation_spec:type_name -> flyteidl2.task.TriggerAutomationSpec + 22, // [22:22] is the sub-list for method output_type + 22, // [22:22] is the sub-list for method input_type + 22, // [22:22] is the sub-list for extension type_name + 22, // [22:22] is the sub-list for extension extendee + 0, // [0:22] is the sub-list for field type_name +} + +func init() { file_flyteidl2_trigger_trigger_definition_proto_init() } +func file_flyteidl2_trigger_trigger_definition_proto_init() { + if File_flyteidl2_trigger_trigger_definition_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_trigger_trigger_definition_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TriggerMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_trigger_trigger_definition_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TriggerSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_trigger_trigger_definition_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TriggerStatus); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_trigger_trigger_definition_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TriggerRevision); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_trigger_trigger_definition_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TriggerDetails); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_trigger_trigger_definition_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Trigger); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_trigger_trigger_definition_proto_msgTypes[4].OneofWrappers = []interface{}{} + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_trigger_trigger_definition_proto_rawDesc, + NumEnums: 1, + NumMessages: 6, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_trigger_trigger_definition_proto_goTypes, + DependencyIndexes: file_flyteidl2_trigger_trigger_definition_proto_depIdxs, + EnumInfos: file_flyteidl2_trigger_trigger_definition_proto_enumTypes, + MessageInfos: file_flyteidl2_trigger_trigger_definition_proto_msgTypes, + }.Build() + File_flyteidl2_trigger_trigger_definition_proto = out.File + file_flyteidl2_trigger_trigger_definition_proto_rawDesc = nil + file_flyteidl2_trigger_trigger_definition_proto_goTypes = nil + file_flyteidl2_trigger_trigger_definition_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/trigger/trigger_definition.pb.validate.go b/gen/go/flyteidl2/trigger/trigger_definition.pb.validate.go new file mode 100644 index 0000000000..5a3f0303ee --- /dev/null +++ b/gen/go/flyteidl2/trigger/trigger_definition.pb.validate.go @@ -0,0 +1,1256 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/trigger/trigger_definition.proto + +package trigger + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on TriggerMetadata with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *TriggerMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TriggerMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TriggerMetadataMultiError, or nil if none found. +func (m *TriggerMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *TriggerMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetDeployedBy()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerMetadataValidationError{ + field: "DeployedBy", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerMetadataValidationError{ + field: "DeployedBy", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDeployedBy()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerMetadataValidationError{ + field: "DeployedBy", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetUpdatedBy()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerMetadataValidationError{ + field: "UpdatedBy", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerMetadataValidationError{ + field: "UpdatedBy", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetUpdatedBy()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerMetadataValidationError{ + field: "UpdatedBy", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return TriggerMetadataMultiError(errors) + } + + return nil +} + +// TriggerMetadataMultiError is an error wrapping multiple validation errors +// returned by TriggerMetadata.ValidateAll() if the designated constraints +// aren't met. +type TriggerMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TriggerMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TriggerMetadataMultiError) AllErrors() []error { return m } + +// TriggerMetadataValidationError is the validation error returned by +// TriggerMetadata.Validate if the designated constraints aren't met. +type TriggerMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TriggerMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TriggerMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TriggerMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TriggerMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TriggerMetadataValidationError) ErrorName() string { return "TriggerMetadataValidationError" } + +// Error satisfies the builtin error interface +func (e TriggerMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTriggerMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TriggerMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TriggerMetadataValidationError{} + +// Validate checks the field values on TriggerSpec with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TriggerSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TriggerSpec with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TriggerSpecMultiError, or +// nil if none found. +func (m *TriggerSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *TriggerSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetInputs()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerSpecValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerSpecValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetInputs()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerSpecValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetRunSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerSpecValidationError{ + field: "RunSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerSpecValidationError{ + field: "RunSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerSpecValidationError{ + field: "RunSpec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Active + + // no validation rules for TaskVersion + + // no validation rules for Description + + if len(errors) > 0 { + return TriggerSpecMultiError(errors) + } + + return nil +} + +// TriggerSpecMultiError is an error wrapping multiple validation errors +// returned by TriggerSpec.ValidateAll() if the designated constraints aren't met. +type TriggerSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TriggerSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TriggerSpecMultiError) AllErrors() []error { return m } + +// TriggerSpecValidationError is the validation error returned by +// TriggerSpec.Validate if the designated constraints aren't met. +type TriggerSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TriggerSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TriggerSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TriggerSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TriggerSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TriggerSpecValidationError) ErrorName() string { return "TriggerSpecValidationError" } + +// Error satisfies the builtin error interface +func (e TriggerSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTriggerSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TriggerSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TriggerSpecValidationError{} + +// Validate checks the field values on TriggerStatus with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TriggerStatus) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TriggerStatus with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TriggerStatusMultiError, or +// nil if none found. +func (m *TriggerStatus) ValidateAll() error { + return m.validate(true) +} + +func (m *TriggerStatus) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetDeployedAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerStatusValidationError{ + field: "DeployedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerStatusValidationError{ + field: "DeployedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDeployedAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerStatusValidationError{ + field: "DeployedAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetUpdatedAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerStatusValidationError{ + field: "UpdatedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerStatusValidationError{ + field: "UpdatedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetUpdatedAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerStatusValidationError{ + field: "UpdatedAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetTriggeredAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerStatusValidationError{ + field: "TriggeredAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerStatusValidationError{ + field: "TriggeredAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTriggeredAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerStatusValidationError{ + field: "TriggeredAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetDeletedAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerStatusValidationError{ + field: "DeletedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerStatusValidationError{ + field: "DeletedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDeletedAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerStatusValidationError{ + field: "DeletedAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return TriggerStatusMultiError(errors) + } + + return nil +} + +// TriggerStatusMultiError is an error wrapping multiple validation errors +// returned by TriggerStatus.ValidateAll() if the designated constraints +// aren't met. +type TriggerStatusMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TriggerStatusMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TriggerStatusMultiError) AllErrors() []error { return m } + +// TriggerStatusValidationError is the validation error returned by +// TriggerStatus.Validate if the designated constraints aren't met. +type TriggerStatusValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TriggerStatusValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TriggerStatusValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TriggerStatusValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TriggerStatusValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TriggerStatusValidationError) ErrorName() string { return "TriggerStatusValidationError" } + +// Error satisfies the builtin error interface +func (e TriggerStatusValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTriggerStatus.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TriggerStatusValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TriggerStatusValidationError{} + +// Validate checks the field values on TriggerRevision with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *TriggerRevision) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TriggerRevision with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TriggerRevisionMultiError, or nil if none found. +func (m *TriggerRevision) ValidateAll() error { + return m.validate(true) +} + +func (m *TriggerRevision) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerRevisionValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerRevisionValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerRevisionValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerRevisionValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerRevisionValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerRevisionValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetStatus()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerRevisionValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerRevisionValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStatus()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerRevisionValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Action + + if all { + switch v := interface{}(m.GetCreatedAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerRevisionValidationError{ + field: "CreatedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerRevisionValidationError{ + field: "CreatedAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCreatedAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerRevisionValidationError{ + field: "CreatedAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return TriggerRevisionMultiError(errors) + } + + return nil +} + +// TriggerRevisionMultiError is an error wrapping multiple validation errors +// returned by TriggerRevision.ValidateAll() if the designated constraints +// aren't met. +type TriggerRevisionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TriggerRevisionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TriggerRevisionMultiError) AllErrors() []error { return m } + +// TriggerRevisionValidationError is the validation error returned by +// TriggerRevision.Validate if the designated constraints aren't met. +type TriggerRevisionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TriggerRevisionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TriggerRevisionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TriggerRevisionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TriggerRevisionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TriggerRevisionValidationError) ErrorName() string { return "TriggerRevisionValidationError" } + +// Error satisfies the builtin error interface +func (e TriggerRevisionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTriggerRevision.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TriggerRevisionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TriggerRevisionValidationError{} + +// Validate checks the field values on TriggerDetails with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TriggerDetails) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TriggerDetails with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TriggerDetailsMultiError, +// or nil if none found. +func (m *TriggerDetails) ValidateAll() error { + return m.validate(true) +} + +func (m *TriggerDetails) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerDetailsValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerDetailsValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerDetailsValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerDetailsValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerDetailsValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerDetailsValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerDetailsValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerDetailsValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerDetailsValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetStatus()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerDetailsValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerDetailsValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStatus()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerDetailsValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetAutomationSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerDetailsValidationError{ + field: "AutomationSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerDetailsValidationError{ + field: "AutomationSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAutomationSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerDetailsValidationError{ + field: "AutomationSpec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if m.Description != nil { + // no validation rules for Description + } + + if len(errors) > 0 { + return TriggerDetailsMultiError(errors) + } + + return nil +} + +// TriggerDetailsMultiError is an error wrapping multiple validation errors +// returned by TriggerDetails.ValidateAll() if the designated constraints +// aren't met. +type TriggerDetailsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TriggerDetailsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TriggerDetailsMultiError) AllErrors() []error { return m } + +// TriggerDetailsValidationError is the validation error returned by +// TriggerDetails.Validate if the designated constraints aren't met. +type TriggerDetailsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TriggerDetailsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TriggerDetailsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TriggerDetailsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TriggerDetailsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TriggerDetailsValidationError) ErrorName() string { return "TriggerDetailsValidationError" } + +// Error satisfies the builtin error interface +func (e TriggerDetailsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTriggerDetails.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TriggerDetailsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TriggerDetailsValidationError{} + +// Validate checks the field values on Trigger with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Trigger) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Trigger with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in TriggerMultiError, or nil if none found. +func (m *Trigger) ValidateAll() error { + return m.validate(true) +} + +func (m *Trigger) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetStatus()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStatus()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Active + + if all { + switch v := interface{}(m.GetAutomationSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TriggerValidationError{ + field: "AutomationSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TriggerValidationError{ + field: "AutomationSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAutomationSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TriggerValidationError{ + field: "AutomationSpec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return TriggerMultiError(errors) + } + + return nil +} + +// TriggerMultiError is an error wrapping multiple validation errors returned +// by Trigger.ValidateAll() if the designated constraints aren't met. +type TriggerMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TriggerMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TriggerMultiError) AllErrors() []error { return m } + +// TriggerValidationError is the validation error returned by Trigger.Validate +// if the designated constraints aren't met. +type TriggerValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TriggerValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TriggerValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TriggerValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TriggerValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TriggerValidationError) ErrorName() string { return "TriggerValidationError" } + +// Error satisfies the builtin error interface +func (e TriggerValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTrigger.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TriggerValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TriggerValidationError{} diff --git a/gen/go/flyteidl2/trigger/trigger_service.pb.go b/gen/go/flyteidl2/trigger/trigger_service.pb.go new file mode 100644 index 0000000000..a78919d94a --- /dev/null +++ b/gen/go/flyteidl2/trigger/trigger_service.pb.go @@ -0,0 +1,1289 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/trigger/trigger_service.proto + +package trigger + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + task "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Request message for saving a trigger. +type DeployTriggerRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name *common.TriggerName `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"` + // Revision of the trigger. + // Optional for the initial deploy of the trigger. + // Mandatory for updating existing trigger and should store latest previously deployed revision. + Revision uint64 `protobuf:"varint,5,opt,name=revision,proto3" json:"revision,omitempty"` + Spec *TriggerSpec `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"` + // Optional automation spec. + AutomationSpec *task.TriggerAutomationSpec `protobuf:"bytes,3,opt,name=automation_spec,json=automationSpec,proto3" json:"automation_spec,omitempty"` +} + +func (x *DeployTriggerRequest) Reset() { + *x = DeployTriggerRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeployTriggerRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeployTriggerRequest) ProtoMessage() {} + +func (x *DeployTriggerRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeployTriggerRequest.ProtoReflect.Descriptor instead. +func (*DeployTriggerRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_service_proto_rawDescGZIP(), []int{0} +} + +func (x *DeployTriggerRequest) GetName() *common.TriggerName { + if x != nil { + return x.Name + } + return nil +} + +func (x *DeployTriggerRequest) GetRevision() uint64 { + if x != nil { + return x.Revision + } + return 0 +} + +func (x *DeployTriggerRequest) GetSpec() *TriggerSpec { + if x != nil { + return x.Spec + } + return nil +} + +func (x *DeployTriggerRequest) GetAutomationSpec() *task.TriggerAutomationSpec { + if x != nil { + return x.AutomationSpec + } + return nil +} + +// Response message for saving a trigger. +type DeployTriggerResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Trigger *TriggerDetails `protobuf:"bytes,1,opt,name=trigger,proto3" json:"trigger,omitempty"` +} + +func (x *DeployTriggerResponse) Reset() { + *x = DeployTriggerResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeployTriggerResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeployTriggerResponse) ProtoMessage() {} + +func (x *DeployTriggerResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeployTriggerResponse.ProtoReflect.Descriptor instead. +func (*DeployTriggerResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_service_proto_rawDescGZIP(), []int{1} +} + +func (x *DeployTriggerResponse) GetTrigger() *TriggerDetails { + if x != nil { + return x.Trigger + } + return nil +} + +// Request message for saving a trigger. +type GetTriggerDetailsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name *common.TriggerName `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *GetTriggerDetailsRequest) Reset() { + *x = GetTriggerDetailsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTriggerDetailsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTriggerDetailsRequest) ProtoMessage() {} + +func (x *GetTriggerDetailsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetTriggerDetailsRequest.ProtoReflect.Descriptor instead. +func (*GetTriggerDetailsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_service_proto_rawDescGZIP(), []int{2} +} + +func (x *GetTriggerDetailsRequest) GetName() *common.TriggerName { + if x != nil { + return x.Name + } + return nil +} + +// Response message for saving a trigger. +type GetTriggerDetailsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Trigger *TriggerDetails `protobuf:"bytes,1,opt,name=trigger,proto3" json:"trigger,omitempty"` +} + +func (x *GetTriggerDetailsResponse) Reset() { + *x = GetTriggerDetailsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTriggerDetailsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTriggerDetailsResponse) ProtoMessage() {} + +func (x *GetTriggerDetailsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetTriggerDetailsResponse.ProtoReflect.Descriptor instead. +func (*GetTriggerDetailsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_service_proto_rawDescGZIP(), []int{3} +} + +func (x *GetTriggerDetailsResponse) GetTrigger() *TriggerDetails { + if x != nil { + return x.Trigger + } + return nil +} + +// Request message for saving a trigger. +type GetTriggerRevisionDetailsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id *common.TriggerIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` +} + +func (x *GetTriggerRevisionDetailsRequest) Reset() { + *x = GetTriggerRevisionDetailsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTriggerRevisionDetailsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTriggerRevisionDetailsRequest) ProtoMessage() {} + +func (x *GetTriggerRevisionDetailsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetTriggerRevisionDetailsRequest.ProtoReflect.Descriptor instead. +func (*GetTriggerRevisionDetailsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_service_proto_rawDescGZIP(), []int{4} +} + +func (x *GetTriggerRevisionDetailsRequest) GetId() *common.TriggerIdentifier { + if x != nil { + return x.Id + } + return nil +} + +// Response message for saving a trigger. +type GetTriggerRevisionDetailsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Trigger *TriggerDetails `protobuf:"bytes,1,opt,name=trigger,proto3" json:"trigger,omitempty"` +} + +func (x *GetTriggerRevisionDetailsResponse) Reset() { + *x = GetTriggerRevisionDetailsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTriggerRevisionDetailsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTriggerRevisionDetailsResponse) ProtoMessage() {} + +func (x *GetTriggerRevisionDetailsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetTriggerRevisionDetailsResponse.ProtoReflect.Descriptor instead. +func (*GetTriggerRevisionDetailsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_service_proto_rawDescGZIP(), []int{5} +} + +func (x *GetTriggerRevisionDetailsResponse) GetTrigger() *TriggerDetails { + if x != nil { + return x.Trigger + } + return nil +} + +type ListTriggersRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Common list request parameters. + Request *common.ListRequest `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"` + // Types that are assignable to ScopeBy: + // + // *ListTriggersRequest_Org + // *ListTriggersRequest_ProjectId + // *ListTriggersRequest_TaskId + // *ListTriggersRequest_TaskName + ScopeBy isListTriggersRequest_ScopeBy `protobuf_oneof:"scope_by"` +} + +func (x *ListTriggersRequest) Reset() { + *x = ListTriggersRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListTriggersRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListTriggersRequest) ProtoMessage() {} + +func (x *ListTriggersRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListTriggersRequest.ProtoReflect.Descriptor instead. +func (*ListTriggersRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_service_proto_rawDescGZIP(), []int{6} +} + +func (x *ListTriggersRequest) GetRequest() *common.ListRequest { + if x != nil { + return x.Request + } + return nil +} + +func (m *ListTriggersRequest) GetScopeBy() isListTriggersRequest_ScopeBy { + if m != nil { + return m.ScopeBy + } + return nil +} + +func (x *ListTriggersRequest) GetOrg() string { + if x, ok := x.GetScopeBy().(*ListTriggersRequest_Org); ok { + return x.Org + } + return "" +} + +func (x *ListTriggersRequest) GetProjectId() *common.ProjectIdentifier { + if x, ok := x.GetScopeBy().(*ListTriggersRequest_ProjectId); ok { + return x.ProjectId + } + return nil +} + +func (x *ListTriggersRequest) GetTaskId() *task.TaskIdentifier { + if x, ok := x.GetScopeBy().(*ListTriggersRequest_TaskId); ok { + return x.TaskId + } + return nil +} + +func (x *ListTriggersRequest) GetTaskName() *task.TaskName { + if x, ok := x.GetScopeBy().(*ListTriggersRequest_TaskName); ok { + return x.TaskName + } + return nil +} + +type isListTriggersRequest_ScopeBy interface { + isListTriggersRequest_ScopeBy() +} + +type ListTriggersRequest_Org struct { + // Organization name for filtering. + Org string `protobuf:"bytes,2,opt,name=org,proto3,oneof"` +} + +type ListTriggersRequest_ProjectId struct { + // Project identifier for filtering. + ProjectId *common.ProjectIdentifier `protobuf:"bytes,3,opt,name=project_id,json=projectId,proto3,oneof"` +} + +type ListTriggersRequest_TaskId struct { + // List all triggers attached to a given version of a task . + TaskId *task.TaskIdentifier `protobuf:"bytes,4,opt,name=task_id,json=taskId,proto3,oneof"` +} + +type ListTriggersRequest_TaskName struct { + // List all triggers attached to a given task. + TaskName *task.TaskName `protobuf:"bytes,5,opt,name=task_name,json=taskName,proto3,oneof"` +} + +func (*ListTriggersRequest_Org) isListTriggersRequest_ScopeBy() {} + +func (*ListTriggersRequest_ProjectId) isListTriggersRequest_ScopeBy() {} + +func (*ListTriggersRequest_TaskId) isListTriggersRequest_ScopeBy() {} + +func (*ListTriggersRequest_TaskName) isListTriggersRequest_ScopeBy() {} + +// Response message for listing triggers. +type ListTriggersResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // List of triggers matching the filter criteria. + Triggers []*Trigger `protobuf:"bytes,1,rep,name=triggers,proto3" json:"triggers,omitempty"` + // Token for fetching the next page of results, if any. + Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"` +} + +func (x *ListTriggersResponse) Reset() { + *x = ListTriggersResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListTriggersResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListTriggersResponse) ProtoMessage() {} + +func (x *ListTriggersResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListTriggersResponse.ProtoReflect.Descriptor instead. +func (*ListTriggersResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_service_proto_rawDescGZIP(), []int{7} +} + +func (x *ListTriggersResponse) GetTriggers() []*Trigger { + if x != nil { + return x.Triggers + } + return nil +} + +func (x *ListTriggersResponse) GetToken() string { + if x != nil { + return x.Token + } + return "" +} + +type GetTriggerRevisionHistoryRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Request *common.ListRequest `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"` + Name *common.TriggerName `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *GetTriggerRevisionHistoryRequest) Reset() { + *x = GetTriggerRevisionHistoryRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTriggerRevisionHistoryRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTriggerRevisionHistoryRequest) ProtoMessage() {} + +func (x *GetTriggerRevisionHistoryRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetTriggerRevisionHistoryRequest.ProtoReflect.Descriptor instead. +func (*GetTriggerRevisionHistoryRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_service_proto_rawDescGZIP(), []int{8} +} + +func (x *GetTriggerRevisionHistoryRequest) GetRequest() *common.ListRequest { + if x != nil { + return x.Request + } + return nil +} + +func (x *GetTriggerRevisionHistoryRequest) GetName() *common.TriggerName { + if x != nil { + return x.Name + } + return nil +} + +type GetTriggerRevisionHistoryResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // List of triggers matching the filter criteria. + Triggers []*TriggerRevision `protobuf:"bytes,1,rep,name=triggers,proto3" json:"triggers,omitempty"` + // Token for fetching the next page of results, if any. + Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"` +} + +func (x *GetTriggerRevisionHistoryResponse) Reset() { + *x = GetTriggerRevisionHistoryResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTriggerRevisionHistoryResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTriggerRevisionHistoryResponse) ProtoMessage() {} + +func (x *GetTriggerRevisionHistoryResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetTriggerRevisionHistoryResponse.ProtoReflect.Descriptor instead. +func (*GetTriggerRevisionHistoryResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_service_proto_rawDescGZIP(), []int{9} +} + +func (x *GetTriggerRevisionHistoryResponse) GetTriggers() []*TriggerRevision { + if x != nil { + return x.Triggers + } + return nil +} + +func (x *GetTriggerRevisionHistoryResponse) GetToken() string { + if x != nil { + return x.Token + } + return "" +} + +// Request message for updating some trigger spec fields for multiple triggers +type UpdateTriggersRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Names []*common.TriggerName `protobuf:"bytes,1,rep,name=names,proto3" json:"names,omitempty"` + Active bool `protobuf:"varint,2,opt,name=active,proto3" json:"active,omitempty"` +} + +func (x *UpdateTriggersRequest) Reset() { + *x = UpdateTriggersRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UpdateTriggersRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateTriggersRequest) ProtoMessage() {} + +func (x *UpdateTriggersRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateTriggersRequest.ProtoReflect.Descriptor instead. +func (*UpdateTriggersRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_service_proto_rawDescGZIP(), []int{10} +} + +func (x *UpdateTriggersRequest) GetNames() []*common.TriggerName { + if x != nil { + return x.Names + } + return nil +} + +func (x *UpdateTriggersRequest) GetActive() bool { + if x != nil { + return x.Active + } + return false +} + +// Response message for updating some trigger spec fields for multiple triggers +type UpdateTriggersResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *UpdateTriggersResponse) Reset() { + *x = UpdateTriggersResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UpdateTriggersResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateTriggersResponse) ProtoMessage() {} + +func (x *UpdateTriggersResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateTriggersResponse.ProtoReflect.Descriptor instead. +func (*UpdateTriggersResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_service_proto_rawDescGZIP(), []int{11} +} + +// Request message for activating or deactivating multiple triggers +type DeleteTriggersRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Names []*common.TriggerName `protobuf:"bytes,1,rep,name=names,proto3" json:"names,omitempty"` +} + +func (x *DeleteTriggersRequest) Reset() { + *x = DeleteTriggersRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteTriggersRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteTriggersRequest) ProtoMessage() {} + +func (x *DeleteTriggersRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteTriggersRequest.ProtoReflect.Descriptor instead. +func (*DeleteTriggersRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_service_proto_rawDescGZIP(), []int{12} +} + +func (x *DeleteTriggersRequest) GetNames() []*common.TriggerName { + if x != nil { + return x.Names + } + return nil +} + +// Response message for activating or deactivating multiple triggers. +type DeleteTriggersResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *DeleteTriggersResponse) Reset() { + *x = DeleteTriggersResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteTriggersResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteTriggersResponse) ProtoMessage() {} + +func (x *DeleteTriggersResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_trigger_trigger_service_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteTriggersResponse.ProtoReflect.Descriptor instead. +func (*DeleteTriggersResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_trigger_trigger_service_proto_rawDescGZIP(), []int{13} +} + +var File_flyteidl2_trigger_trigger_service_proto protoreflect.FileDescriptor + +var file_flyteidl2_trigger_trigger_service_proto_rawDesc = []byte{ + 0x0a, 0x27, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x2f, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x5f, 0x73, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x1a, 0x1b, 0x62, 0x75, + 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x6c, + 0x69, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2a, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2f, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xff, 0x01, 0x0a, 0x14, 0x44, 0x65, 0x70, + 0x6c, 0x6f, 0x79, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x39, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x42, 0x06, + 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, + 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, + 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x3a, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x53, 0x70, 0x65, 0x63, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x04, + 0x73, 0x70, 0x65, 0x63, 0x12, 0x4e, 0x0a, 0x0f, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x41, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x53, 0x70, 0x65, 0x63, 0x52, 0x0e, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x53, 0x70, 0x65, 0x63, 0x4a, 0x04, 0x08, 0x01, 0x10, 0x02, 0x22, 0x5c, 0x0a, 0x15, 0x44, 0x65, + 0x70, 0x6c, 0x6f, 0x79, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x07, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, + 0x07, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x22, 0x55, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x54, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x39, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, + 0x65, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, + 0x60, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x07, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x07, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x22, 0x5f, 0x0a, 0x20, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, + 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3b, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, + 0x69, 0x64, 0x22, 0x68, 0x0a, 0x21, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x07, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x42, 0x06, 0xba, 0x48, 0x03, + 0xc8, 0x01, 0x01, 0x52, 0x07, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x22, 0xb8, 0x02, 0x0a, + 0x13, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x37, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, + 0x03, 0x6f, 0x72, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, + 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x44, 0x0a, 0x0a, 0x70, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, + 0x12, 0x39, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, + 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x48, 0x00, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x12, 0x37, 0x0a, 0x09, 0x74, + 0x61, 0x73, 0x6b, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x54, 0x61, 0x73, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x48, 0x00, 0x52, 0x08, 0x74, 0x61, 0x73, 0x6b, + 0x4e, 0x61, 0x6d, 0x65, 0x42, 0x11, 0x0a, 0x08, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x5f, 0x62, 0x79, + 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, 0x64, 0x0a, 0x14, 0x4c, 0x69, 0x73, 0x74, 0x54, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x36, 0x0a, 0x08, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x08, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x96, 0x01, + 0x0a, 0x20, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, + 0x73, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x37, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x39, 0x0a, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, + 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x79, 0x0a, 0x21, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, + 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x08, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, + 0x6e, 0x52, 0x08, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, + 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, + 0x6e, 0x22, 0x6e, 0x0a, 0x15, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3d, 0x0a, 0x05, 0x6e, 0x61, + 0x6d, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x42, 0x08, 0xba, 0x48, 0x05, 0x92, 0x01, 0x02, + 0x08, 0x01, 0x52, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, + 0x69, 0x76, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, + 0x65, 0x22, 0x18, 0x0a, 0x16, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x56, 0x0a, 0x15, 0x44, + 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x3d, 0x0a, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, + 0x6d, 0x65, 0x42, 0x08, 0xba, 0x48, 0x05, 0x92, 0x01, 0x02, 0x08, 0x01, 0x52, 0x05, 0x6e, 0x61, + 0x6d, 0x65, 0x73, 0x22, 0x18, 0x0a, 0x16, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0xbf, 0x06, + 0x0a, 0x0e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x12, 0x64, 0x0a, 0x0d, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x12, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x54, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x44, + 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x73, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x2b, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, + 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, + 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x8b, 0x01, 0x0a, 0x19, + 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, + 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x33, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x47, 0x65, + 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x34, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, + 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x64, 0x0a, 0x0c, 0x4c, 0x69, 0x73, + 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x12, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x4c, 0x69, + 0x73, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, + 0x8b, 0x01, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, + 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x33, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, + 0x73, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x34, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x67, 0x0a, + 0x0e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x12, + 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x55, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x67, 0x0a, 0x0e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x12, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x44, 0x65, 0x6c, + 0x65, 0x74, 0x65, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, + 0xca, 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x42, 0x13, 0x54, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, + 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, + 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0xa2, 0x02, 0x03, 0x46, 0x54, 0x58, 0xaa, + 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x54, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0xca, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, + 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0xe2, 0x02, 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_trigger_trigger_service_proto_rawDescOnce sync.Once + file_flyteidl2_trigger_trigger_service_proto_rawDescData = file_flyteidl2_trigger_trigger_service_proto_rawDesc +) + +func file_flyteidl2_trigger_trigger_service_proto_rawDescGZIP() []byte { + file_flyteidl2_trigger_trigger_service_proto_rawDescOnce.Do(func() { + file_flyteidl2_trigger_trigger_service_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_trigger_trigger_service_proto_rawDescData) + }) + return file_flyteidl2_trigger_trigger_service_proto_rawDescData +} + +var file_flyteidl2_trigger_trigger_service_proto_msgTypes = make([]protoimpl.MessageInfo, 14) +var file_flyteidl2_trigger_trigger_service_proto_goTypes = []interface{}{ + (*DeployTriggerRequest)(nil), // 0: flyteidl2.trigger.DeployTriggerRequest + (*DeployTriggerResponse)(nil), // 1: flyteidl2.trigger.DeployTriggerResponse + (*GetTriggerDetailsRequest)(nil), // 2: flyteidl2.trigger.GetTriggerDetailsRequest + (*GetTriggerDetailsResponse)(nil), // 3: flyteidl2.trigger.GetTriggerDetailsResponse + (*GetTriggerRevisionDetailsRequest)(nil), // 4: flyteidl2.trigger.GetTriggerRevisionDetailsRequest + (*GetTriggerRevisionDetailsResponse)(nil), // 5: flyteidl2.trigger.GetTriggerRevisionDetailsResponse + (*ListTriggersRequest)(nil), // 6: flyteidl2.trigger.ListTriggersRequest + (*ListTriggersResponse)(nil), // 7: flyteidl2.trigger.ListTriggersResponse + (*GetTriggerRevisionHistoryRequest)(nil), // 8: flyteidl2.trigger.GetTriggerRevisionHistoryRequest + (*GetTriggerRevisionHistoryResponse)(nil), // 9: flyteidl2.trigger.GetTriggerRevisionHistoryResponse + (*UpdateTriggersRequest)(nil), // 10: flyteidl2.trigger.UpdateTriggersRequest + (*UpdateTriggersResponse)(nil), // 11: flyteidl2.trigger.UpdateTriggersResponse + (*DeleteTriggersRequest)(nil), // 12: flyteidl2.trigger.DeleteTriggersRequest + (*DeleteTriggersResponse)(nil), // 13: flyteidl2.trigger.DeleteTriggersResponse + (*common.TriggerName)(nil), // 14: flyteidl2.common.TriggerName + (*TriggerSpec)(nil), // 15: flyteidl2.trigger.TriggerSpec + (*task.TriggerAutomationSpec)(nil), // 16: flyteidl2.task.TriggerAutomationSpec + (*TriggerDetails)(nil), // 17: flyteidl2.trigger.TriggerDetails + (*common.TriggerIdentifier)(nil), // 18: flyteidl2.common.TriggerIdentifier + (*common.ListRequest)(nil), // 19: flyteidl2.common.ListRequest + (*common.ProjectIdentifier)(nil), // 20: flyteidl2.common.ProjectIdentifier + (*task.TaskIdentifier)(nil), // 21: flyteidl2.task.TaskIdentifier + (*task.TaskName)(nil), // 22: flyteidl2.task.TaskName + (*Trigger)(nil), // 23: flyteidl2.trigger.Trigger + (*TriggerRevision)(nil), // 24: flyteidl2.trigger.TriggerRevision +} +var file_flyteidl2_trigger_trigger_service_proto_depIdxs = []int32{ + 14, // 0: flyteidl2.trigger.DeployTriggerRequest.name:type_name -> flyteidl2.common.TriggerName + 15, // 1: flyteidl2.trigger.DeployTriggerRequest.spec:type_name -> flyteidl2.trigger.TriggerSpec + 16, // 2: flyteidl2.trigger.DeployTriggerRequest.automation_spec:type_name -> flyteidl2.task.TriggerAutomationSpec + 17, // 3: flyteidl2.trigger.DeployTriggerResponse.trigger:type_name -> flyteidl2.trigger.TriggerDetails + 14, // 4: flyteidl2.trigger.GetTriggerDetailsRequest.name:type_name -> flyteidl2.common.TriggerName + 17, // 5: flyteidl2.trigger.GetTriggerDetailsResponse.trigger:type_name -> flyteidl2.trigger.TriggerDetails + 18, // 6: flyteidl2.trigger.GetTriggerRevisionDetailsRequest.id:type_name -> flyteidl2.common.TriggerIdentifier + 17, // 7: flyteidl2.trigger.GetTriggerRevisionDetailsResponse.trigger:type_name -> flyteidl2.trigger.TriggerDetails + 19, // 8: flyteidl2.trigger.ListTriggersRequest.request:type_name -> flyteidl2.common.ListRequest + 20, // 9: flyteidl2.trigger.ListTriggersRequest.project_id:type_name -> flyteidl2.common.ProjectIdentifier + 21, // 10: flyteidl2.trigger.ListTriggersRequest.task_id:type_name -> flyteidl2.task.TaskIdentifier + 22, // 11: flyteidl2.trigger.ListTriggersRequest.task_name:type_name -> flyteidl2.task.TaskName + 23, // 12: flyteidl2.trigger.ListTriggersResponse.triggers:type_name -> flyteidl2.trigger.Trigger + 19, // 13: flyteidl2.trigger.GetTriggerRevisionHistoryRequest.request:type_name -> flyteidl2.common.ListRequest + 14, // 14: flyteidl2.trigger.GetTriggerRevisionHistoryRequest.name:type_name -> flyteidl2.common.TriggerName + 24, // 15: flyteidl2.trigger.GetTriggerRevisionHistoryResponse.triggers:type_name -> flyteidl2.trigger.TriggerRevision + 14, // 16: flyteidl2.trigger.UpdateTriggersRequest.names:type_name -> flyteidl2.common.TriggerName + 14, // 17: flyteidl2.trigger.DeleteTriggersRequest.names:type_name -> flyteidl2.common.TriggerName + 0, // 18: flyteidl2.trigger.TriggerService.DeployTrigger:input_type -> flyteidl2.trigger.DeployTriggerRequest + 2, // 19: flyteidl2.trigger.TriggerService.GetTriggerDetails:input_type -> flyteidl2.trigger.GetTriggerDetailsRequest + 4, // 20: flyteidl2.trigger.TriggerService.GetTriggerRevisionDetails:input_type -> flyteidl2.trigger.GetTriggerRevisionDetailsRequest + 6, // 21: flyteidl2.trigger.TriggerService.ListTriggers:input_type -> flyteidl2.trigger.ListTriggersRequest + 8, // 22: flyteidl2.trigger.TriggerService.GetTriggerRevisionHistory:input_type -> flyteidl2.trigger.GetTriggerRevisionHistoryRequest + 10, // 23: flyteidl2.trigger.TriggerService.UpdateTriggers:input_type -> flyteidl2.trigger.UpdateTriggersRequest + 12, // 24: flyteidl2.trigger.TriggerService.DeleteTriggers:input_type -> flyteidl2.trigger.DeleteTriggersRequest + 1, // 25: flyteidl2.trigger.TriggerService.DeployTrigger:output_type -> flyteidl2.trigger.DeployTriggerResponse + 3, // 26: flyteidl2.trigger.TriggerService.GetTriggerDetails:output_type -> flyteidl2.trigger.GetTriggerDetailsResponse + 5, // 27: flyteidl2.trigger.TriggerService.GetTriggerRevisionDetails:output_type -> flyteidl2.trigger.GetTriggerRevisionDetailsResponse + 7, // 28: flyteidl2.trigger.TriggerService.ListTriggers:output_type -> flyteidl2.trigger.ListTriggersResponse + 9, // 29: flyteidl2.trigger.TriggerService.GetTriggerRevisionHistory:output_type -> flyteidl2.trigger.GetTriggerRevisionHistoryResponse + 11, // 30: flyteidl2.trigger.TriggerService.UpdateTriggers:output_type -> flyteidl2.trigger.UpdateTriggersResponse + 13, // 31: flyteidl2.trigger.TriggerService.DeleteTriggers:output_type -> flyteidl2.trigger.DeleteTriggersResponse + 25, // [25:32] is the sub-list for method output_type + 18, // [18:25] is the sub-list for method input_type + 18, // [18:18] is the sub-list for extension type_name + 18, // [18:18] is the sub-list for extension extendee + 0, // [0:18] is the sub-list for field type_name +} + +func init() { file_flyteidl2_trigger_trigger_service_proto_init() } +func file_flyteidl2_trigger_trigger_service_proto_init() { + if File_flyteidl2_trigger_trigger_service_proto != nil { + return + } + file_flyteidl2_trigger_trigger_definition_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_trigger_trigger_service_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeployTriggerRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_trigger_trigger_service_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeployTriggerResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_trigger_trigger_service_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTriggerDetailsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_trigger_trigger_service_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTriggerDetailsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_trigger_trigger_service_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTriggerRevisionDetailsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_trigger_trigger_service_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTriggerRevisionDetailsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_trigger_trigger_service_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListTriggersRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_trigger_trigger_service_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListTriggersResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_trigger_trigger_service_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTriggerRevisionHistoryRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_trigger_trigger_service_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTriggerRevisionHistoryResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_trigger_trigger_service_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UpdateTriggersRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_trigger_trigger_service_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UpdateTriggersResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_trigger_trigger_service_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteTriggersRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_trigger_trigger_service_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteTriggersResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_trigger_trigger_service_proto_msgTypes[6].OneofWrappers = []interface{}{ + (*ListTriggersRequest_Org)(nil), + (*ListTriggersRequest_ProjectId)(nil), + (*ListTriggersRequest_TaskId)(nil), + (*ListTriggersRequest_TaskName)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_trigger_trigger_service_proto_rawDesc, + NumEnums: 0, + NumMessages: 14, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_flyteidl2_trigger_trigger_service_proto_goTypes, + DependencyIndexes: file_flyteidl2_trigger_trigger_service_proto_depIdxs, + MessageInfos: file_flyteidl2_trigger_trigger_service_proto_msgTypes, + }.Build() + File_flyteidl2_trigger_trigger_service_proto = out.File + file_flyteidl2_trigger_trigger_service_proto_rawDesc = nil + file_flyteidl2_trigger_trigger_service_proto_goTypes = nil + file_flyteidl2_trigger_trigger_service_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/trigger/trigger_service.pb.validate.go b/gen/go/flyteidl2/trigger/trigger_service.pb.validate.go new file mode 100644 index 0000000000..7ef0d3ef24 --- /dev/null +++ b/gen/go/flyteidl2/trigger/trigger_service.pb.validate.go @@ -0,0 +1,2079 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/trigger/trigger_service.proto + +package trigger + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on DeployTriggerRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *DeployTriggerRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DeployTriggerRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// DeployTriggerRequestMultiError, or nil if none found. +func (m *DeployTriggerRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *DeployTriggerRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetName()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DeployTriggerRequestValidationError{ + field: "Name", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DeployTriggerRequestValidationError{ + field: "Name", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetName()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DeployTriggerRequestValidationError{ + field: "Name", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Revision + + if all { + switch v := interface{}(m.GetSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DeployTriggerRequestValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DeployTriggerRequestValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DeployTriggerRequestValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetAutomationSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DeployTriggerRequestValidationError{ + field: "AutomationSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DeployTriggerRequestValidationError{ + field: "AutomationSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAutomationSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DeployTriggerRequestValidationError{ + field: "AutomationSpec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DeployTriggerRequestMultiError(errors) + } + + return nil +} + +// DeployTriggerRequestMultiError is an error wrapping multiple validation +// errors returned by DeployTriggerRequest.ValidateAll() if the designated +// constraints aren't met. +type DeployTriggerRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DeployTriggerRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DeployTriggerRequestMultiError) AllErrors() []error { return m } + +// DeployTriggerRequestValidationError is the validation error returned by +// DeployTriggerRequest.Validate if the designated constraints aren't met. +type DeployTriggerRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DeployTriggerRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DeployTriggerRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DeployTriggerRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DeployTriggerRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DeployTriggerRequestValidationError) ErrorName() string { + return "DeployTriggerRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e DeployTriggerRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDeployTriggerRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DeployTriggerRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DeployTriggerRequestValidationError{} + +// Validate checks the field values on DeployTriggerResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *DeployTriggerResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DeployTriggerResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// DeployTriggerResponseMultiError, or nil if none found. +func (m *DeployTriggerResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *DeployTriggerResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetTrigger()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DeployTriggerResponseValidationError{ + field: "Trigger", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DeployTriggerResponseValidationError{ + field: "Trigger", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTrigger()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DeployTriggerResponseValidationError{ + field: "Trigger", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return DeployTriggerResponseMultiError(errors) + } + + return nil +} + +// DeployTriggerResponseMultiError is an error wrapping multiple validation +// errors returned by DeployTriggerResponse.ValidateAll() if the designated +// constraints aren't met. +type DeployTriggerResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DeployTriggerResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DeployTriggerResponseMultiError) AllErrors() []error { return m } + +// DeployTriggerResponseValidationError is the validation error returned by +// DeployTriggerResponse.Validate if the designated constraints aren't met. +type DeployTriggerResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DeployTriggerResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DeployTriggerResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DeployTriggerResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DeployTriggerResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DeployTriggerResponseValidationError) ErrorName() string { + return "DeployTriggerResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e DeployTriggerResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDeployTriggerResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DeployTriggerResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DeployTriggerResponseValidationError{} + +// Validate checks the field values on GetTriggerDetailsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetTriggerDetailsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetTriggerDetailsRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetTriggerDetailsRequestMultiError, or nil if none found. +func (m *GetTriggerDetailsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetTriggerDetailsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetName()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTriggerDetailsRequestValidationError{ + field: "Name", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTriggerDetailsRequestValidationError{ + field: "Name", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetName()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTriggerDetailsRequestValidationError{ + field: "Name", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetTriggerDetailsRequestMultiError(errors) + } + + return nil +} + +// GetTriggerDetailsRequestMultiError is an error wrapping multiple validation +// errors returned by GetTriggerDetailsRequest.ValidateAll() if the designated +// constraints aren't met. +type GetTriggerDetailsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetTriggerDetailsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetTriggerDetailsRequestMultiError) AllErrors() []error { return m } + +// GetTriggerDetailsRequestValidationError is the validation error returned by +// GetTriggerDetailsRequest.Validate if the designated constraints aren't met. +type GetTriggerDetailsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetTriggerDetailsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetTriggerDetailsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetTriggerDetailsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetTriggerDetailsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetTriggerDetailsRequestValidationError) ErrorName() string { + return "GetTriggerDetailsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e GetTriggerDetailsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetTriggerDetailsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetTriggerDetailsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetTriggerDetailsRequestValidationError{} + +// Validate checks the field values on GetTriggerDetailsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetTriggerDetailsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetTriggerDetailsResponse with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetTriggerDetailsResponseMultiError, or nil if none found. +func (m *GetTriggerDetailsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetTriggerDetailsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetTrigger()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTriggerDetailsResponseValidationError{ + field: "Trigger", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTriggerDetailsResponseValidationError{ + field: "Trigger", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTrigger()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTriggerDetailsResponseValidationError{ + field: "Trigger", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetTriggerDetailsResponseMultiError(errors) + } + + return nil +} + +// GetTriggerDetailsResponseMultiError is an error wrapping multiple validation +// errors returned by GetTriggerDetailsResponse.ValidateAll() if the +// designated constraints aren't met. +type GetTriggerDetailsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetTriggerDetailsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetTriggerDetailsResponseMultiError) AllErrors() []error { return m } + +// GetTriggerDetailsResponseValidationError is the validation error returned by +// GetTriggerDetailsResponse.Validate if the designated constraints aren't met. +type GetTriggerDetailsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetTriggerDetailsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetTriggerDetailsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetTriggerDetailsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetTriggerDetailsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetTriggerDetailsResponseValidationError) ErrorName() string { + return "GetTriggerDetailsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e GetTriggerDetailsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetTriggerDetailsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetTriggerDetailsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetTriggerDetailsResponseValidationError{} + +// Validate checks the field values on GetTriggerRevisionDetailsRequest with +// the rules defined in the proto definition for this message. If any rules +// are violated, the first error encountered is returned, or nil if there are +// no violations. +func (m *GetTriggerRevisionDetailsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetTriggerRevisionDetailsRequest with +// the rules defined in the proto definition for this message. If any rules +// are violated, the result is a list of violation errors wrapped in +// GetTriggerRevisionDetailsRequestMultiError, or nil if none found. +func (m *GetTriggerRevisionDetailsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetTriggerRevisionDetailsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTriggerRevisionDetailsRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTriggerRevisionDetailsRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTriggerRevisionDetailsRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetTriggerRevisionDetailsRequestMultiError(errors) + } + + return nil +} + +// GetTriggerRevisionDetailsRequestMultiError is an error wrapping multiple +// validation errors returned by +// GetTriggerRevisionDetailsRequest.ValidateAll() if the designated +// constraints aren't met. +type GetTriggerRevisionDetailsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetTriggerRevisionDetailsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetTriggerRevisionDetailsRequestMultiError) AllErrors() []error { return m } + +// GetTriggerRevisionDetailsRequestValidationError is the validation error +// returned by GetTriggerRevisionDetailsRequest.Validate if the designated +// constraints aren't met. +type GetTriggerRevisionDetailsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetTriggerRevisionDetailsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetTriggerRevisionDetailsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetTriggerRevisionDetailsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetTriggerRevisionDetailsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetTriggerRevisionDetailsRequestValidationError) ErrorName() string { + return "GetTriggerRevisionDetailsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e GetTriggerRevisionDetailsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetTriggerRevisionDetailsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetTriggerRevisionDetailsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetTriggerRevisionDetailsRequestValidationError{} + +// Validate checks the field values on GetTriggerRevisionDetailsResponse with +// the rules defined in the proto definition for this message. If any rules +// are violated, the first error encountered is returned, or nil if there are +// no violations. +func (m *GetTriggerRevisionDetailsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetTriggerRevisionDetailsResponse +// with the rules defined in the proto definition for this message. If any +// rules are violated, the result is a list of violation errors wrapped in +// GetTriggerRevisionDetailsResponseMultiError, or nil if none found. +func (m *GetTriggerRevisionDetailsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetTriggerRevisionDetailsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetTrigger()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTriggerRevisionDetailsResponseValidationError{ + field: "Trigger", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTriggerRevisionDetailsResponseValidationError{ + field: "Trigger", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTrigger()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTriggerRevisionDetailsResponseValidationError{ + field: "Trigger", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetTriggerRevisionDetailsResponseMultiError(errors) + } + + return nil +} + +// GetTriggerRevisionDetailsResponseMultiError is an error wrapping multiple +// validation errors returned by +// GetTriggerRevisionDetailsResponse.ValidateAll() if the designated +// constraints aren't met. +type GetTriggerRevisionDetailsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetTriggerRevisionDetailsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetTriggerRevisionDetailsResponseMultiError) AllErrors() []error { return m } + +// GetTriggerRevisionDetailsResponseValidationError is the validation error +// returned by GetTriggerRevisionDetailsResponse.Validate if the designated +// constraints aren't met. +type GetTriggerRevisionDetailsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetTriggerRevisionDetailsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetTriggerRevisionDetailsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetTriggerRevisionDetailsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetTriggerRevisionDetailsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetTriggerRevisionDetailsResponseValidationError) ErrorName() string { + return "GetTriggerRevisionDetailsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e GetTriggerRevisionDetailsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetTriggerRevisionDetailsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetTriggerRevisionDetailsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetTriggerRevisionDetailsResponseValidationError{} + +// Validate checks the field values on ListTriggersRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ListTriggersRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListTriggersRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ListTriggersRequestMultiError, or nil if none found. +func (m *ListTriggersRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *ListTriggersRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRequest()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListTriggersRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListTriggersRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRequest()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListTriggersRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + } + } + } + + switch v := m.ScopeBy.(type) { + case *ListTriggersRequest_Org: + if v == nil { + err := ListTriggersRequestValidationError{ + field: "ScopeBy", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for Org + case *ListTriggersRequest_ProjectId: + if v == nil { + err := ListTriggersRequestValidationError{ + field: "ScopeBy", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetProjectId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListTriggersRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListTriggersRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetProjectId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListTriggersRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *ListTriggersRequest_TaskId: + if v == nil { + err := ListTriggersRequestValidationError{ + field: "ScopeBy", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTaskId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListTriggersRequestValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListTriggersRequestValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListTriggersRequestValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *ListTriggersRequest_TaskName: + if v == nil { + err := ListTriggersRequestValidationError{ + field: "ScopeBy", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTaskName()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListTriggersRequestValidationError{ + field: "TaskName", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListTriggersRequestValidationError{ + field: "TaskName", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskName()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListTriggersRequestValidationError{ + field: "TaskName", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return ListTriggersRequestMultiError(errors) + } + + return nil +} + +// ListTriggersRequestMultiError is an error wrapping multiple validation +// errors returned by ListTriggersRequest.ValidateAll() if the designated +// constraints aren't met. +type ListTriggersRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListTriggersRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListTriggersRequestMultiError) AllErrors() []error { return m } + +// ListTriggersRequestValidationError is the validation error returned by +// ListTriggersRequest.Validate if the designated constraints aren't met. +type ListTriggersRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListTriggersRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListTriggersRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListTriggersRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListTriggersRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListTriggersRequestValidationError) ErrorName() string { + return "ListTriggersRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e ListTriggersRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListTriggersRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListTriggersRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListTriggersRequestValidationError{} + +// Validate checks the field values on ListTriggersResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ListTriggersResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListTriggersResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ListTriggersResponseMultiError, or nil if none found. +func (m *ListTriggersResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *ListTriggersResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetTriggers() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListTriggersResponseValidationError{ + field: fmt.Sprintf("Triggers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListTriggersResponseValidationError{ + field: fmt.Sprintf("Triggers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListTriggersResponseValidationError{ + field: fmt.Sprintf("Triggers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Token + + if len(errors) > 0 { + return ListTriggersResponseMultiError(errors) + } + + return nil +} + +// ListTriggersResponseMultiError is an error wrapping multiple validation +// errors returned by ListTriggersResponse.ValidateAll() if the designated +// constraints aren't met. +type ListTriggersResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListTriggersResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListTriggersResponseMultiError) AllErrors() []error { return m } + +// ListTriggersResponseValidationError is the validation error returned by +// ListTriggersResponse.Validate if the designated constraints aren't met. +type ListTriggersResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListTriggersResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListTriggersResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListTriggersResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListTriggersResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListTriggersResponseValidationError) ErrorName() string { + return "ListTriggersResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e ListTriggersResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListTriggersResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListTriggersResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListTriggersResponseValidationError{} + +// Validate checks the field values on GetTriggerRevisionHistoryRequest with +// the rules defined in the proto definition for this message. If any rules +// are violated, the first error encountered is returned, or nil if there are +// no violations. +func (m *GetTriggerRevisionHistoryRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetTriggerRevisionHistoryRequest with +// the rules defined in the proto definition for this message. If any rules +// are violated, the result is a list of violation errors wrapped in +// GetTriggerRevisionHistoryRequestMultiError, or nil if none found. +func (m *GetTriggerRevisionHistoryRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetTriggerRevisionHistoryRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRequest()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTriggerRevisionHistoryRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTriggerRevisionHistoryRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRequest()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTriggerRevisionHistoryRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetName()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTriggerRevisionHistoryRequestValidationError{ + field: "Name", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTriggerRevisionHistoryRequestValidationError{ + field: "Name", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetName()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTriggerRevisionHistoryRequestValidationError{ + field: "Name", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetTriggerRevisionHistoryRequestMultiError(errors) + } + + return nil +} + +// GetTriggerRevisionHistoryRequestMultiError is an error wrapping multiple +// validation errors returned by +// GetTriggerRevisionHistoryRequest.ValidateAll() if the designated +// constraints aren't met. +type GetTriggerRevisionHistoryRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetTriggerRevisionHistoryRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetTriggerRevisionHistoryRequestMultiError) AllErrors() []error { return m } + +// GetTriggerRevisionHistoryRequestValidationError is the validation error +// returned by GetTriggerRevisionHistoryRequest.Validate if the designated +// constraints aren't met. +type GetTriggerRevisionHistoryRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetTriggerRevisionHistoryRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetTriggerRevisionHistoryRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetTriggerRevisionHistoryRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetTriggerRevisionHistoryRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetTriggerRevisionHistoryRequestValidationError) ErrorName() string { + return "GetTriggerRevisionHistoryRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e GetTriggerRevisionHistoryRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetTriggerRevisionHistoryRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetTriggerRevisionHistoryRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetTriggerRevisionHistoryRequestValidationError{} + +// Validate checks the field values on GetTriggerRevisionHistoryResponse with +// the rules defined in the proto definition for this message. If any rules +// are violated, the first error encountered is returned, or nil if there are +// no violations. +func (m *GetTriggerRevisionHistoryResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetTriggerRevisionHistoryResponse +// with the rules defined in the proto definition for this message. If any +// rules are violated, the result is a list of violation errors wrapped in +// GetTriggerRevisionHistoryResponseMultiError, or nil if none found. +func (m *GetTriggerRevisionHistoryResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetTriggerRevisionHistoryResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetTriggers() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetTriggerRevisionHistoryResponseValidationError{ + field: fmt.Sprintf("Triggers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetTriggerRevisionHistoryResponseValidationError{ + field: fmt.Sprintf("Triggers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetTriggerRevisionHistoryResponseValidationError{ + field: fmt.Sprintf("Triggers[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Token + + if len(errors) > 0 { + return GetTriggerRevisionHistoryResponseMultiError(errors) + } + + return nil +} + +// GetTriggerRevisionHistoryResponseMultiError is an error wrapping multiple +// validation errors returned by +// GetTriggerRevisionHistoryResponse.ValidateAll() if the designated +// constraints aren't met. +type GetTriggerRevisionHistoryResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetTriggerRevisionHistoryResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetTriggerRevisionHistoryResponseMultiError) AllErrors() []error { return m } + +// GetTriggerRevisionHistoryResponseValidationError is the validation error +// returned by GetTriggerRevisionHistoryResponse.Validate if the designated +// constraints aren't met. +type GetTriggerRevisionHistoryResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetTriggerRevisionHistoryResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetTriggerRevisionHistoryResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetTriggerRevisionHistoryResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetTriggerRevisionHistoryResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetTriggerRevisionHistoryResponseValidationError) ErrorName() string { + return "GetTriggerRevisionHistoryResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e GetTriggerRevisionHistoryResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetTriggerRevisionHistoryResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetTriggerRevisionHistoryResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetTriggerRevisionHistoryResponseValidationError{} + +// Validate checks the field values on UpdateTriggersRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *UpdateTriggersRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on UpdateTriggersRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// UpdateTriggersRequestMultiError, or nil if none found. +func (m *UpdateTriggersRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *UpdateTriggersRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetNames() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, UpdateTriggersRequestValidationError{ + field: fmt.Sprintf("Names[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, UpdateTriggersRequestValidationError{ + field: fmt.Sprintf("Names[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return UpdateTriggersRequestValidationError{ + field: fmt.Sprintf("Names[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Active + + if len(errors) > 0 { + return UpdateTriggersRequestMultiError(errors) + } + + return nil +} + +// UpdateTriggersRequestMultiError is an error wrapping multiple validation +// errors returned by UpdateTriggersRequest.ValidateAll() if the designated +// constraints aren't met. +type UpdateTriggersRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UpdateTriggersRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UpdateTriggersRequestMultiError) AllErrors() []error { return m } + +// UpdateTriggersRequestValidationError is the validation error returned by +// UpdateTriggersRequest.Validate if the designated constraints aren't met. +type UpdateTriggersRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UpdateTriggersRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UpdateTriggersRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UpdateTriggersRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UpdateTriggersRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UpdateTriggersRequestValidationError) ErrorName() string { + return "UpdateTriggersRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e UpdateTriggersRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUpdateTriggersRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UpdateTriggersRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UpdateTriggersRequestValidationError{} + +// Validate checks the field values on UpdateTriggersResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *UpdateTriggersResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on UpdateTriggersResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// UpdateTriggersResponseMultiError, or nil if none found. +func (m *UpdateTriggersResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *UpdateTriggersResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return UpdateTriggersResponseMultiError(errors) + } + + return nil +} + +// UpdateTriggersResponseMultiError is an error wrapping multiple validation +// errors returned by UpdateTriggersResponse.ValidateAll() if the designated +// constraints aren't met. +type UpdateTriggersResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m UpdateTriggersResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m UpdateTriggersResponseMultiError) AllErrors() []error { return m } + +// UpdateTriggersResponseValidationError is the validation error returned by +// UpdateTriggersResponse.Validate if the designated constraints aren't met. +type UpdateTriggersResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e UpdateTriggersResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e UpdateTriggersResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e UpdateTriggersResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e UpdateTriggersResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e UpdateTriggersResponseValidationError) ErrorName() string { + return "UpdateTriggersResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e UpdateTriggersResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sUpdateTriggersResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = UpdateTriggersResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = UpdateTriggersResponseValidationError{} + +// Validate checks the field values on DeleteTriggersRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *DeleteTriggersRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DeleteTriggersRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// DeleteTriggersRequestMultiError, or nil if none found. +func (m *DeleteTriggersRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *DeleteTriggersRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetNames() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, DeleteTriggersRequestValidationError{ + field: fmt.Sprintf("Names[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, DeleteTriggersRequestValidationError{ + field: fmt.Sprintf("Names[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return DeleteTriggersRequestValidationError{ + field: fmt.Sprintf("Names[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return DeleteTriggersRequestMultiError(errors) + } + + return nil +} + +// DeleteTriggersRequestMultiError is an error wrapping multiple validation +// errors returned by DeleteTriggersRequest.ValidateAll() if the designated +// constraints aren't met. +type DeleteTriggersRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DeleteTriggersRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DeleteTriggersRequestMultiError) AllErrors() []error { return m } + +// DeleteTriggersRequestValidationError is the validation error returned by +// DeleteTriggersRequest.Validate if the designated constraints aren't met. +type DeleteTriggersRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DeleteTriggersRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DeleteTriggersRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DeleteTriggersRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DeleteTriggersRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DeleteTriggersRequestValidationError) ErrorName() string { + return "DeleteTriggersRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e DeleteTriggersRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDeleteTriggersRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DeleteTriggersRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DeleteTriggersRequestValidationError{} + +// Validate checks the field values on DeleteTriggersResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *DeleteTriggersResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on DeleteTriggersResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// DeleteTriggersResponseMultiError, or nil if none found. +func (m *DeleteTriggersResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *DeleteTriggersResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return DeleteTriggersResponseMultiError(errors) + } + + return nil +} + +// DeleteTriggersResponseMultiError is an error wrapping multiple validation +// errors returned by DeleteTriggersResponse.ValidateAll() if the designated +// constraints aren't met. +type DeleteTriggersResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m DeleteTriggersResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m DeleteTriggersResponseMultiError) AllErrors() []error { return m } + +// DeleteTriggersResponseValidationError is the validation error returned by +// DeleteTriggersResponse.Validate if the designated constraints aren't met. +type DeleteTriggersResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e DeleteTriggersResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e DeleteTriggersResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e DeleteTriggersResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e DeleteTriggersResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e DeleteTriggersResponseValidationError) ErrorName() string { + return "DeleteTriggersResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e DeleteTriggersResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sDeleteTriggersResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = DeleteTriggersResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = DeleteTriggersResponseValidationError{} diff --git a/gen/go/flyteidl2/trigger/trigger_service_grpc.pb.go b/gen/go/flyteidl2/trigger/trigger_service_grpc.pb.go new file mode 100644 index 0000000000..343759dd32 --- /dev/null +++ b/gen/go/flyteidl2/trigger/trigger_service_grpc.pb.go @@ -0,0 +1,357 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: flyteidl2/trigger/trigger_service.proto + +package trigger + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + TriggerService_DeployTrigger_FullMethodName = "/flyteidl2.trigger.TriggerService/DeployTrigger" + TriggerService_GetTriggerDetails_FullMethodName = "/flyteidl2.trigger.TriggerService/GetTriggerDetails" + TriggerService_GetTriggerRevisionDetails_FullMethodName = "/flyteidl2.trigger.TriggerService/GetTriggerRevisionDetails" + TriggerService_ListTriggers_FullMethodName = "/flyteidl2.trigger.TriggerService/ListTriggers" + TriggerService_GetTriggerRevisionHistory_FullMethodName = "/flyteidl2.trigger.TriggerService/GetTriggerRevisionHistory" + TriggerService_UpdateTriggers_FullMethodName = "/flyteidl2.trigger.TriggerService/UpdateTriggers" + TriggerService_DeleteTriggers_FullMethodName = "/flyteidl2.trigger.TriggerService/DeleteTriggers" +) + +// TriggerServiceClient is the client API for TriggerService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type TriggerServiceClient interface { + // Create if trigger didn't exist previously. + // Update if it already exists. + // Re-create(or undelete) if it was soft-deleted. + // Client must fetch the latest trigger in order to obtain the latest `trigger.id.revision`. + // If trigger is not found, client can set `trigger.id.revision` to 1, it is ignored and set automatically by backend. + // If trigger is found, client should set `trigger.id.revision` to the . + // Backend validates that version is the latest and creates a new revision of the trigger. + // Otherwise, operation is rejected(optimistic locking) and client must re-fetch trigger again. + DeployTrigger(ctx context.Context, in *DeployTriggerRequest, opts ...grpc.CallOption) (*DeployTriggerResponse, error) + // Get detailed info about the latest trigger revision + GetTriggerDetails(ctx context.Context, in *GetTriggerDetailsRequest, opts ...grpc.CallOption) (*GetTriggerDetailsResponse, error) + // Get detailed info about a specific trigger revision + GetTriggerRevisionDetails(ctx context.Context, in *GetTriggerRevisionDetailsRequest, opts ...grpc.CallOption) (*GetTriggerRevisionDetailsResponse, error) + // List basic info about triggers based on various filtering and sorting rules. + ListTriggers(ctx context.Context, in *ListTriggersRequest, opts ...grpc.CallOption) (*ListTriggersResponse, error) + // GetTriggerRevisionHistory returns all revisions for a given trigger + GetTriggerRevisionHistory(ctx context.Context, in *GetTriggerRevisionHistoryRequest, opts ...grpc.CallOption) (*GetTriggerRevisionHistoryResponse, error) + // Update some trigger spec fields for multiple triggers at once + UpdateTriggers(ctx context.Context, in *UpdateTriggersRequest, opts ...grpc.CallOption) (*UpdateTriggersResponse, error) + // Soft-delete multiple triggers at once. + DeleteTriggers(ctx context.Context, in *DeleteTriggersRequest, opts ...grpc.CallOption) (*DeleteTriggersResponse, error) +} + +type triggerServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewTriggerServiceClient(cc grpc.ClientConnInterface) TriggerServiceClient { + return &triggerServiceClient{cc} +} + +func (c *triggerServiceClient) DeployTrigger(ctx context.Context, in *DeployTriggerRequest, opts ...grpc.CallOption) (*DeployTriggerResponse, error) { + out := new(DeployTriggerResponse) + err := c.cc.Invoke(ctx, TriggerService_DeployTrigger_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *triggerServiceClient) GetTriggerDetails(ctx context.Context, in *GetTriggerDetailsRequest, opts ...grpc.CallOption) (*GetTriggerDetailsResponse, error) { + out := new(GetTriggerDetailsResponse) + err := c.cc.Invoke(ctx, TriggerService_GetTriggerDetails_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *triggerServiceClient) GetTriggerRevisionDetails(ctx context.Context, in *GetTriggerRevisionDetailsRequest, opts ...grpc.CallOption) (*GetTriggerRevisionDetailsResponse, error) { + out := new(GetTriggerRevisionDetailsResponse) + err := c.cc.Invoke(ctx, TriggerService_GetTriggerRevisionDetails_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *triggerServiceClient) ListTriggers(ctx context.Context, in *ListTriggersRequest, opts ...grpc.CallOption) (*ListTriggersResponse, error) { + out := new(ListTriggersResponse) + err := c.cc.Invoke(ctx, TriggerService_ListTriggers_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *triggerServiceClient) GetTriggerRevisionHistory(ctx context.Context, in *GetTriggerRevisionHistoryRequest, opts ...grpc.CallOption) (*GetTriggerRevisionHistoryResponse, error) { + out := new(GetTriggerRevisionHistoryResponse) + err := c.cc.Invoke(ctx, TriggerService_GetTriggerRevisionHistory_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *triggerServiceClient) UpdateTriggers(ctx context.Context, in *UpdateTriggersRequest, opts ...grpc.CallOption) (*UpdateTriggersResponse, error) { + out := new(UpdateTriggersResponse) + err := c.cc.Invoke(ctx, TriggerService_UpdateTriggers_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *triggerServiceClient) DeleteTriggers(ctx context.Context, in *DeleteTriggersRequest, opts ...grpc.CallOption) (*DeleteTriggersResponse, error) { + out := new(DeleteTriggersResponse) + err := c.cc.Invoke(ctx, TriggerService_DeleteTriggers_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// TriggerServiceServer is the server API for TriggerService service. +// All implementations should embed UnimplementedTriggerServiceServer +// for forward compatibility +type TriggerServiceServer interface { + // Create if trigger didn't exist previously. + // Update if it already exists. + // Re-create(or undelete) if it was soft-deleted. + // Client must fetch the latest trigger in order to obtain the latest `trigger.id.revision`. + // If trigger is not found, client can set `trigger.id.revision` to 1, it is ignored and set automatically by backend. + // If trigger is found, client should set `trigger.id.revision` to the . + // Backend validates that version is the latest and creates a new revision of the trigger. + // Otherwise, operation is rejected(optimistic locking) and client must re-fetch trigger again. + DeployTrigger(context.Context, *DeployTriggerRequest) (*DeployTriggerResponse, error) + // Get detailed info about the latest trigger revision + GetTriggerDetails(context.Context, *GetTriggerDetailsRequest) (*GetTriggerDetailsResponse, error) + // Get detailed info about a specific trigger revision + GetTriggerRevisionDetails(context.Context, *GetTriggerRevisionDetailsRequest) (*GetTriggerRevisionDetailsResponse, error) + // List basic info about triggers based on various filtering and sorting rules. + ListTriggers(context.Context, *ListTriggersRequest) (*ListTriggersResponse, error) + // GetTriggerRevisionHistory returns all revisions for a given trigger + GetTriggerRevisionHistory(context.Context, *GetTriggerRevisionHistoryRequest) (*GetTriggerRevisionHistoryResponse, error) + // Update some trigger spec fields for multiple triggers at once + UpdateTriggers(context.Context, *UpdateTriggersRequest) (*UpdateTriggersResponse, error) + // Soft-delete multiple triggers at once. + DeleteTriggers(context.Context, *DeleteTriggersRequest) (*DeleteTriggersResponse, error) +} + +// UnimplementedTriggerServiceServer should be embedded to have forward compatible implementations. +type UnimplementedTriggerServiceServer struct { +} + +func (UnimplementedTriggerServiceServer) DeployTrigger(context.Context, *DeployTriggerRequest) (*DeployTriggerResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeployTrigger not implemented") +} +func (UnimplementedTriggerServiceServer) GetTriggerDetails(context.Context, *GetTriggerDetailsRequest) (*GetTriggerDetailsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetTriggerDetails not implemented") +} +func (UnimplementedTriggerServiceServer) GetTriggerRevisionDetails(context.Context, *GetTriggerRevisionDetailsRequest) (*GetTriggerRevisionDetailsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetTriggerRevisionDetails not implemented") +} +func (UnimplementedTriggerServiceServer) ListTriggers(context.Context, *ListTriggersRequest) (*ListTriggersResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ListTriggers not implemented") +} +func (UnimplementedTriggerServiceServer) GetTriggerRevisionHistory(context.Context, *GetTriggerRevisionHistoryRequest) (*GetTriggerRevisionHistoryResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetTriggerRevisionHistory not implemented") +} +func (UnimplementedTriggerServiceServer) UpdateTriggers(context.Context, *UpdateTriggersRequest) (*UpdateTriggersResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateTriggers not implemented") +} +func (UnimplementedTriggerServiceServer) DeleteTriggers(context.Context, *DeleteTriggersRequest) (*DeleteTriggersResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeleteTriggers not implemented") +} + +// UnsafeTriggerServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to TriggerServiceServer will +// result in compilation errors. +type UnsafeTriggerServiceServer interface { + mustEmbedUnimplementedTriggerServiceServer() +} + +func RegisterTriggerServiceServer(s grpc.ServiceRegistrar, srv TriggerServiceServer) { + s.RegisterService(&TriggerService_ServiceDesc, srv) +} + +func _TriggerService_DeployTrigger_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeployTriggerRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TriggerServiceServer).DeployTrigger(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: TriggerService_DeployTrigger_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TriggerServiceServer).DeployTrigger(ctx, req.(*DeployTriggerRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _TriggerService_GetTriggerDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetTriggerDetailsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TriggerServiceServer).GetTriggerDetails(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: TriggerService_GetTriggerDetails_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TriggerServiceServer).GetTriggerDetails(ctx, req.(*GetTriggerDetailsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _TriggerService_GetTriggerRevisionDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetTriggerRevisionDetailsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TriggerServiceServer).GetTriggerRevisionDetails(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: TriggerService_GetTriggerRevisionDetails_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TriggerServiceServer).GetTriggerRevisionDetails(ctx, req.(*GetTriggerRevisionDetailsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _TriggerService_ListTriggers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListTriggersRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TriggerServiceServer).ListTriggers(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: TriggerService_ListTriggers_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TriggerServiceServer).ListTriggers(ctx, req.(*ListTriggersRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _TriggerService_GetTriggerRevisionHistory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetTriggerRevisionHistoryRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TriggerServiceServer).GetTriggerRevisionHistory(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: TriggerService_GetTriggerRevisionHistory_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TriggerServiceServer).GetTriggerRevisionHistory(ctx, req.(*GetTriggerRevisionHistoryRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _TriggerService_UpdateTriggers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateTriggersRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TriggerServiceServer).UpdateTriggers(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: TriggerService_UpdateTriggers_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TriggerServiceServer).UpdateTriggers(ctx, req.(*UpdateTriggersRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _TriggerService_DeleteTriggers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteTriggersRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TriggerServiceServer).DeleteTriggers(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: TriggerService_DeleteTriggers_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TriggerServiceServer).DeleteTriggers(ctx, req.(*DeleteTriggersRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// TriggerService_ServiceDesc is the grpc.ServiceDesc for TriggerService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var TriggerService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.trigger.TriggerService", + HandlerType: (*TriggerServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "DeployTrigger", + Handler: _TriggerService_DeployTrigger_Handler, + }, + { + MethodName: "GetTriggerDetails", + Handler: _TriggerService_GetTriggerDetails_Handler, + }, + { + MethodName: "GetTriggerRevisionDetails", + Handler: _TriggerService_GetTriggerRevisionDetails_Handler, + }, + { + MethodName: "ListTriggers", + Handler: _TriggerService_ListTriggers_Handler, + }, + { + MethodName: "GetTriggerRevisionHistory", + Handler: _TriggerService_GetTriggerRevisionHistory_Handler, + }, + { + MethodName: "UpdateTriggers", + Handler: _TriggerService_UpdateTriggers_Handler, + }, + { + MethodName: "DeleteTriggers", + Handler: _TriggerService_DeleteTriggers_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "flyteidl2/trigger/trigger_service.proto", +} diff --git a/gen/go/flyteidl2/trigger/triggerconnect/trigger_service.connect.go b/gen/go/flyteidl2/trigger/triggerconnect/trigger_service.connect.go new file mode 100644 index 0000000000..98c78615e8 --- /dev/null +++ b/gen/go/flyteidl2/trigger/triggerconnect/trigger_service.connect.go @@ -0,0 +1,329 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: flyteidl2/trigger/trigger_service.proto + +package triggerconnect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + trigger "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/trigger" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // TriggerServiceName is the fully-qualified name of the TriggerService service. + TriggerServiceName = "flyteidl2.trigger.TriggerService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // TriggerServiceDeployTriggerProcedure is the fully-qualified name of the TriggerService's + // DeployTrigger RPC. + TriggerServiceDeployTriggerProcedure = "/flyteidl2.trigger.TriggerService/DeployTrigger" + // TriggerServiceGetTriggerDetailsProcedure is the fully-qualified name of the TriggerService's + // GetTriggerDetails RPC. + TriggerServiceGetTriggerDetailsProcedure = "/flyteidl2.trigger.TriggerService/GetTriggerDetails" + // TriggerServiceGetTriggerRevisionDetailsProcedure is the fully-qualified name of the + // TriggerService's GetTriggerRevisionDetails RPC. + TriggerServiceGetTriggerRevisionDetailsProcedure = "/flyteidl2.trigger.TriggerService/GetTriggerRevisionDetails" + // TriggerServiceListTriggersProcedure is the fully-qualified name of the TriggerService's + // ListTriggers RPC. + TriggerServiceListTriggersProcedure = "/flyteidl2.trigger.TriggerService/ListTriggers" + // TriggerServiceGetTriggerRevisionHistoryProcedure is the fully-qualified name of the + // TriggerService's GetTriggerRevisionHistory RPC. + TriggerServiceGetTriggerRevisionHistoryProcedure = "/flyteidl2.trigger.TriggerService/GetTriggerRevisionHistory" + // TriggerServiceUpdateTriggersProcedure is the fully-qualified name of the TriggerService's + // UpdateTriggers RPC. + TriggerServiceUpdateTriggersProcedure = "/flyteidl2.trigger.TriggerService/UpdateTriggers" + // TriggerServiceDeleteTriggersProcedure is the fully-qualified name of the TriggerService's + // DeleteTriggers RPC. + TriggerServiceDeleteTriggersProcedure = "/flyteidl2.trigger.TriggerService/DeleteTriggers" +) + +// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. +var ( + triggerServiceServiceDescriptor = trigger.File_flyteidl2_trigger_trigger_service_proto.Services().ByName("TriggerService") + triggerServiceDeployTriggerMethodDescriptor = triggerServiceServiceDescriptor.Methods().ByName("DeployTrigger") + triggerServiceGetTriggerDetailsMethodDescriptor = triggerServiceServiceDescriptor.Methods().ByName("GetTriggerDetails") + triggerServiceGetTriggerRevisionDetailsMethodDescriptor = triggerServiceServiceDescriptor.Methods().ByName("GetTriggerRevisionDetails") + triggerServiceListTriggersMethodDescriptor = triggerServiceServiceDescriptor.Methods().ByName("ListTriggers") + triggerServiceGetTriggerRevisionHistoryMethodDescriptor = triggerServiceServiceDescriptor.Methods().ByName("GetTriggerRevisionHistory") + triggerServiceUpdateTriggersMethodDescriptor = triggerServiceServiceDescriptor.Methods().ByName("UpdateTriggers") + triggerServiceDeleteTriggersMethodDescriptor = triggerServiceServiceDescriptor.Methods().ByName("DeleteTriggers") +) + +// TriggerServiceClient is a client for the flyteidl2.trigger.TriggerService service. +type TriggerServiceClient interface { + // Create if trigger didn't exist previously. + // Update if it already exists. + // Re-create(or undelete) if it was soft-deleted. + // Client must fetch the latest trigger in order to obtain the latest `trigger.id.revision`. + // If trigger is not found, client can set `trigger.id.revision` to 1, it is ignored and set automatically by backend. + // If trigger is found, client should set `trigger.id.revision` to the . + // Backend validates that version is the latest and creates a new revision of the trigger. + // Otherwise, operation is rejected(optimistic locking) and client must re-fetch trigger again. + DeployTrigger(context.Context, *connect.Request[trigger.DeployTriggerRequest]) (*connect.Response[trigger.DeployTriggerResponse], error) + // Get detailed info about the latest trigger revision + GetTriggerDetails(context.Context, *connect.Request[trigger.GetTriggerDetailsRequest]) (*connect.Response[trigger.GetTriggerDetailsResponse], error) + // Get detailed info about a specific trigger revision + GetTriggerRevisionDetails(context.Context, *connect.Request[trigger.GetTriggerRevisionDetailsRequest]) (*connect.Response[trigger.GetTriggerRevisionDetailsResponse], error) + // List basic info about triggers based on various filtering and sorting rules. + ListTriggers(context.Context, *connect.Request[trigger.ListTriggersRequest]) (*connect.Response[trigger.ListTriggersResponse], error) + // GetTriggerRevisionHistory returns all revisions for a given trigger + GetTriggerRevisionHistory(context.Context, *connect.Request[trigger.GetTriggerRevisionHistoryRequest]) (*connect.Response[trigger.GetTriggerRevisionHistoryResponse], error) + // Update some trigger spec fields for multiple triggers at once + UpdateTriggers(context.Context, *connect.Request[trigger.UpdateTriggersRequest]) (*connect.Response[trigger.UpdateTriggersResponse], error) + // Soft-delete multiple triggers at once. + DeleteTriggers(context.Context, *connect.Request[trigger.DeleteTriggersRequest]) (*connect.Response[trigger.DeleteTriggersResponse], error) +} + +// NewTriggerServiceClient constructs a client for the flyteidl2.trigger.TriggerService service. By +// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, +// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the +// connect.WithGRPC() or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewTriggerServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) TriggerServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &triggerServiceClient{ + deployTrigger: connect.NewClient[trigger.DeployTriggerRequest, trigger.DeployTriggerResponse]( + httpClient, + baseURL+TriggerServiceDeployTriggerProcedure, + connect.WithSchema(triggerServiceDeployTriggerMethodDescriptor), + connect.WithClientOptions(opts...), + ), + getTriggerDetails: connect.NewClient[trigger.GetTriggerDetailsRequest, trigger.GetTriggerDetailsResponse]( + httpClient, + baseURL+TriggerServiceGetTriggerDetailsProcedure, + connect.WithSchema(triggerServiceGetTriggerDetailsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + getTriggerRevisionDetails: connect.NewClient[trigger.GetTriggerRevisionDetailsRequest, trigger.GetTriggerRevisionDetailsResponse]( + httpClient, + baseURL+TriggerServiceGetTriggerRevisionDetailsProcedure, + connect.WithSchema(triggerServiceGetTriggerRevisionDetailsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + listTriggers: connect.NewClient[trigger.ListTriggersRequest, trigger.ListTriggersResponse]( + httpClient, + baseURL+TriggerServiceListTriggersProcedure, + connect.WithSchema(triggerServiceListTriggersMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + getTriggerRevisionHistory: connect.NewClient[trigger.GetTriggerRevisionHistoryRequest, trigger.GetTriggerRevisionHistoryResponse]( + httpClient, + baseURL+TriggerServiceGetTriggerRevisionHistoryProcedure, + connect.WithSchema(triggerServiceGetTriggerRevisionHistoryMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + updateTriggers: connect.NewClient[trigger.UpdateTriggersRequest, trigger.UpdateTriggersResponse]( + httpClient, + baseURL+TriggerServiceUpdateTriggersProcedure, + connect.WithSchema(triggerServiceUpdateTriggersMethodDescriptor), + connect.WithClientOptions(opts...), + ), + deleteTriggers: connect.NewClient[trigger.DeleteTriggersRequest, trigger.DeleteTriggersResponse]( + httpClient, + baseURL+TriggerServiceDeleteTriggersProcedure, + connect.WithSchema(triggerServiceDeleteTriggersMethodDescriptor), + connect.WithClientOptions(opts...), + ), + } +} + +// triggerServiceClient implements TriggerServiceClient. +type triggerServiceClient struct { + deployTrigger *connect.Client[trigger.DeployTriggerRequest, trigger.DeployTriggerResponse] + getTriggerDetails *connect.Client[trigger.GetTriggerDetailsRequest, trigger.GetTriggerDetailsResponse] + getTriggerRevisionDetails *connect.Client[trigger.GetTriggerRevisionDetailsRequest, trigger.GetTriggerRevisionDetailsResponse] + listTriggers *connect.Client[trigger.ListTriggersRequest, trigger.ListTriggersResponse] + getTriggerRevisionHistory *connect.Client[trigger.GetTriggerRevisionHistoryRequest, trigger.GetTriggerRevisionHistoryResponse] + updateTriggers *connect.Client[trigger.UpdateTriggersRequest, trigger.UpdateTriggersResponse] + deleteTriggers *connect.Client[trigger.DeleteTriggersRequest, trigger.DeleteTriggersResponse] +} + +// DeployTrigger calls flyteidl2.trigger.TriggerService.DeployTrigger. +func (c *triggerServiceClient) DeployTrigger(ctx context.Context, req *connect.Request[trigger.DeployTriggerRequest]) (*connect.Response[trigger.DeployTriggerResponse], error) { + return c.deployTrigger.CallUnary(ctx, req) +} + +// GetTriggerDetails calls flyteidl2.trigger.TriggerService.GetTriggerDetails. +func (c *triggerServiceClient) GetTriggerDetails(ctx context.Context, req *connect.Request[trigger.GetTriggerDetailsRequest]) (*connect.Response[trigger.GetTriggerDetailsResponse], error) { + return c.getTriggerDetails.CallUnary(ctx, req) +} + +// GetTriggerRevisionDetails calls flyteidl2.trigger.TriggerService.GetTriggerRevisionDetails. +func (c *triggerServiceClient) GetTriggerRevisionDetails(ctx context.Context, req *connect.Request[trigger.GetTriggerRevisionDetailsRequest]) (*connect.Response[trigger.GetTriggerRevisionDetailsResponse], error) { + return c.getTriggerRevisionDetails.CallUnary(ctx, req) +} + +// ListTriggers calls flyteidl2.trigger.TriggerService.ListTriggers. +func (c *triggerServiceClient) ListTriggers(ctx context.Context, req *connect.Request[trigger.ListTriggersRequest]) (*connect.Response[trigger.ListTriggersResponse], error) { + return c.listTriggers.CallUnary(ctx, req) +} + +// GetTriggerRevisionHistory calls flyteidl2.trigger.TriggerService.GetTriggerRevisionHistory. +func (c *triggerServiceClient) GetTriggerRevisionHistory(ctx context.Context, req *connect.Request[trigger.GetTriggerRevisionHistoryRequest]) (*connect.Response[trigger.GetTriggerRevisionHistoryResponse], error) { + return c.getTriggerRevisionHistory.CallUnary(ctx, req) +} + +// UpdateTriggers calls flyteidl2.trigger.TriggerService.UpdateTriggers. +func (c *triggerServiceClient) UpdateTriggers(ctx context.Context, req *connect.Request[trigger.UpdateTriggersRequest]) (*connect.Response[trigger.UpdateTriggersResponse], error) { + return c.updateTriggers.CallUnary(ctx, req) +} + +// DeleteTriggers calls flyteidl2.trigger.TriggerService.DeleteTriggers. +func (c *triggerServiceClient) DeleteTriggers(ctx context.Context, req *connect.Request[trigger.DeleteTriggersRequest]) (*connect.Response[trigger.DeleteTriggersResponse], error) { + return c.deleteTriggers.CallUnary(ctx, req) +} + +// TriggerServiceHandler is an implementation of the flyteidl2.trigger.TriggerService service. +type TriggerServiceHandler interface { + // Create if trigger didn't exist previously. + // Update if it already exists. + // Re-create(or undelete) if it was soft-deleted. + // Client must fetch the latest trigger in order to obtain the latest `trigger.id.revision`. + // If trigger is not found, client can set `trigger.id.revision` to 1, it is ignored and set automatically by backend. + // If trigger is found, client should set `trigger.id.revision` to the . + // Backend validates that version is the latest and creates a new revision of the trigger. + // Otherwise, operation is rejected(optimistic locking) and client must re-fetch trigger again. + DeployTrigger(context.Context, *connect.Request[trigger.DeployTriggerRequest]) (*connect.Response[trigger.DeployTriggerResponse], error) + // Get detailed info about the latest trigger revision + GetTriggerDetails(context.Context, *connect.Request[trigger.GetTriggerDetailsRequest]) (*connect.Response[trigger.GetTriggerDetailsResponse], error) + // Get detailed info about a specific trigger revision + GetTriggerRevisionDetails(context.Context, *connect.Request[trigger.GetTriggerRevisionDetailsRequest]) (*connect.Response[trigger.GetTriggerRevisionDetailsResponse], error) + // List basic info about triggers based on various filtering and sorting rules. + ListTriggers(context.Context, *connect.Request[trigger.ListTriggersRequest]) (*connect.Response[trigger.ListTriggersResponse], error) + // GetTriggerRevisionHistory returns all revisions for a given trigger + GetTriggerRevisionHistory(context.Context, *connect.Request[trigger.GetTriggerRevisionHistoryRequest]) (*connect.Response[trigger.GetTriggerRevisionHistoryResponse], error) + // Update some trigger spec fields for multiple triggers at once + UpdateTriggers(context.Context, *connect.Request[trigger.UpdateTriggersRequest]) (*connect.Response[trigger.UpdateTriggersResponse], error) + // Soft-delete multiple triggers at once. + DeleteTriggers(context.Context, *connect.Request[trigger.DeleteTriggersRequest]) (*connect.Response[trigger.DeleteTriggersResponse], error) +} + +// NewTriggerServiceHandler builds an HTTP handler from the service implementation. It returns the +// path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewTriggerServiceHandler(svc TriggerServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + triggerServiceDeployTriggerHandler := connect.NewUnaryHandler( + TriggerServiceDeployTriggerProcedure, + svc.DeployTrigger, + connect.WithSchema(triggerServiceDeployTriggerMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + triggerServiceGetTriggerDetailsHandler := connect.NewUnaryHandler( + TriggerServiceGetTriggerDetailsProcedure, + svc.GetTriggerDetails, + connect.WithSchema(triggerServiceGetTriggerDetailsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + triggerServiceGetTriggerRevisionDetailsHandler := connect.NewUnaryHandler( + TriggerServiceGetTriggerRevisionDetailsProcedure, + svc.GetTriggerRevisionDetails, + connect.WithSchema(triggerServiceGetTriggerRevisionDetailsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + triggerServiceListTriggersHandler := connect.NewUnaryHandler( + TriggerServiceListTriggersProcedure, + svc.ListTriggers, + connect.WithSchema(triggerServiceListTriggersMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + triggerServiceGetTriggerRevisionHistoryHandler := connect.NewUnaryHandler( + TriggerServiceGetTriggerRevisionHistoryProcedure, + svc.GetTriggerRevisionHistory, + connect.WithSchema(triggerServiceGetTriggerRevisionHistoryMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + triggerServiceUpdateTriggersHandler := connect.NewUnaryHandler( + TriggerServiceUpdateTriggersProcedure, + svc.UpdateTriggers, + connect.WithSchema(triggerServiceUpdateTriggersMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + triggerServiceDeleteTriggersHandler := connect.NewUnaryHandler( + TriggerServiceDeleteTriggersProcedure, + svc.DeleteTriggers, + connect.WithSchema(triggerServiceDeleteTriggersMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.trigger.TriggerService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case TriggerServiceDeployTriggerProcedure: + triggerServiceDeployTriggerHandler.ServeHTTP(w, r) + case TriggerServiceGetTriggerDetailsProcedure: + triggerServiceGetTriggerDetailsHandler.ServeHTTP(w, r) + case TriggerServiceGetTriggerRevisionDetailsProcedure: + triggerServiceGetTriggerRevisionDetailsHandler.ServeHTTP(w, r) + case TriggerServiceListTriggersProcedure: + triggerServiceListTriggersHandler.ServeHTTP(w, r) + case TriggerServiceGetTriggerRevisionHistoryProcedure: + triggerServiceGetTriggerRevisionHistoryHandler.ServeHTTP(w, r) + case TriggerServiceUpdateTriggersProcedure: + triggerServiceUpdateTriggersHandler.ServeHTTP(w, r) + case TriggerServiceDeleteTriggersProcedure: + triggerServiceDeleteTriggersHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedTriggerServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedTriggerServiceHandler struct{} + +func (UnimplementedTriggerServiceHandler) DeployTrigger(context.Context, *connect.Request[trigger.DeployTriggerRequest]) (*connect.Response[trigger.DeployTriggerResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.trigger.TriggerService.DeployTrigger is not implemented")) +} + +func (UnimplementedTriggerServiceHandler) GetTriggerDetails(context.Context, *connect.Request[trigger.GetTriggerDetailsRequest]) (*connect.Response[trigger.GetTriggerDetailsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.trigger.TriggerService.GetTriggerDetails is not implemented")) +} + +func (UnimplementedTriggerServiceHandler) GetTriggerRevisionDetails(context.Context, *connect.Request[trigger.GetTriggerRevisionDetailsRequest]) (*connect.Response[trigger.GetTriggerRevisionDetailsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.trigger.TriggerService.GetTriggerRevisionDetails is not implemented")) +} + +func (UnimplementedTriggerServiceHandler) ListTriggers(context.Context, *connect.Request[trigger.ListTriggersRequest]) (*connect.Response[trigger.ListTriggersResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.trigger.TriggerService.ListTriggers is not implemented")) +} + +func (UnimplementedTriggerServiceHandler) GetTriggerRevisionHistory(context.Context, *connect.Request[trigger.GetTriggerRevisionHistoryRequest]) (*connect.Response[trigger.GetTriggerRevisionHistoryResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.trigger.TriggerService.GetTriggerRevisionHistory is not implemented")) +} + +func (UnimplementedTriggerServiceHandler) UpdateTriggers(context.Context, *connect.Request[trigger.UpdateTriggersRequest]) (*connect.Response[trigger.UpdateTriggersResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.trigger.TriggerService.UpdateTriggers is not implemented")) +} + +func (UnimplementedTriggerServiceHandler) DeleteTriggers(context.Context, *connect.Request[trigger.DeleteTriggersRequest]) (*connect.Response[trigger.DeleteTriggersResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.trigger.TriggerService.DeleteTriggers is not implemented")) +} diff --git a/gen/go/flyteidl2/workflow/mocks/is_action_details_result.go b/gen/go/flyteidl2/workflow/mocks/is_action_details_result.go new file mode 100644 index 0000000000..29425c17c0 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/is_action_details_result.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isActionDetails_Result is an autogenerated mock type for the isActionDetails_Result type +type isActionDetails_Result struct { + mock.Mock +} + +type isActionDetails_Result_Expecter struct { + mock *mock.Mock +} + +func (_m *isActionDetails_Result) EXPECT() *isActionDetails_Result_Expecter { + return &isActionDetails_Result_Expecter{mock: &_m.Mock} +} + +// isActionDetails_Result provides a mock function with no fields +func (_m *isActionDetails_Result) isActionDetails_Result() { + _m.Called() +} + +// isActionDetails_Result_isActionDetails_Result_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isActionDetails_Result' +type isActionDetails_Result_isActionDetails_Result_Call struct { + *mock.Call +} + +// isActionDetails_Result is a helper method to define mock.On call +func (_e *isActionDetails_Result_Expecter) isActionDetails_Result() *isActionDetails_Result_isActionDetails_Result_Call { + return &isActionDetails_Result_isActionDetails_Result_Call{Call: _e.mock.On("isActionDetails_Result")} +} + +func (_c *isActionDetails_Result_isActionDetails_Result_Call) Run(run func()) *isActionDetails_Result_isActionDetails_Result_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isActionDetails_Result_isActionDetails_Result_Call) Return() *isActionDetails_Result_isActionDetails_Result_Call { + _c.Call.Return() + return _c +} + +func (_c *isActionDetails_Result_isActionDetails_Result_Call) RunAndReturn(run func()) *isActionDetails_Result_isActionDetails_Result_Call { + _c.Run(run) + return _c +} + +// newIsActionDetails_Result creates a new instance of isActionDetails_Result. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsActionDetails_Result(t interface { + mock.TestingT + Cleanup(func()) +}) *isActionDetails_Result { + mock := &isActionDetails_Result{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/is_action_details_spec.go b/gen/go/flyteidl2/workflow/mocks/is_action_details_spec.go new file mode 100644 index 0000000000..ff2062813a --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/is_action_details_spec.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isActionDetails_Spec is an autogenerated mock type for the isActionDetails_Spec type +type isActionDetails_Spec struct { + mock.Mock +} + +type isActionDetails_Spec_Expecter struct { + mock *mock.Mock +} + +func (_m *isActionDetails_Spec) EXPECT() *isActionDetails_Spec_Expecter { + return &isActionDetails_Spec_Expecter{mock: &_m.Mock} +} + +// isActionDetails_Spec provides a mock function with no fields +func (_m *isActionDetails_Spec) isActionDetails_Spec() { + _m.Called() +} + +// isActionDetails_Spec_isActionDetails_Spec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isActionDetails_Spec' +type isActionDetails_Spec_isActionDetails_Spec_Call struct { + *mock.Call +} + +// isActionDetails_Spec is a helper method to define mock.On call +func (_e *isActionDetails_Spec_Expecter) isActionDetails_Spec() *isActionDetails_Spec_isActionDetails_Spec_Call { + return &isActionDetails_Spec_isActionDetails_Spec_Call{Call: _e.mock.On("isActionDetails_Spec")} +} + +func (_c *isActionDetails_Spec_isActionDetails_Spec_Call) Run(run func()) *isActionDetails_Spec_isActionDetails_Spec_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isActionDetails_Spec_isActionDetails_Spec_Call) Return() *isActionDetails_Spec_isActionDetails_Spec_Call { + _c.Call.Return() + return _c +} + +func (_c *isActionDetails_Spec_isActionDetails_Spec_Call) RunAndReturn(run func()) *isActionDetails_Spec_isActionDetails_Spec_Call { + _c.Run(run) + return _c +} + +// newIsActionDetails_Spec creates a new instance of isActionDetails_Spec. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsActionDetails_Spec(t interface { + mock.TestingT + Cleanup(func()) +}) *isActionDetails_Spec { + mock := &isActionDetails_Spec{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/is_action_metadata_spec.go b/gen/go/flyteidl2/workflow/mocks/is_action_metadata_spec.go new file mode 100644 index 0000000000..5328cba9db --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/is_action_metadata_spec.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isActionMetadata_Spec is an autogenerated mock type for the isActionMetadata_Spec type +type isActionMetadata_Spec struct { + mock.Mock +} + +type isActionMetadata_Spec_Expecter struct { + mock *mock.Mock +} + +func (_m *isActionMetadata_Spec) EXPECT() *isActionMetadata_Spec_Expecter { + return &isActionMetadata_Spec_Expecter{mock: &_m.Mock} +} + +// isActionMetadata_Spec provides a mock function with no fields +func (_m *isActionMetadata_Spec) isActionMetadata_Spec() { + _m.Called() +} + +// isActionMetadata_Spec_isActionMetadata_Spec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isActionMetadata_Spec' +type isActionMetadata_Spec_isActionMetadata_Spec_Call struct { + *mock.Call +} + +// isActionMetadata_Spec is a helper method to define mock.On call +func (_e *isActionMetadata_Spec_Expecter) isActionMetadata_Spec() *isActionMetadata_Spec_isActionMetadata_Spec_Call { + return &isActionMetadata_Spec_isActionMetadata_Spec_Call{Call: _e.mock.On("isActionMetadata_Spec")} +} + +func (_c *isActionMetadata_Spec_isActionMetadata_Spec_Call) Run(run func()) *isActionMetadata_Spec_isActionMetadata_Spec_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isActionMetadata_Spec_isActionMetadata_Spec_Call) Return() *isActionMetadata_Spec_isActionMetadata_Spec_Call { + _c.Call.Return() + return _c +} + +func (_c *isActionMetadata_Spec_isActionMetadata_Spec_Call) RunAndReturn(run func()) *isActionMetadata_Spec_isActionMetadata_Spec_Call { + _c.Run(run) + return _c +} + +// newIsActionMetadata_Spec creates a new instance of isActionMetadata_Spec. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsActionMetadata_Spec(t interface { + mock.TestingT + Cleanup(func()) +}) *isActionMetadata_Spec { + mock := &isActionMetadata_Spec{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/is_action_spec_spec.go b/gen/go/flyteidl2/workflow/mocks/is_action_spec_spec.go new file mode 100644 index 0000000000..9586899972 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/is_action_spec_spec.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isActionSpec_Spec is an autogenerated mock type for the isActionSpec_Spec type +type isActionSpec_Spec struct { + mock.Mock +} + +type isActionSpec_Spec_Expecter struct { + mock *mock.Mock +} + +func (_m *isActionSpec_Spec) EXPECT() *isActionSpec_Spec_Expecter { + return &isActionSpec_Spec_Expecter{mock: &_m.Mock} +} + +// isActionSpec_Spec provides a mock function with no fields +func (_m *isActionSpec_Spec) isActionSpec_Spec() { + _m.Called() +} + +// isActionSpec_Spec_isActionSpec_Spec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isActionSpec_Spec' +type isActionSpec_Spec_isActionSpec_Spec_Call struct { + *mock.Call +} + +// isActionSpec_Spec is a helper method to define mock.On call +func (_e *isActionSpec_Spec_Expecter) isActionSpec_Spec() *isActionSpec_Spec_isActionSpec_Spec_Call { + return &isActionSpec_Spec_isActionSpec_Spec_Call{Call: _e.mock.On("isActionSpec_Spec")} +} + +func (_c *isActionSpec_Spec_isActionSpec_Spec_Call) Run(run func()) *isActionSpec_Spec_isActionSpec_Spec_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isActionSpec_Spec_isActionSpec_Spec_Call) Return() *isActionSpec_Spec_isActionSpec_Spec_Call { + _c.Call.Return() + return _c +} + +func (_c *isActionSpec_Spec_isActionSpec_Spec_Call) RunAndReturn(run func()) *isActionSpec_Spec_isActionSpec_Spec_Call { + _c.Run(run) + return _c +} + +// newIsActionSpec_Spec creates a new instance of isActionSpec_Spec. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsActionSpec_Spec(t interface { + mock.TestingT + Cleanup(func()) +}) *isActionSpec_Spec { + mock := &isActionSpec_Spec{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/is_condition_action_metadata_scope.go b/gen/go/flyteidl2/workflow/mocks/is_condition_action_metadata_scope.go new file mode 100644 index 0000000000..cca09e145e --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/is_condition_action_metadata_scope.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isConditionActionMetadata_Scope is an autogenerated mock type for the isConditionActionMetadata_Scope type +type isConditionActionMetadata_Scope struct { + mock.Mock +} + +type isConditionActionMetadata_Scope_Expecter struct { + mock *mock.Mock +} + +func (_m *isConditionActionMetadata_Scope) EXPECT() *isConditionActionMetadata_Scope_Expecter { + return &isConditionActionMetadata_Scope_Expecter{mock: &_m.Mock} +} + +// isConditionActionMetadata_Scope provides a mock function with no fields +func (_m *isConditionActionMetadata_Scope) isConditionActionMetadata_Scope() { + _m.Called() +} + +// isConditionActionMetadata_Scope_isConditionActionMetadata_Scope_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isConditionActionMetadata_Scope' +type isConditionActionMetadata_Scope_isConditionActionMetadata_Scope_Call struct { + *mock.Call +} + +// isConditionActionMetadata_Scope is a helper method to define mock.On call +func (_e *isConditionActionMetadata_Scope_Expecter) isConditionActionMetadata_Scope() *isConditionActionMetadata_Scope_isConditionActionMetadata_Scope_Call { + return &isConditionActionMetadata_Scope_isConditionActionMetadata_Scope_Call{Call: _e.mock.On("isConditionActionMetadata_Scope")} +} + +func (_c *isConditionActionMetadata_Scope_isConditionActionMetadata_Scope_Call) Run(run func()) *isConditionActionMetadata_Scope_isConditionActionMetadata_Scope_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isConditionActionMetadata_Scope_isConditionActionMetadata_Scope_Call) Return() *isConditionActionMetadata_Scope_isConditionActionMetadata_Scope_Call { + _c.Call.Return() + return _c +} + +func (_c *isConditionActionMetadata_Scope_isConditionActionMetadata_Scope_Call) RunAndReturn(run func()) *isConditionActionMetadata_Scope_isConditionActionMetadata_Scope_Call { + _c.Run(run) + return _c +} + +// newIsConditionActionMetadata_Scope creates a new instance of isConditionActionMetadata_Scope. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsConditionActionMetadata_Scope(t interface { + mock.TestingT + Cleanup(func()) +}) *isConditionActionMetadata_Scope { + mock := &isConditionActionMetadata_Scope{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/is_condition_action_scope.go b/gen/go/flyteidl2/workflow/mocks/is_condition_action_scope.go new file mode 100644 index 0000000000..51b7c28fc0 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/is_condition_action_scope.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isConditionAction_Scope is an autogenerated mock type for the isConditionAction_Scope type +type isConditionAction_Scope struct { + mock.Mock +} + +type isConditionAction_Scope_Expecter struct { + mock *mock.Mock +} + +func (_m *isConditionAction_Scope) EXPECT() *isConditionAction_Scope_Expecter { + return &isConditionAction_Scope_Expecter{mock: &_m.Mock} +} + +// isConditionAction_Scope provides a mock function with no fields +func (_m *isConditionAction_Scope) isConditionAction_Scope() { + _m.Called() +} + +// isConditionAction_Scope_isConditionAction_Scope_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isConditionAction_Scope' +type isConditionAction_Scope_isConditionAction_Scope_Call struct { + *mock.Call +} + +// isConditionAction_Scope is a helper method to define mock.On call +func (_e *isConditionAction_Scope_Expecter) isConditionAction_Scope() *isConditionAction_Scope_isConditionAction_Scope_Call { + return &isConditionAction_Scope_isConditionAction_Scope_Call{Call: _e.mock.On("isConditionAction_Scope")} +} + +func (_c *isConditionAction_Scope_isConditionAction_Scope_Call) Run(run func()) *isConditionAction_Scope_isConditionAction_Scope_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isConditionAction_Scope_isConditionAction_Scope_Call) Return() *isConditionAction_Scope_isConditionAction_Scope_Call { + _c.Call.Return() + return _c +} + +func (_c *isConditionAction_Scope_isConditionAction_Scope_Call) RunAndReturn(run func()) *isConditionAction_Scope_isConditionAction_Scope_Call { + _c.Run(run) + return _c +} + +// newIsConditionAction_Scope creates a new instance of isConditionAction_Scope. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsConditionAction_Scope(t interface { + mock.TestingT + Cleanup(func()) +}) *isConditionAction_Scope { + mock := &isConditionAction_Scope{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/is_create_run_request_id.go b/gen/go/flyteidl2/workflow/mocks/is_create_run_request_id.go new file mode 100644 index 0000000000..f89ec0e24c --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/is_create_run_request_id.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isCreateRunRequest_Id is an autogenerated mock type for the isCreateRunRequest_Id type +type isCreateRunRequest_Id struct { + mock.Mock +} + +type isCreateRunRequest_Id_Expecter struct { + mock *mock.Mock +} + +func (_m *isCreateRunRequest_Id) EXPECT() *isCreateRunRequest_Id_Expecter { + return &isCreateRunRequest_Id_Expecter{mock: &_m.Mock} +} + +// isCreateRunRequest_Id provides a mock function with no fields +func (_m *isCreateRunRequest_Id) isCreateRunRequest_Id() { + _m.Called() +} + +// isCreateRunRequest_Id_isCreateRunRequest_Id_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isCreateRunRequest_Id' +type isCreateRunRequest_Id_isCreateRunRequest_Id_Call struct { + *mock.Call +} + +// isCreateRunRequest_Id is a helper method to define mock.On call +func (_e *isCreateRunRequest_Id_Expecter) isCreateRunRequest_Id() *isCreateRunRequest_Id_isCreateRunRequest_Id_Call { + return &isCreateRunRequest_Id_isCreateRunRequest_Id_Call{Call: _e.mock.On("isCreateRunRequest_Id")} +} + +func (_c *isCreateRunRequest_Id_isCreateRunRequest_Id_Call) Run(run func()) *isCreateRunRequest_Id_isCreateRunRequest_Id_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isCreateRunRequest_Id_isCreateRunRequest_Id_Call) Return() *isCreateRunRequest_Id_isCreateRunRequest_Id_Call { + _c.Call.Return() + return _c +} + +func (_c *isCreateRunRequest_Id_isCreateRunRequest_Id_Call) RunAndReturn(run func()) *isCreateRunRequest_Id_isCreateRunRequest_Id_Call { + _c.Run(run) + return _c +} + +// newIsCreateRunRequest_Id creates a new instance of isCreateRunRequest_Id. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsCreateRunRequest_Id(t interface { + mock.TestingT + Cleanup(func()) +}) *isCreateRunRequest_Id { + mock := &isCreateRunRequest_Id{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/is_create_run_request_task.go b/gen/go/flyteidl2/workflow/mocks/is_create_run_request_task.go new file mode 100644 index 0000000000..0bfb1b72ff --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/is_create_run_request_task.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isCreateRunRequest_Task is an autogenerated mock type for the isCreateRunRequest_Task type +type isCreateRunRequest_Task struct { + mock.Mock +} + +type isCreateRunRequest_Task_Expecter struct { + mock *mock.Mock +} + +func (_m *isCreateRunRequest_Task) EXPECT() *isCreateRunRequest_Task_Expecter { + return &isCreateRunRequest_Task_Expecter{mock: &_m.Mock} +} + +// isCreateRunRequest_Task provides a mock function with no fields +func (_m *isCreateRunRequest_Task) isCreateRunRequest_Task() { + _m.Called() +} + +// isCreateRunRequest_Task_isCreateRunRequest_Task_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isCreateRunRequest_Task' +type isCreateRunRequest_Task_isCreateRunRequest_Task_Call struct { + *mock.Call +} + +// isCreateRunRequest_Task is a helper method to define mock.On call +func (_e *isCreateRunRequest_Task_Expecter) isCreateRunRequest_Task() *isCreateRunRequest_Task_isCreateRunRequest_Task_Call { + return &isCreateRunRequest_Task_isCreateRunRequest_Task_Call{Call: _e.mock.On("isCreateRunRequest_Task")} +} + +func (_c *isCreateRunRequest_Task_isCreateRunRequest_Task_Call) Run(run func()) *isCreateRunRequest_Task_isCreateRunRequest_Task_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isCreateRunRequest_Task_isCreateRunRequest_Task_Call) Return() *isCreateRunRequest_Task_isCreateRunRequest_Task_Call { + _c.Call.Return() + return _c +} + +func (_c *isCreateRunRequest_Task_isCreateRunRequest_Task_Call) RunAndReturn(run func()) *isCreateRunRequest_Task_isCreateRunRequest_Task_Call { + _c.Run(run) + return _c +} + +// newIsCreateRunRequest_Task creates a new instance of isCreateRunRequest_Task. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsCreateRunRequest_Task(t interface { + mock.TestingT + Cleanup(func()) +}) *isCreateRunRequest_Task { + mock := &isCreateRunRequest_Task{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/is_enqueue_action_request_spec.go b/gen/go/flyteidl2/workflow/mocks/is_enqueue_action_request_spec.go new file mode 100644 index 0000000000..5556f382bc --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/is_enqueue_action_request_spec.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isEnqueueActionRequest_Spec is an autogenerated mock type for the isEnqueueActionRequest_Spec type +type isEnqueueActionRequest_Spec struct { + mock.Mock +} + +type isEnqueueActionRequest_Spec_Expecter struct { + mock *mock.Mock +} + +func (_m *isEnqueueActionRequest_Spec) EXPECT() *isEnqueueActionRequest_Spec_Expecter { + return &isEnqueueActionRequest_Spec_Expecter{mock: &_m.Mock} +} + +// isEnqueueActionRequest_Spec provides a mock function with no fields +func (_m *isEnqueueActionRequest_Spec) isEnqueueActionRequest_Spec() { + _m.Called() +} + +// isEnqueueActionRequest_Spec_isEnqueueActionRequest_Spec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isEnqueueActionRequest_Spec' +type isEnqueueActionRequest_Spec_isEnqueueActionRequest_Spec_Call struct { + *mock.Call +} + +// isEnqueueActionRequest_Spec is a helper method to define mock.On call +func (_e *isEnqueueActionRequest_Spec_Expecter) isEnqueueActionRequest_Spec() *isEnqueueActionRequest_Spec_isEnqueueActionRequest_Spec_Call { + return &isEnqueueActionRequest_Spec_isEnqueueActionRequest_Spec_Call{Call: _e.mock.On("isEnqueueActionRequest_Spec")} +} + +func (_c *isEnqueueActionRequest_Spec_isEnqueueActionRequest_Spec_Call) Run(run func()) *isEnqueueActionRequest_Spec_isEnqueueActionRequest_Spec_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isEnqueueActionRequest_Spec_isEnqueueActionRequest_Spec_Call) Return() *isEnqueueActionRequest_Spec_isEnqueueActionRequest_Spec_Call { + _c.Call.Return() + return _c +} + +func (_c *isEnqueueActionRequest_Spec_isEnqueueActionRequest_Spec_Call) RunAndReturn(run func()) *isEnqueueActionRequest_Spec_isEnqueueActionRequest_Spec_Call { + _c.Run(run) + return _c +} + +// newIsEnqueueActionRequest_Spec creates a new instance of isEnqueueActionRequest_Spec. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsEnqueueActionRequest_Spec(t interface { + mock.TestingT + Cleanup(func()) +}) *isEnqueueActionRequest_Spec { + mock := &isEnqueueActionRequest_Spec{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/is_list_runs_request_scope_by.go b/gen/go/flyteidl2/workflow/mocks/is_list_runs_request_scope_by.go new file mode 100644 index 0000000000..194f3542a8 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/is_list_runs_request_scope_by.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isListRunsRequest_ScopeBy is an autogenerated mock type for the isListRunsRequest_ScopeBy type +type isListRunsRequest_ScopeBy struct { + mock.Mock +} + +type isListRunsRequest_ScopeBy_Expecter struct { + mock *mock.Mock +} + +func (_m *isListRunsRequest_ScopeBy) EXPECT() *isListRunsRequest_ScopeBy_Expecter { + return &isListRunsRequest_ScopeBy_Expecter{mock: &_m.Mock} +} + +// isListRunsRequest_ScopeBy provides a mock function with no fields +func (_m *isListRunsRequest_ScopeBy) isListRunsRequest_ScopeBy() { + _m.Called() +} + +// isListRunsRequest_ScopeBy_isListRunsRequest_ScopeBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isListRunsRequest_ScopeBy' +type isListRunsRequest_ScopeBy_isListRunsRequest_ScopeBy_Call struct { + *mock.Call +} + +// isListRunsRequest_ScopeBy is a helper method to define mock.On call +func (_e *isListRunsRequest_ScopeBy_Expecter) isListRunsRequest_ScopeBy() *isListRunsRequest_ScopeBy_isListRunsRequest_ScopeBy_Call { + return &isListRunsRequest_ScopeBy_isListRunsRequest_ScopeBy_Call{Call: _e.mock.On("isListRunsRequest_ScopeBy")} +} + +func (_c *isListRunsRequest_ScopeBy_isListRunsRequest_ScopeBy_Call) Run(run func()) *isListRunsRequest_ScopeBy_isListRunsRequest_ScopeBy_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isListRunsRequest_ScopeBy_isListRunsRequest_ScopeBy_Call) Return() *isListRunsRequest_ScopeBy_isListRunsRequest_ScopeBy_Call { + _c.Call.Return() + return _c +} + +func (_c *isListRunsRequest_ScopeBy_isListRunsRequest_ScopeBy_Call) RunAndReturn(run func()) *isListRunsRequest_ScopeBy_isListRunsRequest_ScopeBy_Call { + _c.Run(run) + return _c +} + +// newIsListRunsRequest_ScopeBy creates a new instance of isListRunsRequest_ScopeBy. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsListRunsRequest_ScopeBy(t interface { + mock.TestingT + Cleanup(func()) +}) *isListRunsRequest_ScopeBy { + mock := &isListRunsRequest_ScopeBy{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/is_watch_groups_request_known_sort_field_sort_by.go b/gen/go/flyteidl2/workflow/mocks/is_watch_groups_request_known_sort_field_sort_by.go new file mode 100644 index 0000000000..08f2ef8f40 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/is_watch_groups_request_known_sort_field_sort_by.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isWatchGroupsRequest_KnownSortField_SortBy is an autogenerated mock type for the isWatchGroupsRequest_KnownSortField_SortBy type +type isWatchGroupsRequest_KnownSortField_SortBy struct { + mock.Mock +} + +type isWatchGroupsRequest_KnownSortField_SortBy_Expecter struct { + mock *mock.Mock +} + +func (_m *isWatchGroupsRequest_KnownSortField_SortBy) EXPECT() *isWatchGroupsRequest_KnownSortField_SortBy_Expecter { + return &isWatchGroupsRequest_KnownSortField_SortBy_Expecter{mock: &_m.Mock} +} + +// isWatchGroupsRequest_KnownSortField_SortBy provides a mock function with no fields +func (_m *isWatchGroupsRequest_KnownSortField_SortBy) isWatchGroupsRequest_KnownSortField_SortBy() { + _m.Called() +} + +// isWatchGroupsRequest_KnownSortField_SortBy_isWatchGroupsRequest_KnownSortField_SortBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isWatchGroupsRequest_KnownSortField_SortBy' +type isWatchGroupsRequest_KnownSortField_SortBy_isWatchGroupsRequest_KnownSortField_SortBy_Call struct { + *mock.Call +} + +// isWatchGroupsRequest_KnownSortField_SortBy is a helper method to define mock.On call +func (_e *isWatchGroupsRequest_KnownSortField_SortBy_Expecter) isWatchGroupsRequest_KnownSortField_SortBy() *isWatchGroupsRequest_KnownSortField_SortBy_isWatchGroupsRequest_KnownSortField_SortBy_Call { + return &isWatchGroupsRequest_KnownSortField_SortBy_isWatchGroupsRequest_KnownSortField_SortBy_Call{Call: _e.mock.On("isWatchGroupsRequest_KnownSortField_SortBy")} +} + +func (_c *isWatchGroupsRequest_KnownSortField_SortBy_isWatchGroupsRequest_KnownSortField_SortBy_Call) Run(run func()) *isWatchGroupsRequest_KnownSortField_SortBy_isWatchGroupsRequest_KnownSortField_SortBy_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isWatchGroupsRequest_KnownSortField_SortBy_isWatchGroupsRequest_KnownSortField_SortBy_Call) Return() *isWatchGroupsRequest_KnownSortField_SortBy_isWatchGroupsRequest_KnownSortField_SortBy_Call { + _c.Call.Return() + return _c +} + +func (_c *isWatchGroupsRequest_KnownSortField_SortBy_isWatchGroupsRequest_KnownSortField_SortBy_Call) RunAndReturn(run func()) *isWatchGroupsRequest_KnownSortField_SortBy_isWatchGroupsRequest_KnownSortField_SortBy_Call { + _c.Run(run) + return _c +} + +// newIsWatchGroupsRequest_KnownSortField_SortBy creates a new instance of isWatchGroupsRequest_KnownSortField_SortBy. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsWatchGroupsRequest_KnownSortField_SortBy(t interface { + mock.TestingT + Cleanup(func()) +}) *isWatchGroupsRequest_KnownSortField_SortBy { + mock := &isWatchGroupsRequest_KnownSortField_SortBy{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/is_watch_groups_request_scope_by.go b/gen/go/flyteidl2/workflow/mocks/is_watch_groups_request_scope_by.go new file mode 100644 index 0000000000..efe9610341 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/is_watch_groups_request_scope_by.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isWatchGroupsRequest_ScopeBy is an autogenerated mock type for the isWatchGroupsRequest_ScopeBy type +type isWatchGroupsRequest_ScopeBy struct { + mock.Mock +} + +type isWatchGroupsRequest_ScopeBy_Expecter struct { + mock *mock.Mock +} + +func (_m *isWatchGroupsRequest_ScopeBy) EXPECT() *isWatchGroupsRequest_ScopeBy_Expecter { + return &isWatchGroupsRequest_ScopeBy_Expecter{mock: &_m.Mock} +} + +// isWatchGroupsRequest_ScopeBy provides a mock function with no fields +func (_m *isWatchGroupsRequest_ScopeBy) isWatchGroupsRequest_ScopeBy() { + _m.Called() +} + +// isWatchGroupsRequest_ScopeBy_isWatchGroupsRequest_ScopeBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isWatchGroupsRequest_ScopeBy' +type isWatchGroupsRequest_ScopeBy_isWatchGroupsRequest_ScopeBy_Call struct { + *mock.Call +} + +// isWatchGroupsRequest_ScopeBy is a helper method to define mock.On call +func (_e *isWatchGroupsRequest_ScopeBy_Expecter) isWatchGroupsRequest_ScopeBy() *isWatchGroupsRequest_ScopeBy_isWatchGroupsRequest_ScopeBy_Call { + return &isWatchGroupsRequest_ScopeBy_isWatchGroupsRequest_ScopeBy_Call{Call: _e.mock.On("isWatchGroupsRequest_ScopeBy")} +} + +func (_c *isWatchGroupsRequest_ScopeBy_isWatchGroupsRequest_ScopeBy_Call) Run(run func()) *isWatchGroupsRequest_ScopeBy_isWatchGroupsRequest_ScopeBy_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isWatchGroupsRequest_ScopeBy_isWatchGroupsRequest_ScopeBy_Call) Return() *isWatchGroupsRequest_ScopeBy_isWatchGroupsRequest_ScopeBy_Call { + _c.Call.Return() + return _c +} + +func (_c *isWatchGroupsRequest_ScopeBy_isWatchGroupsRequest_ScopeBy_Call) RunAndReturn(run func()) *isWatchGroupsRequest_ScopeBy_isWatchGroupsRequest_ScopeBy_Call { + _c.Run(run) + return _c +} + +// newIsWatchGroupsRequest_ScopeBy creates a new instance of isWatchGroupsRequest_ScopeBy. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsWatchGroupsRequest_ScopeBy(t interface { + mock.TestingT + Cleanup(func()) +}) *isWatchGroupsRequest_ScopeBy { + mock := &isWatchGroupsRequest_ScopeBy{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/is_watch_request_filter.go b/gen/go/flyteidl2/workflow/mocks/is_watch_request_filter.go new file mode 100644 index 0000000000..4865145763 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/is_watch_request_filter.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isWatchRequest_Filter is an autogenerated mock type for the isWatchRequest_Filter type +type isWatchRequest_Filter struct { + mock.Mock +} + +type isWatchRequest_Filter_Expecter struct { + mock *mock.Mock +} + +func (_m *isWatchRequest_Filter) EXPECT() *isWatchRequest_Filter_Expecter { + return &isWatchRequest_Filter_Expecter{mock: &_m.Mock} +} + +// isWatchRequest_Filter provides a mock function with no fields +func (_m *isWatchRequest_Filter) isWatchRequest_Filter() { + _m.Called() +} + +// isWatchRequest_Filter_isWatchRequest_Filter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isWatchRequest_Filter' +type isWatchRequest_Filter_isWatchRequest_Filter_Call struct { + *mock.Call +} + +// isWatchRequest_Filter is a helper method to define mock.On call +func (_e *isWatchRequest_Filter_Expecter) isWatchRequest_Filter() *isWatchRequest_Filter_isWatchRequest_Filter_Call { + return &isWatchRequest_Filter_isWatchRequest_Filter_Call{Call: _e.mock.On("isWatchRequest_Filter")} +} + +func (_c *isWatchRequest_Filter_isWatchRequest_Filter_Call) Run(run func()) *isWatchRequest_Filter_isWatchRequest_Filter_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isWatchRequest_Filter_isWatchRequest_Filter_Call) Return() *isWatchRequest_Filter_isWatchRequest_Filter_Call { + _c.Call.Return() + return _c +} + +func (_c *isWatchRequest_Filter_isWatchRequest_Filter_Call) RunAndReturn(run func()) *isWatchRequest_Filter_isWatchRequest_Filter_Call { + _c.Run(run) + return _c +} + +// newIsWatchRequest_Filter creates a new instance of isWatchRequest_Filter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsWatchRequest_Filter(t interface { + mock.TestingT + Cleanup(func()) +}) *isWatchRequest_Filter { + mock := &isWatchRequest_Filter{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/is_watch_response_message.go b/gen/go/flyteidl2/workflow/mocks/is_watch_response_message.go new file mode 100644 index 0000000000..02369c1ce2 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/is_watch_response_message.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isWatchResponse_Message is an autogenerated mock type for the isWatchResponse_Message type +type isWatchResponse_Message struct { + mock.Mock +} + +type isWatchResponse_Message_Expecter struct { + mock *mock.Mock +} + +func (_m *isWatchResponse_Message) EXPECT() *isWatchResponse_Message_Expecter { + return &isWatchResponse_Message_Expecter{mock: &_m.Mock} +} + +// isWatchResponse_Message provides a mock function with no fields +func (_m *isWatchResponse_Message) isWatchResponse_Message() { + _m.Called() +} + +// isWatchResponse_Message_isWatchResponse_Message_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isWatchResponse_Message' +type isWatchResponse_Message_isWatchResponse_Message_Call struct { + *mock.Call +} + +// isWatchResponse_Message is a helper method to define mock.On call +func (_e *isWatchResponse_Message_Expecter) isWatchResponse_Message() *isWatchResponse_Message_isWatchResponse_Message_Call { + return &isWatchResponse_Message_isWatchResponse_Message_Call{Call: _e.mock.On("isWatchResponse_Message")} +} + +func (_c *isWatchResponse_Message_isWatchResponse_Message_Call) Run(run func()) *isWatchResponse_Message_isWatchResponse_Message_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isWatchResponse_Message_isWatchResponse_Message_Call) Return() *isWatchResponse_Message_isWatchResponse_Message_Call { + _c.Call.Return() + return _c +} + +func (_c *isWatchResponse_Message_isWatchResponse_Message_Call) RunAndReturn(run func()) *isWatchResponse_Message_isWatchResponse_Message_Call { + _c.Run(run) + return _c +} + +// newIsWatchResponse_Message creates a new instance of isWatchResponse_Message. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsWatchResponse_Message(t interface { + mock.TestingT + Cleanup(func()) +}) *isWatchResponse_Message { + mock := &isWatchResponse_Message{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/is_watch_runs_request_target.go b/gen/go/flyteidl2/workflow/mocks/is_watch_runs_request_target.go new file mode 100644 index 0000000000..845eb6fc4a --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/is_watch_runs_request_target.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// isWatchRunsRequest_Target is an autogenerated mock type for the isWatchRunsRequest_Target type +type isWatchRunsRequest_Target struct { + mock.Mock +} + +type isWatchRunsRequest_Target_Expecter struct { + mock *mock.Mock +} + +func (_m *isWatchRunsRequest_Target) EXPECT() *isWatchRunsRequest_Target_Expecter { + return &isWatchRunsRequest_Target_Expecter{mock: &_m.Mock} +} + +// isWatchRunsRequest_Target provides a mock function with no fields +func (_m *isWatchRunsRequest_Target) isWatchRunsRequest_Target() { + _m.Called() +} + +// isWatchRunsRequest_Target_isWatchRunsRequest_Target_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'isWatchRunsRequest_Target' +type isWatchRunsRequest_Target_isWatchRunsRequest_Target_Call struct { + *mock.Call +} + +// isWatchRunsRequest_Target is a helper method to define mock.On call +func (_e *isWatchRunsRequest_Target_Expecter) isWatchRunsRequest_Target() *isWatchRunsRequest_Target_isWatchRunsRequest_Target_Call { + return &isWatchRunsRequest_Target_isWatchRunsRequest_Target_Call{Call: _e.mock.On("isWatchRunsRequest_Target")} +} + +func (_c *isWatchRunsRequest_Target_isWatchRunsRequest_Target_Call) Run(run func()) *isWatchRunsRequest_Target_isWatchRunsRequest_Target_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *isWatchRunsRequest_Target_isWatchRunsRequest_Target_Call) Return() *isWatchRunsRequest_Target_isWatchRunsRequest_Target_Call { + _c.Call.Return() + return _c +} + +func (_c *isWatchRunsRequest_Target_isWatchRunsRequest_Target_Call) RunAndReturn(run func()) *isWatchRunsRequest_Target_isWatchRunsRequest_Target_Call { + _c.Run(run) + return _c +} + +// newIsWatchRunsRequest_Target creates a new instance of isWatchRunsRequest_Target. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newIsWatchRunsRequest_Target(t interface { + mock.TestingT + Cleanup(func()) +}) *isWatchRunsRequest_Target { + mock := &isWatchRunsRequest_Target{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/queue_service_client.go b/gen/go/flyteidl2/workflow/mocks/queue_service_client.go new file mode 100644 index 0000000000..fc4f08a3e7 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/queue_service_client.go @@ -0,0 +1,262 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + grpc "google.golang.org/grpc" + + mock "github.com/stretchr/testify/mock" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// QueueServiceClient is an autogenerated mock type for the QueueServiceClient type +type QueueServiceClient struct { + mock.Mock +} + +type QueueServiceClient_Expecter struct { + mock *mock.Mock +} + +func (_m *QueueServiceClient) EXPECT() *QueueServiceClient_Expecter { + return &QueueServiceClient_Expecter{mock: &_m.Mock} +} + +// AbortQueuedAction provides a mock function with given fields: ctx, in, opts +func (_m *QueueServiceClient) AbortQueuedAction(ctx context.Context, in *workflow.AbortQueuedActionRequest, opts ...grpc.CallOption) (*workflow.AbortQueuedActionResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AbortQueuedAction") + } + + var r0 *workflow.AbortQueuedActionResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.AbortQueuedActionRequest, ...grpc.CallOption) (*workflow.AbortQueuedActionResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.AbortQueuedActionRequest, ...grpc.CallOption) *workflow.AbortQueuedActionResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.AbortQueuedActionResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.AbortQueuedActionRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// QueueServiceClient_AbortQueuedAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortQueuedAction' +type QueueServiceClient_AbortQueuedAction_Call struct { + *mock.Call +} + +// AbortQueuedAction is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.AbortQueuedActionRequest +// - opts ...grpc.CallOption +func (_e *QueueServiceClient_Expecter) AbortQueuedAction(ctx interface{}, in interface{}, opts ...interface{}) *QueueServiceClient_AbortQueuedAction_Call { + return &QueueServiceClient_AbortQueuedAction_Call{Call: _e.mock.On("AbortQueuedAction", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *QueueServiceClient_AbortQueuedAction_Call) Run(run func(ctx context.Context, in *workflow.AbortQueuedActionRequest, opts ...grpc.CallOption)) *QueueServiceClient_AbortQueuedAction_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.AbortQueuedActionRequest), variadicArgs...) + }) + return _c +} + +func (_c *QueueServiceClient_AbortQueuedAction_Call) Return(_a0 *workflow.AbortQueuedActionResponse, _a1 error) *QueueServiceClient_AbortQueuedAction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *QueueServiceClient_AbortQueuedAction_Call) RunAndReturn(run func(context.Context, *workflow.AbortQueuedActionRequest, ...grpc.CallOption) (*workflow.AbortQueuedActionResponse, error)) *QueueServiceClient_AbortQueuedAction_Call { + _c.Call.Return(run) + return _c +} + +// AbortQueuedRun provides a mock function with given fields: ctx, in, opts +func (_m *QueueServiceClient) AbortQueuedRun(ctx context.Context, in *workflow.AbortQueuedRunRequest, opts ...grpc.CallOption) (*workflow.AbortQueuedRunResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AbortQueuedRun") + } + + var r0 *workflow.AbortQueuedRunResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.AbortQueuedRunRequest, ...grpc.CallOption) (*workflow.AbortQueuedRunResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.AbortQueuedRunRequest, ...grpc.CallOption) *workflow.AbortQueuedRunResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.AbortQueuedRunResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.AbortQueuedRunRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// QueueServiceClient_AbortQueuedRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortQueuedRun' +type QueueServiceClient_AbortQueuedRun_Call struct { + *mock.Call +} + +// AbortQueuedRun is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.AbortQueuedRunRequest +// - opts ...grpc.CallOption +func (_e *QueueServiceClient_Expecter) AbortQueuedRun(ctx interface{}, in interface{}, opts ...interface{}) *QueueServiceClient_AbortQueuedRun_Call { + return &QueueServiceClient_AbortQueuedRun_Call{Call: _e.mock.On("AbortQueuedRun", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *QueueServiceClient_AbortQueuedRun_Call) Run(run func(ctx context.Context, in *workflow.AbortQueuedRunRequest, opts ...grpc.CallOption)) *QueueServiceClient_AbortQueuedRun_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.AbortQueuedRunRequest), variadicArgs...) + }) + return _c +} + +func (_c *QueueServiceClient_AbortQueuedRun_Call) Return(_a0 *workflow.AbortQueuedRunResponse, _a1 error) *QueueServiceClient_AbortQueuedRun_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *QueueServiceClient_AbortQueuedRun_Call) RunAndReturn(run func(context.Context, *workflow.AbortQueuedRunRequest, ...grpc.CallOption) (*workflow.AbortQueuedRunResponse, error)) *QueueServiceClient_AbortQueuedRun_Call { + _c.Call.Return(run) + return _c +} + +// EnqueueAction provides a mock function with given fields: ctx, in, opts +func (_m *QueueServiceClient) EnqueueAction(ctx context.Context, in *workflow.EnqueueActionRequest, opts ...grpc.CallOption) (*workflow.EnqueueActionResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for EnqueueAction") + } + + var r0 *workflow.EnqueueActionResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.EnqueueActionRequest, ...grpc.CallOption) (*workflow.EnqueueActionResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.EnqueueActionRequest, ...grpc.CallOption) *workflow.EnqueueActionResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.EnqueueActionResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.EnqueueActionRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// QueueServiceClient_EnqueueAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnqueueAction' +type QueueServiceClient_EnqueueAction_Call struct { + *mock.Call +} + +// EnqueueAction is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.EnqueueActionRequest +// - opts ...grpc.CallOption +func (_e *QueueServiceClient_Expecter) EnqueueAction(ctx interface{}, in interface{}, opts ...interface{}) *QueueServiceClient_EnqueueAction_Call { + return &QueueServiceClient_EnqueueAction_Call{Call: _e.mock.On("EnqueueAction", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *QueueServiceClient_EnqueueAction_Call) Run(run func(ctx context.Context, in *workflow.EnqueueActionRequest, opts ...grpc.CallOption)) *QueueServiceClient_EnqueueAction_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.EnqueueActionRequest), variadicArgs...) + }) + return _c +} + +func (_c *QueueServiceClient_EnqueueAction_Call) Return(_a0 *workflow.EnqueueActionResponse, _a1 error) *QueueServiceClient_EnqueueAction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *QueueServiceClient_EnqueueAction_Call) RunAndReturn(run func(context.Context, *workflow.EnqueueActionRequest, ...grpc.CallOption) (*workflow.EnqueueActionResponse, error)) *QueueServiceClient_EnqueueAction_Call { + _c.Call.Return(run) + return _c +} + +// NewQueueServiceClient creates a new instance of QueueServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewQueueServiceClient(t interface { + mock.TestingT + Cleanup(func()) +}) *QueueServiceClient { + mock := &QueueServiceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/queue_service_server.go b/gen/go/flyteidl2/workflow/mocks/queue_service_server.go new file mode 100644 index 0000000000..38b4a7e928 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/queue_service_server.go @@ -0,0 +1,214 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + mock "github.com/stretchr/testify/mock" +) + +// QueueServiceServer is an autogenerated mock type for the QueueServiceServer type +type QueueServiceServer struct { + mock.Mock +} + +type QueueServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *QueueServiceServer) EXPECT() *QueueServiceServer_Expecter { + return &QueueServiceServer_Expecter{mock: &_m.Mock} +} + +// AbortQueuedAction provides a mock function with given fields: _a0, _a1 +func (_m *QueueServiceServer) AbortQueuedAction(_a0 context.Context, _a1 *workflow.AbortQueuedActionRequest) (*workflow.AbortQueuedActionResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for AbortQueuedAction") + } + + var r0 *workflow.AbortQueuedActionResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.AbortQueuedActionRequest) (*workflow.AbortQueuedActionResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.AbortQueuedActionRequest) *workflow.AbortQueuedActionResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.AbortQueuedActionResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.AbortQueuedActionRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// QueueServiceServer_AbortQueuedAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortQueuedAction' +type QueueServiceServer_AbortQueuedAction_Call struct { + *mock.Call +} + +// AbortQueuedAction is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *workflow.AbortQueuedActionRequest +func (_e *QueueServiceServer_Expecter) AbortQueuedAction(_a0 interface{}, _a1 interface{}) *QueueServiceServer_AbortQueuedAction_Call { + return &QueueServiceServer_AbortQueuedAction_Call{Call: _e.mock.On("AbortQueuedAction", _a0, _a1)} +} + +func (_c *QueueServiceServer_AbortQueuedAction_Call) Run(run func(_a0 context.Context, _a1 *workflow.AbortQueuedActionRequest)) *QueueServiceServer_AbortQueuedAction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.AbortQueuedActionRequest)) + }) + return _c +} + +func (_c *QueueServiceServer_AbortQueuedAction_Call) Return(_a0 *workflow.AbortQueuedActionResponse, _a1 error) *QueueServiceServer_AbortQueuedAction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *QueueServiceServer_AbortQueuedAction_Call) RunAndReturn(run func(context.Context, *workflow.AbortQueuedActionRequest) (*workflow.AbortQueuedActionResponse, error)) *QueueServiceServer_AbortQueuedAction_Call { + _c.Call.Return(run) + return _c +} + +// AbortQueuedRun provides a mock function with given fields: _a0, _a1 +func (_m *QueueServiceServer) AbortQueuedRun(_a0 context.Context, _a1 *workflow.AbortQueuedRunRequest) (*workflow.AbortQueuedRunResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for AbortQueuedRun") + } + + var r0 *workflow.AbortQueuedRunResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.AbortQueuedRunRequest) (*workflow.AbortQueuedRunResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.AbortQueuedRunRequest) *workflow.AbortQueuedRunResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.AbortQueuedRunResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.AbortQueuedRunRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// QueueServiceServer_AbortQueuedRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortQueuedRun' +type QueueServiceServer_AbortQueuedRun_Call struct { + *mock.Call +} + +// AbortQueuedRun is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *workflow.AbortQueuedRunRequest +func (_e *QueueServiceServer_Expecter) AbortQueuedRun(_a0 interface{}, _a1 interface{}) *QueueServiceServer_AbortQueuedRun_Call { + return &QueueServiceServer_AbortQueuedRun_Call{Call: _e.mock.On("AbortQueuedRun", _a0, _a1)} +} + +func (_c *QueueServiceServer_AbortQueuedRun_Call) Run(run func(_a0 context.Context, _a1 *workflow.AbortQueuedRunRequest)) *QueueServiceServer_AbortQueuedRun_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.AbortQueuedRunRequest)) + }) + return _c +} + +func (_c *QueueServiceServer_AbortQueuedRun_Call) Return(_a0 *workflow.AbortQueuedRunResponse, _a1 error) *QueueServiceServer_AbortQueuedRun_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *QueueServiceServer_AbortQueuedRun_Call) RunAndReturn(run func(context.Context, *workflow.AbortQueuedRunRequest) (*workflow.AbortQueuedRunResponse, error)) *QueueServiceServer_AbortQueuedRun_Call { + _c.Call.Return(run) + return _c +} + +// EnqueueAction provides a mock function with given fields: _a0, _a1 +func (_m *QueueServiceServer) EnqueueAction(_a0 context.Context, _a1 *workflow.EnqueueActionRequest) (*workflow.EnqueueActionResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for EnqueueAction") + } + + var r0 *workflow.EnqueueActionResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.EnqueueActionRequest) (*workflow.EnqueueActionResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.EnqueueActionRequest) *workflow.EnqueueActionResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.EnqueueActionResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.EnqueueActionRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// QueueServiceServer_EnqueueAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnqueueAction' +type QueueServiceServer_EnqueueAction_Call struct { + *mock.Call +} + +// EnqueueAction is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *workflow.EnqueueActionRequest +func (_e *QueueServiceServer_Expecter) EnqueueAction(_a0 interface{}, _a1 interface{}) *QueueServiceServer_EnqueueAction_Call { + return &QueueServiceServer_EnqueueAction_Call{Call: _e.mock.On("EnqueueAction", _a0, _a1)} +} + +func (_c *QueueServiceServer_EnqueueAction_Call) Run(run func(_a0 context.Context, _a1 *workflow.EnqueueActionRequest)) *QueueServiceServer_EnqueueAction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.EnqueueActionRequest)) + }) + return _c +} + +func (_c *QueueServiceServer_EnqueueAction_Call) Return(_a0 *workflow.EnqueueActionResponse, _a1 error) *QueueServiceServer_EnqueueAction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *QueueServiceServer_EnqueueAction_Call) RunAndReturn(run func(context.Context, *workflow.EnqueueActionRequest) (*workflow.EnqueueActionResponse, error)) *QueueServiceServer_EnqueueAction_Call { + _c.Call.Return(run) + return _c +} + +// NewQueueServiceServer creates a new instance of QueueServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewQueueServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *QueueServiceServer { + mock := &QueueServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/run_logs_service_client.go b/gen/go/flyteidl2/workflow/mocks/run_logs_service_client.go new file mode 100644 index 0000000000..c0b5f40201 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/run_logs_service_client.go @@ -0,0 +1,114 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + grpc "google.golang.org/grpc" + + mock "github.com/stretchr/testify/mock" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunLogsServiceClient is an autogenerated mock type for the RunLogsServiceClient type +type RunLogsServiceClient struct { + mock.Mock +} + +type RunLogsServiceClient_Expecter struct { + mock *mock.Mock +} + +func (_m *RunLogsServiceClient) EXPECT() *RunLogsServiceClient_Expecter { + return &RunLogsServiceClient_Expecter{mock: &_m.Mock} +} + +// TailLogs provides a mock function with given fields: ctx, in, opts +func (_m *RunLogsServiceClient) TailLogs(ctx context.Context, in *workflow.TailLogsRequest, opts ...grpc.CallOption) (workflow.RunLogsService_TailLogsClient, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for TailLogs") + } + + var r0 workflow.RunLogsService_TailLogsClient + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.TailLogsRequest, ...grpc.CallOption) (workflow.RunLogsService_TailLogsClient, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.TailLogsRequest, ...grpc.CallOption) workflow.RunLogsService_TailLogsClient); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(workflow.RunLogsService_TailLogsClient) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.TailLogsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunLogsServiceClient_TailLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TailLogs' +type RunLogsServiceClient_TailLogs_Call struct { + *mock.Call +} + +// TailLogs is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.TailLogsRequest +// - opts ...grpc.CallOption +func (_e *RunLogsServiceClient_Expecter) TailLogs(ctx interface{}, in interface{}, opts ...interface{}) *RunLogsServiceClient_TailLogs_Call { + return &RunLogsServiceClient_TailLogs_Call{Call: _e.mock.On("TailLogs", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *RunLogsServiceClient_TailLogs_Call) Run(run func(ctx context.Context, in *workflow.TailLogsRequest, opts ...grpc.CallOption)) *RunLogsServiceClient_TailLogs_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.TailLogsRequest), variadicArgs...) + }) + return _c +} + +func (_c *RunLogsServiceClient_TailLogs_Call) Return(_a0 workflow.RunLogsService_TailLogsClient, _a1 error) *RunLogsServiceClient_TailLogs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunLogsServiceClient_TailLogs_Call) RunAndReturn(run func(context.Context, *workflow.TailLogsRequest, ...grpc.CallOption) (workflow.RunLogsService_TailLogsClient, error)) *RunLogsServiceClient_TailLogs_Call { + _c.Call.Return(run) + return _c +} + +// NewRunLogsServiceClient creates a new instance of RunLogsServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunLogsServiceClient(t interface { + mock.TestingT + Cleanup(func()) +}) *RunLogsServiceClient { + mock := &RunLogsServiceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/run_logs_service_server.go b/gen/go/flyteidl2/workflow/mocks/run_logs_service_server.go new file mode 100644 index 0000000000..e711f95af4 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/run_logs_service_server.go @@ -0,0 +1,82 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + mock "github.com/stretchr/testify/mock" +) + +// RunLogsServiceServer is an autogenerated mock type for the RunLogsServiceServer type +type RunLogsServiceServer struct { + mock.Mock +} + +type RunLogsServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *RunLogsServiceServer) EXPECT() *RunLogsServiceServer_Expecter { + return &RunLogsServiceServer_Expecter{mock: &_m.Mock} +} + +// TailLogs provides a mock function with given fields: _a0, _a1 +func (_m *RunLogsServiceServer) TailLogs(_a0 *workflow.TailLogsRequest, _a1 workflow.RunLogsService_TailLogsServer) error { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for TailLogs") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*workflow.TailLogsRequest, workflow.RunLogsService_TailLogsServer) error); ok { + r0 = rf(_a0, _a1) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunLogsServiceServer_TailLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TailLogs' +type RunLogsServiceServer_TailLogs_Call struct { + *mock.Call +} + +// TailLogs is a helper method to define mock.On call +// - _a0 *workflow.TailLogsRequest +// - _a1 workflow.RunLogsService_TailLogsServer +func (_e *RunLogsServiceServer_Expecter) TailLogs(_a0 interface{}, _a1 interface{}) *RunLogsServiceServer_TailLogs_Call { + return &RunLogsServiceServer_TailLogs_Call{Call: _e.mock.On("TailLogs", _a0, _a1)} +} + +func (_c *RunLogsServiceServer_TailLogs_Call) Run(run func(_a0 *workflow.TailLogsRequest, _a1 workflow.RunLogsService_TailLogsServer)) *RunLogsServiceServer_TailLogs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*workflow.TailLogsRequest), args[1].(workflow.RunLogsService_TailLogsServer)) + }) + return _c +} + +func (_c *RunLogsServiceServer_TailLogs_Call) Return(_a0 error) *RunLogsServiceServer_TailLogs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunLogsServiceServer_TailLogs_Call) RunAndReturn(run func(*workflow.TailLogsRequest, workflow.RunLogsService_TailLogsServer) error) *RunLogsServiceServer_TailLogs_Call { + _c.Call.Return(run) + return _c +} + +// NewRunLogsServiceServer creates a new instance of RunLogsServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunLogsServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *RunLogsServiceServer { + mock := &RunLogsServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/run_logs_service_tail_logs_client.go b/gen/go/flyteidl2/workflow/mocks/run_logs_service_tail_logs_client.go new file mode 100644 index 0000000000..ada1dfe5e5 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/run_logs_service_tail_logs_client.go @@ -0,0 +1,384 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + metadata "google.golang.org/grpc/metadata" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunLogsService_TailLogsClient is an autogenerated mock type for the RunLogsService_TailLogsClient type +type RunLogsService_TailLogsClient struct { + mock.Mock +} + +type RunLogsService_TailLogsClient_Expecter struct { + mock *mock.Mock +} + +func (_m *RunLogsService_TailLogsClient) EXPECT() *RunLogsService_TailLogsClient_Expecter { + return &RunLogsService_TailLogsClient_Expecter{mock: &_m.Mock} +} + +// CloseSend provides a mock function with no fields +func (_m *RunLogsService_TailLogsClient) CloseSend() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for CloseSend") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunLogsService_TailLogsClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend' +type RunLogsService_TailLogsClient_CloseSend_Call struct { + *mock.Call +} + +// CloseSend is a helper method to define mock.On call +func (_e *RunLogsService_TailLogsClient_Expecter) CloseSend() *RunLogsService_TailLogsClient_CloseSend_Call { + return &RunLogsService_TailLogsClient_CloseSend_Call{Call: _e.mock.On("CloseSend")} +} + +func (_c *RunLogsService_TailLogsClient_CloseSend_Call) Run(run func()) *RunLogsService_TailLogsClient_CloseSend_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunLogsService_TailLogsClient_CloseSend_Call) Return(_a0 error) *RunLogsService_TailLogsClient_CloseSend_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunLogsService_TailLogsClient_CloseSend_Call) RunAndReturn(run func() error) *RunLogsService_TailLogsClient_CloseSend_Call { + _c.Call.Return(run) + return _c +} + +// Context provides a mock function with no fields +func (_m *RunLogsService_TailLogsClient) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// RunLogsService_TailLogsClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type RunLogsService_TailLogsClient_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *RunLogsService_TailLogsClient_Expecter) Context() *RunLogsService_TailLogsClient_Context_Call { + return &RunLogsService_TailLogsClient_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *RunLogsService_TailLogsClient_Context_Call) Run(run func()) *RunLogsService_TailLogsClient_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunLogsService_TailLogsClient_Context_Call) Return(_a0 context.Context) *RunLogsService_TailLogsClient_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunLogsService_TailLogsClient_Context_Call) RunAndReturn(run func() context.Context) *RunLogsService_TailLogsClient_Context_Call { + _c.Call.Return(run) + return _c +} + +// Header provides a mock function with no fields +func (_m *RunLogsService_TailLogsClient) Header() (metadata.MD, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Header") + } + + var r0 metadata.MD + var r1 error + if rf, ok := ret.Get(0).(func() (metadata.MD, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunLogsService_TailLogsClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header' +type RunLogsService_TailLogsClient_Header_Call struct { + *mock.Call +} + +// Header is a helper method to define mock.On call +func (_e *RunLogsService_TailLogsClient_Expecter) Header() *RunLogsService_TailLogsClient_Header_Call { + return &RunLogsService_TailLogsClient_Header_Call{Call: _e.mock.On("Header")} +} + +func (_c *RunLogsService_TailLogsClient_Header_Call) Run(run func()) *RunLogsService_TailLogsClient_Header_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunLogsService_TailLogsClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *RunLogsService_TailLogsClient_Header_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunLogsService_TailLogsClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *RunLogsService_TailLogsClient_Header_Call { + _c.Call.Return(run) + return _c +} + +// Recv provides a mock function with no fields +func (_m *RunLogsService_TailLogsClient) Recv() (*workflow.TailLogsResponse, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Recv") + } + + var r0 *workflow.TailLogsResponse + var r1 error + if rf, ok := ret.Get(0).(func() (*workflow.TailLogsResponse, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() *workflow.TailLogsResponse); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.TailLogsResponse) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunLogsService_TailLogsClient_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv' +type RunLogsService_TailLogsClient_Recv_Call struct { + *mock.Call +} + +// Recv is a helper method to define mock.On call +func (_e *RunLogsService_TailLogsClient_Expecter) Recv() *RunLogsService_TailLogsClient_Recv_Call { + return &RunLogsService_TailLogsClient_Recv_Call{Call: _e.mock.On("Recv")} +} + +func (_c *RunLogsService_TailLogsClient_Recv_Call) Run(run func()) *RunLogsService_TailLogsClient_Recv_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunLogsService_TailLogsClient_Recv_Call) Return(_a0 *workflow.TailLogsResponse, _a1 error) *RunLogsService_TailLogsClient_Recv_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunLogsService_TailLogsClient_Recv_Call) RunAndReturn(run func() (*workflow.TailLogsResponse, error)) *RunLogsService_TailLogsClient_Recv_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *RunLogsService_TailLogsClient) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunLogsService_TailLogsClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type RunLogsService_TailLogsClient_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *RunLogsService_TailLogsClient_Expecter) RecvMsg(m interface{}) *RunLogsService_TailLogsClient_RecvMsg_Call { + return &RunLogsService_TailLogsClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *RunLogsService_TailLogsClient_RecvMsg_Call) Run(run func(m any)) *RunLogsService_TailLogsClient_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunLogsService_TailLogsClient_RecvMsg_Call) Return(_a0 error) *RunLogsService_TailLogsClient_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunLogsService_TailLogsClient_RecvMsg_Call) RunAndReturn(run func(any) error) *RunLogsService_TailLogsClient_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *RunLogsService_TailLogsClient) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunLogsService_TailLogsClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type RunLogsService_TailLogsClient_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *RunLogsService_TailLogsClient_Expecter) SendMsg(m interface{}) *RunLogsService_TailLogsClient_SendMsg_Call { + return &RunLogsService_TailLogsClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *RunLogsService_TailLogsClient_SendMsg_Call) Run(run func(m any)) *RunLogsService_TailLogsClient_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunLogsService_TailLogsClient_SendMsg_Call) Return(_a0 error) *RunLogsService_TailLogsClient_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunLogsService_TailLogsClient_SendMsg_Call) RunAndReturn(run func(any) error) *RunLogsService_TailLogsClient_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// Trailer provides a mock function with no fields +func (_m *RunLogsService_TailLogsClient) Trailer() metadata.MD { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Trailer") + } + + var r0 metadata.MD + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + return r0 +} + +// RunLogsService_TailLogsClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer' +type RunLogsService_TailLogsClient_Trailer_Call struct { + *mock.Call +} + +// Trailer is a helper method to define mock.On call +func (_e *RunLogsService_TailLogsClient_Expecter) Trailer() *RunLogsService_TailLogsClient_Trailer_Call { + return &RunLogsService_TailLogsClient_Trailer_Call{Call: _e.mock.On("Trailer")} +} + +func (_c *RunLogsService_TailLogsClient_Trailer_Call) Run(run func()) *RunLogsService_TailLogsClient_Trailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunLogsService_TailLogsClient_Trailer_Call) Return(_a0 metadata.MD) *RunLogsService_TailLogsClient_Trailer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunLogsService_TailLogsClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *RunLogsService_TailLogsClient_Trailer_Call { + _c.Call.Return(run) + return _c +} + +// NewRunLogsService_TailLogsClient creates a new instance of RunLogsService_TailLogsClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunLogsService_TailLogsClient(t interface { + mock.TestingT + Cleanup(func()) +}) *RunLogsService_TailLogsClient { + mock := &RunLogsService_TailLogsClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/run_logs_service_tail_logs_server.go b/gen/go/flyteidl2/workflow/mocks/run_logs_service_tail_logs_server.go new file mode 100644 index 0000000000..9ceddec62e --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/run_logs_service_tail_logs_server.go @@ -0,0 +1,349 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + metadata "google.golang.org/grpc/metadata" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunLogsService_TailLogsServer is an autogenerated mock type for the RunLogsService_TailLogsServer type +type RunLogsService_TailLogsServer struct { + mock.Mock +} + +type RunLogsService_TailLogsServer_Expecter struct { + mock *mock.Mock +} + +func (_m *RunLogsService_TailLogsServer) EXPECT() *RunLogsService_TailLogsServer_Expecter { + return &RunLogsService_TailLogsServer_Expecter{mock: &_m.Mock} +} + +// Context provides a mock function with no fields +func (_m *RunLogsService_TailLogsServer) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// RunLogsService_TailLogsServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type RunLogsService_TailLogsServer_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *RunLogsService_TailLogsServer_Expecter) Context() *RunLogsService_TailLogsServer_Context_Call { + return &RunLogsService_TailLogsServer_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *RunLogsService_TailLogsServer_Context_Call) Run(run func()) *RunLogsService_TailLogsServer_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunLogsService_TailLogsServer_Context_Call) Return(_a0 context.Context) *RunLogsService_TailLogsServer_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunLogsService_TailLogsServer_Context_Call) RunAndReturn(run func() context.Context) *RunLogsService_TailLogsServer_Context_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *RunLogsService_TailLogsServer) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunLogsService_TailLogsServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type RunLogsService_TailLogsServer_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *RunLogsService_TailLogsServer_Expecter) RecvMsg(m interface{}) *RunLogsService_TailLogsServer_RecvMsg_Call { + return &RunLogsService_TailLogsServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *RunLogsService_TailLogsServer_RecvMsg_Call) Run(run func(m any)) *RunLogsService_TailLogsServer_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunLogsService_TailLogsServer_RecvMsg_Call) Return(_a0 error) *RunLogsService_TailLogsServer_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunLogsService_TailLogsServer_RecvMsg_Call) RunAndReturn(run func(any) error) *RunLogsService_TailLogsServer_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// Send provides a mock function with given fields: _a0 +func (_m *RunLogsService_TailLogsServer) Send(_a0 *workflow.TailLogsResponse) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for Send") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*workflow.TailLogsResponse) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunLogsService_TailLogsServer_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send' +type RunLogsService_TailLogsServer_Send_Call struct { + *mock.Call +} + +// Send is a helper method to define mock.On call +// - _a0 *workflow.TailLogsResponse +func (_e *RunLogsService_TailLogsServer_Expecter) Send(_a0 interface{}) *RunLogsService_TailLogsServer_Send_Call { + return &RunLogsService_TailLogsServer_Send_Call{Call: _e.mock.On("Send", _a0)} +} + +func (_c *RunLogsService_TailLogsServer_Send_Call) Run(run func(_a0 *workflow.TailLogsResponse)) *RunLogsService_TailLogsServer_Send_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*workflow.TailLogsResponse)) + }) + return _c +} + +func (_c *RunLogsService_TailLogsServer_Send_Call) Return(_a0 error) *RunLogsService_TailLogsServer_Send_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunLogsService_TailLogsServer_Send_Call) RunAndReturn(run func(*workflow.TailLogsResponse) error) *RunLogsService_TailLogsServer_Send_Call { + _c.Call.Return(run) + return _c +} + +// SendHeader provides a mock function with given fields: _a0 +func (_m *RunLogsService_TailLogsServer) SendHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SendHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunLogsService_TailLogsServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader' +type RunLogsService_TailLogsServer_SendHeader_Call struct { + *mock.Call +} + +// SendHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunLogsService_TailLogsServer_Expecter) SendHeader(_a0 interface{}) *RunLogsService_TailLogsServer_SendHeader_Call { + return &RunLogsService_TailLogsServer_SendHeader_Call{Call: _e.mock.On("SendHeader", _a0)} +} + +func (_c *RunLogsService_TailLogsServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *RunLogsService_TailLogsServer_SendHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunLogsService_TailLogsServer_SendHeader_Call) Return(_a0 error) *RunLogsService_TailLogsServer_SendHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunLogsService_TailLogsServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *RunLogsService_TailLogsServer_SendHeader_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *RunLogsService_TailLogsServer) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunLogsService_TailLogsServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type RunLogsService_TailLogsServer_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *RunLogsService_TailLogsServer_Expecter) SendMsg(m interface{}) *RunLogsService_TailLogsServer_SendMsg_Call { + return &RunLogsService_TailLogsServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *RunLogsService_TailLogsServer_SendMsg_Call) Run(run func(m any)) *RunLogsService_TailLogsServer_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunLogsService_TailLogsServer_SendMsg_Call) Return(_a0 error) *RunLogsService_TailLogsServer_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunLogsService_TailLogsServer_SendMsg_Call) RunAndReturn(run func(any) error) *RunLogsService_TailLogsServer_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// SetHeader provides a mock function with given fields: _a0 +func (_m *RunLogsService_TailLogsServer) SetHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SetHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunLogsService_TailLogsServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader' +type RunLogsService_TailLogsServer_SetHeader_Call struct { + *mock.Call +} + +// SetHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunLogsService_TailLogsServer_Expecter) SetHeader(_a0 interface{}) *RunLogsService_TailLogsServer_SetHeader_Call { + return &RunLogsService_TailLogsServer_SetHeader_Call{Call: _e.mock.On("SetHeader", _a0)} +} + +func (_c *RunLogsService_TailLogsServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *RunLogsService_TailLogsServer_SetHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunLogsService_TailLogsServer_SetHeader_Call) Return(_a0 error) *RunLogsService_TailLogsServer_SetHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunLogsService_TailLogsServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *RunLogsService_TailLogsServer_SetHeader_Call { + _c.Call.Return(run) + return _c +} + +// SetTrailer provides a mock function with given fields: _a0 +func (_m *RunLogsService_TailLogsServer) SetTrailer(_a0 metadata.MD) { + _m.Called(_a0) +} + +// RunLogsService_TailLogsServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer' +type RunLogsService_TailLogsServer_SetTrailer_Call struct { + *mock.Call +} + +// SetTrailer is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunLogsService_TailLogsServer_Expecter) SetTrailer(_a0 interface{}) *RunLogsService_TailLogsServer_SetTrailer_Call { + return &RunLogsService_TailLogsServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", _a0)} +} + +func (_c *RunLogsService_TailLogsServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *RunLogsService_TailLogsServer_SetTrailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunLogsService_TailLogsServer_SetTrailer_Call) Return() *RunLogsService_TailLogsServer_SetTrailer_Call { + _c.Call.Return() + return _c +} + +func (_c *RunLogsService_TailLogsServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *RunLogsService_TailLogsServer_SetTrailer_Call { + _c.Run(run) + return _c +} + +// NewRunLogsService_TailLogsServer creates a new instance of RunLogsService_TailLogsServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunLogsService_TailLogsServer(t interface { + mock.TestingT + Cleanup(func()) +}) *RunLogsService_TailLogsServer { + mock := &RunLogsService_TailLogsServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/run_service_client.go b/gen/go/flyteidl2/workflow/mocks/run_service_client.go new file mode 100644 index 0000000000..f10c704109 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/run_service_client.go @@ -0,0 +1,1076 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + grpc "google.golang.org/grpc" + + mock "github.com/stretchr/testify/mock" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunServiceClient is an autogenerated mock type for the RunServiceClient type +type RunServiceClient struct { + mock.Mock +} + +type RunServiceClient_Expecter struct { + mock *mock.Mock +} + +func (_m *RunServiceClient) EXPECT() *RunServiceClient_Expecter { + return &RunServiceClient_Expecter{mock: &_m.Mock} +} + +// AbortAction provides a mock function with given fields: ctx, in, opts +func (_m *RunServiceClient) AbortAction(ctx context.Context, in *workflow.AbortActionRequest, opts ...grpc.CallOption) (*workflow.AbortActionResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AbortAction") + } + + var r0 *workflow.AbortActionResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.AbortActionRequest, ...grpc.CallOption) (*workflow.AbortActionResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.AbortActionRequest, ...grpc.CallOption) *workflow.AbortActionResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.AbortActionResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.AbortActionRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_AbortAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortAction' +type RunServiceClient_AbortAction_Call struct { + *mock.Call +} + +// AbortAction is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.AbortActionRequest +// - opts ...grpc.CallOption +func (_e *RunServiceClient_Expecter) AbortAction(ctx interface{}, in interface{}, opts ...interface{}) *RunServiceClient_AbortAction_Call { + return &RunServiceClient_AbortAction_Call{Call: _e.mock.On("AbortAction", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *RunServiceClient_AbortAction_Call) Run(run func(ctx context.Context, in *workflow.AbortActionRequest, opts ...grpc.CallOption)) *RunServiceClient_AbortAction_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.AbortActionRequest), variadicArgs...) + }) + return _c +} + +func (_c *RunServiceClient_AbortAction_Call) Return(_a0 *workflow.AbortActionResponse, _a1 error) *RunServiceClient_AbortAction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_AbortAction_Call) RunAndReturn(run func(context.Context, *workflow.AbortActionRequest, ...grpc.CallOption) (*workflow.AbortActionResponse, error)) *RunServiceClient_AbortAction_Call { + _c.Call.Return(run) + return _c +} + +// AbortRun provides a mock function with given fields: ctx, in, opts +func (_m *RunServiceClient) AbortRun(ctx context.Context, in *workflow.AbortRunRequest, opts ...grpc.CallOption) (*workflow.AbortRunResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AbortRun") + } + + var r0 *workflow.AbortRunResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.AbortRunRequest, ...grpc.CallOption) (*workflow.AbortRunResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.AbortRunRequest, ...grpc.CallOption) *workflow.AbortRunResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.AbortRunResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.AbortRunRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_AbortRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortRun' +type RunServiceClient_AbortRun_Call struct { + *mock.Call +} + +// AbortRun is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.AbortRunRequest +// - opts ...grpc.CallOption +func (_e *RunServiceClient_Expecter) AbortRun(ctx interface{}, in interface{}, opts ...interface{}) *RunServiceClient_AbortRun_Call { + return &RunServiceClient_AbortRun_Call{Call: _e.mock.On("AbortRun", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *RunServiceClient_AbortRun_Call) Run(run func(ctx context.Context, in *workflow.AbortRunRequest, opts ...grpc.CallOption)) *RunServiceClient_AbortRun_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.AbortRunRequest), variadicArgs...) + }) + return _c +} + +func (_c *RunServiceClient_AbortRun_Call) Return(_a0 *workflow.AbortRunResponse, _a1 error) *RunServiceClient_AbortRun_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_AbortRun_Call) RunAndReturn(run func(context.Context, *workflow.AbortRunRequest, ...grpc.CallOption) (*workflow.AbortRunResponse, error)) *RunServiceClient_AbortRun_Call { + _c.Call.Return(run) + return _c +} + +// CreateRun provides a mock function with given fields: ctx, in, opts +func (_m *RunServiceClient) CreateRun(ctx context.Context, in *workflow.CreateRunRequest, opts ...grpc.CallOption) (*workflow.CreateRunResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateRun") + } + + var r0 *workflow.CreateRunResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.CreateRunRequest, ...grpc.CallOption) (*workflow.CreateRunResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.CreateRunRequest, ...grpc.CallOption) *workflow.CreateRunResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.CreateRunResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.CreateRunRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_CreateRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRun' +type RunServiceClient_CreateRun_Call struct { + *mock.Call +} + +// CreateRun is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.CreateRunRequest +// - opts ...grpc.CallOption +func (_e *RunServiceClient_Expecter) CreateRun(ctx interface{}, in interface{}, opts ...interface{}) *RunServiceClient_CreateRun_Call { + return &RunServiceClient_CreateRun_Call{Call: _e.mock.On("CreateRun", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *RunServiceClient_CreateRun_Call) Run(run func(ctx context.Context, in *workflow.CreateRunRequest, opts ...grpc.CallOption)) *RunServiceClient_CreateRun_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.CreateRunRequest), variadicArgs...) + }) + return _c +} + +func (_c *RunServiceClient_CreateRun_Call) Return(_a0 *workflow.CreateRunResponse, _a1 error) *RunServiceClient_CreateRun_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_CreateRun_Call) RunAndReturn(run func(context.Context, *workflow.CreateRunRequest, ...grpc.CallOption) (*workflow.CreateRunResponse, error)) *RunServiceClient_CreateRun_Call { + _c.Call.Return(run) + return _c +} + +// GetActionData provides a mock function with given fields: ctx, in, opts +func (_m *RunServiceClient) GetActionData(ctx context.Context, in *workflow.GetActionDataRequest, opts ...grpc.CallOption) (*workflow.GetActionDataResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetActionData") + } + + var r0 *workflow.GetActionDataResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.GetActionDataRequest, ...grpc.CallOption) (*workflow.GetActionDataResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.GetActionDataRequest, ...grpc.CallOption) *workflow.GetActionDataResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.GetActionDataResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.GetActionDataRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_GetActionData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActionData' +type RunServiceClient_GetActionData_Call struct { + *mock.Call +} + +// GetActionData is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.GetActionDataRequest +// - opts ...grpc.CallOption +func (_e *RunServiceClient_Expecter) GetActionData(ctx interface{}, in interface{}, opts ...interface{}) *RunServiceClient_GetActionData_Call { + return &RunServiceClient_GetActionData_Call{Call: _e.mock.On("GetActionData", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *RunServiceClient_GetActionData_Call) Run(run func(ctx context.Context, in *workflow.GetActionDataRequest, opts ...grpc.CallOption)) *RunServiceClient_GetActionData_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.GetActionDataRequest), variadicArgs...) + }) + return _c +} + +func (_c *RunServiceClient_GetActionData_Call) Return(_a0 *workflow.GetActionDataResponse, _a1 error) *RunServiceClient_GetActionData_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_GetActionData_Call) RunAndReturn(run func(context.Context, *workflow.GetActionDataRequest, ...grpc.CallOption) (*workflow.GetActionDataResponse, error)) *RunServiceClient_GetActionData_Call { + _c.Call.Return(run) + return _c +} + +// GetActionDetails provides a mock function with given fields: ctx, in, opts +func (_m *RunServiceClient) GetActionDetails(ctx context.Context, in *workflow.GetActionDetailsRequest, opts ...grpc.CallOption) (*workflow.GetActionDetailsResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetActionDetails") + } + + var r0 *workflow.GetActionDetailsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.GetActionDetailsRequest, ...grpc.CallOption) (*workflow.GetActionDetailsResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.GetActionDetailsRequest, ...grpc.CallOption) *workflow.GetActionDetailsResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.GetActionDetailsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.GetActionDetailsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_GetActionDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActionDetails' +type RunServiceClient_GetActionDetails_Call struct { + *mock.Call +} + +// GetActionDetails is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.GetActionDetailsRequest +// - opts ...grpc.CallOption +func (_e *RunServiceClient_Expecter) GetActionDetails(ctx interface{}, in interface{}, opts ...interface{}) *RunServiceClient_GetActionDetails_Call { + return &RunServiceClient_GetActionDetails_Call{Call: _e.mock.On("GetActionDetails", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *RunServiceClient_GetActionDetails_Call) Run(run func(ctx context.Context, in *workflow.GetActionDetailsRequest, opts ...grpc.CallOption)) *RunServiceClient_GetActionDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.GetActionDetailsRequest), variadicArgs...) + }) + return _c +} + +func (_c *RunServiceClient_GetActionDetails_Call) Return(_a0 *workflow.GetActionDetailsResponse, _a1 error) *RunServiceClient_GetActionDetails_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_GetActionDetails_Call) RunAndReturn(run func(context.Context, *workflow.GetActionDetailsRequest, ...grpc.CallOption) (*workflow.GetActionDetailsResponse, error)) *RunServiceClient_GetActionDetails_Call { + _c.Call.Return(run) + return _c +} + +// GetRunDetails provides a mock function with given fields: ctx, in, opts +func (_m *RunServiceClient) GetRunDetails(ctx context.Context, in *workflow.GetRunDetailsRequest, opts ...grpc.CallOption) (*workflow.GetRunDetailsResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetRunDetails") + } + + var r0 *workflow.GetRunDetailsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.GetRunDetailsRequest, ...grpc.CallOption) (*workflow.GetRunDetailsResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.GetRunDetailsRequest, ...grpc.CallOption) *workflow.GetRunDetailsResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.GetRunDetailsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.GetRunDetailsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_GetRunDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRunDetails' +type RunServiceClient_GetRunDetails_Call struct { + *mock.Call +} + +// GetRunDetails is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.GetRunDetailsRequest +// - opts ...grpc.CallOption +func (_e *RunServiceClient_Expecter) GetRunDetails(ctx interface{}, in interface{}, opts ...interface{}) *RunServiceClient_GetRunDetails_Call { + return &RunServiceClient_GetRunDetails_Call{Call: _e.mock.On("GetRunDetails", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *RunServiceClient_GetRunDetails_Call) Run(run func(ctx context.Context, in *workflow.GetRunDetailsRequest, opts ...grpc.CallOption)) *RunServiceClient_GetRunDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.GetRunDetailsRequest), variadicArgs...) + }) + return _c +} + +func (_c *RunServiceClient_GetRunDetails_Call) Return(_a0 *workflow.GetRunDetailsResponse, _a1 error) *RunServiceClient_GetRunDetails_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_GetRunDetails_Call) RunAndReturn(run func(context.Context, *workflow.GetRunDetailsRequest, ...grpc.CallOption) (*workflow.GetRunDetailsResponse, error)) *RunServiceClient_GetRunDetails_Call { + _c.Call.Return(run) + return _c +} + +// ListActions provides a mock function with given fields: ctx, in, opts +func (_m *RunServiceClient) ListActions(ctx context.Context, in *workflow.ListActionsRequest, opts ...grpc.CallOption) (*workflow.ListActionsResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListActions") + } + + var r0 *workflow.ListActionsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.ListActionsRequest, ...grpc.CallOption) (*workflow.ListActionsResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.ListActionsRequest, ...grpc.CallOption) *workflow.ListActionsResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.ListActionsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.ListActionsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_ListActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListActions' +type RunServiceClient_ListActions_Call struct { + *mock.Call +} + +// ListActions is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.ListActionsRequest +// - opts ...grpc.CallOption +func (_e *RunServiceClient_Expecter) ListActions(ctx interface{}, in interface{}, opts ...interface{}) *RunServiceClient_ListActions_Call { + return &RunServiceClient_ListActions_Call{Call: _e.mock.On("ListActions", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *RunServiceClient_ListActions_Call) Run(run func(ctx context.Context, in *workflow.ListActionsRequest, opts ...grpc.CallOption)) *RunServiceClient_ListActions_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.ListActionsRequest), variadicArgs...) + }) + return _c +} + +func (_c *RunServiceClient_ListActions_Call) Return(_a0 *workflow.ListActionsResponse, _a1 error) *RunServiceClient_ListActions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_ListActions_Call) RunAndReturn(run func(context.Context, *workflow.ListActionsRequest, ...grpc.CallOption) (*workflow.ListActionsResponse, error)) *RunServiceClient_ListActions_Call { + _c.Call.Return(run) + return _c +} + +// ListRuns provides a mock function with given fields: ctx, in, opts +func (_m *RunServiceClient) ListRuns(ctx context.Context, in *workflow.ListRunsRequest, opts ...grpc.CallOption) (*workflow.ListRunsResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListRuns") + } + + var r0 *workflow.ListRunsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.ListRunsRequest, ...grpc.CallOption) (*workflow.ListRunsResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.ListRunsRequest, ...grpc.CallOption) *workflow.ListRunsResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.ListRunsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.ListRunsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_ListRuns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRuns' +type RunServiceClient_ListRuns_Call struct { + *mock.Call +} + +// ListRuns is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.ListRunsRequest +// - opts ...grpc.CallOption +func (_e *RunServiceClient_Expecter) ListRuns(ctx interface{}, in interface{}, opts ...interface{}) *RunServiceClient_ListRuns_Call { + return &RunServiceClient_ListRuns_Call{Call: _e.mock.On("ListRuns", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *RunServiceClient_ListRuns_Call) Run(run func(ctx context.Context, in *workflow.ListRunsRequest, opts ...grpc.CallOption)) *RunServiceClient_ListRuns_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.ListRunsRequest), variadicArgs...) + }) + return _c +} + +func (_c *RunServiceClient_ListRuns_Call) Return(_a0 *workflow.ListRunsResponse, _a1 error) *RunServiceClient_ListRuns_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_ListRuns_Call) RunAndReturn(run func(context.Context, *workflow.ListRunsRequest, ...grpc.CallOption) (*workflow.ListRunsResponse, error)) *RunServiceClient_ListRuns_Call { + _c.Call.Return(run) + return _c +} + +// WatchActionDetails provides a mock function with given fields: ctx, in, opts +func (_m *RunServiceClient) WatchActionDetails(ctx context.Context, in *workflow.WatchActionDetailsRequest, opts ...grpc.CallOption) (workflow.RunService_WatchActionDetailsClient, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for WatchActionDetails") + } + + var r0 workflow.RunService_WatchActionDetailsClient + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.WatchActionDetailsRequest, ...grpc.CallOption) (workflow.RunService_WatchActionDetailsClient, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.WatchActionDetailsRequest, ...grpc.CallOption) workflow.RunService_WatchActionDetailsClient); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(workflow.RunService_WatchActionDetailsClient) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.WatchActionDetailsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_WatchActionDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchActionDetails' +type RunServiceClient_WatchActionDetails_Call struct { + *mock.Call +} + +// WatchActionDetails is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.WatchActionDetailsRequest +// - opts ...grpc.CallOption +func (_e *RunServiceClient_Expecter) WatchActionDetails(ctx interface{}, in interface{}, opts ...interface{}) *RunServiceClient_WatchActionDetails_Call { + return &RunServiceClient_WatchActionDetails_Call{Call: _e.mock.On("WatchActionDetails", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *RunServiceClient_WatchActionDetails_Call) Run(run func(ctx context.Context, in *workflow.WatchActionDetailsRequest, opts ...grpc.CallOption)) *RunServiceClient_WatchActionDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.WatchActionDetailsRequest), variadicArgs...) + }) + return _c +} + +func (_c *RunServiceClient_WatchActionDetails_Call) Return(_a0 workflow.RunService_WatchActionDetailsClient, _a1 error) *RunServiceClient_WatchActionDetails_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_WatchActionDetails_Call) RunAndReturn(run func(context.Context, *workflow.WatchActionDetailsRequest, ...grpc.CallOption) (workflow.RunService_WatchActionDetailsClient, error)) *RunServiceClient_WatchActionDetails_Call { + _c.Call.Return(run) + return _c +} + +// WatchActions provides a mock function with given fields: ctx, in, opts +func (_m *RunServiceClient) WatchActions(ctx context.Context, in *workflow.WatchActionsRequest, opts ...grpc.CallOption) (workflow.RunService_WatchActionsClient, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for WatchActions") + } + + var r0 workflow.RunService_WatchActionsClient + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.WatchActionsRequest, ...grpc.CallOption) (workflow.RunService_WatchActionsClient, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.WatchActionsRequest, ...grpc.CallOption) workflow.RunService_WatchActionsClient); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(workflow.RunService_WatchActionsClient) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.WatchActionsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_WatchActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchActions' +type RunServiceClient_WatchActions_Call struct { + *mock.Call +} + +// WatchActions is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.WatchActionsRequest +// - opts ...grpc.CallOption +func (_e *RunServiceClient_Expecter) WatchActions(ctx interface{}, in interface{}, opts ...interface{}) *RunServiceClient_WatchActions_Call { + return &RunServiceClient_WatchActions_Call{Call: _e.mock.On("WatchActions", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *RunServiceClient_WatchActions_Call) Run(run func(ctx context.Context, in *workflow.WatchActionsRequest, opts ...grpc.CallOption)) *RunServiceClient_WatchActions_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.WatchActionsRequest), variadicArgs...) + }) + return _c +} + +func (_c *RunServiceClient_WatchActions_Call) Return(_a0 workflow.RunService_WatchActionsClient, _a1 error) *RunServiceClient_WatchActions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_WatchActions_Call) RunAndReturn(run func(context.Context, *workflow.WatchActionsRequest, ...grpc.CallOption) (workflow.RunService_WatchActionsClient, error)) *RunServiceClient_WatchActions_Call { + _c.Call.Return(run) + return _c +} + +// WatchClusterEvents provides a mock function with given fields: ctx, in, opts +func (_m *RunServiceClient) WatchClusterEvents(ctx context.Context, in *workflow.WatchClusterEventsRequest, opts ...grpc.CallOption) (workflow.RunService_WatchClusterEventsClient, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for WatchClusterEvents") + } + + var r0 workflow.RunService_WatchClusterEventsClient + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.WatchClusterEventsRequest, ...grpc.CallOption) (workflow.RunService_WatchClusterEventsClient, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.WatchClusterEventsRequest, ...grpc.CallOption) workflow.RunService_WatchClusterEventsClient); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(workflow.RunService_WatchClusterEventsClient) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.WatchClusterEventsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_WatchClusterEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchClusterEvents' +type RunServiceClient_WatchClusterEvents_Call struct { + *mock.Call +} + +// WatchClusterEvents is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.WatchClusterEventsRequest +// - opts ...grpc.CallOption +func (_e *RunServiceClient_Expecter) WatchClusterEvents(ctx interface{}, in interface{}, opts ...interface{}) *RunServiceClient_WatchClusterEvents_Call { + return &RunServiceClient_WatchClusterEvents_Call{Call: _e.mock.On("WatchClusterEvents", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *RunServiceClient_WatchClusterEvents_Call) Run(run func(ctx context.Context, in *workflow.WatchClusterEventsRequest, opts ...grpc.CallOption)) *RunServiceClient_WatchClusterEvents_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.WatchClusterEventsRequest), variadicArgs...) + }) + return _c +} + +func (_c *RunServiceClient_WatchClusterEvents_Call) Return(_a0 workflow.RunService_WatchClusterEventsClient, _a1 error) *RunServiceClient_WatchClusterEvents_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_WatchClusterEvents_Call) RunAndReturn(run func(context.Context, *workflow.WatchClusterEventsRequest, ...grpc.CallOption) (workflow.RunService_WatchClusterEventsClient, error)) *RunServiceClient_WatchClusterEvents_Call { + _c.Call.Return(run) + return _c +} + +// WatchGroups provides a mock function with given fields: ctx, in, opts +func (_m *RunServiceClient) WatchGroups(ctx context.Context, in *workflow.WatchGroupsRequest, opts ...grpc.CallOption) (workflow.RunService_WatchGroupsClient, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for WatchGroups") + } + + var r0 workflow.RunService_WatchGroupsClient + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.WatchGroupsRequest, ...grpc.CallOption) (workflow.RunService_WatchGroupsClient, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.WatchGroupsRequest, ...grpc.CallOption) workflow.RunService_WatchGroupsClient); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(workflow.RunService_WatchGroupsClient) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.WatchGroupsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_WatchGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchGroups' +type RunServiceClient_WatchGroups_Call struct { + *mock.Call +} + +// WatchGroups is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.WatchGroupsRequest +// - opts ...grpc.CallOption +func (_e *RunServiceClient_Expecter) WatchGroups(ctx interface{}, in interface{}, opts ...interface{}) *RunServiceClient_WatchGroups_Call { + return &RunServiceClient_WatchGroups_Call{Call: _e.mock.On("WatchGroups", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *RunServiceClient_WatchGroups_Call) Run(run func(ctx context.Context, in *workflow.WatchGroupsRequest, opts ...grpc.CallOption)) *RunServiceClient_WatchGroups_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.WatchGroupsRequest), variadicArgs...) + }) + return _c +} + +func (_c *RunServiceClient_WatchGroups_Call) Return(_a0 workflow.RunService_WatchGroupsClient, _a1 error) *RunServiceClient_WatchGroups_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_WatchGroups_Call) RunAndReturn(run func(context.Context, *workflow.WatchGroupsRequest, ...grpc.CallOption) (workflow.RunService_WatchGroupsClient, error)) *RunServiceClient_WatchGroups_Call { + _c.Call.Return(run) + return _c +} + +// WatchRunDetails provides a mock function with given fields: ctx, in, opts +func (_m *RunServiceClient) WatchRunDetails(ctx context.Context, in *workflow.WatchRunDetailsRequest, opts ...grpc.CallOption) (workflow.RunService_WatchRunDetailsClient, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for WatchRunDetails") + } + + var r0 workflow.RunService_WatchRunDetailsClient + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.WatchRunDetailsRequest, ...grpc.CallOption) (workflow.RunService_WatchRunDetailsClient, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.WatchRunDetailsRequest, ...grpc.CallOption) workflow.RunService_WatchRunDetailsClient); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(workflow.RunService_WatchRunDetailsClient) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.WatchRunDetailsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_WatchRunDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchRunDetails' +type RunServiceClient_WatchRunDetails_Call struct { + *mock.Call +} + +// WatchRunDetails is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.WatchRunDetailsRequest +// - opts ...grpc.CallOption +func (_e *RunServiceClient_Expecter) WatchRunDetails(ctx interface{}, in interface{}, opts ...interface{}) *RunServiceClient_WatchRunDetails_Call { + return &RunServiceClient_WatchRunDetails_Call{Call: _e.mock.On("WatchRunDetails", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *RunServiceClient_WatchRunDetails_Call) Run(run func(ctx context.Context, in *workflow.WatchRunDetailsRequest, opts ...grpc.CallOption)) *RunServiceClient_WatchRunDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.WatchRunDetailsRequest), variadicArgs...) + }) + return _c +} + +func (_c *RunServiceClient_WatchRunDetails_Call) Return(_a0 workflow.RunService_WatchRunDetailsClient, _a1 error) *RunServiceClient_WatchRunDetails_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_WatchRunDetails_Call) RunAndReturn(run func(context.Context, *workflow.WatchRunDetailsRequest, ...grpc.CallOption) (workflow.RunService_WatchRunDetailsClient, error)) *RunServiceClient_WatchRunDetails_Call { + _c.Call.Return(run) + return _c +} + +// WatchRuns provides a mock function with given fields: ctx, in, opts +func (_m *RunServiceClient) WatchRuns(ctx context.Context, in *workflow.WatchRunsRequest, opts ...grpc.CallOption) (workflow.RunService_WatchRunsClient, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for WatchRuns") + } + + var r0 workflow.RunService_WatchRunsClient + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.WatchRunsRequest, ...grpc.CallOption) (workflow.RunService_WatchRunsClient, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.WatchRunsRequest, ...grpc.CallOption) workflow.RunService_WatchRunsClient); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(workflow.RunService_WatchRunsClient) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.WatchRunsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_WatchRuns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchRuns' +type RunServiceClient_WatchRuns_Call struct { + *mock.Call +} + +// WatchRuns is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.WatchRunsRequest +// - opts ...grpc.CallOption +func (_e *RunServiceClient_Expecter) WatchRuns(ctx interface{}, in interface{}, opts ...interface{}) *RunServiceClient_WatchRuns_Call { + return &RunServiceClient_WatchRuns_Call{Call: _e.mock.On("WatchRuns", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *RunServiceClient_WatchRuns_Call) Run(run func(ctx context.Context, in *workflow.WatchRunsRequest, opts ...grpc.CallOption)) *RunServiceClient_WatchRuns_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.WatchRunsRequest), variadicArgs...) + }) + return _c +} + +func (_c *RunServiceClient_WatchRuns_Call) Return(_a0 workflow.RunService_WatchRunsClient, _a1 error) *RunServiceClient_WatchRuns_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_WatchRuns_Call) RunAndReturn(run func(context.Context, *workflow.WatchRunsRequest, ...grpc.CallOption) (workflow.RunService_WatchRunsClient, error)) *RunServiceClient_WatchRuns_Call { + _c.Call.Return(run) + return _c +} + +// NewRunServiceClient creates a new instance of RunServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunServiceClient(t interface { + mock.TestingT + Cleanup(func()) +}) *RunServiceClient { + mock := &RunServiceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/run_service_server.go b/gen/go/flyteidl2/workflow/mocks/run_service_server.go new file mode 100644 index 0000000000..8bd5b0ea3d --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/run_service_server.go @@ -0,0 +1,791 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + mock "github.com/stretchr/testify/mock" +) + +// RunServiceServer is an autogenerated mock type for the RunServiceServer type +type RunServiceServer struct { + mock.Mock +} + +type RunServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *RunServiceServer) EXPECT() *RunServiceServer_Expecter { + return &RunServiceServer_Expecter{mock: &_m.Mock} +} + +// AbortAction provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceServer) AbortAction(_a0 context.Context, _a1 *workflow.AbortActionRequest) (*workflow.AbortActionResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for AbortAction") + } + + var r0 *workflow.AbortActionResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.AbortActionRequest) (*workflow.AbortActionResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.AbortActionRequest) *workflow.AbortActionResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.AbortActionResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.AbortActionRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceServer_AbortAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortAction' +type RunServiceServer_AbortAction_Call struct { + *mock.Call +} + +// AbortAction is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *workflow.AbortActionRequest +func (_e *RunServiceServer_Expecter) AbortAction(_a0 interface{}, _a1 interface{}) *RunServiceServer_AbortAction_Call { + return &RunServiceServer_AbortAction_Call{Call: _e.mock.On("AbortAction", _a0, _a1)} +} + +func (_c *RunServiceServer_AbortAction_Call) Run(run func(_a0 context.Context, _a1 *workflow.AbortActionRequest)) *RunServiceServer_AbortAction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.AbortActionRequest)) + }) + return _c +} + +func (_c *RunServiceServer_AbortAction_Call) Return(_a0 *workflow.AbortActionResponse, _a1 error) *RunServiceServer_AbortAction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceServer_AbortAction_Call) RunAndReturn(run func(context.Context, *workflow.AbortActionRequest) (*workflow.AbortActionResponse, error)) *RunServiceServer_AbortAction_Call { + _c.Call.Return(run) + return _c +} + +// AbortRun provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceServer) AbortRun(_a0 context.Context, _a1 *workflow.AbortRunRequest) (*workflow.AbortRunResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for AbortRun") + } + + var r0 *workflow.AbortRunResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.AbortRunRequest) (*workflow.AbortRunResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.AbortRunRequest) *workflow.AbortRunResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.AbortRunResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.AbortRunRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceServer_AbortRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortRun' +type RunServiceServer_AbortRun_Call struct { + *mock.Call +} + +// AbortRun is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *workflow.AbortRunRequest +func (_e *RunServiceServer_Expecter) AbortRun(_a0 interface{}, _a1 interface{}) *RunServiceServer_AbortRun_Call { + return &RunServiceServer_AbortRun_Call{Call: _e.mock.On("AbortRun", _a0, _a1)} +} + +func (_c *RunServiceServer_AbortRun_Call) Run(run func(_a0 context.Context, _a1 *workflow.AbortRunRequest)) *RunServiceServer_AbortRun_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.AbortRunRequest)) + }) + return _c +} + +func (_c *RunServiceServer_AbortRun_Call) Return(_a0 *workflow.AbortRunResponse, _a1 error) *RunServiceServer_AbortRun_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceServer_AbortRun_Call) RunAndReturn(run func(context.Context, *workflow.AbortRunRequest) (*workflow.AbortRunResponse, error)) *RunServiceServer_AbortRun_Call { + _c.Call.Return(run) + return _c +} + +// CreateRun provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceServer) CreateRun(_a0 context.Context, _a1 *workflow.CreateRunRequest) (*workflow.CreateRunResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for CreateRun") + } + + var r0 *workflow.CreateRunResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.CreateRunRequest) (*workflow.CreateRunResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.CreateRunRequest) *workflow.CreateRunResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.CreateRunResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.CreateRunRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceServer_CreateRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRun' +type RunServiceServer_CreateRun_Call struct { + *mock.Call +} + +// CreateRun is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *workflow.CreateRunRequest +func (_e *RunServiceServer_Expecter) CreateRun(_a0 interface{}, _a1 interface{}) *RunServiceServer_CreateRun_Call { + return &RunServiceServer_CreateRun_Call{Call: _e.mock.On("CreateRun", _a0, _a1)} +} + +func (_c *RunServiceServer_CreateRun_Call) Run(run func(_a0 context.Context, _a1 *workflow.CreateRunRequest)) *RunServiceServer_CreateRun_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.CreateRunRequest)) + }) + return _c +} + +func (_c *RunServiceServer_CreateRun_Call) Return(_a0 *workflow.CreateRunResponse, _a1 error) *RunServiceServer_CreateRun_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceServer_CreateRun_Call) RunAndReturn(run func(context.Context, *workflow.CreateRunRequest) (*workflow.CreateRunResponse, error)) *RunServiceServer_CreateRun_Call { + _c.Call.Return(run) + return _c +} + +// GetActionData provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceServer) GetActionData(_a0 context.Context, _a1 *workflow.GetActionDataRequest) (*workflow.GetActionDataResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetActionData") + } + + var r0 *workflow.GetActionDataResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.GetActionDataRequest) (*workflow.GetActionDataResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.GetActionDataRequest) *workflow.GetActionDataResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.GetActionDataResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.GetActionDataRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceServer_GetActionData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActionData' +type RunServiceServer_GetActionData_Call struct { + *mock.Call +} + +// GetActionData is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *workflow.GetActionDataRequest +func (_e *RunServiceServer_Expecter) GetActionData(_a0 interface{}, _a1 interface{}) *RunServiceServer_GetActionData_Call { + return &RunServiceServer_GetActionData_Call{Call: _e.mock.On("GetActionData", _a0, _a1)} +} + +func (_c *RunServiceServer_GetActionData_Call) Run(run func(_a0 context.Context, _a1 *workflow.GetActionDataRequest)) *RunServiceServer_GetActionData_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.GetActionDataRequest)) + }) + return _c +} + +func (_c *RunServiceServer_GetActionData_Call) Return(_a0 *workflow.GetActionDataResponse, _a1 error) *RunServiceServer_GetActionData_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceServer_GetActionData_Call) RunAndReturn(run func(context.Context, *workflow.GetActionDataRequest) (*workflow.GetActionDataResponse, error)) *RunServiceServer_GetActionData_Call { + _c.Call.Return(run) + return _c +} + +// GetActionDetails provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceServer) GetActionDetails(_a0 context.Context, _a1 *workflow.GetActionDetailsRequest) (*workflow.GetActionDetailsResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetActionDetails") + } + + var r0 *workflow.GetActionDetailsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.GetActionDetailsRequest) (*workflow.GetActionDetailsResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.GetActionDetailsRequest) *workflow.GetActionDetailsResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.GetActionDetailsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.GetActionDetailsRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceServer_GetActionDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActionDetails' +type RunServiceServer_GetActionDetails_Call struct { + *mock.Call +} + +// GetActionDetails is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *workflow.GetActionDetailsRequest +func (_e *RunServiceServer_Expecter) GetActionDetails(_a0 interface{}, _a1 interface{}) *RunServiceServer_GetActionDetails_Call { + return &RunServiceServer_GetActionDetails_Call{Call: _e.mock.On("GetActionDetails", _a0, _a1)} +} + +func (_c *RunServiceServer_GetActionDetails_Call) Run(run func(_a0 context.Context, _a1 *workflow.GetActionDetailsRequest)) *RunServiceServer_GetActionDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.GetActionDetailsRequest)) + }) + return _c +} + +func (_c *RunServiceServer_GetActionDetails_Call) Return(_a0 *workflow.GetActionDetailsResponse, _a1 error) *RunServiceServer_GetActionDetails_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceServer_GetActionDetails_Call) RunAndReturn(run func(context.Context, *workflow.GetActionDetailsRequest) (*workflow.GetActionDetailsResponse, error)) *RunServiceServer_GetActionDetails_Call { + _c.Call.Return(run) + return _c +} + +// GetRunDetails provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceServer) GetRunDetails(_a0 context.Context, _a1 *workflow.GetRunDetailsRequest) (*workflow.GetRunDetailsResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetRunDetails") + } + + var r0 *workflow.GetRunDetailsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.GetRunDetailsRequest) (*workflow.GetRunDetailsResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.GetRunDetailsRequest) *workflow.GetRunDetailsResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.GetRunDetailsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.GetRunDetailsRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceServer_GetRunDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRunDetails' +type RunServiceServer_GetRunDetails_Call struct { + *mock.Call +} + +// GetRunDetails is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *workflow.GetRunDetailsRequest +func (_e *RunServiceServer_Expecter) GetRunDetails(_a0 interface{}, _a1 interface{}) *RunServiceServer_GetRunDetails_Call { + return &RunServiceServer_GetRunDetails_Call{Call: _e.mock.On("GetRunDetails", _a0, _a1)} +} + +func (_c *RunServiceServer_GetRunDetails_Call) Run(run func(_a0 context.Context, _a1 *workflow.GetRunDetailsRequest)) *RunServiceServer_GetRunDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.GetRunDetailsRequest)) + }) + return _c +} + +func (_c *RunServiceServer_GetRunDetails_Call) Return(_a0 *workflow.GetRunDetailsResponse, _a1 error) *RunServiceServer_GetRunDetails_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceServer_GetRunDetails_Call) RunAndReturn(run func(context.Context, *workflow.GetRunDetailsRequest) (*workflow.GetRunDetailsResponse, error)) *RunServiceServer_GetRunDetails_Call { + _c.Call.Return(run) + return _c +} + +// ListActions provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceServer) ListActions(_a0 context.Context, _a1 *workflow.ListActionsRequest) (*workflow.ListActionsResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for ListActions") + } + + var r0 *workflow.ListActionsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.ListActionsRequest) (*workflow.ListActionsResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.ListActionsRequest) *workflow.ListActionsResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.ListActionsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.ListActionsRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceServer_ListActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListActions' +type RunServiceServer_ListActions_Call struct { + *mock.Call +} + +// ListActions is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *workflow.ListActionsRequest +func (_e *RunServiceServer_Expecter) ListActions(_a0 interface{}, _a1 interface{}) *RunServiceServer_ListActions_Call { + return &RunServiceServer_ListActions_Call{Call: _e.mock.On("ListActions", _a0, _a1)} +} + +func (_c *RunServiceServer_ListActions_Call) Run(run func(_a0 context.Context, _a1 *workflow.ListActionsRequest)) *RunServiceServer_ListActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.ListActionsRequest)) + }) + return _c +} + +func (_c *RunServiceServer_ListActions_Call) Return(_a0 *workflow.ListActionsResponse, _a1 error) *RunServiceServer_ListActions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceServer_ListActions_Call) RunAndReturn(run func(context.Context, *workflow.ListActionsRequest) (*workflow.ListActionsResponse, error)) *RunServiceServer_ListActions_Call { + _c.Call.Return(run) + return _c +} + +// ListRuns provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceServer) ListRuns(_a0 context.Context, _a1 *workflow.ListRunsRequest) (*workflow.ListRunsResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for ListRuns") + } + + var r0 *workflow.ListRunsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.ListRunsRequest) (*workflow.ListRunsResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.ListRunsRequest) *workflow.ListRunsResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.ListRunsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.ListRunsRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceServer_ListRuns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRuns' +type RunServiceServer_ListRuns_Call struct { + *mock.Call +} + +// ListRuns is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *workflow.ListRunsRequest +func (_e *RunServiceServer_Expecter) ListRuns(_a0 interface{}, _a1 interface{}) *RunServiceServer_ListRuns_Call { + return &RunServiceServer_ListRuns_Call{Call: _e.mock.On("ListRuns", _a0, _a1)} +} + +func (_c *RunServiceServer_ListRuns_Call) Run(run func(_a0 context.Context, _a1 *workflow.ListRunsRequest)) *RunServiceServer_ListRuns_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.ListRunsRequest)) + }) + return _c +} + +func (_c *RunServiceServer_ListRuns_Call) Return(_a0 *workflow.ListRunsResponse, _a1 error) *RunServiceServer_ListRuns_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceServer_ListRuns_Call) RunAndReturn(run func(context.Context, *workflow.ListRunsRequest) (*workflow.ListRunsResponse, error)) *RunServiceServer_ListRuns_Call { + _c.Call.Return(run) + return _c +} + +// WatchActionDetails provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceServer) WatchActionDetails(_a0 *workflow.WatchActionDetailsRequest, _a1 workflow.RunService_WatchActionDetailsServer) error { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for WatchActionDetails") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*workflow.WatchActionDetailsRequest, workflow.RunService_WatchActionDetailsServer) error); ok { + r0 = rf(_a0, _a1) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunServiceServer_WatchActionDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchActionDetails' +type RunServiceServer_WatchActionDetails_Call struct { + *mock.Call +} + +// WatchActionDetails is a helper method to define mock.On call +// - _a0 *workflow.WatchActionDetailsRequest +// - _a1 workflow.RunService_WatchActionDetailsServer +func (_e *RunServiceServer_Expecter) WatchActionDetails(_a0 interface{}, _a1 interface{}) *RunServiceServer_WatchActionDetails_Call { + return &RunServiceServer_WatchActionDetails_Call{Call: _e.mock.On("WatchActionDetails", _a0, _a1)} +} + +func (_c *RunServiceServer_WatchActionDetails_Call) Run(run func(_a0 *workflow.WatchActionDetailsRequest, _a1 workflow.RunService_WatchActionDetailsServer)) *RunServiceServer_WatchActionDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*workflow.WatchActionDetailsRequest), args[1].(workflow.RunService_WatchActionDetailsServer)) + }) + return _c +} + +func (_c *RunServiceServer_WatchActionDetails_Call) Return(_a0 error) *RunServiceServer_WatchActionDetails_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunServiceServer_WatchActionDetails_Call) RunAndReturn(run func(*workflow.WatchActionDetailsRequest, workflow.RunService_WatchActionDetailsServer) error) *RunServiceServer_WatchActionDetails_Call { + _c.Call.Return(run) + return _c +} + +// WatchActions provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceServer) WatchActions(_a0 *workflow.WatchActionsRequest, _a1 workflow.RunService_WatchActionsServer) error { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for WatchActions") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*workflow.WatchActionsRequest, workflow.RunService_WatchActionsServer) error); ok { + r0 = rf(_a0, _a1) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunServiceServer_WatchActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchActions' +type RunServiceServer_WatchActions_Call struct { + *mock.Call +} + +// WatchActions is a helper method to define mock.On call +// - _a0 *workflow.WatchActionsRequest +// - _a1 workflow.RunService_WatchActionsServer +func (_e *RunServiceServer_Expecter) WatchActions(_a0 interface{}, _a1 interface{}) *RunServiceServer_WatchActions_Call { + return &RunServiceServer_WatchActions_Call{Call: _e.mock.On("WatchActions", _a0, _a1)} +} + +func (_c *RunServiceServer_WatchActions_Call) Run(run func(_a0 *workflow.WatchActionsRequest, _a1 workflow.RunService_WatchActionsServer)) *RunServiceServer_WatchActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*workflow.WatchActionsRequest), args[1].(workflow.RunService_WatchActionsServer)) + }) + return _c +} + +func (_c *RunServiceServer_WatchActions_Call) Return(_a0 error) *RunServiceServer_WatchActions_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunServiceServer_WatchActions_Call) RunAndReturn(run func(*workflow.WatchActionsRequest, workflow.RunService_WatchActionsServer) error) *RunServiceServer_WatchActions_Call { + _c.Call.Return(run) + return _c +} + +// WatchClusterEvents provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceServer) WatchClusterEvents(_a0 *workflow.WatchClusterEventsRequest, _a1 workflow.RunService_WatchClusterEventsServer) error { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for WatchClusterEvents") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*workflow.WatchClusterEventsRequest, workflow.RunService_WatchClusterEventsServer) error); ok { + r0 = rf(_a0, _a1) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunServiceServer_WatchClusterEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchClusterEvents' +type RunServiceServer_WatchClusterEvents_Call struct { + *mock.Call +} + +// WatchClusterEvents is a helper method to define mock.On call +// - _a0 *workflow.WatchClusterEventsRequest +// - _a1 workflow.RunService_WatchClusterEventsServer +func (_e *RunServiceServer_Expecter) WatchClusterEvents(_a0 interface{}, _a1 interface{}) *RunServiceServer_WatchClusterEvents_Call { + return &RunServiceServer_WatchClusterEvents_Call{Call: _e.mock.On("WatchClusterEvents", _a0, _a1)} +} + +func (_c *RunServiceServer_WatchClusterEvents_Call) Run(run func(_a0 *workflow.WatchClusterEventsRequest, _a1 workflow.RunService_WatchClusterEventsServer)) *RunServiceServer_WatchClusterEvents_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*workflow.WatchClusterEventsRequest), args[1].(workflow.RunService_WatchClusterEventsServer)) + }) + return _c +} + +func (_c *RunServiceServer_WatchClusterEvents_Call) Return(_a0 error) *RunServiceServer_WatchClusterEvents_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunServiceServer_WatchClusterEvents_Call) RunAndReturn(run func(*workflow.WatchClusterEventsRequest, workflow.RunService_WatchClusterEventsServer) error) *RunServiceServer_WatchClusterEvents_Call { + _c.Call.Return(run) + return _c +} + +// WatchGroups provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceServer) WatchGroups(_a0 *workflow.WatchGroupsRequest, _a1 workflow.RunService_WatchGroupsServer) error { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for WatchGroups") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*workflow.WatchGroupsRequest, workflow.RunService_WatchGroupsServer) error); ok { + r0 = rf(_a0, _a1) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunServiceServer_WatchGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchGroups' +type RunServiceServer_WatchGroups_Call struct { + *mock.Call +} + +// WatchGroups is a helper method to define mock.On call +// - _a0 *workflow.WatchGroupsRequest +// - _a1 workflow.RunService_WatchGroupsServer +func (_e *RunServiceServer_Expecter) WatchGroups(_a0 interface{}, _a1 interface{}) *RunServiceServer_WatchGroups_Call { + return &RunServiceServer_WatchGroups_Call{Call: _e.mock.On("WatchGroups", _a0, _a1)} +} + +func (_c *RunServiceServer_WatchGroups_Call) Run(run func(_a0 *workflow.WatchGroupsRequest, _a1 workflow.RunService_WatchGroupsServer)) *RunServiceServer_WatchGroups_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*workflow.WatchGroupsRequest), args[1].(workflow.RunService_WatchGroupsServer)) + }) + return _c +} + +func (_c *RunServiceServer_WatchGroups_Call) Return(_a0 error) *RunServiceServer_WatchGroups_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunServiceServer_WatchGroups_Call) RunAndReturn(run func(*workflow.WatchGroupsRequest, workflow.RunService_WatchGroupsServer) error) *RunServiceServer_WatchGroups_Call { + _c.Call.Return(run) + return _c +} + +// WatchRunDetails provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceServer) WatchRunDetails(_a0 *workflow.WatchRunDetailsRequest, _a1 workflow.RunService_WatchRunDetailsServer) error { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for WatchRunDetails") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*workflow.WatchRunDetailsRequest, workflow.RunService_WatchRunDetailsServer) error); ok { + r0 = rf(_a0, _a1) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunServiceServer_WatchRunDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchRunDetails' +type RunServiceServer_WatchRunDetails_Call struct { + *mock.Call +} + +// WatchRunDetails is a helper method to define mock.On call +// - _a0 *workflow.WatchRunDetailsRequest +// - _a1 workflow.RunService_WatchRunDetailsServer +func (_e *RunServiceServer_Expecter) WatchRunDetails(_a0 interface{}, _a1 interface{}) *RunServiceServer_WatchRunDetails_Call { + return &RunServiceServer_WatchRunDetails_Call{Call: _e.mock.On("WatchRunDetails", _a0, _a1)} +} + +func (_c *RunServiceServer_WatchRunDetails_Call) Run(run func(_a0 *workflow.WatchRunDetailsRequest, _a1 workflow.RunService_WatchRunDetailsServer)) *RunServiceServer_WatchRunDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*workflow.WatchRunDetailsRequest), args[1].(workflow.RunService_WatchRunDetailsServer)) + }) + return _c +} + +func (_c *RunServiceServer_WatchRunDetails_Call) Return(_a0 error) *RunServiceServer_WatchRunDetails_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunServiceServer_WatchRunDetails_Call) RunAndReturn(run func(*workflow.WatchRunDetailsRequest, workflow.RunService_WatchRunDetailsServer) error) *RunServiceServer_WatchRunDetails_Call { + _c.Call.Return(run) + return _c +} + +// WatchRuns provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceServer) WatchRuns(_a0 *workflow.WatchRunsRequest, _a1 workflow.RunService_WatchRunsServer) error { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for WatchRuns") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*workflow.WatchRunsRequest, workflow.RunService_WatchRunsServer) error); ok { + r0 = rf(_a0, _a1) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunServiceServer_WatchRuns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchRuns' +type RunServiceServer_WatchRuns_Call struct { + *mock.Call +} + +// WatchRuns is a helper method to define mock.On call +// - _a0 *workflow.WatchRunsRequest +// - _a1 workflow.RunService_WatchRunsServer +func (_e *RunServiceServer_Expecter) WatchRuns(_a0 interface{}, _a1 interface{}) *RunServiceServer_WatchRuns_Call { + return &RunServiceServer_WatchRuns_Call{Call: _e.mock.On("WatchRuns", _a0, _a1)} +} + +func (_c *RunServiceServer_WatchRuns_Call) Run(run func(_a0 *workflow.WatchRunsRequest, _a1 workflow.RunService_WatchRunsServer)) *RunServiceServer_WatchRuns_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*workflow.WatchRunsRequest), args[1].(workflow.RunService_WatchRunsServer)) + }) + return _c +} + +func (_c *RunServiceServer_WatchRuns_Call) Return(_a0 error) *RunServiceServer_WatchRuns_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunServiceServer_WatchRuns_Call) RunAndReturn(run func(*workflow.WatchRunsRequest, workflow.RunService_WatchRunsServer) error) *RunServiceServer_WatchRuns_Call { + _c.Call.Return(run) + return _c +} + +// NewRunServiceServer creates a new instance of RunServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *RunServiceServer { + mock := &RunServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/run_service_watch_action_details_client.go b/gen/go/flyteidl2/workflow/mocks/run_service_watch_action_details_client.go new file mode 100644 index 0000000000..6f19f8f3b7 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/run_service_watch_action_details_client.go @@ -0,0 +1,384 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + metadata "google.golang.org/grpc/metadata" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunService_WatchActionDetailsClient is an autogenerated mock type for the RunService_WatchActionDetailsClient type +type RunService_WatchActionDetailsClient struct { + mock.Mock +} + +type RunService_WatchActionDetailsClient_Expecter struct { + mock *mock.Mock +} + +func (_m *RunService_WatchActionDetailsClient) EXPECT() *RunService_WatchActionDetailsClient_Expecter { + return &RunService_WatchActionDetailsClient_Expecter{mock: &_m.Mock} +} + +// CloseSend provides a mock function with no fields +func (_m *RunService_WatchActionDetailsClient) CloseSend() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for CloseSend") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchActionDetailsClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend' +type RunService_WatchActionDetailsClient_CloseSend_Call struct { + *mock.Call +} + +// CloseSend is a helper method to define mock.On call +func (_e *RunService_WatchActionDetailsClient_Expecter) CloseSend() *RunService_WatchActionDetailsClient_CloseSend_Call { + return &RunService_WatchActionDetailsClient_CloseSend_Call{Call: _e.mock.On("CloseSend")} +} + +func (_c *RunService_WatchActionDetailsClient_CloseSend_Call) Run(run func()) *RunService_WatchActionDetailsClient_CloseSend_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchActionDetailsClient_CloseSend_Call) Return(_a0 error) *RunService_WatchActionDetailsClient_CloseSend_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionDetailsClient_CloseSend_Call) RunAndReturn(run func() error) *RunService_WatchActionDetailsClient_CloseSend_Call { + _c.Call.Return(run) + return _c +} + +// Context provides a mock function with no fields +func (_m *RunService_WatchActionDetailsClient) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// RunService_WatchActionDetailsClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type RunService_WatchActionDetailsClient_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *RunService_WatchActionDetailsClient_Expecter) Context() *RunService_WatchActionDetailsClient_Context_Call { + return &RunService_WatchActionDetailsClient_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *RunService_WatchActionDetailsClient_Context_Call) Run(run func()) *RunService_WatchActionDetailsClient_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchActionDetailsClient_Context_Call) Return(_a0 context.Context) *RunService_WatchActionDetailsClient_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionDetailsClient_Context_Call) RunAndReturn(run func() context.Context) *RunService_WatchActionDetailsClient_Context_Call { + _c.Call.Return(run) + return _c +} + +// Header provides a mock function with no fields +func (_m *RunService_WatchActionDetailsClient) Header() (metadata.MD, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Header") + } + + var r0 metadata.MD + var r1 error + if rf, ok := ret.Get(0).(func() (metadata.MD, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunService_WatchActionDetailsClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header' +type RunService_WatchActionDetailsClient_Header_Call struct { + *mock.Call +} + +// Header is a helper method to define mock.On call +func (_e *RunService_WatchActionDetailsClient_Expecter) Header() *RunService_WatchActionDetailsClient_Header_Call { + return &RunService_WatchActionDetailsClient_Header_Call{Call: _e.mock.On("Header")} +} + +func (_c *RunService_WatchActionDetailsClient_Header_Call) Run(run func()) *RunService_WatchActionDetailsClient_Header_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchActionDetailsClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *RunService_WatchActionDetailsClient_Header_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunService_WatchActionDetailsClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *RunService_WatchActionDetailsClient_Header_Call { + _c.Call.Return(run) + return _c +} + +// Recv provides a mock function with no fields +func (_m *RunService_WatchActionDetailsClient) Recv() (*workflow.WatchActionDetailsResponse, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Recv") + } + + var r0 *workflow.WatchActionDetailsResponse + var r1 error + if rf, ok := ret.Get(0).(func() (*workflow.WatchActionDetailsResponse, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() *workflow.WatchActionDetailsResponse); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.WatchActionDetailsResponse) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunService_WatchActionDetailsClient_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv' +type RunService_WatchActionDetailsClient_Recv_Call struct { + *mock.Call +} + +// Recv is a helper method to define mock.On call +func (_e *RunService_WatchActionDetailsClient_Expecter) Recv() *RunService_WatchActionDetailsClient_Recv_Call { + return &RunService_WatchActionDetailsClient_Recv_Call{Call: _e.mock.On("Recv")} +} + +func (_c *RunService_WatchActionDetailsClient_Recv_Call) Run(run func()) *RunService_WatchActionDetailsClient_Recv_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchActionDetailsClient_Recv_Call) Return(_a0 *workflow.WatchActionDetailsResponse, _a1 error) *RunService_WatchActionDetailsClient_Recv_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunService_WatchActionDetailsClient_Recv_Call) RunAndReturn(run func() (*workflow.WatchActionDetailsResponse, error)) *RunService_WatchActionDetailsClient_Recv_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *RunService_WatchActionDetailsClient) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchActionDetailsClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type RunService_WatchActionDetailsClient_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchActionDetailsClient_Expecter) RecvMsg(m interface{}) *RunService_WatchActionDetailsClient_RecvMsg_Call { + return &RunService_WatchActionDetailsClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *RunService_WatchActionDetailsClient_RecvMsg_Call) Run(run func(m any)) *RunService_WatchActionDetailsClient_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchActionDetailsClient_RecvMsg_Call) Return(_a0 error) *RunService_WatchActionDetailsClient_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionDetailsClient_RecvMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchActionDetailsClient_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *RunService_WatchActionDetailsClient) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchActionDetailsClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type RunService_WatchActionDetailsClient_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchActionDetailsClient_Expecter) SendMsg(m interface{}) *RunService_WatchActionDetailsClient_SendMsg_Call { + return &RunService_WatchActionDetailsClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *RunService_WatchActionDetailsClient_SendMsg_Call) Run(run func(m any)) *RunService_WatchActionDetailsClient_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchActionDetailsClient_SendMsg_Call) Return(_a0 error) *RunService_WatchActionDetailsClient_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionDetailsClient_SendMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchActionDetailsClient_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// Trailer provides a mock function with no fields +func (_m *RunService_WatchActionDetailsClient) Trailer() metadata.MD { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Trailer") + } + + var r0 metadata.MD + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + return r0 +} + +// RunService_WatchActionDetailsClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer' +type RunService_WatchActionDetailsClient_Trailer_Call struct { + *mock.Call +} + +// Trailer is a helper method to define mock.On call +func (_e *RunService_WatchActionDetailsClient_Expecter) Trailer() *RunService_WatchActionDetailsClient_Trailer_Call { + return &RunService_WatchActionDetailsClient_Trailer_Call{Call: _e.mock.On("Trailer")} +} + +func (_c *RunService_WatchActionDetailsClient_Trailer_Call) Run(run func()) *RunService_WatchActionDetailsClient_Trailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchActionDetailsClient_Trailer_Call) Return(_a0 metadata.MD) *RunService_WatchActionDetailsClient_Trailer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionDetailsClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *RunService_WatchActionDetailsClient_Trailer_Call { + _c.Call.Return(run) + return _c +} + +// NewRunService_WatchActionDetailsClient creates a new instance of RunService_WatchActionDetailsClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunService_WatchActionDetailsClient(t interface { + mock.TestingT + Cleanup(func()) +}) *RunService_WatchActionDetailsClient { + mock := &RunService_WatchActionDetailsClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/run_service_watch_action_details_server.go b/gen/go/flyteidl2/workflow/mocks/run_service_watch_action_details_server.go new file mode 100644 index 0000000000..2dd9030c0d --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/run_service_watch_action_details_server.go @@ -0,0 +1,349 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + metadata "google.golang.org/grpc/metadata" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunService_WatchActionDetailsServer is an autogenerated mock type for the RunService_WatchActionDetailsServer type +type RunService_WatchActionDetailsServer struct { + mock.Mock +} + +type RunService_WatchActionDetailsServer_Expecter struct { + mock *mock.Mock +} + +func (_m *RunService_WatchActionDetailsServer) EXPECT() *RunService_WatchActionDetailsServer_Expecter { + return &RunService_WatchActionDetailsServer_Expecter{mock: &_m.Mock} +} + +// Context provides a mock function with no fields +func (_m *RunService_WatchActionDetailsServer) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// RunService_WatchActionDetailsServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type RunService_WatchActionDetailsServer_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *RunService_WatchActionDetailsServer_Expecter) Context() *RunService_WatchActionDetailsServer_Context_Call { + return &RunService_WatchActionDetailsServer_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *RunService_WatchActionDetailsServer_Context_Call) Run(run func()) *RunService_WatchActionDetailsServer_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchActionDetailsServer_Context_Call) Return(_a0 context.Context) *RunService_WatchActionDetailsServer_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionDetailsServer_Context_Call) RunAndReturn(run func() context.Context) *RunService_WatchActionDetailsServer_Context_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *RunService_WatchActionDetailsServer) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchActionDetailsServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type RunService_WatchActionDetailsServer_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchActionDetailsServer_Expecter) RecvMsg(m interface{}) *RunService_WatchActionDetailsServer_RecvMsg_Call { + return &RunService_WatchActionDetailsServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *RunService_WatchActionDetailsServer_RecvMsg_Call) Run(run func(m any)) *RunService_WatchActionDetailsServer_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchActionDetailsServer_RecvMsg_Call) Return(_a0 error) *RunService_WatchActionDetailsServer_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionDetailsServer_RecvMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchActionDetailsServer_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// Send provides a mock function with given fields: _a0 +func (_m *RunService_WatchActionDetailsServer) Send(_a0 *workflow.WatchActionDetailsResponse) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for Send") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*workflow.WatchActionDetailsResponse) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchActionDetailsServer_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send' +type RunService_WatchActionDetailsServer_Send_Call struct { + *mock.Call +} + +// Send is a helper method to define mock.On call +// - _a0 *workflow.WatchActionDetailsResponse +func (_e *RunService_WatchActionDetailsServer_Expecter) Send(_a0 interface{}) *RunService_WatchActionDetailsServer_Send_Call { + return &RunService_WatchActionDetailsServer_Send_Call{Call: _e.mock.On("Send", _a0)} +} + +func (_c *RunService_WatchActionDetailsServer_Send_Call) Run(run func(_a0 *workflow.WatchActionDetailsResponse)) *RunService_WatchActionDetailsServer_Send_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*workflow.WatchActionDetailsResponse)) + }) + return _c +} + +func (_c *RunService_WatchActionDetailsServer_Send_Call) Return(_a0 error) *RunService_WatchActionDetailsServer_Send_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionDetailsServer_Send_Call) RunAndReturn(run func(*workflow.WatchActionDetailsResponse) error) *RunService_WatchActionDetailsServer_Send_Call { + _c.Call.Return(run) + return _c +} + +// SendHeader provides a mock function with given fields: _a0 +func (_m *RunService_WatchActionDetailsServer) SendHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SendHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchActionDetailsServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader' +type RunService_WatchActionDetailsServer_SendHeader_Call struct { + *mock.Call +} + +// SendHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunService_WatchActionDetailsServer_Expecter) SendHeader(_a0 interface{}) *RunService_WatchActionDetailsServer_SendHeader_Call { + return &RunService_WatchActionDetailsServer_SendHeader_Call{Call: _e.mock.On("SendHeader", _a0)} +} + +func (_c *RunService_WatchActionDetailsServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *RunService_WatchActionDetailsServer_SendHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunService_WatchActionDetailsServer_SendHeader_Call) Return(_a0 error) *RunService_WatchActionDetailsServer_SendHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionDetailsServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *RunService_WatchActionDetailsServer_SendHeader_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *RunService_WatchActionDetailsServer) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchActionDetailsServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type RunService_WatchActionDetailsServer_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchActionDetailsServer_Expecter) SendMsg(m interface{}) *RunService_WatchActionDetailsServer_SendMsg_Call { + return &RunService_WatchActionDetailsServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *RunService_WatchActionDetailsServer_SendMsg_Call) Run(run func(m any)) *RunService_WatchActionDetailsServer_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchActionDetailsServer_SendMsg_Call) Return(_a0 error) *RunService_WatchActionDetailsServer_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionDetailsServer_SendMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchActionDetailsServer_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// SetHeader provides a mock function with given fields: _a0 +func (_m *RunService_WatchActionDetailsServer) SetHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SetHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchActionDetailsServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader' +type RunService_WatchActionDetailsServer_SetHeader_Call struct { + *mock.Call +} + +// SetHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunService_WatchActionDetailsServer_Expecter) SetHeader(_a0 interface{}) *RunService_WatchActionDetailsServer_SetHeader_Call { + return &RunService_WatchActionDetailsServer_SetHeader_Call{Call: _e.mock.On("SetHeader", _a0)} +} + +func (_c *RunService_WatchActionDetailsServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *RunService_WatchActionDetailsServer_SetHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunService_WatchActionDetailsServer_SetHeader_Call) Return(_a0 error) *RunService_WatchActionDetailsServer_SetHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionDetailsServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *RunService_WatchActionDetailsServer_SetHeader_Call { + _c.Call.Return(run) + return _c +} + +// SetTrailer provides a mock function with given fields: _a0 +func (_m *RunService_WatchActionDetailsServer) SetTrailer(_a0 metadata.MD) { + _m.Called(_a0) +} + +// RunService_WatchActionDetailsServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer' +type RunService_WatchActionDetailsServer_SetTrailer_Call struct { + *mock.Call +} + +// SetTrailer is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunService_WatchActionDetailsServer_Expecter) SetTrailer(_a0 interface{}) *RunService_WatchActionDetailsServer_SetTrailer_Call { + return &RunService_WatchActionDetailsServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", _a0)} +} + +func (_c *RunService_WatchActionDetailsServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *RunService_WatchActionDetailsServer_SetTrailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunService_WatchActionDetailsServer_SetTrailer_Call) Return() *RunService_WatchActionDetailsServer_SetTrailer_Call { + _c.Call.Return() + return _c +} + +func (_c *RunService_WatchActionDetailsServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *RunService_WatchActionDetailsServer_SetTrailer_Call { + _c.Run(run) + return _c +} + +// NewRunService_WatchActionDetailsServer creates a new instance of RunService_WatchActionDetailsServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunService_WatchActionDetailsServer(t interface { + mock.TestingT + Cleanup(func()) +}) *RunService_WatchActionDetailsServer { + mock := &RunService_WatchActionDetailsServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/run_service_watch_actions_client.go b/gen/go/flyteidl2/workflow/mocks/run_service_watch_actions_client.go new file mode 100644 index 0000000000..14f3861cbc --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/run_service_watch_actions_client.go @@ -0,0 +1,384 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + metadata "google.golang.org/grpc/metadata" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunService_WatchActionsClient is an autogenerated mock type for the RunService_WatchActionsClient type +type RunService_WatchActionsClient struct { + mock.Mock +} + +type RunService_WatchActionsClient_Expecter struct { + mock *mock.Mock +} + +func (_m *RunService_WatchActionsClient) EXPECT() *RunService_WatchActionsClient_Expecter { + return &RunService_WatchActionsClient_Expecter{mock: &_m.Mock} +} + +// CloseSend provides a mock function with no fields +func (_m *RunService_WatchActionsClient) CloseSend() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for CloseSend") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchActionsClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend' +type RunService_WatchActionsClient_CloseSend_Call struct { + *mock.Call +} + +// CloseSend is a helper method to define mock.On call +func (_e *RunService_WatchActionsClient_Expecter) CloseSend() *RunService_WatchActionsClient_CloseSend_Call { + return &RunService_WatchActionsClient_CloseSend_Call{Call: _e.mock.On("CloseSend")} +} + +func (_c *RunService_WatchActionsClient_CloseSend_Call) Run(run func()) *RunService_WatchActionsClient_CloseSend_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchActionsClient_CloseSend_Call) Return(_a0 error) *RunService_WatchActionsClient_CloseSend_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionsClient_CloseSend_Call) RunAndReturn(run func() error) *RunService_WatchActionsClient_CloseSend_Call { + _c.Call.Return(run) + return _c +} + +// Context provides a mock function with no fields +func (_m *RunService_WatchActionsClient) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// RunService_WatchActionsClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type RunService_WatchActionsClient_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *RunService_WatchActionsClient_Expecter) Context() *RunService_WatchActionsClient_Context_Call { + return &RunService_WatchActionsClient_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *RunService_WatchActionsClient_Context_Call) Run(run func()) *RunService_WatchActionsClient_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchActionsClient_Context_Call) Return(_a0 context.Context) *RunService_WatchActionsClient_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionsClient_Context_Call) RunAndReturn(run func() context.Context) *RunService_WatchActionsClient_Context_Call { + _c.Call.Return(run) + return _c +} + +// Header provides a mock function with no fields +func (_m *RunService_WatchActionsClient) Header() (metadata.MD, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Header") + } + + var r0 metadata.MD + var r1 error + if rf, ok := ret.Get(0).(func() (metadata.MD, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunService_WatchActionsClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header' +type RunService_WatchActionsClient_Header_Call struct { + *mock.Call +} + +// Header is a helper method to define mock.On call +func (_e *RunService_WatchActionsClient_Expecter) Header() *RunService_WatchActionsClient_Header_Call { + return &RunService_WatchActionsClient_Header_Call{Call: _e.mock.On("Header")} +} + +func (_c *RunService_WatchActionsClient_Header_Call) Run(run func()) *RunService_WatchActionsClient_Header_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchActionsClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *RunService_WatchActionsClient_Header_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunService_WatchActionsClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *RunService_WatchActionsClient_Header_Call { + _c.Call.Return(run) + return _c +} + +// Recv provides a mock function with no fields +func (_m *RunService_WatchActionsClient) Recv() (*workflow.WatchActionsResponse, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Recv") + } + + var r0 *workflow.WatchActionsResponse + var r1 error + if rf, ok := ret.Get(0).(func() (*workflow.WatchActionsResponse, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() *workflow.WatchActionsResponse); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.WatchActionsResponse) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunService_WatchActionsClient_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv' +type RunService_WatchActionsClient_Recv_Call struct { + *mock.Call +} + +// Recv is a helper method to define mock.On call +func (_e *RunService_WatchActionsClient_Expecter) Recv() *RunService_WatchActionsClient_Recv_Call { + return &RunService_WatchActionsClient_Recv_Call{Call: _e.mock.On("Recv")} +} + +func (_c *RunService_WatchActionsClient_Recv_Call) Run(run func()) *RunService_WatchActionsClient_Recv_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchActionsClient_Recv_Call) Return(_a0 *workflow.WatchActionsResponse, _a1 error) *RunService_WatchActionsClient_Recv_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunService_WatchActionsClient_Recv_Call) RunAndReturn(run func() (*workflow.WatchActionsResponse, error)) *RunService_WatchActionsClient_Recv_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *RunService_WatchActionsClient) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchActionsClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type RunService_WatchActionsClient_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchActionsClient_Expecter) RecvMsg(m interface{}) *RunService_WatchActionsClient_RecvMsg_Call { + return &RunService_WatchActionsClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *RunService_WatchActionsClient_RecvMsg_Call) Run(run func(m any)) *RunService_WatchActionsClient_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchActionsClient_RecvMsg_Call) Return(_a0 error) *RunService_WatchActionsClient_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionsClient_RecvMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchActionsClient_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *RunService_WatchActionsClient) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchActionsClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type RunService_WatchActionsClient_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchActionsClient_Expecter) SendMsg(m interface{}) *RunService_WatchActionsClient_SendMsg_Call { + return &RunService_WatchActionsClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *RunService_WatchActionsClient_SendMsg_Call) Run(run func(m any)) *RunService_WatchActionsClient_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchActionsClient_SendMsg_Call) Return(_a0 error) *RunService_WatchActionsClient_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionsClient_SendMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchActionsClient_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// Trailer provides a mock function with no fields +func (_m *RunService_WatchActionsClient) Trailer() metadata.MD { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Trailer") + } + + var r0 metadata.MD + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + return r0 +} + +// RunService_WatchActionsClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer' +type RunService_WatchActionsClient_Trailer_Call struct { + *mock.Call +} + +// Trailer is a helper method to define mock.On call +func (_e *RunService_WatchActionsClient_Expecter) Trailer() *RunService_WatchActionsClient_Trailer_Call { + return &RunService_WatchActionsClient_Trailer_Call{Call: _e.mock.On("Trailer")} +} + +func (_c *RunService_WatchActionsClient_Trailer_Call) Run(run func()) *RunService_WatchActionsClient_Trailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchActionsClient_Trailer_Call) Return(_a0 metadata.MD) *RunService_WatchActionsClient_Trailer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionsClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *RunService_WatchActionsClient_Trailer_Call { + _c.Call.Return(run) + return _c +} + +// NewRunService_WatchActionsClient creates a new instance of RunService_WatchActionsClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunService_WatchActionsClient(t interface { + mock.TestingT + Cleanup(func()) +}) *RunService_WatchActionsClient { + mock := &RunService_WatchActionsClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/run_service_watch_actions_server.go b/gen/go/flyteidl2/workflow/mocks/run_service_watch_actions_server.go new file mode 100644 index 0000000000..4a23a99965 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/run_service_watch_actions_server.go @@ -0,0 +1,349 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + metadata "google.golang.org/grpc/metadata" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunService_WatchActionsServer is an autogenerated mock type for the RunService_WatchActionsServer type +type RunService_WatchActionsServer struct { + mock.Mock +} + +type RunService_WatchActionsServer_Expecter struct { + mock *mock.Mock +} + +func (_m *RunService_WatchActionsServer) EXPECT() *RunService_WatchActionsServer_Expecter { + return &RunService_WatchActionsServer_Expecter{mock: &_m.Mock} +} + +// Context provides a mock function with no fields +func (_m *RunService_WatchActionsServer) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// RunService_WatchActionsServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type RunService_WatchActionsServer_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *RunService_WatchActionsServer_Expecter) Context() *RunService_WatchActionsServer_Context_Call { + return &RunService_WatchActionsServer_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *RunService_WatchActionsServer_Context_Call) Run(run func()) *RunService_WatchActionsServer_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchActionsServer_Context_Call) Return(_a0 context.Context) *RunService_WatchActionsServer_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionsServer_Context_Call) RunAndReturn(run func() context.Context) *RunService_WatchActionsServer_Context_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *RunService_WatchActionsServer) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchActionsServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type RunService_WatchActionsServer_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchActionsServer_Expecter) RecvMsg(m interface{}) *RunService_WatchActionsServer_RecvMsg_Call { + return &RunService_WatchActionsServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *RunService_WatchActionsServer_RecvMsg_Call) Run(run func(m any)) *RunService_WatchActionsServer_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchActionsServer_RecvMsg_Call) Return(_a0 error) *RunService_WatchActionsServer_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionsServer_RecvMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchActionsServer_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// Send provides a mock function with given fields: _a0 +func (_m *RunService_WatchActionsServer) Send(_a0 *workflow.WatchActionsResponse) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for Send") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*workflow.WatchActionsResponse) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchActionsServer_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send' +type RunService_WatchActionsServer_Send_Call struct { + *mock.Call +} + +// Send is a helper method to define mock.On call +// - _a0 *workflow.WatchActionsResponse +func (_e *RunService_WatchActionsServer_Expecter) Send(_a0 interface{}) *RunService_WatchActionsServer_Send_Call { + return &RunService_WatchActionsServer_Send_Call{Call: _e.mock.On("Send", _a0)} +} + +func (_c *RunService_WatchActionsServer_Send_Call) Run(run func(_a0 *workflow.WatchActionsResponse)) *RunService_WatchActionsServer_Send_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*workflow.WatchActionsResponse)) + }) + return _c +} + +func (_c *RunService_WatchActionsServer_Send_Call) Return(_a0 error) *RunService_WatchActionsServer_Send_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionsServer_Send_Call) RunAndReturn(run func(*workflow.WatchActionsResponse) error) *RunService_WatchActionsServer_Send_Call { + _c.Call.Return(run) + return _c +} + +// SendHeader provides a mock function with given fields: _a0 +func (_m *RunService_WatchActionsServer) SendHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SendHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchActionsServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader' +type RunService_WatchActionsServer_SendHeader_Call struct { + *mock.Call +} + +// SendHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunService_WatchActionsServer_Expecter) SendHeader(_a0 interface{}) *RunService_WatchActionsServer_SendHeader_Call { + return &RunService_WatchActionsServer_SendHeader_Call{Call: _e.mock.On("SendHeader", _a0)} +} + +func (_c *RunService_WatchActionsServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *RunService_WatchActionsServer_SendHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunService_WatchActionsServer_SendHeader_Call) Return(_a0 error) *RunService_WatchActionsServer_SendHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionsServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *RunService_WatchActionsServer_SendHeader_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *RunService_WatchActionsServer) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchActionsServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type RunService_WatchActionsServer_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchActionsServer_Expecter) SendMsg(m interface{}) *RunService_WatchActionsServer_SendMsg_Call { + return &RunService_WatchActionsServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *RunService_WatchActionsServer_SendMsg_Call) Run(run func(m any)) *RunService_WatchActionsServer_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchActionsServer_SendMsg_Call) Return(_a0 error) *RunService_WatchActionsServer_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionsServer_SendMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchActionsServer_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// SetHeader provides a mock function with given fields: _a0 +func (_m *RunService_WatchActionsServer) SetHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SetHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchActionsServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader' +type RunService_WatchActionsServer_SetHeader_Call struct { + *mock.Call +} + +// SetHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunService_WatchActionsServer_Expecter) SetHeader(_a0 interface{}) *RunService_WatchActionsServer_SetHeader_Call { + return &RunService_WatchActionsServer_SetHeader_Call{Call: _e.mock.On("SetHeader", _a0)} +} + +func (_c *RunService_WatchActionsServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *RunService_WatchActionsServer_SetHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunService_WatchActionsServer_SetHeader_Call) Return(_a0 error) *RunService_WatchActionsServer_SetHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchActionsServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *RunService_WatchActionsServer_SetHeader_Call { + _c.Call.Return(run) + return _c +} + +// SetTrailer provides a mock function with given fields: _a0 +func (_m *RunService_WatchActionsServer) SetTrailer(_a0 metadata.MD) { + _m.Called(_a0) +} + +// RunService_WatchActionsServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer' +type RunService_WatchActionsServer_SetTrailer_Call struct { + *mock.Call +} + +// SetTrailer is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunService_WatchActionsServer_Expecter) SetTrailer(_a0 interface{}) *RunService_WatchActionsServer_SetTrailer_Call { + return &RunService_WatchActionsServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", _a0)} +} + +func (_c *RunService_WatchActionsServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *RunService_WatchActionsServer_SetTrailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunService_WatchActionsServer_SetTrailer_Call) Return() *RunService_WatchActionsServer_SetTrailer_Call { + _c.Call.Return() + return _c +} + +func (_c *RunService_WatchActionsServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *RunService_WatchActionsServer_SetTrailer_Call { + _c.Run(run) + return _c +} + +// NewRunService_WatchActionsServer creates a new instance of RunService_WatchActionsServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunService_WatchActionsServer(t interface { + mock.TestingT + Cleanup(func()) +}) *RunService_WatchActionsServer { + mock := &RunService_WatchActionsServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/run_service_watch_cluster_events_client.go b/gen/go/flyteidl2/workflow/mocks/run_service_watch_cluster_events_client.go new file mode 100644 index 0000000000..06ddb2e1e4 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/run_service_watch_cluster_events_client.go @@ -0,0 +1,384 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + metadata "google.golang.org/grpc/metadata" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunService_WatchClusterEventsClient is an autogenerated mock type for the RunService_WatchClusterEventsClient type +type RunService_WatchClusterEventsClient struct { + mock.Mock +} + +type RunService_WatchClusterEventsClient_Expecter struct { + mock *mock.Mock +} + +func (_m *RunService_WatchClusterEventsClient) EXPECT() *RunService_WatchClusterEventsClient_Expecter { + return &RunService_WatchClusterEventsClient_Expecter{mock: &_m.Mock} +} + +// CloseSend provides a mock function with no fields +func (_m *RunService_WatchClusterEventsClient) CloseSend() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for CloseSend") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchClusterEventsClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend' +type RunService_WatchClusterEventsClient_CloseSend_Call struct { + *mock.Call +} + +// CloseSend is a helper method to define mock.On call +func (_e *RunService_WatchClusterEventsClient_Expecter) CloseSend() *RunService_WatchClusterEventsClient_CloseSend_Call { + return &RunService_WatchClusterEventsClient_CloseSend_Call{Call: _e.mock.On("CloseSend")} +} + +func (_c *RunService_WatchClusterEventsClient_CloseSend_Call) Run(run func()) *RunService_WatchClusterEventsClient_CloseSend_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchClusterEventsClient_CloseSend_Call) Return(_a0 error) *RunService_WatchClusterEventsClient_CloseSend_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchClusterEventsClient_CloseSend_Call) RunAndReturn(run func() error) *RunService_WatchClusterEventsClient_CloseSend_Call { + _c.Call.Return(run) + return _c +} + +// Context provides a mock function with no fields +func (_m *RunService_WatchClusterEventsClient) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// RunService_WatchClusterEventsClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type RunService_WatchClusterEventsClient_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *RunService_WatchClusterEventsClient_Expecter) Context() *RunService_WatchClusterEventsClient_Context_Call { + return &RunService_WatchClusterEventsClient_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *RunService_WatchClusterEventsClient_Context_Call) Run(run func()) *RunService_WatchClusterEventsClient_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchClusterEventsClient_Context_Call) Return(_a0 context.Context) *RunService_WatchClusterEventsClient_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchClusterEventsClient_Context_Call) RunAndReturn(run func() context.Context) *RunService_WatchClusterEventsClient_Context_Call { + _c.Call.Return(run) + return _c +} + +// Header provides a mock function with no fields +func (_m *RunService_WatchClusterEventsClient) Header() (metadata.MD, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Header") + } + + var r0 metadata.MD + var r1 error + if rf, ok := ret.Get(0).(func() (metadata.MD, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunService_WatchClusterEventsClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header' +type RunService_WatchClusterEventsClient_Header_Call struct { + *mock.Call +} + +// Header is a helper method to define mock.On call +func (_e *RunService_WatchClusterEventsClient_Expecter) Header() *RunService_WatchClusterEventsClient_Header_Call { + return &RunService_WatchClusterEventsClient_Header_Call{Call: _e.mock.On("Header")} +} + +func (_c *RunService_WatchClusterEventsClient_Header_Call) Run(run func()) *RunService_WatchClusterEventsClient_Header_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchClusterEventsClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *RunService_WatchClusterEventsClient_Header_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunService_WatchClusterEventsClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *RunService_WatchClusterEventsClient_Header_Call { + _c.Call.Return(run) + return _c +} + +// Recv provides a mock function with no fields +func (_m *RunService_WatchClusterEventsClient) Recv() (*workflow.WatchClusterEventsResponse, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Recv") + } + + var r0 *workflow.WatchClusterEventsResponse + var r1 error + if rf, ok := ret.Get(0).(func() (*workflow.WatchClusterEventsResponse, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() *workflow.WatchClusterEventsResponse); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.WatchClusterEventsResponse) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunService_WatchClusterEventsClient_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv' +type RunService_WatchClusterEventsClient_Recv_Call struct { + *mock.Call +} + +// Recv is a helper method to define mock.On call +func (_e *RunService_WatchClusterEventsClient_Expecter) Recv() *RunService_WatchClusterEventsClient_Recv_Call { + return &RunService_WatchClusterEventsClient_Recv_Call{Call: _e.mock.On("Recv")} +} + +func (_c *RunService_WatchClusterEventsClient_Recv_Call) Run(run func()) *RunService_WatchClusterEventsClient_Recv_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchClusterEventsClient_Recv_Call) Return(_a0 *workflow.WatchClusterEventsResponse, _a1 error) *RunService_WatchClusterEventsClient_Recv_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunService_WatchClusterEventsClient_Recv_Call) RunAndReturn(run func() (*workflow.WatchClusterEventsResponse, error)) *RunService_WatchClusterEventsClient_Recv_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *RunService_WatchClusterEventsClient) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchClusterEventsClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type RunService_WatchClusterEventsClient_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchClusterEventsClient_Expecter) RecvMsg(m interface{}) *RunService_WatchClusterEventsClient_RecvMsg_Call { + return &RunService_WatchClusterEventsClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *RunService_WatchClusterEventsClient_RecvMsg_Call) Run(run func(m any)) *RunService_WatchClusterEventsClient_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchClusterEventsClient_RecvMsg_Call) Return(_a0 error) *RunService_WatchClusterEventsClient_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchClusterEventsClient_RecvMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchClusterEventsClient_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *RunService_WatchClusterEventsClient) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchClusterEventsClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type RunService_WatchClusterEventsClient_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchClusterEventsClient_Expecter) SendMsg(m interface{}) *RunService_WatchClusterEventsClient_SendMsg_Call { + return &RunService_WatchClusterEventsClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *RunService_WatchClusterEventsClient_SendMsg_Call) Run(run func(m any)) *RunService_WatchClusterEventsClient_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchClusterEventsClient_SendMsg_Call) Return(_a0 error) *RunService_WatchClusterEventsClient_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchClusterEventsClient_SendMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchClusterEventsClient_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// Trailer provides a mock function with no fields +func (_m *RunService_WatchClusterEventsClient) Trailer() metadata.MD { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Trailer") + } + + var r0 metadata.MD + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + return r0 +} + +// RunService_WatchClusterEventsClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer' +type RunService_WatchClusterEventsClient_Trailer_Call struct { + *mock.Call +} + +// Trailer is a helper method to define mock.On call +func (_e *RunService_WatchClusterEventsClient_Expecter) Trailer() *RunService_WatchClusterEventsClient_Trailer_Call { + return &RunService_WatchClusterEventsClient_Trailer_Call{Call: _e.mock.On("Trailer")} +} + +func (_c *RunService_WatchClusterEventsClient_Trailer_Call) Run(run func()) *RunService_WatchClusterEventsClient_Trailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchClusterEventsClient_Trailer_Call) Return(_a0 metadata.MD) *RunService_WatchClusterEventsClient_Trailer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchClusterEventsClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *RunService_WatchClusterEventsClient_Trailer_Call { + _c.Call.Return(run) + return _c +} + +// NewRunService_WatchClusterEventsClient creates a new instance of RunService_WatchClusterEventsClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunService_WatchClusterEventsClient(t interface { + mock.TestingT + Cleanup(func()) +}) *RunService_WatchClusterEventsClient { + mock := &RunService_WatchClusterEventsClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/run_service_watch_cluster_events_server.go b/gen/go/flyteidl2/workflow/mocks/run_service_watch_cluster_events_server.go new file mode 100644 index 0000000000..e4a700d7ac --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/run_service_watch_cluster_events_server.go @@ -0,0 +1,349 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + metadata "google.golang.org/grpc/metadata" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunService_WatchClusterEventsServer is an autogenerated mock type for the RunService_WatchClusterEventsServer type +type RunService_WatchClusterEventsServer struct { + mock.Mock +} + +type RunService_WatchClusterEventsServer_Expecter struct { + mock *mock.Mock +} + +func (_m *RunService_WatchClusterEventsServer) EXPECT() *RunService_WatchClusterEventsServer_Expecter { + return &RunService_WatchClusterEventsServer_Expecter{mock: &_m.Mock} +} + +// Context provides a mock function with no fields +func (_m *RunService_WatchClusterEventsServer) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// RunService_WatchClusterEventsServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type RunService_WatchClusterEventsServer_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *RunService_WatchClusterEventsServer_Expecter) Context() *RunService_WatchClusterEventsServer_Context_Call { + return &RunService_WatchClusterEventsServer_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *RunService_WatchClusterEventsServer_Context_Call) Run(run func()) *RunService_WatchClusterEventsServer_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchClusterEventsServer_Context_Call) Return(_a0 context.Context) *RunService_WatchClusterEventsServer_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchClusterEventsServer_Context_Call) RunAndReturn(run func() context.Context) *RunService_WatchClusterEventsServer_Context_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *RunService_WatchClusterEventsServer) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchClusterEventsServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type RunService_WatchClusterEventsServer_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchClusterEventsServer_Expecter) RecvMsg(m interface{}) *RunService_WatchClusterEventsServer_RecvMsg_Call { + return &RunService_WatchClusterEventsServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *RunService_WatchClusterEventsServer_RecvMsg_Call) Run(run func(m any)) *RunService_WatchClusterEventsServer_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchClusterEventsServer_RecvMsg_Call) Return(_a0 error) *RunService_WatchClusterEventsServer_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchClusterEventsServer_RecvMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchClusterEventsServer_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// Send provides a mock function with given fields: _a0 +func (_m *RunService_WatchClusterEventsServer) Send(_a0 *workflow.WatchClusterEventsResponse) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for Send") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*workflow.WatchClusterEventsResponse) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchClusterEventsServer_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send' +type RunService_WatchClusterEventsServer_Send_Call struct { + *mock.Call +} + +// Send is a helper method to define mock.On call +// - _a0 *workflow.WatchClusterEventsResponse +func (_e *RunService_WatchClusterEventsServer_Expecter) Send(_a0 interface{}) *RunService_WatchClusterEventsServer_Send_Call { + return &RunService_WatchClusterEventsServer_Send_Call{Call: _e.mock.On("Send", _a0)} +} + +func (_c *RunService_WatchClusterEventsServer_Send_Call) Run(run func(_a0 *workflow.WatchClusterEventsResponse)) *RunService_WatchClusterEventsServer_Send_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*workflow.WatchClusterEventsResponse)) + }) + return _c +} + +func (_c *RunService_WatchClusterEventsServer_Send_Call) Return(_a0 error) *RunService_WatchClusterEventsServer_Send_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchClusterEventsServer_Send_Call) RunAndReturn(run func(*workflow.WatchClusterEventsResponse) error) *RunService_WatchClusterEventsServer_Send_Call { + _c.Call.Return(run) + return _c +} + +// SendHeader provides a mock function with given fields: _a0 +func (_m *RunService_WatchClusterEventsServer) SendHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SendHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchClusterEventsServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader' +type RunService_WatchClusterEventsServer_SendHeader_Call struct { + *mock.Call +} + +// SendHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunService_WatchClusterEventsServer_Expecter) SendHeader(_a0 interface{}) *RunService_WatchClusterEventsServer_SendHeader_Call { + return &RunService_WatchClusterEventsServer_SendHeader_Call{Call: _e.mock.On("SendHeader", _a0)} +} + +func (_c *RunService_WatchClusterEventsServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *RunService_WatchClusterEventsServer_SendHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunService_WatchClusterEventsServer_SendHeader_Call) Return(_a0 error) *RunService_WatchClusterEventsServer_SendHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchClusterEventsServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *RunService_WatchClusterEventsServer_SendHeader_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *RunService_WatchClusterEventsServer) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchClusterEventsServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type RunService_WatchClusterEventsServer_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchClusterEventsServer_Expecter) SendMsg(m interface{}) *RunService_WatchClusterEventsServer_SendMsg_Call { + return &RunService_WatchClusterEventsServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *RunService_WatchClusterEventsServer_SendMsg_Call) Run(run func(m any)) *RunService_WatchClusterEventsServer_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchClusterEventsServer_SendMsg_Call) Return(_a0 error) *RunService_WatchClusterEventsServer_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchClusterEventsServer_SendMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchClusterEventsServer_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// SetHeader provides a mock function with given fields: _a0 +func (_m *RunService_WatchClusterEventsServer) SetHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SetHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchClusterEventsServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader' +type RunService_WatchClusterEventsServer_SetHeader_Call struct { + *mock.Call +} + +// SetHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunService_WatchClusterEventsServer_Expecter) SetHeader(_a0 interface{}) *RunService_WatchClusterEventsServer_SetHeader_Call { + return &RunService_WatchClusterEventsServer_SetHeader_Call{Call: _e.mock.On("SetHeader", _a0)} +} + +func (_c *RunService_WatchClusterEventsServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *RunService_WatchClusterEventsServer_SetHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunService_WatchClusterEventsServer_SetHeader_Call) Return(_a0 error) *RunService_WatchClusterEventsServer_SetHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchClusterEventsServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *RunService_WatchClusterEventsServer_SetHeader_Call { + _c.Call.Return(run) + return _c +} + +// SetTrailer provides a mock function with given fields: _a0 +func (_m *RunService_WatchClusterEventsServer) SetTrailer(_a0 metadata.MD) { + _m.Called(_a0) +} + +// RunService_WatchClusterEventsServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer' +type RunService_WatchClusterEventsServer_SetTrailer_Call struct { + *mock.Call +} + +// SetTrailer is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunService_WatchClusterEventsServer_Expecter) SetTrailer(_a0 interface{}) *RunService_WatchClusterEventsServer_SetTrailer_Call { + return &RunService_WatchClusterEventsServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", _a0)} +} + +func (_c *RunService_WatchClusterEventsServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *RunService_WatchClusterEventsServer_SetTrailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunService_WatchClusterEventsServer_SetTrailer_Call) Return() *RunService_WatchClusterEventsServer_SetTrailer_Call { + _c.Call.Return() + return _c +} + +func (_c *RunService_WatchClusterEventsServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *RunService_WatchClusterEventsServer_SetTrailer_Call { + _c.Run(run) + return _c +} + +// NewRunService_WatchClusterEventsServer creates a new instance of RunService_WatchClusterEventsServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunService_WatchClusterEventsServer(t interface { + mock.TestingT + Cleanup(func()) +}) *RunService_WatchClusterEventsServer { + mock := &RunService_WatchClusterEventsServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/run_service_watch_groups_client.go b/gen/go/flyteidl2/workflow/mocks/run_service_watch_groups_client.go new file mode 100644 index 0000000000..d3c8c86a90 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/run_service_watch_groups_client.go @@ -0,0 +1,384 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + metadata "google.golang.org/grpc/metadata" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunService_WatchGroupsClient is an autogenerated mock type for the RunService_WatchGroupsClient type +type RunService_WatchGroupsClient struct { + mock.Mock +} + +type RunService_WatchGroupsClient_Expecter struct { + mock *mock.Mock +} + +func (_m *RunService_WatchGroupsClient) EXPECT() *RunService_WatchGroupsClient_Expecter { + return &RunService_WatchGroupsClient_Expecter{mock: &_m.Mock} +} + +// CloseSend provides a mock function with no fields +func (_m *RunService_WatchGroupsClient) CloseSend() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for CloseSend") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchGroupsClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend' +type RunService_WatchGroupsClient_CloseSend_Call struct { + *mock.Call +} + +// CloseSend is a helper method to define mock.On call +func (_e *RunService_WatchGroupsClient_Expecter) CloseSend() *RunService_WatchGroupsClient_CloseSend_Call { + return &RunService_WatchGroupsClient_CloseSend_Call{Call: _e.mock.On("CloseSend")} +} + +func (_c *RunService_WatchGroupsClient_CloseSend_Call) Run(run func()) *RunService_WatchGroupsClient_CloseSend_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchGroupsClient_CloseSend_Call) Return(_a0 error) *RunService_WatchGroupsClient_CloseSend_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchGroupsClient_CloseSend_Call) RunAndReturn(run func() error) *RunService_WatchGroupsClient_CloseSend_Call { + _c.Call.Return(run) + return _c +} + +// Context provides a mock function with no fields +func (_m *RunService_WatchGroupsClient) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// RunService_WatchGroupsClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type RunService_WatchGroupsClient_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *RunService_WatchGroupsClient_Expecter) Context() *RunService_WatchGroupsClient_Context_Call { + return &RunService_WatchGroupsClient_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *RunService_WatchGroupsClient_Context_Call) Run(run func()) *RunService_WatchGroupsClient_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchGroupsClient_Context_Call) Return(_a0 context.Context) *RunService_WatchGroupsClient_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchGroupsClient_Context_Call) RunAndReturn(run func() context.Context) *RunService_WatchGroupsClient_Context_Call { + _c.Call.Return(run) + return _c +} + +// Header provides a mock function with no fields +func (_m *RunService_WatchGroupsClient) Header() (metadata.MD, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Header") + } + + var r0 metadata.MD + var r1 error + if rf, ok := ret.Get(0).(func() (metadata.MD, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunService_WatchGroupsClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header' +type RunService_WatchGroupsClient_Header_Call struct { + *mock.Call +} + +// Header is a helper method to define mock.On call +func (_e *RunService_WatchGroupsClient_Expecter) Header() *RunService_WatchGroupsClient_Header_Call { + return &RunService_WatchGroupsClient_Header_Call{Call: _e.mock.On("Header")} +} + +func (_c *RunService_WatchGroupsClient_Header_Call) Run(run func()) *RunService_WatchGroupsClient_Header_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchGroupsClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *RunService_WatchGroupsClient_Header_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunService_WatchGroupsClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *RunService_WatchGroupsClient_Header_Call { + _c.Call.Return(run) + return _c +} + +// Recv provides a mock function with no fields +func (_m *RunService_WatchGroupsClient) Recv() (*workflow.WatchGroupsResponse, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Recv") + } + + var r0 *workflow.WatchGroupsResponse + var r1 error + if rf, ok := ret.Get(0).(func() (*workflow.WatchGroupsResponse, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() *workflow.WatchGroupsResponse); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.WatchGroupsResponse) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunService_WatchGroupsClient_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv' +type RunService_WatchGroupsClient_Recv_Call struct { + *mock.Call +} + +// Recv is a helper method to define mock.On call +func (_e *RunService_WatchGroupsClient_Expecter) Recv() *RunService_WatchGroupsClient_Recv_Call { + return &RunService_WatchGroupsClient_Recv_Call{Call: _e.mock.On("Recv")} +} + +func (_c *RunService_WatchGroupsClient_Recv_Call) Run(run func()) *RunService_WatchGroupsClient_Recv_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchGroupsClient_Recv_Call) Return(_a0 *workflow.WatchGroupsResponse, _a1 error) *RunService_WatchGroupsClient_Recv_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunService_WatchGroupsClient_Recv_Call) RunAndReturn(run func() (*workflow.WatchGroupsResponse, error)) *RunService_WatchGroupsClient_Recv_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *RunService_WatchGroupsClient) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchGroupsClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type RunService_WatchGroupsClient_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchGroupsClient_Expecter) RecvMsg(m interface{}) *RunService_WatchGroupsClient_RecvMsg_Call { + return &RunService_WatchGroupsClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *RunService_WatchGroupsClient_RecvMsg_Call) Run(run func(m any)) *RunService_WatchGroupsClient_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchGroupsClient_RecvMsg_Call) Return(_a0 error) *RunService_WatchGroupsClient_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchGroupsClient_RecvMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchGroupsClient_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *RunService_WatchGroupsClient) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchGroupsClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type RunService_WatchGroupsClient_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchGroupsClient_Expecter) SendMsg(m interface{}) *RunService_WatchGroupsClient_SendMsg_Call { + return &RunService_WatchGroupsClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *RunService_WatchGroupsClient_SendMsg_Call) Run(run func(m any)) *RunService_WatchGroupsClient_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchGroupsClient_SendMsg_Call) Return(_a0 error) *RunService_WatchGroupsClient_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchGroupsClient_SendMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchGroupsClient_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// Trailer provides a mock function with no fields +func (_m *RunService_WatchGroupsClient) Trailer() metadata.MD { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Trailer") + } + + var r0 metadata.MD + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + return r0 +} + +// RunService_WatchGroupsClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer' +type RunService_WatchGroupsClient_Trailer_Call struct { + *mock.Call +} + +// Trailer is a helper method to define mock.On call +func (_e *RunService_WatchGroupsClient_Expecter) Trailer() *RunService_WatchGroupsClient_Trailer_Call { + return &RunService_WatchGroupsClient_Trailer_Call{Call: _e.mock.On("Trailer")} +} + +func (_c *RunService_WatchGroupsClient_Trailer_Call) Run(run func()) *RunService_WatchGroupsClient_Trailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchGroupsClient_Trailer_Call) Return(_a0 metadata.MD) *RunService_WatchGroupsClient_Trailer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchGroupsClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *RunService_WatchGroupsClient_Trailer_Call { + _c.Call.Return(run) + return _c +} + +// NewRunService_WatchGroupsClient creates a new instance of RunService_WatchGroupsClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunService_WatchGroupsClient(t interface { + mock.TestingT + Cleanup(func()) +}) *RunService_WatchGroupsClient { + mock := &RunService_WatchGroupsClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/run_service_watch_groups_server.go b/gen/go/flyteidl2/workflow/mocks/run_service_watch_groups_server.go new file mode 100644 index 0000000000..5509efa90a --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/run_service_watch_groups_server.go @@ -0,0 +1,349 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + metadata "google.golang.org/grpc/metadata" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunService_WatchGroupsServer is an autogenerated mock type for the RunService_WatchGroupsServer type +type RunService_WatchGroupsServer struct { + mock.Mock +} + +type RunService_WatchGroupsServer_Expecter struct { + mock *mock.Mock +} + +func (_m *RunService_WatchGroupsServer) EXPECT() *RunService_WatchGroupsServer_Expecter { + return &RunService_WatchGroupsServer_Expecter{mock: &_m.Mock} +} + +// Context provides a mock function with no fields +func (_m *RunService_WatchGroupsServer) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// RunService_WatchGroupsServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type RunService_WatchGroupsServer_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *RunService_WatchGroupsServer_Expecter) Context() *RunService_WatchGroupsServer_Context_Call { + return &RunService_WatchGroupsServer_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *RunService_WatchGroupsServer_Context_Call) Run(run func()) *RunService_WatchGroupsServer_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchGroupsServer_Context_Call) Return(_a0 context.Context) *RunService_WatchGroupsServer_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchGroupsServer_Context_Call) RunAndReturn(run func() context.Context) *RunService_WatchGroupsServer_Context_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *RunService_WatchGroupsServer) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchGroupsServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type RunService_WatchGroupsServer_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchGroupsServer_Expecter) RecvMsg(m interface{}) *RunService_WatchGroupsServer_RecvMsg_Call { + return &RunService_WatchGroupsServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *RunService_WatchGroupsServer_RecvMsg_Call) Run(run func(m any)) *RunService_WatchGroupsServer_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchGroupsServer_RecvMsg_Call) Return(_a0 error) *RunService_WatchGroupsServer_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchGroupsServer_RecvMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchGroupsServer_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// Send provides a mock function with given fields: _a0 +func (_m *RunService_WatchGroupsServer) Send(_a0 *workflow.WatchGroupsResponse) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for Send") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*workflow.WatchGroupsResponse) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchGroupsServer_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send' +type RunService_WatchGroupsServer_Send_Call struct { + *mock.Call +} + +// Send is a helper method to define mock.On call +// - _a0 *workflow.WatchGroupsResponse +func (_e *RunService_WatchGroupsServer_Expecter) Send(_a0 interface{}) *RunService_WatchGroupsServer_Send_Call { + return &RunService_WatchGroupsServer_Send_Call{Call: _e.mock.On("Send", _a0)} +} + +func (_c *RunService_WatchGroupsServer_Send_Call) Run(run func(_a0 *workflow.WatchGroupsResponse)) *RunService_WatchGroupsServer_Send_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*workflow.WatchGroupsResponse)) + }) + return _c +} + +func (_c *RunService_WatchGroupsServer_Send_Call) Return(_a0 error) *RunService_WatchGroupsServer_Send_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchGroupsServer_Send_Call) RunAndReturn(run func(*workflow.WatchGroupsResponse) error) *RunService_WatchGroupsServer_Send_Call { + _c.Call.Return(run) + return _c +} + +// SendHeader provides a mock function with given fields: _a0 +func (_m *RunService_WatchGroupsServer) SendHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SendHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchGroupsServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader' +type RunService_WatchGroupsServer_SendHeader_Call struct { + *mock.Call +} + +// SendHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunService_WatchGroupsServer_Expecter) SendHeader(_a0 interface{}) *RunService_WatchGroupsServer_SendHeader_Call { + return &RunService_WatchGroupsServer_SendHeader_Call{Call: _e.mock.On("SendHeader", _a0)} +} + +func (_c *RunService_WatchGroupsServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *RunService_WatchGroupsServer_SendHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunService_WatchGroupsServer_SendHeader_Call) Return(_a0 error) *RunService_WatchGroupsServer_SendHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchGroupsServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *RunService_WatchGroupsServer_SendHeader_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *RunService_WatchGroupsServer) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchGroupsServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type RunService_WatchGroupsServer_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchGroupsServer_Expecter) SendMsg(m interface{}) *RunService_WatchGroupsServer_SendMsg_Call { + return &RunService_WatchGroupsServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *RunService_WatchGroupsServer_SendMsg_Call) Run(run func(m any)) *RunService_WatchGroupsServer_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchGroupsServer_SendMsg_Call) Return(_a0 error) *RunService_WatchGroupsServer_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchGroupsServer_SendMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchGroupsServer_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// SetHeader provides a mock function with given fields: _a0 +func (_m *RunService_WatchGroupsServer) SetHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SetHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchGroupsServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader' +type RunService_WatchGroupsServer_SetHeader_Call struct { + *mock.Call +} + +// SetHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunService_WatchGroupsServer_Expecter) SetHeader(_a0 interface{}) *RunService_WatchGroupsServer_SetHeader_Call { + return &RunService_WatchGroupsServer_SetHeader_Call{Call: _e.mock.On("SetHeader", _a0)} +} + +func (_c *RunService_WatchGroupsServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *RunService_WatchGroupsServer_SetHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunService_WatchGroupsServer_SetHeader_Call) Return(_a0 error) *RunService_WatchGroupsServer_SetHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchGroupsServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *RunService_WatchGroupsServer_SetHeader_Call { + _c.Call.Return(run) + return _c +} + +// SetTrailer provides a mock function with given fields: _a0 +func (_m *RunService_WatchGroupsServer) SetTrailer(_a0 metadata.MD) { + _m.Called(_a0) +} + +// RunService_WatchGroupsServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer' +type RunService_WatchGroupsServer_SetTrailer_Call struct { + *mock.Call +} + +// SetTrailer is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunService_WatchGroupsServer_Expecter) SetTrailer(_a0 interface{}) *RunService_WatchGroupsServer_SetTrailer_Call { + return &RunService_WatchGroupsServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", _a0)} +} + +func (_c *RunService_WatchGroupsServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *RunService_WatchGroupsServer_SetTrailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunService_WatchGroupsServer_SetTrailer_Call) Return() *RunService_WatchGroupsServer_SetTrailer_Call { + _c.Call.Return() + return _c +} + +func (_c *RunService_WatchGroupsServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *RunService_WatchGroupsServer_SetTrailer_Call { + _c.Run(run) + return _c +} + +// NewRunService_WatchGroupsServer creates a new instance of RunService_WatchGroupsServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunService_WatchGroupsServer(t interface { + mock.TestingT + Cleanup(func()) +}) *RunService_WatchGroupsServer { + mock := &RunService_WatchGroupsServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/run_service_watch_run_details_client.go b/gen/go/flyteidl2/workflow/mocks/run_service_watch_run_details_client.go new file mode 100644 index 0000000000..d4b96c5811 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/run_service_watch_run_details_client.go @@ -0,0 +1,384 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + metadata "google.golang.org/grpc/metadata" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunService_WatchRunDetailsClient is an autogenerated mock type for the RunService_WatchRunDetailsClient type +type RunService_WatchRunDetailsClient struct { + mock.Mock +} + +type RunService_WatchRunDetailsClient_Expecter struct { + mock *mock.Mock +} + +func (_m *RunService_WatchRunDetailsClient) EXPECT() *RunService_WatchRunDetailsClient_Expecter { + return &RunService_WatchRunDetailsClient_Expecter{mock: &_m.Mock} +} + +// CloseSend provides a mock function with no fields +func (_m *RunService_WatchRunDetailsClient) CloseSend() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for CloseSend") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchRunDetailsClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend' +type RunService_WatchRunDetailsClient_CloseSend_Call struct { + *mock.Call +} + +// CloseSend is a helper method to define mock.On call +func (_e *RunService_WatchRunDetailsClient_Expecter) CloseSend() *RunService_WatchRunDetailsClient_CloseSend_Call { + return &RunService_WatchRunDetailsClient_CloseSend_Call{Call: _e.mock.On("CloseSend")} +} + +func (_c *RunService_WatchRunDetailsClient_CloseSend_Call) Run(run func()) *RunService_WatchRunDetailsClient_CloseSend_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchRunDetailsClient_CloseSend_Call) Return(_a0 error) *RunService_WatchRunDetailsClient_CloseSend_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunDetailsClient_CloseSend_Call) RunAndReturn(run func() error) *RunService_WatchRunDetailsClient_CloseSend_Call { + _c.Call.Return(run) + return _c +} + +// Context provides a mock function with no fields +func (_m *RunService_WatchRunDetailsClient) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// RunService_WatchRunDetailsClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type RunService_WatchRunDetailsClient_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *RunService_WatchRunDetailsClient_Expecter) Context() *RunService_WatchRunDetailsClient_Context_Call { + return &RunService_WatchRunDetailsClient_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *RunService_WatchRunDetailsClient_Context_Call) Run(run func()) *RunService_WatchRunDetailsClient_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchRunDetailsClient_Context_Call) Return(_a0 context.Context) *RunService_WatchRunDetailsClient_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunDetailsClient_Context_Call) RunAndReturn(run func() context.Context) *RunService_WatchRunDetailsClient_Context_Call { + _c.Call.Return(run) + return _c +} + +// Header provides a mock function with no fields +func (_m *RunService_WatchRunDetailsClient) Header() (metadata.MD, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Header") + } + + var r0 metadata.MD + var r1 error + if rf, ok := ret.Get(0).(func() (metadata.MD, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunService_WatchRunDetailsClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header' +type RunService_WatchRunDetailsClient_Header_Call struct { + *mock.Call +} + +// Header is a helper method to define mock.On call +func (_e *RunService_WatchRunDetailsClient_Expecter) Header() *RunService_WatchRunDetailsClient_Header_Call { + return &RunService_WatchRunDetailsClient_Header_Call{Call: _e.mock.On("Header")} +} + +func (_c *RunService_WatchRunDetailsClient_Header_Call) Run(run func()) *RunService_WatchRunDetailsClient_Header_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchRunDetailsClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *RunService_WatchRunDetailsClient_Header_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunService_WatchRunDetailsClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *RunService_WatchRunDetailsClient_Header_Call { + _c.Call.Return(run) + return _c +} + +// Recv provides a mock function with no fields +func (_m *RunService_WatchRunDetailsClient) Recv() (*workflow.WatchRunDetailsResponse, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Recv") + } + + var r0 *workflow.WatchRunDetailsResponse + var r1 error + if rf, ok := ret.Get(0).(func() (*workflow.WatchRunDetailsResponse, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() *workflow.WatchRunDetailsResponse); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.WatchRunDetailsResponse) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunService_WatchRunDetailsClient_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv' +type RunService_WatchRunDetailsClient_Recv_Call struct { + *mock.Call +} + +// Recv is a helper method to define mock.On call +func (_e *RunService_WatchRunDetailsClient_Expecter) Recv() *RunService_WatchRunDetailsClient_Recv_Call { + return &RunService_WatchRunDetailsClient_Recv_Call{Call: _e.mock.On("Recv")} +} + +func (_c *RunService_WatchRunDetailsClient_Recv_Call) Run(run func()) *RunService_WatchRunDetailsClient_Recv_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchRunDetailsClient_Recv_Call) Return(_a0 *workflow.WatchRunDetailsResponse, _a1 error) *RunService_WatchRunDetailsClient_Recv_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunService_WatchRunDetailsClient_Recv_Call) RunAndReturn(run func() (*workflow.WatchRunDetailsResponse, error)) *RunService_WatchRunDetailsClient_Recv_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *RunService_WatchRunDetailsClient) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchRunDetailsClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type RunService_WatchRunDetailsClient_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchRunDetailsClient_Expecter) RecvMsg(m interface{}) *RunService_WatchRunDetailsClient_RecvMsg_Call { + return &RunService_WatchRunDetailsClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *RunService_WatchRunDetailsClient_RecvMsg_Call) Run(run func(m any)) *RunService_WatchRunDetailsClient_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchRunDetailsClient_RecvMsg_Call) Return(_a0 error) *RunService_WatchRunDetailsClient_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunDetailsClient_RecvMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchRunDetailsClient_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *RunService_WatchRunDetailsClient) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchRunDetailsClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type RunService_WatchRunDetailsClient_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchRunDetailsClient_Expecter) SendMsg(m interface{}) *RunService_WatchRunDetailsClient_SendMsg_Call { + return &RunService_WatchRunDetailsClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *RunService_WatchRunDetailsClient_SendMsg_Call) Run(run func(m any)) *RunService_WatchRunDetailsClient_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchRunDetailsClient_SendMsg_Call) Return(_a0 error) *RunService_WatchRunDetailsClient_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunDetailsClient_SendMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchRunDetailsClient_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// Trailer provides a mock function with no fields +func (_m *RunService_WatchRunDetailsClient) Trailer() metadata.MD { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Trailer") + } + + var r0 metadata.MD + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + return r0 +} + +// RunService_WatchRunDetailsClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer' +type RunService_WatchRunDetailsClient_Trailer_Call struct { + *mock.Call +} + +// Trailer is a helper method to define mock.On call +func (_e *RunService_WatchRunDetailsClient_Expecter) Trailer() *RunService_WatchRunDetailsClient_Trailer_Call { + return &RunService_WatchRunDetailsClient_Trailer_Call{Call: _e.mock.On("Trailer")} +} + +func (_c *RunService_WatchRunDetailsClient_Trailer_Call) Run(run func()) *RunService_WatchRunDetailsClient_Trailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchRunDetailsClient_Trailer_Call) Return(_a0 metadata.MD) *RunService_WatchRunDetailsClient_Trailer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunDetailsClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *RunService_WatchRunDetailsClient_Trailer_Call { + _c.Call.Return(run) + return _c +} + +// NewRunService_WatchRunDetailsClient creates a new instance of RunService_WatchRunDetailsClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunService_WatchRunDetailsClient(t interface { + mock.TestingT + Cleanup(func()) +}) *RunService_WatchRunDetailsClient { + mock := &RunService_WatchRunDetailsClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/run_service_watch_run_details_server.go b/gen/go/flyteidl2/workflow/mocks/run_service_watch_run_details_server.go new file mode 100644 index 0000000000..6f01d7a29e --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/run_service_watch_run_details_server.go @@ -0,0 +1,349 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + metadata "google.golang.org/grpc/metadata" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunService_WatchRunDetailsServer is an autogenerated mock type for the RunService_WatchRunDetailsServer type +type RunService_WatchRunDetailsServer struct { + mock.Mock +} + +type RunService_WatchRunDetailsServer_Expecter struct { + mock *mock.Mock +} + +func (_m *RunService_WatchRunDetailsServer) EXPECT() *RunService_WatchRunDetailsServer_Expecter { + return &RunService_WatchRunDetailsServer_Expecter{mock: &_m.Mock} +} + +// Context provides a mock function with no fields +func (_m *RunService_WatchRunDetailsServer) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// RunService_WatchRunDetailsServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type RunService_WatchRunDetailsServer_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *RunService_WatchRunDetailsServer_Expecter) Context() *RunService_WatchRunDetailsServer_Context_Call { + return &RunService_WatchRunDetailsServer_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *RunService_WatchRunDetailsServer_Context_Call) Run(run func()) *RunService_WatchRunDetailsServer_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchRunDetailsServer_Context_Call) Return(_a0 context.Context) *RunService_WatchRunDetailsServer_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunDetailsServer_Context_Call) RunAndReturn(run func() context.Context) *RunService_WatchRunDetailsServer_Context_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *RunService_WatchRunDetailsServer) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchRunDetailsServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type RunService_WatchRunDetailsServer_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchRunDetailsServer_Expecter) RecvMsg(m interface{}) *RunService_WatchRunDetailsServer_RecvMsg_Call { + return &RunService_WatchRunDetailsServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *RunService_WatchRunDetailsServer_RecvMsg_Call) Run(run func(m any)) *RunService_WatchRunDetailsServer_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchRunDetailsServer_RecvMsg_Call) Return(_a0 error) *RunService_WatchRunDetailsServer_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunDetailsServer_RecvMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchRunDetailsServer_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// Send provides a mock function with given fields: _a0 +func (_m *RunService_WatchRunDetailsServer) Send(_a0 *workflow.WatchRunDetailsResponse) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for Send") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*workflow.WatchRunDetailsResponse) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchRunDetailsServer_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send' +type RunService_WatchRunDetailsServer_Send_Call struct { + *mock.Call +} + +// Send is a helper method to define mock.On call +// - _a0 *workflow.WatchRunDetailsResponse +func (_e *RunService_WatchRunDetailsServer_Expecter) Send(_a0 interface{}) *RunService_WatchRunDetailsServer_Send_Call { + return &RunService_WatchRunDetailsServer_Send_Call{Call: _e.mock.On("Send", _a0)} +} + +func (_c *RunService_WatchRunDetailsServer_Send_Call) Run(run func(_a0 *workflow.WatchRunDetailsResponse)) *RunService_WatchRunDetailsServer_Send_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*workflow.WatchRunDetailsResponse)) + }) + return _c +} + +func (_c *RunService_WatchRunDetailsServer_Send_Call) Return(_a0 error) *RunService_WatchRunDetailsServer_Send_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunDetailsServer_Send_Call) RunAndReturn(run func(*workflow.WatchRunDetailsResponse) error) *RunService_WatchRunDetailsServer_Send_Call { + _c.Call.Return(run) + return _c +} + +// SendHeader provides a mock function with given fields: _a0 +func (_m *RunService_WatchRunDetailsServer) SendHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SendHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchRunDetailsServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader' +type RunService_WatchRunDetailsServer_SendHeader_Call struct { + *mock.Call +} + +// SendHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunService_WatchRunDetailsServer_Expecter) SendHeader(_a0 interface{}) *RunService_WatchRunDetailsServer_SendHeader_Call { + return &RunService_WatchRunDetailsServer_SendHeader_Call{Call: _e.mock.On("SendHeader", _a0)} +} + +func (_c *RunService_WatchRunDetailsServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *RunService_WatchRunDetailsServer_SendHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunService_WatchRunDetailsServer_SendHeader_Call) Return(_a0 error) *RunService_WatchRunDetailsServer_SendHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunDetailsServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *RunService_WatchRunDetailsServer_SendHeader_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *RunService_WatchRunDetailsServer) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchRunDetailsServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type RunService_WatchRunDetailsServer_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchRunDetailsServer_Expecter) SendMsg(m interface{}) *RunService_WatchRunDetailsServer_SendMsg_Call { + return &RunService_WatchRunDetailsServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *RunService_WatchRunDetailsServer_SendMsg_Call) Run(run func(m any)) *RunService_WatchRunDetailsServer_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchRunDetailsServer_SendMsg_Call) Return(_a0 error) *RunService_WatchRunDetailsServer_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunDetailsServer_SendMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchRunDetailsServer_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// SetHeader provides a mock function with given fields: _a0 +func (_m *RunService_WatchRunDetailsServer) SetHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SetHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchRunDetailsServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader' +type RunService_WatchRunDetailsServer_SetHeader_Call struct { + *mock.Call +} + +// SetHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunService_WatchRunDetailsServer_Expecter) SetHeader(_a0 interface{}) *RunService_WatchRunDetailsServer_SetHeader_Call { + return &RunService_WatchRunDetailsServer_SetHeader_Call{Call: _e.mock.On("SetHeader", _a0)} +} + +func (_c *RunService_WatchRunDetailsServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *RunService_WatchRunDetailsServer_SetHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunService_WatchRunDetailsServer_SetHeader_Call) Return(_a0 error) *RunService_WatchRunDetailsServer_SetHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunDetailsServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *RunService_WatchRunDetailsServer_SetHeader_Call { + _c.Call.Return(run) + return _c +} + +// SetTrailer provides a mock function with given fields: _a0 +func (_m *RunService_WatchRunDetailsServer) SetTrailer(_a0 metadata.MD) { + _m.Called(_a0) +} + +// RunService_WatchRunDetailsServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer' +type RunService_WatchRunDetailsServer_SetTrailer_Call struct { + *mock.Call +} + +// SetTrailer is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunService_WatchRunDetailsServer_Expecter) SetTrailer(_a0 interface{}) *RunService_WatchRunDetailsServer_SetTrailer_Call { + return &RunService_WatchRunDetailsServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", _a0)} +} + +func (_c *RunService_WatchRunDetailsServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *RunService_WatchRunDetailsServer_SetTrailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunService_WatchRunDetailsServer_SetTrailer_Call) Return() *RunService_WatchRunDetailsServer_SetTrailer_Call { + _c.Call.Return() + return _c +} + +func (_c *RunService_WatchRunDetailsServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *RunService_WatchRunDetailsServer_SetTrailer_Call { + _c.Run(run) + return _c +} + +// NewRunService_WatchRunDetailsServer creates a new instance of RunService_WatchRunDetailsServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunService_WatchRunDetailsServer(t interface { + mock.TestingT + Cleanup(func()) +}) *RunService_WatchRunDetailsServer { + mock := &RunService_WatchRunDetailsServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/run_service_watch_runs_client.go b/gen/go/flyteidl2/workflow/mocks/run_service_watch_runs_client.go new file mode 100644 index 0000000000..be6207d66c --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/run_service_watch_runs_client.go @@ -0,0 +1,384 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + metadata "google.golang.org/grpc/metadata" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunService_WatchRunsClient is an autogenerated mock type for the RunService_WatchRunsClient type +type RunService_WatchRunsClient struct { + mock.Mock +} + +type RunService_WatchRunsClient_Expecter struct { + mock *mock.Mock +} + +func (_m *RunService_WatchRunsClient) EXPECT() *RunService_WatchRunsClient_Expecter { + return &RunService_WatchRunsClient_Expecter{mock: &_m.Mock} +} + +// CloseSend provides a mock function with no fields +func (_m *RunService_WatchRunsClient) CloseSend() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for CloseSend") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchRunsClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend' +type RunService_WatchRunsClient_CloseSend_Call struct { + *mock.Call +} + +// CloseSend is a helper method to define mock.On call +func (_e *RunService_WatchRunsClient_Expecter) CloseSend() *RunService_WatchRunsClient_CloseSend_Call { + return &RunService_WatchRunsClient_CloseSend_Call{Call: _e.mock.On("CloseSend")} +} + +func (_c *RunService_WatchRunsClient_CloseSend_Call) Run(run func()) *RunService_WatchRunsClient_CloseSend_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchRunsClient_CloseSend_Call) Return(_a0 error) *RunService_WatchRunsClient_CloseSend_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunsClient_CloseSend_Call) RunAndReturn(run func() error) *RunService_WatchRunsClient_CloseSend_Call { + _c.Call.Return(run) + return _c +} + +// Context provides a mock function with no fields +func (_m *RunService_WatchRunsClient) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// RunService_WatchRunsClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type RunService_WatchRunsClient_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *RunService_WatchRunsClient_Expecter) Context() *RunService_WatchRunsClient_Context_Call { + return &RunService_WatchRunsClient_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *RunService_WatchRunsClient_Context_Call) Run(run func()) *RunService_WatchRunsClient_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchRunsClient_Context_Call) Return(_a0 context.Context) *RunService_WatchRunsClient_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunsClient_Context_Call) RunAndReturn(run func() context.Context) *RunService_WatchRunsClient_Context_Call { + _c.Call.Return(run) + return _c +} + +// Header provides a mock function with no fields +func (_m *RunService_WatchRunsClient) Header() (metadata.MD, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Header") + } + + var r0 metadata.MD + var r1 error + if rf, ok := ret.Get(0).(func() (metadata.MD, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunService_WatchRunsClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header' +type RunService_WatchRunsClient_Header_Call struct { + *mock.Call +} + +// Header is a helper method to define mock.On call +func (_e *RunService_WatchRunsClient_Expecter) Header() *RunService_WatchRunsClient_Header_Call { + return &RunService_WatchRunsClient_Header_Call{Call: _e.mock.On("Header")} +} + +func (_c *RunService_WatchRunsClient_Header_Call) Run(run func()) *RunService_WatchRunsClient_Header_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchRunsClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *RunService_WatchRunsClient_Header_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunService_WatchRunsClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *RunService_WatchRunsClient_Header_Call { + _c.Call.Return(run) + return _c +} + +// Recv provides a mock function with no fields +func (_m *RunService_WatchRunsClient) Recv() (*workflow.WatchRunsResponse, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Recv") + } + + var r0 *workflow.WatchRunsResponse + var r1 error + if rf, ok := ret.Get(0).(func() (*workflow.WatchRunsResponse, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() *workflow.WatchRunsResponse); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.WatchRunsResponse) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunService_WatchRunsClient_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv' +type RunService_WatchRunsClient_Recv_Call struct { + *mock.Call +} + +// Recv is a helper method to define mock.On call +func (_e *RunService_WatchRunsClient_Expecter) Recv() *RunService_WatchRunsClient_Recv_Call { + return &RunService_WatchRunsClient_Recv_Call{Call: _e.mock.On("Recv")} +} + +func (_c *RunService_WatchRunsClient_Recv_Call) Run(run func()) *RunService_WatchRunsClient_Recv_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchRunsClient_Recv_Call) Return(_a0 *workflow.WatchRunsResponse, _a1 error) *RunService_WatchRunsClient_Recv_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunService_WatchRunsClient_Recv_Call) RunAndReturn(run func() (*workflow.WatchRunsResponse, error)) *RunService_WatchRunsClient_Recv_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *RunService_WatchRunsClient) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchRunsClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type RunService_WatchRunsClient_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchRunsClient_Expecter) RecvMsg(m interface{}) *RunService_WatchRunsClient_RecvMsg_Call { + return &RunService_WatchRunsClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *RunService_WatchRunsClient_RecvMsg_Call) Run(run func(m any)) *RunService_WatchRunsClient_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchRunsClient_RecvMsg_Call) Return(_a0 error) *RunService_WatchRunsClient_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunsClient_RecvMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchRunsClient_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *RunService_WatchRunsClient) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchRunsClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type RunService_WatchRunsClient_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchRunsClient_Expecter) SendMsg(m interface{}) *RunService_WatchRunsClient_SendMsg_Call { + return &RunService_WatchRunsClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *RunService_WatchRunsClient_SendMsg_Call) Run(run func(m any)) *RunService_WatchRunsClient_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchRunsClient_SendMsg_Call) Return(_a0 error) *RunService_WatchRunsClient_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunsClient_SendMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchRunsClient_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// Trailer provides a mock function with no fields +func (_m *RunService_WatchRunsClient) Trailer() metadata.MD { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Trailer") + } + + var r0 metadata.MD + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + return r0 +} + +// RunService_WatchRunsClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer' +type RunService_WatchRunsClient_Trailer_Call struct { + *mock.Call +} + +// Trailer is a helper method to define mock.On call +func (_e *RunService_WatchRunsClient_Expecter) Trailer() *RunService_WatchRunsClient_Trailer_Call { + return &RunService_WatchRunsClient_Trailer_Call{Call: _e.mock.On("Trailer")} +} + +func (_c *RunService_WatchRunsClient_Trailer_Call) Run(run func()) *RunService_WatchRunsClient_Trailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchRunsClient_Trailer_Call) Return(_a0 metadata.MD) *RunService_WatchRunsClient_Trailer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunsClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *RunService_WatchRunsClient_Trailer_Call { + _c.Call.Return(run) + return _c +} + +// NewRunService_WatchRunsClient creates a new instance of RunService_WatchRunsClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunService_WatchRunsClient(t interface { + mock.TestingT + Cleanup(func()) +}) *RunService_WatchRunsClient { + mock := &RunService_WatchRunsClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/run_service_watch_runs_server.go b/gen/go/flyteidl2/workflow/mocks/run_service_watch_runs_server.go new file mode 100644 index 0000000000..ae4213a53b --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/run_service_watch_runs_server.go @@ -0,0 +1,349 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + metadata "google.golang.org/grpc/metadata" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunService_WatchRunsServer is an autogenerated mock type for the RunService_WatchRunsServer type +type RunService_WatchRunsServer struct { + mock.Mock +} + +type RunService_WatchRunsServer_Expecter struct { + mock *mock.Mock +} + +func (_m *RunService_WatchRunsServer) EXPECT() *RunService_WatchRunsServer_Expecter { + return &RunService_WatchRunsServer_Expecter{mock: &_m.Mock} +} + +// Context provides a mock function with no fields +func (_m *RunService_WatchRunsServer) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// RunService_WatchRunsServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type RunService_WatchRunsServer_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *RunService_WatchRunsServer_Expecter) Context() *RunService_WatchRunsServer_Context_Call { + return &RunService_WatchRunsServer_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *RunService_WatchRunsServer_Context_Call) Run(run func()) *RunService_WatchRunsServer_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *RunService_WatchRunsServer_Context_Call) Return(_a0 context.Context) *RunService_WatchRunsServer_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunsServer_Context_Call) RunAndReturn(run func() context.Context) *RunService_WatchRunsServer_Context_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *RunService_WatchRunsServer) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchRunsServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type RunService_WatchRunsServer_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchRunsServer_Expecter) RecvMsg(m interface{}) *RunService_WatchRunsServer_RecvMsg_Call { + return &RunService_WatchRunsServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *RunService_WatchRunsServer_RecvMsg_Call) Run(run func(m any)) *RunService_WatchRunsServer_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchRunsServer_RecvMsg_Call) Return(_a0 error) *RunService_WatchRunsServer_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunsServer_RecvMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchRunsServer_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// Send provides a mock function with given fields: _a0 +func (_m *RunService_WatchRunsServer) Send(_a0 *workflow.WatchRunsResponse) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for Send") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*workflow.WatchRunsResponse) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchRunsServer_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send' +type RunService_WatchRunsServer_Send_Call struct { + *mock.Call +} + +// Send is a helper method to define mock.On call +// - _a0 *workflow.WatchRunsResponse +func (_e *RunService_WatchRunsServer_Expecter) Send(_a0 interface{}) *RunService_WatchRunsServer_Send_Call { + return &RunService_WatchRunsServer_Send_Call{Call: _e.mock.On("Send", _a0)} +} + +func (_c *RunService_WatchRunsServer_Send_Call) Run(run func(_a0 *workflow.WatchRunsResponse)) *RunService_WatchRunsServer_Send_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*workflow.WatchRunsResponse)) + }) + return _c +} + +func (_c *RunService_WatchRunsServer_Send_Call) Return(_a0 error) *RunService_WatchRunsServer_Send_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunsServer_Send_Call) RunAndReturn(run func(*workflow.WatchRunsResponse) error) *RunService_WatchRunsServer_Send_Call { + _c.Call.Return(run) + return _c +} + +// SendHeader provides a mock function with given fields: _a0 +func (_m *RunService_WatchRunsServer) SendHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SendHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchRunsServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader' +type RunService_WatchRunsServer_SendHeader_Call struct { + *mock.Call +} + +// SendHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunService_WatchRunsServer_Expecter) SendHeader(_a0 interface{}) *RunService_WatchRunsServer_SendHeader_Call { + return &RunService_WatchRunsServer_SendHeader_Call{Call: _e.mock.On("SendHeader", _a0)} +} + +func (_c *RunService_WatchRunsServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *RunService_WatchRunsServer_SendHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunService_WatchRunsServer_SendHeader_Call) Return(_a0 error) *RunService_WatchRunsServer_SendHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunsServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *RunService_WatchRunsServer_SendHeader_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *RunService_WatchRunsServer) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchRunsServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type RunService_WatchRunsServer_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *RunService_WatchRunsServer_Expecter) SendMsg(m interface{}) *RunService_WatchRunsServer_SendMsg_Call { + return &RunService_WatchRunsServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *RunService_WatchRunsServer_SendMsg_Call) Run(run func(m any)) *RunService_WatchRunsServer_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *RunService_WatchRunsServer_SendMsg_Call) Return(_a0 error) *RunService_WatchRunsServer_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunsServer_SendMsg_Call) RunAndReturn(run func(any) error) *RunService_WatchRunsServer_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// SetHeader provides a mock function with given fields: _a0 +func (_m *RunService_WatchRunsServer) SetHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SetHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunService_WatchRunsServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader' +type RunService_WatchRunsServer_SetHeader_Call struct { + *mock.Call +} + +// SetHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunService_WatchRunsServer_Expecter) SetHeader(_a0 interface{}) *RunService_WatchRunsServer_SetHeader_Call { + return &RunService_WatchRunsServer_SetHeader_Call{Call: _e.mock.On("SetHeader", _a0)} +} + +func (_c *RunService_WatchRunsServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *RunService_WatchRunsServer_SetHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunService_WatchRunsServer_SetHeader_Call) Return(_a0 error) *RunService_WatchRunsServer_SetHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunService_WatchRunsServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *RunService_WatchRunsServer_SetHeader_Call { + _c.Call.Return(run) + return _c +} + +// SetTrailer provides a mock function with given fields: _a0 +func (_m *RunService_WatchRunsServer) SetTrailer(_a0 metadata.MD) { + _m.Called(_a0) +} + +// RunService_WatchRunsServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer' +type RunService_WatchRunsServer_SetTrailer_Call struct { + *mock.Call +} + +// SetTrailer is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *RunService_WatchRunsServer_Expecter) SetTrailer(_a0 interface{}) *RunService_WatchRunsServer_SetTrailer_Call { + return &RunService_WatchRunsServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", _a0)} +} + +func (_c *RunService_WatchRunsServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *RunService_WatchRunsServer_SetTrailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *RunService_WatchRunsServer_SetTrailer_Call) Return() *RunService_WatchRunsServer_SetTrailer_Call { + _c.Call.Return() + return _c +} + +func (_c *RunService_WatchRunsServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *RunService_WatchRunsServer_SetTrailer_Call { + _c.Run(run) + return _c +} + +// NewRunService_WatchRunsServer creates a new instance of RunService_WatchRunsServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunService_WatchRunsServer(t interface { + mock.TestingT + Cleanup(func()) +}) *RunService_WatchRunsServer { + mock := &RunService_WatchRunsServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/state_service_client.go b/gen/go/flyteidl2/workflow/mocks/state_service_client.go new file mode 100644 index 0000000000..fc84931f3a --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/state_service_client.go @@ -0,0 +1,262 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + grpc "google.golang.org/grpc" + + mock "github.com/stretchr/testify/mock" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// StateServiceClient is an autogenerated mock type for the StateServiceClient type +type StateServiceClient struct { + mock.Mock +} + +type StateServiceClient_Expecter struct { + mock *mock.Mock +} + +func (_m *StateServiceClient) EXPECT() *StateServiceClient_Expecter { + return &StateServiceClient_Expecter{mock: &_m.Mock} +} + +// Get provides a mock function with given fields: ctx, in, opts +func (_m *StateServiceClient) Get(ctx context.Context, in *workflow.GetRequest, opts ...grpc.CallOption) (*workflow.GetResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 *workflow.GetResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.GetRequest, ...grpc.CallOption) (*workflow.GetResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.GetRequest, ...grpc.CallOption) *workflow.GetResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.GetResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.GetRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StateServiceClient_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type StateServiceClient_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.GetRequest +// - opts ...grpc.CallOption +func (_e *StateServiceClient_Expecter) Get(ctx interface{}, in interface{}, opts ...interface{}) *StateServiceClient_Get_Call { + return &StateServiceClient_Get_Call{Call: _e.mock.On("Get", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *StateServiceClient_Get_Call) Run(run func(ctx context.Context, in *workflow.GetRequest, opts ...grpc.CallOption)) *StateServiceClient_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.GetRequest), variadicArgs...) + }) + return _c +} + +func (_c *StateServiceClient_Get_Call) Return(_a0 *workflow.GetResponse, _a1 error) *StateServiceClient_Get_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StateServiceClient_Get_Call) RunAndReturn(run func(context.Context, *workflow.GetRequest, ...grpc.CallOption) (*workflow.GetResponse, error)) *StateServiceClient_Get_Call { + _c.Call.Return(run) + return _c +} + +// Put provides a mock function with given fields: ctx, in, opts +func (_m *StateServiceClient) Put(ctx context.Context, in *workflow.PutRequest, opts ...grpc.CallOption) (*workflow.PutResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Put") + } + + var r0 *workflow.PutResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.PutRequest, ...grpc.CallOption) (*workflow.PutResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.PutRequest, ...grpc.CallOption) *workflow.PutResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.PutResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.PutRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StateServiceClient_Put_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Put' +type StateServiceClient_Put_Call struct { + *mock.Call +} + +// Put is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.PutRequest +// - opts ...grpc.CallOption +func (_e *StateServiceClient_Expecter) Put(ctx interface{}, in interface{}, opts ...interface{}) *StateServiceClient_Put_Call { + return &StateServiceClient_Put_Call{Call: _e.mock.On("Put", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *StateServiceClient_Put_Call) Run(run func(ctx context.Context, in *workflow.PutRequest, opts ...grpc.CallOption)) *StateServiceClient_Put_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.PutRequest), variadicArgs...) + }) + return _c +} + +func (_c *StateServiceClient_Put_Call) Return(_a0 *workflow.PutResponse, _a1 error) *StateServiceClient_Put_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StateServiceClient_Put_Call) RunAndReturn(run func(context.Context, *workflow.PutRequest, ...grpc.CallOption) (*workflow.PutResponse, error)) *StateServiceClient_Put_Call { + _c.Call.Return(run) + return _c +} + +// Watch provides a mock function with given fields: ctx, in, opts +func (_m *StateServiceClient) Watch(ctx context.Context, in *workflow.WatchRequest, opts ...grpc.CallOption) (workflow.StateService_WatchClient, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Watch") + } + + var r0 workflow.StateService_WatchClient + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.WatchRequest, ...grpc.CallOption) (workflow.StateService_WatchClient, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.WatchRequest, ...grpc.CallOption) workflow.StateService_WatchClient); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(workflow.StateService_WatchClient) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.WatchRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StateServiceClient_Watch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Watch' +type StateServiceClient_Watch_Call struct { + *mock.Call +} + +// Watch is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.WatchRequest +// - opts ...grpc.CallOption +func (_e *StateServiceClient_Expecter) Watch(ctx interface{}, in interface{}, opts ...interface{}) *StateServiceClient_Watch_Call { + return &StateServiceClient_Watch_Call{Call: _e.mock.On("Watch", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *StateServiceClient_Watch_Call) Run(run func(ctx context.Context, in *workflow.WatchRequest, opts ...grpc.CallOption)) *StateServiceClient_Watch_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.WatchRequest), variadicArgs...) + }) + return _c +} + +func (_c *StateServiceClient_Watch_Call) Return(_a0 workflow.StateService_WatchClient, _a1 error) *StateServiceClient_Watch_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StateServiceClient_Watch_Call) RunAndReturn(run func(context.Context, *workflow.WatchRequest, ...grpc.CallOption) (workflow.StateService_WatchClient, error)) *StateServiceClient_Watch_Call { + _c.Call.Return(run) + return _c +} + +// NewStateServiceClient creates a new instance of StateServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewStateServiceClient(t interface { + mock.TestingT + Cleanup(func()) +}) *StateServiceClient { + mock := &StateServiceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/state_service_server.go b/gen/go/flyteidl2/workflow/mocks/state_service_server.go new file mode 100644 index 0000000000..93b9d609b2 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/state_service_server.go @@ -0,0 +1,202 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + mock "github.com/stretchr/testify/mock" +) + +// StateServiceServer is an autogenerated mock type for the StateServiceServer type +type StateServiceServer struct { + mock.Mock +} + +type StateServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *StateServiceServer) EXPECT() *StateServiceServer_Expecter { + return &StateServiceServer_Expecter{mock: &_m.Mock} +} + +// Get provides a mock function with given fields: _a0, _a1 +func (_m *StateServiceServer) Get(_a0 context.Context, _a1 *workflow.GetRequest) (*workflow.GetResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 *workflow.GetResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.GetRequest) (*workflow.GetResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.GetRequest) *workflow.GetResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.GetResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.GetRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StateServiceServer_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type StateServiceServer_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *workflow.GetRequest +func (_e *StateServiceServer_Expecter) Get(_a0 interface{}, _a1 interface{}) *StateServiceServer_Get_Call { + return &StateServiceServer_Get_Call{Call: _e.mock.On("Get", _a0, _a1)} +} + +func (_c *StateServiceServer_Get_Call) Run(run func(_a0 context.Context, _a1 *workflow.GetRequest)) *StateServiceServer_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.GetRequest)) + }) + return _c +} + +func (_c *StateServiceServer_Get_Call) Return(_a0 *workflow.GetResponse, _a1 error) *StateServiceServer_Get_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StateServiceServer_Get_Call) RunAndReturn(run func(context.Context, *workflow.GetRequest) (*workflow.GetResponse, error)) *StateServiceServer_Get_Call { + _c.Call.Return(run) + return _c +} + +// Put provides a mock function with given fields: _a0, _a1 +func (_m *StateServiceServer) Put(_a0 context.Context, _a1 *workflow.PutRequest) (*workflow.PutResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for Put") + } + + var r0 *workflow.PutResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.PutRequest) (*workflow.PutResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.PutRequest) *workflow.PutResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.PutResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.PutRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StateServiceServer_Put_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Put' +type StateServiceServer_Put_Call struct { + *mock.Call +} + +// Put is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *workflow.PutRequest +func (_e *StateServiceServer_Expecter) Put(_a0 interface{}, _a1 interface{}) *StateServiceServer_Put_Call { + return &StateServiceServer_Put_Call{Call: _e.mock.On("Put", _a0, _a1)} +} + +func (_c *StateServiceServer_Put_Call) Run(run func(_a0 context.Context, _a1 *workflow.PutRequest)) *StateServiceServer_Put_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.PutRequest)) + }) + return _c +} + +func (_c *StateServiceServer_Put_Call) Return(_a0 *workflow.PutResponse, _a1 error) *StateServiceServer_Put_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StateServiceServer_Put_Call) RunAndReturn(run func(context.Context, *workflow.PutRequest) (*workflow.PutResponse, error)) *StateServiceServer_Put_Call { + _c.Call.Return(run) + return _c +} + +// Watch provides a mock function with given fields: _a0, _a1 +func (_m *StateServiceServer) Watch(_a0 *workflow.WatchRequest, _a1 workflow.StateService_WatchServer) error { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for Watch") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*workflow.WatchRequest, workflow.StateService_WatchServer) error); ok { + r0 = rf(_a0, _a1) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// StateServiceServer_Watch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Watch' +type StateServiceServer_Watch_Call struct { + *mock.Call +} + +// Watch is a helper method to define mock.On call +// - _a0 *workflow.WatchRequest +// - _a1 workflow.StateService_WatchServer +func (_e *StateServiceServer_Expecter) Watch(_a0 interface{}, _a1 interface{}) *StateServiceServer_Watch_Call { + return &StateServiceServer_Watch_Call{Call: _e.mock.On("Watch", _a0, _a1)} +} + +func (_c *StateServiceServer_Watch_Call) Run(run func(_a0 *workflow.WatchRequest, _a1 workflow.StateService_WatchServer)) *StateServiceServer_Watch_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*workflow.WatchRequest), args[1].(workflow.StateService_WatchServer)) + }) + return _c +} + +func (_c *StateServiceServer_Watch_Call) Return(_a0 error) *StateServiceServer_Watch_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StateServiceServer_Watch_Call) RunAndReturn(run func(*workflow.WatchRequest, workflow.StateService_WatchServer) error) *StateServiceServer_Watch_Call { + _c.Call.Return(run) + return _c +} + +// NewStateServiceServer creates a new instance of StateServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewStateServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *StateServiceServer { + mock := &StateServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/state_service_watch_client.go b/gen/go/flyteidl2/workflow/mocks/state_service_watch_client.go new file mode 100644 index 0000000000..e0e3008135 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/state_service_watch_client.go @@ -0,0 +1,384 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + metadata "google.golang.org/grpc/metadata" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// StateService_WatchClient is an autogenerated mock type for the StateService_WatchClient type +type StateService_WatchClient struct { + mock.Mock +} + +type StateService_WatchClient_Expecter struct { + mock *mock.Mock +} + +func (_m *StateService_WatchClient) EXPECT() *StateService_WatchClient_Expecter { + return &StateService_WatchClient_Expecter{mock: &_m.Mock} +} + +// CloseSend provides a mock function with no fields +func (_m *StateService_WatchClient) CloseSend() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for CloseSend") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// StateService_WatchClient_CloseSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSend' +type StateService_WatchClient_CloseSend_Call struct { + *mock.Call +} + +// CloseSend is a helper method to define mock.On call +func (_e *StateService_WatchClient_Expecter) CloseSend() *StateService_WatchClient_CloseSend_Call { + return &StateService_WatchClient_CloseSend_Call{Call: _e.mock.On("CloseSend")} +} + +func (_c *StateService_WatchClient_CloseSend_Call) Run(run func()) *StateService_WatchClient_CloseSend_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *StateService_WatchClient_CloseSend_Call) Return(_a0 error) *StateService_WatchClient_CloseSend_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StateService_WatchClient_CloseSend_Call) RunAndReturn(run func() error) *StateService_WatchClient_CloseSend_Call { + _c.Call.Return(run) + return _c +} + +// Context provides a mock function with no fields +func (_m *StateService_WatchClient) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// StateService_WatchClient_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type StateService_WatchClient_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *StateService_WatchClient_Expecter) Context() *StateService_WatchClient_Context_Call { + return &StateService_WatchClient_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *StateService_WatchClient_Context_Call) Run(run func()) *StateService_WatchClient_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *StateService_WatchClient_Context_Call) Return(_a0 context.Context) *StateService_WatchClient_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StateService_WatchClient_Context_Call) RunAndReturn(run func() context.Context) *StateService_WatchClient_Context_Call { + _c.Call.Return(run) + return _c +} + +// Header provides a mock function with no fields +func (_m *StateService_WatchClient) Header() (metadata.MD, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Header") + } + + var r0 metadata.MD + var r1 error + if rf, ok := ret.Get(0).(func() (metadata.MD, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StateService_WatchClient_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header' +type StateService_WatchClient_Header_Call struct { + *mock.Call +} + +// Header is a helper method to define mock.On call +func (_e *StateService_WatchClient_Expecter) Header() *StateService_WatchClient_Header_Call { + return &StateService_WatchClient_Header_Call{Call: _e.mock.On("Header")} +} + +func (_c *StateService_WatchClient_Header_Call) Run(run func()) *StateService_WatchClient_Header_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *StateService_WatchClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *StateService_WatchClient_Header_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StateService_WatchClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *StateService_WatchClient_Header_Call { + _c.Call.Return(run) + return _c +} + +// Recv provides a mock function with no fields +func (_m *StateService_WatchClient) Recv() (*workflow.WatchResponse, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Recv") + } + + var r0 *workflow.WatchResponse + var r1 error + if rf, ok := ret.Get(0).(func() (*workflow.WatchResponse, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() *workflow.WatchResponse); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.WatchResponse) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StateService_WatchClient_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv' +type StateService_WatchClient_Recv_Call struct { + *mock.Call +} + +// Recv is a helper method to define mock.On call +func (_e *StateService_WatchClient_Expecter) Recv() *StateService_WatchClient_Recv_Call { + return &StateService_WatchClient_Recv_Call{Call: _e.mock.On("Recv")} +} + +func (_c *StateService_WatchClient_Recv_Call) Run(run func()) *StateService_WatchClient_Recv_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *StateService_WatchClient_Recv_Call) Return(_a0 *workflow.WatchResponse, _a1 error) *StateService_WatchClient_Recv_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StateService_WatchClient_Recv_Call) RunAndReturn(run func() (*workflow.WatchResponse, error)) *StateService_WatchClient_Recv_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *StateService_WatchClient) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// StateService_WatchClient_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type StateService_WatchClient_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *StateService_WatchClient_Expecter) RecvMsg(m interface{}) *StateService_WatchClient_RecvMsg_Call { + return &StateService_WatchClient_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *StateService_WatchClient_RecvMsg_Call) Run(run func(m any)) *StateService_WatchClient_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *StateService_WatchClient_RecvMsg_Call) Return(_a0 error) *StateService_WatchClient_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StateService_WatchClient_RecvMsg_Call) RunAndReturn(run func(any) error) *StateService_WatchClient_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *StateService_WatchClient) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// StateService_WatchClient_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type StateService_WatchClient_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *StateService_WatchClient_Expecter) SendMsg(m interface{}) *StateService_WatchClient_SendMsg_Call { + return &StateService_WatchClient_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *StateService_WatchClient_SendMsg_Call) Run(run func(m any)) *StateService_WatchClient_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *StateService_WatchClient_SendMsg_Call) Return(_a0 error) *StateService_WatchClient_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StateService_WatchClient_SendMsg_Call) RunAndReturn(run func(any) error) *StateService_WatchClient_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// Trailer provides a mock function with no fields +func (_m *StateService_WatchClient) Trailer() metadata.MD { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Trailer") + } + + var r0 metadata.MD + if rf, ok := ret.Get(0).(func() metadata.MD); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(metadata.MD) + } + } + + return r0 +} + +// StateService_WatchClient_Trailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trailer' +type StateService_WatchClient_Trailer_Call struct { + *mock.Call +} + +// Trailer is a helper method to define mock.On call +func (_e *StateService_WatchClient_Expecter) Trailer() *StateService_WatchClient_Trailer_Call { + return &StateService_WatchClient_Trailer_Call{Call: _e.mock.On("Trailer")} +} + +func (_c *StateService_WatchClient_Trailer_Call) Run(run func()) *StateService_WatchClient_Trailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *StateService_WatchClient_Trailer_Call) Return(_a0 metadata.MD) *StateService_WatchClient_Trailer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StateService_WatchClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *StateService_WatchClient_Trailer_Call { + _c.Call.Return(run) + return _c +} + +// NewStateService_WatchClient creates a new instance of StateService_WatchClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewStateService_WatchClient(t interface { + mock.TestingT + Cleanup(func()) +}) *StateService_WatchClient { + mock := &StateService_WatchClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/state_service_watch_server.go b/gen/go/flyteidl2/workflow/mocks/state_service_watch_server.go new file mode 100644 index 0000000000..4eb91b46f4 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/state_service_watch_server.go @@ -0,0 +1,349 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + metadata "google.golang.org/grpc/metadata" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// StateService_WatchServer is an autogenerated mock type for the StateService_WatchServer type +type StateService_WatchServer struct { + mock.Mock +} + +type StateService_WatchServer_Expecter struct { + mock *mock.Mock +} + +func (_m *StateService_WatchServer) EXPECT() *StateService_WatchServer_Expecter { + return &StateService_WatchServer_Expecter{mock: &_m.Mock} +} + +// Context provides a mock function with no fields +func (_m *StateService_WatchServer) Context() context.Context { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Context") + } + + var r0 context.Context + if rf, ok := ret.Get(0).(func() context.Context); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + return r0 +} + +// StateService_WatchServer_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context' +type StateService_WatchServer_Context_Call struct { + *mock.Call +} + +// Context is a helper method to define mock.On call +func (_e *StateService_WatchServer_Expecter) Context() *StateService_WatchServer_Context_Call { + return &StateService_WatchServer_Context_Call{Call: _e.mock.On("Context")} +} + +func (_c *StateService_WatchServer_Context_Call) Run(run func()) *StateService_WatchServer_Context_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *StateService_WatchServer_Context_Call) Return(_a0 context.Context) *StateService_WatchServer_Context_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StateService_WatchServer_Context_Call) RunAndReturn(run func() context.Context) *StateService_WatchServer_Context_Call { + _c.Call.Return(run) + return _c +} + +// RecvMsg provides a mock function with given fields: m +func (_m *StateService_WatchServer) RecvMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for RecvMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// StateService_WatchServer_RecvMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvMsg' +type StateService_WatchServer_RecvMsg_Call struct { + *mock.Call +} + +// RecvMsg is a helper method to define mock.On call +// - m any +func (_e *StateService_WatchServer_Expecter) RecvMsg(m interface{}) *StateService_WatchServer_RecvMsg_Call { + return &StateService_WatchServer_RecvMsg_Call{Call: _e.mock.On("RecvMsg", m)} +} + +func (_c *StateService_WatchServer_RecvMsg_Call) Run(run func(m any)) *StateService_WatchServer_RecvMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *StateService_WatchServer_RecvMsg_Call) Return(_a0 error) *StateService_WatchServer_RecvMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StateService_WatchServer_RecvMsg_Call) RunAndReturn(run func(any) error) *StateService_WatchServer_RecvMsg_Call { + _c.Call.Return(run) + return _c +} + +// Send provides a mock function with given fields: _a0 +func (_m *StateService_WatchServer) Send(_a0 *workflow.WatchResponse) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for Send") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*workflow.WatchResponse) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// StateService_WatchServer_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send' +type StateService_WatchServer_Send_Call struct { + *mock.Call +} + +// Send is a helper method to define mock.On call +// - _a0 *workflow.WatchResponse +func (_e *StateService_WatchServer_Expecter) Send(_a0 interface{}) *StateService_WatchServer_Send_Call { + return &StateService_WatchServer_Send_Call{Call: _e.mock.On("Send", _a0)} +} + +func (_c *StateService_WatchServer_Send_Call) Run(run func(_a0 *workflow.WatchResponse)) *StateService_WatchServer_Send_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*workflow.WatchResponse)) + }) + return _c +} + +func (_c *StateService_WatchServer_Send_Call) Return(_a0 error) *StateService_WatchServer_Send_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StateService_WatchServer_Send_Call) RunAndReturn(run func(*workflow.WatchResponse) error) *StateService_WatchServer_Send_Call { + _c.Call.Return(run) + return _c +} + +// SendHeader provides a mock function with given fields: _a0 +func (_m *StateService_WatchServer) SendHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SendHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// StateService_WatchServer_SendHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendHeader' +type StateService_WatchServer_SendHeader_Call struct { + *mock.Call +} + +// SendHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *StateService_WatchServer_Expecter) SendHeader(_a0 interface{}) *StateService_WatchServer_SendHeader_Call { + return &StateService_WatchServer_SendHeader_Call{Call: _e.mock.On("SendHeader", _a0)} +} + +func (_c *StateService_WatchServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *StateService_WatchServer_SendHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *StateService_WatchServer_SendHeader_Call) Return(_a0 error) *StateService_WatchServer_SendHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StateService_WatchServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *StateService_WatchServer_SendHeader_Call { + _c.Call.Return(run) + return _c +} + +// SendMsg provides a mock function with given fields: m +func (_m *StateService_WatchServer) SendMsg(m any) error { + ret := _m.Called(m) + + if len(ret) == 0 { + panic("no return value specified for SendMsg") + } + + var r0 error + if rf, ok := ret.Get(0).(func(any) error); ok { + r0 = rf(m) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// StateService_WatchServer_SendMsg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMsg' +type StateService_WatchServer_SendMsg_Call struct { + *mock.Call +} + +// SendMsg is a helper method to define mock.On call +// - m any +func (_e *StateService_WatchServer_Expecter) SendMsg(m interface{}) *StateService_WatchServer_SendMsg_Call { + return &StateService_WatchServer_SendMsg_Call{Call: _e.mock.On("SendMsg", m)} +} + +func (_c *StateService_WatchServer_SendMsg_Call) Run(run func(m any)) *StateService_WatchServer_SendMsg_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(any)) + }) + return _c +} + +func (_c *StateService_WatchServer_SendMsg_Call) Return(_a0 error) *StateService_WatchServer_SendMsg_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StateService_WatchServer_SendMsg_Call) RunAndReturn(run func(any) error) *StateService_WatchServer_SendMsg_Call { + _c.Call.Return(run) + return _c +} + +// SetHeader provides a mock function with given fields: _a0 +func (_m *StateService_WatchServer) SetHeader(_a0 metadata.MD) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for SetHeader") + } + + var r0 error + if rf, ok := ret.Get(0).(func(metadata.MD) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// StateService_WatchServer_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader' +type StateService_WatchServer_SetHeader_Call struct { + *mock.Call +} + +// SetHeader is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *StateService_WatchServer_Expecter) SetHeader(_a0 interface{}) *StateService_WatchServer_SetHeader_Call { + return &StateService_WatchServer_SetHeader_Call{Call: _e.mock.On("SetHeader", _a0)} +} + +func (_c *StateService_WatchServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *StateService_WatchServer_SetHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *StateService_WatchServer_SetHeader_Call) Return(_a0 error) *StateService_WatchServer_SetHeader_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StateService_WatchServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *StateService_WatchServer_SetHeader_Call { + _c.Call.Return(run) + return _c +} + +// SetTrailer provides a mock function with given fields: _a0 +func (_m *StateService_WatchServer) SetTrailer(_a0 metadata.MD) { + _m.Called(_a0) +} + +// StateService_WatchServer_SetTrailer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrailer' +type StateService_WatchServer_SetTrailer_Call struct { + *mock.Call +} + +// SetTrailer is a helper method to define mock.On call +// - _a0 metadata.MD +func (_e *StateService_WatchServer_Expecter) SetTrailer(_a0 interface{}) *StateService_WatchServer_SetTrailer_Call { + return &StateService_WatchServer_SetTrailer_Call{Call: _e.mock.On("SetTrailer", _a0)} +} + +func (_c *StateService_WatchServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *StateService_WatchServer_SetTrailer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(metadata.MD)) + }) + return _c +} + +func (_c *StateService_WatchServer_SetTrailer_Call) Return() *StateService_WatchServer_SetTrailer_Call { + _c.Call.Return() + return _c +} + +func (_c *StateService_WatchServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *StateService_WatchServer_SetTrailer_Call { + _c.Run(run) + return _c +} + +// NewStateService_WatchServer creates a new instance of StateService_WatchServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewStateService_WatchServer(t interface { + mock.TestingT + Cleanup(func()) +}) *StateService_WatchServer { + mock := &StateService_WatchServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/translator_service_client.go b/gen/go/flyteidl2/workflow/mocks/translator_service_client.go new file mode 100644 index 0000000000..2a67700850 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/translator_service_client.go @@ -0,0 +1,336 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + grpc "google.golang.org/grpc" + + mock "github.com/stretchr/testify/mock" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// TranslatorServiceClient is an autogenerated mock type for the TranslatorServiceClient type +type TranslatorServiceClient struct { + mock.Mock +} + +type TranslatorServiceClient_Expecter struct { + mock *mock.Mock +} + +func (_m *TranslatorServiceClient) EXPECT() *TranslatorServiceClient_Expecter { + return &TranslatorServiceClient_Expecter{mock: &_m.Mock} +} + +// JsonValuesToLiterals provides a mock function with given fields: ctx, in, opts +func (_m *TranslatorServiceClient) JsonValuesToLiterals(ctx context.Context, in *workflow.JsonValuesToLiteralsRequest, opts ...grpc.CallOption) (*workflow.JsonValuesToLiteralsResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for JsonValuesToLiterals") + } + + var r0 *workflow.JsonValuesToLiteralsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.JsonValuesToLiteralsRequest, ...grpc.CallOption) (*workflow.JsonValuesToLiteralsResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.JsonValuesToLiteralsRequest, ...grpc.CallOption) *workflow.JsonValuesToLiteralsResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.JsonValuesToLiteralsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.JsonValuesToLiteralsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TranslatorServiceClient_JsonValuesToLiterals_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JsonValuesToLiterals' +type TranslatorServiceClient_JsonValuesToLiterals_Call struct { + *mock.Call +} + +// JsonValuesToLiterals is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.JsonValuesToLiteralsRequest +// - opts ...grpc.CallOption +func (_e *TranslatorServiceClient_Expecter) JsonValuesToLiterals(ctx interface{}, in interface{}, opts ...interface{}) *TranslatorServiceClient_JsonValuesToLiterals_Call { + return &TranslatorServiceClient_JsonValuesToLiterals_Call{Call: _e.mock.On("JsonValuesToLiterals", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *TranslatorServiceClient_JsonValuesToLiterals_Call) Run(run func(ctx context.Context, in *workflow.JsonValuesToLiteralsRequest, opts ...grpc.CallOption)) *TranslatorServiceClient_JsonValuesToLiterals_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.JsonValuesToLiteralsRequest), variadicArgs...) + }) + return _c +} + +func (_c *TranslatorServiceClient_JsonValuesToLiterals_Call) Return(_a0 *workflow.JsonValuesToLiteralsResponse, _a1 error) *TranslatorServiceClient_JsonValuesToLiterals_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TranslatorServiceClient_JsonValuesToLiterals_Call) RunAndReturn(run func(context.Context, *workflow.JsonValuesToLiteralsRequest, ...grpc.CallOption) (*workflow.JsonValuesToLiteralsResponse, error)) *TranslatorServiceClient_JsonValuesToLiterals_Call { + _c.Call.Return(run) + return _c +} + +// LaunchFormJsonToLiterals provides a mock function with given fields: ctx, in, opts +func (_m *TranslatorServiceClient) LaunchFormJsonToLiterals(ctx context.Context, in *workflow.LaunchFormJsonToLiteralsRequest, opts ...grpc.CallOption) (*workflow.LaunchFormJsonToLiteralsResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for LaunchFormJsonToLiterals") + } + + var r0 *workflow.LaunchFormJsonToLiteralsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.LaunchFormJsonToLiteralsRequest, ...grpc.CallOption) (*workflow.LaunchFormJsonToLiteralsResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.LaunchFormJsonToLiteralsRequest, ...grpc.CallOption) *workflow.LaunchFormJsonToLiteralsResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.LaunchFormJsonToLiteralsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.LaunchFormJsonToLiteralsRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TranslatorServiceClient_LaunchFormJsonToLiterals_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LaunchFormJsonToLiterals' +type TranslatorServiceClient_LaunchFormJsonToLiterals_Call struct { + *mock.Call +} + +// LaunchFormJsonToLiterals is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.LaunchFormJsonToLiteralsRequest +// - opts ...grpc.CallOption +func (_e *TranslatorServiceClient_Expecter) LaunchFormJsonToLiterals(ctx interface{}, in interface{}, opts ...interface{}) *TranslatorServiceClient_LaunchFormJsonToLiterals_Call { + return &TranslatorServiceClient_LaunchFormJsonToLiterals_Call{Call: _e.mock.On("LaunchFormJsonToLiterals", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *TranslatorServiceClient_LaunchFormJsonToLiterals_Call) Run(run func(ctx context.Context, in *workflow.LaunchFormJsonToLiteralsRequest, opts ...grpc.CallOption)) *TranslatorServiceClient_LaunchFormJsonToLiterals_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.LaunchFormJsonToLiteralsRequest), variadicArgs...) + }) + return _c +} + +func (_c *TranslatorServiceClient_LaunchFormJsonToLiterals_Call) Return(_a0 *workflow.LaunchFormJsonToLiteralsResponse, _a1 error) *TranslatorServiceClient_LaunchFormJsonToLiterals_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TranslatorServiceClient_LaunchFormJsonToLiterals_Call) RunAndReturn(run func(context.Context, *workflow.LaunchFormJsonToLiteralsRequest, ...grpc.CallOption) (*workflow.LaunchFormJsonToLiteralsResponse, error)) *TranslatorServiceClient_LaunchFormJsonToLiterals_Call { + _c.Call.Return(run) + return _c +} + +// LiteralsToLaunchFormJson provides a mock function with given fields: ctx, in, opts +func (_m *TranslatorServiceClient) LiteralsToLaunchFormJson(ctx context.Context, in *workflow.LiteralsToLaunchFormJsonRequest, opts ...grpc.CallOption) (*workflow.LiteralsToLaunchFormJsonResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for LiteralsToLaunchFormJson") + } + + var r0 *workflow.LiteralsToLaunchFormJsonResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.LiteralsToLaunchFormJsonRequest, ...grpc.CallOption) (*workflow.LiteralsToLaunchFormJsonResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.LiteralsToLaunchFormJsonRequest, ...grpc.CallOption) *workflow.LiteralsToLaunchFormJsonResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.LiteralsToLaunchFormJsonResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.LiteralsToLaunchFormJsonRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TranslatorServiceClient_LiteralsToLaunchFormJson_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LiteralsToLaunchFormJson' +type TranslatorServiceClient_LiteralsToLaunchFormJson_Call struct { + *mock.Call +} + +// LiteralsToLaunchFormJson is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.LiteralsToLaunchFormJsonRequest +// - opts ...grpc.CallOption +func (_e *TranslatorServiceClient_Expecter) LiteralsToLaunchFormJson(ctx interface{}, in interface{}, opts ...interface{}) *TranslatorServiceClient_LiteralsToLaunchFormJson_Call { + return &TranslatorServiceClient_LiteralsToLaunchFormJson_Call{Call: _e.mock.On("LiteralsToLaunchFormJson", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *TranslatorServiceClient_LiteralsToLaunchFormJson_Call) Run(run func(ctx context.Context, in *workflow.LiteralsToLaunchFormJsonRequest, opts ...grpc.CallOption)) *TranslatorServiceClient_LiteralsToLaunchFormJson_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.LiteralsToLaunchFormJsonRequest), variadicArgs...) + }) + return _c +} + +func (_c *TranslatorServiceClient_LiteralsToLaunchFormJson_Call) Return(_a0 *workflow.LiteralsToLaunchFormJsonResponse, _a1 error) *TranslatorServiceClient_LiteralsToLaunchFormJson_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TranslatorServiceClient_LiteralsToLaunchFormJson_Call) RunAndReturn(run func(context.Context, *workflow.LiteralsToLaunchFormJsonRequest, ...grpc.CallOption) (*workflow.LiteralsToLaunchFormJsonResponse, error)) *TranslatorServiceClient_LiteralsToLaunchFormJson_Call { + _c.Call.Return(run) + return _c +} + +// TaskSpecToLaunchFormJson provides a mock function with given fields: ctx, in, opts +func (_m *TranslatorServiceClient) TaskSpecToLaunchFormJson(ctx context.Context, in *workflow.TaskSpecToLaunchFormJsonRequest, opts ...grpc.CallOption) (*workflow.TaskSpecToLaunchFormJsonResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for TaskSpecToLaunchFormJson") + } + + var r0 *workflow.TaskSpecToLaunchFormJsonResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.TaskSpecToLaunchFormJsonRequest, ...grpc.CallOption) (*workflow.TaskSpecToLaunchFormJsonResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.TaskSpecToLaunchFormJsonRequest, ...grpc.CallOption) *workflow.TaskSpecToLaunchFormJsonResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.TaskSpecToLaunchFormJsonResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.TaskSpecToLaunchFormJsonRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TranslatorServiceClient_TaskSpecToLaunchFormJson_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TaskSpecToLaunchFormJson' +type TranslatorServiceClient_TaskSpecToLaunchFormJson_Call struct { + *mock.Call +} + +// TaskSpecToLaunchFormJson is a helper method to define mock.On call +// - ctx context.Context +// - in *workflow.TaskSpecToLaunchFormJsonRequest +// - opts ...grpc.CallOption +func (_e *TranslatorServiceClient_Expecter) TaskSpecToLaunchFormJson(ctx interface{}, in interface{}, opts ...interface{}) *TranslatorServiceClient_TaskSpecToLaunchFormJson_Call { + return &TranslatorServiceClient_TaskSpecToLaunchFormJson_Call{Call: _e.mock.On("TaskSpecToLaunchFormJson", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *TranslatorServiceClient_TaskSpecToLaunchFormJson_Call) Run(run func(ctx context.Context, in *workflow.TaskSpecToLaunchFormJsonRequest, opts ...grpc.CallOption)) *TranslatorServiceClient_TaskSpecToLaunchFormJson_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*workflow.TaskSpecToLaunchFormJsonRequest), variadicArgs...) + }) + return _c +} + +func (_c *TranslatorServiceClient_TaskSpecToLaunchFormJson_Call) Return(_a0 *workflow.TaskSpecToLaunchFormJsonResponse, _a1 error) *TranslatorServiceClient_TaskSpecToLaunchFormJson_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TranslatorServiceClient_TaskSpecToLaunchFormJson_Call) RunAndReturn(run func(context.Context, *workflow.TaskSpecToLaunchFormJsonRequest, ...grpc.CallOption) (*workflow.TaskSpecToLaunchFormJsonResponse, error)) *TranslatorServiceClient_TaskSpecToLaunchFormJson_Call { + _c.Call.Return(run) + return _c +} + +// NewTranslatorServiceClient creates a new instance of TranslatorServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTranslatorServiceClient(t interface { + mock.TestingT + Cleanup(func()) +}) *TranslatorServiceClient { + mock := &TranslatorServiceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/translator_service_server.go b/gen/go/flyteidl2/workflow/mocks/translator_service_server.go new file mode 100644 index 0000000000..35aac02211 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/translator_service_server.go @@ -0,0 +1,273 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + mock "github.com/stretchr/testify/mock" +) + +// TranslatorServiceServer is an autogenerated mock type for the TranslatorServiceServer type +type TranslatorServiceServer struct { + mock.Mock +} + +type TranslatorServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *TranslatorServiceServer) EXPECT() *TranslatorServiceServer_Expecter { + return &TranslatorServiceServer_Expecter{mock: &_m.Mock} +} + +// JsonValuesToLiterals provides a mock function with given fields: _a0, _a1 +func (_m *TranslatorServiceServer) JsonValuesToLiterals(_a0 context.Context, _a1 *workflow.JsonValuesToLiteralsRequest) (*workflow.JsonValuesToLiteralsResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for JsonValuesToLiterals") + } + + var r0 *workflow.JsonValuesToLiteralsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.JsonValuesToLiteralsRequest) (*workflow.JsonValuesToLiteralsResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.JsonValuesToLiteralsRequest) *workflow.JsonValuesToLiteralsResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.JsonValuesToLiteralsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.JsonValuesToLiteralsRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TranslatorServiceServer_JsonValuesToLiterals_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JsonValuesToLiterals' +type TranslatorServiceServer_JsonValuesToLiterals_Call struct { + *mock.Call +} + +// JsonValuesToLiterals is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *workflow.JsonValuesToLiteralsRequest +func (_e *TranslatorServiceServer_Expecter) JsonValuesToLiterals(_a0 interface{}, _a1 interface{}) *TranslatorServiceServer_JsonValuesToLiterals_Call { + return &TranslatorServiceServer_JsonValuesToLiterals_Call{Call: _e.mock.On("JsonValuesToLiterals", _a0, _a1)} +} + +func (_c *TranslatorServiceServer_JsonValuesToLiterals_Call) Run(run func(_a0 context.Context, _a1 *workflow.JsonValuesToLiteralsRequest)) *TranslatorServiceServer_JsonValuesToLiterals_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.JsonValuesToLiteralsRequest)) + }) + return _c +} + +func (_c *TranslatorServiceServer_JsonValuesToLiterals_Call) Return(_a0 *workflow.JsonValuesToLiteralsResponse, _a1 error) *TranslatorServiceServer_JsonValuesToLiterals_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TranslatorServiceServer_JsonValuesToLiterals_Call) RunAndReturn(run func(context.Context, *workflow.JsonValuesToLiteralsRequest) (*workflow.JsonValuesToLiteralsResponse, error)) *TranslatorServiceServer_JsonValuesToLiterals_Call { + _c.Call.Return(run) + return _c +} + +// LaunchFormJsonToLiterals provides a mock function with given fields: _a0, _a1 +func (_m *TranslatorServiceServer) LaunchFormJsonToLiterals(_a0 context.Context, _a1 *workflow.LaunchFormJsonToLiteralsRequest) (*workflow.LaunchFormJsonToLiteralsResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for LaunchFormJsonToLiterals") + } + + var r0 *workflow.LaunchFormJsonToLiteralsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.LaunchFormJsonToLiteralsRequest) (*workflow.LaunchFormJsonToLiteralsResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.LaunchFormJsonToLiteralsRequest) *workflow.LaunchFormJsonToLiteralsResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.LaunchFormJsonToLiteralsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.LaunchFormJsonToLiteralsRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TranslatorServiceServer_LaunchFormJsonToLiterals_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LaunchFormJsonToLiterals' +type TranslatorServiceServer_LaunchFormJsonToLiterals_Call struct { + *mock.Call +} + +// LaunchFormJsonToLiterals is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *workflow.LaunchFormJsonToLiteralsRequest +func (_e *TranslatorServiceServer_Expecter) LaunchFormJsonToLiterals(_a0 interface{}, _a1 interface{}) *TranslatorServiceServer_LaunchFormJsonToLiterals_Call { + return &TranslatorServiceServer_LaunchFormJsonToLiterals_Call{Call: _e.mock.On("LaunchFormJsonToLiterals", _a0, _a1)} +} + +func (_c *TranslatorServiceServer_LaunchFormJsonToLiterals_Call) Run(run func(_a0 context.Context, _a1 *workflow.LaunchFormJsonToLiteralsRequest)) *TranslatorServiceServer_LaunchFormJsonToLiterals_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.LaunchFormJsonToLiteralsRequest)) + }) + return _c +} + +func (_c *TranslatorServiceServer_LaunchFormJsonToLiterals_Call) Return(_a0 *workflow.LaunchFormJsonToLiteralsResponse, _a1 error) *TranslatorServiceServer_LaunchFormJsonToLiterals_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TranslatorServiceServer_LaunchFormJsonToLiterals_Call) RunAndReturn(run func(context.Context, *workflow.LaunchFormJsonToLiteralsRequest) (*workflow.LaunchFormJsonToLiteralsResponse, error)) *TranslatorServiceServer_LaunchFormJsonToLiterals_Call { + _c.Call.Return(run) + return _c +} + +// LiteralsToLaunchFormJson provides a mock function with given fields: _a0, _a1 +func (_m *TranslatorServiceServer) LiteralsToLaunchFormJson(_a0 context.Context, _a1 *workflow.LiteralsToLaunchFormJsonRequest) (*workflow.LiteralsToLaunchFormJsonResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for LiteralsToLaunchFormJson") + } + + var r0 *workflow.LiteralsToLaunchFormJsonResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.LiteralsToLaunchFormJsonRequest) (*workflow.LiteralsToLaunchFormJsonResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.LiteralsToLaunchFormJsonRequest) *workflow.LiteralsToLaunchFormJsonResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.LiteralsToLaunchFormJsonResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.LiteralsToLaunchFormJsonRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TranslatorServiceServer_LiteralsToLaunchFormJson_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LiteralsToLaunchFormJson' +type TranslatorServiceServer_LiteralsToLaunchFormJson_Call struct { + *mock.Call +} + +// LiteralsToLaunchFormJson is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *workflow.LiteralsToLaunchFormJsonRequest +func (_e *TranslatorServiceServer_Expecter) LiteralsToLaunchFormJson(_a0 interface{}, _a1 interface{}) *TranslatorServiceServer_LiteralsToLaunchFormJson_Call { + return &TranslatorServiceServer_LiteralsToLaunchFormJson_Call{Call: _e.mock.On("LiteralsToLaunchFormJson", _a0, _a1)} +} + +func (_c *TranslatorServiceServer_LiteralsToLaunchFormJson_Call) Run(run func(_a0 context.Context, _a1 *workflow.LiteralsToLaunchFormJsonRequest)) *TranslatorServiceServer_LiteralsToLaunchFormJson_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.LiteralsToLaunchFormJsonRequest)) + }) + return _c +} + +func (_c *TranslatorServiceServer_LiteralsToLaunchFormJson_Call) Return(_a0 *workflow.LiteralsToLaunchFormJsonResponse, _a1 error) *TranslatorServiceServer_LiteralsToLaunchFormJson_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TranslatorServiceServer_LiteralsToLaunchFormJson_Call) RunAndReturn(run func(context.Context, *workflow.LiteralsToLaunchFormJsonRequest) (*workflow.LiteralsToLaunchFormJsonResponse, error)) *TranslatorServiceServer_LiteralsToLaunchFormJson_Call { + _c.Call.Return(run) + return _c +} + +// TaskSpecToLaunchFormJson provides a mock function with given fields: _a0, _a1 +func (_m *TranslatorServiceServer) TaskSpecToLaunchFormJson(_a0 context.Context, _a1 *workflow.TaskSpecToLaunchFormJsonRequest) (*workflow.TaskSpecToLaunchFormJsonResponse, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for TaskSpecToLaunchFormJson") + } + + var r0 *workflow.TaskSpecToLaunchFormJsonResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.TaskSpecToLaunchFormJsonRequest) (*workflow.TaskSpecToLaunchFormJsonResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.TaskSpecToLaunchFormJsonRequest) *workflow.TaskSpecToLaunchFormJsonResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflow.TaskSpecToLaunchFormJsonResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.TaskSpecToLaunchFormJsonRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TranslatorServiceServer_TaskSpecToLaunchFormJson_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TaskSpecToLaunchFormJson' +type TranslatorServiceServer_TaskSpecToLaunchFormJson_Call struct { + *mock.Call +} + +// TaskSpecToLaunchFormJson is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *workflow.TaskSpecToLaunchFormJsonRequest +func (_e *TranslatorServiceServer_Expecter) TaskSpecToLaunchFormJson(_a0 interface{}, _a1 interface{}) *TranslatorServiceServer_TaskSpecToLaunchFormJson_Call { + return &TranslatorServiceServer_TaskSpecToLaunchFormJson_Call{Call: _e.mock.On("TaskSpecToLaunchFormJson", _a0, _a1)} +} + +func (_c *TranslatorServiceServer_TaskSpecToLaunchFormJson_Call) Run(run func(_a0 context.Context, _a1 *workflow.TaskSpecToLaunchFormJsonRequest)) *TranslatorServiceServer_TaskSpecToLaunchFormJson_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.TaskSpecToLaunchFormJsonRequest)) + }) + return _c +} + +func (_c *TranslatorServiceServer_TaskSpecToLaunchFormJson_Call) Return(_a0 *workflow.TaskSpecToLaunchFormJsonResponse, _a1 error) *TranslatorServiceServer_TaskSpecToLaunchFormJson_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TranslatorServiceServer_TaskSpecToLaunchFormJson_Call) RunAndReturn(run func(context.Context, *workflow.TaskSpecToLaunchFormJsonRequest) (*workflow.TaskSpecToLaunchFormJsonResponse, error)) *TranslatorServiceServer_TaskSpecToLaunchFormJson_Call { + _c.Call.Return(run) + return _c +} + +// NewTranslatorServiceServer creates a new instance of TranslatorServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTranslatorServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *TranslatorServiceServer { + mock := &TranslatorServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/unsafe_queue_service_server.go b/gen/go/flyteidl2/workflow/mocks/unsafe_queue_service_server.go new file mode 100644 index 0000000000..085d2c6c58 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/unsafe_queue_service_server.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// UnsafeQueueServiceServer is an autogenerated mock type for the UnsafeQueueServiceServer type +type UnsafeQueueServiceServer struct { + mock.Mock +} + +type UnsafeQueueServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *UnsafeQueueServiceServer) EXPECT() *UnsafeQueueServiceServer_Expecter { + return &UnsafeQueueServiceServer_Expecter{mock: &_m.Mock} +} + +// mustEmbedUnimplementedQueueServiceServer provides a mock function with no fields +func (_m *UnsafeQueueServiceServer) mustEmbedUnimplementedQueueServiceServer() { + _m.Called() +} + +// UnsafeQueueServiceServer_mustEmbedUnimplementedQueueServiceServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'mustEmbedUnimplementedQueueServiceServer' +type UnsafeQueueServiceServer_mustEmbedUnimplementedQueueServiceServer_Call struct { + *mock.Call +} + +// mustEmbedUnimplementedQueueServiceServer is a helper method to define mock.On call +func (_e *UnsafeQueueServiceServer_Expecter) mustEmbedUnimplementedQueueServiceServer() *UnsafeQueueServiceServer_mustEmbedUnimplementedQueueServiceServer_Call { + return &UnsafeQueueServiceServer_mustEmbedUnimplementedQueueServiceServer_Call{Call: _e.mock.On("mustEmbedUnimplementedQueueServiceServer")} +} + +func (_c *UnsafeQueueServiceServer_mustEmbedUnimplementedQueueServiceServer_Call) Run(run func()) *UnsafeQueueServiceServer_mustEmbedUnimplementedQueueServiceServer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UnsafeQueueServiceServer_mustEmbedUnimplementedQueueServiceServer_Call) Return() *UnsafeQueueServiceServer_mustEmbedUnimplementedQueueServiceServer_Call { + _c.Call.Return() + return _c +} + +func (_c *UnsafeQueueServiceServer_mustEmbedUnimplementedQueueServiceServer_Call) RunAndReturn(run func()) *UnsafeQueueServiceServer_mustEmbedUnimplementedQueueServiceServer_Call { + _c.Run(run) + return _c +} + +// NewUnsafeQueueServiceServer creates a new instance of UnsafeQueueServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewUnsafeQueueServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *UnsafeQueueServiceServer { + mock := &UnsafeQueueServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/unsafe_run_logs_service_server.go b/gen/go/flyteidl2/workflow/mocks/unsafe_run_logs_service_server.go new file mode 100644 index 0000000000..556e1eca39 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/unsafe_run_logs_service_server.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// UnsafeRunLogsServiceServer is an autogenerated mock type for the UnsafeRunLogsServiceServer type +type UnsafeRunLogsServiceServer struct { + mock.Mock +} + +type UnsafeRunLogsServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *UnsafeRunLogsServiceServer) EXPECT() *UnsafeRunLogsServiceServer_Expecter { + return &UnsafeRunLogsServiceServer_Expecter{mock: &_m.Mock} +} + +// mustEmbedUnimplementedRunLogsServiceServer provides a mock function with no fields +func (_m *UnsafeRunLogsServiceServer) mustEmbedUnimplementedRunLogsServiceServer() { + _m.Called() +} + +// UnsafeRunLogsServiceServer_mustEmbedUnimplementedRunLogsServiceServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'mustEmbedUnimplementedRunLogsServiceServer' +type UnsafeRunLogsServiceServer_mustEmbedUnimplementedRunLogsServiceServer_Call struct { + *mock.Call +} + +// mustEmbedUnimplementedRunLogsServiceServer is a helper method to define mock.On call +func (_e *UnsafeRunLogsServiceServer_Expecter) mustEmbedUnimplementedRunLogsServiceServer() *UnsafeRunLogsServiceServer_mustEmbedUnimplementedRunLogsServiceServer_Call { + return &UnsafeRunLogsServiceServer_mustEmbedUnimplementedRunLogsServiceServer_Call{Call: _e.mock.On("mustEmbedUnimplementedRunLogsServiceServer")} +} + +func (_c *UnsafeRunLogsServiceServer_mustEmbedUnimplementedRunLogsServiceServer_Call) Run(run func()) *UnsafeRunLogsServiceServer_mustEmbedUnimplementedRunLogsServiceServer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UnsafeRunLogsServiceServer_mustEmbedUnimplementedRunLogsServiceServer_Call) Return() *UnsafeRunLogsServiceServer_mustEmbedUnimplementedRunLogsServiceServer_Call { + _c.Call.Return() + return _c +} + +func (_c *UnsafeRunLogsServiceServer_mustEmbedUnimplementedRunLogsServiceServer_Call) RunAndReturn(run func()) *UnsafeRunLogsServiceServer_mustEmbedUnimplementedRunLogsServiceServer_Call { + _c.Run(run) + return _c +} + +// NewUnsafeRunLogsServiceServer creates a new instance of UnsafeRunLogsServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewUnsafeRunLogsServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *UnsafeRunLogsServiceServer { + mock := &UnsafeRunLogsServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/unsafe_run_service_server.go b/gen/go/flyteidl2/workflow/mocks/unsafe_run_service_server.go new file mode 100644 index 0000000000..78bab7dbc0 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/unsafe_run_service_server.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// UnsafeRunServiceServer is an autogenerated mock type for the UnsafeRunServiceServer type +type UnsafeRunServiceServer struct { + mock.Mock +} + +type UnsafeRunServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *UnsafeRunServiceServer) EXPECT() *UnsafeRunServiceServer_Expecter { + return &UnsafeRunServiceServer_Expecter{mock: &_m.Mock} +} + +// mustEmbedUnimplementedRunServiceServer provides a mock function with no fields +func (_m *UnsafeRunServiceServer) mustEmbedUnimplementedRunServiceServer() { + _m.Called() +} + +// UnsafeRunServiceServer_mustEmbedUnimplementedRunServiceServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'mustEmbedUnimplementedRunServiceServer' +type UnsafeRunServiceServer_mustEmbedUnimplementedRunServiceServer_Call struct { + *mock.Call +} + +// mustEmbedUnimplementedRunServiceServer is a helper method to define mock.On call +func (_e *UnsafeRunServiceServer_Expecter) mustEmbedUnimplementedRunServiceServer() *UnsafeRunServiceServer_mustEmbedUnimplementedRunServiceServer_Call { + return &UnsafeRunServiceServer_mustEmbedUnimplementedRunServiceServer_Call{Call: _e.mock.On("mustEmbedUnimplementedRunServiceServer")} +} + +func (_c *UnsafeRunServiceServer_mustEmbedUnimplementedRunServiceServer_Call) Run(run func()) *UnsafeRunServiceServer_mustEmbedUnimplementedRunServiceServer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UnsafeRunServiceServer_mustEmbedUnimplementedRunServiceServer_Call) Return() *UnsafeRunServiceServer_mustEmbedUnimplementedRunServiceServer_Call { + _c.Call.Return() + return _c +} + +func (_c *UnsafeRunServiceServer_mustEmbedUnimplementedRunServiceServer_Call) RunAndReturn(run func()) *UnsafeRunServiceServer_mustEmbedUnimplementedRunServiceServer_Call { + _c.Run(run) + return _c +} + +// NewUnsafeRunServiceServer creates a new instance of UnsafeRunServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewUnsafeRunServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *UnsafeRunServiceServer { + mock := &UnsafeRunServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/unsafe_state_service_server.go b/gen/go/flyteidl2/workflow/mocks/unsafe_state_service_server.go new file mode 100644 index 0000000000..7fd6b31288 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/unsafe_state_service_server.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// UnsafeStateServiceServer is an autogenerated mock type for the UnsafeStateServiceServer type +type UnsafeStateServiceServer struct { + mock.Mock +} + +type UnsafeStateServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *UnsafeStateServiceServer) EXPECT() *UnsafeStateServiceServer_Expecter { + return &UnsafeStateServiceServer_Expecter{mock: &_m.Mock} +} + +// mustEmbedUnimplementedStateServiceServer provides a mock function with no fields +func (_m *UnsafeStateServiceServer) mustEmbedUnimplementedStateServiceServer() { + _m.Called() +} + +// UnsafeStateServiceServer_mustEmbedUnimplementedStateServiceServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'mustEmbedUnimplementedStateServiceServer' +type UnsafeStateServiceServer_mustEmbedUnimplementedStateServiceServer_Call struct { + *mock.Call +} + +// mustEmbedUnimplementedStateServiceServer is a helper method to define mock.On call +func (_e *UnsafeStateServiceServer_Expecter) mustEmbedUnimplementedStateServiceServer() *UnsafeStateServiceServer_mustEmbedUnimplementedStateServiceServer_Call { + return &UnsafeStateServiceServer_mustEmbedUnimplementedStateServiceServer_Call{Call: _e.mock.On("mustEmbedUnimplementedStateServiceServer")} +} + +func (_c *UnsafeStateServiceServer_mustEmbedUnimplementedStateServiceServer_Call) Run(run func()) *UnsafeStateServiceServer_mustEmbedUnimplementedStateServiceServer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UnsafeStateServiceServer_mustEmbedUnimplementedStateServiceServer_Call) Return() *UnsafeStateServiceServer_mustEmbedUnimplementedStateServiceServer_Call { + _c.Call.Return() + return _c +} + +func (_c *UnsafeStateServiceServer_mustEmbedUnimplementedStateServiceServer_Call) RunAndReturn(run func()) *UnsafeStateServiceServer_mustEmbedUnimplementedStateServiceServer_Call { + _c.Run(run) + return _c +} + +// NewUnsafeStateServiceServer creates a new instance of UnsafeStateServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewUnsafeStateServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *UnsafeStateServiceServer { + mock := &UnsafeStateServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/mocks/unsafe_translator_service_server.go b/gen/go/flyteidl2/workflow/mocks/unsafe_translator_service_server.go new file mode 100644 index 0000000000..cfcf2e5759 --- /dev/null +++ b/gen/go/flyteidl2/workflow/mocks/unsafe_translator_service_server.go @@ -0,0 +1,64 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// UnsafeTranslatorServiceServer is an autogenerated mock type for the UnsafeTranslatorServiceServer type +type UnsafeTranslatorServiceServer struct { + mock.Mock +} + +type UnsafeTranslatorServiceServer_Expecter struct { + mock *mock.Mock +} + +func (_m *UnsafeTranslatorServiceServer) EXPECT() *UnsafeTranslatorServiceServer_Expecter { + return &UnsafeTranslatorServiceServer_Expecter{mock: &_m.Mock} +} + +// mustEmbedUnimplementedTranslatorServiceServer provides a mock function with no fields +func (_m *UnsafeTranslatorServiceServer) mustEmbedUnimplementedTranslatorServiceServer() { + _m.Called() +} + +// UnsafeTranslatorServiceServer_mustEmbedUnimplementedTranslatorServiceServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'mustEmbedUnimplementedTranslatorServiceServer' +type UnsafeTranslatorServiceServer_mustEmbedUnimplementedTranslatorServiceServer_Call struct { + *mock.Call +} + +// mustEmbedUnimplementedTranslatorServiceServer is a helper method to define mock.On call +func (_e *UnsafeTranslatorServiceServer_Expecter) mustEmbedUnimplementedTranslatorServiceServer() *UnsafeTranslatorServiceServer_mustEmbedUnimplementedTranslatorServiceServer_Call { + return &UnsafeTranslatorServiceServer_mustEmbedUnimplementedTranslatorServiceServer_Call{Call: _e.mock.On("mustEmbedUnimplementedTranslatorServiceServer")} +} + +func (_c *UnsafeTranslatorServiceServer_mustEmbedUnimplementedTranslatorServiceServer_Call) Run(run func()) *UnsafeTranslatorServiceServer_mustEmbedUnimplementedTranslatorServiceServer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UnsafeTranslatorServiceServer_mustEmbedUnimplementedTranslatorServiceServer_Call) Return() *UnsafeTranslatorServiceServer_mustEmbedUnimplementedTranslatorServiceServer_Call { + _c.Call.Return() + return _c +} + +func (_c *UnsafeTranslatorServiceServer_mustEmbedUnimplementedTranslatorServiceServer_Call) RunAndReturn(run func()) *UnsafeTranslatorServiceServer_mustEmbedUnimplementedTranslatorServiceServer_Call { + _c.Run(run) + return _c +} + +// NewUnsafeTranslatorServiceServer creates a new instance of UnsafeTranslatorServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewUnsafeTranslatorServiceServer(t interface { + mock.TestingT + Cleanup(func()) +}) *UnsafeTranslatorServiceServer { + mock := &UnsafeTranslatorServiceServer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/queue_service.pb.go b/gen/go/flyteidl2/workflow/queue_service.pb.go new file mode 100644 index 0000000000..e9c07ddfa0 --- /dev/null +++ b/gen/go/flyteidl2/workflow/queue_service.pb.go @@ -0,0 +1,681 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/workflow/queue_service.proto + +package workflow + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + task "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// request message for queuing an action. +type EnqueueActionRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // the unique identifier for the action. + ActionId *common.ActionIdentifier `protobuf:"bytes,1,opt,name=action_id,json=actionId,proto3" json:"action_id,omitempty"` + // an optional name for the parent action, if it exists. the remaining run metadata (ex. org, + // project, domain) will be the same as the action_id defined above. + ParentActionName *string `protobuf:"bytes,2,opt,name=parent_action_name,json=parentActionName,proto3,oneof" json:"parent_action_name,omitempty"` + // Optional run spec passed in by the root action to be utilized by all downstream actions in the run. + RunSpec *task.RunSpec `protobuf:"bytes,3,opt,name=run_spec,json=runSpec,proto3" json:"run_spec,omitempty"` + // the path to the input data for this action. + InputUri string `protobuf:"bytes,6,opt,name=input_uri,json=inputUri,proto3" json:"input_uri,omitempty"` + // the run base path this action should write its output to. + RunOutputBase string `protobuf:"bytes,7,opt,name=run_output_base,json=runOutputBase,proto3" json:"run_output_base,omitempty"` + // group this action belongs to, if applicable. + Group string `protobuf:"bytes,8,opt,name=group,proto3" json:"group,omitempty"` + // subject that created the run, if known. + Subject string `protobuf:"bytes,9,opt,name=subject,proto3" json:"subject,omitempty"` + // Types that are assignable to Spec: + // + // *EnqueueActionRequest_Task + // *EnqueueActionRequest_Trace + // *EnqueueActionRequest_Condition + Spec isEnqueueActionRequest_Spec `protobuf_oneof:"spec"` +} + +func (x *EnqueueActionRequest) Reset() { + *x = EnqueueActionRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_queue_service_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EnqueueActionRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EnqueueActionRequest) ProtoMessage() {} + +func (x *EnqueueActionRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_queue_service_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EnqueueActionRequest.ProtoReflect.Descriptor instead. +func (*EnqueueActionRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_queue_service_proto_rawDescGZIP(), []int{0} +} + +func (x *EnqueueActionRequest) GetActionId() *common.ActionIdentifier { + if x != nil { + return x.ActionId + } + return nil +} + +func (x *EnqueueActionRequest) GetParentActionName() string { + if x != nil && x.ParentActionName != nil { + return *x.ParentActionName + } + return "" +} + +func (x *EnqueueActionRequest) GetRunSpec() *task.RunSpec { + if x != nil { + return x.RunSpec + } + return nil +} + +func (x *EnqueueActionRequest) GetInputUri() string { + if x != nil { + return x.InputUri + } + return "" +} + +func (x *EnqueueActionRequest) GetRunOutputBase() string { + if x != nil { + return x.RunOutputBase + } + return "" +} + +func (x *EnqueueActionRequest) GetGroup() string { + if x != nil { + return x.Group + } + return "" +} + +func (x *EnqueueActionRequest) GetSubject() string { + if x != nil { + return x.Subject + } + return "" +} + +func (m *EnqueueActionRequest) GetSpec() isEnqueueActionRequest_Spec { + if m != nil { + return m.Spec + } + return nil +} + +func (x *EnqueueActionRequest) GetTask() *TaskAction { + if x, ok := x.GetSpec().(*EnqueueActionRequest_Task); ok { + return x.Task + } + return nil +} + +func (x *EnqueueActionRequest) GetTrace() *TraceAction { + if x, ok := x.GetSpec().(*EnqueueActionRequest_Trace); ok { + return x.Trace + } + return nil +} + +func (x *EnqueueActionRequest) GetCondition() *ConditionAction { + if x, ok := x.GetSpec().(*EnqueueActionRequest_Condition); ok { + return x.Condition + } + return nil +} + +type isEnqueueActionRequest_Spec interface { + isEnqueueActionRequest_Spec() +} + +type EnqueueActionRequest_Task struct { + Task *TaskAction `protobuf:"bytes,10,opt,name=task,proto3,oneof"` +} + +type EnqueueActionRequest_Trace struct { + Trace *TraceAction `protobuf:"bytes,11,opt,name=trace,proto3,oneof"` +} + +type EnqueueActionRequest_Condition struct { + Condition *ConditionAction `protobuf:"bytes,12,opt,name=condition,proto3,oneof"` +} + +func (*EnqueueActionRequest_Task) isEnqueueActionRequest_Spec() {} + +func (*EnqueueActionRequest_Trace) isEnqueueActionRequest_Spec() {} + +func (*EnqueueActionRequest_Condition) isEnqueueActionRequest_Spec() {} + +// response message for queuing an action. +type EnqueueActionResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *EnqueueActionResponse) Reset() { + *x = EnqueueActionResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_queue_service_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EnqueueActionResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EnqueueActionResponse) ProtoMessage() {} + +func (x *EnqueueActionResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_queue_service_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EnqueueActionResponse.ProtoReflect.Descriptor instead. +func (*EnqueueActionResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_queue_service_proto_rawDescGZIP(), []int{1} +} + +// request message for aborting a run. +type AbortQueuedRunRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // the unique identifier for the run to be aborted. + RunId *common.RunIdentifier `protobuf:"bytes,1,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"` + // Reason for aborting the run, if applicable. + Reason *string `protobuf:"bytes,2,opt,name=reason,proto3,oneof" json:"reason,omitempty"` +} + +func (x *AbortQueuedRunRequest) Reset() { + *x = AbortQueuedRunRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_queue_service_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AbortQueuedRunRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AbortQueuedRunRequest) ProtoMessage() {} + +func (x *AbortQueuedRunRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_queue_service_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AbortQueuedRunRequest.ProtoReflect.Descriptor instead. +func (*AbortQueuedRunRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_queue_service_proto_rawDescGZIP(), []int{2} +} + +func (x *AbortQueuedRunRequest) GetRunId() *common.RunIdentifier { + if x != nil { + return x.RunId + } + return nil +} + +func (x *AbortQueuedRunRequest) GetReason() string { + if x != nil && x.Reason != nil { + return *x.Reason + } + return "" +} + +// response message for aborting a run. +type AbortQueuedRunResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *AbortQueuedRunResponse) Reset() { + *x = AbortQueuedRunResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_queue_service_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AbortQueuedRunResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AbortQueuedRunResponse) ProtoMessage() {} + +func (x *AbortQueuedRunResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_queue_service_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AbortQueuedRunResponse.ProtoReflect.Descriptor instead. +func (*AbortQueuedRunResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_queue_service_proto_rawDescGZIP(), []int{3} +} + +type AbortQueuedActionRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // ActionId is the unique identifier for the action to be aborted + ActionId *common.ActionIdentifier `protobuf:"bytes,1,opt,name=action_id,json=actionId,proto3" json:"action_id,omitempty"` + // Reason for aborting the action, if applicable. + Reason *string `protobuf:"bytes,2,opt,name=reason,proto3,oneof" json:"reason,omitempty"` +} + +func (x *AbortQueuedActionRequest) Reset() { + *x = AbortQueuedActionRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_queue_service_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AbortQueuedActionRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AbortQueuedActionRequest) ProtoMessage() {} + +func (x *AbortQueuedActionRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_queue_service_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AbortQueuedActionRequest.ProtoReflect.Descriptor instead. +func (*AbortQueuedActionRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_queue_service_proto_rawDescGZIP(), []int{4} +} + +func (x *AbortQueuedActionRequest) GetActionId() *common.ActionIdentifier { + if x != nil { + return x.ActionId + } + return nil +} + +func (x *AbortQueuedActionRequest) GetReason() string { + if x != nil && x.Reason != nil { + return *x.Reason + } + return "" +} + +type AbortQueuedActionResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *AbortQueuedActionResponse) Reset() { + *x = AbortQueuedActionResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_queue_service_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AbortQueuedActionResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AbortQueuedActionResponse) ProtoMessage() {} + +func (x *AbortQueuedActionResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_queue_service_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AbortQueuedActionResponse.ProtoReflect.Descriptor instead. +func (*AbortQueuedActionResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_queue_service_proto_rawDescGZIP(), []int{5} +} + +var File_flyteidl2_workflow_queue_service_proto protoreflect.FileDescriptor + +var file_flyteidl2_workflow_queue_service_proto_rawDesc = []byte{ + 0x0a, 0x26, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x71, 0x75, 0x65, 0x75, 0x65, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x1a, 0x1b, 0x62, 0x75, + 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x18, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x72, 0x75, 0x6e, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x1a, 0x27, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x72, 0x75, 0x6e, 0x5f, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa7, 0x04, 0x0a, + 0x14, 0x45, 0x6e, 0x71, 0x75, 0x65, 0x75, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, + 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x31, + 0x0a, 0x12, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x10, 0x70, 0x61, + 0x72, 0x65, 0x6e, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x88, 0x01, + 0x01, 0x12, 0x32, 0x0a, 0x08, 0x72, 0x75, 0x6e, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x52, 0x75, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x52, 0x07, 0x72, 0x75, + 0x6e, 0x53, 0x70, 0x65, 0x63, 0x12, 0x24, 0x0a, 0x09, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x75, + 0x72, 0x69, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, + 0x01, 0x52, 0x08, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x55, 0x72, 0x69, 0x12, 0x2f, 0x0a, 0x0f, 0x72, + 0x75, 0x6e, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x62, 0x61, 0x73, 0x65, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x0d, 0x72, + 0x75, 0x6e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x42, 0x61, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x09, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x34, 0x0a, 0x04, + 0x74, 0x61, 0x73, 0x6b, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, + 0x54, 0x61, 0x73, 0x6b, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x04, 0x74, 0x61, + 0x73, 0x6b, 0x12, 0x37, 0x0a, 0x05, 0x74, 0x72, 0x61, 0x63, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x72, 0x61, 0x63, 0x65, 0x41, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x05, 0x74, 0x72, 0x61, 0x63, 0x65, 0x12, 0x43, 0x0a, 0x09, 0x63, + 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2e, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x09, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x42, 0x0d, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x42, + 0x15, 0x0a, 0x13, 0x5f, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x17, 0x0a, 0x15, 0x45, 0x6e, 0x71, 0x75, 0x65, 0x75, + 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x7f, 0x0a, 0x15, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x51, 0x75, 0x65, 0x75, 0x65, 0x64, 0x52, 0x75, + 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3e, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, + 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x75, 0x6e, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, + 0x01, 0x52, 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, + 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, + 0x6f, 0x6e, 0x88, 0x01, 0x01, 0x42, 0x09, 0x0a, 0x07, 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, + 0x22, 0x18, 0x0a, 0x16, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x51, 0x75, 0x65, 0x75, 0x65, 0x64, 0x52, + 0x75, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x8b, 0x01, 0x0a, 0x18, 0x41, + 0x62, 0x6f, 0x72, 0x74, 0x51, 0x75, 0x65, 0x75, 0x65, 0x64, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, + 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, + 0x12, 0x1b, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x48, 0x00, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x88, 0x01, 0x01, 0x42, 0x09, 0x0a, + 0x07, 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x22, 0x1b, 0x0a, 0x19, 0x41, 0x62, 0x6f, 0x72, + 0x74, 0x51, 0x75, 0x65, 0x75, 0x65, 0x64, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0xd5, 0x02, 0x0a, 0x0c, 0x51, 0x75, 0x65, 0x75, 0x65, 0x53, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x66, 0x0a, 0x0d, 0x45, 0x6e, 0x71, 0x75, 0x65, 0x75, + 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x45, 0x6e, 0x71, + 0x75, 0x65, 0x75, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x45, 0x6e, 0x71, 0x75, 0x65, 0x75, 0x65, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x69, + 0x0a, 0x0e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x51, 0x75, 0x65, 0x75, 0x65, 0x64, 0x52, 0x75, 0x6e, + 0x12, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x51, 0x75, 0x65, 0x75, 0x65, + 0x64, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x51, 0x75, 0x65, 0x75, 0x65, 0x64, 0x52, 0x75, 0x6e, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x72, 0x0a, 0x11, 0x41, 0x62, 0x6f, + 0x72, 0x74, 0x51, 0x75, 0x65, 0x75, 0x65, 0x64, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2c, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x51, 0x75, 0x65, 0x75, 0x65, 0x64, 0x41, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x51, 0x75, 0x65, 0x75, 0x65, 0x64, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0xce, 0x01, + 0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x11, 0x51, 0x75, 0x65, 0x75, 0x65, 0x53, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, + 0x36, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, + 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xa2, 0x02, 0x03, 0x46, 0x57, 0x58, 0xaa, 0x02, 0x12, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0xca, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x57, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xe2, 0x02, 0x1e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5c, 0x47, 0x50, 0x42, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x13, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_workflow_queue_service_proto_rawDescOnce sync.Once + file_flyteidl2_workflow_queue_service_proto_rawDescData = file_flyteidl2_workflow_queue_service_proto_rawDesc +) + +func file_flyteidl2_workflow_queue_service_proto_rawDescGZIP() []byte { + file_flyteidl2_workflow_queue_service_proto_rawDescOnce.Do(func() { + file_flyteidl2_workflow_queue_service_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_workflow_queue_service_proto_rawDescData) + }) + return file_flyteidl2_workflow_queue_service_proto_rawDescData +} + +var file_flyteidl2_workflow_queue_service_proto_msgTypes = make([]protoimpl.MessageInfo, 6) +var file_flyteidl2_workflow_queue_service_proto_goTypes = []interface{}{ + (*EnqueueActionRequest)(nil), // 0: flyteidl2.workflow.EnqueueActionRequest + (*EnqueueActionResponse)(nil), // 1: flyteidl2.workflow.EnqueueActionResponse + (*AbortQueuedRunRequest)(nil), // 2: flyteidl2.workflow.AbortQueuedRunRequest + (*AbortQueuedRunResponse)(nil), // 3: flyteidl2.workflow.AbortQueuedRunResponse + (*AbortQueuedActionRequest)(nil), // 4: flyteidl2.workflow.AbortQueuedActionRequest + (*AbortQueuedActionResponse)(nil), // 5: flyteidl2.workflow.AbortQueuedActionResponse + (*common.ActionIdentifier)(nil), // 6: flyteidl2.common.ActionIdentifier + (*task.RunSpec)(nil), // 7: flyteidl2.task.RunSpec + (*TaskAction)(nil), // 8: flyteidl2.workflow.TaskAction + (*TraceAction)(nil), // 9: flyteidl2.workflow.TraceAction + (*ConditionAction)(nil), // 10: flyteidl2.workflow.ConditionAction + (*common.RunIdentifier)(nil), // 11: flyteidl2.common.RunIdentifier +} +var file_flyteidl2_workflow_queue_service_proto_depIdxs = []int32{ + 6, // 0: flyteidl2.workflow.EnqueueActionRequest.action_id:type_name -> flyteidl2.common.ActionIdentifier + 7, // 1: flyteidl2.workflow.EnqueueActionRequest.run_spec:type_name -> flyteidl2.task.RunSpec + 8, // 2: flyteidl2.workflow.EnqueueActionRequest.task:type_name -> flyteidl2.workflow.TaskAction + 9, // 3: flyteidl2.workflow.EnqueueActionRequest.trace:type_name -> flyteidl2.workflow.TraceAction + 10, // 4: flyteidl2.workflow.EnqueueActionRequest.condition:type_name -> flyteidl2.workflow.ConditionAction + 11, // 5: flyteidl2.workflow.AbortQueuedRunRequest.run_id:type_name -> flyteidl2.common.RunIdentifier + 6, // 6: flyteidl2.workflow.AbortQueuedActionRequest.action_id:type_name -> flyteidl2.common.ActionIdentifier + 0, // 7: flyteidl2.workflow.QueueService.EnqueueAction:input_type -> flyteidl2.workflow.EnqueueActionRequest + 2, // 8: flyteidl2.workflow.QueueService.AbortQueuedRun:input_type -> flyteidl2.workflow.AbortQueuedRunRequest + 4, // 9: flyteidl2.workflow.QueueService.AbortQueuedAction:input_type -> flyteidl2.workflow.AbortQueuedActionRequest + 1, // 10: flyteidl2.workflow.QueueService.EnqueueAction:output_type -> flyteidl2.workflow.EnqueueActionResponse + 3, // 11: flyteidl2.workflow.QueueService.AbortQueuedRun:output_type -> flyteidl2.workflow.AbortQueuedRunResponse + 5, // 12: flyteidl2.workflow.QueueService.AbortQueuedAction:output_type -> flyteidl2.workflow.AbortQueuedActionResponse + 10, // [10:13] is the sub-list for method output_type + 7, // [7:10] is the sub-list for method input_type + 7, // [7:7] is the sub-list for extension type_name + 7, // [7:7] is the sub-list for extension extendee + 0, // [0:7] is the sub-list for field type_name +} + +func init() { file_flyteidl2_workflow_queue_service_proto_init() } +func file_flyteidl2_workflow_queue_service_proto_init() { + if File_flyteidl2_workflow_queue_service_proto != nil { + return + } + file_flyteidl2_workflow_run_definition_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_workflow_queue_service_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EnqueueActionRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_queue_service_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EnqueueActionResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_queue_service_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AbortQueuedRunRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_queue_service_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AbortQueuedRunResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_queue_service_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AbortQueuedActionRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_queue_service_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AbortQueuedActionResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_workflow_queue_service_proto_msgTypes[0].OneofWrappers = []interface{}{ + (*EnqueueActionRequest_Task)(nil), + (*EnqueueActionRequest_Trace)(nil), + (*EnqueueActionRequest_Condition)(nil), + } + file_flyteidl2_workflow_queue_service_proto_msgTypes[2].OneofWrappers = []interface{}{} + file_flyteidl2_workflow_queue_service_proto_msgTypes[4].OneofWrappers = []interface{}{} + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_workflow_queue_service_proto_rawDesc, + NumEnums: 0, + NumMessages: 6, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_flyteidl2_workflow_queue_service_proto_goTypes, + DependencyIndexes: file_flyteidl2_workflow_queue_service_proto_depIdxs, + MessageInfos: file_flyteidl2_workflow_queue_service_proto_msgTypes, + }.Build() + File_flyteidl2_workflow_queue_service_proto = out.File + file_flyteidl2_workflow_queue_service_proto_rawDesc = nil + file_flyteidl2_workflow_queue_service_proto_goTypes = nil + file_flyteidl2_workflow_queue_service_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/workflow/queue_service.pb.validate.go b/gen/go/flyteidl2/workflow/queue_service.pb.validate.go new file mode 100644 index 0000000000..2a13f45f27 --- /dev/null +++ b/gen/go/flyteidl2/workflow/queue_service.pb.validate.go @@ -0,0 +1,912 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/workflow/queue_service.proto + +package workflow + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on EnqueueActionRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *EnqueueActionRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on EnqueueActionRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// EnqueueActionRequestMultiError, or nil if none found. +func (m *EnqueueActionRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *EnqueueActionRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetActionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, EnqueueActionRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, EnqueueActionRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetActionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return EnqueueActionRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetRunSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, EnqueueActionRequestValidationError{ + field: "RunSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, EnqueueActionRequestValidationError{ + field: "RunSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return EnqueueActionRequestValidationError{ + field: "RunSpec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for InputUri + + // no validation rules for RunOutputBase + + // no validation rules for Group + + // no validation rules for Subject + + switch v := m.Spec.(type) { + case *EnqueueActionRequest_Task: + if v == nil { + err := EnqueueActionRequestValidationError{ + field: "Spec", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTask()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, EnqueueActionRequestValidationError{ + field: "Task", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, EnqueueActionRequestValidationError{ + field: "Task", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTask()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return EnqueueActionRequestValidationError{ + field: "Task", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *EnqueueActionRequest_Trace: + if v == nil { + err := EnqueueActionRequestValidationError{ + field: "Spec", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTrace()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, EnqueueActionRequestValidationError{ + field: "Trace", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, EnqueueActionRequestValidationError{ + field: "Trace", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTrace()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return EnqueueActionRequestValidationError{ + field: "Trace", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *EnqueueActionRequest_Condition: + if v == nil { + err := EnqueueActionRequestValidationError{ + field: "Spec", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetCondition()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, EnqueueActionRequestValidationError{ + field: "Condition", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, EnqueueActionRequestValidationError{ + field: "Condition", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCondition()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return EnqueueActionRequestValidationError{ + field: "Condition", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if m.ParentActionName != nil { + // no validation rules for ParentActionName + } + + if len(errors) > 0 { + return EnqueueActionRequestMultiError(errors) + } + + return nil +} + +// EnqueueActionRequestMultiError is an error wrapping multiple validation +// errors returned by EnqueueActionRequest.ValidateAll() if the designated +// constraints aren't met. +type EnqueueActionRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m EnqueueActionRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m EnqueueActionRequestMultiError) AllErrors() []error { return m } + +// EnqueueActionRequestValidationError is the validation error returned by +// EnqueueActionRequest.Validate if the designated constraints aren't met. +type EnqueueActionRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e EnqueueActionRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e EnqueueActionRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e EnqueueActionRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e EnqueueActionRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e EnqueueActionRequestValidationError) ErrorName() string { + return "EnqueueActionRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e EnqueueActionRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sEnqueueActionRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = EnqueueActionRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = EnqueueActionRequestValidationError{} + +// Validate checks the field values on EnqueueActionResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *EnqueueActionResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on EnqueueActionResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// EnqueueActionResponseMultiError, or nil if none found. +func (m *EnqueueActionResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *EnqueueActionResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return EnqueueActionResponseMultiError(errors) + } + + return nil +} + +// EnqueueActionResponseMultiError is an error wrapping multiple validation +// errors returned by EnqueueActionResponse.ValidateAll() if the designated +// constraints aren't met. +type EnqueueActionResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m EnqueueActionResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m EnqueueActionResponseMultiError) AllErrors() []error { return m } + +// EnqueueActionResponseValidationError is the validation error returned by +// EnqueueActionResponse.Validate if the designated constraints aren't met. +type EnqueueActionResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e EnqueueActionResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e EnqueueActionResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e EnqueueActionResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e EnqueueActionResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e EnqueueActionResponseValidationError) ErrorName() string { + return "EnqueueActionResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e EnqueueActionResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sEnqueueActionResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = EnqueueActionResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = EnqueueActionResponseValidationError{} + +// Validate checks the field values on AbortQueuedRunRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *AbortQueuedRunRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on AbortQueuedRunRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// AbortQueuedRunRequestMultiError, or nil if none found. +func (m *AbortQueuedRunRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *AbortQueuedRunRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRunId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, AbortQueuedRunRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, AbortQueuedRunRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return AbortQueuedRunRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if m.Reason != nil { + // no validation rules for Reason + } + + if len(errors) > 0 { + return AbortQueuedRunRequestMultiError(errors) + } + + return nil +} + +// AbortQueuedRunRequestMultiError is an error wrapping multiple validation +// errors returned by AbortQueuedRunRequest.ValidateAll() if the designated +// constraints aren't met. +type AbortQueuedRunRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m AbortQueuedRunRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m AbortQueuedRunRequestMultiError) AllErrors() []error { return m } + +// AbortQueuedRunRequestValidationError is the validation error returned by +// AbortQueuedRunRequest.Validate if the designated constraints aren't met. +type AbortQueuedRunRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e AbortQueuedRunRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e AbortQueuedRunRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e AbortQueuedRunRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e AbortQueuedRunRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e AbortQueuedRunRequestValidationError) ErrorName() string { + return "AbortQueuedRunRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e AbortQueuedRunRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sAbortQueuedRunRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = AbortQueuedRunRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = AbortQueuedRunRequestValidationError{} + +// Validate checks the field values on AbortQueuedRunResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *AbortQueuedRunResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on AbortQueuedRunResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// AbortQueuedRunResponseMultiError, or nil if none found. +func (m *AbortQueuedRunResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *AbortQueuedRunResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return AbortQueuedRunResponseMultiError(errors) + } + + return nil +} + +// AbortQueuedRunResponseMultiError is an error wrapping multiple validation +// errors returned by AbortQueuedRunResponse.ValidateAll() if the designated +// constraints aren't met. +type AbortQueuedRunResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m AbortQueuedRunResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m AbortQueuedRunResponseMultiError) AllErrors() []error { return m } + +// AbortQueuedRunResponseValidationError is the validation error returned by +// AbortQueuedRunResponse.Validate if the designated constraints aren't met. +type AbortQueuedRunResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e AbortQueuedRunResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e AbortQueuedRunResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e AbortQueuedRunResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e AbortQueuedRunResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e AbortQueuedRunResponseValidationError) ErrorName() string { + return "AbortQueuedRunResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e AbortQueuedRunResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sAbortQueuedRunResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = AbortQueuedRunResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = AbortQueuedRunResponseValidationError{} + +// Validate checks the field values on AbortQueuedActionRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *AbortQueuedActionRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on AbortQueuedActionRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// AbortQueuedActionRequestMultiError, or nil if none found. +func (m *AbortQueuedActionRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *AbortQueuedActionRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetActionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, AbortQueuedActionRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, AbortQueuedActionRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetActionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return AbortQueuedActionRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if m.Reason != nil { + // no validation rules for Reason + } + + if len(errors) > 0 { + return AbortQueuedActionRequestMultiError(errors) + } + + return nil +} + +// AbortQueuedActionRequestMultiError is an error wrapping multiple validation +// errors returned by AbortQueuedActionRequest.ValidateAll() if the designated +// constraints aren't met. +type AbortQueuedActionRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m AbortQueuedActionRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m AbortQueuedActionRequestMultiError) AllErrors() []error { return m } + +// AbortQueuedActionRequestValidationError is the validation error returned by +// AbortQueuedActionRequest.Validate if the designated constraints aren't met. +type AbortQueuedActionRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e AbortQueuedActionRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e AbortQueuedActionRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e AbortQueuedActionRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e AbortQueuedActionRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e AbortQueuedActionRequestValidationError) ErrorName() string { + return "AbortQueuedActionRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e AbortQueuedActionRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sAbortQueuedActionRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = AbortQueuedActionRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = AbortQueuedActionRequestValidationError{} + +// Validate checks the field values on AbortQueuedActionResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *AbortQueuedActionResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on AbortQueuedActionResponse with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// AbortQueuedActionResponseMultiError, or nil if none found. +func (m *AbortQueuedActionResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *AbortQueuedActionResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return AbortQueuedActionResponseMultiError(errors) + } + + return nil +} + +// AbortQueuedActionResponseMultiError is an error wrapping multiple validation +// errors returned by AbortQueuedActionResponse.ValidateAll() if the +// designated constraints aren't met. +type AbortQueuedActionResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m AbortQueuedActionResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m AbortQueuedActionResponseMultiError) AllErrors() []error { return m } + +// AbortQueuedActionResponseValidationError is the validation error returned by +// AbortQueuedActionResponse.Validate if the designated constraints aren't met. +type AbortQueuedActionResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e AbortQueuedActionResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e AbortQueuedActionResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e AbortQueuedActionResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e AbortQueuedActionResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e AbortQueuedActionResponseValidationError) ErrorName() string { + return "AbortQueuedActionResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e AbortQueuedActionResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sAbortQueuedActionResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = AbortQueuedActionResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = AbortQueuedActionResponseValidationError{} diff --git a/gen/go/flyteidl2/workflow/queue_service_grpc.pb.go b/gen/go/flyteidl2/workflow/queue_service_grpc.pb.go new file mode 100644 index 0000000000..2eb9655823 --- /dev/null +++ b/gen/go/flyteidl2/workflow/queue_service_grpc.pb.go @@ -0,0 +1,187 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: flyteidl2/workflow/queue_service.proto + +package workflow + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + QueueService_EnqueueAction_FullMethodName = "/flyteidl2.workflow.QueueService/EnqueueAction" + QueueService_AbortQueuedRun_FullMethodName = "/flyteidl2.workflow.QueueService/AbortQueuedRun" + QueueService_AbortQueuedAction_FullMethodName = "/flyteidl2.workflow.QueueService/AbortQueuedAction" +) + +// QueueServiceClient is the client API for QueueService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type QueueServiceClient interface { + // queue a new action for execution. + EnqueueAction(ctx context.Context, in *EnqueueActionRequest, opts ...grpc.CallOption) (*EnqueueActionResponse, error) + // abort a queued run. + AbortQueuedRun(ctx context.Context, in *AbortQueuedRunRequest, opts ...grpc.CallOption) (*AbortQueuedRunResponse, error) + // AbortAction aborts a single action that was previously queued or is currently being processed by a worker. + AbortQueuedAction(ctx context.Context, in *AbortQueuedActionRequest, opts ...grpc.CallOption) (*AbortQueuedActionResponse, error) +} + +type queueServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewQueueServiceClient(cc grpc.ClientConnInterface) QueueServiceClient { + return &queueServiceClient{cc} +} + +func (c *queueServiceClient) EnqueueAction(ctx context.Context, in *EnqueueActionRequest, opts ...grpc.CallOption) (*EnqueueActionResponse, error) { + out := new(EnqueueActionResponse) + err := c.cc.Invoke(ctx, QueueService_EnqueueAction_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queueServiceClient) AbortQueuedRun(ctx context.Context, in *AbortQueuedRunRequest, opts ...grpc.CallOption) (*AbortQueuedRunResponse, error) { + out := new(AbortQueuedRunResponse) + err := c.cc.Invoke(ctx, QueueService_AbortQueuedRun_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queueServiceClient) AbortQueuedAction(ctx context.Context, in *AbortQueuedActionRequest, opts ...grpc.CallOption) (*AbortQueuedActionResponse, error) { + out := new(AbortQueuedActionResponse) + err := c.cc.Invoke(ctx, QueueService_AbortQueuedAction_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueueServiceServer is the server API for QueueService service. +// All implementations should embed UnimplementedQueueServiceServer +// for forward compatibility +type QueueServiceServer interface { + // queue a new action for execution. + EnqueueAction(context.Context, *EnqueueActionRequest) (*EnqueueActionResponse, error) + // abort a queued run. + AbortQueuedRun(context.Context, *AbortQueuedRunRequest) (*AbortQueuedRunResponse, error) + // AbortAction aborts a single action that was previously queued or is currently being processed by a worker. + AbortQueuedAction(context.Context, *AbortQueuedActionRequest) (*AbortQueuedActionResponse, error) +} + +// UnimplementedQueueServiceServer should be embedded to have forward compatible implementations. +type UnimplementedQueueServiceServer struct { +} + +func (UnimplementedQueueServiceServer) EnqueueAction(context.Context, *EnqueueActionRequest) (*EnqueueActionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method EnqueueAction not implemented") +} +func (UnimplementedQueueServiceServer) AbortQueuedRun(context.Context, *AbortQueuedRunRequest) (*AbortQueuedRunResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method AbortQueuedRun not implemented") +} +func (UnimplementedQueueServiceServer) AbortQueuedAction(context.Context, *AbortQueuedActionRequest) (*AbortQueuedActionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method AbortQueuedAction not implemented") +} + +// UnsafeQueueServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to QueueServiceServer will +// result in compilation errors. +type UnsafeQueueServiceServer interface { + mustEmbedUnimplementedQueueServiceServer() +} + +func RegisterQueueServiceServer(s grpc.ServiceRegistrar, srv QueueServiceServer) { + s.RegisterService(&QueueService_ServiceDesc, srv) +} + +func _QueueService_EnqueueAction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(EnqueueActionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueueServiceServer).EnqueueAction(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: QueueService_EnqueueAction_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueueServiceServer).EnqueueAction(ctx, req.(*EnqueueActionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _QueueService_AbortQueuedRun_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AbortQueuedRunRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueueServiceServer).AbortQueuedRun(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: QueueService_AbortQueuedRun_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueueServiceServer).AbortQueuedRun(ctx, req.(*AbortQueuedRunRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _QueueService_AbortQueuedAction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AbortQueuedActionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueueServiceServer).AbortQueuedAction(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: QueueService_AbortQueuedAction_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueueServiceServer).AbortQueuedAction(ctx, req.(*AbortQueuedActionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// QueueService_ServiceDesc is the grpc.ServiceDesc for QueueService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var QueueService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.workflow.QueueService", + HandlerType: (*QueueServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "EnqueueAction", + Handler: _QueueService_EnqueueAction_Handler, + }, + { + MethodName: "AbortQueuedRun", + Handler: _QueueService_AbortQueuedRun_Handler, + }, + { + MethodName: "AbortQueuedAction", + Handler: _QueueService_AbortQueuedAction_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "flyteidl2/workflow/queue_service.proto", +} diff --git a/gen/go/flyteidl2/workflow/run_definition.pb.go b/gen/go/flyteidl2/workflow/run_definition.pb.go new file mode 100644 index 0000000000..3dbc7607da --- /dev/null +++ b/gen/go/flyteidl2/workflow/run_definition.pb.go @@ -0,0 +1,3463 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/workflow/run_definition.proto + +package workflow + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + task "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + durationpb "google.golang.org/protobuf/types/known/durationpb" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + wrapperspb "google.golang.org/protobuf/types/known/wrapperspb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type ActionType int32 + +const ( + ActionType_ACTION_TYPE_UNSPECIFIED ActionType = 0 + ActionType_ACTION_TYPE_TASK ActionType = 1 + ActionType_ACTION_TYPE_TRACE ActionType = 2 + ActionType_ACTION_TYPE_CONDITION ActionType = 3 +) + +// Enum value maps for ActionType. +var ( + ActionType_name = map[int32]string{ + 0: "ACTION_TYPE_UNSPECIFIED", + 1: "ACTION_TYPE_TASK", + 2: "ACTION_TYPE_TRACE", + 3: "ACTION_TYPE_CONDITION", + } + ActionType_value = map[string]int32{ + "ACTION_TYPE_UNSPECIFIED": 0, + "ACTION_TYPE_TASK": 1, + "ACTION_TYPE_TRACE": 2, + "ACTION_TYPE_CONDITION": 3, + } +) + +func (x ActionType) Enum() *ActionType { + p := new(ActionType) + *p = x + return p +} + +func (x ActionType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ActionType) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_workflow_run_definition_proto_enumTypes[0].Descriptor() +} + +func (ActionType) Type() protoreflect.EnumType { + return &file_flyteidl2_workflow_run_definition_proto_enumTypes[0] +} + +func (x ActionType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use ActionType.Descriptor instead. +func (ActionType) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{0} +} + +type RunSource int32 + +const ( + RunSource_RUN_SOURCE_UNSPECIFIED RunSource = 0 + RunSource_RUN_SOURCE_WEB RunSource = 1 + RunSource_RUN_SOURCE_CLI RunSource = 2 + RunSource_RUN_SOURCE_SCHEDULE_TRIGGER RunSource = 3 +) + +// Enum value maps for RunSource. +var ( + RunSource_name = map[int32]string{ + 0: "RUN_SOURCE_UNSPECIFIED", + 1: "RUN_SOURCE_WEB", + 2: "RUN_SOURCE_CLI", + 3: "RUN_SOURCE_SCHEDULE_TRIGGER", + } + RunSource_value = map[string]int32{ + "RUN_SOURCE_UNSPECIFIED": 0, + "RUN_SOURCE_WEB": 1, + "RUN_SOURCE_CLI": 2, + "RUN_SOURCE_SCHEDULE_TRIGGER": 3, + } +) + +func (x RunSource) Enum() *RunSource { + p := new(RunSource) + *p = x + return p +} + +func (x RunSource) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (RunSource) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_workflow_run_definition_proto_enumTypes[1].Descriptor() +} + +func (RunSource) Type() protoreflect.EnumType { + return &file_flyteidl2_workflow_run_definition_proto_enumTypes[1] +} + +func (x RunSource) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use RunSource.Descriptor instead. +func (RunSource) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{1} +} + +type ErrorInfo_Kind int32 + +const ( + ErrorInfo_KIND_UNSPECIFIED ErrorInfo_Kind = 0 + ErrorInfo_KIND_USER ErrorInfo_Kind = 1 + ErrorInfo_KIND_SYSTEM ErrorInfo_Kind = 2 +) + +// Enum value maps for ErrorInfo_Kind. +var ( + ErrorInfo_Kind_name = map[int32]string{ + 0: "KIND_UNSPECIFIED", + 1: "KIND_USER", + 2: "KIND_SYSTEM", + } + ErrorInfo_Kind_value = map[string]int32{ + "KIND_UNSPECIFIED": 0, + "KIND_USER": 1, + "KIND_SYSTEM": 2, + } +) + +func (x ErrorInfo_Kind) Enum() *ErrorInfo_Kind { + p := new(ErrorInfo_Kind) + *p = x + return p +} + +func (x ErrorInfo_Kind) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ErrorInfo_Kind) Descriptor() protoreflect.EnumDescriptor { + return file_flyteidl2_workflow_run_definition_proto_enumTypes[2].Descriptor() +} + +func (ErrorInfo_Kind) Type() protoreflect.EnumType { + return &file_flyteidl2_workflow_run_definition_proto_enumTypes[2] +} + +func (x ErrorInfo_Kind) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use ErrorInfo_Kind.Descriptor instead. +func (ErrorInfo_Kind) EnumDescriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{12, 0} +} + +type Run struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Lightweight information about the root action. + Action *Action `protobuf:"bytes,1,opt,name=action,proto3" json:"action,omitempty"` +} + +func (x *Run) Reset() { + *x = Run{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Run) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Run) ProtoMessage() {} + +func (x *Run) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Run.ProtoReflect.Descriptor instead. +func (*Run) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{0} +} + +func (x *Run) GetAction() *Action { + if x != nil { + return x.Action + } + return nil +} + +type RunDetails struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Run spec. + RunSpec *task.RunSpec `protobuf:"bytes,1,opt,name=run_spec,json=runSpec,proto3" json:"run_spec,omitempty"` + // Detailed information about the root action. + Action *ActionDetails `protobuf:"bytes,2,opt,name=action,proto3" json:"action,omitempty"` +} + +func (x *RunDetails) Reset() { + *x = RunDetails{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RunDetails) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RunDetails) ProtoMessage() {} + +func (x *RunDetails) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RunDetails.ProtoReflect.Descriptor instead. +func (*RunDetails) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{1} +} + +func (x *RunDetails) GetRunSpec() *task.RunSpec { + if x != nil { + return x.RunSpec + } + return nil +} + +func (x *RunDetails) GetAction() *ActionDetails { + if x != nil { + return x.Action + } + return nil +} + +type TaskAction struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // a unique identifier for the task this action is associated with, if applicable. + Id *task.TaskIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // the definition of the task to be executed. + Spec *task.TaskSpec `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"` + // Enables caching when set and specifies the cache version to use. + CacheKey *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=cache_key,json=cacheKey,proto3" json:"cache_key,omitempty"` + // the specific cluster that this action should be executed on. if not set, the cluster from the + // `RunSpec` will be used. + Cluster string `protobuf:"bytes,4,opt,name=cluster,proto3" json:"cluster,omitempty"` +} + +func (x *TaskAction) Reset() { + *x = TaskAction{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskAction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskAction) ProtoMessage() {} + +func (x *TaskAction) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskAction.ProtoReflect.Descriptor instead. +func (*TaskAction) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{2} +} + +func (x *TaskAction) GetId() *task.TaskIdentifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *TaskAction) GetSpec() *task.TaskSpec { + if x != nil { + return x.Spec + } + return nil +} + +func (x *TaskAction) GetCacheKey() *wrapperspb.StringValue { + if x != nil { + return x.CacheKey + } + return nil +} + +func (x *TaskAction) GetCluster() string { + if x != nil { + return x.Cluster + } + return "" +} + +// TraceAction is used to define a trace action that can be used to track the execution of an action that's managed +// by the local worker. This can be used to bring determinism to code that's otherwise not deterministic (e.g. current +// time). +type TraceAction struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Last known phase. + Phase common.ActionPhase `protobuf:"varint,2,opt,name=phase,proto3,enum=flyteidl2.common.ActionPhase" json:"phase,omitempty"` + // Time the attempt started. + StartTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` + // Time the attempt ended, if applicable. + EndTime *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=end_time,json=endTime,proto3,oneof" json:"end_time,omitempty"` + // Output references. + Outputs *task.OutputReferences `protobuf:"bytes,5,opt,name=outputs,proto3" json:"outputs,omitempty"` + // Task spec for the trace, useful for the typed interface inside. + Spec *task.TraceSpec `protobuf:"bytes,6,opt,name=spec,proto3" json:"spec,omitempty"` +} + +func (x *TraceAction) Reset() { + *x = TraceAction{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TraceAction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TraceAction) ProtoMessage() {} + +func (x *TraceAction) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TraceAction.ProtoReflect.Descriptor instead. +func (*TraceAction) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{3} +} + +func (x *TraceAction) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *TraceAction) GetPhase() common.ActionPhase { + if x != nil { + return x.Phase + } + return common.ActionPhase(0) +} + +func (x *TraceAction) GetStartTime() *timestamppb.Timestamp { + if x != nil { + return x.StartTime + } + return nil +} + +func (x *TraceAction) GetEndTime() *timestamppb.Timestamp { + if x != nil { + return x.EndTime + } + return nil +} + +func (x *TraceAction) GetOutputs() *task.OutputReferences { + if x != nil { + return x.Outputs + } + return nil +} + +func (x *TraceAction) GetSpec() *task.TraceSpec { + if x != nil { + return x.Spec + } + return nil +} + +// ConditionAction is used to define a condition that can be evaluated at runtime. It can be used to +// await a signal from an external system and can carry a value. +type ConditionAction struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Name is the unique identifier for the action. It must be unique within the defined scope below. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Types that are assignable to Scope: + // + // *ConditionAction_RunId + // *ConditionAction_ActionId + // *ConditionAction_Global + Scope isConditionAction_Scope `protobuf_oneof:"scope"` + // Type is the type of the value the condition is expected. This can be used to properly render + // a UI element for the condition or validate when a value is received that it is of the expected + // type. + Type *core.LiteralType `protobuf:"bytes,6,opt,name=type,proto3" json:"type,omitempty"` + // Prompt is the prompt that will be shown to the user when the condition is awaited. + Prompt string `protobuf:"bytes,7,opt,name=prompt,proto3" json:"prompt,omitempty"` + // Description is a description of the condition. This can be used to provide additional + // information to the user about the condition. + Description string `protobuf:"bytes,8,opt,name=description,proto3" json:"description,omitempty"` +} + +func (x *ConditionAction) Reset() { + *x = ConditionAction{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ConditionAction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ConditionAction) ProtoMessage() {} + +func (x *ConditionAction) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ConditionAction.ProtoReflect.Descriptor instead. +func (*ConditionAction) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{4} +} + +func (x *ConditionAction) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (m *ConditionAction) GetScope() isConditionAction_Scope { + if m != nil { + return m.Scope + } + return nil +} + +func (x *ConditionAction) GetRunId() string { + if x, ok := x.GetScope().(*ConditionAction_RunId); ok { + return x.RunId + } + return "" +} + +func (x *ConditionAction) GetActionId() string { + if x, ok := x.GetScope().(*ConditionAction_ActionId); ok { + return x.ActionId + } + return "" +} + +func (x *ConditionAction) GetGlobal() bool { + if x, ok := x.GetScope().(*ConditionAction_Global); ok { + return x.Global + } + return false +} + +func (x *ConditionAction) GetType() *core.LiteralType { + if x != nil { + return x.Type + } + return nil +} + +func (x *ConditionAction) GetPrompt() string { + if x != nil { + return x.Prompt + } + return "" +} + +func (x *ConditionAction) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +type isConditionAction_Scope interface { + isConditionAction_Scope() +} + +type ConditionAction_RunId struct { + // RunId is the unique identifier for the run this action is associated with. + RunId string `protobuf:"bytes,2,opt,name=run_id,json=runId,proto3,oneof"` +} + +type ConditionAction_ActionId struct { + // ActionId is the unique identifier for the action this action is associated with. + ActionId string `protobuf:"bytes,3,opt,name=action_id,json=actionId,proto3,oneof"` +} + +type ConditionAction_Global struct { + // Global indicates the condition is global and can be used across all runs and actions. + Global bool `protobuf:"varint,4,opt,name=global,proto3,oneof"` +} + +func (*ConditionAction_RunId) isConditionAction_Scope() {} + +func (*ConditionAction_ActionId) isConditionAction_Scope() {} + +func (*ConditionAction_Global) isConditionAction_Scope() {} + +type TaskActionMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Id of the task this action is associated with. + Id *task.TaskIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // Extensible task type. + TaskType string `protobuf:"bytes,2,opt,name=task_type,json=taskType,proto3" json:"task_type,omitempty"` + // The short name for this task. + ShortName string `protobuf:"bytes,3,opt,name=short_name,json=shortName,proto3" json:"short_name,omitempty"` +} + +func (x *TaskActionMetadata) Reset() { + *x = TaskActionMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskActionMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskActionMetadata) ProtoMessage() {} + +func (x *TaskActionMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskActionMetadata.ProtoReflect.Descriptor instead. +func (*TaskActionMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{5} +} + +func (x *TaskActionMetadata) GetId() *task.TaskIdentifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *TaskActionMetadata) GetTaskType() string { + if x != nil { + return x.TaskType + } + return "" +} + +func (x *TaskActionMetadata) GetShortName() string { + if x != nil { + return x.ShortName + } + return "" +} + +type TraceActionMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *TraceActionMetadata) Reset() { + *x = TraceActionMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TraceActionMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TraceActionMetadata) ProtoMessage() {} + +func (x *TraceActionMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TraceActionMetadata.ProtoReflect.Descriptor instead. +func (*TraceActionMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{6} +} + +func (x *TraceActionMetadata) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type ConditionActionMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Types that are assignable to Scope: + // + // *ConditionActionMetadata_RunId + // *ConditionActionMetadata_ActionId + // *ConditionActionMetadata_Global + Scope isConditionActionMetadata_Scope `protobuf_oneof:"scope"` +} + +func (x *ConditionActionMetadata) Reset() { + *x = ConditionActionMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ConditionActionMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ConditionActionMetadata) ProtoMessage() {} + +func (x *ConditionActionMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ConditionActionMetadata.ProtoReflect.Descriptor instead. +func (*ConditionActionMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{7} +} + +func (x *ConditionActionMetadata) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (m *ConditionActionMetadata) GetScope() isConditionActionMetadata_Scope { + if m != nil { + return m.Scope + } + return nil +} + +func (x *ConditionActionMetadata) GetRunId() string { + if x, ok := x.GetScope().(*ConditionActionMetadata_RunId); ok { + return x.RunId + } + return "" +} + +func (x *ConditionActionMetadata) GetActionId() string { + if x, ok := x.GetScope().(*ConditionActionMetadata_ActionId); ok { + return x.ActionId + } + return "" +} + +func (x *ConditionActionMetadata) GetGlobal() bool { + if x, ok := x.GetScope().(*ConditionActionMetadata_Global); ok { + return x.Global + } + return false +} + +type isConditionActionMetadata_Scope interface { + isConditionActionMetadata_Scope() +} + +type ConditionActionMetadata_RunId struct { + // RunId is the unique identifier for the run this action is associated with. + RunId string `protobuf:"bytes,2,opt,name=run_id,json=runId,proto3,oneof"` +} + +type ConditionActionMetadata_ActionId struct { + // ActionId is the unique identifier for the action this action is associated with. + ActionId string `protobuf:"bytes,3,opt,name=action_id,json=actionId,proto3,oneof"` +} + +type ConditionActionMetadata_Global struct { + // Global indicates the condition is global and can be used across all runs and actions. + Global bool `protobuf:"varint,4,opt,name=global,proto3,oneof"` +} + +func (*ConditionActionMetadata_RunId) isConditionActionMetadata_Scope() {} + +func (*ConditionActionMetadata_ActionId) isConditionActionMetadata_Scope() {} + +func (*ConditionActionMetadata_Global) isConditionActionMetadata_Scope() {} + +// Static, lightweight metadata about an action. +type ActionMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Parent action if not the root. + Parent string `protobuf:"bytes,3,opt,name=parent,proto3" json:"parent,omitempty"` + // Group this action belongs to, if applicable. + Group string `protobuf:"bytes,5,opt,name=group,proto3" json:"group,omitempty"` + // Identity that executed this run. + ExecutedBy *common.EnrichedIdentity `protobuf:"bytes,6,opt,name=executed_by,json=executedBy,proto3" json:"executed_by,omitempty"` + // Types that are assignable to Spec: + // + // *ActionMetadata_Task + // *ActionMetadata_Trace + // *ActionMetadata_Condition + Spec isActionMetadata_Spec `protobuf_oneof:"spec"` + // Action type. + ActionType ActionType `protobuf:"varint,10,opt,name=action_type,json=actionType,proto3,enum=flyteidl2.workflow.ActionType" json:"action_type,omitempty"` + // If this run was initiated by a trigger, this will store the trigger identifier. + TriggerId *common.TriggerIdentifier `protobuf:"bytes,11,opt,name=trigger_id,json=triggerId,proto3" json:"trigger_id,omitempty"` + // Environment name + EnvironmentName string `protobuf:"bytes,12,opt,name=environment_name,json=environmentName,proto3" json:"environment_name,omitempty"` + // Function name + FuntionName string `protobuf:"bytes,13,opt,name=funtion_name,json=funtionName,proto3" json:"funtion_name,omitempty"` + // Trigger name + TriggerName string `protobuf:"bytes,14,opt,name=trigger_name,json=triggerName,proto3" json:"trigger_name,omitempty"` + // Trigger Type + TriggerType *task.TriggerAutomationSpec `protobuf:"bytes,15,opt,name=trigger_type,json=triggerType,proto3" json:"trigger_type,omitempty"` + // Who initiated this run + Source RunSource `protobuf:"varint,16,opt,name=source,proto3,enum=flyteidl2.workflow.RunSource" json:"source,omitempty"` +} + +func (x *ActionMetadata) Reset() { + *x = ActionMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ActionMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ActionMetadata) ProtoMessage() {} + +func (x *ActionMetadata) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ActionMetadata.ProtoReflect.Descriptor instead. +func (*ActionMetadata) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{8} +} + +func (x *ActionMetadata) GetParent() string { + if x != nil { + return x.Parent + } + return "" +} + +func (x *ActionMetadata) GetGroup() string { + if x != nil { + return x.Group + } + return "" +} + +func (x *ActionMetadata) GetExecutedBy() *common.EnrichedIdentity { + if x != nil { + return x.ExecutedBy + } + return nil +} + +func (m *ActionMetadata) GetSpec() isActionMetadata_Spec { + if m != nil { + return m.Spec + } + return nil +} + +func (x *ActionMetadata) GetTask() *TaskActionMetadata { + if x, ok := x.GetSpec().(*ActionMetadata_Task); ok { + return x.Task + } + return nil +} + +func (x *ActionMetadata) GetTrace() *TraceActionMetadata { + if x, ok := x.GetSpec().(*ActionMetadata_Trace); ok { + return x.Trace + } + return nil +} + +func (x *ActionMetadata) GetCondition() *ConditionActionMetadata { + if x, ok := x.GetSpec().(*ActionMetadata_Condition); ok { + return x.Condition + } + return nil +} + +func (x *ActionMetadata) GetActionType() ActionType { + if x != nil { + return x.ActionType + } + return ActionType_ACTION_TYPE_UNSPECIFIED +} + +func (x *ActionMetadata) GetTriggerId() *common.TriggerIdentifier { + if x != nil { + return x.TriggerId + } + return nil +} + +func (x *ActionMetadata) GetEnvironmentName() string { + if x != nil { + return x.EnvironmentName + } + return "" +} + +func (x *ActionMetadata) GetFuntionName() string { + if x != nil { + return x.FuntionName + } + return "" +} + +func (x *ActionMetadata) GetTriggerName() string { + if x != nil { + return x.TriggerName + } + return "" +} + +func (x *ActionMetadata) GetTriggerType() *task.TriggerAutomationSpec { + if x != nil { + return x.TriggerType + } + return nil +} + +func (x *ActionMetadata) GetSource() RunSource { + if x != nil { + return x.Source + } + return RunSource_RUN_SOURCE_UNSPECIFIED +} + +type isActionMetadata_Spec interface { + isActionMetadata_Spec() +} + +type ActionMetadata_Task struct { + // Task action. + Task *TaskActionMetadata `protobuf:"bytes,7,opt,name=task,proto3,oneof"` +} + +type ActionMetadata_Trace struct { + // Trace action. + Trace *TraceActionMetadata `protobuf:"bytes,8,opt,name=trace,proto3,oneof"` +} + +type ActionMetadata_Condition struct { + // Condition action. + Condition *ConditionActionMetadata `protobuf:"bytes,9,opt,name=condition,proto3,oneof"` +} + +func (*ActionMetadata_Task) isActionMetadata_Spec() {} + +func (*ActionMetadata_Trace) isActionMetadata_Spec() {} + +func (*ActionMetadata_Condition) isActionMetadata_Spec() {} + +// Lightweight status of an action. For more detailed status see ActionDetails. +type ActionStatus struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Last known phase. + Phase common.ActionPhase `protobuf:"varint,1,opt,name=phase,proto3,enum=flyteidl2.common.ActionPhase" json:"phase,omitempty"` + // Time the action started. + StartTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` + // Time the action ended, if applicable. + EndTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3,oneof" json:"end_time,omitempty"` + // Number of action attempts. + Attempts uint32 `protobuf:"varint,4,opt,name=attempts,proto3" json:"attempts,omitempty"` + // cache status of the action's latest attempt + CacheStatus core.CatalogCacheStatus `protobuf:"varint,5,opt,name=cache_status,json=cacheStatus,proto3,enum=flyteidl2.core.CatalogCacheStatus" json:"cache_status,omitempty"` + // Duration of the action in milliseconds. + DurationMs *uint64 `protobuf:"varint,6,opt,name=duration_ms,json=durationMs,proto3,oneof" json:"duration_ms,omitempty"` +} + +func (x *ActionStatus) Reset() { + *x = ActionStatus{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ActionStatus) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ActionStatus) ProtoMessage() {} + +func (x *ActionStatus) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ActionStatus.ProtoReflect.Descriptor instead. +func (*ActionStatus) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{9} +} + +func (x *ActionStatus) GetPhase() common.ActionPhase { + if x != nil { + return x.Phase + } + return common.ActionPhase(0) +} + +func (x *ActionStatus) GetStartTime() *timestamppb.Timestamp { + if x != nil { + return x.StartTime + } + return nil +} + +func (x *ActionStatus) GetEndTime() *timestamppb.Timestamp { + if x != nil { + return x.EndTime + } + return nil +} + +func (x *ActionStatus) GetAttempts() uint32 { + if x != nil { + return x.Attempts + } + return 0 +} + +func (x *ActionStatus) GetCacheStatus() core.CatalogCacheStatus { + if x != nil { + return x.CacheStatus + } + return core.CatalogCacheStatus(0) +} + +func (x *ActionStatus) GetDurationMs() uint64 { + if x != nil && x.DurationMs != nil { + return *x.DurationMs + } + return 0 +} + +// Lightweight representation of an action. +type Action struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Id for this action. + Id *common.ActionIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // Metadata for this action. + Metadata *ActionMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"` + // Last known status. + Status *ActionStatus `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"` +} + +func (x *Action) Reset() { + *x = Action{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Action) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Action) ProtoMessage() {} + +func (x *Action) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Action.ProtoReflect.Descriptor instead. +func (*Action) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{10} +} + +func (x *Action) GetId() *common.ActionIdentifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *Action) GetMetadata() *ActionMetadata { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *Action) GetStatus() *ActionStatus { + if x != nil { + return x.Status + } + return nil +} + +// EnrichedAction is a wrapper around Action that contains additional information +type EnrichedAction struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The action itself. + Action *Action `protobuf:"bytes,1,opt,name=action,proto3" json:"action,omitempty"` + // Whether this action meets specified filters of the request or not. + // If an action that was previously meeting the filter but no longer does, will be sent with this flag set to false + MeetsFilter bool `protobuf:"varint,2,opt,name=meets_filter,json=meetsFilter,proto3" json:"meets_filter,omitempty"` + // Child phase info for this action (Map of phase to counts of children in given phase) + ChildrenPhaseCounts map[int32]int32 `protobuf:"bytes,3,rep,name=children_phase_counts,json=childrenPhaseCounts,proto3" json:"children_phase_counts,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` +} + +func (x *EnrichedAction) Reset() { + *x = EnrichedAction{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EnrichedAction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EnrichedAction) ProtoMessage() {} + +func (x *EnrichedAction) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EnrichedAction.ProtoReflect.Descriptor instead. +func (*EnrichedAction) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{11} +} + +func (x *EnrichedAction) GetAction() *Action { + if x != nil { + return x.Action + } + return nil +} + +func (x *EnrichedAction) GetMeetsFilter() bool { + if x != nil { + return x.MeetsFilter + } + return false +} + +func (x *EnrichedAction) GetChildrenPhaseCounts() map[int32]int32 { + if x != nil { + return x.ChildrenPhaseCounts + } + return nil +} + +// ErrorInfo captures details of an error. +type ErrorInfo struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Error message. + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` + // Error kind. + Kind ErrorInfo_Kind `protobuf:"varint,2,opt,name=kind,proto3,enum=flyteidl2.workflow.ErrorInfo_Kind" json:"kind,omitempty"` +} + +func (x *ErrorInfo) Reset() { + *x = ErrorInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ErrorInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ErrorInfo) ProtoMessage() {} + +func (x *ErrorInfo) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ErrorInfo.ProtoReflect.Descriptor instead. +func (*ErrorInfo) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{12} +} + +func (x *ErrorInfo) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +func (x *ErrorInfo) GetKind() ErrorInfo_Kind { + if x != nil { + return x.Kind + } + return ErrorInfo_KIND_UNSPECIFIED +} + +// AbortInfo captures details of an aborted run. +type AbortInfo struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Reason provided for the abort. + Reason string `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"` + // Identity that aborted the run. + AbortedBy *common.EnrichedIdentity `protobuf:"bytes,2,opt,name=aborted_by,json=abortedBy,proto3" json:"aborted_by,omitempty"` +} + +func (x *AbortInfo) Reset() { + *x = AbortInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AbortInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AbortInfo) ProtoMessage() {} + +func (x *AbortInfo) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AbortInfo.ProtoReflect.Descriptor instead. +func (*AbortInfo) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{13} +} + +func (x *AbortInfo) GetReason() string { + if x != nil { + return x.Reason + } + return "" +} + +func (x *AbortInfo) GetAbortedBy() *common.EnrichedIdentity { + if x != nil { + return x.AbortedBy + } + return nil +} + +// ActionDetails is the full details of an action. +type ActionDetails struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Id for this action. + Id *common.ActionIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // Metadata for this action. + Metadata *ActionMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"` + // Last known status. + Status *ActionStatus `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"` + // Types that are assignable to Result: + // + // *ActionDetails_ErrorInfo + // *ActionDetails_AbortInfo + Result isActionDetails_Result `protobuf_oneof:"result"` + // Fully resolved spec of the action. Merges user submitted task spec with platform defaults. + // + // Types that are assignable to Spec: + // + // *ActionDetails_Task + // *ActionDetails_Trace + Spec isActionDetails_Spec `protobuf_oneof:"spec"` + // List of action attempts. + Attempts []*ActionAttempt `protobuf:"bytes,7,rep,name=attempts,proto3" json:"attempts,omitempty"` +} + +func (x *ActionDetails) Reset() { + *x = ActionDetails{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ActionDetails) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ActionDetails) ProtoMessage() {} + +func (x *ActionDetails) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ActionDetails.ProtoReflect.Descriptor instead. +func (*ActionDetails) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{14} +} + +func (x *ActionDetails) GetId() *common.ActionIdentifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *ActionDetails) GetMetadata() *ActionMetadata { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *ActionDetails) GetStatus() *ActionStatus { + if x != nil { + return x.Status + } + return nil +} + +func (m *ActionDetails) GetResult() isActionDetails_Result { + if m != nil { + return m.Result + } + return nil +} + +func (x *ActionDetails) GetErrorInfo() *ErrorInfo { + if x, ok := x.GetResult().(*ActionDetails_ErrorInfo); ok { + return x.ErrorInfo + } + return nil +} + +func (x *ActionDetails) GetAbortInfo() *AbortInfo { + if x, ok := x.GetResult().(*ActionDetails_AbortInfo); ok { + return x.AbortInfo + } + return nil +} + +func (m *ActionDetails) GetSpec() isActionDetails_Spec { + if m != nil { + return m.Spec + } + return nil +} + +func (x *ActionDetails) GetTask() *task.TaskSpec { + if x, ok := x.GetSpec().(*ActionDetails_Task); ok { + return x.Task + } + return nil +} + +func (x *ActionDetails) GetTrace() *task.TraceSpec { + if x, ok := x.GetSpec().(*ActionDetails_Trace); ok { + return x.Trace + } + return nil +} + +func (x *ActionDetails) GetAttempts() []*ActionAttempt { + if x != nil { + return x.Attempts + } + return nil +} + +type isActionDetails_Result interface { + isActionDetails_Result() +} + +type ActionDetails_ErrorInfo struct { + // Error info for the action, if failed. + ErrorInfo *ErrorInfo `protobuf:"bytes,4,opt,name=error_info,json=errorInfo,proto3,oneof"` +} + +type ActionDetails_AbortInfo struct { + // Abort info for the action, if aborted. + AbortInfo *AbortInfo `protobuf:"bytes,5,opt,name=abort_info,json=abortInfo,proto3,oneof"` +} + +func (*ActionDetails_ErrorInfo) isActionDetails_Result() {} + +func (*ActionDetails_AbortInfo) isActionDetails_Result() {} + +type isActionDetails_Spec interface { + isActionDetails_Spec() +} + +type ActionDetails_Task struct { + Task *task.TaskSpec `protobuf:"bytes,6,opt,name=task,proto3,oneof"` +} + +type ActionDetails_Trace struct { + Trace *task.TraceSpec `protobuf:"bytes,8,opt,name=trace,proto3,oneof"` +} + +func (*ActionDetails_Task) isActionDetails_Spec() {} + +func (*ActionDetails_Trace) isActionDetails_Spec() {} + +// ActionAttempt is a single attempt of an action. +type ActionAttempt struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Last known phase. + Phase common.ActionPhase `protobuf:"varint,1,opt,name=phase,proto3,enum=flyteidl2.common.ActionPhase" json:"phase,omitempty"` + // Time the attempt started. + StartTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` + // Time the attempt ended, if applicable. + EndTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3,oneof" json:"end_time,omitempty"` + // Error info for the attempt, if failed. + ErrorInfo *ErrorInfo `protobuf:"bytes,4,opt,name=error_info,json=errorInfo,proto3,oneof" json:"error_info,omitempty"` + // The attempt number, starting with 1. + Attempt uint32 `protobuf:"varint,5,opt,name=attempt,proto3" json:"attempt,omitempty"` + // Log references. + LogInfo []*core.TaskLog `protobuf:"bytes,6,rep,name=log_info,json=logInfo,proto3" json:"log_info,omitempty"` + // Output references. + Outputs *task.OutputReferences `protobuf:"bytes,7,opt,name=outputs,proto3" json:"outputs,omitempty"` + // Indicates whether logs are available for tailing. It doesn't necessarily indicate the logs are present, but that + // we have the info we need to look them up. + LogsAvailable bool `protobuf:"varint,8,opt,name=logs_available,json=logsAvailable,proto3" json:"logs_available,omitempty"` + // cache status of the action attempt + CacheStatus core.CatalogCacheStatus `protobuf:"varint,9,opt,name=cache_status,json=cacheStatus,proto3,enum=flyteidl2.core.CatalogCacheStatus" json:"cache_status,omitempty"` + // Cluster events like k8s events in a human-readable form. + ClusterEvents []*ClusterEvent `protobuf:"bytes,10,rep,name=cluster_events,json=clusterEvents,proto3" json:"cluster_events,omitempty"` + // History of phase transitions. + PhaseTransitions []*PhaseTransition `protobuf:"bytes,11,rep,name=phase_transitions,json=phaseTransitions,proto3" json:"phase_transitions,omitempty"` + // The cluster this attempt is assigned to. + Cluster string `protobuf:"bytes,12,opt,name=cluster,proto3" json:"cluster,omitempty"` + // Contains corresponding k8s pods and containers information for this action attempt. + LogContext *core.LogContext `protobuf:"bytes,13,opt,name=log_context,json=logContext,proto3" json:"log_context,omitempty"` +} + +func (x *ActionAttempt) Reset() { + *x = ActionAttempt{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ActionAttempt) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ActionAttempt) ProtoMessage() {} + +func (x *ActionAttempt) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ActionAttempt.ProtoReflect.Descriptor instead. +func (*ActionAttempt) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{15} +} + +func (x *ActionAttempt) GetPhase() common.ActionPhase { + if x != nil { + return x.Phase + } + return common.ActionPhase(0) +} + +func (x *ActionAttempt) GetStartTime() *timestamppb.Timestamp { + if x != nil { + return x.StartTime + } + return nil +} + +func (x *ActionAttempt) GetEndTime() *timestamppb.Timestamp { + if x != nil { + return x.EndTime + } + return nil +} + +func (x *ActionAttempt) GetErrorInfo() *ErrorInfo { + if x != nil { + return x.ErrorInfo + } + return nil +} + +func (x *ActionAttempt) GetAttempt() uint32 { + if x != nil { + return x.Attempt + } + return 0 +} + +func (x *ActionAttempt) GetLogInfo() []*core.TaskLog { + if x != nil { + return x.LogInfo + } + return nil +} + +func (x *ActionAttempt) GetOutputs() *task.OutputReferences { + if x != nil { + return x.Outputs + } + return nil +} + +func (x *ActionAttempt) GetLogsAvailable() bool { + if x != nil { + return x.LogsAvailable + } + return false +} + +func (x *ActionAttempt) GetCacheStatus() core.CatalogCacheStatus { + if x != nil { + return x.CacheStatus + } + return core.CatalogCacheStatus(0) +} + +func (x *ActionAttempt) GetClusterEvents() []*ClusterEvent { + if x != nil { + return x.ClusterEvents + } + return nil +} + +func (x *ActionAttempt) GetPhaseTransitions() []*PhaseTransition { + if x != nil { + return x.PhaseTransitions + } + return nil +} + +func (x *ActionAttempt) GetCluster() string { + if x != nil { + return x.Cluster + } + return "" +} + +func (x *ActionAttempt) GetLogContext() *core.LogContext { + if x != nil { + return x.LogContext + } + return nil +} + +type ClusterEvent struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // occurred_at is the timestamp indicating the instant that this reason happened. + OccurredAt *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=occurred_at,json=occurredAt,proto3" json:"occurred_at,omitempty"` + // message is the explanation for the most recent phase transition or status update. + Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` +} + +func (x *ClusterEvent) Reset() { + *x = ClusterEvent{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ClusterEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ClusterEvent) ProtoMessage() {} + +func (x *ClusterEvent) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[16] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ClusterEvent.ProtoReflect.Descriptor instead. +func (*ClusterEvent) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{16} +} + +func (x *ClusterEvent) GetOccurredAt() *timestamppb.Timestamp { + if x != nil { + return x.OccurredAt + } + return nil +} + +func (x *ClusterEvent) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +type PhaseTransition struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The phase. + Phase common.ActionPhase `protobuf:"varint,1,opt,name=phase,proto3,enum=flyteidl2.common.ActionPhase" json:"phase,omitempty"` + // Time this phase started. + StartTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` + // Time this phase ended, if applicable. For terminal phases, start time will equal end time. + EndTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3,oneof" json:"end_time,omitempty"` +} + +func (x *PhaseTransition) Reset() { + *x = PhaseTransition{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PhaseTransition) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PhaseTransition) ProtoMessage() {} + +func (x *PhaseTransition) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PhaseTransition.ProtoReflect.Descriptor instead. +func (*PhaseTransition) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{17} +} + +func (x *PhaseTransition) GetPhase() common.ActionPhase { + if x != nil { + return x.Phase + } + return common.ActionPhase(0) +} + +func (x *PhaseTransition) GetStartTime() *timestamppb.Timestamp { + if x != nil { + return x.StartTime + } + return nil +} + +func (x *PhaseTransition) GetEndTime() *timestamppb.Timestamp { + if x != nil { + return x.EndTime + } + return nil +} + +// Event payload for an action +type ActionEvent struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The action id. + Id *common.ActionIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // The attempt number. + Attempt uint32 `protobuf:"varint,2,opt,name=attempt,proto3" json:"attempt,omitempty"` + // The phase for this attempt. + Phase common.ActionPhase `protobuf:"varint,3,opt,name=phase,proto3,enum=flyteidl2.common.ActionPhase" json:"phase,omitempty"` + // The version of this attempt and phase. + Version uint32 `protobuf:"varint,4,opt,name=version,proto3" json:"version,omitempty"` + // Time the attempt started. + // + // Deprecated: Marked as deprecated in flyteidl2/workflow/run_definition.proto. + StartTime *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` + // Timestamp when the event occurred, as recorded by the underlying platform (e.g. Kubernetes). + UpdatedTime *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=updated_time,json=updatedTime,proto3" json:"updated_time,omitempty"` + // Time the attempt ended, if applicable. + // + // Deprecated: Marked as deprecated in flyteidl2/workflow/run_definition.proto. + EndTime *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=end_time,json=endTime,proto3,oneof" json:"end_time,omitempty"` + // Error info for the attempt, if failed. + ErrorInfo *ErrorInfo `protobuf:"bytes,8,opt,name=error_info,json=errorInfo,proto3,oneof" json:"error_info,omitempty"` + // Log references. + LogInfo []*core.TaskLog `protobuf:"bytes,9,rep,name=log_info,json=logInfo,proto3" json:"log_info,omitempty"` + // Metadata to associate containers with logs. + LogContext *core.LogContext `protobuf:"bytes,10,opt,name=log_context,json=logContext,proto3" json:"log_context,omitempty"` + // The cluster this attempt is running on. + Cluster string `protobuf:"bytes,11,opt,name=cluster,proto3" json:"cluster,omitempty"` + // Output references. + Outputs *task.OutputReferences `protobuf:"bytes,12,opt,name=outputs,proto3" json:"outputs,omitempty"` + // cache status of the action attempt + CacheStatus core.CatalogCacheStatus `protobuf:"varint,13,opt,name=cache_status,json=cacheStatus,proto3,enum=flyteidl2.core.CatalogCacheStatus" json:"cache_status,omitempty"` + // Cluster events like k8s events in a human-readable form. + ClusterEvents []*ClusterEvent `protobuf:"bytes,14,rep,name=cluster_events,json=clusterEvents,proto3" json:"cluster_events,omitempty"` + // Timestamp when the event was observed and reported by the executor + ReportedTime *timestamppb.Timestamp `protobuf:"bytes,15,opt,name=reported_time,json=reportedTime,proto3" json:"reported_time,omitempty"` +} + +func (x *ActionEvent) Reset() { + *x = ActionEvent{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ActionEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ActionEvent) ProtoMessage() {} + +func (x *ActionEvent) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[18] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ActionEvent.ProtoReflect.Descriptor instead. +func (*ActionEvent) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{18} +} + +func (x *ActionEvent) GetId() *common.ActionIdentifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *ActionEvent) GetAttempt() uint32 { + if x != nil { + return x.Attempt + } + return 0 +} + +func (x *ActionEvent) GetPhase() common.ActionPhase { + if x != nil { + return x.Phase + } + return common.ActionPhase(0) +} + +func (x *ActionEvent) GetVersion() uint32 { + if x != nil { + return x.Version + } + return 0 +} + +// Deprecated: Marked as deprecated in flyteidl2/workflow/run_definition.proto. +func (x *ActionEvent) GetStartTime() *timestamppb.Timestamp { + if x != nil { + return x.StartTime + } + return nil +} + +func (x *ActionEvent) GetUpdatedTime() *timestamppb.Timestamp { + if x != nil { + return x.UpdatedTime + } + return nil +} + +// Deprecated: Marked as deprecated in flyteidl2/workflow/run_definition.proto. +func (x *ActionEvent) GetEndTime() *timestamppb.Timestamp { + if x != nil { + return x.EndTime + } + return nil +} + +func (x *ActionEvent) GetErrorInfo() *ErrorInfo { + if x != nil { + return x.ErrorInfo + } + return nil +} + +func (x *ActionEvent) GetLogInfo() []*core.TaskLog { + if x != nil { + return x.LogInfo + } + return nil +} + +func (x *ActionEvent) GetLogContext() *core.LogContext { + if x != nil { + return x.LogContext + } + return nil +} + +func (x *ActionEvent) GetCluster() string { + if x != nil { + return x.Cluster + } + return "" +} + +func (x *ActionEvent) GetOutputs() *task.OutputReferences { + if x != nil { + return x.Outputs + } + return nil +} + +func (x *ActionEvent) GetCacheStatus() core.CatalogCacheStatus { + if x != nil { + return x.CacheStatus + } + return core.CatalogCacheStatus(0) +} + +func (x *ActionEvent) GetClusterEvents() []*ClusterEvent { + if x != nil { + return x.ClusterEvents + } + return nil +} + +func (x *ActionEvent) GetReportedTime() *timestamppb.Timestamp { + if x != nil { + return x.ReportedTime + } + return nil +} + +type ActionSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // the unique identifier for the action. + ActionId *common.ActionIdentifier `protobuf:"bytes,1,opt,name=action_id,json=actionId,proto3" json:"action_id,omitempty"` + // an optional name for the parent action, if it exists. the remaining run metadata (ex. org, + // project, domain) will be the same as the action_id defined above. + ParentActionName *string `protobuf:"bytes,2,opt,name=parent_action_name,json=parentActionName,proto3,oneof" json:"parent_action_name,omitempty"` + // the run spec for this action + RunSpec *task.RunSpec `protobuf:"bytes,3,opt,name=run_spec,json=runSpec,proto3" json:"run_spec,omitempty"` + // the path to the input data for this action. + InputUri string `protobuf:"bytes,4,opt,name=input_uri,json=inputUri,proto3" json:"input_uri,omitempty"` + // the run base path this action should write its output to. + RunOutputBase string `protobuf:"bytes,5,opt,name=run_output_base,json=runOutputBase,proto3" json:"run_output_base,omitempty"` + // Types that are assignable to Spec: + // + // *ActionSpec_Task + // *ActionSpec_Condition + // *ActionSpec_Trace + Spec isActionSpec_Spec `protobuf_oneof:"spec"` + // group this action belongs to, if applicable. + Group string `protobuf:"bytes,8,opt,name=group,proto3" json:"group,omitempty"` +} + +func (x *ActionSpec) Reset() { + *x = ActionSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ActionSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ActionSpec) ProtoMessage() {} + +func (x *ActionSpec) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[19] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ActionSpec.ProtoReflect.Descriptor instead. +func (*ActionSpec) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{19} +} + +func (x *ActionSpec) GetActionId() *common.ActionIdentifier { + if x != nil { + return x.ActionId + } + return nil +} + +func (x *ActionSpec) GetParentActionName() string { + if x != nil && x.ParentActionName != nil { + return *x.ParentActionName + } + return "" +} + +func (x *ActionSpec) GetRunSpec() *task.RunSpec { + if x != nil { + return x.RunSpec + } + return nil +} + +func (x *ActionSpec) GetInputUri() string { + if x != nil { + return x.InputUri + } + return "" +} + +func (x *ActionSpec) GetRunOutputBase() string { + if x != nil { + return x.RunOutputBase + } + return "" +} + +func (m *ActionSpec) GetSpec() isActionSpec_Spec { + if m != nil { + return m.Spec + } + return nil +} + +func (x *ActionSpec) GetTask() *TaskAction { + if x, ok := x.GetSpec().(*ActionSpec_Task); ok { + return x.Task + } + return nil +} + +func (x *ActionSpec) GetCondition() *ConditionAction { + if x, ok := x.GetSpec().(*ActionSpec_Condition); ok { + return x.Condition + } + return nil +} + +func (x *ActionSpec) GetTrace() *TraceAction { + if x, ok := x.GetSpec().(*ActionSpec_Trace); ok { + return x.Trace + } + return nil +} + +func (x *ActionSpec) GetGroup() string { + if x != nil { + return x.Group + } + return "" +} + +type isActionSpec_Spec interface { + isActionSpec_Spec() +} + +type ActionSpec_Task struct { + Task *TaskAction `protobuf:"bytes,6,opt,name=task,proto3,oneof"` +} + +type ActionSpec_Condition struct { + Condition *ConditionAction `protobuf:"bytes,7,opt,name=condition,proto3,oneof"` +} + +type ActionSpec_Trace struct { + Trace *TraceAction `protobuf:"bytes,10,opt,name=trace,proto3,oneof"` +} + +func (*ActionSpec_Task) isActionSpec_Spec() {} + +func (*ActionSpec_Condition) isActionSpec_Spec() {} + +func (*ActionSpec_Trace) isActionSpec_Spec() {} + +// TaskGroup represents a group of runs for a specific task. +type TaskGroup struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Task name. + TaskName string `protobuf:"bytes,1,opt,name=task_name,json=taskName,proto3" json:"task_name,omitempty"` + // Environment name. + EnvironmentName string `protobuf:"bytes,2,opt,name=environment_name,json=environmentName,proto3" json:"environment_name,omitempty"` + // Total number of runs for this task. + TotalRuns int64 `protobuf:"varint,3,opt,name=total_runs,json=totalRuns,proto3" json:"total_runs,omitempty"` + // Timestamp of the most recent run. + LatestRunTime *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=latest_run_time,json=latestRunTime,proto3" json:"latest_run_time,omitempty"` + // Recent run statuses, ordered from newest to oldest. Number of statuses determined by request. + RecentStatuses []*TaskGroup_RecentStatus `protobuf:"bytes,5,rep,name=recent_statuses,json=recentStatuses,proto3" json:"recent_statuses,omitempty"` + // Average failure rate of runs in this group (0.0 to 1.0). + // Computed as number of root actions with phase FAILED divided by total root actions. + AverageFailureRate float64 `protobuf:"fixed64,6,opt,name=average_failure_rate,json=averageFailureRate,proto3" json:"average_failure_rate,omitempty"` + // Average duration of runs in this group. + AverageDuration *durationpb.Duration `protobuf:"bytes,7,opt,name=average_duration,json=averageDuration,proto3" json:"average_duration,omitempty"` + // Timestamp of the most recent finished run (terminal phase). + LatestFinishedTime *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=latest_finished_time,json=latestFinishedTime,proto3" json:"latest_finished_time,omitempty"` + // List of user/application's enriched identity that created runs in this group. + CreatedBy []*common.EnrichedIdentity `protobuf:"bytes,9,rep,name=created_by,json=createdBy,proto3" json:"created_by,omitempty"` + ShouldDelete bool `protobuf:"varint,10,opt,name=should_delete,json=shouldDelete,proto3" json:"should_delete,omitempty"` + // short name (function name) of the task. + ShortName string `protobuf:"bytes,11,opt,name=short_name,json=shortName,proto3" json:"short_name,omitempty"` + ErrorCounts *TaskGroup_ErrorCounts `protobuf:"bytes,12,opt,name=error_counts,json=errorCounts,proto3" json:"error_counts,omitempty"` + PhaseCounts []*TaskGroup_PhaseCounts `protobuf:"bytes,13,rep,name=phase_counts,json=phaseCounts,proto3" json:"phase_counts,omitempty"` +} + +func (x *TaskGroup) Reset() { + *x = TaskGroup{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskGroup) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskGroup) ProtoMessage() {} + +func (x *TaskGroup) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[20] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskGroup.ProtoReflect.Descriptor instead. +func (*TaskGroup) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{20} +} + +func (x *TaskGroup) GetTaskName() string { + if x != nil { + return x.TaskName + } + return "" +} + +func (x *TaskGroup) GetEnvironmentName() string { + if x != nil { + return x.EnvironmentName + } + return "" +} + +func (x *TaskGroup) GetTotalRuns() int64 { + if x != nil { + return x.TotalRuns + } + return 0 +} + +func (x *TaskGroup) GetLatestRunTime() *timestamppb.Timestamp { + if x != nil { + return x.LatestRunTime + } + return nil +} + +func (x *TaskGroup) GetRecentStatuses() []*TaskGroup_RecentStatus { + if x != nil { + return x.RecentStatuses + } + return nil +} + +func (x *TaskGroup) GetAverageFailureRate() float64 { + if x != nil { + return x.AverageFailureRate + } + return 0 +} + +func (x *TaskGroup) GetAverageDuration() *durationpb.Duration { + if x != nil { + return x.AverageDuration + } + return nil +} + +func (x *TaskGroup) GetLatestFinishedTime() *timestamppb.Timestamp { + if x != nil { + return x.LatestFinishedTime + } + return nil +} + +func (x *TaskGroup) GetCreatedBy() []*common.EnrichedIdentity { + if x != nil { + return x.CreatedBy + } + return nil +} + +func (x *TaskGroup) GetShouldDelete() bool { + if x != nil { + return x.ShouldDelete + } + return false +} + +func (x *TaskGroup) GetShortName() string { + if x != nil { + return x.ShortName + } + return "" +} + +func (x *TaskGroup) GetErrorCounts() *TaskGroup_ErrorCounts { + if x != nil { + return x.ErrorCounts + } + return nil +} + +func (x *TaskGroup) GetPhaseCounts() []*TaskGroup_PhaseCounts { + if x != nil { + return x.PhaseCounts + } + return nil +} + +type TaskGroup_RecentStatus struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RunName string `protobuf:"bytes,1,opt,name=run_name,json=runName,proto3" json:"run_name,omitempty"` + Phase common.ActionPhase `protobuf:"varint,2,opt,name=phase,proto3,enum=flyteidl2.common.ActionPhase" json:"phase,omitempty"` +} + +func (x *TaskGroup_RecentStatus) Reset() { + *x = TaskGroup_RecentStatus{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskGroup_RecentStatus) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskGroup_RecentStatus) ProtoMessage() {} + +func (x *TaskGroup_RecentStatus) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[22] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskGroup_RecentStatus.ProtoReflect.Descriptor instead. +func (*TaskGroup_RecentStatus) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{20, 0} +} + +func (x *TaskGroup_RecentStatus) GetRunName() string { + if x != nil { + return x.RunName + } + return "" +} + +func (x *TaskGroup_RecentStatus) GetPhase() common.ActionPhase { + if x != nil { + return x.Phase + } + return common.ActionPhase(0) +} + +type TaskGroup_ErrorCounts struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserError int64 `protobuf:"varint,1,opt,name=user_error,json=userError,proto3" json:"user_error,omitempty"` + SystemError int64 `protobuf:"varint,2,opt,name=system_error,json=systemError,proto3" json:"system_error,omitempty"` + UnspecifiedError int64 `protobuf:"varint,3,opt,name=unspecified_error,json=unspecifiedError,proto3" json:"unspecified_error,omitempty"` +} + +func (x *TaskGroup_ErrorCounts) Reset() { + *x = TaskGroup_ErrorCounts{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskGroup_ErrorCounts) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskGroup_ErrorCounts) ProtoMessage() {} + +func (x *TaskGroup_ErrorCounts) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[23] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskGroup_ErrorCounts.ProtoReflect.Descriptor instead. +func (*TaskGroup_ErrorCounts) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{20, 1} +} + +func (x *TaskGroup_ErrorCounts) GetUserError() int64 { + if x != nil { + return x.UserError + } + return 0 +} + +func (x *TaskGroup_ErrorCounts) GetSystemError() int64 { + if x != nil { + return x.SystemError + } + return 0 +} + +func (x *TaskGroup_ErrorCounts) GetUnspecifiedError() int64 { + if x != nil { + return x.UnspecifiedError + } + return 0 +} + +type TaskGroup_PhaseCounts struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Phase common.ActionPhase `protobuf:"varint,1,opt,name=phase,proto3,enum=flyteidl2.common.ActionPhase" json:"phase,omitempty"` + Count int64 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"` +} + +func (x *TaskGroup_PhaseCounts) Reset() { + *x = TaskGroup_PhaseCounts{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskGroup_PhaseCounts) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskGroup_PhaseCounts) ProtoMessage() {} + +func (x *TaskGroup_PhaseCounts) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_definition_proto_msgTypes[24] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskGroup_PhaseCounts.ProtoReflect.Descriptor instead. +func (*TaskGroup_PhaseCounts) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_definition_proto_rawDescGZIP(), []int{20, 2} +} + +func (x *TaskGroup_PhaseCounts) GetPhase() common.ActionPhase { + if x != nil { + return x.Phase + } + return common.ActionPhase(0) +} + +func (x *TaskGroup_PhaseCounts) GetCount() int64 { + if x != nil { + return x.Count + } + return 0 +} + +var File_flyteidl2_workflow_run_definition_proto protoreflect.FileDescriptor + +var file_flyteidl2_workflow_run_definition_proto_rawDesc = []byte{ + 0x0a, 0x27, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x72, 0x75, 0x6e, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x1a, 0x1b, 0x62, + 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, + 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2f, 0x70, 0x68, 0x61, 0x73, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x63, 0x61, 0x74, + 0x61, 0x6c, 0x6f, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x1a, 0x18, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, + 0x61, 0x73, 0x6b, 0x2f, 0x72, 0x75, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x74, 0x61, + 0x73, 0x6b, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x39, 0x0a, 0x03, 0x52, 0x75, 0x6e, 0x12, 0x32, 0x0a, 0x06, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, + 0x7b, 0x0a, 0x0a, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x32, 0x0a, + 0x08, 0x72, 0x75, 0x6e, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, + 0x2e, 0x52, 0x75, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x52, 0x07, 0x72, 0x75, 0x6e, 0x53, 0x70, 0x65, + 0x63, 0x12, 0x39, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xc7, 0x01, 0x0a, + 0x0a, 0x54, 0x61, 0x73, 0x6b, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2e, 0x0a, 0x02, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x02, 0x69, 0x64, 0x12, 0x34, 0x0a, 0x04, 0x73, + 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x53, + 0x70, 0x65, 0x63, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x04, 0x73, 0x70, 0x65, + 0x63, 0x12, 0x39, 0x0a, 0x09, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x52, 0x08, 0x63, 0x61, 0x63, 0x68, 0x65, 0x4b, 0x65, 0x79, 0x12, 0x18, 0x0a, 0x07, + 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x22, 0xd6, 0x02, 0x0a, 0x0b, 0x54, 0x72, 0x61, 0x63, 0x65, + 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x12, 0x33, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x68, 0x61, 0x73, + 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, + 0x69, 0x6d, 0x65, 0x12, 0x3a, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x48, 0x00, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, + 0x3a, 0x0a, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, + 0x6b, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, + 0x65, 0x73, 0x52, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x12, 0x35, 0x0a, 0x04, 0x73, + 0x70, 0x65, 0x63, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x72, 0x61, 0x63, 0x65, + 0x53, 0x70, 0x65, 0x63, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x04, 0x73, 0x70, + 0x65, 0x63, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x22, + 0x8d, 0x02, 0x0a, 0x0f, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x12, 0x20, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, 0x05, 0x72, 0x75, 0x6e, + 0x49, 0x64, 0x12, 0x26, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, + 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x18, 0x0a, 0x06, 0x67, 0x6c, + 0x6f, 0x62, 0x61, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x06, 0x67, 0x6c, + 0x6f, 0x62, 0x61, 0x6c, 0x12, 0x2f, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x52, + 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x18, + 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x12, 0x20, 0x0a, + 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x08, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, + 0x0e, 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, + 0x80, 0x01, 0x0a, 0x12, 0x54, 0x61, 0x73, 0x6b, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x2e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, + 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x74, 0x61, 0x73, 0x6b, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x4e, 0x61, + 0x6d, 0x65, 0x22, 0x29, 0x0a, 0x13, 0x54, 0x72, 0x61, 0x63, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0xa1, 0x01, + 0x0a, 0x17, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x20, 0x0a, + 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, + 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x12, + 0x26, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, 0x08, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x18, 0x0a, 0x06, 0x67, 0x6c, 0x6f, 0x62, 0x61, + 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x06, 0x67, 0x6c, 0x6f, 0x62, 0x61, + 0x6c, 0x42, 0x0e, 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, + 0x01, 0x22, 0xce, 0x05, 0x0a, 0x0e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x12, 0x43, 0x0a, 0x0b, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x5f, 0x62, + 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x45, 0x6e, 0x72, 0x69, 0x63, + 0x68, 0x65, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x0a, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x65, 0x64, 0x42, 0x79, 0x12, 0x3c, 0x0a, 0x04, 0x74, 0x61, 0x73, 0x6b, 0x18, + 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x41, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, + 0x04, 0x74, 0x61, 0x73, 0x6b, 0x12, 0x3f, 0x0a, 0x05, 0x74, 0x72, 0x61, 0x63, 0x65, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x72, 0x61, 0x63, 0x65, 0x41, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, + 0x05, 0x74, 0x72, 0x61, 0x63, 0x65, 0x12, 0x4b, 0x0a, 0x09, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x43, + 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, 0x09, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x3f, 0x0a, 0x0b, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x79, + 0x70, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x54, 0x79, 0x70, 0x65, 0x12, 0x42, 0x0a, 0x0a, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x5f, + 0x69, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x09, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x49, 0x64, 0x12, 0x29, 0x0a, 0x10, 0x65, 0x6e, 0x76, 0x69, + 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0c, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0f, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x4e, + 0x61, 0x6d, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x66, 0x75, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x66, 0x75, 0x6e, 0x74, 0x69, + 0x6f, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x48, 0x0a, 0x0c, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, + 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x41, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0b, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x35, 0x0a, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x10, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x53, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x52, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x42, 0x06, 0x0a, 0x04, 0x73, 0x70, + 0x65, 0x63, 0x22, 0xe9, 0x02, 0x0a, 0x0c, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x12, 0x33, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x68, 0x61, 0x73, + 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, + 0x69, 0x6d, 0x65, 0x12, 0x3a, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x48, 0x00, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, + 0x23, 0x0a, 0x08, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, 0x02, 0x20, 0x00, 0x52, 0x08, 0x61, 0x74, 0x74, 0x65, + 0x6d, 0x70, 0x74, 0x73, 0x12, 0x45, 0x0a, 0x0c, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x73, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x61, 0x74, 0x61, + 0x6c, 0x6f, 0x67, 0x43, 0x61, 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x0b, + 0x63, 0x61, 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x24, 0x0a, 0x0b, 0x64, + 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, + 0x48, 0x01, 0x52, 0x0a, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x73, 0x88, 0x01, + 0x01, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x42, 0x0e, + 0x0a, 0x0c, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x73, 0x22, 0xb6, + 0x01, 0x0a, 0x06, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x32, 0x0a, 0x02, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3e, 0x0a, + 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x38, 0x0a, + 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, + 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0xa0, 0x02, 0x0a, 0x0e, 0x45, 0x6e, 0x72, 0x69, + 0x63, 0x68, 0x65, 0x64, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x32, 0x0a, 0x06, 0x61, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, + 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x21, + 0x0a, 0x0c, 0x6d, 0x65, 0x65, 0x74, 0x73, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x6d, 0x65, 0x65, 0x74, 0x73, 0x46, 0x69, 0x6c, 0x74, 0x65, + 0x72, 0x12, 0x6f, 0x0a, 0x15, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x5f, 0x70, 0x68, + 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x3b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x50, 0x68, 0x61, + 0x73, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13, 0x63, + 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x50, 0x68, 0x61, 0x73, 0x65, 0x43, 0x6f, 0x75, 0x6e, + 0x74, 0x73, 0x1a, 0x46, 0x0a, 0x18, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x50, 0x68, + 0x61, 0x73, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, + 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, + 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x9b, 0x01, 0x0a, 0x09, 0x45, + 0x72, 0x72, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x12, 0x36, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x2e, + 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x22, 0x3c, 0x0a, 0x04, 0x4b, 0x69, + 0x6e, 0x64, 0x12, 0x14, 0x0a, 0x10, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, + 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x4b, 0x49, 0x4e, 0x44, + 0x5f, 0x55, 0x53, 0x45, 0x52, 0x10, 0x01, 0x12, 0x0f, 0x0a, 0x0b, 0x4b, 0x49, 0x4e, 0x44, 0x5f, + 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x10, 0x02, 0x22, 0x66, 0x0a, 0x09, 0x41, 0x62, 0x6f, 0x72, + 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x41, 0x0a, + 0x0a, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x09, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x42, 0x79, + 0x22, 0xf1, 0x03, 0x0a, 0x0d, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x12, 0x32, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3e, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x38, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x12, 0x3e, 0x0a, 0x0a, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x49, + 0x6e, 0x66, 0x6f, 0x48, 0x00, 0x52, 0x09, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, + 0x12, 0x3e, 0x0a, 0x0a, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x49, + 0x6e, 0x66, 0x6f, 0x48, 0x00, 0x52, 0x09, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x49, 0x6e, 0x66, 0x6f, + 0x12, 0x2e, 0x0a, 0x04, 0x74, 0x61, 0x73, 0x6b, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x54, 0x61, 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x48, 0x01, 0x52, 0x04, 0x74, 0x61, 0x73, 0x6b, + 0x12, 0x31, 0x0a, 0x05, 0x74, 0x72, 0x61, 0x63, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, + 0x2e, 0x54, 0x72, 0x61, 0x63, 0x65, 0x53, 0x70, 0x65, 0x63, 0x48, 0x01, 0x52, 0x05, 0x74, 0x72, + 0x61, 0x63, 0x65, 0x12, 0x3d, 0x0a, 0x08, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x18, + 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x52, 0x08, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, + 0x74, 0x73, 0x42, 0x08, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x42, 0x06, 0x0a, 0x04, + 0x73, 0x70, 0x65, 0x63, 0x22, 0x8d, 0x06, 0x0a, 0x0d, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x41, + 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x12, 0x33, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, + 0x68, 0x61, 0x73, 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x0a, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x3a, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, + 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x48, 0x00, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x88, + 0x01, 0x01, 0x12, 0x41, 0x0a, 0x0a, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x69, 0x6e, 0x66, 0x6f, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x45, 0x72, 0x72, 0x6f, + 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x48, 0x01, 0x52, 0x09, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x49, 0x6e, + 0x66, 0x6f, 0x88, 0x01, 0x01, 0x12, 0x21, 0x0a, 0x07, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, 0x02, 0x20, 0x00, 0x52, + 0x07, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x12, 0x32, 0x0a, 0x08, 0x6c, 0x6f, 0x67, 0x5f, + 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, + 0x4c, 0x6f, 0x67, 0x52, 0x07, 0x6c, 0x6f, 0x67, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3a, 0x0a, 0x07, + 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x52, + 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x6c, 0x6f, 0x67, 0x73, + 0x5f, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x0d, 0x6c, 0x6f, 0x67, 0x73, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x12, + 0x45, 0x0a, 0x0c, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, + 0x09, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x43, 0x61, + 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x0b, 0x63, 0x61, 0x63, 0x68, 0x65, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x47, 0x0a, 0x0e, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, + 0x52, 0x0d, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, + 0x50, 0x0a, 0x11, 0x70, 0x68, 0x61, 0x73, 0x65, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, + 0x50, 0x68, 0x61, 0x73, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x10, 0x70, 0x68, 0x61, 0x73, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x18, 0x0c, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, 0x3b, 0x0a, 0x0b, 0x6c, + 0x6f, 0x67, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x4c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, 0x0a, 0x6c, 0x6f, + 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x65, 0x6e, 0x64, + 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, + 0x69, 0x6e, 0x66, 0x6f, 0x22, 0x65, 0x0a, 0x0c, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, + 0x76, 0x65, 0x6e, 0x74, 0x12, 0x3b, 0x0a, 0x0b, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, + 0x5f, 0x61, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0a, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x41, + 0x74, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0xca, 0x01, 0x0a, 0x0f, + 0x50, 0x68, 0x61, 0x73, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x33, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x68, 0x61, 0x73, 0x65, 0x52, 0x05, 0x70, + 0x68, 0x61, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, + 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, + 0x3a, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x48, 0x00, 0x52, + 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x42, 0x0b, 0x0a, 0x09, 0x5f, + 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x22, 0xf0, 0x06, 0x0a, 0x0b, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x3a, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, + 0x52, 0x02, 0x69, 0x64, 0x12, 0x21, 0x0a, 0x07, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, 0x02, 0x20, 0x00, 0x52, 0x07, + 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x12, 0x33, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x50, 0x68, 0x61, 0x73, 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x76, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x3d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, + 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x02, 0x18, 0x01, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x3d, 0x0a, 0x0c, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, + 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0b, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, + 0x54, 0x69, 0x6d, 0x65, 0x12, 0x3e, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x42, 0x02, 0x18, 0x01, 0x48, 0x00, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, + 0x65, 0x88, 0x01, 0x01, 0x12, 0x41, 0x0a, 0x0a, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x69, 0x6e, + 0x66, 0x6f, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x45, 0x72, + 0x72, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x48, 0x01, 0x52, 0x09, 0x65, 0x72, 0x72, 0x6f, 0x72, + 0x49, 0x6e, 0x66, 0x6f, 0x88, 0x01, 0x01, 0x12, 0x32, 0x0a, 0x08, 0x6c, 0x6f, 0x67, 0x5f, 0x69, + 0x6e, 0x66, 0x6f, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x4c, + 0x6f, 0x67, 0x52, 0x07, 0x6c, 0x6f, 0x67, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3b, 0x0a, 0x0b, 0x6c, + 0x6f, 0x67, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x4c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, 0x0a, 0x6c, 0x6f, + 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x12, 0x3a, 0x0a, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x18, 0x0c, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x52, 0x65, 0x66, 0x65, 0x72, + 0x65, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x12, 0x45, + 0x0a, 0x0c, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x0d, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x43, 0x61, 0x63, + 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x0b, 0x63, 0x61, 0x63, 0x68, 0x65, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x47, 0x0a, 0x0e, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, + 0x0d, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x3f, + 0x0a, 0x0d, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, + 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x52, 0x0c, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x42, + 0x0b, 0x0a, 0x09, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x42, 0x0d, 0x0a, 0x0b, + 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x22, 0x83, 0x04, 0x0a, 0x0a, + 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x64, 0x12, 0x31, 0x0a, 0x12, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, + 0x01, 0x52, 0x10, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4e, + 0x61, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, 0x32, 0x0a, 0x08, 0x72, 0x75, 0x6e, 0x5f, 0x73, 0x70, + 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x52, 0x75, 0x6e, 0x53, 0x70, 0x65, + 0x63, 0x52, 0x07, 0x72, 0x75, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x12, 0x24, 0x0a, 0x09, 0x69, 0x6e, + 0x70, 0x75, 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, + 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x08, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x55, 0x72, 0x69, + 0x12, 0x2f, 0x0a, 0x0f, 0x72, 0x75, 0x6e, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x62, + 0x61, 0x73, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, + 0x10, 0x01, 0x52, 0x0d, 0x72, 0x75, 0x6e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x42, 0x61, 0x73, + 0x65, 0x12, 0x34, 0x0a, 0x04, 0x74, 0x61, 0x73, 0x6b, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, + 0x00, 0x52, 0x04, 0x74, 0x61, 0x73, 0x6b, 0x12, 0x43, 0x0a, 0x09, 0x63, 0x6f, 0x6e, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, + 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, + 0x00, 0x52, 0x09, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x37, 0x0a, 0x05, + 0x74, 0x72, 0x61, 0x63, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x2e, 0x54, 0x72, 0x61, 0x63, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x05, + 0x74, 0x72, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x0d, 0x0a, 0x04, 0x73, + 0x70, 0x65, 0x63, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x42, 0x15, 0x0a, 0x13, 0x5f, 0x70, + 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, + 0x65, 0x22, 0xac, 0x08, 0x0a, 0x09, 0x54, 0x61, 0x73, 0x6b, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, + 0x1b, 0x0a, 0x09, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x08, 0x74, 0x61, 0x73, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x29, 0x0a, 0x10, + 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, + 0x65, 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x6f, 0x74, 0x61, 0x6c, + 0x5f, 0x72, 0x75, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x6f, 0x74, + 0x61, 0x6c, 0x52, 0x75, 0x6e, 0x73, 0x12, 0x42, 0x0a, 0x0f, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, + 0x5f, 0x72, 0x75, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0d, 0x6c, 0x61, 0x74, + 0x65, 0x73, 0x74, 0x52, 0x75, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x53, 0x0a, 0x0f, 0x72, 0x65, + 0x63, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x65, 0x73, 0x18, 0x05, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x2e, 0x52, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, + 0x0e, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x65, 0x73, 0x12, + 0x30, 0x0a, 0x14, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x75, + 0x72, 0x65, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x12, 0x61, + 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x52, 0x61, 0x74, + 0x65, 0x12, 0x44, 0x0a, 0x10, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x64, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0f, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x44, + 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x4c, 0x0a, 0x14, 0x6c, 0x61, 0x74, 0x65, 0x73, + 0x74, 0x5f, 0x66, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, + 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x52, 0x12, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, + 0x64, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x41, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, + 0x5f, 0x62, 0x79, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x45, 0x6e, 0x72, + 0x69, 0x63, 0x68, 0x65, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x09, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x0c, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x1d, 0x0a, + 0x0a, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x09, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x4c, 0x0a, 0x0c, + 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, 0x0c, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x52, 0x0b, 0x65, + 0x72, 0x72, 0x6f, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x12, 0x4c, 0x0a, 0x0c, 0x70, 0x68, + 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x2e, + 0x50, 0x68, 0x61, 0x73, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x52, 0x0b, 0x70, 0x68, 0x61, + 0x73, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x1a, 0x5e, 0x0a, 0x0c, 0x52, 0x65, 0x63, 0x65, + 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x75, 0x6e, 0x5f, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x72, 0x75, 0x6e, 0x4e, + 0x61, 0x6d, 0x65, 0x12, 0x33, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x68, 0x61, 0x73, + 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x1a, 0x7c, 0x0a, 0x0b, 0x45, 0x72, 0x72, 0x6f, + 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x75, 0x73, 0x65, 0x72, 0x5f, + 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x75, 0x73, 0x65, + 0x72, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, + 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x73, 0x79, + 0x73, 0x74, 0x65, 0x6d, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x2b, 0x0a, 0x11, 0x75, 0x6e, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x75, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x64, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x1a, 0x58, 0x0a, 0x0b, 0x50, 0x68, 0x61, 0x73, 0x65, 0x43, + 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x12, 0x33, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x68, + 0x61, 0x73, 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, + 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x2a, 0x71, 0x0a, 0x0a, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1b, + 0x0a, 0x17, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, + 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, 0x41, + 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x54, 0x41, 0x53, 0x4b, 0x10, + 0x01, 0x12, 0x15, 0x0a, 0x11, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x54, 0x59, 0x50, 0x45, + 0x5f, 0x54, 0x52, 0x41, 0x43, 0x45, 0x10, 0x02, 0x12, 0x19, 0x0a, 0x15, 0x41, 0x43, 0x54, 0x49, + 0x4f, 0x4e, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, 0x4f, 0x4e, 0x44, 0x49, 0x54, 0x49, 0x4f, + 0x4e, 0x10, 0x03, 0x2a, 0x70, 0x0a, 0x09, 0x52, 0x75, 0x6e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x12, 0x1a, 0x0a, 0x16, 0x52, 0x55, 0x4e, 0x5f, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x55, + 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, + 0x52, 0x55, 0x4e, 0x5f, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x57, 0x45, 0x42, 0x10, 0x01, + 0x12, 0x12, 0x0a, 0x0e, 0x52, 0x55, 0x4e, 0x5f, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x43, + 0x4c, 0x49, 0x10, 0x02, 0x12, 0x1f, 0x0a, 0x1b, 0x52, 0x55, 0x4e, 0x5f, 0x53, 0x4f, 0x55, 0x52, + 0x43, 0x45, 0x5f, 0x53, 0x43, 0x48, 0x45, 0x44, 0x55, 0x4c, 0x45, 0x5f, 0x54, 0x52, 0x49, 0x47, + 0x47, 0x45, 0x52, 0x10, 0x03, 0x42, 0xcf, 0x01, 0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x42, 0x12, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x36, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, + 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0xa2, 0x02, 0x03, 0x46, 0x57, 0x58, 0xaa, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xca, 0x02, 0x12, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0xe2, 0x02, 0x1e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x57, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0xea, 0x02, 0x13, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x57, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_workflow_run_definition_proto_rawDescOnce sync.Once + file_flyteidl2_workflow_run_definition_proto_rawDescData = file_flyteidl2_workflow_run_definition_proto_rawDesc +) + +func file_flyteidl2_workflow_run_definition_proto_rawDescGZIP() []byte { + file_flyteidl2_workflow_run_definition_proto_rawDescOnce.Do(func() { + file_flyteidl2_workflow_run_definition_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_workflow_run_definition_proto_rawDescData) + }) + return file_flyteidl2_workflow_run_definition_proto_rawDescData +} + +var file_flyteidl2_workflow_run_definition_proto_enumTypes = make([]protoimpl.EnumInfo, 3) +var file_flyteidl2_workflow_run_definition_proto_msgTypes = make([]protoimpl.MessageInfo, 25) +var file_flyteidl2_workflow_run_definition_proto_goTypes = []interface{}{ + (ActionType)(0), // 0: flyteidl2.workflow.ActionType + (RunSource)(0), // 1: flyteidl2.workflow.RunSource + (ErrorInfo_Kind)(0), // 2: flyteidl2.workflow.ErrorInfo.Kind + (*Run)(nil), // 3: flyteidl2.workflow.Run + (*RunDetails)(nil), // 4: flyteidl2.workflow.RunDetails + (*TaskAction)(nil), // 5: flyteidl2.workflow.TaskAction + (*TraceAction)(nil), // 6: flyteidl2.workflow.TraceAction + (*ConditionAction)(nil), // 7: flyteidl2.workflow.ConditionAction + (*TaskActionMetadata)(nil), // 8: flyteidl2.workflow.TaskActionMetadata + (*TraceActionMetadata)(nil), // 9: flyteidl2.workflow.TraceActionMetadata + (*ConditionActionMetadata)(nil), // 10: flyteidl2.workflow.ConditionActionMetadata + (*ActionMetadata)(nil), // 11: flyteidl2.workflow.ActionMetadata + (*ActionStatus)(nil), // 12: flyteidl2.workflow.ActionStatus + (*Action)(nil), // 13: flyteidl2.workflow.Action + (*EnrichedAction)(nil), // 14: flyteidl2.workflow.EnrichedAction + (*ErrorInfo)(nil), // 15: flyteidl2.workflow.ErrorInfo + (*AbortInfo)(nil), // 16: flyteidl2.workflow.AbortInfo + (*ActionDetails)(nil), // 17: flyteidl2.workflow.ActionDetails + (*ActionAttempt)(nil), // 18: flyteidl2.workflow.ActionAttempt + (*ClusterEvent)(nil), // 19: flyteidl2.workflow.ClusterEvent + (*PhaseTransition)(nil), // 20: flyteidl2.workflow.PhaseTransition + (*ActionEvent)(nil), // 21: flyteidl2.workflow.ActionEvent + (*ActionSpec)(nil), // 22: flyteidl2.workflow.ActionSpec + (*TaskGroup)(nil), // 23: flyteidl2.workflow.TaskGroup + nil, // 24: flyteidl2.workflow.EnrichedAction.ChildrenPhaseCountsEntry + (*TaskGroup_RecentStatus)(nil), // 25: flyteidl2.workflow.TaskGroup.RecentStatus + (*TaskGroup_ErrorCounts)(nil), // 26: flyteidl2.workflow.TaskGroup.ErrorCounts + (*TaskGroup_PhaseCounts)(nil), // 27: flyteidl2.workflow.TaskGroup.PhaseCounts + (*task.RunSpec)(nil), // 28: flyteidl2.task.RunSpec + (*task.TaskIdentifier)(nil), // 29: flyteidl2.task.TaskIdentifier + (*task.TaskSpec)(nil), // 30: flyteidl2.task.TaskSpec + (*wrapperspb.StringValue)(nil), // 31: google.protobuf.StringValue + (common.ActionPhase)(0), // 32: flyteidl2.common.ActionPhase + (*timestamppb.Timestamp)(nil), // 33: google.protobuf.Timestamp + (*task.OutputReferences)(nil), // 34: flyteidl2.task.OutputReferences + (*task.TraceSpec)(nil), // 35: flyteidl2.task.TraceSpec + (*core.LiteralType)(nil), // 36: flyteidl2.core.LiteralType + (*common.EnrichedIdentity)(nil), // 37: flyteidl2.common.EnrichedIdentity + (*common.TriggerIdentifier)(nil), // 38: flyteidl2.common.TriggerIdentifier + (*task.TriggerAutomationSpec)(nil), // 39: flyteidl2.task.TriggerAutomationSpec + (core.CatalogCacheStatus)(0), // 40: flyteidl2.core.CatalogCacheStatus + (*common.ActionIdentifier)(nil), // 41: flyteidl2.common.ActionIdentifier + (*core.TaskLog)(nil), // 42: flyteidl2.core.TaskLog + (*core.LogContext)(nil), // 43: flyteidl2.core.LogContext + (*durationpb.Duration)(nil), // 44: google.protobuf.Duration +} +var file_flyteidl2_workflow_run_definition_proto_depIdxs = []int32{ + 13, // 0: flyteidl2.workflow.Run.action:type_name -> flyteidl2.workflow.Action + 28, // 1: flyteidl2.workflow.RunDetails.run_spec:type_name -> flyteidl2.task.RunSpec + 17, // 2: flyteidl2.workflow.RunDetails.action:type_name -> flyteidl2.workflow.ActionDetails + 29, // 3: flyteidl2.workflow.TaskAction.id:type_name -> flyteidl2.task.TaskIdentifier + 30, // 4: flyteidl2.workflow.TaskAction.spec:type_name -> flyteidl2.task.TaskSpec + 31, // 5: flyteidl2.workflow.TaskAction.cache_key:type_name -> google.protobuf.StringValue + 32, // 6: flyteidl2.workflow.TraceAction.phase:type_name -> flyteidl2.common.ActionPhase + 33, // 7: flyteidl2.workflow.TraceAction.start_time:type_name -> google.protobuf.Timestamp + 33, // 8: flyteidl2.workflow.TraceAction.end_time:type_name -> google.protobuf.Timestamp + 34, // 9: flyteidl2.workflow.TraceAction.outputs:type_name -> flyteidl2.task.OutputReferences + 35, // 10: flyteidl2.workflow.TraceAction.spec:type_name -> flyteidl2.task.TraceSpec + 36, // 11: flyteidl2.workflow.ConditionAction.type:type_name -> flyteidl2.core.LiteralType + 29, // 12: flyteidl2.workflow.TaskActionMetadata.id:type_name -> flyteidl2.task.TaskIdentifier + 37, // 13: flyteidl2.workflow.ActionMetadata.executed_by:type_name -> flyteidl2.common.EnrichedIdentity + 8, // 14: flyteidl2.workflow.ActionMetadata.task:type_name -> flyteidl2.workflow.TaskActionMetadata + 9, // 15: flyteidl2.workflow.ActionMetadata.trace:type_name -> flyteidl2.workflow.TraceActionMetadata + 10, // 16: flyteidl2.workflow.ActionMetadata.condition:type_name -> flyteidl2.workflow.ConditionActionMetadata + 0, // 17: flyteidl2.workflow.ActionMetadata.action_type:type_name -> flyteidl2.workflow.ActionType + 38, // 18: flyteidl2.workflow.ActionMetadata.trigger_id:type_name -> flyteidl2.common.TriggerIdentifier + 39, // 19: flyteidl2.workflow.ActionMetadata.trigger_type:type_name -> flyteidl2.task.TriggerAutomationSpec + 1, // 20: flyteidl2.workflow.ActionMetadata.source:type_name -> flyteidl2.workflow.RunSource + 32, // 21: flyteidl2.workflow.ActionStatus.phase:type_name -> flyteidl2.common.ActionPhase + 33, // 22: flyteidl2.workflow.ActionStatus.start_time:type_name -> google.protobuf.Timestamp + 33, // 23: flyteidl2.workflow.ActionStatus.end_time:type_name -> google.protobuf.Timestamp + 40, // 24: flyteidl2.workflow.ActionStatus.cache_status:type_name -> flyteidl2.core.CatalogCacheStatus + 41, // 25: flyteidl2.workflow.Action.id:type_name -> flyteidl2.common.ActionIdentifier + 11, // 26: flyteidl2.workflow.Action.metadata:type_name -> flyteidl2.workflow.ActionMetadata + 12, // 27: flyteidl2.workflow.Action.status:type_name -> flyteidl2.workflow.ActionStatus + 13, // 28: flyteidl2.workflow.EnrichedAction.action:type_name -> flyteidl2.workflow.Action + 24, // 29: flyteidl2.workflow.EnrichedAction.children_phase_counts:type_name -> flyteidl2.workflow.EnrichedAction.ChildrenPhaseCountsEntry + 2, // 30: flyteidl2.workflow.ErrorInfo.kind:type_name -> flyteidl2.workflow.ErrorInfo.Kind + 37, // 31: flyteidl2.workflow.AbortInfo.aborted_by:type_name -> flyteidl2.common.EnrichedIdentity + 41, // 32: flyteidl2.workflow.ActionDetails.id:type_name -> flyteidl2.common.ActionIdentifier + 11, // 33: flyteidl2.workflow.ActionDetails.metadata:type_name -> flyteidl2.workflow.ActionMetadata + 12, // 34: flyteidl2.workflow.ActionDetails.status:type_name -> flyteidl2.workflow.ActionStatus + 15, // 35: flyteidl2.workflow.ActionDetails.error_info:type_name -> flyteidl2.workflow.ErrorInfo + 16, // 36: flyteidl2.workflow.ActionDetails.abort_info:type_name -> flyteidl2.workflow.AbortInfo + 30, // 37: flyteidl2.workflow.ActionDetails.task:type_name -> flyteidl2.task.TaskSpec + 35, // 38: flyteidl2.workflow.ActionDetails.trace:type_name -> flyteidl2.task.TraceSpec + 18, // 39: flyteidl2.workflow.ActionDetails.attempts:type_name -> flyteidl2.workflow.ActionAttempt + 32, // 40: flyteidl2.workflow.ActionAttempt.phase:type_name -> flyteidl2.common.ActionPhase + 33, // 41: flyteidl2.workflow.ActionAttempt.start_time:type_name -> google.protobuf.Timestamp + 33, // 42: flyteidl2.workflow.ActionAttempt.end_time:type_name -> google.protobuf.Timestamp + 15, // 43: flyteidl2.workflow.ActionAttempt.error_info:type_name -> flyteidl2.workflow.ErrorInfo + 42, // 44: flyteidl2.workflow.ActionAttempt.log_info:type_name -> flyteidl2.core.TaskLog + 34, // 45: flyteidl2.workflow.ActionAttempt.outputs:type_name -> flyteidl2.task.OutputReferences + 40, // 46: flyteidl2.workflow.ActionAttempt.cache_status:type_name -> flyteidl2.core.CatalogCacheStatus + 19, // 47: flyteidl2.workflow.ActionAttempt.cluster_events:type_name -> flyteidl2.workflow.ClusterEvent + 20, // 48: flyteidl2.workflow.ActionAttempt.phase_transitions:type_name -> flyteidl2.workflow.PhaseTransition + 43, // 49: flyteidl2.workflow.ActionAttempt.log_context:type_name -> flyteidl2.core.LogContext + 33, // 50: flyteidl2.workflow.ClusterEvent.occurred_at:type_name -> google.protobuf.Timestamp + 32, // 51: flyteidl2.workflow.PhaseTransition.phase:type_name -> flyteidl2.common.ActionPhase + 33, // 52: flyteidl2.workflow.PhaseTransition.start_time:type_name -> google.protobuf.Timestamp + 33, // 53: flyteidl2.workflow.PhaseTransition.end_time:type_name -> google.protobuf.Timestamp + 41, // 54: flyteidl2.workflow.ActionEvent.id:type_name -> flyteidl2.common.ActionIdentifier + 32, // 55: flyteidl2.workflow.ActionEvent.phase:type_name -> flyteidl2.common.ActionPhase + 33, // 56: flyteidl2.workflow.ActionEvent.start_time:type_name -> google.protobuf.Timestamp + 33, // 57: flyteidl2.workflow.ActionEvent.updated_time:type_name -> google.protobuf.Timestamp + 33, // 58: flyteidl2.workflow.ActionEvent.end_time:type_name -> google.protobuf.Timestamp + 15, // 59: flyteidl2.workflow.ActionEvent.error_info:type_name -> flyteidl2.workflow.ErrorInfo + 42, // 60: flyteidl2.workflow.ActionEvent.log_info:type_name -> flyteidl2.core.TaskLog + 43, // 61: flyteidl2.workflow.ActionEvent.log_context:type_name -> flyteidl2.core.LogContext + 34, // 62: flyteidl2.workflow.ActionEvent.outputs:type_name -> flyteidl2.task.OutputReferences + 40, // 63: flyteidl2.workflow.ActionEvent.cache_status:type_name -> flyteidl2.core.CatalogCacheStatus + 19, // 64: flyteidl2.workflow.ActionEvent.cluster_events:type_name -> flyteidl2.workflow.ClusterEvent + 33, // 65: flyteidl2.workflow.ActionEvent.reported_time:type_name -> google.protobuf.Timestamp + 41, // 66: flyteidl2.workflow.ActionSpec.action_id:type_name -> flyteidl2.common.ActionIdentifier + 28, // 67: flyteidl2.workflow.ActionSpec.run_spec:type_name -> flyteidl2.task.RunSpec + 5, // 68: flyteidl2.workflow.ActionSpec.task:type_name -> flyteidl2.workflow.TaskAction + 7, // 69: flyteidl2.workflow.ActionSpec.condition:type_name -> flyteidl2.workflow.ConditionAction + 6, // 70: flyteidl2.workflow.ActionSpec.trace:type_name -> flyteidl2.workflow.TraceAction + 33, // 71: flyteidl2.workflow.TaskGroup.latest_run_time:type_name -> google.protobuf.Timestamp + 25, // 72: flyteidl2.workflow.TaskGroup.recent_statuses:type_name -> flyteidl2.workflow.TaskGroup.RecentStatus + 44, // 73: flyteidl2.workflow.TaskGroup.average_duration:type_name -> google.protobuf.Duration + 33, // 74: flyteidl2.workflow.TaskGroup.latest_finished_time:type_name -> google.protobuf.Timestamp + 37, // 75: flyteidl2.workflow.TaskGroup.created_by:type_name -> flyteidl2.common.EnrichedIdentity + 26, // 76: flyteidl2.workflow.TaskGroup.error_counts:type_name -> flyteidl2.workflow.TaskGroup.ErrorCounts + 27, // 77: flyteidl2.workflow.TaskGroup.phase_counts:type_name -> flyteidl2.workflow.TaskGroup.PhaseCounts + 32, // 78: flyteidl2.workflow.TaskGroup.RecentStatus.phase:type_name -> flyteidl2.common.ActionPhase + 32, // 79: flyteidl2.workflow.TaskGroup.PhaseCounts.phase:type_name -> flyteidl2.common.ActionPhase + 80, // [80:80] is the sub-list for method output_type + 80, // [80:80] is the sub-list for method input_type + 80, // [80:80] is the sub-list for extension type_name + 80, // [80:80] is the sub-list for extension extendee + 0, // [0:80] is the sub-list for field type_name +} + +func init() { file_flyteidl2_workflow_run_definition_proto_init() } +func file_flyteidl2_workflow_run_definition_proto_init() { + if File_flyteidl2_workflow_run_definition_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_workflow_run_definition_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Run); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RunDetails); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskAction); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TraceAction); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ConditionAction); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskActionMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TraceActionMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ConditionActionMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ActionMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ActionStatus); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Action); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EnrichedAction); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ErrorInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AbortInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ActionDetails); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ActionAttempt); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ClusterEvent); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PhaseTransition); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ActionEvent); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ActionSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskGroup); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskGroup_RecentStatus); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskGroup_ErrorCounts); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskGroup_PhaseCounts); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[3].OneofWrappers = []interface{}{} + file_flyteidl2_workflow_run_definition_proto_msgTypes[4].OneofWrappers = []interface{}{ + (*ConditionAction_RunId)(nil), + (*ConditionAction_ActionId)(nil), + (*ConditionAction_Global)(nil), + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[7].OneofWrappers = []interface{}{ + (*ConditionActionMetadata_RunId)(nil), + (*ConditionActionMetadata_ActionId)(nil), + (*ConditionActionMetadata_Global)(nil), + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[8].OneofWrappers = []interface{}{ + (*ActionMetadata_Task)(nil), + (*ActionMetadata_Trace)(nil), + (*ActionMetadata_Condition)(nil), + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[9].OneofWrappers = []interface{}{} + file_flyteidl2_workflow_run_definition_proto_msgTypes[14].OneofWrappers = []interface{}{ + (*ActionDetails_ErrorInfo)(nil), + (*ActionDetails_AbortInfo)(nil), + (*ActionDetails_Task)(nil), + (*ActionDetails_Trace)(nil), + } + file_flyteidl2_workflow_run_definition_proto_msgTypes[15].OneofWrappers = []interface{}{} + file_flyteidl2_workflow_run_definition_proto_msgTypes[17].OneofWrappers = []interface{}{} + file_flyteidl2_workflow_run_definition_proto_msgTypes[18].OneofWrappers = []interface{}{} + file_flyteidl2_workflow_run_definition_proto_msgTypes[19].OneofWrappers = []interface{}{ + (*ActionSpec_Task)(nil), + (*ActionSpec_Condition)(nil), + (*ActionSpec_Trace)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_workflow_run_definition_proto_rawDesc, + NumEnums: 3, + NumMessages: 25, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_flyteidl2_workflow_run_definition_proto_goTypes, + DependencyIndexes: file_flyteidl2_workflow_run_definition_proto_depIdxs, + EnumInfos: file_flyteidl2_workflow_run_definition_proto_enumTypes, + MessageInfos: file_flyteidl2_workflow_run_definition_proto_msgTypes, + }.Build() + File_flyteidl2_workflow_run_definition_proto = out.File + file_flyteidl2_workflow_run_definition_proto_rawDesc = nil + file_flyteidl2_workflow_run_definition_proto_goTypes = nil + file_flyteidl2_workflow_run_definition_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/workflow/run_definition.pb.validate.go b/gen/go/flyteidl2/workflow/run_definition.pb.validate.go new file mode 100644 index 0000000000..0d114c8d85 --- /dev/null +++ b/gen/go/flyteidl2/workflow/run_definition.pb.validate.go @@ -0,0 +1,4764 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/workflow/run_definition.proto + +package workflow + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" + + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort + + _ = common.ActionPhase(0) + + _ = core.CatalogCacheStatus(0) +) + +// Validate checks the field values on Run with the rules defined in the proto +// definition for this message. If any rules are violated, the first error +// encountered is returned, or nil if there are no violations. +func (m *Run) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Run with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in RunMultiError, or nil if none found. +func (m *Run) ValidateAll() error { + return m.validate(true) +} + +func (m *Run) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetAction()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, RunValidationError{ + field: "Action", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, RunValidationError{ + field: "Action", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAction()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return RunValidationError{ + field: "Action", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return RunMultiError(errors) + } + + return nil +} + +// RunMultiError is an error wrapping multiple validation errors returned by +// Run.ValidateAll() if the designated constraints aren't met. +type RunMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m RunMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m RunMultiError) AllErrors() []error { return m } + +// RunValidationError is the validation error returned by Run.Validate if the +// designated constraints aren't met. +type RunValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e RunValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e RunValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e RunValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e RunValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e RunValidationError) ErrorName() string { return "RunValidationError" } + +// Error satisfies the builtin error interface +func (e RunValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sRun.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = RunValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = RunValidationError{} + +// Validate checks the field values on RunDetails with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *RunDetails) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on RunDetails with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in RunDetailsMultiError, or +// nil if none found. +func (m *RunDetails) ValidateAll() error { + return m.validate(true) +} + +func (m *RunDetails) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRunSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, RunDetailsValidationError{ + field: "RunSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, RunDetailsValidationError{ + field: "RunSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return RunDetailsValidationError{ + field: "RunSpec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetAction()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, RunDetailsValidationError{ + field: "Action", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, RunDetailsValidationError{ + field: "Action", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAction()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return RunDetailsValidationError{ + field: "Action", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return RunDetailsMultiError(errors) + } + + return nil +} + +// RunDetailsMultiError is an error wrapping multiple validation errors +// returned by RunDetails.ValidateAll() if the designated constraints aren't met. +type RunDetailsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m RunDetailsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m RunDetailsMultiError) AllErrors() []error { return m } + +// RunDetailsValidationError is the validation error returned by +// RunDetails.Validate if the designated constraints aren't met. +type RunDetailsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e RunDetailsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e RunDetailsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e RunDetailsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e RunDetailsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e RunDetailsValidationError) ErrorName() string { return "RunDetailsValidationError" } + +// Error satisfies the builtin error interface +func (e RunDetailsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sRunDetails.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = RunDetailsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = RunDetailsValidationError{} + +// Validate checks the field values on TaskAction with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TaskAction) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskAction with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TaskActionMultiError, or +// nil if none found. +func (m *TaskAction) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskAction) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskActionValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskActionValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskActionValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskActionValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskActionValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskActionValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetCacheKey()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskActionValidationError{ + field: "CacheKey", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskActionValidationError{ + field: "CacheKey", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCacheKey()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskActionValidationError{ + field: "CacheKey", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Cluster + + if len(errors) > 0 { + return TaskActionMultiError(errors) + } + + return nil +} + +// TaskActionMultiError is an error wrapping multiple validation errors +// returned by TaskAction.ValidateAll() if the designated constraints aren't met. +type TaskActionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskActionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskActionMultiError) AllErrors() []error { return m } + +// TaskActionValidationError is the validation error returned by +// TaskAction.Validate if the designated constraints aren't met. +type TaskActionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskActionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskActionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskActionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskActionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskActionValidationError) ErrorName() string { return "TaskActionValidationError" } + +// Error satisfies the builtin error interface +func (e TaskActionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskAction.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskActionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskActionValidationError{} + +// Validate checks the field values on TraceAction with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TraceAction) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TraceAction with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TraceActionMultiError, or +// nil if none found. +func (m *TraceAction) ValidateAll() error { + return m.validate(true) +} + +func (m *TraceAction) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + // no validation rules for Phase + + if all { + switch v := interface{}(m.GetStartTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TraceActionValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TraceActionValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStartTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TraceActionValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetOutputs()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TraceActionValidationError{ + field: "Outputs", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TraceActionValidationError{ + field: "Outputs", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOutputs()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TraceActionValidationError{ + field: "Outputs", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TraceActionValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TraceActionValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TraceActionValidationError{ + field: "Spec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if m.EndTime != nil { + + if all { + switch v := interface{}(m.GetEndTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TraceActionValidationError{ + field: "EndTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TraceActionValidationError{ + field: "EndTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetEndTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TraceActionValidationError{ + field: "EndTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return TraceActionMultiError(errors) + } + + return nil +} + +// TraceActionMultiError is an error wrapping multiple validation errors +// returned by TraceAction.ValidateAll() if the designated constraints aren't met. +type TraceActionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TraceActionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TraceActionMultiError) AllErrors() []error { return m } + +// TraceActionValidationError is the validation error returned by +// TraceAction.Validate if the designated constraints aren't met. +type TraceActionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TraceActionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TraceActionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TraceActionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TraceActionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TraceActionValidationError) ErrorName() string { return "TraceActionValidationError" } + +// Error satisfies the builtin error interface +func (e TraceActionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTraceAction.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TraceActionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TraceActionValidationError{} + +// Validate checks the field values on ConditionAction with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *ConditionAction) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ConditionAction with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ConditionActionMultiError, or nil if none found. +func (m *ConditionAction) ValidateAll() error { + return m.validate(true) +} + +func (m *ConditionAction) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + if all { + switch v := interface{}(m.GetType()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ConditionActionValidationError{ + field: "Type", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ConditionActionValidationError{ + field: "Type", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetType()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ConditionActionValidationError{ + field: "Type", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Prompt + + // no validation rules for Description + + switch v := m.Scope.(type) { + case *ConditionAction_RunId: + if v == nil { + err := ConditionActionValidationError{ + field: "Scope", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for RunId + case *ConditionAction_ActionId: + if v == nil { + err := ConditionActionValidationError{ + field: "Scope", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for ActionId + case *ConditionAction_Global: + if v == nil { + err := ConditionActionValidationError{ + field: "Scope", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for Global + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return ConditionActionMultiError(errors) + } + + return nil +} + +// ConditionActionMultiError is an error wrapping multiple validation errors +// returned by ConditionAction.ValidateAll() if the designated constraints +// aren't met. +type ConditionActionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ConditionActionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ConditionActionMultiError) AllErrors() []error { return m } + +// ConditionActionValidationError is the validation error returned by +// ConditionAction.Validate if the designated constraints aren't met. +type ConditionActionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ConditionActionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ConditionActionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ConditionActionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ConditionActionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ConditionActionValidationError) ErrorName() string { return "ConditionActionValidationError" } + +// Error satisfies the builtin error interface +func (e ConditionActionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sConditionAction.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ConditionActionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ConditionActionValidationError{} + +// Validate checks the field values on TaskActionMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *TaskActionMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskActionMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TaskActionMetadataMultiError, or nil if none found. +func (m *TaskActionMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskActionMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskActionMetadataValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskActionMetadataValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskActionMetadataValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for TaskType + + // no validation rules for ShortName + + if len(errors) > 0 { + return TaskActionMetadataMultiError(errors) + } + + return nil +} + +// TaskActionMetadataMultiError is an error wrapping multiple validation errors +// returned by TaskActionMetadata.ValidateAll() if the designated constraints +// aren't met. +type TaskActionMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskActionMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskActionMetadataMultiError) AllErrors() []error { return m } + +// TaskActionMetadataValidationError is the validation error returned by +// TaskActionMetadata.Validate if the designated constraints aren't met. +type TaskActionMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskActionMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskActionMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskActionMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskActionMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskActionMetadataValidationError) ErrorName() string { + return "TaskActionMetadataValidationError" +} + +// Error satisfies the builtin error interface +func (e TaskActionMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskActionMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskActionMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskActionMetadataValidationError{} + +// Validate checks the field values on TraceActionMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *TraceActionMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TraceActionMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TraceActionMetadataMultiError, or nil if none found. +func (m *TraceActionMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *TraceActionMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + if len(errors) > 0 { + return TraceActionMetadataMultiError(errors) + } + + return nil +} + +// TraceActionMetadataMultiError is an error wrapping multiple validation +// errors returned by TraceActionMetadata.ValidateAll() if the designated +// constraints aren't met. +type TraceActionMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TraceActionMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TraceActionMetadataMultiError) AllErrors() []error { return m } + +// TraceActionMetadataValidationError is the validation error returned by +// TraceActionMetadata.Validate if the designated constraints aren't met. +type TraceActionMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TraceActionMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TraceActionMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TraceActionMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TraceActionMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TraceActionMetadataValidationError) ErrorName() string { + return "TraceActionMetadataValidationError" +} + +// Error satisfies the builtin error interface +func (e TraceActionMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTraceActionMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TraceActionMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TraceActionMetadataValidationError{} + +// Validate checks the field values on ConditionActionMetadata with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ConditionActionMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ConditionActionMetadata with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ConditionActionMetadataMultiError, or nil if none found. +func (m *ConditionActionMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *ConditionActionMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Name + + switch v := m.Scope.(type) { + case *ConditionActionMetadata_RunId: + if v == nil { + err := ConditionActionMetadataValidationError{ + field: "Scope", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for RunId + case *ConditionActionMetadata_ActionId: + if v == nil { + err := ConditionActionMetadataValidationError{ + field: "Scope", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for ActionId + case *ConditionActionMetadata_Global: + if v == nil { + err := ConditionActionMetadataValidationError{ + field: "Scope", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for Global + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return ConditionActionMetadataMultiError(errors) + } + + return nil +} + +// ConditionActionMetadataMultiError is an error wrapping multiple validation +// errors returned by ConditionActionMetadata.ValidateAll() if the designated +// constraints aren't met. +type ConditionActionMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ConditionActionMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ConditionActionMetadataMultiError) AllErrors() []error { return m } + +// ConditionActionMetadataValidationError is the validation error returned by +// ConditionActionMetadata.Validate if the designated constraints aren't met. +type ConditionActionMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ConditionActionMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ConditionActionMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ConditionActionMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ConditionActionMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ConditionActionMetadataValidationError) ErrorName() string { + return "ConditionActionMetadataValidationError" +} + +// Error satisfies the builtin error interface +func (e ConditionActionMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sConditionActionMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ConditionActionMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ConditionActionMetadataValidationError{} + +// Validate checks the field values on ActionMetadata with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ActionMetadata) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ActionMetadata with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ActionMetadataMultiError, +// or nil if none found. +func (m *ActionMetadata) ValidateAll() error { + return m.validate(true) +} + +func (m *ActionMetadata) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Parent + + // no validation rules for Group + + if all { + switch v := interface{}(m.GetExecutedBy()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionMetadataValidationError{ + field: "ExecutedBy", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionMetadataValidationError{ + field: "ExecutedBy", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetExecutedBy()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionMetadataValidationError{ + field: "ExecutedBy", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for ActionType + + if all { + switch v := interface{}(m.GetTriggerId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionMetadataValidationError{ + field: "TriggerId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionMetadataValidationError{ + field: "TriggerId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTriggerId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionMetadataValidationError{ + field: "TriggerId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for EnvironmentName + + // no validation rules for FuntionName + + // no validation rules for TriggerName + + if all { + switch v := interface{}(m.GetTriggerType()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionMetadataValidationError{ + field: "TriggerType", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionMetadataValidationError{ + field: "TriggerType", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTriggerType()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionMetadataValidationError{ + field: "TriggerType", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Source + + switch v := m.Spec.(type) { + case *ActionMetadata_Task: + if v == nil { + err := ActionMetadataValidationError{ + field: "Spec", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTask()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionMetadataValidationError{ + field: "Task", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionMetadataValidationError{ + field: "Task", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTask()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionMetadataValidationError{ + field: "Task", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *ActionMetadata_Trace: + if v == nil { + err := ActionMetadataValidationError{ + field: "Spec", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTrace()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionMetadataValidationError{ + field: "Trace", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionMetadataValidationError{ + field: "Trace", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTrace()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionMetadataValidationError{ + field: "Trace", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *ActionMetadata_Condition: + if v == nil { + err := ActionMetadataValidationError{ + field: "Spec", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetCondition()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionMetadataValidationError{ + field: "Condition", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionMetadataValidationError{ + field: "Condition", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCondition()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionMetadataValidationError{ + field: "Condition", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return ActionMetadataMultiError(errors) + } + + return nil +} + +// ActionMetadataMultiError is an error wrapping multiple validation errors +// returned by ActionMetadata.ValidateAll() if the designated constraints +// aren't met. +type ActionMetadataMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ActionMetadataMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ActionMetadataMultiError) AllErrors() []error { return m } + +// ActionMetadataValidationError is the validation error returned by +// ActionMetadata.Validate if the designated constraints aren't met. +type ActionMetadataValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ActionMetadataValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ActionMetadataValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ActionMetadataValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ActionMetadataValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ActionMetadataValidationError) ErrorName() string { return "ActionMetadataValidationError" } + +// Error satisfies the builtin error interface +func (e ActionMetadataValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sActionMetadata.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ActionMetadataValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ActionMetadataValidationError{} + +// Validate checks the field values on ActionStatus with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ActionStatus) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ActionStatus with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ActionStatusMultiError, or +// nil if none found. +func (m *ActionStatus) ValidateAll() error { + return m.validate(true) +} + +func (m *ActionStatus) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Phase + + if all { + switch v := interface{}(m.GetStartTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionStatusValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionStatusValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStartTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionStatusValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Attempts + + // no validation rules for CacheStatus + + if m.EndTime != nil { + + if all { + switch v := interface{}(m.GetEndTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionStatusValidationError{ + field: "EndTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionStatusValidationError{ + field: "EndTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetEndTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionStatusValidationError{ + field: "EndTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if m.DurationMs != nil { + // no validation rules for DurationMs + } + + if len(errors) > 0 { + return ActionStatusMultiError(errors) + } + + return nil +} + +// ActionStatusMultiError is an error wrapping multiple validation errors +// returned by ActionStatus.ValidateAll() if the designated constraints aren't met. +type ActionStatusMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ActionStatusMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ActionStatusMultiError) AllErrors() []error { return m } + +// ActionStatusValidationError is the validation error returned by +// ActionStatus.Validate if the designated constraints aren't met. +type ActionStatusValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ActionStatusValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ActionStatusValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ActionStatusValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ActionStatusValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ActionStatusValidationError) ErrorName() string { return "ActionStatusValidationError" } + +// Error satisfies the builtin error interface +func (e ActionStatusValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sActionStatus.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ActionStatusValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ActionStatusValidationError{} + +// Validate checks the field values on Action with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Action) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Action with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in ActionMultiError, or nil if none found. +func (m *Action) ValidateAll() error { + return m.validate(true) +} + +func (m *Action) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetStatus()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStatus()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ActionMultiError(errors) + } + + return nil +} + +// ActionMultiError is an error wrapping multiple validation errors returned by +// Action.ValidateAll() if the designated constraints aren't met. +type ActionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ActionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ActionMultiError) AllErrors() []error { return m } + +// ActionValidationError is the validation error returned by Action.Validate if +// the designated constraints aren't met. +type ActionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ActionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ActionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ActionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ActionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ActionValidationError) ErrorName() string { return "ActionValidationError" } + +// Error satisfies the builtin error interface +func (e ActionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sAction.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ActionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ActionValidationError{} + +// Validate checks the field values on EnrichedAction with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *EnrichedAction) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on EnrichedAction with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in EnrichedActionMultiError, +// or nil if none found. +func (m *EnrichedAction) ValidateAll() error { + return m.validate(true) +} + +func (m *EnrichedAction) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetAction()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, EnrichedActionValidationError{ + field: "Action", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, EnrichedActionValidationError{ + field: "Action", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAction()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return EnrichedActionValidationError{ + field: "Action", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for MeetsFilter + + // no validation rules for ChildrenPhaseCounts + + if len(errors) > 0 { + return EnrichedActionMultiError(errors) + } + + return nil +} + +// EnrichedActionMultiError is an error wrapping multiple validation errors +// returned by EnrichedAction.ValidateAll() if the designated constraints +// aren't met. +type EnrichedActionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m EnrichedActionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m EnrichedActionMultiError) AllErrors() []error { return m } + +// EnrichedActionValidationError is the validation error returned by +// EnrichedAction.Validate if the designated constraints aren't met. +type EnrichedActionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e EnrichedActionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e EnrichedActionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e EnrichedActionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e EnrichedActionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e EnrichedActionValidationError) ErrorName() string { return "EnrichedActionValidationError" } + +// Error satisfies the builtin error interface +func (e EnrichedActionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sEnrichedAction.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = EnrichedActionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = EnrichedActionValidationError{} + +// Validate checks the field values on ErrorInfo with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ErrorInfo) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ErrorInfo with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ErrorInfoMultiError, or nil +// if none found. +func (m *ErrorInfo) ValidateAll() error { + return m.validate(true) +} + +func (m *ErrorInfo) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Message + + // no validation rules for Kind + + if len(errors) > 0 { + return ErrorInfoMultiError(errors) + } + + return nil +} + +// ErrorInfoMultiError is an error wrapping multiple validation errors returned +// by ErrorInfo.ValidateAll() if the designated constraints aren't met. +type ErrorInfoMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ErrorInfoMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ErrorInfoMultiError) AllErrors() []error { return m } + +// ErrorInfoValidationError is the validation error returned by +// ErrorInfo.Validate if the designated constraints aren't met. +type ErrorInfoValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ErrorInfoValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ErrorInfoValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ErrorInfoValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ErrorInfoValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ErrorInfoValidationError) ErrorName() string { return "ErrorInfoValidationError" } + +// Error satisfies the builtin error interface +func (e ErrorInfoValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sErrorInfo.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ErrorInfoValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ErrorInfoValidationError{} + +// Validate checks the field values on AbortInfo with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *AbortInfo) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on AbortInfo with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in AbortInfoMultiError, or nil +// if none found. +func (m *AbortInfo) ValidateAll() error { + return m.validate(true) +} + +func (m *AbortInfo) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Reason + + if all { + switch v := interface{}(m.GetAbortedBy()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, AbortInfoValidationError{ + field: "AbortedBy", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, AbortInfoValidationError{ + field: "AbortedBy", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAbortedBy()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return AbortInfoValidationError{ + field: "AbortedBy", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return AbortInfoMultiError(errors) + } + + return nil +} + +// AbortInfoMultiError is an error wrapping multiple validation errors returned +// by AbortInfo.ValidateAll() if the designated constraints aren't met. +type AbortInfoMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m AbortInfoMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m AbortInfoMultiError) AllErrors() []error { return m } + +// AbortInfoValidationError is the validation error returned by +// AbortInfo.Validate if the designated constraints aren't met. +type AbortInfoValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e AbortInfoValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e AbortInfoValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e AbortInfoValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e AbortInfoValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e AbortInfoValidationError) ErrorName() string { return "AbortInfoValidationError" } + +// Error satisfies the builtin error interface +func (e AbortInfoValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sAbortInfo.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = AbortInfoValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = AbortInfoValidationError{} + +// Validate checks the field values on ActionDetails with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ActionDetails) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ActionDetails with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ActionDetailsMultiError, or +// nil if none found. +func (m *ActionDetails) ValidateAll() error { + return m.validate(true) +} + +func (m *ActionDetails) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionDetailsValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionDetailsValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionDetailsValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetMetadata()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionDetailsValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionDetailsValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionDetailsValidationError{ + field: "Metadata", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetStatus()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionDetailsValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionDetailsValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStatus()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionDetailsValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetAttempts() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionDetailsValidationError{ + field: fmt.Sprintf("Attempts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionDetailsValidationError{ + field: fmt.Sprintf("Attempts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionDetailsValidationError{ + field: fmt.Sprintf("Attempts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + switch v := m.Result.(type) { + case *ActionDetails_ErrorInfo: + if v == nil { + err := ActionDetailsValidationError{ + field: "Result", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetErrorInfo()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionDetailsValidationError{ + field: "ErrorInfo", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionDetailsValidationError{ + field: "ErrorInfo", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetErrorInfo()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionDetailsValidationError{ + field: "ErrorInfo", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *ActionDetails_AbortInfo: + if v == nil { + err := ActionDetailsValidationError{ + field: "Result", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetAbortInfo()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionDetailsValidationError{ + field: "AbortInfo", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionDetailsValidationError{ + field: "AbortInfo", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAbortInfo()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionDetailsValidationError{ + field: "AbortInfo", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + switch v := m.Spec.(type) { + case *ActionDetails_Task: + if v == nil { + err := ActionDetailsValidationError{ + field: "Spec", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTask()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionDetailsValidationError{ + field: "Task", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionDetailsValidationError{ + field: "Task", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTask()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionDetailsValidationError{ + field: "Task", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *ActionDetails_Trace: + if v == nil { + err := ActionDetailsValidationError{ + field: "Spec", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTrace()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionDetailsValidationError{ + field: "Trace", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionDetailsValidationError{ + field: "Trace", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTrace()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionDetailsValidationError{ + field: "Trace", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return ActionDetailsMultiError(errors) + } + + return nil +} + +// ActionDetailsMultiError is an error wrapping multiple validation errors +// returned by ActionDetails.ValidateAll() if the designated constraints +// aren't met. +type ActionDetailsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ActionDetailsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ActionDetailsMultiError) AllErrors() []error { return m } + +// ActionDetailsValidationError is the validation error returned by +// ActionDetails.Validate if the designated constraints aren't met. +type ActionDetailsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ActionDetailsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ActionDetailsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ActionDetailsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ActionDetailsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ActionDetailsValidationError) ErrorName() string { return "ActionDetailsValidationError" } + +// Error satisfies the builtin error interface +func (e ActionDetailsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sActionDetails.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ActionDetailsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ActionDetailsValidationError{} + +// Validate checks the field values on ActionAttempt with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ActionAttempt) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ActionAttempt with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ActionAttemptMultiError, or +// nil if none found. +func (m *ActionAttempt) ValidateAll() error { + return m.validate(true) +} + +func (m *ActionAttempt) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Phase + + if all { + switch v := interface{}(m.GetStartTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionAttemptValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionAttemptValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStartTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionAttemptValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Attempt + + for idx, item := range m.GetLogInfo() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionAttemptValidationError{ + field: fmt.Sprintf("LogInfo[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionAttemptValidationError{ + field: fmt.Sprintf("LogInfo[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionAttemptValidationError{ + field: fmt.Sprintf("LogInfo[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if all { + switch v := interface{}(m.GetOutputs()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionAttemptValidationError{ + field: "Outputs", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionAttemptValidationError{ + field: "Outputs", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOutputs()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionAttemptValidationError{ + field: "Outputs", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for LogsAvailable + + // no validation rules for CacheStatus + + for idx, item := range m.GetClusterEvents() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionAttemptValidationError{ + field: fmt.Sprintf("ClusterEvents[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionAttemptValidationError{ + field: fmt.Sprintf("ClusterEvents[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionAttemptValidationError{ + field: fmt.Sprintf("ClusterEvents[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + for idx, item := range m.GetPhaseTransitions() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionAttemptValidationError{ + field: fmt.Sprintf("PhaseTransitions[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionAttemptValidationError{ + field: fmt.Sprintf("PhaseTransitions[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionAttemptValidationError{ + field: fmt.Sprintf("PhaseTransitions[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Cluster + + if all { + switch v := interface{}(m.GetLogContext()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionAttemptValidationError{ + field: "LogContext", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionAttemptValidationError{ + field: "LogContext", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLogContext()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionAttemptValidationError{ + field: "LogContext", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if m.EndTime != nil { + + if all { + switch v := interface{}(m.GetEndTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionAttemptValidationError{ + field: "EndTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionAttemptValidationError{ + field: "EndTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetEndTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionAttemptValidationError{ + field: "EndTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if m.ErrorInfo != nil { + + if all { + switch v := interface{}(m.GetErrorInfo()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionAttemptValidationError{ + field: "ErrorInfo", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionAttemptValidationError{ + field: "ErrorInfo", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetErrorInfo()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionAttemptValidationError{ + field: "ErrorInfo", + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return ActionAttemptMultiError(errors) + } + + return nil +} + +// ActionAttemptMultiError is an error wrapping multiple validation errors +// returned by ActionAttempt.ValidateAll() if the designated constraints +// aren't met. +type ActionAttemptMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ActionAttemptMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ActionAttemptMultiError) AllErrors() []error { return m } + +// ActionAttemptValidationError is the validation error returned by +// ActionAttempt.Validate if the designated constraints aren't met. +type ActionAttemptValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ActionAttemptValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ActionAttemptValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ActionAttemptValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ActionAttemptValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ActionAttemptValidationError) ErrorName() string { return "ActionAttemptValidationError" } + +// Error satisfies the builtin error interface +func (e ActionAttemptValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sActionAttempt.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ActionAttemptValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ActionAttemptValidationError{} + +// Validate checks the field values on ClusterEvent with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ClusterEvent) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ClusterEvent with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ClusterEventMultiError, or +// nil if none found. +func (m *ClusterEvent) ValidateAll() error { + return m.validate(true) +} + +func (m *ClusterEvent) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetOccurredAt()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ClusterEventValidationError{ + field: "OccurredAt", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ClusterEventValidationError{ + field: "OccurredAt", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOccurredAt()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ClusterEventValidationError{ + field: "OccurredAt", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Message + + if len(errors) > 0 { + return ClusterEventMultiError(errors) + } + + return nil +} + +// ClusterEventMultiError is an error wrapping multiple validation errors +// returned by ClusterEvent.ValidateAll() if the designated constraints aren't met. +type ClusterEventMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ClusterEventMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ClusterEventMultiError) AllErrors() []error { return m } + +// ClusterEventValidationError is the validation error returned by +// ClusterEvent.Validate if the designated constraints aren't met. +type ClusterEventValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ClusterEventValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ClusterEventValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ClusterEventValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ClusterEventValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ClusterEventValidationError) ErrorName() string { return "ClusterEventValidationError" } + +// Error satisfies the builtin error interface +func (e ClusterEventValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sClusterEvent.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ClusterEventValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ClusterEventValidationError{} + +// Validate checks the field values on PhaseTransition with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *PhaseTransition) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on PhaseTransition with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// PhaseTransitionMultiError, or nil if none found. +func (m *PhaseTransition) ValidateAll() error { + return m.validate(true) +} + +func (m *PhaseTransition) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Phase + + if all { + switch v := interface{}(m.GetStartTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PhaseTransitionValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PhaseTransitionValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStartTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PhaseTransitionValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if m.EndTime != nil { + + if all { + switch v := interface{}(m.GetEndTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PhaseTransitionValidationError{ + field: "EndTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PhaseTransitionValidationError{ + field: "EndTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetEndTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PhaseTransitionValidationError{ + field: "EndTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return PhaseTransitionMultiError(errors) + } + + return nil +} + +// PhaseTransitionMultiError is an error wrapping multiple validation errors +// returned by PhaseTransition.ValidateAll() if the designated constraints +// aren't met. +type PhaseTransitionMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PhaseTransitionMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PhaseTransitionMultiError) AllErrors() []error { return m } + +// PhaseTransitionValidationError is the validation error returned by +// PhaseTransition.Validate if the designated constraints aren't met. +type PhaseTransitionValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PhaseTransitionValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PhaseTransitionValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PhaseTransitionValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PhaseTransitionValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PhaseTransitionValidationError) ErrorName() string { return "PhaseTransitionValidationError" } + +// Error satisfies the builtin error interface +func (e PhaseTransitionValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPhaseTransition.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PhaseTransitionValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PhaseTransitionValidationError{} + +// Validate checks the field values on ActionEvent with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ActionEvent) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ActionEvent with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ActionEventMultiError, or +// nil if none found. +func (m *ActionEvent) ValidateAll() error { + return m.validate(true) +} + +func (m *ActionEvent) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionEventValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Attempt + + // no validation rules for Phase + + // no validation rules for Version + + if all { + switch v := interface{}(m.GetStartTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStartTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionEventValidationError{ + field: "StartTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetUpdatedTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: "UpdatedTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: "UpdatedTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetUpdatedTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionEventValidationError{ + field: "UpdatedTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetLogInfo() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: fmt.Sprintf("LogInfo[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: fmt.Sprintf("LogInfo[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionEventValidationError{ + field: fmt.Sprintf("LogInfo[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if all { + switch v := interface{}(m.GetLogContext()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: "LogContext", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: "LogContext", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLogContext()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionEventValidationError{ + field: "LogContext", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Cluster + + if all { + switch v := interface{}(m.GetOutputs()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: "Outputs", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: "Outputs", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOutputs()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionEventValidationError{ + field: "Outputs", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for CacheStatus + + for idx, item := range m.GetClusterEvents() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: fmt.Sprintf("ClusterEvents[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: fmt.Sprintf("ClusterEvents[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionEventValidationError{ + field: fmt.Sprintf("ClusterEvents[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if all { + switch v := interface{}(m.GetReportedTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: "ReportedTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: "ReportedTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetReportedTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionEventValidationError{ + field: "ReportedTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if m.EndTime != nil { + + if all { + switch v := interface{}(m.GetEndTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: "EndTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: "EndTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetEndTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionEventValidationError{ + field: "EndTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if m.ErrorInfo != nil { + + if all { + switch v := interface{}(m.GetErrorInfo()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: "ErrorInfo", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionEventValidationError{ + field: "ErrorInfo", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetErrorInfo()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionEventValidationError{ + field: "ErrorInfo", + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return ActionEventMultiError(errors) + } + + return nil +} + +// ActionEventMultiError is an error wrapping multiple validation errors +// returned by ActionEvent.ValidateAll() if the designated constraints aren't met. +type ActionEventMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ActionEventMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ActionEventMultiError) AllErrors() []error { return m } + +// ActionEventValidationError is the validation error returned by +// ActionEvent.Validate if the designated constraints aren't met. +type ActionEventValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ActionEventValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ActionEventValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ActionEventValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ActionEventValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ActionEventValidationError) ErrorName() string { return "ActionEventValidationError" } + +// Error satisfies the builtin error interface +func (e ActionEventValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sActionEvent.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ActionEventValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ActionEventValidationError{} + +// Validate checks the field values on ActionSpec with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ActionSpec) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ActionSpec with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ActionSpecMultiError, or +// nil if none found. +func (m *ActionSpec) ValidateAll() error { + return m.validate(true) +} + +func (m *ActionSpec) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetActionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionSpecValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionSpecValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetActionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionSpecValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetRunSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionSpecValidationError{ + field: "RunSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionSpecValidationError{ + field: "RunSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionSpecValidationError{ + field: "RunSpec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for InputUri + + // no validation rules for RunOutputBase + + // no validation rules for Group + + switch v := m.Spec.(type) { + case *ActionSpec_Task: + if v == nil { + err := ActionSpecValidationError{ + field: "Spec", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTask()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionSpecValidationError{ + field: "Task", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionSpecValidationError{ + field: "Task", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTask()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionSpecValidationError{ + field: "Task", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *ActionSpec_Condition: + if v == nil { + err := ActionSpecValidationError{ + field: "Spec", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetCondition()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionSpecValidationError{ + field: "Condition", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionSpecValidationError{ + field: "Condition", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetCondition()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionSpecValidationError{ + field: "Condition", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *ActionSpec_Trace: + if v == nil { + err := ActionSpecValidationError{ + field: "Spec", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTrace()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionSpecValidationError{ + field: "Trace", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionSpecValidationError{ + field: "Trace", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTrace()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionSpecValidationError{ + field: "Trace", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if m.ParentActionName != nil { + // no validation rules for ParentActionName + } + + if len(errors) > 0 { + return ActionSpecMultiError(errors) + } + + return nil +} + +// ActionSpecMultiError is an error wrapping multiple validation errors +// returned by ActionSpec.ValidateAll() if the designated constraints aren't met. +type ActionSpecMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ActionSpecMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ActionSpecMultiError) AllErrors() []error { return m } + +// ActionSpecValidationError is the validation error returned by +// ActionSpec.Validate if the designated constraints aren't met. +type ActionSpecValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ActionSpecValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ActionSpecValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ActionSpecValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ActionSpecValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ActionSpecValidationError) ErrorName() string { return "ActionSpecValidationError" } + +// Error satisfies the builtin error interface +func (e ActionSpecValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sActionSpec.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ActionSpecValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ActionSpecValidationError{} + +// Validate checks the field values on TaskGroup with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *TaskGroup) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskGroup with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in TaskGroupMultiError, or nil +// if none found. +func (m *TaskGroup) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskGroup) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for TaskName + + // no validation rules for EnvironmentName + + // no validation rules for TotalRuns + + if all { + switch v := interface{}(m.GetLatestRunTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskGroupValidationError{ + field: "LatestRunTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskGroupValidationError{ + field: "LatestRunTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLatestRunTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskGroupValidationError{ + field: "LatestRunTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetRecentStatuses() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskGroupValidationError{ + field: fmt.Sprintf("RecentStatuses[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskGroupValidationError{ + field: fmt.Sprintf("RecentStatuses[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskGroupValidationError{ + field: fmt.Sprintf("RecentStatuses[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for AverageFailureRate + + if all { + switch v := interface{}(m.GetAverageDuration()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskGroupValidationError{ + field: "AverageDuration", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskGroupValidationError{ + field: "AverageDuration", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetAverageDuration()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskGroupValidationError{ + field: "AverageDuration", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetLatestFinishedTime()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskGroupValidationError{ + field: "LatestFinishedTime", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskGroupValidationError{ + field: "LatestFinishedTime", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetLatestFinishedTime()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskGroupValidationError{ + field: "LatestFinishedTime", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetCreatedBy() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskGroupValidationError{ + field: fmt.Sprintf("CreatedBy[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskGroupValidationError{ + field: fmt.Sprintf("CreatedBy[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskGroupValidationError{ + field: fmt.Sprintf("CreatedBy[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for ShouldDelete + + // no validation rules for ShortName + + if all { + switch v := interface{}(m.GetErrorCounts()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskGroupValidationError{ + field: "ErrorCounts", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskGroupValidationError{ + field: "ErrorCounts", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetErrorCounts()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskGroupValidationError{ + field: "ErrorCounts", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetPhaseCounts() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskGroupValidationError{ + field: fmt.Sprintf("PhaseCounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskGroupValidationError{ + field: fmt.Sprintf("PhaseCounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskGroupValidationError{ + field: fmt.Sprintf("PhaseCounts[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return TaskGroupMultiError(errors) + } + + return nil +} + +// TaskGroupMultiError is an error wrapping multiple validation errors returned +// by TaskGroup.ValidateAll() if the designated constraints aren't met. +type TaskGroupMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskGroupMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskGroupMultiError) AllErrors() []error { return m } + +// TaskGroupValidationError is the validation error returned by +// TaskGroup.Validate if the designated constraints aren't met. +type TaskGroupValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskGroupValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskGroupValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskGroupValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskGroupValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskGroupValidationError) ErrorName() string { return "TaskGroupValidationError" } + +// Error satisfies the builtin error interface +func (e TaskGroupValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskGroup.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskGroupValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskGroupValidationError{} + +// Validate checks the field values on TaskGroup_RecentStatus with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *TaskGroup_RecentStatus) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskGroup_RecentStatus with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TaskGroup_RecentStatusMultiError, or nil if none found. +func (m *TaskGroup_RecentStatus) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskGroup_RecentStatus) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for RunName + + // no validation rules for Phase + + if len(errors) > 0 { + return TaskGroup_RecentStatusMultiError(errors) + } + + return nil +} + +// TaskGroup_RecentStatusMultiError is an error wrapping multiple validation +// errors returned by TaskGroup_RecentStatus.ValidateAll() if the designated +// constraints aren't met. +type TaskGroup_RecentStatusMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskGroup_RecentStatusMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskGroup_RecentStatusMultiError) AllErrors() []error { return m } + +// TaskGroup_RecentStatusValidationError is the validation error returned by +// TaskGroup_RecentStatus.Validate if the designated constraints aren't met. +type TaskGroup_RecentStatusValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskGroup_RecentStatusValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskGroup_RecentStatusValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskGroup_RecentStatusValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskGroup_RecentStatusValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskGroup_RecentStatusValidationError) ErrorName() string { + return "TaskGroup_RecentStatusValidationError" +} + +// Error satisfies the builtin error interface +func (e TaskGroup_RecentStatusValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskGroup_RecentStatus.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskGroup_RecentStatusValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskGroup_RecentStatusValidationError{} + +// Validate checks the field values on TaskGroup_ErrorCounts with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *TaskGroup_ErrorCounts) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskGroup_ErrorCounts with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TaskGroup_ErrorCountsMultiError, or nil if none found. +func (m *TaskGroup_ErrorCounts) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskGroup_ErrorCounts) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for UserError + + // no validation rules for SystemError + + // no validation rules for UnspecifiedError + + if len(errors) > 0 { + return TaskGroup_ErrorCountsMultiError(errors) + } + + return nil +} + +// TaskGroup_ErrorCountsMultiError is an error wrapping multiple validation +// errors returned by TaskGroup_ErrorCounts.ValidateAll() if the designated +// constraints aren't met. +type TaskGroup_ErrorCountsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskGroup_ErrorCountsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskGroup_ErrorCountsMultiError) AllErrors() []error { return m } + +// TaskGroup_ErrorCountsValidationError is the validation error returned by +// TaskGroup_ErrorCounts.Validate if the designated constraints aren't met. +type TaskGroup_ErrorCountsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskGroup_ErrorCountsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskGroup_ErrorCountsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskGroup_ErrorCountsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskGroup_ErrorCountsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskGroup_ErrorCountsValidationError) ErrorName() string { + return "TaskGroup_ErrorCountsValidationError" +} + +// Error satisfies the builtin error interface +func (e TaskGroup_ErrorCountsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskGroup_ErrorCounts.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskGroup_ErrorCountsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskGroup_ErrorCountsValidationError{} + +// Validate checks the field values on TaskGroup_PhaseCounts with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *TaskGroup_PhaseCounts) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskGroup_PhaseCounts with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TaskGroup_PhaseCountsMultiError, or nil if none found. +func (m *TaskGroup_PhaseCounts) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskGroup_PhaseCounts) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Phase + + // no validation rules for Count + + if len(errors) > 0 { + return TaskGroup_PhaseCountsMultiError(errors) + } + + return nil +} + +// TaskGroup_PhaseCountsMultiError is an error wrapping multiple validation +// errors returned by TaskGroup_PhaseCounts.ValidateAll() if the designated +// constraints aren't met. +type TaskGroup_PhaseCountsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskGroup_PhaseCountsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskGroup_PhaseCountsMultiError) AllErrors() []error { return m } + +// TaskGroup_PhaseCountsValidationError is the validation error returned by +// TaskGroup_PhaseCounts.Validate if the designated constraints aren't met. +type TaskGroup_PhaseCountsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskGroup_PhaseCountsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskGroup_PhaseCountsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskGroup_PhaseCountsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskGroup_PhaseCountsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskGroup_PhaseCountsValidationError) ErrorName() string { + return "TaskGroup_PhaseCountsValidationError" +} + +// Error satisfies the builtin error interface +func (e TaskGroup_PhaseCountsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskGroup_PhaseCounts.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskGroup_PhaseCountsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskGroup_PhaseCountsValidationError{} diff --git a/gen/go/flyteidl2/workflow/run_logs_service.pb.go b/gen/go/flyteidl2/workflow/run_logs_service.pb.go new file mode 100644 index 0000000000..5b8dfa5119 --- /dev/null +++ b/gen/go/flyteidl2/workflow/run_logs_service.pb.go @@ -0,0 +1,330 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/workflow/run_logs_service.proto + +package workflow + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + dataplane "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/logs/dataplane" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Request message for tailing logs. +type TailLogsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The action id. + ActionId *common.ActionIdentifier `protobuf:"bytes,1,opt,name=action_id,json=actionId,proto3" json:"action_id,omitempty"` + // The attempt number. + Attempt uint32 `protobuf:"varint,2,opt,name=attempt,proto3" json:"attempt,omitempty"` +} + +func (x *TailLogsRequest) Reset() { + *x = TailLogsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_logs_service_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TailLogsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TailLogsRequest) ProtoMessage() {} + +func (x *TailLogsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_logs_service_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TailLogsRequest.ProtoReflect.Descriptor instead. +func (*TailLogsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_logs_service_proto_rawDescGZIP(), []int{0} +} + +func (x *TailLogsRequest) GetActionId() *common.ActionIdentifier { + if x != nil { + return x.ActionId + } + return nil +} + +func (x *TailLogsRequest) GetAttempt() uint32 { + if x != nil { + return x.Attempt + } + return 0 +} + +// Reponse message for tailing logs. +type TailLogsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // One or more batches of logs. + Logs []*TailLogsResponse_Logs `protobuf:"bytes,1,rep,name=logs,proto3" json:"logs,omitempty"` +} + +func (x *TailLogsResponse) Reset() { + *x = TailLogsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_logs_service_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TailLogsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TailLogsResponse) ProtoMessage() {} + +func (x *TailLogsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_logs_service_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TailLogsResponse.ProtoReflect.Descriptor instead. +func (*TailLogsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_logs_service_proto_rawDescGZIP(), []int{1} +} + +func (x *TailLogsResponse) GetLogs() []*TailLogsResponse_Logs { + if x != nil { + return x.Logs + } + return nil +} + +// A batch of logs. +type TailLogsResponse_Logs struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Structured log lines. + Lines []*dataplane.LogLine `protobuf:"bytes,1,rep,name=lines,proto3" json:"lines,omitempty"` +} + +func (x *TailLogsResponse_Logs) Reset() { + *x = TailLogsResponse_Logs{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_logs_service_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TailLogsResponse_Logs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TailLogsResponse_Logs) ProtoMessage() {} + +func (x *TailLogsResponse_Logs) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_logs_service_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TailLogsResponse_Logs.ProtoReflect.Descriptor instead. +func (*TailLogsResponse_Logs) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_logs_service_proto_rawDescGZIP(), []int{1, 0} +} + +func (x *TailLogsResponse_Logs) GetLines() []*dataplane.LogLine { + if x != nil { + return x.Lines + } + return nil +} + +var File_flyteidl2_workflow_run_logs_service_proto protoreflect.FileDescriptor + +var file_flyteidl2_workflow_run_logs_service_proto_rawDesc = []byte{ + 0x0a, 0x29, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x72, 0x75, 0x6e, 0x5f, 0x6c, 0x6f, 0x67, 0x73, 0x5f, 0x73, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x1a, + 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, + 0x26, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x6c, 0x6f, 0x67, 0x73, 0x2f, + 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, + 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x7d, 0x0a, 0x0f, 0x54, 0x61, 0x69, 0x6c, 0x4c, + 0x6f, 0x67, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x07, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, 0x02, 0x20, 0x00, 0x52, 0x07, 0x61, + 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x22, 0x92, 0x01, 0x0a, 0x10, 0x54, 0x61, 0x69, 0x6c, 0x4c, + 0x6f, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3d, 0x0a, 0x04, 0x6c, + 0x6f, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, + 0x61, 0x69, 0x6c, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, + 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x04, 0x6c, 0x6f, 0x67, 0x73, 0x1a, 0x3f, 0x0a, 0x04, 0x4c, 0x6f, + 0x67, 0x73, 0x12, 0x37, 0x0a, 0x05, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x6c, 0x6f, + 0x67, 0x73, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2e, 0x4c, 0x6f, 0x67, + 0x4c, 0x69, 0x6e, 0x65, 0x52, 0x05, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x32, 0x6e, 0x0a, 0x0e, 0x52, + 0x75, 0x6e, 0x4c, 0x6f, 0x67, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x5c, 0x0a, + 0x08, 0x54, 0x61, 0x69, 0x6c, 0x4c, 0x6f, 0x67, 0x73, 0x12, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, + 0x61, 0x69, 0x6c, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x61, 0x69, 0x6c, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x30, 0x01, 0x42, 0xd0, 0x01, 0x0a, 0x16, + 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x13, 0x52, 0x75, 0x6e, 0x4c, 0x6f, 0x67, 0x73, 0x53, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, + 0x36, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, + 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xa2, 0x02, 0x03, 0x46, 0x57, 0x58, 0xaa, 0x02, 0x12, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0xca, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x57, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xe2, 0x02, 0x1e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5c, 0x47, 0x50, 0x42, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x13, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_workflow_run_logs_service_proto_rawDescOnce sync.Once + file_flyteidl2_workflow_run_logs_service_proto_rawDescData = file_flyteidl2_workflow_run_logs_service_proto_rawDesc +) + +func file_flyteidl2_workflow_run_logs_service_proto_rawDescGZIP() []byte { + file_flyteidl2_workflow_run_logs_service_proto_rawDescOnce.Do(func() { + file_flyteidl2_workflow_run_logs_service_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_workflow_run_logs_service_proto_rawDescData) + }) + return file_flyteidl2_workflow_run_logs_service_proto_rawDescData +} + +var file_flyteidl2_workflow_run_logs_service_proto_msgTypes = make([]protoimpl.MessageInfo, 3) +var file_flyteidl2_workflow_run_logs_service_proto_goTypes = []interface{}{ + (*TailLogsRequest)(nil), // 0: flyteidl2.workflow.TailLogsRequest + (*TailLogsResponse)(nil), // 1: flyteidl2.workflow.TailLogsResponse + (*TailLogsResponse_Logs)(nil), // 2: flyteidl2.workflow.TailLogsResponse.Logs + (*common.ActionIdentifier)(nil), // 3: flyteidl2.common.ActionIdentifier + (*dataplane.LogLine)(nil), // 4: flyteidl2.logs.dataplane.LogLine +} +var file_flyteidl2_workflow_run_logs_service_proto_depIdxs = []int32{ + 3, // 0: flyteidl2.workflow.TailLogsRequest.action_id:type_name -> flyteidl2.common.ActionIdentifier + 2, // 1: flyteidl2.workflow.TailLogsResponse.logs:type_name -> flyteidl2.workflow.TailLogsResponse.Logs + 4, // 2: flyteidl2.workflow.TailLogsResponse.Logs.lines:type_name -> flyteidl2.logs.dataplane.LogLine + 0, // 3: flyteidl2.workflow.RunLogsService.TailLogs:input_type -> flyteidl2.workflow.TailLogsRequest + 1, // 4: flyteidl2.workflow.RunLogsService.TailLogs:output_type -> flyteidl2.workflow.TailLogsResponse + 4, // [4:5] is the sub-list for method output_type + 3, // [3:4] is the sub-list for method input_type + 3, // [3:3] is the sub-list for extension type_name + 3, // [3:3] is the sub-list for extension extendee + 0, // [0:3] is the sub-list for field type_name +} + +func init() { file_flyteidl2_workflow_run_logs_service_proto_init() } +func file_flyteidl2_workflow_run_logs_service_proto_init() { + if File_flyteidl2_workflow_run_logs_service_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_workflow_run_logs_service_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TailLogsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_logs_service_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TailLogsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_logs_service_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TailLogsResponse_Logs); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_workflow_run_logs_service_proto_rawDesc, + NumEnums: 0, + NumMessages: 3, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_flyteidl2_workflow_run_logs_service_proto_goTypes, + DependencyIndexes: file_flyteidl2_workflow_run_logs_service_proto_depIdxs, + MessageInfos: file_flyteidl2_workflow_run_logs_service_proto_msgTypes, + }.Build() + File_flyteidl2_workflow_run_logs_service_proto = out.File + file_flyteidl2_workflow_run_logs_service_proto_rawDesc = nil + file_flyteidl2_workflow_run_logs_service_proto_goTypes = nil + file_flyteidl2_workflow_run_logs_service_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/workflow/run_logs_service.pb.validate.go b/gen/go/flyteidl2/workflow/run_logs_service.pb.validate.go new file mode 100644 index 0000000000..4c8b466ae4 --- /dev/null +++ b/gen/go/flyteidl2/workflow/run_logs_service.pb.validate.go @@ -0,0 +1,437 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/workflow/run_logs_service.proto + +package workflow + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on TailLogsRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *TailLogsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TailLogsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TailLogsRequestMultiError, or nil if none found. +func (m *TailLogsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *TailLogsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetActionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TailLogsRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TailLogsRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetActionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TailLogsRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Attempt + + if len(errors) > 0 { + return TailLogsRequestMultiError(errors) + } + + return nil +} + +// TailLogsRequestMultiError is an error wrapping multiple validation errors +// returned by TailLogsRequest.ValidateAll() if the designated constraints +// aren't met. +type TailLogsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TailLogsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TailLogsRequestMultiError) AllErrors() []error { return m } + +// TailLogsRequestValidationError is the validation error returned by +// TailLogsRequest.Validate if the designated constraints aren't met. +type TailLogsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TailLogsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TailLogsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TailLogsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TailLogsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TailLogsRequestValidationError) ErrorName() string { return "TailLogsRequestValidationError" } + +// Error satisfies the builtin error interface +func (e TailLogsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTailLogsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TailLogsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TailLogsRequestValidationError{} + +// Validate checks the field values on TailLogsResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *TailLogsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TailLogsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TailLogsResponseMultiError, or nil if none found. +func (m *TailLogsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *TailLogsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetLogs() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TailLogsResponseValidationError{ + field: fmt.Sprintf("Logs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TailLogsResponseValidationError{ + field: fmt.Sprintf("Logs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TailLogsResponseValidationError{ + field: fmt.Sprintf("Logs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return TailLogsResponseMultiError(errors) + } + + return nil +} + +// TailLogsResponseMultiError is an error wrapping multiple validation errors +// returned by TailLogsResponse.ValidateAll() if the designated constraints +// aren't met. +type TailLogsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TailLogsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TailLogsResponseMultiError) AllErrors() []error { return m } + +// TailLogsResponseValidationError is the validation error returned by +// TailLogsResponse.Validate if the designated constraints aren't met. +type TailLogsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TailLogsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TailLogsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TailLogsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TailLogsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TailLogsResponseValidationError) ErrorName() string { return "TailLogsResponseValidationError" } + +// Error satisfies the builtin error interface +func (e TailLogsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTailLogsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TailLogsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TailLogsResponseValidationError{} + +// Validate checks the field values on TailLogsResponse_Logs with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *TailLogsResponse_Logs) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TailLogsResponse_Logs with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// TailLogsResponse_LogsMultiError, or nil if none found. +func (m *TailLogsResponse_Logs) ValidateAll() error { + return m.validate(true) +} + +func (m *TailLogsResponse_Logs) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetLines() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TailLogsResponse_LogsValidationError{ + field: fmt.Sprintf("Lines[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TailLogsResponse_LogsValidationError{ + field: fmt.Sprintf("Lines[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TailLogsResponse_LogsValidationError{ + field: fmt.Sprintf("Lines[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return TailLogsResponse_LogsMultiError(errors) + } + + return nil +} + +// TailLogsResponse_LogsMultiError is an error wrapping multiple validation +// errors returned by TailLogsResponse_Logs.ValidateAll() if the designated +// constraints aren't met. +type TailLogsResponse_LogsMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TailLogsResponse_LogsMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TailLogsResponse_LogsMultiError) AllErrors() []error { return m } + +// TailLogsResponse_LogsValidationError is the validation error returned by +// TailLogsResponse_Logs.Validate if the designated constraints aren't met. +type TailLogsResponse_LogsValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TailLogsResponse_LogsValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TailLogsResponse_LogsValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TailLogsResponse_LogsValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TailLogsResponse_LogsValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TailLogsResponse_LogsValidationError) ErrorName() string { + return "TailLogsResponse_LogsValidationError" +} + +// Error satisfies the builtin error interface +func (e TailLogsResponse_LogsValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTailLogsResponse_Logs.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TailLogsResponse_LogsValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TailLogsResponse_LogsValidationError{} diff --git a/gen/go/flyteidl2/workflow/run_logs_service_grpc.pb.go b/gen/go/flyteidl2/workflow/run_logs_service_grpc.pb.go new file mode 100644 index 0000000000..4de648d3f7 --- /dev/null +++ b/gen/go/flyteidl2/workflow/run_logs_service_grpc.pb.go @@ -0,0 +1,134 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: flyteidl2/workflow/run_logs_service.proto + +package workflow + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + RunLogsService_TailLogs_FullMethodName = "/flyteidl2.workflow.RunLogsService/TailLogs" +) + +// RunLogsServiceClient is the client API for RunLogsService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type RunLogsServiceClient interface { + TailLogs(ctx context.Context, in *TailLogsRequest, opts ...grpc.CallOption) (RunLogsService_TailLogsClient, error) +} + +type runLogsServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewRunLogsServiceClient(cc grpc.ClientConnInterface) RunLogsServiceClient { + return &runLogsServiceClient{cc} +} + +func (c *runLogsServiceClient) TailLogs(ctx context.Context, in *TailLogsRequest, opts ...grpc.CallOption) (RunLogsService_TailLogsClient, error) { + stream, err := c.cc.NewStream(ctx, &RunLogsService_ServiceDesc.Streams[0], RunLogsService_TailLogs_FullMethodName, opts...) + if err != nil { + return nil, err + } + x := &runLogsServiceTailLogsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type RunLogsService_TailLogsClient interface { + Recv() (*TailLogsResponse, error) + grpc.ClientStream +} + +type runLogsServiceTailLogsClient struct { + grpc.ClientStream +} + +func (x *runLogsServiceTailLogsClient) Recv() (*TailLogsResponse, error) { + m := new(TailLogsResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// RunLogsServiceServer is the server API for RunLogsService service. +// All implementations should embed UnimplementedRunLogsServiceServer +// for forward compatibility +type RunLogsServiceServer interface { + TailLogs(*TailLogsRequest, RunLogsService_TailLogsServer) error +} + +// UnimplementedRunLogsServiceServer should be embedded to have forward compatible implementations. +type UnimplementedRunLogsServiceServer struct { +} + +func (UnimplementedRunLogsServiceServer) TailLogs(*TailLogsRequest, RunLogsService_TailLogsServer) error { + return status.Errorf(codes.Unimplemented, "method TailLogs not implemented") +} + +// UnsafeRunLogsServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to RunLogsServiceServer will +// result in compilation errors. +type UnsafeRunLogsServiceServer interface { + mustEmbedUnimplementedRunLogsServiceServer() +} + +func RegisterRunLogsServiceServer(s grpc.ServiceRegistrar, srv RunLogsServiceServer) { + s.RegisterService(&RunLogsService_ServiceDesc, srv) +} + +func _RunLogsService_TailLogs_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(TailLogsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(RunLogsServiceServer).TailLogs(m, &runLogsServiceTailLogsServer{stream}) +} + +type RunLogsService_TailLogsServer interface { + Send(*TailLogsResponse) error + grpc.ServerStream +} + +type runLogsServiceTailLogsServer struct { + grpc.ServerStream +} + +func (x *runLogsServiceTailLogsServer) Send(m *TailLogsResponse) error { + return x.ServerStream.SendMsg(m) +} + +// RunLogsService_ServiceDesc is the grpc.ServiceDesc for RunLogsService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var RunLogsService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.workflow.RunLogsService", + HandlerType: (*RunLogsServiceServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{ + { + StreamName: "TailLogs", + Handler: _RunLogsService_TailLogs_Handler, + ServerStreams: true, + }, + }, + Metadata: "flyteidl2/workflow/run_logs_service.proto", +} diff --git a/gen/go/flyteidl2/workflow/run_service.pb.go b/gen/go/flyteidl2/workflow/run_service.pb.go new file mode 100644 index 0000000000..e017e70c6e --- /dev/null +++ b/gen/go/flyteidl2/workflow/run_service.pb.go @@ -0,0 +1,2786 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/workflow/run_service.proto + +package workflow + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + task "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Request message for creating a run. +type CreateRunRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Id: + // + // *CreateRunRequest_RunId + // *CreateRunRequest_ProjectId + Id isCreateRunRequest_Id `protobuf_oneof:"id"` + // The task to run. + // + // Types that are assignable to Task: + // + // *CreateRunRequest_TaskId + // *CreateRunRequest_TaskSpec + // *CreateRunRequest_TriggerName + Task isCreateRunRequest_Task `protobuf_oneof:"task"` + // Inputs to use. + Inputs *task.Inputs `protobuf:"bytes,4,opt,name=inputs,proto3" json:"inputs,omitempty"` + // The run spec to use. + RunSpec *task.RunSpec `protobuf:"bytes,5,opt,name=run_spec,json=runSpec,proto3" json:"run_spec,omitempty"` + // Indicates client that created this run. + Source RunSource `protobuf:"varint,8,opt,name=source,proto3,enum=flyteidl2.workflow.RunSource" json:"source,omitempty"` +} + +func (x *CreateRunRequest) Reset() { + *x = CreateRunRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CreateRunRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateRunRequest) ProtoMessage() {} + +func (x *CreateRunRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateRunRequest.ProtoReflect.Descriptor instead. +func (*CreateRunRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{0} +} + +func (m *CreateRunRequest) GetId() isCreateRunRequest_Id { + if m != nil { + return m.Id + } + return nil +} + +func (x *CreateRunRequest) GetRunId() *common.RunIdentifier { + if x, ok := x.GetId().(*CreateRunRequest_RunId); ok { + return x.RunId + } + return nil +} + +func (x *CreateRunRequest) GetProjectId() *common.ProjectIdentifier { + if x, ok := x.GetId().(*CreateRunRequest_ProjectId); ok { + return x.ProjectId + } + return nil +} + +func (m *CreateRunRequest) GetTask() isCreateRunRequest_Task { + if m != nil { + return m.Task + } + return nil +} + +func (x *CreateRunRequest) GetTaskId() *task.TaskIdentifier { + if x, ok := x.GetTask().(*CreateRunRequest_TaskId); ok { + return x.TaskId + } + return nil +} + +func (x *CreateRunRequest) GetTaskSpec() *task.TaskSpec { + if x, ok := x.GetTask().(*CreateRunRequest_TaskSpec); ok { + return x.TaskSpec + } + return nil +} + +func (x *CreateRunRequest) GetTriggerName() *common.TriggerName { + if x, ok := x.GetTask().(*CreateRunRequest_TriggerName); ok { + return x.TriggerName + } + return nil +} + +func (x *CreateRunRequest) GetInputs() *task.Inputs { + if x != nil { + return x.Inputs + } + return nil +} + +func (x *CreateRunRequest) GetRunSpec() *task.RunSpec { + if x != nil { + return x.RunSpec + } + return nil +} + +func (x *CreateRunRequest) GetSource() RunSource { + if x != nil { + return x.Source + } + return RunSource_RUN_SOURCE_UNSPECIFIED +} + +type isCreateRunRequest_Id interface { + isCreateRunRequest_Id() +} + +type CreateRunRequest_RunId struct { + // The user provided run id. + RunId *common.RunIdentifier `protobuf:"bytes,1,opt,name=run_id,json=runId,proto3,oneof"` +} + +type CreateRunRequest_ProjectId struct { + // The project id for this run. Run name will be generated. + ProjectId *common.ProjectIdentifier `protobuf:"bytes,6,opt,name=project_id,json=projectId,proto3,oneof"` +} + +func (*CreateRunRequest_RunId) isCreateRunRequest_Id() {} + +func (*CreateRunRequest_ProjectId) isCreateRunRequest_Id() {} + +type isCreateRunRequest_Task interface { + isCreateRunRequest_Task() +} + +type CreateRunRequest_TaskId struct { + // The task id to use. + TaskId *task.TaskIdentifier `protobuf:"bytes,2,opt,name=task_id,json=taskId,proto3,oneof"` +} + +type CreateRunRequest_TaskSpec struct { + // The task spec to use. + TaskSpec *task.TaskSpec `protobuf:"bytes,3,opt,name=task_spec,json=taskSpec,proto3,oneof"` +} + +type CreateRunRequest_TriggerName struct { + // The trigger name to use. + TriggerName *common.TriggerName `protobuf:"bytes,7,opt,name=trigger_name,json=triggerName,proto3,oneof"` +} + +func (*CreateRunRequest_TaskId) isCreateRunRequest_Task() {} + +func (*CreateRunRequest_TaskSpec) isCreateRunRequest_Task() {} + +func (*CreateRunRequest_TriggerName) isCreateRunRequest_Task() {} + +// Response message for creating a run. +type CreateRunResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Run *Run `protobuf:"bytes,1,opt,name=run,proto3" json:"run,omitempty"` +} + +func (x *CreateRunResponse) Reset() { + *x = CreateRunResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CreateRunResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateRunResponse) ProtoMessage() {} + +func (x *CreateRunResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateRunResponse.ProtoReflect.Descriptor instead. +func (*CreateRunResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{1} +} + +func (x *CreateRunResponse) GetRun() *Run { + if x != nil { + return x.Run + } + return nil +} + +// Request message for aborting a run. +type AbortRunRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Run to abort. + RunId *common.RunIdentifier `protobuf:"bytes,1,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"` + // Reason for aborting the run. if applicable. + Reason *string `protobuf:"bytes,2,opt,name=reason,proto3,oneof" json:"reason,omitempty"` +} + +func (x *AbortRunRequest) Reset() { + *x = AbortRunRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AbortRunRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AbortRunRequest) ProtoMessage() {} + +func (x *AbortRunRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AbortRunRequest.ProtoReflect.Descriptor instead. +func (*AbortRunRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{2} +} + +func (x *AbortRunRequest) GetRunId() *common.RunIdentifier { + if x != nil { + return x.RunId + } + return nil +} + +func (x *AbortRunRequest) GetReason() string { + if x != nil && x.Reason != nil { + return *x.Reason + } + return "" +} + +// Response message for aborting a run. +type AbortRunResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *AbortRunResponse) Reset() { + *x = AbortRunResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AbortRunResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AbortRunResponse) ProtoMessage() {} + +func (x *AbortRunResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AbortRunResponse.ProtoReflect.Descriptor instead. +func (*AbortRunResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{3} +} + +// Request message for getting detailed information about a run. +type GetRunDetailsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Run to query. + RunId *common.RunIdentifier `protobuf:"bytes,1,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"` +} + +func (x *GetRunDetailsRequest) Reset() { + *x = GetRunDetailsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetRunDetailsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetRunDetailsRequest) ProtoMessage() {} + +func (x *GetRunDetailsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetRunDetailsRequest.ProtoReflect.Descriptor instead. +func (*GetRunDetailsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{4} +} + +func (x *GetRunDetailsRequest) GetRunId() *common.RunIdentifier { + if x != nil { + return x.RunId + } + return nil +} + +// Response message for getting detailed information about a run. +type GetRunDetailsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Detailed information about the run. + Details *RunDetails `protobuf:"bytes,1,opt,name=details,proto3" json:"details,omitempty"` +} + +func (x *GetRunDetailsResponse) Reset() { + *x = GetRunDetailsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetRunDetailsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetRunDetailsResponse) ProtoMessage() {} + +func (x *GetRunDetailsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetRunDetailsResponse.ProtoReflect.Descriptor instead. +func (*GetRunDetailsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{5} +} + +func (x *GetRunDetailsResponse) GetDetails() *RunDetails { + if x != nil { + return x.Details + } + return nil +} + +// Request message for watching detailed information about a run. +type WatchRunDetailsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Run to query. + RunId *common.RunIdentifier `protobuf:"bytes,1,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"` +} + +func (x *WatchRunDetailsRequest) Reset() { + *x = WatchRunDetailsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchRunDetailsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchRunDetailsRequest) ProtoMessage() {} + +func (x *WatchRunDetailsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchRunDetailsRequest.ProtoReflect.Descriptor instead. +func (*WatchRunDetailsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{6} +} + +func (x *WatchRunDetailsRequest) GetRunId() *common.RunIdentifier { + if x != nil { + return x.RunId + } + return nil +} + +// Response message for watching detailed information about a run. +type WatchRunDetailsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Detailed information about the run. + Details *RunDetails `protobuf:"bytes,1,opt,name=details,proto3" json:"details,omitempty"` +} + +func (x *WatchRunDetailsResponse) Reset() { + *x = WatchRunDetailsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchRunDetailsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchRunDetailsResponse) ProtoMessage() {} + +func (x *WatchRunDetailsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchRunDetailsResponse.ProtoReflect.Descriptor instead. +func (*WatchRunDetailsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{7} +} + +func (x *WatchRunDetailsResponse) GetDetails() *RunDetails { + if x != nil { + return x.Details + } + return nil +} + +// Request message for getting detailed information about an action. +type GetActionDetailsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Action to query. + ActionId *common.ActionIdentifier `protobuf:"bytes,1,opt,name=action_id,json=actionId,proto3" json:"action_id,omitempty"` +} + +func (x *GetActionDetailsRequest) Reset() { + *x = GetActionDetailsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetActionDetailsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetActionDetailsRequest) ProtoMessage() {} + +func (x *GetActionDetailsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetActionDetailsRequest.ProtoReflect.Descriptor instead. +func (*GetActionDetailsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{8} +} + +func (x *GetActionDetailsRequest) GetActionId() *common.ActionIdentifier { + if x != nil { + return x.ActionId + } + return nil +} + +// Response message for getting detailed information about an action. +type GetActionDetailsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Detailed information about the action. + Details *ActionDetails `protobuf:"bytes,1,opt,name=details,proto3" json:"details,omitempty"` +} + +func (x *GetActionDetailsResponse) Reset() { + *x = GetActionDetailsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetActionDetailsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetActionDetailsResponse) ProtoMessage() {} + +func (x *GetActionDetailsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetActionDetailsResponse.ProtoReflect.Descriptor instead. +func (*GetActionDetailsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{9} +} + +func (x *GetActionDetailsResponse) GetDetails() *ActionDetails { + if x != nil { + return x.Details + } + return nil +} + +// Request message for watching detailed information about an action. +type WatchActionDetailsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Action to query. + ActionId *common.ActionIdentifier `protobuf:"bytes,1,opt,name=action_id,json=actionId,proto3" json:"action_id,omitempty"` +} + +func (x *WatchActionDetailsRequest) Reset() { + *x = WatchActionDetailsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchActionDetailsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchActionDetailsRequest) ProtoMessage() {} + +func (x *WatchActionDetailsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchActionDetailsRequest.ProtoReflect.Descriptor instead. +func (*WatchActionDetailsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{10} +} + +func (x *WatchActionDetailsRequest) GetActionId() *common.ActionIdentifier { + if x != nil { + return x.ActionId + } + return nil +} + +// Response message for watching detailed information about an action. +type WatchActionDetailsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Detailed information about the action. + Details *ActionDetails `protobuf:"bytes,1,opt,name=details,proto3" json:"details,omitempty"` +} + +func (x *WatchActionDetailsResponse) Reset() { + *x = WatchActionDetailsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchActionDetailsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchActionDetailsResponse) ProtoMessage() {} + +func (x *WatchActionDetailsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchActionDetailsResponse.ProtoReflect.Descriptor instead. +func (*WatchActionDetailsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{11} +} + +func (x *WatchActionDetailsResponse) GetDetails() *ActionDetails { + if x != nil { + return x.Details + } + return nil +} + +// Request message for querying action data. +type GetActionDataRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Action to query. + ActionId *common.ActionIdentifier `protobuf:"bytes,1,opt,name=action_id,json=actionId,proto3" json:"action_id,omitempty"` +} + +func (x *GetActionDataRequest) Reset() { + *x = GetActionDataRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetActionDataRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetActionDataRequest) ProtoMessage() {} + +func (x *GetActionDataRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetActionDataRequest.ProtoReflect.Descriptor instead. +func (*GetActionDataRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{12} +} + +func (x *GetActionDataRequest) GetActionId() *common.ActionIdentifier { + if x != nil { + return x.ActionId + } + return nil +} + +// Response message for querying action data. +type GetActionDataResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Inputs for the action. + Inputs *task.Inputs `protobuf:"bytes,1,opt,name=inputs,proto3" json:"inputs,omitempty"` + // Outputs for the action. + Outputs *task.Outputs `protobuf:"bytes,2,opt,name=outputs,proto3" json:"outputs,omitempty"` +} + +func (x *GetActionDataResponse) Reset() { + *x = GetActionDataResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetActionDataResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetActionDataResponse) ProtoMessage() {} + +func (x *GetActionDataResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetActionDataResponse.ProtoReflect.Descriptor instead. +func (*GetActionDataResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{13} +} + +func (x *GetActionDataResponse) GetInputs() *task.Inputs { + if x != nil { + return x.Inputs + } + return nil +} + +func (x *GetActionDataResponse) GetOutputs() *task.Outputs { + if x != nil { + return x.Outputs + } + return nil +} + +// Request message for listing runs. +type ListRunsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Common list request parameters. + Request *common.ListRequest `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"` + // Types that are assignable to ScopeBy: + // + // *ListRunsRequest_Org + // *ListRunsRequest_ProjectId + // *ListRunsRequest_TriggerName + // *ListRunsRequest_TaskName + // *ListRunsRequest_TaskId + ScopeBy isListRunsRequest_ScopeBy `protobuf_oneof:"scope_by"` +} + +func (x *ListRunsRequest) Reset() { + *x = ListRunsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListRunsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListRunsRequest) ProtoMessage() {} + +func (x *ListRunsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListRunsRequest.ProtoReflect.Descriptor instead. +func (*ListRunsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{14} +} + +func (x *ListRunsRequest) GetRequest() *common.ListRequest { + if x != nil { + return x.Request + } + return nil +} + +func (m *ListRunsRequest) GetScopeBy() isListRunsRequest_ScopeBy { + if m != nil { + return m.ScopeBy + } + return nil +} + +func (x *ListRunsRequest) GetOrg() string { + if x, ok := x.GetScopeBy().(*ListRunsRequest_Org); ok { + return x.Org + } + return "" +} + +func (x *ListRunsRequest) GetProjectId() *common.ProjectIdentifier { + if x, ok := x.GetScopeBy().(*ListRunsRequest_ProjectId); ok { + return x.ProjectId + } + return nil +} + +func (x *ListRunsRequest) GetTriggerName() *common.TriggerName { + if x, ok := x.GetScopeBy().(*ListRunsRequest_TriggerName); ok { + return x.TriggerName + } + return nil +} + +func (x *ListRunsRequest) GetTaskName() *task.TaskName { + if x, ok := x.GetScopeBy().(*ListRunsRequest_TaskName); ok { + return x.TaskName + } + return nil +} + +func (x *ListRunsRequest) GetTaskId() *task.TaskIdentifier { + if x, ok := x.GetScopeBy().(*ListRunsRequest_TaskId); ok { + return x.TaskId + } + return nil +} + +type isListRunsRequest_ScopeBy interface { + isListRunsRequest_ScopeBy() +} + +type ListRunsRequest_Org struct { + // Organization name for filtering runs. + Org string `protobuf:"bytes,2,opt,name=org,proto3,oneof"` +} + +type ListRunsRequest_ProjectId struct { + // Project identifier for filtering runs. + ProjectId *common.ProjectIdentifier `protobuf:"bytes,4,opt,name=project_id,json=projectId,proto3,oneof"` +} + +type ListRunsRequest_TriggerName struct { + // List runs created from a trigger. + TriggerName *common.TriggerName `protobuf:"bytes,6,opt,name=trigger_name,json=triggerName,proto3,oneof"` +} + +type ListRunsRequest_TaskName struct { + // Task name for filtering runs + TaskName *task.TaskName `protobuf:"bytes,7,opt,name=task_name,json=taskName,proto3,oneof"` +} + +type ListRunsRequest_TaskId struct { + // Task identifier for filtering runs + TaskId *task.TaskIdentifier `protobuf:"bytes,8,opt,name=task_id,json=taskId,proto3,oneof"` +} + +func (*ListRunsRequest_Org) isListRunsRequest_ScopeBy() {} + +func (*ListRunsRequest_ProjectId) isListRunsRequest_ScopeBy() {} + +func (*ListRunsRequest_TriggerName) isListRunsRequest_ScopeBy() {} + +func (*ListRunsRequest_TaskName) isListRunsRequest_ScopeBy() {} + +func (*ListRunsRequest_TaskId) isListRunsRequest_ScopeBy() {} + +// Response message for listing runs. +type ListRunsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // List of runs matching the filter criteria. + Runs []*Run `protobuf:"bytes,1,rep,name=runs,proto3" json:"runs,omitempty"` + // Token for fetching the next page of results, if any. + Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"` +} + +func (x *ListRunsResponse) Reset() { + *x = ListRunsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListRunsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListRunsResponse) ProtoMessage() {} + +func (x *ListRunsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListRunsResponse.ProtoReflect.Descriptor instead. +func (*ListRunsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{15} +} + +func (x *ListRunsResponse) GetRuns() []*Run { + if x != nil { + return x.Runs + } + return nil +} + +func (x *ListRunsResponse) GetToken() string { + if x != nil { + return x.Token + } + return "" +} + +// Request message for watching runs. +type WatchRunsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Target: + // + // *WatchRunsRequest_Org + // *WatchRunsRequest_ClusterId + // *WatchRunsRequest_ProjectId + // *WatchRunsRequest_TaskId + Target isWatchRunsRequest_Target `protobuf_oneof:"target"` +} + +func (x *WatchRunsRequest) Reset() { + *x = WatchRunsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchRunsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchRunsRequest) ProtoMessage() {} + +func (x *WatchRunsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[16] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchRunsRequest.ProtoReflect.Descriptor instead. +func (*WatchRunsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{16} +} + +func (m *WatchRunsRequest) GetTarget() isWatchRunsRequest_Target { + if m != nil { + return m.Target + } + return nil +} + +func (x *WatchRunsRequest) GetOrg() string { + if x, ok := x.GetTarget().(*WatchRunsRequest_Org); ok { + return x.Org + } + return "" +} + +func (x *WatchRunsRequest) GetClusterId() *common.ClusterIdentifier { + if x, ok := x.GetTarget().(*WatchRunsRequest_ClusterId); ok { + return x.ClusterId + } + return nil +} + +func (x *WatchRunsRequest) GetProjectId() *common.ProjectIdentifier { + if x, ok := x.GetTarget().(*WatchRunsRequest_ProjectId); ok { + return x.ProjectId + } + return nil +} + +func (x *WatchRunsRequest) GetTaskId() *task.TaskIdentifier { + if x, ok := x.GetTarget().(*WatchRunsRequest_TaskId); ok { + return x.TaskId + } + return nil +} + +type isWatchRunsRequest_Target interface { + isWatchRunsRequest_Target() +} + +type WatchRunsRequest_Org struct { + // Organization name for filtering runs. + Org string `protobuf:"bytes,2,opt,name=org,proto3,oneof"` +} + +type WatchRunsRequest_ClusterId struct { + // Cluster identifier for filtering runs. + ClusterId *common.ClusterIdentifier `protobuf:"bytes,3,opt,name=cluster_id,json=clusterId,proto3,oneof"` +} + +type WatchRunsRequest_ProjectId struct { + // Project identifier for filtering runs. + ProjectId *common.ProjectIdentifier `protobuf:"bytes,4,opt,name=project_id,json=projectId,proto3,oneof"` +} + +type WatchRunsRequest_TaskId struct { + // Task identifier for filtering runs. + TaskId *task.TaskIdentifier `protobuf:"bytes,5,opt,name=task_id,json=taskId,proto3,oneof"` +} + +func (*WatchRunsRequest_Org) isWatchRunsRequest_Target() {} + +func (*WatchRunsRequest_ClusterId) isWatchRunsRequest_Target() {} + +func (*WatchRunsRequest_ProjectId) isWatchRunsRequest_Target() {} + +func (*WatchRunsRequest_TaskId) isWatchRunsRequest_Target() {} + +// Response message for watching runs. +type WatchRunsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // New or updated runs matching the filter criteria. + Runs []*Run `protobuf:"bytes,1,rep,name=runs,proto3" json:"runs,omitempty"` +} + +func (x *WatchRunsResponse) Reset() { + *x = WatchRunsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchRunsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchRunsResponse) ProtoMessage() {} + +func (x *WatchRunsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchRunsResponse.ProtoReflect.Descriptor instead. +func (*WatchRunsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{17} +} + +func (x *WatchRunsResponse) GetRuns() []*Run { + if x != nil { + return x.Runs + } + return nil +} + +// Request message for listing actions. +type ListActionsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Common list request parameters. + Request *common.ListRequest `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"` + // Run identifier for filtering actions. + RunId *common.RunIdentifier `protobuf:"bytes,2,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"` +} + +func (x *ListActionsRequest) Reset() { + *x = ListActionsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListActionsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListActionsRequest) ProtoMessage() {} + +func (x *ListActionsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[18] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListActionsRequest.ProtoReflect.Descriptor instead. +func (*ListActionsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{18} +} + +func (x *ListActionsRequest) GetRequest() *common.ListRequest { + if x != nil { + return x.Request + } + return nil +} + +func (x *ListActionsRequest) GetRunId() *common.RunIdentifier { + if x != nil { + return x.RunId + } + return nil +} + +// Response message for listing actions. +type ListActionsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // List of actions matching the filter criteria. + Actions []*Action `protobuf:"bytes,1,rep,name=actions,proto3" json:"actions,omitempty"` + // Token for fetching the next page of results, if any. + Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"` +} + +func (x *ListActionsResponse) Reset() { + *x = ListActionsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ListActionsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListActionsResponse) ProtoMessage() {} + +func (x *ListActionsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[19] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListActionsResponse.ProtoReflect.Descriptor instead. +func (*ListActionsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{19} +} + +func (x *ListActionsResponse) GetActions() []*Action { + if x != nil { + return x.Actions + } + return nil +} + +func (x *ListActionsResponse) GetToken() string { + if x != nil { + return x.Token + } + return "" +} + +// Request message for watching actions. +type WatchActionsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Run identifier for filtering actions. + RunId *common.RunIdentifier `protobuf:"bytes,1,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"` + // Optional filter(s) criteria for actions. + // Valid filter fields include: + // - NAME (must use function CONTAINS_CASE_INSENSITIVE): the value is whatever string to match to. This will cast all strings to lowercase and match. + // - PHASE (must use function VALUE_IN): the value is the stringified integer of the enum of the phase and you can pass multiple phases (i.e. ["1", "4"]) + Filter []*common.Filter `protobuf:"bytes,2,rep,name=filter,proto3" json:"filter,omitempty"` +} + +func (x *WatchActionsRequest) Reset() { + *x = WatchActionsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchActionsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchActionsRequest) ProtoMessage() {} + +func (x *WatchActionsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[20] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchActionsRequest.ProtoReflect.Descriptor instead. +func (*WatchActionsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{20} +} + +func (x *WatchActionsRequest) GetRunId() *common.RunIdentifier { + if x != nil { + return x.RunId + } + return nil +} + +func (x *WatchActionsRequest) GetFilter() []*common.Filter { + if x != nil { + return x.Filter + } + return nil +} + +// Response message for watching actions, comes with enriched action metadata. +type WatchActionsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // New or updated actions matching the filter criteria. Enriched with children status counts + EnrichedActions []*EnrichedAction `protobuf:"bytes,1,rep,name=enriched_actions,json=enrichedActions,proto3" json:"enriched_actions,omitempty"` +} + +func (x *WatchActionsResponse) Reset() { + *x = WatchActionsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchActionsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchActionsResponse) ProtoMessage() {} + +func (x *WatchActionsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[21] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchActionsResponse.ProtoReflect.Descriptor instead. +func (*WatchActionsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{21} +} + +func (x *WatchActionsResponse) GetEnrichedActions() []*EnrichedAction { + if x != nil { + return x.EnrichedActions + } + return nil +} + +type WatchClusterEventsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id *common.ActionIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Attempt uint32 `protobuf:"varint,2,opt,name=attempt,proto3" json:"attempt,omitempty"` +} + +func (x *WatchClusterEventsRequest) Reset() { + *x = WatchClusterEventsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchClusterEventsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchClusterEventsRequest) ProtoMessage() {} + +func (x *WatchClusterEventsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[22] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchClusterEventsRequest.ProtoReflect.Descriptor instead. +func (*WatchClusterEventsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{22} +} + +func (x *WatchClusterEventsRequest) GetId() *common.ActionIdentifier { + if x != nil { + return x.Id + } + return nil +} + +func (x *WatchClusterEventsRequest) GetAttempt() uint32 { + if x != nil { + return x.Attempt + } + return 0 +} + +type WatchClusterEventsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ClusterEvents []*ClusterEvent `protobuf:"bytes,1,rep,name=cluster_events,json=clusterEvents,proto3" json:"cluster_events,omitempty"` +} + +func (x *WatchClusterEventsResponse) Reset() { + *x = WatchClusterEventsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchClusterEventsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchClusterEventsResponse) ProtoMessage() {} + +func (x *WatchClusterEventsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[23] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchClusterEventsResponse.ProtoReflect.Descriptor instead. +func (*WatchClusterEventsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{23} +} + +func (x *WatchClusterEventsResponse) GetClusterEvents() []*ClusterEvent { + if x != nil { + return x.ClusterEvents + } + return nil +} + +type AbortActionRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Action to abort. + ActionId *common.ActionIdentifier `protobuf:"bytes,1,opt,name=action_id,json=actionId,proto3" json:"action_id,omitempty"` + // Optional reason for aborting the action. + Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"` +} + +func (x *AbortActionRequest) Reset() { + *x = AbortActionRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AbortActionRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AbortActionRequest) ProtoMessage() {} + +func (x *AbortActionRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[24] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AbortActionRequest.ProtoReflect.Descriptor instead. +func (*AbortActionRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{24} +} + +func (x *AbortActionRequest) GetActionId() *common.ActionIdentifier { + if x != nil { + return x.ActionId + } + return nil +} + +func (x *AbortActionRequest) GetReason() string { + if x != nil { + return x.Reason + } + return "" +} + +type AbortActionResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *AbortActionResponse) Reset() { + *x = AbortActionResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AbortActionResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AbortActionResponse) ProtoMessage() {} + +func (x *AbortActionResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[25] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AbortActionResponse.ProtoReflect.Descriptor instead. +func (*AbortActionResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{25} +} + +type WatchGroupsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to ScopeBy: + // + // *WatchGroupsRequest_ProjectId + ScopeBy isWatchGroupsRequest_ScopeBy `protobuf_oneof:"scope_by"` + // Filter groups after this date (inclusive). Required. + StartDate *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=start_date,json=startDate,proto3" json:"start_date,omitempty"` + // Filter groups before this date (inclusive). + // If null, will stream updates up to current time. + // If not null, will return groups once and close stream. + EndDate *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=end_date,json=endDate,proto3" json:"end_date,omitempty"` + // Common list request parameters. + Request *common.ListRequest `protobuf:"bytes,4,opt,name=request,proto3" json:"request,omitempty"` + // Known sort fields in watch group + KnownSortFields []*WatchGroupsRequest_KnownSortField `protobuf:"bytes,5,rep,name=known_sort_fields,json=knownSortFields,proto3" json:"known_sort_fields,omitempty"` +} + +func (x *WatchGroupsRequest) Reset() { + *x = WatchGroupsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchGroupsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchGroupsRequest) ProtoMessage() {} + +func (x *WatchGroupsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[26] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchGroupsRequest.ProtoReflect.Descriptor instead. +func (*WatchGroupsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{26} +} + +func (m *WatchGroupsRequest) GetScopeBy() isWatchGroupsRequest_ScopeBy { + if m != nil { + return m.ScopeBy + } + return nil +} + +func (x *WatchGroupsRequest) GetProjectId() *common.ProjectIdentifier { + if x, ok := x.GetScopeBy().(*WatchGroupsRequest_ProjectId); ok { + return x.ProjectId + } + return nil +} + +func (x *WatchGroupsRequest) GetStartDate() *timestamppb.Timestamp { + if x != nil { + return x.StartDate + } + return nil +} + +func (x *WatchGroupsRequest) GetEndDate() *timestamppb.Timestamp { + if x != nil { + return x.EndDate + } + return nil +} + +func (x *WatchGroupsRequest) GetRequest() *common.ListRequest { + if x != nil { + return x.Request + } + return nil +} + +func (x *WatchGroupsRequest) GetKnownSortFields() []*WatchGroupsRequest_KnownSortField { + if x != nil { + return x.KnownSortFields + } + return nil +} + +type isWatchGroupsRequest_ScopeBy interface { + isWatchGroupsRequest_ScopeBy() +} + +type WatchGroupsRequest_ProjectId struct { + // Watch groups within a project. + ProjectId *common.ProjectIdentifier `protobuf:"bytes,1,opt,name=project_id,json=projectId,proto3,oneof"` +} + +func (*WatchGroupsRequest_ProjectId) isWatchGroupsRequest_ScopeBy() {} + +// Response message for watching task groups. +type WatchGroupsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // List of task groups matching the filter criteria. + // For the initial response, this contains all groups. + // For subsequent updates, this contains only changed groups. + TaskGroups []*TaskGroup `protobuf:"bytes,1,rep,name=task_groups,json=taskGroups,proto3" json:"task_groups,omitempty"` + // Indicates when the initial List call is complete, and subsequent messages are updates. + Sentinel bool `protobuf:"varint,2,opt,name=sentinel,proto3" json:"sentinel,omitempty"` +} + +func (x *WatchGroupsResponse) Reset() { + *x = WatchGroupsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchGroupsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchGroupsResponse) ProtoMessage() {} + +func (x *WatchGroupsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[27] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchGroupsResponse.ProtoReflect.Descriptor instead. +func (*WatchGroupsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{27} +} + +func (x *WatchGroupsResponse) GetTaskGroups() []*TaskGroup { + if x != nil { + return x.TaskGroups + } + return nil +} + +func (x *WatchGroupsResponse) GetSentinel() bool { + if x != nil { + return x.Sentinel + } + return false +} + +type WatchGroupsRequest_KnownSortField struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to SortBy: + // + // *WatchGroupsRequest_KnownSortField_CreatedAt + SortBy isWatchGroupsRequest_KnownSortField_SortBy `protobuf_oneof:"sort_by"` +} + +func (x *WatchGroupsRequest_KnownSortField) Reset() { + *x = WatchGroupsRequest_KnownSortField{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchGroupsRequest_KnownSortField) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchGroupsRequest_KnownSortField) ProtoMessage() {} + +func (x *WatchGroupsRequest_KnownSortField) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_run_service_proto_msgTypes[28] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchGroupsRequest_KnownSortField.ProtoReflect.Descriptor instead. +func (*WatchGroupsRequest_KnownSortField) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_run_service_proto_rawDescGZIP(), []int{26, 0} +} + +func (m *WatchGroupsRequest_KnownSortField) GetSortBy() isWatchGroupsRequest_KnownSortField_SortBy { + if m != nil { + return m.SortBy + } + return nil +} + +func (x *WatchGroupsRequest_KnownSortField) GetCreatedAt() common.Sort_Direction { + if x, ok := x.GetSortBy().(*WatchGroupsRequest_KnownSortField_CreatedAt); ok { + return x.CreatedAt + } + return common.Sort_Direction(0) +} + +type isWatchGroupsRequest_KnownSortField_SortBy interface { + isWatchGroupsRequest_KnownSortField_SortBy() +} + +type WatchGroupsRequest_KnownSortField_CreatedAt struct { + CreatedAt common.Sort_Direction `protobuf:"varint,1,opt,name=created_at,json=createdAt,proto3,enum=flyteidl2.common.Sort_Direction,oneof"` +} + +func (*WatchGroupsRequest_KnownSortField_CreatedAt) isWatchGroupsRequest_KnownSortField_SortBy() {} + +var File_flyteidl2_workflow_run_service_proto protoreflect.FileDescriptor + +var file_flyteidl2_workflow_run_service_proto_rawDesc = []byte{ + 0x0a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x72, 0x75, 0x6e, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x6c, 0x69, 0x73, + 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x18, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x72, 0x75, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x74, + 0x61, 0x73, 0x6b, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x27, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x72, 0x75, 0x6e, 0x5f, 0x64, 0x65, 0x66, + 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x81, + 0x04, 0x0a, 0x10, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x75, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x12, 0x44, 0x0a, + 0x0a, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x49, 0x64, 0x12, 0x39, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x48, 0x01, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x12, 0x37, + 0x0a, 0x09, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, + 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x48, 0x01, 0x52, 0x08, 0x74, + 0x61, 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x12, 0x42, 0x0a, 0x0c, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x48, 0x01, 0x52, 0x0b, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x2e, 0x0a, 0x06, 0x69, + 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x49, 0x6e, 0x70, + 0x75, 0x74, 0x73, 0x52, 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x12, 0x32, 0x0a, 0x08, 0x72, + 0x75, 0x6e, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x52, + 0x75, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x52, 0x07, 0x72, 0x75, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x12, + 0x35, 0x0a, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x06, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x42, 0x0b, 0x0a, 0x02, 0x69, 0x64, 0x12, 0x05, 0xba, 0x48, + 0x02, 0x08, 0x01, 0x42, 0x0d, 0x0a, 0x04, 0x74, 0x61, 0x73, 0x6b, 0x12, 0x05, 0xba, 0x48, 0x02, + 0x08, 0x01, 0x22, 0x3e, 0x0a, 0x11, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6e, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x03, 0x72, 0x75, 0x6e, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x52, 0x03, 0x72, + 0x75, 0x6e, 0x22, 0x79, 0x0a, 0x0f, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x52, 0x75, 0x6e, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3e, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x75, 0x6e, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x05, + 0x72, 0x75, 0x6e, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x88, + 0x01, 0x01, 0x42, 0x09, 0x0a, 0x07, 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x22, 0x12, 0x0a, + 0x10, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x56, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3e, 0x0a, 0x06, 0x72, 0x75, 0x6e, + 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x75, 0x6e, + 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, + 0x01, 0x01, 0x52, 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x22, 0x51, 0x0a, 0x15, 0x47, 0x65, 0x74, + 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x38, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x58, 0x0a, 0x16, + 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3e, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x75, 0x6e, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, + 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x22, 0x53, 0x0a, 0x17, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, + 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x38, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x62, 0x0a, 0x17, 0x47, + 0x65, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, + 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, + 0x57, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x07, 0x64, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, + 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x64, 0x0a, 0x19, 0x57, 0x61, 0x74, 0x63, + 0x68, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, + 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x59, + 0x0a, 0x1a, 0x57, 0x61, 0x74, 0x63, 0x68, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x07, + 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x5f, 0x0a, 0x14, 0x47, 0x65, 0x74, + 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, + 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x7a, 0x0a, 0x15, 0x47, 0x65, + 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x2e, 0x0a, 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x52, 0x06, 0x69, 0x6e, 0x70, + 0x75, 0x74, 0x73, 0x12, 0x31, 0x0a, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x52, 0x07, 0x6f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x22, 0x84, 0x03, 0x0a, 0x0f, 0x4c, 0x69, 0x73, 0x74, 0x52, + 0x75, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x37, 0x0a, 0x07, 0x72, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4c, + 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, 0x03, 0x6f, 0x72, 0x67, + 0x12, 0x44, 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x09, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x12, 0x42, 0x0a, 0x0c, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x09, 0x74, 0x61, + 0x73, 0x6b, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, + 0x61, 0x73, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x48, 0x00, 0x52, 0x08, 0x74, 0x61, 0x73, 0x6b, 0x4e, + 0x61, 0x6d, 0x65, 0x12, 0x39, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x42, 0x11, + 0x0a, 0x08, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x5f, 0x62, 0x79, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, + 0x01, 0x4a, 0x04, 0x08, 0x03, 0x10, 0x04, 0x4a, 0x04, 0x08, 0x05, 0x10, 0x06, 0x22, 0x55, 0x0a, + 0x10, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x2b, 0x0a, 0x04, 0x72, 0x75, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x52, 0x04, 0x72, 0x75, 0x6e, 0x73, 0x12, 0x14, + 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, + 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x87, 0x02, 0x0a, 0x10, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x75, + 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x03, 0x6f, 0x72, 0x67, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x48, + 0x00, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x44, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x43, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, + 0x00, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x44, 0x0a, 0x0a, + 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x49, 0x64, 0x12, 0x39, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x42, 0x0f, 0x0a, + 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, 0x40, + 0x0a, 0x11, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x75, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x04, 0x72, 0x75, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x52, 0x04, 0x72, 0x75, 0x6e, 0x73, + 0x22, 0x8d, 0x01, 0x0a, 0x12, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x37, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4c, 0x69, 0x73, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x3e, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x75, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, + 0x22, 0x61, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x07, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x14, 0x0a, + 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x22, 0x87, 0x01, 0x0a, 0x13, 0x57, 0x61, 0x74, 0x63, 0x68, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3e, 0x0a, 0x06, 0x72, + 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, + 0x75, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, + 0x03, 0xc8, 0x01, 0x01, 0x52, 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x12, 0x30, 0x0a, 0x06, 0x66, + 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x46, + 0x69, 0x6c, 0x74, 0x65, 0x72, 0x52, 0x06, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x65, 0x0a, + 0x14, 0x57, 0x61, 0x74, 0x63, 0x68, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4d, 0x0a, 0x10, 0x65, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, + 0x64, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x0f, 0x65, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x7a, 0x0a, 0x19, 0x57, 0x61, 0x74, 0x63, 0x68, 0x43, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x3a, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0x21, 0x0a, + 0x07, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, + 0xba, 0x48, 0x04, 0x2a, 0x02, 0x20, 0x00, 0x52, 0x07, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, + 0x22, 0x65, 0x0a, 0x1a, 0x57, 0x61, 0x74, 0x63, 0x68, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, + 0x0a, 0x0e, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x43, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x0d, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x75, 0x0a, 0x12, 0x41, 0x62, 0x6f, 0x72, 0x74, + 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x47, 0x0a, + 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x22, 0x15, + 0x0a, 0x13, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xe3, 0x03, 0x0a, 0x12, 0x57, 0x61, 0x74, 0x63, 0x68, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x44, 0x0a, 0x0a, + 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x49, 0x64, 0x12, 0x41, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x44, 0x61, 0x74, 0x65, 0x12, 0x35, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x64, 0x61, 0x74, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x44, 0x61, 0x74, 0x65, 0x12, 0x37, 0x0a, 0x07, + 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x07, 0x72, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x61, 0x0a, 0x11, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x5f, 0x73, + 0x6f, 0x72, 0x74, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x35, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x53, 0x6f, + 0x72, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x52, 0x0f, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x53, 0x6f, + 0x72, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x1a, 0x5e, 0x0a, 0x0e, 0x4b, 0x6e, 0x6f, 0x77, + 0x6e, 0x53, 0x6f, 0x72, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x41, 0x0a, 0x0a, 0x63, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x53, 0x6f, 0x72, 0x74, 0x2e, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x48, 0x00, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x42, 0x09, 0x0a, + 0x07, 0x73, 0x6f, 0x72, 0x74, 0x5f, 0x62, 0x79, 0x42, 0x11, 0x0a, 0x08, 0x73, 0x63, 0x6f, 0x70, + 0x65, 0x5f, 0x62, 0x79, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, 0x71, 0x0a, 0x13, 0x57, + 0x61, 0x74, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0b, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x61, 0x73, + 0x6b, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x32, 0xb9, + 0x0b, 0x0a, 0x0a, 0x52, 0x75, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x5a, 0x0a, + 0x09, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6e, 0x12, 0x24, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6e, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x08, 0x41, 0x62, 0x6f, + 0x72, 0x74, 0x52, 0x75, 0x6e, 0x12, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, + 0x52, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, + 0x41, 0x62, 0x6f, 0x72, 0x74, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x00, 0x12, 0x69, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x12, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6e, 0x44, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x6e, 0x0a, + 0x0f, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x12, 0x2a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x75, 0x6e, 0x44, 0x65, + 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x72, 0x0a, + 0x10, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x12, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, + 0x01, 0x12, 0x77, 0x0a, 0x12, 0x57, 0x61, 0x74, 0x63, 0x68, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x2d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, + 0x63, 0x68, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, + 0x68, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x69, 0x0a, 0x0d, 0x47, 0x65, + 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x12, 0x28, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x2e, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x5a, 0x0a, 0x08, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6e, + 0x73, 0x12, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6e, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x4c, 0x69, 0x73, 0x74, + 0x52, 0x75, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, + 0x01, 0x12, 0x5c, 0x0a, 0x09, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x75, 0x6e, 0x73, 0x12, 0x24, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x75, 0x6e, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, + 0x75, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, + 0x63, 0x0a, 0x0b, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x26, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x4c, 0x69, 0x73, 0x74, + 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x03, 0x90, 0x02, 0x01, 0x12, 0x65, 0x0a, 0x0c, 0x57, 0x61, 0x74, 0x63, 0x68, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x41, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x77, 0x0a, 0x12, 0x57, + 0x61, 0x74, 0x63, 0x68, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, + 0x73, 0x12, 0x2d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x43, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x2e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x43, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x00, 0x30, 0x01, 0x12, 0x60, 0x0a, 0x0b, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x62, 0x0a, 0x0b, 0x57, 0x61, 0x74, 0x63, 0x68, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x73, 0x12, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x42, 0xcc, 0x01, 0x0a, 0x16, 0x63, + 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x0f, 0x52, 0x75, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, 0x36, 0x67, 0x69, 0x74, 0x68, + 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0xa2, 0x02, 0x03, 0x46, 0x57, 0x58, 0xaa, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xca, 0x02, 0x12, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0xe2, 0x02, 0x1e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x57, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0xea, 0x02, 0x13, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, + 0x3a, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, +} + +var ( + file_flyteidl2_workflow_run_service_proto_rawDescOnce sync.Once + file_flyteidl2_workflow_run_service_proto_rawDescData = file_flyteidl2_workflow_run_service_proto_rawDesc +) + +func file_flyteidl2_workflow_run_service_proto_rawDescGZIP() []byte { + file_flyteidl2_workflow_run_service_proto_rawDescOnce.Do(func() { + file_flyteidl2_workflow_run_service_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_workflow_run_service_proto_rawDescData) + }) + return file_flyteidl2_workflow_run_service_proto_rawDescData +} + +var file_flyteidl2_workflow_run_service_proto_msgTypes = make([]protoimpl.MessageInfo, 29) +var file_flyteidl2_workflow_run_service_proto_goTypes = []interface{}{ + (*CreateRunRequest)(nil), // 0: flyteidl2.workflow.CreateRunRequest + (*CreateRunResponse)(nil), // 1: flyteidl2.workflow.CreateRunResponse + (*AbortRunRequest)(nil), // 2: flyteidl2.workflow.AbortRunRequest + (*AbortRunResponse)(nil), // 3: flyteidl2.workflow.AbortRunResponse + (*GetRunDetailsRequest)(nil), // 4: flyteidl2.workflow.GetRunDetailsRequest + (*GetRunDetailsResponse)(nil), // 5: flyteidl2.workflow.GetRunDetailsResponse + (*WatchRunDetailsRequest)(nil), // 6: flyteidl2.workflow.WatchRunDetailsRequest + (*WatchRunDetailsResponse)(nil), // 7: flyteidl2.workflow.WatchRunDetailsResponse + (*GetActionDetailsRequest)(nil), // 8: flyteidl2.workflow.GetActionDetailsRequest + (*GetActionDetailsResponse)(nil), // 9: flyteidl2.workflow.GetActionDetailsResponse + (*WatchActionDetailsRequest)(nil), // 10: flyteidl2.workflow.WatchActionDetailsRequest + (*WatchActionDetailsResponse)(nil), // 11: flyteidl2.workflow.WatchActionDetailsResponse + (*GetActionDataRequest)(nil), // 12: flyteidl2.workflow.GetActionDataRequest + (*GetActionDataResponse)(nil), // 13: flyteidl2.workflow.GetActionDataResponse + (*ListRunsRequest)(nil), // 14: flyteidl2.workflow.ListRunsRequest + (*ListRunsResponse)(nil), // 15: flyteidl2.workflow.ListRunsResponse + (*WatchRunsRequest)(nil), // 16: flyteidl2.workflow.WatchRunsRequest + (*WatchRunsResponse)(nil), // 17: flyteidl2.workflow.WatchRunsResponse + (*ListActionsRequest)(nil), // 18: flyteidl2.workflow.ListActionsRequest + (*ListActionsResponse)(nil), // 19: flyteidl2.workflow.ListActionsResponse + (*WatchActionsRequest)(nil), // 20: flyteidl2.workflow.WatchActionsRequest + (*WatchActionsResponse)(nil), // 21: flyteidl2.workflow.WatchActionsResponse + (*WatchClusterEventsRequest)(nil), // 22: flyteidl2.workflow.WatchClusterEventsRequest + (*WatchClusterEventsResponse)(nil), // 23: flyteidl2.workflow.WatchClusterEventsResponse + (*AbortActionRequest)(nil), // 24: flyteidl2.workflow.AbortActionRequest + (*AbortActionResponse)(nil), // 25: flyteidl2.workflow.AbortActionResponse + (*WatchGroupsRequest)(nil), // 26: flyteidl2.workflow.WatchGroupsRequest + (*WatchGroupsResponse)(nil), // 27: flyteidl2.workflow.WatchGroupsResponse + (*WatchGroupsRequest_KnownSortField)(nil), // 28: flyteidl2.workflow.WatchGroupsRequest.KnownSortField + (*common.RunIdentifier)(nil), // 29: flyteidl2.common.RunIdentifier + (*common.ProjectIdentifier)(nil), // 30: flyteidl2.common.ProjectIdentifier + (*task.TaskIdentifier)(nil), // 31: flyteidl2.task.TaskIdentifier + (*task.TaskSpec)(nil), // 32: flyteidl2.task.TaskSpec + (*common.TriggerName)(nil), // 33: flyteidl2.common.TriggerName + (*task.Inputs)(nil), // 34: flyteidl2.task.Inputs + (*task.RunSpec)(nil), // 35: flyteidl2.task.RunSpec + (RunSource)(0), // 36: flyteidl2.workflow.RunSource + (*Run)(nil), // 37: flyteidl2.workflow.Run + (*RunDetails)(nil), // 38: flyteidl2.workflow.RunDetails + (*common.ActionIdentifier)(nil), // 39: flyteidl2.common.ActionIdentifier + (*ActionDetails)(nil), // 40: flyteidl2.workflow.ActionDetails + (*task.Outputs)(nil), // 41: flyteidl2.task.Outputs + (*common.ListRequest)(nil), // 42: flyteidl2.common.ListRequest + (*task.TaskName)(nil), // 43: flyteidl2.task.TaskName + (*common.ClusterIdentifier)(nil), // 44: flyteidl2.common.ClusterIdentifier + (*Action)(nil), // 45: flyteidl2.workflow.Action + (*common.Filter)(nil), // 46: flyteidl2.common.Filter + (*EnrichedAction)(nil), // 47: flyteidl2.workflow.EnrichedAction + (*ClusterEvent)(nil), // 48: flyteidl2.workflow.ClusterEvent + (*timestamppb.Timestamp)(nil), // 49: google.protobuf.Timestamp + (*TaskGroup)(nil), // 50: flyteidl2.workflow.TaskGroup + (common.Sort_Direction)(0), // 51: flyteidl2.common.Sort.Direction +} +var file_flyteidl2_workflow_run_service_proto_depIdxs = []int32{ + 29, // 0: flyteidl2.workflow.CreateRunRequest.run_id:type_name -> flyteidl2.common.RunIdentifier + 30, // 1: flyteidl2.workflow.CreateRunRequest.project_id:type_name -> flyteidl2.common.ProjectIdentifier + 31, // 2: flyteidl2.workflow.CreateRunRequest.task_id:type_name -> flyteidl2.task.TaskIdentifier + 32, // 3: flyteidl2.workflow.CreateRunRequest.task_spec:type_name -> flyteidl2.task.TaskSpec + 33, // 4: flyteidl2.workflow.CreateRunRequest.trigger_name:type_name -> flyteidl2.common.TriggerName + 34, // 5: flyteidl2.workflow.CreateRunRequest.inputs:type_name -> flyteidl2.task.Inputs + 35, // 6: flyteidl2.workflow.CreateRunRequest.run_spec:type_name -> flyteidl2.task.RunSpec + 36, // 7: flyteidl2.workflow.CreateRunRequest.source:type_name -> flyteidl2.workflow.RunSource + 37, // 8: flyteidl2.workflow.CreateRunResponse.run:type_name -> flyteidl2.workflow.Run + 29, // 9: flyteidl2.workflow.AbortRunRequest.run_id:type_name -> flyteidl2.common.RunIdentifier + 29, // 10: flyteidl2.workflow.GetRunDetailsRequest.run_id:type_name -> flyteidl2.common.RunIdentifier + 38, // 11: flyteidl2.workflow.GetRunDetailsResponse.details:type_name -> flyteidl2.workflow.RunDetails + 29, // 12: flyteidl2.workflow.WatchRunDetailsRequest.run_id:type_name -> flyteidl2.common.RunIdentifier + 38, // 13: flyteidl2.workflow.WatchRunDetailsResponse.details:type_name -> flyteidl2.workflow.RunDetails + 39, // 14: flyteidl2.workflow.GetActionDetailsRequest.action_id:type_name -> flyteidl2.common.ActionIdentifier + 40, // 15: flyteidl2.workflow.GetActionDetailsResponse.details:type_name -> flyteidl2.workflow.ActionDetails + 39, // 16: flyteidl2.workflow.WatchActionDetailsRequest.action_id:type_name -> flyteidl2.common.ActionIdentifier + 40, // 17: flyteidl2.workflow.WatchActionDetailsResponse.details:type_name -> flyteidl2.workflow.ActionDetails + 39, // 18: flyteidl2.workflow.GetActionDataRequest.action_id:type_name -> flyteidl2.common.ActionIdentifier + 34, // 19: flyteidl2.workflow.GetActionDataResponse.inputs:type_name -> flyteidl2.task.Inputs + 41, // 20: flyteidl2.workflow.GetActionDataResponse.outputs:type_name -> flyteidl2.task.Outputs + 42, // 21: flyteidl2.workflow.ListRunsRequest.request:type_name -> flyteidl2.common.ListRequest + 30, // 22: flyteidl2.workflow.ListRunsRequest.project_id:type_name -> flyteidl2.common.ProjectIdentifier + 33, // 23: flyteidl2.workflow.ListRunsRequest.trigger_name:type_name -> flyteidl2.common.TriggerName + 43, // 24: flyteidl2.workflow.ListRunsRequest.task_name:type_name -> flyteidl2.task.TaskName + 31, // 25: flyteidl2.workflow.ListRunsRequest.task_id:type_name -> flyteidl2.task.TaskIdentifier + 37, // 26: flyteidl2.workflow.ListRunsResponse.runs:type_name -> flyteidl2.workflow.Run + 44, // 27: flyteidl2.workflow.WatchRunsRequest.cluster_id:type_name -> flyteidl2.common.ClusterIdentifier + 30, // 28: flyteidl2.workflow.WatchRunsRequest.project_id:type_name -> flyteidl2.common.ProjectIdentifier + 31, // 29: flyteidl2.workflow.WatchRunsRequest.task_id:type_name -> flyteidl2.task.TaskIdentifier + 37, // 30: flyteidl2.workflow.WatchRunsResponse.runs:type_name -> flyteidl2.workflow.Run + 42, // 31: flyteidl2.workflow.ListActionsRequest.request:type_name -> flyteidl2.common.ListRequest + 29, // 32: flyteidl2.workflow.ListActionsRequest.run_id:type_name -> flyteidl2.common.RunIdentifier + 45, // 33: flyteidl2.workflow.ListActionsResponse.actions:type_name -> flyteidl2.workflow.Action + 29, // 34: flyteidl2.workflow.WatchActionsRequest.run_id:type_name -> flyteidl2.common.RunIdentifier + 46, // 35: flyteidl2.workflow.WatchActionsRequest.filter:type_name -> flyteidl2.common.Filter + 47, // 36: flyteidl2.workflow.WatchActionsResponse.enriched_actions:type_name -> flyteidl2.workflow.EnrichedAction + 39, // 37: flyteidl2.workflow.WatchClusterEventsRequest.id:type_name -> flyteidl2.common.ActionIdentifier + 48, // 38: flyteidl2.workflow.WatchClusterEventsResponse.cluster_events:type_name -> flyteidl2.workflow.ClusterEvent + 39, // 39: flyteidl2.workflow.AbortActionRequest.action_id:type_name -> flyteidl2.common.ActionIdentifier + 30, // 40: flyteidl2.workflow.WatchGroupsRequest.project_id:type_name -> flyteidl2.common.ProjectIdentifier + 49, // 41: flyteidl2.workflow.WatchGroupsRequest.start_date:type_name -> google.protobuf.Timestamp + 49, // 42: flyteidl2.workflow.WatchGroupsRequest.end_date:type_name -> google.protobuf.Timestamp + 42, // 43: flyteidl2.workflow.WatchGroupsRequest.request:type_name -> flyteidl2.common.ListRequest + 28, // 44: flyteidl2.workflow.WatchGroupsRequest.known_sort_fields:type_name -> flyteidl2.workflow.WatchGroupsRequest.KnownSortField + 50, // 45: flyteidl2.workflow.WatchGroupsResponse.task_groups:type_name -> flyteidl2.workflow.TaskGroup + 51, // 46: flyteidl2.workflow.WatchGroupsRequest.KnownSortField.created_at:type_name -> flyteidl2.common.Sort.Direction + 0, // 47: flyteidl2.workflow.RunService.CreateRun:input_type -> flyteidl2.workflow.CreateRunRequest + 2, // 48: flyteidl2.workflow.RunService.AbortRun:input_type -> flyteidl2.workflow.AbortRunRequest + 4, // 49: flyteidl2.workflow.RunService.GetRunDetails:input_type -> flyteidl2.workflow.GetRunDetailsRequest + 6, // 50: flyteidl2.workflow.RunService.WatchRunDetails:input_type -> flyteidl2.workflow.WatchRunDetailsRequest + 8, // 51: flyteidl2.workflow.RunService.GetActionDetails:input_type -> flyteidl2.workflow.GetActionDetailsRequest + 10, // 52: flyteidl2.workflow.RunService.WatchActionDetails:input_type -> flyteidl2.workflow.WatchActionDetailsRequest + 12, // 53: flyteidl2.workflow.RunService.GetActionData:input_type -> flyteidl2.workflow.GetActionDataRequest + 14, // 54: flyteidl2.workflow.RunService.ListRuns:input_type -> flyteidl2.workflow.ListRunsRequest + 16, // 55: flyteidl2.workflow.RunService.WatchRuns:input_type -> flyteidl2.workflow.WatchRunsRequest + 18, // 56: flyteidl2.workflow.RunService.ListActions:input_type -> flyteidl2.workflow.ListActionsRequest + 20, // 57: flyteidl2.workflow.RunService.WatchActions:input_type -> flyteidl2.workflow.WatchActionsRequest + 22, // 58: flyteidl2.workflow.RunService.WatchClusterEvents:input_type -> flyteidl2.workflow.WatchClusterEventsRequest + 24, // 59: flyteidl2.workflow.RunService.AbortAction:input_type -> flyteidl2.workflow.AbortActionRequest + 26, // 60: flyteidl2.workflow.RunService.WatchGroups:input_type -> flyteidl2.workflow.WatchGroupsRequest + 1, // 61: flyteidl2.workflow.RunService.CreateRun:output_type -> flyteidl2.workflow.CreateRunResponse + 3, // 62: flyteidl2.workflow.RunService.AbortRun:output_type -> flyteidl2.workflow.AbortRunResponse + 5, // 63: flyteidl2.workflow.RunService.GetRunDetails:output_type -> flyteidl2.workflow.GetRunDetailsResponse + 7, // 64: flyteidl2.workflow.RunService.WatchRunDetails:output_type -> flyteidl2.workflow.WatchRunDetailsResponse + 9, // 65: flyteidl2.workflow.RunService.GetActionDetails:output_type -> flyteidl2.workflow.GetActionDetailsResponse + 11, // 66: flyteidl2.workflow.RunService.WatchActionDetails:output_type -> flyteidl2.workflow.WatchActionDetailsResponse + 13, // 67: flyteidl2.workflow.RunService.GetActionData:output_type -> flyteidl2.workflow.GetActionDataResponse + 15, // 68: flyteidl2.workflow.RunService.ListRuns:output_type -> flyteidl2.workflow.ListRunsResponse + 17, // 69: flyteidl2.workflow.RunService.WatchRuns:output_type -> flyteidl2.workflow.WatchRunsResponse + 19, // 70: flyteidl2.workflow.RunService.ListActions:output_type -> flyteidl2.workflow.ListActionsResponse + 21, // 71: flyteidl2.workflow.RunService.WatchActions:output_type -> flyteidl2.workflow.WatchActionsResponse + 23, // 72: flyteidl2.workflow.RunService.WatchClusterEvents:output_type -> flyteidl2.workflow.WatchClusterEventsResponse + 25, // 73: flyteidl2.workflow.RunService.AbortAction:output_type -> flyteidl2.workflow.AbortActionResponse + 27, // 74: flyteidl2.workflow.RunService.WatchGroups:output_type -> flyteidl2.workflow.WatchGroupsResponse + 61, // [61:75] is the sub-list for method output_type + 47, // [47:61] is the sub-list for method input_type + 47, // [47:47] is the sub-list for extension type_name + 47, // [47:47] is the sub-list for extension extendee + 0, // [0:47] is the sub-list for field type_name +} + +func init() { file_flyteidl2_workflow_run_service_proto_init() } +func file_flyteidl2_workflow_run_service_proto_init() { + if File_flyteidl2_workflow_run_service_proto != nil { + return + } + file_flyteidl2_workflow_run_definition_proto_init() + if !protoimpl.UnsafeEnabled { + file_flyteidl2_workflow_run_service_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CreateRunRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CreateRunResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AbortRunRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AbortRunResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetRunDetailsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetRunDetailsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchRunDetailsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchRunDetailsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetActionDetailsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetActionDetailsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchActionDetailsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchActionDetailsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetActionDataRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetActionDataResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListRunsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListRunsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchRunsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchRunsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListActionsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListActionsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchActionsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchActionsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchClusterEventsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchClusterEventsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AbortActionRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AbortActionResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchGroupsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchGroupsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchGroupsRequest_KnownSortField); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_workflow_run_service_proto_msgTypes[0].OneofWrappers = []interface{}{ + (*CreateRunRequest_RunId)(nil), + (*CreateRunRequest_ProjectId)(nil), + (*CreateRunRequest_TaskId)(nil), + (*CreateRunRequest_TaskSpec)(nil), + (*CreateRunRequest_TriggerName)(nil), + } + file_flyteidl2_workflow_run_service_proto_msgTypes[2].OneofWrappers = []interface{}{} + file_flyteidl2_workflow_run_service_proto_msgTypes[14].OneofWrappers = []interface{}{ + (*ListRunsRequest_Org)(nil), + (*ListRunsRequest_ProjectId)(nil), + (*ListRunsRequest_TriggerName)(nil), + (*ListRunsRequest_TaskName)(nil), + (*ListRunsRequest_TaskId)(nil), + } + file_flyteidl2_workflow_run_service_proto_msgTypes[16].OneofWrappers = []interface{}{ + (*WatchRunsRequest_Org)(nil), + (*WatchRunsRequest_ClusterId)(nil), + (*WatchRunsRequest_ProjectId)(nil), + (*WatchRunsRequest_TaskId)(nil), + } + file_flyteidl2_workflow_run_service_proto_msgTypes[26].OneofWrappers = []interface{}{ + (*WatchGroupsRequest_ProjectId)(nil), + } + file_flyteidl2_workflow_run_service_proto_msgTypes[28].OneofWrappers = []interface{}{ + (*WatchGroupsRequest_KnownSortField_CreatedAt)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_workflow_run_service_proto_rawDesc, + NumEnums: 0, + NumMessages: 29, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_flyteidl2_workflow_run_service_proto_goTypes, + DependencyIndexes: file_flyteidl2_workflow_run_service_proto_depIdxs, + MessageInfos: file_flyteidl2_workflow_run_service_proto_msgTypes, + }.Build() + File_flyteidl2_workflow_run_service_proto = out.File + file_flyteidl2_workflow_run_service_proto_rawDesc = nil + file_flyteidl2_workflow_run_service_proto_goTypes = nil + file_flyteidl2_workflow_run_service_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/workflow/run_service.pb.validate.go b/gen/go/flyteidl2/workflow/run_service.pb.validate.go new file mode 100644 index 0000000000..b9283a311b --- /dev/null +++ b/gen/go/flyteidl2/workflow/run_service.pb.validate.go @@ -0,0 +1,4571 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/workflow/run_service.proto + +package workflow + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" + + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort + + _ = common.Sort_Direction(0) +) + +// Validate checks the field values on CreateRunRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *CreateRunRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CreateRunRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CreateRunRequestMultiError, or nil if none found. +func (m *CreateRunRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *CreateRunRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetInputs()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateRunRequestValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateRunRequestValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetInputs()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateRunRequestValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetRunSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateRunRequestValidationError{ + field: "RunSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateRunRequestValidationError{ + field: "RunSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateRunRequestValidationError{ + field: "RunSpec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Source + + switch v := m.Id.(type) { + case *CreateRunRequest_RunId: + if v == nil { + err := CreateRunRequestValidationError{ + field: "Id", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetRunId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateRunRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateRunRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateRunRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *CreateRunRequest_ProjectId: + if v == nil { + err := CreateRunRequestValidationError{ + field: "Id", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetProjectId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateRunRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateRunRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetProjectId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateRunRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + switch v := m.Task.(type) { + case *CreateRunRequest_TaskId: + if v == nil { + err := CreateRunRequestValidationError{ + field: "Task", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTaskId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateRunRequestValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateRunRequestValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateRunRequestValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *CreateRunRequest_TaskSpec: + if v == nil { + err := CreateRunRequestValidationError{ + field: "Task", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTaskSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateRunRequestValidationError{ + field: "TaskSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateRunRequestValidationError{ + field: "TaskSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateRunRequestValidationError{ + field: "TaskSpec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *CreateRunRequest_TriggerName: + if v == nil { + err := CreateRunRequestValidationError{ + field: "Task", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTriggerName()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateRunRequestValidationError{ + field: "TriggerName", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateRunRequestValidationError{ + field: "TriggerName", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTriggerName()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateRunRequestValidationError{ + field: "TriggerName", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return CreateRunRequestMultiError(errors) + } + + return nil +} + +// CreateRunRequestMultiError is an error wrapping multiple validation errors +// returned by CreateRunRequest.ValidateAll() if the designated constraints +// aren't met. +type CreateRunRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CreateRunRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CreateRunRequestMultiError) AllErrors() []error { return m } + +// CreateRunRequestValidationError is the validation error returned by +// CreateRunRequest.Validate if the designated constraints aren't met. +type CreateRunRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CreateRunRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CreateRunRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CreateRunRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CreateRunRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CreateRunRequestValidationError) ErrorName() string { return "CreateRunRequestValidationError" } + +// Error satisfies the builtin error interface +func (e CreateRunRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCreateRunRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CreateRunRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CreateRunRequestValidationError{} + +// Validate checks the field values on CreateRunResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *CreateRunResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on CreateRunResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// CreateRunResponseMultiError, or nil if none found. +func (m *CreateRunResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *CreateRunResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRun()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, CreateRunResponseValidationError{ + field: "Run", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, CreateRunResponseValidationError{ + field: "Run", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRun()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return CreateRunResponseValidationError{ + field: "Run", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return CreateRunResponseMultiError(errors) + } + + return nil +} + +// CreateRunResponseMultiError is an error wrapping multiple validation errors +// returned by CreateRunResponse.ValidateAll() if the designated constraints +// aren't met. +type CreateRunResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m CreateRunResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m CreateRunResponseMultiError) AllErrors() []error { return m } + +// CreateRunResponseValidationError is the validation error returned by +// CreateRunResponse.Validate if the designated constraints aren't met. +type CreateRunResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e CreateRunResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e CreateRunResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e CreateRunResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e CreateRunResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e CreateRunResponseValidationError) ErrorName() string { + return "CreateRunResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e CreateRunResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sCreateRunResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = CreateRunResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = CreateRunResponseValidationError{} + +// Validate checks the field values on AbortRunRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *AbortRunRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on AbortRunRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// AbortRunRequestMultiError, or nil if none found. +func (m *AbortRunRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *AbortRunRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRunId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, AbortRunRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, AbortRunRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return AbortRunRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if m.Reason != nil { + // no validation rules for Reason + } + + if len(errors) > 0 { + return AbortRunRequestMultiError(errors) + } + + return nil +} + +// AbortRunRequestMultiError is an error wrapping multiple validation errors +// returned by AbortRunRequest.ValidateAll() if the designated constraints +// aren't met. +type AbortRunRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m AbortRunRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m AbortRunRequestMultiError) AllErrors() []error { return m } + +// AbortRunRequestValidationError is the validation error returned by +// AbortRunRequest.Validate if the designated constraints aren't met. +type AbortRunRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e AbortRunRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e AbortRunRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e AbortRunRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e AbortRunRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e AbortRunRequestValidationError) ErrorName() string { return "AbortRunRequestValidationError" } + +// Error satisfies the builtin error interface +func (e AbortRunRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sAbortRunRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = AbortRunRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = AbortRunRequestValidationError{} + +// Validate checks the field values on AbortRunResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *AbortRunResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on AbortRunResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// AbortRunResponseMultiError, or nil if none found. +func (m *AbortRunResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *AbortRunResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return AbortRunResponseMultiError(errors) + } + + return nil +} + +// AbortRunResponseMultiError is an error wrapping multiple validation errors +// returned by AbortRunResponse.ValidateAll() if the designated constraints +// aren't met. +type AbortRunResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m AbortRunResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m AbortRunResponseMultiError) AllErrors() []error { return m } + +// AbortRunResponseValidationError is the validation error returned by +// AbortRunResponse.Validate if the designated constraints aren't met. +type AbortRunResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e AbortRunResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e AbortRunResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e AbortRunResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e AbortRunResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e AbortRunResponseValidationError) ErrorName() string { return "AbortRunResponseValidationError" } + +// Error satisfies the builtin error interface +func (e AbortRunResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sAbortRunResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = AbortRunResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = AbortRunResponseValidationError{} + +// Validate checks the field values on GetRunDetailsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetRunDetailsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetRunDetailsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetRunDetailsRequestMultiError, or nil if none found. +func (m *GetRunDetailsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetRunDetailsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRunId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetRunDetailsRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetRunDetailsRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetRunDetailsRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetRunDetailsRequestMultiError(errors) + } + + return nil +} + +// GetRunDetailsRequestMultiError is an error wrapping multiple validation +// errors returned by GetRunDetailsRequest.ValidateAll() if the designated +// constraints aren't met. +type GetRunDetailsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetRunDetailsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetRunDetailsRequestMultiError) AllErrors() []error { return m } + +// GetRunDetailsRequestValidationError is the validation error returned by +// GetRunDetailsRequest.Validate if the designated constraints aren't met. +type GetRunDetailsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetRunDetailsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetRunDetailsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetRunDetailsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetRunDetailsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetRunDetailsRequestValidationError) ErrorName() string { + return "GetRunDetailsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e GetRunDetailsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetRunDetailsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetRunDetailsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetRunDetailsRequestValidationError{} + +// Validate checks the field values on GetRunDetailsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetRunDetailsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetRunDetailsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetRunDetailsResponseMultiError, or nil if none found. +func (m *GetRunDetailsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetRunDetailsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetDetails()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetRunDetailsResponseValidationError{ + field: "Details", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetRunDetailsResponseValidationError{ + field: "Details", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDetails()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetRunDetailsResponseValidationError{ + field: "Details", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetRunDetailsResponseMultiError(errors) + } + + return nil +} + +// GetRunDetailsResponseMultiError is an error wrapping multiple validation +// errors returned by GetRunDetailsResponse.ValidateAll() if the designated +// constraints aren't met. +type GetRunDetailsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetRunDetailsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetRunDetailsResponseMultiError) AllErrors() []error { return m } + +// GetRunDetailsResponseValidationError is the validation error returned by +// GetRunDetailsResponse.Validate if the designated constraints aren't met. +type GetRunDetailsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetRunDetailsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetRunDetailsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetRunDetailsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetRunDetailsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetRunDetailsResponseValidationError) ErrorName() string { + return "GetRunDetailsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e GetRunDetailsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetRunDetailsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetRunDetailsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetRunDetailsResponseValidationError{} + +// Validate checks the field values on WatchRunDetailsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *WatchRunDetailsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WatchRunDetailsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// WatchRunDetailsRequestMultiError, or nil if none found. +func (m *WatchRunDetailsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *WatchRunDetailsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRunId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchRunDetailsRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchRunDetailsRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchRunDetailsRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return WatchRunDetailsRequestMultiError(errors) + } + + return nil +} + +// WatchRunDetailsRequestMultiError is an error wrapping multiple validation +// errors returned by WatchRunDetailsRequest.ValidateAll() if the designated +// constraints aren't met. +type WatchRunDetailsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WatchRunDetailsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WatchRunDetailsRequestMultiError) AllErrors() []error { return m } + +// WatchRunDetailsRequestValidationError is the validation error returned by +// WatchRunDetailsRequest.Validate if the designated constraints aren't met. +type WatchRunDetailsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WatchRunDetailsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WatchRunDetailsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WatchRunDetailsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WatchRunDetailsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WatchRunDetailsRequestValidationError) ErrorName() string { + return "WatchRunDetailsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e WatchRunDetailsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWatchRunDetailsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WatchRunDetailsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WatchRunDetailsRequestValidationError{} + +// Validate checks the field values on WatchRunDetailsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *WatchRunDetailsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WatchRunDetailsResponse with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// WatchRunDetailsResponseMultiError, or nil if none found. +func (m *WatchRunDetailsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *WatchRunDetailsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetDetails()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchRunDetailsResponseValidationError{ + field: "Details", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchRunDetailsResponseValidationError{ + field: "Details", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDetails()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchRunDetailsResponseValidationError{ + field: "Details", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return WatchRunDetailsResponseMultiError(errors) + } + + return nil +} + +// WatchRunDetailsResponseMultiError is an error wrapping multiple validation +// errors returned by WatchRunDetailsResponse.ValidateAll() if the designated +// constraints aren't met. +type WatchRunDetailsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WatchRunDetailsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WatchRunDetailsResponseMultiError) AllErrors() []error { return m } + +// WatchRunDetailsResponseValidationError is the validation error returned by +// WatchRunDetailsResponse.Validate if the designated constraints aren't met. +type WatchRunDetailsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WatchRunDetailsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WatchRunDetailsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WatchRunDetailsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WatchRunDetailsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WatchRunDetailsResponseValidationError) ErrorName() string { + return "WatchRunDetailsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e WatchRunDetailsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWatchRunDetailsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WatchRunDetailsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WatchRunDetailsResponseValidationError{} + +// Validate checks the field values on GetActionDetailsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetActionDetailsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetActionDetailsRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetActionDetailsRequestMultiError, or nil if none found. +func (m *GetActionDetailsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetActionDetailsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetActionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetActionDetailsRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetActionDetailsRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetActionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetActionDetailsRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetActionDetailsRequestMultiError(errors) + } + + return nil +} + +// GetActionDetailsRequestMultiError is an error wrapping multiple validation +// errors returned by GetActionDetailsRequest.ValidateAll() if the designated +// constraints aren't met. +type GetActionDetailsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetActionDetailsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetActionDetailsRequestMultiError) AllErrors() []error { return m } + +// GetActionDetailsRequestValidationError is the validation error returned by +// GetActionDetailsRequest.Validate if the designated constraints aren't met. +type GetActionDetailsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetActionDetailsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetActionDetailsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetActionDetailsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetActionDetailsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetActionDetailsRequestValidationError) ErrorName() string { + return "GetActionDetailsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e GetActionDetailsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetActionDetailsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetActionDetailsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetActionDetailsRequestValidationError{} + +// Validate checks the field values on GetActionDetailsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetActionDetailsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetActionDetailsResponse with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetActionDetailsResponseMultiError, or nil if none found. +func (m *GetActionDetailsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetActionDetailsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetDetails()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetActionDetailsResponseValidationError{ + field: "Details", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetActionDetailsResponseValidationError{ + field: "Details", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDetails()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetActionDetailsResponseValidationError{ + field: "Details", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetActionDetailsResponseMultiError(errors) + } + + return nil +} + +// GetActionDetailsResponseMultiError is an error wrapping multiple validation +// errors returned by GetActionDetailsResponse.ValidateAll() if the designated +// constraints aren't met. +type GetActionDetailsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetActionDetailsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetActionDetailsResponseMultiError) AllErrors() []error { return m } + +// GetActionDetailsResponseValidationError is the validation error returned by +// GetActionDetailsResponse.Validate if the designated constraints aren't met. +type GetActionDetailsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetActionDetailsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetActionDetailsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetActionDetailsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetActionDetailsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetActionDetailsResponseValidationError) ErrorName() string { + return "GetActionDetailsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e GetActionDetailsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetActionDetailsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetActionDetailsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetActionDetailsResponseValidationError{} + +// Validate checks the field values on WatchActionDetailsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *WatchActionDetailsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WatchActionDetailsRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// WatchActionDetailsRequestMultiError, or nil if none found. +func (m *WatchActionDetailsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *WatchActionDetailsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetActionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchActionDetailsRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchActionDetailsRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetActionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchActionDetailsRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return WatchActionDetailsRequestMultiError(errors) + } + + return nil +} + +// WatchActionDetailsRequestMultiError is an error wrapping multiple validation +// errors returned by WatchActionDetailsRequest.ValidateAll() if the +// designated constraints aren't met. +type WatchActionDetailsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WatchActionDetailsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WatchActionDetailsRequestMultiError) AllErrors() []error { return m } + +// WatchActionDetailsRequestValidationError is the validation error returned by +// WatchActionDetailsRequest.Validate if the designated constraints aren't met. +type WatchActionDetailsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WatchActionDetailsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WatchActionDetailsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WatchActionDetailsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WatchActionDetailsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WatchActionDetailsRequestValidationError) ErrorName() string { + return "WatchActionDetailsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e WatchActionDetailsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWatchActionDetailsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WatchActionDetailsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WatchActionDetailsRequestValidationError{} + +// Validate checks the field values on WatchActionDetailsResponse with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *WatchActionDetailsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WatchActionDetailsResponse with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// WatchActionDetailsResponseMultiError, or nil if none found. +func (m *WatchActionDetailsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *WatchActionDetailsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetDetails()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchActionDetailsResponseValidationError{ + field: "Details", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchActionDetailsResponseValidationError{ + field: "Details", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDetails()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchActionDetailsResponseValidationError{ + field: "Details", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return WatchActionDetailsResponseMultiError(errors) + } + + return nil +} + +// WatchActionDetailsResponseMultiError is an error wrapping multiple +// validation errors returned by WatchActionDetailsResponse.ValidateAll() if +// the designated constraints aren't met. +type WatchActionDetailsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WatchActionDetailsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WatchActionDetailsResponseMultiError) AllErrors() []error { return m } + +// WatchActionDetailsResponseValidationError is the validation error returned +// by WatchActionDetailsResponse.Validate if the designated constraints aren't met. +type WatchActionDetailsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WatchActionDetailsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WatchActionDetailsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WatchActionDetailsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WatchActionDetailsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WatchActionDetailsResponseValidationError) ErrorName() string { + return "WatchActionDetailsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e WatchActionDetailsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWatchActionDetailsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WatchActionDetailsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WatchActionDetailsResponseValidationError{} + +// Validate checks the field values on GetActionDataRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetActionDataRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetActionDataRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetActionDataRequestMultiError, or nil if none found. +func (m *GetActionDataRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetActionDataRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetActionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetActionDataRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetActionDataRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetActionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetActionDataRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetActionDataRequestMultiError(errors) + } + + return nil +} + +// GetActionDataRequestMultiError is an error wrapping multiple validation +// errors returned by GetActionDataRequest.ValidateAll() if the designated +// constraints aren't met. +type GetActionDataRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetActionDataRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetActionDataRequestMultiError) AllErrors() []error { return m } + +// GetActionDataRequestValidationError is the validation error returned by +// GetActionDataRequest.Validate if the designated constraints aren't met. +type GetActionDataRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetActionDataRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetActionDataRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetActionDataRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetActionDataRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetActionDataRequestValidationError) ErrorName() string { + return "GetActionDataRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e GetActionDataRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetActionDataRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetActionDataRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetActionDataRequestValidationError{} + +// Validate checks the field values on GetActionDataResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *GetActionDataResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetActionDataResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// GetActionDataResponseMultiError, or nil if none found. +func (m *GetActionDataResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetActionDataResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetInputs()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetActionDataResponseValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetActionDataResponseValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetInputs()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetActionDataResponseValidationError{ + field: "Inputs", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetOutputs()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetActionDataResponseValidationError{ + field: "Outputs", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetActionDataResponseValidationError{ + field: "Outputs", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetOutputs()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetActionDataResponseValidationError{ + field: "Outputs", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetActionDataResponseMultiError(errors) + } + + return nil +} + +// GetActionDataResponseMultiError is an error wrapping multiple validation +// errors returned by GetActionDataResponse.ValidateAll() if the designated +// constraints aren't met. +type GetActionDataResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetActionDataResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetActionDataResponseMultiError) AllErrors() []error { return m } + +// GetActionDataResponseValidationError is the validation error returned by +// GetActionDataResponse.Validate if the designated constraints aren't met. +type GetActionDataResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetActionDataResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetActionDataResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetActionDataResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetActionDataResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetActionDataResponseValidationError) ErrorName() string { + return "GetActionDataResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e GetActionDataResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetActionDataResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetActionDataResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetActionDataResponseValidationError{} + +// Validate checks the field values on ListRunsRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *ListRunsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListRunsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ListRunsRequestMultiError, or nil if none found. +func (m *ListRunsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *ListRunsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRequest()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListRunsRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListRunsRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRequest()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListRunsRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + } + } + } + + switch v := m.ScopeBy.(type) { + case *ListRunsRequest_Org: + if v == nil { + err := ListRunsRequestValidationError{ + field: "ScopeBy", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for Org + case *ListRunsRequest_ProjectId: + if v == nil { + err := ListRunsRequestValidationError{ + field: "ScopeBy", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetProjectId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListRunsRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListRunsRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetProjectId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListRunsRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *ListRunsRequest_TriggerName: + if v == nil { + err := ListRunsRequestValidationError{ + field: "ScopeBy", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTriggerName()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListRunsRequestValidationError{ + field: "TriggerName", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListRunsRequestValidationError{ + field: "TriggerName", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTriggerName()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListRunsRequestValidationError{ + field: "TriggerName", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *ListRunsRequest_TaskName: + if v == nil { + err := ListRunsRequestValidationError{ + field: "ScopeBy", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTaskName()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListRunsRequestValidationError{ + field: "TaskName", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListRunsRequestValidationError{ + field: "TaskName", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskName()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListRunsRequestValidationError{ + field: "TaskName", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *ListRunsRequest_TaskId: + if v == nil { + err := ListRunsRequestValidationError{ + field: "ScopeBy", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTaskId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListRunsRequestValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListRunsRequestValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListRunsRequestValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return ListRunsRequestMultiError(errors) + } + + return nil +} + +// ListRunsRequestMultiError is an error wrapping multiple validation errors +// returned by ListRunsRequest.ValidateAll() if the designated constraints +// aren't met. +type ListRunsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListRunsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListRunsRequestMultiError) AllErrors() []error { return m } + +// ListRunsRequestValidationError is the validation error returned by +// ListRunsRequest.Validate if the designated constraints aren't met. +type ListRunsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListRunsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListRunsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListRunsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListRunsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListRunsRequestValidationError) ErrorName() string { return "ListRunsRequestValidationError" } + +// Error satisfies the builtin error interface +func (e ListRunsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListRunsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListRunsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListRunsRequestValidationError{} + +// Validate checks the field values on ListRunsResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *ListRunsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListRunsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ListRunsResponseMultiError, or nil if none found. +func (m *ListRunsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *ListRunsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetRuns() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListRunsResponseValidationError{ + field: fmt.Sprintf("Runs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListRunsResponseValidationError{ + field: fmt.Sprintf("Runs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListRunsResponseValidationError{ + field: fmt.Sprintf("Runs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Token + + if len(errors) > 0 { + return ListRunsResponseMultiError(errors) + } + + return nil +} + +// ListRunsResponseMultiError is an error wrapping multiple validation errors +// returned by ListRunsResponse.ValidateAll() if the designated constraints +// aren't met. +type ListRunsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListRunsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListRunsResponseMultiError) AllErrors() []error { return m } + +// ListRunsResponseValidationError is the validation error returned by +// ListRunsResponse.Validate if the designated constraints aren't met. +type ListRunsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListRunsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListRunsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListRunsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListRunsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListRunsResponseValidationError) ErrorName() string { return "ListRunsResponseValidationError" } + +// Error satisfies the builtin error interface +func (e ListRunsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListRunsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListRunsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListRunsResponseValidationError{} + +// Validate checks the field values on WatchRunsRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *WatchRunsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WatchRunsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// WatchRunsRequestMultiError, or nil if none found. +func (m *WatchRunsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *WatchRunsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Target.(type) { + case *WatchRunsRequest_Org: + if v == nil { + err := WatchRunsRequestValidationError{ + field: "Target", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for Org + case *WatchRunsRequest_ClusterId: + if v == nil { + err := WatchRunsRequestValidationError{ + field: "Target", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetClusterId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchRunsRequestValidationError{ + field: "ClusterId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchRunsRequestValidationError{ + field: "ClusterId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetClusterId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchRunsRequestValidationError{ + field: "ClusterId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *WatchRunsRequest_ProjectId: + if v == nil { + err := WatchRunsRequestValidationError{ + field: "Target", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetProjectId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchRunsRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchRunsRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetProjectId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchRunsRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *WatchRunsRequest_TaskId: + if v == nil { + err := WatchRunsRequestValidationError{ + field: "Target", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetTaskId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchRunsRequestValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchRunsRequestValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchRunsRequestValidationError{ + field: "TaskId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return WatchRunsRequestMultiError(errors) + } + + return nil +} + +// WatchRunsRequestMultiError is an error wrapping multiple validation errors +// returned by WatchRunsRequest.ValidateAll() if the designated constraints +// aren't met. +type WatchRunsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WatchRunsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WatchRunsRequestMultiError) AllErrors() []error { return m } + +// WatchRunsRequestValidationError is the validation error returned by +// WatchRunsRequest.Validate if the designated constraints aren't met. +type WatchRunsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WatchRunsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WatchRunsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WatchRunsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WatchRunsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WatchRunsRequestValidationError) ErrorName() string { return "WatchRunsRequestValidationError" } + +// Error satisfies the builtin error interface +func (e WatchRunsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWatchRunsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WatchRunsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WatchRunsRequestValidationError{} + +// Validate checks the field values on WatchRunsResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// first error encountered is returned, or nil if there are no violations. +func (m *WatchRunsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WatchRunsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// WatchRunsResponseMultiError, or nil if none found. +func (m *WatchRunsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *WatchRunsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetRuns() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchRunsResponseValidationError{ + field: fmt.Sprintf("Runs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchRunsResponseValidationError{ + field: fmt.Sprintf("Runs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchRunsResponseValidationError{ + field: fmt.Sprintf("Runs[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return WatchRunsResponseMultiError(errors) + } + + return nil +} + +// WatchRunsResponseMultiError is an error wrapping multiple validation errors +// returned by WatchRunsResponse.ValidateAll() if the designated constraints +// aren't met. +type WatchRunsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WatchRunsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WatchRunsResponseMultiError) AllErrors() []error { return m } + +// WatchRunsResponseValidationError is the validation error returned by +// WatchRunsResponse.Validate if the designated constraints aren't met. +type WatchRunsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WatchRunsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WatchRunsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WatchRunsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WatchRunsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WatchRunsResponseValidationError) ErrorName() string { + return "WatchRunsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e WatchRunsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWatchRunsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WatchRunsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WatchRunsResponseValidationError{} + +// Validate checks the field values on ListActionsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ListActionsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListActionsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ListActionsRequestMultiError, or nil if none found. +func (m *ListActionsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *ListActionsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRequest()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListActionsRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListActionsRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRequest()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListActionsRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetRunId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListActionsRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListActionsRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListActionsRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return ListActionsRequestMultiError(errors) + } + + return nil +} + +// ListActionsRequestMultiError is an error wrapping multiple validation errors +// returned by ListActionsRequest.ValidateAll() if the designated constraints +// aren't met. +type ListActionsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListActionsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListActionsRequestMultiError) AllErrors() []error { return m } + +// ListActionsRequestValidationError is the validation error returned by +// ListActionsRequest.Validate if the designated constraints aren't met. +type ListActionsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListActionsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListActionsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListActionsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListActionsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListActionsRequestValidationError) ErrorName() string { + return "ListActionsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e ListActionsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListActionsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListActionsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListActionsRequestValidationError{} + +// Validate checks the field values on ListActionsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *ListActionsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ListActionsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// ListActionsResponseMultiError, or nil if none found. +func (m *ListActionsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *ListActionsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetActions() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ListActionsResponseValidationError{ + field: fmt.Sprintf("Actions[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ListActionsResponseValidationError{ + field: fmt.Sprintf("Actions[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ListActionsResponseValidationError{ + field: fmt.Sprintf("Actions[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Token + + if len(errors) > 0 { + return ListActionsResponseMultiError(errors) + } + + return nil +} + +// ListActionsResponseMultiError is an error wrapping multiple validation +// errors returned by ListActionsResponse.ValidateAll() if the designated +// constraints aren't met. +type ListActionsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ListActionsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ListActionsResponseMultiError) AllErrors() []error { return m } + +// ListActionsResponseValidationError is the validation error returned by +// ListActionsResponse.Validate if the designated constraints aren't met. +type ListActionsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ListActionsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ListActionsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ListActionsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ListActionsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ListActionsResponseValidationError) ErrorName() string { + return "ListActionsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e ListActionsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sListActionsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ListActionsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ListActionsResponseValidationError{} + +// Validate checks the field values on WatchActionsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *WatchActionsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WatchActionsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// WatchActionsRequestMultiError, or nil if none found. +func (m *WatchActionsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *WatchActionsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetRunId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchActionsRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchActionsRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRunId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchActionsRequestValidationError{ + field: "RunId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetFilter() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchActionsRequestValidationError{ + field: fmt.Sprintf("Filter[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchActionsRequestValidationError{ + field: fmt.Sprintf("Filter[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchActionsRequestValidationError{ + field: fmt.Sprintf("Filter[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return WatchActionsRequestMultiError(errors) + } + + return nil +} + +// WatchActionsRequestMultiError is an error wrapping multiple validation +// errors returned by WatchActionsRequest.ValidateAll() if the designated +// constraints aren't met. +type WatchActionsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WatchActionsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WatchActionsRequestMultiError) AllErrors() []error { return m } + +// WatchActionsRequestValidationError is the validation error returned by +// WatchActionsRequest.Validate if the designated constraints aren't met. +type WatchActionsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WatchActionsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WatchActionsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WatchActionsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WatchActionsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WatchActionsRequestValidationError) ErrorName() string { + return "WatchActionsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e WatchActionsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWatchActionsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WatchActionsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WatchActionsRequestValidationError{} + +// Validate checks the field values on WatchActionsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *WatchActionsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WatchActionsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// WatchActionsResponseMultiError, or nil if none found. +func (m *WatchActionsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *WatchActionsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetEnrichedActions() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchActionsResponseValidationError{ + field: fmt.Sprintf("EnrichedActions[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchActionsResponseValidationError{ + field: fmt.Sprintf("EnrichedActions[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchActionsResponseValidationError{ + field: fmt.Sprintf("EnrichedActions[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return WatchActionsResponseMultiError(errors) + } + + return nil +} + +// WatchActionsResponseMultiError is an error wrapping multiple validation +// errors returned by WatchActionsResponse.ValidateAll() if the designated +// constraints aren't met. +type WatchActionsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WatchActionsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WatchActionsResponseMultiError) AllErrors() []error { return m } + +// WatchActionsResponseValidationError is the validation error returned by +// WatchActionsResponse.Validate if the designated constraints aren't met. +type WatchActionsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WatchActionsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WatchActionsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WatchActionsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WatchActionsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WatchActionsResponseValidationError) ErrorName() string { + return "WatchActionsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e WatchActionsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWatchActionsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WatchActionsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WatchActionsResponseValidationError{} + +// Validate checks the field values on WatchClusterEventsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *WatchClusterEventsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WatchClusterEventsRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// WatchClusterEventsRequestMultiError, or nil if none found. +func (m *WatchClusterEventsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *WatchClusterEventsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchClusterEventsRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchClusterEventsRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchClusterEventsRequestValidationError{ + field: "Id", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Attempt + + if len(errors) > 0 { + return WatchClusterEventsRequestMultiError(errors) + } + + return nil +} + +// WatchClusterEventsRequestMultiError is an error wrapping multiple validation +// errors returned by WatchClusterEventsRequest.ValidateAll() if the +// designated constraints aren't met. +type WatchClusterEventsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WatchClusterEventsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WatchClusterEventsRequestMultiError) AllErrors() []error { return m } + +// WatchClusterEventsRequestValidationError is the validation error returned by +// WatchClusterEventsRequest.Validate if the designated constraints aren't met. +type WatchClusterEventsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WatchClusterEventsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WatchClusterEventsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WatchClusterEventsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WatchClusterEventsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WatchClusterEventsRequestValidationError) ErrorName() string { + return "WatchClusterEventsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e WatchClusterEventsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWatchClusterEventsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WatchClusterEventsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WatchClusterEventsRequestValidationError{} + +// Validate checks the field values on WatchClusterEventsResponse with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *WatchClusterEventsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WatchClusterEventsResponse with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// WatchClusterEventsResponseMultiError, or nil if none found. +func (m *WatchClusterEventsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *WatchClusterEventsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetClusterEvents() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchClusterEventsResponseValidationError{ + field: fmt.Sprintf("ClusterEvents[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchClusterEventsResponseValidationError{ + field: fmt.Sprintf("ClusterEvents[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchClusterEventsResponseValidationError{ + field: fmt.Sprintf("ClusterEvents[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return WatchClusterEventsResponseMultiError(errors) + } + + return nil +} + +// WatchClusterEventsResponseMultiError is an error wrapping multiple +// validation errors returned by WatchClusterEventsResponse.ValidateAll() if +// the designated constraints aren't met. +type WatchClusterEventsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WatchClusterEventsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WatchClusterEventsResponseMultiError) AllErrors() []error { return m } + +// WatchClusterEventsResponseValidationError is the validation error returned +// by WatchClusterEventsResponse.Validate if the designated constraints aren't met. +type WatchClusterEventsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WatchClusterEventsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WatchClusterEventsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WatchClusterEventsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WatchClusterEventsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WatchClusterEventsResponseValidationError) ErrorName() string { + return "WatchClusterEventsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e WatchClusterEventsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWatchClusterEventsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WatchClusterEventsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WatchClusterEventsResponseValidationError{} + +// Validate checks the field values on AbortActionRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *AbortActionRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on AbortActionRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// AbortActionRequestMultiError, or nil if none found. +func (m *AbortActionRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *AbortActionRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetActionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, AbortActionRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, AbortActionRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetActionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return AbortActionRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Reason + + if len(errors) > 0 { + return AbortActionRequestMultiError(errors) + } + + return nil +} + +// AbortActionRequestMultiError is an error wrapping multiple validation errors +// returned by AbortActionRequest.ValidateAll() if the designated constraints +// aren't met. +type AbortActionRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m AbortActionRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m AbortActionRequestMultiError) AllErrors() []error { return m } + +// AbortActionRequestValidationError is the validation error returned by +// AbortActionRequest.Validate if the designated constraints aren't met. +type AbortActionRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e AbortActionRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e AbortActionRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e AbortActionRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e AbortActionRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e AbortActionRequestValidationError) ErrorName() string { + return "AbortActionRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e AbortActionRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sAbortActionRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = AbortActionRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = AbortActionRequestValidationError{} + +// Validate checks the field values on AbortActionResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *AbortActionResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on AbortActionResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// AbortActionResponseMultiError, or nil if none found. +func (m *AbortActionResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *AbortActionResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if len(errors) > 0 { + return AbortActionResponseMultiError(errors) + } + + return nil +} + +// AbortActionResponseMultiError is an error wrapping multiple validation +// errors returned by AbortActionResponse.ValidateAll() if the designated +// constraints aren't met. +type AbortActionResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m AbortActionResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m AbortActionResponseMultiError) AllErrors() []error { return m } + +// AbortActionResponseValidationError is the validation error returned by +// AbortActionResponse.Validate if the designated constraints aren't met. +type AbortActionResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e AbortActionResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e AbortActionResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e AbortActionResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e AbortActionResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e AbortActionResponseValidationError) ErrorName() string { + return "AbortActionResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e AbortActionResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sAbortActionResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = AbortActionResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = AbortActionResponseValidationError{} + +// Validate checks the field values on WatchGroupsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *WatchGroupsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WatchGroupsRequest with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// WatchGroupsRequestMultiError, or nil if none found. +func (m *WatchGroupsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *WatchGroupsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetStartDate()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchGroupsRequestValidationError{ + field: "StartDate", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchGroupsRequestValidationError{ + field: "StartDate", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStartDate()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchGroupsRequestValidationError{ + field: "StartDate", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetEndDate()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchGroupsRequestValidationError{ + field: "EndDate", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchGroupsRequestValidationError{ + field: "EndDate", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetEndDate()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchGroupsRequestValidationError{ + field: "EndDate", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetRequest()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchGroupsRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchGroupsRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetRequest()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchGroupsRequestValidationError{ + field: "Request", + reason: "embedded message failed validation", + cause: err, + } + } + } + + for idx, item := range m.GetKnownSortFields() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchGroupsRequestValidationError{ + field: fmt.Sprintf("KnownSortFields[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchGroupsRequestValidationError{ + field: fmt.Sprintf("KnownSortFields[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchGroupsRequestValidationError{ + field: fmt.Sprintf("KnownSortFields[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + switch v := m.ScopeBy.(type) { + case *WatchGroupsRequest_ProjectId: + if v == nil { + err := WatchGroupsRequestValidationError{ + field: "ScopeBy", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetProjectId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchGroupsRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchGroupsRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetProjectId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchGroupsRequestValidationError{ + field: "ProjectId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return WatchGroupsRequestMultiError(errors) + } + + return nil +} + +// WatchGroupsRequestMultiError is an error wrapping multiple validation errors +// returned by WatchGroupsRequest.ValidateAll() if the designated constraints +// aren't met. +type WatchGroupsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WatchGroupsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WatchGroupsRequestMultiError) AllErrors() []error { return m } + +// WatchGroupsRequestValidationError is the validation error returned by +// WatchGroupsRequest.Validate if the designated constraints aren't met. +type WatchGroupsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WatchGroupsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WatchGroupsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WatchGroupsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WatchGroupsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WatchGroupsRequestValidationError) ErrorName() string { + return "WatchGroupsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e WatchGroupsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWatchGroupsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WatchGroupsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WatchGroupsRequestValidationError{} + +// Validate checks the field values on WatchGroupsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *WatchGroupsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WatchGroupsResponse with the rules +// defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// WatchGroupsResponseMultiError, or nil if none found. +func (m *WatchGroupsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *WatchGroupsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetTaskGroups() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchGroupsResponseValidationError{ + field: fmt.Sprintf("TaskGroups[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchGroupsResponseValidationError{ + field: fmt.Sprintf("TaskGroups[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchGroupsResponseValidationError{ + field: fmt.Sprintf("TaskGroups[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + // no validation rules for Sentinel + + if len(errors) > 0 { + return WatchGroupsResponseMultiError(errors) + } + + return nil +} + +// WatchGroupsResponseMultiError is an error wrapping multiple validation +// errors returned by WatchGroupsResponse.ValidateAll() if the designated +// constraints aren't met. +type WatchGroupsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WatchGroupsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WatchGroupsResponseMultiError) AllErrors() []error { return m } + +// WatchGroupsResponseValidationError is the validation error returned by +// WatchGroupsResponse.Validate if the designated constraints aren't met. +type WatchGroupsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WatchGroupsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WatchGroupsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WatchGroupsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WatchGroupsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WatchGroupsResponseValidationError) ErrorName() string { + return "WatchGroupsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e WatchGroupsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWatchGroupsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WatchGroupsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WatchGroupsResponseValidationError{} + +// Validate checks the field values on WatchGroupsRequest_KnownSortField with +// the rules defined in the proto definition for this message. If any rules +// are violated, the first error encountered is returned, or nil if there are +// no violations. +func (m *WatchGroupsRequest_KnownSortField) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WatchGroupsRequest_KnownSortField +// with the rules defined in the proto definition for this message. If any +// rules are violated, the result is a list of violation errors wrapped in +// WatchGroupsRequest_KnownSortFieldMultiError, or nil if none found. +func (m *WatchGroupsRequest_KnownSortField) ValidateAll() error { + return m.validate(true) +} + +func (m *WatchGroupsRequest_KnownSortField) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.SortBy.(type) { + case *WatchGroupsRequest_KnownSortField_CreatedAt: + if v == nil { + err := WatchGroupsRequest_KnownSortFieldValidationError{ + field: "SortBy", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + // no validation rules for CreatedAt + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return WatchGroupsRequest_KnownSortFieldMultiError(errors) + } + + return nil +} + +// WatchGroupsRequest_KnownSortFieldMultiError is an error wrapping multiple +// validation errors returned by +// WatchGroupsRequest_KnownSortField.ValidateAll() if the designated +// constraints aren't met. +type WatchGroupsRequest_KnownSortFieldMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WatchGroupsRequest_KnownSortFieldMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WatchGroupsRequest_KnownSortFieldMultiError) AllErrors() []error { return m } + +// WatchGroupsRequest_KnownSortFieldValidationError is the validation error +// returned by WatchGroupsRequest_KnownSortField.Validate if the designated +// constraints aren't met. +type WatchGroupsRequest_KnownSortFieldValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WatchGroupsRequest_KnownSortFieldValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WatchGroupsRequest_KnownSortFieldValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WatchGroupsRequest_KnownSortFieldValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WatchGroupsRequest_KnownSortFieldValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WatchGroupsRequest_KnownSortFieldValidationError) ErrorName() string { + return "WatchGroupsRequest_KnownSortFieldValidationError" +} + +// Error satisfies the builtin error interface +func (e WatchGroupsRequest_KnownSortFieldValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWatchGroupsRequest_KnownSortField.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WatchGroupsRequest_KnownSortFieldValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WatchGroupsRequest_KnownSortFieldValidationError{} diff --git a/gen/go/flyteidl2/workflow/run_service_grpc.pb.go b/gen/go/flyteidl2/workflow/run_service_grpc.pb.go new file mode 100644 index 0000000000..e40486e76b --- /dev/null +++ b/gen/go/flyteidl2/workflow/run_service_grpc.pb.go @@ -0,0 +1,783 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: flyteidl2/workflow/run_service.proto + +package workflow + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + RunService_CreateRun_FullMethodName = "/flyteidl2.workflow.RunService/CreateRun" + RunService_AbortRun_FullMethodName = "/flyteidl2.workflow.RunService/AbortRun" + RunService_GetRunDetails_FullMethodName = "/flyteidl2.workflow.RunService/GetRunDetails" + RunService_WatchRunDetails_FullMethodName = "/flyteidl2.workflow.RunService/WatchRunDetails" + RunService_GetActionDetails_FullMethodName = "/flyteidl2.workflow.RunService/GetActionDetails" + RunService_WatchActionDetails_FullMethodName = "/flyteidl2.workflow.RunService/WatchActionDetails" + RunService_GetActionData_FullMethodName = "/flyteidl2.workflow.RunService/GetActionData" + RunService_ListRuns_FullMethodName = "/flyteidl2.workflow.RunService/ListRuns" + RunService_WatchRuns_FullMethodName = "/flyteidl2.workflow.RunService/WatchRuns" + RunService_ListActions_FullMethodName = "/flyteidl2.workflow.RunService/ListActions" + RunService_WatchActions_FullMethodName = "/flyteidl2.workflow.RunService/WatchActions" + RunService_WatchClusterEvents_FullMethodName = "/flyteidl2.workflow.RunService/WatchClusterEvents" + RunService_AbortAction_FullMethodName = "/flyteidl2.workflow.RunService/AbortAction" + RunService_WatchGroups_FullMethodName = "/flyteidl2.workflow.RunService/WatchGroups" +) + +// RunServiceClient is the client API for RunService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type RunServiceClient interface { + // Create a new run of the given task. + CreateRun(ctx context.Context, in *CreateRunRequest, opts ...grpc.CallOption) (*CreateRunResponse, error) + // Abort a run. + AbortRun(ctx context.Context, in *AbortRunRequest, opts ...grpc.CallOption) (*AbortRunResponse, error) + // Get detailed information about a run. + GetRunDetails(ctx context.Context, in *GetRunDetailsRequest, opts ...grpc.CallOption) (*GetRunDetailsResponse, error) + // Stream detailed information updates about a run. The call will terminate when the run reaches a terminal phase. + WatchRunDetails(ctx context.Context, in *WatchRunDetailsRequest, opts ...grpc.CallOption) (RunService_WatchRunDetailsClient, error) + // Get detailed information about an action. + GetActionDetails(ctx context.Context, in *GetActionDetailsRequest, opts ...grpc.CallOption) (*GetActionDetailsResponse, error) + // Stream detailed information updates about an action. The call will terminate when the action reaches a terminal phase. + WatchActionDetails(ctx context.Context, in *WatchActionDetailsRequest, opts ...grpc.CallOption) (RunService_WatchActionDetailsClient, error) + // Get input and output for an action. + GetActionData(ctx context.Context, in *GetActionDataRequest, opts ...grpc.CallOption) (*GetActionDataResponse, error) + // List runs based on the provided filter criteria. + ListRuns(ctx context.Context, in *ListRunsRequest, opts ...grpc.CallOption) (*ListRunsResponse, error) + // Stream updates for runs based on the provided filter criteria. Responses may include newly discovered + // runs or updates to existing ones from the point of invocation. + WatchRuns(ctx context.Context, in *WatchRunsRequest, opts ...grpc.CallOption) (RunService_WatchRunsClient, error) + // List all actions for a given run. + ListActions(ctx context.Context, in *ListActionsRequest, opts ...grpc.CallOption) (*ListActionsResponse, error) + // Stream updates for actions given a run. Responses may include newly discovered nested runs or updates + // to existing ones from the point of invocation. + WatchActions(ctx context.Context, in *WatchActionsRequest, opts ...grpc.CallOption) (RunService_WatchActionsClient, error) + // Stream of k8s cluster events in human readable form + WatchClusterEvents(ctx context.Context, in *WatchClusterEventsRequest, opts ...grpc.CallOption) (RunService_WatchClusterEventsClient, error) + // AbortAction aborts a single action that was previously created or is currently being processed by a worker. + AbortAction(ctx context.Context, in *AbortActionRequest, opts ...grpc.CallOption) (*AbortActionResponse, error) + // Stream updates for task groups based on the provided filter criteria. + WatchGroups(ctx context.Context, in *WatchGroupsRequest, opts ...grpc.CallOption) (RunService_WatchGroupsClient, error) +} + +type runServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewRunServiceClient(cc grpc.ClientConnInterface) RunServiceClient { + return &runServiceClient{cc} +} + +func (c *runServiceClient) CreateRun(ctx context.Context, in *CreateRunRequest, opts ...grpc.CallOption) (*CreateRunResponse, error) { + out := new(CreateRunResponse) + err := c.cc.Invoke(ctx, RunService_CreateRun_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *runServiceClient) AbortRun(ctx context.Context, in *AbortRunRequest, opts ...grpc.CallOption) (*AbortRunResponse, error) { + out := new(AbortRunResponse) + err := c.cc.Invoke(ctx, RunService_AbortRun_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *runServiceClient) GetRunDetails(ctx context.Context, in *GetRunDetailsRequest, opts ...grpc.CallOption) (*GetRunDetailsResponse, error) { + out := new(GetRunDetailsResponse) + err := c.cc.Invoke(ctx, RunService_GetRunDetails_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *runServiceClient) WatchRunDetails(ctx context.Context, in *WatchRunDetailsRequest, opts ...grpc.CallOption) (RunService_WatchRunDetailsClient, error) { + stream, err := c.cc.NewStream(ctx, &RunService_ServiceDesc.Streams[0], RunService_WatchRunDetails_FullMethodName, opts...) + if err != nil { + return nil, err + } + x := &runServiceWatchRunDetailsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type RunService_WatchRunDetailsClient interface { + Recv() (*WatchRunDetailsResponse, error) + grpc.ClientStream +} + +type runServiceWatchRunDetailsClient struct { + grpc.ClientStream +} + +func (x *runServiceWatchRunDetailsClient) Recv() (*WatchRunDetailsResponse, error) { + m := new(WatchRunDetailsResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *runServiceClient) GetActionDetails(ctx context.Context, in *GetActionDetailsRequest, opts ...grpc.CallOption) (*GetActionDetailsResponse, error) { + out := new(GetActionDetailsResponse) + err := c.cc.Invoke(ctx, RunService_GetActionDetails_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *runServiceClient) WatchActionDetails(ctx context.Context, in *WatchActionDetailsRequest, opts ...grpc.CallOption) (RunService_WatchActionDetailsClient, error) { + stream, err := c.cc.NewStream(ctx, &RunService_ServiceDesc.Streams[1], RunService_WatchActionDetails_FullMethodName, opts...) + if err != nil { + return nil, err + } + x := &runServiceWatchActionDetailsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type RunService_WatchActionDetailsClient interface { + Recv() (*WatchActionDetailsResponse, error) + grpc.ClientStream +} + +type runServiceWatchActionDetailsClient struct { + grpc.ClientStream +} + +func (x *runServiceWatchActionDetailsClient) Recv() (*WatchActionDetailsResponse, error) { + m := new(WatchActionDetailsResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *runServiceClient) GetActionData(ctx context.Context, in *GetActionDataRequest, opts ...grpc.CallOption) (*GetActionDataResponse, error) { + out := new(GetActionDataResponse) + err := c.cc.Invoke(ctx, RunService_GetActionData_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *runServiceClient) ListRuns(ctx context.Context, in *ListRunsRequest, opts ...grpc.CallOption) (*ListRunsResponse, error) { + out := new(ListRunsResponse) + err := c.cc.Invoke(ctx, RunService_ListRuns_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *runServiceClient) WatchRuns(ctx context.Context, in *WatchRunsRequest, opts ...grpc.CallOption) (RunService_WatchRunsClient, error) { + stream, err := c.cc.NewStream(ctx, &RunService_ServiceDesc.Streams[2], RunService_WatchRuns_FullMethodName, opts...) + if err != nil { + return nil, err + } + x := &runServiceWatchRunsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type RunService_WatchRunsClient interface { + Recv() (*WatchRunsResponse, error) + grpc.ClientStream +} + +type runServiceWatchRunsClient struct { + grpc.ClientStream +} + +func (x *runServiceWatchRunsClient) Recv() (*WatchRunsResponse, error) { + m := new(WatchRunsResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *runServiceClient) ListActions(ctx context.Context, in *ListActionsRequest, opts ...grpc.CallOption) (*ListActionsResponse, error) { + out := new(ListActionsResponse) + err := c.cc.Invoke(ctx, RunService_ListActions_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *runServiceClient) WatchActions(ctx context.Context, in *WatchActionsRequest, opts ...grpc.CallOption) (RunService_WatchActionsClient, error) { + stream, err := c.cc.NewStream(ctx, &RunService_ServiceDesc.Streams[3], RunService_WatchActions_FullMethodName, opts...) + if err != nil { + return nil, err + } + x := &runServiceWatchActionsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type RunService_WatchActionsClient interface { + Recv() (*WatchActionsResponse, error) + grpc.ClientStream +} + +type runServiceWatchActionsClient struct { + grpc.ClientStream +} + +func (x *runServiceWatchActionsClient) Recv() (*WatchActionsResponse, error) { + m := new(WatchActionsResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *runServiceClient) WatchClusterEvents(ctx context.Context, in *WatchClusterEventsRequest, opts ...grpc.CallOption) (RunService_WatchClusterEventsClient, error) { + stream, err := c.cc.NewStream(ctx, &RunService_ServiceDesc.Streams[4], RunService_WatchClusterEvents_FullMethodName, opts...) + if err != nil { + return nil, err + } + x := &runServiceWatchClusterEventsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type RunService_WatchClusterEventsClient interface { + Recv() (*WatchClusterEventsResponse, error) + grpc.ClientStream +} + +type runServiceWatchClusterEventsClient struct { + grpc.ClientStream +} + +func (x *runServiceWatchClusterEventsClient) Recv() (*WatchClusterEventsResponse, error) { + m := new(WatchClusterEventsResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *runServiceClient) AbortAction(ctx context.Context, in *AbortActionRequest, opts ...grpc.CallOption) (*AbortActionResponse, error) { + out := new(AbortActionResponse) + err := c.cc.Invoke(ctx, RunService_AbortAction_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *runServiceClient) WatchGroups(ctx context.Context, in *WatchGroupsRequest, opts ...grpc.CallOption) (RunService_WatchGroupsClient, error) { + stream, err := c.cc.NewStream(ctx, &RunService_ServiceDesc.Streams[5], RunService_WatchGroups_FullMethodName, opts...) + if err != nil { + return nil, err + } + x := &runServiceWatchGroupsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type RunService_WatchGroupsClient interface { + Recv() (*WatchGroupsResponse, error) + grpc.ClientStream +} + +type runServiceWatchGroupsClient struct { + grpc.ClientStream +} + +func (x *runServiceWatchGroupsClient) Recv() (*WatchGroupsResponse, error) { + m := new(WatchGroupsResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// RunServiceServer is the server API for RunService service. +// All implementations should embed UnimplementedRunServiceServer +// for forward compatibility +type RunServiceServer interface { + // Create a new run of the given task. + CreateRun(context.Context, *CreateRunRequest) (*CreateRunResponse, error) + // Abort a run. + AbortRun(context.Context, *AbortRunRequest) (*AbortRunResponse, error) + // Get detailed information about a run. + GetRunDetails(context.Context, *GetRunDetailsRequest) (*GetRunDetailsResponse, error) + // Stream detailed information updates about a run. The call will terminate when the run reaches a terminal phase. + WatchRunDetails(*WatchRunDetailsRequest, RunService_WatchRunDetailsServer) error + // Get detailed information about an action. + GetActionDetails(context.Context, *GetActionDetailsRequest) (*GetActionDetailsResponse, error) + // Stream detailed information updates about an action. The call will terminate when the action reaches a terminal phase. + WatchActionDetails(*WatchActionDetailsRequest, RunService_WatchActionDetailsServer) error + // Get input and output for an action. + GetActionData(context.Context, *GetActionDataRequest) (*GetActionDataResponse, error) + // List runs based on the provided filter criteria. + ListRuns(context.Context, *ListRunsRequest) (*ListRunsResponse, error) + // Stream updates for runs based on the provided filter criteria. Responses may include newly discovered + // runs or updates to existing ones from the point of invocation. + WatchRuns(*WatchRunsRequest, RunService_WatchRunsServer) error + // List all actions for a given run. + ListActions(context.Context, *ListActionsRequest) (*ListActionsResponse, error) + // Stream updates for actions given a run. Responses may include newly discovered nested runs or updates + // to existing ones from the point of invocation. + WatchActions(*WatchActionsRequest, RunService_WatchActionsServer) error + // Stream of k8s cluster events in human readable form + WatchClusterEvents(*WatchClusterEventsRequest, RunService_WatchClusterEventsServer) error + // AbortAction aborts a single action that was previously created or is currently being processed by a worker. + AbortAction(context.Context, *AbortActionRequest) (*AbortActionResponse, error) + // Stream updates for task groups based on the provided filter criteria. + WatchGroups(*WatchGroupsRequest, RunService_WatchGroupsServer) error +} + +// UnimplementedRunServiceServer should be embedded to have forward compatible implementations. +type UnimplementedRunServiceServer struct { +} + +func (UnimplementedRunServiceServer) CreateRun(context.Context, *CreateRunRequest) (*CreateRunResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CreateRun not implemented") +} +func (UnimplementedRunServiceServer) AbortRun(context.Context, *AbortRunRequest) (*AbortRunResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method AbortRun not implemented") +} +func (UnimplementedRunServiceServer) GetRunDetails(context.Context, *GetRunDetailsRequest) (*GetRunDetailsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetRunDetails not implemented") +} +func (UnimplementedRunServiceServer) WatchRunDetails(*WatchRunDetailsRequest, RunService_WatchRunDetailsServer) error { + return status.Errorf(codes.Unimplemented, "method WatchRunDetails not implemented") +} +func (UnimplementedRunServiceServer) GetActionDetails(context.Context, *GetActionDetailsRequest) (*GetActionDetailsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetActionDetails not implemented") +} +func (UnimplementedRunServiceServer) WatchActionDetails(*WatchActionDetailsRequest, RunService_WatchActionDetailsServer) error { + return status.Errorf(codes.Unimplemented, "method WatchActionDetails not implemented") +} +func (UnimplementedRunServiceServer) GetActionData(context.Context, *GetActionDataRequest) (*GetActionDataResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetActionData not implemented") +} +func (UnimplementedRunServiceServer) ListRuns(context.Context, *ListRunsRequest) (*ListRunsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ListRuns not implemented") +} +func (UnimplementedRunServiceServer) WatchRuns(*WatchRunsRequest, RunService_WatchRunsServer) error { + return status.Errorf(codes.Unimplemented, "method WatchRuns not implemented") +} +func (UnimplementedRunServiceServer) ListActions(context.Context, *ListActionsRequest) (*ListActionsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ListActions not implemented") +} +func (UnimplementedRunServiceServer) WatchActions(*WatchActionsRequest, RunService_WatchActionsServer) error { + return status.Errorf(codes.Unimplemented, "method WatchActions not implemented") +} +func (UnimplementedRunServiceServer) WatchClusterEvents(*WatchClusterEventsRequest, RunService_WatchClusterEventsServer) error { + return status.Errorf(codes.Unimplemented, "method WatchClusterEvents not implemented") +} +func (UnimplementedRunServiceServer) AbortAction(context.Context, *AbortActionRequest) (*AbortActionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method AbortAction not implemented") +} +func (UnimplementedRunServiceServer) WatchGroups(*WatchGroupsRequest, RunService_WatchGroupsServer) error { + return status.Errorf(codes.Unimplemented, "method WatchGroups not implemented") +} + +// UnsafeRunServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to RunServiceServer will +// result in compilation errors. +type UnsafeRunServiceServer interface { + mustEmbedUnimplementedRunServiceServer() +} + +func RegisterRunServiceServer(s grpc.ServiceRegistrar, srv RunServiceServer) { + s.RegisterService(&RunService_ServiceDesc, srv) +} + +func _RunService_CreateRun_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CreateRunRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RunServiceServer).CreateRun(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: RunService_CreateRun_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RunServiceServer).CreateRun(ctx, req.(*CreateRunRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _RunService_AbortRun_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AbortRunRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RunServiceServer).AbortRun(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: RunService_AbortRun_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RunServiceServer).AbortRun(ctx, req.(*AbortRunRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _RunService_GetRunDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetRunDetailsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RunServiceServer).GetRunDetails(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: RunService_GetRunDetails_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RunServiceServer).GetRunDetails(ctx, req.(*GetRunDetailsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _RunService_WatchRunDetails_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(WatchRunDetailsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(RunServiceServer).WatchRunDetails(m, &runServiceWatchRunDetailsServer{stream}) +} + +type RunService_WatchRunDetailsServer interface { + Send(*WatchRunDetailsResponse) error + grpc.ServerStream +} + +type runServiceWatchRunDetailsServer struct { + grpc.ServerStream +} + +func (x *runServiceWatchRunDetailsServer) Send(m *WatchRunDetailsResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _RunService_GetActionDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetActionDetailsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RunServiceServer).GetActionDetails(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: RunService_GetActionDetails_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RunServiceServer).GetActionDetails(ctx, req.(*GetActionDetailsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _RunService_WatchActionDetails_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(WatchActionDetailsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(RunServiceServer).WatchActionDetails(m, &runServiceWatchActionDetailsServer{stream}) +} + +type RunService_WatchActionDetailsServer interface { + Send(*WatchActionDetailsResponse) error + grpc.ServerStream +} + +type runServiceWatchActionDetailsServer struct { + grpc.ServerStream +} + +func (x *runServiceWatchActionDetailsServer) Send(m *WatchActionDetailsResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _RunService_GetActionData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetActionDataRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RunServiceServer).GetActionData(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: RunService_GetActionData_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RunServiceServer).GetActionData(ctx, req.(*GetActionDataRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _RunService_ListRuns_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListRunsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RunServiceServer).ListRuns(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: RunService_ListRuns_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RunServiceServer).ListRuns(ctx, req.(*ListRunsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _RunService_WatchRuns_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(WatchRunsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(RunServiceServer).WatchRuns(m, &runServiceWatchRunsServer{stream}) +} + +type RunService_WatchRunsServer interface { + Send(*WatchRunsResponse) error + grpc.ServerStream +} + +type runServiceWatchRunsServer struct { + grpc.ServerStream +} + +func (x *runServiceWatchRunsServer) Send(m *WatchRunsResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _RunService_ListActions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListActionsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RunServiceServer).ListActions(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: RunService_ListActions_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RunServiceServer).ListActions(ctx, req.(*ListActionsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _RunService_WatchActions_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(WatchActionsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(RunServiceServer).WatchActions(m, &runServiceWatchActionsServer{stream}) +} + +type RunService_WatchActionsServer interface { + Send(*WatchActionsResponse) error + grpc.ServerStream +} + +type runServiceWatchActionsServer struct { + grpc.ServerStream +} + +func (x *runServiceWatchActionsServer) Send(m *WatchActionsResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _RunService_WatchClusterEvents_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(WatchClusterEventsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(RunServiceServer).WatchClusterEvents(m, &runServiceWatchClusterEventsServer{stream}) +} + +type RunService_WatchClusterEventsServer interface { + Send(*WatchClusterEventsResponse) error + grpc.ServerStream +} + +type runServiceWatchClusterEventsServer struct { + grpc.ServerStream +} + +func (x *runServiceWatchClusterEventsServer) Send(m *WatchClusterEventsResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _RunService_AbortAction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AbortActionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RunServiceServer).AbortAction(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: RunService_AbortAction_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RunServiceServer).AbortAction(ctx, req.(*AbortActionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _RunService_WatchGroups_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(WatchGroupsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(RunServiceServer).WatchGroups(m, &runServiceWatchGroupsServer{stream}) +} + +type RunService_WatchGroupsServer interface { + Send(*WatchGroupsResponse) error + grpc.ServerStream +} + +type runServiceWatchGroupsServer struct { + grpc.ServerStream +} + +func (x *runServiceWatchGroupsServer) Send(m *WatchGroupsResponse) error { + return x.ServerStream.SendMsg(m) +} + +// RunService_ServiceDesc is the grpc.ServiceDesc for RunService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var RunService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.workflow.RunService", + HandlerType: (*RunServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "CreateRun", + Handler: _RunService_CreateRun_Handler, + }, + { + MethodName: "AbortRun", + Handler: _RunService_AbortRun_Handler, + }, + { + MethodName: "GetRunDetails", + Handler: _RunService_GetRunDetails_Handler, + }, + { + MethodName: "GetActionDetails", + Handler: _RunService_GetActionDetails_Handler, + }, + { + MethodName: "GetActionData", + Handler: _RunService_GetActionData_Handler, + }, + { + MethodName: "ListRuns", + Handler: _RunService_ListRuns_Handler, + }, + { + MethodName: "ListActions", + Handler: _RunService_ListActions_Handler, + }, + { + MethodName: "AbortAction", + Handler: _RunService_AbortAction_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "WatchRunDetails", + Handler: _RunService_WatchRunDetails_Handler, + ServerStreams: true, + }, + { + StreamName: "WatchActionDetails", + Handler: _RunService_WatchActionDetails_Handler, + ServerStreams: true, + }, + { + StreamName: "WatchRuns", + Handler: _RunService_WatchRuns_Handler, + ServerStreams: true, + }, + { + StreamName: "WatchActions", + Handler: _RunService_WatchActions_Handler, + ServerStreams: true, + }, + { + StreamName: "WatchClusterEvents", + Handler: _RunService_WatchClusterEvents_Handler, + ServerStreams: true, + }, + { + StreamName: "WatchGroups", + Handler: _RunService_WatchGroups_Handler, + ServerStreams: true, + }, + }, + Metadata: "flyteidl2/workflow/run_service.proto", +} diff --git a/gen/go/flyteidl2/workflow/state_service.pb.go b/gen/go/flyteidl2/workflow/state_service.pb.go new file mode 100644 index 0000000000..1648ad7b22 --- /dev/null +++ b/gen/go/flyteidl2/workflow/state_service.pb.go @@ -0,0 +1,856 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/workflow/state_service.proto + +package workflow + +import ( + _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + status "google.golang.org/genproto/googleapis/rpc/status" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// request message to put the state of an action. +type PutRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // a unique identifier for the action. + ActionId *common.ActionIdentifier `protobuf:"bytes,1,opt,name=action_id,json=actionId,proto3" json:"action_id,omitempty"` + // optional name of the parent action if this is a nested action. + ParentActionName *string `protobuf:"bytes,2,opt,name=parent_action_name,json=parentActionName,proto3,oneof" json:"parent_action_name,omitempty"` + // currently we will store state as a json serialized `NodeStatus` object. this will be required + // to seamlessly integrate with existing FlytePropeller node execution logic. we can update this + // to be a subset of fields in the future if there are necessary performance improvements. + State string `protobuf:"bytes,3,opt,name=state,proto3" json:"state,omitempty"` +} + +func (x *PutRequest) Reset() { + *x = PutRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_state_service_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PutRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PutRequest) ProtoMessage() {} + +func (x *PutRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_state_service_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PutRequest.ProtoReflect.Descriptor instead. +func (*PutRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_state_service_proto_rawDescGZIP(), []int{0} +} + +func (x *PutRequest) GetActionId() *common.ActionIdentifier { + if x != nil { + return x.ActionId + } + return nil +} + +func (x *PutRequest) GetParentActionName() string { + if x != nil && x.ParentActionName != nil { + return *x.ParentActionName + } + return "" +} + +func (x *PutRequest) GetState() string { + if x != nil { + return x.State + } + return "" +} + +// response message for putting the state of an action. +type PutResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // a unique identifier for the action. + ActionId *common.ActionIdentifier `protobuf:"bytes,1,opt,name=action_id,json=actionId,proto3" json:"action_id,omitempty"` + // The result. + Status *status.Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"` +} + +func (x *PutResponse) Reset() { + *x = PutResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_state_service_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PutResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PutResponse) ProtoMessage() {} + +func (x *PutResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_state_service_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PutResponse.ProtoReflect.Descriptor instead. +func (*PutResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_state_service_proto_rawDescGZIP(), []int{1} +} + +func (x *PutResponse) GetActionId() *common.ActionIdentifier { + if x != nil { + return x.ActionId + } + return nil +} + +func (x *PutResponse) GetStatus() *status.Status { + if x != nil { + return x.Status + } + return nil +} + +// request message to get the state of an action. +type GetRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // a unique identifier for the action. + ActionId *common.ActionIdentifier `protobuf:"bytes,1,opt,name=action_id,json=actionId,proto3" json:"action_id,omitempty"` +} + +func (x *GetRequest) Reset() { + *x = GetRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_state_service_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetRequest) ProtoMessage() {} + +func (x *GetRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_state_service_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetRequest.ProtoReflect.Descriptor instead. +func (*GetRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_state_service_proto_rawDescGZIP(), []int{2} +} + +func (x *GetRequest) GetActionId() *common.ActionIdentifier { + if x != nil { + return x.ActionId + } + return nil +} + +// response message for getting the state of an action. +type GetResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // a unique identifier for the action. + ActionId *common.ActionIdentifier `protobuf:"bytes,1,opt,name=action_id,json=actionId,proto3" json:"action_id,omitempty"` + // The result. + Status *status.Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"` + // a json serialized `NodeStatus` object. + State string `protobuf:"bytes,3,opt,name=state,proto3" json:"state,omitempty"` +} + +func (x *GetResponse) Reset() { + *x = GetResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_state_service_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetResponse) ProtoMessage() {} + +func (x *GetResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_state_service_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetResponse.ProtoReflect.Descriptor instead. +func (*GetResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_state_service_proto_rawDescGZIP(), []int{3} +} + +func (x *GetResponse) GetActionId() *common.ActionIdentifier { + if x != nil { + return x.ActionId + } + return nil +} + +func (x *GetResponse) GetStatus() *status.Status { + if x != nil { + return x.Status + } + return nil +} + +func (x *GetResponse) GetState() string { + if x != nil { + return x.State + } + return "" +} + +// request message for watching updates to the state of actions. +type WatchRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // criteria for filtering which actions to watch. + // + // Types that are assignable to Filter: + // + // *WatchRequest_ParentActionId + Filter isWatchRequest_Filter `protobuf_oneof:"filter"` +} + +func (x *WatchRequest) Reset() { + *x = WatchRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_state_service_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchRequest) ProtoMessage() {} + +func (x *WatchRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_state_service_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchRequest.ProtoReflect.Descriptor instead. +func (*WatchRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_state_service_proto_rawDescGZIP(), []int{4} +} + +func (m *WatchRequest) GetFilter() isWatchRequest_Filter { + if m != nil { + return m.Filter + } + return nil +} + +func (x *WatchRequest) GetParentActionId() *common.ActionIdentifier { + if x, ok := x.GetFilter().(*WatchRequest_ParentActionId); ok { + return x.ParentActionId + } + return nil +} + +type isWatchRequest_Filter interface { + isWatchRequest_Filter() +} + +type WatchRequest_ParentActionId struct { + // a unique identifier for the parent action to watch. this will result in updates for all child + // actions. + ParentActionId *common.ActionIdentifier `protobuf:"bytes,1,opt,name=parent_action_id,json=parentActionId,proto3,oneof"` +} + +func (*WatchRequest_ParentActionId) isWatchRequest_Filter() {} + +// response message for watching updates to the state of actions. +type WatchResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // an update to the state of a specific action. + // + // Types that are assignable to Message: + // + // *WatchResponse_ActionUpdate + // *WatchResponse_ControlMessage + Message isWatchResponse_Message `protobuf_oneof:"message"` +} + +func (x *WatchResponse) Reset() { + *x = WatchResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_state_service_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchResponse) ProtoMessage() {} + +func (x *WatchResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_state_service_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchResponse.ProtoReflect.Descriptor instead. +func (*WatchResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_state_service_proto_rawDescGZIP(), []int{5} +} + +func (m *WatchResponse) GetMessage() isWatchResponse_Message { + if m != nil { + return m.Message + } + return nil +} + +func (x *WatchResponse) GetActionUpdate() *ActionUpdate { + if x, ok := x.GetMessage().(*WatchResponse_ActionUpdate); ok { + return x.ActionUpdate + } + return nil +} + +func (x *WatchResponse) GetControlMessage() *ControlMessage { + if x, ok := x.GetMessage().(*WatchResponse_ControlMessage); ok { + return x.ControlMessage + } + return nil +} + +type isWatchResponse_Message interface { + isWatchResponse_Message() +} + +type WatchResponse_ActionUpdate struct { + ActionUpdate *ActionUpdate `protobuf:"bytes,1,opt,name=action_update,json=actionUpdate,proto3,oneof"` +} + +type WatchResponse_ControlMessage struct { + ControlMessage *ControlMessage `protobuf:"bytes,2,opt,name=control_message,json=controlMessage,proto3,oneof"` +} + +func (*WatchResponse_ActionUpdate) isWatchResponse_Message() {} + +func (*WatchResponse_ControlMessage) isWatchResponse_Message() {} + +type ControlMessage struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // a sentinel value to indicate the end of a stream. this is used to disambiguate between a control message and a + // regular message. When a watch begins the service will return the existing state of all actions, then a sentinel value, + // before continuing on with ongoing updates. this sequence disambiguates the current state from new updates. + Sentinel bool `protobuf:"varint,1,opt,name=sentinel,proto3" json:"sentinel,omitempty"` +} + +func (x *ControlMessage) Reset() { + *x = ControlMessage{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_state_service_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ControlMessage) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ControlMessage) ProtoMessage() {} + +func (x *ControlMessage) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_state_service_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ControlMessage.ProtoReflect.Descriptor instead. +func (*ControlMessage) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_state_service_proto_rawDescGZIP(), []int{6} +} + +func (x *ControlMessage) GetSentinel() bool { + if x != nil { + return x.Sentinel + } + return false +} + +// message to represent an update to the state of an action. +type ActionUpdate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // A unique identifier for the action. `nil` is used as a sentinel value; for example, + ActionId *common.ActionIdentifier `protobuf:"bytes,1,opt,name=action_id,json=actionId,proto3" json:"action_id,omitempty"` + // the current phase of the action. + Phase common.ActionPhase `protobuf:"varint,2,opt,name=phase,proto3,enum=flyteidl2.common.ActionPhase" json:"phase,omitempty"` + // the error associated with the action (if exists). + Error *core.ExecutionError `protobuf:"bytes,3,opt,name=error,proto3,oneof" json:"error,omitempty"` + // the output uri for the action + OutputUri string `protobuf:"bytes,4,opt,name=output_uri,json=outputUri,proto3" json:"output_uri,omitempty"` +} + +func (x *ActionUpdate) Reset() { + *x = ActionUpdate{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_state_service_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ActionUpdate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ActionUpdate) ProtoMessage() {} + +func (x *ActionUpdate) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_state_service_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ActionUpdate.ProtoReflect.Descriptor instead. +func (*ActionUpdate) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_state_service_proto_rawDescGZIP(), []int{7} +} + +func (x *ActionUpdate) GetActionId() *common.ActionIdentifier { + if x != nil { + return x.ActionId + } + return nil +} + +func (x *ActionUpdate) GetPhase() common.ActionPhase { + if x != nil { + return x.Phase + } + return common.ActionPhase(0) +} + +func (x *ActionUpdate) GetError() *core.ExecutionError { + if x != nil { + return x.Error + } + return nil +} + +func (x *ActionUpdate) GetOutputUri() string { + if x != nil { + return x.OutputUri + } + return "" +} + +var File_flyteidl2_workflow_state_service_proto protoreflect.FileDescriptor + +var file_flyteidl2_workflow_state_service_proto_rawDesc = []byte{ + 0x0a, 0x26, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x1a, 0x1b, 0x62, 0x75, + 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x70, + 0x68, 0x61, 0x73, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x17, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2f, 0x72, 0x70, 0x63, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x22, 0xbe, 0x01, 0x0a, 0x0a, 0x50, 0x75, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, + 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x31, 0x0a, 0x12, 0x70, + 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x10, 0x70, 0x61, 0x72, 0x65, 0x6e, + 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, 0x1d, + 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, + 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x42, 0x15, 0x0a, + 0x13, 0x5f, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x8a, 0x01, 0x0a, 0x0b, 0x50, 0x75, 0x74, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, + 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x32, 0x0a, + 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x22, 0x55, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0xa9, 0x01, 0x0a, 0x0b, 0x47, 0x65, 0x74, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, + 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, + 0x64, 0x12, 0x32, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x72, 0x70, 0x63, 0x2e, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x06, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1d, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x05, 0x73, + 0x74, 0x61, 0x74, 0x65, 0x22, 0x6f, 0x0a, 0x0c, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x4e, 0x0a, 0x10, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x48, 0x00, 0x52, 0x0e, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x41, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x64, 0x42, 0x0f, 0x0a, 0x06, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x05, + 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, 0xb2, 0x01, 0x0a, 0x0d, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x0d, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x48, 0x00, 0x52, 0x0c, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x12, 0x4d, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x5f, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x48, 0x00, 0x52, + 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x42, + 0x09, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x2c, 0x0a, 0x0e, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1a, 0x0a, 0x08, + 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, + 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x22, 0xf0, 0x01, 0x0a, 0x0c, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x64, 0x12, 0x33, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x68, 0x61, 0x73, 0x65, + 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x48, 0x00, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x88, + 0x01, 0x01, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x75, 0x72, 0x69, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x55, 0x72, + 0x69, 0x42, 0x08, 0x0a, 0x06, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x32, 0xf4, 0x01, 0x0a, 0x0c, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x48, 0x0a, 0x03, + 0x50, 0x75, 0x74, 0x12, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x50, 0x75, 0x74, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x50, 0x75, 0x74, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x48, 0x0a, 0x03, 0x47, 0x65, 0x74, 0x12, 0x1e, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, + 0x12, 0x50, 0x0a, 0x05, 0x57, 0x61, 0x74, 0x63, 0x68, 0x12, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x57, + 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, + 0x30, 0x01, 0x42, 0xce, 0x01, 0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x11, 0x53, + 0x74, 0x61, 0x74, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, + 0x48, 0x02, 0x50, 0x01, 0x5a, 0x36, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, + 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, + 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xa2, 0x02, 0x03, 0x46, + 0x57, 0x58, 0xaa, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x57, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xca, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xe2, 0x02, 0x1e, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x13, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x57, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_workflow_state_service_proto_rawDescOnce sync.Once + file_flyteidl2_workflow_state_service_proto_rawDescData = file_flyteidl2_workflow_state_service_proto_rawDesc +) + +func file_flyteidl2_workflow_state_service_proto_rawDescGZIP() []byte { + file_flyteidl2_workflow_state_service_proto_rawDescOnce.Do(func() { + file_flyteidl2_workflow_state_service_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_workflow_state_service_proto_rawDescData) + }) + return file_flyteidl2_workflow_state_service_proto_rawDescData +} + +var file_flyteidl2_workflow_state_service_proto_msgTypes = make([]protoimpl.MessageInfo, 8) +var file_flyteidl2_workflow_state_service_proto_goTypes = []interface{}{ + (*PutRequest)(nil), // 0: flyteidl2.workflow.PutRequest + (*PutResponse)(nil), // 1: flyteidl2.workflow.PutResponse + (*GetRequest)(nil), // 2: flyteidl2.workflow.GetRequest + (*GetResponse)(nil), // 3: flyteidl2.workflow.GetResponse + (*WatchRequest)(nil), // 4: flyteidl2.workflow.WatchRequest + (*WatchResponse)(nil), // 5: flyteidl2.workflow.WatchResponse + (*ControlMessage)(nil), // 6: flyteidl2.workflow.ControlMessage + (*ActionUpdate)(nil), // 7: flyteidl2.workflow.ActionUpdate + (*common.ActionIdentifier)(nil), // 8: flyteidl2.common.ActionIdentifier + (*status.Status)(nil), // 9: google.rpc.Status + (common.ActionPhase)(0), // 10: flyteidl2.common.ActionPhase + (*core.ExecutionError)(nil), // 11: flyteidl2.core.ExecutionError +} +var file_flyteidl2_workflow_state_service_proto_depIdxs = []int32{ + 8, // 0: flyteidl2.workflow.PutRequest.action_id:type_name -> flyteidl2.common.ActionIdentifier + 8, // 1: flyteidl2.workflow.PutResponse.action_id:type_name -> flyteidl2.common.ActionIdentifier + 9, // 2: flyteidl2.workflow.PutResponse.status:type_name -> google.rpc.Status + 8, // 3: flyteidl2.workflow.GetRequest.action_id:type_name -> flyteidl2.common.ActionIdentifier + 8, // 4: flyteidl2.workflow.GetResponse.action_id:type_name -> flyteidl2.common.ActionIdentifier + 9, // 5: flyteidl2.workflow.GetResponse.status:type_name -> google.rpc.Status + 8, // 6: flyteidl2.workflow.WatchRequest.parent_action_id:type_name -> flyteidl2.common.ActionIdentifier + 7, // 7: flyteidl2.workflow.WatchResponse.action_update:type_name -> flyteidl2.workflow.ActionUpdate + 6, // 8: flyteidl2.workflow.WatchResponse.control_message:type_name -> flyteidl2.workflow.ControlMessage + 8, // 9: flyteidl2.workflow.ActionUpdate.action_id:type_name -> flyteidl2.common.ActionIdentifier + 10, // 10: flyteidl2.workflow.ActionUpdate.phase:type_name -> flyteidl2.common.ActionPhase + 11, // 11: flyteidl2.workflow.ActionUpdate.error:type_name -> flyteidl2.core.ExecutionError + 0, // 12: flyteidl2.workflow.StateService.Put:input_type -> flyteidl2.workflow.PutRequest + 2, // 13: flyteidl2.workflow.StateService.Get:input_type -> flyteidl2.workflow.GetRequest + 4, // 14: flyteidl2.workflow.StateService.Watch:input_type -> flyteidl2.workflow.WatchRequest + 1, // 15: flyteidl2.workflow.StateService.Put:output_type -> flyteidl2.workflow.PutResponse + 3, // 16: flyteidl2.workflow.StateService.Get:output_type -> flyteidl2.workflow.GetResponse + 5, // 17: flyteidl2.workflow.StateService.Watch:output_type -> flyteidl2.workflow.WatchResponse + 15, // [15:18] is the sub-list for method output_type + 12, // [12:15] is the sub-list for method input_type + 12, // [12:12] is the sub-list for extension type_name + 12, // [12:12] is the sub-list for extension extendee + 0, // [0:12] is the sub-list for field type_name +} + +func init() { file_flyteidl2_workflow_state_service_proto_init() } +func file_flyteidl2_workflow_state_service_proto_init() { + if File_flyteidl2_workflow_state_service_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_workflow_state_service_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PutRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_state_service_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PutResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_state_service_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_state_service_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_state_service_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_state_service_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_state_service_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ControlMessage); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_state_service_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ActionUpdate); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_flyteidl2_workflow_state_service_proto_msgTypes[0].OneofWrappers = []interface{}{} + file_flyteidl2_workflow_state_service_proto_msgTypes[4].OneofWrappers = []interface{}{ + (*WatchRequest_ParentActionId)(nil), + } + file_flyteidl2_workflow_state_service_proto_msgTypes[5].OneofWrappers = []interface{}{ + (*WatchResponse_ActionUpdate)(nil), + (*WatchResponse_ControlMessage)(nil), + } + file_flyteidl2_workflow_state_service_proto_msgTypes[7].OneofWrappers = []interface{}{} + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_workflow_state_service_proto_rawDesc, + NumEnums: 0, + NumMessages: 8, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_flyteidl2_workflow_state_service_proto_goTypes, + DependencyIndexes: file_flyteidl2_workflow_state_service_proto_depIdxs, + MessageInfos: file_flyteidl2_workflow_state_service_proto_msgTypes, + }.Build() + File_flyteidl2_workflow_state_service_proto = out.File + file_flyteidl2_workflow_state_service_proto_rawDesc = nil + file_flyteidl2_workflow_state_service_proto_goTypes = nil + file_flyteidl2_workflow_state_service_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/workflow/state_service.pb.validate.go b/gen/go/flyteidl2/workflow/state_service.pb.validate.go new file mode 100644 index 0000000000..ab67f0e1e2 --- /dev/null +++ b/gen/go/flyteidl2/workflow/state_service.pb.validate.go @@ -0,0 +1,1217 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/workflow/state_service.proto + +package workflow + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" + + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort + + _ = common.ActionPhase(0) +) + +// Validate checks the field values on PutRequest with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *PutRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on PutRequest with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in PutRequestMultiError, or +// nil if none found. +func (m *PutRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *PutRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetActionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PutRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PutRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetActionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PutRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for State + + if m.ParentActionName != nil { + // no validation rules for ParentActionName + } + + if len(errors) > 0 { + return PutRequestMultiError(errors) + } + + return nil +} + +// PutRequestMultiError is an error wrapping multiple validation errors +// returned by PutRequest.ValidateAll() if the designated constraints aren't met. +type PutRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PutRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PutRequestMultiError) AllErrors() []error { return m } + +// PutRequestValidationError is the validation error returned by +// PutRequest.Validate if the designated constraints aren't met. +type PutRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PutRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PutRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PutRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PutRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PutRequestValidationError) ErrorName() string { return "PutRequestValidationError" } + +// Error satisfies the builtin error interface +func (e PutRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPutRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PutRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PutRequestValidationError{} + +// Validate checks the field values on PutResponse with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *PutResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on PutResponse with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in PutResponseMultiError, or +// nil if none found. +func (m *PutResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *PutResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetActionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PutResponseValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PutResponseValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetActionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PutResponseValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetStatus()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, PutResponseValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, PutResponseValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStatus()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return PutResponseValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return PutResponseMultiError(errors) + } + + return nil +} + +// PutResponseMultiError is an error wrapping multiple validation errors +// returned by PutResponse.ValidateAll() if the designated constraints aren't met. +type PutResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m PutResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m PutResponseMultiError) AllErrors() []error { return m } + +// PutResponseValidationError is the validation error returned by +// PutResponse.Validate if the designated constraints aren't met. +type PutResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e PutResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e PutResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e PutResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e PutResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e PutResponseValidationError) ErrorName() string { return "PutResponseValidationError" } + +// Error satisfies the builtin error interface +func (e PutResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sPutResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = PutResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = PutResponseValidationError{} + +// Validate checks the field values on GetRequest with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *GetRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetRequest with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in GetRequestMultiError, or +// nil if none found. +func (m *GetRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *GetRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetActionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetActionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetRequestValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return GetRequestMultiError(errors) + } + + return nil +} + +// GetRequestMultiError is an error wrapping multiple validation errors +// returned by GetRequest.ValidateAll() if the designated constraints aren't met. +type GetRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetRequestMultiError) AllErrors() []error { return m } + +// GetRequestValidationError is the validation error returned by +// GetRequest.Validate if the designated constraints aren't met. +type GetRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetRequestValidationError) ErrorName() string { return "GetRequestValidationError" } + +// Error satisfies the builtin error interface +func (e GetRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetRequestValidationError{} + +// Validate checks the field values on GetResponse with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *GetResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on GetResponse with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in GetResponseMultiError, or +// nil if none found. +func (m *GetResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *GetResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetActionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetResponseValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetResponseValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetActionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetResponseValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetStatus()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, GetResponseValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, GetResponseValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetStatus()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return GetResponseValidationError{ + field: "Status", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for State + + if len(errors) > 0 { + return GetResponseMultiError(errors) + } + + return nil +} + +// GetResponseMultiError is an error wrapping multiple validation errors +// returned by GetResponse.ValidateAll() if the designated constraints aren't met. +type GetResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m GetResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m GetResponseMultiError) AllErrors() []error { return m } + +// GetResponseValidationError is the validation error returned by +// GetResponse.Validate if the designated constraints aren't met. +type GetResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e GetResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e GetResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e GetResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e GetResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e GetResponseValidationError) ErrorName() string { return "GetResponseValidationError" } + +// Error satisfies the builtin error interface +func (e GetResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sGetResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = GetResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = GetResponseValidationError{} + +// Validate checks the field values on WatchRequest with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *WatchRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WatchRequest with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in WatchRequestMultiError, or +// nil if none found. +func (m *WatchRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *WatchRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Filter.(type) { + case *WatchRequest_ParentActionId: + if v == nil { + err := WatchRequestValidationError{ + field: "Filter", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetParentActionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchRequestValidationError{ + field: "ParentActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchRequestValidationError{ + field: "ParentActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetParentActionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchRequestValidationError{ + field: "ParentActionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return WatchRequestMultiError(errors) + } + + return nil +} + +// WatchRequestMultiError is an error wrapping multiple validation errors +// returned by WatchRequest.ValidateAll() if the designated constraints aren't met. +type WatchRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WatchRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WatchRequestMultiError) AllErrors() []error { return m } + +// WatchRequestValidationError is the validation error returned by +// WatchRequest.Validate if the designated constraints aren't met. +type WatchRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WatchRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WatchRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WatchRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WatchRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WatchRequestValidationError) ErrorName() string { return "WatchRequestValidationError" } + +// Error satisfies the builtin error interface +func (e WatchRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWatchRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WatchRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WatchRequestValidationError{} + +// Validate checks the field values on WatchResponse with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *WatchResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on WatchResponse with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in WatchResponseMultiError, or +// nil if none found. +func (m *WatchResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *WatchResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + switch v := m.Message.(type) { + case *WatchResponse_ActionUpdate: + if v == nil { + err := WatchResponseValidationError{ + field: "Message", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetActionUpdate()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchResponseValidationError{ + field: "ActionUpdate", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchResponseValidationError{ + field: "ActionUpdate", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetActionUpdate()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchResponseValidationError{ + field: "ActionUpdate", + reason: "embedded message failed validation", + cause: err, + } + } + } + + case *WatchResponse_ControlMessage: + if v == nil { + err := WatchResponseValidationError{ + field: "Message", + reason: "oneof value cannot be a typed-nil", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetControlMessage()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, WatchResponseValidationError{ + field: "ControlMessage", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, WatchResponseValidationError{ + field: "ControlMessage", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetControlMessage()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return WatchResponseValidationError{ + field: "ControlMessage", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + _ = v // ensures v is used + } + + if len(errors) > 0 { + return WatchResponseMultiError(errors) + } + + return nil +} + +// WatchResponseMultiError is an error wrapping multiple validation errors +// returned by WatchResponse.ValidateAll() if the designated constraints +// aren't met. +type WatchResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m WatchResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m WatchResponseMultiError) AllErrors() []error { return m } + +// WatchResponseValidationError is the validation error returned by +// WatchResponse.Validate if the designated constraints aren't met. +type WatchResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e WatchResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e WatchResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e WatchResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e WatchResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e WatchResponseValidationError) ErrorName() string { return "WatchResponseValidationError" } + +// Error satisfies the builtin error interface +func (e WatchResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sWatchResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = WatchResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = WatchResponseValidationError{} + +// Validate checks the field values on ControlMessage with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ControlMessage) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ControlMessage with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ControlMessageMultiError, +// or nil if none found. +func (m *ControlMessage) ValidateAll() error { + return m.validate(true) +} + +func (m *ControlMessage) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Sentinel + + if len(errors) > 0 { + return ControlMessageMultiError(errors) + } + + return nil +} + +// ControlMessageMultiError is an error wrapping multiple validation errors +// returned by ControlMessage.ValidateAll() if the designated constraints +// aren't met. +type ControlMessageMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ControlMessageMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ControlMessageMultiError) AllErrors() []error { return m } + +// ControlMessageValidationError is the validation error returned by +// ControlMessage.Validate if the designated constraints aren't met. +type ControlMessageValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ControlMessageValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ControlMessageValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ControlMessageValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ControlMessageValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ControlMessageValidationError) ErrorName() string { return "ControlMessageValidationError" } + +// Error satisfies the builtin error interface +func (e ControlMessageValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sControlMessage.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ControlMessageValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ControlMessageValidationError{} + +// Validate checks the field values on ActionUpdate with the rules defined in +// the proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *ActionUpdate) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on ActionUpdate with the rules defined +// in the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ActionUpdateMultiError, or +// nil if none found. +func (m *ActionUpdate) ValidateAll() error { + return m.validate(true) +} + +func (m *ActionUpdate) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetActionId()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionUpdateValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionUpdateValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetActionId()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionUpdateValidationError{ + field: "ActionId", + reason: "embedded message failed validation", + cause: err, + } + } + } + + // no validation rules for Phase + + // no validation rules for OutputUri + + if m.Error != nil { + + if all { + switch v := interface{}(m.GetError()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, ActionUpdateValidationError{ + field: "Error", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, ActionUpdateValidationError{ + field: "Error", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetError()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return ActionUpdateValidationError{ + field: "Error", + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return ActionUpdateMultiError(errors) + } + + return nil +} + +// ActionUpdateMultiError is an error wrapping multiple validation errors +// returned by ActionUpdate.ValidateAll() if the designated constraints aren't met. +type ActionUpdateMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ActionUpdateMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ActionUpdateMultiError) AllErrors() []error { return m } + +// ActionUpdateValidationError is the validation error returned by +// ActionUpdate.Validate if the designated constraints aren't met. +type ActionUpdateValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ActionUpdateValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ActionUpdateValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ActionUpdateValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ActionUpdateValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ActionUpdateValidationError) ErrorName() string { return "ActionUpdateValidationError" } + +// Error satisfies the builtin error interface +func (e ActionUpdateValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sActionUpdate.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ActionUpdateValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ActionUpdateValidationError{} diff --git a/gen/go/flyteidl2/workflow/state_service_grpc.pb.go b/gen/go/flyteidl2/workflow/state_service_grpc.pb.go new file mode 100644 index 0000000000..dfa918f8a7 --- /dev/null +++ b/gen/go/flyteidl2/workflow/state_service_grpc.pb.go @@ -0,0 +1,215 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: flyteidl2/workflow/state_service.proto + +package workflow + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + StateService_Put_FullMethodName = "/flyteidl2.workflow.StateService/Put" + StateService_Get_FullMethodName = "/flyteidl2.workflow.StateService/Get" + StateService_Watch_FullMethodName = "/flyteidl2.workflow.StateService/Watch" +) + +// StateServiceClient is the client API for StateService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type StateServiceClient interface { + // put the state of an action. + Put(ctx context.Context, in *PutRequest, opts ...grpc.CallOption) (*PutResponse, error) + // get the state of an action. + Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) + // watch for updates to the state of actions. this api guarantees at-least-once delivery semantics. + Watch(ctx context.Context, in *WatchRequest, opts ...grpc.CallOption) (StateService_WatchClient, error) +} + +type stateServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewStateServiceClient(cc grpc.ClientConnInterface) StateServiceClient { + return &stateServiceClient{cc} +} + +func (c *stateServiceClient) Put(ctx context.Context, in *PutRequest, opts ...grpc.CallOption) (*PutResponse, error) { + out := new(PutResponse) + err := c.cc.Invoke(ctx, StateService_Put_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *stateServiceClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) { + out := new(GetResponse) + err := c.cc.Invoke(ctx, StateService_Get_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *stateServiceClient) Watch(ctx context.Context, in *WatchRequest, opts ...grpc.CallOption) (StateService_WatchClient, error) { + stream, err := c.cc.NewStream(ctx, &StateService_ServiceDesc.Streams[0], StateService_Watch_FullMethodName, opts...) + if err != nil { + return nil, err + } + x := &stateServiceWatchClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type StateService_WatchClient interface { + Recv() (*WatchResponse, error) + grpc.ClientStream +} + +type stateServiceWatchClient struct { + grpc.ClientStream +} + +func (x *stateServiceWatchClient) Recv() (*WatchResponse, error) { + m := new(WatchResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// StateServiceServer is the server API for StateService service. +// All implementations should embed UnimplementedStateServiceServer +// for forward compatibility +type StateServiceServer interface { + // put the state of an action. + Put(context.Context, *PutRequest) (*PutResponse, error) + // get the state of an action. + Get(context.Context, *GetRequest) (*GetResponse, error) + // watch for updates to the state of actions. this api guarantees at-least-once delivery semantics. + Watch(*WatchRequest, StateService_WatchServer) error +} + +// UnimplementedStateServiceServer should be embedded to have forward compatible implementations. +type UnimplementedStateServiceServer struct { +} + +func (UnimplementedStateServiceServer) Put(context.Context, *PutRequest) (*PutResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Put not implemented") +} +func (UnimplementedStateServiceServer) Get(context.Context, *GetRequest) (*GetResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Get not implemented") +} +func (UnimplementedStateServiceServer) Watch(*WatchRequest, StateService_WatchServer) error { + return status.Errorf(codes.Unimplemented, "method Watch not implemented") +} + +// UnsafeStateServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to StateServiceServer will +// result in compilation errors. +type UnsafeStateServiceServer interface { + mustEmbedUnimplementedStateServiceServer() +} + +func RegisterStateServiceServer(s grpc.ServiceRegistrar, srv StateServiceServer) { + s.RegisterService(&StateService_ServiceDesc, srv) +} + +func _StateService_Put_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PutRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StateServiceServer).Put(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: StateService_Put_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StateServiceServer).Put(ctx, req.(*PutRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _StateService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StateServiceServer).Get(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: StateService_Get_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StateServiceServer).Get(ctx, req.(*GetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _StateService_Watch_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(WatchRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(StateServiceServer).Watch(m, &stateServiceWatchServer{stream}) +} + +type StateService_WatchServer interface { + Send(*WatchResponse) error + grpc.ServerStream +} + +type stateServiceWatchServer struct { + grpc.ServerStream +} + +func (x *stateServiceWatchServer) Send(m *WatchResponse) error { + return x.ServerStream.SendMsg(m) +} + +// StateService_ServiceDesc is the grpc.ServiceDesc for StateService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var StateService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.workflow.StateService", + HandlerType: (*StateServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Put", + Handler: _StateService_Put_Handler, + }, + { + MethodName: "Get", + Handler: _StateService_Get_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "Watch", + Handler: _StateService_Watch_Handler, + ServerStreams: true, + }, + }, + Metadata: "flyteidl2/workflow/state_service.proto", +} diff --git a/gen/go/flyteidl2/workflow/translator_service.pb.go b/gen/go/flyteidl2/workflow/translator_service.pb.go new file mode 100644 index 0000000000..c69ba853a5 --- /dev/null +++ b/gen/go/flyteidl2/workflow/translator_service.pb.go @@ -0,0 +1,720 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc (unknown) +// source: flyteidl2/workflow/translator_service.proto + +package workflow + +import ( + core "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + task "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + structpb "google.golang.org/protobuf/types/known/structpb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type LiteralsToLaunchFormJsonRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The literals to convert to JSON. + Literals []*task.NamedLiteral `protobuf:"bytes,1,rep,name=literals,proto3" json:"literals,omitempty"` + Variables *core.VariableMap `protobuf:"bytes,2,opt,name=variables,proto3" json:"variables,omitempty"` +} + +func (x *LiteralsToLaunchFormJsonRequest) Reset() { + *x = LiteralsToLaunchFormJsonRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_translator_service_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LiteralsToLaunchFormJsonRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LiteralsToLaunchFormJsonRequest) ProtoMessage() {} + +func (x *LiteralsToLaunchFormJsonRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_translator_service_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LiteralsToLaunchFormJsonRequest.ProtoReflect.Descriptor instead. +func (*LiteralsToLaunchFormJsonRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_translator_service_proto_rawDescGZIP(), []int{0} +} + +func (x *LiteralsToLaunchFormJsonRequest) GetLiterals() []*task.NamedLiteral { + if x != nil { + return x.Literals + } + return nil +} + +func (x *LiteralsToLaunchFormJsonRequest) GetVariables() *core.VariableMap { + if x != nil { + return x.Variables + } + return nil +} + +type LiteralsToLaunchFormJsonResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The JSON for the literals. + Json *structpb.Struct `protobuf:"bytes,1,opt,name=json,proto3" json:"json,omitempty"` +} + +func (x *LiteralsToLaunchFormJsonResponse) Reset() { + *x = LiteralsToLaunchFormJsonResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_translator_service_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LiteralsToLaunchFormJsonResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LiteralsToLaunchFormJsonResponse) ProtoMessage() {} + +func (x *LiteralsToLaunchFormJsonResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_translator_service_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LiteralsToLaunchFormJsonResponse.ProtoReflect.Descriptor instead. +func (*LiteralsToLaunchFormJsonResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_translator_service_proto_rawDescGZIP(), []int{1} +} + +func (x *LiteralsToLaunchFormJsonResponse) GetJson() *structpb.Struct { + if x != nil { + return x.Json + } + return nil +} + +type LaunchFormJsonToLiteralsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The JSON schema to convert to literals. + Json *structpb.Struct `protobuf:"bytes,1,opt,name=json,proto3" json:"json,omitempty"` +} + +func (x *LaunchFormJsonToLiteralsRequest) Reset() { + *x = LaunchFormJsonToLiteralsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_translator_service_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LaunchFormJsonToLiteralsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LaunchFormJsonToLiteralsRequest) ProtoMessage() {} + +func (x *LaunchFormJsonToLiteralsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_translator_service_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LaunchFormJsonToLiteralsRequest.ProtoReflect.Descriptor instead. +func (*LaunchFormJsonToLiteralsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_translator_service_proto_rawDescGZIP(), []int{2} +} + +func (x *LaunchFormJsonToLiteralsRequest) GetJson() *structpb.Struct { + if x != nil { + return x.Json + } + return nil +} + +type LaunchFormJsonToLiteralsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The literals generated from the JSON schema. + Literals []*task.NamedLiteral `protobuf:"bytes,1,rep,name=literals,proto3" json:"literals,omitempty"` +} + +func (x *LaunchFormJsonToLiteralsResponse) Reset() { + *x = LaunchFormJsonToLiteralsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_translator_service_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LaunchFormJsonToLiteralsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LaunchFormJsonToLiteralsResponse) ProtoMessage() {} + +func (x *LaunchFormJsonToLiteralsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_translator_service_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LaunchFormJsonToLiteralsResponse.ProtoReflect.Descriptor instead. +func (*LaunchFormJsonToLiteralsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_translator_service_proto_rawDescGZIP(), []int{3} +} + +func (x *LaunchFormJsonToLiteralsResponse) GetLiterals() []*task.NamedLiteral { + if x != nil { + return x.Literals + } + return nil +} + +type TaskSpecToLaunchFormJsonRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The task spec to convert to JSON. + // Merges the VariableMap and the default inputs + TaskSpec *task.TaskSpec `protobuf:"bytes,1,opt,name=task_spec,json=taskSpec,proto3" json:"task_spec,omitempty"` +} + +func (x *TaskSpecToLaunchFormJsonRequest) Reset() { + *x = TaskSpecToLaunchFormJsonRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_translator_service_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskSpecToLaunchFormJsonRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskSpecToLaunchFormJsonRequest) ProtoMessage() {} + +func (x *TaskSpecToLaunchFormJsonRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_translator_service_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskSpecToLaunchFormJsonRequest.ProtoReflect.Descriptor instead. +func (*TaskSpecToLaunchFormJsonRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_translator_service_proto_rawDescGZIP(), []int{4} +} + +func (x *TaskSpecToLaunchFormJsonRequest) GetTaskSpec() *task.TaskSpec { + if x != nil { + return x.TaskSpec + } + return nil +} + +type TaskSpecToLaunchFormJsonResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The JSON for the variables. + Json *structpb.Struct `protobuf:"bytes,1,opt,name=json,proto3" json:"json,omitempty"` +} + +func (x *TaskSpecToLaunchFormJsonResponse) Reset() { + *x = TaskSpecToLaunchFormJsonResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_translator_service_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TaskSpecToLaunchFormJsonResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskSpecToLaunchFormJsonResponse) ProtoMessage() {} + +func (x *TaskSpecToLaunchFormJsonResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_translator_service_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskSpecToLaunchFormJsonResponse.ProtoReflect.Descriptor instead. +func (*TaskSpecToLaunchFormJsonResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_translator_service_proto_rawDescGZIP(), []int{5} +} + +func (x *TaskSpecToLaunchFormJsonResponse) GetJson() *structpb.Struct { + if x != nil { + return x.Json + } + return nil +} + +type JsonValuesToLiteralsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The type definitions (VariableMap) describing the expected structure. + Variables *core.VariableMap `protobuf:"bytes,1,opt,name=variables,proto3" json:"variables,omitempty"` + // The raw JSON values to convert to literals. + Values *structpb.Struct `protobuf:"bytes,2,opt,name=values,proto3" json:"values,omitempty"` +} + +func (x *JsonValuesToLiteralsRequest) Reset() { + *x = JsonValuesToLiteralsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_translator_service_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *JsonValuesToLiteralsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*JsonValuesToLiteralsRequest) ProtoMessage() {} + +func (x *JsonValuesToLiteralsRequest) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_translator_service_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use JsonValuesToLiteralsRequest.ProtoReflect.Descriptor instead. +func (*JsonValuesToLiteralsRequest) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_translator_service_proto_rawDescGZIP(), []int{6} +} + +func (x *JsonValuesToLiteralsRequest) GetVariables() *core.VariableMap { + if x != nil { + return x.Variables + } + return nil +} + +func (x *JsonValuesToLiteralsRequest) GetValues() *structpb.Struct { + if x != nil { + return x.Values + } + return nil +} + +type JsonValuesToLiteralsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The literals generated from the JSON values using the type definitions. + Literals []*task.NamedLiteral `protobuf:"bytes,1,rep,name=literals,proto3" json:"literals,omitempty"` +} + +func (x *JsonValuesToLiteralsResponse) Reset() { + *x = JsonValuesToLiteralsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_flyteidl2_workflow_translator_service_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *JsonValuesToLiteralsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*JsonValuesToLiteralsResponse) ProtoMessage() {} + +func (x *JsonValuesToLiteralsResponse) ProtoReflect() protoreflect.Message { + mi := &file_flyteidl2_workflow_translator_service_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use JsonValuesToLiteralsResponse.ProtoReflect.Descriptor instead. +func (*JsonValuesToLiteralsResponse) Descriptor() ([]byte, []int) { + return file_flyteidl2_workflow_translator_service_proto_rawDescGZIP(), []int{7} +} + +func (x *JsonValuesToLiteralsResponse) GetLiterals() []*task.NamedLiteral { + if x != nil { + return x.Literals + } + return nil +} + +var File_flyteidl2_workflow_translator_service_proto protoreflect.FileDescriptor + +var file_flyteidl2_workflow_translator_service_proto_rawDesc = []byte{ + 0x0a, 0x2b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x5f, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, + 0x65, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, + 0x6b, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x74, + 0x61, 0x73, 0x6b, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x22, 0x96, 0x01, 0x0a, 0x1f, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x54, + 0x6f, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, + 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x64, 0x4c, + 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, + 0x12, 0x39, 0x0a, 0x09, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x4d, 0x61, 0x70, + 0x52, 0x09, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x22, 0x4f, 0x0a, 0x20, 0x4c, + 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x54, 0x6f, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, + 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x2b, 0x0a, 0x04, 0x6a, 0x73, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x04, 0x6a, 0x73, 0x6f, 0x6e, 0x22, 0x4e, 0x0a, 0x1f, + 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x54, 0x6f, + 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x2b, 0x0a, 0x04, 0x6a, 0x73, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x04, 0x6a, 0x73, 0x6f, 0x6e, 0x22, 0x5c, 0x0a, 0x20, + 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x54, 0x6f, + 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x38, 0x0a, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, + 0x61, 0x73, 0x6b, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x64, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, + 0x52, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x22, 0x58, 0x0a, 0x1f, 0x54, 0x61, + 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x54, 0x6f, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, + 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x35, 0x0a, + 0x09, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, + 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x52, 0x08, 0x74, 0x61, 0x73, 0x6b, + 0x53, 0x70, 0x65, 0x63, 0x22, 0x4f, 0x0a, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, + 0x54, 0x6f, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x04, 0x6a, 0x73, 0x6f, 0x6e, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, + 0x04, 0x6a, 0x73, 0x6f, 0x6e, 0x22, 0x89, 0x01, 0x0a, 0x1b, 0x4a, 0x73, 0x6f, 0x6e, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x54, 0x6f, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x39, 0x0a, 0x09, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, + 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, + 0x6c, 0x65, 0x4d, 0x61, 0x70, 0x52, 0x09, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, + 0x12, 0x2f, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x73, 0x22, 0x58, 0x0a, 0x1c, 0x4a, 0x73, 0x6f, 0x6e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x54, + 0x6f, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x38, 0x0a, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x64, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, + 0x6c, 0x52, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x32, 0xba, 0x04, 0x0a, 0x11, + 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x12, 0x8a, 0x01, 0x0a, 0x18, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x54, 0x6f, + 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x12, 0x33, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x54, 0x6f, 0x4c, 0x61, + 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x34, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, + 0x73, 0x54, 0x6f, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, + 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x8a, + 0x01, 0x0a, 0x18, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, + 0x6e, 0x54, 0x6f, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x12, 0x33, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x2e, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x54, + 0x6f, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x34, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, + 0x4a, 0x73, 0x6f, 0x6e, 0x54, 0x6f, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x8a, 0x01, 0x0a, 0x18, + 0x54, 0x61, 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x54, 0x6f, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, + 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x12, 0x33, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x61, + 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x54, 0x6f, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, + 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x34, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x54, 0x6f, 0x4c, 0x61, 0x75, + 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x7e, 0x0a, 0x14, 0x4a, 0x73, 0x6f, 0x6e, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x54, 0x6f, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, + 0x12, 0x2f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x4a, 0x73, 0x6f, 0x6e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x54, 0x6f, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x30, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x4a, 0x73, 0x6f, 0x6e, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x73, 0x54, 0x6f, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x42, 0xd3, 0x01, 0x0a, 0x16, 0x63, 0x6f, 0x6d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x42, 0x16, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x53, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x48, 0x02, 0x50, 0x01, 0x5a, + 0x36, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, + 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xa2, 0x02, 0x03, 0x46, 0x57, 0x58, 0xaa, 0x02, 0x12, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0xca, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x57, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xe2, 0x02, 0x1e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5c, 0x47, 0x50, 0x42, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x13, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_flyteidl2_workflow_translator_service_proto_rawDescOnce sync.Once + file_flyteidl2_workflow_translator_service_proto_rawDescData = file_flyteidl2_workflow_translator_service_proto_rawDesc +) + +func file_flyteidl2_workflow_translator_service_proto_rawDescGZIP() []byte { + file_flyteidl2_workflow_translator_service_proto_rawDescOnce.Do(func() { + file_flyteidl2_workflow_translator_service_proto_rawDescData = protoimpl.X.CompressGZIP(file_flyteidl2_workflow_translator_service_proto_rawDescData) + }) + return file_flyteidl2_workflow_translator_service_proto_rawDescData +} + +var file_flyteidl2_workflow_translator_service_proto_msgTypes = make([]protoimpl.MessageInfo, 8) +var file_flyteidl2_workflow_translator_service_proto_goTypes = []interface{}{ + (*LiteralsToLaunchFormJsonRequest)(nil), // 0: flyteidl2.workflow.LiteralsToLaunchFormJsonRequest + (*LiteralsToLaunchFormJsonResponse)(nil), // 1: flyteidl2.workflow.LiteralsToLaunchFormJsonResponse + (*LaunchFormJsonToLiteralsRequest)(nil), // 2: flyteidl2.workflow.LaunchFormJsonToLiteralsRequest + (*LaunchFormJsonToLiteralsResponse)(nil), // 3: flyteidl2.workflow.LaunchFormJsonToLiteralsResponse + (*TaskSpecToLaunchFormJsonRequest)(nil), // 4: flyteidl2.workflow.TaskSpecToLaunchFormJsonRequest + (*TaskSpecToLaunchFormJsonResponse)(nil), // 5: flyteidl2.workflow.TaskSpecToLaunchFormJsonResponse + (*JsonValuesToLiteralsRequest)(nil), // 6: flyteidl2.workflow.JsonValuesToLiteralsRequest + (*JsonValuesToLiteralsResponse)(nil), // 7: flyteidl2.workflow.JsonValuesToLiteralsResponse + (*task.NamedLiteral)(nil), // 8: flyteidl2.task.NamedLiteral + (*core.VariableMap)(nil), // 9: flyteidl2.core.VariableMap + (*structpb.Struct)(nil), // 10: google.protobuf.Struct + (*task.TaskSpec)(nil), // 11: flyteidl2.task.TaskSpec +} +var file_flyteidl2_workflow_translator_service_proto_depIdxs = []int32{ + 8, // 0: flyteidl2.workflow.LiteralsToLaunchFormJsonRequest.literals:type_name -> flyteidl2.task.NamedLiteral + 9, // 1: flyteidl2.workflow.LiteralsToLaunchFormJsonRequest.variables:type_name -> flyteidl2.core.VariableMap + 10, // 2: flyteidl2.workflow.LiteralsToLaunchFormJsonResponse.json:type_name -> google.protobuf.Struct + 10, // 3: flyteidl2.workflow.LaunchFormJsonToLiteralsRequest.json:type_name -> google.protobuf.Struct + 8, // 4: flyteidl2.workflow.LaunchFormJsonToLiteralsResponse.literals:type_name -> flyteidl2.task.NamedLiteral + 11, // 5: flyteidl2.workflow.TaskSpecToLaunchFormJsonRequest.task_spec:type_name -> flyteidl2.task.TaskSpec + 10, // 6: flyteidl2.workflow.TaskSpecToLaunchFormJsonResponse.json:type_name -> google.protobuf.Struct + 9, // 7: flyteidl2.workflow.JsonValuesToLiteralsRequest.variables:type_name -> flyteidl2.core.VariableMap + 10, // 8: flyteidl2.workflow.JsonValuesToLiteralsRequest.values:type_name -> google.protobuf.Struct + 8, // 9: flyteidl2.workflow.JsonValuesToLiteralsResponse.literals:type_name -> flyteidl2.task.NamedLiteral + 0, // 10: flyteidl2.workflow.TranslatorService.LiteralsToLaunchFormJson:input_type -> flyteidl2.workflow.LiteralsToLaunchFormJsonRequest + 2, // 11: flyteidl2.workflow.TranslatorService.LaunchFormJsonToLiterals:input_type -> flyteidl2.workflow.LaunchFormJsonToLiteralsRequest + 4, // 12: flyteidl2.workflow.TranslatorService.TaskSpecToLaunchFormJson:input_type -> flyteidl2.workflow.TaskSpecToLaunchFormJsonRequest + 6, // 13: flyteidl2.workflow.TranslatorService.JsonValuesToLiterals:input_type -> flyteidl2.workflow.JsonValuesToLiteralsRequest + 1, // 14: flyteidl2.workflow.TranslatorService.LiteralsToLaunchFormJson:output_type -> flyteidl2.workflow.LiteralsToLaunchFormJsonResponse + 3, // 15: flyteidl2.workflow.TranslatorService.LaunchFormJsonToLiterals:output_type -> flyteidl2.workflow.LaunchFormJsonToLiteralsResponse + 5, // 16: flyteidl2.workflow.TranslatorService.TaskSpecToLaunchFormJson:output_type -> flyteidl2.workflow.TaskSpecToLaunchFormJsonResponse + 7, // 17: flyteidl2.workflow.TranslatorService.JsonValuesToLiterals:output_type -> flyteidl2.workflow.JsonValuesToLiteralsResponse + 14, // [14:18] is the sub-list for method output_type + 10, // [10:14] is the sub-list for method input_type + 10, // [10:10] is the sub-list for extension type_name + 10, // [10:10] is the sub-list for extension extendee + 0, // [0:10] is the sub-list for field type_name +} + +func init() { file_flyteidl2_workflow_translator_service_proto_init() } +func file_flyteidl2_workflow_translator_service_proto_init() { + if File_flyteidl2_workflow_translator_service_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_flyteidl2_workflow_translator_service_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LiteralsToLaunchFormJsonRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_translator_service_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LiteralsToLaunchFormJsonResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_translator_service_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LaunchFormJsonToLiteralsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_translator_service_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LaunchFormJsonToLiteralsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_translator_service_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskSpecToLaunchFormJsonRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_translator_service_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TaskSpecToLaunchFormJsonResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_translator_service_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*JsonValuesToLiteralsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_flyteidl2_workflow_translator_service_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*JsonValuesToLiteralsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_flyteidl2_workflow_translator_service_proto_rawDesc, + NumEnums: 0, + NumMessages: 8, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_flyteidl2_workflow_translator_service_proto_goTypes, + DependencyIndexes: file_flyteidl2_workflow_translator_service_proto_depIdxs, + MessageInfos: file_flyteidl2_workflow_translator_service_proto_msgTypes, + }.Build() + File_flyteidl2_workflow_translator_service_proto = out.File + file_flyteidl2_workflow_translator_service_proto_rawDesc = nil + file_flyteidl2_workflow_translator_service_proto_goTypes = nil + file_flyteidl2_workflow_translator_service_proto_depIdxs = nil +} diff --git a/gen/go/flyteidl2/workflow/translator_service.pb.validate.go b/gen/go/flyteidl2/workflow/translator_service.pb.validate.go new file mode 100644 index 0000000000..86769f6cec --- /dev/null +++ b/gen/go/flyteidl2/workflow/translator_service.pb.validate.go @@ -0,0 +1,1171 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: flyteidl2/workflow/translator_service.proto + +package workflow + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on LiteralsToLaunchFormJsonRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *LiteralsToLaunchFormJsonRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LiteralsToLaunchFormJsonRequest with +// the rules defined in the proto definition for this message. If any rules +// are violated, the result is a list of violation errors wrapped in +// LiteralsToLaunchFormJsonRequestMultiError, or nil if none found. +func (m *LiteralsToLaunchFormJsonRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *LiteralsToLaunchFormJsonRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetLiterals() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralsToLaunchFormJsonRequestValidationError{ + field: fmt.Sprintf("Literals[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralsToLaunchFormJsonRequestValidationError{ + field: fmt.Sprintf("Literals[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralsToLaunchFormJsonRequestValidationError{ + field: fmt.Sprintf("Literals[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if all { + switch v := interface{}(m.GetVariables()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralsToLaunchFormJsonRequestValidationError{ + field: "Variables", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralsToLaunchFormJsonRequestValidationError{ + field: "Variables", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetVariables()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralsToLaunchFormJsonRequestValidationError{ + field: "Variables", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return LiteralsToLaunchFormJsonRequestMultiError(errors) + } + + return nil +} + +// LiteralsToLaunchFormJsonRequestMultiError is an error wrapping multiple +// validation errors returned by LiteralsToLaunchFormJsonRequest.ValidateAll() +// if the designated constraints aren't met. +type LiteralsToLaunchFormJsonRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LiteralsToLaunchFormJsonRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LiteralsToLaunchFormJsonRequestMultiError) AllErrors() []error { return m } + +// LiteralsToLaunchFormJsonRequestValidationError is the validation error +// returned by LiteralsToLaunchFormJsonRequest.Validate if the designated +// constraints aren't met. +type LiteralsToLaunchFormJsonRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LiteralsToLaunchFormJsonRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LiteralsToLaunchFormJsonRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LiteralsToLaunchFormJsonRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LiteralsToLaunchFormJsonRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LiteralsToLaunchFormJsonRequestValidationError) ErrorName() string { + return "LiteralsToLaunchFormJsonRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e LiteralsToLaunchFormJsonRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLiteralsToLaunchFormJsonRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LiteralsToLaunchFormJsonRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LiteralsToLaunchFormJsonRequestValidationError{} + +// Validate checks the field values on LiteralsToLaunchFormJsonResponse with +// the rules defined in the proto definition for this message. If any rules +// are violated, the first error encountered is returned, or nil if there are +// no violations. +func (m *LiteralsToLaunchFormJsonResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LiteralsToLaunchFormJsonResponse with +// the rules defined in the proto definition for this message. If any rules +// are violated, the result is a list of violation errors wrapped in +// LiteralsToLaunchFormJsonResponseMultiError, or nil if none found. +func (m *LiteralsToLaunchFormJsonResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *LiteralsToLaunchFormJsonResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetJson()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LiteralsToLaunchFormJsonResponseValidationError{ + field: "Json", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LiteralsToLaunchFormJsonResponseValidationError{ + field: "Json", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetJson()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LiteralsToLaunchFormJsonResponseValidationError{ + field: "Json", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return LiteralsToLaunchFormJsonResponseMultiError(errors) + } + + return nil +} + +// LiteralsToLaunchFormJsonResponseMultiError is an error wrapping multiple +// validation errors returned by +// LiteralsToLaunchFormJsonResponse.ValidateAll() if the designated +// constraints aren't met. +type LiteralsToLaunchFormJsonResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LiteralsToLaunchFormJsonResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LiteralsToLaunchFormJsonResponseMultiError) AllErrors() []error { return m } + +// LiteralsToLaunchFormJsonResponseValidationError is the validation error +// returned by LiteralsToLaunchFormJsonResponse.Validate if the designated +// constraints aren't met. +type LiteralsToLaunchFormJsonResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LiteralsToLaunchFormJsonResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LiteralsToLaunchFormJsonResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LiteralsToLaunchFormJsonResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LiteralsToLaunchFormJsonResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LiteralsToLaunchFormJsonResponseValidationError) ErrorName() string { + return "LiteralsToLaunchFormJsonResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e LiteralsToLaunchFormJsonResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLiteralsToLaunchFormJsonResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LiteralsToLaunchFormJsonResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LiteralsToLaunchFormJsonResponseValidationError{} + +// Validate checks the field values on LaunchFormJsonToLiteralsRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *LaunchFormJsonToLiteralsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LaunchFormJsonToLiteralsRequest with +// the rules defined in the proto definition for this message. If any rules +// are violated, the result is a list of violation errors wrapped in +// LaunchFormJsonToLiteralsRequestMultiError, or nil if none found. +func (m *LaunchFormJsonToLiteralsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *LaunchFormJsonToLiteralsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetJson()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LaunchFormJsonToLiteralsRequestValidationError{ + field: "Json", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LaunchFormJsonToLiteralsRequestValidationError{ + field: "Json", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetJson()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LaunchFormJsonToLiteralsRequestValidationError{ + field: "Json", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return LaunchFormJsonToLiteralsRequestMultiError(errors) + } + + return nil +} + +// LaunchFormJsonToLiteralsRequestMultiError is an error wrapping multiple +// validation errors returned by LaunchFormJsonToLiteralsRequest.ValidateAll() +// if the designated constraints aren't met. +type LaunchFormJsonToLiteralsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LaunchFormJsonToLiteralsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LaunchFormJsonToLiteralsRequestMultiError) AllErrors() []error { return m } + +// LaunchFormJsonToLiteralsRequestValidationError is the validation error +// returned by LaunchFormJsonToLiteralsRequest.Validate if the designated +// constraints aren't met. +type LaunchFormJsonToLiteralsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LaunchFormJsonToLiteralsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LaunchFormJsonToLiteralsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LaunchFormJsonToLiteralsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LaunchFormJsonToLiteralsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LaunchFormJsonToLiteralsRequestValidationError) ErrorName() string { + return "LaunchFormJsonToLiteralsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e LaunchFormJsonToLiteralsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLaunchFormJsonToLiteralsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LaunchFormJsonToLiteralsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LaunchFormJsonToLiteralsRequestValidationError{} + +// Validate checks the field values on LaunchFormJsonToLiteralsResponse with +// the rules defined in the proto definition for this message. If any rules +// are violated, the first error encountered is returned, or nil if there are +// no violations. +func (m *LaunchFormJsonToLiteralsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on LaunchFormJsonToLiteralsResponse with +// the rules defined in the proto definition for this message. If any rules +// are violated, the result is a list of violation errors wrapped in +// LaunchFormJsonToLiteralsResponseMultiError, or nil if none found. +func (m *LaunchFormJsonToLiteralsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *LaunchFormJsonToLiteralsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetLiterals() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, LaunchFormJsonToLiteralsResponseValidationError{ + field: fmt.Sprintf("Literals[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, LaunchFormJsonToLiteralsResponseValidationError{ + field: fmt.Sprintf("Literals[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return LaunchFormJsonToLiteralsResponseValidationError{ + field: fmt.Sprintf("Literals[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return LaunchFormJsonToLiteralsResponseMultiError(errors) + } + + return nil +} + +// LaunchFormJsonToLiteralsResponseMultiError is an error wrapping multiple +// validation errors returned by +// LaunchFormJsonToLiteralsResponse.ValidateAll() if the designated +// constraints aren't met. +type LaunchFormJsonToLiteralsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m LaunchFormJsonToLiteralsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m LaunchFormJsonToLiteralsResponseMultiError) AllErrors() []error { return m } + +// LaunchFormJsonToLiteralsResponseValidationError is the validation error +// returned by LaunchFormJsonToLiteralsResponse.Validate if the designated +// constraints aren't met. +type LaunchFormJsonToLiteralsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e LaunchFormJsonToLiteralsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e LaunchFormJsonToLiteralsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e LaunchFormJsonToLiteralsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e LaunchFormJsonToLiteralsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e LaunchFormJsonToLiteralsResponseValidationError) ErrorName() string { + return "LaunchFormJsonToLiteralsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e LaunchFormJsonToLiteralsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sLaunchFormJsonToLiteralsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = LaunchFormJsonToLiteralsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = LaunchFormJsonToLiteralsResponseValidationError{} + +// Validate checks the field values on TaskSpecToLaunchFormJsonRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *TaskSpecToLaunchFormJsonRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskSpecToLaunchFormJsonRequest with +// the rules defined in the proto definition for this message. If any rules +// are violated, the result is a list of violation errors wrapped in +// TaskSpecToLaunchFormJsonRequestMultiError, or nil if none found. +func (m *TaskSpecToLaunchFormJsonRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskSpecToLaunchFormJsonRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetTaskSpec()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskSpecToLaunchFormJsonRequestValidationError{ + field: "TaskSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskSpecToLaunchFormJsonRequestValidationError{ + field: "TaskSpec", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetTaskSpec()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskSpecToLaunchFormJsonRequestValidationError{ + field: "TaskSpec", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return TaskSpecToLaunchFormJsonRequestMultiError(errors) + } + + return nil +} + +// TaskSpecToLaunchFormJsonRequestMultiError is an error wrapping multiple +// validation errors returned by TaskSpecToLaunchFormJsonRequest.ValidateAll() +// if the designated constraints aren't met. +type TaskSpecToLaunchFormJsonRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskSpecToLaunchFormJsonRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskSpecToLaunchFormJsonRequestMultiError) AllErrors() []error { return m } + +// TaskSpecToLaunchFormJsonRequestValidationError is the validation error +// returned by TaskSpecToLaunchFormJsonRequest.Validate if the designated +// constraints aren't met. +type TaskSpecToLaunchFormJsonRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskSpecToLaunchFormJsonRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskSpecToLaunchFormJsonRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskSpecToLaunchFormJsonRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskSpecToLaunchFormJsonRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskSpecToLaunchFormJsonRequestValidationError) ErrorName() string { + return "TaskSpecToLaunchFormJsonRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e TaskSpecToLaunchFormJsonRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskSpecToLaunchFormJsonRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskSpecToLaunchFormJsonRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskSpecToLaunchFormJsonRequestValidationError{} + +// Validate checks the field values on TaskSpecToLaunchFormJsonResponse with +// the rules defined in the proto definition for this message. If any rules +// are violated, the first error encountered is returned, or nil if there are +// no violations. +func (m *TaskSpecToLaunchFormJsonResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on TaskSpecToLaunchFormJsonResponse with +// the rules defined in the proto definition for this message. If any rules +// are violated, the result is a list of violation errors wrapped in +// TaskSpecToLaunchFormJsonResponseMultiError, or nil if none found. +func (m *TaskSpecToLaunchFormJsonResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *TaskSpecToLaunchFormJsonResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetJson()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, TaskSpecToLaunchFormJsonResponseValidationError{ + field: "Json", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, TaskSpecToLaunchFormJsonResponseValidationError{ + field: "Json", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetJson()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return TaskSpecToLaunchFormJsonResponseValidationError{ + field: "Json", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return TaskSpecToLaunchFormJsonResponseMultiError(errors) + } + + return nil +} + +// TaskSpecToLaunchFormJsonResponseMultiError is an error wrapping multiple +// validation errors returned by +// TaskSpecToLaunchFormJsonResponse.ValidateAll() if the designated +// constraints aren't met. +type TaskSpecToLaunchFormJsonResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m TaskSpecToLaunchFormJsonResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m TaskSpecToLaunchFormJsonResponseMultiError) AllErrors() []error { return m } + +// TaskSpecToLaunchFormJsonResponseValidationError is the validation error +// returned by TaskSpecToLaunchFormJsonResponse.Validate if the designated +// constraints aren't met. +type TaskSpecToLaunchFormJsonResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e TaskSpecToLaunchFormJsonResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e TaskSpecToLaunchFormJsonResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e TaskSpecToLaunchFormJsonResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e TaskSpecToLaunchFormJsonResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e TaskSpecToLaunchFormJsonResponseValidationError) ErrorName() string { + return "TaskSpecToLaunchFormJsonResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e TaskSpecToLaunchFormJsonResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sTaskSpecToLaunchFormJsonResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = TaskSpecToLaunchFormJsonResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = TaskSpecToLaunchFormJsonResponseValidationError{} + +// Validate checks the field values on JsonValuesToLiteralsRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *JsonValuesToLiteralsRequest) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on JsonValuesToLiteralsRequest with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// JsonValuesToLiteralsRequestMultiError, or nil if none found. +func (m *JsonValuesToLiteralsRequest) ValidateAll() error { + return m.validate(true) +} + +func (m *JsonValuesToLiteralsRequest) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + if all { + switch v := interface{}(m.GetVariables()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, JsonValuesToLiteralsRequestValidationError{ + field: "Variables", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, JsonValuesToLiteralsRequestValidationError{ + field: "Variables", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetVariables()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return JsonValuesToLiteralsRequestValidationError{ + field: "Variables", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if all { + switch v := interface{}(m.GetValues()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, JsonValuesToLiteralsRequestValidationError{ + field: "Values", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, JsonValuesToLiteralsRequestValidationError{ + field: "Values", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetValues()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return JsonValuesToLiteralsRequestValidationError{ + field: "Values", + reason: "embedded message failed validation", + cause: err, + } + } + } + + if len(errors) > 0 { + return JsonValuesToLiteralsRequestMultiError(errors) + } + + return nil +} + +// JsonValuesToLiteralsRequestMultiError is an error wrapping multiple +// validation errors returned by JsonValuesToLiteralsRequest.ValidateAll() if +// the designated constraints aren't met. +type JsonValuesToLiteralsRequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m JsonValuesToLiteralsRequestMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m JsonValuesToLiteralsRequestMultiError) AllErrors() []error { return m } + +// JsonValuesToLiteralsRequestValidationError is the validation error returned +// by JsonValuesToLiteralsRequest.Validate if the designated constraints +// aren't met. +type JsonValuesToLiteralsRequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e JsonValuesToLiteralsRequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e JsonValuesToLiteralsRequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e JsonValuesToLiteralsRequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e JsonValuesToLiteralsRequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e JsonValuesToLiteralsRequestValidationError) ErrorName() string { + return "JsonValuesToLiteralsRequestValidationError" +} + +// Error satisfies the builtin error interface +func (e JsonValuesToLiteralsRequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sJsonValuesToLiteralsRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = JsonValuesToLiteralsRequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = JsonValuesToLiteralsRequestValidationError{} + +// Validate checks the field values on JsonValuesToLiteralsResponse with the +// rules defined in the proto definition for this message. If any rules are +// violated, the first error encountered is returned, or nil if there are no violations. +func (m *JsonValuesToLiteralsResponse) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on JsonValuesToLiteralsResponse with the +// rules defined in the proto definition for this message. If any rules are +// violated, the result is a list of violation errors wrapped in +// JsonValuesToLiteralsResponseMultiError, or nil if none found. +func (m *JsonValuesToLiteralsResponse) ValidateAll() error { + return m.validate(true) +} + +func (m *JsonValuesToLiteralsResponse) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + for idx, item := range m.GetLiterals() { + _, _ = idx, item + + if all { + switch v := interface{}(item).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, JsonValuesToLiteralsResponseValidationError{ + field: fmt.Sprintf("Literals[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, JsonValuesToLiteralsResponseValidationError{ + field: fmt.Sprintf("Literals[%v]", idx), + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return JsonValuesToLiteralsResponseValidationError{ + field: fmt.Sprintf("Literals[%v]", idx), + reason: "embedded message failed validation", + cause: err, + } + } + } + + } + + if len(errors) > 0 { + return JsonValuesToLiteralsResponseMultiError(errors) + } + + return nil +} + +// JsonValuesToLiteralsResponseMultiError is an error wrapping multiple +// validation errors returned by JsonValuesToLiteralsResponse.ValidateAll() if +// the designated constraints aren't met. +type JsonValuesToLiteralsResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m JsonValuesToLiteralsResponseMultiError) Error() string { + msgs := make([]string, 0, len(m)) + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m JsonValuesToLiteralsResponseMultiError) AllErrors() []error { return m } + +// JsonValuesToLiteralsResponseValidationError is the validation error returned +// by JsonValuesToLiteralsResponse.Validate if the designated constraints +// aren't met. +type JsonValuesToLiteralsResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e JsonValuesToLiteralsResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e JsonValuesToLiteralsResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e JsonValuesToLiteralsResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e JsonValuesToLiteralsResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e JsonValuesToLiteralsResponseValidationError) ErrorName() string { + return "JsonValuesToLiteralsResponseValidationError" +} + +// Error satisfies the builtin error interface +func (e JsonValuesToLiteralsResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sJsonValuesToLiteralsResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = JsonValuesToLiteralsResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = JsonValuesToLiteralsResponseValidationError{} diff --git a/gen/go/flyteidl2/workflow/translator_service_grpc.pb.go b/gen/go/flyteidl2/workflow/translator_service_grpc.pb.go new file mode 100644 index 0000000000..d317741bc8 --- /dev/null +++ b/gen/go/flyteidl2/workflow/translator_service_grpc.pb.go @@ -0,0 +1,218 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: flyteidl2/workflow/translator_service.proto + +package workflow + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + TranslatorService_LiteralsToLaunchFormJson_FullMethodName = "/flyteidl2.workflow.TranslatorService/LiteralsToLaunchFormJson" + TranslatorService_LaunchFormJsonToLiterals_FullMethodName = "/flyteidl2.workflow.TranslatorService/LaunchFormJsonToLiterals" + TranslatorService_TaskSpecToLaunchFormJson_FullMethodName = "/flyteidl2.workflow.TranslatorService/TaskSpecToLaunchFormJson" + TranslatorService_JsonValuesToLiterals_FullMethodName = "/flyteidl2.workflow.TranslatorService/JsonValuesToLiterals" +) + +// TranslatorServiceClient is the client API for TranslatorService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type TranslatorServiceClient interface { + LiteralsToLaunchFormJson(ctx context.Context, in *LiteralsToLaunchFormJsonRequest, opts ...grpc.CallOption) (*LiteralsToLaunchFormJsonResponse, error) + LaunchFormJsonToLiterals(ctx context.Context, in *LaunchFormJsonToLiteralsRequest, opts ...grpc.CallOption) (*LaunchFormJsonToLiteralsResponse, error) + TaskSpecToLaunchFormJson(ctx context.Context, in *TaskSpecToLaunchFormJsonRequest, opts ...grpc.CallOption) (*TaskSpecToLaunchFormJsonResponse, error) + JsonValuesToLiterals(ctx context.Context, in *JsonValuesToLiteralsRequest, opts ...grpc.CallOption) (*JsonValuesToLiteralsResponse, error) +} + +type translatorServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewTranslatorServiceClient(cc grpc.ClientConnInterface) TranslatorServiceClient { + return &translatorServiceClient{cc} +} + +func (c *translatorServiceClient) LiteralsToLaunchFormJson(ctx context.Context, in *LiteralsToLaunchFormJsonRequest, opts ...grpc.CallOption) (*LiteralsToLaunchFormJsonResponse, error) { + out := new(LiteralsToLaunchFormJsonResponse) + err := c.cc.Invoke(ctx, TranslatorService_LiteralsToLaunchFormJson_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *translatorServiceClient) LaunchFormJsonToLiterals(ctx context.Context, in *LaunchFormJsonToLiteralsRequest, opts ...grpc.CallOption) (*LaunchFormJsonToLiteralsResponse, error) { + out := new(LaunchFormJsonToLiteralsResponse) + err := c.cc.Invoke(ctx, TranslatorService_LaunchFormJsonToLiterals_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *translatorServiceClient) TaskSpecToLaunchFormJson(ctx context.Context, in *TaskSpecToLaunchFormJsonRequest, opts ...grpc.CallOption) (*TaskSpecToLaunchFormJsonResponse, error) { + out := new(TaskSpecToLaunchFormJsonResponse) + err := c.cc.Invoke(ctx, TranslatorService_TaskSpecToLaunchFormJson_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *translatorServiceClient) JsonValuesToLiterals(ctx context.Context, in *JsonValuesToLiteralsRequest, opts ...grpc.CallOption) (*JsonValuesToLiteralsResponse, error) { + out := new(JsonValuesToLiteralsResponse) + err := c.cc.Invoke(ctx, TranslatorService_JsonValuesToLiterals_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// TranslatorServiceServer is the server API for TranslatorService service. +// All implementations should embed UnimplementedTranslatorServiceServer +// for forward compatibility +type TranslatorServiceServer interface { + LiteralsToLaunchFormJson(context.Context, *LiteralsToLaunchFormJsonRequest) (*LiteralsToLaunchFormJsonResponse, error) + LaunchFormJsonToLiterals(context.Context, *LaunchFormJsonToLiteralsRequest) (*LaunchFormJsonToLiteralsResponse, error) + TaskSpecToLaunchFormJson(context.Context, *TaskSpecToLaunchFormJsonRequest) (*TaskSpecToLaunchFormJsonResponse, error) + JsonValuesToLiterals(context.Context, *JsonValuesToLiteralsRequest) (*JsonValuesToLiteralsResponse, error) +} + +// UnimplementedTranslatorServiceServer should be embedded to have forward compatible implementations. +type UnimplementedTranslatorServiceServer struct { +} + +func (UnimplementedTranslatorServiceServer) LiteralsToLaunchFormJson(context.Context, *LiteralsToLaunchFormJsonRequest) (*LiteralsToLaunchFormJsonResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LiteralsToLaunchFormJson not implemented") +} +func (UnimplementedTranslatorServiceServer) LaunchFormJsonToLiterals(context.Context, *LaunchFormJsonToLiteralsRequest) (*LaunchFormJsonToLiteralsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LaunchFormJsonToLiterals not implemented") +} +func (UnimplementedTranslatorServiceServer) TaskSpecToLaunchFormJson(context.Context, *TaskSpecToLaunchFormJsonRequest) (*TaskSpecToLaunchFormJsonResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method TaskSpecToLaunchFormJson not implemented") +} +func (UnimplementedTranslatorServiceServer) JsonValuesToLiterals(context.Context, *JsonValuesToLiteralsRequest) (*JsonValuesToLiteralsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method JsonValuesToLiterals not implemented") +} + +// UnsafeTranslatorServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to TranslatorServiceServer will +// result in compilation errors. +type UnsafeTranslatorServiceServer interface { + mustEmbedUnimplementedTranslatorServiceServer() +} + +func RegisterTranslatorServiceServer(s grpc.ServiceRegistrar, srv TranslatorServiceServer) { + s.RegisterService(&TranslatorService_ServiceDesc, srv) +} + +func _TranslatorService_LiteralsToLaunchFormJson_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(LiteralsToLaunchFormJsonRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TranslatorServiceServer).LiteralsToLaunchFormJson(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: TranslatorService_LiteralsToLaunchFormJson_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TranslatorServiceServer).LiteralsToLaunchFormJson(ctx, req.(*LiteralsToLaunchFormJsonRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _TranslatorService_LaunchFormJsonToLiterals_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(LaunchFormJsonToLiteralsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TranslatorServiceServer).LaunchFormJsonToLiterals(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: TranslatorService_LaunchFormJsonToLiterals_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TranslatorServiceServer).LaunchFormJsonToLiterals(ctx, req.(*LaunchFormJsonToLiteralsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _TranslatorService_TaskSpecToLaunchFormJson_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(TaskSpecToLaunchFormJsonRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TranslatorServiceServer).TaskSpecToLaunchFormJson(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: TranslatorService_TaskSpecToLaunchFormJson_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TranslatorServiceServer).TaskSpecToLaunchFormJson(ctx, req.(*TaskSpecToLaunchFormJsonRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _TranslatorService_JsonValuesToLiterals_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(JsonValuesToLiteralsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TranslatorServiceServer).JsonValuesToLiterals(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: TranslatorService_JsonValuesToLiterals_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TranslatorServiceServer).JsonValuesToLiterals(ctx, req.(*JsonValuesToLiteralsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// TranslatorService_ServiceDesc is the grpc.ServiceDesc for TranslatorService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var TranslatorService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "flyteidl2.workflow.TranslatorService", + HandlerType: (*TranslatorServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "LiteralsToLaunchFormJson", + Handler: _TranslatorService_LiteralsToLaunchFormJson_Handler, + }, + { + MethodName: "LaunchFormJsonToLiterals", + Handler: _TranslatorService_LaunchFormJsonToLiterals_Handler, + }, + { + MethodName: "TaskSpecToLaunchFormJson", + Handler: _TranslatorService_TaskSpecToLaunchFormJson_Handler, + }, + { + MethodName: "JsonValuesToLiterals", + Handler: _TranslatorService_JsonValuesToLiterals_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "flyteidl2/workflow/translator_service.proto", +} diff --git a/gen/go/flyteidl2/workflow/workflowconnect/mocks/queue_service_client.go b/gen/go/flyteidl2/workflow/workflowconnect/mocks/queue_service_client.go new file mode 100644 index 0000000000..5c2c2494d4 --- /dev/null +++ b/gen/go/flyteidl2/workflow/workflowconnect/mocks/queue_service_client.go @@ -0,0 +1,217 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + connect "connectrpc.com/connect" + + mock "github.com/stretchr/testify/mock" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// QueueServiceClient is an autogenerated mock type for the QueueServiceClient type +type QueueServiceClient struct { + mock.Mock +} + +type QueueServiceClient_Expecter struct { + mock *mock.Mock +} + +func (_m *QueueServiceClient) EXPECT() *QueueServiceClient_Expecter { + return &QueueServiceClient_Expecter{mock: &_m.Mock} +} + +// AbortQueuedAction provides a mock function with given fields: _a0, _a1 +func (_m *QueueServiceClient) AbortQueuedAction(_a0 context.Context, _a1 *connect.Request[workflow.AbortQueuedActionRequest]) (*connect.Response[workflow.AbortQueuedActionResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for AbortQueuedAction") + } + + var r0 *connect.Response[workflow.AbortQueuedActionResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.AbortQueuedActionRequest]) (*connect.Response[workflow.AbortQueuedActionResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.AbortQueuedActionRequest]) *connect.Response[workflow.AbortQueuedActionResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.AbortQueuedActionResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.AbortQueuedActionRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// QueueServiceClient_AbortQueuedAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortQueuedAction' +type QueueServiceClient_AbortQueuedAction_Call struct { + *mock.Call +} + +// AbortQueuedAction is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.AbortQueuedActionRequest] +func (_e *QueueServiceClient_Expecter) AbortQueuedAction(_a0 interface{}, _a1 interface{}) *QueueServiceClient_AbortQueuedAction_Call { + return &QueueServiceClient_AbortQueuedAction_Call{Call: _e.mock.On("AbortQueuedAction", _a0, _a1)} +} + +func (_c *QueueServiceClient_AbortQueuedAction_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.AbortQueuedActionRequest])) *QueueServiceClient_AbortQueuedAction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.AbortQueuedActionRequest])) + }) + return _c +} + +func (_c *QueueServiceClient_AbortQueuedAction_Call) Return(_a0 *connect.Response[workflow.AbortQueuedActionResponse], _a1 error) *QueueServiceClient_AbortQueuedAction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *QueueServiceClient_AbortQueuedAction_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.AbortQueuedActionRequest]) (*connect.Response[workflow.AbortQueuedActionResponse], error)) *QueueServiceClient_AbortQueuedAction_Call { + _c.Call.Return(run) + return _c +} + +// AbortQueuedRun provides a mock function with given fields: _a0, _a1 +func (_m *QueueServiceClient) AbortQueuedRun(_a0 context.Context, _a1 *connect.Request[workflow.AbortQueuedRunRequest]) (*connect.Response[workflow.AbortQueuedRunResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for AbortQueuedRun") + } + + var r0 *connect.Response[workflow.AbortQueuedRunResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.AbortQueuedRunRequest]) (*connect.Response[workflow.AbortQueuedRunResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.AbortQueuedRunRequest]) *connect.Response[workflow.AbortQueuedRunResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.AbortQueuedRunResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.AbortQueuedRunRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// QueueServiceClient_AbortQueuedRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortQueuedRun' +type QueueServiceClient_AbortQueuedRun_Call struct { + *mock.Call +} + +// AbortQueuedRun is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.AbortQueuedRunRequest] +func (_e *QueueServiceClient_Expecter) AbortQueuedRun(_a0 interface{}, _a1 interface{}) *QueueServiceClient_AbortQueuedRun_Call { + return &QueueServiceClient_AbortQueuedRun_Call{Call: _e.mock.On("AbortQueuedRun", _a0, _a1)} +} + +func (_c *QueueServiceClient_AbortQueuedRun_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.AbortQueuedRunRequest])) *QueueServiceClient_AbortQueuedRun_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.AbortQueuedRunRequest])) + }) + return _c +} + +func (_c *QueueServiceClient_AbortQueuedRun_Call) Return(_a0 *connect.Response[workflow.AbortQueuedRunResponse], _a1 error) *QueueServiceClient_AbortQueuedRun_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *QueueServiceClient_AbortQueuedRun_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.AbortQueuedRunRequest]) (*connect.Response[workflow.AbortQueuedRunResponse], error)) *QueueServiceClient_AbortQueuedRun_Call { + _c.Call.Return(run) + return _c +} + +// EnqueueAction provides a mock function with given fields: _a0, _a1 +func (_m *QueueServiceClient) EnqueueAction(_a0 context.Context, _a1 *connect.Request[workflow.EnqueueActionRequest]) (*connect.Response[workflow.EnqueueActionResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for EnqueueAction") + } + + var r0 *connect.Response[workflow.EnqueueActionResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.EnqueueActionRequest]) (*connect.Response[workflow.EnqueueActionResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.EnqueueActionRequest]) *connect.Response[workflow.EnqueueActionResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.EnqueueActionResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.EnqueueActionRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// QueueServiceClient_EnqueueAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnqueueAction' +type QueueServiceClient_EnqueueAction_Call struct { + *mock.Call +} + +// EnqueueAction is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.EnqueueActionRequest] +func (_e *QueueServiceClient_Expecter) EnqueueAction(_a0 interface{}, _a1 interface{}) *QueueServiceClient_EnqueueAction_Call { + return &QueueServiceClient_EnqueueAction_Call{Call: _e.mock.On("EnqueueAction", _a0, _a1)} +} + +func (_c *QueueServiceClient_EnqueueAction_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.EnqueueActionRequest])) *QueueServiceClient_EnqueueAction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.EnqueueActionRequest])) + }) + return _c +} + +func (_c *QueueServiceClient_EnqueueAction_Call) Return(_a0 *connect.Response[workflow.EnqueueActionResponse], _a1 error) *QueueServiceClient_EnqueueAction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *QueueServiceClient_EnqueueAction_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.EnqueueActionRequest]) (*connect.Response[workflow.EnqueueActionResponse], error)) *QueueServiceClient_EnqueueAction_Call { + _c.Call.Return(run) + return _c +} + +// NewQueueServiceClient creates a new instance of QueueServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewQueueServiceClient(t interface { + mock.TestingT + Cleanup(func()) +}) *QueueServiceClient { + mock := &QueueServiceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/workflowconnect/mocks/queue_service_handler.go b/gen/go/flyteidl2/workflow/workflowconnect/mocks/queue_service_handler.go new file mode 100644 index 0000000000..55a259ac07 --- /dev/null +++ b/gen/go/flyteidl2/workflow/workflowconnect/mocks/queue_service_handler.go @@ -0,0 +1,217 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + connect "connectrpc.com/connect" + + mock "github.com/stretchr/testify/mock" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// QueueServiceHandler is an autogenerated mock type for the QueueServiceHandler type +type QueueServiceHandler struct { + mock.Mock +} + +type QueueServiceHandler_Expecter struct { + mock *mock.Mock +} + +func (_m *QueueServiceHandler) EXPECT() *QueueServiceHandler_Expecter { + return &QueueServiceHandler_Expecter{mock: &_m.Mock} +} + +// AbortQueuedAction provides a mock function with given fields: _a0, _a1 +func (_m *QueueServiceHandler) AbortQueuedAction(_a0 context.Context, _a1 *connect.Request[workflow.AbortQueuedActionRequest]) (*connect.Response[workflow.AbortQueuedActionResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for AbortQueuedAction") + } + + var r0 *connect.Response[workflow.AbortQueuedActionResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.AbortQueuedActionRequest]) (*connect.Response[workflow.AbortQueuedActionResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.AbortQueuedActionRequest]) *connect.Response[workflow.AbortQueuedActionResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.AbortQueuedActionResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.AbortQueuedActionRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// QueueServiceHandler_AbortQueuedAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortQueuedAction' +type QueueServiceHandler_AbortQueuedAction_Call struct { + *mock.Call +} + +// AbortQueuedAction is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.AbortQueuedActionRequest] +func (_e *QueueServiceHandler_Expecter) AbortQueuedAction(_a0 interface{}, _a1 interface{}) *QueueServiceHandler_AbortQueuedAction_Call { + return &QueueServiceHandler_AbortQueuedAction_Call{Call: _e.mock.On("AbortQueuedAction", _a0, _a1)} +} + +func (_c *QueueServiceHandler_AbortQueuedAction_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.AbortQueuedActionRequest])) *QueueServiceHandler_AbortQueuedAction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.AbortQueuedActionRequest])) + }) + return _c +} + +func (_c *QueueServiceHandler_AbortQueuedAction_Call) Return(_a0 *connect.Response[workflow.AbortQueuedActionResponse], _a1 error) *QueueServiceHandler_AbortQueuedAction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *QueueServiceHandler_AbortQueuedAction_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.AbortQueuedActionRequest]) (*connect.Response[workflow.AbortQueuedActionResponse], error)) *QueueServiceHandler_AbortQueuedAction_Call { + _c.Call.Return(run) + return _c +} + +// AbortQueuedRun provides a mock function with given fields: _a0, _a1 +func (_m *QueueServiceHandler) AbortQueuedRun(_a0 context.Context, _a1 *connect.Request[workflow.AbortQueuedRunRequest]) (*connect.Response[workflow.AbortQueuedRunResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for AbortQueuedRun") + } + + var r0 *connect.Response[workflow.AbortQueuedRunResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.AbortQueuedRunRequest]) (*connect.Response[workflow.AbortQueuedRunResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.AbortQueuedRunRequest]) *connect.Response[workflow.AbortQueuedRunResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.AbortQueuedRunResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.AbortQueuedRunRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// QueueServiceHandler_AbortQueuedRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortQueuedRun' +type QueueServiceHandler_AbortQueuedRun_Call struct { + *mock.Call +} + +// AbortQueuedRun is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.AbortQueuedRunRequest] +func (_e *QueueServiceHandler_Expecter) AbortQueuedRun(_a0 interface{}, _a1 interface{}) *QueueServiceHandler_AbortQueuedRun_Call { + return &QueueServiceHandler_AbortQueuedRun_Call{Call: _e.mock.On("AbortQueuedRun", _a0, _a1)} +} + +func (_c *QueueServiceHandler_AbortQueuedRun_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.AbortQueuedRunRequest])) *QueueServiceHandler_AbortQueuedRun_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.AbortQueuedRunRequest])) + }) + return _c +} + +func (_c *QueueServiceHandler_AbortQueuedRun_Call) Return(_a0 *connect.Response[workflow.AbortQueuedRunResponse], _a1 error) *QueueServiceHandler_AbortQueuedRun_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *QueueServiceHandler_AbortQueuedRun_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.AbortQueuedRunRequest]) (*connect.Response[workflow.AbortQueuedRunResponse], error)) *QueueServiceHandler_AbortQueuedRun_Call { + _c.Call.Return(run) + return _c +} + +// EnqueueAction provides a mock function with given fields: _a0, _a1 +func (_m *QueueServiceHandler) EnqueueAction(_a0 context.Context, _a1 *connect.Request[workflow.EnqueueActionRequest]) (*connect.Response[workflow.EnqueueActionResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for EnqueueAction") + } + + var r0 *connect.Response[workflow.EnqueueActionResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.EnqueueActionRequest]) (*connect.Response[workflow.EnqueueActionResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.EnqueueActionRequest]) *connect.Response[workflow.EnqueueActionResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.EnqueueActionResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.EnqueueActionRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// QueueServiceHandler_EnqueueAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnqueueAction' +type QueueServiceHandler_EnqueueAction_Call struct { + *mock.Call +} + +// EnqueueAction is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.EnqueueActionRequest] +func (_e *QueueServiceHandler_Expecter) EnqueueAction(_a0 interface{}, _a1 interface{}) *QueueServiceHandler_EnqueueAction_Call { + return &QueueServiceHandler_EnqueueAction_Call{Call: _e.mock.On("EnqueueAction", _a0, _a1)} +} + +func (_c *QueueServiceHandler_EnqueueAction_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.EnqueueActionRequest])) *QueueServiceHandler_EnqueueAction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.EnqueueActionRequest])) + }) + return _c +} + +func (_c *QueueServiceHandler_EnqueueAction_Call) Return(_a0 *connect.Response[workflow.EnqueueActionResponse], _a1 error) *QueueServiceHandler_EnqueueAction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *QueueServiceHandler_EnqueueAction_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.EnqueueActionRequest]) (*connect.Response[workflow.EnqueueActionResponse], error)) *QueueServiceHandler_EnqueueAction_Call { + _c.Call.Return(run) + return _c +} + +// NewQueueServiceHandler creates a new instance of QueueServiceHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewQueueServiceHandler(t interface { + mock.TestingT + Cleanup(func()) +}) *QueueServiceHandler { + mock := &QueueServiceHandler{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/workflowconnect/mocks/run_logs_service_client.go b/gen/go/flyteidl2/workflow/workflowconnect/mocks/run_logs_service_client.go new file mode 100644 index 0000000000..afd8892aa0 --- /dev/null +++ b/gen/go/flyteidl2/workflow/workflowconnect/mocks/run_logs_service_client.go @@ -0,0 +1,99 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + connect "connectrpc.com/connect" + + mock "github.com/stretchr/testify/mock" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunLogsServiceClient is an autogenerated mock type for the RunLogsServiceClient type +type RunLogsServiceClient struct { + mock.Mock +} + +type RunLogsServiceClient_Expecter struct { + mock *mock.Mock +} + +func (_m *RunLogsServiceClient) EXPECT() *RunLogsServiceClient_Expecter { + return &RunLogsServiceClient_Expecter{mock: &_m.Mock} +} + +// TailLogs provides a mock function with given fields: _a0, _a1 +func (_m *RunLogsServiceClient) TailLogs(_a0 context.Context, _a1 *connect.Request[workflow.TailLogsRequest]) (*connect.ServerStreamForClient[workflow.TailLogsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for TailLogs") + } + + var r0 *connect.ServerStreamForClient[workflow.TailLogsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.TailLogsRequest]) (*connect.ServerStreamForClient[workflow.TailLogsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.TailLogsRequest]) *connect.ServerStreamForClient[workflow.TailLogsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.ServerStreamForClient[workflow.TailLogsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.TailLogsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunLogsServiceClient_TailLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TailLogs' +type RunLogsServiceClient_TailLogs_Call struct { + *mock.Call +} + +// TailLogs is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.TailLogsRequest] +func (_e *RunLogsServiceClient_Expecter) TailLogs(_a0 interface{}, _a1 interface{}) *RunLogsServiceClient_TailLogs_Call { + return &RunLogsServiceClient_TailLogs_Call{Call: _e.mock.On("TailLogs", _a0, _a1)} +} + +func (_c *RunLogsServiceClient_TailLogs_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.TailLogsRequest])) *RunLogsServiceClient_TailLogs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.TailLogsRequest])) + }) + return _c +} + +func (_c *RunLogsServiceClient_TailLogs_Call) Return(_a0 *connect.ServerStreamForClient[workflow.TailLogsResponse], _a1 error) *RunLogsServiceClient_TailLogs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunLogsServiceClient_TailLogs_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.TailLogsRequest]) (*connect.ServerStreamForClient[workflow.TailLogsResponse], error)) *RunLogsServiceClient_TailLogs_Call { + _c.Call.Return(run) + return _c +} + +// NewRunLogsServiceClient creates a new instance of RunLogsServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunLogsServiceClient(t interface { + mock.TestingT + Cleanup(func()) +}) *RunLogsServiceClient { + mock := &RunLogsServiceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/workflowconnect/mocks/run_logs_service_handler.go b/gen/go/flyteidl2/workflow/workflowconnect/mocks/run_logs_service_handler.go new file mode 100644 index 0000000000..2dd80a8364 --- /dev/null +++ b/gen/go/flyteidl2/workflow/workflowconnect/mocks/run_logs_service_handler.go @@ -0,0 +1,88 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + connect "connectrpc.com/connect" + + mock "github.com/stretchr/testify/mock" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunLogsServiceHandler is an autogenerated mock type for the RunLogsServiceHandler type +type RunLogsServiceHandler struct { + mock.Mock +} + +type RunLogsServiceHandler_Expecter struct { + mock *mock.Mock +} + +func (_m *RunLogsServiceHandler) EXPECT() *RunLogsServiceHandler_Expecter { + return &RunLogsServiceHandler_Expecter{mock: &_m.Mock} +} + +// TailLogs provides a mock function with given fields: _a0, _a1, _a2 +func (_m *RunLogsServiceHandler) TailLogs(_a0 context.Context, _a1 *connect.Request[workflow.TailLogsRequest], _a2 *connect.ServerStream[workflow.TailLogsResponse]) error { + ret := _m.Called(_a0, _a1, _a2) + + if len(ret) == 0 { + panic("no return value specified for TailLogs") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.TailLogsRequest], *connect.ServerStream[workflow.TailLogsResponse]) error); ok { + r0 = rf(_a0, _a1, _a2) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunLogsServiceHandler_TailLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TailLogs' +type RunLogsServiceHandler_TailLogs_Call struct { + *mock.Call +} + +// TailLogs is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.TailLogsRequest] +// - _a2 *connect.ServerStream[workflow.TailLogsResponse] +func (_e *RunLogsServiceHandler_Expecter) TailLogs(_a0 interface{}, _a1 interface{}, _a2 interface{}) *RunLogsServiceHandler_TailLogs_Call { + return &RunLogsServiceHandler_TailLogs_Call{Call: _e.mock.On("TailLogs", _a0, _a1, _a2)} +} + +func (_c *RunLogsServiceHandler_TailLogs_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.TailLogsRequest], _a2 *connect.ServerStream[workflow.TailLogsResponse])) *RunLogsServiceHandler_TailLogs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.TailLogsRequest]), args[2].(*connect.ServerStream[workflow.TailLogsResponse])) + }) + return _c +} + +func (_c *RunLogsServiceHandler_TailLogs_Call) Return(_a0 error) *RunLogsServiceHandler_TailLogs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunLogsServiceHandler_TailLogs_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.TailLogsRequest], *connect.ServerStream[workflow.TailLogsResponse]) error) *RunLogsServiceHandler_TailLogs_Call { + _c.Call.Return(run) + return _c +} + +// NewRunLogsServiceHandler creates a new instance of RunLogsServiceHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunLogsServiceHandler(t interface { + mock.TestingT + Cleanup(func()) +}) *RunLogsServiceHandler { + mock := &RunLogsServiceHandler{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/workflowconnect/mocks/run_service_client.go b/gen/go/flyteidl2/workflow/workflowconnect/mocks/run_service_client.go new file mode 100644 index 0000000000..af0bbaaee7 --- /dev/null +++ b/gen/go/flyteidl2/workflow/workflowconnect/mocks/run_service_client.go @@ -0,0 +1,866 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + connect "connectrpc.com/connect" + + mock "github.com/stretchr/testify/mock" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunServiceClient is an autogenerated mock type for the RunServiceClient type +type RunServiceClient struct { + mock.Mock +} + +type RunServiceClient_Expecter struct { + mock *mock.Mock +} + +func (_m *RunServiceClient) EXPECT() *RunServiceClient_Expecter { + return &RunServiceClient_Expecter{mock: &_m.Mock} +} + +// AbortAction provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceClient) AbortAction(_a0 context.Context, _a1 *connect.Request[workflow.AbortActionRequest]) (*connect.Response[workflow.AbortActionResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for AbortAction") + } + + var r0 *connect.Response[workflow.AbortActionResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.AbortActionRequest]) (*connect.Response[workflow.AbortActionResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.AbortActionRequest]) *connect.Response[workflow.AbortActionResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.AbortActionResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.AbortActionRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_AbortAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortAction' +type RunServiceClient_AbortAction_Call struct { + *mock.Call +} + +// AbortAction is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.AbortActionRequest] +func (_e *RunServiceClient_Expecter) AbortAction(_a0 interface{}, _a1 interface{}) *RunServiceClient_AbortAction_Call { + return &RunServiceClient_AbortAction_Call{Call: _e.mock.On("AbortAction", _a0, _a1)} +} + +func (_c *RunServiceClient_AbortAction_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.AbortActionRequest])) *RunServiceClient_AbortAction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.AbortActionRequest])) + }) + return _c +} + +func (_c *RunServiceClient_AbortAction_Call) Return(_a0 *connect.Response[workflow.AbortActionResponse], _a1 error) *RunServiceClient_AbortAction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_AbortAction_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.AbortActionRequest]) (*connect.Response[workflow.AbortActionResponse], error)) *RunServiceClient_AbortAction_Call { + _c.Call.Return(run) + return _c +} + +// AbortRun provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceClient) AbortRun(_a0 context.Context, _a1 *connect.Request[workflow.AbortRunRequest]) (*connect.Response[workflow.AbortRunResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for AbortRun") + } + + var r0 *connect.Response[workflow.AbortRunResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.AbortRunRequest]) (*connect.Response[workflow.AbortRunResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.AbortRunRequest]) *connect.Response[workflow.AbortRunResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.AbortRunResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.AbortRunRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_AbortRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortRun' +type RunServiceClient_AbortRun_Call struct { + *mock.Call +} + +// AbortRun is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.AbortRunRequest] +func (_e *RunServiceClient_Expecter) AbortRun(_a0 interface{}, _a1 interface{}) *RunServiceClient_AbortRun_Call { + return &RunServiceClient_AbortRun_Call{Call: _e.mock.On("AbortRun", _a0, _a1)} +} + +func (_c *RunServiceClient_AbortRun_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.AbortRunRequest])) *RunServiceClient_AbortRun_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.AbortRunRequest])) + }) + return _c +} + +func (_c *RunServiceClient_AbortRun_Call) Return(_a0 *connect.Response[workflow.AbortRunResponse], _a1 error) *RunServiceClient_AbortRun_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_AbortRun_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.AbortRunRequest]) (*connect.Response[workflow.AbortRunResponse], error)) *RunServiceClient_AbortRun_Call { + _c.Call.Return(run) + return _c +} + +// CreateRun provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceClient) CreateRun(_a0 context.Context, _a1 *connect.Request[workflow.CreateRunRequest]) (*connect.Response[workflow.CreateRunResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for CreateRun") + } + + var r0 *connect.Response[workflow.CreateRunResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.CreateRunRequest]) (*connect.Response[workflow.CreateRunResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.CreateRunRequest]) *connect.Response[workflow.CreateRunResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.CreateRunResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.CreateRunRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_CreateRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRun' +type RunServiceClient_CreateRun_Call struct { + *mock.Call +} + +// CreateRun is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.CreateRunRequest] +func (_e *RunServiceClient_Expecter) CreateRun(_a0 interface{}, _a1 interface{}) *RunServiceClient_CreateRun_Call { + return &RunServiceClient_CreateRun_Call{Call: _e.mock.On("CreateRun", _a0, _a1)} +} + +func (_c *RunServiceClient_CreateRun_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.CreateRunRequest])) *RunServiceClient_CreateRun_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.CreateRunRequest])) + }) + return _c +} + +func (_c *RunServiceClient_CreateRun_Call) Return(_a0 *connect.Response[workflow.CreateRunResponse], _a1 error) *RunServiceClient_CreateRun_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_CreateRun_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.CreateRunRequest]) (*connect.Response[workflow.CreateRunResponse], error)) *RunServiceClient_CreateRun_Call { + _c.Call.Return(run) + return _c +} + +// GetActionData provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceClient) GetActionData(_a0 context.Context, _a1 *connect.Request[workflow.GetActionDataRequest]) (*connect.Response[workflow.GetActionDataResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetActionData") + } + + var r0 *connect.Response[workflow.GetActionDataResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.GetActionDataRequest]) (*connect.Response[workflow.GetActionDataResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.GetActionDataRequest]) *connect.Response[workflow.GetActionDataResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.GetActionDataResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.GetActionDataRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_GetActionData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActionData' +type RunServiceClient_GetActionData_Call struct { + *mock.Call +} + +// GetActionData is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.GetActionDataRequest] +func (_e *RunServiceClient_Expecter) GetActionData(_a0 interface{}, _a1 interface{}) *RunServiceClient_GetActionData_Call { + return &RunServiceClient_GetActionData_Call{Call: _e.mock.On("GetActionData", _a0, _a1)} +} + +func (_c *RunServiceClient_GetActionData_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.GetActionDataRequest])) *RunServiceClient_GetActionData_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.GetActionDataRequest])) + }) + return _c +} + +func (_c *RunServiceClient_GetActionData_Call) Return(_a0 *connect.Response[workflow.GetActionDataResponse], _a1 error) *RunServiceClient_GetActionData_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_GetActionData_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.GetActionDataRequest]) (*connect.Response[workflow.GetActionDataResponse], error)) *RunServiceClient_GetActionData_Call { + _c.Call.Return(run) + return _c +} + +// GetActionDetails provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceClient) GetActionDetails(_a0 context.Context, _a1 *connect.Request[workflow.GetActionDetailsRequest]) (*connect.Response[workflow.GetActionDetailsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetActionDetails") + } + + var r0 *connect.Response[workflow.GetActionDetailsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.GetActionDetailsRequest]) (*connect.Response[workflow.GetActionDetailsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.GetActionDetailsRequest]) *connect.Response[workflow.GetActionDetailsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.GetActionDetailsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.GetActionDetailsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_GetActionDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActionDetails' +type RunServiceClient_GetActionDetails_Call struct { + *mock.Call +} + +// GetActionDetails is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.GetActionDetailsRequest] +func (_e *RunServiceClient_Expecter) GetActionDetails(_a0 interface{}, _a1 interface{}) *RunServiceClient_GetActionDetails_Call { + return &RunServiceClient_GetActionDetails_Call{Call: _e.mock.On("GetActionDetails", _a0, _a1)} +} + +func (_c *RunServiceClient_GetActionDetails_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.GetActionDetailsRequest])) *RunServiceClient_GetActionDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.GetActionDetailsRequest])) + }) + return _c +} + +func (_c *RunServiceClient_GetActionDetails_Call) Return(_a0 *connect.Response[workflow.GetActionDetailsResponse], _a1 error) *RunServiceClient_GetActionDetails_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_GetActionDetails_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.GetActionDetailsRequest]) (*connect.Response[workflow.GetActionDetailsResponse], error)) *RunServiceClient_GetActionDetails_Call { + _c.Call.Return(run) + return _c +} + +// GetRunDetails provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceClient) GetRunDetails(_a0 context.Context, _a1 *connect.Request[workflow.GetRunDetailsRequest]) (*connect.Response[workflow.GetRunDetailsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetRunDetails") + } + + var r0 *connect.Response[workflow.GetRunDetailsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.GetRunDetailsRequest]) (*connect.Response[workflow.GetRunDetailsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.GetRunDetailsRequest]) *connect.Response[workflow.GetRunDetailsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.GetRunDetailsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.GetRunDetailsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_GetRunDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRunDetails' +type RunServiceClient_GetRunDetails_Call struct { + *mock.Call +} + +// GetRunDetails is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.GetRunDetailsRequest] +func (_e *RunServiceClient_Expecter) GetRunDetails(_a0 interface{}, _a1 interface{}) *RunServiceClient_GetRunDetails_Call { + return &RunServiceClient_GetRunDetails_Call{Call: _e.mock.On("GetRunDetails", _a0, _a1)} +} + +func (_c *RunServiceClient_GetRunDetails_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.GetRunDetailsRequest])) *RunServiceClient_GetRunDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.GetRunDetailsRequest])) + }) + return _c +} + +func (_c *RunServiceClient_GetRunDetails_Call) Return(_a0 *connect.Response[workflow.GetRunDetailsResponse], _a1 error) *RunServiceClient_GetRunDetails_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_GetRunDetails_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.GetRunDetailsRequest]) (*connect.Response[workflow.GetRunDetailsResponse], error)) *RunServiceClient_GetRunDetails_Call { + _c.Call.Return(run) + return _c +} + +// ListActions provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceClient) ListActions(_a0 context.Context, _a1 *connect.Request[workflow.ListActionsRequest]) (*connect.Response[workflow.ListActionsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for ListActions") + } + + var r0 *connect.Response[workflow.ListActionsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.ListActionsRequest]) (*connect.Response[workflow.ListActionsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.ListActionsRequest]) *connect.Response[workflow.ListActionsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.ListActionsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.ListActionsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_ListActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListActions' +type RunServiceClient_ListActions_Call struct { + *mock.Call +} + +// ListActions is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.ListActionsRequest] +func (_e *RunServiceClient_Expecter) ListActions(_a0 interface{}, _a1 interface{}) *RunServiceClient_ListActions_Call { + return &RunServiceClient_ListActions_Call{Call: _e.mock.On("ListActions", _a0, _a1)} +} + +func (_c *RunServiceClient_ListActions_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.ListActionsRequest])) *RunServiceClient_ListActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.ListActionsRequest])) + }) + return _c +} + +func (_c *RunServiceClient_ListActions_Call) Return(_a0 *connect.Response[workflow.ListActionsResponse], _a1 error) *RunServiceClient_ListActions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_ListActions_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.ListActionsRequest]) (*connect.Response[workflow.ListActionsResponse], error)) *RunServiceClient_ListActions_Call { + _c.Call.Return(run) + return _c +} + +// ListRuns provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceClient) ListRuns(_a0 context.Context, _a1 *connect.Request[workflow.ListRunsRequest]) (*connect.Response[workflow.ListRunsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for ListRuns") + } + + var r0 *connect.Response[workflow.ListRunsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.ListRunsRequest]) (*connect.Response[workflow.ListRunsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.ListRunsRequest]) *connect.Response[workflow.ListRunsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.ListRunsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.ListRunsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_ListRuns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRuns' +type RunServiceClient_ListRuns_Call struct { + *mock.Call +} + +// ListRuns is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.ListRunsRequest] +func (_e *RunServiceClient_Expecter) ListRuns(_a0 interface{}, _a1 interface{}) *RunServiceClient_ListRuns_Call { + return &RunServiceClient_ListRuns_Call{Call: _e.mock.On("ListRuns", _a0, _a1)} +} + +func (_c *RunServiceClient_ListRuns_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.ListRunsRequest])) *RunServiceClient_ListRuns_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.ListRunsRequest])) + }) + return _c +} + +func (_c *RunServiceClient_ListRuns_Call) Return(_a0 *connect.Response[workflow.ListRunsResponse], _a1 error) *RunServiceClient_ListRuns_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_ListRuns_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.ListRunsRequest]) (*connect.Response[workflow.ListRunsResponse], error)) *RunServiceClient_ListRuns_Call { + _c.Call.Return(run) + return _c +} + +// WatchActionDetails provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceClient) WatchActionDetails(_a0 context.Context, _a1 *connect.Request[workflow.WatchActionDetailsRequest]) (*connect.ServerStreamForClient[workflow.WatchActionDetailsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for WatchActionDetails") + } + + var r0 *connect.ServerStreamForClient[workflow.WatchActionDetailsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchActionDetailsRequest]) (*connect.ServerStreamForClient[workflow.WatchActionDetailsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchActionDetailsRequest]) *connect.ServerStreamForClient[workflow.WatchActionDetailsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.ServerStreamForClient[workflow.WatchActionDetailsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.WatchActionDetailsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_WatchActionDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchActionDetails' +type RunServiceClient_WatchActionDetails_Call struct { + *mock.Call +} + +// WatchActionDetails is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.WatchActionDetailsRequest] +func (_e *RunServiceClient_Expecter) WatchActionDetails(_a0 interface{}, _a1 interface{}) *RunServiceClient_WatchActionDetails_Call { + return &RunServiceClient_WatchActionDetails_Call{Call: _e.mock.On("WatchActionDetails", _a0, _a1)} +} + +func (_c *RunServiceClient_WatchActionDetails_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.WatchActionDetailsRequest])) *RunServiceClient_WatchActionDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.WatchActionDetailsRequest])) + }) + return _c +} + +func (_c *RunServiceClient_WatchActionDetails_Call) Return(_a0 *connect.ServerStreamForClient[workflow.WatchActionDetailsResponse], _a1 error) *RunServiceClient_WatchActionDetails_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_WatchActionDetails_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.WatchActionDetailsRequest]) (*connect.ServerStreamForClient[workflow.WatchActionDetailsResponse], error)) *RunServiceClient_WatchActionDetails_Call { + _c.Call.Return(run) + return _c +} + +// WatchActions provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceClient) WatchActions(_a0 context.Context, _a1 *connect.Request[workflow.WatchActionsRequest]) (*connect.ServerStreamForClient[workflow.WatchActionsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for WatchActions") + } + + var r0 *connect.ServerStreamForClient[workflow.WatchActionsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchActionsRequest]) (*connect.ServerStreamForClient[workflow.WatchActionsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchActionsRequest]) *connect.ServerStreamForClient[workflow.WatchActionsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.ServerStreamForClient[workflow.WatchActionsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.WatchActionsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_WatchActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchActions' +type RunServiceClient_WatchActions_Call struct { + *mock.Call +} + +// WatchActions is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.WatchActionsRequest] +func (_e *RunServiceClient_Expecter) WatchActions(_a0 interface{}, _a1 interface{}) *RunServiceClient_WatchActions_Call { + return &RunServiceClient_WatchActions_Call{Call: _e.mock.On("WatchActions", _a0, _a1)} +} + +func (_c *RunServiceClient_WatchActions_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.WatchActionsRequest])) *RunServiceClient_WatchActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.WatchActionsRequest])) + }) + return _c +} + +func (_c *RunServiceClient_WatchActions_Call) Return(_a0 *connect.ServerStreamForClient[workflow.WatchActionsResponse], _a1 error) *RunServiceClient_WatchActions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_WatchActions_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.WatchActionsRequest]) (*connect.ServerStreamForClient[workflow.WatchActionsResponse], error)) *RunServiceClient_WatchActions_Call { + _c.Call.Return(run) + return _c +} + +// WatchClusterEvents provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceClient) WatchClusterEvents(_a0 context.Context, _a1 *connect.Request[workflow.WatchClusterEventsRequest]) (*connect.ServerStreamForClient[workflow.WatchClusterEventsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for WatchClusterEvents") + } + + var r0 *connect.ServerStreamForClient[workflow.WatchClusterEventsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchClusterEventsRequest]) (*connect.ServerStreamForClient[workflow.WatchClusterEventsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchClusterEventsRequest]) *connect.ServerStreamForClient[workflow.WatchClusterEventsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.ServerStreamForClient[workflow.WatchClusterEventsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.WatchClusterEventsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_WatchClusterEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchClusterEvents' +type RunServiceClient_WatchClusterEvents_Call struct { + *mock.Call +} + +// WatchClusterEvents is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.WatchClusterEventsRequest] +func (_e *RunServiceClient_Expecter) WatchClusterEvents(_a0 interface{}, _a1 interface{}) *RunServiceClient_WatchClusterEvents_Call { + return &RunServiceClient_WatchClusterEvents_Call{Call: _e.mock.On("WatchClusterEvents", _a0, _a1)} +} + +func (_c *RunServiceClient_WatchClusterEvents_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.WatchClusterEventsRequest])) *RunServiceClient_WatchClusterEvents_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.WatchClusterEventsRequest])) + }) + return _c +} + +func (_c *RunServiceClient_WatchClusterEvents_Call) Return(_a0 *connect.ServerStreamForClient[workflow.WatchClusterEventsResponse], _a1 error) *RunServiceClient_WatchClusterEvents_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_WatchClusterEvents_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.WatchClusterEventsRequest]) (*connect.ServerStreamForClient[workflow.WatchClusterEventsResponse], error)) *RunServiceClient_WatchClusterEvents_Call { + _c.Call.Return(run) + return _c +} + +// WatchGroups provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceClient) WatchGroups(_a0 context.Context, _a1 *connect.Request[workflow.WatchGroupsRequest]) (*connect.ServerStreamForClient[workflow.WatchGroupsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for WatchGroups") + } + + var r0 *connect.ServerStreamForClient[workflow.WatchGroupsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchGroupsRequest]) (*connect.ServerStreamForClient[workflow.WatchGroupsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchGroupsRequest]) *connect.ServerStreamForClient[workflow.WatchGroupsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.ServerStreamForClient[workflow.WatchGroupsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.WatchGroupsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_WatchGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchGroups' +type RunServiceClient_WatchGroups_Call struct { + *mock.Call +} + +// WatchGroups is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.WatchGroupsRequest] +func (_e *RunServiceClient_Expecter) WatchGroups(_a0 interface{}, _a1 interface{}) *RunServiceClient_WatchGroups_Call { + return &RunServiceClient_WatchGroups_Call{Call: _e.mock.On("WatchGroups", _a0, _a1)} +} + +func (_c *RunServiceClient_WatchGroups_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.WatchGroupsRequest])) *RunServiceClient_WatchGroups_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.WatchGroupsRequest])) + }) + return _c +} + +func (_c *RunServiceClient_WatchGroups_Call) Return(_a0 *connect.ServerStreamForClient[workflow.WatchGroupsResponse], _a1 error) *RunServiceClient_WatchGroups_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_WatchGroups_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.WatchGroupsRequest]) (*connect.ServerStreamForClient[workflow.WatchGroupsResponse], error)) *RunServiceClient_WatchGroups_Call { + _c.Call.Return(run) + return _c +} + +// WatchRunDetails provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceClient) WatchRunDetails(_a0 context.Context, _a1 *connect.Request[workflow.WatchRunDetailsRequest]) (*connect.ServerStreamForClient[workflow.WatchRunDetailsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for WatchRunDetails") + } + + var r0 *connect.ServerStreamForClient[workflow.WatchRunDetailsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchRunDetailsRequest]) (*connect.ServerStreamForClient[workflow.WatchRunDetailsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchRunDetailsRequest]) *connect.ServerStreamForClient[workflow.WatchRunDetailsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.ServerStreamForClient[workflow.WatchRunDetailsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.WatchRunDetailsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_WatchRunDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchRunDetails' +type RunServiceClient_WatchRunDetails_Call struct { + *mock.Call +} + +// WatchRunDetails is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.WatchRunDetailsRequest] +func (_e *RunServiceClient_Expecter) WatchRunDetails(_a0 interface{}, _a1 interface{}) *RunServiceClient_WatchRunDetails_Call { + return &RunServiceClient_WatchRunDetails_Call{Call: _e.mock.On("WatchRunDetails", _a0, _a1)} +} + +func (_c *RunServiceClient_WatchRunDetails_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.WatchRunDetailsRequest])) *RunServiceClient_WatchRunDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.WatchRunDetailsRequest])) + }) + return _c +} + +func (_c *RunServiceClient_WatchRunDetails_Call) Return(_a0 *connect.ServerStreamForClient[workflow.WatchRunDetailsResponse], _a1 error) *RunServiceClient_WatchRunDetails_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_WatchRunDetails_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.WatchRunDetailsRequest]) (*connect.ServerStreamForClient[workflow.WatchRunDetailsResponse], error)) *RunServiceClient_WatchRunDetails_Call { + _c.Call.Return(run) + return _c +} + +// WatchRuns provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceClient) WatchRuns(_a0 context.Context, _a1 *connect.Request[workflow.WatchRunsRequest]) (*connect.ServerStreamForClient[workflow.WatchRunsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for WatchRuns") + } + + var r0 *connect.ServerStreamForClient[workflow.WatchRunsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchRunsRequest]) (*connect.ServerStreamForClient[workflow.WatchRunsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchRunsRequest]) *connect.ServerStreamForClient[workflow.WatchRunsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.ServerStreamForClient[workflow.WatchRunsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.WatchRunsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceClient_WatchRuns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchRuns' +type RunServiceClient_WatchRuns_Call struct { + *mock.Call +} + +// WatchRuns is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.WatchRunsRequest] +func (_e *RunServiceClient_Expecter) WatchRuns(_a0 interface{}, _a1 interface{}) *RunServiceClient_WatchRuns_Call { + return &RunServiceClient_WatchRuns_Call{Call: _e.mock.On("WatchRuns", _a0, _a1)} +} + +func (_c *RunServiceClient_WatchRuns_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.WatchRunsRequest])) *RunServiceClient_WatchRuns_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.WatchRunsRequest])) + }) + return _c +} + +func (_c *RunServiceClient_WatchRuns_Call) Return(_a0 *connect.ServerStreamForClient[workflow.WatchRunsResponse], _a1 error) *RunServiceClient_WatchRuns_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceClient_WatchRuns_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.WatchRunsRequest]) (*connect.ServerStreamForClient[workflow.WatchRunsResponse], error)) *RunServiceClient_WatchRuns_Call { + _c.Call.Return(run) + return _c +} + +// NewRunServiceClient creates a new instance of RunServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunServiceClient(t interface { + mock.TestingT + Cleanup(func()) +}) *RunServiceClient { + mock := &RunServiceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/workflowconnect/mocks/run_service_handler.go b/gen/go/flyteidl2/workflow/workflowconnect/mocks/run_service_handler.go new file mode 100644 index 0000000000..1c198db1b5 --- /dev/null +++ b/gen/go/flyteidl2/workflow/workflowconnect/mocks/run_service_handler.go @@ -0,0 +1,800 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + connect "connectrpc.com/connect" + + mock "github.com/stretchr/testify/mock" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// RunServiceHandler is an autogenerated mock type for the RunServiceHandler type +type RunServiceHandler struct { + mock.Mock +} + +type RunServiceHandler_Expecter struct { + mock *mock.Mock +} + +func (_m *RunServiceHandler) EXPECT() *RunServiceHandler_Expecter { + return &RunServiceHandler_Expecter{mock: &_m.Mock} +} + +// AbortAction provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceHandler) AbortAction(_a0 context.Context, _a1 *connect.Request[workflow.AbortActionRequest]) (*connect.Response[workflow.AbortActionResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for AbortAction") + } + + var r0 *connect.Response[workflow.AbortActionResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.AbortActionRequest]) (*connect.Response[workflow.AbortActionResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.AbortActionRequest]) *connect.Response[workflow.AbortActionResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.AbortActionResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.AbortActionRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceHandler_AbortAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortAction' +type RunServiceHandler_AbortAction_Call struct { + *mock.Call +} + +// AbortAction is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.AbortActionRequest] +func (_e *RunServiceHandler_Expecter) AbortAction(_a0 interface{}, _a1 interface{}) *RunServiceHandler_AbortAction_Call { + return &RunServiceHandler_AbortAction_Call{Call: _e.mock.On("AbortAction", _a0, _a1)} +} + +func (_c *RunServiceHandler_AbortAction_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.AbortActionRequest])) *RunServiceHandler_AbortAction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.AbortActionRequest])) + }) + return _c +} + +func (_c *RunServiceHandler_AbortAction_Call) Return(_a0 *connect.Response[workflow.AbortActionResponse], _a1 error) *RunServiceHandler_AbortAction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceHandler_AbortAction_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.AbortActionRequest]) (*connect.Response[workflow.AbortActionResponse], error)) *RunServiceHandler_AbortAction_Call { + _c.Call.Return(run) + return _c +} + +// AbortRun provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceHandler) AbortRun(_a0 context.Context, _a1 *connect.Request[workflow.AbortRunRequest]) (*connect.Response[workflow.AbortRunResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for AbortRun") + } + + var r0 *connect.Response[workflow.AbortRunResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.AbortRunRequest]) (*connect.Response[workflow.AbortRunResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.AbortRunRequest]) *connect.Response[workflow.AbortRunResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.AbortRunResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.AbortRunRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceHandler_AbortRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortRun' +type RunServiceHandler_AbortRun_Call struct { + *mock.Call +} + +// AbortRun is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.AbortRunRequest] +func (_e *RunServiceHandler_Expecter) AbortRun(_a0 interface{}, _a1 interface{}) *RunServiceHandler_AbortRun_Call { + return &RunServiceHandler_AbortRun_Call{Call: _e.mock.On("AbortRun", _a0, _a1)} +} + +func (_c *RunServiceHandler_AbortRun_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.AbortRunRequest])) *RunServiceHandler_AbortRun_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.AbortRunRequest])) + }) + return _c +} + +func (_c *RunServiceHandler_AbortRun_Call) Return(_a0 *connect.Response[workflow.AbortRunResponse], _a1 error) *RunServiceHandler_AbortRun_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceHandler_AbortRun_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.AbortRunRequest]) (*connect.Response[workflow.AbortRunResponse], error)) *RunServiceHandler_AbortRun_Call { + _c.Call.Return(run) + return _c +} + +// CreateRun provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceHandler) CreateRun(_a0 context.Context, _a1 *connect.Request[workflow.CreateRunRequest]) (*connect.Response[workflow.CreateRunResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for CreateRun") + } + + var r0 *connect.Response[workflow.CreateRunResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.CreateRunRequest]) (*connect.Response[workflow.CreateRunResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.CreateRunRequest]) *connect.Response[workflow.CreateRunResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.CreateRunResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.CreateRunRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceHandler_CreateRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRun' +type RunServiceHandler_CreateRun_Call struct { + *mock.Call +} + +// CreateRun is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.CreateRunRequest] +func (_e *RunServiceHandler_Expecter) CreateRun(_a0 interface{}, _a1 interface{}) *RunServiceHandler_CreateRun_Call { + return &RunServiceHandler_CreateRun_Call{Call: _e.mock.On("CreateRun", _a0, _a1)} +} + +func (_c *RunServiceHandler_CreateRun_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.CreateRunRequest])) *RunServiceHandler_CreateRun_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.CreateRunRequest])) + }) + return _c +} + +func (_c *RunServiceHandler_CreateRun_Call) Return(_a0 *connect.Response[workflow.CreateRunResponse], _a1 error) *RunServiceHandler_CreateRun_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceHandler_CreateRun_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.CreateRunRequest]) (*connect.Response[workflow.CreateRunResponse], error)) *RunServiceHandler_CreateRun_Call { + _c.Call.Return(run) + return _c +} + +// GetActionData provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceHandler) GetActionData(_a0 context.Context, _a1 *connect.Request[workflow.GetActionDataRequest]) (*connect.Response[workflow.GetActionDataResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetActionData") + } + + var r0 *connect.Response[workflow.GetActionDataResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.GetActionDataRequest]) (*connect.Response[workflow.GetActionDataResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.GetActionDataRequest]) *connect.Response[workflow.GetActionDataResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.GetActionDataResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.GetActionDataRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceHandler_GetActionData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActionData' +type RunServiceHandler_GetActionData_Call struct { + *mock.Call +} + +// GetActionData is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.GetActionDataRequest] +func (_e *RunServiceHandler_Expecter) GetActionData(_a0 interface{}, _a1 interface{}) *RunServiceHandler_GetActionData_Call { + return &RunServiceHandler_GetActionData_Call{Call: _e.mock.On("GetActionData", _a0, _a1)} +} + +func (_c *RunServiceHandler_GetActionData_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.GetActionDataRequest])) *RunServiceHandler_GetActionData_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.GetActionDataRequest])) + }) + return _c +} + +func (_c *RunServiceHandler_GetActionData_Call) Return(_a0 *connect.Response[workflow.GetActionDataResponse], _a1 error) *RunServiceHandler_GetActionData_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceHandler_GetActionData_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.GetActionDataRequest]) (*connect.Response[workflow.GetActionDataResponse], error)) *RunServiceHandler_GetActionData_Call { + _c.Call.Return(run) + return _c +} + +// GetActionDetails provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceHandler) GetActionDetails(_a0 context.Context, _a1 *connect.Request[workflow.GetActionDetailsRequest]) (*connect.Response[workflow.GetActionDetailsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetActionDetails") + } + + var r0 *connect.Response[workflow.GetActionDetailsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.GetActionDetailsRequest]) (*connect.Response[workflow.GetActionDetailsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.GetActionDetailsRequest]) *connect.Response[workflow.GetActionDetailsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.GetActionDetailsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.GetActionDetailsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceHandler_GetActionDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActionDetails' +type RunServiceHandler_GetActionDetails_Call struct { + *mock.Call +} + +// GetActionDetails is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.GetActionDetailsRequest] +func (_e *RunServiceHandler_Expecter) GetActionDetails(_a0 interface{}, _a1 interface{}) *RunServiceHandler_GetActionDetails_Call { + return &RunServiceHandler_GetActionDetails_Call{Call: _e.mock.On("GetActionDetails", _a0, _a1)} +} + +func (_c *RunServiceHandler_GetActionDetails_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.GetActionDetailsRequest])) *RunServiceHandler_GetActionDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.GetActionDetailsRequest])) + }) + return _c +} + +func (_c *RunServiceHandler_GetActionDetails_Call) Return(_a0 *connect.Response[workflow.GetActionDetailsResponse], _a1 error) *RunServiceHandler_GetActionDetails_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceHandler_GetActionDetails_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.GetActionDetailsRequest]) (*connect.Response[workflow.GetActionDetailsResponse], error)) *RunServiceHandler_GetActionDetails_Call { + _c.Call.Return(run) + return _c +} + +// GetRunDetails provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceHandler) GetRunDetails(_a0 context.Context, _a1 *connect.Request[workflow.GetRunDetailsRequest]) (*connect.Response[workflow.GetRunDetailsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for GetRunDetails") + } + + var r0 *connect.Response[workflow.GetRunDetailsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.GetRunDetailsRequest]) (*connect.Response[workflow.GetRunDetailsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.GetRunDetailsRequest]) *connect.Response[workflow.GetRunDetailsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.GetRunDetailsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.GetRunDetailsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceHandler_GetRunDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRunDetails' +type RunServiceHandler_GetRunDetails_Call struct { + *mock.Call +} + +// GetRunDetails is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.GetRunDetailsRequest] +func (_e *RunServiceHandler_Expecter) GetRunDetails(_a0 interface{}, _a1 interface{}) *RunServiceHandler_GetRunDetails_Call { + return &RunServiceHandler_GetRunDetails_Call{Call: _e.mock.On("GetRunDetails", _a0, _a1)} +} + +func (_c *RunServiceHandler_GetRunDetails_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.GetRunDetailsRequest])) *RunServiceHandler_GetRunDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.GetRunDetailsRequest])) + }) + return _c +} + +func (_c *RunServiceHandler_GetRunDetails_Call) Return(_a0 *connect.Response[workflow.GetRunDetailsResponse], _a1 error) *RunServiceHandler_GetRunDetails_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceHandler_GetRunDetails_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.GetRunDetailsRequest]) (*connect.Response[workflow.GetRunDetailsResponse], error)) *RunServiceHandler_GetRunDetails_Call { + _c.Call.Return(run) + return _c +} + +// ListActions provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceHandler) ListActions(_a0 context.Context, _a1 *connect.Request[workflow.ListActionsRequest]) (*connect.Response[workflow.ListActionsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for ListActions") + } + + var r0 *connect.Response[workflow.ListActionsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.ListActionsRequest]) (*connect.Response[workflow.ListActionsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.ListActionsRequest]) *connect.Response[workflow.ListActionsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.ListActionsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.ListActionsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceHandler_ListActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListActions' +type RunServiceHandler_ListActions_Call struct { + *mock.Call +} + +// ListActions is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.ListActionsRequest] +func (_e *RunServiceHandler_Expecter) ListActions(_a0 interface{}, _a1 interface{}) *RunServiceHandler_ListActions_Call { + return &RunServiceHandler_ListActions_Call{Call: _e.mock.On("ListActions", _a0, _a1)} +} + +func (_c *RunServiceHandler_ListActions_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.ListActionsRequest])) *RunServiceHandler_ListActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.ListActionsRequest])) + }) + return _c +} + +func (_c *RunServiceHandler_ListActions_Call) Return(_a0 *connect.Response[workflow.ListActionsResponse], _a1 error) *RunServiceHandler_ListActions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceHandler_ListActions_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.ListActionsRequest]) (*connect.Response[workflow.ListActionsResponse], error)) *RunServiceHandler_ListActions_Call { + _c.Call.Return(run) + return _c +} + +// ListRuns provides a mock function with given fields: _a0, _a1 +func (_m *RunServiceHandler) ListRuns(_a0 context.Context, _a1 *connect.Request[workflow.ListRunsRequest]) (*connect.Response[workflow.ListRunsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for ListRuns") + } + + var r0 *connect.Response[workflow.ListRunsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.ListRunsRequest]) (*connect.Response[workflow.ListRunsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.ListRunsRequest]) *connect.Response[workflow.ListRunsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.ListRunsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.ListRunsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RunServiceHandler_ListRuns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRuns' +type RunServiceHandler_ListRuns_Call struct { + *mock.Call +} + +// ListRuns is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.ListRunsRequest] +func (_e *RunServiceHandler_Expecter) ListRuns(_a0 interface{}, _a1 interface{}) *RunServiceHandler_ListRuns_Call { + return &RunServiceHandler_ListRuns_Call{Call: _e.mock.On("ListRuns", _a0, _a1)} +} + +func (_c *RunServiceHandler_ListRuns_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.ListRunsRequest])) *RunServiceHandler_ListRuns_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.ListRunsRequest])) + }) + return _c +} + +func (_c *RunServiceHandler_ListRuns_Call) Return(_a0 *connect.Response[workflow.ListRunsResponse], _a1 error) *RunServiceHandler_ListRuns_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RunServiceHandler_ListRuns_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.ListRunsRequest]) (*connect.Response[workflow.ListRunsResponse], error)) *RunServiceHandler_ListRuns_Call { + _c.Call.Return(run) + return _c +} + +// WatchActionDetails provides a mock function with given fields: _a0, _a1, _a2 +func (_m *RunServiceHandler) WatchActionDetails(_a0 context.Context, _a1 *connect.Request[workflow.WatchActionDetailsRequest], _a2 *connect.ServerStream[workflow.WatchActionDetailsResponse]) error { + ret := _m.Called(_a0, _a1, _a2) + + if len(ret) == 0 { + panic("no return value specified for WatchActionDetails") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchActionDetailsRequest], *connect.ServerStream[workflow.WatchActionDetailsResponse]) error); ok { + r0 = rf(_a0, _a1, _a2) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunServiceHandler_WatchActionDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchActionDetails' +type RunServiceHandler_WatchActionDetails_Call struct { + *mock.Call +} + +// WatchActionDetails is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.WatchActionDetailsRequest] +// - _a2 *connect.ServerStream[workflow.WatchActionDetailsResponse] +func (_e *RunServiceHandler_Expecter) WatchActionDetails(_a0 interface{}, _a1 interface{}, _a2 interface{}) *RunServiceHandler_WatchActionDetails_Call { + return &RunServiceHandler_WatchActionDetails_Call{Call: _e.mock.On("WatchActionDetails", _a0, _a1, _a2)} +} + +func (_c *RunServiceHandler_WatchActionDetails_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.WatchActionDetailsRequest], _a2 *connect.ServerStream[workflow.WatchActionDetailsResponse])) *RunServiceHandler_WatchActionDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.WatchActionDetailsRequest]), args[2].(*connect.ServerStream[workflow.WatchActionDetailsResponse])) + }) + return _c +} + +func (_c *RunServiceHandler_WatchActionDetails_Call) Return(_a0 error) *RunServiceHandler_WatchActionDetails_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunServiceHandler_WatchActionDetails_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.WatchActionDetailsRequest], *connect.ServerStream[workflow.WatchActionDetailsResponse]) error) *RunServiceHandler_WatchActionDetails_Call { + _c.Call.Return(run) + return _c +} + +// WatchActions provides a mock function with given fields: _a0, _a1, _a2 +func (_m *RunServiceHandler) WatchActions(_a0 context.Context, _a1 *connect.Request[workflow.WatchActionsRequest], _a2 *connect.ServerStream[workflow.WatchActionsResponse]) error { + ret := _m.Called(_a0, _a1, _a2) + + if len(ret) == 0 { + panic("no return value specified for WatchActions") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchActionsRequest], *connect.ServerStream[workflow.WatchActionsResponse]) error); ok { + r0 = rf(_a0, _a1, _a2) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunServiceHandler_WatchActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchActions' +type RunServiceHandler_WatchActions_Call struct { + *mock.Call +} + +// WatchActions is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.WatchActionsRequest] +// - _a2 *connect.ServerStream[workflow.WatchActionsResponse] +func (_e *RunServiceHandler_Expecter) WatchActions(_a0 interface{}, _a1 interface{}, _a2 interface{}) *RunServiceHandler_WatchActions_Call { + return &RunServiceHandler_WatchActions_Call{Call: _e.mock.On("WatchActions", _a0, _a1, _a2)} +} + +func (_c *RunServiceHandler_WatchActions_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.WatchActionsRequest], _a2 *connect.ServerStream[workflow.WatchActionsResponse])) *RunServiceHandler_WatchActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.WatchActionsRequest]), args[2].(*connect.ServerStream[workflow.WatchActionsResponse])) + }) + return _c +} + +func (_c *RunServiceHandler_WatchActions_Call) Return(_a0 error) *RunServiceHandler_WatchActions_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunServiceHandler_WatchActions_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.WatchActionsRequest], *connect.ServerStream[workflow.WatchActionsResponse]) error) *RunServiceHandler_WatchActions_Call { + _c.Call.Return(run) + return _c +} + +// WatchClusterEvents provides a mock function with given fields: _a0, _a1, _a2 +func (_m *RunServiceHandler) WatchClusterEvents(_a0 context.Context, _a1 *connect.Request[workflow.WatchClusterEventsRequest], _a2 *connect.ServerStream[workflow.WatchClusterEventsResponse]) error { + ret := _m.Called(_a0, _a1, _a2) + + if len(ret) == 0 { + panic("no return value specified for WatchClusterEvents") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchClusterEventsRequest], *connect.ServerStream[workflow.WatchClusterEventsResponse]) error); ok { + r0 = rf(_a0, _a1, _a2) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunServiceHandler_WatchClusterEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchClusterEvents' +type RunServiceHandler_WatchClusterEvents_Call struct { + *mock.Call +} + +// WatchClusterEvents is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.WatchClusterEventsRequest] +// - _a2 *connect.ServerStream[workflow.WatchClusterEventsResponse] +func (_e *RunServiceHandler_Expecter) WatchClusterEvents(_a0 interface{}, _a1 interface{}, _a2 interface{}) *RunServiceHandler_WatchClusterEvents_Call { + return &RunServiceHandler_WatchClusterEvents_Call{Call: _e.mock.On("WatchClusterEvents", _a0, _a1, _a2)} +} + +func (_c *RunServiceHandler_WatchClusterEvents_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.WatchClusterEventsRequest], _a2 *connect.ServerStream[workflow.WatchClusterEventsResponse])) *RunServiceHandler_WatchClusterEvents_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.WatchClusterEventsRequest]), args[2].(*connect.ServerStream[workflow.WatchClusterEventsResponse])) + }) + return _c +} + +func (_c *RunServiceHandler_WatchClusterEvents_Call) Return(_a0 error) *RunServiceHandler_WatchClusterEvents_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunServiceHandler_WatchClusterEvents_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.WatchClusterEventsRequest], *connect.ServerStream[workflow.WatchClusterEventsResponse]) error) *RunServiceHandler_WatchClusterEvents_Call { + _c.Call.Return(run) + return _c +} + +// WatchGroups provides a mock function with given fields: _a0, _a1, _a2 +func (_m *RunServiceHandler) WatchGroups(_a0 context.Context, _a1 *connect.Request[workflow.WatchGroupsRequest], _a2 *connect.ServerStream[workflow.WatchGroupsResponse]) error { + ret := _m.Called(_a0, _a1, _a2) + + if len(ret) == 0 { + panic("no return value specified for WatchGroups") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchGroupsRequest], *connect.ServerStream[workflow.WatchGroupsResponse]) error); ok { + r0 = rf(_a0, _a1, _a2) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunServiceHandler_WatchGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchGroups' +type RunServiceHandler_WatchGroups_Call struct { + *mock.Call +} + +// WatchGroups is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.WatchGroupsRequest] +// - _a2 *connect.ServerStream[workflow.WatchGroupsResponse] +func (_e *RunServiceHandler_Expecter) WatchGroups(_a0 interface{}, _a1 interface{}, _a2 interface{}) *RunServiceHandler_WatchGroups_Call { + return &RunServiceHandler_WatchGroups_Call{Call: _e.mock.On("WatchGroups", _a0, _a1, _a2)} +} + +func (_c *RunServiceHandler_WatchGroups_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.WatchGroupsRequest], _a2 *connect.ServerStream[workflow.WatchGroupsResponse])) *RunServiceHandler_WatchGroups_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.WatchGroupsRequest]), args[2].(*connect.ServerStream[workflow.WatchGroupsResponse])) + }) + return _c +} + +func (_c *RunServiceHandler_WatchGroups_Call) Return(_a0 error) *RunServiceHandler_WatchGroups_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunServiceHandler_WatchGroups_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.WatchGroupsRequest], *connect.ServerStream[workflow.WatchGroupsResponse]) error) *RunServiceHandler_WatchGroups_Call { + _c.Call.Return(run) + return _c +} + +// WatchRunDetails provides a mock function with given fields: _a0, _a1, _a2 +func (_m *RunServiceHandler) WatchRunDetails(_a0 context.Context, _a1 *connect.Request[workflow.WatchRunDetailsRequest], _a2 *connect.ServerStream[workflow.WatchRunDetailsResponse]) error { + ret := _m.Called(_a0, _a1, _a2) + + if len(ret) == 0 { + panic("no return value specified for WatchRunDetails") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchRunDetailsRequest], *connect.ServerStream[workflow.WatchRunDetailsResponse]) error); ok { + r0 = rf(_a0, _a1, _a2) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunServiceHandler_WatchRunDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchRunDetails' +type RunServiceHandler_WatchRunDetails_Call struct { + *mock.Call +} + +// WatchRunDetails is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.WatchRunDetailsRequest] +// - _a2 *connect.ServerStream[workflow.WatchRunDetailsResponse] +func (_e *RunServiceHandler_Expecter) WatchRunDetails(_a0 interface{}, _a1 interface{}, _a2 interface{}) *RunServiceHandler_WatchRunDetails_Call { + return &RunServiceHandler_WatchRunDetails_Call{Call: _e.mock.On("WatchRunDetails", _a0, _a1, _a2)} +} + +func (_c *RunServiceHandler_WatchRunDetails_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.WatchRunDetailsRequest], _a2 *connect.ServerStream[workflow.WatchRunDetailsResponse])) *RunServiceHandler_WatchRunDetails_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.WatchRunDetailsRequest]), args[2].(*connect.ServerStream[workflow.WatchRunDetailsResponse])) + }) + return _c +} + +func (_c *RunServiceHandler_WatchRunDetails_Call) Return(_a0 error) *RunServiceHandler_WatchRunDetails_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunServiceHandler_WatchRunDetails_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.WatchRunDetailsRequest], *connect.ServerStream[workflow.WatchRunDetailsResponse]) error) *RunServiceHandler_WatchRunDetails_Call { + _c.Call.Return(run) + return _c +} + +// WatchRuns provides a mock function with given fields: _a0, _a1, _a2 +func (_m *RunServiceHandler) WatchRuns(_a0 context.Context, _a1 *connect.Request[workflow.WatchRunsRequest], _a2 *connect.ServerStream[workflow.WatchRunsResponse]) error { + ret := _m.Called(_a0, _a1, _a2) + + if len(ret) == 0 { + panic("no return value specified for WatchRuns") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchRunsRequest], *connect.ServerStream[workflow.WatchRunsResponse]) error); ok { + r0 = rf(_a0, _a1, _a2) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RunServiceHandler_WatchRuns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchRuns' +type RunServiceHandler_WatchRuns_Call struct { + *mock.Call +} + +// WatchRuns is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.WatchRunsRequest] +// - _a2 *connect.ServerStream[workflow.WatchRunsResponse] +func (_e *RunServiceHandler_Expecter) WatchRuns(_a0 interface{}, _a1 interface{}, _a2 interface{}) *RunServiceHandler_WatchRuns_Call { + return &RunServiceHandler_WatchRuns_Call{Call: _e.mock.On("WatchRuns", _a0, _a1, _a2)} +} + +func (_c *RunServiceHandler_WatchRuns_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.WatchRunsRequest], _a2 *connect.ServerStream[workflow.WatchRunsResponse])) *RunServiceHandler_WatchRuns_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.WatchRunsRequest]), args[2].(*connect.ServerStream[workflow.WatchRunsResponse])) + }) + return _c +} + +func (_c *RunServiceHandler_WatchRuns_Call) Return(_a0 error) *RunServiceHandler_WatchRuns_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RunServiceHandler_WatchRuns_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.WatchRunsRequest], *connect.ServerStream[workflow.WatchRunsResponse]) error) *RunServiceHandler_WatchRuns_Call { + _c.Call.Return(run) + return _c +} + +// NewRunServiceHandler creates a new instance of RunServiceHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRunServiceHandler(t interface { + mock.TestingT + Cleanup(func()) +}) *RunServiceHandler { + mock := &RunServiceHandler{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/workflowconnect/mocks/state_service_client.go b/gen/go/flyteidl2/workflow/workflowconnect/mocks/state_service_client.go new file mode 100644 index 0000000000..d724b49613 --- /dev/null +++ b/gen/go/flyteidl2/workflow/workflowconnect/mocks/state_service_client.go @@ -0,0 +1,217 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + connect "connectrpc.com/connect" + + mock "github.com/stretchr/testify/mock" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// StateServiceClient is an autogenerated mock type for the StateServiceClient type +type StateServiceClient struct { + mock.Mock +} + +type StateServiceClient_Expecter struct { + mock *mock.Mock +} + +func (_m *StateServiceClient) EXPECT() *StateServiceClient_Expecter { + return &StateServiceClient_Expecter{mock: &_m.Mock} +} + +// Get provides a mock function with given fields: _a0, _a1 +func (_m *StateServiceClient) Get(_a0 context.Context, _a1 *connect.Request[workflow.GetRequest]) (*connect.Response[workflow.GetResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 *connect.Response[workflow.GetResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.GetRequest]) (*connect.Response[workflow.GetResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.GetRequest]) *connect.Response[workflow.GetResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.GetResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.GetRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StateServiceClient_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type StateServiceClient_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.GetRequest] +func (_e *StateServiceClient_Expecter) Get(_a0 interface{}, _a1 interface{}) *StateServiceClient_Get_Call { + return &StateServiceClient_Get_Call{Call: _e.mock.On("Get", _a0, _a1)} +} + +func (_c *StateServiceClient_Get_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.GetRequest])) *StateServiceClient_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.GetRequest])) + }) + return _c +} + +func (_c *StateServiceClient_Get_Call) Return(_a0 *connect.Response[workflow.GetResponse], _a1 error) *StateServiceClient_Get_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StateServiceClient_Get_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.GetRequest]) (*connect.Response[workflow.GetResponse], error)) *StateServiceClient_Get_Call { + _c.Call.Return(run) + return _c +} + +// Put provides a mock function with given fields: _a0, _a1 +func (_m *StateServiceClient) Put(_a0 context.Context, _a1 *connect.Request[workflow.PutRequest]) (*connect.Response[workflow.PutResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for Put") + } + + var r0 *connect.Response[workflow.PutResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.PutRequest]) (*connect.Response[workflow.PutResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.PutRequest]) *connect.Response[workflow.PutResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.PutResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.PutRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StateServiceClient_Put_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Put' +type StateServiceClient_Put_Call struct { + *mock.Call +} + +// Put is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.PutRequest] +func (_e *StateServiceClient_Expecter) Put(_a0 interface{}, _a1 interface{}) *StateServiceClient_Put_Call { + return &StateServiceClient_Put_Call{Call: _e.mock.On("Put", _a0, _a1)} +} + +func (_c *StateServiceClient_Put_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.PutRequest])) *StateServiceClient_Put_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.PutRequest])) + }) + return _c +} + +func (_c *StateServiceClient_Put_Call) Return(_a0 *connect.Response[workflow.PutResponse], _a1 error) *StateServiceClient_Put_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StateServiceClient_Put_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.PutRequest]) (*connect.Response[workflow.PutResponse], error)) *StateServiceClient_Put_Call { + _c.Call.Return(run) + return _c +} + +// Watch provides a mock function with given fields: _a0, _a1 +func (_m *StateServiceClient) Watch(_a0 context.Context, _a1 *connect.Request[workflow.WatchRequest]) (*connect.ServerStreamForClient[workflow.WatchResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for Watch") + } + + var r0 *connect.ServerStreamForClient[workflow.WatchResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchRequest]) (*connect.ServerStreamForClient[workflow.WatchResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchRequest]) *connect.ServerStreamForClient[workflow.WatchResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.ServerStreamForClient[workflow.WatchResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.WatchRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StateServiceClient_Watch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Watch' +type StateServiceClient_Watch_Call struct { + *mock.Call +} + +// Watch is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.WatchRequest] +func (_e *StateServiceClient_Expecter) Watch(_a0 interface{}, _a1 interface{}) *StateServiceClient_Watch_Call { + return &StateServiceClient_Watch_Call{Call: _e.mock.On("Watch", _a0, _a1)} +} + +func (_c *StateServiceClient_Watch_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.WatchRequest])) *StateServiceClient_Watch_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.WatchRequest])) + }) + return _c +} + +func (_c *StateServiceClient_Watch_Call) Return(_a0 *connect.ServerStreamForClient[workflow.WatchResponse], _a1 error) *StateServiceClient_Watch_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StateServiceClient_Watch_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.WatchRequest]) (*connect.ServerStreamForClient[workflow.WatchResponse], error)) *StateServiceClient_Watch_Call { + _c.Call.Return(run) + return _c +} + +// NewStateServiceClient creates a new instance of StateServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewStateServiceClient(t interface { + mock.TestingT + Cleanup(func()) +}) *StateServiceClient { + mock := &StateServiceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/workflowconnect/mocks/state_service_handler.go b/gen/go/flyteidl2/workflow/workflowconnect/mocks/state_service_handler.go new file mode 100644 index 0000000000..ad463883fa --- /dev/null +++ b/gen/go/flyteidl2/workflow/workflowconnect/mocks/state_service_handler.go @@ -0,0 +1,206 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + connect "connectrpc.com/connect" + + mock "github.com/stretchr/testify/mock" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// StateServiceHandler is an autogenerated mock type for the StateServiceHandler type +type StateServiceHandler struct { + mock.Mock +} + +type StateServiceHandler_Expecter struct { + mock *mock.Mock +} + +func (_m *StateServiceHandler) EXPECT() *StateServiceHandler_Expecter { + return &StateServiceHandler_Expecter{mock: &_m.Mock} +} + +// Get provides a mock function with given fields: _a0, _a1 +func (_m *StateServiceHandler) Get(_a0 context.Context, _a1 *connect.Request[workflow.GetRequest]) (*connect.Response[workflow.GetResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 *connect.Response[workflow.GetResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.GetRequest]) (*connect.Response[workflow.GetResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.GetRequest]) *connect.Response[workflow.GetResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.GetResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.GetRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StateServiceHandler_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type StateServiceHandler_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.GetRequest] +func (_e *StateServiceHandler_Expecter) Get(_a0 interface{}, _a1 interface{}) *StateServiceHandler_Get_Call { + return &StateServiceHandler_Get_Call{Call: _e.mock.On("Get", _a0, _a1)} +} + +func (_c *StateServiceHandler_Get_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.GetRequest])) *StateServiceHandler_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.GetRequest])) + }) + return _c +} + +func (_c *StateServiceHandler_Get_Call) Return(_a0 *connect.Response[workflow.GetResponse], _a1 error) *StateServiceHandler_Get_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StateServiceHandler_Get_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.GetRequest]) (*connect.Response[workflow.GetResponse], error)) *StateServiceHandler_Get_Call { + _c.Call.Return(run) + return _c +} + +// Put provides a mock function with given fields: _a0, _a1 +func (_m *StateServiceHandler) Put(_a0 context.Context, _a1 *connect.Request[workflow.PutRequest]) (*connect.Response[workflow.PutResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for Put") + } + + var r0 *connect.Response[workflow.PutResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.PutRequest]) (*connect.Response[workflow.PutResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.PutRequest]) *connect.Response[workflow.PutResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.PutResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.PutRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StateServiceHandler_Put_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Put' +type StateServiceHandler_Put_Call struct { + *mock.Call +} + +// Put is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.PutRequest] +func (_e *StateServiceHandler_Expecter) Put(_a0 interface{}, _a1 interface{}) *StateServiceHandler_Put_Call { + return &StateServiceHandler_Put_Call{Call: _e.mock.On("Put", _a0, _a1)} +} + +func (_c *StateServiceHandler_Put_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.PutRequest])) *StateServiceHandler_Put_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.PutRequest])) + }) + return _c +} + +func (_c *StateServiceHandler_Put_Call) Return(_a0 *connect.Response[workflow.PutResponse], _a1 error) *StateServiceHandler_Put_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StateServiceHandler_Put_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.PutRequest]) (*connect.Response[workflow.PutResponse], error)) *StateServiceHandler_Put_Call { + _c.Call.Return(run) + return _c +} + +// Watch provides a mock function with given fields: _a0, _a1, _a2 +func (_m *StateServiceHandler) Watch(_a0 context.Context, _a1 *connect.Request[workflow.WatchRequest], _a2 *connect.ServerStream[workflow.WatchResponse]) error { + ret := _m.Called(_a0, _a1, _a2) + + if len(ret) == 0 { + panic("no return value specified for Watch") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.WatchRequest], *connect.ServerStream[workflow.WatchResponse]) error); ok { + r0 = rf(_a0, _a1, _a2) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// StateServiceHandler_Watch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Watch' +type StateServiceHandler_Watch_Call struct { + *mock.Call +} + +// Watch is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.WatchRequest] +// - _a2 *connect.ServerStream[workflow.WatchResponse] +func (_e *StateServiceHandler_Expecter) Watch(_a0 interface{}, _a1 interface{}, _a2 interface{}) *StateServiceHandler_Watch_Call { + return &StateServiceHandler_Watch_Call{Call: _e.mock.On("Watch", _a0, _a1, _a2)} +} + +func (_c *StateServiceHandler_Watch_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.WatchRequest], _a2 *connect.ServerStream[workflow.WatchResponse])) *StateServiceHandler_Watch_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.WatchRequest]), args[2].(*connect.ServerStream[workflow.WatchResponse])) + }) + return _c +} + +func (_c *StateServiceHandler_Watch_Call) Return(_a0 error) *StateServiceHandler_Watch_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StateServiceHandler_Watch_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.WatchRequest], *connect.ServerStream[workflow.WatchResponse]) error) *StateServiceHandler_Watch_Call { + _c.Call.Return(run) + return _c +} + +// NewStateServiceHandler creates a new instance of StateServiceHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewStateServiceHandler(t interface { + mock.TestingT + Cleanup(func()) +}) *StateServiceHandler { + mock := &StateServiceHandler{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/workflowconnect/mocks/translator_service_client.go b/gen/go/flyteidl2/workflow/workflowconnect/mocks/translator_service_client.go new file mode 100644 index 0000000000..0237883d20 --- /dev/null +++ b/gen/go/flyteidl2/workflow/workflowconnect/mocks/translator_service_client.go @@ -0,0 +1,276 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + connect "connectrpc.com/connect" + + mock "github.com/stretchr/testify/mock" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// TranslatorServiceClient is an autogenerated mock type for the TranslatorServiceClient type +type TranslatorServiceClient struct { + mock.Mock +} + +type TranslatorServiceClient_Expecter struct { + mock *mock.Mock +} + +func (_m *TranslatorServiceClient) EXPECT() *TranslatorServiceClient_Expecter { + return &TranslatorServiceClient_Expecter{mock: &_m.Mock} +} + +// JsonValuesToLiterals provides a mock function with given fields: _a0, _a1 +func (_m *TranslatorServiceClient) JsonValuesToLiterals(_a0 context.Context, _a1 *connect.Request[workflow.JsonValuesToLiteralsRequest]) (*connect.Response[workflow.JsonValuesToLiteralsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for JsonValuesToLiterals") + } + + var r0 *connect.Response[workflow.JsonValuesToLiteralsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.JsonValuesToLiteralsRequest]) (*connect.Response[workflow.JsonValuesToLiteralsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.JsonValuesToLiteralsRequest]) *connect.Response[workflow.JsonValuesToLiteralsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.JsonValuesToLiteralsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.JsonValuesToLiteralsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TranslatorServiceClient_JsonValuesToLiterals_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JsonValuesToLiterals' +type TranslatorServiceClient_JsonValuesToLiterals_Call struct { + *mock.Call +} + +// JsonValuesToLiterals is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.JsonValuesToLiteralsRequest] +func (_e *TranslatorServiceClient_Expecter) JsonValuesToLiterals(_a0 interface{}, _a1 interface{}) *TranslatorServiceClient_JsonValuesToLiterals_Call { + return &TranslatorServiceClient_JsonValuesToLiterals_Call{Call: _e.mock.On("JsonValuesToLiterals", _a0, _a1)} +} + +func (_c *TranslatorServiceClient_JsonValuesToLiterals_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.JsonValuesToLiteralsRequest])) *TranslatorServiceClient_JsonValuesToLiterals_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.JsonValuesToLiteralsRequest])) + }) + return _c +} + +func (_c *TranslatorServiceClient_JsonValuesToLiterals_Call) Return(_a0 *connect.Response[workflow.JsonValuesToLiteralsResponse], _a1 error) *TranslatorServiceClient_JsonValuesToLiterals_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TranslatorServiceClient_JsonValuesToLiterals_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.JsonValuesToLiteralsRequest]) (*connect.Response[workflow.JsonValuesToLiteralsResponse], error)) *TranslatorServiceClient_JsonValuesToLiterals_Call { + _c.Call.Return(run) + return _c +} + +// LaunchFormJsonToLiterals provides a mock function with given fields: _a0, _a1 +func (_m *TranslatorServiceClient) LaunchFormJsonToLiterals(_a0 context.Context, _a1 *connect.Request[workflow.LaunchFormJsonToLiteralsRequest]) (*connect.Response[workflow.LaunchFormJsonToLiteralsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for LaunchFormJsonToLiterals") + } + + var r0 *connect.Response[workflow.LaunchFormJsonToLiteralsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.LaunchFormJsonToLiteralsRequest]) (*connect.Response[workflow.LaunchFormJsonToLiteralsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.LaunchFormJsonToLiteralsRequest]) *connect.Response[workflow.LaunchFormJsonToLiteralsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.LaunchFormJsonToLiteralsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.LaunchFormJsonToLiteralsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TranslatorServiceClient_LaunchFormJsonToLiterals_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LaunchFormJsonToLiterals' +type TranslatorServiceClient_LaunchFormJsonToLiterals_Call struct { + *mock.Call +} + +// LaunchFormJsonToLiterals is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.LaunchFormJsonToLiteralsRequest] +func (_e *TranslatorServiceClient_Expecter) LaunchFormJsonToLiterals(_a0 interface{}, _a1 interface{}) *TranslatorServiceClient_LaunchFormJsonToLiterals_Call { + return &TranslatorServiceClient_LaunchFormJsonToLiterals_Call{Call: _e.mock.On("LaunchFormJsonToLiterals", _a0, _a1)} +} + +func (_c *TranslatorServiceClient_LaunchFormJsonToLiterals_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.LaunchFormJsonToLiteralsRequest])) *TranslatorServiceClient_LaunchFormJsonToLiterals_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.LaunchFormJsonToLiteralsRequest])) + }) + return _c +} + +func (_c *TranslatorServiceClient_LaunchFormJsonToLiterals_Call) Return(_a0 *connect.Response[workflow.LaunchFormJsonToLiteralsResponse], _a1 error) *TranslatorServiceClient_LaunchFormJsonToLiterals_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TranslatorServiceClient_LaunchFormJsonToLiterals_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.LaunchFormJsonToLiteralsRequest]) (*connect.Response[workflow.LaunchFormJsonToLiteralsResponse], error)) *TranslatorServiceClient_LaunchFormJsonToLiterals_Call { + _c.Call.Return(run) + return _c +} + +// LiteralsToLaunchFormJson provides a mock function with given fields: _a0, _a1 +func (_m *TranslatorServiceClient) LiteralsToLaunchFormJson(_a0 context.Context, _a1 *connect.Request[workflow.LiteralsToLaunchFormJsonRequest]) (*connect.Response[workflow.LiteralsToLaunchFormJsonResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for LiteralsToLaunchFormJson") + } + + var r0 *connect.Response[workflow.LiteralsToLaunchFormJsonResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.LiteralsToLaunchFormJsonRequest]) (*connect.Response[workflow.LiteralsToLaunchFormJsonResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.LiteralsToLaunchFormJsonRequest]) *connect.Response[workflow.LiteralsToLaunchFormJsonResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.LiteralsToLaunchFormJsonResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.LiteralsToLaunchFormJsonRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TranslatorServiceClient_LiteralsToLaunchFormJson_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LiteralsToLaunchFormJson' +type TranslatorServiceClient_LiteralsToLaunchFormJson_Call struct { + *mock.Call +} + +// LiteralsToLaunchFormJson is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.LiteralsToLaunchFormJsonRequest] +func (_e *TranslatorServiceClient_Expecter) LiteralsToLaunchFormJson(_a0 interface{}, _a1 interface{}) *TranslatorServiceClient_LiteralsToLaunchFormJson_Call { + return &TranslatorServiceClient_LiteralsToLaunchFormJson_Call{Call: _e.mock.On("LiteralsToLaunchFormJson", _a0, _a1)} +} + +func (_c *TranslatorServiceClient_LiteralsToLaunchFormJson_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.LiteralsToLaunchFormJsonRequest])) *TranslatorServiceClient_LiteralsToLaunchFormJson_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.LiteralsToLaunchFormJsonRequest])) + }) + return _c +} + +func (_c *TranslatorServiceClient_LiteralsToLaunchFormJson_Call) Return(_a0 *connect.Response[workflow.LiteralsToLaunchFormJsonResponse], _a1 error) *TranslatorServiceClient_LiteralsToLaunchFormJson_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TranslatorServiceClient_LiteralsToLaunchFormJson_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.LiteralsToLaunchFormJsonRequest]) (*connect.Response[workflow.LiteralsToLaunchFormJsonResponse], error)) *TranslatorServiceClient_LiteralsToLaunchFormJson_Call { + _c.Call.Return(run) + return _c +} + +// TaskSpecToLaunchFormJson provides a mock function with given fields: _a0, _a1 +func (_m *TranslatorServiceClient) TaskSpecToLaunchFormJson(_a0 context.Context, _a1 *connect.Request[workflow.TaskSpecToLaunchFormJsonRequest]) (*connect.Response[workflow.TaskSpecToLaunchFormJsonResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for TaskSpecToLaunchFormJson") + } + + var r0 *connect.Response[workflow.TaskSpecToLaunchFormJsonResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.TaskSpecToLaunchFormJsonRequest]) (*connect.Response[workflow.TaskSpecToLaunchFormJsonResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.TaskSpecToLaunchFormJsonRequest]) *connect.Response[workflow.TaskSpecToLaunchFormJsonResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.TaskSpecToLaunchFormJsonResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.TaskSpecToLaunchFormJsonRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TranslatorServiceClient_TaskSpecToLaunchFormJson_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TaskSpecToLaunchFormJson' +type TranslatorServiceClient_TaskSpecToLaunchFormJson_Call struct { + *mock.Call +} + +// TaskSpecToLaunchFormJson is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.TaskSpecToLaunchFormJsonRequest] +func (_e *TranslatorServiceClient_Expecter) TaskSpecToLaunchFormJson(_a0 interface{}, _a1 interface{}) *TranslatorServiceClient_TaskSpecToLaunchFormJson_Call { + return &TranslatorServiceClient_TaskSpecToLaunchFormJson_Call{Call: _e.mock.On("TaskSpecToLaunchFormJson", _a0, _a1)} +} + +func (_c *TranslatorServiceClient_TaskSpecToLaunchFormJson_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.TaskSpecToLaunchFormJsonRequest])) *TranslatorServiceClient_TaskSpecToLaunchFormJson_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.TaskSpecToLaunchFormJsonRequest])) + }) + return _c +} + +func (_c *TranslatorServiceClient_TaskSpecToLaunchFormJson_Call) Return(_a0 *connect.Response[workflow.TaskSpecToLaunchFormJsonResponse], _a1 error) *TranslatorServiceClient_TaskSpecToLaunchFormJson_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TranslatorServiceClient_TaskSpecToLaunchFormJson_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.TaskSpecToLaunchFormJsonRequest]) (*connect.Response[workflow.TaskSpecToLaunchFormJsonResponse], error)) *TranslatorServiceClient_TaskSpecToLaunchFormJson_Call { + _c.Call.Return(run) + return _c +} + +// NewTranslatorServiceClient creates a new instance of TranslatorServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTranslatorServiceClient(t interface { + mock.TestingT + Cleanup(func()) +}) *TranslatorServiceClient { + mock := &TranslatorServiceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/workflowconnect/mocks/translator_service_handler.go b/gen/go/flyteidl2/workflow/workflowconnect/mocks/translator_service_handler.go new file mode 100644 index 0000000000..e82c7a198c --- /dev/null +++ b/gen/go/flyteidl2/workflow/workflowconnect/mocks/translator_service_handler.go @@ -0,0 +1,276 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + connect "connectrpc.com/connect" + + mock "github.com/stretchr/testify/mock" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// TranslatorServiceHandler is an autogenerated mock type for the TranslatorServiceHandler type +type TranslatorServiceHandler struct { + mock.Mock +} + +type TranslatorServiceHandler_Expecter struct { + mock *mock.Mock +} + +func (_m *TranslatorServiceHandler) EXPECT() *TranslatorServiceHandler_Expecter { + return &TranslatorServiceHandler_Expecter{mock: &_m.Mock} +} + +// JsonValuesToLiterals provides a mock function with given fields: _a0, _a1 +func (_m *TranslatorServiceHandler) JsonValuesToLiterals(_a0 context.Context, _a1 *connect.Request[workflow.JsonValuesToLiteralsRequest]) (*connect.Response[workflow.JsonValuesToLiteralsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for JsonValuesToLiterals") + } + + var r0 *connect.Response[workflow.JsonValuesToLiteralsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.JsonValuesToLiteralsRequest]) (*connect.Response[workflow.JsonValuesToLiteralsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.JsonValuesToLiteralsRequest]) *connect.Response[workflow.JsonValuesToLiteralsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.JsonValuesToLiteralsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.JsonValuesToLiteralsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TranslatorServiceHandler_JsonValuesToLiterals_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JsonValuesToLiterals' +type TranslatorServiceHandler_JsonValuesToLiterals_Call struct { + *mock.Call +} + +// JsonValuesToLiterals is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.JsonValuesToLiteralsRequest] +func (_e *TranslatorServiceHandler_Expecter) JsonValuesToLiterals(_a0 interface{}, _a1 interface{}) *TranslatorServiceHandler_JsonValuesToLiterals_Call { + return &TranslatorServiceHandler_JsonValuesToLiterals_Call{Call: _e.mock.On("JsonValuesToLiterals", _a0, _a1)} +} + +func (_c *TranslatorServiceHandler_JsonValuesToLiterals_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.JsonValuesToLiteralsRequest])) *TranslatorServiceHandler_JsonValuesToLiterals_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.JsonValuesToLiteralsRequest])) + }) + return _c +} + +func (_c *TranslatorServiceHandler_JsonValuesToLiterals_Call) Return(_a0 *connect.Response[workflow.JsonValuesToLiteralsResponse], _a1 error) *TranslatorServiceHandler_JsonValuesToLiterals_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TranslatorServiceHandler_JsonValuesToLiterals_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.JsonValuesToLiteralsRequest]) (*connect.Response[workflow.JsonValuesToLiteralsResponse], error)) *TranslatorServiceHandler_JsonValuesToLiterals_Call { + _c.Call.Return(run) + return _c +} + +// LaunchFormJsonToLiterals provides a mock function with given fields: _a0, _a1 +func (_m *TranslatorServiceHandler) LaunchFormJsonToLiterals(_a0 context.Context, _a1 *connect.Request[workflow.LaunchFormJsonToLiteralsRequest]) (*connect.Response[workflow.LaunchFormJsonToLiteralsResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for LaunchFormJsonToLiterals") + } + + var r0 *connect.Response[workflow.LaunchFormJsonToLiteralsResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.LaunchFormJsonToLiteralsRequest]) (*connect.Response[workflow.LaunchFormJsonToLiteralsResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.LaunchFormJsonToLiteralsRequest]) *connect.Response[workflow.LaunchFormJsonToLiteralsResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.LaunchFormJsonToLiteralsResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.LaunchFormJsonToLiteralsRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TranslatorServiceHandler_LaunchFormJsonToLiterals_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LaunchFormJsonToLiterals' +type TranslatorServiceHandler_LaunchFormJsonToLiterals_Call struct { + *mock.Call +} + +// LaunchFormJsonToLiterals is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.LaunchFormJsonToLiteralsRequest] +func (_e *TranslatorServiceHandler_Expecter) LaunchFormJsonToLiterals(_a0 interface{}, _a1 interface{}) *TranslatorServiceHandler_LaunchFormJsonToLiterals_Call { + return &TranslatorServiceHandler_LaunchFormJsonToLiterals_Call{Call: _e.mock.On("LaunchFormJsonToLiterals", _a0, _a1)} +} + +func (_c *TranslatorServiceHandler_LaunchFormJsonToLiterals_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.LaunchFormJsonToLiteralsRequest])) *TranslatorServiceHandler_LaunchFormJsonToLiterals_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.LaunchFormJsonToLiteralsRequest])) + }) + return _c +} + +func (_c *TranslatorServiceHandler_LaunchFormJsonToLiterals_Call) Return(_a0 *connect.Response[workflow.LaunchFormJsonToLiteralsResponse], _a1 error) *TranslatorServiceHandler_LaunchFormJsonToLiterals_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TranslatorServiceHandler_LaunchFormJsonToLiterals_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.LaunchFormJsonToLiteralsRequest]) (*connect.Response[workflow.LaunchFormJsonToLiteralsResponse], error)) *TranslatorServiceHandler_LaunchFormJsonToLiterals_Call { + _c.Call.Return(run) + return _c +} + +// LiteralsToLaunchFormJson provides a mock function with given fields: _a0, _a1 +func (_m *TranslatorServiceHandler) LiteralsToLaunchFormJson(_a0 context.Context, _a1 *connect.Request[workflow.LiteralsToLaunchFormJsonRequest]) (*connect.Response[workflow.LiteralsToLaunchFormJsonResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for LiteralsToLaunchFormJson") + } + + var r0 *connect.Response[workflow.LiteralsToLaunchFormJsonResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.LiteralsToLaunchFormJsonRequest]) (*connect.Response[workflow.LiteralsToLaunchFormJsonResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.LiteralsToLaunchFormJsonRequest]) *connect.Response[workflow.LiteralsToLaunchFormJsonResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.LiteralsToLaunchFormJsonResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.LiteralsToLaunchFormJsonRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TranslatorServiceHandler_LiteralsToLaunchFormJson_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LiteralsToLaunchFormJson' +type TranslatorServiceHandler_LiteralsToLaunchFormJson_Call struct { + *mock.Call +} + +// LiteralsToLaunchFormJson is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.LiteralsToLaunchFormJsonRequest] +func (_e *TranslatorServiceHandler_Expecter) LiteralsToLaunchFormJson(_a0 interface{}, _a1 interface{}) *TranslatorServiceHandler_LiteralsToLaunchFormJson_Call { + return &TranslatorServiceHandler_LiteralsToLaunchFormJson_Call{Call: _e.mock.On("LiteralsToLaunchFormJson", _a0, _a1)} +} + +func (_c *TranslatorServiceHandler_LiteralsToLaunchFormJson_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.LiteralsToLaunchFormJsonRequest])) *TranslatorServiceHandler_LiteralsToLaunchFormJson_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.LiteralsToLaunchFormJsonRequest])) + }) + return _c +} + +func (_c *TranslatorServiceHandler_LiteralsToLaunchFormJson_Call) Return(_a0 *connect.Response[workflow.LiteralsToLaunchFormJsonResponse], _a1 error) *TranslatorServiceHandler_LiteralsToLaunchFormJson_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TranslatorServiceHandler_LiteralsToLaunchFormJson_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.LiteralsToLaunchFormJsonRequest]) (*connect.Response[workflow.LiteralsToLaunchFormJsonResponse], error)) *TranslatorServiceHandler_LiteralsToLaunchFormJson_Call { + _c.Call.Return(run) + return _c +} + +// TaskSpecToLaunchFormJson provides a mock function with given fields: _a0, _a1 +func (_m *TranslatorServiceHandler) TaskSpecToLaunchFormJson(_a0 context.Context, _a1 *connect.Request[workflow.TaskSpecToLaunchFormJsonRequest]) (*connect.Response[workflow.TaskSpecToLaunchFormJsonResponse], error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for TaskSpecToLaunchFormJson") + } + + var r0 *connect.Response[workflow.TaskSpecToLaunchFormJsonResponse] + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.TaskSpecToLaunchFormJsonRequest]) (*connect.Response[workflow.TaskSpecToLaunchFormJsonResponse], error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[workflow.TaskSpecToLaunchFormJsonRequest]) *connect.Response[workflow.TaskSpecToLaunchFormJsonResponse]); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[workflow.TaskSpecToLaunchFormJsonResponse]) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[workflow.TaskSpecToLaunchFormJsonRequest]) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TranslatorServiceHandler_TaskSpecToLaunchFormJson_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TaskSpecToLaunchFormJson' +type TranslatorServiceHandler_TaskSpecToLaunchFormJson_Call struct { + *mock.Call +} + +// TaskSpecToLaunchFormJson is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *connect.Request[workflow.TaskSpecToLaunchFormJsonRequest] +func (_e *TranslatorServiceHandler_Expecter) TaskSpecToLaunchFormJson(_a0 interface{}, _a1 interface{}) *TranslatorServiceHandler_TaskSpecToLaunchFormJson_Call { + return &TranslatorServiceHandler_TaskSpecToLaunchFormJson_Call{Call: _e.mock.On("TaskSpecToLaunchFormJson", _a0, _a1)} +} + +func (_c *TranslatorServiceHandler_TaskSpecToLaunchFormJson_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[workflow.TaskSpecToLaunchFormJsonRequest])) *TranslatorServiceHandler_TaskSpecToLaunchFormJson_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*connect.Request[workflow.TaskSpecToLaunchFormJsonRequest])) + }) + return _c +} + +func (_c *TranslatorServiceHandler_TaskSpecToLaunchFormJson_Call) Return(_a0 *connect.Response[workflow.TaskSpecToLaunchFormJsonResponse], _a1 error) *TranslatorServiceHandler_TaskSpecToLaunchFormJson_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TranslatorServiceHandler_TaskSpecToLaunchFormJson_Call) RunAndReturn(run func(context.Context, *connect.Request[workflow.TaskSpecToLaunchFormJsonRequest]) (*connect.Response[workflow.TaskSpecToLaunchFormJsonResponse], error)) *TranslatorServiceHandler_TaskSpecToLaunchFormJson_Call { + _c.Call.Return(run) + return _c +} + +// NewTranslatorServiceHandler creates a new instance of TranslatorServiceHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTranslatorServiceHandler(t interface { + mock.TestingT + Cleanup(func()) +}) *TranslatorServiceHandler { + mock := &TranslatorServiceHandler{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gen/go/flyteidl2/workflow/workflowconnect/queue_service.connect.go b/gen/go/flyteidl2/workflow/workflowconnect/queue_service.connect.go new file mode 100644 index 0000000000..6d76fab859 --- /dev/null +++ b/gen/go/flyteidl2/workflow/workflowconnect/queue_service.connect.go @@ -0,0 +1,179 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: flyteidl2/workflow/queue_service.proto + +package workflowconnect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // QueueServiceName is the fully-qualified name of the QueueService service. + QueueServiceName = "flyteidl2.workflow.QueueService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // QueueServiceEnqueueActionProcedure is the fully-qualified name of the QueueService's + // EnqueueAction RPC. + QueueServiceEnqueueActionProcedure = "/flyteidl2.workflow.QueueService/EnqueueAction" + // QueueServiceAbortQueuedRunProcedure is the fully-qualified name of the QueueService's + // AbortQueuedRun RPC. + QueueServiceAbortQueuedRunProcedure = "/flyteidl2.workflow.QueueService/AbortQueuedRun" + // QueueServiceAbortQueuedActionProcedure is the fully-qualified name of the QueueService's + // AbortQueuedAction RPC. + QueueServiceAbortQueuedActionProcedure = "/flyteidl2.workflow.QueueService/AbortQueuedAction" +) + +// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. +var ( + queueServiceServiceDescriptor = workflow.File_flyteidl2_workflow_queue_service_proto.Services().ByName("QueueService") + queueServiceEnqueueActionMethodDescriptor = queueServiceServiceDescriptor.Methods().ByName("EnqueueAction") + queueServiceAbortQueuedRunMethodDescriptor = queueServiceServiceDescriptor.Methods().ByName("AbortQueuedRun") + queueServiceAbortQueuedActionMethodDescriptor = queueServiceServiceDescriptor.Methods().ByName("AbortQueuedAction") +) + +// QueueServiceClient is a client for the flyteidl2.workflow.QueueService service. +type QueueServiceClient interface { + // queue a new action for execution. + EnqueueAction(context.Context, *connect.Request[workflow.EnqueueActionRequest]) (*connect.Response[workflow.EnqueueActionResponse], error) + // abort a queued run. + AbortQueuedRun(context.Context, *connect.Request[workflow.AbortQueuedRunRequest]) (*connect.Response[workflow.AbortQueuedRunResponse], error) + // AbortAction aborts a single action that was previously queued or is currently being processed by a worker. + AbortQueuedAction(context.Context, *connect.Request[workflow.AbortQueuedActionRequest]) (*connect.Response[workflow.AbortQueuedActionResponse], error) +} + +// NewQueueServiceClient constructs a client for the flyteidl2.workflow.QueueService service. By +// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, +// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the +// connect.WithGRPC() or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewQueueServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) QueueServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &queueServiceClient{ + enqueueAction: connect.NewClient[workflow.EnqueueActionRequest, workflow.EnqueueActionResponse]( + httpClient, + baseURL+QueueServiceEnqueueActionProcedure, + connect.WithSchema(queueServiceEnqueueActionMethodDescriptor), + connect.WithClientOptions(opts...), + ), + abortQueuedRun: connect.NewClient[workflow.AbortQueuedRunRequest, workflow.AbortQueuedRunResponse]( + httpClient, + baseURL+QueueServiceAbortQueuedRunProcedure, + connect.WithSchema(queueServiceAbortQueuedRunMethodDescriptor), + connect.WithClientOptions(opts...), + ), + abortQueuedAction: connect.NewClient[workflow.AbortQueuedActionRequest, workflow.AbortQueuedActionResponse]( + httpClient, + baseURL+QueueServiceAbortQueuedActionProcedure, + connect.WithSchema(queueServiceAbortQueuedActionMethodDescriptor), + connect.WithClientOptions(opts...), + ), + } +} + +// queueServiceClient implements QueueServiceClient. +type queueServiceClient struct { + enqueueAction *connect.Client[workflow.EnqueueActionRequest, workflow.EnqueueActionResponse] + abortQueuedRun *connect.Client[workflow.AbortQueuedRunRequest, workflow.AbortQueuedRunResponse] + abortQueuedAction *connect.Client[workflow.AbortQueuedActionRequest, workflow.AbortQueuedActionResponse] +} + +// EnqueueAction calls flyteidl2.workflow.QueueService.EnqueueAction. +func (c *queueServiceClient) EnqueueAction(ctx context.Context, req *connect.Request[workflow.EnqueueActionRequest]) (*connect.Response[workflow.EnqueueActionResponse], error) { + return c.enqueueAction.CallUnary(ctx, req) +} + +// AbortQueuedRun calls flyteidl2.workflow.QueueService.AbortQueuedRun. +func (c *queueServiceClient) AbortQueuedRun(ctx context.Context, req *connect.Request[workflow.AbortQueuedRunRequest]) (*connect.Response[workflow.AbortQueuedRunResponse], error) { + return c.abortQueuedRun.CallUnary(ctx, req) +} + +// AbortQueuedAction calls flyteidl2.workflow.QueueService.AbortQueuedAction. +func (c *queueServiceClient) AbortQueuedAction(ctx context.Context, req *connect.Request[workflow.AbortQueuedActionRequest]) (*connect.Response[workflow.AbortQueuedActionResponse], error) { + return c.abortQueuedAction.CallUnary(ctx, req) +} + +// QueueServiceHandler is an implementation of the flyteidl2.workflow.QueueService service. +type QueueServiceHandler interface { + // queue a new action for execution. + EnqueueAction(context.Context, *connect.Request[workflow.EnqueueActionRequest]) (*connect.Response[workflow.EnqueueActionResponse], error) + // abort a queued run. + AbortQueuedRun(context.Context, *connect.Request[workflow.AbortQueuedRunRequest]) (*connect.Response[workflow.AbortQueuedRunResponse], error) + // AbortAction aborts a single action that was previously queued or is currently being processed by a worker. + AbortQueuedAction(context.Context, *connect.Request[workflow.AbortQueuedActionRequest]) (*connect.Response[workflow.AbortQueuedActionResponse], error) +} + +// NewQueueServiceHandler builds an HTTP handler from the service implementation. It returns the +// path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewQueueServiceHandler(svc QueueServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + queueServiceEnqueueActionHandler := connect.NewUnaryHandler( + QueueServiceEnqueueActionProcedure, + svc.EnqueueAction, + connect.WithSchema(queueServiceEnqueueActionMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + queueServiceAbortQueuedRunHandler := connect.NewUnaryHandler( + QueueServiceAbortQueuedRunProcedure, + svc.AbortQueuedRun, + connect.WithSchema(queueServiceAbortQueuedRunMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + queueServiceAbortQueuedActionHandler := connect.NewUnaryHandler( + QueueServiceAbortQueuedActionProcedure, + svc.AbortQueuedAction, + connect.WithSchema(queueServiceAbortQueuedActionMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.workflow.QueueService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case QueueServiceEnqueueActionProcedure: + queueServiceEnqueueActionHandler.ServeHTTP(w, r) + case QueueServiceAbortQueuedRunProcedure: + queueServiceAbortQueuedRunHandler.ServeHTTP(w, r) + case QueueServiceAbortQueuedActionProcedure: + queueServiceAbortQueuedActionHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedQueueServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedQueueServiceHandler struct{} + +func (UnimplementedQueueServiceHandler) EnqueueAction(context.Context, *connect.Request[workflow.EnqueueActionRequest]) (*connect.Response[workflow.EnqueueActionResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.QueueService.EnqueueAction is not implemented")) +} + +func (UnimplementedQueueServiceHandler) AbortQueuedRun(context.Context, *connect.Request[workflow.AbortQueuedRunRequest]) (*connect.Response[workflow.AbortQueuedRunResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.QueueService.AbortQueuedRun is not implemented")) +} + +func (UnimplementedQueueServiceHandler) AbortQueuedAction(context.Context, *connect.Request[workflow.AbortQueuedActionRequest]) (*connect.Response[workflow.AbortQueuedActionResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.QueueService.AbortQueuedAction is not implemented")) +} diff --git a/gen/go/flyteidl2/workflow/workflowconnect/run_logs_service.connect.go b/gen/go/flyteidl2/workflow/workflowconnect/run_logs_service.connect.go new file mode 100644 index 0000000000..ca9461070e --- /dev/null +++ b/gen/go/flyteidl2/workflow/workflowconnect/run_logs_service.connect.go @@ -0,0 +1,114 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: flyteidl2/workflow/run_logs_service.proto + +package workflowconnect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // RunLogsServiceName is the fully-qualified name of the RunLogsService service. + RunLogsServiceName = "flyteidl2.workflow.RunLogsService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // RunLogsServiceTailLogsProcedure is the fully-qualified name of the RunLogsService's TailLogs RPC. + RunLogsServiceTailLogsProcedure = "/flyteidl2.workflow.RunLogsService/TailLogs" +) + +// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. +var ( + runLogsServiceServiceDescriptor = workflow.File_flyteidl2_workflow_run_logs_service_proto.Services().ByName("RunLogsService") + runLogsServiceTailLogsMethodDescriptor = runLogsServiceServiceDescriptor.Methods().ByName("TailLogs") +) + +// RunLogsServiceClient is a client for the flyteidl2.workflow.RunLogsService service. +type RunLogsServiceClient interface { + TailLogs(context.Context, *connect.Request[workflow.TailLogsRequest]) (*connect.ServerStreamForClient[workflow.TailLogsResponse], error) +} + +// NewRunLogsServiceClient constructs a client for the flyteidl2.workflow.RunLogsService service. By +// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, +// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the +// connect.WithGRPC() or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewRunLogsServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) RunLogsServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &runLogsServiceClient{ + tailLogs: connect.NewClient[workflow.TailLogsRequest, workflow.TailLogsResponse]( + httpClient, + baseURL+RunLogsServiceTailLogsProcedure, + connect.WithSchema(runLogsServiceTailLogsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + } +} + +// runLogsServiceClient implements RunLogsServiceClient. +type runLogsServiceClient struct { + tailLogs *connect.Client[workflow.TailLogsRequest, workflow.TailLogsResponse] +} + +// TailLogs calls flyteidl2.workflow.RunLogsService.TailLogs. +func (c *runLogsServiceClient) TailLogs(ctx context.Context, req *connect.Request[workflow.TailLogsRequest]) (*connect.ServerStreamForClient[workflow.TailLogsResponse], error) { + return c.tailLogs.CallServerStream(ctx, req) +} + +// RunLogsServiceHandler is an implementation of the flyteidl2.workflow.RunLogsService service. +type RunLogsServiceHandler interface { + TailLogs(context.Context, *connect.Request[workflow.TailLogsRequest], *connect.ServerStream[workflow.TailLogsResponse]) error +} + +// NewRunLogsServiceHandler builds an HTTP handler from the service implementation. It returns the +// path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewRunLogsServiceHandler(svc RunLogsServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + runLogsServiceTailLogsHandler := connect.NewServerStreamHandler( + RunLogsServiceTailLogsProcedure, + svc.TailLogs, + connect.WithSchema(runLogsServiceTailLogsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.workflow.RunLogsService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case RunLogsServiceTailLogsProcedure: + runLogsServiceTailLogsHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedRunLogsServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedRunLogsServiceHandler struct{} + +func (UnimplementedRunLogsServiceHandler) TailLogs(context.Context, *connect.Request[workflow.TailLogsRequest], *connect.ServerStream[workflow.TailLogsResponse]) error { + return connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.RunLogsService.TailLogs is not implemented")) +} diff --git a/gen/go/flyteidl2/workflow/workflowconnect/run_service.connect.go b/gen/go/flyteidl2/workflow/workflowconnect/run_service.connect.go new file mode 100644 index 0000000000..27b912fb42 --- /dev/null +++ b/gen/go/flyteidl2/workflow/workflowconnect/run_service.connect.go @@ -0,0 +1,537 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: flyteidl2/workflow/run_service.proto + +package workflowconnect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // RunServiceName is the fully-qualified name of the RunService service. + RunServiceName = "flyteidl2.workflow.RunService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // RunServiceCreateRunProcedure is the fully-qualified name of the RunService's CreateRun RPC. + RunServiceCreateRunProcedure = "/flyteidl2.workflow.RunService/CreateRun" + // RunServiceAbortRunProcedure is the fully-qualified name of the RunService's AbortRun RPC. + RunServiceAbortRunProcedure = "/flyteidl2.workflow.RunService/AbortRun" + // RunServiceGetRunDetailsProcedure is the fully-qualified name of the RunService's GetRunDetails + // RPC. + RunServiceGetRunDetailsProcedure = "/flyteidl2.workflow.RunService/GetRunDetails" + // RunServiceWatchRunDetailsProcedure is the fully-qualified name of the RunService's + // WatchRunDetails RPC. + RunServiceWatchRunDetailsProcedure = "/flyteidl2.workflow.RunService/WatchRunDetails" + // RunServiceGetActionDetailsProcedure is the fully-qualified name of the RunService's + // GetActionDetails RPC. + RunServiceGetActionDetailsProcedure = "/flyteidl2.workflow.RunService/GetActionDetails" + // RunServiceWatchActionDetailsProcedure is the fully-qualified name of the RunService's + // WatchActionDetails RPC. + RunServiceWatchActionDetailsProcedure = "/flyteidl2.workflow.RunService/WatchActionDetails" + // RunServiceGetActionDataProcedure is the fully-qualified name of the RunService's GetActionData + // RPC. + RunServiceGetActionDataProcedure = "/flyteidl2.workflow.RunService/GetActionData" + // RunServiceListRunsProcedure is the fully-qualified name of the RunService's ListRuns RPC. + RunServiceListRunsProcedure = "/flyteidl2.workflow.RunService/ListRuns" + // RunServiceWatchRunsProcedure is the fully-qualified name of the RunService's WatchRuns RPC. + RunServiceWatchRunsProcedure = "/flyteidl2.workflow.RunService/WatchRuns" + // RunServiceListActionsProcedure is the fully-qualified name of the RunService's ListActions RPC. + RunServiceListActionsProcedure = "/flyteidl2.workflow.RunService/ListActions" + // RunServiceWatchActionsProcedure is the fully-qualified name of the RunService's WatchActions RPC. + RunServiceWatchActionsProcedure = "/flyteidl2.workflow.RunService/WatchActions" + // RunServiceWatchClusterEventsProcedure is the fully-qualified name of the RunService's + // WatchClusterEvents RPC. + RunServiceWatchClusterEventsProcedure = "/flyteidl2.workflow.RunService/WatchClusterEvents" + // RunServiceAbortActionProcedure is the fully-qualified name of the RunService's AbortAction RPC. + RunServiceAbortActionProcedure = "/flyteidl2.workflow.RunService/AbortAction" + // RunServiceWatchGroupsProcedure is the fully-qualified name of the RunService's WatchGroups RPC. + RunServiceWatchGroupsProcedure = "/flyteidl2.workflow.RunService/WatchGroups" +) + +// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. +var ( + runServiceServiceDescriptor = workflow.File_flyteidl2_workflow_run_service_proto.Services().ByName("RunService") + runServiceCreateRunMethodDescriptor = runServiceServiceDescriptor.Methods().ByName("CreateRun") + runServiceAbortRunMethodDescriptor = runServiceServiceDescriptor.Methods().ByName("AbortRun") + runServiceGetRunDetailsMethodDescriptor = runServiceServiceDescriptor.Methods().ByName("GetRunDetails") + runServiceWatchRunDetailsMethodDescriptor = runServiceServiceDescriptor.Methods().ByName("WatchRunDetails") + runServiceGetActionDetailsMethodDescriptor = runServiceServiceDescriptor.Methods().ByName("GetActionDetails") + runServiceWatchActionDetailsMethodDescriptor = runServiceServiceDescriptor.Methods().ByName("WatchActionDetails") + runServiceGetActionDataMethodDescriptor = runServiceServiceDescriptor.Methods().ByName("GetActionData") + runServiceListRunsMethodDescriptor = runServiceServiceDescriptor.Methods().ByName("ListRuns") + runServiceWatchRunsMethodDescriptor = runServiceServiceDescriptor.Methods().ByName("WatchRuns") + runServiceListActionsMethodDescriptor = runServiceServiceDescriptor.Methods().ByName("ListActions") + runServiceWatchActionsMethodDescriptor = runServiceServiceDescriptor.Methods().ByName("WatchActions") + runServiceWatchClusterEventsMethodDescriptor = runServiceServiceDescriptor.Methods().ByName("WatchClusterEvents") + runServiceAbortActionMethodDescriptor = runServiceServiceDescriptor.Methods().ByName("AbortAction") + runServiceWatchGroupsMethodDescriptor = runServiceServiceDescriptor.Methods().ByName("WatchGroups") +) + +// RunServiceClient is a client for the flyteidl2.workflow.RunService service. +type RunServiceClient interface { + // Create a new run of the given task. + CreateRun(context.Context, *connect.Request[workflow.CreateRunRequest]) (*connect.Response[workflow.CreateRunResponse], error) + // Abort a run. + AbortRun(context.Context, *connect.Request[workflow.AbortRunRequest]) (*connect.Response[workflow.AbortRunResponse], error) + // Get detailed information about a run. + GetRunDetails(context.Context, *connect.Request[workflow.GetRunDetailsRequest]) (*connect.Response[workflow.GetRunDetailsResponse], error) + // Stream detailed information updates about a run. The call will terminate when the run reaches a terminal phase. + WatchRunDetails(context.Context, *connect.Request[workflow.WatchRunDetailsRequest]) (*connect.ServerStreamForClient[workflow.WatchRunDetailsResponse], error) + // Get detailed information about an action. + GetActionDetails(context.Context, *connect.Request[workflow.GetActionDetailsRequest]) (*connect.Response[workflow.GetActionDetailsResponse], error) + // Stream detailed information updates about an action. The call will terminate when the action reaches a terminal phase. + WatchActionDetails(context.Context, *connect.Request[workflow.WatchActionDetailsRequest]) (*connect.ServerStreamForClient[workflow.WatchActionDetailsResponse], error) + // Get input and output for an action. + GetActionData(context.Context, *connect.Request[workflow.GetActionDataRequest]) (*connect.Response[workflow.GetActionDataResponse], error) + // List runs based on the provided filter criteria. + ListRuns(context.Context, *connect.Request[workflow.ListRunsRequest]) (*connect.Response[workflow.ListRunsResponse], error) + // Stream updates for runs based on the provided filter criteria. Responses may include newly discovered + // runs or updates to existing ones from the point of invocation. + WatchRuns(context.Context, *connect.Request[workflow.WatchRunsRequest]) (*connect.ServerStreamForClient[workflow.WatchRunsResponse], error) + // List all actions for a given run. + ListActions(context.Context, *connect.Request[workflow.ListActionsRequest]) (*connect.Response[workflow.ListActionsResponse], error) + // Stream updates for actions given a run. Responses may include newly discovered nested runs or updates + // to existing ones from the point of invocation. + WatchActions(context.Context, *connect.Request[workflow.WatchActionsRequest]) (*connect.ServerStreamForClient[workflow.WatchActionsResponse], error) + // Stream of k8s cluster events in human readable form + WatchClusterEvents(context.Context, *connect.Request[workflow.WatchClusterEventsRequest]) (*connect.ServerStreamForClient[workflow.WatchClusterEventsResponse], error) + // AbortAction aborts a single action that was previously created or is currently being processed by a worker. + AbortAction(context.Context, *connect.Request[workflow.AbortActionRequest]) (*connect.Response[workflow.AbortActionResponse], error) + // Stream updates for task groups based on the provided filter criteria. + WatchGroups(context.Context, *connect.Request[workflow.WatchGroupsRequest]) (*connect.ServerStreamForClient[workflow.WatchGroupsResponse], error) +} + +// NewRunServiceClient constructs a client for the flyteidl2.workflow.RunService service. By +// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, +// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the +// connect.WithGRPC() or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewRunServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) RunServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &runServiceClient{ + createRun: connect.NewClient[workflow.CreateRunRequest, workflow.CreateRunResponse]( + httpClient, + baseURL+RunServiceCreateRunProcedure, + connect.WithSchema(runServiceCreateRunMethodDescriptor), + connect.WithClientOptions(opts...), + ), + abortRun: connect.NewClient[workflow.AbortRunRequest, workflow.AbortRunResponse]( + httpClient, + baseURL+RunServiceAbortRunProcedure, + connect.WithSchema(runServiceAbortRunMethodDescriptor), + connect.WithClientOptions(opts...), + ), + getRunDetails: connect.NewClient[workflow.GetRunDetailsRequest, workflow.GetRunDetailsResponse]( + httpClient, + baseURL+RunServiceGetRunDetailsProcedure, + connect.WithSchema(runServiceGetRunDetailsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + watchRunDetails: connect.NewClient[workflow.WatchRunDetailsRequest, workflow.WatchRunDetailsResponse]( + httpClient, + baseURL+RunServiceWatchRunDetailsProcedure, + connect.WithSchema(runServiceWatchRunDetailsMethodDescriptor), + connect.WithClientOptions(opts...), + ), + getActionDetails: connect.NewClient[workflow.GetActionDetailsRequest, workflow.GetActionDetailsResponse]( + httpClient, + baseURL+RunServiceGetActionDetailsProcedure, + connect.WithSchema(runServiceGetActionDetailsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + watchActionDetails: connect.NewClient[workflow.WatchActionDetailsRequest, workflow.WatchActionDetailsResponse]( + httpClient, + baseURL+RunServiceWatchActionDetailsProcedure, + connect.WithSchema(runServiceWatchActionDetailsMethodDescriptor), + connect.WithClientOptions(opts...), + ), + getActionData: connect.NewClient[workflow.GetActionDataRequest, workflow.GetActionDataResponse]( + httpClient, + baseURL+RunServiceGetActionDataProcedure, + connect.WithSchema(runServiceGetActionDataMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + listRuns: connect.NewClient[workflow.ListRunsRequest, workflow.ListRunsResponse]( + httpClient, + baseURL+RunServiceListRunsProcedure, + connect.WithSchema(runServiceListRunsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + watchRuns: connect.NewClient[workflow.WatchRunsRequest, workflow.WatchRunsResponse]( + httpClient, + baseURL+RunServiceWatchRunsProcedure, + connect.WithSchema(runServiceWatchRunsMethodDescriptor), + connect.WithClientOptions(opts...), + ), + listActions: connect.NewClient[workflow.ListActionsRequest, workflow.ListActionsResponse]( + httpClient, + baseURL+RunServiceListActionsProcedure, + connect.WithSchema(runServiceListActionsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + watchActions: connect.NewClient[workflow.WatchActionsRequest, workflow.WatchActionsResponse]( + httpClient, + baseURL+RunServiceWatchActionsProcedure, + connect.WithSchema(runServiceWatchActionsMethodDescriptor), + connect.WithClientOptions(opts...), + ), + watchClusterEvents: connect.NewClient[workflow.WatchClusterEventsRequest, workflow.WatchClusterEventsResponse]( + httpClient, + baseURL+RunServiceWatchClusterEventsProcedure, + connect.WithSchema(runServiceWatchClusterEventsMethodDescriptor), + connect.WithClientOptions(opts...), + ), + abortAction: connect.NewClient[workflow.AbortActionRequest, workflow.AbortActionResponse]( + httpClient, + baseURL+RunServiceAbortActionProcedure, + connect.WithSchema(runServiceAbortActionMethodDescriptor), + connect.WithClientOptions(opts...), + ), + watchGroups: connect.NewClient[workflow.WatchGroupsRequest, workflow.WatchGroupsResponse]( + httpClient, + baseURL+RunServiceWatchGroupsProcedure, + connect.WithSchema(runServiceWatchGroupsMethodDescriptor), + connect.WithClientOptions(opts...), + ), + } +} + +// runServiceClient implements RunServiceClient. +type runServiceClient struct { + createRun *connect.Client[workflow.CreateRunRequest, workflow.CreateRunResponse] + abortRun *connect.Client[workflow.AbortRunRequest, workflow.AbortRunResponse] + getRunDetails *connect.Client[workflow.GetRunDetailsRequest, workflow.GetRunDetailsResponse] + watchRunDetails *connect.Client[workflow.WatchRunDetailsRequest, workflow.WatchRunDetailsResponse] + getActionDetails *connect.Client[workflow.GetActionDetailsRequest, workflow.GetActionDetailsResponse] + watchActionDetails *connect.Client[workflow.WatchActionDetailsRequest, workflow.WatchActionDetailsResponse] + getActionData *connect.Client[workflow.GetActionDataRequest, workflow.GetActionDataResponse] + listRuns *connect.Client[workflow.ListRunsRequest, workflow.ListRunsResponse] + watchRuns *connect.Client[workflow.WatchRunsRequest, workflow.WatchRunsResponse] + listActions *connect.Client[workflow.ListActionsRequest, workflow.ListActionsResponse] + watchActions *connect.Client[workflow.WatchActionsRequest, workflow.WatchActionsResponse] + watchClusterEvents *connect.Client[workflow.WatchClusterEventsRequest, workflow.WatchClusterEventsResponse] + abortAction *connect.Client[workflow.AbortActionRequest, workflow.AbortActionResponse] + watchGroups *connect.Client[workflow.WatchGroupsRequest, workflow.WatchGroupsResponse] +} + +// CreateRun calls flyteidl2.workflow.RunService.CreateRun. +func (c *runServiceClient) CreateRun(ctx context.Context, req *connect.Request[workflow.CreateRunRequest]) (*connect.Response[workflow.CreateRunResponse], error) { + return c.createRun.CallUnary(ctx, req) +} + +// AbortRun calls flyteidl2.workflow.RunService.AbortRun. +func (c *runServiceClient) AbortRun(ctx context.Context, req *connect.Request[workflow.AbortRunRequest]) (*connect.Response[workflow.AbortRunResponse], error) { + return c.abortRun.CallUnary(ctx, req) +} + +// GetRunDetails calls flyteidl2.workflow.RunService.GetRunDetails. +func (c *runServiceClient) GetRunDetails(ctx context.Context, req *connect.Request[workflow.GetRunDetailsRequest]) (*connect.Response[workflow.GetRunDetailsResponse], error) { + return c.getRunDetails.CallUnary(ctx, req) +} + +// WatchRunDetails calls flyteidl2.workflow.RunService.WatchRunDetails. +func (c *runServiceClient) WatchRunDetails(ctx context.Context, req *connect.Request[workflow.WatchRunDetailsRequest]) (*connect.ServerStreamForClient[workflow.WatchRunDetailsResponse], error) { + return c.watchRunDetails.CallServerStream(ctx, req) +} + +// GetActionDetails calls flyteidl2.workflow.RunService.GetActionDetails. +func (c *runServiceClient) GetActionDetails(ctx context.Context, req *connect.Request[workflow.GetActionDetailsRequest]) (*connect.Response[workflow.GetActionDetailsResponse], error) { + return c.getActionDetails.CallUnary(ctx, req) +} + +// WatchActionDetails calls flyteidl2.workflow.RunService.WatchActionDetails. +func (c *runServiceClient) WatchActionDetails(ctx context.Context, req *connect.Request[workflow.WatchActionDetailsRequest]) (*connect.ServerStreamForClient[workflow.WatchActionDetailsResponse], error) { + return c.watchActionDetails.CallServerStream(ctx, req) +} + +// GetActionData calls flyteidl2.workflow.RunService.GetActionData. +func (c *runServiceClient) GetActionData(ctx context.Context, req *connect.Request[workflow.GetActionDataRequest]) (*connect.Response[workflow.GetActionDataResponse], error) { + return c.getActionData.CallUnary(ctx, req) +} + +// ListRuns calls flyteidl2.workflow.RunService.ListRuns. +func (c *runServiceClient) ListRuns(ctx context.Context, req *connect.Request[workflow.ListRunsRequest]) (*connect.Response[workflow.ListRunsResponse], error) { + return c.listRuns.CallUnary(ctx, req) +} + +// WatchRuns calls flyteidl2.workflow.RunService.WatchRuns. +func (c *runServiceClient) WatchRuns(ctx context.Context, req *connect.Request[workflow.WatchRunsRequest]) (*connect.ServerStreamForClient[workflow.WatchRunsResponse], error) { + return c.watchRuns.CallServerStream(ctx, req) +} + +// ListActions calls flyteidl2.workflow.RunService.ListActions. +func (c *runServiceClient) ListActions(ctx context.Context, req *connect.Request[workflow.ListActionsRequest]) (*connect.Response[workflow.ListActionsResponse], error) { + return c.listActions.CallUnary(ctx, req) +} + +// WatchActions calls flyteidl2.workflow.RunService.WatchActions. +func (c *runServiceClient) WatchActions(ctx context.Context, req *connect.Request[workflow.WatchActionsRequest]) (*connect.ServerStreamForClient[workflow.WatchActionsResponse], error) { + return c.watchActions.CallServerStream(ctx, req) +} + +// WatchClusterEvents calls flyteidl2.workflow.RunService.WatchClusterEvents. +func (c *runServiceClient) WatchClusterEvents(ctx context.Context, req *connect.Request[workflow.WatchClusterEventsRequest]) (*connect.ServerStreamForClient[workflow.WatchClusterEventsResponse], error) { + return c.watchClusterEvents.CallServerStream(ctx, req) +} + +// AbortAction calls flyteidl2.workflow.RunService.AbortAction. +func (c *runServiceClient) AbortAction(ctx context.Context, req *connect.Request[workflow.AbortActionRequest]) (*connect.Response[workflow.AbortActionResponse], error) { + return c.abortAction.CallUnary(ctx, req) +} + +// WatchGroups calls flyteidl2.workflow.RunService.WatchGroups. +func (c *runServiceClient) WatchGroups(ctx context.Context, req *connect.Request[workflow.WatchGroupsRequest]) (*connect.ServerStreamForClient[workflow.WatchGroupsResponse], error) { + return c.watchGroups.CallServerStream(ctx, req) +} + +// RunServiceHandler is an implementation of the flyteidl2.workflow.RunService service. +type RunServiceHandler interface { + // Create a new run of the given task. + CreateRun(context.Context, *connect.Request[workflow.CreateRunRequest]) (*connect.Response[workflow.CreateRunResponse], error) + // Abort a run. + AbortRun(context.Context, *connect.Request[workflow.AbortRunRequest]) (*connect.Response[workflow.AbortRunResponse], error) + // Get detailed information about a run. + GetRunDetails(context.Context, *connect.Request[workflow.GetRunDetailsRequest]) (*connect.Response[workflow.GetRunDetailsResponse], error) + // Stream detailed information updates about a run. The call will terminate when the run reaches a terminal phase. + WatchRunDetails(context.Context, *connect.Request[workflow.WatchRunDetailsRequest], *connect.ServerStream[workflow.WatchRunDetailsResponse]) error + // Get detailed information about an action. + GetActionDetails(context.Context, *connect.Request[workflow.GetActionDetailsRequest]) (*connect.Response[workflow.GetActionDetailsResponse], error) + // Stream detailed information updates about an action. The call will terminate when the action reaches a terminal phase. + WatchActionDetails(context.Context, *connect.Request[workflow.WatchActionDetailsRequest], *connect.ServerStream[workflow.WatchActionDetailsResponse]) error + // Get input and output for an action. + GetActionData(context.Context, *connect.Request[workflow.GetActionDataRequest]) (*connect.Response[workflow.GetActionDataResponse], error) + // List runs based on the provided filter criteria. + ListRuns(context.Context, *connect.Request[workflow.ListRunsRequest]) (*connect.Response[workflow.ListRunsResponse], error) + // Stream updates for runs based on the provided filter criteria. Responses may include newly discovered + // runs or updates to existing ones from the point of invocation. + WatchRuns(context.Context, *connect.Request[workflow.WatchRunsRequest], *connect.ServerStream[workflow.WatchRunsResponse]) error + // List all actions for a given run. + ListActions(context.Context, *connect.Request[workflow.ListActionsRequest]) (*connect.Response[workflow.ListActionsResponse], error) + // Stream updates for actions given a run. Responses may include newly discovered nested runs or updates + // to existing ones from the point of invocation. + WatchActions(context.Context, *connect.Request[workflow.WatchActionsRequest], *connect.ServerStream[workflow.WatchActionsResponse]) error + // Stream of k8s cluster events in human readable form + WatchClusterEvents(context.Context, *connect.Request[workflow.WatchClusterEventsRequest], *connect.ServerStream[workflow.WatchClusterEventsResponse]) error + // AbortAction aborts a single action that was previously created or is currently being processed by a worker. + AbortAction(context.Context, *connect.Request[workflow.AbortActionRequest]) (*connect.Response[workflow.AbortActionResponse], error) + // Stream updates for task groups based on the provided filter criteria. + WatchGroups(context.Context, *connect.Request[workflow.WatchGroupsRequest], *connect.ServerStream[workflow.WatchGroupsResponse]) error +} + +// NewRunServiceHandler builds an HTTP handler from the service implementation. It returns the path +// on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewRunServiceHandler(svc RunServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + runServiceCreateRunHandler := connect.NewUnaryHandler( + RunServiceCreateRunProcedure, + svc.CreateRun, + connect.WithSchema(runServiceCreateRunMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + runServiceAbortRunHandler := connect.NewUnaryHandler( + RunServiceAbortRunProcedure, + svc.AbortRun, + connect.WithSchema(runServiceAbortRunMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + runServiceGetRunDetailsHandler := connect.NewUnaryHandler( + RunServiceGetRunDetailsProcedure, + svc.GetRunDetails, + connect.WithSchema(runServiceGetRunDetailsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + runServiceWatchRunDetailsHandler := connect.NewServerStreamHandler( + RunServiceWatchRunDetailsProcedure, + svc.WatchRunDetails, + connect.WithSchema(runServiceWatchRunDetailsMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + runServiceGetActionDetailsHandler := connect.NewUnaryHandler( + RunServiceGetActionDetailsProcedure, + svc.GetActionDetails, + connect.WithSchema(runServiceGetActionDetailsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + runServiceWatchActionDetailsHandler := connect.NewServerStreamHandler( + RunServiceWatchActionDetailsProcedure, + svc.WatchActionDetails, + connect.WithSchema(runServiceWatchActionDetailsMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + runServiceGetActionDataHandler := connect.NewUnaryHandler( + RunServiceGetActionDataProcedure, + svc.GetActionData, + connect.WithSchema(runServiceGetActionDataMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + runServiceListRunsHandler := connect.NewUnaryHandler( + RunServiceListRunsProcedure, + svc.ListRuns, + connect.WithSchema(runServiceListRunsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + runServiceWatchRunsHandler := connect.NewServerStreamHandler( + RunServiceWatchRunsProcedure, + svc.WatchRuns, + connect.WithSchema(runServiceWatchRunsMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + runServiceListActionsHandler := connect.NewUnaryHandler( + RunServiceListActionsProcedure, + svc.ListActions, + connect.WithSchema(runServiceListActionsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + runServiceWatchActionsHandler := connect.NewServerStreamHandler( + RunServiceWatchActionsProcedure, + svc.WatchActions, + connect.WithSchema(runServiceWatchActionsMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + runServiceWatchClusterEventsHandler := connect.NewServerStreamHandler( + RunServiceWatchClusterEventsProcedure, + svc.WatchClusterEvents, + connect.WithSchema(runServiceWatchClusterEventsMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + runServiceAbortActionHandler := connect.NewUnaryHandler( + RunServiceAbortActionProcedure, + svc.AbortAction, + connect.WithSchema(runServiceAbortActionMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + runServiceWatchGroupsHandler := connect.NewServerStreamHandler( + RunServiceWatchGroupsProcedure, + svc.WatchGroups, + connect.WithSchema(runServiceWatchGroupsMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.workflow.RunService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case RunServiceCreateRunProcedure: + runServiceCreateRunHandler.ServeHTTP(w, r) + case RunServiceAbortRunProcedure: + runServiceAbortRunHandler.ServeHTTP(w, r) + case RunServiceGetRunDetailsProcedure: + runServiceGetRunDetailsHandler.ServeHTTP(w, r) + case RunServiceWatchRunDetailsProcedure: + runServiceWatchRunDetailsHandler.ServeHTTP(w, r) + case RunServiceGetActionDetailsProcedure: + runServiceGetActionDetailsHandler.ServeHTTP(w, r) + case RunServiceWatchActionDetailsProcedure: + runServiceWatchActionDetailsHandler.ServeHTTP(w, r) + case RunServiceGetActionDataProcedure: + runServiceGetActionDataHandler.ServeHTTP(w, r) + case RunServiceListRunsProcedure: + runServiceListRunsHandler.ServeHTTP(w, r) + case RunServiceWatchRunsProcedure: + runServiceWatchRunsHandler.ServeHTTP(w, r) + case RunServiceListActionsProcedure: + runServiceListActionsHandler.ServeHTTP(w, r) + case RunServiceWatchActionsProcedure: + runServiceWatchActionsHandler.ServeHTTP(w, r) + case RunServiceWatchClusterEventsProcedure: + runServiceWatchClusterEventsHandler.ServeHTTP(w, r) + case RunServiceAbortActionProcedure: + runServiceAbortActionHandler.ServeHTTP(w, r) + case RunServiceWatchGroupsProcedure: + runServiceWatchGroupsHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedRunServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedRunServiceHandler struct{} + +func (UnimplementedRunServiceHandler) CreateRun(context.Context, *connect.Request[workflow.CreateRunRequest]) (*connect.Response[workflow.CreateRunResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.RunService.CreateRun is not implemented")) +} + +func (UnimplementedRunServiceHandler) AbortRun(context.Context, *connect.Request[workflow.AbortRunRequest]) (*connect.Response[workflow.AbortRunResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.RunService.AbortRun is not implemented")) +} + +func (UnimplementedRunServiceHandler) GetRunDetails(context.Context, *connect.Request[workflow.GetRunDetailsRequest]) (*connect.Response[workflow.GetRunDetailsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.RunService.GetRunDetails is not implemented")) +} + +func (UnimplementedRunServiceHandler) WatchRunDetails(context.Context, *connect.Request[workflow.WatchRunDetailsRequest], *connect.ServerStream[workflow.WatchRunDetailsResponse]) error { + return connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.RunService.WatchRunDetails is not implemented")) +} + +func (UnimplementedRunServiceHandler) GetActionDetails(context.Context, *connect.Request[workflow.GetActionDetailsRequest]) (*connect.Response[workflow.GetActionDetailsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.RunService.GetActionDetails is not implemented")) +} + +func (UnimplementedRunServiceHandler) WatchActionDetails(context.Context, *connect.Request[workflow.WatchActionDetailsRequest], *connect.ServerStream[workflow.WatchActionDetailsResponse]) error { + return connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.RunService.WatchActionDetails is not implemented")) +} + +func (UnimplementedRunServiceHandler) GetActionData(context.Context, *connect.Request[workflow.GetActionDataRequest]) (*connect.Response[workflow.GetActionDataResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.RunService.GetActionData is not implemented")) +} + +func (UnimplementedRunServiceHandler) ListRuns(context.Context, *connect.Request[workflow.ListRunsRequest]) (*connect.Response[workflow.ListRunsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.RunService.ListRuns is not implemented")) +} + +func (UnimplementedRunServiceHandler) WatchRuns(context.Context, *connect.Request[workflow.WatchRunsRequest], *connect.ServerStream[workflow.WatchRunsResponse]) error { + return connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.RunService.WatchRuns is not implemented")) +} + +func (UnimplementedRunServiceHandler) ListActions(context.Context, *connect.Request[workflow.ListActionsRequest]) (*connect.Response[workflow.ListActionsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.RunService.ListActions is not implemented")) +} + +func (UnimplementedRunServiceHandler) WatchActions(context.Context, *connect.Request[workflow.WatchActionsRequest], *connect.ServerStream[workflow.WatchActionsResponse]) error { + return connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.RunService.WatchActions is not implemented")) +} + +func (UnimplementedRunServiceHandler) WatchClusterEvents(context.Context, *connect.Request[workflow.WatchClusterEventsRequest], *connect.ServerStream[workflow.WatchClusterEventsResponse]) error { + return connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.RunService.WatchClusterEvents is not implemented")) +} + +func (UnimplementedRunServiceHandler) AbortAction(context.Context, *connect.Request[workflow.AbortActionRequest]) (*connect.Response[workflow.AbortActionResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.RunService.AbortAction is not implemented")) +} + +func (UnimplementedRunServiceHandler) WatchGroups(context.Context, *connect.Request[workflow.WatchGroupsRequest], *connect.ServerStream[workflow.WatchGroupsResponse]) error { + return connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.RunService.WatchGroups is not implemented")) +} diff --git a/gen/go/flyteidl2/workflow/workflowconnect/state_service.connect.go b/gen/go/flyteidl2/workflow/workflowconnect/state_service.connect.go new file mode 100644 index 0000000000..38e3f76b25 --- /dev/null +++ b/gen/go/flyteidl2/workflow/workflowconnect/state_service.connect.go @@ -0,0 +1,176 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: flyteidl2/workflow/state_service.proto + +package workflowconnect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // StateServiceName is the fully-qualified name of the StateService service. + StateServiceName = "flyteidl2.workflow.StateService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // StateServicePutProcedure is the fully-qualified name of the StateService's Put RPC. + StateServicePutProcedure = "/flyteidl2.workflow.StateService/Put" + // StateServiceGetProcedure is the fully-qualified name of the StateService's Get RPC. + StateServiceGetProcedure = "/flyteidl2.workflow.StateService/Get" + // StateServiceWatchProcedure is the fully-qualified name of the StateService's Watch RPC. + StateServiceWatchProcedure = "/flyteidl2.workflow.StateService/Watch" +) + +// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. +var ( + stateServiceServiceDescriptor = workflow.File_flyteidl2_workflow_state_service_proto.Services().ByName("StateService") + stateServicePutMethodDescriptor = stateServiceServiceDescriptor.Methods().ByName("Put") + stateServiceGetMethodDescriptor = stateServiceServiceDescriptor.Methods().ByName("Get") + stateServiceWatchMethodDescriptor = stateServiceServiceDescriptor.Methods().ByName("Watch") +) + +// StateServiceClient is a client for the flyteidl2.workflow.StateService service. +type StateServiceClient interface { + // put the state of an action. + Put(context.Context, *connect.Request[workflow.PutRequest]) (*connect.Response[workflow.PutResponse], error) + // get the state of an action. + Get(context.Context, *connect.Request[workflow.GetRequest]) (*connect.Response[workflow.GetResponse], error) + // watch for updates to the state of actions. this api guarantees at-least-once delivery semantics. + Watch(context.Context, *connect.Request[workflow.WatchRequest]) (*connect.ServerStreamForClient[workflow.WatchResponse], error) +} + +// NewStateServiceClient constructs a client for the flyteidl2.workflow.StateService service. By +// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, +// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the +// connect.WithGRPC() or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewStateServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) StateServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &stateServiceClient{ + put: connect.NewClient[workflow.PutRequest, workflow.PutResponse]( + httpClient, + baseURL+StateServicePutProcedure, + connect.WithSchema(stateServicePutMethodDescriptor), + connect.WithClientOptions(opts...), + ), + get: connect.NewClient[workflow.GetRequest, workflow.GetResponse]( + httpClient, + baseURL+StateServiceGetProcedure, + connect.WithSchema(stateServiceGetMethodDescriptor), + connect.WithClientOptions(opts...), + ), + watch: connect.NewClient[workflow.WatchRequest, workflow.WatchResponse]( + httpClient, + baseURL+StateServiceWatchProcedure, + connect.WithSchema(stateServiceWatchMethodDescriptor), + connect.WithClientOptions(opts...), + ), + } +} + +// stateServiceClient implements StateServiceClient. +type stateServiceClient struct { + put *connect.Client[workflow.PutRequest, workflow.PutResponse] + get *connect.Client[workflow.GetRequest, workflow.GetResponse] + watch *connect.Client[workflow.WatchRequest, workflow.WatchResponse] +} + +// Put calls flyteidl2.workflow.StateService.Put. +func (c *stateServiceClient) Put(ctx context.Context, req *connect.Request[workflow.PutRequest]) (*connect.Response[workflow.PutResponse], error) { + return c.put.CallUnary(ctx, req) +} + +// Get calls flyteidl2.workflow.StateService.Get. +func (c *stateServiceClient) Get(ctx context.Context, req *connect.Request[workflow.GetRequest]) (*connect.Response[workflow.GetResponse], error) { + return c.get.CallUnary(ctx, req) +} + +// Watch calls flyteidl2.workflow.StateService.Watch. +func (c *stateServiceClient) Watch(ctx context.Context, req *connect.Request[workflow.WatchRequest]) (*connect.ServerStreamForClient[workflow.WatchResponse], error) { + return c.watch.CallServerStream(ctx, req) +} + +// StateServiceHandler is an implementation of the flyteidl2.workflow.StateService service. +type StateServiceHandler interface { + // put the state of an action. + Put(context.Context, *connect.Request[workflow.PutRequest]) (*connect.Response[workflow.PutResponse], error) + // get the state of an action. + Get(context.Context, *connect.Request[workflow.GetRequest]) (*connect.Response[workflow.GetResponse], error) + // watch for updates to the state of actions. this api guarantees at-least-once delivery semantics. + Watch(context.Context, *connect.Request[workflow.WatchRequest], *connect.ServerStream[workflow.WatchResponse]) error +} + +// NewStateServiceHandler builds an HTTP handler from the service implementation. It returns the +// path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewStateServiceHandler(svc StateServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + stateServicePutHandler := connect.NewUnaryHandler( + StateServicePutProcedure, + svc.Put, + connect.WithSchema(stateServicePutMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + stateServiceGetHandler := connect.NewUnaryHandler( + StateServiceGetProcedure, + svc.Get, + connect.WithSchema(stateServiceGetMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + stateServiceWatchHandler := connect.NewServerStreamHandler( + StateServiceWatchProcedure, + svc.Watch, + connect.WithSchema(stateServiceWatchMethodDescriptor), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.workflow.StateService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case StateServicePutProcedure: + stateServicePutHandler.ServeHTTP(w, r) + case StateServiceGetProcedure: + stateServiceGetHandler.ServeHTTP(w, r) + case StateServiceWatchProcedure: + stateServiceWatchHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedStateServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedStateServiceHandler struct{} + +func (UnimplementedStateServiceHandler) Put(context.Context, *connect.Request[workflow.PutRequest]) (*connect.Response[workflow.PutResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.StateService.Put is not implemented")) +} + +func (UnimplementedStateServiceHandler) Get(context.Context, *connect.Request[workflow.GetRequest]) (*connect.Response[workflow.GetResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.StateService.Get is not implemented")) +} + +func (UnimplementedStateServiceHandler) Watch(context.Context, *connect.Request[workflow.WatchRequest], *connect.ServerStream[workflow.WatchResponse]) error { + return connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.StateService.Watch is not implemented")) +} diff --git a/gen/go/flyteidl2/workflow/workflowconnect/translator_service.connect.go b/gen/go/flyteidl2/workflow/workflowconnect/translator_service.connect.go new file mode 100644 index 0000000000..cd0e2c93db --- /dev/null +++ b/gen/go/flyteidl2/workflow/workflowconnect/translator_service.connect.go @@ -0,0 +1,212 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: flyteidl2/workflow/translator_service.proto + +package workflowconnect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // TranslatorServiceName is the fully-qualified name of the TranslatorService service. + TranslatorServiceName = "flyteidl2.workflow.TranslatorService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // TranslatorServiceLiteralsToLaunchFormJsonProcedure is the fully-qualified name of the + // TranslatorService's LiteralsToLaunchFormJson RPC. + TranslatorServiceLiteralsToLaunchFormJsonProcedure = "/flyteidl2.workflow.TranslatorService/LiteralsToLaunchFormJson" + // TranslatorServiceLaunchFormJsonToLiteralsProcedure is the fully-qualified name of the + // TranslatorService's LaunchFormJsonToLiterals RPC. + TranslatorServiceLaunchFormJsonToLiteralsProcedure = "/flyteidl2.workflow.TranslatorService/LaunchFormJsonToLiterals" + // TranslatorServiceTaskSpecToLaunchFormJsonProcedure is the fully-qualified name of the + // TranslatorService's TaskSpecToLaunchFormJson RPC. + TranslatorServiceTaskSpecToLaunchFormJsonProcedure = "/flyteidl2.workflow.TranslatorService/TaskSpecToLaunchFormJson" + // TranslatorServiceJsonValuesToLiteralsProcedure is the fully-qualified name of the + // TranslatorService's JsonValuesToLiterals RPC. + TranslatorServiceJsonValuesToLiteralsProcedure = "/flyteidl2.workflow.TranslatorService/JsonValuesToLiterals" +) + +// These variables are the protoreflect.Descriptor objects for the RPCs defined in this package. +var ( + translatorServiceServiceDescriptor = workflow.File_flyteidl2_workflow_translator_service_proto.Services().ByName("TranslatorService") + translatorServiceLiteralsToLaunchFormJsonMethodDescriptor = translatorServiceServiceDescriptor.Methods().ByName("LiteralsToLaunchFormJson") + translatorServiceLaunchFormJsonToLiteralsMethodDescriptor = translatorServiceServiceDescriptor.Methods().ByName("LaunchFormJsonToLiterals") + translatorServiceTaskSpecToLaunchFormJsonMethodDescriptor = translatorServiceServiceDescriptor.Methods().ByName("TaskSpecToLaunchFormJson") + translatorServiceJsonValuesToLiteralsMethodDescriptor = translatorServiceServiceDescriptor.Methods().ByName("JsonValuesToLiterals") +) + +// TranslatorServiceClient is a client for the flyteidl2.workflow.TranslatorService service. +type TranslatorServiceClient interface { + LiteralsToLaunchFormJson(context.Context, *connect.Request[workflow.LiteralsToLaunchFormJsonRequest]) (*connect.Response[workflow.LiteralsToLaunchFormJsonResponse], error) + LaunchFormJsonToLiterals(context.Context, *connect.Request[workflow.LaunchFormJsonToLiteralsRequest]) (*connect.Response[workflow.LaunchFormJsonToLiteralsResponse], error) + TaskSpecToLaunchFormJson(context.Context, *connect.Request[workflow.TaskSpecToLaunchFormJsonRequest]) (*connect.Response[workflow.TaskSpecToLaunchFormJsonResponse], error) + JsonValuesToLiterals(context.Context, *connect.Request[workflow.JsonValuesToLiteralsRequest]) (*connect.Response[workflow.JsonValuesToLiteralsResponse], error) +} + +// NewTranslatorServiceClient constructs a client for the flyteidl2.workflow.TranslatorService +// service. By default, it uses the Connect protocol with the binary Protobuf Codec, asks for +// gzipped responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply +// the connect.WithGRPC() or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewTranslatorServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) TranslatorServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + return &translatorServiceClient{ + literalsToLaunchFormJson: connect.NewClient[workflow.LiteralsToLaunchFormJsonRequest, workflow.LiteralsToLaunchFormJsonResponse]( + httpClient, + baseURL+TranslatorServiceLiteralsToLaunchFormJsonProcedure, + connect.WithSchema(translatorServiceLiteralsToLaunchFormJsonMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + launchFormJsonToLiterals: connect.NewClient[workflow.LaunchFormJsonToLiteralsRequest, workflow.LaunchFormJsonToLiteralsResponse]( + httpClient, + baseURL+TranslatorServiceLaunchFormJsonToLiteralsProcedure, + connect.WithSchema(translatorServiceLaunchFormJsonToLiteralsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + taskSpecToLaunchFormJson: connect.NewClient[workflow.TaskSpecToLaunchFormJsonRequest, workflow.TaskSpecToLaunchFormJsonResponse]( + httpClient, + baseURL+TranslatorServiceTaskSpecToLaunchFormJsonProcedure, + connect.WithSchema(translatorServiceTaskSpecToLaunchFormJsonMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + jsonValuesToLiterals: connect.NewClient[workflow.JsonValuesToLiteralsRequest, workflow.JsonValuesToLiteralsResponse]( + httpClient, + baseURL+TranslatorServiceJsonValuesToLiteralsProcedure, + connect.WithSchema(translatorServiceJsonValuesToLiteralsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithClientOptions(opts...), + ), + } +} + +// translatorServiceClient implements TranslatorServiceClient. +type translatorServiceClient struct { + literalsToLaunchFormJson *connect.Client[workflow.LiteralsToLaunchFormJsonRequest, workflow.LiteralsToLaunchFormJsonResponse] + launchFormJsonToLiterals *connect.Client[workflow.LaunchFormJsonToLiteralsRequest, workflow.LaunchFormJsonToLiteralsResponse] + taskSpecToLaunchFormJson *connect.Client[workflow.TaskSpecToLaunchFormJsonRequest, workflow.TaskSpecToLaunchFormJsonResponse] + jsonValuesToLiterals *connect.Client[workflow.JsonValuesToLiteralsRequest, workflow.JsonValuesToLiteralsResponse] +} + +// LiteralsToLaunchFormJson calls flyteidl2.workflow.TranslatorService.LiteralsToLaunchFormJson. +func (c *translatorServiceClient) LiteralsToLaunchFormJson(ctx context.Context, req *connect.Request[workflow.LiteralsToLaunchFormJsonRequest]) (*connect.Response[workflow.LiteralsToLaunchFormJsonResponse], error) { + return c.literalsToLaunchFormJson.CallUnary(ctx, req) +} + +// LaunchFormJsonToLiterals calls flyteidl2.workflow.TranslatorService.LaunchFormJsonToLiterals. +func (c *translatorServiceClient) LaunchFormJsonToLiterals(ctx context.Context, req *connect.Request[workflow.LaunchFormJsonToLiteralsRequest]) (*connect.Response[workflow.LaunchFormJsonToLiteralsResponse], error) { + return c.launchFormJsonToLiterals.CallUnary(ctx, req) +} + +// TaskSpecToLaunchFormJson calls flyteidl2.workflow.TranslatorService.TaskSpecToLaunchFormJson. +func (c *translatorServiceClient) TaskSpecToLaunchFormJson(ctx context.Context, req *connect.Request[workflow.TaskSpecToLaunchFormJsonRequest]) (*connect.Response[workflow.TaskSpecToLaunchFormJsonResponse], error) { + return c.taskSpecToLaunchFormJson.CallUnary(ctx, req) +} + +// JsonValuesToLiterals calls flyteidl2.workflow.TranslatorService.JsonValuesToLiterals. +func (c *translatorServiceClient) JsonValuesToLiterals(ctx context.Context, req *connect.Request[workflow.JsonValuesToLiteralsRequest]) (*connect.Response[workflow.JsonValuesToLiteralsResponse], error) { + return c.jsonValuesToLiterals.CallUnary(ctx, req) +} + +// TranslatorServiceHandler is an implementation of the flyteidl2.workflow.TranslatorService +// service. +type TranslatorServiceHandler interface { + LiteralsToLaunchFormJson(context.Context, *connect.Request[workflow.LiteralsToLaunchFormJsonRequest]) (*connect.Response[workflow.LiteralsToLaunchFormJsonResponse], error) + LaunchFormJsonToLiterals(context.Context, *connect.Request[workflow.LaunchFormJsonToLiteralsRequest]) (*connect.Response[workflow.LaunchFormJsonToLiteralsResponse], error) + TaskSpecToLaunchFormJson(context.Context, *connect.Request[workflow.TaskSpecToLaunchFormJsonRequest]) (*connect.Response[workflow.TaskSpecToLaunchFormJsonResponse], error) + JsonValuesToLiterals(context.Context, *connect.Request[workflow.JsonValuesToLiteralsRequest]) (*connect.Response[workflow.JsonValuesToLiteralsResponse], error) +} + +// NewTranslatorServiceHandler builds an HTTP handler from the service implementation. It returns +// the path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewTranslatorServiceHandler(svc TranslatorServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + translatorServiceLiteralsToLaunchFormJsonHandler := connect.NewUnaryHandler( + TranslatorServiceLiteralsToLaunchFormJsonProcedure, + svc.LiteralsToLaunchFormJson, + connect.WithSchema(translatorServiceLiteralsToLaunchFormJsonMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + translatorServiceLaunchFormJsonToLiteralsHandler := connect.NewUnaryHandler( + TranslatorServiceLaunchFormJsonToLiteralsProcedure, + svc.LaunchFormJsonToLiterals, + connect.WithSchema(translatorServiceLaunchFormJsonToLiteralsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + translatorServiceTaskSpecToLaunchFormJsonHandler := connect.NewUnaryHandler( + TranslatorServiceTaskSpecToLaunchFormJsonProcedure, + svc.TaskSpecToLaunchFormJson, + connect.WithSchema(translatorServiceTaskSpecToLaunchFormJsonMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + translatorServiceJsonValuesToLiteralsHandler := connect.NewUnaryHandler( + TranslatorServiceJsonValuesToLiteralsProcedure, + svc.JsonValuesToLiterals, + connect.WithSchema(translatorServiceJsonValuesToLiteralsMethodDescriptor), + connect.WithIdempotency(connect.IdempotencyNoSideEffects), + connect.WithHandlerOptions(opts...), + ) + return "/flyteidl2.workflow.TranslatorService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case TranslatorServiceLiteralsToLaunchFormJsonProcedure: + translatorServiceLiteralsToLaunchFormJsonHandler.ServeHTTP(w, r) + case TranslatorServiceLaunchFormJsonToLiteralsProcedure: + translatorServiceLaunchFormJsonToLiteralsHandler.ServeHTTP(w, r) + case TranslatorServiceTaskSpecToLaunchFormJsonProcedure: + translatorServiceTaskSpecToLaunchFormJsonHandler.ServeHTTP(w, r) + case TranslatorServiceJsonValuesToLiteralsProcedure: + translatorServiceJsonValuesToLiteralsHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedTranslatorServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedTranslatorServiceHandler struct{} + +func (UnimplementedTranslatorServiceHandler) LiteralsToLaunchFormJson(context.Context, *connect.Request[workflow.LiteralsToLaunchFormJsonRequest]) (*connect.Response[workflow.LiteralsToLaunchFormJsonResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.TranslatorService.LiteralsToLaunchFormJson is not implemented")) +} + +func (UnimplementedTranslatorServiceHandler) LaunchFormJsonToLiterals(context.Context, *connect.Request[workflow.LaunchFormJsonToLiteralsRequest]) (*connect.Response[workflow.LaunchFormJsonToLiteralsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.TranslatorService.LaunchFormJsonToLiterals is not implemented")) +} + +func (UnimplementedTranslatorServiceHandler) TaskSpecToLaunchFormJson(context.Context, *connect.Request[workflow.TaskSpecToLaunchFormJsonRequest]) (*connect.Response[workflow.TaskSpecToLaunchFormJsonResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.TranslatorService.TaskSpecToLaunchFormJson is not implemented")) +} + +func (UnimplementedTranslatorServiceHandler) JsonValuesToLiterals(context.Context, *connect.Request[workflow.JsonValuesToLiteralsRequest]) (*connect.Response[workflow.JsonValuesToLiteralsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("flyteidl2.workflow.TranslatorService.JsonValuesToLiterals is not implemented")) +} diff --git a/gen/go/gateway/flyteidl2/app/app_definition.swagger.json b/gen/go/gateway/flyteidl2/app/app_definition.swagger.json new file mode 100644 index 0000000000..63fa8c5ba4 --- /dev/null +++ b/gen/go/gateway/flyteidl2/app/app_definition.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/app/app_definition.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/app/app_logs_payload.swagger.json b/gen/go/gateway/flyteidl2/app/app_logs_payload.swagger.json new file mode 100644 index 0000000000..b96afe2e50 --- /dev/null +++ b/gen/go/gateway/flyteidl2/app/app_logs_payload.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/app/app_logs_payload.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/app/app_logs_service.swagger.json b/gen/go/gateway/flyteidl2/app/app_logs_service.swagger.json new file mode 100644 index 0000000000..6bfc04080e --- /dev/null +++ b/gen/go/gateway/flyteidl2/app/app_logs_service.swagger.json @@ -0,0 +1,55 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/app/app_logs_service.proto", + "version": "version not set" + }, + "tags": [ + { + "name": "AppLogsService" + } + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/app/app_payload.swagger.json b/gen/go/gateway/flyteidl2/app/app_payload.swagger.json new file mode 100644 index 0000000000..f675f42a82 --- /dev/null +++ b/gen/go/gateway/flyteidl2/app/app_payload.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/app/app_payload.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/app/app_service.swagger.json b/gen/go/gateway/flyteidl2/app/app_service.swagger.json new file mode 100644 index 0000000000..d512b6d414 --- /dev/null +++ b/gen/go/gateway/flyteidl2/app/app_service.swagger.json @@ -0,0 +1,55 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/app/app_service.proto", + "version": "version not set" + }, + "tags": [ + { + "name": "AppService" + } + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/app/replica_definition.swagger.json b/gen/go/gateway/flyteidl2/app/replica_definition.swagger.json new file mode 100644 index 0000000000..727b7f088f --- /dev/null +++ b/gen/go/gateway/flyteidl2/app/replica_definition.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/app/replica_definition.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/auth/auth_service.swagger.json b/gen/go/gateway/flyteidl2/auth/auth_service.swagger.json new file mode 100644 index 0000000000..3b3f661939 --- /dev/null +++ b/gen/go/gateway/flyteidl2/auth/auth_service.swagger.json @@ -0,0 +1,55 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/auth/auth_service.proto", + "version": "version not set" + }, + "tags": [ + { + "name": "AuthMetadataService" + } + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/auth/identity.swagger.json b/gen/go/gateway/flyteidl2/auth/identity.swagger.json new file mode 100644 index 0000000000..65e375cea5 --- /dev/null +++ b/gen/go/gateway/flyteidl2/auth/identity.swagger.json @@ -0,0 +1,55 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/auth/identity.proto", + "version": "version not set" + }, + "tags": [ + { + "name": "IdentityService" + } + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/cacheservice/cacheservice.swagger.json b/gen/go/gateway/flyteidl2/cacheservice/cacheservice.swagger.json new file mode 100644 index 0000000000..7a02516eff --- /dev/null +++ b/gen/go/gateway/flyteidl2/cacheservice/cacheservice.swagger.json @@ -0,0 +1,55 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/cacheservice/cacheservice.proto", + "version": "version not set" + }, + "tags": [ + { + "name": "CacheService" + } + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/cacheservice/v2/cacheservice.swagger.json b/gen/go/gateway/flyteidl2/cacheservice/v2/cacheservice.swagger.json new file mode 100644 index 0000000000..1d0e6e99cc --- /dev/null +++ b/gen/go/gateway/flyteidl2/cacheservice/v2/cacheservice.swagger.json @@ -0,0 +1,55 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/cacheservice/v2/cacheservice.proto", + "version": "version not set" + }, + "tags": [ + { + "name": "CacheService" + } + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/common/authorization.swagger.json b/gen/go/gateway/flyteidl2/common/authorization.swagger.json new file mode 100644 index 0000000000..93989b7269 --- /dev/null +++ b/gen/go/gateway/flyteidl2/common/authorization.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/common/authorization.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/common/configuration.swagger.json b/gen/go/gateway/flyteidl2/common/configuration.swagger.json new file mode 100644 index 0000000000..96e49806dc --- /dev/null +++ b/gen/go/gateway/flyteidl2/common/configuration.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/common/configuration.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/common/identifier.swagger.json b/gen/go/gateway/flyteidl2/common/identifier.swagger.json new file mode 100644 index 0000000000..d17d2f2279 --- /dev/null +++ b/gen/go/gateway/flyteidl2/common/identifier.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/common/identifier.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/common/identity.swagger.json b/gen/go/gateway/flyteidl2/common/identity.swagger.json new file mode 100644 index 0000000000..ceeaadb509 --- /dev/null +++ b/gen/go/gateway/flyteidl2/common/identity.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/common/identity.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/common/list.swagger.json b/gen/go/gateway/flyteidl2/common/list.swagger.json new file mode 100644 index 0000000000..370df754ab --- /dev/null +++ b/gen/go/gateway/flyteidl2/common/list.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/common/list.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/common/phase.swagger.json b/gen/go/gateway/flyteidl2/common/phase.swagger.json new file mode 100644 index 0000000000..150b3ec6e2 --- /dev/null +++ b/gen/go/gateway/flyteidl2/common/phase.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/common/phase.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/common/policy.swagger.json b/gen/go/gateway/flyteidl2/common/policy.swagger.json new file mode 100644 index 0000000000..a8c6c3048c --- /dev/null +++ b/gen/go/gateway/flyteidl2/common/policy.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/common/policy.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/common/role.swagger.json b/gen/go/gateway/flyteidl2/common/role.swagger.json new file mode 100644 index 0000000000..99b8434291 --- /dev/null +++ b/gen/go/gateway/flyteidl2/common/role.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/common/role.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/common/runtime_version.swagger.json b/gen/go/gateway/flyteidl2/common/runtime_version.swagger.json new file mode 100644 index 0000000000..5f36fd7029 --- /dev/null +++ b/gen/go/gateway/flyteidl2/common/runtime_version.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/common/runtime_version.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/connector/connector.swagger.json b/gen/go/gateway/flyteidl2/connector/connector.swagger.json new file mode 100644 index 0000000000..a40742825e --- /dev/null +++ b/gen/go/gateway/flyteidl2/connector/connector.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/connector/connector.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/connector/service.pb.gw.go b/gen/go/gateway/flyteidl2/connector/service.pb.gw.go new file mode 100644 index 0000000000..7e8fdc3d8e --- /dev/null +++ b/gen/go/gateway/flyteidl2/connector/service.pb.gw.go @@ -0,0 +1,979 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: flyteidl2/connector/service.proto + +/* +Package connector is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package connector + +import ( + "context" + "io" + "net/http" + + extConnector "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector" + "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" + "github.com/grpc-ecosystem/grpc-gateway/v2/utilities" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" + "google.golang.org/protobuf/proto" +) + +// Suppress "imported and not used" errors +var _ codes.Code +var _ io.Reader +var _ status.Status +var _ = runtime.String +var _ = utilities.NewDoubleArray +var _ = metadata.Join + +func request_AsyncConnectorService_CreateTask_0(ctx context.Context, marshaler runtime.Marshaler, client extConnector.AsyncConnectorServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extConnector.CreateTaskRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.CreateTask(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_AsyncConnectorService_CreateTask_0(ctx context.Context, marshaler runtime.Marshaler, server extConnector.AsyncConnectorServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extConnector.CreateTaskRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.CreateTask(ctx, &protoReq) + return msg, metadata, err + +} + +var ( + filter_AsyncConnectorService_GetTask_0 = &utilities.DoubleArray{Encoding: map[string]int{"task_category": 0, "name": 1, "version": 2, "resource_meta": 3, "resourceMeta": 4}, Base: []int{1, 6, 5, 6, 7, 8, 2, 0, 4, 0, 0, 0, 0, 0}, Check: []int{0, 1, 1, 1, 1, 1, 2, 7, 2, 9, 3, 4, 5, 6}} +) + +func request_AsyncConnectorService_GetTask_0(ctx context.Context, marshaler runtime.Marshaler, client extConnector.AsyncConnectorServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extConnector.GetTaskRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["task_category.name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "task_category.name") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "task_category.name", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "task_category.name", err) + } + + val, ok = pathParams["task_category.version"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "task_category.version") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "task_category.version", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "task_category.version", err) + } + + val, ok = pathParams["resource_meta"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "resource_meta") + } + + protoReq.ResourceMeta, err = runtime.Bytes(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "resource_meta", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_AsyncConnectorService_GetTask_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.GetTask(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_AsyncConnectorService_GetTask_0(ctx context.Context, marshaler runtime.Marshaler, server extConnector.AsyncConnectorServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extConnector.GetTaskRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["task_category.name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "task_category.name") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "task_category.name", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "task_category.name", err) + } + + val, ok = pathParams["task_category.version"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "task_category.version") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "task_category.version", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "task_category.version", err) + } + + val, ok = pathParams["resource_meta"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "resource_meta") + } + + protoReq.ResourceMeta, err = runtime.Bytes(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "resource_meta", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_AsyncConnectorService_GetTask_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.GetTask(ctx, &protoReq) + return msg, metadata, err + +} + +var ( + filter_AsyncConnectorService_DeleteTask_0 = &utilities.DoubleArray{Encoding: map[string]int{"task_category": 0, "name": 1, "version": 2, "resource_meta": 3, "resourceMeta": 4}, Base: []int{1, 6, 5, 6, 7, 8, 2, 0, 4, 0, 0, 0, 0, 0}, Check: []int{0, 1, 1, 1, 1, 1, 2, 7, 2, 9, 3, 4, 5, 6}} +) + +func request_AsyncConnectorService_DeleteTask_0(ctx context.Context, marshaler runtime.Marshaler, client extConnector.AsyncConnectorServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extConnector.DeleteTaskRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["task_category.name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "task_category.name") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "task_category.name", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "task_category.name", err) + } + + val, ok = pathParams["task_category.version"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "task_category.version") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "task_category.version", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "task_category.version", err) + } + + val, ok = pathParams["resource_meta"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "resource_meta") + } + + protoReq.ResourceMeta, err = runtime.Bytes(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "resource_meta", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_AsyncConnectorService_DeleteTask_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.DeleteTask(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_AsyncConnectorService_DeleteTask_0(ctx context.Context, marshaler runtime.Marshaler, server extConnector.AsyncConnectorServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extConnector.DeleteTaskRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["task_category.name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "task_category.name") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "task_category.name", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "task_category.name", err) + } + + val, ok = pathParams["task_category.version"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "task_category.version") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "task_category.version", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "task_category.version", err) + } + + val, ok = pathParams["resource_meta"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "resource_meta") + } + + protoReq.ResourceMeta, err = runtime.Bytes(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "resource_meta", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_AsyncConnectorService_DeleteTask_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.DeleteTask(ctx, &protoReq) + return msg, metadata, err + +} + +var ( + filter_AsyncConnectorService_GetTaskMetrics_0 = &utilities.DoubleArray{Encoding: map[string]int{"task_category": 0, "name": 1, "version": 2, "resource_meta": 3, "resourceMeta": 4}, Base: []int{1, 6, 5, 6, 7, 8, 2, 0, 4, 0, 0, 0, 0, 0}, Check: []int{0, 1, 1, 1, 1, 1, 2, 7, 2, 9, 3, 4, 5, 6}} +) + +func request_AsyncConnectorService_GetTaskMetrics_0(ctx context.Context, marshaler runtime.Marshaler, client extConnector.AsyncConnectorServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extConnector.GetTaskMetricsRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["task_category.name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "task_category.name") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "task_category.name", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "task_category.name", err) + } + + val, ok = pathParams["task_category.version"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "task_category.version") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "task_category.version", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "task_category.version", err) + } + + val, ok = pathParams["resource_meta"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "resource_meta") + } + + protoReq.ResourceMeta, err = runtime.Bytes(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "resource_meta", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_AsyncConnectorService_GetTaskMetrics_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.GetTaskMetrics(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_AsyncConnectorService_GetTaskMetrics_0(ctx context.Context, marshaler runtime.Marshaler, server extConnector.AsyncConnectorServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extConnector.GetTaskMetricsRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["task_category.name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "task_category.name") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "task_category.name", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "task_category.name", err) + } + + val, ok = pathParams["task_category.version"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "task_category.version") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "task_category.version", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "task_category.version", err) + } + + val, ok = pathParams["resource_meta"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "resource_meta") + } + + protoReq.ResourceMeta, err = runtime.Bytes(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "resource_meta", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_AsyncConnectorService_GetTaskMetrics_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.GetTaskMetrics(ctx, &protoReq) + return msg, metadata, err + +} + +var ( + filter_AsyncConnectorService_GetTaskLogs_0 = &utilities.DoubleArray{Encoding: map[string]int{"task_category": 0, "name": 1, "version": 2, "resource_meta": 3, "resourceMeta": 4}, Base: []int{1, 6, 5, 6, 7, 8, 2, 0, 4, 0, 0, 0, 0, 0}, Check: []int{0, 1, 1, 1, 1, 1, 2, 7, 2, 9, 3, 4, 5, 6}} +) + +func request_AsyncConnectorService_GetTaskLogs_0(ctx context.Context, marshaler runtime.Marshaler, client extConnector.AsyncConnectorServiceClient, req *http.Request, pathParams map[string]string) (extConnector.AsyncConnectorService_GetTaskLogsClient, runtime.ServerMetadata, error) { + var protoReq extConnector.GetTaskLogsRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["task_category.name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "task_category.name") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "task_category.name", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "task_category.name", err) + } + + val, ok = pathParams["task_category.version"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "task_category.version") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "task_category.version", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "task_category.version", err) + } + + val, ok = pathParams["resource_meta"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "resource_meta") + } + + protoReq.ResourceMeta, err = runtime.Bytes(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "resource_meta", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_AsyncConnectorService_GetTaskLogs_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + stream, err := client.GetTaskLogs(ctx, &protoReq) + if err != nil { + return nil, metadata, err + } + header, err := stream.Header() + if err != nil { + return nil, metadata, err + } + metadata.HeaderMD = header + return stream, metadata, nil + +} + +func request_ConnectorMetadataService_GetConnector_0(ctx context.Context, marshaler runtime.Marshaler, client extConnector.ConnectorMetadataServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extConnector.GetConnectorRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") + } + + protoReq.Name, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) + } + + msg, err := client.GetConnector(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_ConnectorMetadataService_GetConnector_0(ctx context.Context, marshaler runtime.Marshaler, server extConnector.ConnectorMetadataServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extConnector.GetConnectorRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") + } + + protoReq.Name, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) + } + + msg, err := server.GetConnector(ctx, &protoReq) + return msg, metadata, err + +} + +func request_ConnectorMetadataService_ListConnectors_0(ctx context.Context, marshaler runtime.Marshaler, client extConnector.ConnectorMetadataServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extConnector.ListConnectorsRequest + var metadata runtime.ServerMetadata + + msg, err := client.ListConnectors(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_ConnectorMetadataService_ListConnectors_0(ctx context.Context, marshaler runtime.Marshaler, server extConnector.ConnectorMetadataServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extConnector.ListConnectorsRequest + var metadata runtime.ServerMetadata + + msg, err := server.ListConnectors(ctx, &protoReq) + return msg, metadata, err + +} + +// RegisterAsyncConnectorServiceHandlerServer registers the http handlers for service AsyncConnectorService to "mux". +// UnaryRPC :call AsyncConnectorServiceServer directly. +// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterAsyncConnectorServiceHandlerFromEndpoint instead. +func RegisterAsyncConnectorServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extConnector.AsyncConnectorServiceServer) error { + + mux.Handle("POST", pattern_AsyncConnectorService_CreateTask_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/flyteidl2.connector.AsyncConnectorService/CreateTask", runtime.WithHTTPPathPattern("/api/v1/connector/task")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_AsyncConnectorService_CreateTask_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_AsyncConnectorService_CreateTask_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_AsyncConnectorService_GetTask_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/flyteidl2.connector.AsyncConnectorService/GetTask", runtime.WithHTTPPathPattern("/api/v1/connector/task/{task_category.name}/{task_category.version}/{resource_meta}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_AsyncConnectorService_GetTask_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_AsyncConnectorService_GetTask_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("DELETE", pattern_AsyncConnectorService_DeleteTask_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/flyteidl2.connector.AsyncConnectorService/DeleteTask", runtime.WithHTTPPathPattern("/api/v1/connector/task_executions/{task_category.name}/{task_category.version}/{resource_meta}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_AsyncConnectorService_DeleteTask_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_AsyncConnectorService_DeleteTask_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_AsyncConnectorService_GetTaskMetrics_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/flyteidl2.connector.AsyncConnectorService/GetTaskMetrics", runtime.WithHTTPPathPattern("/api/v1/connector/task/metrics/{task_category.name}/{task_category.version}/{resource_meta}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_AsyncConnectorService_GetTaskMetrics_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_AsyncConnectorService_GetTaskMetrics_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_AsyncConnectorService_GetTaskLogs_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport") + _, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + }) + + return nil +} + +// RegisterConnectorMetadataServiceHandlerServer registers the http handlers for service ConnectorMetadataService to "mux". +// UnaryRPC :call ConnectorMetadataServiceServer directly. +// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterConnectorMetadataServiceHandlerFromEndpoint instead. +func RegisterConnectorMetadataServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extConnector.ConnectorMetadataServiceServer) error { + + mux.Handle("GET", pattern_ConnectorMetadataService_GetConnector_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/flyteidl2.connector.ConnectorMetadataService/GetConnector", runtime.WithHTTPPathPattern("/api/v1/connector/{name}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_ConnectorMetadataService_GetConnector_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_ConnectorMetadataService_GetConnector_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_ConnectorMetadataService_ListConnectors_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/flyteidl2.connector.ConnectorMetadataService/ListConnectors", runtime.WithHTTPPathPattern("/api/v1/connectors")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_ConnectorMetadataService_ListConnectors_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_ConnectorMetadataService_ListConnectors_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +// RegisterAsyncConnectorServiceHandlerFromEndpoint is same as RegisterAsyncConnectorServiceHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterAsyncConnectorServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.DialContext(ctx, endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterAsyncConnectorServiceHandler(ctx, mux, conn) +} + +// RegisterAsyncConnectorServiceHandler registers the http handlers for service AsyncConnectorService to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterAsyncConnectorServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterAsyncConnectorServiceHandlerClient(ctx, mux, extConnector.NewAsyncConnectorServiceClient(conn)) +} + +// RegisterAsyncConnectorServiceHandlerClient registers the http handlers for service AsyncConnectorService +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extConnector.AsyncConnectorServiceClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extConnector.AsyncConnectorServiceClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "extConnector.AsyncConnectorServiceClient" to call the correct interceptors. +func RegisterAsyncConnectorServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extConnector.AsyncConnectorServiceClient) error { + + mux.Handle("POST", pattern_AsyncConnectorService_CreateTask_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/flyteidl2.connector.AsyncConnectorService/CreateTask", runtime.WithHTTPPathPattern("/api/v1/connector/task")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_AsyncConnectorService_CreateTask_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_AsyncConnectorService_CreateTask_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_AsyncConnectorService_GetTask_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/flyteidl2.connector.AsyncConnectorService/GetTask", runtime.WithHTTPPathPattern("/api/v1/connector/task/{task_category.name}/{task_category.version}/{resource_meta}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_AsyncConnectorService_GetTask_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_AsyncConnectorService_GetTask_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("DELETE", pattern_AsyncConnectorService_DeleteTask_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/flyteidl2.connector.AsyncConnectorService/DeleteTask", runtime.WithHTTPPathPattern("/api/v1/connector/task_executions/{task_category.name}/{task_category.version}/{resource_meta}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_AsyncConnectorService_DeleteTask_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_AsyncConnectorService_DeleteTask_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_AsyncConnectorService_GetTaskMetrics_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/flyteidl2.connector.AsyncConnectorService/GetTaskMetrics", runtime.WithHTTPPathPattern("/api/v1/connector/task/metrics/{task_category.name}/{task_category.version}/{resource_meta}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_AsyncConnectorService_GetTaskMetrics_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_AsyncConnectorService_GetTaskMetrics_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_AsyncConnectorService_GetTaskLogs_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/flyteidl2.connector.AsyncConnectorService/GetTaskLogs", runtime.WithHTTPPathPattern("/api/v1/connector/task/logs/{task_category.name}/{task_category.version}/{resource_meta}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_AsyncConnectorService_GetTaskLogs_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_AsyncConnectorService_GetTaskLogs_0(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_AsyncConnectorService_CreateTask_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"api", "v1", "connector", "task"}, "")) + + pattern_AsyncConnectorService_GetTask_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5, 1, 0, 4, 1, 5, 6}, []string{"api", "v1", "connector", "task", "task_category.name", "task_category.version", "resource_meta"}, "")) + + pattern_AsyncConnectorService_DeleteTask_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5, 1, 0, 4, 1, 5, 6}, []string{"api", "v1", "connector", "task_executions", "task_category.name", "task_category.version", "resource_meta"}, "")) + + pattern_AsyncConnectorService_GetTaskMetrics_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 1, 0, 4, 1, 5, 6, 1, 0, 4, 1, 5, 7}, []string{"api", "v1", "connector", "task", "metrics", "task_category.name", "task_category.version", "resource_meta"}, "")) + + pattern_AsyncConnectorService_GetTaskLogs_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 1, 0, 4, 1, 5, 6, 1, 0, 4, 1, 5, 7}, []string{"api", "v1", "connector", "task", "logs", "task_category.name", "task_category.version", "resource_meta"}, "")) +) + +var ( + forward_AsyncConnectorService_CreateTask_0 = runtime.ForwardResponseMessage + + forward_AsyncConnectorService_GetTask_0 = runtime.ForwardResponseMessage + + forward_AsyncConnectorService_DeleteTask_0 = runtime.ForwardResponseMessage + + forward_AsyncConnectorService_GetTaskMetrics_0 = runtime.ForwardResponseMessage + + forward_AsyncConnectorService_GetTaskLogs_0 = runtime.ForwardResponseStream +) + +// RegisterConnectorMetadataServiceHandlerFromEndpoint is same as RegisterConnectorMetadataServiceHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterConnectorMetadataServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.DialContext(ctx, endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterConnectorMetadataServiceHandler(ctx, mux, conn) +} + +// RegisterConnectorMetadataServiceHandler registers the http handlers for service ConnectorMetadataService to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterConnectorMetadataServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterConnectorMetadataServiceHandlerClient(ctx, mux, extConnector.NewConnectorMetadataServiceClient(conn)) +} + +// RegisterConnectorMetadataServiceHandlerClient registers the http handlers for service ConnectorMetadataService +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extConnector.ConnectorMetadataServiceClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extConnector.ConnectorMetadataServiceClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "extConnector.ConnectorMetadataServiceClient" to call the correct interceptors. +func RegisterConnectorMetadataServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extConnector.ConnectorMetadataServiceClient) error { + + mux.Handle("GET", pattern_ConnectorMetadataService_GetConnector_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/flyteidl2.connector.ConnectorMetadataService/GetConnector", runtime.WithHTTPPathPattern("/api/v1/connector/{name}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_ConnectorMetadataService_GetConnector_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_ConnectorMetadataService_GetConnector_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_ConnectorMetadataService_ListConnectors_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/flyteidl2.connector.ConnectorMetadataService/ListConnectors", runtime.WithHTTPPathPattern("/api/v1/connectors")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_ConnectorMetadataService_ListConnectors_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_ConnectorMetadataService_ListConnectors_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_ConnectorMetadataService_GetConnector_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"api", "v1", "connector", "name"}, "")) + + pattern_ConnectorMetadataService_ListConnectors_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "v1", "connectors"}, "")) +) + +var ( + forward_ConnectorMetadataService_GetConnector_0 = runtime.ForwardResponseMessage + + forward_ConnectorMetadataService_ListConnectors_0 = runtime.ForwardResponseMessage +) diff --git a/gen/go/gateway/flyteidl2/connector/service.swagger.json b/gen/go/gateway/flyteidl2/connector/service.swagger.json new file mode 100644 index 0000000000..6667c9d93a --- /dev/null +++ b/gen/go/gateway/flyteidl2/connector/service.swagger.json @@ -0,0 +1,2243 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/connector/service.proto", + "version": "version not set" + }, + "tags": [ + { + "name": "AsyncConnectorService" + }, + { + "name": "ConnectorMetadataService" + } + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/api/v1/connector/task": { + "post": { + "summary": "CreateTask sends a task create request to the connector service.", + "operationId": "AsyncConnectorService_CreateTask", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/connectorCreateTaskResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + }, + "parameters": [ + { + "name": "body", + "description": "Represents a request structure to create task.", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/connectorCreateTaskRequest" + } + } + ], + "tags": [ + "AsyncConnectorService" + ] + } + }, + "/api/v1/connector/task/logs/{task_category.name}/{task_category.version}/{resource_meta}": { + "get": { + "summary": "GetTaskLogs returns task execution logs, if available.", + "operationId": "AsyncConnectorService_GetTaskLogs", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/connectorGetTaskLogsResponse" + }, + "error": { + "$ref": "#/definitions/googlerpcStatus" + } + }, + "title": "Stream result of connectorGetTaskLogsResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + }, + "parameters": [ + { + "name": "task_category.name", + "description": "The name of the task type.", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "task_category.version", + "description": "The version of the task type.", + "in": "path", + "required": true, + "type": "integer", + "format": "int32" + }, + { + "name": "resource_meta", + "description": "Metadata is created by the connector. It could be a string (jobId) or a dict (more complex metadata).", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "lines", + "description": "Number of lines to return.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "token", + "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query. If there are no more results, this value will be empty.", + "in": "query", + "required": false, + "type": "string" + } + ], + "tags": [ + "AsyncConnectorService" + ] + } + }, + "/api/v1/connector/task/metrics/{task_category.name}/{task_category.version}/{resource_meta}": { + "get": { + "summary": "GetTaskMetrics returns one or more task execution metrics, if available.", + "description": "Errors include\n * OutOfRange if metrics are not available for the specified task time range\n * various other errors", + "operationId": "AsyncConnectorService_GetTaskMetrics", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/connectorGetTaskMetricsResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + }, + "parameters": [ + { + "name": "task_category.name", + "description": "The name of the task type.", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "task_category.version", + "description": "The version of the task type.", + "in": "path", + "required": true, + "type": "integer", + "format": "int32" + }, + { + "name": "resource_meta", + "description": "Metadata is created by the connector. It could be a string (jobId) or a dict (more complex metadata).", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "queries", + "description": "The metrics to query. If empty, will return a default set of metrics.\ne.g. EXECUTION_METRIC_USED_CPU_AVG or EXECUTION_METRIC_USED_MEMORY_BYTES_AVG", + "in": "query", + "required": false, + "type": "array", + "items": { + "type": "string" + }, + "collectionFormat": "multi" + }, + { + "name": "start_time", + "description": "Start timestamp, inclusive.", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + }, + { + "name": "end_time", + "description": "End timestamp, inclusive..", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + }, + { + "name": "step", + "description": "Query resolution step width in duration format or float number of seconds.", + "in": "query", + "required": false, + "type": "string" + } + ], + "tags": [ + "AsyncConnectorService" + ] + } + }, + "/api/v1/connector/task/{task_category.name}/{task_category.version}/{resource_meta}": { + "get": { + "summary": "Get job status.", + "operationId": "AsyncConnectorService_GetTask", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/connectorGetTaskResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + }, + "parameters": [ + { + "name": "task_category.name", + "description": "The name of the task type.", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "task_category.version", + "description": "The version of the task type.", + "in": "path", + "required": true, + "type": "integer", + "format": "int32" + }, + { + "name": "resource_meta", + "description": "Metadata about the resource to be pass to the connector.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "output_prefix", + "description": "Prefix for where task output data will be written. (e.g. s3://my-bucket/randomstring)", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "connection.task_type", + "description": "The task type that the connection is used for.", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "connection.secrets[string]", + "description": "The credentials to use for the connection, such as API keys, OAuth2 tokens, etc.\nThe key is the name of the secret, and it's defined in the flytekit.\nflytekit uses the key to locate the desired secret within the map.", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "connection.configs[string]", + "description": "The configuration to use for the connection, such as the endpoint, account name, etc.\nThe key is the name of the config, and it's defined in the flytekit.", + "in": "query", + "required": false, + "type": "string" + } + ], + "tags": [ + "AsyncConnectorService" + ] + } + }, + "/api/v1/connector/task_executions/{task_category.name}/{task_category.version}/{resource_meta}": { + "delete": { + "summary": "Delete the task resource.", + "operationId": "AsyncConnectorService_DeleteTask", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/connectorDeleteTaskResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + }, + "parameters": [ + { + "name": "task_category.name", + "description": "The name of the task type.", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "task_category.version", + "description": "The version of the task type.", + "in": "path", + "required": true, + "type": "integer", + "format": "int32" + }, + { + "name": "resource_meta", + "description": "Metadata about the resource to be pass to the connector.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "connection.task_type", + "description": "The task type that the connection is used for.", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "connection.secrets[string][string]", + "description": "The credentials to use for the connection, such as API keys, OAuth2 tokens, etc.\nThe key is the name of the secret, and it's defined in the flytekit.\nflytekit uses the key to locate the desired secret within the map.", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "connection.configs[string][string]", + "description": "The configuration to use for the connection, such as the endpoint, account name, etc.\nThe key is the name of the config, and it's defined in the flytekit.", + "in": "query", + "required": false, + "type": "string" + } + ], + "tags": [ + "AsyncConnectorService" + ] + } + }, + "/api/v1/connector/{name}": { + "get": { + "summary": "Fetch a :ref:`ref_flyteidl2.plugins.Connector` definition.", + "operationId": "ConnectorMetadataService_GetConnector", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/connectorGetConnectorResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + }, + "parameters": [ + { + "name": "name", + "description": "The name of the connector.", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ConnectorMetadataService" + ] + } + }, + "/api/v1/connectors": { + "get": { + "summary": "Fetch a list of :ref:`ref_flyteidl2.plugins.Connector` definitions.", + "operationId": "ConnectorMetadataService_ListConnectors", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/connectorListConnectorsResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + }, + "tags": [ + "ConnectorMetadataService" + ] + } + } + }, + "definitions": { + "BlobTypeBlobDimensionality": { + "type": "string", + "enum": [ + "SINGLE", + "MULTIPART" + ], + "default": "SINGLE" + }, + "ContainerArchitecture": { + "type": "string", + "enum": [ + "UNKNOWN", + "AMD64", + "ARM64", + "ARM_V6", + "ARM_V7" + ], + "default": "UNKNOWN", + "description": "Architecture-type the container image supports." + }, + "DataLoadingConfigLiteralMapFormat": { + "type": "string", + "enum": [ + "JSON", + "YAML", + "PROTO" + ], + "default": "JSON", + "description": "- JSON: JSON / YAML for the metadata (which contains inlined primitive values). The representation is inline with the standard json specification as specified - https://www.json.org/json-en.html\n - PROTO: Proto is a serialized binary of `core.LiteralMap` defined in flyteidl/core", + "title": "LiteralMapFormat decides the encoding format in which the input metadata should be made available to the containers.\nIf the user has access to the protocol buffer definitions, it is recommended to use the PROTO format.\nJSON and YAML do not need any protobuf definitions to read it\nAll remote references in core.LiteralMap are replaced with local filesystem references (the data is downloaded to local filesystem)" + }, + "GPUAcceleratorDeviceClass": { + "type": "string", + "enum": [ + "NVIDIA_GPU", + "GOOGLE_TPU", + "AMAZON_NEURON", + "AMD_GPU", + "HABANA_GAUDI" + ], + "default": "NVIDIA_GPU", + "description": "Specifies the class of accelerator device.\n\n - NVIDIA_GPU: NVIDIA GPU devices (default for backward compatibility)\n - GOOGLE_TPU: Google TPU devices\n - AMAZON_NEURON: Amazon Neuron devices\n - AMD_GPU: AMD GPU devices\n - HABANA_GAUDI: Habana Gaudi devices" + }, + "IOStrategyDownloadMode": { + "type": "string", + "enum": [ + "DOWNLOAD_EAGER", + "DOWNLOAD_STREAM", + "DO_NOT_DOWNLOAD" + ], + "default": "DOWNLOAD_EAGER", + "description": "- DOWNLOAD_EAGER: All data will be downloaded before the main container is executed\n - DOWNLOAD_STREAM: Data will be downloaded as a stream and an End-Of-Stream marker will be written to indicate all data has been downloaded. Refer to protocol for details\n - DO_NOT_DOWNLOAD: Large objects (offloaded) will not be downloaded", + "title": "Mode to use for downloading" + }, + "IOStrategyUploadMode": { + "type": "string", + "enum": [ + "UPLOAD_ON_EXIT", + "UPLOAD_EAGER", + "DO_NOT_UPLOAD" + ], + "default": "UPLOAD_ON_EXIT", + "description": "- UPLOAD_ON_EXIT: All data will be uploaded after the main container exits\n - UPLOAD_EAGER: Data will be uploaded as it appears. Refer to protocol specification for details\n - DO_NOT_UPLOAD: Data will not be uploaded, only references will be written", + "title": "Mode to use for uploading" + }, + "ResourcesResourceEntry": { + "type": "object", + "properties": { + "name": { + "$ref": "#/definitions/ResourcesResourceName", + "description": "Resource name." + }, + "value": { + "type": "string", + "title": "Value must be a valid k8s quantity. See\nhttps://github.com/kubernetes/apimachinery/blob/master/pkg/api/resource/quantity.go#L30-L80" + } + }, + "description": "Encapsulates a resource name and value." + }, + "ResourcesResourceName": { + "type": "string", + "enum": [ + "UNKNOWN", + "CPU", + "GPU", + "MEMORY", + "STORAGE", + "EPHEMERAL_STORAGE" + ], + "default": "UNKNOWN", + "description": "Known resource names.\n\n - EPHEMERAL_STORAGE: For Kubernetes-based deployments, pods use ephemeral local storage for scratch space, caching, and for logs." + }, + "SchemaColumnSchemaColumnType": { + "type": "string", + "enum": [ + "INTEGER", + "FLOAT", + "STRING", + "BOOLEAN", + "DATETIME", + "DURATION" + ], + "default": "INTEGER" + }, + "SchemaTypeSchemaColumn": { + "type": "object", + "properties": { + "name": { + "type": "string", + "title": "A unique name -within the schema type- for the column" + }, + "type": { + "$ref": "#/definitions/SchemaColumnSchemaColumnType", + "description": "The column type. This allows a limited set of types currently." + } + } + }, + "SecretMountType": { + "type": "string", + "enum": [ + "ANY", + "ENV_VAR", + "FILE" + ], + "default": "ANY", + "description": " - ANY: Default case, indicates the client can tolerate either mounting options.\n - ENV_VAR: ENV_VAR indicates the secret needs to be mounted as an environment variable.\n - FILE: FILE indicates the secret needs to be mounted as a file." + }, + "SqlDialect": { + "type": "string", + "enum": [ + "UNDEFINED", + "ANSI", + "HIVE", + "OTHER" + ], + "default": "UNDEFINED", + "description": "The dialect of the SQL statement. This is used to validate and parse SQL statements at compilation time to avoid\nexpensive runtime operations. If set to an unsupported dialect, no validation will be done on the statement.\nWe support the following dialect: ansi, hive." + }, + "StructuredDatasetTypeDatasetColumn": { + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "A unique name within the schema type for the column." + }, + "literal_type": { + "$ref": "#/definitions/coreLiteralType", + "description": "The column type." + } + } + }, + "TaskLogLinkType": { + "type": "string", + "enum": [ + "EXTERNAL", + "DASHBOARD", + "IDE" + ], + "default": "EXTERNAL", + "description": " - EXTERNAL: The link for task log. For example, the aws cloudwatch logs, gcp stackdriver logs, etc.\n - DASHBOARD: The link for spark UI, ray dashboard, etc.\n - IDE: The link for vscode or other IDEs." + }, + "TaskLogMessageFormat": { + "type": "string", + "enum": [ + "UNKNOWN", + "CSV", + "JSON" + ], + "default": "UNKNOWN" + }, + "connectorConnector": { + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "Name is the developer-assigned name of the connector." + }, + "supported_task_categories": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/connectorTaskCategory" + }, + "description": "Supported_task_categories are the categories of the tasks that the connector can handle." + } + }, + "description": "A message containing the connector metadata." + }, + "connectorCreateTaskRequest": { + "type": "object", + "properties": { + "inputs": { + "$ref": "#/definitions/taskInputs", + "title": "The inputs required to start the execution. All required inputs must be\nincluded in this map. If not required and not provided, defaults apply.\n+optional" + }, + "template": { + "$ref": "#/definitions/coreTaskTemplate", + "description": "Template of the task that encapsulates all the metadata of the task." + }, + "output_prefix": { + "type": "string", + "title": "Prefix for where task output data will be written. (e.g. s3://my-bucket/randomstring)" + }, + "task_execution_metadata": { + "$ref": "#/definitions/flyteidl2connectorTaskExecutionMetadata", + "description": "subset of runtime task execution metadata." + }, + "connection": { + "$ref": "#/definitions/coreConnection", + "title": "Connection (secret and config) required by the connector.\nConnector will use the secret and config in the taskTemplate if it's None.\n+optional" + } + }, + "description": "Represents a request structure to create task." + }, + "connectorCreateTaskResponse": { + "type": "object", + "properties": { + "resource_meta": { + "type": "string", + "format": "byte", + "description": "ResourceMeta is created by the connector. It could be a string (jobId) or a dict (more complex metadata)." + } + }, + "description": "Represents a create response structure." + }, + "connectorDeleteTaskResponse": { + "type": "object", + "description": "Response to delete a task." + }, + "connectorGetConnectorResponse": { + "type": "object", + "properties": { + "connector": { + "$ref": "#/definitions/connectorConnector" + } + }, + "description": "A response containing an connector." + }, + "connectorGetTaskLogsResponse": { + "type": "object", + "properties": { + "header": { + "$ref": "#/definitions/connectorGetTaskLogsResponseHeader" + }, + "body": { + "$ref": "#/definitions/connectorGetTaskLogsResponseBody" + } + }, + "description": "A response containing the logs for a task execution." + }, + "connectorGetTaskLogsResponseBody": { + "type": "object", + "properties": { + "results": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The execution log results." + } + } + }, + "connectorGetTaskLogsResponseHeader": { + "type": "object", + "properties": { + "token": { + "type": "string", + "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query. If there are no more results, this value will be empty." + } + } + }, + "connectorGetTaskMetricsResponse": { + "type": "object", + "properties": { + "results": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/coreExecutionMetricResult" + }, + "description": "The execution metric results." + } + }, + "description": "A response containing a list of metrics for a task execution." + }, + "connectorGetTaskResponse": { + "type": "object", + "properties": { + "resource": { + "$ref": "#/definitions/flyteidl2connectorResource" + } + }, + "description": "Response to get an individual task resource." + }, + "connectorListConnectorsResponse": { + "type": "object", + "properties": { + "connectors": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/connectorConnector" + } + } + }, + "description": "A response containing a list of connectors." + }, + "connectorTaskCategory": { + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "The name of the task type." + }, + "version": { + "type": "integer", + "format": "int32", + "description": "The version of the task type." + } + } + }, + "coreArtifactBindingData": { + "type": "object", + "properties": { + "partition_key": { + "type": "string" + }, + "bind_to_time_partition": { + "type": "boolean" + }, + "time_transform": { + "$ref": "#/definitions/coreTimeTransform", + "title": "This is only relevant in the time partition case" + } + }, + "title": "Only valid for triggers" + }, + "coreArtifactID": { + "type": "object", + "properties": { + "artifact_key": { + "$ref": "#/definitions/coreArtifactKey" + }, + "version": { + "type": "string" + }, + "partitions": { + "$ref": "#/definitions/corePartitions", + "description": "Think of a partition as a tag on an Artifact, except it's a key-value pair.\nDifferent partitions naturally have different versions (execution ids)." + }, + "time_partition": { + "$ref": "#/definitions/coreTimePartition", + "description": "There is no such thing as an empty time partition - if it's not set, then there is no time partition." + } + } + }, + "coreArtifactKey": { + "type": "object", + "properties": { + "project": { + "type": "string", + "description": "Project and domain and suffix needs to be unique across a given artifact store." + }, + "domain": { + "type": "string" + }, + "name": { + "type": "string" + }, + "org": { + "type": "string" + } + } + }, + "coreArtifactTag": { + "type": "object", + "properties": { + "artifact_key": { + "$ref": "#/definitions/coreArtifactKey" + }, + "value": { + "$ref": "#/definitions/coreLabelValue" + } + } + }, + "coreBinary": { + "type": "object", + "properties": { + "value": { + "type": "string", + "format": "byte", + "description": "Serialized data (MessagePack) for supported types like Dataclass, Pydantic BaseModel, and untyped dict." + }, + "tag": { + "type": "string", + "description": "The serialization format identifier (e.g., MessagePack). Consumers must define unique tags and validate them before deserialization." + } + }, + "description": "A simple byte array with a tag to help different parts of the system communicate about what is in the byte array.\nIt's strongly advisable that consumers of this type define a unique tag and validate the tag before parsing the data." + }, + "coreBlob": { + "type": "object", + "properties": { + "metadata": { + "$ref": "#/definitions/coreBlobMetadata" + }, + "uri": { + "type": "string" + } + }, + "description": "Refers to an offloaded set of files. It encapsulates the type of the store and a unique uri for where the data is.\nThere are no restrictions on how the uri is formatted since it will depend on how to interact with the store." + }, + "coreBlobMetadata": { + "type": "object", + "properties": { + "type": { + "$ref": "#/definitions/coreBlobType" + } + } + }, + "coreBlobType": { + "type": "object", + "properties": { + "format": { + "type": "string", + "title": "Format can be a free form string understood by SDK/UI etc like\ncsv, parquet etc" + }, + "dimensionality": { + "$ref": "#/definitions/BlobTypeBlobDimensionality" + } + }, + "title": "Defines type behavior for blob objects" + }, + "coreConnection": { + "type": "object", + "properties": { + "task_type": { + "type": "string", + "description": "The task type that the connection is used for." + }, + "secrets[string][string]": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "The credentials to use for the connection, such as API keys, OAuth2 tokens, etc.\nThe key is the name of the secret, and it's defined in the flytekit.\nflytekit uses the key to locate the desired secret within the map." + }, + "configs[string][string]": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "The configuration to use for the connection, such as the endpoint, account name, etc.\nThe key is the name of the config, and it's defined in the flytekit." + } + } + }, + "coreContainer": { + "type": "object", + "properties": { + "image": { + "type": "string", + "title": "Container image url. Eg: docker/redis:latest" + }, + "command": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Command to be executed, if not provided, the default entrypoint in the container image will be used." + }, + "args": { + "type": "array", + "items": { + "type": "string" + }, + "description": "These will default to Flyte given paths. If provided, the system will not append known paths. If the task still\nneeds flyte's inputs and outputs path, add $(FLYTE_INPUT_FILE), $(FLYTE_OUTPUT_FILE) wherever makes sense and the\nsystem will populate these before executing the container." + }, + "resources": { + "$ref": "#/definitions/coreResources", + "description": "Container resources requirement as specified by the container engine." + }, + "env": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/coreKeyValuePair" + }, + "description": "Environment variables will be set as the container is starting up." + }, + "config": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/coreKeyValuePair" + }, + "description": "Allows extra configs to be available for the container.\nTODO: elaborate on how configs will become available.\nDeprecated, please use TaskTemplate.config instead." + }, + "ports": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/coreContainerPort" + }, + "title": "Ports to open in the container. This feature is not supported by all execution engines. (e.g. supported on K8s but\nnot supported on AWS Batch)\nOnly K8s" + }, + "data_config": { + "$ref": "#/definitions/coreDataLoadingConfig", + "title": "BETA: Optional configuration for DataLoading. If not specified, then default values are used.\nThis makes it possible to to run a completely portable container, that uses inputs and outputs\nonly from the local file-system and without having any reference to flyteidl. This is supported only on K8s at the moment.\nIf data loading is enabled, then data will be mounted in accompanying directories specified in the DataLoadingConfig. If the directories\nare not specified, inputs will be mounted onto and outputs will be uploaded from a pre-determined file-system path. Refer to the documentation\nto understand the default paths.\nOnly K8s" + }, + "architecture": { + "$ref": "#/definitions/ContainerArchitecture" + } + } + }, + "coreContainerPort": { + "type": "object", + "properties": { + "container_port": { + "type": "integer", + "format": "int64", + "description": "Number of port to expose on the pod's IP address.\nThis must be a valid port number, 0 \u003c x \u003c 65536." + }, + "name": { + "type": "string", + "description": "Name of the port to expose on the pod's IP address." + } + }, + "description": "Defines port properties for a container." + }, + "coreDataLoadingConfig": { + "type": "object", + "properties": { + "enabled": { + "type": "boolean", + "title": "Flag enables DataLoading Config. If this is not set, data loading will not be used!" + }, + "input_path": { + "type": "string", + "title": "File system path (start at root). This folder will contain all the inputs exploded to a separate file.\nExample, if the input interface needs (x: int, y: blob, z: multipart_blob) and the input path is '/var/flyte/inputs', then the file system will look like\n/var/flyte/inputs/inputs.\u003cmetadata format dependent -\u003e .pb .json .yaml\u003e -\u003e Format as defined previously. The Blob and Multipart blob will reference local filesystem instead of remote locations\n/var/flyte/inputs/x -\u003e X is a file that contains the value of x (integer) in string format\n/var/flyte/inputs/y -\u003e Y is a file in Binary format\n/var/flyte/inputs/z/... -\u003e Note Z itself is a directory\nMore information about the protocol - refer to docs #TODO reference docs here" + }, + "output_path": { + "type": "string", + "title": "File system path (start at root). This folder should contain all the outputs for the task as individual files and/or an error text file" + }, + "format": { + "$ref": "#/definitions/DataLoadingConfigLiteralMapFormat", + "title": "In the inputs folder, there will be an additional summary/metadata file that contains references to all files or inlined primitive values.\nThis format decides the actual encoding for the data. Refer to the encoding to understand the specifics of the contents and the encoding" + }, + "io_strategy": { + "$ref": "#/definitions/coreIOStrategy" + } + }, + "description": "This configuration allows executing raw containers in Flyte using the Flyte CoPilot system.\nFlyte CoPilot, eliminates the needs of flytekit or sdk inside the container. Any inputs required by the users container are side-loaded in the input_path\nAny outputs generated by the user container - within output_path are automatically uploaded." + }, + "coreError": { + "type": "object", + "properties": { + "failed_node_id": { + "type": "string", + "description": "The node id that threw the error." + }, + "message": { + "type": "string", + "description": "Error message thrown." + } + }, + "description": "Represents an error thrown from a node." + }, + "coreExecutionMetricResult": { + "type": "object", + "properties": { + "metric": { + "type": "string", + "description": "The metric this data represents. e.g. EXECUTION_METRIC_USED_CPU_AVG or EXECUTION_METRIC_USED_MEMORY_BYTES_AVG." + }, + "data": { + "type": "object", + "title": "The result data in prometheus range query result format\nhttps://prometheus.io/docs/prometheus/latest/querying/api/#expression-query-result-formats.\nThis may include multiple time series, differentiated by their metric labels.\nStart time is greater of (execution attempt start, 48h ago)\nEnd time is lesser of (execution attempt end, now)" + } + }, + "description": "ExecutionMetrics is a collection of metrics that are collected during the execution of a Flyte task." + }, + "coreExtendedResources": { + "type": "object", + "properties": { + "gpu_accelerator": { + "$ref": "#/definitions/coreGPUAccelerator", + "description": "GPU accelerator to select for task. Contains information about device type, and\nfor multi-instance GPUs, the partition size to use." + }, + "shared_memory": { + "$ref": "#/definitions/coreSharedMemory" + } + }, + "description": "Encapsulates all non-standard resources, not captured by v1.ResourceRequirements, to\nallocate to a task." + }, + "coreGPUAccelerator": { + "type": "object", + "properties": { + "device": { + "type": "string", + "description": "This can be any arbitrary string, and should be informed by the labels or taints\nassociated with the nodes in question. Default cloud provider labels typically\nuse the following values: `nvidia-tesla-t4`, `nvidia-tesla-a100`, etc." + }, + "unpartitioned": { + "type": "boolean" + }, + "partition_size": { + "type": "string", + "description": "Like `device`, this can be any arbitrary string, and should be informed by\nthe labels or taints associated with the nodes in question. Default cloud\nprovider labels typically use the following values: `1g.5gb`, `2g.10gb`, etc." + }, + "device_class": { + "$ref": "#/definitions/GPUAcceleratorDeviceClass", + "description": "The class of accelerator device. Defaults to NVIDIA_GPU if not specified." + } + }, + "description": "Metadata associated with the GPU accelerator to allocate to a task. Contains\ninformation about device type, and for multi-instance GPUs, the partition size to\nuse." + }, + "coreGranularity": { + "type": "string", + "enum": [ + "UNSET", + "MINUTE", + "HOUR", + "DAY", + "MONTH" + ], + "default": "UNSET", + "title": "- DAY: default" + }, + "coreIOStrategy": { + "type": "object", + "properties": { + "download_mode": { + "$ref": "#/definitions/IOStrategyDownloadMode", + "title": "Mode to use to manage downloads" + }, + "upload_mode": { + "$ref": "#/definitions/IOStrategyUploadMode", + "title": "Mode to use to manage uploads" + } + }, + "title": "Strategy to use when dealing with Blob, Schema, or multipart blob data (large datasets)" + }, + "coreInputBindingData": { + "type": "object", + "properties": { + "var": { + "type": "string" + } + } + }, + "coreK8sObjectMetadata": { + "type": "object", + "properties": { + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Optional labels to add to the pod definition." + }, + "annotations": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Optional annotations to add to the pod definition." + } + }, + "description": "Metadata for building a kubernetes object when a task is executed." + }, + "coreK8sPod": { + "type": "object", + "properties": { + "metadata": { + "$ref": "#/definitions/coreK8sObjectMetadata", + "description": "Contains additional metadata for building a kubernetes pod." + }, + "pod_spec": { + "type": "object", + "title": "Defines the primary pod spec created when a task is executed.\nThis should be a JSON-marshalled pod spec, which can be defined in\n- go, using: https://github.com/kubernetes/api/blob/release-1.21/core/v1/types.go#L2936\n- python: using https://github.com/kubernetes-client/python/blob/release-19.0/kubernetes/client/models/v1_pod_spec.py" + }, + "data_config": { + "$ref": "#/definitions/coreDataLoadingConfig", + "title": "BETA: Optional configuration for DataLoading. If not specified, then default values are used.\nThis makes it possible to to run a completely portable container, that uses inputs and outputs\nonly from the local file-system and without having any reference to flytekit. This is supported only on K8s at the moment.\nIf data loading is enabled, then data will be mounted in accompanying directories specified in the DataLoadingConfig. If the directories\nare not specified, inputs will be mounted onto and outputs will be uploaded from a pre-determined file-system path. Refer to the documentation\nto understand the default paths.\nOnly K8s" + }, + "primary_container_name": { + "type": "string", + "description": "Defines the primary container name when pod template override is executed." + } + }, + "description": "Defines a pod spec and additional pod metadata that is created when a task is executed." + }, + "coreKeyValuePair": { + "type": "object", + "properties": { + "key": { + "type": "string", + "description": "required." + }, + "value": { + "type": "string", + "description": "+optional." + } + }, + "description": "A generic key value pair." + }, + "coreLabelValue": { + "type": "object", + "properties": { + "static_value": { + "type": "string", + "title": "The string static value is for use in the Partitions object" + }, + "time_value": { + "type": "string", + "format": "date-time", + "title": "The time value is for use in the TimePartition case" + }, + "triggered_binding": { + "$ref": "#/definitions/coreArtifactBindingData" + }, + "input_binding": { + "$ref": "#/definitions/coreInputBindingData" + }, + "runtime_binding": { + "$ref": "#/definitions/coreRuntimeBinding" + } + } + }, + "coreLiteral": { + "type": "object", + "properties": { + "scalar": { + "$ref": "#/definitions/coreScalar", + "description": "A simple value." + }, + "collection": { + "$ref": "#/definitions/coreLiteralCollection", + "description": "A collection of literals to allow nesting." + }, + "map": { + "$ref": "#/definitions/coreLiteralMap", + "description": "A map of strings to literals." + }, + "offloaded_metadata": { + "$ref": "#/definitions/coreLiteralOffloadedMetadata", + "description": "Offloaded literal metadata\nWhen you deserialize the offloaded metadata, it would be of Literal and its type would be defined by LiteralType stored in offloaded_metadata." + }, + "hash": { + "type": "string", + "title": "A hash representing this literal.\nThis is used for caching purposes. For more details refer to RFC 1893\n(https://github.com/flyteorg/flyte/blob/master/rfc/system/1893-caching-of-offloaded-objects.md)" + }, + "metadata": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Additional metadata for literals." + } + }, + "description": "A simple value. This supports any level of nesting (e.g. array of array of array of Blobs) as well as simple primitives." + }, + "coreLiteralCollection": { + "type": "object", + "properties": { + "literals": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/coreLiteral" + } + } + }, + "description": "A collection of literals. This is a workaround since oneofs in proto messages cannot contain a repeated field." + }, + "coreLiteralMap": { + "type": "object", + "properties": { + "literals": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/coreLiteral" + } + } + }, + "description": "A map of literals. This is a workaround since oneofs in proto messages cannot contain a repeated field." + }, + "coreLiteralOffloadedMetadata": { + "type": "object", + "properties": { + "uri": { + "type": "string", + "description": "The location of the offloaded core.Literal." + }, + "size_bytes": { + "type": "string", + "format": "uint64", + "description": "The size of the offloaded data." + }, + "inferred_type": { + "$ref": "#/definitions/coreLiteralType", + "description": "The inferred literal type of the offloaded data." + } + }, + "description": "A message that contains the metadata of the offloaded data." + }, + "coreLiteralType": { + "type": "object", + "properties": { + "simple": { + "$ref": "#/definitions/coreSimpleType", + "description": "A simple type that can be compared one-to-one with another." + }, + "schema": { + "$ref": "#/definitions/coreSchemaType", + "description": "A complex type that requires matching of inner fields." + }, + "collection_type": { + "$ref": "#/definitions/coreLiteralType", + "description": "Defines the type of the value of a collection. Only homogeneous collections are allowed." + }, + "map_value_type": { + "$ref": "#/definitions/coreLiteralType", + "description": "Defines the type of the value of a map type. The type of the key is always a string." + }, + "blob": { + "$ref": "#/definitions/coreBlobType", + "description": "A blob might have specialized implementation details depending on associated metadata." + }, + "enum_type": { + "$ref": "#/definitions/flyteidl2coreEnumType", + "description": "Defines an enum with pre-defined string values." + }, + "structured_dataset_type": { + "$ref": "#/definitions/coreStructuredDatasetType", + "title": "Generalized schema support" + }, + "union_type": { + "$ref": "#/definitions/coreUnionType", + "description": "Defines an union type with pre-defined LiteralTypes." + }, + "metadata": { + "type": "object", + "description": "This field contains type metadata that is descriptive of the type, but is NOT considered in type-checking. This might be used by\nconsumers to identify special behavior or display extended information for the type." + }, + "annotation": { + "$ref": "#/definitions/coreTypeAnnotation", + "description": "This field contains arbitrary data that might have special semantic\nmeaning for the client but does not effect internal flyte behavior." + }, + "structure": { + "$ref": "#/definitions/coreTypeStructure", + "description": "Hints to improve type matching." + } + }, + "description": "Defines a strong type to allow type checking between interfaces." + }, + "coreNodeExecutionIdentifier": { + "type": "object", + "properties": { + "node_id": { + "type": "string" + }, + "execution_id": { + "$ref": "#/definitions/coreWorkflowExecutionIdentifier" + } + }, + "description": "Encapsulation of fields that identify a Flyte node execution entity." + }, + "coreOAuth2Client": { + "type": "object", + "properties": { + "client_id": { + "type": "string", + "title": "client_id is the public id for the client to use. The system will not perform any pre-auth validation that the\nsecret requested matches the client_id indicated here.\n+required" + }, + "client_secret": { + "$ref": "#/definitions/flyteidl2coreSecret", + "title": "client_secret is a reference to the secret used to authenticate the OAuth2 client.\n+required" + } + }, + "description": "OAuth2Client encapsulates OAuth2 Client Credentials to be used when making calls on behalf of that task." + }, + "coreOAuth2TokenRequest": { + "type": "object", + "properties": { + "name": { + "type": "string", + "title": "name indicates a unique id for the token request within this task token requests. It'll be used as a suffix for\nenvironment variables and as a filename for mounting tokens as files.\n+required" + }, + "type": { + "$ref": "#/definitions/coreOAuth2TokenRequestType", + "title": "type indicates the type of the request to make. Defaults to CLIENT_CREDENTIALS.\n+required" + }, + "client": { + "$ref": "#/definitions/coreOAuth2Client", + "title": "client references the client_id/secret to use to request the OAuth2 token.\n+required" + }, + "idp_discovery_endpoint": { + "type": "string", + "title": "idp_discovery_endpoint references the discovery endpoint used to retrieve token endpoint and other related\ninformation.\n+optional" + }, + "token_endpoint": { + "type": "string", + "title": "token_endpoint references the token issuance endpoint. If idp_discovery_endpoint is not provided, this parameter is\nmandatory.\n+optional" + } + }, + "description": "OAuth2TokenRequest encapsulates information needed to request an OAuth2 token.\nFLYTE_TOKENS_ENV_PREFIX will be passed to indicate the prefix of the environment variables that will be present if\ntokens are passed through environment variables.\nFLYTE_TOKENS_PATH_PREFIX will be passed to indicate the prefix of the path where secrets will be mounted if tokens\nare passed through file mounts." + }, + "coreOAuth2TokenRequestType": { + "type": "string", + "enum": [ + "CLIENT_CREDENTIALS" + ], + "default": "CLIENT_CREDENTIALS", + "description": "Type of the token requested.\n\n - CLIENT_CREDENTIALS: CLIENT_CREDENTIALS indicates a 2-legged OAuth token requested using client credentials." + }, + "coreOperator": { + "type": "string", + "enum": [ + "MINUS", + "PLUS" + ], + "default": "MINUS" + }, + "corePartitions": { + "type": "object", + "properties": { + "value": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/coreLabelValue" + } + } + } + }, + "corePrimitive": { + "type": "object", + "properties": { + "integer": { + "type": "string", + "format": "int64" + }, + "float_value": { + "type": "number", + "format": "double" + }, + "string_value": { + "type": "string" + }, + "boolean": { + "type": "boolean" + }, + "datetime": { + "type": "string", + "format": "date-time" + }, + "duration": { + "type": "string" + } + }, + "title": "Primitive Types" + }, + "coreResourceType": { + "type": "string", + "enum": [ + "UNSPECIFIED", + "TASK", + "WORKFLOW", + "LAUNCH_PLAN", + "DATASET" + ], + "default": "UNSPECIFIED", + "description": "Indicates a resource type within Flyte.\n\n - DATASET: A dataset represents an entity modeled in Flyte DataCatalog. A Dataset is also a versioned entity and can be a compilation of multiple individual objects.\nEventually all Catalog objects should be modeled similar to Flyte Objects. The Dataset entities makes it possible for the UI and CLI to act on the objects\nin a similar manner to other Flyte objects" + }, + "coreResources": { + "type": "object", + "properties": { + "requests": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/ResourcesResourceEntry" + }, + "description": "The desired set of resources requested. ResourceNames must be unique within the list." + }, + "limits": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/ResourcesResourceEntry" + }, + "description": "Defines a set of bounds (e.g. min/max) within which the task can reliably run. ResourceNames must be unique\nwithin the list." + } + }, + "description": "A customizable interface to convey resources requested for a container. This can be interpreted differently for different\ncontainer engines." + }, + "coreRetryStrategy": { + "type": "object", + "properties": { + "retries": { + "type": "integer", + "format": "int64", + "description": "Number of retries. Retries will be consumed when the job fails with a recoverable error.\nThe number of retries must be less than or equals to 10." + } + }, + "description": "Retry strategy associated with an executable unit." + }, + "coreRuntimeBinding": { + "type": "object" + }, + "coreScalar": { + "type": "object", + "properties": { + "primitive": { + "$ref": "#/definitions/corePrimitive" + }, + "blob": { + "$ref": "#/definitions/coreBlob" + }, + "binary": { + "$ref": "#/definitions/coreBinary" + }, + "schema": { + "$ref": "#/definitions/flyteidl2coreSchema" + }, + "none_type": { + "$ref": "#/definitions/coreVoid" + }, + "error": { + "$ref": "#/definitions/coreError" + }, + "generic": { + "type": "object" + }, + "structured_dataset": { + "$ref": "#/definitions/coreStructuredDataset" + }, + "union": { + "$ref": "#/definitions/coreUnion" + } + } + }, + "coreSchemaType": { + "type": "object", + "properties": { + "columns": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/SchemaTypeSchemaColumn" + }, + "description": "A list of ordered columns this schema comprises of." + } + }, + "description": "Defines schema columns and types to strongly type-validate schemas interoperability." + }, + "coreSharedMemory": { + "type": "object", + "properties": { + "mount_path": { + "type": "string", + "title": "Mount path to place in container" + }, + "mount_name": { + "type": "string", + "title": "Name for volume" + }, + "size_limit": { + "type": "string", + "title": "Size limit for shared memory. If not set, then the shared memory is equal\nto the allocated memory.\n+optional" + } + }, + "description": "Metadata associated with configuring a shared memory volume for a task." + }, + "coreSimpleType": { + "type": "string", + "enum": [ + "NONE", + "INTEGER", + "FLOAT", + "STRING", + "BOOLEAN", + "DATETIME", + "DURATION", + "BINARY", + "ERROR", + "STRUCT" + ], + "default": "NONE", + "description": "Define a set of simple types." + }, + "coreSql": { + "type": "object", + "properties": { + "statement": { + "type": "string", + "title": "The actual query to run, the query can have templated parameters.\nWe use Flyte's Golang templating format for Query templating.\nFor example,\ninsert overwrite directory '{{ .rawOutputDataPrefix }}' stored as parquet\nselect *\nfrom my_table\nwhere ds = '{{ .Inputs.ds }}'" + }, + "dialect": { + "$ref": "#/definitions/SqlDialect" + } + }, + "description": "Sql represents a generic sql workload with a statement and dialect." + }, + "coreStructuredDataset": { + "type": "object", + "properties": { + "uri": { + "type": "string", + "title": "String location uniquely identifying where the data is.\nShould start with the storage location (e.g. s3://, gs://, bq://, etc.)" + }, + "metadata": { + "$ref": "#/definitions/coreStructuredDatasetMetadata" + } + } + }, + "coreStructuredDatasetMetadata": { + "type": "object", + "properties": { + "structured_dataset_type": { + "$ref": "#/definitions/coreStructuredDatasetType", + "description": "Bundle the type information along with the literal.\nThis is here because StructuredDatasets can often be more defined at run time than at compile time.\nThat is, at compile time you might only declare a task to return a pandas dataframe or a StructuredDataset,\nwithout any column information, but at run time, you might have that column information.\nflytekit python will copy this type information into the literal, from the type information, if not provided by\nthe various plugins (encoders).\nSince this field is run time generated, it's not used for any type checking." + } + } + }, + "coreStructuredDatasetType": { + "type": "object", + "properties": { + "columns": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/StructuredDatasetTypeDatasetColumn" + }, + "description": "A list of ordered columns this schema comprises of." + }, + "format": { + "type": "string", + "description": "This is the storage format, the format of the bits at rest\nparquet, feather, csv, etc.\nFor two types to be compatible, the format will need to be an exact match." + }, + "external_schema_type": { + "type": "string", + "description": "This is a string representing the type that the bytes in external_schema_bytes are formatted in.\nThis is an optional field that will not be used for type checking." + }, + "external_schema_bytes": { + "type": "string", + "format": "byte", + "description": "The serialized bytes of a third-party schema library like Arrow.\nThis is an optional field that will not be used for type checking." + } + } + }, + "coreTaskExecutionIdentifier": { + "type": "object", + "properties": { + "task_id": { + "$ref": "#/definitions/flyteidl2coreIdentifier" + }, + "node_execution_id": { + "$ref": "#/definitions/coreNodeExecutionIdentifier" + }, + "retry_attempt": { + "type": "integer", + "format": "int64" + } + }, + "description": "Encapsulation of fields that identify a Flyte task execution entity." + }, + "coreTaskExecutionPhase": { + "type": "string", + "enum": [ + "UNDEFINED", + "QUEUED", + "RUNNING", + "SUCCEEDED", + "ABORTED", + "FAILED", + "INITIALIZING", + "WAITING_FOR_RESOURCES", + "RETRYABLE_FAILED" + ], + "default": "UNDEFINED", + "title": "- INITIALIZING: To indicate cases where task is initializing, like: ErrImagePull, ContainerCreating, PodInitializing\n - WAITING_FOR_RESOURCES: To address cases, where underlying resource is not available: Backoff error, Resource quota exceeded" + }, + "coreTaskLog": { + "type": "object", + "properties": { + "uri": { + "type": "string" + }, + "name": { + "type": "string" + }, + "message_format": { + "$ref": "#/definitions/TaskLogMessageFormat" + }, + "ttl": { + "type": "string" + }, + "ShowWhilePending": { + "type": "boolean" + }, + "HideOnceFinished": { + "type": "boolean" + }, + "link_type": { + "$ref": "#/definitions/TaskLogLinkType" + }, + "ready": { + "type": "boolean" + }, + "icon_uri": { + "type": "string" + } + }, + "title": "Log information for the task that is specific to a log sink\nWhen our log story is flushed out, we may have more metadata here like log link expiry" + }, + "coreTaskTemplate": { + "type": "object", + "properties": { + "id": { + "$ref": "#/definitions/flyteidl2coreIdentifier", + "description": "Auto generated taskId by the system. Task Id uniquely identifies this task globally." + }, + "type": { + "type": "string", + "description": "A predefined yet extensible Task type identifier. This can be used to customize any of the components. If no\nextensions are provided in the system, Flyte will resolve the this task to its TaskCategory and default the\nimplementation registered for the TaskCategory." + }, + "metadata": { + "$ref": "#/definitions/flyteidl2coreTaskMetadata", + "description": "Extra metadata about the task." + }, + "interface": { + "$ref": "#/definitions/coreTypedInterface", + "description": "A strongly typed interface for the task. This enables others to use this task within a workflow and guarantees\ncompile-time validation of the workflow to avoid costly runtime failures." + }, + "custom": { + "type": "object", + "description": "Custom data about the task. This is extensible to allow various plugins in the system." + }, + "container": { + "$ref": "#/definitions/coreContainer" + }, + "k8s_pod": { + "$ref": "#/definitions/coreK8sPod" + }, + "sql": { + "$ref": "#/definitions/coreSql" + }, + "task_type_version": { + "type": "integer", + "format": "int32", + "description": "This can be used to customize task handling at execution time for the same task type." + }, + "security_context": { + "$ref": "#/definitions/flyteidl2coreSecurityContext", + "description": "security_context encapsulates security attributes requested to run this task." + }, + "extended_resources": { + "$ref": "#/definitions/coreExtendedResources", + "description": "Encapsulates all non-standard resources, not captured by\nv1.ResourceRequirements, to allocate to a task." + }, + "config": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "title": "Metadata about the custom defined for this task. This is extensible to allow various plugins in the system\nto use as required.\nreserve the field numbers 1 through 15 for very frequently occurring message elements" + } + }, + "description": "A Task structure that uniquely identifies a task in the system\nTasks are registered as a first step in the system." + }, + "coreTimePartition": { + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/coreLabelValue" + }, + "granularity": { + "$ref": "#/definitions/coreGranularity" + } + } + }, + "coreTimeTransform": { + "type": "object", + "properties": { + "transform": { + "type": "string" + }, + "op": { + "$ref": "#/definitions/coreOperator" + } + } + }, + "coreTypeAnnotation": { + "type": "object", + "properties": { + "annotations": { + "type": "object", + "description": "A arbitrary JSON payload to describe a type." + } + }, + "description": "TypeAnnotation encapsulates registration time information about a type. This can be used for various control-plane operations. TypeAnnotation will not be available at runtime when a task runs." + }, + "coreTypeStructure": { + "type": "object", + "properties": { + "tag": { + "type": "string", + "title": "Must exactly match for types to be castable" + }, + "dataclass_type": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/coreLiteralType" + }, + "title": "dataclass_type only exists for dataclasses.\nThis is used to resolve the type of the fields of dataclass\nThe key is the field name, and the value is the literal type of the field\ne.g. For dataclass Foo, with fields a, and a is a string\nFoo.a will be resolved as a literal type of string from dataclass_type" + } + }, + "description": "Hints to improve type matching\ne.g. allows distinguishing output from custom type transformers\neven if the underlying IDL serialization matches." + }, + "coreTypedInterface": { + "type": "object", + "properties": { + "inputs": { + "$ref": "#/definitions/coreVariableMap" + }, + "outputs": { + "$ref": "#/definitions/coreVariableMap" + } + }, + "description": "Defines strongly typed inputs and outputs." + }, + "coreUnion": { + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/coreLiteral" + }, + "type": { + "$ref": "#/definitions/coreLiteralType" + } + }, + "description": "The runtime representation of a tagged union value. See `UnionType` for more details." + }, + "coreUnionType": { + "type": "object", + "properties": { + "variants": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/coreLiteralType" + }, + "description": "Predefined set of variants in union." + } + }, + "description": "Defines a tagged union type, also known as a variant (and formally as the sum type).\n\nA sum type S is defined by a sequence of types (A, B, C, ...), each tagged by a string tag\nA value of type S is constructed from a value of any of the variant types. The specific choice of type is recorded by\nstoring the varaint's tag with the literal value and can be examined in runtime.\n\nType S is typically written as\nS := Apple A | Banana B | Cantaloupe C | ...\n\nNotably, a nullable (optional) type is a sum type between some type X and the singleton type representing a null-value:\nOptional X := X | Null\n\nSee also: https://en.wikipedia.org/wiki/Tagged_union" + }, + "coreVariable": { + "type": "object", + "properties": { + "type": { + "$ref": "#/definitions/coreLiteralType", + "description": "Variable literal type." + }, + "description": { + "type": "string", + "title": "+optional string describing input variable" + }, + "artifact_partial_id": { + "$ref": "#/definitions/coreArtifactID", + "description": "+optional This object allows the user to specify how Artifacts are created.\nname, tag, partitions can be specified. The other fields (version and project/domain) are ignored." + }, + "artifact_tag": { + "$ref": "#/definitions/coreArtifactTag" + } + }, + "description": "Defines a strongly typed variable." + }, + "coreVariableMap": { + "type": "object", + "properties": { + "variables": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/coreVariable" + }, + "description": "Defines a map of variable names to variables." + } + }, + "title": "A map of Variables" + }, + "coreVoid": { + "type": "object", + "description": "Used to denote a nil/null/None assignment to a scalar value. The underlying LiteralType for Void is intentionally\nundefined since it can be assigned to a scalar of any LiteralType." + }, + "coreWorkflowExecutionIdentifier": { + "type": "object", + "properties": { + "project": { + "type": "string", + "description": "Name of the project the resource belongs to." + }, + "domain": { + "type": "string", + "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project." + }, + "name": { + "type": "string", + "description": "User or system provided value for the resource." + }, + "org": { + "type": "string", + "description": "Optional, org key applied to the resource." + } + }, + "title": "Encapsulation of fields that uniquely identifies a Flyte workflow execution" + }, + "flyteidl2connectorResource": { + "type": "object", + "properties": { + "outputs": { + "$ref": "#/definitions/taskOutputs", + "title": "The outputs of the execution. It's typically used by sql task. connector service will create a\nStructured dataset pointing to the query result table.\n+optional" + }, + "message": { + "type": "string", + "description": "A descriptive message for the current state. e.g. waiting for cluster." + }, + "log_links": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/coreTaskLog" + }, + "description": "log information for the task execution." + }, + "phase": { + "$ref": "#/definitions/coreTaskExecutionPhase", + "description": "The phase of the execution is used to determine the phase of the plugin's execution." + }, + "custom_info": { + "type": "object", + "description": "Custom data specific to the connector." + } + } + }, + "flyteidl2connectorTaskExecutionMetadata": { + "type": "object", + "properties": { + "task_execution_id": { + "$ref": "#/definitions/coreTaskExecutionIdentifier" + }, + "namespace": { + "type": "string", + "title": "k8s namespace where the task is executed in" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "title": "Labels attached to the task execution" + }, + "annotations": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "title": "Annotations attached to the task execution" + }, + "k8s_service_account": { + "type": "string", + "title": "k8s service account associated with the task execution" + }, + "environment_variables": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "title": "Environment variables attached to the task execution" + }, + "max_attempts": { + "type": "integer", + "format": "int32", + "description": "Represents the maximum number of attempts allowed for a task.\nIf a task fails, it can be retried up to this maximum number of attempts." + }, + "interruptible": { + "type": "boolean", + "description": "Indicates whether the task execution can be interrupted.\nIf set to true, the task can be stopped before completion." + }, + "interruptible_failure_threshold": { + "type": "integer", + "format": "int32", + "description": "Specifies the threshold for failure count at which the interruptible property\nwill take effect. If the number of consecutive task failures exceeds this threshold,\ninterruptible behavior will be activated." + }, + "identity": { + "$ref": "#/definitions/flyteidl2coreIdentity", + "title": "Identity of user running this task execution" + } + }, + "description": "Represents a subset of runtime task execution metadata that are relevant to external plugins.\n\nID of the task execution" + }, + "flyteidl2coreEnumType": { + "type": "object", + "properties": { + "values": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Predefined set of enum values." + } + }, + "description": "Enables declaring enum types, with predefined string values\nFor len(values) \u003e 0, the first value in the ordered list is regarded as the default value. If you wish\nTo provide no defaults, make the first value as undefined." + }, + "flyteidl2coreIdentifier": { + "type": "object", + "properties": { + "resource_type": { + "$ref": "#/definitions/coreResourceType", + "description": "Identifies the specific type of resource that this identifier corresponds to." + }, + "project": { + "type": "string", + "description": "Name of the project the resource belongs to." + }, + "domain": { + "type": "string", + "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project." + }, + "name": { + "type": "string", + "description": "User provided value for the resource." + }, + "version": { + "type": "string", + "description": "Specific version of the resource." + }, + "org": { + "type": "string", + "description": "Optional, org key applied to the resource." + } + }, + "description": "Encapsulation of fields that uniquely identifies a Flyte resource." + }, + "flyteidl2coreIdentity": { + "type": "object", + "properties": { + "iam_role": { + "type": "string", + "description": "iam_role references the fully qualified name of Identity \u0026 Access Management role to impersonate." + }, + "k8s_service_account": { + "type": "string", + "description": "k8s_service_account references a kubernetes service account to impersonate." + }, + "oauth2_client": { + "$ref": "#/definitions/coreOAuth2Client", + "description": "oauth2_client references an oauth2 client. Backend plugins can use this information to impersonate the client when\nmaking external calls." + }, + "execution_identity": { + "type": "string", + "title": "execution_identity references the subject who makes the execution" + } + }, + "description": "Identity encapsulates the various security identities a task can run as. It's up to the underlying plugin to pick the\nright identity for the execution environment." + }, + "flyteidl2coreRuntimeMetadata": { + "type": "object", + "properties": { + "type": { + "$ref": "#/definitions/flyteidl2coreRuntimeMetadataRuntimeType", + "description": "Type of runtime." + }, + "version": { + "type": "string", + "description": "Version of the runtime. All versions should be backward compatible. However, certain cases call for version\nchecks to ensure tighter validation or setting expectations." + }, + "flavor": { + "type": "string", + "description": "+optional It can be used to provide extra information about the runtime (e.g. python, golang... etc.)." + } + }, + "description": "Runtime information. This is loosely defined to allow for extensibility." + }, + "flyteidl2coreRuntimeMetadataRuntimeType": { + "type": "string", + "enum": [ + "OTHER", + "FLYTE_SDK" + ], + "default": "OTHER" + }, + "flyteidl2coreSchema": { + "type": "object", + "properties": { + "uri": { + "type": "string" + }, + "type": { + "$ref": "#/definitions/coreSchemaType" + } + }, + "description": "A strongly typed schema that defines the interface of data retrieved from the underlying storage medium." + }, + "flyteidl2coreSecret": { + "type": "object", + "properties": { + "group": { + "type": "string", + "title": "The name of the secret group where to find the key referenced below. For K8s secrets, this should be the name of\nthe v1/secret object. For Confidant, this should be the Credential name. For Vault, this should be the secret name.\nFor AWS Secret Manager, this should be the name of the secret.\n+required" + }, + "group_version": { + "type": "string", + "title": "The group version to fetch. This is not supported in all secret management systems. It'll be ignored for the ones\nthat do not support it.\n+optional" + }, + "key": { + "type": "string", + "title": "The name of the secret to mount. This has to match an existing secret in the system. It's up to the implementation\nof the secret management system to require case sensitivity. For K8s secrets, Confidant and Vault, this should\nmatch one of the keys inside the secret. For AWS Secret Manager, it's ignored.\n+optional" + }, + "mount_requirement": { + "$ref": "#/definitions/SecretMountType", + "title": "mount_requirement is optional. Indicates where the secret has to be mounted. If provided, the execution will fail\nif the underlying key management system cannot satisfy that requirement. If not provided, the default location\nwill depend on the key management system.\n+optional" + }, + "env_var": { + "type": "string", + "title": "env_var is optional. Custom environment variable to set the value of the secret. If mount_requirement is ENV_VAR,\nthen the value is the secret itself. If mount_requirement is FILE, then the value is the path to the secret file.\n+optional" + } + }, + "description": "Secret encapsulates information about the secret a task needs to proceed. An environment variable\nFLYTE_SECRETS_ENV_PREFIX will be passed to indicate the prefix of the environment variables that will be present if\nsecrets are passed through environment variables.\nFLYTE_SECRETS_DEFAULT_DIR will be passed to indicate the prefix of the path where secrets will be mounted if secrets\nare passed through file mounts." + }, + "flyteidl2coreSecurityContext": { + "type": "object", + "properties": { + "run_as": { + "$ref": "#/definitions/flyteidl2coreIdentity", + "description": "run_as encapsulates the identity a pod should run as. If the task fills in multiple fields here, it'll be up to the\nbackend plugin to choose the appropriate identity for the execution engine the task will run on." + }, + "secrets": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/flyteidl2coreSecret" + }, + "description": "secrets indicate the list of secrets the task needs in order to proceed. Secrets will be mounted/passed to the\npod as it starts. If the plugin responsible for kicking of the task will not run it on a flyte cluster (e.g. AWS\nBatch), it's the responsibility of the plugin to fetch the secret (which means propeller identity will need access\nto the secret) and to pass it to the remote execution engine." + }, + "tokens": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/coreOAuth2TokenRequest" + }, + "description": "tokens indicate the list of token requests the task needs in order to proceed. Tokens will be mounted/passed to the\npod as it starts. If the plugin responsible for kicking of the task will not run it on a flyte cluster (e.g. AWS\nBatch), it's the responsibility of the plugin to fetch the secret (which means propeller identity will need access\nto the secret) and to pass it to the remote execution engine." + } + }, + "description": "SecurityContext holds security attributes that apply to tasks." + }, + "flyteidl2coreTaskMetadata": { + "type": "object", + "properties": { + "discoverable": { + "type": "boolean", + "description": "Indicates whether the system should attempt to lookup this task's output to avoid duplication of work." + }, + "runtime": { + "$ref": "#/definitions/flyteidl2coreRuntimeMetadata", + "description": "Runtime information about the task." + }, + "timeout": { + "type": "string", + "description": "The overall timeout of a task including user-triggered retries." + }, + "retries": { + "$ref": "#/definitions/coreRetryStrategy", + "description": "Number of retries per task." + }, + "discovery_version": { + "type": "string", + "description": "Indicates a logical version to apply to this task for the purpose of discovery." + }, + "deprecated_error_message": { + "type": "string", + "description": "If set, this indicates that this task is deprecated. This will enable owners of tasks to notify consumers\nof the ending of support for a given task." + }, + "interruptible": { + "type": "boolean" + }, + "cache_serializable": { + "type": "boolean", + "title": "Indicates whether the system should attempt to execute discoverable instances in serial to avoid duplicate work" + }, + "tags": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "title": "Arbitrary tags that allow users and the platform to store small but arbitrary labels" + }, + "pod_template_name": { + "type": "string", + "description": "pod_template_name is the unique name of a PodTemplate k8s resource to be used as the base configuration if this\ntask creates a k8s Pod. If this value is set, the specified PodTemplate will be used instead of, but applied\nidentically as, the default PodTemplate configured in FlytePropeller." + }, + "cache_ignore_input_vars": { + "type": "array", + "items": { + "type": "string" + }, + "description": "cache_ignore_input_vars is the input variables that should not be included when calculating hash for cache." + }, + "is_eager": { + "type": "boolean", + "description": "is_eager indicates whether the task is eager or not.\nThis would be used by CreateTask endpoint." + }, + "generates_deck": { + "type": "boolean", + "description": "Indicates whether the task will generate a deck when it finishes executing.\nThe BoolValue can have three states:\n- nil: The value is not set.\n- true: The task will generate a deck.\n- false: The task will not generate a deck." + }, + "metadata": { + "$ref": "#/definitions/coreK8sObjectMetadata", + "description": "Metadata applied to task pods or task CR objects.\nIn flytekit, labels and annotations resulting in this metadata field\nare provided via `@task(labels=..., annotations=...)`.\nFor tasks backed by pods like PythonFunctionTask, these take precedence\nover the metadata provided via `@task(pod_template=PodTemplate(labels=...))` which are transported\nin the K8sPod message. For tasks backed by CRDs, this metadata is applied to\nthe CR object itself while the metadata in the pod template/K8sPod is applied\nto the pod template spec of the CR object." + }, + "debuggable": { + "type": "boolean", + "description": "Whether the task is able to run the debugger (vscode server) inside the task container." + }, + "log_links": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/coreTaskLog" + }, + "description": "Log links associated with this task." + } + }, + "title": "Task Metadata" + }, + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "protobufNullValue": { + "type": "string", + "enum": [ + "NULL_VALUE" + ], + "default": "NULL_VALUE", + "description": "`NullValue` is a singleton enumeration to represent the null value for the\n`Value` type union.\n\nThe JSON representation for `NullValue` is JSON `null`.\n\n - NULL_VALUE: Null value." + }, + "taskInputs": { + "type": "object", + "properties": { + "literals": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/taskNamedLiteral" + }, + "description": "Ordered inputs. THIS FIELD MUST REMAIN FIRST as this would break Run service assumptions if it were to move." + }, + "context": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/coreKeyValuePair" + }, + "title": "Context for the action. If an action receives context, it'll automatically pass it to any actions it spawns.\nContext will not be used for cache key computation.\nExamples for context include:\n - User-provided metadata that is not part of the action's inputs.\n - Information about the environment the action is running in (e.g. cluster, region, etc.)\n - Tracing information about the action" + } + }, + "description": "Input payload for an action." + }, + "taskNamedLiteral": { + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "Name of the literal." + }, + "value": { + "$ref": "#/definitions/coreLiteral", + "description": "Literal value." + } + }, + "description": "Named literal value." + }, + "taskOutputs": { + "type": "object", + "properties": { + "literals": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/taskNamedLiteral" + }, + "description": "Ordered outputs. THIS FIELD MUST REMAIN FIRST as this would break Run service assumptions if it were to move." + } + }, + "description": "Output payload for an action." + } + } +} diff --git a/gen/go/gateway/flyteidl2/core/artifact_id.swagger.json b/gen/go/gateway/flyteidl2/core/artifact_id.swagger.json new file mode 100644 index 0000000000..f4ea58b47b --- /dev/null +++ b/gen/go/gateway/flyteidl2/core/artifact_id.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/core/artifact_id.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/core/catalog.swagger.json b/gen/go/gateway/flyteidl2/core/catalog.swagger.json new file mode 100644 index 0000000000..584bffc002 --- /dev/null +++ b/gen/go/gateway/flyteidl2/core/catalog.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/core/catalog.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/core/errors.swagger.json b/gen/go/gateway/flyteidl2/core/errors.swagger.json new file mode 100644 index 0000000000..24a8fb5678 --- /dev/null +++ b/gen/go/gateway/flyteidl2/core/errors.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/core/errors.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/core/execution.swagger.json b/gen/go/gateway/flyteidl2/core/execution.swagger.json new file mode 100644 index 0000000000..7211ebdb61 --- /dev/null +++ b/gen/go/gateway/flyteidl2/core/execution.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/core/execution.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/core/identifier.swagger.json b/gen/go/gateway/flyteidl2/core/identifier.swagger.json new file mode 100644 index 0000000000..5a56e131e4 --- /dev/null +++ b/gen/go/gateway/flyteidl2/core/identifier.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/core/identifier.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/core/interface.swagger.json b/gen/go/gateway/flyteidl2/core/interface.swagger.json new file mode 100644 index 0000000000..37a2cdbe04 --- /dev/null +++ b/gen/go/gateway/flyteidl2/core/interface.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/core/interface.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/core/literals.swagger.json b/gen/go/gateway/flyteidl2/core/literals.swagger.json new file mode 100644 index 0000000000..c7325a0b43 --- /dev/null +++ b/gen/go/gateway/flyteidl2/core/literals.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/core/literals.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/core/metrics.swagger.json b/gen/go/gateway/flyteidl2/core/metrics.swagger.json new file mode 100644 index 0000000000..e41e3ada4f --- /dev/null +++ b/gen/go/gateway/flyteidl2/core/metrics.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/core/metrics.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/core/security.swagger.json b/gen/go/gateway/flyteidl2/core/security.swagger.json new file mode 100644 index 0000000000..6ffbda00be --- /dev/null +++ b/gen/go/gateway/flyteidl2/core/security.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/core/security.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/core/tasks.swagger.json b/gen/go/gateway/flyteidl2/core/tasks.swagger.json new file mode 100644 index 0000000000..7d91055e62 --- /dev/null +++ b/gen/go/gateway/flyteidl2/core/tasks.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/core/tasks.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/core/types.swagger.json b/gen/go/gateway/flyteidl2/core/types.swagger.json new file mode 100644 index 0000000000..8a5bd26da4 --- /dev/null +++ b/gen/go/gateway/flyteidl2/core/types.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/core/types.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/dataproxy/dataproxy_service.pb.gw.go b/gen/go/gateway/flyteidl2/dataproxy/dataproxy_service.pb.gw.go new file mode 100644 index 0000000000..c016a5343e --- /dev/null +++ b/gen/go/gateway/flyteidl2/dataproxy/dataproxy_service.pb.gw.go @@ -0,0 +1,257 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: flyteidl2/dataproxy/dataproxy_service.proto + +/* +Package dataproxy is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package dataproxy + +import ( + "context" + "io" + "net/http" + + extDataproxy "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/dataproxy" + "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" + "github.com/grpc-ecosystem/grpc-gateway/v2/utilities" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" + "google.golang.org/protobuf/proto" +) + +// Suppress "imported and not used" errors +var _ codes.Code +var _ io.Reader +var _ status.Status +var _ = runtime.String +var _ = utilities.NewDoubleArray +var _ = metadata.Join + +func request_DataProxyService_CreateUploadLocation_0(ctx context.Context, marshaler runtime.Marshaler, client extDataproxy.DataProxyServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extDataproxy.CreateUploadLocationRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.CreateUploadLocation(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_DataProxyService_CreateUploadLocation_0(ctx context.Context, marshaler runtime.Marshaler, server extDataproxy.DataProxyServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extDataproxy.CreateUploadLocationRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.CreateUploadLocation(ctx, &protoReq) + return msg, metadata, err + +} + +func request_DataProxyService_CreateUploadLocation_1(ctx context.Context, marshaler runtime.Marshaler, client extDataproxy.DataProxyServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extDataproxy.CreateUploadLocationRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.CreateUploadLocation(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_DataProxyService_CreateUploadLocation_1(ctx context.Context, marshaler runtime.Marshaler, server extDataproxy.DataProxyServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extDataproxy.CreateUploadLocationRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.CreateUploadLocation(ctx, &protoReq) + return msg, metadata, err + +} + +// RegisterDataProxyServiceHandlerServer registers the http handlers for service DataProxyService to "mux". +// UnaryRPC :call DataProxyServiceServer directly. +// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterDataProxyServiceHandlerFromEndpoint instead. +func RegisterDataProxyServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extDataproxy.DataProxyServiceServer) error { + + mux.Handle("POST", pattern_DataProxyService_CreateUploadLocation_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/flyteidl2.dataproxy.DataProxyService/CreateUploadLocation", runtime.WithHTTPPathPattern("/api/v1/dataproxy/artifact_urn")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_DataProxyService_CreateUploadLocation_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_DataProxyService_CreateUploadLocation_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_DataProxyService_CreateUploadLocation_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/flyteidl2.dataproxy.DataProxyService/CreateUploadLocation", runtime.WithHTTPPathPattern("/api/v1/org/dataproxy/artifact_urn")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_DataProxyService_CreateUploadLocation_1(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_DataProxyService_CreateUploadLocation_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +// RegisterDataProxyServiceHandlerFromEndpoint is same as RegisterDataProxyServiceHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterDataProxyServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.DialContext(ctx, endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterDataProxyServiceHandler(ctx, mux, conn) +} + +// RegisterDataProxyServiceHandler registers the http handlers for service DataProxyService to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterDataProxyServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterDataProxyServiceHandlerClient(ctx, mux, extDataproxy.NewDataProxyServiceClient(conn)) +} + +// RegisterDataProxyServiceHandlerClient registers the http handlers for service DataProxyService +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extDataproxy.DataProxyServiceClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extDataproxy.DataProxyServiceClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "extDataproxy.DataProxyServiceClient" to call the correct interceptors. +func RegisterDataProxyServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extDataproxy.DataProxyServiceClient) error { + + mux.Handle("POST", pattern_DataProxyService_CreateUploadLocation_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/flyteidl2.dataproxy.DataProxyService/CreateUploadLocation", runtime.WithHTTPPathPattern("/api/v1/dataproxy/artifact_urn")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_DataProxyService_CreateUploadLocation_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_DataProxyService_CreateUploadLocation_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_DataProxyService_CreateUploadLocation_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/flyteidl2.dataproxy.DataProxyService/CreateUploadLocation", runtime.WithHTTPPathPattern("/api/v1/org/dataproxy/artifact_urn")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_DataProxyService_CreateUploadLocation_1(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_DataProxyService_CreateUploadLocation_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_DataProxyService_CreateUploadLocation_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"api", "v1", "dataproxy", "artifact_urn"}, "")) + + pattern_DataProxyService_CreateUploadLocation_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"api", "v1", "org", "dataproxy", "artifact_urn"}, "")) +) + +var ( + forward_DataProxyService_CreateUploadLocation_0 = runtime.ForwardResponseMessage + + forward_DataProxyService_CreateUploadLocation_1 = runtime.ForwardResponseMessage +) diff --git a/gen/go/gateway/flyteidl2/dataproxy/dataproxy_service.swagger.json b/gen/go/gateway/flyteidl2/dataproxy/dataproxy_service.swagger.json new file mode 100644 index 0000000000..6a6b222948 --- /dev/null +++ b/gen/go/gateway/flyteidl2/dataproxy/dataproxy_service.swagger.json @@ -0,0 +1,196 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/dataproxy/dataproxy_service.proto", + "version": "version not set" + }, + "tags": [ + { + "name": "DataProxyService" + } + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/api/v1/dataproxy/artifact_urn": { + "post": { + "summary": "CreateUploadLocation generates a signed URL for uploading data to the configured storage backend.", + "description": "Creates a write-only http location that is accessible for tasks at runtime.", + "operationId": "DataProxyService_CreateUploadLocation", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/dataproxyCreateUploadLocationResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + }, + "parameters": [ + { + "name": "body", + "description": "CreateUploadLocationRequest specifies the request for the CreateUploadLocation API.\nThe data proxy service will generate a storage location with server-side configured prefixes.\nThe generated path follows one of these patterns:\n - project/domain/(deterministic hash of content_md5)/filename (if filename is present); OR\n - project/domain/filename_root/filename (if filename_root and filename are present).", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/dataproxyCreateUploadLocationRequest" + } + } + ], + "tags": [ + "DataProxyService" + ] + } + }, + "/api/v1/org/dataproxy/artifact_urn": { + "post": { + "summary": "CreateUploadLocation generates a signed URL for uploading data to the configured storage backend.", + "description": "Creates a write-only http location that is accessible for tasks at runtime.", + "operationId": "DataProxyService_CreateUploadLocation2", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/dataproxyCreateUploadLocationResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + }, + "parameters": [ + { + "name": "body", + "description": "CreateUploadLocationRequest specifies the request for the CreateUploadLocation API.\nThe data proxy service will generate a storage location with server-side configured prefixes.\nThe generated path follows one of these patterns:\n - project/domain/(deterministic hash of content_md5)/filename (if filename is present); OR\n - project/domain/filename_root/filename (if filename_root and filename are present).", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/dataproxyCreateUploadLocationRequest" + } + } + ], + "tags": [ + "DataProxyService" + ] + } + } + }, + "definitions": { + "dataproxyCreateUploadLocationRequest": { + "type": "object", + "properties": { + "project": { + "type": "string", + "title": "Project to create the upload location for.\n+required" + }, + "domain": { + "type": "string", + "title": "Domain to create the upload location for.\n+required" + }, + "filename": { + "type": "string", + "description": "Filename specifies the desired suffix for the generated location. E.g. `file.py` or `pre/fix/file.zip`.\n+optional. By default, the service generates a consistent name based on the default filename length provided in the global config.." + }, + "expires_in": { + "type": "string", + "description": "ExpiresIn defines the requested expiration duration for the generated URL. The request will be rejected if this\nexceeds the platform's configured maximum.\n+optional. The default value comes from the global config." + }, + "content_md5": { + "type": "string", + "format": "byte", + "title": "ContentMD5 restricts the upload location to the specific MD5 provided. The MD5 hash will also appear in the\ngenerated path for verification.\n+required" + }, + "filename_root": { + "type": "string", + "title": "FilenameRoot, if present, will be used instead of the MD5 hash in the path. When combined with filename,\nthis makes the upload location deterministic. The native URL will still be prefixed by the upload location prefix\nconfigured in the data proxy. This option is useful when uploading multiple related files.\n+optional" + }, + "add_content_md5_metadata": { + "type": "boolean", + "description": "If true, the data proxy will add content_md5 to the Signed URL requirements,\nforcing clients to send this checksum with the object.\nThis is required to enforce data integrity on backends like GCP, ensuring that\nthe uploaded file matches the hash." + }, + "org": { + "type": "string", + "title": "Org is the organization key applied to the resource.\n+optional" + }, + "content_length": { + "type": "string", + "format": "int64", + "title": "ContentLength specifies the size of the content to be uploaded in bytes.\nThis is validated against the platform's maximum upload size if provided.\n+optional" + } + }, + "description": "CreateUploadLocationRequest specifies the request for the CreateUploadLocation API.\nThe data proxy service will generate a storage location with server-side configured prefixes.\nThe generated path follows one of these patterns:\n - project/domain/(deterministic hash of content_md5)/filename (if filename is present); OR\n - project/domain/filename_root/filename (if filename_root and filename are present)." + }, + "dataproxyCreateUploadLocationResponse": { + "type": "object", + "properties": { + "signed_url": { + "type": "string", + "description": "SignedUrl is the URL to use for uploading content (e.g. https://my-bucket.s3.amazonaws.com/randomstring/suffix.tar?X-...)." + }, + "native_url": { + "type": "string", + "description": "NativeUrl is the URL in the format of the configured storage provider (e.g. s3://my-bucket/randomstring/suffix.tar)." + }, + "expires_at": { + "type": "string", + "format": "date-time", + "description": "ExpiresAt defines when the signed URL will expire." + }, + "headers": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Headers are generated by the data proxy for the client. Clients must include these headers in the upload request." + } + }, + "description": "CreateUploadLocationResponse specifies the response for the CreateUploadLocation API." + }, + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/event/cloudevents.swagger.json b/gen/go/gateway/flyteidl2/event/cloudevents.swagger.json new file mode 100644 index 0000000000..a54edf71fa --- /dev/null +++ b/gen/go/gateway/flyteidl2/event/cloudevents.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/event/cloudevents.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/event/event.swagger.json b/gen/go/gateway/flyteidl2/event/event.swagger.json new file mode 100644 index 0000000000..b6937c1ff6 --- /dev/null +++ b/gen/go/gateway/flyteidl2/event/event.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/event/event.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/imagebuilder/definition.swagger.json b/gen/go/gateway/flyteidl2/imagebuilder/definition.swagger.json new file mode 100644 index 0000000000..04873e7816 --- /dev/null +++ b/gen/go/gateway/flyteidl2/imagebuilder/definition.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/imagebuilder/definition.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/imagebuilder/payload.swagger.json b/gen/go/gateway/flyteidl2/imagebuilder/payload.swagger.json new file mode 100644 index 0000000000..b4e0de3b57 --- /dev/null +++ b/gen/go/gateway/flyteidl2/imagebuilder/payload.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/imagebuilder/payload.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/imagebuilder/service.swagger.json b/gen/go/gateway/flyteidl2/imagebuilder/service.swagger.json new file mode 100644 index 0000000000..29d1562307 --- /dev/null +++ b/gen/go/gateway/flyteidl2/imagebuilder/service.swagger.json @@ -0,0 +1,55 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/imagebuilder/service.proto", + "version": "version not set" + }, + "tags": [ + { + "name": "ImageService" + } + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/logs/dataplane/payload.swagger.json b/gen/go/gateway/flyteidl2/logs/dataplane/payload.swagger.json new file mode 100644 index 0000000000..8f85245483 --- /dev/null +++ b/gen/go/gateway/flyteidl2/logs/dataplane/payload.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/logs/dataplane/payload.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/plugins/common.swagger.json b/gen/go/gateway/flyteidl2/plugins/common.swagger.json new file mode 100644 index 0000000000..6159c03342 --- /dev/null +++ b/gen/go/gateway/flyteidl2/plugins/common.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/plugins/common.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/plugins/dask.swagger.json b/gen/go/gateway/flyteidl2/plugins/dask.swagger.json new file mode 100644 index 0000000000..d72fc77cf7 --- /dev/null +++ b/gen/go/gateway/flyteidl2/plugins/dask.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/plugins/dask.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/plugins/kubeflow/common.swagger.json b/gen/go/gateway/flyteidl2/plugins/kubeflow/common.swagger.json new file mode 100644 index 0000000000..5893395bfa --- /dev/null +++ b/gen/go/gateway/flyteidl2/plugins/kubeflow/common.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/plugins/kubeflow/common.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/plugins/kubeflow/mpi.swagger.json b/gen/go/gateway/flyteidl2/plugins/kubeflow/mpi.swagger.json new file mode 100644 index 0000000000..a900eab98f --- /dev/null +++ b/gen/go/gateway/flyteidl2/plugins/kubeflow/mpi.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/plugins/kubeflow/mpi.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/plugins/kubeflow/pytorch.swagger.json b/gen/go/gateway/flyteidl2/plugins/kubeflow/pytorch.swagger.json new file mode 100644 index 0000000000..1477b15565 --- /dev/null +++ b/gen/go/gateway/flyteidl2/plugins/kubeflow/pytorch.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/plugins/kubeflow/pytorch.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/plugins/kubeflow/tensorflow.swagger.json b/gen/go/gateway/flyteidl2/plugins/kubeflow/tensorflow.swagger.json new file mode 100644 index 0000000000..60cb2fa9b8 --- /dev/null +++ b/gen/go/gateway/flyteidl2/plugins/kubeflow/tensorflow.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/plugins/kubeflow/tensorflow.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/plugins/mpi.swagger.json b/gen/go/gateway/flyteidl2/plugins/mpi.swagger.json new file mode 100644 index 0000000000..b84935b7da --- /dev/null +++ b/gen/go/gateway/flyteidl2/plugins/mpi.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/plugins/mpi.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/plugins/presto.swagger.json b/gen/go/gateway/flyteidl2/plugins/presto.swagger.json new file mode 100644 index 0000000000..f78a0bac54 --- /dev/null +++ b/gen/go/gateway/flyteidl2/plugins/presto.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/plugins/presto.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/plugins/pytorch.swagger.json b/gen/go/gateway/flyteidl2/plugins/pytorch.swagger.json new file mode 100644 index 0000000000..4aa659a098 --- /dev/null +++ b/gen/go/gateway/flyteidl2/plugins/pytorch.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/plugins/pytorch.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/plugins/qubole.swagger.json b/gen/go/gateway/flyteidl2/plugins/qubole.swagger.json new file mode 100644 index 0000000000..7a1eca793a --- /dev/null +++ b/gen/go/gateway/flyteidl2/plugins/qubole.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/plugins/qubole.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/plugins/ray.swagger.json b/gen/go/gateway/flyteidl2/plugins/ray.swagger.json new file mode 100644 index 0000000000..0b5383c05b --- /dev/null +++ b/gen/go/gateway/flyteidl2/plugins/ray.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/plugins/ray.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/plugins/spark.swagger.json b/gen/go/gateway/flyteidl2/plugins/spark.swagger.json new file mode 100644 index 0000000000..2772525349 --- /dev/null +++ b/gen/go/gateway/flyteidl2/plugins/spark.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/plugins/spark.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/plugins/tensorflow.swagger.json b/gen/go/gateway/flyteidl2/plugins/tensorflow.swagger.json new file mode 100644 index 0000000000..7bfdd65db8 --- /dev/null +++ b/gen/go/gateway/flyteidl2/plugins/tensorflow.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/plugins/tensorflow.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/project/project_service.swagger.json b/gen/go/gateway/flyteidl2/project/project_service.swagger.json new file mode 100644 index 0000000000..1e1a4316a3 --- /dev/null +++ b/gen/go/gateway/flyteidl2/project/project_service.swagger.json @@ -0,0 +1,55 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/project/project_service.proto", + "version": "version not set" + }, + "tags": [ + { + "name": "ProjectService" + } + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/secret/definition.swagger.json b/gen/go/gateway/flyteidl2/secret/definition.swagger.json new file mode 100644 index 0000000000..0715ae2173 --- /dev/null +++ b/gen/go/gateway/flyteidl2/secret/definition.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/secret/definition.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/secret/payload.swagger.json b/gen/go/gateway/flyteidl2/secret/payload.swagger.json new file mode 100644 index 0000000000..8f588cdd72 --- /dev/null +++ b/gen/go/gateway/flyteidl2/secret/payload.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/secret/payload.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/secret/secret.pb.gw.go b/gen/go/gateway/flyteidl2/secret/secret.pb.gw.go new file mode 100644 index 0000000000..36d0087b81 --- /dev/null +++ b/gen/go/gateway/flyteidl2/secret/secret.pb.gw.go @@ -0,0 +1,620 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: flyteidl2/secret/secret.proto + +/* +Package secret is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package secret + +import ( + "context" + "io" + "net/http" + + extSecret "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/secret" + "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" + "github.com/grpc-ecosystem/grpc-gateway/v2/utilities" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" + "google.golang.org/protobuf/proto" +) + +// Suppress "imported and not used" errors +var _ codes.Code +var _ io.Reader +var _ status.Status +var _ = runtime.String +var _ = utilities.NewDoubleArray +var _ = metadata.Join + +func request_SecretService_CreateSecret_0(ctx context.Context, marshaler runtime.Marshaler, client extSecret.SecretServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extSecret.CreateSecretRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.CreateSecret(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_SecretService_CreateSecret_0(ctx context.Context, marshaler runtime.Marshaler, server extSecret.SecretServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extSecret.CreateSecretRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.CreateSecret(ctx, &protoReq) + return msg, metadata, err + +} + +func request_SecretService_UpdateSecret_0(ctx context.Context, marshaler runtime.Marshaler, client extSecret.SecretServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extSecret.UpdateSecretRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["id.name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id.name") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "id.name", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id.name", err) + } + + msg, err := client.UpdateSecret(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_SecretService_UpdateSecret_0(ctx context.Context, marshaler runtime.Marshaler, server extSecret.SecretServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extSecret.UpdateSecretRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["id.name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id.name") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "id.name", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id.name", err) + } + + msg, err := server.UpdateSecret(ctx, &protoReq) + return msg, metadata, err + +} + +var ( + filter_SecretService_GetSecret_0 = &utilities.DoubleArray{Encoding: map[string]int{"id": 0, "name": 1}, Base: []int{1, 2, 3, 2, 0, 0}, Check: []int{0, 1, 1, 2, 4, 3}} +) + +func request_SecretService_GetSecret_0(ctx context.Context, marshaler runtime.Marshaler, client extSecret.SecretServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extSecret.GetSecretRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["id.name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id.name") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "id.name", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id.name", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_SecretService_GetSecret_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.GetSecret(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_SecretService_GetSecret_0(ctx context.Context, marshaler runtime.Marshaler, server extSecret.SecretServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extSecret.GetSecretRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["id.name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id.name") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "id.name", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id.name", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_SecretService_GetSecret_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.GetSecret(ctx, &protoReq) + return msg, metadata, err + +} + +var ( + filter_SecretService_DeleteSecret_0 = &utilities.DoubleArray{Encoding: map[string]int{"id": 0, "name": 1}, Base: []int{1, 2, 3, 2, 0, 0}, Check: []int{0, 1, 1, 2, 4, 3}} +) + +func request_SecretService_DeleteSecret_0(ctx context.Context, marshaler runtime.Marshaler, client extSecret.SecretServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extSecret.DeleteSecretRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["id.name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id.name") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "id.name", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id.name", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_SecretService_DeleteSecret_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.DeleteSecret(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_SecretService_DeleteSecret_0(ctx context.Context, marshaler runtime.Marshaler, server extSecret.SecretServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extSecret.DeleteSecretRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["id.name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id.name") + } + + err = runtime.PopulateFieldFromPath(&protoReq, "id.name", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id.name", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_SecretService_DeleteSecret_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.DeleteSecret(ctx, &protoReq) + return msg, metadata, err + +} + +var ( + filter_SecretService_ListSecrets_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + +func request_SecretService_ListSecrets_0(ctx context.Context, marshaler runtime.Marshaler, client extSecret.SecretServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extSecret.ListSecretsRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_SecretService_ListSecrets_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.ListSecrets(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_SecretService_ListSecrets_0(ctx context.Context, marshaler runtime.Marshaler, server extSecret.SecretServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq extSecret.ListSecretsRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_SecretService_ListSecrets_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.ListSecrets(ctx, &protoReq) + return msg, metadata, err + +} + +// RegisterSecretServiceHandlerServer registers the http handlers for service SecretService to "mux". +// UnaryRPC :call SecretServiceServer directly. +// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterSecretServiceHandlerFromEndpoint instead. +func RegisterSecretServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server extSecret.SecretServiceServer) error { + + mux.Handle("POST", pattern_SecretService_CreateSecret_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/flyteidl2.secret.SecretService/CreateSecret", runtime.WithHTTPPathPattern("/secrets/api/v1")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SecretService_CreateSecret_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_SecretService_CreateSecret_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("PUT", pattern_SecretService_UpdateSecret_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/flyteidl2.secret.SecretService/UpdateSecret", runtime.WithHTTPPathPattern("/secrets/api/v1/name/{id.name}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SecretService_UpdateSecret_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_SecretService_UpdateSecret_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_SecretService_GetSecret_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/flyteidl2.secret.SecretService/GetSecret", runtime.WithHTTPPathPattern("/secrets/api/v1/name/{id.name}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SecretService_GetSecret_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_SecretService_GetSecret_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("DELETE", pattern_SecretService_DeleteSecret_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/flyteidl2.secret.SecretService/DeleteSecret", runtime.WithHTTPPathPattern("/secrets/api/v1/name/{id.name}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SecretService_DeleteSecret_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_SecretService_DeleteSecret_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_SecretService_ListSecrets_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/flyteidl2.secret.SecretService/ListSecrets", runtime.WithHTTPPathPattern("/secrets/api/v1")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SecretService_ListSecrets_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_SecretService_ListSecrets_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +// RegisterSecretServiceHandlerFromEndpoint is same as RegisterSecretServiceHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterSecretServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.DialContext(ctx, endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterSecretServiceHandler(ctx, mux, conn) +} + +// RegisterSecretServiceHandler registers the http handlers for service SecretService to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterSecretServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterSecretServiceHandlerClient(ctx, mux, extSecret.NewSecretServiceClient(conn)) +} + +// RegisterSecretServiceHandlerClient registers the http handlers for service SecretService +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "extSecret.SecretServiceClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "extSecret.SecretServiceClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "extSecret.SecretServiceClient" to call the correct interceptors. +func RegisterSecretServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client extSecret.SecretServiceClient) error { + + mux.Handle("POST", pattern_SecretService_CreateSecret_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/flyteidl2.secret.SecretService/CreateSecret", runtime.WithHTTPPathPattern("/secrets/api/v1")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SecretService_CreateSecret_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_SecretService_CreateSecret_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("PUT", pattern_SecretService_UpdateSecret_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/flyteidl2.secret.SecretService/UpdateSecret", runtime.WithHTTPPathPattern("/secrets/api/v1/name/{id.name}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SecretService_UpdateSecret_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_SecretService_UpdateSecret_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_SecretService_GetSecret_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/flyteidl2.secret.SecretService/GetSecret", runtime.WithHTTPPathPattern("/secrets/api/v1/name/{id.name}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SecretService_GetSecret_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_SecretService_GetSecret_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("DELETE", pattern_SecretService_DeleteSecret_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/flyteidl2.secret.SecretService/DeleteSecret", runtime.WithHTTPPathPattern("/secrets/api/v1/name/{id.name}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SecretService_DeleteSecret_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_SecretService_DeleteSecret_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_SecretService_ListSecrets_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/flyteidl2.secret.SecretService/ListSecrets", runtime.WithHTTPPathPattern("/secrets/api/v1")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SecretService_ListSecrets_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_SecretService_ListSecrets_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_SecretService_CreateSecret_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"secrets", "api", "v1"}, "")) + + pattern_SecretService_UpdateSecret_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"secrets", "api", "v1", "name", "id.name"}, "")) + + pattern_SecretService_GetSecret_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"secrets", "api", "v1", "name", "id.name"}, "")) + + pattern_SecretService_DeleteSecret_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"secrets", "api", "v1", "name", "id.name"}, "")) + + pattern_SecretService_ListSecrets_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"secrets", "api", "v1"}, "")) +) + +var ( + forward_SecretService_CreateSecret_0 = runtime.ForwardResponseMessage + + forward_SecretService_UpdateSecret_0 = runtime.ForwardResponseMessage + + forward_SecretService_GetSecret_0 = runtime.ForwardResponseMessage + + forward_SecretService_DeleteSecret_0 = runtime.ForwardResponseMessage + + forward_SecretService_ListSecrets_0 = runtime.ForwardResponseMessage +) diff --git a/gen/go/gateway/flyteidl2/secret/secret.swagger.json b/gen/go/gateway/flyteidl2/secret/secret.swagger.json new file mode 100644 index 0000000000..98ebefbba2 --- /dev/null +++ b/gen/go/gateway/flyteidl2/secret/secret.swagger.json @@ -0,0 +1,514 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/secret/secret.proto", + "version": "version not set" + }, + "tags": [ + { + "name": "SecretService" + } + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/secrets/api/v1": { + "get": { + "operationId": "SecretService_ListSecrets", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/secretListSecretsResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + }, + "parameters": [ + { + "name": "organization", + "description": "Only org scoped resources are supported right now", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "domain", + "description": "domain scoped secret", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "project", + "description": "Project-domain scoped secret", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "limit", + "description": "Max page results", + "in": "query", + "required": false, + "type": "integer", + "format": "int32" + }, + { + "name": "token", + "description": "Leave this empty if you are getting the first set of results. The next_token would be set in the response that can be used to fetch the next set of results.", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "per_cluster_tokens[string]", + "description": "Per cluster token. This allows the service to return paginated results per cluster.\nService collates the results from all clusters and returns the next token for each cluster.\nThe client can use the next token for each cluster to fetch the next page of results.\nIn multi cluster, inorder to page through next set of results, client needs to send this token in the next request", + "in": "query", + "required": false, + "type": "string" + } + ], + "tags": [ + "SecretService" + ] + }, + "post": { + "operationId": "SecretService_CreateSecret", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/secretCreateSecretResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/secretCreateSecretRequest" + } + } + ], + "tags": [ + "SecretService" + ] + } + }, + "/secrets/api/v1/name/{id.name}": { + "get": { + "operationId": "SecretService_GetSecret", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/secretGetSecretResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + }, + "parameters": [ + { + "name": "id.name", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id.organization", + "description": "Only org scoped resources are supported right now", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "id.domain", + "description": "domain scoped secret", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "id.project", + "description": "Project-domain scoped secret", + "in": "query", + "required": false, + "type": "string" + } + ], + "tags": [ + "SecretService" + ] + }, + "delete": { + "operationId": "SecretService_DeleteSecret", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/secretDeleteSecretResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + }, + "parameters": [ + { + "name": "id.name", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id.organization", + "description": "Only org scoped resources are supported right now", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "id.domain", + "description": "domain scoped secret", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "id.project", + "description": "Project-domain scoped secret", + "in": "query", + "required": false, + "type": "string" + } + ], + "tags": [ + "SecretService" + ] + }, + "put": { + "operationId": "SecretService_UpdateSecret", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/secretUpdateSecretResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + }, + "parameters": [ + { + "name": "id.name", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/SecretServiceUpdateSecretBody" + } + } + ], + "tags": [ + "SecretService" + ] + } + } + }, + "definitions": { + "SecretServiceUpdateSecretBody": { + "type": "object", + "properties": { + "id": { + "type": "object", + "properties": { + "organization": { + "type": "string", + "title": "Only org scoped resources are supported right now" + }, + "domain": { + "type": "string", + "title": "domain scoped secret" + }, + "project": { + "type": "string", + "title": "Project-domain scoped secret" + } + }, + "title": "SecretIdentifier contains the uniquely identifiable way of storing or retrieving the secret\nName and scope combination are used for defining the format for storage and retrieval of the secret\nFor eg : for org scope secrets\nstorage format org:\u003corg-name\u003e:name:secret-name" + }, + "secret_spec": { + "$ref": "#/definitions/secretSecretSpec" + } + }, + "title": "UpdateSecretProxyRequest contains the spec and identifier used for secret updation" + }, + "commonClusterIdentifier": { + "type": "object", + "properties": { + "organization": { + "type": "string" + }, + "name": { + "type": "string" + } + } + }, + "flyteidl2secretSecret": { + "type": "object", + "properties": { + "id": { + "$ref": "#/definitions/secretSecretIdentifier" + }, + "secret_metadata": { + "$ref": "#/definitions/secretSecretMetadata" + } + }, + "title": "Secret is the returned object for Get and List calls which returns the identifier of the secret along with\nmeta information in future about the creation data, update date, tags etc\nThis doesn't contain the value of the secret" + }, + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "secretClusterSecretStatus": { + "type": "object", + "properties": { + "cluster": { + "$ref": "#/definitions/commonClusterIdentifier" + }, + "presence_status": { + "$ref": "#/definitions/secretSecretPresenceStatus", + "title": "presence_status reports the status of the secret in the cluster" + } + }, + "title": "ClusterSecretStatus contains the status of the secret in a cluster" + }, + "secretCreateSecretRequest": { + "type": "object", + "properties": { + "id": { + "$ref": "#/definitions/secretSecretIdentifier" + }, + "secret_spec": { + "$ref": "#/definitions/secretSecretSpec" + } + }, + "title": "CreateSecretProxyRequest contains the spec and identifier used for secret creation" + }, + "secretCreateSecretResponse": { + "type": "object", + "title": "CreateSecretResponse" + }, + "secretDeleteSecretResponse": { + "type": "object", + "description": "DeleteSecretResponse is an empty response right now on successfully deleting the secret." + }, + "secretGetSecretResponse": { + "type": "object", + "properties": { + "secret": { + "$ref": "#/definitions/flyteidl2secretSecret" + } + }, + "title": "GetSecretProxyResponse returns the looked up secret from the secret service" + }, + "secretListSecretsResponse": { + "type": "object", + "properties": { + "secrets": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/flyteidl2secretSecret" + } + }, + "token": { + "type": "string", + "description": "next token to use for fetching new page results." + }, + "per_cluster_tokens": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "title": "Per cluster token. This allows the service to return paginated results per cluster.\nService collates the results from all clusters and returns the next token for each cluster.\nThe client can use the next token for each cluster to fetch the next page of results.\nIn multi cluster, inorder to page through next set of results, client needs to send this token in the next request" + } + }, + "description": "ListSecretsResponse returns paginated results of the accessible secrets at the scope defined in the request." + }, + "secretOverallStatus": { + "type": "string", + "enum": [ + "UNSPECIFIED", + "PARTIALLY_PRESENT", + "FULLY_PRESENT", + "UNKNOWN_STATUS" + ], + "default": "UNSPECIFIED", + "title": "- PARTIALLY_PRESENT: Exists in some cluster\n - FULLY_PRESENT: Exists in all enabled clusters\n - UNKNOWN_STATUS: Status is unknown" + }, + "secretSecretIdentifier": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "organization": { + "type": "string", + "title": "Only org scoped resources are supported right now" + }, + "domain": { + "type": "string", + "title": "domain scoped secret" + }, + "project": { + "type": "string", + "title": "Project-domain scoped secret" + } + }, + "title": "SecretIdentifier contains the uniquely identifiable way of storing or retrieving the secret\nName and scope combination are used for defining the format for storage and retrieval of the secret\nFor eg : for org scope secrets\nstorage format org:\u003corg-name\u003e:name:secret-name" + }, + "secretSecretMetadata": { + "type": "object", + "properties": { + "created_time": { + "type": "string", + "format": "date-time", + "description": "created_time of the secret." + }, + "secret_status": { + "$ref": "#/definitions/secretSecretStatus", + "description": "secret_status reports the overall status of the secret across all the clusters.\nThis relies on number of clusters queried which relies on there enabled state." + }, + "type": { + "$ref": "#/definitions/secretSecretType", + "title": "The secret type" + } + }, + "title": "SecretMetadata contain meta info about the secret" + }, + "secretSecretPresenceStatus": { + "type": "string", + "enum": [ + "UNKNOWN", + "MISSING", + "PRESENT" + ], + "default": "UNKNOWN", + "title": "- MISSING: Secret is missing in the cluster\n - PRESENT: Secret is present in the cluster" + }, + "secretSecretSpec": { + "type": "object", + "properties": { + "string_value": { + "type": "string" + }, + "binary_value": { + "type": "string", + "format": "byte" + }, + "type": { + "$ref": "#/definitions/secretSecretType", + "title": "The secret type" + } + }, + "description": "SecretSpec contains information used for creating/updating the secret.\nMainly it contains the value of the secret\nIn future we could add meta info like tags, rotation config, whether stored secret has any binary format etc for storage/retrieval." + }, + "secretSecretStatus": { + "type": "object", + "properties": { + "overall_status": { + "$ref": "#/definitions/secretOverallStatus", + "description": "overall_status reports the overall status of the secret across all the clusters." + }, + "cluster_status": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/secretClusterSecretStatus" + }, + "title": "cluster_status reports the status of the secret in each cluster" + } + }, + "title": "SecretStatus contains the status of the secret across all the clusters" + }, + "secretSecretType": { + "type": "string", + "enum": [ + "SECRET_TYPE_GENERIC", + "SECRET_TYPE_IMAGE_PULL_SECRET" + ], + "default": "SECRET_TYPE_GENERIC", + "description": " - SECRET_TYPE_GENERIC: Default, unspecified secret type. Assumed to be generic and no type specific handling required.\n - SECRET_TYPE_IMAGE_PULL_SECRET: Secret used specifically for pulling images from a container registry." + }, + "secretUpdateSecretResponse": { + "type": "object", + "title": "UpdateSecretResponse returns an empty response if the secret is successfully updated" + } + } +} diff --git a/gen/go/gateway/flyteidl2/task/common.swagger.json b/gen/go/gateway/flyteidl2/task/common.swagger.json new file mode 100644 index 0000000000..d359667f71 --- /dev/null +++ b/gen/go/gateway/flyteidl2/task/common.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/task/common.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/task/environment.swagger.json b/gen/go/gateway/flyteidl2/task/environment.swagger.json new file mode 100644 index 0000000000..cf569acb6f --- /dev/null +++ b/gen/go/gateway/flyteidl2/task/environment.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/task/environment.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/task/run.swagger.json b/gen/go/gateway/flyteidl2/task/run.swagger.json new file mode 100644 index 0000000000..68bf98960f --- /dev/null +++ b/gen/go/gateway/flyteidl2/task/run.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/task/run.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/task/task_definition.swagger.json b/gen/go/gateway/flyteidl2/task/task_definition.swagger.json new file mode 100644 index 0000000000..3aab33f9b1 --- /dev/null +++ b/gen/go/gateway/flyteidl2/task/task_definition.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/task/task_definition.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/task/task_service.swagger.json b/gen/go/gateway/flyteidl2/task/task_service.swagger.json new file mode 100644 index 0000000000..438b264497 --- /dev/null +++ b/gen/go/gateway/flyteidl2/task/task_service.swagger.json @@ -0,0 +1,55 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/task/task_service.proto", + "version": "version not set" + }, + "tags": [ + { + "name": "TaskService" + } + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/trigger/trigger_definition.swagger.json b/gen/go/gateway/flyteidl2/trigger/trigger_definition.swagger.json new file mode 100644 index 0000000000..1cd16ebb7e --- /dev/null +++ b/gen/go/gateway/flyteidl2/trigger/trigger_definition.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/trigger/trigger_definition.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/trigger/trigger_service.swagger.json b/gen/go/gateway/flyteidl2/trigger/trigger_service.swagger.json new file mode 100644 index 0000000000..1f77cb6cda --- /dev/null +++ b/gen/go/gateway/flyteidl2/trigger/trigger_service.swagger.json @@ -0,0 +1,55 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/trigger/trigger_service.proto", + "version": "version not set" + }, + "tags": [ + { + "name": "TriggerService" + } + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/workflow/queue_service.swagger.json b/gen/go/gateway/flyteidl2/workflow/queue_service.swagger.json new file mode 100644 index 0000000000..f35decd5cd --- /dev/null +++ b/gen/go/gateway/flyteidl2/workflow/queue_service.swagger.json @@ -0,0 +1,55 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/workflow/queue_service.proto", + "version": "version not set" + }, + "tags": [ + { + "name": "QueueService" + } + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/workflow/run_definition.swagger.json b/gen/go/gateway/flyteidl2/workflow/run_definition.swagger.json new file mode 100644 index 0000000000..56a0de298d --- /dev/null +++ b/gen/go/gateway/flyteidl2/workflow/run_definition.swagger.json @@ -0,0 +1,50 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/workflow/run_definition.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/workflow/run_logs_service.swagger.json b/gen/go/gateway/flyteidl2/workflow/run_logs_service.swagger.json new file mode 100644 index 0000000000..00921bfdac --- /dev/null +++ b/gen/go/gateway/flyteidl2/workflow/run_logs_service.swagger.json @@ -0,0 +1,55 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/workflow/run_logs_service.proto", + "version": "version not set" + }, + "tags": [ + { + "name": "RunLogsService" + } + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/workflow/run_service.swagger.json b/gen/go/gateway/flyteidl2/workflow/run_service.swagger.json new file mode 100644 index 0000000000..cd43de0cae --- /dev/null +++ b/gen/go/gateway/flyteidl2/workflow/run_service.swagger.json @@ -0,0 +1,55 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/workflow/run_service.proto", + "version": "version not set" + }, + "tags": [ + { + "name": "RunService" + } + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/workflow/state_service.swagger.json b/gen/go/gateway/flyteidl2/workflow/state_service.swagger.json new file mode 100644 index 0000000000..22b76f9d68 --- /dev/null +++ b/gen/go/gateway/flyteidl2/workflow/state_service.swagger.json @@ -0,0 +1,55 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/workflow/state_service.proto", + "version": "version not set" + }, + "tags": [ + { + "name": "StateService" + } + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/go/gateway/flyteidl2/workflow/translator_service.swagger.json b/gen/go/gateway/flyteidl2/workflow/translator_service.swagger.json new file mode 100644 index 0000000000..34b28f4df3 --- /dev/null +++ b/gen/go/gateway/flyteidl2/workflow/translator_service.swagger.json @@ -0,0 +1,55 @@ +{ + "swagger": "2.0", + "info": { + "title": "flyteidl2/workflow/translator_service.proto", + "version": "version not set" + }, + "tags": [ + { + "name": "TranslatorService" + } + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": {}, + "definitions": { + "googlerpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32", + "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]." + }, + "message": { + "type": "string", + "description": "A developer-facing error message, which should be in English. Any\nuser-facing error message should be localized and sent in the\n[google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client." + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/protobufAny" + }, + "description": "A list of messages that carry the error details. There is a common set of\nmessage types for APIs to use." + } + }, + "description": "The `Status` type defines a logical error model that is suitable for\ndifferent programming environments, including REST APIs and RPC APIs. It is\nused by [gRPC](https://github.com/grpc). Each `Status` message contains\nthree pieces of data: error code, error message, and error details.\n\nYou can find out more about this error model and how to work with it in the\n[API Design Guide](https://cloud.google.com/apis/design/errors)." + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + } + }, + "additionalProperties": {}, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n // or ...\n if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n foo = any.unpack(Foo.getDefaultInstance());\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := anypb.New(foo)\n if err != nil {\n ...\n }\n ...\n foo := \u0026pb.Foo{}\n if err := any.UnmarshalTo(foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } +} diff --git a/gen/python/README.md b/gen/python/README.md new file mode 100644 index 0000000000..cae843b7a3 --- /dev/null +++ b/gen/python/README.md @@ -0,0 +1 @@ +# Python library of flyte IDL (protobuf) \ No newline at end of file diff --git a/gen/python/__init__.py b/gen/python/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/buf/__init__.py b/gen/python/buf/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/buf/validate/__init__.py b/gen/python/buf/validate/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/buf/validate/validate_pb2.py b/gen/python/buf/validate/validate_pb2.py new file mode 100644 index 0000000000..7fcfdd96c4 --- /dev/null +++ b/gen/python/buf/validate/validate_pb2.py @@ -0,0 +1,439 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: buf/validate/validate.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2 +from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1b\x62uf/validate/validate.proto\x12\x0c\x62uf.validate\x1a google/protobuf/descriptor.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"P\n\x04Rule\x12\x0e\n\x02id\x18\x01 \x01(\tR\x02id\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\x12\x1e\n\nexpression\x18\x03 \x01(\tR\nexpression\"z\n\x0cMessageRules\x12$\n\x03\x63\x65l\x18\x03 \x03(\x0b\x32\x12.buf.validate.RuleR\x03\x63\x65l\x12\x34\n\x05oneof\x18\x04 \x03(\x0b\x32\x1e.buf.validate.MessageOneofRuleR\x05oneofJ\x04\x08\x01\x10\x02R\x08\x64isabled\"F\n\x10MessageOneofRule\x12\x16\n\x06\x66ields\x18\x01 \x03(\tR\x06\x66ields\x12\x1a\n\x08required\x18\x02 \x01(\x08R\x08required\"(\n\nOneofRules\x12\x1a\n\x08required\x18\x01 \x01(\x08R\x08required\"\xfd\t\n\nFieldRules\x12$\n\x03\x63\x65l\x18\x17 \x03(\x0b\x32\x12.buf.validate.RuleR\x03\x63\x65l\x12\x1a\n\x08required\x18\x19 \x01(\x08R\x08required\x12,\n\x06ignore\x18\x1b \x01(\x0e\x32\x14.buf.validate.IgnoreR\x06ignore\x12\x30\n\x05\x66loat\x18\x01 \x01(\x0b\x32\x18.buf.validate.FloatRulesH\x00R\x05\x66loat\x12\x33\n\x06\x64ouble\x18\x02 \x01(\x0b\x32\x19.buf.validate.DoubleRulesH\x00R\x06\x64ouble\x12\x30\n\x05int32\x18\x03 \x01(\x0b\x32\x18.buf.validate.Int32RulesH\x00R\x05int32\x12\x30\n\x05int64\x18\x04 \x01(\x0b\x32\x18.buf.validate.Int64RulesH\x00R\x05int64\x12\x33\n\x06uint32\x18\x05 \x01(\x0b\x32\x19.buf.validate.UInt32RulesH\x00R\x06uint32\x12\x33\n\x06uint64\x18\x06 \x01(\x0b\x32\x19.buf.validate.UInt64RulesH\x00R\x06uint64\x12\x33\n\x06sint32\x18\x07 \x01(\x0b\x32\x19.buf.validate.SInt32RulesH\x00R\x06sint32\x12\x33\n\x06sint64\x18\x08 \x01(\x0b\x32\x19.buf.validate.SInt64RulesH\x00R\x06sint64\x12\x36\n\x07\x66ixed32\x18\t \x01(\x0b\x32\x1a.buf.validate.Fixed32RulesH\x00R\x07\x66ixed32\x12\x36\n\x07\x66ixed64\x18\n \x01(\x0b\x32\x1a.buf.validate.Fixed64RulesH\x00R\x07\x66ixed64\x12\x39\n\x08sfixed32\x18\x0b \x01(\x0b\x32\x1b.buf.validate.SFixed32RulesH\x00R\x08sfixed32\x12\x39\n\x08sfixed64\x18\x0c \x01(\x0b\x32\x1b.buf.validate.SFixed64RulesH\x00R\x08sfixed64\x12-\n\x04\x62ool\x18\r \x01(\x0b\x32\x17.buf.validate.BoolRulesH\x00R\x04\x62ool\x12\x33\n\x06string\x18\x0e \x01(\x0b\x32\x19.buf.validate.StringRulesH\x00R\x06string\x12\x30\n\x05\x62ytes\x18\x0f \x01(\x0b\x32\x18.buf.validate.BytesRulesH\x00R\x05\x62ytes\x12-\n\x04\x65num\x18\x10 \x01(\x0b\x32\x17.buf.validate.EnumRulesH\x00R\x04\x65num\x12\x39\n\x08repeated\x18\x12 \x01(\x0b\x32\x1b.buf.validate.RepeatedRulesH\x00R\x08repeated\x12*\n\x03map\x18\x13 \x01(\x0b\x32\x16.buf.validate.MapRulesH\x00R\x03map\x12*\n\x03\x61ny\x18\x14 \x01(\x0b\x32\x16.buf.validate.AnyRulesH\x00R\x03\x61ny\x12\x39\n\x08\x64uration\x18\x15 \x01(\x0b\x32\x1b.buf.validate.DurationRulesH\x00R\x08\x64uration\x12<\n\ttimestamp\x18\x16 \x01(\x0b\x32\x1c.buf.validate.TimestampRulesH\x00R\ttimestampB\x06\n\x04typeJ\x04\x08\x18\x10\x19J\x04\x08\x1a\x10\x1bR\x07skippedR\x0cignore_empty\"Z\n\x0fPredefinedRules\x12$\n\x03\x63\x65l\x18\x01 \x03(\x0b\x32\x12.buf.validate.RuleR\x03\x63\x65lJ\x04\x08\x18\x10\x19J\x04\x08\x1a\x10\x1bR\x07skippedR\x0cignore_empty\"\x90\x18\n\nFloatRules\x12\x8a\x01\n\x05\x63onst\x18\x01 \x01(\x02\x42t\xc2Hq\no\n\x0b\x66loat.const\x1a`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'R\x05\x63onst\x12\xa3\x01\n\x02lt\x18\x02 \x01(\x02\x42\x90\x01\xc2H\x8c\x01\n\x89\x01\n\x08\x66loat.lt\x1a}!has(rules.gte) && !has(rules.gt) && (this.isNan() || this >= rules.lt)? \'value must be less than %s\'.format([rules.lt]) : \'\'H\x00R\x02lt\x12\xb4\x01\n\x03lte\x18\x03 \x01(\x02\x42\x9f\x01\xc2H\x9b\x01\n\x98\x01\n\tfloat.lte\x1a\x8a\x01!has(rules.gte) && !has(rules.gt) && (this.isNan() || this > rules.lte)? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'H\x00R\x03lte\x12\xf3\x07\n\x02gt\x18\x04 \x01(\x02\x42\xe0\x07\xc2H\xdc\x07\n\x8d\x01\n\x08\x66loat.gt\x1a\x80\x01!has(rules.lt) && !has(rules.lte) && (this.isNan() || this <= rules.gt)? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\xc3\x01\n\x0b\x66loat.gt_lt\x1a\xb3\x01has(rules.lt) && rules.lt >= rules.gt && (this.isNan() || this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xcd\x01\n\x15\x66loat.gt_lt_exclusive\x1a\xb3\x01has(rules.lt) && rules.lt < rules.gt && (this.isNan() || (rules.lt <= this && this <= rules.gt))? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xd3\x01\n\x0c\x66loat.gt_lte\x1a\xc2\x01has(rules.lte) && rules.lte >= rules.gt && (this.isNan() || this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\xdd\x01\n\x16\x66loat.gt_lte_exclusive\x1a\xc2\x01has(rules.lte) && rules.lte < rules.gt && (this.isNan() || (rules.lte < this && this <= rules.gt))? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'H\x01R\x02gt\x12\xbf\x08\n\x03gte\x18\x05 \x01(\x02\x42\xaa\x08\xc2H\xa6\x08\n\x9b\x01\n\tfloat.gte\x1a\x8d\x01!has(rules.lt) && !has(rules.lte) && (this.isNan() || this < rules.gte)? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\xd2\x01\n\x0c\x66loat.gte_lt\x1a\xc1\x01has(rules.lt) && rules.lt >= rules.gte && (this.isNan() || this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xdc\x01\n\x16\x66loat.gte_lt_exclusive\x1a\xc1\x01has(rules.lt) && rules.lt < rules.gte && (this.isNan() || (rules.lt <= this && this < rules.gte))? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xe2\x01\n\rfloat.gte_lte\x1a\xd0\x01has(rules.lte) && rules.lte >= rules.gte && (this.isNan() || this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\xec\x01\n\x17\x66loat.gte_lte_exclusive\x1a\xd0\x01has(rules.lte) && rules.lte < rules.gte && (this.isNan() || (rules.lte < this && this < rules.gte))? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'H\x01R\x03gte\x12\x83\x01\n\x02in\x18\x06 \x03(\x02\x42s\xc2Hp\nn\n\x08\x66loat.in\x1a\x62!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'R\x02in\x12}\n\x06not_in\x18\x07 \x03(\x02\x42\x66\xc2Hc\na\n\x0c\x66loat.not_in\x1aQthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'R\x05notIn\x12}\n\x06\x66inite\x18\x08 \x01(\x08\x42\x65\xc2Hb\n`\n\x0c\x66loat.finite\x1aPrules.finite ? (this.isNan() || this.isInf() ? \'value must be finite\' : \'\') : \'\'R\x06\x66inite\x12\x34\n\x07\x65xample\x18\t \x03(\x02\x42\x1a\xc2H\x17\n\x15\n\rfloat.example\x1a\x04trueR\x07\x65xample*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\x42\x0b\n\tless_thanB\x0e\n\x0cgreater_than\"\xa2\x18\n\x0b\x44oubleRules\x12\x8b\x01\n\x05\x63onst\x18\x01 \x01(\x01\x42u\xc2Hr\np\n\x0c\x64ouble.const\x1a`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'R\x05\x63onst\x12\xa4\x01\n\x02lt\x18\x02 \x01(\x01\x42\x91\x01\xc2H\x8d\x01\n\x8a\x01\n\tdouble.lt\x1a}!has(rules.gte) && !has(rules.gt) && (this.isNan() || this >= rules.lt)? \'value must be less than %s\'.format([rules.lt]) : \'\'H\x00R\x02lt\x12\xb5\x01\n\x03lte\x18\x03 \x01(\x01\x42\xa0\x01\xc2H\x9c\x01\n\x99\x01\n\ndouble.lte\x1a\x8a\x01!has(rules.gte) && !has(rules.gt) && (this.isNan() || this > rules.lte)? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'H\x00R\x03lte\x12\xf8\x07\n\x02gt\x18\x04 \x01(\x01\x42\xe5\x07\xc2H\xe1\x07\n\x8e\x01\n\tdouble.gt\x1a\x80\x01!has(rules.lt) && !has(rules.lte) && (this.isNan() || this <= rules.gt)? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\xc4\x01\n\x0c\x64ouble.gt_lt\x1a\xb3\x01has(rules.lt) && rules.lt >= rules.gt && (this.isNan() || this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xce\x01\n\x16\x64ouble.gt_lt_exclusive\x1a\xb3\x01has(rules.lt) && rules.lt < rules.gt && (this.isNan() || (rules.lt <= this && this <= rules.gt))? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xd4\x01\n\rdouble.gt_lte\x1a\xc2\x01has(rules.lte) && rules.lte >= rules.gt && (this.isNan() || this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\xde\x01\n\x17\x64ouble.gt_lte_exclusive\x1a\xc2\x01has(rules.lte) && rules.lte < rules.gt && (this.isNan() || (rules.lte < this && this <= rules.gt))? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'H\x01R\x02gt\x12\xc4\x08\n\x03gte\x18\x05 \x01(\x01\x42\xaf\x08\xc2H\xab\x08\n\x9c\x01\n\ndouble.gte\x1a\x8d\x01!has(rules.lt) && !has(rules.lte) && (this.isNan() || this < rules.gte)? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\xd3\x01\n\rdouble.gte_lt\x1a\xc1\x01has(rules.lt) && rules.lt >= rules.gte && (this.isNan() || this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xdd\x01\n\x17\x64ouble.gte_lt_exclusive\x1a\xc1\x01has(rules.lt) && rules.lt < rules.gte && (this.isNan() || (rules.lt <= this && this < rules.gte))? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xe3\x01\n\x0e\x64ouble.gte_lte\x1a\xd0\x01has(rules.lte) && rules.lte >= rules.gte && (this.isNan() || this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\xed\x01\n\x18\x64ouble.gte_lte_exclusive\x1a\xd0\x01has(rules.lte) && rules.lte < rules.gte && (this.isNan() || (rules.lte < this && this < rules.gte))? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'H\x01R\x03gte\x12\x84\x01\n\x02in\x18\x06 \x03(\x01\x42t\xc2Hq\no\n\tdouble.in\x1a\x62!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'R\x02in\x12~\n\x06not_in\x18\x07 \x03(\x01\x42g\xc2Hd\nb\n\rdouble.not_in\x1aQthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'R\x05notIn\x12~\n\x06\x66inite\x18\x08 \x01(\x08\x42\x66\xc2Hc\na\n\rdouble.finite\x1aPrules.finite ? (this.isNan() || this.isInf() ? \'value must be finite\' : \'\') : \'\'R\x06\x66inite\x12\x35\n\x07\x65xample\x18\t \x03(\x01\x42\x1b\xc2H\x18\n\x16\n\x0e\x64ouble.example\x1a\x04trueR\x07\x65xample*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\x42\x0b\n\tless_thanB\x0e\n\x0cgreater_than\"\xba\x15\n\nInt32Rules\x12\x8a\x01\n\x05\x63onst\x18\x01 \x01(\x05\x42t\xc2Hq\no\n\x0bint32.const\x1a`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'R\x05\x63onst\x12\x8e\x01\n\x02lt\x18\x02 \x01(\x05\x42|\xc2Hy\nw\n\x08int32.lt\x1ak!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'H\x00R\x02lt\x12\xa1\x01\n\x03lte\x18\x03 \x01(\x05\x42\x8c\x01\xc2H\x88\x01\n\x85\x01\n\tint32.lte\x1ax!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'H\x00R\x03lte\x12\x9b\x07\n\x02gt\x18\x04 \x01(\x05\x42\x88\x07\xc2H\x84\x07\nz\n\x08int32.gt\x1an!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\xb3\x01\n\x0bint32.gt_lt\x1a\xa3\x01has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xbb\x01\n\x15int32.gt_lt_exclusive\x1a\xa1\x01has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xc3\x01\n\x0cint32.gt_lte\x1a\xb2\x01has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\xcb\x01\n\x16int32.gt_lte_exclusive\x1a\xb0\x01has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'H\x01R\x02gt\x12\xe8\x07\n\x03gte\x18\x05 \x01(\x05\x42\xd3\x07\xc2H\xcf\x07\n\x88\x01\n\tint32.gte\x1a{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\xc2\x01\n\x0cint32.gte_lt\x1a\xb1\x01has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xca\x01\n\x16int32.gte_lt_exclusive\x1a\xaf\x01has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xd2\x01\n\rint32.gte_lte\x1a\xc0\x01has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\xda\x01\n\x17int32.gte_lte_exclusive\x1a\xbe\x01has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'H\x01R\x03gte\x12\x83\x01\n\x02in\x18\x06 \x03(\x05\x42s\xc2Hp\nn\n\x08int32.in\x1a\x62!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'R\x02in\x12}\n\x06not_in\x18\x07 \x03(\x05\x42\x66\xc2Hc\na\n\x0cint32.not_in\x1aQthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'R\x05notIn\x12\x34\n\x07\x65xample\x18\x08 \x03(\x05\x42\x1a\xc2H\x17\n\x15\n\rint32.example\x1a\x04trueR\x07\x65xample*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\x42\x0b\n\tless_thanB\x0e\n\x0cgreater_than\"\xba\x15\n\nInt64Rules\x12\x8a\x01\n\x05\x63onst\x18\x01 \x01(\x03\x42t\xc2Hq\no\n\x0bint64.const\x1a`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'R\x05\x63onst\x12\x8e\x01\n\x02lt\x18\x02 \x01(\x03\x42|\xc2Hy\nw\n\x08int64.lt\x1ak!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'H\x00R\x02lt\x12\xa1\x01\n\x03lte\x18\x03 \x01(\x03\x42\x8c\x01\xc2H\x88\x01\n\x85\x01\n\tint64.lte\x1ax!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'H\x00R\x03lte\x12\x9b\x07\n\x02gt\x18\x04 \x01(\x03\x42\x88\x07\xc2H\x84\x07\nz\n\x08int64.gt\x1an!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\xb3\x01\n\x0bint64.gt_lt\x1a\xa3\x01has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xbb\x01\n\x15int64.gt_lt_exclusive\x1a\xa1\x01has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xc3\x01\n\x0cint64.gt_lte\x1a\xb2\x01has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\xcb\x01\n\x16int64.gt_lte_exclusive\x1a\xb0\x01has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'H\x01R\x02gt\x12\xe8\x07\n\x03gte\x18\x05 \x01(\x03\x42\xd3\x07\xc2H\xcf\x07\n\x88\x01\n\tint64.gte\x1a{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\xc2\x01\n\x0cint64.gte_lt\x1a\xb1\x01has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xca\x01\n\x16int64.gte_lt_exclusive\x1a\xaf\x01has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xd2\x01\n\rint64.gte_lte\x1a\xc0\x01has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\xda\x01\n\x17int64.gte_lte_exclusive\x1a\xbe\x01has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'H\x01R\x03gte\x12\x83\x01\n\x02in\x18\x06 \x03(\x03\x42s\xc2Hp\nn\n\x08int64.in\x1a\x62!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'R\x02in\x12}\n\x06not_in\x18\x07 \x03(\x03\x42\x66\xc2Hc\na\n\x0cint64.not_in\x1aQthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'R\x05notIn\x12\x34\n\x07\x65xample\x18\t \x03(\x03\x42\x1a\xc2H\x17\n\x15\n\rint64.example\x1a\x04trueR\x07\x65xample*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\x42\x0b\n\tless_thanB\x0e\n\x0cgreater_than\"\xcb\x15\n\x0bUInt32Rules\x12\x8b\x01\n\x05\x63onst\x18\x01 \x01(\rBu\xc2Hr\np\n\x0cuint32.const\x1a`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'R\x05\x63onst\x12\x8f\x01\n\x02lt\x18\x02 \x01(\rB}\xc2Hz\nx\n\tuint32.lt\x1ak!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'H\x00R\x02lt\x12\xa2\x01\n\x03lte\x18\x03 \x01(\rB\x8d\x01\xc2H\x89\x01\n\x86\x01\n\nuint32.lte\x1ax!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'H\x00R\x03lte\x12\xa0\x07\n\x02gt\x18\x04 \x01(\rB\x8d\x07\xc2H\x89\x07\n{\n\tuint32.gt\x1an!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\xb4\x01\n\x0cuint32.gt_lt\x1a\xa3\x01has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xbc\x01\n\x16uint32.gt_lt_exclusive\x1a\xa1\x01has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xc4\x01\n\ruint32.gt_lte\x1a\xb2\x01has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\xcc\x01\n\x17uint32.gt_lte_exclusive\x1a\xb0\x01has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'H\x01R\x02gt\x12\xed\x07\n\x03gte\x18\x05 \x01(\rB\xd8\x07\xc2H\xd4\x07\n\x89\x01\n\nuint32.gte\x1a{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\xc3\x01\n\ruint32.gte_lt\x1a\xb1\x01has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xcb\x01\n\x17uint32.gte_lt_exclusive\x1a\xaf\x01has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xd3\x01\n\x0euint32.gte_lte\x1a\xc0\x01has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\xdb\x01\n\x18uint32.gte_lte_exclusive\x1a\xbe\x01has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'H\x01R\x03gte\x12\x84\x01\n\x02in\x18\x06 \x03(\rBt\xc2Hq\no\n\tuint32.in\x1a\x62!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'R\x02in\x12~\n\x06not_in\x18\x07 \x03(\rBg\xc2Hd\nb\n\ruint32.not_in\x1aQthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'R\x05notIn\x12\x35\n\x07\x65xample\x18\x08 \x03(\rB\x1b\xc2H\x18\n\x16\n\x0euint32.example\x1a\x04trueR\x07\x65xample*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\x42\x0b\n\tless_thanB\x0e\n\x0cgreater_than\"\xcb\x15\n\x0bUInt64Rules\x12\x8b\x01\n\x05\x63onst\x18\x01 \x01(\x04\x42u\xc2Hr\np\n\x0cuint64.const\x1a`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'R\x05\x63onst\x12\x8f\x01\n\x02lt\x18\x02 \x01(\x04\x42}\xc2Hz\nx\n\tuint64.lt\x1ak!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'H\x00R\x02lt\x12\xa2\x01\n\x03lte\x18\x03 \x01(\x04\x42\x8d\x01\xc2H\x89\x01\n\x86\x01\n\nuint64.lte\x1ax!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'H\x00R\x03lte\x12\xa0\x07\n\x02gt\x18\x04 \x01(\x04\x42\x8d\x07\xc2H\x89\x07\n{\n\tuint64.gt\x1an!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\xb4\x01\n\x0cuint64.gt_lt\x1a\xa3\x01has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xbc\x01\n\x16uint64.gt_lt_exclusive\x1a\xa1\x01has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xc4\x01\n\ruint64.gt_lte\x1a\xb2\x01has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\xcc\x01\n\x17uint64.gt_lte_exclusive\x1a\xb0\x01has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'H\x01R\x02gt\x12\xed\x07\n\x03gte\x18\x05 \x01(\x04\x42\xd8\x07\xc2H\xd4\x07\n\x89\x01\n\nuint64.gte\x1a{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\xc3\x01\n\ruint64.gte_lt\x1a\xb1\x01has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xcb\x01\n\x17uint64.gte_lt_exclusive\x1a\xaf\x01has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xd3\x01\n\x0euint64.gte_lte\x1a\xc0\x01has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\xdb\x01\n\x18uint64.gte_lte_exclusive\x1a\xbe\x01has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'H\x01R\x03gte\x12\x84\x01\n\x02in\x18\x06 \x03(\x04\x42t\xc2Hq\no\n\tuint64.in\x1a\x62!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'R\x02in\x12~\n\x06not_in\x18\x07 \x03(\x04\x42g\xc2Hd\nb\n\ruint64.not_in\x1aQthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'R\x05notIn\x12\x35\n\x07\x65xample\x18\x08 \x03(\x04\x42\x1b\xc2H\x18\n\x16\n\x0euint64.example\x1a\x04trueR\x07\x65xample*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\x42\x0b\n\tless_thanB\x0e\n\x0cgreater_than\"\xcb\x15\n\x0bSInt32Rules\x12\x8b\x01\n\x05\x63onst\x18\x01 \x01(\x11\x42u\xc2Hr\np\n\x0csint32.const\x1a`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'R\x05\x63onst\x12\x8f\x01\n\x02lt\x18\x02 \x01(\x11\x42}\xc2Hz\nx\n\tsint32.lt\x1ak!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'H\x00R\x02lt\x12\xa2\x01\n\x03lte\x18\x03 \x01(\x11\x42\x8d\x01\xc2H\x89\x01\n\x86\x01\n\nsint32.lte\x1ax!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'H\x00R\x03lte\x12\xa0\x07\n\x02gt\x18\x04 \x01(\x11\x42\x8d\x07\xc2H\x89\x07\n{\n\tsint32.gt\x1an!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\xb4\x01\n\x0csint32.gt_lt\x1a\xa3\x01has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xbc\x01\n\x16sint32.gt_lt_exclusive\x1a\xa1\x01has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xc4\x01\n\rsint32.gt_lte\x1a\xb2\x01has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\xcc\x01\n\x17sint32.gt_lte_exclusive\x1a\xb0\x01has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'H\x01R\x02gt\x12\xed\x07\n\x03gte\x18\x05 \x01(\x11\x42\xd8\x07\xc2H\xd4\x07\n\x89\x01\n\nsint32.gte\x1a{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\xc3\x01\n\rsint32.gte_lt\x1a\xb1\x01has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xcb\x01\n\x17sint32.gte_lt_exclusive\x1a\xaf\x01has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xd3\x01\n\x0esint32.gte_lte\x1a\xc0\x01has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\xdb\x01\n\x18sint32.gte_lte_exclusive\x1a\xbe\x01has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'H\x01R\x03gte\x12\x84\x01\n\x02in\x18\x06 \x03(\x11\x42t\xc2Hq\no\n\tsint32.in\x1a\x62!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'R\x02in\x12~\n\x06not_in\x18\x07 \x03(\x11\x42g\xc2Hd\nb\n\rsint32.not_in\x1aQthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'R\x05notIn\x12\x35\n\x07\x65xample\x18\x08 \x03(\x11\x42\x1b\xc2H\x18\n\x16\n\x0esint32.example\x1a\x04trueR\x07\x65xample*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\x42\x0b\n\tless_thanB\x0e\n\x0cgreater_than\"\xcb\x15\n\x0bSInt64Rules\x12\x8b\x01\n\x05\x63onst\x18\x01 \x01(\x12\x42u\xc2Hr\np\n\x0csint64.const\x1a`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'R\x05\x63onst\x12\x8f\x01\n\x02lt\x18\x02 \x01(\x12\x42}\xc2Hz\nx\n\tsint64.lt\x1ak!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'H\x00R\x02lt\x12\xa2\x01\n\x03lte\x18\x03 \x01(\x12\x42\x8d\x01\xc2H\x89\x01\n\x86\x01\n\nsint64.lte\x1ax!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'H\x00R\x03lte\x12\xa0\x07\n\x02gt\x18\x04 \x01(\x12\x42\x8d\x07\xc2H\x89\x07\n{\n\tsint64.gt\x1an!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\xb4\x01\n\x0csint64.gt_lt\x1a\xa3\x01has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xbc\x01\n\x16sint64.gt_lt_exclusive\x1a\xa1\x01has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xc4\x01\n\rsint64.gt_lte\x1a\xb2\x01has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\xcc\x01\n\x17sint64.gt_lte_exclusive\x1a\xb0\x01has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'H\x01R\x02gt\x12\xed\x07\n\x03gte\x18\x05 \x01(\x12\x42\xd8\x07\xc2H\xd4\x07\n\x89\x01\n\nsint64.gte\x1a{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\xc3\x01\n\rsint64.gte_lt\x1a\xb1\x01has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xcb\x01\n\x17sint64.gte_lt_exclusive\x1a\xaf\x01has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xd3\x01\n\x0esint64.gte_lte\x1a\xc0\x01has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\xdb\x01\n\x18sint64.gte_lte_exclusive\x1a\xbe\x01has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'H\x01R\x03gte\x12\x84\x01\n\x02in\x18\x06 \x03(\x12\x42t\xc2Hq\no\n\tsint64.in\x1a\x62!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'R\x02in\x12~\n\x06not_in\x18\x07 \x03(\x12\x42g\xc2Hd\nb\n\rsint64.not_in\x1aQthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'R\x05notIn\x12\x35\n\x07\x65xample\x18\x08 \x03(\x12\x42\x1b\xc2H\x18\n\x16\n\x0esint64.example\x1a\x04trueR\x07\x65xample*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\x42\x0b\n\tless_thanB\x0e\n\x0cgreater_than\"\xdc\x15\n\x0c\x46ixed32Rules\x12\x8c\x01\n\x05\x63onst\x18\x01 \x01(\x07\x42v\xc2Hs\nq\n\rfixed32.const\x1a`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'R\x05\x63onst\x12\x90\x01\n\x02lt\x18\x02 \x01(\x07\x42~\xc2H{\ny\n\nfixed32.lt\x1ak!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'H\x00R\x02lt\x12\xa3\x01\n\x03lte\x18\x03 \x01(\x07\x42\x8e\x01\xc2H\x8a\x01\n\x87\x01\n\x0b\x66ixed32.lte\x1ax!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'H\x00R\x03lte\x12\xa5\x07\n\x02gt\x18\x04 \x01(\x07\x42\x92\x07\xc2H\x8e\x07\n|\n\nfixed32.gt\x1an!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\xb5\x01\n\rfixed32.gt_lt\x1a\xa3\x01has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xbd\x01\n\x17\x66ixed32.gt_lt_exclusive\x1a\xa1\x01has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xc5\x01\n\x0e\x66ixed32.gt_lte\x1a\xb2\x01has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\xcd\x01\n\x18\x66ixed32.gt_lte_exclusive\x1a\xb0\x01has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'H\x01R\x02gt\x12\xf2\x07\n\x03gte\x18\x05 \x01(\x07\x42\xdd\x07\xc2H\xd9\x07\n\x8a\x01\n\x0b\x66ixed32.gte\x1a{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\xc4\x01\n\x0e\x66ixed32.gte_lt\x1a\xb1\x01has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xcc\x01\n\x18\x66ixed32.gte_lt_exclusive\x1a\xaf\x01has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xd4\x01\n\x0f\x66ixed32.gte_lte\x1a\xc0\x01has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\xdc\x01\n\x19\x66ixed32.gte_lte_exclusive\x1a\xbe\x01has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'H\x01R\x03gte\x12\x85\x01\n\x02in\x18\x06 \x03(\x07\x42u\xc2Hr\np\n\nfixed32.in\x1a\x62!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'R\x02in\x12\x7f\n\x06not_in\x18\x07 \x03(\x07\x42h\xc2He\nc\n\x0e\x66ixed32.not_in\x1aQthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'R\x05notIn\x12\x36\n\x07\x65xample\x18\x08 \x03(\x07\x42\x1c\xc2H\x19\n\x17\n\x0f\x66ixed32.example\x1a\x04trueR\x07\x65xample*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\x42\x0b\n\tless_thanB\x0e\n\x0cgreater_than\"\xdc\x15\n\x0c\x46ixed64Rules\x12\x8c\x01\n\x05\x63onst\x18\x01 \x01(\x06\x42v\xc2Hs\nq\n\rfixed64.const\x1a`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'R\x05\x63onst\x12\x90\x01\n\x02lt\x18\x02 \x01(\x06\x42~\xc2H{\ny\n\nfixed64.lt\x1ak!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'H\x00R\x02lt\x12\xa3\x01\n\x03lte\x18\x03 \x01(\x06\x42\x8e\x01\xc2H\x8a\x01\n\x87\x01\n\x0b\x66ixed64.lte\x1ax!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'H\x00R\x03lte\x12\xa5\x07\n\x02gt\x18\x04 \x01(\x06\x42\x92\x07\xc2H\x8e\x07\n|\n\nfixed64.gt\x1an!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\xb5\x01\n\rfixed64.gt_lt\x1a\xa3\x01has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xbd\x01\n\x17\x66ixed64.gt_lt_exclusive\x1a\xa1\x01has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xc5\x01\n\x0e\x66ixed64.gt_lte\x1a\xb2\x01has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\xcd\x01\n\x18\x66ixed64.gt_lte_exclusive\x1a\xb0\x01has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'H\x01R\x02gt\x12\xf2\x07\n\x03gte\x18\x05 \x01(\x06\x42\xdd\x07\xc2H\xd9\x07\n\x8a\x01\n\x0b\x66ixed64.gte\x1a{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\xc4\x01\n\x0e\x66ixed64.gte_lt\x1a\xb1\x01has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xcc\x01\n\x18\x66ixed64.gte_lt_exclusive\x1a\xaf\x01has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xd4\x01\n\x0f\x66ixed64.gte_lte\x1a\xc0\x01has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\xdc\x01\n\x19\x66ixed64.gte_lte_exclusive\x1a\xbe\x01has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'H\x01R\x03gte\x12\x85\x01\n\x02in\x18\x06 \x03(\x06\x42u\xc2Hr\np\n\nfixed64.in\x1a\x62!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'R\x02in\x12\x7f\n\x06not_in\x18\x07 \x03(\x06\x42h\xc2He\nc\n\x0e\x66ixed64.not_in\x1aQthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'R\x05notIn\x12\x36\n\x07\x65xample\x18\x08 \x03(\x06\x42\x1c\xc2H\x19\n\x17\n\x0f\x66ixed64.example\x1a\x04trueR\x07\x65xample*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\x42\x0b\n\tless_thanB\x0e\n\x0cgreater_than\"\xee\x15\n\rSFixed32Rules\x12\x8d\x01\n\x05\x63onst\x18\x01 \x01(\x0f\x42w\xc2Ht\nr\n\x0esfixed32.const\x1a`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'R\x05\x63onst\x12\x91\x01\n\x02lt\x18\x02 \x01(\x0f\x42\x7f\xc2H|\nz\n\x0bsfixed32.lt\x1ak!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'H\x00R\x02lt\x12\xa4\x01\n\x03lte\x18\x03 \x01(\x0f\x42\x8f\x01\xc2H\x8b\x01\n\x88\x01\n\x0csfixed32.lte\x1ax!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'H\x00R\x03lte\x12\xaa\x07\n\x02gt\x18\x04 \x01(\x0f\x42\x97\x07\xc2H\x93\x07\n}\n\x0bsfixed32.gt\x1an!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\xb6\x01\n\x0esfixed32.gt_lt\x1a\xa3\x01has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xbe\x01\n\x18sfixed32.gt_lt_exclusive\x1a\xa1\x01has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xc6\x01\n\x0fsfixed32.gt_lte\x1a\xb2\x01has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\xce\x01\n\x19sfixed32.gt_lte_exclusive\x1a\xb0\x01has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'H\x01R\x02gt\x12\xf7\x07\n\x03gte\x18\x05 \x01(\x0f\x42\xe2\x07\xc2H\xde\x07\n\x8b\x01\n\x0csfixed32.gte\x1a{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\xc5\x01\n\x0fsfixed32.gte_lt\x1a\xb1\x01has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xcd\x01\n\x19sfixed32.gte_lt_exclusive\x1a\xaf\x01has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xd5\x01\n\x10sfixed32.gte_lte\x1a\xc0\x01has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\xdd\x01\n\x1asfixed32.gte_lte_exclusive\x1a\xbe\x01has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'H\x01R\x03gte\x12\x86\x01\n\x02in\x18\x06 \x03(\x0f\x42v\xc2Hs\nq\n\x0bsfixed32.in\x1a\x62!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'R\x02in\x12\x80\x01\n\x06not_in\x18\x07 \x03(\x0f\x42i\xc2Hf\nd\n\x0fsfixed32.not_in\x1aQthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'R\x05notIn\x12\x37\n\x07\x65xample\x18\x08 \x03(\x0f\x42\x1d\xc2H\x1a\n\x18\n\x10sfixed32.example\x1a\x04trueR\x07\x65xample*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\x42\x0b\n\tless_thanB\x0e\n\x0cgreater_than\"\xee\x15\n\rSFixed64Rules\x12\x8d\x01\n\x05\x63onst\x18\x01 \x01(\x10\x42w\xc2Ht\nr\n\x0esfixed64.const\x1a`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'R\x05\x63onst\x12\x91\x01\n\x02lt\x18\x02 \x01(\x10\x42\x7f\xc2H|\nz\n\x0bsfixed64.lt\x1ak!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'H\x00R\x02lt\x12\xa4\x01\n\x03lte\x18\x03 \x01(\x10\x42\x8f\x01\xc2H\x8b\x01\n\x88\x01\n\x0csfixed64.lte\x1ax!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'H\x00R\x03lte\x12\xaa\x07\n\x02gt\x18\x04 \x01(\x10\x42\x97\x07\xc2H\x93\x07\n}\n\x0bsfixed64.gt\x1an!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\xb6\x01\n\x0esfixed64.gt_lt\x1a\xa3\x01has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xbe\x01\n\x18sfixed64.gt_lt_exclusive\x1a\xa1\x01has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xc6\x01\n\x0fsfixed64.gt_lte\x1a\xb2\x01has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\xce\x01\n\x19sfixed64.gt_lte_exclusive\x1a\xb0\x01has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'H\x01R\x02gt\x12\xf7\x07\n\x03gte\x18\x05 \x01(\x10\x42\xe2\x07\xc2H\xde\x07\n\x8b\x01\n\x0csfixed64.gte\x1a{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\xc5\x01\n\x0fsfixed64.gte_lt\x1a\xb1\x01has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xcd\x01\n\x19sfixed64.gte_lt_exclusive\x1a\xaf\x01has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xd5\x01\n\x10sfixed64.gte_lte\x1a\xc0\x01has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\xdd\x01\n\x1asfixed64.gte_lte_exclusive\x1a\xbe\x01has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'H\x01R\x03gte\x12\x86\x01\n\x02in\x18\x06 \x03(\x10\x42v\xc2Hs\nq\n\x0bsfixed64.in\x1a\x62!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'R\x02in\x12\x80\x01\n\x06not_in\x18\x07 \x03(\x10\x42i\xc2Hf\nd\n\x0fsfixed64.not_in\x1aQthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'R\x05notIn\x12\x37\n\x07\x65xample\x18\x08 \x03(\x10\x42\x1d\xc2H\x1a\n\x18\n\x10sfixed64.example\x1a\x04trueR\x07\x65xample*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\x42\x0b\n\tless_thanB\x0e\n\x0cgreater_than\"\xd7\x01\n\tBoolRules\x12\x89\x01\n\x05\x63onst\x18\x01 \x01(\x08\x42s\xc2Hp\nn\n\nbool.const\x1a`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'R\x05\x63onst\x12\x33\n\x07\x65xample\x18\x02 \x03(\x08\x42\x19\xc2H\x16\n\x14\n\x0c\x62ool.example\x1a\x04trueR\x07\x65xample*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\xd1\x39\n\x0bStringRules\x12\x8d\x01\n\x05\x63onst\x18\x01 \x01(\tBw\xc2Ht\nr\n\x0cstring.const\x1a\x62this != getField(rules, \'const\') ? \'value must equal `%s`\'.format([getField(rules, \'const\')]) : \'\'R\x05\x63onst\x12\x83\x01\n\x03len\x18\x13 \x01(\x04\x42q\xc2Hn\nl\n\nstring.len\x1a^uint(this.size()) != rules.len ? \'value length must be %s characters\'.format([rules.len]) : \'\'R\x03len\x12\xa1\x01\n\x07min_len\x18\x02 \x01(\x04\x42\x87\x01\xc2H\x83\x01\n\x80\x01\n\x0estring.min_len\x1anuint(this.size()) < rules.min_len ? \'value length must be at least %s characters\'.format([rules.min_len]) : \'\'R\x06minLen\x12\x9f\x01\n\x07max_len\x18\x03 \x01(\x04\x42\x85\x01\xc2H\x81\x01\n\x7f\n\x0estring.max_len\x1amuint(this.size()) > rules.max_len ? \'value length must be at most %s characters\'.format([rules.max_len]) : \'\'R\x06maxLen\x12\xa5\x01\n\tlen_bytes\x18\x14 \x01(\x04\x42\x87\x01\xc2H\x83\x01\n\x80\x01\n\x10string.len_bytes\x1aluint(bytes(this).size()) != rules.len_bytes ? \'value length must be %s bytes\'.format([rules.len_bytes]) : \'\'R\x08lenBytes\x12\xad\x01\n\tmin_bytes\x18\x04 \x01(\x04\x42\x8f\x01\xc2H\x8b\x01\n\x88\x01\n\x10string.min_bytes\x1atuint(bytes(this).size()) < rules.min_bytes ? \'value length must be at least %s bytes\'.format([rules.min_bytes]) : \'\'R\x08minBytes\x12\xac\x01\n\tmax_bytes\x18\x05 \x01(\x04\x42\x8e\x01\xc2H\x8a\x01\n\x87\x01\n\x10string.max_bytes\x1asuint(bytes(this).size()) > rules.max_bytes ? \'value length must be at most %s bytes\'.format([rules.max_bytes]) : \'\'R\x08maxBytes\x12\x96\x01\n\x07pattern\x18\x06 \x01(\tB|\xc2Hy\nw\n\x0estring.pattern\x1a\x65!this.matches(rules.pattern) ? \'value does not match regex pattern `%s`\'.format([rules.pattern]) : \'\'R\x07pattern\x12\x8c\x01\n\x06prefix\x18\x07 \x01(\tBt\xc2Hq\no\n\rstring.prefix\x1a^!this.startsWith(rules.prefix) ? \'value does not have prefix `%s`\'.format([rules.prefix]) : \'\'R\x06prefix\x12\x8a\x01\n\x06suffix\x18\x08 \x01(\tBr\xc2Ho\nm\n\rstring.suffix\x1a\\!this.endsWith(rules.suffix) ? \'value does not have suffix `%s`\'.format([rules.suffix]) : \'\'R\x06suffix\x12\x9a\x01\n\x08\x63ontains\x18\t \x01(\tB~\xc2H{\ny\n\x0fstring.contains\x1a\x66!this.contains(rules.contains) ? \'value does not contain substring `%s`\'.format([rules.contains]) : \'\'R\x08\x63ontains\x12\xa5\x01\n\x0cnot_contains\x18\x17 \x01(\tB\x81\x01\xc2H~\n|\n\x13string.not_contains\x1a\x65this.contains(rules.not_contains) ? \'value contains substring `%s`\'.format([rules.not_contains]) : \'\'R\x0bnotContains\x12\x84\x01\n\x02in\x18\n \x03(\tBt\xc2Hq\no\n\tstring.in\x1a\x62!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'R\x02in\x12~\n\x06not_in\x18\x0b \x03(\tBg\xc2Hd\nb\n\rstring.not_in\x1aQthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'R\x05notIn\x12\xe6\x01\n\x05\x65mail\x18\x0c \x01(\x08\x42\xcd\x01\xc2H\xc9\x01\na\n\x0cstring.email\x12#value must be a valid email address\x1a,!rules.email || this == \'\' || this.isEmail()\nd\n\x12string.email_empty\x12\x32value is empty, which is not a valid email address\x1a\x1a!rules.email || this != \'\'H\x00R\x05\x65mail\x12\xf1\x01\n\x08hostname\x18\r \x01(\x08\x42\xd2\x01\xc2H\xce\x01\ne\n\x0fstring.hostname\x12\x1evalue must be a valid hostname\x1a\x32!rules.hostname || this == \'\' || this.isHostname()\ne\n\x15string.hostname_empty\x12-value is empty, which is not a valid hostname\x1a\x1d!rules.hostname || this != \'\'H\x00R\x08hostname\x12\xcb\x01\n\x02ip\x18\x0e \x01(\x08\x42\xb8\x01\xc2H\xb4\x01\nU\n\tstring.ip\x12 value must be a valid IP address\x1a&!rules.ip || this == \'\' || this.isIp()\n[\n\x0fstring.ip_empty\x12/value is empty, which is not a valid IP address\x1a\x17!rules.ip || this != \'\'H\x00R\x02ip\x12\xdc\x01\n\x04ipv4\x18\x0f \x01(\x08\x42\xc5\x01\xc2H\xc1\x01\n\\\n\x0bstring.ipv4\x12\"value must be a valid IPv4 address\x1a)!rules.ipv4 || this == \'\' || this.isIp(4)\na\n\x11string.ipv4_empty\x12\x31value is empty, which is not a valid IPv4 address\x1a\x19!rules.ipv4 || this != \'\'H\x00R\x04ipv4\x12\xdc\x01\n\x04ipv6\x18\x10 \x01(\x08\x42\xc5\x01\xc2H\xc1\x01\n\\\n\x0bstring.ipv6\x12\"value must be a valid IPv6 address\x1a)!rules.ipv6 || this == \'\' || this.isIp(6)\na\n\x11string.ipv6_empty\x12\x31value is empty, which is not a valid IPv6 address\x1a\x19!rules.ipv6 || this != \'\'H\x00R\x04ipv6\x12\xc4\x01\n\x03uri\x18\x11 \x01(\x08\x42\xaf\x01\xc2H\xab\x01\nQ\n\nstring.uri\x12\x19value must be a valid URI\x1a(!rules.uri || this == \'\' || this.isUri()\nV\n\x10string.uri_empty\x12(value is empty, which is not a valid URI\x1a\x18!rules.uri || this != \'\'H\x00R\x03uri\x12x\n\x07uri_ref\x18\x12 \x01(\x08\x42]\xc2HZ\nX\n\x0estring.uri_ref\x12#value must be a valid URI Reference\x1a!!rules.uri_ref || this.isUriRef()H\x00R\x06uriRef\x12\x99\x02\n\x07\x61\x64\x64ress\x18\x15 \x01(\x08\x42\xfc\x01\xc2H\xf8\x01\n\x81\x01\n\x0estring.address\x12-value must be a valid hostname, or ip address\x1a@!rules.address || this == \'\' || this.isHostname() || this.isIp()\nr\n\x14string.address_empty\x12!rules.ipv4_with_prefixlen || this == \'\' || this.isIpPrefix(4)\n\x92\x01\n string.ipv4_with_prefixlen_empty\x12\x44value is empty, which is not a valid IPv4 address with prefix length\x1a(!rules.ipv4_with_prefixlen || this != \'\'H\x00R\x11ipv4WithPrefixlen\x12\xe2\x02\n\x13ipv6_with_prefixlen\x18\x1c \x01(\x08\x42\xaf\x02\xc2H\xab\x02\n\x93\x01\n\x1astring.ipv6_with_prefixlen\x12\x35value must be a valid IPv6 address with prefix length\x1a>!rules.ipv6_with_prefixlen || this == \'\' || this.isIpPrefix(6)\n\x92\x01\n string.ipv6_with_prefixlen_empty\x12\x44value is empty, which is not a valid IPv6 address with prefix length\x1a(!rules.ipv6_with_prefixlen || this != \'\'H\x00R\x11ipv6WithPrefixlen\x12\xfc\x01\n\tip_prefix\x18\x1d \x01(\x08\x42\xdc\x01\xc2H\xd8\x01\nl\n\x10string.ip_prefix\x12\x1fvalue must be a valid IP prefix\x1a\x37!rules.ip_prefix || this == \'\' || this.isIpPrefix(true)\nh\n\x16string.ip_prefix_empty\x12.value is empty, which is not a valid IP prefix\x1a\x1e!rules.ip_prefix || this != \'\'H\x00R\x08ipPrefix\x12\x8f\x02\n\x0bipv4_prefix\x18\x1e \x01(\x08\x42\xeb\x01\xc2H\xe7\x01\nu\n\x12string.ipv4_prefix\x12!value must be a valid IPv4 prefix\x1a!rules.host_and_port || this == \'\' || this.isHostAndPort(true)\ny\n\x1astring.host_and_port_empty\x12\x37value is empty, which is not a valid host and port pair\x1a\"!rules.host_and_port || this != \'\'H\x00R\x0bhostAndPort\x12\xb8\x05\n\x10well_known_regex\x18\x18 \x01(\x0e\x32\x18.buf.validate.KnownRegexB\xf1\x04\xc2H\xed\x04\n\xf0\x01\n#string.well_known_regex.header_name\x12&value must be a valid HTTP header name\x1a\xa0\x01rules.well_known_regex != 1 || this == \'\' || this.matches(!has(rules.strict) || rules.strict ?\'^:?[0-9a-zA-Z!#$%&\\\'*+-.^_|~\\x60]+$\' :\'^[^\\u0000\\u000A\\u000D]+$\')\n\x8d\x01\n)string.well_known_regex.header_name_empty\x12\x35value is empty, which is not a valid HTTP header name\x1a)rules.well_known_regex != 1 || this != \'\'\n\xe7\x01\n$string.well_known_regex.header_value\x12\'value must be a valid HTTP header value\x1a\x95\x01rules.well_known_regex != 2 || this.matches(!has(rules.strict) || rules.strict ?\'^[^\\u0000-\\u0008\\u000A-\\u001F\\u007F]*$\' :\'^[^\\u0000\\u000A\\u000D]*$\')H\x00R\x0ewellKnownRegex\x12\x16\n\x06strict\x18\x19 \x01(\x08R\x06strict\x12\x35\n\x07\x65xample\x18\" \x03(\tB\x1b\xc2H\x18\n\x16\n\x0estring.example\x1a\x04trueR\x07\x65xample*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\x42\x0c\n\nwell_known\"\xce\x11\n\nBytesRules\x12\x87\x01\n\x05\x63onst\x18\x01 \x01(\x0c\x42q\xc2Hn\nl\n\x0b\x62ytes.const\x1a]this != getField(rules, \'const\') ? \'value must be %x\'.format([getField(rules, \'const\')]) : \'\'R\x05\x63onst\x12}\n\x03len\x18\r \x01(\x04\x42k\xc2Hh\nf\n\tbytes.len\x1aYuint(this.size()) != rules.len ? \'value length must be %s bytes\'.format([rules.len]) : \'\'R\x03len\x12\x98\x01\n\x07min_len\x18\x02 \x01(\x04\x42\x7f\xc2H|\nz\n\rbytes.min_len\x1aiuint(this.size()) < rules.min_len ? \'value length must be at least %s bytes\'.format([rules.min_len]) : \'\'R\x06minLen\x12\x90\x01\n\x07max_len\x18\x03 \x01(\x04\x42w\xc2Ht\nr\n\rbytes.max_len\x1a\x61uint(this.size()) > rules.max_len ? \'value must be at most %s bytes\'.format([rules.max_len]) : \'\'R\x06maxLen\x12\x99\x01\n\x07pattern\x18\x04 \x01(\tB\x7f\xc2H|\nz\n\rbytes.pattern\x1ai!string(this).matches(rules.pattern) ? \'value must match regex pattern `%s`\'.format([rules.pattern]) : \'\'R\x07pattern\x12\x89\x01\n\x06prefix\x18\x05 \x01(\x0c\x42q\xc2Hn\nl\n\x0c\x62ytes.prefix\x1a\\!this.startsWith(rules.prefix) ? \'value does not have prefix %x\'.format([rules.prefix]) : \'\'R\x06prefix\x12\x87\x01\n\x06suffix\x18\x06 \x01(\x0c\x42o\xc2Hl\nj\n\x0c\x62ytes.suffix\x1aZ!this.endsWith(rules.suffix) ? \'value does not have suffix %x\'.format([rules.suffix]) : \'\'R\x06suffix\x12\x8d\x01\n\x08\x63ontains\x18\x07 \x01(\x0c\x42q\xc2Hn\nl\n\x0e\x62ytes.contains\x1aZ!this.contains(rules.contains) ? \'value does not contain %x\'.format([rules.contains]) : \'\'R\x08\x63ontains\x12\xab\x01\n\x02in\x18\x08 \x03(\x0c\x42\x9a\x01\xc2H\x96\x01\n\x93\x01\n\x08\x62ytes.in\x1a\x86\x01getField(rules, \'in\').size() > 0 && !(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'R\x02in\x12}\n\x06not_in\x18\t \x03(\x0c\x42\x66\xc2Hc\na\n\x0c\x62ytes.not_in\x1aQthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'R\x05notIn\x12\xef\x01\n\x02ip\x18\n \x01(\x08\x42\xdc\x01\xc2H\xd8\x01\nt\n\x08\x62ytes.ip\x12 value must be a valid IP address\x1a\x46!rules.ip || this.size() == 0 || this.size() == 4 || this.size() == 16\n`\n\x0e\x62ytes.ip_empty\x12/value is empty, which is not a valid IP address\x1a\x1d!rules.ip || this.size() != 0H\x00R\x02ip\x12\xea\x01\n\x04ipv4\x18\x0b \x01(\x08\x42\xd3\x01\xc2H\xcf\x01\ne\n\nbytes.ipv4\x12\"value must be a valid IPv4 address\x1a\x33!rules.ipv4 || this.size() == 0 || this.size() == 4\nf\n\x10\x62ytes.ipv4_empty\x12\x31value is empty, which is not a valid IPv4 address\x1a\x1f!rules.ipv4 || this.size() != 0H\x00R\x04ipv4\x12\xeb\x01\n\x04ipv6\x18\x0c \x01(\x08\x42\xd4\x01\xc2H\xd0\x01\nf\n\nbytes.ipv6\x12\"value must be a valid IPv6 address\x1a\x34!rules.ipv6 || this.size() == 0 || this.size() == 16\nf\n\x10\x62ytes.ipv6_empty\x12\x31value is empty, which is not a valid IPv6 address\x1a\x1f!rules.ipv6 || this.size() != 0H\x00R\x04ipv6\x12\x34\n\x07\x65xample\x18\x0e \x03(\x0c\x42\x1a\xc2H\x17\n\x15\n\rbytes.example\x1a\x04trueR\x07\x65xample*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\x42\x0c\n\nwell_known\"\xfd\x03\n\tEnumRules\x12\x89\x01\n\x05\x63onst\x18\x01 \x01(\x05\x42s\xc2Hp\nn\n\nenum.const\x1a`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'R\x05\x63onst\x12!\n\x0c\x64\x65\x66ined_only\x18\x02 \x01(\x08R\x0b\x64\x65\x66inedOnly\x12\x82\x01\n\x02in\x18\x03 \x03(\x05\x42r\xc2Ho\nm\n\x07\x65num.in\x1a\x62!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'R\x02in\x12|\n\x06not_in\x18\x04 \x03(\x05\x42\x65\xc2Hb\n`\n\x0b\x65num.not_in\x1aQthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'R\x05notIn\x12\x33\n\x07\x65xample\x18\x05 \x03(\x05\x42\x19\xc2H\x16\n\x14\n\x0c\x65num.example\x1a\x04trueR\x07\x65xample*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\x9e\x04\n\rRepeatedRules\x12\xa8\x01\n\tmin_items\x18\x01 \x01(\x04\x42\x8a\x01\xc2H\x86\x01\n\x83\x01\n\x12repeated.min_items\x1amuint(this.size()) < rules.min_items ? \'value must contain at least %d item(s)\'.format([rules.min_items]) : \'\'R\x08minItems\x12\xac\x01\n\tmax_items\x18\x02 \x01(\x04\x42\x8e\x01\xc2H\x8a\x01\n\x87\x01\n\x12repeated.max_items\x1aquint(this.size()) > rules.max_items ? \'value must contain no more than %s item(s)\'.format([rules.max_items]) : \'\'R\x08maxItems\x12x\n\x06unique\x18\x03 \x01(\x08\x42`\xc2H]\n[\n\x0frepeated.unique\x12(repeated value must contain unique items\x1a\x1e!rules.unique || this.unique()R\x06unique\x12.\n\x05items\x18\x04 \x01(\x0b\x32\x18.buf.validate.FieldRulesR\x05items*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\xac\x03\n\x08MapRules\x12\x99\x01\n\tmin_pairs\x18\x01 \x01(\x04\x42|\xc2Hy\nw\n\rmap.min_pairs\x1a\x66uint(this.size()) < rules.min_pairs ? \'map must be at least %d entries\'.format([rules.min_pairs]) : \'\'R\x08minPairs\x12\x98\x01\n\tmax_pairs\x18\x02 \x01(\x04\x42{\xc2Hx\nv\n\rmap.max_pairs\x1a\x65uint(this.size()) > rules.max_pairs ? \'map must be at most %d entries\'.format([rules.max_pairs]) : \'\'R\x08maxPairs\x12,\n\x04keys\x18\x04 \x01(\x0b\x32\x18.buf.validate.FieldRulesR\x04keys\x12\x30\n\x06values\x18\x05 \x01(\x0b\x32\x18.buf.validate.FieldRulesR\x06values*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"1\n\x08\x41nyRules\x12\x0e\n\x02in\x18\x02 \x03(\tR\x02in\x12\x15\n\x06not_in\x18\x03 \x03(\tR\x05notIn\"\xc6\x17\n\rDurationRules\x12\xa8\x01\n\x05\x63onst\x18\x02 \x01(\x0b\x32\x19.google.protobuf.DurationBw\xc2Ht\nr\n\x0e\x64uration.const\x1a`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'R\x05\x63onst\x12\xac\x01\n\x02lt\x18\x03 \x01(\x0b\x32\x19.google.protobuf.DurationB\x7f\xc2H|\nz\n\x0b\x64uration.lt\x1ak!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'H\x00R\x02lt\x12\xbf\x01\n\x03lte\x18\x04 \x01(\x0b\x32\x19.google.protobuf.DurationB\x8f\x01\xc2H\x8b\x01\n\x88\x01\n\x0c\x64uration.lte\x1ax!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'H\x00R\x03lte\x12\xc5\x07\n\x02gt\x18\x05 \x01(\x0b\x32\x19.google.protobuf.DurationB\x97\x07\xc2H\x93\x07\n}\n\x0b\x64uration.gt\x1an!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\xb6\x01\n\x0e\x64uration.gt_lt\x1a\xa3\x01has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xbe\x01\n\x18\x64uration.gt_lt_exclusive\x1a\xa1\x01has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xc6\x01\n\x0f\x64uration.gt_lte\x1a\xb2\x01has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\xce\x01\n\x19\x64uration.gt_lte_exclusive\x1a\xb0\x01has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'H\x01R\x02gt\x12\x92\x08\n\x03gte\x18\x06 \x01(\x0b\x32\x19.google.protobuf.DurationB\xe2\x07\xc2H\xde\x07\n\x8b\x01\n\x0c\x64uration.gte\x1a{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\xc5\x01\n\x0f\x64uration.gte_lt\x1a\xb1\x01has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xcd\x01\n\x19\x64uration.gte_lt_exclusive\x1a\xaf\x01has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xd5\x01\n\x10\x64uration.gte_lte\x1a\xc0\x01has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\xdd\x01\n\x1a\x64uration.gte_lte_exclusive\x1a\xbe\x01has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'H\x01R\x03gte\x12\xa1\x01\n\x02in\x18\x07 \x03(\x0b\x32\x19.google.protobuf.DurationBv\xc2Hs\nq\n\x0b\x64uration.in\x1a\x62!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'R\x02in\x12\x9b\x01\n\x06not_in\x18\x08 \x03(\x0b\x32\x19.google.protobuf.DurationBi\xc2Hf\nd\n\x0f\x64uration.not_in\x1aQthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'R\x05notIn\x12R\n\x07\x65xample\x18\t \x03(\x0b\x32\x19.google.protobuf.DurationB\x1d\xc2H\x1a\n\x18\n\x10\x64uration.example\x1a\x04trueR\x07\x65xample*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\x42\x0b\n\tless_thanB\x0e\n\x0cgreater_than\"\xca\x18\n\x0eTimestampRules\x12\xaa\x01\n\x05\x63onst\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampBx\xc2Hu\ns\n\x0ftimestamp.const\x1a`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'R\x05\x63onst\x12\xaf\x01\n\x02lt\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.TimestampB\x80\x01\xc2H}\n{\n\x0ctimestamp.lt\x1ak!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'H\x00R\x02lt\x12\xc1\x01\n\x03lte\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.TimestampB\x90\x01\xc2H\x8c\x01\n\x89\x01\n\rtimestamp.lte\x1ax!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'H\x00R\x03lte\x12s\n\x06lt_now\x18\x07 \x01(\x08\x42Z\xc2HW\nU\n\x10timestamp.lt_now\x1a\x41(rules.lt_now && this > now) ? \'value must be less than now\' : \'\'H\x00R\x05ltNow\x12\xcb\x07\n\x02gt\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.TimestampB\x9c\x07\xc2H\x98\x07\n~\n\x0ctimestamp.gt\x1an!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\xb7\x01\n\x0ftimestamp.gt_lt\x1a\xa3\x01has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xbf\x01\n\x19timestamp.gt_lt_exclusive\x1a\xa1\x01has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\xc7\x01\n\x10timestamp.gt_lte\x1a\xb2\x01has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\xcf\x01\n\x1atimestamp.gt_lte_exclusive\x1a\xb0\x01has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'H\x01R\x02gt\x12\x98\x08\n\x03gte\x18\x06 \x01(\x0b\x32\x1a.google.protobuf.TimestampB\xe7\x07\xc2H\xe3\x07\n\x8c\x01\n\rtimestamp.gte\x1a{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\xc6\x01\n\x10timestamp.gte_lt\x1a\xb1\x01has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xce\x01\n\x1atimestamp.gte_lt_exclusive\x1a\xaf\x01has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\xd6\x01\n\x11timestamp.gte_lte\x1a\xc0\x01has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\xde\x01\n\x1btimestamp.gte_lte_exclusive\x1a\xbe\x01has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'H\x01R\x03gte\x12v\n\x06gt_now\x18\x08 \x01(\x08\x42]\xc2HZ\nX\n\x10timestamp.gt_now\x1a\x44(rules.gt_now && this < now) ? \'value must be greater than now\' : \'\'H\x01R\x05gtNow\x12\xc0\x01\n\x06within\x18\t \x01(\x0b\x32\x19.google.protobuf.DurationB\x8c\x01\xc2H\x88\x01\n\x85\x01\n\x10timestamp.within\x1aqthis < now-rules.within || this > now+rules.within ? \'value must be within %s of now\'.format([rules.within]) : \'\'R\x06within\x12T\n\x07\x65xample\x18\n \x03(\x0b\x32\x1a.google.protobuf.TimestampB\x1e\xc2H\x1b\n\x19\n\x11timestamp.example\x1a\x04trueR\x07\x65xample*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\x42\x0b\n\tless_thanB\x0e\n\x0cgreater_than\"E\n\nViolations\x12\x37\n\nviolations\x18\x01 \x03(\x0b\x32\x17.buf.validate.ViolationR\nviolations\"\xc5\x01\n\tViolation\x12-\n\x05\x66ield\x18\x05 \x01(\x0b\x32\x17.buf.validate.FieldPathR\x05\x66ield\x12+\n\x04rule\x18\x06 \x01(\x0b\x32\x17.buf.validate.FieldPathR\x04rule\x12\x17\n\x07rule_id\x18\x02 \x01(\tR\x06ruleId\x12\x18\n\x07message\x18\x03 \x01(\tR\x07message\x12\x17\n\x07\x66or_key\x18\x04 \x01(\x08R\x06\x66orKeyJ\x04\x08\x01\x10\x02R\nfield_path\"G\n\tFieldPath\x12:\n\x08\x65lements\x18\x01 \x03(\x0b\x32\x1e.buf.validate.FieldPathElementR\x08\x65lements\"\xcc\x03\n\x10\x46ieldPathElement\x12!\n\x0c\x66ield_number\x18\x01 \x01(\x05R\x0b\x66ieldNumber\x12\x1d\n\nfield_name\x18\x02 \x01(\tR\tfieldName\x12I\n\nfield_type\x18\x03 \x01(\x0e\x32*.google.protobuf.FieldDescriptorProto.TypeR\tfieldType\x12\x45\n\x08key_type\x18\x04 \x01(\x0e\x32*.google.protobuf.FieldDescriptorProto.TypeR\x07keyType\x12I\n\nvalue_type\x18\x05 \x01(\x0e\x32*.google.protobuf.FieldDescriptorProto.TypeR\tvalueType\x12\x16\n\x05index\x18\x06 \x01(\x04H\x00R\x05index\x12\x1b\n\x08\x62ool_key\x18\x07 \x01(\x08H\x00R\x07\x62oolKey\x12\x19\n\x07int_key\x18\x08 \x01(\x03H\x00R\x06intKey\x12\x1b\n\x08uint_key\x18\t \x01(\x04H\x00R\x07uintKey\x12\x1f\n\nstring_key\x18\n \x01(\tH\x00R\tstringKeyB\x0b\n\tsubscript*\xa1\x01\n\x06Ignore\x12\x16\n\x12IGNORE_UNSPECIFIED\x10\x00\x12\x18\n\x14IGNORE_IF_ZERO_VALUE\x10\x01\x12\x11\n\rIGNORE_ALWAYS\x10\x03\"\x04\x08\x02\x10\x02*\x0cIGNORE_EMPTY*\x0eIGNORE_DEFAULT*\x17IGNORE_IF_DEFAULT_VALUE*\x15IGNORE_IF_UNPOPULATED*n\n\nKnownRegex\x12\x1b\n\x17KNOWN_REGEX_UNSPECIFIED\x10\x00\x12 \n\x1cKNOWN_REGEX_HTTP_HEADER_NAME\x10\x01\x12!\n\x1dKNOWN_REGEX_HTTP_HEADER_VALUE\x10\x02:V\n\x07message\x12\x1f.google.protobuf.MessageOptions\x18\x87\t \x01(\x0b\x32\x1a.buf.validate.MessageRulesR\x07message:N\n\x05oneof\x12\x1d.google.protobuf.OneofOptions\x18\x87\t \x01(\x0b\x32\x18.buf.validate.OneofRulesR\x05oneof:N\n\x05\x66ield\x12\x1d.google.protobuf.FieldOptions\x18\x87\t \x01(\x0b\x32\x18.buf.validate.FieldRulesR\x05\x66ield:]\n\npredefined\x12\x1d.google.protobuf.FieldOptions\x18\x88\t \x01(\x0b\x32\x1d.buf.validate.PredefinedRulesR\npredefinedB\xbd\x01\n\x10\x63om.buf.validateB\rValidateProtoH\x02P\x01ZGbuf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate\xa2\x02\x03\x42VX\xaa\x02\x0c\x42uf.Validate\xca\x02\x0c\x42uf\\Validate\xe2\x02\x18\x42uf\\Validate\\GPBMetadata\xea\x02\rBuf::Validate') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'buf.validate.validate_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\020com.buf.validateB\rValidateProtoH\002P\001ZGbuf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate\242\002\003BVX\252\002\014Buf.Validate\312\002\014Buf\\Validate\342\002\030Buf\\Validate\\GPBMetadata\352\002\rBuf::Validate' + _FLOATRULES.fields_by_name['const']._options = None + _FLOATRULES.fields_by_name['const']._serialized_options = b'\302Hq\no\n\013float.const\032`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'' + _FLOATRULES.fields_by_name['lt']._options = None + _FLOATRULES.fields_by_name['lt']._serialized_options = b'\302H\214\001\n\211\001\n\010float.lt\032}!has(rules.gte) && !has(rules.gt) && (this.isNan() || this >= rules.lt)? \'value must be less than %s\'.format([rules.lt]) : \'\'' + _FLOATRULES.fields_by_name['lte']._options = None + _FLOATRULES.fields_by_name['lte']._serialized_options = b'\302H\233\001\n\230\001\n\tfloat.lte\032\212\001!has(rules.gte) && !has(rules.gt) && (this.isNan() || this > rules.lte)? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'' + _FLOATRULES.fields_by_name['gt']._options = None + _FLOATRULES.fields_by_name['gt']._serialized_options = b'\302H\334\007\n\215\001\n\010float.gt\032\200\001!has(rules.lt) && !has(rules.lte) && (this.isNan() || this <= rules.gt)? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\303\001\n\013float.gt_lt\032\263\001has(rules.lt) && rules.lt >= rules.gt && (this.isNan() || this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\315\001\n\025float.gt_lt_exclusive\032\263\001has(rules.lt) && rules.lt < rules.gt && (this.isNan() || (rules.lt <= this && this <= rules.gt))? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\323\001\n\014float.gt_lte\032\302\001has(rules.lte) && rules.lte >= rules.gt && (this.isNan() || this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\335\001\n\026float.gt_lte_exclusive\032\302\001has(rules.lte) && rules.lte < rules.gt && (this.isNan() || (rules.lte < this && this <= rules.gt))? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'' + _FLOATRULES.fields_by_name['gte']._options = None + _FLOATRULES.fields_by_name['gte']._serialized_options = b'\302H\246\010\n\233\001\n\tfloat.gte\032\215\001!has(rules.lt) && !has(rules.lte) && (this.isNan() || this < rules.gte)? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\322\001\n\014float.gte_lt\032\301\001has(rules.lt) && rules.lt >= rules.gte && (this.isNan() || this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\334\001\n\026float.gte_lt_exclusive\032\301\001has(rules.lt) && rules.lt < rules.gte && (this.isNan() || (rules.lt <= this && this < rules.gte))? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\342\001\n\rfloat.gte_lte\032\320\001has(rules.lte) && rules.lte >= rules.gte && (this.isNan() || this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\354\001\n\027float.gte_lte_exclusive\032\320\001has(rules.lte) && rules.lte < rules.gte && (this.isNan() || (rules.lte < this && this < rules.gte))? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'' + _FLOATRULES.fields_by_name['in']._options = None + _FLOATRULES.fields_by_name['in']._serialized_options = b'\302Hp\nn\n\010float.in\032b!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'' + _FLOATRULES.fields_by_name['not_in']._options = None + _FLOATRULES.fields_by_name['not_in']._serialized_options = b'\302Hc\na\n\014float.not_in\032Qthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'' + _FLOATRULES.fields_by_name['finite']._options = None + _FLOATRULES.fields_by_name['finite']._serialized_options = b'\302Hb\n`\n\014float.finite\032Prules.finite ? (this.isNan() || this.isInf() ? \'value must be finite\' : \'\') : \'\'' + _FLOATRULES.fields_by_name['example']._options = None + _FLOATRULES.fields_by_name['example']._serialized_options = b'\302H\027\n\025\n\rfloat.example\032\004true' + _DOUBLERULES.fields_by_name['const']._options = None + _DOUBLERULES.fields_by_name['const']._serialized_options = b'\302Hr\np\n\014double.const\032`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'' + _DOUBLERULES.fields_by_name['lt']._options = None + _DOUBLERULES.fields_by_name['lt']._serialized_options = b'\302H\215\001\n\212\001\n\tdouble.lt\032}!has(rules.gte) && !has(rules.gt) && (this.isNan() || this >= rules.lt)? \'value must be less than %s\'.format([rules.lt]) : \'\'' + _DOUBLERULES.fields_by_name['lte']._options = None + _DOUBLERULES.fields_by_name['lte']._serialized_options = b'\302H\234\001\n\231\001\n\ndouble.lte\032\212\001!has(rules.gte) && !has(rules.gt) && (this.isNan() || this > rules.lte)? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'' + _DOUBLERULES.fields_by_name['gt']._options = None + _DOUBLERULES.fields_by_name['gt']._serialized_options = b'\302H\341\007\n\216\001\n\tdouble.gt\032\200\001!has(rules.lt) && !has(rules.lte) && (this.isNan() || this <= rules.gt)? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\304\001\n\014double.gt_lt\032\263\001has(rules.lt) && rules.lt >= rules.gt && (this.isNan() || this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\316\001\n\026double.gt_lt_exclusive\032\263\001has(rules.lt) && rules.lt < rules.gt && (this.isNan() || (rules.lt <= this && this <= rules.gt))? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\324\001\n\rdouble.gt_lte\032\302\001has(rules.lte) && rules.lte >= rules.gt && (this.isNan() || this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\336\001\n\027double.gt_lte_exclusive\032\302\001has(rules.lte) && rules.lte < rules.gt && (this.isNan() || (rules.lte < this && this <= rules.gt))? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'' + _DOUBLERULES.fields_by_name['gte']._options = None + _DOUBLERULES.fields_by_name['gte']._serialized_options = b'\302H\253\010\n\234\001\n\ndouble.gte\032\215\001!has(rules.lt) && !has(rules.lte) && (this.isNan() || this < rules.gte)? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\323\001\n\rdouble.gte_lt\032\301\001has(rules.lt) && rules.lt >= rules.gte && (this.isNan() || this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\335\001\n\027double.gte_lt_exclusive\032\301\001has(rules.lt) && rules.lt < rules.gte && (this.isNan() || (rules.lt <= this && this < rules.gte))? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\343\001\n\016double.gte_lte\032\320\001has(rules.lte) && rules.lte >= rules.gte && (this.isNan() || this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\355\001\n\030double.gte_lte_exclusive\032\320\001has(rules.lte) && rules.lte < rules.gte && (this.isNan() || (rules.lte < this && this < rules.gte))? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'' + _DOUBLERULES.fields_by_name['in']._options = None + _DOUBLERULES.fields_by_name['in']._serialized_options = b'\302Hq\no\n\tdouble.in\032b!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'' + _DOUBLERULES.fields_by_name['not_in']._options = None + _DOUBLERULES.fields_by_name['not_in']._serialized_options = b'\302Hd\nb\n\rdouble.not_in\032Qthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'' + _DOUBLERULES.fields_by_name['finite']._options = None + _DOUBLERULES.fields_by_name['finite']._serialized_options = b'\302Hc\na\n\rdouble.finite\032Prules.finite ? (this.isNan() || this.isInf() ? \'value must be finite\' : \'\') : \'\'' + _DOUBLERULES.fields_by_name['example']._options = None + _DOUBLERULES.fields_by_name['example']._serialized_options = b'\302H\030\n\026\n\016double.example\032\004true' + _INT32RULES.fields_by_name['const']._options = None + _INT32RULES.fields_by_name['const']._serialized_options = b'\302Hq\no\n\013int32.const\032`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'' + _INT32RULES.fields_by_name['lt']._options = None + _INT32RULES.fields_by_name['lt']._serialized_options = b'\302Hy\nw\n\010int32.lt\032k!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'' + _INT32RULES.fields_by_name['lte']._options = None + _INT32RULES.fields_by_name['lte']._serialized_options = b'\302H\210\001\n\205\001\n\tint32.lte\032x!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'' + _INT32RULES.fields_by_name['gt']._options = None + _INT32RULES.fields_by_name['gt']._serialized_options = b'\302H\204\007\nz\n\010int32.gt\032n!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\263\001\n\013int32.gt_lt\032\243\001has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\273\001\n\025int32.gt_lt_exclusive\032\241\001has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\303\001\n\014int32.gt_lte\032\262\001has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\313\001\n\026int32.gt_lte_exclusive\032\260\001has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'' + _INT32RULES.fields_by_name['gte']._options = None + _INT32RULES.fields_by_name['gte']._serialized_options = b'\302H\317\007\n\210\001\n\tint32.gte\032{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\302\001\n\014int32.gte_lt\032\261\001has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\312\001\n\026int32.gte_lt_exclusive\032\257\001has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\322\001\n\rint32.gte_lte\032\300\001has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\332\001\n\027int32.gte_lte_exclusive\032\276\001has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'' + _INT32RULES.fields_by_name['in']._options = None + _INT32RULES.fields_by_name['in']._serialized_options = b'\302Hp\nn\n\010int32.in\032b!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'' + _INT32RULES.fields_by_name['not_in']._options = None + _INT32RULES.fields_by_name['not_in']._serialized_options = b'\302Hc\na\n\014int32.not_in\032Qthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'' + _INT32RULES.fields_by_name['example']._options = None + _INT32RULES.fields_by_name['example']._serialized_options = b'\302H\027\n\025\n\rint32.example\032\004true' + _INT64RULES.fields_by_name['const']._options = None + _INT64RULES.fields_by_name['const']._serialized_options = b'\302Hq\no\n\013int64.const\032`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'' + _INT64RULES.fields_by_name['lt']._options = None + _INT64RULES.fields_by_name['lt']._serialized_options = b'\302Hy\nw\n\010int64.lt\032k!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'' + _INT64RULES.fields_by_name['lte']._options = None + _INT64RULES.fields_by_name['lte']._serialized_options = b'\302H\210\001\n\205\001\n\tint64.lte\032x!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'' + _INT64RULES.fields_by_name['gt']._options = None + _INT64RULES.fields_by_name['gt']._serialized_options = b'\302H\204\007\nz\n\010int64.gt\032n!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\263\001\n\013int64.gt_lt\032\243\001has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\273\001\n\025int64.gt_lt_exclusive\032\241\001has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\303\001\n\014int64.gt_lte\032\262\001has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\313\001\n\026int64.gt_lte_exclusive\032\260\001has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'' + _INT64RULES.fields_by_name['gte']._options = None + _INT64RULES.fields_by_name['gte']._serialized_options = b'\302H\317\007\n\210\001\n\tint64.gte\032{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\302\001\n\014int64.gte_lt\032\261\001has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\312\001\n\026int64.gte_lt_exclusive\032\257\001has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\322\001\n\rint64.gte_lte\032\300\001has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\332\001\n\027int64.gte_lte_exclusive\032\276\001has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'' + _INT64RULES.fields_by_name['in']._options = None + _INT64RULES.fields_by_name['in']._serialized_options = b'\302Hp\nn\n\010int64.in\032b!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'' + _INT64RULES.fields_by_name['not_in']._options = None + _INT64RULES.fields_by_name['not_in']._serialized_options = b'\302Hc\na\n\014int64.not_in\032Qthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'' + _INT64RULES.fields_by_name['example']._options = None + _INT64RULES.fields_by_name['example']._serialized_options = b'\302H\027\n\025\n\rint64.example\032\004true' + _UINT32RULES.fields_by_name['const']._options = None + _UINT32RULES.fields_by_name['const']._serialized_options = b'\302Hr\np\n\014uint32.const\032`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'' + _UINT32RULES.fields_by_name['lt']._options = None + _UINT32RULES.fields_by_name['lt']._serialized_options = b'\302Hz\nx\n\tuint32.lt\032k!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'' + _UINT32RULES.fields_by_name['lte']._options = None + _UINT32RULES.fields_by_name['lte']._serialized_options = b'\302H\211\001\n\206\001\n\nuint32.lte\032x!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'' + _UINT32RULES.fields_by_name['gt']._options = None + _UINT32RULES.fields_by_name['gt']._serialized_options = b'\302H\211\007\n{\n\tuint32.gt\032n!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\264\001\n\014uint32.gt_lt\032\243\001has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\274\001\n\026uint32.gt_lt_exclusive\032\241\001has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\304\001\n\ruint32.gt_lte\032\262\001has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\314\001\n\027uint32.gt_lte_exclusive\032\260\001has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'' + _UINT32RULES.fields_by_name['gte']._options = None + _UINT32RULES.fields_by_name['gte']._serialized_options = b'\302H\324\007\n\211\001\n\nuint32.gte\032{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\303\001\n\ruint32.gte_lt\032\261\001has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\313\001\n\027uint32.gte_lt_exclusive\032\257\001has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\323\001\n\016uint32.gte_lte\032\300\001has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\333\001\n\030uint32.gte_lte_exclusive\032\276\001has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'' + _UINT32RULES.fields_by_name['in']._options = None + _UINT32RULES.fields_by_name['in']._serialized_options = b'\302Hq\no\n\tuint32.in\032b!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'' + _UINT32RULES.fields_by_name['not_in']._options = None + _UINT32RULES.fields_by_name['not_in']._serialized_options = b'\302Hd\nb\n\ruint32.not_in\032Qthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'' + _UINT32RULES.fields_by_name['example']._options = None + _UINT32RULES.fields_by_name['example']._serialized_options = b'\302H\030\n\026\n\016uint32.example\032\004true' + _UINT64RULES.fields_by_name['const']._options = None + _UINT64RULES.fields_by_name['const']._serialized_options = b'\302Hr\np\n\014uint64.const\032`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'' + _UINT64RULES.fields_by_name['lt']._options = None + _UINT64RULES.fields_by_name['lt']._serialized_options = b'\302Hz\nx\n\tuint64.lt\032k!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'' + _UINT64RULES.fields_by_name['lte']._options = None + _UINT64RULES.fields_by_name['lte']._serialized_options = b'\302H\211\001\n\206\001\n\nuint64.lte\032x!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'' + _UINT64RULES.fields_by_name['gt']._options = None + _UINT64RULES.fields_by_name['gt']._serialized_options = b'\302H\211\007\n{\n\tuint64.gt\032n!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\264\001\n\014uint64.gt_lt\032\243\001has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\274\001\n\026uint64.gt_lt_exclusive\032\241\001has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\304\001\n\ruint64.gt_lte\032\262\001has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\314\001\n\027uint64.gt_lte_exclusive\032\260\001has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'' + _UINT64RULES.fields_by_name['gte']._options = None + _UINT64RULES.fields_by_name['gte']._serialized_options = b'\302H\324\007\n\211\001\n\nuint64.gte\032{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\303\001\n\ruint64.gte_lt\032\261\001has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\313\001\n\027uint64.gte_lt_exclusive\032\257\001has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\323\001\n\016uint64.gte_lte\032\300\001has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\333\001\n\030uint64.gte_lte_exclusive\032\276\001has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'' + _UINT64RULES.fields_by_name['in']._options = None + _UINT64RULES.fields_by_name['in']._serialized_options = b'\302Hq\no\n\tuint64.in\032b!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'' + _UINT64RULES.fields_by_name['not_in']._options = None + _UINT64RULES.fields_by_name['not_in']._serialized_options = b'\302Hd\nb\n\ruint64.not_in\032Qthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'' + _UINT64RULES.fields_by_name['example']._options = None + _UINT64RULES.fields_by_name['example']._serialized_options = b'\302H\030\n\026\n\016uint64.example\032\004true' + _SINT32RULES.fields_by_name['const']._options = None + _SINT32RULES.fields_by_name['const']._serialized_options = b'\302Hr\np\n\014sint32.const\032`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'' + _SINT32RULES.fields_by_name['lt']._options = None + _SINT32RULES.fields_by_name['lt']._serialized_options = b'\302Hz\nx\n\tsint32.lt\032k!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'' + _SINT32RULES.fields_by_name['lte']._options = None + _SINT32RULES.fields_by_name['lte']._serialized_options = b'\302H\211\001\n\206\001\n\nsint32.lte\032x!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'' + _SINT32RULES.fields_by_name['gt']._options = None + _SINT32RULES.fields_by_name['gt']._serialized_options = b'\302H\211\007\n{\n\tsint32.gt\032n!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\264\001\n\014sint32.gt_lt\032\243\001has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\274\001\n\026sint32.gt_lt_exclusive\032\241\001has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\304\001\n\rsint32.gt_lte\032\262\001has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\314\001\n\027sint32.gt_lte_exclusive\032\260\001has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'' + _SINT32RULES.fields_by_name['gte']._options = None + _SINT32RULES.fields_by_name['gte']._serialized_options = b'\302H\324\007\n\211\001\n\nsint32.gte\032{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\303\001\n\rsint32.gte_lt\032\261\001has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\313\001\n\027sint32.gte_lt_exclusive\032\257\001has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\323\001\n\016sint32.gte_lte\032\300\001has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\333\001\n\030sint32.gte_lte_exclusive\032\276\001has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'' + _SINT32RULES.fields_by_name['in']._options = None + _SINT32RULES.fields_by_name['in']._serialized_options = b'\302Hq\no\n\tsint32.in\032b!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'' + _SINT32RULES.fields_by_name['not_in']._options = None + _SINT32RULES.fields_by_name['not_in']._serialized_options = b'\302Hd\nb\n\rsint32.not_in\032Qthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'' + _SINT32RULES.fields_by_name['example']._options = None + _SINT32RULES.fields_by_name['example']._serialized_options = b'\302H\030\n\026\n\016sint32.example\032\004true' + _SINT64RULES.fields_by_name['const']._options = None + _SINT64RULES.fields_by_name['const']._serialized_options = b'\302Hr\np\n\014sint64.const\032`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'' + _SINT64RULES.fields_by_name['lt']._options = None + _SINT64RULES.fields_by_name['lt']._serialized_options = b'\302Hz\nx\n\tsint64.lt\032k!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'' + _SINT64RULES.fields_by_name['lte']._options = None + _SINT64RULES.fields_by_name['lte']._serialized_options = b'\302H\211\001\n\206\001\n\nsint64.lte\032x!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'' + _SINT64RULES.fields_by_name['gt']._options = None + _SINT64RULES.fields_by_name['gt']._serialized_options = b'\302H\211\007\n{\n\tsint64.gt\032n!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\264\001\n\014sint64.gt_lt\032\243\001has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\274\001\n\026sint64.gt_lt_exclusive\032\241\001has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\304\001\n\rsint64.gt_lte\032\262\001has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\314\001\n\027sint64.gt_lte_exclusive\032\260\001has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'' + _SINT64RULES.fields_by_name['gte']._options = None + _SINT64RULES.fields_by_name['gte']._serialized_options = b'\302H\324\007\n\211\001\n\nsint64.gte\032{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\303\001\n\rsint64.gte_lt\032\261\001has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\313\001\n\027sint64.gte_lt_exclusive\032\257\001has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\323\001\n\016sint64.gte_lte\032\300\001has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\333\001\n\030sint64.gte_lte_exclusive\032\276\001has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'' + _SINT64RULES.fields_by_name['in']._options = None + _SINT64RULES.fields_by_name['in']._serialized_options = b'\302Hq\no\n\tsint64.in\032b!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'' + _SINT64RULES.fields_by_name['not_in']._options = None + _SINT64RULES.fields_by_name['not_in']._serialized_options = b'\302Hd\nb\n\rsint64.not_in\032Qthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'' + _SINT64RULES.fields_by_name['example']._options = None + _SINT64RULES.fields_by_name['example']._serialized_options = b'\302H\030\n\026\n\016sint64.example\032\004true' + _FIXED32RULES.fields_by_name['const']._options = None + _FIXED32RULES.fields_by_name['const']._serialized_options = b'\302Hs\nq\n\rfixed32.const\032`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'' + _FIXED32RULES.fields_by_name['lt']._options = None + _FIXED32RULES.fields_by_name['lt']._serialized_options = b'\302H{\ny\n\nfixed32.lt\032k!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'' + _FIXED32RULES.fields_by_name['lte']._options = None + _FIXED32RULES.fields_by_name['lte']._serialized_options = b'\302H\212\001\n\207\001\n\013fixed32.lte\032x!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'' + _FIXED32RULES.fields_by_name['gt']._options = None + _FIXED32RULES.fields_by_name['gt']._serialized_options = b'\302H\216\007\n|\n\nfixed32.gt\032n!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\265\001\n\rfixed32.gt_lt\032\243\001has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\275\001\n\027fixed32.gt_lt_exclusive\032\241\001has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\305\001\n\016fixed32.gt_lte\032\262\001has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\315\001\n\030fixed32.gt_lte_exclusive\032\260\001has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'' + _FIXED32RULES.fields_by_name['gte']._options = None + _FIXED32RULES.fields_by_name['gte']._serialized_options = b'\302H\331\007\n\212\001\n\013fixed32.gte\032{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\304\001\n\016fixed32.gte_lt\032\261\001has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\314\001\n\030fixed32.gte_lt_exclusive\032\257\001has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\324\001\n\017fixed32.gte_lte\032\300\001has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\334\001\n\031fixed32.gte_lte_exclusive\032\276\001has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'' + _FIXED32RULES.fields_by_name['in']._options = None + _FIXED32RULES.fields_by_name['in']._serialized_options = b'\302Hr\np\n\nfixed32.in\032b!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'' + _FIXED32RULES.fields_by_name['not_in']._options = None + _FIXED32RULES.fields_by_name['not_in']._serialized_options = b'\302He\nc\n\016fixed32.not_in\032Qthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'' + _FIXED32RULES.fields_by_name['example']._options = None + _FIXED32RULES.fields_by_name['example']._serialized_options = b'\302H\031\n\027\n\017fixed32.example\032\004true' + _FIXED64RULES.fields_by_name['const']._options = None + _FIXED64RULES.fields_by_name['const']._serialized_options = b'\302Hs\nq\n\rfixed64.const\032`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'' + _FIXED64RULES.fields_by_name['lt']._options = None + _FIXED64RULES.fields_by_name['lt']._serialized_options = b'\302H{\ny\n\nfixed64.lt\032k!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'' + _FIXED64RULES.fields_by_name['lte']._options = None + _FIXED64RULES.fields_by_name['lte']._serialized_options = b'\302H\212\001\n\207\001\n\013fixed64.lte\032x!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'' + _FIXED64RULES.fields_by_name['gt']._options = None + _FIXED64RULES.fields_by_name['gt']._serialized_options = b'\302H\216\007\n|\n\nfixed64.gt\032n!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\265\001\n\rfixed64.gt_lt\032\243\001has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\275\001\n\027fixed64.gt_lt_exclusive\032\241\001has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\305\001\n\016fixed64.gt_lte\032\262\001has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\315\001\n\030fixed64.gt_lte_exclusive\032\260\001has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'' + _FIXED64RULES.fields_by_name['gte']._options = None + _FIXED64RULES.fields_by_name['gte']._serialized_options = b'\302H\331\007\n\212\001\n\013fixed64.gte\032{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\304\001\n\016fixed64.gte_lt\032\261\001has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\314\001\n\030fixed64.gte_lt_exclusive\032\257\001has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\324\001\n\017fixed64.gte_lte\032\300\001has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\334\001\n\031fixed64.gte_lte_exclusive\032\276\001has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'' + _FIXED64RULES.fields_by_name['in']._options = None + _FIXED64RULES.fields_by_name['in']._serialized_options = b'\302Hr\np\n\nfixed64.in\032b!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'' + _FIXED64RULES.fields_by_name['not_in']._options = None + _FIXED64RULES.fields_by_name['not_in']._serialized_options = b'\302He\nc\n\016fixed64.not_in\032Qthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'' + _FIXED64RULES.fields_by_name['example']._options = None + _FIXED64RULES.fields_by_name['example']._serialized_options = b'\302H\031\n\027\n\017fixed64.example\032\004true' + _SFIXED32RULES.fields_by_name['const']._options = None + _SFIXED32RULES.fields_by_name['const']._serialized_options = b'\302Ht\nr\n\016sfixed32.const\032`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'' + _SFIXED32RULES.fields_by_name['lt']._options = None + _SFIXED32RULES.fields_by_name['lt']._serialized_options = b'\302H|\nz\n\013sfixed32.lt\032k!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'' + _SFIXED32RULES.fields_by_name['lte']._options = None + _SFIXED32RULES.fields_by_name['lte']._serialized_options = b'\302H\213\001\n\210\001\n\014sfixed32.lte\032x!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'' + _SFIXED32RULES.fields_by_name['gt']._options = None + _SFIXED32RULES.fields_by_name['gt']._serialized_options = b'\302H\223\007\n}\n\013sfixed32.gt\032n!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\266\001\n\016sfixed32.gt_lt\032\243\001has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\276\001\n\030sfixed32.gt_lt_exclusive\032\241\001has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\306\001\n\017sfixed32.gt_lte\032\262\001has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\316\001\n\031sfixed32.gt_lte_exclusive\032\260\001has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'' + _SFIXED32RULES.fields_by_name['gte']._options = None + _SFIXED32RULES.fields_by_name['gte']._serialized_options = b'\302H\336\007\n\213\001\n\014sfixed32.gte\032{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\305\001\n\017sfixed32.gte_lt\032\261\001has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\315\001\n\031sfixed32.gte_lt_exclusive\032\257\001has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\325\001\n\020sfixed32.gte_lte\032\300\001has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\335\001\n\032sfixed32.gte_lte_exclusive\032\276\001has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'' + _SFIXED32RULES.fields_by_name['in']._options = None + _SFIXED32RULES.fields_by_name['in']._serialized_options = b'\302Hs\nq\n\013sfixed32.in\032b!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'' + _SFIXED32RULES.fields_by_name['not_in']._options = None + _SFIXED32RULES.fields_by_name['not_in']._serialized_options = b'\302Hf\nd\n\017sfixed32.not_in\032Qthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'' + _SFIXED32RULES.fields_by_name['example']._options = None + _SFIXED32RULES.fields_by_name['example']._serialized_options = b'\302H\032\n\030\n\020sfixed32.example\032\004true' + _SFIXED64RULES.fields_by_name['const']._options = None + _SFIXED64RULES.fields_by_name['const']._serialized_options = b'\302Ht\nr\n\016sfixed64.const\032`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'' + _SFIXED64RULES.fields_by_name['lt']._options = None + _SFIXED64RULES.fields_by_name['lt']._serialized_options = b'\302H|\nz\n\013sfixed64.lt\032k!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'' + _SFIXED64RULES.fields_by_name['lte']._options = None + _SFIXED64RULES.fields_by_name['lte']._serialized_options = b'\302H\213\001\n\210\001\n\014sfixed64.lte\032x!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'' + _SFIXED64RULES.fields_by_name['gt']._options = None + _SFIXED64RULES.fields_by_name['gt']._serialized_options = b'\302H\223\007\n}\n\013sfixed64.gt\032n!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\266\001\n\016sfixed64.gt_lt\032\243\001has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\276\001\n\030sfixed64.gt_lt_exclusive\032\241\001has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\306\001\n\017sfixed64.gt_lte\032\262\001has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\316\001\n\031sfixed64.gt_lte_exclusive\032\260\001has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'' + _SFIXED64RULES.fields_by_name['gte']._options = None + _SFIXED64RULES.fields_by_name['gte']._serialized_options = b'\302H\336\007\n\213\001\n\014sfixed64.gte\032{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\305\001\n\017sfixed64.gte_lt\032\261\001has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\315\001\n\031sfixed64.gte_lt_exclusive\032\257\001has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\325\001\n\020sfixed64.gte_lte\032\300\001has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\335\001\n\032sfixed64.gte_lte_exclusive\032\276\001has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'' + _SFIXED64RULES.fields_by_name['in']._options = None + _SFIXED64RULES.fields_by_name['in']._serialized_options = b'\302Hs\nq\n\013sfixed64.in\032b!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'' + _SFIXED64RULES.fields_by_name['not_in']._options = None + _SFIXED64RULES.fields_by_name['not_in']._serialized_options = b'\302Hf\nd\n\017sfixed64.not_in\032Qthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'' + _SFIXED64RULES.fields_by_name['example']._options = None + _SFIXED64RULES.fields_by_name['example']._serialized_options = b'\302H\032\n\030\n\020sfixed64.example\032\004true' + _BOOLRULES.fields_by_name['const']._options = None + _BOOLRULES.fields_by_name['const']._serialized_options = b'\302Hp\nn\n\nbool.const\032`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'' + _BOOLRULES.fields_by_name['example']._options = None + _BOOLRULES.fields_by_name['example']._serialized_options = b'\302H\026\n\024\n\014bool.example\032\004true' + _STRINGRULES.fields_by_name['const']._options = None + _STRINGRULES.fields_by_name['const']._serialized_options = b'\302Ht\nr\n\014string.const\032bthis != getField(rules, \'const\') ? \'value must equal `%s`\'.format([getField(rules, \'const\')]) : \'\'' + _STRINGRULES.fields_by_name['len']._options = None + _STRINGRULES.fields_by_name['len']._serialized_options = b'\302Hn\nl\n\nstring.len\032^uint(this.size()) != rules.len ? \'value length must be %s characters\'.format([rules.len]) : \'\'' + _STRINGRULES.fields_by_name['min_len']._options = None + _STRINGRULES.fields_by_name['min_len']._serialized_options = b'\302H\203\001\n\200\001\n\016string.min_len\032nuint(this.size()) < rules.min_len ? \'value length must be at least %s characters\'.format([rules.min_len]) : \'\'' + _STRINGRULES.fields_by_name['max_len']._options = None + _STRINGRULES.fields_by_name['max_len']._serialized_options = b'\302H\201\001\n\177\n\016string.max_len\032muint(this.size()) > rules.max_len ? \'value length must be at most %s characters\'.format([rules.max_len]) : \'\'' + _STRINGRULES.fields_by_name['len_bytes']._options = None + _STRINGRULES.fields_by_name['len_bytes']._serialized_options = b'\302H\203\001\n\200\001\n\020string.len_bytes\032luint(bytes(this).size()) != rules.len_bytes ? \'value length must be %s bytes\'.format([rules.len_bytes]) : \'\'' + _STRINGRULES.fields_by_name['min_bytes']._options = None + _STRINGRULES.fields_by_name['min_bytes']._serialized_options = b'\302H\213\001\n\210\001\n\020string.min_bytes\032tuint(bytes(this).size()) < rules.min_bytes ? \'value length must be at least %s bytes\'.format([rules.min_bytes]) : \'\'' + _STRINGRULES.fields_by_name['max_bytes']._options = None + _STRINGRULES.fields_by_name['max_bytes']._serialized_options = b'\302H\212\001\n\207\001\n\020string.max_bytes\032suint(bytes(this).size()) > rules.max_bytes ? \'value length must be at most %s bytes\'.format([rules.max_bytes]) : \'\'' + _STRINGRULES.fields_by_name['pattern']._options = None + _STRINGRULES.fields_by_name['pattern']._serialized_options = b'\302Hy\nw\n\016string.pattern\032e!this.matches(rules.pattern) ? \'value does not match regex pattern `%s`\'.format([rules.pattern]) : \'\'' + _STRINGRULES.fields_by_name['prefix']._options = None + _STRINGRULES.fields_by_name['prefix']._serialized_options = b'\302Hq\no\n\rstring.prefix\032^!this.startsWith(rules.prefix) ? \'value does not have prefix `%s`\'.format([rules.prefix]) : \'\'' + _STRINGRULES.fields_by_name['suffix']._options = None + _STRINGRULES.fields_by_name['suffix']._serialized_options = b'\302Ho\nm\n\rstring.suffix\032\\!this.endsWith(rules.suffix) ? \'value does not have suffix `%s`\'.format([rules.suffix]) : \'\'' + _STRINGRULES.fields_by_name['contains']._options = None + _STRINGRULES.fields_by_name['contains']._serialized_options = b'\302H{\ny\n\017string.contains\032f!this.contains(rules.contains) ? \'value does not contain substring `%s`\'.format([rules.contains]) : \'\'' + _STRINGRULES.fields_by_name['not_contains']._options = None + _STRINGRULES.fields_by_name['not_contains']._serialized_options = b'\302H~\n|\n\023string.not_contains\032ethis.contains(rules.not_contains) ? \'value contains substring `%s`\'.format([rules.not_contains]) : \'\'' + _STRINGRULES.fields_by_name['in']._options = None + _STRINGRULES.fields_by_name['in']._serialized_options = b'\302Hq\no\n\tstring.in\032b!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'' + _STRINGRULES.fields_by_name['not_in']._options = None + _STRINGRULES.fields_by_name['not_in']._serialized_options = b'\302Hd\nb\n\rstring.not_in\032Qthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'' + _STRINGRULES.fields_by_name['email']._options = None + _STRINGRULES.fields_by_name['email']._serialized_options = b'\302H\311\001\na\n\014string.email\022#value must be a valid email address\032,!rules.email || this == \'\' || this.isEmail()\nd\n\022string.email_empty\0222value is empty, which is not a valid email address\032\032!rules.email || this != \'\'' + _STRINGRULES.fields_by_name['hostname']._options = None + _STRINGRULES.fields_by_name['hostname']._serialized_options = b'\302H\316\001\ne\n\017string.hostname\022\036value must be a valid hostname\0322!rules.hostname || this == \'\' || this.isHostname()\ne\n\025string.hostname_empty\022-value is empty, which is not a valid hostname\032\035!rules.hostname || this != \'\'' + _STRINGRULES.fields_by_name['ip']._options = None + _STRINGRULES.fields_by_name['ip']._serialized_options = b'\302H\264\001\nU\n\tstring.ip\022 value must be a valid IP address\032&!rules.ip || this == \'\' || this.isIp()\n[\n\017string.ip_empty\022/value is empty, which is not a valid IP address\032\027!rules.ip || this != \'\'' + _STRINGRULES.fields_by_name['ipv4']._options = None + _STRINGRULES.fields_by_name['ipv4']._serialized_options = b'\302H\301\001\n\\\n\013string.ipv4\022\"value must be a valid IPv4 address\032)!rules.ipv4 || this == \'\' || this.isIp(4)\na\n\021string.ipv4_empty\0221value is empty, which is not a valid IPv4 address\032\031!rules.ipv4 || this != \'\'' + _STRINGRULES.fields_by_name['ipv6']._options = None + _STRINGRULES.fields_by_name['ipv6']._serialized_options = b'\302H\301\001\n\\\n\013string.ipv6\022\"value must be a valid IPv6 address\032)!rules.ipv6 || this == \'\' || this.isIp(6)\na\n\021string.ipv6_empty\0221value is empty, which is not a valid IPv6 address\032\031!rules.ipv6 || this != \'\'' + _STRINGRULES.fields_by_name['uri']._options = None + _STRINGRULES.fields_by_name['uri']._serialized_options = b'\302H\253\001\nQ\n\nstring.uri\022\031value must be a valid URI\032(!rules.uri || this == \'\' || this.isUri()\nV\n\020string.uri_empty\022(value is empty, which is not a valid URI\032\030!rules.uri || this != \'\'' + _STRINGRULES.fields_by_name['uri_ref']._options = None + _STRINGRULES.fields_by_name['uri_ref']._serialized_options = b'\302HZ\nX\n\016string.uri_ref\022#value must be a valid URI Reference\032!!rules.uri_ref || this.isUriRef()' + _STRINGRULES.fields_by_name['address']._options = None + _STRINGRULES.fields_by_name['address']._serialized_options = b'\302H\370\001\n\201\001\n\016string.address\022-value must be a valid hostname, or ip address\032@!rules.address || this == \'\' || this.isHostname() || this.isIp()\nr\n\024string.address_empty\022!rules.ipv4_with_prefixlen || this == \'\' || this.isIpPrefix(4)\n\222\001\n string.ipv4_with_prefixlen_empty\022Dvalue is empty, which is not a valid IPv4 address with prefix length\032(!rules.ipv4_with_prefixlen || this != \'\'' + _STRINGRULES.fields_by_name['ipv6_with_prefixlen']._options = None + _STRINGRULES.fields_by_name['ipv6_with_prefixlen']._serialized_options = b'\302H\253\002\n\223\001\n\032string.ipv6_with_prefixlen\0225value must be a valid IPv6 address with prefix length\032>!rules.ipv6_with_prefixlen || this == \'\' || this.isIpPrefix(6)\n\222\001\n string.ipv6_with_prefixlen_empty\022Dvalue is empty, which is not a valid IPv6 address with prefix length\032(!rules.ipv6_with_prefixlen || this != \'\'' + _STRINGRULES.fields_by_name['ip_prefix']._options = None + _STRINGRULES.fields_by_name['ip_prefix']._serialized_options = b'\302H\330\001\nl\n\020string.ip_prefix\022\037value must be a valid IP prefix\0327!rules.ip_prefix || this == \'\' || this.isIpPrefix(true)\nh\n\026string.ip_prefix_empty\022.value is empty, which is not a valid IP prefix\032\036!rules.ip_prefix || this != \'\'' + _STRINGRULES.fields_by_name['ipv4_prefix']._options = None + _STRINGRULES.fields_by_name['ipv4_prefix']._serialized_options = b'\302H\347\001\nu\n\022string.ipv4_prefix\022!value must be a valid IPv4 prefix\032!rules.host_and_port || this == \'\' || this.isHostAndPort(true)\ny\n\032string.host_and_port_empty\0227value is empty, which is not a valid host and port pair\032\"!rules.host_and_port || this != \'\'' + _STRINGRULES.fields_by_name['well_known_regex']._options = None + _STRINGRULES.fields_by_name['well_known_regex']._serialized_options = b'\302H\355\004\n\360\001\n#string.well_known_regex.header_name\022&value must be a valid HTTP header name\032\240\001rules.well_known_regex != 1 || this == \'\' || this.matches(!has(rules.strict) || rules.strict ?\'^:?[0-9a-zA-Z!#$%&\\\'*+-.^_|~\\x60]+$\' :\'^[^\\u0000\\u000A\\u000D]+$\')\n\215\001\n)string.well_known_regex.header_name_empty\0225value is empty, which is not a valid HTTP header name\032)rules.well_known_regex != 1 || this != \'\'\n\347\001\n$string.well_known_regex.header_value\022\'value must be a valid HTTP header value\032\225\001rules.well_known_regex != 2 || this.matches(!has(rules.strict) || rules.strict ?\'^[^\\u0000-\\u0008\\u000A-\\u001F\\u007F]*$\' :\'^[^\\u0000\\u000A\\u000D]*$\')' + _STRINGRULES.fields_by_name['example']._options = None + _STRINGRULES.fields_by_name['example']._serialized_options = b'\302H\030\n\026\n\016string.example\032\004true' + _BYTESRULES.fields_by_name['const']._options = None + _BYTESRULES.fields_by_name['const']._serialized_options = b'\302Hn\nl\n\013bytes.const\032]this != getField(rules, \'const\') ? \'value must be %x\'.format([getField(rules, \'const\')]) : \'\'' + _BYTESRULES.fields_by_name['len']._options = None + _BYTESRULES.fields_by_name['len']._serialized_options = b'\302Hh\nf\n\tbytes.len\032Yuint(this.size()) != rules.len ? \'value length must be %s bytes\'.format([rules.len]) : \'\'' + _BYTESRULES.fields_by_name['min_len']._options = None + _BYTESRULES.fields_by_name['min_len']._serialized_options = b'\302H|\nz\n\rbytes.min_len\032iuint(this.size()) < rules.min_len ? \'value length must be at least %s bytes\'.format([rules.min_len]) : \'\'' + _BYTESRULES.fields_by_name['max_len']._options = None + _BYTESRULES.fields_by_name['max_len']._serialized_options = b'\302Ht\nr\n\rbytes.max_len\032auint(this.size()) > rules.max_len ? \'value must be at most %s bytes\'.format([rules.max_len]) : \'\'' + _BYTESRULES.fields_by_name['pattern']._options = None + _BYTESRULES.fields_by_name['pattern']._serialized_options = b'\302H|\nz\n\rbytes.pattern\032i!string(this).matches(rules.pattern) ? \'value must match regex pattern `%s`\'.format([rules.pattern]) : \'\'' + _BYTESRULES.fields_by_name['prefix']._options = None + _BYTESRULES.fields_by_name['prefix']._serialized_options = b'\302Hn\nl\n\014bytes.prefix\032\\!this.startsWith(rules.prefix) ? \'value does not have prefix %x\'.format([rules.prefix]) : \'\'' + _BYTESRULES.fields_by_name['suffix']._options = None + _BYTESRULES.fields_by_name['suffix']._serialized_options = b'\302Hl\nj\n\014bytes.suffix\032Z!this.endsWith(rules.suffix) ? \'value does not have suffix %x\'.format([rules.suffix]) : \'\'' + _BYTESRULES.fields_by_name['contains']._options = None + _BYTESRULES.fields_by_name['contains']._serialized_options = b'\302Hn\nl\n\016bytes.contains\032Z!this.contains(rules.contains) ? \'value does not contain %x\'.format([rules.contains]) : \'\'' + _BYTESRULES.fields_by_name['in']._options = None + _BYTESRULES.fields_by_name['in']._serialized_options = b'\302H\226\001\n\223\001\n\010bytes.in\032\206\001getField(rules, \'in\').size() > 0 && !(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'' + _BYTESRULES.fields_by_name['not_in']._options = None + _BYTESRULES.fields_by_name['not_in']._serialized_options = b'\302Hc\na\n\014bytes.not_in\032Qthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'' + _BYTESRULES.fields_by_name['ip']._options = None + _BYTESRULES.fields_by_name['ip']._serialized_options = b'\302H\330\001\nt\n\010bytes.ip\022 value must be a valid IP address\032F!rules.ip || this.size() == 0 || this.size() == 4 || this.size() == 16\n`\n\016bytes.ip_empty\022/value is empty, which is not a valid IP address\032\035!rules.ip || this.size() != 0' + _BYTESRULES.fields_by_name['ipv4']._options = None + _BYTESRULES.fields_by_name['ipv4']._serialized_options = b'\302H\317\001\ne\n\nbytes.ipv4\022\"value must be a valid IPv4 address\0323!rules.ipv4 || this.size() == 0 || this.size() == 4\nf\n\020bytes.ipv4_empty\0221value is empty, which is not a valid IPv4 address\032\037!rules.ipv4 || this.size() != 0' + _BYTESRULES.fields_by_name['ipv6']._options = None + _BYTESRULES.fields_by_name['ipv6']._serialized_options = b'\302H\320\001\nf\n\nbytes.ipv6\022\"value must be a valid IPv6 address\0324!rules.ipv6 || this.size() == 0 || this.size() == 16\nf\n\020bytes.ipv6_empty\0221value is empty, which is not a valid IPv6 address\032\037!rules.ipv6 || this.size() != 0' + _BYTESRULES.fields_by_name['example']._options = None + _BYTESRULES.fields_by_name['example']._serialized_options = b'\302H\027\n\025\n\rbytes.example\032\004true' + _ENUMRULES.fields_by_name['const']._options = None + _ENUMRULES.fields_by_name['const']._serialized_options = b'\302Hp\nn\n\nenum.const\032`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'' + _ENUMRULES.fields_by_name['in']._options = None + _ENUMRULES.fields_by_name['in']._serialized_options = b'\302Ho\nm\n\007enum.in\032b!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'' + _ENUMRULES.fields_by_name['not_in']._options = None + _ENUMRULES.fields_by_name['not_in']._serialized_options = b'\302Hb\n`\n\013enum.not_in\032Qthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'' + _ENUMRULES.fields_by_name['example']._options = None + _ENUMRULES.fields_by_name['example']._serialized_options = b'\302H\026\n\024\n\014enum.example\032\004true' + _REPEATEDRULES.fields_by_name['min_items']._options = None + _REPEATEDRULES.fields_by_name['min_items']._serialized_options = b'\302H\206\001\n\203\001\n\022repeated.min_items\032muint(this.size()) < rules.min_items ? \'value must contain at least %d item(s)\'.format([rules.min_items]) : \'\'' + _REPEATEDRULES.fields_by_name['max_items']._options = None + _REPEATEDRULES.fields_by_name['max_items']._serialized_options = b'\302H\212\001\n\207\001\n\022repeated.max_items\032quint(this.size()) > rules.max_items ? \'value must contain no more than %s item(s)\'.format([rules.max_items]) : \'\'' + _REPEATEDRULES.fields_by_name['unique']._options = None + _REPEATEDRULES.fields_by_name['unique']._serialized_options = b'\302H]\n[\n\017repeated.unique\022(repeated value must contain unique items\032\036!rules.unique || this.unique()' + _MAPRULES.fields_by_name['min_pairs']._options = None + _MAPRULES.fields_by_name['min_pairs']._serialized_options = b'\302Hy\nw\n\rmap.min_pairs\032fuint(this.size()) < rules.min_pairs ? \'map must be at least %d entries\'.format([rules.min_pairs]) : \'\'' + _MAPRULES.fields_by_name['max_pairs']._options = None + _MAPRULES.fields_by_name['max_pairs']._serialized_options = b'\302Hx\nv\n\rmap.max_pairs\032euint(this.size()) > rules.max_pairs ? \'map must be at most %d entries\'.format([rules.max_pairs]) : \'\'' + _DURATIONRULES.fields_by_name['const']._options = None + _DURATIONRULES.fields_by_name['const']._serialized_options = b'\302Ht\nr\n\016duration.const\032`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'' + _DURATIONRULES.fields_by_name['lt']._options = None + _DURATIONRULES.fields_by_name['lt']._serialized_options = b'\302H|\nz\n\013duration.lt\032k!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'' + _DURATIONRULES.fields_by_name['lte']._options = None + _DURATIONRULES.fields_by_name['lte']._serialized_options = b'\302H\213\001\n\210\001\n\014duration.lte\032x!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'' + _DURATIONRULES.fields_by_name['gt']._options = None + _DURATIONRULES.fields_by_name['gt']._serialized_options = b'\302H\223\007\n}\n\013duration.gt\032n!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\266\001\n\016duration.gt_lt\032\243\001has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\276\001\n\030duration.gt_lt_exclusive\032\241\001has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\306\001\n\017duration.gt_lte\032\262\001has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\316\001\n\031duration.gt_lte_exclusive\032\260\001has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'' + _DURATIONRULES.fields_by_name['gte']._options = None + _DURATIONRULES.fields_by_name['gte']._serialized_options = b'\302H\336\007\n\213\001\n\014duration.gte\032{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\305\001\n\017duration.gte_lt\032\261\001has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\315\001\n\031duration.gte_lt_exclusive\032\257\001has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\325\001\n\020duration.gte_lte\032\300\001has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\335\001\n\032duration.gte_lte_exclusive\032\276\001has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'' + _DURATIONRULES.fields_by_name['in']._options = None + _DURATIONRULES.fields_by_name['in']._serialized_options = b'\302Hs\nq\n\013duration.in\032b!(this in getField(rules, \'in\')) ? \'value must be in list %s\'.format([getField(rules, \'in\')]) : \'\'' + _DURATIONRULES.fields_by_name['not_in']._options = None + _DURATIONRULES.fields_by_name['not_in']._serialized_options = b'\302Hf\nd\n\017duration.not_in\032Qthis in rules.not_in ? \'value must not be in list %s\'.format([rules.not_in]) : \'\'' + _DURATIONRULES.fields_by_name['example']._options = None + _DURATIONRULES.fields_by_name['example']._serialized_options = b'\302H\032\n\030\n\020duration.example\032\004true' + _TIMESTAMPRULES.fields_by_name['const']._options = None + _TIMESTAMPRULES.fields_by_name['const']._serialized_options = b'\302Hu\ns\n\017timestamp.const\032`this != getField(rules, \'const\') ? \'value must equal %s\'.format([getField(rules, \'const\')]) : \'\'' + _TIMESTAMPRULES.fields_by_name['lt']._options = None + _TIMESTAMPRULES.fields_by_name['lt']._serialized_options = b'\302H}\n{\n\014timestamp.lt\032k!has(rules.gte) && !has(rules.gt) && this >= rules.lt? \'value must be less than %s\'.format([rules.lt]) : \'\'' + _TIMESTAMPRULES.fields_by_name['lte']._options = None + _TIMESTAMPRULES.fields_by_name['lte']._serialized_options = b'\302H\214\001\n\211\001\n\rtimestamp.lte\032x!has(rules.gte) && !has(rules.gt) && this > rules.lte? \'value must be less than or equal to %s\'.format([rules.lte]) : \'\'' + _TIMESTAMPRULES.fields_by_name['lt_now']._options = None + _TIMESTAMPRULES.fields_by_name['lt_now']._serialized_options = b'\302HW\nU\n\020timestamp.lt_now\032A(rules.lt_now && this > now) ? \'value must be less than now\' : \'\'' + _TIMESTAMPRULES.fields_by_name['gt']._options = None + _TIMESTAMPRULES.fields_by_name['gt']._serialized_options = b'\302H\230\007\n~\n\014timestamp.gt\032n!has(rules.lt) && !has(rules.lte) && this <= rules.gt? \'value must be greater than %s\'.format([rules.gt]) : \'\'\n\267\001\n\017timestamp.gt_lt\032\243\001has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)? \'value must be greater than %s and less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\277\001\n\031timestamp.gt_lt_exclusive\032\241\001has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)? \'value must be greater than %s or less than %s\'.format([rules.gt, rules.lt]) : \'\'\n\307\001\n\020timestamp.gt_lte\032\262\001has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)? \'value must be greater than %s and less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'\n\317\001\n\032timestamp.gt_lte_exclusive\032\260\001has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)? \'value must be greater than %s or less than or equal to %s\'.format([rules.gt, rules.lte]) : \'\'' + _TIMESTAMPRULES.fields_by_name['gte']._options = None + _TIMESTAMPRULES.fields_by_name['gte']._serialized_options = b'\302H\343\007\n\214\001\n\rtimestamp.gte\032{!has(rules.lt) && !has(rules.lte) && this < rules.gte? \'value must be greater than or equal to %s\'.format([rules.gte]) : \'\'\n\306\001\n\020timestamp.gte_lt\032\261\001has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)? \'value must be greater than or equal to %s and less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\316\001\n\032timestamp.gte_lt_exclusive\032\257\001has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)? \'value must be greater than or equal to %s or less than %s\'.format([rules.gte, rules.lt]) : \'\'\n\326\001\n\021timestamp.gte_lte\032\300\001has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)? \'value must be greater than or equal to %s and less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'\n\336\001\n\033timestamp.gte_lte_exclusive\032\276\001has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)? \'value must be greater than or equal to %s or less than or equal to %s\'.format([rules.gte, rules.lte]) : \'\'' + _TIMESTAMPRULES.fields_by_name['gt_now']._options = None + _TIMESTAMPRULES.fields_by_name['gt_now']._serialized_options = b'\302HZ\nX\n\020timestamp.gt_now\032D(rules.gt_now && this < now) ? \'value must be greater than now\' : \'\'' + _TIMESTAMPRULES.fields_by_name['within']._options = None + _TIMESTAMPRULES.fields_by_name['within']._serialized_options = b'\302H\210\001\n\205\001\n\020timestamp.within\032qthis < now-rules.within || this > now+rules.within ? \'value must be within %s of now\'.format([rules.within]) : \'\'' + _TIMESTAMPRULES.fields_by_name['example']._options = None + _TIMESTAMPRULES.fields_by_name['example']._serialized_options = b'\302H\033\n\031\n\021timestamp.example\032\004true' + _globals['_IGNORE']._serialized_start=54134 + _globals['_IGNORE']._serialized_end=54295 + _globals['_KNOWNREGEX']._serialized_start=54297 + _globals['_KNOWNREGEX']._serialized_end=54407 + _globals['_RULE']._serialized_start=144 + _globals['_RULE']._serialized_end=224 + _globals['_MESSAGERULES']._serialized_start=226 + _globals['_MESSAGERULES']._serialized_end=348 + _globals['_MESSAGEONEOFRULE']._serialized_start=350 + _globals['_MESSAGEONEOFRULE']._serialized_end=420 + _globals['_ONEOFRULES']._serialized_start=422 + _globals['_ONEOFRULES']._serialized_end=462 + _globals['_FIELDRULES']._serialized_start=465 + _globals['_FIELDRULES']._serialized_end=1742 + _globals['_PREDEFINEDRULES']._serialized_start=1744 + _globals['_PREDEFINEDRULES']._serialized_end=1834 + _globals['_FLOATRULES']._serialized_start=1837 + _globals['_FLOATRULES']._serialized_end=4925 + _globals['_DOUBLERULES']._serialized_start=4928 + _globals['_DOUBLERULES']._serialized_end=8034 + _globals['_INT32RULES']._serialized_start=8037 + _globals['_INT32RULES']._serialized_end=10783 + _globals['_INT64RULES']._serialized_start=10786 + _globals['_INT64RULES']._serialized_end=13532 + _globals['_UINT32RULES']._serialized_start=13535 + _globals['_UINT32RULES']._serialized_end=16298 + _globals['_UINT64RULES']._serialized_start=16301 + _globals['_UINT64RULES']._serialized_end=19064 + _globals['_SINT32RULES']._serialized_start=19067 + _globals['_SINT32RULES']._serialized_end=21830 + _globals['_SINT64RULES']._serialized_start=21833 + _globals['_SINT64RULES']._serialized_end=24596 + _globals['_FIXED32RULES']._serialized_start=24599 + _globals['_FIXED32RULES']._serialized_end=27379 + _globals['_FIXED64RULES']._serialized_start=27382 + _globals['_FIXED64RULES']._serialized_end=30162 + _globals['_SFIXED32RULES']._serialized_start=30165 + _globals['_SFIXED32RULES']._serialized_end=32963 + _globals['_SFIXED64RULES']._serialized_start=32966 + _globals['_SFIXED64RULES']._serialized_end=35764 + _globals['_BOOLRULES']._serialized_start=35767 + _globals['_BOOLRULES']._serialized_end=35982 + _globals['_STRINGRULES']._serialized_start=35985 + _globals['_STRINGRULES']._serialized_end=43362 + _globals['_BYTESRULES']._serialized_start=43365 + _globals['_BYTESRULES']._serialized_end=45619 + _globals['_ENUMRULES']._serialized_start=45622 + _globals['_ENUMRULES']._serialized_end=46131 + _globals['_REPEATEDRULES']._serialized_start=46134 + _globals['_REPEATEDRULES']._serialized_end=46676 + _globals['_MAPRULES']._serialized_start=46679 + _globals['_MAPRULES']._serialized_end=47107 + _globals['_ANYRULES']._serialized_start=47109 + _globals['_ANYRULES']._serialized_end=47158 + _globals['_DURATIONRULES']._serialized_start=47161 + _globals['_DURATIONRULES']._serialized_end=50175 + _globals['_TIMESTAMPRULES']._serialized_start=50178 + _globals['_TIMESTAMPRULES']._serialized_end=53324 + _globals['_VIOLATIONS']._serialized_start=53326 + _globals['_VIOLATIONS']._serialized_end=53395 + _globals['_VIOLATION']._serialized_start=53398 + _globals['_VIOLATION']._serialized_end=53595 + _globals['_FIELDPATH']._serialized_start=53597 + _globals['_FIELDPATH']._serialized_end=53668 + _globals['_FIELDPATHELEMENT']._serialized_start=53671 + _globals['_FIELDPATHELEMENT']._serialized_end=54131 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/buf/validate/validate_pb2.pyi b/gen/python/buf/validate/validate_pb2.pyi new file mode 100644 index 0000000000..3883e8df1d --- /dev/null +++ b/gen/python/buf/validate/validate_pb2.pyi @@ -0,0 +1,624 @@ +from google.protobuf import descriptor_pb2 as _descriptor_pb2 +from google.protobuf import duration_pb2 as _duration_pb2 +from google.protobuf import timestamp_pb2 as _timestamp_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf.internal import python_message as _python_message +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class Ignore(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + IGNORE_UNSPECIFIED: _ClassVar[Ignore] + IGNORE_IF_ZERO_VALUE: _ClassVar[Ignore] + IGNORE_ALWAYS: _ClassVar[Ignore] + +class KnownRegex(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + KNOWN_REGEX_UNSPECIFIED: _ClassVar[KnownRegex] + KNOWN_REGEX_HTTP_HEADER_NAME: _ClassVar[KnownRegex] + KNOWN_REGEX_HTTP_HEADER_VALUE: _ClassVar[KnownRegex] +IGNORE_UNSPECIFIED: Ignore +IGNORE_IF_ZERO_VALUE: Ignore +IGNORE_ALWAYS: Ignore +KNOWN_REGEX_UNSPECIFIED: KnownRegex +KNOWN_REGEX_HTTP_HEADER_NAME: KnownRegex +KNOWN_REGEX_HTTP_HEADER_VALUE: KnownRegex +MESSAGE_FIELD_NUMBER: _ClassVar[int] +message: _descriptor.FieldDescriptor +ONEOF_FIELD_NUMBER: _ClassVar[int] +oneof: _descriptor.FieldDescriptor +FIELD_FIELD_NUMBER: _ClassVar[int] +field: _descriptor.FieldDescriptor +PREDEFINED_FIELD_NUMBER: _ClassVar[int] +predefined: _descriptor.FieldDescriptor + +class Rule(_message.Message): + __slots__ = ["id", "message", "expression"] + ID_FIELD_NUMBER: _ClassVar[int] + MESSAGE_FIELD_NUMBER: _ClassVar[int] + EXPRESSION_FIELD_NUMBER: _ClassVar[int] + id: str + message: str + expression: str + def __init__(self, id: _Optional[str] = ..., message: _Optional[str] = ..., expression: _Optional[str] = ...) -> None: ... + +class MessageRules(_message.Message): + __slots__ = ["cel", "oneof"] + CEL_FIELD_NUMBER: _ClassVar[int] + ONEOF_FIELD_NUMBER: _ClassVar[int] + cel: _containers.RepeatedCompositeFieldContainer[Rule] + oneof: _containers.RepeatedCompositeFieldContainer[MessageOneofRule] + def __init__(self, cel: _Optional[_Iterable[_Union[Rule, _Mapping]]] = ..., oneof: _Optional[_Iterable[_Union[MessageOneofRule, _Mapping]]] = ...) -> None: ... + +class MessageOneofRule(_message.Message): + __slots__ = ["fields", "required"] + FIELDS_FIELD_NUMBER: _ClassVar[int] + REQUIRED_FIELD_NUMBER: _ClassVar[int] + fields: _containers.RepeatedScalarFieldContainer[str] + required: bool + def __init__(self, fields: _Optional[_Iterable[str]] = ..., required: bool = ...) -> None: ... + +class OneofRules(_message.Message): + __slots__ = ["required"] + REQUIRED_FIELD_NUMBER: _ClassVar[int] + required: bool + def __init__(self, required: bool = ...) -> None: ... + +class FieldRules(_message.Message): + __slots__ = ["cel", "required", "ignore", "float", "double", "int32", "int64", "uint32", "uint64", "sint32", "sint64", "fixed32", "fixed64", "sfixed32", "sfixed64", "bool", "string", "bytes", "enum", "repeated", "map", "any", "duration", "timestamp"] + CEL_FIELD_NUMBER: _ClassVar[int] + REQUIRED_FIELD_NUMBER: _ClassVar[int] + IGNORE_FIELD_NUMBER: _ClassVar[int] + FLOAT_FIELD_NUMBER: _ClassVar[int] + DOUBLE_FIELD_NUMBER: _ClassVar[int] + INT32_FIELD_NUMBER: _ClassVar[int] + INT64_FIELD_NUMBER: _ClassVar[int] + UINT32_FIELD_NUMBER: _ClassVar[int] + UINT64_FIELD_NUMBER: _ClassVar[int] + SINT32_FIELD_NUMBER: _ClassVar[int] + SINT64_FIELD_NUMBER: _ClassVar[int] + FIXED32_FIELD_NUMBER: _ClassVar[int] + FIXED64_FIELD_NUMBER: _ClassVar[int] + SFIXED32_FIELD_NUMBER: _ClassVar[int] + SFIXED64_FIELD_NUMBER: _ClassVar[int] + BOOL_FIELD_NUMBER: _ClassVar[int] + STRING_FIELD_NUMBER: _ClassVar[int] + BYTES_FIELD_NUMBER: _ClassVar[int] + ENUM_FIELD_NUMBER: _ClassVar[int] + REPEATED_FIELD_NUMBER: _ClassVar[int] + MAP_FIELD_NUMBER: _ClassVar[int] + ANY_FIELD_NUMBER: _ClassVar[int] + DURATION_FIELD_NUMBER: _ClassVar[int] + TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + cel: _containers.RepeatedCompositeFieldContainer[Rule] + required: bool + ignore: Ignore + float: FloatRules + double: DoubleRules + int32: Int32Rules + int64: Int64Rules + uint32: UInt32Rules + uint64: UInt64Rules + sint32: SInt32Rules + sint64: SInt64Rules + fixed32: Fixed32Rules + fixed64: Fixed64Rules + sfixed32: SFixed32Rules + sfixed64: SFixed64Rules + bool: BoolRules + string: StringRules + bytes: BytesRules + enum: EnumRules + repeated: RepeatedRules + map: MapRules + any: AnyRules + duration: DurationRules + timestamp: TimestampRules + def __init__(self, cel: _Optional[_Iterable[_Union[Rule, _Mapping]]] = ..., required: bool = ..., ignore: _Optional[_Union[Ignore, str]] = ..., float: _Optional[_Union[FloatRules, _Mapping]] = ..., double: _Optional[_Union[DoubleRules, _Mapping]] = ..., int32: _Optional[_Union[Int32Rules, _Mapping]] = ..., int64: _Optional[_Union[Int64Rules, _Mapping]] = ..., uint32: _Optional[_Union[UInt32Rules, _Mapping]] = ..., uint64: _Optional[_Union[UInt64Rules, _Mapping]] = ..., sint32: _Optional[_Union[SInt32Rules, _Mapping]] = ..., sint64: _Optional[_Union[SInt64Rules, _Mapping]] = ..., fixed32: _Optional[_Union[Fixed32Rules, _Mapping]] = ..., fixed64: _Optional[_Union[Fixed64Rules, _Mapping]] = ..., sfixed32: _Optional[_Union[SFixed32Rules, _Mapping]] = ..., sfixed64: _Optional[_Union[SFixed64Rules, _Mapping]] = ..., bool: _Optional[_Union[BoolRules, _Mapping]] = ..., string: _Optional[_Union[StringRules, _Mapping]] = ..., bytes: _Optional[_Union[BytesRules, _Mapping]] = ..., enum: _Optional[_Union[EnumRules, _Mapping]] = ..., repeated: _Optional[_Union[RepeatedRules, _Mapping]] = ..., map: _Optional[_Union[MapRules, _Mapping]] = ..., any: _Optional[_Union[AnyRules, _Mapping]] = ..., duration: _Optional[_Union[DurationRules, _Mapping]] = ..., timestamp: _Optional[_Union[TimestampRules, _Mapping]] = ...) -> None: ... + +class PredefinedRules(_message.Message): + __slots__ = ["cel"] + CEL_FIELD_NUMBER: _ClassVar[int] + cel: _containers.RepeatedCompositeFieldContainer[Rule] + def __init__(self, cel: _Optional[_Iterable[_Union[Rule, _Mapping]]] = ...) -> None: ... + +class FloatRules(_message.Message): + __slots__ = ["const", "lt", "lte", "gt", "gte", "not_in", "finite", "example"] + Extensions: _python_message._ExtensionDict + CONST_FIELD_NUMBER: _ClassVar[int] + LT_FIELD_NUMBER: _ClassVar[int] + LTE_FIELD_NUMBER: _ClassVar[int] + GT_FIELD_NUMBER: _ClassVar[int] + GTE_FIELD_NUMBER: _ClassVar[int] + IN_FIELD_NUMBER: _ClassVar[int] + NOT_IN_FIELD_NUMBER: _ClassVar[int] + FINITE_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + const: float + lt: float + lte: float + gt: float + gte: float + not_in: _containers.RepeatedScalarFieldContainer[float] + finite: bool + example: _containers.RepeatedScalarFieldContainer[float] + def __init__(self, const: _Optional[float] = ..., lt: _Optional[float] = ..., lte: _Optional[float] = ..., gt: _Optional[float] = ..., gte: _Optional[float] = ..., not_in: _Optional[_Iterable[float]] = ..., finite: bool = ..., example: _Optional[_Iterable[float]] = ..., **kwargs) -> None: ... + +class DoubleRules(_message.Message): + __slots__ = ["const", "lt", "lte", "gt", "gte", "not_in", "finite", "example"] + Extensions: _python_message._ExtensionDict + CONST_FIELD_NUMBER: _ClassVar[int] + LT_FIELD_NUMBER: _ClassVar[int] + LTE_FIELD_NUMBER: _ClassVar[int] + GT_FIELD_NUMBER: _ClassVar[int] + GTE_FIELD_NUMBER: _ClassVar[int] + IN_FIELD_NUMBER: _ClassVar[int] + NOT_IN_FIELD_NUMBER: _ClassVar[int] + FINITE_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + const: float + lt: float + lte: float + gt: float + gte: float + not_in: _containers.RepeatedScalarFieldContainer[float] + finite: bool + example: _containers.RepeatedScalarFieldContainer[float] + def __init__(self, const: _Optional[float] = ..., lt: _Optional[float] = ..., lte: _Optional[float] = ..., gt: _Optional[float] = ..., gte: _Optional[float] = ..., not_in: _Optional[_Iterable[float]] = ..., finite: bool = ..., example: _Optional[_Iterable[float]] = ..., **kwargs) -> None: ... + +class Int32Rules(_message.Message): + __slots__ = ["const", "lt", "lte", "gt", "gte", "not_in", "example"] + Extensions: _python_message._ExtensionDict + CONST_FIELD_NUMBER: _ClassVar[int] + LT_FIELD_NUMBER: _ClassVar[int] + LTE_FIELD_NUMBER: _ClassVar[int] + GT_FIELD_NUMBER: _ClassVar[int] + GTE_FIELD_NUMBER: _ClassVar[int] + IN_FIELD_NUMBER: _ClassVar[int] + NOT_IN_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + const: int + lt: int + lte: int + gt: int + gte: int + not_in: _containers.RepeatedScalarFieldContainer[int] + example: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, const: _Optional[int] = ..., lt: _Optional[int] = ..., lte: _Optional[int] = ..., gt: _Optional[int] = ..., gte: _Optional[int] = ..., not_in: _Optional[_Iterable[int]] = ..., example: _Optional[_Iterable[int]] = ..., **kwargs) -> None: ... + +class Int64Rules(_message.Message): + __slots__ = ["const", "lt", "lte", "gt", "gte", "not_in", "example"] + Extensions: _python_message._ExtensionDict + CONST_FIELD_NUMBER: _ClassVar[int] + LT_FIELD_NUMBER: _ClassVar[int] + LTE_FIELD_NUMBER: _ClassVar[int] + GT_FIELD_NUMBER: _ClassVar[int] + GTE_FIELD_NUMBER: _ClassVar[int] + IN_FIELD_NUMBER: _ClassVar[int] + NOT_IN_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + const: int + lt: int + lte: int + gt: int + gte: int + not_in: _containers.RepeatedScalarFieldContainer[int] + example: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, const: _Optional[int] = ..., lt: _Optional[int] = ..., lte: _Optional[int] = ..., gt: _Optional[int] = ..., gte: _Optional[int] = ..., not_in: _Optional[_Iterable[int]] = ..., example: _Optional[_Iterable[int]] = ..., **kwargs) -> None: ... + +class UInt32Rules(_message.Message): + __slots__ = ["const", "lt", "lte", "gt", "gte", "not_in", "example"] + Extensions: _python_message._ExtensionDict + CONST_FIELD_NUMBER: _ClassVar[int] + LT_FIELD_NUMBER: _ClassVar[int] + LTE_FIELD_NUMBER: _ClassVar[int] + GT_FIELD_NUMBER: _ClassVar[int] + GTE_FIELD_NUMBER: _ClassVar[int] + IN_FIELD_NUMBER: _ClassVar[int] + NOT_IN_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + const: int + lt: int + lte: int + gt: int + gte: int + not_in: _containers.RepeatedScalarFieldContainer[int] + example: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, const: _Optional[int] = ..., lt: _Optional[int] = ..., lte: _Optional[int] = ..., gt: _Optional[int] = ..., gte: _Optional[int] = ..., not_in: _Optional[_Iterable[int]] = ..., example: _Optional[_Iterable[int]] = ..., **kwargs) -> None: ... + +class UInt64Rules(_message.Message): + __slots__ = ["const", "lt", "lte", "gt", "gte", "not_in", "example"] + Extensions: _python_message._ExtensionDict + CONST_FIELD_NUMBER: _ClassVar[int] + LT_FIELD_NUMBER: _ClassVar[int] + LTE_FIELD_NUMBER: _ClassVar[int] + GT_FIELD_NUMBER: _ClassVar[int] + GTE_FIELD_NUMBER: _ClassVar[int] + IN_FIELD_NUMBER: _ClassVar[int] + NOT_IN_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + const: int + lt: int + lte: int + gt: int + gte: int + not_in: _containers.RepeatedScalarFieldContainer[int] + example: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, const: _Optional[int] = ..., lt: _Optional[int] = ..., lte: _Optional[int] = ..., gt: _Optional[int] = ..., gte: _Optional[int] = ..., not_in: _Optional[_Iterable[int]] = ..., example: _Optional[_Iterable[int]] = ..., **kwargs) -> None: ... + +class SInt32Rules(_message.Message): + __slots__ = ["const", "lt", "lte", "gt", "gte", "not_in", "example"] + Extensions: _python_message._ExtensionDict + CONST_FIELD_NUMBER: _ClassVar[int] + LT_FIELD_NUMBER: _ClassVar[int] + LTE_FIELD_NUMBER: _ClassVar[int] + GT_FIELD_NUMBER: _ClassVar[int] + GTE_FIELD_NUMBER: _ClassVar[int] + IN_FIELD_NUMBER: _ClassVar[int] + NOT_IN_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + const: int + lt: int + lte: int + gt: int + gte: int + not_in: _containers.RepeatedScalarFieldContainer[int] + example: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, const: _Optional[int] = ..., lt: _Optional[int] = ..., lte: _Optional[int] = ..., gt: _Optional[int] = ..., gte: _Optional[int] = ..., not_in: _Optional[_Iterable[int]] = ..., example: _Optional[_Iterable[int]] = ..., **kwargs) -> None: ... + +class SInt64Rules(_message.Message): + __slots__ = ["const", "lt", "lte", "gt", "gte", "not_in", "example"] + Extensions: _python_message._ExtensionDict + CONST_FIELD_NUMBER: _ClassVar[int] + LT_FIELD_NUMBER: _ClassVar[int] + LTE_FIELD_NUMBER: _ClassVar[int] + GT_FIELD_NUMBER: _ClassVar[int] + GTE_FIELD_NUMBER: _ClassVar[int] + IN_FIELD_NUMBER: _ClassVar[int] + NOT_IN_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + const: int + lt: int + lte: int + gt: int + gte: int + not_in: _containers.RepeatedScalarFieldContainer[int] + example: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, const: _Optional[int] = ..., lt: _Optional[int] = ..., lte: _Optional[int] = ..., gt: _Optional[int] = ..., gte: _Optional[int] = ..., not_in: _Optional[_Iterable[int]] = ..., example: _Optional[_Iterable[int]] = ..., **kwargs) -> None: ... + +class Fixed32Rules(_message.Message): + __slots__ = ["const", "lt", "lte", "gt", "gte", "not_in", "example"] + Extensions: _python_message._ExtensionDict + CONST_FIELD_NUMBER: _ClassVar[int] + LT_FIELD_NUMBER: _ClassVar[int] + LTE_FIELD_NUMBER: _ClassVar[int] + GT_FIELD_NUMBER: _ClassVar[int] + GTE_FIELD_NUMBER: _ClassVar[int] + IN_FIELD_NUMBER: _ClassVar[int] + NOT_IN_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + const: int + lt: int + lte: int + gt: int + gte: int + not_in: _containers.RepeatedScalarFieldContainer[int] + example: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, const: _Optional[int] = ..., lt: _Optional[int] = ..., lte: _Optional[int] = ..., gt: _Optional[int] = ..., gte: _Optional[int] = ..., not_in: _Optional[_Iterable[int]] = ..., example: _Optional[_Iterable[int]] = ..., **kwargs) -> None: ... + +class Fixed64Rules(_message.Message): + __slots__ = ["const", "lt", "lte", "gt", "gte", "not_in", "example"] + Extensions: _python_message._ExtensionDict + CONST_FIELD_NUMBER: _ClassVar[int] + LT_FIELD_NUMBER: _ClassVar[int] + LTE_FIELD_NUMBER: _ClassVar[int] + GT_FIELD_NUMBER: _ClassVar[int] + GTE_FIELD_NUMBER: _ClassVar[int] + IN_FIELD_NUMBER: _ClassVar[int] + NOT_IN_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + const: int + lt: int + lte: int + gt: int + gte: int + not_in: _containers.RepeatedScalarFieldContainer[int] + example: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, const: _Optional[int] = ..., lt: _Optional[int] = ..., lte: _Optional[int] = ..., gt: _Optional[int] = ..., gte: _Optional[int] = ..., not_in: _Optional[_Iterable[int]] = ..., example: _Optional[_Iterable[int]] = ..., **kwargs) -> None: ... + +class SFixed32Rules(_message.Message): + __slots__ = ["const", "lt", "lte", "gt", "gte", "not_in", "example"] + Extensions: _python_message._ExtensionDict + CONST_FIELD_NUMBER: _ClassVar[int] + LT_FIELD_NUMBER: _ClassVar[int] + LTE_FIELD_NUMBER: _ClassVar[int] + GT_FIELD_NUMBER: _ClassVar[int] + GTE_FIELD_NUMBER: _ClassVar[int] + IN_FIELD_NUMBER: _ClassVar[int] + NOT_IN_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + const: int + lt: int + lte: int + gt: int + gte: int + not_in: _containers.RepeatedScalarFieldContainer[int] + example: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, const: _Optional[int] = ..., lt: _Optional[int] = ..., lte: _Optional[int] = ..., gt: _Optional[int] = ..., gte: _Optional[int] = ..., not_in: _Optional[_Iterable[int]] = ..., example: _Optional[_Iterable[int]] = ..., **kwargs) -> None: ... + +class SFixed64Rules(_message.Message): + __slots__ = ["const", "lt", "lte", "gt", "gte", "not_in", "example"] + Extensions: _python_message._ExtensionDict + CONST_FIELD_NUMBER: _ClassVar[int] + LT_FIELD_NUMBER: _ClassVar[int] + LTE_FIELD_NUMBER: _ClassVar[int] + GT_FIELD_NUMBER: _ClassVar[int] + GTE_FIELD_NUMBER: _ClassVar[int] + IN_FIELD_NUMBER: _ClassVar[int] + NOT_IN_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + const: int + lt: int + lte: int + gt: int + gte: int + not_in: _containers.RepeatedScalarFieldContainer[int] + example: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, const: _Optional[int] = ..., lt: _Optional[int] = ..., lte: _Optional[int] = ..., gt: _Optional[int] = ..., gte: _Optional[int] = ..., not_in: _Optional[_Iterable[int]] = ..., example: _Optional[_Iterable[int]] = ..., **kwargs) -> None: ... + +class BoolRules(_message.Message): + __slots__ = ["const", "example"] + Extensions: _python_message._ExtensionDict + CONST_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + const: bool + example: _containers.RepeatedScalarFieldContainer[bool] + def __init__(self, const: bool = ..., example: _Optional[_Iterable[bool]] = ...) -> None: ... + +class StringRules(_message.Message): + __slots__ = ["const", "len", "min_len", "max_len", "len_bytes", "min_bytes", "max_bytes", "pattern", "prefix", "suffix", "contains", "not_contains", "not_in", "email", "hostname", "ip", "ipv4", "ipv6", "uri", "uri_ref", "address", "uuid", "tuuid", "ip_with_prefixlen", "ipv4_with_prefixlen", "ipv6_with_prefixlen", "ip_prefix", "ipv4_prefix", "ipv6_prefix", "host_and_port", "well_known_regex", "strict", "example"] + Extensions: _python_message._ExtensionDict + CONST_FIELD_NUMBER: _ClassVar[int] + LEN_FIELD_NUMBER: _ClassVar[int] + MIN_LEN_FIELD_NUMBER: _ClassVar[int] + MAX_LEN_FIELD_NUMBER: _ClassVar[int] + LEN_BYTES_FIELD_NUMBER: _ClassVar[int] + MIN_BYTES_FIELD_NUMBER: _ClassVar[int] + MAX_BYTES_FIELD_NUMBER: _ClassVar[int] + PATTERN_FIELD_NUMBER: _ClassVar[int] + PREFIX_FIELD_NUMBER: _ClassVar[int] + SUFFIX_FIELD_NUMBER: _ClassVar[int] + CONTAINS_FIELD_NUMBER: _ClassVar[int] + NOT_CONTAINS_FIELD_NUMBER: _ClassVar[int] + IN_FIELD_NUMBER: _ClassVar[int] + NOT_IN_FIELD_NUMBER: _ClassVar[int] + EMAIL_FIELD_NUMBER: _ClassVar[int] + HOSTNAME_FIELD_NUMBER: _ClassVar[int] + IP_FIELD_NUMBER: _ClassVar[int] + IPV4_FIELD_NUMBER: _ClassVar[int] + IPV6_FIELD_NUMBER: _ClassVar[int] + URI_FIELD_NUMBER: _ClassVar[int] + URI_REF_FIELD_NUMBER: _ClassVar[int] + ADDRESS_FIELD_NUMBER: _ClassVar[int] + UUID_FIELD_NUMBER: _ClassVar[int] + TUUID_FIELD_NUMBER: _ClassVar[int] + IP_WITH_PREFIXLEN_FIELD_NUMBER: _ClassVar[int] + IPV4_WITH_PREFIXLEN_FIELD_NUMBER: _ClassVar[int] + IPV6_WITH_PREFIXLEN_FIELD_NUMBER: _ClassVar[int] + IP_PREFIX_FIELD_NUMBER: _ClassVar[int] + IPV4_PREFIX_FIELD_NUMBER: _ClassVar[int] + IPV6_PREFIX_FIELD_NUMBER: _ClassVar[int] + HOST_AND_PORT_FIELD_NUMBER: _ClassVar[int] + WELL_KNOWN_REGEX_FIELD_NUMBER: _ClassVar[int] + STRICT_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + const: str + len: int + min_len: int + max_len: int + len_bytes: int + min_bytes: int + max_bytes: int + pattern: str + prefix: str + suffix: str + contains: str + not_contains: str + not_in: _containers.RepeatedScalarFieldContainer[str] + email: bool + hostname: bool + ip: bool + ipv4: bool + ipv6: bool + uri: bool + uri_ref: bool + address: bool + uuid: bool + tuuid: bool + ip_with_prefixlen: bool + ipv4_with_prefixlen: bool + ipv6_with_prefixlen: bool + ip_prefix: bool + ipv4_prefix: bool + ipv6_prefix: bool + host_and_port: bool + well_known_regex: KnownRegex + strict: bool + example: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, const: _Optional[str] = ..., len: _Optional[int] = ..., min_len: _Optional[int] = ..., max_len: _Optional[int] = ..., len_bytes: _Optional[int] = ..., min_bytes: _Optional[int] = ..., max_bytes: _Optional[int] = ..., pattern: _Optional[str] = ..., prefix: _Optional[str] = ..., suffix: _Optional[str] = ..., contains: _Optional[str] = ..., not_contains: _Optional[str] = ..., not_in: _Optional[_Iterable[str]] = ..., email: bool = ..., hostname: bool = ..., ip: bool = ..., ipv4: bool = ..., ipv6: bool = ..., uri: bool = ..., uri_ref: bool = ..., address: bool = ..., uuid: bool = ..., tuuid: bool = ..., ip_with_prefixlen: bool = ..., ipv4_with_prefixlen: bool = ..., ipv6_with_prefixlen: bool = ..., ip_prefix: bool = ..., ipv4_prefix: bool = ..., ipv6_prefix: bool = ..., host_and_port: bool = ..., well_known_regex: _Optional[_Union[KnownRegex, str]] = ..., strict: bool = ..., example: _Optional[_Iterable[str]] = ..., **kwargs) -> None: ... + +class BytesRules(_message.Message): + __slots__ = ["const", "len", "min_len", "max_len", "pattern", "prefix", "suffix", "contains", "not_in", "ip", "ipv4", "ipv6", "example"] + Extensions: _python_message._ExtensionDict + CONST_FIELD_NUMBER: _ClassVar[int] + LEN_FIELD_NUMBER: _ClassVar[int] + MIN_LEN_FIELD_NUMBER: _ClassVar[int] + MAX_LEN_FIELD_NUMBER: _ClassVar[int] + PATTERN_FIELD_NUMBER: _ClassVar[int] + PREFIX_FIELD_NUMBER: _ClassVar[int] + SUFFIX_FIELD_NUMBER: _ClassVar[int] + CONTAINS_FIELD_NUMBER: _ClassVar[int] + IN_FIELD_NUMBER: _ClassVar[int] + NOT_IN_FIELD_NUMBER: _ClassVar[int] + IP_FIELD_NUMBER: _ClassVar[int] + IPV4_FIELD_NUMBER: _ClassVar[int] + IPV6_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + const: bytes + len: int + min_len: int + max_len: int + pattern: str + prefix: bytes + suffix: bytes + contains: bytes + not_in: _containers.RepeatedScalarFieldContainer[bytes] + ip: bool + ipv4: bool + ipv6: bool + example: _containers.RepeatedScalarFieldContainer[bytes] + def __init__(self, const: _Optional[bytes] = ..., len: _Optional[int] = ..., min_len: _Optional[int] = ..., max_len: _Optional[int] = ..., pattern: _Optional[str] = ..., prefix: _Optional[bytes] = ..., suffix: _Optional[bytes] = ..., contains: _Optional[bytes] = ..., not_in: _Optional[_Iterable[bytes]] = ..., ip: bool = ..., ipv4: bool = ..., ipv6: bool = ..., example: _Optional[_Iterable[bytes]] = ..., **kwargs) -> None: ... + +class EnumRules(_message.Message): + __slots__ = ["const", "defined_only", "not_in", "example"] + Extensions: _python_message._ExtensionDict + CONST_FIELD_NUMBER: _ClassVar[int] + DEFINED_ONLY_FIELD_NUMBER: _ClassVar[int] + IN_FIELD_NUMBER: _ClassVar[int] + NOT_IN_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + const: int + defined_only: bool + not_in: _containers.RepeatedScalarFieldContainer[int] + example: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, const: _Optional[int] = ..., defined_only: bool = ..., not_in: _Optional[_Iterable[int]] = ..., example: _Optional[_Iterable[int]] = ..., **kwargs) -> None: ... + +class RepeatedRules(_message.Message): + __slots__ = ["min_items", "max_items", "unique", "items"] + Extensions: _python_message._ExtensionDict + MIN_ITEMS_FIELD_NUMBER: _ClassVar[int] + MAX_ITEMS_FIELD_NUMBER: _ClassVar[int] + UNIQUE_FIELD_NUMBER: _ClassVar[int] + ITEMS_FIELD_NUMBER: _ClassVar[int] + min_items: int + max_items: int + unique: bool + items: FieldRules + def __init__(self, min_items: _Optional[int] = ..., max_items: _Optional[int] = ..., unique: bool = ..., items: _Optional[_Union[FieldRules, _Mapping]] = ...) -> None: ... + +class MapRules(_message.Message): + __slots__ = ["min_pairs", "max_pairs", "keys", "values"] + Extensions: _python_message._ExtensionDict + MIN_PAIRS_FIELD_NUMBER: _ClassVar[int] + MAX_PAIRS_FIELD_NUMBER: _ClassVar[int] + KEYS_FIELD_NUMBER: _ClassVar[int] + VALUES_FIELD_NUMBER: _ClassVar[int] + min_pairs: int + max_pairs: int + keys: FieldRules + values: FieldRules + def __init__(self, min_pairs: _Optional[int] = ..., max_pairs: _Optional[int] = ..., keys: _Optional[_Union[FieldRules, _Mapping]] = ..., values: _Optional[_Union[FieldRules, _Mapping]] = ...) -> None: ... + +class AnyRules(_message.Message): + __slots__ = ["not_in"] + IN_FIELD_NUMBER: _ClassVar[int] + NOT_IN_FIELD_NUMBER: _ClassVar[int] + not_in: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, not_in: _Optional[_Iterable[str]] = ..., **kwargs) -> None: ... + +class DurationRules(_message.Message): + __slots__ = ["const", "lt", "lte", "gt", "gte", "not_in", "example"] + Extensions: _python_message._ExtensionDict + CONST_FIELD_NUMBER: _ClassVar[int] + LT_FIELD_NUMBER: _ClassVar[int] + LTE_FIELD_NUMBER: _ClassVar[int] + GT_FIELD_NUMBER: _ClassVar[int] + GTE_FIELD_NUMBER: _ClassVar[int] + IN_FIELD_NUMBER: _ClassVar[int] + NOT_IN_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + const: _duration_pb2.Duration + lt: _duration_pb2.Duration + lte: _duration_pb2.Duration + gt: _duration_pb2.Duration + gte: _duration_pb2.Duration + not_in: _containers.RepeatedCompositeFieldContainer[_duration_pb2.Duration] + example: _containers.RepeatedCompositeFieldContainer[_duration_pb2.Duration] + def __init__(self, const: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., lt: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., lte: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., gt: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., gte: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., not_in: _Optional[_Iterable[_Union[_duration_pb2.Duration, _Mapping]]] = ..., example: _Optional[_Iterable[_Union[_duration_pb2.Duration, _Mapping]]] = ..., **kwargs) -> None: ... + +class TimestampRules(_message.Message): + __slots__ = ["const", "lt", "lte", "lt_now", "gt", "gte", "gt_now", "within", "example"] + Extensions: _python_message._ExtensionDict + CONST_FIELD_NUMBER: _ClassVar[int] + LT_FIELD_NUMBER: _ClassVar[int] + LTE_FIELD_NUMBER: _ClassVar[int] + LT_NOW_FIELD_NUMBER: _ClassVar[int] + GT_FIELD_NUMBER: _ClassVar[int] + GTE_FIELD_NUMBER: _ClassVar[int] + GT_NOW_FIELD_NUMBER: _ClassVar[int] + WITHIN_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + const: _timestamp_pb2.Timestamp + lt: _timestamp_pb2.Timestamp + lte: _timestamp_pb2.Timestamp + lt_now: bool + gt: _timestamp_pb2.Timestamp + gte: _timestamp_pb2.Timestamp + gt_now: bool + within: _duration_pb2.Duration + example: _containers.RepeatedCompositeFieldContainer[_timestamp_pb2.Timestamp] + def __init__(self, const: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., lt: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., lte: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., lt_now: bool = ..., gt: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., gte: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., gt_now: bool = ..., within: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., example: _Optional[_Iterable[_Union[_timestamp_pb2.Timestamp, _Mapping]]] = ...) -> None: ... + +class Violations(_message.Message): + __slots__ = ["violations"] + VIOLATIONS_FIELD_NUMBER: _ClassVar[int] + violations: _containers.RepeatedCompositeFieldContainer[Violation] + def __init__(self, violations: _Optional[_Iterable[_Union[Violation, _Mapping]]] = ...) -> None: ... + +class Violation(_message.Message): + __slots__ = ["field", "rule", "rule_id", "message", "for_key"] + FIELD_FIELD_NUMBER: _ClassVar[int] + RULE_FIELD_NUMBER: _ClassVar[int] + RULE_ID_FIELD_NUMBER: _ClassVar[int] + MESSAGE_FIELD_NUMBER: _ClassVar[int] + FOR_KEY_FIELD_NUMBER: _ClassVar[int] + field: FieldPath + rule: FieldPath + rule_id: str + message: str + for_key: bool + def __init__(self, field: _Optional[_Union[FieldPath, _Mapping]] = ..., rule: _Optional[_Union[FieldPath, _Mapping]] = ..., rule_id: _Optional[str] = ..., message: _Optional[str] = ..., for_key: bool = ...) -> None: ... + +class FieldPath(_message.Message): + __slots__ = ["elements"] + ELEMENTS_FIELD_NUMBER: _ClassVar[int] + elements: _containers.RepeatedCompositeFieldContainer[FieldPathElement] + def __init__(self, elements: _Optional[_Iterable[_Union[FieldPathElement, _Mapping]]] = ...) -> None: ... + +class FieldPathElement(_message.Message): + __slots__ = ["field_number", "field_name", "field_type", "key_type", "value_type", "index", "bool_key", "int_key", "uint_key", "string_key"] + FIELD_NUMBER_FIELD_NUMBER: _ClassVar[int] + FIELD_NAME_FIELD_NUMBER: _ClassVar[int] + FIELD_TYPE_FIELD_NUMBER: _ClassVar[int] + KEY_TYPE_FIELD_NUMBER: _ClassVar[int] + VALUE_TYPE_FIELD_NUMBER: _ClassVar[int] + INDEX_FIELD_NUMBER: _ClassVar[int] + BOOL_KEY_FIELD_NUMBER: _ClassVar[int] + INT_KEY_FIELD_NUMBER: _ClassVar[int] + UINT_KEY_FIELD_NUMBER: _ClassVar[int] + STRING_KEY_FIELD_NUMBER: _ClassVar[int] + field_number: int + field_name: str + field_type: _descriptor_pb2.FieldDescriptorProto.Type + key_type: _descriptor_pb2.FieldDescriptorProto.Type + value_type: _descriptor_pb2.FieldDescriptorProto.Type + index: int + bool_key: bool + int_key: int + uint_key: int + string_key: str + def __init__(self, field_number: _Optional[int] = ..., field_name: _Optional[str] = ..., field_type: _Optional[_Union[_descriptor_pb2.FieldDescriptorProto.Type, str]] = ..., key_type: _Optional[_Union[_descriptor_pb2.FieldDescriptorProto.Type, str]] = ..., value_type: _Optional[_Union[_descriptor_pb2.FieldDescriptorProto.Type, str]] = ..., index: _Optional[int] = ..., bool_key: bool = ..., int_key: _Optional[int] = ..., uint_key: _Optional[int] = ..., string_key: _Optional[str] = ...) -> None: ... diff --git a/gen/python/buf/validate/validate_pb2_grpc.py b/gen/python/buf/validate/validate_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/buf/validate/validate_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/__init__.py b/gen/python/flyteidl2/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/app/__init__.py b/gen/python/flyteidl2/app/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/app/app_definition_pb2.py b/gen/python/flyteidl2/app/app_definition_pb2.py new file mode 100644 index 0000000000..172ce2a70e --- /dev/null +++ b/gen/python/flyteidl2/app/app_definition_pb2.py @@ -0,0 +1,148 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/app/app_definition.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.common import identity_pb2 as flyteidl2_dot_common_dot_identity__pb2 +from flyteidl2.common import runtime_version_pb2 as flyteidl2_dot_common_dot_runtime__version__pb2 +from flyteidl2.core import artifact_id_pb2 as flyteidl2_dot_core_dot_artifact__id__pb2 +from flyteidl2.core import security_pb2 as flyteidl2_dot_core_dot_security__pb2 +from flyteidl2.core import tasks_pb2 as flyteidl2_dot_core_dot_tasks__pb2 +from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\"flyteidl2/app/app_definition.proto\x12\rflyteidl2.app\x1a\x1b\x62uf/validate/validate.proto\x1a\x1f\x66lyteidl2/common/identity.proto\x1a&flyteidl2/common/runtime_version.proto\x1a flyteidl2/core/artifact_id.proto\x1a\x1d\x66lyteidl2/core/security.proto\x1a\x1a\x66lyteidl2/core/tasks.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xb2\x01\n\nIdentifier\x12\x10\n\x03org\x18\x01 \x01(\tR\x03org\x12!\n\x07project\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x07project\x12\x1f\n\x06\x64omain\x18\x03 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x06\x64omain\x12N\n\x04name\x18\x04 \x01(\tB:\xbaH7r5\x10\x01\x18\x1e\x32/^[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?$R\x04name\"\xd2\x01\n\x04Meta\x12\x31\n\x02id\x18\x01 \x01(\x0b\x32\x19.flyteidl2.app.IdentifierB\x06\xbaH\x03\xc8\x01\x01R\x02id\x12#\n\x08revision\x18\x02 \x01(\x04\x42\x07\xbaH\x04\x32\x02(\x00R\x08revision\x12\x37\n\x06labels\x18\x03 \x03(\x0b\x32\x1f.flyteidl2.app.Meta.LabelsEntryR\x06labels\x1a\x39\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\x87\x01\n\nAppWrapper\x12\x12\n\x04host\x18\x01 \x01(\tR\x04host\x12&\n\x03\x61pp\x18\x02 \x01(\x0b\x32\x12.flyteidl2.app.AppH\x00R\x03\x61pp\x12\x32\n\x06\x61pp_id\x18\x03 \x01(\x0b\x32\x19.flyteidl2.app.IdentifierH\x00R\x05\x61ppIdB\t\n\x07payload\"\x9e\x01\n\x03\x41pp\x12\x37\n\x08metadata\x18\x01 \x01(\x0b\x32\x13.flyteidl2.app.MetaB\x06\xbaH\x03\xc8\x01\x01R\x08metadata\x12/\n\x04spec\x18\x02 \x01(\x0b\x32\x13.flyteidl2.app.SpecB\x06\xbaH\x03\xc8\x01\x01R\x04spec\x12-\n\x06status\x18\x03 \x01(\x0b\x32\x15.flyteidl2.app.StatusR\x06status\"\xa7\x02\n\tCondition\x12L\n\x14last_transition_time\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x12lastTransitionTime\x12S\n\x11\x64\x65ployment_status\x18\x02 \x01(\x0e\x32&.flyteidl2.app.Status.DeploymentStatusR\x10\x64\x65ploymentStatus\x12\x18\n\x07message\x18\x03 \x01(\tR\x07message\x12#\n\x08revision\x18\x04 \x01(\x04\x42\x07\xbaH\x04\x32\x02(\x00R\x08revision\x12\x38\n\x05\x61\x63tor\x18\x05 \x01(\x0b\x32\".flyteidl2.common.EnrichedIdentityR\x05\x61\x63tor\"\xaa\x07\n\x06Status\x12)\n\x10\x61ssigned_cluster\x18\x01 \x01(\tR\x0f\x61ssignedCluster\x12\x32\n\x10\x63urrent_replicas\x18\x02 \x01(\rB\x07\xbaH\x04*\x02(\x00R\x0f\x63urrentReplicas\x12\x30\n\x07ingress\x18\x03 \x01(\x0b\x32\x16.flyteidl2.app.IngressR\x07ingress\x12\x39\n\ncreated_at\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\tcreatedAt\x12\x42\n\x0flast_updated_at\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\rlastUpdatedAt\x12\x38\n\nconditions\x18\x06 \x03(\x0b\x32\x18.flyteidl2.app.ConditionR\nconditions\x12\x45\n\x10lease_expiration\x18\x07 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x0fleaseExpiration\x12=\n\x0ck8s_metadata\x18\x08 \x01(\x0b\x32\x1a.flyteidl2.app.K8sMetadataR\x0bk8sMetadata\x12R\n\x13materialized_inputs\x18\t \x01(\x0b\x32!.flyteidl2.app.MaterializedInputsR\x12materializedInputs\"\xfb\x02\n\x10\x44\x65ploymentStatus\x12!\n\x1d\x44\x45PLOYMENT_STATUS_UNSPECIFIED\x10\x00\x12 \n\x1c\x44\x45PLOYMENT_STATUS_UNASSIGNED\x10\x01\x12\x1e\n\x1a\x44\x45PLOYMENT_STATUS_ASSIGNED\x10\x02\x12\x1d\n\x19\x44\x45PLOYMENT_STATUS_PENDING\x10\x03\x12\x1d\n\x19\x44\x45PLOYMENT_STATUS_STOPPED\x10\x04\x12!\n\x19\x44\x45PLOYMENT_STATUS_STARTED\x10\x05\x1a\x02\x08\x01\x12\x1c\n\x18\x44\x45PLOYMENT_STATUS_FAILED\x10\x06\x12\x1c\n\x18\x44\x45PLOYMENT_STATUS_ACTIVE\x10\x07\x12 \n\x1c\x44\x45PLOYMENT_STATUS_SCALING_UP\x10\x08\x12\"\n\x1e\x44\x45PLOYMENT_STATUS_SCALING_DOWN\x10\t\x12\x1f\n\x1b\x44\x45PLOYMENT_STATUS_DEPLOYING\x10\n\"+\n\x0bK8sMetadata\x12\x1c\n\tnamespace\x18\x01 \x01(\tR\tnamespace\"\x85\x01\n\x07Ingress\x12*\n\npublic_url\x18\x01 \x01(\tB\x0b\xbaH\x08r\x03\x88\x01\x01\xd8\x01\x01R\tpublicUrl\x12(\n\tcname_url\x18\x02 \x01(\tB\x0b\xbaH\x08r\x03\x88\x01\x01\xd8\x01\x01R\x08\x63nameUrl\x12$\n\x07vpc_url\x18\x03 \x01(\tB\x0b\xbaH\x08r\x03\x88\x01\x01\xd8\x01\x01R\x06vpcUrl\"\x94\x08\n\x04Spec\x12\x39\n\tcontainer\x18\x01 \x01(\x0b\x32\x19.flyteidl2.core.ContainerH\x00R\tcontainer\x12*\n\x03pod\x18\x02 \x01(\x0b\x32\x16.flyteidl2.core.K8sPodH\x00R\x03pod\x12\x42\n\x0b\x61utoscaling\x18\x03 \x01(\x0b\x32 .flyteidl2.app.AutoscalingConfigR\x0b\x61utoscaling\x12\x36\n\x07ingress\x18\x04 \x01(\x0b\x32\x1c.flyteidl2.app.IngressConfigR\x07ingress\x12\x45\n\rdesired_state\x18\x05 \x01(\x0e\x32 .flyteidl2.app.Spec.DesiredStateR\x0c\x64\x65siredState\x12!\n\x0c\x63luster_pool\x18\x06 \x01(\tR\x0b\x63lusterPool\x12\x33\n\x06images\x18\x07 \x01(\x0b\x32\x1b.flyteidl2.app.ImageSpecSetR\x06images\x12I\n\x10security_context\x18\x08 \x01(\x0b\x32\x1e.flyteidl2.app.SecurityContextR\x0fsecurityContext\x12P\n\x12\x65xtended_resources\x18\t \x01(\x0b\x32!.flyteidl2.core.ExtendedResourcesR\x11\x65xtendedResources\x12L\n\x10runtime_metadata\x18\n \x01(\x0b\x32!.flyteidl2.common.RuntimeMetadataR\x0fruntimeMetadata\x12\x30\n\x07profile\x18\x0b \x01(\x0b\x32\x16.flyteidl2.app.ProfileR\x07profile\x12<\n\x07\x63reator\x18\x0c \x01(\x0b\x32\".flyteidl2.common.EnrichedIdentityR\x07\x63reator\x12\x30\n\x06inputs\x18\r \x01(\x0b\x32\x18.flyteidl2.app.InputListR\x06inputs\x12)\n\x05links\x18\x0e \x03(\x0b\x32\x13.flyteidl2.app.LinkR\x05links\x12\x38\n\x08timeouts\x18\x0f \x01(\x0b\x32\x1c.flyteidl2.app.TimeoutConfigR\x08timeouts\"\x81\x01\n\x0c\x44\x65siredState\x12\x1d\n\x19\x44\x45SIRED_STATE_UNSPECIFIED\x10\x00\x12\x19\n\x15\x44\x45SIRED_STATE_STOPPED\x10\x01\x12\x1d\n\x15\x44\x45SIRED_STATE_STARTED\x10\x02\x1a\x02\x08\x01\x12\x18\n\x14\x44\x45SIRED_STATE_ACTIVE\x10\x03\x42\x14\n\x0b\x61pp_payload\x12\x05\xbaH\x02\x08\x01\"Z\n\x04Link\x12\x1b\n\x04path\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x04path\x12\x14\n\x05title\x18\x02 \x01(\tR\x05title\x12\x1f\n\x0bis_relative\x18\x03 \x01(\x08R\nisRelative\"\x9d\x02\n\x05Input\x12\x1b\n\x04name\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x04name\x12,\n\x0cstring_value\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01H\x00R\x0bstringValue\x12\x46\n\x0e\x61rtifact_query\x18\x03 \x01(\x0b\x32\x1d.flyteidl2.core.ArtifactQueryH\x00R\rartifactQuery\x12=\n\x0b\x61rtifact_id\x18\x04 \x01(\x0b\x32\x1a.flyteidl2.core.ArtifactIDH\x00R\nartifactId\x12\x32\n\x06\x61pp_id\x18\x05 \x01(\x0b\x32\x19.flyteidl2.app.IdentifierH\x00R\x05\x61ppIdB\x0e\n\x05value\x12\x05\xbaH\x02\x08\x01\"q\n\x12MaterializedInputs\x12\x36\n\x05items\x18\x01 \x03(\x0b\x32 .flyteidl2.app.MaterializedInputR\x05items\x12#\n\x08revision\x18\x02 \x01(\x04\x42\x07\xbaH\x04\x32\x02(\x00R\x08revision\"\x7f\n\x11MaterializedInput\x12\x1b\n\x04name\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x04name\x12=\n\x0b\x61rtifact_id\x18\x02 \x01(\x0b\x32\x1a.flyteidl2.core.ArtifactIDH\x00R\nartifactIdB\x0e\n\x05value\x12\x05\xbaH\x02\x08\x01\"7\n\tInputList\x12*\n\x05items\x18\x01 \x03(\x0b\x32\x14.flyteidl2.app.InputR\x05items\"\x82\x01\n\x07Profile\x12\x12\n\x04type\x18\x01 \x01(\tR\x04type\x12\x12\n\x04name\x18\x02 \x01(\tR\x04name\x12\x34\n\x11short_description\x18\x03 \x01(\tB\x07\xbaH\x04r\x02\x18\x64R\x10shortDescription\x12\x19\n\x08icon_url\x18\x04 \x01(\tR\x07iconUrl\"\xa9\x01\n\x0fSecurityContext\x12/\n\x06run_as\x18\x01 \x01(\x0b\x32\x18.flyteidl2.core.IdentityR\x05runAs\x12\x30\n\x07secrets\x18\x02 \x03(\x0b\x32\x16.flyteidl2.core.SecretR\x07secrets\x12\'\n\x0f\x61llow_anonymous\x18\x05 \x01(\x08R\x0e\x61llowAnonymousJ\x04\x08\x03\x10\x04J\x04\x08\x04\x10\x05\"A\n\tImageSpec\x12\x10\n\x03tag\x18\x01 \x01(\tR\x03tag\x12\"\n\rbuild_job_url\x18\x02 \x01(\tR\x0b\x62uildJobUrl\"@\n\x0cImageSpecSet\x12\x30\n\x06images\x18\x01 \x03(\x0b\x32\x18.flyteidl2.app.ImageSpecR\x06images\"]\n\rIngressConfig\x12\x18\n\x07private\x18\x01 \x01(\x08R\x07private\x12\x1c\n\tsubdomain\x18\x02 \x01(\tR\tsubdomain\x12\x14\n\x05\x63name\x18\x03 \x01(\tR\x05\x63name\"\xd3\x01\n\x11\x41utoscalingConfig\x12\x33\n\x08replicas\x18\x01 \x01(\x0b\x32\x17.flyteidl2.app.ReplicasR\x08replicas\x12\x44\n\x10scaledown_period\x18\x02 \x01(\x0b\x32\x19.google.protobuf.DurationR\x0fscaledownPeriod\x12\x43\n\x0escaling_metric\x18\x03 \x01(\x0b\x32\x1c.flyteidl2.app.ScalingMetricR\rscalingMetric\"\xa1\x01\n\rScalingMetric\x12?\n\x0crequest_rate\x18\x01 \x01(\x0b\x32\x1a.flyteidl2.app.RequestRateH\x00R\x0brequestRate\x12>\n\x0b\x63oncurrency\x18\x02 \x01(\x0b\x32\x1a.flyteidl2.app.ConcurrencyH\x00R\x0b\x63oncurrencyB\x0f\n\x06metric\x12\x05\xbaH\x02\x08\x01\"9\n\x0b\x43oncurrency\x12*\n\x0ctarget_value\x18\x01 \x01(\rB\x07\xbaH\x04*\x02 \x00R\x0btargetValue\"9\n\x0bRequestRate\x12*\n\x0ctarget_value\x18\x01 \x01(\rB\x07\xbaH\x04*\x02(\x00R\x0btargetValue\"@\n\x08Replicas\x12\x19\n\x03min\x18\x01 \x01(\rB\x07\xbaH\x04*\x02(\x00R\x03min\x12\x19\n\x03max\x18\x02 \x01(\rB\x07\xbaH\x04*\x02(\x00R\x03max\"b\n\rTimeoutConfig\x12Q\n\x0frequest_timeout\x18\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\r\xbaH\n\xaa\x01\x07\"\x03\x08\x90\x1c\x32\x00R\x0erequestTimeoutB\xb1\x01\n\x11\x63om.flyteidl2.appB\x12\x41ppDefinitionProtoH\x02P\x01Z1github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app\xa2\x02\x03\x46\x41X\xaa\x02\rFlyteidl2.App\xca\x02\rFlyteidl2\\App\xe2\x02\x19\x46lyteidl2\\App\\GPBMetadata\xea\x02\x0e\x46lyteidl2::Appb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.app.app_definition_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\021com.flyteidl2.appB\022AppDefinitionProtoH\002P\001Z1github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app\242\002\003FAX\252\002\rFlyteidl2.App\312\002\rFlyteidl2\\App\342\002\031Flyteidl2\\App\\GPBMetadata\352\002\016Flyteidl2::App' + _IDENTIFIER.fields_by_name['project']._options = None + _IDENTIFIER.fields_by_name['project']._serialized_options = b'\272H\004r\002\020\001' + _IDENTIFIER.fields_by_name['domain']._options = None + _IDENTIFIER.fields_by_name['domain']._serialized_options = b'\272H\004r\002\020\001' + _IDENTIFIER.fields_by_name['name']._options = None + _IDENTIFIER.fields_by_name['name']._serialized_options = b'\272H7r5\020\001\030\0362/^[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?$' + _META_LABELSENTRY._options = None + _META_LABELSENTRY._serialized_options = b'8\001' + _META.fields_by_name['id']._options = None + _META.fields_by_name['id']._serialized_options = b'\272H\003\310\001\001' + _META.fields_by_name['revision']._options = None + _META.fields_by_name['revision']._serialized_options = b'\272H\0042\002(\000' + _APP.fields_by_name['metadata']._options = None + _APP.fields_by_name['metadata']._serialized_options = b'\272H\003\310\001\001' + _APP.fields_by_name['spec']._options = None + _APP.fields_by_name['spec']._serialized_options = b'\272H\003\310\001\001' + _CONDITION.fields_by_name['revision']._options = None + _CONDITION.fields_by_name['revision']._serialized_options = b'\272H\0042\002(\000' + _STATUS_DEPLOYMENTSTATUS.values_by_name["DEPLOYMENT_STATUS_STARTED"]._options = None + _STATUS_DEPLOYMENTSTATUS.values_by_name["DEPLOYMENT_STATUS_STARTED"]._serialized_options = b'\010\001' + _STATUS.fields_by_name['current_replicas']._options = None + _STATUS.fields_by_name['current_replicas']._serialized_options = b'\272H\004*\002(\000' + _INGRESS.fields_by_name['public_url']._options = None + _INGRESS.fields_by_name['public_url']._serialized_options = b'\272H\010r\003\210\001\001\330\001\001' + _INGRESS.fields_by_name['cname_url']._options = None + _INGRESS.fields_by_name['cname_url']._serialized_options = b'\272H\010r\003\210\001\001\330\001\001' + _INGRESS.fields_by_name['vpc_url']._options = None + _INGRESS.fields_by_name['vpc_url']._serialized_options = b'\272H\010r\003\210\001\001\330\001\001' + _SPEC.oneofs_by_name['app_payload']._options = None + _SPEC.oneofs_by_name['app_payload']._serialized_options = b'\272H\002\010\001' + _SPEC_DESIREDSTATE.values_by_name["DESIRED_STATE_STARTED"]._options = None + _SPEC_DESIREDSTATE.values_by_name["DESIRED_STATE_STARTED"]._serialized_options = b'\010\001' + _LINK.fields_by_name['path']._options = None + _LINK.fields_by_name['path']._serialized_options = b'\272H\004r\002\020\001' + _INPUT.oneofs_by_name['value']._options = None + _INPUT.oneofs_by_name['value']._serialized_options = b'\272H\002\010\001' + _INPUT.fields_by_name['name']._options = None + _INPUT.fields_by_name['name']._serialized_options = b'\272H\004r\002\020\001' + _INPUT.fields_by_name['string_value']._options = None + _INPUT.fields_by_name['string_value']._serialized_options = b'\272H\004r\002\020\001' + _MATERIALIZEDINPUTS.fields_by_name['revision']._options = None + _MATERIALIZEDINPUTS.fields_by_name['revision']._serialized_options = b'\272H\0042\002(\000' + _MATERIALIZEDINPUT.oneofs_by_name['value']._options = None + _MATERIALIZEDINPUT.oneofs_by_name['value']._serialized_options = b'\272H\002\010\001' + _MATERIALIZEDINPUT.fields_by_name['name']._options = None + _MATERIALIZEDINPUT.fields_by_name['name']._serialized_options = b'\272H\004r\002\020\001' + _PROFILE.fields_by_name['short_description']._options = None + _PROFILE.fields_by_name['short_description']._serialized_options = b'\272H\004r\002\030d' + _SCALINGMETRIC.oneofs_by_name['metric']._options = None + _SCALINGMETRIC.oneofs_by_name['metric']._serialized_options = b'\272H\002\010\001' + _CONCURRENCY.fields_by_name['target_value']._options = None + _CONCURRENCY.fields_by_name['target_value']._serialized_options = b'\272H\004*\002 \000' + _REQUESTRATE.fields_by_name['target_value']._options = None + _REQUESTRATE.fields_by_name['target_value']._serialized_options = b'\272H\004*\002(\000' + _REPLICAS.fields_by_name['min']._options = None + _REPLICAS.fields_by_name['min']._serialized_options = b'\272H\004*\002(\000' + _REPLICAS.fields_by_name['max']._options = None + _REPLICAS.fields_by_name['max']._serialized_options = b'\272H\004*\002(\000' + _TIMEOUTCONFIG.fields_by_name['request_timeout']._options = None + _TIMEOUTCONFIG.fields_by_name['request_timeout']._serialized_options = b'\272H\n\252\001\007\"\003\010\220\0342\000' + _globals['_IDENTIFIER']._serialized_start=314 + _globals['_IDENTIFIER']._serialized_end=492 + _globals['_META']._serialized_start=495 + _globals['_META']._serialized_end=705 + _globals['_META_LABELSENTRY']._serialized_start=648 + _globals['_META_LABELSENTRY']._serialized_end=705 + _globals['_APPWRAPPER']._serialized_start=708 + _globals['_APPWRAPPER']._serialized_end=843 + _globals['_APP']._serialized_start=846 + _globals['_APP']._serialized_end=1004 + _globals['_CONDITION']._serialized_start=1007 + _globals['_CONDITION']._serialized_end=1302 + _globals['_STATUS']._serialized_start=1305 + _globals['_STATUS']._serialized_end=2243 + _globals['_STATUS_DEPLOYMENTSTATUS']._serialized_start=1864 + _globals['_STATUS_DEPLOYMENTSTATUS']._serialized_end=2243 + _globals['_K8SMETADATA']._serialized_start=2245 + _globals['_K8SMETADATA']._serialized_end=2288 + _globals['_INGRESS']._serialized_start=2291 + _globals['_INGRESS']._serialized_end=2424 + _globals['_SPEC']._serialized_start=2427 + _globals['_SPEC']._serialized_end=3471 + _globals['_SPEC_DESIREDSTATE']._serialized_start=3320 + _globals['_SPEC_DESIREDSTATE']._serialized_end=3449 + _globals['_LINK']._serialized_start=3473 + _globals['_LINK']._serialized_end=3563 + _globals['_INPUT']._serialized_start=3566 + _globals['_INPUT']._serialized_end=3851 + _globals['_MATERIALIZEDINPUTS']._serialized_start=3853 + _globals['_MATERIALIZEDINPUTS']._serialized_end=3966 + _globals['_MATERIALIZEDINPUT']._serialized_start=3968 + _globals['_MATERIALIZEDINPUT']._serialized_end=4095 + _globals['_INPUTLIST']._serialized_start=4097 + _globals['_INPUTLIST']._serialized_end=4152 + _globals['_PROFILE']._serialized_start=4155 + _globals['_PROFILE']._serialized_end=4285 + _globals['_SECURITYCONTEXT']._serialized_start=4288 + _globals['_SECURITYCONTEXT']._serialized_end=4457 + _globals['_IMAGESPEC']._serialized_start=4459 + _globals['_IMAGESPEC']._serialized_end=4524 + _globals['_IMAGESPECSET']._serialized_start=4526 + _globals['_IMAGESPECSET']._serialized_end=4590 + _globals['_INGRESSCONFIG']._serialized_start=4592 + _globals['_INGRESSCONFIG']._serialized_end=4685 + _globals['_AUTOSCALINGCONFIG']._serialized_start=4688 + _globals['_AUTOSCALINGCONFIG']._serialized_end=4899 + _globals['_SCALINGMETRIC']._serialized_start=4902 + _globals['_SCALINGMETRIC']._serialized_end=5063 + _globals['_CONCURRENCY']._serialized_start=5065 + _globals['_CONCURRENCY']._serialized_end=5122 + _globals['_REQUESTRATE']._serialized_start=5124 + _globals['_REQUESTRATE']._serialized_end=5181 + _globals['_REPLICAS']._serialized_start=5183 + _globals['_REPLICAS']._serialized_end=5247 + _globals['_TIMEOUTCONFIG']._serialized_start=5249 + _globals['_TIMEOUTCONFIG']._serialized_end=5347 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/app/app_definition_pb2.pyi b/gen/python/flyteidl2/app/app_definition_pb2.pyi new file mode 100644 index 0000000000..19370d4536 --- /dev/null +++ b/gen/python/flyteidl2/app/app_definition_pb2.pyi @@ -0,0 +1,320 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.common import identity_pb2 as _identity_pb2 +from flyteidl2.common import runtime_version_pb2 as _runtime_version_pb2 +from flyteidl2.core import artifact_id_pb2 as _artifact_id_pb2 +from flyteidl2.core import security_pb2 as _security_pb2 +from flyteidl2.core import tasks_pb2 as _tasks_pb2 +from google.protobuf import duration_pb2 as _duration_pb2 +from google.protobuf import timestamp_pb2 as _timestamp_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class Identifier(_message.Message): + __slots__ = ["org", "project", "domain", "name"] + ORG_FIELD_NUMBER: _ClassVar[int] + PROJECT_FIELD_NUMBER: _ClassVar[int] + DOMAIN_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + org: str + project: str + domain: str + name: str + def __init__(self, org: _Optional[str] = ..., project: _Optional[str] = ..., domain: _Optional[str] = ..., name: _Optional[str] = ...) -> None: ... + +class Meta(_message.Message): + __slots__ = ["id", "revision", "labels"] + class LabelsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + ID_FIELD_NUMBER: _ClassVar[int] + REVISION_FIELD_NUMBER: _ClassVar[int] + LABELS_FIELD_NUMBER: _ClassVar[int] + id: Identifier + revision: int + labels: _containers.ScalarMap[str, str] + def __init__(self, id: _Optional[_Union[Identifier, _Mapping]] = ..., revision: _Optional[int] = ..., labels: _Optional[_Mapping[str, str]] = ...) -> None: ... + +class AppWrapper(_message.Message): + __slots__ = ["host", "app", "app_id"] + HOST_FIELD_NUMBER: _ClassVar[int] + APP_FIELD_NUMBER: _ClassVar[int] + APP_ID_FIELD_NUMBER: _ClassVar[int] + host: str + app: App + app_id: Identifier + def __init__(self, host: _Optional[str] = ..., app: _Optional[_Union[App, _Mapping]] = ..., app_id: _Optional[_Union[Identifier, _Mapping]] = ...) -> None: ... + +class App(_message.Message): + __slots__ = ["metadata", "spec", "status"] + METADATA_FIELD_NUMBER: _ClassVar[int] + SPEC_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + metadata: Meta + spec: Spec + status: Status + def __init__(self, metadata: _Optional[_Union[Meta, _Mapping]] = ..., spec: _Optional[_Union[Spec, _Mapping]] = ..., status: _Optional[_Union[Status, _Mapping]] = ...) -> None: ... + +class Condition(_message.Message): + __slots__ = ["last_transition_time", "deployment_status", "message", "revision", "actor"] + LAST_TRANSITION_TIME_FIELD_NUMBER: _ClassVar[int] + DEPLOYMENT_STATUS_FIELD_NUMBER: _ClassVar[int] + MESSAGE_FIELD_NUMBER: _ClassVar[int] + REVISION_FIELD_NUMBER: _ClassVar[int] + ACTOR_FIELD_NUMBER: _ClassVar[int] + last_transition_time: _timestamp_pb2.Timestamp + deployment_status: Status.DeploymentStatus + message: str + revision: int + actor: _identity_pb2.EnrichedIdentity + def __init__(self, last_transition_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., deployment_status: _Optional[_Union[Status.DeploymentStatus, str]] = ..., message: _Optional[str] = ..., revision: _Optional[int] = ..., actor: _Optional[_Union[_identity_pb2.EnrichedIdentity, _Mapping]] = ...) -> None: ... + +class Status(_message.Message): + __slots__ = ["assigned_cluster", "current_replicas", "ingress", "created_at", "last_updated_at", "conditions", "lease_expiration", "k8s_metadata", "materialized_inputs"] + class DeploymentStatus(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + DEPLOYMENT_STATUS_UNSPECIFIED: _ClassVar[Status.DeploymentStatus] + DEPLOYMENT_STATUS_UNASSIGNED: _ClassVar[Status.DeploymentStatus] + DEPLOYMENT_STATUS_ASSIGNED: _ClassVar[Status.DeploymentStatus] + DEPLOYMENT_STATUS_PENDING: _ClassVar[Status.DeploymentStatus] + DEPLOYMENT_STATUS_STOPPED: _ClassVar[Status.DeploymentStatus] + DEPLOYMENT_STATUS_STARTED: _ClassVar[Status.DeploymentStatus] + DEPLOYMENT_STATUS_FAILED: _ClassVar[Status.DeploymentStatus] + DEPLOYMENT_STATUS_ACTIVE: _ClassVar[Status.DeploymentStatus] + DEPLOYMENT_STATUS_SCALING_UP: _ClassVar[Status.DeploymentStatus] + DEPLOYMENT_STATUS_SCALING_DOWN: _ClassVar[Status.DeploymentStatus] + DEPLOYMENT_STATUS_DEPLOYING: _ClassVar[Status.DeploymentStatus] + DEPLOYMENT_STATUS_UNSPECIFIED: Status.DeploymentStatus + DEPLOYMENT_STATUS_UNASSIGNED: Status.DeploymentStatus + DEPLOYMENT_STATUS_ASSIGNED: Status.DeploymentStatus + DEPLOYMENT_STATUS_PENDING: Status.DeploymentStatus + DEPLOYMENT_STATUS_STOPPED: Status.DeploymentStatus + DEPLOYMENT_STATUS_STARTED: Status.DeploymentStatus + DEPLOYMENT_STATUS_FAILED: Status.DeploymentStatus + DEPLOYMENT_STATUS_ACTIVE: Status.DeploymentStatus + DEPLOYMENT_STATUS_SCALING_UP: Status.DeploymentStatus + DEPLOYMENT_STATUS_SCALING_DOWN: Status.DeploymentStatus + DEPLOYMENT_STATUS_DEPLOYING: Status.DeploymentStatus + ASSIGNED_CLUSTER_FIELD_NUMBER: _ClassVar[int] + CURRENT_REPLICAS_FIELD_NUMBER: _ClassVar[int] + INGRESS_FIELD_NUMBER: _ClassVar[int] + CREATED_AT_FIELD_NUMBER: _ClassVar[int] + LAST_UPDATED_AT_FIELD_NUMBER: _ClassVar[int] + CONDITIONS_FIELD_NUMBER: _ClassVar[int] + LEASE_EXPIRATION_FIELD_NUMBER: _ClassVar[int] + K8S_METADATA_FIELD_NUMBER: _ClassVar[int] + MATERIALIZED_INPUTS_FIELD_NUMBER: _ClassVar[int] + assigned_cluster: str + current_replicas: int + ingress: Ingress + created_at: _timestamp_pb2.Timestamp + last_updated_at: _timestamp_pb2.Timestamp + conditions: _containers.RepeatedCompositeFieldContainer[Condition] + lease_expiration: _timestamp_pb2.Timestamp + k8s_metadata: K8sMetadata + materialized_inputs: MaterializedInputs + def __init__(self, assigned_cluster: _Optional[str] = ..., current_replicas: _Optional[int] = ..., ingress: _Optional[_Union[Ingress, _Mapping]] = ..., created_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., last_updated_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., conditions: _Optional[_Iterable[_Union[Condition, _Mapping]]] = ..., lease_expiration: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., k8s_metadata: _Optional[_Union[K8sMetadata, _Mapping]] = ..., materialized_inputs: _Optional[_Union[MaterializedInputs, _Mapping]] = ...) -> None: ... + +class K8sMetadata(_message.Message): + __slots__ = ["namespace"] + NAMESPACE_FIELD_NUMBER: _ClassVar[int] + namespace: str + def __init__(self, namespace: _Optional[str] = ...) -> None: ... + +class Ingress(_message.Message): + __slots__ = ["public_url", "cname_url", "vpc_url"] + PUBLIC_URL_FIELD_NUMBER: _ClassVar[int] + CNAME_URL_FIELD_NUMBER: _ClassVar[int] + VPC_URL_FIELD_NUMBER: _ClassVar[int] + public_url: str + cname_url: str + vpc_url: str + def __init__(self, public_url: _Optional[str] = ..., cname_url: _Optional[str] = ..., vpc_url: _Optional[str] = ...) -> None: ... + +class Spec(_message.Message): + __slots__ = ["container", "pod", "autoscaling", "ingress", "desired_state", "cluster_pool", "images", "security_context", "extended_resources", "runtime_metadata", "profile", "creator", "inputs", "links", "timeouts"] + class DesiredState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + DESIRED_STATE_UNSPECIFIED: _ClassVar[Spec.DesiredState] + DESIRED_STATE_STOPPED: _ClassVar[Spec.DesiredState] + DESIRED_STATE_STARTED: _ClassVar[Spec.DesiredState] + DESIRED_STATE_ACTIVE: _ClassVar[Spec.DesiredState] + DESIRED_STATE_UNSPECIFIED: Spec.DesiredState + DESIRED_STATE_STOPPED: Spec.DesiredState + DESIRED_STATE_STARTED: Spec.DesiredState + DESIRED_STATE_ACTIVE: Spec.DesiredState + CONTAINER_FIELD_NUMBER: _ClassVar[int] + POD_FIELD_NUMBER: _ClassVar[int] + AUTOSCALING_FIELD_NUMBER: _ClassVar[int] + INGRESS_FIELD_NUMBER: _ClassVar[int] + DESIRED_STATE_FIELD_NUMBER: _ClassVar[int] + CLUSTER_POOL_FIELD_NUMBER: _ClassVar[int] + IMAGES_FIELD_NUMBER: _ClassVar[int] + SECURITY_CONTEXT_FIELD_NUMBER: _ClassVar[int] + EXTENDED_RESOURCES_FIELD_NUMBER: _ClassVar[int] + RUNTIME_METADATA_FIELD_NUMBER: _ClassVar[int] + PROFILE_FIELD_NUMBER: _ClassVar[int] + CREATOR_FIELD_NUMBER: _ClassVar[int] + INPUTS_FIELD_NUMBER: _ClassVar[int] + LINKS_FIELD_NUMBER: _ClassVar[int] + TIMEOUTS_FIELD_NUMBER: _ClassVar[int] + container: _tasks_pb2.Container + pod: _tasks_pb2.K8sPod + autoscaling: AutoscalingConfig + ingress: IngressConfig + desired_state: Spec.DesiredState + cluster_pool: str + images: ImageSpecSet + security_context: SecurityContext + extended_resources: _tasks_pb2.ExtendedResources + runtime_metadata: _runtime_version_pb2.RuntimeMetadata + profile: Profile + creator: _identity_pb2.EnrichedIdentity + inputs: InputList + links: _containers.RepeatedCompositeFieldContainer[Link] + timeouts: TimeoutConfig + def __init__(self, container: _Optional[_Union[_tasks_pb2.Container, _Mapping]] = ..., pod: _Optional[_Union[_tasks_pb2.K8sPod, _Mapping]] = ..., autoscaling: _Optional[_Union[AutoscalingConfig, _Mapping]] = ..., ingress: _Optional[_Union[IngressConfig, _Mapping]] = ..., desired_state: _Optional[_Union[Spec.DesiredState, str]] = ..., cluster_pool: _Optional[str] = ..., images: _Optional[_Union[ImageSpecSet, _Mapping]] = ..., security_context: _Optional[_Union[SecurityContext, _Mapping]] = ..., extended_resources: _Optional[_Union[_tasks_pb2.ExtendedResources, _Mapping]] = ..., runtime_metadata: _Optional[_Union[_runtime_version_pb2.RuntimeMetadata, _Mapping]] = ..., profile: _Optional[_Union[Profile, _Mapping]] = ..., creator: _Optional[_Union[_identity_pb2.EnrichedIdentity, _Mapping]] = ..., inputs: _Optional[_Union[InputList, _Mapping]] = ..., links: _Optional[_Iterable[_Union[Link, _Mapping]]] = ..., timeouts: _Optional[_Union[TimeoutConfig, _Mapping]] = ...) -> None: ... + +class Link(_message.Message): + __slots__ = ["path", "title", "is_relative"] + PATH_FIELD_NUMBER: _ClassVar[int] + TITLE_FIELD_NUMBER: _ClassVar[int] + IS_RELATIVE_FIELD_NUMBER: _ClassVar[int] + path: str + title: str + is_relative: bool + def __init__(self, path: _Optional[str] = ..., title: _Optional[str] = ..., is_relative: bool = ...) -> None: ... + +class Input(_message.Message): + __slots__ = ["name", "string_value", "artifact_query", "artifact_id", "app_id"] + NAME_FIELD_NUMBER: _ClassVar[int] + STRING_VALUE_FIELD_NUMBER: _ClassVar[int] + ARTIFACT_QUERY_FIELD_NUMBER: _ClassVar[int] + ARTIFACT_ID_FIELD_NUMBER: _ClassVar[int] + APP_ID_FIELD_NUMBER: _ClassVar[int] + name: str + string_value: str + artifact_query: _artifact_id_pb2.ArtifactQuery + artifact_id: _artifact_id_pb2.ArtifactID + app_id: Identifier + def __init__(self, name: _Optional[str] = ..., string_value: _Optional[str] = ..., artifact_query: _Optional[_Union[_artifact_id_pb2.ArtifactQuery, _Mapping]] = ..., artifact_id: _Optional[_Union[_artifact_id_pb2.ArtifactID, _Mapping]] = ..., app_id: _Optional[_Union[Identifier, _Mapping]] = ...) -> None: ... + +class MaterializedInputs(_message.Message): + __slots__ = ["items", "revision"] + ITEMS_FIELD_NUMBER: _ClassVar[int] + REVISION_FIELD_NUMBER: _ClassVar[int] + items: _containers.RepeatedCompositeFieldContainer[MaterializedInput] + revision: int + def __init__(self, items: _Optional[_Iterable[_Union[MaterializedInput, _Mapping]]] = ..., revision: _Optional[int] = ...) -> None: ... + +class MaterializedInput(_message.Message): + __slots__ = ["name", "artifact_id"] + NAME_FIELD_NUMBER: _ClassVar[int] + ARTIFACT_ID_FIELD_NUMBER: _ClassVar[int] + name: str + artifact_id: _artifact_id_pb2.ArtifactID + def __init__(self, name: _Optional[str] = ..., artifact_id: _Optional[_Union[_artifact_id_pb2.ArtifactID, _Mapping]] = ...) -> None: ... + +class InputList(_message.Message): + __slots__ = ["items"] + ITEMS_FIELD_NUMBER: _ClassVar[int] + items: _containers.RepeatedCompositeFieldContainer[Input] + def __init__(self, items: _Optional[_Iterable[_Union[Input, _Mapping]]] = ...) -> None: ... + +class Profile(_message.Message): + __slots__ = ["type", "name", "short_description", "icon_url"] + TYPE_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + SHORT_DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + ICON_URL_FIELD_NUMBER: _ClassVar[int] + type: str + name: str + short_description: str + icon_url: str + def __init__(self, type: _Optional[str] = ..., name: _Optional[str] = ..., short_description: _Optional[str] = ..., icon_url: _Optional[str] = ...) -> None: ... + +class SecurityContext(_message.Message): + __slots__ = ["run_as", "secrets", "allow_anonymous"] + RUN_AS_FIELD_NUMBER: _ClassVar[int] + SECRETS_FIELD_NUMBER: _ClassVar[int] + ALLOW_ANONYMOUS_FIELD_NUMBER: _ClassVar[int] + run_as: _security_pb2.Identity + secrets: _containers.RepeatedCompositeFieldContainer[_security_pb2.Secret] + allow_anonymous: bool + def __init__(self, run_as: _Optional[_Union[_security_pb2.Identity, _Mapping]] = ..., secrets: _Optional[_Iterable[_Union[_security_pb2.Secret, _Mapping]]] = ..., allow_anonymous: bool = ...) -> None: ... + +class ImageSpec(_message.Message): + __slots__ = ["tag", "build_job_url"] + TAG_FIELD_NUMBER: _ClassVar[int] + BUILD_JOB_URL_FIELD_NUMBER: _ClassVar[int] + tag: str + build_job_url: str + def __init__(self, tag: _Optional[str] = ..., build_job_url: _Optional[str] = ...) -> None: ... + +class ImageSpecSet(_message.Message): + __slots__ = ["images"] + IMAGES_FIELD_NUMBER: _ClassVar[int] + images: _containers.RepeatedCompositeFieldContainer[ImageSpec] + def __init__(self, images: _Optional[_Iterable[_Union[ImageSpec, _Mapping]]] = ...) -> None: ... + +class IngressConfig(_message.Message): + __slots__ = ["private", "subdomain", "cname"] + PRIVATE_FIELD_NUMBER: _ClassVar[int] + SUBDOMAIN_FIELD_NUMBER: _ClassVar[int] + CNAME_FIELD_NUMBER: _ClassVar[int] + private: bool + subdomain: str + cname: str + def __init__(self, private: bool = ..., subdomain: _Optional[str] = ..., cname: _Optional[str] = ...) -> None: ... + +class AutoscalingConfig(_message.Message): + __slots__ = ["replicas", "scaledown_period", "scaling_metric"] + REPLICAS_FIELD_NUMBER: _ClassVar[int] + SCALEDOWN_PERIOD_FIELD_NUMBER: _ClassVar[int] + SCALING_METRIC_FIELD_NUMBER: _ClassVar[int] + replicas: Replicas + scaledown_period: _duration_pb2.Duration + scaling_metric: ScalingMetric + def __init__(self, replicas: _Optional[_Union[Replicas, _Mapping]] = ..., scaledown_period: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., scaling_metric: _Optional[_Union[ScalingMetric, _Mapping]] = ...) -> None: ... + +class ScalingMetric(_message.Message): + __slots__ = ["request_rate", "concurrency"] + REQUEST_RATE_FIELD_NUMBER: _ClassVar[int] + CONCURRENCY_FIELD_NUMBER: _ClassVar[int] + request_rate: RequestRate + concurrency: Concurrency + def __init__(self, request_rate: _Optional[_Union[RequestRate, _Mapping]] = ..., concurrency: _Optional[_Union[Concurrency, _Mapping]] = ...) -> None: ... + +class Concurrency(_message.Message): + __slots__ = ["target_value"] + TARGET_VALUE_FIELD_NUMBER: _ClassVar[int] + target_value: int + def __init__(self, target_value: _Optional[int] = ...) -> None: ... + +class RequestRate(_message.Message): + __slots__ = ["target_value"] + TARGET_VALUE_FIELD_NUMBER: _ClassVar[int] + target_value: int + def __init__(self, target_value: _Optional[int] = ...) -> None: ... + +class Replicas(_message.Message): + __slots__ = ["min", "max"] + MIN_FIELD_NUMBER: _ClassVar[int] + MAX_FIELD_NUMBER: _ClassVar[int] + min: int + max: int + def __init__(self, min: _Optional[int] = ..., max: _Optional[int] = ...) -> None: ... + +class TimeoutConfig(_message.Message): + __slots__ = ["request_timeout"] + REQUEST_TIMEOUT_FIELD_NUMBER: _ClassVar[int] + request_timeout: _duration_pb2.Duration + def __init__(self, request_timeout: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/app/app_definition_pb2_grpc.py b/gen/python/flyteidl2/app/app_definition_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/app/app_definition_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/app/app_logs_payload_pb2.py b/gen/python/flyteidl2/app/app_logs_payload_pb2.py new file mode 100644 index 0000000000..cbddfbd256 --- /dev/null +++ b/gen/python/flyteidl2/app/app_logs_payload_pb2.py @@ -0,0 +1,48 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/app/app_logs_payload.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.app import app_definition_pb2 as flyteidl2_dot_app_dot_app__definition__pb2 +from flyteidl2.app import replica_definition_pb2 as flyteidl2_dot_app_dot_replica__definition__pb2 +from flyteidl2.logs.dataplane import payload_pb2 as flyteidl2_dot_logs_dot_dataplane_dot_payload__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n$flyteidl2/app/app_logs_payload.proto\x12\rflyteidl2.app\x1a\x1b\x62uf/validate/validate.proto\x1a\"flyteidl2/app/app_definition.proto\x1a&flyteidl2/app/replica_definition.proto\x1a&flyteidl2/logs/dataplane/payload.proto\"\x99\x01\n\x0fTailLogsRequest\x12\x32\n\x06\x61pp_id\x18\x01 \x01(\x0b\x32\x19.flyteidl2.app.IdentifierH\x00R\x05\x61ppId\x12\x41\n\nreplica_id\x18\x02 \x01(\x0b\x32 .flyteidl2.app.ReplicaIdentifierH\x00R\treplicaIdB\x0f\n\x06target\x12\x05\xbaH\x02\x08\x01\"U\n\x15ReplicaIdentifierList\x12<\n\x08replicas\x18\x01 \x03(\x0b\x32 .flyteidl2.app.ReplicaIdentifierR\x08replicas\"\xbb\x01\n\x08LogLines\x12\x18\n\x05lines\x18\x01 \x03(\tB\x02\x18\x01R\x05lines\x12G\n\nreplica_id\x18\x02 \x01(\x0b\x32 .flyteidl2.app.ReplicaIdentifierB\x06\xbaH\x03\xc8\x01\x01R\treplicaId\x12L\n\x10structured_lines\x18\x03 \x03(\x0b\x32!.flyteidl2.logs.dataplane.LogLineR\x0fstructuredLines\"<\n\rLogLinesBatch\x12+\n\x04logs\x18\x01 \x03(\x0b\x32\x17.flyteidl2.app.LogLinesR\x04logs\"\xe6\x01\n\x10TailLogsResponse\x12\x42\n\x08replicas\x18\x01 \x01(\x0b\x32$.flyteidl2.app.ReplicaIdentifierListH\x00R\x08replicas\x12\x45\n\tlog_lines\x18\x02 \x01(\x0b\x32\".flyteidl2.logs.dataplane.LogLinesB\x02\x18\x01H\x00R\x08logLines\x12\x38\n\x07\x62\x61tches\x18\x03 \x01(\x0b\x32\x1c.flyteidl2.app.LogLinesBatchH\x00R\x07\x62\x61tchesB\r\n\x04resp\x12\x05\xbaH\x02\x08\x01\x42\xb2\x01\n\x11\x63om.flyteidl2.appB\x13\x41ppLogsPayloadProtoH\x02P\x01Z1github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app\xa2\x02\x03\x46\x41X\xaa\x02\rFlyteidl2.App\xca\x02\rFlyteidl2\\App\xe2\x02\x19\x46lyteidl2\\App\\GPBMetadata\xea\x02\x0e\x46lyteidl2::Appb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.app.app_logs_payload_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\021com.flyteidl2.appB\023AppLogsPayloadProtoH\002P\001Z1github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app\242\002\003FAX\252\002\rFlyteidl2.App\312\002\rFlyteidl2\\App\342\002\031Flyteidl2\\App\\GPBMetadata\352\002\016Flyteidl2::App' + _TAILLOGSREQUEST.oneofs_by_name['target']._options = None + _TAILLOGSREQUEST.oneofs_by_name['target']._serialized_options = b'\272H\002\010\001' + _LOGLINES.fields_by_name['lines']._options = None + _LOGLINES.fields_by_name['lines']._serialized_options = b'\030\001' + _LOGLINES.fields_by_name['replica_id']._options = None + _LOGLINES.fields_by_name['replica_id']._serialized_options = b'\272H\003\310\001\001' + _TAILLOGSRESPONSE.oneofs_by_name['resp']._options = None + _TAILLOGSRESPONSE.oneofs_by_name['resp']._serialized_options = b'\272H\002\010\001' + _TAILLOGSRESPONSE.fields_by_name['log_lines']._options = None + _TAILLOGSRESPONSE.fields_by_name['log_lines']._serialized_options = b'\030\001' + _globals['_TAILLOGSREQUEST']._serialized_start=201 + _globals['_TAILLOGSREQUEST']._serialized_end=354 + _globals['_REPLICAIDENTIFIERLIST']._serialized_start=356 + _globals['_REPLICAIDENTIFIERLIST']._serialized_end=441 + _globals['_LOGLINES']._serialized_start=444 + _globals['_LOGLINES']._serialized_end=631 + _globals['_LOGLINESBATCH']._serialized_start=633 + _globals['_LOGLINESBATCH']._serialized_end=693 + _globals['_TAILLOGSRESPONSE']._serialized_start=696 + _globals['_TAILLOGSRESPONSE']._serialized_end=926 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/app/app_logs_payload_pb2.pyi b/gen/python/flyteidl2/app/app_logs_payload_pb2.pyi new file mode 100644 index 0000000000..9088182562 --- /dev/null +++ b/gen/python/flyteidl2/app/app_logs_payload_pb2.pyi @@ -0,0 +1,50 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.app import app_definition_pb2 as _app_definition_pb2 +from flyteidl2.app import replica_definition_pb2 as _replica_definition_pb2 +from flyteidl2.logs.dataplane import payload_pb2 as _payload_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class TailLogsRequest(_message.Message): + __slots__ = ["app_id", "replica_id"] + APP_ID_FIELD_NUMBER: _ClassVar[int] + REPLICA_ID_FIELD_NUMBER: _ClassVar[int] + app_id: _app_definition_pb2.Identifier + replica_id: _replica_definition_pb2.ReplicaIdentifier + def __init__(self, app_id: _Optional[_Union[_app_definition_pb2.Identifier, _Mapping]] = ..., replica_id: _Optional[_Union[_replica_definition_pb2.ReplicaIdentifier, _Mapping]] = ...) -> None: ... + +class ReplicaIdentifierList(_message.Message): + __slots__ = ["replicas"] + REPLICAS_FIELD_NUMBER: _ClassVar[int] + replicas: _containers.RepeatedCompositeFieldContainer[_replica_definition_pb2.ReplicaIdentifier] + def __init__(self, replicas: _Optional[_Iterable[_Union[_replica_definition_pb2.ReplicaIdentifier, _Mapping]]] = ...) -> None: ... + +class LogLines(_message.Message): + __slots__ = ["lines", "replica_id", "structured_lines"] + LINES_FIELD_NUMBER: _ClassVar[int] + REPLICA_ID_FIELD_NUMBER: _ClassVar[int] + STRUCTURED_LINES_FIELD_NUMBER: _ClassVar[int] + lines: _containers.RepeatedScalarFieldContainer[str] + replica_id: _replica_definition_pb2.ReplicaIdentifier + structured_lines: _containers.RepeatedCompositeFieldContainer[_payload_pb2.LogLine] + def __init__(self, lines: _Optional[_Iterable[str]] = ..., replica_id: _Optional[_Union[_replica_definition_pb2.ReplicaIdentifier, _Mapping]] = ..., structured_lines: _Optional[_Iterable[_Union[_payload_pb2.LogLine, _Mapping]]] = ...) -> None: ... + +class LogLinesBatch(_message.Message): + __slots__ = ["logs"] + LOGS_FIELD_NUMBER: _ClassVar[int] + logs: _containers.RepeatedCompositeFieldContainer[LogLines] + def __init__(self, logs: _Optional[_Iterable[_Union[LogLines, _Mapping]]] = ...) -> None: ... + +class TailLogsResponse(_message.Message): + __slots__ = ["replicas", "log_lines", "batches"] + REPLICAS_FIELD_NUMBER: _ClassVar[int] + LOG_LINES_FIELD_NUMBER: _ClassVar[int] + BATCHES_FIELD_NUMBER: _ClassVar[int] + replicas: ReplicaIdentifierList + log_lines: _payload_pb2.LogLines + batches: LogLinesBatch + def __init__(self, replicas: _Optional[_Union[ReplicaIdentifierList, _Mapping]] = ..., log_lines: _Optional[_Union[_payload_pb2.LogLines, _Mapping]] = ..., batches: _Optional[_Union[LogLinesBatch, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/app/app_logs_payload_pb2_grpc.py b/gen/python/flyteidl2/app/app_logs_payload_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/app/app_logs_payload_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/app/app_logs_service_pb2.py b/gen/python/flyteidl2/app/app_logs_service_pb2.py new file mode 100644 index 0000000000..e9f41d99bb --- /dev/null +++ b/gen/python/flyteidl2/app/app_logs_service_pb2.py @@ -0,0 +1,29 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/app/app_logs_service.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.app import app_logs_payload_pb2 as flyteidl2_dot_app_dot_app__logs__payload__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n$flyteidl2/app/app_logs_service.proto\x12\rflyteidl2.app\x1a$flyteidl2/app/app_logs_payload.proto2d\n\x0e\x41ppLogsService\x12R\n\x08TailLogs\x12\x1e.flyteidl2.app.TailLogsRequest\x1a\x1f.flyteidl2.app.TailLogsResponse\"\x03\x90\x02\x01\x30\x01\x42\xb2\x01\n\x11\x63om.flyteidl2.appB\x13\x41ppLogsServiceProtoH\x02P\x01Z1github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app\xa2\x02\x03\x46\x41X\xaa\x02\rFlyteidl2.App\xca\x02\rFlyteidl2\\App\xe2\x02\x19\x46lyteidl2\\App\\GPBMetadata\xea\x02\x0e\x46lyteidl2::Appb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.app.app_logs_service_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\021com.flyteidl2.appB\023AppLogsServiceProtoH\002P\001Z1github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app\242\002\003FAX\252\002\rFlyteidl2.App\312\002\rFlyteidl2\\App\342\002\031Flyteidl2\\App\\GPBMetadata\352\002\016Flyteidl2::App' + _APPLOGSSERVICE.methods_by_name['TailLogs']._options = None + _APPLOGSSERVICE.methods_by_name['TailLogs']._serialized_options = b'\220\002\001' + _globals['_APPLOGSSERVICE']._serialized_start=93 + _globals['_APPLOGSSERVICE']._serialized_end=193 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/app/app_logs_service_pb2.pyi b/gen/python/flyteidl2/app/app_logs_service_pb2.pyi new file mode 100644 index 0000000000..8774ece462 --- /dev/null +++ b/gen/python/flyteidl2/app/app_logs_service_pb2.pyi @@ -0,0 +1,5 @@ +from flyteidl2.app import app_logs_payload_pb2 as _app_logs_payload_pb2 +from google.protobuf import descriptor as _descriptor +from typing import ClassVar as _ClassVar + +DESCRIPTOR: _descriptor.FileDescriptor diff --git a/gen/python/flyteidl2/app/app_logs_service_pb2_grpc.py b/gen/python/flyteidl2/app/app_logs_service_pb2_grpc.py new file mode 100644 index 0000000000..339b95cc9a --- /dev/null +++ b/gen/python/flyteidl2/app/app_logs_service_pb2_grpc.py @@ -0,0 +1,66 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from flyteidl2.app import app_logs_payload_pb2 as flyteidl2_dot_app_dot_app__logs__payload__pb2 + + +class AppLogsServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.TailLogs = channel.unary_stream( + '/flyteidl2.app.AppLogsService/TailLogs', + request_serializer=flyteidl2_dot_app_dot_app__logs__payload__pb2.TailLogsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_app_dot_app__logs__payload__pb2.TailLogsResponse.FromString, + ) + + +class AppLogsServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def TailLogs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_AppLogsServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'TailLogs': grpc.unary_stream_rpc_method_handler( + servicer.TailLogs, + request_deserializer=flyteidl2_dot_app_dot_app__logs__payload__pb2.TailLogsRequest.FromString, + response_serializer=flyteidl2_dot_app_dot_app__logs__payload__pb2.TailLogsResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.app.AppLogsService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class AppLogsService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def TailLogs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream(request, target, '/flyteidl2.app.AppLogsService/TailLogs', + flyteidl2_dot_app_dot_app__logs__payload__pb2.TailLogsRequest.SerializeToString, + flyteidl2_dot_app_dot_app__logs__payload__pb2.TailLogsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/gen/python/flyteidl2/app/app_payload_pb2.py b/gen/python/flyteidl2/app/app_payload_pb2.py new file mode 100644 index 0000000000..a56c42b97d --- /dev/null +++ b/gen/python/flyteidl2/app/app_payload_pb2.py @@ -0,0 +1,88 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/app/app_payload.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.app import app_definition_pb2 as flyteidl2_dot_app_dot_app__definition__pb2 +from flyteidl2.common import identifier_pb2 as flyteidl2_dot_common_dot_identifier__pb2 +from flyteidl2.common import list_pb2 as flyteidl2_dot_common_dot_list__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1f\x66lyteidl2/app/app_payload.proto\x12\rflyteidl2.app\x1a\x1b\x62uf/validate/validate.proto\x1a\"flyteidl2/app/app_definition.proto\x1a!flyteidl2/common/identifier.proto\x1a\x1b\x66lyteidl2/common/list.proto\"=\n\rCreateRequest\x12,\n\x03\x61pp\x18\x01 \x01(\x0b\x32\x12.flyteidl2.app.AppB\x06\xbaH\x03\xc8\x01\x01R\x03\x61pp\"6\n\x0e\x43reateResponse\x12$\n\x03\x61pp\x18\x01 \x01(\x0b\x32\x12.flyteidl2.app.AppR\x03\x61pp\"\x89\x01\n\nGetRequest\x12\x32\n\x06\x61pp_id\x18\x01 \x01(\x0b\x32\x19.flyteidl2.app.IdentifierH\x00R\x05\x61ppId\x12\x32\n\x07ingress\x18\x02 \x01(\x0b\x32\x16.flyteidl2.app.IngressH\x00R\x07ingressB\x13\n\nidentifier\x12\x05\xbaH\x02\x08\x01\"3\n\x0bGetResponse\x12$\n\x03\x61pp\x18\x01 \x01(\x0b\x32\x12.flyteidl2.app.AppR\x03\x61pp\"^\n\rUpdateRequest\x12,\n\x03\x61pp\x18\x01 \x01(\x0b\x32\x12.flyteidl2.app.AppB\x06\xbaH\x03\xc8\x01\x01R\x03\x61pp\x12\x1f\n\x06reason\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x18\x64R\x06reason\"6\n\x0eUpdateResponse\x12$\n\x03\x61pp\x18\x01 \x01(\x0b\x32\x12.flyteidl2.app.AppR\x03\x61pp\"I\n\rDeleteRequest\x12\x38\n\x06\x61pp_id\x18\x01 \x01(\x0b\x32\x19.flyteidl2.app.IdentifierB\x06\xbaH\x03\xc8\x01\x01R\x05\x61ppId\"\x10\n\x0e\x44\x65leteResponse\"\xfe\x01\n\x0bListRequest\x12\x37\n\x07request\x18\x01 \x01(\x0b\x32\x1d.flyteidl2.common.ListRequestR\x07request\x12\x1b\n\x03org\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01H\x00R\x03org\x12\x44\n\ncluster_id\x18\x03 \x01(\x0b\x32#.flyteidl2.common.ClusterIdentifierH\x00R\tclusterId\x12?\n\x07project\x18\x04 \x01(\x0b\x32#.flyteidl2.common.ProjectIdentifierH\x00R\x07projectB\x12\n\tfilter_by\x12\x05\xbaH\x02\x08\x01\"L\n\x0cListResponse\x12&\n\x04\x61pps\x18\x01 \x03(\x0b\x32\x12.flyteidl2.app.AppR\x04\x61pps\x12\x14\n\x05token\x18\x02 \x01(\tR\x05token\"\xf7\x01\n\x0cWatchRequest\x12\x1b\n\x03org\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01H\x00R\x03org\x12\x44\n\ncluster_id\x18\x02 \x01(\x0b\x32#.flyteidl2.common.ClusterIdentifierH\x00R\tclusterId\x12?\n\x07project\x18\x03 \x01(\x0b\x32#.flyteidl2.common.ProjectIdentifierH\x00R\x07project\x12\x32\n\x06\x61pp_id\x18\x04 \x01(\x0b\x32\x19.flyteidl2.app.IdentifierH\x00R\x05\x61ppIdB\x0f\n\x06target\x12\x05\xbaH\x02\x08\x01\"3\n\x0b\x43reateEvent\x12$\n\x03\x61pp\x18\x01 \x01(\x0b\x32\x12.flyteidl2.app.AppR\x03\x61pp\"o\n\x0bUpdateEvent\x12\x33\n\x0bupdated_app\x18\x01 \x01(\x0b\x32\x12.flyteidl2.app.AppR\nupdatedApp\x12+\n\x07old_app\x18\x02 \x01(\x0b\x32\x12.flyteidl2.app.AppR\x06oldApp\"3\n\x0b\x44\x65leteEvent\x12$\n\x03\x61pp\x18\x01 \x01(\x0b\x32\x12.flyteidl2.app.AppR\x03\x61pp\"\xdb\x01\n\rWatchResponse\x12?\n\x0c\x63reate_event\x18\x01 \x01(\x0b\x32\x1a.flyteidl2.app.CreateEventH\x00R\x0b\x63reateEvent\x12?\n\x0cupdate_event\x18\x02 \x01(\x0b\x32\x1a.flyteidl2.app.UpdateEventH\x00R\x0bupdateEvent\x12?\n\x0c\x64\x65lete_event\x18\x03 \x01(\x0b\x32\x1a.flyteidl2.app.DeleteEventH\x00R\x0b\x64\x65leteEventB\x07\n\x05\x65vent\"C\n\x13UpdateStatusRequest\x12,\n\x03\x61pp\x18\x01 \x01(\x0b\x32\x12.flyteidl2.app.AppB\x06\xbaH\x03\xc8\x01\x01R\x03\x61pp\"<\n\x14UpdateStatusResponse\x12$\n\x03\x61pp\x18\x01 \x01(\x0b\x32\x12.flyteidl2.app.AppR\x03\x61pp\"K\n\x0cLeaseRequest\x12;\n\x02id\x18\x01 \x01(\x0b\x32#.flyteidl2.common.ClusterIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x02id\"7\n\rLeaseResponse\x12&\n\x04\x61pps\x18\x01 \x03(\x0b\x32\x12.flyteidl2.app.AppR\x04\x61ppsB\xae\x01\n\x11\x63om.flyteidl2.appB\x0f\x41ppPayloadProtoH\x02P\x01Z1github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app\xa2\x02\x03\x46\x41X\xaa\x02\rFlyteidl2.App\xca\x02\rFlyteidl2\\App\xe2\x02\x19\x46lyteidl2\\App\\GPBMetadata\xea\x02\x0e\x46lyteidl2::Appb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.app.app_payload_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\021com.flyteidl2.appB\017AppPayloadProtoH\002P\001Z1github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app\242\002\003FAX\252\002\rFlyteidl2.App\312\002\rFlyteidl2\\App\342\002\031Flyteidl2\\App\\GPBMetadata\352\002\016Flyteidl2::App' + _CREATEREQUEST.fields_by_name['app']._options = None + _CREATEREQUEST.fields_by_name['app']._serialized_options = b'\272H\003\310\001\001' + _GETREQUEST.oneofs_by_name['identifier']._options = None + _GETREQUEST.oneofs_by_name['identifier']._serialized_options = b'\272H\002\010\001' + _UPDATEREQUEST.fields_by_name['app']._options = None + _UPDATEREQUEST.fields_by_name['app']._serialized_options = b'\272H\003\310\001\001' + _UPDATEREQUEST.fields_by_name['reason']._options = None + _UPDATEREQUEST.fields_by_name['reason']._serialized_options = b'\272H\004r\002\030d' + _DELETEREQUEST.fields_by_name['app_id']._options = None + _DELETEREQUEST.fields_by_name['app_id']._serialized_options = b'\272H\003\310\001\001' + _LISTREQUEST.oneofs_by_name['filter_by']._options = None + _LISTREQUEST.oneofs_by_name['filter_by']._serialized_options = b'\272H\002\010\001' + _LISTREQUEST.fields_by_name['org']._options = None + _LISTREQUEST.fields_by_name['org']._serialized_options = b'\272H\004r\002\020\001' + _WATCHREQUEST.oneofs_by_name['target']._options = None + _WATCHREQUEST.oneofs_by_name['target']._serialized_options = b'\272H\002\010\001' + _WATCHREQUEST.fields_by_name['org']._options = None + _WATCHREQUEST.fields_by_name['org']._serialized_options = b'\272H\004r\002\020\001' + _UPDATESTATUSREQUEST.fields_by_name['app']._options = None + _UPDATESTATUSREQUEST.fields_by_name['app']._serialized_options = b'\272H\003\310\001\001' + _LEASEREQUEST.fields_by_name['id']._options = None + _LEASEREQUEST.fields_by_name['id']._serialized_options = b'\272H\003\310\001\001' + _globals['_CREATEREQUEST']._serialized_start=179 + _globals['_CREATEREQUEST']._serialized_end=240 + _globals['_CREATERESPONSE']._serialized_start=242 + _globals['_CREATERESPONSE']._serialized_end=296 + _globals['_GETREQUEST']._serialized_start=299 + _globals['_GETREQUEST']._serialized_end=436 + _globals['_GETRESPONSE']._serialized_start=438 + _globals['_GETRESPONSE']._serialized_end=489 + _globals['_UPDATEREQUEST']._serialized_start=491 + _globals['_UPDATEREQUEST']._serialized_end=585 + _globals['_UPDATERESPONSE']._serialized_start=587 + _globals['_UPDATERESPONSE']._serialized_end=641 + _globals['_DELETEREQUEST']._serialized_start=643 + _globals['_DELETEREQUEST']._serialized_end=716 + _globals['_DELETERESPONSE']._serialized_start=718 + _globals['_DELETERESPONSE']._serialized_end=734 + _globals['_LISTREQUEST']._serialized_start=737 + _globals['_LISTREQUEST']._serialized_end=991 + _globals['_LISTRESPONSE']._serialized_start=993 + _globals['_LISTRESPONSE']._serialized_end=1069 + _globals['_WATCHREQUEST']._serialized_start=1072 + _globals['_WATCHREQUEST']._serialized_end=1319 + _globals['_CREATEEVENT']._serialized_start=1321 + _globals['_CREATEEVENT']._serialized_end=1372 + _globals['_UPDATEEVENT']._serialized_start=1374 + _globals['_UPDATEEVENT']._serialized_end=1485 + _globals['_DELETEEVENT']._serialized_start=1487 + _globals['_DELETEEVENT']._serialized_end=1538 + _globals['_WATCHRESPONSE']._serialized_start=1541 + _globals['_WATCHRESPONSE']._serialized_end=1760 + _globals['_UPDATESTATUSREQUEST']._serialized_start=1762 + _globals['_UPDATESTATUSREQUEST']._serialized_end=1829 + _globals['_UPDATESTATUSRESPONSE']._serialized_start=1831 + _globals['_UPDATESTATUSRESPONSE']._serialized_end=1891 + _globals['_LEASEREQUEST']._serialized_start=1893 + _globals['_LEASEREQUEST']._serialized_end=1968 + _globals['_LEASERESPONSE']._serialized_start=1970 + _globals['_LEASERESPONSE']._serialized_end=2025 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/app/app_payload_pb2.pyi b/gen/python/flyteidl2/app/app_payload_pb2.pyi new file mode 100644 index 0000000000..0480b6ed6d --- /dev/null +++ b/gen/python/flyteidl2/app/app_payload_pb2.pyi @@ -0,0 +1,146 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.app import app_definition_pb2 as _app_definition_pb2 +from flyteidl2.common import identifier_pb2 as _identifier_pb2 +from flyteidl2.common import list_pb2 as _list_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class CreateRequest(_message.Message): + __slots__ = ["app"] + APP_FIELD_NUMBER: _ClassVar[int] + app: _app_definition_pb2.App + def __init__(self, app: _Optional[_Union[_app_definition_pb2.App, _Mapping]] = ...) -> None: ... + +class CreateResponse(_message.Message): + __slots__ = ["app"] + APP_FIELD_NUMBER: _ClassVar[int] + app: _app_definition_pb2.App + def __init__(self, app: _Optional[_Union[_app_definition_pb2.App, _Mapping]] = ...) -> None: ... + +class GetRequest(_message.Message): + __slots__ = ["app_id", "ingress"] + APP_ID_FIELD_NUMBER: _ClassVar[int] + INGRESS_FIELD_NUMBER: _ClassVar[int] + app_id: _app_definition_pb2.Identifier + ingress: _app_definition_pb2.Ingress + def __init__(self, app_id: _Optional[_Union[_app_definition_pb2.Identifier, _Mapping]] = ..., ingress: _Optional[_Union[_app_definition_pb2.Ingress, _Mapping]] = ...) -> None: ... + +class GetResponse(_message.Message): + __slots__ = ["app"] + APP_FIELD_NUMBER: _ClassVar[int] + app: _app_definition_pb2.App + def __init__(self, app: _Optional[_Union[_app_definition_pb2.App, _Mapping]] = ...) -> None: ... + +class UpdateRequest(_message.Message): + __slots__ = ["app", "reason"] + APP_FIELD_NUMBER: _ClassVar[int] + REASON_FIELD_NUMBER: _ClassVar[int] + app: _app_definition_pb2.App + reason: str + def __init__(self, app: _Optional[_Union[_app_definition_pb2.App, _Mapping]] = ..., reason: _Optional[str] = ...) -> None: ... + +class UpdateResponse(_message.Message): + __slots__ = ["app"] + APP_FIELD_NUMBER: _ClassVar[int] + app: _app_definition_pb2.App + def __init__(self, app: _Optional[_Union[_app_definition_pb2.App, _Mapping]] = ...) -> None: ... + +class DeleteRequest(_message.Message): + __slots__ = ["app_id"] + APP_ID_FIELD_NUMBER: _ClassVar[int] + app_id: _app_definition_pb2.Identifier + def __init__(self, app_id: _Optional[_Union[_app_definition_pb2.Identifier, _Mapping]] = ...) -> None: ... + +class DeleteResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class ListRequest(_message.Message): + __slots__ = ["request", "org", "cluster_id", "project"] + REQUEST_FIELD_NUMBER: _ClassVar[int] + ORG_FIELD_NUMBER: _ClassVar[int] + CLUSTER_ID_FIELD_NUMBER: _ClassVar[int] + PROJECT_FIELD_NUMBER: _ClassVar[int] + request: _list_pb2.ListRequest + org: str + cluster_id: _identifier_pb2.ClusterIdentifier + project: _identifier_pb2.ProjectIdentifier + def __init__(self, request: _Optional[_Union[_list_pb2.ListRequest, _Mapping]] = ..., org: _Optional[str] = ..., cluster_id: _Optional[_Union[_identifier_pb2.ClusterIdentifier, _Mapping]] = ..., project: _Optional[_Union[_identifier_pb2.ProjectIdentifier, _Mapping]] = ...) -> None: ... + +class ListResponse(_message.Message): + __slots__ = ["apps", "token"] + APPS_FIELD_NUMBER: _ClassVar[int] + TOKEN_FIELD_NUMBER: _ClassVar[int] + apps: _containers.RepeatedCompositeFieldContainer[_app_definition_pb2.App] + token: str + def __init__(self, apps: _Optional[_Iterable[_Union[_app_definition_pb2.App, _Mapping]]] = ..., token: _Optional[str] = ...) -> None: ... + +class WatchRequest(_message.Message): + __slots__ = ["org", "cluster_id", "project", "app_id"] + ORG_FIELD_NUMBER: _ClassVar[int] + CLUSTER_ID_FIELD_NUMBER: _ClassVar[int] + PROJECT_FIELD_NUMBER: _ClassVar[int] + APP_ID_FIELD_NUMBER: _ClassVar[int] + org: str + cluster_id: _identifier_pb2.ClusterIdentifier + project: _identifier_pb2.ProjectIdentifier + app_id: _app_definition_pb2.Identifier + def __init__(self, org: _Optional[str] = ..., cluster_id: _Optional[_Union[_identifier_pb2.ClusterIdentifier, _Mapping]] = ..., project: _Optional[_Union[_identifier_pb2.ProjectIdentifier, _Mapping]] = ..., app_id: _Optional[_Union[_app_definition_pb2.Identifier, _Mapping]] = ...) -> None: ... + +class CreateEvent(_message.Message): + __slots__ = ["app"] + APP_FIELD_NUMBER: _ClassVar[int] + app: _app_definition_pb2.App + def __init__(self, app: _Optional[_Union[_app_definition_pb2.App, _Mapping]] = ...) -> None: ... + +class UpdateEvent(_message.Message): + __slots__ = ["updated_app", "old_app"] + UPDATED_APP_FIELD_NUMBER: _ClassVar[int] + OLD_APP_FIELD_NUMBER: _ClassVar[int] + updated_app: _app_definition_pb2.App + old_app: _app_definition_pb2.App + def __init__(self, updated_app: _Optional[_Union[_app_definition_pb2.App, _Mapping]] = ..., old_app: _Optional[_Union[_app_definition_pb2.App, _Mapping]] = ...) -> None: ... + +class DeleteEvent(_message.Message): + __slots__ = ["app"] + APP_FIELD_NUMBER: _ClassVar[int] + app: _app_definition_pb2.App + def __init__(self, app: _Optional[_Union[_app_definition_pb2.App, _Mapping]] = ...) -> None: ... + +class WatchResponse(_message.Message): + __slots__ = ["create_event", "update_event", "delete_event"] + CREATE_EVENT_FIELD_NUMBER: _ClassVar[int] + UPDATE_EVENT_FIELD_NUMBER: _ClassVar[int] + DELETE_EVENT_FIELD_NUMBER: _ClassVar[int] + create_event: CreateEvent + update_event: UpdateEvent + delete_event: DeleteEvent + def __init__(self, create_event: _Optional[_Union[CreateEvent, _Mapping]] = ..., update_event: _Optional[_Union[UpdateEvent, _Mapping]] = ..., delete_event: _Optional[_Union[DeleteEvent, _Mapping]] = ...) -> None: ... + +class UpdateStatusRequest(_message.Message): + __slots__ = ["app"] + APP_FIELD_NUMBER: _ClassVar[int] + app: _app_definition_pb2.App + def __init__(self, app: _Optional[_Union[_app_definition_pb2.App, _Mapping]] = ...) -> None: ... + +class UpdateStatusResponse(_message.Message): + __slots__ = ["app"] + APP_FIELD_NUMBER: _ClassVar[int] + app: _app_definition_pb2.App + def __init__(self, app: _Optional[_Union[_app_definition_pb2.App, _Mapping]] = ...) -> None: ... + +class LeaseRequest(_message.Message): + __slots__ = ["id"] + ID_FIELD_NUMBER: _ClassVar[int] + id: _identifier_pb2.ClusterIdentifier + def __init__(self, id: _Optional[_Union[_identifier_pb2.ClusterIdentifier, _Mapping]] = ...) -> None: ... + +class LeaseResponse(_message.Message): + __slots__ = ["apps"] + APPS_FIELD_NUMBER: _ClassVar[int] + apps: _containers.RepeatedCompositeFieldContainer[_app_definition_pb2.App] + def __init__(self, apps: _Optional[_Iterable[_Union[_app_definition_pb2.App, _Mapping]]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/app/app_payload_pb2_grpc.py b/gen/python/flyteidl2/app/app_payload_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/app/app_payload_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/app/app_service_pb2.py b/gen/python/flyteidl2/app/app_service_pb2.py new file mode 100644 index 0000000000..f5fc958dfc --- /dev/null +++ b/gen/python/flyteidl2/app/app_service_pb2.py @@ -0,0 +1,33 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/app/app_service.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.app import app_payload_pb2 as flyteidl2_dot_app_dot_app__payload__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1f\x66lyteidl2/app/app_service.proto\x12\rflyteidl2.app\x1a\x1f\x66lyteidl2/app/app_payload.proto2\xde\x04\n\nAppService\x12G\n\x06\x43reate\x12\x1c.flyteidl2.app.CreateRequest\x1a\x1d.flyteidl2.app.CreateResponse\"\x00\x12\x41\n\x03Get\x12\x19.flyteidl2.app.GetRequest\x1a\x1a.flyteidl2.app.GetResponse\"\x03\x90\x02\x01\x12G\n\x06Update\x12\x1c.flyteidl2.app.UpdateRequest\x1a\x1d.flyteidl2.app.UpdateResponse\"\x00\x12Y\n\x0cUpdateStatus\x12\".flyteidl2.app.UpdateStatusRequest\x1a#.flyteidl2.app.UpdateStatusResponse\"\x00\x12G\n\x06\x44\x65lete\x12\x1c.flyteidl2.app.DeleteRequest\x1a\x1d.flyteidl2.app.DeleteResponse\"\x00\x12\x44\n\x04List\x12\x1a.flyteidl2.app.ListRequest\x1a\x1b.flyteidl2.app.ListResponse\"\x03\x90\x02\x01\x12I\n\x05Watch\x12\x1b.flyteidl2.app.WatchRequest\x1a\x1c.flyteidl2.app.WatchResponse\"\x03\x90\x02\x01\x30\x01\x12\x46\n\x05Lease\x12\x1b.flyteidl2.app.LeaseRequest\x1a\x1c.flyteidl2.app.LeaseResponse\"\x00\x30\x01\x42\xae\x01\n\x11\x63om.flyteidl2.appB\x0f\x41ppServiceProtoH\x02P\x01Z1github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app\xa2\x02\x03\x46\x41X\xaa\x02\rFlyteidl2.App\xca\x02\rFlyteidl2\\App\xe2\x02\x19\x46lyteidl2\\App\\GPBMetadata\xea\x02\x0e\x46lyteidl2::Appb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.app.app_service_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\021com.flyteidl2.appB\017AppServiceProtoH\002P\001Z1github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app\242\002\003FAX\252\002\rFlyteidl2.App\312\002\rFlyteidl2\\App\342\002\031Flyteidl2\\App\\GPBMetadata\352\002\016Flyteidl2::App' + _APPSERVICE.methods_by_name['Get']._options = None + _APPSERVICE.methods_by_name['Get']._serialized_options = b'\220\002\001' + _APPSERVICE.methods_by_name['List']._options = None + _APPSERVICE.methods_by_name['List']._serialized_options = b'\220\002\001' + _APPSERVICE.methods_by_name['Watch']._options = None + _APPSERVICE.methods_by_name['Watch']._serialized_options = b'\220\002\001' + _globals['_APPSERVICE']._serialized_start=84 + _globals['_APPSERVICE']._serialized_end=690 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/app/app_service_pb2.pyi b/gen/python/flyteidl2/app/app_service_pb2.pyi new file mode 100644 index 0000000000..efaf3a61eb --- /dev/null +++ b/gen/python/flyteidl2/app/app_service_pb2.pyi @@ -0,0 +1,5 @@ +from flyteidl2.app import app_payload_pb2 as _app_payload_pb2 +from google.protobuf import descriptor as _descriptor +from typing import ClassVar as _ClassVar + +DESCRIPTOR: _descriptor.FileDescriptor diff --git a/gen/python/flyteidl2/app/app_service_pb2_grpc.py b/gen/python/flyteidl2/app/app_service_pb2_grpc.py new file mode 100644 index 0000000000..dde498b0f4 --- /dev/null +++ b/gen/python/flyteidl2/app/app_service_pb2_grpc.py @@ -0,0 +1,308 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from flyteidl2.app import app_payload_pb2 as flyteidl2_dot_app_dot_app__payload__pb2 + + +class AppServiceStub(object): + """AppService defines the service for managing apps. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.Create = channel.unary_unary( + '/flyteidl2.app.AppService/Create', + request_serializer=flyteidl2_dot_app_dot_app__payload__pb2.CreateRequest.SerializeToString, + response_deserializer=flyteidl2_dot_app_dot_app__payload__pb2.CreateResponse.FromString, + ) + self.Get = channel.unary_unary( + '/flyteidl2.app.AppService/Get', + request_serializer=flyteidl2_dot_app_dot_app__payload__pb2.GetRequest.SerializeToString, + response_deserializer=flyteidl2_dot_app_dot_app__payload__pb2.GetResponse.FromString, + ) + self.Update = channel.unary_unary( + '/flyteidl2.app.AppService/Update', + request_serializer=flyteidl2_dot_app_dot_app__payload__pb2.UpdateRequest.SerializeToString, + response_deserializer=flyteidl2_dot_app_dot_app__payload__pb2.UpdateResponse.FromString, + ) + self.UpdateStatus = channel.unary_unary( + '/flyteidl2.app.AppService/UpdateStatus', + request_serializer=flyteidl2_dot_app_dot_app__payload__pb2.UpdateStatusRequest.SerializeToString, + response_deserializer=flyteidl2_dot_app_dot_app__payload__pb2.UpdateStatusResponse.FromString, + ) + self.Delete = channel.unary_unary( + '/flyteidl2.app.AppService/Delete', + request_serializer=flyteidl2_dot_app_dot_app__payload__pb2.DeleteRequest.SerializeToString, + response_deserializer=flyteidl2_dot_app_dot_app__payload__pb2.DeleteResponse.FromString, + ) + self.List = channel.unary_unary( + '/flyteidl2.app.AppService/List', + request_serializer=flyteidl2_dot_app_dot_app__payload__pb2.ListRequest.SerializeToString, + response_deserializer=flyteidl2_dot_app_dot_app__payload__pb2.ListResponse.FromString, + ) + self.Watch = channel.unary_stream( + '/flyteidl2.app.AppService/Watch', + request_serializer=flyteidl2_dot_app_dot_app__payload__pb2.WatchRequest.SerializeToString, + response_deserializer=flyteidl2_dot_app_dot_app__payload__pb2.WatchResponse.FromString, + ) + self.Lease = channel.unary_stream( + '/flyteidl2.app.AppService/Lease', + request_serializer=flyteidl2_dot_app_dot_app__payload__pb2.LeaseRequest.SerializeToString, + response_deserializer=flyteidl2_dot_app_dot_app__payload__pb2.LeaseResponse.FromString, + ) + + +class AppServiceServicer(object): + """AppService defines the service for managing apps. + """ + + def Create(self, request, context): + """Create creates a new app. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Get(self, request, context): + """Get retrieves an app by its identifier. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Update(self, request, context): + """Update updates an existing app. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateStatus(self, request, context): + """UpdateStatus updates the status of an existing app. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Delete(self, request, context): + """Delete deletes an app by its identifier. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def List(self, request, context): + """List lists all apps with optional filtering. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Watch(self, request, context): + """Watch watches for app events. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Lease(self, request, context): + """Lease leases apps. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_AppServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'Create': grpc.unary_unary_rpc_method_handler( + servicer.Create, + request_deserializer=flyteidl2_dot_app_dot_app__payload__pb2.CreateRequest.FromString, + response_serializer=flyteidl2_dot_app_dot_app__payload__pb2.CreateResponse.SerializeToString, + ), + 'Get': grpc.unary_unary_rpc_method_handler( + servicer.Get, + request_deserializer=flyteidl2_dot_app_dot_app__payload__pb2.GetRequest.FromString, + response_serializer=flyteidl2_dot_app_dot_app__payload__pb2.GetResponse.SerializeToString, + ), + 'Update': grpc.unary_unary_rpc_method_handler( + servicer.Update, + request_deserializer=flyteidl2_dot_app_dot_app__payload__pb2.UpdateRequest.FromString, + response_serializer=flyteidl2_dot_app_dot_app__payload__pb2.UpdateResponse.SerializeToString, + ), + 'UpdateStatus': grpc.unary_unary_rpc_method_handler( + servicer.UpdateStatus, + request_deserializer=flyteidl2_dot_app_dot_app__payload__pb2.UpdateStatusRequest.FromString, + response_serializer=flyteidl2_dot_app_dot_app__payload__pb2.UpdateStatusResponse.SerializeToString, + ), + 'Delete': grpc.unary_unary_rpc_method_handler( + servicer.Delete, + request_deserializer=flyteidl2_dot_app_dot_app__payload__pb2.DeleteRequest.FromString, + response_serializer=flyteidl2_dot_app_dot_app__payload__pb2.DeleteResponse.SerializeToString, + ), + 'List': grpc.unary_unary_rpc_method_handler( + servicer.List, + request_deserializer=flyteidl2_dot_app_dot_app__payload__pb2.ListRequest.FromString, + response_serializer=flyteidl2_dot_app_dot_app__payload__pb2.ListResponse.SerializeToString, + ), + 'Watch': grpc.unary_stream_rpc_method_handler( + servicer.Watch, + request_deserializer=flyteidl2_dot_app_dot_app__payload__pb2.WatchRequest.FromString, + response_serializer=flyteidl2_dot_app_dot_app__payload__pb2.WatchResponse.SerializeToString, + ), + 'Lease': grpc.unary_stream_rpc_method_handler( + servicer.Lease, + request_deserializer=flyteidl2_dot_app_dot_app__payload__pb2.LeaseRequest.FromString, + response_serializer=flyteidl2_dot_app_dot_app__payload__pb2.LeaseResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.app.AppService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class AppService(object): + """AppService defines the service for managing apps. + """ + + @staticmethod + def Create(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.app.AppService/Create', + flyteidl2_dot_app_dot_app__payload__pb2.CreateRequest.SerializeToString, + flyteidl2_dot_app_dot_app__payload__pb2.CreateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Get(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.app.AppService/Get', + flyteidl2_dot_app_dot_app__payload__pb2.GetRequest.SerializeToString, + flyteidl2_dot_app_dot_app__payload__pb2.GetResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Update(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.app.AppService/Update', + flyteidl2_dot_app_dot_app__payload__pb2.UpdateRequest.SerializeToString, + flyteidl2_dot_app_dot_app__payload__pb2.UpdateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def UpdateStatus(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.app.AppService/UpdateStatus', + flyteidl2_dot_app_dot_app__payload__pb2.UpdateStatusRequest.SerializeToString, + flyteidl2_dot_app_dot_app__payload__pb2.UpdateStatusResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Delete(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.app.AppService/Delete', + flyteidl2_dot_app_dot_app__payload__pb2.DeleteRequest.SerializeToString, + flyteidl2_dot_app_dot_app__payload__pb2.DeleteResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def List(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.app.AppService/List', + flyteidl2_dot_app_dot_app__payload__pb2.ListRequest.SerializeToString, + flyteidl2_dot_app_dot_app__payload__pb2.ListResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Watch(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream(request, target, '/flyteidl2.app.AppService/Watch', + flyteidl2_dot_app_dot_app__payload__pb2.WatchRequest.SerializeToString, + flyteidl2_dot_app_dot_app__payload__pb2.WatchResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Lease(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream(request, target, '/flyteidl2.app.AppService/Lease', + flyteidl2_dot_app_dot_app__payload__pb2.LeaseRequest.SerializeToString, + flyteidl2_dot_app_dot_app__payload__pb2.LeaseResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/gen/python/flyteidl2/app/replica_definition_pb2.py b/gen/python/flyteidl2/app/replica_definition_pb2.py new file mode 100644 index 0000000000..2eae844f61 --- /dev/null +++ b/gen/python/flyteidl2/app/replica_definition_pb2.py @@ -0,0 +1,44 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/app/replica_definition.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.app import app_definition_pb2 as flyteidl2_dot_app_dot_app__definition__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n&flyteidl2/app/replica_definition.proto\x12\rflyteidl2.app\x1a\x1b\x62uf/validate/validate.proto\x1a\"flyteidl2/app/app_definition.proto\"j\n\x11ReplicaIdentifier\x12\x38\n\x06\x61pp_id\x18\x01 \x01(\x0b\x32\x19.flyteidl2.app.IdentifierB\x06\xbaH\x03\xc8\x01\x01R\x05\x61ppId\x12\x1b\n\x04name\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x04name\"c\n\x0bReplicaMeta\x12\x38\n\x02id\x18\x01 \x01(\x0b\x32 .flyteidl2.app.ReplicaIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x02id\x12\x1a\n\x08revision\x18\x02 \x01(\x04R\x08revision\";\n\x0bReplicaList\x12,\n\x05items\x18\x01 \x03(\x0b\x32\x16.flyteidl2.app.ReplicaR\x05items\"\x7f\n\x07Replica\x12>\n\x08metadata\x18\x01 \x01(\x0b\x32\x1a.flyteidl2.app.ReplicaMetaB\x06\xbaH\x03\xc8\x01\x01R\x08metadata\x12\x34\n\x06status\x18\x02 \x01(\x0b\x32\x1c.flyteidl2.app.ReplicaStatusR\x06status\"T\n\rReplicaStatus\x12+\n\x11\x64\x65ployment_status\x18\x01 \x01(\tR\x10\x64\x65ploymentStatus\x12\x16\n\x06reason\x18\x02 \x01(\tR\x06reasonB\xb5\x01\n\x11\x63om.flyteidl2.appB\x16ReplicaDefinitionProtoH\x02P\x01Z1github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app\xa2\x02\x03\x46\x41X\xaa\x02\rFlyteidl2.App\xca\x02\rFlyteidl2\\App\xe2\x02\x19\x46lyteidl2\\App\\GPBMetadata\xea\x02\x0e\x46lyteidl2::Appb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.app.replica_definition_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\021com.flyteidl2.appB\026ReplicaDefinitionProtoH\002P\001Z1github.com/flyteorg/flyte/v2/gen/go/flyteidl2/app\242\002\003FAX\252\002\rFlyteidl2.App\312\002\rFlyteidl2\\App\342\002\031Flyteidl2\\App\\GPBMetadata\352\002\016Flyteidl2::App' + _REPLICAIDENTIFIER.fields_by_name['app_id']._options = None + _REPLICAIDENTIFIER.fields_by_name['app_id']._serialized_options = b'\272H\003\310\001\001' + _REPLICAIDENTIFIER.fields_by_name['name']._options = None + _REPLICAIDENTIFIER.fields_by_name['name']._serialized_options = b'\272H\004r\002\020\001' + _REPLICAMETA.fields_by_name['id']._options = None + _REPLICAMETA.fields_by_name['id']._serialized_options = b'\272H\003\310\001\001' + _REPLICA.fields_by_name['metadata']._options = None + _REPLICA.fields_by_name['metadata']._serialized_options = b'\272H\003\310\001\001' + _globals['_REPLICAIDENTIFIER']._serialized_start=122 + _globals['_REPLICAIDENTIFIER']._serialized_end=228 + _globals['_REPLICAMETA']._serialized_start=230 + _globals['_REPLICAMETA']._serialized_end=329 + _globals['_REPLICALIST']._serialized_start=331 + _globals['_REPLICALIST']._serialized_end=390 + _globals['_REPLICA']._serialized_start=392 + _globals['_REPLICA']._serialized_end=519 + _globals['_REPLICASTATUS']._serialized_start=521 + _globals['_REPLICASTATUS']._serialized_end=605 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/app/replica_definition_pb2.pyi b/gen/python/flyteidl2/app/replica_definition_pb2.pyi new file mode 100644 index 0000000000..06ad80db72 --- /dev/null +++ b/gen/python/flyteidl2/app/replica_definition_pb2.pyi @@ -0,0 +1,46 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.app import app_definition_pb2 as _app_definition_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class ReplicaIdentifier(_message.Message): + __slots__ = ["app_id", "name"] + APP_ID_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + app_id: _app_definition_pb2.Identifier + name: str + def __init__(self, app_id: _Optional[_Union[_app_definition_pb2.Identifier, _Mapping]] = ..., name: _Optional[str] = ...) -> None: ... + +class ReplicaMeta(_message.Message): + __slots__ = ["id", "revision"] + ID_FIELD_NUMBER: _ClassVar[int] + REVISION_FIELD_NUMBER: _ClassVar[int] + id: ReplicaIdentifier + revision: int + def __init__(self, id: _Optional[_Union[ReplicaIdentifier, _Mapping]] = ..., revision: _Optional[int] = ...) -> None: ... + +class ReplicaList(_message.Message): + __slots__ = ["items"] + ITEMS_FIELD_NUMBER: _ClassVar[int] + items: _containers.RepeatedCompositeFieldContainer[Replica] + def __init__(self, items: _Optional[_Iterable[_Union[Replica, _Mapping]]] = ...) -> None: ... + +class Replica(_message.Message): + __slots__ = ["metadata", "status"] + METADATA_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + metadata: ReplicaMeta + status: ReplicaStatus + def __init__(self, metadata: _Optional[_Union[ReplicaMeta, _Mapping]] = ..., status: _Optional[_Union[ReplicaStatus, _Mapping]] = ...) -> None: ... + +class ReplicaStatus(_message.Message): + __slots__ = ["deployment_status", "reason"] + DEPLOYMENT_STATUS_FIELD_NUMBER: _ClassVar[int] + REASON_FIELD_NUMBER: _ClassVar[int] + deployment_status: str + reason: str + def __init__(self, deployment_status: _Optional[str] = ..., reason: _Optional[str] = ...) -> None: ... diff --git a/gen/python/flyteidl2/app/replica_definition_pb2_grpc.py b/gen/python/flyteidl2/app/replica_definition_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/app/replica_definition_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/auth/__init__.py b/gen/python/flyteidl2/auth/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/auth/auth_service_pb2.py b/gen/python/flyteidl2/auth/auth_service_pb2.py new file mode 100644 index 0000000000..7af299d208 --- /dev/null +++ b/gen/python/flyteidl2/auth/auth_service_pb2.py @@ -0,0 +1,38 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/auth/auth_service.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n!flyteidl2/auth/auth_service.proto\x12\x0e\x66lyteidl2.auth\"\x1a\n\x18GetOAuth2MetadataRequest\"\xa4\x04\n\x19GetOAuth2MetadataResponse\x12\x16\n\x06issuer\x18\x01 \x01(\tR\x06issuer\x12\x35\n\x16\x61uthorization_endpoint\x18\x02 \x01(\tR\x15\x61uthorizationEndpoint\x12%\n\x0etoken_endpoint\x18\x03 \x01(\tR\rtokenEndpoint\x12\x38\n\x18response_types_supported\x18\x04 \x03(\tR\x16responseTypesSupported\x12)\n\x10scopes_supported\x18\x05 \x03(\tR\x0fscopesSupported\x12P\n%token_endpoint_auth_methods_supported\x18\x06 \x03(\tR!tokenEndpointAuthMethodsSupported\x12\x19\n\x08jwks_uri\x18\x07 \x01(\tR\x07jwksUri\x12G\n code_challenge_methods_supported\x18\x08 \x03(\tR\x1d\x63odeChallengeMethodsSupported\x12\x32\n\x15grant_types_supported\x18\t \x03(\tR\x13grantTypesSupported\x12\x42\n\x1d\x64\x65vice_authorization_endpoint\x18\n \x01(\tR\x1b\x64\x65viceAuthorizationEndpoint\"\x1e\n\x1cGetPublicClientConfigRequest\"\x85\x02\n\x1dGetPublicClientConfigResponse\x12\x1b\n\tclient_id\x18\x01 \x01(\tR\x08\x63lientId\x12!\n\x0credirect_uri\x18\x02 \x01(\tR\x0bredirectUri\x12\x16\n\x06scopes\x18\x03 \x03(\tR\x06scopes\x12<\n\x1a\x61uthorization_metadata_key\x18\x04 \x01(\tR\x18\x61uthorizationMetadataKey\x12\x32\n\x15service_http_endpoint\x18\x05 \x01(\tR\x13serviceHttpEndpoint\x12\x1a\n\x08\x61udience\x18\x06 \x01(\tR\x08\x61udience2\xff\x01\n\x13\x41uthMetadataService\x12m\n\x11GetOAuth2Metadata\x12(.flyteidl2.auth.GetOAuth2MetadataRequest\x1a).flyteidl2.auth.GetOAuth2MetadataResponse\"\x03\x90\x02\x01\x12y\n\x15GetPublicClientConfig\x12,.flyteidl2.auth.GetPublicClientConfigRequest\x1a-.flyteidl2.auth.GetPublicClientConfigResponse\"\x03\x90\x02\x01\x42\xb5\x01\n\x12\x63om.flyteidl2.authB\x10\x41uthServiceProtoH\x02P\x01Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/auth\xa2\x02\x03\x46\x41X\xaa\x02\x0e\x46lyteidl2.Auth\xca\x02\x0e\x46lyteidl2\\Auth\xe2\x02\x1a\x46lyteidl2\\Auth\\GPBMetadata\xea\x02\x0f\x46lyteidl2::Authb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.auth.auth_service_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\022com.flyteidl2.authB\020AuthServiceProtoH\002P\001Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/auth\242\002\003FAX\252\002\016Flyteidl2.Auth\312\002\016Flyteidl2\\Auth\342\002\032Flyteidl2\\Auth\\GPBMetadata\352\002\017Flyteidl2::Auth' + _AUTHMETADATASERVICE.methods_by_name['GetOAuth2Metadata']._options = None + _AUTHMETADATASERVICE.methods_by_name['GetOAuth2Metadata']._serialized_options = b'\220\002\001' + _AUTHMETADATASERVICE.methods_by_name['GetPublicClientConfig']._options = None + _AUTHMETADATASERVICE.methods_by_name['GetPublicClientConfig']._serialized_options = b'\220\002\001' + _globals['_GETOAUTH2METADATAREQUEST']._serialized_start=53 + _globals['_GETOAUTH2METADATAREQUEST']._serialized_end=79 + _globals['_GETOAUTH2METADATARESPONSE']._serialized_start=82 + _globals['_GETOAUTH2METADATARESPONSE']._serialized_end=630 + _globals['_GETPUBLICCLIENTCONFIGREQUEST']._serialized_start=632 + _globals['_GETPUBLICCLIENTCONFIGREQUEST']._serialized_end=662 + _globals['_GETPUBLICCLIENTCONFIGRESPONSE']._serialized_start=665 + _globals['_GETPUBLICCLIENTCONFIGRESPONSE']._serialized_end=926 + _globals['_AUTHMETADATASERVICE']._serialized_start=929 + _globals['_AUTHMETADATASERVICE']._serialized_end=1184 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/auth/auth_service_pb2.pyi b/gen/python/flyteidl2/auth/auth_service_pb2.pyi new file mode 100644 index 0000000000..1f43620803 --- /dev/null +++ b/gen/python/flyteidl2/auth/auth_service_pb2.pyi @@ -0,0 +1,54 @@ +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Optional as _Optional + +DESCRIPTOR: _descriptor.FileDescriptor + +class GetOAuth2MetadataRequest(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class GetOAuth2MetadataResponse(_message.Message): + __slots__ = ["issuer", "authorization_endpoint", "token_endpoint", "response_types_supported", "scopes_supported", "token_endpoint_auth_methods_supported", "jwks_uri", "code_challenge_methods_supported", "grant_types_supported", "device_authorization_endpoint"] + ISSUER_FIELD_NUMBER: _ClassVar[int] + AUTHORIZATION_ENDPOINT_FIELD_NUMBER: _ClassVar[int] + TOKEN_ENDPOINT_FIELD_NUMBER: _ClassVar[int] + RESPONSE_TYPES_SUPPORTED_FIELD_NUMBER: _ClassVar[int] + SCOPES_SUPPORTED_FIELD_NUMBER: _ClassVar[int] + TOKEN_ENDPOINT_AUTH_METHODS_SUPPORTED_FIELD_NUMBER: _ClassVar[int] + JWKS_URI_FIELD_NUMBER: _ClassVar[int] + CODE_CHALLENGE_METHODS_SUPPORTED_FIELD_NUMBER: _ClassVar[int] + GRANT_TYPES_SUPPORTED_FIELD_NUMBER: _ClassVar[int] + DEVICE_AUTHORIZATION_ENDPOINT_FIELD_NUMBER: _ClassVar[int] + issuer: str + authorization_endpoint: str + token_endpoint: str + response_types_supported: _containers.RepeatedScalarFieldContainer[str] + scopes_supported: _containers.RepeatedScalarFieldContainer[str] + token_endpoint_auth_methods_supported: _containers.RepeatedScalarFieldContainer[str] + jwks_uri: str + code_challenge_methods_supported: _containers.RepeatedScalarFieldContainer[str] + grant_types_supported: _containers.RepeatedScalarFieldContainer[str] + device_authorization_endpoint: str + def __init__(self, issuer: _Optional[str] = ..., authorization_endpoint: _Optional[str] = ..., token_endpoint: _Optional[str] = ..., response_types_supported: _Optional[_Iterable[str]] = ..., scopes_supported: _Optional[_Iterable[str]] = ..., token_endpoint_auth_methods_supported: _Optional[_Iterable[str]] = ..., jwks_uri: _Optional[str] = ..., code_challenge_methods_supported: _Optional[_Iterable[str]] = ..., grant_types_supported: _Optional[_Iterable[str]] = ..., device_authorization_endpoint: _Optional[str] = ...) -> None: ... + +class GetPublicClientConfigRequest(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class GetPublicClientConfigResponse(_message.Message): + __slots__ = ["client_id", "redirect_uri", "scopes", "authorization_metadata_key", "service_http_endpoint", "audience"] + CLIENT_ID_FIELD_NUMBER: _ClassVar[int] + REDIRECT_URI_FIELD_NUMBER: _ClassVar[int] + SCOPES_FIELD_NUMBER: _ClassVar[int] + AUTHORIZATION_METADATA_KEY_FIELD_NUMBER: _ClassVar[int] + SERVICE_HTTP_ENDPOINT_FIELD_NUMBER: _ClassVar[int] + AUDIENCE_FIELD_NUMBER: _ClassVar[int] + client_id: str + redirect_uri: str + scopes: _containers.RepeatedScalarFieldContainer[str] + authorization_metadata_key: str + service_http_endpoint: str + audience: str + def __init__(self, client_id: _Optional[str] = ..., redirect_uri: _Optional[str] = ..., scopes: _Optional[_Iterable[str]] = ..., authorization_metadata_key: _Optional[str] = ..., service_http_endpoint: _Optional[str] = ..., audience: _Optional[str] = ...) -> None: ... diff --git a/gen/python/flyteidl2/auth/auth_service_pb2_grpc.py b/gen/python/flyteidl2/auth/auth_service_pb2_grpc.py new file mode 100644 index 0000000000..8e67a98aba --- /dev/null +++ b/gen/python/flyteidl2/auth/auth_service_pb2_grpc.py @@ -0,0 +1,111 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from flyteidl2.auth import auth_service_pb2 as flyteidl2_dot_auth_dot_auth__service__pb2 + + +class AuthMetadataServiceStub(object): + """The following defines an RPC service that is also served over HTTP via grpc-gateway. + Standard response codes for both are defined here: https://github.com/grpc-ecosystem/grpc-gateway/blob/master/runtime/errors.go + RPCs defined in this service must be anonymously accessible. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.GetOAuth2Metadata = channel.unary_unary( + '/flyteidl2.auth.AuthMetadataService/GetOAuth2Metadata', + request_serializer=flyteidl2_dot_auth_dot_auth__service__pb2.GetOAuth2MetadataRequest.SerializeToString, + response_deserializer=flyteidl2_dot_auth_dot_auth__service__pb2.GetOAuth2MetadataResponse.FromString, + ) + self.GetPublicClientConfig = channel.unary_unary( + '/flyteidl2.auth.AuthMetadataService/GetPublicClientConfig', + request_serializer=flyteidl2_dot_auth_dot_auth__service__pb2.GetPublicClientConfigRequest.SerializeToString, + response_deserializer=flyteidl2_dot_auth_dot_auth__service__pb2.GetPublicClientConfigResponse.FromString, + ) + + +class AuthMetadataServiceServicer(object): + """The following defines an RPC service that is also served over HTTP via grpc-gateway. + Standard response codes for both are defined here: https://github.com/grpc-ecosystem/grpc-gateway/blob/master/runtime/errors.go + RPCs defined in this service must be anonymously accessible. + """ + + def GetOAuth2Metadata(self, request, context): + """Anonymously accessible. Retrieves local or external oauth authorization server metadata. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetPublicClientConfig(self, request, context): + """Anonymously accessible. Retrieves the client information clients should use when initiating OAuth2 authorization + requests. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_AuthMetadataServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'GetOAuth2Metadata': grpc.unary_unary_rpc_method_handler( + servicer.GetOAuth2Metadata, + request_deserializer=flyteidl2_dot_auth_dot_auth__service__pb2.GetOAuth2MetadataRequest.FromString, + response_serializer=flyteidl2_dot_auth_dot_auth__service__pb2.GetOAuth2MetadataResponse.SerializeToString, + ), + 'GetPublicClientConfig': grpc.unary_unary_rpc_method_handler( + servicer.GetPublicClientConfig, + request_deserializer=flyteidl2_dot_auth_dot_auth__service__pb2.GetPublicClientConfigRequest.FromString, + response_serializer=flyteidl2_dot_auth_dot_auth__service__pb2.GetPublicClientConfigResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.auth.AuthMetadataService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class AuthMetadataService(object): + """The following defines an RPC service that is also served over HTTP via grpc-gateway. + Standard response codes for both are defined here: https://github.com/grpc-ecosystem/grpc-gateway/blob/master/runtime/errors.go + RPCs defined in this service must be anonymously accessible. + """ + + @staticmethod + def GetOAuth2Metadata(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.auth.AuthMetadataService/GetOAuth2Metadata', + flyteidl2_dot_auth_dot_auth__service__pb2.GetOAuth2MetadataRequest.SerializeToString, + flyteidl2_dot_auth_dot_auth__service__pb2.GetOAuth2MetadataResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetPublicClientConfig(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.auth.AuthMetadataService/GetPublicClientConfig', + flyteidl2_dot_auth_dot_auth__service__pb2.GetPublicClientConfigRequest.SerializeToString, + flyteidl2_dot_auth_dot_auth__service__pb2.GetPublicClientConfigResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/gen/python/flyteidl2/auth/identity_pb2.py b/gen/python/flyteidl2/auth/identity_pb2.py new file mode 100644 index 0000000000..33ae7d8b28 --- /dev/null +++ b/gen/python/flyteidl2/auth/identity_pb2.py @@ -0,0 +1,31 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/auth/identity.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1d\x66lyteidl2/auth/identity.proto\x12\x0e\x66lyteidl2.auth\x1a\x1cgoogle/protobuf/struct.proto\"\x11\n\x0fUserInfoRequest\"\xa5\x02\n\x10UserInfoResponse\x12\x18\n\x07subject\x18\x01 \x01(\tR\x07subject\x12\x12\n\x04name\x18\x02 \x01(\tR\x04name\x12-\n\x12preferred_username\x18\x03 \x01(\tR\x11preferredUsername\x12\x1d\n\ngiven_name\x18\x04 \x01(\tR\tgivenName\x12\x1f\n\x0b\x66\x61mily_name\x18\x05 \x01(\tR\nfamilyName\x12\x14\n\x05\x65mail\x18\x06 \x01(\tR\x05\x65mail\x12\x18\n\x07picture\x18\x07 \x01(\tR\x07picture\x12\x44\n\x11\x61\x64\x64itional_claims\x18\x08 \x01(\x0b\x32\x17.google.protobuf.StructR\x10\x61\x64\x64itionalClaims2b\n\x0fIdentityService\x12O\n\x08UserInfo\x12\x1f.flyteidl2.auth.UserInfoRequest\x1a .flyteidl2.auth.UserInfoResponse\"\x00\x42\xb2\x01\n\x12\x63om.flyteidl2.authB\rIdentityProtoH\x02P\x01Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/auth\xa2\x02\x03\x46\x41X\xaa\x02\x0e\x46lyteidl2.Auth\xca\x02\x0e\x46lyteidl2\\Auth\xe2\x02\x1a\x46lyteidl2\\Auth\\GPBMetadata\xea\x02\x0f\x46lyteidl2::Authb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.auth.identity_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\022com.flyteidl2.authB\rIdentityProtoH\002P\001Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/auth\242\002\003FAX\252\002\016Flyteidl2.Auth\312\002\016Flyteidl2\\Auth\342\002\032Flyteidl2\\Auth\\GPBMetadata\352\002\017Flyteidl2::Auth' + _globals['_USERINFOREQUEST']._serialized_start=79 + _globals['_USERINFOREQUEST']._serialized_end=96 + _globals['_USERINFORESPONSE']._serialized_start=99 + _globals['_USERINFORESPONSE']._serialized_end=392 + _globals['_IDENTITYSERVICE']._serialized_start=394 + _globals['_IDENTITYSERVICE']._serialized_end=492 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/auth/identity_pb2.pyi b/gen/python/flyteidl2/auth/identity_pb2.pyi new file mode 100644 index 0000000000..8b23e242e1 --- /dev/null +++ b/gen/python/flyteidl2/auth/identity_pb2.pyi @@ -0,0 +1,30 @@ +from google.protobuf import struct_pb2 as _struct_pb2 +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class UserInfoRequest(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class UserInfoResponse(_message.Message): + __slots__ = ["subject", "name", "preferred_username", "given_name", "family_name", "email", "picture", "additional_claims"] + SUBJECT_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + PREFERRED_USERNAME_FIELD_NUMBER: _ClassVar[int] + GIVEN_NAME_FIELD_NUMBER: _ClassVar[int] + FAMILY_NAME_FIELD_NUMBER: _ClassVar[int] + EMAIL_FIELD_NUMBER: _ClassVar[int] + PICTURE_FIELD_NUMBER: _ClassVar[int] + ADDITIONAL_CLAIMS_FIELD_NUMBER: _ClassVar[int] + subject: str + name: str + preferred_username: str + given_name: str + family_name: str + email: str + picture: str + additional_claims: _struct_pb2.Struct + def __init__(self, subject: _Optional[str] = ..., name: _Optional[str] = ..., preferred_username: _Optional[str] = ..., given_name: _Optional[str] = ..., family_name: _Optional[str] = ..., email: _Optional[str] = ..., picture: _Optional[str] = ..., additional_claims: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/auth/identity_pb2_grpc.py b/gen/python/flyteidl2/auth/identity_pb2_grpc.py new file mode 100644 index 0000000000..0d665bb9f9 --- /dev/null +++ b/gen/python/flyteidl2/auth/identity_pb2_grpc.py @@ -0,0 +1,70 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from flyteidl2.auth import identity_pb2 as flyteidl2_dot_auth_dot_identity__pb2 + + +class IdentityServiceStub(object): + """IdentityService defines an RPC Service that interacts with user/app identities. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.UserInfo = channel.unary_unary( + '/flyteidl2.auth.IdentityService/UserInfo', + request_serializer=flyteidl2_dot_auth_dot_identity__pb2.UserInfoRequest.SerializeToString, + response_deserializer=flyteidl2_dot_auth_dot_identity__pb2.UserInfoResponse.FromString, + ) + + +class IdentityServiceServicer(object): + """IdentityService defines an RPC Service that interacts with user/app identities. + """ + + def UserInfo(self, request, context): + """Retrieves user information about the currently logged in user. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_IdentityServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'UserInfo': grpc.unary_unary_rpc_method_handler( + servicer.UserInfo, + request_deserializer=flyteidl2_dot_auth_dot_identity__pb2.UserInfoRequest.FromString, + response_serializer=flyteidl2_dot_auth_dot_identity__pb2.UserInfoResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.auth.IdentityService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class IdentityService(object): + """IdentityService defines an RPC Service that interacts with user/app identities. + """ + + @staticmethod + def UserInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.auth.IdentityService/UserInfo', + flyteidl2_dot_auth_dot_identity__pb2.UserInfoRequest.SerializeToString, + flyteidl2_dot_auth_dot_identity__pb2.UserInfoResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/gen/python/flyteidl2/cacheservice/__init__.py b/gen/python/flyteidl2/cacheservice/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/cacheservice/cacheservice_pb2.py b/gen/python/flyteidl2/cacheservice/cacheservice_pb2.py new file mode 100644 index 0000000000..352d73053f --- /dev/null +++ b/gen/python/flyteidl2/cacheservice/cacheservice_pb2.py @@ -0,0 +1,64 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/cacheservice/cacheservice.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.core import identifier_pb2 as flyteidl2_dot_core_dot_identifier__pb2 +from flyteidl2.core import literals_pb2 as flyteidl2_dot_core_dot_literals__pb2 +from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n)flyteidl2/cacheservice/cacheservice.proto\x12\x16\x66lyteidl2.cacheservice\x1a\x1f\x66lyteidl2/core/identifier.proto\x1a\x1d\x66lyteidl2/core/literals.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\x97\x01\n\x0eKeyMapMetadata\x12J\n\x06values\x18\x01 \x03(\x0b\x32\x32.flyteidl2.cacheservice.KeyMapMetadata.ValuesEntryR\x06values\x1a\x39\n\x0bValuesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\x93\x02\n\x08Metadata\x12G\n\x11source_identifier\x18\x01 \x01(\x0b\x32\x1a.flyteidl2.core.IdentifierR\x10sourceIdentifier\x12?\n\x07key_map\x18\x02 \x01(\x0b\x32&.flyteidl2.cacheservice.KeyMapMetadataR\x06keyMap\x12\x39\n\ncreated_at\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\tcreatedAt\x12\x42\n\x0flast_updated_at\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\rlastUpdatedAt\"\xbe\x01\n\x0c\x43\x61\x63hedOutput\x12\x45\n\x0foutput_literals\x18\x01 \x01(\x0b\x32\x1a.flyteidl2.core.LiteralMapH\x00R\x0eoutputLiterals\x12\x1f\n\noutput_uri\x18\x02 \x01(\tH\x00R\toutputUri\x12<\n\x08metadata\x18\x03 \x01(\x0b\x32 .flyteidl2.cacheservice.MetadataR\x08metadataB\x08\n\x06output\"#\n\x0fGetCacheRequest\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\"P\n\x10GetCacheResponse\x12<\n\x06output\x18\x01 \x01(\x0b\x32$.flyteidl2.cacheservice.CachedOutputR\x06output\"\x84\x01\n\x0fOverwriteOutput\x12\x1c\n\toverwrite\x18\x01 \x01(\x08R\toverwrite\x12\x1f\n\x0b\x64\x65lete_blob\x18\x02 \x01(\x08R\ndeleteBlob\x12\x32\n\x07max_age\x18\x03 \x01(\x0b\x32\x19.google.protobuf.DurationR\x06maxAge\"\xa8\x01\n\x0fPutCacheRequest\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12<\n\x06output\x18\x02 \x01(\x0b\x32$.flyteidl2.cacheservice.CachedOutputR\x06output\x12\x45\n\toverwrite\x18\x03 \x01(\x0b\x32\'.flyteidl2.cacheservice.OverwriteOutputR\toverwrite\"\x12\n\x10PutCacheResponse\"&\n\x12\x44\x65leteCacheRequest\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\"\x15\n\x13\x44\x65leteCacheResponse\"\xbf\x01\n\x0bReservation\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x19\n\x08owner_id\x18\x02 \x01(\tR\x07ownerId\x12H\n\x12heartbeat_interval\x18\x03 \x01(\x0b\x32\x19.google.protobuf.DurationR\x11heartbeatInterval\x12\x39\n\nexpires_at\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\texpiresAt\"\x96\x01\n\x1dGetOrExtendReservationRequest\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x19\n\x08owner_id\x18\x02 \x01(\tR\x07ownerId\x12H\n\x12heartbeat_interval\x18\x03 \x01(\x0b\x32\x19.google.protobuf.DurationR\x11heartbeatInterval\"g\n\x1eGetOrExtendReservationResponse\x12\x45\n\x0breservation\x18\x01 \x01(\x0b\x32#.flyteidl2.cacheservice.ReservationR\x0breservation\"H\n\x19ReleaseReservationRequest\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x19\n\x08owner_id\x18\x02 \x01(\tR\x07ownerId\"\x1c\n\x1aReleaseReservationResponse2\xac\x04\n\x0c\x43\x61\x63heService\x12X\n\x03Get\x12\'.flyteidl2.cacheservice.GetCacheRequest\x1a(.flyteidl2.cacheservice.GetCacheResponse\x12X\n\x03Put\x12\'.flyteidl2.cacheservice.PutCacheRequest\x1a(.flyteidl2.cacheservice.PutCacheResponse\x12\x61\n\x06\x44\x65lete\x12*.flyteidl2.cacheservice.DeleteCacheRequest\x1a+.flyteidl2.cacheservice.DeleteCacheResponse\x12\x87\x01\n\x16GetOrExtendReservation\x12\x35.flyteidl2.cacheservice.GetOrExtendReservationRequest\x1a\x36.flyteidl2.cacheservice.GetOrExtendReservationResponse\x12{\n\x12ReleaseReservation\x12\x31.flyteidl2.cacheservice.ReleaseReservationRequest\x1a\x32.flyteidl2.cacheservice.ReleaseReservationResponseB\xe6\x01\n\x1a\x63om.flyteidl2.cacheserviceB\x11\x43\x61\x63heserviceProtoH\x02P\x01Z:github.com/flyteorg/flyte/v2/gen/go/flyteidl2/cacheservice\xa2\x02\x03\x46\x43X\xaa\x02\x16\x46lyteidl2.Cacheservice\xca\x02\x16\x46lyteidl2\\Cacheservice\xe2\x02\"Flyteidl2\\Cacheservice\\GPBMetadata\xea\x02\x17\x46lyteidl2::Cacheserviceb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.cacheservice.cacheservice_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\032com.flyteidl2.cacheserviceB\021CacheserviceProtoH\002P\001Z:github.com/flyteorg/flyte/v2/gen/go/flyteidl2/cacheservice\242\002\003FCX\252\002\026Flyteidl2.Cacheservice\312\002\026Flyteidl2\\Cacheservice\342\002\"Flyteidl2\\Cacheservice\\GPBMetadata\352\002\027Flyteidl2::Cacheservice' + _KEYMAPMETADATA_VALUESENTRY._options = None + _KEYMAPMETADATA_VALUESENTRY._serialized_options = b'8\001' + _globals['_KEYMAPMETADATA']._serialized_start=199 + _globals['_KEYMAPMETADATA']._serialized_end=350 + _globals['_KEYMAPMETADATA_VALUESENTRY']._serialized_start=293 + _globals['_KEYMAPMETADATA_VALUESENTRY']._serialized_end=350 + _globals['_METADATA']._serialized_start=353 + _globals['_METADATA']._serialized_end=628 + _globals['_CACHEDOUTPUT']._serialized_start=631 + _globals['_CACHEDOUTPUT']._serialized_end=821 + _globals['_GETCACHEREQUEST']._serialized_start=823 + _globals['_GETCACHEREQUEST']._serialized_end=858 + _globals['_GETCACHERESPONSE']._serialized_start=860 + _globals['_GETCACHERESPONSE']._serialized_end=940 + _globals['_OVERWRITEOUTPUT']._serialized_start=943 + _globals['_OVERWRITEOUTPUT']._serialized_end=1075 + _globals['_PUTCACHEREQUEST']._serialized_start=1078 + _globals['_PUTCACHEREQUEST']._serialized_end=1246 + _globals['_PUTCACHERESPONSE']._serialized_start=1248 + _globals['_PUTCACHERESPONSE']._serialized_end=1266 + _globals['_DELETECACHEREQUEST']._serialized_start=1268 + _globals['_DELETECACHEREQUEST']._serialized_end=1306 + _globals['_DELETECACHERESPONSE']._serialized_start=1308 + _globals['_DELETECACHERESPONSE']._serialized_end=1329 + _globals['_RESERVATION']._serialized_start=1332 + _globals['_RESERVATION']._serialized_end=1523 + _globals['_GETOREXTENDRESERVATIONREQUEST']._serialized_start=1526 + _globals['_GETOREXTENDRESERVATIONREQUEST']._serialized_end=1676 + _globals['_GETOREXTENDRESERVATIONRESPONSE']._serialized_start=1678 + _globals['_GETOREXTENDRESERVATIONRESPONSE']._serialized_end=1781 + _globals['_RELEASERESERVATIONREQUEST']._serialized_start=1783 + _globals['_RELEASERESERVATIONREQUEST']._serialized_end=1855 + _globals['_RELEASERESERVATIONRESPONSE']._serialized_start=1857 + _globals['_RELEASERESERVATIONRESPONSE']._serialized_end=1885 + _globals['_CACHESERVICE']._serialized_start=1888 + _globals['_CACHESERVICE']._serialized_end=2444 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/cacheservice/cacheservice_pb2.pyi b/gen/python/flyteidl2/cacheservice/cacheservice_pb2.pyi new file mode 100644 index 0000000000..7defbd0c33 --- /dev/null +++ b/gen/python/flyteidl2/cacheservice/cacheservice_pb2.pyi @@ -0,0 +1,131 @@ +from flyteidl2.core import identifier_pb2 as _identifier_pb2 +from flyteidl2.core import literals_pb2 as _literals_pb2 +from google.protobuf import duration_pb2 as _duration_pb2 +from google.protobuf import timestamp_pb2 as _timestamp_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class KeyMapMetadata(_message.Message): + __slots__ = ["values"] + class ValuesEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + VALUES_FIELD_NUMBER: _ClassVar[int] + values: _containers.ScalarMap[str, str] + def __init__(self, values: _Optional[_Mapping[str, str]] = ...) -> None: ... + +class Metadata(_message.Message): + __slots__ = ["source_identifier", "key_map", "created_at", "last_updated_at"] + SOURCE_IDENTIFIER_FIELD_NUMBER: _ClassVar[int] + KEY_MAP_FIELD_NUMBER: _ClassVar[int] + CREATED_AT_FIELD_NUMBER: _ClassVar[int] + LAST_UPDATED_AT_FIELD_NUMBER: _ClassVar[int] + source_identifier: _identifier_pb2.Identifier + key_map: KeyMapMetadata + created_at: _timestamp_pb2.Timestamp + last_updated_at: _timestamp_pb2.Timestamp + def __init__(self, source_identifier: _Optional[_Union[_identifier_pb2.Identifier, _Mapping]] = ..., key_map: _Optional[_Union[KeyMapMetadata, _Mapping]] = ..., created_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., last_updated_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ...) -> None: ... + +class CachedOutput(_message.Message): + __slots__ = ["output_literals", "output_uri", "metadata"] + OUTPUT_LITERALS_FIELD_NUMBER: _ClassVar[int] + OUTPUT_URI_FIELD_NUMBER: _ClassVar[int] + METADATA_FIELD_NUMBER: _ClassVar[int] + output_literals: _literals_pb2.LiteralMap + output_uri: str + metadata: Metadata + def __init__(self, output_literals: _Optional[_Union[_literals_pb2.LiteralMap, _Mapping]] = ..., output_uri: _Optional[str] = ..., metadata: _Optional[_Union[Metadata, _Mapping]] = ...) -> None: ... + +class GetCacheRequest(_message.Message): + __slots__ = ["key"] + KEY_FIELD_NUMBER: _ClassVar[int] + key: str + def __init__(self, key: _Optional[str] = ...) -> None: ... + +class GetCacheResponse(_message.Message): + __slots__ = ["output"] + OUTPUT_FIELD_NUMBER: _ClassVar[int] + output: CachedOutput + def __init__(self, output: _Optional[_Union[CachedOutput, _Mapping]] = ...) -> None: ... + +class OverwriteOutput(_message.Message): + __slots__ = ["overwrite", "delete_blob", "max_age"] + OVERWRITE_FIELD_NUMBER: _ClassVar[int] + DELETE_BLOB_FIELD_NUMBER: _ClassVar[int] + MAX_AGE_FIELD_NUMBER: _ClassVar[int] + overwrite: bool + delete_blob: bool + max_age: _duration_pb2.Duration + def __init__(self, overwrite: bool = ..., delete_blob: bool = ..., max_age: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ...) -> None: ... + +class PutCacheRequest(_message.Message): + __slots__ = ["key", "output", "overwrite"] + KEY_FIELD_NUMBER: _ClassVar[int] + OUTPUT_FIELD_NUMBER: _ClassVar[int] + OVERWRITE_FIELD_NUMBER: _ClassVar[int] + key: str + output: CachedOutput + overwrite: OverwriteOutput + def __init__(self, key: _Optional[str] = ..., output: _Optional[_Union[CachedOutput, _Mapping]] = ..., overwrite: _Optional[_Union[OverwriteOutput, _Mapping]] = ...) -> None: ... + +class PutCacheResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class DeleteCacheRequest(_message.Message): + __slots__ = ["key"] + KEY_FIELD_NUMBER: _ClassVar[int] + key: str + def __init__(self, key: _Optional[str] = ...) -> None: ... + +class DeleteCacheResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class Reservation(_message.Message): + __slots__ = ["key", "owner_id", "heartbeat_interval", "expires_at"] + KEY_FIELD_NUMBER: _ClassVar[int] + OWNER_ID_FIELD_NUMBER: _ClassVar[int] + HEARTBEAT_INTERVAL_FIELD_NUMBER: _ClassVar[int] + EXPIRES_AT_FIELD_NUMBER: _ClassVar[int] + key: str + owner_id: str + heartbeat_interval: _duration_pb2.Duration + expires_at: _timestamp_pb2.Timestamp + def __init__(self, key: _Optional[str] = ..., owner_id: _Optional[str] = ..., heartbeat_interval: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., expires_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ...) -> None: ... + +class GetOrExtendReservationRequest(_message.Message): + __slots__ = ["key", "owner_id", "heartbeat_interval"] + KEY_FIELD_NUMBER: _ClassVar[int] + OWNER_ID_FIELD_NUMBER: _ClassVar[int] + HEARTBEAT_INTERVAL_FIELD_NUMBER: _ClassVar[int] + key: str + owner_id: str + heartbeat_interval: _duration_pb2.Duration + def __init__(self, key: _Optional[str] = ..., owner_id: _Optional[str] = ..., heartbeat_interval: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ...) -> None: ... + +class GetOrExtendReservationResponse(_message.Message): + __slots__ = ["reservation"] + RESERVATION_FIELD_NUMBER: _ClassVar[int] + reservation: Reservation + def __init__(self, reservation: _Optional[_Union[Reservation, _Mapping]] = ...) -> None: ... + +class ReleaseReservationRequest(_message.Message): + __slots__ = ["key", "owner_id"] + KEY_FIELD_NUMBER: _ClassVar[int] + OWNER_ID_FIELD_NUMBER: _ClassVar[int] + key: str + owner_id: str + def __init__(self, key: _Optional[str] = ..., owner_id: _Optional[str] = ...) -> None: ... + +class ReleaseReservationResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... diff --git a/gen/python/flyteidl2/cacheservice/cacheservice_pb2_grpc.py b/gen/python/flyteidl2/cacheservice/cacheservice_pb2_grpc.py new file mode 100644 index 0000000000..bd3fb51607 --- /dev/null +++ b/gen/python/flyteidl2/cacheservice/cacheservice_pb2_grpc.py @@ -0,0 +1,209 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from flyteidl2.cacheservice import cacheservice_pb2 as flyteidl2_dot_cacheservice_dot_cacheservice__pb2 + + +class CacheServiceStub(object): + """ + CacheService defines operations for cache management including retrieval, storage, and deletion of cached task/workflow outputs. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.Get = channel.unary_unary( + '/flyteidl2.cacheservice.CacheService/Get', + request_serializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.GetCacheRequest.SerializeToString, + response_deserializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.GetCacheResponse.FromString, + ) + self.Put = channel.unary_unary( + '/flyteidl2.cacheservice.CacheService/Put', + request_serializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.PutCacheRequest.SerializeToString, + response_deserializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.PutCacheResponse.FromString, + ) + self.Delete = channel.unary_unary( + '/flyteidl2.cacheservice.CacheService/Delete', + request_serializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.DeleteCacheRequest.SerializeToString, + response_deserializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.DeleteCacheResponse.FromString, + ) + self.GetOrExtendReservation = channel.unary_unary( + '/flyteidl2.cacheservice.CacheService/GetOrExtendReservation', + request_serializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.GetOrExtendReservationRequest.SerializeToString, + response_deserializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.GetOrExtendReservationResponse.FromString, + ) + self.ReleaseReservation = channel.unary_unary( + '/flyteidl2.cacheservice.CacheService/ReleaseReservation', + request_serializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.ReleaseReservationRequest.SerializeToString, + response_deserializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.ReleaseReservationResponse.FromString, + ) + + +class CacheServiceServicer(object): + """ + CacheService defines operations for cache management including retrieval, storage, and deletion of cached task/workflow outputs. + """ + + def Get(self, request, context): + """Retrieves cached data by key. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Put(self, request, context): + """Stores or updates cached data by key. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Delete(self, request, context): + """Deletes cached data by key. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetOrExtendReservation(self, request, context): + """Get or extend a reservation for a cache key + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReleaseReservation(self, request, context): + """Release the reservation for a cache key + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_CacheServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'Get': grpc.unary_unary_rpc_method_handler( + servicer.Get, + request_deserializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.GetCacheRequest.FromString, + response_serializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.GetCacheResponse.SerializeToString, + ), + 'Put': grpc.unary_unary_rpc_method_handler( + servicer.Put, + request_deserializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.PutCacheRequest.FromString, + response_serializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.PutCacheResponse.SerializeToString, + ), + 'Delete': grpc.unary_unary_rpc_method_handler( + servicer.Delete, + request_deserializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.DeleteCacheRequest.FromString, + response_serializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.DeleteCacheResponse.SerializeToString, + ), + 'GetOrExtendReservation': grpc.unary_unary_rpc_method_handler( + servicer.GetOrExtendReservation, + request_deserializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.GetOrExtendReservationRequest.FromString, + response_serializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.GetOrExtendReservationResponse.SerializeToString, + ), + 'ReleaseReservation': grpc.unary_unary_rpc_method_handler( + servicer.ReleaseReservation, + request_deserializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.ReleaseReservationRequest.FromString, + response_serializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.ReleaseReservationResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.cacheservice.CacheService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class CacheService(object): + """ + CacheService defines operations for cache management including retrieval, storage, and deletion of cached task/workflow outputs. + """ + + @staticmethod + def Get(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.cacheservice.CacheService/Get', + flyteidl2_dot_cacheservice_dot_cacheservice__pb2.GetCacheRequest.SerializeToString, + flyteidl2_dot_cacheservice_dot_cacheservice__pb2.GetCacheResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Put(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.cacheservice.CacheService/Put', + flyteidl2_dot_cacheservice_dot_cacheservice__pb2.PutCacheRequest.SerializeToString, + flyteidl2_dot_cacheservice_dot_cacheservice__pb2.PutCacheResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Delete(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.cacheservice.CacheService/Delete', + flyteidl2_dot_cacheservice_dot_cacheservice__pb2.DeleteCacheRequest.SerializeToString, + flyteidl2_dot_cacheservice_dot_cacheservice__pb2.DeleteCacheResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetOrExtendReservation(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.cacheservice.CacheService/GetOrExtendReservation', + flyteidl2_dot_cacheservice_dot_cacheservice__pb2.GetOrExtendReservationRequest.SerializeToString, + flyteidl2_dot_cacheservice_dot_cacheservice__pb2.GetOrExtendReservationResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReleaseReservation(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.cacheservice.CacheService/ReleaseReservation', + flyteidl2_dot_cacheservice_dot_cacheservice__pb2.ReleaseReservationRequest.SerializeToString, + flyteidl2_dot_cacheservice_dot_cacheservice__pb2.ReleaseReservationResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/gen/python/flyteidl2/cacheservice/v2/__init__.py b/gen/python/flyteidl2/cacheservice/v2/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/cacheservice/v2/cacheservice_pb2.py b/gen/python/flyteidl2/cacheservice/v2/cacheservice_pb2.py new file mode 100644 index 0000000000..a6a602a362 --- /dev/null +++ b/gen/python/flyteidl2/cacheservice/v2/cacheservice_pb2.py @@ -0,0 +1,56 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/cacheservice/v2/cacheservice.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.cacheservice import cacheservice_pb2 as flyteidl2_dot_cacheservice_dot_cacheservice__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n,flyteidl2/cacheservice/v2/cacheservice.proto\x12\x19\x66lyteidl2.cacheservice.v2\x1a\x1b\x62uf/validate/validate.proto\x1a)flyteidl2/cacheservice/cacheservice.proto\"k\n\nIdentifier\x12\x19\n\x03org\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x03org\x12!\n\x07project\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x07project\x12\x1f\n\x06\x64omain\x18\x03 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x06\x64omain\"\xac\x01\n\x0fGetCacheRequest\x12J\n\x0c\x62\x61se_request\x18\x01 \x01(\x0b\x32\'.flyteidl2.cacheservice.GetCacheRequestR\x0b\x62\x61seRequest\x12M\n\nidentifier\x18\x02 \x01(\x0b\x32%.flyteidl2.cacheservice.v2.IdentifierB\x06\xbaH\x03\xc8\x01\x01R\nidentifier\"\xac\x01\n\x0fPutCacheRequest\x12J\n\x0c\x62\x61se_request\x18\x01 \x01(\x0b\x32\'.flyteidl2.cacheservice.PutCacheRequestR\x0b\x62\x61seRequest\x12M\n\nidentifier\x18\x02 \x01(\x0b\x32%.flyteidl2.cacheservice.v2.IdentifierB\x06\xbaH\x03\xc8\x01\x01R\nidentifier\"\xb2\x01\n\x12\x44\x65leteCacheRequest\x12M\n\x0c\x62\x61se_request\x18\x01 \x01(\x0b\x32*.flyteidl2.cacheservice.DeleteCacheRequestR\x0b\x62\x61seRequest\x12M\n\nidentifier\x18\x02 \x01(\x0b\x32%.flyteidl2.cacheservice.v2.IdentifierB\x06\xbaH\x03\xc8\x01\x01R\nidentifier\"\xc8\x01\n\x1dGetOrExtendReservationRequest\x12X\n\x0c\x62\x61se_request\x18\x01 \x01(\x0b\x32\x35.flyteidl2.cacheservice.GetOrExtendReservationRequestR\x0b\x62\x61seRequest\x12M\n\nidentifier\x18\x02 \x01(\x0b\x32%.flyteidl2.cacheservice.v2.IdentifierB\x06\xbaH\x03\xc8\x01\x01R\nidentifier\"\xc0\x01\n\x19ReleaseReservationRequest\x12T\n\x0c\x62\x61se_request\x18\x01 \x01(\x0b\x32\x31.flyteidl2.cacheservice.ReleaseReservationRequestR\x0b\x62\x61seRequest\x12M\n\nidentifier\x18\x02 \x01(\x0b\x32%.flyteidl2.cacheservice.v2.IdentifierB\x06\xbaH\x03\xc8\x01\x01R\nidentifier2\xbb\x04\n\x0c\x43\x61\x63heService\x12[\n\x03Get\x12*.flyteidl2.cacheservice.v2.GetCacheRequest\x1a(.flyteidl2.cacheservice.GetCacheResponse\x12[\n\x03Put\x12*.flyteidl2.cacheservice.v2.PutCacheRequest\x1a(.flyteidl2.cacheservice.PutCacheResponse\x12\x64\n\x06\x44\x65lete\x12-.flyteidl2.cacheservice.v2.DeleteCacheRequest\x1a+.flyteidl2.cacheservice.DeleteCacheResponse\x12\x8a\x01\n\x16GetOrExtendReservation\x12\x38.flyteidl2.cacheservice.v2.GetOrExtendReservationRequest\x1a\x36.flyteidl2.cacheservice.GetOrExtendReservationResponse\x12~\n\x12ReleaseReservation\x12\x34.flyteidl2.cacheservice.v2.ReleaseReservationRequest\x1a\x32.flyteidl2.cacheservice.ReleaseReservationResponseB\xf9\x01\n\x1d\x63om.flyteidl2.cacheservice.v2B\x11\x43\x61\x63heserviceProtoH\x02P\x01Z=github.com/flyteorg/flyte/v2/gen/go/flyteidl2/cacheservice/v2\xa2\x02\x03\x46\x43X\xaa\x02\x19\x46lyteidl2.Cacheservice.V2\xca\x02\x19\x46lyteidl2\\Cacheservice\\V2\xe2\x02%Flyteidl2\\Cacheservice\\V2\\GPBMetadata\xea\x02\x1b\x46lyteidl2::Cacheservice::V2b\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.cacheservice.v2.cacheservice_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\035com.flyteidl2.cacheservice.v2B\021CacheserviceProtoH\002P\001Z=github.com/flyteorg/flyte/v2/gen/go/flyteidl2/cacheservice/v2\242\002\003FCX\252\002\031Flyteidl2.Cacheservice.V2\312\002\031Flyteidl2\\Cacheservice\\V2\342\002%Flyteidl2\\Cacheservice\\V2\\GPBMetadata\352\002\033Flyteidl2::Cacheservice::V2' + _IDENTIFIER.fields_by_name['org']._options = None + _IDENTIFIER.fields_by_name['org']._serialized_options = b'\272H\004r\002\020\001' + _IDENTIFIER.fields_by_name['project']._options = None + _IDENTIFIER.fields_by_name['project']._serialized_options = b'\272H\004r\002\020\001' + _IDENTIFIER.fields_by_name['domain']._options = None + _IDENTIFIER.fields_by_name['domain']._serialized_options = b'\272H\004r\002\020\001' + _GETCACHEREQUEST.fields_by_name['identifier']._options = None + _GETCACHEREQUEST.fields_by_name['identifier']._serialized_options = b'\272H\003\310\001\001' + _PUTCACHEREQUEST.fields_by_name['identifier']._options = None + _PUTCACHEREQUEST.fields_by_name['identifier']._serialized_options = b'\272H\003\310\001\001' + _DELETECACHEREQUEST.fields_by_name['identifier']._options = None + _DELETECACHEREQUEST.fields_by_name['identifier']._serialized_options = b'\272H\003\310\001\001' + _GETOREXTENDRESERVATIONREQUEST.fields_by_name['identifier']._options = None + _GETOREXTENDRESERVATIONREQUEST.fields_by_name['identifier']._serialized_options = b'\272H\003\310\001\001' + _RELEASERESERVATIONREQUEST.fields_by_name['identifier']._options = None + _RELEASERESERVATIONREQUEST.fields_by_name['identifier']._serialized_options = b'\272H\003\310\001\001' + _globals['_IDENTIFIER']._serialized_start=147 + _globals['_IDENTIFIER']._serialized_end=254 + _globals['_GETCACHEREQUEST']._serialized_start=257 + _globals['_GETCACHEREQUEST']._serialized_end=429 + _globals['_PUTCACHEREQUEST']._serialized_start=432 + _globals['_PUTCACHEREQUEST']._serialized_end=604 + _globals['_DELETECACHEREQUEST']._serialized_start=607 + _globals['_DELETECACHEREQUEST']._serialized_end=785 + _globals['_GETOREXTENDRESERVATIONREQUEST']._serialized_start=788 + _globals['_GETOREXTENDRESERVATIONREQUEST']._serialized_end=988 + _globals['_RELEASERESERVATIONREQUEST']._serialized_start=991 + _globals['_RELEASERESERVATIONREQUEST']._serialized_end=1183 + _globals['_CACHESERVICE']._serialized_start=1186 + _globals['_CACHESERVICE']._serialized_end=1757 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/cacheservice/v2/cacheservice_pb2.pyi b/gen/python/flyteidl2/cacheservice/v2/cacheservice_pb2.pyi new file mode 100644 index 0000000000..7468c086ea --- /dev/null +++ b/gen/python/flyteidl2/cacheservice/v2/cacheservice_pb2.pyi @@ -0,0 +1,57 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.cacheservice import cacheservice_pb2 as _cacheservice_pb2 +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class Identifier(_message.Message): + __slots__ = ["org", "project", "domain"] + ORG_FIELD_NUMBER: _ClassVar[int] + PROJECT_FIELD_NUMBER: _ClassVar[int] + DOMAIN_FIELD_NUMBER: _ClassVar[int] + org: str + project: str + domain: str + def __init__(self, org: _Optional[str] = ..., project: _Optional[str] = ..., domain: _Optional[str] = ...) -> None: ... + +class GetCacheRequest(_message.Message): + __slots__ = ["base_request", "identifier"] + BASE_REQUEST_FIELD_NUMBER: _ClassVar[int] + IDENTIFIER_FIELD_NUMBER: _ClassVar[int] + base_request: _cacheservice_pb2.GetCacheRequest + identifier: Identifier + def __init__(self, base_request: _Optional[_Union[_cacheservice_pb2.GetCacheRequest, _Mapping]] = ..., identifier: _Optional[_Union[Identifier, _Mapping]] = ...) -> None: ... + +class PutCacheRequest(_message.Message): + __slots__ = ["base_request", "identifier"] + BASE_REQUEST_FIELD_NUMBER: _ClassVar[int] + IDENTIFIER_FIELD_NUMBER: _ClassVar[int] + base_request: _cacheservice_pb2.PutCacheRequest + identifier: Identifier + def __init__(self, base_request: _Optional[_Union[_cacheservice_pb2.PutCacheRequest, _Mapping]] = ..., identifier: _Optional[_Union[Identifier, _Mapping]] = ...) -> None: ... + +class DeleteCacheRequest(_message.Message): + __slots__ = ["base_request", "identifier"] + BASE_REQUEST_FIELD_NUMBER: _ClassVar[int] + IDENTIFIER_FIELD_NUMBER: _ClassVar[int] + base_request: _cacheservice_pb2.DeleteCacheRequest + identifier: Identifier + def __init__(self, base_request: _Optional[_Union[_cacheservice_pb2.DeleteCacheRequest, _Mapping]] = ..., identifier: _Optional[_Union[Identifier, _Mapping]] = ...) -> None: ... + +class GetOrExtendReservationRequest(_message.Message): + __slots__ = ["base_request", "identifier"] + BASE_REQUEST_FIELD_NUMBER: _ClassVar[int] + IDENTIFIER_FIELD_NUMBER: _ClassVar[int] + base_request: _cacheservice_pb2.GetOrExtendReservationRequest + identifier: Identifier + def __init__(self, base_request: _Optional[_Union[_cacheservice_pb2.GetOrExtendReservationRequest, _Mapping]] = ..., identifier: _Optional[_Union[Identifier, _Mapping]] = ...) -> None: ... + +class ReleaseReservationRequest(_message.Message): + __slots__ = ["base_request", "identifier"] + BASE_REQUEST_FIELD_NUMBER: _ClassVar[int] + IDENTIFIER_FIELD_NUMBER: _ClassVar[int] + base_request: _cacheservice_pb2.ReleaseReservationRequest + identifier: Identifier + def __init__(self, base_request: _Optional[_Union[_cacheservice_pb2.ReleaseReservationRequest, _Mapping]] = ..., identifier: _Optional[_Union[Identifier, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/cacheservice/v2/cacheservice_pb2_grpc.py b/gen/python/flyteidl2/cacheservice/v2/cacheservice_pb2_grpc.py new file mode 100644 index 0000000000..1c01a4cb6e --- /dev/null +++ b/gen/python/flyteidl2/cacheservice/v2/cacheservice_pb2_grpc.py @@ -0,0 +1,210 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from flyteidl2.cacheservice import cacheservice_pb2 as flyteidl2_dot_cacheservice_dot_cacheservice__pb2 +from flyteidl2.cacheservice.v2 import cacheservice_pb2 as flyteidl2_dot_cacheservice_dot_v2_dot_cacheservice__pb2 + + +class CacheServiceStub(object): + """ + CacheService defines operations for cache management including retrieval, storage, and deletion of cached task/workflow outputs. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.Get = channel.unary_unary( + '/flyteidl2.cacheservice.v2.CacheService/Get', + request_serializer=flyteidl2_dot_cacheservice_dot_v2_dot_cacheservice__pb2.GetCacheRequest.SerializeToString, + response_deserializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.GetCacheResponse.FromString, + ) + self.Put = channel.unary_unary( + '/flyteidl2.cacheservice.v2.CacheService/Put', + request_serializer=flyteidl2_dot_cacheservice_dot_v2_dot_cacheservice__pb2.PutCacheRequest.SerializeToString, + response_deserializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.PutCacheResponse.FromString, + ) + self.Delete = channel.unary_unary( + '/flyteidl2.cacheservice.v2.CacheService/Delete', + request_serializer=flyteidl2_dot_cacheservice_dot_v2_dot_cacheservice__pb2.DeleteCacheRequest.SerializeToString, + response_deserializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.DeleteCacheResponse.FromString, + ) + self.GetOrExtendReservation = channel.unary_unary( + '/flyteidl2.cacheservice.v2.CacheService/GetOrExtendReservation', + request_serializer=flyteidl2_dot_cacheservice_dot_v2_dot_cacheservice__pb2.GetOrExtendReservationRequest.SerializeToString, + response_deserializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.GetOrExtendReservationResponse.FromString, + ) + self.ReleaseReservation = channel.unary_unary( + '/flyteidl2.cacheservice.v2.CacheService/ReleaseReservation', + request_serializer=flyteidl2_dot_cacheservice_dot_v2_dot_cacheservice__pb2.ReleaseReservationRequest.SerializeToString, + response_deserializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.ReleaseReservationResponse.FromString, + ) + + +class CacheServiceServicer(object): + """ + CacheService defines operations for cache management including retrieval, storage, and deletion of cached task/workflow outputs. + """ + + def Get(self, request, context): + """Retrieves cached data by key. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Put(self, request, context): + """Stores or updates cached data by key. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Delete(self, request, context): + """Deletes cached data by key. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetOrExtendReservation(self, request, context): + """Get or extend a reservation for a cache key + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReleaseReservation(self, request, context): + """Release the reservation for a cache key + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_CacheServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'Get': grpc.unary_unary_rpc_method_handler( + servicer.Get, + request_deserializer=flyteidl2_dot_cacheservice_dot_v2_dot_cacheservice__pb2.GetCacheRequest.FromString, + response_serializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.GetCacheResponse.SerializeToString, + ), + 'Put': grpc.unary_unary_rpc_method_handler( + servicer.Put, + request_deserializer=flyteidl2_dot_cacheservice_dot_v2_dot_cacheservice__pb2.PutCacheRequest.FromString, + response_serializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.PutCacheResponse.SerializeToString, + ), + 'Delete': grpc.unary_unary_rpc_method_handler( + servicer.Delete, + request_deserializer=flyteidl2_dot_cacheservice_dot_v2_dot_cacheservice__pb2.DeleteCacheRequest.FromString, + response_serializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.DeleteCacheResponse.SerializeToString, + ), + 'GetOrExtendReservation': grpc.unary_unary_rpc_method_handler( + servicer.GetOrExtendReservation, + request_deserializer=flyteidl2_dot_cacheservice_dot_v2_dot_cacheservice__pb2.GetOrExtendReservationRequest.FromString, + response_serializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.GetOrExtendReservationResponse.SerializeToString, + ), + 'ReleaseReservation': grpc.unary_unary_rpc_method_handler( + servicer.ReleaseReservation, + request_deserializer=flyteidl2_dot_cacheservice_dot_v2_dot_cacheservice__pb2.ReleaseReservationRequest.FromString, + response_serializer=flyteidl2_dot_cacheservice_dot_cacheservice__pb2.ReleaseReservationResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.cacheservice.v2.CacheService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class CacheService(object): + """ + CacheService defines operations for cache management including retrieval, storage, and deletion of cached task/workflow outputs. + """ + + @staticmethod + def Get(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.cacheservice.v2.CacheService/Get', + flyteidl2_dot_cacheservice_dot_v2_dot_cacheservice__pb2.GetCacheRequest.SerializeToString, + flyteidl2_dot_cacheservice_dot_cacheservice__pb2.GetCacheResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Put(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.cacheservice.v2.CacheService/Put', + flyteidl2_dot_cacheservice_dot_v2_dot_cacheservice__pb2.PutCacheRequest.SerializeToString, + flyteidl2_dot_cacheservice_dot_cacheservice__pb2.PutCacheResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Delete(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.cacheservice.v2.CacheService/Delete', + flyteidl2_dot_cacheservice_dot_v2_dot_cacheservice__pb2.DeleteCacheRequest.SerializeToString, + flyteidl2_dot_cacheservice_dot_cacheservice__pb2.DeleteCacheResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetOrExtendReservation(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.cacheservice.v2.CacheService/GetOrExtendReservation', + flyteidl2_dot_cacheservice_dot_v2_dot_cacheservice__pb2.GetOrExtendReservationRequest.SerializeToString, + flyteidl2_dot_cacheservice_dot_cacheservice__pb2.GetOrExtendReservationResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReleaseReservation(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.cacheservice.v2.CacheService/ReleaseReservation', + flyteidl2_dot_cacheservice_dot_v2_dot_cacheservice__pb2.ReleaseReservationRequest.SerializeToString, + flyteidl2_dot_cacheservice_dot_cacheservice__pb2.ReleaseReservationResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/gen/python/flyteidl2/common/__init__.py b/gen/python/flyteidl2/common/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/common/authorization_pb2.py b/gen/python/flyteidl2/common/authorization_pb2.py new file mode 100644 index 0000000000..9e11411a7e --- /dev/null +++ b/gen/python/flyteidl2/common/authorization_pb2.py @@ -0,0 +1,66 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/common/authorization.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.common import identifier_pb2 as flyteidl2_dot_common_dot_identifier__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n$flyteidl2/common/authorization.proto\x12\x10\x66lyteidl2.common\x1a\x1b\x62uf/validate/validate.proto\x1a!flyteidl2/common/identifier.proto\"+\n\x0cOrganization\x12\x1b\n\x04name\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x04name\"h\n\x06\x44omain\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12J\n\x0corganization\x18\x02 \x01(\x0b\x32\x1e.flyteidl2.common.OrganizationB\x06\xbaH\x03\xc8\x01\x01R\x0corganization\"`\n\x07Project\x12\x1b\n\x04name\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x04name\x12\x38\n\x06\x64omain\x18\x02 \x01(\x0b\x32\x18.flyteidl2.common.DomainB\x06\xbaH\x03\xc8\x01\x01R\x06\x64omain\"d\n\x08Workflow\x12\x1b\n\x04name\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x04name\x12;\n\x07project\x18\x02 \x01(\x0b\x32\x19.flyteidl2.common.ProjectB\x06\xbaH\x03\xc8\x01\x01R\x07project\"f\n\nLaunchPlan\x12\x1b\n\x04name\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x04name\x12;\n\x07project\x18\x02 \x01(\x0b\x32\x19.flyteidl2.common.ProjectB\x06\xbaH\x03\xc8\x01\x01R\x07project\"\x83\x03\n\x08Resource\x12\x44\n\x0corganization\x18\x01 \x01(\x0b\x32\x1e.flyteidl2.common.OrganizationH\x00R\x0corganization\x12\x32\n\x06\x64omain\x18\x02 \x01(\x0b\x32\x18.flyteidl2.common.DomainH\x00R\x06\x64omain\x12\x35\n\x07project\x18\x03 \x01(\x0b\x32\x19.flyteidl2.common.ProjectH\x00R\x07project\x12\x38\n\x08workflow\x18\x04 \x01(\x0b\x32\x1a.flyteidl2.common.WorkflowH\x00R\x08workflow\x12?\n\x0blaunch_plan\x18\x05 \x01(\x0b\x32\x1c.flyteidl2.common.LaunchPlanH\x00R\nlaunchPlan\x12?\n\x07\x63luster\x18\x06 \x01(\x0b\x32#.flyteidl2.common.ClusterIdentifierH\x00R\x07\x63lusterB\n\n\x08resource\"x\n\nPermission\x12\x36\n\x08resource\x18\x01 \x01(\x0b\x32\x1a.flyteidl2.common.ResourceR\x08resource\x12\x32\n\x07\x61\x63tions\x18\x02 \x03(\x0e\x32\x18.flyteidl2.common.ActionR\x07\x61\x63tions*\x94\x04\n\x06\x41\x63tion\x12\x0f\n\x0b\x41\x43TION_NONE\x10\x00\x12\x15\n\rACTION_CREATE\x10\x01\x1a\x02\x08\x01\x12\x13\n\x0b\x41\x43TION_READ\x10\x02\x1a\x02\x08\x01\x12\x15\n\rACTION_UPDATE\x10\x03\x1a\x02\x08\x01\x12\x15\n\rACTION_DELETE\x10\x04\x1a\x02\x08\x01\x12\x1f\n\x1b\x41\x43TION_VIEW_FLYTE_INVENTORY\x10\x05\x12 \n\x1c\x41\x43TION_VIEW_FLYTE_EXECUTIONS\x10\x06\x12#\n\x1f\x41\x43TION_REGISTER_FLYTE_INVENTORY\x10\x07\x12\"\n\x1e\x41\x43TION_CREATE_FLYTE_EXECUTIONS\x10\x08\x12\x1d\n\x19\x41\x43TION_ADMINISTER_PROJECT\x10\t\x12\x1d\n\x19\x41\x43TION_MANAGE_PERMISSIONS\x10\n\x12\x1d\n\x19\x41\x43TION_ADMINISTER_ACCOUNT\x10\x0b\x12\x19\n\x15\x41\x43TION_MANAGE_CLUSTER\x10\x0c\x12,\n(ACTION_EDIT_EXECUTION_RELATED_ATTRIBUTES\x10\r\x12*\n&ACTION_EDIT_CLUSTER_RELATED_ATTRIBUTES\x10\x0e\x12!\n\x1d\x41\x43TION_EDIT_UNUSED_ATTRIBUTES\x10\x0f\x12\x1e\n\x1a\x41\x43TION_SUPPORT_SYSTEM_LOGS\x10\x10\x42\xc3\x01\n\x14\x63om.flyteidl2.commonB\x12\x41uthorizationProtoH\x02P\x01Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common\xa2\x02\x03\x46\x43X\xaa\x02\x10\x46lyteidl2.Common\xca\x02\x10\x46lyteidl2\\Common\xe2\x02\x1c\x46lyteidl2\\Common\\GPBMetadata\xea\x02\x11\x46lyteidl2::Commonb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.common.authorization_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\024com.flyteidl2.commonB\022AuthorizationProtoH\002P\001Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common\242\002\003FCX\252\002\020Flyteidl2.Common\312\002\020Flyteidl2\\Common\342\002\034Flyteidl2\\Common\\GPBMetadata\352\002\021Flyteidl2::Common' + _ACTION.values_by_name["ACTION_CREATE"]._options = None + _ACTION.values_by_name["ACTION_CREATE"]._serialized_options = b'\010\001' + _ACTION.values_by_name["ACTION_READ"]._options = None + _ACTION.values_by_name["ACTION_READ"]._serialized_options = b'\010\001' + _ACTION.values_by_name["ACTION_UPDATE"]._options = None + _ACTION.values_by_name["ACTION_UPDATE"]._serialized_options = b'\010\001' + _ACTION.values_by_name["ACTION_DELETE"]._options = None + _ACTION.values_by_name["ACTION_DELETE"]._serialized_options = b'\010\001' + _ORGANIZATION.fields_by_name['name']._options = None + _ORGANIZATION.fields_by_name['name']._serialized_options = b'\272H\004r\002\020\001' + _DOMAIN.fields_by_name['organization']._options = None + _DOMAIN.fields_by_name['organization']._serialized_options = b'\272H\003\310\001\001' + _PROJECT.fields_by_name['name']._options = None + _PROJECT.fields_by_name['name']._serialized_options = b'\272H\004r\002\020\001' + _PROJECT.fields_by_name['domain']._options = None + _PROJECT.fields_by_name['domain']._serialized_options = b'\272H\003\310\001\001' + _WORKFLOW.fields_by_name['name']._options = None + _WORKFLOW.fields_by_name['name']._serialized_options = b'\272H\004r\002\020\001' + _WORKFLOW.fields_by_name['project']._options = None + _WORKFLOW.fields_by_name['project']._serialized_options = b'\272H\003\310\001\001' + _LAUNCHPLAN.fields_by_name['name']._options = None + _LAUNCHPLAN.fields_by_name['name']._serialized_options = b'\272H\004r\002\020\001' + _LAUNCHPLAN.fields_by_name['project']._options = None + _LAUNCHPLAN.fields_by_name['project']._serialized_options = b'\272H\003\310\001\001' + _globals['_ACTION']._serialized_start=1090 + _globals['_ACTION']._serialized_end=1622 + _globals['_ORGANIZATION']._serialized_start=122 + _globals['_ORGANIZATION']._serialized_end=165 + _globals['_DOMAIN']._serialized_start=167 + _globals['_DOMAIN']._serialized_end=271 + _globals['_PROJECT']._serialized_start=273 + _globals['_PROJECT']._serialized_end=369 + _globals['_WORKFLOW']._serialized_start=371 + _globals['_WORKFLOW']._serialized_end=471 + _globals['_LAUNCHPLAN']._serialized_start=473 + _globals['_LAUNCHPLAN']._serialized_end=575 + _globals['_RESOURCE']._serialized_start=578 + _globals['_RESOURCE']._serialized_end=965 + _globals['_PERMISSION']._serialized_start=967 + _globals['_PERMISSION']._serialized_end=1087 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/common/authorization_pb2.pyi b/gen/python/flyteidl2/common/authorization_pb2.pyi new file mode 100644 index 0000000000..a2aa122955 --- /dev/null +++ b/gen/python/flyteidl2/common/authorization_pb2.pyi @@ -0,0 +1,108 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.common import identifier_pb2 as _identifier_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class Action(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + ACTION_NONE: _ClassVar[Action] + ACTION_CREATE: _ClassVar[Action] + ACTION_READ: _ClassVar[Action] + ACTION_UPDATE: _ClassVar[Action] + ACTION_DELETE: _ClassVar[Action] + ACTION_VIEW_FLYTE_INVENTORY: _ClassVar[Action] + ACTION_VIEW_FLYTE_EXECUTIONS: _ClassVar[Action] + ACTION_REGISTER_FLYTE_INVENTORY: _ClassVar[Action] + ACTION_CREATE_FLYTE_EXECUTIONS: _ClassVar[Action] + ACTION_ADMINISTER_PROJECT: _ClassVar[Action] + ACTION_MANAGE_PERMISSIONS: _ClassVar[Action] + ACTION_ADMINISTER_ACCOUNT: _ClassVar[Action] + ACTION_MANAGE_CLUSTER: _ClassVar[Action] + ACTION_EDIT_EXECUTION_RELATED_ATTRIBUTES: _ClassVar[Action] + ACTION_EDIT_CLUSTER_RELATED_ATTRIBUTES: _ClassVar[Action] + ACTION_EDIT_UNUSED_ATTRIBUTES: _ClassVar[Action] + ACTION_SUPPORT_SYSTEM_LOGS: _ClassVar[Action] +ACTION_NONE: Action +ACTION_CREATE: Action +ACTION_READ: Action +ACTION_UPDATE: Action +ACTION_DELETE: Action +ACTION_VIEW_FLYTE_INVENTORY: Action +ACTION_VIEW_FLYTE_EXECUTIONS: Action +ACTION_REGISTER_FLYTE_INVENTORY: Action +ACTION_CREATE_FLYTE_EXECUTIONS: Action +ACTION_ADMINISTER_PROJECT: Action +ACTION_MANAGE_PERMISSIONS: Action +ACTION_ADMINISTER_ACCOUNT: Action +ACTION_MANAGE_CLUSTER: Action +ACTION_EDIT_EXECUTION_RELATED_ATTRIBUTES: Action +ACTION_EDIT_CLUSTER_RELATED_ATTRIBUTES: Action +ACTION_EDIT_UNUSED_ATTRIBUTES: Action +ACTION_SUPPORT_SYSTEM_LOGS: Action + +class Organization(_message.Message): + __slots__ = ["name"] + NAME_FIELD_NUMBER: _ClassVar[int] + name: str + def __init__(self, name: _Optional[str] = ...) -> None: ... + +class Domain(_message.Message): + __slots__ = ["name", "organization"] + NAME_FIELD_NUMBER: _ClassVar[int] + ORGANIZATION_FIELD_NUMBER: _ClassVar[int] + name: str + organization: Organization + def __init__(self, name: _Optional[str] = ..., organization: _Optional[_Union[Organization, _Mapping]] = ...) -> None: ... + +class Project(_message.Message): + __slots__ = ["name", "domain"] + NAME_FIELD_NUMBER: _ClassVar[int] + DOMAIN_FIELD_NUMBER: _ClassVar[int] + name: str + domain: Domain + def __init__(self, name: _Optional[str] = ..., domain: _Optional[_Union[Domain, _Mapping]] = ...) -> None: ... + +class Workflow(_message.Message): + __slots__ = ["name", "project"] + NAME_FIELD_NUMBER: _ClassVar[int] + PROJECT_FIELD_NUMBER: _ClassVar[int] + name: str + project: Project + def __init__(self, name: _Optional[str] = ..., project: _Optional[_Union[Project, _Mapping]] = ...) -> None: ... + +class LaunchPlan(_message.Message): + __slots__ = ["name", "project"] + NAME_FIELD_NUMBER: _ClassVar[int] + PROJECT_FIELD_NUMBER: _ClassVar[int] + name: str + project: Project + def __init__(self, name: _Optional[str] = ..., project: _Optional[_Union[Project, _Mapping]] = ...) -> None: ... + +class Resource(_message.Message): + __slots__ = ["organization", "domain", "project", "workflow", "launch_plan", "cluster"] + ORGANIZATION_FIELD_NUMBER: _ClassVar[int] + DOMAIN_FIELD_NUMBER: _ClassVar[int] + PROJECT_FIELD_NUMBER: _ClassVar[int] + WORKFLOW_FIELD_NUMBER: _ClassVar[int] + LAUNCH_PLAN_FIELD_NUMBER: _ClassVar[int] + CLUSTER_FIELD_NUMBER: _ClassVar[int] + organization: Organization + domain: Domain + project: Project + workflow: Workflow + launch_plan: LaunchPlan + cluster: _identifier_pb2.ClusterIdentifier + def __init__(self, organization: _Optional[_Union[Organization, _Mapping]] = ..., domain: _Optional[_Union[Domain, _Mapping]] = ..., project: _Optional[_Union[Project, _Mapping]] = ..., workflow: _Optional[_Union[Workflow, _Mapping]] = ..., launch_plan: _Optional[_Union[LaunchPlan, _Mapping]] = ..., cluster: _Optional[_Union[_identifier_pb2.ClusterIdentifier, _Mapping]] = ...) -> None: ... + +class Permission(_message.Message): + __slots__ = ["resource", "actions"] + RESOURCE_FIELD_NUMBER: _ClassVar[int] + ACTIONS_FIELD_NUMBER: _ClassVar[int] + resource: Resource + actions: _containers.RepeatedScalarFieldContainer[Action] + def __init__(self, resource: _Optional[_Union[Resource, _Mapping]] = ..., actions: _Optional[_Iterable[_Union[Action, str]]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/common/authorization_pb2_grpc.py b/gen/python/flyteidl2/common/authorization_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/common/authorization_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/common/configuration_pb2.py b/gen/python/flyteidl2/common/configuration_pb2.py new file mode 100644 index 0000000000..7a9ba96a51 --- /dev/null +++ b/gen/python/flyteidl2/common/configuration_pb2.py @@ -0,0 +1,26 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/common/configuration.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n$flyteidl2/common/configuration.proto\x12\x10\x66lyteidl2.common*l\n\x10\x41ttributesSource\x12\x16\n\x12SOURCE_UNSPECIFIED\x10\x00\x12\n\n\x06GLOBAL\x10\x01\x12\n\n\x06\x44OMAIN\x10\x02\x12\x0b\n\x07PROJECT\x10\x03\x12\x12\n\x0ePROJECT_DOMAIN\x10\x04\x12\x07\n\x03ORG\x10\x05\x42\xc3\x01\n\x14\x63om.flyteidl2.commonB\x12\x43onfigurationProtoH\x02P\x01Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common\xa2\x02\x03\x46\x43X\xaa\x02\x10\x46lyteidl2.Common\xca\x02\x10\x46lyteidl2\\Common\xe2\x02\x1c\x46lyteidl2\\Common\\GPBMetadata\xea\x02\x11\x46lyteidl2::Commonb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.common.configuration_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\024com.flyteidl2.commonB\022ConfigurationProtoH\002P\001Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common\242\002\003FCX\252\002\020Flyteidl2.Common\312\002\020Flyteidl2\\Common\342\002\034Flyteidl2\\Common\\GPBMetadata\352\002\021Flyteidl2::Common' + _globals['_ATTRIBUTESSOURCE']._serialized_start=58 + _globals['_ATTRIBUTESSOURCE']._serialized_end=166 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/common/configuration_pb2.pyi b/gen/python/flyteidl2/common/configuration_pb2.pyi new file mode 100644 index 0000000000..72b51de8f4 --- /dev/null +++ b/gen/python/flyteidl2/common/configuration_pb2.pyi @@ -0,0 +1,20 @@ +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from typing import ClassVar as _ClassVar + +DESCRIPTOR: _descriptor.FileDescriptor + +class AttributesSource(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + SOURCE_UNSPECIFIED: _ClassVar[AttributesSource] + GLOBAL: _ClassVar[AttributesSource] + DOMAIN: _ClassVar[AttributesSource] + PROJECT: _ClassVar[AttributesSource] + PROJECT_DOMAIN: _ClassVar[AttributesSource] + ORG: _ClassVar[AttributesSource] +SOURCE_UNSPECIFIED: AttributesSource +GLOBAL: AttributesSource +DOMAIN: AttributesSource +PROJECT: AttributesSource +PROJECT_DOMAIN: AttributesSource +ORG: AttributesSource diff --git a/gen/python/flyteidl2/common/configuration_pb2_grpc.py b/gen/python/flyteidl2/common/configuration_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/common/configuration_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/common/identifier_pb2.py b/gen/python/flyteidl2/common/identifier_pb2.py new file mode 100644 index 0000000000..90dc27319f --- /dev/null +++ b/gen/python/flyteidl2/common/identifier_pb2.py @@ -0,0 +1,117 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/common/identifier.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n!flyteidl2/common/identifier.proto\x12\x10\x66lyteidl2.common\x1a\x1b\x62uf/validate/validate.proto\"~\n\x11ProjectIdentifier\x12+\n\x0corganization\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x0corganization\x12\x1f\n\x06\x64omain\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x06\x64omain\x12\x1b\n\x04name\x18\x03 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x04name\"T\n\x11\x43lusterIdentifier\x12\"\n\x0corganization\x18\x01 \x01(\tR\x0corganization\x12\x1b\n\x04name\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x04name\"O\n\x15\x43lusterPoolIdentifier\x12\"\n\x0corganization\x18\x01 \x01(\tR\x0corganization\x12\x12\n\x04name\x18\x02 \x01(\tR\x04name\"_\n\x17\x43lusterConfigIdentifier\x12+\n\x0corganization\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x0corganization\x12\x17\n\x02id\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x02id\"\x88\x01\n\x19\x43lusterNodepoolIdentifier\x12\"\n\x0corganization\x18\x01 \x01(\tR\x0corganization\x12*\n\x0c\x63luster_name\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x0b\x63lusterName\x12\x1b\n\x04name\x18\x03 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x04name\"3\n\x0eUserIdentifier\x12!\n\x07subject\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x07subject\":\n\x15\x41pplicationIdentifier\x12!\n\x07subject\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x07subject\"Q\n\x0eRoleIdentifier\x12\"\n\x0corganization\x18\x01 \x01(\tR\x0corganization\x12\x1b\n\x04name\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x04name\"O\n\rOrgIdentifier\x12>\n\x04name\x18\x01 \x01(\tB*\xbaH\'r%\x10\x01\x18?2\x1f^[a-z0-9]([-a-z0-9]*[a-z0-9])?$R\x04name\"x\n\x18ManagedClusterIdentifier\x12\x1b\n\x04name\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x04name\x12\x39\n\x03org\x18\x03 \x01(\x0b\x32\x1f.flyteidl2.common.OrgIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x03orgJ\x04\x08\x01\x10\x02\"S\n\x10PolicyIdentifier\x12\"\n\x0corganization\x18\x01 \x01(\tR\x0corganization\x12\x1b\n\x04name\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x04name\"\x93\x01\n\rRunIdentifier\x12\x1b\n\x03org\x18\x01 \x01(\tB\t\xbaH\x06r\x04\x10\x01\x18?R\x03org\x12#\n\x07project\x18\x02 \x01(\tB\t\xbaH\x06r\x04\x10\x01\x18?R\x07project\x12!\n\x06\x64omain\x18\x03 \x01(\tB\t\xbaH\x06r\x04\x10\x01\x18?R\x06\x64omain\x12\x1d\n\x04name\x18\x04 \x01(\tB\t\xbaH\x06r\x04\x10\x01\x18\x1eR\x04name\"l\n\x10\x41\x63tionIdentifier\x12\x39\n\x03run\x18\x01 \x01(\x0b\x32\x1f.flyteidl2.common.RunIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x03run\x12\x1d\n\x04name\x18\x02 \x01(\tB\t\xbaH\x06r\x04\x10\x01\x18\x1eR\x04name\"\x85\x01\n\x17\x41\x63tionAttemptIdentifier\x12G\n\taction_id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x08\x61\x63tionId\x12!\n\x07\x61ttempt\x18\x02 \x01(\rB\x07\xbaH\x04*\x02 \x00R\x07\x61ttempt\"\xbb\x01\n\x0bTriggerName\x12\x1b\n\x03org\x18\x01 \x01(\tB\t\xbaH\x06r\x04\x10\x01\x18?R\x03org\x12#\n\x07project\x18\x02 \x01(\tB\t\xbaH\x06r\x04\x10\x01\x18?R\x07project\x12!\n\x06\x64omain\x18\x03 \x01(\tB\t\xbaH\x06r\x04\x10\x01\x18?R\x06\x64omain\x12\x1e\n\x04name\x18\x04 \x01(\tB\n\xbaH\x07r\x05\x10\x01\x18\xff\x01R\x04name\x12\'\n\ttask_name\x18\x05 \x01(\tB\n\xbaH\x07r\x05\x10\x01\x18\xff\x01R\x08taskName\"s\n\x11TriggerIdentifier\x12\x39\n\x04name\x18\x01 \x01(\x0b\x32\x1d.flyteidl2.common.TriggerNameB\x06\xbaH\x03\xc8\x01\x01R\x04name\x12#\n\x08revision\x18\x02 \x01(\x04\x42\x07\xbaH\x04\x32\x02 \x00R\x08revisionB\xc0\x01\n\x14\x63om.flyteidl2.commonB\x0fIdentifierProtoH\x02P\x01Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common\xa2\x02\x03\x46\x43X\xaa\x02\x10\x46lyteidl2.Common\xca\x02\x10\x46lyteidl2\\Common\xe2\x02\x1c\x46lyteidl2\\Common\\GPBMetadata\xea\x02\x11\x46lyteidl2::Commonb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.common.identifier_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\024com.flyteidl2.commonB\017IdentifierProtoH\002P\001Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common\242\002\003FCX\252\002\020Flyteidl2.Common\312\002\020Flyteidl2\\Common\342\002\034Flyteidl2\\Common\\GPBMetadata\352\002\021Flyteidl2::Common' + _PROJECTIDENTIFIER.fields_by_name['organization']._options = None + _PROJECTIDENTIFIER.fields_by_name['organization']._serialized_options = b'\272H\004r\002\020\001' + _PROJECTIDENTIFIER.fields_by_name['domain']._options = None + _PROJECTIDENTIFIER.fields_by_name['domain']._serialized_options = b'\272H\004r\002\020\001' + _PROJECTIDENTIFIER.fields_by_name['name']._options = None + _PROJECTIDENTIFIER.fields_by_name['name']._serialized_options = b'\272H\004r\002\020\001' + _CLUSTERIDENTIFIER.fields_by_name['name']._options = None + _CLUSTERIDENTIFIER.fields_by_name['name']._serialized_options = b'\272H\004r\002\020\001' + _CLUSTERCONFIGIDENTIFIER.fields_by_name['organization']._options = None + _CLUSTERCONFIGIDENTIFIER.fields_by_name['organization']._serialized_options = b'\272H\004r\002\020\001' + _CLUSTERCONFIGIDENTIFIER.fields_by_name['id']._options = None + _CLUSTERCONFIGIDENTIFIER.fields_by_name['id']._serialized_options = b'\272H\004r\002\020\001' + _CLUSTERNODEPOOLIDENTIFIER.fields_by_name['cluster_name']._options = None + _CLUSTERNODEPOOLIDENTIFIER.fields_by_name['cluster_name']._serialized_options = b'\272H\004r\002\020\001' + _CLUSTERNODEPOOLIDENTIFIER.fields_by_name['name']._options = None + _CLUSTERNODEPOOLIDENTIFIER.fields_by_name['name']._serialized_options = b'\272H\004r\002\020\001' + _USERIDENTIFIER.fields_by_name['subject']._options = None + _USERIDENTIFIER.fields_by_name['subject']._serialized_options = b'\272H\004r\002\020\001' + _APPLICATIONIDENTIFIER.fields_by_name['subject']._options = None + _APPLICATIONIDENTIFIER.fields_by_name['subject']._serialized_options = b'\272H\004r\002\020\001' + _ROLEIDENTIFIER.fields_by_name['name']._options = None + _ROLEIDENTIFIER.fields_by_name['name']._serialized_options = b'\272H\004r\002\020\001' + _ORGIDENTIFIER.fields_by_name['name']._options = None + _ORGIDENTIFIER.fields_by_name['name']._serialized_options = b'\272H\'r%\020\001\030?2\037^[a-z0-9]([-a-z0-9]*[a-z0-9])?$' + _MANAGEDCLUSTERIDENTIFIER.fields_by_name['name']._options = None + _MANAGEDCLUSTERIDENTIFIER.fields_by_name['name']._serialized_options = b'\272H\004r\002\020\001' + _MANAGEDCLUSTERIDENTIFIER.fields_by_name['org']._options = None + _MANAGEDCLUSTERIDENTIFIER.fields_by_name['org']._serialized_options = b'\272H\003\310\001\001' + _POLICYIDENTIFIER.fields_by_name['name']._options = None + _POLICYIDENTIFIER.fields_by_name['name']._serialized_options = b'\272H\004r\002\020\001' + _RUNIDENTIFIER.fields_by_name['org']._options = None + _RUNIDENTIFIER.fields_by_name['org']._serialized_options = b'\272H\006r\004\020\001\030?' + _RUNIDENTIFIER.fields_by_name['project']._options = None + _RUNIDENTIFIER.fields_by_name['project']._serialized_options = b'\272H\006r\004\020\001\030?' + _RUNIDENTIFIER.fields_by_name['domain']._options = None + _RUNIDENTIFIER.fields_by_name['domain']._serialized_options = b'\272H\006r\004\020\001\030?' + _RUNIDENTIFIER.fields_by_name['name']._options = None + _RUNIDENTIFIER.fields_by_name['name']._serialized_options = b'\272H\006r\004\020\001\030\036' + _ACTIONIDENTIFIER.fields_by_name['run']._options = None + _ACTIONIDENTIFIER.fields_by_name['run']._serialized_options = b'\272H\003\310\001\001' + _ACTIONIDENTIFIER.fields_by_name['name']._options = None + _ACTIONIDENTIFIER.fields_by_name['name']._serialized_options = b'\272H\006r\004\020\001\030\036' + _ACTIONATTEMPTIDENTIFIER.fields_by_name['action_id']._options = None + _ACTIONATTEMPTIDENTIFIER.fields_by_name['action_id']._serialized_options = b'\272H\003\310\001\001' + _ACTIONATTEMPTIDENTIFIER.fields_by_name['attempt']._options = None + _ACTIONATTEMPTIDENTIFIER.fields_by_name['attempt']._serialized_options = b'\272H\004*\002 \000' + _TRIGGERNAME.fields_by_name['org']._options = None + _TRIGGERNAME.fields_by_name['org']._serialized_options = b'\272H\006r\004\020\001\030?' + _TRIGGERNAME.fields_by_name['project']._options = None + _TRIGGERNAME.fields_by_name['project']._serialized_options = b'\272H\006r\004\020\001\030?' + _TRIGGERNAME.fields_by_name['domain']._options = None + _TRIGGERNAME.fields_by_name['domain']._serialized_options = b'\272H\006r\004\020\001\030?' + _TRIGGERNAME.fields_by_name['name']._options = None + _TRIGGERNAME.fields_by_name['name']._serialized_options = b'\272H\007r\005\020\001\030\377\001' + _TRIGGERNAME.fields_by_name['task_name']._options = None + _TRIGGERNAME.fields_by_name['task_name']._serialized_options = b'\272H\007r\005\020\001\030\377\001' + _TRIGGERIDENTIFIER.fields_by_name['name']._options = None + _TRIGGERIDENTIFIER.fields_by_name['name']._serialized_options = b'\272H\003\310\001\001' + _TRIGGERIDENTIFIER.fields_by_name['revision']._options = None + _TRIGGERIDENTIFIER.fields_by_name['revision']._serialized_options = b'\272H\0042\002 \000' + _globals['_PROJECTIDENTIFIER']._serialized_start=84 + _globals['_PROJECTIDENTIFIER']._serialized_end=210 + _globals['_CLUSTERIDENTIFIER']._serialized_start=212 + _globals['_CLUSTERIDENTIFIER']._serialized_end=296 + _globals['_CLUSTERPOOLIDENTIFIER']._serialized_start=298 + _globals['_CLUSTERPOOLIDENTIFIER']._serialized_end=377 + _globals['_CLUSTERCONFIGIDENTIFIER']._serialized_start=379 + _globals['_CLUSTERCONFIGIDENTIFIER']._serialized_end=474 + _globals['_CLUSTERNODEPOOLIDENTIFIER']._serialized_start=477 + _globals['_CLUSTERNODEPOOLIDENTIFIER']._serialized_end=613 + _globals['_USERIDENTIFIER']._serialized_start=615 + _globals['_USERIDENTIFIER']._serialized_end=666 + _globals['_APPLICATIONIDENTIFIER']._serialized_start=668 + _globals['_APPLICATIONIDENTIFIER']._serialized_end=726 + _globals['_ROLEIDENTIFIER']._serialized_start=728 + _globals['_ROLEIDENTIFIER']._serialized_end=809 + _globals['_ORGIDENTIFIER']._serialized_start=811 + _globals['_ORGIDENTIFIER']._serialized_end=890 + _globals['_MANAGEDCLUSTERIDENTIFIER']._serialized_start=892 + _globals['_MANAGEDCLUSTERIDENTIFIER']._serialized_end=1012 + _globals['_POLICYIDENTIFIER']._serialized_start=1014 + _globals['_POLICYIDENTIFIER']._serialized_end=1097 + _globals['_RUNIDENTIFIER']._serialized_start=1100 + _globals['_RUNIDENTIFIER']._serialized_end=1247 + _globals['_ACTIONIDENTIFIER']._serialized_start=1249 + _globals['_ACTIONIDENTIFIER']._serialized_end=1357 + _globals['_ACTIONATTEMPTIDENTIFIER']._serialized_start=1360 + _globals['_ACTIONATTEMPTIDENTIFIER']._serialized_end=1493 + _globals['_TRIGGERNAME']._serialized_start=1496 + _globals['_TRIGGERNAME']._serialized_end=1683 + _globals['_TRIGGERIDENTIFIER']._serialized_start=1685 + _globals['_TRIGGERIDENTIFIER']._serialized_end=1800 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/common/identifier_pb2.pyi b/gen/python/flyteidl2/common/identifier_pb2.pyi new file mode 100644 index 0000000000..f4ba4b3721 --- /dev/null +++ b/gen/python/flyteidl2/common/identifier_pb2.pyi @@ -0,0 +1,142 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class ProjectIdentifier(_message.Message): + __slots__ = ["organization", "domain", "name"] + ORGANIZATION_FIELD_NUMBER: _ClassVar[int] + DOMAIN_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + organization: str + domain: str + name: str + def __init__(self, organization: _Optional[str] = ..., domain: _Optional[str] = ..., name: _Optional[str] = ...) -> None: ... + +class ClusterIdentifier(_message.Message): + __slots__ = ["organization", "name"] + ORGANIZATION_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + organization: str + name: str + def __init__(self, organization: _Optional[str] = ..., name: _Optional[str] = ...) -> None: ... + +class ClusterPoolIdentifier(_message.Message): + __slots__ = ["organization", "name"] + ORGANIZATION_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + organization: str + name: str + def __init__(self, organization: _Optional[str] = ..., name: _Optional[str] = ...) -> None: ... + +class ClusterConfigIdentifier(_message.Message): + __slots__ = ["organization", "id"] + ORGANIZATION_FIELD_NUMBER: _ClassVar[int] + ID_FIELD_NUMBER: _ClassVar[int] + organization: str + id: str + def __init__(self, organization: _Optional[str] = ..., id: _Optional[str] = ...) -> None: ... + +class ClusterNodepoolIdentifier(_message.Message): + __slots__ = ["organization", "cluster_name", "name"] + ORGANIZATION_FIELD_NUMBER: _ClassVar[int] + CLUSTER_NAME_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + organization: str + cluster_name: str + name: str + def __init__(self, organization: _Optional[str] = ..., cluster_name: _Optional[str] = ..., name: _Optional[str] = ...) -> None: ... + +class UserIdentifier(_message.Message): + __slots__ = ["subject"] + SUBJECT_FIELD_NUMBER: _ClassVar[int] + subject: str + def __init__(self, subject: _Optional[str] = ...) -> None: ... + +class ApplicationIdentifier(_message.Message): + __slots__ = ["subject"] + SUBJECT_FIELD_NUMBER: _ClassVar[int] + subject: str + def __init__(self, subject: _Optional[str] = ...) -> None: ... + +class RoleIdentifier(_message.Message): + __slots__ = ["organization", "name"] + ORGANIZATION_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + organization: str + name: str + def __init__(self, organization: _Optional[str] = ..., name: _Optional[str] = ...) -> None: ... + +class OrgIdentifier(_message.Message): + __slots__ = ["name"] + NAME_FIELD_NUMBER: _ClassVar[int] + name: str + def __init__(self, name: _Optional[str] = ...) -> None: ... + +class ManagedClusterIdentifier(_message.Message): + __slots__ = ["name", "org"] + NAME_FIELD_NUMBER: _ClassVar[int] + ORG_FIELD_NUMBER: _ClassVar[int] + name: str + org: OrgIdentifier + def __init__(self, name: _Optional[str] = ..., org: _Optional[_Union[OrgIdentifier, _Mapping]] = ...) -> None: ... + +class PolicyIdentifier(_message.Message): + __slots__ = ["organization", "name"] + ORGANIZATION_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + organization: str + name: str + def __init__(self, organization: _Optional[str] = ..., name: _Optional[str] = ...) -> None: ... + +class RunIdentifier(_message.Message): + __slots__ = ["org", "project", "domain", "name"] + ORG_FIELD_NUMBER: _ClassVar[int] + PROJECT_FIELD_NUMBER: _ClassVar[int] + DOMAIN_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + org: str + project: str + domain: str + name: str + def __init__(self, org: _Optional[str] = ..., project: _Optional[str] = ..., domain: _Optional[str] = ..., name: _Optional[str] = ...) -> None: ... + +class ActionIdentifier(_message.Message): + __slots__ = ["run", "name"] + RUN_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + run: RunIdentifier + name: str + def __init__(self, run: _Optional[_Union[RunIdentifier, _Mapping]] = ..., name: _Optional[str] = ...) -> None: ... + +class ActionAttemptIdentifier(_message.Message): + __slots__ = ["action_id", "attempt"] + ACTION_ID_FIELD_NUMBER: _ClassVar[int] + ATTEMPT_FIELD_NUMBER: _ClassVar[int] + action_id: ActionIdentifier + attempt: int + def __init__(self, action_id: _Optional[_Union[ActionIdentifier, _Mapping]] = ..., attempt: _Optional[int] = ...) -> None: ... + +class TriggerName(_message.Message): + __slots__ = ["org", "project", "domain", "name", "task_name"] + ORG_FIELD_NUMBER: _ClassVar[int] + PROJECT_FIELD_NUMBER: _ClassVar[int] + DOMAIN_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + TASK_NAME_FIELD_NUMBER: _ClassVar[int] + org: str + project: str + domain: str + name: str + task_name: str + def __init__(self, org: _Optional[str] = ..., project: _Optional[str] = ..., domain: _Optional[str] = ..., name: _Optional[str] = ..., task_name: _Optional[str] = ...) -> None: ... + +class TriggerIdentifier(_message.Message): + __slots__ = ["name", "revision"] + NAME_FIELD_NUMBER: _ClassVar[int] + REVISION_FIELD_NUMBER: _ClassVar[int] + name: TriggerName + revision: int + def __init__(self, name: _Optional[_Union[TriggerName, _Mapping]] = ..., revision: _Optional[int] = ...) -> None: ... diff --git a/gen/python/flyteidl2/common/identifier_pb2_grpc.py b/gen/python/flyteidl2/common/identifier_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/common/identifier_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/common/identity_pb2.py b/gen/python/flyteidl2/common/identity_pb2.py new file mode 100644 index 0000000000..566ef7ccee --- /dev/null +++ b/gen/python/flyteidl2/common/identity_pb2.py @@ -0,0 +1,44 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/common/identity.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.common import identifier_pb2 as flyteidl2_dot_common_dot_identifier__pb2 +from flyteidl2.common import policy_pb2 as flyteidl2_dot_common_dot_policy__pb2 +from flyteidl2.common import role_pb2 as flyteidl2_dot_common_dot_role__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1f\x66lyteidl2/common/identity.proto\x12\x10\x66lyteidl2.common\x1a\x1b\x62uf/validate/validate.proto\x1a!flyteidl2/common/identifier.proto\x1a\x1d\x66lyteidl2/common/policy.proto\x1a\x1b\x66lyteidl2/common/role.proto\"\xd0\x01\n\x04User\x12\x30\n\x02id\x18\x01 \x01(\x0b\x32 .flyteidl2.common.UserIdentifierR\x02id\x12.\n\x04spec\x18\x02 \x01(\x0b\x32\x1a.flyteidl2.common.UserSpecR\x04spec\x12\x30\n\x05roles\x18\x03 \x03(\x0b\x32\x16.flyteidl2.common.RoleB\x02\x18\x01R\x05roles\x12\x34\n\x08policies\x18\x04 \x03(\x0b\x32\x18.flyteidl2.common.PolicyR\x08policies\"\xd6\x01\n\x08UserSpec\x12\x1d\n\nfirst_name\x18\x01 \x01(\tR\tfirstName\x12\x1b\n\tlast_name\x18\x02 \x01(\tR\x08lastName\x12\x14\n\x05\x65mail\x18\x03 \x01(\tR\x05\x65mail\x12\"\n\x0corganization\x18\x04 \x01(\tR\x0corganization\x12\x1f\n\x0buser_handle\x18\x05 \x01(\tR\nuserHandle\x12\x16\n\x06groups\x18\x06 \x03(\tR\x06groups\x12\x1b\n\tphoto_url\x18\x07 \x01(\tR\x08photoUrl\"u\n\x0b\x41pplication\x12\x37\n\x02id\x18\x01 \x01(\x0b\x32\'.flyteidl2.common.ApplicationIdentifierR\x02id\x12-\n\x04spec\x18\x02 \x01(\x0b\x32\x19.flyteidl2.common.AppSpecR\x04spec\"A\n\x07\x41ppSpec\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\"\n\x0corganization\x18\x02 \x01(\tR\x0corganization\"\x97\x01\n\x10\x45nrichedIdentity\x12,\n\x04user\x18\x01 \x01(\x0b\x32\x16.flyteidl2.common.UserH\x00R\x04user\x12\x41\n\x0b\x61pplication\x18\x02 \x01(\x0b\x32\x1d.flyteidl2.common.ApplicationH\x00R\x0b\x61pplicationB\x12\n\tprincipal\x12\x05\xbaH\x02\x08\x01\"\xa6\x01\n\x08Identity\x12;\n\x07user_id\x18\x01 \x01(\x0b\x32 .flyteidl2.common.UserIdentifierH\x00R\x06userId\x12P\n\x0e\x61pplication_id\x18\x02 \x01(\x0b\x32\'.flyteidl2.common.ApplicationIdentifierH\x00R\rapplicationIdB\x0b\n\tprincipalB\xbe\x01\n\x14\x63om.flyteidl2.commonB\rIdentityProtoH\x02P\x01Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common\xa2\x02\x03\x46\x43X\xaa\x02\x10\x46lyteidl2.Common\xca\x02\x10\x46lyteidl2\\Common\xe2\x02\x1c\x46lyteidl2\\Common\\GPBMetadata\xea\x02\x11\x46lyteidl2::Commonb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.common.identity_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\024com.flyteidl2.commonB\rIdentityProtoH\002P\001Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common\242\002\003FCX\252\002\020Flyteidl2.Common\312\002\020Flyteidl2\\Common\342\002\034Flyteidl2\\Common\\GPBMetadata\352\002\021Flyteidl2::Common' + _USER.fields_by_name['roles']._options = None + _USER.fields_by_name['roles']._serialized_options = b'\030\001' + _ENRICHEDIDENTITY.oneofs_by_name['principal']._options = None + _ENRICHEDIDENTITY.oneofs_by_name['principal']._serialized_options = b'\272H\002\010\001' + _globals['_USER']._serialized_start=178 + _globals['_USER']._serialized_end=386 + _globals['_USERSPEC']._serialized_start=389 + _globals['_USERSPEC']._serialized_end=603 + _globals['_APPLICATION']._serialized_start=605 + _globals['_APPLICATION']._serialized_end=722 + _globals['_APPSPEC']._serialized_start=724 + _globals['_APPSPEC']._serialized_end=789 + _globals['_ENRICHEDIDENTITY']._serialized_start=792 + _globals['_ENRICHEDIDENTITY']._serialized_end=943 + _globals['_IDENTITY']._serialized_start=946 + _globals['_IDENTITY']._serialized_end=1112 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/common/identity_pb2.pyi b/gen/python/flyteidl2/common/identity_pb2.pyi new file mode 100644 index 0000000000..11a8cafae2 --- /dev/null +++ b/gen/python/flyteidl2/common/identity_pb2.pyi @@ -0,0 +1,72 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.common import identifier_pb2 as _identifier_pb2 +from flyteidl2.common import policy_pb2 as _policy_pb2 +from flyteidl2.common import role_pb2 as _role_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class User(_message.Message): + __slots__ = ["id", "spec", "roles", "policies"] + ID_FIELD_NUMBER: _ClassVar[int] + SPEC_FIELD_NUMBER: _ClassVar[int] + ROLES_FIELD_NUMBER: _ClassVar[int] + POLICIES_FIELD_NUMBER: _ClassVar[int] + id: _identifier_pb2.UserIdentifier + spec: UserSpec + roles: _containers.RepeatedCompositeFieldContainer[_role_pb2.Role] + policies: _containers.RepeatedCompositeFieldContainer[_policy_pb2.Policy] + def __init__(self, id: _Optional[_Union[_identifier_pb2.UserIdentifier, _Mapping]] = ..., spec: _Optional[_Union[UserSpec, _Mapping]] = ..., roles: _Optional[_Iterable[_Union[_role_pb2.Role, _Mapping]]] = ..., policies: _Optional[_Iterable[_Union[_policy_pb2.Policy, _Mapping]]] = ...) -> None: ... + +class UserSpec(_message.Message): + __slots__ = ["first_name", "last_name", "email", "organization", "user_handle", "groups", "photo_url"] + FIRST_NAME_FIELD_NUMBER: _ClassVar[int] + LAST_NAME_FIELD_NUMBER: _ClassVar[int] + EMAIL_FIELD_NUMBER: _ClassVar[int] + ORGANIZATION_FIELD_NUMBER: _ClassVar[int] + USER_HANDLE_FIELD_NUMBER: _ClassVar[int] + GROUPS_FIELD_NUMBER: _ClassVar[int] + PHOTO_URL_FIELD_NUMBER: _ClassVar[int] + first_name: str + last_name: str + email: str + organization: str + user_handle: str + groups: _containers.RepeatedScalarFieldContainer[str] + photo_url: str + def __init__(self, first_name: _Optional[str] = ..., last_name: _Optional[str] = ..., email: _Optional[str] = ..., organization: _Optional[str] = ..., user_handle: _Optional[str] = ..., groups: _Optional[_Iterable[str]] = ..., photo_url: _Optional[str] = ...) -> None: ... + +class Application(_message.Message): + __slots__ = ["id", "spec"] + ID_FIELD_NUMBER: _ClassVar[int] + SPEC_FIELD_NUMBER: _ClassVar[int] + id: _identifier_pb2.ApplicationIdentifier + spec: AppSpec + def __init__(self, id: _Optional[_Union[_identifier_pb2.ApplicationIdentifier, _Mapping]] = ..., spec: _Optional[_Union[AppSpec, _Mapping]] = ...) -> None: ... + +class AppSpec(_message.Message): + __slots__ = ["name", "organization"] + NAME_FIELD_NUMBER: _ClassVar[int] + ORGANIZATION_FIELD_NUMBER: _ClassVar[int] + name: str + organization: str + def __init__(self, name: _Optional[str] = ..., organization: _Optional[str] = ...) -> None: ... + +class EnrichedIdentity(_message.Message): + __slots__ = ["user", "application"] + USER_FIELD_NUMBER: _ClassVar[int] + APPLICATION_FIELD_NUMBER: _ClassVar[int] + user: User + application: Application + def __init__(self, user: _Optional[_Union[User, _Mapping]] = ..., application: _Optional[_Union[Application, _Mapping]] = ...) -> None: ... + +class Identity(_message.Message): + __slots__ = ["user_id", "application_id"] + USER_ID_FIELD_NUMBER: _ClassVar[int] + APPLICATION_ID_FIELD_NUMBER: _ClassVar[int] + user_id: _identifier_pb2.UserIdentifier + application_id: _identifier_pb2.ApplicationIdentifier + def __init__(self, user_id: _Optional[_Union[_identifier_pb2.UserIdentifier, _Mapping]] = ..., application_id: _Optional[_Union[_identifier_pb2.ApplicationIdentifier, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/common/identity_pb2_grpc.py b/gen/python/flyteidl2/common/identity_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/common/identity_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/common/list_pb2.py b/gen/python/flyteidl2/common/list_pb2.py new file mode 100644 index 0000000000..9e2b20a455 --- /dev/null +++ b/gen/python/flyteidl2/common/list_pb2.py @@ -0,0 +1,36 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/common/list.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1b\x66lyteidl2/common/list.proto\x12\x10\x66lyteidl2.common\"\x84\x01\n\x04Sort\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12>\n\tdirection\x18\x02 \x01(\x0e\x32 .flyteidl2.common.Sort.DirectionR\tdirection\"*\n\tDirection\x12\x0e\n\nDESCENDING\x10\x00\x12\r\n\tASCENDING\x10\x01\"\x81\x02\n\x0bListRequest\x12\x14\n\x05limit\x18\x01 \x01(\rR\x05limit\x12\x14\n\x05token\x18\x02 \x01(\tR\x05token\x12\x33\n\x07sort_by\x18\x03 \x01(\x0b\x32\x16.flyteidl2.common.SortB\x02\x18\x01R\x06sortBy\x12\x32\n\x07\x66ilters\x18\x04 \x03(\x0b\x32\x18.flyteidl2.common.FilterR\x07\x66ilters\x12\x1f\n\x0braw_filters\x18\x05 \x03(\tR\nrawFilters\x12<\n\x0esort_by_fields\x18\x06 \x03(\x0b\x32\x16.flyteidl2.common.SortR\x0csortByFields\"\xcd\x02\n\x06\x46ilter\x12=\n\x08\x66unction\x18\x01 \x01(\x0e\x32!.flyteidl2.common.Filter.FunctionR\x08\x66unction\x12\x14\n\x05\x66ield\x18\x02 \x01(\tR\x05\x66ield\x12\x16\n\x06values\x18\x03 \x03(\tR\x06values\"\xd5\x01\n\x08\x46unction\x12\t\n\x05\x45QUAL\x10\x00\x12\r\n\tNOT_EQUAL\x10\x01\x12\x10\n\x0cGREATER_THAN\x10\x02\x12\x19\n\x15GREATER_THAN_OR_EQUAL\x10\x03\x12\r\n\tLESS_THAN\x10\x04\x12\x16\n\x12LESS_THAN_OR_EQUAL\x10\x05\x12\x0c\n\x08\x43ONTAINS\x10\x06\x12\x0c\n\x08VALUE_IN\x10\x07\x12\r\n\tENDS_WITH\x10\x0c\x12\x11\n\rNOT_ENDS_WITH\x10\r\x12\x1d\n\x19\x43ONTAINS_CASE_INSENSITIVE\x10\x0e\x42\xba\x01\n\x14\x63om.flyteidl2.commonB\tListProtoH\x02P\x01Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common\xa2\x02\x03\x46\x43X\xaa\x02\x10\x46lyteidl2.Common\xca\x02\x10\x46lyteidl2\\Common\xe2\x02\x1c\x46lyteidl2\\Common\\GPBMetadata\xea\x02\x11\x46lyteidl2::Commonb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.common.list_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\024com.flyteidl2.commonB\tListProtoH\002P\001Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common\242\002\003FCX\252\002\020Flyteidl2.Common\312\002\020Flyteidl2\\Common\342\002\034Flyteidl2\\Common\\GPBMetadata\352\002\021Flyteidl2::Common' + _LISTREQUEST.fields_by_name['sort_by']._options = None + _LISTREQUEST.fields_by_name['sort_by']._serialized_options = b'\030\001' + _globals['_SORT']._serialized_start=50 + _globals['_SORT']._serialized_end=182 + _globals['_SORT_DIRECTION']._serialized_start=140 + _globals['_SORT_DIRECTION']._serialized_end=182 + _globals['_LISTREQUEST']._serialized_start=185 + _globals['_LISTREQUEST']._serialized_end=442 + _globals['_FILTER']._serialized_start=445 + _globals['_FILTER']._serialized_end=778 + _globals['_FILTER_FUNCTION']._serialized_start=565 + _globals['_FILTER_FUNCTION']._serialized_end=778 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/common/list_pb2.pyi b/gen/python/flyteidl2/common/list_pb2.pyi new file mode 100644 index 0000000000..22000c8a47 --- /dev/null +++ b/gen/python/flyteidl2/common/list_pb2.pyi @@ -0,0 +1,71 @@ +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class Sort(_message.Message): + __slots__ = ["key", "direction"] + class Direction(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + DESCENDING: _ClassVar[Sort.Direction] + ASCENDING: _ClassVar[Sort.Direction] + DESCENDING: Sort.Direction + ASCENDING: Sort.Direction + KEY_FIELD_NUMBER: _ClassVar[int] + DIRECTION_FIELD_NUMBER: _ClassVar[int] + key: str + direction: Sort.Direction + def __init__(self, key: _Optional[str] = ..., direction: _Optional[_Union[Sort.Direction, str]] = ...) -> None: ... + +class ListRequest(_message.Message): + __slots__ = ["limit", "token", "sort_by", "filters", "raw_filters", "sort_by_fields"] + LIMIT_FIELD_NUMBER: _ClassVar[int] + TOKEN_FIELD_NUMBER: _ClassVar[int] + SORT_BY_FIELD_NUMBER: _ClassVar[int] + FILTERS_FIELD_NUMBER: _ClassVar[int] + RAW_FILTERS_FIELD_NUMBER: _ClassVar[int] + SORT_BY_FIELDS_FIELD_NUMBER: _ClassVar[int] + limit: int + token: str + sort_by: Sort + filters: _containers.RepeatedCompositeFieldContainer[Filter] + raw_filters: _containers.RepeatedScalarFieldContainer[str] + sort_by_fields: _containers.RepeatedCompositeFieldContainer[Sort] + def __init__(self, limit: _Optional[int] = ..., token: _Optional[str] = ..., sort_by: _Optional[_Union[Sort, _Mapping]] = ..., filters: _Optional[_Iterable[_Union[Filter, _Mapping]]] = ..., raw_filters: _Optional[_Iterable[str]] = ..., sort_by_fields: _Optional[_Iterable[_Union[Sort, _Mapping]]] = ...) -> None: ... + +class Filter(_message.Message): + __slots__ = ["function", "field", "values"] + class Function(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + EQUAL: _ClassVar[Filter.Function] + NOT_EQUAL: _ClassVar[Filter.Function] + GREATER_THAN: _ClassVar[Filter.Function] + GREATER_THAN_OR_EQUAL: _ClassVar[Filter.Function] + LESS_THAN: _ClassVar[Filter.Function] + LESS_THAN_OR_EQUAL: _ClassVar[Filter.Function] + CONTAINS: _ClassVar[Filter.Function] + VALUE_IN: _ClassVar[Filter.Function] + ENDS_WITH: _ClassVar[Filter.Function] + NOT_ENDS_WITH: _ClassVar[Filter.Function] + CONTAINS_CASE_INSENSITIVE: _ClassVar[Filter.Function] + EQUAL: Filter.Function + NOT_EQUAL: Filter.Function + GREATER_THAN: Filter.Function + GREATER_THAN_OR_EQUAL: Filter.Function + LESS_THAN: Filter.Function + LESS_THAN_OR_EQUAL: Filter.Function + CONTAINS: Filter.Function + VALUE_IN: Filter.Function + ENDS_WITH: Filter.Function + NOT_ENDS_WITH: Filter.Function + CONTAINS_CASE_INSENSITIVE: Filter.Function + FUNCTION_FIELD_NUMBER: _ClassVar[int] + FIELD_FIELD_NUMBER: _ClassVar[int] + VALUES_FIELD_NUMBER: _ClassVar[int] + function: Filter.Function + field: str + values: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, function: _Optional[_Union[Filter.Function, str]] = ..., field: _Optional[str] = ..., values: _Optional[_Iterable[str]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/common/list_pb2_grpc.py b/gen/python/flyteidl2/common/list_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/common/list_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/common/phase_pb2.py b/gen/python/flyteidl2/common/phase_pb2.py new file mode 100644 index 0000000000..868f35376e --- /dev/null +++ b/gen/python/flyteidl2/common/phase_pb2.py @@ -0,0 +1,26 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/common/phase.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1c\x66lyteidl2/common/phase.proto\x12\x10\x66lyteidl2.common*\x90\x02\n\x0b\x41\x63tionPhase\x12\x1c\n\x18\x41\x43TION_PHASE_UNSPECIFIED\x10\x00\x12\x17\n\x13\x41\x43TION_PHASE_QUEUED\x10\x01\x12&\n\"ACTION_PHASE_WAITING_FOR_RESOURCES\x10\x02\x12\x1d\n\x19\x41\x43TION_PHASE_INITIALIZING\x10\x03\x12\x18\n\x14\x41\x43TION_PHASE_RUNNING\x10\x04\x12\x1a\n\x16\x41\x43TION_PHASE_SUCCEEDED\x10\x05\x12\x17\n\x13\x41\x43TION_PHASE_FAILED\x10\x06\x12\x18\n\x14\x41\x43TION_PHASE_ABORTED\x10\x07\x12\x1a\n\x16\x41\x43TION_PHASE_TIMED_OUT\x10\x08\x42\xbb\x01\n\x14\x63om.flyteidl2.commonB\nPhaseProtoH\x02P\x01Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common\xa2\x02\x03\x46\x43X\xaa\x02\x10\x46lyteidl2.Common\xca\x02\x10\x46lyteidl2\\Common\xe2\x02\x1c\x46lyteidl2\\Common\\GPBMetadata\xea\x02\x11\x46lyteidl2::Commonb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.common.phase_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\024com.flyteidl2.commonB\nPhaseProtoH\002P\001Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common\242\002\003FCX\252\002\020Flyteidl2.Common\312\002\020Flyteidl2\\Common\342\002\034Flyteidl2\\Common\\GPBMetadata\352\002\021Flyteidl2::Common' + _globals['_ACTIONPHASE']._serialized_start=51 + _globals['_ACTIONPHASE']._serialized_end=323 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/common/phase_pb2.pyi b/gen/python/flyteidl2/common/phase_pb2.pyi new file mode 100644 index 0000000000..338ddc321f --- /dev/null +++ b/gen/python/flyteidl2/common/phase_pb2.pyi @@ -0,0 +1,26 @@ +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from typing import ClassVar as _ClassVar + +DESCRIPTOR: _descriptor.FileDescriptor + +class ActionPhase(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + ACTION_PHASE_UNSPECIFIED: _ClassVar[ActionPhase] + ACTION_PHASE_QUEUED: _ClassVar[ActionPhase] + ACTION_PHASE_WAITING_FOR_RESOURCES: _ClassVar[ActionPhase] + ACTION_PHASE_INITIALIZING: _ClassVar[ActionPhase] + ACTION_PHASE_RUNNING: _ClassVar[ActionPhase] + ACTION_PHASE_SUCCEEDED: _ClassVar[ActionPhase] + ACTION_PHASE_FAILED: _ClassVar[ActionPhase] + ACTION_PHASE_ABORTED: _ClassVar[ActionPhase] + ACTION_PHASE_TIMED_OUT: _ClassVar[ActionPhase] +ACTION_PHASE_UNSPECIFIED: ActionPhase +ACTION_PHASE_QUEUED: ActionPhase +ACTION_PHASE_WAITING_FOR_RESOURCES: ActionPhase +ACTION_PHASE_INITIALIZING: ActionPhase +ACTION_PHASE_RUNNING: ActionPhase +ACTION_PHASE_SUCCEEDED: ActionPhase +ACTION_PHASE_FAILED: ActionPhase +ACTION_PHASE_ABORTED: ActionPhase +ACTION_PHASE_TIMED_OUT: ActionPhase diff --git a/gen/python/flyteidl2/common/phase_pb2_grpc.py b/gen/python/flyteidl2/common/phase_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/common/phase_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/common/policy_pb2.py b/gen/python/flyteidl2/common/policy_pb2.py new file mode 100644 index 0000000000..6d053e7cfc --- /dev/null +++ b/gen/python/flyteidl2/common/policy_pb2.py @@ -0,0 +1,37 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/common/policy.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.common import authorization_pb2 as flyteidl2_dot_common_dot_authorization__pb2 +from flyteidl2.common import identifier_pb2 as flyteidl2_dot_common_dot_identifier__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1d\x66lyteidl2/common/policy.proto\x12\x10\x66lyteidl2.common\x1a\x1b\x62uf/validate/validate.proto\x1a$flyteidl2/common/authorization.proto\x1a!flyteidl2/common/identifier.proto\"\xa3\x01\n\x06Policy\x12:\n\x02id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.PolicyIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x02id\x12;\n\x08\x62indings\x18\x02 \x03(\x0b\x32\x1f.flyteidl2.common.PolicyBindingR\x08\x62indings\x12 \n\x0b\x64\x65scription\x18\x03 \x01(\tR\x0b\x64\x65scription\"\x92\x01\n\rPolicyBinding\x12\x41\n\x07role_id\x18\x01 \x01(\x0b\x32 .flyteidl2.common.RoleIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x06roleId\x12>\n\x08resource\x18\x02 \x01(\x0b\x32\x1a.flyteidl2.common.ResourceB\x06\xbaH\x03\xc8\x01\x01R\x08resourceB\xbc\x01\n\x14\x63om.flyteidl2.commonB\x0bPolicyProtoH\x02P\x01Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common\xa2\x02\x03\x46\x43X\xaa\x02\x10\x46lyteidl2.Common\xca\x02\x10\x46lyteidl2\\Common\xe2\x02\x1c\x46lyteidl2\\Common\\GPBMetadata\xea\x02\x11\x46lyteidl2::Commonb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.common.policy_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\024com.flyteidl2.commonB\013PolicyProtoH\002P\001Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common\242\002\003FCX\252\002\020Flyteidl2.Common\312\002\020Flyteidl2\\Common\342\002\034Flyteidl2\\Common\\GPBMetadata\352\002\021Flyteidl2::Common' + _POLICY.fields_by_name['id']._options = None + _POLICY.fields_by_name['id']._serialized_options = b'\272H\003\310\001\001' + _POLICYBINDING.fields_by_name['role_id']._options = None + _POLICYBINDING.fields_by_name['role_id']._serialized_options = b'\272H\003\310\001\001' + _POLICYBINDING.fields_by_name['resource']._options = None + _POLICYBINDING.fields_by_name['resource']._serialized_options = b'\272H\003\310\001\001' + _globals['_POLICY']._serialized_start=154 + _globals['_POLICY']._serialized_end=317 + _globals['_POLICYBINDING']._serialized_start=320 + _globals['_POLICYBINDING']._serialized_end=466 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/common/policy_pb2.pyi b/gen/python/flyteidl2/common/policy_pb2.pyi new file mode 100644 index 0000000000..5380f62ceb --- /dev/null +++ b/gen/python/flyteidl2/common/policy_pb2.pyi @@ -0,0 +1,27 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.common import authorization_pb2 as _authorization_pb2 +from flyteidl2.common import identifier_pb2 as _identifier_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class Policy(_message.Message): + __slots__ = ["id", "bindings", "description"] + ID_FIELD_NUMBER: _ClassVar[int] + BINDINGS_FIELD_NUMBER: _ClassVar[int] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + id: _identifier_pb2.PolicyIdentifier + bindings: _containers.RepeatedCompositeFieldContainer[PolicyBinding] + description: str + def __init__(self, id: _Optional[_Union[_identifier_pb2.PolicyIdentifier, _Mapping]] = ..., bindings: _Optional[_Iterable[_Union[PolicyBinding, _Mapping]]] = ..., description: _Optional[str] = ...) -> None: ... + +class PolicyBinding(_message.Message): + __slots__ = ["role_id", "resource"] + ROLE_ID_FIELD_NUMBER: _ClassVar[int] + RESOURCE_FIELD_NUMBER: _ClassVar[int] + role_id: _identifier_pb2.RoleIdentifier + resource: _authorization_pb2.Resource + def __init__(self, role_id: _Optional[_Union[_identifier_pb2.RoleIdentifier, _Mapping]] = ..., resource: _Optional[_Union[_authorization_pb2.Resource, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/common/policy_pb2_grpc.py b/gen/python/flyteidl2/common/policy_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/common/policy_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/common/role_pb2.py b/gen/python/flyteidl2/common/role_pb2.py new file mode 100644 index 0000000000..5fb64ac339 --- /dev/null +++ b/gen/python/flyteidl2/common/role_pb2.py @@ -0,0 +1,37 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/common/role.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.common import authorization_pb2 as flyteidl2_dot_common_dot_authorization__pb2 +from flyteidl2.common import identifier_pb2 as flyteidl2_dot_common_dot_identifier__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1b\x66lyteidl2/common/role.proto\x12\x10\x66lyteidl2.common\x1a\x1b\x62uf/validate/validate.proto\x1a$flyteidl2/common/authorization.proto\x1a!flyteidl2/common/identifier.proto\"\xaa\x02\n\x04Role\x12\x38\n\x02id\x18\x01 \x01(\x0b\x32 .flyteidl2.common.RoleIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x02id\x12\x42\n\x0bpermissions\x18\x02 \x03(\x0b\x32\x1c.flyteidl2.common.PermissionB\x02\x18\x01R\x0bpermissions\x12\x37\n\trole_spec\x18\x03 \x01(\x0b\x32\x1a.flyteidl2.common.RoleSpecR\x08roleSpec\x12\x37\n\trole_type\x18\x04 \x01(\x0e\x32\x1a.flyteidl2.common.RoleTypeR\x08roleType\x12\x32\n\x07\x61\x63tions\x18\x05 \x03(\x0e\x32\x18.flyteidl2.common.ActionR\x07\x61\x63tions\",\n\x08RoleSpec\x12 \n\x0b\x64\x65scription\x18\x01 \x01(\tR\x0b\x64\x65scription*\x9a\x02\n\x08RoleType\x12\x12\n\x0eROLE_TYPE_NONE\x10\x00\x12\x13\n\x0fROLE_TYPE_ADMIN\x10\x01\x12\x19\n\x15ROLE_TYPE_CONTRIBUTOR\x10\x02\x12\x14\n\x10ROLE_TYPE_VIEWER\x10\x03\x12\x14\n\x10ROLE_TYPE_CUSTOM\x10\x04\x12\x1d\n\x19ROLE_TYPE_CLUSTER_MANAGER\x10\x05\x12!\n\x1dROLE_TYPE_FLYTE_PROJECT_ADMIN\x10\x06\x12\x1f\n\x1bROLE_TYPE_SERVERLESS_VIEWER\x10\x07\x12$\n ROLE_TYPE_SERVERLESS_CONTRIBUTOR\x10\x08\x12\x15\n\x11ROLE_TYPE_SUPPORT\x10\tB\xba\x01\n\x14\x63om.flyteidl2.commonB\tRoleProtoH\x02P\x01Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common\xa2\x02\x03\x46\x43X\xaa\x02\x10\x46lyteidl2.Common\xca\x02\x10\x46lyteidl2\\Common\xe2\x02\x1c\x46lyteidl2\\Common\\GPBMetadata\xea\x02\x11\x46lyteidl2::Commonb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.common.role_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\024com.flyteidl2.commonB\tRoleProtoH\002P\001Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common\242\002\003FCX\252\002\020Flyteidl2.Common\312\002\020Flyteidl2\\Common\342\002\034Flyteidl2\\Common\\GPBMetadata\352\002\021Flyteidl2::Common' + _ROLE.fields_by_name['id']._options = None + _ROLE.fields_by_name['id']._serialized_options = b'\272H\003\310\001\001' + _ROLE.fields_by_name['permissions']._options = None + _ROLE.fields_by_name['permissions']._serialized_options = b'\030\001' + _globals['_ROLETYPE']._serialized_start=499 + _globals['_ROLETYPE']._serialized_end=781 + _globals['_ROLE']._serialized_start=152 + _globals['_ROLE']._serialized_end=450 + _globals['_ROLESPEC']._serialized_start=452 + _globals['_ROLESPEC']._serialized_end=496 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/common/role_pb2.pyi b/gen/python/flyteidl2/common/role_pb2.pyi new file mode 100644 index 0000000000..31df8c4a81 --- /dev/null +++ b/gen/python/flyteidl2/common/role_pb2.pyi @@ -0,0 +1,53 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.common import authorization_pb2 as _authorization_pb2 +from flyteidl2.common import identifier_pb2 as _identifier_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class RoleType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + ROLE_TYPE_NONE: _ClassVar[RoleType] + ROLE_TYPE_ADMIN: _ClassVar[RoleType] + ROLE_TYPE_CONTRIBUTOR: _ClassVar[RoleType] + ROLE_TYPE_VIEWER: _ClassVar[RoleType] + ROLE_TYPE_CUSTOM: _ClassVar[RoleType] + ROLE_TYPE_CLUSTER_MANAGER: _ClassVar[RoleType] + ROLE_TYPE_FLYTE_PROJECT_ADMIN: _ClassVar[RoleType] + ROLE_TYPE_SERVERLESS_VIEWER: _ClassVar[RoleType] + ROLE_TYPE_SERVERLESS_CONTRIBUTOR: _ClassVar[RoleType] + ROLE_TYPE_SUPPORT: _ClassVar[RoleType] +ROLE_TYPE_NONE: RoleType +ROLE_TYPE_ADMIN: RoleType +ROLE_TYPE_CONTRIBUTOR: RoleType +ROLE_TYPE_VIEWER: RoleType +ROLE_TYPE_CUSTOM: RoleType +ROLE_TYPE_CLUSTER_MANAGER: RoleType +ROLE_TYPE_FLYTE_PROJECT_ADMIN: RoleType +ROLE_TYPE_SERVERLESS_VIEWER: RoleType +ROLE_TYPE_SERVERLESS_CONTRIBUTOR: RoleType +ROLE_TYPE_SUPPORT: RoleType + +class Role(_message.Message): + __slots__ = ["id", "permissions", "role_spec", "role_type", "actions"] + ID_FIELD_NUMBER: _ClassVar[int] + PERMISSIONS_FIELD_NUMBER: _ClassVar[int] + ROLE_SPEC_FIELD_NUMBER: _ClassVar[int] + ROLE_TYPE_FIELD_NUMBER: _ClassVar[int] + ACTIONS_FIELD_NUMBER: _ClassVar[int] + id: _identifier_pb2.RoleIdentifier + permissions: _containers.RepeatedCompositeFieldContainer[_authorization_pb2.Permission] + role_spec: RoleSpec + role_type: RoleType + actions: _containers.RepeatedScalarFieldContainer[_authorization_pb2.Action] + def __init__(self, id: _Optional[_Union[_identifier_pb2.RoleIdentifier, _Mapping]] = ..., permissions: _Optional[_Iterable[_Union[_authorization_pb2.Permission, _Mapping]]] = ..., role_spec: _Optional[_Union[RoleSpec, _Mapping]] = ..., role_type: _Optional[_Union[RoleType, str]] = ..., actions: _Optional[_Iterable[_Union[_authorization_pb2.Action, str]]] = ...) -> None: ... + +class RoleSpec(_message.Message): + __slots__ = ["description"] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + description: str + def __init__(self, description: _Optional[str] = ...) -> None: ... diff --git a/gen/python/flyteidl2/common/role_pb2_grpc.py b/gen/python/flyteidl2/common/role_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/common/role_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/common/runtime_version_pb2.py b/gen/python/flyteidl2/common/runtime_version_pb2.py new file mode 100644 index 0000000000..e003904f65 --- /dev/null +++ b/gen/python/flyteidl2/common/runtime_version_pb2.py @@ -0,0 +1,28 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/common/runtime_version.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n&flyteidl2/common/runtime_version.proto\x12\x10\x66lyteidl2.common\"\xbe\x01\n\x0fRuntimeMetadata\x12\x41\n\x04type\x18\x01 \x01(\x0e\x32-.flyteidl2.common.RuntimeMetadata.RuntimeTypeR\x04type\x12\x18\n\x07version\x18\x02 \x01(\tR\x07version\x12\x16\n\x06\x66lavor\x18\x03 \x01(\tR\x06\x66lavor\"6\n\x0bRuntimeType\x12\t\n\x05OTHER\x10\x00\x12\r\n\tFLYTE_SDK\x10\x01\x12\r\n\tUNION_SDK\x10\x02\x42\xc4\x01\n\x14\x63om.flyteidl2.commonB\x13RuntimeVersionProtoH\x02P\x01Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common\xa2\x02\x03\x46\x43X\xaa\x02\x10\x46lyteidl2.Common\xca\x02\x10\x46lyteidl2\\Common\xe2\x02\x1c\x46lyteidl2\\Common\\GPBMetadata\xea\x02\x11\x46lyteidl2::Commonb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.common.runtime_version_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\024com.flyteidl2.commonB\023RuntimeVersionProtoH\002P\001Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common\242\002\003FCX\252\002\020Flyteidl2.Common\312\002\020Flyteidl2\\Common\342\002\034Flyteidl2\\Common\\GPBMetadata\352\002\021Flyteidl2::Common' + _globals['_RUNTIMEMETADATA']._serialized_start=61 + _globals['_RUNTIMEMETADATA']._serialized_end=251 + _globals['_RUNTIMEMETADATA_RUNTIMETYPE']._serialized_start=197 + _globals['_RUNTIMEMETADATA_RUNTIMETYPE']._serialized_end=251 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/common/runtime_version_pb2.pyi b/gen/python/flyteidl2/common/runtime_version_pb2.pyi new file mode 100644 index 0000000000..7627e77c98 --- /dev/null +++ b/gen/python/flyteidl2/common/runtime_version_pb2.pyi @@ -0,0 +1,24 @@ +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class RuntimeMetadata(_message.Message): + __slots__ = ["type", "version", "flavor"] + class RuntimeType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + OTHER: _ClassVar[RuntimeMetadata.RuntimeType] + FLYTE_SDK: _ClassVar[RuntimeMetadata.RuntimeType] + UNION_SDK: _ClassVar[RuntimeMetadata.RuntimeType] + OTHER: RuntimeMetadata.RuntimeType + FLYTE_SDK: RuntimeMetadata.RuntimeType + UNION_SDK: RuntimeMetadata.RuntimeType + TYPE_FIELD_NUMBER: _ClassVar[int] + VERSION_FIELD_NUMBER: _ClassVar[int] + FLAVOR_FIELD_NUMBER: _ClassVar[int] + type: RuntimeMetadata.RuntimeType + version: str + flavor: str + def __init__(self, type: _Optional[_Union[RuntimeMetadata.RuntimeType, str]] = ..., version: _Optional[str] = ..., flavor: _Optional[str] = ...) -> None: ... diff --git a/gen/python/flyteidl2/common/runtime_version_pb2_grpc.py b/gen/python/flyteidl2/common/runtime_version_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/common/runtime_version_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/connector/__init__.py b/gen/python/flyteidl2/connector/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/connector/connector_pb2.py b/gen/python/flyteidl2/connector/connector_pb2.py new file mode 100644 index 0000000000..16324f619a --- /dev/null +++ b/gen/python/flyteidl2/connector/connector_pb2.py @@ -0,0 +1,87 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/connector/connector.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.core import execution_pb2 as flyteidl2_dot_core_dot_execution__pb2 +from flyteidl2.core import identifier_pb2 as flyteidl2_dot_core_dot_identifier__pb2 +from flyteidl2.core import metrics_pb2 as flyteidl2_dot_core_dot_metrics__pb2 +from flyteidl2.core import security_pb2 as flyteidl2_dot_core_dot_security__pb2 +from flyteidl2.core import tasks_pb2 as flyteidl2_dot_core_dot_tasks__pb2 +from flyteidl2.task import common_pb2 as flyteidl2_dot_task_dot_common__pb2 +from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 +from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n#flyteidl2/connector/connector.proto\x12\x13\x66lyteidl2.connector\x1a\x1e\x66lyteidl2/core/execution.proto\x1a\x1f\x66lyteidl2/core/identifier.proto\x1a\x1c\x66lyteidl2/core/metrics.proto\x1a\x1d\x66lyteidl2/core/security.proto\x1a\x1a\x66lyteidl2/core/tasks.proto\x1a\x1b\x66lyteidl2/task/common.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xef\x06\n\x15TaskExecutionMetadata\x12S\n\x11task_execution_id\x18\x01 \x01(\x0b\x32\'.flyteidl2.core.TaskExecutionIdentifierR\x0ftaskExecutionId\x12\x1c\n\tnamespace\x18\x02 \x01(\tR\tnamespace\x12N\n\x06labels\x18\x03 \x03(\x0b\x32\x36.flyteidl2.connector.TaskExecutionMetadata.LabelsEntryR\x06labels\x12]\n\x0b\x61nnotations\x18\x04 \x03(\x0b\x32;.flyteidl2.connector.TaskExecutionMetadata.AnnotationsEntryR\x0b\x61nnotations\x12.\n\x13k8s_service_account\x18\x05 \x01(\tR\x11k8sServiceAccount\x12y\n\x15\x65nvironment_variables\x18\x06 \x03(\x0b\x32\x44.flyteidl2.connector.TaskExecutionMetadata.EnvironmentVariablesEntryR\x14\x65nvironmentVariables\x12!\n\x0cmax_attempts\x18\x07 \x01(\x05R\x0bmaxAttempts\x12$\n\rinterruptible\x18\x08 \x01(\x08R\rinterruptible\x12\x46\n\x1finterruptible_failure_threshold\x18\t \x01(\x05R\x1dinterruptibleFailureThreshold\x12\x34\n\x08identity\x18\x0b \x01(\x0b\x32\x18.flyteidl2.core.IdentityR\x08identity\x1a\x39\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x1a>\n\x10\x41nnotationsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x1aG\n\x19\x45nvironmentVariablesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\xc2\x02\n\x11\x43reateTaskRequest\x12.\n\x06inputs\x18\x01 \x01(\x0b\x32\x16.flyteidl2.task.InputsR\x06inputs\x12\x38\n\x08template\x18\x02 \x01(\x0b\x32\x1c.flyteidl2.core.TaskTemplateR\x08template\x12#\n\routput_prefix\x18\x03 \x01(\tR\x0coutputPrefix\x12\x62\n\x17task_execution_metadata\x18\x04 \x01(\x0b\x32*.flyteidl2.connector.TaskExecutionMetadataR\x15taskExecutionMetadata\x12:\n\nconnection\x18\x05 \x01(\x0b\x32\x1a.flyteidl2.core.ConnectionR\nconnection\"9\n\x12\x43reateTaskResponse\x12#\n\rresource_meta\x18\x01 \x01(\x0cR\x0cresourceMeta\"\xc9\x02\n\x13\x43reateRequestHeader\x12\x38\n\x08template\x18\x01 \x01(\x0b\x32\x1c.flyteidl2.core.TaskTemplateR\x08template\x12#\n\routput_prefix\x18\x02 \x01(\tR\x0coutputPrefix\x12\x62\n\x17task_execution_metadata\x18\x03 \x01(\x0b\x32*.flyteidl2.connector.TaskExecutionMetadataR\x15taskExecutionMetadata\x12\x33\n\x16max_dataset_size_bytes\x18\x04 \x01(\x03R\x13maxDatasetSizeBytes\x12:\n\nconnection\x18\x05 \x01(\x0b\x32\x1a.flyteidl2.core.ConnectionR\nconnection\"\xde\x01\n\x0eGetTaskRequest\x12#\n\rresource_meta\x18\x02 \x01(\x0cR\x0cresourceMeta\x12\x46\n\rtask_category\x18\x03 \x01(\x0b\x32!.flyteidl2.connector.TaskCategoryR\x0ctaskCategory\x12#\n\routput_prefix\x18\x04 \x01(\tR\x0coutputPrefix\x12:\n\nconnection\x18\x05 \x01(\x0b\x32\x1a.flyteidl2.core.ConnectionR\nconnection\"L\n\x0fGetTaskResponse\x12\x39\n\x08resource\x18\x01 \x01(\x0b\x32\x1d.flyteidl2.connector.ResourceR\x08resource\"\x82\x02\n\x08Resource\x12\x31\n\x07outputs\x18\x02 \x01(\x0b\x32\x17.flyteidl2.task.OutputsR\x07outputs\x12\x18\n\x07message\x18\x03 \x01(\tR\x07message\x12\x34\n\tlog_links\x18\x04 \x03(\x0b\x32\x17.flyteidl2.core.TaskLogR\x08logLinks\x12\x39\n\x05phase\x18\x05 \x01(\x0e\x32#.flyteidl2.core.TaskExecution.PhaseR\x05phase\x12\x38\n\x0b\x63ustom_info\x18\x06 \x01(\x0b\x32\x17.google.protobuf.StructR\ncustomInfo\"\xbc\x01\n\x11\x44\x65leteTaskRequest\x12#\n\rresource_meta\x18\x02 \x01(\x0cR\x0cresourceMeta\x12\x46\n\rtask_category\x18\x03 \x01(\x0b\x32!.flyteidl2.connector.TaskCategoryR\x0ctaskCategory\x12:\n\nconnection\x18\x05 \x01(\x0b\x32\x1a.flyteidl2.core.ConnectionR\nconnection\"\x14\n\x12\x44\x65leteTaskResponse\"~\n\tConnector\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12]\n\x19supported_task_categories\x18\x04 \x03(\x0b\x32!.flyteidl2.connector.TaskCategoryR\x17supportedTaskCategories\"<\n\x0cTaskCategory\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x18\n\x07version\x18\x02 \x01(\x05R\x07version\")\n\x13GetConnectorRequest\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\"T\n\x14GetConnectorResponse\x12<\n\tconnector\x18\x01 \x01(\x0b\x32\x1e.flyteidl2.connector.ConnectorR\tconnector\"\x17\n\x15ListConnectorsRequest\"X\n\x16ListConnectorsResponse\x12>\n\nconnectors\x18\x01 \x03(\x0b\x32\x1e.flyteidl2.connector.ConnectorR\nconnectors\"\xbf\x02\n\x15GetTaskMetricsRequest\x12#\n\rresource_meta\x18\x02 \x01(\x0cR\x0cresourceMeta\x12\x18\n\x07queries\x18\x03 \x03(\tR\x07queries\x12\x39\n\nstart_time\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\tstartTime\x12\x35\n\x08\x65nd_time\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x07\x65ndTime\x12-\n\x04step\x18\x06 \x01(\x0b\x32\x19.google.protobuf.DurationR\x04step\x12\x46\n\rtask_category\x18\x07 \x01(\x0b\x32!.flyteidl2.connector.TaskCategoryR\x0ctaskCategory\"Y\n\x16GetTaskMetricsResponse\x12?\n\x07results\x18\x01 \x03(\x0b\x32%.flyteidl2.core.ExecutionMetricResultR\x07results\"\xad\x01\n\x12GetTaskLogsRequest\x12#\n\rresource_meta\x18\x02 \x01(\x0cR\x0cresourceMeta\x12\x14\n\x05lines\x18\x03 \x01(\x04R\x05lines\x12\x14\n\x05token\x18\x04 \x01(\tR\x05token\x12\x46\n\rtask_category\x18\x05 \x01(\x0b\x32!.flyteidl2.connector.TaskCategoryR\x0ctaskCategory\"1\n\x19GetTaskLogsResponseHeader\x12\x14\n\x05token\x18\x01 \x01(\tR\x05token\"3\n\x17GetTaskLogsResponseBody\x12\x18\n\x07results\x18\x01 \x03(\tR\x07results\"\xab\x01\n\x13GetTaskLogsResponse\x12H\n\x06header\x18\x01 \x01(\x0b\x32..flyteidl2.connector.GetTaskLogsResponseHeaderH\x00R\x06header\x12\x42\n\x04\x62ody\x18\x02 \x01(\x0b\x32,.flyteidl2.connector.GetTaskLogsResponseBodyH\x00R\x04\x62odyB\x06\n\x04partB\xd1\x01\n\x17\x63om.flyteidl2.connectorB\x0e\x43onnectorProtoH\x02P\x01Z7github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector\xa2\x02\x03\x46\x43X\xaa\x02\x13\x46lyteidl2.Connector\xca\x02\x13\x46lyteidl2\\Connector\xe2\x02\x1f\x46lyteidl2\\Connector\\GPBMetadata\xea\x02\x14\x46lyteidl2::Connectorb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.connector.connector_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\027com.flyteidl2.connectorB\016ConnectorProtoH\002P\001Z7github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector\242\002\003FCX\252\002\023Flyteidl2.Connector\312\002\023Flyteidl2\\Connector\342\002\037Flyteidl2\\Connector\\GPBMetadata\352\002\024Flyteidl2::Connector' + _TASKEXECUTIONMETADATA_LABELSENTRY._options = None + _TASKEXECUTIONMETADATA_LABELSENTRY._serialized_options = b'8\001' + _TASKEXECUTIONMETADATA_ANNOTATIONSENTRY._options = None + _TASKEXECUTIONMETADATA_ANNOTATIONSENTRY._serialized_options = b'8\001' + _TASKEXECUTIONMETADATA_ENVIRONMENTVARIABLESENTRY._options = None + _TASKEXECUTIONMETADATA_ENVIRONMENTVARIABLESENTRY._serialized_options = b'8\001' + _globals['_TASKEXECUTIONMETADATA']._serialized_start=339 + _globals['_TASKEXECUTIONMETADATA']._serialized_end=1218 + _globals['_TASKEXECUTIONMETADATA_LABELSENTRY']._serialized_start=1024 + _globals['_TASKEXECUTIONMETADATA_LABELSENTRY']._serialized_end=1081 + _globals['_TASKEXECUTIONMETADATA_ANNOTATIONSENTRY']._serialized_start=1083 + _globals['_TASKEXECUTIONMETADATA_ANNOTATIONSENTRY']._serialized_end=1145 + _globals['_TASKEXECUTIONMETADATA_ENVIRONMENTVARIABLESENTRY']._serialized_start=1147 + _globals['_TASKEXECUTIONMETADATA_ENVIRONMENTVARIABLESENTRY']._serialized_end=1218 + _globals['_CREATETASKREQUEST']._serialized_start=1221 + _globals['_CREATETASKREQUEST']._serialized_end=1543 + _globals['_CREATETASKRESPONSE']._serialized_start=1545 + _globals['_CREATETASKRESPONSE']._serialized_end=1602 + _globals['_CREATEREQUESTHEADER']._serialized_start=1605 + _globals['_CREATEREQUESTHEADER']._serialized_end=1934 + _globals['_GETTASKREQUEST']._serialized_start=1937 + _globals['_GETTASKREQUEST']._serialized_end=2159 + _globals['_GETTASKRESPONSE']._serialized_start=2161 + _globals['_GETTASKRESPONSE']._serialized_end=2237 + _globals['_RESOURCE']._serialized_start=2240 + _globals['_RESOURCE']._serialized_end=2498 + _globals['_DELETETASKREQUEST']._serialized_start=2501 + _globals['_DELETETASKREQUEST']._serialized_end=2689 + _globals['_DELETETASKRESPONSE']._serialized_start=2691 + _globals['_DELETETASKRESPONSE']._serialized_end=2711 + _globals['_CONNECTOR']._serialized_start=2713 + _globals['_CONNECTOR']._serialized_end=2839 + _globals['_TASKCATEGORY']._serialized_start=2841 + _globals['_TASKCATEGORY']._serialized_end=2901 + _globals['_GETCONNECTORREQUEST']._serialized_start=2903 + _globals['_GETCONNECTORREQUEST']._serialized_end=2944 + _globals['_GETCONNECTORRESPONSE']._serialized_start=2946 + _globals['_GETCONNECTORRESPONSE']._serialized_end=3030 + _globals['_LISTCONNECTORSREQUEST']._serialized_start=3032 + _globals['_LISTCONNECTORSREQUEST']._serialized_end=3055 + _globals['_LISTCONNECTORSRESPONSE']._serialized_start=3057 + _globals['_LISTCONNECTORSRESPONSE']._serialized_end=3145 + _globals['_GETTASKMETRICSREQUEST']._serialized_start=3148 + _globals['_GETTASKMETRICSREQUEST']._serialized_end=3467 + _globals['_GETTASKMETRICSRESPONSE']._serialized_start=3469 + _globals['_GETTASKMETRICSRESPONSE']._serialized_end=3558 + _globals['_GETTASKLOGSREQUEST']._serialized_start=3561 + _globals['_GETTASKLOGSREQUEST']._serialized_end=3734 + _globals['_GETTASKLOGSRESPONSEHEADER']._serialized_start=3736 + _globals['_GETTASKLOGSRESPONSEHEADER']._serialized_end=3785 + _globals['_GETTASKLOGSRESPONSEBODY']._serialized_start=3787 + _globals['_GETTASKLOGSRESPONSEBODY']._serialized_end=3838 + _globals['_GETTASKLOGSRESPONSE']._serialized_start=3841 + _globals['_GETTASKLOGSRESPONSE']._serialized_end=4012 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/connector/connector_pb2.pyi b/gen/python/flyteidl2/connector/connector_pb2.pyi new file mode 100644 index 0000000000..e0df04da71 --- /dev/null +++ b/gen/python/flyteidl2/connector/connector_pb2.pyi @@ -0,0 +1,232 @@ +from flyteidl2.core import execution_pb2 as _execution_pb2 +from flyteidl2.core import identifier_pb2 as _identifier_pb2 +from flyteidl2.core import metrics_pb2 as _metrics_pb2 +from flyteidl2.core import security_pb2 as _security_pb2 +from flyteidl2.core import tasks_pb2 as _tasks_pb2 +from flyteidl2.task import common_pb2 as _common_pb2 +from google.protobuf import duration_pb2 as _duration_pb2 +from google.protobuf import struct_pb2 as _struct_pb2 +from google.protobuf import timestamp_pb2 as _timestamp_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class TaskExecutionMetadata(_message.Message): + __slots__ = ["task_execution_id", "namespace", "labels", "annotations", "k8s_service_account", "environment_variables", "max_attempts", "interruptible", "interruptible_failure_threshold", "identity"] + class LabelsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + class AnnotationsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + class EnvironmentVariablesEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + TASK_EXECUTION_ID_FIELD_NUMBER: _ClassVar[int] + NAMESPACE_FIELD_NUMBER: _ClassVar[int] + LABELS_FIELD_NUMBER: _ClassVar[int] + ANNOTATIONS_FIELD_NUMBER: _ClassVar[int] + K8S_SERVICE_ACCOUNT_FIELD_NUMBER: _ClassVar[int] + ENVIRONMENT_VARIABLES_FIELD_NUMBER: _ClassVar[int] + MAX_ATTEMPTS_FIELD_NUMBER: _ClassVar[int] + INTERRUPTIBLE_FIELD_NUMBER: _ClassVar[int] + INTERRUPTIBLE_FAILURE_THRESHOLD_FIELD_NUMBER: _ClassVar[int] + IDENTITY_FIELD_NUMBER: _ClassVar[int] + task_execution_id: _identifier_pb2.TaskExecutionIdentifier + namespace: str + labels: _containers.ScalarMap[str, str] + annotations: _containers.ScalarMap[str, str] + k8s_service_account: str + environment_variables: _containers.ScalarMap[str, str] + max_attempts: int + interruptible: bool + interruptible_failure_threshold: int + identity: _security_pb2.Identity + def __init__(self, task_execution_id: _Optional[_Union[_identifier_pb2.TaskExecutionIdentifier, _Mapping]] = ..., namespace: _Optional[str] = ..., labels: _Optional[_Mapping[str, str]] = ..., annotations: _Optional[_Mapping[str, str]] = ..., k8s_service_account: _Optional[str] = ..., environment_variables: _Optional[_Mapping[str, str]] = ..., max_attempts: _Optional[int] = ..., interruptible: bool = ..., interruptible_failure_threshold: _Optional[int] = ..., identity: _Optional[_Union[_security_pb2.Identity, _Mapping]] = ...) -> None: ... + +class CreateTaskRequest(_message.Message): + __slots__ = ["inputs", "template", "output_prefix", "task_execution_metadata", "connection"] + INPUTS_FIELD_NUMBER: _ClassVar[int] + TEMPLATE_FIELD_NUMBER: _ClassVar[int] + OUTPUT_PREFIX_FIELD_NUMBER: _ClassVar[int] + TASK_EXECUTION_METADATA_FIELD_NUMBER: _ClassVar[int] + CONNECTION_FIELD_NUMBER: _ClassVar[int] + inputs: _common_pb2.Inputs + template: _tasks_pb2.TaskTemplate + output_prefix: str + task_execution_metadata: TaskExecutionMetadata + connection: _security_pb2.Connection + def __init__(self, inputs: _Optional[_Union[_common_pb2.Inputs, _Mapping]] = ..., template: _Optional[_Union[_tasks_pb2.TaskTemplate, _Mapping]] = ..., output_prefix: _Optional[str] = ..., task_execution_metadata: _Optional[_Union[TaskExecutionMetadata, _Mapping]] = ..., connection: _Optional[_Union[_security_pb2.Connection, _Mapping]] = ...) -> None: ... + +class CreateTaskResponse(_message.Message): + __slots__ = ["resource_meta"] + RESOURCE_META_FIELD_NUMBER: _ClassVar[int] + resource_meta: bytes + def __init__(self, resource_meta: _Optional[bytes] = ...) -> None: ... + +class CreateRequestHeader(_message.Message): + __slots__ = ["template", "output_prefix", "task_execution_metadata", "max_dataset_size_bytes", "connection"] + TEMPLATE_FIELD_NUMBER: _ClassVar[int] + OUTPUT_PREFIX_FIELD_NUMBER: _ClassVar[int] + TASK_EXECUTION_METADATA_FIELD_NUMBER: _ClassVar[int] + MAX_DATASET_SIZE_BYTES_FIELD_NUMBER: _ClassVar[int] + CONNECTION_FIELD_NUMBER: _ClassVar[int] + template: _tasks_pb2.TaskTemplate + output_prefix: str + task_execution_metadata: TaskExecutionMetadata + max_dataset_size_bytes: int + connection: _security_pb2.Connection + def __init__(self, template: _Optional[_Union[_tasks_pb2.TaskTemplate, _Mapping]] = ..., output_prefix: _Optional[str] = ..., task_execution_metadata: _Optional[_Union[TaskExecutionMetadata, _Mapping]] = ..., max_dataset_size_bytes: _Optional[int] = ..., connection: _Optional[_Union[_security_pb2.Connection, _Mapping]] = ...) -> None: ... + +class GetTaskRequest(_message.Message): + __slots__ = ["resource_meta", "task_category", "output_prefix", "connection"] + RESOURCE_META_FIELD_NUMBER: _ClassVar[int] + TASK_CATEGORY_FIELD_NUMBER: _ClassVar[int] + OUTPUT_PREFIX_FIELD_NUMBER: _ClassVar[int] + CONNECTION_FIELD_NUMBER: _ClassVar[int] + resource_meta: bytes + task_category: TaskCategory + output_prefix: str + connection: _security_pb2.Connection + def __init__(self, resource_meta: _Optional[bytes] = ..., task_category: _Optional[_Union[TaskCategory, _Mapping]] = ..., output_prefix: _Optional[str] = ..., connection: _Optional[_Union[_security_pb2.Connection, _Mapping]] = ...) -> None: ... + +class GetTaskResponse(_message.Message): + __slots__ = ["resource"] + RESOURCE_FIELD_NUMBER: _ClassVar[int] + resource: Resource + def __init__(self, resource: _Optional[_Union[Resource, _Mapping]] = ...) -> None: ... + +class Resource(_message.Message): + __slots__ = ["outputs", "message", "log_links", "phase", "custom_info"] + OUTPUTS_FIELD_NUMBER: _ClassVar[int] + MESSAGE_FIELD_NUMBER: _ClassVar[int] + LOG_LINKS_FIELD_NUMBER: _ClassVar[int] + PHASE_FIELD_NUMBER: _ClassVar[int] + CUSTOM_INFO_FIELD_NUMBER: _ClassVar[int] + outputs: _common_pb2.Outputs + message: str + log_links: _containers.RepeatedCompositeFieldContainer[_execution_pb2.TaskLog] + phase: _execution_pb2.TaskExecution.Phase + custom_info: _struct_pb2.Struct + def __init__(self, outputs: _Optional[_Union[_common_pb2.Outputs, _Mapping]] = ..., message: _Optional[str] = ..., log_links: _Optional[_Iterable[_Union[_execution_pb2.TaskLog, _Mapping]]] = ..., phase: _Optional[_Union[_execution_pb2.TaskExecution.Phase, str]] = ..., custom_info: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ... + +class DeleteTaskRequest(_message.Message): + __slots__ = ["resource_meta", "task_category", "connection"] + RESOURCE_META_FIELD_NUMBER: _ClassVar[int] + TASK_CATEGORY_FIELD_NUMBER: _ClassVar[int] + CONNECTION_FIELD_NUMBER: _ClassVar[int] + resource_meta: bytes + task_category: TaskCategory + connection: _security_pb2.Connection + def __init__(self, resource_meta: _Optional[bytes] = ..., task_category: _Optional[_Union[TaskCategory, _Mapping]] = ..., connection: _Optional[_Union[_security_pb2.Connection, _Mapping]] = ...) -> None: ... + +class DeleteTaskResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class Connector(_message.Message): + __slots__ = ["name", "supported_task_categories"] + NAME_FIELD_NUMBER: _ClassVar[int] + SUPPORTED_TASK_CATEGORIES_FIELD_NUMBER: _ClassVar[int] + name: str + supported_task_categories: _containers.RepeatedCompositeFieldContainer[TaskCategory] + def __init__(self, name: _Optional[str] = ..., supported_task_categories: _Optional[_Iterable[_Union[TaskCategory, _Mapping]]] = ...) -> None: ... + +class TaskCategory(_message.Message): + __slots__ = ["name", "version"] + NAME_FIELD_NUMBER: _ClassVar[int] + VERSION_FIELD_NUMBER: _ClassVar[int] + name: str + version: int + def __init__(self, name: _Optional[str] = ..., version: _Optional[int] = ...) -> None: ... + +class GetConnectorRequest(_message.Message): + __slots__ = ["name"] + NAME_FIELD_NUMBER: _ClassVar[int] + name: str + def __init__(self, name: _Optional[str] = ...) -> None: ... + +class GetConnectorResponse(_message.Message): + __slots__ = ["connector"] + CONNECTOR_FIELD_NUMBER: _ClassVar[int] + connector: Connector + def __init__(self, connector: _Optional[_Union[Connector, _Mapping]] = ...) -> None: ... + +class ListConnectorsRequest(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class ListConnectorsResponse(_message.Message): + __slots__ = ["connectors"] + CONNECTORS_FIELD_NUMBER: _ClassVar[int] + connectors: _containers.RepeatedCompositeFieldContainer[Connector] + def __init__(self, connectors: _Optional[_Iterable[_Union[Connector, _Mapping]]] = ...) -> None: ... + +class GetTaskMetricsRequest(_message.Message): + __slots__ = ["resource_meta", "queries", "start_time", "end_time", "step", "task_category"] + RESOURCE_META_FIELD_NUMBER: _ClassVar[int] + QUERIES_FIELD_NUMBER: _ClassVar[int] + START_TIME_FIELD_NUMBER: _ClassVar[int] + END_TIME_FIELD_NUMBER: _ClassVar[int] + STEP_FIELD_NUMBER: _ClassVar[int] + TASK_CATEGORY_FIELD_NUMBER: _ClassVar[int] + resource_meta: bytes + queries: _containers.RepeatedScalarFieldContainer[str] + start_time: _timestamp_pb2.Timestamp + end_time: _timestamp_pb2.Timestamp + step: _duration_pb2.Duration + task_category: TaskCategory + def __init__(self, resource_meta: _Optional[bytes] = ..., queries: _Optional[_Iterable[str]] = ..., start_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., end_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., step: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., task_category: _Optional[_Union[TaskCategory, _Mapping]] = ...) -> None: ... + +class GetTaskMetricsResponse(_message.Message): + __slots__ = ["results"] + RESULTS_FIELD_NUMBER: _ClassVar[int] + results: _containers.RepeatedCompositeFieldContainer[_metrics_pb2.ExecutionMetricResult] + def __init__(self, results: _Optional[_Iterable[_Union[_metrics_pb2.ExecutionMetricResult, _Mapping]]] = ...) -> None: ... + +class GetTaskLogsRequest(_message.Message): + __slots__ = ["resource_meta", "lines", "token", "task_category"] + RESOURCE_META_FIELD_NUMBER: _ClassVar[int] + LINES_FIELD_NUMBER: _ClassVar[int] + TOKEN_FIELD_NUMBER: _ClassVar[int] + TASK_CATEGORY_FIELD_NUMBER: _ClassVar[int] + resource_meta: bytes + lines: int + token: str + task_category: TaskCategory + def __init__(self, resource_meta: _Optional[bytes] = ..., lines: _Optional[int] = ..., token: _Optional[str] = ..., task_category: _Optional[_Union[TaskCategory, _Mapping]] = ...) -> None: ... + +class GetTaskLogsResponseHeader(_message.Message): + __slots__ = ["token"] + TOKEN_FIELD_NUMBER: _ClassVar[int] + token: str + def __init__(self, token: _Optional[str] = ...) -> None: ... + +class GetTaskLogsResponseBody(_message.Message): + __slots__ = ["results"] + RESULTS_FIELD_NUMBER: _ClassVar[int] + results: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, results: _Optional[_Iterable[str]] = ...) -> None: ... + +class GetTaskLogsResponse(_message.Message): + __slots__ = ["header", "body"] + HEADER_FIELD_NUMBER: _ClassVar[int] + BODY_FIELD_NUMBER: _ClassVar[int] + header: GetTaskLogsResponseHeader + body: GetTaskLogsResponseBody + def __init__(self, header: _Optional[_Union[GetTaskLogsResponseHeader, _Mapping]] = ..., body: _Optional[_Union[GetTaskLogsResponseBody, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/connector/connector_pb2_grpc.py b/gen/python/flyteidl2/connector/connector_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/connector/connector_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/connector/service_pb2.py b/gen/python/flyteidl2/connector/service_pb2.py new file mode 100644 index 0000000000..f159191cb4 --- /dev/null +++ b/gen/python/flyteidl2/connector/service_pb2.py @@ -0,0 +1,44 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/connector/service.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.connector import connector_pb2 as flyteidl2_dot_connector_dot_connector__pb2 +from google.api import annotations_pb2 as google_dot_api_dot_annotations__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n!flyteidl2/connector/service.proto\x12\x13\x66lyteidl2.connector\x1a#flyteidl2/connector/connector.proto\x1a\x1cgoogle/api/annotations.proto2\xae\x07\n\x15\x41syncConnectorService\x12\x80\x01\n\nCreateTask\x12&.flyteidl2.connector.CreateTaskRequest\x1a\'.flyteidl2.connector.CreateTaskResponse\"!\x82\xd3\xe4\x93\x02\x1b\"\x16/api/v1/connector/task:\x01*\x12\xb1\x01\n\x07GetTask\x12#.flyteidl2.connector.GetTaskRequest\x1a$.flyteidl2.connector.GetTaskResponse\"[\x82\xd3\xe4\x93\x02U\x12S/api/v1/connector/task/{task_category.name}/{task_category.version}/{resource_meta}\x12\xc5\x01\n\nDeleteTask\x12&.flyteidl2.connector.DeleteTaskRequest\x1a\'.flyteidl2.connector.DeleteTaskResponse\"f\x82\xd3\xe4\x93\x02`*^/api/v1/connector/task_executions/{task_category.name}/{task_category.version}/{resource_meta}\x12\xce\x01\n\x0eGetTaskMetrics\x12*.flyteidl2.connector.GetTaskMetricsRequest\x1a+.flyteidl2.connector.GetTaskMetricsResponse\"c\x82\xd3\xe4\x93\x02]\x12[/api/v1/connector/task/metrics/{task_category.name}/{task_category.version}/{resource_meta}\x12\xc4\x01\n\x0bGetTaskLogs\x12\'.flyteidl2.connector.GetTaskLogsRequest\x1a(.flyteidl2.connector.GetTaskLogsResponse\"`\x82\xd3\xe4\x93\x02Z\x12X/api/v1/connector/task/logs/{task_category.name}/{task_category.version}/{resource_meta}0\x01\x32\xaa\x02\n\x18\x43onnectorMetadataService\x12\x85\x01\n\x0cGetConnector\x12(.flyteidl2.connector.GetConnectorRequest\x1a).flyteidl2.connector.GetConnectorResponse\" \x82\xd3\xe4\x93\x02\x1a\x12\x18/api/v1/connector/{name}\x12\x85\x01\n\x0eListConnectors\x12*.flyteidl2.connector.ListConnectorsRequest\x1a+.flyteidl2.connector.ListConnectorsResponse\"\x1a\x82\xd3\xe4\x93\x02\x14\x12\x12/api/v1/connectorsB\xcf\x01\n\x17\x63om.flyteidl2.connectorB\x0cServiceProtoH\x02P\x01Z7github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector\xa2\x02\x03\x46\x43X\xaa\x02\x13\x46lyteidl2.Connector\xca\x02\x13\x46lyteidl2\\Connector\xe2\x02\x1f\x46lyteidl2\\Connector\\GPBMetadata\xea\x02\x14\x46lyteidl2::Connectorb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.connector.service_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\027com.flyteidl2.connectorB\014ServiceProtoH\002P\001Z7github.com/flyteorg/flyte/v2/gen/go/flyteidl2/connector\242\002\003FCX\252\002\023Flyteidl2.Connector\312\002\023Flyteidl2\\Connector\342\002\037Flyteidl2\\Connector\\GPBMetadata\352\002\024Flyteidl2::Connector' + _ASYNCCONNECTORSERVICE.methods_by_name['CreateTask']._options = None + _ASYNCCONNECTORSERVICE.methods_by_name['CreateTask']._serialized_options = b'\202\323\344\223\002\033\"\026/api/v1/connector/task:\001*' + _ASYNCCONNECTORSERVICE.methods_by_name['GetTask']._options = None + _ASYNCCONNECTORSERVICE.methods_by_name['GetTask']._serialized_options = b'\202\323\344\223\002U\022S/api/v1/connector/task/{task_category.name}/{task_category.version}/{resource_meta}' + _ASYNCCONNECTORSERVICE.methods_by_name['DeleteTask']._options = None + _ASYNCCONNECTORSERVICE.methods_by_name['DeleteTask']._serialized_options = b'\202\323\344\223\002`*^/api/v1/connector/task_executions/{task_category.name}/{task_category.version}/{resource_meta}' + _ASYNCCONNECTORSERVICE.methods_by_name['GetTaskMetrics']._options = None + _ASYNCCONNECTORSERVICE.methods_by_name['GetTaskMetrics']._serialized_options = b'\202\323\344\223\002]\022[/api/v1/connector/task/metrics/{task_category.name}/{task_category.version}/{resource_meta}' + _ASYNCCONNECTORSERVICE.methods_by_name['GetTaskLogs']._options = None + _ASYNCCONNECTORSERVICE.methods_by_name['GetTaskLogs']._serialized_options = b'\202\323\344\223\002Z\022X/api/v1/connector/task/logs/{task_category.name}/{task_category.version}/{resource_meta}' + _CONNECTORMETADATASERVICE.methods_by_name['GetConnector']._options = None + _CONNECTORMETADATASERVICE.methods_by_name['GetConnector']._serialized_options = b'\202\323\344\223\002\032\022\030/api/v1/connector/{name}' + _CONNECTORMETADATASERVICE.methods_by_name['ListConnectors']._options = None + _CONNECTORMETADATASERVICE.methods_by_name['ListConnectors']._serialized_options = b'\202\323\344\223\002\024\022\022/api/v1/connectors' + _globals['_ASYNCCONNECTORSERVICE']._serialized_start=126 + _globals['_ASYNCCONNECTORSERVICE']._serialized_end=1068 + _globals['_CONNECTORMETADATASERVICE']._serialized_start=1071 + _globals['_CONNECTORMETADATASERVICE']._serialized_end=1369 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/connector/service_pb2.pyi b/gen/python/flyteidl2/connector/service_pb2.pyi new file mode 100644 index 0000000000..785bcf3e3d --- /dev/null +++ b/gen/python/flyteidl2/connector/service_pb2.pyi @@ -0,0 +1,6 @@ +from flyteidl2.connector import connector_pb2 as _connector_pb2 +from google.api import annotations_pb2 as _annotations_pb2 +from google.protobuf import descriptor as _descriptor +from typing import ClassVar as _ClassVar + +DESCRIPTOR: _descriptor.FileDescriptor diff --git a/gen/python/flyteidl2/connector/service_pb2_grpc.py b/gen/python/flyteidl2/connector/service_pb2_grpc.py new file mode 100644 index 0000000000..18434e847f --- /dev/null +++ b/gen/python/flyteidl2/connector/service_pb2_grpc.py @@ -0,0 +1,312 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from flyteidl2.connector import connector_pb2 as flyteidl2_dot_connector_dot_connector__pb2 + + +class AsyncConnectorServiceStub(object): + """AsyncConnectorService defines an RPC Service that allows executor to send the request to the connector server asynchronously. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.CreateTask = channel.unary_unary( + '/flyteidl2.connector.AsyncConnectorService/CreateTask', + request_serializer=flyteidl2_dot_connector_dot_connector__pb2.CreateTaskRequest.SerializeToString, + response_deserializer=flyteidl2_dot_connector_dot_connector__pb2.CreateTaskResponse.FromString, + ) + self.GetTask = channel.unary_unary( + '/flyteidl2.connector.AsyncConnectorService/GetTask', + request_serializer=flyteidl2_dot_connector_dot_connector__pb2.GetTaskRequest.SerializeToString, + response_deserializer=flyteidl2_dot_connector_dot_connector__pb2.GetTaskResponse.FromString, + ) + self.DeleteTask = channel.unary_unary( + '/flyteidl2.connector.AsyncConnectorService/DeleteTask', + request_serializer=flyteidl2_dot_connector_dot_connector__pb2.DeleteTaskRequest.SerializeToString, + response_deserializer=flyteidl2_dot_connector_dot_connector__pb2.DeleteTaskResponse.FromString, + ) + self.GetTaskMetrics = channel.unary_unary( + '/flyteidl2.connector.AsyncConnectorService/GetTaskMetrics', + request_serializer=flyteidl2_dot_connector_dot_connector__pb2.GetTaskMetricsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_connector_dot_connector__pb2.GetTaskMetricsResponse.FromString, + ) + self.GetTaskLogs = channel.unary_stream( + '/flyteidl2.connector.AsyncConnectorService/GetTaskLogs', + request_serializer=flyteidl2_dot_connector_dot_connector__pb2.GetTaskLogsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_connector_dot_connector__pb2.GetTaskLogsResponse.FromString, + ) + + +class AsyncConnectorServiceServicer(object): + """AsyncConnectorService defines an RPC Service that allows executor to send the request to the connector server asynchronously. + """ + + def CreateTask(self, request, context): + """CreateTask sends a task create request to the connector service. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetTask(self, request, context): + """Get job status. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DeleteTask(self, request, context): + """Delete the task resource. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetTaskMetrics(self, request, context): + """GetTaskMetrics returns one or more task execution metrics, if available. + + Errors include + * OutOfRange if metrics are not available for the specified task time range + * various other errors + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetTaskLogs(self, request, context): + """GetTaskLogs returns task execution logs, if available. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_AsyncConnectorServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'CreateTask': grpc.unary_unary_rpc_method_handler( + servicer.CreateTask, + request_deserializer=flyteidl2_dot_connector_dot_connector__pb2.CreateTaskRequest.FromString, + response_serializer=flyteidl2_dot_connector_dot_connector__pb2.CreateTaskResponse.SerializeToString, + ), + 'GetTask': grpc.unary_unary_rpc_method_handler( + servicer.GetTask, + request_deserializer=flyteidl2_dot_connector_dot_connector__pb2.GetTaskRequest.FromString, + response_serializer=flyteidl2_dot_connector_dot_connector__pb2.GetTaskResponse.SerializeToString, + ), + 'DeleteTask': grpc.unary_unary_rpc_method_handler( + servicer.DeleteTask, + request_deserializer=flyteidl2_dot_connector_dot_connector__pb2.DeleteTaskRequest.FromString, + response_serializer=flyteidl2_dot_connector_dot_connector__pb2.DeleteTaskResponse.SerializeToString, + ), + 'GetTaskMetrics': grpc.unary_unary_rpc_method_handler( + servicer.GetTaskMetrics, + request_deserializer=flyteidl2_dot_connector_dot_connector__pb2.GetTaskMetricsRequest.FromString, + response_serializer=flyteidl2_dot_connector_dot_connector__pb2.GetTaskMetricsResponse.SerializeToString, + ), + 'GetTaskLogs': grpc.unary_stream_rpc_method_handler( + servicer.GetTaskLogs, + request_deserializer=flyteidl2_dot_connector_dot_connector__pb2.GetTaskLogsRequest.FromString, + response_serializer=flyteidl2_dot_connector_dot_connector__pb2.GetTaskLogsResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.connector.AsyncConnectorService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class AsyncConnectorService(object): + """AsyncConnectorService defines an RPC Service that allows executor to send the request to the connector server asynchronously. + """ + + @staticmethod + def CreateTask(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.connector.AsyncConnectorService/CreateTask', + flyteidl2_dot_connector_dot_connector__pb2.CreateTaskRequest.SerializeToString, + flyteidl2_dot_connector_dot_connector__pb2.CreateTaskResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetTask(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.connector.AsyncConnectorService/GetTask', + flyteidl2_dot_connector_dot_connector__pb2.GetTaskRequest.SerializeToString, + flyteidl2_dot_connector_dot_connector__pb2.GetTaskResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DeleteTask(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.connector.AsyncConnectorService/DeleteTask', + flyteidl2_dot_connector_dot_connector__pb2.DeleteTaskRequest.SerializeToString, + flyteidl2_dot_connector_dot_connector__pb2.DeleteTaskResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetTaskMetrics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.connector.AsyncConnectorService/GetTaskMetrics', + flyteidl2_dot_connector_dot_connector__pb2.GetTaskMetricsRequest.SerializeToString, + flyteidl2_dot_connector_dot_connector__pb2.GetTaskMetricsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetTaskLogs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream(request, target, '/flyteidl2.connector.AsyncConnectorService/GetTaskLogs', + flyteidl2_dot_connector_dot_connector__pb2.GetTaskLogsRequest.SerializeToString, + flyteidl2_dot_connector_dot_connector__pb2.GetTaskLogsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + +class ConnectorMetadataServiceStub(object): + """ConnectorMetadataService defines an RPC service that is also served over HTTP via grpc-gateway. + This service allows executor or users to get the metadata of connectors. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.GetConnector = channel.unary_unary( + '/flyteidl2.connector.ConnectorMetadataService/GetConnector', + request_serializer=flyteidl2_dot_connector_dot_connector__pb2.GetConnectorRequest.SerializeToString, + response_deserializer=flyteidl2_dot_connector_dot_connector__pb2.GetConnectorResponse.FromString, + ) + self.ListConnectors = channel.unary_unary( + '/flyteidl2.connector.ConnectorMetadataService/ListConnectors', + request_serializer=flyteidl2_dot_connector_dot_connector__pb2.ListConnectorsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_connector_dot_connector__pb2.ListConnectorsResponse.FromString, + ) + + +class ConnectorMetadataServiceServicer(object): + """ConnectorMetadataService defines an RPC service that is also served over HTTP via grpc-gateway. + This service allows executor or users to get the metadata of connectors. + """ + + def GetConnector(self, request, context): + """Fetch a :ref:`ref_flyteidl2.plugins.Connector` definition. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListConnectors(self, request, context): + """Fetch a list of :ref:`ref_flyteidl2.plugins.Connector` definitions. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_ConnectorMetadataServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'GetConnector': grpc.unary_unary_rpc_method_handler( + servicer.GetConnector, + request_deserializer=flyteidl2_dot_connector_dot_connector__pb2.GetConnectorRequest.FromString, + response_serializer=flyteidl2_dot_connector_dot_connector__pb2.GetConnectorResponse.SerializeToString, + ), + 'ListConnectors': grpc.unary_unary_rpc_method_handler( + servicer.ListConnectors, + request_deserializer=flyteidl2_dot_connector_dot_connector__pb2.ListConnectorsRequest.FromString, + response_serializer=flyteidl2_dot_connector_dot_connector__pb2.ListConnectorsResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.connector.ConnectorMetadataService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class ConnectorMetadataService(object): + """ConnectorMetadataService defines an RPC service that is also served over HTTP via grpc-gateway. + This service allows executor or users to get the metadata of connectors. + """ + + @staticmethod + def GetConnector(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.connector.ConnectorMetadataService/GetConnector', + flyteidl2_dot_connector_dot_connector__pb2.GetConnectorRequest.SerializeToString, + flyteidl2_dot_connector_dot_connector__pb2.GetConnectorResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListConnectors(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.connector.ConnectorMetadataService/ListConnectors', + flyteidl2_dot_connector_dot_connector__pb2.ListConnectorsRequest.SerializeToString, + flyteidl2_dot_connector_dot_connector__pb2.ListConnectorsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/gen/python/flyteidl2/core/__init__.py b/gen/python/flyteidl2/core/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/core/artifact_id_pb2.py b/gen/python/flyteidl2/core/artifact_id_pb2.py new file mode 100644 index 0000000000..338dc283e4 --- /dev/null +++ b/gen/python/flyteidl2/core/artifact_id_pb2.py @@ -0,0 +1,55 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/core/artifact_id.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n flyteidl2/core/artifact_id.proto\x12\x0e\x66lyteidl2.core\x1a\x1fgoogle/protobuf/timestamp.proto\"e\n\x0b\x41rtifactKey\x12\x18\n\x07project\x18\x01 \x01(\tR\x07project\x12\x16\n\x06\x64omain\x18\x02 \x01(\tR\x06\x64omain\x12\x12\n\x04name\x18\x03 \x01(\tR\x04name\x12\x10\n\x03org\x18\x04 \x01(\tR\x03org\"\xd1\x01\n\x13\x41rtifactBindingData\x12%\n\rpartition_key\x18\x05 \x01(\tH\x00R\x0cpartitionKey\x12\x35\n\x16\x62ind_to_time_partition\x18\x06 \x01(\x08H\x00R\x13\x62indToTimePartition\x12\x44\n\x0etime_transform\x18\x07 \x01(\x0b\x32\x1d.flyteidl2.core.TimeTransformR\rtimeTransformB\x10\n\x0epartition_dataJ\x04\x08\x01\x10\x05\"W\n\rTimeTransform\x12\x1c\n\ttransform\x18\x01 \x01(\tR\ttransform\x12(\n\x02op\x18\x02 \x01(\x0e\x32\x18.flyteidl2.core.OperatorR\x02op\"$\n\x10InputBindingData\x12\x10\n\x03var\x18\x01 \x01(\tR\x03var\"\x10\n\x0eRuntimeBinding\"\xdf\x02\n\nLabelValue\x12#\n\x0cstatic_value\x18\x01 \x01(\tH\x00R\x0bstaticValue\x12;\n\ntime_value\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampH\x00R\ttimeValue\x12R\n\x11triggered_binding\x18\x03 \x01(\x0b\x32#.flyteidl2.core.ArtifactBindingDataH\x00R\x10triggeredBinding\x12G\n\rinput_binding\x18\x04 \x01(\x0b\x32 .flyteidl2.core.InputBindingDataH\x00R\x0cinputBinding\x12I\n\x0fruntime_binding\x18\x05 \x01(\x0b\x32\x1e.flyteidl2.core.RuntimeBindingH\x00R\x0eruntimeBindingB\x07\n\x05value\"\x9f\x01\n\nPartitions\x12;\n\x05value\x18\x01 \x03(\x0b\x32%.flyteidl2.core.Partitions.ValueEntryR\x05value\x1aT\n\nValueEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x30\n\x05value\x18\x02 \x01(\x0b\x32\x1a.flyteidl2.core.LabelValueR\x05value:\x02\x38\x01\"\x80\x01\n\rTimePartition\x12\x30\n\x05value\x18\x01 \x01(\x0b\x32\x1a.flyteidl2.core.LabelValueR\x05value\x12=\n\x0bgranularity\x18\x02 \x01(\x0e\x32\x1b.flyteidl2.core.GranularityR\x0bgranularity\"\xe8\x01\n\nArtifactID\x12>\n\x0c\x61rtifact_key\x18\x01 \x01(\x0b\x32\x1b.flyteidl2.core.ArtifactKeyR\x0b\x61rtifactKey\x12\x18\n\x07version\x18\x02 \x01(\tR\x07version\x12:\n\npartitions\x18\x03 \x01(\x0b\x32\x1a.flyteidl2.core.PartitionsR\npartitions\x12\x44\n\x0etime_partition\x18\x04 \x01(\x0b\x32\x1d.flyteidl2.core.TimePartitionR\rtimePartition\"\x7f\n\x0b\x41rtifactTag\x12>\n\x0c\x61rtifact_key\x18\x01 \x01(\x0b\x32\x1b.flyteidl2.core.ArtifactKeyR\x0b\x61rtifactKey\x12\x30\n\x05value\x18\x02 \x01(\x0b\x32\x1a.flyteidl2.core.LabelValueR\x05value\"\xf3\x01\n\rArtifactQuery\x12=\n\x0b\x61rtifact_id\x18\x01 \x01(\x0b\x32\x1a.flyteidl2.core.ArtifactIDH\x00R\nartifactId\x12@\n\x0c\x61rtifact_tag\x18\x02 \x01(\x0b\x32\x1b.flyteidl2.core.ArtifactTagH\x00R\x0b\x61rtifactTag\x12\x12\n\x03uri\x18\x03 \x01(\tH\x00R\x03uri\x12?\n\x07\x62inding\x18\x04 \x01(\x0b\x32#.flyteidl2.core.ArtifactBindingDataH\x00R\x07\x62indingB\x0c\n\nidentifier*B\n\x0bGranularity\x12\t\n\x05UNSET\x10\x00\x12\n\n\x06MINUTE\x10\x01\x12\x08\n\x04HOUR\x10\x02\x12\x07\n\x03\x44\x41Y\x10\x03\x12\t\n\x05MONTH\x10\x04*\x1f\n\x08Operator\x12\t\n\x05MINUS\x10\x00\x12\x08\n\x04PLUS\x10\x01\x42\xb4\x01\n\x12\x63om.flyteidl2.coreB\x0f\x41rtifactIdProtoH\x02P\x01Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\xa2\x02\x03\x46\x43X\xaa\x02\x0e\x46lyteidl2.Core\xca\x02\x0e\x46lyteidl2\\Core\xe2\x02\x1a\x46lyteidl2\\Core\\GPBMetadata\xea\x02\x0f\x46lyteidl2::Coreb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.core.artifact_id_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\022com.flyteidl2.coreB\017ArtifactIdProtoH\002P\001Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\242\002\003FCX\252\002\016Flyteidl2.Core\312\002\016Flyteidl2\\Core\342\002\032Flyteidl2\\Core\\GPBMetadata\352\002\017Flyteidl2::Core' + _PARTITIONS_VALUEENTRY._options = None + _PARTITIONS_VALUEENTRY._serialized_options = b'8\001' + _globals['_GRANULARITY']._serialized_start=1802 + _globals['_GRANULARITY']._serialized_end=1868 + _globals['_OPERATOR']._serialized_start=1870 + _globals['_OPERATOR']._serialized_end=1901 + _globals['_ARTIFACTKEY']._serialized_start=85 + _globals['_ARTIFACTKEY']._serialized_end=186 + _globals['_ARTIFACTBINDINGDATA']._serialized_start=189 + _globals['_ARTIFACTBINDINGDATA']._serialized_end=398 + _globals['_TIMETRANSFORM']._serialized_start=400 + _globals['_TIMETRANSFORM']._serialized_end=487 + _globals['_INPUTBINDINGDATA']._serialized_start=489 + _globals['_INPUTBINDINGDATA']._serialized_end=525 + _globals['_RUNTIMEBINDING']._serialized_start=527 + _globals['_RUNTIMEBINDING']._serialized_end=543 + _globals['_LABELVALUE']._serialized_start=546 + _globals['_LABELVALUE']._serialized_end=897 + _globals['_PARTITIONS']._serialized_start=900 + _globals['_PARTITIONS']._serialized_end=1059 + _globals['_PARTITIONS_VALUEENTRY']._serialized_start=975 + _globals['_PARTITIONS_VALUEENTRY']._serialized_end=1059 + _globals['_TIMEPARTITION']._serialized_start=1062 + _globals['_TIMEPARTITION']._serialized_end=1190 + _globals['_ARTIFACTID']._serialized_start=1193 + _globals['_ARTIFACTID']._serialized_end=1425 + _globals['_ARTIFACTTAG']._serialized_start=1427 + _globals['_ARTIFACTTAG']._serialized_end=1554 + _globals['_ARTIFACTQUERY']._serialized_start=1557 + _globals['_ARTIFACTQUERY']._serialized_end=1800 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/core/artifact_id_pb2.pyi b/gen/python/flyteidl2/core/artifact_id_pb2.pyi new file mode 100644 index 0000000000..975f0030d9 --- /dev/null +++ b/gen/python/flyteidl2/core/artifact_id_pb2.pyi @@ -0,0 +1,135 @@ +from google.protobuf import timestamp_pb2 as _timestamp_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class Granularity(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + UNSET: _ClassVar[Granularity] + MINUTE: _ClassVar[Granularity] + HOUR: _ClassVar[Granularity] + DAY: _ClassVar[Granularity] + MONTH: _ClassVar[Granularity] + +class Operator(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + MINUS: _ClassVar[Operator] + PLUS: _ClassVar[Operator] +UNSET: Granularity +MINUTE: Granularity +HOUR: Granularity +DAY: Granularity +MONTH: Granularity +MINUS: Operator +PLUS: Operator + +class ArtifactKey(_message.Message): + __slots__ = ["project", "domain", "name", "org"] + PROJECT_FIELD_NUMBER: _ClassVar[int] + DOMAIN_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + ORG_FIELD_NUMBER: _ClassVar[int] + project: str + domain: str + name: str + org: str + def __init__(self, project: _Optional[str] = ..., domain: _Optional[str] = ..., name: _Optional[str] = ..., org: _Optional[str] = ...) -> None: ... + +class ArtifactBindingData(_message.Message): + __slots__ = ["partition_key", "bind_to_time_partition", "time_transform"] + PARTITION_KEY_FIELD_NUMBER: _ClassVar[int] + BIND_TO_TIME_PARTITION_FIELD_NUMBER: _ClassVar[int] + TIME_TRANSFORM_FIELD_NUMBER: _ClassVar[int] + partition_key: str + bind_to_time_partition: bool + time_transform: TimeTransform + def __init__(self, partition_key: _Optional[str] = ..., bind_to_time_partition: bool = ..., time_transform: _Optional[_Union[TimeTransform, _Mapping]] = ...) -> None: ... + +class TimeTransform(_message.Message): + __slots__ = ["transform", "op"] + TRANSFORM_FIELD_NUMBER: _ClassVar[int] + OP_FIELD_NUMBER: _ClassVar[int] + transform: str + op: Operator + def __init__(self, transform: _Optional[str] = ..., op: _Optional[_Union[Operator, str]] = ...) -> None: ... + +class InputBindingData(_message.Message): + __slots__ = ["var"] + VAR_FIELD_NUMBER: _ClassVar[int] + var: str + def __init__(self, var: _Optional[str] = ...) -> None: ... + +class RuntimeBinding(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class LabelValue(_message.Message): + __slots__ = ["static_value", "time_value", "triggered_binding", "input_binding", "runtime_binding"] + STATIC_VALUE_FIELD_NUMBER: _ClassVar[int] + TIME_VALUE_FIELD_NUMBER: _ClassVar[int] + TRIGGERED_BINDING_FIELD_NUMBER: _ClassVar[int] + INPUT_BINDING_FIELD_NUMBER: _ClassVar[int] + RUNTIME_BINDING_FIELD_NUMBER: _ClassVar[int] + static_value: str + time_value: _timestamp_pb2.Timestamp + triggered_binding: ArtifactBindingData + input_binding: InputBindingData + runtime_binding: RuntimeBinding + def __init__(self, static_value: _Optional[str] = ..., time_value: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., triggered_binding: _Optional[_Union[ArtifactBindingData, _Mapping]] = ..., input_binding: _Optional[_Union[InputBindingData, _Mapping]] = ..., runtime_binding: _Optional[_Union[RuntimeBinding, _Mapping]] = ...) -> None: ... + +class Partitions(_message.Message): + __slots__ = ["value"] + class ValueEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: LabelValue + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[LabelValue, _Mapping]] = ...) -> None: ... + VALUE_FIELD_NUMBER: _ClassVar[int] + value: _containers.MessageMap[str, LabelValue] + def __init__(self, value: _Optional[_Mapping[str, LabelValue]] = ...) -> None: ... + +class TimePartition(_message.Message): + __slots__ = ["value", "granularity"] + VALUE_FIELD_NUMBER: _ClassVar[int] + GRANULARITY_FIELD_NUMBER: _ClassVar[int] + value: LabelValue + granularity: Granularity + def __init__(self, value: _Optional[_Union[LabelValue, _Mapping]] = ..., granularity: _Optional[_Union[Granularity, str]] = ...) -> None: ... + +class ArtifactID(_message.Message): + __slots__ = ["artifact_key", "version", "partitions", "time_partition"] + ARTIFACT_KEY_FIELD_NUMBER: _ClassVar[int] + VERSION_FIELD_NUMBER: _ClassVar[int] + PARTITIONS_FIELD_NUMBER: _ClassVar[int] + TIME_PARTITION_FIELD_NUMBER: _ClassVar[int] + artifact_key: ArtifactKey + version: str + partitions: Partitions + time_partition: TimePartition + def __init__(self, artifact_key: _Optional[_Union[ArtifactKey, _Mapping]] = ..., version: _Optional[str] = ..., partitions: _Optional[_Union[Partitions, _Mapping]] = ..., time_partition: _Optional[_Union[TimePartition, _Mapping]] = ...) -> None: ... + +class ArtifactTag(_message.Message): + __slots__ = ["artifact_key", "value"] + ARTIFACT_KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + artifact_key: ArtifactKey + value: LabelValue + def __init__(self, artifact_key: _Optional[_Union[ArtifactKey, _Mapping]] = ..., value: _Optional[_Union[LabelValue, _Mapping]] = ...) -> None: ... + +class ArtifactQuery(_message.Message): + __slots__ = ["artifact_id", "artifact_tag", "uri", "binding"] + ARTIFACT_ID_FIELD_NUMBER: _ClassVar[int] + ARTIFACT_TAG_FIELD_NUMBER: _ClassVar[int] + URI_FIELD_NUMBER: _ClassVar[int] + BINDING_FIELD_NUMBER: _ClassVar[int] + artifact_id: ArtifactID + artifact_tag: ArtifactTag + uri: str + binding: ArtifactBindingData + def __init__(self, artifact_id: _Optional[_Union[ArtifactID, _Mapping]] = ..., artifact_tag: _Optional[_Union[ArtifactTag, _Mapping]] = ..., uri: _Optional[str] = ..., binding: _Optional[_Union[ArtifactBindingData, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/core/artifact_id_pb2_grpc.py b/gen/python/flyteidl2/core/artifact_id_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/core/artifact_id_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/core/catalog_pb2.py b/gen/python/flyteidl2/core/catalog_pb2.py new file mode 100644 index 0000000000..70ec93fa4d --- /dev/null +++ b/gen/python/flyteidl2/core/catalog_pb2.py @@ -0,0 +1,35 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/core/catalog.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.core import identifier_pb2 as flyteidl2_dot_core_dot_identifier__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1c\x66lyteidl2/core/catalog.proto\x12\x0e\x66lyteidl2.core\x1a\x1f\x66lyteidl2/core/identifier.proto\"I\n\x12\x43\x61talogArtifactTag\x12\x1f\n\x0b\x61rtifact_id\x18\x01 \x01(\tR\nartifactId\x12\x12\n\x04name\x18\x02 \x01(\tR\x04name\"\x86\x02\n\x0f\x43\x61talogMetadata\x12\x39\n\ndataset_id\x18\x01 \x01(\x0b\x32\x1a.flyteidl2.core.IdentifierR\tdatasetId\x12\x45\n\x0c\x61rtifact_tag\x18\x02 \x01(\x0b\x32\".flyteidl2.core.CatalogArtifactTagR\x0b\x61rtifactTag\x12]\n\x15source_task_execution\x18\x03 \x01(\x0b\x32\'.flyteidl2.core.TaskExecutionIdentifierH\x00R\x13sourceTaskExecutionB\x12\n\x10source_execution\"\x9e\x01\n\x12\x43\x61talogReservation\"\x87\x01\n\x06Status\x12\x18\n\x14RESERVATION_DISABLED\x10\x00\x12\x18\n\x14RESERVATION_ACQUIRED\x10\x01\x12\x16\n\x12RESERVATION_EXISTS\x10\x02\x12\x18\n\x14RESERVATION_RELEASED\x10\x03\x12\x17\n\x13RESERVATION_FAILURE\x10\x04*\xb3\x01\n\x12\x43\x61talogCacheStatus\x12\x12\n\x0e\x43\x41\x43HE_DISABLED\x10\x00\x12\x0e\n\nCACHE_MISS\x10\x01\x12\r\n\tCACHE_HIT\x10\x02\x12\x13\n\x0f\x43\x41\x43HE_POPULATED\x10\x03\x12\x18\n\x14\x43\x41\x43HE_LOOKUP_FAILURE\x10\x04\x12\x15\n\x11\x43\x41\x43HE_PUT_FAILURE\x10\x05\x12\x11\n\rCACHE_SKIPPED\x10\x06\x12\x11\n\rCACHE_EVICTED\x10\x07\x42\xb1\x01\n\x12\x63om.flyteidl2.coreB\x0c\x43\x61talogProtoH\x02P\x01Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\xa2\x02\x03\x46\x43X\xaa\x02\x0e\x46lyteidl2.Core\xca\x02\x0e\x46lyteidl2\\Core\xe2\x02\x1a\x46lyteidl2\\Core\\GPBMetadata\xea\x02\x0f\x46lyteidl2::Coreb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.core.catalog_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\022com.flyteidl2.coreB\014CatalogProtoH\002P\001Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\242\002\003FCX\252\002\016Flyteidl2.Core\312\002\016Flyteidl2\\Core\342\002\032Flyteidl2\\Core\\GPBMetadata\352\002\017Flyteidl2::Core' + _globals['_CATALOGCACHESTATUS']._serialized_start=583 + _globals['_CATALOGCACHESTATUS']._serialized_end=762 + _globals['_CATALOGARTIFACTTAG']._serialized_start=81 + _globals['_CATALOGARTIFACTTAG']._serialized_end=154 + _globals['_CATALOGMETADATA']._serialized_start=157 + _globals['_CATALOGMETADATA']._serialized_end=419 + _globals['_CATALOGRESERVATION']._serialized_start=422 + _globals['_CATALOGRESERVATION']._serialized_end=580 + _globals['_CATALOGRESERVATION_STATUS']._serialized_start=445 + _globals['_CATALOGRESERVATION_STATUS']._serialized_end=580 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/core/catalog_pb2.pyi b/gen/python/flyteidl2/core/catalog_pb2.pyi new file mode 100644 index 0000000000..b0ff7b91ad --- /dev/null +++ b/gen/python/flyteidl2/core/catalog_pb2.pyi @@ -0,0 +1,60 @@ +from flyteidl2.core import identifier_pb2 as _identifier_pb2 +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class CatalogCacheStatus(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + CACHE_DISABLED: _ClassVar[CatalogCacheStatus] + CACHE_MISS: _ClassVar[CatalogCacheStatus] + CACHE_HIT: _ClassVar[CatalogCacheStatus] + CACHE_POPULATED: _ClassVar[CatalogCacheStatus] + CACHE_LOOKUP_FAILURE: _ClassVar[CatalogCacheStatus] + CACHE_PUT_FAILURE: _ClassVar[CatalogCacheStatus] + CACHE_SKIPPED: _ClassVar[CatalogCacheStatus] + CACHE_EVICTED: _ClassVar[CatalogCacheStatus] +CACHE_DISABLED: CatalogCacheStatus +CACHE_MISS: CatalogCacheStatus +CACHE_HIT: CatalogCacheStatus +CACHE_POPULATED: CatalogCacheStatus +CACHE_LOOKUP_FAILURE: CatalogCacheStatus +CACHE_PUT_FAILURE: CatalogCacheStatus +CACHE_SKIPPED: CatalogCacheStatus +CACHE_EVICTED: CatalogCacheStatus + +class CatalogArtifactTag(_message.Message): + __slots__ = ["artifact_id", "name"] + ARTIFACT_ID_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + artifact_id: str + name: str + def __init__(self, artifact_id: _Optional[str] = ..., name: _Optional[str] = ...) -> None: ... + +class CatalogMetadata(_message.Message): + __slots__ = ["dataset_id", "artifact_tag", "source_task_execution"] + DATASET_ID_FIELD_NUMBER: _ClassVar[int] + ARTIFACT_TAG_FIELD_NUMBER: _ClassVar[int] + SOURCE_TASK_EXECUTION_FIELD_NUMBER: _ClassVar[int] + dataset_id: _identifier_pb2.Identifier + artifact_tag: CatalogArtifactTag + source_task_execution: _identifier_pb2.TaskExecutionIdentifier + def __init__(self, dataset_id: _Optional[_Union[_identifier_pb2.Identifier, _Mapping]] = ..., artifact_tag: _Optional[_Union[CatalogArtifactTag, _Mapping]] = ..., source_task_execution: _Optional[_Union[_identifier_pb2.TaskExecutionIdentifier, _Mapping]] = ...) -> None: ... + +class CatalogReservation(_message.Message): + __slots__ = [] + class Status(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + RESERVATION_DISABLED: _ClassVar[CatalogReservation.Status] + RESERVATION_ACQUIRED: _ClassVar[CatalogReservation.Status] + RESERVATION_EXISTS: _ClassVar[CatalogReservation.Status] + RESERVATION_RELEASED: _ClassVar[CatalogReservation.Status] + RESERVATION_FAILURE: _ClassVar[CatalogReservation.Status] + RESERVATION_DISABLED: CatalogReservation.Status + RESERVATION_ACQUIRED: CatalogReservation.Status + RESERVATION_EXISTS: CatalogReservation.Status + RESERVATION_RELEASED: CatalogReservation.Status + RESERVATION_FAILURE: CatalogReservation.Status + def __init__(self) -> None: ... diff --git a/gen/python/flyteidl2/core/catalog_pb2_grpc.py b/gen/python/flyteidl2/core/catalog_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/core/catalog_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/core/errors_pb2.py b/gen/python/flyteidl2/core/errors_pb2.py new file mode 100644 index 0000000000..b6d8b5e769 --- /dev/null +++ b/gen/python/flyteidl2/core/errors_pb2.py @@ -0,0 +1,31 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/core/errors.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.core import execution_pb2 as flyteidl2_dot_core_dot_execution__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1b\x66lyteidl2/core/errors.proto\x12\x0e\x66lyteidl2.core\x1a\x1e\x66lyteidl2/core/execution.proto\"\xe7\x01\n\x0e\x43ontainerError\x12\x12\n\x04\x63ode\x18\x01 \x01(\tR\x04\x63ode\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\x12\x37\n\x04kind\x18\x03 \x01(\x0e\x32#.flyteidl2.core.ContainerError.KindR\x04kind\x12@\n\x06origin\x18\x04 \x01(\x0e\x32(.flyteidl2.core.ExecutionError.ErrorKindR\x06origin\",\n\x04Kind\x12\x13\n\x0fNON_RECOVERABLE\x10\x00\x12\x0f\n\x0bRECOVERABLE\x10\x01\"E\n\rErrorDocument\x12\x34\n\x05\x65rror\x18\x01 \x01(\x0b\x32\x1e.flyteidl2.core.ContainerErrorR\x05\x65rrorB\xb0\x01\n\x12\x63om.flyteidl2.coreB\x0b\x45rrorsProtoH\x02P\x01Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\xa2\x02\x03\x46\x43X\xaa\x02\x0e\x46lyteidl2.Core\xca\x02\x0e\x46lyteidl2\\Core\xe2\x02\x1a\x46lyteidl2\\Core\\GPBMetadata\xea\x02\x0f\x46lyteidl2::Coreb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.core.errors_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\022com.flyteidl2.coreB\013ErrorsProtoH\002P\001Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\242\002\003FCX\252\002\016Flyteidl2.Core\312\002\016Flyteidl2\\Core\342\002\032Flyteidl2\\Core\\GPBMetadata\352\002\017Flyteidl2::Core' + _globals['_CONTAINERERROR']._serialized_start=80 + _globals['_CONTAINERERROR']._serialized_end=311 + _globals['_CONTAINERERROR_KIND']._serialized_start=267 + _globals['_CONTAINERERROR_KIND']._serialized_end=311 + _globals['_ERRORDOCUMENT']._serialized_start=313 + _globals['_ERRORDOCUMENT']._serialized_end=382 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/core/errors_pb2.pyi b/gen/python/flyteidl2/core/errors_pb2.pyi new file mode 100644 index 0000000000..b990af6eb9 --- /dev/null +++ b/gen/python/flyteidl2/core/errors_pb2.pyi @@ -0,0 +1,31 @@ +from flyteidl2.core import execution_pb2 as _execution_pb2 +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class ContainerError(_message.Message): + __slots__ = ["code", "message", "kind", "origin"] + class Kind(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + NON_RECOVERABLE: _ClassVar[ContainerError.Kind] + RECOVERABLE: _ClassVar[ContainerError.Kind] + NON_RECOVERABLE: ContainerError.Kind + RECOVERABLE: ContainerError.Kind + CODE_FIELD_NUMBER: _ClassVar[int] + MESSAGE_FIELD_NUMBER: _ClassVar[int] + KIND_FIELD_NUMBER: _ClassVar[int] + ORIGIN_FIELD_NUMBER: _ClassVar[int] + code: str + message: str + kind: ContainerError.Kind + origin: _execution_pb2.ExecutionError.ErrorKind + def __init__(self, code: _Optional[str] = ..., message: _Optional[str] = ..., kind: _Optional[_Union[ContainerError.Kind, str]] = ..., origin: _Optional[_Union[_execution_pb2.ExecutionError.ErrorKind, str]] = ...) -> None: ... + +class ErrorDocument(_message.Message): + __slots__ = ["error"] + ERROR_FIELD_NUMBER: _ClassVar[int] + error: ContainerError + def __init__(self, error: _Optional[_Union[ContainerError, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/core/errors_pb2_grpc.py b/gen/python/flyteidl2/core/errors_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/core/errors_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/core/execution_pb2.py b/gen/python/flyteidl2/core/execution_pb2.py new file mode 100644 index 0000000000..60ce5cc97d --- /dev/null +++ b/gen/python/flyteidl2/core/execution_pb2.py @@ -0,0 +1,62 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/core/execution.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1e\x66lyteidl2/core/execution.proto\x12\x0e\x66lyteidl2.core\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xa7\x01\n\x11WorkflowExecution\"\x91\x01\n\x05Phase\x12\r\n\tUNDEFINED\x10\x00\x12\n\n\x06QUEUED\x10\x01\x12\x0b\n\x07RUNNING\x10\x02\x12\x0e\n\nSUCCEEDING\x10\x03\x12\r\n\tSUCCEEDED\x10\x04\x12\x0b\n\x07\x46\x41ILING\x10\x05\x12\n\n\x06\x46\x41ILED\x10\x06\x12\x0b\n\x07\x41\x42ORTED\x10\x07\x12\r\n\tTIMED_OUT\x10\x08\x12\x0c\n\x08\x41\x42ORTING\x10\t\"\xb6\x01\n\rNodeExecution\"\xa4\x01\n\x05Phase\x12\r\n\tUNDEFINED\x10\x00\x12\n\n\x06QUEUED\x10\x01\x12\x0b\n\x07RUNNING\x10\x02\x12\r\n\tSUCCEEDED\x10\x03\x12\x0b\n\x07\x46\x41ILING\x10\x04\x12\n\n\x06\x46\x41ILED\x10\x05\x12\x0b\n\x07\x41\x42ORTED\x10\x06\x12\x0b\n\x07SKIPPED\x10\x07\x12\r\n\tTIMED_OUT\x10\x08\x12\x13\n\x0f\x44YNAMIC_RUNNING\x10\t\x12\r\n\tRECOVERED\x10\n\"\xac\x01\n\rTaskExecution\"\x9a\x01\n\x05Phase\x12\r\n\tUNDEFINED\x10\x00\x12\n\n\x06QUEUED\x10\x01\x12\x0b\n\x07RUNNING\x10\x02\x12\r\n\tSUCCEEDED\x10\x03\x12\x0b\n\x07\x41\x42ORTED\x10\x04\x12\n\n\x06\x46\x41ILED\x10\x05\x12\x10\n\x0cINITIALIZING\x10\x06\x12\x19\n\x15WAITING_FOR_RESOURCES\x10\x07\x12\x14\n\x10RETRYABLE_FAILED\x10\x08\"\x9b\x02\n\x0e\x45xecutionError\x12\x12\n\x04\x63ode\x18\x01 \x01(\tR\x04\x63ode\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\x12\x1b\n\terror_uri\x18\x03 \x01(\tR\x08\x65rrorUri\x12<\n\x04kind\x18\x04 \x01(\x0e\x32(.flyteidl2.core.ExecutionError.ErrorKindR\x04kind\x12\x38\n\ttimestamp\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\ttimestamp\x12\x16\n\x06worker\x18\x06 \x01(\tR\x06worker\".\n\tErrorKind\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x08\n\x04USER\x10\x01\x12\n\n\x06SYSTEM\x10\x02\"\xd5\x03\n\x07TaskLog\x12\x10\n\x03uri\x18\x01 \x01(\tR\x03uri\x12\x12\n\x04name\x18\x02 \x01(\tR\x04name\x12L\n\x0emessage_format\x18\x03 \x01(\x0e\x32%.flyteidl2.core.TaskLog.MessageFormatR\rmessageFormat\x12+\n\x03ttl\x18\x04 \x01(\x0b\x32\x19.google.protobuf.DurationR\x03ttl\x12*\n\x10ShowWhilePending\x18\x05 \x01(\x08R\x10ShowWhilePending\x12*\n\x10HideOnceFinished\x18\x06 \x01(\x08R\x10HideOnceFinished\x12=\n\tlink_type\x18\x07 \x01(\x0e\x32 .flyteidl2.core.TaskLog.LinkTypeR\x08linkType\x12\x14\n\x05ready\x18\x08 \x01(\x08R\x05ready\x12\x19\n\x08icon_uri\x18\t \x01(\tR\x07iconUri\"/\n\rMessageFormat\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x07\n\x03\x43SV\x10\x01\x12\x08\n\x04JSON\x10\x02\"0\n\x08LinkType\x12\x0c\n\x08\x45XTERNAL\x10\x00\x12\r\n\tDASHBOARD\x10\x01\x12\x07\n\x03IDE\x10\x02\"i\n\nLogContext\x12\x31\n\x04pods\x18\x01 \x03(\x0b\x32\x1d.flyteidl2.core.PodLogContextR\x04pods\x12(\n\x10primary_pod_name\x18\x02 \x01(\tR\x0eprimaryPodName\"\x8b\x02\n\rPodLogContext\x12\x1c\n\tnamespace\x18\x01 \x01(\tR\tnamespace\x12\x19\n\x08pod_name\x18\x02 \x01(\tR\x07podName\x12@\n\ncontainers\x18\x03 \x03(\x0b\x32 .flyteidl2.core.ContainerContextR\ncontainers\x12\x34\n\x16primary_container_name\x18\x04 \x01(\tR\x14primaryContainerName\x12I\n\x0finit_containers\x18\x05 \x03(\x0b\x32 .flyteidl2.core.ContainerContextR\x0einitContainers\"\xaf\x02\n\x10\x43ontainerContext\x12%\n\x0e\x63ontainer_name\x18\x01 \x01(\tR\rcontainerName\x12I\n\x07process\x18\x02 \x01(\x0b\x32/.flyteidl2.core.ContainerContext.ProcessContextR\x07process\x1a\xa8\x01\n\x0eProcessContext\x12L\n\x14\x63ontainer_start_time\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x12\x63ontainerStartTime\x12H\n\x12\x63ontainer_end_time\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x10\x63ontainerEndTime\"Z\n\x14QualityOfServiceSpec\x12\x42\n\x0fqueueing_budget\x18\x01 \x01(\x0b\x32\x19.google.protobuf.DurationR\x0equeueingBudget\"\xd0\x01\n\x10QualityOfService\x12;\n\x04tier\x18\x01 \x01(\x0e\x32%.flyteidl2.core.QualityOfService.TierH\x00R\x04tier\x12:\n\x04spec\x18\x02 \x01(\x0b\x32$.flyteidl2.core.QualityOfServiceSpecH\x00R\x04spec\"4\n\x04Tier\x12\r\n\tUNDEFINED\x10\x00\x12\x08\n\x04HIGH\x10\x01\x12\n\n\x06MEDIUM\x10\x02\x12\x07\n\x03LOW\x10\x03\x42\r\n\x0b\x64\x65signationB\xb3\x01\n\x12\x63om.flyteidl2.coreB\x0e\x45xecutionProtoH\x02P\x01Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\xa2\x02\x03\x46\x43X\xaa\x02\x0e\x46lyteidl2.Core\xca\x02\x0e\x46lyteidl2\\Core\xe2\x02\x1a\x46lyteidl2\\Core\\GPBMetadata\xea\x02\x0f\x46lyteidl2::Coreb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.core.execution_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\022com.flyteidl2.coreB\016ExecutionProtoH\002P\001Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\242\002\003FCX\252\002\016Flyteidl2.Core\312\002\016Flyteidl2\\Core\342\002\032Flyteidl2\\Core\\GPBMetadata\352\002\017Flyteidl2::Core' + _globals['_WORKFLOWEXECUTION']._serialized_start=116 + _globals['_WORKFLOWEXECUTION']._serialized_end=283 + _globals['_WORKFLOWEXECUTION_PHASE']._serialized_start=138 + _globals['_WORKFLOWEXECUTION_PHASE']._serialized_end=283 + _globals['_NODEEXECUTION']._serialized_start=286 + _globals['_NODEEXECUTION']._serialized_end=468 + _globals['_NODEEXECUTION_PHASE']._serialized_start=304 + _globals['_NODEEXECUTION_PHASE']._serialized_end=468 + _globals['_TASKEXECUTION']._serialized_start=471 + _globals['_TASKEXECUTION']._serialized_end=643 + _globals['_TASKEXECUTION_PHASE']._serialized_start=489 + _globals['_TASKEXECUTION_PHASE']._serialized_end=643 + _globals['_EXECUTIONERROR']._serialized_start=646 + _globals['_EXECUTIONERROR']._serialized_end=929 + _globals['_EXECUTIONERROR_ERRORKIND']._serialized_start=883 + _globals['_EXECUTIONERROR_ERRORKIND']._serialized_end=929 + _globals['_TASKLOG']._serialized_start=932 + _globals['_TASKLOG']._serialized_end=1401 + _globals['_TASKLOG_MESSAGEFORMAT']._serialized_start=1304 + _globals['_TASKLOG_MESSAGEFORMAT']._serialized_end=1351 + _globals['_TASKLOG_LINKTYPE']._serialized_start=1353 + _globals['_TASKLOG_LINKTYPE']._serialized_end=1401 + _globals['_LOGCONTEXT']._serialized_start=1403 + _globals['_LOGCONTEXT']._serialized_end=1508 + _globals['_PODLOGCONTEXT']._serialized_start=1511 + _globals['_PODLOGCONTEXT']._serialized_end=1778 + _globals['_CONTAINERCONTEXT']._serialized_start=1781 + _globals['_CONTAINERCONTEXT']._serialized_end=2084 + _globals['_CONTAINERCONTEXT_PROCESSCONTEXT']._serialized_start=1916 + _globals['_CONTAINERCONTEXT_PROCESSCONTEXT']._serialized_end=2084 + _globals['_QUALITYOFSERVICESPEC']._serialized_start=2086 + _globals['_QUALITYOFSERVICESPEC']._serialized_end=2176 + _globals['_QUALITYOFSERVICE']._serialized_start=2179 + _globals['_QUALITYOFSERVICE']._serialized_end=2387 + _globals['_QUALITYOFSERVICE_TIER']._serialized_start=2320 + _globals['_QUALITYOFSERVICE_TIER']._serialized_end=2372 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/core/execution_pb2.pyi b/gen/python/flyteidl2/core/execution_pb2.pyi new file mode 100644 index 0000000000..05fbdca8a9 --- /dev/null +++ b/gen/python/flyteidl2/core/execution_pb2.pyi @@ -0,0 +1,210 @@ +from google.protobuf import duration_pb2 as _duration_pb2 +from google.protobuf import timestamp_pb2 as _timestamp_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class WorkflowExecution(_message.Message): + __slots__ = [] + class Phase(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + UNDEFINED: _ClassVar[WorkflowExecution.Phase] + QUEUED: _ClassVar[WorkflowExecution.Phase] + RUNNING: _ClassVar[WorkflowExecution.Phase] + SUCCEEDING: _ClassVar[WorkflowExecution.Phase] + SUCCEEDED: _ClassVar[WorkflowExecution.Phase] + FAILING: _ClassVar[WorkflowExecution.Phase] + FAILED: _ClassVar[WorkflowExecution.Phase] + ABORTED: _ClassVar[WorkflowExecution.Phase] + TIMED_OUT: _ClassVar[WorkflowExecution.Phase] + ABORTING: _ClassVar[WorkflowExecution.Phase] + UNDEFINED: WorkflowExecution.Phase + QUEUED: WorkflowExecution.Phase + RUNNING: WorkflowExecution.Phase + SUCCEEDING: WorkflowExecution.Phase + SUCCEEDED: WorkflowExecution.Phase + FAILING: WorkflowExecution.Phase + FAILED: WorkflowExecution.Phase + ABORTED: WorkflowExecution.Phase + TIMED_OUT: WorkflowExecution.Phase + ABORTING: WorkflowExecution.Phase + def __init__(self) -> None: ... + +class NodeExecution(_message.Message): + __slots__ = [] + class Phase(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + UNDEFINED: _ClassVar[NodeExecution.Phase] + QUEUED: _ClassVar[NodeExecution.Phase] + RUNNING: _ClassVar[NodeExecution.Phase] + SUCCEEDED: _ClassVar[NodeExecution.Phase] + FAILING: _ClassVar[NodeExecution.Phase] + FAILED: _ClassVar[NodeExecution.Phase] + ABORTED: _ClassVar[NodeExecution.Phase] + SKIPPED: _ClassVar[NodeExecution.Phase] + TIMED_OUT: _ClassVar[NodeExecution.Phase] + DYNAMIC_RUNNING: _ClassVar[NodeExecution.Phase] + RECOVERED: _ClassVar[NodeExecution.Phase] + UNDEFINED: NodeExecution.Phase + QUEUED: NodeExecution.Phase + RUNNING: NodeExecution.Phase + SUCCEEDED: NodeExecution.Phase + FAILING: NodeExecution.Phase + FAILED: NodeExecution.Phase + ABORTED: NodeExecution.Phase + SKIPPED: NodeExecution.Phase + TIMED_OUT: NodeExecution.Phase + DYNAMIC_RUNNING: NodeExecution.Phase + RECOVERED: NodeExecution.Phase + def __init__(self) -> None: ... + +class TaskExecution(_message.Message): + __slots__ = [] + class Phase(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + UNDEFINED: _ClassVar[TaskExecution.Phase] + QUEUED: _ClassVar[TaskExecution.Phase] + RUNNING: _ClassVar[TaskExecution.Phase] + SUCCEEDED: _ClassVar[TaskExecution.Phase] + ABORTED: _ClassVar[TaskExecution.Phase] + FAILED: _ClassVar[TaskExecution.Phase] + INITIALIZING: _ClassVar[TaskExecution.Phase] + WAITING_FOR_RESOURCES: _ClassVar[TaskExecution.Phase] + RETRYABLE_FAILED: _ClassVar[TaskExecution.Phase] + UNDEFINED: TaskExecution.Phase + QUEUED: TaskExecution.Phase + RUNNING: TaskExecution.Phase + SUCCEEDED: TaskExecution.Phase + ABORTED: TaskExecution.Phase + FAILED: TaskExecution.Phase + INITIALIZING: TaskExecution.Phase + WAITING_FOR_RESOURCES: TaskExecution.Phase + RETRYABLE_FAILED: TaskExecution.Phase + def __init__(self) -> None: ... + +class ExecutionError(_message.Message): + __slots__ = ["code", "message", "error_uri", "kind", "timestamp", "worker"] + class ErrorKind(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + UNKNOWN: _ClassVar[ExecutionError.ErrorKind] + USER: _ClassVar[ExecutionError.ErrorKind] + SYSTEM: _ClassVar[ExecutionError.ErrorKind] + UNKNOWN: ExecutionError.ErrorKind + USER: ExecutionError.ErrorKind + SYSTEM: ExecutionError.ErrorKind + CODE_FIELD_NUMBER: _ClassVar[int] + MESSAGE_FIELD_NUMBER: _ClassVar[int] + ERROR_URI_FIELD_NUMBER: _ClassVar[int] + KIND_FIELD_NUMBER: _ClassVar[int] + TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + WORKER_FIELD_NUMBER: _ClassVar[int] + code: str + message: str + error_uri: str + kind: ExecutionError.ErrorKind + timestamp: _timestamp_pb2.Timestamp + worker: str + def __init__(self, code: _Optional[str] = ..., message: _Optional[str] = ..., error_uri: _Optional[str] = ..., kind: _Optional[_Union[ExecutionError.ErrorKind, str]] = ..., timestamp: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., worker: _Optional[str] = ...) -> None: ... + +class TaskLog(_message.Message): + __slots__ = ["uri", "name", "message_format", "ttl", "ShowWhilePending", "HideOnceFinished", "link_type", "ready", "icon_uri"] + class MessageFormat(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + UNKNOWN: _ClassVar[TaskLog.MessageFormat] + CSV: _ClassVar[TaskLog.MessageFormat] + JSON: _ClassVar[TaskLog.MessageFormat] + UNKNOWN: TaskLog.MessageFormat + CSV: TaskLog.MessageFormat + JSON: TaskLog.MessageFormat + class LinkType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + EXTERNAL: _ClassVar[TaskLog.LinkType] + DASHBOARD: _ClassVar[TaskLog.LinkType] + IDE: _ClassVar[TaskLog.LinkType] + EXTERNAL: TaskLog.LinkType + DASHBOARD: TaskLog.LinkType + IDE: TaskLog.LinkType + URI_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + MESSAGE_FORMAT_FIELD_NUMBER: _ClassVar[int] + TTL_FIELD_NUMBER: _ClassVar[int] + SHOWWHILEPENDING_FIELD_NUMBER: _ClassVar[int] + HIDEONCEFINISHED_FIELD_NUMBER: _ClassVar[int] + LINK_TYPE_FIELD_NUMBER: _ClassVar[int] + READY_FIELD_NUMBER: _ClassVar[int] + ICON_URI_FIELD_NUMBER: _ClassVar[int] + uri: str + name: str + message_format: TaskLog.MessageFormat + ttl: _duration_pb2.Duration + ShowWhilePending: bool + HideOnceFinished: bool + link_type: TaskLog.LinkType + ready: bool + icon_uri: str + def __init__(self, uri: _Optional[str] = ..., name: _Optional[str] = ..., message_format: _Optional[_Union[TaskLog.MessageFormat, str]] = ..., ttl: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., ShowWhilePending: bool = ..., HideOnceFinished: bool = ..., link_type: _Optional[_Union[TaskLog.LinkType, str]] = ..., ready: bool = ..., icon_uri: _Optional[str] = ...) -> None: ... + +class LogContext(_message.Message): + __slots__ = ["pods", "primary_pod_name"] + PODS_FIELD_NUMBER: _ClassVar[int] + PRIMARY_POD_NAME_FIELD_NUMBER: _ClassVar[int] + pods: _containers.RepeatedCompositeFieldContainer[PodLogContext] + primary_pod_name: str + def __init__(self, pods: _Optional[_Iterable[_Union[PodLogContext, _Mapping]]] = ..., primary_pod_name: _Optional[str] = ...) -> None: ... + +class PodLogContext(_message.Message): + __slots__ = ["namespace", "pod_name", "containers", "primary_container_name", "init_containers"] + NAMESPACE_FIELD_NUMBER: _ClassVar[int] + POD_NAME_FIELD_NUMBER: _ClassVar[int] + CONTAINERS_FIELD_NUMBER: _ClassVar[int] + PRIMARY_CONTAINER_NAME_FIELD_NUMBER: _ClassVar[int] + INIT_CONTAINERS_FIELD_NUMBER: _ClassVar[int] + namespace: str + pod_name: str + containers: _containers.RepeatedCompositeFieldContainer[ContainerContext] + primary_container_name: str + init_containers: _containers.RepeatedCompositeFieldContainer[ContainerContext] + def __init__(self, namespace: _Optional[str] = ..., pod_name: _Optional[str] = ..., containers: _Optional[_Iterable[_Union[ContainerContext, _Mapping]]] = ..., primary_container_name: _Optional[str] = ..., init_containers: _Optional[_Iterable[_Union[ContainerContext, _Mapping]]] = ...) -> None: ... + +class ContainerContext(_message.Message): + __slots__ = ["container_name", "process"] + class ProcessContext(_message.Message): + __slots__ = ["container_start_time", "container_end_time"] + CONTAINER_START_TIME_FIELD_NUMBER: _ClassVar[int] + CONTAINER_END_TIME_FIELD_NUMBER: _ClassVar[int] + container_start_time: _timestamp_pb2.Timestamp + container_end_time: _timestamp_pb2.Timestamp + def __init__(self, container_start_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., container_end_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ...) -> None: ... + CONTAINER_NAME_FIELD_NUMBER: _ClassVar[int] + PROCESS_FIELD_NUMBER: _ClassVar[int] + container_name: str + process: ContainerContext.ProcessContext + def __init__(self, container_name: _Optional[str] = ..., process: _Optional[_Union[ContainerContext.ProcessContext, _Mapping]] = ...) -> None: ... + +class QualityOfServiceSpec(_message.Message): + __slots__ = ["queueing_budget"] + QUEUEING_BUDGET_FIELD_NUMBER: _ClassVar[int] + queueing_budget: _duration_pb2.Duration + def __init__(self, queueing_budget: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ...) -> None: ... + +class QualityOfService(_message.Message): + __slots__ = ["tier", "spec"] + class Tier(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + UNDEFINED: _ClassVar[QualityOfService.Tier] + HIGH: _ClassVar[QualityOfService.Tier] + MEDIUM: _ClassVar[QualityOfService.Tier] + LOW: _ClassVar[QualityOfService.Tier] + UNDEFINED: QualityOfService.Tier + HIGH: QualityOfService.Tier + MEDIUM: QualityOfService.Tier + LOW: QualityOfService.Tier + TIER_FIELD_NUMBER: _ClassVar[int] + SPEC_FIELD_NUMBER: _ClassVar[int] + tier: QualityOfService.Tier + spec: QualityOfServiceSpec + def __init__(self, tier: _Optional[_Union[QualityOfService.Tier, str]] = ..., spec: _Optional[_Union[QualityOfServiceSpec, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/core/execution_pb2_grpc.py b/gen/python/flyteidl2/core/execution_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/core/execution_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/core/identifier_pb2.py b/gen/python/flyteidl2/core/identifier_pb2.py new file mode 100644 index 0000000000..136f154071 --- /dev/null +++ b/gen/python/flyteidl2/core/identifier_pb2.py @@ -0,0 +1,36 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/core/identifier.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1f\x66lyteidl2/core/identifier.proto\x12\x0e\x66lyteidl2.core\"\xc1\x01\n\nIdentifier\x12\x41\n\rresource_type\x18\x01 \x01(\x0e\x32\x1c.flyteidl2.core.ResourceTypeR\x0cresourceType\x12\x18\n\x07project\x18\x02 \x01(\tR\x07project\x12\x16\n\x06\x64omain\x18\x03 \x01(\tR\x06\x64omain\x12\x12\n\x04name\x18\x04 \x01(\tR\x04name\x12\x18\n\x07version\x18\x05 \x01(\tR\x07version\x12\x10\n\x03org\x18\x06 \x01(\tR\x03org\"u\n\x1bWorkflowExecutionIdentifier\x12\x18\n\x07project\x18\x01 \x01(\tR\x07project\x12\x16\n\x06\x64omain\x18\x02 \x01(\tR\x06\x64omain\x12\x12\n\x04name\x18\x04 \x01(\tR\x04name\x12\x10\n\x03org\x18\x05 \x01(\tR\x03org\"\x82\x01\n\x17NodeExecutionIdentifier\x12\x17\n\x07node_id\x18\x01 \x01(\tR\x06nodeId\x12N\n\x0c\x65xecution_id\x18\x02 \x01(\x0b\x32+.flyteidl2.core.WorkflowExecutionIdentifierR\x0b\x65xecutionId\"\xc8\x01\n\x17TaskExecutionIdentifier\x12\x33\n\x07task_id\x18\x01 \x01(\x0b\x32\x1a.flyteidl2.core.IdentifierR\x06taskId\x12S\n\x11node_execution_id\x18\x02 \x01(\x0b\x32\'.flyteidl2.core.NodeExecutionIdentifierR\x0fnodeExecutionId\x12#\n\rretry_attempt\x18\x03 \x01(\rR\x0cretryAttempt\"\x7f\n\x10SignalIdentifier\x12\x1b\n\tsignal_id\x18\x01 \x01(\tR\x08signalId\x12N\n\x0c\x65xecution_id\x18\x02 \x01(\x0b\x32+.flyteidl2.core.WorkflowExecutionIdentifierR\x0b\x65xecutionId*U\n\x0cResourceType\x12\x0f\n\x0bUNSPECIFIED\x10\x00\x12\x08\n\x04TASK\x10\x01\x12\x0c\n\x08WORKFLOW\x10\x02\x12\x0f\n\x0bLAUNCH_PLAN\x10\x03\x12\x0b\n\x07\x44\x41TASET\x10\x04\x42\xb4\x01\n\x12\x63om.flyteidl2.coreB\x0fIdentifierProtoH\x02P\x01Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\xa2\x02\x03\x46\x43X\xaa\x02\x0e\x46lyteidl2.Core\xca\x02\x0e\x46lyteidl2\\Core\xe2\x02\x1a\x46lyteidl2\\Core\\GPBMetadata\xea\x02\x0f\x46lyteidl2::Coreb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.core.identifier_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\022com.flyteidl2.coreB\017IdentifierProtoH\002P\001Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\242\002\003FCX\252\002\016Flyteidl2.Core\312\002\016Flyteidl2\\Core\342\002\032Flyteidl2\\Core\\GPBMetadata\352\002\017Flyteidl2::Core' + _globals['_RESOURCETYPE']._serialized_start=831 + _globals['_RESOURCETYPE']._serialized_end=916 + _globals['_IDENTIFIER']._serialized_start=52 + _globals['_IDENTIFIER']._serialized_end=245 + _globals['_WORKFLOWEXECUTIONIDENTIFIER']._serialized_start=247 + _globals['_WORKFLOWEXECUTIONIDENTIFIER']._serialized_end=364 + _globals['_NODEEXECUTIONIDENTIFIER']._serialized_start=367 + _globals['_NODEEXECUTIONIDENTIFIER']._serialized_end=497 + _globals['_TASKEXECUTIONIDENTIFIER']._serialized_start=500 + _globals['_TASKEXECUTIONIDENTIFIER']._serialized_end=700 + _globals['_SIGNALIDENTIFIER']._serialized_start=702 + _globals['_SIGNALIDENTIFIER']._serialized_end=829 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/core/identifier_pb2.pyi b/gen/python/flyteidl2/core/identifier_pb2.pyi new file mode 100644 index 0000000000..5d3857195e --- /dev/null +++ b/gen/python/flyteidl2/core/identifier_pb2.pyi @@ -0,0 +1,73 @@ +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class ResourceType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + UNSPECIFIED: _ClassVar[ResourceType] + TASK: _ClassVar[ResourceType] + WORKFLOW: _ClassVar[ResourceType] + LAUNCH_PLAN: _ClassVar[ResourceType] + DATASET: _ClassVar[ResourceType] +UNSPECIFIED: ResourceType +TASK: ResourceType +WORKFLOW: ResourceType +LAUNCH_PLAN: ResourceType +DATASET: ResourceType + +class Identifier(_message.Message): + __slots__ = ["resource_type", "project", "domain", "name", "version", "org"] + RESOURCE_TYPE_FIELD_NUMBER: _ClassVar[int] + PROJECT_FIELD_NUMBER: _ClassVar[int] + DOMAIN_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + VERSION_FIELD_NUMBER: _ClassVar[int] + ORG_FIELD_NUMBER: _ClassVar[int] + resource_type: ResourceType + project: str + domain: str + name: str + version: str + org: str + def __init__(self, resource_type: _Optional[_Union[ResourceType, str]] = ..., project: _Optional[str] = ..., domain: _Optional[str] = ..., name: _Optional[str] = ..., version: _Optional[str] = ..., org: _Optional[str] = ...) -> None: ... + +class WorkflowExecutionIdentifier(_message.Message): + __slots__ = ["project", "domain", "name", "org"] + PROJECT_FIELD_NUMBER: _ClassVar[int] + DOMAIN_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + ORG_FIELD_NUMBER: _ClassVar[int] + project: str + domain: str + name: str + org: str + def __init__(self, project: _Optional[str] = ..., domain: _Optional[str] = ..., name: _Optional[str] = ..., org: _Optional[str] = ...) -> None: ... + +class NodeExecutionIdentifier(_message.Message): + __slots__ = ["node_id", "execution_id"] + NODE_ID_FIELD_NUMBER: _ClassVar[int] + EXECUTION_ID_FIELD_NUMBER: _ClassVar[int] + node_id: str + execution_id: WorkflowExecutionIdentifier + def __init__(self, node_id: _Optional[str] = ..., execution_id: _Optional[_Union[WorkflowExecutionIdentifier, _Mapping]] = ...) -> None: ... + +class TaskExecutionIdentifier(_message.Message): + __slots__ = ["task_id", "node_execution_id", "retry_attempt"] + TASK_ID_FIELD_NUMBER: _ClassVar[int] + NODE_EXECUTION_ID_FIELD_NUMBER: _ClassVar[int] + RETRY_ATTEMPT_FIELD_NUMBER: _ClassVar[int] + task_id: Identifier + node_execution_id: NodeExecutionIdentifier + retry_attempt: int + def __init__(self, task_id: _Optional[_Union[Identifier, _Mapping]] = ..., node_execution_id: _Optional[_Union[NodeExecutionIdentifier, _Mapping]] = ..., retry_attempt: _Optional[int] = ...) -> None: ... + +class SignalIdentifier(_message.Message): + __slots__ = ["signal_id", "execution_id"] + SIGNAL_ID_FIELD_NUMBER: _ClassVar[int] + EXECUTION_ID_FIELD_NUMBER: _ClassVar[int] + signal_id: str + execution_id: WorkflowExecutionIdentifier + def __init__(self, signal_id: _Optional[str] = ..., execution_id: _Optional[_Union[WorkflowExecutionIdentifier, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/core/identifier_pb2_grpc.py b/gen/python/flyteidl2/core/identifier_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/core/identifier_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/core/interface_pb2.py b/gen/python/flyteidl2/core/interface_pb2.py new file mode 100644 index 0000000000..e884a7a758 --- /dev/null +++ b/gen/python/flyteidl2/core/interface_pb2.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/core/interface.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.core import artifact_id_pb2 as flyteidl2_dot_core_dot_artifact__id__pb2 +from flyteidl2.core import literals_pb2 as flyteidl2_dot_core_dot_literals__pb2 +from flyteidl2.core import types_pb2 as flyteidl2_dot_core_dot_types__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1e\x66lyteidl2/core/interface.proto\x12\x0e\x66lyteidl2.core\x1a flyteidl2/core/artifact_id.proto\x1a\x1d\x66lyteidl2/core/literals.proto\x1a\x1a\x66lyteidl2/core/types.proto\"\xe9\x01\n\x08Variable\x12/\n\x04type\x18\x01 \x01(\x0b\x32\x1b.flyteidl2.core.LiteralTypeR\x04type\x12 \n\x0b\x64\x65scription\x18\x02 \x01(\tR\x0b\x64\x65scription\x12J\n\x13\x61rtifact_partial_id\x18\x03 \x01(\x0b\x32\x1a.flyteidl2.core.ArtifactIDR\x11\x61rtifactPartialId\x12>\n\x0c\x61rtifact_tag\x18\x04 \x01(\x0b\x32\x1b.flyteidl2.core.ArtifactTagR\x0b\x61rtifactTag\"\xaf\x01\n\x0bVariableMap\x12H\n\tvariables\x18\x01 \x03(\x0b\x32*.flyteidl2.core.VariableMap.VariablesEntryR\tvariables\x1aV\n\x0eVariablesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12.\n\x05value\x18\x02 \x01(\x0b\x32\x18.flyteidl2.core.VariableR\x05value:\x02\x38\x01\"|\n\x0eTypedInterface\x12\x33\n\x06inputs\x18\x01 \x01(\x0b\x32\x1b.flyteidl2.core.VariableMapR\x06inputs\x12\x35\n\x07outputs\x18\x02 \x01(\x0b\x32\x1b.flyteidl2.core.VariableMapR\x07outputs\"\x9d\x02\n\tParameter\x12*\n\x03var\x18\x01 \x01(\x0b\x32\x18.flyteidl2.core.VariableR\x03var\x12\x33\n\x07\x64\x65\x66\x61ult\x18\x02 \x01(\x0b\x32\x17.flyteidl2.core.LiteralH\x00R\x07\x64\x65\x66\x61ult\x12\x1c\n\x08required\x18\x03 \x01(\x08H\x00R\x08required\x12\x46\n\x0e\x61rtifact_query\x18\x04 \x01(\x0b\x32\x1d.flyteidl2.core.ArtifactQueryH\x00R\rartifactQuery\x12=\n\x0b\x61rtifact_id\x18\x05 \x01(\x0b\x32\x1a.flyteidl2.core.ArtifactIDH\x00R\nartifactIdB\n\n\x08\x62\x65havior\"\xb6\x01\n\x0cParameterMap\x12L\n\nparameters\x18\x01 \x03(\x0b\x32,.flyteidl2.core.ParameterMap.ParametersEntryR\nparameters\x1aX\n\x0fParametersEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12/\n\x05value\x18\x02 \x01(\x0b\x32\x19.flyteidl2.core.ParameterR\x05value:\x02\x38\x01\x42\xb3\x01\n\x12\x63om.flyteidl2.coreB\x0eInterfaceProtoH\x02P\x01Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\xa2\x02\x03\x46\x43X\xaa\x02\x0e\x46lyteidl2.Core\xca\x02\x0e\x46lyteidl2\\Core\xe2\x02\x1a\x46lyteidl2\\Core\\GPBMetadata\xea\x02\x0f\x46lyteidl2::Coreb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.core.interface_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\022com.flyteidl2.coreB\016InterfaceProtoH\002P\001Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\242\002\003FCX\252\002\016Flyteidl2.Core\312\002\016Flyteidl2\\Core\342\002\032Flyteidl2\\Core\\GPBMetadata\352\002\017Flyteidl2::Core' + _VARIABLEMAP_VARIABLESENTRY._options = None + _VARIABLEMAP_VARIABLESENTRY._serialized_options = b'8\001' + _PARAMETERMAP_PARAMETERSENTRY._options = None + _PARAMETERMAP_PARAMETERSENTRY._serialized_options = b'8\001' + _globals['_VARIABLE']._serialized_start=144 + _globals['_VARIABLE']._serialized_end=377 + _globals['_VARIABLEMAP']._serialized_start=380 + _globals['_VARIABLEMAP']._serialized_end=555 + _globals['_VARIABLEMAP_VARIABLESENTRY']._serialized_start=469 + _globals['_VARIABLEMAP_VARIABLESENTRY']._serialized_end=555 + _globals['_TYPEDINTERFACE']._serialized_start=557 + _globals['_TYPEDINTERFACE']._serialized_end=681 + _globals['_PARAMETER']._serialized_start=684 + _globals['_PARAMETER']._serialized_end=969 + _globals['_PARAMETERMAP']._serialized_start=972 + _globals['_PARAMETERMAP']._serialized_end=1154 + _globals['_PARAMETERMAP_PARAMETERSENTRY']._serialized_start=1066 + _globals['_PARAMETERMAP_PARAMETERSENTRY']._serialized_end=1154 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/core/interface_pb2.pyi b/gen/python/flyteidl2/core/interface_pb2.pyi new file mode 100644 index 0000000000..c5a6cc7efb --- /dev/null +++ b/gen/python/flyteidl2/core/interface_pb2.pyi @@ -0,0 +1,69 @@ +from flyteidl2.core import artifact_id_pb2 as _artifact_id_pb2 +from flyteidl2.core import literals_pb2 as _literals_pb2 +from flyteidl2.core import types_pb2 as _types_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class Variable(_message.Message): + __slots__ = ["type", "description", "artifact_partial_id", "artifact_tag"] + TYPE_FIELD_NUMBER: _ClassVar[int] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + ARTIFACT_PARTIAL_ID_FIELD_NUMBER: _ClassVar[int] + ARTIFACT_TAG_FIELD_NUMBER: _ClassVar[int] + type: _types_pb2.LiteralType + description: str + artifact_partial_id: _artifact_id_pb2.ArtifactID + artifact_tag: _artifact_id_pb2.ArtifactTag + def __init__(self, type: _Optional[_Union[_types_pb2.LiteralType, _Mapping]] = ..., description: _Optional[str] = ..., artifact_partial_id: _Optional[_Union[_artifact_id_pb2.ArtifactID, _Mapping]] = ..., artifact_tag: _Optional[_Union[_artifact_id_pb2.ArtifactTag, _Mapping]] = ...) -> None: ... + +class VariableMap(_message.Message): + __slots__ = ["variables"] + class VariablesEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: Variable + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Variable, _Mapping]] = ...) -> None: ... + VARIABLES_FIELD_NUMBER: _ClassVar[int] + variables: _containers.MessageMap[str, Variable] + def __init__(self, variables: _Optional[_Mapping[str, Variable]] = ...) -> None: ... + +class TypedInterface(_message.Message): + __slots__ = ["inputs", "outputs"] + INPUTS_FIELD_NUMBER: _ClassVar[int] + OUTPUTS_FIELD_NUMBER: _ClassVar[int] + inputs: VariableMap + outputs: VariableMap + def __init__(self, inputs: _Optional[_Union[VariableMap, _Mapping]] = ..., outputs: _Optional[_Union[VariableMap, _Mapping]] = ...) -> None: ... + +class Parameter(_message.Message): + __slots__ = ["var", "default", "required", "artifact_query", "artifact_id"] + VAR_FIELD_NUMBER: _ClassVar[int] + DEFAULT_FIELD_NUMBER: _ClassVar[int] + REQUIRED_FIELD_NUMBER: _ClassVar[int] + ARTIFACT_QUERY_FIELD_NUMBER: _ClassVar[int] + ARTIFACT_ID_FIELD_NUMBER: _ClassVar[int] + var: Variable + default: _literals_pb2.Literal + required: bool + artifact_query: _artifact_id_pb2.ArtifactQuery + artifact_id: _artifact_id_pb2.ArtifactID + def __init__(self, var: _Optional[_Union[Variable, _Mapping]] = ..., default: _Optional[_Union[_literals_pb2.Literal, _Mapping]] = ..., required: bool = ..., artifact_query: _Optional[_Union[_artifact_id_pb2.ArtifactQuery, _Mapping]] = ..., artifact_id: _Optional[_Union[_artifact_id_pb2.ArtifactID, _Mapping]] = ...) -> None: ... + +class ParameterMap(_message.Message): + __slots__ = ["parameters"] + class ParametersEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: Parameter + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Parameter, _Mapping]] = ...) -> None: ... + PARAMETERS_FIELD_NUMBER: _ClassVar[int] + parameters: _containers.MessageMap[str, Parameter] + def __init__(self, parameters: _Optional[_Mapping[str, Parameter]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/core/interface_pb2_grpc.py b/gen/python/flyteidl2/core/interface_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/core/interface_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/core/literals_pb2.py b/gen/python/flyteidl2/core/literals_pb2.py new file mode 100644 index 0000000000..4d060db283 --- /dev/null +++ b/gen/python/flyteidl2/core/literals_pb2.py @@ -0,0 +1,82 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/core/literals.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.core import types_pb2 as flyteidl2_dot_core_dot_types__pb2 +from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 +from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1d\x66lyteidl2/core/literals.proto\x12\x0e\x66lyteidl2.core\x1a\x1a\x66lyteidl2/core/types.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\x87\x02\n\tPrimitive\x12\x1a\n\x07integer\x18\x01 \x01(\x03H\x00R\x07integer\x12!\n\x0b\x66loat_value\x18\x02 \x01(\x01H\x00R\nfloatValue\x12#\n\x0cstring_value\x18\x03 \x01(\tH\x00R\x0bstringValue\x12\x1a\n\x07\x62oolean\x18\x04 \x01(\x08H\x00R\x07\x62oolean\x12\x38\n\x08\x64\x61tetime\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.TimestampH\x00R\x08\x64\x61tetime\x12\x37\n\x08\x64uration\x18\x06 \x01(\x0b\x32\x19.google.protobuf.DurationH\x00R\x08\x64urationB\x07\n\x05value\"\x06\n\x04Void\"R\n\x04\x42lob\x12\x38\n\x08metadata\x18\x01 \x01(\x0b\x32\x1c.flyteidl2.core.BlobMetadataR\x08metadata\x12\x10\n\x03uri\x18\x03 \x01(\tR\x03uri\"<\n\x0c\x42lobMetadata\x12,\n\x04type\x18\x01 \x01(\x0b\x32\x18.flyteidl2.core.BlobTypeR\x04type\"0\n\x06\x42inary\x12\x14\n\x05value\x18\x01 \x01(\x0cR\x05value\x12\x10\n\x03tag\x18\x02 \x01(\tR\x03tag\"J\n\x06Schema\x12\x10\n\x03uri\x18\x01 \x01(\tR\x03uri\x12.\n\x04type\x18\x03 \x01(\x0b\x32\x1a.flyteidl2.core.SchemaTypeR\x04type\"g\n\x05Union\x12-\n\x05value\x18\x01 \x01(\x0b\x32\x17.flyteidl2.core.LiteralR\x05value\x12/\n\x04type\x18\x02 \x01(\x0b\x32\x1b.flyteidl2.core.LiteralTypeR\x04type\"z\n\x19StructuredDatasetMetadata\x12]\n\x17structured_dataset_type\x18\x01 \x01(\x0b\x32%.flyteidl2.core.StructuredDatasetTypeR\x15structuredDatasetType\"l\n\x11StructuredDataset\x12\x10\n\x03uri\x18\x01 \x01(\tR\x03uri\x12\x45\n\x08metadata\x18\x02 \x01(\x0b\x32).flyteidl2.core.StructuredDatasetMetadataR\x08metadata\"\xf8\x03\n\x06Scalar\x12\x39\n\tprimitive\x18\x01 \x01(\x0b\x32\x19.flyteidl2.core.PrimitiveH\x00R\tprimitive\x12*\n\x04\x62lob\x18\x02 \x01(\x0b\x32\x14.flyteidl2.core.BlobH\x00R\x04\x62lob\x12\x30\n\x06\x62inary\x18\x03 \x01(\x0b\x32\x16.flyteidl2.core.BinaryH\x00R\x06\x62inary\x12\x30\n\x06schema\x18\x04 \x01(\x0b\x32\x16.flyteidl2.core.SchemaH\x00R\x06schema\x12\x33\n\tnone_type\x18\x05 \x01(\x0b\x32\x14.flyteidl2.core.VoidH\x00R\x08noneType\x12-\n\x05\x65rror\x18\x06 \x01(\x0b\x32\x15.flyteidl2.core.ErrorH\x00R\x05\x65rror\x12\x33\n\x07generic\x18\x07 \x01(\x0b\x32\x17.google.protobuf.StructH\x00R\x07generic\x12R\n\x12structured_dataset\x18\x08 \x01(\x0b\x32!.flyteidl2.core.StructuredDatasetH\x00R\x11structuredDataset\x12-\n\x05union\x18\t \x01(\x0b\x32\x15.flyteidl2.core.UnionH\x00R\x05unionB\x07\n\x05value\"\xb4\x03\n\x07Literal\x12\x30\n\x06scalar\x18\x01 \x01(\x0b\x32\x16.flyteidl2.core.ScalarH\x00R\x06scalar\x12\x43\n\ncollection\x18\x02 \x01(\x0b\x32!.flyteidl2.core.LiteralCollectionH\x00R\ncollection\x12.\n\x03map\x18\x03 \x01(\x0b\x32\x1a.flyteidl2.core.LiteralMapH\x00R\x03map\x12Y\n\x12offloaded_metadata\x18\x08 \x01(\x0b\x32(.flyteidl2.core.LiteralOffloadedMetadataH\x00R\x11offloadedMetadata\x12\x12\n\x04hash\x18\x04 \x01(\tR\x04hash\x12\x41\n\x08metadata\x18\x05 \x03(\x0b\x32%.flyteidl2.core.Literal.MetadataEntryR\x08metadata\x1a;\n\rMetadataEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x42\x07\n\x05valueJ\x04\x08\x06\x10\x07J\x04\x08\x07\x10\x08\"\x8d\x01\n\x18LiteralOffloadedMetadata\x12\x10\n\x03uri\x18\x01 \x01(\tR\x03uri\x12\x1d\n\nsize_bytes\x18\x02 \x01(\x04R\tsizeBytes\x12@\n\rinferred_type\x18\x03 \x01(\x0b\x32\x1b.flyteidl2.core.LiteralTypeR\x0cinferredType\"H\n\x11LiteralCollection\x12\x33\n\x08literals\x18\x01 \x03(\x0b\x32\x17.flyteidl2.core.LiteralR\x08literals\"\xa8\x01\n\nLiteralMap\x12\x44\n\x08literals\x18\x01 \x03(\x0b\x32(.flyteidl2.core.LiteralMap.LiteralsEntryR\x08literals\x1aT\n\rLiteralsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12-\n\x05value\x18\x02 \x01(\x0b\x32\x17.flyteidl2.core.LiteralR\x05value:\x02\x38\x01\"P\n\x15\x42indingDataCollection\x12\x37\n\x08\x62indings\x18\x01 \x03(\x0b\x32\x1b.flyteidl2.core.BindingDataR\x08\x62indings\"\xb4\x01\n\x0e\x42indingDataMap\x12H\n\x08\x62indings\x18\x01 \x03(\x0b\x32,.flyteidl2.core.BindingDataMap.BindingsEntryR\x08\x62indings\x1aX\n\rBindingsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x31\n\x05value\x18\x02 \x01(\x0b\x32\x1b.flyteidl2.core.BindingDataR\x05value:\x02\x38\x01\"H\n\tUnionInfo\x12;\n\ntargetType\x18\x01 \x01(\x0b\x32\x1b.flyteidl2.core.LiteralTypeR\ntargetType\"\x8e\x03\n\x0b\x42indingData\x12\x30\n\x06scalar\x18\x01 \x01(\x0b\x32\x16.flyteidl2.core.ScalarH\x00R\x06scalar\x12G\n\ncollection\x18\x02 \x01(\x0b\x32%.flyteidl2.core.BindingDataCollectionH\x00R\ncollection\x12;\n\x07promise\x18\x03 \x01(\x0b\x32\x1f.flyteidl2.core.OutputReferenceH\x00R\x07promise\x12\x32\n\x03map\x18\x04 \x01(\x0b\x32\x1e.flyteidl2.core.BindingDataMapH\x00R\x03map\x12Y\n\x12offloaded_metadata\x18\x06 \x01(\x0b\x32(.flyteidl2.core.LiteralOffloadedMetadataH\x00R\x11offloadedMetadata\x12/\n\x05union\x18\x05 \x01(\x0b\x32\x19.flyteidl2.core.UnionInfoR\x05unionB\x07\n\x05value\"R\n\x07\x42inding\x12\x10\n\x03var\x18\x01 \x01(\tR\x03var\x12\x35\n\x07\x62inding\x18\x02 \x01(\x0b\x32\x1b.flyteidl2.core.BindingDataR\x07\x62inding\"6\n\x0cKeyValuePair\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value\")\n\rRetryStrategy\x12\x18\n\x07retries\x18\x05 \x01(\rR\x07retriesB\xb2\x01\n\x12\x63om.flyteidl2.coreB\rLiteralsProtoH\x02P\x01Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\xa2\x02\x03\x46\x43X\xaa\x02\x0e\x46lyteidl2.Core\xca\x02\x0e\x46lyteidl2\\Core\xe2\x02\x1a\x46lyteidl2\\Core\\GPBMetadata\xea\x02\x0f\x46lyteidl2::Coreb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.core.literals_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\022com.flyteidl2.coreB\rLiteralsProtoH\002P\001Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\242\002\003FCX\252\002\016Flyteidl2.Core\312\002\016Flyteidl2\\Core\342\002\032Flyteidl2\\Core\\GPBMetadata\352\002\017Flyteidl2::Core' + _LITERAL_METADATAENTRY._options = None + _LITERAL_METADATAENTRY._serialized_options = b'8\001' + _LITERALMAP_LITERALSENTRY._options = None + _LITERALMAP_LITERALSENTRY._serialized_options = b'8\001' + _BINDINGDATAMAP_BINDINGSENTRY._options = None + _BINDINGDATAMAP_BINDINGSENTRY._serialized_options = b'8\001' + _globals['_PRIMITIVE']._serialized_start=173 + _globals['_PRIMITIVE']._serialized_end=436 + _globals['_VOID']._serialized_start=438 + _globals['_VOID']._serialized_end=444 + _globals['_BLOB']._serialized_start=446 + _globals['_BLOB']._serialized_end=528 + _globals['_BLOBMETADATA']._serialized_start=530 + _globals['_BLOBMETADATA']._serialized_end=590 + _globals['_BINARY']._serialized_start=592 + _globals['_BINARY']._serialized_end=640 + _globals['_SCHEMA']._serialized_start=642 + _globals['_SCHEMA']._serialized_end=716 + _globals['_UNION']._serialized_start=718 + _globals['_UNION']._serialized_end=821 + _globals['_STRUCTUREDDATASETMETADATA']._serialized_start=823 + _globals['_STRUCTUREDDATASETMETADATA']._serialized_end=945 + _globals['_STRUCTUREDDATASET']._serialized_start=947 + _globals['_STRUCTUREDDATASET']._serialized_end=1055 + _globals['_SCALAR']._serialized_start=1058 + _globals['_SCALAR']._serialized_end=1562 + _globals['_LITERAL']._serialized_start=1565 + _globals['_LITERAL']._serialized_end=2001 + _globals['_LITERAL_METADATAENTRY']._serialized_start=1921 + _globals['_LITERAL_METADATAENTRY']._serialized_end=1980 + _globals['_LITERALOFFLOADEDMETADATA']._serialized_start=2004 + _globals['_LITERALOFFLOADEDMETADATA']._serialized_end=2145 + _globals['_LITERALCOLLECTION']._serialized_start=2147 + _globals['_LITERALCOLLECTION']._serialized_end=2219 + _globals['_LITERALMAP']._serialized_start=2222 + _globals['_LITERALMAP']._serialized_end=2390 + _globals['_LITERALMAP_LITERALSENTRY']._serialized_start=2306 + _globals['_LITERALMAP_LITERALSENTRY']._serialized_end=2390 + _globals['_BINDINGDATACOLLECTION']._serialized_start=2392 + _globals['_BINDINGDATACOLLECTION']._serialized_end=2472 + _globals['_BINDINGDATAMAP']._serialized_start=2475 + _globals['_BINDINGDATAMAP']._serialized_end=2655 + _globals['_BINDINGDATAMAP_BINDINGSENTRY']._serialized_start=2567 + _globals['_BINDINGDATAMAP_BINDINGSENTRY']._serialized_end=2655 + _globals['_UNIONINFO']._serialized_start=2657 + _globals['_UNIONINFO']._serialized_end=2729 + _globals['_BINDINGDATA']._serialized_start=2732 + _globals['_BINDINGDATA']._serialized_end=3130 + _globals['_BINDING']._serialized_start=3132 + _globals['_BINDING']._serialized_end=3214 + _globals['_KEYVALUEPAIR']._serialized_start=3216 + _globals['_KEYVALUEPAIR']._serialized_end=3270 + _globals['_RETRYSTRATEGY']._serialized_start=3272 + _globals['_RETRYSTRATEGY']._serialized_end=3313 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/core/literals_pb2.pyi b/gen/python/flyteidl2/core/literals_pb2.pyi new file mode 100644 index 0000000000..a451144c54 --- /dev/null +++ b/gen/python/flyteidl2/core/literals_pb2.pyi @@ -0,0 +1,219 @@ +from flyteidl2.core import types_pb2 as _types_pb2 +from google.protobuf import duration_pb2 as _duration_pb2 +from google.protobuf import struct_pb2 as _struct_pb2 +from google.protobuf import timestamp_pb2 as _timestamp_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class Primitive(_message.Message): + __slots__ = ["integer", "float_value", "string_value", "boolean", "datetime", "duration"] + INTEGER_FIELD_NUMBER: _ClassVar[int] + FLOAT_VALUE_FIELD_NUMBER: _ClassVar[int] + STRING_VALUE_FIELD_NUMBER: _ClassVar[int] + BOOLEAN_FIELD_NUMBER: _ClassVar[int] + DATETIME_FIELD_NUMBER: _ClassVar[int] + DURATION_FIELD_NUMBER: _ClassVar[int] + integer: int + float_value: float + string_value: str + boolean: bool + datetime: _timestamp_pb2.Timestamp + duration: _duration_pb2.Duration + def __init__(self, integer: _Optional[int] = ..., float_value: _Optional[float] = ..., string_value: _Optional[str] = ..., boolean: bool = ..., datetime: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., duration: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ...) -> None: ... + +class Void(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class Blob(_message.Message): + __slots__ = ["metadata", "uri"] + METADATA_FIELD_NUMBER: _ClassVar[int] + URI_FIELD_NUMBER: _ClassVar[int] + metadata: BlobMetadata + uri: str + def __init__(self, metadata: _Optional[_Union[BlobMetadata, _Mapping]] = ..., uri: _Optional[str] = ...) -> None: ... + +class BlobMetadata(_message.Message): + __slots__ = ["type"] + TYPE_FIELD_NUMBER: _ClassVar[int] + type: _types_pb2.BlobType + def __init__(self, type: _Optional[_Union[_types_pb2.BlobType, _Mapping]] = ...) -> None: ... + +class Binary(_message.Message): + __slots__ = ["value", "tag"] + VALUE_FIELD_NUMBER: _ClassVar[int] + TAG_FIELD_NUMBER: _ClassVar[int] + value: bytes + tag: str + def __init__(self, value: _Optional[bytes] = ..., tag: _Optional[str] = ...) -> None: ... + +class Schema(_message.Message): + __slots__ = ["uri", "type"] + URI_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + uri: str + type: _types_pb2.SchemaType + def __init__(self, uri: _Optional[str] = ..., type: _Optional[_Union[_types_pb2.SchemaType, _Mapping]] = ...) -> None: ... + +class Union(_message.Message): + __slots__ = ["value", "type"] + VALUE_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + value: Literal + type: _types_pb2.LiteralType + def __init__(self, value: _Optional[_Union[Literal, _Mapping]] = ..., type: _Optional[_Union[_types_pb2.LiteralType, _Mapping]] = ...) -> None: ... + +class StructuredDatasetMetadata(_message.Message): + __slots__ = ["structured_dataset_type"] + STRUCTURED_DATASET_TYPE_FIELD_NUMBER: _ClassVar[int] + structured_dataset_type: _types_pb2.StructuredDatasetType + def __init__(self, structured_dataset_type: _Optional[_Union[_types_pb2.StructuredDatasetType, _Mapping]] = ...) -> None: ... + +class StructuredDataset(_message.Message): + __slots__ = ["uri", "metadata"] + URI_FIELD_NUMBER: _ClassVar[int] + METADATA_FIELD_NUMBER: _ClassVar[int] + uri: str + metadata: StructuredDatasetMetadata + def __init__(self, uri: _Optional[str] = ..., metadata: _Optional[_Union[StructuredDatasetMetadata, _Mapping]] = ...) -> None: ... + +class Scalar(_message.Message): + __slots__ = ["primitive", "blob", "binary", "schema", "none_type", "error", "generic", "structured_dataset", "union"] + PRIMITIVE_FIELD_NUMBER: _ClassVar[int] + BLOB_FIELD_NUMBER: _ClassVar[int] + BINARY_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + NONE_TYPE_FIELD_NUMBER: _ClassVar[int] + ERROR_FIELD_NUMBER: _ClassVar[int] + GENERIC_FIELD_NUMBER: _ClassVar[int] + STRUCTURED_DATASET_FIELD_NUMBER: _ClassVar[int] + UNION_FIELD_NUMBER: _ClassVar[int] + primitive: Primitive + blob: Blob + binary: Binary + schema: Schema + none_type: Void + error: _types_pb2.Error + generic: _struct_pb2.Struct + structured_dataset: StructuredDataset + union: Union + def __init__(self, primitive: _Optional[_Union[Primitive, _Mapping]] = ..., blob: _Optional[_Union[Blob, _Mapping]] = ..., binary: _Optional[_Union[Binary, _Mapping]] = ..., schema: _Optional[_Union[Schema, _Mapping]] = ..., none_type: _Optional[_Union[Void, _Mapping]] = ..., error: _Optional[_Union[_types_pb2.Error, _Mapping]] = ..., generic: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., structured_dataset: _Optional[_Union[StructuredDataset, _Mapping]] = ..., union: _Optional[_Union[Union, _Mapping]] = ...) -> None: ... + +class Literal(_message.Message): + __slots__ = ["scalar", "collection", "map", "offloaded_metadata", "hash", "metadata"] + class MetadataEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + SCALAR_FIELD_NUMBER: _ClassVar[int] + COLLECTION_FIELD_NUMBER: _ClassVar[int] + MAP_FIELD_NUMBER: _ClassVar[int] + OFFLOADED_METADATA_FIELD_NUMBER: _ClassVar[int] + HASH_FIELD_NUMBER: _ClassVar[int] + METADATA_FIELD_NUMBER: _ClassVar[int] + scalar: Scalar + collection: LiteralCollection + map: LiteralMap + offloaded_metadata: LiteralOffloadedMetadata + hash: str + metadata: _containers.ScalarMap[str, str] + def __init__(self, scalar: _Optional[_Union[Scalar, _Mapping]] = ..., collection: _Optional[_Union[LiteralCollection, _Mapping]] = ..., map: _Optional[_Union[LiteralMap, _Mapping]] = ..., offloaded_metadata: _Optional[_Union[LiteralOffloadedMetadata, _Mapping]] = ..., hash: _Optional[str] = ..., metadata: _Optional[_Mapping[str, str]] = ...) -> None: ... + +class LiteralOffloadedMetadata(_message.Message): + __slots__ = ["uri", "size_bytes", "inferred_type"] + URI_FIELD_NUMBER: _ClassVar[int] + SIZE_BYTES_FIELD_NUMBER: _ClassVar[int] + INFERRED_TYPE_FIELD_NUMBER: _ClassVar[int] + uri: str + size_bytes: int + inferred_type: _types_pb2.LiteralType + def __init__(self, uri: _Optional[str] = ..., size_bytes: _Optional[int] = ..., inferred_type: _Optional[_Union[_types_pb2.LiteralType, _Mapping]] = ...) -> None: ... + +class LiteralCollection(_message.Message): + __slots__ = ["literals"] + LITERALS_FIELD_NUMBER: _ClassVar[int] + literals: _containers.RepeatedCompositeFieldContainer[Literal] + def __init__(self, literals: _Optional[_Iterable[_Union[Literal, _Mapping]]] = ...) -> None: ... + +class LiteralMap(_message.Message): + __slots__ = ["literals"] + class LiteralsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: Literal + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Literal, _Mapping]] = ...) -> None: ... + LITERALS_FIELD_NUMBER: _ClassVar[int] + literals: _containers.MessageMap[str, Literal] + def __init__(self, literals: _Optional[_Mapping[str, Literal]] = ...) -> None: ... + +class BindingDataCollection(_message.Message): + __slots__ = ["bindings"] + BINDINGS_FIELD_NUMBER: _ClassVar[int] + bindings: _containers.RepeatedCompositeFieldContainer[BindingData] + def __init__(self, bindings: _Optional[_Iterable[_Union[BindingData, _Mapping]]] = ...) -> None: ... + +class BindingDataMap(_message.Message): + __slots__ = ["bindings"] + class BindingsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: BindingData + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[BindingData, _Mapping]] = ...) -> None: ... + BINDINGS_FIELD_NUMBER: _ClassVar[int] + bindings: _containers.MessageMap[str, BindingData] + def __init__(self, bindings: _Optional[_Mapping[str, BindingData]] = ...) -> None: ... + +class UnionInfo(_message.Message): + __slots__ = ["targetType"] + TARGETTYPE_FIELD_NUMBER: _ClassVar[int] + targetType: _types_pb2.LiteralType + def __init__(self, targetType: _Optional[_Union[_types_pb2.LiteralType, _Mapping]] = ...) -> None: ... + +class BindingData(_message.Message): + __slots__ = ["scalar", "collection", "promise", "map", "offloaded_metadata", "union"] + SCALAR_FIELD_NUMBER: _ClassVar[int] + COLLECTION_FIELD_NUMBER: _ClassVar[int] + PROMISE_FIELD_NUMBER: _ClassVar[int] + MAP_FIELD_NUMBER: _ClassVar[int] + OFFLOADED_METADATA_FIELD_NUMBER: _ClassVar[int] + UNION_FIELD_NUMBER: _ClassVar[int] + scalar: Scalar + collection: BindingDataCollection + promise: _types_pb2.OutputReference + map: BindingDataMap + offloaded_metadata: LiteralOffloadedMetadata + union: UnionInfo + def __init__(self, scalar: _Optional[_Union[Scalar, _Mapping]] = ..., collection: _Optional[_Union[BindingDataCollection, _Mapping]] = ..., promise: _Optional[_Union[_types_pb2.OutputReference, _Mapping]] = ..., map: _Optional[_Union[BindingDataMap, _Mapping]] = ..., offloaded_metadata: _Optional[_Union[LiteralOffloadedMetadata, _Mapping]] = ..., union: _Optional[_Union[UnionInfo, _Mapping]] = ...) -> None: ... + +class Binding(_message.Message): + __slots__ = ["var", "binding"] + VAR_FIELD_NUMBER: _ClassVar[int] + BINDING_FIELD_NUMBER: _ClassVar[int] + var: str + binding: BindingData + def __init__(self, var: _Optional[str] = ..., binding: _Optional[_Union[BindingData, _Mapping]] = ...) -> None: ... + +class KeyValuePair(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + +class RetryStrategy(_message.Message): + __slots__ = ["retries"] + RETRIES_FIELD_NUMBER: _ClassVar[int] + retries: int + def __init__(self, retries: _Optional[int] = ...) -> None: ... diff --git a/gen/python/flyteidl2/core/literals_pb2_grpc.py b/gen/python/flyteidl2/core/literals_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/core/literals_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/core/metrics_pb2.py b/gen/python/flyteidl2/core/metrics_pb2.py new file mode 100644 index 0000000000..c065e450a5 --- /dev/null +++ b/gen/python/flyteidl2/core/metrics_pb2.py @@ -0,0 +1,27 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/core/metrics.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1c\x66lyteidl2/core/metrics.proto\x12\x0e\x66lyteidl2.core\x1a\x1cgoogle/protobuf/struct.proto\"\\\n\x15\x45xecutionMetricResult\x12\x16\n\x06metric\x18\x01 \x01(\tR\x06metric\x12+\n\x04\x64\x61ta\x18\x02 \x01(\x0b\x32\x17.google.protobuf.StructR\x04\x64\x61taB\xb1\x01\n\x12\x63om.flyteidl2.coreB\x0cMetricsProtoH\x02P\x01Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\xa2\x02\x03\x46\x43X\xaa\x02\x0e\x46lyteidl2.Core\xca\x02\x0e\x46lyteidl2\\Core\xe2\x02\x1a\x46lyteidl2\\Core\\GPBMetadata\xea\x02\x0f\x46lyteidl2::Coreb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.core.metrics_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\022com.flyteidl2.coreB\014MetricsProtoH\002P\001Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\242\002\003FCX\252\002\016Flyteidl2.Core\312\002\016Flyteidl2\\Core\342\002\032Flyteidl2\\Core\\GPBMetadata\352\002\017Flyteidl2::Core' + _globals['_EXECUTIONMETRICRESULT']._serialized_start=78 + _globals['_EXECUTIONMETRICRESULT']._serialized_end=170 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/core/metrics_pb2.pyi b/gen/python/flyteidl2/core/metrics_pb2.pyi new file mode 100644 index 0000000000..a04bbf95cb --- /dev/null +++ b/gen/python/flyteidl2/core/metrics_pb2.pyi @@ -0,0 +1,14 @@ +from google.protobuf import struct_pb2 as _struct_pb2 +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class ExecutionMetricResult(_message.Message): + __slots__ = ["metric", "data"] + METRIC_FIELD_NUMBER: _ClassVar[int] + DATA_FIELD_NUMBER: _ClassVar[int] + metric: str + data: _struct_pb2.Struct + def __init__(self, metric: _Optional[str] = ..., data: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/core/metrics_pb2_grpc.py b/gen/python/flyteidl2/core/metrics_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/core/metrics_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/core/security_pb2.py b/gen/python/flyteidl2/core/security_pb2.py new file mode 100644 index 0000000000..70581591ad --- /dev/null +++ b/gen/python/flyteidl2/core/security_pb2.py @@ -0,0 +1,48 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/core/security.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1d\x66lyteidl2/core/security.proto\x12\x0e\x66lyteidl2.core\"\xea\x01\n\x06Secret\x12\x14\n\x05group\x18\x01 \x01(\tR\x05group\x12#\n\rgroup_version\x18\x02 \x01(\tR\x0cgroupVersion\x12\x10\n\x03key\x18\x03 \x01(\tR\x03key\x12M\n\x11mount_requirement\x18\x04 \x01(\x0e\x32 .flyteidl2.core.Secret.MountTypeR\x10mountRequirement\x12\x17\n\x07\x65nv_var\x18\x05 \x01(\tR\x06\x65nvVar\"+\n\tMountType\x12\x07\n\x03\x41NY\x10\x00\x12\x0b\n\x07\x45NV_VAR\x10\x01\x12\x08\n\x04\x46ILE\x10\x02\"\xa7\x02\n\nConnection\x12\x1b\n\ttask_type\x18\x01 \x01(\tR\x08taskType\x12\x41\n\x07secrets\x18\x02 \x03(\x0b\x32\'.flyteidl2.core.Connection.SecretsEntryR\x07secrets\x12\x41\n\x07\x63onfigs\x18\x03 \x03(\x0b\x32\'.flyteidl2.core.Connection.ConfigsEntryR\x07\x63onfigs\x1a:\n\x0cSecretsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x1a:\n\x0c\x43onfigsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"h\n\x0cOAuth2Client\x12\x1b\n\tclient_id\x18\x01 \x01(\tR\x08\x63lientId\x12;\n\rclient_secret\x18\x02 \x01(\x0b\x32\x16.flyteidl2.core.SecretR\x0c\x63lientSecret\"\xc7\x01\n\x08Identity\x12\x19\n\x08iam_role\x18\x01 \x01(\tR\x07iamRole\x12.\n\x13k8s_service_account\x18\x02 \x01(\tR\x11k8sServiceAccount\x12\x41\n\roauth2_client\x18\x03 \x01(\x0b\x32\x1c.flyteidl2.core.OAuth2ClientR\x0coauth2Client\x12-\n\x12\x65xecution_identity\x18\x04 \x01(\tR\x11\x65xecutionIdentity\"\x98\x02\n\x12OAuth2TokenRequest\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12;\n\x04type\x18\x02 \x01(\x0e\x32\'.flyteidl2.core.OAuth2TokenRequest.TypeR\x04type\x12\x34\n\x06\x63lient\x18\x03 \x01(\x0b\x32\x1c.flyteidl2.core.OAuth2ClientR\x06\x63lient\x12\x34\n\x16idp_discovery_endpoint\x18\x04 \x01(\tR\x14idpDiscoveryEndpoint\x12%\n\x0etoken_endpoint\x18\x05 \x01(\tR\rtokenEndpoint\"\x1e\n\x04Type\x12\x16\n\x12\x43LIENT_CREDENTIALS\x10\x00\"\xb0\x01\n\x0fSecurityContext\x12/\n\x06run_as\x18\x01 \x01(\x0b\x32\x18.flyteidl2.core.IdentityR\x05runAs\x12\x30\n\x07secrets\x18\x02 \x03(\x0b\x32\x16.flyteidl2.core.SecretR\x07secrets\x12:\n\x06tokens\x18\x03 \x03(\x0b\x32\".flyteidl2.core.OAuth2TokenRequestR\x06tokensB\xb2\x01\n\x12\x63om.flyteidl2.coreB\rSecurityProtoH\x02P\x01Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\xa2\x02\x03\x46\x43X\xaa\x02\x0e\x46lyteidl2.Core\xca\x02\x0e\x46lyteidl2\\Core\xe2\x02\x1a\x46lyteidl2\\Core\\GPBMetadata\xea\x02\x0f\x46lyteidl2::Coreb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.core.security_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\022com.flyteidl2.coreB\rSecurityProtoH\002P\001Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\242\002\003FCX\252\002\016Flyteidl2.Core\312\002\016Flyteidl2\\Core\342\002\032Flyteidl2\\Core\\GPBMetadata\352\002\017Flyteidl2::Core' + _CONNECTION_SECRETSENTRY._options = None + _CONNECTION_SECRETSENTRY._serialized_options = b'8\001' + _CONNECTION_CONFIGSENTRY._options = None + _CONNECTION_CONFIGSENTRY._serialized_options = b'8\001' + _globals['_SECRET']._serialized_start=50 + _globals['_SECRET']._serialized_end=284 + _globals['_SECRET_MOUNTTYPE']._serialized_start=241 + _globals['_SECRET_MOUNTTYPE']._serialized_end=284 + _globals['_CONNECTION']._serialized_start=287 + _globals['_CONNECTION']._serialized_end=582 + _globals['_CONNECTION_SECRETSENTRY']._serialized_start=464 + _globals['_CONNECTION_SECRETSENTRY']._serialized_end=522 + _globals['_CONNECTION_CONFIGSENTRY']._serialized_start=524 + _globals['_CONNECTION_CONFIGSENTRY']._serialized_end=582 + _globals['_OAUTH2CLIENT']._serialized_start=584 + _globals['_OAUTH2CLIENT']._serialized_end=688 + _globals['_IDENTITY']._serialized_start=691 + _globals['_IDENTITY']._serialized_end=890 + _globals['_OAUTH2TOKENREQUEST']._serialized_start=893 + _globals['_OAUTH2TOKENREQUEST']._serialized_end=1173 + _globals['_OAUTH2TOKENREQUEST_TYPE']._serialized_start=1143 + _globals['_OAUTH2TOKENREQUEST_TYPE']._serialized_end=1173 + _globals['_SECURITYCONTEXT']._serialized_start=1176 + _globals['_SECURITYCONTEXT']._serialized_end=1352 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/core/security_pb2.pyi b/gen/python/flyteidl2/core/security_pb2.pyi new file mode 100644 index 0000000000..4d88cc6222 --- /dev/null +++ b/gen/python/flyteidl2/core/security_pb2.pyi @@ -0,0 +1,101 @@ +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class Secret(_message.Message): + __slots__ = ["group", "group_version", "key", "mount_requirement", "env_var"] + class MountType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + ANY: _ClassVar[Secret.MountType] + ENV_VAR: _ClassVar[Secret.MountType] + FILE: _ClassVar[Secret.MountType] + ANY: Secret.MountType + ENV_VAR: Secret.MountType + FILE: Secret.MountType + GROUP_FIELD_NUMBER: _ClassVar[int] + GROUP_VERSION_FIELD_NUMBER: _ClassVar[int] + KEY_FIELD_NUMBER: _ClassVar[int] + MOUNT_REQUIREMENT_FIELD_NUMBER: _ClassVar[int] + ENV_VAR_FIELD_NUMBER: _ClassVar[int] + group: str + group_version: str + key: str + mount_requirement: Secret.MountType + env_var: str + def __init__(self, group: _Optional[str] = ..., group_version: _Optional[str] = ..., key: _Optional[str] = ..., mount_requirement: _Optional[_Union[Secret.MountType, str]] = ..., env_var: _Optional[str] = ...) -> None: ... + +class Connection(_message.Message): + __slots__ = ["task_type", "secrets", "configs"] + class SecretsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + class ConfigsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + TASK_TYPE_FIELD_NUMBER: _ClassVar[int] + SECRETS_FIELD_NUMBER: _ClassVar[int] + CONFIGS_FIELD_NUMBER: _ClassVar[int] + task_type: str + secrets: _containers.ScalarMap[str, str] + configs: _containers.ScalarMap[str, str] + def __init__(self, task_type: _Optional[str] = ..., secrets: _Optional[_Mapping[str, str]] = ..., configs: _Optional[_Mapping[str, str]] = ...) -> None: ... + +class OAuth2Client(_message.Message): + __slots__ = ["client_id", "client_secret"] + CLIENT_ID_FIELD_NUMBER: _ClassVar[int] + CLIENT_SECRET_FIELD_NUMBER: _ClassVar[int] + client_id: str + client_secret: Secret + def __init__(self, client_id: _Optional[str] = ..., client_secret: _Optional[_Union[Secret, _Mapping]] = ...) -> None: ... + +class Identity(_message.Message): + __slots__ = ["iam_role", "k8s_service_account", "oauth2_client", "execution_identity"] + IAM_ROLE_FIELD_NUMBER: _ClassVar[int] + K8S_SERVICE_ACCOUNT_FIELD_NUMBER: _ClassVar[int] + OAUTH2_CLIENT_FIELD_NUMBER: _ClassVar[int] + EXECUTION_IDENTITY_FIELD_NUMBER: _ClassVar[int] + iam_role: str + k8s_service_account: str + oauth2_client: OAuth2Client + execution_identity: str + def __init__(self, iam_role: _Optional[str] = ..., k8s_service_account: _Optional[str] = ..., oauth2_client: _Optional[_Union[OAuth2Client, _Mapping]] = ..., execution_identity: _Optional[str] = ...) -> None: ... + +class OAuth2TokenRequest(_message.Message): + __slots__ = ["name", "type", "client", "idp_discovery_endpoint", "token_endpoint"] + class Type(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + CLIENT_CREDENTIALS: _ClassVar[OAuth2TokenRequest.Type] + CLIENT_CREDENTIALS: OAuth2TokenRequest.Type + NAME_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + CLIENT_FIELD_NUMBER: _ClassVar[int] + IDP_DISCOVERY_ENDPOINT_FIELD_NUMBER: _ClassVar[int] + TOKEN_ENDPOINT_FIELD_NUMBER: _ClassVar[int] + name: str + type: OAuth2TokenRequest.Type + client: OAuth2Client + idp_discovery_endpoint: str + token_endpoint: str + def __init__(self, name: _Optional[str] = ..., type: _Optional[_Union[OAuth2TokenRequest.Type, str]] = ..., client: _Optional[_Union[OAuth2Client, _Mapping]] = ..., idp_discovery_endpoint: _Optional[str] = ..., token_endpoint: _Optional[str] = ...) -> None: ... + +class SecurityContext(_message.Message): + __slots__ = ["run_as", "secrets", "tokens"] + RUN_AS_FIELD_NUMBER: _ClassVar[int] + SECRETS_FIELD_NUMBER: _ClassVar[int] + TOKENS_FIELD_NUMBER: _ClassVar[int] + run_as: Identity + secrets: _containers.RepeatedCompositeFieldContainer[Secret] + tokens: _containers.RepeatedCompositeFieldContainer[OAuth2TokenRequest] + def __init__(self, run_as: _Optional[_Union[Identity, _Mapping]] = ..., secrets: _Optional[_Iterable[_Union[Secret, _Mapping]]] = ..., tokens: _Optional[_Iterable[_Union[OAuth2TokenRequest, _Mapping]]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/core/security_pb2_grpc.py b/gen/python/flyteidl2/core/security_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/core/security_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/core/tasks_pb2.py b/gen/python/flyteidl2/core/tasks_pb2.py new file mode 100644 index 0000000000..5d2087e032 --- /dev/null +++ b/gen/python/flyteidl2/core/tasks_pb2.py @@ -0,0 +1,96 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/core/tasks.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.core import execution_pb2 as flyteidl2_dot_core_dot_execution__pb2 +from flyteidl2.core import identifier_pb2 as flyteidl2_dot_core_dot_identifier__pb2 +from flyteidl2.core import interface_pb2 as flyteidl2_dot_core_dot_interface__pb2 +from flyteidl2.core import literals_pb2 as flyteidl2_dot_core_dot_literals__pb2 +from flyteidl2.core import security_pb2 as flyteidl2_dot_core_dot_security__pb2 +from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 +from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2 +from google.protobuf import wrappers_pb2 as google_dot_protobuf_dot_wrappers__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1a\x66lyteidl2/core/tasks.proto\x12\x0e\x66lyteidl2.core\x1a\x1e\x66lyteidl2/core/execution.proto\x1a\x1f\x66lyteidl2/core/identifier.proto\x1a\x1e\x66lyteidl2/core/interface.proto\x1a\x1d\x66lyteidl2/core/literals.proto\x1a\x1d\x66lyteidl2/core/security.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1egoogle/protobuf/wrappers.proto\"\xd3\x02\n\tResources\x12\x43\n\x08requests\x18\x01 \x03(\x0b\x32\'.flyteidl2.core.Resources.ResourceEntryR\x08requests\x12?\n\x06limits\x18\x02 \x03(\x0b\x32\'.flyteidl2.core.Resources.ResourceEntryR\x06limits\x1a\x61\n\rResourceEntry\x12:\n\x04name\x18\x01 \x01(\x0e\x32&.flyteidl2.core.Resources.ResourceNameR\x04name\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value\"]\n\x0cResourceName\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x07\n\x03\x43PU\x10\x01\x12\x07\n\x03GPU\x10\x02\x12\n\n\x06MEMORY\x10\x03\x12\x0b\n\x07STORAGE\x10\x04\x12\x15\n\x11\x45PHEMERAL_STORAGE\x10\x05\"\xc1\x02\n\x0eGPUAccelerator\x12\x16\n\x06\x64\x65vice\x18\x01 \x01(\tR\x06\x64\x65vice\x12&\n\runpartitioned\x18\x02 \x01(\x08H\x00R\runpartitioned\x12\'\n\x0epartition_size\x18\x03 \x01(\tH\x00R\rpartitionSize\x12M\n\x0c\x64\x65vice_class\x18\x04 \x01(\x0e\x32*.flyteidl2.core.GPUAccelerator.DeviceClassR\x0b\x64\x65viceClass\"_\n\x0b\x44\x65viceClass\x12\x0e\n\nNVIDIA_GPU\x10\x00\x12\x0e\n\nGOOGLE_TPU\x10\x01\x12\x11\n\rAMAZON_NEURON\x10\x02\x12\x0b\n\x07\x41MD_GPU\x10\x03\x12\x10\n\x0cHABANA_GAUDI\x10\x04\x42\x16\n\x14partition_size_value\"k\n\x0cSharedMemory\x12\x1d\n\nmount_path\x18\x01 \x01(\tR\tmountPath\x12\x1d\n\nmount_name\x18\x02 \x01(\tR\tmountName\x12\x1d\n\nsize_limit\x18\x03 \x01(\tR\tsizeLimit\"\x9f\x01\n\x11\x45xtendedResources\x12G\n\x0fgpu_accelerator\x18\x01 \x01(\x0b\x32\x1e.flyteidl2.core.GPUAcceleratorR\x0egpuAccelerator\x12\x41\n\rshared_memory\x18\x02 \x01(\x0b\x32\x1c.flyteidl2.core.SharedMemoryR\x0csharedMemory\"\xad\x01\n\x0fRuntimeMetadata\x12?\n\x04type\x18\x01 \x01(\x0e\x32+.flyteidl2.core.RuntimeMetadata.RuntimeTypeR\x04type\x12\x18\n\x07version\x18\x02 \x01(\tR\x07version\x12\x16\n\x06\x66lavor\x18\x03 \x01(\tR\x06\x66lavor\"\'\n\x0bRuntimeType\x12\t\n\x05OTHER\x10\x00\x12\r\n\tFLYTE_SDK\x10\x01\"\x81\x07\n\x0cTaskMetadata\x12\"\n\x0c\x64iscoverable\x18\x01 \x01(\x08R\x0c\x64iscoverable\x12\x39\n\x07runtime\x18\x02 \x01(\x0b\x32\x1f.flyteidl2.core.RuntimeMetadataR\x07runtime\x12\x33\n\x07timeout\x18\x04 \x01(\x0b\x32\x19.google.protobuf.DurationR\x07timeout\x12\x37\n\x07retries\x18\x05 \x01(\x0b\x32\x1d.flyteidl2.core.RetryStrategyR\x07retries\x12+\n\x11\x64iscovery_version\x18\x06 \x01(\tR\x10\x64iscoveryVersion\x12\x38\n\x18\x64\x65precated_error_message\x18\x07 \x01(\tR\x16\x64\x65precatedErrorMessage\x12&\n\rinterruptible\x18\x08 \x01(\x08H\x00R\rinterruptible\x12-\n\x12\x63\x61\x63he_serializable\x18\t \x01(\x08R\x11\x63\x61\x63heSerializable\x12:\n\x04tags\x18\x0b \x03(\x0b\x32&.flyteidl2.core.TaskMetadata.TagsEntryR\x04tags\x12*\n\x11pod_template_name\x18\x0c \x01(\tR\x0fpodTemplateName\x12\x35\n\x17\x63\x61\x63he_ignore_input_vars\x18\r \x03(\tR\x14\x63\x61\x63heIgnoreInputVars\x12\x19\n\x08is_eager\x18\x0e \x01(\x08R\x07isEager\x12\x41\n\x0egenerates_deck\x18\x0f \x01(\x0b\x32\x1a.google.protobuf.BoolValueR\rgeneratesDeck\x12=\n\x08metadata\x18\x10 \x01(\x0b\x32!.flyteidl2.core.K8sObjectMetadataR\x08metadata\x12\x1e\n\ndebuggable\x18\x11 \x01(\x08R\ndebuggable\x12\x34\n\tlog_links\x18\x12 \x03(\x0b\x32\x17.flyteidl2.core.TaskLogR\x08logLinks\x1a\x37\n\tTagsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x42\x15\n\x13interruptible_valueJ\x04\x08\n\x10\x0b\"\xdf\x05\n\x0cTaskTemplate\x12*\n\x02id\x18\x01 \x01(\x0b\x32\x1a.flyteidl2.core.IdentifierR\x02id\x12\x12\n\x04type\x18\x02 \x01(\tR\x04type\x12\x38\n\x08metadata\x18\x03 \x01(\x0b\x32\x1c.flyteidl2.core.TaskMetadataR\x08metadata\x12<\n\tinterface\x18\x04 \x01(\x0b\x32\x1e.flyteidl2.core.TypedInterfaceR\tinterface\x12/\n\x06\x63ustom\x18\x05 \x01(\x0b\x32\x17.google.protobuf.StructR\x06\x63ustom\x12\x39\n\tcontainer\x18\x06 \x01(\x0b\x32\x19.flyteidl2.core.ContainerH\x00R\tcontainer\x12\x31\n\x07k8s_pod\x18\x11 \x01(\x0b\x32\x16.flyteidl2.core.K8sPodH\x00R\x06k8sPod\x12\'\n\x03sql\x18\x12 \x01(\x0b\x32\x13.flyteidl2.core.SqlH\x00R\x03sql\x12*\n\x11task_type_version\x18\x07 \x01(\x05R\x0ftaskTypeVersion\x12J\n\x10security_context\x18\x08 \x01(\x0b\x32\x1f.flyteidl2.core.SecurityContextR\x0fsecurityContext\x12P\n\x12\x65xtended_resources\x18\t \x01(\x0b\x32!.flyteidl2.core.ExtendedResourcesR\x11\x65xtendedResources\x12@\n\x06\x63onfig\x18\x10 \x03(\x0b\x32(.flyteidl2.core.TaskTemplate.ConfigEntryR\x06\x63onfig\x1a\x39\n\x0b\x43onfigEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x42\x08\n\x06target\"J\n\rContainerPort\x12%\n\x0e\x63ontainer_port\x18\x01 \x01(\rR\rcontainerPort\x12\x12\n\x04name\x18\x02 \x01(\tR\x04name\"\x82\x04\n\tContainer\x12\x14\n\x05image\x18\x01 \x01(\tR\x05image\x12\x18\n\x07\x63ommand\x18\x02 \x03(\tR\x07\x63ommand\x12\x12\n\x04\x61rgs\x18\x03 \x03(\tR\x04\x61rgs\x12\x37\n\tresources\x18\x04 \x01(\x0b\x32\x19.flyteidl2.core.ResourcesR\tresources\x12.\n\x03\x65nv\x18\x05 \x03(\x0b\x32\x1c.flyteidl2.core.KeyValuePairR\x03\x65nv\x12\x38\n\x06\x63onfig\x18\x06 \x03(\x0b\x32\x1c.flyteidl2.core.KeyValuePairB\x02\x18\x01R\x06\x63onfig\x12\x33\n\x05ports\x18\x07 \x03(\x0b\x32\x1d.flyteidl2.core.ContainerPortR\x05ports\x12\x42\n\x0b\x64\x61ta_config\x18\t \x01(\x0b\x32!.flyteidl2.core.DataLoadingConfigR\ndataConfig\x12J\n\x0c\x61rchitecture\x18\n \x01(\x0e\x32&.flyteidl2.core.Container.ArchitectureR\x0c\x61rchitecture\"I\n\x0c\x41rchitecture\x12\x0b\n\x07UNKNOWN\x10\x00\x12\t\n\x05\x41MD64\x10\x01\x12\t\n\x05\x41RM64\x10\x02\x12\n\n\x06\x41RM_V6\x10\x03\x12\n\n\x06\x41RM_V7\x10\x04\"\xb7\x02\n\nIOStrategy\x12L\n\rdownload_mode\x18\x01 \x01(\x0e\x32\'.flyteidl2.core.IOStrategy.DownloadModeR\x0c\x64ownloadMode\x12\x46\n\x0bupload_mode\x18\x02 \x01(\x0e\x32%.flyteidl2.core.IOStrategy.UploadModeR\nuploadMode\"L\n\x0c\x44ownloadMode\x12\x12\n\x0e\x44OWNLOAD_EAGER\x10\x00\x12\x13\n\x0f\x44OWNLOAD_STREAM\x10\x01\x12\x13\n\x0f\x44O_NOT_DOWNLOAD\x10\x02\"E\n\nUploadMode\x12\x12\n\x0eUPLOAD_ON_EXIT\x10\x00\x12\x10\n\x0cUPLOAD_EAGER\x10\x01\x12\x11\n\rDO_NOT_UPLOAD\x10\x02\"\xa9\x02\n\x11\x44\x61taLoadingConfig\x12\x18\n\x07\x65nabled\x18\x01 \x01(\x08R\x07\x65nabled\x12\x1d\n\ninput_path\x18\x02 \x01(\tR\tinputPath\x12\x1f\n\x0boutput_path\x18\x03 \x01(\tR\noutputPath\x12J\n\x06\x66ormat\x18\x04 \x01(\x0e\x32\x32.flyteidl2.core.DataLoadingConfig.LiteralMapFormatR\x06\x66ormat\x12;\n\x0bio_strategy\x18\x05 \x01(\x0b\x32\x1a.flyteidl2.core.IOStrategyR\nioStrategy\"1\n\x10LiteralMapFormat\x12\x08\n\x04JSON\x10\x00\x12\x08\n\x04YAML\x10\x01\x12\t\n\x05PROTO\x10\x02\"\xf5\x01\n\x06K8sPod\x12=\n\x08metadata\x18\x01 \x01(\x0b\x32!.flyteidl2.core.K8sObjectMetadataR\x08metadata\x12\x32\n\x08pod_spec\x18\x02 \x01(\x0b\x32\x17.google.protobuf.StructR\x07podSpec\x12\x42\n\x0b\x64\x61ta_config\x18\x03 \x01(\x0b\x32!.flyteidl2.core.DataLoadingConfigR\ndataConfig\x12\x34\n\x16primary_container_name\x18\x04 \x01(\tR\x14primaryContainerName\"\xab\x02\n\x11K8sObjectMetadata\x12\x45\n\x06labels\x18\x01 \x03(\x0b\x32-.flyteidl2.core.K8sObjectMetadata.LabelsEntryR\x06labels\x12T\n\x0b\x61nnotations\x18\x02 \x03(\x0b\x32\x32.flyteidl2.core.K8sObjectMetadata.AnnotationsEntryR\x0b\x61nnotations\x1a\x39\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x1a>\n\x10\x41nnotationsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\x93\x01\n\x03Sql\x12\x1c\n\tstatement\x18\x01 \x01(\tR\tstatement\x12\x35\n\x07\x64ialect\x18\x02 \x01(\x0e\x32\x1b.flyteidl2.core.Sql.DialectR\x07\x64ialect\"7\n\x07\x44ialect\x12\r\n\tUNDEFINED\x10\x00\x12\x08\n\x04\x41NSI\x10\x01\x12\x08\n\x04HIVE\x10\x02\x12\t\n\x05OTHER\x10\x03\x42\xaf\x01\n\x12\x63om.flyteidl2.coreB\nTasksProtoH\x02P\x01Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\xa2\x02\x03\x46\x43X\xaa\x02\x0e\x46lyteidl2.Core\xca\x02\x0e\x46lyteidl2\\Core\xe2\x02\x1a\x46lyteidl2\\Core\\GPBMetadata\xea\x02\x0f\x46lyteidl2::Coreb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.core.tasks_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\022com.flyteidl2.coreB\nTasksProtoH\002P\001Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\242\002\003FCX\252\002\016Flyteidl2.Core\312\002\016Flyteidl2\\Core\342\002\032Flyteidl2\\Core\\GPBMetadata\352\002\017Flyteidl2::Core' + _TASKMETADATA_TAGSENTRY._options = None + _TASKMETADATA_TAGSENTRY._serialized_options = b'8\001' + _TASKTEMPLATE_CONFIGENTRY._options = None + _TASKTEMPLATE_CONFIGENTRY._serialized_options = b'8\001' + _CONTAINER.fields_by_name['config']._options = None + _CONTAINER.fields_by_name['config']._serialized_options = b'\030\001' + _K8SOBJECTMETADATA_LABELSENTRY._options = None + _K8SOBJECTMETADATA_LABELSENTRY._serialized_options = b'8\001' + _K8SOBJECTMETADATA_ANNOTATIONSENTRY._options = None + _K8SOBJECTMETADATA_ANNOTATIONSENTRY._serialized_options = b'8\001' + _globals['_RESOURCES']._serialized_start=300 + _globals['_RESOURCES']._serialized_end=639 + _globals['_RESOURCES_RESOURCEENTRY']._serialized_start=447 + _globals['_RESOURCES_RESOURCEENTRY']._serialized_end=544 + _globals['_RESOURCES_RESOURCENAME']._serialized_start=546 + _globals['_RESOURCES_RESOURCENAME']._serialized_end=639 + _globals['_GPUACCELERATOR']._serialized_start=642 + _globals['_GPUACCELERATOR']._serialized_end=963 + _globals['_GPUACCELERATOR_DEVICECLASS']._serialized_start=844 + _globals['_GPUACCELERATOR_DEVICECLASS']._serialized_end=939 + _globals['_SHAREDMEMORY']._serialized_start=965 + _globals['_SHAREDMEMORY']._serialized_end=1072 + _globals['_EXTENDEDRESOURCES']._serialized_start=1075 + _globals['_EXTENDEDRESOURCES']._serialized_end=1234 + _globals['_RUNTIMEMETADATA']._serialized_start=1237 + _globals['_RUNTIMEMETADATA']._serialized_end=1410 + _globals['_RUNTIMEMETADATA_RUNTIMETYPE']._serialized_start=1371 + _globals['_RUNTIMEMETADATA_RUNTIMETYPE']._serialized_end=1410 + _globals['_TASKMETADATA']._serialized_start=1413 + _globals['_TASKMETADATA']._serialized_end=2310 + _globals['_TASKMETADATA_TAGSENTRY']._serialized_start=2226 + _globals['_TASKMETADATA_TAGSENTRY']._serialized_end=2281 + _globals['_TASKTEMPLATE']._serialized_start=2313 + _globals['_TASKTEMPLATE']._serialized_end=3048 + _globals['_TASKTEMPLATE_CONFIGENTRY']._serialized_start=2981 + _globals['_TASKTEMPLATE_CONFIGENTRY']._serialized_end=3038 + _globals['_CONTAINERPORT']._serialized_start=3050 + _globals['_CONTAINERPORT']._serialized_end=3124 + _globals['_CONTAINER']._serialized_start=3127 + _globals['_CONTAINER']._serialized_end=3641 + _globals['_CONTAINER_ARCHITECTURE']._serialized_start=3568 + _globals['_CONTAINER_ARCHITECTURE']._serialized_end=3641 + _globals['_IOSTRATEGY']._serialized_start=3644 + _globals['_IOSTRATEGY']._serialized_end=3955 + _globals['_IOSTRATEGY_DOWNLOADMODE']._serialized_start=3808 + _globals['_IOSTRATEGY_DOWNLOADMODE']._serialized_end=3884 + _globals['_IOSTRATEGY_UPLOADMODE']._serialized_start=3886 + _globals['_IOSTRATEGY_UPLOADMODE']._serialized_end=3955 + _globals['_DATALOADINGCONFIG']._serialized_start=3958 + _globals['_DATALOADINGCONFIG']._serialized_end=4255 + _globals['_DATALOADINGCONFIG_LITERALMAPFORMAT']._serialized_start=4206 + _globals['_DATALOADINGCONFIG_LITERALMAPFORMAT']._serialized_end=4255 + _globals['_K8SPOD']._serialized_start=4258 + _globals['_K8SPOD']._serialized_end=4503 + _globals['_K8SOBJECTMETADATA']._serialized_start=4506 + _globals['_K8SOBJECTMETADATA']._serialized_end=4805 + _globals['_K8SOBJECTMETADATA_LABELSENTRY']._serialized_start=4684 + _globals['_K8SOBJECTMETADATA_LABELSENTRY']._serialized_end=4741 + _globals['_K8SOBJECTMETADATA_ANNOTATIONSENTRY']._serialized_start=4743 + _globals['_K8SOBJECTMETADATA_ANNOTATIONSENTRY']._serialized_end=4805 + _globals['_SQL']._serialized_start=4808 + _globals['_SQL']._serialized_end=4955 + _globals['_SQL_DIALECT']._serialized_start=4900 + _globals['_SQL_DIALECT']._serialized_end=4955 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/core/tasks_pb2.pyi b/gen/python/flyteidl2/core/tasks_pb2.pyi new file mode 100644 index 0000000000..01aeaf1507 --- /dev/null +++ b/gen/python/flyteidl2/core/tasks_pb2.pyi @@ -0,0 +1,320 @@ +from flyteidl2.core import execution_pb2 as _execution_pb2 +from flyteidl2.core import identifier_pb2 as _identifier_pb2 +from flyteidl2.core import interface_pb2 as _interface_pb2 +from flyteidl2.core import literals_pb2 as _literals_pb2 +from flyteidl2.core import security_pb2 as _security_pb2 +from google.protobuf import duration_pb2 as _duration_pb2 +from google.protobuf import struct_pb2 as _struct_pb2 +from google.protobuf import wrappers_pb2 as _wrappers_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class Resources(_message.Message): + __slots__ = ["requests", "limits"] + class ResourceName(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + UNKNOWN: _ClassVar[Resources.ResourceName] + CPU: _ClassVar[Resources.ResourceName] + GPU: _ClassVar[Resources.ResourceName] + MEMORY: _ClassVar[Resources.ResourceName] + STORAGE: _ClassVar[Resources.ResourceName] + EPHEMERAL_STORAGE: _ClassVar[Resources.ResourceName] + UNKNOWN: Resources.ResourceName + CPU: Resources.ResourceName + GPU: Resources.ResourceName + MEMORY: Resources.ResourceName + STORAGE: Resources.ResourceName + EPHEMERAL_STORAGE: Resources.ResourceName + class ResourceEntry(_message.Message): + __slots__ = ["name", "value"] + NAME_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + name: Resources.ResourceName + value: str + def __init__(self, name: _Optional[_Union[Resources.ResourceName, str]] = ..., value: _Optional[str] = ...) -> None: ... + REQUESTS_FIELD_NUMBER: _ClassVar[int] + LIMITS_FIELD_NUMBER: _ClassVar[int] + requests: _containers.RepeatedCompositeFieldContainer[Resources.ResourceEntry] + limits: _containers.RepeatedCompositeFieldContainer[Resources.ResourceEntry] + def __init__(self, requests: _Optional[_Iterable[_Union[Resources.ResourceEntry, _Mapping]]] = ..., limits: _Optional[_Iterable[_Union[Resources.ResourceEntry, _Mapping]]] = ...) -> None: ... + +class GPUAccelerator(_message.Message): + __slots__ = ["device", "unpartitioned", "partition_size", "device_class"] + class DeviceClass(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + NVIDIA_GPU: _ClassVar[GPUAccelerator.DeviceClass] + GOOGLE_TPU: _ClassVar[GPUAccelerator.DeviceClass] + AMAZON_NEURON: _ClassVar[GPUAccelerator.DeviceClass] + AMD_GPU: _ClassVar[GPUAccelerator.DeviceClass] + HABANA_GAUDI: _ClassVar[GPUAccelerator.DeviceClass] + NVIDIA_GPU: GPUAccelerator.DeviceClass + GOOGLE_TPU: GPUAccelerator.DeviceClass + AMAZON_NEURON: GPUAccelerator.DeviceClass + AMD_GPU: GPUAccelerator.DeviceClass + HABANA_GAUDI: GPUAccelerator.DeviceClass + DEVICE_FIELD_NUMBER: _ClassVar[int] + UNPARTITIONED_FIELD_NUMBER: _ClassVar[int] + PARTITION_SIZE_FIELD_NUMBER: _ClassVar[int] + DEVICE_CLASS_FIELD_NUMBER: _ClassVar[int] + device: str + unpartitioned: bool + partition_size: str + device_class: GPUAccelerator.DeviceClass + def __init__(self, device: _Optional[str] = ..., unpartitioned: bool = ..., partition_size: _Optional[str] = ..., device_class: _Optional[_Union[GPUAccelerator.DeviceClass, str]] = ...) -> None: ... + +class SharedMemory(_message.Message): + __slots__ = ["mount_path", "mount_name", "size_limit"] + MOUNT_PATH_FIELD_NUMBER: _ClassVar[int] + MOUNT_NAME_FIELD_NUMBER: _ClassVar[int] + SIZE_LIMIT_FIELD_NUMBER: _ClassVar[int] + mount_path: str + mount_name: str + size_limit: str + def __init__(self, mount_path: _Optional[str] = ..., mount_name: _Optional[str] = ..., size_limit: _Optional[str] = ...) -> None: ... + +class ExtendedResources(_message.Message): + __slots__ = ["gpu_accelerator", "shared_memory"] + GPU_ACCELERATOR_FIELD_NUMBER: _ClassVar[int] + SHARED_MEMORY_FIELD_NUMBER: _ClassVar[int] + gpu_accelerator: GPUAccelerator + shared_memory: SharedMemory + def __init__(self, gpu_accelerator: _Optional[_Union[GPUAccelerator, _Mapping]] = ..., shared_memory: _Optional[_Union[SharedMemory, _Mapping]] = ...) -> None: ... + +class RuntimeMetadata(_message.Message): + __slots__ = ["type", "version", "flavor"] + class RuntimeType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + OTHER: _ClassVar[RuntimeMetadata.RuntimeType] + FLYTE_SDK: _ClassVar[RuntimeMetadata.RuntimeType] + OTHER: RuntimeMetadata.RuntimeType + FLYTE_SDK: RuntimeMetadata.RuntimeType + TYPE_FIELD_NUMBER: _ClassVar[int] + VERSION_FIELD_NUMBER: _ClassVar[int] + FLAVOR_FIELD_NUMBER: _ClassVar[int] + type: RuntimeMetadata.RuntimeType + version: str + flavor: str + def __init__(self, type: _Optional[_Union[RuntimeMetadata.RuntimeType, str]] = ..., version: _Optional[str] = ..., flavor: _Optional[str] = ...) -> None: ... + +class TaskMetadata(_message.Message): + __slots__ = ["discoverable", "runtime", "timeout", "retries", "discovery_version", "deprecated_error_message", "interruptible", "cache_serializable", "tags", "pod_template_name", "cache_ignore_input_vars", "is_eager", "generates_deck", "metadata", "debuggable", "log_links"] + class TagsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + DISCOVERABLE_FIELD_NUMBER: _ClassVar[int] + RUNTIME_FIELD_NUMBER: _ClassVar[int] + TIMEOUT_FIELD_NUMBER: _ClassVar[int] + RETRIES_FIELD_NUMBER: _ClassVar[int] + DISCOVERY_VERSION_FIELD_NUMBER: _ClassVar[int] + DEPRECATED_ERROR_MESSAGE_FIELD_NUMBER: _ClassVar[int] + INTERRUPTIBLE_FIELD_NUMBER: _ClassVar[int] + CACHE_SERIALIZABLE_FIELD_NUMBER: _ClassVar[int] + TAGS_FIELD_NUMBER: _ClassVar[int] + POD_TEMPLATE_NAME_FIELD_NUMBER: _ClassVar[int] + CACHE_IGNORE_INPUT_VARS_FIELD_NUMBER: _ClassVar[int] + IS_EAGER_FIELD_NUMBER: _ClassVar[int] + GENERATES_DECK_FIELD_NUMBER: _ClassVar[int] + METADATA_FIELD_NUMBER: _ClassVar[int] + DEBUGGABLE_FIELD_NUMBER: _ClassVar[int] + LOG_LINKS_FIELD_NUMBER: _ClassVar[int] + discoverable: bool + runtime: RuntimeMetadata + timeout: _duration_pb2.Duration + retries: _literals_pb2.RetryStrategy + discovery_version: str + deprecated_error_message: str + interruptible: bool + cache_serializable: bool + tags: _containers.ScalarMap[str, str] + pod_template_name: str + cache_ignore_input_vars: _containers.RepeatedScalarFieldContainer[str] + is_eager: bool + generates_deck: _wrappers_pb2.BoolValue + metadata: K8sObjectMetadata + debuggable: bool + log_links: _containers.RepeatedCompositeFieldContainer[_execution_pb2.TaskLog] + def __init__(self, discoverable: bool = ..., runtime: _Optional[_Union[RuntimeMetadata, _Mapping]] = ..., timeout: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., retries: _Optional[_Union[_literals_pb2.RetryStrategy, _Mapping]] = ..., discovery_version: _Optional[str] = ..., deprecated_error_message: _Optional[str] = ..., interruptible: bool = ..., cache_serializable: bool = ..., tags: _Optional[_Mapping[str, str]] = ..., pod_template_name: _Optional[str] = ..., cache_ignore_input_vars: _Optional[_Iterable[str]] = ..., is_eager: bool = ..., generates_deck: _Optional[_Union[_wrappers_pb2.BoolValue, _Mapping]] = ..., metadata: _Optional[_Union[K8sObjectMetadata, _Mapping]] = ..., debuggable: bool = ..., log_links: _Optional[_Iterable[_Union[_execution_pb2.TaskLog, _Mapping]]] = ...) -> None: ... + +class TaskTemplate(_message.Message): + __slots__ = ["id", "type", "metadata", "interface", "custom", "container", "k8s_pod", "sql", "task_type_version", "security_context", "extended_resources", "config"] + class ConfigEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + ID_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + METADATA_FIELD_NUMBER: _ClassVar[int] + INTERFACE_FIELD_NUMBER: _ClassVar[int] + CUSTOM_FIELD_NUMBER: _ClassVar[int] + CONTAINER_FIELD_NUMBER: _ClassVar[int] + K8S_POD_FIELD_NUMBER: _ClassVar[int] + SQL_FIELD_NUMBER: _ClassVar[int] + TASK_TYPE_VERSION_FIELD_NUMBER: _ClassVar[int] + SECURITY_CONTEXT_FIELD_NUMBER: _ClassVar[int] + EXTENDED_RESOURCES_FIELD_NUMBER: _ClassVar[int] + CONFIG_FIELD_NUMBER: _ClassVar[int] + id: _identifier_pb2.Identifier + type: str + metadata: TaskMetadata + interface: _interface_pb2.TypedInterface + custom: _struct_pb2.Struct + container: Container + k8s_pod: K8sPod + sql: Sql + task_type_version: int + security_context: _security_pb2.SecurityContext + extended_resources: ExtendedResources + config: _containers.ScalarMap[str, str] + def __init__(self, id: _Optional[_Union[_identifier_pb2.Identifier, _Mapping]] = ..., type: _Optional[str] = ..., metadata: _Optional[_Union[TaskMetadata, _Mapping]] = ..., interface: _Optional[_Union[_interface_pb2.TypedInterface, _Mapping]] = ..., custom: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., container: _Optional[_Union[Container, _Mapping]] = ..., k8s_pod: _Optional[_Union[K8sPod, _Mapping]] = ..., sql: _Optional[_Union[Sql, _Mapping]] = ..., task_type_version: _Optional[int] = ..., security_context: _Optional[_Union[_security_pb2.SecurityContext, _Mapping]] = ..., extended_resources: _Optional[_Union[ExtendedResources, _Mapping]] = ..., config: _Optional[_Mapping[str, str]] = ...) -> None: ... + +class ContainerPort(_message.Message): + __slots__ = ["container_port", "name"] + CONTAINER_PORT_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + container_port: int + name: str + def __init__(self, container_port: _Optional[int] = ..., name: _Optional[str] = ...) -> None: ... + +class Container(_message.Message): + __slots__ = ["image", "command", "args", "resources", "env", "config", "ports", "data_config", "architecture"] + class Architecture(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + UNKNOWN: _ClassVar[Container.Architecture] + AMD64: _ClassVar[Container.Architecture] + ARM64: _ClassVar[Container.Architecture] + ARM_V6: _ClassVar[Container.Architecture] + ARM_V7: _ClassVar[Container.Architecture] + UNKNOWN: Container.Architecture + AMD64: Container.Architecture + ARM64: Container.Architecture + ARM_V6: Container.Architecture + ARM_V7: Container.Architecture + IMAGE_FIELD_NUMBER: _ClassVar[int] + COMMAND_FIELD_NUMBER: _ClassVar[int] + ARGS_FIELD_NUMBER: _ClassVar[int] + RESOURCES_FIELD_NUMBER: _ClassVar[int] + ENV_FIELD_NUMBER: _ClassVar[int] + CONFIG_FIELD_NUMBER: _ClassVar[int] + PORTS_FIELD_NUMBER: _ClassVar[int] + DATA_CONFIG_FIELD_NUMBER: _ClassVar[int] + ARCHITECTURE_FIELD_NUMBER: _ClassVar[int] + image: str + command: _containers.RepeatedScalarFieldContainer[str] + args: _containers.RepeatedScalarFieldContainer[str] + resources: Resources + env: _containers.RepeatedCompositeFieldContainer[_literals_pb2.KeyValuePair] + config: _containers.RepeatedCompositeFieldContainer[_literals_pb2.KeyValuePair] + ports: _containers.RepeatedCompositeFieldContainer[ContainerPort] + data_config: DataLoadingConfig + architecture: Container.Architecture + def __init__(self, image: _Optional[str] = ..., command: _Optional[_Iterable[str]] = ..., args: _Optional[_Iterable[str]] = ..., resources: _Optional[_Union[Resources, _Mapping]] = ..., env: _Optional[_Iterable[_Union[_literals_pb2.KeyValuePair, _Mapping]]] = ..., config: _Optional[_Iterable[_Union[_literals_pb2.KeyValuePair, _Mapping]]] = ..., ports: _Optional[_Iterable[_Union[ContainerPort, _Mapping]]] = ..., data_config: _Optional[_Union[DataLoadingConfig, _Mapping]] = ..., architecture: _Optional[_Union[Container.Architecture, str]] = ...) -> None: ... + +class IOStrategy(_message.Message): + __slots__ = ["download_mode", "upload_mode"] + class DownloadMode(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + DOWNLOAD_EAGER: _ClassVar[IOStrategy.DownloadMode] + DOWNLOAD_STREAM: _ClassVar[IOStrategy.DownloadMode] + DO_NOT_DOWNLOAD: _ClassVar[IOStrategy.DownloadMode] + DOWNLOAD_EAGER: IOStrategy.DownloadMode + DOWNLOAD_STREAM: IOStrategy.DownloadMode + DO_NOT_DOWNLOAD: IOStrategy.DownloadMode + class UploadMode(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + UPLOAD_ON_EXIT: _ClassVar[IOStrategy.UploadMode] + UPLOAD_EAGER: _ClassVar[IOStrategy.UploadMode] + DO_NOT_UPLOAD: _ClassVar[IOStrategy.UploadMode] + UPLOAD_ON_EXIT: IOStrategy.UploadMode + UPLOAD_EAGER: IOStrategy.UploadMode + DO_NOT_UPLOAD: IOStrategy.UploadMode + DOWNLOAD_MODE_FIELD_NUMBER: _ClassVar[int] + UPLOAD_MODE_FIELD_NUMBER: _ClassVar[int] + download_mode: IOStrategy.DownloadMode + upload_mode: IOStrategy.UploadMode + def __init__(self, download_mode: _Optional[_Union[IOStrategy.DownloadMode, str]] = ..., upload_mode: _Optional[_Union[IOStrategy.UploadMode, str]] = ...) -> None: ... + +class DataLoadingConfig(_message.Message): + __slots__ = ["enabled", "input_path", "output_path", "format", "io_strategy"] + class LiteralMapFormat(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + JSON: _ClassVar[DataLoadingConfig.LiteralMapFormat] + YAML: _ClassVar[DataLoadingConfig.LiteralMapFormat] + PROTO: _ClassVar[DataLoadingConfig.LiteralMapFormat] + JSON: DataLoadingConfig.LiteralMapFormat + YAML: DataLoadingConfig.LiteralMapFormat + PROTO: DataLoadingConfig.LiteralMapFormat + ENABLED_FIELD_NUMBER: _ClassVar[int] + INPUT_PATH_FIELD_NUMBER: _ClassVar[int] + OUTPUT_PATH_FIELD_NUMBER: _ClassVar[int] + FORMAT_FIELD_NUMBER: _ClassVar[int] + IO_STRATEGY_FIELD_NUMBER: _ClassVar[int] + enabled: bool + input_path: str + output_path: str + format: DataLoadingConfig.LiteralMapFormat + io_strategy: IOStrategy + def __init__(self, enabled: bool = ..., input_path: _Optional[str] = ..., output_path: _Optional[str] = ..., format: _Optional[_Union[DataLoadingConfig.LiteralMapFormat, str]] = ..., io_strategy: _Optional[_Union[IOStrategy, _Mapping]] = ...) -> None: ... + +class K8sPod(_message.Message): + __slots__ = ["metadata", "pod_spec", "data_config", "primary_container_name"] + METADATA_FIELD_NUMBER: _ClassVar[int] + POD_SPEC_FIELD_NUMBER: _ClassVar[int] + DATA_CONFIG_FIELD_NUMBER: _ClassVar[int] + PRIMARY_CONTAINER_NAME_FIELD_NUMBER: _ClassVar[int] + metadata: K8sObjectMetadata + pod_spec: _struct_pb2.Struct + data_config: DataLoadingConfig + primary_container_name: str + def __init__(self, metadata: _Optional[_Union[K8sObjectMetadata, _Mapping]] = ..., pod_spec: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., data_config: _Optional[_Union[DataLoadingConfig, _Mapping]] = ..., primary_container_name: _Optional[str] = ...) -> None: ... + +class K8sObjectMetadata(_message.Message): + __slots__ = ["labels", "annotations"] + class LabelsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + class AnnotationsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + LABELS_FIELD_NUMBER: _ClassVar[int] + ANNOTATIONS_FIELD_NUMBER: _ClassVar[int] + labels: _containers.ScalarMap[str, str] + annotations: _containers.ScalarMap[str, str] + def __init__(self, labels: _Optional[_Mapping[str, str]] = ..., annotations: _Optional[_Mapping[str, str]] = ...) -> None: ... + +class Sql(_message.Message): + __slots__ = ["statement", "dialect"] + class Dialect(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + UNDEFINED: _ClassVar[Sql.Dialect] + ANSI: _ClassVar[Sql.Dialect] + HIVE: _ClassVar[Sql.Dialect] + OTHER: _ClassVar[Sql.Dialect] + UNDEFINED: Sql.Dialect + ANSI: Sql.Dialect + HIVE: Sql.Dialect + OTHER: Sql.Dialect + STATEMENT_FIELD_NUMBER: _ClassVar[int] + DIALECT_FIELD_NUMBER: _ClassVar[int] + statement: str + dialect: Sql.Dialect + def __init__(self, statement: _Optional[str] = ..., dialect: _Optional[_Union[Sql.Dialect, str]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/core/tasks_pb2_grpc.py b/gen/python/flyteidl2/core/tasks_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/core/tasks_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/core/types_pb2.py b/gen/python/flyteidl2/core/types_pb2.py new file mode 100644 index 0000000000..d32aa1c63e --- /dev/null +++ b/gen/python/flyteidl2/core/types_pb2.py @@ -0,0 +1,61 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/core/types.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1a\x66lyteidl2/core/types.proto\x12\x0e\x66lyteidl2.core\x1a\x1cgoogle/protobuf/struct.proto\"\xa3\x02\n\nSchemaType\x12\x41\n\x07\x63olumns\x18\x03 \x03(\x0b\x32\'.flyteidl2.core.SchemaType.SchemaColumnR\x07\x63olumns\x1a\xd1\x01\n\x0cSchemaColumn\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12L\n\x04type\x18\x02 \x01(\x0e\x32\x38.flyteidl2.core.SchemaType.SchemaColumn.SchemaColumnTypeR\x04type\"_\n\x10SchemaColumnType\x12\x0b\n\x07INTEGER\x10\x00\x12\t\n\x05\x46LOAT\x10\x01\x12\n\n\x06STRING\x10\x02\x12\x0b\n\x07\x42OOLEAN\x10\x03\x12\x0c\n\x08\x44\x41TETIME\x10\x04\x12\x0c\n\x08\x44URATION\x10\x05\"\xc9\x02\n\x15StructuredDatasetType\x12M\n\x07\x63olumns\x18\x01 \x03(\x0b\x32\x33.flyteidl2.core.StructuredDatasetType.DatasetColumnR\x07\x63olumns\x12\x16\n\x06\x66ormat\x18\x02 \x01(\tR\x06\x66ormat\x12\x30\n\x14\x65xternal_schema_type\x18\x03 \x01(\tR\x12\x65xternalSchemaType\x12\x32\n\x15\x65xternal_schema_bytes\x18\x04 \x01(\x0cR\x13\x65xternalSchemaBytes\x1a\x63\n\rDatasetColumn\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12>\n\x0cliteral_type\x18\x02 \x01(\x0b\x32\x1b.flyteidl2.core.LiteralTypeR\x0bliteralType\"\xa8\x01\n\x08\x42lobType\x12\x16\n\x06\x66ormat\x18\x01 \x01(\tR\x06\x66ormat\x12S\n\x0e\x64imensionality\x18\x02 \x01(\x0e\x32+.flyteidl2.core.BlobType.BlobDimensionalityR\x0e\x64imensionality\"/\n\x12\x42lobDimensionality\x12\n\n\x06SINGLE\x10\x00\x12\r\n\tMULTIPART\x10\x01\"\"\n\x08\x45numType\x12\x16\n\x06values\x18\x01 \x03(\tR\x06values\"D\n\tUnionType\x12\x37\n\x08variants\x18\x01 \x03(\x0b\x32\x1b.flyteidl2.core.LiteralTypeR\x08variants\"\xd9\x01\n\rTypeStructure\x12\x10\n\x03tag\x18\x01 \x01(\tR\x03tag\x12W\n\x0e\x64\x61taclass_type\x18\x02 \x03(\x0b\x32\x30.flyteidl2.core.TypeStructure.DataclassTypeEntryR\rdataclassType\x1a]\n\x12\x44\x61taclassTypeEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x31\n\x05value\x18\x02 \x01(\x0b\x32\x1b.flyteidl2.core.LiteralTypeR\x05value:\x02\x38\x01\"K\n\x0eTypeAnnotation\x12\x39\n\x0b\x61nnotations\x18\x01 \x01(\x0b\x32\x17.google.protobuf.StructR\x0b\x61nnotations\"\xc6\x05\n\x0bLiteralType\x12\x34\n\x06simple\x18\x01 \x01(\x0e\x32\x1a.flyteidl2.core.SimpleTypeH\x00R\x06simple\x12\x34\n\x06schema\x18\x02 \x01(\x0b\x32\x1a.flyteidl2.core.SchemaTypeH\x00R\x06schema\x12\x46\n\x0f\x63ollection_type\x18\x03 \x01(\x0b\x32\x1b.flyteidl2.core.LiteralTypeH\x00R\x0e\x63ollectionType\x12\x43\n\x0emap_value_type\x18\x04 \x01(\x0b\x32\x1b.flyteidl2.core.LiteralTypeH\x00R\x0cmapValueType\x12.\n\x04\x62lob\x18\x05 \x01(\x0b\x32\x18.flyteidl2.core.BlobTypeH\x00R\x04\x62lob\x12\x37\n\tenum_type\x18\x07 \x01(\x0b\x32\x18.flyteidl2.core.EnumTypeH\x00R\x08\x65numType\x12_\n\x17structured_dataset_type\x18\x08 \x01(\x0b\x32%.flyteidl2.core.StructuredDatasetTypeH\x00R\x15structuredDatasetType\x12:\n\nunion_type\x18\n \x01(\x0b\x32\x19.flyteidl2.core.UnionTypeH\x00R\tunionType\x12\x33\n\x08metadata\x18\x06 \x01(\x0b\x32\x17.google.protobuf.StructR\x08metadata\x12>\n\nannotation\x18\t \x01(\x0b\x32\x1e.flyteidl2.core.TypeAnnotationR\nannotation\x12;\n\tstructure\x18\x0b \x01(\x0b\x32\x1d.flyteidl2.core.TypeStructureR\tstructureB\x06\n\x04type\"{\n\x0fOutputReference\x12\x17\n\x07node_id\x18\x01 \x01(\tR\x06nodeId\x12\x10\n\x03var\x18\x02 \x01(\tR\x03var\x12=\n\tattr_path\x18\x03 \x03(\x0b\x32 .flyteidl2.core.PromiseAttributeR\x08\x61ttrPath\"_\n\x10PromiseAttribute\x12#\n\x0cstring_value\x18\x01 \x01(\tH\x00R\x0bstringValue\x12\x1d\n\tint_value\x18\x02 \x01(\x05H\x00R\x08intValueB\x07\n\x05value\"G\n\x05\x45rror\x12$\n\x0e\x66\x61iled_node_id\x18\x01 \x01(\tR\x0c\x66\x61iledNodeId\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message*\x86\x01\n\nSimpleType\x12\x08\n\x04NONE\x10\x00\x12\x0b\n\x07INTEGER\x10\x01\x12\t\n\x05\x46LOAT\x10\x02\x12\n\n\x06STRING\x10\x03\x12\x0b\n\x07\x42OOLEAN\x10\x04\x12\x0c\n\x08\x44\x41TETIME\x10\x05\x12\x0c\n\x08\x44URATION\x10\x06\x12\n\n\x06\x42INARY\x10\x07\x12\t\n\x05\x45RROR\x10\x08\x12\n\n\x06STRUCT\x10\tB\xaf\x01\n\x12\x63om.flyteidl2.coreB\nTypesProtoH\x02P\x01Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\xa2\x02\x03\x46\x43X\xaa\x02\x0e\x46lyteidl2.Core\xca\x02\x0e\x46lyteidl2\\Core\xe2\x02\x1a\x46lyteidl2\\Core\\GPBMetadata\xea\x02\x0f\x46lyteidl2::Coreb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.core.types_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\022com.flyteidl2.coreB\nTypesProtoH\002P\001Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core\242\002\003FCX\252\002\016Flyteidl2.Core\312\002\016Flyteidl2\\Core\342\002\032Flyteidl2\\Core\\GPBMetadata\352\002\017Flyteidl2::Core' + _TYPESTRUCTURE_DATACLASSTYPEENTRY._options = None + _TYPESTRUCTURE_DATACLASSTYPEENTRY._serialized_options = b'8\001' + _globals['_SIMPLETYPE']._serialized_start=2285 + _globals['_SIMPLETYPE']._serialized_end=2419 + _globals['_SCHEMATYPE']._serialized_start=77 + _globals['_SCHEMATYPE']._serialized_end=368 + _globals['_SCHEMATYPE_SCHEMACOLUMN']._serialized_start=159 + _globals['_SCHEMATYPE_SCHEMACOLUMN']._serialized_end=368 + _globals['_SCHEMATYPE_SCHEMACOLUMN_SCHEMACOLUMNTYPE']._serialized_start=273 + _globals['_SCHEMATYPE_SCHEMACOLUMN_SCHEMACOLUMNTYPE']._serialized_end=368 + _globals['_STRUCTUREDDATASETTYPE']._serialized_start=371 + _globals['_STRUCTUREDDATASETTYPE']._serialized_end=700 + _globals['_STRUCTUREDDATASETTYPE_DATASETCOLUMN']._serialized_start=601 + _globals['_STRUCTUREDDATASETTYPE_DATASETCOLUMN']._serialized_end=700 + _globals['_BLOBTYPE']._serialized_start=703 + _globals['_BLOBTYPE']._serialized_end=871 + _globals['_BLOBTYPE_BLOBDIMENSIONALITY']._serialized_start=824 + _globals['_BLOBTYPE_BLOBDIMENSIONALITY']._serialized_end=871 + _globals['_ENUMTYPE']._serialized_start=873 + _globals['_ENUMTYPE']._serialized_end=907 + _globals['_UNIONTYPE']._serialized_start=909 + _globals['_UNIONTYPE']._serialized_end=977 + _globals['_TYPESTRUCTURE']._serialized_start=980 + _globals['_TYPESTRUCTURE']._serialized_end=1197 + _globals['_TYPESTRUCTURE_DATACLASSTYPEENTRY']._serialized_start=1104 + _globals['_TYPESTRUCTURE_DATACLASSTYPEENTRY']._serialized_end=1197 + _globals['_TYPEANNOTATION']._serialized_start=1199 + _globals['_TYPEANNOTATION']._serialized_end=1274 + _globals['_LITERALTYPE']._serialized_start=1277 + _globals['_LITERALTYPE']._serialized_end=1987 + _globals['_OUTPUTREFERENCE']._serialized_start=1989 + _globals['_OUTPUTREFERENCE']._serialized_end=2112 + _globals['_PROMISEATTRIBUTE']._serialized_start=2114 + _globals['_PROMISEATTRIBUTE']._serialized_end=2209 + _globals['_ERROR']._serialized_start=2211 + _globals['_ERROR']._serialized_end=2282 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/core/types_pb2.pyi b/gen/python/flyteidl2/core/types_pb2.pyi new file mode 100644 index 0000000000..9028afabd5 --- /dev/null +++ b/gen/python/flyteidl2/core/types_pb2.pyi @@ -0,0 +1,176 @@ +from google.protobuf import struct_pb2 as _struct_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class SimpleType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + NONE: _ClassVar[SimpleType] + INTEGER: _ClassVar[SimpleType] + FLOAT: _ClassVar[SimpleType] + STRING: _ClassVar[SimpleType] + BOOLEAN: _ClassVar[SimpleType] + DATETIME: _ClassVar[SimpleType] + DURATION: _ClassVar[SimpleType] + BINARY: _ClassVar[SimpleType] + ERROR: _ClassVar[SimpleType] + STRUCT: _ClassVar[SimpleType] +NONE: SimpleType +INTEGER: SimpleType +FLOAT: SimpleType +STRING: SimpleType +BOOLEAN: SimpleType +DATETIME: SimpleType +DURATION: SimpleType +BINARY: SimpleType +ERROR: SimpleType +STRUCT: SimpleType + +class SchemaType(_message.Message): + __slots__ = ["columns"] + class SchemaColumn(_message.Message): + __slots__ = ["name", "type"] + class SchemaColumnType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + INTEGER: _ClassVar[SchemaType.SchemaColumn.SchemaColumnType] + FLOAT: _ClassVar[SchemaType.SchemaColumn.SchemaColumnType] + STRING: _ClassVar[SchemaType.SchemaColumn.SchemaColumnType] + BOOLEAN: _ClassVar[SchemaType.SchemaColumn.SchemaColumnType] + DATETIME: _ClassVar[SchemaType.SchemaColumn.SchemaColumnType] + DURATION: _ClassVar[SchemaType.SchemaColumn.SchemaColumnType] + INTEGER: SchemaType.SchemaColumn.SchemaColumnType + FLOAT: SchemaType.SchemaColumn.SchemaColumnType + STRING: SchemaType.SchemaColumn.SchemaColumnType + BOOLEAN: SchemaType.SchemaColumn.SchemaColumnType + DATETIME: SchemaType.SchemaColumn.SchemaColumnType + DURATION: SchemaType.SchemaColumn.SchemaColumnType + NAME_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + name: str + type: SchemaType.SchemaColumn.SchemaColumnType + def __init__(self, name: _Optional[str] = ..., type: _Optional[_Union[SchemaType.SchemaColumn.SchemaColumnType, str]] = ...) -> None: ... + COLUMNS_FIELD_NUMBER: _ClassVar[int] + columns: _containers.RepeatedCompositeFieldContainer[SchemaType.SchemaColumn] + def __init__(self, columns: _Optional[_Iterable[_Union[SchemaType.SchemaColumn, _Mapping]]] = ...) -> None: ... + +class StructuredDatasetType(_message.Message): + __slots__ = ["columns", "format", "external_schema_type", "external_schema_bytes"] + class DatasetColumn(_message.Message): + __slots__ = ["name", "literal_type"] + NAME_FIELD_NUMBER: _ClassVar[int] + LITERAL_TYPE_FIELD_NUMBER: _ClassVar[int] + name: str + literal_type: LiteralType + def __init__(self, name: _Optional[str] = ..., literal_type: _Optional[_Union[LiteralType, _Mapping]] = ...) -> None: ... + COLUMNS_FIELD_NUMBER: _ClassVar[int] + FORMAT_FIELD_NUMBER: _ClassVar[int] + EXTERNAL_SCHEMA_TYPE_FIELD_NUMBER: _ClassVar[int] + EXTERNAL_SCHEMA_BYTES_FIELD_NUMBER: _ClassVar[int] + columns: _containers.RepeatedCompositeFieldContainer[StructuredDatasetType.DatasetColumn] + format: str + external_schema_type: str + external_schema_bytes: bytes + def __init__(self, columns: _Optional[_Iterable[_Union[StructuredDatasetType.DatasetColumn, _Mapping]]] = ..., format: _Optional[str] = ..., external_schema_type: _Optional[str] = ..., external_schema_bytes: _Optional[bytes] = ...) -> None: ... + +class BlobType(_message.Message): + __slots__ = ["format", "dimensionality"] + class BlobDimensionality(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + SINGLE: _ClassVar[BlobType.BlobDimensionality] + MULTIPART: _ClassVar[BlobType.BlobDimensionality] + SINGLE: BlobType.BlobDimensionality + MULTIPART: BlobType.BlobDimensionality + FORMAT_FIELD_NUMBER: _ClassVar[int] + DIMENSIONALITY_FIELD_NUMBER: _ClassVar[int] + format: str + dimensionality: BlobType.BlobDimensionality + def __init__(self, format: _Optional[str] = ..., dimensionality: _Optional[_Union[BlobType.BlobDimensionality, str]] = ...) -> None: ... + +class EnumType(_message.Message): + __slots__ = ["values"] + VALUES_FIELD_NUMBER: _ClassVar[int] + values: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, values: _Optional[_Iterable[str]] = ...) -> None: ... + +class UnionType(_message.Message): + __slots__ = ["variants"] + VARIANTS_FIELD_NUMBER: _ClassVar[int] + variants: _containers.RepeatedCompositeFieldContainer[LiteralType] + def __init__(self, variants: _Optional[_Iterable[_Union[LiteralType, _Mapping]]] = ...) -> None: ... + +class TypeStructure(_message.Message): + __slots__ = ["tag", "dataclass_type"] + class DataclassTypeEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: LiteralType + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[LiteralType, _Mapping]] = ...) -> None: ... + TAG_FIELD_NUMBER: _ClassVar[int] + DATACLASS_TYPE_FIELD_NUMBER: _ClassVar[int] + tag: str + dataclass_type: _containers.MessageMap[str, LiteralType] + def __init__(self, tag: _Optional[str] = ..., dataclass_type: _Optional[_Mapping[str, LiteralType]] = ...) -> None: ... + +class TypeAnnotation(_message.Message): + __slots__ = ["annotations"] + ANNOTATIONS_FIELD_NUMBER: _ClassVar[int] + annotations: _struct_pb2.Struct + def __init__(self, annotations: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ... + +class LiteralType(_message.Message): + __slots__ = ["simple", "schema", "collection_type", "map_value_type", "blob", "enum_type", "structured_dataset_type", "union_type", "metadata", "annotation", "structure"] + SIMPLE_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + COLLECTION_TYPE_FIELD_NUMBER: _ClassVar[int] + MAP_VALUE_TYPE_FIELD_NUMBER: _ClassVar[int] + BLOB_FIELD_NUMBER: _ClassVar[int] + ENUM_TYPE_FIELD_NUMBER: _ClassVar[int] + STRUCTURED_DATASET_TYPE_FIELD_NUMBER: _ClassVar[int] + UNION_TYPE_FIELD_NUMBER: _ClassVar[int] + METADATA_FIELD_NUMBER: _ClassVar[int] + ANNOTATION_FIELD_NUMBER: _ClassVar[int] + STRUCTURE_FIELD_NUMBER: _ClassVar[int] + simple: SimpleType + schema: SchemaType + collection_type: LiteralType + map_value_type: LiteralType + blob: BlobType + enum_type: EnumType + structured_dataset_type: StructuredDatasetType + union_type: UnionType + metadata: _struct_pb2.Struct + annotation: TypeAnnotation + structure: TypeStructure + def __init__(self, simple: _Optional[_Union[SimpleType, str]] = ..., schema: _Optional[_Union[SchemaType, _Mapping]] = ..., collection_type: _Optional[_Union[LiteralType, _Mapping]] = ..., map_value_type: _Optional[_Union[LiteralType, _Mapping]] = ..., blob: _Optional[_Union[BlobType, _Mapping]] = ..., enum_type: _Optional[_Union[EnumType, _Mapping]] = ..., structured_dataset_type: _Optional[_Union[StructuredDatasetType, _Mapping]] = ..., union_type: _Optional[_Union[UnionType, _Mapping]] = ..., metadata: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., annotation: _Optional[_Union[TypeAnnotation, _Mapping]] = ..., structure: _Optional[_Union[TypeStructure, _Mapping]] = ...) -> None: ... + +class OutputReference(_message.Message): + __slots__ = ["node_id", "var", "attr_path"] + NODE_ID_FIELD_NUMBER: _ClassVar[int] + VAR_FIELD_NUMBER: _ClassVar[int] + ATTR_PATH_FIELD_NUMBER: _ClassVar[int] + node_id: str + var: str + attr_path: _containers.RepeatedCompositeFieldContainer[PromiseAttribute] + def __init__(self, node_id: _Optional[str] = ..., var: _Optional[str] = ..., attr_path: _Optional[_Iterable[_Union[PromiseAttribute, _Mapping]]] = ...) -> None: ... + +class PromiseAttribute(_message.Message): + __slots__ = ["string_value", "int_value"] + STRING_VALUE_FIELD_NUMBER: _ClassVar[int] + INT_VALUE_FIELD_NUMBER: _ClassVar[int] + string_value: str + int_value: int + def __init__(self, string_value: _Optional[str] = ..., int_value: _Optional[int] = ...) -> None: ... + +class Error(_message.Message): + __slots__ = ["failed_node_id", "message"] + FAILED_NODE_ID_FIELD_NUMBER: _ClassVar[int] + MESSAGE_FIELD_NUMBER: _ClassVar[int] + failed_node_id: str + message: str + def __init__(self, failed_node_id: _Optional[str] = ..., message: _Optional[str] = ...) -> None: ... diff --git a/gen/python/flyteidl2/core/types_pb2_grpc.py b/gen/python/flyteidl2/core/types_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/core/types_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/dataproxy/__init__.py b/gen/python/flyteidl2/dataproxy/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/dataproxy/dataproxy_service_pb2.py b/gen/python/flyteidl2/dataproxy/dataproxy_service_pb2.py new file mode 100644 index 0000000000..94ca8e45a9 --- /dev/null +++ b/gen/python/flyteidl2/dataproxy/dataproxy_service_pb2.py @@ -0,0 +1,47 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/dataproxy/dataproxy_service.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from google.api import annotations_pb2 as google_dot_api_dot_annotations__pb2 +from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 +from protoc_gen_openapiv2.options import annotations_pb2 as protoc__gen__openapiv2_dot_options_dot_annotations__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n+flyteidl2/dataproxy/dataproxy_service.proto\x12\x13\x66lyteidl2.dataproxy\x1a\x1b\x62uf/validate/validate.proto\x1a\x1cgoogle/api/annotations.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a.protoc-gen-openapiv2/options/annotations.proto\"\xf8\x02\n\x1b\x43reateUploadLocationRequest\x12!\n\x07project\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x07project\x12\x1f\n\x06\x64omain\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x06\x64omain\x12\x1a\n\x08\x66ilename\x18\x03 \x01(\tR\x08\x66ilename\x12\x38\n\nexpires_in\x18\x04 \x01(\x0b\x32\x19.google.protobuf.DurationR\texpiresIn\x12(\n\x0b\x63ontent_md5\x18\x05 \x01(\x0c\x42\x07\xbaH\x04z\x02h\x10R\ncontentMd5\x12#\n\rfilename_root\x18\x06 \x01(\tR\x0c\x66ilenameRoot\x12\x37\n\x18\x61\x64\x64_content_md5_metadata\x18\x07 \x01(\x08R\x15\x61\x64\x64\x43ontentMd5Metadata\x12\x10\n\x03org\x18\x08 \x01(\tR\x03org\x12%\n\x0e\x63ontent_length\x18\t \x01(\x03R\rcontentLength\"\xad\x02\n\x1c\x43reateUploadLocationResponse\x12\x1d\n\nsigned_url\x18\x01 \x01(\tR\tsignedUrl\x12\x1d\n\nnative_url\x18\x02 \x01(\tR\tnativeUrl\x12\x39\n\nexpires_at\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\texpiresAt\x12X\n\x07headers\x18\x04 \x03(\x0b\x32>.flyteidl2.dataproxy.CreateUploadLocationResponse.HeadersEntryR\x07headers\x1a:\n\x0cHeadersEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x32\xb5\x02\n\x10\x44\x61taProxyService\x12\xa0\x02\n\x14\x43reateUploadLocation\x12\x30.flyteidl2.dataproxy.CreateUploadLocationRequest\x1a\x31.flyteidl2.dataproxy.CreateUploadLocationResponse\"\xa2\x01\x92\x41M\x1aKCreates a write-only http location that is accessible for tasks at runtime.\x82\xd3\xe4\x93\x02L\"\x1e/api/v1/dataproxy/artifact_urn:\x01*Z\'\"\"/api/v1/org/dataproxy/artifact_urn:\x01*B\xd8\x01\n\x17\x63om.flyteidl2.dataproxyB\x15\x44\x61taproxyServiceProtoH\x02P\x01Z7github.com/flyteorg/flyte/v2/gen/go/flyteidl2/dataproxy\xa2\x02\x03\x46\x44X\xaa\x02\x13\x46lyteidl2.Dataproxy\xca\x02\x13\x46lyteidl2\\Dataproxy\xe2\x02\x1f\x46lyteidl2\\Dataproxy\\GPBMetadata\xea\x02\x14\x46lyteidl2::Dataproxyb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.dataproxy.dataproxy_service_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\027com.flyteidl2.dataproxyB\025DataproxyServiceProtoH\002P\001Z7github.com/flyteorg/flyte/v2/gen/go/flyteidl2/dataproxy\242\002\003FDX\252\002\023Flyteidl2.Dataproxy\312\002\023Flyteidl2\\Dataproxy\342\002\037Flyteidl2\\Dataproxy\\GPBMetadata\352\002\024Flyteidl2::Dataproxy' + _CREATEUPLOADLOCATIONREQUEST.fields_by_name['project']._options = None + _CREATEUPLOADLOCATIONREQUEST.fields_by_name['project']._serialized_options = b'\272H\004r\002\020\001' + _CREATEUPLOADLOCATIONREQUEST.fields_by_name['domain']._options = None + _CREATEUPLOADLOCATIONREQUEST.fields_by_name['domain']._serialized_options = b'\272H\004r\002\020\001' + _CREATEUPLOADLOCATIONREQUEST.fields_by_name['content_md5']._options = None + _CREATEUPLOADLOCATIONREQUEST.fields_by_name['content_md5']._serialized_options = b'\272H\004z\002h\020' + _CREATEUPLOADLOCATIONRESPONSE_HEADERSENTRY._options = None + _CREATEUPLOADLOCATIONRESPONSE_HEADERSENTRY._serialized_options = b'8\001' + _DATAPROXYSERVICE.methods_by_name['CreateUploadLocation']._options = None + _DATAPROXYSERVICE.methods_by_name['CreateUploadLocation']._serialized_options = b'\222AM\032KCreates a write-only http location that is accessible for tasks at runtime.\202\323\344\223\002L\"\036/api/v1/dataproxy/artifact_urn:\001*Z\'\"\"/api/v1/org/dataproxy/artifact_urn:\001*' + _globals['_CREATEUPLOADLOCATIONREQUEST']._serialized_start=241 + _globals['_CREATEUPLOADLOCATIONREQUEST']._serialized_end=617 + _globals['_CREATEUPLOADLOCATIONRESPONSE']._serialized_start=620 + _globals['_CREATEUPLOADLOCATIONRESPONSE']._serialized_end=921 + _globals['_CREATEUPLOADLOCATIONRESPONSE_HEADERSENTRY']._serialized_start=863 + _globals['_CREATEUPLOADLOCATIONRESPONSE_HEADERSENTRY']._serialized_end=921 + _globals['_DATAPROXYSERVICE']._serialized_start=924 + _globals['_DATAPROXYSERVICE']._serialized_end=1233 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/dataproxy/dataproxy_service_pb2.pyi b/gen/python/flyteidl2/dataproxy/dataproxy_service_pb2.pyi new file mode 100644 index 0000000000..7aead538a8 --- /dev/null +++ b/gen/python/flyteidl2/dataproxy/dataproxy_service_pb2.pyi @@ -0,0 +1,52 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from google.api import annotations_pb2 as _annotations_pb2 +from google.protobuf import duration_pb2 as _duration_pb2 +from google.protobuf import timestamp_pb2 as _timestamp_pb2 +from protoc_gen_openapiv2.options import annotations_pb2 as _annotations_pb2_1 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class CreateUploadLocationRequest(_message.Message): + __slots__ = ["project", "domain", "filename", "expires_in", "content_md5", "filename_root", "add_content_md5_metadata", "org", "content_length"] + PROJECT_FIELD_NUMBER: _ClassVar[int] + DOMAIN_FIELD_NUMBER: _ClassVar[int] + FILENAME_FIELD_NUMBER: _ClassVar[int] + EXPIRES_IN_FIELD_NUMBER: _ClassVar[int] + CONTENT_MD5_FIELD_NUMBER: _ClassVar[int] + FILENAME_ROOT_FIELD_NUMBER: _ClassVar[int] + ADD_CONTENT_MD5_METADATA_FIELD_NUMBER: _ClassVar[int] + ORG_FIELD_NUMBER: _ClassVar[int] + CONTENT_LENGTH_FIELD_NUMBER: _ClassVar[int] + project: str + domain: str + filename: str + expires_in: _duration_pb2.Duration + content_md5: bytes + filename_root: str + add_content_md5_metadata: bool + org: str + content_length: int + def __init__(self, project: _Optional[str] = ..., domain: _Optional[str] = ..., filename: _Optional[str] = ..., expires_in: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., content_md5: _Optional[bytes] = ..., filename_root: _Optional[str] = ..., add_content_md5_metadata: bool = ..., org: _Optional[str] = ..., content_length: _Optional[int] = ...) -> None: ... + +class CreateUploadLocationResponse(_message.Message): + __slots__ = ["signed_url", "native_url", "expires_at", "headers"] + class HeadersEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + SIGNED_URL_FIELD_NUMBER: _ClassVar[int] + NATIVE_URL_FIELD_NUMBER: _ClassVar[int] + EXPIRES_AT_FIELD_NUMBER: _ClassVar[int] + HEADERS_FIELD_NUMBER: _ClassVar[int] + signed_url: str + native_url: str + expires_at: _timestamp_pb2.Timestamp + headers: _containers.ScalarMap[str, str] + def __init__(self, signed_url: _Optional[str] = ..., native_url: _Optional[str] = ..., expires_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., headers: _Optional[_Mapping[str, str]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/dataproxy/dataproxy_service_pb2_grpc.py b/gen/python/flyteidl2/dataproxy/dataproxy_service_pb2_grpc.py new file mode 100644 index 0000000000..d1de6eb259 --- /dev/null +++ b/gen/python/flyteidl2/dataproxy/dataproxy_service_pb2_grpc.py @@ -0,0 +1,70 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from flyteidl2.dataproxy import dataproxy_service_pb2 as flyteidl2_dot_dataproxy_dot_dataproxy__service__pb2 + + +class DataProxyServiceStub(object): + """DataProxyService provides an interface for managing data uploads and downloads. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.CreateUploadLocation = channel.unary_unary( + '/flyteidl2.dataproxy.DataProxyService/CreateUploadLocation', + request_serializer=flyteidl2_dot_dataproxy_dot_dataproxy__service__pb2.CreateUploadLocationRequest.SerializeToString, + response_deserializer=flyteidl2_dot_dataproxy_dot_dataproxy__service__pb2.CreateUploadLocationResponse.FromString, + ) + + +class DataProxyServiceServicer(object): + """DataProxyService provides an interface for managing data uploads and downloads. + """ + + def CreateUploadLocation(self, request, context): + """CreateUploadLocation generates a signed URL for uploading data to the configured storage backend. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_DataProxyServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'CreateUploadLocation': grpc.unary_unary_rpc_method_handler( + servicer.CreateUploadLocation, + request_deserializer=flyteidl2_dot_dataproxy_dot_dataproxy__service__pb2.CreateUploadLocationRequest.FromString, + response_serializer=flyteidl2_dot_dataproxy_dot_dataproxy__service__pb2.CreateUploadLocationResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.dataproxy.DataProxyService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class DataProxyService(object): + """DataProxyService provides an interface for managing data uploads and downloads. + """ + + @staticmethod + def CreateUploadLocation(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.dataproxy.DataProxyService/CreateUploadLocation', + flyteidl2_dot_dataproxy_dot_dataproxy__service__pb2.CreateUploadLocationRequest.SerializeToString, + flyteidl2_dot_dataproxy_dot_dataproxy__service__pb2.CreateUploadLocationResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/gen/python/flyteidl2/event/__init__.py b/gen/python/flyteidl2/event/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/event/cloudevents_pb2.py b/gen/python/flyteidl2/event/cloudevents_pb2.py new file mode 100644 index 0000000000..a6dfd4a58c --- /dev/null +++ b/gen/python/flyteidl2/event/cloudevents_pb2.py @@ -0,0 +1,48 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/event/cloudevents.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.core import artifact_id_pb2 as flyteidl2_dot_core_dot_artifact__id__pb2 +from flyteidl2.core import identifier_pb2 as flyteidl2_dot_core_dot_identifier__pb2 +from flyteidl2.core import interface_pb2 as flyteidl2_dot_core_dot_interface__pb2 +from flyteidl2.event import event_pb2 as flyteidl2_dot_event_dot_event__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n!flyteidl2/event/cloudevents.proto\x12\x0f\x66lyteidl2.event\x1a flyteidl2/core/artifact_id.proto\x1a\x1f\x66lyteidl2/core/identifier.proto\x1a\x1e\x66lyteidl2/core/interface.proto\x1a\x1b\x66lyteidl2/event/event.proto\"\xb8\x04\n\x1b\x43loudEventWorkflowExecution\x12\x44\n\traw_event\x18\x01 \x01(\x0b\x32\'.flyteidl2.event.WorkflowExecutionEventR\x08rawEvent\x12I\n\x10output_interface\x18\x02 \x01(\x0b\x32\x1e.flyteidl2.core.TypedInterfaceR\x0foutputInterface\x12=\n\x0c\x61rtifact_ids\x18\x03 \x03(\x0b\x32\x1a.flyteidl2.core.ArtifactIDR\x0b\x61rtifactIds\x12\\\n\x13reference_execution\x18\x04 \x01(\x0b\x32+.flyteidl2.core.WorkflowExecutionIdentifierR\x12referenceExecution\x12\x1c\n\tprincipal\x18\x05 \x01(\tR\tprincipal\x12@\n\x0elaunch_plan_id\x18\x06 \x01(\x0b\x32\x1a.flyteidl2.core.IdentifierR\x0claunchPlanId\x12P\n\x06labels\x18\x07 \x03(\x0b\x32\x38.flyteidl2.event.CloudEventWorkflowExecution.LabelsEntryR\x06labels\x1a\x39\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\x99\x04\n\x17\x43loudEventNodeExecution\x12@\n\traw_event\x18\x01 \x01(\x0b\x32#.flyteidl2.event.NodeExecutionEventR\x08rawEvent\x12I\n\x0ctask_exec_id\x18\x02 \x01(\x0b\x32\'.flyteidl2.core.TaskExecutionIdentifierR\ntaskExecId\x12I\n\x10output_interface\x18\x03 \x01(\x0b\x32\x1e.flyteidl2.core.TypedInterfaceR\x0foutputInterface\x12=\n\x0c\x61rtifact_ids\x18\x04 \x03(\x0b\x32\x1a.flyteidl2.core.ArtifactIDR\x0b\x61rtifactIds\x12\x1c\n\tprincipal\x18\x05 \x01(\tR\tprincipal\x12@\n\x0elaunch_plan_id\x18\x06 \x01(\x0b\x32\x1a.flyteidl2.core.IdentifierR\x0claunchPlanId\x12L\n\x06labels\x18\x07 \x03(\x0b\x32\x34.flyteidl2.event.CloudEventNodeExecution.LabelsEntryR\x06labels\x1a\x39\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\xe4\x01\n\x17\x43loudEventTaskExecution\x12@\n\traw_event\x18\x01 \x01(\x0b\x32#.flyteidl2.event.TaskExecutionEventR\x08rawEvent\x12L\n\x06labels\x18\x02 \x03(\x0b\x32\x34.flyteidl2.event.CloudEventTaskExecution.LabelsEntryR\x06labels\x1a\x39\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\xf3\x02\n\x18\x43loudEventExecutionStart\x12N\n\x0c\x65xecution_id\x18\x01 \x01(\x0b\x32+.flyteidl2.core.WorkflowExecutionIdentifierR\x0b\x65xecutionId\x12@\n\x0elaunch_plan_id\x18\x02 \x01(\x0b\x32\x1a.flyteidl2.core.IdentifierR\x0claunchPlanId\x12;\n\x0bworkflow_id\x18\x03 \x01(\x0b\x32\x1a.flyteidl2.core.IdentifierR\nworkflowId\x12=\n\x0c\x61rtifact_ids\x18\x04 \x03(\x0b\x32\x1a.flyteidl2.core.ArtifactIDR\x0b\x61rtifactIds\x12+\n\x11\x61rtifact_trackers\x18\x05 \x03(\tR\x10\x61rtifactTrackers\x12\x1c\n\tprincipal\x18\x06 \x01(\tR\tprincipalB\xbb\x01\n\x13\x63om.flyteidl2.eventB\x10\x43loudeventsProtoH\x02P\x01Z3github.com/flyteorg/flyte/v2/gen/go/flyteidl2/event\xa2\x02\x03\x46\x45X\xaa\x02\x0f\x46lyteidl2.Event\xca\x02\x0f\x46lyteidl2\\Event\xe2\x02\x1b\x46lyteidl2\\Event\\GPBMetadata\xea\x02\x10\x46lyteidl2::Eventb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.event.cloudevents_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\023com.flyteidl2.eventB\020CloudeventsProtoH\002P\001Z3github.com/flyteorg/flyte/v2/gen/go/flyteidl2/event\242\002\003FEX\252\002\017Flyteidl2.Event\312\002\017Flyteidl2\\Event\342\002\033Flyteidl2\\Event\\GPBMetadata\352\002\020Flyteidl2::Event' + _CLOUDEVENTWORKFLOWEXECUTION_LABELSENTRY._options = None + _CLOUDEVENTWORKFLOWEXECUTION_LABELSENTRY._serialized_options = b'8\001' + _CLOUDEVENTNODEEXECUTION_LABELSENTRY._options = None + _CLOUDEVENTNODEEXECUTION_LABELSENTRY._serialized_options = b'8\001' + _CLOUDEVENTTASKEXECUTION_LABELSENTRY._options = None + _CLOUDEVENTTASKEXECUTION_LABELSENTRY._serialized_options = b'8\001' + _globals['_CLOUDEVENTWORKFLOWEXECUTION']._serialized_start=183 + _globals['_CLOUDEVENTWORKFLOWEXECUTION']._serialized_end=751 + _globals['_CLOUDEVENTWORKFLOWEXECUTION_LABELSENTRY']._serialized_start=694 + _globals['_CLOUDEVENTWORKFLOWEXECUTION_LABELSENTRY']._serialized_end=751 + _globals['_CLOUDEVENTNODEEXECUTION']._serialized_start=754 + _globals['_CLOUDEVENTNODEEXECUTION']._serialized_end=1291 + _globals['_CLOUDEVENTNODEEXECUTION_LABELSENTRY']._serialized_start=694 + _globals['_CLOUDEVENTNODEEXECUTION_LABELSENTRY']._serialized_end=751 + _globals['_CLOUDEVENTTASKEXECUTION']._serialized_start=1294 + _globals['_CLOUDEVENTTASKEXECUTION']._serialized_end=1522 + _globals['_CLOUDEVENTTASKEXECUTION_LABELSENTRY']._serialized_start=694 + _globals['_CLOUDEVENTTASKEXECUTION_LABELSENTRY']._serialized_end=751 + _globals['_CLOUDEVENTEXECUTIONSTART']._serialized_start=1525 + _globals['_CLOUDEVENTEXECUTIONSTART']._serialized_end=1896 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/event/cloudevents_pb2.pyi b/gen/python/flyteidl2/event/cloudevents_pb2.pyi new file mode 100644 index 0000000000..a5dabf91a3 --- /dev/null +++ b/gen/python/flyteidl2/event/cloudevents_pb2.pyi @@ -0,0 +1,91 @@ +from flyteidl2.core import artifact_id_pb2 as _artifact_id_pb2 +from flyteidl2.core import identifier_pb2 as _identifier_pb2 +from flyteidl2.core import interface_pb2 as _interface_pb2 +from flyteidl2.event import event_pb2 as _event_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class CloudEventWorkflowExecution(_message.Message): + __slots__ = ["raw_event", "output_interface", "artifact_ids", "reference_execution", "principal", "launch_plan_id", "labels"] + class LabelsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + RAW_EVENT_FIELD_NUMBER: _ClassVar[int] + OUTPUT_INTERFACE_FIELD_NUMBER: _ClassVar[int] + ARTIFACT_IDS_FIELD_NUMBER: _ClassVar[int] + REFERENCE_EXECUTION_FIELD_NUMBER: _ClassVar[int] + PRINCIPAL_FIELD_NUMBER: _ClassVar[int] + LAUNCH_PLAN_ID_FIELD_NUMBER: _ClassVar[int] + LABELS_FIELD_NUMBER: _ClassVar[int] + raw_event: _event_pb2.WorkflowExecutionEvent + output_interface: _interface_pb2.TypedInterface + artifact_ids: _containers.RepeatedCompositeFieldContainer[_artifact_id_pb2.ArtifactID] + reference_execution: _identifier_pb2.WorkflowExecutionIdentifier + principal: str + launch_plan_id: _identifier_pb2.Identifier + labels: _containers.ScalarMap[str, str] + def __init__(self, raw_event: _Optional[_Union[_event_pb2.WorkflowExecutionEvent, _Mapping]] = ..., output_interface: _Optional[_Union[_interface_pb2.TypedInterface, _Mapping]] = ..., artifact_ids: _Optional[_Iterable[_Union[_artifact_id_pb2.ArtifactID, _Mapping]]] = ..., reference_execution: _Optional[_Union[_identifier_pb2.WorkflowExecutionIdentifier, _Mapping]] = ..., principal: _Optional[str] = ..., launch_plan_id: _Optional[_Union[_identifier_pb2.Identifier, _Mapping]] = ..., labels: _Optional[_Mapping[str, str]] = ...) -> None: ... + +class CloudEventNodeExecution(_message.Message): + __slots__ = ["raw_event", "task_exec_id", "output_interface", "artifact_ids", "principal", "launch_plan_id", "labels"] + class LabelsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + RAW_EVENT_FIELD_NUMBER: _ClassVar[int] + TASK_EXEC_ID_FIELD_NUMBER: _ClassVar[int] + OUTPUT_INTERFACE_FIELD_NUMBER: _ClassVar[int] + ARTIFACT_IDS_FIELD_NUMBER: _ClassVar[int] + PRINCIPAL_FIELD_NUMBER: _ClassVar[int] + LAUNCH_PLAN_ID_FIELD_NUMBER: _ClassVar[int] + LABELS_FIELD_NUMBER: _ClassVar[int] + raw_event: _event_pb2.NodeExecutionEvent + task_exec_id: _identifier_pb2.TaskExecutionIdentifier + output_interface: _interface_pb2.TypedInterface + artifact_ids: _containers.RepeatedCompositeFieldContainer[_artifact_id_pb2.ArtifactID] + principal: str + launch_plan_id: _identifier_pb2.Identifier + labels: _containers.ScalarMap[str, str] + def __init__(self, raw_event: _Optional[_Union[_event_pb2.NodeExecutionEvent, _Mapping]] = ..., task_exec_id: _Optional[_Union[_identifier_pb2.TaskExecutionIdentifier, _Mapping]] = ..., output_interface: _Optional[_Union[_interface_pb2.TypedInterface, _Mapping]] = ..., artifact_ids: _Optional[_Iterable[_Union[_artifact_id_pb2.ArtifactID, _Mapping]]] = ..., principal: _Optional[str] = ..., launch_plan_id: _Optional[_Union[_identifier_pb2.Identifier, _Mapping]] = ..., labels: _Optional[_Mapping[str, str]] = ...) -> None: ... + +class CloudEventTaskExecution(_message.Message): + __slots__ = ["raw_event", "labels"] + class LabelsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + RAW_EVENT_FIELD_NUMBER: _ClassVar[int] + LABELS_FIELD_NUMBER: _ClassVar[int] + raw_event: _event_pb2.TaskExecutionEvent + labels: _containers.ScalarMap[str, str] + def __init__(self, raw_event: _Optional[_Union[_event_pb2.TaskExecutionEvent, _Mapping]] = ..., labels: _Optional[_Mapping[str, str]] = ...) -> None: ... + +class CloudEventExecutionStart(_message.Message): + __slots__ = ["execution_id", "launch_plan_id", "workflow_id", "artifact_ids", "artifact_trackers", "principal"] + EXECUTION_ID_FIELD_NUMBER: _ClassVar[int] + LAUNCH_PLAN_ID_FIELD_NUMBER: _ClassVar[int] + WORKFLOW_ID_FIELD_NUMBER: _ClassVar[int] + ARTIFACT_IDS_FIELD_NUMBER: _ClassVar[int] + ARTIFACT_TRACKERS_FIELD_NUMBER: _ClassVar[int] + PRINCIPAL_FIELD_NUMBER: _ClassVar[int] + execution_id: _identifier_pb2.WorkflowExecutionIdentifier + launch_plan_id: _identifier_pb2.Identifier + workflow_id: _identifier_pb2.Identifier + artifact_ids: _containers.RepeatedCompositeFieldContainer[_artifact_id_pb2.ArtifactID] + artifact_trackers: _containers.RepeatedScalarFieldContainer[str] + principal: str + def __init__(self, execution_id: _Optional[_Union[_identifier_pb2.WorkflowExecutionIdentifier, _Mapping]] = ..., launch_plan_id: _Optional[_Union[_identifier_pb2.Identifier, _Mapping]] = ..., workflow_id: _Optional[_Union[_identifier_pb2.Identifier, _Mapping]] = ..., artifact_ids: _Optional[_Iterable[_Union[_artifact_id_pb2.ArtifactID, _Mapping]]] = ..., artifact_trackers: _Optional[_Iterable[str]] = ..., principal: _Optional[str] = ...) -> None: ... diff --git a/gen/python/flyteidl2/event/cloudevents_pb2_grpc.py b/gen/python/flyteidl2/event/cloudevents_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/event/cloudevents_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/event/event_pb2.py b/gen/python/flyteidl2/event/event_pb2.py new file mode 100644 index 0000000000..9b5a4f0edb --- /dev/null +++ b/gen/python/flyteidl2/event/event_pb2.py @@ -0,0 +1,56 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/event/event.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.core import catalog_pb2 as flyteidl2_dot_core_dot_catalog__pb2 +from flyteidl2.core import execution_pb2 as flyteidl2_dot_core_dot_execution__pb2 +from flyteidl2.core import identifier_pb2 as flyteidl2_dot_core_dot_identifier__pb2 +from flyteidl2.core import literals_pb2 as flyteidl2_dot_core_dot_literals__pb2 +from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1b\x66lyteidl2/event/event.proto\x12\x0f\x66lyteidl2.event\x1a\x1c\x66lyteidl2/core/catalog.proto\x1a\x1e\x66lyteidl2/core/execution.proto\x1a\x1f\x66lyteidl2/core/identifier.proto\x1a\x1d\x66lyteidl2/core/literals.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xae\x03\n\x16WorkflowExecutionEvent\x12N\n\x0c\x65xecution_id\x18\x01 \x01(\x0b\x32+.flyteidl2.core.WorkflowExecutionIdentifierR\x0b\x65xecutionId\x12\x1f\n\x0bproducer_id\x18\x02 \x01(\tR\nproducerId\x12=\n\x05phase\x18\x03 \x01(\x0e\x32\'.flyteidl2.core.WorkflowExecution.PhaseR\x05phase\x12;\n\x0boccurred_at\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\noccurredAt\x12\x1f\n\noutput_uri\x18\x05 \x01(\tH\x00R\toutputUri\x12\x36\n\x05\x65rror\x18\x06 \x01(\x0b\x32\x1e.flyteidl2.core.ExecutionErrorH\x00R\x05\x65rror\x12=\n\x0boutput_data\x18\x07 \x01(\x0b\x32\x1a.flyteidl2.core.LiteralMapH\x00R\noutputDataB\x0f\n\routput_result\"\xbe\n\n\x12NodeExecutionEvent\x12\x37\n\x02id\x18\x01 \x01(\x0b\x32\'.flyteidl2.core.NodeExecutionIdentifierR\x02id\x12\x1f\n\x0bproducer_id\x18\x02 \x01(\tR\nproducerId\x12\x39\n\x05phase\x18\x03 \x01(\x0e\x32#.flyteidl2.core.NodeExecution.PhaseR\x05phase\x12;\n\x0boccurred_at\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\noccurredAt\x12\x1d\n\tinput_uri\x18\x05 \x01(\tH\x00R\x08inputUri\x12;\n\ninput_data\x18\x14 \x01(\x0b\x32\x1a.flyteidl2.core.LiteralMapH\x00R\tinputData\x12\x1f\n\noutput_uri\x18\x06 \x01(\tH\x01R\toutputUri\x12\x36\n\x05\x65rror\x18\x07 \x01(\x0b\x32\x1e.flyteidl2.core.ExecutionErrorH\x01R\x05\x65rror\x12=\n\x0boutput_data\x18\x0f \x01(\x0b\x32\x1a.flyteidl2.core.LiteralMapH\x01R\noutputData\x12]\n\x16workflow_node_metadata\x18\x08 \x01(\x0b\x32%.flyteidl2.event.WorkflowNodeMetadataH\x02R\x14workflowNodeMetadata\x12Q\n\x12task_node_metadata\x18\x0e \x01(\x0b\x32!.flyteidl2.event.TaskNodeMetadataH\x02R\x10taskNodeMetadata\x12^\n\x14parent_task_metadata\x18\t \x01(\x0b\x32,.flyteidl2.event.ParentTaskExecutionMetadataR\x12parentTaskMetadata\x12^\n\x14parent_node_metadata\x18\n \x01(\x0b\x32,.flyteidl2.event.ParentNodeExecutionMetadataR\x12parentNodeMetadata\x12\x1f\n\x0bretry_group\x18\x0b \x01(\tR\nretryGroup\x12 \n\x0cspec_node_id\x18\x0c \x01(\tR\nspecNodeId\x12\x1b\n\tnode_name\x18\r \x01(\tR\x08nodeName\x12#\n\revent_version\x18\x10 \x01(\x05R\x0c\x65ventVersion\x12\x1b\n\tis_parent\x18\x11 \x01(\x08R\x08isParent\x12\x1d\n\nis_dynamic\x18\x12 \x01(\x08R\tisDynamic\x12\x19\n\x08\x64\x65\x63k_uri\x18\x13 \x01(\tR\x07\x64\x65\x63kUri\x12;\n\x0breported_at\x18\x15 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\nreportedAt\x12\x19\n\x08is_array\x18\x16 \x01(\x08R\x07isArray\x12?\n\rtarget_entity\x18\x17 \x01(\x0b\x32\x1a.flyteidl2.core.IdentifierR\x0ctargetEntity\x12-\n\x13is_in_dynamic_chain\x18\x18 \x01(\x08R\x10isInDynamicChain\x12\x19\n\x08is_eager\x18\x19 \x01(\x08R\x07isEagerB\r\n\x0binput_valueB\x0f\n\routput_resultB\x11\n\x0ftarget_metadata\"f\n\x14WorkflowNodeMetadata\x12N\n\x0c\x65xecution_id\x18\x01 \x01(\x0b\x32+.flyteidl2.core.WorkflowExecutionIdentifierR\x0b\x65xecutionId\"\x9c\x02\n\x10TaskNodeMetadata\x12\x45\n\x0c\x63\x61\x63he_status\x18\x01 \x01(\x0e\x32\".flyteidl2.core.CatalogCacheStatusR\x0b\x63\x61\x63heStatus\x12@\n\x0b\x63\x61talog_key\x18\x02 \x01(\x0b\x32\x1f.flyteidl2.core.CatalogMetadataR\ncatalogKey\x12X\n\x12reservation_status\x18\x03 \x01(\x0e\x32).flyteidl2.core.CatalogReservation.StatusR\x11reservationStatus\x12%\n\x0e\x63heckpoint_uri\x18\x04 \x01(\tR\rcheckpointUri\"V\n\x1bParentTaskExecutionMetadata\x12\x37\n\x02id\x18\x01 \x01(\x0b\x32\'.flyteidl2.core.TaskExecutionIdentifierR\x02id\"6\n\x1bParentNodeExecutionMetadata\x12\x17\n\x07node_id\x18\x01 \x01(\tR\x06nodeId\"b\n\x0b\x45ventReason\x12\x16\n\x06reason\x18\x01 \x01(\tR\x06reason\x12;\n\x0boccurred_at\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\noccurredAt\"\xdd\x08\n\x12TaskExecutionEvent\x12\x33\n\x07task_id\x18\x01 \x01(\x0b\x32\x1a.flyteidl2.core.IdentifierR\x06taskId\x12`\n\x18parent_node_execution_id\x18\x02 \x01(\x0b\x32\'.flyteidl2.core.NodeExecutionIdentifierR\x15parentNodeExecutionId\x12#\n\rretry_attempt\x18\x03 \x01(\rR\x0cretryAttempt\x12\x39\n\x05phase\x18\x04 \x01(\x0e\x32#.flyteidl2.core.TaskExecution.PhaseR\x05phase\x12\x1f\n\x0bproducer_id\x18\x05 \x01(\tR\nproducerId\x12+\n\x04logs\x18\x06 \x03(\x0b\x32\x17.flyteidl2.core.TaskLogR\x04logs\x12;\n\x0boccurred_at\x18\x07 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\noccurredAt\x12\x1d\n\tinput_uri\x18\x08 \x01(\tH\x00R\x08inputUri\x12;\n\ninput_data\x18\x13 \x01(\x0b\x32\x1a.flyteidl2.core.LiteralMapH\x00R\tinputData\x12\x1f\n\noutput_uri\x18\t \x01(\tH\x01R\toutputUri\x12\x36\n\x05\x65rror\x18\n \x01(\x0b\x32\x1e.flyteidl2.core.ExecutionErrorH\x01R\x05\x65rror\x12=\n\x0boutput_data\x18\x11 \x01(\x0b\x32\x1a.flyteidl2.core.LiteralMapH\x01R\noutputData\x12\x38\n\x0b\x63ustom_info\x18\x0b \x01(\x0b\x32\x17.google.protobuf.StructR\ncustomInfo\x12#\n\rphase_version\x18\x0c \x01(\rR\x0cphaseVersion\x12\x1a\n\x06reason\x18\r \x01(\tB\x02\x18\x01R\x06reason\x12\x36\n\x07reasons\x18\x15 \x03(\x0b\x32\x1c.flyteidl2.event.EventReasonR\x07reasons\x12\x1b\n\ttask_type\x18\x0e \x01(\tR\x08taskType\x12\x42\n\x08metadata\x18\x10 \x01(\x0b\x32&.flyteidl2.event.TaskExecutionMetadataR\x08metadata\x12#\n\revent_version\x18\x12 \x01(\x05R\x0c\x65ventVersion\x12;\n\x0breported_at\x18\x14 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\nreportedAt\x12;\n\x0blog_context\x18\x16 \x01(\x0b\x32\x1a.flyteidl2.core.LogContextR\nlogContextB\r\n\x0binput_valueB\x0f\n\routput_result\"\x8a\x04\n\x14\x45xternalResourceInfo\x12\x1f\n\x0b\x65xternal_id\x18\x01 \x01(\tR\nexternalId\x12\x14\n\x05index\x18\x02 \x01(\rR\x05index\x12#\n\rretry_attempt\x18\x03 \x01(\rR\x0cretryAttempt\x12\x39\n\x05phase\x18\x04 \x01(\x0e\x32#.flyteidl2.core.TaskExecution.PhaseR\x05phase\x12\x45\n\x0c\x63\x61\x63he_status\x18\x05 \x01(\x0e\x32\".flyteidl2.core.CatalogCacheStatusR\x0b\x63\x61\x63heStatus\x12+\n\x04logs\x18\x06 \x03(\x0b\x32\x17.flyteidl2.core.TaskLogR\x04logs\x12]\n\x16workflow_node_metadata\x18\x07 \x01(\x0b\x32%.flyteidl2.event.WorkflowNodeMetadataH\x00R\x14workflowNodeMetadata\x12\x38\n\x0b\x63ustom_info\x18\x08 \x01(\x0b\x32\x17.google.protobuf.StructR\ncustomInfo\x12;\n\x0blog_context\x18\t \x01(\x0b\x32\x1a.flyteidl2.core.LogContextR\nlogContextB\x11\n\x0ftarget_metadata\"[\n\x10ResourcePoolInfo\x12)\n\x10\x61llocation_token\x18\x01 \x01(\tR\x0f\x61llocationToken\x12\x1c\n\tnamespace\x18\x02 \x01(\tR\tnamespace\"\xa0\x03\n\x15TaskExecutionMetadata\x12%\n\x0egenerated_name\x18\x01 \x01(\tR\rgeneratedName\x12T\n\x12\x65xternal_resources\x18\x02 \x03(\x0b\x32%.flyteidl2.event.ExternalResourceInfoR\x11\x65xternalResources\x12O\n\x12resource_pool_info\x18\x03 \x03(\x0b\x32!.flyteidl2.event.ResourcePoolInfoR\x10resourcePoolInfo\x12+\n\x11plugin_identifier\x18\x04 \x01(\tR\x10pluginIdentifier\x12[\n\x0einstance_class\x18\x10 \x01(\x0e\x32\x34.flyteidl2.event.TaskExecutionMetadata.InstanceClassR\rinstanceClass\"/\n\rInstanceClass\x12\x0b\n\x07\x44\x45\x46\x41ULT\x10\x00\x12\x11\n\rINTERRUPTIBLE\x10\x01\x42\xb5\x01\n\x13\x63om.flyteidl2.eventB\nEventProtoH\x02P\x01Z3github.com/flyteorg/flyte/v2/gen/go/flyteidl2/event\xa2\x02\x03\x46\x45X\xaa\x02\x0f\x46lyteidl2.Event\xca\x02\x0f\x46lyteidl2\\Event\xe2\x02\x1b\x46lyteidl2\\Event\\GPBMetadata\xea\x02\x10\x46lyteidl2::Eventb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.event.event_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\023com.flyteidl2.eventB\nEventProtoH\002P\001Z3github.com/flyteorg/flyte/v2/gen/go/flyteidl2/event\242\002\003FEX\252\002\017Flyteidl2.Event\312\002\017Flyteidl2\\Event\342\002\033Flyteidl2\\Event\\GPBMetadata\352\002\020Flyteidl2::Event' + _TASKEXECUTIONEVENT.fields_by_name['reason']._options = None + _TASKEXECUTIONEVENT.fields_by_name['reason']._serialized_options = b'\030\001' + _globals['_WORKFLOWEXECUTIONEVENT']._serialized_start=238 + _globals['_WORKFLOWEXECUTIONEVENT']._serialized_end=668 + _globals['_NODEEXECUTIONEVENT']._serialized_start=671 + _globals['_NODEEXECUTIONEVENT']._serialized_end=2013 + _globals['_WORKFLOWNODEMETADATA']._serialized_start=2015 + _globals['_WORKFLOWNODEMETADATA']._serialized_end=2117 + _globals['_TASKNODEMETADATA']._serialized_start=2120 + _globals['_TASKNODEMETADATA']._serialized_end=2404 + _globals['_PARENTTASKEXECUTIONMETADATA']._serialized_start=2406 + _globals['_PARENTTASKEXECUTIONMETADATA']._serialized_end=2492 + _globals['_PARENTNODEEXECUTIONMETADATA']._serialized_start=2494 + _globals['_PARENTNODEEXECUTIONMETADATA']._serialized_end=2548 + _globals['_EVENTREASON']._serialized_start=2550 + _globals['_EVENTREASON']._serialized_end=2648 + _globals['_TASKEXECUTIONEVENT']._serialized_start=2651 + _globals['_TASKEXECUTIONEVENT']._serialized_end=3768 + _globals['_EXTERNALRESOURCEINFO']._serialized_start=3771 + _globals['_EXTERNALRESOURCEINFO']._serialized_end=4293 + _globals['_RESOURCEPOOLINFO']._serialized_start=4295 + _globals['_RESOURCEPOOLINFO']._serialized_end=4386 + _globals['_TASKEXECUTIONMETADATA']._serialized_start=4389 + _globals['_TASKEXECUTIONMETADATA']._serialized_end=4805 + _globals['_TASKEXECUTIONMETADATA_INSTANCECLASS']._serialized_start=4758 + _globals['_TASKEXECUTIONMETADATA_INSTANCECLASS']._serialized_end=4805 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/event/event_pb2.pyi b/gen/python/flyteidl2/event/event_pb2.pyi new file mode 100644 index 0000000000..03d6a6579f --- /dev/null +++ b/gen/python/flyteidl2/event/event_pb2.pyi @@ -0,0 +1,219 @@ +from flyteidl2.core import catalog_pb2 as _catalog_pb2 +from flyteidl2.core import execution_pb2 as _execution_pb2 +from flyteidl2.core import identifier_pb2 as _identifier_pb2 +from flyteidl2.core import literals_pb2 as _literals_pb2 +from google.protobuf import struct_pb2 as _struct_pb2 +from google.protobuf import timestamp_pb2 as _timestamp_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class WorkflowExecutionEvent(_message.Message): + __slots__ = ["execution_id", "producer_id", "phase", "occurred_at", "output_uri", "error", "output_data"] + EXECUTION_ID_FIELD_NUMBER: _ClassVar[int] + PRODUCER_ID_FIELD_NUMBER: _ClassVar[int] + PHASE_FIELD_NUMBER: _ClassVar[int] + OCCURRED_AT_FIELD_NUMBER: _ClassVar[int] + OUTPUT_URI_FIELD_NUMBER: _ClassVar[int] + ERROR_FIELD_NUMBER: _ClassVar[int] + OUTPUT_DATA_FIELD_NUMBER: _ClassVar[int] + execution_id: _identifier_pb2.WorkflowExecutionIdentifier + producer_id: str + phase: _execution_pb2.WorkflowExecution.Phase + occurred_at: _timestamp_pb2.Timestamp + output_uri: str + error: _execution_pb2.ExecutionError + output_data: _literals_pb2.LiteralMap + def __init__(self, execution_id: _Optional[_Union[_identifier_pb2.WorkflowExecutionIdentifier, _Mapping]] = ..., producer_id: _Optional[str] = ..., phase: _Optional[_Union[_execution_pb2.WorkflowExecution.Phase, str]] = ..., occurred_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., output_uri: _Optional[str] = ..., error: _Optional[_Union[_execution_pb2.ExecutionError, _Mapping]] = ..., output_data: _Optional[_Union[_literals_pb2.LiteralMap, _Mapping]] = ...) -> None: ... + +class NodeExecutionEvent(_message.Message): + __slots__ = ["id", "producer_id", "phase", "occurred_at", "input_uri", "input_data", "output_uri", "error", "output_data", "workflow_node_metadata", "task_node_metadata", "parent_task_metadata", "parent_node_metadata", "retry_group", "spec_node_id", "node_name", "event_version", "is_parent", "is_dynamic", "deck_uri", "reported_at", "is_array", "target_entity", "is_in_dynamic_chain", "is_eager"] + ID_FIELD_NUMBER: _ClassVar[int] + PRODUCER_ID_FIELD_NUMBER: _ClassVar[int] + PHASE_FIELD_NUMBER: _ClassVar[int] + OCCURRED_AT_FIELD_NUMBER: _ClassVar[int] + INPUT_URI_FIELD_NUMBER: _ClassVar[int] + INPUT_DATA_FIELD_NUMBER: _ClassVar[int] + OUTPUT_URI_FIELD_NUMBER: _ClassVar[int] + ERROR_FIELD_NUMBER: _ClassVar[int] + OUTPUT_DATA_FIELD_NUMBER: _ClassVar[int] + WORKFLOW_NODE_METADATA_FIELD_NUMBER: _ClassVar[int] + TASK_NODE_METADATA_FIELD_NUMBER: _ClassVar[int] + PARENT_TASK_METADATA_FIELD_NUMBER: _ClassVar[int] + PARENT_NODE_METADATA_FIELD_NUMBER: _ClassVar[int] + RETRY_GROUP_FIELD_NUMBER: _ClassVar[int] + SPEC_NODE_ID_FIELD_NUMBER: _ClassVar[int] + NODE_NAME_FIELD_NUMBER: _ClassVar[int] + EVENT_VERSION_FIELD_NUMBER: _ClassVar[int] + IS_PARENT_FIELD_NUMBER: _ClassVar[int] + IS_DYNAMIC_FIELD_NUMBER: _ClassVar[int] + DECK_URI_FIELD_NUMBER: _ClassVar[int] + REPORTED_AT_FIELD_NUMBER: _ClassVar[int] + IS_ARRAY_FIELD_NUMBER: _ClassVar[int] + TARGET_ENTITY_FIELD_NUMBER: _ClassVar[int] + IS_IN_DYNAMIC_CHAIN_FIELD_NUMBER: _ClassVar[int] + IS_EAGER_FIELD_NUMBER: _ClassVar[int] + id: _identifier_pb2.NodeExecutionIdentifier + producer_id: str + phase: _execution_pb2.NodeExecution.Phase + occurred_at: _timestamp_pb2.Timestamp + input_uri: str + input_data: _literals_pb2.LiteralMap + output_uri: str + error: _execution_pb2.ExecutionError + output_data: _literals_pb2.LiteralMap + workflow_node_metadata: WorkflowNodeMetadata + task_node_metadata: TaskNodeMetadata + parent_task_metadata: ParentTaskExecutionMetadata + parent_node_metadata: ParentNodeExecutionMetadata + retry_group: str + spec_node_id: str + node_name: str + event_version: int + is_parent: bool + is_dynamic: bool + deck_uri: str + reported_at: _timestamp_pb2.Timestamp + is_array: bool + target_entity: _identifier_pb2.Identifier + is_in_dynamic_chain: bool + is_eager: bool + def __init__(self, id: _Optional[_Union[_identifier_pb2.NodeExecutionIdentifier, _Mapping]] = ..., producer_id: _Optional[str] = ..., phase: _Optional[_Union[_execution_pb2.NodeExecution.Phase, str]] = ..., occurred_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., input_uri: _Optional[str] = ..., input_data: _Optional[_Union[_literals_pb2.LiteralMap, _Mapping]] = ..., output_uri: _Optional[str] = ..., error: _Optional[_Union[_execution_pb2.ExecutionError, _Mapping]] = ..., output_data: _Optional[_Union[_literals_pb2.LiteralMap, _Mapping]] = ..., workflow_node_metadata: _Optional[_Union[WorkflowNodeMetadata, _Mapping]] = ..., task_node_metadata: _Optional[_Union[TaskNodeMetadata, _Mapping]] = ..., parent_task_metadata: _Optional[_Union[ParentTaskExecutionMetadata, _Mapping]] = ..., parent_node_metadata: _Optional[_Union[ParentNodeExecutionMetadata, _Mapping]] = ..., retry_group: _Optional[str] = ..., spec_node_id: _Optional[str] = ..., node_name: _Optional[str] = ..., event_version: _Optional[int] = ..., is_parent: bool = ..., is_dynamic: bool = ..., deck_uri: _Optional[str] = ..., reported_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., is_array: bool = ..., target_entity: _Optional[_Union[_identifier_pb2.Identifier, _Mapping]] = ..., is_in_dynamic_chain: bool = ..., is_eager: bool = ...) -> None: ... + +class WorkflowNodeMetadata(_message.Message): + __slots__ = ["execution_id"] + EXECUTION_ID_FIELD_NUMBER: _ClassVar[int] + execution_id: _identifier_pb2.WorkflowExecutionIdentifier + def __init__(self, execution_id: _Optional[_Union[_identifier_pb2.WorkflowExecutionIdentifier, _Mapping]] = ...) -> None: ... + +class TaskNodeMetadata(_message.Message): + __slots__ = ["cache_status", "catalog_key", "reservation_status", "checkpoint_uri"] + CACHE_STATUS_FIELD_NUMBER: _ClassVar[int] + CATALOG_KEY_FIELD_NUMBER: _ClassVar[int] + RESERVATION_STATUS_FIELD_NUMBER: _ClassVar[int] + CHECKPOINT_URI_FIELD_NUMBER: _ClassVar[int] + cache_status: _catalog_pb2.CatalogCacheStatus + catalog_key: _catalog_pb2.CatalogMetadata + reservation_status: _catalog_pb2.CatalogReservation.Status + checkpoint_uri: str + def __init__(self, cache_status: _Optional[_Union[_catalog_pb2.CatalogCacheStatus, str]] = ..., catalog_key: _Optional[_Union[_catalog_pb2.CatalogMetadata, _Mapping]] = ..., reservation_status: _Optional[_Union[_catalog_pb2.CatalogReservation.Status, str]] = ..., checkpoint_uri: _Optional[str] = ...) -> None: ... + +class ParentTaskExecutionMetadata(_message.Message): + __slots__ = ["id"] + ID_FIELD_NUMBER: _ClassVar[int] + id: _identifier_pb2.TaskExecutionIdentifier + def __init__(self, id: _Optional[_Union[_identifier_pb2.TaskExecutionIdentifier, _Mapping]] = ...) -> None: ... + +class ParentNodeExecutionMetadata(_message.Message): + __slots__ = ["node_id"] + NODE_ID_FIELD_NUMBER: _ClassVar[int] + node_id: str + def __init__(self, node_id: _Optional[str] = ...) -> None: ... + +class EventReason(_message.Message): + __slots__ = ["reason", "occurred_at"] + REASON_FIELD_NUMBER: _ClassVar[int] + OCCURRED_AT_FIELD_NUMBER: _ClassVar[int] + reason: str + occurred_at: _timestamp_pb2.Timestamp + def __init__(self, reason: _Optional[str] = ..., occurred_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ...) -> None: ... + +class TaskExecutionEvent(_message.Message): + __slots__ = ["task_id", "parent_node_execution_id", "retry_attempt", "phase", "producer_id", "logs", "occurred_at", "input_uri", "input_data", "output_uri", "error", "output_data", "custom_info", "phase_version", "reason", "reasons", "task_type", "metadata", "event_version", "reported_at", "log_context"] + TASK_ID_FIELD_NUMBER: _ClassVar[int] + PARENT_NODE_EXECUTION_ID_FIELD_NUMBER: _ClassVar[int] + RETRY_ATTEMPT_FIELD_NUMBER: _ClassVar[int] + PHASE_FIELD_NUMBER: _ClassVar[int] + PRODUCER_ID_FIELD_NUMBER: _ClassVar[int] + LOGS_FIELD_NUMBER: _ClassVar[int] + OCCURRED_AT_FIELD_NUMBER: _ClassVar[int] + INPUT_URI_FIELD_NUMBER: _ClassVar[int] + INPUT_DATA_FIELD_NUMBER: _ClassVar[int] + OUTPUT_URI_FIELD_NUMBER: _ClassVar[int] + ERROR_FIELD_NUMBER: _ClassVar[int] + OUTPUT_DATA_FIELD_NUMBER: _ClassVar[int] + CUSTOM_INFO_FIELD_NUMBER: _ClassVar[int] + PHASE_VERSION_FIELD_NUMBER: _ClassVar[int] + REASON_FIELD_NUMBER: _ClassVar[int] + REASONS_FIELD_NUMBER: _ClassVar[int] + TASK_TYPE_FIELD_NUMBER: _ClassVar[int] + METADATA_FIELD_NUMBER: _ClassVar[int] + EVENT_VERSION_FIELD_NUMBER: _ClassVar[int] + REPORTED_AT_FIELD_NUMBER: _ClassVar[int] + LOG_CONTEXT_FIELD_NUMBER: _ClassVar[int] + task_id: _identifier_pb2.Identifier + parent_node_execution_id: _identifier_pb2.NodeExecutionIdentifier + retry_attempt: int + phase: _execution_pb2.TaskExecution.Phase + producer_id: str + logs: _containers.RepeatedCompositeFieldContainer[_execution_pb2.TaskLog] + occurred_at: _timestamp_pb2.Timestamp + input_uri: str + input_data: _literals_pb2.LiteralMap + output_uri: str + error: _execution_pb2.ExecutionError + output_data: _literals_pb2.LiteralMap + custom_info: _struct_pb2.Struct + phase_version: int + reason: str + reasons: _containers.RepeatedCompositeFieldContainer[EventReason] + task_type: str + metadata: TaskExecutionMetadata + event_version: int + reported_at: _timestamp_pb2.Timestamp + log_context: _execution_pb2.LogContext + def __init__(self, task_id: _Optional[_Union[_identifier_pb2.Identifier, _Mapping]] = ..., parent_node_execution_id: _Optional[_Union[_identifier_pb2.NodeExecutionIdentifier, _Mapping]] = ..., retry_attempt: _Optional[int] = ..., phase: _Optional[_Union[_execution_pb2.TaskExecution.Phase, str]] = ..., producer_id: _Optional[str] = ..., logs: _Optional[_Iterable[_Union[_execution_pb2.TaskLog, _Mapping]]] = ..., occurred_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., input_uri: _Optional[str] = ..., input_data: _Optional[_Union[_literals_pb2.LiteralMap, _Mapping]] = ..., output_uri: _Optional[str] = ..., error: _Optional[_Union[_execution_pb2.ExecutionError, _Mapping]] = ..., output_data: _Optional[_Union[_literals_pb2.LiteralMap, _Mapping]] = ..., custom_info: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., phase_version: _Optional[int] = ..., reason: _Optional[str] = ..., reasons: _Optional[_Iterable[_Union[EventReason, _Mapping]]] = ..., task_type: _Optional[str] = ..., metadata: _Optional[_Union[TaskExecutionMetadata, _Mapping]] = ..., event_version: _Optional[int] = ..., reported_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., log_context: _Optional[_Union[_execution_pb2.LogContext, _Mapping]] = ...) -> None: ... + +class ExternalResourceInfo(_message.Message): + __slots__ = ["external_id", "index", "retry_attempt", "phase", "cache_status", "logs", "workflow_node_metadata", "custom_info", "log_context"] + EXTERNAL_ID_FIELD_NUMBER: _ClassVar[int] + INDEX_FIELD_NUMBER: _ClassVar[int] + RETRY_ATTEMPT_FIELD_NUMBER: _ClassVar[int] + PHASE_FIELD_NUMBER: _ClassVar[int] + CACHE_STATUS_FIELD_NUMBER: _ClassVar[int] + LOGS_FIELD_NUMBER: _ClassVar[int] + WORKFLOW_NODE_METADATA_FIELD_NUMBER: _ClassVar[int] + CUSTOM_INFO_FIELD_NUMBER: _ClassVar[int] + LOG_CONTEXT_FIELD_NUMBER: _ClassVar[int] + external_id: str + index: int + retry_attempt: int + phase: _execution_pb2.TaskExecution.Phase + cache_status: _catalog_pb2.CatalogCacheStatus + logs: _containers.RepeatedCompositeFieldContainer[_execution_pb2.TaskLog] + workflow_node_metadata: WorkflowNodeMetadata + custom_info: _struct_pb2.Struct + log_context: _execution_pb2.LogContext + def __init__(self, external_id: _Optional[str] = ..., index: _Optional[int] = ..., retry_attempt: _Optional[int] = ..., phase: _Optional[_Union[_execution_pb2.TaskExecution.Phase, str]] = ..., cache_status: _Optional[_Union[_catalog_pb2.CatalogCacheStatus, str]] = ..., logs: _Optional[_Iterable[_Union[_execution_pb2.TaskLog, _Mapping]]] = ..., workflow_node_metadata: _Optional[_Union[WorkflowNodeMetadata, _Mapping]] = ..., custom_info: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., log_context: _Optional[_Union[_execution_pb2.LogContext, _Mapping]] = ...) -> None: ... + +class ResourcePoolInfo(_message.Message): + __slots__ = ["allocation_token", "namespace"] + ALLOCATION_TOKEN_FIELD_NUMBER: _ClassVar[int] + NAMESPACE_FIELD_NUMBER: _ClassVar[int] + allocation_token: str + namespace: str + def __init__(self, allocation_token: _Optional[str] = ..., namespace: _Optional[str] = ...) -> None: ... + +class TaskExecutionMetadata(_message.Message): + __slots__ = ["generated_name", "external_resources", "resource_pool_info", "plugin_identifier", "instance_class"] + class InstanceClass(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + DEFAULT: _ClassVar[TaskExecutionMetadata.InstanceClass] + INTERRUPTIBLE: _ClassVar[TaskExecutionMetadata.InstanceClass] + DEFAULT: TaskExecutionMetadata.InstanceClass + INTERRUPTIBLE: TaskExecutionMetadata.InstanceClass + GENERATED_NAME_FIELD_NUMBER: _ClassVar[int] + EXTERNAL_RESOURCES_FIELD_NUMBER: _ClassVar[int] + RESOURCE_POOL_INFO_FIELD_NUMBER: _ClassVar[int] + PLUGIN_IDENTIFIER_FIELD_NUMBER: _ClassVar[int] + INSTANCE_CLASS_FIELD_NUMBER: _ClassVar[int] + generated_name: str + external_resources: _containers.RepeatedCompositeFieldContainer[ExternalResourceInfo] + resource_pool_info: _containers.RepeatedCompositeFieldContainer[ResourcePoolInfo] + plugin_identifier: str + instance_class: TaskExecutionMetadata.InstanceClass + def __init__(self, generated_name: _Optional[str] = ..., external_resources: _Optional[_Iterable[_Union[ExternalResourceInfo, _Mapping]]] = ..., resource_pool_info: _Optional[_Iterable[_Union[ResourcePoolInfo, _Mapping]]] = ..., plugin_identifier: _Optional[str] = ..., instance_class: _Optional[_Union[TaskExecutionMetadata.InstanceClass, str]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/event/event_pb2_grpc.py b/gen/python/flyteidl2/event/event_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/event/event_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/imagebuilder/__init__.py b/gen/python/flyteidl2/imagebuilder/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/imagebuilder/definition_pb2.py b/gen/python/flyteidl2/imagebuilder/definition_pb2.py new file mode 100644 index 0000000000..d1ae131ba8 --- /dev/null +++ b/gen/python/flyteidl2/imagebuilder/definition_pb2.py @@ -0,0 +1,62 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/imagebuilder/definition.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.core import security_pb2 as flyteidl2_dot_core_dot_security__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\'flyteidl2/imagebuilder/definition.proto\x12\x16\x66lyteidl2.imagebuilder\x1a\x1b\x62uf/validate/validate.proto\x1a\x1d\x66lyteidl2/core/security.proto\".\n\x0fImageIdentifier\x12\x1b\n\x04name\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x04name\"T\n\x05Image\x12\x37\n\x02id\x18\x01 \x01(\x0b\x32\'.flyteidl2.imagebuilder.ImageIdentifierR\x02id\x12\x12\n\x04\x66qin\x18\x02 \x01(\tR\x04\x66qin\"f\n\x0b\x41ptPackages\x12\x1a\n\x08packages\x18\x01 \x03(\tR\x08packages\x12;\n\rsecret_mounts\x18\x02 \x03(\x0b\x32\x16.flyteidl2.core.SecretR\x0csecretMounts\"\x84\x01\n\nPipOptions\x12\x1b\n\tindex_url\x18\x02 \x01(\tR\x08indexUrl\x12(\n\x10\x65xtra_index_urls\x18\x03 \x03(\tR\x0e\x65xtraIndexUrls\x12\x10\n\x03pre\x18\x04 \x01(\x08R\x03pre\x12\x1d\n\nextra_args\x18\x05 \x01(\tR\textraArgs\"\xa4\x01\n\x0bPipPackages\x12\x1a\n\x08packages\x18\x01 \x03(\tR\x08packages\x12<\n\x07options\x18\x02 \x01(\x0b\x32\".flyteidl2.imagebuilder.PipOptionsR\x07options\x12;\n\rsecret_mounts\x18\x03 \x03(\x0b\x32\x16.flyteidl2.core.SecretR\x0csecretMounts\"\x9d\x01\n\x0cRequirements\x12\x12\n\x04\x66ile\x18\x01 \x01(\tR\x04\x66ile\x12<\n\x07options\x18\x02 \x01(\x0b\x32\".flyteidl2.imagebuilder.PipOptionsR\x07options\x12;\n\rsecret_mounts\x18\x03 \x03(\x0b\x32\x16.flyteidl2.core.SecretR\x0csecretMounts\"\x9b\x01\n\x0cPythonWheels\x12\x10\n\x03\x64ir\x18\x01 \x01(\tR\x03\x64ir\x12<\n\x07options\x18\x02 \x01(\x0b\x32\".flyteidl2.imagebuilder.PipOptionsR\x07options\x12;\n\rsecret_mounts\x18\x03 \x03(\x0b\x32\x16.flyteidl2.core.SecretR\x0csecretMounts\"\xbc\x01\n\tUVProject\x12\x1c\n\tpyproject\x18\x01 \x01(\tR\tpyproject\x12\x16\n\x06uvlock\x18\x02 \x01(\tR\x06uvlock\x12<\n\x07options\x18\x03 \x01(\x0b\x32\".flyteidl2.imagebuilder.PipOptionsR\x07options\x12;\n\rsecret_mounts\x18\x04 \x03(\x0b\x32\x16.flyteidl2.core.SecretR\x0csecretMounts\"Y\n\x08\x43ommands\x12\x10\n\x03\x63md\x18\x02 \x03(\tR\x03\x63md\x12;\n\rsecret_mounts\x18\x03 \x03(\x0b\x32\x16.flyteidl2.core.SecretR\x0csecretMounts\"#\n\x07WorkDir\x12\x18\n\x07workdir\x18\x01 \x01(\tR\x07workdir\"0\n\nCopyConfig\x12\x10\n\x03src\x18\x01 \x01(\tR\x03src\x12\x10\n\x03\x64st\x18\x02 \x01(\tR\x03\x64st\"\x9a\x01\n\x03\x45nv\x12R\n\renv_variables\x18\x01 \x03(\x0b\x32-.flyteidl2.imagebuilder.Env.EnvVariablesEntryR\x0c\x65nvVariables\x1a?\n\x11\x45nvVariablesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\xaa\x01\n\rPoetryProject\x12\x1c\n\tpyproject\x18\x01 \x01(\tR\tpyproject\x12\x1f\n\x0bpoetry_lock\x18\x02 \x01(\tR\npoetryLock\x12\x1d\n\nextra_args\x18\x03 \x01(\tR\textraArgs\x12;\n\rsecret_mounts\x18\x04 \x03(\x0b\x32\x16.flyteidl2.core.SecretR\x0csecretMounts\"\xc6\x05\n\x05Layer\x12H\n\x0c\x61pt_packages\x18\x01 \x01(\x0b\x32#.flyteidl2.imagebuilder.AptPackagesH\x00R\x0b\x61ptPackages\x12H\n\x0cpip_packages\x18\x02 \x01(\x0b\x32#.flyteidl2.imagebuilder.PipPackagesH\x00R\x0bpipPackages\x12>\n\x08\x63ommands\x18\x03 \x01(\x0b\x32 .flyteidl2.imagebuilder.CommandsH\x00R\x08\x63ommands\x12J\n\x0crequirements\x18\x04 \x01(\x0b\x32$.flyteidl2.imagebuilder.RequirementsH\x00R\x0crequirements\x12K\n\rpython_wheels\x18\x05 \x01(\x0b\x32$.flyteidl2.imagebuilder.PythonWheelsH\x00R\x0cpythonWheels\x12;\n\x07workdir\x18\x06 \x01(\x0b\x32\x1f.flyteidl2.imagebuilder.WorkDirH\x00R\x07workdir\x12\x45\n\x0b\x63opy_config\x18\x07 \x01(\x0b\x32\".flyteidl2.imagebuilder.CopyConfigH\x00R\ncopyConfig\x12\x42\n\nuv_project\x18\x08 \x01(\x0b\x32!.flyteidl2.imagebuilder.UVProjectH\x00R\tuvProject\x12/\n\x03\x65nv\x18\t \x01(\x0b\x32\x1b.flyteidl2.imagebuilder.EnvH\x00R\x03\x65nv\x12N\n\x0epoetry_project\x18\n \x01(\x0b\x32%.flyteidl2.imagebuilder.PoetryProjectH\x00R\rpoetryProjectB\x07\n\x05layer\"\xa4\x01\n\tImageSpec\x12\x1d\n\nbase_image\x18\x01 \x01(\tR\tbaseImage\x12%\n\x0epython_version\x18\x02 \x01(\tR\rpythonVersion\x12\x35\n\x06layers\x18\x03 \x03(\x0b\x32\x1d.flyteidl2.imagebuilder.LayerR\x06layers\x12\x1a\n\x08platform\x18\x04 \x03(\tR\x08platformB\xe4\x01\n\x1a\x63om.flyteidl2.imagebuilderB\x0f\x44\x65\x66initionProtoH\x02P\x01Z:github.com/flyteorg/flyte/v2/gen/go/flyteidl2/imagebuilder\xa2\x02\x03\x46IX\xaa\x02\x16\x46lyteidl2.Imagebuilder\xca\x02\x16\x46lyteidl2\\Imagebuilder\xe2\x02\"Flyteidl2\\Imagebuilder\\GPBMetadata\xea\x02\x17\x46lyteidl2::Imagebuilderb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.imagebuilder.definition_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\032com.flyteidl2.imagebuilderB\017DefinitionProtoH\002P\001Z:github.com/flyteorg/flyte/v2/gen/go/flyteidl2/imagebuilder\242\002\003FIX\252\002\026Flyteidl2.Imagebuilder\312\002\026Flyteidl2\\Imagebuilder\342\002\"Flyteidl2\\Imagebuilder\\GPBMetadata\352\002\027Flyteidl2::Imagebuilder' + _IMAGEIDENTIFIER.fields_by_name['name']._options = None + _IMAGEIDENTIFIER.fields_by_name['name']._serialized_options = b'\272H\004r\002\020\001' + _ENV_ENVVARIABLESENTRY._options = None + _ENV_ENVVARIABLESENTRY._serialized_options = b'8\001' + _globals['_IMAGEIDENTIFIER']._serialized_start=127 + _globals['_IMAGEIDENTIFIER']._serialized_end=173 + _globals['_IMAGE']._serialized_start=175 + _globals['_IMAGE']._serialized_end=259 + _globals['_APTPACKAGES']._serialized_start=261 + _globals['_APTPACKAGES']._serialized_end=363 + _globals['_PIPOPTIONS']._serialized_start=366 + _globals['_PIPOPTIONS']._serialized_end=498 + _globals['_PIPPACKAGES']._serialized_start=501 + _globals['_PIPPACKAGES']._serialized_end=665 + _globals['_REQUIREMENTS']._serialized_start=668 + _globals['_REQUIREMENTS']._serialized_end=825 + _globals['_PYTHONWHEELS']._serialized_start=828 + _globals['_PYTHONWHEELS']._serialized_end=983 + _globals['_UVPROJECT']._serialized_start=986 + _globals['_UVPROJECT']._serialized_end=1174 + _globals['_COMMANDS']._serialized_start=1176 + _globals['_COMMANDS']._serialized_end=1265 + _globals['_WORKDIR']._serialized_start=1267 + _globals['_WORKDIR']._serialized_end=1302 + _globals['_COPYCONFIG']._serialized_start=1304 + _globals['_COPYCONFIG']._serialized_end=1352 + _globals['_ENV']._serialized_start=1355 + _globals['_ENV']._serialized_end=1509 + _globals['_ENV_ENVVARIABLESENTRY']._serialized_start=1446 + _globals['_ENV_ENVVARIABLESENTRY']._serialized_end=1509 + _globals['_POETRYPROJECT']._serialized_start=1512 + _globals['_POETRYPROJECT']._serialized_end=1682 + _globals['_LAYER']._serialized_start=1685 + _globals['_LAYER']._serialized_end=2395 + _globals['_IMAGESPEC']._serialized_start=2398 + _globals['_IMAGESPEC']._serialized_end=2562 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/imagebuilder/definition_pb2.pyi b/gen/python/flyteidl2/imagebuilder/definition_pb2.pyi new file mode 100644 index 0000000000..bf78c98adb --- /dev/null +++ b/gen/python/flyteidl2/imagebuilder/definition_pb2.pyi @@ -0,0 +1,167 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.core import security_pb2 as _security_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class ImageIdentifier(_message.Message): + __slots__ = ["name"] + NAME_FIELD_NUMBER: _ClassVar[int] + name: str + def __init__(self, name: _Optional[str] = ...) -> None: ... + +class Image(_message.Message): + __slots__ = ["id", "fqin"] + ID_FIELD_NUMBER: _ClassVar[int] + FQIN_FIELD_NUMBER: _ClassVar[int] + id: ImageIdentifier + fqin: str + def __init__(self, id: _Optional[_Union[ImageIdentifier, _Mapping]] = ..., fqin: _Optional[str] = ...) -> None: ... + +class AptPackages(_message.Message): + __slots__ = ["packages", "secret_mounts"] + PACKAGES_FIELD_NUMBER: _ClassVar[int] + SECRET_MOUNTS_FIELD_NUMBER: _ClassVar[int] + packages: _containers.RepeatedScalarFieldContainer[str] + secret_mounts: _containers.RepeatedCompositeFieldContainer[_security_pb2.Secret] + def __init__(self, packages: _Optional[_Iterable[str]] = ..., secret_mounts: _Optional[_Iterable[_Union[_security_pb2.Secret, _Mapping]]] = ...) -> None: ... + +class PipOptions(_message.Message): + __slots__ = ["index_url", "extra_index_urls", "pre", "extra_args"] + INDEX_URL_FIELD_NUMBER: _ClassVar[int] + EXTRA_INDEX_URLS_FIELD_NUMBER: _ClassVar[int] + PRE_FIELD_NUMBER: _ClassVar[int] + EXTRA_ARGS_FIELD_NUMBER: _ClassVar[int] + index_url: str + extra_index_urls: _containers.RepeatedScalarFieldContainer[str] + pre: bool + extra_args: str + def __init__(self, index_url: _Optional[str] = ..., extra_index_urls: _Optional[_Iterable[str]] = ..., pre: bool = ..., extra_args: _Optional[str] = ...) -> None: ... + +class PipPackages(_message.Message): + __slots__ = ["packages", "options", "secret_mounts"] + PACKAGES_FIELD_NUMBER: _ClassVar[int] + OPTIONS_FIELD_NUMBER: _ClassVar[int] + SECRET_MOUNTS_FIELD_NUMBER: _ClassVar[int] + packages: _containers.RepeatedScalarFieldContainer[str] + options: PipOptions + secret_mounts: _containers.RepeatedCompositeFieldContainer[_security_pb2.Secret] + def __init__(self, packages: _Optional[_Iterable[str]] = ..., options: _Optional[_Union[PipOptions, _Mapping]] = ..., secret_mounts: _Optional[_Iterable[_Union[_security_pb2.Secret, _Mapping]]] = ...) -> None: ... + +class Requirements(_message.Message): + __slots__ = ["file", "options", "secret_mounts"] + FILE_FIELD_NUMBER: _ClassVar[int] + OPTIONS_FIELD_NUMBER: _ClassVar[int] + SECRET_MOUNTS_FIELD_NUMBER: _ClassVar[int] + file: str + options: PipOptions + secret_mounts: _containers.RepeatedCompositeFieldContainer[_security_pb2.Secret] + def __init__(self, file: _Optional[str] = ..., options: _Optional[_Union[PipOptions, _Mapping]] = ..., secret_mounts: _Optional[_Iterable[_Union[_security_pb2.Secret, _Mapping]]] = ...) -> None: ... + +class PythonWheels(_message.Message): + __slots__ = ["dir", "options", "secret_mounts"] + DIR_FIELD_NUMBER: _ClassVar[int] + OPTIONS_FIELD_NUMBER: _ClassVar[int] + SECRET_MOUNTS_FIELD_NUMBER: _ClassVar[int] + dir: str + options: PipOptions + secret_mounts: _containers.RepeatedCompositeFieldContainer[_security_pb2.Secret] + def __init__(self, dir: _Optional[str] = ..., options: _Optional[_Union[PipOptions, _Mapping]] = ..., secret_mounts: _Optional[_Iterable[_Union[_security_pb2.Secret, _Mapping]]] = ...) -> None: ... + +class UVProject(_message.Message): + __slots__ = ["pyproject", "uvlock", "options", "secret_mounts"] + PYPROJECT_FIELD_NUMBER: _ClassVar[int] + UVLOCK_FIELD_NUMBER: _ClassVar[int] + OPTIONS_FIELD_NUMBER: _ClassVar[int] + SECRET_MOUNTS_FIELD_NUMBER: _ClassVar[int] + pyproject: str + uvlock: str + options: PipOptions + secret_mounts: _containers.RepeatedCompositeFieldContainer[_security_pb2.Secret] + def __init__(self, pyproject: _Optional[str] = ..., uvlock: _Optional[str] = ..., options: _Optional[_Union[PipOptions, _Mapping]] = ..., secret_mounts: _Optional[_Iterable[_Union[_security_pb2.Secret, _Mapping]]] = ...) -> None: ... + +class Commands(_message.Message): + __slots__ = ["cmd", "secret_mounts"] + CMD_FIELD_NUMBER: _ClassVar[int] + SECRET_MOUNTS_FIELD_NUMBER: _ClassVar[int] + cmd: _containers.RepeatedScalarFieldContainer[str] + secret_mounts: _containers.RepeatedCompositeFieldContainer[_security_pb2.Secret] + def __init__(self, cmd: _Optional[_Iterable[str]] = ..., secret_mounts: _Optional[_Iterable[_Union[_security_pb2.Secret, _Mapping]]] = ...) -> None: ... + +class WorkDir(_message.Message): + __slots__ = ["workdir"] + WORKDIR_FIELD_NUMBER: _ClassVar[int] + workdir: str + def __init__(self, workdir: _Optional[str] = ...) -> None: ... + +class CopyConfig(_message.Message): + __slots__ = ["src", "dst"] + SRC_FIELD_NUMBER: _ClassVar[int] + DST_FIELD_NUMBER: _ClassVar[int] + src: str + dst: str + def __init__(self, src: _Optional[str] = ..., dst: _Optional[str] = ...) -> None: ... + +class Env(_message.Message): + __slots__ = ["env_variables"] + class EnvVariablesEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + ENV_VARIABLES_FIELD_NUMBER: _ClassVar[int] + env_variables: _containers.ScalarMap[str, str] + def __init__(self, env_variables: _Optional[_Mapping[str, str]] = ...) -> None: ... + +class PoetryProject(_message.Message): + __slots__ = ["pyproject", "poetry_lock", "extra_args", "secret_mounts"] + PYPROJECT_FIELD_NUMBER: _ClassVar[int] + POETRY_LOCK_FIELD_NUMBER: _ClassVar[int] + EXTRA_ARGS_FIELD_NUMBER: _ClassVar[int] + SECRET_MOUNTS_FIELD_NUMBER: _ClassVar[int] + pyproject: str + poetry_lock: str + extra_args: str + secret_mounts: _containers.RepeatedCompositeFieldContainer[_security_pb2.Secret] + def __init__(self, pyproject: _Optional[str] = ..., poetry_lock: _Optional[str] = ..., extra_args: _Optional[str] = ..., secret_mounts: _Optional[_Iterable[_Union[_security_pb2.Secret, _Mapping]]] = ...) -> None: ... + +class Layer(_message.Message): + __slots__ = ["apt_packages", "pip_packages", "commands", "requirements", "python_wheels", "workdir", "copy_config", "uv_project", "env", "poetry_project"] + APT_PACKAGES_FIELD_NUMBER: _ClassVar[int] + PIP_PACKAGES_FIELD_NUMBER: _ClassVar[int] + COMMANDS_FIELD_NUMBER: _ClassVar[int] + REQUIREMENTS_FIELD_NUMBER: _ClassVar[int] + PYTHON_WHEELS_FIELD_NUMBER: _ClassVar[int] + WORKDIR_FIELD_NUMBER: _ClassVar[int] + COPY_CONFIG_FIELD_NUMBER: _ClassVar[int] + UV_PROJECT_FIELD_NUMBER: _ClassVar[int] + ENV_FIELD_NUMBER: _ClassVar[int] + POETRY_PROJECT_FIELD_NUMBER: _ClassVar[int] + apt_packages: AptPackages + pip_packages: PipPackages + commands: Commands + requirements: Requirements + python_wheels: PythonWheels + workdir: WorkDir + copy_config: CopyConfig + uv_project: UVProject + env: Env + poetry_project: PoetryProject + def __init__(self, apt_packages: _Optional[_Union[AptPackages, _Mapping]] = ..., pip_packages: _Optional[_Union[PipPackages, _Mapping]] = ..., commands: _Optional[_Union[Commands, _Mapping]] = ..., requirements: _Optional[_Union[Requirements, _Mapping]] = ..., python_wheels: _Optional[_Union[PythonWheels, _Mapping]] = ..., workdir: _Optional[_Union[WorkDir, _Mapping]] = ..., copy_config: _Optional[_Union[CopyConfig, _Mapping]] = ..., uv_project: _Optional[_Union[UVProject, _Mapping]] = ..., env: _Optional[_Union[Env, _Mapping]] = ..., poetry_project: _Optional[_Union[PoetryProject, _Mapping]] = ...) -> None: ... + +class ImageSpec(_message.Message): + __slots__ = ["base_image", "python_version", "layers", "platform"] + BASE_IMAGE_FIELD_NUMBER: _ClassVar[int] + PYTHON_VERSION_FIELD_NUMBER: _ClassVar[int] + LAYERS_FIELD_NUMBER: _ClassVar[int] + PLATFORM_FIELD_NUMBER: _ClassVar[int] + base_image: str + python_version: str + layers: _containers.RepeatedCompositeFieldContainer[Layer] + platform: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, base_image: _Optional[str] = ..., python_version: _Optional[str] = ..., layers: _Optional[_Iterable[_Union[Layer, _Mapping]]] = ..., platform: _Optional[_Iterable[str]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/imagebuilder/definition_pb2_grpc.py b/gen/python/flyteidl2/imagebuilder/definition_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/imagebuilder/definition_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/imagebuilder/payload_pb2.py b/gen/python/flyteidl2/imagebuilder/payload_pb2.py new file mode 100644 index 0000000000..74e192eff5 --- /dev/null +++ b/gen/python/flyteidl2/imagebuilder/payload_pb2.py @@ -0,0 +1,35 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/imagebuilder/payload.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.common import identifier_pb2 as flyteidl2_dot_common_dot_identifier__pb2 +from flyteidl2.imagebuilder import definition_pb2 as flyteidl2_dot_imagebuilder_dot_definition__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n$flyteidl2/imagebuilder/payload.proto\x12\x16\x66lyteidl2.imagebuilder\x1a\x1b\x62uf/validate/validate.proto\x1a!flyteidl2/common/identifier.proto\x1a\'flyteidl2/imagebuilder/definition.proto\"\xbe\x01\n\x0fGetImageRequest\x12?\n\x02id\x18\x01 \x01(\x0b\x32\'.flyteidl2.imagebuilder.ImageIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x02id\x12&\n\x0corganization\x18\x02 \x01(\tB\x02\x18\x01R\x0corganization\x12\x42\n\nproject_id\x18\x03 \x01(\x0b\x32#.flyteidl2.common.ProjectIdentifierR\tprojectId\"G\n\x10GetImageResponse\x12\x33\n\x05image\x18\x01 \x01(\x0b\x32\x1d.flyteidl2.imagebuilder.ImageR\x05imageB\xe1\x01\n\x1a\x63om.flyteidl2.imagebuilderB\x0cPayloadProtoH\x02P\x01Z:github.com/flyteorg/flyte/v2/gen/go/flyteidl2/imagebuilder\xa2\x02\x03\x46IX\xaa\x02\x16\x46lyteidl2.Imagebuilder\xca\x02\x16\x46lyteidl2\\Imagebuilder\xe2\x02\"Flyteidl2\\Imagebuilder\\GPBMetadata\xea\x02\x17\x46lyteidl2::Imagebuilderb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.imagebuilder.payload_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\032com.flyteidl2.imagebuilderB\014PayloadProtoH\002P\001Z:github.com/flyteorg/flyte/v2/gen/go/flyteidl2/imagebuilder\242\002\003FIX\252\002\026Flyteidl2.Imagebuilder\312\002\026Flyteidl2\\Imagebuilder\342\002\"Flyteidl2\\Imagebuilder\\GPBMetadata\352\002\027Flyteidl2::Imagebuilder' + _GETIMAGEREQUEST.fields_by_name['id']._options = None + _GETIMAGEREQUEST.fields_by_name['id']._serialized_options = b'\272H\003\310\001\001' + _GETIMAGEREQUEST.fields_by_name['organization']._options = None + _GETIMAGEREQUEST.fields_by_name['organization']._serialized_options = b'\030\001' + _globals['_GETIMAGEREQUEST']._serialized_start=170 + _globals['_GETIMAGEREQUEST']._serialized_end=360 + _globals['_GETIMAGERESPONSE']._serialized_start=362 + _globals['_GETIMAGERESPONSE']._serialized_end=433 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/imagebuilder/payload_pb2.pyi b/gen/python/flyteidl2/imagebuilder/payload_pb2.pyi new file mode 100644 index 0000000000..b0ee5c2fa5 --- /dev/null +++ b/gen/python/flyteidl2/imagebuilder/payload_pb2.pyi @@ -0,0 +1,24 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.common import identifier_pb2 as _identifier_pb2 +from flyteidl2.imagebuilder import definition_pb2 as _definition_pb2 +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class GetImageRequest(_message.Message): + __slots__ = ["id", "organization", "project_id"] + ID_FIELD_NUMBER: _ClassVar[int] + ORGANIZATION_FIELD_NUMBER: _ClassVar[int] + PROJECT_ID_FIELD_NUMBER: _ClassVar[int] + id: _definition_pb2.ImageIdentifier + organization: str + project_id: _identifier_pb2.ProjectIdentifier + def __init__(self, id: _Optional[_Union[_definition_pb2.ImageIdentifier, _Mapping]] = ..., organization: _Optional[str] = ..., project_id: _Optional[_Union[_identifier_pb2.ProjectIdentifier, _Mapping]] = ...) -> None: ... + +class GetImageResponse(_message.Message): + __slots__ = ["image"] + IMAGE_FIELD_NUMBER: _ClassVar[int] + image: _definition_pb2.Image + def __init__(self, image: _Optional[_Union[_definition_pb2.Image, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/imagebuilder/payload_pb2_grpc.py b/gen/python/flyteidl2/imagebuilder/payload_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/imagebuilder/payload_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/imagebuilder/service_pb2.py b/gen/python/flyteidl2/imagebuilder/service_pb2.py new file mode 100644 index 0000000000..e9df07e748 --- /dev/null +++ b/gen/python/flyteidl2/imagebuilder/service_pb2.py @@ -0,0 +1,29 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/imagebuilder/service.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.imagebuilder import payload_pb2 as flyteidl2_dot_imagebuilder_dot_payload__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n$flyteidl2/imagebuilder/service.proto\x12\x16\x66lyteidl2.imagebuilder\x1a$flyteidl2/imagebuilder/payload.proto2r\n\x0cImageService\x12\x62\n\x08GetImage\x12\'.flyteidl2.imagebuilder.GetImageRequest\x1a(.flyteidl2.imagebuilder.GetImageResponse\"\x03\x90\x02\x01\x42\xe1\x01\n\x1a\x63om.flyteidl2.imagebuilderB\x0cServiceProtoH\x02P\x01Z:github.com/flyteorg/flyte/v2/gen/go/flyteidl2/imagebuilder\xa2\x02\x03\x46IX\xaa\x02\x16\x46lyteidl2.Imagebuilder\xca\x02\x16\x46lyteidl2\\Imagebuilder\xe2\x02\"Flyteidl2\\Imagebuilder\\GPBMetadata\xea\x02\x17\x46lyteidl2::Imagebuilderb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.imagebuilder.service_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\032com.flyteidl2.imagebuilderB\014ServiceProtoH\002P\001Z:github.com/flyteorg/flyte/v2/gen/go/flyteidl2/imagebuilder\242\002\003FIX\252\002\026Flyteidl2.Imagebuilder\312\002\026Flyteidl2\\Imagebuilder\342\002\"Flyteidl2\\Imagebuilder\\GPBMetadata\352\002\027Flyteidl2::Imagebuilder' + _IMAGESERVICE.methods_by_name['GetImage']._options = None + _IMAGESERVICE.methods_by_name['GetImage']._serialized_options = b'\220\002\001' + _globals['_IMAGESERVICE']._serialized_start=102 + _globals['_IMAGESERVICE']._serialized_end=216 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/imagebuilder/service_pb2.pyi b/gen/python/flyteidl2/imagebuilder/service_pb2.pyi new file mode 100644 index 0000000000..9d65b7aebb --- /dev/null +++ b/gen/python/flyteidl2/imagebuilder/service_pb2.pyi @@ -0,0 +1,5 @@ +from flyteidl2.imagebuilder import payload_pb2 as _payload_pb2 +from google.protobuf import descriptor as _descriptor +from typing import ClassVar as _ClassVar + +DESCRIPTOR: _descriptor.FileDescriptor diff --git a/gen/python/flyteidl2/imagebuilder/service_pb2_grpc.py b/gen/python/flyteidl2/imagebuilder/service_pb2_grpc.py new file mode 100644 index 0000000000..369adb257e --- /dev/null +++ b/gen/python/flyteidl2/imagebuilder/service_pb2_grpc.py @@ -0,0 +1,66 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from flyteidl2.imagebuilder import payload_pb2 as flyteidl2_dot_imagebuilder_dot_payload__pb2 + + +class ImageServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.GetImage = channel.unary_unary( + '/flyteidl2.imagebuilder.ImageService/GetImage', + request_serializer=flyteidl2_dot_imagebuilder_dot_payload__pb2.GetImageRequest.SerializeToString, + response_deserializer=flyteidl2_dot_imagebuilder_dot_payload__pb2.GetImageResponse.FromString, + ) + + +class ImageServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def GetImage(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_ImageServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'GetImage': grpc.unary_unary_rpc_method_handler( + servicer.GetImage, + request_deserializer=flyteidl2_dot_imagebuilder_dot_payload__pb2.GetImageRequest.FromString, + response_serializer=flyteidl2_dot_imagebuilder_dot_payload__pb2.GetImageResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.imagebuilder.ImageService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class ImageService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def GetImage(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.imagebuilder.ImageService/GetImage', + flyteidl2_dot_imagebuilder_dot_payload__pb2.GetImageRequest.SerializeToString, + flyteidl2_dot_imagebuilder_dot_payload__pb2.GetImageResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/gen/python/flyteidl2/logs/__init__.py b/gen/python/flyteidl2/logs/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/logs/dataplane/__init__.py b/gen/python/flyteidl2/logs/dataplane/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/logs/dataplane/payload_pb2.py b/gen/python/flyteidl2/logs/dataplane/payload_pb2.py new file mode 100644 index 0000000000..e9d0804c22 --- /dev/null +++ b/gen/python/flyteidl2/logs/dataplane/payload_pb2.py @@ -0,0 +1,78 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/logs/dataplane/payload.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n&flyteidl2/logs/dataplane/payload.proto\x12\x18\x66lyteidl2.logs.dataplane\x1a\x1b\x62uf/validate/validate.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"o\n\x0bPodResource\x12%\n\tnamespace\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\tnamespace\x12\x1b\n\x04name\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x04name\x12\x1c\n\tcontainer\x18\x03 \x01(\tR\tcontainer\"\xf7\x04\n\x0eLoggingContext\x12*\n\x0c\x63luster_name\x18\x03 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x0b\x63lusterName\x12:\n\x14kubernetes_namespace\x18\x04 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x13kubernetesNamespace\x12\x37\n\x13kubernetes_pod_name\x18\x05 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x11kubernetesPodName\x12\x43\n\x19kubernetes_container_name\x18\x06 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x17kubernetesContainerName\x12[\n\x1c\x65xecution_attempt_start_time\x18\x07 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x19\x65xecutionAttemptStartTime\x12W\n\x1a\x65xecution_attempt_end_time\x18\x08 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x17\x65xecutionAttemptEndTime\x12u\n\x15kubernetes_pod_labels\x18\t \x03(\x0b\x32\x41.flyteidl2.logs.dataplane.LoggingContext.KubernetesPodLabelsEntryR\x13kubernetesPodLabels\x1a\x46\n\x18KubernetesPodLabelsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01J\x04\x08\x01\x10\x02J\x04\x08\x02\x10\x03\"\xf2\x01\n\x13\x43ontainerIdentifier\x12*\n\x0c\x63luster_name\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x0b\x63lusterName\x12:\n\x14kubernetes_namespace\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x13kubernetesNamespace\x12\x37\n\x13kubernetes_pod_name\x18\x03 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x11kubernetesPodName\x12:\n\x19kubernetes_container_name\x18\x04 \x01(\tR\x17kubernetesContainerName\"\xb7\x02\n\x11\x43ontainerSelector\x12*\n\x0c\x63luster_name\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x0b\x63lusterName\x12:\n\x14kubernetes_namespace\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x13kubernetesNamespace\x12;\n\x1akubernetes_pod_name_prefix\x18\x03 \x01(\tR\x17kubernetesPodNamePrefix\x12:\n\x19kubernetes_container_name\x18\x04 \x01(\tR\x17kubernetesContainerName\x12\x41\n\x1dkubernetes_pod_label_selector\x18\x05 \x01(\tR\x1akubernetesPodLabelSelector\"^\n\x0fLiveLogsOptions\x12$\n\x0elog_pod_status\x18\x01 \x01(\x08R\x0clogPodStatus\x12%\n\x0elog_timestamps\x18\x02 \x01(\x08R\rlogTimestamps\"\xaa\x01\n\x07LogLine\x12\x38\n\ttimestamp\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\ttimestamp\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\x12K\n\noriginator\x18\x03 \x01(\x0e\x32+.flyteidl2.logs.dataplane.LogLineOriginatorR\noriginator\"\xf0\x01\n\x08LogLines\x12\x18\n\x05lines\x18\x01 \x03(\tB\x02\x18\x01R\x05lines\x12\'\n\x0f\x63ontainer_index\x18\x02 \x01(\rR\x0e\x63ontainerIndex\x12S\n\tcontainer\x18\x03 \x01(\x0b\x32-.flyteidl2.logs.dataplane.ContainerIdentifierB\x06\xbaH\x03\xc8\x01\x01R\tcontainer\x12L\n\x10structured_lines\x18\x04 \x03(\x0b\x32!.flyteidl2.logs.dataplane.LogLineR\x0fstructuredLines\"b\n\x11LogContainersList\x12M\n\ncontainers\x18\x01 \x03(\x0b\x32-.flyteidl2.logs.dataplane.ContainerIdentifierR\ncontainers\"G\n\rLogLinesBatch\x12\x36\n\x04logs\x18\x01 \x03(\x0b\x32\".flyteidl2.logs.dataplane.LogLinesR\x04logs*6\n\x11LogLineOriginator\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x08\n\x04USER\x10\x01\x12\n\n\x06SYSTEM\x10\x02*F\n\nLogsSource\x12\x15\n\x11LIVE_OR_PERSISTED\x10\x00\x12\r\n\tLIVE_ONLY\x10\x01\x12\x12\n\x0ePERSISTED_ONLY\x10\x02\x42\xee\x01\n\x1c\x63om.flyteidl2.logs.dataplaneB\x0cPayloadProtoH\x02P\x01Z None: ... + +class LoggingContext(_message.Message): + __slots__ = ["cluster_name", "kubernetes_namespace", "kubernetes_pod_name", "kubernetes_container_name", "execution_attempt_start_time", "execution_attempt_end_time", "kubernetes_pod_labels"] + class KubernetesPodLabelsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + CLUSTER_NAME_FIELD_NUMBER: _ClassVar[int] + KUBERNETES_NAMESPACE_FIELD_NUMBER: _ClassVar[int] + KUBERNETES_POD_NAME_FIELD_NUMBER: _ClassVar[int] + KUBERNETES_CONTAINER_NAME_FIELD_NUMBER: _ClassVar[int] + EXECUTION_ATTEMPT_START_TIME_FIELD_NUMBER: _ClassVar[int] + EXECUTION_ATTEMPT_END_TIME_FIELD_NUMBER: _ClassVar[int] + KUBERNETES_POD_LABELS_FIELD_NUMBER: _ClassVar[int] + cluster_name: str + kubernetes_namespace: str + kubernetes_pod_name: str + kubernetes_container_name: str + execution_attempt_start_time: _timestamp_pb2.Timestamp + execution_attempt_end_time: _timestamp_pb2.Timestamp + kubernetes_pod_labels: _containers.ScalarMap[str, str] + def __init__(self, cluster_name: _Optional[str] = ..., kubernetes_namespace: _Optional[str] = ..., kubernetes_pod_name: _Optional[str] = ..., kubernetes_container_name: _Optional[str] = ..., execution_attempt_start_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., execution_attempt_end_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., kubernetes_pod_labels: _Optional[_Mapping[str, str]] = ...) -> None: ... + +class ContainerIdentifier(_message.Message): + __slots__ = ["cluster_name", "kubernetes_namespace", "kubernetes_pod_name", "kubernetes_container_name"] + CLUSTER_NAME_FIELD_NUMBER: _ClassVar[int] + KUBERNETES_NAMESPACE_FIELD_NUMBER: _ClassVar[int] + KUBERNETES_POD_NAME_FIELD_NUMBER: _ClassVar[int] + KUBERNETES_CONTAINER_NAME_FIELD_NUMBER: _ClassVar[int] + cluster_name: str + kubernetes_namespace: str + kubernetes_pod_name: str + kubernetes_container_name: str + def __init__(self, cluster_name: _Optional[str] = ..., kubernetes_namespace: _Optional[str] = ..., kubernetes_pod_name: _Optional[str] = ..., kubernetes_container_name: _Optional[str] = ...) -> None: ... + +class ContainerSelector(_message.Message): + __slots__ = ["cluster_name", "kubernetes_namespace", "kubernetes_pod_name_prefix", "kubernetes_container_name", "kubernetes_pod_label_selector"] + CLUSTER_NAME_FIELD_NUMBER: _ClassVar[int] + KUBERNETES_NAMESPACE_FIELD_NUMBER: _ClassVar[int] + KUBERNETES_POD_NAME_PREFIX_FIELD_NUMBER: _ClassVar[int] + KUBERNETES_CONTAINER_NAME_FIELD_NUMBER: _ClassVar[int] + KUBERNETES_POD_LABEL_SELECTOR_FIELD_NUMBER: _ClassVar[int] + cluster_name: str + kubernetes_namespace: str + kubernetes_pod_name_prefix: str + kubernetes_container_name: str + kubernetes_pod_label_selector: str + def __init__(self, cluster_name: _Optional[str] = ..., kubernetes_namespace: _Optional[str] = ..., kubernetes_pod_name_prefix: _Optional[str] = ..., kubernetes_container_name: _Optional[str] = ..., kubernetes_pod_label_selector: _Optional[str] = ...) -> None: ... + +class LiveLogsOptions(_message.Message): + __slots__ = ["log_pod_status", "log_timestamps"] + LOG_POD_STATUS_FIELD_NUMBER: _ClassVar[int] + LOG_TIMESTAMPS_FIELD_NUMBER: _ClassVar[int] + log_pod_status: bool + log_timestamps: bool + def __init__(self, log_pod_status: bool = ..., log_timestamps: bool = ...) -> None: ... + +class LogLine(_message.Message): + __slots__ = ["timestamp", "message", "originator"] + TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + MESSAGE_FIELD_NUMBER: _ClassVar[int] + ORIGINATOR_FIELD_NUMBER: _ClassVar[int] + timestamp: _timestamp_pb2.Timestamp + message: str + originator: LogLineOriginator + def __init__(self, timestamp: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., message: _Optional[str] = ..., originator: _Optional[_Union[LogLineOriginator, str]] = ...) -> None: ... + +class LogLines(_message.Message): + __slots__ = ["lines", "container_index", "container", "structured_lines"] + LINES_FIELD_NUMBER: _ClassVar[int] + CONTAINER_INDEX_FIELD_NUMBER: _ClassVar[int] + CONTAINER_FIELD_NUMBER: _ClassVar[int] + STRUCTURED_LINES_FIELD_NUMBER: _ClassVar[int] + lines: _containers.RepeatedScalarFieldContainer[str] + container_index: int + container: ContainerIdentifier + structured_lines: _containers.RepeatedCompositeFieldContainer[LogLine] + def __init__(self, lines: _Optional[_Iterable[str]] = ..., container_index: _Optional[int] = ..., container: _Optional[_Union[ContainerIdentifier, _Mapping]] = ..., structured_lines: _Optional[_Iterable[_Union[LogLine, _Mapping]]] = ...) -> None: ... + +class LogContainersList(_message.Message): + __slots__ = ["containers"] + CONTAINERS_FIELD_NUMBER: _ClassVar[int] + containers: _containers.RepeatedCompositeFieldContainer[ContainerIdentifier] + def __init__(self, containers: _Optional[_Iterable[_Union[ContainerIdentifier, _Mapping]]] = ...) -> None: ... + +class LogLinesBatch(_message.Message): + __slots__ = ["logs"] + LOGS_FIELD_NUMBER: _ClassVar[int] + logs: _containers.RepeatedCompositeFieldContainer[LogLines] + def __init__(self, logs: _Optional[_Iterable[_Union[LogLines, _Mapping]]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/logs/dataplane/payload_pb2_grpc.py b/gen/python/flyteidl2/logs/dataplane/payload_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/logs/dataplane/payload_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/plugins/__init__.py b/gen/python/flyteidl2/plugins/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/plugins/common_pb2.py b/gen/python/flyteidl2/plugins/common_pb2.py new file mode 100644 index 0000000000..ada9e0b1da --- /dev/null +++ b/gen/python/flyteidl2/plugins/common_pb2.py @@ -0,0 +1,29 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/plugins/common.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.core import tasks_pb2 as flyteidl2_dot_core_dot_tasks__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1e\x66lyteidl2/plugins/common.proto\x12\x11\x66lyteidl2.plugins\x1a\x1a\x66lyteidl2/core/tasks.proto\"\xc7\x01\n\x11\x43ommonReplicaSpec\x12\x1a\n\x08replicas\x18\x01 \x01(\x05R\x08replicas\x12\x14\n\x05image\x18\x02 \x01(\tR\x05image\x12\x37\n\tresources\x18\x03 \x01(\x0b\x32\x19.flyteidl2.core.ResourcesR\tresources\x12G\n\x0erestart_policy\x18\x04 \x01(\x0e\x32 .flyteidl2.plugins.RestartPolicyR\rrestartPolicy*c\n\rRestartPolicy\x12\x18\n\x14RESTART_POLICY_NEVER\x10\x00\x12\x1d\n\x19RESTART_POLICY_ON_FAILURE\x10\x01\x12\x19\n\x15RESTART_POLICY_ALWAYS\x10\x02\x42\xc2\x01\n\x15\x63om.flyteidl2.pluginsB\x0b\x43ommonProtoH\x02P\x01Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins\xa2\x02\x03\x46PX\xaa\x02\x11\x46lyteidl2.Plugins\xca\x02\x11\x46lyteidl2\\Plugins\xe2\x02\x1d\x46lyteidl2\\Plugins\\GPBMetadata\xea\x02\x12\x46lyteidl2::Pluginsb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.plugins.common_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\025com.flyteidl2.pluginsB\013CommonProtoH\002P\001Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins\242\002\003FPX\252\002\021Flyteidl2.Plugins\312\002\021Flyteidl2\\Plugins\342\002\035Flyteidl2\\Plugins\\GPBMetadata\352\002\022Flyteidl2::Plugins' + _globals['_RESTARTPOLICY']._serialized_start=283 + _globals['_RESTARTPOLICY']._serialized_end=382 + _globals['_COMMONREPLICASPEC']._serialized_start=82 + _globals['_COMMONREPLICASPEC']._serialized_end=281 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/plugins/common_pb2.pyi b/gen/python/flyteidl2/plugins/common_pb2.pyi new file mode 100644 index 0000000000..b33b9d6d8b --- /dev/null +++ b/gen/python/flyteidl2/plugins/common_pb2.pyi @@ -0,0 +1,28 @@ +from flyteidl2.core import tasks_pb2 as _tasks_pb2 +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class RestartPolicy(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + RESTART_POLICY_NEVER: _ClassVar[RestartPolicy] + RESTART_POLICY_ON_FAILURE: _ClassVar[RestartPolicy] + RESTART_POLICY_ALWAYS: _ClassVar[RestartPolicy] +RESTART_POLICY_NEVER: RestartPolicy +RESTART_POLICY_ON_FAILURE: RestartPolicy +RESTART_POLICY_ALWAYS: RestartPolicy + +class CommonReplicaSpec(_message.Message): + __slots__ = ["replicas", "image", "resources", "restart_policy"] + REPLICAS_FIELD_NUMBER: _ClassVar[int] + IMAGE_FIELD_NUMBER: _ClassVar[int] + RESOURCES_FIELD_NUMBER: _ClassVar[int] + RESTART_POLICY_FIELD_NUMBER: _ClassVar[int] + replicas: int + image: str + resources: _tasks_pb2.Resources + restart_policy: RestartPolicy + def __init__(self, replicas: _Optional[int] = ..., image: _Optional[str] = ..., resources: _Optional[_Union[_tasks_pb2.Resources, _Mapping]] = ..., restart_policy: _Optional[_Union[RestartPolicy, str]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/plugins/common_pb2_grpc.py b/gen/python/flyteidl2/plugins/common_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/plugins/common_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/plugins/dask_pb2.py b/gen/python/flyteidl2/plugins/dask_pb2.py new file mode 100644 index 0000000000..043bedc9f4 --- /dev/null +++ b/gen/python/flyteidl2/plugins/dask_pb2.py @@ -0,0 +1,31 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/plugins/dask.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.core import tasks_pb2 as flyteidl2_dot_core_dot_tasks__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1c\x66lyteidl2/plugins/dask.proto\x12\x11\x66lyteidl2.plugins\x1a\x1a\x66lyteidl2/core/tasks.proto\"\x87\x01\n\x07\x44\x61skJob\x12>\n\tscheduler\x18\x01 \x01(\x0b\x32 .flyteidl2.plugins.DaskSchedulerR\tscheduler\x12<\n\x07workers\x18\x02 \x01(\x0b\x32\".flyteidl2.plugins.DaskWorkerGroupR\x07workers\"^\n\rDaskScheduler\x12\x14\n\x05image\x18\x01 \x01(\tR\x05image\x12\x37\n\tresources\x18\x02 \x01(\x0b\x32\x19.flyteidl2.core.ResourcesR\tresources\"\x8c\x01\n\x0f\x44\x61skWorkerGroup\x12*\n\x11number_of_workers\x18\x01 \x01(\rR\x0fnumberOfWorkers\x12\x14\n\x05image\x18\x02 \x01(\tR\x05image\x12\x37\n\tresources\x18\x03 \x01(\x0b\x32\x19.flyteidl2.core.ResourcesR\tresourcesB\xc0\x01\n\x15\x63om.flyteidl2.pluginsB\tDaskProtoH\x02P\x01Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins\xa2\x02\x03\x46PX\xaa\x02\x11\x46lyteidl2.Plugins\xca\x02\x11\x46lyteidl2\\Plugins\xe2\x02\x1d\x46lyteidl2\\Plugins\\GPBMetadata\xea\x02\x12\x46lyteidl2::Pluginsb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.plugins.dask_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\025com.flyteidl2.pluginsB\tDaskProtoH\002P\001Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins\242\002\003FPX\252\002\021Flyteidl2.Plugins\312\002\021Flyteidl2\\Plugins\342\002\035Flyteidl2\\Plugins\\GPBMetadata\352\002\022Flyteidl2::Plugins' + _globals['_DASKJOB']._serialized_start=80 + _globals['_DASKJOB']._serialized_end=215 + _globals['_DASKSCHEDULER']._serialized_start=217 + _globals['_DASKSCHEDULER']._serialized_end=311 + _globals['_DASKWORKERGROUP']._serialized_start=314 + _globals['_DASKWORKERGROUP']._serialized_end=454 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/plugins/dask_pb2.pyi b/gen/python/flyteidl2/plugins/dask_pb2.pyi new file mode 100644 index 0000000000..70c7d7aa16 --- /dev/null +++ b/gen/python/flyteidl2/plugins/dask_pb2.pyi @@ -0,0 +1,32 @@ +from flyteidl2.core import tasks_pb2 as _tasks_pb2 +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class DaskJob(_message.Message): + __slots__ = ["scheduler", "workers"] + SCHEDULER_FIELD_NUMBER: _ClassVar[int] + WORKERS_FIELD_NUMBER: _ClassVar[int] + scheduler: DaskScheduler + workers: DaskWorkerGroup + def __init__(self, scheduler: _Optional[_Union[DaskScheduler, _Mapping]] = ..., workers: _Optional[_Union[DaskWorkerGroup, _Mapping]] = ...) -> None: ... + +class DaskScheduler(_message.Message): + __slots__ = ["image", "resources"] + IMAGE_FIELD_NUMBER: _ClassVar[int] + RESOURCES_FIELD_NUMBER: _ClassVar[int] + image: str + resources: _tasks_pb2.Resources + def __init__(self, image: _Optional[str] = ..., resources: _Optional[_Union[_tasks_pb2.Resources, _Mapping]] = ...) -> None: ... + +class DaskWorkerGroup(_message.Message): + __slots__ = ["number_of_workers", "image", "resources"] + NUMBER_OF_WORKERS_FIELD_NUMBER: _ClassVar[int] + IMAGE_FIELD_NUMBER: _ClassVar[int] + RESOURCES_FIELD_NUMBER: _ClassVar[int] + number_of_workers: int + image: str + resources: _tasks_pb2.Resources + def __init__(self, number_of_workers: _Optional[int] = ..., image: _Optional[str] = ..., resources: _Optional[_Union[_tasks_pb2.Resources, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/plugins/dask_pb2_grpc.py b/gen/python/flyteidl2/plugins/dask_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/plugins/dask_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/plugins/kubeflow/__init__.py b/gen/python/flyteidl2/plugins/kubeflow/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/plugins/kubeflow/common_pb2.py b/gen/python/flyteidl2/plugins/kubeflow/common_pb2.py new file mode 100644 index 0000000000..d2448a5578 --- /dev/null +++ b/gen/python/flyteidl2/plugins/kubeflow/common_pb2.py @@ -0,0 +1,28 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/plugins/kubeflow/common.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\'flyteidl2/plugins/kubeflow/common.proto\x12\x1a\x66lyteidl2.plugins.kubeflow\"\xfb\x01\n\tRunPolicy\x12T\n\x10\x63lean_pod_policy\x18\x01 \x01(\x0e\x32*.flyteidl2.plugins.kubeflow.CleanPodPolicyR\x0e\x63leanPodPolicy\x12;\n\x1attl_seconds_after_finished\x18\x02 \x01(\x05R\x17ttlSecondsAfterFinished\x12\x36\n\x17\x61\x63tive_deadline_seconds\x18\x03 \x01(\x05R\x15\x61\x63tiveDeadlineSeconds\x12#\n\rbackoff_limit\x18\x04 \x01(\x05R\x0c\x62\x61\x63koffLimit*`\n\x0e\x43leanPodPolicy\x12\x18\n\x14\x43LEANPOD_POLICY_NONE\x10\x00\x12\x1b\n\x17\x43LEANPOD_POLICY_RUNNING\x10\x01\x12\x17\n\x13\x43LEANPOD_POLICY_ALL\x10\x02\x42\xf9\x01\n\x1e\x63om.flyteidl2.plugins.kubeflowB\x0b\x43ommonProtoH\x02P\x01Z>github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow\xa2\x02\x03\x46PK\xaa\x02\x1a\x46lyteidl2.Plugins.Kubeflow\xca\x02\x1a\x46lyteidl2\\Plugins\\Kubeflow\xe2\x02&Flyteidl2\\Plugins\\Kubeflow\\GPBMetadata\xea\x02\x1c\x46lyteidl2::Plugins::Kubeflowb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.plugins.kubeflow.common_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\036com.flyteidl2.plugins.kubeflowB\013CommonProtoH\002P\001Z>github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow\242\002\003FPK\252\002\032Flyteidl2.Plugins.Kubeflow\312\002\032Flyteidl2\\Plugins\\Kubeflow\342\002&Flyteidl2\\Plugins\\Kubeflow\\GPBMetadata\352\002\034Flyteidl2::Plugins::Kubeflow' + _globals['_CLEANPODPOLICY']._serialized_start=325 + _globals['_CLEANPODPOLICY']._serialized_end=421 + _globals['_RUNPOLICY']._serialized_start=72 + _globals['_RUNPOLICY']._serialized_end=323 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/plugins/kubeflow/common_pb2.pyi b/gen/python/flyteidl2/plugins/kubeflow/common_pb2.pyi new file mode 100644 index 0000000000..3052ab62bb --- /dev/null +++ b/gen/python/flyteidl2/plugins/kubeflow/common_pb2.pyi @@ -0,0 +1,27 @@ +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class CleanPodPolicy(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + CLEANPOD_POLICY_NONE: _ClassVar[CleanPodPolicy] + CLEANPOD_POLICY_RUNNING: _ClassVar[CleanPodPolicy] + CLEANPOD_POLICY_ALL: _ClassVar[CleanPodPolicy] +CLEANPOD_POLICY_NONE: CleanPodPolicy +CLEANPOD_POLICY_RUNNING: CleanPodPolicy +CLEANPOD_POLICY_ALL: CleanPodPolicy + +class RunPolicy(_message.Message): + __slots__ = ["clean_pod_policy", "ttl_seconds_after_finished", "active_deadline_seconds", "backoff_limit"] + CLEAN_POD_POLICY_FIELD_NUMBER: _ClassVar[int] + TTL_SECONDS_AFTER_FINISHED_FIELD_NUMBER: _ClassVar[int] + ACTIVE_DEADLINE_SECONDS_FIELD_NUMBER: _ClassVar[int] + BACKOFF_LIMIT_FIELD_NUMBER: _ClassVar[int] + clean_pod_policy: CleanPodPolicy + ttl_seconds_after_finished: int + active_deadline_seconds: int + backoff_limit: int + def __init__(self, clean_pod_policy: _Optional[_Union[CleanPodPolicy, str]] = ..., ttl_seconds_after_finished: _Optional[int] = ..., active_deadline_seconds: _Optional[int] = ..., backoff_limit: _Optional[int] = ...) -> None: ... diff --git a/gen/python/flyteidl2/plugins/kubeflow/common_pb2_grpc.py b/gen/python/flyteidl2/plugins/kubeflow/common_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/plugins/kubeflow/common_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/plugins/kubeflow/mpi_pb2.py b/gen/python/flyteidl2/plugins/kubeflow/mpi_pb2.py new file mode 100644 index 0000000000..c997fbd8d1 --- /dev/null +++ b/gen/python/flyteidl2/plugins/kubeflow/mpi_pb2.py @@ -0,0 +1,39 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/plugins/kubeflow/mpi.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.core import tasks_pb2 as flyteidl2_dot_core_dot_tasks__pb2 +from flyteidl2.plugins import common_pb2 as flyteidl2_dot_plugins_dot_common__pb2 +from flyteidl2.plugins.kubeflow import common_pb2 as flyteidl2_dot_plugins_dot_kubeflow_dot_common__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n$flyteidl2/plugins/kubeflow/mpi.proto\x12\x1a\x66lyteidl2.plugins.kubeflow\x1a\x1a\x66lyteidl2/core/tasks.proto\x1a\x1e\x66lyteidl2/plugins/common.proto\x1a\'flyteidl2/plugins/kubeflow/common.proto\"\xcc\x02\n\x1a\x44istributedMPITrainingTask\x12\x66\n\x0fworker_replicas\x18\x01 \x01(\x0b\x32=.flyteidl2.plugins.kubeflow.DistributedMPITrainingReplicaSpecR\x0eworkerReplicas\x12j\n\x11launcher_replicas\x18\x02 \x01(\x0b\x32=.flyteidl2.plugins.kubeflow.DistributedMPITrainingReplicaSpecR\x10launcherReplicas\x12\x44\n\nrun_policy\x18\x03 \x01(\x0b\x32%.flyteidl2.plugins.kubeflow.RunPolicyR\trunPolicy\x12\x14\n\x05slots\x18\x04 \x01(\x05R\x05slots\"\xbf\x02\n!DistributedMPITrainingReplicaSpec\x12\x1e\n\x08replicas\x18\x01 \x01(\x05\x42\x02\x18\x01R\x08replicas\x12\x18\n\x05image\x18\x02 \x01(\tB\x02\x18\x01R\x05image\x12;\n\tresources\x18\x03 \x01(\x0b\x32\x19.flyteidl2.core.ResourcesB\x02\x18\x01R\tresources\x12K\n\x0erestart_policy\x18\x04 \x01(\x0e\x32 .flyteidl2.plugins.RestartPolicyB\x02\x18\x01R\rrestartPolicy\x12\x18\n\x07\x63ommand\x18\x05 \x03(\tR\x07\x63ommand\x12<\n\x06\x63ommon\x18\x06 \x01(\x0b\x32$.flyteidl2.plugins.CommonReplicaSpecR\x06\x63ommonB\xf6\x01\n\x1e\x63om.flyteidl2.plugins.kubeflowB\x08MpiProtoH\x02P\x01Z>github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow\xa2\x02\x03\x46PK\xaa\x02\x1a\x46lyteidl2.Plugins.Kubeflow\xca\x02\x1a\x46lyteidl2\\Plugins\\Kubeflow\xe2\x02&Flyteidl2\\Plugins\\Kubeflow\\GPBMetadata\xea\x02\x1c\x46lyteidl2::Plugins::Kubeflowb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.plugins.kubeflow.mpi_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\036com.flyteidl2.plugins.kubeflowB\010MpiProtoH\002P\001Z>github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow\242\002\003FPK\252\002\032Flyteidl2.Plugins.Kubeflow\312\002\032Flyteidl2\\Plugins\\Kubeflow\342\002&Flyteidl2\\Plugins\\Kubeflow\\GPBMetadata\352\002\034Flyteidl2::Plugins::Kubeflow' + _DISTRIBUTEDMPITRAININGREPLICASPEC.fields_by_name['replicas']._options = None + _DISTRIBUTEDMPITRAININGREPLICASPEC.fields_by_name['replicas']._serialized_options = b'\030\001' + _DISTRIBUTEDMPITRAININGREPLICASPEC.fields_by_name['image']._options = None + _DISTRIBUTEDMPITRAININGREPLICASPEC.fields_by_name['image']._serialized_options = b'\030\001' + _DISTRIBUTEDMPITRAININGREPLICASPEC.fields_by_name['resources']._options = None + _DISTRIBUTEDMPITRAININGREPLICASPEC.fields_by_name['resources']._serialized_options = b'\030\001' + _DISTRIBUTEDMPITRAININGREPLICASPEC.fields_by_name['restart_policy']._options = None + _DISTRIBUTEDMPITRAININGREPLICASPEC.fields_by_name['restart_policy']._serialized_options = b'\030\001' + _globals['_DISTRIBUTEDMPITRAININGTASK']._serialized_start=170 + _globals['_DISTRIBUTEDMPITRAININGTASK']._serialized_end=502 + _globals['_DISTRIBUTEDMPITRAININGREPLICASPEC']._serialized_start=505 + _globals['_DISTRIBUTEDMPITRAININGREPLICASPEC']._serialized_end=824 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/plugins/kubeflow/mpi_pb2.pyi b/gen/python/flyteidl2/plugins/kubeflow/mpi_pb2.pyi new file mode 100644 index 0000000000..3978bd61e7 --- /dev/null +++ b/gen/python/flyteidl2/plugins/kubeflow/mpi_pb2.pyi @@ -0,0 +1,37 @@ +from flyteidl2.core import tasks_pb2 as _tasks_pb2 +from flyteidl2.plugins import common_pb2 as _common_pb2 +from flyteidl2.plugins.kubeflow import common_pb2 as _common_pb2_1 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class DistributedMPITrainingTask(_message.Message): + __slots__ = ["worker_replicas", "launcher_replicas", "run_policy", "slots"] + WORKER_REPLICAS_FIELD_NUMBER: _ClassVar[int] + LAUNCHER_REPLICAS_FIELD_NUMBER: _ClassVar[int] + RUN_POLICY_FIELD_NUMBER: _ClassVar[int] + SLOTS_FIELD_NUMBER: _ClassVar[int] + worker_replicas: DistributedMPITrainingReplicaSpec + launcher_replicas: DistributedMPITrainingReplicaSpec + run_policy: _common_pb2_1.RunPolicy + slots: int + def __init__(self, worker_replicas: _Optional[_Union[DistributedMPITrainingReplicaSpec, _Mapping]] = ..., launcher_replicas: _Optional[_Union[DistributedMPITrainingReplicaSpec, _Mapping]] = ..., run_policy: _Optional[_Union[_common_pb2_1.RunPolicy, _Mapping]] = ..., slots: _Optional[int] = ...) -> None: ... + +class DistributedMPITrainingReplicaSpec(_message.Message): + __slots__ = ["replicas", "image", "resources", "restart_policy", "command", "common"] + REPLICAS_FIELD_NUMBER: _ClassVar[int] + IMAGE_FIELD_NUMBER: _ClassVar[int] + RESOURCES_FIELD_NUMBER: _ClassVar[int] + RESTART_POLICY_FIELD_NUMBER: _ClassVar[int] + COMMAND_FIELD_NUMBER: _ClassVar[int] + COMMON_FIELD_NUMBER: _ClassVar[int] + replicas: int + image: str + resources: _tasks_pb2.Resources + restart_policy: _common_pb2.RestartPolicy + command: _containers.RepeatedScalarFieldContainer[str] + common: _common_pb2.CommonReplicaSpec + def __init__(self, replicas: _Optional[int] = ..., image: _Optional[str] = ..., resources: _Optional[_Union[_tasks_pb2.Resources, _Mapping]] = ..., restart_policy: _Optional[_Union[_common_pb2.RestartPolicy, str]] = ..., command: _Optional[_Iterable[str]] = ..., common: _Optional[_Union[_common_pb2.CommonReplicaSpec, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/plugins/kubeflow/mpi_pb2_grpc.py b/gen/python/flyteidl2/plugins/kubeflow/mpi_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/plugins/kubeflow/mpi_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/plugins/kubeflow/pytorch_pb2.py b/gen/python/flyteidl2/plugins/kubeflow/pytorch_pb2.py new file mode 100644 index 0000000000..2b4ab6b4ee --- /dev/null +++ b/gen/python/flyteidl2/plugins/kubeflow/pytorch_pb2.py @@ -0,0 +1,41 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/plugins/kubeflow/pytorch.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.core import tasks_pb2 as flyteidl2_dot_core_dot_tasks__pb2 +from flyteidl2.plugins import common_pb2 as flyteidl2_dot_plugins_dot_common__pb2 +from flyteidl2.plugins.kubeflow import common_pb2 as flyteidl2_dot_plugins_dot_kubeflow_dot_common__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n(flyteidl2/plugins/kubeflow/pytorch.proto\x12\x1a\x66lyteidl2.plugins.kubeflow\x1a\x1a\x66lyteidl2/core/tasks.proto\x1a\x1e\x66lyteidl2/plugins/common.proto\x1a\'flyteidl2/plugins/kubeflow/common.proto\"\xc1\x01\n\rElasticConfig\x12!\n\x0crdzv_backend\x18\x01 \x01(\tR\x0brdzvBackend\x12!\n\x0cmin_replicas\x18\x02 \x01(\x05R\x0bminReplicas\x12!\n\x0cmax_replicas\x18\x03 \x01(\x05R\x0bmaxReplicas\x12$\n\x0enproc_per_node\x18\x04 \x01(\x05R\x0cnprocPerNode\x12!\n\x0cmax_restarts\x18\x05 \x01(\x05R\x0bmaxRestarts\"\x90\x03\n\x1e\x44istributedPyTorchTrainingTask\x12j\n\x0fworker_replicas\x18\x01 \x01(\x0b\x32\x41.flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingReplicaSpecR\x0eworkerReplicas\x12j\n\x0fmaster_replicas\x18\x02 \x01(\x0b\x32\x41.flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingReplicaSpecR\x0emasterReplicas\x12\x44\n\nrun_policy\x18\x03 \x01(\x0b\x32%.flyteidl2.plugins.kubeflow.RunPolicyR\trunPolicy\x12P\n\x0e\x65lastic_config\x18\x04 \x01(\x0b\x32).flyteidl2.plugins.kubeflow.ElasticConfigR\relasticConfig\"\xa9\x02\n%DistributedPyTorchTrainingReplicaSpec\x12\x1e\n\x08replicas\x18\x01 \x01(\x05\x42\x02\x18\x01R\x08replicas\x12\x18\n\x05image\x18\x02 \x01(\tB\x02\x18\x01R\x05image\x12;\n\tresources\x18\x03 \x01(\x0b\x32\x19.flyteidl2.core.ResourcesB\x02\x18\x01R\tresources\x12K\n\x0erestart_policy\x18\x04 \x01(\x0e\x32 .flyteidl2.plugins.RestartPolicyB\x02\x18\x01R\rrestartPolicy\x12<\n\x06\x63ommon\x18\x05 \x01(\x0b\x32$.flyteidl2.plugins.CommonReplicaSpecR\x06\x63ommonB\xfa\x01\n\x1e\x63om.flyteidl2.plugins.kubeflowB\x0cPytorchProtoH\x02P\x01Z>github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow\xa2\x02\x03\x46PK\xaa\x02\x1a\x46lyteidl2.Plugins.Kubeflow\xca\x02\x1a\x46lyteidl2\\Plugins\\Kubeflow\xe2\x02&Flyteidl2\\Plugins\\Kubeflow\\GPBMetadata\xea\x02\x1c\x46lyteidl2::Plugins::Kubeflowb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.plugins.kubeflow.pytorch_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\036com.flyteidl2.plugins.kubeflowB\014PytorchProtoH\002P\001Z>github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow\242\002\003FPK\252\002\032Flyteidl2.Plugins.Kubeflow\312\002\032Flyteidl2\\Plugins\\Kubeflow\342\002&Flyteidl2\\Plugins\\Kubeflow\\GPBMetadata\352\002\034Flyteidl2::Plugins::Kubeflow' + _DISTRIBUTEDPYTORCHTRAININGREPLICASPEC.fields_by_name['replicas']._options = None + _DISTRIBUTEDPYTORCHTRAININGREPLICASPEC.fields_by_name['replicas']._serialized_options = b'\030\001' + _DISTRIBUTEDPYTORCHTRAININGREPLICASPEC.fields_by_name['image']._options = None + _DISTRIBUTEDPYTORCHTRAININGREPLICASPEC.fields_by_name['image']._serialized_options = b'\030\001' + _DISTRIBUTEDPYTORCHTRAININGREPLICASPEC.fields_by_name['resources']._options = None + _DISTRIBUTEDPYTORCHTRAININGREPLICASPEC.fields_by_name['resources']._serialized_options = b'\030\001' + _DISTRIBUTEDPYTORCHTRAININGREPLICASPEC.fields_by_name['restart_policy']._options = None + _DISTRIBUTEDPYTORCHTRAININGREPLICASPEC.fields_by_name['restart_policy']._serialized_options = b'\030\001' + _globals['_ELASTICCONFIG']._serialized_start=174 + _globals['_ELASTICCONFIG']._serialized_end=367 + _globals['_DISTRIBUTEDPYTORCHTRAININGTASK']._serialized_start=370 + _globals['_DISTRIBUTEDPYTORCHTRAININGTASK']._serialized_end=770 + _globals['_DISTRIBUTEDPYTORCHTRAININGREPLICASPEC']._serialized_start=773 + _globals['_DISTRIBUTEDPYTORCHTRAININGREPLICASPEC']._serialized_end=1070 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/plugins/kubeflow/pytorch_pb2.pyi b/gen/python/flyteidl2/plugins/kubeflow/pytorch_pb2.pyi new file mode 100644 index 0000000000..99bc167c2d --- /dev/null +++ b/gen/python/flyteidl2/plugins/kubeflow/pytorch_pb2.pyi @@ -0,0 +1,48 @@ +from flyteidl2.core import tasks_pb2 as _tasks_pb2 +from flyteidl2.plugins import common_pb2 as _common_pb2 +from flyteidl2.plugins.kubeflow import common_pb2 as _common_pb2_1 +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class ElasticConfig(_message.Message): + __slots__ = ["rdzv_backend", "min_replicas", "max_replicas", "nproc_per_node", "max_restarts"] + RDZV_BACKEND_FIELD_NUMBER: _ClassVar[int] + MIN_REPLICAS_FIELD_NUMBER: _ClassVar[int] + MAX_REPLICAS_FIELD_NUMBER: _ClassVar[int] + NPROC_PER_NODE_FIELD_NUMBER: _ClassVar[int] + MAX_RESTARTS_FIELD_NUMBER: _ClassVar[int] + rdzv_backend: str + min_replicas: int + max_replicas: int + nproc_per_node: int + max_restarts: int + def __init__(self, rdzv_backend: _Optional[str] = ..., min_replicas: _Optional[int] = ..., max_replicas: _Optional[int] = ..., nproc_per_node: _Optional[int] = ..., max_restarts: _Optional[int] = ...) -> None: ... + +class DistributedPyTorchTrainingTask(_message.Message): + __slots__ = ["worker_replicas", "master_replicas", "run_policy", "elastic_config"] + WORKER_REPLICAS_FIELD_NUMBER: _ClassVar[int] + MASTER_REPLICAS_FIELD_NUMBER: _ClassVar[int] + RUN_POLICY_FIELD_NUMBER: _ClassVar[int] + ELASTIC_CONFIG_FIELD_NUMBER: _ClassVar[int] + worker_replicas: DistributedPyTorchTrainingReplicaSpec + master_replicas: DistributedPyTorchTrainingReplicaSpec + run_policy: _common_pb2_1.RunPolicy + elastic_config: ElasticConfig + def __init__(self, worker_replicas: _Optional[_Union[DistributedPyTorchTrainingReplicaSpec, _Mapping]] = ..., master_replicas: _Optional[_Union[DistributedPyTorchTrainingReplicaSpec, _Mapping]] = ..., run_policy: _Optional[_Union[_common_pb2_1.RunPolicy, _Mapping]] = ..., elastic_config: _Optional[_Union[ElasticConfig, _Mapping]] = ...) -> None: ... + +class DistributedPyTorchTrainingReplicaSpec(_message.Message): + __slots__ = ["replicas", "image", "resources", "restart_policy", "common"] + REPLICAS_FIELD_NUMBER: _ClassVar[int] + IMAGE_FIELD_NUMBER: _ClassVar[int] + RESOURCES_FIELD_NUMBER: _ClassVar[int] + RESTART_POLICY_FIELD_NUMBER: _ClassVar[int] + COMMON_FIELD_NUMBER: _ClassVar[int] + replicas: int + image: str + resources: _tasks_pb2.Resources + restart_policy: _common_pb2.RestartPolicy + common: _common_pb2.CommonReplicaSpec + def __init__(self, replicas: _Optional[int] = ..., image: _Optional[str] = ..., resources: _Optional[_Union[_tasks_pb2.Resources, _Mapping]] = ..., restart_policy: _Optional[_Union[_common_pb2.RestartPolicy, str]] = ..., common: _Optional[_Union[_common_pb2.CommonReplicaSpec, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/plugins/kubeflow/pytorch_pb2_grpc.py b/gen/python/flyteidl2/plugins/kubeflow/pytorch_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/plugins/kubeflow/pytorch_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/plugins/kubeflow/tensorflow_pb2.py b/gen/python/flyteidl2/plugins/kubeflow/tensorflow_pb2.py new file mode 100644 index 0000000000..8edef5e56c --- /dev/null +++ b/gen/python/flyteidl2/plugins/kubeflow/tensorflow_pb2.py @@ -0,0 +1,39 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/plugins/kubeflow/tensorflow.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.core import tasks_pb2 as flyteidl2_dot_core_dot_tasks__pb2 +from flyteidl2.plugins import common_pb2 as flyteidl2_dot_plugins_dot_common__pb2 +from flyteidl2.plugins.kubeflow import common_pb2 as flyteidl2_dot_plugins_dot_kubeflow_dot_common__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n+flyteidl2/plugins/kubeflow/tensorflow.proto\x12\x1a\x66lyteidl2.plugins.kubeflow\x1a\x1a\x66lyteidl2/core/tasks.proto\x1a\x1e\x66lyteidl2/plugins/common.proto\x1a\'flyteidl2/plugins/kubeflow/common.proto\"\xa1\x04\n!DistributedTensorflowTrainingTask\x12m\n\x0fworker_replicas\x18\x01 \x01(\x0b\x32\x44.flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpecR\x0eworkerReplicas\x12\x65\n\x0bps_replicas\x18\x02 \x01(\x0b\x32\x44.flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpecR\npsReplicas\x12k\n\x0e\x63hief_replicas\x18\x03 \x01(\x0b\x32\x44.flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpecR\rchiefReplicas\x12\x44\n\nrun_policy\x18\x04 \x01(\x0b\x32%.flyteidl2.plugins.kubeflow.RunPolicyR\trunPolicy\x12s\n\x12\x65valuator_replicas\x18\x05 \x01(\x0b\x32\x44.flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpecR\x11\x65valuatorReplicas\"\xac\x02\n(DistributedTensorflowTrainingReplicaSpec\x12\x1e\n\x08replicas\x18\x01 \x01(\x05\x42\x02\x18\x01R\x08replicas\x12\x18\n\x05image\x18\x02 \x01(\tB\x02\x18\x01R\x05image\x12;\n\tresources\x18\x03 \x01(\x0b\x32\x19.flyteidl2.core.ResourcesB\x02\x18\x01R\tresources\x12K\n\x0erestart_policy\x18\x04 \x01(\x0e\x32 .flyteidl2.plugins.RestartPolicyB\x02\x18\x01R\rrestartPolicy\x12<\n\x06\x63ommon\x18\x05 \x01(\x0b\x32$.flyteidl2.plugins.CommonReplicaSpecR\x06\x63ommonB\xfd\x01\n\x1e\x63om.flyteidl2.plugins.kubeflowB\x0fTensorflowProtoH\x02P\x01Z>github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow\xa2\x02\x03\x46PK\xaa\x02\x1a\x46lyteidl2.Plugins.Kubeflow\xca\x02\x1a\x46lyteidl2\\Plugins\\Kubeflow\xe2\x02&Flyteidl2\\Plugins\\Kubeflow\\GPBMetadata\xea\x02\x1c\x46lyteidl2::Plugins::Kubeflowb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.plugins.kubeflow.tensorflow_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\036com.flyteidl2.plugins.kubeflowB\017TensorflowProtoH\002P\001Z>github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins/kubeflow\242\002\003FPK\252\002\032Flyteidl2.Plugins.Kubeflow\312\002\032Flyteidl2\\Plugins\\Kubeflow\342\002&Flyteidl2\\Plugins\\Kubeflow\\GPBMetadata\352\002\034Flyteidl2::Plugins::Kubeflow' + _DISTRIBUTEDTENSORFLOWTRAININGREPLICASPEC.fields_by_name['replicas']._options = None + _DISTRIBUTEDTENSORFLOWTRAININGREPLICASPEC.fields_by_name['replicas']._serialized_options = b'\030\001' + _DISTRIBUTEDTENSORFLOWTRAININGREPLICASPEC.fields_by_name['image']._options = None + _DISTRIBUTEDTENSORFLOWTRAININGREPLICASPEC.fields_by_name['image']._serialized_options = b'\030\001' + _DISTRIBUTEDTENSORFLOWTRAININGREPLICASPEC.fields_by_name['resources']._options = None + _DISTRIBUTEDTENSORFLOWTRAININGREPLICASPEC.fields_by_name['resources']._serialized_options = b'\030\001' + _DISTRIBUTEDTENSORFLOWTRAININGREPLICASPEC.fields_by_name['restart_policy']._options = None + _DISTRIBUTEDTENSORFLOWTRAININGREPLICASPEC.fields_by_name['restart_policy']._serialized_options = b'\030\001' + _globals['_DISTRIBUTEDTENSORFLOWTRAININGTASK']._serialized_start=177 + _globals['_DISTRIBUTEDTENSORFLOWTRAININGTASK']._serialized_end=722 + _globals['_DISTRIBUTEDTENSORFLOWTRAININGREPLICASPEC']._serialized_start=725 + _globals['_DISTRIBUTEDTENSORFLOWTRAININGREPLICASPEC']._serialized_end=1025 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/plugins/kubeflow/tensorflow_pb2.pyi b/gen/python/flyteidl2/plugins/kubeflow/tensorflow_pb2.pyi new file mode 100644 index 0000000000..afb6399141 --- /dev/null +++ b/gen/python/flyteidl2/plugins/kubeflow/tensorflow_pb2.pyi @@ -0,0 +1,36 @@ +from flyteidl2.core import tasks_pb2 as _tasks_pb2 +from flyteidl2.plugins import common_pb2 as _common_pb2 +from flyteidl2.plugins.kubeflow import common_pb2 as _common_pb2_1 +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class DistributedTensorflowTrainingTask(_message.Message): + __slots__ = ["worker_replicas", "ps_replicas", "chief_replicas", "run_policy", "evaluator_replicas"] + WORKER_REPLICAS_FIELD_NUMBER: _ClassVar[int] + PS_REPLICAS_FIELD_NUMBER: _ClassVar[int] + CHIEF_REPLICAS_FIELD_NUMBER: _ClassVar[int] + RUN_POLICY_FIELD_NUMBER: _ClassVar[int] + EVALUATOR_REPLICAS_FIELD_NUMBER: _ClassVar[int] + worker_replicas: DistributedTensorflowTrainingReplicaSpec + ps_replicas: DistributedTensorflowTrainingReplicaSpec + chief_replicas: DistributedTensorflowTrainingReplicaSpec + run_policy: _common_pb2_1.RunPolicy + evaluator_replicas: DistributedTensorflowTrainingReplicaSpec + def __init__(self, worker_replicas: _Optional[_Union[DistributedTensorflowTrainingReplicaSpec, _Mapping]] = ..., ps_replicas: _Optional[_Union[DistributedTensorflowTrainingReplicaSpec, _Mapping]] = ..., chief_replicas: _Optional[_Union[DistributedTensorflowTrainingReplicaSpec, _Mapping]] = ..., run_policy: _Optional[_Union[_common_pb2_1.RunPolicy, _Mapping]] = ..., evaluator_replicas: _Optional[_Union[DistributedTensorflowTrainingReplicaSpec, _Mapping]] = ...) -> None: ... + +class DistributedTensorflowTrainingReplicaSpec(_message.Message): + __slots__ = ["replicas", "image", "resources", "restart_policy", "common"] + REPLICAS_FIELD_NUMBER: _ClassVar[int] + IMAGE_FIELD_NUMBER: _ClassVar[int] + RESOURCES_FIELD_NUMBER: _ClassVar[int] + RESTART_POLICY_FIELD_NUMBER: _ClassVar[int] + COMMON_FIELD_NUMBER: _ClassVar[int] + replicas: int + image: str + resources: _tasks_pb2.Resources + restart_policy: _common_pb2.RestartPolicy + common: _common_pb2.CommonReplicaSpec + def __init__(self, replicas: _Optional[int] = ..., image: _Optional[str] = ..., resources: _Optional[_Union[_tasks_pb2.Resources, _Mapping]] = ..., restart_policy: _Optional[_Union[_common_pb2.RestartPolicy, str]] = ..., common: _Optional[_Union[_common_pb2.CommonReplicaSpec, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/plugins/kubeflow/tensorflow_pb2_grpc.py b/gen/python/flyteidl2/plugins/kubeflow/tensorflow_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/plugins/kubeflow/tensorflow_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/plugins/mpi_pb2.py b/gen/python/flyteidl2/plugins/mpi_pb2.py new file mode 100644 index 0000000000..2bbc284f3d --- /dev/null +++ b/gen/python/flyteidl2/plugins/mpi_pb2.py @@ -0,0 +1,26 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/plugins/mpi.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1b\x66lyteidl2/plugins/mpi.proto\x12\x11\x66lyteidl2.plugins\"\x87\x01\n\x1a\x44istributedMPITrainingTask\x12\x1f\n\x0bnum_workers\x18\x01 \x01(\x05R\nnumWorkers\x12\x32\n\x15num_launcher_replicas\x18\x02 \x01(\x05R\x13numLauncherReplicas\x12\x14\n\x05slots\x18\x03 \x01(\x05R\x05slotsB\xbf\x01\n\x15\x63om.flyteidl2.pluginsB\x08MpiProtoH\x02P\x01Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins\xa2\x02\x03\x46PX\xaa\x02\x11\x46lyteidl2.Plugins\xca\x02\x11\x46lyteidl2\\Plugins\xe2\x02\x1d\x46lyteidl2\\Plugins\\GPBMetadata\xea\x02\x12\x46lyteidl2::Pluginsb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.plugins.mpi_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\025com.flyteidl2.pluginsB\010MpiProtoH\002P\001Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins\242\002\003FPX\252\002\021Flyteidl2.Plugins\312\002\021Flyteidl2\\Plugins\342\002\035Flyteidl2\\Plugins\\GPBMetadata\352\002\022Flyteidl2::Plugins' + _globals['_DISTRIBUTEDMPITRAININGTASK']._serialized_start=51 + _globals['_DISTRIBUTEDMPITRAININGTASK']._serialized_end=186 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/plugins/mpi_pb2.pyi b/gen/python/flyteidl2/plugins/mpi_pb2.pyi new file mode 100644 index 0000000000..b907bede41 --- /dev/null +++ b/gen/python/flyteidl2/plugins/mpi_pb2.pyi @@ -0,0 +1,15 @@ +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Optional as _Optional + +DESCRIPTOR: _descriptor.FileDescriptor + +class DistributedMPITrainingTask(_message.Message): + __slots__ = ["num_workers", "num_launcher_replicas", "slots"] + NUM_WORKERS_FIELD_NUMBER: _ClassVar[int] + NUM_LAUNCHER_REPLICAS_FIELD_NUMBER: _ClassVar[int] + SLOTS_FIELD_NUMBER: _ClassVar[int] + num_workers: int + num_launcher_replicas: int + slots: int + def __init__(self, num_workers: _Optional[int] = ..., num_launcher_replicas: _Optional[int] = ..., slots: _Optional[int] = ...) -> None: ... diff --git a/gen/python/flyteidl2/plugins/mpi_pb2_grpc.py b/gen/python/flyteidl2/plugins/mpi_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/plugins/mpi_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/plugins/presto_pb2.py b/gen/python/flyteidl2/plugins/presto_pb2.py new file mode 100644 index 0000000000..08bcd4d565 --- /dev/null +++ b/gen/python/flyteidl2/plugins/presto_pb2.py @@ -0,0 +1,26 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/plugins/presto.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1e\x66lyteidl2/plugins/presto.proto\x12\x11\x66lyteidl2.plugins\"\x82\x01\n\x0bPrestoQuery\x12#\n\rrouting_group\x18\x01 \x01(\tR\x0croutingGroup\x12\x18\n\x07\x63\x61talog\x18\x02 \x01(\tR\x07\x63\x61talog\x12\x16\n\x06schema\x18\x03 \x01(\tR\x06schema\x12\x1c\n\tstatement\x18\x04 \x01(\tR\tstatementB\xc2\x01\n\x15\x63om.flyteidl2.pluginsB\x0bPrestoProtoH\x02P\x01Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins\xa2\x02\x03\x46PX\xaa\x02\x11\x46lyteidl2.Plugins\xca\x02\x11\x46lyteidl2\\Plugins\xe2\x02\x1d\x46lyteidl2\\Plugins\\GPBMetadata\xea\x02\x12\x46lyteidl2::Pluginsb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.plugins.presto_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\025com.flyteidl2.pluginsB\013PrestoProtoH\002P\001Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins\242\002\003FPX\252\002\021Flyteidl2.Plugins\312\002\021Flyteidl2\\Plugins\342\002\035Flyteidl2\\Plugins\\GPBMetadata\352\002\022Flyteidl2::Plugins' + _globals['_PRESTOQUERY']._serialized_start=54 + _globals['_PRESTOQUERY']._serialized_end=184 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/plugins/presto_pb2.pyi b/gen/python/flyteidl2/plugins/presto_pb2.pyi new file mode 100644 index 0000000000..6f185403e4 --- /dev/null +++ b/gen/python/flyteidl2/plugins/presto_pb2.pyi @@ -0,0 +1,17 @@ +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Optional as _Optional + +DESCRIPTOR: _descriptor.FileDescriptor + +class PrestoQuery(_message.Message): + __slots__ = ["routing_group", "catalog", "schema", "statement"] + ROUTING_GROUP_FIELD_NUMBER: _ClassVar[int] + CATALOG_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + STATEMENT_FIELD_NUMBER: _ClassVar[int] + routing_group: str + catalog: str + schema: str + statement: str + def __init__(self, routing_group: _Optional[str] = ..., catalog: _Optional[str] = ..., schema: _Optional[str] = ..., statement: _Optional[str] = ...) -> None: ... diff --git a/gen/python/flyteidl2/plugins/presto_pb2_grpc.py b/gen/python/flyteidl2/plugins/presto_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/plugins/presto_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/plugins/pytorch_pb2.py b/gen/python/flyteidl2/plugins/pytorch_pb2.py new file mode 100644 index 0000000000..42c1ad46da --- /dev/null +++ b/gen/python/flyteidl2/plugins/pytorch_pb2.py @@ -0,0 +1,28 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/plugins/pytorch.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1f\x66lyteidl2/plugins/pytorch.proto\x12\x11\x66lyteidl2.plugins\"\xc1\x01\n\rElasticConfig\x12!\n\x0crdzv_backend\x18\x01 \x01(\tR\x0brdzvBackend\x12!\n\x0cmin_replicas\x18\x02 \x01(\x05R\x0bminReplicas\x12!\n\x0cmax_replicas\x18\x03 \x01(\x05R\x0bmaxReplicas\x12$\n\x0enproc_per_node\x18\x04 \x01(\x05R\x0cnprocPerNode\x12!\n\x0cmax_restarts\x18\x05 \x01(\x05R\x0bmaxRestarts\"\x83\x01\n\x1e\x44istributedPyTorchTrainingTask\x12\x18\n\x07workers\x18\x01 \x01(\x05R\x07workers\x12G\n\x0e\x65lastic_config\x18\x02 \x01(\x0b\x32 .flyteidl2.plugins.ElasticConfigR\relasticConfigB\xc3\x01\n\x15\x63om.flyteidl2.pluginsB\x0cPytorchProtoH\x02P\x01Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins\xa2\x02\x03\x46PX\xaa\x02\x11\x46lyteidl2.Plugins\xca\x02\x11\x46lyteidl2\\Plugins\xe2\x02\x1d\x46lyteidl2\\Plugins\\GPBMetadata\xea\x02\x12\x46lyteidl2::Pluginsb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.plugins.pytorch_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\025com.flyteidl2.pluginsB\014PytorchProtoH\002P\001Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins\242\002\003FPX\252\002\021Flyteidl2.Plugins\312\002\021Flyteidl2\\Plugins\342\002\035Flyteidl2\\Plugins\\GPBMetadata\352\002\022Flyteidl2::Plugins' + _globals['_ELASTICCONFIG']._serialized_start=55 + _globals['_ELASTICCONFIG']._serialized_end=248 + _globals['_DISTRIBUTEDPYTORCHTRAININGTASK']._serialized_start=251 + _globals['_DISTRIBUTEDPYTORCHTRAININGTASK']._serialized_end=382 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/plugins/pytorch_pb2.pyi b/gen/python/flyteidl2/plugins/pytorch_pb2.pyi new file mode 100644 index 0000000000..882c38d2de --- /dev/null +++ b/gen/python/flyteidl2/plugins/pytorch_pb2.pyi @@ -0,0 +1,27 @@ +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class ElasticConfig(_message.Message): + __slots__ = ["rdzv_backend", "min_replicas", "max_replicas", "nproc_per_node", "max_restarts"] + RDZV_BACKEND_FIELD_NUMBER: _ClassVar[int] + MIN_REPLICAS_FIELD_NUMBER: _ClassVar[int] + MAX_REPLICAS_FIELD_NUMBER: _ClassVar[int] + NPROC_PER_NODE_FIELD_NUMBER: _ClassVar[int] + MAX_RESTARTS_FIELD_NUMBER: _ClassVar[int] + rdzv_backend: str + min_replicas: int + max_replicas: int + nproc_per_node: int + max_restarts: int + def __init__(self, rdzv_backend: _Optional[str] = ..., min_replicas: _Optional[int] = ..., max_replicas: _Optional[int] = ..., nproc_per_node: _Optional[int] = ..., max_restarts: _Optional[int] = ...) -> None: ... + +class DistributedPyTorchTrainingTask(_message.Message): + __slots__ = ["workers", "elastic_config"] + WORKERS_FIELD_NUMBER: _ClassVar[int] + ELASTIC_CONFIG_FIELD_NUMBER: _ClassVar[int] + workers: int + elastic_config: ElasticConfig + def __init__(self, workers: _Optional[int] = ..., elastic_config: _Optional[_Union[ElasticConfig, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/plugins/pytorch_pb2_grpc.py b/gen/python/flyteidl2/plugins/pytorch_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/plugins/pytorch_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/plugins/qubole_pb2.py b/gen/python/flyteidl2/plugins/qubole_pb2.py new file mode 100644 index 0000000000..2cc97e4fc8 --- /dev/null +++ b/gen/python/flyteidl2/plugins/qubole_pb2.py @@ -0,0 +1,32 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/plugins/qubole.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1e\x66lyteidl2/plugins/qubole.proto\x12\x11\x66lyteidl2.plugins\"b\n\tHiveQuery\x12\x14\n\x05query\x18\x01 \x01(\tR\x05query\x12\x1f\n\x0btimeout_sec\x18\x02 \x01(\rR\ntimeoutSec\x12\x1e\n\nretryCount\x18\x03 \x01(\rR\nretryCount\"M\n\x13HiveQueryCollection\x12\x36\n\x07queries\x18\x02 \x03(\x0b\x32\x1c.flyteidl2.plugins.HiveQueryR\x07queries\"\xd3\x01\n\rQuboleHiveJob\x12#\n\rcluster_label\x18\x01 \x01(\tR\x0c\x63lusterLabel\x12U\n\x10query_collection\x18\x02 \x01(\x0b\x32&.flyteidl2.plugins.HiveQueryCollectionB\x02\x18\x01R\x0fqueryCollection\x12\x12\n\x04tags\x18\x03 \x03(\tR\x04tags\x12\x32\n\x05query\x18\x04 \x01(\x0b\x32\x1c.flyteidl2.plugins.HiveQueryR\x05queryB\xc2\x01\n\x15\x63om.flyteidl2.pluginsB\x0bQuboleProtoH\x02P\x01Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins\xa2\x02\x03\x46PX\xaa\x02\x11\x46lyteidl2.Plugins\xca\x02\x11\x46lyteidl2\\Plugins\xe2\x02\x1d\x46lyteidl2\\Plugins\\GPBMetadata\xea\x02\x12\x46lyteidl2::Pluginsb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.plugins.qubole_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\025com.flyteidl2.pluginsB\013QuboleProtoH\002P\001Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins\242\002\003FPX\252\002\021Flyteidl2.Plugins\312\002\021Flyteidl2\\Plugins\342\002\035Flyteidl2\\Plugins\\GPBMetadata\352\002\022Flyteidl2::Plugins' + _QUBOLEHIVEJOB.fields_by_name['query_collection']._options = None + _QUBOLEHIVEJOB.fields_by_name['query_collection']._serialized_options = b'\030\001' + _globals['_HIVEQUERY']._serialized_start=53 + _globals['_HIVEQUERY']._serialized_end=151 + _globals['_HIVEQUERYCOLLECTION']._serialized_start=153 + _globals['_HIVEQUERYCOLLECTION']._serialized_end=230 + _globals['_QUBOLEHIVEJOB']._serialized_start=233 + _globals['_QUBOLEHIVEJOB']._serialized_end=444 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/plugins/qubole_pb2.pyi b/gen/python/flyteidl2/plugins/qubole_pb2.pyi new file mode 100644 index 0000000000..71e6bd6698 --- /dev/null +++ b/gen/python/flyteidl2/plugins/qubole_pb2.pyi @@ -0,0 +1,34 @@ +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class HiveQuery(_message.Message): + __slots__ = ["query", "timeout_sec", "retryCount"] + QUERY_FIELD_NUMBER: _ClassVar[int] + TIMEOUT_SEC_FIELD_NUMBER: _ClassVar[int] + RETRYCOUNT_FIELD_NUMBER: _ClassVar[int] + query: str + timeout_sec: int + retryCount: int + def __init__(self, query: _Optional[str] = ..., timeout_sec: _Optional[int] = ..., retryCount: _Optional[int] = ...) -> None: ... + +class HiveQueryCollection(_message.Message): + __slots__ = ["queries"] + QUERIES_FIELD_NUMBER: _ClassVar[int] + queries: _containers.RepeatedCompositeFieldContainer[HiveQuery] + def __init__(self, queries: _Optional[_Iterable[_Union[HiveQuery, _Mapping]]] = ...) -> None: ... + +class QuboleHiveJob(_message.Message): + __slots__ = ["cluster_label", "query_collection", "tags", "query"] + CLUSTER_LABEL_FIELD_NUMBER: _ClassVar[int] + QUERY_COLLECTION_FIELD_NUMBER: _ClassVar[int] + TAGS_FIELD_NUMBER: _ClassVar[int] + QUERY_FIELD_NUMBER: _ClassVar[int] + cluster_label: str + query_collection: HiveQueryCollection + tags: _containers.RepeatedScalarFieldContainer[str] + query: HiveQuery + def __init__(self, cluster_label: _Optional[str] = ..., query_collection: _Optional[_Union[HiveQueryCollection, _Mapping]] = ..., tags: _Optional[_Iterable[str]] = ..., query: _Optional[_Union[HiveQuery, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/plugins/qubole_pb2_grpc.py b/gen/python/flyteidl2/plugins/qubole_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/plugins/qubole_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/plugins/ray_pb2.py b/gen/python/flyteidl2/plugins/ray_pb2.py new file mode 100644 index 0000000000..3f2e457d59 --- /dev/null +++ b/gen/python/flyteidl2/plugins/ray_pb2.py @@ -0,0 +1,43 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/plugins/ray.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.core import tasks_pb2 as flyteidl2_dot_core_dot_tasks__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1b\x66lyteidl2/plugins/ray.proto\x12\x11\x66lyteidl2.plugins\x1a\x1a\x66lyteidl2/core/tasks.proto\"\x93\x02\n\x06RayJob\x12>\n\x0bray_cluster\x18\x01 \x01(\x0b\x32\x1d.flyteidl2.plugins.RayClusterR\nrayCluster\x12#\n\x0bruntime_env\x18\x02 \x01(\tB\x02\x18\x01R\nruntimeEnv\x12=\n\x1bshutdown_after_job_finishes\x18\x03 \x01(\x08R\x18shutdownAfterJobFinishes\x12;\n\x1attl_seconds_after_finished\x18\x04 \x01(\x05R\x17ttlSecondsAfterFinished\x12(\n\x10runtime_env_yaml\x18\x05 \x01(\tR\x0eruntimeEnvYaml\"\xd5\x01\n\nRayCluster\x12H\n\x0fhead_group_spec\x18\x01 \x01(\x0b\x32 .flyteidl2.plugins.HeadGroupSpecR\rheadGroupSpec\x12N\n\x11worker_group_spec\x18\x02 \x03(\x0b\x32\".flyteidl2.plugins.WorkerGroupSpecR\x0fworkerGroupSpec\x12-\n\x12\x65nable_autoscaling\x18\x03 \x01(\x08R\x11\x65nableAutoscaling\"\xe3\x01\n\rHeadGroupSpec\x12^\n\x10ray_start_params\x18\x01 \x03(\x0b\x32\x34.flyteidl2.plugins.HeadGroupSpec.RayStartParamsEntryR\x0erayStartParams\x12/\n\x07k8s_pod\x18\x02 \x01(\x0b\x32\x16.flyteidl2.core.K8sPodR\x06k8sPod\x1a\x41\n\x13RayStartParamsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\xe8\x02\n\x0fWorkerGroupSpec\x12\x1d\n\ngroup_name\x18\x01 \x01(\tR\tgroupName\x12\x1a\n\x08replicas\x18\x02 \x01(\x05R\x08replicas\x12!\n\x0cmin_replicas\x18\x03 \x01(\x05R\x0bminReplicas\x12!\n\x0cmax_replicas\x18\x04 \x01(\x05R\x0bmaxReplicas\x12`\n\x10ray_start_params\x18\x05 \x03(\x0b\x32\x36.flyteidl2.plugins.WorkerGroupSpec.RayStartParamsEntryR\x0erayStartParams\x12/\n\x07k8s_pod\x18\x06 \x01(\x0b\x32\x16.flyteidl2.core.K8sPodR\x06k8sPod\x1a\x41\n\x13RayStartParamsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x42\xbf\x01\n\x15\x63om.flyteidl2.pluginsB\x08RayProtoH\x02P\x01Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins\xa2\x02\x03\x46PX\xaa\x02\x11\x46lyteidl2.Plugins\xca\x02\x11\x46lyteidl2\\Plugins\xe2\x02\x1d\x46lyteidl2\\Plugins\\GPBMetadata\xea\x02\x12\x46lyteidl2::Pluginsb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.plugins.ray_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\025com.flyteidl2.pluginsB\010RayProtoH\002P\001Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins\242\002\003FPX\252\002\021Flyteidl2.Plugins\312\002\021Flyteidl2\\Plugins\342\002\035Flyteidl2\\Plugins\\GPBMetadata\352\002\022Flyteidl2::Plugins' + _RAYJOB.fields_by_name['runtime_env']._options = None + _RAYJOB.fields_by_name['runtime_env']._serialized_options = b'\030\001' + _HEADGROUPSPEC_RAYSTARTPARAMSENTRY._options = None + _HEADGROUPSPEC_RAYSTARTPARAMSENTRY._serialized_options = b'8\001' + _WORKERGROUPSPEC_RAYSTARTPARAMSENTRY._options = None + _WORKERGROUPSPEC_RAYSTARTPARAMSENTRY._serialized_options = b'8\001' + _globals['_RAYJOB']._serialized_start=79 + _globals['_RAYJOB']._serialized_end=354 + _globals['_RAYCLUSTER']._serialized_start=357 + _globals['_RAYCLUSTER']._serialized_end=570 + _globals['_HEADGROUPSPEC']._serialized_start=573 + _globals['_HEADGROUPSPEC']._serialized_end=800 + _globals['_HEADGROUPSPEC_RAYSTARTPARAMSENTRY']._serialized_start=735 + _globals['_HEADGROUPSPEC_RAYSTARTPARAMSENTRY']._serialized_end=800 + _globals['_WORKERGROUPSPEC']._serialized_start=803 + _globals['_WORKERGROUPSPEC']._serialized_end=1163 + _globals['_WORKERGROUPSPEC_RAYSTARTPARAMSENTRY']._serialized_start=735 + _globals['_WORKERGROUPSPEC_RAYSTARTPARAMSENTRY']._serialized_end=800 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/plugins/ray_pb2.pyi b/gen/python/flyteidl2/plugins/ray_pb2.pyi new file mode 100644 index 0000000000..4a5d2cfd02 --- /dev/null +++ b/gen/python/flyteidl2/plugins/ray_pb2.pyi @@ -0,0 +1,69 @@ +from flyteidl2.core import tasks_pb2 as _tasks_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class RayJob(_message.Message): + __slots__ = ["ray_cluster", "runtime_env", "shutdown_after_job_finishes", "ttl_seconds_after_finished", "runtime_env_yaml"] + RAY_CLUSTER_FIELD_NUMBER: _ClassVar[int] + RUNTIME_ENV_FIELD_NUMBER: _ClassVar[int] + SHUTDOWN_AFTER_JOB_FINISHES_FIELD_NUMBER: _ClassVar[int] + TTL_SECONDS_AFTER_FINISHED_FIELD_NUMBER: _ClassVar[int] + RUNTIME_ENV_YAML_FIELD_NUMBER: _ClassVar[int] + ray_cluster: RayCluster + runtime_env: str + shutdown_after_job_finishes: bool + ttl_seconds_after_finished: int + runtime_env_yaml: str + def __init__(self, ray_cluster: _Optional[_Union[RayCluster, _Mapping]] = ..., runtime_env: _Optional[str] = ..., shutdown_after_job_finishes: bool = ..., ttl_seconds_after_finished: _Optional[int] = ..., runtime_env_yaml: _Optional[str] = ...) -> None: ... + +class RayCluster(_message.Message): + __slots__ = ["head_group_spec", "worker_group_spec", "enable_autoscaling"] + HEAD_GROUP_SPEC_FIELD_NUMBER: _ClassVar[int] + WORKER_GROUP_SPEC_FIELD_NUMBER: _ClassVar[int] + ENABLE_AUTOSCALING_FIELD_NUMBER: _ClassVar[int] + head_group_spec: HeadGroupSpec + worker_group_spec: _containers.RepeatedCompositeFieldContainer[WorkerGroupSpec] + enable_autoscaling: bool + def __init__(self, head_group_spec: _Optional[_Union[HeadGroupSpec, _Mapping]] = ..., worker_group_spec: _Optional[_Iterable[_Union[WorkerGroupSpec, _Mapping]]] = ..., enable_autoscaling: bool = ...) -> None: ... + +class HeadGroupSpec(_message.Message): + __slots__ = ["ray_start_params", "k8s_pod"] + class RayStartParamsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + RAY_START_PARAMS_FIELD_NUMBER: _ClassVar[int] + K8S_POD_FIELD_NUMBER: _ClassVar[int] + ray_start_params: _containers.ScalarMap[str, str] + k8s_pod: _tasks_pb2.K8sPod + def __init__(self, ray_start_params: _Optional[_Mapping[str, str]] = ..., k8s_pod: _Optional[_Union[_tasks_pb2.K8sPod, _Mapping]] = ...) -> None: ... + +class WorkerGroupSpec(_message.Message): + __slots__ = ["group_name", "replicas", "min_replicas", "max_replicas", "ray_start_params", "k8s_pod"] + class RayStartParamsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + GROUP_NAME_FIELD_NUMBER: _ClassVar[int] + REPLICAS_FIELD_NUMBER: _ClassVar[int] + MIN_REPLICAS_FIELD_NUMBER: _ClassVar[int] + MAX_REPLICAS_FIELD_NUMBER: _ClassVar[int] + RAY_START_PARAMS_FIELD_NUMBER: _ClassVar[int] + K8S_POD_FIELD_NUMBER: _ClassVar[int] + group_name: str + replicas: int + min_replicas: int + max_replicas: int + ray_start_params: _containers.ScalarMap[str, str] + k8s_pod: _tasks_pb2.K8sPod + def __init__(self, group_name: _Optional[str] = ..., replicas: _Optional[int] = ..., min_replicas: _Optional[int] = ..., max_replicas: _Optional[int] = ..., ray_start_params: _Optional[_Mapping[str, str]] = ..., k8s_pod: _Optional[_Union[_tasks_pb2.K8sPod, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/plugins/ray_pb2_grpc.py b/gen/python/flyteidl2/plugins/ray_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/plugins/ray_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/plugins/spark_pb2.py b/gen/python/flyteidl2/plugins/spark_pb2.py new file mode 100644 index 0000000000..0b71326a27 --- /dev/null +++ b/gen/python/flyteidl2/plugins/spark_pb2.py @@ -0,0 +1,40 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/plugins/spark.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.core import tasks_pb2 as flyteidl2_dot_core_dot_tasks__pb2 +from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1d\x66lyteidl2/plugins/spark.proto\x12\x11\x66lyteidl2.plugins\x1a\x1a\x66lyteidl2/core/tasks.proto\x1a\x1cgoogle/protobuf/struct.proto\"B\n\x10SparkApplication\".\n\x04Type\x12\n\n\x06PYTHON\x10\x00\x12\x08\n\x04JAVA\x10\x01\x12\t\n\x05SCALA\x10\x02\x12\x05\n\x01R\x10\x03\"\xf1\x05\n\x08SparkJob\x12R\n\x0f\x61pplicationType\x18\x01 \x01(\x0e\x32(.flyteidl2.plugins.SparkApplication.TypeR\x0f\x61pplicationType\x12\x30\n\x13mainApplicationFile\x18\x02 \x01(\tR\x13mainApplicationFile\x12\x1c\n\tmainClass\x18\x03 \x01(\tR\tmainClass\x12H\n\tsparkConf\x18\x04 \x03(\x0b\x32*.flyteidl2.plugins.SparkJob.SparkConfEntryR\tsparkConf\x12K\n\nhadoopConf\x18\x05 \x03(\x0b\x32+.flyteidl2.plugins.SparkJob.HadoopConfEntryR\nhadoopConf\x12\"\n\x0c\x65xecutorPath\x18\x06 \x01(\tR\x0c\x65xecutorPath\x12?\n\x0e\x64\x61tabricksConf\x18\x07 \x01(\x0b\x32\x17.google.protobuf.StructR\x0e\x64\x61tabricksConf\x12(\n\x0f\x64\x61tabricksToken\x18\x08 \x01(\tR\x0f\x64\x61tabricksToken\x12.\n\x12\x64\x61tabricksInstance\x18\t \x01(\tR\x12\x64\x61tabricksInstance\x12\x34\n\tdriverPod\x18\n \x01(\x0b\x32\x16.flyteidl2.core.K8sPodR\tdriverPod\x12\x38\n\x0b\x65xecutorPod\x18\x0b \x01(\x0b\x32\x16.flyteidl2.core.K8sPodR\x0b\x65xecutorPod\x1a<\n\x0eSparkConfEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x1a=\n\x0fHadoopConfEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x42\xc1\x01\n\x15\x63om.flyteidl2.pluginsB\nSparkProtoH\x02P\x01Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins\xa2\x02\x03\x46PX\xaa\x02\x11\x46lyteidl2.Plugins\xca\x02\x11\x46lyteidl2\\Plugins\xe2\x02\x1d\x46lyteidl2\\Plugins\\GPBMetadata\xea\x02\x12\x46lyteidl2::Pluginsb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.plugins.spark_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\025com.flyteidl2.pluginsB\nSparkProtoH\002P\001Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins\242\002\003FPX\252\002\021Flyteidl2.Plugins\312\002\021Flyteidl2\\Plugins\342\002\035Flyteidl2\\Plugins\\GPBMetadata\352\002\022Flyteidl2::Plugins' + _SPARKJOB_SPARKCONFENTRY._options = None + _SPARKJOB_SPARKCONFENTRY._serialized_options = b'8\001' + _SPARKJOB_HADOOPCONFENTRY._options = None + _SPARKJOB_HADOOPCONFENTRY._serialized_options = b'8\001' + _globals['_SPARKAPPLICATION']._serialized_start=110 + _globals['_SPARKAPPLICATION']._serialized_end=176 + _globals['_SPARKAPPLICATION_TYPE']._serialized_start=130 + _globals['_SPARKAPPLICATION_TYPE']._serialized_end=176 + _globals['_SPARKJOB']._serialized_start=179 + _globals['_SPARKJOB']._serialized_end=932 + _globals['_SPARKJOB_SPARKCONFENTRY']._serialized_start=809 + _globals['_SPARKJOB_SPARKCONFENTRY']._serialized_end=869 + _globals['_SPARKJOB_HADOOPCONFENTRY']._serialized_start=871 + _globals['_SPARKJOB_HADOOPCONFENTRY']._serialized_end=932 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/plugins/spark_pb2.pyi b/gen/python/flyteidl2/plugins/spark_pb2.pyi new file mode 100644 index 0000000000..813c9b874e --- /dev/null +++ b/gen/python/flyteidl2/plugins/spark_pb2.pyi @@ -0,0 +1,63 @@ +from flyteidl2.core import tasks_pb2 as _tasks_pb2 +from google.protobuf import struct_pb2 as _struct_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class SparkApplication(_message.Message): + __slots__ = [] + class Type(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + PYTHON: _ClassVar[SparkApplication.Type] + JAVA: _ClassVar[SparkApplication.Type] + SCALA: _ClassVar[SparkApplication.Type] + R: _ClassVar[SparkApplication.Type] + PYTHON: SparkApplication.Type + JAVA: SparkApplication.Type + SCALA: SparkApplication.Type + R: SparkApplication.Type + def __init__(self) -> None: ... + +class SparkJob(_message.Message): + __slots__ = ["applicationType", "mainApplicationFile", "mainClass", "sparkConf", "hadoopConf", "executorPath", "databricksConf", "databricksToken", "databricksInstance", "driverPod", "executorPod"] + class SparkConfEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + class HadoopConfEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + APPLICATIONTYPE_FIELD_NUMBER: _ClassVar[int] + MAINAPPLICATIONFILE_FIELD_NUMBER: _ClassVar[int] + MAINCLASS_FIELD_NUMBER: _ClassVar[int] + SPARKCONF_FIELD_NUMBER: _ClassVar[int] + HADOOPCONF_FIELD_NUMBER: _ClassVar[int] + EXECUTORPATH_FIELD_NUMBER: _ClassVar[int] + DATABRICKSCONF_FIELD_NUMBER: _ClassVar[int] + DATABRICKSTOKEN_FIELD_NUMBER: _ClassVar[int] + DATABRICKSINSTANCE_FIELD_NUMBER: _ClassVar[int] + DRIVERPOD_FIELD_NUMBER: _ClassVar[int] + EXECUTORPOD_FIELD_NUMBER: _ClassVar[int] + applicationType: SparkApplication.Type + mainApplicationFile: str + mainClass: str + sparkConf: _containers.ScalarMap[str, str] + hadoopConf: _containers.ScalarMap[str, str] + executorPath: str + databricksConf: _struct_pb2.Struct + databricksToken: str + databricksInstance: str + driverPod: _tasks_pb2.K8sPod + executorPod: _tasks_pb2.K8sPod + def __init__(self, applicationType: _Optional[_Union[SparkApplication.Type, str]] = ..., mainApplicationFile: _Optional[str] = ..., mainClass: _Optional[str] = ..., sparkConf: _Optional[_Mapping[str, str]] = ..., hadoopConf: _Optional[_Mapping[str, str]] = ..., executorPath: _Optional[str] = ..., databricksConf: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., databricksToken: _Optional[str] = ..., databricksInstance: _Optional[str] = ..., driverPod: _Optional[_Union[_tasks_pb2.K8sPod, _Mapping]] = ..., executorPod: _Optional[_Union[_tasks_pb2.K8sPod, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/plugins/spark_pb2_grpc.py b/gen/python/flyteidl2/plugins/spark_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/plugins/spark_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/plugins/tensorflow_pb2.py b/gen/python/flyteidl2/plugins/tensorflow_pb2.py new file mode 100644 index 0000000000..65c56353b1 --- /dev/null +++ b/gen/python/flyteidl2/plugins/tensorflow_pb2.py @@ -0,0 +1,26 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/plugins/tensorflow.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\"flyteidl2/plugins/tensorflow.proto\x12\x11\x66lyteidl2.plugins\"\xb4\x01\n!DistributedTensorflowTrainingTask\x12\x18\n\x07workers\x18\x01 \x01(\x05R\x07workers\x12\x1f\n\x0bps_replicas\x18\x02 \x01(\x05R\npsReplicas\x12%\n\x0e\x63hief_replicas\x18\x03 \x01(\x05R\rchiefReplicas\x12-\n\x12\x65valuator_replicas\x18\x04 \x01(\x05R\x11\x65valuatorReplicasB\xc6\x01\n\x15\x63om.flyteidl2.pluginsB\x0fTensorflowProtoH\x02P\x01Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins\xa2\x02\x03\x46PX\xaa\x02\x11\x46lyteidl2.Plugins\xca\x02\x11\x46lyteidl2\\Plugins\xe2\x02\x1d\x46lyteidl2\\Plugins\\GPBMetadata\xea\x02\x12\x46lyteidl2::Pluginsb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.plugins.tensorflow_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\025com.flyteidl2.pluginsB\017TensorflowProtoH\002P\001Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/plugins\242\002\003FPX\252\002\021Flyteidl2.Plugins\312\002\021Flyteidl2\\Plugins\342\002\035Flyteidl2\\Plugins\\GPBMetadata\352\002\022Flyteidl2::Plugins' + _globals['_DISTRIBUTEDTENSORFLOWTRAININGTASK']._serialized_start=58 + _globals['_DISTRIBUTEDTENSORFLOWTRAININGTASK']._serialized_end=238 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/plugins/tensorflow_pb2.pyi b/gen/python/flyteidl2/plugins/tensorflow_pb2.pyi new file mode 100644 index 0000000000..81e2bc30b9 --- /dev/null +++ b/gen/python/flyteidl2/plugins/tensorflow_pb2.pyi @@ -0,0 +1,17 @@ +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Optional as _Optional + +DESCRIPTOR: _descriptor.FileDescriptor + +class DistributedTensorflowTrainingTask(_message.Message): + __slots__ = ["workers", "ps_replicas", "chief_replicas", "evaluator_replicas"] + WORKERS_FIELD_NUMBER: _ClassVar[int] + PS_REPLICAS_FIELD_NUMBER: _ClassVar[int] + CHIEF_REPLICAS_FIELD_NUMBER: _ClassVar[int] + EVALUATOR_REPLICAS_FIELD_NUMBER: _ClassVar[int] + workers: int + ps_replicas: int + chief_replicas: int + evaluator_replicas: int + def __init__(self, workers: _Optional[int] = ..., ps_replicas: _Optional[int] = ..., chief_replicas: _Optional[int] = ..., evaluator_replicas: _Optional[int] = ...) -> None: ... diff --git a/gen/python/flyteidl2/plugins/tensorflow_pb2_grpc.py b/gen/python/flyteidl2/plugins/tensorflow_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/plugins/tensorflow_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/project/__init__.py b/gen/python/flyteidl2/project/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/project/project_service_pb2.py b/gen/python/flyteidl2/project/project_service_pb2.py new file mode 100644 index 0000000000..4255addbf6 --- /dev/null +++ b/gen/python/flyteidl2/project/project_service_pb2.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/project/project_service.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.common import list_pb2 as flyteidl2_dot_common_dot_list__pb2 +from flyteidl2.task import run_pb2 as flyteidl2_dot_task_dot_run__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\'flyteidl2/project/project_service.proto\x12\x11\x66lyteidl2.project\x1a\x1b\x66lyteidl2/common/list.proto\x1a\x18\x66lyteidl2/task/run.proto\",\n\x06\x44omain\x12\x0e\n\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n\x04name\x18\x02 \x01(\tR\x04name\"\xfd\x01\n\x07Project\x12\x0e\n\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n\x04name\x18\x02 \x01(\tR\x04name\x12\x33\n\x07\x64omains\x18\x03 \x03(\x0b\x32\x19.flyteidl2.project.DomainR\x07\x64omains\x12 \n\x0b\x64\x65scription\x18\x04 \x01(\tR\x0b\x64\x65scription\x12.\n\x06labels\x18\x05 \x01(\x0b\x32\x16.flyteidl2.task.LabelsR\x06labels\x12\x35\n\x05state\x18\x06 \x01(\x0e\x32\x1f.flyteidl2.project.ProjectStateR\x05state\x12\x10\n\x03org\x18\x07 \x01(\tR\x03org\"X\n\x08Projects\x12\x36\n\x08projects\x18\x01 \x03(\x0b\x32\x1a.flyteidl2.project.ProjectR\x08projects\x12\x14\n\x05token\x18\x02 \x01(\tR\x05token\"L\n\x14\x43reateProjectRequest\x12\x34\n\x07project\x18\x01 \x01(\x0b\x32\x1a.flyteidl2.project.ProjectR\x07project\"\x17\n\x15\x43reateProjectResponse\"L\n\x14UpdateProjectRequest\x12\x34\n\x07project\x18\x01 \x01(\x0b\x32\x1a.flyteidl2.project.ProjectR\x07project\"\x17\n\x15UpdateProjectResponse\"5\n\x11GetProjectRequest\x12\x0e\n\x02id\x18\x01 \x01(\tR\x02id\x12\x10\n\x03org\x18\x02 \x01(\tR\x03org\"J\n\x12GetProjectResponse\x12\x34\n\x07project\x18\x01 \x01(\x0b\x32\x1a.flyteidl2.project.ProjectR\x07project\"\x9e\x01\n\x13ListProjectsRequest\x12\x14\n\x05limit\x18\x01 \x01(\rR\x05limit\x12\x14\n\x05token\x18\x02 \x01(\tR\x05token\x12\x18\n\x07\x66ilters\x18\x03 \x01(\tR\x07\x66ilters\x12/\n\x07sort_by\x18\x04 \x01(\x0b\x32\x16.flyteidl2.common.SortR\x06sortBy\x12\x10\n\x03org\x18\x05 \x01(\tR\x03org\"O\n\x14ListProjectsResponse\x12\x37\n\x08projects\x18\x01 \x01(\x0b\x32\x1b.flyteidl2.project.ProjectsR\x08projects*\x8b\x01\n\x0cProjectState\x12\x18\n\x14PROJECT_STATE_ACTIVE\x10\x00\x12\x1a\n\x16PROJECT_STATE_ARCHIVED\x10\x01\x12\"\n\x1ePROJECT_STATE_SYSTEM_GENERATED\x10\x02\x12!\n\x1dPROJECT_STATE_SYSTEM_ARCHIVED\x10\x03\x32\x9f\x03\n\x0eProjectService\x12\x64\n\rCreateProject\x12\'.flyteidl2.project.CreateProjectRequest\x1a(.flyteidl2.project.CreateProjectResponse\"\x00\x12\x64\n\rUpdateProject\x12\'.flyteidl2.project.UpdateProjectRequest\x1a(.flyteidl2.project.UpdateProjectResponse\"\x00\x12^\n\nGetProject\x12$.flyteidl2.project.GetProjectRequest\x1a%.flyteidl2.project.GetProjectResponse\"\x03\x90\x02\x01\x12\x61\n\x0cListProjects\x12&.flyteidl2.project.ListProjectsRequest\x1a\'.flyteidl2.project.ListProjectsResponse\"\x00\x42\xca\x01\n\x15\x63om.flyteidl2.projectB\x13ProjectServiceProtoH\x02P\x01Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/project\xa2\x02\x03\x46PX\xaa\x02\x11\x46lyteidl2.Project\xca\x02\x11\x46lyteidl2\\Project\xe2\x02\x1d\x46lyteidl2\\Project\\GPBMetadata\xea\x02\x12\x46lyteidl2::Projectb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.project.project_service_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\025com.flyteidl2.projectB\023ProjectServiceProtoH\002P\001Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/project\242\002\003FPX\252\002\021Flyteidl2.Project\312\002\021Flyteidl2\\Project\342\002\035Flyteidl2\\Project\\GPBMetadata\352\002\022Flyteidl2::Project' + _PROJECTSERVICE.methods_by_name['GetProject']._options = None + _PROJECTSERVICE.methods_by_name['GetProject']._serialized_options = b'\220\002\001' + _globals['_PROJECTSTATE']._serialized_start=1089 + _globals['_PROJECTSTATE']._serialized_end=1228 + _globals['_DOMAIN']._serialized_start=117 + _globals['_DOMAIN']._serialized_end=161 + _globals['_PROJECT']._serialized_start=164 + _globals['_PROJECT']._serialized_end=417 + _globals['_PROJECTS']._serialized_start=419 + _globals['_PROJECTS']._serialized_end=507 + _globals['_CREATEPROJECTREQUEST']._serialized_start=509 + _globals['_CREATEPROJECTREQUEST']._serialized_end=585 + _globals['_CREATEPROJECTRESPONSE']._serialized_start=587 + _globals['_CREATEPROJECTRESPONSE']._serialized_end=610 + _globals['_UPDATEPROJECTREQUEST']._serialized_start=612 + _globals['_UPDATEPROJECTREQUEST']._serialized_end=688 + _globals['_UPDATEPROJECTRESPONSE']._serialized_start=690 + _globals['_UPDATEPROJECTRESPONSE']._serialized_end=713 + _globals['_GETPROJECTREQUEST']._serialized_start=715 + _globals['_GETPROJECTREQUEST']._serialized_end=768 + _globals['_GETPROJECTRESPONSE']._serialized_start=770 + _globals['_GETPROJECTRESPONSE']._serialized_end=844 + _globals['_LISTPROJECTSREQUEST']._serialized_start=847 + _globals['_LISTPROJECTSREQUEST']._serialized_end=1005 + _globals['_LISTPROJECTSRESPONSE']._serialized_start=1007 + _globals['_LISTPROJECTSRESPONSE']._serialized_end=1086 + _globals['_PROJECTSERVICE']._serialized_start=1231 + _globals['_PROJECTSERVICE']._serialized_end=1646 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/project/project_service_pb2.pyi b/gen/python/flyteidl2/project/project_service_pb2.pyi new file mode 100644 index 0000000000..b306c33619 --- /dev/null +++ b/gen/python/flyteidl2/project/project_service_pb2.pyi @@ -0,0 +1,108 @@ +from flyteidl2.common import list_pb2 as _list_pb2 +from flyteidl2.task import run_pb2 as _run_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class ProjectState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + PROJECT_STATE_ACTIVE: _ClassVar[ProjectState] + PROJECT_STATE_ARCHIVED: _ClassVar[ProjectState] + PROJECT_STATE_SYSTEM_GENERATED: _ClassVar[ProjectState] + PROJECT_STATE_SYSTEM_ARCHIVED: _ClassVar[ProjectState] +PROJECT_STATE_ACTIVE: ProjectState +PROJECT_STATE_ARCHIVED: ProjectState +PROJECT_STATE_SYSTEM_GENERATED: ProjectState +PROJECT_STATE_SYSTEM_ARCHIVED: ProjectState + +class Domain(_message.Message): + __slots__ = ["id", "name"] + ID_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + id: str + name: str + def __init__(self, id: _Optional[str] = ..., name: _Optional[str] = ...) -> None: ... + +class Project(_message.Message): + __slots__ = ["id", "name", "domains", "description", "labels", "state", "org"] + ID_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + DOMAINS_FIELD_NUMBER: _ClassVar[int] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + LABELS_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + ORG_FIELD_NUMBER: _ClassVar[int] + id: str + name: str + domains: _containers.RepeatedCompositeFieldContainer[Domain] + description: str + labels: _run_pb2.Labels + state: ProjectState + org: str + def __init__(self, id: _Optional[str] = ..., name: _Optional[str] = ..., domains: _Optional[_Iterable[_Union[Domain, _Mapping]]] = ..., description: _Optional[str] = ..., labels: _Optional[_Union[_run_pb2.Labels, _Mapping]] = ..., state: _Optional[_Union[ProjectState, str]] = ..., org: _Optional[str] = ...) -> None: ... + +class Projects(_message.Message): + __slots__ = ["projects", "token"] + PROJECTS_FIELD_NUMBER: _ClassVar[int] + TOKEN_FIELD_NUMBER: _ClassVar[int] + projects: _containers.RepeatedCompositeFieldContainer[Project] + token: str + def __init__(self, projects: _Optional[_Iterable[_Union[Project, _Mapping]]] = ..., token: _Optional[str] = ...) -> None: ... + +class CreateProjectRequest(_message.Message): + __slots__ = ["project"] + PROJECT_FIELD_NUMBER: _ClassVar[int] + project: Project + def __init__(self, project: _Optional[_Union[Project, _Mapping]] = ...) -> None: ... + +class CreateProjectResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class UpdateProjectRequest(_message.Message): + __slots__ = ["project"] + PROJECT_FIELD_NUMBER: _ClassVar[int] + project: Project + def __init__(self, project: _Optional[_Union[Project, _Mapping]] = ...) -> None: ... + +class UpdateProjectResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class GetProjectRequest(_message.Message): + __slots__ = ["id", "org"] + ID_FIELD_NUMBER: _ClassVar[int] + ORG_FIELD_NUMBER: _ClassVar[int] + id: str + org: str + def __init__(self, id: _Optional[str] = ..., org: _Optional[str] = ...) -> None: ... + +class GetProjectResponse(_message.Message): + __slots__ = ["project"] + PROJECT_FIELD_NUMBER: _ClassVar[int] + project: Project + def __init__(self, project: _Optional[_Union[Project, _Mapping]] = ...) -> None: ... + +class ListProjectsRequest(_message.Message): + __slots__ = ["limit", "token", "filters", "sort_by", "org"] + LIMIT_FIELD_NUMBER: _ClassVar[int] + TOKEN_FIELD_NUMBER: _ClassVar[int] + FILTERS_FIELD_NUMBER: _ClassVar[int] + SORT_BY_FIELD_NUMBER: _ClassVar[int] + ORG_FIELD_NUMBER: _ClassVar[int] + limit: int + token: str + filters: str + sort_by: _list_pb2.Sort + org: str + def __init__(self, limit: _Optional[int] = ..., token: _Optional[str] = ..., filters: _Optional[str] = ..., sort_by: _Optional[_Union[_list_pb2.Sort, _Mapping]] = ..., org: _Optional[str] = ...) -> None: ... + +class ListProjectsResponse(_message.Message): + __slots__ = ["projects"] + PROJECTS_FIELD_NUMBER: _ClassVar[int] + projects: Projects + def __init__(self, projects: _Optional[_Union[Projects, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/project/project_service_pb2_grpc.py b/gen/python/flyteidl2/project/project_service_pb2_grpc.py new file mode 100644 index 0000000000..877a220ceb --- /dev/null +++ b/gen/python/flyteidl2/project/project_service_pb2_grpc.py @@ -0,0 +1,166 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from flyteidl2.project import project_service_pb2 as flyteidl2_dot_project_dot_project__service__pb2 + + +class ProjectServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.CreateProject = channel.unary_unary( + '/flyteidl2.project.ProjectService/CreateProject', + request_serializer=flyteidl2_dot_project_dot_project__service__pb2.CreateProjectRequest.SerializeToString, + response_deserializer=flyteidl2_dot_project_dot_project__service__pb2.CreateProjectResponse.FromString, + ) + self.UpdateProject = channel.unary_unary( + '/flyteidl2.project.ProjectService/UpdateProject', + request_serializer=flyteidl2_dot_project_dot_project__service__pb2.UpdateProjectRequest.SerializeToString, + response_deserializer=flyteidl2_dot_project_dot_project__service__pb2.UpdateProjectResponse.FromString, + ) + self.GetProject = channel.unary_unary( + '/flyteidl2.project.ProjectService/GetProject', + request_serializer=flyteidl2_dot_project_dot_project__service__pb2.GetProjectRequest.SerializeToString, + response_deserializer=flyteidl2_dot_project_dot_project__service__pb2.GetProjectResponse.FromString, + ) + self.ListProjects = channel.unary_unary( + '/flyteidl2.project.ProjectService/ListProjects', + request_serializer=flyteidl2_dot_project_dot_project__service__pb2.ListProjectsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_project_dot_project__service__pb2.ListProjectsResponse.FromString, + ) + + +class ProjectServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def CreateProject(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateProject(self, request, context): + """it will be ignored in the handler as domains cannot be updated via this API. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetProject(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListProjects(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_ProjectServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'CreateProject': grpc.unary_unary_rpc_method_handler( + servicer.CreateProject, + request_deserializer=flyteidl2_dot_project_dot_project__service__pb2.CreateProjectRequest.FromString, + response_serializer=flyteidl2_dot_project_dot_project__service__pb2.CreateProjectResponse.SerializeToString, + ), + 'UpdateProject': grpc.unary_unary_rpc_method_handler( + servicer.UpdateProject, + request_deserializer=flyteidl2_dot_project_dot_project__service__pb2.UpdateProjectRequest.FromString, + response_serializer=flyteidl2_dot_project_dot_project__service__pb2.UpdateProjectResponse.SerializeToString, + ), + 'GetProject': grpc.unary_unary_rpc_method_handler( + servicer.GetProject, + request_deserializer=flyteidl2_dot_project_dot_project__service__pb2.GetProjectRequest.FromString, + response_serializer=flyteidl2_dot_project_dot_project__service__pb2.GetProjectResponse.SerializeToString, + ), + 'ListProjects': grpc.unary_unary_rpc_method_handler( + servicer.ListProjects, + request_deserializer=flyteidl2_dot_project_dot_project__service__pb2.ListProjectsRequest.FromString, + response_serializer=flyteidl2_dot_project_dot_project__service__pb2.ListProjectsResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.project.ProjectService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class ProjectService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def CreateProject(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.project.ProjectService/CreateProject', + flyteidl2_dot_project_dot_project__service__pb2.CreateProjectRequest.SerializeToString, + flyteidl2_dot_project_dot_project__service__pb2.CreateProjectResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def UpdateProject(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.project.ProjectService/UpdateProject', + flyteidl2_dot_project_dot_project__service__pb2.UpdateProjectRequest.SerializeToString, + flyteidl2_dot_project_dot_project__service__pb2.UpdateProjectResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetProject(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.project.ProjectService/GetProject', + flyteidl2_dot_project_dot_project__service__pb2.GetProjectRequest.SerializeToString, + flyteidl2_dot_project_dot_project__service__pb2.GetProjectResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListProjects(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.project.ProjectService/ListProjects', + flyteidl2_dot_project_dot_project__service__pb2.ListProjectsRequest.SerializeToString, + flyteidl2_dot_project_dot_project__service__pb2.ListProjectsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/gen/python/flyteidl2/secret/__init__.py b/gen/python/flyteidl2/secret/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/secret/definition_pb2.py b/gen/python/flyteidl2/secret/definition_pb2.py new file mode 100644 index 0000000000..42aa8f5714 --- /dev/null +++ b/gen/python/flyteidl2/secret/definition_pb2.py @@ -0,0 +1,49 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/secret/definition.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.common import identifier_pb2 as flyteidl2_dot_common_dot_identifier__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n!flyteidl2/secret/definition.proto\x12\x10\x66lyteidl2.secret\x1a\x1b\x62uf/validate/validate.proto\x1a!flyteidl2/common/identifier.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\x98\x01\n\nSecretSpec\x12#\n\x0cstring_value\x18\x01 \x01(\tH\x00R\x0bstringValue\x12#\n\x0c\x62inary_value\x18\x02 \x01(\x0cH\x00R\x0b\x62inaryValue\x12\x30\n\x04type\x18\x03 \x01(\x0e\x32\x1c.flyteidl2.secret.SecretTypeR\x04typeB\x0e\n\x05value\x12\x05\xbaH\x02\x08\x01\"\x97\x01\n\x10SecretIdentifier\x12-\n\x04name\x18\x01 \x01(\tB\x19\xbaH\x16r\x14\x10\x01\x32\x10^[-a-zA-Z0-9_]+$R\x04name\x12\"\n\x0corganization\x18\x02 \x01(\tR\x0corganization\x12\x16\n\x06\x64omain\x18\x03 \x01(\tR\x06\x64omain\x12\x18\n\x07project\x18\x04 \x01(\tR\x07project\"\xc6\x01\n\x0eSecretMetadata\x12=\n\x0c\x63reated_time\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x0b\x63reatedTime\x12\x43\n\rsecret_status\x18\x02 \x01(\x0b\x32\x1e.flyteidl2.secret.SecretStatusR\x0csecretStatus\x12\x30\n\x04type\x18\x03 \x01(\x0e\x32\x1c.flyteidl2.secret.SecretTypeR\x04type\"\xa4\x01\n\x0cSecretStatus\x12\x46\n\x0eoverall_status\x18\x01 \x01(\x0e\x32\x1f.flyteidl2.secret.OverallStatusR\roverallStatus\x12L\n\x0e\x63luster_status\x18\x02 \x03(\x0b\x32%.flyteidl2.secret.ClusterSecretStatusR\rclusterStatus\"\xa5\x01\n\x13\x43lusterSecretStatus\x12=\n\x07\x63luster\x18\x01 \x01(\x0b\x32#.flyteidl2.common.ClusterIdentifierR\x07\x63luster\x12O\n\x0fpresence_status\x18\x02 \x01(\x0e\x32&.flyteidl2.secret.SecretPresenceStatusR\x0epresenceStatus\"\x87\x01\n\x06Secret\x12\x32\n\x02id\x18\x01 \x01(\x0b\x32\".flyteidl2.secret.SecretIdentifierR\x02id\x12I\n\x0fsecret_metadata\x18\x02 \x01(\x0b\x32 .flyteidl2.secret.SecretMetadataR\x0esecretMetadata*H\n\nSecretType\x12\x17\n\x13SECRET_TYPE_GENERIC\x10\x00\x12!\n\x1dSECRET_TYPE_IMAGE_PULL_SECRET\x10\x01*^\n\rOverallStatus\x12\x0f\n\x0bUNSPECIFIED\x10\x00\x12\x15\n\x11PARTIALLY_PRESENT\x10\x01\x12\x11\n\rFULLY_PRESENT\x10\x02\x12\x12\n\x0eUNKNOWN_STATUS\x10\x03*=\n\x14SecretPresenceStatus\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0b\n\x07MISSING\x10\x01\x12\x0b\n\x07PRESENT\x10\x02\x42\xc0\x01\n\x14\x63om.flyteidl2.secretB\x0f\x44\x65\x66initionProtoH\x02P\x01Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/secret\xa2\x02\x03\x46SX\xaa\x02\x10\x46lyteidl2.Secret\xca\x02\x10\x46lyteidl2\\Secret\xe2\x02\x1c\x46lyteidl2\\Secret\\GPBMetadata\xea\x02\x11\x46lyteidl2::Secretb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.secret.definition_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\024com.flyteidl2.secretB\017DefinitionProtoH\002P\001Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/secret\242\002\003FSX\252\002\020Flyteidl2.Secret\312\002\020Flyteidl2\\Secret\342\002\034Flyteidl2\\Secret\\GPBMetadata\352\002\021Flyteidl2::Secret' + _SECRETSPEC.oneofs_by_name['value']._options = None + _SECRETSPEC.oneofs_by_name['value']._serialized_options = b'\272H\002\010\001' + _SECRETIDENTIFIER.fields_by_name['name']._options = None + _SECRETIDENTIFIER.fields_by_name['name']._serialized_options = b'\272H\026r\024\020\0012\020^[-a-zA-Z0-9_]+$' + _globals['_SECRETTYPE']._serialized_start=1135 + _globals['_SECRETTYPE']._serialized_end=1207 + _globals['_OVERALLSTATUS']._serialized_start=1209 + _globals['_OVERALLSTATUS']._serialized_end=1303 + _globals['_SECRETPRESENCESTATUS']._serialized_start=1305 + _globals['_SECRETPRESENCESTATUS']._serialized_end=1366 + _globals['_SECRETSPEC']._serialized_start=153 + _globals['_SECRETSPEC']._serialized_end=305 + _globals['_SECRETIDENTIFIER']._serialized_start=308 + _globals['_SECRETIDENTIFIER']._serialized_end=459 + _globals['_SECRETMETADATA']._serialized_start=462 + _globals['_SECRETMETADATA']._serialized_end=660 + _globals['_SECRETSTATUS']._serialized_start=663 + _globals['_SECRETSTATUS']._serialized_end=827 + _globals['_CLUSTERSECRETSTATUS']._serialized_start=830 + _globals['_CLUSTERSECRETSTATUS']._serialized_end=995 + _globals['_SECRET']._serialized_start=998 + _globals['_SECRET']._serialized_end=1133 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/secret/definition_pb2.pyi b/gen/python/flyteidl2/secret/definition_pb2.pyi new file mode 100644 index 0000000000..a65fa879d4 --- /dev/null +++ b/gen/python/flyteidl2/secret/definition_pb2.pyi @@ -0,0 +1,93 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.common import identifier_pb2 as _identifier_pb2 +from google.protobuf import timestamp_pb2 as _timestamp_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class SecretType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + SECRET_TYPE_GENERIC: _ClassVar[SecretType] + SECRET_TYPE_IMAGE_PULL_SECRET: _ClassVar[SecretType] + +class OverallStatus(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + UNSPECIFIED: _ClassVar[OverallStatus] + PARTIALLY_PRESENT: _ClassVar[OverallStatus] + FULLY_PRESENT: _ClassVar[OverallStatus] + UNKNOWN_STATUS: _ClassVar[OverallStatus] + +class SecretPresenceStatus(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + UNKNOWN: _ClassVar[SecretPresenceStatus] + MISSING: _ClassVar[SecretPresenceStatus] + PRESENT: _ClassVar[SecretPresenceStatus] +SECRET_TYPE_GENERIC: SecretType +SECRET_TYPE_IMAGE_PULL_SECRET: SecretType +UNSPECIFIED: OverallStatus +PARTIALLY_PRESENT: OverallStatus +FULLY_PRESENT: OverallStatus +UNKNOWN_STATUS: OverallStatus +UNKNOWN: SecretPresenceStatus +MISSING: SecretPresenceStatus +PRESENT: SecretPresenceStatus + +class SecretSpec(_message.Message): + __slots__ = ["string_value", "binary_value", "type"] + STRING_VALUE_FIELD_NUMBER: _ClassVar[int] + BINARY_VALUE_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + string_value: str + binary_value: bytes + type: SecretType + def __init__(self, string_value: _Optional[str] = ..., binary_value: _Optional[bytes] = ..., type: _Optional[_Union[SecretType, str]] = ...) -> None: ... + +class SecretIdentifier(_message.Message): + __slots__ = ["name", "organization", "domain", "project"] + NAME_FIELD_NUMBER: _ClassVar[int] + ORGANIZATION_FIELD_NUMBER: _ClassVar[int] + DOMAIN_FIELD_NUMBER: _ClassVar[int] + PROJECT_FIELD_NUMBER: _ClassVar[int] + name: str + organization: str + domain: str + project: str + def __init__(self, name: _Optional[str] = ..., organization: _Optional[str] = ..., domain: _Optional[str] = ..., project: _Optional[str] = ...) -> None: ... + +class SecretMetadata(_message.Message): + __slots__ = ["created_time", "secret_status", "type"] + CREATED_TIME_FIELD_NUMBER: _ClassVar[int] + SECRET_STATUS_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + created_time: _timestamp_pb2.Timestamp + secret_status: SecretStatus + type: SecretType + def __init__(self, created_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., secret_status: _Optional[_Union[SecretStatus, _Mapping]] = ..., type: _Optional[_Union[SecretType, str]] = ...) -> None: ... + +class SecretStatus(_message.Message): + __slots__ = ["overall_status", "cluster_status"] + OVERALL_STATUS_FIELD_NUMBER: _ClassVar[int] + CLUSTER_STATUS_FIELD_NUMBER: _ClassVar[int] + overall_status: OverallStatus + cluster_status: _containers.RepeatedCompositeFieldContainer[ClusterSecretStatus] + def __init__(self, overall_status: _Optional[_Union[OverallStatus, str]] = ..., cluster_status: _Optional[_Iterable[_Union[ClusterSecretStatus, _Mapping]]] = ...) -> None: ... + +class ClusterSecretStatus(_message.Message): + __slots__ = ["cluster", "presence_status"] + CLUSTER_FIELD_NUMBER: _ClassVar[int] + PRESENCE_STATUS_FIELD_NUMBER: _ClassVar[int] + cluster: _identifier_pb2.ClusterIdentifier + presence_status: SecretPresenceStatus + def __init__(self, cluster: _Optional[_Union[_identifier_pb2.ClusterIdentifier, _Mapping]] = ..., presence_status: _Optional[_Union[SecretPresenceStatus, str]] = ...) -> None: ... + +class Secret(_message.Message): + __slots__ = ["id", "secret_metadata"] + ID_FIELD_NUMBER: _ClassVar[int] + SECRET_METADATA_FIELD_NUMBER: _ClassVar[int] + id: SecretIdentifier + secret_metadata: SecretMetadata + def __init__(self, id: _Optional[_Union[SecretIdentifier, _Mapping]] = ..., secret_metadata: _Optional[_Union[SecretMetadata, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/secret/definition_pb2_grpc.py b/gen/python/flyteidl2/secret/definition_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/secret/definition_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/secret/payload_pb2.py b/gen/python/flyteidl2/secret/payload_pb2.py new file mode 100644 index 0000000000..290b403727 --- /dev/null +++ b/gen/python/flyteidl2/secret/payload_pb2.py @@ -0,0 +1,62 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/secret/payload.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.secret import definition_pb2 as flyteidl2_dot_secret_dot_definition__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1e\x66lyteidl2/secret/payload.proto\x12\x10\x66lyteidl2.secret\x1a\x1b\x62uf/validate/validate.proto\x1a!flyteidl2/secret/definition.proto\"\x90\x01\n\x13\x43reateSecretRequest\x12:\n\x02id\x18\x01 \x01(\x0b\x32\".flyteidl2.secret.SecretIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x02id\x12=\n\x0bsecret_spec\x18\x02 \x01(\x0b\x32\x1c.flyteidl2.secret.SecretSpecR\nsecretSpec\"\x16\n\x14\x43reateSecretResponse\"\x90\x01\n\x13UpdateSecretRequest\x12:\n\x02id\x18\x01 \x01(\x0b\x32\".flyteidl2.secret.SecretIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x02id\x12=\n\x0bsecret_spec\x18\x02 \x01(\x0b\x32\x1c.flyteidl2.secret.SecretSpecR\nsecretSpec\"\x16\n\x14UpdateSecretResponse\"N\n\x10GetSecretRequest\x12:\n\x02id\x18\x01 \x01(\x0b\x32\".flyteidl2.secret.SecretIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x02id\"E\n\x11GetSecretResponse\x12\x30\n\x06secret\x18\x01 \x01(\x0b\x32\x18.flyteidl2.secret.SecretR\x06secret\"Q\n\x13\x44\x65leteSecretRequest\x12:\n\x02id\x18\x01 \x01(\x0b\x32\".flyteidl2.secret.SecretIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x02id\"\x16\n\x14\x44\x65leteSecretResponse\"\xc5\x02\n\x12ListSecretsRequest\x12\"\n\x0corganization\x18\x01 \x01(\tR\x0corganization\x12\x16\n\x06\x64omain\x18\x02 \x01(\tR\x06\x64omain\x12\x18\n\x07project\x18\x03 \x01(\tR\x07project\x12\x14\n\x05limit\x18\x04 \x01(\x05R\x05limit\x12\x14\n\x05token\x18\x05 \x01(\tR\x05token\x12h\n\x12per_cluster_tokens\x18\x06 \x03(\x0b\x32:.flyteidl2.secret.ListSecretsRequest.PerClusterTokensEntryR\x10perClusterTokens\x1a\x43\n\x15PerClusterTokensEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\x8f\x02\n\x13ListSecretsResponse\x12\x32\n\x07secrets\x18\x01 \x03(\x0b\x32\x18.flyteidl2.secret.SecretR\x07secrets\x12\x14\n\x05token\x18\x02 \x01(\tR\x05token\x12i\n\x12per_cluster_tokens\x18\x03 \x03(\x0b\x32;.flyteidl2.secret.ListSecretsResponse.PerClusterTokensEntryR\x10perClusterTokens\x1a\x43\n\x15PerClusterTokensEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x42\xbd\x01\n\x14\x63om.flyteidl2.secretB\x0cPayloadProtoH\x02P\x01Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/secret\xa2\x02\x03\x46SX\xaa\x02\x10\x46lyteidl2.Secret\xca\x02\x10\x46lyteidl2\\Secret\xe2\x02\x1c\x46lyteidl2\\Secret\\GPBMetadata\xea\x02\x11\x46lyteidl2::Secretb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.secret.payload_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\024com.flyteidl2.secretB\014PayloadProtoH\002P\001Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/secret\242\002\003FSX\252\002\020Flyteidl2.Secret\312\002\020Flyteidl2\\Secret\342\002\034Flyteidl2\\Secret\\GPBMetadata\352\002\021Flyteidl2::Secret' + _CREATESECRETREQUEST.fields_by_name['id']._options = None + _CREATESECRETREQUEST.fields_by_name['id']._serialized_options = b'\272H\003\310\001\001' + _UPDATESECRETREQUEST.fields_by_name['id']._options = None + _UPDATESECRETREQUEST.fields_by_name['id']._serialized_options = b'\272H\003\310\001\001' + _GETSECRETREQUEST.fields_by_name['id']._options = None + _GETSECRETREQUEST.fields_by_name['id']._serialized_options = b'\272H\003\310\001\001' + _DELETESECRETREQUEST.fields_by_name['id']._options = None + _DELETESECRETREQUEST.fields_by_name['id']._serialized_options = b'\272H\003\310\001\001' + _LISTSECRETSREQUEST_PERCLUSTERTOKENSENTRY._options = None + _LISTSECRETSREQUEST_PERCLUSTERTOKENSENTRY._serialized_options = b'8\001' + _LISTSECRETSRESPONSE_PERCLUSTERTOKENSENTRY._options = None + _LISTSECRETSRESPONSE_PERCLUSTERTOKENSENTRY._serialized_options = b'8\001' + _globals['_CREATESECRETREQUEST']._serialized_start=117 + _globals['_CREATESECRETREQUEST']._serialized_end=261 + _globals['_CREATESECRETRESPONSE']._serialized_start=263 + _globals['_CREATESECRETRESPONSE']._serialized_end=285 + _globals['_UPDATESECRETREQUEST']._serialized_start=288 + _globals['_UPDATESECRETREQUEST']._serialized_end=432 + _globals['_UPDATESECRETRESPONSE']._serialized_start=434 + _globals['_UPDATESECRETRESPONSE']._serialized_end=456 + _globals['_GETSECRETREQUEST']._serialized_start=458 + _globals['_GETSECRETREQUEST']._serialized_end=536 + _globals['_GETSECRETRESPONSE']._serialized_start=538 + _globals['_GETSECRETRESPONSE']._serialized_end=607 + _globals['_DELETESECRETREQUEST']._serialized_start=609 + _globals['_DELETESECRETREQUEST']._serialized_end=690 + _globals['_DELETESECRETRESPONSE']._serialized_start=692 + _globals['_DELETESECRETRESPONSE']._serialized_end=714 + _globals['_LISTSECRETSREQUEST']._serialized_start=717 + _globals['_LISTSECRETSREQUEST']._serialized_end=1042 + _globals['_LISTSECRETSREQUEST_PERCLUSTERTOKENSENTRY']._serialized_start=975 + _globals['_LISTSECRETSREQUEST_PERCLUSTERTOKENSENTRY']._serialized_end=1042 + _globals['_LISTSECRETSRESPONSE']._serialized_start=1045 + _globals['_LISTSECRETSRESPONSE']._serialized_end=1316 + _globals['_LISTSECRETSRESPONSE_PERCLUSTERTOKENSENTRY']._serialized_start=975 + _globals['_LISTSECRETSRESPONSE_PERCLUSTERTOKENSENTRY']._serialized_end=1042 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/secret/payload_pb2.pyi b/gen/python/flyteidl2/secret/payload_pb2.pyi new file mode 100644 index 0000000000..b7327b198a --- /dev/null +++ b/gen/python/flyteidl2/secret/payload_pb2.pyi @@ -0,0 +1,94 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.secret import definition_pb2 as _definition_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class CreateSecretRequest(_message.Message): + __slots__ = ["id", "secret_spec"] + ID_FIELD_NUMBER: _ClassVar[int] + SECRET_SPEC_FIELD_NUMBER: _ClassVar[int] + id: _definition_pb2.SecretIdentifier + secret_spec: _definition_pb2.SecretSpec + def __init__(self, id: _Optional[_Union[_definition_pb2.SecretIdentifier, _Mapping]] = ..., secret_spec: _Optional[_Union[_definition_pb2.SecretSpec, _Mapping]] = ...) -> None: ... + +class CreateSecretResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class UpdateSecretRequest(_message.Message): + __slots__ = ["id", "secret_spec"] + ID_FIELD_NUMBER: _ClassVar[int] + SECRET_SPEC_FIELD_NUMBER: _ClassVar[int] + id: _definition_pb2.SecretIdentifier + secret_spec: _definition_pb2.SecretSpec + def __init__(self, id: _Optional[_Union[_definition_pb2.SecretIdentifier, _Mapping]] = ..., secret_spec: _Optional[_Union[_definition_pb2.SecretSpec, _Mapping]] = ...) -> None: ... + +class UpdateSecretResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class GetSecretRequest(_message.Message): + __slots__ = ["id"] + ID_FIELD_NUMBER: _ClassVar[int] + id: _definition_pb2.SecretIdentifier + def __init__(self, id: _Optional[_Union[_definition_pb2.SecretIdentifier, _Mapping]] = ...) -> None: ... + +class GetSecretResponse(_message.Message): + __slots__ = ["secret"] + SECRET_FIELD_NUMBER: _ClassVar[int] + secret: _definition_pb2.Secret + def __init__(self, secret: _Optional[_Union[_definition_pb2.Secret, _Mapping]] = ...) -> None: ... + +class DeleteSecretRequest(_message.Message): + __slots__ = ["id"] + ID_FIELD_NUMBER: _ClassVar[int] + id: _definition_pb2.SecretIdentifier + def __init__(self, id: _Optional[_Union[_definition_pb2.SecretIdentifier, _Mapping]] = ...) -> None: ... + +class DeleteSecretResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class ListSecretsRequest(_message.Message): + __slots__ = ["organization", "domain", "project", "limit", "token", "per_cluster_tokens"] + class PerClusterTokensEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + ORGANIZATION_FIELD_NUMBER: _ClassVar[int] + DOMAIN_FIELD_NUMBER: _ClassVar[int] + PROJECT_FIELD_NUMBER: _ClassVar[int] + LIMIT_FIELD_NUMBER: _ClassVar[int] + TOKEN_FIELD_NUMBER: _ClassVar[int] + PER_CLUSTER_TOKENS_FIELD_NUMBER: _ClassVar[int] + organization: str + domain: str + project: str + limit: int + token: str + per_cluster_tokens: _containers.ScalarMap[str, str] + def __init__(self, organization: _Optional[str] = ..., domain: _Optional[str] = ..., project: _Optional[str] = ..., limit: _Optional[int] = ..., token: _Optional[str] = ..., per_cluster_tokens: _Optional[_Mapping[str, str]] = ...) -> None: ... + +class ListSecretsResponse(_message.Message): + __slots__ = ["secrets", "token", "per_cluster_tokens"] + class PerClusterTokensEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + SECRETS_FIELD_NUMBER: _ClassVar[int] + TOKEN_FIELD_NUMBER: _ClassVar[int] + PER_CLUSTER_TOKENS_FIELD_NUMBER: _ClassVar[int] + secrets: _containers.RepeatedCompositeFieldContainer[_definition_pb2.Secret] + token: str + per_cluster_tokens: _containers.ScalarMap[str, str] + def __init__(self, secrets: _Optional[_Iterable[_Union[_definition_pb2.Secret, _Mapping]]] = ..., token: _Optional[str] = ..., per_cluster_tokens: _Optional[_Mapping[str, str]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/secret/payload_pb2_grpc.py b/gen/python/flyteidl2/secret/payload_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/secret/payload_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/secret/secret_pb2.py b/gen/python/flyteidl2/secret/secret_pb2.py new file mode 100644 index 0000000000..caa83e538b --- /dev/null +++ b/gen/python/flyteidl2/secret/secret_pb2.py @@ -0,0 +1,38 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/secret/secret.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.secret import payload_pb2 as flyteidl2_dot_secret_dot_payload__pb2 +from google.api import annotations_pb2 as google_dot_api_dot_annotations__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1d\x66lyteidl2/secret/secret.proto\x12\x10\x66lyteidl2.secret\x1a\x1e\x66lyteidl2/secret/payload.proto\x1a\x1cgoogle/api/annotations.proto2\x90\x05\n\rSecretService\x12y\n\x0c\x43reateSecret\x12%.flyteidl2.secret.CreateSecretRequest\x1a&.flyteidl2.secret.CreateSecretResponse\"\x1a\x82\xd3\xe4\x93\x02\x14\"\x0f/secrets/api/v1:\x01*\x12\x88\x01\n\x0cUpdateSecret\x12%.flyteidl2.secret.UpdateSecretRequest\x1a&.flyteidl2.secret.UpdateSecretResponse\")\x82\xd3\xe4\x93\x02#\x1a\x1e/secrets/api/v1/name/{id.name}:\x01*\x12|\n\tGetSecret\x12\".flyteidl2.secret.GetSecretRequest\x1a#.flyteidl2.secret.GetSecretResponse\"&\x82\xd3\xe4\x93\x02 \x12\x1e/secrets/api/v1/name/{id.name}\x12\x85\x01\n\x0c\x44\x65leteSecret\x12%.flyteidl2.secret.DeleteSecretRequest\x1a&.flyteidl2.secret.DeleteSecretResponse\"&\x82\xd3\xe4\x93\x02 *\x1e/secrets/api/v1/name/{id.name}\x12s\n\x0bListSecrets\x12$.flyteidl2.secret.ListSecretsRequest\x1a%.flyteidl2.secret.ListSecretsResponse\"\x17\x82\xd3\xe4\x93\x02\x11\x12\x0f/secrets/api/v1B\xbc\x01\n\x14\x63om.flyteidl2.secretB\x0bSecretProtoH\x02P\x01Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/secret\xa2\x02\x03\x46SX\xaa\x02\x10\x46lyteidl2.Secret\xca\x02\x10\x46lyteidl2\\Secret\xe2\x02\x1c\x46lyteidl2\\Secret\\GPBMetadata\xea\x02\x11\x46lyteidl2::Secretb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.secret.secret_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\024com.flyteidl2.secretB\013SecretProtoH\002P\001Z4github.com/flyteorg/flyte/v2/gen/go/flyteidl2/secret\242\002\003FSX\252\002\020Flyteidl2.Secret\312\002\020Flyteidl2\\Secret\342\002\034Flyteidl2\\Secret\\GPBMetadata\352\002\021Flyteidl2::Secret' + _SECRETSERVICE.methods_by_name['CreateSecret']._options = None + _SECRETSERVICE.methods_by_name['CreateSecret']._serialized_options = b'\202\323\344\223\002\024\"\017/secrets/api/v1:\001*' + _SECRETSERVICE.methods_by_name['UpdateSecret']._options = None + _SECRETSERVICE.methods_by_name['UpdateSecret']._serialized_options = b'\202\323\344\223\002#\032\036/secrets/api/v1/name/{id.name}:\001*' + _SECRETSERVICE.methods_by_name['GetSecret']._options = None + _SECRETSERVICE.methods_by_name['GetSecret']._serialized_options = b'\202\323\344\223\002 \022\036/secrets/api/v1/name/{id.name}' + _SECRETSERVICE.methods_by_name['DeleteSecret']._options = None + _SECRETSERVICE.methods_by_name['DeleteSecret']._serialized_options = b'\202\323\344\223\002 *\036/secrets/api/v1/name/{id.name}' + _SECRETSERVICE.methods_by_name['ListSecrets']._options = None + _SECRETSERVICE.methods_by_name['ListSecrets']._serialized_options = b'\202\323\344\223\002\021\022\017/secrets/api/v1' + _globals['_SECRETSERVICE']._serialized_start=114 + _globals['_SECRETSERVICE']._serialized_end=770 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/secret/secret_pb2.pyi b/gen/python/flyteidl2/secret/secret_pb2.pyi new file mode 100644 index 0000000000..e3c6975df2 --- /dev/null +++ b/gen/python/flyteidl2/secret/secret_pb2.pyi @@ -0,0 +1,6 @@ +from flyteidl2.secret import payload_pb2 as _payload_pb2 +from google.api import annotations_pb2 as _annotations_pb2 +from google.protobuf import descriptor as _descriptor +from typing import ClassVar as _ClassVar + +DESCRIPTOR: _descriptor.FileDescriptor diff --git a/gen/python/flyteidl2/secret/secret_pb2_grpc.py b/gen/python/flyteidl2/secret/secret_pb2_grpc.py new file mode 100644 index 0000000000..07a1c28973 --- /dev/null +++ b/gen/python/flyteidl2/secret/secret_pb2_grpc.py @@ -0,0 +1,198 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from flyteidl2.secret import payload_pb2 as flyteidl2_dot_secret_dot_payload__pb2 + + +class SecretServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.CreateSecret = channel.unary_unary( + '/flyteidl2.secret.SecretService/CreateSecret', + request_serializer=flyteidl2_dot_secret_dot_payload__pb2.CreateSecretRequest.SerializeToString, + response_deserializer=flyteidl2_dot_secret_dot_payload__pb2.CreateSecretResponse.FromString, + ) + self.UpdateSecret = channel.unary_unary( + '/flyteidl2.secret.SecretService/UpdateSecret', + request_serializer=flyteidl2_dot_secret_dot_payload__pb2.UpdateSecretRequest.SerializeToString, + response_deserializer=flyteidl2_dot_secret_dot_payload__pb2.UpdateSecretResponse.FromString, + ) + self.GetSecret = channel.unary_unary( + '/flyteidl2.secret.SecretService/GetSecret', + request_serializer=flyteidl2_dot_secret_dot_payload__pb2.GetSecretRequest.SerializeToString, + response_deserializer=flyteidl2_dot_secret_dot_payload__pb2.GetSecretResponse.FromString, + ) + self.DeleteSecret = channel.unary_unary( + '/flyteidl2.secret.SecretService/DeleteSecret', + request_serializer=flyteidl2_dot_secret_dot_payload__pb2.DeleteSecretRequest.SerializeToString, + response_deserializer=flyteidl2_dot_secret_dot_payload__pb2.DeleteSecretResponse.FromString, + ) + self.ListSecrets = channel.unary_unary( + '/flyteidl2.secret.SecretService/ListSecrets', + request_serializer=flyteidl2_dot_secret_dot_payload__pb2.ListSecretsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_secret_dot_payload__pb2.ListSecretsResponse.FromString, + ) + + +class SecretServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def CreateSecret(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateSecret(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetSecret(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DeleteSecret(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListSecrets(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_SecretServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'CreateSecret': grpc.unary_unary_rpc_method_handler( + servicer.CreateSecret, + request_deserializer=flyteidl2_dot_secret_dot_payload__pb2.CreateSecretRequest.FromString, + response_serializer=flyteidl2_dot_secret_dot_payload__pb2.CreateSecretResponse.SerializeToString, + ), + 'UpdateSecret': grpc.unary_unary_rpc_method_handler( + servicer.UpdateSecret, + request_deserializer=flyteidl2_dot_secret_dot_payload__pb2.UpdateSecretRequest.FromString, + response_serializer=flyteidl2_dot_secret_dot_payload__pb2.UpdateSecretResponse.SerializeToString, + ), + 'GetSecret': grpc.unary_unary_rpc_method_handler( + servicer.GetSecret, + request_deserializer=flyteidl2_dot_secret_dot_payload__pb2.GetSecretRequest.FromString, + response_serializer=flyteidl2_dot_secret_dot_payload__pb2.GetSecretResponse.SerializeToString, + ), + 'DeleteSecret': grpc.unary_unary_rpc_method_handler( + servicer.DeleteSecret, + request_deserializer=flyteidl2_dot_secret_dot_payload__pb2.DeleteSecretRequest.FromString, + response_serializer=flyteidl2_dot_secret_dot_payload__pb2.DeleteSecretResponse.SerializeToString, + ), + 'ListSecrets': grpc.unary_unary_rpc_method_handler( + servicer.ListSecrets, + request_deserializer=flyteidl2_dot_secret_dot_payload__pb2.ListSecretsRequest.FromString, + response_serializer=flyteidl2_dot_secret_dot_payload__pb2.ListSecretsResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.secret.SecretService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class SecretService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def CreateSecret(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.secret.SecretService/CreateSecret', + flyteidl2_dot_secret_dot_payload__pb2.CreateSecretRequest.SerializeToString, + flyteidl2_dot_secret_dot_payload__pb2.CreateSecretResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def UpdateSecret(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.secret.SecretService/UpdateSecret', + flyteidl2_dot_secret_dot_payload__pb2.UpdateSecretRequest.SerializeToString, + flyteidl2_dot_secret_dot_payload__pb2.UpdateSecretResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetSecret(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.secret.SecretService/GetSecret', + flyteidl2_dot_secret_dot_payload__pb2.GetSecretRequest.SerializeToString, + flyteidl2_dot_secret_dot_payload__pb2.GetSecretResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DeleteSecret(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.secret.SecretService/DeleteSecret', + flyteidl2_dot_secret_dot_payload__pb2.DeleteSecretRequest.SerializeToString, + flyteidl2_dot_secret_dot_payload__pb2.DeleteSecretResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListSecrets(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.secret.SecretService/ListSecrets', + flyteidl2_dot_secret_dot_payload__pb2.ListSecretsRequest.SerializeToString, + flyteidl2_dot_secret_dot_payload__pb2.ListSecretsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/gen/python/flyteidl2/task/__init__.py b/gen/python/flyteidl2/task/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/task/common_pb2.py b/gen/python/flyteidl2/task/common_pb2.py new file mode 100644 index 0000000000..c13f2c31d5 --- /dev/null +++ b/gen/python/flyteidl2/task/common_pb2.py @@ -0,0 +1,62 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/task/common.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.core import interface_pb2 as flyteidl2_dot_core_dot_interface__pb2 +from flyteidl2.core import literals_pb2 as flyteidl2_dot_core_dot_literals__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1b\x66lyteidl2/task/common.proto\x12\x0e\x66lyteidl2.task\x1a\x1b\x62uf/validate/validate.proto\x1a\x1e\x66lyteidl2/core/interface.proto\x1a\x1d\x66lyteidl2/core/literals.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"]\n\x0eNamedParameter\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x37\n\tparameter\x18\x02 \x01(\x0b\x32\x19.flyteidl2.core.ParameterR\tparameter\"\xa2\x01\n\tFixedRate\x12\x1d\n\x05value\x18\x01 \x01(\rB\x07\xbaH\x04*\x02 \x00R\x05value\x12;\n\x04unit\x18\x02 \x01(\x0e\x32\x1d.flyteidl2.task.FixedRateUnitB\x08\xbaH\x05\x82\x01\x02 \x00R\x04unit\x12\x39\n\nstart_time\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\tstartTime\"K\n\x04\x43ron\x12\'\n\nexpression\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\nexpression\x12\x1a\n\x08timezone\x18\x02 \x01(\tR\x08timezone\"\xe0\x01\n\x08Schedule\x12/\n\x04rate\x18\x01 \x01(\x0b\x32\x19.flyteidl2.task.FixedRateH\x00R\x04rate\x12-\n\x0f\x63ron_expression\x18\x02 \x01(\tB\x02\x18\x01H\x00R\x0e\x63ronExpression\x12*\n\x04\x63ron\x18\x04 \x01(\x0b\x32\x14.flyteidl2.task.CronH\x00R\x04\x63ron\x12\x33\n\x16kickoff_time_input_arg\x18\x03 \x01(\tR\x13kickoffTimeInputArgB\x13\n\nexpression\x12\x05\xbaH\x02\x08\x01\"\xa6\x01\n\x15TriggerAutomationSpec\x12G\n\x04type\x18\x01 \x01(\x0e\x32).flyteidl2.task.TriggerAutomationSpecTypeB\x08\xbaH\x05\x82\x01\x02 \x00R\x04type\x12\x36\n\x08schedule\x18\x02 \x01(\x0b\x32\x18.flyteidl2.task.ScheduleH\x00R\x08scheduleB\x0c\n\nautomation\"Q\n\x0cNamedLiteral\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12-\n\x05value\x18\x02 \x01(\x0b\x32\x17.flyteidl2.core.LiteralR\x05value\"P\n\x10OutputReferences\x12\x1d\n\noutput_uri\x18\x01 \x01(\tR\toutputUri\x12\x1d\n\nreport_uri\x18\x02 \x01(\tR\treportUri\"z\n\x06Inputs\x12\x38\n\x08literals\x18\x01 \x03(\x0b\x32\x1c.flyteidl2.task.NamedLiteralR\x08literals\x12\x36\n\x07\x63ontext\x18\x02 \x03(\x0b\x32\x1c.flyteidl2.core.KeyValuePairR\x07\x63ontext\"C\n\x07Outputs\x12\x38\n\x08literals\x18\x01 \x03(\x0b\x32\x1c.flyteidl2.task.NamedLiteralR\x08literals*\x7f\n\rFixedRateUnit\x12\x1f\n\x1b\x46IXED_RATE_UNIT_UNSPECIFIED\x10\x00\x12\x1a\n\x16\x46IXED_RATE_UNIT_MINUTE\x10\x01\x12\x18\n\x14\x46IXED_RATE_UNIT_HOUR\x10\x02\x12\x17\n\x13\x46IXED_RATE_UNIT_DAY\x10\x03*S\n\x19TriggerAutomationSpecType\x12\x14\n\x10TYPE_UNSPECIFIED\x10\x00\x12\r\n\tTYPE_NONE\x10\x01\x12\x11\n\rTYPE_SCHEDULE\x10\x02\x42\xb0\x01\n\x12\x63om.flyteidl2.taskB\x0b\x43ommonProtoH\x02P\x01Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task\xa2\x02\x03\x46TX\xaa\x02\x0e\x46lyteidl2.Task\xca\x02\x0e\x46lyteidl2\\Task\xe2\x02\x1a\x46lyteidl2\\Task\\GPBMetadata\xea\x02\x0f\x46lyteidl2::Taskb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.task.common_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\022com.flyteidl2.taskB\013CommonProtoH\002P\001Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task\242\002\003FTX\252\002\016Flyteidl2.Task\312\002\016Flyteidl2\\Task\342\002\032Flyteidl2\\Task\\GPBMetadata\352\002\017Flyteidl2::Task' + _FIXEDRATE.fields_by_name['value']._options = None + _FIXEDRATE.fields_by_name['value']._serialized_options = b'\272H\004*\002 \000' + _FIXEDRATE.fields_by_name['unit']._options = None + _FIXEDRATE.fields_by_name['unit']._serialized_options = b'\272H\005\202\001\002 \000' + _CRON.fields_by_name['expression']._options = None + _CRON.fields_by_name['expression']._serialized_options = b'\272H\004r\002\020\001' + _SCHEDULE.oneofs_by_name['expression']._options = None + _SCHEDULE.oneofs_by_name['expression']._serialized_options = b'\272H\002\010\001' + _SCHEDULE.fields_by_name['cron_expression']._options = None + _SCHEDULE.fields_by_name['cron_expression']._serialized_options = b'\030\001' + _TRIGGERAUTOMATIONSPEC.fields_by_name['type']._options = None + _TRIGGERAUTOMATIONSPEC.fields_by_name['type']._serialized_options = b'\272H\005\202\001\002 \000' + _globals['_FIXEDRATEUNIT']._serialized_start=1263 + _globals['_FIXEDRATEUNIT']._serialized_end=1390 + _globals['_TRIGGERAUTOMATIONSPECTYPE']._serialized_start=1392 + _globals['_TRIGGERAUTOMATIONSPECTYPE']._serialized_end=1475 + _globals['_NAMEDPARAMETER']._serialized_start=172 + _globals['_NAMEDPARAMETER']._serialized_end=265 + _globals['_FIXEDRATE']._serialized_start=268 + _globals['_FIXEDRATE']._serialized_end=430 + _globals['_CRON']._serialized_start=432 + _globals['_CRON']._serialized_end=507 + _globals['_SCHEDULE']._serialized_start=510 + _globals['_SCHEDULE']._serialized_end=734 + _globals['_TRIGGERAUTOMATIONSPEC']._serialized_start=737 + _globals['_TRIGGERAUTOMATIONSPEC']._serialized_end=903 + _globals['_NAMEDLITERAL']._serialized_start=905 + _globals['_NAMEDLITERAL']._serialized_end=986 + _globals['_OUTPUTREFERENCES']._serialized_start=988 + _globals['_OUTPUTREFERENCES']._serialized_end=1068 + _globals['_INPUTS']._serialized_start=1070 + _globals['_INPUTS']._serialized_end=1192 + _globals['_OUTPUTS']._serialized_start=1194 + _globals['_OUTPUTS']._serialized_end=1261 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/task/common_pb2.pyi b/gen/python/flyteidl2/task/common_pb2.pyi new file mode 100644 index 0000000000..a27c0d4879 --- /dev/null +++ b/gen/python/flyteidl2/task/common_pb2.pyi @@ -0,0 +1,107 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.core import interface_pb2 as _interface_pb2 +from flyteidl2.core import literals_pb2 as _literals_pb2 +from google.protobuf import timestamp_pb2 as _timestamp_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class FixedRateUnit(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + FIXED_RATE_UNIT_UNSPECIFIED: _ClassVar[FixedRateUnit] + FIXED_RATE_UNIT_MINUTE: _ClassVar[FixedRateUnit] + FIXED_RATE_UNIT_HOUR: _ClassVar[FixedRateUnit] + FIXED_RATE_UNIT_DAY: _ClassVar[FixedRateUnit] + +class TriggerAutomationSpecType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + TYPE_UNSPECIFIED: _ClassVar[TriggerAutomationSpecType] + TYPE_NONE: _ClassVar[TriggerAutomationSpecType] + TYPE_SCHEDULE: _ClassVar[TriggerAutomationSpecType] +FIXED_RATE_UNIT_UNSPECIFIED: FixedRateUnit +FIXED_RATE_UNIT_MINUTE: FixedRateUnit +FIXED_RATE_UNIT_HOUR: FixedRateUnit +FIXED_RATE_UNIT_DAY: FixedRateUnit +TYPE_UNSPECIFIED: TriggerAutomationSpecType +TYPE_NONE: TriggerAutomationSpecType +TYPE_SCHEDULE: TriggerAutomationSpecType + +class NamedParameter(_message.Message): + __slots__ = ["name", "parameter"] + NAME_FIELD_NUMBER: _ClassVar[int] + PARAMETER_FIELD_NUMBER: _ClassVar[int] + name: str + parameter: _interface_pb2.Parameter + def __init__(self, name: _Optional[str] = ..., parameter: _Optional[_Union[_interface_pb2.Parameter, _Mapping]] = ...) -> None: ... + +class FixedRate(_message.Message): + __slots__ = ["value", "unit", "start_time"] + VALUE_FIELD_NUMBER: _ClassVar[int] + UNIT_FIELD_NUMBER: _ClassVar[int] + START_TIME_FIELD_NUMBER: _ClassVar[int] + value: int + unit: FixedRateUnit + start_time: _timestamp_pb2.Timestamp + def __init__(self, value: _Optional[int] = ..., unit: _Optional[_Union[FixedRateUnit, str]] = ..., start_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ...) -> None: ... + +class Cron(_message.Message): + __slots__ = ["expression", "timezone"] + EXPRESSION_FIELD_NUMBER: _ClassVar[int] + TIMEZONE_FIELD_NUMBER: _ClassVar[int] + expression: str + timezone: str + def __init__(self, expression: _Optional[str] = ..., timezone: _Optional[str] = ...) -> None: ... + +class Schedule(_message.Message): + __slots__ = ["rate", "cron_expression", "cron", "kickoff_time_input_arg"] + RATE_FIELD_NUMBER: _ClassVar[int] + CRON_EXPRESSION_FIELD_NUMBER: _ClassVar[int] + CRON_FIELD_NUMBER: _ClassVar[int] + KICKOFF_TIME_INPUT_ARG_FIELD_NUMBER: _ClassVar[int] + rate: FixedRate + cron_expression: str + cron: Cron + kickoff_time_input_arg: str + def __init__(self, rate: _Optional[_Union[FixedRate, _Mapping]] = ..., cron_expression: _Optional[str] = ..., cron: _Optional[_Union[Cron, _Mapping]] = ..., kickoff_time_input_arg: _Optional[str] = ...) -> None: ... + +class TriggerAutomationSpec(_message.Message): + __slots__ = ["type", "schedule"] + TYPE_FIELD_NUMBER: _ClassVar[int] + SCHEDULE_FIELD_NUMBER: _ClassVar[int] + type: TriggerAutomationSpecType + schedule: Schedule + def __init__(self, type: _Optional[_Union[TriggerAutomationSpecType, str]] = ..., schedule: _Optional[_Union[Schedule, _Mapping]] = ...) -> None: ... + +class NamedLiteral(_message.Message): + __slots__ = ["name", "value"] + NAME_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + name: str + value: _literals_pb2.Literal + def __init__(self, name: _Optional[str] = ..., value: _Optional[_Union[_literals_pb2.Literal, _Mapping]] = ...) -> None: ... + +class OutputReferences(_message.Message): + __slots__ = ["output_uri", "report_uri"] + OUTPUT_URI_FIELD_NUMBER: _ClassVar[int] + REPORT_URI_FIELD_NUMBER: _ClassVar[int] + output_uri: str + report_uri: str + def __init__(self, output_uri: _Optional[str] = ..., report_uri: _Optional[str] = ...) -> None: ... + +class Inputs(_message.Message): + __slots__ = ["literals", "context"] + LITERALS_FIELD_NUMBER: _ClassVar[int] + CONTEXT_FIELD_NUMBER: _ClassVar[int] + literals: _containers.RepeatedCompositeFieldContainer[NamedLiteral] + context: _containers.RepeatedCompositeFieldContainer[_literals_pb2.KeyValuePair] + def __init__(self, literals: _Optional[_Iterable[_Union[NamedLiteral, _Mapping]]] = ..., context: _Optional[_Iterable[_Union[_literals_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class Outputs(_message.Message): + __slots__ = ["literals"] + LITERALS_FIELD_NUMBER: _ClassVar[int] + literals: _containers.RepeatedCompositeFieldContainer[NamedLiteral] + def __init__(self, literals: _Optional[_Iterable[_Union[NamedLiteral, _Mapping]]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/task/common_pb2_grpc.py b/gen/python/flyteidl2/task/common_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/task/common_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/task/environment_pb2.py b/gen/python/flyteidl2/task/environment_pb2.py new file mode 100644 index 0000000000..d6c0853133 --- /dev/null +++ b/gen/python/flyteidl2/task/environment_pb2.py @@ -0,0 +1,31 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/task/environment.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n flyteidl2/task/environment.proto\x12\x0e\x66lyteidl2.task\x1a\x1b\x62uf/validate/validate.proto\"X\n\x0b\x45nvironment\x12\x1d\n\x04name\x18\x01 \x01(\tB\t\xbaH\x06r\x04\x10\x01\x18?R\x04name\x12*\n\x0b\x64\x65scription\x18\x02 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\x0b\x64\x65scriptionB\xb5\x01\n\x12\x63om.flyteidl2.taskB\x10\x45nvironmentProtoH\x02P\x01Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task\xa2\x02\x03\x46TX\xaa\x02\x0e\x46lyteidl2.Task\xca\x02\x0e\x46lyteidl2\\Task\xe2\x02\x1a\x46lyteidl2\\Task\\GPBMetadata\xea\x02\x0f\x46lyteidl2::Taskb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.task.environment_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\022com.flyteidl2.taskB\020EnvironmentProtoH\002P\001Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task\242\002\003FTX\252\002\016Flyteidl2.Task\312\002\016Flyteidl2\\Task\342\002\032Flyteidl2\\Task\\GPBMetadata\352\002\017Flyteidl2::Task' + _ENVIRONMENT.fields_by_name['name']._options = None + _ENVIRONMENT.fields_by_name['name']._serialized_options = b'\272H\006r\004\020\001\030?' + _ENVIRONMENT.fields_by_name['description']._options = None + _ENVIRONMENT.fields_by_name['description']._serialized_options = b'\272H\005r\003\030\377\001' + _globals['_ENVIRONMENT']._serialized_start=81 + _globals['_ENVIRONMENT']._serialized_end=169 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/task/environment_pb2.pyi b/gen/python/flyteidl2/task/environment_pb2.pyi new file mode 100644 index 0000000000..26cbfb4d4f --- /dev/null +++ b/gen/python/flyteidl2/task/environment_pb2.pyi @@ -0,0 +1,14 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Optional as _Optional + +DESCRIPTOR: _descriptor.FileDescriptor + +class Environment(_message.Message): + __slots__ = ["name", "description"] + NAME_FIELD_NUMBER: _ClassVar[int] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + name: str + description: str + def __init__(self, name: _Optional[str] = ..., description: _Optional[str] = ...) -> None: ... diff --git a/gen/python/flyteidl2/task/environment_pb2_grpc.py b/gen/python/flyteidl2/task/environment_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/task/environment_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/task/run_pb2.py b/gen/python/flyteidl2/task/run_pb2.py new file mode 100644 index 0000000000..f94fc763bd --- /dev/null +++ b/gen/python/flyteidl2/task/run_pb2.py @@ -0,0 +1,51 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/task/run.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.core import literals_pb2 as flyteidl2_dot_core_dot_literals__pb2 +from flyteidl2.core import security_pb2 as flyteidl2_dot_core_dot_security__pb2 +from google.protobuf import wrappers_pb2 as google_dot_protobuf_dot_wrappers__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x18\x66lyteidl2/task/run.proto\x12\x0e\x66lyteidl2.task\x1a\x1d\x66lyteidl2/core/literals.proto\x1a\x1d\x66lyteidl2/core/security.proto\x1a\x1egoogle/protobuf/wrappers.proto\"\x7f\n\x06Labels\x12:\n\x06values\x18\x01 \x03(\x0b\x32\".flyteidl2.task.Labels.ValuesEntryR\x06values\x1a\x39\n\x0bValuesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\x89\x01\n\x0b\x41nnotations\x12?\n\x06values\x18\x01 \x03(\x0b\x32\'.flyteidl2.task.Annotations.ValuesEntryR\x06values\x1a\x39\n\x0bValuesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"<\n\x04\x45nvs\x12\x34\n\x06values\x18\x01 \x03(\x0b\x32\x1c.flyteidl2.core.KeyValuePairR\x06values\"8\n\x0eRawDataStorage\x12&\n\x0fraw_data_prefix\x18\x01 \x01(\tR\rrawDataPrefix\"\x86\x01\n\x0b\x43\x61\x63heConfig\x12\'\n\x0foverwrite_cache\x18\x01 \x01(\x08R\x0eoverwriteCache\x12N\n\x12\x63\x61\x63he_lookup_scope\x18\x02 \x01(\x0e\x32 .flyteidl2.task.CacheLookupScopeR\x10\x63\x61\x63heLookupScope\"\x81\x04\n\x07RunSpec\x12.\n\x06labels\x18\x01 \x01(\x0b\x32\x16.flyteidl2.task.LabelsR\x06labels\x12=\n\x0b\x61nnotations\x18\x02 \x01(\x0b\x32\x1b.flyteidl2.task.AnnotationsR\x0b\x61nnotations\x12(\n\x04\x65nvs\x18\x03 \x01(\x0b\x32\x14.flyteidl2.task.EnvsR\x04\x65nvs\x12@\n\rinterruptible\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.BoolValueR\rinterruptible\x12+\n\x0foverwrite_cache\x18\x05 \x01(\x08\x42\x02\x18\x01R\x0eoverwriteCache\x12\x18\n\x07\x63luster\x18\x06 \x01(\tR\x07\x63luster\x12H\n\x10raw_data_storage\x18\x07 \x01(\x0b\x32\x1e.flyteidl2.task.RawDataStorageR\x0erawDataStorage\x12J\n\x10security_context\x18\x08 \x01(\x0b\x32\x1f.flyteidl2.core.SecurityContextR\x0fsecurityContext\x12>\n\x0c\x63\x61\x63he_config\x18\t \x01(\x0b\x32\x1b.flyteidl2.task.CacheConfigR\x0b\x63\x61\x63heConfig*|\n\x10\x43\x61\x63heLookupScope\x12\"\n\x1e\x43\x41\x43HE_LOOKUP_SCOPE_UNSPECIFIED\x10\x00\x12\x1d\n\x19\x43\x41\x43HE_LOOKUP_SCOPE_GLOBAL\x10\x01\x12%\n!CACHE_LOOKUP_SCOPE_PROJECT_DOMAIN\x10\x02\x42\xad\x01\n\x12\x63om.flyteidl2.taskB\x08RunProtoH\x02P\x01Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task\xa2\x02\x03\x46TX\xaa\x02\x0e\x46lyteidl2.Task\xca\x02\x0e\x46lyteidl2\\Task\xe2\x02\x1a\x46lyteidl2\\Task\\GPBMetadata\xea\x02\x0f\x46lyteidl2::Taskb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.task.run_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\022com.flyteidl2.taskB\010RunProtoH\002P\001Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task\242\002\003FTX\252\002\016Flyteidl2.Task\312\002\016Flyteidl2\\Task\342\002\032Flyteidl2\\Task\\GPBMetadata\352\002\017Flyteidl2::Task' + _LABELS_VALUESENTRY._options = None + _LABELS_VALUESENTRY._serialized_options = b'8\001' + _ANNOTATIONS_VALUESENTRY._options = None + _ANNOTATIONS_VALUESENTRY._serialized_options = b'8\001' + _RUNSPEC.fields_by_name['overwrite_cache']._options = None + _RUNSPEC.fields_by_name['overwrite_cache']._serialized_options = b'\030\001' + _globals['_CACHELOOKUPSCOPE']._serialized_start=1180 + _globals['_CACHELOOKUPSCOPE']._serialized_end=1304 + _globals['_LABELS']._serialized_start=138 + _globals['_LABELS']._serialized_end=265 + _globals['_LABELS_VALUESENTRY']._serialized_start=208 + _globals['_LABELS_VALUESENTRY']._serialized_end=265 + _globals['_ANNOTATIONS']._serialized_start=268 + _globals['_ANNOTATIONS']._serialized_end=405 + _globals['_ANNOTATIONS_VALUESENTRY']._serialized_start=208 + _globals['_ANNOTATIONS_VALUESENTRY']._serialized_end=265 + _globals['_ENVS']._serialized_start=407 + _globals['_ENVS']._serialized_end=467 + _globals['_RAWDATASTORAGE']._serialized_start=469 + _globals['_RAWDATASTORAGE']._serialized_end=525 + _globals['_CACHECONFIG']._serialized_start=528 + _globals['_CACHECONFIG']._serialized_end=662 + _globals['_RUNSPEC']._serialized_start=665 + _globals['_RUNSPEC']._serialized_end=1178 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/task/run_pb2.pyi b/gen/python/flyteidl2/task/run_pb2.pyi new file mode 100644 index 0000000000..15a60b7eeb --- /dev/null +++ b/gen/python/flyteidl2/task/run_pb2.pyi @@ -0,0 +1,87 @@ +from flyteidl2.core import literals_pb2 as _literals_pb2 +from flyteidl2.core import security_pb2 as _security_pb2 +from google.protobuf import wrappers_pb2 as _wrappers_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class CacheLookupScope(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + CACHE_LOOKUP_SCOPE_UNSPECIFIED: _ClassVar[CacheLookupScope] + CACHE_LOOKUP_SCOPE_GLOBAL: _ClassVar[CacheLookupScope] + CACHE_LOOKUP_SCOPE_PROJECT_DOMAIN: _ClassVar[CacheLookupScope] +CACHE_LOOKUP_SCOPE_UNSPECIFIED: CacheLookupScope +CACHE_LOOKUP_SCOPE_GLOBAL: CacheLookupScope +CACHE_LOOKUP_SCOPE_PROJECT_DOMAIN: CacheLookupScope + +class Labels(_message.Message): + __slots__ = ["values"] + class ValuesEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + VALUES_FIELD_NUMBER: _ClassVar[int] + values: _containers.ScalarMap[str, str] + def __init__(self, values: _Optional[_Mapping[str, str]] = ...) -> None: ... + +class Annotations(_message.Message): + __slots__ = ["values"] + class ValuesEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + VALUES_FIELD_NUMBER: _ClassVar[int] + values: _containers.ScalarMap[str, str] + def __init__(self, values: _Optional[_Mapping[str, str]] = ...) -> None: ... + +class Envs(_message.Message): + __slots__ = ["values"] + VALUES_FIELD_NUMBER: _ClassVar[int] + values: _containers.RepeatedCompositeFieldContainer[_literals_pb2.KeyValuePair] + def __init__(self, values: _Optional[_Iterable[_Union[_literals_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class RawDataStorage(_message.Message): + __slots__ = ["raw_data_prefix"] + RAW_DATA_PREFIX_FIELD_NUMBER: _ClassVar[int] + raw_data_prefix: str + def __init__(self, raw_data_prefix: _Optional[str] = ...) -> None: ... + +class CacheConfig(_message.Message): + __slots__ = ["overwrite_cache", "cache_lookup_scope"] + OVERWRITE_CACHE_FIELD_NUMBER: _ClassVar[int] + CACHE_LOOKUP_SCOPE_FIELD_NUMBER: _ClassVar[int] + overwrite_cache: bool + cache_lookup_scope: CacheLookupScope + def __init__(self, overwrite_cache: bool = ..., cache_lookup_scope: _Optional[_Union[CacheLookupScope, str]] = ...) -> None: ... + +class RunSpec(_message.Message): + __slots__ = ["labels", "annotations", "envs", "interruptible", "overwrite_cache", "cluster", "raw_data_storage", "security_context", "cache_config"] + LABELS_FIELD_NUMBER: _ClassVar[int] + ANNOTATIONS_FIELD_NUMBER: _ClassVar[int] + ENVS_FIELD_NUMBER: _ClassVar[int] + INTERRUPTIBLE_FIELD_NUMBER: _ClassVar[int] + OVERWRITE_CACHE_FIELD_NUMBER: _ClassVar[int] + CLUSTER_FIELD_NUMBER: _ClassVar[int] + RAW_DATA_STORAGE_FIELD_NUMBER: _ClassVar[int] + SECURITY_CONTEXT_FIELD_NUMBER: _ClassVar[int] + CACHE_CONFIG_FIELD_NUMBER: _ClassVar[int] + labels: Labels + annotations: Annotations + envs: Envs + interruptible: _wrappers_pb2.BoolValue + overwrite_cache: bool + cluster: str + raw_data_storage: RawDataStorage + security_context: _security_pb2.SecurityContext + cache_config: CacheConfig + def __init__(self, labels: _Optional[_Union[Labels, _Mapping]] = ..., annotations: _Optional[_Union[Annotations, _Mapping]] = ..., envs: _Optional[_Union[Envs, _Mapping]] = ..., interruptible: _Optional[_Union[_wrappers_pb2.BoolValue, _Mapping]] = ..., overwrite_cache: bool = ..., cluster: _Optional[str] = ..., raw_data_storage: _Optional[_Union[RawDataStorage, _Mapping]] = ..., security_context: _Optional[_Union[_security_pb2.SecurityContext, _Mapping]] = ..., cache_config: _Optional[_Union[CacheConfig, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/task/run_pb2_grpc.py b/gen/python/flyteidl2/task/run_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/task/run_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/task/task_definition_pb2.py b/gen/python/flyteidl2/task/task_definition_pb2.py new file mode 100644 index 0000000000..5135a62a8b --- /dev/null +++ b/gen/python/flyteidl2/task/task_definition_pb2.py @@ -0,0 +1,110 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/task/task_definition.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.common import identifier_pb2 as flyteidl2_dot_common_dot_identifier__pb2 +from flyteidl2.common import identity_pb2 as flyteidl2_dot_common_dot_identity__pb2 +from flyteidl2.common import phase_pb2 as flyteidl2_dot_common_dot_phase__pb2 +from flyteidl2.core import interface_pb2 as flyteidl2_dot_core_dot_interface__pb2 +from flyteidl2.core import tasks_pb2 as flyteidl2_dot_core_dot_tasks__pb2 +from flyteidl2.task import common_pb2 as flyteidl2_dot_task_dot_common__pb2 +from flyteidl2.task import environment_pb2 as flyteidl2_dot_task_dot_environment__pb2 +from flyteidl2.task import run_pb2 as flyteidl2_dot_task_dot_run__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n$flyteidl2/task/task_definition.proto\x12\x0e\x66lyteidl2.task\x1a\x1b\x62uf/validate/validate.proto\x1a!flyteidl2/common/identifier.proto\x1a\x1f\x66lyteidl2/common/identity.proto\x1a\x1c\x66lyteidl2/common/phase.proto\x1a\x1e\x66lyteidl2/core/interface.proto\x1a\x1a\x66lyteidl2/core/tasks.proto\x1a\x1b\x66lyteidl2/task/common.proto\x1a flyteidl2/task/environment.proto\x1a\x18\x66lyteidl2/task/run.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\x8f\x01\n\x08TaskName\x12\x1b\n\x03org\x18\x01 \x01(\tB\t\xbaH\x06r\x04\x10\x01\x18?R\x03org\x12#\n\x07project\x18\x02 \x01(\tB\t\xbaH\x06r\x04\x10\x01\x18?R\x07project\x12!\n\x06\x64omain\x18\x03 \x01(\tB\t\xbaH\x06r\x04\x10\x01\x18?R\x06\x64omain\x12\x1e\n\x04name\x18\x04 \x01(\tB\n\xbaH\x07r\x05\x10\x01\x18\xff\x01R\x04name\"\xba\x01\n\x0eTaskIdentifier\x12\x1b\n\x03org\x18\x01 \x01(\tB\t\xbaH\x06r\x04\x10\x01\x18?R\x03org\x12#\n\x07project\x18\x02 \x01(\tB\t\xbaH\x06r\x04\x10\x01\x18?R\x07project\x12!\n\x06\x64omain\x18\x03 \x01(\tB\t\xbaH\x06r\x04\x10\x01\x18?R\x06\x64omain\x12\x1e\n\x04name\x18\x04 \x01(\tB\n\xbaH\x07r\x05\x10\x01\x18\xff\x01R\x04name\x12#\n\x07version\x18\x05 \x01(\tB\t\xbaH\x06r\x04\x10\x01\x18?R\x07version\"\x8d\x03\n\x13TaskTriggersSummary\x12N\n\x07\x64\x65tails\x18\x03 \x01(\x0b\x32\x32.flyteidl2.task.TaskTriggersSummary.TriggerDetailsH\x00R\x07\x64\x65tails\x12H\n\x05stats\x18\x02 \x01(\x0b\x32\x30.flyteidl2.task.TaskTriggersSummary.TriggerStatsH\x00R\x05stats\x1a\x8c\x01\n\x0eTriggerDetails\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n\x06\x61\x63tive\x18\x02 \x01(\x08R\x06\x61\x63tive\x12N\n\x0f\x61utomation_spec\x18\x03 \x01(\x0b\x32%.flyteidl2.task.TriggerAutomationSpecR\x0e\x61utomationSpec\x1a<\n\x0cTriggerStats\x12\x14\n\x05total\x18\x01 \x01(\rR\x05total\x12\x16\n\x06\x61\x63tive\x18\x02 \x01(\rR\x06\x61\x63tiveB\t\n\x07summaryJ\x04\x08\x01\x10\x02\"\xdc\x01\n\x10LatestRunSummary\x12\x36\n\x06run_id\x18\x01 \x01(\x0b\x32\x1f.flyteidl2.common.RunIdentifierR\x05runId\x12\x35\n\x08run_time\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x07runTime\x12\x33\n\x05phase\x18\x03 \x01(\x0e\x32\x1d.flyteidl2.common.ActionPhaseR\x05phase\x12$\n\x0eroot_task_name\x18\x04 \x01(\tR\x0crootTaskName\"\xe7\x02\n\x0cTaskMetadata\x12K\n\x0b\x64\x65ployed_by\x18\x01 \x01(\x0b\x32\".flyteidl2.common.EnrichedIdentityB\x06\xbaH\x03\xc8\x01\x01R\ndeployedBy\x12\x1d\n\nshort_name\x18\x02 \x01(\tR\tshortName\x12\x43\n\x0b\x64\x65ployed_at\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.TimestampB\x06\xbaH\x03\xc8\x01\x01R\ndeployedAt\x12)\n\x10\x65nvironment_name\x18\x04 \x01(\tR\x0f\x65nvironmentName\x12N\n\x10triggers_summary\x18\x05 \x01(\x0b\x32#.flyteidl2.task.TaskTriggersSummaryR\x0ftriggersSummary\x12+\n\x11short_description\x18\x06 \x01(\tR\x10shortDescription\"b\n\x0bTaskSummary\x12\x44\n\nlatest_run\x18\x01 \x01(\x0b\x32 .flyteidl2.task.LatestRunSummaryH\x00R\tlatestRun\x88\x01\x01\x42\r\n\x0b_latest_run\"\xdf\x01\n\x04Task\x12?\n\x07task_id\x18\x01 \x01(\x0b\x32\x1e.flyteidl2.task.TaskIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x06taskId\x12@\n\x08metadata\x18\x02 \x01(\x0b\x32\x1c.flyteidl2.task.TaskMetadataB\x06\xbaH\x03\xc8\x01\x01R\x08metadata\x12\x43\n\x0ctask_summary\x18\x03 \x01(\x0b\x32\x1b.flyteidl2.task.TaskSummaryH\x00R\x0btaskSummary\x88\x01\x01\x42\x0f\n\r_task_summary\" \n\nSourceCode\x12\x12\n\x04link\x18\x01 \x01(\tR\x04link\"\xbe\x01\n\x13\x44ocumentationEntity\x12\x35\n\x11short_description\x18\x01 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\x10shortDescription\x12\x33\n\x10long_description\x18\x02 \x01(\tB\x08\xbaH\x05r\x03\x18\x80\x10R\x0flongDescription\x12;\n\x0bsource_code\x18\x03 \x01(\x0b\x32\x1a.flyteidl2.task.SourceCodeR\nsourceCode\"\xce\x02\n\x08TaskSpec\x12I\n\rtask_template\x18\x01 \x01(\x0b\x32\x1c.flyteidl2.core.TaskTemplateB\x06\xbaH\x03\xc8\x01\x01R\x0ctaskTemplate\x12\x45\n\x0e\x64\x65\x66\x61ult_inputs\x18\x02 \x03(\x0b\x32\x1e.flyteidl2.task.NamedParameterR\rdefaultInputs\x12&\n\nshort_name\x18\x03 \x01(\tB\x07\xbaH\x04r\x02\x18?R\tshortName\x12=\n\x0b\x65nvironment\x18\x04 \x01(\x0b\x32\x1b.flyteidl2.task.EnvironmentR\x0b\x65nvironment\x12I\n\rdocumentation\x18\x05 \x01(\x0b\x32#.flyteidl2.task.DocumentationEntityR\rdocumentation\"I\n\tTraceSpec\x12<\n\tinterface\x18\x01 \x01(\x0b\x32\x1e.flyteidl2.core.TypedInterfaceR\tinterface\"\xc6\x01\n\x0bTaskDetails\x12?\n\x07task_id\x18\x01 \x01(\x0b\x32\x1e.flyteidl2.task.TaskIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x06taskId\x12@\n\x08metadata\x18\x02 \x01(\x0b\x32\x1c.flyteidl2.task.TaskMetadataB\x06\xbaH\x03\xc8\x01\x01R\x08metadata\x12\x34\n\x04spec\x18\x03 \x01(\x0b\x32\x18.flyteidl2.task.TaskSpecB\x06\xbaH\x03\xc8\x01\x01R\x04spec\"\xba\x01\n\x0bTaskTrigger\x12\x1e\n\x04name\x18\x01 \x01(\tB\n\xbaH\x07r\x05\x10\x01\x18\xff\x01R\x04name\x12;\n\x04spec\x18\x02 \x01(\x0b\x32\x1f.flyteidl2.task.TaskTriggerSpecB\x06\xbaH\x03\xc8\x01\x01R\x04spec\x12N\n\x0f\x61utomation_spec\x18\x03 \x01(\x0b\x32%.flyteidl2.task.TriggerAutomationSpecR\x0e\x61utomationSpec\"\xaf\x01\n\x0fTaskTriggerSpec\x12\x16\n\x06\x61\x63tive\x18\x01 \x01(\x08R\x06\x61\x63tive\x12.\n\x06inputs\x18\x02 \x01(\x0b\x32\x16.flyteidl2.task.InputsR\x06inputs\x12\x32\n\x08run_spec\x18\x03 \x01(\x0b\x32\x17.flyteidl2.task.RunSpecR\x07runSpec\x12 \n\x0b\x64\x65scription\x18\x04 \x01(\tR\x0b\x64\x65scriptionB\xb8\x01\n\x12\x63om.flyteidl2.taskB\x13TaskDefinitionProtoH\x02P\x01Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task\xa2\x02\x03\x46TX\xaa\x02\x0e\x46lyteidl2.Task\xca\x02\x0e\x46lyteidl2\\Task\xe2\x02\x1a\x46lyteidl2\\Task\\GPBMetadata\xea\x02\x0f\x46lyteidl2::Taskb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.task.task_definition_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\022com.flyteidl2.taskB\023TaskDefinitionProtoH\002P\001Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task\242\002\003FTX\252\002\016Flyteidl2.Task\312\002\016Flyteidl2\\Task\342\002\032Flyteidl2\\Task\\GPBMetadata\352\002\017Flyteidl2::Task' + _TASKNAME.fields_by_name['org']._options = None + _TASKNAME.fields_by_name['org']._serialized_options = b'\272H\006r\004\020\001\030?' + _TASKNAME.fields_by_name['project']._options = None + _TASKNAME.fields_by_name['project']._serialized_options = b'\272H\006r\004\020\001\030?' + _TASKNAME.fields_by_name['domain']._options = None + _TASKNAME.fields_by_name['domain']._serialized_options = b'\272H\006r\004\020\001\030?' + _TASKNAME.fields_by_name['name']._options = None + _TASKNAME.fields_by_name['name']._serialized_options = b'\272H\007r\005\020\001\030\377\001' + _TASKIDENTIFIER.fields_by_name['org']._options = None + _TASKIDENTIFIER.fields_by_name['org']._serialized_options = b'\272H\006r\004\020\001\030?' + _TASKIDENTIFIER.fields_by_name['project']._options = None + _TASKIDENTIFIER.fields_by_name['project']._serialized_options = b'\272H\006r\004\020\001\030?' + _TASKIDENTIFIER.fields_by_name['domain']._options = None + _TASKIDENTIFIER.fields_by_name['domain']._serialized_options = b'\272H\006r\004\020\001\030?' + _TASKIDENTIFIER.fields_by_name['name']._options = None + _TASKIDENTIFIER.fields_by_name['name']._serialized_options = b'\272H\007r\005\020\001\030\377\001' + _TASKIDENTIFIER.fields_by_name['version']._options = None + _TASKIDENTIFIER.fields_by_name['version']._serialized_options = b'\272H\006r\004\020\001\030?' + _TASKMETADATA.fields_by_name['deployed_by']._options = None + _TASKMETADATA.fields_by_name['deployed_by']._serialized_options = b'\272H\003\310\001\001' + _TASKMETADATA.fields_by_name['deployed_at']._options = None + _TASKMETADATA.fields_by_name['deployed_at']._serialized_options = b'\272H\003\310\001\001' + _TASK.fields_by_name['task_id']._options = None + _TASK.fields_by_name['task_id']._serialized_options = b'\272H\003\310\001\001' + _TASK.fields_by_name['metadata']._options = None + _TASK.fields_by_name['metadata']._serialized_options = b'\272H\003\310\001\001' + _DOCUMENTATIONENTITY.fields_by_name['short_description']._options = None + _DOCUMENTATIONENTITY.fields_by_name['short_description']._serialized_options = b'\272H\005r\003\030\377\001' + _DOCUMENTATIONENTITY.fields_by_name['long_description']._options = None + _DOCUMENTATIONENTITY.fields_by_name['long_description']._serialized_options = b'\272H\005r\003\030\200\020' + _TASKSPEC.fields_by_name['task_template']._options = None + _TASKSPEC.fields_by_name['task_template']._serialized_options = b'\272H\003\310\001\001' + _TASKSPEC.fields_by_name['short_name']._options = None + _TASKSPEC.fields_by_name['short_name']._serialized_options = b'\272H\004r\002\030?' + _TASKDETAILS.fields_by_name['task_id']._options = None + _TASKDETAILS.fields_by_name['task_id']._serialized_options = b'\272H\003\310\001\001' + _TASKDETAILS.fields_by_name['metadata']._options = None + _TASKDETAILS.fields_by_name['metadata']._serialized_options = b'\272H\003\310\001\001' + _TASKDETAILS.fields_by_name['spec']._options = None + _TASKDETAILS.fields_by_name['spec']._serialized_options = b'\272H\003\310\001\001' + _TASKTRIGGER.fields_by_name['name']._options = None + _TASKTRIGGER.fields_by_name['name']._serialized_options = b'\272H\007r\005\020\001\030\377\001' + _TASKTRIGGER.fields_by_name['spec']._options = None + _TASKTRIGGER.fields_by_name['spec']._serialized_options = b'\272H\003\310\001\001' + _globals['_TASKNAME']._serialized_start=366 + _globals['_TASKNAME']._serialized_end=509 + _globals['_TASKIDENTIFIER']._serialized_start=512 + _globals['_TASKIDENTIFIER']._serialized_end=698 + _globals['_TASKTRIGGERSSUMMARY']._serialized_start=701 + _globals['_TASKTRIGGERSSUMMARY']._serialized_end=1098 + _globals['_TASKTRIGGERSSUMMARY_TRIGGERDETAILS']._serialized_start=879 + _globals['_TASKTRIGGERSSUMMARY_TRIGGERDETAILS']._serialized_end=1019 + _globals['_TASKTRIGGERSSUMMARY_TRIGGERSTATS']._serialized_start=1021 + _globals['_TASKTRIGGERSSUMMARY_TRIGGERSTATS']._serialized_end=1081 + _globals['_LATESTRUNSUMMARY']._serialized_start=1101 + _globals['_LATESTRUNSUMMARY']._serialized_end=1321 + _globals['_TASKMETADATA']._serialized_start=1324 + _globals['_TASKMETADATA']._serialized_end=1683 + _globals['_TASKSUMMARY']._serialized_start=1685 + _globals['_TASKSUMMARY']._serialized_end=1783 + _globals['_TASK']._serialized_start=1786 + _globals['_TASK']._serialized_end=2009 + _globals['_SOURCECODE']._serialized_start=2011 + _globals['_SOURCECODE']._serialized_end=2043 + _globals['_DOCUMENTATIONENTITY']._serialized_start=2046 + _globals['_DOCUMENTATIONENTITY']._serialized_end=2236 + _globals['_TASKSPEC']._serialized_start=2239 + _globals['_TASKSPEC']._serialized_end=2573 + _globals['_TRACESPEC']._serialized_start=2575 + _globals['_TRACESPEC']._serialized_end=2648 + _globals['_TASKDETAILS']._serialized_start=2651 + _globals['_TASKDETAILS']._serialized_end=2849 + _globals['_TASKTRIGGER']._serialized_start=2852 + _globals['_TASKTRIGGER']._serialized_end=3038 + _globals['_TASKTRIGGERSPEC']._serialized_start=3041 + _globals['_TASKTRIGGERSPEC']._serialized_end=3216 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/task/task_definition_pb2.pyi b/gen/python/flyteidl2/task/task_definition_pb2.pyi new file mode 100644 index 0000000000..83174f5e97 --- /dev/null +++ b/gen/python/flyteidl2/task/task_definition_pb2.pyi @@ -0,0 +1,178 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.common import identifier_pb2 as _identifier_pb2 +from flyteidl2.common import identity_pb2 as _identity_pb2 +from flyteidl2.common import phase_pb2 as _phase_pb2 +from flyteidl2.core import interface_pb2 as _interface_pb2 +from flyteidl2.core import tasks_pb2 as _tasks_pb2 +from flyteidl2.task import common_pb2 as _common_pb2 +from flyteidl2.task import environment_pb2 as _environment_pb2 +from flyteidl2.task import run_pb2 as _run_pb2 +from google.protobuf import timestamp_pb2 as _timestamp_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class TaskName(_message.Message): + __slots__ = ["org", "project", "domain", "name"] + ORG_FIELD_NUMBER: _ClassVar[int] + PROJECT_FIELD_NUMBER: _ClassVar[int] + DOMAIN_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + org: str + project: str + domain: str + name: str + def __init__(self, org: _Optional[str] = ..., project: _Optional[str] = ..., domain: _Optional[str] = ..., name: _Optional[str] = ...) -> None: ... + +class TaskIdentifier(_message.Message): + __slots__ = ["org", "project", "domain", "name", "version"] + ORG_FIELD_NUMBER: _ClassVar[int] + PROJECT_FIELD_NUMBER: _ClassVar[int] + DOMAIN_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + VERSION_FIELD_NUMBER: _ClassVar[int] + org: str + project: str + domain: str + name: str + version: str + def __init__(self, org: _Optional[str] = ..., project: _Optional[str] = ..., domain: _Optional[str] = ..., name: _Optional[str] = ..., version: _Optional[str] = ...) -> None: ... + +class TaskTriggersSummary(_message.Message): + __slots__ = ["details", "stats"] + class TriggerDetails(_message.Message): + __slots__ = ["name", "active", "automation_spec"] + NAME_FIELD_NUMBER: _ClassVar[int] + ACTIVE_FIELD_NUMBER: _ClassVar[int] + AUTOMATION_SPEC_FIELD_NUMBER: _ClassVar[int] + name: str + active: bool + automation_spec: _common_pb2.TriggerAutomationSpec + def __init__(self, name: _Optional[str] = ..., active: bool = ..., automation_spec: _Optional[_Union[_common_pb2.TriggerAutomationSpec, _Mapping]] = ...) -> None: ... + class TriggerStats(_message.Message): + __slots__ = ["total", "active"] + TOTAL_FIELD_NUMBER: _ClassVar[int] + ACTIVE_FIELD_NUMBER: _ClassVar[int] + total: int + active: int + def __init__(self, total: _Optional[int] = ..., active: _Optional[int] = ...) -> None: ... + DETAILS_FIELD_NUMBER: _ClassVar[int] + STATS_FIELD_NUMBER: _ClassVar[int] + details: TaskTriggersSummary.TriggerDetails + stats: TaskTriggersSummary.TriggerStats + def __init__(self, details: _Optional[_Union[TaskTriggersSummary.TriggerDetails, _Mapping]] = ..., stats: _Optional[_Union[TaskTriggersSummary.TriggerStats, _Mapping]] = ...) -> None: ... + +class LatestRunSummary(_message.Message): + __slots__ = ["run_id", "run_time", "phase", "root_task_name"] + RUN_ID_FIELD_NUMBER: _ClassVar[int] + RUN_TIME_FIELD_NUMBER: _ClassVar[int] + PHASE_FIELD_NUMBER: _ClassVar[int] + ROOT_TASK_NAME_FIELD_NUMBER: _ClassVar[int] + run_id: _identifier_pb2.RunIdentifier + run_time: _timestamp_pb2.Timestamp + phase: _phase_pb2.ActionPhase + root_task_name: str + def __init__(self, run_id: _Optional[_Union[_identifier_pb2.RunIdentifier, _Mapping]] = ..., run_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., phase: _Optional[_Union[_phase_pb2.ActionPhase, str]] = ..., root_task_name: _Optional[str] = ...) -> None: ... + +class TaskMetadata(_message.Message): + __slots__ = ["deployed_by", "short_name", "deployed_at", "environment_name", "triggers_summary", "short_description"] + DEPLOYED_BY_FIELD_NUMBER: _ClassVar[int] + SHORT_NAME_FIELD_NUMBER: _ClassVar[int] + DEPLOYED_AT_FIELD_NUMBER: _ClassVar[int] + ENVIRONMENT_NAME_FIELD_NUMBER: _ClassVar[int] + TRIGGERS_SUMMARY_FIELD_NUMBER: _ClassVar[int] + SHORT_DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + deployed_by: _identity_pb2.EnrichedIdentity + short_name: str + deployed_at: _timestamp_pb2.Timestamp + environment_name: str + triggers_summary: TaskTriggersSummary + short_description: str + def __init__(self, deployed_by: _Optional[_Union[_identity_pb2.EnrichedIdentity, _Mapping]] = ..., short_name: _Optional[str] = ..., deployed_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., environment_name: _Optional[str] = ..., triggers_summary: _Optional[_Union[TaskTriggersSummary, _Mapping]] = ..., short_description: _Optional[str] = ...) -> None: ... + +class TaskSummary(_message.Message): + __slots__ = ["latest_run"] + LATEST_RUN_FIELD_NUMBER: _ClassVar[int] + latest_run: LatestRunSummary + def __init__(self, latest_run: _Optional[_Union[LatestRunSummary, _Mapping]] = ...) -> None: ... + +class Task(_message.Message): + __slots__ = ["task_id", "metadata", "task_summary"] + TASK_ID_FIELD_NUMBER: _ClassVar[int] + METADATA_FIELD_NUMBER: _ClassVar[int] + TASK_SUMMARY_FIELD_NUMBER: _ClassVar[int] + task_id: TaskIdentifier + metadata: TaskMetadata + task_summary: TaskSummary + def __init__(self, task_id: _Optional[_Union[TaskIdentifier, _Mapping]] = ..., metadata: _Optional[_Union[TaskMetadata, _Mapping]] = ..., task_summary: _Optional[_Union[TaskSummary, _Mapping]] = ...) -> None: ... + +class SourceCode(_message.Message): + __slots__ = ["link"] + LINK_FIELD_NUMBER: _ClassVar[int] + link: str + def __init__(self, link: _Optional[str] = ...) -> None: ... + +class DocumentationEntity(_message.Message): + __slots__ = ["short_description", "long_description", "source_code"] + SHORT_DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + LONG_DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + SOURCE_CODE_FIELD_NUMBER: _ClassVar[int] + short_description: str + long_description: str + source_code: SourceCode + def __init__(self, short_description: _Optional[str] = ..., long_description: _Optional[str] = ..., source_code: _Optional[_Union[SourceCode, _Mapping]] = ...) -> None: ... + +class TaskSpec(_message.Message): + __slots__ = ["task_template", "default_inputs", "short_name", "environment", "documentation"] + TASK_TEMPLATE_FIELD_NUMBER: _ClassVar[int] + DEFAULT_INPUTS_FIELD_NUMBER: _ClassVar[int] + SHORT_NAME_FIELD_NUMBER: _ClassVar[int] + ENVIRONMENT_FIELD_NUMBER: _ClassVar[int] + DOCUMENTATION_FIELD_NUMBER: _ClassVar[int] + task_template: _tasks_pb2.TaskTemplate + default_inputs: _containers.RepeatedCompositeFieldContainer[_common_pb2.NamedParameter] + short_name: str + environment: _environment_pb2.Environment + documentation: DocumentationEntity + def __init__(self, task_template: _Optional[_Union[_tasks_pb2.TaskTemplate, _Mapping]] = ..., default_inputs: _Optional[_Iterable[_Union[_common_pb2.NamedParameter, _Mapping]]] = ..., short_name: _Optional[str] = ..., environment: _Optional[_Union[_environment_pb2.Environment, _Mapping]] = ..., documentation: _Optional[_Union[DocumentationEntity, _Mapping]] = ...) -> None: ... + +class TraceSpec(_message.Message): + __slots__ = ["interface"] + INTERFACE_FIELD_NUMBER: _ClassVar[int] + interface: _interface_pb2.TypedInterface + def __init__(self, interface: _Optional[_Union[_interface_pb2.TypedInterface, _Mapping]] = ...) -> None: ... + +class TaskDetails(_message.Message): + __slots__ = ["task_id", "metadata", "spec"] + TASK_ID_FIELD_NUMBER: _ClassVar[int] + METADATA_FIELD_NUMBER: _ClassVar[int] + SPEC_FIELD_NUMBER: _ClassVar[int] + task_id: TaskIdentifier + metadata: TaskMetadata + spec: TaskSpec + def __init__(self, task_id: _Optional[_Union[TaskIdentifier, _Mapping]] = ..., metadata: _Optional[_Union[TaskMetadata, _Mapping]] = ..., spec: _Optional[_Union[TaskSpec, _Mapping]] = ...) -> None: ... + +class TaskTrigger(_message.Message): + __slots__ = ["name", "spec", "automation_spec"] + NAME_FIELD_NUMBER: _ClassVar[int] + SPEC_FIELD_NUMBER: _ClassVar[int] + AUTOMATION_SPEC_FIELD_NUMBER: _ClassVar[int] + name: str + spec: TaskTriggerSpec + automation_spec: _common_pb2.TriggerAutomationSpec + def __init__(self, name: _Optional[str] = ..., spec: _Optional[_Union[TaskTriggerSpec, _Mapping]] = ..., automation_spec: _Optional[_Union[_common_pb2.TriggerAutomationSpec, _Mapping]] = ...) -> None: ... + +class TaskTriggerSpec(_message.Message): + __slots__ = ["active", "inputs", "run_spec", "description"] + ACTIVE_FIELD_NUMBER: _ClassVar[int] + INPUTS_FIELD_NUMBER: _ClassVar[int] + RUN_SPEC_FIELD_NUMBER: _ClassVar[int] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + active: bool + inputs: _common_pb2.Inputs + run_spec: _run_pb2.RunSpec + description: str + def __init__(self, active: bool = ..., inputs: _Optional[_Union[_common_pb2.Inputs, _Mapping]] = ..., run_spec: _Optional[_Union[_run_pb2.RunSpec, _Mapping]] = ..., description: _Optional[str] = ...) -> None: ... diff --git a/gen/python/flyteidl2/task/task_definition_pb2_grpc.py b/gen/python/flyteidl2/task/task_definition_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/task/task_definition_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/task/task_service_pb2.py b/gen/python/flyteidl2/task/task_service_pb2.py new file mode 100644 index 0000000000..d3a60a393d --- /dev/null +++ b/gen/python/flyteidl2/task/task_service_pb2.py @@ -0,0 +1,73 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/task/task_service.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.common import identifier_pb2 as flyteidl2_dot_common_dot_identifier__pb2 +from flyteidl2.common import list_pb2 as flyteidl2_dot_common_dot_list__pb2 +from flyteidl2.task import task_definition_pb2 as flyteidl2_dot_task_dot_task__definition__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n!flyteidl2/task/task_service.proto\x12\x0e\x66lyteidl2.task\x1a\x1b\x62uf/validate/validate.proto\x1a!flyteidl2/common/identifier.proto\x1a\x1b\x66lyteidl2/common/list.proto\x1a$flyteidl2/task/task_definition.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xc3\x01\n\x11\x44\x65ployTaskRequest\x12?\n\x07task_id\x18\x01 \x01(\x0b\x32\x1e.flyteidl2.task.TaskIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x06taskId\x12\x34\n\x04spec\x18\x02 \x01(\x0b\x32\x18.flyteidl2.task.TaskSpecB\x06\xbaH\x03\xc8\x01\x01R\x04spec\x12\x37\n\x08triggers\x18\x03 \x03(\x0b\x32\x1b.flyteidl2.task.TaskTriggerR\x08triggers\"\x14\n\x12\x44\x65ployTaskResponse\"X\n\x15GetTaskDetailsRequest\x12?\n\x07task_id\x18\x01 \x01(\x0b\x32\x1e.flyteidl2.task.TaskIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x06taskId\"O\n\x16GetTaskDetailsResponse\x12\x35\n\x07\x64\x65tails\x18\x01 \x01(\x0b\x32\x1b.flyteidl2.task.TaskDetailsR\x07\x64\x65tails\"\xd3\x02\n\x10ListTasksRequest\x12\x37\n\x07request\x18\x01 \x01(\x0b\x32\x1d.flyteidl2.common.ListRequestR\x07request\x12\x1b\n\x03org\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01H\x00R\x03org\x12\x44\n\nproject_id\x18\x03 \x01(\x0b\x32#.flyteidl2.common.ProjectIdentifierH\x00R\tprojectId\x12Q\n\rknown_filters\x18\x04 \x03(\x0b\x32,.flyteidl2.task.ListTasksRequest.KnownFilterR\x0cknownFilters\x1a=\n\x0bKnownFilter\x12!\n\x0b\x64\x65ployed_by\x18\x01 \x01(\tH\x00R\ndeployedByB\x0b\n\tfilter_byB\x11\n\x08scope_by\x12\x05\xbaH\x02\x08\x01\"\xf8\x01\n\x11ListTasksResponse\x12*\n\x05tasks\x18\x01 \x03(\x0b\x32\x14.flyteidl2.task.TaskR\x05tasks\x12\x14\n\x05token\x18\x02 \x01(\tR\x05token\x12O\n\x08metadata\x18\x03 \x01(\x0b\x32\x33.flyteidl2.task.ListTasksResponse.ListTasksMetadataR\x08metadata\x1aP\n\x11ListTasksMetadata\x12\x14\n\x05total\x18\x01 \x01(\rR\x05total\x12%\n\x0e\x66iltered_total\x18\x02 \x01(\rR\rfilteredTotal\"\x8d\x01\n\x13ListVersionsRequest\x12\x37\n\x07request\x18\x01 \x01(\x0b\x32\x1d.flyteidl2.common.ListRequestR\x07request\x12=\n\ttask_name\x18\x02 \x01(\x0b\x32\x18.flyteidl2.task.TaskNameB\x06\xbaH\x03\xc8\x01\x01R\x08taskName\"\xf0\x01\n\x14ListVersionsResponse\x12P\n\x08versions\x18\x01 \x03(\x0b\x32\x34.flyteidl2.task.ListVersionsResponse.VersionResponseR\x08versions\x12\x14\n\x05token\x18\x02 \x01(\tR\x05token\x1ap\n\x0fVersionResponse\x12\x18\n\x07version\x18\x01 \x01(\tR\x07version\x12\x43\n\x0b\x64\x65ployed_at\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampB\x06\xbaH\x03\xc8\x01\x01R\ndeployedAt2\x81\x03\n\x0bTaskService\x12U\n\nDeployTask\x12!.flyteidl2.task.DeployTaskRequest\x1a\".flyteidl2.task.DeployTaskResponse\"\x00\x12\x64\n\x0eGetTaskDetails\x12%.flyteidl2.task.GetTaskDetailsRequest\x1a&.flyteidl2.task.GetTaskDetailsResponse\"\x03\x90\x02\x01\x12U\n\tListTasks\x12 .flyteidl2.task.ListTasksRequest\x1a!.flyteidl2.task.ListTasksResponse\"\x03\x90\x02\x01\x12^\n\x0cListVersions\x12#.flyteidl2.task.ListVersionsRequest\x1a$.flyteidl2.task.ListVersionsResponse\"\x03\x90\x02\x01\x42\xb5\x01\n\x12\x63om.flyteidl2.taskB\x10TaskServiceProtoH\x02P\x01Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task\xa2\x02\x03\x46TX\xaa\x02\x0e\x46lyteidl2.Task\xca\x02\x0e\x46lyteidl2\\Task\xe2\x02\x1a\x46lyteidl2\\Task\\GPBMetadata\xea\x02\x0f\x46lyteidl2::Taskb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.task.task_service_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\022com.flyteidl2.taskB\020TaskServiceProtoH\002P\001Z2github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task\242\002\003FTX\252\002\016Flyteidl2.Task\312\002\016Flyteidl2\\Task\342\002\032Flyteidl2\\Task\\GPBMetadata\352\002\017Flyteidl2::Task' + _DEPLOYTASKREQUEST.fields_by_name['task_id']._options = None + _DEPLOYTASKREQUEST.fields_by_name['task_id']._serialized_options = b'\272H\003\310\001\001' + _DEPLOYTASKREQUEST.fields_by_name['spec']._options = None + _DEPLOYTASKREQUEST.fields_by_name['spec']._serialized_options = b'\272H\003\310\001\001' + _GETTASKDETAILSREQUEST.fields_by_name['task_id']._options = None + _GETTASKDETAILSREQUEST.fields_by_name['task_id']._serialized_options = b'\272H\003\310\001\001' + _LISTTASKSREQUEST.oneofs_by_name['scope_by']._options = None + _LISTTASKSREQUEST.oneofs_by_name['scope_by']._serialized_options = b'\272H\002\010\001' + _LISTTASKSREQUEST.fields_by_name['org']._options = None + _LISTTASKSREQUEST.fields_by_name['org']._serialized_options = b'\272H\004r\002\020\001' + _LISTVERSIONSREQUEST.fields_by_name['task_name']._options = None + _LISTVERSIONSREQUEST.fields_by_name['task_name']._serialized_options = b'\272H\003\310\001\001' + _LISTVERSIONSRESPONSE_VERSIONRESPONSE.fields_by_name['deployed_at']._options = None + _LISTVERSIONSRESPONSE_VERSIONRESPONSE.fields_by_name['deployed_at']._serialized_options = b'\272H\003\310\001\001' + _TASKSERVICE.methods_by_name['GetTaskDetails']._options = None + _TASKSERVICE.methods_by_name['GetTaskDetails']._serialized_options = b'\220\002\001' + _TASKSERVICE.methods_by_name['ListTasks']._options = None + _TASKSERVICE.methods_by_name['ListTasks']._serialized_options = b'\220\002\001' + _TASKSERVICE.methods_by_name['ListVersions']._options = None + _TASKSERVICE.methods_by_name['ListVersions']._serialized_options = b'\220\002\001' + _globals['_DEPLOYTASKREQUEST']._serialized_start=218 + _globals['_DEPLOYTASKREQUEST']._serialized_end=413 + _globals['_DEPLOYTASKRESPONSE']._serialized_start=415 + _globals['_DEPLOYTASKRESPONSE']._serialized_end=435 + _globals['_GETTASKDETAILSREQUEST']._serialized_start=437 + _globals['_GETTASKDETAILSREQUEST']._serialized_end=525 + _globals['_GETTASKDETAILSRESPONSE']._serialized_start=527 + _globals['_GETTASKDETAILSRESPONSE']._serialized_end=606 + _globals['_LISTTASKSREQUEST']._serialized_start=609 + _globals['_LISTTASKSREQUEST']._serialized_end=948 + _globals['_LISTTASKSREQUEST_KNOWNFILTER']._serialized_start=868 + _globals['_LISTTASKSREQUEST_KNOWNFILTER']._serialized_end=929 + _globals['_LISTTASKSRESPONSE']._serialized_start=951 + _globals['_LISTTASKSRESPONSE']._serialized_end=1199 + _globals['_LISTTASKSRESPONSE_LISTTASKSMETADATA']._serialized_start=1119 + _globals['_LISTTASKSRESPONSE_LISTTASKSMETADATA']._serialized_end=1199 + _globals['_LISTVERSIONSREQUEST']._serialized_start=1202 + _globals['_LISTVERSIONSREQUEST']._serialized_end=1343 + _globals['_LISTVERSIONSRESPONSE']._serialized_start=1346 + _globals['_LISTVERSIONSRESPONSE']._serialized_end=1586 + _globals['_LISTVERSIONSRESPONSE_VERSIONRESPONSE']._serialized_start=1474 + _globals['_LISTVERSIONSRESPONSE_VERSIONRESPONSE']._serialized_end=1586 + _globals['_TASKSERVICE']._serialized_start=1589 + _globals['_TASKSERVICE']._serialized_end=1974 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/task/task_service_pb2.pyi b/gen/python/flyteidl2/task/task_service_pb2.pyi new file mode 100644 index 0000000000..376541c098 --- /dev/null +++ b/gen/python/flyteidl2/task/task_service_pb2.pyi @@ -0,0 +1,94 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.common import identifier_pb2 as _identifier_pb2 +from flyteidl2.common import list_pb2 as _list_pb2 +from flyteidl2.task import task_definition_pb2 as _task_definition_pb2 +from google.protobuf import timestamp_pb2 as _timestamp_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class DeployTaskRequest(_message.Message): + __slots__ = ["task_id", "spec", "triggers"] + TASK_ID_FIELD_NUMBER: _ClassVar[int] + SPEC_FIELD_NUMBER: _ClassVar[int] + TRIGGERS_FIELD_NUMBER: _ClassVar[int] + task_id: _task_definition_pb2.TaskIdentifier + spec: _task_definition_pb2.TaskSpec + triggers: _containers.RepeatedCompositeFieldContainer[_task_definition_pb2.TaskTrigger] + def __init__(self, task_id: _Optional[_Union[_task_definition_pb2.TaskIdentifier, _Mapping]] = ..., spec: _Optional[_Union[_task_definition_pb2.TaskSpec, _Mapping]] = ..., triggers: _Optional[_Iterable[_Union[_task_definition_pb2.TaskTrigger, _Mapping]]] = ...) -> None: ... + +class DeployTaskResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class GetTaskDetailsRequest(_message.Message): + __slots__ = ["task_id"] + TASK_ID_FIELD_NUMBER: _ClassVar[int] + task_id: _task_definition_pb2.TaskIdentifier + def __init__(self, task_id: _Optional[_Union[_task_definition_pb2.TaskIdentifier, _Mapping]] = ...) -> None: ... + +class GetTaskDetailsResponse(_message.Message): + __slots__ = ["details"] + DETAILS_FIELD_NUMBER: _ClassVar[int] + details: _task_definition_pb2.TaskDetails + def __init__(self, details: _Optional[_Union[_task_definition_pb2.TaskDetails, _Mapping]] = ...) -> None: ... + +class ListTasksRequest(_message.Message): + __slots__ = ["request", "org", "project_id", "known_filters"] + class KnownFilter(_message.Message): + __slots__ = ["deployed_by"] + DEPLOYED_BY_FIELD_NUMBER: _ClassVar[int] + deployed_by: str + def __init__(self, deployed_by: _Optional[str] = ...) -> None: ... + REQUEST_FIELD_NUMBER: _ClassVar[int] + ORG_FIELD_NUMBER: _ClassVar[int] + PROJECT_ID_FIELD_NUMBER: _ClassVar[int] + KNOWN_FILTERS_FIELD_NUMBER: _ClassVar[int] + request: _list_pb2.ListRequest + org: str + project_id: _identifier_pb2.ProjectIdentifier + known_filters: _containers.RepeatedCompositeFieldContainer[ListTasksRequest.KnownFilter] + def __init__(self, request: _Optional[_Union[_list_pb2.ListRequest, _Mapping]] = ..., org: _Optional[str] = ..., project_id: _Optional[_Union[_identifier_pb2.ProjectIdentifier, _Mapping]] = ..., known_filters: _Optional[_Iterable[_Union[ListTasksRequest.KnownFilter, _Mapping]]] = ...) -> None: ... + +class ListTasksResponse(_message.Message): + __slots__ = ["tasks", "token", "metadata"] + class ListTasksMetadata(_message.Message): + __slots__ = ["total", "filtered_total"] + TOTAL_FIELD_NUMBER: _ClassVar[int] + FILTERED_TOTAL_FIELD_NUMBER: _ClassVar[int] + total: int + filtered_total: int + def __init__(self, total: _Optional[int] = ..., filtered_total: _Optional[int] = ...) -> None: ... + TASKS_FIELD_NUMBER: _ClassVar[int] + TOKEN_FIELD_NUMBER: _ClassVar[int] + METADATA_FIELD_NUMBER: _ClassVar[int] + tasks: _containers.RepeatedCompositeFieldContainer[_task_definition_pb2.Task] + token: str + metadata: ListTasksResponse.ListTasksMetadata + def __init__(self, tasks: _Optional[_Iterable[_Union[_task_definition_pb2.Task, _Mapping]]] = ..., token: _Optional[str] = ..., metadata: _Optional[_Union[ListTasksResponse.ListTasksMetadata, _Mapping]] = ...) -> None: ... + +class ListVersionsRequest(_message.Message): + __slots__ = ["request", "task_name"] + REQUEST_FIELD_NUMBER: _ClassVar[int] + TASK_NAME_FIELD_NUMBER: _ClassVar[int] + request: _list_pb2.ListRequest + task_name: _task_definition_pb2.TaskName + def __init__(self, request: _Optional[_Union[_list_pb2.ListRequest, _Mapping]] = ..., task_name: _Optional[_Union[_task_definition_pb2.TaskName, _Mapping]] = ...) -> None: ... + +class ListVersionsResponse(_message.Message): + __slots__ = ["versions", "token"] + class VersionResponse(_message.Message): + __slots__ = ["version", "deployed_at"] + VERSION_FIELD_NUMBER: _ClassVar[int] + DEPLOYED_AT_FIELD_NUMBER: _ClassVar[int] + version: str + deployed_at: _timestamp_pb2.Timestamp + def __init__(self, version: _Optional[str] = ..., deployed_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ...) -> None: ... + VERSIONS_FIELD_NUMBER: _ClassVar[int] + TOKEN_FIELD_NUMBER: _ClassVar[int] + versions: _containers.RepeatedCompositeFieldContainer[ListVersionsResponse.VersionResponse] + token: str + def __init__(self, versions: _Optional[_Iterable[_Union[ListVersionsResponse.VersionResponse, _Mapping]]] = ..., token: _Optional[str] = ...) -> None: ... diff --git a/gen/python/flyteidl2/task/task_service_pb2_grpc.py b/gen/python/flyteidl2/task/task_service_pb2_grpc.py new file mode 100644 index 0000000000..f4b68f1caa --- /dev/null +++ b/gen/python/flyteidl2/task/task_service_pb2_grpc.py @@ -0,0 +1,172 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from flyteidl2.task import task_service_pb2 as flyteidl2_dot_task_dot_task__service__pb2 + + +class TaskServiceStub(object): + """TaskService provides an interface for managing tasks. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.DeployTask = channel.unary_unary( + '/flyteidl2.task.TaskService/DeployTask', + request_serializer=flyteidl2_dot_task_dot_task__service__pb2.DeployTaskRequest.SerializeToString, + response_deserializer=flyteidl2_dot_task_dot_task__service__pb2.DeployTaskResponse.FromString, + ) + self.GetTaskDetails = channel.unary_unary( + '/flyteidl2.task.TaskService/GetTaskDetails', + request_serializer=flyteidl2_dot_task_dot_task__service__pb2.GetTaskDetailsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_task_dot_task__service__pb2.GetTaskDetailsResponse.FromString, + ) + self.ListTasks = channel.unary_unary( + '/flyteidl2.task.TaskService/ListTasks', + request_serializer=flyteidl2_dot_task_dot_task__service__pb2.ListTasksRequest.SerializeToString, + response_deserializer=flyteidl2_dot_task_dot_task__service__pb2.ListTasksResponse.FromString, + ) + self.ListVersions = channel.unary_unary( + '/flyteidl2.task.TaskService/ListVersions', + request_serializer=flyteidl2_dot_task_dot_task__service__pb2.ListVersionsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_task_dot_task__service__pb2.ListVersionsResponse.FromString, + ) + + +class TaskServiceServicer(object): + """TaskService provides an interface for managing tasks. + """ + + def DeployTask(self, request, context): + """Deploy a task. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetTaskDetails(self, request, context): + """Get detailed information about a task. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListTasks(self, request, context): + """Lists tasks, one per task name, returning the latest version and who it was deployed by. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListVersions(self, request, context): + """Lists all versions for a task. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_TaskServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'DeployTask': grpc.unary_unary_rpc_method_handler( + servicer.DeployTask, + request_deserializer=flyteidl2_dot_task_dot_task__service__pb2.DeployTaskRequest.FromString, + response_serializer=flyteidl2_dot_task_dot_task__service__pb2.DeployTaskResponse.SerializeToString, + ), + 'GetTaskDetails': grpc.unary_unary_rpc_method_handler( + servicer.GetTaskDetails, + request_deserializer=flyteidl2_dot_task_dot_task__service__pb2.GetTaskDetailsRequest.FromString, + response_serializer=flyteidl2_dot_task_dot_task__service__pb2.GetTaskDetailsResponse.SerializeToString, + ), + 'ListTasks': grpc.unary_unary_rpc_method_handler( + servicer.ListTasks, + request_deserializer=flyteidl2_dot_task_dot_task__service__pb2.ListTasksRequest.FromString, + response_serializer=flyteidl2_dot_task_dot_task__service__pb2.ListTasksResponse.SerializeToString, + ), + 'ListVersions': grpc.unary_unary_rpc_method_handler( + servicer.ListVersions, + request_deserializer=flyteidl2_dot_task_dot_task__service__pb2.ListVersionsRequest.FromString, + response_serializer=flyteidl2_dot_task_dot_task__service__pb2.ListVersionsResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.task.TaskService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class TaskService(object): + """TaskService provides an interface for managing tasks. + """ + + @staticmethod + def DeployTask(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.task.TaskService/DeployTask', + flyteidl2_dot_task_dot_task__service__pb2.DeployTaskRequest.SerializeToString, + flyteidl2_dot_task_dot_task__service__pb2.DeployTaskResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetTaskDetails(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.task.TaskService/GetTaskDetails', + flyteidl2_dot_task_dot_task__service__pb2.GetTaskDetailsRequest.SerializeToString, + flyteidl2_dot_task_dot_task__service__pb2.GetTaskDetailsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListTasks(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.task.TaskService/ListTasks', + flyteidl2_dot_task_dot_task__service__pb2.ListTasksRequest.SerializeToString, + flyteidl2_dot_task_dot_task__service__pb2.ListTasksResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListVersions(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.task.TaskService/ListVersions', + flyteidl2_dot_task_dot_task__service__pb2.ListVersionsRequest.SerializeToString, + flyteidl2_dot_task_dot_task__service__pb2.ListVersionsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/gen/python/flyteidl2/trigger/__init__.py b/gen/python/flyteidl2/trigger/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/trigger/trigger_definition_pb2.py b/gen/python/flyteidl2/trigger/trigger_definition_pb2.py new file mode 100644 index 0000000000..d590e6031e --- /dev/null +++ b/gen/python/flyteidl2/trigger/trigger_definition_pb2.py @@ -0,0 +1,60 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/trigger/trigger_definition.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.common import identifier_pb2 as flyteidl2_dot_common_dot_identifier__pb2 +from flyteidl2.common import identity_pb2 as flyteidl2_dot_common_dot_identity__pb2 +from flyteidl2.task import common_pb2 as flyteidl2_dot_task_dot_common__pb2 +from flyteidl2.task import run_pb2 as flyteidl2_dot_task_dot_run__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n*flyteidl2/trigger/trigger_definition.proto\x12\x11\x66lyteidl2.trigger\x1a\x1b\x62uf/validate/validate.proto\x1a!flyteidl2/common/identifier.proto\x1a\x1f\x66lyteidl2/common/identity.proto\x1a\x1b\x66lyteidl2/task/common.proto\x1a\x18\x66lyteidl2/task/run.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xa9\x01\n\x0fTriggerMetadata\x12K\n\x0b\x64\x65ployed_by\x18\x01 \x01(\x0b\x32\".flyteidl2.common.EnrichedIdentityB\x06\xbaH\x03\xc8\x01\x01R\ndeployedBy\x12I\n\nupdated_by\x18\x02 \x01(\x0b\x32\".flyteidl2.common.EnrichedIdentityB\x06\xbaH\x03\xc8\x01\x01R\tupdatedBy\"\xdf\x01\n\x0bTriggerSpec\x12.\n\x06inputs\x18\x02 \x01(\x0b\x32\x16.flyteidl2.task.InputsR\x06inputs\x12\x32\n\x08run_spec\x18\x03 \x01(\x0b\x32\x17.flyteidl2.task.RunSpecR\x07runSpec\x12\x16\n\x06\x61\x63tive\x18\x04 \x01(\x08R\x06\x61\x63tive\x12,\n\x0ctask_version\x18\x05 \x01(\tB\t\xbaH\x06r\x04\x10\x01\x18?R\x0btaskVersion\x12 \n\x0b\x64\x65scription\x18\x06 \x01(\tR\x0b\x64\x65scriptionJ\x04\x08\x01\x10\x02\"\x91\x02\n\rTriggerStatus\x12\x43\n\x0b\x64\x65ployed_at\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.TimestampB\x06\xbaH\x03\xc8\x01\x01R\ndeployedAt\x12\x41\n\nupdated_at\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampB\x06\xbaH\x03\xc8\x01\x01R\tupdatedAt\x12=\n\x0ctriggered_at\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x0btriggeredAt\x12\x39\n\ndeleted_at\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\tdeletedAt\"\xbd\x02\n\x0fTriggerRevision\x12\x33\n\x02id\x18\x01 \x01(\x0b\x32#.flyteidl2.common.TriggerIdentifierR\x02id\x12>\n\x08metadata\x18\x02 \x01(\x0b\x32\".flyteidl2.trigger.TriggerMetadataR\x08metadata\x12\x38\n\x06status\x18\x03 \x01(\x0b\x32 .flyteidl2.trigger.TriggerStatusR\x06status\x12@\n\x06\x61\x63tion\x18\x04 \x01(\x0e\x32(.flyteidl2.trigger.TriggerRevisionActionR\x06\x61\x63tion\x12\x39\n\ncreated_at\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\tcreatedAt\"\x94\x03\n\x0eTriggerDetails\x12;\n\x02id\x18\x01 \x01(\x0b\x32#.flyteidl2.common.TriggerIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x02id\x12>\n\x08metadata\x18\x02 \x01(\x0b\x32\".flyteidl2.trigger.TriggerMetadataR\x08metadata\x12:\n\x04spec\x18\x03 \x01(\x0b\x32\x1e.flyteidl2.trigger.TriggerSpecB\x06\xbaH\x03\xc8\x01\x01R\x04spec\x12\x38\n\x06status\x18\x04 \x01(\x0b\x32 .flyteidl2.trigger.TriggerStatusR\x06status\x12N\n\x0f\x61utomation_spec\x18\x05 \x01(\x0b\x32%.flyteidl2.task.TriggerAutomationSpecR\x0e\x61utomationSpec\x12/\n\x0b\x64\x65scription\x18\x06 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01H\x00R\x0b\x64\x65scription\x88\x01\x01\x42\x0e\n\x0c_description\"\xa6\x02\n\x07Trigger\x12\x33\n\x02id\x18\x01 \x01(\x0b\x32#.flyteidl2.common.TriggerIdentifierR\x02id\x12>\n\x08metadata\x18\x02 \x01(\x0b\x32\".flyteidl2.trigger.TriggerMetadataR\x08metadata\x12\x38\n\x06status\x18\x03 \x01(\x0b\x32 .flyteidl2.trigger.TriggerStatusR\x06status\x12\x16\n\x06\x61\x63tive\x18\x05 \x01(\x08R\x06\x61\x63tive\x12N\n\x0f\x61utomation_spec\x18\x06 \x01(\x0b\x32%.flyteidl2.task.TriggerAutomationSpecR\x0e\x61utomationSpecJ\x04\x08\x04\x10\x05*\xd6\x01\n\x15TriggerRevisionAction\x12\'\n#TRIGGER_REVISION_ACTION_UNSPECIFIED\x10\x00\x12\"\n\x1eTRIGGER_REVISION_ACTION_DEPLOY\x10\x01\x12$\n TRIGGER_REVISION_ACTION_ACTIVATE\x10\x02\x12&\n\"TRIGGER_REVISION_ACTION_DEACTIVATE\x10\x03\x12\"\n\x1eTRIGGER_REVISION_ACTION_DELETE\x10\x04\x42\xcd\x01\n\x15\x63om.flyteidl2.triggerB\x16TriggerDefinitionProtoH\x02P\x01Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/trigger\xa2\x02\x03\x46TX\xaa\x02\x11\x46lyteidl2.Trigger\xca\x02\x11\x46lyteidl2\\Trigger\xe2\x02\x1d\x46lyteidl2\\Trigger\\GPBMetadata\xea\x02\x12\x46lyteidl2::Triggerb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.trigger.trigger_definition_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\025com.flyteidl2.triggerB\026TriggerDefinitionProtoH\002P\001Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/trigger\242\002\003FTX\252\002\021Flyteidl2.Trigger\312\002\021Flyteidl2\\Trigger\342\002\035Flyteidl2\\Trigger\\GPBMetadata\352\002\022Flyteidl2::Trigger' + _TRIGGERMETADATA.fields_by_name['deployed_by']._options = None + _TRIGGERMETADATA.fields_by_name['deployed_by']._serialized_options = b'\272H\003\310\001\001' + _TRIGGERMETADATA.fields_by_name['updated_by']._options = None + _TRIGGERMETADATA.fields_by_name['updated_by']._serialized_options = b'\272H\003\310\001\001' + _TRIGGERSPEC.fields_by_name['task_version']._options = None + _TRIGGERSPEC.fields_by_name['task_version']._serialized_options = b'\272H\006r\004\020\001\030?' + _TRIGGERSTATUS.fields_by_name['deployed_at']._options = None + _TRIGGERSTATUS.fields_by_name['deployed_at']._serialized_options = b'\272H\003\310\001\001' + _TRIGGERSTATUS.fields_by_name['updated_at']._options = None + _TRIGGERSTATUS.fields_by_name['updated_at']._serialized_options = b'\272H\003\310\001\001' + _TRIGGERDETAILS.fields_by_name['id']._options = None + _TRIGGERDETAILS.fields_by_name['id']._serialized_options = b'\272H\003\310\001\001' + _TRIGGERDETAILS.fields_by_name['spec']._options = None + _TRIGGERDETAILS.fields_by_name['spec']._serialized_options = b'\272H\003\310\001\001' + _TRIGGERDETAILS.fields_by_name['description']._options = None + _TRIGGERDETAILS.fields_by_name['description']._serialized_options = b'\272H\005r\003\030\377\001' + _globals['_TRIGGERREVISIONACTION']._serialized_start=1949 + _globals['_TRIGGERREVISIONACTION']._serialized_end=2163 + _globals['_TRIGGERMETADATA']._serialized_start=251 + _globals['_TRIGGERMETADATA']._serialized_end=420 + _globals['_TRIGGERSPEC']._serialized_start=423 + _globals['_TRIGGERSPEC']._serialized_end=646 + _globals['_TRIGGERSTATUS']._serialized_start=649 + _globals['_TRIGGERSTATUS']._serialized_end=922 + _globals['_TRIGGERREVISION']._serialized_start=925 + _globals['_TRIGGERREVISION']._serialized_end=1242 + _globals['_TRIGGERDETAILS']._serialized_start=1245 + _globals['_TRIGGERDETAILS']._serialized_end=1649 + _globals['_TRIGGER']._serialized_start=1652 + _globals['_TRIGGER']._serialized_end=1946 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/trigger/trigger_definition_pb2.pyi b/gen/python/flyteidl2/trigger/trigger_definition_pb2.pyi new file mode 100644 index 0000000000..08a0e83874 --- /dev/null +++ b/gen/python/flyteidl2/trigger/trigger_definition_pb2.pyi @@ -0,0 +1,103 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.common import identifier_pb2 as _identifier_pb2 +from flyteidl2.common import identity_pb2 as _identity_pb2 +from flyteidl2.task import common_pb2 as _common_pb2 +from flyteidl2.task import run_pb2 as _run_pb2 +from google.protobuf import timestamp_pb2 as _timestamp_pb2 +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class TriggerRevisionAction(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + TRIGGER_REVISION_ACTION_UNSPECIFIED: _ClassVar[TriggerRevisionAction] + TRIGGER_REVISION_ACTION_DEPLOY: _ClassVar[TriggerRevisionAction] + TRIGGER_REVISION_ACTION_ACTIVATE: _ClassVar[TriggerRevisionAction] + TRIGGER_REVISION_ACTION_DEACTIVATE: _ClassVar[TriggerRevisionAction] + TRIGGER_REVISION_ACTION_DELETE: _ClassVar[TriggerRevisionAction] +TRIGGER_REVISION_ACTION_UNSPECIFIED: TriggerRevisionAction +TRIGGER_REVISION_ACTION_DEPLOY: TriggerRevisionAction +TRIGGER_REVISION_ACTION_ACTIVATE: TriggerRevisionAction +TRIGGER_REVISION_ACTION_DEACTIVATE: TriggerRevisionAction +TRIGGER_REVISION_ACTION_DELETE: TriggerRevisionAction + +class TriggerMetadata(_message.Message): + __slots__ = ["deployed_by", "updated_by"] + DEPLOYED_BY_FIELD_NUMBER: _ClassVar[int] + UPDATED_BY_FIELD_NUMBER: _ClassVar[int] + deployed_by: _identity_pb2.EnrichedIdentity + updated_by: _identity_pb2.EnrichedIdentity + def __init__(self, deployed_by: _Optional[_Union[_identity_pb2.EnrichedIdentity, _Mapping]] = ..., updated_by: _Optional[_Union[_identity_pb2.EnrichedIdentity, _Mapping]] = ...) -> None: ... + +class TriggerSpec(_message.Message): + __slots__ = ["inputs", "run_spec", "active", "task_version", "description"] + INPUTS_FIELD_NUMBER: _ClassVar[int] + RUN_SPEC_FIELD_NUMBER: _ClassVar[int] + ACTIVE_FIELD_NUMBER: _ClassVar[int] + TASK_VERSION_FIELD_NUMBER: _ClassVar[int] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + inputs: _common_pb2.Inputs + run_spec: _run_pb2.RunSpec + active: bool + task_version: str + description: str + def __init__(self, inputs: _Optional[_Union[_common_pb2.Inputs, _Mapping]] = ..., run_spec: _Optional[_Union[_run_pb2.RunSpec, _Mapping]] = ..., active: bool = ..., task_version: _Optional[str] = ..., description: _Optional[str] = ...) -> None: ... + +class TriggerStatus(_message.Message): + __slots__ = ["deployed_at", "updated_at", "triggered_at", "deleted_at"] + DEPLOYED_AT_FIELD_NUMBER: _ClassVar[int] + UPDATED_AT_FIELD_NUMBER: _ClassVar[int] + TRIGGERED_AT_FIELD_NUMBER: _ClassVar[int] + DELETED_AT_FIELD_NUMBER: _ClassVar[int] + deployed_at: _timestamp_pb2.Timestamp + updated_at: _timestamp_pb2.Timestamp + triggered_at: _timestamp_pb2.Timestamp + deleted_at: _timestamp_pb2.Timestamp + def __init__(self, deployed_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., updated_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., triggered_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., deleted_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ...) -> None: ... + +class TriggerRevision(_message.Message): + __slots__ = ["id", "metadata", "status", "action", "created_at"] + ID_FIELD_NUMBER: _ClassVar[int] + METADATA_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + ACTION_FIELD_NUMBER: _ClassVar[int] + CREATED_AT_FIELD_NUMBER: _ClassVar[int] + id: _identifier_pb2.TriggerIdentifier + metadata: TriggerMetadata + status: TriggerStatus + action: TriggerRevisionAction + created_at: _timestamp_pb2.Timestamp + def __init__(self, id: _Optional[_Union[_identifier_pb2.TriggerIdentifier, _Mapping]] = ..., metadata: _Optional[_Union[TriggerMetadata, _Mapping]] = ..., status: _Optional[_Union[TriggerStatus, _Mapping]] = ..., action: _Optional[_Union[TriggerRevisionAction, str]] = ..., created_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ...) -> None: ... + +class TriggerDetails(_message.Message): + __slots__ = ["id", "metadata", "spec", "status", "automation_spec", "description"] + ID_FIELD_NUMBER: _ClassVar[int] + METADATA_FIELD_NUMBER: _ClassVar[int] + SPEC_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + AUTOMATION_SPEC_FIELD_NUMBER: _ClassVar[int] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + id: _identifier_pb2.TriggerIdentifier + metadata: TriggerMetadata + spec: TriggerSpec + status: TriggerStatus + automation_spec: _common_pb2.TriggerAutomationSpec + description: str + def __init__(self, id: _Optional[_Union[_identifier_pb2.TriggerIdentifier, _Mapping]] = ..., metadata: _Optional[_Union[TriggerMetadata, _Mapping]] = ..., spec: _Optional[_Union[TriggerSpec, _Mapping]] = ..., status: _Optional[_Union[TriggerStatus, _Mapping]] = ..., automation_spec: _Optional[_Union[_common_pb2.TriggerAutomationSpec, _Mapping]] = ..., description: _Optional[str] = ...) -> None: ... + +class Trigger(_message.Message): + __slots__ = ["id", "metadata", "status", "active", "automation_spec"] + ID_FIELD_NUMBER: _ClassVar[int] + METADATA_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + ACTIVE_FIELD_NUMBER: _ClassVar[int] + AUTOMATION_SPEC_FIELD_NUMBER: _ClassVar[int] + id: _identifier_pb2.TriggerIdentifier + metadata: TriggerMetadata + status: TriggerStatus + active: bool + automation_spec: _common_pb2.TriggerAutomationSpec + def __init__(self, id: _Optional[_Union[_identifier_pb2.TriggerIdentifier, _Mapping]] = ..., metadata: _Optional[_Union[TriggerMetadata, _Mapping]] = ..., status: _Optional[_Union[TriggerStatus, _Mapping]] = ..., active: bool = ..., automation_spec: _Optional[_Union[_common_pb2.TriggerAutomationSpec, _Mapping]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/trigger/trigger_definition_pb2_grpc.py b/gen/python/flyteidl2/trigger/trigger_definition_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/trigger/trigger_definition_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/trigger/trigger_service_pb2.py b/gen/python/flyteidl2/trigger/trigger_service_pb2.py new file mode 100644 index 0000000000..65e3c4a7e4 --- /dev/null +++ b/gen/python/flyteidl2/trigger/trigger_service_pb2.py @@ -0,0 +1,92 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/trigger/trigger_service.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.common import identifier_pb2 as flyteidl2_dot_common_dot_identifier__pb2 +from flyteidl2.common import list_pb2 as flyteidl2_dot_common_dot_list__pb2 +from flyteidl2.task import common_pb2 as flyteidl2_dot_task_dot_common__pb2 +from flyteidl2.task import task_definition_pb2 as flyteidl2_dot_task_dot_task__definition__pb2 +from flyteidl2.trigger import trigger_definition_pb2 as flyteidl2_dot_trigger_dot_trigger__definition__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\'flyteidl2/trigger/trigger_service.proto\x12\x11\x66lyteidl2.trigger\x1a\x1b\x62uf/validate/validate.proto\x1a!flyteidl2/common/identifier.proto\x1a\x1b\x66lyteidl2/common/list.proto\x1a\x1b\x66lyteidl2/task/common.proto\x1a$flyteidl2/task/task_definition.proto\x1a*flyteidl2/trigger/trigger_definition.proto\"\xff\x01\n\x14\x44\x65ployTriggerRequest\x12\x39\n\x04name\x18\x04 \x01(\x0b\x32\x1d.flyteidl2.common.TriggerNameB\x06\xbaH\x03\xc8\x01\x01R\x04name\x12\x1a\n\x08revision\x18\x05 \x01(\x04R\x08revision\x12:\n\x04spec\x18\x02 \x01(\x0b\x32\x1e.flyteidl2.trigger.TriggerSpecB\x06\xbaH\x03\xc8\x01\x01R\x04spec\x12N\n\x0f\x61utomation_spec\x18\x03 \x01(\x0b\x32%.flyteidl2.task.TriggerAutomationSpecR\x0e\x61utomationSpecJ\x04\x08\x01\x10\x02\"\\\n\x15\x44\x65ployTriggerResponse\x12\x43\n\x07trigger\x18\x01 \x01(\x0b\x32!.flyteidl2.trigger.TriggerDetailsB\x06\xbaH\x03\xc8\x01\x01R\x07trigger\"U\n\x18GetTriggerDetailsRequest\x12\x39\n\x04name\x18\x01 \x01(\x0b\x32\x1d.flyteidl2.common.TriggerNameB\x06\xbaH\x03\xc8\x01\x01R\x04name\"`\n\x19GetTriggerDetailsResponse\x12\x43\n\x07trigger\x18\x01 \x01(\x0b\x32!.flyteidl2.trigger.TriggerDetailsB\x06\xbaH\x03\xc8\x01\x01R\x07trigger\"_\n GetTriggerRevisionDetailsRequest\x12;\n\x02id\x18\x01 \x01(\x0b\x32#.flyteidl2.common.TriggerIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x02id\"h\n!GetTriggerRevisionDetailsResponse\x12\x43\n\x07trigger\x18\x01 \x01(\x0b\x32!.flyteidl2.trigger.TriggerDetailsB\x06\xbaH\x03\xc8\x01\x01R\x07trigger\"\xb8\x02\n\x13ListTriggersRequest\x12\x37\n\x07request\x18\x01 \x01(\x0b\x32\x1d.flyteidl2.common.ListRequestR\x07request\x12\x1b\n\x03org\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01H\x00R\x03org\x12\x44\n\nproject_id\x18\x03 \x01(\x0b\x32#.flyteidl2.common.ProjectIdentifierH\x00R\tprojectId\x12\x39\n\x07task_id\x18\x04 \x01(\x0b\x32\x1e.flyteidl2.task.TaskIdentifierH\x00R\x06taskId\x12\x37\n\ttask_name\x18\x05 \x01(\x0b\x32\x18.flyteidl2.task.TaskNameH\x00R\x08taskNameB\x11\n\x08scope_by\x12\x05\xbaH\x02\x08\x01\"d\n\x14ListTriggersResponse\x12\x36\n\x08triggers\x18\x01 \x03(\x0b\x32\x1a.flyteidl2.trigger.TriggerR\x08triggers\x12\x14\n\x05token\x18\x02 \x01(\tR\x05token\"\x96\x01\n GetTriggerRevisionHistoryRequest\x12\x37\n\x07request\x18\x01 \x01(\x0b\x32\x1d.flyteidl2.common.ListRequestR\x07request\x12\x39\n\x04name\x18\x02 \x01(\x0b\x32\x1d.flyteidl2.common.TriggerNameB\x06\xbaH\x03\xc8\x01\x01R\x04name\"y\n!GetTriggerRevisionHistoryResponse\x12>\n\x08triggers\x18\x01 \x03(\x0b\x32\".flyteidl2.trigger.TriggerRevisionR\x08triggers\x12\x14\n\x05token\x18\x02 \x01(\tR\x05token\"n\n\x15UpdateTriggersRequest\x12=\n\x05names\x18\x01 \x03(\x0b\x32\x1d.flyteidl2.common.TriggerNameB\x08\xbaH\x05\x92\x01\x02\x08\x01R\x05names\x12\x16\n\x06\x61\x63tive\x18\x02 \x01(\x08R\x06\x61\x63tive\"\x18\n\x16UpdateTriggersResponse\"V\n\x15\x44\x65leteTriggersRequest\x12=\n\x05names\x18\x01 \x03(\x0b\x32\x1d.flyteidl2.common.TriggerNameB\x08\xbaH\x05\x92\x01\x02\x08\x01R\x05names\"\x18\n\x16\x44\x65leteTriggersResponse2\xbf\x06\n\x0eTriggerService\x12\x64\n\rDeployTrigger\x12\'.flyteidl2.trigger.DeployTriggerRequest\x1a(.flyteidl2.trigger.DeployTriggerResponse\"\x00\x12s\n\x11GetTriggerDetails\x12+.flyteidl2.trigger.GetTriggerDetailsRequest\x1a,.flyteidl2.trigger.GetTriggerDetailsResponse\"\x03\x90\x02\x01\x12\x8b\x01\n\x19GetTriggerRevisionDetails\x12\x33.flyteidl2.trigger.GetTriggerRevisionDetailsRequest\x1a\x34.flyteidl2.trigger.GetTriggerRevisionDetailsResponse\"\x03\x90\x02\x01\x12\x64\n\x0cListTriggers\x12&.flyteidl2.trigger.ListTriggersRequest\x1a\'.flyteidl2.trigger.ListTriggersResponse\"\x03\x90\x02\x01\x12\x8b\x01\n\x19GetTriggerRevisionHistory\x12\x33.flyteidl2.trigger.GetTriggerRevisionHistoryRequest\x1a\x34.flyteidl2.trigger.GetTriggerRevisionHistoryResponse\"\x03\x90\x02\x01\x12g\n\x0eUpdateTriggers\x12(.flyteidl2.trigger.UpdateTriggersRequest\x1a).flyteidl2.trigger.UpdateTriggersResponse\"\x00\x12g\n\x0e\x44\x65leteTriggers\x12(.flyteidl2.trigger.DeleteTriggersRequest\x1a).flyteidl2.trigger.DeleteTriggersResponse\"\x00\x42\xca\x01\n\x15\x63om.flyteidl2.triggerB\x13TriggerServiceProtoH\x02P\x01Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/trigger\xa2\x02\x03\x46TX\xaa\x02\x11\x46lyteidl2.Trigger\xca\x02\x11\x46lyteidl2\\Trigger\xe2\x02\x1d\x46lyteidl2\\Trigger\\GPBMetadata\xea\x02\x12\x46lyteidl2::Triggerb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.trigger.trigger_service_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\025com.flyteidl2.triggerB\023TriggerServiceProtoH\002P\001Z5github.com/flyteorg/flyte/v2/gen/go/flyteidl2/trigger\242\002\003FTX\252\002\021Flyteidl2.Trigger\312\002\021Flyteidl2\\Trigger\342\002\035Flyteidl2\\Trigger\\GPBMetadata\352\002\022Flyteidl2::Trigger' + _DEPLOYTRIGGERREQUEST.fields_by_name['name']._options = None + _DEPLOYTRIGGERREQUEST.fields_by_name['name']._serialized_options = b'\272H\003\310\001\001' + _DEPLOYTRIGGERREQUEST.fields_by_name['spec']._options = None + _DEPLOYTRIGGERREQUEST.fields_by_name['spec']._serialized_options = b'\272H\003\310\001\001' + _DEPLOYTRIGGERRESPONSE.fields_by_name['trigger']._options = None + _DEPLOYTRIGGERRESPONSE.fields_by_name['trigger']._serialized_options = b'\272H\003\310\001\001' + _GETTRIGGERDETAILSREQUEST.fields_by_name['name']._options = None + _GETTRIGGERDETAILSREQUEST.fields_by_name['name']._serialized_options = b'\272H\003\310\001\001' + _GETTRIGGERDETAILSRESPONSE.fields_by_name['trigger']._options = None + _GETTRIGGERDETAILSRESPONSE.fields_by_name['trigger']._serialized_options = b'\272H\003\310\001\001' + _GETTRIGGERREVISIONDETAILSREQUEST.fields_by_name['id']._options = None + _GETTRIGGERREVISIONDETAILSREQUEST.fields_by_name['id']._serialized_options = b'\272H\003\310\001\001' + _GETTRIGGERREVISIONDETAILSRESPONSE.fields_by_name['trigger']._options = None + _GETTRIGGERREVISIONDETAILSRESPONSE.fields_by_name['trigger']._serialized_options = b'\272H\003\310\001\001' + _LISTTRIGGERSREQUEST.oneofs_by_name['scope_by']._options = None + _LISTTRIGGERSREQUEST.oneofs_by_name['scope_by']._serialized_options = b'\272H\002\010\001' + _LISTTRIGGERSREQUEST.fields_by_name['org']._options = None + _LISTTRIGGERSREQUEST.fields_by_name['org']._serialized_options = b'\272H\004r\002\020\001' + _GETTRIGGERREVISIONHISTORYREQUEST.fields_by_name['name']._options = None + _GETTRIGGERREVISIONHISTORYREQUEST.fields_by_name['name']._serialized_options = b'\272H\003\310\001\001' + _UPDATETRIGGERSREQUEST.fields_by_name['names']._options = None + _UPDATETRIGGERSREQUEST.fields_by_name['names']._serialized_options = b'\272H\005\222\001\002\010\001' + _DELETETRIGGERSREQUEST.fields_by_name['names']._options = None + _DELETETRIGGERSREQUEST.fields_by_name['names']._serialized_options = b'\272H\005\222\001\002\010\001' + _TRIGGERSERVICE.methods_by_name['GetTriggerDetails']._options = None + _TRIGGERSERVICE.methods_by_name['GetTriggerDetails']._serialized_options = b'\220\002\001' + _TRIGGERSERVICE.methods_by_name['GetTriggerRevisionDetails']._options = None + _TRIGGERSERVICE.methods_by_name['GetTriggerRevisionDetails']._serialized_options = b'\220\002\001' + _TRIGGERSERVICE.methods_by_name['ListTriggers']._options = None + _TRIGGERSERVICE.methods_by_name['ListTriggers']._serialized_options = b'\220\002\001' + _TRIGGERSERVICE.methods_by_name['GetTriggerRevisionHistory']._options = None + _TRIGGERSERVICE.methods_by_name['GetTriggerRevisionHistory']._serialized_options = b'\220\002\001' + _globals['_DEPLOYTRIGGERREQUEST']._serialized_start=267 + _globals['_DEPLOYTRIGGERREQUEST']._serialized_end=522 + _globals['_DEPLOYTRIGGERRESPONSE']._serialized_start=524 + _globals['_DEPLOYTRIGGERRESPONSE']._serialized_end=616 + _globals['_GETTRIGGERDETAILSREQUEST']._serialized_start=618 + _globals['_GETTRIGGERDETAILSREQUEST']._serialized_end=703 + _globals['_GETTRIGGERDETAILSRESPONSE']._serialized_start=705 + _globals['_GETTRIGGERDETAILSRESPONSE']._serialized_end=801 + _globals['_GETTRIGGERREVISIONDETAILSREQUEST']._serialized_start=803 + _globals['_GETTRIGGERREVISIONDETAILSREQUEST']._serialized_end=898 + _globals['_GETTRIGGERREVISIONDETAILSRESPONSE']._serialized_start=900 + _globals['_GETTRIGGERREVISIONDETAILSRESPONSE']._serialized_end=1004 + _globals['_LISTTRIGGERSREQUEST']._serialized_start=1007 + _globals['_LISTTRIGGERSREQUEST']._serialized_end=1319 + _globals['_LISTTRIGGERSRESPONSE']._serialized_start=1321 + _globals['_LISTTRIGGERSRESPONSE']._serialized_end=1421 + _globals['_GETTRIGGERREVISIONHISTORYREQUEST']._serialized_start=1424 + _globals['_GETTRIGGERREVISIONHISTORYREQUEST']._serialized_end=1574 + _globals['_GETTRIGGERREVISIONHISTORYRESPONSE']._serialized_start=1576 + _globals['_GETTRIGGERREVISIONHISTORYRESPONSE']._serialized_end=1697 + _globals['_UPDATETRIGGERSREQUEST']._serialized_start=1699 + _globals['_UPDATETRIGGERSREQUEST']._serialized_end=1809 + _globals['_UPDATETRIGGERSRESPONSE']._serialized_start=1811 + _globals['_UPDATETRIGGERSRESPONSE']._serialized_end=1835 + _globals['_DELETETRIGGERSREQUEST']._serialized_start=1837 + _globals['_DELETETRIGGERSREQUEST']._serialized_end=1923 + _globals['_DELETETRIGGERSRESPONSE']._serialized_start=1925 + _globals['_DELETETRIGGERSRESPONSE']._serialized_end=1949 + _globals['_TRIGGERSERVICE']._serialized_start=1952 + _globals['_TRIGGERSERVICE']._serialized_end=2783 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/trigger/trigger_service_pb2.pyi b/gen/python/flyteidl2/trigger/trigger_service_pb2.pyi new file mode 100644 index 0000000000..d29f4d94e7 --- /dev/null +++ b/gen/python/flyteidl2/trigger/trigger_service_pb2.pyi @@ -0,0 +1,114 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.common import identifier_pb2 as _identifier_pb2 +from flyteidl2.common import list_pb2 as _list_pb2 +from flyteidl2.task import common_pb2 as _common_pb2 +from flyteidl2.task import task_definition_pb2 as _task_definition_pb2 +from flyteidl2.trigger import trigger_definition_pb2 as _trigger_definition_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class DeployTriggerRequest(_message.Message): + __slots__ = ["name", "revision", "spec", "automation_spec"] + NAME_FIELD_NUMBER: _ClassVar[int] + REVISION_FIELD_NUMBER: _ClassVar[int] + SPEC_FIELD_NUMBER: _ClassVar[int] + AUTOMATION_SPEC_FIELD_NUMBER: _ClassVar[int] + name: _identifier_pb2.TriggerName + revision: int + spec: _trigger_definition_pb2.TriggerSpec + automation_spec: _common_pb2.TriggerAutomationSpec + def __init__(self, name: _Optional[_Union[_identifier_pb2.TriggerName, _Mapping]] = ..., revision: _Optional[int] = ..., spec: _Optional[_Union[_trigger_definition_pb2.TriggerSpec, _Mapping]] = ..., automation_spec: _Optional[_Union[_common_pb2.TriggerAutomationSpec, _Mapping]] = ...) -> None: ... + +class DeployTriggerResponse(_message.Message): + __slots__ = ["trigger"] + TRIGGER_FIELD_NUMBER: _ClassVar[int] + trigger: _trigger_definition_pb2.TriggerDetails + def __init__(self, trigger: _Optional[_Union[_trigger_definition_pb2.TriggerDetails, _Mapping]] = ...) -> None: ... + +class GetTriggerDetailsRequest(_message.Message): + __slots__ = ["name"] + NAME_FIELD_NUMBER: _ClassVar[int] + name: _identifier_pb2.TriggerName + def __init__(self, name: _Optional[_Union[_identifier_pb2.TriggerName, _Mapping]] = ...) -> None: ... + +class GetTriggerDetailsResponse(_message.Message): + __slots__ = ["trigger"] + TRIGGER_FIELD_NUMBER: _ClassVar[int] + trigger: _trigger_definition_pb2.TriggerDetails + def __init__(self, trigger: _Optional[_Union[_trigger_definition_pb2.TriggerDetails, _Mapping]] = ...) -> None: ... + +class GetTriggerRevisionDetailsRequest(_message.Message): + __slots__ = ["id"] + ID_FIELD_NUMBER: _ClassVar[int] + id: _identifier_pb2.TriggerIdentifier + def __init__(self, id: _Optional[_Union[_identifier_pb2.TriggerIdentifier, _Mapping]] = ...) -> None: ... + +class GetTriggerRevisionDetailsResponse(_message.Message): + __slots__ = ["trigger"] + TRIGGER_FIELD_NUMBER: _ClassVar[int] + trigger: _trigger_definition_pb2.TriggerDetails + def __init__(self, trigger: _Optional[_Union[_trigger_definition_pb2.TriggerDetails, _Mapping]] = ...) -> None: ... + +class ListTriggersRequest(_message.Message): + __slots__ = ["request", "org", "project_id", "task_id", "task_name"] + REQUEST_FIELD_NUMBER: _ClassVar[int] + ORG_FIELD_NUMBER: _ClassVar[int] + PROJECT_ID_FIELD_NUMBER: _ClassVar[int] + TASK_ID_FIELD_NUMBER: _ClassVar[int] + TASK_NAME_FIELD_NUMBER: _ClassVar[int] + request: _list_pb2.ListRequest + org: str + project_id: _identifier_pb2.ProjectIdentifier + task_id: _task_definition_pb2.TaskIdentifier + task_name: _task_definition_pb2.TaskName + def __init__(self, request: _Optional[_Union[_list_pb2.ListRequest, _Mapping]] = ..., org: _Optional[str] = ..., project_id: _Optional[_Union[_identifier_pb2.ProjectIdentifier, _Mapping]] = ..., task_id: _Optional[_Union[_task_definition_pb2.TaskIdentifier, _Mapping]] = ..., task_name: _Optional[_Union[_task_definition_pb2.TaskName, _Mapping]] = ...) -> None: ... + +class ListTriggersResponse(_message.Message): + __slots__ = ["triggers", "token"] + TRIGGERS_FIELD_NUMBER: _ClassVar[int] + TOKEN_FIELD_NUMBER: _ClassVar[int] + triggers: _containers.RepeatedCompositeFieldContainer[_trigger_definition_pb2.Trigger] + token: str + def __init__(self, triggers: _Optional[_Iterable[_Union[_trigger_definition_pb2.Trigger, _Mapping]]] = ..., token: _Optional[str] = ...) -> None: ... + +class GetTriggerRevisionHistoryRequest(_message.Message): + __slots__ = ["request", "name"] + REQUEST_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + request: _list_pb2.ListRequest + name: _identifier_pb2.TriggerName + def __init__(self, request: _Optional[_Union[_list_pb2.ListRequest, _Mapping]] = ..., name: _Optional[_Union[_identifier_pb2.TriggerName, _Mapping]] = ...) -> None: ... + +class GetTriggerRevisionHistoryResponse(_message.Message): + __slots__ = ["triggers", "token"] + TRIGGERS_FIELD_NUMBER: _ClassVar[int] + TOKEN_FIELD_NUMBER: _ClassVar[int] + triggers: _containers.RepeatedCompositeFieldContainer[_trigger_definition_pb2.TriggerRevision] + token: str + def __init__(self, triggers: _Optional[_Iterable[_Union[_trigger_definition_pb2.TriggerRevision, _Mapping]]] = ..., token: _Optional[str] = ...) -> None: ... + +class UpdateTriggersRequest(_message.Message): + __slots__ = ["names", "active"] + NAMES_FIELD_NUMBER: _ClassVar[int] + ACTIVE_FIELD_NUMBER: _ClassVar[int] + names: _containers.RepeatedCompositeFieldContainer[_identifier_pb2.TriggerName] + active: bool + def __init__(self, names: _Optional[_Iterable[_Union[_identifier_pb2.TriggerName, _Mapping]]] = ..., active: bool = ...) -> None: ... + +class UpdateTriggersResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class DeleteTriggersRequest(_message.Message): + __slots__ = ["names"] + NAMES_FIELD_NUMBER: _ClassVar[int] + names: _containers.RepeatedCompositeFieldContainer[_identifier_pb2.TriggerName] + def __init__(self, names: _Optional[_Iterable[_Union[_identifier_pb2.TriggerName, _Mapping]]] = ...) -> None: ... + +class DeleteTriggersResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... diff --git a/gen/python/flyteidl2/trigger/trigger_service_pb2_grpc.py b/gen/python/flyteidl2/trigger/trigger_service_pb2_grpc.py new file mode 100644 index 0000000000..5ac14d4860 --- /dev/null +++ b/gen/python/flyteidl2/trigger/trigger_service_pb2_grpc.py @@ -0,0 +1,281 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from flyteidl2.trigger import trigger_service_pb2 as flyteidl2_dot_trigger_dot_trigger__service__pb2 + + +class TriggerServiceStub(object): + """TriggerService provides an interface for managing triggers. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.DeployTrigger = channel.unary_unary( + '/flyteidl2.trigger.TriggerService/DeployTrigger', + request_serializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.DeployTriggerRequest.SerializeToString, + response_deserializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.DeployTriggerResponse.FromString, + ) + self.GetTriggerDetails = channel.unary_unary( + '/flyteidl2.trigger.TriggerService/GetTriggerDetails', + request_serializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.GetTriggerDetailsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.GetTriggerDetailsResponse.FromString, + ) + self.GetTriggerRevisionDetails = channel.unary_unary( + '/flyteidl2.trigger.TriggerService/GetTriggerRevisionDetails', + request_serializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.GetTriggerRevisionDetailsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.GetTriggerRevisionDetailsResponse.FromString, + ) + self.ListTriggers = channel.unary_unary( + '/flyteidl2.trigger.TriggerService/ListTriggers', + request_serializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.ListTriggersRequest.SerializeToString, + response_deserializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.ListTriggersResponse.FromString, + ) + self.GetTriggerRevisionHistory = channel.unary_unary( + '/flyteidl2.trigger.TriggerService/GetTriggerRevisionHistory', + request_serializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.GetTriggerRevisionHistoryRequest.SerializeToString, + response_deserializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.GetTriggerRevisionHistoryResponse.FromString, + ) + self.UpdateTriggers = channel.unary_unary( + '/flyteidl2.trigger.TriggerService/UpdateTriggers', + request_serializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.UpdateTriggersRequest.SerializeToString, + response_deserializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.UpdateTriggersResponse.FromString, + ) + self.DeleteTriggers = channel.unary_unary( + '/flyteidl2.trigger.TriggerService/DeleteTriggers', + request_serializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.DeleteTriggersRequest.SerializeToString, + response_deserializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.DeleteTriggersResponse.FromString, + ) + + +class TriggerServiceServicer(object): + """TriggerService provides an interface for managing triggers. + """ + + def DeployTrigger(self, request, context): + """Create if trigger didn't exist previously. + Update if it already exists. + Re-create(or undelete) if it was soft-deleted. + Client must fetch the latest trigger in order to obtain the latest `trigger.id.revision`. + If trigger is not found, client can set `trigger.id.revision` to 1, it is ignored and set automatically by backend. + If trigger is found, client should set `trigger.id.revision` to the . + Backend validates that version is the latest and creates a new revision of the trigger. + Otherwise, operation is rejected(optimistic locking) and client must re-fetch trigger again. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetTriggerDetails(self, request, context): + """Get detailed info about the latest trigger revision + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetTriggerRevisionDetails(self, request, context): + """Get detailed info about a specific trigger revision + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListTriggers(self, request, context): + """List basic info about triggers based on various filtering and sorting rules. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetTriggerRevisionHistory(self, request, context): + """GetTriggerRevisionHistory returns all revisions for a given trigger + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateTriggers(self, request, context): + """Update some trigger spec fields for multiple triggers at once + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DeleteTriggers(self, request, context): + """Soft-delete multiple triggers at once. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_TriggerServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'DeployTrigger': grpc.unary_unary_rpc_method_handler( + servicer.DeployTrigger, + request_deserializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.DeployTriggerRequest.FromString, + response_serializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.DeployTriggerResponse.SerializeToString, + ), + 'GetTriggerDetails': grpc.unary_unary_rpc_method_handler( + servicer.GetTriggerDetails, + request_deserializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.GetTriggerDetailsRequest.FromString, + response_serializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.GetTriggerDetailsResponse.SerializeToString, + ), + 'GetTriggerRevisionDetails': grpc.unary_unary_rpc_method_handler( + servicer.GetTriggerRevisionDetails, + request_deserializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.GetTriggerRevisionDetailsRequest.FromString, + response_serializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.GetTriggerRevisionDetailsResponse.SerializeToString, + ), + 'ListTriggers': grpc.unary_unary_rpc_method_handler( + servicer.ListTriggers, + request_deserializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.ListTriggersRequest.FromString, + response_serializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.ListTriggersResponse.SerializeToString, + ), + 'GetTriggerRevisionHistory': grpc.unary_unary_rpc_method_handler( + servicer.GetTriggerRevisionHistory, + request_deserializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.GetTriggerRevisionHistoryRequest.FromString, + response_serializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.GetTriggerRevisionHistoryResponse.SerializeToString, + ), + 'UpdateTriggers': grpc.unary_unary_rpc_method_handler( + servicer.UpdateTriggers, + request_deserializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.UpdateTriggersRequest.FromString, + response_serializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.UpdateTriggersResponse.SerializeToString, + ), + 'DeleteTriggers': grpc.unary_unary_rpc_method_handler( + servicer.DeleteTriggers, + request_deserializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.DeleteTriggersRequest.FromString, + response_serializer=flyteidl2_dot_trigger_dot_trigger__service__pb2.DeleteTriggersResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.trigger.TriggerService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class TriggerService(object): + """TriggerService provides an interface for managing triggers. + """ + + @staticmethod + def DeployTrigger(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.trigger.TriggerService/DeployTrigger', + flyteidl2_dot_trigger_dot_trigger__service__pb2.DeployTriggerRequest.SerializeToString, + flyteidl2_dot_trigger_dot_trigger__service__pb2.DeployTriggerResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetTriggerDetails(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.trigger.TriggerService/GetTriggerDetails', + flyteidl2_dot_trigger_dot_trigger__service__pb2.GetTriggerDetailsRequest.SerializeToString, + flyteidl2_dot_trigger_dot_trigger__service__pb2.GetTriggerDetailsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetTriggerRevisionDetails(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.trigger.TriggerService/GetTriggerRevisionDetails', + flyteidl2_dot_trigger_dot_trigger__service__pb2.GetTriggerRevisionDetailsRequest.SerializeToString, + flyteidl2_dot_trigger_dot_trigger__service__pb2.GetTriggerRevisionDetailsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListTriggers(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.trigger.TriggerService/ListTriggers', + flyteidl2_dot_trigger_dot_trigger__service__pb2.ListTriggersRequest.SerializeToString, + flyteidl2_dot_trigger_dot_trigger__service__pb2.ListTriggersResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetTriggerRevisionHistory(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.trigger.TriggerService/GetTriggerRevisionHistory', + flyteidl2_dot_trigger_dot_trigger__service__pb2.GetTriggerRevisionHistoryRequest.SerializeToString, + flyteidl2_dot_trigger_dot_trigger__service__pb2.GetTriggerRevisionHistoryResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def UpdateTriggers(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.trigger.TriggerService/UpdateTriggers', + flyteidl2_dot_trigger_dot_trigger__service__pb2.UpdateTriggersRequest.SerializeToString, + flyteidl2_dot_trigger_dot_trigger__service__pb2.UpdateTriggersResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DeleteTriggers(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.trigger.TriggerService/DeleteTriggers', + flyteidl2_dot_trigger_dot_trigger__service__pb2.DeleteTriggersRequest.SerializeToString, + flyteidl2_dot_trigger_dot_trigger__service__pb2.DeleteTriggersResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/gen/python/flyteidl2/workflow/__init__.py b/gen/python/flyteidl2/workflow/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/flyteidl2/workflow/queue_service_pb2.py b/gen/python/flyteidl2/workflow/queue_service_pb2.py new file mode 100644 index 0000000000..a077f15123 --- /dev/null +++ b/gen/python/flyteidl2/workflow/queue_service_pb2.py @@ -0,0 +1,55 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/workflow/queue_service.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.common import identifier_pb2 as flyteidl2_dot_common_dot_identifier__pb2 +from flyteidl2.task import common_pb2 as flyteidl2_dot_task_dot_common__pb2 +from flyteidl2.task import run_pb2 as flyteidl2_dot_task_dot_run__pb2 +from flyteidl2.workflow import run_definition_pb2 as flyteidl2_dot_workflow_dot_run__definition__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n&flyteidl2/workflow/queue_service.proto\x12\x12\x66lyteidl2.workflow\x1a\x1b\x62uf/validate/validate.proto\x1a!flyteidl2/common/identifier.proto\x1a\x1b\x66lyteidl2/task/common.proto\x1a\x18\x66lyteidl2/task/run.proto\x1a\'flyteidl2/workflow/run_definition.proto\"\xa7\x04\n\x14\x45nqueueActionRequest\x12G\n\taction_id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x08\x61\x63tionId\x12\x31\n\x12parent_action_name\x18\x02 \x01(\tH\x01R\x10parentActionName\x88\x01\x01\x12\x32\n\x08run_spec\x18\x03 \x01(\x0b\x32\x17.flyteidl2.task.RunSpecR\x07runSpec\x12$\n\tinput_uri\x18\x06 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x08inputUri\x12/\n\x0frun_output_base\x18\x07 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\rrunOutputBase\x12\x14\n\x05group\x18\x08 \x01(\tR\x05group\x12\x18\n\x07subject\x18\t \x01(\tR\x07subject\x12\x34\n\x04task\x18\n \x01(\x0b\x32\x1e.flyteidl2.workflow.TaskActionH\x00R\x04task\x12\x37\n\x05trace\x18\x0b \x01(\x0b\x32\x1f.flyteidl2.workflow.TraceActionH\x00R\x05trace\x12\x43\n\tcondition\x18\x0c \x01(\x0b\x32#.flyteidl2.workflow.ConditionActionH\x00R\tconditionB\r\n\x04spec\x12\x05\xbaH\x02\x08\x01\x42\x15\n\x13_parent_action_name\"\x17\n\x15\x45nqueueActionResponse\"\x7f\n\x15\x41\x62ortQueuedRunRequest\x12>\n\x06run_id\x18\x01 \x01(\x0b\x32\x1f.flyteidl2.common.RunIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x05runId\x12\x1b\n\x06reason\x18\x02 \x01(\tH\x00R\x06reason\x88\x01\x01\x42\t\n\x07_reason\"\x18\n\x16\x41\x62ortQueuedRunResponse\"\x8b\x01\n\x18\x41\x62ortQueuedActionRequest\x12G\n\taction_id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x08\x61\x63tionId\x12\x1b\n\x06reason\x18\x02 \x01(\tH\x00R\x06reason\x88\x01\x01\x42\t\n\x07_reason\"\x1b\n\x19\x41\x62ortQueuedActionResponse2\xd5\x02\n\x0cQueueService\x12\x66\n\rEnqueueAction\x12(.flyteidl2.workflow.EnqueueActionRequest\x1a).flyteidl2.workflow.EnqueueActionResponse\"\x00\x12i\n\x0e\x41\x62ortQueuedRun\x12).flyteidl2.workflow.AbortQueuedRunRequest\x1a*.flyteidl2.workflow.AbortQueuedRunResponse\"\x00\x12r\n\x11\x41\x62ortQueuedAction\x12,.flyteidl2.workflow.AbortQueuedActionRequest\x1a-.flyteidl2.workflow.AbortQueuedActionResponse\"\x00\x42\xce\x01\n\x16\x63om.flyteidl2.workflowB\x11QueueServiceProtoH\x02P\x01Z6github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow\xa2\x02\x03\x46WX\xaa\x02\x12\x46lyteidl2.Workflow\xca\x02\x12\x46lyteidl2\\Workflow\xe2\x02\x1e\x46lyteidl2\\Workflow\\GPBMetadata\xea\x02\x13\x46lyteidl2::Workflowb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.workflow.queue_service_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\026com.flyteidl2.workflowB\021QueueServiceProtoH\002P\001Z6github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow\242\002\003FWX\252\002\022Flyteidl2.Workflow\312\002\022Flyteidl2\\Workflow\342\002\036Flyteidl2\\Workflow\\GPBMetadata\352\002\023Flyteidl2::Workflow' + _ENQUEUEACTIONREQUEST.oneofs_by_name['spec']._options = None + _ENQUEUEACTIONREQUEST.oneofs_by_name['spec']._serialized_options = b'\272H\002\010\001' + _ENQUEUEACTIONREQUEST.fields_by_name['action_id']._options = None + _ENQUEUEACTIONREQUEST.fields_by_name['action_id']._serialized_options = b'\272H\003\310\001\001' + _ENQUEUEACTIONREQUEST.fields_by_name['input_uri']._options = None + _ENQUEUEACTIONREQUEST.fields_by_name['input_uri']._serialized_options = b'\272H\004r\002\020\001' + _ENQUEUEACTIONREQUEST.fields_by_name['run_output_base']._options = None + _ENQUEUEACTIONREQUEST.fields_by_name['run_output_base']._serialized_options = b'\272H\004r\002\020\001' + _ABORTQUEUEDRUNREQUEST.fields_by_name['run_id']._options = None + _ABORTQUEUEDRUNREQUEST.fields_by_name['run_id']._serialized_options = b'\272H\003\310\001\001' + _ABORTQUEUEDACTIONREQUEST.fields_by_name['action_id']._options = None + _ABORTQUEUEDACTIONREQUEST.fields_by_name['action_id']._serialized_options = b'\272H\003\310\001\001' + _globals['_ENQUEUEACTIONREQUEST']._serialized_start=223 + _globals['_ENQUEUEACTIONREQUEST']._serialized_end=774 + _globals['_ENQUEUEACTIONRESPONSE']._serialized_start=776 + _globals['_ENQUEUEACTIONRESPONSE']._serialized_end=799 + _globals['_ABORTQUEUEDRUNREQUEST']._serialized_start=801 + _globals['_ABORTQUEUEDRUNREQUEST']._serialized_end=928 + _globals['_ABORTQUEUEDRUNRESPONSE']._serialized_start=930 + _globals['_ABORTQUEUEDRUNRESPONSE']._serialized_end=954 + _globals['_ABORTQUEUEDACTIONREQUEST']._serialized_start=957 + _globals['_ABORTQUEUEDACTIONREQUEST']._serialized_end=1096 + _globals['_ABORTQUEUEDACTIONRESPONSE']._serialized_start=1098 + _globals['_ABORTQUEUEDACTIONRESPONSE']._serialized_end=1125 + _globals['_QUEUESERVICE']._serialized_start=1128 + _globals['_QUEUESERVICE']._serialized_end=1469 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/workflow/queue_service_pb2.pyi b/gen/python/flyteidl2/workflow/queue_service_pb2.pyi new file mode 100644 index 0000000000..2c5e945c06 --- /dev/null +++ b/gen/python/flyteidl2/workflow/queue_service_pb2.pyi @@ -0,0 +1,62 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.common import identifier_pb2 as _identifier_pb2 +from flyteidl2.task import common_pb2 as _common_pb2 +from flyteidl2.task import run_pb2 as _run_pb2 +from flyteidl2.workflow import run_definition_pb2 as _run_definition_pb2 +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class EnqueueActionRequest(_message.Message): + __slots__ = ["action_id", "parent_action_name", "run_spec", "input_uri", "run_output_base", "group", "subject", "task", "trace", "condition"] + ACTION_ID_FIELD_NUMBER: _ClassVar[int] + PARENT_ACTION_NAME_FIELD_NUMBER: _ClassVar[int] + RUN_SPEC_FIELD_NUMBER: _ClassVar[int] + INPUT_URI_FIELD_NUMBER: _ClassVar[int] + RUN_OUTPUT_BASE_FIELD_NUMBER: _ClassVar[int] + GROUP_FIELD_NUMBER: _ClassVar[int] + SUBJECT_FIELD_NUMBER: _ClassVar[int] + TASK_FIELD_NUMBER: _ClassVar[int] + TRACE_FIELD_NUMBER: _ClassVar[int] + CONDITION_FIELD_NUMBER: _ClassVar[int] + action_id: _identifier_pb2.ActionIdentifier + parent_action_name: str + run_spec: _run_pb2.RunSpec + input_uri: str + run_output_base: str + group: str + subject: str + task: _run_definition_pb2.TaskAction + trace: _run_definition_pb2.TraceAction + condition: _run_definition_pb2.ConditionAction + def __init__(self, action_id: _Optional[_Union[_identifier_pb2.ActionIdentifier, _Mapping]] = ..., parent_action_name: _Optional[str] = ..., run_spec: _Optional[_Union[_run_pb2.RunSpec, _Mapping]] = ..., input_uri: _Optional[str] = ..., run_output_base: _Optional[str] = ..., group: _Optional[str] = ..., subject: _Optional[str] = ..., task: _Optional[_Union[_run_definition_pb2.TaskAction, _Mapping]] = ..., trace: _Optional[_Union[_run_definition_pb2.TraceAction, _Mapping]] = ..., condition: _Optional[_Union[_run_definition_pb2.ConditionAction, _Mapping]] = ...) -> None: ... + +class EnqueueActionResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class AbortQueuedRunRequest(_message.Message): + __slots__ = ["run_id", "reason"] + RUN_ID_FIELD_NUMBER: _ClassVar[int] + REASON_FIELD_NUMBER: _ClassVar[int] + run_id: _identifier_pb2.RunIdentifier + reason: str + def __init__(self, run_id: _Optional[_Union[_identifier_pb2.RunIdentifier, _Mapping]] = ..., reason: _Optional[str] = ...) -> None: ... + +class AbortQueuedRunResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class AbortQueuedActionRequest(_message.Message): + __slots__ = ["action_id", "reason"] + ACTION_ID_FIELD_NUMBER: _ClassVar[int] + REASON_FIELD_NUMBER: _ClassVar[int] + action_id: _identifier_pb2.ActionIdentifier + reason: str + def __init__(self, action_id: _Optional[_Union[_identifier_pb2.ActionIdentifier, _Mapping]] = ..., reason: _Optional[str] = ...) -> None: ... + +class AbortQueuedActionResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... diff --git a/gen/python/flyteidl2/workflow/queue_service_pb2_grpc.py b/gen/python/flyteidl2/workflow/queue_service_pb2_grpc.py new file mode 100644 index 0000000000..9b2c08747f --- /dev/null +++ b/gen/python/flyteidl2/workflow/queue_service_pb2_grpc.py @@ -0,0 +1,138 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from flyteidl2.workflow import queue_service_pb2 as flyteidl2_dot_workflow_dot_queue__service__pb2 + + +class QueueServiceStub(object): + """provides an interface for managing execution of runs over a collection of workers. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.EnqueueAction = channel.unary_unary( + '/flyteidl2.workflow.QueueService/EnqueueAction', + request_serializer=flyteidl2_dot_workflow_dot_queue__service__pb2.EnqueueActionRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_queue__service__pb2.EnqueueActionResponse.FromString, + ) + self.AbortQueuedRun = channel.unary_unary( + '/flyteidl2.workflow.QueueService/AbortQueuedRun', + request_serializer=flyteidl2_dot_workflow_dot_queue__service__pb2.AbortQueuedRunRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_queue__service__pb2.AbortQueuedRunResponse.FromString, + ) + self.AbortQueuedAction = channel.unary_unary( + '/flyteidl2.workflow.QueueService/AbortQueuedAction', + request_serializer=flyteidl2_dot_workflow_dot_queue__service__pb2.AbortQueuedActionRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_queue__service__pb2.AbortQueuedActionResponse.FromString, + ) + + +class QueueServiceServicer(object): + """provides an interface for managing execution of runs over a collection of workers. + """ + + def EnqueueAction(self, request, context): + """queue a new action for execution. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AbortQueuedRun(self, request, context): + """abort a queued run. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AbortQueuedAction(self, request, context): + """AbortAction aborts a single action that was previously queued or is currently being processed by a worker. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_QueueServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'EnqueueAction': grpc.unary_unary_rpc_method_handler( + servicer.EnqueueAction, + request_deserializer=flyteidl2_dot_workflow_dot_queue__service__pb2.EnqueueActionRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_queue__service__pb2.EnqueueActionResponse.SerializeToString, + ), + 'AbortQueuedRun': grpc.unary_unary_rpc_method_handler( + servicer.AbortQueuedRun, + request_deserializer=flyteidl2_dot_workflow_dot_queue__service__pb2.AbortQueuedRunRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_queue__service__pb2.AbortQueuedRunResponse.SerializeToString, + ), + 'AbortQueuedAction': grpc.unary_unary_rpc_method_handler( + servicer.AbortQueuedAction, + request_deserializer=flyteidl2_dot_workflow_dot_queue__service__pb2.AbortQueuedActionRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_queue__service__pb2.AbortQueuedActionResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.workflow.QueueService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class QueueService(object): + """provides an interface for managing execution of runs over a collection of workers. + """ + + @staticmethod + def EnqueueAction(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.workflow.QueueService/EnqueueAction', + flyteidl2_dot_workflow_dot_queue__service__pb2.EnqueueActionRequest.SerializeToString, + flyteidl2_dot_workflow_dot_queue__service__pb2.EnqueueActionResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def AbortQueuedRun(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.workflow.QueueService/AbortQueuedRun', + flyteidl2_dot_workflow_dot_queue__service__pb2.AbortQueuedRunRequest.SerializeToString, + flyteidl2_dot_workflow_dot_queue__service__pb2.AbortQueuedRunResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def AbortQueuedAction(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.workflow.QueueService/AbortQueuedAction', + flyteidl2_dot_workflow_dot_queue__service__pb2.AbortQueuedActionRequest.SerializeToString, + flyteidl2_dot_workflow_dot_queue__service__pb2.AbortQueuedActionResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/gen/python/flyteidl2/workflow/run_definition_pb2.py b/gen/python/flyteidl2/workflow/run_definition_pb2.py new file mode 100644 index 0000000000..93fea9f89d --- /dev/null +++ b/gen/python/flyteidl2/workflow/run_definition_pb2.py @@ -0,0 +1,135 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/workflow/run_definition.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.common import identifier_pb2 as flyteidl2_dot_common_dot_identifier__pb2 +from flyteidl2.common import identity_pb2 as flyteidl2_dot_common_dot_identity__pb2 +from flyteidl2.common import phase_pb2 as flyteidl2_dot_common_dot_phase__pb2 +from flyteidl2.core import catalog_pb2 as flyteidl2_dot_core_dot_catalog__pb2 +from flyteidl2.core import execution_pb2 as flyteidl2_dot_core_dot_execution__pb2 +from flyteidl2.core import types_pb2 as flyteidl2_dot_core_dot_types__pb2 +from flyteidl2.task import common_pb2 as flyteidl2_dot_task_dot_common__pb2 +from flyteidl2.task import run_pb2 as flyteidl2_dot_task_dot_run__pb2 +from flyteidl2.task import task_definition_pb2 as flyteidl2_dot_task_dot_task__definition__pb2 +from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 +from google.protobuf import wrappers_pb2 as google_dot_protobuf_dot_wrappers__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\'flyteidl2/workflow/run_definition.proto\x12\x12\x66lyteidl2.workflow\x1a\x1b\x62uf/validate/validate.proto\x1a!flyteidl2/common/identifier.proto\x1a\x1f\x66lyteidl2/common/identity.proto\x1a\x1c\x66lyteidl2/common/phase.proto\x1a\x1c\x66lyteidl2/core/catalog.proto\x1a\x1e\x66lyteidl2/core/execution.proto\x1a\x1a\x66lyteidl2/core/types.proto\x1a\x1b\x66lyteidl2/task/common.proto\x1a\x18\x66lyteidl2/task/run.proto\x1a$flyteidl2/task/task_definition.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1egoogle/protobuf/wrappers.proto\"9\n\x03Run\x12\x32\n\x06\x61\x63tion\x18\x01 \x01(\x0b\x32\x1a.flyteidl2.workflow.ActionR\x06\x61\x63tion\"{\n\nRunDetails\x12\x32\n\x08run_spec\x18\x01 \x01(\x0b\x32\x17.flyteidl2.task.RunSpecR\x07runSpec\x12\x39\n\x06\x61\x63tion\x18\x02 \x01(\x0b\x32!.flyteidl2.workflow.ActionDetailsR\x06\x61\x63tion\"\xc7\x01\n\nTaskAction\x12.\n\x02id\x18\x01 \x01(\x0b\x32\x1e.flyteidl2.task.TaskIdentifierR\x02id\x12\x34\n\x04spec\x18\x02 \x01(\x0b\x32\x18.flyteidl2.task.TaskSpecB\x06\xbaH\x03\xc8\x01\x01R\x04spec\x12\x39\n\tcache_key\x18\x03 \x01(\x0b\x32\x1c.google.protobuf.StringValueR\x08\x63\x61\x63heKey\x12\x18\n\x07\x63luster\x18\x04 \x01(\tR\x07\x63luster\"\xd6\x02\n\x0bTraceAction\x12\x1b\n\x04name\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x04name\x12\x33\n\x05phase\x18\x02 \x01(\x0e\x32\x1d.flyteidl2.common.ActionPhaseR\x05phase\x12\x39\n\nstart_time\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\tstartTime\x12:\n\x08\x65nd_time\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.TimestampH\x00R\x07\x65ndTime\x88\x01\x01\x12:\n\x07outputs\x18\x05 \x01(\x0b\x32 .flyteidl2.task.OutputReferencesR\x07outputs\x12\x35\n\x04spec\x18\x06 \x01(\x0b\x32\x19.flyteidl2.task.TraceSpecB\x06\xbaH\x03\xc8\x01\x01R\x04specB\x0b\n\t_end_time\"\x8d\x02\n\x0f\x43onditionAction\x12\x1b\n\x04name\x18\x01 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x04name\x12 \n\x06run_id\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01H\x00R\x05runId\x12&\n\taction_id\x18\x03 \x01(\tB\x07\xbaH\x04r\x02\x10\x01H\x00R\x08\x61\x63tionId\x12\x18\n\x06global\x18\x04 \x01(\x08H\x00R\x06global\x12/\n\x04type\x18\x06 \x01(\x0b\x32\x1b.flyteidl2.core.LiteralTypeR\x04type\x12\x16\n\x06prompt\x18\x07 \x01(\tR\x06prompt\x12 \n\x0b\x64\x65scription\x18\x08 \x01(\tR\x0b\x64\x65scriptionB\x0e\n\x05scope\x12\x05\xbaH\x02\x08\x01\"\x80\x01\n\x12TaskActionMetadata\x12.\n\x02id\x18\x01 \x01(\x0b\x32\x1e.flyteidl2.task.TaskIdentifierR\x02id\x12\x1b\n\ttask_type\x18\x02 \x01(\tR\x08taskType\x12\x1d\n\nshort_name\x18\x03 \x01(\tR\tshortName\")\n\x13TraceActionMetadata\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\"\xa1\x01\n\x17\x43onditionActionMetadata\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12 \n\x06run_id\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01H\x00R\x05runId\x12&\n\taction_id\x18\x03 \x01(\tB\x07\xbaH\x04r\x02\x10\x01H\x00R\x08\x61\x63tionId\x12\x18\n\x06global\x18\x04 \x01(\x08H\x00R\x06globalB\x0e\n\x05scope\x12\x05\xbaH\x02\x08\x01\"\xce\x05\n\x0e\x41\x63tionMetadata\x12\x16\n\x06parent\x18\x03 \x01(\tR\x06parent\x12\x14\n\x05group\x18\x05 \x01(\tR\x05group\x12\x43\n\x0b\x65xecuted_by\x18\x06 \x01(\x0b\x32\".flyteidl2.common.EnrichedIdentityR\nexecutedBy\x12<\n\x04task\x18\x07 \x01(\x0b\x32&.flyteidl2.workflow.TaskActionMetadataH\x00R\x04task\x12?\n\x05trace\x18\x08 \x01(\x0b\x32\'.flyteidl2.workflow.TraceActionMetadataH\x00R\x05trace\x12K\n\tcondition\x18\t \x01(\x0b\x32+.flyteidl2.workflow.ConditionActionMetadataH\x00R\tcondition\x12?\n\x0b\x61\x63tion_type\x18\n \x01(\x0e\x32\x1e.flyteidl2.workflow.ActionTypeR\nactionType\x12\x42\n\ntrigger_id\x18\x0b \x01(\x0b\x32#.flyteidl2.common.TriggerIdentifierR\ttriggerId\x12)\n\x10\x65nvironment_name\x18\x0c \x01(\tR\x0f\x65nvironmentName\x12!\n\x0c\x66untion_name\x18\r \x01(\tR\x0b\x66untionName\x12!\n\x0ctrigger_name\x18\x0e \x01(\tR\x0btriggerName\x12H\n\x0ctrigger_type\x18\x0f \x01(\x0b\x32%.flyteidl2.task.TriggerAutomationSpecR\x0btriggerType\x12\x35\n\x06source\x18\x10 \x01(\x0e\x32\x1d.flyteidl2.workflow.RunSourceR\x06sourceB\x06\n\x04spec\"\xe9\x02\n\x0c\x41\x63tionStatus\x12\x33\n\x05phase\x18\x01 \x01(\x0e\x32\x1d.flyteidl2.common.ActionPhaseR\x05phase\x12\x39\n\nstart_time\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\tstartTime\x12:\n\x08\x65nd_time\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.TimestampH\x00R\x07\x65ndTime\x88\x01\x01\x12#\n\x08\x61ttempts\x18\x04 \x01(\rB\x07\xbaH\x04*\x02 \x00R\x08\x61ttempts\x12\x45\n\x0c\x63\x61\x63he_status\x18\x05 \x01(\x0e\x32\".flyteidl2.core.CatalogCacheStatusR\x0b\x63\x61\x63heStatus\x12$\n\x0b\x64uration_ms\x18\x06 \x01(\x04H\x01R\ndurationMs\x88\x01\x01\x42\x0b\n\t_end_timeB\x0e\n\x0c_duration_ms\"\xb6\x01\n\x06\x41\x63tion\x12\x32\n\x02id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierR\x02id\x12>\n\x08metadata\x18\x02 \x01(\x0b\x32\".flyteidl2.workflow.ActionMetadataR\x08metadata\x12\x38\n\x06status\x18\x03 \x01(\x0b\x32 .flyteidl2.workflow.ActionStatusR\x06status\"\xa0\x02\n\x0e\x45nrichedAction\x12\x32\n\x06\x61\x63tion\x18\x01 \x01(\x0b\x32\x1a.flyteidl2.workflow.ActionR\x06\x61\x63tion\x12!\n\x0cmeets_filter\x18\x02 \x01(\x08R\x0bmeetsFilter\x12o\n\x15\x63hildren_phase_counts\x18\x03 \x03(\x0b\x32;.flyteidl2.workflow.EnrichedAction.ChildrenPhaseCountsEntryR\x13\x63hildrenPhaseCounts\x1a\x46\n\x18\x43hildrenPhaseCountsEntry\x12\x10\n\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n\x05value\x18\x02 \x01(\x05R\x05value:\x02\x38\x01\"\x9b\x01\n\tErrorInfo\x12\x18\n\x07message\x18\x01 \x01(\tR\x07message\x12\x36\n\x04kind\x18\x02 \x01(\x0e\x32\".flyteidl2.workflow.ErrorInfo.KindR\x04kind\"<\n\x04Kind\x12\x14\n\x10KIND_UNSPECIFIED\x10\x00\x12\r\n\tKIND_USER\x10\x01\x12\x0f\n\x0bKIND_SYSTEM\x10\x02\"f\n\tAbortInfo\x12\x16\n\x06reason\x18\x01 \x01(\tR\x06reason\x12\x41\n\naborted_by\x18\x02 \x01(\x0b\x32\".flyteidl2.common.EnrichedIdentityR\tabortedBy\"\xf1\x03\n\rActionDetails\x12\x32\n\x02id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierR\x02id\x12>\n\x08metadata\x18\x02 \x01(\x0b\x32\".flyteidl2.workflow.ActionMetadataR\x08metadata\x12\x38\n\x06status\x18\x03 \x01(\x0b\x32 .flyteidl2.workflow.ActionStatusR\x06status\x12>\n\nerror_info\x18\x04 \x01(\x0b\x32\x1d.flyteidl2.workflow.ErrorInfoH\x00R\terrorInfo\x12>\n\nabort_info\x18\x05 \x01(\x0b\x32\x1d.flyteidl2.workflow.AbortInfoH\x00R\tabortInfo\x12.\n\x04task\x18\x06 \x01(\x0b\x32\x18.flyteidl2.task.TaskSpecH\x01R\x04task\x12\x31\n\x05trace\x18\x08 \x01(\x0b\x32\x19.flyteidl2.task.TraceSpecH\x01R\x05trace\x12=\n\x08\x61ttempts\x18\x07 \x03(\x0b\x32!.flyteidl2.workflow.ActionAttemptR\x08\x61ttemptsB\x08\n\x06resultB\x06\n\x04spec\"\x8d\x06\n\rActionAttempt\x12\x33\n\x05phase\x18\x01 \x01(\x0e\x32\x1d.flyteidl2.common.ActionPhaseR\x05phase\x12\x39\n\nstart_time\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\tstartTime\x12:\n\x08\x65nd_time\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.TimestampH\x00R\x07\x65ndTime\x88\x01\x01\x12\x41\n\nerror_info\x18\x04 \x01(\x0b\x32\x1d.flyteidl2.workflow.ErrorInfoH\x01R\terrorInfo\x88\x01\x01\x12!\n\x07\x61ttempt\x18\x05 \x01(\rB\x07\xbaH\x04*\x02 \x00R\x07\x61ttempt\x12\x32\n\x08log_info\x18\x06 \x03(\x0b\x32\x17.flyteidl2.core.TaskLogR\x07logInfo\x12:\n\x07outputs\x18\x07 \x01(\x0b\x32 .flyteidl2.task.OutputReferencesR\x07outputs\x12%\n\x0elogs_available\x18\x08 \x01(\x08R\rlogsAvailable\x12\x45\n\x0c\x63\x61\x63he_status\x18\t \x01(\x0e\x32\".flyteidl2.core.CatalogCacheStatusR\x0b\x63\x61\x63heStatus\x12G\n\x0e\x63luster_events\x18\n \x03(\x0b\x32 .flyteidl2.workflow.ClusterEventR\rclusterEvents\x12P\n\x11phase_transitions\x18\x0b \x03(\x0b\x32#.flyteidl2.workflow.PhaseTransitionR\x10phaseTransitions\x12\x18\n\x07\x63luster\x18\x0c \x01(\tR\x07\x63luster\x12;\n\x0blog_context\x18\r \x01(\x0b\x32\x1a.flyteidl2.core.LogContextR\nlogContextB\x0b\n\t_end_timeB\r\n\x0b_error_info\"e\n\x0c\x43lusterEvent\x12;\n\x0boccurred_at\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\noccurredAt\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\"\xca\x01\n\x0fPhaseTransition\x12\x33\n\x05phase\x18\x01 \x01(\x0e\x32\x1d.flyteidl2.common.ActionPhaseR\x05phase\x12\x39\n\nstart_time\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\tstartTime\x12:\n\x08\x65nd_time\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.TimestampH\x00R\x07\x65ndTime\x88\x01\x01\x42\x0b\n\t_end_time\"\xf0\x06\n\x0b\x41\x63tionEvent\x12:\n\x02id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x02id\x12!\n\x07\x61ttempt\x18\x02 \x01(\rB\x07\xbaH\x04*\x02 \x00R\x07\x61ttempt\x12\x33\n\x05phase\x18\x03 \x01(\x0e\x32\x1d.flyteidl2.common.ActionPhaseR\x05phase\x12\x18\n\x07version\x18\x04 \x01(\rR\x07version\x12=\n\nstart_time\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.TimestampB\x02\x18\x01R\tstartTime\x12=\n\x0cupdated_time\x18\x06 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x0bupdatedTime\x12>\n\x08\x65nd_time\x18\x07 \x01(\x0b\x32\x1a.google.protobuf.TimestampB\x02\x18\x01H\x00R\x07\x65ndTime\x88\x01\x01\x12\x41\n\nerror_info\x18\x08 \x01(\x0b\x32\x1d.flyteidl2.workflow.ErrorInfoH\x01R\terrorInfo\x88\x01\x01\x12\x32\n\x08log_info\x18\t \x03(\x0b\x32\x17.flyteidl2.core.TaskLogR\x07logInfo\x12;\n\x0blog_context\x18\n \x01(\x0b\x32\x1a.flyteidl2.core.LogContextR\nlogContext\x12\x18\n\x07\x63luster\x18\x0b \x01(\tR\x07\x63luster\x12:\n\x07outputs\x18\x0c \x01(\x0b\x32 .flyteidl2.task.OutputReferencesR\x07outputs\x12\x45\n\x0c\x63\x61\x63he_status\x18\r \x01(\x0e\x32\".flyteidl2.core.CatalogCacheStatusR\x0b\x63\x61\x63heStatus\x12G\n\x0e\x63luster_events\x18\x0e \x03(\x0b\x32 .flyteidl2.workflow.ClusterEventR\rclusterEvents\x12?\n\rreported_time\x18\x0f \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x0creportedTimeB\x0b\n\t_end_timeB\r\n\x0b_error_info\"\x83\x04\n\nActionSpec\x12G\n\taction_id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x08\x61\x63tionId\x12\x31\n\x12parent_action_name\x18\x02 \x01(\tH\x01R\x10parentActionName\x88\x01\x01\x12\x32\n\x08run_spec\x18\x03 \x01(\x0b\x32\x17.flyteidl2.task.RunSpecR\x07runSpec\x12$\n\tinput_uri\x18\x04 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x08inputUri\x12/\n\x0frun_output_base\x18\x05 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\rrunOutputBase\x12\x34\n\x04task\x18\x06 \x01(\x0b\x32\x1e.flyteidl2.workflow.TaskActionH\x00R\x04task\x12\x43\n\tcondition\x18\x07 \x01(\x0b\x32#.flyteidl2.workflow.ConditionActionH\x00R\tcondition\x12\x37\n\x05trace\x18\n \x01(\x0b\x32\x1f.flyteidl2.workflow.TraceActionH\x00R\x05trace\x12\x14\n\x05group\x18\x08 \x01(\tR\x05groupB\r\n\x04spec\x12\x05\xbaH\x02\x08\x01\x42\x15\n\x13_parent_action_name\"\xac\x08\n\tTaskGroup\x12\x1b\n\ttask_name\x18\x01 \x01(\tR\x08taskName\x12)\n\x10\x65nvironment_name\x18\x02 \x01(\tR\x0f\x65nvironmentName\x12\x1d\n\ntotal_runs\x18\x03 \x01(\x03R\ttotalRuns\x12\x42\n\x0flatest_run_time\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\rlatestRunTime\x12S\n\x0frecent_statuses\x18\x05 \x03(\x0b\x32*.flyteidl2.workflow.TaskGroup.RecentStatusR\x0erecentStatuses\x12\x30\n\x14\x61verage_failure_rate\x18\x06 \x01(\x01R\x12\x61verageFailureRate\x12\x44\n\x10\x61verage_duration\x18\x07 \x01(\x0b\x32\x19.google.protobuf.DurationR\x0f\x61verageDuration\x12L\n\x14latest_finished_time\x18\x08 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x12latestFinishedTime\x12\x41\n\ncreated_by\x18\t \x03(\x0b\x32\".flyteidl2.common.EnrichedIdentityR\tcreatedBy\x12#\n\rshould_delete\x18\n \x01(\x08R\x0cshouldDelete\x12\x1d\n\nshort_name\x18\x0b \x01(\tR\tshortName\x12L\n\x0c\x65rror_counts\x18\x0c \x01(\x0b\x32).flyteidl2.workflow.TaskGroup.ErrorCountsR\x0b\x65rrorCounts\x12L\n\x0cphase_counts\x18\r \x03(\x0b\x32).flyteidl2.workflow.TaskGroup.PhaseCountsR\x0bphaseCounts\x1a^\n\x0cRecentStatus\x12\x19\n\x08run_name\x18\x01 \x01(\tR\x07runName\x12\x33\n\x05phase\x18\x02 \x01(\x0e\x32\x1d.flyteidl2.common.ActionPhaseR\x05phase\x1a|\n\x0b\x45rrorCounts\x12\x1d\n\nuser_error\x18\x01 \x01(\x03R\tuserError\x12!\n\x0csystem_error\x18\x02 \x01(\x03R\x0bsystemError\x12+\n\x11unspecified_error\x18\x03 \x01(\x03R\x10unspecifiedError\x1aX\n\x0bPhaseCounts\x12\x33\n\x05phase\x18\x01 \x01(\x0e\x32\x1d.flyteidl2.common.ActionPhaseR\x05phase\x12\x14\n\x05\x63ount\x18\x02 \x01(\x03R\x05\x63ount*q\n\nActionType\x12\x1b\n\x17\x41\x43TION_TYPE_UNSPECIFIED\x10\x00\x12\x14\n\x10\x41\x43TION_TYPE_TASK\x10\x01\x12\x15\n\x11\x41\x43TION_TYPE_TRACE\x10\x02\x12\x19\n\x15\x41\x43TION_TYPE_CONDITION\x10\x03*p\n\tRunSource\x12\x1a\n\x16RUN_SOURCE_UNSPECIFIED\x10\x00\x12\x12\n\x0eRUN_SOURCE_WEB\x10\x01\x12\x12\n\x0eRUN_SOURCE_CLI\x10\x02\x12\x1f\n\x1bRUN_SOURCE_SCHEDULE_TRIGGER\x10\x03\x42\xcf\x01\n\x16\x63om.flyteidl2.workflowB\x12RunDefinitionProtoH\x02P\x01Z6github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow\xa2\x02\x03\x46WX\xaa\x02\x12\x46lyteidl2.Workflow\xca\x02\x12\x46lyteidl2\\Workflow\xe2\x02\x1e\x46lyteidl2\\Workflow\\GPBMetadata\xea\x02\x13\x46lyteidl2::Workflowb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.workflow.run_definition_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\026com.flyteidl2.workflowB\022RunDefinitionProtoH\002P\001Z6github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow\242\002\003FWX\252\002\022Flyteidl2.Workflow\312\002\022Flyteidl2\\Workflow\342\002\036Flyteidl2\\Workflow\\GPBMetadata\352\002\023Flyteidl2::Workflow' + _TASKACTION.fields_by_name['spec']._options = None + _TASKACTION.fields_by_name['spec']._serialized_options = b'\272H\003\310\001\001' + _TRACEACTION.fields_by_name['name']._options = None + _TRACEACTION.fields_by_name['name']._serialized_options = b'\272H\004r\002\020\001' + _TRACEACTION.fields_by_name['spec']._options = None + _TRACEACTION.fields_by_name['spec']._serialized_options = b'\272H\003\310\001\001' + _CONDITIONACTION.oneofs_by_name['scope']._options = None + _CONDITIONACTION.oneofs_by_name['scope']._serialized_options = b'\272H\002\010\001' + _CONDITIONACTION.fields_by_name['name']._options = None + _CONDITIONACTION.fields_by_name['name']._serialized_options = b'\272H\004r\002\020\001' + _CONDITIONACTION.fields_by_name['run_id']._options = None + _CONDITIONACTION.fields_by_name['run_id']._serialized_options = b'\272H\004r\002\020\001' + _CONDITIONACTION.fields_by_name['action_id']._options = None + _CONDITIONACTION.fields_by_name['action_id']._serialized_options = b'\272H\004r\002\020\001' + _CONDITIONACTIONMETADATA.oneofs_by_name['scope']._options = None + _CONDITIONACTIONMETADATA.oneofs_by_name['scope']._serialized_options = b'\272H\002\010\001' + _CONDITIONACTIONMETADATA.fields_by_name['run_id']._options = None + _CONDITIONACTIONMETADATA.fields_by_name['run_id']._serialized_options = b'\272H\004r\002\020\001' + _CONDITIONACTIONMETADATA.fields_by_name['action_id']._options = None + _CONDITIONACTIONMETADATA.fields_by_name['action_id']._serialized_options = b'\272H\004r\002\020\001' + _ACTIONSTATUS.fields_by_name['attempts']._options = None + _ACTIONSTATUS.fields_by_name['attempts']._serialized_options = b'\272H\004*\002 \000' + _ENRICHEDACTION_CHILDRENPHASECOUNTSENTRY._options = None + _ENRICHEDACTION_CHILDRENPHASECOUNTSENTRY._serialized_options = b'8\001' + _ACTIONATTEMPT.fields_by_name['attempt']._options = None + _ACTIONATTEMPT.fields_by_name['attempt']._serialized_options = b'\272H\004*\002 \000' + _ACTIONEVENT.fields_by_name['id']._options = None + _ACTIONEVENT.fields_by_name['id']._serialized_options = b'\272H\003\310\001\001' + _ACTIONEVENT.fields_by_name['attempt']._options = None + _ACTIONEVENT.fields_by_name['attempt']._serialized_options = b'\272H\004*\002 \000' + _ACTIONEVENT.fields_by_name['start_time']._options = None + _ACTIONEVENT.fields_by_name['start_time']._serialized_options = b'\030\001' + _ACTIONEVENT.fields_by_name['end_time']._options = None + _ACTIONEVENT.fields_by_name['end_time']._serialized_options = b'\030\001' + _ACTIONSPEC.oneofs_by_name['spec']._options = None + _ACTIONSPEC.oneofs_by_name['spec']._serialized_options = b'\272H\002\010\001' + _ACTIONSPEC.fields_by_name['action_id']._options = None + _ACTIONSPEC.fields_by_name['action_id']._serialized_options = b'\272H\003\310\001\001' + _ACTIONSPEC.fields_by_name['input_uri']._options = None + _ACTIONSPEC.fields_by_name['input_uri']._serialized_options = b'\272H\004r\002\020\001' + _ACTIONSPEC.fields_by_name['run_output_base']._options = None + _ACTIONSPEC.fields_by_name['run_output_base']._serialized_options = b'\272H\004r\002\020\001' + _globals['_ACTIONTYPE']._serialized_start=7698 + _globals['_ACTIONTYPE']._serialized_end=7811 + _globals['_RUNSOURCE']._serialized_start=7813 + _globals['_RUNSOURCE']._serialized_end=7925 + _globals['_RUN']._serialized_start=470 + _globals['_RUN']._serialized_end=527 + _globals['_RUNDETAILS']._serialized_start=529 + _globals['_RUNDETAILS']._serialized_end=652 + _globals['_TASKACTION']._serialized_start=655 + _globals['_TASKACTION']._serialized_end=854 + _globals['_TRACEACTION']._serialized_start=857 + _globals['_TRACEACTION']._serialized_end=1199 + _globals['_CONDITIONACTION']._serialized_start=1202 + _globals['_CONDITIONACTION']._serialized_end=1471 + _globals['_TASKACTIONMETADATA']._serialized_start=1474 + _globals['_TASKACTIONMETADATA']._serialized_end=1602 + _globals['_TRACEACTIONMETADATA']._serialized_start=1604 + _globals['_TRACEACTIONMETADATA']._serialized_end=1645 + _globals['_CONDITIONACTIONMETADATA']._serialized_start=1648 + _globals['_CONDITIONACTIONMETADATA']._serialized_end=1809 + _globals['_ACTIONMETADATA']._serialized_start=1812 + _globals['_ACTIONMETADATA']._serialized_end=2530 + _globals['_ACTIONSTATUS']._serialized_start=2533 + _globals['_ACTIONSTATUS']._serialized_end=2894 + _globals['_ACTION']._serialized_start=2897 + _globals['_ACTION']._serialized_end=3079 + _globals['_ENRICHEDACTION']._serialized_start=3082 + _globals['_ENRICHEDACTION']._serialized_end=3370 + _globals['_ENRICHEDACTION_CHILDRENPHASECOUNTSENTRY']._serialized_start=3300 + _globals['_ENRICHEDACTION_CHILDRENPHASECOUNTSENTRY']._serialized_end=3370 + _globals['_ERRORINFO']._serialized_start=3373 + _globals['_ERRORINFO']._serialized_end=3528 + _globals['_ERRORINFO_KIND']._serialized_start=3468 + _globals['_ERRORINFO_KIND']._serialized_end=3528 + _globals['_ABORTINFO']._serialized_start=3530 + _globals['_ABORTINFO']._serialized_end=3632 + _globals['_ACTIONDETAILS']._serialized_start=3635 + _globals['_ACTIONDETAILS']._serialized_end=4132 + _globals['_ACTIONATTEMPT']._serialized_start=4135 + _globals['_ACTIONATTEMPT']._serialized_end=4916 + _globals['_CLUSTEREVENT']._serialized_start=4918 + _globals['_CLUSTEREVENT']._serialized_end=5019 + _globals['_PHASETRANSITION']._serialized_start=5022 + _globals['_PHASETRANSITION']._serialized_end=5224 + _globals['_ACTIONEVENT']._serialized_start=5227 + _globals['_ACTIONEVENT']._serialized_end=6107 + _globals['_ACTIONSPEC']._serialized_start=6110 + _globals['_ACTIONSPEC']._serialized_end=6625 + _globals['_TASKGROUP']._serialized_start=6628 + _globals['_TASKGROUP']._serialized_end=7696 + _globals['_TASKGROUP_RECENTSTATUS']._serialized_start=7386 + _globals['_TASKGROUP_RECENTSTATUS']._serialized_end=7480 + _globals['_TASKGROUP_ERRORCOUNTS']._serialized_start=7482 + _globals['_TASKGROUP_ERRORCOUNTS']._serialized_end=7606 + _globals['_TASKGROUP_PHASECOUNTS']._serialized_start=7608 + _globals['_TASKGROUP_PHASECOUNTS']._serialized_end=7696 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/workflow/run_definition_pb2.pyi b/gen/python/flyteidl2/workflow/run_definition_pb2.pyi new file mode 100644 index 0000000000..1adf8da20f --- /dev/null +++ b/gen/python/flyteidl2/workflow/run_definition_pb2.pyi @@ -0,0 +1,402 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.common import identifier_pb2 as _identifier_pb2 +from flyteidl2.common import identity_pb2 as _identity_pb2 +from flyteidl2.common import phase_pb2 as _phase_pb2 +from flyteidl2.core import catalog_pb2 as _catalog_pb2 +from flyteidl2.core import execution_pb2 as _execution_pb2 +from flyteidl2.core import types_pb2 as _types_pb2 +from flyteidl2.task import common_pb2 as _common_pb2 +from flyteidl2.task import run_pb2 as _run_pb2 +from flyteidl2.task import task_definition_pb2 as _task_definition_pb2 +from google.protobuf import duration_pb2 as _duration_pb2 +from google.protobuf import timestamp_pb2 as _timestamp_pb2 +from google.protobuf import wrappers_pb2 as _wrappers_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class ActionType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + ACTION_TYPE_UNSPECIFIED: _ClassVar[ActionType] + ACTION_TYPE_TASK: _ClassVar[ActionType] + ACTION_TYPE_TRACE: _ClassVar[ActionType] + ACTION_TYPE_CONDITION: _ClassVar[ActionType] + +class RunSource(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + RUN_SOURCE_UNSPECIFIED: _ClassVar[RunSource] + RUN_SOURCE_WEB: _ClassVar[RunSource] + RUN_SOURCE_CLI: _ClassVar[RunSource] + RUN_SOURCE_SCHEDULE_TRIGGER: _ClassVar[RunSource] +ACTION_TYPE_UNSPECIFIED: ActionType +ACTION_TYPE_TASK: ActionType +ACTION_TYPE_TRACE: ActionType +ACTION_TYPE_CONDITION: ActionType +RUN_SOURCE_UNSPECIFIED: RunSource +RUN_SOURCE_WEB: RunSource +RUN_SOURCE_CLI: RunSource +RUN_SOURCE_SCHEDULE_TRIGGER: RunSource + +class Run(_message.Message): + __slots__ = ["action"] + ACTION_FIELD_NUMBER: _ClassVar[int] + action: Action + def __init__(self, action: _Optional[_Union[Action, _Mapping]] = ...) -> None: ... + +class RunDetails(_message.Message): + __slots__ = ["run_spec", "action"] + RUN_SPEC_FIELD_NUMBER: _ClassVar[int] + ACTION_FIELD_NUMBER: _ClassVar[int] + run_spec: _run_pb2.RunSpec + action: ActionDetails + def __init__(self, run_spec: _Optional[_Union[_run_pb2.RunSpec, _Mapping]] = ..., action: _Optional[_Union[ActionDetails, _Mapping]] = ...) -> None: ... + +class TaskAction(_message.Message): + __slots__ = ["id", "spec", "cache_key", "cluster"] + ID_FIELD_NUMBER: _ClassVar[int] + SPEC_FIELD_NUMBER: _ClassVar[int] + CACHE_KEY_FIELD_NUMBER: _ClassVar[int] + CLUSTER_FIELD_NUMBER: _ClassVar[int] + id: _task_definition_pb2.TaskIdentifier + spec: _task_definition_pb2.TaskSpec + cache_key: _wrappers_pb2.StringValue + cluster: str + def __init__(self, id: _Optional[_Union[_task_definition_pb2.TaskIdentifier, _Mapping]] = ..., spec: _Optional[_Union[_task_definition_pb2.TaskSpec, _Mapping]] = ..., cache_key: _Optional[_Union[_wrappers_pb2.StringValue, _Mapping]] = ..., cluster: _Optional[str] = ...) -> None: ... + +class TraceAction(_message.Message): + __slots__ = ["name", "phase", "start_time", "end_time", "outputs", "spec"] + NAME_FIELD_NUMBER: _ClassVar[int] + PHASE_FIELD_NUMBER: _ClassVar[int] + START_TIME_FIELD_NUMBER: _ClassVar[int] + END_TIME_FIELD_NUMBER: _ClassVar[int] + OUTPUTS_FIELD_NUMBER: _ClassVar[int] + SPEC_FIELD_NUMBER: _ClassVar[int] + name: str + phase: _phase_pb2.ActionPhase + start_time: _timestamp_pb2.Timestamp + end_time: _timestamp_pb2.Timestamp + outputs: _common_pb2.OutputReferences + spec: _task_definition_pb2.TraceSpec + def __init__(self, name: _Optional[str] = ..., phase: _Optional[_Union[_phase_pb2.ActionPhase, str]] = ..., start_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., end_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., outputs: _Optional[_Union[_common_pb2.OutputReferences, _Mapping]] = ..., spec: _Optional[_Union[_task_definition_pb2.TraceSpec, _Mapping]] = ...) -> None: ... + +class ConditionAction(_message.Message): + __slots__ = ["name", "run_id", "action_id", "type", "prompt", "description"] + NAME_FIELD_NUMBER: _ClassVar[int] + RUN_ID_FIELD_NUMBER: _ClassVar[int] + ACTION_ID_FIELD_NUMBER: _ClassVar[int] + GLOBAL_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + PROMPT_FIELD_NUMBER: _ClassVar[int] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + name: str + run_id: str + action_id: str + type: _types_pb2.LiteralType + prompt: str + description: str + def __init__(self, name: _Optional[str] = ..., run_id: _Optional[str] = ..., action_id: _Optional[str] = ..., type: _Optional[_Union[_types_pb2.LiteralType, _Mapping]] = ..., prompt: _Optional[str] = ..., description: _Optional[str] = ..., **kwargs) -> None: ... + +class TaskActionMetadata(_message.Message): + __slots__ = ["id", "task_type", "short_name"] + ID_FIELD_NUMBER: _ClassVar[int] + TASK_TYPE_FIELD_NUMBER: _ClassVar[int] + SHORT_NAME_FIELD_NUMBER: _ClassVar[int] + id: _task_definition_pb2.TaskIdentifier + task_type: str + short_name: str + def __init__(self, id: _Optional[_Union[_task_definition_pb2.TaskIdentifier, _Mapping]] = ..., task_type: _Optional[str] = ..., short_name: _Optional[str] = ...) -> None: ... + +class TraceActionMetadata(_message.Message): + __slots__ = ["name"] + NAME_FIELD_NUMBER: _ClassVar[int] + name: str + def __init__(self, name: _Optional[str] = ...) -> None: ... + +class ConditionActionMetadata(_message.Message): + __slots__ = ["name", "run_id", "action_id"] + NAME_FIELD_NUMBER: _ClassVar[int] + RUN_ID_FIELD_NUMBER: _ClassVar[int] + ACTION_ID_FIELD_NUMBER: _ClassVar[int] + GLOBAL_FIELD_NUMBER: _ClassVar[int] + name: str + run_id: str + action_id: str + def __init__(self, name: _Optional[str] = ..., run_id: _Optional[str] = ..., action_id: _Optional[str] = ..., **kwargs) -> None: ... + +class ActionMetadata(_message.Message): + __slots__ = ["parent", "group", "executed_by", "task", "trace", "condition", "action_type", "trigger_id", "environment_name", "funtion_name", "trigger_name", "trigger_type", "source"] + PARENT_FIELD_NUMBER: _ClassVar[int] + GROUP_FIELD_NUMBER: _ClassVar[int] + EXECUTED_BY_FIELD_NUMBER: _ClassVar[int] + TASK_FIELD_NUMBER: _ClassVar[int] + TRACE_FIELD_NUMBER: _ClassVar[int] + CONDITION_FIELD_NUMBER: _ClassVar[int] + ACTION_TYPE_FIELD_NUMBER: _ClassVar[int] + TRIGGER_ID_FIELD_NUMBER: _ClassVar[int] + ENVIRONMENT_NAME_FIELD_NUMBER: _ClassVar[int] + FUNTION_NAME_FIELD_NUMBER: _ClassVar[int] + TRIGGER_NAME_FIELD_NUMBER: _ClassVar[int] + TRIGGER_TYPE_FIELD_NUMBER: _ClassVar[int] + SOURCE_FIELD_NUMBER: _ClassVar[int] + parent: str + group: str + executed_by: _identity_pb2.EnrichedIdentity + task: TaskActionMetadata + trace: TraceActionMetadata + condition: ConditionActionMetadata + action_type: ActionType + trigger_id: _identifier_pb2.TriggerIdentifier + environment_name: str + funtion_name: str + trigger_name: str + trigger_type: _common_pb2.TriggerAutomationSpec + source: RunSource + def __init__(self, parent: _Optional[str] = ..., group: _Optional[str] = ..., executed_by: _Optional[_Union[_identity_pb2.EnrichedIdentity, _Mapping]] = ..., task: _Optional[_Union[TaskActionMetadata, _Mapping]] = ..., trace: _Optional[_Union[TraceActionMetadata, _Mapping]] = ..., condition: _Optional[_Union[ConditionActionMetadata, _Mapping]] = ..., action_type: _Optional[_Union[ActionType, str]] = ..., trigger_id: _Optional[_Union[_identifier_pb2.TriggerIdentifier, _Mapping]] = ..., environment_name: _Optional[str] = ..., funtion_name: _Optional[str] = ..., trigger_name: _Optional[str] = ..., trigger_type: _Optional[_Union[_common_pb2.TriggerAutomationSpec, _Mapping]] = ..., source: _Optional[_Union[RunSource, str]] = ...) -> None: ... + +class ActionStatus(_message.Message): + __slots__ = ["phase", "start_time", "end_time", "attempts", "cache_status", "duration_ms"] + PHASE_FIELD_NUMBER: _ClassVar[int] + START_TIME_FIELD_NUMBER: _ClassVar[int] + END_TIME_FIELD_NUMBER: _ClassVar[int] + ATTEMPTS_FIELD_NUMBER: _ClassVar[int] + CACHE_STATUS_FIELD_NUMBER: _ClassVar[int] + DURATION_MS_FIELD_NUMBER: _ClassVar[int] + phase: _phase_pb2.ActionPhase + start_time: _timestamp_pb2.Timestamp + end_time: _timestamp_pb2.Timestamp + attempts: int + cache_status: _catalog_pb2.CatalogCacheStatus + duration_ms: int + def __init__(self, phase: _Optional[_Union[_phase_pb2.ActionPhase, str]] = ..., start_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., end_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., attempts: _Optional[int] = ..., cache_status: _Optional[_Union[_catalog_pb2.CatalogCacheStatus, str]] = ..., duration_ms: _Optional[int] = ...) -> None: ... + +class Action(_message.Message): + __slots__ = ["id", "metadata", "status"] + ID_FIELD_NUMBER: _ClassVar[int] + METADATA_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + id: _identifier_pb2.ActionIdentifier + metadata: ActionMetadata + status: ActionStatus + def __init__(self, id: _Optional[_Union[_identifier_pb2.ActionIdentifier, _Mapping]] = ..., metadata: _Optional[_Union[ActionMetadata, _Mapping]] = ..., status: _Optional[_Union[ActionStatus, _Mapping]] = ...) -> None: ... + +class EnrichedAction(_message.Message): + __slots__ = ["action", "meets_filter", "children_phase_counts"] + class ChildrenPhaseCountsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: int + def __init__(self, key: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + ACTION_FIELD_NUMBER: _ClassVar[int] + MEETS_FILTER_FIELD_NUMBER: _ClassVar[int] + CHILDREN_PHASE_COUNTS_FIELD_NUMBER: _ClassVar[int] + action: Action + meets_filter: bool + children_phase_counts: _containers.ScalarMap[int, int] + def __init__(self, action: _Optional[_Union[Action, _Mapping]] = ..., meets_filter: bool = ..., children_phase_counts: _Optional[_Mapping[int, int]] = ...) -> None: ... + +class ErrorInfo(_message.Message): + __slots__ = ["message", "kind"] + class Kind(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + KIND_UNSPECIFIED: _ClassVar[ErrorInfo.Kind] + KIND_USER: _ClassVar[ErrorInfo.Kind] + KIND_SYSTEM: _ClassVar[ErrorInfo.Kind] + KIND_UNSPECIFIED: ErrorInfo.Kind + KIND_USER: ErrorInfo.Kind + KIND_SYSTEM: ErrorInfo.Kind + MESSAGE_FIELD_NUMBER: _ClassVar[int] + KIND_FIELD_NUMBER: _ClassVar[int] + message: str + kind: ErrorInfo.Kind + def __init__(self, message: _Optional[str] = ..., kind: _Optional[_Union[ErrorInfo.Kind, str]] = ...) -> None: ... + +class AbortInfo(_message.Message): + __slots__ = ["reason", "aborted_by"] + REASON_FIELD_NUMBER: _ClassVar[int] + ABORTED_BY_FIELD_NUMBER: _ClassVar[int] + reason: str + aborted_by: _identity_pb2.EnrichedIdentity + def __init__(self, reason: _Optional[str] = ..., aborted_by: _Optional[_Union[_identity_pb2.EnrichedIdentity, _Mapping]] = ...) -> None: ... + +class ActionDetails(_message.Message): + __slots__ = ["id", "metadata", "status", "error_info", "abort_info", "task", "trace", "attempts"] + ID_FIELD_NUMBER: _ClassVar[int] + METADATA_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + ERROR_INFO_FIELD_NUMBER: _ClassVar[int] + ABORT_INFO_FIELD_NUMBER: _ClassVar[int] + TASK_FIELD_NUMBER: _ClassVar[int] + TRACE_FIELD_NUMBER: _ClassVar[int] + ATTEMPTS_FIELD_NUMBER: _ClassVar[int] + id: _identifier_pb2.ActionIdentifier + metadata: ActionMetadata + status: ActionStatus + error_info: ErrorInfo + abort_info: AbortInfo + task: _task_definition_pb2.TaskSpec + trace: _task_definition_pb2.TraceSpec + attempts: _containers.RepeatedCompositeFieldContainer[ActionAttempt] + def __init__(self, id: _Optional[_Union[_identifier_pb2.ActionIdentifier, _Mapping]] = ..., metadata: _Optional[_Union[ActionMetadata, _Mapping]] = ..., status: _Optional[_Union[ActionStatus, _Mapping]] = ..., error_info: _Optional[_Union[ErrorInfo, _Mapping]] = ..., abort_info: _Optional[_Union[AbortInfo, _Mapping]] = ..., task: _Optional[_Union[_task_definition_pb2.TaskSpec, _Mapping]] = ..., trace: _Optional[_Union[_task_definition_pb2.TraceSpec, _Mapping]] = ..., attempts: _Optional[_Iterable[_Union[ActionAttempt, _Mapping]]] = ...) -> None: ... + +class ActionAttempt(_message.Message): + __slots__ = ["phase", "start_time", "end_time", "error_info", "attempt", "log_info", "outputs", "logs_available", "cache_status", "cluster_events", "phase_transitions", "cluster", "log_context"] + PHASE_FIELD_NUMBER: _ClassVar[int] + START_TIME_FIELD_NUMBER: _ClassVar[int] + END_TIME_FIELD_NUMBER: _ClassVar[int] + ERROR_INFO_FIELD_NUMBER: _ClassVar[int] + ATTEMPT_FIELD_NUMBER: _ClassVar[int] + LOG_INFO_FIELD_NUMBER: _ClassVar[int] + OUTPUTS_FIELD_NUMBER: _ClassVar[int] + LOGS_AVAILABLE_FIELD_NUMBER: _ClassVar[int] + CACHE_STATUS_FIELD_NUMBER: _ClassVar[int] + CLUSTER_EVENTS_FIELD_NUMBER: _ClassVar[int] + PHASE_TRANSITIONS_FIELD_NUMBER: _ClassVar[int] + CLUSTER_FIELD_NUMBER: _ClassVar[int] + LOG_CONTEXT_FIELD_NUMBER: _ClassVar[int] + phase: _phase_pb2.ActionPhase + start_time: _timestamp_pb2.Timestamp + end_time: _timestamp_pb2.Timestamp + error_info: ErrorInfo + attempt: int + log_info: _containers.RepeatedCompositeFieldContainer[_execution_pb2.TaskLog] + outputs: _common_pb2.OutputReferences + logs_available: bool + cache_status: _catalog_pb2.CatalogCacheStatus + cluster_events: _containers.RepeatedCompositeFieldContainer[ClusterEvent] + phase_transitions: _containers.RepeatedCompositeFieldContainer[PhaseTransition] + cluster: str + log_context: _execution_pb2.LogContext + def __init__(self, phase: _Optional[_Union[_phase_pb2.ActionPhase, str]] = ..., start_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., end_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., error_info: _Optional[_Union[ErrorInfo, _Mapping]] = ..., attempt: _Optional[int] = ..., log_info: _Optional[_Iterable[_Union[_execution_pb2.TaskLog, _Mapping]]] = ..., outputs: _Optional[_Union[_common_pb2.OutputReferences, _Mapping]] = ..., logs_available: bool = ..., cache_status: _Optional[_Union[_catalog_pb2.CatalogCacheStatus, str]] = ..., cluster_events: _Optional[_Iterable[_Union[ClusterEvent, _Mapping]]] = ..., phase_transitions: _Optional[_Iterable[_Union[PhaseTransition, _Mapping]]] = ..., cluster: _Optional[str] = ..., log_context: _Optional[_Union[_execution_pb2.LogContext, _Mapping]] = ...) -> None: ... + +class ClusterEvent(_message.Message): + __slots__ = ["occurred_at", "message"] + OCCURRED_AT_FIELD_NUMBER: _ClassVar[int] + MESSAGE_FIELD_NUMBER: _ClassVar[int] + occurred_at: _timestamp_pb2.Timestamp + message: str + def __init__(self, occurred_at: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., message: _Optional[str] = ...) -> None: ... + +class PhaseTransition(_message.Message): + __slots__ = ["phase", "start_time", "end_time"] + PHASE_FIELD_NUMBER: _ClassVar[int] + START_TIME_FIELD_NUMBER: _ClassVar[int] + END_TIME_FIELD_NUMBER: _ClassVar[int] + phase: _phase_pb2.ActionPhase + start_time: _timestamp_pb2.Timestamp + end_time: _timestamp_pb2.Timestamp + def __init__(self, phase: _Optional[_Union[_phase_pb2.ActionPhase, str]] = ..., start_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., end_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ...) -> None: ... + +class ActionEvent(_message.Message): + __slots__ = ["id", "attempt", "phase", "version", "start_time", "updated_time", "end_time", "error_info", "log_info", "log_context", "cluster", "outputs", "cache_status", "cluster_events", "reported_time"] + ID_FIELD_NUMBER: _ClassVar[int] + ATTEMPT_FIELD_NUMBER: _ClassVar[int] + PHASE_FIELD_NUMBER: _ClassVar[int] + VERSION_FIELD_NUMBER: _ClassVar[int] + START_TIME_FIELD_NUMBER: _ClassVar[int] + UPDATED_TIME_FIELD_NUMBER: _ClassVar[int] + END_TIME_FIELD_NUMBER: _ClassVar[int] + ERROR_INFO_FIELD_NUMBER: _ClassVar[int] + LOG_INFO_FIELD_NUMBER: _ClassVar[int] + LOG_CONTEXT_FIELD_NUMBER: _ClassVar[int] + CLUSTER_FIELD_NUMBER: _ClassVar[int] + OUTPUTS_FIELD_NUMBER: _ClassVar[int] + CACHE_STATUS_FIELD_NUMBER: _ClassVar[int] + CLUSTER_EVENTS_FIELD_NUMBER: _ClassVar[int] + REPORTED_TIME_FIELD_NUMBER: _ClassVar[int] + id: _identifier_pb2.ActionIdentifier + attempt: int + phase: _phase_pb2.ActionPhase + version: int + start_time: _timestamp_pb2.Timestamp + updated_time: _timestamp_pb2.Timestamp + end_time: _timestamp_pb2.Timestamp + error_info: ErrorInfo + log_info: _containers.RepeatedCompositeFieldContainer[_execution_pb2.TaskLog] + log_context: _execution_pb2.LogContext + cluster: str + outputs: _common_pb2.OutputReferences + cache_status: _catalog_pb2.CatalogCacheStatus + cluster_events: _containers.RepeatedCompositeFieldContainer[ClusterEvent] + reported_time: _timestamp_pb2.Timestamp + def __init__(self, id: _Optional[_Union[_identifier_pb2.ActionIdentifier, _Mapping]] = ..., attempt: _Optional[int] = ..., phase: _Optional[_Union[_phase_pb2.ActionPhase, str]] = ..., version: _Optional[int] = ..., start_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., updated_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., end_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., error_info: _Optional[_Union[ErrorInfo, _Mapping]] = ..., log_info: _Optional[_Iterable[_Union[_execution_pb2.TaskLog, _Mapping]]] = ..., log_context: _Optional[_Union[_execution_pb2.LogContext, _Mapping]] = ..., cluster: _Optional[str] = ..., outputs: _Optional[_Union[_common_pb2.OutputReferences, _Mapping]] = ..., cache_status: _Optional[_Union[_catalog_pb2.CatalogCacheStatus, str]] = ..., cluster_events: _Optional[_Iterable[_Union[ClusterEvent, _Mapping]]] = ..., reported_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ...) -> None: ... + +class ActionSpec(_message.Message): + __slots__ = ["action_id", "parent_action_name", "run_spec", "input_uri", "run_output_base", "task", "condition", "trace", "group"] + ACTION_ID_FIELD_NUMBER: _ClassVar[int] + PARENT_ACTION_NAME_FIELD_NUMBER: _ClassVar[int] + RUN_SPEC_FIELD_NUMBER: _ClassVar[int] + INPUT_URI_FIELD_NUMBER: _ClassVar[int] + RUN_OUTPUT_BASE_FIELD_NUMBER: _ClassVar[int] + TASK_FIELD_NUMBER: _ClassVar[int] + CONDITION_FIELD_NUMBER: _ClassVar[int] + TRACE_FIELD_NUMBER: _ClassVar[int] + GROUP_FIELD_NUMBER: _ClassVar[int] + action_id: _identifier_pb2.ActionIdentifier + parent_action_name: str + run_spec: _run_pb2.RunSpec + input_uri: str + run_output_base: str + task: TaskAction + condition: ConditionAction + trace: TraceAction + group: str + def __init__(self, action_id: _Optional[_Union[_identifier_pb2.ActionIdentifier, _Mapping]] = ..., parent_action_name: _Optional[str] = ..., run_spec: _Optional[_Union[_run_pb2.RunSpec, _Mapping]] = ..., input_uri: _Optional[str] = ..., run_output_base: _Optional[str] = ..., task: _Optional[_Union[TaskAction, _Mapping]] = ..., condition: _Optional[_Union[ConditionAction, _Mapping]] = ..., trace: _Optional[_Union[TraceAction, _Mapping]] = ..., group: _Optional[str] = ...) -> None: ... + +class TaskGroup(_message.Message): + __slots__ = ["task_name", "environment_name", "total_runs", "latest_run_time", "recent_statuses", "average_failure_rate", "average_duration", "latest_finished_time", "created_by", "should_delete", "short_name", "error_counts", "phase_counts"] + class RecentStatus(_message.Message): + __slots__ = ["run_name", "phase"] + RUN_NAME_FIELD_NUMBER: _ClassVar[int] + PHASE_FIELD_NUMBER: _ClassVar[int] + run_name: str + phase: _phase_pb2.ActionPhase + def __init__(self, run_name: _Optional[str] = ..., phase: _Optional[_Union[_phase_pb2.ActionPhase, str]] = ...) -> None: ... + class ErrorCounts(_message.Message): + __slots__ = ["user_error", "system_error", "unspecified_error"] + USER_ERROR_FIELD_NUMBER: _ClassVar[int] + SYSTEM_ERROR_FIELD_NUMBER: _ClassVar[int] + UNSPECIFIED_ERROR_FIELD_NUMBER: _ClassVar[int] + user_error: int + system_error: int + unspecified_error: int + def __init__(self, user_error: _Optional[int] = ..., system_error: _Optional[int] = ..., unspecified_error: _Optional[int] = ...) -> None: ... + class PhaseCounts(_message.Message): + __slots__ = ["phase", "count"] + PHASE_FIELD_NUMBER: _ClassVar[int] + COUNT_FIELD_NUMBER: _ClassVar[int] + phase: _phase_pb2.ActionPhase + count: int + def __init__(self, phase: _Optional[_Union[_phase_pb2.ActionPhase, str]] = ..., count: _Optional[int] = ...) -> None: ... + TASK_NAME_FIELD_NUMBER: _ClassVar[int] + ENVIRONMENT_NAME_FIELD_NUMBER: _ClassVar[int] + TOTAL_RUNS_FIELD_NUMBER: _ClassVar[int] + LATEST_RUN_TIME_FIELD_NUMBER: _ClassVar[int] + RECENT_STATUSES_FIELD_NUMBER: _ClassVar[int] + AVERAGE_FAILURE_RATE_FIELD_NUMBER: _ClassVar[int] + AVERAGE_DURATION_FIELD_NUMBER: _ClassVar[int] + LATEST_FINISHED_TIME_FIELD_NUMBER: _ClassVar[int] + CREATED_BY_FIELD_NUMBER: _ClassVar[int] + SHOULD_DELETE_FIELD_NUMBER: _ClassVar[int] + SHORT_NAME_FIELD_NUMBER: _ClassVar[int] + ERROR_COUNTS_FIELD_NUMBER: _ClassVar[int] + PHASE_COUNTS_FIELD_NUMBER: _ClassVar[int] + task_name: str + environment_name: str + total_runs: int + latest_run_time: _timestamp_pb2.Timestamp + recent_statuses: _containers.RepeatedCompositeFieldContainer[TaskGroup.RecentStatus] + average_failure_rate: float + average_duration: _duration_pb2.Duration + latest_finished_time: _timestamp_pb2.Timestamp + created_by: _containers.RepeatedCompositeFieldContainer[_identity_pb2.EnrichedIdentity] + should_delete: bool + short_name: str + error_counts: TaskGroup.ErrorCounts + phase_counts: _containers.RepeatedCompositeFieldContainer[TaskGroup.PhaseCounts] + def __init__(self, task_name: _Optional[str] = ..., environment_name: _Optional[str] = ..., total_runs: _Optional[int] = ..., latest_run_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., recent_statuses: _Optional[_Iterable[_Union[TaskGroup.RecentStatus, _Mapping]]] = ..., average_failure_rate: _Optional[float] = ..., average_duration: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., latest_finished_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., created_by: _Optional[_Iterable[_Union[_identity_pb2.EnrichedIdentity, _Mapping]]] = ..., should_delete: bool = ..., short_name: _Optional[str] = ..., error_counts: _Optional[_Union[TaskGroup.ErrorCounts, _Mapping]] = ..., phase_counts: _Optional[_Iterable[_Union[TaskGroup.PhaseCounts, _Mapping]]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/workflow/run_definition_pb2_grpc.py b/gen/python/flyteidl2/workflow/run_definition_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/flyteidl2/workflow/run_definition_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/flyteidl2/workflow/run_logs_service_pb2.py b/gen/python/flyteidl2/workflow/run_logs_service_pb2.py new file mode 100644 index 0000000000..d74b4050db --- /dev/null +++ b/gen/python/flyteidl2/workflow/run_logs_service_pb2.py @@ -0,0 +1,41 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/workflow/run_logs_service.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.common import identifier_pb2 as flyteidl2_dot_common_dot_identifier__pb2 +from flyteidl2.logs.dataplane import payload_pb2 as flyteidl2_dot_logs_dot_dataplane_dot_payload__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n)flyteidl2/workflow/run_logs_service.proto\x12\x12\x66lyteidl2.workflow\x1a\x1b\x62uf/validate/validate.proto\x1a!flyteidl2/common/identifier.proto\x1a&flyteidl2/logs/dataplane/payload.proto\"}\n\x0fTailLogsRequest\x12G\n\taction_id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x08\x61\x63tionId\x12!\n\x07\x61ttempt\x18\x02 \x01(\rB\x07\xbaH\x04*\x02 \x00R\x07\x61ttempt\"\x92\x01\n\x10TailLogsResponse\x12=\n\x04logs\x18\x01 \x03(\x0b\x32).flyteidl2.workflow.TailLogsResponse.LogsR\x04logs\x1a?\n\x04Logs\x12\x37\n\x05lines\x18\x01 \x03(\x0b\x32!.flyteidl2.logs.dataplane.LogLineR\x05lines2n\n\x0eRunLogsService\x12\\\n\x08TailLogs\x12#.flyteidl2.workflow.TailLogsRequest\x1a$.flyteidl2.workflow.TailLogsResponse\"\x03\x90\x02\x01\x30\x01\x42\xd0\x01\n\x16\x63om.flyteidl2.workflowB\x13RunLogsServiceProtoH\x02P\x01Z6github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow\xa2\x02\x03\x46WX\xaa\x02\x12\x46lyteidl2.Workflow\xca\x02\x12\x46lyteidl2\\Workflow\xe2\x02\x1e\x46lyteidl2\\Workflow\\GPBMetadata\xea\x02\x13\x46lyteidl2::Workflowb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.workflow.run_logs_service_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\026com.flyteidl2.workflowB\023RunLogsServiceProtoH\002P\001Z6github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow\242\002\003FWX\252\002\022Flyteidl2.Workflow\312\002\022Flyteidl2\\Workflow\342\002\036Flyteidl2\\Workflow\\GPBMetadata\352\002\023Flyteidl2::Workflow' + _TAILLOGSREQUEST.fields_by_name['action_id']._options = None + _TAILLOGSREQUEST.fields_by_name['action_id']._serialized_options = b'\272H\003\310\001\001' + _TAILLOGSREQUEST.fields_by_name['attempt']._options = None + _TAILLOGSREQUEST.fields_by_name['attempt']._serialized_options = b'\272H\004*\002 \000' + _RUNLOGSSERVICE.methods_by_name['TailLogs']._options = None + _RUNLOGSSERVICE.methods_by_name['TailLogs']._serialized_options = b'\220\002\001' + _globals['_TAILLOGSREQUEST']._serialized_start=169 + _globals['_TAILLOGSREQUEST']._serialized_end=294 + _globals['_TAILLOGSRESPONSE']._serialized_start=297 + _globals['_TAILLOGSRESPONSE']._serialized_end=443 + _globals['_TAILLOGSRESPONSE_LOGS']._serialized_start=380 + _globals['_TAILLOGSRESPONSE_LOGS']._serialized_end=443 + _globals['_RUNLOGSSERVICE']._serialized_start=445 + _globals['_RUNLOGSSERVICE']._serialized_end=555 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/workflow/run_logs_service_pb2.pyi b/gen/python/flyteidl2/workflow/run_logs_service_pb2.pyi new file mode 100644 index 0000000000..030e172dd5 --- /dev/null +++ b/gen/python/flyteidl2/workflow/run_logs_service_pb2.pyi @@ -0,0 +1,28 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.common import identifier_pb2 as _identifier_pb2 +from flyteidl2.logs.dataplane import payload_pb2 as _payload_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class TailLogsRequest(_message.Message): + __slots__ = ["action_id", "attempt"] + ACTION_ID_FIELD_NUMBER: _ClassVar[int] + ATTEMPT_FIELD_NUMBER: _ClassVar[int] + action_id: _identifier_pb2.ActionIdentifier + attempt: int + def __init__(self, action_id: _Optional[_Union[_identifier_pb2.ActionIdentifier, _Mapping]] = ..., attempt: _Optional[int] = ...) -> None: ... + +class TailLogsResponse(_message.Message): + __slots__ = ["logs"] + class Logs(_message.Message): + __slots__ = ["lines"] + LINES_FIELD_NUMBER: _ClassVar[int] + lines: _containers.RepeatedCompositeFieldContainer[_payload_pb2.LogLine] + def __init__(self, lines: _Optional[_Iterable[_Union[_payload_pb2.LogLine, _Mapping]]] = ...) -> None: ... + LOGS_FIELD_NUMBER: _ClassVar[int] + logs: _containers.RepeatedCompositeFieldContainer[TailLogsResponse.Logs] + def __init__(self, logs: _Optional[_Iterable[_Union[TailLogsResponse.Logs, _Mapping]]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/workflow/run_logs_service_pb2_grpc.py b/gen/python/flyteidl2/workflow/run_logs_service_pb2_grpc.py new file mode 100644 index 0000000000..9e240e6d3e --- /dev/null +++ b/gen/python/flyteidl2/workflow/run_logs_service_pb2_grpc.py @@ -0,0 +1,69 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from flyteidl2.workflow import run_logs_service_pb2 as flyteidl2_dot_workflow_dot_run__logs__service__pb2 + + +class RunLogsServiceStub(object): + """RunLogsService provides an interface for streaming logs. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.TailLogs = channel.unary_stream( + '/flyteidl2.workflow.RunLogsService/TailLogs', + request_serializer=flyteidl2_dot_workflow_dot_run__logs__service__pb2.TailLogsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_run__logs__service__pb2.TailLogsResponse.FromString, + ) + + +class RunLogsServiceServicer(object): + """RunLogsService provides an interface for streaming logs. + """ + + def TailLogs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_RunLogsServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'TailLogs': grpc.unary_stream_rpc_method_handler( + servicer.TailLogs, + request_deserializer=flyteidl2_dot_workflow_dot_run__logs__service__pb2.TailLogsRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_run__logs__service__pb2.TailLogsResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.workflow.RunLogsService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class RunLogsService(object): + """RunLogsService provides an interface for streaming logs. + """ + + @staticmethod + def TailLogs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream(request, target, '/flyteidl2.workflow.RunLogsService/TailLogs', + flyteidl2_dot_workflow_dot_run__logs__service__pb2.TailLogsRequest.SerializeToString, + flyteidl2_dot_workflow_dot_run__logs__service__pb2.TailLogsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/gen/python/flyteidl2/workflow/run_service_pb2.py b/gen/python/flyteidl2/workflow/run_service_pb2.py new file mode 100644 index 0000000000..69247e63a3 --- /dev/null +++ b/gen/python/flyteidl2/workflow/run_service_pb2.py @@ -0,0 +1,140 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/workflow/run_service.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.common import identifier_pb2 as flyteidl2_dot_common_dot_identifier__pb2 +from flyteidl2.common import list_pb2 as flyteidl2_dot_common_dot_list__pb2 +from flyteidl2.task import common_pb2 as flyteidl2_dot_task_dot_common__pb2 +from flyteidl2.task import run_pb2 as flyteidl2_dot_task_dot_run__pb2 +from flyteidl2.task import task_definition_pb2 as flyteidl2_dot_task_dot_task__definition__pb2 +from flyteidl2.workflow import run_definition_pb2 as flyteidl2_dot_workflow_dot_run__definition__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n$flyteidl2/workflow/run_service.proto\x12\x12\x66lyteidl2.workflow\x1a\x1b\x62uf/validate/validate.proto\x1a!flyteidl2/common/identifier.proto\x1a\x1b\x66lyteidl2/common/list.proto\x1a\x1b\x66lyteidl2/task/common.proto\x1a\x18\x66lyteidl2/task/run.proto\x1a$flyteidl2/task/task_definition.proto\x1a\'flyteidl2/workflow/run_definition.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\x81\x04\n\x10\x43reateRunRequest\x12\x38\n\x06run_id\x18\x01 \x01(\x0b\x32\x1f.flyteidl2.common.RunIdentifierH\x00R\x05runId\x12\x44\n\nproject_id\x18\x06 \x01(\x0b\x32#.flyteidl2.common.ProjectIdentifierH\x00R\tprojectId\x12\x39\n\x07task_id\x18\x02 \x01(\x0b\x32\x1e.flyteidl2.task.TaskIdentifierH\x01R\x06taskId\x12\x37\n\ttask_spec\x18\x03 \x01(\x0b\x32\x18.flyteidl2.task.TaskSpecH\x01R\x08taskSpec\x12\x42\n\x0ctrigger_name\x18\x07 \x01(\x0b\x32\x1d.flyteidl2.common.TriggerNameH\x01R\x0btriggerName\x12.\n\x06inputs\x18\x04 \x01(\x0b\x32\x16.flyteidl2.task.InputsR\x06inputs\x12\x32\n\x08run_spec\x18\x05 \x01(\x0b\x32\x17.flyteidl2.task.RunSpecR\x07runSpec\x12\x35\n\x06source\x18\x08 \x01(\x0e\x32\x1d.flyteidl2.workflow.RunSourceR\x06sourceB\x0b\n\x02id\x12\x05\xbaH\x02\x08\x01\x42\r\n\x04task\x12\x05\xbaH\x02\x08\x01\">\n\x11\x43reateRunResponse\x12)\n\x03run\x18\x01 \x01(\x0b\x32\x17.flyteidl2.workflow.RunR\x03run\"y\n\x0f\x41\x62ortRunRequest\x12>\n\x06run_id\x18\x01 \x01(\x0b\x32\x1f.flyteidl2.common.RunIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x05runId\x12\x1b\n\x06reason\x18\x02 \x01(\tH\x00R\x06reason\x88\x01\x01\x42\t\n\x07_reason\"\x12\n\x10\x41\x62ortRunResponse\"V\n\x14GetRunDetailsRequest\x12>\n\x06run_id\x18\x01 \x01(\x0b\x32\x1f.flyteidl2.common.RunIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x05runId\"Q\n\x15GetRunDetailsResponse\x12\x38\n\x07\x64\x65tails\x18\x01 \x01(\x0b\x32\x1e.flyteidl2.workflow.RunDetailsR\x07\x64\x65tails\"X\n\x16WatchRunDetailsRequest\x12>\n\x06run_id\x18\x01 \x01(\x0b\x32\x1f.flyteidl2.common.RunIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x05runId\"S\n\x17WatchRunDetailsResponse\x12\x38\n\x07\x64\x65tails\x18\x01 \x01(\x0b\x32\x1e.flyteidl2.workflow.RunDetailsR\x07\x64\x65tails\"b\n\x17GetActionDetailsRequest\x12G\n\taction_id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x08\x61\x63tionId\"W\n\x18GetActionDetailsResponse\x12;\n\x07\x64\x65tails\x18\x01 \x01(\x0b\x32!.flyteidl2.workflow.ActionDetailsR\x07\x64\x65tails\"d\n\x19WatchActionDetailsRequest\x12G\n\taction_id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x08\x61\x63tionId\"Y\n\x1aWatchActionDetailsResponse\x12;\n\x07\x64\x65tails\x18\x01 \x01(\x0b\x32!.flyteidl2.workflow.ActionDetailsR\x07\x64\x65tails\"_\n\x14GetActionDataRequest\x12G\n\taction_id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x08\x61\x63tionId\"z\n\x15GetActionDataResponse\x12.\n\x06inputs\x18\x01 \x01(\x0b\x32\x16.flyteidl2.task.InputsR\x06inputs\x12\x31\n\x07outputs\x18\x02 \x01(\x0b\x32\x17.flyteidl2.task.OutputsR\x07outputs\"\x84\x03\n\x0fListRunsRequest\x12\x37\n\x07request\x18\x01 \x01(\x0b\x32\x1d.flyteidl2.common.ListRequestR\x07request\x12\x1b\n\x03org\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01H\x00R\x03org\x12\x44\n\nproject_id\x18\x04 \x01(\x0b\x32#.flyteidl2.common.ProjectIdentifierH\x00R\tprojectId\x12\x42\n\x0ctrigger_name\x18\x06 \x01(\x0b\x32\x1d.flyteidl2.common.TriggerNameH\x00R\x0btriggerName\x12\x37\n\ttask_name\x18\x07 \x01(\x0b\x32\x18.flyteidl2.task.TaskNameH\x00R\x08taskName\x12\x39\n\x07task_id\x18\x08 \x01(\x0b\x32\x1e.flyteidl2.task.TaskIdentifierH\x00R\x06taskIdB\x11\n\x08scope_by\x12\x05\xbaH\x02\x08\x01J\x04\x08\x03\x10\x04J\x04\x08\x05\x10\x06\"U\n\x10ListRunsResponse\x12+\n\x04runs\x18\x01 \x03(\x0b\x32\x17.flyteidl2.workflow.RunR\x04runs\x12\x14\n\x05token\x18\x02 \x01(\tR\x05token\"\x87\x02\n\x10WatchRunsRequest\x12\x1b\n\x03org\x18\x02 \x01(\tB\x07\xbaH\x04r\x02\x10\x01H\x00R\x03org\x12\x44\n\ncluster_id\x18\x03 \x01(\x0b\x32#.flyteidl2.common.ClusterIdentifierH\x00R\tclusterId\x12\x44\n\nproject_id\x18\x04 \x01(\x0b\x32#.flyteidl2.common.ProjectIdentifierH\x00R\tprojectId\x12\x39\n\x07task_id\x18\x05 \x01(\x0b\x32\x1e.flyteidl2.task.TaskIdentifierH\x00R\x06taskIdB\x0f\n\x06target\x12\x05\xbaH\x02\x08\x01\"@\n\x11WatchRunsResponse\x12+\n\x04runs\x18\x01 \x03(\x0b\x32\x17.flyteidl2.workflow.RunR\x04runs\"\x8d\x01\n\x12ListActionsRequest\x12\x37\n\x07request\x18\x01 \x01(\x0b\x32\x1d.flyteidl2.common.ListRequestR\x07request\x12>\n\x06run_id\x18\x02 \x01(\x0b\x32\x1f.flyteidl2.common.RunIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x05runId\"a\n\x13ListActionsResponse\x12\x34\n\x07\x61\x63tions\x18\x01 \x03(\x0b\x32\x1a.flyteidl2.workflow.ActionR\x07\x61\x63tions\x12\x14\n\x05token\x18\x02 \x01(\tR\x05token\"\x87\x01\n\x13WatchActionsRequest\x12>\n\x06run_id\x18\x01 \x01(\x0b\x32\x1f.flyteidl2.common.RunIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x05runId\x12\x30\n\x06\x66ilter\x18\x02 \x03(\x0b\x32\x18.flyteidl2.common.FilterR\x06\x66ilter\"e\n\x14WatchActionsResponse\x12M\n\x10\x65nriched_actions\x18\x01 \x03(\x0b\x32\".flyteidl2.workflow.EnrichedActionR\x0f\x65nrichedActions\"z\n\x19WatchClusterEventsRequest\x12:\n\x02id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x02id\x12!\n\x07\x61ttempt\x18\x02 \x01(\rB\x07\xbaH\x04*\x02 \x00R\x07\x61ttempt\"e\n\x1aWatchClusterEventsResponse\x12G\n\x0e\x63luster_events\x18\x01 \x03(\x0b\x32 .flyteidl2.workflow.ClusterEventR\rclusterEvents\"u\n\x12\x41\x62ortActionRequest\x12G\n\taction_id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x08\x61\x63tionId\x12\x16\n\x06reason\x18\x02 \x01(\tR\x06reason\"\x15\n\x13\x41\x62ortActionResponse\"\xe3\x03\n\x12WatchGroupsRequest\x12\x44\n\nproject_id\x18\x01 \x01(\x0b\x32#.flyteidl2.common.ProjectIdentifierH\x00R\tprojectId\x12\x41\n\nstart_date\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampB\x06\xbaH\x03\xc8\x01\x01R\tstartDate\x12\x35\n\x08\x65nd_date\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x07\x65ndDate\x12\x37\n\x07request\x18\x04 \x01(\x0b\x32\x1d.flyteidl2.common.ListRequestR\x07request\x12\x61\n\x11known_sort_fields\x18\x05 \x03(\x0b\x32\x35.flyteidl2.workflow.WatchGroupsRequest.KnownSortFieldR\x0fknownSortFields\x1a^\n\x0eKnownSortField\x12\x41\n\ncreated_at\x18\x01 \x01(\x0e\x32 .flyteidl2.common.Sort.DirectionH\x00R\tcreatedAtB\t\n\x07sort_byB\x11\n\x08scope_by\x12\x05\xbaH\x02\x08\x01\"q\n\x13WatchGroupsResponse\x12>\n\x0btask_groups\x18\x01 \x03(\x0b\x32\x1d.flyteidl2.workflow.TaskGroupR\ntaskGroups\x12\x1a\n\x08sentinel\x18\x02 \x01(\x08R\x08sentinel2\xb9\x0b\n\nRunService\x12Z\n\tCreateRun\x12$.flyteidl2.workflow.CreateRunRequest\x1a%.flyteidl2.workflow.CreateRunResponse\"\x00\x12W\n\x08\x41\x62ortRun\x12#.flyteidl2.workflow.AbortRunRequest\x1a$.flyteidl2.workflow.AbortRunResponse\"\x00\x12i\n\rGetRunDetails\x12(.flyteidl2.workflow.GetRunDetailsRequest\x1a).flyteidl2.workflow.GetRunDetailsResponse\"\x03\x90\x02\x01\x12n\n\x0fWatchRunDetails\x12*.flyteidl2.workflow.WatchRunDetailsRequest\x1a+.flyteidl2.workflow.WatchRunDetailsResponse\"\x00\x30\x01\x12r\n\x10GetActionDetails\x12+.flyteidl2.workflow.GetActionDetailsRequest\x1a,.flyteidl2.workflow.GetActionDetailsResponse\"\x03\x90\x02\x01\x12w\n\x12WatchActionDetails\x12-.flyteidl2.workflow.WatchActionDetailsRequest\x1a..flyteidl2.workflow.WatchActionDetailsResponse\"\x00\x30\x01\x12i\n\rGetActionData\x12(.flyteidl2.workflow.GetActionDataRequest\x1a).flyteidl2.workflow.GetActionDataResponse\"\x03\x90\x02\x01\x12Z\n\x08ListRuns\x12#.flyteidl2.workflow.ListRunsRequest\x1a$.flyteidl2.workflow.ListRunsResponse\"\x03\x90\x02\x01\x12\\\n\tWatchRuns\x12$.flyteidl2.workflow.WatchRunsRequest\x1a%.flyteidl2.workflow.WatchRunsResponse\"\x00\x30\x01\x12\x63\n\x0bListActions\x12&.flyteidl2.workflow.ListActionsRequest\x1a\'.flyteidl2.workflow.ListActionsResponse\"\x03\x90\x02\x01\x12\x65\n\x0cWatchActions\x12\'.flyteidl2.workflow.WatchActionsRequest\x1a(.flyteidl2.workflow.WatchActionsResponse\"\x00\x30\x01\x12w\n\x12WatchClusterEvents\x12-.flyteidl2.workflow.WatchClusterEventsRequest\x1a..flyteidl2.workflow.WatchClusterEventsResponse\"\x00\x30\x01\x12`\n\x0b\x41\x62ortAction\x12&.flyteidl2.workflow.AbortActionRequest\x1a\'.flyteidl2.workflow.AbortActionResponse\"\x00\x12\x62\n\x0bWatchGroups\x12&.flyteidl2.workflow.WatchGroupsRequest\x1a\'.flyteidl2.workflow.WatchGroupsResponse\"\x00\x30\x01\x42\xcc\x01\n\x16\x63om.flyteidl2.workflowB\x0fRunServiceProtoH\x02P\x01Z6github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow\xa2\x02\x03\x46WX\xaa\x02\x12\x46lyteidl2.Workflow\xca\x02\x12\x46lyteidl2\\Workflow\xe2\x02\x1e\x46lyteidl2\\Workflow\\GPBMetadata\xea\x02\x13\x46lyteidl2::Workflowb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.workflow.run_service_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\026com.flyteidl2.workflowB\017RunServiceProtoH\002P\001Z6github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow\242\002\003FWX\252\002\022Flyteidl2.Workflow\312\002\022Flyteidl2\\Workflow\342\002\036Flyteidl2\\Workflow\\GPBMetadata\352\002\023Flyteidl2::Workflow' + _CREATERUNREQUEST.oneofs_by_name['id']._options = None + _CREATERUNREQUEST.oneofs_by_name['id']._serialized_options = b'\272H\002\010\001' + _CREATERUNREQUEST.oneofs_by_name['task']._options = None + _CREATERUNREQUEST.oneofs_by_name['task']._serialized_options = b'\272H\002\010\001' + _ABORTRUNREQUEST.fields_by_name['run_id']._options = None + _ABORTRUNREQUEST.fields_by_name['run_id']._serialized_options = b'\272H\003\310\001\001' + _GETRUNDETAILSREQUEST.fields_by_name['run_id']._options = None + _GETRUNDETAILSREQUEST.fields_by_name['run_id']._serialized_options = b'\272H\003\310\001\001' + _WATCHRUNDETAILSREQUEST.fields_by_name['run_id']._options = None + _WATCHRUNDETAILSREQUEST.fields_by_name['run_id']._serialized_options = b'\272H\003\310\001\001' + _GETACTIONDETAILSREQUEST.fields_by_name['action_id']._options = None + _GETACTIONDETAILSREQUEST.fields_by_name['action_id']._serialized_options = b'\272H\003\310\001\001' + _WATCHACTIONDETAILSREQUEST.fields_by_name['action_id']._options = None + _WATCHACTIONDETAILSREQUEST.fields_by_name['action_id']._serialized_options = b'\272H\003\310\001\001' + _GETACTIONDATAREQUEST.fields_by_name['action_id']._options = None + _GETACTIONDATAREQUEST.fields_by_name['action_id']._serialized_options = b'\272H\003\310\001\001' + _LISTRUNSREQUEST.oneofs_by_name['scope_by']._options = None + _LISTRUNSREQUEST.oneofs_by_name['scope_by']._serialized_options = b'\272H\002\010\001' + _LISTRUNSREQUEST.fields_by_name['org']._options = None + _LISTRUNSREQUEST.fields_by_name['org']._serialized_options = b'\272H\004r\002\020\001' + _WATCHRUNSREQUEST.oneofs_by_name['target']._options = None + _WATCHRUNSREQUEST.oneofs_by_name['target']._serialized_options = b'\272H\002\010\001' + _WATCHRUNSREQUEST.fields_by_name['org']._options = None + _WATCHRUNSREQUEST.fields_by_name['org']._serialized_options = b'\272H\004r\002\020\001' + _LISTACTIONSREQUEST.fields_by_name['run_id']._options = None + _LISTACTIONSREQUEST.fields_by_name['run_id']._serialized_options = b'\272H\003\310\001\001' + _WATCHACTIONSREQUEST.fields_by_name['run_id']._options = None + _WATCHACTIONSREQUEST.fields_by_name['run_id']._serialized_options = b'\272H\003\310\001\001' + _WATCHCLUSTEREVENTSREQUEST.fields_by_name['id']._options = None + _WATCHCLUSTEREVENTSREQUEST.fields_by_name['id']._serialized_options = b'\272H\003\310\001\001' + _WATCHCLUSTEREVENTSREQUEST.fields_by_name['attempt']._options = None + _WATCHCLUSTEREVENTSREQUEST.fields_by_name['attempt']._serialized_options = b'\272H\004*\002 \000' + _ABORTACTIONREQUEST.fields_by_name['action_id']._options = None + _ABORTACTIONREQUEST.fields_by_name['action_id']._serialized_options = b'\272H\003\310\001\001' + _WATCHGROUPSREQUEST.oneofs_by_name['scope_by']._options = None + _WATCHGROUPSREQUEST.oneofs_by_name['scope_by']._serialized_options = b'\272H\002\010\001' + _WATCHGROUPSREQUEST.fields_by_name['start_date']._options = None + _WATCHGROUPSREQUEST.fields_by_name['start_date']._serialized_options = b'\272H\003\310\001\001' + _RUNSERVICE.methods_by_name['GetRunDetails']._options = None + _RUNSERVICE.methods_by_name['GetRunDetails']._serialized_options = b'\220\002\001' + _RUNSERVICE.methods_by_name['GetActionDetails']._options = None + _RUNSERVICE.methods_by_name['GetActionDetails']._serialized_options = b'\220\002\001' + _RUNSERVICE.methods_by_name['GetActionData']._options = None + _RUNSERVICE.methods_by_name['GetActionData']._serialized_options = b'\220\002\001' + _RUNSERVICE.methods_by_name['ListRuns']._options = None + _RUNSERVICE.methods_by_name['ListRuns']._serialized_options = b'\220\002\001' + _RUNSERVICE.methods_by_name['ListActions']._options = None + _RUNSERVICE.methods_by_name['ListActions']._serialized_options = b'\220\002\001' + _globals['_CREATERUNREQUEST']._serialized_start=321 + _globals['_CREATERUNREQUEST']._serialized_end=834 + _globals['_CREATERUNRESPONSE']._serialized_start=836 + _globals['_CREATERUNRESPONSE']._serialized_end=898 + _globals['_ABORTRUNREQUEST']._serialized_start=900 + _globals['_ABORTRUNREQUEST']._serialized_end=1021 + _globals['_ABORTRUNRESPONSE']._serialized_start=1023 + _globals['_ABORTRUNRESPONSE']._serialized_end=1041 + _globals['_GETRUNDETAILSREQUEST']._serialized_start=1043 + _globals['_GETRUNDETAILSREQUEST']._serialized_end=1129 + _globals['_GETRUNDETAILSRESPONSE']._serialized_start=1131 + _globals['_GETRUNDETAILSRESPONSE']._serialized_end=1212 + _globals['_WATCHRUNDETAILSREQUEST']._serialized_start=1214 + _globals['_WATCHRUNDETAILSREQUEST']._serialized_end=1302 + _globals['_WATCHRUNDETAILSRESPONSE']._serialized_start=1304 + _globals['_WATCHRUNDETAILSRESPONSE']._serialized_end=1387 + _globals['_GETACTIONDETAILSREQUEST']._serialized_start=1389 + _globals['_GETACTIONDETAILSREQUEST']._serialized_end=1487 + _globals['_GETACTIONDETAILSRESPONSE']._serialized_start=1489 + _globals['_GETACTIONDETAILSRESPONSE']._serialized_end=1576 + _globals['_WATCHACTIONDETAILSREQUEST']._serialized_start=1578 + _globals['_WATCHACTIONDETAILSREQUEST']._serialized_end=1678 + _globals['_WATCHACTIONDETAILSRESPONSE']._serialized_start=1680 + _globals['_WATCHACTIONDETAILSRESPONSE']._serialized_end=1769 + _globals['_GETACTIONDATAREQUEST']._serialized_start=1771 + _globals['_GETACTIONDATAREQUEST']._serialized_end=1866 + _globals['_GETACTIONDATARESPONSE']._serialized_start=1868 + _globals['_GETACTIONDATARESPONSE']._serialized_end=1990 + _globals['_LISTRUNSREQUEST']._serialized_start=1993 + _globals['_LISTRUNSREQUEST']._serialized_end=2381 + _globals['_LISTRUNSRESPONSE']._serialized_start=2383 + _globals['_LISTRUNSRESPONSE']._serialized_end=2468 + _globals['_WATCHRUNSREQUEST']._serialized_start=2471 + _globals['_WATCHRUNSREQUEST']._serialized_end=2734 + _globals['_WATCHRUNSRESPONSE']._serialized_start=2736 + _globals['_WATCHRUNSRESPONSE']._serialized_end=2800 + _globals['_LISTACTIONSREQUEST']._serialized_start=2803 + _globals['_LISTACTIONSREQUEST']._serialized_end=2944 + _globals['_LISTACTIONSRESPONSE']._serialized_start=2946 + _globals['_LISTACTIONSRESPONSE']._serialized_end=3043 + _globals['_WATCHACTIONSREQUEST']._serialized_start=3046 + _globals['_WATCHACTIONSREQUEST']._serialized_end=3181 + _globals['_WATCHACTIONSRESPONSE']._serialized_start=3183 + _globals['_WATCHACTIONSRESPONSE']._serialized_end=3284 + _globals['_WATCHCLUSTEREVENTSREQUEST']._serialized_start=3286 + _globals['_WATCHCLUSTEREVENTSREQUEST']._serialized_end=3408 + _globals['_WATCHCLUSTEREVENTSRESPONSE']._serialized_start=3410 + _globals['_WATCHCLUSTEREVENTSRESPONSE']._serialized_end=3511 + _globals['_ABORTACTIONREQUEST']._serialized_start=3513 + _globals['_ABORTACTIONREQUEST']._serialized_end=3630 + _globals['_ABORTACTIONRESPONSE']._serialized_start=3632 + _globals['_ABORTACTIONRESPONSE']._serialized_end=3653 + _globals['_WATCHGROUPSREQUEST']._serialized_start=3656 + _globals['_WATCHGROUPSREQUEST']._serialized_end=4139 + _globals['_WATCHGROUPSREQUEST_KNOWNSORTFIELD']._serialized_start=4026 + _globals['_WATCHGROUPSREQUEST_KNOWNSORTFIELD']._serialized_end=4120 + _globals['_WATCHGROUPSRESPONSE']._serialized_start=4141 + _globals['_WATCHGROUPSRESPONSE']._serialized_end=4254 + _globals['_RUNSERVICE']._serialized_start=4257 + _globals['_RUNSERVICE']._serialized_end=5722 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/workflow/run_service_pb2.pyi b/gen/python/flyteidl2/workflow/run_service_pb2.pyi new file mode 100644 index 0000000000..c12e4e99cd --- /dev/null +++ b/gen/python/flyteidl2/workflow/run_service_pb2.pyi @@ -0,0 +1,239 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.common import identifier_pb2 as _identifier_pb2 +from flyteidl2.common import list_pb2 as _list_pb2 +from flyteidl2.task import common_pb2 as _common_pb2 +from flyteidl2.task import run_pb2 as _run_pb2 +from flyteidl2.task import task_definition_pb2 as _task_definition_pb2 +from flyteidl2.workflow import run_definition_pb2 as _run_definition_pb2 +from google.protobuf import timestamp_pb2 as _timestamp_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class CreateRunRequest(_message.Message): + __slots__ = ["run_id", "project_id", "task_id", "task_spec", "trigger_name", "inputs", "run_spec", "source"] + RUN_ID_FIELD_NUMBER: _ClassVar[int] + PROJECT_ID_FIELD_NUMBER: _ClassVar[int] + TASK_ID_FIELD_NUMBER: _ClassVar[int] + TASK_SPEC_FIELD_NUMBER: _ClassVar[int] + TRIGGER_NAME_FIELD_NUMBER: _ClassVar[int] + INPUTS_FIELD_NUMBER: _ClassVar[int] + RUN_SPEC_FIELD_NUMBER: _ClassVar[int] + SOURCE_FIELD_NUMBER: _ClassVar[int] + run_id: _identifier_pb2.RunIdentifier + project_id: _identifier_pb2.ProjectIdentifier + task_id: _task_definition_pb2.TaskIdentifier + task_spec: _task_definition_pb2.TaskSpec + trigger_name: _identifier_pb2.TriggerName + inputs: _common_pb2.Inputs + run_spec: _run_pb2.RunSpec + source: _run_definition_pb2.RunSource + def __init__(self, run_id: _Optional[_Union[_identifier_pb2.RunIdentifier, _Mapping]] = ..., project_id: _Optional[_Union[_identifier_pb2.ProjectIdentifier, _Mapping]] = ..., task_id: _Optional[_Union[_task_definition_pb2.TaskIdentifier, _Mapping]] = ..., task_spec: _Optional[_Union[_task_definition_pb2.TaskSpec, _Mapping]] = ..., trigger_name: _Optional[_Union[_identifier_pb2.TriggerName, _Mapping]] = ..., inputs: _Optional[_Union[_common_pb2.Inputs, _Mapping]] = ..., run_spec: _Optional[_Union[_run_pb2.RunSpec, _Mapping]] = ..., source: _Optional[_Union[_run_definition_pb2.RunSource, str]] = ...) -> None: ... + +class CreateRunResponse(_message.Message): + __slots__ = ["run"] + RUN_FIELD_NUMBER: _ClassVar[int] + run: _run_definition_pb2.Run + def __init__(self, run: _Optional[_Union[_run_definition_pb2.Run, _Mapping]] = ...) -> None: ... + +class AbortRunRequest(_message.Message): + __slots__ = ["run_id", "reason"] + RUN_ID_FIELD_NUMBER: _ClassVar[int] + REASON_FIELD_NUMBER: _ClassVar[int] + run_id: _identifier_pb2.RunIdentifier + reason: str + def __init__(self, run_id: _Optional[_Union[_identifier_pb2.RunIdentifier, _Mapping]] = ..., reason: _Optional[str] = ...) -> None: ... + +class AbortRunResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class GetRunDetailsRequest(_message.Message): + __slots__ = ["run_id"] + RUN_ID_FIELD_NUMBER: _ClassVar[int] + run_id: _identifier_pb2.RunIdentifier + def __init__(self, run_id: _Optional[_Union[_identifier_pb2.RunIdentifier, _Mapping]] = ...) -> None: ... + +class GetRunDetailsResponse(_message.Message): + __slots__ = ["details"] + DETAILS_FIELD_NUMBER: _ClassVar[int] + details: _run_definition_pb2.RunDetails + def __init__(self, details: _Optional[_Union[_run_definition_pb2.RunDetails, _Mapping]] = ...) -> None: ... + +class WatchRunDetailsRequest(_message.Message): + __slots__ = ["run_id"] + RUN_ID_FIELD_NUMBER: _ClassVar[int] + run_id: _identifier_pb2.RunIdentifier + def __init__(self, run_id: _Optional[_Union[_identifier_pb2.RunIdentifier, _Mapping]] = ...) -> None: ... + +class WatchRunDetailsResponse(_message.Message): + __slots__ = ["details"] + DETAILS_FIELD_NUMBER: _ClassVar[int] + details: _run_definition_pb2.RunDetails + def __init__(self, details: _Optional[_Union[_run_definition_pb2.RunDetails, _Mapping]] = ...) -> None: ... + +class GetActionDetailsRequest(_message.Message): + __slots__ = ["action_id"] + ACTION_ID_FIELD_NUMBER: _ClassVar[int] + action_id: _identifier_pb2.ActionIdentifier + def __init__(self, action_id: _Optional[_Union[_identifier_pb2.ActionIdentifier, _Mapping]] = ...) -> None: ... + +class GetActionDetailsResponse(_message.Message): + __slots__ = ["details"] + DETAILS_FIELD_NUMBER: _ClassVar[int] + details: _run_definition_pb2.ActionDetails + def __init__(self, details: _Optional[_Union[_run_definition_pb2.ActionDetails, _Mapping]] = ...) -> None: ... + +class WatchActionDetailsRequest(_message.Message): + __slots__ = ["action_id"] + ACTION_ID_FIELD_NUMBER: _ClassVar[int] + action_id: _identifier_pb2.ActionIdentifier + def __init__(self, action_id: _Optional[_Union[_identifier_pb2.ActionIdentifier, _Mapping]] = ...) -> None: ... + +class WatchActionDetailsResponse(_message.Message): + __slots__ = ["details"] + DETAILS_FIELD_NUMBER: _ClassVar[int] + details: _run_definition_pb2.ActionDetails + def __init__(self, details: _Optional[_Union[_run_definition_pb2.ActionDetails, _Mapping]] = ...) -> None: ... + +class GetActionDataRequest(_message.Message): + __slots__ = ["action_id"] + ACTION_ID_FIELD_NUMBER: _ClassVar[int] + action_id: _identifier_pb2.ActionIdentifier + def __init__(self, action_id: _Optional[_Union[_identifier_pb2.ActionIdentifier, _Mapping]] = ...) -> None: ... + +class GetActionDataResponse(_message.Message): + __slots__ = ["inputs", "outputs"] + INPUTS_FIELD_NUMBER: _ClassVar[int] + OUTPUTS_FIELD_NUMBER: _ClassVar[int] + inputs: _common_pb2.Inputs + outputs: _common_pb2.Outputs + def __init__(self, inputs: _Optional[_Union[_common_pb2.Inputs, _Mapping]] = ..., outputs: _Optional[_Union[_common_pb2.Outputs, _Mapping]] = ...) -> None: ... + +class ListRunsRequest(_message.Message): + __slots__ = ["request", "org", "project_id", "trigger_name", "task_name", "task_id"] + REQUEST_FIELD_NUMBER: _ClassVar[int] + ORG_FIELD_NUMBER: _ClassVar[int] + PROJECT_ID_FIELD_NUMBER: _ClassVar[int] + TRIGGER_NAME_FIELD_NUMBER: _ClassVar[int] + TASK_NAME_FIELD_NUMBER: _ClassVar[int] + TASK_ID_FIELD_NUMBER: _ClassVar[int] + request: _list_pb2.ListRequest + org: str + project_id: _identifier_pb2.ProjectIdentifier + trigger_name: _identifier_pb2.TriggerName + task_name: _task_definition_pb2.TaskName + task_id: _task_definition_pb2.TaskIdentifier + def __init__(self, request: _Optional[_Union[_list_pb2.ListRequest, _Mapping]] = ..., org: _Optional[str] = ..., project_id: _Optional[_Union[_identifier_pb2.ProjectIdentifier, _Mapping]] = ..., trigger_name: _Optional[_Union[_identifier_pb2.TriggerName, _Mapping]] = ..., task_name: _Optional[_Union[_task_definition_pb2.TaskName, _Mapping]] = ..., task_id: _Optional[_Union[_task_definition_pb2.TaskIdentifier, _Mapping]] = ...) -> None: ... + +class ListRunsResponse(_message.Message): + __slots__ = ["runs", "token"] + RUNS_FIELD_NUMBER: _ClassVar[int] + TOKEN_FIELD_NUMBER: _ClassVar[int] + runs: _containers.RepeatedCompositeFieldContainer[_run_definition_pb2.Run] + token: str + def __init__(self, runs: _Optional[_Iterable[_Union[_run_definition_pb2.Run, _Mapping]]] = ..., token: _Optional[str] = ...) -> None: ... + +class WatchRunsRequest(_message.Message): + __slots__ = ["org", "cluster_id", "project_id", "task_id"] + ORG_FIELD_NUMBER: _ClassVar[int] + CLUSTER_ID_FIELD_NUMBER: _ClassVar[int] + PROJECT_ID_FIELD_NUMBER: _ClassVar[int] + TASK_ID_FIELD_NUMBER: _ClassVar[int] + org: str + cluster_id: _identifier_pb2.ClusterIdentifier + project_id: _identifier_pb2.ProjectIdentifier + task_id: _task_definition_pb2.TaskIdentifier + def __init__(self, org: _Optional[str] = ..., cluster_id: _Optional[_Union[_identifier_pb2.ClusterIdentifier, _Mapping]] = ..., project_id: _Optional[_Union[_identifier_pb2.ProjectIdentifier, _Mapping]] = ..., task_id: _Optional[_Union[_task_definition_pb2.TaskIdentifier, _Mapping]] = ...) -> None: ... + +class WatchRunsResponse(_message.Message): + __slots__ = ["runs"] + RUNS_FIELD_NUMBER: _ClassVar[int] + runs: _containers.RepeatedCompositeFieldContainer[_run_definition_pb2.Run] + def __init__(self, runs: _Optional[_Iterable[_Union[_run_definition_pb2.Run, _Mapping]]] = ...) -> None: ... + +class ListActionsRequest(_message.Message): + __slots__ = ["request", "run_id"] + REQUEST_FIELD_NUMBER: _ClassVar[int] + RUN_ID_FIELD_NUMBER: _ClassVar[int] + request: _list_pb2.ListRequest + run_id: _identifier_pb2.RunIdentifier + def __init__(self, request: _Optional[_Union[_list_pb2.ListRequest, _Mapping]] = ..., run_id: _Optional[_Union[_identifier_pb2.RunIdentifier, _Mapping]] = ...) -> None: ... + +class ListActionsResponse(_message.Message): + __slots__ = ["actions", "token"] + ACTIONS_FIELD_NUMBER: _ClassVar[int] + TOKEN_FIELD_NUMBER: _ClassVar[int] + actions: _containers.RepeatedCompositeFieldContainer[_run_definition_pb2.Action] + token: str + def __init__(self, actions: _Optional[_Iterable[_Union[_run_definition_pb2.Action, _Mapping]]] = ..., token: _Optional[str] = ...) -> None: ... + +class WatchActionsRequest(_message.Message): + __slots__ = ["run_id", "filter"] + RUN_ID_FIELD_NUMBER: _ClassVar[int] + FILTER_FIELD_NUMBER: _ClassVar[int] + run_id: _identifier_pb2.RunIdentifier + filter: _containers.RepeatedCompositeFieldContainer[_list_pb2.Filter] + def __init__(self, run_id: _Optional[_Union[_identifier_pb2.RunIdentifier, _Mapping]] = ..., filter: _Optional[_Iterable[_Union[_list_pb2.Filter, _Mapping]]] = ...) -> None: ... + +class WatchActionsResponse(_message.Message): + __slots__ = ["enriched_actions"] + ENRICHED_ACTIONS_FIELD_NUMBER: _ClassVar[int] + enriched_actions: _containers.RepeatedCompositeFieldContainer[_run_definition_pb2.EnrichedAction] + def __init__(self, enriched_actions: _Optional[_Iterable[_Union[_run_definition_pb2.EnrichedAction, _Mapping]]] = ...) -> None: ... + +class WatchClusterEventsRequest(_message.Message): + __slots__ = ["id", "attempt"] + ID_FIELD_NUMBER: _ClassVar[int] + ATTEMPT_FIELD_NUMBER: _ClassVar[int] + id: _identifier_pb2.ActionIdentifier + attempt: int + def __init__(self, id: _Optional[_Union[_identifier_pb2.ActionIdentifier, _Mapping]] = ..., attempt: _Optional[int] = ...) -> None: ... + +class WatchClusterEventsResponse(_message.Message): + __slots__ = ["cluster_events"] + CLUSTER_EVENTS_FIELD_NUMBER: _ClassVar[int] + cluster_events: _containers.RepeatedCompositeFieldContainer[_run_definition_pb2.ClusterEvent] + def __init__(self, cluster_events: _Optional[_Iterable[_Union[_run_definition_pb2.ClusterEvent, _Mapping]]] = ...) -> None: ... + +class AbortActionRequest(_message.Message): + __slots__ = ["action_id", "reason"] + ACTION_ID_FIELD_NUMBER: _ClassVar[int] + REASON_FIELD_NUMBER: _ClassVar[int] + action_id: _identifier_pb2.ActionIdentifier + reason: str + def __init__(self, action_id: _Optional[_Union[_identifier_pb2.ActionIdentifier, _Mapping]] = ..., reason: _Optional[str] = ...) -> None: ... + +class AbortActionResponse(_message.Message): + __slots__ = [] + def __init__(self) -> None: ... + +class WatchGroupsRequest(_message.Message): + __slots__ = ["project_id", "start_date", "end_date", "request", "known_sort_fields"] + class KnownSortField(_message.Message): + __slots__ = ["created_at"] + CREATED_AT_FIELD_NUMBER: _ClassVar[int] + created_at: _list_pb2.Sort.Direction + def __init__(self, created_at: _Optional[_Union[_list_pb2.Sort.Direction, str]] = ...) -> None: ... + PROJECT_ID_FIELD_NUMBER: _ClassVar[int] + START_DATE_FIELD_NUMBER: _ClassVar[int] + END_DATE_FIELD_NUMBER: _ClassVar[int] + REQUEST_FIELD_NUMBER: _ClassVar[int] + KNOWN_SORT_FIELDS_FIELD_NUMBER: _ClassVar[int] + project_id: _identifier_pb2.ProjectIdentifier + start_date: _timestamp_pb2.Timestamp + end_date: _timestamp_pb2.Timestamp + request: _list_pb2.ListRequest + known_sort_fields: _containers.RepeatedCompositeFieldContainer[WatchGroupsRequest.KnownSortField] + def __init__(self, project_id: _Optional[_Union[_identifier_pb2.ProjectIdentifier, _Mapping]] = ..., start_date: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., end_date: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., request: _Optional[_Union[_list_pb2.ListRequest, _Mapping]] = ..., known_sort_fields: _Optional[_Iterable[_Union[WatchGroupsRequest.KnownSortField, _Mapping]]] = ...) -> None: ... + +class WatchGroupsResponse(_message.Message): + __slots__ = ["task_groups", "sentinel"] + TASK_GROUPS_FIELD_NUMBER: _ClassVar[int] + SENTINEL_FIELD_NUMBER: _ClassVar[int] + task_groups: _containers.RepeatedCompositeFieldContainer[_run_definition_pb2.TaskGroup] + sentinel: bool + def __init__(self, task_groups: _Optional[_Iterable[_Union[_run_definition_pb2.TaskGroup, _Mapping]]] = ..., sentinel: bool = ...) -> None: ... diff --git a/gen/python/flyteidl2/workflow/run_service_pb2_grpc.py b/gen/python/flyteidl2/workflow/run_service_pb2_grpc.py new file mode 100644 index 0000000000..b80eceb82c --- /dev/null +++ b/gen/python/flyteidl2/workflow/run_service_pb2_grpc.py @@ -0,0 +1,514 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from flyteidl2.workflow import run_service_pb2 as flyteidl2_dot_workflow_dot_run__service__pb2 + + +class RunServiceStub(object): + """RunService provides an interface for managing runs. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.CreateRun = channel.unary_unary( + '/flyteidl2.workflow.RunService/CreateRun', + request_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.CreateRunRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.CreateRunResponse.FromString, + ) + self.AbortRun = channel.unary_unary( + '/flyteidl2.workflow.RunService/AbortRun', + request_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.AbortRunRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.AbortRunResponse.FromString, + ) + self.GetRunDetails = channel.unary_unary( + '/flyteidl2.workflow.RunService/GetRunDetails', + request_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.GetRunDetailsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.GetRunDetailsResponse.FromString, + ) + self.WatchRunDetails = channel.unary_stream( + '/flyteidl2.workflow.RunService/WatchRunDetails', + request_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchRunDetailsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchRunDetailsResponse.FromString, + ) + self.GetActionDetails = channel.unary_unary( + '/flyteidl2.workflow.RunService/GetActionDetails', + request_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.GetActionDetailsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.GetActionDetailsResponse.FromString, + ) + self.WatchActionDetails = channel.unary_stream( + '/flyteidl2.workflow.RunService/WatchActionDetails', + request_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchActionDetailsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchActionDetailsResponse.FromString, + ) + self.GetActionData = channel.unary_unary( + '/flyteidl2.workflow.RunService/GetActionData', + request_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.GetActionDataRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.GetActionDataResponse.FromString, + ) + self.ListRuns = channel.unary_unary( + '/flyteidl2.workflow.RunService/ListRuns', + request_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.ListRunsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.ListRunsResponse.FromString, + ) + self.WatchRuns = channel.unary_stream( + '/flyteidl2.workflow.RunService/WatchRuns', + request_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchRunsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchRunsResponse.FromString, + ) + self.ListActions = channel.unary_unary( + '/flyteidl2.workflow.RunService/ListActions', + request_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.ListActionsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.ListActionsResponse.FromString, + ) + self.WatchActions = channel.unary_stream( + '/flyteidl2.workflow.RunService/WatchActions', + request_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchActionsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchActionsResponse.FromString, + ) + self.WatchClusterEvents = channel.unary_stream( + '/flyteidl2.workflow.RunService/WatchClusterEvents', + request_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchClusterEventsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchClusterEventsResponse.FromString, + ) + self.AbortAction = channel.unary_unary( + '/flyteidl2.workflow.RunService/AbortAction', + request_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.AbortActionRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.AbortActionResponse.FromString, + ) + self.WatchGroups = channel.unary_stream( + '/flyteidl2.workflow.RunService/WatchGroups', + request_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchGroupsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchGroupsResponse.FromString, + ) + + +class RunServiceServicer(object): + """RunService provides an interface for managing runs. + """ + + def CreateRun(self, request, context): + """Create a new run of the given task. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AbortRun(self, request, context): + """Abort a run. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetRunDetails(self, request, context): + """Get detailed information about a run. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def WatchRunDetails(self, request, context): + """Stream detailed information updates about a run. The call will terminate when the run reaches a terminal phase. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetActionDetails(self, request, context): + """Get detailed information about an action. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def WatchActionDetails(self, request, context): + """Stream detailed information updates about an action. The call will terminate when the action reaches a terminal phase. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetActionData(self, request, context): + """Get input and output for an action. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListRuns(self, request, context): + """List runs based on the provided filter criteria. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def WatchRuns(self, request, context): + """Stream updates for runs based on the provided filter criteria. Responses may include newly discovered + runs or updates to existing ones from the point of invocation. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListActions(self, request, context): + """List all actions for a given run. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def WatchActions(self, request, context): + """Stream updates for actions given a run. Responses may include newly discovered nested runs or updates + to existing ones from the point of invocation. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def WatchClusterEvents(self, request, context): + """Stream of k8s cluster events in human readable form + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AbortAction(self, request, context): + """AbortAction aborts a single action that was previously created or is currently being processed by a worker. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def WatchGroups(self, request, context): + """Stream updates for task groups based on the provided filter criteria. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_RunServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'CreateRun': grpc.unary_unary_rpc_method_handler( + servicer.CreateRun, + request_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.CreateRunRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.CreateRunResponse.SerializeToString, + ), + 'AbortRun': grpc.unary_unary_rpc_method_handler( + servicer.AbortRun, + request_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.AbortRunRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.AbortRunResponse.SerializeToString, + ), + 'GetRunDetails': grpc.unary_unary_rpc_method_handler( + servicer.GetRunDetails, + request_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.GetRunDetailsRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.GetRunDetailsResponse.SerializeToString, + ), + 'WatchRunDetails': grpc.unary_stream_rpc_method_handler( + servicer.WatchRunDetails, + request_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchRunDetailsRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchRunDetailsResponse.SerializeToString, + ), + 'GetActionDetails': grpc.unary_unary_rpc_method_handler( + servicer.GetActionDetails, + request_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.GetActionDetailsRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.GetActionDetailsResponse.SerializeToString, + ), + 'WatchActionDetails': grpc.unary_stream_rpc_method_handler( + servicer.WatchActionDetails, + request_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchActionDetailsRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchActionDetailsResponse.SerializeToString, + ), + 'GetActionData': grpc.unary_unary_rpc_method_handler( + servicer.GetActionData, + request_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.GetActionDataRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.GetActionDataResponse.SerializeToString, + ), + 'ListRuns': grpc.unary_unary_rpc_method_handler( + servicer.ListRuns, + request_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.ListRunsRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.ListRunsResponse.SerializeToString, + ), + 'WatchRuns': grpc.unary_stream_rpc_method_handler( + servicer.WatchRuns, + request_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchRunsRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchRunsResponse.SerializeToString, + ), + 'ListActions': grpc.unary_unary_rpc_method_handler( + servicer.ListActions, + request_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.ListActionsRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.ListActionsResponse.SerializeToString, + ), + 'WatchActions': grpc.unary_stream_rpc_method_handler( + servicer.WatchActions, + request_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchActionsRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchActionsResponse.SerializeToString, + ), + 'WatchClusterEvents': grpc.unary_stream_rpc_method_handler( + servicer.WatchClusterEvents, + request_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchClusterEventsRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchClusterEventsResponse.SerializeToString, + ), + 'AbortAction': grpc.unary_unary_rpc_method_handler( + servicer.AbortAction, + request_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.AbortActionRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.AbortActionResponse.SerializeToString, + ), + 'WatchGroups': grpc.unary_stream_rpc_method_handler( + servicer.WatchGroups, + request_deserializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchGroupsRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_run__service__pb2.WatchGroupsResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.workflow.RunService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class RunService(object): + """RunService provides an interface for managing runs. + """ + + @staticmethod + def CreateRun(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.workflow.RunService/CreateRun', + flyteidl2_dot_workflow_dot_run__service__pb2.CreateRunRequest.SerializeToString, + flyteidl2_dot_workflow_dot_run__service__pb2.CreateRunResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def AbortRun(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.workflow.RunService/AbortRun', + flyteidl2_dot_workflow_dot_run__service__pb2.AbortRunRequest.SerializeToString, + flyteidl2_dot_workflow_dot_run__service__pb2.AbortRunResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetRunDetails(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.workflow.RunService/GetRunDetails', + flyteidl2_dot_workflow_dot_run__service__pb2.GetRunDetailsRequest.SerializeToString, + flyteidl2_dot_workflow_dot_run__service__pb2.GetRunDetailsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def WatchRunDetails(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream(request, target, '/flyteidl2.workflow.RunService/WatchRunDetails', + flyteidl2_dot_workflow_dot_run__service__pb2.WatchRunDetailsRequest.SerializeToString, + flyteidl2_dot_workflow_dot_run__service__pb2.WatchRunDetailsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetActionDetails(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.workflow.RunService/GetActionDetails', + flyteidl2_dot_workflow_dot_run__service__pb2.GetActionDetailsRequest.SerializeToString, + flyteidl2_dot_workflow_dot_run__service__pb2.GetActionDetailsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def WatchActionDetails(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream(request, target, '/flyteidl2.workflow.RunService/WatchActionDetails', + flyteidl2_dot_workflow_dot_run__service__pb2.WatchActionDetailsRequest.SerializeToString, + flyteidl2_dot_workflow_dot_run__service__pb2.WatchActionDetailsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetActionData(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.workflow.RunService/GetActionData', + flyteidl2_dot_workflow_dot_run__service__pb2.GetActionDataRequest.SerializeToString, + flyteidl2_dot_workflow_dot_run__service__pb2.GetActionDataResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListRuns(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.workflow.RunService/ListRuns', + flyteidl2_dot_workflow_dot_run__service__pb2.ListRunsRequest.SerializeToString, + flyteidl2_dot_workflow_dot_run__service__pb2.ListRunsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def WatchRuns(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream(request, target, '/flyteidl2.workflow.RunService/WatchRuns', + flyteidl2_dot_workflow_dot_run__service__pb2.WatchRunsRequest.SerializeToString, + flyteidl2_dot_workflow_dot_run__service__pb2.WatchRunsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListActions(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.workflow.RunService/ListActions', + flyteidl2_dot_workflow_dot_run__service__pb2.ListActionsRequest.SerializeToString, + flyteidl2_dot_workflow_dot_run__service__pb2.ListActionsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def WatchActions(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream(request, target, '/flyteidl2.workflow.RunService/WatchActions', + flyteidl2_dot_workflow_dot_run__service__pb2.WatchActionsRequest.SerializeToString, + flyteidl2_dot_workflow_dot_run__service__pb2.WatchActionsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def WatchClusterEvents(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream(request, target, '/flyteidl2.workflow.RunService/WatchClusterEvents', + flyteidl2_dot_workflow_dot_run__service__pb2.WatchClusterEventsRequest.SerializeToString, + flyteidl2_dot_workflow_dot_run__service__pb2.WatchClusterEventsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def AbortAction(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.workflow.RunService/AbortAction', + flyteidl2_dot_workflow_dot_run__service__pb2.AbortActionRequest.SerializeToString, + flyteidl2_dot_workflow_dot_run__service__pb2.AbortActionResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def WatchGroups(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream(request, target, '/flyteidl2.workflow.RunService/WatchGroups', + flyteidl2_dot_workflow_dot_run__service__pb2.WatchGroupsRequest.SerializeToString, + flyteidl2_dot_workflow_dot_run__service__pb2.WatchGroupsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/gen/python/flyteidl2/workflow/state_service_pb2.py b/gen/python/flyteidl2/workflow/state_service_pb2.py new file mode 100644 index 0000000000..9b27028db5 --- /dev/null +++ b/gen/python/flyteidl2/workflow/state_service_pb2.py @@ -0,0 +1,67 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/workflow/state_service.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 +from flyteidl2.common import identifier_pb2 as flyteidl2_dot_common_dot_identifier__pb2 +from flyteidl2.common import phase_pb2 as flyteidl2_dot_common_dot_phase__pb2 +from flyteidl2.core import execution_pb2 as flyteidl2_dot_core_dot_execution__pb2 +from google.rpc import status_pb2 as google_dot_rpc_dot_status__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n&flyteidl2/workflow/state_service.proto\x12\x12\x66lyteidl2.workflow\x1a\x1b\x62uf/validate/validate.proto\x1a!flyteidl2/common/identifier.proto\x1a\x1c\x66lyteidl2/common/phase.proto\x1a\x1e\x66lyteidl2/core/execution.proto\x1a\x17google/rpc/status.proto\"\xbe\x01\n\nPutRequest\x12G\n\taction_id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x08\x61\x63tionId\x12\x31\n\x12parent_action_name\x18\x02 \x01(\tH\x00R\x10parentActionName\x88\x01\x01\x12\x1d\n\x05state\x18\x03 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x05stateB\x15\n\x13_parent_action_name\"\x8a\x01\n\x0bPutResponse\x12G\n\taction_id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x08\x61\x63tionId\x12\x32\n\x06status\x18\x02 \x01(\x0b\x32\x12.google.rpc.StatusB\x06\xbaH\x03\xc8\x01\x01R\x06status\"U\n\nGetRequest\x12G\n\taction_id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x08\x61\x63tionId\"\xa9\x01\n\x0bGetResponse\x12G\n\taction_id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x08\x61\x63tionId\x12\x32\n\x06status\x18\x02 \x01(\x0b\x32\x12.google.rpc.StatusB\x06\xbaH\x03\xc8\x01\x01R\x06status\x12\x1d\n\x05state\x18\x03 \x01(\tB\x07\xbaH\x04r\x02\x10\x01R\x05state\"o\n\x0cWatchRequest\x12N\n\x10parent_action_id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierH\x00R\x0eparentActionIdB\x0f\n\x06\x66ilter\x12\x05\xbaH\x02\x08\x01\"\xb2\x01\n\rWatchResponse\x12G\n\raction_update\x18\x01 \x01(\x0b\x32 .flyteidl2.workflow.ActionUpdateH\x00R\x0c\x61\x63tionUpdate\x12M\n\x0f\x63ontrol_message\x18\x02 \x01(\x0b\x32\".flyteidl2.workflow.ControlMessageH\x00R\x0e\x63ontrolMessageB\t\n\x07message\",\n\x0e\x43ontrolMessage\x12\x1a\n\x08sentinel\x18\x01 \x01(\x08R\x08sentinel\"\xf0\x01\n\x0c\x41\x63tionUpdate\x12G\n\taction_id\x18\x01 \x01(\x0b\x32\".flyteidl2.common.ActionIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x08\x61\x63tionId\x12\x33\n\x05phase\x18\x02 \x01(\x0e\x32\x1d.flyteidl2.common.ActionPhaseR\x05phase\x12\x39\n\x05\x65rror\x18\x03 \x01(\x0b\x32\x1e.flyteidl2.core.ExecutionErrorH\x00R\x05\x65rror\x88\x01\x01\x12\x1d\n\noutput_uri\x18\x04 \x01(\tR\toutputUriB\x08\n\x06_error2\xf4\x01\n\x0cStateService\x12H\n\x03Put\x12\x1e.flyteidl2.workflow.PutRequest\x1a\x1f.flyteidl2.workflow.PutResponse\"\x00\x12H\n\x03Get\x12\x1e.flyteidl2.workflow.GetRequest\x1a\x1f.flyteidl2.workflow.GetResponse\"\x00\x12P\n\x05Watch\x12 .flyteidl2.workflow.WatchRequest\x1a!.flyteidl2.workflow.WatchResponse\"\x00\x30\x01\x42\xce\x01\n\x16\x63om.flyteidl2.workflowB\x11StateServiceProtoH\x02P\x01Z6github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow\xa2\x02\x03\x46WX\xaa\x02\x12\x46lyteidl2.Workflow\xca\x02\x12\x46lyteidl2\\Workflow\xe2\x02\x1e\x46lyteidl2\\Workflow\\GPBMetadata\xea\x02\x13\x46lyteidl2::Workflowb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.workflow.state_service_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\026com.flyteidl2.workflowB\021StateServiceProtoH\002P\001Z6github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow\242\002\003FWX\252\002\022Flyteidl2.Workflow\312\002\022Flyteidl2\\Workflow\342\002\036Flyteidl2\\Workflow\\GPBMetadata\352\002\023Flyteidl2::Workflow' + _PUTREQUEST.fields_by_name['action_id']._options = None + _PUTREQUEST.fields_by_name['action_id']._serialized_options = b'\272H\003\310\001\001' + _PUTREQUEST.fields_by_name['state']._options = None + _PUTREQUEST.fields_by_name['state']._serialized_options = b'\272H\004r\002\020\001' + _PUTRESPONSE.fields_by_name['action_id']._options = None + _PUTRESPONSE.fields_by_name['action_id']._serialized_options = b'\272H\003\310\001\001' + _PUTRESPONSE.fields_by_name['status']._options = None + _PUTRESPONSE.fields_by_name['status']._serialized_options = b'\272H\003\310\001\001' + _GETREQUEST.fields_by_name['action_id']._options = None + _GETREQUEST.fields_by_name['action_id']._serialized_options = b'\272H\003\310\001\001' + _GETRESPONSE.fields_by_name['action_id']._options = None + _GETRESPONSE.fields_by_name['action_id']._serialized_options = b'\272H\003\310\001\001' + _GETRESPONSE.fields_by_name['status']._options = None + _GETRESPONSE.fields_by_name['status']._serialized_options = b'\272H\003\310\001\001' + _GETRESPONSE.fields_by_name['state']._options = None + _GETRESPONSE.fields_by_name['state']._serialized_options = b'\272H\004r\002\020\001' + _WATCHREQUEST.oneofs_by_name['filter']._options = None + _WATCHREQUEST.oneofs_by_name['filter']._serialized_options = b'\272H\002\010\001' + _ACTIONUPDATE.fields_by_name['action_id']._options = None + _ACTIONUPDATE.fields_by_name['action_id']._serialized_options = b'\272H\003\310\001\001' + _globals['_PUTREQUEST']._serialized_start=214 + _globals['_PUTREQUEST']._serialized_end=404 + _globals['_PUTRESPONSE']._serialized_start=407 + _globals['_PUTRESPONSE']._serialized_end=545 + _globals['_GETREQUEST']._serialized_start=547 + _globals['_GETREQUEST']._serialized_end=632 + _globals['_GETRESPONSE']._serialized_start=635 + _globals['_GETRESPONSE']._serialized_end=804 + _globals['_WATCHREQUEST']._serialized_start=806 + _globals['_WATCHREQUEST']._serialized_end=917 + _globals['_WATCHRESPONSE']._serialized_start=920 + _globals['_WATCHRESPONSE']._serialized_end=1098 + _globals['_CONTROLMESSAGE']._serialized_start=1100 + _globals['_CONTROLMESSAGE']._serialized_end=1144 + _globals['_ACTIONUPDATE']._serialized_start=1147 + _globals['_ACTIONUPDATE']._serialized_end=1387 + _globals['_STATESERVICE']._serialized_start=1390 + _globals['_STATESERVICE']._serialized_end=1634 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/workflow/state_service_pb2.pyi b/gen/python/flyteidl2/workflow/state_service_pb2.pyi new file mode 100644 index 0000000000..0205b1ca8b --- /dev/null +++ b/gen/python/flyteidl2/workflow/state_service_pb2.pyi @@ -0,0 +1,76 @@ +from buf.validate import validate_pb2 as _validate_pb2 +from flyteidl2.common import identifier_pb2 as _identifier_pb2 +from flyteidl2.common import phase_pb2 as _phase_pb2 +from flyteidl2.core import execution_pb2 as _execution_pb2 +from google.rpc import status_pb2 as _status_pb2 +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class PutRequest(_message.Message): + __slots__ = ["action_id", "parent_action_name", "state"] + ACTION_ID_FIELD_NUMBER: _ClassVar[int] + PARENT_ACTION_NAME_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + action_id: _identifier_pb2.ActionIdentifier + parent_action_name: str + state: str + def __init__(self, action_id: _Optional[_Union[_identifier_pb2.ActionIdentifier, _Mapping]] = ..., parent_action_name: _Optional[str] = ..., state: _Optional[str] = ...) -> None: ... + +class PutResponse(_message.Message): + __slots__ = ["action_id", "status"] + ACTION_ID_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + action_id: _identifier_pb2.ActionIdentifier + status: _status_pb2.Status + def __init__(self, action_id: _Optional[_Union[_identifier_pb2.ActionIdentifier, _Mapping]] = ..., status: _Optional[_Union[_status_pb2.Status, _Mapping]] = ...) -> None: ... + +class GetRequest(_message.Message): + __slots__ = ["action_id"] + ACTION_ID_FIELD_NUMBER: _ClassVar[int] + action_id: _identifier_pb2.ActionIdentifier + def __init__(self, action_id: _Optional[_Union[_identifier_pb2.ActionIdentifier, _Mapping]] = ...) -> None: ... + +class GetResponse(_message.Message): + __slots__ = ["action_id", "status", "state"] + ACTION_ID_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + action_id: _identifier_pb2.ActionIdentifier + status: _status_pb2.Status + state: str + def __init__(self, action_id: _Optional[_Union[_identifier_pb2.ActionIdentifier, _Mapping]] = ..., status: _Optional[_Union[_status_pb2.Status, _Mapping]] = ..., state: _Optional[str] = ...) -> None: ... + +class WatchRequest(_message.Message): + __slots__ = ["parent_action_id"] + PARENT_ACTION_ID_FIELD_NUMBER: _ClassVar[int] + parent_action_id: _identifier_pb2.ActionIdentifier + def __init__(self, parent_action_id: _Optional[_Union[_identifier_pb2.ActionIdentifier, _Mapping]] = ...) -> None: ... + +class WatchResponse(_message.Message): + __slots__ = ["action_update", "control_message"] + ACTION_UPDATE_FIELD_NUMBER: _ClassVar[int] + CONTROL_MESSAGE_FIELD_NUMBER: _ClassVar[int] + action_update: ActionUpdate + control_message: ControlMessage + def __init__(self, action_update: _Optional[_Union[ActionUpdate, _Mapping]] = ..., control_message: _Optional[_Union[ControlMessage, _Mapping]] = ...) -> None: ... + +class ControlMessage(_message.Message): + __slots__ = ["sentinel"] + SENTINEL_FIELD_NUMBER: _ClassVar[int] + sentinel: bool + def __init__(self, sentinel: bool = ...) -> None: ... + +class ActionUpdate(_message.Message): + __slots__ = ["action_id", "phase", "error", "output_uri"] + ACTION_ID_FIELD_NUMBER: _ClassVar[int] + PHASE_FIELD_NUMBER: _ClassVar[int] + ERROR_FIELD_NUMBER: _ClassVar[int] + OUTPUT_URI_FIELD_NUMBER: _ClassVar[int] + action_id: _identifier_pb2.ActionIdentifier + phase: _phase_pb2.ActionPhase + error: _execution_pb2.ExecutionError + output_uri: str + def __init__(self, action_id: _Optional[_Union[_identifier_pb2.ActionIdentifier, _Mapping]] = ..., phase: _Optional[_Union[_phase_pb2.ActionPhase, str]] = ..., error: _Optional[_Union[_execution_pb2.ExecutionError, _Mapping]] = ..., output_uri: _Optional[str] = ...) -> None: ... diff --git a/gen/python/flyteidl2/workflow/state_service_pb2_grpc.py b/gen/python/flyteidl2/workflow/state_service_pb2_grpc.py new file mode 100644 index 0000000000..060f985c38 --- /dev/null +++ b/gen/python/flyteidl2/workflow/state_service_pb2_grpc.py @@ -0,0 +1,138 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from flyteidl2.workflow import state_service_pb2 as flyteidl2_dot_workflow_dot_state__service__pb2 + + +class StateServiceStub(object): + """provides an interface for managing the state of actions. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.Put = channel.unary_unary( + '/flyteidl2.workflow.StateService/Put', + request_serializer=flyteidl2_dot_workflow_dot_state__service__pb2.PutRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_state__service__pb2.PutResponse.FromString, + ) + self.Get = channel.unary_unary( + '/flyteidl2.workflow.StateService/Get', + request_serializer=flyteidl2_dot_workflow_dot_state__service__pb2.GetRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_state__service__pb2.GetResponse.FromString, + ) + self.Watch = channel.unary_stream( + '/flyteidl2.workflow.StateService/Watch', + request_serializer=flyteidl2_dot_workflow_dot_state__service__pb2.WatchRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_state__service__pb2.WatchResponse.FromString, + ) + + +class StateServiceServicer(object): + """provides an interface for managing the state of actions. + """ + + def Put(self, request, context): + """put the state of an action. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Get(self, request, context): + """get the state of an action. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Watch(self, request, context): + """watch for updates to the state of actions. this api guarantees at-least-once delivery semantics. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_StateServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'Put': grpc.unary_unary_rpc_method_handler( + servicer.Put, + request_deserializer=flyteidl2_dot_workflow_dot_state__service__pb2.PutRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_state__service__pb2.PutResponse.SerializeToString, + ), + 'Get': grpc.unary_unary_rpc_method_handler( + servicer.Get, + request_deserializer=flyteidl2_dot_workflow_dot_state__service__pb2.GetRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_state__service__pb2.GetResponse.SerializeToString, + ), + 'Watch': grpc.unary_stream_rpc_method_handler( + servicer.Watch, + request_deserializer=flyteidl2_dot_workflow_dot_state__service__pb2.WatchRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_state__service__pb2.WatchResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.workflow.StateService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class StateService(object): + """provides an interface for managing the state of actions. + """ + + @staticmethod + def Put(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.workflow.StateService/Put', + flyteidl2_dot_workflow_dot_state__service__pb2.PutRequest.SerializeToString, + flyteidl2_dot_workflow_dot_state__service__pb2.PutResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Get(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.workflow.StateService/Get', + flyteidl2_dot_workflow_dot_state__service__pb2.GetRequest.SerializeToString, + flyteidl2_dot_workflow_dot_state__service__pb2.GetResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Watch(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream(request, target, '/flyteidl2.workflow.StateService/Watch', + flyteidl2_dot_workflow_dot_state__service__pb2.WatchRequest.SerializeToString, + flyteidl2_dot_workflow_dot_state__service__pb2.WatchResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/gen/python/flyteidl2/workflow/translator_service_pb2.py b/gen/python/flyteidl2/workflow/translator_service_pb2.py new file mode 100644 index 0000000000..de5a0bfdb9 --- /dev/null +++ b/gen/python/flyteidl2/workflow/translator_service_pb2.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: flyteidl2/workflow/translator_service.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from flyteidl2.core import interface_pb2 as flyteidl2_dot_core_dot_interface__pb2 +from flyteidl2.task import common_pb2 as flyteidl2_dot_task_dot_common__pb2 +from flyteidl2.task import task_definition_pb2 as flyteidl2_dot_task_dot_task__definition__pb2 +from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n+flyteidl2/workflow/translator_service.proto\x12\x12\x66lyteidl2.workflow\x1a\x1e\x66lyteidl2/core/interface.proto\x1a\x1b\x66lyteidl2/task/common.proto\x1a$flyteidl2/task/task_definition.proto\x1a\x1cgoogle/protobuf/struct.proto\"\x96\x01\n\x1fLiteralsToLaunchFormJsonRequest\x12\x38\n\x08literals\x18\x01 \x03(\x0b\x32\x1c.flyteidl2.task.NamedLiteralR\x08literals\x12\x39\n\tvariables\x18\x02 \x01(\x0b\x32\x1b.flyteidl2.core.VariableMapR\tvariables\"O\n LiteralsToLaunchFormJsonResponse\x12+\n\x04json\x18\x01 \x01(\x0b\x32\x17.google.protobuf.StructR\x04json\"N\n\x1fLaunchFormJsonToLiteralsRequest\x12+\n\x04json\x18\x01 \x01(\x0b\x32\x17.google.protobuf.StructR\x04json\"\\\n LaunchFormJsonToLiteralsResponse\x12\x38\n\x08literals\x18\x01 \x03(\x0b\x32\x1c.flyteidl2.task.NamedLiteralR\x08literals\"X\n\x1fTaskSpecToLaunchFormJsonRequest\x12\x35\n\ttask_spec\x18\x01 \x01(\x0b\x32\x18.flyteidl2.task.TaskSpecR\x08taskSpec\"O\n TaskSpecToLaunchFormJsonResponse\x12+\n\x04json\x18\x01 \x01(\x0b\x32\x17.google.protobuf.StructR\x04json\"\x89\x01\n\x1bJsonValuesToLiteralsRequest\x12\x39\n\tvariables\x18\x01 \x01(\x0b\x32\x1b.flyteidl2.core.VariableMapR\tvariables\x12/\n\x06values\x18\x02 \x01(\x0b\x32\x17.google.protobuf.StructR\x06values\"X\n\x1cJsonValuesToLiteralsResponse\x12\x38\n\x08literals\x18\x01 \x03(\x0b\x32\x1c.flyteidl2.task.NamedLiteralR\x08literals2\xba\x04\n\x11TranslatorService\x12\x8a\x01\n\x18LiteralsToLaunchFormJson\x12\x33.flyteidl2.workflow.LiteralsToLaunchFormJsonRequest\x1a\x34.flyteidl2.workflow.LiteralsToLaunchFormJsonResponse\"\x03\x90\x02\x01\x12\x8a\x01\n\x18LaunchFormJsonToLiterals\x12\x33.flyteidl2.workflow.LaunchFormJsonToLiteralsRequest\x1a\x34.flyteidl2.workflow.LaunchFormJsonToLiteralsResponse\"\x03\x90\x02\x01\x12\x8a\x01\n\x18TaskSpecToLaunchFormJson\x12\x33.flyteidl2.workflow.TaskSpecToLaunchFormJsonRequest\x1a\x34.flyteidl2.workflow.TaskSpecToLaunchFormJsonResponse\"\x03\x90\x02\x01\x12~\n\x14JsonValuesToLiterals\x12/.flyteidl2.workflow.JsonValuesToLiteralsRequest\x1a\x30.flyteidl2.workflow.JsonValuesToLiteralsResponse\"\x03\x90\x02\x01\x42\xd3\x01\n\x16\x63om.flyteidl2.workflowB\x16TranslatorServiceProtoH\x02P\x01Z6github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow\xa2\x02\x03\x46WX\xaa\x02\x12\x46lyteidl2.Workflow\xca\x02\x12\x46lyteidl2\\Workflow\xe2\x02\x1e\x46lyteidl2\\Workflow\\GPBMetadata\xea\x02\x13\x46lyteidl2::Workflowb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flyteidl2.workflow.translator_service_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\026com.flyteidl2.workflowB\026TranslatorServiceProtoH\002P\001Z6github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow\242\002\003FWX\252\002\022Flyteidl2.Workflow\312\002\022Flyteidl2\\Workflow\342\002\036Flyteidl2\\Workflow\\GPBMetadata\352\002\023Flyteidl2::Workflow' + _TRANSLATORSERVICE.methods_by_name['LiteralsToLaunchFormJson']._options = None + _TRANSLATORSERVICE.methods_by_name['LiteralsToLaunchFormJson']._serialized_options = b'\220\002\001' + _TRANSLATORSERVICE.methods_by_name['LaunchFormJsonToLiterals']._options = None + _TRANSLATORSERVICE.methods_by_name['LaunchFormJsonToLiterals']._serialized_options = b'\220\002\001' + _TRANSLATORSERVICE.methods_by_name['TaskSpecToLaunchFormJson']._options = None + _TRANSLATORSERVICE.methods_by_name['TaskSpecToLaunchFormJson']._serialized_options = b'\220\002\001' + _TRANSLATORSERVICE.methods_by_name['JsonValuesToLiterals']._options = None + _TRANSLATORSERVICE.methods_by_name['JsonValuesToLiterals']._serialized_options = b'\220\002\001' + _globals['_LITERALSTOLAUNCHFORMJSONREQUEST']._serialized_start=197 + _globals['_LITERALSTOLAUNCHFORMJSONREQUEST']._serialized_end=347 + _globals['_LITERALSTOLAUNCHFORMJSONRESPONSE']._serialized_start=349 + _globals['_LITERALSTOLAUNCHFORMJSONRESPONSE']._serialized_end=428 + _globals['_LAUNCHFORMJSONTOLITERALSREQUEST']._serialized_start=430 + _globals['_LAUNCHFORMJSONTOLITERALSREQUEST']._serialized_end=508 + _globals['_LAUNCHFORMJSONTOLITERALSRESPONSE']._serialized_start=510 + _globals['_LAUNCHFORMJSONTOLITERALSRESPONSE']._serialized_end=602 + _globals['_TASKSPECTOLAUNCHFORMJSONREQUEST']._serialized_start=604 + _globals['_TASKSPECTOLAUNCHFORMJSONREQUEST']._serialized_end=692 + _globals['_TASKSPECTOLAUNCHFORMJSONRESPONSE']._serialized_start=694 + _globals['_TASKSPECTOLAUNCHFORMJSONRESPONSE']._serialized_end=773 + _globals['_JSONVALUESTOLITERALSREQUEST']._serialized_start=776 + _globals['_JSONVALUESTOLITERALSREQUEST']._serialized_end=913 + _globals['_JSONVALUESTOLITERALSRESPONSE']._serialized_start=915 + _globals['_JSONVALUESTOLITERALSRESPONSE']._serialized_end=1003 + _globals['_TRANSLATORSERVICE']._serialized_start=1006 + _globals['_TRANSLATORSERVICE']._serialized_end=1576 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/flyteidl2/workflow/translator_service_pb2.pyi b/gen/python/flyteidl2/workflow/translator_service_pb2.pyi new file mode 100644 index 0000000000..ca66e13d8d --- /dev/null +++ b/gen/python/flyteidl2/workflow/translator_service_pb2.pyi @@ -0,0 +1,62 @@ +from flyteidl2.core import interface_pb2 as _interface_pb2 +from flyteidl2.task import common_pb2 as _common_pb2 +from flyteidl2.task import task_definition_pb2 as _task_definition_pb2 +from google.protobuf import struct_pb2 as _struct_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class LiteralsToLaunchFormJsonRequest(_message.Message): + __slots__ = ["literals", "variables"] + LITERALS_FIELD_NUMBER: _ClassVar[int] + VARIABLES_FIELD_NUMBER: _ClassVar[int] + literals: _containers.RepeatedCompositeFieldContainer[_common_pb2.NamedLiteral] + variables: _interface_pb2.VariableMap + def __init__(self, literals: _Optional[_Iterable[_Union[_common_pb2.NamedLiteral, _Mapping]]] = ..., variables: _Optional[_Union[_interface_pb2.VariableMap, _Mapping]] = ...) -> None: ... + +class LiteralsToLaunchFormJsonResponse(_message.Message): + __slots__ = ["json"] + JSON_FIELD_NUMBER: _ClassVar[int] + json: _struct_pb2.Struct + def __init__(self, json: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ... + +class LaunchFormJsonToLiteralsRequest(_message.Message): + __slots__ = ["json"] + JSON_FIELD_NUMBER: _ClassVar[int] + json: _struct_pb2.Struct + def __init__(self, json: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ... + +class LaunchFormJsonToLiteralsResponse(_message.Message): + __slots__ = ["literals"] + LITERALS_FIELD_NUMBER: _ClassVar[int] + literals: _containers.RepeatedCompositeFieldContainer[_common_pb2.NamedLiteral] + def __init__(self, literals: _Optional[_Iterable[_Union[_common_pb2.NamedLiteral, _Mapping]]] = ...) -> None: ... + +class TaskSpecToLaunchFormJsonRequest(_message.Message): + __slots__ = ["task_spec"] + TASK_SPEC_FIELD_NUMBER: _ClassVar[int] + task_spec: _task_definition_pb2.TaskSpec + def __init__(self, task_spec: _Optional[_Union[_task_definition_pb2.TaskSpec, _Mapping]] = ...) -> None: ... + +class TaskSpecToLaunchFormJsonResponse(_message.Message): + __slots__ = ["json"] + JSON_FIELD_NUMBER: _ClassVar[int] + json: _struct_pb2.Struct + def __init__(self, json: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ... + +class JsonValuesToLiteralsRequest(_message.Message): + __slots__ = ["variables", "values"] + VARIABLES_FIELD_NUMBER: _ClassVar[int] + VALUES_FIELD_NUMBER: _ClassVar[int] + variables: _interface_pb2.VariableMap + values: _struct_pb2.Struct + def __init__(self, variables: _Optional[_Union[_interface_pb2.VariableMap, _Mapping]] = ..., values: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ...) -> None: ... + +class JsonValuesToLiteralsResponse(_message.Message): + __slots__ = ["literals"] + LITERALS_FIELD_NUMBER: _ClassVar[int] + literals: _containers.RepeatedCompositeFieldContainer[_common_pb2.NamedLiteral] + def __init__(self, literals: _Optional[_Iterable[_Union[_common_pb2.NamedLiteral, _Mapping]]] = ...) -> None: ... diff --git a/gen/python/flyteidl2/workflow/translator_service_pb2_grpc.py b/gen/python/flyteidl2/workflow/translator_service_pb2_grpc.py new file mode 100644 index 0000000000..fa33e75d88 --- /dev/null +++ b/gen/python/flyteidl2/workflow/translator_service_pb2_grpc.py @@ -0,0 +1,168 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from flyteidl2.workflow import translator_service_pb2 as flyteidl2_dot_workflow_dot_translator__service__pb2 + + +class TranslatorServiceStub(object): + """TranslatorService provides an interface for all diferent types of translations for the platform. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.LiteralsToLaunchFormJson = channel.unary_unary( + '/flyteidl2.workflow.TranslatorService/LiteralsToLaunchFormJson', + request_serializer=flyteidl2_dot_workflow_dot_translator__service__pb2.LiteralsToLaunchFormJsonRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_translator__service__pb2.LiteralsToLaunchFormJsonResponse.FromString, + ) + self.LaunchFormJsonToLiterals = channel.unary_unary( + '/flyteidl2.workflow.TranslatorService/LaunchFormJsonToLiterals', + request_serializer=flyteidl2_dot_workflow_dot_translator__service__pb2.LaunchFormJsonToLiteralsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_translator__service__pb2.LaunchFormJsonToLiteralsResponse.FromString, + ) + self.TaskSpecToLaunchFormJson = channel.unary_unary( + '/flyteidl2.workflow.TranslatorService/TaskSpecToLaunchFormJson', + request_serializer=flyteidl2_dot_workflow_dot_translator__service__pb2.TaskSpecToLaunchFormJsonRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_translator__service__pb2.TaskSpecToLaunchFormJsonResponse.FromString, + ) + self.JsonValuesToLiterals = channel.unary_unary( + '/flyteidl2.workflow.TranslatorService/JsonValuesToLiterals', + request_serializer=flyteidl2_dot_workflow_dot_translator__service__pb2.JsonValuesToLiteralsRequest.SerializeToString, + response_deserializer=flyteidl2_dot_workflow_dot_translator__service__pb2.JsonValuesToLiteralsResponse.FromString, + ) + + +class TranslatorServiceServicer(object): + """TranslatorService provides an interface for all diferent types of translations for the platform. + """ + + def LiteralsToLaunchFormJson(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def LaunchFormJsonToLiterals(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def TaskSpecToLaunchFormJson(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def JsonValuesToLiterals(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_TranslatorServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'LiteralsToLaunchFormJson': grpc.unary_unary_rpc_method_handler( + servicer.LiteralsToLaunchFormJson, + request_deserializer=flyteidl2_dot_workflow_dot_translator__service__pb2.LiteralsToLaunchFormJsonRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_translator__service__pb2.LiteralsToLaunchFormJsonResponse.SerializeToString, + ), + 'LaunchFormJsonToLiterals': grpc.unary_unary_rpc_method_handler( + servicer.LaunchFormJsonToLiterals, + request_deserializer=flyteidl2_dot_workflow_dot_translator__service__pb2.LaunchFormJsonToLiteralsRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_translator__service__pb2.LaunchFormJsonToLiteralsResponse.SerializeToString, + ), + 'TaskSpecToLaunchFormJson': grpc.unary_unary_rpc_method_handler( + servicer.TaskSpecToLaunchFormJson, + request_deserializer=flyteidl2_dot_workflow_dot_translator__service__pb2.TaskSpecToLaunchFormJsonRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_translator__service__pb2.TaskSpecToLaunchFormJsonResponse.SerializeToString, + ), + 'JsonValuesToLiterals': grpc.unary_unary_rpc_method_handler( + servicer.JsonValuesToLiterals, + request_deserializer=flyteidl2_dot_workflow_dot_translator__service__pb2.JsonValuesToLiteralsRequest.FromString, + response_serializer=flyteidl2_dot_workflow_dot_translator__service__pb2.JsonValuesToLiteralsResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'flyteidl2.workflow.TranslatorService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class TranslatorService(object): + """TranslatorService provides an interface for all diferent types of translations for the platform. + """ + + @staticmethod + def LiteralsToLaunchFormJson(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.workflow.TranslatorService/LiteralsToLaunchFormJson', + flyteidl2_dot_workflow_dot_translator__service__pb2.LiteralsToLaunchFormJsonRequest.SerializeToString, + flyteidl2_dot_workflow_dot_translator__service__pb2.LiteralsToLaunchFormJsonResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def LaunchFormJsonToLiterals(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.workflow.TranslatorService/LaunchFormJsonToLiterals', + flyteidl2_dot_workflow_dot_translator__service__pb2.LaunchFormJsonToLiteralsRequest.SerializeToString, + flyteidl2_dot_workflow_dot_translator__service__pb2.LaunchFormJsonToLiteralsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def TaskSpecToLaunchFormJson(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.workflow.TranslatorService/TaskSpecToLaunchFormJson', + flyteidl2_dot_workflow_dot_translator__service__pb2.TaskSpecToLaunchFormJsonRequest.SerializeToString, + flyteidl2_dot_workflow_dot_translator__service__pb2.TaskSpecToLaunchFormJsonResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def JsonValuesToLiterals(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/flyteidl2.workflow.TranslatorService/JsonValuesToLiterals', + flyteidl2_dot_workflow_dot_translator__service__pb2.JsonValuesToLiteralsRequest.SerializeToString, + flyteidl2_dot_workflow_dot_translator__service__pb2.JsonValuesToLiteralsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/gen/python/google/__init__.py b/gen/python/google/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/google/api/__init__.py b/gen/python/google/api/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/google/api/annotations_pb2.py b/gen/python/google/api/annotations_pb2.py new file mode 100644 index 0000000000..a3d8bed030 --- /dev/null +++ b/gen/python/google/api/annotations_pb2.py @@ -0,0 +1,26 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/api/annotations.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.api import http_pb2 as google_dot_api_dot_http__pb2 +from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1cgoogle/api/annotations.proto\x12\ngoogle.api\x1a\x15google/api/http.proto\x1a google/protobuf/descriptor.proto:K\n\x04http\x12\x1e.google.protobuf.MethodOptions\x18\xb0\xca\xbc\" \x01(\x0b\x32\x14.google.api.HttpRuleR\x04httpB\xb0\x01\n\x0e\x63om.google.apiB\x10\x41nnotationsProtoH\x02P\x01ZAgoogle.golang.org/genproto/googleapis/api/annotations;annotations\xa2\x02\x03GAX\xaa\x02\nGoogle.Api\xca\x02\nGoogle\\Api\xe2\x02\x16Google\\Api\\GPBMetadata\xea\x02\x0bGoogle::Apib\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.api.annotations_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\016com.google.apiB\020AnnotationsProtoH\002P\001ZAgoogle.golang.org/genproto/googleapis/api/annotations;annotations\242\002\003GAX\252\002\nGoogle.Api\312\002\nGoogle\\Api\342\002\026Google\\Api\\GPBMetadata\352\002\013Google::Api' +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/google/api/annotations_pb2.pyi b/gen/python/google/api/annotations_pb2.pyi new file mode 100644 index 0000000000..b818f1809c --- /dev/null +++ b/gen/python/google/api/annotations_pb2.pyi @@ -0,0 +1,8 @@ +from google.api import http_pb2 as _http_pb2 +from google.protobuf import descriptor_pb2 as _descriptor_pb2 +from google.protobuf import descriptor as _descriptor +from typing import ClassVar as _ClassVar + +DESCRIPTOR: _descriptor.FileDescriptor +HTTP_FIELD_NUMBER: _ClassVar[int] +http: _descriptor.FieldDescriptor diff --git a/gen/python/google/api/annotations_pb2_grpc.py b/gen/python/google/api/annotations_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/google/api/annotations_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/google/api/http_pb2.py b/gen/python/google/api/http_pb2.py new file mode 100644 index 0000000000..0c304dbbca --- /dev/null +++ b/gen/python/google/api/http_pb2.py @@ -0,0 +1,30 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/api/http.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x15google/api/http.proto\x12\ngoogle.api\"y\n\x04Http\x12*\n\x05rules\x18\x01 \x03(\x0b\x32\x14.google.api.HttpRuleR\x05rules\x12\x45\n\x1f\x66ully_decode_reserved_expansion\x18\x02 \x01(\x08R\x1c\x66ullyDecodeReservedExpansion\"\xda\x02\n\x08HttpRule\x12\x1a\n\x08selector\x18\x01 \x01(\tR\x08selector\x12\x12\n\x03get\x18\x02 \x01(\tH\x00R\x03get\x12\x12\n\x03put\x18\x03 \x01(\tH\x00R\x03put\x12\x14\n\x04post\x18\x04 \x01(\tH\x00R\x04post\x12\x18\n\x06\x64\x65lete\x18\x05 \x01(\tH\x00R\x06\x64\x65lete\x12\x16\n\x05patch\x18\x06 \x01(\tH\x00R\x05patch\x12\x37\n\x06\x63ustom\x18\x08 \x01(\x0b\x32\x1d.google.api.CustomHttpPatternH\x00R\x06\x63ustom\x12\x12\n\x04\x62ody\x18\x07 \x01(\tR\x04\x62ody\x12#\n\rresponse_body\x18\x0c \x01(\tR\x0cresponseBody\x12\x45\n\x13\x61\x64\x64itional_bindings\x18\x0b \x03(\x0b\x32\x14.google.api.HttpRuleR\x12\x61\x64\x64itionalBindingsB\t\n\x07pattern\";\n\x11\x43ustomHttpPattern\x12\x12\n\x04kind\x18\x01 \x01(\tR\x04kind\x12\x12\n\x04path\x18\x02 \x01(\tR\x04pathB\xac\x01\n\x0e\x63om.google.apiB\tHttpProtoH\x02P\x01ZAgoogle.golang.org/genproto/googleapis/api/annotations;annotations\xf8\x01\x01\xa2\x02\x03GAX\xaa\x02\nGoogle.Api\xca\x02\nGoogle\\Api\xe2\x02\x16Google\\Api\\GPBMetadata\xea\x02\x0bGoogle::Apib\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.api.http_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\016com.google.apiB\tHttpProtoH\002P\001ZAgoogle.golang.org/genproto/googleapis/api/annotations;annotations\370\001\001\242\002\003GAX\252\002\nGoogle.Api\312\002\nGoogle\\Api\342\002\026Google\\Api\\GPBMetadata\352\002\013Google::Api' + _globals['_HTTP']._serialized_start=37 + _globals['_HTTP']._serialized_end=158 + _globals['_HTTPRULE']._serialized_start=161 + _globals['_HTTPRULE']._serialized_end=507 + _globals['_CUSTOMHTTPPATTERN']._serialized_start=509 + _globals['_CUSTOMHTTPPATTERN']._serialized_end=568 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/google/api/http_pb2.pyi b/gen/python/google/api/http_pb2.pyi new file mode 100644 index 0000000000..b2811fb04b --- /dev/null +++ b/gen/python/google/api/http_pb2.pyi @@ -0,0 +1,46 @@ +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class Http(_message.Message): + __slots__ = ["rules", "fully_decode_reserved_expansion"] + RULES_FIELD_NUMBER: _ClassVar[int] + FULLY_DECODE_RESERVED_EXPANSION_FIELD_NUMBER: _ClassVar[int] + rules: _containers.RepeatedCompositeFieldContainer[HttpRule] + fully_decode_reserved_expansion: bool + def __init__(self, rules: _Optional[_Iterable[_Union[HttpRule, _Mapping]]] = ..., fully_decode_reserved_expansion: bool = ...) -> None: ... + +class HttpRule(_message.Message): + __slots__ = ["selector", "get", "put", "post", "delete", "patch", "custom", "body", "response_body", "additional_bindings"] + SELECTOR_FIELD_NUMBER: _ClassVar[int] + GET_FIELD_NUMBER: _ClassVar[int] + PUT_FIELD_NUMBER: _ClassVar[int] + POST_FIELD_NUMBER: _ClassVar[int] + DELETE_FIELD_NUMBER: _ClassVar[int] + PATCH_FIELD_NUMBER: _ClassVar[int] + CUSTOM_FIELD_NUMBER: _ClassVar[int] + BODY_FIELD_NUMBER: _ClassVar[int] + RESPONSE_BODY_FIELD_NUMBER: _ClassVar[int] + ADDITIONAL_BINDINGS_FIELD_NUMBER: _ClassVar[int] + selector: str + get: str + put: str + post: str + delete: str + patch: str + custom: CustomHttpPattern + body: str + response_body: str + additional_bindings: _containers.RepeatedCompositeFieldContainer[HttpRule] + def __init__(self, selector: _Optional[str] = ..., get: _Optional[str] = ..., put: _Optional[str] = ..., post: _Optional[str] = ..., delete: _Optional[str] = ..., patch: _Optional[str] = ..., custom: _Optional[_Union[CustomHttpPattern, _Mapping]] = ..., body: _Optional[str] = ..., response_body: _Optional[str] = ..., additional_bindings: _Optional[_Iterable[_Union[HttpRule, _Mapping]]] = ...) -> None: ... + +class CustomHttpPattern(_message.Message): + __slots__ = ["kind", "path"] + KIND_FIELD_NUMBER: _ClassVar[int] + PATH_FIELD_NUMBER: _ClassVar[int] + kind: str + path: str + def __init__(self, kind: _Optional[str] = ..., path: _Optional[str] = ...) -> None: ... diff --git a/gen/python/google/api/http_pb2_grpc.py b/gen/python/google/api/http_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/google/api/http_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/google/rpc/__init__.py b/gen/python/google/rpc/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/google/rpc/status_pb2.py b/gen/python/google/rpc/status_pb2.py new file mode 100644 index 0000000000..446668aedf --- /dev/null +++ b/gen/python/google/rpc/status_pb2.py @@ -0,0 +1,27 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/rpc/status.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x17google/rpc/status.proto\x12\ngoogle.rpc\x1a\x19google/protobuf/any.proto\"f\n\x06Status\x12\x12\n\x04\x63ode\x18\x01 \x01(\x05R\x04\x63ode\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\x12.\n\x07\x64\x65tails\x18\x03 \x03(\x0b\x32\x14.google.protobuf.AnyR\x07\x64\x65tailsB\xa4\x01\n\x0e\x63om.google.rpcB\x0bStatusProtoH\x02P\x01Z7google.golang.org/genproto/googleapis/rpc/status;status\xf8\x01\x01\xa2\x02\x03GRX\xaa\x02\nGoogle.Rpc\xca\x02\nGoogle\\Rpc\xe2\x02\x16Google\\Rpc\\GPBMetadata\xea\x02\x0bGoogle::Rpcb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.rpc.status_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n\016com.google.rpcB\013StatusProtoH\002P\001Z7google.golang.org/genproto/googleapis/rpc/status;status\370\001\001\242\002\003GRX\252\002\nGoogle.Rpc\312\002\nGoogle\\Rpc\342\002\026Google\\Rpc\\GPBMetadata\352\002\013Google::Rpc' + _globals['_STATUS']._serialized_start=66 + _globals['_STATUS']._serialized_end=168 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/google/rpc/status_pb2.pyi b/gen/python/google/rpc/status_pb2.pyi new file mode 100644 index 0000000000..2a795ebc82 --- /dev/null +++ b/gen/python/google/rpc/status_pb2.pyi @@ -0,0 +1,17 @@ +from google.protobuf import any_pb2 as _any_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class Status(_message.Message): + __slots__ = ["code", "message", "details"] + CODE_FIELD_NUMBER: _ClassVar[int] + MESSAGE_FIELD_NUMBER: _ClassVar[int] + DETAILS_FIELD_NUMBER: _ClassVar[int] + code: int + message: str + details: _containers.RepeatedCompositeFieldContainer[_any_pb2.Any] + def __init__(self, code: _Optional[int] = ..., message: _Optional[str] = ..., details: _Optional[_Iterable[_Union[_any_pb2.Any, _Mapping]]] = ...) -> None: ... diff --git a/gen/python/google/rpc/status_pb2_grpc.py b/gen/python/google/rpc/status_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/google/rpc/status_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/protoc_gen_openapiv2/__init__.py b/gen/python/protoc_gen_openapiv2/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/protoc_gen_openapiv2/options/__init__.py b/gen/python/protoc_gen_openapiv2/options/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/gen/python/protoc_gen_openapiv2/options/annotations_pb2.py b/gen/python/protoc_gen_openapiv2/options/annotations_pb2.py new file mode 100644 index 0000000000..f1b55b79db --- /dev/null +++ b/gen/python/protoc_gen_openapiv2/options/annotations_pb2.py @@ -0,0 +1,26 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: protoc-gen-openapiv2/options/annotations.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2 +from protoc_gen_openapiv2.options import openapiv2_pb2 as protoc__gen__openapiv2_dot_options_dot_openapiv2__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n.protoc-gen-openapiv2/options/annotations.proto\x12)grpc.gateway.protoc_gen_openapiv2.options\x1a google/protobuf/descriptor.proto\x1a,protoc-gen-openapiv2/options/openapiv2.proto:~\n\x11openapiv2_swagger\x12\x1c.google.protobuf.FileOptions\x18\x92\x08 \x01(\x0b\x32\x32.grpc.gateway.protoc_gen_openapiv2.options.SwaggerR\x10openapiv2Swagger:\x86\x01\n\x13openapiv2_operation\x12\x1e.google.protobuf.MethodOptions\x18\x92\x08 \x01(\x0b\x32\x34.grpc.gateway.protoc_gen_openapiv2.options.OperationR\x12openapiv2Operation:~\n\x10openapiv2_schema\x12\x1f.google.protobuf.MessageOptions\x18\x92\x08 \x01(\x0b\x32\x31.grpc.gateway.protoc_gen_openapiv2.options.SchemaR\x0fopenapiv2Schema:{\n\x0eopenapiv2_enum\x12\x1c.google.protobuf.EnumOptions\x18\x92\x08 \x01(\x0b\x32\x35.grpc.gateway.protoc_gen_openapiv2.options.EnumSchemaR\ropenapiv2Enum:u\n\ropenapiv2_tag\x12\x1f.google.protobuf.ServiceOptions\x18\x92\x08 \x01(\x0b\x32..grpc.gateway.protoc_gen_openapiv2.options.TagR\x0copenapiv2Tag:~\n\x0fopenapiv2_field\x12\x1d.google.protobuf.FieldOptions\x18\x92\x08 \x01(\x0b\x32\x35.grpc.gateway.protoc_gen_openapiv2.options.JSONSchemaR\x0eopenapiv2FieldB\xcb\x02\n-com.grpc.gateway.protoc_gen_openapiv2.optionsB\x10\x41nnotationsProtoH\x02P\x01ZFgithub.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2/options\xa2\x02\x04GGPO\xaa\x02\'Grpc.Gateway.ProtocGenOpenapiv2.Options\xca\x02\'Grpc\\Gateway\\ProtocGenOpenapiv2\\Options\xe2\x02\x33Grpc\\Gateway\\ProtocGenOpenapiv2\\Options\\GPBMetadata\xea\x02*Grpc::Gateway::ProtocGenOpenapiv2::Optionsb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'protoc_gen_openapiv2.options.annotations_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n-com.grpc.gateway.protoc_gen_openapiv2.optionsB\020AnnotationsProtoH\002P\001ZFgithub.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2/options\242\002\004GGPO\252\002\'Grpc.Gateway.ProtocGenOpenapiv2.Options\312\002\'Grpc\\Gateway\\ProtocGenOpenapiv2\\Options\342\0023Grpc\\Gateway\\ProtocGenOpenapiv2\\Options\\GPBMetadata\352\002*Grpc::Gateway::ProtocGenOpenapiv2::Options' +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/protoc_gen_openapiv2/options/annotations_pb2.pyi b/gen/python/protoc_gen_openapiv2/options/annotations_pb2.pyi new file mode 100644 index 0000000000..48b05b7385 --- /dev/null +++ b/gen/python/protoc_gen_openapiv2/options/annotations_pb2.pyi @@ -0,0 +1,18 @@ +from google.protobuf import descriptor_pb2 as _descriptor_pb2 +from protoc_gen_openapiv2.options import openapiv2_pb2 as _openapiv2_pb2 +from google.protobuf import descriptor as _descriptor +from typing import ClassVar as _ClassVar + +DESCRIPTOR: _descriptor.FileDescriptor +OPENAPIV2_SWAGGER_FIELD_NUMBER: _ClassVar[int] +openapiv2_swagger: _descriptor.FieldDescriptor +OPENAPIV2_OPERATION_FIELD_NUMBER: _ClassVar[int] +openapiv2_operation: _descriptor.FieldDescriptor +OPENAPIV2_SCHEMA_FIELD_NUMBER: _ClassVar[int] +openapiv2_schema: _descriptor.FieldDescriptor +OPENAPIV2_ENUM_FIELD_NUMBER: _ClassVar[int] +openapiv2_enum: _descriptor.FieldDescriptor +OPENAPIV2_TAG_FIELD_NUMBER: _ClassVar[int] +openapiv2_tag: _descriptor.FieldDescriptor +OPENAPIV2_FIELD_FIELD_NUMBER: _ClassVar[int] +openapiv2_field: _descriptor.FieldDescriptor diff --git a/gen/python/protoc_gen_openapiv2/options/annotations_pb2_grpc.py b/gen/python/protoc_gen_openapiv2/options/annotations_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/protoc_gen_openapiv2/options/annotations_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/protoc_gen_openapiv2/options/openapiv2_pb2.py b/gen/python/protoc_gen_openapiv2/options/openapiv2_pb2.py new file mode 100644 index 0000000000..600dd93c8b --- /dev/null +++ b/gen/python/protoc_gen_openapiv2/options/openapiv2_pb2.py @@ -0,0 +1,137 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: protoc-gen-openapiv2/options/openapiv2.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n,protoc-gen-openapiv2/options/openapiv2.proto\x12)grpc.gateway.protoc_gen_openapiv2.options\x1a\x1cgoogle/protobuf/struct.proto\"\xb3\x08\n\x07Swagger\x12\x18\n\x07swagger\x18\x01 \x01(\tR\x07swagger\x12\x43\n\x04info\x18\x02 \x01(\x0b\x32/.grpc.gateway.protoc_gen_openapiv2.options.InfoR\x04info\x12\x12\n\x04host\x18\x03 \x01(\tR\x04host\x12\x1b\n\tbase_path\x18\x04 \x01(\tR\x08\x62\x61sePath\x12K\n\x07schemes\x18\x05 \x03(\x0e\x32\x31.grpc.gateway.protoc_gen_openapiv2.options.SchemeR\x07schemes\x12\x1a\n\x08\x63onsumes\x18\x06 \x03(\tR\x08\x63onsumes\x12\x1a\n\x08produces\x18\x07 \x03(\tR\x08produces\x12_\n\tresponses\x18\n \x03(\x0b\x32\x41.grpc.gateway.protoc_gen_openapiv2.options.Swagger.ResponsesEntryR\tresponses\x12q\n\x14security_definitions\x18\x0b \x01(\x0b\x32>.grpc.gateway.protoc_gen_openapiv2.options.SecurityDefinitionsR\x13securityDefinitions\x12Z\n\x08security\x18\x0c \x03(\x0b\x32>.grpc.gateway.protoc_gen_openapiv2.options.SecurityRequirementR\x08security\x12\x42\n\x04tags\x18\r \x03(\x0b\x32..grpc.gateway.protoc_gen_openapiv2.options.TagR\x04tags\x12\x65\n\rexternal_docs\x18\x0e \x01(\x0b\x32@.grpc.gateway.protoc_gen_openapiv2.options.ExternalDocumentationR\x0c\x65xternalDocs\x12\x62\n\nextensions\x18\x0f \x03(\x0b\x32\x42.grpc.gateway.protoc_gen_openapiv2.options.Swagger.ExtensionsEntryR\nextensions\x1aq\n\x0eResponsesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12I\n\x05value\x18\x02 \x01(\x0b\x32\x33.grpc.gateway.protoc_gen_openapiv2.options.ResponseR\x05value:\x02\x38\x01\x1aU\n\x0f\x45xtensionsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12,\n\x05value\x18\x02 \x01(\x0b\x32\x16.google.protobuf.ValueR\x05value:\x02\x38\x01J\x04\x08\x08\x10\tJ\x04\x08\t\x10\n\"\xd6\x07\n\tOperation\x12\x12\n\x04tags\x18\x01 \x03(\tR\x04tags\x12\x18\n\x07summary\x18\x02 \x01(\tR\x07summary\x12 \n\x0b\x64\x65scription\x18\x03 \x01(\tR\x0b\x64\x65scription\x12\x65\n\rexternal_docs\x18\x04 \x01(\x0b\x32@.grpc.gateway.protoc_gen_openapiv2.options.ExternalDocumentationR\x0c\x65xternalDocs\x12!\n\x0coperation_id\x18\x05 \x01(\tR\x0boperationId\x12\x1a\n\x08\x63onsumes\x18\x06 \x03(\tR\x08\x63onsumes\x12\x1a\n\x08produces\x18\x07 \x03(\tR\x08produces\x12\x61\n\tresponses\x18\t \x03(\x0b\x32\x43.grpc.gateway.protoc_gen_openapiv2.options.Operation.ResponsesEntryR\tresponses\x12K\n\x07schemes\x18\n \x03(\x0e\x32\x31.grpc.gateway.protoc_gen_openapiv2.options.SchemeR\x07schemes\x12\x1e\n\ndeprecated\x18\x0b \x01(\x08R\ndeprecated\x12Z\n\x08security\x18\x0c \x03(\x0b\x32>.grpc.gateway.protoc_gen_openapiv2.options.SecurityRequirementR\x08security\x12\x64\n\nextensions\x18\r \x03(\x0b\x32\x44.grpc.gateway.protoc_gen_openapiv2.options.Operation.ExtensionsEntryR\nextensions\x12U\n\nparameters\x18\x0e \x01(\x0b\x32\x35.grpc.gateway.protoc_gen_openapiv2.options.ParametersR\nparameters\x1aq\n\x0eResponsesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12I\n\x05value\x18\x02 \x01(\x0b\x32\x33.grpc.gateway.protoc_gen_openapiv2.options.ResponseR\x05value:\x02\x38\x01\x1aU\n\x0f\x45xtensionsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12,\n\x05value\x18\x02 \x01(\x0b\x32\x16.google.protobuf.ValueR\x05value:\x02\x38\x01J\x04\x08\x08\x10\t\"b\n\nParameters\x12T\n\x07headers\x18\x01 \x03(\x0b\x32:.grpc.gateway.protoc_gen_openapiv2.options.HeaderParameterR\x07headers\"\xa3\x02\n\x0fHeaderParameter\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12 \n\x0b\x64\x65scription\x18\x02 \x01(\tR\x0b\x64\x65scription\x12S\n\x04type\x18\x03 \x01(\x0e\x32?.grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter.TypeR\x04type\x12\x16\n\x06\x66ormat\x18\x04 \x01(\tR\x06\x66ormat\x12\x1a\n\x08required\x18\x05 \x01(\x08R\x08required\"E\n\x04Type\x12\x0b\n\x07UNKNOWN\x10\x00\x12\n\n\x06STRING\x10\x01\x12\n\n\x06NUMBER\x10\x02\x12\x0b\n\x07INTEGER\x10\x03\x12\x0b\n\x07\x42OOLEAN\x10\x04J\x04\x08\x06\x10\x07J\x04\x08\x07\x10\x08\"\xd8\x01\n\x06Header\x12 \n\x0b\x64\x65scription\x18\x01 \x01(\tR\x0b\x64\x65scription\x12\x12\n\x04type\x18\x02 \x01(\tR\x04type\x12\x16\n\x06\x66ormat\x18\x03 \x01(\tR\x06\x66ormat\x12\x18\n\x07\x64\x65\x66\x61ult\x18\x06 \x01(\tR\x07\x64\x65\x66\x61ult\x12\x18\n\x07pattern\x18\r \x01(\tR\x07patternJ\x04\x08\x04\x10\x05J\x04\x08\x05\x10\x06J\x04\x08\x07\x10\x08J\x04\x08\x08\x10\tJ\x04\x08\t\x10\nJ\x04\x08\n\x10\x0bJ\x04\x08\x0b\x10\x0cJ\x04\x08\x0c\x10\rJ\x04\x08\x0e\x10\x0fJ\x04\x08\x0f\x10\x10J\x04\x08\x10\x10\x11J\x04\x08\x11\x10\x12J\x04\x08\x12\x10\x13\"\x9a\x05\n\x08Response\x12 \n\x0b\x64\x65scription\x18\x01 \x01(\tR\x0b\x64\x65scription\x12I\n\x06schema\x18\x02 \x01(\x0b\x32\x31.grpc.gateway.protoc_gen_openapiv2.options.SchemaR\x06schema\x12Z\n\x07headers\x18\x03 \x03(\x0b\x32@.grpc.gateway.protoc_gen_openapiv2.options.Response.HeadersEntryR\x07headers\x12]\n\x08\x65xamples\x18\x04 \x03(\x0b\x32\x41.grpc.gateway.protoc_gen_openapiv2.options.Response.ExamplesEntryR\x08\x65xamples\x12\x63\n\nextensions\x18\x05 \x03(\x0b\x32\x43.grpc.gateway.protoc_gen_openapiv2.options.Response.ExtensionsEntryR\nextensions\x1am\n\x0cHeadersEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12G\n\x05value\x18\x02 \x01(\x0b\x32\x31.grpc.gateway.protoc_gen_openapiv2.options.HeaderR\x05value:\x02\x38\x01\x1a;\n\rExamplesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x1aU\n\x0f\x45xtensionsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12,\n\x05value\x18\x02 \x01(\x0b\x32\x16.google.protobuf.ValueR\x05value:\x02\x38\x01\"\xd6\x03\n\x04Info\x12\x14\n\x05title\x18\x01 \x01(\tR\x05title\x12 \n\x0b\x64\x65scription\x18\x02 \x01(\tR\x0b\x64\x65scription\x12(\n\x10terms_of_service\x18\x03 \x01(\tR\x0etermsOfService\x12L\n\x07\x63ontact\x18\x04 \x01(\x0b\x32\x32.grpc.gateway.protoc_gen_openapiv2.options.ContactR\x07\x63ontact\x12L\n\x07license\x18\x05 \x01(\x0b\x32\x32.grpc.gateway.protoc_gen_openapiv2.options.LicenseR\x07license\x12\x18\n\x07version\x18\x06 \x01(\tR\x07version\x12_\n\nextensions\x18\x07 \x03(\x0b\x32?.grpc.gateway.protoc_gen_openapiv2.options.Info.ExtensionsEntryR\nextensions\x1aU\n\x0f\x45xtensionsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12,\n\x05value\x18\x02 \x01(\x0b\x32\x16.google.protobuf.ValueR\x05value:\x02\x38\x01\"E\n\x07\x43ontact\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x10\n\x03url\x18\x02 \x01(\tR\x03url\x12\x14\n\x05\x65mail\x18\x03 \x01(\tR\x05\x65mail\"/\n\x07License\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x10\n\x03url\x18\x02 \x01(\tR\x03url\"K\n\x15\x45xternalDocumentation\x12 \n\x0b\x64\x65scription\x18\x01 \x01(\tR\x0b\x64\x65scription\x12\x10\n\x03url\x18\x02 \x01(\tR\x03url\"\xaa\x02\n\x06Schema\x12V\n\x0bjson_schema\x18\x01 \x01(\x0b\x32\x35.grpc.gateway.protoc_gen_openapiv2.options.JSONSchemaR\njsonSchema\x12$\n\rdiscriminator\x18\x02 \x01(\tR\rdiscriminator\x12\x1b\n\tread_only\x18\x03 \x01(\x08R\x08readOnly\x12\x65\n\rexternal_docs\x18\x05 \x01(\x0b\x32@.grpc.gateway.protoc_gen_openapiv2.options.ExternalDocumentationR\x0c\x65xternalDocs\x12\x18\n\x07\x65xample\x18\x06 \x01(\tR\x07\x65xampleJ\x04\x08\x04\x10\x05\"\xe8\x03\n\nEnumSchema\x12 \n\x0b\x64\x65scription\x18\x01 \x01(\tR\x0b\x64\x65scription\x12\x18\n\x07\x64\x65\x66\x61ult\x18\x02 \x01(\tR\x07\x64\x65\x66\x61ult\x12\x14\n\x05title\x18\x03 \x01(\tR\x05title\x12\x1a\n\x08required\x18\x04 \x01(\x08R\x08required\x12\x1b\n\tread_only\x18\x05 \x01(\x08R\x08readOnly\x12\x65\n\rexternal_docs\x18\x06 \x01(\x0b\x32@.grpc.gateway.protoc_gen_openapiv2.options.ExternalDocumentationR\x0c\x65xternalDocs\x12\x18\n\x07\x65xample\x18\x07 \x01(\tR\x07\x65xample\x12\x10\n\x03ref\x18\x08 \x01(\tR\x03ref\x12\x65\n\nextensions\x18\t \x03(\x0b\x32\x45.grpc.gateway.protoc_gen_openapiv2.options.EnumSchema.ExtensionsEntryR\nextensions\x1aU\n\x0f\x45xtensionsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12,\n\x05value\x18\x02 \x01(\x0b\x32\x16.google.protobuf.ValueR\x05value:\x02\x38\x01\"\xf7\n\n\nJSONSchema\x12\x10\n\x03ref\x18\x03 \x01(\tR\x03ref\x12\x14\n\x05title\x18\x05 \x01(\tR\x05title\x12 \n\x0b\x64\x65scription\x18\x06 \x01(\tR\x0b\x64\x65scription\x12\x18\n\x07\x64\x65\x66\x61ult\x18\x07 \x01(\tR\x07\x64\x65\x66\x61ult\x12\x1b\n\tread_only\x18\x08 \x01(\x08R\x08readOnly\x12\x18\n\x07\x65xample\x18\t \x01(\tR\x07\x65xample\x12\x1f\n\x0bmultiple_of\x18\n \x01(\x01R\nmultipleOf\x12\x18\n\x07maximum\x18\x0b \x01(\x01R\x07maximum\x12+\n\x11\x65xclusive_maximum\x18\x0c \x01(\x08R\x10\x65xclusiveMaximum\x12\x18\n\x07minimum\x18\r \x01(\x01R\x07minimum\x12+\n\x11\x65xclusive_minimum\x18\x0e \x01(\x08R\x10\x65xclusiveMinimum\x12\x1d\n\nmax_length\x18\x0f \x01(\x04R\tmaxLength\x12\x1d\n\nmin_length\x18\x10 \x01(\x04R\tminLength\x12\x18\n\x07pattern\x18\x11 \x01(\tR\x07pattern\x12\x1b\n\tmax_items\x18\x14 \x01(\x04R\x08maxItems\x12\x1b\n\tmin_items\x18\x15 \x01(\x04R\x08minItems\x12!\n\x0cunique_items\x18\x16 \x01(\x08R\x0buniqueItems\x12%\n\x0emax_properties\x18\x18 \x01(\x04R\rmaxProperties\x12%\n\x0emin_properties\x18\x19 \x01(\x04R\rminProperties\x12\x1a\n\x08required\x18\x1a \x03(\tR\x08required\x12\x14\n\x05\x61rray\x18\" \x03(\tR\x05\x61rray\x12_\n\x04type\x18# \x03(\x0e\x32K.grpc.gateway.protoc_gen_openapiv2.options.JSONSchema.JSONSchemaSimpleTypesR\x04type\x12\x16\n\x06\x66ormat\x18$ \x01(\tR\x06\x66ormat\x12\x12\n\x04\x65num\x18. \x03(\tR\x04\x65num\x12z\n\x13\x66ield_configuration\x18\xe9\x07 \x01(\x0b\x32H.grpc.gateway.protoc_gen_openapiv2.options.JSONSchema.FieldConfigurationR\x12\x66ieldConfiguration\x12\x65\n\nextensions\x18\x30 \x03(\x0b\x32\x45.grpc.gateway.protoc_gen_openapiv2.options.JSONSchema.ExtensionsEntryR\nextensions\x1a\\\n\x12\x46ieldConfiguration\x12&\n\x0fpath_param_name\x18/ \x01(\tR\rpathParamName\x12\x1e\n\ndeprecated\x18\x31 \x01(\x08R\ndeprecated\x1aU\n\x0f\x45xtensionsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12,\n\x05value\x18\x02 \x01(\x0b\x32\x16.google.protobuf.ValueR\x05value:\x02\x38\x01\"w\n\x15JSONSchemaSimpleTypes\x12\x0b\n\x07UNKNOWN\x10\x00\x12\t\n\x05\x41RRAY\x10\x01\x12\x0b\n\x07\x42OOLEAN\x10\x02\x12\x0b\n\x07INTEGER\x10\x03\x12\x08\n\x04NULL\x10\x04\x12\n\n\x06NUMBER\x10\x05\x12\n\n\x06OBJECT\x10\x06\x12\n\n\x06STRING\x10\x07J\x04\x08\x01\x10\x02J\x04\x08\x02\x10\x03J\x04\x08\x04\x10\x05J\x04\x08\x12\x10\x13J\x04\x08\x13\x10\x14J\x04\x08\x17\x10\x18J\x04\x08\x1b\x10\x1cJ\x04\x08\x1c\x10\x1dJ\x04\x08\x1d\x10\x1eJ\x04\x08\x1e\x10\"J\x04\x08%\x10*J\x04\x08*\x10+J\x04\x08+\x10.\"\xd9\x02\n\x03Tag\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12 \n\x0b\x64\x65scription\x18\x02 \x01(\tR\x0b\x64\x65scription\x12\x65\n\rexternal_docs\x18\x03 \x01(\x0b\x32@.grpc.gateway.protoc_gen_openapiv2.options.ExternalDocumentationR\x0c\x65xternalDocs\x12^\n\nextensions\x18\x04 \x03(\x0b\x32>.grpc.gateway.protoc_gen_openapiv2.options.Tag.ExtensionsEntryR\nextensions\x1aU\n\x0f\x45xtensionsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12,\n\x05value\x18\x02 \x01(\x0b\x32\x16.google.protobuf.ValueR\x05value:\x02\x38\x01\"\xf7\x01\n\x13SecurityDefinitions\x12h\n\x08security\x18\x01 \x03(\x0b\x32L.grpc.gateway.protoc_gen_openapiv2.options.SecurityDefinitions.SecurityEntryR\x08security\x1av\n\rSecurityEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12O\n\x05value\x18\x02 \x01(\x0b\x32\x39.grpc.gateway.protoc_gen_openapiv2.options.SecuritySchemeR\x05value:\x02\x38\x01\"\xff\x06\n\x0eSecurityScheme\x12R\n\x04type\x18\x01 \x01(\x0e\x32>.grpc.gateway.protoc_gen_openapiv2.options.SecurityScheme.TypeR\x04type\x12 \n\x0b\x64\x65scription\x18\x02 \x01(\tR\x0b\x64\x65scription\x12\x12\n\x04name\x18\x03 \x01(\tR\x04name\x12L\n\x02in\x18\x04 \x01(\x0e\x32<.grpc.gateway.protoc_gen_openapiv2.options.SecurityScheme.InR\x02in\x12R\n\x04\x66low\x18\x05 \x01(\x0e\x32>.grpc.gateway.protoc_gen_openapiv2.options.SecurityScheme.FlowR\x04\x66low\x12+\n\x11\x61uthorization_url\x18\x06 \x01(\tR\x10\x61uthorizationUrl\x12\x1b\n\ttoken_url\x18\x07 \x01(\tR\x08tokenUrl\x12I\n\x06scopes\x18\x08 \x01(\x0b\x32\x31.grpc.gateway.protoc_gen_openapiv2.options.ScopesR\x06scopes\x12i\n\nextensions\x18\t \x03(\x0b\x32I.grpc.gateway.protoc_gen_openapiv2.options.SecurityScheme.ExtensionsEntryR\nextensions\x1aU\n\x0f\x45xtensionsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12,\n\x05value\x18\x02 \x01(\x0b\x32\x16.google.protobuf.ValueR\x05value:\x02\x38\x01\"K\n\x04Type\x12\x10\n\x0cTYPE_INVALID\x10\x00\x12\x0e\n\nTYPE_BASIC\x10\x01\x12\x10\n\x0cTYPE_API_KEY\x10\x02\x12\x0f\n\x0bTYPE_OAUTH2\x10\x03\"1\n\x02In\x12\x0e\n\nIN_INVALID\x10\x00\x12\x0c\n\x08IN_QUERY\x10\x01\x12\r\n\tIN_HEADER\x10\x02\"j\n\x04\x46low\x12\x10\n\x0c\x46LOW_INVALID\x10\x00\x12\x11\n\rFLOW_IMPLICIT\x10\x01\x12\x11\n\rFLOW_PASSWORD\x10\x02\x12\x14\n\x10\x46LOW_APPLICATION\x10\x03\x12\x14\n\x10\x46LOW_ACCESS_CODE\x10\x04\"\xf6\x02\n\x13SecurityRequirement\x12\x8a\x01\n\x14security_requirement\x18\x01 \x03(\x0b\x32W.grpc.gateway.protoc_gen_openapiv2.options.SecurityRequirement.SecurityRequirementEntryR\x13securityRequirement\x1a\x30\n\x18SecurityRequirementValue\x12\x14\n\x05scope\x18\x01 \x03(\tR\x05scope\x1a\x9f\x01\n\x18SecurityRequirementEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12m\n\x05value\x18\x02 \x01(\x0b\x32W.grpc.gateway.protoc_gen_openapiv2.options.SecurityRequirement.SecurityRequirementValueR\x05value:\x02\x38\x01\"\x96\x01\n\x06Scopes\x12R\n\x05scope\x18\x01 \x03(\x0b\x32<.grpc.gateway.protoc_gen_openapiv2.options.Scopes.ScopeEntryR\x05scope\x1a\x38\n\nScopeEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01*;\n\x06Scheme\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x08\n\x04HTTP\x10\x01\x12\t\n\x05HTTPS\x10\x02\x12\x06\n\x02WS\x10\x03\x12\x07\n\x03WSS\x10\x04\x42\xc9\x02\n-com.grpc.gateway.protoc_gen_openapiv2.optionsB\x0eOpenapiv2ProtoH\x02P\x01ZFgithub.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2/options\xa2\x02\x04GGPO\xaa\x02\'Grpc.Gateway.ProtocGenOpenapiv2.Options\xca\x02\'Grpc\\Gateway\\ProtocGenOpenapiv2\\Options\xe2\x02\x33Grpc\\Gateway\\ProtocGenOpenapiv2\\Options\\GPBMetadata\xea\x02*Grpc::Gateway::ProtocGenOpenapiv2::Optionsb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'protoc_gen_openapiv2.options.openapiv2_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b'\n-com.grpc.gateway.protoc_gen_openapiv2.optionsB\016Openapiv2ProtoH\002P\001ZFgithub.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2/options\242\002\004GGPO\252\002\'Grpc.Gateway.ProtocGenOpenapiv2.Options\312\002\'Grpc\\Gateway\\ProtocGenOpenapiv2\\Options\342\0023Grpc\\Gateway\\ProtocGenOpenapiv2\\Options\\GPBMetadata\352\002*Grpc::Gateway::ProtocGenOpenapiv2::Options' + _SWAGGER_RESPONSESENTRY._options = None + _SWAGGER_RESPONSESENTRY._serialized_options = b'8\001' + _SWAGGER_EXTENSIONSENTRY._options = None + _SWAGGER_EXTENSIONSENTRY._serialized_options = b'8\001' + _OPERATION_RESPONSESENTRY._options = None + _OPERATION_RESPONSESENTRY._serialized_options = b'8\001' + _OPERATION_EXTENSIONSENTRY._options = None + _OPERATION_EXTENSIONSENTRY._serialized_options = b'8\001' + _RESPONSE_HEADERSENTRY._options = None + _RESPONSE_HEADERSENTRY._serialized_options = b'8\001' + _RESPONSE_EXAMPLESENTRY._options = None + _RESPONSE_EXAMPLESENTRY._serialized_options = b'8\001' + _RESPONSE_EXTENSIONSENTRY._options = None + _RESPONSE_EXTENSIONSENTRY._serialized_options = b'8\001' + _INFO_EXTENSIONSENTRY._options = None + _INFO_EXTENSIONSENTRY._serialized_options = b'8\001' + _ENUMSCHEMA_EXTENSIONSENTRY._options = None + _ENUMSCHEMA_EXTENSIONSENTRY._serialized_options = b'8\001' + _JSONSCHEMA_EXTENSIONSENTRY._options = None + _JSONSCHEMA_EXTENSIONSENTRY._serialized_options = b'8\001' + _TAG_EXTENSIONSENTRY._options = None + _TAG_EXTENSIONSENTRY._serialized_options = b'8\001' + _SECURITYDEFINITIONS_SECURITYENTRY._options = None + _SECURITYDEFINITIONS_SECURITYENTRY._serialized_options = b'8\001' + _SECURITYSCHEME_EXTENSIONSENTRY._options = None + _SECURITYSCHEME_EXTENSIONSENTRY._serialized_options = b'8\001' + _SECURITYREQUIREMENT_SECURITYREQUIREMENTENTRY._options = None + _SECURITYREQUIREMENT_SECURITYREQUIREMENTENTRY._serialized_options = b'8\001' + _SCOPES_SCOPEENTRY._options = None + _SCOPES_SCOPEENTRY._serialized_options = b'8\001' + _globals['_SCHEME']._serialized_start=8356 + _globals['_SCHEME']._serialized_end=8415 + _globals['_SWAGGER']._serialized_start=122 + _globals['_SWAGGER']._serialized_end=1197 + _globals['_SWAGGER_RESPONSESENTRY']._serialized_start=985 + _globals['_SWAGGER_RESPONSESENTRY']._serialized_end=1098 + _globals['_SWAGGER_EXTENSIONSENTRY']._serialized_start=1100 + _globals['_SWAGGER_EXTENSIONSENTRY']._serialized_end=1185 + _globals['_OPERATION']._serialized_start=1200 + _globals['_OPERATION']._serialized_end=2182 + _globals['_OPERATION_RESPONSESENTRY']._serialized_start=985 + _globals['_OPERATION_RESPONSESENTRY']._serialized_end=1098 + _globals['_OPERATION_EXTENSIONSENTRY']._serialized_start=1100 + _globals['_OPERATION_EXTENSIONSENTRY']._serialized_end=1185 + _globals['_PARAMETERS']._serialized_start=2184 + _globals['_PARAMETERS']._serialized_end=2282 + _globals['_HEADERPARAMETER']._serialized_start=2285 + _globals['_HEADERPARAMETER']._serialized_end=2576 + _globals['_HEADERPARAMETER_TYPE']._serialized_start=2495 + _globals['_HEADERPARAMETER_TYPE']._serialized_end=2564 + _globals['_HEADER']._serialized_start=2579 + _globals['_HEADER']._serialized_end=2795 + _globals['_RESPONSE']._serialized_start=2798 + _globals['_RESPONSE']._serialized_end=3464 + _globals['_RESPONSE_HEADERSENTRY']._serialized_start=3207 + _globals['_RESPONSE_HEADERSENTRY']._serialized_end=3316 + _globals['_RESPONSE_EXAMPLESENTRY']._serialized_start=3318 + _globals['_RESPONSE_EXAMPLESENTRY']._serialized_end=3377 + _globals['_RESPONSE_EXTENSIONSENTRY']._serialized_start=1100 + _globals['_RESPONSE_EXTENSIONSENTRY']._serialized_end=1185 + _globals['_INFO']._serialized_start=3467 + _globals['_INFO']._serialized_end=3937 + _globals['_INFO_EXTENSIONSENTRY']._serialized_start=1100 + _globals['_INFO_EXTENSIONSENTRY']._serialized_end=1185 + _globals['_CONTACT']._serialized_start=3939 + _globals['_CONTACT']._serialized_end=4008 + _globals['_LICENSE']._serialized_start=4010 + _globals['_LICENSE']._serialized_end=4057 + _globals['_EXTERNALDOCUMENTATION']._serialized_start=4059 + _globals['_EXTERNALDOCUMENTATION']._serialized_end=4134 + _globals['_SCHEMA']._serialized_start=4137 + _globals['_SCHEMA']._serialized_end=4435 + _globals['_ENUMSCHEMA']._serialized_start=4438 + _globals['_ENUMSCHEMA']._serialized_end=4926 + _globals['_ENUMSCHEMA_EXTENSIONSENTRY']._serialized_start=1100 + _globals['_ENUMSCHEMA_EXTENSIONSENTRY']._serialized_end=1185 + _globals['_JSONSCHEMA']._serialized_start=4929 + _globals['_JSONSCHEMA']._serialized_end=6328 + _globals['_JSONSCHEMA_FIELDCONFIGURATION']._serialized_start=5950 + _globals['_JSONSCHEMA_FIELDCONFIGURATION']._serialized_end=6042 + _globals['_JSONSCHEMA_EXTENSIONSENTRY']._serialized_start=1100 + _globals['_JSONSCHEMA_EXTENSIONSENTRY']._serialized_end=1185 + _globals['_JSONSCHEMA_JSONSCHEMASIMPLETYPES']._serialized_start=6131 + _globals['_JSONSCHEMA_JSONSCHEMASIMPLETYPES']._serialized_end=6250 + _globals['_TAG']._serialized_start=6331 + _globals['_TAG']._serialized_end=6676 + _globals['_TAG_EXTENSIONSENTRY']._serialized_start=1100 + _globals['_TAG_EXTENSIONSENTRY']._serialized_end=1185 + _globals['_SECURITYDEFINITIONS']._serialized_start=6679 + _globals['_SECURITYDEFINITIONS']._serialized_end=6926 + _globals['_SECURITYDEFINITIONS_SECURITYENTRY']._serialized_start=6808 + _globals['_SECURITYDEFINITIONS_SECURITYENTRY']._serialized_end=6926 + _globals['_SECURITYSCHEME']._serialized_start=6929 + _globals['_SECURITYSCHEME']._serialized_end=7824 + _globals['_SECURITYSCHEME_EXTENSIONSENTRY']._serialized_start=1100 + _globals['_SECURITYSCHEME_EXTENSIONSENTRY']._serialized_end=1185 + _globals['_SECURITYSCHEME_TYPE']._serialized_start=7590 + _globals['_SECURITYSCHEME_TYPE']._serialized_end=7665 + _globals['_SECURITYSCHEME_IN']._serialized_start=7667 + _globals['_SECURITYSCHEME_IN']._serialized_end=7716 + _globals['_SECURITYSCHEME_FLOW']._serialized_start=7718 + _globals['_SECURITYSCHEME_FLOW']._serialized_end=7824 + _globals['_SECURITYREQUIREMENT']._serialized_start=7827 + _globals['_SECURITYREQUIREMENT']._serialized_end=8201 + _globals['_SECURITYREQUIREMENT_SECURITYREQUIREMENTVALUE']._serialized_start=7991 + _globals['_SECURITYREQUIREMENT_SECURITYREQUIREMENTVALUE']._serialized_end=8039 + _globals['_SECURITYREQUIREMENT_SECURITYREQUIREMENTENTRY']._serialized_start=8042 + _globals['_SECURITYREQUIREMENT_SECURITYREQUIREMENTENTRY']._serialized_end=8201 + _globals['_SCOPES']._serialized_start=8204 + _globals['_SCOPES']._serialized_end=8354 + _globals['_SCOPES_SCOPEENTRY']._serialized_start=8298 + _globals['_SCOPES_SCOPEENTRY']._serialized_end=8354 +# @@protoc_insertion_point(module_scope) diff --git a/gen/python/protoc_gen_openapiv2/options/openapiv2_pb2.pyi b/gen/python/protoc_gen_openapiv2/options/openapiv2_pb2.pyi new file mode 100644 index 0000000000..8dfc58c5c5 --- /dev/null +++ b/gen/python/protoc_gen_openapiv2/options/openapiv2_pb2.pyi @@ -0,0 +1,493 @@ +from google.protobuf import struct_pb2 as _struct_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class Scheme(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + UNKNOWN: _ClassVar[Scheme] + HTTP: _ClassVar[Scheme] + HTTPS: _ClassVar[Scheme] + WS: _ClassVar[Scheme] + WSS: _ClassVar[Scheme] +UNKNOWN: Scheme +HTTP: Scheme +HTTPS: Scheme +WS: Scheme +WSS: Scheme + +class Swagger(_message.Message): + __slots__ = ["swagger", "info", "host", "base_path", "schemes", "consumes", "produces", "responses", "security_definitions", "security", "tags", "external_docs", "extensions"] + class ResponsesEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: Response + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Response, _Mapping]] = ...) -> None: ... + class ExtensionsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: _struct_pb2.Value + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[_struct_pb2.Value, _Mapping]] = ...) -> None: ... + SWAGGER_FIELD_NUMBER: _ClassVar[int] + INFO_FIELD_NUMBER: _ClassVar[int] + HOST_FIELD_NUMBER: _ClassVar[int] + BASE_PATH_FIELD_NUMBER: _ClassVar[int] + SCHEMES_FIELD_NUMBER: _ClassVar[int] + CONSUMES_FIELD_NUMBER: _ClassVar[int] + PRODUCES_FIELD_NUMBER: _ClassVar[int] + RESPONSES_FIELD_NUMBER: _ClassVar[int] + SECURITY_DEFINITIONS_FIELD_NUMBER: _ClassVar[int] + SECURITY_FIELD_NUMBER: _ClassVar[int] + TAGS_FIELD_NUMBER: _ClassVar[int] + EXTERNAL_DOCS_FIELD_NUMBER: _ClassVar[int] + EXTENSIONS_FIELD_NUMBER: _ClassVar[int] + swagger: str + info: Info + host: str + base_path: str + schemes: _containers.RepeatedScalarFieldContainer[Scheme] + consumes: _containers.RepeatedScalarFieldContainer[str] + produces: _containers.RepeatedScalarFieldContainer[str] + responses: _containers.MessageMap[str, Response] + security_definitions: SecurityDefinitions + security: _containers.RepeatedCompositeFieldContainer[SecurityRequirement] + tags: _containers.RepeatedCompositeFieldContainer[Tag] + external_docs: ExternalDocumentation + extensions: _containers.MessageMap[str, _struct_pb2.Value] + def __init__(self, swagger: _Optional[str] = ..., info: _Optional[_Union[Info, _Mapping]] = ..., host: _Optional[str] = ..., base_path: _Optional[str] = ..., schemes: _Optional[_Iterable[_Union[Scheme, str]]] = ..., consumes: _Optional[_Iterable[str]] = ..., produces: _Optional[_Iterable[str]] = ..., responses: _Optional[_Mapping[str, Response]] = ..., security_definitions: _Optional[_Union[SecurityDefinitions, _Mapping]] = ..., security: _Optional[_Iterable[_Union[SecurityRequirement, _Mapping]]] = ..., tags: _Optional[_Iterable[_Union[Tag, _Mapping]]] = ..., external_docs: _Optional[_Union[ExternalDocumentation, _Mapping]] = ..., extensions: _Optional[_Mapping[str, _struct_pb2.Value]] = ...) -> None: ... + +class Operation(_message.Message): + __slots__ = ["tags", "summary", "description", "external_docs", "operation_id", "consumes", "produces", "responses", "schemes", "deprecated", "security", "extensions", "parameters"] + class ResponsesEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: Response + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Response, _Mapping]] = ...) -> None: ... + class ExtensionsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: _struct_pb2.Value + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[_struct_pb2.Value, _Mapping]] = ...) -> None: ... + TAGS_FIELD_NUMBER: _ClassVar[int] + SUMMARY_FIELD_NUMBER: _ClassVar[int] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + EXTERNAL_DOCS_FIELD_NUMBER: _ClassVar[int] + OPERATION_ID_FIELD_NUMBER: _ClassVar[int] + CONSUMES_FIELD_NUMBER: _ClassVar[int] + PRODUCES_FIELD_NUMBER: _ClassVar[int] + RESPONSES_FIELD_NUMBER: _ClassVar[int] + SCHEMES_FIELD_NUMBER: _ClassVar[int] + DEPRECATED_FIELD_NUMBER: _ClassVar[int] + SECURITY_FIELD_NUMBER: _ClassVar[int] + EXTENSIONS_FIELD_NUMBER: _ClassVar[int] + PARAMETERS_FIELD_NUMBER: _ClassVar[int] + tags: _containers.RepeatedScalarFieldContainer[str] + summary: str + description: str + external_docs: ExternalDocumentation + operation_id: str + consumes: _containers.RepeatedScalarFieldContainer[str] + produces: _containers.RepeatedScalarFieldContainer[str] + responses: _containers.MessageMap[str, Response] + schemes: _containers.RepeatedScalarFieldContainer[Scheme] + deprecated: bool + security: _containers.RepeatedCompositeFieldContainer[SecurityRequirement] + extensions: _containers.MessageMap[str, _struct_pb2.Value] + parameters: Parameters + def __init__(self, tags: _Optional[_Iterable[str]] = ..., summary: _Optional[str] = ..., description: _Optional[str] = ..., external_docs: _Optional[_Union[ExternalDocumentation, _Mapping]] = ..., operation_id: _Optional[str] = ..., consumes: _Optional[_Iterable[str]] = ..., produces: _Optional[_Iterable[str]] = ..., responses: _Optional[_Mapping[str, Response]] = ..., schemes: _Optional[_Iterable[_Union[Scheme, str]]] = ..., deprecated: bool = ..., security: _Optional[_Iterable[_Union[SecurityRequirement, _Mapping]]] = ..., extensions: _Optional[_Mapping[str, _struct_pb2.Value]] = ..., parameters: _Optional[_Union[Parameters, _Mapping]] = ...) -> None: ... + +class Parameters(_message.Message): + __slots__ = ["headers"] + HEADERS_FIELD_NUMBER: _ClassVar[int] + headers: _containers.RepeatedCompositeFieldContainer[HeaderParameter] + def __init__(self, headers: _Optional[_Iterable[_Union[HeaderParameter, _Mapping]]] = ...) -> None: ... + +class HeaderParameter(_message.Message): + __slots__ = ["name", "description", "type", "format", "required"] + class Type(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + UNKNOWN: _ClassVar[HeaderParameter.Type] + STRING: _ClassVar[HeaderParameter.Type] + NUMBER: _ClassVar[HeaderParameter.Type] + INTEGER: _ClassVar[HeaderParameter.Type] + BOOLEAN: _ClassVar[HeaderParameter.Type] + UNKNOWN: HeaderParameter.Type + STRING: HeaderParameter.Type + NUMBER: HeaderParameter.Type + INTEGER: HeaderParameter.Type + BOOLEAN: HeaderParameter.Type + NAME_FIELD_NUMBER: _ClassVar[int] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + FORMAT_FIELD_NUMBER: _ClassVar[int] + REQUIRED_FIELD_NUMBER: _ClassVar[int] + name: str + description: str + type: HeaderParameter.Type + format: str + required: bool + def __init__(self, name: _Optional[str] = ..., description: _Optional[str] = ..., type: _Optional[_Union[HeaderParameter.Type, str]] = ..., format: _Optional[str] = ..., required: bool = ...) -> None: ... + +class Header(_message.Message): + __slots__ = ["description", "type", "format", "default", "pattern"] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + FORMAT_FIELD_NUMBER: _ClassVar[int] + DEFAULT_FIELD_NUMBER: _ClassVar[int] + PATTERN_FIELD_NUMBER: _ClassVar[int] + description: str + type: str + format: str + default: str + pattern: str + def __init__(self, description: _Optional[str] = ..., type: _Optional[str] = ..., format: _Optional[str] = ..., default: _Optional[str] = ..., pattern: _Optional[str] = ...) -> None: ... + +class Response(_message.Message): + __slots__ = ["description", "schema", "headers", "examples", "extensions"] + class HeadersEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: Header + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Header, _Mapping]] = ...) -> None: ... + class ExamplesEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + class ExtensionsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: _struct_pb2.Value + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[_struct_pb2.Value, _Mapping]] = ...) -> None: ... + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + HEADERS_FIELD_NUMBER: _ClassVar[int] + EXAMPLES_FIELD_NUMBER: _ClassVar[int] + EXTENSIONS_FIELD_NUMBER: _ClassVar[int] + description: str + schema: Schema + headers: _containers.MessageMap[str, Header] + examples: _containers.ScalarMap[str, str] + extensions: _containers.MessageMap[str, _struct_pb2.Value] + def __init__(self, description: _Optional[str] = ..., schema: _Optional[_Union[Schema, _Mapping]] = ..., headers: _Optional[_Mapping[str, Header]] = ..., examples: _Optional[_Mapping[str, str]] = ..., extensions: _Optional[_Mapping[str, _struct_pb2.Value]] = ...) -> None: ... + +class Info(_message.Message): + __slots__ = ["title", "description", "terms_of_service", "contact", "license", "version", "extensions"] + class ExtensionsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: _struct_pb2.Value + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[_struct_pb2.Value, _Mapping]] = ...) -> None: ... + TITLE_FIELD_NUMBER: _ClassVar[int] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + TERMS_OF_SERVICE_FIELD_NUMBER: _ClassVar[int] + CONTACT_FIELD_NUMBER: _ClassVar[int] + LICENSE_FIELD_NUMBER: _ClassVar[int] + VERSION_FIELD_NUMBER: _ClassVar[int] + EXTENSIONS_FIELD_NUMBER: _ClassVar[int] + title: str + description: str + terms_of_service: str + contact: Contact + license: License + version: str + extensions: _containers.MessageMap[str, _struct_pb2.Value] + def __init__(self, title: _Optional[str] = ..., description: _Optional[str] = ..., terms_of_service: _Optional[str] = ..., contact: _Optional[_Union[Contact, _Mapping]] = ..., license: _Optional[_Union[License, _Mapping]] = ..., version: _Optional[str] = ..., extensions: _Optional[_Mapping[str, _struct_pb2.Value]] = ...) -> None: ... + +class Contact(_message.Message): + __slots__ = ["name", "url", "email"] + NAME_FIELD_NUMBER: _ClassVar[int] + URL_FIELD_NUMBER: _ClassVar[int] + EMAIL_FIELD_NUMBER: _ClassVar[int] + name: str + url: str + email: str + def __init__(self, name: _Optional[str] = ..., url: _Optional[str] = ..., email: _Optional[str] = ...) -> None: ... + +class License(_message.Message): + __slots__ = ["name", "url"] + NAME_FIELD_NUMBER: _ClassVar[int] + URL_FIELD_NUMBER: _ClassVar[int] + name: str + url: str + def __init__(self, name: _Optional[str] = ..., url: _Optional[str] = ...) -> None: ... + +class ExternalDocumentation(_message.Message): + __slots__ = ["description", "url"] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + URL_FIELD_NUMBER: _ClassVar[int] + description: str + url: str + def __init__(self, description: _Optional[str] = ..., url: _Optional[str] = ...) -> None: ... + +class Schema(_message.Message): + __slots__ = ["json_schema", "discriminator", "read_only", "external_docs", "example"] + JSON_SCHEMA_FIELD_NUMBER: _ClassVar[int] + DISCRIMINATOR_FIELD_NUMBER: _ClassVar[int] + READ_ONLY_FIELD_NUMBER: _ClassVar[int] + EXTERNAL_DOCS_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + json_schema: JSONSchema + discriminator: str + read_only: bool + external_docs: ExternalDocumentation + example: str + def __init__(self, json_schema: _Optional[_Union[JSONSchema, _Mapping]] = ..., discriminator: _Optional[str] = ..., read_only: bool = ..., external_docs: _Optional[_Union[ExternalDocumentation, _Mapping]] = ..., example: _Optional[str] = ...) -> None: ... + +class EnumSchema(_message.Message): + __slots__ = ["description", "default", "title", "required", "read_only", "external_docs", "example", "ref", "extensions"] + class ExtensionsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: _struct_pb2.Value + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[_struct_pb2.Value, _Mapping]] = ...) -> None: ... + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + DEFAULT_FIELD_NUMBER: _ClassVar[int] + TITLE_FIELD_NUMBER: _ClassVar[int] + REQUIRED_FIELD_NUMBER: _ClassVar[int] + READ_ONLY_FIELD_NUMBER: _ClassVar[int] + EXTERNAL_DOCS_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + REF_FIELD_NUMBER: _ClassVar[int] + EXTENSIONS_FIELD_NUMBER: _ClassVar[int] + description: str + default: str + title: str + required: bool + read_only: bool + external_docs: ExternalDocumentation + example: str + ref: str + extensions: _containers.MessageMap[str, _struct_pb2.Value] + def __init__(self, description: _Optional[str] = ..., default: _Optional[str] = ..., title: _Optional[str] = ..., required: bool = ..., read_only: bool = ..., external_docs: _Optional[_Union[ExternalDocumentation, _Mapping]] = ..., example: _Optional[str] = ..., ref: _Optional[str] = ..., extensions: _Optional[_Mapping[str, _struct_pb2.Value]] = ...) -> None: ... + +class JSONSchema(_message.Message): + __slots__ = ["ref", "title", "description", "default", "read_only", "example", "multiple_of", "maximum", "exclusive_maximum", "minimum", "exclusive_minimum", "max_length", "min_length", "pattern", "max_items", "min_items", "unique_items", "max_properties", "min_properties", "required", "array", "type", "format", "enum", "field_configuration", "extensions"] + class JSONSchemaSimpleTypes(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + UNKNOWN: _ClassVar[JSONSchema.JSONSchemaSimpleTypes] + ARRAY: _ClassVar[JSONSchema.JSONSchemaSimpleTypes] + BOOLEAN: _ClassVar[JSONSchema.JSONSchemaSimpleTypes] + INTEGER: _ClassVar[JSONSchema.JSONSchemaSimpleTypes] + NULL: _ClassVar[JSONSchema.JSONSchemaSimpleTypes] + NUMBER: _ClassVar[JSONSchema.JSONSchemaSimpleTypes] + OBJECT: _ClassVar[JSONSchema.JSONSchemaSimpleTypes] + STRING: _ClassVar[JSONSchema.JSONSchemaSimpleTypes] + UNKNOWN: JSONSchema.JSONSchemaSimpleTypes + ARRAY: JSONSchema.JSONSchemaSimpleTypes + BOOLEAN: JSONSchema.JSONSchemaSimpleTypes + INTEGER: JSONSchema.JSONSchemaSimpleTypes + NULL: JSONSchema.JSONSchemaSimpleTypes + NUMBER: JSONSchema.JSONSchemaSimpleTypes + OBJECT: JSONSchema.JSONSchemaSimpleTypes + STRING: JSONSchema.JSONSchemaSimpleTypes + class FieldConfiguration(_message.Message): + __slots__ = ["path_param_name", "deprecated"] + PATH_PARAM_NAME_FIELD_NUMBER: _ClassVar[int] + DEPRECATED_FIELD_NUMBER: _ClassVar[int] + path_param_name: str + deprecated: bool + def __init__(self, path_param_name: _Optional[str] = ..., deprecated: bool = ...) -> None: ... + class ExtensionsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: _struct_pb2.Value + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[_struct_pb2.Value, _Mapping]] = ...) -> None: ... + REF_FIELD_NUMBER: _ClassVar[int] + TITLE_FIELD_NUMBER: _ClassVar[int] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + DEFAULT_FIELD_NUMBER: _ClassVar[int] + READ_ONLY_FIELD_NUMBER: _ClassVar[int] + EXAMPLE_FIELD_NUMBER: _ClassVar[int] + MULTIPLE_OF_FIELD_NUMBER: _ClassVar[int] + MAXIMUM_FIELD_NUMBER: _ClassVar[int] + EXCLUSIVE_MAXIMUM_FIELD_NUMBER: _ClassVar[int] + MINIMUM_FIELD_NUMBER: _ClassVar[int] + EXCLUSIVE_MINIMUM_FIELD_NUMBER: _ClassVar[int] + MAX_LENGTH_FIELD_NUMBER: _ClassVar[int] + MIN_LENGTH_FIELD_NUMBER: _ClassVar[int] + PATTERN_FIELD_NUMBER: _ClassVar[int] + MAX_ITEMS_FIELD_NUMBER: _ClassVar[int] + MIN_ITEMS_FIELD_NUMBER: _ClassVar[int] + UNIQUE_ITEMS_FIELD_NUMBER: _ClassVar[int] + MAX_PROPERTIES_FIELD_NUMBER: _ClassVar[int] + MIN_PROPERTIES_FIELD_NUMBER: _ClassVar[int] + REQUIRED_FIELD_NUMBER: _ClassVar[int] + ARRAY_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + FORMAT_FIELD_NUMBER: _ClassVar[int] + ENUM_FIELD_NUMBER: _ClassVar[int] + FIELD_CONFIGURATION_FIELD_NUMBER: _ClassVar[int] + EXTENSIONS_FIELD_NUMBER: _ClassVar[int] + ref: str + title: str + description: str + default: str + read_only: bool + example: str + multiple_of: float + maximum: float + exclusive_maximum: bool + minimum: float + exclusive_minimum: bool + max_length: int + min_length: int + pattern: str + max_items: int + min_items: int + unique_items: bool + max_properties: int + min_properties: int + required: _containers.RepeatedScalarFieldContainer[str] + array: _containers.RepeatedScalarFieldContainer[str] + type: _containers.RepeatedScalarFieldContainer[JSONSchema.JSONSchemaSimpleTypes] + format: str + enum: _containers.RepeatedScalarFieldContainer[str] + field_configuration: JSONSchema.FieldConfiguration + extensions: _containers.MessageMap[str, _struct_pb2.Value] + def __init__(self, ref: _Optional[str] = ..., title: _Optional[str] = ..., description: _Optional[str] = ..., default: _Optional[str] = ..., read_only: bool = ..., example: _Optional[str] = ..., multiple_of: _Optional[float] = ..., maximum: _Optional[float] = ..., exclusive_maximum: bool = ..., minimum: _Optional[float] = ..., exclusive_minimum: bool = ..., max_length: _Optional[int] = ..., min_length: _Optional[int] = ..., pattern: _Optional[str] = ..., max_items: _Optional[int] = ..., min_items: _Optional[int] = ..., unique_items: bool = ..., max_properties: _Optional[int] = ..., min_properties: _Optional[int] = ..., required: _Optional[_Iterable[str]] = ..., array: _Optional[_Iterable[str]] = ..., type: _Optional[_Iterable[_Union[JSONSchema.JSONSchemaSimpleTypes, str]]] = ..., format: _Optional[str] = ..., enum: _Optional[_Iterable[str]] = ..., field_configuration: _Optional[_Union[JSONSchema.FieldConfiguration, _Mapping]] = ..., extensions: _Optional[_Mapping[str, _struct_pb2.Value]] = ...) -> None: ... + +class Tag(_message.Message): + __slots__ = ["name", "description", "external_docs", "extensions"] + class ExtensionsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: _struct_pb2.Value + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[_struct_pb2.Value, _Mapping]] = ...) -> None: ... + NAME_FIELD_NUMBER: _ClassVar[int] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + EXTERNAL_DOCS_FIELD_NUMBER: _ClassVar[int] + EXTENSIONS_FIELD_NUMBER: _ClassVar[int] + name: str + description: str + external_docs: ExternalDocumentation + extensions: _containers.MessageMap[str, _struct_pb2.Value] + def __init__(self, name: _Optional[str] = ..., description: _Optional[str] = ..., external_docs: _Optional[_Union[ExternalDocumentation, _Mapping]] = ..., extensions: _Optional[_Mapping[str, _struct_pb2.Value]] = ...) -> None: ... + +class SecurityDefinitions(_message.Message): + __slots__ = ["security"] + class SecurityEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: SecurityScheme + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[SecurityScheme, _Mapping]] = ...) -> None: ... + SECURITY_FIELD_NUMBER: _ClassVar[int] + security: _containers.MessageMap[str, SecurityScheme] + def __init__(self, security: _Optional[_Mapping[str, SecurityScheme]] = ...) -> None: ... + +class SecurityScheme(_message.Message): + __slots__ = ["type", "description", "name", "flow", "authorization_url", "token_url", "scopes", "extensions"] + class Type(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + TYPE_INVALID: _ClassVar[SecurityScheme.Type] + TYPE_BASIC: _ClassVar[SecurityScheme.Type] + TYPE_API_KEY: _ClassVar[SecurityScheme.Type] + TYPE_OAUTH2: _ClassVar[SecurityScheme.Type] + TYPE_INVALID: SecurityScheme.Type + TYPE_BASIC: SecurityScheme.Type + TYPE_API_KEY: SecurityScheme.Type + TYPE_OAUTH2: SecurityScheme.Type + class In(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + IN_INVALID: _ClassVar[SecurityScheme.In] + IN_QUERY: _ClassVar[SecurityScheme.In] + IN_HEADER: _ClassVar[SecurityScheme.In] + IN_INVALID: SecurityScheme.In + IN_QUERY: SecurityScheme.In + IN_HEADER: SecurityScheme.In + class Flow(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + FLOW_INVALID: _ClassVar[SecurityScheme.Flow] + FLOW_IMPLICIT: _ClassVar[SecurityScheme.Flow] + FLOW_PASSWORD: _ClassVar[SecurityScheme.Flow] + FLOW_APPLICATION: _ClassVar[SecurityScheme.Flow] + FLOW_ACCESS_CODE: _ClassVar[SecurityScheme.Flow] + FLOW_INVALID: SecurityScheme.Flow + FLOW_IMPLICIT: SecurityScheme.Flow + FLOW_PASSWORD: SecurityScheme.Flow + FLOW_APPLICATION: SecurityScheme.Flow + FLOW_ACCESS_CODE: SecurityScheme.Flow + class ExtensionsEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: _struct_pb2.Value + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[_struct_pb2.Value, _Mapping]] = ...) -> None: ... + TYPE_FIELD_NUMBER: _ClassVar[int] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + IN_FIELD_NUMBER: _ClassVar[int] + FLOW_FIELD_NUMBER: _ClassVar[int] + AUTHORIZATION_URL_FIELD_NUMBER: _ClassVar[int] + TOKEN_URL_FIELD_NUMBER: _ClassVar[int] + SCOPES_FIELD_NUMBER: _ClassVar[int] + EXTENSIONS_FIELD_NUMBER: _ClassVar[int] + type: SecurityScheme.Type + description: str + name: str + flow: SecurityScheme.Flow + authorization_url: str + token_url: str + scopes: Scopes + extensions: _containers.MessageMap[str, _struct_pb2.Value] + def __init__(self, type: _Optional[_Union[SecurityScheme.Type, str]] = ..., description: _Optional[str] = ..., name: _Optional[str] = ..., flow: _Optional[_Union[SecurityScheme.Flow, str]] = ..., authorization_url: _Optional[str] = ..., token_url: _Optional[str] = ..., scopes: _Optional[_Union[Scopes, _Mapping]] = ..., extensions: _Optional[_Mapping[str, _struct_pb2.Value]] = ..., **kwargs) -> None: ... + +class SecurityRequirement(_message.Message): + __slots__ = ["security_requirement"] + class SecurityRequirementValue(_message.Message): + __slots__ = ["scope"] + SCOPE_FIELD_NUMBER: _ClassVar[int] + scope: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, scope: _Optional[_Iterable[str]] = ...) -> None: ... + class SecurityRequirementEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: SecurityRequirement.SecurityRequirementValue + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[SecurityRequirement.SecurityRequirementValue, _Mapping]] = ...) -> None: ... + SECURITY_REQUIREMENT_FIELD_NUMBER: _ClassVar[int] + security_requirement: _containers.MessageMap[str, SecurityRequirement.SecurityRequirementValue] + def __init__(self, security_requirement: _Optional[_Mapping[str, SecurityRequirement.SecurityRequirementValue]] = ...) -> None: ... + +class Scopes(_message.Message): + __slots__ = ["scope"] + class ScopeEntry(_message.Message): + __slots__ = ["key", "value"] + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + SCOPE_FIELD_NUMBER: _ClassVar[int] + scope: _containers.ScalarMap[str, str] + def __init__(self, scope: _Optional[_Mapping[str, str]] = ...) -> None: ... diff --git a/gen/python/protoc_gen_openapiv2/options/openapiv2_pb2_grpc.py b/gen/python/protoc_gen_openapiv2/options/openapiv2_pb2_grpc.py new file mode 100644 index 0000000000..2daafffebf --- /dev/null +++ b/gen/python/protoc_gen_openapiv2/options/openapiv2_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/gen/python/pyproject.toml b/gen/python/pyproject.toml new file mode 100644 index 0000000000..5d69d55360 --- /dev/null +++ b/gen/python/pyproject.toml @@ -0,0 +1,45 @@ +[build-system] +requires = ["setuptools", "setuptools_scm"] +build-backend = "setuptools.build_meta" + +[project] +name = "flyteidl2" +dynamic = ["version"] +authors = [{ name = "Union Eng", email = "support@union.ai" }] +description = "IDL for Flyte" +readme = { file = "README.md", content-type = "text/markdown" } +requires-python = ">=3.10" +dependencies = [ + 'googleapis-common-protos', + 'protoc-gen-openapiv2', + 'protobuf>=4.21.1', + "protovalidate>=1.0.0", +] +classifiers = [ + "Intended Audience :: Science/Research", + "Intended Audience :: Developers", + "License :: OSI Approved :: Apache Software License", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Topic :: Scientific/Engineering", + "Topic :: Scientific/Engineering :: Artificial Intelligence", + "Topic :: Software Development", + "Topic :: Software Development :: Libraries", + "Topic :: Software Development :: Libraries :: Python Modules", +] +license-files = ["licenses/*.txt", "LICENSE"] + +[tool.setuptools] +include-package-data = true + +# Intentionally leaving out the google folder, which contains googleapis-common-protos. This library is a dependency +# of too many google libraries including grpcio-status which flyte already depends on, so don't want to +# risk version conflicts. +[tool.setuptools.packages.find] +include = ["flyteidl2*", "buf*"] +exclude = ["build*"] + +[tool.setuptools_scm] +root = "../../" diff --git a/gen/python/setup.py b/gen/python/setup.py new file mode 100644 index 0000000000..7f576889bf --- /dev/null +++ b/gen/python/setup.py @@ -0,0 +1,6 @@ +from setuptools import setup + + +__version__ = "0.0.0+develop" + +setup() \ No newline at end of file diff --git a/gen/python/uv.lock b/gen/python/uv.lock new file mode 100644 index 0000000000..7b25950d93 --- /dev/null +++ b/gen/python/uv.lock @@ -0,0 +1,248 @@ +version = 1 +revision = 3 +requires-python = ">=3.10" +resolution-markers = [ + "python_full_version == '3.13.*'", + "python_full_version == '3.12.*'", + "python_full_version < '3.12' or python_full_version >= '3.14'", +] + +[[package]] +name = "cel-python" +version = "0.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jmespath" }, + { name = "lark" }, + { name = "python-dateutil" }, + { name = "pyyaml" }, + { name = "types-python-dateutil" }, + { name = "types-pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/10/87/85a1b99b98f6466bb87d40df636626385945ae82348e82cd97d44313f612/cel_python-0.2.0.tar.gz", hash = "sha256:75de72a5cf223ec690b236f0cc24da267219e667bd3e7f8f4f20595fcc1c0c0f", size = 67185, upload-time = "2025-02-14T11:42:21.882Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/28/08871462a0347b3e707658a8308be6f979167488a2196f93b402c2ea7170/cel_python-0.2.0-py3-none-any.whl", hash = "sha256:478ff73def7b39d51e6982f95d937a57c2b088c491c578fe5cecdbd79f476f60", size = 71337, upload-time = "2025-02-14T11:42:19.996Z" }, +] + +[[package]] +name = "flyteidl2" +source = { editable = "." } +dependencies = [ + { name = "googleapis-common-protos" }, + { name = "protobuf" }, + { name = "protoc-gen-openapiv2" }, + { name = "protovalidate" }, +] + +[package.metadata] +requires-dist = [ + { name = "googleapis-common-protos" }, + { name = "protobuf", specifier = ">=4.21.1" }, + { name = "protoc-gen-openapiv2" }, + { name = "protovalidate", specifier = ">=1.0.0" }, +] + +[[package]] +name = "google-re2" +version = "1.1.20250805" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/93/ed/7caa25b34a201ef8db5a635e03ca71c926caff92aba1b17e86b78190de43/google_re2-1.1.20250805.tar.gz", hash = "sha256:c55d9f7c92a814eb53918a7b38e5ba5eaa1c99548321acb826da9532781af5b5", size = 11698, upload-time = "2025-08-05T19:30:24.345Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/9c/e120dc14daa0b6d5e0ddb659e0f132292abf22fad3563c017b73ab549a01/google_re2-1.1.20250805-1-cp310-cp310-macosx_13_0_arm64.whl", hash = "sha256:7d2a7dea1448733184a99516a41f28ffcfc9eda345697a14fd5c6d8144b60841", size = 483036, upload-time = "2025-08-05T19:29:05.84Z" }, + { url = "https://files.pythonhosted.org/packages/b2/b6/981ae8734410617c0cb6d32b059a6833ca980bbe6e65840bc8e68f5697ea/google_re2-1.1.20250805-1-cp310-cp310-macosx_13_0_x86_64.whl", hash = "sha256:51b4e3c5e6f3f74193666295385b44e1043e55cf98e4b933fe11a0d7a2457a67", size = 514139, upload-time = "2025-08-05T19:29:07.721Z" }, + { url = "https://files.pythonhosted.org/packages/73/56/d1c1c729b7e356dd8b8224bf1873d90fa94c350eddce0ef7da775440a552/google_re2-1.1.20250805-1-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:0c43d2120ba62e8da4d064dcb5b5c9ac103bfe4cd71a5472055a7f02298b544b", size = 484050, upload-time = "2025-08-05T19:29:09.163Z" }, + { url = "https://files.pythonhosted.org/packages/1d/78/a07b752d7d879f25b6de12f442ebfd57be9acc79857f16c026ba989afad0/google_re2-1.1.20250805-1-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:46eb32ca99136e5ff76b33195b37d41342afcc505f4b60309a4159008f80b064", size = 515591, upload-time = "2025-08-05T19:29:10.742Z" }, + { url = "https://files.pythonhosted.org/packages/0b/4a/651971a6ece6a85ff6598bcf801cb0c7ee20a251b9631b7b5d4886642818/google_re2-1.1.20250805-1-cp310-cp310-macosx_15_0_arm64.whl", hash = "sha256:eaf8b912020ec9bcc1811f64478e2dfb82907e502b718ad4b263045820519595", size = 484613, upload-time = "2025-08-05T19:29:12.348Z" }, + { url = "https://files.pythonhosted.org/packages/fa/ad/8768a99b2b79b14806b7da89f783f6828f540469169066cf3a7bb16cbe44/google_re2-1.1.20250805-1-cp310-cp310-macosx_15_0_x86_64.whl", hash = "sha256:0df2591355131457f9a008b3bd8fbdb104f8344b75d150fd90ddc0bc19b80935", size = 511041, upload-time = "2025-08-05T19:29:13.87Z" }, + { url = "https://files.pythonhosted.org/packages/68/34/997ee9e113398c5ca6ec8bb5c2d210e7931e44b1fbd38024d09dabd2ba9a/google_re2-1.1.20250805-1-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fb56c6e7c8fe2eaf045b987dbf8dfc979f61a21e6446dd8b3c0e4028f9ff8611", size = 572722, upload-time = "2025-08-05T19:29:15.435Z" }, + { url = "https://files.pythonhosted.org/packages/51/e2/f99887835200a961a957dab4208d00ae344a8906ed9e0bb1ce578aec87a1/google_re2-1.1.20250805-1-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7f2124ccc4e06c1841e18360edbc379f050b8dcb54096293e2e6e90b5f913f92", size = 588956, upload-time = "2025-08-05T19:29:16.975Z" }, + { url = "https://files.pythonhosted.org/packages/4c/fc/bd56b2133ce1d6853e4abafa89685860eda725a2fe62c233a30cfe928abb/google_re2-1.1.20250805-1-cp310-cp310-win32.whl", hash = "sha256:0bcf2acdc32a3890ddfca87fa846806b6db200a059a83ab114e6ab390beaf10e", size = 432851, upload-time = "2025-08-05T19:29:18.568Z" }, + { url = "https://files.pythonhosted.org/packages/a8/ac/21473b4de4a829bc9822d810fc1a26c7abdbee76c60a915a8ade0dae6372/google_re2-1.1.20250805-1-cp310-cp310-win_amd64.whl", hash = "sha256:8c6da22b158459e5a592fcd66a9e99347f517284d91d61b6ff2befff3eb79339", size = 490154, upload-time = "2025-08-05T19:29:19.762Z" }, + { url = "https://files.pythonhosted.org/packages/ec/6f/c99a04f13114282362bf73dd1a79e96b92ed80ed47bf1f57744646753e08/google_re2-1.1.20250805-1-cp311-cp311-macosx_13_0_arm64.whl", hash = "sha256:e7f7e960002c702ae2c0aff3b8db895ded37006ac7aa0c158743fb20dcd485c2", size = 483730, upload-time = "2025-08-05T19:29:21.181Z" }, + { url = "https://files.pythonhosted.org/packages/23/c8/994a5fef87eb977d06ff8dfe7bb59ba31f535d3f2622334b6b32f1b65528/google_re2-1.1.20250805-1-cp311-cp311-macosx_13_0_x86_64.whl", hash = "sha256:bfacaa9b274871796bfd0750e23f804ff632a5397b830c640449d3d57b3d148f", size = 515513, upload-time = "2025-08-05T19:29:22.63Z" }, + { url = "https://files.pythonhosted.org/packages/30/25/81672efc1d0cce43813e0b3bffc14c3d32e102cf254c9d280bf4e5194664/google_re2-1.1.20250805-1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:c4f72b275ec6b5ef6e3215dab9392aefc2e8f8590d0c3d8b266e6a913503d2a1", size = 485374, upload-time = "2025-08-05T19:29:23.925Z" }, + { url = "https://files.pythonhosted.org/packages/da/04/7a3361618217d401203a9eb34712c824e9645f7d2830d1e804eb9859374c/google_re2-1.1.20250805-1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:c6b5550a9767e444b17a9c3c4b020c51629282748d77244d833aacbd765f28fe", size = 517105, upload-time = "2025-08-05T19:29:25.196Z" }, + { url = "https://files.pythonhosted.org/packages/38/97/29e8097e449b0af993acd7d7d658ecfac3914ac501e6c6d40ffcebc03b8e/google_re2-1.1.20250805-1-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:4c1e5ec68dfe2e0866f14468600e2e2928dcfe684c0f2fbeda8d16f14f909141", size = 485756, upload-time = "2025-08-05T19:29:26.975Z" }, + { url = "https://files.pythonhosted.org/packages/1c/88/cb3647eb92c991d93fde8b1fefddd52ff3bb45a5d1c20185e2fd24e1e5fa/google_re2-1.1.20250805-1-cp311-cp311-macosx_15_0_x86_64.whl", hash = "sha256:336d6830888ea2abdc1744d201e19cf76c4f001cf821bed3e8844c1899bcbdaf", size = 512227, upload-time = "2025-08-05T19:29:28.207Z" }, + { url = "https://files.pythonhosted.org/packages/b8/fe/33e357bb8d090a4879e9e257be577740d1b5d762686b4fa448f050b15caf/google_re2-1.1.20250805-1-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:52a153ce37ccfd5429257a91d68f4338fe2809711bff64c7ab84c97ddef2de25", size = 573694, upload-time = "2025-08-05T19:29:29.52Z" }, + { url = "https://files.pythonhosted.org/packages/96/97/e1648859b140b76717319a8d8aceec3365e354ea9ff0690d0fbbcb5774e3/google_re2-1.1.20250805-1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2ffc79fe2f4be9c5e3e8bb04c8e84e0c9a27b5f08ad5103779b084005e99d220", size = 590760, upload-time = "2025-08-05T19:29:30.967Z" }, + { url = "https://files.pythonhosted.org/packages/af/0a/1dae50eece5fe4f53503f47f8535ee7f8667e2f84dbbf87f0fa8942678b6/google_re2-1.1.20250805-1-cp311-cp311-win32.whl", hash = "sha256:2cfccbbd8577250406a3a3ff1b5d3ee21a479e3f1a01f78042d4d15c461eca1e", size = 434080, upload-time = "2025-08-05T19:29:32.578Z" }, + { url = "https://files.pythonhosted.org/packages/d2/b8/1c4e100d2b1dac7c4ab52d18b8c3060a835f1e2b9dc0802024313fa69277/google_re2-1.1.20250805-1-cp311-cp311-win_amd64.whl", hash = "sha256:4d0669fed9f9f993c5cffae42d7193da752e5b4e42e95b0e9ee0b95de9fcd8ad", size = 490954, upload-time = "2025-08-05T19:29:33.784Z" }, + { url = "https://files.pythonhosted.org/packages/8d/ac/3ed55b2f70cb1b091a59c5242376524e68de88d0280ea0be7c8f4754a37d/google_re2-1.1.20250805-1-cp311-cp311-win_arm64.whl", hash = "sha256:50495e5f783e0c1577384bac75455a799904158b5077284c70e6a9510995f3be", size = 642137, upload-time = "2025-08-05T19:29:34.973Z" }, + { url = "https://files.pythonhosted.org/packages/78/b5/5ed6ffcb1f33348e7f212819d1082f125bd224c89aef842b78b63f9a97e0/google_re2-1.1.20250805-1-cp312-cp312-macosx_13_0_arm64.whl", hash = "sha256:39f81ff026701533593ffb43acd999d11b8ff769d2234e2083c9ae38d02a01a4", size = 485610, upload-time = "2025-08-05T19:29:36.243Z" }, + { url = "https://files.pythonhosted.org/packages/ff/e3/b4db34e633b0c5c880c2a3371eedcab600ea0c04a51a2509cda09c913e1e/google_re2-1.1.20250805-1-cp312-cp312-macosx_13_0_x86_64.whl", hash = "sha256:7d26aecd8850ec469bf8ae7d3a1ad26b1b1c0477400351ff5df181ef5dff68f0", size = 518722, upload-time = "2025-08-05T19:29:37.51Z" }, + { url = "https://files.pythonhosted.org/packages/b9/96/ca6f0ff5693558ba104007cf7cc8187d3d47c5d01af06c4204bbe9d8d160/google_re2-1.1.20250805-1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:f45314ef7b22c28a1c43469d522398068af4bd1b59839c831033723c782c7402", size = 486962, upload-time = "2025-08-05T19:29:38.775Z" }, + { url = "https://files.pythonhosted.org/packages/e9/e5/41e316d9a160bca99f7a4bff2dc9f4a9b8a3b3b927a610fdf7717f0af2f7/google_re2-1.1.20250805-1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:13e8b83655fcb97d7190d8c07a2886dd5bf9c55935419c98a4b7f09cc6e2019d", size = 520209, upload-time = "2025-08-05T19:29:39.967Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c6/30d8c5988c640d6de7a9b0739bc33d9b2a4d00bf12a7e6c0abfebc0c365b/google_re2-1.1.20250805-1-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:9c17c678b3bf2ca874c74b898a21b534d3e60123eda8ef18dde1c1932d142b1f", size = 487152, upload-time = "2025-08-05T19:29:41.596Z" }, + { url = "https://files.pythonhosted.org/packages/73/1f/d3f04e5c66c2bf235cb449f4e7372596375f6a8537eaeaa35f076927bd0b/google_re2-1.1.20250805-1-cp312-cp312-macosx_15_0_x86_64.whl", hash = "sha256:a848f44752286372cfb0ff225a836ed7b02738b29ca31ed3c58e70dc7d584537", size = 514497, upload-time = "2025-08-05T19:29:43.196Z" }, + { url = "https://files.pythonhosted.org/packages/2b/e3/14c2999896aa5bc111a18fe41c56283f222179076c52d515ea5c3e0043ad/google_re2-1.1.20250805-1-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a90f090081e415ee182a01f4113076ad5707c5501ae985c8edc5bfc439cbdee6", size = 572418, upload-time = "2025-08-05T19:29:44.478Z" }, + { url = "https://files.pythonhosted.org/packages/5f/ad/7c4e61bccbfaf036011960ebbc8743971a34f1bd1b07d1f379b2feb81296/google_re2-1.1.20250805-1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9b5749bcbb363cdfdff5da14aa0c53de28f918662d0b6f546af31f96c8fd46dd", size = 591359, upload-time = "2025-08-05T19:29:46.186Z" }, + { url = "https://files.pythonhosted.org/packages/9f/fe/f1a0966c76a52467879f951ba1ffbbc5f2a4a0ecc2f2c2e40b131613b9e9/google_re2-1.1.20250805-1-cp312-cp312-win32.whl", hash = "sha256:19689531ce9839813035663df68aa49074c92e426b20095e5e665521c55c1cab", size = 433756, upload-time = "2025-08-05T19:29:47.416Z" }, + { url = "https://files.pythonhosted.org/packages/7e/27/f20d98d5121479eed67127eafb3ed99531d9bc43fac2e75e04938950b2ca/google_re2-1.1.20250805-1-cp312-cp312-win_amd64.whl", hash = "sha256:b533077b8a1c120c5f446e6734893d2a18d098e3edde149dda6a9ff9a3e2e7d2", size = 491663, upload-time = "2025-08-05T19:29:48.726Z" }, + { url = "https://files.pythonhosted.org/packages/80/5a/8997a1e00fcd75db5a6c1243ee512f174a2e266f0017d2a209de36007cef/google_re2-1.1.20250805-1-cp312-cp312-win_arm64.whl", hash = "sha256:3a0193237b274faf57492efbeecc9be5818f3852f186ea5c672490b49da4d124", size = 642623, upload-time = "2025-08-05T19:29:50.172Z" }, + { url = "https://files.pythonhosted.org/packages/79/c0/f4b5c894335bc7d276e5be58d72e24811db8d5900dfdf37069528d65b73c/google_re2-1.1.20250805-1-cp313-cp313-macosx_13_0_arm64.whl", hash = "sha256:049732fce70dea6246f035027e512f7cbc22fa9c7f2969c503cd0abb0fcfc674", size = 485546, upload-time = "2025-08-05T19:29:51.461Z" }, + { url = "https://files.pythonhosted.org/packages/dd/a8/afcddbf964add57569cc0081e99fc968e1bc9d65c34612e0a63ec2085606/google_re2-1.1.20250805-1-cp313-cp313-macosx_13_0_x86_64.whl", hash = "sha256:552e37f08514778d98b6d27aea2abd80efca19c4812ca6388175fd5e54d08229", size = 518842, upload-time = "2025-08-05T19:29:52.826Z" }, + { url = "https://files.pythonhosted.org/packages/02/a4/82063779d7c6c56136b8217c022f6d95c490d73ccc78ca5e57158fd91855/google_re2-1.1.20250805-1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:6d452dab6bd9dedecef4cc4a0ba22203f5c4273395fd7896fe9ed0cc85643b11", size = 487043, upload-time = "2025-08-05T19:29:54.526Z" }, + { url = "https://files.pythonhosted.org/packages/5d/06/aee9f7315c00c77e1f3653d44a356c68c2066bc1de516c1bd473b6d827c5/google_re2-1.1.20250805-1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:358f497682cb5d57f0dd107944f7a2167226d31fb5211cfd187ec16cb5275355", size = 520233, upload-time = "2025-08-05T19:29:55.8Z" }, + { url = "https://files.pythonhosted.org/packages/08/7f/d28e64ce85604635da2870c99ac8c8c3e078aaba1f132ecea239f65f0030/google_re2-1.1.20250805-1-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:af66c822179f7f412e4c1fcc8b5ca84885e24ba77c2ee8aa7364f19131b77e7d", size = 487233, upload-time = "2025-08-05T19:29:57.531Z" }, + { url = "https://files.pythonhosted.org/packages/ff/37/bc22d185861461aafa8e8193a1e22f9eac1217e9bec9ac34b681f1c10bd9/google_re2-1.1.20250805-1-cp313-cp313-macosx_15_0_x86_64.whl", hash = "sha256:555b6183fa1a6f54117ec0eda333b98d96620c5d59b563a1dbe2a3eddf64ca24", size = 514473, upload-time = "2025-08-05T19:29:58.826Z" }, + { url = "https://files.pythonhosted.org/packages/56/05/a6da22582817396e30931e0d292d2ef4819c2eea3fb21b08661f9a6f3106/google_re2-1.1.20250805-1-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e7dfeab6a641a8e6c8ac1cb7fa40b4d2cb91571a3c4bcc840a6d1245d37c33bb", size = 572370, upload-time = "2025-08-05T19:30:00.164Z" }, + { url = "https://files.pythonhosted.org/packages/ec/14/feb54f3f11522f334294a916dffb54ab36dfaba47c7c8d0e091aec1084f1/google_re2-1.1.20250805-1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8b328e6d75e7b1e161dd834c42a7e1762d2e03919453257a64712a5bda798226", size = 591407, upload-time = "2025-08-05T19:30:01.62Z" }, + { url = "https://files.pythonhosted.org/packages/f3/b2/7c785a0596e8535794b5c21d27c3081928748acd556a4a0ef3b2c8338881/google_re2-1.1.20250805-1-cp313-cp313-win32.whl", hash = "sha256:eb1c398eaec3c8ffe74fe7064008c81f452ca5bdf12c2538acc4c087d043a6e1", size = 433845, upload-time = "2025-08-05T19:30:03.46Z" }, + { url = "https://files.pythonhosted.org/packages/5b/1d/af1fc1a5247d6549e67716bcb5e790761bb550026e659dfcfd89408389fd/google_re2-1.1.20250805-1-cp313-cp313-win_amd64.whl", hash = "sha256:18f72952c71de0ace48fbe0ca9928bd7b7bbe1062f685c0d1326a0205966f2dc", size = 491718, upload-time = "2025-08-05T19:30:05.14Z" }, + { url = "https://files.pythonhosted.org/packages/eb/89/39fd1d16a9cbda45cf55b920fac4840fc16ca668b96333f1a5d8931e1ec0/google_re2-1.1.20250805-1-cp313-cp313-win_arm64.whl", hash = "sha256:149ec3ce1a4711daf45aab4fc7d5926f9e3082ee2c6ea138043c27e64ff1d782", size = 642609, upload-time = "2025-08-05T19:30:06.632Z" }, +] + +[[package]] +name = "googleapis-common-protos" +version = "1.70.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "protobuf" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/39/24/33db22342cf4a2ea27c9955e6713140fedd51e8b141b5ce5260897020f1a/googleapis_common_protos-1.70.0.tar.gz", hash = "sha256:0e1b44e0ea153e6594f9f394fef15193a68aaaea2d843f83e2742717ca753257", size = 145903, upload-time = "2025-04-14T10:17:02.924Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/86/f1/62a193f0227cf15a920390abe675f386dec35f7ae3ffe6da582d3ade42c7/googleapis_common_protos-1.70.0-py3-none-any.whl", hash = "sha256:b8bfcca8c25a2bb253e0e0b0adaf8c00773e5e6af6fd92397576680b807e0fd8", size = 294530, upload-time = "2025-04-14T10:17:01.271Z" }, +] + +[[package]] +name = "jmespath" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/00/2a/e867e8531cf3e36b41201936b7fa7ba7b5702dbef42922193f05c8976cd6/jmespath-1.0.1.tar.gz", hash = "sha256:90261b206d6defd58fdd5e85f478bf633a2901798906be2ad389150c5c60edbe", size = 25843, upload-time = "2022-06-17T18:00:12.224Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/31/b4/b9b800c45527aadd64d5b442f9b932b00648617eb5d63d2c7a6587b7cafc/jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980", size = 20256, upload-time = "2022-06-17T18:00:10.251Z" }, +] + +[[package]] +name = "lark" +version = "0.12.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/02/1d/29681d27b84e384ea50b5546e9f0089126afbc91754db4ca89593fcfd0e8/lark-0.12.0.tar.gz", hash = "sha256:7da76fcfddadabbbbfd949bbae221efd33938451d90b1fefbbc423c3cccf48ef", size = 235168, upload-time = "2021-11-12T11:15:32.124Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/39/cef2ccdfd984ae3cf93878d050c1b7c9354dd9493ce83fd9bb33a41f7a33/lark-0.12.0-py2.py3-none-any.whl", hash = "sha256:ed1d891cbcf5151ead1c1d14663bf542443e579e63a76ae175b01b899bd854ca", size = 103540, upload-time = "2021-11-12T11:15:34.408Z" }, +] + +[[package]] +name = "protobuf" +version = "6.32.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fa/a4/cc17347aa2897568beece2e674674359f911d6fe21b0b8d6268cd42727ac/protobuf-6.32.1.tar.gz", hash = "sha256:ee2469e4a021474ab9baafea6cd070e5bf27c7d29433504ddea1a4ee5850f68d", size = 440635, upload-time = "2025-09-11T21:38:42.935Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/98/645183ea03ab3995d29086b8bf4f7562ebd3d10c9a4b14ee3f20d47cfe50/protobuf-6.32.1-cp310-abi3-win32.whl", hash = "sha256:a8a32a84bc9f2aad712041b8b366190f71dde248926da517bde9e832e4412085", size = 424411, upload-time = "2025-09-11T21:38:27.427Z" }, + { url = "https://files.pythonhosted.org/packages/8c/f3/6f58f841f6ebafe076cebeae33fc336e900619d34b1c93e4b5c97a81fdfa/protobuf-6.32.1-cp310-abi3-win_amd64.whl", hash = "sha256:b00a7d8c25fa471f16bc8153d0e53d6c9e827f0953f3c09aaa4331c718cae5e1", size = 435738, upload-time = "2025-09-11T21:38:30.959Z" }, + { url = "https://files.pythonhosted.org/packages/10/56/a8a3f4e7190837139e68c7002ec749190a163af3e330f65d90309145a210/protobuf-6.32.1-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d8c7e6eb619ffdf105ee4ab76af5a68b60a9d0f66da3ea12d1640e6d8dab7281", size = 426454, upload-time = "2025-09-11T21:38:34.076Z" }, + { url = "https://files.pythonhosted.org/packages/3f/be/8dd0a927c559b37d7a6c8ab79034fd167dcc1f851595f2e641ad62be8643/protobuf-6.32.1-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:2f5b80a49e1eb7b86d85fcd23fe92df154b9730a725c3b38c4e43b9d77018bf4", size = 322874, upload-time = "2025-09-11T21:38:35.509Z" }, + { url = "https://files.pythonhosted.org/packages/5c/f6/88d77011b605ef979aace37b7703e4eefad066f7e84d935e5a696515c2dd/protobuf-6.32.1-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:b1864818300c297265c83a4982fd3169f97122c299f56a56e2445c3698d34710", size = 322013, upload-time = "2025-09-11T21:38:37.017Z" }, + { url = "https://files.pythonhosted.org/packages/97/b7/15cc7d93443d6c6a84626ae3258a91f4c6ac8c0edd5df35ea7658f71b79c/protobuf-6.32.1-py3-none-any.whl", hash = "sha256:2601b779fc7d32a866c6b4404f9d42a3f67c5b9f3f15b4db3cccabe06b95c346", size = 169289, upload-time = "2025-09-11T21:38:41.234Z" }, +] + +[[package]] +name = "protoc-gen-openapiv2" +version = "0.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "googleapis-common-protos" }, + { name = "protobuf" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d8/d2/84fecd8df61640226c726c12ad7ddd2a7666a7cd7f898b9a5b72e3a66d44/protoc-gen-openapiv2-0.0.1.tar.gz", hash = "sha256:6f79188d842c13177c9c0558845442c340b43011bf67dfef1dfc3bc067506409", size = 7323, upload-time = "2022-12-02T01:40:57.306Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2d/ac/bd8961859d8f3f81530465d2ce9b165627e961c00348939009bac2700cc6/protoc_gen_openapiv2-0.0.1-py3-none-any.whl", hash = "sha256:18090c8be3877c438e7da0f7eb7cace45a9a210306bca4707708dbad367857be", size = 7883, upload-time = "2022-12-02T01:40:55.244Z" }, +] + +[[package]] +name = "protovalidate" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cel-python" }, + { name = "google-re2" }, + { name = "protobuf" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/dd/98/1595ae90c4a29c625580ee84415bb0c752e09c6c7aa13595e8ea94a7c929/protovalidate-1.0.0.tar.gz", hash = "sha256:926f7a212fed9190d00cc076fa24ef5e48a404b5577465028697f4dea8c4a507", size = 215286, upload-time = "2025-09-12T16:28:02.665Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/17/1d/30a86726b317593469eb526c8ca25dd8ce7f7b9f4237137fedb1f352ffff/protovalidate-1.0.0-py3-none-any.whl", hash = "sha256:933818942700c85d4a47f1030e61f59d7bd9a8c1572e9dc822f98eef45a39d9e", size = 29478, upload-time = "2025-09-12T16:28:01.201Z" }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631, upload-time = "2024-08-06T20:33:50.674Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/95/a3fac87cb7158e231b5a6012e438c647e1a87f09f8e0d123acec8ab8bf71/PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086", size = 184199, upload-time = "2024-08-06T20:31:40.178Z" }, + { url = "https://files.pythonhosted.org/packages/c7/7a/68bd47624dab8fd4afbfd3c48e3b79efe09098ae941de5b58abcbadff5cb/PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf", size = 171758, upload-time = "2024-08-06T20:31:42.173Z" }, + { url = "https://files.pythonhosted.org/packages/49/ee/14c54df452143b9ee9f0f29074d7ca5516a36edb0b4cc40c3f280131656f/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237", size = 718463, upload-time = "2024-08-06T20:31:44.263Z" }, + { url = "https://files.pythonhosted.org/packages/4d/61/de363a97476e766574650d742205be468921a7b532aa2499fcd886b62530/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b", size = 719280, upload-time = "2024-08-06T20:31:50.199Z" }, + { url = "https://files.pythonhosted.org/packages/6b/4e/1523cb902fd98355e2e9ea5e5eb237cbc5f3ad5f3075fa65087aa0ecb669/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed", size = 751239, upload-time = "2024-08-06T20:31:52.292Z" }, + { url = "https://files.pythonhosted.org/packages/b7/33/5504b3a9a4464893c32f118a9cc045190a91637b119a9c881da1cf6b7a72/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180", size = 695802, upload-time = "2024-08-06T20:31:53.836Z" }, + { url = "https://files.pythonhosted.org/packages/5c/20/8347dcabd41ef3a3cdc4f7b7a2aff3d06598c8779faa189cdbf878b626a4/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68", size = 720527, upload-time = "2024-08-06T20:31:55.565Z" }, + { url = "https://files.pythonhosted.org/packages/be/aa/5afe99233fb360d0ff37377145a949ae258aaab831bde4792b32650a4378/PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99", size = 144052, upload-time = "2024-08-06T20:31:56.914Z" }, + { url = "https://files.pythonhosted.org/packages/b5/84/0fa4b06f6d6c958d207620fc60005e241ecedceee58931bb20138e1e5776/PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e", size = 161774, upload-time = "2024-08-06T20:31:58.304Z" }, + { url = "https://files.pythonhosted.org/packages/f8/aa/7af4e81f7acba21a4c6be026da38fd2b872ca46226673c89a758ebdc4fd2/PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774", size = 184612, upload-time = "2024-08-06T20:32:03.408Z" }, + { url = "https://files.pythonhosted.org/packages/8b/62/b9faa998fd185f65c1371643678e4d58254add437edb764a08c5a98fb986/PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee", size = 172040, upload-time = "2024-08-06T20:32:04.926Z" }, + { url = "https://files.pythonhosted.org/packages/ad/0c/c804f5f922a9a6563bab712d8dcc70251e8af811fce4524d57c2c0fd49a4/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c", size = 736829, upload-time = "2024-08-06T20:32:06.459Z" }, + { url = "https://files.pythonhosted.org/packages/51/16/6af8d6a6b210c8e54f1406a6b9481febf9c64a3109c541567e35a49aa2e7/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317", size = 764167, upload-time = "2024-08-06T20:32:08.338Z" }, + { url = "https://files.pythonhosted.org/packages/75/e4/2c27590dfc9992f73aabbeb9241ae20220bd9452df27483b6e56d3975cc5/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85", size = 762952, upload-time = "2024-08-06T20:32:14.124Z" }, + { url = "https://files.pythonhosted.org/packages/9b/97/ecc1abf4a823f5ac61941a9c00fe501b02ac3ab0e373c3857f7d4b83e2b6/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4", size = 735301, upload-time = "2024-08-06T20:32:16.17Z" }, + { url = "https://files.pythonhosted.org/packages/45/73/0f49dacd6e82c9430e46f4a027baa4ca205e8b0a9dce1397f44edc23559d/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e", size = 756638, upload-time = "2024-08-06T20:32:18.555Z" }, + { url = "https://files.pythonhosted.org/packages/22/5f/956f0f9fc65223a58fbc14459bf34b4cc48dec52e00535c79b8db361aabd/PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5", size = 143850, upload-time = "2024-08-06T20:32:19.889Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/8da0bbe2ab9dcdd11f4f4557ccaf95c10b9811b13ecced089d43ce59c3c8/PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44", size = 161980, upload-time = "2024-08-06T20:32:21.273Z" }, + { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873, upload-time = "2024-08-06T20:32:25.131Z" }, + { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302, upload-time = "2024-08-06T20:32:26.511Z" }, + { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154, upload-time = "2024-08-06T20:32:28.363Z" }, + { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223, upload-time = "2024-08-06T20:32:30.058Z" }, + { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542, upload-time = "2024-08-06T20:32:31.881Z" }, + { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164, upload-time = "2024-08-06T20:32:37.083Z" }, + { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611, upload-time = "2024-08-06T20:32:38.898Z" }, + { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591, upload-time = "2024-08-06T20:32:40.241Z" }, + { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338, upload-time = "2024-08-06T20:32:41.93Z" }, + { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309, upload-time = "2024-08-06T20:32:43.4Z" }, + { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679, upload-time = "2024-08-06T20:32:44.801Z" }, + { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428, upload-time = "2024-08-06T20:32:46.432Z" }, + { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361, upload-time = "2024-08-06T20:32:51.188Z" }, + { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523, upload-time = "2024-08-06T20:32:53.019Z" }, + { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660, upload-time = "2024-08-06T20:32:54.708Z" }, + { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597, upload-time = "2024-08-06T20:32:56.985Z" }, + { url = "https://files.pythonhosted.org/packages/14/0d/e2c3b43bbce3cf6bd97c840b46088a3031085179e596d4929729d8d68270/PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183", size = 140527, upload-time = "2024-08-06T20:33:03.001Z" }, + { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446, upload-time = "2024-08-06T20:33:04.33Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "types-python-dateutil" +version = "2.9.0.20250822" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0c/0a/775f8551665992204c756be326f3575abba58c4a3a52eef9909ef4536428/types_python_dateutil-2.9.0.20250822.tar.gz", hash = "sha256:84c92c34bd8e68b117bff742bc00b692a1e8531262d4507b33afcc9f7716cd53", size = 16084, upload-time = "2025-08-22T03:02:00.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ab/d9/a29dfa84363e88b053bf85a8b7f212a04f0d7343a4d24933baa45c06e08b/types_python_dateutil-2.9.0.20250822-py3-none-any.whl", hash = "sha256:849d52b737e10a6dc6621d2bd7940ec7c65fcb69e6aa2882acf4e56b2b508ddc", size = 17892, upload-time = "2025-08-22T03:01:59.436Z" }, +] + +[[package]] +name = "types-pyyaml" +version = "6.0.12.20250915" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/69/3c51b36d04da19b92f9e815be12753125bd8bc247ba0470a982e6979e71c/types_pyyaml-6.0.12.20250915.tar.gz", hash = "sha256:0f8b54a528c303f0e6f7165687dd33fafa81c807fcac23f632b63aa624ced1d3", size = 17522, upload-time = "2025-09-15T03:01:00.728Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/e0/1eed384f02555dde685fff1a1ac805c1c7dcb6dd019c916fe659b1c1f9ec/types_pyyaml-6.0.12.20250915-py3-none-any.whl", hash = "sha256:e7d4d9e064e89a3b3cae120b4990cd370874d2bf12fa5f46c97018dd5d3c9ab6", size = 20338, upload-time = "2025-09-15T03:00:59.218Z" }, +] diff --git a/gen/rust/Cargo.lock b/gen/rust/Cargo.lock new file mode 100644 index 0000000000..df35a5c975 --- /dev/null +++ b/gen/rust/Cargo.lock @@ -0,0 +1,1742 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301" +dependencies = [ + "memchr", +] + +[[package]] +name = "anyhow" +version = "1.0.100" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61" + +[[package]] +name = "async-stream" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b5a71a6f37880a80d1d7f19efd781e4b5de42c88f0722cc13bcb6cc2cfe8476" +dependencies = [ + "async-stream-impl", + "futures-core", + "pin-project-lite", +] + +[[package]] +name = "async-stream-impl" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "async-trait" +version = "0.1.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "atomic-waker" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" + +[[package]] +name = "autocfg" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" + +[[package]] +name = "axum" +version = "0.7.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edca88bc138befd0323b20752846e6587272d3b03b0343c8ea28a6f819e6e71f" +dependencies = [ + "async-trait", + "axum-core", + "bytes", + "futures-util", + "http", + "http-body", + "http-body-util", + "itoa", + "matchit", + "memchr", + "mime", + "percent-encoding", + "pin-project-lite", + "rustversion", + "serde", + "sync_wrapper", + "tower 0.5.3", + "tower-layer", + "tower-service", +] + +[[package]] +name = "axum-core" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09f2bd6146b97ae3359fa0cc6d6b376d9539582c7b4220f041a33ec24c226199" +dependencies = [ + "async-trait", + "bytes", + "futures-util", + "http", + "http-body", + "http-body-util", + "mime", + "pin-project-lite", + "rustversion", + "sync_wrapper", + "tower-layer", + "tower-service", +] + +[[package]] +name = "base64" +version = "0.21.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567" + +[[package]] +name = "base64" +version = "0.22.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" + +[[package]] +name = "bitflags" +version = "2.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3" + +[[package]] +name = "bytes" +version = "1.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b35204fbdc0b3f4446b89fc1ac2cf84a8a68971995d0bf2e925ec7cd960f9cb3" + +[[package]] +name = "cc" +version = "1.2.55" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47b26a0954ae34af09b50f0de26458fa95369a0d478d8236d3f93082b219bd29" +dependencies = [ + "find-msvc-tools", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "chrono" +version = "0.4.43" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fac4744fb15ae8337dc853fee7fb3f4e48c0fbaa23d0afe49c447b4fab126118" +dependencies = [ + "num-traits", +] + +[[package]] +name = "either" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "fastrand" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" + +[[package]] +name = "find-msvc-tools" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" + +[[package]] +name = "fixedbitset" +version = "0.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99" + +[[package]] +name = "flyteidl2" +version = "0.1.0" +dependencies = [ + "async-trait", + "futures", + "pbjson", + "pbjson-build", + "pbjson-types", + "prettyplease", + "prost 0.13.5", + "prost-build 0.14.3", + "prost-types 0.12.6", + "protobuf", + "pyo3", + "pyo3-async-runtimes", + "quote", + "regex", + "serde", + "syn", + "thiserror", + "tokio", + "tonic", + "tower 0.4.13", + "tower-http", + "tracing", + "tracing-subscriber", +] + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + +[[package]] +name = "futures" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876" +dependencies = [ + "futures-channel", + "futures-core", + "futures-executor", + "futures-io", + "futures-sink", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-channel" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10" +dependencies = [ + "futures-core", + "futures-sink", +] + +[[package]] +name = "futures-core" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" + +[[package]] +name = "futures-executor" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f" +dependencies = [ + "futures-core", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-io" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" + +[[package]] +name = "futures-macro" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "futures-sink" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7" + +[[package]] +name = "futures-task" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988" + +[[package]] +name = "futures-util" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" +dependencies = [ + "futures-channel", + "futures-core", + "futures-io", + "futures-macro", + "futures-sink", + "futures-task", + "memchr", + "pin-project-lite", + "pin-utils", + "slab", +] + +[[package]] +name = "getrandom" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "libc", + "r-efi", + "wasip2", +] + +[[package]] +name = "h2" +version = "0.4.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f44da3a8150a6703ed5d34e164b875fd14c2cdab9af1252a9a1020bde2bdc54" +dependencies = [ + "atomic-waker", + "bytes", + "fnv", + "futures-core", + "futures-sink", + "http", + "indexmap 2.13.0", + "slab", + "tokio", + "tokio-util", + "tracing", +] + +[[package]] +name = "hashbrown" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" + +[[package]] +name = "hashbrown" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" +dependencies = [ + "foldhash", +] + +[[package]] +name = "hashbrown" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "http" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a" +dependencies = [ + "bytes", + "itoa", +] + +[[package]] +name = "http-body" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184" +dependencies = [ + "bytes", + "http", +] + +[[package]] +name = "http-body-util" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a" +dependencies = [ + "bytes", + "futures-core", + "http", + "http-body", + "pin-project-lite", +] + +[[package]] +name = "httparse" +version = "1.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" + +[[package]] +name = "httpdate" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9" + +[[package]] +name = "hyper" +version = "1.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11" +dependencies = [ + "atomic-waker", + "bytes", + "futures-channel", + "futures-core", + "h2", + "http", + "http-body", + "httparse", + "httpdate", + "itoa", + "pin-project-lite", + "pin-utils", + "smallvec", + "tokio", + "want", +] + +[[package]] +name = "hyper-timeout" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b90d566bffbce6a75bd8b09a05aa8c2cb1fabb6cb348f8840c9e4c90a0d83b0" +dependencies = [ + "hyper", + "hyper-util", + "pin-project-lite", + "tokio", + "tower-service", +] + +[[package]] +name = "hyper-util" +version = "0.1.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "727805d60e7938b76b826a6ef209eb70eaa1812794f9424d4a4e2d740662df5f" +dependencies = [ + "bytes", + "futures-channel", + "futures-core", + "futures-util", + "http", + "http-body", + "hyper", + "libc", + "pin-project-lite", + "socket2 0.6.2", + "tokio", + "tower-service", + "tracing", +] + +[[package]] +name = "indexmap" +version = "1.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99" +dependencies = [ + "autocfg", + "hashbrown 0.12.3", +] + +[[package]] +name = "indexmap" +version = "2.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017" +dependencies = [ + "equivalent", + "hashbrown 0.16.1", +] + +[[package]] +name = "indoc" +version = "2.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706" +dependencies = [ + "rustversion", +] + +[[package]] +name = "itertools" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569" +dependencies = [ + "either", +] + +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + +[[package]] +name = "itertools" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2" + +[[package]] +name = "lazy_static" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" + +[[package]] +name = "libc" +version = "0.2.180" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc" + +[[package]] +name = "linux-raw-sys" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039" + +[[package]] +name = "lock_api" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965" +dependencies = [ + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897" + +[[package]] +name = "matchit" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94" + +[[package]] +name = "memchr" +version = "2.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273" + +[[package]] +name = "memoffset" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a" +dependencies = [ + "autocfg", +] + +[[package]] +name = "mime" +version = "0.3.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a" + +[[package]] +name = "mio" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc" +dependencies = [ + "libc", + "wasi", + "windows-sys 0.61.2", +] + +[[package]] +name = "multimap" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d87ecb2933e8aeadb3e3a02b828fed80a7528047e68b4f424523a0981a3a084" + +[[package]] +name = "nu-ansi-term" +version = "0.50.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "once_cell" +version = "1.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" + +[[package]] +name = "parking_lot" +version = "0.12.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall", + "smallvec", + "windows-link", +] + +[[package]] +name = "paste" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" + +[[package]] +name = "pbjson" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7e6349fa080353f4a597daffd05cb81572a9c031a6d4fff7e504947496fcc68" +dependencies = [ + "base64 0.21.7", + "serde", +] + +[[package]] +name = "pbjson-build" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6eea3058763d6e656105d1403cb04e0a41b7bbac6362d413e7c33be0c32279c9" +dependencies = [ + "heck", + "itertools 0.13.0", + "prost 0.13.5", + "prost-types 0.13.5", +] + +[[package]] +name = "pbjson-types" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e54e5e7bfb1652f95bc361d76f3c780d8e526b134b85417e774166ee941f0887" +dependencies = [ + "bytes", + "chrono", + "pbjson", + "pbjson-build", + "prost 0.13.5", + "prost-build 0.13.5", + "serde", +] + +[[package]] +name = "percent-encoding" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" + +[[package]] +name = "petgraph" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3672b37090dbd86368a4145bc067582552b29c27377cad4e0a306c97f9bd7772" +dependencies = [ + "fixedbitset", + "indexmap 2.13.0", +] + +[[package]] +name = "petgraph" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455" +dependencies = [ + "fixedbitset", + "hashbrown 0.15.5", + "indexmap 2.13.0", +] + +[[package]] +name = "pin-project" +version = "1.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "677f1add503faace112b9f1373e43e9e054bfdd22ff1a63c1bc485eaec6a6a8a" +dependencies = [ + "pin-project-internal", +] + +[[package]] +name = "pin-project-internal" +version = "1.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "pin-project-lite" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + +[[package]] +name = "portable-atomic" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f89776e4d69bb58bc6993e99ffa1d11f228b839984854c7daeb5d37f87cbe950" + +[[package]] +name = "ppv-lite86" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] + +[[package]] +name = "prettyplease" +version = "0.2.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" +dependencies = [ + "proc-macro2", + "syn", +] + +[[package]] +name = "proc-macro2" +version = "1.0.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "prost" +version = "0.12.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "deb1435c188b76130da55f17a466d252ff7b1418b2ad3e037d127b94e3411f29" +dependencies = [ + "bytes", + "prost-derive 0.12.6", +] + +[[package]] +name = "prost" +version = "0.13.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5" +dependencies = [ + "bytes", + "prost-derive 0.13.5", +] + +[[package]] +name = "prost" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2ea70524a2f82d518bce41317d0fae74151505651af45faf1ffbd6fd33f0568" +dependencies = [ + "bytes", + "prost-derive 0.14.3", +] + +[[package]] +name = "prost-build" +version = "0.13.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be769465445e8c1474e9c5dac2018218498557af32d9ed057325ec9a41ae81bf" +dependencies = [ + "heck", + "itertools 0.14.0", + "log", + "multimap", + "once_cell", + "petgraph 0.7.1", + "prettyplease", + "prost 0.13.5", + "prost-types 0.13.5", + "regex", + "syn", + "tempfile", +] + +[[package]] +name = "prost-build" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "343d3bd7056eda839b03204e68deff7d1b13aba7af2b2fd16890697274262ee7" +dependencies = [ + "heck", + "itertools 0.14.0", + "log", + "multimap", + "petgraph 0.8.3", + "prettyplease", + "prost 0.14.3", + "prost-types 0.14.3", + "regex", + "syn", + "tempfile", +] + +[[package]] +name = "prost-derive" +version = "0.12.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81bddcdb20abf9501610992b6759a4c888aef7d1a7247ef75e2404275ac24af1" +dependencies = [ + "anyhow", + "itertools 0.12.1", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "prost-derive" +version = "0.13.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d" +dependencies = [ + "anyhow", + "itertools 0.14.0", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "prost-derive" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27c6023962132f4b30eb4c172c91ce92d933da334c59c23cddee82358ddafb0b" +dependencies = [ + "anyhow", + "itertools 0.14.0", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "prost-types" +version = "0.12.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9091c90b0a32608e984ff2fa4091273cbdd755d54935c51d520887f4a1dbd5b0" +dependencies = [ + "prost 0.12.6", +] + +[[package]] +name = "prost-types" +version = "0.13.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52c2c1bf36ddb1a1c396b3601a3cec27c2462e45f07c386894ec3ccf5332bd16" +dependencies = [ + "prost 0.13.5", +] + +[[package]] +name = "prost-types" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8991c4cbdb8bc5b11f0b074ffe286c30e523de90fee5ba8132f1399f23cb3dd7" +dependencies = [ + "prost 0.14.3", +] + +[[package]] +name = "protobuf" +version = "4.31.1-release" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7967deb2e74ba240cdcfbf447858848c9edaae6231027d31f4120d42243543a2" +dependencies = [ + "cc", + "paste", +] + +[[package]] +name = "pyo3" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5203598f366b11a02b13aa20cab591229ff0a89fd121a308a5df751d5fc9219" +dependencies = [ + "cfg-if", + "indoc", + "libc", + "memoffset", + "once_cell", + "portable-atomic", + "pyo3-build-config", + "pyo3-ffi", + "pyo3-macros", + "unindent", +] + +[[package]] +name = "pyo3-async-runtimes" +version = "0.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd0b83dc42f9d41f50d38180dad65f0c99763b65a3ff2a81bf351dd35a1df8bf" +dependencies = [ + "futures", + "once_cell", + "pin-project-lite", + "pyo3", + "tokio", +] + +[[package]] +name = "pyo3-build-config" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "99636d423fa2ca130fa5acde3059308006d46f98caac629418e53f7ebb1e9999" +dependencies = [ + "once_cell", + "target-lexicon", +] + +[[package]] +name = "pyo3-ffi" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78f9cf92ba9c409279bc3305b5409d90db2d2c22392d443a87df3a1adad59e33" +dependencies = [ + "libc", + "pyo3-build-config", +] + +[[package]] +name = "pyo3-macros" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b999cb1a6ce21f9a6b147dcf1be9ffedf02e0043aec74dc390f3007047cecd9" +dependencies = [ + "proc-macro2", + "pyo3-macros-backend", + "quote", + "syn", +] + +[[package]] +name = "pyo3-macros-backend" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "822ece1c7e1012745607d5cf0bcb2874769f0f7cb34c4cde03b9358eb9ef911a" +dependencies = [ + "heck", + "proc-macro2", + "pyo3-build-config", + "quote", + "syn", +] + +[[package]] +name = "quote" +version = "1.0.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha", + "rand_core", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom 0.2.17", +] + +[[package]] +name = "redox_syscall" +version = "0.5.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" +dependencies = [ + "bitflags", +] + +[[package]] +name = "regex" +version = "1.12.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58" + +[[package]] +name = "rustix" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34" +dependencies = [ + "bitflags", + "errno", + "libc", + "linux-raw-sys", + "windows-sys 0.61.2", +] + +[[package]] +name = "rustversion" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" + +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "serde" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "sharded-slab" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" +dependencies = [ + "lazy_static", +] + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "signal-hook-registry" +version = "1.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b" +dependencies = [ + "errno", + "libc", +] + +[[package]] +name = "slab" +version = "0.4.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589" + +[[package]] +name = "smallvec" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" + +[[package]] +name = "socket2" +version = "0.5.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678" +dependencies = [ + "libc", + "windows-sys 0.52.0", +] + +[[package]] +name = "socket2" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86f4aa3ad99f2088c990dfa82d367e19cb29268ed67c574d10d0a4bfe71f07e0" +dependencies = [ + "libc", + "windows-sys 0.60.2", +] + +[[package]] +name = "syn" +version = "2.0.114" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "sync_wrapper" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263" + +[[package]] +name = "target-lexicon" +version = "0.13.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1dd07eb858a2067e2f3c7155d54e929265c264e6f37efe3ee7a8d1b5a1dd0ba" + +[[package]] +name = "tempfile" +version = "3.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "655da9c7eb6305c55742045d5a8d2037996d61d8de95806335c7c86ce0f82e9c" +dependencies = [ + "fastrand", + "getrandom 0.3.4", + "once_cell", + "rustix", + "windows-sys 0.61.2", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "thread_local" +version = "1.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "tokio" +version = "1.49.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86" +dependencies = [ + "bytes", + "libc", + "mio", + "parking_lot", + "pin-project-lite", + "signal-hook-registry", + "socket2 0.6.2", + "tokio-macros", + "windows-sys 0.61.2", +] + +[[package]] +name = "tokio-macros" +version = "2.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tokio-stream" +version = "0.1.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32da49809aab5c3bc678af03902d4ccddea2a87d028d86392a4b1560c6906c70" +dependencies = [ + "futures-core", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "tokio-util" +version = "0.7.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098" +dependencies = [ + "bytes", + "futures-core", + "futures-sink", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "tonic" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877c5b330756d856ffcc4553ab34a5684481ade925ecc54bcd1bf02b1d0d4d52" +dependencies = [ + "async-stream", + "async-trait", + "axum", + "base64 0.22.1", + "bytes", + "h2", + "http", + "http-body", + "http-body-util", + "hyper", + "hyper-timeout", + "hyper-util", + "percent-encoding", + "pin-project", + "prost 0.13.5", + "socket2 0.5.10", + "tokio", + "tokio-stream", + "tower 0.4.13", + "tower-layer", + "tower-service", + "tracing", +] + +[[package]] +name = "tower" +version = "0.4.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c" +dependencies = [ + "futures-core", + "futures-util", + "indexmap 1.9.3", + "pin-project", + "pin-project-lite", + "rand", + "slab", + "tokio", + "tokio-util", + "tower-layer", + "tower-service", + "tracing", +] + +[[package]] +name = "tower" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4" +dependencies = [ + "futures-core", + "futures-util", + "pin-project-lite", + "sync_wrapper", + "tower-layer", + "tower-service", +] + +[[package]] +name = "tower-http" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e9cd434a998747dd2c4276bc96ee2e0c7a2eadf3cae88e52be55a05fa9053f5" +dependencies = [ + "bitflags", + "bytes", + "http", + "http-body", + "http-body-util", + "pin-project-lite", + "tower-layer", + "tower-service", + "tracing", +] + +[[package]] +name = "tower-layer" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e" + +[[package]] +name = "tower-service" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3" + +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "log", + "pin-project-lite", + "tracing-attributes", + "tracing-core", +] + +[[package]] +name = "tracing-attributes" +version = "0.1.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" +dependencies = [ + "once_cell", + "valuable", +] + +[[package]] +name = "tracing-log" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" +dependencies = [ + "log", + "once_cell", + "tracing-core", +] + +[[package]] +name = "tracing-subscriber" +version = "0.3.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e" +dependencies = [ + "nu-ansi-term", + "sharded-slab", + "smallvec", + "thread_local", + "tracing-core", + "tracing-log", +] + +[[package]] +name = "try-lock" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" + +[[package]] +name = "unicode-ident" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5" + +[[package]] +name = "unindent" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3" + +[[package]] +name = "valuable" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" + +[[package]] +name = "want" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e" +dependencies = [ + "try-lock", +] + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "wasip2" +version = "1.0.2+wasi-0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb" +dependencies = [ + "windows-targets 0.53.5", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", + "windows_i686_gnullvm 0.52.6", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", +] + +[[package]] +name = "windows-targets" +version = "0.53.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3" +dependencies = [ + "windows-link", + "windows_aarch64_gnullvm 0.53.1", + "windows_aarch64_msvc 0.53.1", + "windows_i686_gnu 0.53.1", + "windows_i686_gnullvm 0.53.1", + "windows_i686_msvc 0.53.1", + "windows_x86_64_gnu 0.53.1", + "windows_x86_64_gnullvm 0.53.1", + "windows_x86_64_msvc 0.53.1", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_i686_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" + +[[package]] +name = "wit-bindgen" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5" + +[[package]] +name = "zerocopy" +version = "0.8.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7456cf00f0685ad319c5b1693f291a650eaf345e941d082fc4e03df8a03996ac" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1328722bbf2115db7e19d69ebcc15e795719e2d66b60827c6a69a117365e37a0" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] diff --git a/gen/rust/Cargo.toml b/gen/rust/Cargo.toml new file mode 100644 index 0000000000..8c17d109ab --- /dev/null +++ b/gen/rust/Cargo.toml @@ -0,0 +1,50 @@ +[package] +name = "flyteidl2" +version = "0.1.0" +edition = "2021" +description = "Rust bindings and utilities for FlyteIDL protobufs." +license = "Apache-2.0" + +[dependencies] +pyo3 = { version = "0.24", features = ["experimental-async"] } +pyo3-async-runtimes = { version = "0.24", features = ["tokio-runtime"] } +tokio = { version = "1.0", features = ["full"] } +tonic = "0.12.3" +prost = { version = "0.13.5", features = ["std"] } +prost-types = { version = "0.12", features = ["std"] } +futures = "0.3" +tower = "0.4" +tower-http = { version = "0.5", features = ["trace"] } +tracing = "0.1" +tracing-subscriber = "0.3" +async-trait = "0.1" +thiserror = "1.0" +serde = { version = "1.0", features = ["derive"] } +pbjson = { version = "0.7.0" } +pbjson-types = { version = "0.7.0" } +protobuf = { version = "4.31.1-release" } +prost-build = "0.14" +quote = "1.0" +syn = { version = "2.0", features = ["full", "extra-traits"] } +prettyplease = "0.2" +regex = "1.11.1" + +[lib] +name = "flyteidl2" +path = "src/lib.rs" +#crate-type = ["cdylib"] + +[features] +default = [] +## @@protoc_insertion_point(features) + +[build-dependencies] +prost-build = "0.14" +pbjson-build = { version = "0.7.0" } +quote = "1.0" +syn = { version = "2.0", features = ["full", "extra-traits"] } +prettyplease = "0.2" +regex = "1.10" + +#[profile.dev.build-override] +#debug = true \ No newline at end of file diff --git a/gen/rust/build.rs b/gen/rust/build.rs new file mode 100644 index 0000000000..10e4c5c9df --- /dev/null +++ b/gen/rust/build.rs @@ -0,0 +1,516 @@ +//! Compiles Protocol Buffers and FlatBuffers schema definitions into +//! native Rust types. + +use prettyplease::unparse; +use quote::quote; +use std::fs::File; +use std::io::Write; +use std::path::PathBuf; +use syn::{parse_quote, Type}; + +type Error = Box; +type Result = std::result::Result; + +fn generate_boxed_impls() -> String { + // Define the types we want to implement Box for + let types: Vec = vec![ + parse_quote!(crate::validate::FieldRules), + parse_quote!(crate::validate::RepeatedRules), + parse_quote!(crate::validate::MapRules), + parse_quote!(crate::flyteidl::core::LiteralType), + parse_quote!(crate::flyteidl::core::Literal), + parse_quote!(crate::flyteidl::core::Union), + parse_quote!(crate::google::protobuf::FeatureSet), + parse_quote!(crate::flyteidl::core::Scalar), + // parse_quote!(crate::pyo3::types::PyBytes), + ]; + + // Generate the code using quote + let tokens = quote! { + use pyo3::prelude::*; + use pyo3::conversion::{IntoPyObject, FromPyObject}; + use std::convert::Infallible; + + #( + impl<'py> IntoPyObject<'py> for Box<#types> { + type Target = PyAny; + type Output = Bound<'py, Self::Target>; + type Error = Infallible; + + fn into_pyobject(self, py: Python<'py>) -> Result { + Ok(self.as_ref().clone().into_py(py).into_bound(py)) + } + } + + impl<'py> FromPyObject<'py> for Box<#types> { + fn extract_bound(obj: &Bound<'py, PyAny>) -> PyResult { + Ok(Box::new(#types::extract_bound(obj)?)) + } + } + )* + }; + + // Convert the generated code to a string and format it + let syntax = syn::parse_file(&tokens.to_string()).expect("Failed to parse generated code"); + unparse(&syntax) +} + +// Map file names to module paths +fn file_to_modpath(file: &str) -> Option<&'static str> { + match file { + "cloudidl.common.rs" => Some("crate::cloudidl::common"), + "cloudidl.workflow.rs" => Some("crate::cloudidl::workflow"), + "cloudidl.logs.dataplane.rs" => Some("crate::cloudidl::logs::dataplane"), + "flyteidl.core.rs" => Some("crate::flyteidl::core"), + "google.rpc.rs" => Some("crate::google::rpc"), + "validate.rs" => Some("crate::validate"), + _ => None, + } +} + +#[derive(Debug)] +struct ProstStructInfo { + ty: Type, + fq_name: String, + fields: Vec<(String, String)>, + is_tuple: bool, + mod_path: String, // e.g. crate::cloudidl::common +} + +// Find all prost-generated types in src/ +fn find_prost_types(src_dir: &PathBuf) -> Vec { + use std::collections::HashSet; + use std::path::Path; + use syn::{Fields, Item}; + + let mut structs = Vec::new(); + let mut visited = HashSet::new(); + + // Helper to recursively walk modules + fn walk_items(items: &[Item], mod_path: &mut Vec, structs: &mut Vec) { + for item in items { + match item { + Item::Mod(m) => { + mod_path.push(m.ident.to_string()); + // If inline module, recurse into its content + if let Some((_, items)) = &m.content { + walk_items(items, mod_path, structs); + } + // Outline modules are handled in the main loop + mod_path.pop(); + } + Item::Struct(s) => { + let fq = format!("{}::{}", mod_path.join("::"), s.ident); + let ty = match syn::parse_str::(&fq) { + Ok(t) => t, + Err(_) => continue, + }; + let (fields, is_tuple) = match &s.fields { + Fields::Named(fields) => { + let fields = fields + .named + .iter() + .map(|f| { + let name = f.ident.as_ref().unwrap().to_string(); + let ty = quote::ToTokens::to_token_stream(&f.ty).to_string(); + (name, ty) + }) + .collect(); + (fields, false) + } + Fields::Unnamed(fields) => { + let fields = fields + .unnamed + .iter() + .enumerate() + .map(|(i, f)| { + let name = format!("field{}", i); + let ty = quote::ToTokens::to_token_stream(&f.ty).to_string(); + (name, ty) + }) + .collect(); + (fields, true) + } + Fields::Unit => (vec![], false), + }; + let mod_path = mod_path.join("::"); + let mod_path = if !mod_path.is_empty() { + format!("crate::{}", mod_path) + } else { + "crate".to_string() + }; + structs.push(ProstStructInfo { + ty, + fq_name: fq, + fields, + is_tuple, + mod_path, + }); + } + _ => {} + } + } + } + + // Helper to parse a file and walk its items + fn parse_and_walk( + path: &Path, + mod_path: &mut Vec, + structs: &mut Vec, + visited: &mut HashSet, + ) { + if !visited.insert(path.to_path_buf()) { + return; + } + let content = match std::fs::read_to_string(path) { + Ok(c) => c, + Err(_) => return, + }; + let ast: syn::File = match syn::parse_file(&content) { + Ok(f) => f, + Err(_) => return, + }; + walk_items(&ast.items, mod_path, structs); + // Recursively handle outline modules + for item in &ast.items { + if let Item::Mod(m) = item { + if m.content.is_none() { + // Outline module: look for mod.rs or .rs + let mod_name = m.ident.to_string(); + let parent = path.parent().unwrap_or(Path::new("")); + let mod_rs = parent.join(&mod_name).join("mod.rs"); + let mod_file = parent.join(format!("{}.rs", mod_name)); + if mod_rs.exists() { + mod_path.push(mod_name.clone()); + parse_and_walk(&mod_rs, mod_path, structs, visited); + mod_path.pop(); + } else if mod_file.exists() { + mod_path.push(mod_name.clone()); + parse_and_walk(&mod_file, mod_path, structs, visited); + mod_path.pop(); + } + } + } + } + } + + for entry in std::fs::read_dir(src_dir).unwrap() { + let entry = entry.unwrap(); + let path = entry.path(); + let file_name = path.file_name().unwrap().to_string_lossy(); + + if !file_name.ends_with(".rs") || file_name == "serde_impl.rs" || file_name == "lib.rs" { + continue; + } + + let modpath = match file_to_modpath(&file_name) { + Some(m) => m.replace("crate::", ""), + None => continue, + }; + let mut mod_path: Vec = modpath.split("::").map(|s| s.to_string()).collect(); + parse_and_walk(&path, &mut mod_path, &mut structs, &mut visited); + } + structs +} + +fn generate_encode_decode(infos: &[ProstStructInfo]) -> String { + // Helper to qualify types + fn qualify_type(ty: &str, current_mod: &str) -> String { + let primitives = [ + "String", "u8", "u16", "u32", "u64", "i8", "i16", "i32", "i64", "bool", "f32", "f64", + "usize", "isize", "char", "str", + ]; + let ty = ty.trim(); + let mut ty_clean = ty + .replace(" :: ", "::") + .replace("crate ::", "crate::") + .replace("super ::", "super::") + .replace("self ::", "self::"); + while ty_clean.contains("::::") { + ty_clean = ty_clean.replace("::::", "::"); + } + // Handle generics recursively (e.g., Option, Vec) + if let Some(start) = ty_clean.find('<') { + if let Some(end) = ty_clean.rfind('>') { + let outer = &ty_clean[..start]; + let inner = &ty_clean[start + 1..end]; + let qualified_inner = inner + .split(',') + .map(|s| qualify_type(s, current_mod)) + .collect::>() + .join(", "); + return format!("{}<{}>", outer, qualified_inner); + } + } + // Handle super:: prefix by resolving up the module path + if ty_clean.starts_with("super::") { + let mut mod_parts: Vec<&str> = current_mod.split("::").collect(); + let mut ty_remainder = ty_clean.to_string(); + while ty_remainder.starts_with("super::") { + ty_remainder = ty_remainder[7..].to_string(); + if mod_parts.len() > 1 { + mod_parts.pop(); + } + } + let abs_path = if ty_remainder.is_empty() { + mod_parts.join("::") + } else { + format!("{}::{}", mod_parts.join("::"), ty_remainder) + }; + return abs_path; + } + if ty_clean.starts_with("self::") { + // self:: just means current_mod + let ty_remainder = &ty_clean[6..]; + return format!("{}::{}", current_mod, ty_remainder); + } + if ty_clean.starts_with("crate::") + || ty_clean.starts_with("::") + || ty_clean.starts_with("prost::") + || ty_clean.starts_with("core::") + || ty_clean.starts_with("std::") + || ty_clean.starts_with("alloc::") + { + ty_clean + } else if primitives.iter().any(|&p| ty_clean == p) + || ty_clean.starts_with("Option") + || ty_clean.starts_with("Vec") + || ty_clean.starts_with("HashMap") + { + ty_clean + } else if ty_clean.contains("::") { + // Prepend current_mod for relative paths like enriched_identity::Principal + format!("{}::{}", current_mod, ty_clean) + } else { + format!("{}::{}", current_mod, ty_clean.replace(' ', "")) + } + } + let mut py_methods = String::new(); + for info in infos { + let fq = info + .fq_name + .replace("crate :: ", "crate::") + .replace(" :: ", "::"); + let fields = &info.fields; + let is_tuple = info.is_tuple; + let mod_path = &info.mod_path; + let py_new = if fields.is_empty() { + format!( + " #[new]\n pub fn py_new() -> Self {{\n Self::default()\n }}\n" + ) + } else if is_tuple { + let args = fields + .iter() + .map(|(n, t)| format!("{}: {}", n, qualify_type(t, mod_path))) + .collect::>() + .join(", "); + let vals = fields + .iter() + .map(|(n, _)| n.clone()) + .collect::>() + .join(", "); + format!( + " #[new]\n pub fn py_new({}) -> Self {{\n Self({})\n }}\n", + args, vals + ) + } else { + let args = fields + .iter() + .map(|(n, t)| format!("{}: {}", n, qualify_type(t, mod_path))) + .collect::>() + .join(", "); + let vals = fields + .iter() + .map(|(n, _)| format!("{}", n)) + .collect::>() + .join(", "); + format!( + " #[new]\n pub fn py_new({}) -> Self {{\n Self {{ {} }}\n }}\n", + args, vals + ) + }; + py_methods += &format!( + r#" + #[::pyo3::pymethods] + impl {fq} {{ +{py_new} + fn __repr__(&self) -> String {{ + format!("{{:?}}", self) + }} + fn __str__(&self) -> String {{ + format!("{{:?}}", self) + }} + }} +"#, + fq = fq, + py_new = py_new + ); + } + + let syntax = syn::parse_file(&py_methods.to_string()).expect("Failed to parse generated code"); + unparse(&syntax) +} + +#[derive(Default)] +struct ModuleNode { + children: std::collections::HashMap, + types: Vec, // store fully qualified type paths +} + +fn build_module_tree( + types: &[Type], + all_types: &mut std::collections::BTreeSet, +) -> ModuleNode { + let mut root = ModuleNode::default(); + for ty in types { + let fq = quote!(#ty) + .to_string() + .replace("crate :: ", "crate::") + .replace(" :: ", "::"); + let parts: Vec<_> = fq.split("::").map(|s| s.trim().to_string()).collect(); + if parts.len() < 2 { + continue; + } + let (mod_path, type_name) = parts.split_at(parts.len() - 1); + let mut node = &mut root; + for part in mod_path { + node = node.children.entry(part.clone()).or_default(); + } + let full_type = parts.join("::"); + node.types.push(full_type.clone()); + all_types.insert(full_type); + } + root +} + +fn generate_pymodules_file( + module_tree: &ModuleNode, + all_types: &std::collections::BTreeSet, +) -> String { + let mut code = String::new(); + code += "use pyo3::prelude::*;\n\ + #[pyo3::pymodule]\n"; + // for ty in all_types { + // code += &format!( + // "use {}; + // ", + // ty + // ); + // } + code += &generate_pymodules(module_tree, &[]); + code +} + +fn generate_pymodules(node: &ModuleNode, mod_path: &[String]) -> String { + let mod_name = mod_path + .last() + .cloned() + .unwrap_or_else(|| "cloud".to_string()); + let func_name = if mod_path.is_empty() { + "init_pymodule".to_string() + } else { + format!("init_{}", mod_path.join("_")) + }; + let mut code = format!( + "pub fn {}_mod(_py: pyo3::Python, m: &Bound<'_, PyModule>) -> pyo3::PyResult<()> {{\n", + mod_name + ); + for ty in &node.types { + code += &format!(" m.add_class::()?;\n", ty); + } + for (child_name, _child_node) in &node.children { + let submod_func = format!("{}_mod", child_name.clone()); + code += &format!( + " let submod = pyo3::types::PyModule::new(_py, \"{}\")?;\n", + child_name + ); + code += &format!(" {}(_py, &submod)?;\n", submod_func); + code += &format!(" m.add_submodule(&submod)?;\n"); + } + code += " Ok(())\n}\n"; + for (child_name, child_node) in &node.children { + let mut child_path = mod_path.to_vec(); + child_path.push(child_name.clone()); + code += &generate_pymodules(child_node, &child_path); + } + code +} + +fn main() -> Result<()> { + let descriptor_path: PathBuf = "descriptors.bin".into(); + println!("cargo:rerun-if-changed={}", descriptor_path.display()); + + let mut config = prost_build::Config::new(); + config + .file_descriptor_set_path(&descriptor_path) + .compile_well_known_types() + .disable_comments(["."]) + // .bytes(["."]) // Add prost::bytes::Bytes exclusion + .type_attribute(".", "#[pyo3::pyclass(dict, get_all, set_all)]") + // .type_attribute(".", "#[pyo3_prost::pyclass_for_prost_struct]") + // .type_attribute("bytes::Bytes", "#[pyo3::pyclass(dict, get_all, set_all)]") + // .type_attribute( + // "::pyo3::types::PyBytes", + // "#[pyo3::pyclass(dict, get_all, set_all)]", + // ) + .skip_protoc_run(); + + let empty: &[&str] = &[]; + config.compile_protos(empty, empty)?; + + let descriptor_set = std::fs::read(descriptor_path)?; + pbjson_build::Builder::new() + .register_descriptors(&descriptor_set)? + .exclude([ + ".google.protobuf.Duration", + ".google.protobuf.Timestamp", + ".google.protobuf.Value", + ".google.protobuf.Struct", + ".google.protobuf.ListValue", + ".google.protobuf.NullValue", + ".google.protobuf.BoolValue", + ".google.protobuf.BytesValue", + ".google.protobuf.DoubleValue", + ".google.protobuf.FloatValue", + ".google.protobuf.Int32Value", + ".google.protobuf.Int64Value", + ".google.protobuf.StringValue", + ".google.protobuf.UInt32Value", + ".google.protobuf.UInt64Value", + ]) + .build(&[".google"])?; + + // Generate Box implementations + let boxed_impls = generate_boxed_impls(); + let out_dir = std::env::var("OUT_DIR").unwrap(); + let boxed_impls_path = PathBuf::from(&out_dir).join("boxed_impls.rs"); + let mut file = File::create(boxed_impls_path)?; + file.write_all(boxed_impls.as_bytes())?; + + // Find all prost types + let src_dir = PathBuf::from("src"); + let prost_infos = find_prost_types(&src_dir); + eprintln!("Found {} prost types", prost_infos.len()); + eprintln!("Generating implementations for {:?} types", prost_infos); + // unsafe { std::intrinsics::breakpoint(); } + + // Generate encode,decode implementations for all prost types + let serde_impls = generate_encode_decode(&prost_infos); + let serde_impls_path = PathBuf::from(&out_dir).join("serde_impls.rs"); + let mut file = File::create(serde_impls_path)?; + file.write_all(serde_impls.as_bytes())?; + + // --- New: Generate PyO3 module tree code --- + let mut all_types = std::collections::BTreeSet::new(); + let module_tree = build_module_tree( + &prost_infos.iter().map(|i| i.ty.clone()).collect::>(), + &mut all_types, + ); + let pymodules_code = generate_pymodules_file(&module_tree, &all_types); + let pymodules_path = PathBuf::from(&out_dir).join("pymodules.rs"); + let mut file = File::create(pymodules_path)?; + file.write_all(pymodules_code.as_bytes())?; + // --- End new --- + + Ok(()) +} diff --git a/gen/rust/descriptors.bin b/gen/rust/descriptors.bin new file mode 100644 index 0000000000..0e370ea3c1 Binary files /dev/null and b/gen/rust/descriptors.bin differ diff --git a/gen/rust/pyproject.toml b/gen/rust/pyproject.toml new file mode 100644 index 0000000000..350cb34e25 --- /dev/null +++ b/gen/rust/pyproject.toml @@ -0,0 +1,17 @@ +[build-system] +requires = ["maturin>=1.9,<2.0"] +build-backend = "maturin" + +[project] +name = "flyteidl" +version = "0.1.0" +description = "Rust protos for Flyte" +requires-python = ">=3.10" +classifiers = [ + "Programming Language :: Python", + "Programming Language :: Rust", +] + +[tool.maturin] +python-source = "src" +module-name = "flyte_mod" diff --git a/gen/rust/src/flyteidl2.app.rs b/gen/rust/src/flyteidl2.app.rs new file mode 100644 index 0000000000..1a182b2309 --- /dev/null +++ b/gen/rust/src/flyteidl2.app.rs @@ -0,0 +1,3189 @@ +// @generated +// This file is @generated by prost-build. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Identifier { + /// Org that the app belongs to. + #[prost(string, tag="1")] + pub org: ::prost::alloc::string::String, + /// Project that the app belongs to. + #[prost(string, tag="2")] + pub project: ::prost::alloc::string::String, + /// Domain that the app belongs to. + #[prost(string, tag="3")] + pub domain: ::prost::alloc::string::String, + /// Name that the user provided for the app. + #[prost(string, tag="4")] + pub name: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Meta { + /// ID of the app. + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + /// Revision of the app object. + #[prost(uint64, tag="2")] + pub revision: u64, + /// Labels for the app. + #[prost(map="string, string", tag="3")] + pub labels: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, +} +/// For internal usage only. This message is used to wrap the app message with the host. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AppWrapper { + #[prost(string, tag="1")] + pub host: ::prost::alloc::string::String, + #[prost(oneof="app_wrapper::Payload", tags="2, 3")] + pub payload: ::core::option::Option, +} +/// Nested message and enum types in `AppWrapper`. +pub mod app_wrapper { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Payload { + #[prost(message, tag="2")] + App(super::App), + #[prost(message, tag="3")] + AppId(super::Identifier), + } +} +/// Represents an app with its specification and status. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct App { + /// Metadata of the app. + #[prost(message, optional, tag="1")] + pub metadata: ::core::option::Option, + /// Specification of the app. + #[prost(message, optional, tag="2")] + pub spec: ::core::option::Option, + /// Status of the app. + #[prost(message, optional, tag="3")] + pub status: ::core::option::Option, +} +// State machine for the app status +// +// โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” +// โ”‚ โ”‚ +// โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ–บ Unassigned โ”‚ +// โ”‚ โ”‚ โ”‚ +// โ”‚ โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”ฌโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ +// โ”‚Lease โ”‚ +// โ”‚Expired โ”‚ Leased to a cluster +// โ”‚ โ”‚ +// โ”‚ โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ–ผโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” +// โ”‚ โ”‚ Assigned โ”‚ +// โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”ผ + โ”‚ +// โ”‚ Timeout โ”‚ +// โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”ฌโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ +// โ”‚ +// โ”‚ Acknowledged by cluster +// โ”‚ +// โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ–ผโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” +// โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ–บ Pending โ”‚ +// โ”‚ โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”ฌโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ +// โ”‚New โ”‚ +// โ”‚Revision โ”‚ Action performed by cluster +// โ”‚ โ”‚ +// โ”‚ โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ–ผโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” +// โ””โ”€โ”€โ”€โ”€โ”€โ”ผ Stopped/Started/Failed โ”‚ +// โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ + +/// Represents the condition of an app. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Condition { + /// Last transition time of the condition. + #[prost(message, optional, tag="1")] + pub last_transition_time: ::core::option::Option, + /// Deployment status of the app. + #[prost(enumeration="status::DeploymentStatus", tag="2")] + pub deployment_status: i32, + /// Message for the condition. + #[prost(string, tag="3")] + pub message: ::prost::alloc::string::String, + /// Revision the Condition applies to. This can be used by consumers + /// to introspect and visualize which revisions are up. + #[prost(uint64, tag="4")] + pub revision: u64, + /// Actor is the principal that caused the condition. + #[prost(message, optional, tag="5")] + pub actor: ::core::option::Option, +} +/// Represents the status of an app. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Status { + #[prost(string, tag="1")] + pub assigned_cluster: ::prost::alloc::string::String, + /// Current number of replicas. + #[prost(uint32, tag="2")] + pub current_replicas: u32, + /// List of public URLs for the app. + #[prost(message, optional, tag="3")] + pub ingress: ::core::option::Option, + /// CreatedAt is the time when the app was first created + #[prost(message, optional, tag="4")] + pub created_at: ::core::option::Option, + /// LastUpdatedAt is the time when the app was last updated + #[prost(message, optional, tag="5")] + pub last_updated_at: ::core::option::Option, + /// Conditions for the app. + #[prost(message, repeated, tag="6")] + pub conditions: ::prost::alloc::vec::Vec, + /// LeaseExpiration refers to how long the app is leased to a cluster for it to start processing it. If the lease + /// period expires, the cluster will no longer be allowed to update this app and another cluster can pick it up. + #[prost(message, optional, tag="7")] + pub lease_expiration: ::core::option::Option, + /// K8sMetadata contains metadata about the app in the K8s cluster. + #[prost(message, optional, tag="8")] + pub k8s_metadata: ::core::option::Option, + #[prost(message, optional, tag="9")] + pub materialized_inputs: ::core::option::Option, +} +/// Nested message and enum types in `Status`. +pub mod status { + /// Enum for deployment status of the app. + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum DeploymentStatus { + /// Unspecified deployment status. + Unspecified = 0, + /// Deployment is enabled but hasn't been assigned to a cluster yet. + Unassigned = 1, + /// Deployment is assigned to a cluster but hasn't been acknowledged yet. + Assigned = 2, + /// Deployment is picked up by a cluster but is awaiting deployment. + Pending = 3, + /// Deployment is disabled. + Stopped = 4, + /// Deployment is completed. Please use DEPLOYMENT_STATUS_ACTIVE instead. + Started = 5, + /// Deployment has failed. + Failed = 6, + /// Deployment is completed. + Active = 7, + /// Triggered in response to desired app replicas > actual app replicas + ScalingUp = 8, + /// Triggered in response to desired app replicas < actual app replicas + ScalingDown = 9, + /// Triggered in response to the latest app spec changing + Deploying = 10, + } + impl DeploymentStatus { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + DeploymentStatus::Unspecified => "DEPLOYMENT_STATUS_UNSPECIFIED", + DeploymentStatus::Unassigned => "DEPLOYMENT_STATUS_UNASSIGNED", + DeploymentStatus::Assigned => "DEPLOYMENT_STATUS_ASSIGNED", + DeploymentStatus::Pending => "DEPLOYMENT_STATUS_PENDING", + DeploymentStatus::Stopped => "DEPLOYMENT_STATUS_STOPPED", + DeploymentStatus::Started => "DEPLOYMENT_STATUS_STARTED", + DeploymentStatus::Failed => "DEPLOYMENT_STATUS_FAILED", + DeploymentStatus::Active => "DEPLOYMENT_STATUS_ACTIVE", + DeploymentStatus::ScalingUp => "DEPLOYMENT_STATUS_SCALING_UP", + DeploymentStatus::ScalingDown => "DEPLOYMENT_STATUS_SCALING_DOWN", + DeploymentStatus::Deploying => "DEPLOYMENT_STATUS_DEPLOYING", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "DEPLOYMENT_STATUS_UNSPECIFIED" => Some(Self::Unspecified), + "DEPLOYMENT_STATUS_UNASSIGNED" => Some(Self::Unassigned), + "DEPLOYMENT_STATUS_ASSIGNED" => Some(Self::Assigned), + "DEPLOYMENT_STATUS_PENDING" => Some(Self::Pending), + "DEPLOYMENT_STATUS_STOPPED" => Some(Self::Stopped), + "DEPLOYMENT_STATUS_STARTED" => Some(Self::Started), + "DEPLOYMENT_STATUS_FAILED" => Some(Self::Failed), + "DEPLOYMENT_STATUS_ACTIVE" => Some(Self::Active), + "DEPLOYMENT_STATUS_SCALING_UP" => Some(Self::ScalingUp), + "DEPLOYMENT_STATUS_SCALING_DOWN" => Some(Self::ScalingDown), + "DEPLOYMENT_STATUS_DEPLOYING" => Some(Self::Deploying), + _ => None, + } + } + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct K8sMetadata { + /// Namespace points to the namespace the app is deployed in. + #[prost(string, tag="1")] + pub namespace: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Ingress { + /// Public URL of the app. + #[prost(string, tag="1")] + pub public_url: ::prost::alloc::string::String, + /// Canonical name (CNAME) URL of the app. + #[prost(string, tag="2")] + pub cname_url: ::prost::alloc::string::String, + /// VPC URL of the app. + #[prost(string, tag="3")] + pub vpc_url: ::prost::alloc::string::String, +} +/// Represents the specification of an app. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Spec { + /// Autoscaling configuration for the app. + #[prost(message, optional, tag="3")] + pub autoscaling: ::core::option::Option, + /// Ingress configuration for the app. + #[prost(message, optional, tag="4")] + pub ingress: ::core::option::Option, + /// Deployment status of the app. + #[prost(enumeration="spec::DesiredState", tag="5")] + pub desired_state: i32, + /// ClusterPool to place this app on. By default it'll use the default cluster pool. + #[prost(string, tag="6")] + pub cluster_pool: ::prost::alloc::string::String, + /// Set of image specifications for the app. + #[prost(message, optional, tag="7")] + pub images: ::core::option::Option, + /// security_context encapsulates security attributes requested to run this task. + #[prost(message, optional, tag="8")] + pub security_context: ::core::option::Option, + /// Encapsulates all non-standard resources, not captured by + /// v1.ResourceRequirements, to allocate to a task. + #[prost(message, optional, tag="9")] + pub extended_resources: ::core::option::Option, + /// Runtime metadata for the app. + #[prost(message, optional, tag="10")] + pub runtime_metadata: ::core::option::Option, + /// Profile of the app. + #[prost(message, optional, tag="11")] + pub profile: ::core::option::Option, + /// Creator of the app is the first principal that provisioned this app. Other principals may + /// interact with the app by updating its spec or stopping/starting it. + #[prost(message, optional, tag="12")] + pub creator: ::core::option::Option, + /// Inputs of the app. + #[prost(message, optional, tag="13")] + pub inputs: ::core::option::Option, + #[prost(message, repeated, tag="14")] + pub links: ::prost::alloc::vec::Vec, + /// Timeout configuration for the app. + #[prost(message, optional, tag="15")] + pub timeouts: ::core::option::Option, + /// Payload of the app, which can be either a container or a K8s pod. + #[prost(oneof="spec::AppPayload", tags="1, 2")] + pub app_payload: ::core::option::Option, +} +/// Nested message and enum types in `Spec`. +pub mod spec { + /// Enum for deployment status of the app. + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum DesiredState { + /// Unspecified state + Unspecified = 0, + /// Deployment is disabled. + Stopped = 1, + /// Deployment is completed. Please use DESIRED_STATE_ACTIVE instead. + Started = 2, + /// Deployment is completed. + Active = 3, + } + impl DesiredState { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + DesiredState::Unspecified => "DESIRED_STATE_UNSPECIFIED", + DesiredState::Stopped => "DESIRED_STATE_STOPPED", + DesiredState::Started => "DESIRED_STATE_STARTED", + DesiredState::Active => "DESIRED_STATE_ACTIVE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "DESIRED_STATE_UNSPECIFIED" => Some(Self::Unspecified), + "DESIRED_STATE_STOPPED" => Some(Self::Stopped), + "DESIRED_STATE_STARTED" => Some(Self::Started), + "DESIRED_STATE_ACTIVE" => Some(Self::Active), + _ => None, + } + } + } + /// Payload of the app, which can be either a container or a K8s pod. + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum AppPayload { + /// Container payload. + #[prost(message, tag="1")] + Container(super::super::core::Container), + /// K8s pod payload. + #[prost(message, tag="2")] + Pod(super::super::core::K8sPod), + } +} +/// Represents a link to an external resource (Arize project link, W&B dashboard, etc) +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Link { + /// URL of the external service. + /// This can be an absolute or relative path. + #[prost(string, tag="1")] + pub path: ::prost::alloc::string::String, + /// Human readable name of the external service. + #[prost(string, tag="2")] + pub title: ::prost::alloc::string::String, + /// Whether the path is absolute (default) or relative. + #[prost(bool, tag="3")] + pub is_relative: bool, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Input { + /// Name is a unique identifier of the input within the list of inputs of the app + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + #[prost(oneof="input::Value", tags="2, 3, 4, 5")] + pub value: ::core::option::Option, +} +/// Nested message and enum types in `Input`. +pub mod input { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Value { + /// StringValue is a plain string value for the input + #[prost(string, tag="2")] + StringValue(::prost::alloc::string::String), + /// ArtifactQuery is that should result in a single artifact that will be used as the input to the app at runtime. + /// The artifact will be pinned at the time of the app creation. + #[prost(message, tag="3")] + ArtifactQuery(super::super::core::ArtifactQuery), + /// ArtifactId is an identifier of an artifact that will be used as the input to the app at runtime. + #[prost(message, tag="4")] + ArtifactId(super::super::core::ArtifactId), + /// ID of the app. + #[prost(message, tag="5")] + AppId(super::Identifier), + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MaterializedInputs { + #[prost(message, repeated, tag="1")] + pub items: ::prost::alloc::vec::Vec, + /// Revision of the app object that we materialized the input for. + #[prost(uint64, tag="2")] + pub revision: u64, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MaterializedInput { + /// Name is a unique identifier of the input within the list of inputs of the app + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + #[prost(oneof="materialized_input::Value", tags="2")] + pub value: ::core::option::Option, +} +/// Nested message and enum types in `MaterializedInput`. +pub mod materialized_input { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Value { + /// ArtifactId is an identifier of an artifact that will be used as the input to the app at runtime. + #[prost(message, tag="2")] + ArtifactId(super::super::core::ArtifactId), + } +} +/// InputList is a list of dependencies for the app. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InputList { + /// Items is the list of inputs to fulfil for the app. + #[prost(message, repeated, tag="1")] + pub items: ::prost::alloc::vec::Vec, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Profile { + /// App Type (e.g. FastAPI, Flask, VLLM, NIM etc.) + #[prost(string, tag="1")] + pub r#type: ::prost::alloc::string::String, + /// Friendly name of the app. + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, + /// Short description of the app. + #[prost(string, tag="3")] + pub short_description: ::prost::alloc::string::String, + /// Icon URL of the app. + #[prost(string, tag="4")] + pub icon_url: ::prost::alloc::string::String, +} +/// SecurityContext holds security attributes that apply to tasks. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SecurityContext { + /// run_as encapsulates the identity a pod should run as. If the task fills in multiple fields here, it'll be up to the + /// backend plugin to choose the appropriate identity for the execution engine the task will run on. + #[prost(message, optional, tag="1")] + pub run_as: ::core::option::Option, + /// secrets indicate the list of secrets the task needs in order to proceed. Secrets will be mounted/passed to the + /// pod as it starts. If the plugin responsible for kicking of the task will not run it on a flyte cluster (e.g. AWS + /// Batch), it's the responsibility of the plugin to fetch the secret (which means propeller identity will need access + /// to the secret) and to pass it to the remote execution engine. + #[prost(message, repeated, tag="2")] + pub secrets: ::prost::alloc::vec::Vec, + /// AllowAnonymous indicates if the app should be accessible without authentication. This assumes the app will handle + /// its own authentication or that it's a public app. + #[prost(bool, tag="5")] + pub allow_anonymous: bool, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ImageSpec { + /// Tag of the image. + #[prost(string, tag="1")] + pub tag: ::prost::alloc::string::String, + /// URL of the build job for the image. + #[prost(string, tag="2")] + pub build_job_url: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ImageSpecSet { + /// List of image specifications. + #[prost(message, repeated, tag="1")] + pub images: ::prost::alloc::vec::Vec, +} +/// Represents the ingress configuration of an app. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IngressConfig { + /// Indicates if the app should be private. + #[prost(bool, tag="1")] + pub private: bool, + /// Subdomain for the app. If not specified, a random subdomain will be generated. + #[prost(string, tag="2")] + pub subdomain: ::prost::alloc::string::String, + /// Canonical name (CNAME) for the app. + #[prost(string, tag="3")] + pub cname: ::prost::alloc::string::String, +} +/// Represents the autoscaling configuration of an app. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct AutoscalingConfig { + /// Configuration for the number of replicas. + #[prost(message, optional, tag="1")] + pub replicas: ::core::option::Option, + /// The period for scaling down the object. + #[prost(message, optional, tag="2")] + pub scaledown_period: ::core::option::Option, + /// Metric for scaling the app. + #[prost(message, optional, tag="3")] + pub scaling_metric: ::core::option::Option, +} +/// ScalingMetric allows different scaling strategies for the app. +/// See: +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct ScalingMetric { + #[prost(oneof="scaling_metric::Metric", tags="1, 2")] + pub metric: ::core::option::Option, +} +/// Nested message and enum types in `ScalingMetric`. +pub mod scaling_metric { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Oneof)] + pub enum Metric { + /// Configuration for scaling based on request rate. + #[prost(message, tag="1")] + RequestRate(super::RequestRate), + /// Configuration for scaling based on concurrency. + #[prost(message, tag="2")] + Concurrency(super::Concurrency), + } +} +/// This section enables scaling based on the request concurrency. Concurrency calculates how many +/// requests are being processed at the same time. This is useful for apps that take longer to process +/// requests (e.g. seconds) +/// The autoscaler has a default window of 60 seconds to calculate the concurrency value. However, it has +/// panic mode that kicks in if the request rate jumps to 2x its value within 6 seconds. If that's +/// triggered, it'll start scaling up immediately instead of waiting for the full 60 seconds. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct Concurrency { + /// This is the target value for the scaling configuration. + /// default=100 + #[prost(uint32, tag="1")] + pub target_value: u32, +} +/// RequestRate enables scaling based on the request rate. Request rate calculates how many requests +/// the app is receiving per second. +/// The autoscaler has a default window of 60 seconds to calculate the request rate. However, it has +/// panic mode that kicks in if the request rate jumps to 2x its value within 6 seconds. If that's +/// triggered, it'll start scaling up immediately instead of waiting for the full 60 seconds. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct RequestRate { + /// This is the target value for the scaling configuration. + /// default=100 + #[prost(uint32, tag="1")] + pub target_value: u32, +} +/// Represents the configuration for the number of replicas. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct Replicas { + /// Minimum number of replicas. + #[prost(uint32, tag="1")] + pub min: u32, + /// Maximum number of replicas. + #[prost(uint32, tag="2")] + pub max: u32, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct TimeoutConfig { + /// This is the maximum duration that the request instance + /// is allowed to respond to a request. If unspecified, a system default will + /// be provided. + /// default=300s + #[prost(message, optional, tag="1")] + pub request_timeout: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ReplicaIdentifier { + /// ID of the app. + #[prost(message, optional, tag="1")] + pub app_id: ::core::option::Option, + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ReplicaMeta { + /// ID of the replica. + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + /// Revision of the replica object. + #[prost(uint64, tag="2")] + pub revision: u64, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ReplicaList { + /// List of replicas. + #[prost(message, repeated, tag="1")] + pub items: ::prost::alloc::vec::Vec, +} +/// Represents a replica of an app with its specification and status. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Replica { + /// Metadata of the app. + #[prost(message, optional, tag="1")] + pub metadata: ::core::option::Option, + /// Status of the app. + #[prost(message, optional, tag="2")] + pub status: ::core::option::Option, +} +/// Represents the status of the replica. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ReplicaStatus { + /// Current deployment status of the replica. + #[prost(string, tag="1")] + pub deployment_status: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub reason: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TailLogsRequest { + #[prost(oneof="tail_logs_request::Target", tags="1, 2")] + pub target: ::core::option::Option, +} +/// Nested message and enum types in `TailLogsRequest`. +pub mod tail_logs_request { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Target { + /// Identifier of the application to get logs for. + #[prost(message, tag="1")] + AppId(super::Identifier), + /// Identifier of the replica to get logs for. + #[prost(message, tag="2")] + ReplicaId(super::ReplicaIdentifier), + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ReplicaIdentifierList { + #[prost(message, repeated, tag="1")] + pub replicas: ::prost::alloc::vec::Vec, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LogLines { + #[deprecated] + #[prost(string, repeated, tag="1")] + pub lines: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(message, optional, tag="2")] + pub replica_id: ::core::option::Option, + #[prost(message, repeated, tag="3")] + pub structured_lines: ::prost::alloc::vec::Vec, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LogLinesBatch { + #[prost(message, repeated, tag="1")] + pub logs: ::prost::alloc::vec::Vec, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TailLogsResponse { + #[prost(oneof="tail_logs_response::Resp", tags="1, 2, 3")] + pub resp: ::core::option::Option, +} +/// Nested message and enum types in `TailLogsResponse`. +pub mod tail_logs_response { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Resp { + /// Replicas lists the replicas that the logs are being tailed for. This is expected to be the first + /// message to be sent in the stream but also can be sent at any later time to update the list of + /// replicas being tailed. + #[prost(message, tag="1")] + Replicas(super::ReplicaIdentifierList), + /// The latest log lines for the application. + /// Deprecated, use batches instead. + #[prost(message, tag="2")] + LogLines(super::super::logs::dataplane::LogLines), + /// The latest log lines for the application. + #[prost(message, tag="3")] + Batches(super::LogLinesBatch), + } +} +/// Request message for creating an app. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateRequest { + /// The app to be created. + #[prost(message, optional, tag="1")] + pub app: ::core::option::Option, +} +/// Response message for creating an app. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateResponse { + /// The created app. + #[prost(message, optional, tag="1")] + pub app: ::core::option::Option, +} +/// Request message for retrieving an app. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetRequest { + #[prost(oneof="get_request::Identifier", tags="1, 2")] + pub identifier: ::core::option::Option, +} +/// Nested message and enum types in `GetRequest`. +pub mod get_request { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Identifier { + /// Identifier of the app to be retrieved. + #[prost(message, tag="1")] + AppId(super::Identifier), + /// Ingress of the app to be retrieved. Only one field need to be set. + /// If multiple fields are set, they must resolve into the same app. + /// Otherwise, an error is returned. + #[prost(message, tag="2")] + Ingress(super::Ingress), + } +} +/// Response message for retrieving an app. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetResponse { + /// The retrieved app. + #[prost(message, optional, tag="1")] + pub app: ::core::option::Option, +} +/// Request message for updating an app. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UpdateRequest { + /// The app to be updated. + #[prost(message, optional, tag="1")] + pub app: ::core::option::Option, + #[prost(string, tag="2")] + pub reason: ::prost::alloc::string::String, +} +/// Response message for updating an app. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UpdateResponse { + /// The updated app. + #[prost(message, optional, tag="1")] + pub app: ::core::option::Option, +} +/// Request message for deleting an app. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DeleteRequest { + /// Identifier of the app to be deleted. + #[prost(message, optional, tag="1")] + pub app_id: ::core::option::Option, +} +/// Response message for deleting an app. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct DeleteResponse { +} +/// Request message for listing apps. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListRequest { + /// Common list request parameters. + #[prost(message, optional, tag="1")] + pub request: ::core::option::Option, + #[prost(oneof="list_request::FilterBy", tags="2, 3, 4")] + pub filter_by: ::core::option::Option, +} +/// Nested message and enum types in `ListRequest`. +pub mod list_request { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum FilterBy { + /// Organization name for filtering apps. + #[prost(string, tag="2")] + Org(::prost::alloc::string::String), + /// Cluster identifier for filtering apps. + #[prost(message, tag="3")] + ClusterId(super::super::common::ClusterIdentifier), + /// Project identifier for filtering apps. + #[prost(message, tag="4")] + Project(super::super::common::ProjectIdentifier), + } +} +/// Response message for listing apps. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListResponse { + /// List of apps. + #[prost(message, repeated, tag="1")] + pub apps: ::prost::alloc::vec::Vec, + /// Token for fetching the next page of results, if any. + #[prost(string, tag="2")] + pub token: ::prost::alloc::string::String, +} +/// Request message for watching app events. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchRequest { + #[prost(oneof="watch_request::Target", tags="1, 2, 3, 4")] + pub target: ::core::option::Option, +} +/// Nested message and enum types in `WatchRequest`. +pub mod watch_request { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Target { + /// Organization name for filtering events. + #[prost(string, tag="1")] + Org(::prost::alloc::string::String), + /// Cluster identifier for filtering events. + #[prost(message, tag="2")] + ClusterId(super::super::common::ClusterIdentifier), + /// Project identifier for filtering events. + #[prost(message, tag="3")] + Project(super::super::common::ProjectIdentifier), + /// App identifier for filtering events. + #[prost(message, tag="4")] + AppId(super::Identifier), + } +} +/// Event message for app creation. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateEvent { + /// The created app. + #[prost(message, optional, tag="1")] + pub app: ::core::option::Option, +} +/// Event message for app update. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UpdateEvent { + /// The updated app. + #[prost(message, optional, tag="1")] + pub updated_app: ::core::option::Option, + /// The old app before the update. + #[prost(message, optional, tag="2")] + pub old_app: ::core::option::Option, +} +/// Event message for app deletion. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DeleteEvent { + /// The deleted app. + #[prost(message, optional, tag="1")] + pub app: ::core::option::Option, +} +/// Response message for watching app events. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchResponse { + #[prost(oneof="watch_response::Event", tags="1, 2, 3")] + pub event: ::core::option::Option, +} +/// Nested message and enum types in `WatchResponse`. +pub mod watch_response { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Event { + /// Event for app creation. + #[prost(message, tag="1")] + CreateEvent(super::CreateEvent), + /// Event for app update. + #[prost(message, tag="2")] + UpdateEvent(super::UpdateEvent), + /// Event for app deletion. + #[prost(message, tag="3")] + DeleteEvent(super::DeleteEvent), + } +} +/// Request message for updating app status. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UpdateStatusRequest { + /// The app with updated status. + #[prost(message, optional, tag="1")] + pub app: ::core::option::Option, +} +/// Response message for updating app status. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UpdateStatusResponse { + /// The app with updated status. + #[prost(message, optional, tag="1")] + pub app: ::core::option::Option, +} +/// Request message for leasing apps. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LeaseRequest { + /// Cluster identifier for leasing apps. + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, +} +/// Response message for leasing apps. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LeaseResponse { + /// List of leased apps. + #[prost(message, repeated, tag="1")] + pub apps: ::prost::alloc::vec::Vec, +} +/// Encoded file descriptor set for the `flyteidl2.app` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0x83, 0xaa, 0x01, 0x0a, 0x22, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x61, 0x70, 0x70, 0x2f, 0x61, 0x70, 0x70, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x26, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x61, 0x72, + 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, + 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, + 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1a, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, + 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xb2, 0x01, 0x0a, 0x0a, + 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x6f, 0x72, + 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x21, 0x0a, 0x07, + 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, + 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, + 0x1f, 0x0a, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, + 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, + 0x12, 0x4e, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x3a, + 0xba, 0x48, 0x37, 0x72, 0x35, 0x10, 0x01, 0x18, 0x1e, 0x32, 0x2f, 0x5e, 0x5b, 0x41, 0x2d, 0x5a, + 0x61, 0x2d, 0x7a, 0x30, 0x2d, 0x39, 0x5d, 0x28, 0x3f, 0x3a, 0x5b, 0x41, 0x2d, 0x5a, 0x61, 0x2d, + 0x7a, 0x30, 0x2d, 0x39, 0x2d, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x31, 0x7d, 0x5b, 0x41, 0x2d, 0x5a, + 0x61, 0x2d, 0x7a, 0x30, 0x2d, 0x39, 0x5d, 0x29, 0x3f, 0x24, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x22, 0xd2, 0x01, 0x0a, 0x04, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x31, 0x0a, 0x02, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0x23, 0x0a, 0x08, + 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x42, 0x07, + 0xba, 0x48, 0x04, 0x32, 0x02, 0x28, 0x00, 0x52, 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, + 0x6e, 0x12, 0x37, 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x1a, 0x39, 0x0a, 0x0b, 0x4c, 0x61, + 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x87, 0x01, 0x0a, 0x0a, 0x41, 0x70, 0x70, 0x57, 0x72, 0x61, + 0x70, 0x70, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x12, 0x26, 0x0a, 0x03, 0x61, 0x70, 0x70, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x41, 0x70, 0x70, 0x48, 0x00, 0x52, 0x03, 0x61, 0x70, 0x70, + 0x12, 0x32, 0x0a, 0x06, 0x61, 0x70, 0x70, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, + 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x05, 0x61, + 0x70, 0x70, 0x49, 0x64, 0x42, 0x09, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, + 0x9e, 0x01, 0x0a, 0x03, 0x41, 0x70, 0x70, 0x12, 0x37, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x42, 0x06, + 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x12, 0x2f, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x53, + 0x70, 0x65, 0x63, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x04, 0x73, 0x70, 0x65, + 0x63, 0x12, 0x2d, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x15, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x22, 0xa7, 0x02, 0x0a, 0x09, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x4c, + 0x0a, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x54, 0x72, + 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x53, 0x0a, 0x11, + 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x44, + 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, + 0x10, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x23, 0x0a, 0x08, 0x72, + 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x42, 0x07, 0xba, + 0x48, 0x04, 0x32, 0x02, 0x28, 0x00, 0x52, 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, + 0x12, 0x38, 0x0a, 0x05, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x52, 0x05, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x22, 0xaa, 0x07, 0x0a, 0x06, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, + 0x64, 0x5f, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0f, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x12, 0x32, 0x0a, 0x10, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, + 0x02, 0x28, 0x00, 0x52, 0x0f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x73, 0x12, 0x30, 0x0a, 0x07, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x52, 0x07, 0x69, + 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x64, 0x5f, 0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, + 0x74, 0x12, 0x42, 0x0a, 0x0f, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x64, 0x5f, 0x61, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x38, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, + 0x45, 0x0a, 0x10, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0f, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x45, 0x78, 0x70, 0x69, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3d, 0x0a, 0x0c, 0x6b, 0x38, 0x73, 0x5f, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x4b, 0x38, 0x73, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x0b, 0x6b, 0x38, 0x73, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x52, 0x0a, 0x13, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, + 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x09, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, + 0x70, 0x70, 0x2e, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x49, + 0x6e, 0x70, 0x75, 0x74, 0x73, 0x52, 0x12, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, + 0x7a, 0x65, 0x64, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x22, 0xfb, 0x02, 0x0a, 0x10, 0x44, 0x65, + 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x21, + 0x0a, 0x1d, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x53, 0x54, 0x41, + 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, + 0x00, 0x12, 0x20, 0x0a, 0x1c, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, + 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x45, + 0x44, 0x10, 0x01, 0x12, 0x1e, 0x0a, 0x1a, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, + 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x45, + 0x44, 0x10, 0x02, 0x12, 0x1d, 0x0a, 0x19, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, + 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x50, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, + 0x10, 0x03, 0x12, 0x1d, 0x0a, 0x19, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, + 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x53, 0x54, 0x4f, 0x50, 0x50, 0x45, 0x44, 0x10, + 0x04, 0x12, 0x21, 0x0a, 0x19, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, + 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x52, 0x54, 0x45, 0x44, 0x10, 0x05, + 0x1a, 0x02, 0x08, 0x01, 0x12, 0x1c, 0x0a, 0x18, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, + 0x4e, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, + 0x10, 0x06, 0x12, 0x1c, 0x0a, 0x18, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, + 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x10, 0x07, + 0x12, 0x20, 0x0a, 0x1c, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x53, + 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x53, 0x43, 0x41, 0x4c, 0x49, 0x4e, 0x47, 0x5f, 0x55, 0x50, + 0x10, 0x08, 0x12, 0x22, 0x0a, 0x1e, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, + 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x53, 0x43, 0x41, 0x4c, 0x49, 0x4e, 0x47, 0x5f, + 0x44, 0x4f, 0x57, 0x4e, 0x10, 0x09, 0x12, 0x1f, 0x0a, 0x1b, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, + 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x44, 0x45, 0x50, 0x4c, + 0x4f, 0x59, 0x49, 0x4e, 0x47, 0x10, 0x0a, 0x22, 0x2b, 0x0a, 0x0b, 0x4b, 0x38, 0x73, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x22, 0x85, 0x01, 0x0a, 0x07, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, + 0x12, 0x2a, 0x0a, 0x0a, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x0b, 0xba, 0x48, 0x08, 0xd8, 0x01, 0x01, 0x72, 0x03, 0x88, 0x01, + 0x01, 0x52, 0x09, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x55, 0x72, 0x6c, 0x12, 0x28, 0x0a, 0x09, + 0x63, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, + 0x0b, 0xba, 0x48, 0x08, 0xd8, 0x01, 0x01, 0x72, 0x03, 0x88, 0x01, 0x01, 0x52, 0x08, 0x63, 0x6e, + 0x61, 0x6d, 0x65, 0x55, 0x72, 0x6c, 0x12, 0x24, 0x0a, 0x07, 0x76, 0x70, 0x63, 0x5f, 0x75, 0x72, + 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0b, 0xba, 0x48, 0x08, 0xd8, 0x01, 0x01, 0x72, + 0x03, 0x88, 0x01, 0x01, 0x52, 0x06, 0x76, 0x70, 0x63, 0x55, 0x72, 0x6c, 0x22, 0x94, 0x08, 0x0a, + 0x04, 0x53, 0x70, 0x65, 0x63, 0x12, 0x39, 0x0a, 0x09, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x48, 0x00, 0x52, 0x09, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x12, 0x2a, 0x0a, 0x03, 0x70, 0x6f, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, + 0x38, 0x73, 0x50, 0x6f, 0x64, 0x48, 0x00, 0x52, 0x03, 0x70, 0x6f, 0x64, 0x12, 0x42, 0x0a, 0x0b, + 0x61, 0x75, 0x74, 0x6f, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x2e, 0x41, 0x75, 0x74, 0x6f, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x52, 0x0b, 0x61, 0x75, 0x74, 0x6f, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, + 0x12, 0x36, 0x0a, 0x07, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x2e, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, + 0x07, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x12, 0x45, 0x0a, 0x0d, 0x64, 0x65, 0x73, 0x69, + 0x72, 0x65, 0x64, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, + 0x53, 0x70, 0x65, 0x63, 0x2e, 0x44, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x52, 0x0c, 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, + 0x21, 0x0a, 0x0c, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x70, 0x6f, 0x6f, 0x6c, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x50, 0x6f, + 0x6f, 0x6c, 0x12, 0x33, 0x0a, 0x06, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, + 0x70, 0x70, 0x2e, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x53, 0x70, 0x65, 0x63, 0x53, 0x65, 0x74, 0x52, + 0x06, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x12, 0x49, 0x0a, 0x10, 0x73, 0x65, 0x63, 0x75, 0x72, + 0x69, 0x74, 0x79, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x2e, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, + 0x74, 0x52, 0x0f, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, + 0x78, 0x74, 0x12, 0x50, 0x0a, 0x12, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x73, 0x52, 0x11, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x73, 0x12, 0x4c, 0x0a, 0x10, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x52, 0x0f, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x12, 0x30, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x0b, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x61, 0x70, 0x70, 0x2e, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x07, 0x70, 0x72, 0x6f, + 0x66, 0x69, 0x6c, 0x65, 0x12, 0x3c, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, + 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, + 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, + 0x6f, 0x72, 0x12, 0x30, 0x0a, 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x0d, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, + 0x70, 0x70, 0x2e, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x06, 0x69, 0x6e, + 0x70, 0x75, 0x74, 0x73, 0x12, 0x29, 0x0a, 0x05, 0x6c, 0x69, 0x6e, 0x6b, 0x73, 0x18, 0x0e, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x61, 0x70, 0x70, 0x2e, 0x4c, 0x69, 0x6e, 0x6b, 0x52, 0x05, 0x6c, 0x69, 0x6e, 0x6b, 0x73, 0x12, + 0x38, 0x0a, 0x08, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, + 0x08, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x73, 0x22, 0x81, 0x01, 0x0a, 0x0c, 0x44, 0x65, + 0x73, 0x69, 0x72, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x1d, 0x0a, 0x19, 0x44, 0x45, + 0x53, 0x49, 0x52, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, + 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x19, 0x0a, 0x15, 0x44, 0x45, 0x53, + 0x49, 0x52, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x54, 0x4f, 0x50, 0x50, + 0x45, 0x44, 0x10, 0x01, 0x12, 0x1d, 0x0a, 0x15, 0x44, 0x45, 0x53, 0x49, 0x52, 0x45, 0x44, 0x5f, + 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x52, 0x54, 0x45, 0x44, 0x10, 0x02, 0x1a, + 0x02, 0x08, 0x01, 0x12, 0x18, 0x0a, 0x14, 0x44, 0x45, 0x53, 0x49, 0x52, 0x45, 0x44, 0x5f, 0x53, + 0x54, 0x41, 0x54, 0x45, 0x5f, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x10, 0x03, 0x42, 0x14, 0x0a, + 0x0b, 0x61, 0x70, 0x70, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x05, 0xba, 0x48, + 0x02, 0x08, 0x01, 0x22, 0x5a, 0x0a, 0x04, 0x4c, 0x69, 0x6e, 0x6b, 0x12, 0x1b, 0x0a, 0x04, 0x70, + 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, + 0x10, 0x01, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x69, 0x74, 0x6c, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x12, 0x1f, + 0x0a, 0x0b, 0x69, 0x73, 0x5f, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x73, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x22, + 0x9d, 0x02, 0x0a, 0x05, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, + 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2c, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, + 0x04, 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x12, 0x46, 0x0a, 0x0e, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, + 0x5f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, + 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x48, 0x00, 0x52, 0x0d, 0x61, + 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x3d, 0x0a, 0x0b, + 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x44, 0x48, 0x00, 0x52, + 0x0a, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x64, 0x12, 0x32, 0x0a, 0x06, 0x61, + 0x70, 0x70, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x05, 0x61, 0x70, 0x70, 0x49, 0x64, 0x42, + 0x0e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, + 0x71, 0x0a, 0x12, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x49, + 0x6e, 0x70, 0x75, 0x74, 0x73, 0x12, 0x36, 0x0a, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, + 0x64, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x52, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x12, 0x23, 0x0a, + 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x42, + 0x07, 0xba, 0x48, 0x04, 0x32, 0x02, 0x28, 0x00, 0x52, 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, + 0x6f, 0x6e, 0x22, 0x7f, 0x0a, 0x11, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, + 0x65, 0x64, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3d, 0x0a, 0x0b, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, + 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x66, + 0x61, 0x63, 0x74, 0x49, 0x44, 0x48, 0x00, 0x52, 0x0a, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, + 0x74, 0x49, 0x64, 0x42, 0x0e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x05, 0xba, 0x48, + 0x02, 0x08, 0x01, 0x22, 0x37, 0x0a, 0x09, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x4c, 0x69, 0x73, 0x74, + 0x12, 0x2a, 0x0a, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x14, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, + 0x49, 0x6e, 0x70, 0x75, 0x74, 0x52, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x82, 0x01, 0x0a, + 0x07, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x12, 0x34, 0x0a, 0x11, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, + 0x72, 0x02, 0x18, 0x64, 0x52, 0x10, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x19, 0x0a, 0x08, 0x69, 0x63, 0x6f, 0x6e, 0x5f, 0x75, + 0x72, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x69, 0x63, 0x6f, 0x6e, 0x55, 0x72, + 0x6c, 0x22, 0xa9, 0x01, 0x0a, 0x0f, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x43, 0x6f, + 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x2f, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x61, 0x73, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, + 0x05, 0x72, 0x75, 0x6e, 0x41, 0x73, 0x12, 0x30, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, + 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x61, 0x6c, 0x6c, 0x6f, + 0x77, 0x5f, 0x61, 0x6e, 0x6f, 0x6e, 0x79, 0x6d, 0x6f, 0x75, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x0e, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x41, 0x6e, 0x6f, 0x6e, 0x79, 0x6d, 0x6f, 0x75, + 0x73, 0x4a, 0x04, 0x08, 0x03, 0x10, 0x04, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x22, 0x41, 0x0a, + 0x09, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x53, 0x70, 0x65, 0x63, 0x12, 0x10, 0x0a, 0x03, 0x74, 0x61, + 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x74, 0x61, 0x67, 0x12, 0x22, 0x0a, 0x0d, + 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x6a, 0x6f, 0x62, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0b, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x4a, 0x6f, 0x62, 0x55, 0x72, 0x6c, + 0x22, 0x40, 0x0a, 0x0c, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x53, 0x70, 0x65, 0x63, 0x53, 0x65, 0x74, + 0x12, 0x30, 0x0a, 0x06, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, + 0x2e, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x53, 0x70, 0x65, 0x63, 0x52, 0x06, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x73, 0x22, 0x5d, 0x0a, 0x0d, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x12, 0x1c, 0x0a, + 0x09, 0x73, 0x75, 0x62, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x73, 0x75, 0x62, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x63, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, 0x6e, 0x61, 0x6d, + 0x65, 0x22, 0xd3, 0x01, 0x0a, 0x11, 0x41, 0x75, 0x74, 0x6f, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, + 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x33, 0x0a, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x73, 0x52, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x44, 0x0a, 0x10, + 0x73, 0x63, 0x61, 0x6c, 0x65, 0x64, 0x6f, 0x77, 0x6e, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x0f, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x64, 0x6f, 0x77, 0x6e, 0x50, 0x65, 0x72, 0x69, + 0x6f, 0x64, 0x12, 0x43, 0x0a, 0x0e, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x5f, 0x6d, 0x65, + 0x74, 0x72, 0x69, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x53, 0x63, 0x61, 0x6c, 0x69, + 0x6e, 0x67, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x52, 0x0d, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, + 0x67, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x22, 0xa1, 0x01, 0x0a, 0x0d, 0x53, 0x63, 0x61, 0x6c, + 0x69, 0x6e, 0x67, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x3f, 0x0a, 0x0c, 0x72, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x72, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x61, 0x74, 0x65, 0x12, 0x3e, 0x0a, 0x0b, 0x63, 0x6f, + 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, + 0x43, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x48, 0x00, 0x52, 0x0b, 0x63, + 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x42, 0x0f, 0x0a, 0x06, 0x6d, 0x65, + 0x74, 0x72, 0x69, 0x63, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, 0x39, 0x0a, 0x0b, 0x43, + 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x2a, 0x0a, 0x0c, 0x74, 0x61, + 0x72, 0x67, 0x65, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, + 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, 0x02, 0x20, 0x00, 0x52, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, + 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x39, 0x0a, 0x0b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x52, 0x61, 0x74, 0x65, 0x12, 0x2a, 0x0a, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, + 0x2a, 0x02, 0x28, 0x00, 0x52, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x22, 0x40, 0x0a, 0x08, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x19, 0x0a, + 0x03, 0x6d, 0x69, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, + 0x02, 0x28, 0x00, 0x52, 0x03, 0x6d, 0x69, 0x6e, 0x12, 0x19, 0x0a, 0x03, 0x6d, 0x61, 0x78, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, 0x02, 0x28, 0x00, 0x52, 0x03, + 0x6d, 0x61, 0x78, 0x22, 0x62, 0x0a, 0x0d, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x43, 0x6f, + 0x6e, 0x66, 0x69, 0x67, 0x12, 0x51, 0x0a, 0x0f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, + 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x0d, 0xba, 0x48, 0x0a, 0xaa, 0x01, 0x07, + 0x22, 0x03, 0x08, 0x90, 0x1c, 0x32, 0x00, 0x52, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x42, 0xaf, 0x01, 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x42, 0x12, 0x41, + 0x70, 0x70, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, + 0x6f, 0x50, 0x01, 0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, + 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0xa2, 0x02, 0x03, 0x46, 0x41, 0x58, 0xaa, 0x02, 0x0d, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x41, 0x70, 0x70, 0xca, 0x02, 0x0d, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, 0xe2, 0x02, 0x19, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, 0x5c, 0x47, 0x50, 0x42, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x41, 0x70, 0x70, 0x4a, 0xe3, 0x7e, 0x0a, 0x07, 0x12, 0x05, + 0x00, 0x00, 0xbb, 0x03, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, + 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x16, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, + 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x29, 0x0a, + 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, 0x30, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x03, + 0x12, 0x03, 0x07, 0x00, 0x2a, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x04, 0x12, 0x03, 0x08, 0x00, 0x27, + 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x05, 0x12, 0x03, 0x09, 0x00, 0x24, 0x0a, 0x09, 0x0a, 0x02, 0x03, + 0x06, 0x12, 0x03, 0x0a, 0x00, 0x28, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x07, 0x12, 0x03, 0x0b, 0x00, + 0x29, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x0d, 0x00, 0x48, 0x0a, 0x09, 0x0a, 0x02, 0x08, + 0x0b, 0x12, 0x03, 0x0d, 0x00, 0x48, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0f, 0x00, + 0x21, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0f, 0x08, 0x12, 0x0a, 0x2b, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x11, 0x02, 0x11, 0x1a, 0x1e, 0x20, 0x4f, 0x72, + 0x67, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x62, + 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x11, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x11, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x11, 0x0f, 0x10, 0x0a, 0x2f, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x14, + 0x02, 0x3f, 0x1a, 0x22, 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x6e, 0x67, + 0x73, 0x20, 0x74, 0x6f, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, + 0x03, 0x14, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x14, + 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x14, 0x13, 0x14, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x08, 0x12, 0x03, 0x14, 0x15, 0x3e, 0x0a, 0x10, + 0x0a, 0x09, 0x04, 0x00, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x14, 0x16, 0x3d, + 0x0a, 0x2e, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x17, 0x02, 0x3e, 0x1a, 0x21, 0x20, + 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x61, 0x70, 0x70, 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x17, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x17, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x17, 0x12, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x02, 0x08, 0x12, 0x03, 0x17, 0x14, 0x3d, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x02, + 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x17, 0x15, 0x3c, 0x0a, 0x38, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x03, 0x12, 0x04, 0x1a, 0x02, 0x20, 0x04, 0x1a, 0x2a, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x70, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, + 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x05, 0x12, 0x03, 0x1a, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x1a, 0x09, 0x0d, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x1a, 0x10, 0x11, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x08, 0x12, 0x04, 0x1a, 0x12, 0x20, 0x03, 0x0a, 0x10, 0x0a, + 0x09, 0x04, 0x00, 0x02, 0x03, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x1b, 0x04, 0x2b, 0x0a, + 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x03, 0x08, 0x87, 0x09, 0x0e, 0x03, 0x12, 0x03, 0x1c, 0x04, + 0x2c, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x03, 0x08, 0x87, 0x09, 0x0e, 0x06, 0x12, 0x03, + 0x1f, 0x04, 0x5b, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x23, 0x00, 0x2c, 0x01, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x23, 0x08, 0x0c, 0x0a, 0x1d, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x00, 0x12, 0x03, 0x25, 0x02, 0x3b, 0x1a, 0x10, 0x20, 0x49, 0x44, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x06, 0x12, 0x03, 0x25, 0x02, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x25, 0x0d, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x25, 0x12, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x08, 0x12, 0x03, 0x25, + 0x14, 0x3a, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x01, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, + 0x25, 0x15, 0x39, 0x0a, 0x2a, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x28, 0x02, 0x3c, + 0x1a, 0x1d, 0x20, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, 0x28, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x28, 0x09, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x28, 0x14, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x01, 0x08, 0x12, 0x03, 0x28, 0x16, 0x3b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x01, 0x02, 0x01, 0x08, + 0x87, 0x09, 0x06, 0x05, 0x12, 0x03, 0x28, 0x17, 0x3a, 0x0a, 0x22, 0x0a, 0x04, 0x04, 0x01, 0x02, + 0x02, 0x12, 0x03, 0x2b, 0x02, 0x21, 0x1a, 0x15, 0x20, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x02, 0x06, 0x12, 0x03, 0x2b, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x2b, 0x16, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x02, 0x03, 0x12, 0x03, 0x2b, 0x1f, 0x20, 0x0a, 0x62, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x2f, + 0x00, 0x35, 0x01, 0x1a, 0x56, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, + 0x61, 0x6c, 0x20, 0x75, 0x73, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x2e, 0x20, 0x54, + 0x68, 0x69, 0x73, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x75, + 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x72, 0x61, 0x70, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x61, 0x70, 0x70, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x02, 0x01, 0x12, 0x03, 0x2f, 0x08, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, + 0x03, 0x30, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, 0x30, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x30, 0x09, 0x0d, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x30, 0x10, 0x11, 0x0a, 0x0c, + 0x0a, 0x04, 0x04, 0x02, 0x08, 0x00, 0x12, 0x04, 0x31, 0x02, 0x34, 0x03, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x08, 0x00, 0x01, 0x12, 0x03, 0x31, 0x08, 0x0f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x32, 0x04, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x06, + 0x12, 0x03, 0x32, 0x04, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x32, 0x08, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x32, 0x0e, + 0x0f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x02, 0x12, 0x03, 0x33, 0x04, 0x1a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x06, 0x12, 0x03, 0x33, 0x04, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, 0x33, 0x0f, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x02, 0x03, 0x12, 0x03, 0x33, 0x18, 0x19, 0x0a, 0x42, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, + 0x38, 0x00, 0x41, 0x01, 0x1a, 0x36, 0x20, 0x52, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, + 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x70, 0x70, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x69, 0x74, + 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x61, 0x6e, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x03, 0x01, 0x12, 0x03, 0x38, 0x08, 0x0b, 0x0a, 0x23, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, + 0x12, 0x03, 0x3a, 0x02, 0x3b, 0x1a, 0x16, 0x20, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x3a, 0x02, 0x06, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x3a, 0x07, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x3a, 0x12, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x08, + 0x12, 0x03, 0x3a, 0x14, 0x3a, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x03, 0x02, 0x00, 0x08, 0x87, 0x09, + 0x19, 0x12, 0x03, 0x3a, 0x15, 0x39, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, + 0x3d, 0x02, 0x37, 0x1a, 0x1b, 0x20, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x06, 0x12, 0x03, 0x3d, 0x02, 0x06, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, 0x3d, 0x07, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x3d, 0x0e, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x01, 0x08, 0x12, 0x03, 0x3d, 0x10, 0x36, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x03, 0x02, 0x01, + 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x3d, 0x11, 0x35, 0x0a, 0x21, 0x0a, 0x04, 0x04, 0x03, 0x02, + 0x02, 0x12, 0x03, 0x40, 0x02, 0x14, 0x1a, 0x14, 0x20, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x02, 0x06, 0x12, 0x03, 0x40, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x40, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, + 0x03, 0x12, 0x03, 0x40, 0x12, 0x13, 0x0a, 0xef, 0x08, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x61, + 0x00, 0x71, 0x01, 0x1a, 0x25, 0x20, 0x52, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, + 0x66, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x32, 0xbb, 0x08, 0x20, 0x53, 0x74, + 0x61, 0x74, 0x65, 0x20, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x0a, 0x0a, + 0xe2, 0x94, 0x8c, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, + 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, + 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x90, + 0x0a, 0xe2, 0x94, 0x82, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0xe2, 0x94, 0x82, 0x0a, 0xe2, 0x94, 0x8c, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, + 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, + 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x96, 0xba, 0x20, 0x20, 0x55, 0x6e, 0x61, 0x73, + 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x20, 0xe2, 0x94, 0x82, 0x0a, 0xe2, 0x94, 0x82, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xe2, 0x94, 0x82, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xe2, 0x94, 0x82, 0x0a, 0xe2, 0x94, + 0x82, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xe2, 0x94, 0x94, 0xe2, 0x94, + 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, + 0xe2, 0x94, 0xac, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, + 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x98, 0x0a, 0xe2, 0x94, 0x82, 0x4c, + 0x65, 0x61, 0x73, 0x65, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0xe2, 0x94, 0x82, 0x0a, 0xe2, 0x94, 0x82, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x64, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xe2, 0x94, 0x82, 0x20, 0x4c, 0x65, 0x61, 0x73, + 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x0a, + 0xe2, 0x94, 0x82, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0xe2, 0x94, 0x82, 0x0a, 0xe2, 0x94, 0x82, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0xe2, 0x94, 0x8c, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, + 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x96, 0xbc, 0xe2, 0x94, 0x80, + 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, + 0x94, 0x80, 0xe2, 0x94, 0x90, 0x0a, 0xe2, 0x94, 0x82, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0xe2, 0x94, 0x82, 0x20, 0x20, 0x20, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, + 0x64, 0x20, 0x20, 0x20, 0xe2, 0x94, 0x82, 0x0a, 0xe2, 0x94, 0x94, 0xe2, 0x94, 0x80, 0xe2, 0x94, + 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, + 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0xbc, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x2b, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xe2, 0x94, 0x82, 0x0a, 0xe2, 0x94, + 0x82, 0x20, 0x20, 0x20, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x20, 0x20, 0x20, 0x20, 0xe2, + 0x94, 0x82, 0x0a, 0xe2, 0x94, 0x94, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, + 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0xac, 0xe2, 0x94, 0x80, 0xe2, 0x94, + 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, + 0xe2, 0x94, 0x98, 0x0a, 0xe2, 0x94, 0x82, 0x0a, 0xe2, 0x94, 0x82, 0x20, 0x41, 0x63, 0x6b, 0x6e, + 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x0a, 0xe2, 0x94, 0x82, 0x0a, 0xe2, 0x94, 0x8c, 0xe2, 0x94, 0x80, 0xe2, 0x94, + 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x96, 0xbc, + 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, + 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x90, 0x0a, 0xe2, 0x94, 0x8c, 0xe2, 0x94, 0x80, 0xe2, + 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, + 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x96, 0xba, 0x20, 0x20, 0x20, + 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x20, 0x20, 0x20, 0xe2, 0x94, 0x82, 0x0a, 0xe2, + 0x94, 0x82, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xe2, 0x94, 0x94, 0xe2, + 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, + 0x80, 0xe2, 0x94, 0xac, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, + 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x98, 0x0a, 0xe2, 0x94, 0x82, + 0x4e, 0x65, 0x77, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0xe2, 0x94, 0x82, 0x0a, 0xe2, 0x94, 0x82, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xe2, 0x94, 0x82, 0x20, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x64, 0x20, 0x62, 0x79, + 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x0a, 0xe2, 0x94, 0x82, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xe2, 0x94, 0x82, + 0x0a, 0xe2, 0x94, 0x82, 0x20, 0x20, 0x20, 0x20, 0x20, 0xe2, 0x94, 0x8c, 0xe2, 0x94, 0x80, 0xe2, + 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, + 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x96, 0xbc, + 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, + 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, + 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x90, 0x0a, 0xe2, 0x94, 0x94, 0xe2, 0x94, 0x80, 0xe2, 0x94, + 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0xbc, 0x20, 0x53, 0x74, + 0x6f, 0x70, 0x70, 0x65, 0x64, 0x2f, 0x53, 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, 0x2f, 0x46, 0x61, + 0x69, 0x6c, 0x65, 0x64, 0x20, 0xe2, 0x94, 0x82, 0x0a, 0xe2, 0x94, 0x94, 0xe2, 0x94, 0x80, 0xe2, + 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, + 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, + 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, + 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, + 0x80, 0xe2, 0x94, 0x80, 0xe2, 0x94, 0x98, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, + 0x03, 0x61, 0x08, 0x11, 0x0a, 0x35, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x63, 0x02, + 0x35, 0x1a, 0x28, 0x20, 0x4c, 0x61, 0x73, 0x74, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x00, 0x06, 0x12, 0x03, 0x63, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x63, 0x1c, 0x30, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x63, 0x33, 0x34, 0x0a, 0x2c, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x66, + 0x02, 0x30, 0x1a, 0x1f, 0x20, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x20, + 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, + 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x06, 0x12, 0x03, 0x66, 0x02, + 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x66, 0x1a, 0x2b, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x66, 0x2e, 0x2f, 0x0a, 0x29, 0x0a, + 0x04, 0x04, 0x04, 0x02, 0x02, 0x12, 0x03, 0x69, 0x02, 0x15, 0x1a, 0x1c, 0x20, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, + 0x05, 0x12, 0x03, 0x69, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x69, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, 0x69, + 0x13, 0x14, 0x0a, 0x84, 0x01, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x03, 0x12, 0x03, 0x6d, 0x02, 0x3c, + 0x1a, 0x77, 0x20, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, + 0x73, 0x20, 0x74, 0x6f, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, + 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, + 0x65, 0x72, 0x73, 0x0a, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x74, 0x72, 0x6f, 0x73, 0x70, 0x65, + 0x63, 0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x76, 0x69, 0x73, 0x75, 0x61, 0x6c, 0x69, 0x7a, 0x65, + 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x73, + 0x20, 0x61, 0x72, 0x65, 0x20, 0x75, 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x03, 0x05, 0x12, 0x03, 0x6d, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x01, + 0x12, 0x03, 0x6d, 0x09, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x03, 0x12, 0x03, + 0x6d, 0x14, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x08, 0x12, 0x03, 0x6d, 0x16, + 0x3b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x04, 0x02, 0x03, 0x08, 0x87, 0x09, 0x06, 0x05, 0x12, 0x03, + 0x6d, 0x17, 0x3a, 0x0a, 0x40, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x04, 0x12, 0x03, 0x70, 0x02, 0x24, + 0x1a, 0x33, 0x20, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, + 0x61, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x06, 0x12, 0x03, + 0x70, 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x01, 0x12, 0x03, 0x70, 0x1a, + 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x03, 0x12, 0x03, 0x70, 0x22, 0x23, 0x0a, + 0x2f, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x05, 0x74, 0x00, 0xa8, 0x01, 0x01, 0x1a, 0x22, 0x20, 0x52, + 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x74, 0x08, 0x0e, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x75, 0x02, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x75, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x75, 0x09, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x75, 0x1c, 0x1d, 0x0a, 0x37, 0x0a, 0x04, 0x04, 0x05, 0x04, 0x00, 0x12, 0x05, 0x78, 0x02, 0x8f, + 0x01, 0x03, 0x1a, 0x28, 0x20, 0x45, 0x6e, 0x75, 0x6d, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x64, 0x65, + 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x04, 0x00, 0x01, 0x12, 0x03, 0x78, 0x07, 0x17, 0x0a, 0x2f, 0x0a, 0x06, 0x04, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x7a, 0x04, 0x26, 0x1a, 0x20, 0x20, 0x55, 0x6e, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, + 0x6e, 0x74, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x7a, 0x04, 0x21, 0x0a, 0x0e, 0x0a, 0x07, 0x04, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x7a, 0x24, 0x25, 0x0a, 0x51, 0x0a, 0x06, 0x04, + 0x05, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x7c, 0x04, 0x25, 0x1a, 0x42, 0x20, 0x44, 0x65, 0x70, + 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x73, 0x20, 0x65, 0x6e, 0x61, 0x62, 0x6c, + 0x65, 0x64, 0x20, 0x62, 0x75, 0x74, 0x20, 0x68, 0x61, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x62, 0x65, + 0x65, 0x6e, 0x20, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x61, + 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x79, 0x65, 0x74, 0x2e, 0x0a, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x7c, 0x04, 0x20, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x7c, 0x23, 0x24, 0x0a, 0x56, + 0x0a, 0x06, 0x04, 0x05, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x7e, 0x04, 0x23, 0x1a, 0x47, 0x20, + 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x73, + 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x20, 0x62, 0x75, 0x74, 0x20, 0x68, 0x61, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x62, + 0x65, 0x65, 0x6e, 0x20, 0x61, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x64, + 0x20, 0x79, 0x65, 0x74, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, 0x02, + 0x01, 0x12, 0x03, 0x7e, 0x04, 0x1e, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, 0x02, + 0x02, 0x12, 0x03, 0x7e, 0x21, 0x22, 0x0a, 0x52, 0x0a, 0x06, 0x04, 0x05, 0x04, 0x00, 0x02, 0x03, + 0x12, 0x04, 0x80, 0x01, 0x04, 0x22, 0x1a, 0x42, 0x20, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, + 0x65, 0x6e, 0x74, 0x20, 0x69, 0x73, 0x20, 0x70, 0x69, 0x63, 0x6b, 0x65, 0x64, 0x20, 0x75, 0x70, + 0x20, 0x62, 0x79, 0x20, 0x61, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x62, 0x75, + 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x77, 0x61, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x65, + 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x05, + 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x04, 0x80, 0x01, 0x04, 0x1d, 0x0a, 0x0f, 0x0a, 0x07, 0x04, + 0x05, 0x04, 0x00, 0x02, 0x03, 0x02, 0x12, 0x04, 0x80, 0x01, 0x20, 0x21, 0x0a, 0x29, 0x0a, 0x06, + 0x04, 0x05, 0x04, 0x00, 0x02, 0x04, 0x12, 0x04, 0x82, 0x01, 0x04, 0x22, 0x1a, 0x19, 0x20, 0x44, + 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x73, 0x20, 0x64, 0x69, 0x73, + 0x61, 0x62, 0x6c, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, + 0x04, 0x01, 0x12, 0x04, 0x82, 0x01, 0x04, 0x1d, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, + 0x02, 0x04, 0x02, 0x12, 0x04, 0x82, 0x01, 0x20, 0x21, 0x0a, 0x57, 0x0a, 0x06, 0x04, 0x05, 0x04, + 0x00, 0x02, 0x05, 0x12, 0x04, 0x84, 0x01, 0x04, 0x36, 0x1a, 0x47, 0x20, 0x44, 0x65, 0x70, 0x6c, + 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, + 0x74, 0x65, 0x64, 0x2e, 0x20, 0x50, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x75, 0x73, 0x65, 0x20, + 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, + 0x53, 0x5f, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, + 0x2e, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, 0x05, 0x01, 0x12, 0x04, 0x84, + 0x01, 0x04, 0x1d, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, 0x05, 0x02, 0x12, 0x04, + 0x84, 0x01, 0x20, 0x21, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, 0x05, 0x03, 0x12, + 0x04, 0x84, 0x01, 0x22, 0x35, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x05, 0x04, 0x00, 0x02, 0x05, 0x03, + 0x01, 0x12, 0x04, 0x84, 0x01, 0x23, 0x34, 0x0a, 0x28, 0x0a, 0x06, 0x04, 0x05, 0x04, 0x00, 0x02, + 0x06, 0x12, 0x04, 0x86, 0x01, 0x04, 0x21, 0x1a, 0x18, 0x20, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, + 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x2e, + 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, 0x06, 0x01, 0x12, 0x04, 0x86, 0x01, + 0x04, 0x1c, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, 0x06, 0x02, 0x12, 0x04, 0x86, + 0x01, 0x1f, 0x20, 0x0a, 0x2a, 0x0a, 0x06, 0x04, 0x05, 0x04, 0x00, 0x02, 0x07, 0x12, 0x04, 0x88, + 0x01, 0x04, 0x21, 0x1a, 0x1a, 0x20, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, + 0x20, 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a, + 0x0f, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, 0x07, 0x01, 0x12, 0x04, 0x88, 0x01, 0x04, 0x1c, + 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, 0x07, 0x02, 0x12, 0x04, 0x88, 0x01, 0x1f, + 0x20, 0x0a, 0x55, 0x0a, 0x06, 0x04, 0x05, 0x04, 0x00, 0x02, 0x08, 0x12, 0x04, 0x8a, 0x01, 0x04, + 0x25, 0x1a, 0x45, 0x20, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6e, + 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x64, 0x65, 0x73, + 0x69, 0x72, 0x65, 0x64, 0x20, 0x61, 0x70, 0x70, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x73, 0x20, 0x3e, 0x20, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x20, 0x61, 0x70, 0x70, 0x20, 0x72, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, + 0x02, 0x08, 0x01, 0x12, 0x04, 0x8a, 0x01, 0x04, 0x20, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x05, 0x04, + 0x00, 0x02, 0x08, 0x02, 0x12, 0x04, 0x8a, 0x01, 0x23, 0x24, 0x0a, 0x55, 0x0a, 0x06, 0x04, 0x05, + 0x04, 0x00, 0x02, 0x09, 0x12, 0x04, 0x8c, 0x01, 0x04, 0x27, 0x1a, 0x45, 0x20, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x20, 0x61, 0x70, + 0x70, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, 0x3c, 0x20, 0x61, 0x63, 0x74, + 0x75, 0x61, 0x6c, 0x20, 0x61, 0x70, 0x70, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, + 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, 0x09, 0x01, 0x12, 0x04, 0x8c, 0x01, + 0x04, 0x22, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, 0x09, 0x02, 0x12, 0x04, 0x8c, + 0x01, 0x25, 0x26, 0x0a, 0x47, 0x0a, 0x06, 0x04, 0x05, 0x04, 0x00, 0x02, 0x0a, 0x12, 0x04, 0x8e, + 0x01, 0x04, 0x25, 0x1a, 0x37, 0x20, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x65, 0x64, 0x20, + 0x69, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x20, 0x61, 0x70, 0x70, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x20, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x69, 0x6e, 0x67, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, + 0x04, 0x05, 0x04, 0x00, 0x02, 0x0a, 0x01, 0x12, 0x04, 0x8e, 0x01, 0x04, 0x1f, 0x0a, 0x0f, 0x0a, + 0x07, 0x04, 0x05, 0x04, 0x00, 0x02, 0x0a, 0x02, 0x12, 0x04, 0x8e, 0x01, 0x22, 0x24, 0x0a, 0x2b, + 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x04, 0x92, 0x01, 0x02, 0x44, 0x1a, 0x1d, 0x20, 0x43, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, + 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x01, 0x05, 0x12, 0x04, 0x92, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x01, 0x01, 0x12, 0x04, 0x92, 0x01, 0x09, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x01, 0x03, 0x12, 0x04, 0x92, 0x01, 0x1c, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, + 0x08, 0x12, 0x04, 0x92, 0x01, 0x1e, 0x43, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x05, 0x02, 0x01, 0x08, + 0x87, 0x09, 0x05, 0x05, 0x12, 0x04, 0x92, 0x01, 0x1f, 0x42, 0x0a, 0x30, 0x0a, 0x04, 0x04, 0x05, + 0x02, 0x02, 0x12, 0x04, 0x95, 0x01, 0x02, 0x16, 0x1a, 0x22, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, + 0x6f, 0x66, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x55, 0x52, 0x4c, 0x73, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x02, 0x06, 0x12, 0x04, 0x95, 0x01, 0x02, 0x09, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x02, 0x01, 0x12, 0x04, 0x95, 0x01, 0x0a, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x02, 0x03, 0x12, 0x04, 0x95, 0x01, 0x14, 0x15, 0x0a, 0x44, 0x0a, 0x04, 0x04, 0x05, 0x02, + 0x03, 0x12, 0x04, 0x98, 0x01, 0x02, 0x2b, 0x1a, 0x36, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x64, 0x41, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, + 0x77, 0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x77, 0x61, 0x73, + 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x06, 0x12, 0x04, 0x98, 0x01, 0x02, 0x1b, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x01, 0x12, 0x04, 0x98, 0x01, 0x1c, 0x26, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x03, 0x03, 0x12, 0x04, 0x98, 0x01, 0x29, 0x2a, 0x0a, 0x47, 0x0a, 0x04, + 0x04, 0x05, 0x02, 0x04, 0x12, 0x04, 0x9b, 0x01, 0x02, 0x30, 0x1a, 0x39, 0x20, 0x4c, 0x61, 0x73, + 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x61, 0x70, 0x70, 0x20, 0x77, 0x61, 0x73, 0x20, 0x6c, 0x61, 0x73, 0x74, 0x20, 0x75, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x64, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x06, 0x12, 0x04, + 0x9b, 0x01, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x01, 0x12, 0x04, 0x9b, + 0x01, 0x1c, 0x2b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x03, 0x12, 0x04, 0x9b, 0x01, + 0x2e, 0x2f, 0x0a, 0x27, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x05, 0x12, 0x04, 0x9e, 0x01, 0x02, 0x24, + 0x1a, 0x19, 0x20, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x05, 0x04, 0x12, 0x04, 0x9e, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x05, 0x06, 0x12, 0x04, 0x9e, 0x01, 0x0b, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x05, 0x01, 0x12, 0x04, 0x9e, 0x01, 0x15, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x05, + 0x03, 0x12, 0x04, 0x9e, 0x01, 0x22, 0x23, 0x0a, 0xec, 0x01, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x06, + 0x12, 0x04, 0xa2, 0x01, 0x02, 0x31, 0x1a, 0xdd, 0x01, 0x20, 0x4c, 0x65, 0x61, 0x73, 0x65, 0x45, + 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x73, + 0x20, 0x74, 0x6f, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x61, 0x70, 0x70, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x20, 0x74, + 0x6f, 0x20, 0x61, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x69, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x63, + 0x65, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x74, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x0a, 0x20, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x20, + 0x65, 0x78, 0x70, 0x69, 0x72, 0x65, 0x73, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6e, 0x6f, 0x20, 0x6c, 0x6f, 0x6e, + 0x67, 0x65, 0x72, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x20, 0x74, + 0x6f, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x70, + 0x70, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x63, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x70, 0x69, 0x63, 0x6b, 0x20, 0x69, + 0x74, 0x20, 0x75, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, 0x06, 0x12, + 0x04, 0xa2, 0x01, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, 0x01, 0x12, 0x04, + 0xa2, 0x01, 0x1c, 0x2c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, 0x03, 0x12, 0x04, 0xa2, + 0x01, 0x2f, 0x30, 0x0a, 0x4f, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x07, 0x12, 0x04, 0xa5, 0x01, 0x02, + 0x1f, 0x1a, 0x41, 0x20, 0x4b, 0x38, 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, + 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4b, 0x38, 0x73, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x06, 0x12, 0x04, 0xa5, + 0x01, 0x02, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x01, 0x12, 0x04, 0xa5, 0x01, + 0x0e, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x03, 0x12, 0x04, 0xa5, 0x01, 0x1d, + 0x1e, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x08, 0x12, 0x04, 0xa7, 0x01, 0x02, 0x2d, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x08, 0x06, 0x12, 0x04, 0xa7, 0x01, 0x02, 0x14, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x08, 0x01, 0x12, 0x04, 0xa7, 0x01, 0x15, 0x28, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x08, 0x03, 0x12, 0x04, 0xa7, 0x01, 0x2b, 0x2c, 0x0a, 0x0c, 0x0a, 0x02, + 0x04, 0x06, 0x12, 0x06, 0xaa, 0x01, 0x00, 0xad, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x06, + 0x01, 0x12, 0x04, 0xaa, 0x01, 0x08, 0x13, 0x0a, 0x49, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, + 0x04, 0xac, 0x01, 0x02, 0x17, 0x1a, 0x3b, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, + 0x65, 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, + 0x70, 0x20, 0x69, 0x73, 0x20, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x20, 0x69, 0x6e, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x05, 0x12, 0x04, 0xac, 0x01, 0x02, + 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x04, 0xac, 0x01, 0x09, 0x12, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x04, 0xac, 0x01, 0x15, 0x16, 0x0a, + 0x0c, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x06, 0xaf, 0x01, 0x00, 0xc1, 0x01, 0x01, 0x0a, 0x0b, 0x0a, + 0x03, 0x04, 0x07, 0x01, 0x12, 0x04, 0xaf, 0x01, 0x08, 0x0f, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x07, + 0x02, 0x00, 0x12, 0x06, 0xb1, 0x01, 0x02, 0xb4, 0x01, 0x04, 0x1a, 0x18, 0x20, 0x50, 0x75, 0x62, + 0x6c, 0x69, 0x63, 0x20, 0x55, 0x52, 0x4c, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, + 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x05, 0x12, 0x04, 0xb1, + 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x01, 0x12, 0x04, 0xb1, 0x01, + 0x09, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x03, 0x12, 0x04, 0xb1, 0x01, 0x16, + 0x17, 0x0a, 0x0f, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x08, 0x12, 0x06, 0xb1, 0x01, 0x18, 0xb4, + 0x01, 0x03, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x07, 0x02, 0x00, 0x08, 0x87, 0x09, 0x1b, 0x12, 0x04, + 0xb2, 0x01, 0x04, 0x36, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x07, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, + 0x11, 0x12, 0x04, 0xb3, 0x01, 0x04, 0x2a, 0x0a, 0x38, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x01, 0x12, + 0x06, 0xb7, 0x01, 0x02, 0xba, 0x01, 0x04, 0x1a, 0x28, 0x20, 0x43, 0x61, 0x6e, 0x6f, 0x6e, 0x69, + 0x63, 0x61, 0x6c, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x28, 0x43, 0x4e, 0x41, 0x4d, 0x45, 0x29, + 0x20, 0x55, 0x52, 0x4c, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x05, 0x12, 0x04, 0xb7, 0x01, 0x02, 0x08, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x01, 0x12, 0x04, 0xb7, 0x01, 0x09, 0x12, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, 0x04, 0xb7, 0x01, 0x15, 0x16, 0x0a, 0x0f, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x08, 0x12, 0x06, 0xb7, 0x01, 0x17, 0xba, 0x01, 0x03, 0x0a, + 0x10, 0x0a, 0x08, 0x04, 0x07, 0x02, 0x01, 0x08, 0x87, 0x09, 0x1b, 0x12, 0x04, 0xb8, 0x01, 0x04, + 0x36, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x07, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, 0x11, 0x12, 0x04, + 0xb9, 0x01, 0x04, 0x2a, 0x0a, 0x25, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x02, 0x12, 0x06, 0xbd, 0x01, + 0x02, 0xc0, 0x01, 0x04, 0x1a, 0x15, 0x20, 0x56, 0x50, 0x43, 0x20, 0x55, 0x52, 0x4c, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x02, 0x05, 0x12, 0x04, 0xbd, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x02, 0x01, 0x12, 0x04, 0xbd, 0x01, 0x09, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x02, 0x03, 0x12, 0x04, 0xbd, 0x01, 0x13, 0x14, 0x0a, 0x0f, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, + 0x08, 0x12, 0x06, 0xbd, 0x01, 0x15, 0xc0, 0x01, 0x03, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x07, 0x02, + 0x02, 0x08, 0x87, 0x09, 0x1b, 0x12, 0x04, 0xbe, 0x01, 0x04, 0x36, 0x0a, 0x11, 0x0a, 0x09, 0x04, + 0x07, 0x02, 0x02, 0x08, 0x87, 0x09, 0x0e, 0x11, 0x12, 0x04, 0xbf, 0x01, 0x04, 0x2a, 0x0a, 0x37, + 0x0a, 0x02, 0x04, 0x08, 0x12, 0x06, 0xc4, 0x01, 0x00, 0x83, 0x02, 0x01, 0x1a, 0x29, 0x20, 0x52, + 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x61, + 0x6e, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x08, 0x01, 0x12, 0x04, + 0xc4, 0x01, 0x08, 0x0c, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x08, 0x08, 0x00, 0x12, 0x06, 0xc6, 0x01, + 0x02, 0xce, 0x01, 0x03, 0x1a, 0x43, 0x20, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2c, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, + 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x61, + 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x61, 0x20, + 0x4b, 0x38, 0x73, 0x20, 0x70, 0x6f, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x08, + 0x00, 0x01, 0x12, 0x04, 0xc6, 0x01, 0x08, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x08, 0x00, + 0x02, 0x12, 0x04, 0xc7, 0x01, 0x04, 0x30, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x08, 0x08, 0x00, 0x02, + 0x87, 0x09, 0x01, 0x12, 0x04, 0xc7, 0x01, 0x04, 0x30, 0x0a, 0x22, 0x0a, 0x04, 0x04, 0x08, 0x02, + 0x00, 0x12, 0x04, 0xca, 0x01, 0x04, 0x2b, 0x1a, 0x14, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x00, 0x06, 0x12, 0x04, 0xca, 0x01, 0x04, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x04, 0xca, 0x01, 0x1d, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x00, 0x03, 0x12, 0x04, 0xca, 0x01, 0x29, 0x2a, 0x0a, 0x20, 0x0a, 0x04, 0x04, 0x08, + 0x02, 0x01, 0x12, 0x04, 0xcd, 0x01, 0x04, 0x22, 0x1a, 0x12, 0x20, 0x4b, 0x38, 0x73, 0x20, 0x70, + 0x6f, 0x64, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x08, 0x02, 0x01, 0x06, 0x12, 0x04, 0xcd, 0x01, 0x04, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x01, 0x01, 0x12, 0x04, 0xcd, 0x01, 0x1a, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x01, 0x03, 0x12, 0x04, 0xcd, 0x01, 0x20, 0x21, 0x0a, 0x36, 0x0a, 0x04, 0x04, 0x08, 0x02, + 0x02, 0x12, 0x04, 0xd1, 0x01, 0x02, 0x24, 0x1a, 0x28, 0x20, 0x41, 0x75, 0x74, 0x6f, 0x73, 0x63, + 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x06, 0x12, 0x04, 0xd1, 0x01, 0x02, 0x13, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x01, 0x12, 0x04, 0xd1, 0x01, 0x14, 0x1f, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x03, 0x12, 0x04, 0xd1, 0x01, 0x22, 0x23, 0x0a, 0x32, + 0x0a, 0x04, 0x04, 0x08, 0x02, 0x03, 0x12, 0x04, 0xd4, 0x01, 0x02, 0x1c, 0x1a, 0x24, 0x20, 0x49, + 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x06, 0x12, 0x04, 0xd4, 0x01, 0x02, + 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x01, 0x12, 0x04, 0xd4, 0x01, 0x10, 0x17, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x03, 0x12, 0x04, 0xd4, 0x01, 0x1a, 0x1b, 0x0a, + 0x38, 0x0a, 0x04, 0x04, 0x08, 0x04, 0x00, 0x12, 0x06, 0xd7, 0x01, 0x02, 0xe0, 0x01, 0x03, 0x1a, + 0x28, 0x20, 0x45, 0x6e, 0x75, 0x6d, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x70, 0x6c, 0x6f, + 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x04, + 0x00, 0x01, 0x12, 0x04, 0xd7, 0x01, 0x07, 0x13, 0x0a, 0x23, 0x0a, 0x06, 0x04, 0x08, 0x04, 0x00, + 0x02, 0x00, 0x12, 0x04, 0xd9, 0x01, 0x04, 0x22, 0x1a, 0x13, 0x20, 0x55, 0x6e, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x0a, 0x0a, 0x0f, 0x0a, + 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, 0xd9, 0x01, 0x04, 0x1d, 0x0a, 0x0f, + 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x04, 0xd9, 0x01, 0x20, 0x21, 0x0a, + 0x29, 0x0a, 0x06, 0x04, 0x08, 0x04, 0x00, 0x02, 0x01, 0x12, 0x04, 0xdb, 0x01, 0x04, 0x1e, 0x1a, + 0x19, 0x20, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x73, 0x20, + 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, + 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x04, 0xdb, 0x01, 0x04, 0x19, 0x0a, 0x0f, 0x0a, 0x07, 0x04, + 0x08, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x04, 0xdb, 0x01, 0x1c, 0x1d, 0x0a, 0x53, 0x0a, 0x06, + 0x04, 0x08, 0x04, 0x00, 0x02, 0x02, 0x12, 0x04, 0xdd, 0x01, 0x04, 0x32, 0x1a, 0x43, 0x20, 0x44, + 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6d, + 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x2e, 0x20, 0x50, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x75, + 0x73, 0x65, 0x20, 0x44, 0x45, 0x53, 0x49, 0x52, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, + 0x5f, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x2e, + 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x04, 0xdd, 0x01, + 0x04, 0x19, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, 0x02, 0x02, 0x12, 0x04, 0xdd, + 0x01, 0x1c, 0x1d, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x04, + 0xdd, 0x01, 0x1e, 0x31, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x08, 0x04, 0x00, 0x02, 0x02, 0x03, 0x01, + 0x12, 0x04, 0xdd, 0x01, 0x1f, 0x30, 0x0a, 0x2a, 0x0a, 0x06, 0x04, 0x08, 0x04, 0x00, 0x02, 0x03, + 0x12, 0x04, 0xdf, 0x01, 0x04, 0x1d, 0x1a, 0x1a, 0x20, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, + 0x65, 0x6e, 0x74, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, + 0x2e, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x04, 0xdf, + 0x01, 0x04, 0x18, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, 0x03, 0x02, 0x12, 0x04, + 0xdf, 0x01, 0x1b, 0x1c, 0x0a, 0x2d, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x04, 0x12, 0x04, 0xe3, 0x01, + 0x02, 0x21, 0x1a, 0x1f, 0x20, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x20, + 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, + 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x04, 0x06, 0x12, 0x04, 0xe3, 0x01, + 0x02, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x04, 0x01, 0x12, 0x04, 0xe3, 0x01, 0x0f, + 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x04, 0x03, 0x12, 0x04, 0xe3, 0x01, 0x1f, 0x20, + 0x0a, 0x60, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x05, 0x12, 0x04, 0xe6, 0x01, 0x02, 0x1a, 0x1a, 0x52, + 0x20, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x50, 0x6f, 0x6f, 0x6c, 0x20, 0x74, 0x6f, 0x20, + 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x70, 0x70, 0x20, 0x6f, + 0x6e, 0x2e, 0x20, 0x42, 0x79, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x69, 0x74, + 0x27, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, + 0x75, 0x6c, 0x74, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x70, 0x6f, 0x6f, 0x6c, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x05, 0x12, 0x04, 0xe6, 0x01, 0x02, + 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x01, 0x12, 0x04, 0xe6, 0x01, 0x09, 0x15, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x03, 0x12, 0x04, 0xe6, 0x01, 0x18, 0x19, 0x0a, + 0x38, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x06, 0x12, 0x04, 0xe9, 0x01, 0x02, 0x1a, 0x1a, 0x2a, 0x20, + 0x53, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x06, 0x06, 0x12, 0x04, 0xe9, 0x01, 0x02, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, + 0x01, 0x12, 0x04, 0xe9, 0x01, 0x0f, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x03, + 0x12, 0x04, 0xe9, 0x01, 0x18, 0x19, 0x0a, 0x5d, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x07, 0x12, 0x04, + 0xec, 0x01, 0x02, 0x27, 0x1a, 0x4f, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x5f, + 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x20, 0x65, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, + 0x61, 0x74, 0x65, 0x73, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x74, + 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, + 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x06, 0x12, 0x04, + 0xec, 0x01, 0x02, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x01, 0x12, 0x04, 0xec, + 0x01, 0x12, 0x22, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x03, 0x12, 0x04, 0xec, 0x01, + 0x25, 0x26, 0x0a, 0x79, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x08, 0x12, 0x04, 0xf0, 0x01, 0x02, 0x3a, + 0x1a, 0x6b, 0x20, 0x45, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, + 0x61, 0x6c, 0x6c, 0x20, 0x6e, 0x6f, 0x6e, 0x2d, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, + 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x2c, 0x20, 0x6e, 0x6f, 0x74, 0x20, + 0x63, 0x61, 0x70, 0x74, 0x75, 0x72, 0x65, 0x64, 0x20, 0x62, 0x79, 0x0a, 0x20, 0x76, 0x31, 0x2e, + 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, + 0x65, 0x6e, 0x74, 0x73, 0x2c, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, + 0x65, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x08, 0x06, 0x12, 0x04, 0xf0, 0x01, 0x02, 0x22, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x08, 0x02, 0x08, 0x01, 0x12, 0x04, 0xf0, 0x01, 0x23, 0x35, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x08, 0x03, 0x12, 0x04, 0xf0, 0x01, 0x38, 0x39, 0x0a, 0x2d, 0x0a, 0x04, 0x04, 0x08, + 0x02, 0x09, 0x12, 0x04, 0xf3, 0x01, 0x02, 0x2f, 0x1a, 0x1f, 0x20, 0x52, 0x75, 0x6e, 0x74, 0x69, + 0x6d, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x09, 0x06, 0x12, 0x04, 0xf3, 0x01, 0x02, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x09, + 0x01, 0x12, 0x04, 0xf3, 0x01, 0x19, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x09, 0x03, + 0x12, 0x04, 0xf3, 0x01, 0x2c, 0x2e, 0x0a, 0x23, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x0a, 0x12, 0x04, + 0xf6, 0x01, 0x02, 0x17, 0x1a, 0x15, 0x20, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x0a, 0x06, 0x12, 0x04, 0xf6, 0x01, 0x02, 0x09, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x0a, 0x01, 0x12, 0x04, 0xf6, 0x01, 0x0a, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x0a, 0x03, 0x12, 0x04, 0xf6, 0x01, 0x14, 0x16, 0x0a, 0xaf, 0x01, 0x0a, 0x04, 0x04, 0x08, 0x02, + 0x0b, 0x12, 0x04, 0xfa, 0x01, 0x02, 0x27, 0x1a, 0xa0, 0x01, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x6f, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x69, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x63, + 0x69, 0x70, 0x61, 0x6c, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x73, + 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x20, + 0x4f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x73, + 0x20, 0x6d, 0x61, 0x79, 0x0a, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x61, 0x63, 0x74, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x62, 0x79, 0x20, 0x75, + 0x70, 0x64, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x74, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x20, 0x6f, 0x72, 0x20, 0x73, 0x74, 0x6f, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x2f, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x74, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x0b, 0x06, 0x12, 0x04, 0xfa, 0x01, 0x02, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x0b, 0x01, 0x12, 0x04, 0xfa, 0x01, 0x1a, 0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x0b, + 0x03, 0x12, 0x04, 0xfa, 0x01, 0x24, 0x26, 0x0a, 0x22, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x0c, 0x12, + 0x04, 0xfd, 0x01, 0x02, 0x18, 0x1a, 0x14, 0x20, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x0c, 0x06, 0x12, 0x04, 0xfd, 0x01, 0x02, 0x0b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x0c, 0x01, 0x12, 0x04, 0xfd, 0x01, 0x0c, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x0c, 0x03, 0x12, 0x04, 0xfd, 0x01, 0x15, 0x17, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x0d, + 0x12, 0x04, 0xff, 0x01, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x0d, 0x04, 0x12, + 0x04, 0xff, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x0d, 0x06, 0x12, 0x04, + 0xff, 0x01, 0x0b, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x0d, 0x01, 0x12, 0x04, 0xff, + 0x01, 0x10, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x0d, 0x03, 0x12, 0x04, 0xff, 0x01, + 0x18, 0x1a, 0x0a, 0x32, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x0e, 0x12, 0x04, 0x82, 0x02, 0x02, 0x1e, + 0x1a, 0x24, 0x20, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x0e, 0x06, 0x12, + 0x04, 0x82, 0x02, 0x02, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x0e, 0x01, 0x12, 0x04, + 0x82, 0x02, 0x10, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x0e, 0x03, 0x12, 0x04, 0x82, + 0x02, 0x1b, 0x1d, 0x0a, 0x62, 0x0a, 0x02, 0x04, 0x09, 0x12, 0x06, 0x86, 0x02, 0x00, 0x90, 0x02, + 0x01, 0x1a, 0x54, 0x20, 0x52, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, + 0x20, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x78, 0x74, 0x65, + 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x28, 0x41, + 0x72, 0x69, 0x7a, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x6c, 0x69, 0x6e, + 0x6b, 0x2c, 0x20, 0x57, 0x26, 0x42, 0x20, 0x64, 0x61, 0x73, 0x68, 0x62, 0x6f, 0x61, 0x72, 0x64, + 0x2c, 0x20, 0x65, 0x74, 0x63, 0x29, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, 0x04, + 0x86, 0x02, 0x08, 0x0c, 0x0a, 0x57, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x00, 0x12, 0x04, 0x89, 0x02, + 0x02, 0x3c, 0x1a, 0x49, 0x20, 0x55, 0x52, 0x4c, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x61, + 0x6e, 0x20, 0x61, 0x62, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x65, 0x20, 0x6f, 0x72, 0x20, 0x72, 0x65, + 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x09, 0x02, 0x00, 0x05, 0x12, 0x04, 0x89, 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x04, 0x89, 0x02, 0x09, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x09, 0x02, 0x00, 0x03, 0x12, 0x04, 0x89, 0x02, 0x10, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x00, 0x08, 0x12, 0x04, 0x89, 0x02, 0x12, 0x3b, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x09, 0x02, + 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x04, 0x89, 0x02, 0x13, 0x3a, 0x0a, 0x3c, 0x0a, 0x04, + 0x04, 0x09, 0x02, 0x01, 0x12, 0x04, 0x8c, 0x02, 0x02, 0x13, 0x1a, 0x2e, 0x20, 0x48, 0x75, 0x6d, + 0x61, 0x6e, 0x20, 0x72, 0x65, 0x61, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, + 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x01, 0x05, 0x12, 0x04, 0x8c, 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, + 0x01, 0x01, 0x12, 0x04, 0x8c, 0x02, 0x09, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, + 0x03, 0x12, 0x04, 0x8c, 0x02, 0x11, 0x12, 0x0a, 0x43, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x02, 0x12, + 0x04, 0x8f, 0x02, 0x02, 0x17, 0x1a, 0x35, 0x20, 0x57, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x69, 0x73, 0x20, 0x61, 0x62, 0x73, 0x6f, + 0x6c, 0x75, 0x74, 0x65, 0x20, 0x28, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x29, 0x20, 0x6f, + 0x72, 0x20, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x09, 0x02, 0x02, 0x05, 0x12, 0x04, 0x8f, 0x02, 0x02, 0x06, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x09, 0x02, 0x02, 0x01, 0x12, 0x04, 0x8f, 0x02, 0x07, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x02, 0x03, 0x12, 0x04, 0x8f, 0x02, 0x15, 0x16, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0a, 0x12, + 0x06, 0x92, 0x02, 0x00, 0xa6, 0x02, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0a, 0x01, 0x12, 0x04, + 0x92, 0x02, 0x08, 0x0d, 0x0a, 0x5d, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x00, 0x12, 0x04, 0x94, 0x02, + 0x02, 0x3c, 0x1a, 0x4f, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x75, + 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, + 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, + 0x70, 0x70, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x05, 0x12, 0x04, 0x94, 0x02, + 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x04, 0x94, 0x02, 0x09, + 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, 0x04, 0x94, 0x02, 0x10, 0x11, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x08, 0x12, 0x04, 0x94, 0x02, 0x12, 0x3b, 0x0a, + 0x11, 0x0a, 0x09, 0x04, 0x0a, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x04, 0x94, 0x02, + 0x13, 0x3a, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x0a, 0x08, 0x00, 0x12, 0x06, 0x96, 0x02, 0x02, 0xa5, + 0x02, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x08, 0x00, 0x01, 0x12, 0x04, 0x96, 0x02, 0x08, + 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x08, 0x00, 0x02, 0x12, 0x04, 0x97, 0x02, 0x04, 0x30, + 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x0a, 0x08, 0x00, 0x02, 0x87, 0x09, 0x01, 0x12, 0x04, 0x97, 0x02, + 0x04, 0x30, 0x0a, 0x41, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x01, 0x12, 0x04, 0x9a, 0x02, 0x04, 0x46, + 0x1a, 0x33, 0x20, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x69, + 0x73, 0x20, 0x61, 0x20, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, + 0x6e, 0x70, 0x75, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x05, 0x12, 0x04, + 0x9a, 0x02, 0x04, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x01, 0x12, 0x04, 0x9a, + 0x02, 0x0b, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x03, 0x12, 0x04, 0x9a, 0x02, + 0x1a, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x08, 0x12, 0x04, 0x9a, 0x02, 0x1c, + 0x45, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x0a, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x04, + 0x9a, 0x02, 0x1d, 0x44, 0x0a, 0xbd, 0x01, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x02, 0x12, 0x04, 0x9e, + 0x02, 0x04, 0x34, 0x1a, 0xae, 0x01, 0x20, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, + 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, + 0x64, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x74, + 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x61, 0x74, 0x20, 0x72, 0x75, 0x6e, + 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x61, 0x72, 0x74, 0x69, 0x66, + 0x61, 0x63, 0x74, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x70, 0x69, 0x6e, 0x6e, + 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x06, 0x12, 0x04, 0x9e, + 0x02, 0x04, 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x01, 0x12, 0x04, 0x9e, 0x02, + 0x21, 0x2f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x03, 0x12, 0x04, 0x9e, 0x02, 0x32, + 0x33, 0x0a, 0x70, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x03, 0x12, 0x04, 0xa1, 0x02, 0x04, 0x2e, 0x1a, + 0x62, 0x20, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x64, 0x20, 0x69, 0x73, 0x20, + 0x61, 0x6e, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x6f, 0x66, + 0x20, 0x61, 0x6e, 0x20, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x61, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x61, 0x74, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, + 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, 0x06, 0x12, 0x04, 0xa1, 0x02, + 0x04, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x04, 0xa1, 0x02, 0x1e, + 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, 0x03, 0x12, 0x04, 0xa1, 0x02, 0x2c, 0x2d, + 0x0a, 0x1e, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x04, 0x12, 0x04, 0xa4, 0x02, 0x04, 0x1a, 0x1a, 0x10, + 0x20, 0x49, 0x44, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x04, 0xa4, 0x02, 0x04, 0x0e, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0xa4, 0x02, 0x0f, 0x15, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0xa4, 0x02, 0x18, 0x19, 0x0a, 0x0c, 0x0a, + 0x02, 0x04, 0x0b, 0x12, 0x06, 0xa8, 0x02, 0x00, 0xad, 0x02, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, + 0x0b, 0x01, 0x12, 0x04, 0xa8, 0x02, 0x08, 0x1a, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x00, + 0x12, 0x04, 0xa9, 0x02, 0x02, 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x04, 0x12, + 0x04, 0xa9, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x06, 0x12, 0x04, + 0xa9, 0x02, 0x0b, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x01, 0x12, 0x04, 0xa9, + 0x02, 0x1d, 0x22, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x03, 0x12, 0x04, 0xa9, 0x02, + 0x25, 0x26, 0x0a, 0x4e, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x01, 0x12, 0x04, 0xac, 0x02, 0x02, 0x3c, + 0x1a, 0x40, 0x20, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x77, 0x65, 0x20, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, + 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x66, 0x6f, 0x72, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x05, 0x12, 0x04, 0xac, 0x02, 0x02, + 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x01, 0x12, 0x04, 0xac, 0x02, 0x09, 0x11, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x03, 0x12, 0x04, 0xac, 0x02, 0x14, 0x15, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x08, 0x12, 0x04, 0xac, 0x02, 0x16, 0x3b, 0x0a, 0x11, + 0x0a, 0x09, 0x04, 0x0b, 0x02, 0x01, 0x08, 0x87, 0x09, 0x06, 0x05, 0x12, 0x04, 0xac, 0x02, 0x17, + 0x3a, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0c, 0x12, 0x06, 0xaf, 0x02, 0x00, 0xb9, 0x02, 0x01, 0x0a, + 0x0b, 0x0a, 0x03, 0x04, 0x0c, 0x01, 0x12, 0x04, 0xaf, 0x02, 0x08, 0x19, 0x0a, 0x5d, 0x0a, 0x04, + 0x04, 0x0c, 0x02, 0x00, 0x12, 0x04, 0xb1, 0x02, 0x02, 0x3c, 0x1a, 0x4f, 0x20, 0x4e, 0x61, 0x6d, + 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x69, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0c, 0x02, 0x00, 0x05, 0x12, 0x04, 0xb1, 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, + 0x02, 0x00, 0x01, 0x12, 0x04, 0xb1, 0x02, 0x09, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, + 0x00, 0x03, 0x12, 0x04, 0xb1, 0x02, 0x10, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, + 0x08, 0x12, 0x04, 0xb1, 0x02, 0x12, 0x3b, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x0c, 0x02, 0x00, 0x08, + 0x87, 0x09, 0x0e, 0x02, 0x12, 0x04, 0xb1, 0x02, 0x13, 0x3a, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x0c, + 0x08, 0x00, 0x12, 0x06, 0xb3, 0x02, 0x02, 0xb8, 0x02, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, + 0x08, 0x00, 0x01, 0x12, 0x04, 0xb3, 0x02, 0x08, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x08, + 0x00, 0x02, 0x12, 0x04, 0xb4, 0x02, 0x04, 0x30, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x0c, 0x08, 0x00, + 0x02, 0x87, 0x09, 0x01, 0x12, 0x04, 0xb4, 0x02, 0x04, 0x30, 0x0a, 0x70, 0x0a, 0x04, 0x04, 0x0c, + 0x02, 0x01, 0x12, 0x04, 0xb7, 0x02, 0x04, 0x2e, 0x1a, 0x62, 0x20, 0x41, 0x72, 0x74, 0x69, 0x66, + 0x61, 0x63, 0x74, 0x49, 0x64, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x72, 0x74, + 0x69, 0x66, 0x61, 0x63, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, + 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, + 0x6e, 0x70, 0x75, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, + 0x61, 0x74, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0c, 0x02, 0x01, 0x06, 0x12, 0x04, 0xb7, 0x02, 0x04, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0c, 0x02, 0x01, 0x01, 0x12, 0x04, 0xb7, 0x02, 0x1e, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, + 0x02, 0x01, 0x03, 0x12, 0x04, 0xb7, 0x02, 0x2c, 0x2d, 0x0a, 0x40, 0x0a, 0x02, 0x04, 0x0d, 0x12, + 0x06, 0xbc, 0x02, 0x00, 0xbf, 0x02, 0x01, 0x1a, 0x32, 0x20, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x4c, + 0x69, 0x73, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, + 0x20, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x69, 0x65, 0x73, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, + 0x0d, 0x01, 0x12, 0x04, 0xbc, 0x02, 0x08, 0x11, 0x0a, 0x42, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x00, + 0x12, 0x04, 0xbe, 0x02, 0x02, 0x1b, 0x1a, 0x34, 0x20, 0x49, 0x74, 0x65, 0x6d, 0x73, 0x20, 0x69, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x6e, + 0x70, 0x75, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x75, 0x6c, 0x66, 0x69, 0x6c, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0d, 0x02, 0x00, 0x04, 0x12, 0x04, 0xbe, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0d, 0x02, 0x00, 0x06, 0x12, 0x04, 0xbe, 0x02, 0x0b, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, + 0x02, 0x00, 0x01, 0x12, 0x04, 0xbe, 0x02, 0x11, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, + 0x00, 0x03, 0x12, 0x04, 0xbe, 0x02, 0x19, 0x1a, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0e, 0x12, 0x06, + 0xc1, 0x02, 0x00, 0xcd, 0x02, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0e, 0x01, 0x12, 0x04, 0xc1, + 0x02, 0x08, 0x0f, 0x0a, 0x3e, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x00, 0x12, 0x04, 0xc3, 0x02, 0x02, + 0x12, 0x1a, 0x30, 0x20, 0x41, 0x70, 0x70, 0x20, 0x54, 0x79, 0x70, 0x65, 0x20, 0x28, 0x65, 0x2e, + 0x67, 0x2e, 0x20, 0x46, 0x61, 0x73, 0x74, 0x41, 0x50, 0x49, 0x2c, 0x20, 0x46, 0x6c, 0x61, 0x73, + 0x6b, 0x2c, 0x20, 0x56, 0x4c, 0x4c, 0x4d, 0x2c, 0x20, 0x4e, 0x49, 0x4d, 0x20, 0x65, 0x74, 0x63, + 0x2e, 0x29, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x05, 0x12, 0x04, 0xc3, 0x02, + 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x01, 0x12, 0x04, 0xc3, 0x02, 0x09, + 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x03, 0x12, 0x04, 0xc3, 0x02, 0x10, 0x11, + 0x0a, 0x29, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x01, 0x12, 0x04, 0xc6, 0x02, 0x02, 0x12, 0x1a, 0x1b, + 0x20, 0x46, 0x72, 0x69, 0x65, 0x6e, 0x64, 0x6c, 0x79, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x01, 0x05, 0x12, 0x04, 0xc6, 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x01, 0x01, 0x12, 0x04, 0xc6, 0x02, 0x09, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x01, 0x03, 0x12, 0x04, 0xc6, 0x02, 0x10, 0x11, 0x0a, 0x2d, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x02, + 0x12, 0x04, 0xc9, 0x02, 0x02, 0x4b, 0x1a, 0x1f, 0x20, 0x53, 0x68, 0x6f, 0x72, 0x74, 0x20, 0x64, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x02, 0x05, + 0x12, 0x04, 0xc9, 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x02, 0x01, 0x12, + 0x04, 0xc9, 0x02, 0x09, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x02, 0x03, 0x12, 0x04, + 0xc9, 0x02, 0x1d, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x02, 0x08, 0x12, 0x04, 0xc9, + 0x02, 0x1f, 0x4a, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x0e, 0x02, 0x02, 0x08, 0x87, 0x09, 0x0e, 0x03, + 0x12, 0x04, 0xc9, 0x02, 0x20, 0x49, 0x0a, 0x24, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x03, 0x12, 0x04, + 0xcc, 0x02, 0x02, 0x16, 0x1a, 0x16, 0x20, 0x49, 0x63, 0x6f, 0x6e, 0x20, 0x55, 0x52, 0x4c, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x03, 0x05, 0x12, 0x04, 0xcc, 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x03, 0x01, 0x12, 0x04, 0xcc, 0x02, 0x09, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x03, 0x03, 0x12, 0x04, 0xcc, 0x02, 0x14, 0x15, 0x0a, 0x4e, 0x0a, 0x02, 0x04, 0x0f, 0x12, + 0x06, 0xd0, 0x02, 0x00, 0xe1, 0x02, 0x01, 0x1a, 0x40, 0x20, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, + 0x74, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x20, 0x68, 0x6f, 0x6c, 0x64, 0x73, 0x20, + 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, + 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x20, 0x74, + 0x6f, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0f, 0x01, + 0x12, 0x04, 0xd0, 0x02, 0x08, 0x17, 0x0a, 0xe6, 0x01, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x00, 0x12, + 0x04, 0xd3, 0x02, 0x02, 0x25, 0x1a, 0xd7, 0x01, 0x20, 0x72, 0x75, 0x6e, 0x5f, 0x61, 0x73, 0x20, + 0x65, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x61, 0x20, 0x70, 0x6f, 0x64, 0x20, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x61, 0x73, 0x2e, 0x20, 0x49, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x66, 0x69, 0x6c, 0x6c, 0x73, + 0x20, 0x69, 0x6e, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x73, 0x20, 0x68, 0x65, 0x72, 0x65, 0x2c, 0x20, 0x69, 0x74, 0x27, 0x6c, 0x6c, 0x20, + 0x62, 0x65, 0x20, 0x75, 0x70, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x62, 0x61, + 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x20, 0x74, 0x6f, 0x20, + 0x63, 0x68, 0x6f, 0x6f, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x72, 0x6f, + 0x70, 0x72, 0x69, 0x61, 0x74, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, + 0x6b, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x06, 0x12, 0x04, 0xd3, 0x02, 0x02, 0x19, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x01, 0x12, 0x04, 0xd3, 0x02, 0x1a, 0x20, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0f, 0x02, 0x00, 0x03, 0x12, 0x04, 0xd3, 0x02, 0x23, 0x24, 0x0a, 0xa4, 0x03, 0x0a, + 0x04, 0x04, 0x0f, 0x02, 0x01, 0x12, 0x04, 0xd9, 0x02, 0x02, 0x2d, 0x1a, 0x95, 0x03, 0x20, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x6e, 0x65, 0x65, + 0x64, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x70, + 0x72, 0x6f, 0x63, 0x65, 0x65, 0x64, 0x2e, 0x20, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x20, + 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x64, 0x2f, + 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x70, + 0x6f, 0x64, 0x20, 0x61, 0x73, 0x20, 0x69, 0x74, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x73, 0x2e, + 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x20, 0x72, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6b, + 0x69, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, + 0x73, 0x6b, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x72, 0x75, 0x6e, 0x20, + 0x69, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x61, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x20, 0x63, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x41, 0x57, 0x53, 0x0a, + 0x20, 0x42, 0x61, 0x74, 0x63, 0x68, 0x29, 0x2c, 0x20, 0x69, 0x74, 0x27, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x20, 0x74, + 0x6f, 0x20, 0x66, 0x65, 0x74, 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x20, 0x28, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x6d, 0x65, 0x61, 0x6e, 0x73, 0x20, + 0x70, 0x72, 0x6f, 0x70, 0x65, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x74, 0x79, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x20, 0x61, 0x63, 0x63, + 0x65, 0x73, 0x73, 0x0a, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x29, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x73, 0x73, 0x20, + 0x69, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, + 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x6e, 0x67, 0x69, 0x6e, + 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x04, 0x12, 0x04, 0xd9, 0x02, + 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x06, 0x12, 0x04, 0xd9, 0x02, 0x0b, + 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x01, 0x12, 0x04, 0xd9, 0x02, 0x21, 0x28, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x03, 0x12, 0x04, 0xd9, 0x02, 0x2b, 0x2c, 0x0a, + 0x0b, 0x0a, 0x03, 0x04, 0x0f, 0x09, 0x12, 0x04, 0xdb, 0x02, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x04, + 0x04, 0x0f, 0x09, 0x00, 0x12, 0x04, 0xdb, 0x02, 0x0b, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, + 0x09, 0x00, 0x01, 0x12, 0x04, 0xdb, 0x02, 0x0b, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x09, + 0x00, 0x02, 0x12, 0x04, 0xdb, 0x02, 0x0b, 0x0c, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0f, 0x09, 0x12, + 0x04, 0xdc, 0x02, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0f, 0x09, 0x01, 0x12, 0x04, 0xdc, + 0x02, 0x0b, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x09, 0x01, 0x01, 0x12, 0x04, 0xdc, 0x02, + 0x0b, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x09, 0x01, 0x02, 0x12, 0x04, 0xdc, 0x02, 0x0b, + 0x0c, 0x0a, 0xb5, 0x01, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x02, 0x12, 0x04, 0xe0, 0x02, 0x02, 0x1b, + 0x1a, 0xa6, 0x01, 0x20, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x41, 0x6e, 0x6f, 0x6e, 0x79, 0x6d, 0x6f, + 0x75, 0x73, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x69, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, + 0x65, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x68, + 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x0a, 0x20, 0x69, 0x74, 0x73, 0x20, 0x6f, 0x77, 0x6e, 0x20, 0x61, + 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x72, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x74, 0x27, 0x73, 0x20, 0x61, 0x20, 0x70, 0x75, 0x62, + 0x6c, 0x69, 0x63, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, + 0x02, 0x05, 0x12, 0x04, 0xe0, 0x02, 0x02, 0x06, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x02, + 0x01, 0x12, 0x04, 0xe0, 0x02, 0x07, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x02, 0x03, + 0x12, 0x04, 0xe0, 0x02, 0x19, 0x1a, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x10, 0x12, 0x06, 0xe3, 0x02, + 0x00, 0xe8, 0x02, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x10, 0x01, 0x12, 0x04, 0xe3, 0x02, 0x08, + 0x11, 0x0a, 0x21, 0x0a, 0x04, 0x04, 0x10, 0x02, 0x00, 0x12, 0x04, 0xe5, 0x02, 0x02, 0x11, 0x1a, + 0x13, 0x20, 0x54, 0x61, 0x67, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6d, 0x61, + 0x67, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, 0x05, 0x12, 0x04, 0xe5, + 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, 0x01, 0x12, 0x04, 0xe5, 0x02, + 0x09, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, 0x03, 0x12, 0x04, 0xe5, 0x02, 0x0f, + 0x10, 0x0a, 0x33, 0x0a, 0x04, 0x04, 0x10, 0x02, 0x01, 0x12, 0x04, 0xe7, 0x02, 0x02, 0x1b, 0x1a, + 0x25, 0x20, 0x55, 0x52, 0x4c, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x69, + 0x6c, 0x64, 0x20, 0x6a, 0x6f, 0x62, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, + 0x6d, 0x61, 0x67, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x01, 0x05, 0x12, + 0x04, 0xe7, 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x01, 0x01, 0x12, 0x04, + 0xe7, 0x02, 0x09, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x01, 0x03, 0x12, 0x04, 0xe7, + 0x02, 0x19, 0x1a, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x11, 0x12, 0x06, 0xea, 0x02, 0x00, 0xed, 0x02, + 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x11, 0x01, 0x12, 0x04, 0xea, 0x02, 0x08, 0x14, 0x0a, 0x2d, + 0x0a, 0x04, 0x04, 0x11, 0x02, 0x00, 0x12, 0x04, 0xec, 0x02, 0x02, 0x20, 0x1a, 0x1f, 0x20, 0x4c, + 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x11, 0x02, 0x00, 0x04, 0x12, 0x04, 0xec, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x11, 0x02, 0x00, 0x06, 0x12, 0x04, 0xec, 0x02, 0x0b, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x11, 0x02, 0x00, 0x01, 0x12, 0x04, 0xec, 0x02, 0x15, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, + 0x02, 0x00, 0x03, 0x12, 0x04, 0xec, 0x02, 0x1e, 0x1f, 0x0a, 0x3f, 0x0a, 0x02, 0x04, 0x12, 0x12, + 0x06, 0xf0, 0x02, 0x00, 0xf9, 0x02, 0x01, 0x1a, 0x31, 0x20, 0x52, 0x65, 0x70, 0x72, 0x65, 0x73, + 0x65, 0x6e, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, + 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, + 0x66, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x12, + 0x01, 0x12, 0x04, 0xf0, 0x02, 0x08, 0x15, 0x0a, 0x37, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x00, 0x12, + 0x04, 0xf2, 0x02, 0x02, 0x13, 0x1a, 0x29, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, + 0x73, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x00, 0x05, 0x12, 0x04, 0xf2, 0x02, 0x02, 0x06, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x00, 0x01, 0x12, 0x04, 0xf2, 0x02, 0x07, 0x0e, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x12, 0x02, 0x00, 0x03, 0x12, 0x04, 0xf2, 0x02, 0x11, 0x12, 0x0a, 0x5e, 0x0a, + 0x04, 0x04, 0x12, 0x02, 0x01, 0x12, 0x04, 0xf5, 0x02, 0x02, 0x17, 0x1a, 0x50, 0x20, 0x53, 0x75, + 0x62, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x61, 0x70, 0x70, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x20, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x20, + 0x73, 0x75, 0x62, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, + 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x12, 0x02, 0x01, 0x05, 0x12, 0x04, 0xf5, 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x12, 0x02, 0x01, 0x01, 0x12, 0x04, 0xf5, 0x02, 0x09, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x12, 0x02, 0x01, 0x03, 0x12, 0x04, 0xf5, 0x02, 0x15, 0x16, 0x0a, 0x33, 0x0a, 0x04, 0x04, 0x12, + 0x02, 0x02, 0x12, 0x04, 0xf8, 0x02, 0x02, 0x13, 0x1a, 0x25, 0x20, 0x43, 0x61, 0x6e, 0x6f, 0x6e, + 0x69, 0x63, 0x61, 0x6c, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x28, 0x43, 0x4e, 0x41, 0x4d, 0x45, + 0x29, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x02, 0x05, 0x12, 0x04, 0xf8, 0x02, 0x02, 0x08, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x12, 0x02, 0x02, 0x01, 0x12, 0x04, 0xf8, 0x02, 0x09, 0x0e, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x12, 0x02, 0x02, 0x03, 0x12, 0x04, 0xf8, 0x02, 0x11, 0x12, 0x0a, 0x43, 0x0a, 0x02, + 0x04, 0x13, 0x12, 0x06, 0xfc, 0x02, 0x00, 0x83, 0x03, 0x01, 0x1a, 0x35, 0x20, 0x52, 0x65, 0x70, + 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x75, 0x74, 0x6f, + 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x70, 0x70, 0x2e, + 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x13, 0x01, 0x12, 0x04, 0xfc, 0x02, 0x08, 0x19, 0x0a, 0x39, + 0x0a, 0x04, 0x04, 0x13, 0x02, 0x00, 0x12, 0x04, 0xfe, 0x02, 0x02, 0x18, 0x1a, 0x2b, 0x20, 0x43, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x72, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, + 0x00, 0x06, 0x12, 0x04, 0xfe, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x00, + 0x01, 0x12, 0x04, 0xfe, 0x02, 0x0b, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x00, 0x03, + 0x12, 0x04, 0xfe, 0x02, 0x16, 0x17, 0x0a, 0x37, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x01, 0x12, 0x04, + 0x80, 0x03, 0x02, 0x30, 0x1a, 0x29, 0x20, 0x54, 0x68, 0x65, 0x20, 0x70, 0x65, 0x72, 0x69, 0x6f, + 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x6f, + 0x77, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x01, 0x06, 0x12, 0x04, 0x80, 0x03, 0x02, 0x1a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x13, 0x02, 0x01, 0x01, 0x12, 0x04, 0x80, 0x03, 0x1b, 0x2b, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x13, 0x02, 0x01, 0x03, 0x12, 0x04, 0x80, 0x03, 0x2e, 0x2f, 0x0a, 0x2b, 0x0a, 0x04, + 0x04, 0x13, 0x02, 0x02, 0x12, 0x04, 0x82, 0x03, 0x02, 0x23, 0x1a, 0x1d, 0x20, 0x4d, 0x65, 0x74, + 0x72, 0x69, 0x63, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, + 0x02, 0x06, 0x12, 0x04, 0x82, 0x03, 0x02, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x02, + 0x01, 0x12, 0x04, 0x82, 0x03, 0x10, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x02, 0x03, + 0x12, 0x04, 0x82, 0x03, 0x21, 0x22, 0x0a, 0x97, 0x01, 0x0a, 0x02, 0x04, 0x14, 0x12, 0x06, 0x87, + 0x03, 0x00, 0x90, 0x03, 0x01, 0x1a, 0x88, 0x01, 0x20, 0x53, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, + 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x20, 0x64, 0x69, + 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x20, + 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x65, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x20, 0x53, 0x65, 0x65, 0x3a, 0x20, 0x68, 0x74, + 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x6b, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x2e, 0x64, 0x65, + 0x76, 0x2f, 0x64, 0x6f, 0x63, 0x73, 0x2f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67, 0x2f, 0x61, + 0x75, 0x74, 0x6f, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x2f, 0x61, 0x75, 0x74, 0x6f, 0x73, + 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x2d, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x2f, 0x0a, + 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x14, 0x01, 0x12, 0x04, 0x87, 0x03, 0x08, 0x15, 0x0a, 0x0e, 0x0a, + 0x04, 0x04, 0x14, 0x08, 0x00, 0x12, 0x06, 0x88, 0x03, 0x02, 0x8f, 0x03, 0x03, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x14, 0x08, 0x00, 0x01, 0x12, 0x04, 0x88, 0x03, 0x08, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x14, 0x08, 0x00, 0x02, 0x12, 0x04, 0x89, 0x03, 0x04, 0x30, 0x0a, 0x10, 0x0a, 0x08, 0x04, + 0x14, 0x08, 0x00, 0x02, 0x87, 0x09, 0x01, 0x12, 0x04, 0x89, 0x03, 0x04, 0x30, 0x0a, 0x40, 0x0a, + 0x04, 0x04, 0x14, 0x02, 0x00, 0x12, 0x04, 0x8c, 0x03, 0x04, 0x21, 0x1a, 0x32, 0x20, 0x43, 0x6f, + 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x62, 0x61, 0x73, 0x65, 0x64, 0x20, 0x6f, 0x6e, + 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x72, 0x61, 0x74, 0x65, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x00, 0x06, 0x12, 0x04, 0x8c, 0x03, 0x04, 0x0f, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x14, 0x02, 0x00, 0x01, 0x12, 0x04, 0x8c, 0x03, 0x10, 0x1c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x14, 0x02, 0x00, 0x03, 0x12, 0x04, 0x8c, 0x03, 0x1f, 0x20, 0x0a, 0x3f, 0x0a, 0x04, + 0x04, 0x14, 0x02, 0x01, 0x12, 0x04, 0x8e, 0x03, 0x04, 0x20, 0x1a, 0x31, 0x20, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, + 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x62, 0x61, 0x73, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x20, + 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x14, 0x02, 0x01, 0x06, 0x12, 0x04, 0x8e, 0x03, 0x04, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x14, 0x02, 0x01, 0x01, 0x12, 0x04, 0x8e, 0x03, 0x10, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x14, 0x02, 0x01, 0x03, 0x12, 0x04, 0x8e, 0x03, 0x1e, 0x1f, 0x0a, 0x8e, 0x04, 0x0a, 0x02, 0x04, + 0x15, 0x12, 0x06, 0x98, 0x03, 0x00, 0x9c, 0x03, 0x01, 0x1a, 0xff, 0x03, 0x20, 0x54, 0x68, 0x69, + 0x73, 0x20, 0x73, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, + 0x73, 0x20, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x62, 0x61, 0x73, 0x65, 0x64, 0x20, + 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x63, + 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x2e, 0x20, 0x43, 0x6f, 0x6e, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, + 0x65, 0x73, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x6d, 0x61, 0x6e, 0x79, 0x0a, 0x20, 0x72, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x62, 0x65, 0x69, 0x6e, 0x67, 0x20, + 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x61, 0x6d, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x66, 0x75, 0x6c, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, + 0x70, 0x70, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x20, 0x6c, 0x6f, + 0x6e, 0x67, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x0a, + 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20, + 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x29, 0x0a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x61, 0x75, + 0x74, 0x6f, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x72, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x20, 0x64, + 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x20, 0x6f, 0x66, + 0x20, 0x36, 0x30, 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x63, + 0x61, 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2e, 0x20, + 0x48, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x68, 0x61, 0x73, 0x0a, + 0x20, 0x70, 0x61, 0x6e, 0x69, 0x63, 0x20, 0x6d, 0x6f, 0x64, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x6b, 0x69, 0x63, 0x6b, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x72, 0x61, 0x74, 0x65, 0x20, 0x6a, 0x75, + 0x6d, 0x70, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x32, 0x78, 0x20, 0x69, 0x74, 0x73, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x36, 0x20, 0x73, 0x65, 0x63, + 0x6f, 0x6e, 0x64, 0x73, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x61, 0x74, 0x27, 0x73, 0x0a, + 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x65, 0x64, 0x2c, 0x20, 0x69, 0x74, 0x27, 0x6c, + 0x6c, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x20, + 0x75, 0x70, 0x20, 0x69, 0x6d, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x20, 0x69, + 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6f, 0x66, 0x20, 0x77, 0x61, 0x69, 0x74, 0x69, 0x6e, + 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x6c, 0x6c, 0x20, 0x36, + 0x30, 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, + 0x15, 0x01, 0x12, 0x04, 0x98, 0x03, 0x08, 0x13, 0x0a, 0x54, 0x0a, 0x04, 0x04, 0x15, 0x02, 0x00, + 0x12, 0x04, 0x9b, 0x03, 0x02, 0x3f, 0x1a, 0x46, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, + 0x67, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, + 0x0a, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x3d, 0x31, 0x30, 0x30, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x15, 0x02, 0x00, 0x05, 0x12, 0x04, 0x9b, 0x03, 0x02, 0x08, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x15, 0x02, 0x00, 0x01, 0x12, 0x04, 0x9b, 0x03, 0x09, 0x15, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x15, 0x02, 0x00, 0x03, 0x12, 0x04, 0x9b, 0x03, 0x18, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x15, 0x02, 0x00, 0x08, 0x12, 0x04, 0x9b, 0x03, 0x1a, 0x3e, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x15, + 0x02, 0x00, 0x08, 0x87, 0x09, 0x05, 0x04, 0x12, 0x04, 0x9b, 0x03, 0x1b, 0x3d, 0x0a, 0xb0, 0x03, + 0x0a, 0x02, 0x04, 0x16, 0x12, 0x06, 0xa3, 0x03, 0x00, 0xa7, 0x03, 0x01, 0x1a, 0xa1, 0x03, 0x20, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x61, 0x74, 0x65, 0x20, 0x65, 0x6e, 0x61, 0x62, + 0x6c, 0x65, 0x73, 0x20, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x62, 0x61, 0x73, 0x65, + 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x20, 0x72, 0x61, 0x74, 0x65, 0x2e, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x72, + 0x61, 0x74, 0x65, 0x20, 0x63, 0x61, 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x68, + 0x6f, 0x77, 0x20, 0x6d, 0x61, 0x6e, 0x79, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, + 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x63, + 0x65, 0x69, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x70, 0x65, 0x72, 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, + 0x64, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x61, 0x75, 0x74, 0x6f, 0x73, 0x63, 0x61, 0x6c, + 0x65, 0x72, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, + 0x20, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x20, 0x6f, 0x66, 0x20, 0x36, 0x30, 0x20, 0x73, 0x65, + 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x61, 0x6c, 0x63, 0x75, 0x6c, 0x61, + 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x72, + 0x61, 0x74, 0x65, 0x2e, 0x20, 0x48, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x2c, 0x20, 0x69, 0x74, + 0x20, 0x68, 0x61, 0x73, 0x0a, 0x20, 0x70, 0x61, 0x6e, 0x69, 0x63, 0x20, 0x6d, 0x6f, 0x64, 0x65, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x6b, 0x69, 0x63, 0x6b, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x69, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x72, 0x61, + 0x74, 0x65, 0x20, 0x6a, 0x75, 0x6d, 0x70, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x32, 0x78, 0x20, 0x69, + 0x74, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, + 0x36, 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x27, 0x73, 0x0a, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x65, 0x64, 0x2c, + 0x20, 0x69, 0x74, 0x27, 0x6c, 0x6c, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x73, 0x63, 0x61, + 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x75, 0x70, 0x20, 0x69, 0x6d, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, + 0x65, 0x6c, 0x79, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6f, 0x66, 0x20, 0x77, + 0x61, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x75, 0x6c, 0x6c, 0x20, 0x36, 0x30, 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x2e, 0x0a, + 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x16, 0x01, 0x12, 0x04, 0xa3, 0x03, 0x08, 0x13, 0x0a, 0x54, 0x0a, + 0x04, 0x04, 0x16, 0x02, 0x00, 0x12, 0x04, 0xa6, 0x03, 0x02, 0x40, 0x1a, 0x46, 0x20, 0x54, 0x68, + 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x3d, 0x31, + 0x30, 0x30, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x00, 0x05, 0x12, 0x04, 0xa6, 0x03, + 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x00, 0x01, 0x12, 0x04, 0xa6, 0x03, 0x09, + 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x00, 0x03, 0x12, 0x04, 0xa6, 0x03, 0x18, 0x19, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x00, 0x08, 0x12, 0x04, 0xa6, 0x03, 0x1a, 0x3f, 0x0a, + 0x11, 0x0a, 0x09, 0x04, 0x16, 0x02, 0x00, 0x08, 0x87, 0x09, 0x05, 0x05, 0x12, 0x04, 0xa6, 0x03, + 0x1b, 0x3e, 0x0a, 0x48, 0x0a, 0x02, 0x04, 0x17, 0x12, 0x06, 0xaa, 0x03, 0x00, 0xb0, 0x03, 0x01, + 0x1a, 0x3a, 0x20, 0x52, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, + 0x66, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, + 0x04, 0x17, 0x01, 0x12, 0x04, 0xaa, 0x03, 0x08, 0x10, 0x0a, 0x2b, 0x0a, 0x04, 0x04, 0x17, 0x02, + 0x00, 0x12, 0x04, 0xac, 0x03, 0x02, 0x37, 0x1a, 0x1d, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x6d, 0x75, + 0x6d, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x17, 0x02, 0x00, 0x05, 0x12, + 0x04, 0xac, 0x03, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x17, 0x02, 0x00, 0x01, 0x12, 0x04, + 0xac, 0x03, 0x09, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x17, 0x02, 0x00, 0x03, 0x12, 0x04, 0xac, + 0x03, 0x0f, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x17, 0x02, 0x00, 0x08, 0x12, 0x04, 0xac, 0x03, + 0x11, 0x36, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x17, 0x02, 0x00, 0x08, 0x87, 0x09, 0x05, 0x05, 0x12, + 0x04, 0xac, 0x03, 0x12, 0x35, 0x0a, 0x2b, 0x0a, 0x04, 0x04, 0x17, 0x02, 0x01, 0x12, 0x04, 0xaf, + 0x03, 0x02, 0x37, 0x1a, 0x1d, 0x20, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x6e, 0x75, + 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x17, 0x02, 0x01, 0x05, 0x12, 0x04, 0xaf, 0x03, 0x02, + 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x17, 0x02, 0x01, 0x01, 0x12, 0x04, 0xaf, 0x03, 0x09, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x17, 0x02, 0x01, 0x03, 0x12, 0x04, 0xaf, 0x03, 0x0f, 0x10, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x17, 0x02, 0x01, 0x08, 0x12, 0x04, 0xaf, 0x03, 0x11, 0x36, 0x0a, 0x11, + 0x0a, 0x09, 0x04, 0x17, 0x02, 0x01, 0x08, 0x87, 0x09, 0x05, 0x05, 0x12, 0x04, 0xaf, 0x03, 0x12, + 0x35, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x18, 0x12, 0x06, 0xb2, 0x03, 0x00, 0xbb, 0x03, 0x01, 0x0a, + 0x0b, 0x0a, 0x03, 0x04, 0x18, 0x01, 0x12, 0x04, 0xb2, 0x03, 0x08, 0x15, 0x0a, 0xb0, 0x01, 0x0a, + 0x04, 0x04, 0x18, 0x02, 0x00, 0x12, 0x06, 0xb7, 0x03, 0x02, 0xba, 0x03, 0x05, 0x1a, 0x9f, 0x01, + 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, + 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x69, + 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x0a, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x6f, + 0x77, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x20, 0x74, + 0x6f, 0x20, 0x61, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x20, 0x49, 0x66, 0x20, + 0x75, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x20, 0x73, + 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x77, 0x69, + 0x6c, 0x6c, 0x0a, 0x20, 0x62, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2e, + 0x0a, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x3d, 0x33, 0x30, 0x30, 0x73, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x18, 0x02, 0x00, 0x06, 0x12, 0x04, 0xb7, 0x03, 0x02, 0x1a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x18, 0x02, 0x00, 0x01, 0x12, 0x04, 0xb7, 0x03, 0x1b, 0x2a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x18, 0x02, 0x00, 0x03, 0x12, 0x04, 0xb7, 0x03, 0x2d, 0x2e, 0x0a, 0x0f, 0x0a, 0x05, + 0x04, 0x18, 0x02, 0x00, 0x08, 0x12, 0x06, 0xb7, 0x03, 0x2f, 0xba, 0x03, 0x04, 0x0a, 0x12, 0x0a, + 0x08, 0x04, 0x18, 0x02, 0x00, 0x08, 0x87, 0x09, 0x15, 0x12, 0x06, 0xb7, 0x03, 0x30, 0xba, 0x03, + 0x03, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x18, 0x02, 0x00, 0x08, 0x87, 0x09, 0x15, 0x06, 0x12, 0x04, + 0xb8, 0x03, 0x04, 0x15, 0x0a, 0x12, 0x0a, 0x0a, 0x04, 0x18, 0x02, 0x00, 0x08, 0x87, 0x09, 0x15, + 0x06, 0x01, 0x12, 0x04, 0xb8, 0x03, 0x0a, 0x14, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x18, 0x02, 0x00, + 0x08, 0x87, 0x09, 0x15, 0x04, 0x12, 0x04, 0xb9, 0x03, 0x04, 0x18, 0x0a, 0x12, 0x0a, 0x0a, 0x04, + 0x18, 0x02, 0x00, 0x08, 0x87, 0x09, 0x15, 0x04, 0x01, 0x12, 0x04, 0xb9, 0x03, 0x0a, 0x17, 0x62, + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0x80, 0x0f, 0x0a, 0x26, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x12, 0x0d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x22, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x61, 0x70, + 0x70, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x22, 0x6a, 0x0a, 0x11, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x38, 0x0a, 0x06, 0x61, 0x70, 0x70, 0x5f, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x05, 0x61, 0x70, 0x70, 0x49, + 0x64, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, + 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x63, + 0x0a, 0x0b, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x38, 0x0a, + 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, + 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, + 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, + 0x69, 0x6f, 0x6e, 0x22, 0x3b, 0x0a, 0x0b, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x4c, 0x69, + 0x73, 0x74, 0x12, 0x2c, 0x0a, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x52, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, + 0x22, 0x7f, 0x0a, 0x07, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x12, 0x3e, 0x0a, 0x08, 0x6d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x52, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x4d, 0x65, 0x74, 0x61, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, + 0x01, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x34, 0x0a, 0x06, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x52, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x22, 0x54, 0x0a, 0x0d, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, + 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x64, + 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, + 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x42, 0xb3, 0x01, 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x42, 0x16, 0x52, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0xa2, 0x02, 0x03, 0x46, 0x41, 0x58, + 0xaa, 0x02, 0x0d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x41, 0x70, 0x70, + 0xca, 0x02, 0x0d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, + 0xe2, 0x02, 0x19, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0e, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x41, 0x70, 0x70, 0x4a, 0xe2, 0x08, + 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x2a, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, + 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x16, 0x0a, 0x09, 0x0a, 0x02, + 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, + 0x00, 0x2c, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x07, 0x00, 0x48, 0x0a, 0x09, 0x0a, 0x02, + 0x08, 0x0b, 0x12, 0x03, 0x07, 0x00, 0x48, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x09, + 0x00, 0x0d, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x09, 0x08, 0x19, 0x0a, + 0x1d, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0b, 0x02, 0x3f, 0x1a, 0x10, 0x20, 0x49, + 0x44, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x0b, 0x02, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0b, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x0b, 0x16, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x08, 0x12, 0x03, 0x0b, 0x18, 0x3e, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x02, 0x00, 0x08, 0x87, + 0x09, 0x19, 0x12, 0x03, 0x0b, 0x19, 0x3d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, + 0x03, 0x0c, 0x02, 0x3c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x0c, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0c, 0x09, 0x0d, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x0c, 0x10, 0x11, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x08, 0x12, 0x03, 0x0c, 0x12, 0x3b, 0x0a, 0x10, 0x0a, 0x09, + 0x04, 0x00, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x0c, 0x13, 0x3a, 0x0a, 0x0a, + 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x0f, 0x00, 0x15, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, + 0x01, 0x12, 0x03, 0x0f, 0x08, 0x13, 0x0a, 0x21, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, + 0x11, 0x02, 0x42, 0x1a, 0x14, 0x20, 0x49, 0x44, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x11, 0x02, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x11, 0x14, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x11, 0x19, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x08, 0x12, 0x03, 0x11, 0x1b, + 0x41, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x01, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x11, + 0x1c, 0x40, 0x0a, 0x2e, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x14, 0x02, 0x16, 0x1a, + 0x21, 0x20, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, 0x14, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x14, 0x09, 0x11, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x14, 0x14, 0x15, 0x0a, 0x0a, 0x0a, 0x02, + 0x04, 0x02, 0x12, 0x04, 0x17, 0x00, 0x1a, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, + 0x03, 0x17, 0x08, 0x13, 0x0a, 0x20, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x19, 0x02, + 0x1d, 0x1a, 0x13, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x04, 0x12, + 0x03, 0x19, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, 0x03, 0x19, + 0x0b, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x19, 0x13, 0x18, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x19, 0x1b, 0x1c, 0x0a, 0x4f, + 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x1d, 0x00, 0x22, 0x01, 0x1a, 0x43, 0x20, 0x52, 0x65, 0x70, + 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x70, 0x70, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x20, 0x69, 0x74, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x1d, 0x08, 0x0f, 0x0a, 0x23, 0x0a, 0x04, 0x04, + 0x03, 0x02, 0x00, 0x12, 0x03, 0x1f, 0x02, 0x42, 0x1a, 0x16, 0x20, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x1f, 0x02, 0x0d, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1f, 0x0e, 0x16, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1f, 0x19, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x00, 0x08, 0x12, 0x03, 0x1f, 0x1b, 0x41, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x03, 0x02, 0x00, + 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x1f, 0x1c, 0x40, 0x0a, 0x21, 0x0a, 0x04, 0x04, 0x03, 0x02, + 0x01, 0x12, 0x03, 0x21, 0x02, 0x1b, 0x1a, 0x14, 0x20, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x01, 0x06, 0x12, 0x03, 0x21, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x21, 0x10, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x21, 0x19, 0x1a, 0x0a, 0x33, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x25, 0x00, + 0x2a, 0x01, 0x1a, 0x27, 0x20, 0x52, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x04, 0x01, 0x12, 0x03, 0x25, 0x08, 0x15, 0x0a, 0x38, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, + 0x03, 0x27, 0x02, 0x1f, 0x1a, 0x2b, 0x20, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x64, + 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x05, 0x12, 0x03, 0x27, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x27, 0x09, 0x1a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x27, 0x1d, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x04, 0x02, 0x01, 0x12, 0x03, 0x29, 0x02, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, + 0x05, 0x12, 0x03, 0x29, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x29, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x29, + 0x12, 0x13, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0x97, 0x14, 0x0a, 0x24, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x61, 0x70, 0x70, + 0x5f, 0x6c, 0x6f, 0x67, 0x73, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, + 0x70, 0x70, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, + 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, + 0x22, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x61, + 0x70, 0x70, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x1a, 0x26, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, + 0x70, 0x70, 0x2f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x26, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x6c, 0x6f, 0x67, 0x73, 0x2f, 0x64, 0x61, 0x74, 0x61, + 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x22, 0x99, 0x01, 0x0a, 0x0f, 0x54, 0x61, 0x69, 0x6c, 0x4c, 0x6f, 0x67, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x32, 0x0a, 0x06, 0x61, 0x70, 0x70, 0x5f, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x48, 0x00, 0x52, 0x05, 0x61, 0x70, 0x70, 0x49, 0x64, 0x12, 0x41, 0x0a, 0x0a, 0x72, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, + 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x48, 0x00, 0x52, 0x09, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x64, 0x42, 0x0f, + 0x0a, 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, + 0x55, 0x0a, 0x15, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x3c, 0x0a, 0x08, 0x72, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x08, 0x72, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x22, 0xbb, 0x01, 0x0a, 0x08, 0x4c, 0x6f, 0x67, 0x4c, 0x69, + 0x6e, 0x65, 0x73, 0x12, 0x18, 0x0a, 0x05, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x05, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x12, 0x47, 0x0a, + 0x0a, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x09, 0x72, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x49, 0x64, 0x12, 0x4c, 0x0a, 0x10, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, + 0x75, 0x72, 0x65, 0x64, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x6c, 0x6f, 0x67, + 0x73, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2e, 0x4c, 0x6f, 0x67, 0x4c, + 0x69, 0x6e, 0x65, 0x52, 0x0f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x4c, + 0x69, 0x6e, 0x65, 0x73, 0x22, 0x3c, 0x0a, 0x0d, 0x4c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x73, + 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x2b, 0x0a, 0x04, 0x6c, 0x6f, 0x67, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x61, 0x70, 0x70, 0x2e, 0x4c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x73, 0x52, 0x04, 0x6c, 0x6f, + 0x67, 0x73, 0x22, 0xe6, 0x01, 0x0a, 0x10, 0x54, 0x61, 0x69, 0x6c, 0x4c, 0x6f, 0x67, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x4c, 0x69, 0x73, 0x74, 0x48, + 0x00, 0x52, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x45, 0x0a, 0x09, 0x6c, + 0x6f, 0x67, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x6c, 0x6f, 0x67, 0x73, 0x2e, + 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2e, 0x4c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, + 0x65, 0x73, 0x42, 0x02, 0x18, 0x01, 0x48, 0x00, 0x52, 0x08, 0x6c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, + 0x65, 0x73, 0x12, 0x38, 0x0a, 0x07, 0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x61, 0x70, 0x70, 0x2e, 0x4c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x73, 0x42, 0x61, 0x74, 0x63, + 0x68, 0x48, 0x00, 0x52, 0x07, 0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x42, 0x0d, 0x0a, 0x04, + 0x72, 0x65, 0x73, 0x70, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x42, 0xb0, 0x01, 0x0a, 0x11, + 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x42, 0x13, 0x41, 0x70, 0x70, 0x4c, 0x6f, 0x67, 0x73, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, + 0x64, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, + 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0xa2, 0x02, 0x03, 0x46, 0x41, + 0x58, 0xaa, 0x02, 0x0d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x41, 0x70, + 0x70, 0xca, 0x02, 0x0d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, + 0x70, 0xe2, 0x02, 0x19, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, + 0x70, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0e, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x41, 0x70, 0x70, 0x4a, 0xbb, + 0x0b, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x37, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, + 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x16, 0x0a, 0x09, 0x0a, + 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, + 0x05, 0x00, 0x2c, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, 0x30, 0x0a, 0x09, + 0x0a, 0x02, 0x03, 0x03, 0x12, 0x03, 0x07, 0x00, 0x30, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, + 0x09, 0x00, 0x48, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x09, 0x00, 0x48, 0x0a, 0x0a, + 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0b, 0x00, 0x15, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, + 0x01, 0x12, 0x03, 0x0b, 0x08, 0x17, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x00, 0x08, 0x00, 0x12, 0x04, + 0x0c, 0x02, 0x14, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x08, 0x00, 0x01, 0x12, 0x03, 0x0c, + 0x08, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x08, 0x00, 0x02, 0x12, 0x03, 0x0d, 0x04, 0x30, + 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x08, 0x00, 0x02, 0x87, 0x09, 0x01, 0x12, 0x03, 0x0d, 0x04, + 0x30, 0x0a, 0x3d, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x10, 0x04, 0x1a, 0x1a, 0x30, + 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, + 0x6f, 0x20, 0x67, 0x65, 0x74, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x10, 0x04, 0x0e, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x10, 0x0f, 0x15, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x10, 0x18, 0x19, 0x0a, 0x39, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x01, 0x12, 0x03, 0x13, 0x04, 0x25, 0x1a, 0x2c, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x20, 0x74, 0x6f, 0x20, 0x67, 0x65, 0x74, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, + 0x66, 0x6f, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, + 0x13, 0x04, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x13, 0x16, + 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x13, 0x23, 0x24, 0x0a, + 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x17, 0x00, 0x19, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x01, 0x01, 0x12, 0x03, 0x17, 0x08, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, + 0x03, 0x18, 0x02, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x04, 0x12, 0x03, 0x18, + 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x18, 0x0b, 0x1c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x18, 0x1d, 0x25, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x18, 0x28, 0x29, 0x0a, 0x0a, 0x0a, 0x02, + 0x04, 0x02, 0x12, 0x04, 0x1b, 0x00, 0x21, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, + 0x03, 0x1b, 0x08, 0x10, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x1c, 0x02, + 0x30, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x04, 0x12, 0x03, 0x1c, 0x02, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, 0x1c, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1c, 0x12, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1c, 0x1a, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x00, 0x08, 0x12, 0x03, 0x1c, 0x1c, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x02, 0x00, 0x08, + 0x03, 0x12, 0x03, 0x1c, 0x1d, 0x2e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x1e, 0x02, 0x4a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, 0x03, 0x1e, 0x02, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x1e, 0x14, 0x1e, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x1e, 0x21, 0x22, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x01, 0x08, 0x12, 0x03, 0x1e, 0x23, 0x49, 0x0a, 0x0f, 0x0a, 0x08, 0x04, + 0x02, 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x1e, 0x24, 0x48, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x02, 0x02, 0x02, 0x12, 0x03, 0x20, 0x02, 0x41, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x02, 0x04, 0x12, 0x03, 0x20, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x06, + 0x12, 0x03, 0x20, 0x0b, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x20, 0x2c, 0x3c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x03, 0x12, 0x03, 0x20, 0x3f, + 0x40, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x23, 0x00, 0x25, 0x01, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x23, 0x08, 0x15, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, + 0x00, 0x12, 0x03, 0x24, 0x02, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x04, 0x12, + 0x03, 0x24, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x24, + 0x0b, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x24, 0x14, 0x18, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x24, 0x1b, 0x1c, 0x0a, 0x0a, + 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x27, 0x00, 0x37, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, + 0x01, 0x12, 0x03, 0x27, 0x08, 0x18, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x04, 0x08, 0x00, 0x12, 0x04, + 0x28, 0x02, 0x36, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x08, 0x00, 0x01, 0x12, 0x03, 0x28, + 0x08, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x08, 0x00, 0x02, 0x12, 0x03, 0x29, 0x04, 0x30, + 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x04, 0x08, 0x00, 0x02, 0x87, 0x09, 0x01, 0x12, 0x03, 0x29, 0x04, + 0x30, 0x0a, 0xe7, 0x01, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x2e, 0x04, 0x27, 0x1a, + 0xd9, 0x01, 0x20, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x61, 0x72, 0x65, + 0x20, 0x62, 0x65, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x66, 0x6f, + 0x72, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x65, 0x78, 0x70, 0x65, 0x63, + 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x72, 0x73, 0x74, 0x0a, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x74, 0x6f, 0x20, + 0x62, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x74, 0x72, 0x65, 0x61, 0x6d, 0x20, 0x62, 0x75, 0x74, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x63, + 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x74, 0x20, 0x61, 0x74, 0x20, 0x61, 0x6e, + 0x79, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x74, 0x6f, 0x20, + 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, + 0x6f, 0x66, 0x0a, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, 0x62, 0x65, 0x69, + 0x6e, 0x67, 0x20, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x00, 0x06, 0x12, 0x03, 0x2e, 0x04, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x2e, 0x1a, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x2e, 0x25, 0x26, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x32, + 0x04, 0x48, 0x1a, 0x4d, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x20, + 0x6c, 0x6f, 0x67, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x20, + 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x2c, 0x20, 0x75, 0x73, 0x65, 0x20, + 0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x06, 0x12, 0x03, 0x32, 0x04, 0x25, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x32, 0x26, 0x2f, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x32, 0x32, 0x33, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x01, 0x08, 0x12, 0x03, 0x32, 0x34, 0x47, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x04, 0x02, + 0x01, 0x08, 0x03, 0x12, 0x03, 0x32, 0x35, 0x46, 0x0a, 0x38, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x02, + 0x12, 0x03, 0x35, 0x04, 0x1e, 0x1a, 0x2b, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x74, 0x65, + 0x73, 0x74, 0x20, 0x6c, 0x6f, 0x67, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x06, 0x12, 0x03, 0x35, 0x04, 0x11, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x35, 0x12, 0x19, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, 0x35, 0x1c, 0x1d, 0x62, 0x06, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xb6, 0x04, 0x0a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x61, 0x70, 0x70, 0x5f, 0x6c, 0x6f, 0x67, 0x73, 0x5f, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x1a, 0x24, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x61, 0x70, 0x70, 0x5f, + 0x6c, 0x6f, 0x67, 0x73, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x32, 0x64, 0x0a, 0x0e, 0x41, 0x70, 0x70, 0x4c, 0x6f, 0x67, 0x73, 0x53, 0x65, 0x72, + 0x76, 0x69, 0x63, 0x65, 0x12, 0x52, 0x0a, 0x08, 0x54, 0x61, 0x69, 0x6c, 0x4c, 0x6f, 0x67, 0x73, + 0x12, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, + 0x2e, 0x54, 0x61, 0x69, 0x6c, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, + 0x2e, 0x54, 0x61, 0x69, 0x6c, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x30, 0x01, 0x42, 0xb0, 0x01, 0x0a, 0x11, 0x63, 0x6f, 0x6d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x42, 0x13, + 0x41, 0x70, 0x70, 0x4c, 0x6f, 0x67, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, + 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0xa2, 0x02, 0x03, 0x46, 0x41, 0x58, 0xaa, 0x02, + 0x0d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x41, 0x70, 0x70, 0xca, 0x02, + 0x0d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, 0xe2, 0x02, + 0x19, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, 0x5c, 0x47, + 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0e, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x41, 0x70, 0x70, 0x4a, 0xb7, 0x01, 0x0a, 0x06, + 0x12, 0x04, 0x00, 0x00, 0x0c, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, + 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x16, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, + 0x12, 0x03, 0x04, 0x00, 0x2e, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x06, 0x00, 0x48, 0x0a, + 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x06, 0x00, 0x48, 0x0a, 0x0a, 0x0a, 0x02, 0x06, 0x00, + 0x12, 0x04, 0x08, 0x00, 0x0c, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x06, 0x00, 0x01, 0x12, 0x03, 0x08, + 0x08, 0x16, 0x0a, 0x0c, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x00, 0x12, 0x04, 0x09, 0x02, 0x0b, 0x03, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x09, 0x06, 0x0e, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x09, 0x0f, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x09, 0x29, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x09, 0x30, 0x40, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, + 0x04, 0x12, 0x03, 0x0a, 0x04, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, 0x06, 0x00, 0x02, 0x00, 0x04, 0x22, + 0x12, 0x03, 0x0a, 0x04, 0x2f, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xf9, 0x34, + 0x0a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, + 0x61, 0x70, 0x70, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x0d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, + 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x22, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x61, 0x70, 0x70, + 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x22, 0x3d, 0x0a, 0x0d, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x2c, 0x0a, 0x03, 0x61, 0x70, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, + 0x41, 0x70, 0x70, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x03, 0x61, 0x70, 0x70, + 0x22, 0x36, 0x0a, 0x0e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x24, 0x0a, 0x03, 0x61, 0x70, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, + 0x41, 0x70, 0x70, 0x52, 0x03, 0x61, 0x70, 0x70, 0x22, 0x89, 0x01, 0x0a, 0x0a, 0x47, 0x65, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x32, 0x0a, 0x06, 0x61, 0x70, 0x70, 0x5f, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x48, 0x00, 0x52, 0x05, 0x61, 0x70, 0x70, 0x49, 0x64, 0x12, 0x32, 0x0a, 0x07, 0x69, + 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x49, 0x6e, 0x67, + 0x72, 0x65, 0x73, 0x73, 0x48, 0x00, 0x52, 0x07, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x42, + 0x13, 0x0a, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x05, 0xba, + 0x48, 0x02, 0x08, 0x01, 0x22, 0x33, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x24, 0x0a, 0x03, 0x61, 0x70, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, + 0x2e, 0x41, 0x70, 0x70, 0x52, 0x03, 0x61, 0x70, 0x70, 0x22, 0x5e, 0x0a, 0x0d, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2c, 0x0a, 0x03, 0x61, 0x70, + 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x41, 0x70, 0x70, 0x42, 0x06, 0xba, 0x48, 0x03, + 0xc8, 0x01, 0x01, 0x52, 0x03, 0x61, 0x70, 0x70, 0x12, 0x1f, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, + 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x18, + 0x64, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x22, 0x36, 0x0a, 0x0e, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x24, 0x0a, 0x03, 0x61, + 0x70, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x41, 0x70, 0x70, 0x52, 0x03, 0x61, 0x70, + 0x70, 0x22, 0x49, 0x0a, 0x0d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x38, 0x0a, 0x06, 0x61, 0x70, 0x70, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, + 0x70, 0x70, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, + 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x05, 0x61, 0x70, 0x70, 0x49, 0x64, 0x22, 0x10, 0x0a, 0x0e, + 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xfe, + 0x01, 0x0a, 0x0b, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x37, + 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x07, + 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, + 0x03, 0x6f, 0x72, 0x67, 0x12, 0x44, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, + 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x43, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, + 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x3f, 0x0a, 0x07, 0x70, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x50, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x48, 0x00, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x42, 0x12, 0x0a, 0x09, 0x66, + 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x62, 0x79, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, + 0x4c, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x26, 0x0a, 0x04, 0x61, 0x70, 0x70, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x41, 0x70, + 0x70, 0x52, 0x04, 0x61, 0x70, 0x70, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0xf7, 0x01, + 0x0a, 0x0c, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, + 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, + 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x44, 0x0a, 0x0a, 0x63, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, + 0x64, 0x12, 0x3f, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x12, 0x32, 0x0a, 0x06, 0x61, 0x70, 0x70, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, + 0x70, 0x70, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, + 0x05, 0x61, 0x70, 0x70, 0x49, 0x64, 0x42, 0x0f, 0x0a, 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, 0x33, 0x0a, 0x0b, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x24, 0x0a, 0x03, 0x61, 0x70, 0x70, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x61, 0x70, 0x70, 0x2e, 0x41, 0x70, 0x70, 0x52, 0x03, 0x61, 0x70, 0x70, 0x22, 0x6f, 0x0a, 0x0b, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x33, 0x0a, 0x0b, 0x75, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x70, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, + 0x2e, 0x41, 0x70, 0x70, 0x52, 0x0a, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x70, 0x70, + 0x12, 0x2b, 0x0a, 0x07, 0x6f, 0x6c, 0x64, 0x5f, 0x61, 0x70, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x2e, 0x41, 0x70, 0x70, 0x52, 0x06, 0x6f, 0x6c, 0x64, 0x41, 0x70, 0x70, 0x22, 0x33, 0x0a, + 0x0b, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x24, 0x0a, 0x03, + 0x61, 0x70, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x41, 0x70, 0x70, 0x52, 0x03, 0x61, + 0x70, 0x70, 0x22, 0xdb, 0x01, 0x0a, 0x0d, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x0c, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x5f, 0x65, + 0x76, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x0b, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x3f, 0x0a, 0x0c, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, + 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x55, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x0b, 0x75, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x3f, 0x0a, 0x0c, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x44, 0x65, 0x6c, + 0x65, 0x74, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x0b, 0x64, 0x65, 0x6c, 0x65, + 0x74, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x42, 0x07, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, + 0x22, 0x43, 0x0a, 0x13, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2c, 0x0a, 0x03, 0x61, 0x70, 0x70, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x41, 0x70, 0x70, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, + 0x52, 0x03, 0x61, 0x70, 0x70, 0x22, 0x3c, 0x0a, 0x14, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x24, 0x0a, + 0x03, 0x61, 0x70, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x41, 0x70, 0x70, 0x52, 0x03, + 0x61, 0x70, 0x70, 0x22, 0x4b, 0x0a, 0x0c, 0x4c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x3b, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, + 0x22, 0x37, 0x0a, 0x0d, 0x4c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x26, 0x0a, 0x04, 0x61, 0x70, 0x70, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x12, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, + 0x41, 0x70, 0x70, 0x52, 0x04, 0x61, 0x70, 0x70, 0x73, 0x42, 0xac, 0x01, 0x0a, 0x11, 0x63, 0x6f, + 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x42, + 0x0f, 0x41, 0x70, 0x70, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x50, 0x72, 0x6f, 0x74, 0x6f, + 0x50, 0x01, 0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, + 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x61, 0x70, 0x70, 0xa2, 0x02, 0x03, 0x46, 0x41, 0x58, 0xaa, 0x02, 0x0d, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x41, 0x70, 0x70, 0xca, 0x02, 0x0d, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, 0xe2, 0x02, 0x19, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, 0x5c, 0x47, 0x50, 0x42, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x41, 0x70, 0x70, 0x4a, 0xd6, 0x23, 0x0a, 0x07, 0x12, 0x05, 0x00, + 0x00, 0xa1, 0x01, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, + 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x16, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, + 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x2c, 0x0a, 0x09, + 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, 0x2b, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x03, 0x12, + 0x03, 0x07, 0x00, 0x25, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x09, 0x00, 0x48, 0x0a, 0x09, + 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x09, 0x00, 0x48, 0x0a, 0x32, 0x0a, 0x02, 0x04, 0x00, 0x12, + 0x04, 0x0c, 0x00, 0x0f, 0x01, 0x1a, 0x26, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x63, 0x72, 0x65, 0x61, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0c, 0x08, 0x15, 0x0a, 0x25, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x00, 0x12, 0x03, 0x0e, 0x02, 0x35, 0x1a, 0x18, 0x20, 0x54, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, + 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x0e, 0x02, 0x05, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0e, 0x06, 0x09, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0e, 0x0c, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x08, 0x12, 0x03, 0x0e, 0x0e, 0x34, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x02, 0x00, + 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x0e, 0x0f, 0x33, 0x0a, 0x33, 0x0a, 0x02, 0x04, 0x01, 0x12, + 0x04, 0x12, 0x00, 0x15, 0x01, 0x1a, 0x27, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x63, 0x72, 0x65, + 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x12, 0x08, 0x16, 0x0a, 0x1f, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x00, 0x12, 0x03, 0x14, 0x02, 0x0e, 0x1a, 0x12, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x14, 0x02, 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x14, 0x06, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x14, 0x0c, 0x0d, 0x0a, 0x34, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x18, 0x00, 0x24, + 0x01, 0x1a, 0x28, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x69, + 0x6e, 0x67, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x02, 0x01, 0x12, 0x03, 0x18, 0x08, 0x12, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x02, 0x08, 0x00, 0x12, + 0x04, 0x19, 0x02, 0x23, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x08, 0x00, 0x01, 0x12, 0x03, + 0x19, 0x08, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x08, 0x00, 0x02, 0x12, 0x03, 0x1a, 0x04, + 0x30, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x02, 0x08, 0x00, 0x02, 0x87, 0x09, 0x01, 0x12, 0x03, 0x1a, + 0x04, 0x30, 0x0a, 0x35, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x1d, 0x04, 0x1a, 0x1a, + 0x28, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, + 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x1d, 0x04, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x1d, 0x0f, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x1d, 0x18, 0x19, 0x0a, 0xb6, 0x01, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x22, 0x04, + 0x18, 0x1a, 0xa8, 0x01, 0x20, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, + 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x64, 0x2e, 0x20, 0x4f, 0x6e, 0x6c, 0x79, 0x20, 0x6f, 0x6e, + 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x62, 0x65, 0x20, 0x73, 0x65, 0x74, 0x2e, 0x0a, 0x20, 0x49, 0x66, 0x20, 0x6d, 0x75, 0x6c, 0x74, + 0x69, 0x70, 0x6c, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, + 0x73, 0x65, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x72, + 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x61, 0x6d, 0x65, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x20, 0x4f, 0x74, 0x68, 0x65, 0x72, + 0x77, 0x69, 0x73, 0x65, 0x2c, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x69, + 0x73, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, 0x03, 0x22, 0x04, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x22, 0x0c, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x22, 0x16, 0x17, 0x0a, 0x35, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x27, 0x00, + 0x2a, 0x01, 0x1a, 0x29, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, + 0x76, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x27, 0x08, 0x13, 0x0a, 0x21, 0x0a, 0x04, 0x04, 0x03, 0x02, + 0x00, 0x12, 0x03, 0x29, 0x02, 0x0e, 0x1a, 0x14, 0x20, 0x54, 0x68, 0x65, 0x20, 0x72, 0x65, 0x74, + 0x72, 0x69, 0x65, 0x76, 0x65, 0x64, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x29, 0x02, 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x29, 0x06, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x29, 0x0c, 0x0d, 0x0a, 0x32, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x2d, 0x00, + 0x31, 0x01, 0x1a, 0x26, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x69, 0x6e, + 0x67, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, + 0x01, 0x12, 0x03, 0x2d, 0x08, 0x15, 0x0a, 0x25, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, + 0x2f, 0x02, 0x35, 0x1a, 0x18, 0x20, 0x54, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x74, 0x6f, + 0x20, 0x62, 0x65, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x00, 0x06, 0x12, 0x03, 0x2f, 0x02, 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2f, 0x06, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x2f, 0x0c, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x08, + 0x12, 0x03, 0x2f, 0x0e, 0x34, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x04, 0x02, 0x00, 0x08, 0x87, 0x09, + 0x19, 0x12, 0x03, 0x2f, 0x0f, 0x33, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, + 0x30, 0x02, 0x40, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x05, 0x12, 0x03, 0x30, 0x02, + 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x30, 0x09, 0x0f, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x30, 0x12, 0x13, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x01, 0x08, 0x12, 0x03, 0x30, 0x14, 0x3f, 0x0a, 0x10, 0x0a, 0x09, 0x04, + 0x04, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, 0x03, 0x12, 0x03, 0x30, 0x15, 0x3e, 0x0a, 0x33, 0x0a, + 0x02, 0x04, 0x05, 0x12, 0x04, 0x34, 0x00, 0x37, 0x01, 0x1a, 0x27, 0x20, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x70, 0x70, + 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x34, 0x08, 0x16, 0x0a, 0x1f, + 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x36, 0x02, 0x0e, 0x1a, 0x12, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x06, 0x12, 0x03, 0x36, 0x02, 0x05, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x36, 0x06, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x36, 0x0c, 0x0d, 0x0a, 0x32, 0x0a, 0x02, 0x04, 0x06, 0x12, + 0x04, 0x3a, 0x00, 0x3d, 0x01, 0x1a, 0x26, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x6c, 0x65, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x06, 0x01, 0x12, 0x03, 0x3a, 0x08, 0x15, 0x0a, 0x33, 0x0a, 0x04, 0x04, 0x06, 0x02, + 0x00, 0x12, 0x03, 0x3c, 0x02, 0x3f, 0x1a, 0x26, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x74, + 0x6f, 0x20, 0x62, 0x65, 0x20, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x06, 0x12, 0x03, 0x3c, 0x02, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x03, 0x3c, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x3c, 0x16, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, + 0x08, 0x12, 0x03, 0x3c, 0x18, 0x3e, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x06, 0x02, 0x00, 0x08, 0x87, + 0x09, 0x19, 0x12, 0x03, 0x3c, 0x19, 0x3d, 0x0a, 0x32, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x03, 0x40, + 0x00, 0x19, 0x1a, 0x27, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x69, + 0x6e, 0x67, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x07, 0x01, 0x12, 0x03, 0x40, 0x08, 0x16, 0x0a, 0x2f, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x04, 0x43, + 0x00, 0x51, 0x01, 0x1a, 0x23, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x69, 0x6e, + 0x67, 0x20, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x08, 0x01, 0x12, + 0x03, 0x43, 0x08, 0x13, 0x0a, 0x2e, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x00, 0x12, 0x03, 0x45, 0x02, + 0x21, 0x1a, 0x21, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, + 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, + 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x06, 0x12, 0x03, 0x45, + 0x02, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x03, 0x45, 0x15, 0x1c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x03, 0x45, 0x1f, 0x20, 0x0a, 0x0c, + 0x0a, 0x04, 0x04, 0x08, 0x08, 0x00, 0x12, 0x04, 0x47, 0x02, 0x50, 0x03, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x08, 0x08, 0x00, 0x01, 0x12, 0x03, 0x47, 0x08, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, + 0x08, 0x00, 0x02, 0x12, 0x03, 0x48, 0x04, 0x30, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x08, 0x08, 0x00, + 0x02, 0x87, 0x09, 0x01, 0x12, 0x03, 0x48, 0x04, 0x30, 0x0a, 0x34, 0x0a, 0x04, 0x04, 0x08, 0x02, + 0x01, 0x12, 0x03, 0x4b, 0x04, 0x3d, 0x1a, 0x27, 0x20, 0x4f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, + 0x69, 0x6c, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x05, 0x12, 0x03, 0x4b, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x01, 0x01, 0x12, 0x03, 0x4b, 0x0b, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x01, 0x03, 0x12, 0x03, 0x4b, 0x11, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x01, 0x08, 0x12, 0x03, 0x4b, 0x13, 0x3c, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x08, 0x02, 0x01, 0x08, + 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x4b, 0x14, 0x3b, 0x0a, 0x35, 0x0a, 0x04, 0x04, 0x08, 0x02, + 0x02, 0x12, 0x03, 0x4d, 0x04, 0x2c, 0x1a, 0x28, 0x20, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x06, 0x12, 0x03, 0x4d, 0x04, 0x1c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x01, 0x12, 0x03, 0x4d, 0x1d, 0x27, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x08, 0x02, 0x02, 0x03, 0x12, 0x03, 0x4d, 0x2a, 0x2b, 0x0a, 0x35, 0x0a, 0x04, 0x04, 0x08, + 0x02, 0x03, 0x12, 0x03, 0x4f, 0x04, 0x29, 0x1a, 0x28, 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x70, 0x70, 0x73, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x06, 0x12, 0x03, 0x4f, 0x04, 0x1c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x01, 0x12, 0x03, 0x4f, 0x1d, 0x24, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x03, 0x03, 0x12, 0x03, 0x4f, 0x27, 0x28, 0x0a, 0x30, 0x0a, 0x02, 0x04, + 0x09, 0x12, 0x04, 0x54, 0x00, 0x59, 0x01, 0x1a, 0x24, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6c, + 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x09, 0x01, 0x12, 0x03, 0x54, 0x08, 0x14, 0x0a, 0x1c, 0x0a, 0x04, 0x04, 0x09, 0x02, + 0x00, 0x12, 0x03, 0x56, 0x02, 0x18, 0x1a, 0x0f, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, + 0x20, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x04, + 0x12, 0x03, 0x56, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x06, 0x12, 0x03, + 0x56, 0x0b, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x03, 0x56, 0x0f, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, 0x03, 0x56, 0x16, 0x17, 0x0a, + 0x43, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x01, 0x12, 0x03, 0x58, 0x02, 0x13, 0x1a, 0x36, 0x20, 0x54, + 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x65, 0x74, 0x63, 0x68, 0x69, 0x6e, + 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x70, 0x61, 0x67, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x61, + 0x6e, 0x79, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x05, 0x12, 0x03, 0x58, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x01, 0x12, 0x03, 0x58, 0x09, 0x0e, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x03, 0x12, 0x03, 0x58, 0x11, 0x12, 0x0a, 0x36, + 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x04, 0x5c, 0x00, 0x69, 0x01, 0x1a, 0x2a, 0x20, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x77, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x70, 0x70, 0x20, 0x65, 0x76, + 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x0a, 0x01, 0x12, 0x03, 0x5c, + 0x08, 0x14, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0a, 0x08, 0x00, 0x12, 0x04, 0x5d, 0x02, 0x68, 0x03, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x08, 0x00, 0x01, 0x12, 0x03, 0x5d, 0x08, 0x0e, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x0a, 0x08, 0x00, 0x02, 0x12, 0x03, 0x5e, 0x04, 0x30, 0x0a, 0x0f, 0x0a, 0x08, + 0x04, 0x0a, 0x08, 0x00, 0x02, 0x87, 0x09, 0x01, 0x12, 0x03, 0x5e, 0x04, 0x30, 0x0a, 0x36, 0x0a, + 0x04, 0x04, 0x0a, 0x02, 0x00, 0x12, 0x03, 0x61, 0x04, 0x3d, 0x1a, 0x29, 0x20, 0x4f, 0x72, 0x67, + 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x76, 0x65, + 0x6e, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x61, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x03, 0x61, 0x0b, + 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, 0x03, 0x61, 0x11, 0x12, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x08, 0x12, 0x03, 0x61, 0x13, 0x3c, 0x0a, 0x10, 0x0a, + 0x09, 0x04, 0x0a, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x61, 0x14, 0x3b, 0x0a, + 0x37, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x01, 0x12, 0x03, 0x63, 0x04, 0x2c, 0x1a, 0x2a, 0x20, 0x43, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x20, + 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, + 0x06, 0x12, 0x03, 0x63, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x63, 0x1d, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x03, 0x12, 0x03, 0x63, + 0x2a, 0x2b, 0x0a, 0x37, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x02, 0x12, 0x03, 0x65, 0x04, 0x29, 0x1a, + 0x2a, 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x69, + 0x6e, 0x67, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x0a, 0x02, 0x02, 0x06, 0x12, 0x03, 0x65, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x65, 0x1d, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x65, 0x27, 0x28, 0x0a, 0x33, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x03, 0x12, 0x03, 0x67, + 0x04, 0x1a, 0x1a, 0x26, 0x20, 0x41, 0x70, 0x70, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x69, 0x6e, + 0x67, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, + 0x02, 0x03, 0x06, 0x12, 0x03, 0x67, 0x04, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, + 0x01, 0x12, 0x03, 0x67, 0x0f, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, 0x03, 0x12, + 0x03, 0x67, 0x18, 0x19, 0x0a, 0x2d, 0x0a, 0x02, 0x04, 0x0b, 0x12, 0x04, 0x6c, 0x00, 0x6f, 0x01, + 0x1a, 0x21, 0x20, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x70, 0x70, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x0b, 0x01, 0x12, 0x03, 0x6c, 0x08, 0x13, 0x0a, + 0x1f, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x00, 0x12, 0x03, 0x6e, 0x02, 0x0e, 0x1a, 0x12, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x06, 0x12, 0x03, 0x6e, 0x02, 0x05, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x01, 0x12, 0x03, 0x6e, 0x06, 0x09, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x0b, 0x02, 0x00, 0x03, 0x12, 0x03, 0x6e, 0x0c, 0x0d, 0x0a, 0x2b, 0x0a, 0x02, 0x04, 0x0c, + 0x12, 0x04, 0x72, 0x00, 0x77, 0x01, 0x1a, 0x1f, 0x20, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x20, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x70, 0x70, 0x20, 0x75, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x0c, 0x01, 0x12, 0x03, + 0x72, 0x08, 0x13, 0x0a, 0x1f, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x00, 0x12, 0x03, 0x74, 0x02, 0x16, + 0x1a, 0x12, 0x20, 0x54, 0x68, 0x65, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x20, 0x61, + 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x06, 0x12, 0x03, 0x74, + 0x02, 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x01, 0x12, 0x03, 0x74, 0x06, 0x11, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x03, 0x12, 0x03, 0x74, 0x14, 0x15, 0x0a, 0x2d, + 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x01, 0x12, 0x03, 0x76, 0x02, 0x12, 0x1a, 0x20, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x6f, 0x6c, 0x64, 0x20, 0x61, 0x70, 0x70, 0x20, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x0c, 0x02, 0x01, 0x06, 0x12, 0x03, 0x76, 0x02, 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x0c, 0x02, 0x01, 0x01, 0x12, 0x03, 0x76, 0x06, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, + 0x01, 0x03, 0x12, 0x03, 0x76, 0x10, 0x11, 0x0a, 0x2d, 0x0a, 0x02, 0x04, 0x0d, 0x12, 0x04, 0x7a, + 0x00, 0x7d, 0x01, 0x1a, 0x21, 0x20, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x70, 0x70, 0x20, 0x64, 0x65, 0x6c, 0x65, + 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x0d, 0x01, 0x12, 0x03, 0x7a, + 0x08, 0x13, 0x0a, 0x1f, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x00, 0x12, 0x03, 0x7c, 0x02, 0x0e, 0x1a, + 0x12, 0x20, 0x54, 0x68, 0x65, 0x20, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x20, 0x61, 0x70, + 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x06, 0x12, 0x03, 0x7c, 0x02, + 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x01, 0x12, 0x03, 0x7c, 0x06, 0x09, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x03, 0x12, 0x03, 0x7c, 0x0c, 0x0d, 0x0a, 0x39, 0x0a, + 0x02, 0x04, 0x0e, 0x12, 0x06, 0x80, 0x01, 0x00, 0x89, 0x01, 0x01, 0x1a, 0x2b, 0x20, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x77, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x70, 0x70, 0x20, + 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0e, 0x01, 0x12, + 0x04, 0x80, 0x01, 0x08, 0x15, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x0e, 0x08, 0x00, 0x12, 0x06, 0x81, + 0x01, 0x02, 0x88, 0x01, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x08, 0x00, 0x01, 0x12, 0x04, + 0x81, 0x01, 0x08, 0x0d, 0x0a, 0x27, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x00, 0x12, 0x04, 0x83, 0x01, + 0x04, 0x21, 0x1a, 0x19, 0x20, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, + 0x70, 0x70, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x00, 0x06, 0x12, 0x04, 0x83, 0x01, 0x04, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x00, 0x01, 0x12, 0x04, 0x83, 0x01, 0x10, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x00, 0x03, 0x12, 0x04, 0x83, 0x01, 0x1f, 0x20, 0x0a, 0x25, 0x0a, 0x04, 0x04, 0x0e, + 0x02, 0x01, 0x12, 0x04, 0x85, 0x01, 0x04, 0x21, 0x1a, 0x17, 0x20, 0x45, 0x76, 0x65, 0x6e, 0x74, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x70, 0x70, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x06, 0x12, 0x04, 0x85, 0x01, 0x04, 0x0f, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x01, 0x12, 0x04, 0x85, 0x01, 0x10, 0x1c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x03, 0x12, 0x04, 0x85, 0x01, 0x1f, 0x20, 0x0a, 0x27, + 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x02, 0x12, 0x04, 0x87, 0x01, 0x04, 0x21, 0x1a, 0x19, 0x20, 0x45, + 0x76, 0x65, 0x6e, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x70, 0x70, 0x20, 0x64, 0x65, 0x6c, + 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x02, 0x06, + 0x12, 0x04, 0x87, 0x01, 0x04, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x02, 0x01, 0x12, + 0x04, 0x87, 0x01, 0x10, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x02, 0x03, 0x12, 0x04, + 0x87, 0x01, 0x1f, 0x20, 0x0a, 0x38, 0x0a, 0x02, 0x04, 0x0f, 0x12, 0x06, 0x8c, 0x01, 0x00, 0x8f, + 0x01, 0x01, 0x1a, 0x2a, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x69, 0x6e, + 0x67, 0x20, 0x61, 0x70, 0x70, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x0a, 0x0a, 0x0b, + 0x0a, 0x03, 0x04, 0x0f, 0x01, 0x12, 0x04, 0x8c, 0x01, 0x08, 0x1b, 0x0a, 0x2c, 0x0a, 0x04, 0x04, + 0x0f, 0x02, 0x00, 0x12, 0x04, 0x8e, 0x01, 0x02, 0x35, 0x1a, 0x1e, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x61, 0x70, 0x70, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, + 0x00, 0x06, 0x12, 0x04, 0x8e, 0x01, 0x02, 0x05, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, + 0x01, 0x12, 0x04, 0x8e, 0x01, 0x06, 0x09, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x03, + 0x12, 0x04, 0x8e, 0x01, 0x0c, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x08, 0x12, + 0x04, 0x8e, 0x01, 0x0e, 0x34, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x0f, 0x02, 0x00, 0x08, 0x87, 0x09, + 0x19, 0x12, 0x04, 0x8e, 0x01, 0x0f, 0x33, 0x0a, 0x39, 0x0a, 0x02, 0x04, 0x10, 0x12, 0x06, 0x92, + 0x01, 0x00, 0x95, 0x01, 0x01, 0x1a, 0x2b, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x75, 0x70, 0x64, + 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x70, 0x70, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x10, 0x01, 0x12, 0x04, 0x92, 0x01, 0x08, 0x1c, 0x0a, + 0x2c, 0x0a, 0x04, 0x04, 0x10, 0x02, 0x00, 0x12, 0x04, 0x94, 0x01, 0x02, 0x0e, 0x1a, 0x1e, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x75, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x10, 0x02, 0x00, 0x06, 0x12, 0x04, 0x94, 0x01, 0x02, 0x05, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x10, 0x02, 0x00, 0x01, 0x12, 0x04, 0x94, 0x01, 0x06, 0x09, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x10, 0x02, 0x00, 0x03, 0x12, 0x04, 0x94, 0x01, 0x0c, 0x0d, 0x0a, 0x31, 0x0a, 0x02, 0x04, 0x11, + 0x12, 0x06, 0x98, 0x01, 0x00, 0x9b, 0x01, 0x01, 0x1a, 0x23, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6c, + 0x65, 0x61, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, + 0x03, 0x04, 0x11, 0x01, 0x12, 0x04, 0x98, 0x01, 0x08, 0x14, 0x0a, 0x34, 0x0a, 0x04, 0x04, 0x11, + 0x02, 0x00, 0x12, 0x04, 0x9a, 0x01, 0x02, 0x49, 0x1a, 0x26, 0x20, 0x43, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x6c, 0x65, 0x61, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, 0x06, 0x12, 0x04, 0x9a, 0x01, 0x02, 0x1a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, 0x01, 0x12, 0x04, 0x9a, 0x01, 0x1b, 0x1d, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, 0x03, 0x12, 0x04, 0x9a, 0x01, 0x20, 0x21, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x11, 0x02, 0x00, 0x08, 0x12, 0x04, 0x9a, 0x01, 0x22, 0x48, 0x0a, 0x10, 0x0a, 0x08, + 0x04, 0x11, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x04, 0x9a, 0x01, 0x23, 0x47, 0x0a, 0x32, + 0x0a, 0x02, 0x04, 0x12, 0x12, 0x06, 0x9e, 0x01, 0x00, 0xa1, 0x01, 0x01, 0x1a, 0x24, 0x20, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x6c, 0x65, 0x61, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x70, 0x70, 0x73, + 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x12, 0x01, 0x12, 0x04, 0x9e, 0x01, 0x08, 0x15, 0x0a, + 0x24, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x00, 0x12, 0x04, 0xa0, 0x01, 0x02, 0x18, 0x1a, 0x16, 0x20, + 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x20, 0x61, + 0x70, 0x70, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x00, 0x04, 0x12, 0x04, + 0xa0, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x00, 0x06, 0x12, 0x04, 0xa0, + 0x01, 0x0b, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x00, 0x01, 0x12, 0x04, 0xa0, 0x01, + 0x0f, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x00, 0x03, 0x12, 0x04, 0xa0, 0x01, 0x16, + 0x17, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xd8, 0x0e, 0x0a, 0x1f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x61, 0x70, 0x70, 0x5f, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x1a, 0x1f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x61, 0x70, 0x70, 0x5f, + 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0xde, 0x04, + 0x0a, 0x0a, 0x41, 0x70, 0x70, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x47, 0x0a, 0x06, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x41, 0x0a, 0x03, 0x47, 0x65, 0x74, 0x12, 0x19, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x47, 0x65, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x47, 0x0a, 0x06, 0x55, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x12, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, + 0x70, 0x70, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, + 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x00, 0x12, 0x59, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x12, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x47, 0x0a, 0x06, + 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x44, 0x0a, 0x04, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x1a, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x4c, 0x69, + 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x49, 0x0a, 0x05, 0x57, + 0x61, 0x74, 0x63, 0x68, 0x12, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, + 0x70, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x03, 0x90, 0x02, 0x01, 0x30, 0x01, 0x12, 0x46, 0x0a, 0x05, 0x4c, 0x65, 0x61, 0x73, 0x65, 0x12, + 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, + 0x4c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x4c, 0x65, 0x61, + 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x42, 0xac, + 0x01, 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x61, 0x70, 0x70, 0x42, 0x0f, 0x41, 0x70, 0x70, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x70, 0x70, 0xa2, 0x02, 0x03, 0x46, 0x41, 0x58, + 0xaa, 0x02, 0x0d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x41, 0x70, 0x70, + 0xca, 0x02, 0x0d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, + 0xe2, 0x02, 0x19, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x70, 0x70, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0e, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x41, 0x70, 0x70, 0x4a, 0xec, 0x07, + 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x27, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, + 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x16, 0x0a, 0x09, 0x0a, 0x02, + 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x29, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x06, 0x00, + 0x48, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x06, 0x00, 0x48, 0x0a, 0x3f, 0x0a, 0x02, + 0x06, 0x00, 0x12, 0x04, 0x09, 0x00, 0x27, 0x01, 0x1a, 0x33, 0x20, 0x41, 0x70, 0x70, 0x53, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6d, 0x61, + 0x6e, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x06, 0x00, 0x01, 0x12, 0x03, 0x09, 0x08, 0x12, 0x0a, 0x28, 0x0a, 0x04, 0x06, 0x00, 0x02, + 0x00, 0x12, 0x03, 0x0b, 0x02, 0x37, 0x1a, 0x1b, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, + 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x61, 0x70, + 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0b, 0x06, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x0b, 0x0d, 0x1a, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0b, 0x25, 0x33, 0x0a, 0x37, 0x0a, + 0x04, 0x06, 0x00, 0x02, 0x01, 0x12, 0x04, 0x0e, 0x02, 0x10, 0x03, 0x1a, 0x29, 0x20, 0x47, 0x65, + 0x74, 0x20, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, + 0x70, 0x70, 0x20, 0x62, 0x79, 0x20, 0x69, 0x74, 0x73, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x0e, 0x06, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x0e, + 0x0a, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x0e, 0x1f, 0x2a, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x04, 0x12, 0x03, 0x0f, 0x04, 0x2f, 0x0a, 0x0d, + 0x0a, 0x06, 0x06, 0x00, 0x02, 0x01, 0x04, 0x22, 0x12, 0x03, 0x0f, 0x04, 0x2f, 0x0a, 0x2e, 0x0a, + 0x04, 0x06, 0x00, 0x02, 0x02, 0x12, 0x03, 0x13, 0x02, 0x37, 0x1a, 0x21, 0x20, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x65, + 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x06, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x13, 0x06, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x06, + 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x13, 0x0d, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, + 0x02, 0x03, 0x12, 0x03, 0x13, 0x25, 0x33, 0x0a, 0x42, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x03, 0x12, + 0x03, 0x16, 0x02, 0x49, 0x1a, 0x35, 0x20, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x78, 0x69, + 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x70, 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, + 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x16, 0x06, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, + 0x03, 0x02, 0x12, 0x03, 0x16, 0x13, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x03, + 0x12, 0x03, 0x16, 0x31, 0x45, 0x0a, 0x37, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x04, 0x12, 0x03, 0x19, + 0x02, 0x37, 0x1a, 0x2a, 0x20, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x64, 0x65, 0x6c, 0x65, + 0x74, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x70, 0x70, 0x20, 0x62, 0x79, 0x20, 0x69, 0x74, + 0x73, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x19, 0x06, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, 0x19, 0x0d, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x04, 0x03, 0x12, 0x03, 0x19, 0x25, 0x33, 0x0a, 0x3c, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x05, + 0x12, 0x04, 0x1c, 0x02, 0x1e, 0x03, 0x1a, 0x2e, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6c, 0x69, + 0x73, 0x74, 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x61, 0x70, 0x70, 0x73, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, + 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x05, 0x01, 0x12, + 0x03, 0x1c, 0x06, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x05, 0x02, 0x12, 0x03, 0x1c, + 0x0b, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x05, 0x03, 0x12, 0x03, 0x1c, 0x21, 0x2d, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x05, 0x04, 0x12, 0x03, 0x1d, 0x04, 0x2f, 0x0a, 0x0d, + 0x0a, 0x06, 0x06, 0x00, 0x02, 0x05, 0x04, 0x22, 0x12, 0x03, 0x1d, 0x04, 0x2f, 0x0a, 0x2d, 0x0a, + 0x04, 0x06, 0x00, 0x02, 0x06, 0x12, 0x04, 0x21, 0x02, 0x23, 0x03, 0x1a, 0x1f, 0x20, 0x57, 0x61, + 0x74, 0x63, 0x68, 0x20, 0x77, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x61, 0x70, 0x70, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x21, 0x06, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x06, 0x02, 0x12, 0x03, 0x21, 0x0c, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x06, + 0x06, 0x12, 0x03, 0x21, 0x23, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x06, 0x03, 0x12, + 0x03, 0x21, 0x2a, 0x37, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x06, 0x04, 0x12, 0x03, 0x22, + 0x04, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, 0x06, 0x00, 0x02, 0x06, 0x04, 0x22, 0x12, 0x03, 0x22, 0x04, + 0x2f, 0x0a, 0x21, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x07, 0x12, 0x03, 0x26, 0x02, 0x3b, 0x1a, 0x14, + 0x20, 0x4c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x73, 0x20, 0x61, 0x70, + 0x70, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x07, 0x01, 0x12, 0x03, 0x26, + 0x06, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x07, 0x02, 0x12, 0x03, 0x26, 0x0c, 0x18, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x07, 0x06, 0x12, 0x03, 0x26, 0x23, 0x29, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x07, 0x03, 0x12, 0x03, 0x26, 0x2a, 0x37, 0x62, 0x06, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x33, +]; +include!("flyteidl2.app.tonic.rs"); +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/flyteidl2.app.tonic.rs b/gen/rust/src/flyteidl2.app.tonic.rs new file mode 100644 index 0000000000..fd7a5c53f5 --- /dev/null +++ b/gen/rust/src/flyteidl2.app.tonic.rs @@ -0,0 +1,1114 @@ +// @generated +/// Generated client implementations. +pub mod app_logs_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct AppLogsServiceClient { + inner: tonic::client::Grpc, + } + impl AppLogsServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl AppLogsServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> AppLogsServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + AppLogsServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /// + pub async fn tail_logs( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.app.AppLogsService/TailLogs", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.app.AppLogsService", "TailLogs")); + self.inner.server_streaming(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod app_logs_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with AppLogsServiceServer. + #[async_trait] + pub trait AppLogsService: Send + Sync + 'static { + /// Server streaming response type for the TailLogs method. + type TailLogsStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + Send + + 'static; + /// + async fn tail_logs( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + } + #[derive(Debug)] + pub struct AppLogsServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl AppLogsServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for AppLogsServiceServer + where + T: AppLogsService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.app.AppLogsService/TailLogs" => { + #[allow(non_camel_case_types)] + struct TailLogsSvc(pub Arc); + impl< + T: AppLogsService, + > tonic::server::ServerStreamingService + for TailLogsSvc { + type Response = super::TailLogsResponse; + type ResponseStream = T::TailLogsStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::tail_logs(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = TailLogsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for AppLogsServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService for AppLogsServiceServer { + const NAME: &'static str = "flyteidl2.app.AppLogsService"; + } +} +/// Generated client implementations. +pub mod app_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + /** AppService defines the service for managing apps. +*/ + #[derive(Debug, Clone)] + pub struct AppServiceClient { + inner: tonic::client::Grpc, + } + impl AppServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl AppServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> AppServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + AppServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /** Create creates a new app. +*/ + pub async fn create( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.app.AppService/Create", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.app.AppService", "Create")); + self.inner.unary(req, path, codec).await + } + /** Get retrieves an app by its identifier. +*/ + pub async fn get( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.app.AppService/Get", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.app.AppService", "Get")); + self.inner.unary(req, path, codec).await + } + /** Update updates an existing app. +*/ + pub async fn update( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.app.AppService/Update", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.app.AppService", "Update")); + self.inner.unary(req, path, codec).await + } + /** UpdateStatus updates the status of an existing app. +*/ + pub async fn update_status( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.app.AppService/UpdateStatus", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.app.AppService", "UpdateStatus")); + self.inner.unary(req, path, codec).await + } + /** Delete deletes an app by its identifier. +*/ + pub async fn delete( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.app.AppService/Delete", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.app.AppService", "Delete")); + self.inner.unary(req, path, codec).await + } + /** List lists all apps with optional filtering. +*/ + pub async fn list( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.app.AppService/List", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.app.AppService", "List")); + self.inner.unary(req, path, codec).await + } + /** Watch watches for app events. +*/ + pub async fn watch( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.app.AppService/Watch", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.app.AppService", "Watch")); + self.inner.server_streaming(req, path, codec).await + } + /** Lease leases apps. +*/ + pub async fn lease( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.app.AppService/Lease", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.app.AppService", "Lease")); + self.inner.server_streaming(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod app_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with AppServiceServer. + #[async_trait] + pub trait AppService: Send + Sync + 'static { + /** Create creates a new app. +*/ + async fn create( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /** Get retrieves an app by its identifier. +*/ + async fn get( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /** Update updates an existing app. +*/ + async fn update( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /** UpdateStatus updates the status of an existing app. +*/ + async fn update_status( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /** Delete deletes an app by its identifier. +*/ + async fn delete( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /** List lists all apps with optional filtering. +*/ + async fn list( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Server streaming response type for the Watch method. + type WatchStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + Send + + 'static; + /** Watch watches for app events. +*/ + async fn watch( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Server streaming response type for the Lease method. + type LeaseStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + Send + + 'static; + /** Lease leases apps. +*/ + async fn lease( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + } + /** AppService defines the service for managing apps. +*/ + #[derive(Debug)] + pub struct AppServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl AppServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for AppServiceServer + where + T: AppService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.app.AppService/Create" => { + #[allow(non_camel_case_types)] + struct CreateSvc(pub Arc); + impl tonic::server::UnaryService + for CreateSvc { + type Response = super::CreateResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::create(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = CreateSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.app.AppService/Get" => { + #[allow(non_camel_case_types)] + struct GetSvc(pub Arc); + impl tonic::server::UnaryService + for GetSvc { + type Response = super::GetResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.app.AppService/Update" => { + #[allow(non_camel_case_types)] + struct UpdateSvc(pub Arc); + impl tonic::server::UnaryService + for UpdateSvc { + type Response = super::UpdateResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::update(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = UpdateSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.app.AppService/UpdateStatus" => { + #[allow(non_camel_case_types)] + struct UpdateStatusSvc(pub Arc); + impl< + T: AppService, + > tonic::server::UnaryService + for UpdateStatusSvc { + type Response = super::UpdateStatusResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::update_status(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = UpdateStatusSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.app.AppService/Delete" => { + #[allow(non_camel_case_types)] + struct DeleteSvc(pub Arc); + impl tonic::server::UnaryService + for DeleteSvc { + type Response = super::DeleteResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::delete(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = DeleteSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.app.AppService/List" => { + #[allow(non_camel_case_types)] + struct ListSvc(pub Arc); + impl tonic::server::UnaryService + for ListSvc { + type Response = super::ListResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::list(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ListSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.app.AppService/Watch" => { + #[allow(non_camel_case_types)] + struct WatchSvc(pub Arc); + impl< + T: AppService, + > tonic::server::ServerStreamingService + for WatchSvc { + type Response = super::WatchResponse; + type ResponseStream = T::WatchStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::watch(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = WatchSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.app.AppService/Lease" => { + #[allow(non_camel_case_types)] + struct LeaseSvc(pub Arc); + impl< + T: AppService, + > tonic::server::ServerStreamingService + for LeaseSvc { + type Response = super::LeaseResponse; + type ResponseStream = T::LeaseStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::lease(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = LeaseSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for AppServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService for AppServiceServer { + const NAME: &'static str = "flyteidl2.app.AppService"; + } +} diff --git a/gen/rust/src/flyteidl2.auth.rs b/gen/rust/src/flyteidl2.auth.rs new file mode 100644 index 0000000000..5b8eb8a87e --- /dev/null +++ b/gen/rust/src/flyteidl2.auth.rs @@ -0,0 +1,578 @@ +// @generated +// This file is @generated by prost-build. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct GetOAuth2MetadataRequest { +} +/// OAuth2MetadataResponse defines an RFC-Compliant response for /.well-known/oauth-authorization-server metadata +/// as defined in +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetOAuth2MetadataResponse { + /// Defines the issuer string in all JWT tokens this server issues. The issuer can be admin itself or an external + /// issuer. + #[prost(string, tag="1")] + pub issuer: ::prost::alloc::string::String, + /// URL of the authorization server's authorization endpoint \[RFC6749\]. This is REQUIRED unless no grant types are + /// supported that use the authorization endpoint. + #[prost(string, tag="2")] + pub authorization_endpoint: ::prost::alloc::string::String, + /// URL of the authorization server's token endpoint \[RFC6749\]. + #[prost(string, tag="3")] + pub token_endpoint: ::prost::alloc::string::String, + /// Array containing a list of the OAuth 2.0 response_type values that this authorization server supports. + #[prost(string, repeated, tag="4")] + pub response_types_supported: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// JSON array containing a list of the OAuth 2.0 \[RFC6749\] scope values that this authorization server supports. + #[prost(string, repeated, tag="5")] + pub scopes_supported: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// JSON array containing a list of client authentication methods supported by this token endpoint. + #[prost(string, repeated, tag="6")] + pub token_endpoint_auth_methods_supported: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// URL of the authorization server's JWK Set \[JWK\] document. The referenced document contains the signing key(s) the + /// client uses to validate signatures from the authorization server. + #[prost(string, tag="7")] + pub jwks_uri: ::prost::alloc::string::String, + /// JSON array containing a list of Proof Key for Code Exchange (PKCE) \[RFC7636\] code challenge methods supported by + /// this authorization server. + #[prost(string, repeated, tag="8")] + pub code_challenge_methods_supported: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// JSON array containing a list of the OAuth 2.0 grant type values that this authorization server supports. + #[prost(string, repeated, tag="9")] + pub grant_types_supported: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// URL of the authorization server's device authorization endpoint, as defined in Section 3.1 of \[RFC8628\] + #[prost(string, tag="10")] + pub device_authorization_endpoint: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct GetPublicClientConfigRequest { +} +/// FlyteClientResponse encapsulates public information that flyte clients (CLIs... etc.) can use to authenticate users. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetPublicClientConfigResponse { + /// client_id to use when initiating OAuth2 authorization requests. + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + /// redirect uri to use when initiating OAuth2 authorization requests. + #[prost(string, tag="2")] + pub redirect_uri: ::prost::alloc::string::String, + /// scopes to request when initiating OAuth2 authorization requests. + #[prost(string, repeated, tag="3")] + pub scopes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Authorization Header to use when passing Access Tokens to the server. If not provided, the client should use the + /// default http `Authorization` header. + #[prost(string, tag="4")] + pub authorization_metadata_key: ::prost::alloc::string::String, + /// ServiceHttpEndpoint points to the http endpoint for the backend. If empty, clients can assume the endpoint used + /// to configure the gRPC connection can be used for the http one respecting the insecure flag to choose between + /// SSL or no SSL connections. + #[prost(string, tag="5")] + pub service_http_endpoint: ::prost::alloc::string::String, + /// audience to use when initiating OAuth2 authorization requests. + #[prost(string, tag="6")] + pub audience: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct UserInfoRequest { +} +/// See the OpenID Connect spec at for more information. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UserInfoResponse { + /// Locally unique and never reassigned identifier within the Issuer for the End-User, which is intended to be consumed + /// by the Client. + #[prost(string, tag="1")] + pub subject: ::prost::alloc::string::String, + /// Full name + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, + /// Shorthand name by which the End-User wishes to be referred to + #[prost(string, tag="3")] + pub preferred_username: ::prost::alloc::string::String, + /// Given name(s) or first name(s) + #[prost(string, tag="4")] + pub given_name: ::prost::alloc::string::String, + /// Surname(s) or last name(s) + #[prost(string, tag="5")] + pub family_name: ::prost::alloc::string::String, + /// Preferred e-mail address + #[prost(string, tag="6")] + pub email: ::prost::alloc::string::String, + /// Profile picture URL + #[prost(string, tag="7")] + pub picture: ::prost::alloc::string::String, + /// Additional claims + #[prost(message, optional, tag="8")] + pub additional_claims: ::core::option::Option, +} +/// Encoded file descriptor set for the `flyteidl2.auth` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xf3, 0x29, 0x0a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, + 0x75, 0x74, 0x68, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x22, 0x1a, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x4f, 0x41, 0x75, + 0x74, 0x68, 0x32, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x22, 0xa4, 0x04, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x16, 0x0a, 0x06, 0x69, 0x73, 0x73, 0x75, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x06, 0x69, 0x73, 0x73, 0x75, 0x65, 0x72, 0x12, 0x35, 0x0a, 0x16, 0x61, 0x75, 0x74, 0x68, + 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, + 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x15, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, + 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, + 0x25, 0x0a, 0x0e, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, + 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x45, 0x6e, + 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x38, 0x0a, 0x18, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, + 0x65, 0x64, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x16, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, + 0x12, 0x29, 0x0a, 0x10, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x73, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6f, + 0x72, 0x74, 0x65, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0f, 0x73, 0x63, 0x6f, 0x70, + 0x65, 0x73, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x12, 0x50, 0x0a, 0x25, 0x74, + 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x5f, 0x61, 0x75, + 0x74, 0x68, 0x5f, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6f, + 0x72, 0x74, 0x65, 0x64, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x21, 0x74, 0x6f, 0x6b, 0x65, + 0x6e, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x41, 0x75, 0x74, 0x68, 0x4d, 0x65, 0x74, + 0x68, 0x6f, 0x64, 0x73, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x12, 0x19, 0x0a, + 0x08, 0x6a, 0x77, 0x6b, 0x73, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x07, 0x6a, 0x77, 0x6b, 0x73, 0x55, 0x72, 0x69, 0x12, 0x47, 0x0a, 0x20, 0x63, 0x6f, 0x64, 0x65, + 0x5f, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x68, 0x6f, + 0x64, 0x73, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x18, 0x08, 0x20, 0x03, + 0x28, 0x09, 0x52, 0x1d, 0x63, 0x6f, 0x64, 0x65, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, + 0x65, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x12, 0x32, 0x0a, 0x15, 0x67, 0x72, 0x61, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, + 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x18, 0x09, 0x20, 0x03, 0x28, 0x09, + 0x52, 0x13, 0x67, 0x72, 0x61, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x73, 0x53, 0x75, 0x70, 0x70, + 0x6f, 0x72, 0x74, 0x65, 0x64, 0x12, 0x42, 0x0a, 0x1d, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x5f, + 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x6e, + 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x1b, 0x64, 0x65, + 0x76, 0x69, 0x63, 0x65, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x22, 0x1e, 0x0a, 0x1c, 0x47, 0x65, 0x74, + 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x85, 0x02, 0x0a, 0x1d, 0x47, 0x65, + 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x63, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x65, 0x64, 0x69, + 0x72, 0x65, 0x63, 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, + 0x72, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x55, 0x72, 0x69, 0x12, 0x16, 0x0a, 0x06, 0x73, + 0x63, 0x6f, 0x70, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x73, 0x63, 0x6f, + 0x70, 0x65, 0x73, 0x12, 0x3c, 0x0a, 0x1a, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x6b, 0x65, + 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x18, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, + 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x4b, 0x65, + 0x79, 0x12, 0x32, 0x0a, 0x15, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x68, 0x74, 0x74, + 0x70, 0x5f, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x13, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x48, 0x74, 0x74, 0x70, 0x45, 0x6e, 0x64, + 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x61, 0x75, 0x64, 0x69, 0x65, 0x6e, 0x63, + 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x61, 0x75, 0x64, 0x69, 0x65, 0x6e, 0x63, + 0x65, 0x32, 0xff, 0x01, 0x0a, 0x13, 0x41, 0x75, 0x74, 0x68, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x6d, 0x0a, 0x11, 0x47, 0x65, 0x74, + 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x28, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x2e, + 0x47, 0x65, 0x74, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x41, 0x75, + 0x74, 0x68, 0x32, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x79, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x50, + 0x75, 0x62, 0x6c, 0x69, 0x63, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x12, 0x2c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x75, + 0x74, 0x68, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x43, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x2d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x75, 0x74, 0x68, + 0x2e, 0x47, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, + 0x90, 0x02, 0x01, 0x42, 0xb3, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x42, 0x10, 0x41, 0x75, 0x74, 0x68, + 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x32, + 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, + 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x75, + 0x74, 0x68, 0xa2, 0x02, 0x03, 0x46, 0x41, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x41, 0x75, 0x74, 0x68, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x75, 0x74, 0x68, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x75, 0x74, 0x68, 0x5c, 0x47, 0x50, 0x42, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x41, 0x75, 0x74, 0x68, 0x4a, 0x92, 0x1f, 0x0a, 0x06, 0x12, 0x04, + 0x00, 0x00, 0x50, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, + 0x0a, 0x01, 0x02, 0x12, 0x03, 0x01, 0x00, 0x17, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x03, + 0x00, 0x49, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x03, 0x00, 0x49, 0x0a, 0x09, 0x0a, + 0x02, 0x04, 0x00, 0x12, 0x03, 0x05, 0x00, 0x23, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, + 0x03, 0x05, 0x08, 0x20, 0x0a, 0xaf, 0x01, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x09, 0x00, 0x2b, + 0x01, 0x1a, 0xa2, 0x01, 0x20, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x52, 0x46, 0x43, 0x2d, 0x43, 0x6f, 0x6d, 0x70, 0x6c, + 0x69, 0x61, 0x6e, 0x74, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x2f, 0x2e, 0x77, 0x65, 0x6c, 0x6c, 0x2d, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x2f, 0x6f, + 0x61, 0x75, 0x74, 0x68, 0x2d, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x2d, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x0a, 0x20, 0x61, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x69, + 0x6e, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x74, 0x6f, 0x6f, 0x6c, 0x73, 0x2e, + 0x69, 0x65, 0x74, 0x66, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x2f, 0x72, 0x66, + 0x63, 0x38, 0x34, 0x31, 0x34, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x09, + 0x08, 0x21, 0x0a, 0x85, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x0c, 0x02, 0x14, + 0x1a, 0x78, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, + 0x73, 0x73, 0x75, 0x65, 0x72, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x6e, 0x20, + 0x61, 0x6c, 0x6c, 0x20, 0x4a, 0x57, 0x54, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x69, 0x73, 0x73, 0x75, 0x65, + 0x73, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x69, 0x73, 0x73, 0x75, 0x65, 0x72, 0x20, 0x63, 0x61, + 0x6e, 0x20, 0x62, 0x65, 0x20, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x20, 0x69, 0x74, 0x73, 0x65, 0x6c, + 0x66, 0x20, 0x6f, 0x72, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, + 0x0a, 0x20, 0x69, 0x73, 0x73, 0x75, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x05, 0x12, 0x03, 0x0c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x0c, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x0c, 0x12, 0x13, 0x0a, 0xae, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x10, + 0x02, 0x24, 0x1a, 0xa0, 0x01, 0x20, 0x55, 0x52, 0x4c, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x27, 0x73, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x20, 0x5b, + 0x52, 0x46, 0x43, 0x36, 0x37, 0x34, 0x39, 0x5d, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, + 0x73, 0x20, 0x52, 0x45, 0x51, 0x55, 0x49, 0x52, 0x45, 0x44, 0x20, 0x75, 0x6e, 0x6c, 0x65, 0x73, + 0x73, 0x20, 0x6e, 0x6f, 0x20, 0x67, 0x72, 0x61, 0x6e, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, + 0x20, 0x61, 0x72, 0x65, 0x0a, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x75, 0x74, + 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x6e, 0x64, 0x70, 0x6f, + 0x69, 0x6e, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, + 0x10, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x10, 0x09, + 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x10, 0x22, 0x23, 0x0a, + 0x4a, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x13, 0x02, 0x1c, 0x1a, 0x3d, 0x20, 0x55, + 0x52, 0x4c, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, + 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x27, 0x73, + 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x20, + 0x5b, 0x52, 0x46, 0x43, 0x36, 0x37, 0x34, 0x39, 0x5d, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x02, 0x05, 0x12, 0x03, 0x13, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x13, 0x09, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x13, 0x1a, 0x1b, 0x0a, 0x75, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x03, 0x12, 0x03, 0x16, + 0x02, 0x2f, 0x1a, 0x68, 0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x20, 0x32, 0x2e, 0x30, 0x20, 0x72, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x75, 0x74, + 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x03, 0x04, 0x12, 0x03, 0x16, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x03, 0x05, 0x12, 0x03, 0x16, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, + 0x01, 0x12, 0x03, 0x16, 0x12, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x03, 0x12, + 0x03, 0x16, 0x2d, 0x2e, 0x0a, 0x7c, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x04, 0x12, 0x03, 0x19, 0x02, + 0x27, 0x1a, 0x6f, 0x20, 0x4a, 0x53, 0x4f, 0x4e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x63, + 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x20, 0x32, 0x2e, + 0x30, 0x20, 0x5b, 0x52, 0x46, 0x43, 0x36, 0x37, 0x34, 0x39, 0x5d, 0x20, 0x73, 0x63, 0x6f, 0x70, + 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x73, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x04, 0x12, 0x03, 0x19, 0x02, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x05, 0x12, 0x03, 0x19, 0x0b, 0x11, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x01, 0x12, 0x03, 0x19, 0x12, 0x22, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x04, 0x03, 0x12, 0x03, 0x19, 0x25, 0x26, 0x0a, 0x6e, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x05, 0x12, 0x03, 0x1c, 0x02, 0x3c, 0x1a, 0x61, 0x20, 0x4a, 0x53, 0x4f, 0x4e, 0x20, 0x61, + 0x72, 0x72, 0x61, 0x79, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, + 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x20, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, + 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x05, 0x04, 0x12, 0x03, 0x1c, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, + 0x05, 0x12, 0x03, 0x1c, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x01, 0x12, + 0x03, 0x1c, 0x12, 0x37, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x03, 0x12, 0x03, 0x1c, + 0x3a, 0x3b, 0x0a, 0xc4, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x06, 0x12, 0x03, 0x20, 0x02, 0x16, + 0x1a, 0xb6, 0x01, 0x20, 0x55, 0x52, 0x4c, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, + 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x27, 0x73, 0x20, 0x4a, 0x57, 0x4b, 0x20, 0x53, 0x65, 0x74, 0x20, 0x5b, 0x4a, + 0x57, 0x4b, 0x5d, 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x64, 0x20, 0x64, 0x6f, 0x63, + 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x6b, 0x65, 0x79, 0x28, 0x73, + 0x29, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x75, 0x73, + 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x20, 0x73, + 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x06, 0x05, 0x12, 0x03, 0x20, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x01, + 0x12, 0x03, 0x20, 0x09, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x03, 0x12, 0x03, + 0x20, 0x14, 0x15, 0x0a, 0x9c, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x07, 0x12, 0x03, 0x24, 0x02, + 0x37, 0x1a, 0x8e, 0x01, 0x20, 0x4a, 0x53, 0x4f, 0x4e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x73, + 0x74, 0x20, 0x6f, 0x66, 0x20, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x20, 0x4b, 0x65, 0x79, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x43, 0x6f, 0x64, 0x65, 0x20, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x20, 0x28, 0x50, 0x4b, 0x43, 0x45, 0x29, 0x20, 0x5b, 0x52, 0x46, 0x43, 0x37, 0x36, 0x33, 0x36, + 0x5d, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, + 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, + 0x65, 0x64, 0x20, 0x62, 0x79, 0x0a, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x75, 0x74, 0x68, + 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x04, 0x12, 0x03, 0x24, 0x02, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x05, 0x12, 0x03, 0x24, 0x0b, 0x11, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x01, 0x12, 0x03, 0x24, 0x12, 0x32, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x07, 0x03, 0x12, 0x03, 0x24, 0x35, 0x36, 0x0a, 0x77, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x08, 0x12, 0x03, 0x27, 0x02, 0x2c, 0x1a, 0x6a, 0x20, 0x4a, 0x53, 0x4f, 0x4e, 0x20, 0x61, + 0x72, 0x72, 0x61, 0x79, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, + 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4f, 0x41, + 0x75, 0x74, 0x68, 0x20, 0x32, 0x2e, 0x30, 0x20, 0x67, 0x72, 0x61, 0x6e, 0x74, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, + 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x08, 0x04, 0x12, 0x03, 0x27, 0x02, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x08, 0x05, 0x12, 0x03, 0x27, 0x0b, 0x11, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x08, 0x01, 0x12, 0x03, 0x27, 0x12, 0x27, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x08, 0x03, 0x12, 0x03, 0x27, 0x2a, 0x2b, 0x0a, 0x76, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x09, 0x12, 0x03, 0x2a, 0x02, 0x2c, 0x1a, 0x69, 0x20, 0x55, 0x52, 0x4c, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x27, 0x73, 0x20, 0x64, 0x65, 0x76, + 0x69, 0x63, 0x65, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x2c, 0x20, 0x61, 0x73, 0x20, 0x64, + 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x53, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x33, 0x2e, 0x31, 0x20, 0x6f, 0x66, 0x20, 0x5b, 0x52, 0x46, 0x43, 0x38, 0x36, 0x32, + 0x38, 0x5d, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x09, 0x05, 0x12, 0x03, 0x2a, 0x02, + 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x09, 0x01, 0x12, 0x03, 0x2a, 0x09, 0x26, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x09, 0x03, 0x12, 0x03, 0x2a, 0x29, 0x2b, 0x0a, 0x09, 0x0a, + 0x02, 0x04, 0x02, 0x12, 0x03, 0x2d, 0x00, 0x27, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, + 0x03, 0x2d, 0x08, 0x24, 0x0a, 0x82, 0x01, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x30, 0x00, 0x40, + 0x01, 0x1a, 0x76, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x65, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, + 0x61, 0x74, 0x65, 0x73, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x69, 0x6e, 0x66, 0x6f, + 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x28, 0x43, 0x4c, 0x49, 0x73, + 0x2e, 0x2e, 0x2e, 0x20, 0x65, 0x74, 0x63, 0x2e, 0x29, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x75, 0x73, + 0x65, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, + 0x65, 0x20, 0x75, 0x73, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, + 0x12, 0x03, 0x30, 0x08, 0x25, 0x0a, 0x4e, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x32, + 0x02, 0x17, 0x1a, 0x41, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x20, 0x74, + 0x6f, 0x20, 0x75, 0x73, 0x65, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x69, 0x6e, 0x69, 0x74, 0x69, + 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x20, 0x61, 0x75, 0x74, + 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x32, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x32, 0x09, + 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x32, 0x15, 0x16, 0x0a, + 0x51, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, 0x34, 0x02, 0x1a, 0x1a, 0x44, 0x20, 0x72, + 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x20, 0x75, 0x72, 0x69, 0x20, 0x74, 0x6f, 0x20, 0x75, + 0x73, 0x65, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x69, + 0x6e, 0x67, 0x20, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, + 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x05, 0x12, 0x03, 0x34, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, 0x34, 0x09, 0x15, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x34, 0x18, 0x19, 0x0a, 0x4f, 0x0a, 0x04, + 0x04, 0x03, 0x02, 0x02, 0x12, 0x03, 0x36, 0x02, 0x1d, 0x1a, 0x42, 0x20, 0x73, 0x63, 0x6f, 0x70, + 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x77, 0x68, + 0x65, 0x6e, 0x20, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x4f, 0x41, + 0x75, 0x74, 0x68, 0x32, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x02, 0x04, 0x12, 0x03, 0x36, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x02, 0x05, 0x12, 0x03, 0x36, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x36, 0x12, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x36, 0x1b, 0x1c, 0x0a, 0xa6, 0x01, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x03, 0x12, 0x03, + 0x39, 0x02, 0x28, 0x1a, 0x98, 0x01, 0x20, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x75, + 0x73, 0x65, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x70, 0x61, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x20, + 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x20, 0x74, 0x6f, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x20, 0x49, 0x66, 0x20, + 0x6e, 0x6f, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2c, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, + 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, + 0x20, 0x68, 0x74, 0x74, 0x70, 0x20, 0x60, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x60, 0x20, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x05, 0x12, 0x03, 0x39, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x03, 0x01, 0x12, 0x03, 0x39, 0x09, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x03, 0x03, 0x12, 0x03, 0x39, 0x26, 0x27, 0x0a, 0x89, 0x02, 0x0a, 0x04, 0x04, 0x03, 0x02, + 0x04, 0x12, 0x03, 0x3d, 0x02, 0x23, 0x1a, 0xfb, 0x01, 0x20, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x48, 0x74, 0x74, 0x70, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x20, 0x70, 0x6f, + 0x69, 0x6e, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x68, 0x74, 0x74, 0x70, + 0x20, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x65, 0x6d, + 0x70, 0x74, 0x79, 0x2c, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x63, 0x61, 0x6e, + 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x64, 0x70, + 0x6f, 0x69, 0x6e, 0x74, 0x20, 0x75, 0x73, 0x65, 0x64, 0x0a, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6f, + 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x52, 0x50, 0x43, + 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x61, 0x6e, 0x20, + 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x68, 0x74, 0x74, 0x70, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, + 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, + 0x20, 0x66, 0x6c, 0x61, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x68, 0x6f, 0x6f, 0x73, 0x65, 0x20, + 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x0a, 0x20, 0x53, 0x53, 0x4c, 0x20, 0x6f, 0x72, 0x20, + 0x6e, 0x6f, 0x20, 0x53, 0x53, 0x4c, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x05, 0x12, 0x03, 0x3d, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x01, 0x12, 0x03, 0x3d, 0x09, 0x1e, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x03, 0x12, 0x03, 0x3d, 0x21, 0x22, 0x0a, 0x4d, + 0x0a, 0x04, 0x04, 0x03, 0x02, 0x05, 0x12, 0x03, 0x3f, 0x02, 0x16, 0x1a, 0x40, 0x20, 0x61, 0x75, + 0x64, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x20, 0x77, 0x68, + 0x65, 0x6e, 0x20, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x4f, 0x41, + 0x75, 0x74, 0x68, 0x32, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x05, 0x05, 0x12, 0x03, 0x3f, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x05, 0x01, 0x12, 0x03, 0x3f, 0x09, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x05, 0x03, 0x12, 0x03, 0x3f, 0x14, 0x15, 0x0a, 0xa2, 0x02, 0x0a, 0x02, 0x06, 0x00, 0x12, 0x04, + 0x45, 0x00, 0x50, 0x01, 0x1a, 0x95, 0x02, 0x20, 0x54, 0x68, 0x65, 0x20, 0x66, 0x6f, 0x6c, 0x6c, + 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x61, 0x6e, + 0x20, 0x52, 0x50, 0x43, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, + 0x20, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x48, 0x54, 0x54, 0x50, 0x20, 0x76, 0x69, 0x61, 0x20, 0x67, + 0x72, 0x70, 0x63, 0x2d, 0x67, 0x61, 0x74, 0x65, 0x77, 0x61, 0x79, 0x2e, 0x0a, 0x20, 0x53, 0x74, + 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, + 0x63, 0x6f, 0x64, 0x65, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6f, 0x74, 0x68, 0x20, 0x61, + 0x72, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x68, 0x65, 0x72, 0x65, 0x3a, + 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x72, 0x70, 0x63, 0x2d, 0x65, 0x63, 0x6f, 0x73, 0x79, 0x73, 0x74, + 0x65, 0x6d, 0x2f, 0x67, 0x72, 0x70, 0x63, 0x2d, 0x67, 0x61, 0x74, 0x65, 0x77, 0x61, 0x79, 0x2f, + 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x2f, 0x72, 0x75, 0x6e, 0x74, + 0x69, 0x6d, 0x65, 0x2f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x2e, 0x67, 0x6f, 0x0a, 0x20, 0x52, + 0x50, 0x43, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x61, 0x6e, 0x6f, 0x6e, 0x79, 0x6d, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x20, + 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x06, 0x00, 0x01, 0x12, 0x03, 0x45, 0x08, 0x1b, 0x0a, 0x68, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x00, + 0x12, 0x04, 0x47, 0x02, 0x49, 0x03, 0x1a, 0x5a, 0x20, 0x41, 0x6e, 0x6f, 0x6e, 0x79, 0x6d, 0x6f, + 0x75, 0x73, 0x6c, 0x79, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x2e, + 0x20, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x73, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, + 0x20, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x6f, 0x61, 0x75, + 0x74, 0x68, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x47, 0x06, 0x17, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x47, 0x18, 0x30, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x47, 0x3b, 0x54, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x00, 0x04, 0x12, 0x03, 0x48, 0x04, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, 0x06, 0x00, + 0x02, 0x00, 0x04, 0x22, 0x12, 0x03, 0x48, 0x04, 0x2f, 0x0a, 0x8b, 0x01, 0x0a, 0x04, 0x06, 0x00, + 0x02, 0x01, 0x12, 0x04, 0x4d, 0x02, 0x4f, 0x03, 0x1a, 0x7d, 0x20, 0x41, 0x6e, 0x6f, 0x6e, 0x79, + 0x6d, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c, + 0x65, 0x2e, 0x20, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x20, 0x75, 0x73, 0x65, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x69, 0x6e, 0x69, 0x74, + 0x69, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x20, 0x61, 0x75, + 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x72, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x4d, 0x06, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, + 0x4d, 0x1c, 0x38, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x4d, 0x43, + 0x60, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x04, 0x12, 0x03, 0x4e, 0x04, 0x2f, 0x0a, + 0x0d, 0x0a, 0x06, 0x06, 0x00, 0x02, 0x01, 0x04, 0x22, 0x12, 0x03, 0x4e, 0x04, 0x2f, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0x90, 0x0f, 0x0a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x11, 0x0a, 0x0f, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, + 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xa5, 0x02, 0x0a, 0x10, 0x55, 0x73, + 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, + 0x0a, 0x07, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x07, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2d, 0x0a, 0x12, + 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x5f, 0x75, 0x73, 0x65, 0x72, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, + 0x72, 0x65, 0x64, 0x55, 0x73, 0x65, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x67, + 0x69, 0x76, 0x65, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x09, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, + 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0a, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, + 0x6d, 0x61, 0x69, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x6d, 0x61, 0x69, + 0x6c, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x69, 0x63, 0x74, 0x75, 0x72, 0x65, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x07, 0x70, 0x69, 0x63, 0x74, 0x75, 0x72, 0x65, 0x12, 0x44, 0x0a, 0x11, 0x61, + 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x73, + 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, + 0x10, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x43, 0x6c, 0x61, 0x69, 0x6d, + 0x73, 0x32, 0x62, 0x0a, 0x0f, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x53, 0x65, 0x72, + 0x76, 0x69, 0x63, 0x65, 0x12, 0x4f, 0x0a, 0x08, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, + 0x12, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x75, 0x74, + 0x68, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x75, + 0x74, 0x68, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0xb0, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x42, 0x0d, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x32, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, + 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, + 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x61, 0x75, 0x74, + 0x68, 0xa2, 0x02, 0x03, 0x46, 0x41, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x41, 0x75, 0x74, 0x68, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x75, 0x74, 0x68, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x41, 0x75, 0x74, 0x68, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x3a, 0x3a, 0x41, 0x75, 0x74, 0x68, 0x4a, 0xe6, 0x09, 0x0a, 0x06, 0x12, 0x04, 0x00, + 0x00, 0x29, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, + 0x01, 0x02, 0x12, 0x03, 0x01, 0x00, 0x17, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x03, + 0x00, 0x26, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x05, 0x00, 0x49, 0x0a, 0x09, 0x0a, 0x02, + 0x08, 0x0b, 0x12, 0x03, 0x05, 0x00, 0x49, 0x0a, 0x09, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x03, 0x07, + 0x00, 0x1a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x07, 0x08, 0x17, 0x0a, 0x89, + 0x01, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x0a, 0x00, 0x23, 0x01, 0x1a, 0x7d, 0x20, 0x53, 0x65, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4f, 0x70, 0x65, 0x6e, 0x49, 0x44, 0x20, 0x43, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x20, 0x61, 0x74, 0x20, 0x68, 0x74, 0x74, + 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x6f, 0x70, 0x65, 0x6e, 0x69, 0x64, 0x2e, 0x6e, 0x65, 0x74, 0x2f, + 0x73, 0x70, 0x65, 0x63, 0x73, 0x2f, 0x6f, 0x70, 0x65, 0x6e, 0x69, 0x64, 0x2d, 0x63, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x2d, 0x63, 0x6f, 0x72, 0x65, 0x2d, 0x31, 0x5f, 0x30, 0x2e, 0x68, 0x74, + 0x6d, 0x6c, 0x23, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x69, 0x6e, 0x66, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, + 0x01, 0x12, 0x03, 0x0a, 0x08, 0x18, 0x0a, 0x93, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, + 0x03, 0x0d, 0x02, 0x15, 0x1a, 0x85, 0x01, 0x20, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, + 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6e, 0x65, 0x76, 0x65, 0x72, + 0x20, 0x72, 0x65, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x49, 0x73, 0x73, 0x75, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x45, 0x6e, 0x64, 0x2d, 0x55, 0x73, 0x65, 0x72, 0x2c, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, + 0x20, 0x69, 0x73, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x62, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x64, 0x0a, 0x20, 0x62, 0x79, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x0d, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x0d, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x0d, 0x13, 0x14, 0x0a, 0x18, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, + 0x10, 0x02, 0x12, 0x1a, 0x0b, 0x20, 0x46, 0x75, 0x6c, 0x6c, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, 0x10, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x10, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x10, 0x10, 0x11, 0x0a, 0x4c, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x02, 0x12, 0x03, 0x13, 0x02, 0x20, 0x1a, 0x3f, 0x20, 0x53, 0x68, 0x6f, 0x72, 0x74, 0x68, + 0x61, 0x6e, 0x64, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x62, 0x79, 0x20, 0x77, 0x68, 0x69, 0x63, + 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x45, 0x6e, 0x64, 0x2d, 0x55, 0x73, 0x65, 0x72, 0x20, 0x77, + 0x69, 0x73, 0x68, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x66, 0x65, + 0x72, 0x72, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, + 0x05, 0x12, 0x03, 0x13, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x13, 0x09, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x13, + 0x1e, 0x1f, 0x0a, 0x2d, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x03, 0x12, 0x03, 0x16, 0x02, 0x18, 0x1a, + 0x20, 0x20, 0x47, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x28, 0x73, 0x29, 0x20, + 0x6f, 0x72, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x28, 0x73, 0x29, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x05, 0x12, 0x03, 0x16, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x01, 0x12, 0x03, 0x16, 0x09, 0x13, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x03, 0x03, 0x12, 0x03, 0x16, 0x16, 0x17, 0x0a, 0x29, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x04, 0x12, 0x03, 0x19, 0x02, 0x19, 0x1a, 0x1c, 0x20, 0x53, 0x75, 0x72, 0x6e, 0x61, + 0x6d, 0x65, 0x28, 0x73, 0x29, 0x20, 0x6f, 0x72, 0x20, 0x6c, 0x61, 0x73, 0x74, 0x20, 0x6e, 0x61, + 0x6d, 0x65, 0x28, 0x73, 0x29, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x05, 0x12, + 0x03, 0x19, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x01, 0x12, 0x03, 0x19, + 0x09, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x03, 0x12, 0x03, 0x19, 0x17, 0x18, + 0x0a, 0x27, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x05, 0x12, 0x03, 0x1c, 0x02, 0x13, 0x1a, 0x1a, 0x20, + 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x20, 0x65, 0x2d, 0x6d, 0x61, 0x69, 0x6c, + 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x05, 0x05, 0x12, 0x03, 0x1c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x01, + 0x12, 0x03, 0x1c, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x03, 0x12, 0x03, + 0x1c, 0x11, 0x12, 0x0a, 0x22, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x06, 0x12, 0x03, 0x1f, 0x02, 0x15, + 0x1a, 0x15, 0x20, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x70, 0x69, 0x63, 0x74, 0x75, + 0x72, 0x65, 0x20, 0x55, 0x52, 0x4c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x05, + 0x12, 0x03, 0x1f, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x01, 0x12, 0x03, + 0x1f, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x03, 0x12, 0x03, 0x1f, 0x13, + 0x14, 0x0a, 0x20, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x07, 0x12, 0x03, 0x22, 0x02, 0x2f, 0x1a, 0x13, + 0x20, 0x41, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x63, 0x6c, 0x61, 0x69, + 0x6d, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x06, 0x12, 0x03, 0x22, 0x02, + 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x01, 0x12, 0x03, 0x22, 0x19, 0x2a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x03, 0x12, 0x03, 0x22, 0x2d, 0x2e, 0x0a, 0x5d, 0x0a, + 0x02, 0x06, 0x00, 0x12, 0x04, 0x26, 0x00, 0x29, 0x01, 0x1a, 0x51, 0x20, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x52, 0x50, 0x43, 0x20, 0x53, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x61, 0x63, 0x74, + 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x75, 0x73, 0x65, 0x72, 0x2f, 0x61, 0x70, 0x70, 0x20, + 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x06, 0x00, 0x01, 0x12, 0x03, 0x26, 0x08, 0x17, 0x0a, 0x4d, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x00, + 0x12, 0x03, 0x28, 0x02, 0x3d, 0x1a, 0x40, 0x20, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, + 0x73, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x20, 0x6c, 0x6f, 0x67, 0x67, 0x65, 0x64, 0x20, 0x69, 0x6e, + 0x20, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x28, 0x06, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, + 0x28, 0x0f, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x28, 0x29, + 0x39, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +]; +include!("flyteidl2.auth.tonic.rs"); +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/flyteidl2.auth.tonic.rs b/gen/rust/src/flyteidl2.auth.tonic.rs new file mode 100644 index 0000000000..b022964d9e --- /dev/null +++ b/gen/rust/src/flyteidl2.auth.tonic.rs @@ -0,0 +1,687 @@ +// @generated +/// Generated client implementations. +pub mod auth_metadata_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + /** The following defines an RPC service that is also served over HTTP via grpc-gateway. + Standard response codes for both are defined here: https://github.com/grpc-ecosystem/grpc-gateway/blob/master/runtime/errors.go + RPCs defined in this service must be anonymously accessible. +*/ + #[derive(Debug, Clone)] + pub struct AuthMetadataServiceClient { + inner: tonic::client::Grpc, + } + impl AuthMetadataServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl AuthMetadataServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> AuthMetadataServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + AuthMetadataServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /** Anonymously accessible. Retrieves local or external oauth authorization server metadata. +*/ + pub async fn get_o_auth2_metadata( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.auth.AuthMetadataService/GetOAuth2Metadata", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.auth.AuthMetadataService", + "GetOAuth2Metadata", + ), + ); + self.inner.unary(req, path, codec).await + } + /** Anonymously accessible. Retrieves the client information clients should use when initiating OAuth2 authorization + requests. +*/ + pub async fn get_public_client_config( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.auth.AuthMetadataService/GetPublicClientConfig", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.auth.AuthMetadataService", + "GetPublicClientConfig", + ), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod auth_metadata_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with AuthMetadataServiceServer. + #[async_trait] + pub trait AuthMetadataService: Send + Sync + 'static { + /** Anonymously accessible. Retrieves local or external oauth authorization server metadata. +*/ + async fn get_o_auth2_metadata( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /** Anonymously accessible. Retrieves the client information clients should use when initiating OAuth2 authorization + requests. +*/ + async fn get_public_client_config( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + /** The following defines an RPC service that is also served over HTTP via grpc-gateway. + Standard response codes for both are defined here: https://github.com/grpc-ecosystem/grpc-gateway/blob/master/runtime/errors.go + RPCs defined in this service must be anonymously accessible. +*/ + #[derive(Debug)] + pub struct AuthMetadataServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl AuthMetadataServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for AuthMetadataServiceServer + where + T: AuthMetadataService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.auth.AuthMetadataService/GetOAuth2Metadata" => { + #[allow(non_camel_case_types)] + struct GetOAuth2MetadataSvc(pub Arc); + impl< + T: AuthMetadataService, + > tonic::server::UnaryService + for GetOAuth2MetadataSvc { + type Response = super::GetOAuth2MetadataResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_o_auth2_metadata( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetOAuth2MetadataSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.auth.AuthMetadataService/GetPublicClientConfig" => { + #[allow(non_camel_case_types)] + struct GetPublicClientConfigSvc(pub Arc); + impl< + T: AuthMetadataService, + > tonic::server::UnaryService + for GetPublicClientConfigSvc { + type Response = super::GetPublicClientConfigResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_public_client_config( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetPublicClientConfigSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for AuthMetadataServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService + for AuthMetadataServiceServer { + const NAME: &'static str = "flyteidl2.auth.AuthMetadataService"; + } +} +/// Generated client implementations. +pub mod identity_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + /** IdentityService defines an RPC Service that interacts with user/app identities. +*/ + #[derive(Debug, Clone)] + pub struct IdentityServiceClient { + inner: tonic::client::Grpc, + } + impl IdentityServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl IdentityServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> IdentityServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + IdentityServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /** Retrieves user information about the currently logged in user. +*/ + pub async fn user_info( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.auth.IdentityService/UserInfo", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.auth.IdentityService", "UserInfo")); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod identity_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with IdentityServiceServer. + #[async_trait] + pub trait IdentityService: Send + Sync + 'static { + /** Retrieves user information about the currently logged in user. +*/ + async fn user_info( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + /** IdentityService defines an RPC Service that interacts with user/app identities. +*/ + #[derive(Debug)] + pub struct IdentityServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl IdentityServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for IdentityServiceServer + where + T: IdentityService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.auth.IdentityService/UserInfo" => { + #[allow(non_camel_case_types)] + struct UserInfoSvc(pub Arc); + impl< + T: IdentityService, + > tonic::server::UnaryService + for UserInfoSvc { + type Response = super::UserInfoResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::user_info(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = UserInfoSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for IdentityServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService for IdentityServiceServer { + const NAME: &'static str = "flyteidl2.auth.IdentityService"; + } +} diff --git a/gen/rust/src/flyteidl2.cacheservice.rs b/gen/rust/src/flyteidl2.cacheservice.rs new file mode 100644 index 0000000000..a253cb31e9 --- /dev/null +++ b/gen/rust/src/flyteidl2.cacheservice.rs @@ -0,0 +1,657 @@ +// @generated +// This file is @generated by prost-build. +/// +/// Additional metadata as key-value pairs +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct KeyMapMetadata { + /// Additional metadata as key-value pairs + #[prost(map="string, string", tag="1")] + pub values: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, +} +/// +/// Metadata for cached outputs, including the source identifier and timestamps. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Metadata { + /// Source task or workflow identifier + #[prost(message, optional, tag="1")] + pub source_identifier: ::core::option::Option, + /// Additional metadata as key-value pairs + #[prost(message, optional, tag="2")] + pub key_map: ::core::option::Option, + /// Creation timestamp + #[prost(message, optional, tag="3")] + pub created_at: ::core::option::Option, + /// Last update timestamp + #[prost(message, optional, tag="4")] + pub last_updated_at: ::core::option::Option, +} +/// +/// Represents cached output, either as literals or an URI, with associated metadata. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CachedOutput { + /// Associated metadata + #[prost(message, optional, tag="3")] + pub metadata: ::core::option::Option, + #[prost(oneof="cached_output::Output", tags="1, 2")] + pub output: ::core::option::Option, +} +/// Nested message and enum types in `CachedOutput`. +pub mod cached_output { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Output { + /// Output literals + #[prost(message, tag="1")] + OutputLiterals(super::super::core::LiteralMap), + /// URI to output data + #[prost(string, tag="2")] + OutputUri(::prost::alloc::string::String), + } +} +/// +/// Request to retrieve cached data by key. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetCacheRequest { + /// Cache key + #[prost(string, tag="1")] + pub key: ::prost::alloc::string::String, +} +/// +/// Response with cached data for a given key. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetCacheResponse { + /// Cached output + #[prost(message, optional, tag="1")] + pub output: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct OverwriteOutput { + /// Overwrite flag + #[prost(bool, tag="1")] + pub overwrite: bool, + /// Delete existing blob + #[prost(bool, tag="2")] + pub delete_blob: bool, + /// Maximum age of the cached output since last update + #[prost(message, optional, tag="3")] + pub max_age: ::core::option::Option, +} +/// +/// Request to store/update cached data by key. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PutCacheRequest { + /// Cache key + #[prost(string, tag="1")] + pub key: ::prost::alloc::string::String, + /// Output to cache + #[prost(message, optional, tag="2")] + pub output: ::core::option::Option, + /// Overwrite flag if exists + #[prost(message, optional, tag="3")] + pub overwrite: ::core::option::Option, +} +/// +/// Response message of cache store/update operation. +/// +/// Empty, success indicated by no errors +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct PutCacheResponse { +} +/// +/// Request to delete cached data by key. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DeleteCacheRequest { + /// Cache key + #[prost(string, tag="1")] + pub key: ::prost::alloc::string::String, +} +/// +/// Response message of cache deletion operation. +/// +/// Empty, success indicated by no errors +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct DeleteCacheResponse { +} +/// A reservation including owner, heartbeat interval, expiration timestamp, and various metadata. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Reservation { + /// The unique ID for the reservation - same as the cache key + #[prost(string, tag="1")] + pub key: ::prost::alloc::string::String, + /// The unique ID of the owner for the reservation + #[prost(string, tag="2")] + pub owner_id: ::prost::alloc::string::String, + /// Requested reservation extension heartbeat interval + #[prost(message, optional, tag="3")] + pub heartbeat_interval: ::core::option::Option, + /// Expiration timestamp of this reservation + #[prost(message, optional, tag="4")] + pub expires_at: ::core::option::Option, +} +/// +/// Request to get or extend a reservation for a cache key +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetOrExtendReservationRequest { + /// The unique ID for the reservation - same as the cache key + #[prost(string, tag="1")] + pub key: ::prost::alloc::string::String, + /// The unique ID of the owner for the reservation + #[prost(string, tag="2")] + pub owner_id: ::prost::alloc::string::String, + /// Requested reservation extension heartbeat interval + #[prost(message, optional, tag="3")] + pub heartbeat_interval: ::core::option::Option, +} +/// +/// Request to get or extend a reservation for a cache key +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetOrExtendReservationResponse { + /// The reservation that was created or extended + #[prost(message, optional, tag="1")] + pub reservation: ::core::option::Option, +} +/// +/// Request to release the reservation for a cache key +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ReleaseReservationRequest { + /// The unique ID for the reservation - same as the cache key + #[prost(string, tag="1")] + pub key: ::prost::alloc::string::String, + /// The unique ID of the owner for the reservation + #[prost(string, tag="2")] + pub owner_id: ::prost::alloc::string::String, +} +/// +/// Response message of release reservation operation. +/// +/// Empty, success indicated by no errors +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct ReleaseReservationResponse { +} +/// Encoded file descriptor set for the `flyteidl2.cacheservice` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xac, 0x38, 0x0a, 0x29, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, + 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2f, 0x63, 0x61, 0x63, 0x68, + 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x16, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x1a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x97, 0x01, 0x0a, 0x0e, 0x4b, 0x65, 0x79, 0x4d, + 0x61, 0x70, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x4a, 0x0a, 0x06, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x2e, 0x4b, 0x65, 0x79, 0x4d, 0x61, 0x70, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x1a, 0x39, 0x0a, 0x0b, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, + 0x01, 0x22, 0x93, 0x02, 0x0a, 0x08, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x47, + 0x0a, 0x11, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x3f, 0x0a, 0x07, 0x6b, 0x65, 0x79, 0x5f, 0x6d, + 0x61, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x2e, 0x4b, 0x65, 0x79, 0x4d, 0x61, 0x70, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x52, 0x06, 0x6b, 0x65, 0x79, 0x4d, 0x61, 0x70, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x64, 0x41, 0x74, 0x12, 0x42, 0x0a, 0x0f, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x22, 0xbe, 0x01, 0x0a, 0x0c, 0x43, 0x61, 0x63, 0x68, + 0x65, 0x64, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x45, 0x0a, 0x0f, 0x6f, 0x75, 0x74, 0x70, + 0x75, 0x74, 0x5f, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, 0x70, 0x48, 0x00, 0x52, + 0x0e, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x12, + 0x1f, 0x0a, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x09, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x55, 0x72, 0x69, + 0x12, 0x3c, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x4d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x42, 0x08, + 0x0a, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x22, 0x23, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x43, + 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, + 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x22, 0x50, 0x0a, + 0x10, 0x47, 0x65, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x3c, 0x0a, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, + 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x43, 0x61, 0x63, 0x68, 0x65, + 0x64, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x52, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x22, + 0x84, 0x01, 0x0a, 0x0f, 0x4f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x4f, 0x75, 0x74, + 0x70, 0x75, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, + 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x5f, 0x62, 0x6c, 0x6f, 0x62, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x42, 0x6c, + 0x6f, 0x62, 0x12, 0x32, 0x0a, 0x07, 0x6d, 0x61, 0x78, 0x5f, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x06, + 0x6d, 0x61, 0x78, 0x41, 0x67, 0x65, 0x22, 0xa8, 0x01, 0x0a, 0x0f, 0x50, 0x75, 0x74, 0x43, 0x61, + 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, + 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x3c, 0x0a, 0x06, + 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x43, 0x61, 0x63, 0x68, 0x65, 0x64, 0x4f, 0x75, 0x74, 0x70, + 0x75, 0x74, 0x52, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x45, 0x0a, 0x09, 0x6f, 0x76, + 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x4f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, + 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x52, 0x09, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, + 0x65, 0x22, 0x12, 0x0a, 0x10, 0x50, 0x75, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x0a, 0x12, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, + 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, + 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x22, 0x15, 0x0a, + 0x13, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xbf, 0x01, 0x0a, 0x0b, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x5f, + 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x49, + 0x64, 0x12, 0x48, 0x0a, 0x12, 0x68, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, 0x5f, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x11, 0x68, 0x65, 0x61, 0x72, 0x74, 0x62, + 0x65, 0x61, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x39, 0x0a, 0x0a, 0x65, + 0x78, 0x70, 0x69, 0x72, 0x65, 0x73, 0x5f, 0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x65, 0x78, 0x70, + 0x69, 0x72, 0x65, 0x73, 0x41, 0x74, 0x22, 0x96, 0x01, 0x0a, 0x1d, 0x47, 0x65, 0x74, 0x4f, 0x72, + 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x77, + 0x6e, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x77, + 0x6e, 0x65, 0x72, 0x49, 0x64, 0x12, 0x48, 0x0a, 0x12, 0x68, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, + 0x61, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x11, 0x68, 0x65, + 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x22, + 0x67, 0x0a, 0x1e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x52, 0x65, + 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x45, 0x0a, 0x0b, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, + 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x72, 0x65, 0x73, + 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x48, 0x0a, 0x19, 0x52, 0x65, 0x6c, 0x65, + 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x77, 0x6e, 0x65, 0x72, + 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x77, 0x6e, 0x65, 0x72, + 0x49, 0x64, 0x22, 0x1c, 0x0a, 0x1a, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, + 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x32, 0xac, 0x04, 0x0a, 0x0c, 0x43, 0x61, 0x63, 0x68, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x12, 0x58, 0x0a, 0x03, 0x47, 0x65, 0x74, 0x12, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, + 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x61, + 0x63, 0x68, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x03, 0x50, + 0x75, 0x74, 0x12, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x50, 0x75, 0x74, 0x43, + 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, + 0x76, 0x69, 0x63, 0x65, 0x2e, 0x50, 0x75, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x61, 0x0a, 0x06, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, + 0x2a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, + 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, + 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, + 0x76, 0x69, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x61, 0x63, 0x68, 0x65, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x87, 0x01, 0x0a, 0x16, 0x47, 0x65, 0x74, + 0x4f, 0x72, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x35, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x47, 0x65, 0x74, + 0x4f, 0x72, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x36, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x52, + 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x7b, 0x0a, 0x12, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, + 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x31, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x2e, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, + 0x76, 0x69, 0x63, 0x65, 0x2e, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x65, + 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, + 0xe4, 0x01, 0x0a, 0x1a, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x42, 0x11, + 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, + 0x6f, 0x50, 0x01, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, + 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0xa2, + 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x16, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0xca, 0x02, + 0x16, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x61, 0x63, 0x68, 0x65, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0xe2, 0x02, 0x22, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x17, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4a, 0xae, 0x23, 0x0a, 0x07, 0x12, 0x05, 0x00, 0x00, 0x92, + 0x01, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, + 0x02, 0x12, 0x03, 0x02, 0x00, 0x1f, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, + 0x29, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x27, 0x0a, 0x09, 0x0a, 0x02, + 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, 0x28, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x03, 0x12, 0x03, 0x07, + 0x00, 0x29, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x09, 0x00, 0x51, 0x0a, 0x09, 0x0a, 0x02, + 0x08, 0x0b, 0x12, 0x03, 0x09, 0x00, 0x51, 0x0a, 0x90, 0x01, 0x0a, 0x02, 0x06, 0x00, 0x12, 0x04, + 0x0e, 0x00, 0x1d, 0x01, 0x1a, 0x83, 0x01, 0x0a, 0x20, 0x43, 0x61, 0x63, 0x68, 0x65, 0x53, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x6f, 0x70, + 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x63, 0x61, 0x63, + 0x68, 0x65, 0x20, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x6e, + 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x61, + 0x6c, 0x2c, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, + 0x64, 0x65, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x63, 0x61, 0x63, 0x68, + 0x65, 0x64, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x06, 0x00, + 0x01, 0x12, 0x03, 0x0e, 0x08, 0x14, 0x0a, 0x2c, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x00, 0x12, 0x03, + 0x10, 0x02, 0x36, 0x1a, 0x1f, 0x20, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x73, 0x20, + 0x63, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, 0x79, 0x20, 0x6b, + 0x65, 0x79, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x10, + 0x06, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x10, 0x0a, 0x19, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x10, 0x24, 0x34, 0x0a, 0x34, + 0x0a, 0x04, 0x06, 0x00, 0x02, 0x01, 0x12, 0x03, 0x13, 0x02, 0x36, 0x1a, 0x27, 0x20, 0x53, 0x74, + 0x6f, 0x72, 0x65, 0x73, 0x20, 0x6f, 0x72, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x20, + 0x63, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, 0x79, 0x20, 0x6b, + 0x65, 0x79, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x13, + 0x06, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x13, 0x0a, 0x19, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x13, 0x24, 0x34, 0x0a, 0x2a, + 0x0a, 0x04, 0x06, 0x00, 0x02, 0x02, 0x12, 0x03, 0x16, 0x02, 0x3f, 0x1a, 0x1d, 0x20, 0x44, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x73, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x62, 0x79, 0x20, 0x6b, 0x65, 0x79, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x16, 0x06, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, + 0x02, 0x12, 0x03, 0x16, 0x0d, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x03, 0x12, + 0x03, 0x16, 0x2a, 0x3d, 0x0a, 0x3a, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x03, 0x12, 0x03, 0x19, 0x02, + 0x65, 0x1a, 0x2d, 0x20, 0x47, 0x65, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, + 0x64, 0x20, 0x61, 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x19, 0x06, 0x1c, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x19, 0x1d, 0x3a, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x19, 0x45, 0x63, 0x0a, 0x36, 0x0a, 0x04, 0x06, 0x00, + 0x02, 0x04, 0x12, 0x03, 0x1c, 0x02, 0x59, 0x1a, 0x29, 0x20, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6b, 0x65, + 0x79, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x1c, 0x06, 0x18, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, 0x1c, 0x19, 0x32, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, 0x1c, 0x3d, 0x57, 0x0a, 0x35, 0x0a, 0x02, + 0x04, 0x00, 0x12, 0x04, 0x22, 0x00, 0x24, 0x01, 0x1a, 0x29, 0x0a, 0x20, 0x41, 0x64, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, + 0x61, 0x73, 0x20, 0x6b, 0x65, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x70, 0x61, 0x69, + 0x72, 0x73, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x22, 0x08, 0x16, 0x0a, + 0x35, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x23, 0x02, 0x21, 0x22, 0x28, 0x20, 0x41, + 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x20, 0x61, 0x73, 0x20, 0x6b, 0x65, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, + 0x70, 0x61, 0x69, 0x72, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x23, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x23, + 0x16, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x23, 0x1f, 0x20, + 0x0a, 0x5b, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x29, 0x00, 0x2e, 0x01, 0x1a, 0x4f, 0x0a, 0x20, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x63, 0x61, 0x63, + 0x68, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x2c, 0x20, 0x69, 0x6e, 0x63, + 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x61, 0x6e, 0x64, + 0x20, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x29, 0x08, 0x10, 0x0a, 0x31, 0x0a, 0x04, 0x04, 0x01, 0x02, + 0x00, 0x12, 0x03, 0x2a, 0x02, 0x28, 0x22, 0x24, 0x20, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, + 0x74, 0x61, 0x73, 0x6b, 0x20, 0x6f, 0x72, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x2a, 0x02, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x2a, 0x12, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x2a, 0x26, 0x27, 0x0a, 0x35, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, + 0x2b, 0x02, 0x1d, 0x22, 0x28, 0x20, 0x41, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x61, 0x73, 0x20, 0x6b, 0x65, 0x79, + 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x70, 0x61, 0x69, 0x72, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x01, 0x06, 0x12, 0x03, 0x2b, 0x02, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x2b, 0x11, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x01, 0x03, 0x12, 0x03, 0x2b, 0x1b, 0x1c, 0x0a, 0x21, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, + 0x03, 0x2c, 0x02, 0x2b, 0x22, 0x14, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x02, 0x06, 0x12, 0x03, 0x2c, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, + 0x01, 0x12, 0x03, 0x2c, 0x1c, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, + 0x03, 0x2c, 0x29, 0x2a, 0x0a, 0x24, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x03, 0x12, 0x03, 0x2d, 0x02, + 0x30, 0x22, 0x17, 0x20, 0x4c, 0x61, 0x73, 0x74, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x20, + 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x03, 0x06, 0x12, 0x03, 0x2d, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, + 0x01, 0x12, 0x03, 0x2d, 0x1c, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x03, 0x12, + 0x03, 0x2d, 0x2e, 0x2f, 0x0a, 0x60, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x33, 0x00, 0x39, 0x01, + 0x1a, 0x54, 0x0a, 0x20, 0x52, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x63, + 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2c, 0x20, 0x65, 0x69, + 0x74, 0x68, 0x65, 0x72, 0x20, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, + 0x20, 0x6f, 0x72, 0x20, 0x61, 0x6e, 0x20, 0x55, 0x52, 0x49, 0x2c, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x33, + 0x08, 0x14, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x02, 0x08, 0x00, 0x12, 0x04, 0x34, 0x02, 0x37, 0x03, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x08, 0x00, 0x01, 0x12, 0x03, 0x34, 0x08, 0x0e, 0x0a, 0x1e, + 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x35, 0x04, 0x32, 0x22, 0x11, 0x20, 0x4f, 0x75, + 0x74, 0x70, 0x75, 0x74, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, 0x03, 0x35, 0x04, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x35, 0x1e, 0x2d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x35, 0x30, 0x31, 0x0a, 0x21, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x36, 0x04, 0x1a, 0x22, 0x14, 0x20, 0x55, 0x52, 0x49, 0x20, 0x74, 0x6f, 0x20, 0x6f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x01, 0x05, 0x12, 0x03, 0x36, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x36, 0x0b, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x36, 0x18, 0x19, 0x0a, 0x22, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x02, 0x12, 0x03, 0x38, + 0x02, 0x18, 0x22, 0x15, 0x20, 0x41, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x02, 0x06, 0x12, 0x03, 0x38, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x38, 0x0b, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x03, 0x12, 0x03, + 0x38, 0x16, 0x17, 0x0a, 0x36, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x3e, 0x00, 0x40, 0x01, 0x1a, + 0x2a, 0x0a, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, + 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x64, 0x61, + 0x74, 0x61, 0x20, 0x62, 0x79, 0x20, 0x6b, 0x65, 0x79, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x03, 0x01, 0x12, 0x03, 0x3e, 0x08, 0x17, 0x0a, 0x18, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, + 0x03, 0x3f, 0x02, 0x11, 0x22, 0x0b, 0x20, 0x43, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x05, 0x12, 0x03, 0x3f, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x3f, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x3f, 0x0f, 0x10, 0x0a, 0x39, 0x0a, 0x02, 0x04, + 0x04, 0x12, 0x04, 0x45, 0x00, 0x47, 0x01, 0x1a, 0x2d, 0x0a, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, + 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, + 0x20, 0x6b, 0x65, 0x79, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x45, + 0x08, 0x18, 0x0a, 0x1c, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x46, 0x02, 0x1a, 0x22, + 0x0f, 0x20, 0x43, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x06, 0x12, 0x03, 0x46, 0x02, 0x0e, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x46, 0x0f, 0x15, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x46, 0x18, 0x19, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x05, + 0x12, 0x04, 0x49, 0x00, 0x4d, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x49, + 0x08, 0x17, 0x0a, 0x1d, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x4a, 0x02, 0x15, 0x22, + 0x10, 0x20, 0x4f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x66, 0x6c, 0x61, 0x67, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x05, 0x12, 0x03, 0x4a, 0x02, 0x06, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x4a, 0x07, 0x10, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x4a, 0x13, 0x14, 0x0a, 0x23, 0x0a, 0x04, 0x04, + 0x05, 0x02, 0x01, 0x12, 0x03, 0x4b, 0x02, 0x17, 0x22, 0x16, 0x20, 0x44, 0x65, 0x6c, 0x65, 0x74, + 0x65, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x05, 0x12, 0x03, 0x4b, 0x02, 0x06, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, 0x12, 0x03, 0x4b, 0x07, 0x12, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x03, 0x4b, 0x15, 0x16, 0x0a, 0x41, 0x0a, 0x04, 0x04, 0x05, + 0x02, 0x02, 0x12, 0x03, 0x4c, 0x02, 0x27, 0x22, 0x34, 0x20, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, + 0x6d, 0x20, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x63, + 0x68, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x73, 0x69, 0x6e, 0x63, 0x65, + 0x20, 0x6c, 0x61, 0x73, 0x74, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x02, 0x06, 0x12, 0x03, 0x4c, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x02, 0x01, 0x12, 0x03, 0x4c, 0x1b, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x02, 0x03, 0x12, 0x03, 0x4c, 0x25, 0x26, 0x0a, 0x3a, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x04, 0x52, + 0x00, 0x56, 0x01, 0x1a, 0x2e, 0x0a, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x74, + 0x6f, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x20, 0x63, + 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, 0x79, 0x20, 0x6b, 0x65, + 0x79, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x03, 0x52, 0x08, 0x17, 0x0a, + 0x18, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x03, 0x53, 0x02, 0x11, 0x22, 0x0b, 0x20, 0x43, + 0x61, 0x63, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x53, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x53, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x53, 0x0f, 0x10, 0x0a, 0x1e, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x01, 0x12, 0x03, 0x54, 0x02, 0x1a, + 0x22, 0x11, 0x20, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x61, 0x63, + 0x68, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x06, 0x12, 0x03, 0x54, 0x02, + 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x01, 0x12, 0x03, 0x54, 0x0f, 0x15, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x03, 0x12, 0x03, 0x54, 0x18, 0x19, 0x0a, 0x27, 0x0a, + 0x04, 0x04, 0x06, 0x02, 0x02, 0x12, 0x03, 0x55, 0x02, 0x20, 0x22, 0x1a, 0x20, 0x4f, 0x76, 0x65, + 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x66, 0x6c, 0x61, 0x67, 0x20, 0x69, 0x66, 0x20, 0x65, + 0x78, 0x69, 0x73, 0x74, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x06, 0x12, + 0x03, 0x55, 0x02, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x01, 0x12, 0x03, 0x55, + 0x12, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x03, 0x12, 0x03, 0x55, 0x1e, 0x1f, + 0x0a, 0x69, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x04, 0x5b, 0x00, 0x5d, 0x01, 0x1a, 0x34, 0x0a, 0x20, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x20, 0x6f, 0x66, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2f, + 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x0a, 0x22, 0x27, 0x20, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x2c, 0x20, 0x73, 0x75, 0x63, 0x63, + 0x65, 0x73, 0x73, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, + 0x20, 0x6e, 0x6f, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x07, 0x01, 0x12, 0x03, 0x5b, 0x08, 0x18, 0x0a, 0x34, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x04, 0x62, + 0x00, 0x64, 0x01, 0x1a, 0x28, 0x0a, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x74, + 0x6f, 0x20, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, + 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, 0x79, 0x20, 0x6b, 0x65, 0x79, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x08, 0x01, 0x12, 0x03, 0x62, 0x08, 0x1a, 0x0a, 0x18, 0x0a, 0x04, 0x04, 0x08, 0x02, + 0x00, 0x12, 0x03, 0x63, 0x02, 0x11, 0x22, 0x0b, 0x20, 0x43, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6b, + 0x65, 0x79, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x05, 0x12, 0x03, 0x63, 0x02, + 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x03, 0x63, 0x09, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x03, 0x63, 0x0f, 0x10, 0x0a, 0x65, 0x0a, + 0x02, 0x04, 0x09, 0x12, 0x04, 0x69, 0x00, 0x6b, 0x01, 0x1a, 0x30, 0x0a, 0x20, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x66, + 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x22, 0x27, 0x20, 0x45, 0x6d, + 0x70, 0x74, 0x79, 0x2c, 0x20, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x69, 0x6e, 0x64, + 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x6e, 0x6f, 0x20, 0x65, 0x72, 0x72, + 0x6f, 0x72, 0x73, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, 0x03, 0x69, 0x08, 0x1b, + 0x0a, 0x6c, 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x04, 0x6e, 0x00, 0x73, 0x01, 0x1a, 0x60, 0x20, 0x41, + 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x63, + 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x2c, 0x20, 0x68, 0x65, + 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, + 0x2c, 0x20, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x76, 0x61, 0x72, 0x69, + 0x6f, 0x75, 0x73, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x0a, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x0a, 0x01, 0x12, 0x03, 0x6e, 0x08, 0x13, 0x0a, 0x48, 0x0a, 0x04, 0x04, 0x0a, + 0x02, 0x00, 0x12, 0x03, 0x6f, 0x02, 0x11, 0x22, 0x3b, 0x20, 0x54, 0x68, 0x65, 0x20, 0x75, 0x6e, + 0x69, 0x71, 0x75, 0x65, 0x20, 0x49, 0x44, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x2d, 0x20, 0x73, 0x61, + 0x6d, 0x65, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, + 0x6b, 0x65, 0x79, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x05, 0x12, 0x03, 0x6f, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x03, 0x6f, 0x09, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, 0x03, 0x6f, 0x0f, 0x10, 0x0a, 0x3d, + 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x01, 0x12, 0x03, 0x70, 0x02, 0x16, 0x22, 0x30, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x49, 0x44, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x0a, 0x02, 0x01, 0x05, 0x12, 0x03, 0x70, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x0a, 0x02, 0x01, 0x01, 0x12, 0x03, 0x70, 0x09, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, + 0x01, 0x03, 0x12, 0x03, 0x70, 0x14, 0x15, 0x0a, 0x41, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x02, 0x12, + 0x03, 0x71, 0x02, 0x32, 0x22, 0x34, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, + 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x78, 0x74, + 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, + 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, + 0x02, 0x02, 0x06, 0x12, 0x03, 0x71, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, + 0x01, 0x12, 0x03, 0x71, 0x1b, 0x2d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x03, 0x12, + 0x03, 0x71, 0x30, 0x31, 0x0a, 0x37, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x03, 0x12, 0x03, 0x72, 0x02, + 0x2b, 0x22, 0x2a, 0x20, 0x45, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x0a, 0x02, 0x03, 0x06, 0x12, 0x03, 0x72, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x72, 0x1c, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, + 0x03, 0x03, 0x12, 0x03, 0x72, 0x29, 0x2a, 0x0a, 0x45, 0x0a, 0x02, 0x04, 0x0b, 0x12, 0x04, 0x78, + 0x00, 0x7c, 0x01, 0x1a, 0x39, 0x0a, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x74, + 0x6f, 0x20, 0x67, 0x65, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x20, + 0x61, 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x61, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x0a, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x0b, 0x01, 0x12, 0x03, 0x78, 0x08, 0x25, 0x0a, 0x48, 0x0a, 0x04, 0x04, 0x0b, + 0x02, 0x00, 0x12, 0x03, 0x79, 0x02, 0x11, 0x22, 0x3b, 0x20, 0x54, 0x68, 0x65, 0x20, 0x75, 0x6e, + 0x69, 0x71, 0x75, 0x65, 0x20, 0x49, 0x44, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x2d, 0x20, 0x73, 0x61, + 0x6d, 0x65, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, + 0x6b, 0x65, 0x79, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x05, 0x12, 0x03, 0x79, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x01, 0x12, 0x03, 0x79, 0x09, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x03, 0x12, 0x03, 0x79, 0x0f, 0x10, 0x0a, 0x3d, + 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x01, 0x12, 0x03, 0x7a, 0x02, 0x16, 0x22, 0x30, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x49, 0x44, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x0b, 0x02, 0x01, 0x05, 0x12, 0x03, 0x7a, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x0b, 0x02, 0x01, 0x01, 0x12, 0x03, 0x7a, 0x09, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, + 0x01, 0x03, 0x12, 0x03, 0x7a, 0x14, 0x15, 0x0a, 0x41, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x02, 0x12, + 0x03, 0x7b, 0x02, 0x32, 0x22, 0x34, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, + 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x78, 0x74, + 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, + 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, + 0x02, 0x02, 0x06, 0x12, 0x03, 0x7b, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x02, + 0x01, 0x12, 0x03, 0x7b, 0x1b, 0x2d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x02, 0x03, 0x12, + 0x03, 0x7b, 0x30, 0x31, 0x0a, 0x47, 0x0a, 0x02, 0x04, 0x0c, 0x12, 0x06, 0x81, 0x01, 0x00, 0x83, + 0x01, 0x01, 0x1a, 0x39, 0x0a, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x74, 0x6f, + 0x20, 0x67, 0x65, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x20, 0x61, + 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x61, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x0a, 0x0a, 0x0b, 0x0a, + 0x03, 0x04, 0x0c, 0x01, 0x12, 0x04, 0x81, 0x01, 0x08, 0x26, 0x0a, 0x3c, 0x0a, 0x04, 0x04, 0x0c, + 0x02, 0x00, 0x12, 0x04, 0x82, 0x01, 0x02, 0x1e, 0x22, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x72, + 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x77, 0x61, 0x73, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x72, 0x20, 0x65, + 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, + 0x06, 0x12, 0x04, 0x82, 0x01, 0x02, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x01, + 0x12, 0x04, 0x82, 0x01, 0x0e, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x03, 0x12, + 0x04, 0x82, 0x01, 0x1c, 0x1d, 0x0a, 0x43, 0x0a, 0x02, 0x04, 0x0d, 0x12, 0x06, 0x88, 0x01, 0x00, + 0x8b, 0x01, 0x01, 0x1a, 0x35, 0x0a, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x74, + 0x6f, 0x20, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, + 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, + 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0d, + 0x01, 0x12, 0x04, 0x88, 0x01, 0x08, 0x21, 0x0a, 0x49, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x00, 0x12, + 0x04, 0x89, 0x01, 0x02, 0x11, 0x22, 0x3b, 0x20, 0x54, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, + 0x75, 0x65, 0x20, 0x49, 0x44, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, + 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x2d, 0x20, 0x73, 0x61, 0x6d, 0x65, + 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6b, 0x65, + 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x05, 0x12, 0x04, 0x89, 0x01, 0x02, + 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x01, 0x12, 0x04, 0x89, 0x01, 0x09, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x03, 0x12, 0x04, 0x89, 0x01, 0x0f, 0x10, 0x0a, + 0x3e, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x01, 0x12, 0x04, 0x8a, 0x01, 0x02, 0x16, 0x22, 0x30, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x49, 0x44, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x05, 0x12, 0x04, 0x8a, 0x01, 0x02, 0x08, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x01, 0x12, 0x04, 0x8a, 0x01, 0x09, 0x11, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0d, 0x02, 0x01, 0x03, 0x12, 0x04, 0x8a, 0x01, 0x14, 0x15, 0x0a, 0x6c, 0x0a, 0x02, + 0x04, 0x0e, 0x12, 0x06, 0x90, 0x01, 0x00, 0x92, 0x01, 0x01, 0x1a, 0x35, 0x0a, 0x20, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, + 0x0a, 0x22, 0x27, 0x20, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x2c, 0x20, 0x73, 0x75, 0x63, 0x63, 0x65, + 0x73, 0x73, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, + 0x6e, 0x6f, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0e, + 0x01, 0x12, 0x04, 0x90, 0x01, 0x08, 0x22, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +]; +include!("flyteidl2.cacheservice.tonic.rs"); +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/flyteidl2.cacheservice.tonic.rs b/gen/rust/src/flyteidl2.cacheservice.tonic.rs new file mode 100644 index 0000000000..f076e8a7f9 --- /dev/null +++ b/gen/rust/src/flyteidl2.cacheservice.tonic.rs @@ -0,0 +1,606 @@ +// @generated +/// Generated client implementations. +pub mod cache_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct CacheServiceClient { + inner: tonic::client::Grpc, + } + impl CacheServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl CacheServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> CacheServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + CacheServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + pub async fn get( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.cacheservice.CacheService/Get", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.cacheservice.CacheService", "Get")); + self.inner.unary(req, path, codec).await + } + pub async fn put( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.cacheservice.CacheService/Put", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.cacheservice.CacheService", "Put")); + self.inner.unary(req, path, codec).await + } + pub async fn delete( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.cacheservice.CacheService/Delete", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.cacheservice.CacheService", "Delete"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn get_or_extend_reservation( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.cacheservice.CacheService/GetOrExtendReservation", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.cacheservice.CacheService", + "GetOrExtendReservation", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn release_reservation( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.cacheservice.CacheService/ReleaseReservation", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.cacheservice.CacheService", + "ReleaseReservation", + ), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod cache_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with CacheServiceServer. + #[async_trait] + pub trait CacheService: Send + Sync + 'static { + async fn get( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn put( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn delete( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn get_or_extend_reservation( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn release_reservation( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + #[derive(Debug)] + pub struct CacheServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl CacheServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for CacheServiceServer + where + T: CacheService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.cacheservice.CacheService/Get" => { + #[allow(non_camel_case_types)] + struct GetSvc(pub Arc); + impl< + T: CacheService, + > tonic::server::UnaryService for GetSvc { + type Response = super::GetCacheResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.cacheservice.CacheService/Put" => { + #[allow(non_camel_case_types)] + struct PutSvc(pub Arc); + impl< + T: CacheService, + > tonic::server::UnaryService for PutSvc { + type Response = super::PutCacheResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::put(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = PutSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.cacheservice.CacheService/Delete" => { + #[allow(non_camel_case_types)] + struct DeleteSvc(pub Arc); + impl< + T: CacheService, + > tonic::server::UnaryService + for DeleteSvc { + type Response = super::DeleteCacheResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::delete(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = DeleteSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.cacheservice.CacheService/GetOrExtendReservation" => { + #[allow(non_camel_case_types)] + struct GetOrExtendReservationSvc(pub Arc); + impl< + T: CacheService, + > tonic::server::UnaryService + for GetOrExtendReservationSvc { + type Response = super::GetOrExtendReservationResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_or_extend_reservation( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetOrExtendReservationSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.cacheservice.CacheService/ReleaseReservation" => { + #[allow(non_camel_case_types)] + struct ReleaseReservationSvc(pub Arc); + impl< + T: CacheService, + > tonic::server::UnaryService + for ReleaseReservationSvc { + type Response = super::ReleaseReservationResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::release_reservation(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ReleaseReservationSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for CacheServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService for CacheServiceServer { + const NAME: &'static str = "flyteidl2.cacheservice.CacheService"; + } +} diff --git a/gen/rust/src/flyteidl2.cacheservice.v2.rs b/gen/rust/src/flyteidl2.cacheservice.v2.rs new file mode 100644 index 0000000000..03e736043f --- /dev/null +++ b/gen/rust/src/flyteidl2.cacheservice.v2.rs @@ -0,0 +1,365 @@ +// @generated +// This file is @generated by prost-build. +/// +/// Identifier for cache operations, including org, project, and domain. +/// This is used to scope cache operations to specific organizational contexts. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Identifier { + /// Organization identifier + #[prost(string, tag="1")] + pub org: ::prost::alloc::string::String, + /// Project identifier + #[prost(string, tag="2")] + pub project: ::prost::alloc::string::String, + /// Domain identifier + #[prost(string, tag="3")] + pub domain: ::prost::alloc::string::String, +} +/// +/// Request to retrieve cached data by key. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetCacheRequest { + #[prost(message, optional, tag="1")] + pub base_request: ::core::option::Option, + /// Identifier for the cache operation + #[prost(message, optional, tag="2")] + pub identifier: ::core::option::Option, +} +/// +/// Request to store/update cached data by key. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PutCacheRequest { + #[prost(message, optional, tag="1")] + pub base_request: ::core::option::Option, + /// Identifier for the cache operation + #[prost(message, optional, tag="2")] + pub identifier: ::core::option::Option, +} +/// +/// Request to delete cached data by key. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DeleteCacheRequest { + #[prost(message, optional, tag="1")] + pub base_request: ::core::option::Option, + /// Identifier for the cache operation + #[prost(message, optional, tag="2")] + pub identifier: ::core::option::Option, +} +/// +/// Request to get or extend a reservation for a cache key +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetOrExtendReservationRequest { + #[prost(message, optional, tag="1")] + pub base_request: ::core::option::Option, + /// Identifier for the cache operation + #[prost(message, optional, tag="2")] + pub identifier: ::core::option::Option, +} +/// +/// Request to release the reservation for a cache key +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ReleaseReservationRequest { + #[prost(message, optional, tag="1")] + pub base_request: ::core::option::Option, + /// Identifier for the cache operation + #[prost(message, optional, tag="2")] + pub identifier: ::core::option::Option, +} +/// Encoded file descriptor set for the `flyteidl2.cacheservice.v2` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0x88, 0x23, 0x0a, 0x2c, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, + 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x63, + 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x19, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, + 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x76, 0x32, 0x1a, 0x1b, 0x62, 0x75, + 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x29, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x2f, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x6b, 0x0a, 0x0a, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x12, 0x19, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, + 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x21, 0x0a, + 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, + 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x12, 0x1f, 0x0a, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, + 0x6e, 0x22, 0xac, 0x01, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x4a, 0x0a, 0x0c, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x72, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, + 0x76, 0x69, 0x63, 0x65, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x52, 0x0b, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x4d, 0x0a, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x76, + 0x32, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, + 0x03, 0xc8, 0x01, 0x01, 0x52, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x22, 0xac, 0x01, 0x0a, 0x0f, 0x50, 0x75, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x4a, 0x0a, 0x0c, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x72, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x2e, 0x50, 0x75, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x52, 0x0b, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x4d, 0x0a, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x76, 0x32, + 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, + 0xc8, 0x01, 0x01, 0x52, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x22, + 0xb2, 0x01, 0x0a, 0x12, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x4d, 0x0a, 0x0c, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x72, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x61, 0x63, 0x68, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0b, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x4d, 0x0a, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x22, 0xc8, 0x01, 0x0a, 0x1d, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x45, 0x78, + 0x74, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x58, 0x0a, 0x0c, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x72, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x45, 0x78, 0x74, 0x65, 0x6e, + 0x64, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x52, 0x0b, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x4d, 0x0a, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x76, 0x32, + 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, + 0xc8, 0x01, 0x01, 0x52, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x22, + 0xc0, 0x01, 0x0a, 0x19, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, + 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x54, 0x0a, + 0x0c, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x52, 0x65, 0x6c, + 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0b, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x4d, 0x0a, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x2e, 0x76, 0x32, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, + 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x32, 0xbb, 0x04, 0x0a, 0x0c, 0x43, 0x61, 0x63, 0x68, 0x65, 0x53, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x12, 0x5b, 0x0a, 0x03, 0x47, 0x65, 0x74, 0x12, 0x2a, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, + 0x47, 0x65, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x5b, 0x0a, 0x03, 0x50, 0x75, 0x74, 0x12, 0x2a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x2e, 0x76, 0x32, 0x2e, 0x50, 0x75, 0x74, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x50, 0x75, 0x74, + 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x64, 0x0a, + 0x06, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x2d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x2e, 0x76, 0x32, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, + 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x8a, 0x01, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x45, 0x78, 0x74, + 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x38, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, + 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x36, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, + 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x7e, 0x0a, 0x12, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, + 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x34, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, + 0x76, 0x32, 0x2e, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, + 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x42, 0xf7, 0x01, 0x0a, 0x1d, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, + 0x76, 0x32, 0x42, 0x11, 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x2f, 0x76, 0x32, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x19, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x56, 0x32, 0xca, 0x02, 0x19, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x5c, 0x56, 0x32, 0xe2, 0x02, 0x25, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5c, 0x56, 0x32, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1b, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x3a, 0x3a, 0x56, 0x32, 0x4a, 0xa6, 0x13, 0x0a, 0x06, 0x12, + 0x04, 0x00, 0x00, 0x4d, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, + 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x22, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, + 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x33, 0x0a, + 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x07, 0x00, 0x54, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, + 0x03, 0x07, 0x00, 0x54, 0x0a, 0x90, 0x01, 0x0a, 0x02, 0x06, 0x00, 0x12, 0x04, 0x0c, 0x00, 0x1b, + 0x01, 0x1a, 0x83, 0x01, 0x0a, 0x20, 0x43, 0x61, 0x63, 0x68, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x6f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, + 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, + 0x64, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x61, 0x6c, 0x2c, 0x20, + 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x64, 0x65, 0x6c, + 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, + 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x20, 0x6f, 0x75, + 0x74, 0x70, 0x75, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x06, 0x00, 0x01, 0x12, 0x03, + 0x0c, 0x08, 0x14, 0x0a, 0x2c, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0e, 0x02, 0x4d, + 0x1a, 0x1f, 0x20, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x73, 0x20, 0x63, 0x61, 0x63, + 0x68, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, 0x79, 0x20, 0x6b, 0x65, 0x79, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0e, 0x06, 0x09, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x0e, 0x0a, 0x19, 0x0a, 0x0c, 0x0a, + 0x05, 0x06, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0e, 0x24, 0x4b, 0x0a, 0x34, 0x0a, 0x04, 0x06, + 0x00, 0x02, 0x01, 0x12, 0x03, 0x11, 0x02, 0x4d, 0x1a, 0x27, 0x20, 0x53, 0x74, 0x6f, 0x72, 0x65, + 0x73, 0x20, 0x6f, 0x72, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x20, 0x63, 0x61, 0x63, + 0x68, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, 0x79, 0x20, 0x6b, 0x65, 0x79, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x11, 0x06, 0x09, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x11, 0x0a, 0x19, 0x0a, 0x0c, 0x0a, + 0x05, 0x06, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x11, 0x24, 0x4b, 0x0a, 0x2a, 0x0a, 0x04, 0x06, + 0x00, 0x02, 0x02, 0x12, 0x03, 0x14, 0x02, 0x56, 0x1a, 0x1d, 0x20, 0x44, 0x65, 0x6c, 0x65, 0x74, + 0x65, 0x73, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, + 0x79, 0x20, 0x6b, 0x65, 0x79, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x14, 0x06, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, + 0x14, 0x0d, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x14, 0x2a, + 0x54, 0x0a, 0x3a, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x03, 0x12, 0x03, 0x17, 0x02, 0x7c, 0x1a, 0x2d, + 0x20, 0x47, 0x65, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x20, 0x61, + 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x61, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x06, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x17, 0x06, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x06, + 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x17, 0x1d, 0x3a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, + 0x03, 0x03, 0x12, 0x03, 0x17, 0x45, 0x7a, 0x0a, 0x36, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x04, 0x12, + 0x03, 0x1a, 0x02, 0x70, 0x1a, 0x29, 0x20, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x61, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x1a, 0x06, 0x18, 0x0a, 0x0c, 0x0a, + 0x05, 0x06, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, 0x1a, 0x19, 0x32, 0x0a, 0x0c, 0x0a, 0x05, 0x06, + 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, 0x1a, 0x3d, 0x6e, 0x0a, 0xa1, 0x01, 0x0a, 0x02, 0x04, 0x00, + 0x12, 0x04, 0x21, 0x00, 0x25, 0x01, 0x1a, 0x94, 0x01, 0x0a, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, + 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, + 0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x72, 0x67, 0x2c, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x2e, 0x0a, + 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x20, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6f, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x63, 0x20, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x21, 0x08, 0x12, 0x0a, 0x26, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x00, 0x12, 0x03, 0x22, 0x02, 0x3b, 0x22, 0x19, 0x20, 0x4f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x22, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x22, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x22, 0x0f, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x00, 0x08, 0x12, 0x03, 0x22, 0x11, 0x3a, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, + 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x22, 0x12, 0x39, 0x0a, 0x21, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x01, 0x12, 0x03, 0x23, 0x02, 0x3f, 0x22, 0x14, 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x23, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x23, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x23, 0x13, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, + 0x08, 0x12, 0x03, 0x23, 0x15, 0x3e, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x01, 0x08, 0x87, + 0x09, 0x0e, 0x02, 0x12, 0x03, 0x23, 0x16, 0x3d, 0x0a, 0x20, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, + 0x12, 0x03, 0x24, 0x02, 0x3e, 0x22, 0x13, 0x20, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x02, 0x05, 0x12, 0x03, 0x24, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, + 0x01, 0x12, 0x03, 0x24, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, + 0x03, 0x24, 0x12, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x08, 0x12, 0x03, 0x24, + 0x14, 0x3d, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x02, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, + 0x03, 0x24, 0x15, 0x3c, 0x0a, 0x36, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x2a, 0x00, 0x2d, 0x01, + 0x1a, 0x2a, 0x0a, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x72, + 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x64, + 0x61, 0x74, 0x61, 0x20, 0x62, 0x79, 0x20, 0x6b, 0x65, 0x79, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x01, 0x01, 0x12, 0x03, 0x2a, 0x08, 0x17, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, + 0x12, 0x03, 0x2b, 0x02, 0x3a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, + 0x2b, 0x02, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2b, 0x29, + 0x35, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x2b, 0x38, 0x39, 0x0a, + 0x31, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x2c, 0x02, 0x43, 0x22, 0x24, 0x20, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x06, 0x12, 0x03, 0x2c, 0x02, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x2c, 0x0d, 0x17, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x2c, 0x1a, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x01, 0x08, 0x12, 0x03, 0x2c, 0x1c, 0x42, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x01, + 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x2c, 0x1d, 0x41, 0x0a, 0x3a, 0x0a, 0x02, 0x04, + 0x02, 0x12, 0x04, 0x32, 0x00, 0x35, 0x01, 0x1a, 0x2e, 0x0a, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2f, 0x75, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, + 0x79, 0x20, 0x6b, 0x65, 0x79, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, + 0x32, 0x08, 0x17, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x33, 0x02, 0x3a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, 0x03, 0x33, 0x02, 0x28, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x33, 0x29, 0x35, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x33, 0x38, 0x39, 0x0a, 0x31, 0x0a, 0x04, 0x04, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x34, 0x02, 0x43, 0x22, 0x24, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x63, + 0x68, 0x65, 0x20, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, 0x03, 0x34, 0x02, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x34, 0x0d, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x01, 0x03, 0x12, 0x03, 0x34, 0x1a, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x08, + 0x12, 0x03, 0x34, 0x1c, 0x42, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x02, 0x02, 0x01, 0x08, 0x87, 0x09, + 0x19, 0x12, 0x03, 0x34, 0x1d, 0x41, 0x0a, 0x34, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x3a, 0x00, + 0x3d, 0x01, 0x1a, 0x28, 0x0a, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x74, 0x6f, + 0x20, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x64, + 0x61, 0x74, 0x61, 0x20, 0x62, 0x79, 0x20, 0x6b, 0x65, 0x79, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x03, 0x01, 0x12, 0x03, 0x3a, 0x08, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, + 0x12, 0x03, 0x3b, 0x02, 0x3d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, + 0x3b, 0x02, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x3b, 0x2c, + 0x38, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x3b, 0x3b, 0x3c, 0x0a, + 0x31, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, 0x3c, 0x02, 0x43, 0x22, 0x24, 0x20, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x06, 0x12, 0x03, 0x3c, 0x02, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, 0x3c, 0x0d, 0x17, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x3c, 0x1a, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x01, 0x08, 0x12, 0x03, 0x3c, 0x1c, 0x42, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x03, + 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x3c, 0x1d, 0x41, 0x0a, 0x45, 0x0a, 0x02, 0x04, + 0x04, 0x12, 0x04, 0x42, 0x00, 0x45, 0x01, 0x1a, 0x39, 0x0a, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x67, 0x65, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x74, + 0x65, 0x6e, 0x64, 0x20, 0x61, 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6b, 0x65, + 0x79, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x42, 0x08, 0x25, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x43, 0x02, 0x48, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x00, 0x06, 0x12, 0x03, 0x43, 0x02, 0x36, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x43, 0x37, 0x43, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x43, 0x46, 0x47, 0x0a, 0x31, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x44, + 0x02, 0x43, 0x22, 0x24, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6f, 0x70, + 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, + 0x06, 0x12, 0x03, 0x44, 0x02, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x44, 0x0d, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x44, + 0x1a, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x08, 0x12, 0x03, 0x44, 0x1c, 0x42, + 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x04, 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x44, 0x1d, + 0x41, 0x0a, 0x41, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x4a, 0x00, 0x4d, 0x01, 0x1a, 0x35, 0x0a, + 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x6c, 0x65, + 0x61, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, + 0x6b, 0x65, 0x79, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x4a, 0x08, 0x21, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x4b, 0x02, 0x44, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x00, 0x06, 0x12, 0x03, 0x4b, 0x02, 0x32, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x4b, 0x33, 0x3f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x4b, 0x42, 0x43, 0x0a, 0x31, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, + 0x03, 0x4c, 0x02, 0x43, 0x22, 0x24, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, + 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x01, 0x06, 0x12, 0x03, 0x4c, 0x02, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x4c, 0x0d, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x4c, 0x1a, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x08, 0x12, 0x03, 0x4c, + 0x1c, 0x42, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x05, 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, + 0x4c, 0x1d, 0x41, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +]; +include!("flyteidl2.cacheservice.v2.tonic.rs"); +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/flyteidl2.cacheservice.v2.tonic.rs b/gen/rust/src/flyteidl2.cacheservice.v2.tonic.rs new file mode 100644 index 0000000000..b301115cc1 --- /dev/null +++ b/gen/rust/src/flyteidl2.cacheservice.v2.tonic.rs @@ -0,0 +1,610 @@ +// @generated +/// Generated client implementations. +pub mod cache_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct CacheServiceClient { + inner: tonic::client::Grpc, + } + impl CacheServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl CacheServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> CacheServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + CacheServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + pub async fn get( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.cacheservice.v2.CacheService/Get", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.cacheservice.v2.CacheService", "Get"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn put( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.cacheservice.v2.CacheService/Put", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.cacheservice.v2.CacheService", "Put"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn delete( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.cacheservice.v2.CacheService/Delete", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.cacheservice.v2.CacheService", "Delete"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn get_or_extend_reservation( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.cacheservice.v2.CacheService/GetOrExtendReservation", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.cacheservice.v2.CacheService", + "GetOrExtendReservation", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn release_reservation( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.cacheservice.v2.CacheService/ReleaseReservation", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.cacheservice.v2.CacheService", + "ReleaseReservation", + ), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod cache_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with CacheServiceServer. + #[async_trait] + pub trait CacheService: Send + Sync + 'static { + async fn get( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn put( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn delete( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn get_or_extend_reservation( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn release_reservation( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + #[derive(Debug)] + pub struct CacheServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl CacheServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for CacheServiceServer + where + T: CacheService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.cacheservice.v2.CacheService/Get" => { + #[allow(non_camel_case_types)] + struct GetSvc(pub Arc); + impl< + T: CacheService, + > tonic::server::UnaryService for GetSvc { + type Response = super::super::GetCacheResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.cacheservice.v2.CacheService/Put" => { + #[allow(non_camel_case_types)] + struct PutSvc(pub Arc); + impl< + T: CacheService, + > tonic::server::UnaryService for PutSvc { + type Response = super::super::PutCacheResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::put(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = PutSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.cacheservice.v2.CacheService/Delete" => { + #[allow(non_camel_case_types)] + struct DeleteSvc(pub Arc); + impl< + T: CacheService, + > tonic::server::UnaryService + for DeleteSvc { + type Response = super::super::DeleteCacheResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::delete(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = DeleteSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.cacheservice.v2.CacheService/GetOrExtendReservation" => { + #[allow(non_camel_case_types)] + struct GetOrExtendReservationSvc(pub Arc); + impl< + T: CacheService, + > tonic::server::UnaryService + for GetOrExtendReservationSvc { + type Response = super::super::GetOrExtendReservationResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_or_extend_reservation( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetOrExtendReservationSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.cacheservice.v2.CacheService/ReleaseReservation" => { + #[allow(non_camel_case_types)] + struct ReleaseReservationSvc(pub Arc); + impl< + T: CacheService, + > tonic::server::UnaryService + for ReleaseReservationSvc { + type Response = super::super::ReleaseReservationResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::release_reservation(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ReleaseReservationSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for CacheServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService for CacheServiceServer { + const NAME: &'static str = "flyteidl2.cacheservice.v2.CacheService"; + } +} diff --git a/gen/rust/src/flyteidl2.common.rs b/gen/rust/src/flyteidl2.common.rs new file mode 100644 index 0000000000..b326773c22 --- /dev/null +++ b/gen/rust/src/flyteidl2.common.rs @@ -0,0 +1,2487 @@ +// @generated +// This file is @generated by prost-build. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ProjectIdentifier { + #[prost(string, tag="1")] + pub organization: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub domain: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub name: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ClusterIdentifier { + #[prost(string, tag="1")] + pub organization: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ClusterPoolIdentifier { + #[prost(string, tag="1")] + pub organization: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ClusterConfigIdentifier { + #[prost(string, tag="1")] + pub organization: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub id: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ClusterNodepoolIdentifier { + #[prost(string, tag="1")] + pub organization: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub cluster_name: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub name: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UserIdentifier { + #[prost(string, tag="1")] + pub subject: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ApplicationIdentifier { + #[prost(string, tag="1")] + pub subject: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RoleIdentifier { + #[prost(string, tag="1")] + pub organization: ::prost::alloc::string::String, + /// Unique name for this role within the organization + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct OrgIdentifier { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ManagedClusterIdentifier { + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, + #[prost(message, optional, tag="3")] + pub org: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PolicyIdentifier { + #[prost(string, tag="1")] + pub organization: ::prost::alloc::string::String, + /// Unique name for this policy within the organization + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, +} +/// Unique identifier of a run. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RunIdentifier { + /// Org this run belongs to. + #[prost(string, tag="1")] + pub org: ::prost::alloc::string::String, + /// Project this run belongs to. + #[prost(string, tag="2")] + pub project: ::prost::alloc::string::String, + /// Domain this run belongs to. + #[prost(string, tag="3")] + pub domain: ::prost::alloc::string::String, + /// Name of the run. Must be unique across all runs in this org, project, and domain pairing. + #[prost(string, tag="4")] + pub name: ::prost::alloc::string::String, +} +/// Unique identifier of an action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ActionIdentifier { + /// Identifier for the run. + #[prost(message, optional, tag="1")] + pub run: ::core::option::Option, + /// Name of the action. Must be unique within the run. + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, +} +/// Unique identifier of a single action attempt +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ActionAttemptIdentifier { + #[prost(message, optional, tag="1")] + pub action_id: ::core::option::Option, + #[prost(uint32, tag="2")] + pub attempt: u32, +} +/// Identifies trigger within an org, project and domain +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TriggerName { + /// Org this trigger belongs to. + #[prost(string, tag="1")] + pub org: ::prost::alloc::string::String, + /// Project this trigger belongs to. + #[prost(string, tag="2")] + pub project: ::prost::alloc::string::String, + /// Domain this trigger belongs to. + #[prost(string, tag="3")] + pub domain: ::prost::alloc::string::String, + /// Unique name of the trigger. + #[prost(string, tag="4")] + pub name: ::prost::alloc::string::String, + #[prost(string, tag="5")] + pub task_name: ::prost::alloc::string::String, +} +/// Identifies a trigger revision within an org, project and domain +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TriggerIdentifier { + #[prost(message, optional, tag="1")] + pub name: ::core::option::Option, + /// Revision of the trigger. + #[prost(uint64, tag="2")] + pub revision: u64, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Organization { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Domain { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + #[prost(message, optional, tag="2")] + pub organization: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Project { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + #[prost(message, optional, tag="2")] + pub domain: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Workflow { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + #[prost(message, optional, tag="2")] + pub project: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LaunchPlan { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + #[prost(message, optional, tag="2")] + pub project: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Resource { + #[prost(oneof="resource::Resource", tags="1, 2, 3, 4, 5, 6")] + pub resource: ::core::option::Option, +} +/// Nested message and enum types in `Resource`. +pub mod resource { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Resource { + #[prost(message, tag="1")] + Organization(super::Organization), + #[prost(message, tag="2")] + Domain(super::Domain), + #[prost(message, tag="3")] + Project(super::Project), + #[prost(message, tag="4")] + Workflow(super::Workflow), + #[prost(message, tag="5")] + LaunchPlan(super::LaunchPlan), + #[prost(message, tag="6")] + Cluster(super::ClusterIdentifier), + } +} +/// Defines a set of allowed actions on a specific authorization resource. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Permission { + #[prost(message, optional, tag="1")] + pub resource: ::core::option::Option, + #[prost(enumeration="Action", repeated, tag="2")] + pub actions: ::prost::alloc::vec::Vec, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum Action { + None = 0, + Create = 1, + Read = 2, + Update = 3, + Delete = 4, + /// Read Flyte workflows, tasks and launch plans + ViewFlyteInventory = 5, + /// View Flyte executions + ViewFlyteExecutions = 6, + /// Register new versions of Flyte workflows, tasks and launch plans + RegisterFlyteInventory = 7, + /// Create new Flyte workflow and task executions + CreateFlyteExecutions = 8, + /// Create new projects and update project descriptions + AdministerProject = 9, + /// Add users, roles and update role assignments. + ManagePermissions = 10, + /// Manage billing, account-wide settings + AdministerAccount = 11, + /// Operations for clusters + ManageCluster = 12, + /// Edit execution related attributes, including TASK_RESOURCE, WORKFLOW_EXECUTION_CONFIG, and EXTERNAL_RESOURCE + EditExecutionRelatedAttributes = 13, + /// Edit cluster related attributes, including CLUSTER_RESOURCE and CLUSTER_ASSIGNMENT + EditClusterRelatedAttributes = 14, + /// Edit unused attributes, including EXECUTION_QUEUE, EXECUTION_CLUSTER_LABEL, QUALITY_OF_SERVICE_SPECIFICATION, and PLUGIN_OVERRIDE + EditUnusedAttributes = 15, + /// View system logs + SupportSystemLogs = 16, +} +impl Action { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Action::None => "ACTION_NONE", + Action::Create => "ACTION_CREATE", + Action::Read => "ACTION_READ", + Action::Update => "ACTION_UPDATE", + Action::Delete => "ACTION_DELETE", + Action::ViewFlyteInventory => "ACTION_VIEW_FLYTE_INVENTORY", + Action::ViewFlyteExecutions => "ACTION_VIEW_FLYTE_EXECUTIONS", + Action::RegisterFlyteInventory => "ACTION_REGISTER_FLYTE_INVENTORY", + Action::CreateFlyteExecutions => "ACTION_CREATE_FLYTE_EXECUTIONS", + Action::AdministerProject => "ACTION_ADMINISTER_PROJECT", + Action::ManagePermissions => "ACTION_MANAGE_PERMISSIONS", + Action::AdministerAccount => "ACTION_ADMINISTER_ACCOUNT", + Action::ManageCluster => "ACTION_MANAGE_CLUSTER", + Action::EditExecutionRelatedAttributes => "ACTION_EDIT_EXECUTION_RELATED_ATTRIBUTES", + Action::EditClusterRelatedAttributes => "ACTION_EDIT_CLUSTER_RELATED_ATTRIBUTES", + Action::EditUnusedAttributes => "ACTION_EDIT_UNUSED_ATTRIBUTES", + Action::SupportSystemLogs => "ACTION_SUPPORT_SYSTEM_LOGS", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ACTION_NONE" => Some(Self::None), + "ACTION_CREATE" => Some(Self::Create), + "ACTION_READ" => Some(Self::Read), + "ACTION_UPDATE" => Some(Self::Update), + "ACTION_DELETE" => Some(Self::Delete), + "ACTION_VIEW_FLYTE_INVENTORY" => Some(Self::ViewFlyteInventory), + "ACTION_VIEW_FLYTE_EXECUTIONS" => Some(Self::ViewFlyteExecutions), + "ACTION_REGISTER_FLYTE_INVENTORY" => Some(Self::RegisterFlyteInventory), + "ACTION_CREATE_FLYTE_EXECUTIONS" => Some(Self::CreateFlyteExecutions), + "ACTION_ADMINISTER_PROJECT" => Some(Self::AdministerProject), + "ACTION_MANAGE_PERMISSIONS" => Some(Self::ManagePermissions), + "ACTION_ADMINISTER_ACCOUNT" => Some(Self::AdministerAccount), + "ACTION_MANAGE_CLUSTER" => Some(Self::ManageCluster), + "ACTION_EDIT_EXECUTION_RELATED_ATTRIBUTES" => Some(Self::EditExecutionRelatedAttributes), + "ACTION_EDIT_CLUSTER_RELATED_ATTRIBUTES" => Some(Self::EditClusterRelatedAttributes), + "ACTION_EDIT_UNUSED_ATTRIBUTES" => Some(Self::EditUnusedAttributes), + "ACTION_SUPPORT_SYSTEM_LOGS" => Some(Self::SupportSystemLogs), + _ => None, + } + } +} +/// A policy is a collection of roles bound to a resource. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Policy { + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + #[prost(message, repeated, tag="2")] + pub bindings: ::prost::alloc::vec::Vec, + /// Optional: human readable description + #[prost(string, tag="3")] + pub description: ::prost::alloc::string::String, +} +/// A policy binding represents a role (a set of actions) defined on a resource. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PolicyBinding { + /// The role designates the permitted set of actions which can be applied to the resource. + #[prost(message, optional, tag="1")] + pub role_id: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub resource: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Role { + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + #[deprecated] + #[prost(message, repeated, tag="2")] + pub permissions: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="3")] + pub role_spec: ::core::option::Option, + #[prost(enumeration="RoleType", tag="4")] + pub role_type: i32, + #[prost(enumeration="Action", repeated, tag="5")] + pub actions: ::prost::alloc::vec::Vec, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RoleSpec { + /// Optional, human readable description for this role. + #[prost(string, tag="1")] + pub description: ::prost::alloc::string::String, +} +/// A role type is a short-hand for understanding the permissions associated with a role. +/// Boilerplate role types include a conventional collection of permissions +/// Custom role types include a user-defined collection of permissions +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum RoleType { + /// Default group. Not used in practice. + None = 0, + /// The admin role has a collective set of permissions to do everything + Admin = 1, + /// The contributor role has a collective set of permissions to view inventory, view executions, write inventory and create executions + Contributor = 2, + /// The viewer role has a collective set of permissions to view inventory and view executions + Viewer = 3, + /// Represent a role with user-defined sets of permissions. + Custom = 4, + /// The role with permissions to administer a specific customer cluster. + ClusterManager = 5, + /// Role with permissions specific to administer flyte project(s). + FlyteProjectAdmin = 6, + /// The viewer role for serverless + ServerlessViewer = 7, + /// The contributor role for serverless + ServerlessContributor = 8, + /// The support role would have contributor permissions plus the access to support endpoints + Support = 9, +} +impl RoleType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + RoleType::None => "ROLE_TYPE_NONE", + RoleType::Admin => "ROLE_TYPE_ADMIN", + RoleType::Contributor => "ROLE_TYPE_CONTRIBUTOR", + RoleType::Viewer => "ROLE_TYPE_VIEWER", + RoleType::Custom => "ROLE_TYPE_CUSTOM", + RoleType::ClusterManager => "ROLE_TYPE_CLUSTER_MANAGER", + RoleType::FlyteProjectAdmin => "ROLE_TYPE_FLYTE_PROJECT_ADMIN", + RoleType::ServerlessViewer => "ROLE_TYPE_SERVERLESS_VIEWER", + RoleType::ServerlessContributor => "ROLE_TYPE_SERVERLESS_CONTRIBUTOR", + RoleType::Support => "ROLE_TYPE_SUPPORT", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ROLE_TYPE_NONE" => Some(Self::None), + "ROLE_TYPE_ADMIN" => Some(Self::Admin), + "ROLE_TYPE_CONTRIBUTOR" => Some(Self::Contributor), + "ROLE_TYPE_VIEWER" => Some(Self::Viewer), + "ROLE_TYPE_CUSTOM" => Some(Self::Custom), + "ROLE_TYPE_CLUSTER_MANAGER" => Some(Self::ClusterManager), + "ROLE_TYPE_FLYTE_PROJECT_ADMIN" => Some(Self::FlyteProjectAdmin), + "ROLE_TYPE_SERVERLESS_VIEWER" => Some(Self::ServerlessViewer), + "ROLE_TYPE_SERVERLESS_CONTRIBUTOR" => Some(Self::ServerlessContributor), + "ROLE_TYPE_SUPPORT" => Some(Self::Support), + _ => None, + } + } +} +/// Encapsulates user profile details for a member of an organization. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct User { + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub spec: ::core::option::Option, + #[deprecated] + #[prost(message, repeated, tag="3")] + pub roles: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="4")] + pub policies: ::prost::alloc::vec::Vec, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UserSpec { + #[prost(string, tag="1")] + pub first_name: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub last_name: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub email: ::prost::alloc::string::String, + #[prost(string, tag="4")] + pub organization: ::prost::alloc::string::String, + #[prost(string, tag="5")] + pub user_handle: ::prost::alloc::string::String, + #[prost(string, repeated, tag="6")] + pub groups: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(string, tag="7")] + pub photo_url: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Application { + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub spec: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AppSpec { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub organization: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EnrichedIdentity { + #[prost(oneof="enriched_identity::Principal", tags="1, 2")] + pub principal: ::core::option::Option, +} +/// Nested message and enum types in `EnrichedIdentity`. +pub mod enriched_identity { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Principal { + #[prost(message, tag="1")] + User(super::User), + #[prost(message, tag="2")] + Application(super::Application), + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Identity { + #[prost(oneof="identity::Principal", tags="1, 2")] + pub principal: ::core::option::Option, +} +/// Nested message and enum types in `Identity`. +pub mod identity { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Principal { + #[prost(message, tag="1")] + UserId(super::UserIdentifier), + #[prost(message, tag="2")] + ApplicationId(super::ApplicationIdentifier), + } +} +/// Runtime information. This is loosely defined to allow for extensibility. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RuntimeMetadata { + /// Type of runtime. + #[prost(enumeration="runtime_metadata::RuntimeType", tag="1")] + pub r#type: i32, + /// Version of the runtime. All versions should be backward compatible. However, certain cases call for version + /// checks to ensure tighter validation or setting expectations. + #[prost(string, tag="2")] + pub version: ::prost::alloc::string::String, + /// +optional It can be used to provide extra information about the runtime (e.g. python, golang... etc.). + #[prost(string, tag="3")] + pub flavor: ::prost::alloc::string::String, +} +/// Nested message and enum types in `RuntimeMetadata`. +pub mod runtime_metadata { + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum RuntimeType { + Other = 0, + FlyteSdk = 1, + UnionSdk = 2, + } + impl RuntimeType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + RuntimeType::Other => "OTHER", + RuntimeType::FlyteSdk => "FLYTE_SDK", + RuntimeType::UnionSdk => "UNION_SDK", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "OTHER" => Some(Self::Other), + "FLYTE_SDK" => Some(Self::FlyteSdk), + "UNION_SDK" => Some(Self::UnionSdk), + _ => None, + } + } + } +} +/// Specifies sort ordering in a list request. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Sort { + /// Indicates an attribute to sort the response values. + /// +required + #[prost(string, tag="1")] + pub key: ::prost::alloc::string::String, + /// Indicates the direction to apply sort key for response values. + /// +optional + #[prost(enumeration="sort::Direction", tag="2")] + pub direction: i32, +} +/// Nested message and enum types in `Sort`. +pub mod sort { + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum Direction { + /// By default, fields are sorted in descending order. + Descending = 0, + Ascending = 1, + } + impl Direction { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Direction::Descending => "DESCENDING", + Direction::Ascending => "ASCENDING", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "DESCENDING" => Some(Self::Descending), + "ASCENDING" => Some(Self::Ascending), + _ => None, + } + } + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListRequest { + /// Indicates the number of resources to be returned. + /// +required + #[prost(uint32, tag="1")] + pub limit: u32, + /// In the case of multiple pages of results, the server-provided token can be used to fetch the next page + /// in a query. + /// +optional + #[prost(string, tag="2")] + pub token: ::prost::alloc::string::String, + /// Deprecated, use sort_by_fields instead. + /// Specifies how listed entities should be sorted in the response. + /// +optional + #[deprecated] + #[prost(message, optional, tag="3")] + pub sort_by: ::core::option::Option, + /// Indicates a list of filters. This field is used for grpc get requests. + /// +optional + #[prost(message, repeated, tag="4")] + pub filters: ::prost::alloc::vec::Vec, + /// Indicates a raw list of filters passed as string.This field is used for REST get requests + /// +optional + #[prost(string, repeated, tag="5")] + pub raw_filters: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Specifies how listed entities should be sorted in the response. + /// Sort fields are applied in order. + /// +optional + #[prost(message, repeated, tag="6")] + pub sort_by_fields: ::prost::alloc::vec::Vec, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Filter { + #[prost(enumeration="filter::Function", tag="1")] + pub function: i32, + /// e.g. name or version + #[prost(string, tag="2")] + pub field: ::prost::alloc::string::String, + /// Only in the case of a VALUE_IN function, values may contain multiple entries. + #[prost(string, repeated, tag="3")] + pub values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +/// Nested message and enum types in `Filter`. +pub mod filter { + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum Function { + Equal = 0, + NotEqual = 1, + GreaterThan = 2, + GreaterThanOrEqual = 3, + LessThan = 4, + LessThanOrEqual = 5, + /// Case sensitive contains function. + Contains = 6, + ValueIn = 7, + // NOT_CONTAINS = 8; + // VALUE_NOT_IN = 9; + // STARTS_WITH = 10; + // NOT_STARTS_WITH = 11; + + EndsWith = 12, + NotEndsWith = 13, + /// Case insensitive contains function. + ContainsCaseInsensitive = 14, + } + impl Function { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Function::Equal => "EQUAL", + Function::NotEqual => "NOT_EQUAL", + Function::GreaterThan => "GREATER_THAN", + Function::GreaterThanOrEqual => "GREATER_THAN_OR_EQUAL", + Function::LessThan => "LESS_THAN", + Function::LessThanOrEqual => "LESS_THAN_OR_EQUAL", + Function::Contains => "CONTAINS", + Function::ValueIn => "VALUE_IN", + Function::EndsWith => "ENDS_WITH", + Function::NotEndsWith => "NOT_ENDS_WITH", + Function::ContainsCaseInsensitive => "CONTAINS_CASE_INSENSITIVE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "EQUAL" => Some(Self::Equal), + "NOT_EQUAL" => Some(Self::NotEqual), + "GREATER_THAN" => Some(Self::GreaterThan), + "GREATER_THAN_OR_EQUAL" => Some(Self::GreaterThanOrEqual), + "LESS_THAN" => Some(Self::LessThan), + "LESS_THAN_OR_EQUAL" => Some(Self::LessThanOrEqual), + "CONTAINS" => Some(Self::Contains), + "VALUE_IN" => Some(Self::ValueIn), + "ENDS_WITH" => Some(Self::EndsWith), + "NOT_ENDS_WITH" => Some(Self::NotEndsWith), + "CONTAINS_CASE_INSENSITIVE" => Some(Self::ContainsCaseInsensitive), + _ => None, + } + } + } +} +/// The source of an attribute. We may have other sources in the future. +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum AttributesSource { + /// The source is unspecified. + SourceUnspecified = 0, + /// The configuration is a global configuration. + Global = 1, + /// The configuration is a domain configuration. + Domain = 2, + /// The configuration is a project configuration. + Project = 3, + /// The configuration is a project-domain configuration. + ProjectDomain = 4, + /// The configuration is a org configuration. + Org = 5, +} +impl AttributesSource { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + AttributesSource::SourceUnspecified => "SOURCE_UNSPECIFIED", + AttributesSource::Global => "GLOBAL", + AttributesSource::Domain => "DOMAIN", + AttributesSource::Project => "PROJECT", + AttributesSource::ProjectDomain => "PROJECT_DOMAIN", + AttributesSource::Org => "ORG", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "SOURCE_UNSPECIFIED" => Some(Self::SourceUnspecified), + "GLOBAL" => Some(Self::Global), + "DOMAIN" => Some(Self::Domain), + "PROJECT" => Some(Self::Project), + "PROJECT_DOMAIN" => Some(Self::ProjectDomain), + "ORG" => Some(Self::Org), + _ => None, + } + } +} +/// ActionPhase represents the execution state of an action. +/// +/// Phase transitions follow this typical flow: +/// QUEUED -> WAITING_FOR_RESOURCES -> INITIALIZING -> RUNNING -> {SUCCEEDED|FAILED|ABORTED|TIMED_OUT} +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ActionPhase { + /// Default/unknown phase + Unspecified = 0, + /// Action has been accepted and is waiting to be scheduled + Queued = 1, + /// Action is scheduled but waiting for compute resources to become available + WaitingForResources = 2, + /// Resources have been allocated and the action is being set up + Initializing = 3, + /// Action is actively executing + Running = 4, + /// Action completed successfully + Succeeded = 5, + /// Action failed during execution + Failed = 6, + /// Action was manually terminated or cancelled + Aborted = 7, + /// Action exceeded its execution time limit + TimedOut = 8, +} +impl ActionPhase { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ActionPhase::Unspecified => "ACTION_PHASE_UNSPECIFIED", + ActionPhase::Queued => "ACTION_PHASE_QUEUED", + ActionPhase::WaitingForResources => "ACTION_PHASE_WAITING_FOR_RESOURCES", + ActionPhase::Initializing => "ACTION_PHASE_INITIALIZING", + ActionPhase::Running => "ACTION_PHASE_RUNNING", + ActionPhase::Succeeded => "ACTION_PHASE_SUCCEEDED", + ActionPhase::Failed => "ACTION_PHASE_FAILED", + ActionPhase::Aborted => "ACTION_PHASE_ABORTED", + ActionPhase::TimedOut => "ACTION_PHASE_TIMED_OUT", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ACTION_PHASE_UNSPECIFIED" => Some(Self::Unspecified), + "ACTION_PHASE_QUEUED" => Some(Self::Queued), + "ACTION_PHASE_WAITING_FOR_RESOURCES" => Some(Self::WaitingForResources), + "ACTION_PHASE_INITIALIZING" => Some(Self::Initializing), + "ACTION_PHASE_RUNNING" => Some(Self::Running), + "ACTION_PHASE_SUCCEEDED" => Some(Self::Succeeded), + "ACTION_PHASE_FAILED" => Some(Self::Failed), + "ACTION_PHASE_ABORTED" => Some(Self::Aborted), + "ACTION_PHASE_TIMED_OUT" => Some(Self::TimedOut), + _ => None, + } + } +} +/// Encoded file descriptor set for the `flyteidl2.common` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xf0, 0x32, 0x0a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x7e, 0x0a, 0x11, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x2b, 0x0a, 0x0c, 0x6f, 0x72, + 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, + 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1f, 0x0a, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, + 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, + 0x52, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x54, 0x0a, 0x11, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x22, 0x0a, 0x0c, 0x6f, 0x72, + 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1b, + 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, + 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x4f, 0x0a, 0x15, 0x43, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x50, 0x6f, 0x6f, 0x6c, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x12, 0x22, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, 0x72, 0x67, 0x61, + 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x5f, 0x0a, 0x17, + 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x2b, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, + 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, + 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x17, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x02, 0x69, 0x64, 0x22, 0x88, 0x01, + 0x0a, 0x19, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x70, 0x6f, 0x6f, + 0x6c, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x22, 0x0a, 0x0c, 0x6f, + 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x2a, 0x0a, 0x0c, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x0b, + 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1b, 0x0a, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, + 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x33, 0x0a, 0x0e, 0x55, 0x73, 0x65, 0x72, + 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x21, 0x0a, 0x07, 0x73, 0x75, + 0x62, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, + 0x72, 0x02, 0x10, 0x01, 0x52, 0x07, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x3a, 0x0a, + 0x15, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x21, 0x0a, 0x07, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, + 0x52, 0x07, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x51, 0x0a, 0x0e, 0x52, 0x6f, 0x6c, + 0x65, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x22, 0x0a, 0x0c, 0x6f, + 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, + 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x4f, 0x0a, 0x0d, + 0x4f, 0x72, 0x67, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x3e, 0x0a, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x2a, 0xba, 0x48, 0x27, + 0x72, 0x25, 0x10, 0x01, 0x18, 0x3f, 0x32, 0x1f, 0x5e, 0x5b, 0x61, 0x2d, 0x7a, 0x30, 0x2d, 0x39, + 0x5d, 0x28, 0x5b, 0x2d, 0x61, 0x2d, 0x7a, 0x30, 0x2d, 0x39, 0x5d, 0x2a, 0x5b, 0x61, 0x2d, 0x7a, + 0x30, 0x2d, 0x39, 0x5d, 0x29, 0x3f, 0x24, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x78, 0x0a, + 0x18, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, + 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x39, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4f, 0x72, 0x67, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x03, 0x6f, 0x72, + 0x67, 0x4a, 0x04, 0x08, 0x01, 0x10, 0x02, 0x22, 0x53, 0x0a, 0x10, 0x50, 0x6f, 0x6c, 0x69, 0x63, + 0x79, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x22, 0x0a, 0x0c, 0x6f, + 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, + 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x93, 0x01, 0x0a, + 0x0d, 0x52, 0x75, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x1b, + 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, + 0x72, 0x04, 0x10, 0x01, 0x18, 0x3f, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x23, 0x0a, 0x07, 0x70, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, + 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x3f, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x12, 0x21, 0x0a, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x3f, 0x52, 0x06, 0x64, 0x6f, 0x6d, + 0x61, 0x69, 0x6e, 0x12, 0x1d, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x1e, 0x52, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x22, 0x6c, 0x0a, 0x10, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x39, 0x0a, 0x03, 0x72, 0x75, 0x6e, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x75, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x03, 0x72, 0x75, + 0x6e, 0x12, 0x1d, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, + 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x1e, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x22, 0x85, 0x01, 0x0a, 0x17, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x74, 0x74, 0x65, 0x6d, + 0x70, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x47, 0x0a, 0x09, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x07, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, 0x02, 0x20, 0x00, 0x52, + 0x07, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x22, 0xbb, 0x01, 0x0a, 0x0b, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1b, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x3f, + 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x23, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, + 0x3f, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x21, 0x0a, 0x06, 0x64, 0x6f, + 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, + 0x04, 0x10, 0x01, 0x18, 0x3f, 0x52, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x1e, 0x0a, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0a, 0xba, 0x48, 0x07, + 0x72, 0x05, 0x10, 0x01, 0x18, 0xff, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x27, 0x0a, + 0x09, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, + 0x42, 0x0a, 0xba, 0x48, 0x07, 0x72, 0x05, 0x10, 0x01, 0x18, 0xff, 0x01, 0x52, 0x08, 0x74, 0x61, + 0x73, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x73, 0x0a, 0x11, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x39, 0x0a, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, + 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, + 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x42, 0x07, 0xba, 0x48, 0x04, 0x32, 0x02, 0x20, + 0x00, 0x52, 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0xbe, 0x01, 0x0a, 0x14, + 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x42, 0x0f, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xa2, 0x02, 0x03, + 0x46, 0x43, 0x58, 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xca, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xe2, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x5c, 0x47, 0x50, 0x42, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x4a, 0x9c, 0x23, 0x0a, + 0x07, 0x12, 0x05, 0x00, 0x00, 0x9b, 0x01, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, + 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x19, 0x0a, 0x09, 0x0a, 0x02, + 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x25, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x06, 0x00, + 0x4b, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x06, 0x00, 0x4b, 0x0a, 0x0a, 0x0a, 0x02, + 0x04, 0x00, 0x12, 0x04, 0x08, 0x00, 0x0c, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, + 0x03, 0x08, 0x08, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x09, 0x02, + 0x44, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x09, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x09, 0x09, 0x15, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x09, 0x18, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x00, 0x08, 0x12, 0x03, 0x09, 0x1a, 0x43, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, + 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x09, 0x1b, 0x42, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x01, 0x12, 0x03, 0x0a, 0x02, 0x3e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, + 0x05, 0x12, 0x03, 0x0a, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x0a, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x0a, + 0x12, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x08, 0x12, 0x03, 0x0a, 0x14, 0x3d, + 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x0a, + 0x15, 0x3c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x0b, 0x02, 0x3c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x0b, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x0b, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x0b, 0x10, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x02, 0x08, 0x12, 0x03, 0x0b, 0x12, 0x3b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x02, 0x08, + 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x0b, 0x13, 0x3a, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, + 0x04, 0x0e, 0x00, 0x11, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x0e, 0x08, + 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x0f, 0x02, 0x1a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x0f, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0f, 0x09, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x0f, 0x18, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, + 0x12, 0x03, 0x10, 0x02, 0x3c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, + 0x10, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x10, 0x09, + 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x10, 0x10, 0x11, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x08, 0x12, 0x03, 0x10, 0x12, 0x3b, 0x0a, 0x10, 0x0a, + 0x09, 0x04, 0x01, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x10, 0x13, 0x3a, 0x0a, + 0x0a, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x13, 0x00, 0x16, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x02, 0x01, 0x12, 0x03, 0x13, 0x08, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, + 0x03, 0x14, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, 0x14, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x14, 0x09, 0x15, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x14, 0x18, 0x19, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x15, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x01, 0x05, 0x12, 0x03, 0x15, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x15, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x15, 0x10, 0x11, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x18, 0x00, 0x1b, + 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x18, 0x08, 0x1f, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x19, 0x02, 0x44, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x00, 0x05, 0x12, 0x03, 0x19, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x19, 0x09, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x19, 0x18, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x08, 0x12, 0x03, 0x19, + 0x1a, 0x43, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x03, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, + 0x03, 0x19, 0x1b, 0x42, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, 0x1a, 0x02, + 0x3a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x05, 0x12, 0x03, 0x1a, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, 0x1a, 0x09, 0x0b, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x1a, 0x0e, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x01, 0x08, 0x12, 0x03, 0x1a, 0x10, 0x39, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x03, 0x02, + 0x01, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x1a, 0x11, 0x38, 0x0a, 0x0a, 0x0a, 0x02, 0x04, + 0x04, 0x12, 0x04, 0x1d, 0x00, 0x21, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, + 0x1d, 0x08, 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x1e, 0x02, 0x1a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x05, 0x12, 0x03, 0x1e, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1e, 0x09, 0x15, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1e, 0x18, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, + 0x02, 0x01, 0x12, 0x03, 0x1f, 0x02, 0x44, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x05, + 0x12, 0x03, 0x1f, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x1f, 0x09, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x1f, 0x18, + 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x08, 0x12, 0x03, 0x1f, 0x1a, 0x43, 0x0a, + 0x10, 0x0a, 0x09, 0x04, 0x04, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x1f, 0x1b, + 0x42, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x02, 0x12, 0x03, 0x20, 0x02, 0x3c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x05, 0x12, 0x03, 0x20, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x20, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x02, 0x03, 0x12, 0x03, 0x20, 0x10, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, + 0x08, 0x12, 0x03, 0x20, 0x12, 0x3b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x04, 0x02, 0x02, 0x08, 0x87, + 0x09, 0x0e, 0x02, 0x12, 0x03, 0x20, 0x13, 0x3a, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, + 0x23, 0x00, 0x25, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x23, 0x08, 0x16, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x24, 0x02, 0x3f, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x00, 0x05, 0x12, 0x03, 0x24, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x24, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x24, 0x13, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x08, + 0x12, 0x03, 0x24, 0x15, 0x3e, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x05, 0x02, 0x00, 0x08, 0x87, 0x09, + 0x0e, 0x02, 0x12, 0x03, 0x24, 0x16, 0x3d, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x04, 0x27, + 0x00, 0x29, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x03, 0x27, 0x08, 0x1d, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x03, 0x28, 0x02, 0x3f, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x00, 0x05, 0x12, 0x03, 0x28, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x28, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x28, 0x13, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x08, 0x12, + 0x03, 0x28, 0x15, 0x3e, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x06, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, + 0x02, 0x12, 0x03, 0x28, 0x16, 0x3d, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x04, 0x2b, 0x00, + 0x30, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x03, 0x2b, 0x08, 0x16, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x03, 0x2c, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x00, 0x05, 0x12, 0x03, 0x2c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x2c, 0x09, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x2c, 0x18, 0x19, 0x0a, 0x40, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x01, 0x12, 0x03, 0x2f, + 0x02, 0x3c, 0x1a, 0x33, 0x20, 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x72, 0x6f, 0x6c, 0x65, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, + 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x05, + 0x12, 0x03, 0x2f, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x2f, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, 0x03, 0x2f, 0x10, + 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x08, 0x12, 0x03, 0x2f, 0x12, 0x3b, 0x0a, + 0x10, 0x0a, 0x09, 0x04, 0x07, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x2f, 0x13, + 0x3a, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x04, 0x32, 0x00, 0x38, 0x01, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x08, 0x01, 0x12, 0x03, 0x32, 0x08, 0x15, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x08, 0x02, + 0x00, 0x12, 0x04, 0x33, 0x02, 0x37, 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x05, + 0x12, 0x03, 0x33, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x33, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x03, 0x33, 0x10, + 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x08, 0x12, 0x04, 0x33, 0x12, 0x37, 0x04, + 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x08, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x12, 0x04, 0x33, 0x13, + 0x37, 0x03, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x08, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, + 0x03, 0x34, 0x04, 0x0e, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x08, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, + 0x03, 0x12, 0x03, 0x35, 0x04, 0x0f, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x08, 0x02, 0x00, 0x08, 0x87, + 0x09, 0x0e, 0x06, 0x12, 0x03, 0x36, 0x04, 0x2e, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x09, 0x12, 0x04, + 0x3a, 0x00, 0x3e, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, 0x03, 0x3a, 0x08, 0x20, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x09, 0x09, 0x12, 0x03, 0x3b, 0x02, 0x0d, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x09, 0x09, 0x00, 0x12, 0x03, 0x3b, 0x0b, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x09, + 0x00, 0x01, 0x12, 0x03, 0x3b, 0x0b, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x09, 0x00, 0x02, + 0x12, 0x03, 0x3b, 0x0b, 0x0c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x00, 0x12, 0x03, 0x3c, + 0x02, 0x3c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x05, 0x12, 0x03, 0x3c, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x03, 0x3c, 0x09, 0x0d, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, 0x03, 0x3c, 0x10, 0x11, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x09, 0x02, 0x00, 0x08, 0x12, 0x03, 0x3c, 0x12, 0x3b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x09, + 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x3c, 0x13, 0x3a, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x09, 0x02, 0x01, 0x12, 0x03, 0x3d, 0x02, 0x3f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, + 0x01, 0x06, 0x12, 0x03, 0x3d, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x3d, 0x10, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x3d, 0x16, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x08, 0x12, 0x03, 0x3d, 0x18, + 0x3e, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x09, 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x3d, + 0x19, 0x3d, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x04, 0x40, 0x00, 0x45, 0x01, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x0a, 0x01, 0x12, 0x03, 0x40, 0x08, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x0a, + 0x02, 0x00, 0x12, 0x03, 0x41, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x05, + 0x12, 0x03, 0x41, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x41, 0x09, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, 0x03, 0x41, 0x18, + 0x19, 0x0a, 0x42, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x01, 0x12, 0x03, 0x44, 0x02, 0x3c, 0x1a, 0x35, + 0x20, 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x05, 0x12, 0x03, + 0x44, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x01, 0x12, 0x03, 0x44, 0x09, + 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x03, 0x12, 0x03, 0x44, 0x10, 0x11, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x08, 0x12, 0x03, 0x44, 0x12, 0x3b, 0x0a, 0x10, 0x0a, + 0x09, 0x04, 0x0a, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x44, 0x13, 0x3a, 0x0a, + 0x29, 0x0a, 0x02, 0x04, 0x0b, 0x12, 0x04, 0x48, 0x00, 0x60, 0x01, 0x1a, 0x1d, 0x20, 0x55, 0x6e, + 0x69, 0x71, 0x75, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, + 0x6f, 0x66, 0x20, 0x61, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x0b, + 0x01, 0x12, 0x03, 0x48, 0x08, 0x15, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x00, 0x12, 0x04, + 0x4a, 0x02, 0x4d, 0x04, 0x1a, 0x1a, 0x20, 0x4f, 0x72, 0x67, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x72, 0x75, 0x6e, 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x05, 0x12, 0x03, 0x4a, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x01, 0x12, 0x03, 0x4a, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x0b, 0x02, 0x00, 0x03, 0x12, 0x03, 0x4a, 0x0f, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, + 0x02, 0x00, 0x08, 0x12, 0x04, 0x4a, 0x11, 0x4d, 0x03, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x0b, 0x02, + 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x4b, 0x04, 0x2b, 0x0a, 0x10, 0x0a, 0x09, 0x04, + 0x0b, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x03, 0x12, 0x03, 0x4c, 0x04, 0x2c, 0x0a, 0x2c, 0x0a, + 0x04, 0x04, 0x0b, 0x02, 0x01, 0x12, 0x04, 0x50, 0x02, 0x53, 0x04, 0x1a, 0x1e, 0x20, 0x50, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x62, + 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x0b, 0x02, 0x01, 0x05, 0x12, 0x03, 0x50, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x50, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x50, 0x13, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x08, 0x12, 0x04, + 0x50, 0x15, 0x53, 0x03, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x0b, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, + 0x02, 0x12, 0x03, 0x51, 0x04, 0x2b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x0b, 0x02, 0x01, 0x08, 0x87, + 0x09, 0x0e, 0x03, 0x12, 0x03, 0x52, 0x04, 0x2c, 0x0a, 0x2b, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x02, + 0x12, 0x04, 0x56, 0x02, 0x59, 0x04, 0x1a, 0x1d, 0x20, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x73, + 0x20, 0x74, 0x6f, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x02, 0x05, 0x12, 0x03, + 0x56, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x02, 0x01, 0x12, 0x03, 0x56, 0x09, + 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x02, 0x03, 0x12, 0x03, 0x56, 0x12, 0x13, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x02, 0x08, 0x12, 0x04, 0x56, 0x14, 0x59, 0x03, 0x0a, 0x10, + 0x0a, 0x09, 0x04, 0x0b, 0x02, 0x02, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x57, 0x04, 0x2b, + 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x0b, 0x02, 0x02, 0x08, 0x87, 0x09, 0x0e, 0x03, 0x12, 0x03, 0x58, + 0x04, 0x2c, 0x0a, 0x69, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x03, 0x12, 0x04, 0x5c, 0x02, 0x5f, 0x04, + 0x1a, 0x5b, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, + 0x75, 0x6e, 0x2e, 0x20, 0x4d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, + 0x75, 0x65, 0x20, 0x61, 0x63, 0x72, 0x6f, 0x73, 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x72, 0x75, + 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6f, 0x72, 0x67, 0x2c, 0x20, + 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x64, 0x6f, 0x6d, + 0x61, 0x69, 0x6e, 0x20, 0x70, 0x61, 0x69, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x0b, 0x02, 0x03, 0x05, 0x12, 0x03, 0x5c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x0b, 0x02, 0x03, 0x01, 0x12, 0x03, 0x5c, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, + 0x03, 0x03, 0x12, 0x03, 0x5c, 0x10, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x03, 0x08, + 0x12, 0x04, 0x5c, 0x12, 0x5f, 0x03, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x0b, 0x02, 0x03, 0x08, 0x87, + 0x09, 0x0e, 0x02, 0x12, 0x03, 0x5d, 0x04, 0x2b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x0b, 0x02, 0x03, + 0x08, 0x87, 0x09, 0x0e, 0x03, 0x12, 0x03, 0x5e, 0x04, 0x2c, 0x0a, 0x2d, 0x0a, 0x02, 0x04, 0x0c, + 0x12, 0x04, 0x63, 0x00, 0x6c, 0x01, 0x1a, 0x21, 0x20, 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, + 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, + 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x0c, 0x01, + 0x12, 0x03, 0x63, 0x08, 0x18, 0x0a, 0x26, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x00, 0x12, 0x03, 0x65, + 0x02, 0x3f, 0x1a, 0x19, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x0c, 0x02, 0x00, 0x06, 0x12, 0x03, 0x65, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x0c, 0x02, 0x00, 0x01, 0x12, 0x03, 0x65, 0x10, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x65, 0x16, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x08, + 0x12, 0x03, 0x65, 0x18, 0x3e, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x0c, 0x02, 0x00, 0x08, 0x87, 0x09, + 0x19, 0x12, 0x03, 0x65, 0x19, 0x3d, 0x0a, 0x42, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x01, 0x12, 0x04, + 0x68, 0x02, 0x6b, 0x04, 0x1a, 0x34, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x4d, 0x75, 0x73, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, + 0x02, 0x01, 0x05, 0x12, 0x03, 0x68, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x68, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x68, 0x10, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x08, 0x12, 0x04, 0x68, + 0x12, 0x6b, 0x03, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x0c, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, 0x02, + 0x12, 0x03, 0x69, 0x04, 0x2b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x0c, 0x02, 0x01, 0x08, 0x87, 0x09, + 0x0e, 0x03, 0x12, 0x03, 0x6a, 0x04, 0x2c, 0x0a, 0x3a, 0x0a, 0x02, 0x04, 0x0d, 0x12, 0x04, 0x6f, + 0x00, 0x73, 0x01, 0x1a, 0x2e, 0x20, 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x69, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6e, + 0x67, 0x6c, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, + 0x70, 0x74, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x0d, 0x01, 0x12, 0x03, 0x6f, 0x08, 0x1f, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x00, 0x12, 0x03, 0x70, 0x02, 0x48, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x0d, 0x02, 0x00, 0x06, 0x12, 0x03, 0x70, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x70, 0x13, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x70, 0x1f, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x08, 0x12, + 0x03, 0x70, 0x21, 0x47, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x0d, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, + 0x12, 0x03, 0x70, 0x22, 0x46, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x01, 0x12, 0x03, 0x72, + 0x02, 0x3a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x05, 0x12, 0x03, 0x72, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x01, 0x12, 0x03, 0x72, 0x09, 0x10, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x03, 0x12, 0x03, 0x72, 0x13, 0x14, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x0d, 0x02, 0x01, 0x08, 0x12, 0x03, 0x72, 0x15, 0x39, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x0d, + 0x02, 0x01, 0x08, 0x87, 0x09, 0x05, 0x04, 0x12, 0x03, 0x72, 0x16, 0x38, 0x0a, 0x43, 0x0a, 0x02, + 0x04, 0x0e, 0x12, 0x05, 0x76, 0x00, 0x93, 0x01, 0x01, 0x1a, 0x36, 0x20, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x67, 0x2c, 0x20, 0x70, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, + 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x0e, 0x01, 0x12, 0x03, 0x76, 0x08, 0x13, 0x0a, 0x2c, 0x0a, + 0x04, 0x04, 0x0e, 0x02, 0x00, 0x12, 0x04, 0x78, 0x02, 0x7b, 0x04, 0x1a, 0x1e, 0x20, 0x4f, 0x72, + 0x67, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x62, + 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x00, 0x05, 0x12, 0x03, 0x78, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x78, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x78, 0x0f, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x08, 0x12, 0x04, + 0x78, 0x11, 0x7b, 0x03, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x0e, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, + 0x02, 0x12, 0x03, 0x79, 0x04, 0x2b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x0e, 0x02, 0x00, 0x08, 0x87, + 0x09, 0x0e, 0x03, 0x12, 0x03, 0x7a, 0x04, 0x2c, 0x0a, 0x31, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x01, + 0x12, 0x05, 0x7e, 0x02, 0x81, 0x01, 0x04, 0x1a, 0x22, 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x62, + 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x01, 0x05, 0x12, 0x03, 0x7e, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x7e, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x7e, 0x13, 0x14, 0x0a, 0x0e, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x08, 0x12, 0x05, + 0x7e, 0x15, 0x81, 0x01, 0x03, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x0e, 0x02, 0x01, 0x08, 0x87, 0x09, + 0x0e, 0x02, 0x12, 0x03, 0x7f, 0x04, 0x2b, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x0e, 0x02, 0x01, 0x08, + 0x87, 0x09, 0x0e, 0x03, 0x12, 0x04, 0x80, 0x01, 0x04, 0x2c, 0x0a, 0x31, 0x0a, 0x04, 0x04, 0x0e, + 0x02, 0x02, 0x12, 0x06, 0x84, 0x01, 0x02, 0x87, 0x01, 0x04, 0x1a, 0x21, 0x20, 0x44, 0x6f, 0x6d, + 0x61, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x02, 0x05, 0x12, 0x04, 0x84, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x02, 0x01, 0x12, 0x04, 0x84, 0x01, 0x09, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x02, 0x03, 0x12, 0x04, 0x84, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x02, 0x08, 0x12, 0x06, 0x84, 0x01, 0x14, 0x87, 0x01, 0x03, 0x0a, 0x11, 0x0a, 0x09, 0x04, + 0x0e, 0x02, 0x02, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x04, 0x85, 0x01, 0x04, 0x2b, 0x0a, 0x11, + 0x0a, 0x09, 0x04, 0x0e, 0x02, 0x02, 0x08, 0x87, 0x09, 0x0e, 0x03, 0x12, 0x04, 0x86, 0x01, 0x04, + 0x2c, 0x0a, 0x2d, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x03, 0x12, 0x06, 0x8a, 0x01, 0x02, 0x8d, 0x01, + 0x04, 0x1a, 0x1d, 0x20, 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x05, 0x12, 0x04, 0x8a, 0x01, 0x02, 0x08, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x01, 0x12, 0x04, 0x8a, 0x01, 0x09, 0x0d, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x03, 0x12, 0x04, 0x8a, 0x01, 0x10, 0x11, 0x0a, 0x0f, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x03, 0x08, 0x12, 0x06, 0x8a, 0x01, 0x12, 0x8d, 0x01, 0x03, 0x0a, 0x11, + 0x0a, 0x09, 0x04, 0x0e, 0x02, 0x03, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x04, 0x8b, 0x01, 0x04, + 0x2b, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x0e, 0x02, 0x03, 0x08, 0x87, 0x09, 0x0e, 0x03, 0x12, 0x04, + 0x8c, 0x01, 0x04, 0x2d, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x04, 0x12, 0x06, 0x8f, 0x01, + 0x02, 0x92, 0x01, 0x04, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x04, 0x05, 0x12, 0x04, 0x8f, + 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x04, 0x01, 0x12, 0x04, 0x8f, 0x01, + 0x09, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x04, 0x03, 0x12, 0x04, 0x8f, 0x01, 0x15, + 0x16, 0x0a, 0x0f, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x04, 0x08, 0x12, 0x06, 0x8f, 0x01, 0x17, 0x92, + 0x01, 0x03, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x0e, 0x02, 0x04, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, + 0x04, 0x90, 0x01, 0x04, 0x2b, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x0e, 0x02, 0x04, 0x08, 0x87, 0x09, + 0x0e, 0x03, 0x12, 0x04, 0x91, 0x01, 0x04, 0x2d, 0x0a, 0x4f, 0x0a, 0x02, 0x04, 0x0f, 0x12, 0x06, + 0x96, 0x01, 0x00, 0x9b, 0x01, 0x01, 0x1a, 0x41, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x61, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x72, 0x65, + 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x61, 0x6e, + 0x20, 0x6f, 0x72, 0x67, 0x2c, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0f, 0x01, + 0x12, 0x04, 0x96, 0x01, 0x08, 0x19, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x00, 0x12, 0x04, + 0x97, 0x01, 0x02, 0x3e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x06, 0x12, 0x04, 0x97, + 0x01, 0x02, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x01, 0x12, 0x04, 0x97, 0x01, + 0x0e, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x03, 0x12, 0x04, 0x97, 0x01, 0x15, + 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x08, 0x12, 0x04, 0x97, 0x01, 0x17, 0x3d, + 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x0f, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x04, 0x97, 0x01, + 0x18, 0x3c, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x01, 0x12, 0x04, 0x9a, 0x01, 0x02, 0x3b, + 0x1a, 0x1a, 0x20, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0f, 0x02, 0x01, 0x05, 0x12, 0x04, 0x9a, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0f, 0x02, 0x01, 0x01, 0x12, 0x04, 0x9a, 0x01, 0x09, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, + 0x02, 0x01, 0x03, 0x12, 0x04, 0x9a, 0x01, 0x14, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, + 0x01, 0x08, 0x12, 0x04, 0x9a, 0x01, 0x16, 0x3a, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x0f, 0x02, 0x01, + 0x08, 0x87, 0x09, 0x06, 0x04, 0x12, 0x04, 0x9a, 0x01, 0x17, 0x39, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, 0x0a, 0xbb, 0x26, 0x0a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, + 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x1a, 0x1b, + 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x2b, + 0x0a, 0x0c, 0x4f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1b, + 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, + 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x68, 0x0a, 0x06, 0x44, + 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x4a, 0x0a, 0x0c, 0x6f, 0x72, 0x67, + 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x4f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, + 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x60, 0x0a, 0x07, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, + 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x38, 0x0a, + 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, + 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x22, 0x64, 0x0a, 0x08, 0x57, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x12, 0x3b, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x42, 0x06, 0xba, 0x48, + 0x03, 0xc8, 0x01, 0x01, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x66, 0x0a, + 0x0a, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x50, 0x6c, 0x61, 0x6e, 0x12, 0x1b, 0x0a, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, + 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3b, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x50, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x07, 0x70, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x83, 0x03, 0x0a, 0x08, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x12, 0x44, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4f, 0x72, 0x67, 0x61, + 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0c, 0x6f, 0x72, 0x67, 0x61, + 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x32, 0x0a, 0x06, 0x64, 0x6f, 0x6d, 0x61, + 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x44, 0x6f, 0x6d, 0x61, + 0x69, 0x6e, 0x48, 0x00, 0x52, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x35, 0x0a, 0x07, + 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x48, 0x00, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x12, 0x38, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x48, 0x00, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x3f, 0x0a, + 0x0b, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x70, 0x6c, 0x61, 0x6e, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x50, 0x6c, 0x61, 0x6e, + 0x48, 0x00, 0x52, 0x0a, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x50, 0x6c, 0x61, 0x6e, 0x12, 0x3f, + 0x0a, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x42, + 0x0a, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x22, 0x78, 0x0a, 0x0a, 0x50, + 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x36, 0x0a, 0x08, 0x72, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x08, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x12, 0x32, 0x0a, 0x07, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, + 0x28, 0x0e, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x61, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2a, 0x94, 0x04, 0x0a, 0x06, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x0f, 0x0a, 0x0b, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, + 0x00, 0x12, 0x15, 0x0a, 0x0d, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x52, 0x45, 0x41, + 0x54, 0x45, 0x10, 0x01, 0x1a, 0x02, 0x08, 0x01, 0x12, 0x13, 0x0a, 0x0b, 0x41, 0x43, 0x54, 0x49, + 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x41, 0x44, 0x10, 0x02, 0x1a, 0x02, 0x08, 0x01, 0x12, 0x15, 0x0a, + 0x0d, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x03, + 0x1a, 0x02, 0x08, 0x01, 0x12, 0x15, 0x0a, 0x0d, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, + 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x04, 0x1a, 0x02, 0x08, 0x01, 0x12, 0x1f, 0x0a, 0x1b, 0x41, + 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x56, 0x49, 0x45, 0x57, 0x5f, 0x46, 0x4c, 0x59, 0x54, 0x45, + 0x5f, 0x49, 0x4e, 0x56, 0x45, 0x4e, 0x54, 0x4f, 0x52, 0x59, 0x10, 0x05, 0x12, 0x20, 0x0a, 0x1c, + 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x56, 0x49, 0x45, 0x57, 0x5f, 0x46, 0x4c, 0x59, 0x54, + 0x45, 0x5f, 0x45, 0x58, 0x45, 0x43, 0x55, 0x54, 0x49, 0x4f, 0x4e, 0x53, 0x10, 0x06, 0x12, 0x23, + 0x0a, 0x1f, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x47, 0x49, 0x53, 0x54, 0x45, + 0x52, 0x5f, 0x46, 0x4c, 0x59, 0x54, 0x45, 0x5f, 0x49, 0x4e, 0x56, 0x45, 0x4e, 0x54, 0x4f, 0x52, + 0x59, 0x10, 0x07, 0x12, 0x22, 0x0a, 0x1e, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x52, + 0x45, 0x41, 0x54, 0x45, 0x5f, 0x46, 0x4c, 0x59, 0x54, 0x45, 0x5f, 0x45, 0x58, 0x45, 0x43, 0x55, + 0x54, 0x49, 0x4f, 0x4e, 0x53, 0x10, 0x08, 0x12, 0x1d, 0x0a, 0x19, 0x41, 0x43, 0x54, 0x49, 0x4f, + 0x4e, 0x5f, 0x41, 0x44, 0x4d, 0x49, 0x4e, 0x49, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x50, 0x52, 0x4f, + 0x4a, 0x45, 0x43, 0x54, 0x10, 0x09, 0x12, 0x1d, 0x0a, 0x19, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, + 0x5f, 0x4d, 0x41, 0x4e, 0x41, 0x47, 0x45, 0x5f, 0x50, 0x45, 0x52, 0x4d, 0x49, 0x53, 0x53, 0x49, + 0x4f, 0x4e, 0x53, 0x10, 0x0a, 0x12, 0x1d, 0x0a, 0x19, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, + 0x41, 0x44, 0x4d, 0x49, 0x4e, 0x49, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x41, 0x43, 0x43, 0x4f, 0x55, + 0x4e, 0x54, 0x10, 0x0b, 0x12, 0x19, 0x0a, 0x15, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x4d, + 0x41, 0x4e, 0x41, 0x47, 0x45, 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x10, 0x0c, 0x12, + 0x2c, 0x0a, 0x28, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x44, 0x49, 0x54, 0x5f, 0x45, + 0x58, 0x45, 0x43, 0x55, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x45, 0x44, + 0x5f, 0x41, 0x54, 0x54, 0x52, 0x49, 0x42, 0x55, 0x54, 0x45, 0x53, 0x10, 0x0d, 0x12, 0x2a, 0x0a, + 0x26, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x44, 0x49, 0x54, 0x5f, 0x43, 0x4c, 0x55, + 0x53, 0x54, 0x45, 0x52, 0x5f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x41, 0x54, 0x54, + 0x52, 0x49, 0x42, 0x55, 0x54, 0x45, 0x53, 0x10, 0x0e, 0x12, 0x21, 0x0a, 0x1d, 0x41, 0x43, 0x54, + 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x44, 0x49, 0x54, 0x5f, 0x55, 0x4e, 0x55, 0x53, 0x45, 0x44, 0x5f, + 0x41, 0x54, 0x54, 0x52, 0x49, 0x42, 0x55, 0x54, 0x45, 0x53, 0x10, 0x0f, 0x12, 0x1e, 0x0a, 0x1a, + 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x53, 0x55, 0x50, 0x50, 0x4f, 0x52, 0x54, 0x5f, 0x53, + 0x59, 0x53, 0x54, 0x45, 0x4d, 0x5f, 0x4c, 0x4f, 0x47, 0x53, 0x10, 0x10, 0x42, 0xc1, 0x01, 0x0a, + 0x14, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x42, 0x12, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x34, 0x67, 0x69, 0x74, + 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, + 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, + 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xca, 0x02, 0x10, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xe2, 0x02, 0x1c, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x11, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x4a, 0x96, 0x18, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x5d, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, + 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x19, 0x0a, + 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, + 0x12, 0x03, 0x05, 0x00, 0x2b, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x07, 0x00, 0x4b, 0x0a, + 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x07, 0x00, 0x4b, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, + 0x12, 0x04, 0x09, 0x00, 0x0b, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x09, + 0x08, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0a, 0x02, 0x3c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x0a, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0a, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0a, 0x10, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x00, 0x08, 0x12, 0x03, 0x0a, 0x12, 0x3b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x00, 0x08, + 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x0a, 0x13, 0x3a, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, + 0x04, 0x0d, 0x00, 0x10, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x0d, 0x08, + 0x0e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x0e, 0x02, 0x12, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x0e, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0e, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x0e, 0x10, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, + 0x12, 0x03, 0x0f, 0x02, 0x47, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x06, 0x12, 0x03, + 0x0f, 0x02, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0f, 0x0f, + 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x0f, 0x1e, 0x1f, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x08, 0x12, 0x03, 0x0f, 0x20, 0x46, 0x0a, 0x0f, 0x0a, + 0x08, 0x04, 0x01, 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x0f, 0x21, 0x45, 0x0a, 0x0a, + 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x12, 0x00, 0x15, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, + 0x01, 0x12, 0x03, 0x12, 0x08, 0x0f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, + 0x13, 0x02, 0x3c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, 0x13, 0x02, + 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x13, 0x09, 0x0d, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x13, 0x10, 0x11, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x00, 0x08, 0x12, 0x03, 0x13, 0x12, 0x3b, 0x0a, 0x10, 0x0a, 0x09, 0x04, + 0x02, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x13, 0x13, 0x3a, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x14, 0x02, 0x3b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x01, 0x06, 0x12, 0x03, 0x14, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x14, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x14, 0x12, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x08, 0x12, 0x03, 0x14, + 0x14, 0x3a, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x02, 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, + 0x14, 0x15, 0x39, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x17, 0x00, 0x1a, 0x01, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x17, 0x08, 0x10, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x03, 0x02, 0x00, 0x12, 0x03, 0x18, 0x02, 0x3c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, + 0x05, 0x12, 0x03, 0x18, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x18, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x18, + 0x10, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x08, 0x12, 0x03, 0x18, 0x12, 0x3b, + 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x03, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x18, + 0x13, 0x3a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, 0x19, 0x02, 0x3d, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x06, 0x12, 0x03, 0x19, 0x02, 0x09, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, 0x19, 0x0a, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x19, 0x14, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x01, 0x08, 0x12, 0x03, 0x19, 0x16, 0x3c, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x03, 0x02, 0x01, 0x08, + 0x87, 0x09, 0x19, 0x12, 0x03, 0x19, 0x17, 0x3b, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, + 0x1c, 0x00, 0x1f, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x1c, 0x08, 0x12, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x1d, 0x02, 0x3c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x00, 0x05, 0x12, 0x03, 0x1d, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1d, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x1d, 0x10, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x08, + 0x12, 0x03, 0x1d, 0x12, 0x3b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x04, 0x02, 0x00, 0x08, 0x87, 0x09, + 0x0e, 0x02, 0x12, 0x03, 0x1d, 0x13, 0x3a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, + 0x03, 0x1e, 0x02, 0x3d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x06, 0x12, 0x03, 0x1e, + 0x02, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x1e, 0x0a, 0x11, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x1e, 0x14, 0x15, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x08, 0x12, 0x03, 0x1e, 0x16, 0x3c, 0x0a, 0x0f, 0x0a, 0x08, + 0x04, 0x04, 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x1e, 0x17, 0x3b, 0x0a, 0x0a, 0x0a, + 0x02, 0x04, 0x05, 0x12, 0x04, 0x21, 0x00, 0x2a, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, + 0x12, 0x03, 0x21, 0x08, 0x10, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x05, 0x08, 0x00, 0x12, 0x04, 0x22, + 0x02, 0x29, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x08, 0x00, 0x01, 0x12, 0x03, 0x22, 0x08, + 0x10, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x23, 0x04, 0x22, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x06, 0x12, 0x03, 0x23, 0x04, 0x10, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x23, 0x11, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x23, 0x20, 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, + 0x12, 0x03, 0x24, 0x04, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x06, 0x12, 0x03, + 0x24, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, 0x12, 0x03, 0x24, 0x0b, + 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x03, 0x24, 0x14, 0x15, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x02, 0x12, 0x03, 0x25, 0x04, 0x18, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x02, 0x06, 0x12, 0x03, 0x25, 0x04, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x25, 0x0c, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, + 0x03, 0x12, 0x03, 0x25, 0x16, 0x17, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x03, 0x12, 0x03, + 0x26, 0x04, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x06, 0x12, 0x03, 0x26, 0x04, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x01, 0x12, 0x03, 0x26, 0x0d, 0x15, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x03, 0x12, 0x03, 0x26, 0x18, 0x19, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x05, 0x02, 0x04, 0x12, 0x03, 0x27, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x04, 0x06, 0x12, 0x03, 0x27, 0x04, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, + 0x01, 0x12, 0x03, 0x27, 0x0f, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x03, 0x12, + 0x03, 0x27, 0x1d, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x05, 0x12, 0x03, 0x28, 0x04, + 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x05, 0x06, 0x12, 0x03, 0x28, 0x04, 0x15, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x05, 0x01, 0x12, 0x03, 0x28, 0x16, 0x1d, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x05, 0x03, 0x12, 0x03, 0x28, 0x20, 0x21, 0x0a, 0x0a, 0x0a, 0x02, 0x05, + 0x00, 0x12, 0x04, 0x2c, 0x00, 0x56, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, 0x03, + 0x2c, 0x05, 0x0b, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x00, 0x12, 0x03, 0x2d, 0x02, 0x12, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2d, 0x02, 0x0d, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x2d, 0x10, 0x11, 0x0a, 0x0b, 0x0a, 0x04, + 0x05, 0x00, 0x02, 0x01, 0x12, 0x03, 0x2e, 0x02, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x2e, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x02, + 0x12, 0x03, 0x2e, 0x12, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x2e, 0x14, 0x27, 0x0a, 0x0d, 0x0a, 0x06, 0x05, 0x00, 0x02, 0x01, 0x03, 0x01, 0x12, 0x03, 0x2e, + 0x15, 0x26, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x02, 0x12, 0x03, 0x2f, 0x02, 0x26, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x2f, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x2f, 0x10, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x2f, 0x12, 0x25, 0x0a, 0x0d, 0x0a, 0x06, 0x05, 0x00, 0x02, + 0x02, 0x03, 0x01, 0x12, 0x03, 0x2f, 0x13, 0x24, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x03, + 0x12, 0x03, 0x30, 0x02, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, + 0x30, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x30, 0x12, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x30, 0x14, 0x27, 0x0a, + 0x0d, 0x0a, 0x06, 0x05, 0x00, 0x02, 0x03, 0x03, 0x01, 0x12, 0x03, 0x30, 0x15, 0x26, 0x0a, 0x0b, + 0x0a, 0x04, 0x05, 0x00, 0x02, 0x04, 0x12, 0x03, 0x31, 0x02, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x31, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, + 0x04, 0x02, 0x12, 0x03, 0x31, 0x12, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x04, 0x03, + 0x12, 0x03, 0x31, 0x14, 0x27, 0x0a, 0x0d, 0x0a, 0x06, 0x05, 0x00, 0x02, 0x04, 0x03, 0x01, 0x12, + 0x03, 0x31, 0x15, 0x26, 0x0a, 0x3b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x05, 0x12, 0x03, 0x34, 0x02, + 0x22, 0x1a, 0x2e, 0x20, 0x52, 0x65, 0x61, 0x64, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x20, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x73, 0x2c, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x20, + 0x61, 0x6e, 0x64, 0x20, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x20, 0x70, 0x6c, 0x61, 0x6e, 0x73, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x34, 0x02, 0x1d, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x05, 0x02, 0x12, 0x03, 0x34, 0x20, 0x21, 0x0a, 0x24, 0x0a, + 0x04, 0x05, 0x00, 0x02, 0x06, 0x12, 0x03, 0x37, 0x02, 0x23, 0x1a, 0x17, 0x20, 0x56, 0x69, 0x65, + 0x77, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x37, 0x02, + 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x06, 0x02, 0x12, 0x03, 0x37, 0x21, 0x22, 0x0a, + 0x4f, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x07, 0x12, 0x03, 0x3a, 0x02, 0x26, 0x1a, 0x42, 0x20, 0x52, + 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x20, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x73, 0x2c, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x20, 0x61, + 0x6e, 0x64, 0x20, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x20, 0x70, 0x6c, 0x61, 0x6e, 0x73, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x07, 0x01, 0x12, 0x03, 0x3a, 0x02, 0x21, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x00, 0x02, 0x07, 0x02, 0x12, 0x03, 0x3a, 0x24, 0x25, 0x0a, 0x3c, 0x0a, 0x04, + 0x05, 0x00, 0x02, 0x08, 0x12, 0x03, 0x3d, 0x02, 0x25, 0x1a, 0x2f, 0x20, 0x43, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x20, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, + 0x02, 0x08, 0x01, 0x12, 0x03, 0x3d, 0x02, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x08, + 0x02, 0x12, 0x03, 0x3d, 0x23, 0x24, 0x0a, 0x42, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x09, 0x12, 0x03, + 0x40, 0x02, 0x20, 0x1a, 0x35, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x6e, 0x65, 0x77, + 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x75, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x64, 0x65, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, + 0x02, 0x09, 0x01, 0x12, 0x03, 0x40, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x09, + 0x02, 0x12, 0x03, 0x40, 0x1e, 0x1f, 0x0a, 0x3c, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x0a, 0x12, 0x03, + 0x43, 0x02, 0x21, 0x1a, 0x2f, 0x20, 0x41, 0x64, 0x64, 0x20, 0x75, 0x73, 0x65, 0x72, 0x73, 0x2c, + 0x20, 0x72, 0x6f, 0x6c, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x20, 0x72, 0x6f, 0x6c, 0x65, 0x20, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, + 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0a, 0x01, 0x12, 0x03, 0x43, + 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0a, 0x02, 0x12, 0x03, 0x43, 0x1e, 0x20, + 0x0a, 0x34, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x0b, 0x12, 0x03, 0x46, 0x02, 0x21, 0x1a, 0x27, 0x20, + 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x20, 0x62, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x2c, 0x20, + 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x2d, 0x77, 0x69, 0x64, 0x65, 0x20, 0x73, 0x65, 0x74, + 0x74, 0x69, 0x6e, 0x67, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0b, 0x01, 0x12, + 0x03, 0x46, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0b, 0x02, 0x12, 0x03, 0x46, + 0x1e, 0x20, 0x0a, 0x26, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x0c, 0x12, 0x03, 0x49, 0x02, 0x1d, 0x1a, + 0x19, 0x20, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, + 0x02, 0x0c, 0x01, 0x12, 0x03, 0x49, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0c, + 0x02, 0x12, 0x03, 0x49, 0x1a, 0x1c, 0x0a, 0x7b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x0d, 0x12, 0x03, + 0x4c, 0x02, 0x30, 0x1a, 0x6e, 0x20, 0x45, 0x64, 0x69, 0x74, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x20, 0x61, 0x74, 0x74, + 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, + 0x6e, 0x67, 0x20, 0x54, 0x41, 0x53, 0x4b, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, + 0x2c, 0x20, 0x57, 0x4f, 0x52, 0x4b, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x45, 0x58, 0x45, 0x43, 0x55, + 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x4f, 0x4e, 0x46, 0x49, 0x47, 0x2c, 0x20, 0x61, 0x6e, 0x64, + 0x20, 0x45, 0x58, 0x54, 0x45, 0x52, 0x4e, 0x41, 0x4c, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, + 0x43, 0x45, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0d, 0x01, 0x12, 0x03, 0x4c, 0x02, + 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0d, 0x02, 0x12, 0x03, 0x4c, 0x2d, 0x2f, 0x0a, + 0x61, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x0e, 0x12, 0x03, 0x4f, 0x02, 0x2e, 0x1a, 0x54, 0x20, 0x45, + 0x64, 0x69, 0x74, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x72, 0x65, 0x6c, 0x61, + 0x74, 0x65, 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x2c, 0x20, + 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, + 0x52, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x43, + 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, + 0x54, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0e, 0x01, 0x12, 0x03, 0x4f, 0x02, 0x28, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0e, 0x02, 0x12, 0x03, 0x4f, 0x2b, 0x2d, 0x0a, 0x91, + 0x01, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x0f, 0x12, 0x03, 0x52, 0x02, 0x25, 0x1a, 0x83, 0x01, 0x20, + 0x45, 0x64, 0x69, 0x74, 0x20, 0x75, 0x6e, 0x75, 0x73, 0x65, 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, + 0x67, 0x20, 0x45, 0x58, 0x45, 0x43, 0x55, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x51, 0x55, 0x45, 0x55, + 0x45, 0x2c, 0x20, 0x45, 0x58, 0x45, 0x43, 0x55, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x4c, 0x55, + 0x53, 0x54, 0x45, 0x52, 0x5f, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x2c, 0x20, 0x51, 0x55, 0x41, 0x4c, + 0x49, 0x54, 0x59, 0x5f, 0x4f, 0x46, 0x5f, 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, 0x45, 0x5f, 0x53, + 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x2c, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x50, 0x4c, 0x55, 0x47, 0x49, 0x4e, 0x5f, 0x4f, 0x56, 0x45, 0x52, 0x52, 0x49, 0x44, + 0x45, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0f, 0x01, 0x12, 0x03, 0x52, 0x02, 0x1f, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x0f, 0x02, 0x12, 0x03, 0x52, 0x22, 0x24, 0x0a, 0x1f, + 0x0a, 0x04, 0x05, 0x00, 0x02, 0x10, 0x12, 0x03, 0x55, 0x02, 0x22, 0x1a, 0x12, 0x20, 0x56, 0x69, + 0x65, 0x77, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x10, 0x01, 0x12, 0x03, 0x55, 0x02, 0x1c, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x10, 0x02, 0x12, 0x03, 0x55, 0x1f, 0x21, 0x0a, 0x54, 0x0a, 0x02, 0x04, + 0x06, 0x12, 0x04, 0x59, 0x00, 0x5d, 0x01, 0x1a, 0x48, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, + 0x73, 0x20, 0x61, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, + 0x65, 0x64, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x6e, 0x20, 0x61, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, + 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, + 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x03, 0x59, 0x08, 0x12, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x03, 0x5a, 0x02, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x00, 0x06, 0x12, 0x03, 0x5a, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x5a, 0x0b, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x5a, 0x16, 0x17, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x01, 0x12, 0x03, 0x5c, 0x02, + 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x04, 0x12, 0x03, 0x5c, 0x02, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x06, 0x12, 0x03, 0x5c, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x01, 0x01, 0x12, 0x03, 0x5c, 0x12, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x01, 0x03, 0x12, 0x03, 0x5c, 0x1c, 0x1d, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, 0x0a, 0xa6, 0x0b, 0x0a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa3, 0x01, 0x0a, 0x06, + 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x3a, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, + 0x69, 0x64, 0x12, 0x3b, 0x0a, 0x08, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x02, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x42, 0x69, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x08, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x12, + 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x22, 0x92, 0x01, 0x0a, 0x0d, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x42, 0x69, 0x6e, 0x64, + 0x69, 0x6e, 0x67, 0x12, 0x41, 0x0a, 0x07, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x06, + 0x72, 0x6f, 0x6c, 0x65, 0x49, 0x64, 0x12, 0x3e, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x42, 0xba, 0x01, 0x0a, 0x14, 0x63, 0x6f, 0x6d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x42, + 0x0b, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x34, + 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, + 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xca, 0x02, 0x10, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0xe2, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, + 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x4a, 0x8c, 0x06, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x1a, 0x01, 0x0a, 0x08, + 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, + 0x00, 0x19, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, + 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x2e, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, + 0x06, 0x00, 0x2b, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x08, 0x00, 0x4b, 0x0a, 0x09, 0x0a, + 0x02, 0x08, 0x0b, 0x12, 0x03, 0x08, 0x00, 0x4b, 0x0a, 0x44, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, + 0x0b, 0x00, 0x12, 0x01, 0x1a, 0x38, 0x20, 0x41, 0x20, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x20, + 0x69, 0x73, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x6f, 0x66, 0x20, 0x72, 0x6f, 0x6c, 0x65, 0x73, 0x20, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x74, + 0x6f, 0x20, 0x61, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0b, 0x08, 0x0e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x00, 0x12, 0x03, 0x0c, 0x02, 0x41, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x0c, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x0c, 0x13, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0c, 0x18, + 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x08, 0x12, 0x03, 0x0c, 0x1a, 0x40, 0x0a, + 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x0c, 0x1b, 0x3f, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0e, 0x02, 0x26, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x01, 0x04, 0x12, 0x03, 0x0e, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x0e, 0x0b, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x0e, 0x19, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x0e, 0x24, 0x25, 0x0a, 0x33, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x11, + 0x02, 0x19, 0x1a, 0x26, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x3a, 0x20, 0x68, + 0x75, 0x6d, 0x61, 0x6e, 0x20, 0x72, 0x65, 0x61, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x02, 0x05, 0x12, 0x03, 0x11, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, + 0x01, 0x12, 0x03, 0x11, 0x09, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, + 0x03, 0x11, 0x17, 0x18, 0x0a, 0x5a, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x15, 0x00, 0x1a, 0x01, + 0x1a, 0x4e, 0x20, 0x41, 0x20, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x20, 0x62, 0x69, 0x6e, 0x64, + 0x69, 0x6e, 0x67, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, + 0x20, 0x72, 0x6f, 0x6c, 0x65, 0x20, 0x28, 0x61, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x29, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, + 0x20, 0x6f, 0x6e, 0x20, 0x61, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x15, 0x08, 0x15, 0x0a, 0x65, 0x0a, 0x04, + 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x17, 0x02, 0x44, 0x1a, 0x58, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x72, 0x6f, 0x6c, 0x65, 0x20, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x64, 0x20, 0x73, 0x65, + 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x77, 0x68, 0x69, + 0x63, 0x68, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x17, 0x02, + 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x17, 0x11, 0x18, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x17, 0x1b, 0x1c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x00, 0x08, 0x12, 0x03, 0x17, 0x1d, 0x43, 0x0a, 0x0f, 0x0a, 0x08, 0x04, + 0x01, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x17, 0x1e, 0x42, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x19, 0x02, 0x46, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x01, 0x06, 0x12, 0x03, 0x19, 0x02, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x19, 0x12, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x19, 0x1d, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x08, 0x12, 0x03, 0x19, 0x1f, + 0x45, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x01, 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x19, + 0x20, 0x44, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0x86, 0x17, 0x0a, 0x1b, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, + 0x72, 0x6f, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x1a, 0x1b, 0x62, 0x75, + 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x61, 0x75, 0x74, 0x68, + 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, + 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x22, 0xaa, 0x02, 0x0a, 0x04, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x38, 0x0a, 0x02, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, + 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0x42, 0x0a, 0x0b, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, + 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x50, 0x65, + 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0b, 0x70, 0x65, + 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x37, 0x0a, 0x09, 0x72, 0x6f, 0x6c, + 0x65, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x52, 0x6f, 0x6c, 0x65, 0x53, 0x70, 0x65, 0x63, 0x52, 0x08, 0x72, 0x6f, 0x6c, 0x65, 0x53, 0x70, + 0x65, 0x63, 0x12, 0x37, 0x0a, 0x09, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x54, 0x79, 0x70, + 0x65, 0x52, 0x08, 0x72, 0x6f, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x32, 0x0a, 0x07, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x18, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, + 0x2c, 0x0a, 0x08, 0x52, 0x6f, 0x6c, 0x65, 0x53, 0x70, 0x65, 0x63, 0x12, 0x20, 0x0a, 0x0b, 0x64, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x9a, 0x02, + 0x0a, 0x08, 0x52, 0x6f, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x0e, 0x52, 0x4f, + 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x00, 0x12, 0x13, + 0x0a, 0x0f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x41, 0x44, 0x4d, 0x49, + 0x4e, 0x10, 0x01, 0x12, 0x19, 0x0a, 0x15, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, + 0x5f, 0x43, 0x4f, 0x4e, 0x54, 0x52, 0x49, 0x42, 0x55, 0x54, 0x4f, 0x52, 0x10, 0x02, 0x12, 0x14, + 0x0a, 0x10, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x56, 0x49, 0x45, 0x57, + 0x45, 0x52, 0x10, 0x03, 0x12, 0x14, 0x0a, 0x10, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, + 0x45, 0x5f, 0x43, 0x55, 0x53, 0x54, 0x4f, 0x4d, 0x10, 0x04, 0x12, 0x1d, 0x0a, 0x19, 0x52, 0x4f, + 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, 0x4c, 0x55, 0x53, 0x54, 0x45, 0x52, 0x5f, + 0x4d, 0x41, 0x4e, 0x41, 0x47, 0x45, 0x52, 0x10, 0x05, 0x12, 0x21, 0x0a, 0x1d, 0x52, 0x4f, 0x4c, + 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46, 0x4c, 0x59, 0x54, 0x45, 0x5f, 0x50, 0x52, 0x4f, + 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x41, 0x44, 0x4d, 0x49, 0x4e, 0x10, 0x06, 0x12, 0x1f, 0x0a, 0x1b, + 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x45, 0x52, 0x56, 0x45, 0x52, + 0x4c, 0x45, 0x53, 0x53, 0x5f, 0x56, 0x49, 0x45, 0x57, 0x45, 0x52, 0x10, 0x07, 0x12, 0x24, 0x0a, + 0x20, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x45, 0x52, 0x56, 0x45, + 0x52, 0x4c, 0x45, 0x53, 0x53, 0x5f, 0x43, 0x4f, 0x4e, 0x54, 0x52, 0x49, 0x42, 0x55, 0x54, 0x4f, + 0x52, 0x10, 0x08, 0x12, 0x15, 0x0a, 0x11, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, + 0x5f, 0x53, 0x55, 0x50, 0x50, 0x4f, 0x52, 0x54, 0x10, 0x09, 0x42, 0xb8, 0x01, 0x0a, 0x14, 0x63, + 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x42, 0x09, 0x52, 0x6f, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, + 0x5a, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, + 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x10, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xca, + 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0xe2, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0xea, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x4a, 0xb3, 0x0f, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x39, 0x01, + 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, + 0x03, 0x02, 0x00, 0x19, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x25, 0x0a, + 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x2e, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, + 0x12, 0x03, 0x06, 0x00, 0x2b, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x08, 0x00, 0x4b, 0x0a, + 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x08, 0x00, 0x4b, 0x0a, 0xf1, 0x01, 0x0a, 0x02, 0x05, + 0x00, 0x12, 0x04, 0x0d, 0x00, 0x28, 0x01, 0x1a, 0xe4, 0x01, 0x20, 0x41, 0x20, 0x72, 0x6f, 0x6c, + 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x73, 0x68, 0x6f, 0x72, + 0x74, 0x2d, 0x68, 0x61, 0x6e, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, + 0x73, 0x74, 0x61, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x65, 0x72, + 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, + 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x72, 0x6f, 0x6c, 0x65, 0x2e, + 0x0a, 0x20, 0x42, 0x6f, 0x69, 0x6c, 0x65, 0x72, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x72, 0x6f, + 0x6c, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, + 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, + 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x70, 0x65, + 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x0a, 0x20, 0x43, 0x75, 0x73, 0x74, 0x6f, + 0x6d, 0x20, 0x72, 0x6f, 0x6c, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x63, + 0x6c, 0x75, 0x64, 0x65, 0x20, 0x61, 0x20, 0x75, 0x73, 0x65, 0x72, 0x2d, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x65, 0x64, 0x20, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, + 0x66, 0x20, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x0a, 0x0a, 0x0a, + 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, 0x03, 0x0d, 0x05, 0x0d, 0x0a, 0x33, 0x0a, 0x04, 0x05, 0x00, + 0x02, 0x00, 0x12, 0x03, 0x0f, 0x02, 0x15, 0x1a, 0x26, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, + 0x74, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x20, 0x4e, 0x6f, 0x74, 0x20, 0x75, 0x73, 0x65, + 0x64, 0x20, 0x69, 0x6e, 0x20, 0x70, 0x72, 0x61, 0x63, 0x74, 0x69, 0x63, 0x65, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0f, 0x02, 0x10, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x0f, 0x13, 0x14, 0x0a, 0x52, 0x0a, 0x04, 0x05, + 0x00, 0x02, 0x01, 0x12, 0x03, 0x11, 0x02, 0x16, 0x1a, 0x45, 0x20, 0x54, 0x68, 0x65, 0x20, 0x61, + 0x64, 0x6d, 0x69, 0x6e, 0x20, 0x72, 0x6f, 0x6c, 0x65, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x20, + 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, + 0x66, 0x20, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x74, 0x6f, + 0x20, 0x64, 0x6f, 0x20, 0x65, 0x76, 0x65, 0x72, 0x79, 0x74, 0x68, 0x69, 0x6e, 0x67, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x11, 0x02, 0x11, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x11, 0x14, 0x15, 0x0a, 0x92, 0x01, 0x0a, 0x04, + 0x05, 0x00, 0x02, 0x02, 0x12, 0x03, 0x13, 0x02, 0x1c, 0x1a, 0x84, 0x01, 0x20, 0x54, 0x68, 0x65, + 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x6f, 0x72, 0x20, 0x72, 0x6f, 0x6c, + 0x65, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, + 0x76, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x76, 0x69, 0x65, 0x77, 0x20, 0x69, 0x6e, + 0x76, 0x65, 0x6e, 0x74, 0x6f, 0x72, 0x79, 0x2c, 0x20, 0x76, 0x69, 0x65, 0x77, 0x20, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2c, 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, + 0x69, 0x6e, 0x76, 0x65, 0x6e, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x13, 0x02, 0x17, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x13, 0x1a, 0x1b, 0x0a, 0x68, 0x0a, 0x04, + 0x05, 0x00, 0x02, 0x03, 0x12, 0x03, 0x15, 0x02, 0x17, 0x1a, 0x5b, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x76, 0x69, 0x65, 0x77, 0x65, 0x72, 0x20, 0x72, 0x6f, 0x6c, 0x65, 0x20, 0x68, 0x61, 0x73, 0x20, + 0x61, 0x20, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x73, 0x65, 0x74, + 0x20, 0x6f, 0x66, 0x20, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, + 0x74, 0x6f, 0x20, 0x76, 0x69, 0x65, 0x77, 0x20, 0x69, 0x6e, 0x76, 0x65, 0x6e, 0x74, 0x6f, 0x72, + 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x76, 0x69, 0x65, 0x77, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x01, 0x12, + 0x03, 0x15, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x15, + 0x15, 0x16, 0x0a, 0x46, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x04, 0x12, 0x03, 0x18, 0x02, 0x17, 0x1a, + 0x39, 0x20, 0x52, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x20, 0x61, 0x20, 0x72, 0x6f, + 0x6c, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x75, 0x73, 0x65, 0x72, 0x2d, 0x64, 0x65, 0x66, + 0x69, 0x6e, 0x65, 0x64, 0x20, 0x73, 0x65, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x70, 0x65, 0x72, + 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, + 0x02, 0x04, 0x01, 0x12, 0x03, 0x18, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x04, + 0x02, 0x12, 0x03, 0x18, 0x15, 0x16, 0x0a, 0x53, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x05, 0x12, 0x03, + 0x1b, 0x02, 0x20, 0x1a, 0x46, 0x20, 0x54, 0x68, 0x65, 0x20, 0x72, 0x6f, 0x6c, 0x65, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x20, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, + 0x74, 0x6f, 0x20, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x69, 0x73, 0x74, 0x65, 0x72, 0x20, 0x61, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, + 0x72, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x1b, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, + 0x05, 0x02, 0x12, 0x03, 0x1b, 0x1e, 0x1f, 0x0a, 0x4d, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x06, 0x12, + 0x03, 0x1e, 0x02, 0x24, 0x1a, 0x40, 0x20, 0x52, 0x6f, 0x6c, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x20, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x69, 0x73, + 0x74, 0x65, 0x72, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x28, 0x73, 0x29, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x06, 0x01, 0x12, + 0x03, 0x1e, 0x02, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x06, 0x02, 0x12, 0x03, 0x1e, + 0x22, 0x23, 0x0a, 0x2d, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x07, 0x12, 0x03, 0x21, 0x02, 0x22, 0x1a, + 0x20, 0x20, 0x54, 0x68, 0x65, 0x20, 0x76, 0x69, 0x65, 0x77, 0x65, 0x72, 0x20, 0x72, 0x6f, 0x6c, + 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x6c, 0x65, 0x73, 0x73, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x07, 0x01, 0x12, 0x03, 0x21, 0x02, 0x1d, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x07, 0x02, 0x12, 0x03, 0x21, 0x20, 0x21, 0x0a, 0x32, 0x0a, + 0x04, 0x05, 0x00, 0x02, 0x08, 0x12, 0x03, 0x24, 0x02, 0x27, 0x1a, 0x25, 0x20, 0x54, 0x68, 0x65, + 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x6f, 0x72, 0x20, 0x72, 0x6f, 0x6c, + 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x6c, 0x65, 0x73, 0x73, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x08, 0x01, 0x12, 0x03, 0x24, 0x02, 0x22, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x08, 0x02, 0x12, 0x03, 0x24, 0x25, 0x26, 0x0a, 0x67, 0x0a, + 0x04, 0x05, 0x00, 0x02, 0x09, 0x12, 0x03, 0x27, 0x02, 0x18, 0x1a, 0x5a, 0x20, 0x54, 0x68, 0x65, + 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x72, 0x6f, 0x6c, 0x65, 0x20, 0x77, 0x6f, + 0x75, 0x6c, 0x64, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x6f, 0x72, 0x20, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, + 0x20, 0x70, 0x6c, 0x75, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, + 0x20, 0x74, 0x6f, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x65, 0x6e, 0x64, 0x70, + 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x09, 0x01, 0x12, + 0x03, 0x27, 0x02, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x09, 0x02, 0x12, 0x03, 0x27, + 0x16, 0x17, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x2a, 0x00, 0x34, 0x01, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x2a, 0x08, 0x0c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x00, 0x12, 0x03, 0x2b, 0x02, 0x3f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x2b, 0x02, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x2b, 0x11, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x2b, 0x16, + 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x08, 0x12, 0x03, 0x2b, 0x18, 0x3e, 0x0a, + 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x2b, 0x19, 0x3d, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x2d, 0x02, 0x3a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x01, 0x04, 0x12, 0x03, 0x2d, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x2d, 0x0b, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x2d, 0x16, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x2d, 0x24, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x08, 0x12, 0x03, + 0x2d, 0x26, 0x39, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x02, 0x01, 0x08, 0x03, 0x12, 0x03, 0x2d, + 0x27, 0x38, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x2f, 0x02, 0x19, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x2f, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x2f, 0x0b, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x2f, 0x17, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x03, 0x12, 0x03, 0x31, 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x06, 0x12, + 0x03, 0x31, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x31, + 0x0b, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x31, 0x17, 0x18, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, 0x33, 0x02, 0x1e, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x04, 0x04, 0x12, 0x03, 0x33, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x04, 0x06, 0x12, 0x03, 0x33, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x04, 0x01, 0x12, 0x03, 0x33, 0x12, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x03, + 0x12, 0x03, 0x33, 0x1c, 0x1d, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x36, 0x00, 0x39, + 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x36, 0x08, 0x10, 0x0a, 0x42, 0x0a, + 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x38, 0x02, 0x19, 0x1a, 0x35, 0x20, 0x4f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2c, 0x20, 0x68, 0x75, 0x6d, 0x61, 0x6e, 0x20, 0x72, 0x65, 0x61, + 0x64, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x72, 0x6f, 0x6c, 0x65, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x38, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x38, 0x09, 0x14, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x38, 0x17, 0x18, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, 0x0a, 0x88, 0x16, 0x0a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6c, 0x69, + 0x63, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x72, 0x6f, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xd0, 0x01, 0x0a, 0x04, 0x55, 0x73, 0x65, 0x72, 0x12, 0x30, + 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x55, 0x73, + 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x02, 0x69, 0x64, + 0x12, 0x2e, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x53, 0x70, 0x65, 0x63, 0x52, 0x04, 0x73, 0x70, 0x65, 0x63, + 0x12, 0x30, 0x0a, 0x05, 0x72, 0x6f, 0x6c, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x42, 0x02, 0x18, 0x01, 0x52, 0x05, 0x72, 0x6f, 0x6c, + 0x65, 0x73, 0x12, 0x34, 0x0a, 0x08, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x65, 0x73, 0x18, 0x04, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x08, + 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x65, 0x73, 0x22, 0xd6, 0x01, 0x0a, 0x08, 0x55, 0x73, 0x65, + 0x72, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1d, 0x0a, 0x0a, 0x66, 0x69, 0x72, 0x73, 0x74, 0x5f, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x66, 0x69, 0x72, 0x73, 0x74, + 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6c, 0x61, 0x73, 0x74, 0x4e, 0x61, 0x6d, + 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x12, 0x22, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, + 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, + 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x75, + 0x73, 0x65, 0x72, 0x5f, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0a, 0x75, 0x73, 0x65, 0x72, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x12, 0x16, 0x0a, 0x06, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x67, 0x72, + 0x6f, 0x75, 0x70, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x70, 0x68, 0x6f, 0x74, 0x6f, 0x5f, 0x75, 0x72, + 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x68, 0x6f, 0x74, 0x6f, 0x55, 0x72, + 0x6c, 0x22, 0x75, 0x0a, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x37, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x02, 0x69, 0x64, 0x12, 0x2d, 0x0a, 0x04, 0x73, 0x70, 0x65, + 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x70, 0x70, 0x53, 0x70, + 0x65, 0x63, 0x52, 0x04, 0x73, 0x70, 0x65, 0x63, 0x22, 0x41, 0x0a, 0x07, 0x41, 0x70, 0x70, 0x53, + 0x70, 0x65, 0x63, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x22, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, + 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, + 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x97, 0x01, 0x0a, 0x10, + 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, + 0x12, 0x2c, 0x0a, 0x04, 0x75, 0x73, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x48, 0x00, 0x52, 0x04, 0x75, 0x73, 0x65, 0x72, 0x12, 0x41, + 0x0a, 0x0b, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0b, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x42, 0x12, 0x0a, 0x09, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x12, 0x05, + 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, 0xa6, 0x01, 0x0a, 0x08, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x74, 0x79, 0x12, 0x3b, 0x0a, 0x07, 0x75, 0x73, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x06, 0x75, 0x73, 0x65, 0x72, 0x49, 0x64, 0x12, + 0x50, 0x0a, 0x0e, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, + 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x70, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x48, 0x00, 0x52, 0x0d, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, + 0x64, 0x42, 0x0b, 0x0a, 0x09, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x42, 0xbc, + 0x01, 0x0a, 0x14, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x42, 0x0d, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, + 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xa2, 0x02, + 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xca, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xe2, 0x02, 0x1c, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x5c, 0x47, 0x50, + 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x4a, 0xe6, 0x0b, + 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x3f, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, + 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x19, 0x0a, 0x09, 0x0a, 0x02, + 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, + 0x00, 0x2b, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, 0x27, 0x0a, 0x09, 0x0a, + 0x02, 0x03, 0x03, 0x12, 0x03, 0x07, 0x00, 0x25, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x09, + 0x00, 0x4b, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x09, 0x00, 0x4b, 0x0a, 0x50, 0x0a, + 0x02, 0x04, 0x00, 0x12, 0x04, 0x0c, 0x00, 0x14, 0x01, 0x1a, 0x44, 0x20, 0x45, 0x6e, 0x63, 0x61, + 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x70, 0x72, + 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x61, 0x20, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, + 0x20, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0c, 0x08, 0x0c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x00, 0x12, 0x03, 0x0d, 0x02, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x06, 0x12, 0x03, 0x0d, 0x02, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x0d, 0x11, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0d, + 0x16, 0x17, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0f, 0x02, 0x14, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x0f, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0f, 0x0b, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x0f, 0x12, 0x13, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x02, 0x12, 0x03, 0x11, 0x02, 0x2e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x04, 0x12, + 0x03, 0x11, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x11, + 0x0b, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x11, 0x10, 0x15, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x11, 0x18, 0x19, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x08, 0x12, 0x03, 0x11, 0x1a, 0x2d, 0x0a, 0x0d, 0x0a, 0x06, + 0x04, 0x00, 0x02, 0x02, 0x08, 0x03, 0x12, 0x03, 0x11, 0x1b, 0x2c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x03, 0x12, 0x03, 0x13, 0x02, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, + 0x04, 0x12, 0x03, 0x13, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x06, 0x12, + 0x03, 0x13, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x13, + 0x12, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x13, 0x1d, 0x1e, + 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x16, 0x00, 0x24, 0x01, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x01, 0x01, 0x12, 0x03, 0x16, 0x08, 0x10, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, + 0x12, 0x03, 0x17, 0x02, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x17, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x17, 0x09, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x17, 0x16, 0x17, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x19, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, 0x19, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x19, 0x09, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x19, 0x15, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, + 0x1b, 0x02, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x05, 0x12, 0x03, 0x1b, 0x02, + 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x1b, 0x09, 0x0e, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x1b, 0x11, 0x12, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x01, 0x02, 0x03, 0x12, 0x03, 0x1d, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x03, 0x05, 0x12, 0x03, 0x1d, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, + 0x01, 0x12, 0x03, 0x1d, 0x09, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x03, 0x12, + 0x03, 0x1d, 0x18, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x04, 0x12, 0x03, 0x1f, 0x02, + 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x05, 0x12, 0x03, 0x1f, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x01, 0x12, 0x03, 0x1f, 0x09, 0x14, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x04, 0x03, 0x12, 0x03, 0x1f, 0x17, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x05, 0x12, 0x03, 0x21, 0x02, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, + 0x04, 0x12, 0x03, 0x21, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x05, 0x12, + 0x03, 0x21, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x01, 0x12, 0x03, 0x21, + 0x12, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x03, 0x12, 0x03, 0x21, 0x1b, 0x1c, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x06, 0x12, 0x03, 0x23, 0x02, 0x17, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x06, 0x05, 0x12, 0x03, 0x23, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x06, 0x01, 0x12, 0x03, 0x23, 0x09, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x06, 0x03, 0x12, 0x03, 0x23, 0x15, 0x16, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x26, + 0x00, 0x2a, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x26, 0x08, 0x13, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x27, 0x02, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, 0x03, 0x27, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x27, 0x18, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x27, 0x1d, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x29, 0x02, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, 0x03, 0x29, 0x02, + 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x29, 0x0a, 0x0e, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x29, 0x11, 0x12, 0x0a, 0x0a, 0x0a, + 0x02, 0x04, 0x03, 0x12, 0x04, 0x2c, 0x00, 0x30, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, + 0x12, 0x03, 0x2c, 0x08, 0x0f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x2d, + 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x05, 0x12, 0x03, 0x2d, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2d, 0x09, 0x0d, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x2d, 0x10, 0x11, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, 0x2f, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x01, 0x05, 0x12, 0x03, 0x2f, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x2f, 0x09, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x2f, 0x18, 0x19, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x32, 0x00, 0x38, 0x01, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x32, 0x08, 0x18, 0x0a, 0x0c, 0x0a, 0x04, 0x04, + 0x04, 0x08, 0x00, 0x12, 0x04, 0x33, 0x02, 0x37, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x08, + 0x00, 0x01, 0x12, 0x03, 0x33, 0x08, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x08, 0x00, 0x02, + 0x12, 0x03, 0x34, 0x04, 0x30, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x04, 0x08, 0x00, 0x02, 0x87, 0x09, + 0x01, 0x12, 0x03, 0x34, 0x04, 0x30, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, + 0x35, 0x04, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x06, 0x12, 0x03, 0x35, 0x04, + 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x35, 0x09, 0x0d, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x35, 0x10, 0x11, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x36, 0x04, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x01, 0x06, 0x12, 0x03, 0x36, 0x04, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x36, 0x10, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x36, 0x1e, 0x1f, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x3a, 0x00, 0x3f, 0x01, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x3a, 0x08, 0x10, 0x0a, 0x0c, 0x0a, 0x04, + 0x04, 0x05, 0x08, 0x00, 0x12, 0x04, 0x3b, 0x02, 0x3e, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x08, 0x00, 0x01, 0x12, 0x03, 0x3b, 0x08, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, + 0x12, 0x03, 0x3c, 0x04, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x06, 0x12, 0x03, + 0x3c, 0x04, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x3c, 0x1a, + 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x3c, 0x24, 0x25, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x03, 0x3d, 0x04, 0x34, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x01, 0x06, 0x12, 0x03, 0x3d, 0x04, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x3d, 0x21, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x3d, 0x32, 0x33, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xda, + 0x09, 0x0a, 0x26, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2f, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x22, 0xbe, 0x01, 0x0a, 0x0f, + 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, + 0x41, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2d, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, + 0x70, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, + 0x66, 0x6c, 0x61, 0x76, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, 0x6c, + 0x61, 0x76, 0x6f, 0x72, 0x22, 0x36, 0x0a, 0x0b, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x09, 0x0a, 0x05, 0x4f, 0x54, 0x48, 0x45, 0x52, 0x10, 0x00, 0x12, 0x0d, + 0x0a, 0x09, 0x46, 0x4c, 0x59, 0x54, 0x45, 0x5f, 0x53, 0x44, 0x4b, 0x10, 0x01, 0x12, 0x0d, 0x0a, + 0x09, 0x55, 0x4e, 0x49, 0x4f, 0x4e, 0x5f, 0x53, 0x44, 0x4b, 0x10, 0x02, 0x42, 0xc2, 0x01, 0x0a, + 0x14, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x42, 0x13, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x56, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x34, 0x67, 0x69, + 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, + 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, + 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xca, 0x02, 0x10, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xe2, 0x02, + 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x11, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x4a, 0x8f, 0x06, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x17, 0x01, 0x0a, 0x08, 0x0a, 0x01, + 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x19, + 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x04, 0x00, 0x4b, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, + 0x12, 0x03, 0x04, 0x00, 0x4b, 0x0a, 0x56, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x07, 0x00, 0x17, + 0x01, 0x1a, 0x4a, 0x20, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, + 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, + 0x20, 0x6c, 0x6f, 0x6f, 0x73, 0x65, 0x6c, 0x79, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x78, + 0x74, 0x65, 0x6e, 0x73, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x07, 0x08, 0x17, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x00, 0x04, + 0x00, 0x12, 0x04, 0x08, 0x02, 0x0c, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x04, 0x00, 0x01, + 0x12, 0x03, 0x08, 0x07, 0x12, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x12, + 0x03, 0x09, 0x04, 0x0e, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x09, 0x04, 0x09, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, + 0x03, 0x09, 0x0c, 0x0d, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, + 0x0a, 0x04, 0x12, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x0a, 0x04, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, + 0x0a, 0x10, 0x11, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x0b, + 0x04, 0x12, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x0b, + 0x04, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x0b, + 0x10, 0x11, 0x0a, 0x1f, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0f, 0x02, 0x17, 0x1a, + 0x12, 0x20, 0x54, 0x79, 0x70, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, + 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x0f, 0x02, + 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0f, 0x0e, 0x12, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0f, 0x15, 0x16, 0x0a, 0xb9, 0x01, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x13, 0x02, 0x15, 0x1a, 0xab, 0x01, 0x20, 0x56, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, + 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x20, 0x41, 0x6c, 0x6c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x73, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x62, 0x61, + 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x6c, + 0x65, 0x2e, 0x20, 0x48, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x2c, 0x20, 0x63, 0x65, 0x72, 0x74, + 0x61, 0x69, 0x6e, 0x20, 0x63, 0x61, 0x73, 0x65, 0x73, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x63, 0x68, 0x65, 0x63, + 0x6b, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x20, 0x74, 0x69, 0x67, + 0x68, 0x74, 0x65, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x6f, 0x72, 0x20, 0x73, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x78, 0x70, 0x65, 0x63, + 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x01, 0x05, 0x12, 0x03, 0x13, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x13, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x13, 0x13, 0x14, 0x0a, 0x74, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x16, 0x02, 0x14, + 0x1a, 0x67, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x49, 0x74, 0x20, 0x63, + 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x20, 0x65, 0x78, 0x74, 0x72, 0x61, 0x20, 0x69, 0x6e, 0x66, 0x6f, + 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20, + 0x70, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x2c, 0x20, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x2e, + 0x2e, 0x20, 0x65, 0x74, 0x63, 0x2e, 0x29, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x02, 0x05, 0x12, 0x03, 0x16, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x16, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, + 0x16, 0x12, 0x13, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xfa, 0x1b, 0x0a, 0x1b, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2f, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x22, 0x84, 0x01, + 0x0a, 0x04, 0x53, 0x6f, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x3e, 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, + 0x6f, 0x72, 0x74, 0x2e, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x09, 0x64, + 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2a, 0x0a, 0x09, 0x44, 0x69, 0x72, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x0e, 0x0a, 0x0a, 0x44, 0x45, 0x53, 0x43, 0x45, 0x4e, 0x44, + 0x49, 0x4e, 0x47, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x41, 0x53, 0x43, 0x45, 0x4e, 0x44, 0x49, + 0x4e, 0x47, 0x10, 0x01, 0x22, 0x81, 0x02, 0x0a, 0x0b, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, + 0x12, 0x33, 0x0a, 0x07, 0x73, 0x6f, 0x72, 0x74, 0x5f, 0x62, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x6f, 0x72, 0x74, 0x42, 0x02, 0x18, 0x01, 0x52, 0x06, 0x73, + 0x6f, 0x72, 0x74, 0x42, 0x79, 0x12, 0x32, 0x0a, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, + 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, + 0x52, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x72, 0x61, 0x77, + 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, + 0x72, 0x61, 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x12, 0x3c, 0x0a, 0x0e, 0x73, 0x6f, + 0x72, 0x74, 0x5f, 0x62, 0x79, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x18, 0x06, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x6f, 0x72, 0x74, 0x52, 0x0c, 0x73, 0x6f, 0x72, 0x74, + 0x42, 0x79, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x22, 0xcd, 0x02, 0x0a, 0x06, 0x46, 0x69, 0x6c, + 0x74, 0x65, 0x72, 0x12, 0x3d, 0x0a, 0x08, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x2e, + 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x08, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x22, 0xd5, 0x01, 0x0a, 0x08, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x09, 0x0a, + 0x05, 0x45, 0x51, 0x55, 0x41, 0x4c, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x4e, 0x4f, 0x54, 0x5f, + 0x45, 0x51, 0x55, 0x41, 0x4c, 0x10, 0x01, 0x12, 0x10, 0x0a, 0x0c, 0x47, 0x52, 0x45, 0x41, 0x54, + 0x45, 0x52, 0x5f, 0x54, 0x48, 0x41, 0x4e, 0x10, 0x02, 0x12, 0x19, 0x0a, 0x15, 0x47, 0x52, 0x45, + 0x41, 0x54, 0x45, 0x52, 0x5f, 0x54, 0x48, 0x41, 0x4e, 0x5f, 0x4f, 0x52, 0x5f, 0x45, 0x51, 0x55, + 0x41, 0x4c, 0x10, 0x03, 0x12, 0x0d, 0x0a, 0x09, 0x4c, 0x45, 0x53, 0x53, 0x5f, 0x54, 0x48, 0x41, + 0x4e, 0x10, 0x04, 0x12, 0x16, 0x0a, 0x12, 0x4c, 0x45, 0x53, 0x53, 0x5f, 0x54, 0x48, 0x41, 0x4e, + 0x5f, 0x4f, 0x52, 0x5f, 0x45, 0x51, 0x55, 0x41, 0x4c, 0x10, 0x05, 0x12, 0x0c, 0x0a, 0x08, 0x43, + 0x4f, 0x4e, 0x54, 0x41, 0x49, 0x4e, 0x53, 0x10, 0x06, 0x12, 0x0c, 0x0a, 0x08, 0x56, 0x41, 0x4c, + 0x55, 0x45, 0x5f, 0x49, 0x4e, 0x10, 0x07, 0x12, 0x0d, 0x0a, 0x09, 0x45, 0x4e, 0x44, 0x53, 0x5f, + 0x57, 0x49, 0x54, 0x48, 0x10, 0x0c, 0x12, 0x11, 0x0a, 0x0d, 0x4e, 0x4f, 0x54, 0x5f, 0x45, 0x4e, + 0x44, 0x53, 0x5f, 0x57, 0x49, 0x54, 0x48, 0x10, 0x0d, 0x12, 0x1d, 0x0a, 0x19, 0x43, 0x4f, 0x4e, + 0x54, 0x41, 0x49, 0x4e, 0x53, 0x5f, 0x43, 0x41, 0x53, 0x45, 0x5f, 0x49, 0x4e, 0x53, 0x45, 0x4e, + 0x53, 0x49, 0x54, 0x49, 0x56, 0x45, 0x10, 0x0e, 0x42, 0xb8, 0x01, 0x0a, 0x14, 0x63, 0x6f, 0x6d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x42, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x34, + 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, + 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xca, 0x02, 0x10, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0xe2, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, + 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x4a, 0xaa, 0x14, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x50, 0x01, 0x0a, 0x08, + 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, + 0x00, 0x19, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x04, 0x00, 0x4b, 0x0a, 0x09, 0x0a, 0x02, + 0x08, 0x0b, 0x12, 0x03, 0x04, 0x00, 0x4b, 0x0a, 0x38, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x07, + 0x00, 0x15, 0x01, 0x1a, 0x2c, 0x20, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, + 0x73, 0x6f, 0x72, 0x74, 0x20, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x6e, + 0x20, 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, + 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x07, 0x08, 0x0c, 0x0a, 0x0c, 0x0a, + 0x04, 0x04, 0x00, 0x04, 0x00, 0x12, 0x04, 0x08, 0x02, 0x0c, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x04, 0x00, 0x01, 0x12, 0x03, 0x08, 0x07, 0x10, 0x0a, 0x43, 0x0a, 0x06, 0x04, 0x00, 0x04, + 0x00, 0x02, 0x00, 0x12, 0x03, 0x0a, 0x04, 0x13, 0x1a, 0x34, 0x20, 0x42, 0x79, 0x20, 0x64, 0x65, + 0x66, 0x61, 0x75, 0x6c, 0x74, 0x2c, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, 0x61, 0x72, + 0x65, 0x20, 0x73, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, + 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0a, 0x04, 0x0e, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x0a, 0x11, 0x12, 0x0a, 0x0d, + 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0b, 0x04, 0x12, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0b, 0x04, 0x0d, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x0b, 0x10, 0x11, 0x0a, 0x4d, 0x0a, + 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x10, 0x02, 0x11, 0x1a, 0x40, 0x20, 0x49, 0x6e, 0x64, + 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x6f, 0x72, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2e, + 0x0a, 0x20, 0x2b, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x10, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x10, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x10, 0x0f, 0x10, 0x0a, 0x58, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, + 0x14, 0x02, 0x1a, 0x1a, 0x4b, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, + 0x20, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x20, 0x73, 0x6f, 0x72, 0x74, 0x20, 0x6b, 0x65, 0x79, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x14, 0x02, 0x0b, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x14, 0x0c, 0x15, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x14, 0x18, 0x19, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x01, + 0x12, 0x04, 0x17, 0x00, 0x32, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x17, + 0x08, 0x13, 0x0a, 0x4b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x1a, 0x02, 0x13, 0x1a, + 0x3e, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, + 0x65, 0x64, 0x2e, 0x0a, 0x20, 0x2b, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x1a, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1a, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1a, 0x11, 0x12, 0x0a, 0x8e, 0x01, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x01, 0x12, 0x03, 0x1f, 0x02, 0x13, 0x1a, 0x80, 0x01, 0x20, 0x49, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, + 0x6c, 0x65, 0x20, 0x70, 0x61, 0x67, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x73, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2d, + 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x63, + 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x65, + 0x74, 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x70, 0x61, 0x67, + 0x65, 0x0a, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x0a, 0x20, + 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x01, 0x05, 0x12, 0x03, 0x1f, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x1f, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x1f, 0x11, 0x12, 0x0a, 0x82, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x24, + 0x02, 0x27, 0x1a, 0x75, 0x20, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x2c, + 0x20, 0x75, 0x73, 0x65, 0x20, 0x73, 0x6f, 0x72, 0x74, 0x5f, 0x62, 0x79, 0x5f, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x73, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x2e, 0x0a, 0x20, 0x53, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x6c, 0x69, 0x73, 0x74, + 0x65, 0x64, 0x20, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x20, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x73, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x0a, 0x20, 0x2b, + 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x02, 0x06, 0x12, 0x03, 0x24, 0x02, 0x06, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x24, 0x07, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, + 0x24, 0x11, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x08, 0x12, 0x03, 0x24, 0x13, + 0x26, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x02, 0x02, 0x08, 0x03, 0x12, 0x03, 0x24, 0x14, 0x25, + 0x0a, 0x60, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x03, 0x12, 0x03, 0x28, 0x02, 0x1e, 0x1a, 0x53, 0x20, + 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, + 0x20, 0x6f, 0x66, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x67, 0x72, 0x70, 0x63, 0x20, 0x67, 0x65, 0x74, 0x20, 0x72, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x73, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x04, 0x12, 0x03, 0x28, 0x02, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x06, 0x12, 0x03, 0x28, 0x0b, 0x11, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x01, 0x12, 0x03, 0x28, 0x12, 0x19, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x03, 0x03, 0x12, 0x03, 0x28, 0x1c, 0x1d, 0x0a, 0x73, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x04, 0x12, 0x03, 0x2c, 0x02, 0x22, 0x1a, 0x66, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, + 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x72, 0x61, 0x77, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, + 0x66, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, + 0x20, 0x61, 0x73, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x54, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x52, 0x45, 0x53, 0x54, 0x20, 0x67, 0x65, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x73, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x04, 0x12, 0x03, 0x2c, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x04, 0x05, 0x12, 0x03, 0x2c, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x04, 0x01, 0x12, 0x03, 0x2c, 0x12, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x04, 0x03, 0x12, 0x03, 0x2c, 0x20, 0x21, 0x0a, 0x7c, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x05, 0x12, + 0x03, 0x31, 0x02, 0x23, 0x1a, 0x6f, 0x20, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x68, 0x6f, 0x77, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x64, 0x20, 0x65, 0x6e, 0x74, 0x69, + 0x74, 0x69, 0x65, 0x73, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x73, + 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x0a, 0x20, 0x53, 0x6f, 0x72, 0x74, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, + 0x69, 0x6e, 0x20, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x04, 0x12, 0x03, + 0x31, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x06, 0x12, 0x03, 0x31, 0x0b, + 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x01, 0x12, 0x03, 0x31, 0x10, 0x1e, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x03, 0x12, 0x03, 0x31, 0x21, 0x22, 0x0a, 0x0a, 0x0a, + 0x02, 0x04, 0x02, 0x12, 0x04, 0x34, 0x00, 0x50, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, + 0x12, 0x03, 0x34, 0x08, 0x0e, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x02, 0x04, 0x00, 0x12, 0x04, 0x35, + 0x02, 0x47, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x04, 0x00, 0x01, 0x12, 0x03, 0x35, 0x07, + 0x0f, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x36, 0x04, 0x0e, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x36, 0x04, 0x09, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x36, 0x0c, 0x0d, + 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x37, 0x04, 0x12, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x37, 0x04, 0x0d, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x37, 0x10, 0x11, 0x0a, + 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x38, 0x04, 0x15, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x38, 0x04, 0x10, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x38, 0x13, 0x14, 0x0a, 0x0d, + 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x39, 0x04, 0x1e, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x39, 0x04, 0x19, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x39, 0x1c, 0x1d, 0x0a, 0x0d, 0x0a, + 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, 0x3a, 0x04, 0x12, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x02, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x3a, 0x04, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x02, 0x04, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, 0x3a, 0x10, 0x11, 0x0a, 0x0d, 0x0a, 0x06, + 0x04, 0x02, 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x3b, 0x04, 0x1b, 0x0a, 0x0e, 0x0a, 0x07, 0x04, + 0x02, 0x04, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x3b, 0x04, 0x16, 0x0a, 0x0e, 0x0a, 0x07, 0x04, + 0x02, 0x04, 0x00, 0x02, 0x05, 0x02, 0x12, 0x03, 0x3b, 0x19, 0x1a, 0x0a, 0x32, 0x0a, 0x06, 0x04, + 0x02, 0x04, 0x00, 0x02, 0x06, 0x12, 0x03, 0x3c, 0x04, 0x11, 0x22, 0x23, 0x20, 0x43, 0x61, 0x73, + 0x65, 0x20, 0x73, 0x65, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x73, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x3c, 0x04, 0x0c, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x06, 0x02, 0x12, 0x03, 0x3c, 0x0f, 0x10, 0x0a, + 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x07, 0x12, 0x03, 0x3d, 0x04, 0x11, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x07, 0x01, 0x12, 0x03, 0x3d, 0x04, 0x0c, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x07, 0x02, 0x12, 0x03, 0x3d, 0x0f, 0x10, 0x0a, 0x5f, + 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x08, 0x12, 0x03, 0x44, 0x04, 0x13, 0x32, 0x50, 0x20, + 0x4e, 0x4f, 0x54, 0x5f, 0x43, 0x4f, 0x4e, 0x54, 0x41, 0x49, 0x4e, 0x53, 0x20, 0x3d, 0x20, 0x38, + 0x3b, 0x0a, 0x20, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x49, 0x4e, 0x20, + 0x3d, 0x20, 0x39, 0x3b, 0x0a, 0x20, 0x53, 0x54, 0x41, 0x52, 0x54, 0x53, 0x5f, 0x57, 0x49, 0x54, + 0x48, 0x20, 0x3d, 0x20, 0x31, 0x30, 0x3b, 0x0a, 0x20, 0x4e, 0x4f, 0x54, 0x5f, 0x53, 0x54, 0x41, + 0x52, 0x54, 0x53, 0x5f, 0x57, 0x49, 0x54, 0x48, 0x20, 0x3d, 0x20, 0x31, 0x31, 0x3b, 0x0a, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x08, 0x01, 0x12, 0x03, 0x44, 0x04, 0x0d, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x08, 0x02, 0x12, 0x03, 0x44, 0x10, 0x12, 0x0a, + 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x09, 0x12, 0x03, 0x45, 0x04, 0x17, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x09, 0x01, 0x12, 0x03, 0x45, 0x04, 0x11, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x09, 0x02, 0x12, 0x03, 0x45, 0x14, 0x16, 0x0a, 0x34, + 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x0a, 0x12, 0x03, 0x46, 0x04, 0x23, 0x22, 0x25, 0x20, + 0x43, 0x61, 0x73, 0x65, 0x20, 0x69, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, + 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x0a, 0x01, 0x12, + 0x03, 0x46, 0x04, 0x1d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x0a, 0x02, 0x12, + 0x03, 0x46, 0x20, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x49, 0x02, + 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, 0x03, 0x49, 0x02, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x49, 0x0b, 0x13, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x49, 0x16, 0x17, 0x0a, 0x23, 0x0a, 0x04, 0x04, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x4c, 0x02, 0x13, 0x1a, 0x16, 0x20, 0x65, 0x2e, 0x67, 0x2e, 0x20, + 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x72, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x05, 0x12, 0x03, 0x4c, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x4c, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x4c, 0x11, 0x12, 0x0a, 0x5c, 0x0a, 0x04, 0x04, 0x02, + 0x02, 0x02, 0x12, 0x03, 0x4f, 0x02, 0x1d, 0x1a, 0x4f, 0x20, 0x4f, 0x6e, 0x6c, 0x79, 0x20, 0x69, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, + 0x56, 0x41, 0x4c, 0x55, 0x45, 0x5f, 0x49, 0x4e, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x2c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x65, + 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, + 0x04, 0x12, 0x03, 0x4f, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x05, 0x12, + 0x03, 0x4f, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, 0x4f, + 0x12, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x03, 0x12, 0x03, 0x4f, 0x1b, 0x1c, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0x90, 0x08, 0x0a, 0x24, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x63, 0x6f, + 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x10, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2a, 0x6c, 0x0a, 0x10, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, + 0x73, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x4f, 0x55, 0x52, 0x43, + 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, + 0x0a, 0x0a, 0x06, 0x47, 0x4c, 0x4f, 0x42, 0x41, 0x4c, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x44, + 0x4f, 0x4d, 0x41, 0x49, 0x4e, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, 0x50, 0x52, 0x4f, 0x4a, 0x45, + 0x43, 0x54, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, 0x5f, + 0x44, 0x4f, 0x4d, 0x41, 0x49, 0x4e, 0x10, 0x04, 0x12, 0x07, 0x0a, 0x03, 0x4f, 0x52, 0x47, 0x10, + 0x05, 0x42, 0xc1, 0x01, 0x0a, 0x14, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x42, 0x12, 0x43, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, + 0x5a, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, + 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x10, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xca, + 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0xe2, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0xea, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x4a, 0x9b, 0x05, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x19, 0x01, + 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, + 0x03, 0x02, 0x00, 0x19, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x04, 0x00, 0x4b, 0x0a, 0x09, + 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x04, 0x00, 0x4b, 0x0a, 0x52, 0x0a, 0x02, 0x05, 0x00, 0x12, + 0x04, 0x07, 0x00, 0x19, 0x01, 0x1a, 0x46, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, + 0x74, 0x65, 0x2e, 0x20, 0x57, 0x65, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, + 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x20, 0x69, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x05, 0x00, 0x01, 0x12, 0x03, 0x07, 0x05, 0x15, 0x0a, 0x29, 0x0a, 0x04, 0x05, 0x00, 0x02, + 0x00, 0x12, 0x03, 0x09, 0x02, 0x19, 0x1a, 0x1c, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x20, 0x69, 0x73, 0x20, 0x75, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x09, + 0x02, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x09, 0x17, 0x18, + 0x0a, 0x3b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0c, 0x02, 0x0d, 0x1a, 0x2e, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x20, 0x63, 0x6f, + 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x0c, 0x0b, 0x0c, 0x0a, 0x3b, 0x0a, 0x04, 0x05, 0x00, 0x02, + 0x02, 0x12, 0x03, 0x0f, 0x02, 0x0d, 0x1a, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, + 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x0f, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x0f, + 0x0b, 0x0c, 0x0a, 0x3c, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x03, 0x12, 0x03, 0x12, 0x02, 0x0e, 0x1a, + 0x2f, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x12, 0x02, 0x09, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x12, 0x0c, 0x0d, 0x0a, 0x43, 0x0a, 0x04, + 0x05, 0x00, 0x02, 0x04, 0x12, 0x03, 0x15, 0x02, 0x15, 0x1a, 0x36, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, + 0x20, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2d, 0x64, 0x6f, 0x6d, 0x61, 0x69, + 0x6e, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x15, 0x02, 0x10, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, 0x15, 0x13, 0x14, 0x0a, 0x38, 0x0a, + 0x04, 0x05, 0x00, 0x02, 0x05, 0x12, 0x03, 0x18, 0x02, 0x0a, 0x1a, 0x2b, 0x20, 0x54, 0x68, 0x65, + 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, + 0x73, 0x20, 0x61, 0x20, 0x6f, 0x72, 0x67, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x05, 0x01, + 0x12, 0x03, 0x18, 0x02, 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x05, 0x02, 0x12, 0x03, + 0x18, 0x08, 0x09, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xb3, 0x0c, 0x0a, 0x1c, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2f, 0x70, 0x68, 0x61, 0x73, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2a, 0x90, + 0x02, 0x0a, 0x0b, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x68, 0x61, 0x73, 0x65, 0x12, 0x1c, + 0x0a, 0x18, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x48, 0x41, 0x53, 0x45, 0x5f, 0x55, + 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, + 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x48, 0x41, 0x53, 0x45, 0x5f, 0x51, 0x55, 0x45, + 0x55, 0x45, 0x44, 0x10, 0x01, 0x12, 0x26, 0x0a, 0x22, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, + 0x50, 0x48, 0x41, 0x53, 0x45, 0x5f, 0x57, 0x41, 0x49, 0x54, 0x49, 0x4e, 0x47, 0x5f, 0x46, 0x4f, + 0x52, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x53, 0x10, 0x02, 0x12, 0x1d, 0x0a, + 0x19, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x48, 0x41, 0x53, 0x45, 0x5f, 0x49, 0x4e, + 0x49, 0x54, 0x49, 0x41, 0x4c, 0x49, 0x5a, 0x49, 0x4e, 0x47, 0x10, 0x03, 0x12, 0x18, 0x0a, 0x14, + 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x48, 0x41, 0x53, 0x45, 0x5f, 0x52, 0x55, 0x4e, + 0x4e, 0x49, 0x4e, 0x47, 0x10, 0x04, 0x12, 0x1a, 0x0a, 0x16, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, + 0x5f, 0x50, 0x48, 0x41, 0x53, 0x45, 0x5f, 0x53, 0x55, 0x43, 0x43, 0x45, 0x45, 0x44, 0x45, 0x44, + 0x10, 0x05, 0x12, 0x17, 0x0a, 0x13, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x48, 0x41, + 0x53, 0x45, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x10, 0x06, 0x12, 0x18, 0x0a, 0x14, 0x41, + 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x48, 0x41, 0x53, 0x45, 0x5f, 0x41, 0x42, 0x4f, 0x52, + 0x54, 0x45, 0x44, 0x10, 0x07, 0x12, 0x1a, 0x0a, 0x16, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, + 0x50, 0x48, 0x41, 0x53, 0x45, 0x5f, 0x54, 0x49, 0x4d, 0x45, 0x44, 0x5f, 0x4f, 0x55, 0x54, 0x10, + 0x08, 0x42, 0xb9, 0x01, 0x0a, 0x14, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x42, 0x0a, 0x50, 0x68, 0x61, 0x73, + 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, + 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xa2, 0x02, + 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xca, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xe2, 0x02, 0x1c, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x5c, 0x47, 0x50, + 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x4a, 0xa9, 0x08, + 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x25, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, + 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x19, 0x0a, 0x08, 0x0a, 0x01, + 0x08, 0x12, 0x03, 0x04, 0x00, 0x4b, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x04, 0x00, + 0x4b, 0x0a, 0xd9, 0x01, 0x0a, 0x02, 0x05, 0x00, 0x12, 0x04, 0x0a, 0x00, 0x25, 0x01, 0x1a, 0xcc, + 0x01, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x68, 0x61, 0x73, 0x65, 0x20, 0x72, 0x65, + 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, + 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x20, 0x50, 0x68, 0x61, + 0x73, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, + 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x79, 0x70, 0x69, 0x63, + 0x61, 0x6c, 0x20, 0x66, 0x6c, 0x6f, 0x77, 0x3a, 0x0a, 0x20, 0x51, 0x55, 0x45, 0x55, 0x45, 0x44, + 0x20, 0x2d, 0x3e, 0x20, 0x57, 0x41, 0x49, 0x54, 0x49, 0x4e, 0x47, 0x5f, 0x46, 0x4f, 0x52, 0x5f, + 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x53, 0x20, 0x2d, 0x3e, 0x20, 0x49, 0x4e, 0x49, + 0x54, 0x49, 0x41, 0x4c, 0x49, 0x5a, 0x49, 0x4e, 0x47, 0x20, 0x2d, 0x3e, 0x20, 0x52, 0x55, 0x4e, + 0x4e, 0x49, 0x4e, 0x47, 0x20, 0x2d, 0x3e, 0x20, 0x7b, 0x53, 0x55, 0x43, 0x43, 0x45, 0x45, 0x44, + 0x45, 0x44, 0x7c, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x7c, 0x41, 0x42, 0x4f, 0x52, 0x54, 0x45, + 0x44, 0x7c, 0x54, 0x49, 0x4d, 0x45, 0x44, 0x5f, 0x4f, 0x55, 0x54, 0x7d, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x05, 0x00, 0x01, 0x12, 0x03, 0x0a, 0x05, 0x10, 0x0a, 0x24, 0x0a, 0x04, 0x05, 0x00, 0x02, + 0x00, 0x12, 0x03, 0x0c, 0x02, 0x1f, 0x1a, 0x17, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, + 0x2f, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0c, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x0c, 0x1d, 0x1e, 0x0a, 0x46, 0x0a, 0x04, 0x05, + 0x00, 0x02, 0x01, 0x12, 0x03, 0x0f, 0x02, 0x1a, 0x1a, 0x39, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x68, 0x61, 0x73, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x20, 0x61, 0x63, 0x63, 0x65, 0x70, + 0x74, 0x65, 0x64, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x69, 0x73, 0x20, 0x77, 0x61, 0x69, 0x74, 0x69, + 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, + 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0f, 0x02, + 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x0f, 0x18, 0x19, 0x0a, + 0x58, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x02, 0x12, 0x03, 0x12, 0x02, 0x29, 0x1a, 0x4b, 0x20, 0x41, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, + 0x65, 0x64, 0x20, 0x62, 0x75, 0x74, 0x20, 0x77, 0x61, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x63, 0x6f, 0x6d, 0x65, 0x20, 0x61, + 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x12, 0x02, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x02, + 0x12, 0x03, 0x12, 0x27, 0x28, 0x0a, 0x4b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x03, 0x12, 0x03, 0x15, + 0x02, 0x20, 0x1a, 0x3e, 0x20, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x20, 0x68, + 0x61, 0x76, 0x65, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, + 0x65, 0x64, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x69, 0x73, 0x20, 0x62, 0x65, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x65, 0x74, 0x20, 0x75, + 0x70, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x15, 0x02, 0x1b, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x15, 0x1e, 0x1f, 0x0a, 0x2b, + 0x0a, 0x04, 0x05, 0x00, 0x02, 0x04, 0x12, 0x03, 0x18, 0x02, 0x1b, 0x1a, 0x1e, 0x20, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, + 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x18, 0x02, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, + 0x04, 0x02, 0x12, 0x03, 0x18, 0x19, 0x1a, 0x0a, 0x2c, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x05, 0x12, + 0x03, 0x1b, 0x02, 0x1d, 0x1a, 0x1f, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x6f, + 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x20, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, + 0x75, 0x6c, 0x6c, 0x79, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, + 0x1b, 0x02, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x05, 0x02, 0x12, 0x03, 0x1b, 0x1b, + 0x1c, 0x0a, 0x2d, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x06, 0x12, 0x03, 0x1e, 0x02, 0x1a, 0x1a, 0x20, + 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x64, + 0x75, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x1e, 0x02, 0x15, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x00, 0x02, 0x06, 0x02, 0x12, 0x03, 0x1e, 0x18, 0x19, 0x0a, 0x3a, 0x0a, 0x04, + 0x05, 0x00, 0x02, 0x07, 0x12, 0x03, 0x21, 0x02, 0x1b, 0x1a, 0x2d, 0x20, 0x41, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x77, 0x61, 0x73, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, + 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x72, 0x20, 0x63, 0x61, + 0x6e, 0x63, 0x65, 0x6c, 0x6c, 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x07, + 0x01, 0x12, 0x03, 0x21, 0x02, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x07, 0x02, 0x12, + 0x03, 0x21, 0x19, 0x1a, 0x0a, 0x37, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x08, 0x12, 0x03, 0x24, 0x02, + 0x1d, 0x1a, 0x2a, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x78, 0x63, 0x65, 0x65, + 0x64, 0x65, 0x64, 0x20, 0x69, 0x74, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x08, 0x01, 0x12, 0x03, 0x24, 0x02, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x08, 0x02, 0x12, 0x03, 0x24, 0x1b, 0x1c, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, +]; +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/flyteidl2.connector.rs b/gen/rust/src/flyteidl2.connector.rs new file mode 100644 index 0000000000..2420fb0607 --- /dev/null +++ b/gen/rust/src/flyteidl2.connector.rs @@ -0,0 +1,1355 @@ +// @generated +// This file is @generated by prost-build. +/// Represents a subset of runtime task execution metadata that are relevant to external plugins. +/// +/// ID of the task execution +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskExecutionMetadata { + #[prost(message, optional, tag="1")] + pub task_execution_id: ::core::option::Option, + /// k8s namespace where the task is executed in + #[prost(string, tag="2")] + pub namespace: ::prost::alloc::string::String, + /// Labels attached to the task execution + #[prost(map="string, string", tag="3")] + pub labels: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + /// Annotations attached to the task execution + #[prost(map="string, string", tag="4")] + pub annotations: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + /// k8s service account associated with the task execution + #[prost(string, tag="5")] + pub k8s_service_account: ::prost::alloc::string::String, + /// Environment variables attached to the task execution + #[prost(map="string, string", tag="6")] + pub environment_variables: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + /// Represents the maximum number of attempts allowed for a task. + /// If a task fails, it can be retried up to this maximum number of attempts. + #[prost(int32, tag="7")] + pub max_attempts: i32, + /// Indicates whether the task execution can be interrupted. + /// If set to true, the task can be stopped before completion. + #[prost(bool, tag="8")] + pub interruptible: bool, + /// Specifies the threshold for failure count at which the interruptible property + /// will take effect. If the number of consecutive task failures exceeds this threshold, + /// interruptible behavior will be activated. + #[prost(int32, tag="9")] + pub interruptible_failure_threshold: i32, + /// Identity of user running this task execution + #[prost(message, optional, tag="11")] + pub identity: ::core::option::Option, +} +/// Represents a request structure to create task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateTaskRequest { + /// The inputs required to start the execution. All required inputs must be + /// included in this map. If not required and not provided, defaults apply. + /// +optional + #[prost(message, optional, tag="1")] + pub inputs: ::core::option::Option, + /// Template of the task that encapsulates all the metadata of the task. + #[prost(message, optional, tag="2")] + pub template: ::core::option::Option, + /// Prefix for where task output data will be written. (e.g. s3://my-bucket/randomstring) + #[prost(string, tag="3")] + pub output_prefix: ::prost::alloc::string::String, + /// subset of runtime task execution metadata. + #[prost(message, optional, tag="4")] + pub task_execution_metadata: ::core::option::Option, + /// Connection (secret and config) required by the connector. + /// Connector will use the secret and config in the taskTemplate if it's None. + /// +optional + #[prost(message, optional, tag="5")] + pub connection: ::core::option::Option, +} +/// Represents a create response structure. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateTaskResponse { + /// ResourceMeta is created by the connector. It could be a string (jobId) or a dict (more complex metadata). + #[prost(bytes="vec", tag="1")] + pub resource_meta: ::prost::alloc::vec::Vec, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateRequestHeader { + /// Template of the task that encapsulates all the metadata of the task. + #[prost(message, optional, tag="1")] + pub template: ::core::option::Option, + /// Prefix for where task output data will be written. (e.g. s3://my-bucket/randomstring) + #[prost(string, tag="2")] + pub output_prefix: ::prost::alloc::string::String, + /// subset of runtime task execution metadata. + #[prost(message, optional, tag="3")] + pub task_execution_metadata: ::core::option::Option, + /// MaxDatasetSizeBytes is the maximum size of the dataset that can be generated by the task. + #[prost(int64, tag="4")] + pub max_dataset_size_bytes: i64, + /// Connection (secret and config) required by the connector. + /// Connector will use the secret and config in the taskTemplate if it's None. + /// +optional + #[prost(message, optional, tag="5")] + pub connection: ::core::option::Option, +} +/// A message used to fetch a job resource from flyte connector server. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTaskRequest { + /// Metadata about the resource to be pass to the connector. + #[prost(bytes="vec", tag="2")] + pub resource_meta: ::prost::alloc::vec::Vec, + /// A predefined yet extensible Task type identifier. + #[prost(message, optional, tag="3")] + pub task_category: ::core::option::Option, + /// Prefix for where task output data will be written. (e.g. s3://my-bucket/randomstring) + #[prost(string, tag="4")] + pub output_prefix: ::prost::alloc::string::String, + /// Connection (secret and config) required by the connector. + /// Connector will use the secret and config in the taskTemplate if it's None. + /// +optional + #[prost(message, optional, tag="5")] + pub connection: ::core::option::Option, +} +/// Response to get an individual task resource. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTaskResponse { + #[prost(message, optional, tag="1")] + pub resource: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Resource { + /// The outputs of the execution. It's typically used by sql task. connector service will create a + /// Structured dataset pointing to the query result table. + /// +optional + #[prost(message, optional, tag="2")] + pub outputs: ::core::option::Option, + /// A descriptive message for the current state. e.g. waiting for cluster. + #[prost(string, tag="3")] + pub message: ::prost::alloc::string::String, + /// log information for the task execution. + #[prost(message, repeated, tag="4")] + pub log_links: ::prost::alloc::vec::Vec, + /// The phase of the execution is used to determine the phase of the plugin's execution. + #[prost(enumeration="super::core::task_execution::Phase", tag="5")] + pub phase: i32, + /// Custom data specific to the connector. + #[prost(message, optional, tag="6")] + pub custom_info: ::core::option::Option, +} +/// A message used to delete a task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DeleteTaskRequest { + /// Metadata about the resource to be pass to the connector. + #[prost(bytes="vec", tag="2")] + pub resource_meta: ::prost::alloc::vec::Vec, + /// A predefined yet extensible Task type identifier. + #[prost(message, optional, tag="3")] + pub task_category: ::core::option::Option, + /// Connection (secret and config) required by the connector. + /// Connector will use the secret and config in the taskTemplate if it's None. + /// +optional + #[prost(message, optional, tag="5")] + pub connection: ::core::option::Option, +} +/// Response to delete a task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct DeleteTaskResponse { +} +/// A message containing the connector metadata. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Connector { + /// Name is the developer-assigned name of the connector. + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// Supported_task_categories are the categories of the tasks that the connector can handle. + #[prost(message, repeated, tag="4")] + pub supported_task_categories: ::prost::alloc::vec::Vec, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskCategory { + /// The name of the task type. + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// The version of the task type. + #[prost(int32, tag="2")] + pub version: i32, +} +/// A request to get an connector. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetConnectorRequest { + /// The name of the connector. + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, +} +/// A response containing an connector. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetConnectorResponse { + #[prost(message, optional, tag="1")] + pub connector: ::core::option::Option, +} +/// A request to list all connectors. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct ListConnectorsRequest { +} +/// A response containing a list of connectors. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListConnectorsResponse { + #[prost(message, repeated, tag="1")] + pub connectors: ::prost::alloc::vec::Vec, +} +/// A request to get the metrics from a task execution. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTaskMetricsRequest { + /// Metadata is created by the connector. It could be a string (jobId) or a dict (more complex metadata). + #[prost(bytes="vec", tag="2")] + pub resource_meta: ::prost::alloc::vec::Vec, + /// The metrics to query. If empty, will return a default set of metrics. + /// e.g. EXECUTION_METRIC_USED_CPU_AVG or EXECUTION_METRIC_USED_MEMORY_BYTES_AVG + #[prost(string, repeated, tag="3")] + pub queries: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Start timestamp, inclusive. + #[prost(message, optional, tag="4")] + pub start_time: ::core::option::Option, + /// End timestamp, inclusive.. + #[prost(message, optional, tag="5")] + pub end_time: ::core::option::Option, + /// Query resolution step width in duration format or float number of seconds. + #[prost(message, optional, tag="6")] + pub step: ::core::option::Option, + /// A predefined yet extensible Task type identifier. + #[prost(message, optional, tag="7")] + pub task_category: ::core::option::Option, +} +/// A response containing a list of metrics for a task execution. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTaskMetricsResponse { + /// The execution metric results. + #[prost(message, repeated, tag="1")] + pub results: ::prost::alloc::vec::Vec, +} +/// A request to get the log from a task execution. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTaskLogsRequest { + /// Metadata is created by the connector. It could be a string (jobId) or a dict (more complex metadata). + #[prost(bytes="vec", tag="2")] + pub resource_meta: ::prost::alloc::vec::Vec, + /// Number of lines to return. + #[prost(uint64, tag="3")] + pub lines: u64, + /// In the case of multiple pages of results, the server-provided token can be used to fetch the next page + /// in a query. If there are no more results, this value will be empty. + #[prost(string, tag="4")] + pub token: ::prost::alloc::string::String, + /// A predefined yet extensible Task type identifier. + #[prost(message, optional, tag="5")] + pub task_category: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTaskLogsResponseHeader { + /// In the case of multiple pages of results, the server-provided token can be used to fetch the next page + /// in a query. If there are no more results, this value will be empty. + #[prost(string, tag="1")] + pub token: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTaskLogsResponseBody { + /// The execution log results. + #[prost(string, repeated, tag="1")] + pub results: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +/// A response containing the logs for a task execution. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTaskLogsResponse { + #[prost(oneof="get_task_logs_response::Part", tags="1, 2")] + pub part: ::core::option::Option, +} +/// Nested message and enum types in `GetTaskLogsResponse`. +pub mod get_task_logs_response { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Part { + #[prost(message, tag="1")] + Header(super::GetTaskLogsResponseHeader), + #[prost(message, tag="2")] + Body(super::GetTaskLogsResponseBody), + } +} +/// Encoded file descriptor set for the `flyteidl2.connector` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xa4, 0x67, 0x0a, 0x23, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, + 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x13, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x1a, 0x1e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x6d, + 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x73, 0x65, 0x63, + 0x75, 0x72, 0x69, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1a, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x61, 0x73, 0x6b, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x22, 0xef, 0x06, 0x0a, 0x15, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x53, 0x0a, + 0x11, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x52, 0x0f, 0x74, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, + 0x12, 0x4e, 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x36, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4c, 0x61, 0x62, + 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, + 0x12, 0x5d, 0x0a, 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, + 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x54, 0x61, 0x73, 0x6b, + 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, + 0x2e, 0x0a, 0x13, 0x6b, 0x38, 0x73, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x61, + 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x6b, 0x38, + 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, + 0x79, 0x0a, 0x15, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x76, + 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x44, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x45, 0x6e, 0x76, 0x69, 0x72, + 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x14, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, + 0x74, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x61, + 0x78, 0x5f, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x0b, 0x6d, 0x61, 0x78, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x12, 0x24, 0x0a, + 0x0d, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, + 0x62, 0x6c, 0x65, 0x12, 0x46, 0x0a, 0x1f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, + 0x69, 0x62, 0x6c, 0x65, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x5f, 0x74, 0x68, 0x72, + 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x1d, 0x69, 0x6e, + 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x46, 0x61, 0x69, 0x6c, 0x75, + 0x72, 0x65, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x34, 0x0a, 0x08, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x08, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x1a, 0x39, 0x0a, 0x0b, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, + 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3e, 0x0a, 0x10, + 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, + 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x47, 0x0a, 0x19, + 0x45, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x56, 0x61, 0x72, 0x69, 0x61, + 0x62, 0x6c, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xc2, 0x02, 0x0a, 0x11, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2e, 0x0a, 0x06, 0x69, + 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x49, 0x6e, 0x70, + 0x75, 0x74, 0x73, 0x52, 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x12, 0x38, 0x0a, 0x08, 0x74, + 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, + 0x61, 0x73, 0x6b, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x08, 0x74, 0x65, 0x6d, + 0x70, 0x6c, 0x61, 0x74, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, + 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, 0x75, + 0x74, 0x70, 0x75, 0x74, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x62, 0x0a, 0x17, 0x74, 0x61, + 0x73, 0x6b, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x15, 0x74, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x3a, + 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, + 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x39, 0x0a, 0x12, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, + 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x4d, 0x65, 0x74, 0x61, 0x22, 0xc9, 0x02, 0x0a, 0x13, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x38, 0x0a, + 0x08, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x08, 0x74, + 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x6f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, + 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x62, 0x0a, 0x17, + 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x15, 0x74, 0x61, 0x73, 0x6b, 0x45, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x12, 0x33, 0x0a, 0x16, 0x6d, 0x61, 0x78, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x5f, + 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x13, 0x6d, 0x61, 0x78, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x53, 0x69, 0x7a, 0x65, + 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x3a, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x22, 0xde, 0x01, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x72, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x46, 0x0a, 0x0d, 0x74, 0x61, 0x73, + 0x6b, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x43, 0x61, 0x74, 0x65, 0x67, + 0x6f, 0x72, 0x79, 0x52, 0x0c, 0x74, 0x61, 0x73, 0x6b, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, + 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x70, 0x72, 0x65, 0x66, + 0x69, 0x78, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, + 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x3a, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x22, 0x4c, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x08, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x22, 0x82, 0x02, 0x0a, 0x08, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x31, 0x0a, + 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x52, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, + 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x34, 0x0a, 0x09, 0x6c, 0x6f, + 0x67, 0x5f, 0x6c, 0x69, 0x6e, 0x6b, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, + 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x52, 0x08, 0x6c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x6b, 0x73, + 0x12, 0x39, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x50, + 0x68, 0x61, 0x73, 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x38, 0x0a, 0x0b, 0x63, + 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x0a, 0x63, 0x75, 0x73, 0x74, 0x6f, + 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0xbc, 0x01, 0x0a, 0x11, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x61, + 0x12, 0x46, 0x0a, 0x0d, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, + 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x54, 0x61, + 0x73, 0x6b, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x52, 0x0c, 0x74, 0x61, 0x73, 0x6b, + 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x12, 0x3a, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, + 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x14, 0x0a, 0x12, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x61, + 0x73, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x7e, 0x0a, 0x09, 0x43, 0x6f, + 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x5d, 0x0a, 0x19, 0x73, + 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, + 0x74, 0x65, 0x67, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, + 0x79, 0x52, 0x17, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x54, 0x61, 0x73, 0x6b, + 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x22, 0x3c, 0x0a, 0x0c, 0x54, 0x61, + 0x73, 0x6b, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x18, + 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x29, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x43, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x22, 0x54, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3c, 0x0a, 0x09, 0x63, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x09, + 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x22, 0x17, 0x0a, 0x15, 0x4c, 0x69, 0x73, + 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x22, 0x58, 0x0a, 0x16, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0a, + 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x22, 0xbf, 0x02, 0x0a, + 0x15, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x18, 0x0a, 0x07, 0x71, + 0x75, 0x65, 0x72, 0x69, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x71, 0x75, + 0x65, 0x72, 0x69, 0x65, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, + 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, + 0x12, 0x35, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x07, + 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x2d, 0x0a, 0x04, 0x73, 0x74, 0x65, 0x70, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x04, 0x73, 0x74, 0x65, 0x70, 0x12, 0x46, 0x0a, 0x0d, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, + 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, + 0x52, 0x0c, 0x74, 0x61, 0x73, 0x6b, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x22, 0x59, + 0x0a, 0x16, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0xad, 0x01, 0x0a, 0x12, 0x47, 0x65, + 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, + 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, + 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, + 0x6e, 0x12, 0x46, 0x0a, 0x0d, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, + 0x72, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x54, + 0x61, 0x73, 0x6b, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x52, 0x0c, 0x74, 0x61, 0x73, + 0x6b, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x22, 0x31, 0x0a, 0x19, 0x47, 0x65, 0x74, + 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x33, 0x0a, 0x17, + 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x42, 0x6f, 0x64, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, + 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x73, 0x22, 0xab, 0x01, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x48, 0x0a, 0x06, 0x68, 0x65, 0x61, + 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, + 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x48, 0x00, 0x52, 0x06, 0x68, 0x65, 0x61, + 0x64, 0x65, 0x72, 0x12, 0x42, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x2c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4c, + 0x6f, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x6f, 0x64, 0x79, 0x48, + 0x00, 0x52, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x42, 0x06, 0x0a, 0x04, 0x70, 0x61, 0x72, 0x74, 0x42, + 0xcf, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x42, 0x0e, 0x43, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x37, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, + 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, + 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x13, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, + 0x6f, 0x72, 0xca, 0x02, 0x13, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0xe2, 0x02, 0x1f, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5c, 0x47, + 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x4a, 0x9b, 0x46, 0x0a, 0x07, 0x12, 0x05, 0x00, 0x00, 0xdc, 0x01, 0x01, 0x0a, 0x08, 0x0a, + 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, + 0x1c, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x28, 0x0a, 0x09, 0x0a, 0x02, + 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x29, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, + 0x00, 0x26, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x03, 0x12, 0x03, 0x07, 0x00, 0x27, 0x0a, 0x09, 0x0a, + 0x02, 0x03, 0x04, 0x12, 0x03, 0x08, 0x00, 0x24, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x05, 0x12, 0x03, + 0x09, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x06, 0x12, 0x03, 0x0a, 0x00, 0x28, 0x0a, 0x09, + 0x0a, 0x02, 0x03, 0x07, 0x12, 0x03, 0x0b, 0x00, 0x26, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x08, 0x12, + 0x03, 0x0c, 0x00, 0x29, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x0e, 0x00, 0x4e, 0x0a, 0x09, + 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x0e, 0x00, 0x4e, 0x0a, 0x87, 0x01, 0x0a, 0x02, 0x04, 0x00, + 0x12, 0x04, 0x11, 0x00, 0x2b, 0x01, 0x1a, 0x5f, 0x20, 0x52, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, + 0x6e, 0x74, 0x73, 0x20, 0x61, 0x20, 0x73, 0x75, 0x62, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, + 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x72, 0x65, 0x20, 0x72, 0x65, 0x6c, 0x65, 0x76, 0x61, 0x6e, + 0x74, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x70, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x0a, 0x22, 0x1a, 0x20, 0x49, 0x44, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x11, 0x08, 0x1d, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x14, 0x02, 0x35, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x14, 0x02, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x14, 0x1f, 0x30, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x14, 0x33, 0x34, 0x0a, 0x3a, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, + 0x16, 0x02, 0x17, 0x1a, 0x2d, 0x20, 0x6b, 0x38, 0x73, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, + 0x73, 0x6b, 0x20, 0x69, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x20, 0x69, + 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x16, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x16, 0x09, 0x12, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x16, 0x15, 0x16, 0x0a, 0x34, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x18, 0x02, 0x21, 0x1a, 0x27, 0x20, 0x4c, 0x61, 0x62, 0x65, + 0x6c, 0x73, 0x20, 0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x18, 0x02, 0x15, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x18, 0x16, 0x1c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x18, 0x1f, 0x20, 0x0a, 0x39, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x1a, 0x02, 0x26, 0x1a, 0x2c, 0x20, 0x41, 0x6e, 0x6e, 0x6f, + 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x06, + 0x12, 0x03, 0x1a, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, + 0x1a, 0x16, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x1a, 0x24, + 0x25, 0x0a, 0x45, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, 0x1c, 0x02, 0x21, 0x1a, 0x38, + 0x20, 0x6b, 0x38, 0x73, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x61, 0x63, 0x63, + 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, + 0x05, 0x12, 0x03, 0x1c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, + 0x03, 0x1c, 0x09, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, 0x1c, + 0x1f, 0x20, 0x0a, 0x43, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x1e, 0x02, 0x30, 0x1a, + 0x36, 0x20, 0x45, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, + 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x06, + 0x12, 0x03, 0x1e, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, + 0x1e, 0x16, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x03, 0x12, 0x03, 0x1e, 0x2e, + 0x2f, 0x0a, 0x98, 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x06, 0x12, 0x03, 0x21, 0x02, 0x19, 0x1a, + 0x8a, 0x01, 0x20, 0x52, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, + 0x20, 0x6f, 0x66, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x20, 0x61, 0x6c, 0x6c, + 0x6f, 0x77, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x0a, 0x20, 0x49, 0x66, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x66, 0x61, 0x69, 0x6c, + 0x73, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x74, + 0x72, 0x69, 0x65, 0x64, 0x20, 0x75, 0x70, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, + 0x66, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x06, 0x05, 0x12, 0x03, 0x21, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x06, 0x01, 0x12, 0x03, 0x21, 0x08, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, + 0x03, 0x12, 0x03, 0x21, 0x17, 0x18, 0x0a, 0x83, 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x07, 0x12, + 0x03, 0x24, 0x02, 0x19, 0x1a, 0x76, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, + 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, + 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x61, 0x6e, 0x20, + 0x62, 0x65, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x65, 0x64, 0x2e, 0x0a, + 0x20, 0x49, 0x66, 0x20, 0x73, 0x65, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, + 0x20, 0x73, 0x74, 0x6f, 0x70, 0x70, 0x65, 0x64, 0x20, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, + 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x07, 0x05, 0x12, 0x03, 0x24, 0x02, 0x06, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x07, 0x01, 0x12, 0x03, 0x24, 0x07, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x07, + 0x03, 0x12, 0x03, 0x24, 0x17, 0x18, 0x0a, 0xde, 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x08, 0x12, + 0x03, 0x28, 0x02, 0x2c, 0x1a, 0xd0, 0x01, 0x20, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x20, 0x63, 0x6f, 0x75, 0x6e, + 0x74, 0x20, 0x61, 0x74, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x70, 0x72, 0x6f, + 0x70, 0x65, 0x72, 0x74, 0x79, 0x0a, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x74, 0x61, 0x6b, 0x65, + 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x66, 0x61, 0x69, 0x6c, 0x75, + 0x72, 0x65, 0x73, 0x20, 0x65, 0x78, 0x63, 0x65, 0x65, 0x64, 0x73, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x2c, 0x0a, 0x20, 0x69, 0x6e, 0x74, + 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x62, 0x65, 0x68, 0x61, 0x76, + 0x69, 0x6f, 0x72, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, + 0x76, 0x61, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x05, + 0x12, 0x03, 0x28, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x01, 0x12, 0x03, + 0x28, 0x08, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x03, 0x12, 0x03, 0x28, 0x2a, + 0x2b, 0x0a, 0x3b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x09, 0x12, 0x03, 0x2a, 0x02, 0x1e, 0x1a, 0x2e, + 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x75, 0x73, 0x65, + 0x72, 0x20, 0x72, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, + 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x09, 0x06, 0x12, 0x03, 0x2a, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x09, 0x01, 0x12, 0x03, 0x2a, 0x10, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x09, 0x03, 0x12, 0x03, 0x2a, 0x1b, 0x1d, 0x0a, 0x3c, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, + 0x2e, 0x00, 0x3d, 0x01, 0x1a, 0x30, 0x20, 0x52, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, + 0x73, 0x20, 0x61, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x73, 0x74, 0x72, 0x75, + 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, + 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x2e, + 0x08, 0x19, 0x0a, 0xab, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x32, 0x02, 0x19, + 0x1a, 0x9d, 0x01, 0x20, 0x54, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x20, 0x72, + 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, + 0x41, 0x6c, 0x6c, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x70, + 0x75, 0x74, 0x73, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x69, 0x6e, 0x63, + 0x6c, 0x75, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x61, + 0x70, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, + 0x65, 0x64, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x64, 0x2c, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x61, 0x70, + 0x70, 0x6c, 0x79, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x32, 0x02, 0x0d, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x32, 0x0e, 0x14, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x32, 0x17, 0x18, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x01, 0x12, 0x03, 0x34, 0x02, 0x21, 0x1a, 0x46, 0x20, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, + 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x65, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, + 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x06, 0x12, 0x03, 0x34, 0x02, 0x13, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x34, 0x14, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x34, 0x1f, 0x20, 0x0a, 0x64, 0x0a, 0x04, 0x04, 0x01, 0x02, + 0x02, 0x12, 0x03, 0x36, 0x02, 0x1b, 0x1a, 0x57, 0x20, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x6f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, + 0x62, 0x65, 0x20, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x2e, 0x20, 0x28, 0x65, 0x2e, 0x67, + 0x2e, 0x20, 0x73, 0x33, 0x3a, 0x2f, 0x2f, 0x6d, 0x79, 0x2d, 0x62, 0x75, 0x63, 0x6b, 0x65, 0x74, + 0x2f, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x29, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x05, 0x12, 0x03, 0x36, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x36, 0x09, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x36, 0x19, 0x1a, 0x0a, 0x39, 0x0a, 0x04, 0x04, 0x01, 0x02, + 0x03, 0x12, 0x03, 0x38, 0x02, 0x34, 0x1a, 0x2c, 0x20, 0x73, 0x75, 0x62, 0x73, 0x65, 0x74, 0x20, + 0x6f, 0x66, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x06, 0x12, 0x03, 0x38, + 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x01, 0x12, 0x03, 0x38, 0x18, 0x2f, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x03, 0x12, 0x03, 0x38, 0x32, 0x33, 0x0a, 0xa0, + 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x04, 0x12, 0x03, 0x3c, 0x02, 0x21, 0x1a, 0x92, 0x01, 0x20, + 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x20, 0x72, + 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x0a, 0x20, 0x43, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x54, + 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x69, 0x66, 0x20, 0x69, 0x74, 0x27, 0x73, 0x20, + 0x4e, 0x6f, 0x6e, 0x65, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x06, 0x12, 0x03, 0x3c, 0x02, 0x11, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x01, 0x12, 0x03, 0x3c, 0x12, 0x1c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x04, 0x03, 0x12, 0x03, 0x3c, 0x1f, 0x20, 0x0a, 0x35, 0x0a, 0x02, 0x04, + 0x02, 0x12, 0x04, 0x40, 0x00, 0x43, 0x01, 0x1a, 0x29, 0x20, 0x52, 0x65, 0x70, 0x72, 0x65, 0x73, + 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x72, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, + 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x40, 0x08, 0x1a, 0x0a, 0x78, + 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x42, 0x02, 0x1a, 0x1a, 0x6b, 0x20, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x20, 0x69, 0x73, 0x20, 0x63, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x20, 0x49, 0x74, 0x20, 0x63, 0x6f, 0x75, 0x6c, 0x64, + 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x28, 0x6a, 0x6f, + 0x62, 0x49, 0x64, 0x29, 0x20, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x64, 0x69, 0x63, 0x74, 0x20, 0x28, + 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x78, 0x20, 0x6d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x29, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, + 0x05, 0x12, 0x03, 0x42, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x42, 0x08, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x42, + 0x18, 0x19, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x45, 0x00, 0x52, 0x01, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x45, 0x08, 0x1b, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x03, + 0x02, 0x00, 0x12, 0x03, 0x47, 0x02, 0x21, 0x1a, 0x46, 0x20, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, + 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x65, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, + 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x47, 0x02, 0x13, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x47, 0x14, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x47, 0x1f, 0x20, 0x0a, 0x64, 0x0a, 0x04, 0x04, 0x03, 0x02, + 0x01, 0x12, 0x03, 0x49, 0x02, 0x1b, 0x1a, 0x57, 0x20, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x6f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, + 0x62, 0x65, 0x20, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x2e, 0x20, 0x28, 0x65, 0x2e, 0x67, + 0x2e, 0x20, 0x73, 0x33, 0x3a, 0x2f, 0x2f, 0x6d, 0x79, 0x2d, 0x62, 0x75, 0x63, 0x6b, 0x65, 0x74, + 0x2f, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x29, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x05, 0x12, 0x03, 0x49, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, 0x49, 0x09, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x49, 0x19, 0x1a, 0x0a, 0x39, 0x0a, 0x04, 0x04, 0x03, 0x02, + 0x02, 0x12, 0x03, 0x4b, 0x02, 0x34, 0x1a, 0x2c, 0x20, 0x73, 0x75, 0x62, 0x73, 0x65, 0x74, 0x20, + 0x6f, 0x66, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x06, 0x12, 0x03, 0x4b, + 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x01, 0x12, 0x03, 0x4b, 0x18, 0x2f, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x03, 0x12, 0x03, 0x4b, 0x32, 0x33, 0x0a, 0x68, + 0x0a, 0x04, 0x04, 0x03, 0x02, 0x03, 0x12, 0x03, 0x4d, 0x02, 0x23, 0x1a, 0x5b, 0x20, 0x4d, 0x61, + 0x78, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x53, 0x69, 0x7a, 0x65, 0x42, 0x79, 0x74, 0x65, + 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, + 0x20, 0x73, 0x69, 0x7a, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x61, 0x74, + 0x61, 0x73, 0x65, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, + 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, + 0x05, 0x12, 0x03, 0x4d, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x01, 0x12, + 0x03, 0x4d, 0x08, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x03, 0x12, 0x03, 0x4d, + 0x21, 0x22, 0x0a, 0xa0, 0x01, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x04, 0x12, 0x03, 0x51, 0x02, 0x21, + 0x1a, 0x92, 0x01, 0x20, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x29, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x0a, 0x20, 0x43, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x75, 0x73, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x61, 0x6e, 0x64, + 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, + 0x61, 0x73, 0x6b, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x69, 0x66, 0x20, 0x69, + 0x74, 0x27, 0x73, 0x20, 0x4e, 0x6f, 0x6e, 0x65, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x06, 0x12, 0x03, + 0x51, 0x02, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x01, 0x12, 0x03, 0x51, 0x12, + 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x03, 0x12, 0x03, 0x51, 0x1f, 0x20, 0x0a, + 0x51, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x55, 0x00, 0x60, 0x01, 0x1a, 0x45, 0x20, 0x41, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x66, 0x65, 0x74, 0x63, 0x68, 0x20, 0x61, 0x20, 0x6a, 0x6f, 0x62, 0x20, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x20, + 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x55, 0x08, 0x16, 0x0a, 0x47, + 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x57, 0x02, 0x1a, 0x1a, 0x3a, 0x20, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, + 0x70, 0x61, 0x73, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x05, + 0x12, 0x03, 0x57, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x57, 0x08, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x57, 0x18, + 0x19, 0x0a, 0x40, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x59, 0x02, 0x21, 0x1a, 0x33, + 0x20, 0x41, 0x20, 0x70, 0x72, 0x65, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x79, 0x65, + 0x74, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x54, 0x61, 0x73, + 0x6b, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x06, 0x12, 0x03, 0x59, 0x02, + 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x59, 0x0f, 0x1c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x59, 0x1f, 0x20, 0x0a, 0x64, 0x0a, + 0x04, 0x04, 0x04, 0x02, 0x02, 0x12, 0x03, 0x5b, 0x02, 0x1b, 0x1a, 0x57, 0x20, 0x50, 0x72, 0x65, + 0x66, 0x69, 0x78, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x74, 0x61, + 0x73, 0x6b, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x77, + 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x2e, 0x20, + 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x73, 0x33, 0x3a, 0x2f, 0x2f, 0x6d, 0x79, 0x2d, 0x62, 0x75, + 0x63, 0x6b, 0x65, 0x74, 0x2f, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x73, 0x74, 0x72, 0x69, 0x6e, + 0x67, 0x29, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x05, 0x12, 0x03, 0x5b, 0x02, + 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x5b, 0x09, 0x16, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, 0x5b, 0x19, 0x1a, 0x0a, 0xa0, 0x01, + 0x0a, 0x04, 0x04, 0x04, 0x02, 0x03, 0x12, 0x03, 0x5f, 0x02, 0x21, 0x1a, 0x92, 0x01, 0x20, 0x43, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x20, 0x72, 0x65, + 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, + 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x0a, 0x20, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x54, 0x65, + 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x69, 0x66, 0x20, 0x69, 0x74, 0x27, 0x73, 0x20, 0x4e, + 0x6f, 0x6e, 0x65, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x06, 0x12, 0x03, 0x5f, 0x02, 0x11, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x01, 0x12, 0x03, 0x5f, 0x12, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x03, 0x03, 0x12, 0x03, 0x5f, 0x1f, 0x20, 0x0a, 0x3a, 0x0a, 0x02, 0x04, 0x05, + 0x12, 0x04, 0x63, 0x00, 0x65, 0x01, 0x1a, 0x2e, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x20, 0x74, 0x6f, 0x20, 0x67, 0x65, 0x74, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x69, + 0x76, 0x69, 0x64, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x63, + 0x08, 0x17, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x64, 0x02, 0x18, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x06, 0x12, 0x03, 0x64, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x64, 0x0b, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x64, 0x16, 0x17, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x06, 0x12, + 0x04, 0x67, 0x00, 0x74, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x03, 0x67, 0x08, + 0x10, 0x0a, 0xb1, 0x01, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x03, 0x6b, 0x02, 0x1b, 0x1a, + 0xa3, 0x01, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, + 0x20, 0x49, 0x74, 0x27, 0x73, 0x20, 0x74, 0x79, 0x70, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, + 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x73, 0x71, 0x6c, 0x20, 0x74, 0x61, 0x73, 0x6b, + 0x2e, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x20, 0x73, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, + 0x61, 0x0a, 0x20, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x20, 0x64, 0x61, + 0x74, 0x61, 0x73, 0x65, 0x74, 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x74, + 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x20, 0x72, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x20, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x06, 0x12, 0x03, + 0x6b, 0x02, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x03, 0x6b, 0x0f, + 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x03, 0x6b, 0x19, 0x1a, 0x0a, + 0x55, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x01, 0x12, 0x03, 0x6d, 0x02, 0x15, 0x1a, 0x48, 0x20, 0x41, + 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x76, 0x65, 0x20, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x74, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x2e, 0x20, 0x65, 0x2e, 0x67, 0x2e, + 0x20, 0x77, 0x61, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x63, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x05, 0x12, + 0x03, 0x6d, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x01, 0x12, 0x03, 0x6d, + 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x03, 0x12, 0x03, 0x6d, 0x13, 0x14, + 0x0a, 0x36, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x02, 0x12, 0x03, 0x6f, 0x02, 0x26, 0x1a, 0x29, 0x20, + 0x6c, 0x6f, 0x67, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, + 0x04, 0x12, 0x03, 0x6f, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x06, 0x12, + 0x03, 0x6f, 0x0b, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x01, 0x12, 0x03, 0x6f, + 0x18, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x03, 0x12, 0x03, 0x6f, 0x24, 0x25, + 0x0a, 0x63, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x03, 0x12, 0x03, 0x71, 0x02, 0x25, 0x1a, 0x56, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, + 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x64, 0x65, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x27, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x03, 0x06, 0x12, 0x03, + 0x71, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x03, 0x01, 0x12, 0x03, 0x71, 0x1b, + 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x03, 0x03, 0x12, 0x03, 0x71, 0x23, 0x24, 0x0a, + 0x35, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x04, 0x12, 0x03, 0x73, 0x02, 0x29, 0x1a, 0x28, 0x20, 0x43, + 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x63, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x06, 0x12, + 0x03, 0x73, 0x02, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x01, 0x12, 0x03, 0x73, + 0x19, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x03, 0x12, 0x03, 0x73, 0x27, 0x28, + 0x0a, 0x2f, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x05, 0x77, 0x00, 0x80, 0x01, 0x01, 0x1a, 0x22, 0x20, + 0x41, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, + 0x6f, 0x20, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x03, 0x77, 0x08, 0x19, 0x0a, 0x47, 0x0a, + 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x03, 0x79, 0x02, 0x1a, 0x1a, 0x3a, 0x20, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, + 0x61, 0x73, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x05, 0x12, + 0x03, 0x79, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x01, 0x12, 0x03, 0x79, + 0x08, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x03, 0x12, 0x03, 0x79, 0x18, 0x19, + 0x0a, 0x40, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x01, 0x12, 0x03, 0x7b, 0x02, 0x21, 0x1a, 0x33, 0x20, + 0x41, 0x20, 0x70, 0x72, 0x65, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x79, 0x65, 0x74, + 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x54, 0x61, 0x73, 0x6b, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x06, 0x12, 0x03, 0x7b, 0x02, 0x0e, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x01, 0x12, 0x03, 0x7b, 0x0f, 0x1c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, 0x03, 0x7b, 0x1f, 0x20, 0x0a, 0xa0, 0x01, 0x0a, + 0x04, 0x04, 0x07, 0x02, 0x02, 0x12, 0x03, 0x7f, 0x02, 0x21, 0x1a, 0x92, 0x01, 0x20, 0x43, 0x6f, + 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x20, 0x72, 0x65, 0x71, + 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x0a, 0x20, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, + 0x6f, 0x72, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x54, 0x65, 0x6d, + 0x70, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x69, 0x66, 0x20, 0x69, 0x74, 0x27, 0x73, 0x20, 0x4e, 0x6f, + 0x6e, 0x65, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x06, 0x12, 0x03, 0x7f, 0x02, 0x11, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x02, 0x01, 0x12, 0x03, 0x7f, 0x12, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x02, 0x03, 0x12, 0x03, 0x7f, 0x1f, 0x20, 0x0a, 0x28, 0x0a, 0x02, 0x04, 0x08, 0x12, + 0x04, 0x83, 0x01, 0x00, 0x1d, 0x1a, 0x1c, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x20, 0x74, 0x6f, 0x20, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, + 0x6b, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x08, 0x01, 0x12, 0x04, 0x83, 0x01, 0x08, 0x1a, + 0x0a, 0x3c, 0x0a, 0x02, 0x04, 0x09, 0x12, 0x06, 0x86, 0x01, 0x00, 0x8b, 0x01, 0x01, 0x1a, 0x2e, + 0x20, 0x41, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x0a, 0x0a, 0x0b, + 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, 0x04, 0x86, 0x01, 0x08, 0x11, 0x0a, 0x45, 0x0a, 0x04, 0x04, + 0x09, 0x02, 0x00, 0x12, 0x04, 0x88, 0x01, 0x02, 0x12, 0x1a, 0x37, 0x20, 0x4e, 0x61, 0x6d, 0x65, + 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, + 0x72, 0x2d, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x05, 0x12, 0x04, 0x88, 0x01, 0x02, + 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x04, 0x88, 0x01, 0x09, 0x0d, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, 0x04, 0x88, 0x01, 0x10, 0x11, 0x0a, + 0x68, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x01, 0x12, 0x04, 0x8a, 0x01, 0x02, 0x36, 0x1a, 0x5a, 0x20, + 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, + 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x20, 0x63, 0x61, 0x6e, + 0x20, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, + 0x01, 0x04, 0x12, 0x04, 0x8a, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, + 0x06, 0x12, 0x04, 0x8a, 0x01, 0x0b, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x01, + 0x12, 0x04, 0x8a, 0x01, 0x18, 0x31, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x03, 0x12, + 0x04, 0x8a, 0x01, 0x34, 0x35, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x06, 0x8d, 0x01, 0x00, + 0x92, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0a, 0x01, 0x12, 0x04, 0x8d, 0x01, 0x08, 0x14, + 0x0a, 0x2a, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x00, 0x12, 0x04, 0x8f, 0x01, 0x02, 0x12, 0x1a, 0x1c, + 0x20, 0x54, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0a, 0x02, 0x00, 0x05, 0x12, 0x04, 0x8f, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0a, 0x02, 0x00, 0x01, 0x12, 0x04, 0x8f, 0x01, 0x09, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, + 0x02, 0x00, 0x03, 0x12, 0x04, 0x8f, 0x01, 0x10, 0x11, 0x0a, 0x2d, 0x0a, 0x04, 0x04, 0x0a, 0x02, + 0x01, 0x12, 0x04, 0x91, 0x01, 0x02, 0x14, 0x1a, 0x1f, 0x20, 0x54, 0x68, 0x65, 0x20, 0x76, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, + 0x6b, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, + 0x05, 0x12, 0x04, 0x91, 0x01, 0x02, 0x07, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x01, + 0x12, 0x04, 0x91, 0x01, 0x08, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x03, 0x12, + 0x04, 0x91, 0x01, 0x12, 0x13, 0x0a, 0x2e, 0x0a, 0x02, 0x04, 0x0b, 0x12, 0x06, 0x95, 0x01, 0x00, + 0x98, 0x01, 0x01, 0x1a, 0x20, 0x20, 0x41, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, + 0x74, 0x6f, 0x20, 0x67, 0x65, 0x74, 0x20, 0x61, 0x6e, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0b, 0x01, 0x12, 0x04, 0x95, 0x01, + 0x08, 0x1b, 0x0a, 0x2a, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x00, 0x12, 0x04, 0x97, 0x01, 0x02, 0x12, + 0x1a, 0x1c, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x05, 0x12, 0x04, 0x97, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0b, 0x02, 0x00, 0x01, 0x12, 0x04, 0x97, 0x01, 0x09, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0b, 0x02, 0x00, 0x03, 0x12, 0x04, 0x97, 0x01, 0x10, 0x11, 0x0a, 0x33, 0x0a, 0x02, 0x04, + 0x0c, 0x12, 0x06, 0x9b, 0x01, 0x00, 0x9d, 0x01, 0x01, 0x1a, 0x25, 0x20, 0x41, 0x20, 0x72, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, + 0x67, 0x20, 0x61, 0x6e, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x0a, + 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0c, 0x01, 0x12, 0x04, 0x9b, 0x01, 0x08, 0x1c, 0x0a, 0x0c, 0x0a, + 0x04, 0x04, 0x0c, 0x02, 0x00, 0x12, 0x04, 0x9c, 0x01, 0x02, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0c, 0x02, 0x00, 0x06, 0x12, 0x04, 0x9c, 0x01, 0x02, 0x0b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, + 0x02, 0x00, 0x01, 0x12, 0x04, 0x9c, 0x01, 0x0c, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, + 0x00, 0x03, 0x12, 0x04, 0x9c, 0x01, 0x18, 0x19, 0x0a, 0x2f, 0x0a, 0x02, 0x04, 0x0d, 0x12, 0x04, + 0xa0, 0x01, 0x00, 0x20, 0x1a, 0x23, 0x20, 0x41, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x20, 0x74, 0x6f, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x63, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0d, 0x01, + 0x12, 0x04, 0xa0, 0x01, 0x08, 0x1d, 0x0a, 0x3b, 0x0a, 0x02, 0x04, 0x0e, 0x12, 0x06, 0xa3, 0x01, + 0x00, 0xa5, 0x01, 0x01, 0x1a, 0x2d, 0x20, 0x41, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x6c, + 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0x73, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0e, 0x01, 0x12, 0x04, 0xa3, 0x01, 0x08, 0x1e, + 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x00, 0x12, 0x04, 0xa4, 0x01, 0x02, 0x24, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x04, 0x12, 0x04, 0xa4, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x00, 0x06, 0x12, 0x04, 0xa4, 0x01, 0x0b, 0x14, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x00, 0x01, 0x12, 0x04, 0xa4, 0x01, 0x15, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x00, 0x03, 0x12, 0x04, 0xa4, 0x01, 0x22, 0x23, 0x0a, 0x43, 0x0a, 0x02, 0x04, 0x0f, + 0x12, 0x06, 0xa8, 0x01, 0x00, 0xb6, 0x01, 0x01, 0x1a, 0x35, 0x20, 0x41, 0x20, 0x72, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x67, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x20, 0x74, + 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, + 0x0b, 0x0a, 0x03, 0x04, 0x0f, 0x01, 0x12, 0x04, 0xa8, 0x01, 0x08, 0x1d, 0x0a, 0x75, 0x0a, 0x04, + 0x04, 0x0f, 0x02, 0x00, 0x12, 0x04, 0xaa, 0x01, 0x02, 0x1a, 0x1a, 0x67, 0x20, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x69, 0x73, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x2e, 0x20, 0x49, 0x74, 0x20, 0x63, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x61, + 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x28, 0x6a, 0x6f, 0x62, 0x49, 0x64, 0x29, 0x20, + 0x6f, 0x72, 0x20, 0x61, 0x20, 0x64, 0x69, 0x63, 0x74, 0x20, 0x28, 0x6d, 0x6f, 0x72, 0x65, 0x20, + 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x78, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x29, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x05, 0x12, 0x04, 0xaa, 0x01, + 0x02, 0x07, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x01, 0x12, 0x04, 0xaa, 0x01, 0x08, + 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x03, 0x12, 0x04, 0xaa, 0x01, 0x18, 0x19, + 0x0a, 0xa4, 0x01, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x01, 0x12, 0x04, 0xad, 0x01, 0x02, 0x1e, 0x1a, + 0x95, 0x01, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x20, 0x74, + 0x6f, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x65, 0x6d, 0x70, 0x74, + 0x79, 0x2c, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, + 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, + 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x2e, 0x0a, 0x20, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x45, + 0x58, 0x45, 0x43, 0x55, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x4d, 0x45, 0x54, 0x52, 0x49, 0x43, 0x5f, + 0x55, 0x53, 0x45, 0x44, 0x5f, 0x43, 0x50, 0x55, 0x5f, 0x41, 0x56, 0x47, 0x20, 0x6f, 0x72, 0x20, + 0x45, 0x58, 0x45, 0x43, 0x55, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x4d, 0x45, 0x54, 0x52, 0x49, 0x43, + 0x5f, 0x55, 0x53, 0x45, 0x44, 0x5f, 0x4d, 0x45, 0x4d, 0x4f, 0x52, 0x59, 0x5f, 0x42, 0x59, 0x54, + 0x45, 0x53, 0x5f, 0x41, 0x56, 0x47, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x04, + 0x12, 0x04, 0xad, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x05, 0x12, + 0x04, 0xad, 0x01, 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x01, 0x12, 0x04, + 0xad, 0x01, 0x12, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x03, 0x12, 0x04, 0xad, + 0x01, 0x1c, 0x1d, 0x0a, 0x2b, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x02, 0x12, 0x04, 0xaf, 0x01, 0x02, + 0x2b, 0x1a, 0x1d, 0x20, 0x53, 0x74, 0x61, 0x72, 0x74, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x02, 0x06, 0x12, 0x04, 0xaf, 0x01, 0x02, 0x1b, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x02, 0x01, 0x12, 0x04, 0xaf, 0x01, 0x1c, 0x26, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x02, 0x03, 0x12, 0x04, 0xaf, 0x01, 0x29, 0x2a, 0x0a, 0x2a, 0x0a, + 0x04, 0x04, 0x0f, 0x02, 0x03, 0x12, 0x04, 0xb1, 0x01, 0x02, 0x29, 0x1a, 0x1c, 0x20, 0x45, 0x6e, + 0x64, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2c, 0x20, 0x69, 0x6e, 0x63, + 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, + 0x03, 0x06, 0x12, 0x04, 0xb1, 0x01, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x03, + 0x01, 0x12, 0x04, 0xb1, 0x01, 0x1c, 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x03, 0x03, + 0x12, 0x04, 0xb1, 0x01, 0x27, 0x28, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x04, 0x12, 0x04, + 0xb3, 0x01, 0x02, 0x24, 0x1a, 0x4c, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x20, 0x72, 0x65, 0x73, + 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x74, 0x65, 0x70, 0x20, 0x77, 0x69, 0x64, + 0x74, 0x68, 0x20, 0x69, 0x6e, 0x20, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x6e, + 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x04, 0x06, 0x12, 0x04, 0xb3, 0x01, 0x02, + 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x04, 0x01, 0x12, 0x04, 0xb3, 0x01, 0x1b, 0x1f, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x04, 0x03, 0x12, 0x04, 0xb3, 0x01, 0x22, 0x23, 0x0a, + 0x41, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x05, 0x12, 0x04, 0xb5, 0x01, 0x02, 0x21, 0x1a, 0x33, 0x20, + 0x41, 0x20, 0x70, 0x72, 0x65, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x79, 0x65, 0x74, + 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x54, 0x61, 0x73, 0x6b, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x05, 0x06, 0x12, 0x04, 0xb5, 0x01, 0x02, + 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x05, 0x01, 0x12, 0x04, 0xb5, 0x01, 0x0f, 0x1c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x05, 0x03, 0x12, 0x04, 0xb5, 0x01, 0x1f, 0x20, 0x0a, + 0x4d, 0x0a, 0x02, 0x04, 0x10, 0x12, 0x06, 0xb9, 0x01, 0x00, 0xbc, 0x01, 0x01, 0x1a, 0x3f, 0x20, + 0x41, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, + 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x74, 0x61, + 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0b, + 0x0a, 0x03, 0x04, 0x10, 0x01, 0x12, 0x04, 0xb9, 0x01, 0x08, 0x1e, 0x0a, 0x2d, 0x0a, 0x04, 0x04, + 0x10, 0x02, 0x00, 0x12, 0x04, 0xbb, 0x01, 0x02, 0x32, 0x1a, 0x1f, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, + 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, + 0x02, 0x00, 0x04, 0x12, 0x04, 0xbb, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, + 0x00, 0x06, 0x12, 0x04, 0xbb, 0x01, 0x0b, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, + 0x01, 0x12, 0x04, 0xbb, 0x01, 0x26, 0x2d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, 0x03, + 0x12, 0x04, 0xbb, 0x01, 0x30, 0x31, 0x0a, 0x3f, 0x0a, 0x02, 0x04, 0x11, 0x12, 0x06, 0xbf, 0x01, + 0x00, 0xc9, 0x01, 0x01, 0x1a, 0x31, 0x20, 0x41, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x20, 0x74, 0x6f, 0x20, 0x67, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x67, 0x20, + 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x11, 0x01, 0x12, 0x04, + 0xbf, 0x01, 0x08, 0x1a, 0x0a, 0x75, 0x0a, 0x04, 0x04, 0x11, 0x02, 0x00, 0x12, 0x04, 0xc1, 0x01, + 0x02, 0x1a, 0x1a, 0x67, 0x20, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x69, 0x73, + 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x20, 0x49, 0x74, 0x20, 0x63, 0x6f, + 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, + 0x28, 0x6a, 0x6f, 0x62, 0x49, 0x64, 0x29, 0x20, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x64, 0x69, 0x63, + 0x74, 0x20, 0x28, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x78, 0x20, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x29, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x11, 0x02, 0x00, 0x05, 0x12, 0x04, 0xc1, 0x01, 0x02, 0x07, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, + 0x02, 0x00, 0x01, 0x12, 0x04, 0xc1, 0x01, 0x08, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, + 0x00, 0x03, 0x12, 0x04, 0xc1, 0x01, 0x18, 0x19, 0x0a, 0x2a, 0x0a, 0x04, 0x04, 0x11, 0x02, 0x01, + 0x12, 0x04, 0xc3, 0x01, 0x02, 0x13, 0x1a, 0x1c, 0x20, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, + 0x6f, 0x66, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x01, 0x05, 0x12, 0x04, 0xc3, + 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x01, 0x01, 0x12, 0x04, 0xc3, 0x01, + 0x09, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x01, 0x03, 0x12, 0x04, 0xc3, 0x01, 0x11, + 0x12, 0x0a, 0xbc, 0x01, 0x0a, 0x04, 0x04, 0x11, 0x02, 0x02, 0x12, 0x04, 0xc6, 0x01, 0x02, 0x13, + 0x1a, 0xad, 0x01, 0x20, 0x49, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x70, 0x61, 0x67, 0x65, + 0x73, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2c, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2d, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x75, + 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x65, 0x74, 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x70, 0x61, 0x67, 0x65, 0x0a, 0x20, 0x69, 0x6e, 0x20, 0x61, + 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, + 0x20, 0x61, 0x72, 0x65, 0x20, 0x6e, 0x6f, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x72, 0x65, 0x73, + 0x75, 0x6c, 0x74, 0x73, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x02, 0x05, 0x12, 0x04, 0xc6, 0x01, 0x02, 0x08, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x02, 0x01, 0x12, 0x04, 0xc6, 0x01, 0x09, 0x0e, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x11, 0x02, 0x02, 0x03, 0x12, 0x04, 0xc6, 0x01, 0x11, 0x12, 0x0a, 0x41, 0x0a, + 0x04, 0x04, 0x11, 0x02, 0x03, 0x12, 0x04, 0xc8, 0x01, 0x02, 0x21, 0x1a, 0x33, 0x20, 0x41, 0x20, + 0x70, 0x72, 0x65, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x79, 0x65, 0x74, 0x20, 0x65, + 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x20, 0x74, + 0x79, 0x70, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x03, 0x06, 0x12, 0x04, 0xc8, 0x01, 0x02, 0x0e, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x03, 0x01, 0x12, 0x04, 0xc8, 0x01, 0x0f, 0x1c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x11, 0x02, 0x03, 0x03, 0x12, 0x04, 0xc8, 0x01, 0x1f, 0x20, 0x0a, 0x0c, 0x0a, + 0x02, 0x04, 0x12, 0x12, 0x06, 0xcb, 0x01, 0x00, 0xcf, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, + 0x12, 0x01, 0x12, 0x04, 0xcb, 0x01, 0x08, 0x21, 0x0a, 0xbc, 0x01, 0x0a, 0x04, 0x04, 0x12, 0x02, + 0x00, 0x12, 0x04, 0xce, 0x01, 0x02, 0x13, 0x1a, 0xad, 0x01, 0x20, 0x49, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, + 0x6c, 0x65, 0x20, 0x70, 0x61, 0x67, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x73, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2d, + 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x63, + 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x65, + 0x74, 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x70, 0x61, 0x67, + 0x65, 0x0a, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x20, 0x49, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6e, 0x6f, 0x20, 0x6d, + 0x6f, 0x72, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2c, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, + 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x00, 0x05, + 0x12, 0x04, 0xce, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x00, 0x01, 0x12, + 0x04, 0xce, 0x01, 0x09, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x00, 0x03, 0x12, 0x04, + 0xce, 0x01, 0x11, 0x12, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x13, 0x12, 0x06, 0xd1, 0x01, 0x00, 0xd4, + 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x13, 0x01, 0x12, 0x04, 0xd1, 0x01, 0x08, 0x1f, 0x0a, + 0x2a, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x00, 0x12, 0x04, 0xd3, 0x01, 0x02, 0x1e, 0x1a, 0x1c, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6c, 0x6f, + 0x67, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x13, 0x02, 0x00, 0x04, 0x12, 0x04, 0xd3, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, + 0x02, 0x00, 0x05, 0x12, 0x04, 0xd3, 0x01, 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, + 0x00, 0x01, 0x12, 0x04, 0xd3, 0x01, 0x12, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x00, + 0x03, 0x12, 0x04, 0xd3, 0x01, 0x1c, 0x1d, 0x0a, 0x44, 0x0a, 0x02, 0x04, 0x14, 0x12, 0x06, 0xd7, + 0x01, 0x00, 0xdc, 0x01, 0x01, 0x1a, 0x36, 0x20, 0x41, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, + 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, + 0x03, 0x04, 0x14, 0x01, 0x12, 0x04, 0xd7, 0x01, 0x08, 0x1b, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x14, + 0x08, 0x00, 0x12, 0x06, 0xd8, 0x01, 0x02, 0xdb, 0x01, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, + 0x08, 0x00, 0x01, 0x12, 0x04, 0xd8, 0x01, 0x08, 0x0c, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x14, 0x02, + 0x00, 0x12, 0x04, 0xd9, 0x01, 0x04, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x00, 0x06, + 0x12, 0x04, 0xd9, 0x01, 0x04, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x00, 0x01, 0x12, + 0x04, 0xd9, 0x01, 0x1e, 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x00, 0x03, 0x12, 0x04, + 0xd9, 0x01, 0x27, 0x28, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x14, 0x02, 0x01, 0x12, 0x04, 0xda, 0x01, + 0x04, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x01, 0x06, 0x12, 0x04, 0xda, 0x01, 0x04, + 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x01, 0x01, 0x12, 0x04, 0xda, 0x01, 0x1c, 0x20, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x01, 0x03, 0x12, 0x04, 0xda, 0x01, 0x23, 0x24, 0x62, + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xed, 0x19, 0x0a, 0x21, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2f, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x13, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, + 0x6f, 0x72, 0x1a, 0x23, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, + 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0xae, 0x07, 0x0a, 0x15, 0x41, 0x73, 0x79, 0x6e, 0x63, 0x43, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, + 0x80, 0x01, 0x0a, 0x0a, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x26, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x61, 0x73, 0x6b, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1b, 0x3a, 0x01, 0x2a, 0x22, 0x16, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2f, 0x74, 0x61, + 0x73, 0x6b, 0x12, 0xb1, 0x01, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x23, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, + 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x5b, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x55, 0x12, 0x53, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x7b, 0x74, 0x61, 0x73, 0x6b, 0x5f, + 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x2f, 0x7b, + 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x2e, 0x76, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x7d, 0x2f, 0x7b, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x7d, 0x12, 0xc5, 0x01, 0x0a, 0x0a, 0x44, 0x65, 0x6c, 0x65, 0x74, + 0x65, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x44, 0x65, 0x6c, 0x65, + 0x74, 0x65, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x66, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x60, 0x2a, 0x5e, + 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x2f, 0x7b, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, + 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x2f, 0x7b, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, 0x74, + 0x65, 0x67, 0x6f, 0x72, 0x79, 0x2e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x7d, 0x2f, 0x7b, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x7d, 0x12, 0xce, + 0x01, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, + 0x73, 0x12, 0x2a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4d, + 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x72, 0x69, + 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x63, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x5d, 0x12, 0x5b, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x6d, 0x65, 0x74, 0x72, 0x69, + 0x63, 0x73, 0x2f, 0x7b, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, + 0x79, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x2f, 0x7b, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, + 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x2e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x7d, 0x2f, + 0x7b, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x7d, 0x12, + 0xc4, 0x01, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x73, 0x12, + 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x47, + 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x60, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x5a, 0x12, 0x58, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2f, 0x74, 0x61, + 0x73, 0x6b, 0x2f, 0x6c, 0x6f, 0x67, 0x73, 0x2f, 0x7b, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x61, + 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x2f, 0x7b, 0x74, 0x61, + 0x73, 0x6b, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x2e, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x7d, 0x2f, 0x7b, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6d, + 0x65, 0x74, 0x61, 0x7d, 0x30, 0x01, 0x32, 0xaa, 0x02, 0x0a, 0x18, 0x43, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x53, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x12, 0x85, 0x01, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x12, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, + 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x1a, 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, 0x85, 0x01, 0x0a, 0x0e, + 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x12, 0x2a, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, + 0x6f, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x12, + 0x12, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, + 0x6f, 0x72, 0x73, 0x42, 0xcd, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x42, + 0x0c, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, + 0x37, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, + 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, + 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, + 0x13, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x6f, 0x72, 0xca, 0x02, 0x13, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0xe2, 0x02, 0x1f, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x4a, 0xb9, 0x0d, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x37, 0x01, 0x0a, 0x08, + 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x01, + 0x00, 0x1c, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x03, 0x00, 0x2d, 0x0a, 0x09, 0x0a, + 0x02, 0x03, 0x01, 0x12, 0x03, 0x04, 0x00, 0x26, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x06, + 0x00, 0x4e, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x06, 0x00, 0x4e, 0x0a, 0x8b, 0x01, + 0x0a, 0x02, 0x06, 0x00, 0x12, 0x04, 0x09, 0x00, 0x29, 0x01, 0x1a, 0x7f, 0x20, 0x41, 0x73, 0x79, + 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x52, 0x50, + 0x43, 0x20, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, + 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x20, 0x74, + 0x6f, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x61, 0x73, 0x79, 0x6e, 0x63, + 0x68, 0x72, 0x6f, 0x6e, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x06, + 0x00, 0x01, 0x12, 0x03, 0x09, 0x08, 0x1d, 0x0a, 0x50, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x00, 0x12, + 0x04, 0x0b, 0x02, 0x10, 0x03, 0x1a, 0x42, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x61, + 0x73, 0x6b, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x73, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, + 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x74, + 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x20, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x0b, 0x06, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x02, + 0x12, 0x03, 0x0b, 0x11, 0x36, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x0b, 0x41, 0x67, 0x0a, 0x0d, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x04, 0x12, 0x04, 0x0c, 0x04, + 0x0f, 0x06, 0x0a, 0x11, 0x0a, 0x09, 0x06, 0x00, 0x02, 0x00, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x12, + 0x04, 0x0c, 0x04, 0x0f, 0x06, 0x0a, 0x11, 0x0a, 0x0a, 0x06, 0x00, 0x02, 0x00, 0x04, 0xb0, 0xca, + 0xbc, 0x22, 0x04, 0x12, 0x03, 0x0d, 0x06, 0x24, 0x0a, 0x11, 0x0a, 0x0a, 0x06, 0x00, 0x02, 0x00, + 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x07, 0x12, 0x03, 0x0e, 0x06, 0x0f, 0x0a, 0x1f, 0x0a, 0x04, 0x06, + 0x00, 0x02, 0x01, 0x12, 0x04, 0x13, 0x02, 0x15, 0x03, 0x1a, 0x11, 0x20, 0x47, 0x65, 0x74, 0x20, + 0x6a, 0x6f, 0x62, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x13, 0x06, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x01, 0x02, 0x12, 0x03, 0x13, 0x0e, 0x30, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x13, 0x3b, 0x5e, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x04, 0x12, + 0x03, 0x14, 0x04, 0x7c, 0x0a, 0x10, 0x0a, 0x09, 0x06, 0x00, 0x02, 0x01, 0x04, 0xb0, 0xca, 0xbc, + 0x22, 0x12, 0x03, 0x14, 0x04, 0x7c, 0x0a, 0x11, 0x0a, 0x0a, 0x06, 0x00, 0x02, 0x01, 0x04, 0xb0, + 0xca, 0xbc, 0x22, 0x02, 0x12, 0x03, 0x14, 0x20, 0x7a, 0x0a, 0x29, 0x0a, 0x04, 0x06, 0x00, 0x02, + 0x02, 0x12, 0x04, 0x18, 0x02, 0x1a, 0x03, 0x1a, 0x1b, 0x20, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x18, + 0x06, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x18, 0x11, 0x36, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x18, 0x41, 0x67, 0x0a, 0x0d, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x04, 0x12, 0x04, 0x19, 0x04, 0x8a, 0x01, 0x0a, 0x11, 0x0a, + 0x09, 0x06, 0x00, 0x02, 0x02, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x12, 0x04, 0x19, 0x04, 0x8a, 0x01, + 0x0a, 0x12, 0x0a, 0x0a, 0x06, 0x00, 0x02, 0x02, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x05, 0x12, 0x04, + 0x19, 0x20, 0x88, 0x01, 0x0a, 0xd1, 0x01, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x03, 0x12, 0x04, 0x21, + 0x02, 0x23, 0x03, 0x1a, 0xc2, 0x01, 0x20, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4d, 0x65, + 0x74, 0x72, 0x69, 0x63, 0x73, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x6f, 0x6e, + 0x65, 0x20, 0x6f, 0x72, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, + 0x2c, 0x20, 0x69, 0x66, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, + 0x0a, 0x20, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, + 0x0a, 0x20, 0x20, 0x2a, 0x20, 0x4f, 0x75, 0x74, 0x4f, 0x66, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x20, + 0x69, 0x66, 0x20, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6e, + 0x6f, 0x74, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x74, + 0x61, 0x73, 0x6b, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x0a, 0x20, + 0x20, 0x2a, 0x20, 0x76, 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, + 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, + 0x01, 0x12, 0x03, 0x21, 0x06, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x02, 0x12, + 0x03, 0x21, 0x15, 0x3e, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x21, + 0x49, 0x73, 0x0a, 0x0d, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x04, 0x12, 0x04, 0x22, 0x04, 0x84, + 0x01, 0x0a, 0x11, 0x0a, 0x09, 0x06, 0x00, 0x02, 0x03, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x12, 0x04, + 0x22, 0x04, 0x84, 0x01, 0x0a, 0x12, 0x0a, 0x0a, 0x06, 0x00, 0x02, 0x03, 0x04, 0xb0, 0xca, 0xbc, + 0x22, 0x02, 0x12, 0x04, 0x22, 0x20, 0x82, 0x01, 0x0a, 0x46, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x04, + 0x12, 0x04, 0x26, 0x02, 0x28, 0x03, 0x1a, 0x38, 0x20, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, + 0x4c, 0x6f, 0x67, 0x73, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x61, 0x73, + 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6c, 0x6f, 0x67, 0x73, + 0x2c, 0x20, 0x69, 0x66, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x26, 0x06, 0x11, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, 0x26, 0x12, 0x38, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x04, 0x06, 0x12, 0x03, 0x26, 0x43, 0x49, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x04, 0x03, 0x12, 0x03, 0x26, 0x4a, 0x71, 0x0a, 0x0d, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x04, + 0x04, 0x12, 0x04, 0x27, 0x04, 0x81, 0x01, 0x0a, 0x11, 0x0a, 0x09, 0x06, 0x00, 0x02, 0x04, 0x04, + 0xb0, 0xca, 0xbc, 0x22, 0x12, 0x04, 0x27, 0x04, 0x81, 0x01, 0x0a, 0x11, 0x0a, 0x0a, 0x06, 0x00, + 0x02, 0x04, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x02, 0x12, 0x03, 0x27, 0x20, 0x7f, 0x0a, 0xb8, 0x01, + 0x0a, 0x02, 0x06, 0x01, 0x12, 0x04, 0x2d, 0x00, 0x37, 0x01, 0x1a, 0xab, 0x01, 0x20, 0x43, 0x6f, + 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x53, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x61, + 0x6e, 0x20, 0x52, 0x50, 0x43, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x64, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x48, 0x54, 0x54, 0x50, 0x20, 0x76, 0x69, 0x61, 0x20, + 0x67, 0x72, 0x70, 0x63, 0x2d, 0x67, 0x61, 0x74, 0x65, 0x77, 0x61, 0x79, 0x2e, 0x0a, 0x20, 0x54, + 0x68, 0x69, 0x73, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x61, 0x6c, 0x6c, 0x6f, + 0x77, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x75, + 0x73, 0x65, 0x72, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x67, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x6f, 0x66, 0x20, 0x63, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x06, 0x01, 0x01, 0x12, + 0x03, 0x2d, 0x08, 0x20, 0x0a, 0x4a, 0x0a, 0x04, 0x06, 0x01, 0x02, 0x00, 0x12, 0x04, 0x2f, 0x02, + 0x31, 0x03, 0x1a, 0x3c, 0x20, 0x46, 0x65, 0x74, 0x63, 0x68, 0x20, 0x61, 0x20, 0x3a, 0x72, 0x65, + 0x66, 0x3a, 0x60, 0x72, 0x65, 0x66, 0x5f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, + 0x6f, 0x72, 0x60, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2f, 0x06, 0x12, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x01, 0x02, 0x00, 0x02, 0x12, 0x03, 0x2f, 0x13, 0x3a, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x2f, 0x45, 0x6d, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x01, + 0x02, 0x00, 0x04, 0x12, 0x03, 0x30, 0x04, 0x41, 0x0a, 0x10, 0x0a, 0x09, 0x06, 0x01, 0x02, 0x00, + 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x12, 0x03, 0x30, 0x04, 0x41, 0x0a, 0x11, 0x0a, 0x0a, 0x06, 0x01, + 0x02, 0x00, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x02, 0x12, 0x03, 0x30, 0x20, 0x3f, 0x0a, 0x53, 0x0a, + 0x04, 0x06, 0x01, 0x02, 0x01, 0x12, 0x04, 0x34, 0x02, 0x36, 0x03, 0x1a, 0x45, 0x20, 0x46, 0x65, + 0x74, 0x63, 0x68, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x3a, 0x72, + 0x65, 0x66, 0x3a, 0x60, 0x72, 0x65, 0x66, 0x5f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x60, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x34, 0x06, 0x14, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x01, 0x02, 0x01, 0x02, 0x12, 0x03, 0x34, 0x15, 0x3e, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x34, 0x49, 0x73, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x01, 0x02, 0x01, 0x04, 0x12, 0x03, 0x35, 0x04, 0x3b, 0x0a, 0x10, 0x0a, 0x09, 0x06, 0x01, + 0x02, 0x01, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x12, 0x03, 0x35, 0x04, 0x3b, 0x0a, 0x11, 0x0a, 0x0a, + 0x06, 0x01, 0x02, 0x01, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x02, 0x12, 0x03, 0x35, 0x20, 0x39, 0x62, + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +]; +include!("flyteidl2.connector.tonic.rs"); +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/flyteidl2.connector.tonic.rs b/gen/rust/src/flyteidl2.connector.tonic.rs new file mode 100644 index 0000000000..bc8111a339 --- /dev/null +++ b/gen/rust/src/flyteidl2.connector.tonic.rs @@ -0,0 +1,1057 @@ +// @generated +/// Generated client implementations. +pub mod async_connector_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + /** AsyncConnectorService defines an RPC Service that allows executor to send the request to the connector server asynchronously. +*/ + #[derive(Debug, Clone)] + pub struct AsyncConnectorServiceClient { + inner: tonic::client::Grpc, + } + impl AsyncConnectorServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl AsyncConnectorServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> AsyncConnectorServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + AsyncConnectorServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /** CreateTask sends a task create request to the connector service. +*/ + pub async fn create_task( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.connector.AsyncConnectorService/CreateTask", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.connector.AsyncConnectorService", + "CreateTask", + ), + ); + self.inner.unary(req, path, codec).await + } + /** Get job status. +*/ + pub async fn get_task( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.connector.AsyncConnectorService/GetTask", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.connector.AsyncConnectorService", + "GetTask", + ), + ); + self.inner.unary(req, path, codec).await + } + /** Delete the task resource. +*/ + pub async fn delete_task( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.connector.AsyncConnectorService/DeleteTask", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.connector.AsyncConnectorService", + "DeleteTask", + ), + ); + self.inner.unary(req, path, codec).await + } + /** GetTaskMetrics returns one or more task execution metrics, if available. + + Errors include + * OutOfRange if metrics are not available for the specified task time range + * various other errors +*/ + pub async fn get_task_metrics( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.connector.AsyncConnectorService/GetTaskMetrics", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.connector.AsyncConnectorService", + "GetTaskMetrics", + ), + ); + self.inner.unary(req, path, codec).await + } + /** GetTaskLogs returns task execution logs, if available. +*/ + pub async fn get_task_logs( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.connector.AsyncConnectorService/GetTaskLogs", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.connector.AsyncConnectorService", + "GetTaskLogs", + ), + ); + self.inner.server_streaming(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod async_connector_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with AsyncConnectorServiceServer. + #[async_trait] + pub trait AsyncConnectorService: Send + Sync + 'static { + /** CreateTask sends a task create request to the connector service. +*/ + async fn create_task( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /** Get job status. +*/ + async fn get_task( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /** Delete the task resource. +*/ + async fn delete_task( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /** GetTaskMetrics returns one or more task execution metrics, if available. + + Errors include + * OutOfRange if metrics are not available for the specified task time range + * various other errors +*/ + async fn get_task_metrics( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the GetTaskLogs method. + type GetTaskLogsStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + Send + + 'static; + /** GetTaskLogs returns task execution logs, if available. +*/ + async fn get_task_logs( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + /** AsyncConnectorService defines an RPC Service that allows executor to send the request to the connector server asynchronously. +*/ + #[derive(Debug)] + pub struct AsyncConnectorServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl AsyncConnectorServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> + for AsyncConnectorServiceServer + where + T: AsyncConnectorService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.connector.AsyncConnectorService/CreateTask" => { + #[allow(non_camel_case_types)] + struct CreateTaskSvc(pub Arc); + impl< + T: AsyncConnectorService, + > tonic::server::UnaryService + for CreateTaskSvc { + type Response = super::CreateTaskResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::create_task(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = CreateTaskSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.connector.AsyncConnectorService/GetTask" => { + #[allow(non_camel_case_types)] + struct GetTaskSvc(pub Arc); + impl< + T: AsyncConnectorService, + > tonic::server::UnaryService + for GetTaskSvc { + type Response = super::GetTaskResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_task(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetTaskSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.connector.AsyncConnectorService/DeleteTask" => { + #[allow(non_camel_case_types)] + struct DeleteTaskSvc(pub Arc); + impl< + T: AsyncConnectorService, + > tonic::server::UnaryService + for DeleteTaskSvc { + type Response = super::DeleteTaskResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::delete_task(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = DeleteTaskSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.connector.AsyncConnectorService/GetTaskMetrics" => { + #[allow(non_camel_case_types)] + struct GetTaskMetricsSvc(pub Arc); + impl< + T: AsyncConnectorService, + > tonic::server::UnaryService + for GetTaskMetricsSvc { + type Response = super::GetTaskMetricsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_task_metrics( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetTaskMetricsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.connector.AsyncConnectorService/GetTaskLogs" => { + #[allow(non_camel_case_types)] + struct GetTaskLogsSvc(pub Arc); + impl< + T: AsyncConnectorService, + > tonic::server::ServerStreamingService + for GetTaskLogsSvc { + type Response = super::GetTaskLogsResponse; + type ResponseStream = T::GetTaskLogsStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_task_logs(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetTaskLogsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for AsyncConnectorServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService + for AsyncConnectorServiceServer { + const NAME: &'static str = "flyteidl2.connector.AsyncConnectorService"; + } +} +/// Generated client implementations. +pub mod connector_metadata_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + /** ConnectorMetadataService defines an RPC service that is also served over HTTP via grpc-gateway. + This service allows executor or users to get the metadata of connectors. +*/ + #[derive(Debug, Clone)] + pub struct ConnectorMetadataServiceClient { + inner: tonic::client::Grpc, + } + impl ConnectorMetadataServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl ConnectorMetadataServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> ConnectorMetadataServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + ConnectorMetadataServiceClient::new( + InterceptedService::new(inner, interceptor), + ) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /** Fetch a :ref:`ref_flyteidl2.plugins.Connector` definition. +*/ + pub async fn get_connector( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.connector.ConnectorMetadataService/GetConnector", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.connector.ConnectorMetadataService", + "GetConnector", + ), + ); + self.inner.unary(req, path, codec).await + } + /** Fetch a list of :ref:`ref_flyteidl2.plugins.Connector` definitions. +*/ + pub async fn list_connectors( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.connector.ConnectorMetadataService/ListConnectors", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.connector.ConnectorMetadataService", + "ListConnectors", + ), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod connector_metadata_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with ConnectorMetadataServiceServer. + #[async_trait] + pub trait ConnectorMetadataService: Send + Sync + 'static { + /** Fetch a :ref:`ref_flyteidl2.plugins.Connector` definition. +*/ + async fn get_connector( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /** Fetch a list of :ref:`ref_flyteidl2.plugins.Connector` definitions. +*/ + async fn list_connectors( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + /** ConnectorMetadataService defines an RPC service that is also served over HTTP via grpc-gateway. + This service allows executor or users to get the metadata of connectors. +*/ + #[derive(Debug)] + pub struct ConnectorMetadataServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl ConnectorMetadataServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> + for ConnectorMetadataServiceServer + where + T: ConnectorMetadataService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.connector.ConnectorMetadataService/GetConnector" => { + #[allow(non_camel_case_types)] + struct GetConnectorSvc(pub Arc); + impl< + T: ConnectorMetadataService, + > tonic::server::UnaryService + for GetConnectorSvc { + type Response = super::GetConnectorResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_connector( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetConnectorSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.connector.ConnectorMetadataService/ListConnectors" => { + #[allow(non_camel_case_types)] + struct ListConnectorsSvc(pub Arc); + impl< + T: ConnectorMetadataService, + > tonic::server::UnaryService + for ListConnectorsSvc { + type Response = super::ListConnectorsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::list_connectors( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ListConnectorsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for ConnectorMetadataServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService + for ConnectorMetadataServiceServer { + const NAME: &'static str = "flyteidl2.connector.ConnectorMetadataService"; + } +} diff --git a/gen/rust/src/flyteidl2.core.rs b/gen/rust/src/flyteidl2.core.rs new file mode 100644 index 0000000000..d23f45c10f --- /dev/null +++ b/gen/rust/src/flyteidl2.core.rs @@ -0,0 +1,7929 @@ +// @generated +// This file is @generated by prost-build. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ArtifactKey { + /// Project and domain and suffix needs to be unique across a given artifact store. + #[prost(string, tag="1")] + pub project: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub domain: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub name: ::prost::alloc::string::String, + #[prost(string, tag="4")] + pub org: ::prost::alloc::string::String, +} +/// Only valid for triggers +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ArtifactBindingData { + /// This is only relevant in the time partition case + #[prost(message, optional, tag="7")] + pub time_transform: ::core::option::Option, + /// These two fields are only relevant in the partition value case + #[prost(oneof="artifact_binding_data::PartitionData", tags="5, 6")] + pub partition_data: ::core::option::Option, +} +/// Nested message and enum types in `ArtifactBindingData`. +pub mod artifact_binding_data { + /// These two fields are only relevant in the partition value case + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum PartitionData { + #[prost(string, tag="5")] + PartitionKey(::prost::alloc::string::String), + #[prost(bool, tag="6")] + BindToTimePartition(bool), + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TimeTransform { + #[prost(string, tag="1")] + pub transform: ::prost::alloc::string::String, + #[prost(enumeration="Operator", tag="2")] + pub op: i32, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InputBindingData { + #[prost(string, tag="1")] + pub var: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct RuntimeBinding { +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LabelValue { + #[prost(oneof="label_value::Value", tags="1, 2, 3, 4, 5")] + pub value: ::core::option::Option, +} +/// Nested message and enum types in `LabelValue`. +pub mod label_value { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Value { + /// The string static value is for use in the Partitions object + #[prost(string, tag="1")] + StaticValue(::prost::alloc::string::String), + /// The time value is for use in the TimePartition case + #[prost(message, tag="2")] + TimeValue(super::super::super::google::protobuf::Timestamp), + #[prost(message, tag="3")] + TriggeredBinding(super::ArtifactBindingData), + #[prost(message, tag="4")] + InputBinding(super::InputBindingData), + #[prost(message, tag="5")] + RuntimeBinding(super::RuntimeBinding), + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Partitions { + #[prost(map="string, message", tag="1")] + pub value: ::std::collections::HashMap<::prost::alloc::string::String, LabelValue>, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TimePartition { + #[prost(message, optional, tag="1")] + pub value: ::core::option::Option, + #[prost(enumeration="Granularity", tag="2")] + pub granularity: i32, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ArtifactId { + #[prost(message, optional, tag="1")] + pub artifact_key: ::core::option::Option, + #[prost(string, tag="2")] + pub version: ::prost::alloc::string::String, + /// Think of a partition as a tag on an Artifact, except it's a key-value pair. + /// Different partitions naturally have different versions (execution ids). + #[prost(message, optional, tag="3")] + pub partitions: ::core::option::Option, + /// There is no such thing as an empty time partition - if it's not set, then there is no time partition. + #[prost(message, optional, tag="4")] + pub time_partition: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ArtifactTag { + #[prost(message, optional, tag="1")] + pub artifact_key: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub value: ::core::option::Option, +} +/// Uniqueness constraints for Artifacts +/// - project, domain, name, version, partitions +/// Option 2 (tags are standalone, point to an individual artifact id): +/// - project, domain, name, alias (points to one partition if partitioned) +/// - project, domain, name, partition key, partition value +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ArtifactQuery { + #[prost(oneof="artifact_query::Identifier", tags="1, 2, 3, 4")] + pub identifier: ::core::option::Option, +} +/// Nested message and enum types in `ArtifactQuery`. +pub mod artifact_query { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Identifier { + #[prost(message, tag="1")] + ArtifactId(super::ArtifactId), + #[prost(message, tag="2")] + ArtifactTag(super::ArtifactTag), + #[prost(string, tag="3")] + Uri(::prost::alloc::string::String), + /// This is used in the trigger case, where a user specifies a value for an input that is one of the triggering + /// artifacts, or a partition value derived from a triggering artifact. + #[prost(message, tag="4")] + Binding(super::ArtifactBindingData), + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum Granularity { + Unset = 0, + Minute = 1, + Hour = 2, + /// default + Day = 3, + Month = 4, +} +impl Granularity { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Granularity::Unset => "UNSET", + Granularity::Minute => "MINUTE", + Granularity::Hour => "HOUR", + Granularity::Day => "DAY", + Granularity::Month => "MONTH", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNSET" => Some(Self::Unset), + "MINUTE" => Some(Self::Minute), + "HOUR" => Some(Self::Hour), + "DAY" => Some(Self::Day), + "MONTH" => Some(Self::Month), + _ => None, + } + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum Operator { + Minus = 0, + Plus = 1, +} +impl Operator { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Operator::Minus => "MINUS", + Operator::Plus => "PLUS", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "MINUS" => Some(Self::Minus), + "PLUS" => Some(Self::Plus), + _ => None, + } + } +} +/// Secret encapsulates information about the secret a task needs to proceed. An environment variable +/// FLYTE_SECRETS_ENV_PREFIX will be passed to indicate the prefix of the environment variables that will be present if +/// secrets are passed through environment variables. +/// FLYTE_SECRETS_DEFAULT_DIR will be passed to indicate the prefix of the path where secrets will be mounted if secrets +/// are passed through file mounts. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Secret { + /// The name of the secret group where to find the key referenced below. For K8s secrets, this should be the name of + /// the v1/secret object. For Confidant, this should be the Credential name. For Vault, this should be the secret name. + /// For AWS Secret Manager, this should be the name of the secret. + /// +required + #[prost(string, tag="1")] + pub group: ::prost::alloc::string::String, + /// The group version to fetch. This is not supported in all secret management systems. It'll be ignored for the ones + /// that do not support it. + /// +optional + #[prost(string, tag="2")] + pub group_version: ::prost::alloc::string::String, + /// The name of the secret to mount. This has to match an existing secret in the system. It's up to the implementation + /// of the secret management system to require case sensitivity. For K8s secrets, Confidant and Vault, this should + /// match one of the keys inside the secret. For AWS Secret Manager, it's ignored. + /// +optional + #[prost(string, tag="3")] + pub key: ::prost::alloc::string::String, + /// mount_requirement is optional. Indicates where the secret has to be mounted. If provided, the execution will fail + /// if the underlying key management system cannot satisfy that requirement. If not provided, the default location + /// will depend on the key management system. + /// +optional + #[prost(enumeration="secret::MountType", tag="4")] + pub mount_requirement: i32, + /// env_var is optional. Custom environment variable to set the value of the secret. If mount_requirement is ENV_VAR, + /// then the value is the secret itself. If mount_requirement is FILE, then the value is the path to the secret file. + /// +optional + #[prost(string, tag="5")] + pub env_var: ::prost::alloc::string::String, +} +/// Nested message and enum types in `Secret`. +pub mod secret { + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum MountType { + /// Default case, indicates the client can tolerate either mounting options. + Any = 0, + /// ENV_VAR indicates the secret needs to be mounted as an environment variable. + EnvVar = 1, + /// FILE indicates the secret needs to be mounted as a file. + File = 2, + } + impl MountType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + MountType::Any => "ANY", + MountType::EnvVar => "ENV_VAR", + MountType::File => "FILE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ANY" => Some(Self::Any), + "ENV_VAR" => Some(Self::EnvVar), + "FILE" => Some(Self::File), + _ => None, + } + } + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Connection { + /// The task type that the connection is used for. + #[prost(string, tag="1")] + pub task_type: ::prost::alloc::string::String, + /// The credentials to use for the connection, such as API keys, OAuth2 tokens, etc. + /// The key is the name of the secret, and it's defined in the flytekit. + /// flytekit uses the key to locate the desired secret within the map. + #[prost(map="string, string", tag="2")] + pub secrets: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + /// The configuration to use for the connection, such as the endpoint, account name, etc. + /// The key is the name of the config, and it's defined in the flytekit. + #[prost(map="string, string", tag="3")] + pub configs: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, +} +/// OAuth2Client encapsulates OAuth2 Client Credentials to be used when making calls on behalf of that task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct OAuth2Client { + /// client_id is the public id for the client to use. The system will not perform any pre-auth validation that the + /// secret requested matches the client_id indicated here. + /// +required + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + /// client_secret is a reference to the secret used to authenticate the OAuth2 client. + /// +required + #[prost(message, optional, tag="2")] + pub client_secret: ::core::option::Option, +} +/// Identity encapsulates the various security identities a task can run as. It's up to the underlying plugin to pick the +/// right identity for the execution environment. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Identity { + /// iam_role references the fully qualified name of Identity & Access Management role to impersonate. + #[prost(string, tag="1")] + pub iam_role: ::prost::alloc::string::String, + /// k8s_service_account references a kubernetes service account to impersonate. + #[prost(string, tag="2")] + pub k8s_service_account: ::prost::alloc::string::String, + /// oauth2_client references an oauth2 client. Backend plugins can use this information to impersonate the client when + /// making external calls. + #[prost(message, optional, tag="3")] + pub oauth2_client: ::core::option::Option, + /// execution_identity references the subject who makes the execution + #[prost(string, tag="4")] + pub execution_identity: ::prost::alloc::string::String, +} +/// OAuth2TokenRequest encapsulates information needed to request an OAuth2 token. +/// FLYTE_TOKENS_ENV_PREFIX will be passed to indicate the prefix of the environment variables that will be present if +/// tokens are passed through environment variables. +/// FLYTE_TOKENS_PATH_PREFIX will be passed to indicate the prefix of the path where secrets will be mounted if tokens +/// are passed through file mounts. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct OAuth2TokenRequest { + /// name indicates a unique id for the token request within this task token requests. It'll be used as a suffix for + /// environment variables and as a filename for mounting tokens as files. + /// +required + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// type indicates the type of the request to make. Defaults to CLIENT_CREDENTIALS. + /// +required + #[prost(enumeration="o_auth2_token_request::Type", tag="2")] + pub r#type: i32, + /// client references the client_id/secret to use to request the OAuth2 token. + /// +required + #[prost(message, optional, tag="3")] + pub client: ::core::option::Option, + /// idp_discovery_endpoint references the discovery endpoint used to retrieve token endpoint and other related + /// information. + /// +optional + #[prost(string, tag="4")] + pub idp_discovery_endpoint: ::prost::alloc::string::String, + /// token_endpoint references the token issuance endpoint. If idp_discovery_endpoint is not provided, this parameter is + /// mandatory. + /// +optional + #[prost(string, tag="5")] + pub token_endpoint: ::prost::alloc::string::String, +} +/// Nested message and enum types in `OAuth2TokenRequest`. +pub mod o_auth2_token_request { + /// Type of the token requested. + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum Type { + /// CLIENT_CREDENTIALS indicates a 2-legged OAuth token requested using client credentials. + ClientCredentials = 0, + } + impl Type { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Type::ClientCredentials => "CLIENT_CREDENTIALS", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "CLIENT_CREDENTIALS" => Some(Self::ClientCredentials), + _ => None, + } + } + } +} +/// SecurityContext holds security attributes that apply to tasks. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SecurityContext { + /// run_as encapsulates the identity a pod should run as. If the task fills in multiple fields here, it'll be up to the + /// backend plugin to choose the appropriate identity for the execution engine the task will run on. + #[prost(message, optional, tag="1")] + pub run_as: ::core::option::Option, + /// secrets indicate the list of secrets the task needs in order to proceed. Secrets will be mounted/passed to the + /// pod as it starts. If the plugin responsible for kicking of the task will not run it on a flyte cluster (e.g. AWS + /// Batch), it's the responsibility of the plugin to fetch the secret (which means propeller identity will need access + /// to the secret) and to pass it to the remote execution engine. + #[prost(message, repeated, tag="2")] + pub secrets: ::prost::alloc::vec::Vec, + /// tokens indicate the list of token requests the task needs in order to proceed. Tokens will be mounted/passed to the + /// pod as it starts. If the plugin responsible for kicking of the task will not run it on a flyte cluster (e.g. AWS + /// Batch), it's the responsibility of the plugin to fetch the secret (which means propeller identity will need access + /// to the secret) and to pass it to the remote execution engine. + #[prost(message, repeated, tag="3")] + pub tokens: ::prost::alloc::vec::Vec, +} +/// Indicates various phases of Workflow Execution +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct WorkflowExecution { +} +/// Nested message and enum types in `WorkflowExecution`. +pub mod workflow_execution { + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum Phase { + Undefined = 0, + Queued = 1, + Running = 2, + Succeeding = 3, + Succeeded = 4, + Failing = 5, + Failed = 6, + Aborted = 7, + TimedOut = 8, + Aborting = 9, + } + impl Phase { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Phase::Undefined => "UNDEFINED", + Phase::Queued => "QUEUED", + Phase::Running => "RUNNING", + Phase::Succeeding => "SUCCEEDING", + Phase::Succeeded => "SUCCEEDED", + Phase::Failing => "FAILING", + Phase::Failed => "FAILED", + Phase::Aborted => "ABORTED", + Phase::TimedOut => "TIMED_OUT", + Phase::Aborting => "ABORTING", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNDEFINED" => Some(Self::Undefined), + "QUEUED" => Some(Self::Queued), + "RUNNING" => Some(Self::Running), + "SUCCEEDING" => Some(Self::Succeeding), + "SUCCEEDED" => Some(Self::Succeeded), + "FAILING" => Some(Self::Failing), + "FAILED" => Some(Self::Failed), + "ABORTED" => Some(Self::Aborted), + "TIMED_OUT" => Some(Self::TimedOut), + "ABORTING" => Some(Self::Aborting), + _ => None, + } + } + } +} +/// Indicates various phases of Node Execution that only include the time spent to run the nodes/workflows +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct NodeExecution { +} +/// Nested message and enum types in `NodeExecution`. +pub mod node_execution { + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum Phase { + Undefined = 0, + Queued = 1, + Running = 2, + Succeeded = 3, + Failing = 4, + Failed = 5, + Aborted = 6, + Skipped = 7, + TimedOut = 8, + DynamicRunning = 9, + Recovered = 10, + } + impl Phase { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Phase::Undefined => "UNDEFINED", + Phase::Queued => "QUEUED", + Phase::Running => "RUNNING", + Phase::Succeeded => "SUCCEEDED", + Phase::Failing => "FAILING", + Phase::Failed => "FAILED", + Phase::Aborted => "ABORTED", + Phase::Skipped => "SKIPPED", + Phase::TimedOut => "TIMED_OUT", + Phase::DynamicRunning => "DYNAMIC_RUNNING", + Phase::Recovered => "RECOVERED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNDEFINED" => Some(Self::Undefined), + "QUEUED" => Some(Self::Queued), + "RUNNING" => Some(Self::Running), + "SUCCEEDED" => Some(Self::Succeeded), + "FAILING" => Some(Self::Failing), + "FAILED" => Some(Self::Failed), + "ABORTED" => Some(Self::Aborted), + "SKIPPED" => Some(Self::Skipped), + "TIMED_OUT" => Some(Self::TimedOut), + "DYNAMIC_RUNNING" => Some(Self::DynamicRunning), + "RECOVERED" => Some(Self::Recovered), + _ => None, + } + } + } +} +/// Phases that task plugins can go through. Not all phases may be applicable to a specific plugin task, +/// but this is the cumulative list that customers may want to know about for their task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct TaskExecution { +} +/// Nested message and enum types in `TaskExecution`. +pub mod task_execution { + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum Phase { + Undefined = 0, + Queued = 1, + Running = 2, + Succeeded = 3, + Aborted = 4, + Failed = 5, + /// To indicate cases where task is initializing, like: ErrImagePull, ContainerCreating, PodInitializing + Initializing = 6, + /// To address cases, where underlying resource is not available: Backoff error, Resource quota exceeded + WaitingForResources = 7, + RetryableFailed = 8, + } + impl Phase { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Phase::Undefined => "UNDEFINED", + Phase::Queued => "QUEUED", + Phase::Running => "RUNNING", + Phase::Succeeded => "SUCCEEDED", + Phase::Aborted => "ABORTED", + Phase::Failed => "FAILED", + Phase::Initializing => "INITIALIZING", + Phase::WaitingForResources => "WAITING_FOR_RESOURCES", + Phase::RetryableFailed => "RETRYABLE_FAILED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNDEFINED" => Some(Self::Undefined), + "QUEUED" => Some(Self::Queued), + "RUNNING" => Some(Self::Running), + "SUCCEEDED" => Some(Self::Succeeded), + "ABORTED" => Some(Self::Aborted), + "FAILED" => Some(Self::Failed), + "INITIALIZING" => Some(Self::Initializing), + "WAITING_FOR_RESOURCES" => Some(Self::WaitingForResources), + "RETRYABLE_FAILED" => Some(Self::RetryableFailed), + _ => None, + } + } + } +} +/// Represents the error message from the execution. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExecutionError { + /// Error code indicates a grouping of a type of error. + /// More Info: + #[prost(string, tag="1")] + pub code: ::prost::alloc::string::String, + /// Detailed description of the error - including stack trace. + #[prost(string, tag="2")] + pub message: ::prost::alloc::string::String, + /// Full error contents accessible via a URI + #[prost(string, tag="3")] + pub error_uri: ::prost::alloc::string::String, + #[prost(enumeration="execution_error::ErrorKind", tag="4")] + pub kind: i32, + /// Timestamp of the error + #[prost(message, optional, tag="5")] + pub timestamp: ::core::option::Option, + /// Worker that generated the error + #[prost(string, tag="6")] + pub worker: ::prost::alloc::string::String, +} +/// Nested message and enum types in `ExecutionError`. +pub mod execution_error { + /// Error type: System or User + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum ErrorKind { + Unknown = 0, + User = 1, + System = 2, + } + impl ErrorKind { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ErrorKind::Unknown => "UNKNOWN", + ErrorKind::User => "USER", + ErrorKind::System => "SYSTEM", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNKNOWN" => Some(Self::Unknown), + "USER" => Some(Self::User), + "SYSTEM" => Some(Self::System), + _ => None, + } + } + } +} +/// Log information for the task that is specific to a log sink +/// When our log story is flushed out, we may have more metadata here like log link expiry +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskLog { + #[prost(string, tag="1")] + pub uri: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, + #[prost(enumeration="task_log::MessageFormat", tag="3")] + pub message_format: i32, + #[prost(message, optional, tag="4")] + pub ttl: ::core::option::Option, + #[prost(bool, tag="5")] + pub show_while_pending: bool, + #[prost(bool, tag="6")] + pub hide_once_finished: bool, + #[prost(enumeration="task_log::LinkType", tag="7")] + pub link_type: i32, + #[prost(bool, tag="8")] + pub ready: bool, + #[prost(string, tag="9")] + pub icon_uri: ::prost::alloc::string::String, +} +/// Nested message and enum types in `TaskLog`. +pub mod task_log { + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum MessageFormat { + Unknown = 0, + Csv = 1, + Json = 2, + } + impl MessageFormat { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + MessageFormat::Unknown => "UNKNOWN", + MessageFormat::Csv => "CSV", + MessageFormat::Json => "JSON", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNKNOWN" => Some(Self::Unknown), + "CSV" => Some(Self::Csv), + "JSON" => Some(Self::Json), + _ => None, + } + } + } + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum LinkType { + /// The link for task log. For example, the aws cloudwatch logs, gcp stackdriver logs, etc. + External = 0, + /// The link for spark UI, ray dashboard, etc. + Dashboard = 1, + /// The link for vscode or other IDEs. + Ide = 2, + } + impl LinkType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + LinkType::External => "EXTERNAL", + LinkType::Dashboard => "DASHBOARD", + LinkType::Ide => "IDE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "EXTERNAL" => Some(Self::External), + "DASHBOARD" => Some(Self::Dashboard), + "IDE" => Some(Self::Ide), + _ => None, + } + } + } +} +/// Contains metadata required to identify logs produces by a set of pods +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LogContext { + #[prost(message, repeated, tag="1")] + pub pods: ::prost::alloc::vec::Vec, + #[prost(string, tag="2")] + pub primary_pod_name: ::prost::alloc::string::String, +} +/// Contains metadata required to identify logs produces by a single pod +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PodLogContext { + #[prost(string, tag="1")] + pub namespace: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub pod_name: ::prost::alloc::string::String, + #[prost(message, repeated, tag="3")] + pub containers: ::prost::alloc::vec::Vec, + #[prost(string, tag="4")] + pub primary_container_name: ::prost::alloc::string::String, + #[prost(message, repeated, tag="5")] + pub init_containers: ::prost::alloc::vec::Vec, +} +/// Contains metadata required to identify logs produces by a single container +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ContainerContext { + #[prost(string, tag="1")] + pub container_name: ::prost::alloc::string::String, + #[prost(message, optional, tag="2")] + pub process: ::core::option::Option, +} +/// Nested message and enum types in `ContainerContext`. +pub mod container_context { + /// Contains metadata required to identify logs produces by a single light-weight process that was run inside a container + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] + pub struct ProcessContext { + #[prost(message, optional, tag="1")] + pub container_start_time: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub container_end_time: ::core::option::Option, + } +} +/// Represents customized execution run-time attributes. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct QualityOfServiceSpec { + /// Indicates how much queueing delay an execution can tolerate. + #[prost(message, optional, tag="1")] + pub queueing_budget: ::core::option::Option, +} +/// Indicates the priority of an execution. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct QualityOfService { + #[prost(oneof="quality_of_service::Designation", tags="1, 2")] + pub designation: ::core::option::Option, +} +/// Nested message and enum types in `QualityOfService`. +pub mod quality_of_service { + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum Tier { + /// Default: no quality of service specified. + Undefined = 0, + High = 1, + Medium = 2, + Low = 3, + } + impl Tier { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Tier::Undefined => "UNDEFINED", + Tier::High => "HIGH", + Tier::Medium => "MEDIUM", + Tier::Low => "LOW", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNDEFINED" => Some(Self::Undefined), + "HIGH" => Some(Self::High), + "MEDIUM" => Some(Self::Medium), + "LOW" => Some(Self::Low), + _ => None, + } + } + } + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Oneof)] + pub enum Designation { + #[prost(enumeration="Tier", tag="1")] + Tier(i32), + #[prost(message, tag="2")] + Spec(super::QualityOfServiceSpec), + } +} +/// Encapsulation of fields that uniquely identifies a Flyte resource. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Identifier { + /// Identifies the specific type of resource that this identifier corresponds to. + #[prost(enumeration="ResourceType", tag="1")] + pub resource_type: i32, + /// Name of the project the resource belongs to. + #[prost(string, tag="2")] + pub project: ::prost::alloc::string::String, + /// Name of the domain the resource belongs to. + /// A domain can be considered as a subset within a specific project. + #[prost(string, tag="3")] + pub domain: ::prost::alloc::string::String, + /// User provided value for the resource. + #[prost(string, tag="4")] + pub name: ::prost::alloc::string::String, + /// Specific version of the resource. + #[prost(string, tag="5")] + pub version: ::prost::alloc::string::String, + /// Optional, org key applied to the resource. + #[prost(string, tag="6")] + pub org: ::prost::alloc::string::String, +} +/// Encapsulation of fields that uniquely identifies a Flyte workflow execution +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorkflowExecutionIdentifier { + /// Name of the project the resource belongs to. + #[prost(string, tag="1")] + pub project: ::prost::alloc::string::String, + /// Name of the domain the resource belongs to. + /// A domain can be considered as a subset within a specific project. + #[prost(string, tag="2")] + pub domain: ::prost::alloc::string::String, + /// User or system provided value for the resource. + #[prost(string, tag="4")] + pub name: ::prost::alloc::string::String, + /// Optional, org key applied to the resource. + #[prost(string, tag="5")] + pub org: ::prost::alloc::string::String, +} +/// Encapsulation of fields that identify a Flyte node execution entity. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct NodeExecutionIdentifier { + #[prost(string, tag="1")] + pub node_id: ::prost::alloc::string::String, + #[prost(message, optional, tag="2")] + pub execution_id: ::core::option::Option, +} +/// Encapsulation of fields that identify a Flyte task execution entity. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskExecutionIdentifier { + #[prost(message, optional, tag="1")] + pub task_id: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub node_execution_id: ::core::option::Option, + #[prost(uint32, tag="3")] + pub retry_attempt: u32, +} +/// Encapsulation of fields the uniquely identify a signal. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SignalIdentifier { + /// Unique identifier for a signal. + #[prost(string, tag="1")] + pub signal_id: ::prost::alloc::string::String, + /// Identifies the Flyte workflow execution this signal belongs to. + #[prost(message, optional, tag="2")] + pub execution_id: ::core::option::Option, +} +/// Indicates a resource type within Flyte. +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ResourceType { + Unspecified = 0, + Task = 1, + Workflow = 2, + LaunchPlan = 3, + /// A dataset represents an entity modeled in Flyte DataCatalog. A Dataset is also a versioned entity and can be a compilation of multiple individual objects. + /// Eventually all Catalog objects should be modeled similar to Flyte Objects. The Dataset entities makes it possible for the UI and CLI to act on the objects + /// in a similar manner to other Flyte objects + Dataset = 4, +} +impl ResourceType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ResourceType::Unspecified => "UNSPECIFIED", + ResourceType::Task => "TASK", + ResourceType::Workflow => "WORKFLOW", + ResourceType::LaunchPlan => "LAUNCH_PLAN", + ResourceType::Dataset => "DATASET", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNSPECIFIED" => Some(Self::Unspecified), + "TASK" => Some(Self::Task), + "WORKFLOW" => Some(Self::Workflow), + "LAUNCH_PLAN" => Some(Self::LaunchPlan), + "DATASET" => Some(Self::Dataset), + _ => None, + } + } +} +/// Defines schema columns and types to strongly type-validate schemas interoperability. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SchemaType { + /// A list of ordered columns this schema comprises of. + #[prost(message, repeated, tag="3")] + pub columns: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `SchemaType`. +pub mod schema_type { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct SchemaColumn { + /// A unique name -within the schema type- for the column + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// The column type. This allows a limited set of types currently. + #[prost(enumeration="schema_column::SchemaColumnType", tag="2")] + pub r#type: i32, + } + /// Nested message and enum types in `SchemaColumn`. + pub mod schema_column { + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum SchemaColumnType { + Integer = 0, + Float = 1, + String = 2, + Boolean = 3, + Datetime = 4, + Duration = 5, + } + impl SchemaColumnType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + SchemaColumnType::Integer => "INTEGER", + SchemaColumnType::Float => "FLOAT", + SchemaColumnType::String => "STRING", + SchemaColumnType::Boolean => "BOOLEAN", + SchemaColumnType::Datetime => "DATETIME", + SchemaColumnType::Duration => "DURATION", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "INTEGER" => Some(Self::Integer), + "FLOAT" => Some(Self::Float), + "STRING" => Some(Self::String), + "BOOLEAN" => Some(Self::Boolean), + "DATETIME" => Some(Self::Datetime), + "DURATION" => Some(Self::Duration), + _ => None, + } + } + } + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct StructuredDatasetType { + /// A list of ordered columns this schema comprises of. + #[prost(message, repeated, tag="1")] + pub columns: ::prost::alloc::vec::Vec, + /// This is the storage format, the format of the bits at rest + /// parquet, feather, csv, etc. + /// For two types to be compatible, the format will need to be an exact match. + #[prost(string, tag="2")] + pub format: ::prost::alloc::string::String, + /// This is a string representing the type that the bytes in external_schema_bytes are formatted in. + /// This is an optional field that will not be used for type checking. + #[prost(string, tag="3")] + pub external_schema_type: ::prost::alloc::string::String, + /// The serialized bytes of a third-party schema library like Arrow. + /// This is an optional field that will not be used for type checking. + #[prost(bytes="vec", tag="4")] + pub external_schema_bytes: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `StructuredDatasetType`. +pub mod structured_dataset_type { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct DatasetColumn { + /// A unique name within the schema type for the column. + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// The column type. + #[prost(message, optional, tag="2")] + pub literal_type: ::core::option::Option, + } +} +/// Defines type behavior for blob objects +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BlobType { + /// Format can be a free form string understood by SDK/UI etc like + /// csv, parquet etc + #[prost(string, tag="1")] + pub format: ::prost::alloc::string::String, + #[prost(enumeration="blob_type::BlobDimensionality", tag="2")] + pub dimensionality: i32, +} +/// Nested message and enum types in `BlobType`. +pub mod blob_type { + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum BlobDimensionality { + Single = 0, + Multipart = 1, + } + impl BlobDimensionality { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + BlobDimensionality::Single => "SINGLE", + BlobDimensionality::Multipart => "MULTIPART", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "SINGLE" => Some(Self::Single), + "MULTIPART" => Some(Self::Multipart), + _ => None, + } + } + } +} +/// Enables declaring enum types, with predefined string values +/// For len(values) > 0, the first value in the ordered list is regarded as the default value. If you wish +/// To provide no defaults, make the first value as undefined. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EnumType { + /// Predefined set of enum values. + #[prost(string, repeated, tag="1")] + pub values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +/// Defines a tagged union type, also known as a variant (and formally as the sum type). +/// +/// A sum type S is defined by a sequence of types (A, B, C, ...), each tagged by a string tag +/// A value of type S is constructed from a value of any of the variant types. The specific choice of type is recorded by +/// storing the varaint's tag with the literal value and can be examined in runtime. +/// +/// Type S is typically written as +/// S := Apple A | Banana B | Cantaloupe C | ... +/// +/// Notably, a nullable (optional) type is a sum type between some type X and the singleton type representing a null-value: +/// Optional X := X | Null +/// +/// See also: +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UnionType { + /// Predefined set of variants in union. + #[prost(message, repeated, tag="1")] + pub variants: ::prost::alloc::vec::Vec, +} +/// Hints to improve type matching +/// e.g. allows distinguishing output from custom type transformers +/// even if the underlying IDL serialization matches. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TypeStructure { + /// Must exactly match for types to be castable + #[prost(string, tag="1")] + pub tag: ::prost::alloc::string::String, + /// dataclass_type only exists for dataclasses. + /// This is used to resolve the type of the fields of dataclass + /// The key is the field name, and the value is the literal type of the field + /// e.g. For dataclass Foo, with fields a, and a is a string + /// Foo.a will be resolved as a literal type of string from dataclass_type + #[prost(map="string, message", tag="2")] + pub dataclass_type: ::std::collections::HashMap<::prost::alloc::string::String, LiteralType>, +} +/// TypeAnnotation encapsulates registration time information about a type. This can be used for various control-plane operations. TypeAnnotation will not be available at runtime when a task runs. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TypeAnnotation { + /// A arbitrary JSON payload to describe a type. + #[prost(message, optional, tag="1")] + pub annotations: ::core::option::Option, +} +/// Defines a strong type to allow type checking between interfaces. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LiteralType { + /// This field contains type metadata that is descriptive of the type, but is NOT considered in type-checking. This might be used by + /// consumers to identify special behavior or display extended information for the type. + #[prost(message, optional, tag="6")] + pub metadata: ::core::option::Option, + /// This field contains arbitrary data that might have special semantic + /// meaning for the client but does not effect internal flyte behavior. + #[prost(message, optional, tag="9")] + pub annotation: ::core::option::Option, + /// Hints to improve type matching. + #[prost(message, optional, tag="11")] + pub structure: ::core::option::Option, + #[prost(oneof="literal_type::Type", tags="1, 2, 3, 4, 5, 7, 8, 10")] + pub r#type: ::core::option::Option, +} +/// Nested message and enum types in `LiteralType`. +pub mod literal_type { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Type { + /// A simple type that can be compared one-to-one with another. + #[prost(enumeration="super::SimpleType", tag="1")] + Simple(i32), + /// A complex type that requires matching of inner fields. + #[prost(message, tag="2")] + Schema(super::SchemaType), + /// Defines the type of the value of a collection. Only homogeneous collections are allowed. + #[prost(message, tag="3")] + CollectionType(::prost::alloc::boxed::Box), + /// Defines the type of the value of a map type. The type of the key is always a string. + #[prost(message, tag="4")] + MapValueType(::prost::alloc::boxed::Box), + /// A blob might have specialized implementation details depending on associated metadata. + #[prost(message, tag="5")] + Blob(super::BlobType), + /// Defines an enum with pre-defined string values. + #[prost(message, tag="7")] + EnumType(super::EnumType), + /// Generalized schema support + #[prost(message, tag="8")] + StructuredDatasetType(super::StructuredDatasetType), + /// Defines an union type with pre-defined LiteralTypes. + #[prost(message, tag="10")] + UnionType(super::UnionType), + } +} +/// A reference to an output produced by a node. The type can be retrieved -and validated- from +/// the underlying interface of the node. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct OutputReference { + /// Node id must exist at the graph layer. + #[prost(string, tag="1")] + pub node_id: ::prost::alloc::string::String, + /// Variable name must refer to an output variable for the node. + #[prost(string, tag="2")] + pub var: ::prost::alloc::string::String, + #[prost(message, repeated, tag="3")] + pub attr_path: ::prost::alloc::vec::Vec, +} +// PromiseAttribute stores the attribute path of a promise, which will be resolved at runtime. +// The attribute path is a list of strings and integers. +// In the following example, +// ``` +// @workflow +// def wf(): +// o = t1() +// t2(o.a["b"][0]) +// ``` +// the output reference t2 binds to has a list of PromiseAttribute \["a", "b", 0\] + +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PromiseAttribute { + #[prost(oneof="promise_attribute::Value", tags="1, 2")] + pub value: ::core::option::Option, +} +/// Nested message and enum types in `PromiseAttribute`. +pub mod promise_attribute { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Value { + #[prost(string, tag="1")] + StringValue(::prost::alloc::string::String), + #[prost(int32, tag="2")] + IntValue(i32), + } +} +/// Represents an error thrown from a node. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Error { + /// The node id that threw the error. + #[prost(string, tag="1")] + pub failed_node_id: ::prost::alloc::string::String, + /// Error message thrown. + #[prost(string, tag="2")] + pub message: ::prost::alloc::string::String, +} +/// Define a set of simple types. +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum SimpleType { + None = 0, + Integer = 1, + Float = 2, + String = 3, + Boolean = 4, + Datetime = 5, + Duration = 6, + Binary = 7, + Error = 8, + Struct = 9, +} +impl SimpleType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + SimpleType::None => "NONE", + SimpleType::Integer => "INTEGER", + SimpleType::Float => "FLOAT", + SimpleType::String => "STRING", + SimpleType::Boolean => "BOOLEAN", + SimpleType::Datetime => "DATETIME", + SimpleType::Duration => "DURATION", + SimpleType::Binary => "BINARY", + SimpleType::Error => "ERROR", + SimpleType::Struct => "STRUCT", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "NONE" => Some(Self::None), + "INTEGER" => Some(Self::Integer), + "FLOAT" => Some(Self::Float), + "STRING" => Some(Self::String), + "BOOLEAN" => Some(Self::Boolean), + "DATETIME" => Some(Self::Datetime), + "DURATION" => Some(Self::Duration), + "BINARY" => Some(Self::Binary), + "ERROR" => Some(Self::Error), + "STRUCT" => Some(Self::Struct), + _ => None, + } + } +} +/// Primitive Types +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Primitive { + /// Defines one of simple primitive types. These types will get translated into different programming languages as + /// described in + #[prost(oneof="primitive::Value", tags="1, 2, 3, 4, 5, 6")] + pub value: ::core::option::Option, +} +/// Nested message and enum types in `Primitive`. +pub mod primitive { + /// Defines one of simple primitive types. These types will get translated into different programming languages as + /// described in + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Value { + #[prost(int64, tag="1")] + Integer(i64), + #[prost(double, tag="2")] + FloatValue(f64), + #[prost(string, tag="3")] + StringValue(::prost::alloc::string::String), + #[prost(bool, tag="4")] + Boolean(bool), + #[prost(message, tag="5")] + Datetime(super::super::super::google::protobuf::Timestamp), + #[prost(message, tag="6")] + Duration(super::super::super::google::protobuf::Duration), + } +} +/// Used to denote a nil/null/None assignment to a scalar value. The underlying LiteralType for Void is intentionally +/// undefined since it can be assigned to a scalar of any LiteralType. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct Void { +} +/// Refers to an offloaded set of files. It encapsulates the type of the store and a unique uri for where the data is. +/// There are no restrictions on how the uri is formatted since it will depend on how to interact with the store. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Blob { + #[prost(message, optional, tag="1")] + pub metadata: ::core::option::Option, + #[prost(string, tag="3")] + pub uri: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BlobMetadata { + #[prost(message, optional, tag="1")] + pub r#type: ::core::option::Option, +} +/// A simple byte array with a tag to help different parts of the system communicate about what is in the byte array. +/// It's strongly advisable that consumers of this type define a unique tag and validate the tag before parsing the data. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Binary { + /// Serialized data (MessagePack) for supported types like Dataclass, Pydantic BaseModel, and untyped dict. + #[prost(bytes="vec", tag="1")] + pub value: ::prost::alloc::vec::Vec, + /// The serialization format identifier (e.g., MessagePack). Consumers must define unique tags and validate them before deserialization. + #[prost(string, tag="2")] + pub tag: ::prost::alloc::string::String, +} +/// A strongly typed schema that defines the interface of data retrieved from the underlying storage medium. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Schema { + #[prost(string, tag="1")] + pub uri: ::prost::alloc::string::String, + #[prost(message, optional, tag="3")] + pub r#type: ::core::option::Option, +} +/// The runtime representation of a tagged union value. See `UnionType` for more details. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Union { + #[prost(message, optional, boxed, tag="1")] + pub value: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, tag="2")] + pub r#type: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct StructuredDatasetMetadata { + /// Bundle the type information along with the literal. + /// This is here because StructuredDatasets can often be more defined at run time than at compile time. + /// That is, at compile time you might only declare a task to return a pandas dataframe or a StructuredDataset, + /// without any column information, but at run time, you might have that column information. + /// flytekit python will copy this type information into the literal, from the type information, if not provided by + /// the various plugins (encoders). + /// Since this field is run time generated, it's not used for any type checking. + #[prost(message, optional, tag="1")] + pub structured_dataset_type: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct StructuredDataset { + /// String location uniquely identifying where the data is. + /// Should start with the storage location (e.g. s3://, gs://, bq://, etc.) + #[prost(string, tag="1")] + pub uri: ::prost::alloc::string::String, + #[prost(message, optional, tag="2")] + pub metadata: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Scalar { + #[prost(oneof="scalar::Value", tags="1, 2, 3, 4, 5, 6, 7, 8, 9")] + pub value: ::core::option::Option, +} +/// Nested message and enum types in `Scalar`. +pub mod scalar { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Value { + #[prost(message, tag="1")] + Primitive(super::Primitive), + #[prost(message, tag="2")] + Blob(super::Blob), + #[prost(message, tag="3")] + Binary(super::Binary), + #[prost(message, tag="4")] + Schema(super::Schema), + #[prost(message, tag="5")] + NoneType(super::Void), + #[prost(message, tag="6")] + Error(super::Error), + #[prost(message, tag="7")] + Generic(super::super::super::google::protobuf::Struct), + #[prost(message, tag="8")] + StructuredDataset(super::StructuredDataset), + #[prost(message, tag="9")] + Union(::prost::alloc::boxed::Box), + } +} +/// A simple value. This supports any level of nesting (e.g. array of array of array of Blobs) as well as simple primitives. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Literal { + /// A hash representing this literal. + /// This is used for caching purposes. For more details refer to RFC 1893 + /// () + #[prost(string, tag="4")] + pub hash: ::prost::alloc::string::String, + /// Additional metadata for literals. + #[prost(map="string, string", tag="5")] + pub metadata: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + #[prost(oneof="literal::Value", tags="1, 2, 3, 8")] + pub value: ::core::option::Option, +} +/// Nested message and enum types in `Literal`. +pub mod literal { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Value { + /// A simple value. + #[prost(message, tag="1")] + Scalar(::prost::alloc::boxed::Box), + /// A collection of literals to allow nesting. + #[prost(message, tag="2")] + Collection(super::LiteralCollection), + /// A map of strings to literals. + #[prost(message, tag="3")] + Map(super::LiteralMap), + /// Offloaded literal metadata + /// When you deserialize the offloaded metadata, it would be of Literal and its type would be defined by LiteralType stored in offloaded_metadata. + #[prost(message, tag="8")] + OffloadedMetadata(super::LiteralOffloadedMetadata), + } +} +/// A message that contains the metadata of the offloaded data. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LiteralOffloadedMetadata { + /// The location of the offloaded core.Literal. + #[prost(string, tag="1")] + pub uri: ::prost::alloc::string::String, + /// The size of the offloaded data. + #[prost(uint64, tag="2")] + pub size_bytes: u64, + /// The inferred literal type of the offloaded data. + #[prost(message, optional, tag="3")] + pub inferred_type: ::core::option::Option, +} +/// A collection of literals. This is a workaround since oneofs in proto messages cannot contain a repeated field. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LiteralCollection { + #[prost(message, repeated, tag="1")] + pub literals: ::prost::alloc::vec::Vec, +} +/// A map of literals. This is a workaround since oneofs in proto messages cannot contain a repeated field. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LiteralMap { + #[prost(map="string, message", tag="1")] + pub literals: ::std::collections::HashMap<::prost::alloc::string::String, Literal>, +} +/// A collection of BindingData items. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BindingDataCollection { + #[prost(message, repeated, tag="1")] + pub bindings: ::prost::alloc::vec::Vec, +} +/// A map of BindingData items. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BindingDataMap { + #[prost(map="string, message", tag="1")] + pub bindings: ::std::collections::HashMap<::prost::alloc::string::String, BindingData>, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UnionInfo { + #[prost(message, optional, tag="1")] + pub target_type: ::core::option::Option, +} +/// Specifies either a simple value or a reference to another output. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BindingData { + #[prost(message, optional, tag="5")] + pub union: ::core::option::Option, + #[prost(oneof="binding_data::Value", tags="1, 2, 3, 4, 6")] + pub value: ::core::option::Option, +} +/// Nested message and enum types in `BindingData`. +pub mod binding_data { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Value { + /// A simple scalar value. + #[prost(message, tag="1")] + Scalar(super::Scalar), + /// A collection of binding data. This allows nesting of binding data to any number + /// of levels. + #[prost(message, tag="2")] + Collection(super::BindingDataCollection), + /// References an output promised by another node. + #[prost(message, tag="3")] + Promise(super::OutputReference), + /// A map of bindings. The key is always a string. + #[prost(message, tag="4")] + Map(super::BindingDataMap), + /// Offloaded literal metadata + /// When you deserialize the offloaded metadata, it would be of Literal and its type would be defined by LiteralType stored in offloaded_metadata. + /// Used for nodes that don't have promises from upstream nodes such as ArrayNode subNodes. + #[prost(message, tag="6")] + OffloadedMetadata(super::LiteralOffloadedMetadata), + } +} +/// An input/output binding of a variable to either static value or a node output. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Binding { + /// Variable name must match an input/output variable of the node. + #[prost(string, tag="1")] + pub var: ::prost::alloc::string::String, + /// Data to use to bind this variable. + #[prost(message, optional, tag="2")] + pub binding: ::core::option::Option, +} +/// A generic key value pair. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct KeyValuePair { + /// required. + #[prost(string, tag="1")] + pub key: ::prost::alloc::string::String, + /// +optional. + #[prost(string, tag="2")] + pub value: ::prost::alloc::string::String, +} +/// Retry strategy associated with an executable unit. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct RetryStrategy { + /// Number of retries. Retries will be consumed when the job fails with a recoverable error. + /// The number of retries must be less than or equals to 10. + #[prost(uint32, tag="5")] + pub retries: u32, +} +/// Defines a strongly typed variable. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Variable { + /// Variable literal type. + #[prost(message, optional, tag="1")] + pub r#type: ::core::option::Option, + /// +optional string describing input variable + #[prost(string, tag="2")] + pub description: ::prost::alloc::string::String, + /// +optional This object allows the user to specify how Artifacts are created. + /// name, tag, partitions can be specified. The other fields (version and project/domain) are ignored. + #[prost(message, optional, tag="3")] + pub artifact_partial_id: ::core::option::Option, + #[prost(message, optional, tag="4")] + pub artifact_tag: ::core::option::Option, +} +/// A map of Variables +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct VariableMap { + /// Defines a map of variable names to variables. + #[prost(map="string, message", tag="1")] + pub variables: ::std::collections::HashMap<::prost::alloc::string::String, Variable>, +} +/// Defines strongly typed inputs and outputs. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TypedInterface { + #[prost(message, optional, tag="1")] + pub inputs: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub outputs: ::core::option::Option, +} +/// A parameter is used as input to a launch plan and has +/// the special ability to have a default value or mark itself as required. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Parameter { + /// +required Variable. Defines the type of the variable backing this parameter. + #[prost(message, optional, tag="1")] + pub var: ::core::option::Option, + /// +optional + #[prost(oneof="parameter::Behavior", tags="2, 3, 4, 5")] + pub behavior: ::core::option::Option, +} +/// Nested message and enum types in `Parameter`. +pub mod parameter { + /// +optional + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Behavior { + /// Defines a default value that has to match the variable type defined. + #[prost(message, tag="2")] + Default(super::Literal), + /// +optional, is this value required to be filled. + #[prost(bool, tag="3")] + Required(bool), + /// This is an execution time search basically that should result in exactly one Artifact with a Type that + /// matches the type of the variable. + #[prost(message, tag="4")] + ArtifactQuery(super::ArtifactQuery), + #[prost(message, tag="5")] + ArtifactId(super::ArtifactId), + } +} +/// A map of Parameters. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ParameterMap { + /// Defines a map of parameter names to parameters. + #[prost(map="string, message", tag="1")] + pub parameters: ::std::collections::HashMap<::prost::alloc::string::String, Parameter>, +} +/// A customizable interface to convey resources requested for a container. This can be interpreted differently for different +/// container engines. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Resources { + /// The desired set of resources requested. ResourceNames must be unique within the list. + #[prost(message, repeated, tag="1")] + pub requests: ::prost::alloc::vec::Vec, + /// Defines a set of bounds (e.g. min/max) within which the task can reliably run. ResourceNames must be unique + /// within the list. + #[prost(message, repeated, tag="2")] + pub limits: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `Resources`. +pub mod resources { + /// Encapsulates a resource name and value. + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct ResourceEntry { + /// Resource name. + #[prost(enumeration="ResourceName", tag="1")] + pub name: i32, + /// Value must be a valid k8s quantity. See + /// + #[prost(string, tag="2")] + pub value: ::prost::alloc::string::String, + } + /// Known resource names. + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum ResourceName { + Unknown = 0, + Cpu = 1, + Gpu = 2, + Memory = 3, + Storage = 4, + /// For Kubernetes-based deployments, pods use ephemeral local storage for scratch space, caching, and for logs. + EphemeralStorage = 5, + } + impl ResourceName { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ResourceName::Unknown => "UNKNOWN", + ResourceName::Cpu => "CPU", + ResourceName::Gpu => "GPU", + ResourceName::Memory => "MEMORY", + ResourceName::Storage => "STORAGE", + ResourceName::EphemeralStorage => "EPHEMERAL_STORAGE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNKNOWN" => Some(Self::Unknown), + "CPU" => Some(Self::Cpu), + "GPU" => Some(Self::Gpu), + "MEMORY" => Some(Self::Memory), + "STORAGE" => Some(Self::Storage), + "EPHEMERAL_STORAGE" => Some(Self::EphemeralStorage), + _ => None, + } + } + } +} +/// Metadata associated with the GPU accelerator to allocate to a task. Contains +/// information about device type, and for multi-instance GPUs, the partition size to +/// use. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GpuAccelerator { + /// This can be any arbitrary string, and should be informed by the labels or taints + /// associated with the nodes in question. Default cloud provider labels typically + /// use the following values: `nvidia-tesla-t4`, `nvidia-tesla-a100`, etc. + #[prost(string, tag="1")] + pub device: ::prost::alloc::string::String, + /// The class of accelerator device. Defaults to NVIDIA_GPU if not specified. + #[prost(enumeration="gpu_accelerator::DeviceClass", tag="4")] + pub device_class: i32, + #[prost(oneof="gpu_accelerator::PartitionSizeValue", tags="2, 3")] + pub partition_size_value: ::core::option::Option, +} +/// Nested message and enum types in `GPUAccelerator`. +pub mod gpu_accelerator { + /// Specifies the class of accelerator device. + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum DeviceClass { + /// NVIDIA GPU devices (default for backward compatibility) + NvidiaGpu = 0, + /// Google TPU devices + GoogleTpu = 1, + /// Amazon Neuron devices + AmazonNeuron = 2, + /// AMD GPU devices + AmdGpu = 3, + /// Habana Gaudi devices + HabanaGaudi = 4, + } + impl DeviceClass { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + DeviceClass::NvidiaGpu => "NVIDIA_GPU", + DeviceClass::GoogleTpu => "GOOGLE_TPU", + DeviceClass::AmazonNeuron => "AMAZON_NEURON", + DeviceClass::AmdGpu => "AMD_GPU", + DeviceClass::HabanaGaudi => "HABANA_GAUDI", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "NVIDIA_GPU" => Some(Self::NvidiaGpu), + "GOOGLE_TPU" => Some(Self::GoogleTpu), + "AMAZON_NEURON" => Some(Self::AmazonNeuron), + "AMD_GPU" => Some(Self::AmdGpu), + "HABANA_GAUDI" => Some(Self::HabanaGaudi), + _ => None, + } + } + } + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum PartitionSizeValue { + #[prost(bool, tag="2")] + Unpartitioned(bool), + /// Like `device`, this can be any arbitrary string, and should be informed by + /// the labels or taints associated with the nodes in question. Default cloud + /// provider labels typically use the following values: `1g.5gb`, `2g.10gb`, etc. + #[prost(string, tag="3")] + PartitionSize(::prost::alloc::string::String), + } +} +/// Metadata associated with configuring a shared memory volume for a task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SharedMemory { + /// Mount path to place in container + #[prost(string, tag="1")] + pub mount_path: ::prost::alloc::string::String, + /// Name for volume + #[prost(string, tag="2")] + pub mount_name: ::prost::alloc::string::String, + /// Size limit for shared memory. If not set, then the shared memory is equal + /// to the allocated memory. + /// +optional + #[prost(string, tag="3")] + pub size_limit: ::prost::alloc::string::String, +} +/// Encapsulates all non-standard resources, not captured by v1.ResourceRequirements, to +/// allocate to a task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExtendedResources { + /// GPU accelerator to select for task. Contains information about device type, and + /// for multi-instance GPUs, the partition size to use. + #[prost(message, optional, tag="1")] + pub gpu_accelerator: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub shared_memory: ::core::option::Option, +} +/// Runtime information. This is loosely defined to allow for extensibility. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RuntimeMetadata { + /// Type of runtime. + #[prost(enumeration="runtime_metadata::RuntimeType", tag="1")] + pub r#type: i32, + /// Version of the runtime. All versions should be backward compatible. However, certain cases call for version + /// checks to ensure tighter validation or setting expectations. + #[prost(string, tag="2")] + pub version: ::prost::alloc::string::String, + /// +optional It can be used to provide extra information about the runtime (e.g. python, golang... etc.). + #[prost(string, tag="3")] + pub flavor: ::prost::alloc::string::String, +} +/// Nested message and enum types in `RuntimeMetadata`. +pub mod runtime_metadata { + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum RuntimeType { + Other = 0, + FlyteSdk = 1, + } + impl RuntimeType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + RuntimeType::Other => "OTHER", + RuntimeType::FlyteSdk => "FLYTE_SDK", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "OTHER" => Some(Self::Other), + "FLYTE_SDK" => Some(Self::FlyteSdk), + _ => None, + } + } + } +} +/// Task Metadata +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskMetadata { + /// Indicates whether the system should attempt to lookup this task's output to avoid duplication of work. + #[prost(bool, tag="1")] + pub discoverable: bool, + /// Runtime information about the task. + #[prost(message, optional, tag="2")] + pub runtime: ::core::option::Option, + /// The overall timeout of a task including user-triggered retries. + #[prost(message, optional, tag="4")] + pub timeout: ::core::option::Option, + /// Number of retries per task. + #[prost(message, optional, tag="5")] + pub retries: ::core::option::Option, + /// Indicates a logical version to apply to this task for the purpose of discovery. + #[prost(string, tag="6")] + pub discovery_version: ::prost::alloc::string::String, + /// If set, this indicates that this task is deprecated. This will enable owners of tasks to notify consumers + /// of the ending of support for a given task. + #[prost(string, tag="7")] + pub deprecated_error_message: ::prost::alloc::string::String, + /// Indicates whether the system should attempt to execute discoverable instances in serial to avoid duplicate work + #[prost(bool, tag="9")] + pub cache_serializable: bool, + /// Arbitrary tags that allow users and the platform to store small but arbitrary labels + #[prost(map="string, string", tag="11")] + pub tags: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + /// pod_template_name is the unique name of a PodTemplate k8s resource to be used as the base configuration if this + /// task creates a k8s Pod. If this value is set, the specified PodTemplate will be used instead of, but applied + /// identically as, the default PodTemplate configured in FlytePropeller. + #[prost(string, tag="12")] + pub pod_template_name: ::prost::alloc::string::String, + /// cache_ignore_input_vars is the input variables that should not be included when calculating hash for cache. + #[prost(string, repeated, tag="13")] + pub cache_ignore_input_vars: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// is_eager indicates whether the task is eager or not. + /// This would be used by CreateTask endpoint. + #[prost(bool, tag="14")] + pub is_eager: bool, + /// Indicates whether the task will generate a deck when it finishes executing. + /// The BoolValue can have three states: + /// - nil: The value is not set. + /// - true: The task will generate a deck. + /// - false: The task will not generate a deck. + #[prost(message, optional, tag="15")] + pub generates_deck: ::core::option::Option, + /// Metadata applied to task pods or task CR objects. + /// In flytekit, labels and annotations resulting in this metadata field + /// are provided via `@task(labels=..., annotations=...)`. + /// For tasks backed by pods like PythonFunctionTask, these take precedence + /// over the metadata provided via `@task(pod_template=PodTemplate(labels=...))` which are transported + /// in the K8sPod message. For tasks backed by CRDs, this metadata is applied to + /// the CR object itself while the metadata in the pod template/K8sPod is applied + /// to the pod template spec of the CR object. + #[prost(message, optional, tag="16")] + pub metadata: ::core::option::Option, + /// Whether the task is able to run the debugger (vscode server) inside the task container. + #[prost(bool, tag="17")] + pub debuggable: bool, + /// Log links associated with this task. + #[prost(message, repeated, tag="18")] + pub log_links: ::prost::alloc::vec::Vec, + // For interruptible we will populate it at the node level but require it be part of TaskMetadata + // for a user to set the value. + // We are using oneof instead of bool because otherwise we would be unable to distinguish between value being + // set by the user or defaulting to false. + // The logic of handling precedence will be done as part of flytepropeller. + + /// Identify whether task is interruptible + #[prost(oneof="task_metadata::InterruptibleValue", tags="8")] + pub interruptible_value: ::core::option::Option, +} +/// Nested message and enum types in `TaskMetadata`. +pub mod task_metadata { + // For interruptible we will populate it at the node level but require it be part of TaskMetadata + // for a user to set the value. + // We are using oneof instead of bool because otherwise we would be unable to distinguish between value being + // set by the user or defaulting to false. + // The logic of handling precedence will be done as part of flytepropeller. + + /// Identify whether task is interruptible + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Oneof)] + pub enum InterruptibleValue { + #[prost(bool, tag="8")] + Interruptible(bool), + } +} +/// A Task structure that uniquely identifies a task in the system +/// Tasks are registered as a first step in the system. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskTemplate { + /// Auto generated taskId by the system. Task Id uniquely identifies this task globally. + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + /// A predefined yet extensible Task type identifier. This can be used to customize any of the components. If no + /// extensions are provided in the system, Flyte will resolve the this task to its TaskCategory and default the + /// implementation registered for the TaskCategory. + #[prost(string, tag="2")] + pub r#type: ::prost::alloc::string::String, + /// Extra metadata about the task. + #[prost(message, optional, tag="3")] + pub metadata: ::core::option::Option, + /// A strongly typed interface for the task. This enables others to use this task within a workflow and guarantees + /// compile-time validation of the workflow to avoid costly runtime failures. + #[prost(message, optional, tag="4")] + pub interface: ::core::option::Option, + /// Custom data about the task. This is extensible to allow various plugins in the system. + #[prost(message, optional, tag="5")] + pub custom: ::core::option::Option, + /// This can be used to customize task handling at execution time for the same task type. + #[prost(int32, tag="7")] + pub task_type_version: i32, + /// security_context encapsulates security attributes requested to run this task. + #[prost(message, optional, tag="8")] + pub security_context: ::core::option::Option, + /// Encapsulates all non-standard resources, not captured by + /// v1.ResourceRequirements, to allocate to a task. + #[prost(message, optional, tag="9")] + pub extended_resources: ::core::option::Option, + /// Metadata about the custom defined for this task. This is extensible to allow various plugins in the system + /// to use as required. + /// reserve the field numbers 1 through 15 for very frequently occurring message elements + #[prost(map="string, string", tag="16")] + pub config: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + /// Known target types that the system will guarantee plugins for. Custom SDK plugins are allowed to set these if needed. + /// If no corresponding execution-layer plugins are found, the system will default to handling these using built-in + /// handlers. + #[prost(oneof="task_template::Target", tags="6, 17, 18")] + pub target: ::core::option::Option, +} +/// Nested message and enum types in `TaskTemplate`. +pub mod task_template { + /// Known target types that the system will guarantee plugins for. Custom SDK plugins are allowed to set these if needed. + /// If no corresponding execution-layer plugins are found, the system will default to handling these using built-in + /// handlers. + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Target { + #[prost(message, tag="6")] + Container(super::Container), + #[prost(message, tag="17")] + K8sPod(super::K8sPod), + #[prost(message, tag="18")] + Sql(super::Sql), + } +} +// ----------------- First class Plugins + +/// Defines port properties for a container. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ContainerPort { + /// Number of port to expose on the pod's IP address. + /// This must be a valid port number, 0 < x < 65536. + #[prost(uint32, tag="1")] + pub container_port: u32, + /// Name of the port to expose on the pod's IP address. + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Container { + /// Container image url. Eg: docker/redis:latest + #[prost(string, tag="1")] + pub image: ::prost::alloc::string::String, + /// Command to be executed, if not provided, the default entrypoint in the container image will be used. + #[prost(string, repeated, tag="2")] + pub command: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// These will default to Flyte given paths. If provided, the system will not append known paths. If the task still + /// needs flyte's inputs and outputs path, add $(FLYTE_INPUT_FILE), $(FLYTE_OUTPUT_FILE) wherever makes sense and the + /// system will populate these before executing the container. + #[prost(string, repeated, tag="3")] + pub args: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Container resources requirement as specified by the container engine. + #[prost(message, optional, tag="4")] + pub resources: ::core::option::Option, + /// Environment variables will be set as the container is starting up. + #[prost(message, repeated, tag="5")] + pub env: ::prost::alloc::vec::Vec, + /// Allows extra configs to be available for the container. + /// TODO: elaborate on how configs will become available. + /// Deprecated, please use TaskTemplate.config instead. + #[deprecated] + #[prost(message, repeated, tag="6")] + pub config: ::prost::alloc::vec::Vec, + /// Ports to open in the container. This feature is not supported by all execution engines. (e.g. supported on K8s but + /// not supported on AWS Batch) + /// Only K8s + #[prost(message, repeated, tag="7")] + pub ports: ::prost::alloc::vec::Vec, + /// BETA: Optional configuration for DataLoading. If not specified, then default values are used. + /// This makes it possible to to run a completely portable container, that uses inputs and outputs + /// only from the local file-system and without having any reference to flyteidl. This is supported only on K8s at the moment. + /// If data loading is enabled, then data will be mounted in accompanying directories specified in the DataLoadingConfig. If the directories + /// are not specified, inputs will be mounted onto and outputs will be uploaded from a pre-determined file-system path. Refer to the documentation + /// to understand the default paths. + /// Only K8s + #[prost(message, optional, tag="9")] + pub data_config: ::core::option::Option, + #[prost(enumeration="container::Architecture", tag="10")] + pub architecture: i32, +} +/// Nested message and enum types in `Container`. +pub mod container { + /// Architecture-type the container image supports. + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum Architecture { + Unknown = 0, + Amd64 = 1, + Arm64 = 2, + ArmV6 = 3, + ArmV7 = 4, + } + impl Architecture { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Architecture::Unknown => "UNKNOWN", + Architecture::Amd64 => "AMD64", + Architecture::Arm64 => "ARM64", + Architecture::ArmV6 => "ARM_V6", + Architecture::ArmV7 => "ARM_V7", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNKNOWN" => Some(Self::Unknown), + "AMD64" => Some(Self::Amd64), + "ARM64" => Some(Self::Arm64), + "ARM_V6" => Some(Self::ArmV6), + "ARM_V7" => Some(Self::ArmV7), + _ => None, + } + } + } +} +/// Strategy to use when dealing with Blob, Schema, or multipart blob data (large datasets) +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct IoStrategy { + /// Mode to use to manage downloads + #[prost(enumeration="io_strategy::DownloadMode", tag="1")] + pub download_mode: i32, + /// Mode to use to manage uploads + #[prost(enumeration="io_strategy::UploadMode", tag="2")] + pub upload_mode: i32, +} +/// Nested message and enum types in `IOStrategy`. +pub mod io_strategy { + /// Mode to use for downloading + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum DownloadMode { + /// All data will be downloaded before the main container is executed + DownloadEager = 0, + /// Data will be downloaded as a stream and an End-Of-Stream marker will be written to indicate all data has been downloaded. Refer to protocol for details + DownloadStream = 1, + /// Large objects (offloaded) will not be downloaded + DoNotDownload = 2, + } + impl DownloadMode { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + DownloadMode::DownloadEager => "DOWNLOAD_EAGER", + DownloadMode::DownloadStream => "DOWNLOAD_STREAM", + DownloadMode::DoNotDownload => "DO_NOT_DOWNLOAD", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "DOWNLOAD_EAGER" => Some(Self::DownloadEager), + "DOWNLOAD_STREAM" => Some(Self::DownloadStream), + "DO_NOT_DOWNLOAD" => Some(Self::DoNotDownload), + _ => None, + } + } + } + /// Mode to use for uploading + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum UploadMode { + /// All data will be uploaded after the main container exits + UploadOnExit = 0, + /// Data will be uploaded as it appears. Refer to protocol specification for details + UploadEager = 1, + /// Data will not be uploaded, only references will be written + DoNotUpload = 2, + } + impl UploadMode { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + UploadMode::UploadOnExit => "UPLOAD_ON_EXIT", + UploadMode::UploadEager => "UPLOAD_EAGER", + UploadMode::DoNotUpload => "DO_NOT_UPLOAD", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UPLOAD_ON_EXIT" => Some(Self::UploadOnExit), + "UPLOAD_EAGER" => Some(Self::UploadEager), + "DO_NOT_UPLOAD" => Some(Self::DoNotUpload), + _ => None, + } + } + } +} +/// This configuration allows executing raw containers in Flyte using the Flyte CoPilot system. +/// Flyte CoPilot, eliminates the needs of flytekit or sdk inside the container. Any inputs required by the users container are side-loaded in the input_path +/// Any outputs generated by the user container - within output_path are automatically uploaded. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DataLoadingConfig { + /// Flag enables DataLoading Config. If this is not set, data loading will not be used! + #[prost(bool, tag="1")] + pub enabled: bool, + /// File system path (start at root). This folder will contain all the inputs exploded to a separate file. + /// Example, if the input interface needs (x: int, y: blob, z: multipart_blob) and the input path is '/var/flyte/inputs', then the file system will look like + /// /var/flyte/inputs/inputs. .pb .json .yaml> -> Format as defined previously. The Blob and Multipart blob will reference local filesystem instead of remote locations + /// /var/flyte/inputs/x -> X is a file that contains the value of x (integer) in string format + /// /var/flyte/inputs/y -> Y is a file in Binary format + /// /var/flyte/inputs/z/... -> Note Z itself is a directory + /// More information about the protocol - refer to docs #TODO reference docs here + #[prost(string, tag="2")] + pub input_path: ::prost::alloc::string::String, + /// File system path (start at root). This folder should contain all the outputs for the task as individual files and/or an error text file + #[prost(string, tag="3")] + pub output_path: ::prost::alloc::string::String, + /// In the inputs folder, there will be an additional summary/metadata file that contains references to all files or inlined primitive values. + /// This format decides the actual encoding for the data. Refer to the encoding to understand the specifics of the contents and the encoding + #[prost(enumeration="data_loading_config::LiteralMapFormat", tag="4")] + pub format: i32, + #[prost(message, optional, tag="5")] + pub io_strategy: ::core::option::Option, +} +/// Nested message and enum types in `DataLoadingConfig`. +pub mod data_loading_config { + /// LiteralMapFormat decides the encoding format in which the input metadata should be made available to the containers. + /// If the user has access to the protocol buffer definitions, it is recommended to use the PROTO format. + /// JSON and YAML do not need any protobuf definitions to read it + /// All remote references in core.LiteralMap are replaced with local filesystem references (the data is downloaded to local filesystem) + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum LiteralMapFormat { + /// JSON / YAML for the metadata (which contains inlined primitive values). The representation is inline with the standard json specification as specified - + Json = 0, + Yaml = 1, + /// Proto is a serialized binary of `core.LiteralMap` defined in flyteidl/core + Proto = 2, + } + impl LiteralMapFormat { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + LiteralMapFormat::Json => "JSON", + LiteralMapFormat::Yaml => "YAML", + LiteralMapFormat::Proto => "PROTO", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "JSON" => Some(Self::Json), + "YAML" => Some(Self::Yaml), + "PROTO" => Some(Self::Proto), + _ => None, + } + } + } +} +/// Defines a pod spec and additional pod metadata that is created when a task is executed. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct K8sPod { + /// Contains additional metadata for building a kubernetes pod. + #[prost(message, optional, tag="1")] + pub metadata: ::core::option::Option, + /// Defines the primary pod spec created when a task is executed. + /// This should be a JSON-marshalled pod spec, which can be defined in + /// - go, using: + /// - python: using + #[prost(message, optional, tag="2")] + pub pod_spec: ::core::option::Option, + /// BETA: Optional configuration for DataLoading. If not specified, then default values are used. + /// This makes it possible to to run a completely portable container, that uses inputs and outputs + /// only from the local file-system and without having any reference to flytekit. This is supported only on K8s at the moment. + /// If data loading is enabled, then data will be mounted in accompanying directories specified in the DataLoadingConfig. If the directories + /// are not specified, inputs will be mounted onto and outputs will be uploaded from a pre-determined file-system path. Refer to the documentation + /// to understand the default paths. + /// Only K8s + #[prost(message, optional, tag="3")] + pub data_config: ::core::option::Option, + /// Defines the primary container name when pod template override is executed. + #[prost(string, tag="4")] + pub primary_container_name: ::prost::alloc::string::String, +} +/// Metadata for building a kubernetes object when a task is executed. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct K8sObjectMetadata { + /// Optional labels to add to the pod definition. + #[prost(map="string, string", tag="1")] + pub labels: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + /// Optional annotations to add to the pod definition. + #[prost(map="string, string", tag="2")] + pub annotations: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, +} +/// Sql represents a generic sql workload with a statement and dialect. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Sql { + /// The actual query to run, the query can have templated parameters. + /// We use Flyte's Golang templating format for Query templating. + /// For example, + /// insert overwrite directory '{{ .rawOutputDataPrefix }}' stored as parquet + /// select * + /// from my_table + /// where ds = '{{ .Inputs.ds }}' + #[prost(string, tag="1")] + pub statement: ::prost::alloc::string::String, + #[prost(enumeration="sql::Dialect", tag="2")] + pub dialect: i32, +} +/// Nested message and enum types in `Sql`. +pub mod sql { + /// The dialect of the SQL statement. This is used to validate and parse SQL statements at compilation time to avoid + /// expensive runtime operations. If set to an unsupported dialect, no validation will be done on the statement. + /// We support the following dialect: ansi, hive. + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum Dialect { + Undefined = 0, + Ansi = 1, + Hive = 2, + Other = 3, + } + impl Dialect { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Dialect::Undefined => "UNDEFINED", + Dialect::Ansi => "ANSI", + Dialect::Hive => "HIVE", + Dialect::Other => "OTHER", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNDEFINED" => Some(Self::Undefined), + "ANSI" => Some(Self::Ansi), + "HIVE" => Some(Self::Hive), + "OTHER" => Some(Self::Other), + _ => None, + } + } + } +} +/// ExecutionMetrics is a collection of metrics that are collected during the execution of a Flyte task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExecutionMetricResult { + /// The metric this data represents. e.g. EXECUTION_METRIC_USED_CPU_AVG or EXECUTION_METRIC_USED_MEMORY_BYTES_AVG. + #[prost(string, tag="1")] + pub metric: ::prost::alloc::string::String, + /// The result data in prometheus range query result format + /// + /// This may include multiple time series, differentiated by their metric labels. + /// Start time is greater of (execution attempt start, 48h ago) + /// End time is lesser of (execution attempt end, now) + #[prost(message, optional, tag="2")] + pub data: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CatalogArtifactTag { + /// Artifact ID is generated name + #[prost(string, tag="1")] + pub artifact_id: ::prost::alloc::string::String, + /// Flyte computes the tag automatically, as the hash of the values + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, +} +/// Catalog artifact information with specific metadata +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CatalogMetadata { + /// Dataset ID in the catalog + #[prost(message, optional, tag="1")] + pub dataset_id: ::core::option::Option, + /// Artifact tag in the catalog + #[prost(message, optional, tag="2")] + pub artifact_tag: ::core::option::Option, + /// Optional: Source Execution identifier, if this dataset was generated by another execution in Flyte. This is a one-of field and will depend on the caching context + #[prost(oneof="catalog_metadata::SourceExecution", tags="3")] + pub source_execution: ::core::option::Option, +} +/// Nested message and enum types in `CatalogMetadata`. +pub mod catalog_metadata { + /// Optional: Source Execution identifier, if this dataset was generated by another execution in Flyte. This is a one-of field and will depend on the caching context + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum SourceExecution { + /// Today we only support TaskExecutionIdentifier as a source, as catalog caching only works for task executions + #[prost(message, tag="3")] + SourceTaskExecution(super::TaskExecutionIdentifier), + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct CatalogReservation { +} +/// Nested message and enum types in `CatalogReservation`. +pub mod catalog_reservation { + /// Indicates the status of a catalog reservation operation. + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum Status { + /// Used to indicate that reservations are disabled + ReservationDisabled = 0, + /// Used to indicate that a reservation was successfully acquired or extended + ReservationAcquired = 1, + /// Used to indicate that an active reservation currently exists + ReservationExists = 2, + /// Used to indicate that the reservation has been successfully released + ReservationReleased = 3, + /// Used to indicate that a reservation operation resulted in failure + ReservationFailure = 4, + } + impl Status { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Status::ReservationDisabled => "RESERVATION_DISABLED", + Status::ReservationAcquired => "RESERVATION_ACQUIRED", + Status::ReservationExists => "RESERVATION_EXISTS", + Status::ReservationReleased => "RESERVATION_RELEASED", + Status::ReservationFailure => "RESERVATION_FAILURE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "RESERVATION_DISABLED" => Some(Self::ReservationDisabled), + "RESERVATION_ACQUIRED" => Some(Self::ReservationAcquired), + "RESERVATION_EXISTS" => Some(Self::ReservationExists), + "RESERVATION_RELEASED" => Some(Self::ReservationReleased), + "RESERVATION_FAILURE" => Some(Self::ReservationFailure), + _ => None, + } + } + } +} +/// Indicates the status of CatalogCaching. The reason why this is not embedded in TaskNodeMetadata is, that we may use for other types of nodes as well in the future +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum CatalogCacheStatus { + /// Used to indicate that caching was disabled + CacheDisabled = 0, + /// Used to indicate that the cache lookup resulted in no matches + CacheMiss = 1, + /// used to indicate that the associated artifact was a result of a previous execution + CacheHit = 2, + /// used to indicate that the resultant artifact was added to the cache + CachePopulated = 3, + /// Used to indicate that cache lookup failed because of an error + CacheLookupFailure = 4, + /// Used to indicate that cache lookup failed because of an error + CachePutFailure = 5, + /// Used to indicate the cache lookup was skipped + CacheSkipped = 6, + /// Used to indicate that the cache was evicted + CacheEvicted = 7, +} +impl CatalogCacheStatus { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + CatalogCacheStatus::CacheDisabled => "CACHE_DISABLED", + CatalogCacheStatus::CacheMiss => "CACHE_MISS", + CatalogCacheStatus::CacheHit => "CACHE_HIT", + CatalogCacheStatus::CachePopulated => "CACHE_POPULATED", + CatalogCacheStatus::CacheLookupFailure => "CACHE_LOOKUP_FAILURE", + CatalogCacheStatus::CachePutFailure => "CACHE_PUT_FAILURE", + CatalogCacheStatus::CacheSkipped => "CACHE_SKIPPED", + CatalogCacheStatus::CacheEvicted => "CACHE_EVICTED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "CACHE_DISABLED" => Some(Self::CacheDisabled), + "CACHE_MISS" => Some(Self::CacheMiss), + "CACHE_HIT" => Some(Self::CacheHit), + "CACHE_POPULATED" => Some(Self::CachePopulated), + "CACHE_LOOKUP_FAILURE" => Some(Self::CacheLookupFailure), + "CACHE_PUT_FAILURE" => Some(Self::CachePutFailure), + "CACHE_SKIPPED" => Some(Self::CacheSkipped), + "CACHE_EVICTED" => Some(Self::CacheEvicted), + _ => None, + } + } +} +/// Error message to propagate detailed errors from container executions to the execution +/// engine. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ContainerError { + /// A simplified code for errors, so that we can provide a glossary of all possible errors. + #[prost(string, tag="1")] + pub code: ::prost::alloc::string::String, + /// A detailed error message. + #[prost(string, tag="2")] + pub message: ::prost::alloc::string::String, + /// An abstract error kind for this error. Defaults to Non_Recoverable if not specified. + #[prost(enumeration="container_error::Kind", tag="3")] + pub kind: i32, + /// Defines the origin of the error (system, user, unknown). + #[prost(enumeration="execution_error::ErrorKind", tag="4")] + pub origin: i32, +} +/// Nested message and enum types in `ContainerError`. +pub mod container_error { + /// Defines a generic error type that dictates the behavior of the retry strategy. + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum Kind { + NonRecoverable = 0, + Recoverable = 1, + } + impl Kind { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Kind::NonRecoverable => "NON_RECOVERABLE", + Kind::Recoverable => "RECOVERABLE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "NON_RECOVERABLE" => Some(Self::NonRecoverable), + "RECOVERABLE" => Some(Self::Recoverable), + _ => None, + } + } + } +} +/// Defines the errors.pb file format the container can produce to communicate +/// failure reasons to the execution engine. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ErrorDocument { + /// The error raised during execution. + #[prost(message, optional, tag="1")] + pub error: ::core::option::Option, +} +/// Encoded file descriptor set for the `flyteidl2.core` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0x8c, 0x2b, 0x0a, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, + 0x6f, 0x72, 0x65, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x65, 0x0a, 0x0b, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, + 0x63, 0x74, 0x4b, 0x65, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, + 0x16, 0x0a, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6f, + 0x72, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x22, 0xd1, 0x01, + 0x0a, 0x13, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, + 0x67, 0x44, 0x61, 0x74, 0x61, 0x12, 0x25, 0x0a, 0x0d, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0c, + 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x12, 0x35, 0x0a, 0x16, + 0x62, 0x69, 0x6e, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x70, 0x61, 0x72, + 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x13, + 0x62, 0x69, 0x6e, 0x64, 0x54, 0x6f, 0x54, 0x69, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x44, 0x0a, 0x0e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x74, 0x72, 0x61, 0x6e, + 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x69, 0x6d, + 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x52, 0x0d, 0x74, 0x69, 0x6d, 0x65, + 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x42, 0x10, 0x0a, 0x0e, 0x70, 0x61, 0x72, + 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x4a, 0x04, 0x08, 0x01, 0x10, + 0x05, 0x22, 0x57, 0x0a, 0x0d, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, + 0x72, 0x6d, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, + 0x12, 0x28, 0x0a, 0x02, 0x6f, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x18, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4f, 0x70, + 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x02, 0x6f, 0x70, 0x22, 0x24, 0x0a, 0x10, 0x49, 0x6e, + 0x70, 0x75, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x12, 0x10, + 0x0a, 0x03, 0x76, 0x61, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x76, 0x61, 0x72, + 0x22, 0x10, 0x0a, 0x0e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, + 0x6e, 0x67, 0x22, 0xdf, 0x02, 0x0a, 0x0a, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x73, 0x74, 0x61, 0x74, 0x69, 0x63, 0x5f, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x73, 0x74, 0x61, 0x74, 0x69, + 0x63, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x3b, 0x0a, 0x0a, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x48, 0x00, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x12, 0x52, 0x0a, 0x11, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x65, 0x64, + 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, + 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, 0x10, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x65, 0x64, + 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x47, 0x0a, 0x0d, 0x69, 0x6e, 0x70, 0x75, 0x74, + 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x49, 0x6e, 0x70, 0x75, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, + 0x48, 0x00, 0x52, 0x0c, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, + 0x12, 0x49, 0x0a, 0x0f, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x62, 0x69, 0x6e, 0x64, + 0x69, 0x6e, 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x75, 0x6e, 0x74, 0x69, + 0x6d, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x48, 0x00, 0x52, 0x0e, 0x72, 0x75, 0x6e, + 0x74, 0x69, 0x6d, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x42, 0x07, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x22, 0x9f, 0x01, 0x0a, 0x0a, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x12, 0x3b, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x1a, 0x54, 0x0a, 0x0a, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, + 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, + 0x12, 0x30, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x80, 0x01, 0x0a, 0x0d, 0x54, 0x69, 0x6d, 0x65, 0x50, + 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x30, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x3d, 0x0a, 0x0b, 0x67, 0x72, + 0x61, 0x6e, 0x75, 0x6c, 0x61, 0x72, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x47, 0x72, 0x61, 0x6e, 0x75, 0x6c, 0x61, 0x72, 0x69, 0x74, 0x79, 0x52, 0x0b, 0x67, 0x72, + 0x61, 0x6e, 0x75, 0x6c, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0xe8, 0x01, 0x0a, 0x0a, 0x41, 0x72, + 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x44, 0x12, 0x3e, 0x0a, 0x0c, 0x61, 0x72, 0x74, 0x69, + 0x66, 0x61, 0x63, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x4b, 0x65, 0x79, 0x52, 0x0b, 0x61, 0x72, 0x74, + 0x69, 0x66, 0x61, 0x63, 0x74, 0x4b, 0x65, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x12, 0x3a, 0x0a, 0x0a, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x44, + 0x0a, 0x0e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0d, 0x74, 0x69, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x7f, 0x0a, 0x0b, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, + 0x54, 0x61, 0x67, 0x12, 0x3e, 0x0a, 0x0c, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x66, + 0x61, 0x63, 0x74, 0x4b, 0x65, 0x79, 0x52, 0x0b, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, + 0x4b, 0x65, 0x79, 0x12, 0x30, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0xf3, 0x01, 0x0a, 0x0d, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, + 0x63, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x3d, 0x0a, 0x0b, 0x61, 0x72, 0x74, 0x69, 0x66, + 0x61, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, + 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x44, 0x48, 0x00, 0x52, 0x0a, 0x61, 0x72, 0x74, 0x69, + 0x66, 0x61, 0x63, 0x74, 0x49, 0x64, 0x12, 0x40, 0x0a, 0x0c, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, + 0x63, 0x74, 0x5f, 0x74, 0x61, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, + 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x54, 0x61, 0x67, 0x48, 0x00, 0x52, 0x0b, 0x61, 0x72, 0x74, + 0x69, 0x66, 0x61, 0x63, 0x74, 0x54, 0x61, 0x67, 0x12, 0x12, 0x0a, 0x03, 0x75, 0x72, 0x69, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x03, 0x75, 0x72, 0x69, 0x12, 0x3f, 0x0a, 0x07, + 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, + 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, + 0x74, 0x61, 0x48, 0x00, 0x52, 0x07, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x42, 0x0c, 0x0a, + 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2a, 0x42, 0x0a, 0x0b, 0x47, + 0x72, 0x61, 0x6e, 0x75, 0x6c, 0x61, 0x72, 0x69, 0x74, 0x79, 0x12, 0x09, 0x0a, 0x05, 0x55, 0x4e, + 0x53, 0x45, 0x54, 0x10, 0x00, 0x12, 0x0a, 0x0a, 0x06, 0x4d, 0x49, 0x4e, 0x55, 0x54, 0x45, 0x10, + 0x01, 0x12, 0x08, 0x0a, 0x04, 0x48, 0x4f, 0x55, 0x52, 0x10, 0x02, 0x12, 0x07, 0x0a, 0x03, 0x44, + 0x41, 0x59, 0x10, 0x03, 0x12, 0x09, 0x0a, 0x05, 0x4d, 0x4f, 0x4e, 0x54, 0x48, 0x10, 0x04, 0x2a, + 0x1f, 0x0a, 0x08, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x09, 0x0a, 0x05, 0x4d, + 0x49, 0x4e, 0x55, 0x53, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x50, 0x4c, 0x55, 0x53, 0x10, 0x01, + 0x42, 0xb2, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x42, 0x0f, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, + 0x74, 0x49, 0x64, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, + 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0xa2, 0x02, + 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x43, 0x6f, 0x72, 0x65, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, + 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x4a, 0xdf, 0x1a, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x6d, 0x01, + 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, + 0x03, 0x02, 0x00, 0x17, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x29, 0x0a, + 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x06, 0x00, 0x49, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, + 0x03, 0x06, 0x00, 0x49, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x08, 0x00, 0x0e, 0x01, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x08, 0x08, 0x13, 0x0a, 0x5e, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0a, 0x02, 0x15, 0x1a, 0x51, 0x20, 0x50, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x61, + 0x6e, 0x64, 0x20, 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x73, 0x20, + 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x61, 0x63, 0x72, + 0x6f, 0x73, 0x73, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x61, 0x72, 0x74, 0x69, + 0x66, 0x61, 0x63, 0x74, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x0a, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x0a, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x0a, 0x13, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, + 0x0b, 0x02, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x0b, 0x02, + 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0b, 0x09, 0x0f, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x0b, 0x12, 0x13, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x0c, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x02, 0x05, 0x12, 0x03, 0x0c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, + 0x01, 0x12, 0x03, 0x0c, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, + 0x03, 0x0c, 0x10, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x0d, 0x02, + 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x05, 0x12, 0x03, 0x0d, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x0d, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x0d, 0x0f, 0x10, 0x0a, 0x25, 0x0a, 0x02, 0x04, + 0x01, 0x12, 0x04, 0x11, 0x00, 0x1b, 0x01, 0x1a, 0x19, 0x20, 0x4f, 0x6e, 0x6c, 0x79, 0x20, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x73, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x11, 0x08, 0x1b, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x01, 0x09, 0x12, 0x03, 0x12, 0x02, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, + 0x09, 0x00, 0x12, 0x03, 0x12, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x09, 0x00, 0x01, + 0x12, 0x03, 0x12, 0x0b, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x09, 0x00, 0x02, 0x12, 0x03, + 0x12, 0x10, 0x11, 0x0a, 0x4e, 0x0a, 0x04, 0x04, 0x01, 0x08, 0x00, 0x12, 0x04, 0x14, 0x02, 0x17, + 0x03, 0x1a, 0x40, 0x20, 0x54, 0x68, 0x65, 0x73, 0x65, 0x20, 0x74, 0x77, 0x6f, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x72, 0x65, + 0x6c, 0x65, 0x76, 0x61, 0x6e, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, + 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x63, 0x61, + 0x73, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x08, 0x00, 0x01, 0x12, 0x03, 0x14, 0x08, + 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x15, 0x04, 0x1d, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x15, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x15, 0x0b, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x15, 0x1b, 0x1c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, + 0x12, 0x03, 0x16, 0x04, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, + 0x16, 0x04, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x16, 0x09, + 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x16, 0x22, 0x23, 0x0a, + 0x3f, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x1a, 0x02, 0x23, 0x1a, 0x32, 0x20, 0x54, + 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x72, 0x65, 0x6c, 0x65, + 0x76, 0x61, 0x6e, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, + 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x61, 0x73, 0x65, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x06, 0x12, 0x03, 0x1a, 0x02, 0x0f, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x1a, 0x10, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x1a, 0x21, 0x22, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x00, + 0x12, 0x04, 0x1d, 0x00, 0x23, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, 0x03, 0x1d, + 0x05, 0x10, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x00, 0x12, 0x03, 0x1e, 0x02, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1e, 0x02, 0x07, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x1e, 0x0a, 0x0b, 0x0a, 0x0b, 0x0a, 0x04, 0x05, + 0x00, 0x02, 0x01, 0x12, 0x03, 0x1f, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x1f, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x02, 0x12, + 0x03, 0x1f, 0x0b, 0x0c, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x02, 0x12, 0x03, 0x20, 0x02, + 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x20, 0x02, 0x06, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x20, 0x09, 0x0a, 0x0a, 0x16, 0x0a, + 0x04, 0x05, 0x00, 0x02, 0x03, 0x12, 0x03, 0x21, 0x02, 0x0a, 0x22, 0x09, 0x20, 0x64, 0x65, 0x66, + 0x61, 0x75, 0x6c, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, + 0x21, 0x02, 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x21, 0x08, + 0x09, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x04, 0x12, 0x03, 0x22, 0x02, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x22, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, 0x22, 0x0a, 0x0b, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x01, + 0x12, 0x04, 0x25, 0x00, 0x28, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x01, 0x01, 0x12, 0x03, 0x25, + 0x05, 0x0d, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x01, 0x02, 0x00, 0x12, 0x03, 0x26, 0x02, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x26, 0x02, 0x07, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x01, 0x02, 0x00, 0x02, 0x12, 0x03, 0x26, 0x0a, 0x0b, 0x0a, 0x0b, 0x0a, 0x04, 0x05, + 0x01, 0x02, 0x01, 0x12, 0x03, 0x27, 0x02, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x27, 0x02, 0x06, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x01, 0x02, 0x12, + 0x03, 0x27, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x2a, 0x00, 0x2d, 0x01, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x2a, 0x08, 0x15, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x2b, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x2b, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x2b, 0x09, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x2b, 0x15, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x2c, 0x02, 0x12, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, 0x03, 0x2c, 0x02, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x2c, 0x0b, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x2c, 0x10, 0x11, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x03, + 0x12, 0x04, 0x2f, 0x00, 0x31, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x2f, + 0x08, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x30, 0x02, 0x11, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x05, 0x12, 0x03, 0x30, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x30, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x30, 0x0f, 0x10, 0x0a, 0x09, 0x0a, 0x02, 0x04, 0x04, 0x12, + 0x03, 0x33, 0x00, 0x19, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x33, 0x08, 0x16, + 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x35, 0x00, 0x40, 0x01, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x05, 0x01, 0x12, 0x03, 0x35, 0x08, 0x12, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x05, 0x08, 0x00, + 0x12, 0x04, 0x36, 0x02, 0x3f, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x08, 0x00, 0x01, 0x12, + 0x03, 0x36, 0x08, 0x0d, 0x0a, 0x4a, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x38, 0x04, + 0x1c, 0x1a, 0x3d, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x73, + 0x74, 0x61, 0x74, 0x69, 0x63, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x69, 0x73, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x75, 0x73, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x50, 0x61, + 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x05, 0x12, 0x03, 0x38, 0x04, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x38, 0x0b, 0x17, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x38, 0x1a, 0x1b, 0x0a, 0x42, 0x0a, 0x04, 0x04, 0x05, + 0x02, 0x01, 0x12, 0x03, 0x3b, 0x04, 0x2d, 0x1a, 0x35, 0x20, 0x54, 0x68, 0x65, 0x20, 0x74, 0x69, + 0x6d, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x69, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x75, 0x73, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x54, 0x69, 0x6d, 0x65, 0x50, + 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x61, 0x73, 0x65, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x06, 0x12, 0x03, 0x3b, 0x04, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x01, 0x01, 0x12, 0x03, 0x3b, 0x1e, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x3b, 0x2b, 0x2c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x02, + 0x12, 0x03, 0x3c, 0x04, 0x2e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x06, 0x12, 0x03, + 0x3c, 0x04, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x01, 0x12, 0x03, 0x3c, 0x18, + 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x03, 0x12, 0x03, 0x3c, 0x2c, 0x2d, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x03, 0x12, 0x03, 0x3d, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x03, 0x06, 0x12, 0x03, 0x3d, 0x04, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x03, 0x01, 0x12, 0x03, 0x3d, 0x15, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, + 0x03, 0x12, 0x03, 0x3d, 0x25, 0x26, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x04, 0x12, 0x03, + 0x3e, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x06, 0x12, 0x03, 0x3e, 0x04, + 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x01, 0x12, 0x03, 0x3e, 0x13, 0x22, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x03, 0x12, 0x03, 0x3e, 0x25, 0x26, 0x0a, 0x0a, 0x0a, + 0x02, 0x04, 0x06, 0x12, 0x04, 0x42, 0x00, 0x44, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, 0x01, + 0x12, 0x03, 0x42, 0x08, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x03, 0x43, + 0x02, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x06, 0x12, 0x03, 0x43, 0x02, 0x19, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x03, 0x43, 0x1a, 0x1f, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x03, 0x43, 0x22, 0x23, 0x0a, 0x0a, 0x0a, 0x02, + 0x04, 0x07, 0x12, 0x04, 0x46, 0x00, 0x49, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, + 0x03, 0x46, 0x08, 0x15, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x03, 0x47, 0x02, + 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x06, 0x12, 0x03, 0x47, 0x02, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x01, 0x12, 0x03, 0x47, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x00, 0x03, 0x12, 0x03, 0x47, 0x15, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x07, 0x02, 0x01, 0x12, 0x03, 0x48, 0x02, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, + 0x06, 0x12, 0x03, 0x48, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x48, 0x0e, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, 0x03, 0x48, + 0x1c, 0x1d, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x04, 0x4b, 0x00, 0x56, 0x01, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x08, 0x01, 0x12, 0x03, 0x4b, 0x08, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, + 0x02, 0x00, 0x12, 0x03, 0x4c, 0x02, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x4c, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x4c, 0x0e, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x03, 0x4c, 0x1d, + 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x01, 0x12, 0x03, 0x4e, 0x02, 0x15, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x05, 0x12, 0x03, 0x4e, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x08, 0x02, 0x01, 0x01, 0x12, 0x03, 0x4e, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x4e, 0x13, 0x14, 0x0a, 0xa4, 0x01, 0x0a, 0x04, 0x04, 0x08, 0x02, + 0x02, 0x12, 0x03, 0x52, 0x02, 0x1c, 0x1a, 0x96, 0x01, 0x20, 0x54, 0x68, 0x69, 0x6e, 0x6b, 0x20, + 0x6f, 0x66, 0x20, 0x61, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, + 0x73, 0x20, 0x61, 0x20, 0x74, 0x61, 0x67, 0x20, 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x20, 0x41, 0x72, + 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x2c, 0x20, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74, 0x20, 0x69, + 0x74, 0x27, 0x73, 0x20, 0x61, 0x20, 0x6b, 0x65, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, + 0x70, 0x61, 0x69, 0x72, 0x2e, 0x0a, 0x20, 0x44, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, + 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6e, 0x61, 0x74, 0x75, + 0x72, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, + 0x72, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x28, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x64, 0x73, 0x29, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x06, 0x12, 0x03, 0x52, 0x02, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x02, 0x01, 0x12, 0x03, 0x52, 0x0d, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x02, 0x03, 0x12, 0x03, 0x52, 0x1a, 0x1b, 0x0a, 0x74, 0x0a, 0x04, 0x04, 0x08, 0x02, + 0x03, 0x12, 0x03, 0x55, 0x02, 0x23, 0x1a, 0x67, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, + 0x73, 0x20, 0x6e, 0x6f, 0x20, 0x73, 0x75, 0x63, 0x68, 0x20, 0x74, 0x68, 0x69, 0x6e, 0x67, 0x20, + 0x61, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x74, 0x69, 0x6d, 0x65, + 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x2d, 0x20, 0x69, 0x66, 0x20, + 0x69, 0x74, 0x27, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x65, 0x74, 0x2c, 0x20, 0x74, 0x68, + 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x20, 0x74, + 0x69, 0x6d, 0x65, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x06, 0x12, 0x03, 0x55, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x03, 0x01, 0x12, 0x03, 0x55, 0x10, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x03, 0x03, 0x12, 0x03, 0x55, 0x21, 0x22, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x09, 0x12, + 0x04, 0x58, 0x00, 0x5c, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, 0x03, 0x58, 0x08, + 0x13, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x00, 0x12, 0x03, 0x59, 0x02, 0x1f, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x06, 0x12, 0x03, 0x59, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x03, 0x59, 0x0e, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x59, 0x1d, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x01, + 0x12, 0x03, 0x5b, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x06, 0x12, 0x03, + 0x5b, 0x02, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x01, 0x12, 0x03, 0x5b, 0x0d, + 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x03, 0x12, 0x03, 0x5b, 0x15, 0x16, 0x0a, + 0xab, 0x02, 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x04, 0x63, 0x00, 0x6d, 0x01, 0x1a, 0x9e, 0x02, 0x20, + 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x6e, 0x65, 0x73, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, + 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x41, 0x72, 0x74, 0x69, 0x66, + 0x61, 0x63, 0x74, 0x73, 0x0a, 0x20, 0x20, 0x2d, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x2c, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x2c, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x20, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x0a, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x32, 0x20, 0x28, 0x74, + 0x61, 0x67, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x6c, 0x6f, + 0x6e, 0x65, 0x2c, 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6e, 0x20, + 0x69, 0x6e, 0x64, 0x69, 0x76, 0x69, 0x64, 0x75, 0x61, 0x6c, 0x20, 0x61, 0x72, 0x74, 0x69, 0x66, + 0x61, 0x63, 0x74, 0x20, 0x69, 0x64, 0x29, 0x3a, 0x0a, 0x20, 0x20, 0x2d, 0x20, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x2c, 0x20, 0x6e, 0x61, + 0x6d, 0x65, 0x2c, 0x20, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x20, 0x28, 0x70, 0x6f, 0x69, 0x6e, 0x74, + 0x73, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x69, 0x66, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x65, + 0x64, 0x29, 0x0a, 0x20, 0x20, 0x2d, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x20, + 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x2c, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x20, 0x70, 0x61, + 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6b, 0x65, 0x79, 0x2c, 0x20, 0x70, 0x61, 0x72, + 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x0a, 0x01, 0x12, 0x03, 0x63, 0x08, 0x15, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0a, 0x08, + 0x00, 0x12, 0x04, 0x64, 0x02, 0x6c, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x08, 0x00, 0x01, + 0x12, 0x03, 0x64, 0x08, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x00, 0x12, 0x03, 0x65, + 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x06, 0x12, 0x03, 0x65, 0x04, 0x0e, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x03, 0x65, 0x0f, 0x1a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, 0x03, 0x65, 0x1d, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x0a, 0x02, 0x01, 0x12, 0x03, 0x66, 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, + 0x01, 0x06, 0x12, 0x03, 0x66, 0x04, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x66, 0x10, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x66, 0x1f, 0x20, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x02, 0x12, 0x03, 0x67, 0x04, 0x13, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x05, 0x12, 0x03, 0x67, 0x04, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x01, 0x12, 0x03, 0x67, 0x0b, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x0a, 0x02, 0x02, 0x03, 0x12, 0x03, 0x67, 0x11, 0x12, 0x0a, 0xc0, 0x01, 0x0a, 0x04, 0x04, + 0x0a, 0x02, 0x03, 0x12, 0x03, 0x6b, 0x04, 0x24, 0x1a, 0xb2, 0x01, 0x20, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x63, 0x61, 0x73, 0x65, 0x2c, 0x20, 0x77, 0x68, + 0x65, 0x72, 0x65, 0x20, 0x61, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, + 0x73, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, + 0x74, 0x73, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x64, 0x65, 0x72, 0x69, 0x76, 0x65, 0x64, + 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x69, + 0x6e, 0x67, 0x20, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x0a, 0x02, 0x03, 0x06, 0x12, 0x03, 0x6b, 0x04, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x6b, 0x18, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, + 0x03, 0x03, 0x12, 0x03, 0x6b, 0x22, 0x23, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, + 0xa7, 0x45, 0x0a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, + 0x72, 0x65, 0x2f, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x22, 0xea, 0x01, 0x0a, 0x06, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x12, 0x14, 0x0a, 0x05, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x12, 0x23, 0x0a, 0x0d, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x4d, 0x0a, 0x11, 0x6d, 0x6f, 0x75, + 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x4d, 0x6f, 0x75, + 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x10, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x71, + 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x65, 0x6e, 0x76, 0x5f, + 0x76, 0x61, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x65, 0x6e, 0x76, 0x56, 0x61, + 0x72, 0x22, 0x2b, 0x0a, 0x09, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x07, + 0x0a, 0x03, 0x41, 0x4e, 0x59, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x45, 0x4e, 0x56, 0x5f, 0x56, + 0x41, 0x52, 0x10, 0x01, 0x12, 0x08, 0x0a, 0x04, 0x46, 0x49, 0x4c, 0x45, 0x10, 0x02, 0x22, 0xa7, + 0x02, 0x0a, 0x0a, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, + 0x09, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x74, 0x61, 0x73, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x12, 0x41, 0x0a, 0x07, 0x73, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x41, 0x0a, + 0x07, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, + 0x1a, 0x3a, 0x0a, 0x0c, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, + 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3a, 0x0a, 0x0c, + 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x68, 0x0a, 0x0c, 0x4f, 0x41, 0x75, 0x74, + 0x68, 0x32, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x49, 0x64, 0x12, 0x3b, 0x0a, 0x0d, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x52, 0x0c, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x22, 0xc7, 0x01, 0x0a, 0x08, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, + 0x19, 0x0a, 0x08, 0x69, 0x61, 0x6d, 0x5f, 0x72, 0x6f, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x07, 0x69, 0x61, 0x6d, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x6b, 0x38, + 0x73, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, + 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x6b, 0x38, 0x73, 0x53, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x41, 0x0a, 0x0d, 0x6f, 0x61, + 0x75, 0x74, 0x68, 0x32, 0x5f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x52, + 0x0c, 0x6f, 0x61, 0x75, 0x74, 0x68, 0x32, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x2d, 0x0a, + 0x12, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x65, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x22, 0x98, 0x02, 0x0a, + 0x12, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3b, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x54, 0x6f, 0x6b, + 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, + 0x74, 0x79, 0x70, 0x65, 0x12, 0x34, 0x0a, 0x06, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x43, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x52, 0x06, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x34, 0x0a, 0x16, 0x69, 0x64, + 0x70, 0x5f, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x5f, 0x65, 0x6e, 0x64, 0x70, + 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x14, 0x69, 0x64, 0x70, 0x44, + 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, + 0x12, 0x25, 0x0a, 0x0e, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, + 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x45, + 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x22, 0x1e, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, + 0x16, 0x0a, 0x12, 0x43, 0x4c, 0x49, 0x45, 0x4e, 0x54, 0x5f, 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, + 0x54, 0x49, 0x41, 0x4c, 0x53, 0x10, 0x00, 0x22, 0xb0, 0x01, 0x0a, 0x0f, 0x53, 0x65, 0x63, 0x75, + 0x72, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x2f, 0x0a, 0x06, 0x72, + 0x75, 0x6e, 0x5f, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x05, 0x72, 0x75, 0x6e, 0x41, 0x73, 0x12, 0x30, 0x0a, 0x07, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x3a, + 0x0a, 0x06, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x52, 0x06, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x42, 0xb0, 0x01, 0x0a, 0x12, 0x63, + 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x42, 0x0d, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, + 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, + 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x0e, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0xca, 0x02, 0x0e, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0xe2, 0x02, + 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, + 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x4a, 0xa1, 0x39, + 0x0a, 0x07, 0x12, 0x05, 0x00, 0x00, 0x93, 0x01, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, + 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x17, 0x0a, 0x08, 0x0a, + 0x01, 0x08, 0x12, 0x03, 0x04, 0x00, 0x49, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x04, + 0x00, 0x49, 0x0a, 0xaf, 0x03, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0b, 0x00, 0x32, 0x01, 0x1a, + 0xa2, 0x03, 0x20, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x65, 0x6e, 0x63, 0x61, 0x70, 0x73, + 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x73, + 0x20, 0x74, 0x6f, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x65, 0x64, 0x2e, 0x20, 0x41, 0x6e, 0x20, + 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x72, 0x69, + 0x61, 0x62, 0x6c, 0x65, 0x0a, 0x20, 0x46, 0x4c, 0x59, 0x54, 0x45, 0x5f, 0x53, 0x45, 0x43, 0x52, + 0x45, 0x54, 0x53, 0x5f, 0x45, 0x4e, 0x56, 0x5f, 0x50, 0x52, 0x45, 0x46, 0x49, 0x58, 0x20, 0x77, + 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, + 0x65, 0x66, 0x69, 0x78, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x76, 0x69, + 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x70, + 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x66, 0x0a, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x68, + 0x72, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, + 0x74, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x46, 0x4c, + 0x59, 0x54, 0x45, 0x5f, 0x53, 0x45, 0x43, 0x52, 0x45, 0x54, 0x53, 0x5f, 0x44, 0x45, 0x46, 0x41, + 0x55, 0x4c, 0x54, 0x5f, 0x44, 0x49, 0x52, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, + 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, + 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, + 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x64, 0x20, 0x69, 0x66, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x73, 0x0a, 0x20, 0x61, 0x72, 0x65, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, + 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x6d, 0x6f, 0x75, 0x6e, + 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0b, 0x08, 0x0e, + 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x00, 0x04, 0x00, 0x12, 0x04, 0x0c, 0x02, 0x15, 0x03, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0c, 0x07, 0x10, 0x0a, 0x59, 0x0a, 0x06, + 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0e, 0x04, 0x0c, 0x1a, 0x4a, 0x20, 0x44, 0x65, + 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x63, 0x61, 0x73, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x64, 0x69, + 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x20, 0x63, 0x61, 0x6e, 0x20, 0x74, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x65, 0x20, 0x65, 0x69, + 0x74, 0x68, 0x65, 0x72, 0x20, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x0e, 0x04, 0x07, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, + 0x00, 0x02, 0x12, 0x03, 0x0e, 0x0a, 0x0b, 0x0a, 0x5d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, + 0x01, 0x12, 0x03, 0x11, 0x04, 0x10, 0x1a, 0x4e, 0x20, 0x45, 0x4e, 0x56, 0x5f, 0x56, 0x41, 0x52, + 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, + 0x65, 0x20, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6e, 0x20, + 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x72, 0x69, + 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x11, 0x04, 0x0b, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, + 0x02, 0x12, 0x03, 0x11, 0x0e, 0x0f, 0x0a, 0x49, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, + 0x12, 0x03, 0x14, 0x04, 0x0d, 0x1a, 0x3a, 0x20, 0x46, 0x49, 0x4c, 0x45, 0x20, 0x69, 0x6e, 0x64, + 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x6d, 0x6f, + 0x75, 0x6e, 0x74, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2e, + 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x14, 0x04, + 0x08, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x14, 0x0b, + 0x0c, 0x0a, 0xc0, 0x02, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x1b, 0x02, 0x13, 0x1a, + 0xb2, 0x02, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x20, + 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x69, 0x6e, 0x64, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x64, + 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x77, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x4b, 0x38, 0x73, 0x20, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, + 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x31, 0x2f, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x43, + 0x6f, 0x6e, 0x66, 0x69, 0x64, 0x61, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x43, 0x72, 0x65, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2e, 0x20, 0x46, 0x6f, + 0x72, 0x20, 0x56, 0x61, 0x75, 0x6c, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2e, 0x0a, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x41, 0x57, + 0x53, 0x20, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, + 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x0a, 0x20, 0x2b, 0x72, 0x65, 0x71, 0x75, 0x69, + 0x72, 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x1b, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1b, 0x09, 0x0e, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1b, 0x11, 0x12, 0x0a, 0xa5, + 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x20, 0x02, 0x1b, 0x1a, 0x97, 0x01, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x65, 0x74, 0x63, 0x68, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, + 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, + 0x6d, 0x73, 0x2e, 0x20, 0x49, 0x74, 0x27, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x69, 0x67, 0x6e, + 0x6f, 0x72, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x6e, 0x65, + 0x73, 0x0a, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, + 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x69, 0x74, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, + 0x03, 0x20, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x20, + 0x09, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x20, 0x19, 0x1a, + 0x0a, 0xcd, 0x02, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x26, 0x02, 0x11, 0x1a, 0xbf, + 0x02, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x6f, 0x75, 0x6e, + 0x74, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x68, 0x61, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x6d, + 0x61, 0x74, 0x63, 0x68, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, + 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x20, 0x49, 0x74, 0x27, 0x73, 0x20, 0x75, 0x70, 0x20, 0x74, + 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x20, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x73, + 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, + 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x76, 0x69, 0x74, + 0x79, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x4b, 0x38, 0x73, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x73, 0x2c, 0x20, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x64, 0x61, 0x6e, 0x74, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x56, 0x61, 0x75, 0x6c, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x0a, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x20, 0x6f, 0x6e, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x20, 0x69, 0x6e, 0x73, 0x69, + 0x64, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x20, 0x46, + 0x6f, 0x72, 0x20, 0x41, 0x57, 0x53, 0x20, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x4d, 0x61, + 0x6e, 0x61, 0x67, 0x65, 0x72, 0x2c, 0x20, 0x69, 0x74, 0x27, 0x73, 0x20, 0x69, 0x67, 0x6e, 0x6f, + 0x72, 0x65, 0x64, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x26, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x26, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x26, 0x0f, 0x10, 0x0a, 0xa7, 0x02, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x03, 0x12, 0x03, 0x2c, 0x02, 0x22, 0x1a, 0x99, 0x02, 0x20, 0x6d, 0x6f, 0x75, 0x6e, + 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x73, + 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2e, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, + 0x61, 0x74, 0x65, 0x73, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, + 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x64, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x70, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x64, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x66, 0x61, 0x69, 0x6c, 0x0a, 0x20, 0x69, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, 0x79, 0x69, 0x6e, 0x67, + 0x20, 0x6b, 0x65, 0x79, 0x20, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, + 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x61, + 0x74, 0x69, 0x73, 0x66, 0x79, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, + 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x70, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, + 0x61, 0x75, 0x6c, 0x74, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x77, + 0x69, 0x6c, 0x6c, 0x20, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, + 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x61, 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x06, 0x12, 0x03, 0x2c, + 0x02, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x2c, 0x0c, 0x1d, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x2c, 0x20, 0x21, 0x0a, 0xff, + 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, 0x31, 0x02, 0x15, 0x1a, 0xf1, 0x01, 0x20, + 0x65, 0x6e, 0x76, 0x5f, 0x76, 0x61, 0x72, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x61, 0x6c, 0x2e, 0x20, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x65, 0x6e, 0x76, 0x69, + 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, + 0x20, 0x74, 0x6f, 0x20, 0x73, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, + 0x20, 0x49, 0x66, 0x20, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, + 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x73, 0x20, 0x45, 0x4e, 0x56, 0x5f, 0x56, 0x41, 0x52, + 0x2c, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, + 0x69, 0x74, 0x73, 0x65, 0x6c, 0x66, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x6d, 0x6f, 0x75, 0x6e, 0x74, + 0x5f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x73, 0x20, + 0x46, 0x49, 0x4c, 0x45, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, + 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x66, + 0x69, 0x6c, 0x65, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x05, 0x12, 0x03, 0x31, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x31, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, 0x31, 0x13, 0x14, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x01, + 0x12, 0x04, 0x34, 0x00, 0x3f, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x34, + 0x08, 0x12, 0x0a, 0x3d, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x36, 0x02, 0x17, 0x1a, + 0x30, 0x20, 0x54, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x36, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x36, 0x09, 0x12, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x36, 0x15, 0x16, 0x0a, 0xea, 0x01, 0x0a, 0x04, + 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x3a, 0x02, 0x22, 0x1a, 0xdc, 0x01, 0x20, 0x54, 0x68, 0x65, + 0x20, 0x63, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x20, 0x74, 0x6f, 0x20, + 0x75, 0x73, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x73, 0x75, 0x63, 0x68, 0x20, 0x61, 0x73, 0x20, + 0x41, 0x50, 0x49, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x2c, 0x20, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, + 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x2c, 0x20, 0x65, 0x74, 0x63, 0x2e, 0x0a, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x61, + 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x69, 0x74, 0x27, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, + 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6b, + 0x69, 0x74, 0x2e, 0x0a, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6b, 0x69, 0x74, 0x20, 0x75, 0x73, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6c, 0x6f, + 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, + 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6d, 0x61, 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, + 0x06, 0x12, 0x03, 0x3a, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x3a, 0x16, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x3a, + 0x20, 0x21, 0x0a, 0xab, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x3e, 0x02, 0x22, + 0x1a, 0x9d, 0x01, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c, + 0x20, 0x73, 0x75, 0x63, 0x68, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x64, + 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x2c, 0x20, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x6e, + 0x61, 0x6d, 0x65, 0x2c, 0x20, 0x65, 0x74, 0x63, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6b, + 0x65, 0x79, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2c, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x69, 0x74, 0x27, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x69, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6b, 0x69, 0x74, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x06, 0x12, 0x03, 0x3e, 0x02, 0x15, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x3e, 0x16, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x3e, 0x20, 0x21, 0x0a, 0x76, 0x0a, 0x02, 0x04, 0x02, + 0x12, 0x04, 0x42, 0x00, 0x4b, 0x01, 0x1a, 0x6a, 0x20, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x43, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x65, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, + 0x65, 0x73, 0x20, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x20, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x20, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x20, 0x74, 0x6f, 0x20, + 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x6d, 0x61, 0x6b, + 0x69, 0x6e, 0x67, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x73, 0x20, 0x6f, 0x6e, 0x20, 0x62, 0x65, 0x68, + 0x61, 0x6c, 0x66, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x61, 0x73, 0x6b, + 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x42, 0x08, 0x14, 0x0a, 0xc1, + 0x01, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x46, 0x02, 0x17, 0x1a, 0xb3, 0x01, 0x20, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x69, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, + 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x77, 0x69, 0x6c, + 0x6c, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x61, 0x6e, + 0x79, 0x20, 0x70, 0x72, 0x65, 0x2d, 0x61, 0x75, 0x74, 0x68, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, + 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x68, 0x65, 0x72, 0x65, 0x2e, 0x0a, 0x20, 0x2b, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, + 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, 0x46, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x46, 0x09, 0x12, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x46, 0x15, 0x16, 0x0a, 0x6c, 0x0a, 0x04, + 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x4a, 0x02, 0x1b, 0x1a, 0x5f, 0x20, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x5f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x72, + 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x61, + 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x0a, 0x20, + 0x2b, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x01, 0x06, 0x12, 0x03, 0x4a, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x4a, 0x09, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x4a, 0x19, 0x1a, 0x0a, 0xb3, 0x01, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x4f, 0x00, 0x5c, + 0x01, 0x1a, 0xa6, 0x01, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x65, 0x6e, + 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, + 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x20, + 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, + 0x6b, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x61, 0x73, 0x2e, 0x20, 0x49, 0x74, + 0x27, 0x73, 0x20, 0x75, 0x70, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x64, + 0x65, 0x72, 0x6c, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x20, 0x74, + 0x6f, 0x20, 0x70, 0x69, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x6e, 0x76, + 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, + 0x01, 0x12, 0x03, 0x4f, 0x08, 0x10, 0x0a, 0x70, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, + 0x51, 0x02, 0x16, 0x1a, 0x63, 0x20, 0x69, 0x61, 0x6d, 0x5f, 0x72, 0x6f, 0x6c, 0x65, 0x20, 0x72, + 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, + 0x6c, 0x6c, 0x79, 0x20, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x6e, 0x61, + 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x26, + 0x20, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, + 0x6e, 0x74, 0x20, 0x72, 0x6f, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6d, 0x70, 0x65, 0x72, + 0x73, 0x6f, 0x6e, 0x61, 0x74, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, + 0x05, 0x12, 0x03, 0x51, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x51, 0x09, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x51, + 0x14, 0x15, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, 0x54, 0x02, 0x21, 0x1a, + 0x4d, 0x20, 0x6b, 0x38, 0x73, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x61, 0x63, + 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, + 0x20, 0x61, 0x20, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x20, 0x73, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x74, 0x6f, + 0x20, 0x69, 0x6d, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x61, 0x74, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x05, 0x12, 0x03, 0x54, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, 0x54, 0x09, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x54, 0x1f, 0x20, 0x0a, 0x9a, 0x01, 0x0a, 0x04, 0x04, 0x03, 0x02, + 0x02, 0x12, 0x03, 0x58, 0x02, 0x21, 0x1a, 0x8c, 0x01, 0x20, 0x6f, 0x61, 0x75, 0x74, 0x68, 0x32, + 0x5f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, + 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x6f, 0x61, 0x75, 0x74, 0x68, 0x32, 0x20, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x2e, 0x20, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x20, 0x70, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, + 0x20, 0x69, 0x6d, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x6d, 0x61, + 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x63, 0x61, + 0x6c, 0x6c, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x06, 0x12, 0x03, + 0x58, 0x02, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x01, 0x12, 0x03, 0x58, 0x0f, + 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x03, 0x12, 0x03, 0x58, 0x1f, 0x20, 0x0a, + 0x50, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x03, 0x12, 0x03, 0x5b, 0x02, 0x20, 0x1a, 0x43, 0x20, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x77, 0x68, 0x6f, 0x20, 0x6d, 0x61, 0x6b, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x05, 0x12, 0x03, 0x5b, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x01, 0x12, 0x03, 0x5b, 0x09, 0x1b, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x03, 0x03, 0x12, 0x03, 0x5b, 0x1e, 0x1f, 0x0a, 0x99, 0x03, 0x0a, 0x02, + 0x04, 0x04, 0x12, 0x05, 0x63, 0x00, 0x80, 0x01, 0x01, 0x1a, 0x8b, 0x03, 0x20, 0x4f, 0x41, 0x75, + 0x74, 0x68, 0x32, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, + 0x65, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x66, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x61, 0x6e, 0x20, 0x4f, 0x41, + 0x75, 0x74, 0x68, 0x32, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x0a, 0x20, 0x46, 0x4c, 0x59, + 0x54, 0x45, 0x5f, 0x54, 0x4f, 0x4b, 0x45, 0x4e, 0x53, 0x5f, 0x45, 0x4e, 0x56, 0x5f, 0x50, 0x52, + 0x45, 0x46, 0x49, 0x58, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x73, + 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, + 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6c, + 0x6c, 0x20, 0x62, 0x65, 0x20, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x66, 0x0a, + 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x70, 0x61, 0x73, 0x73, + 0x65, 0x64, 0x20, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x65, 0x6e, 0x76, 0x69, 0x72, + 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, + 0x2e, 0x0a, 0x20, 0x46, 0x4c, 0x59, 0x54, 0x45, 0x5f, 0x54, 0x4f, 0x4b, 0x45, 0x4e, 0x53, 0x5f, + 0x50, 0x41, 0x54, 0x48, 0x5f, 0x50, 0x52, 0x45, 0x46, 0x49, 0x58, 0x20, 0x77, 0x69, 0x6c, 0x6c, + 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, + 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, + 0x78, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x77, 0x68, + 0x65, 0x72, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, + 0x20, 0x62, 0x65, 0x20, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x64, 0x20, 0x69, 0x66, 0x20, 0x74, + 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x0a, 0x20, 0x61, 0x72, 0x65, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, + 0x64, 0x20, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x6d, + 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, + 0x63, 0x08, 0x1a, 0x0a, 0x2c, 0x0a, 0x04, 0x04, 0x04, 0x04, 0x00, 0x12, 0x04, 0x65, 0x02, 0x68, + 0x03, 0x1a, 0x1e, 0x20, 0x54, 0x79, 0x70, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x04, 0x00, 0x01, 0x12, 0x03, 0x65, 0x07, 0x0b, 0x0a, + 0x68, 0x0a, 0x06, 0x04, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x67, 0x04, 0x1b, 0x1a, 0x59, + 0x20, 0x43, 0x4c, 0x49, 0x45, 0x4e, 0x54, 0x5f, 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, 0x49, + 0x41, 0x4c, 0x53, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, + 0x32, 0x2d, 0x6c, 0x65, 0x67, 0x67, 0x65, 0x64, 0x20, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x20, 0x74, + 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x75, + 0x73, 0x69, 0x6e, 0x67, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x65, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x04, + 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x67, 0x04, 0x16, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x04, + 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x67, 0x19, 0x1a, 0x0a, 0xd1, 0x01, 0x0a, 0x04, 0x04, 0x04, + 0x02, 0x00, 0x12, 0x03, 0x6d, 0x02, 0x12, 0x1a, 0xc3, 0x01, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, + 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x75, 0x6e, 0x69, 0x71, + 0x75, 0x65, 0x20, 0x69, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x69, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x74, 0x6f, 0x6b, + 0x65, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x2e, 0x20, 0x49, 0x74, 0x27, + 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, + 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x20, 0x66, 0x6f, 0x72, 0x0a, 0x20, 0x65, 0x6e, 0x76, 0x69, + 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, + 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x6e, + 0x61, 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x69, 0x6e, 0x67, + 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x20, 0x61, 0x73, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x73, + 0x2e, 0x0a, 0x20, 0x2b, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x00, 0x05, 0x12, 0x03, 0x6d, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x6d, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x6d, 0x10, 0x11, 0x0a, 0x69, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, + 0x03, 0x71, 0x02, 0x10, 0x1a, 0x5c, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x69, 0x6e, 0x64, 0x69, + 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x74, 0x6f, + 0x20, 0x6d, 0x61, 0x6b, 0x65, 0x2e, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x20, + 0x74, 0x6f, 0x20, 0x43, 0x4c, 0x49, 0x45, 0x4e, 0x54, 0x5f, 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, + 0x54, 0x49, 0x41, 0x4c, 0x53, 0x2e, 0x0a, 0x20, 0x2b, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, + 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x06, 0x12, 0x03, 0x71, 0x02, 0x06, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x71, 0x07, 0x0b, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x71, 0x0e, 0x0f, 0x0a, 0x64, 0x0a, 0x04, + 0x04, 0x04, 0x02, 0x02, 0x12, 0x03, 0x75, 0x02, 0x1a, 0x1a, 0x57, 0x20, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x2f, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x32, 0x20, + 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x0a, 0x20, 0x2b, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, + 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x06, 0x12, 0x03, 0x75, 0x02, 0x0e, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x75, 0x0f, 0x15, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, 0x75, 0x18, 0x19, 0x0a, 0x93, 0x01, 0x0a, + 0x04, 0x04, 0x04, 0x02, 0x03, 0x12, 0x03, 0x7a, 0x02, 0x24, 0x1a, 0x85, 0x01, 0x20, 0x69, 0x64, + 0x70, 0x5f, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x5f, 0x65, 0x6e, 0x64, 0x70, + 0x6f, 0x69, 0x6e, 0x74, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x20, 0x65, 0x6e, + 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x72, + 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x65, 0x6e, + 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, + 0x20, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x0a, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x05, 0x12, 0x03, 0x7a, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x01, 0x12, 0x03, 0x7a, 0x09, 0x1f, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x03, 0x12, 0x03, 0x7a, 0x22, 0x23, 0x0a, 0x9a, 0x01, 0x0a, + 0x04, 0x04, 0x04, 0x02, 0x04, 0x12, 0x03, 0x7f, 0x02, 0x1c, 0x1a, 0x8c, 0x01, 0x20, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x5f, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x20, 0x72, 0x65, 0x66, + 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x6f, 0x6b, 0x65, + 0x6e, 0x20, 0x69, 0x73, 0x73, 0x75, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x65, 0x6e, 0x64, 0x70, 0x6f, + 0x69, 0x6e, 0x74, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x69, 0x64, 0x70, 0x5f, 0x64, 0x69, 0x73, 0x63, + 0x6f, 0x76, 0x65, 0x72, 0x79, 0x5f, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x20, 0x69, + 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2c, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x20, 0x69, + 0x73, 0x0a, 0x20, 0x6d, 0x61, 0x6e, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x79, 0x2e, 0x0a, 0x20, 0x2b, + 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x04, 0x05, 0x12, 0x03, 0x7f, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x01, + 0x12, 0x03, 0x7f, 0x09, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x03, 0x12, 0x03, + 0x7f, 0x1a, 0x1b, 0x0a, 0x4e, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x06, 0x83, 0x01, 0x00, 0x93, 0x01, + 0x01, 0x1a, 0x40, 0x20, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x6e, 0x74, + 0x65, 0x78, 0x74, 0x20, 0x68, 0x6f, 0x6c, 0x64, 0x73, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, + 0x74, 0x79, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x61, 0x73, 0x6b, + 0x73, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x04, 0x83, 0x01, 0x08, 0x17, + 0x0a, 0xe6, 0x01, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x04, 0x86, 0x01, 0x02, 0x16, 0x1a, + 0xd7, 0x01, 0x20, 0x72, 0x75, 0x6e, 0x5f, 0x61, 0x73, 0x20, 0x65, 0x6e, 0x63, 0x61, 0x70, 0x73, + 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x20, 0x61, 0x20, 0x70, 0x6f, 0x64, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x20, 0x72, 0x75, 0x6e, 0x20, 0x61, 0x73, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x74, 0x61, 0x73, 0x6b, 0x20, 0x66, 0x69, 0x6c, 0x6c, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x6d, 0x75, + 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, 0x68, 0x65, + 0x72, 0x65, 0x2c, 0x20, 0x69, 0x74, 0x27, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x75, 0x70, 0x20, + 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x20, + 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x68, 0x6f, 0x6f, 0x73, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x70, 0x72, 0x69, 0x61, 0x74, 0x65, + 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x6e, 0x67, 0x69, + 0x6e, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x77, 0x69, 0x6c, 0x6c, + 0x20, 0x72, 0x75, 0x6e, 0x20, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x00, 0x06, 0x12, 0x04, 0x86, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, + 0x01, 0x12, 0x04, 0x86, 0x01, 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, + 0x12, 0x04, 0x86, 0x01, 0x14, 0x15, 0x0a, 0xa4, 0x03, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, + 0x04, 0x8c, 0x01, 0x02, 0x1e, 0x1a, 0x95, 0x03, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, + 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, + 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x73, 0x20, 0x69, 0x6e, 0x20, + 0x6f, 0x72, 0x64, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x65, 0x64, + 0x2e, 0x20, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, + 0x65, 0x20, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x64, 0x2f, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x70, 0x6f, 0x64, 0x20, 0x61, 0x73, 0x20, + 0x69, 0x74, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x73, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x69, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6b, 0x69, 0x63, 0x6b, 0x69, 0x6e, 0x67, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x77, 0x69, 0x6c, + 0x6c, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x69, 0x74, 0x20, 0x6f, 0x6e, 0x20, + 0x61, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, + 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x41, 0x57, 0x53, 0x0a, 0x20, 0x42, 0x61, 0x74, 0x63, 0x68, + 0x29, 0x2c, 0x20, 0x69, 0x74, 0x27, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x65, 0x74, 0x63, + 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x28, 0x77, 0x68, + 0x69, 0x63, 0x68, 0x20, 0x6d, 0x65, 0x61, 0x6e, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x6c, + 0x6c, 0x65, 0x72, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x77, 0x69, 0x6c, + 0x6c, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x0a, 0x20, 0x74, + 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x29, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x73, 0x73, 0x20, 0x69, 0x74, 0x20, 0x74, 0x6f, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x01, 0x04, 0x12, 0x04, 0x8c, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x01, 0x06, 0x12, 0x04, 0x8c, 0x01, 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x01, 0x01, 0x12, 0x04, 0x8c, 0x01, 0x12, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x01, 0x03, 0x12, 0x04, 0x8c, 0x01, 0x1c, 0x1d, 0x0a, 0xa9, 0x03, 0x0a, 0x04, 0x04, 0x05, + 0x02, 0x02, 0x12, 0x04, 0x92, 0x01, 0x02, 0x29, 0x1a, 0x9a, 0x03, 0x20, 0x74, 0x6f, 0x6b, 0x65, + 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x72, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, + 0x6e, 0x65, 0x65, 0x64, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x20, 0x74, + 0x6f, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x65, 0x64, 0x2e, 0x20, 0x54, 0x6f, 0x6b, 0x65, 0x6e, + 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x65, + 0x64, 0x2f, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, + 0x20, 0x70, 0x6f, 0x64, 0x20, 0x61, 0x73, 0x20, 0x69, 0x74, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x73, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x6b, 0x69, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x74, 0x61, 0x73, 0x6b, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x72, 0x75, + 0x6e, 0x20, 0x69, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x61, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x20, + 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x41, 0x57, + 0x53, 0x0a, 0x20, 0x42, 0x61, 0x74, 0x63, 0x68, 0x29, 0x2c, 0x20, 0x69, 0x74, 0x27, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x69, 0x62, 0x69, 0x6c, 0x69, + 0x74, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x20, 0x74, 0x6f, 0x20, 0x66, 0x65, 0x74, 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x20, 0x28, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x6d, 0x65, 0x61, 0x6e, + 0x73, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x69, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x20, 0x61, + 0x63, 0x63, 0x65, 0x73, 0x73, 0x0a, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x29, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x73, + 0x73, 0x20, 0x69, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x6d, 0x6f, + 0x74, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x6e, 0x67, + 0x69, 0x6e, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x04, 0x12, 0x04, + 0x92, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x06, 0x12, 0x04, 0x92, + 0x01, 0x0b, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x01, 0x12, 0x04, 0x92, 0x01, + 0x1e, 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x03, 0x12, 0x04, 0x92, 0x01, 0x27, + 0x28, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xbc, 0x43, 0x0a, 0x1e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x1a, 0x1e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa7, 0x01, + 0x0a, 0x11, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x22, 0x91, 0x01, 0x0a, 0x05, 0x50, 0x68, 0x61, 0x73, 0x65, 0x12, 0x0d, 0x0a, + 0x09, 0x55, 0x4e, 0x44, 0x45, 0x46, 0x49, 0x4e, 0x45, 0x44, 0x10, 0x00, 0x12, 0x0a, 0x0a, 0x06, + 0x51, 0x55, 0x45, 0x55, 0x45, 0x44, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x52, 0x55, 0x4e, 0x4e, + 0x49, 0x4e, 0x47, 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a, 0x53, 0x55, 0x43, 0x43, 0x45, 0x45, 0x44, + 0x49, 0x4e, 0x47, 0x10, 0x03, 0x12, 0x0d, 0x0a, 0x09, 0x53, 0x55, 0x43, 0x43, 0x45, 0x45, 0x44, + 0x45, 0x44, 0x10, 0x04, 0x12, 0x0b, 0x0a, 0x07, 0x46, 0x41, 0x49, 0x4c, 0x49, 0x4e, 0x47, 0x10, + 0x05, 0x12, 0x0a, 0x0a, 0x06, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x10, 0x06, 0x12, 0x0b, 0x0a, + 0x07, 0x41, 0x42, 0x4f, 0x52, 0x54, 0x45, 0x44, 0x10, 0x07, 0x12, 0x0d, 0x0a, 0x09, 0x54, 0x49, + 0x4d, 0x45, 0x44, 0x5f, 0x4f, 0x55, 0x54, 0x10, 0x08, 0x12, 0x0c, 0x0a, 0x08, 0x41, 0x42, 0x4f, + 0x52, 0x54, 0x49, 0x4e, 0x47, 0x10, 0x09, 0x22, 0xb6, 0x01, 0x0a, 0x0d, 0x4e, 0x6f, 0x64, 0x65, + 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xa4, 0x01, 0x0a, 0x05, 0x50, 0x68, + 0x61, 0x73, 0x65, 0x12, 0x0d, 0x0a, 0x09, 0x55, 0x4e, 0x44, 0x45, 0x46, 0x49, 0x4e, 0x45, 0x44, + 0x10, 0x00, 0x12, 0x0a, 0x0a, 0x06, 0x51, 0x55, 0x45, 0x55, 0x45, 0x44, 0x10, 0x01, 0x12, 0x0b, + 0x0a, 0x07, 0x52, 0x55, 0x4e, 0x4e, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x12, 0x0d, 0x0a, 0x09, 0x53, + 0x55, 0x43, 0x43, 0x45, 0x45, 0x44, 0x45, 0x44, 0x10, 0x03, 0x12, 0x0b, 0x0a, 0x07, 0x46, 0x41, + 0x49, 0x4c, 0x49, 0x4e, 0x47, 0x10, 0x04, 0x12, 0x0a, 0x0a, 0x06, 0x46, 0x41, 0x49, 0x4c, 0x45, + 0x44, 0x10, 0x05, 0x12, 0x0b, 0x0a, 0x07, 0x41, 0x42, 0x4f, 0x52, 0x54, 0x45, 0x44, 0x10, 0x06, + 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x4b, 0x49, 0x50, 0x50, 0x45, 0x44, 0x10, 0x07, 0x12, 0x0d, 0x0a, + 0x09, 0x54, 0x49, 0x4d, 0x45, 0x44, 0x5f, 0x4f, 0x55, 0x54, 0x10, 0x08, 0x12, 0x13, 0x0a, 0x0f, + 0x44, 0x59, 0x4e, 0x41, 0x4d, 0x49, 0x43, 0x5f, 0x52, 0x55, 0x4e, 0x4e, 0x49, 0x4e, 0x47, 0x10, + 0x09, 0x12, 0x0d, 0x0a, 0x09, 0x52, 0x45, 0x43, 0x4f, 0x56, 0x45, 0x52, 0x45, 0x44, 0x10, 0x0a, + 0x22, 0xac, 0x01, 0x0a, 0x0d, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x22, 0x9a, 0x01, 0x0a, 0x05, 0x50, 0x68, 0x61, 0x73, 0x65, 0x12, 0x0d, 0x0a, 0x09, + 0x55, 0x4e, 0x44, 0x45, 0x46, 0x49, 0x4e, 0x45, 0x44, 0x10, 0x00, 0x12, 0x0a, 0x0a, 0x06, 0x51, + 0x55, 0x45, 0x55, 0x45, 0x44, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x52, 0x55, 0x4e, 0x4e, 0x49, + 0x4e, 0x47, 0x10, 0x02, 0x12, 0x0d, 0x0a, 0x09, 0x53, 0x55, 0x43, 0x43, 0x45, 0x45, 0x44, 0x45, + 0x44, 0x10, 0x03, 0x12, 0x0b, 0x0a, 0x07, 0x41, 0x42, 0x4f, 0x52, 0x54, 0x45, 0x44, 0x10, 0x04, + 0x12, 0x0a, 0x0a, 0x06, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x10, 0x05, 0x12, 0x10, 0x0a, 0x0c, + 0x49, 0x4e, 0x49, 0x54, 0x49, 0x41, 0x4c, 0x49, 0x5a, 0x49, 0x4e, 0x47, 0x10, 0x06, 0x12, 0x19, + 0x0a, 0x15, 0x57, 0x41, 0x49, 0x54, 0x49, 0x4e, 0x47, 0x5f, 0x46, 0x4f, 0x52, 0x5f, 0x52, 0x45, + 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x53, 0x10, 0x07, 0x12, 0x14, 0x0a, 0x10, 0x52, 0x45, 0x54, + 0x52, 0x59, 0x41, 0x42, 0x4c, 0x45, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x10, 0x08, 0x22, + 0x9b, 0x02, 0x0a, 0x0e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, + 0x6f, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x12, 0x1b, 0x0a, 0x09, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x55, 0x72, 0x69, 0x12, 0x3c, 0x0a, + 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x28, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x45, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x2e, 0x45, 0x72, 0x72, 0x6f, + 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x38, 0x0a, 0x09, 0x74, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x16, 0x0a, 0x06, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x22, 0x2e, 0x0a, + 0x09, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, + 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x55, 0x53, 0x45, 0x52, 0x10, + 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x10, 0x02, 0x22, 0xd5, 0x03, + 0x0a, 0x07, 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x69, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x69, 0x12, 0x12, 0x0a, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, + 0x4c, 0x0a, 0x0e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, + 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, + 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x0d, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x2b, 0x0a, + 0x03, 0x74, 0x74, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x03, 0x74, 0x74, 0x6c, 0x12, 0x2a, 0x0a, 0x10, 0x53, 0x68, + 0x6f, 0x77, 0x57, 0x68, 0x69, 0x6c, 0x65, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x53, 0x68, 0x6f, 0x77, 0x57, 0x68, 0x69, 0x6c, 0x65, 0x50, + 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x2a, 0x0a, 0x10, 0x48, 0x69, 0x64, 0x65, 0x4f, 0x6e, + 0x63, 0x65, 0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x10, 0x48, 0x69, 0x64, 0x65, 0x4f, 0x6e, 0x63, 0x65, 0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, + 0x65, 0x64, 0x12, 0x3d, 0x0a, 0x09, 0x6c, 0x69, 0x6e, 0x6b, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x2e, 0x4c, + 0x69, 0x6e, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x52, 0x08, 0x6c, 0x69, 0x6e, 0x6b, 0x54, 0x79, 0x70, + 0x65, 0x12, 0x14, 0x0a, 0x05, 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x05, 0x72, 0x65, 0x61, 0x64, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x69, 0x63, 0x6f, 0x6e, 0x5f, + 0x75, 0x72, 0x69, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x69, 0x63, 0x6f, 0x6e, 0x55, + 0x72, 0x69, 0x22, 0x2f, 0x0a, 0x0d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, + 0x6d, 0x61, 0x74, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, + 0x12, 0x07, 0x0a, 0x03, 0x43, 0x53, 0x56, 0x10, 0x01, 0x12, 0x08, 0x0a, 0x04, 0x4a, 0x53, 0x4f, + 0x4e, 0x10, 0x02, 0x22, 0x30, 0x0a, 0x08, 0x4c, 0x69, 0x6e, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x12, + 0x0c, 0x0a, 0x08, 0x45, 0x58, 0x54, 0x45, 0x52, 0x4e, 0x41, 0x4c, 0x10, 0x00, 0x12, 0x0d, 0x0a, + 0x09, 0x44, 0x41, 0x53, 0x48, 0x42, 0x4f, 0x41, 0x52, 0x44, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, + 0x49, 0x44, 0x45, 0x10, 0x02, 0x22, 0x69, 0x0a, 0x0a, 0x4c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x74, + 0x65, 0x78, 0x74, 0x12, 0x31, 0x0a, 0x04, 0x70, 0x6f, 0x64, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x50, 0x6f, 0x64, 0x4c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, + 0x52, 0x04, 0x70, 0x6f, 0x64, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, + 0x79, 0x5f, 0x70, 0x6f, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0e, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x50, 0x6f, 0x64, 0x4e, 0x61, 0x6d, 0x65, + 0x22, 0x8b, 0x02, 0x0a, 0x0d, 0x50, 0x6f, 0x64, 0x4c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x65, + 0x78, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, + 0x12, 0x19, 0x0a, 0x08, 0x70, 0x6f, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x07, 0x70, 0x6f, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x40, 0x0a, 0x0a, 0x63, + 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, + 0x74, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x12, 0x34, 0x0a, + 0x16, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x14, 0x70, + 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4e, + 0x61, 0x6d, 0x65, 0x12, 0x49, 0x0a, 0x0f, 0x69, 0x6e, 0x69, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, 0x0e, + 0x69, 0x6e, 0x69, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x22, 0xaf, + 0x02, 0x0a, 0x10, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x74, + 0x65, 0x78, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x49, 0x0a, 0x07, 0x70, 0x72, + 0x6f, 0x63, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2e, 0x50, 0x72, + 0x6f, 0x63, 0x65, 0x73, 0x73, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, 0x07, 0x70, 0x72, + 0x6f, 0x63, 0x65, 0x73, 0x73, 0x1a, 0xa8, 0x01, 0x0a, 0x0e, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, + 0x73, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x4c, 0x0a, 0x14, 0x63, 0x6f, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x52, 0x12, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x53, 0x74, 0x61, + 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x48, 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x10, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x45, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, + 0x22, 0x5a, 0x0a, 0x14, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x4f, 0x66, 0x53, 0x65, 0x72, + 0x76, 0x69, 0x63, 0x65, 0x53, 0x70, 0x65, 0x63, 0x12, 0x42, 0x0a, 0x0f, 0x71, 0x75, 0x65, 0x75, + 0x65, 0x69, 0x6e, 0x67, 0x5f, 0x62, 0x75, 0x64, 0x67, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0e, 0x71, 0x75, + 0x65, 0x75, 0x65, 0x69, 0x6e, 0x67, 0x42, 0x75, 0x64, 0x67, 0x65, 0x74, 0x22, 0xd0, 0x01, 0x0a, + 0x10, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x4f, 0x66, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x12, 0x3b, 0x0a, 0x04, 0x74, 0x69, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x4f, 0x66, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x2e, 0x54, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x04, 0x74, 0x69, 0x65, 0x72, 0x12, 0x3a, + 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x51, 0x75, + 0x61, 0x6c, 0x69, 0x74, 0x79, 0x4f, 0x66, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x53, 0x70, + 0x65, 0x63, 0x48, 0x00, 0x52, 0x04, 0x73, 0x70, 0x65, 0x63, 0x22, 0x34, 0x0a, 0x04, 0x54, 0x69, + 0x65, 0x72, 0x12, 0x0d, 0x0a, 0x09, 0x55, 0x4e, 0x44, 0x45, 0x46, 0x49, 0x4e, 0x45, 0x44, 0x10, + 0x00, 0x12, 0x08, 0x0a, 0x04, 0x48, 0x49, 0x47, 0x48, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x4d, + 0x45, 0x44, 0x49, 0x55, 0x4d, 0x10, 0x02, 0x12, 0x07, 0x0a, 0x03, 0x4c, 0x4f, 0x57, 0x10, 0x03, + 0x42, 0x0d, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, + 0xb1, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x42, 0x0e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, + 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0xa2, 0x02, 0x03, 0x46, + 0x43, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, + 0x6f, 0x72, 0x65, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, + 0x43, 0x6f, 0x72, 0x65, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, + 0x6f, 0x72, 0x65, 0x4a, 0xaa, 0x2f, 0x0a, 0x07, 0x12, 0x05, 0x00, 0x00, 0xa5, 0x01, 0x01, 0x0a, + 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, + 0x02, 0x00, 0x17, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x28, 0x0a, 0x09, + 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x29, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, + 0x07, 0x00, 0x49, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x07, 0x00, 0x49, 0x0a, 0x3c, + 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0a, 0x00, 0x17, 0x01, 0x1a, 0x30, 0x20, 0x49, 0x6e, 0x64, + 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x76, 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x70, + 0x68, 0x61, 0x73, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x20, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x00, 0x01, 0x12, 0x03, 0x0a, 0x08, 0x19, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x00, 0x04, 0x00, + 0x12, 0x04, 0x0b, 0x02, 0x16, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x04, 0x00, 0x01, 0x12, + 0x03, 0x0b, 0x07, 0x0c, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, + 0x0c, 0x04, 0x12, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x0c, 0x04, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, + 0x0c, 0x10, 0x11, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0d, + 0x04, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0d, + 0x04, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x0d, + 0x0d, 0x0e, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x0e, 0x04, + 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x0e, 0x04, + 0x0b, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x0e, 0x0e, + 0x0f, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x0f, 0x04, 0x13, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x0f, 0x04, 0x0e, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x0f, 0x11, 0x12, + 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, 0x10, 0x04, 0x12, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x10, 0x04, 0x0d, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, 0x10, 0x10, 0x11, 0x0a, + 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x11, 0x04, 0x10, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x11, 0x04, 0x0b, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x05, 0x02, 0x12, 0x03, 0x11, 0x0e, 0x0f, 0x0a, 0x0d, + 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x06, 0x12, 0x03, 0x12, 0x04, 0x0f, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x12, 0x04, 0x0a, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x06, 0x02, 0x12, 0x03, 0x12, 0x0d, 0x0e, 0x0a, 0x0d, 0x0a, + 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x07, 0x12, 0x03, 0x13, 0x04, 0x10, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x00, 0x04, 0x00, 0x02, 0x07, 0x01, 0x12, 0x03, 0x13, 0x04, 0x0b, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x00, 0x04, 0x00, 0x02, 0x07, 0x02, 0x12, 0x03, 0x13, 0x0e, 0x0f, 0x0a, 0x0d, 0x0a, 0x06, + 0x04, 0x00, 0x04, 0x00, 0x02, 0x08, 0x12, 0x03, 0x14, 0x04, 0x12, 0x0a, 0x0e, 0x0a, 0x07, 0x04, + 0x00, 0x04, 0x00, 0x02, 0x08, 0x01, 0x12, 0x03, 0x14, 0x04, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, + 0x00, 0x04, 0x00, 0x02, 0x08, 0x02, 0x12, 0x03, 0x14, 0x10, 0x11, 0x0a, 0x0d, 0x0a, 0x06, 0x04, + 0x00, 0x04, 0x00, 0x02, 0x09, 0x12, 0x03, 0x15, 0x04, 0x11, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, + 0x04, 0x00, 0x02, 0x09, 0x01, 0x12, 0x03, 0x15, 0x04, 0x0c, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, + 0x04, 0x00, 0x02, 0x09, 0x02, 0x12, 0x03, 0x15, 0x0f, 0x10, 0x0a, 0x74, 0x0a, 0x02, 0x04, 0x01, + 0x12, 0x04, 0x1a, 0x00, 0x28, 0x01, 0x1a, 0x68, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, + 0x65, 0x73, 0x20, 0x76, 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, + 0x73, 0x20, 0x6f, 0x66, 0x20, 0x4e, 0x6f, 0x64, 0x65, 0x20, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x6e, + 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x73, + 0x70, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x73, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x1a, 0x08, 0x15, 0x0a, 0x0c, 0x0a, 0x04, + 0x04, 0x01, 0x04, 0x00, 0x12, 0x04, 0x1b, 0x02, 0x27, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x04, 0x00, 0x01, 0x12, 0x03, 0x1b, 0x07, 0x0c, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x04, 0x00, + 0x02, 0x00, 0x12, 0x03, 0x1c, 0x04, 0x12, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x1c, 0x04, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, + 0x00, 0x02, 0x12, 0x03, 0x1c, 0x10, 0x11, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x04, 0x00, 0x02, + 0x01, 0x12, 0x03, 0x1d, 0x04, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x1d, 0x04, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x01, + 0x02, 0x12, 0x03, 0x1d, 0x0d, 0x0e, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x04, 0x00, 0x02, 0x02, + 0x12, 0x03, 0x1e, 0x04, 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x1e, 0x04, 0x0b, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x02, 0x02, + 0x12, 0x03, 0x1e, 0x0e, 0x0f, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x04, 0x00, 0x02, 0x03, 0x12, + 0x03, 0x1f, 0x04, 0x12, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, + 0x03, 0x1f, 0x04, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x03, 0x02, 0x12, + 0x03, 0x1f, 0x10, 0x11, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, + 0x20, 0x04, 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, + 0x20, 0x04, 0x0b, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, + 0x20, 0x0e, 0x0f, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x21, + 0x04, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x21, + 0x04, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x05, 0x02, 0x12, 0x03, 0x21, + 0x0d, 0x0e, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x04, 0x00, 0x02, 0x06, 0x12, 0x03, 0x22, 0x04, + 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x22, 0x04, + 0x0b, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x06, 0x02, 0x12, 0x03, 0x22, 0x0e, + 0x0f, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x04, 0x00, 0x02, 0x07, 0x12, 0x03, 0x23, 0x04, 0x10, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x07, 0x01, 0x12, 0x03, 0x23, 0x04, 0x0b, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x07, 0x02, 0x12, 0x03, 0x23, 0x0e, 0x0f, + 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x04, 0x00, 0x02, 0x08, 0x12, 0x03, 0x24, 0x04, 0x12, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x08, 0x01, 0x12, 0x03, 0x24, 0x04, 0x0d, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x08, 0x02, 0x12, 0x03, 0x24, 0x10, 0x11, 0x0a, + 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x04, 0x00, 0x02, 0x09, 0x12, 0x03, 0x25, 0x04, 0x18, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x09, 0x01, 0x12, 0x03, 0x25, 0x04, 0x13, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x09, 0x02, 0x12, 0x03, 0x25, 0x16, 0x17, 0x0a, 0x0d, + 0x0a, 0x06, 0x04, 0x01, 0x04, 0x00, 0x02, 0x0a, 0x12, 0x03, 0x26, 0x04, 0x13, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x0a, 0x01, 0x12, 0x03, 0x26, 0x04, 0x0d, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x0a, 0x02, 0x12, 0x03, 0x26, 0x10, 0x12, 0x0a, 0xca, 0x01, + 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x2c, 0x00, 0x3a, 0x01, 0x1a, 0xbd, 0x01, 0x20, 0x50, 0x68, + 0x61, 0x73, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x70, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x67, 0x6f, 0x20, 0x74, 0x68, + 0x72, 0x6f, 0x75, 0x67, 0x68, 0x2e, 0x20, 0x4e, 0x6f, 0x74, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x70, + 0x68, 0x61, 0x73, 0x65, 0x73, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x61, 0x70, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x20, 0x74, 0x61, 0x73, + 0x6b, 0x2c, 0x0a, 0x20, 0x62, 0x75, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x6c, + 0x69, 0x73, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, + 0x72, 0x73, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x6b, + 0x6e, 0x6f, 0x77, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, + 0x65, 0x69, 0x72, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, + 0x01, 0x12, 0x03, 0x2c, 0x08, 0x15, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x02, 0x04, 0x00, 0x12, 0x04, + 0x2d, 0x02, 0x39, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x04, 0x00, 0x01, 0x12, 0x03, 0x2d, + 0x07, 0x0c, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x2e, 0x04, + 0x12, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2e, 0x04, + 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x2e, 0x10, + 0x11, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x2f, 0x04, 0x0f, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x2f, 0x04, 0x0a, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x2f, 0x0d, 0x0e, + 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x30, 0x04, 0x10, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x30, 0x04, 0x0b, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x30, 0x0e, 0x0f, 0x0a, + 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x31, 0x04, 0x12, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x31, 0x04, 0x0d, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x31, 0x10, 0x11, 0x0a, 0x0d, + 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, 0x32, 0x04, 0x10, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x32, 0x04, 0x0b, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, 0x32, 0x0e, 0x0f, 0x0a, 0x0d, 0x0a, + 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x33, 0x04, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x02, 0x04, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x33, 0x04, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x02, 0x04, 0x00, 0x02, 0x05, 0x02, 0x12, 0x03, 0x33, 0x0d, 0x0e, 0x0a, 0x75, 0x0a, 0x06, + 0x04, 0x02, 0x04, 0x00, 0x02, 0x06, 0x12, 0x03, 0x35, 0x04, 0x15, 0x1a, 0x66, 0x20, 0x54, 0x6f, + 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x63, 0x61, 0x73, 0x65, 0x73, 0x20, + 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6e, + 0x69, 0x74, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x69, 0x6e, 0x67, 0x2c, 0x20, 0x6c, 0x69, 0x6b, 0x65, + 0x3a, 0x20, 0x45, 0x72, 0x72, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x50, 0x75, 0x6c, 0x6c, 0x2c, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6e, + 0x67, 0x2c, 0x20, 0x50, 0x6f, 0x64, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x69, + 0x6e, 0x67, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, + 0x35, 0x04, 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x06, 0x02, 0x12, 0x03, + 0x35, 0x13, 0x14, 0x0a, 0x75, 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x07, 0x12, 0x03, 0x37, + 0x04, 0x1e, 0x1a, 0x66, 0x20, 0x54, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, + 0x63, 0x61, 0x73, 0x65, 0x73, 0x2c, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x75, 0x6e, 0x64, + 0x65, 0x72, 0x6c, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, + 0x65, 0x3a, 0x20, 0x42, 0x61, 0x63, 0x6b, 0x6f, 0x66, 0x66, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, + 0x2c, 0x20, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x71, 0x75, 0x6f, 0x74, 0x61, + 0x20, 0x65, 0x78, 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, + 0x04, 0x00, 0x02, 0x07, 0x01, 0x12, 0x03, 0x37, 0x04, 0x19, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, + 0x04, 0x00, 0x02, 0x07, 0x02, 0x12, 0x03, 0x37, 0x1c, 0x1d, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, + 0x04, 0x00, 0x02, 0x08, 0x12, 0x03, 0x38, 0x04, 0x19, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, + 0x00, 0x02, 0x08, 0x01, 0x12, 0x03, 0x38, 0x04, 0x14, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, + 0x00, 0x02, 0x08, 0x02, 0x12, 0x03, 0x38, 0x17, 0x18, 0x0a, 0x3e, 0x0a, 0x02, 0x04, 0x03, 0x12, + 0x04, 0x3d, 0x00, 0x50, 0x01, 0x1a, 0x32, 0x20, 0x52, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, + 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, + 0x12, 0x03, 0x3d, 0x08, 0x16, 0x0a, 0x55, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x40, + 0x02, 0x12, 0x1a, 0x48, 0x20, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, + 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x67, 0x72, 0x6f, 0x75, + 0x70, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x2e, 0x0a, 0x20, 0x4d, 0x6f, 0x72, 0x65, 0x20, 0x49, + 0x6e, 0x66, 0x6f, 0x3a, 0x20, 0x3c, 0x4c, 0x69, 0x6e, 0x6b, 0x3e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x00, 0x05, 0x12, 0x03, 0x40, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x40, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x40, 0x10, 0x11, 0x0a, 0x49, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, + 0x42, 0x02, 0x15, 0x1a, 0x3c, 0x20, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x64, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x2d, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, + 0x69, 0x6e, 0x67, 0x20, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x20, 0x74, 0x72, 0x61, 0x63, 0x65, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x05, 0x12, 0x03, 0x42, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, 0x42, 0x09, 0x10, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x42, 0x13, 0x14, 0x0a, 0x37, 0x0a, 0x04, 0x04, + 0x03, 0x02, 0x02, 0x12, 0x03, 0x44, 0x02, 0x17, 0x1a, 0x2a, 0x20, 0x46, 0x75, 0x6c, 0x6c, 0x20, + 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, + 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x76, 0x69, 0x61, 0x20, 0x61, 0x20, + 0x55, 0x52, 0x49, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x05, 0x12, 0x03, 0x44, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x01, 0x12, 0x03, 0x44, 0x09, 0x12, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x03, 0x12, 0x03, 0x44, 0x15, 0x16, 0x0a, 0x2a, + 0x0a, 0x04, 0x04, 0x03, 0x04, 0x00, 0x12, 0x04, 0x46, 0x02, 0x4a, 0x03, 0x1a, 0x1c, 0x20, 0x45, + 0x72, 0x72, 0x6f, 0x72, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x20, 0x53, 0x79, 0x73, 0x74, 0x65, + 0x6d, 0x20, 0x6f, 0x72, 0x20, 0x55, 0x73, 0x65, 0x72, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x04, 0x00, 0x01, 0x12, 0x03, 0x46, 0x07, 0x10, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x03, 0x04, 0x00, + 0x02, 0x00, 0x12, 0x03, 0x47, 0x04, 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x47, 0x04, 0x0b, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, + 0x00, 0x02, 0x12, 0x03, 0x47, 0x0e, 0x0f, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x03, 0x04, 0x00, 0x02, + 0x01, 0x12, 0x03, 0x48, 0x04, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x48, 0x04, 0x08, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x01, + 0x02, 0x12, 0x03, 0x48, 0x0b, 0x0c, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x03, 0x04, 0x00, 0x02, 0x02, + 0x12, 0x03, 0x49, 0x04, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x49, 0x04, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x02, 0x02, + 0x12, 0x03, 0x49, 0x0d, 0x0e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x03, 0x12, 0x03, 0x4b, + 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x06, 0x12, 0x03, 0x4b, 0x02, 0x0b, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x01, 0x12, 0x03, 0x4b, 0x0c, 0x10, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x03, 0x12, 0x03, 0x4b, 0x13, 0x14, 0x0a, 0x25, 0x0a, 0x04, + 0x04, 0x03, 0x02, 0x04, 0x12, 0x03, 0x4d, 0x02, 0x2a, 0x1a, 0x18, 0x20, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x72, 0x72, + 0x6f, 0x72, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x06, 0x12, 0x03, 0x4d, 0x02, + 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x01, 0x12, 0x03, 0x4d, 0x1c, 0x25, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x03, 0x12, 0x03, 0x4d, 0x28, 0x29, 0x0a, 0x2e, 0x0a, + 0x04, 0x04, 0x03, 0x02, 0x05, 0x12, 0x03, 0x4f, 0x02, 0x14, 0x1a, 0x21, 0x20, 0x57, 0x6f, 0x72, + 0x6b, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, + 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x05, 0x05, 0x12, 0x03, 0x4f, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x05, 0x01, 0x12, 0x03, 0x4f, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x05, 0x03, 0x12, 0x03, 0x4f, 0x12, 0x13, 0x0a, 0xa2, 0x01, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, + 0x54, 0x00, 0x6d, 0x01, 0x1a, 0x95, 0x01, 0x20, 0x4c, 0x6f, 0x67, 0x20, 0x69, 0x6e, 0x66, 0x6f, + 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x74, 0x61, 0x73, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x6c, 0x6f, 0x67, 0x20, 0x73, + 0x69, 0x6e, 0x6b, 0x0a, 0x20, 0x57, 0x68, 0x65, 0x6e, 0x20, 0x6f, 0x75, 0x72, 0x20, 0x6c, 0x6f, + 0x67, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x69, 0x73, 0x20, 0x66, 0x6c, 0x75, 0x73, 0x68, + 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x2c, 0x20, 0x77, 0x65, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x68, + 0x61, 0x76, 0x65, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x68, 0x65, 0x72, 0x65, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x6c, 0x6f, 0x67, 0x20, + 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x04, 0x01, 0x12, 0x03, 0x54, 0x08, 0x0f, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x04, 0x04, 0x00, + 0x12, 0x04, 0x55, 0x02, 0x59, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x04, 0x00, 0x01, 0x12, + 0x03, 0x55, 0x07, 0x14, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, + 0x56, 0x04, 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x56, 0x04, 0x0b, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, + 0x56, 0x0e, 0x0f, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x57, + 0x04, 0x0c, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x57, + 0x04, 0x07, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x57, + 0x0a, 0x0b, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x58, 0x04, + 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x58, 0x04, + 0x08, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x58, 0x0b, + 0x0c, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x04, 0x04, 0x01, 0x12, 0x04, 0x5b, 0x02, 0x62, 0x03, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x04, 0x01, 0x01, 0x12, 0x03, 0x5b, 0x07, 0x0f, 0x0a, 0x68, 0x0a, + 0x06, 0x04, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x5d, 0x04, 0x11, 0x1a, 0x59, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x73, 0x6b, + 0x20, 0x6c, 0x6f, 0x67, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, + 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x77, 0x73, 0x20, 0x63, 0x6c, 0x6f, 0x75, 0x64, + 0x77, 0x61, 0x74, 0x63, 0x68, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x2c, 0x20, 0x67, 0x63, 0x70, 0x20, + 0x73, 0x74, 0x61, 0x63, 0x6b, 0x64, 0x72, 0x69, 0x76, 0x65, 0x72, 0x20, 0x6c, 0x6f, 0x67, 0x73, + 0x2c, 0x20, 0x65, 0x74, 0x63, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x04, 0x01, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x5d, 0x04, 0x0c, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x04, 0x01, 0x02, + 0x00, 0x02, 0x12, 0x03, 0x5d, 0x0f, 0x10, 0x0a, 0x3b, 0x0a, 0x06, 0x04, 0x04, 0x04, 0x01, 0x02, + 0x01, 0x12, 0x03, 0x5f, 0x04, 0x12, 0x1a, 0x2c, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x6e, + 0x6b, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x70, 0x61, 0x72, 0x6b, 0x20, 0x55, 0x49, 0x2c, 0x20, + 0x72, 0x61, 0x79, 0x20, 0x64, 0x61, 0x73, 0x68, 0x62, 0x6f, 0x61, 0x72, 0x64, 0x2c, 0x20, 0x65, + 0x74, 0x63, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x5f, 0x04, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x04, 0x01, 0x02, 0x01, 0x02, 0x12, + 0x03, 0x5f, 0x10, 0x11, 0x0a, 0x33, 0x0a, 0x06, 0x04, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, + 0x61, 0x04, 0x0c, 0x1a, 0x24, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x76, 0x73, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x6f, 0x72, 0x20, 0x6f, 0x74, 0x68, + 0x65, 0x72, 0x20, 0x49, 0x44, 0x45, 0x73, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x04, + 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x61, 0x04, 0x07, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x04, + 0x01, 0x02, 0x02, 0x02, 0x12, 0x03, 0x61, 0x0a, 0x0b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, + 0x00, 0x12, 0x03, 0x64, 0x02, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x05, 0x12, + 0x03, 0x64, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x64, + 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x64, 0x0f, 0x10, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x65, 0x02, 0x12, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x01, 0x05, 0x12, 0x03, 0x65, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x65, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x01, 0x03, 0x12, 0x03, 0x65, 0x10, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x02, 0x12, + 0x03, 0x66, 0x02, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x06, 0x12, 0x03, 0x66, + 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x66, 0x10, 0x1e, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, 0x66, 0x21, 0x22, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x04, 0x02, 0x03, 0x12, 0x03, 0x67, 0x02, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x03, 0x06, 0x12, 0x03, 0x67, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x03, 0x01, 0x12, 0x03, 0x67, 0x1b, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x03, + 0x12, 0x03, 0x67, 0x21, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x04, 0x12, 0x03, 0x68, + 0x02, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x05, 0x12, 0x03, 0x68, 0x02, 0x06, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x01, 0x12, 0x03, 0x68, 0x07, 0x17, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x03, 0x12, 0x03, 0x68, 0x1a, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x04, 0x02, 0x05, 0x12, 0x03, 0x69, 0x02, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x05, 0x05, 0x12, 0x03, 0x69, 0x02, 0x06, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x05, 0x01, + 0x12, 0x03, 0x69, 0x07, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x05, 0x03, 0x12, 0x03, + 0x69, 0x1a, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x06, 0x12, 0x03, 0x6a, 0x02, 0x19, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x06, 0x06, 0x12, 0x03, 0x6a, 0x02, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x06, 0x01, 0x12, 0x03, 0x6a, 0x0b, 0x14, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x06, 0x03, 0x12, 0x03, 0x6a, 0x17, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, + 0x02, 0x07, 0x12, 0x03, 0x6b, 0x02, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x07, 0x05, + 0x12, 0x03, 0x6b, 0x02, 0x06, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x07, 0x01, 0x12, 0x03, + 0x6b, 0x07, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x07, 0x03, 0x12, 0x03, 0x6b, 0x0f, + 0x10, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x08, 0x12, 0x03, 0x6c, 0x02, 0x16, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x08, 0x05, 0x12, 0x03, 0x6c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x08, 0x01, 0x12, 0x03, 0x6c, 0x09, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x08, 0x03, 0x12, 0x03, 0x6c, 0x14, 0x15, 0x0a, 0x53, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, + 0x70, 0x00, 0x73, 0x01, 0x1a, 0x47, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x79, 0x20, 0x6c, 0x6f, + 0x67, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x73, 0x20, 0x62, 0x79, 0x20, 0x61, + 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x70, 0x6f, 0x64, 0x73, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x70, 0x08, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, + 0x00, 0x12, 0x03, 0x71, 0x02, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x04, 0x12, + 0x03, 0x71, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x06, 0x12, 0x03, 0x71, + 0x0b, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x71, 0x19, 0x1d, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x71, 0x20, 0x21, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x03, 0x72, 0x02, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x01, 0x05, 0x12, 0x03, 0x72, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x72, 0x09, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x72, 0x1c, 0x1d, 0x0a, 0x53, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x05, 0x76, 0x00, 0x80, + 0x01, 0x01, 0x1a, 0x46, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x79, 0x20, 0x6c, 0x6f, 0x67, 0x73, + 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x73, 0x20, 0x62, 0x79, 0x20, 0x61, 0x20, 0x73, + 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x70, 0x6f, 0x64, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, + 0x01, 0x12, 0x03, 0x76, 0x08, 0x15, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x03, + 0x77, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x05, 0x12, 0x03, 0x77, 0x02, + 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x03, 0x77, 0x09, 0x12, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x03, 0x77, 0x15, 0x16, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x06, 0x02, 0x01, 0x12, 0x03, 0x79, 0x02, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x01, 0x05, 0x12, 0x03, 0x79, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x79, 0x09, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x79, 0x14, 0x15, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x02, 0x12, 0x03, 0x7b, 0x02, + 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x04, 0x12, 0x03, 0x7b, 0x02, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x06, 0x12, 0x03, 0x7b, 0x0b, 0x1b, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x02, 0x01, 0x12, 0x03, 0x7b, 0x1c, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x02, 0x03, 0x12, 0x03, 0x7b, 0x29, 0x2a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, + 0x03, 0x12, 0x03, 0x7d, 0x02, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x03, 0x05, 0x12, + 0x03, 0x7d, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x03, 0x01, 0x12, 0x03, 0x7d, + 0x09, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x03, 0x03, 0x12, 0x03, 0x7d, 0x22, 0x23, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x04, 0x12, 0x03, 0x7f, 0x02, 0x30, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x04, 0x04, 0x12, 0x03, 0x7f, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x04, 0x06, 0x12, 0x03, 0x7f, 0x0b, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x04, 0x01, 0x12, 0x03, 0x7f, 0x1c, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x03, + 0x12, 0x03, 0x7f, 0x2e, 0x2f, 0x0a, 0x5a, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x06, 0x83, 0x01, 0x00, + 0x8d, 0x01, 0x01, 0x1a, 0x4c, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x6d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x79, 0x20, 0x6c, 0x6f, 0x67, + 0x73, 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x73, 0x20, 0x62, 0x79, 0x20, 0x61, 0x20, + 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x04, 0x83, 0x01, 0x08, 0x18, 0x0a, 0x0c, + 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x04, 0x84, 0x01, 0x02, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x00, 0x05, 0x12, 0x04, 0x84, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x00, 0x01, 0x12, 0x04, 0x84, 0x01, 0x09, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x00, 0x03, 0x12, 0x04, 0x84, 0x01, 0x1a, 0x1b, 0x0a, 0x87, 0x01, 0x0a, 0x04, 0x04, 0x07, + 0x03, 0x00, 0x12, 0x06, 0x87, 0x01, 0x02, 0x8a, 0x01, 0x03, 0x1a, 0x77, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x72, + 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x79, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, + 0x73, 0x20, 0x62, 0x79, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x6c, 0x69, + 0x67, 0x68, 0x74, 0x2d, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, + 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x61, 0x73, 0x20, 0x72, 0x75, 0x6e, 0x20, + 0x69, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x65, 0x72, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x03, 0x00, 0x01, 0x12, 0x04, 0x87, 0x01, + 0x0a, 0x18, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x07, 0x03, 0x00, 0x02, 0x00, 0x12, 0x04, 0x88, 0x01, + 0x04, 0x37, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x07, 0x03, 0x00, 0x02, 0x00, 0x06, 0x12, 0x04, 0x88, + 0x01, 0x04, 0x1d, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x07, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, + 0x88, 0x01, 0x1e, 0x32, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x07, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, + 0x04, 0x88, 0x01, 0x35, 0x36, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x07, 0x03, 0x00, 0x02, 0x01, 0x12, + 0x04, 0x89, 0x01, 0x04, 0x35, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x07, 0x03, 0x00, 0x02, 0x01, 0x06, + 0x12, 0x04, 0x89, 0x01, 0x04, 0x1d, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x07, 0x03, 0x00, 0x02, 0x01, + 0x01, 0x12, 0x04, 0x89, 0x01, 0x1e, 0x30, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x07, 0x03, 0x00, 0x02, + 0x01, 0x03, 0x12, 0x04, 0x89, 0x01, 0x33, 0x34, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x01, + 0x12, 0x04, 0x8c, 0x01, 0x02, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x06, 0x12, + 0x04, 0x8c, 0x01, 0x02, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x01, 0x12, 0x04, + 0x8c, 0x01, 0x11, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, 0x04, 0x8c, + 0x01, 0x1b, 0x1c, 0x0a, 0x44, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x06, 0x90, 0x01, 0x00, 0x95, 0x01, + 0x01, 0x1a, 0x36, 0x20, 0x52, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x63, + 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6e, 0x2d, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x61, 0x74, 0x74, + 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x08, 0x01, + 0x12, 0x04, 0x90, 0x01, 0x08, 0x1c, 0x0a, 0x4c, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x00, 0x12, 0x04, + 0x92, 0x01, 0x02, 0x2f, 0x1a, 0x3e, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, + 0x20, 0x68, 0x6f, 0x77, 0x20, 0x6d, 0x75, 0x63, 0x68, 0x20, 0x71, 0x75, 0x65, 0x75, 0x65, 0x69, + 0x6e, 0x67, 0x20, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x74, 0x6f, 0x6c, 0x65, 0x72, 0x61, + 0x74, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x06, 0x12, 0x04, 0x92, + 0x01, 0x02, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x04, 0x92, 0x01, + 0x1b, 0x2a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x04, 0x92, 0x01, 0x2d, + 0x2e, 0x0a, 0x37, 0x0a, 0x02, 0x04, 0x09, 0x12, 0x06, 0x98, 0x01, 0x00, 0xa5, 0x01, 0x01, 0x1a, + 0x29, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x09, + 0x01, 0x12, 0x04, 0x98, 0x01, 0x08, 0x18, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x09, 0x04, 0x00, 0x12, + 0x06, 0x99, 0x01, 0x02, 0x9f, 0x01, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x04, 0x00, 0x01, + 0x12, 0x04, 0x99, 0x01, 0x07, 0x0b, 0x0a, 0x3b, 0x0a, 0x06, 0x04, 0x09, 0x04, 0x00, 0x02, 0x00, + 0x12, 0x04, 0x9b, 0x01, 0x04, 0x12, 0x1a, 0x2b, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, + 0x3a, 0x20, 0x6e, 0x6f, 0x20, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x20, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x64, 0x2e, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, + 0x9b, 0x01, 0x04, 0x0d, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, + 0x04, 0x9b, 0x01, 0x10, 0x11, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x09, 0x04, 0x00, 0x02, 0x01, 0x12, + 0x04, 0x9c, 0x01, 0x04, 0x0d, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x04, 0x00, 0x02, 0x01, 0x01, + 0x12, 0x04, 0x9c, 0x01, 0x04, 0x08, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x04, 0x00, 0x02, 0x01, + 0x02, 0x12, 0x04, 0x9c, 0x01, 0x0b, 0x0c, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x09, 0x04, 0x00, 0x02, + 0x02, 0x12, 0x04, 0x9d, 0x01, 0x04, 0x0f, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x04, 0x00, 0x02, + 0x02, 0x01, 0x12, 0x04, 0x9d, 0x01, 0x04, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x04, 0x00, + 0x02, 0x02, 0x02, 0x12, 0x04, 0x9d, 0x01, 0x0d, 0x0e, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x09, 0x04, + 0x00, 0x02, 0x03, 0x12, 0x04, 0x9e, 0x01, 0x04, 0x0c, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x04, + 0x00, 0x02, 0x03, 0x01, 0x12, 0x04, 0x9e, 0x01, 0x04, 0x07, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, + 0x04, 0x00, 0x02, 0x03, 0x02, 0x12, 0x04, 0x9e, 0x01, 0x0a, 0x0b, 0x0a, 0x0e, 0x0a, 0x04, 0x04, + 0x09, 0x08, 0x00, 0x12, 0x06, 0xa1, 0x01, 0x02, 0xa4, 0x01, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x09, 0x08, 0x00, 0x01, 0x12, 0x04, 0xa1, 0x01, 0x08, 0x13, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x09, + 0x02, 0x00, 0x12, 0x04, 0xa2, 0x01, 0x04, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, + 0x06, 0x12, 0x04, 0xa2, 0x01, 0x04, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, + 0x12, 0x04, 0xa2, 0x01, 0x09, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, + 0x04, 0xa2, 0x01, 0x10, 0x11, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x01, 0x12, 0x04, 0xa3, + 0x01, 0x04, 0x22, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x06, 0x12, 0x04, 0xa3, 0x01, + 0x04, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x01, 0x12, 0x04, 0xa3, 0x01, 0x19, + 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x03, 0x12, 0x04, 0xa3, 0x01, 0x20, 0x21, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xd5, 0x1e, 0x0a, 0x1f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x22, 0xc1, 0x01, 0x0a, + 0x0a, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x41, 0x0a, 0x0d, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, + 0x52, 0x0c, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x18, + 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x6f, 0x6d, 0x61, + 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, + 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x10, + 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6f, 0x72, 0x67, + 0x22, 0x75, 0x0a, 0x1b, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, + 0x18, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x6f, 0x6d, + 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, + 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x22, 0x82, 0x01, 0x0a, 0x17, 0x4e, 0x6f, 0x64, 0x65, + 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x4e, 0x0a, 0x0c, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, + 0x0b, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0xc8, 0x01, 0x0a, + 0x17, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x33, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, + 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x12, 0x53, 0x0a, + 0x11, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x52, 0x0f, 0x6e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x74, 0x72, 0x79, 0x5f, 0x61, 0x74, 0x74, 0x65, + 0x6d, 0x70, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x72, 0x65, 0x74, 0x72, 0x79, + 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x22, 0x7f, 0x0a, 0x10, 0x53, 0x69, 0x67, 0x6e, 0x61, + 0x6c, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x1b, 0x0a, 0x09, 0x73, + 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x4e, 0x0a, 0x0c, 0x65, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x0b, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x2a, 0x55, 0x0a, 0x0c, 0x52, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0f, 0x0a, 0x0b, 0x55, 0x4e, 0x53, 0x50, + 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x54, 0x41, 0x53, + 0x4b, 0x10, 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x57, 0x4f, 0x52, 0x4b, 0x46, 0x4c, 0x4f, 0x57, 0x10, + 0x02, 0x12, 0x0f, 0x0a, 0x0b, 0x4c, 0x41, 0x55, 0x4e, 0x43, 0x48, 0x5f, 0x50, 0x4c, 0x41, 0x4e, + 0x10, 0x03, 0x12, 0x0b, 0x0a, 0x07, 0x44, 0x41, 0x54, 0x41, 0x53, 0x45, 0x54, 0x10, 0x04, 0x42, + 0xb2, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x42, 0x0f, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0xa2, 0x02, 0x03, + 0x46, 0x43, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x43, 0x6f, 0x72, 0x65, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x43, 0x6f, 0x72, 0x65, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, + 0x43, 0x6f, 0x72, 0x65, 0x4a, 0x81, 0x16, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x4f, 0x01, 0x0a, + 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, + 0x02, 0x00, 0x17, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x04, 0x00, 0x49, 0x0a, 0x09, 0x0a, + 0x02, 0x08, 0x0b, 0x12, 0x03, 0x04, 0x00, 0x49, 0x0a, 0x35, 0x0a, 0x02, 0x05, 0x00, 0x12, 0x04, + 0x07, 0x00, 0x10, 0x01, 0x1a, 0x29, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, + 0x20, 0x61, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x2e, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, 0x03, 0x07, 0x05, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x05, + 0x00, 0x02, 0x00, 0x12, 0x03, 0x08, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x08, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x02, 0x12, + 0x03, 0x08, 0x10, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x01, 0x12, 0x03, 0x09, 0x02, + 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x09, 0x02, 0x06, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x09, 0x09, 0x0a, 0x0a, 0x0b, 0x0a, + 0x04, 0x05, 0x00, 0x02, 0x02, 0x12, 0x03, 0x0a, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x0a, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, + 0x02, 0x12, 0x03, 0x0a, 0x0d, 0x0e, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x03, 0x12, 0x03, + 0x0b, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x0b, 0x02, + 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x0b, 0x10, 0x11, 0x0a, + 0xf3, 0x02, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x04, 0x12, 0x03, 0x0f, 0x02, 0x0e, 0x1a, 0xe5, 0x02, + 0x20, 0x41, 0x20, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, + 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, + 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x20, 0x44, 0x61, 0x74, 0x61, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x2e, 0x20, 0x41, 0x20, + 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x20, + 0x61, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x65, 0x6e, 0x74, 0x69, + 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, + 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x6d, + 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x76, 0x69, 0x64, 0x75, + 0x61, 0x6c, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2e, 0x0a, 0x20, 0x45, 0x76, 0x65, + 0x6e, 0x74, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x43, 0x61, 0x74, 0x61, + 0x6c, 0x6f, 0x67, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x20, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x65, 0x64, 0x20, 0x73, 0x69, + 0x6d, 0x69, 0x6c, 0x61, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x20, 0x4f, + 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x44, 0x61, 0x74, 0x61, + 0x73, 0x65, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x20, 0x6d, 0x61, 0x6b, + 0x65, 0x73, 0x20, 0x69, 0x74, 0x20, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x55, 0x49, 0x20, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x43, + 0x4c, 0x49, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x63, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x0a, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x73, + 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72, 0x20, 0x6d, 0x61, 0x6e, 0x6e, 0x65, 0x72, 0x20, 0x74, 0x6f, + 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x20, 0x6f, 0x62, 0x6a, + 0x65, 0x63, 0x74, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, + 0x0f, 0x02, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, 0x0f, 0x0c, + 0x0d, 0x0a, 0x50, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x13, 0x00, 0x26, 0x01, 0x1a, 0x44, 0x20, + 0x45, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x75, 0x6e, 0x69, + 0x71, 0x75, 0x65, 0x6c, 0x79, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x61, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x13, 0x08, 0x12, 0x0a, + 0x5c, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x15, 0x02, 0x26, 0x1a, 0x4f, 0x20, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x63, 0x6f, 0x72, + 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x73, 0x20, 0x74, 0x6f, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x15, 0x02, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x15, 0x14, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x15, 0x24, 0x25, 0x0a, 0x3b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, + 0x03, 0x18, 0x02, 0x15, 0x1a, 0x2e, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, + 0x74, 0x6f, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x18, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x18, 0x09, 0x10, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x18, 0x13, 0x14, 0x0a, 0x7d, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x1c, 0x02, 0x14, 0x1a, 0x70, 0x20, 0x4e, 0x61, + 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x62, 0x65, + 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x2e, 0x0a, 0x20, 0x41, 0x20, 0x64, 0x6f, 0x6d, + 0x61, 0x69, 0x6e, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, + 0x64, 0x65, 0x72, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x73, 0x75, 0x62, 0x73, 0x65, + 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x63, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x1c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x1c, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x02, 0x03, 0x12, 0x03, 0x1c, 0x12, 0x13, 0x0a, 0x34, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x03, 0x12, + 0x03, 0x1f, 0x02, 0x12, 0x1a, 0x27, 0x20, 0x55, 0x73, 0x65, 0x72, 0x20, 0x70, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x03, 0x05, 0x12, 0x03, 0x1f, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x1f, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x03, 0x03, 0x12, 0x03, 0x1f, 0x10, 0x11, 0x0a, 0x30, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x04, 0x12, + 0x03, 0x22, 0x02, 0x15, 0x1a, 0x23, 0x20, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x04, 0x05, 0x12, 0x03, 0x22, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x01, + 0x12, 0x03, 0x22, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, + 0x22, 0x13, 0x14, 0x0a, 0x39, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x25, 0x02, 0x11, + 0x1a, 0x2c, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2c, 0x20, 0x6f, 0x72, 0x67, + 0x20, 0x6b, 0x65, 0x79, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x05, 0x12, 0x03, 0x25, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x25, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x05, 0x03, 0x12, 0x03, 0x25, 0x0f, 0x10, 0x0a, 0x59, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, + 0x29, 0x00, 0x36, 0x01, 0x1a, 0x4d, 0x20, 0x45, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x6c, 0x79, 0x20, 0x69, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x61, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x20, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x29, 0x08, 0x23, 0x0a, + 0x3b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x2b, 0x02, 0x15, 0x1a, 0x2e, 0x20, 0x4e, + 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, + 0x62, 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x2b, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x2b, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x2b, 0x13, 0x14, 0x0a, 0x7d, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, + 0x2f, 0x02, 0x14, 0x1a, 0x70, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, + 0x2e, 0x0a, 0x20, 0x41, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x63, 0x61, 0x6e, 0x20, + 0x62, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20, 0x61, 0x73, + 0x20, 0x61, 0x20, 0x73, 0x75, 0x62, 0x73, 0x65, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, + 0x20, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x70, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, + 0x2f, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x2f, 0x09, + 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x2f, 0x12, 0x13, 0x0a, + 0x3e, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x32, 0x02, 0x12, 0x1a, 0x31, 0x20, 0x55, + 0x73, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x70, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x05, 0x12, 0x03, 0x32, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x32, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x32, 0x10, 0x11, 0x0a, 0x39, 0x0a, 0x04, 0x04, 0x01, 0x02, + 0x03, 0x12, 0x03, 0x35, 0x02, 0x11, 0x1a, 0x2c, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x2c, 0x20, 0x6f, 0x72, 0x67, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, + 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x05, 0x12, 0x03, 0x35, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x01, 0x12, 0x03, 0x35, 0x09, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x03, 0x12, 0x03, 0x35, 0x0f, 0x10, 0x0a, 0x52, + 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x39, 0x00, 0x3d, 0x01, 0x1a, 0x46, 0x20, 0x45, 0x6e, 0x63, + 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x79, 0x20, 0x61, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, + 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x39, 0x08, 0x1f, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x3a, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, 0x3a, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x3a, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x3a, 0x13, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x3c, + 0x02, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, 0x03, 0x3c, 0x02, 0x1d, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x3c, 0x1e, 0x2a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x3c, 0x2d, 0x2e, 0x0a, 0x52, 0x0a, 0x02, + 0x04, 0x03, 0x12, 0x04, 0x40, 0x00, 0x46, 0x01, 0x1a, 0x46, 0x20, 0x45, 0x6e, 0x63, 0x61, 0x70, + 0x73, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x79, + 0x20, 0x61, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x40, 0x08, 0x1f, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x41, 0x02, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x41, 0x02, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x41, 0x12, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x41, 0x1c, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, 0x43, 0x02, 0x35, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x06, 0x12, 0x03, 0x43, 0x02, 0x1e, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, 0x43, 0x1f, 0x30, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x43, 0x33, 0x34, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, + 0x02, 0x02, 0x12, 0x03, 0x45, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x05, + 0x12, 0x03, 0x45, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x45, 0x09, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x03, 0x12, 0x03, 0x45, 0x19, + 0x1a, 0x0a, 0x45, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x49, 0x00, 0x4f, 0x01, 0x1a, 0x39, 0x20, + 0x45, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, + 0x75, 0x65, 0x6c, 0x79, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x79, 0x20, 0x61, 0x20, + 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, + 0x03, 0x49, 0x08, 0x18, 0x0a, 0x2e, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x4b, 0x02, + 0x17, 0x1a, 0x21, 0x20, 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x73, 0x69, 0x67, 0x6e, + 0x61, 0x6c, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x05, 0x12, 0x03, 0x4b, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x4b, 0x09, 0x12, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x4b, 0x15, 0x16, 0x0a, 0x4e, + 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x4e, 0x02, 0x2f, 0x1a, 0x41, 0x20, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x20, 0x65, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, + 0x6c, 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x06, 0x12, 0x03, 0x4e, 0x02, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x4e, 0x1e, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x4e, 0x2d, 0x2e, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x0a, 0xc7, 0x51, 0x0a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, + 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, + 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x1a, + 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa3, 0x02, + 0x0a, 0x0a, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x54, 0x79, 0x70, 0x65, 0x12, 0x41, 0x0a, 0x07, + 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, + 0x63, 0x68, 0x65, 0x6d, 0x61, 0x54, 0x79, 0x70, 0x65, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, + 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x1a, + 0xd1, 0x01, 0x0a, 0x0c, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, + 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x4c, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x38, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x54, 0x79, 0x70, 0x65, 0x2e, 0x53, + 0x63, 0x68, 0x65, 0x6d, 0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x2e, 0x53, 0x63, 0x68, 0x65, + 0x6d, 0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, + 0x70, 0x65, 0x22, 0x5f, 0x0a, 0x10, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x43, 0x6f, 0x6c, 0x75, + 0x6d, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, + 0x52, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x46, 0x4c, 0x4f, 0x41, 0x54, 0x10, 0x01, 0x12, 0x0a, + 0x0a, 0x06, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, 0x42, 0x4f, + 0x4f, 0x4c, 0x45, 0x41, 0x4e, 0x10, 0x03, 0x12, 0x0c, 0x0a, 0x08, 0x44, 0x41, 0x54, 0x45, 0x54, + 0x49, 0x4d, 0x45, 0x10, 0x04, 0x12, 0x0c, 0x0a, 0x08, 0x44, 0x55, 0x52, 0x41, 0x54, 0x49, 0x4f, + 0x4e, 0x10, 0x05, 0x22, 0xc9, 0x02, 0x0a, 0x15, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, + 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x4d, 0x0a, + 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x33, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, + 0x74, 0x54, 0x79, 0x70, 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x43, 0x6f, 0x6c, + 0x75, 0x6d, 0x6e, 0x52, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x16, 0x0a, 0x06, + 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, 0x6f, + 0x72, 0x6d, 0x61, 0x74, 0x12, 0x30, 0x0a, 0x14, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, + 0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x12, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x53, 0x63, 0x68, 0x65, + 0x6d, 0x61, 0x54, 0x79, 0x70, 0x65, 0x12, 0x32, 0x0a, 0x15, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, + 0x61, 0x6c, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x13, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x53, + 0x63, 0x68, 0x65, 0x6d, 0x61, 0x42, 0x79, 0x74, 0x65, 0x73, 0x1a, 0x63, 0x0a, 0x0d, 0x44, 0x61, + 0x74, 0x61, 0x73, 0x65, 0x74, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, + 0x3e, 0x0a, 0x0c, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, + 0x70, 0x65, 0x52, 0x0b, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x22, + 0xa8, 0x01, 0x0a, 0x08, 0x42, 0x6c, 0x6f, 0x62, 0x54, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, + 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, 0x6f, + 0x72, 0x6d, 0x61, 0x74, 0x12, 0x53, 0x0a, 0x0e, 0x64, 0x69, 0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f, + 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x42, 0x6c, + 0x6f, 0x62, 0x54, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x6c, 0x6f, 0x62, 0x44, 0x69, 0x6d, 0x65, 0x6e, + 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x0e, 0x64, 0x69, 0x6d, 0x65, 0x6e, + 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x22, 0x2f, 0x0a, 0x12, 0x42, 0x6c, 0x6f, + 0x62, 0x44, 0x69, 0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x12, + 0x0a, 0x0a, 0x06, 0x53, 0x49, 0x4e, 0x47, 0x4c, 0x45, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x4d, + 0x55, 0x4c, 0x54, 0x49, 0x50, 0x41, 0x52, 0x54, 0x10, 0x01, 0x22, 0x22, 0x0a, 0x08, 0x45, 0x6e, + 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x22, 0x44, + 0x0a, 0x09, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x37, 0x0a, 0x08, 0x76, + 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, + 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x52, 0x08, 0x76, 0x61, 0x72, 0x69, + 0x61, 0x6e, 0x74, 0x73, 0x22, 0xd9, 0x01, 0x0a, 0x0d, 0x54, 0x79, 0x70, 0x65, 0x53, 0x74, 0x72, + 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x74, 0x61, 0x67, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x74, 0x61, 0x67, 0x12, 0x57, 0x0a, 0x0e, 0x64, 0x61, 0x74, 0x61, + 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x30, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2e, + 0x44, 0x61, 0x74, 0x61, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x79, 0x70, 0x65, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x0d, 0x64, 0x61, 0x74, 0x61, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x79, 0x70, + 0x65, 0x1a, 0x5d, 0x0a, 0x12, 0x44, 0x61, 0x74, 0x61, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x79, + 0x70, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x31, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, + 0x6c, 0x54, 0x79, 0x70, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, + 0x22, 0x4b, 0x0a, 0x0e, 0x54, 0x79, 0x70, 0x65, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x39, 0x0a, 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, + 0x52, 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xc6, 0x05, + 0x0a, 0x0b, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x12, 0x34, 0x0a, + 0x06, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, + 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x06, 0x73, 0x69, 0x6d, + 0x70, 0x6c, 0x65, 0x12, 0x34, 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x54, 0x79, 0x70, 0x65, 0x48, + 0x00, 0x52, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x46, 0x0a, 0x0f, 0x63, 0x6f, 0x6c, + 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x48, + 0x00, 0x52, 0x0e, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, + 0x65, 0x12, 0x43, 0x0a, 0x0e, 0x6d, 0x61, 0x70, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, + 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x6d, 0x61, 0x70, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2e, 0x0a, 0x04, 0x62, 0x6c, 0x6f, 0x62, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x42, 0x6c, 0x6f, 0x62, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, + 0x52, 0x04, 0x62, 0x6c, 0x6f, 0x62, 0x12, 0x37, 0x0a, 0x09, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x54, + 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x08, 0x65, 0x6e, 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x12, + 0x5f, 0x0a, 0x17, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x5f, 0x64, 0x61, + 0x74, 0x61, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, + 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x15, 0x73, 0x74, 0x72, 0x75, 0x63, + 0x74, 0x75, 0x72, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, + 0x12, 0x3a, 0x0a, 0x0a, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0a, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x48, + 0x00, 0x52, 0x09, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x33, 0x0a, 0x08, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x12, 0x3e, 0x0a, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, + 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x41, 0x6e, 0x6e, 0x6f, 0x74, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x3b, 0x0a, 0x09, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x18, 0x0b, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, + 0x75, 0x72, 0x65, 0x52, 0x09, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x42, 0x06, + 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x7b, 0x0a, 0x0f, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, + 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, + 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, + 0x49, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x76, 0x61, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x03, 0x76, 0x61, 0x72, 0x12, 0x3d, 0x0a, 0x09, 0x61, 0x74, 0x74, 0x72, 0x5f, 0x70, 0x61, 0x74, + 0x68, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x6d, 0x69, 0x73, 0x65, + 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52, 0x08, 0x61, 0x74, 0x74, 0x72, 0x50, + 0x61, 0x74, 0x68, 0x22, 0x5f, 0x0a, 0x10, 0x50, 0x72, 0x6f, 0x6d, 0x69, 0x73, 0x65, 0x41, 0x74, + 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, + 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, + 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1d, 0x0a, 0x09, + 0x69, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x48, + 0x00, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x07, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x22, 0x47, 0x0a, 0x05, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x24, 0x0a, + 0x0e, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x4e, 0x6f, 0x64, + 0x65, 0x49, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2a, 0x86, 0x01, + 0x0a, 0x0a, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x08, 0x0a, 0x04, + 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, + 0x52, 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05, 0x46, 0x4c, 0x4f, 0x41, 0x54, 0x10, 0x02, 0x12, 0x0a, + 0x0a, 0x06, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x03, 0x12, 0x0b, 0x0a, 0x07, 0x42, 0x4f, + 0x4f, 0x4c, 0x45, 0x41, 0x4e, 0x10, 0x04, 0x12, 0x0c, 0x0a, 0x08, 0x44, 0x41, 0x54, 0x45, 0x54, + 0x49, 0x4d, 0x45, 0x10, 0x05, 0x12, 0x0c, 0x0a, 0x08, 0x44, 0x55, 0x52, 0x41, 0x54, 0x49, 0x4f, + 0x4e, 0x10, 0x06, 0x12, 0x0a, 0x0a, 0x06, 0x42, 0x49, 0x4e, 0x41, 0x52, 0x59, 0x10, 0x07, 0x12, + 0x09, 0x0a, 0x05, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x08, 0x12, 0x0a, 0x0a, 0x06, 0x53, 0x54, + 0x52, 0x55, 0x43, 0x54, 0x10, 0x09, 0x42, 0xad, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x42, 0x0a, 0x54, + 0x79, 0x70, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, + 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, + 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, + 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0xa2, + 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x4a, 0x99, 0x3d, 0x0a, 0x07, 0x12, 0x05, 0x00, 0x00, 0xcf, + 0x01, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, + 0x02, 0x12, 0x03, 0x02, 0x00, 0x17, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, + 0x26, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x06, 0x00, 0x49, 0x0a, 0x09, 0x0a, 0x02, 0x08, + 0x0b, 0x12, 0x03, 0x06, 0x00, 0x49, 0x0a, 0x2b, 0x0a, 0x02, 0x05, 0x00, 0x12, 0x04, 0x09, 0x00, + 0x14, 0x01, 0x1a, 0x1f, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x20, 0x61, 0x20, 0x73, 0x65, + 0x74, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, + 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, 0x03, 0x09, 0x05, 0x0f, 0x0a, + 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0a, 0x02, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0a, 0x02, 0x06, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, + 0x02, 0x00, 0x02, 0x12, 0x03, 0x0a, 0x09, 0x0a, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x01, + 0x12, 0x03, 0x0b, 0x02, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x0b, 0x02, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x0b, 0x0c, + 0x0d, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x02, 0x12, 0x03, 0x0c, 0x02, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x0c, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x0c, 0x0a, 0x0b, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, + 0x02, 0x03, 0x12, 0x03, 0x0d, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x01, + 0x12, 0x03, 0x0d, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, + 0x0d, 0x0b, 0x0c, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x04, 0x12, 0x03, 0x0e, 0x02, 0x0e, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x0e, 0x02, 0x09, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, 0x0e, 0x0c, 0x0d, 0x0a, 0x0b, 0x0a, 0x04, + 0x05, 0x00, 0x02, 0x05, 0x12, 0x03, 0x0f, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, + 0x05, 0x01, 0x12, 0x03, 0x0f, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x05, 0x02, + 0x12, 0x03, 0x0f, 0x0d, 0x0e, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x06, 0x12, 0x03, 0x10, + 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x10, 0x02, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x06, 0x02, 0x12, 0x03, 0x10, 0x0d, 0x0e, 0x0a, 0x0b, + 0x0a, 0x04, 0x05, 0x00, 0x02, 0x07, 0x12, 0x03, 0x11, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x07, 0x01, 0x12, 0x03, 0x11, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, + 0x07, 0x02, 0x12, 0x03, 0x11, 0x0b, 0x0c, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x08, 0x12, + 0x03, 0x12, 0x02, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x08, 0x01, 0x12, 0x03, 0x12, + 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x08, 0x02, 0x12, 0x03, 0x12, 0x0a, 0x0b, + 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x09, 0x12, 0x03, 0x13, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x09, 0x01, 0x12, 0x03, 0x13, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x09, 0x02, 0x12, 0x03, 0x13, 0x0b, 0x0c, 0x0a, 0x62, 0x0a, 0x02, 0x04, 0x00, 0x12, + 0x04, 0x17, 0x00, 0x2b, 0x01, 0x1a, 0x56, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, + 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x20, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x20, 0x61, + 0x6e, 0x64, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x74, 0x72, 0x6f, + 0x6e, 0x67, 0x6c, 0x79, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x65, 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, + 0x6f, 0x70, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x17, 0x08, 0x12, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x00, 0x03, + 0x00, 0x12, 0x04, 0x18, 0x02, 0x27, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x03, 0x00, 0x01, + 0x12, 0x03, 0x18, 0x0a, 0x16, 0x0a, 0x46, 0x0a, 0x06, 0x04, 0x00, 0x03, 0x00, 0x02, 0x00, 0x12, + 0x03, 0x1a, 0x04, 0x14, 0x1a, 0x37, 0x20, 0x41, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, + 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x2d, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2d, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x0a, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x1a, 0x04, 0x0a, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1a, 0x0b, 0x0f, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1a, 0x12, 0x13, 0x0a, 0x0e, 0x0a, + 0x06, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x12, 0x04, 0x1c, 0x04, 0x23, 0x05, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x01, 0x12, 0x03, 0x1c, 0x09, 0x19, 0x0a, 0x0f, 0x0a, + 0x08, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x1d, 0x06, 0x12, 0x0a, 0x10, + 0x0a, 0x09, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1d, 0x06, 0x0d, + 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x1d, + 0x10, 0x11, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, + 0x1e, 0x06, 0x10, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x1e, 0x06, 0x0b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x02, + 0x01, 0x02, 0x12, 0x03, 0x1e, 0x0e, 0x0f, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x03, 0x00, 0x04, + 0x00, 0x02, 0x02, 0x12, 0x03, 0x1f, 0x06, 0x11, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x03, 0x00, + 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x1f, 0x06, 0x0c, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, + 0x03, 0x00, 0x04, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x1f, 0x0f, 0x10, 0x0a, 0x0f, 0x0a, 0x08, + 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x20, 0x06, 0x12, 0x0a, 0x10, 0x0a, + 0x09, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x20, 0x06, 0x0d, 0x0a, + 0x10, 0x0a, 0x09, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x20, 0x10, + 0x11, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, 0x21, + 0x06, 0x13, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, + 0x03, 0x21, 0x06, 0x0e, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x02, 0x04, + 0x02, 0x12, 0x03, 0x21, 0x11, 0x12, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, + 0x02, 0x05, 0x12, 0x03, 0x22, 0x06, 0x13, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x03, 0x00, 0x04, + 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x22, 0x06, 0x0e, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x03, + 0x00, 0x04, 0x00, 0x02, 0x05, 0x02, 0x12, 0x03, 0x22, 0x11, 0x12, 0x0a, 0x4f, 0x0a, 0x06, 0x04, + 0x00, 0x03, 0x00, 0x02, 0x01, 0x12, 0x03, 0x26, 0x04, 0x1e, 0x1a, 0x40, 0x20, 0x54, 0x68, 0x65, + 0x20, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x20, 0x54, 0x68, + 0x69, 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x6d, 0x69, + 0x74, 0x65, 0x64, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, + 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x00, 0x03, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x26, 0x04, 0x14, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x00, 0x03, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x26, 0x15, 0x19, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x00, 0x03, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x26, 0x1c, 0x1d, 0x0a, 0x42, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x2a, 0x02, 0x24, 0x1a, 0x35, 0x20, 0x41, 0x20, 0x6c, 0x69, + 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20, 0x63, 0x6f, + 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d, + 0x61, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x69, 0x73, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x04, 0x12, 0x03, 0x2a, 0x02, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x2a, 0x0b, 0x17, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2a, 0x18, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x2a, 0x22, 0x23, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, + 0x2d, 0x00, 0x45, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x2d, 0x08, 0x1d, + 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x01, 0x03, 0x00, 0x12, 0x04, 0x2e, 0x02, 0x34, 0x03, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x03, 0x00, 0x01, 0x12, 0x03, 0x2e, 0x0a, 0x17, 0x0a, 0x45, 0x0a, 0x06, + 0x04, 0x01, 0x03, 0x00, 0x02, 0x00, 0x12, 0x03, 0x30, 0x04, 0x14, 0x1a, 0x36, 0x20, 0x41, 0x20, + 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6c, 0x75, 0x6d, + 0x6e, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x30, 0x04, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x30, 0x0b, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x30, 0x12, 0x13, 0x0a, 0x21, 0x0a, 0x06, 0x04, 0x01, 0x03, 0x00, 0x02, 0x01, 0x12, 0x03, 0x33, + 0x04, 0x21, 0x1a, 0x12, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x20, + 0x74, 0x79, 0x70, 0x65, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x01, + 0x06, 0x12, 0x03, 0x33, 0x04, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x33, 0x10, 0x1c, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x33, 0x1f, 0x20, 0x0a, 0x42, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, + 0x37, 0x02, 0x25, 0x1a, 0x35, 0x20, 0x41, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, + 0x6f, 0x72, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x20, 0x63, 0x6f, 0x6d, 0x70, + 0x72, 0x69, 0x73, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x04, 0x12, 0x03, 0x37, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, + 0x06, 0x12, 0x03, 0x37, 0x0b, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x37, 0x19, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x37, + 0x23, 0x24, 0x0a, 0xb3, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x3c, 0x02, 0x14, + 0x1a, 0xa5, 0x01, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x2c, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x62, 0x69, 0x74, 0x73, 0x20, 0x61, 0x74, 0x20, 0x72, 0x65, 0x73, 0x74, 0x0a, 0x20, + 0x70, 0x61, 0x72, 0x71, 0x75, 0x65, 0x74, 0x2c, 0x20, 0x66, 0x65, 0x61, 0x74, 0x68, 0x65, 0x72, + 0x2c, 0x20, 0x63, 0x73, 0x76, 0x2c, 0x20, 0x65, 0x74, 0x63, 0x2e, 0x0a, 0x20, 0x46, 0x6f, 0x72, + 0x20, 0x74, 0x77, 0x6f, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, + 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6e, 0x65, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, + 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, + 0x05, 0x12, 0x03, 0x3c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x3c, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x3c, + 0x12, 0x13, 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x40, 0x02, 0x22, + 0x1a, 0xa6, 0x01, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x73, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, + 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x65, 0x78, 0x74, + 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x5f, 0x62, 0x79, 0x74, + 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x64, + 0x20, 0x69, 0x6e, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6e, + 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, + 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x63, + 0x68, 0x65, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x02, 0x05, 0x12, 0x03, 0x40, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x40, 0x09, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, + 0x40, 0x20, 0x21, 0x0a, 0x94, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x03, 0x12, 0x03, 0x44, 0x02, + 0x22, 0x1a, 0x86, 0x01, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, + 0x7a, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x74, + 0x68, 0x69, 0x72, 0x64, 0x2d, 0x70, 0x61, 0x72, 0x74, 0x79, 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d, + 0x61, 0x20, 0x6c, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x41, + 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, + 0x6e, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, + 0x63, 0x68, 0x65, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x03, 0x05, 0x12, 0x03, 0x44, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, + 0x01, 0x12, 0x03, 0x44, 0x08, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x03, 0x12, + 0x03, 0x44, 0x20, 0x21, 0x0a, 0x34, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x48, 0x00, 0x52, 0x01, + 0x1a, 0x28, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, + 0x62, 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, + 0x62, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, + 0x01, 0x12, 0x03, 0x48, 0x08, 0x10, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x02, 0x04, 0x00, 0x12, 0x04, + 0x49, 0x02, 0x4c, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x04, 0x00, 0x01, 0x12, 0x03, 0x49, + 0x07, 0x19, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x4a, 0x04, + 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x4a, 0x04, + 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x4a, 0x0d, + 0x0e, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x4b, 0x04, 0x12, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x4b, 0x04, 0x0d, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x4b, 0x10, 0x11, + 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x50, 0x02, 0x14, 0x1a, 0x52, 0x20, + 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, + 0x66, 0x72, 0x65, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x74, 0x6f, 0x6f, 0x64, 0x20, 0x62, 0x79, 0x20, 0x53, + 0x44, 0x4b, 0x2f, 0x55, 0x49, 0x20, 0x65, 0x74, 0x63, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x0a, 0x20, + 0x63, 0x73, 0x76, 0x2c, 0x20, 0x70, 0x61, 0x72, 0x71, 0x75, 0x65, 0x74, 0x20, 0x65, 0x74, 0x63, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, 0x50, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x50, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x50, 0x12, 0x13, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x51, 0x02, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, + 0x06, 0x12, 0x03, 0x51, 0x02, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x51, 0x15, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x51, + 0x26, 0x27, 0x0a, 0xee, 0x01, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x57, 0x00, 0x5a, 0x01, 0x1a, + 0xe1, 0x01, 0x20, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x63, 0x6c, 0x61, + 0x72, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x6e, 0x75, 0x6d, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2c, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x70, 0x72, 0x65, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, + 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x20, + 0x46, 0x6f, 0x72, 0x20, 0x6c, 0x65, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x29, 0x20, + 0x3e, 0x20, 0x30, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x72, 0x64, 0x65, + 0x72, 0x65, 0x64, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x67, 0x61, + 0x72, 0x64, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, + 0x75, 0x6c, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x79, 0x6f, + 0x75, 0x20, 0x77, 0x69, 0x73, 0x68, 0x0a, 0x20, 0x54, 0x6f, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x20, 0x6e, 0x6f, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x2c, 0x20, + 0x6d, 0x61, 0x6b, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x20, 0x61, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, + 0x64, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x57, 0x08, 0x10, 0x0a, + 0x2d, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x59, 0x02, 0x1d, 0x1a, 0x20, 0x20, 0x50, + 0x72, 0x65, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, + 0x20, 0x65, 0x6e, 0x75, 0x6d, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x04, 0x12, 0x03, 0x59, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x00, 0x05, 0x12, 0x03, 0x59, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x59, 0x12, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x59, 0x1b, 0x1c, 0x0a, 0xa1, 0x05, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x69, + 0x00, 0x6c, 0x01, 0x1a, 0x94, 0x05, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x61, + 0x20, 0x74, 0x61, 0x67, 0x67, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x2c, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x61, + 0x73, 0x20, 0x61, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74, 0x20, 0x28, 0x61, 0x6e, 0x64, + 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x75, 0x6d, 0x20, 0x74, 0x79, 0x70, 0x65, 0x29, 0x2e, 0x0a, 0x0a, 0x20, 0x41, 0x20, + 0x73, 0x75, 0x6d, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x53, 0x20, 0x69, 0x73, 0x20, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x20, 0x73, 0x65, 0x71, 0x75, 0x65, + 0x6e, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x28, 0x41, 0x2c, + 0x20, 0x42, 0x2c, 0x20, 0x43, 0x2c, 0x20, 0x2e, 0x2e, 0x2e, 0x29, 0x2c, 0x20, 0x65, 0x61, 0x63, + 0x68, 0x20, 0x74, 0x61, 0x67, 0x67, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x20, 0x73, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x61, 0x67, 0x0a, 0x20, 0x41, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x53, 0x20, 0x69, 0x73, 0x20, 0x63, + 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, + 0x61, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x63, 0x20, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x79, 0x70, 0x65, + 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x0a, + 0x20, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x72, + 0x61, 0x69, 0x6e, 0x74, 0x27, 0x73, 0x20, 0x74, 0x61, 0x67, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, + 0x6d, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, + 0x2e, 0x0a, 0x0a, 0x20, 0x54, 0x79, 0x70, 0x65, 0x20, 0x53, 0x20, 0x69, 0x73, 0x20, 0x74, 0x79, + 0x70, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x20, + 0x61, 0x73, 0x0a, 0x20, 0x53, 0x20, 0x3a, 0x3d, 0x20, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x41, + 0x20, 0x7c, 0x20, 0x42, 0x61, 0x6e, 0x61, 0x6e, 0x61, 0x20, 0x42, 0x20, 0x7c, 0x20, 0x43, 0x61, + 0x6e, 0x74, 0x61, 0x6c, 0x6f, 0x75, 0x70, 0x65, 0x20, 0x43, 0x20, 0x7c, 0x20, 0x2e, 0x2e, 0x2e, + 0x0a, 0x0a, 0x20, 0x4e, 0x6f, 0x74, 0x61, 0x62, 0x6c, 0x79, 0x2c, 0x20, 0x61, 0x20, 0x6e, 0x75, + 0x6c, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x28, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x29, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x73, 0x75, 0x6d, 0x20, + 0x74, 0x79, 0x70, 0x65, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x20, 0x73, 0x6f, 0x6d, + 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x58, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x74, 0x6f, 0x6e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, + 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x6e, + 0x75, 0x6c, 0x6c, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x0a, 0x20, 0x4f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x58, 0x20, 0x3a, 0x3d, 0x20, 0x58, 0x20, 0x7c, 0x20, 0x4e, 0x75, + 0x6c, 0x6c, 0x0a, 0x0a, 0x20, 0x53, 0x65, 0x65, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x3a, 0x20, 0x68, + 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x65, 0x6e, 0x2e, 0x77, 0x69, 0x6b, 0x69, 0x70, 0x65, + 0x64, 0x69, 0x61, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x77, 0x69, 0x6b, 0x69, 0x2f, 0x54, 0x61, 0x67, + 0x67, 0x65, 0x64, 0x5f, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, + 0x01, 0x12, 0x03, 0x69, 0x08, 0x11, 0x0a, 0x33, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, + 0x6b, 0x02, 0x24, 0x1a, 0x26, 0x20, 0x50, 0x72, 0x65, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, + 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74, 0x73, + 0x20, 0x69, 0x6e, 0x20, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x00, 0x04, 0x12, 0x03, 0x6b, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x6b, 0x0b, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x6b, 0x17, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x6b, 0x22, 0x23, 0x0a, 0xa1, 0x01, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x71, 0x00, 0x7a, 0x01, + 0x1a, 0x94, 0x01, 0x20, 0x48, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6d, 0x70, + 0x72, 0x6f, 0x76, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, + 0x6e, 0x67, 0x0a, 0x20, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x20, + 0x64, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x75, 0x69, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x6f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x63, 0x75, 0x73, 0x74, 0x6f, + 0x6d, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, + 0x65, 0x72, 0x73, 0x0a, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x49, 0x44, 0x4c, 0x20, + 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6d, 0x61, + 0x74, 0x63, 0x68, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, + 0x71, 0x08, 0x15, 0x0a, 0x3a, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x73, 0x02, 0x11, + 0x1a, 0x2d, 0x20, 0x4d, 0x75, 0x73, 0x74, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, + 0x6d, 0x61, 0x74, 0x63, 0x68, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, + 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x63, 0x61, 0x73, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x05, 0x12, 0x03, 0x73, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x73, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x73, 0x0f, 0x10, 0x0a, 0xc5, 0x02, 0x0a, 0x04, 0x04, 0x05, + 0x02, 0x01, 0x12, 0x03, 0x79, 0x02, 0x2e, 0x1a, 0xb7, 0x02, 0x20, 0x64, 0x61, 0x74, 0x61, 0x63, + 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x65, + 0x78, 0x69, 0x73, 0x74, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x64, 0x61, 0x74, 0x61, 0x63, 0x6c, + 0x61, 0x73, 0x73, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, + 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x64, 0x61, 0x74, 0x61, 0x63, 0x6c, + 0x61, 0x73, 0x73, 0x0a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x69, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x20, + 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x74, 0x79, 0x70, + 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x0a, 0x20, + 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x64, 0x61, 0x74, 0x61, 0x63, 0x6c, 0x61, + 0x73, 0x73, 0x20, 0x46, 0x6f, 0x6f, 0x2c, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x73, 0x20, 0x61, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x20, 0x69, 0x73, 0x20, + 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x46, 0x6f, 0x6f, 0x2e, 0x61, 0x20, + 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x64, + 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x72, 0x6f, + 0x6d, 0x20, 0x64, 0x61, 0x74, 0x61, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x74, 0x79, 0x70, 0x65, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x06, 0x12, 0x03, 0x79, 0x02, 0x1a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, 0x12, 0x03, 0x79, 0x1b, 0x29, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x03, 0x79, 0x2c, 0x2d, 0x0a, 0xd0, 0x01, 0x0a, 0x02, + 0x04, 0x06, 0x12, 0x05, 0x7d, 0x00, 0x80, 0x01, 0x01, 0x1a, 0xc2, 0x01, 0x20, 0x54, 0x79, 0x70, + 0x65, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x6e, 0x63, 0x61, + 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, + 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x20, 0x74, + 0x79, 0x70, 0x65, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, + 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x76, 0x61, 0x72, 0x69, 0x6f, 0x75, + 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x2d, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x20, + 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x20, 0x54, 0x79, 0x70, 0x65, + 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, + 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, + 0x20, 0x61, 0x74, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x77, 0x68, 0x65, 0x6e, + 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x03, 0x7d, 0x08, 0x16, 0x0a, 0x3b, 0x0a, 0x04, 0x04, 0x06, + 0x02, 0x00, 0x12, 0x03, 0x7f, 0x02, 0x29, 0x1a, 0x2e, 0x20, 0x41, 0x20, 0x61, 0x72, 0x62, 0x69, + 0x74, 0x72, 0x61, 0x72, 0x79, 0x20, 0x4a, 0x53, 0x4f, 0x4e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, + 0x61, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x61, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x7f, 0x02, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x7f, 0x19, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x03, 0x7f, 0x27, + 0x28, 0x0a, 0x50, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x06, 0x83, 0x01, 0x00, 0xa8, 0x01, 0x01, 0x1a, + 0x42, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x6f, + 0x6e, 0x67, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x62, + 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, + 0x73, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x04, 0x83, 0x01, 0x08, 0x13, + 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x07, 0x08, 0x00, 0x12, 0x06, 0x84, 0x01, 0x02, 0x9c, 0x01, 0x03, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x08, 0x00, 0x01, 0x12, 0x04, 0x84, 0x01, 0x08, 0x0c, 0x0a, + 0x4b, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x04, 0x86, 0x01, 0x04, 0x1a, 0x1a, 0x3d, 0x20, + 0x41, 0x20, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, + 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x65, 0x2d, 0x74, 0x6f, 0x2d, 0x6f, 0x6e, 0x65, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x20, 0x61, 0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x00, 0x06, 0x12, 0x04, 0x86, 0x01, 0x04, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x00, 0x01, 0x12, 0x04, 0x86, 0x01, 0x0f, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x00, 0x03, 0x12, 0x04, 0x86, 0x01, 0x18, 0x19, 0x0a, 0x46, 0x0a, 0x04, 0x04, 0x07, 0x02, + 0x01, 0x12, 0x04, 0x89, 0x01, 0x04, 0x1a, 0x1a, 0x38, 0x20, 0x41, 0x20, 0x63, 0x6f, 0x6d, 0x70, + 0x6c, 0x65, 0x78, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x72, 0x65, + 0x71, 0x75, 0x69, 0x72, 0x65, 0x73, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, + 0x6f, 0x66, 0x20, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x06, 0x12, 0x04, 0x89, 0x01, 0x04, 0x0e, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x01, 0x12, 0x04, 0x89, 0x01, 0x0f, 0x15, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, 0x04, 0x89, 0x01, 0x18, 0x19, 0x0a, 0x68, + 0x0a, 0x04, 0x04, 0x07, 0x02, 0x02, 0x12, 0x04, 0x8c, 0x01, 0x04, 0x24, 0x1a, 0x5a, 0x20, 0x44, + 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, + 0x61, 0x20, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x4f, 0x6e, + 0x6c, 0x79, 0x20, 0x68, 0x6f, 0x6d, 0x6f, 0x67, 0x65, 0x6e, 0x65, 0x6f, 0x75, 0x73, 0x20, 0x63, + 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, + 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, + 0x06, 0x12, 0x04, 0x8c, 0x01, 0x04, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x01, + 0x12, 0x04, 0x8c, 0x01, 0x10, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x03, 0x12, + 0x04, 0x8c, 0x01, 0x22, 0x23, 0x0a, 0x64, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x03, 0x12, 0x04, 0x8f, + 0x01, 0x04, 0x23, 0x1a, 0x56, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x6d, 0x61, 0x70, 0x20, 0x74, 0x79, 0x70, + 0x65, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6c, 0x77, 0x61, 0x79, 0x73, + 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x03, 0x06, 0x12, 0x04, 0x8f, 0x01, 0x04, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x03, 0x01, 0x12, 0x04, 0x8f, 0x01, 0x10, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x03, 0x03, 0x12, 0x04, 0x8f, 0x01, 0x21, 0x22, 0x0a, 0x66, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x04, + 0x12, 0x04, 0x92, 0x01, 0x04, 0x16, 0x1a, 0x58, 0x20, 0x41, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, + 0x6d, 0x69, 0x67, 0x68, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x20, 0x64, 0x65, + 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x6e, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, + 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x04, 0x06, 0x12, 0x04, 0x92, 0x01, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x04, 0x01, 0x12, 0x04, 0x92, 0x01, 0x0d, 0x11, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x04, 0x03, 0x12, 0x04, 0x92, 0x01, 0x14, 0x15, 0x0a, 0x3f, 0x0a, + 0x04, 0x04, 0x07, 0x02, 0x05, 0x12, 0x04, 0x95, 0x01, 0x04, 0x1b, 0x1a, 0x31, 0x20, 0x44, 0x65, + 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x6e, 0x75, 0x6d, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x20, 0x70, 0x72, 0x65, 0x2d, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x73, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x05, 0x06, 0x12, 0x04, 0x95, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x05, 0x01, 0x12, 0x04, 0x95, 0x01, 0x0d, 0x16, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x05, 0x03, 0x12, 0x04, 0x95, 0x01, 0x19, 0x1a, 0x0a, 0x2a, 0x0a, 0x04, 0x04, + 0x07, 0x02, 0x06, 0x12, 0x04, 0x98, 0x01, 0x04, 0x36, 0x1a, 0x1c, 0x20, 0x47, 0x65, 0x6e, 0x65, + 0x72, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x20, 0x73, + 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x06, 0x06, + 0x12, 0x04, 0x98, 0x01, 0x04, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x06, 0x01, 0x12, + 0x04, 0x98, 0x01, 0x1a, 0x31, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x06, 0x03, 0x12, 0x04, + 0x98, 0x01, 0x34, 0x35, 0x0a, 0x44, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x07, 0x12, 0x04, 0x9b, 0x01, + 0x04, 0x1e, 0x1a, 0x36, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, + 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x70, 0x72, 0x65, 0x2d, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x4c, 0x69, 0x74, 0x65, + 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x07, 0x06, 0x12, 0x04, 0x9b, 0x01, 0x04, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x07, 0x01, 0x12, 0x04, 0x9b, 0x01, 0x0e, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x07, + 0x03, 0x12, 0x04, 0x9b, 0x01, 0x1b, 0x1d, 0x0a, 0xe8, 0x01, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x08, + 0x12, 0x04, 0xa0, 0x01, 0x02, 0x26, 0x1a, 0xd9, 0x01, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x69, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x76, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2c, 0x20, 0x62, 0x75, 0x74, + 0x20, 0x69, 0x73, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, + 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2d, 0x63, 0x68, 0x65, 0x63, 0x6b, + 0x69, 0x6e, 0x67, 0x2e, 0x20, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x69, 0x67, 0x68, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x0a, 0x20, 0x63, 0x6f, 0x6e, + 0x73, 0x75, 0x6d, 0x65, 0x72, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x20, 0x62, 0x65, 0x68, 0x61, 0x76, + 0x69, 0x6f, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x20, 0x65, + 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x08, 0x06, 0x12, 0x04, 0xa0, 0x01, 0x02, + 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x08, 0x01, 0x12, 0x04, 0xa0, 0x01, 0x19, 0x21, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x08, 0x03, 0x12, 0x04, 0xa0, 0x01, 0x24, 0x25, 0x0a, + 0x99, 0x01, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x09, 0x12, 0x04, 0xa4, 0x01, 0x02, 0x20, 0x1a, 0x8a, + 0x01, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x61, 0x72, 0x62, 0x69, 0x74, 0x72, 0x61, 0x72, 0x79, 0x20, + 0x64, 0x61, 0x74, 0x61, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x6d, 0x69, 0x67, 0x68, 0x74, 0x20, + 0x68, 0x61, 0x76, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x20, 0x73, 0x65, 0x6d, + 0x61, 0x6e, 0x74, 0x69, 0x63, 0x0a, 0x20, 0x6d, 0x65, 0x61, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x75, + 0x74, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, + 0x74, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x20, 0x62, 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x09, 0x06, 0x12, 0x04, 0xa4, 0x01, 0x02, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x09, 0x01, 0x12, 0x04, 0xa4, 0x01, 0x11, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x09, 0x03, 0x12, 0x04, 0xa4, 0x01, 0x1e, 0x1f, 0x0a, 0x2f, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x0a, + 0x12, 0x04, 0xa7, 0x01, 0x02, 0x1f, 0x1a, 0x21, 0x20, 0x48, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x74, + 0x6f, 0x20, 0x69, 0x6d, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6d, + 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x0a, 0x06, 0x12, 0x04, 0xa7, 0x01, 0x02, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x0a, + 0x01, 0x12, 0x04, 0xa7, 0x01, 0x10, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x0a, 0x03, + 0x12, 0x04, 0xa7, 0x01, 0x1c, 0x1e, 0x0a, 0x93, 0x01, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x06, 0xac, + 0x01, 0x00, 0xb4, 0x01, 0x01, 0x1a, 0x84, 0x01, 0x20, 0x41, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, + 0x65, 0x6e, 0x63, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6e, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x20, + 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x63, + 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x64, 0x20, + 0x2d, 0x61, 0x6e, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x64, 0x2d, 0x20, + 0x66, 0x72, 0x6f, 0x6d, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, + 0x79, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, + 0x04, 0x08, 0x01, 0x12, 0x04, 0xac, 0x01, 0x08, 0x17, 0x0a, 0x36, 0x0a, 0x04, 0x04, 0x08, 0x02, + 0x00, 0x12, 0x04, 0xae, 0x01, 0x02, 0x15, 0x1a, 0x28, 0x20, 0x4e, 0x6f, 0x64, 0x65, 0x20, 0x69, + 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x20, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x67, 0x72, 0x61, 0x70, 0x68, 0x20, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x05, 0x12, 0x04, 0xae, 0x01, 0x02, 0x08, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x04, 0xae, 0x01, 0x09, 0x10, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x04, 0xae, 0x01, 0x13, 0x14, 0x0a, 0x4c, + 0x0a, 0x04, 0x04, 0x08, 0x02, 0x01, 0x12, 0x04, 0xb1, 0x01, 0x02, 0x11, 0x1a, 0x3e, 0x20, 0x56, + 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6d, 0x75, 0x73, + 0x74, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6e, 0x20, 0x6f, 0x75, + 0x74, 0x70, 0x75, 0x74, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x08, 0x02, 0x01, 0x05, 0x12, 0x04, 0xb1, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x01, 0x01, 0x12, 0x04, 0xb1, 0x01, 0x09, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x01, 0x03, 0x12, 0x04, 0xb1, 0x01, 0x0f, 0x10, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x08, 0x02, + 0x02, 0x12, 0x04, 0xb3, 0x01, 0x02, 0x2a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x04, + 0x12, 0x04, 0xb3, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x06, 0x12, + 0x04, 0xb3, 0x01, 0x0b, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x01, 0x12, 0x04, + 0xb3, 0x01, 0x1c, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x03, 0x12, 0x04, 0xb3, + 0x01, 0x28, 0x29, 0x0a, 0xd0, 0x02, 0x0a, 0x02, 0x04, 0x09, 0x12, 0x06, 0xc1, 0x01, 0x00, 0xc6, + 0x01, 0x01, 0x32, 0xc1, 0x02, 0x20, 0x50, 0x72, 0x6f, 0x6d, 0x69, 0x73, 0x65, 0x41, 0x74, 0x74, + 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, + 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x6d, 0x69, 0x73, 0x65, 0x2c, 0x20, 0x77, + 0x68, 0x69, 0x63, 0x68, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, + 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, + 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, + 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, + 0x6f, 0x66, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x69, + 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x20, 0x49, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, + 0x6c, 0x65, 0x2c, 0x0a, 0x20, 0x60, 0x60, 0x60, 0x0a, 0x20, 0x40, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x0a, 0x20, 0x64, 0x65, 0x66, 0x20, 0x77, 0x66, 0x28, 0x29, 0x3a, 0x0a, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x6f, 0x20, 0x3d, 0x20, 0x74, 0x31, 0x28, 0x29, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x74, 0x32, 0x28, 0x6f, 0x2e, 0x61, 0x5b, 0x22, 0x62, 0x22, 0x5d, 0x5b, 0x30, 0x5d, + 0x29, 0x0a, 0x20, 0x60, 0x60, 0x60, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x75, 0x74, 0x70, + 0x75, 0x74, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x74, 0x32, 0x20, + 0x62, 0x69, 0x6e, 0x64, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x20, 0x6c, + 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x50, 0x72, 0x6f, 0x6d, 0x69, 0x73, 0x65, 0x41, 0x74, + 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x20, 0x5b, 0x22, 0x61, 0x22, 0x2c, 0x20, 0x22, 0x62, + 0x22, 0x2c, 0x20, 0x30, 0x5d, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, 0x04, 0xc1, + 0x01, 0x08, 0x18, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x09, 0x08, 0x00, 0x12, 0x06, 0xc2, 0x01, 0x02, + 0xc5, 0x01, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x08, 0x00, 0x01, 0x12, 0x04, 0xc2, 0x01, + 0x08, 0x0d, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x00, 0x12, 0x04, 0xc3, 0x01, 0x04, 0x1c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x05, 0x12, 0x04, 0xc3, 0x01, 0x04, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x04, 0xc3, 0x01, 0x0b, 0x17, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, 0x04, 0xc3, 0x01, 0x1a, 0x1b, 0x0a, 0x0c, 0x0a, + 0x04, 0x04, 0x09, 0x02, 0x01, 0x12, 0x04, 0xc4, 0x01, 0x04, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x09, 0x02, 0x01, 0x05, 0x12, 0x04, 0xc4, 0x01, 0x04, 0x09, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x01, 0x01, 0x12, 0x04, 0xc4, 0x01, 0x0a, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, + 0x01, 0x03, 0x12, 0x04, 0xc4, 0x01, 0x16, 0x17, 0x0a, 0x37, 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x06, + 0xc9, 0x01, 0x00, 0xcf, 0x01, 0x01, 0x1a, 0x29, 0x20, 0x52, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, + 0x6e, 0x74, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x72, + 0x6f, 0x77, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x2e, + 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0a, 0x01, 0x12, 0x04, 0xc9, 0x01, 0x08, 0x0d, 0x0a, 0x31, + 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x00, 0x12, 0x04, 0xcb, 0x01, 0x02, 0x1c, 0x1a, 0x23, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x69, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x72, 0x65, 0x77, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x05, 0x12, 0x04, 0xcb, 0x01, 0x02, 0x08, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x04, 0xcb, 0x01, 0x09, 0x17, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, 0x04, 0xcb, 0x01, 0x1a, 0x1b, 0x0a, 0x25, + 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x01, 0x12, 0x04, 0xce, 0x01, 0x02, 0x15, 0x1a, 0x17, 0x20, 0x45, + 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x74, 0x68, 0x72, + 0x6f, 0x77, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x05, 0x12, 0x04, + 0xce, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x01, 0x12, 0x04, 0xce, + 0x01, 0x09, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x03, 0x12, 0x04, 0xce, 0x01, + 0x13, 0x14, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xbe, 0x59, 0x0a, 0x1d, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x6c, 0x69, + 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x1a, 0x1a, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x79, 0x70, + 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x87, 0x02, 0x0a, 0x09, 0x50, 0x72, 0x69, 0x6d, + 0x69, 0x74, 0x69, 0x76, 0x65, 0x12, 0x1a, 0x0a, 0x07, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x07, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, + 0x72, 0x12, 0x21, 0x0a, 0x0b, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, 0x0a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x73, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1a, 0x0a, 0x07, 0x62, 0x6f, 0x6f, + 0x6c, 0x65, 0x61, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x07, 0x62, 0x6f, + 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x12, 0x38, 0x0a, 0x08, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, + 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x48, 0x00, 0x52, 0x08, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x12, + 0x37, 0x0a, 0x08, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x08, + 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x07, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x22, 0x06, 0x0a, 0x04, 0x56, 0x6f, 0x69, 0x64, 0x22, 0x52, 0x0a, 0x04, 0x42, 0x6c, 0x6f, + 0x62, 0x12, 0x38, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x42, 0x6c, 0x6f, 0x62, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x10, 0x0a, 0x03, 0x75, + 0x72, 0x69, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x69, 0x22, 0x3c, 0x0a, + 0x0c, 0x42, 0x6c, 0x6f, 0x62, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x2c, 0x0a, + 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x42, 0x6c, 0x6f, + 0x62, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x30, 0x0a, 0x06, 0x42, + 0x69, 0x6e, 0x61, 0x72, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x74, + 0x61, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x74, 0x61, 0x67, 0x22, 0x4a, 0x0a, + 0x06, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x69, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x69, 0x12, 0x2e, 0x0a, 0x04, 0x74, 0x79, 0x70, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x54, + 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x67, 0x0a, 0x05, 0x55, 0x6e, 0x69, + 0x6f, 0x6e, 0x12, 0x2d, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x12, 0x2f, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, + 0x70, 0x65, 0x22, 0x7a, 0x0a, 0x19, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, + 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, + 0x5d, 0x0a, 0x17, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x5f, 0x64, 0x61, + 0x74, 0x61, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, + 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x15, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, + 0x72, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x6c, + 0x0a, 0x11, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, + 0x73, 0x65, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x75, 0x72, 0x69, 0x12, 0x45, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, + 0x72, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0xf8, 0x03, 0x0a, + 0x06, 0x53, 0x63, 0x61, 0x6c, 0x61, 0x72, 0x12, 0x39, 0x0a, 0x09, 0x70, 0x72, 0x69, 0x6d, 0x69, + 0x74, 0x69, 0x76, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x50, 0x72, 0x69, 0x6d, + 0x69, 0x74, 0x69, 0x76, 0x65, 0x48, 0x00, 0x52, 0x09, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, + 0x76, 0x65, 0x12, 0x2a, 0x0a, 0x04, 0x62, 0x6c, 0x6f, 0x62, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x14, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x42, 0x6c, 0x6f, 0x62, 0x48, 0x00, 0x52, 0x04, 0x62, 0x6c, 0x6f, 0x62, 0x12, 0x30, + 0x0a, 0x06, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x48, 0x00, 0x52, 0x06, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, + 0x12, 0x30, 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x48, 0x00, 0x52, 0x06, 0x73, 0x63, 0x68, 0x65, + 0x6d, 0x61, 0x12, 0x33, 0x0a, 0x09, 0x6e, 0x6f, 0x6e, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x56, 0x6f, 0x69, 0x64, 0x48, 0x00, 0x52, 0x08, 0x6e, + 0x6f, 0x6e, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2d, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x48, 0x00, 0x52, + 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x33, 0x0a, 0x07, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, + 0x63, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, + 0x48, 0x00, 0x52, 0x07, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x12, 0x52, 0x0a, 0x12, 0x73, + 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, + 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, + 0x72, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x48, 0x00, 0x52, 0x11, 0x73, 0x74, + 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x12, + 0x2d, 0x0a, 0x05, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x05, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x42, 0x07, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0xb4, 0x03, 0x0a, 0x07, 0x4c, 0x69, 0x74, 0x65, + 0x72, 0x61, 0x6c, 0x12, 0x30, 0x0a, 0x06, 0x73, 0x63, 0x61, 0x6c, 0x61, 0x72, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x63, 0x61, 0x6c, 0x61, 0x72, 0x48, 0x00, 0x52, 0x06, 0x73, + 0x63, 0x61, 0x6c, 0x61, 0x72, 0x12, 0x43, 0x0a, 0x0a, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, + 0x61, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0a, + 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2e, 0x0a, 0x03, 0x6d, 0x61, + 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, + 0x4d, 0x61, 0x70, 0x48, 0x00, 0x52, 0x03, 0x6d, 0x61, 0x70, 0x12, 0x59, 0x0a, 0x12, 0x6f, 0x66, + 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4f, + 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x48, 0x00, 0x52, 0x11, 0x6f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x61, 0x73, 0x68, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x61, 0x73, 0x68, 0x12, 0x41, 0x0a, 0x08, 0x6d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, + 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, + 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, + 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0x07, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x4a, 0x04, 0x08, 0x06, 0x10, 0x07, 0x4a, 0x04, 0x08, 0x07, 0x10, 0x08, 0x22, 0x8d, + 0x01, 0x0a, 0x18, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4f, 0x66, 0x66, 0x6c, 0x6f, 0x61, + 0x64, 0x65, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x10, 0x0a, 0x03, 0x75, + 0x72, 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x69, 0x12, 0x1d, 0x0a, + 0x0a, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x09, 0x73, 0x69, 0x7a, 0x65, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x40, 0x0a, 0x0d, + 0x69, 0x6e, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, + 0x52, 0x0c, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x22, 0x48, + 0x0a, 0x11, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x33, 0x0a, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x08, + 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x22, 0xa8, 0x01, 0x0a, 0x0a, 0x4c, 0x69, 0x74, + 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, 0x70, 0x12, 0x44, 0x0a, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, + 0x61, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, + 0x61, 0x6c, 0x4d, 0x61, 0x70, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x52, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x1a, 0x54, 0x0a, + 0x0d, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, + 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, + 0x12, 0x2d, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, + 0x02, 0x38, 0x01, 0x22, 0x50, 0x0a, 0x15, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, + 0x74, 0x61, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x37, 0x0a, 0x08, + 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x52, 0x08, 0x62, 0x69, 0x6e, + 0x64, 0x69, 0x6e, 0x67, 0x73, 0x22, 0xb4, 0x01, 0x0a, 0x0e, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, + 0x67, 0x44, 0x61, 0x74, 0x61, 0x4d, 0x61, 0x70, 0x12, 0x48, 0x0a, 0x08, 0x62, 0x69, 0x6e, 0x64, + 0x69, 0x6e, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x42, 0x69, 0x6e, 0x64, + 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x4d, 0x61, 0x70, 0x2e, 0x42, 0x69, 0x6e, 0x64, 0x69, + 0x6e, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, + 0x67, 0x73, 0x1a, 0x58, 0x0a, 0x0d, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x31, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, + 0x61, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x48, 0x0a, 0x09, + 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3b, 0x0a, 0x0a, 0x74, 0x61, 0x72, + 0x67, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, + 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, + 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x8e, 0x03, 0x0a, 0x0b, 0x42, 0x69, 0x6e, 0x64, 0x69, + 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x12, 0x30, 0x0a, 0x06, 0x73, 0x63, 0x61, 0x6c, 0x61, 0x72, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x63, 0x61, 0x6c, 0x61, 0x72, 0x48, 0x00, + 0x52, 0x06, 0x73, 0x63, 0x61, 0x6c, 0x61, 0x72, 0x12, 0x47, 0x0a, 0x0a, 0x63, 0x6f, 0x6c, 0x6c, + 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x42, 0x69, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x3b, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6d, 0x69, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, + 0x6e, 0x63, 0x65, 0x48, 0x00, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6d, 0x69, 0x73, 0x65, 0x12, 0x32, + 0x0a, 0x03, 0x6d, 0x61, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x42, 0x69, 0x6e, + 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x4d, 0x61, 0x70, 0x48, 0x00, 0x52, 0x03, 0x6d, + 0x61, 0x70, 0x12, 0x59, 0x0a, 0x12, 0x6f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x5f, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, 0x11, 0x6f, 0x66, 0x66, 0x6c, + 0x6f, 0x61, 0x64, 0x65, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x2f, 0x0a, + 0x05, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x55, 0x6e, + 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x42, 0x07, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x52, 0x0a, 0x07, 0x42, 0x69, 0x6e, 0x64, 0x69, + 0x6e, 0x67, 0x12, 0x10, 0x0a, 0x03, 0x76, 0x61, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x03, 0x76, 0x61, 0x72, 0x12, 0x35, 0x0a, 0x07, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, + 0x74, 0x61, 0x52, 0x07, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x36, 0x0a, 0x0c, 0x4b, + 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x61, 0x69, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x6b, + 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x22, 0x29, 0x0a, 0x0d, 0x52, 0x65, 0x74, 0x72, 0x79, 0x53, 0x74, 0x72, 0x61, + 0x74, 0x65, 0x67, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73, 0x42, 0xb0, + 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x42, 0x0d, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, + 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x72, + 0x65, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, + 0x72, 0x65, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, + 0x6f, 0x72, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, + 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x72, + 0x65, 0x4a, 0x8f, 0x3e, 0x0a, 0x07, 0x12, 0x05, 0x00, 0x00, 0xcb, 0x01, 0x01, 0x0a, 0x08, 0x0a, + 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, + 0x17, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x24, 0x0a, 0x09, 0x0a, 0x02, + 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x28, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, + 0x00, 0x26, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x03, 0x12, 0x03, 0x07, 0x00, 0x29, 0x0a, 0x08, 0x0a, + 0x01, 0x08, 0x12, 0x03, 0x09, 0x00, 0x49, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x09, + 0x00, 0x49, 0x0a, 0x1d, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0c, 0x00, 0x17, 0x01, 0x1a, 0x11, + 0x20, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x20, 0x54, 0x79, 0x70, 0x65, 0x73, + 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0c, 0x08, 0x11, 0x0a, 0xcf, 0x01, + 0x0a, 0x04, 0x04, 0x00, 0x08, 0x00, 0x12, 0x04, 0x0f, 0x02, 0x16, 0x03, 0x1a, 0xc0, 0x01, 0x20, + 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x73, + 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x20, + 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x73, 0x65, 0x20, 0x74, 0x79, 0x70, + 0x65, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x67, 0x65, 0x74, 0x20, 0x74, 0x72, 0x61, 0x6e, + 0x73, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x20, 0x64, 0x69, 0x66, 0x66, + 0x65, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x6d, 0x69, 0x6e, + 0x67, 0x20, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x73, 0x20, 0x61, 0x73, 0x0a, 0x20, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x68, 0x74, 0x74, + 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x73, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x63, 0x6f, 0x6c, 0x2d, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x73, 0x2f, 0x64, 0x6f, 0x63, 0x73, + 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x23, 0x73, 0x63, 0x61, 0x6c, 0x61, 0x72, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x08, 0x00, 0x01, 0x12, 0x03, 0x0f, 0x08, 0x0d, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x10, 0x04, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x05, 0x12, 0x03, 0x10, 0x04, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x10, 0x0a, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x10, 0x14, 0x15, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x11, 0x04, + 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x11, 0x04, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x11, 0x0b, 0x16, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x11, 0x19, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x02, 0x12, 0x03, 0x12, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, + 0x05, 0x12, 0x03, 0x12, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x12, 0x0b, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x12, + 0x1a, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x13, 0x04, 0x15, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x05, 0x12, 0x03, 0x13, 0x04, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x13, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x13, 0x13, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x04, 0x12, 0x03, 0x14, 0x04, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x06, 0x12, + 0x03, 0x14, 0x04, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x14, + 0x1e, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, 0x14, 0x29, 0x2a, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x15, 0x04, 0x2a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x05, 0x06, 0x12, 0x03, 0x15, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x15, 0x1d, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x05, 0x03, 0x12, 0x03, 0x15, 0x28, 0x29, 0x0a, 0xc3, 0x01, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x03, + 0x1b, 0x00, 0x0f, 0x1a, 0xb7, 0x01, 0x20, 0x55, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x64, + 0x65, 0x6e, 0x6f, 0x74, 0x65, 0x20, 0x61, 0x20, 0x6e, 0x69, 0x6c, 0x2f, 0x6e, 0x75, 0x6c, 0x6c, + 0x2f, 0x4e, 0x6f, 0x6e, 0x65, 0x20, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, + 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x73, 0x63, 0x61, 0x6c, 0x61, 0x72, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, 0x79, 0x69, + 0x6e, 0x67, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x56, 0x6f, 0x69, 0x64, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x0a, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x65, 0x64, 0x20, 0x73, 0x69, 0x6e, 0x63, 0x65, 0x20, 0x69, 0x74, 0x20, 0x63, 0x61, 0x6e, + 0x20, 0x62, 0x65, 0x20, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x61, 0x20, 0x73, 0x63, 0x61, 0x6c, 0x61, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x79, 0x20, + 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x1b, 0x08, 0x0c, 0x0a, 0xf0, 0x01, 0x0a, 0x02, 0x04, 0x02, + 0x12, 0x04, 0x1f, 0x00, 0x22, 0x01, 0x1a, 0xe3, 0x01, 0x20, 0x52, 0x65, 0x66, 0x65, 0x72, 0x73, + 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6e, 0x20, 0x6f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, + 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x2e, 0x20, 0x49, + 0x74, 0x20, 0x65, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x74, 0x6f, 0x72, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, + 0x65, 0x20, 0x75, 0x72, 0x69, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x69, 0x73, 0x2e, 0x0a, 0x20, 0x54, 0x68, + 0x65, 0x72, 0x65, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6e, 0x6f, 0x20, 0x72, 0x65, 0x73, 0x74, 0x72, + 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x6e, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x75, 0x72, 0x69, 0x20, 0x69, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, + 0x74, 0x65, 0x64, 0x20, 0x73, 0x69, 0x6e, 0x63, 0x65, 0x20, 0x69, 0x74, 0x20, 0x77, 0x69, 0x6c, + 0x6c, 0x20, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x68, 0x6f, 0x77, 0x20, + 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x61, 0x63, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x02, 0x01, 0x12, 0x03, 0x1f, 0x08, 0x0c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, + 0x12, 0x03, 0x20, 0x02, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, 0x03, + 0x20, 0x02, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x20, 0x0f, + 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x20, 0x1a, 0x1b, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x21, 0x02, 0x11, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x01, 0x05, 0x12, 0x03, 0x21, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x21, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x21, 0x0f, 0x10, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x24, 0x00, + 0x26, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x24, 0x08, 0x14, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x25, 0x02, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x25, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x25, 0x0b, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x25, 0x12, 0x13, 0x0a, 0xf7, 0x01, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x2a, 0x00, + 0x2d, 0x01, 0x1a, 0xea, 0x01, 0x20, 0x41, 0x20, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x62, + 0x79, 0x74, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, + 0x20, 0x74, 0x61, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x68, 0x65, 0x6c, 0x70, 0x20, 0x64, 0x69, 0x66, + 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x70, 0x61, 0x72, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, + 0x6e, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x77, 0x68, 0x61, + 0x74, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, + 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x0a, 0x20, 0x49, 0x74, 0x27, 0x73, 0x20, 0x73, 0x74, + 0x72, 0x6f, 0x6e, 0x67, 0x6c, 0x79, 0x20, 0x61, 0x64, 0x76, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x72, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x64, 0x65, 0x66, + 0x69, 0x6e, 0x65, 0x20, 0x61, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x74, 0x61, 0x67, + 0x20, 0x61, 0x6e, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x74, 0x61, 0x67, 0x20, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x70, 0x61, 0x72, + 0x73, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x2a, 0x08, 0x0e, 0x0a, 0x76, 0x0a, 0x04, 0x04, + 0x04, 0x02, 0x00, 0x12, 0x03, 0x2b, 0x02, 0x12, 0x22, 0x69, 0x20, 0x53, 0x65, 0x72, 0x69, 0x61, + 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x28, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x50, 0x61, 0x63, 0x6b, 0x29, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x75, 0x70, + 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x6c, 0x69, 0x6b, + 0x65, 0x20, 0x44, 0x61, 0x74, 0x61, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x2c, 0x20, 0x50, 0x79, 0x64, + 0x61, 0x6e, 0x74, 0x69, 0x63, 0x20, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x2c, + 0x20, 0x61, 0x6e, 0x64, 0x20, 0x75, 0x6e, 0x74, 0x79, 0x70, 0x65, 0x64, 0x20, 0x64, 0x69, 0x63, + 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x05, 0x12, 0x03, 0x2b, 0x02, + 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2b, 0x08, 0x0d, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x2b, 0x10, 0x11, 0x0a, 0x94, 0x01, + 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x2c, 0x02, 0x11, 0x22, 0x86, 0x01, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x2c, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x50, 0x61, 0x63, 0x6b, 0x29, 0x2e, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x72, + 0x73, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x20, 0x75, 0x6e, + 0x69, 0x71, 0x75, 0x65, 0x20, 0x74, 0x61, 0x67, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x6d, 0x20, 0x62, 0x65, 0x66, 0x6f, + 0x72, 0x65, 0x20, 0x64, 0x65, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x05, 0x12, 0x03, 0x2c, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x2c, 0x09, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x2c, 0x0f, 0x10, 0x0a, 0x76, + 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x30, 0x00, 0x33, 0x01, 0x1a, 0x6a, 0x20, 0x41, 0x20, 0x73, + 0x74, 0x72, 0x6f, 0x6e, 0x67, 0x6c, 0x79, 0x20, 0x74, 0x79, 0x70, 0x65, 0x64, 0x20, 0x73, 0x63, + 0x68, 0x65, 0x6d, 0x61, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, + 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, + 0x6c, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x20, 0x6d, 0x65, + 0x64, 0x69, 0x75, 0x6d, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x30, + 0x08, 0x0e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x31, 0x02, 0x11, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x05, 0x12, 0x03, 0x31, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x31, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x31, 0x0f, 0x10, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, + 0x01, 0x12, 0x03, 0x32, 0x02, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x06, 0x12, + 0x03, 0x32, 0x02, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, 0x12, 0x03, 0x32, + 0x0d, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x03, 0x32, 0x14, 0x15, + 0x0a, 0x63, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x04, 0x36, 0x00, 0x39, 0x01, 0x1a, 0x57, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, + 0x73, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x74, + 0x61, 0x67, 0x67, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x2e, 0x20, 0x53, 0x65, 0x65, 0x20, 0x60, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, + 0x65, 0x60, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x64, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x03, 0x36, 0x08, + 0x0d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x03, 0x37, 0x02, 0x14, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x06, 0x12, 0x03, 0x37, 0x02, 0x09, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x03, 0x37, 0x0a, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x37, 0x12, 0x13, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x01, + 0x12, 0x03, 0x38, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x06, 0x12, 0x03, + 0x38, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x01, 0x12, 0x03, 0x38, 0x0e, + 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x03, 0x12, 0x03, 0x38, 0x15, 0x16, 0x0a, + 0x0a, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x04, 0x3b, 0x00, 0x44, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x07, 0x01, 0x12, 0x03, 0x3b, 0x08, 0x21, 0x0a, 0xcf, 0x04, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, + 0x12, 0x03, 0x43, 0x02, 0x34, 0x1a, 0xc1, 0x04, 0x20, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x6c, 0x6f, 0x6e, 0x67, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2e, 0x0a, 0x20, 0x54, 0x68, + 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x68, 0x65, 0x72, 0x65, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, + 0x73, 0x65, 0x20, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x44, 0x61, 0x74, + 0x61, 0x73, 0x65, 0x74, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x6f, 0x66, 0x74, 0x65, 0x6e, 0x20, + 0x62, 0x65, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, + 0x61, 0x74, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x61, 0x74, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, + 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x2c, 0x20, 0x61, 0x74, 0x20, 0x63, + 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x79, 0x6f, 0x75, 0x20, + 0x6d, 0x69, 0x67, 0x68, 0x74, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x64, 0x65, 0x63, 0x6c, 0x61, + 0x72, 0x65, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x74, + 0x75, 0x72, 0x6e, 0x20, 0x61, 0x20, 0x70, 0x61, 0x6e, 0x64, 0x61, 0x73, 0x20, 0x64, 0x61, 0x74, + 0x61, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x53, 0x74, 0x72, 0x75, + 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x2c, 0x0a, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x6f, 0x6c, 0x75, + 0x6d, 0x6e, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, + 0x62, 0x75, 0x74, 0x20, 0x61, 0x74, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2c, + 0x20, 0x79, 0x6f, 0x75, 0x20, 0x6d, 0x69, 0x67, 0x68, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x20, 0x69, 0x6e, 0x66, 0x6f, + 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6b, + 0x69, 0x74, 0x20, 0x70, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x63, + 0x6f, 0x70, 0x79, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x69, 0x6e, + 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x2c, 0x20, 0x66, 0x72, 0x6f, 0x6d, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x70, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, + 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x20, 0x28, + 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x72, 0x73, 0x29, 0x2e, 0x0a, 0x20, 0x53, 0x69, 0x6e, 0x63, + 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, + 0x72, 0x75, 0x6e, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, + 0x65, 0x64, 0x2c, 0x20, 0x69, 0x74, 0x27, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x75, 0x73, 0x65, + 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x63, + 0x68, 0x65, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x43, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x43, 0x18, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x43, 0x32, 0x33, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x04, 0x46, 0x00, 0x4c, 0x01, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x08, 0x01, 0x12, 0x03, 0x46, 0x08, 0x19, 0x0a, 0x90, 0x01, 0x0a, 0x04, + 0x04, 0x08, 0x02, 0x00, 0x12, 0x03, 0x49, 0x02, 0x11, 0x1a, 0x82, 0x01, 0x20, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x75, 0x6e, 0x69, + 0x71, 0x75, 0x65, 0x6c, 0x79, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x79, 0x69, 0x6e, + 0x67, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, + 0x20, 0x69, 0x73, 0x2e, 0x0a, 0x20, 0x53, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x6f, 0x72, + 0x61, 0x67, 0x65, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x65, 0x2e, + 0x67, 0x2e, 0x20, 0x73, 0x33, 0x3a, 0x2f, 0x2f, 0x2c, 0x20, 0x67, 0x73, 0x3a, 0x2f, 0x2f, 0x2c, + 0x20, 0x62, 0x71, 0x3a, 0x2f, 0x2f, 0x2c, 0x20, 0x65, 0x74, 0x63, 0x2e, 0x29, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x05, 0x12, 0x03, 0x49, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x03, 0x49, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x49, 0x0f, 0x10, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x01, + 0x12, 0x03, 0x4b, 0x02, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x06, 0x12, 0x03, + 0x4b, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x01, 0x12, 0x03, 0x4b, 0x1c, + 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x03, 0x12, 0x03, 0x4b, 0x27, 0x28, 0x0a, + 0x0a, 0x0a, 0x02, 0x04, 0x09, 0x12, 0x04, 0x4e, 0x00, 0x5a, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x09, 0x01, 0x12, 0x03, 0x4e, 0x08, 0x0e, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x09, 0x08, 0x00, 0x12, + 0x04, 0x4f, 0x02, 0x59, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x08, 0x00, 0x01, 0x12, 0x03, + 0x4f, 0x08, 0x0d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x00, 0x12, 0x03, 0x50, 0x04, 0x1c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x06, 0x12, 0x03, 0x50, 0x04, 0x0d, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x03, 0x50, 0x0e, 0x17, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, 0x03, 0x50, 0x1a, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x09, + 0x02, 0x01, 0x12, 0x03, 0x51, 0x04, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x06, + 0x12, 0x03, 0x51, 0x04, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x51, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x03, 0x12, 0x03, 0x51, 0x10, + 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x02, 0x12, 0x03, 0x52, 0x04, 0x16, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x06, 0x12, 0x03, 0x52, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x09, 0x02, 0x02, 0x01, 0x12, 0x03, 0x52, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x02, 0x03, 0x12, 0x03, 0x52, 0x14, 0x15, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x03, + 0x12, 0x03, 0x53, 0x04, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, 0x06, 0x12, 0x03, + 0x53, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, 0x01, 0x12, 0x03, 0x53, 0x0b, + 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, 0x03, 0x12, 0x03, 0x53, 0x14, 0x15, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x04, 0x12, 0x03, 0x54, 0x04, 0x17, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x09, 0x02, 0x04, 0x06, 0x12, 0x03, 0x54, 0x04, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x04, 0x01, 0x12, 0x03, 0x54, 0x09, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x04, + 0x03, 0x12, 0x03, 0x54, 0x15, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x05, 0x12, 0x03, + 0x55, 0x04, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x05, 0x06, 0x12, 0x03, 0x55, 0x04, + 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x05, 0x01, 0x12, 0x03, 0x55, 0x0a, 0x0f, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x05, 0x03, 0x12, 0x03, 0x55, 0x12, 0x13, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x09, 0x02, 0x06, 0x12, 0x03, 0x56, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x06, 0x06, 0x12, 0x03, 0x56, 0x04, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x06, + 0x01, 0x12, 0x03, 0x56, 0x1b, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x06, 0x03, 0x12, + 0x03, 0x56, 0x25, 0x26, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x07, 0x12, 0x03, 0x57, 0x04, + 0x2d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x07, 0x06, 0x12, 0x03, 0x57, 0x04, 0x15, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x07, 0x01, 0x12, 0x03, 0x57, 0x16, 0x28, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x09, 0x02, 0x07, 0x03, 0x12, 0x03, 0x57, 0x2b, 0x2c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x09, 0x02, 0x08, 0x12, 0x03, 0x58, 0x04, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x08, + 0x06, 0x12, 0x03, 0x58, 0x04, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x08, 0x01, 0x12, + 0x03, 0x58, 0x0a, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x08, 0x03, 0x12, 0x03, 0x58, + 0x12, 0x13, 0x0a, 0x86, 0x01, 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x04, 0x5d, 0x00, 0x75, 0x01, 0x1a, + 0x7a, 0x20, 0x41, 0x20, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x20, + 0x61, 0x6e, 0x79, 0x20, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x20, 0x6f, 0x66, 0x20, 0x6e, 0x65, 0x73, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, + 0x20, 0x6f, 0x66, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x72, 0x72, + 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x42, 0x6c, 0x6f, 0x62, 0x73, 0x29, 0x20, 0x61, 0x73, 0x20, + 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x61, 0x73, 0x20, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x70, + 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x0a, 0x01, 0x12, 0x03, 0x5d, 0x08, 0x0f, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x0a, 0x09, 0x12, 0x03, + 0x5e, 0x02, 0x10, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x0a, 0x09, 0x00, 0x12, 0x03, 0x5e, 0x0b, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x09, 0x00, 0x01, 0x12, 0x03, 0x5e, 0x0b, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x0a, 0x09, 0x00, 0x02, 0x12, 0x03, 0x5e, 0x0b, 0x0c, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x0a, 0x09, 0x01, 0x12, 0x03, 0x5e, 0x0e, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x09, + 0x01, 0x01, 0x12, 0x03, 0x5e, 0x0e, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x09, 0x01, 0x02, + 0x12, 0x03, 0x5e, 0x0e, 0x0f, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0a, 0x08, 0x00, 0x12, 0x04, 0x5f, + 0x02, 0x6c, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x08, 0x00, 0x01, 0x12, 0x03, 0x5f, 0x08, + 0x0d, 0x0a, 0x1e, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x00, 0x12, 0x03, 0x61, 0x04, 0x16, 0x1a, 0x11, + 0x20, 0x41, 0x20, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x06, 0x12, 0x03, 0x61, 0x04, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x03, 0x61, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, 0x03, 0x61, 0x14, 0x15, 0x0a, 0x39, 0x0a, 0x04, 0x04, + 0x0a, 0x02, 0x01, 0x12, 0x03, 0x64, 0x04, 0x25, 0x1a, 0x2c, 0x20, 0x41, 0x20, 0x63, 0x6f, 0x6c, + 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, + 0x61, 0x6c, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x20, 0x6e, 0x65, 0x73, + 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x06, 0x12, + 0x03, 0x64, 0x04, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x01, 0x12, 0x03, 0x64, + 0x16, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x03, 0x12, 0x03, 0x64, 0x23, 0x24, + 0x0a, 0x2c, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x02, 0x12, 0x03, 0x67, 0x04, 0x17, 0x1a, 0x1f, 0x20, + 0x41, 0x20, 0x6d, 0x61, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x73, + 0x20, 0x74, 0x6f, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x06, 0x12, 0x03, 0x67, 0x04, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x0a, 0x02, 0x02, 0x01, 0x12, 0x03, 0x67, 0x0f, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, + 0x02, 0x02, 0x03, 0x12, 0x03, 0x67, 0x15, 0x16, 0x0a, 0xba, 0x01, 0x0a, 0x04, 0x04, 0x0a, 0x02, + 0x03, 0x12, 0x03, 0x6b, 0x04, 0x34, 0x1a, 0xac, 0x01, 0x20, 0x4f, 0x66, 0x66, 0x6c, 0x6f, 0x61, + 0x64, 0x65, 0x64, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x0a, 0x20, 0x57, 0x68, 0x65, 0x6e, 0x20, 0x79, 0x6f, 0x75, 0x20, 0x64, + 0x65, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, + 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x69, 0x74, + 0x73, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, + 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x72, + 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6e, + 0x20, 0x6f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, 0x06, 0x12, 0x03, + 0x6b, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x6b, 0x1d, + 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, 0x03, 0x12, 0x03, 0x6b, 0x32, 0x33, 0x0a, + 0xd9, 0x01, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x04, 0x12, 0x03, 0x71, 0x02, 0x12, 0x1a, 0xcb, 0x01, + 0x20, 0x41, 0x20, 0x68, 0x61, 0x73, 0x68, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, + 0x6c, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x63, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x70, 0x75, 0x72, + 0x70, 0x6f, 0x73, 0x65, 0x73, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, + 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x20, 0x74, 0x6f, + 0x20, 0x52, 0x46, 0x43, 0x20, 0x31, 0x38, 0x39, 0x33, 0x0a, 0x20, 0x28, 0x68, 0x74, 0x74, 0x70, + 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x62, 0x6c, + 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x2f, 0x72, 0x66, 0x63, 0x2f, 0x73, 0x79, + 0x73, 0x74, 0x65, 0x6d, 0x2f, 0x31, 0x38, 0x39, 0x33, 0x2d, 0x63, 0x61, 0x63, 0x68, 0x69, 0x6e, + 0x67, 0x2d, 0x6f, 0x66, 0x2d, 0x6f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x2d, 0x6f, + 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2e, 0x6d, 0x64, 0x29, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x0a, 0x02, 0x04, 0x05, 0x12, 0x03, 0x71, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, + 0x04, 0x01, 0x12, 0x03, 0x71, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x04, 0x03, + 0x12, 0x03, 0x71, 0x10, 0x11, 0x0a, 0x30, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x05, 0x12, 0x03, 0x74, + 0x02, 0x23, 0x1a, 0x23, 0x20, 0x41, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6c, 0x69, 0x74, + 0x65, 0x72, 0x61, 0x6c, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x05, 0x06, + 0x12, 0x03, 0x74, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x05, 0x01, 0x12, 0x03, + 0x74, 0x16, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x05, 0x03, 0x12, 0x03, 0x74, 0x21, + 0x22, 0x0a, 0x4a, 0x0a, 0x02, 0x04, 0x0b, 0x12, 0x05, 0x78, 0x00, 0x81, 0x01, 0x01, 0x1a, 0x3d, + 0x20, 0x41, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x66, 0x66, + 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x0b, 0x01, 0x12, 0x03, 0x78, 0x08, 0x20, 0x0a, 0x3a, 0x0a, 0x04, 0x04, 0x0b, 0x02, + 0x00, 0x12, 0x03, 0x7a, 0x02, 0x11, 0x1a, 0x2d, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x66, 0x66, + 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, + 0x72, 0x61, 0x6c, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x7a, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x01, 0x12, 0x03, 0x7a, 0x09, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x03, 0x12, 0x03, 0x7a, 0x0f, 0x10, 0x0a, + 0x2e, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x01, 0x12, 0x03, 0x7d, 0x02, 0x18, 0x1a, 0x21, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x73, 0x69, 0x7a, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, + 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x05, 0x12, 0x03, 0x7d, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x0b, 0x02, 0x01, 0x01, 0x12, 0x03, 0x7d, 0x09, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x0b, 0x02, 0x01, 0x03, 0x12, 0x03, 0x7d, 0x16, 0x17, 0x0a, 0x40, 0x0a, 0x04, 0x04, 0x0b, 0x02, + 0x02, 0x12, 0x04, 0x80, 0x01, 0x02, 0x20, 0x1a, 0x32, 0x20, 0x54, 0x68, 0x65, 0x20, 0x69, 0x6e, + 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x74, + 0x79, 0x70, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x66, 0x66, 0x6c, 0x6f, + 0x61, 0x64, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0b, 0x02, 0x02, 0x06, 0x12, 0x04, 0x80, 0x01, 0x02, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, + 0x02, 0x02, 0x01, 0x12, 0x04, 0x80, 0x01, 0x0e, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, + 0x02, 0x03, 0x12, 0x04, 0x80, 0x01, 0x1e, 0x1f, 0x0a, 0x7e, 0x0a, 0x02, 0x04, 0x0c, 0x12, 0x06, + 0x84, 0x01, 0x00, 0x86, 0x01, 0x01, 0x1a, 0x70, 0x20, 0x41, 0x20, 0x63, 0x6f, 0x6c, 0x6c, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, + 0x73, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x77, 0x6f, 0x72, + 0x6b, 0x61, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x73, 0x69, 0x6e, 0x63, 0x65, 0x20, 0x6f, 0x6e, + 0x65, 0x6f, 0x66, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0c, 0x01, 0x12, + 0x04, 0x84, 0x01, 0x08, 0x19, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x00, 0x12, 0x04, 0x85, + 0x01, 0x02, 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x04, 0x12, 0x04, 0x85, 0x01, + 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x06, 0x12, 0x04, 0x85, 0x01, 0x0b, + 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x01, 0x12, 0x04, 0x85, 0x01, 0x13, 0x1b, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x03, 0x12, 0x04, 0x85, 0x01, 0x1e, 0x1f, 0x0a, + 0x77, 0x0a, 0x02, 0x04, 0x0d, 0x12, 0x06, 0x89, 0x01, 0x00, 0x8b, 0x01, 0x01, 0x1a, 0x69, 0x20, + 0x41, 0x20, 0x6d, 0x61, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, + 0x73, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x77, 0x6f, 0x72, + 0x6b, 0x61, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x73, 0x69, 0x6e, 0x63, 0x65, 0x20, 0x6f, 0x6e, + 0x65, 0x6f, 0x66, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0d, 0x01, 0x12, + 0x04, 0x89, 0x01, 0x08, 0x12, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x00, 0x12, 0x04, 0x8a, + 0x01, 0x02, 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x06, 0x12, 0x04, 0x8a, 0x01, + 0x02, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x01, 0x12, 0x04, 0x8a, 0x01, 0x17, + 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x03, 0x12, 0x04, 0x8a, 0x01, 0x22, 0x23, + 0x0a, 0x32, 0x0a, 0x02, 0x04, 0x0e, 0x12, 0x06, 0x8e, 0x01, 0x00, 0x90, 0x01, 0x01, 0x1a, 0x24, + 0x20, 0x41, 0x20, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, + 0x20, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x20, 0x69, 0x74, 0x65, + 0x6d, 0x73, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0e, 0x01, 0x12, 0x04, 0x8e, 0x01, 0x08, + 0x1d, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x00, 0x12, 0x04, 0x8f, 0x01, 0x02, 0x24, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x04, 0x12, 0x04, 0x8f, 0x01, 0x02, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x06, 0x12, 0x04, 0x8f, 0x01, 0x0b, 0x16, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x00, 0x01, 0x12, 0x04, 0x8f, 0x01, 0x17, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x00, 0x03, 0x12, 0x04, 0x8f, 0x01, 0x22, 0x23, 0x0a, 0x2b, 0x0a, 0x02, 0x04, + 0x0f, 0x12, 0x06, 0x93, 0x01, 0x00, 0x95, 0x01, 0x01, 0x1a, 0x1d, 0x20, 0x41, 0x20, 0x6d, 0x61, + 0x70, 0x20, 0x6f, 0x66, 0x20, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, + 0x20, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0f, 0x01, 0x12, + 0x04, 0x93, 0x01, 0x08, 0x16, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x00, 0x12, 0x04, 0x94, + 0x01, 0x02, 0x28, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x06, 0x12, 0x04, 0x94, 0x01, + 0x02, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x01, 0x12, 0x04, 0x94, 0x01, 0x1b, + 0x23, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x03, 0x12, 0x04, 0x94, 0x01, 0x26, 0x27, + 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x10, 0x12, 0x06, 0x97, 0x01, 0x00, 0x99, 0x01, 0x01, 0x0a, 0x0b, + 0x0a, 0x03, 0x04, 0x10, 0x01, 0x12, 0x04, 0x97, 0x01, 0x08, 0x11, 0x0a, 0x0c, 0x0a, 0x04, 0x04, + 0x10, 0x02, 0x00, 0x12, 0x04, 0x98, 0x01, 0x02, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, + 0x00, 0x06, 0x12, 0x04, 0x98, 0x01, 0x02, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, + 0x01, 0x12, 0x04, 0x98, 0x01, 0x0e, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, 0x03, + 0x12, 0x04, 0x98, 0x01, 0x1b, 0x1c, 0x0a, 0x51, 0x0a, 0x02, 0x04, 0x11, 0x12, 0x06, 0x9c, 0x01, + 0x00, 0xb2, 0x01, 0x01, 0x1a, 0x43, 0x20, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x72, 0x65, 0x66, 0x65, + 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, + 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x11, 0x01, + 0x12, 0x04, 0x9c, 0x01, 0x08, 0x13, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x11, 0x08, 0x00, 0x12, 0x06, + 0x9d, 0x01, 0x02, 0xaf, 0x01, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x08, 0x00, 0x01, 0x12, + 0x04, 0x9d, 0x01, 0x08, 0x0d, 0x0a, 0x26, 0x0a, 0x04, 0x04, 0x11, 0x02, 0x00, 0x12, 0x04, 0x9f, + 0x01, 0x04, 0x16, 0x1a, 0x18, 0x20, 0x41, 0x20, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x73, + 0x63, 0x61, 0x6c, 0x61, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x11, 0x02, 0x00, 0x06, 0x12, 0x04, 0x9f, 0x01, 0x04, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x11, 0x02, 0x00, 0x01, 0x12, 0x04, 0x9f, 0x01, 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x11, 0x02, 0x00, 0x03, 0x12, 0x04, 0x9f, 0x01, 0x14, 0x15, 0x0a, 0x6b, 0x0a, 0x04, 0x04, 0x11, + 0x02, 0x01, 0x12, 0x04, 0xa3, 0x01, 0x04, 0x29, 0x1a, 0x5d, 0x20, 0x41, 0x20, 0x63, 0x6f, 0x6c, + 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x69, 0x6e, 0x64, 0x69, + 0x6e, 0x67, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x61, 0x6c, + 0x6c, 0x6f, 0x77, 0x73, 0x20, 0x6e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x66, 0x20, + 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x74, 0x6f, 0x20, + 0x61, 0x6e, 0x79, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x0a, 0x20, 0x6f, 0x66, 0x20, 0x6c, + 0x65, 0x76, 0x65, 0x6c, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x01, 0x06, + 0x12, 0x04, 0xa3, 0x01, 0x04, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x01, 0x01, 0x12, + 0x04, 0xa3, 0x01, 0x1a, 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x01, 0x03, 0x12, 0x04, + 0xa3, 0x01, 0x27, 0x28, 0x0a, 0x3e, 0x0a, 0x04, 0x04, 0x11, 0x02, 0x02, 0x12, 0x04, 0xa6, 0x01, + 0x04, 0x20, 0x1a, 0x30, 0x20, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x20, + 0x61, 0x6e, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x6d, 0x69, 0x73, + 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x6e, 0x6f, + 0x64, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x02, 0x06, 0x12, 0x04, 0xa6, + 0x01, 0x04, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x02, 0x01, 0x12, 0x04, 0xa6, 0x01, + 0x14, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x02, 0x03, 0x12, 0x04, 0xa6, 0x01, 0x1e, + 0x1f, 0x0a, 0x3e, 0x0a, 0x04, 0x04, 0x11, 0x02, 0x03, 0x12, 0x04, 0xa9, 0x01, 0x04, 0x1b, 0x1a, + 0x30, 0x20, 0x41, 0x20, 0x6d, 0x61, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x69, 0x6e, 0x64, 0x69, + 0x6e, 0x67, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x69, 0x73, 0x20, + 0x61, 0x6c, 0x77, 0x61, 0x79, 0x73, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x03, 0x06, 0x12, 0x04, 0xa9, 0x01, 0x04, 0x12, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x03, 0x01, 0x12, 0x04, 0xa9, 0x01, 0x13, 0x16, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x03, 0x03, 0x12, 0x04, 0xa9, 0x01, 0x19, 0x1a, 0x0a, 0x94, + 0x02, 0x0a, 0x04, 0x04, 0x11, 0x02, 0x04, 0x12, 0x04, 0xae, 0x01, 0x04, 0x34, 0x1a, 0x85, 0x02, + 0x20, 0x4f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, + 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x20, 0x57, 0x68, 0x65, + 0x6e, 0x20, 0x79, 0x6f, 0x75, 0x20, 0x64, 0x65, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x77, 0x6f, 0x75, + 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, + 0x20, 0x61, 0x6e, 0x64, 0x20, 0x69, 0x74, 0x73, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x77, 0x6f, + 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, + 0x79, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x20, 0x73, 0x74, + 0x6f, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x6f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, + 0x64, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x0a, 0x20, 0x55, 0x73, 0x65, + 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x64, 0x6f, 0x6e, 0x27, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x6d, + 0x69, 0x73, 0x65, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x75, 0x70, 0x73, 0x74, 0x72, 0x65, + 0x61, 0x6d, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x20, 0x73, 0x75, 0x63, 0x68, 0x20, 0x61, 0x73, + 0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x20, 0x73, 0x75, 0x62, 0x4e, 0x6f, + 0x64, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x04, 0x06, 0x12, 0x04, + 0xae, 0x01, 0x04, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x04, 0x01, 0x12, 0x04, 0xae, + 0x01, 0x1d, 0x2f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x04, 0x03, 0x12, 0x04, 0xae, 0x01, + 0x32, 0x33, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x11, 0x02, 0x05, 0x12, 0x04, 0xb1, 0x01, 0x02, 0x16, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x05, 0x06, 0x12, 0x04, 0xb1, 0x01, 0x02, 0x0b, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x05, 0x01, 0x12, 0x04, 0xb1, 0x01, 0x0c, 0x11, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x11, 0x02, 0x05, 0x03, 0x12, 0x04, 0xb1, 0x01, 0x14, 0x15, 0x0a, 0x5e, 0x0a, + 0x02, 0x04, 0x12, 0x12, 0x06, 0xb5, 0x01, 0x00, 0xbb, 0x01, 0x01, 0x1a, 0x50, 0x20, 0x41, 0x6e, + 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x2f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x62, 0x69, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, + 0x62, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x73, 0x74, + 0x61, 0x74, 0x69, 0x63, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x72, 0x20, 0x61, 0x20, + 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, + 0x03, 0x04, 0x12, 0x01, 0x12, 0x04, 0xb5, 0x01, 0x08, 0x0f, 0x0a, 0x4e, 0x0a, 0x04, 0x04, 0x12, + 0x02, 0x00, 0x12, 0x04, 0xb7, 0x01, 0x02, 0x11, 0x1a, 0x40, 0x20, 0x56, 0x61, 0x72, 0x69, 0x61, + 0x62, 0x6c, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x6d, 0x61, + 0x74, 0x63, 0x68, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x2f, 0x6f, 0x75, 0x74, + 0x70, 0x75, 0x74, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, + 0x02, 0x00, 0x05, 0x12, 0x04, 0xb7, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, + 0x00, 0x01, 0x12, 0x04, 0xb7, 0x01, 0x09, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x00, + 0x03, 0x12, 0x04, 0xb7, 0x01, 0x0f, 0x10, 0x0a, 0x32, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x01, 0x12, + 0x04, 0xba, 0x01, 0x02, 0x1a, 0x1a, 0x24, 0x20, 0x44, 0x61, 0x74, 0x61, 0x20, 0x74, 0x6f, 0x20, + 0x75, 0x73, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x69, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x12, 0x02, 0x01, 0x06, 0x12, 0x04, 0xba, 0x01, 0x02, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, + 0x02, 0x01, 0x01, 0x12, 0x04, 0xba, 0x01, 0x0e, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, + 0x01, 0x03, 0x12, 0x04, 0xba, 0x01, 0x18, 0x19, 0x0a, 0x29, 0x0a, 0x02, 0x04, 0x13, 0x12, 0x06, + 0xbe, 0x01, 0x00, 0xc4, 0x01, 0x01, 0x1a, 0x1b, 0x20, 0x41, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, + 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x70, 0x61, 0x69, + 0x72, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x13, 0x01, 0x12, 0x04, 0xbe, 0x01, 0x08, 0x14, + 0x0a, 0x18, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x00, 0x12, 0x04, 0xc0, 0x01, 0x02, 0x11, 0x1a, 0x0a, + 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, + 0x02, 0x00, 0x05, 0x12, 0x04, 0xc0, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, + 0x00, 0x01, 0x12, 0x04, 0xc0, 0x01, 0x09, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x00, + 0x03, 0x12, 0x04, 0xc0, 0x01, 0x0f, 0x10, 0x0a, 0x19, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x01, 0x12, + 0x04, 0xc3, 0x01, 0x02, 0x13, 0x1a, 0x0b, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x01, 0x05, 0x12, 0x04, 0xc3, 0x01, 0x02, + 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x01, 0x01, 0x12, 0x04, 0xc3, 0x01, 0x09, 0x0e, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x01, 0x03, 0x12, 0x04, 0xc3, 0x01, 0x11, 0x12, 0x0a, + 0x42, 0x0a, 0x02, 0x04, 0x14, 0x12, 0x06, 0xc7, 0x01, 0x00, 0xcb, 0x01, 0x01, 0x1a, 0x34, 0x20, + 0x52, 0x65, 0x74, 0x72, 0x79, 0x20, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x20, 0x61, + 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, + 0x6e, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x75, 0x6e, 0x69, + 0x74, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x14, 0x01, 0x12, 0x04, 0xc7, 0x01, 0x08, 0x15, + 0x0a, 0xa3, 0x01, 0x0a, 0x04, 0x04, 0x14, 0x02, 0x00, 0x12, 0x04, 0xca, 0x01, 0x02, 0x15, 0x1a, + 0x94, 0x01, 0x20, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x74, + 0x72, 0x69, 0x65, 0x73, 0x2e, 0x20, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73, 0x20, 0x77, 0x69, + 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x64, 0x20, 0x77, + 0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6a, 0x6f, 0x62, 0x20, 0x66, 0x61, 0x69, 0x6c, + 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, + 0x61, 0x62, 0x6c, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x65, + 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x74, 0x72, 0x69, + 0x65, 0x73, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x73, 0x20, 0x74, + 0x6f, 0x20, 0x31, 0x30, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x00, 0x05, 0x12, + 0x04, 0xca, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x00, 0x01, 0x12, 0x04, + 0xca, 0x01, 0x09, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x00, 0x03, 0x12, 0x04, 0xca, + 0x01, 0x13, 0x14, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xbb, 0x19, 0x0a, 0x1e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x1a, 0x20, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x61, + 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, + 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, + 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xe9, 0x01, 0x0a, 0x08, + 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x2f, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, + 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x4a, 0x0a, 0x13, 0x61, + 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f, + 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, + 0x63, 0x74, 0x49, 0x44, 0x52, 0x11, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x50, 0x61, + 0x72, 0x74, 0x69, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x3e, 0x0a, 0x0c, 0x61, 0x72, 0x74, 0x69, 0x66, + 0x61, 0x63, 0x74, 0x5f, 0x74, 0x61, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, + 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x54, 0x61, 0x67, 0x52, 0x0b, 0x61, 0x72, 0x74, 0x69, + 0x66, 0x61, 0x63, 0x74, 0x54, 0x61, 0x67, 0x22, 0xaf, 0x01, 0x0a, 0x0b, 0x56, 0x61, 0x72, 0x69, + 0x61, 0x62, 0x6c, 0x65, 0x4d, 0x61, 0x70, 0x12, 0x48, 0x0a, 0x09, 0x76, 0x61, 0x72, 0x69, 0x61, + 0x62, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x56, 0x61, 0x72, 0x69, + 0x61, 0x62, 0x6c, 0x65, 0x4d, 0x61, 0x70, 0x2e, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, + 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x09, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, + 0x73, 0x1a, 0x56, 0x0a, 0x0e, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x7c, 0x0a, 0x0e, 0x54, 0x79, 0x70, + 0x65, 0x64, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x69, + 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x56, 0x61, 0x72, + 0x69, 0x61, 0x62, 0x6c, 0x65, 0x4d, 0x61, 0x70, 0x52, 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, + 0x12, 0x35, 0x0a, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x4d, 0x61, 0x70, 0x52, 0x07, + 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x22, 0x9d, 0x02, 0x0a, 0x09, 0x50, 0x61, 0x72, 0x61, + 0x6d, 0x65, 0x74, 0x65, 0x72, 0x12, 0x2a, 0x0a, 0x03, 0x76, 0x61, 0x72, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x03, 0x76, 0x61, + 0x72, 0x12, 0x33, 0x0a, 0x07, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x48, 0x00, 0x52, 0x07, 0x64, + 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x12, 0x1c, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, + 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x08, 0x72, 0x65, 0x71, 0x75, + 0x69, 0x72, 0x65, 0x64, 0x12, 0x46, 0x0a, 0x0e, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, + 0x5f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, + 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x48, 0x00, 0x52, 0x0d, 0x61, + 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x3d, 0x0a, 0x0b, + 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x44, 0x48, 0x00, 0x52, + 0x0a, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x64, 0x42, 0x0a, 0x0a, 0x08, 0x62, + 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x22, 0xb6, 0x01, 0x0a, 0x0c, 0x50, 0x61, 0x72, 0x61, + 0x6d, 0x65, 0x74, 0x65, 0x72, 0x4d, 0x61, 0x70, 0x12, 0x4c, 0x0a, 0x0a, 0x70, 0x61, 0x72, 0x61, + 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x50, 0x61, + 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x4d, 0x61, 0x70, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, + 0x65, 0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x61, + 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x1a, 0x58, 0x0a, 0x0f, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, + 0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2f, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x50, 0x61, 0x72, 0x61, + 0x6d, 0x65, 0x74, 0x65, 0x72, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, + 0x42, 0xb1, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x42, 0x0e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, + 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0xa2, 0x02, 0x03, + 0x46, 0x43, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x43, 0x6f, 0x72, 0x65, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x43, 0x6f, 0x72, 0x65, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, + 0x43, 0x6f, 0x72, 0x65, 0x4a, 0xfa, 0x0e, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x3f, 0x01, 0x0a, + 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, + 0x02, 0x00, 0x17, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x2a, 0x0a, 0x09, + 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x27, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, + 0x03, 0x06, 0x00, 0x24, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x08, 0x00, 0x49, 0x0a, 0x09, + 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x08, 0x00, 0x49, 0x0a, 0x30, 0x0a, 0x02, 0x04, 0x00, 0x12, + 0x04, 0x0b, 0x00, 0x17, 0x01, 0x1a, 0x24, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, + 0x61, 0x20, 0x73, 0x74, 0x72, 0x6f, 0x6e, 0x67, 0x6c, 0x79, 0x20, 0x74, 0x79, 0x70, 0x65, 0x64, + 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x00, 0x01, 0x12, 0x03, 0x0b, 0x08, 0x10, 0x0a, 0x25, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, + 0x03, 0x0d, 0x02, 0x17, 0x1a, 0x18, 0x20, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x20, + 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x0d, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0d, 0x0e, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x0d, 0x15, 0x16, 0x0a, 0x38, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, + 0x12, 0x03, 0x10, 0x02, 0x19, 0x1a, 0x2b, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x69, + 0x6e, 0x67, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, + 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x10, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x10, 0x09, 0x14, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x10, 0x17, 0x18, 0x0a, 0xbe, 0x01, 0x0a, + 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x14, 0x02, 0x2a, 0x1a, 0xb0, 0x01, 0x2b, 0x6f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x73, + 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x79, 0x20, 0x68, 0x6f, + 0x77, 0x20, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, + 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x20, + 0x74, 0x61, 0x67, 0x2c, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, + 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x73, 0x20, 0x28, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, + 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2f, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x29, 0x20, + 0x61, 0x72, 0x65, 0x20, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x14, 0x02, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x14, 0x12, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x02, 0x03, 0x12, 0x03, 0x14, 0x28, 0x29, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x03, 0x12, + 0x03, 0x16, 0x02, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x06, 0x12, 0x03, 0x16, + 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x16, 0x13, 0x1f, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x16, 0x22, 0x23, 0x0a, 0x20, + 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x1a, 0x00, 0x1d, 0x01, 0x1a, 0x14, 0x20, 0x41, 0x20, 0x6d, + 0x61, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x1a, 0x08, 0x13, 0x0a, 0x3c, 0x0a, 0x04, + 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x1c, 0x02, 0x26, 0x1a, 0x2f, 0x20, 0x44, 0x65, 0x66, 0x69, + 0x6e, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6d, 0x61, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x76, 0x61, 0x72, + 0x69, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x76, + 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x06, 0x12, 0x03, 0x1c, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x1c, 0x18, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x1c, 0x24, 0x25, 0x0a, 0x38, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x20, 0x00, 0x23, 0x01, + 0x1a, 0x2c, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x73, 0x74, 0x72, 0x6f, 0x6e, + 0x67, 0x6c, 0x79, 0x20, 0x74, 0x79, 0x70, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, + 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x20, 0x08, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, + 0x02, 0x00, 0x12, 0x03, 0x21, 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x21, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x21, 0x0e, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x21, 0x17, + 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x22, 0x02, 0x1a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, 0x03, 0x22, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x22, 0x0e, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x22, 0x18, 0x19, 0x0a, 0x8d, 0x01, 0x0a, 0x02, 0x04, 0x03, 0x12, + 0x04, 0x27, 0x00, 0x39, 0x01, 0x1a, 0x80, 0x01, 0x20, 0x41, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, + 0x65, 0x74, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, + 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x6c, 0x61, 0x75, 0x6e, 0x63, + 0x68, 0x20, 0x70, 0x6c, 0x61, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x68, 0x61, 0x73, 0x0a, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x20, 0x61, 0x62, 0x69, 0x6c, + 0x69, 0x74, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x61, 0x20, 0x64, 0x65, + 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x72, 0x20, 0x6d, + 0x61, 0x72, 0x6b, 0x20, 0x69, 0x74, 0x73, 0x65, 0x6c, 0x66, 0x20, 0x61, 0x73, 0x20, 0x72, 0x65, + 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, + 0x03, 0x27, 0x08, 0x11, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x29, 0x02, + 0x13, 0x1a, 0x4d, 0x2b, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x56, 0x61, 0x72, + 0x69, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, + 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x29, 0x02, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x29, 0x0b, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x29, 0x11, 0x12, 0x0a, 0x18, 0x0a, 0x04, 0x04, 0x03, + 0x08, 0x00, 0x12, 0x04, 0x2c, 0x02, 0x38, 0x03, 0x1a, 0x0a, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x61, 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x08, 0x00, 0x01, 0x12, 0x03, 0x2c, + 0x08, 0x10, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, 0x2e, 0x04, 0x18, 0x1a, + 0x46, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x61, 0x20, 0x64, 0x65, 0x66, 0x61, + 0x75, 0x6c, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x68, + 0x61, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x06, + 0x12, 0x03, 0x2e, 0x04, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x2e, 0x0c, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x2e, 0x16, + 0x17, 0x0a, 0x3d, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x02, 0x12, 0x03, 0x31, 0x04, 0x16, 0x1a, 0x30, + 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2c, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x66, 0x69, 0x6c, 0x6c, 0x65, 0x64, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x05, 0x12, 0x03, 0x31, 0x04, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x01, 0x12, 0x03, 0x31, 0x09, 0x11, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x02, 0x03, 0x12, 0x03, 0x31, 0x14, 0x15, 0x0a, 0x99, 0x01, 0x0a, 0x04, 0x04, + 0x03, 0x02, 0x03, 0x12, 0x03, 0x35, 0x04, 0x2a, 0x1a, 0x8b, 0x01, 0x20, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x20, 0x62, 0x61, 0x73, + 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x65, 0x78, 0x61, + 0x63, 0x74, 0x6c, 0x79, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, + 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x54, 0x79, 0x70, 0x65, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x0a, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x74, 0x79, 0x70, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x72, 0x69, + 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x06, 0x12, + 0x03, 0x35, 0x04, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x01, 0x12, 0x03, 0x35, + 0x17, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x03, 0x12, 0x03, 0x35, 0x28, 0x29, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x04, 0x12, 0x03, 0x37, 0x04, 0x24, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x04, 0x06, 0x12, 0x03, 0x37, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x04, 0x01, 0x12, 0x03, 0x37, 0x14, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x04, 0x03, 0x12, 0x03, 0x37, 0x22, 0x23, 0x0a, 0x22, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x3c, + 0x00, 0x3f, 0x01, 0x1a, 0x16, 0x20, 0x41, 0x20, 0x6d, 0x61, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x50, + 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x04, 0x01, 0x12, 0x03, 0x3c, 0x08, 0x14, 0x0a, 0x3e, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, + 0x03, 0x3e, 0x02, 0x28, 0x1a, 0x31, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x61, + 0x20, 0x6d, 0x61, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, + 0x72, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, + 0x65, 0x74, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x3e, 0x02, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x3e, 0x19, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x3e, 0x26, + 0x27, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0x80, 0xc6, 0x01, 0x0a, 0x1a, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x61, + 0x73, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, + 0x66, 0x61, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x6c, 0x69, 0x74, 0x65, 0x72, + 0x61, 0x6c, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, + 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xd3, 0x02, 0x0a, 0x09, 0x52, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x73, 0x12, 0x43, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x73, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, + 0x08, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x12, 0x3f, 0x0a, 0x06, 0x6c, 0x69, 0x6d, + 0x69, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x73, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x06, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x1a, 0x61, 0x0a, 0x0d, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x3a, 0x0a, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x73, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x61, 0x6d, + 0x65, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x5d, 0x0a, + 0x0c, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x0b, 0x0a, + 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x43, 0x50, + 0x55, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x47, 0x50, 0x55, 0x10, 0x02, 0x12, 0x0a, 0x0a, 0x06, + 0x4d, 0x45, 0x4d, 0x4f, 0x52, 0x59, 0x10, 0x03, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x54, 0x4f, 0x52, + 0x41, 0x47, 0x45, 0x10, 0x04, 0x12, 0x15, 0x0a, 0x11, 0x45, 0x50, 0x48, 0x45, 0x4d, 0x45, 0x52, + 0x41, 0x4c, 0x5f, 0x53, 0x54, 0x4f, 0x52, 0x41, 0x47, 0x45, 0x10, 0x05, 0x22, 0xc1, 0x02, 0x0a, + 0x0e, 0x47, 0x50, 0x55, 0x41, 0x63, 0x63, 0x65, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, + 0x16, 0x0a, 0x06, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x12, 0x26, 0x0a, 0x0d, 0x75, 0x6e, 0x70, 0x61, 0x72, + 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, + 0x52, 0x0d, 0x75, 0x6e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x12, + 0x27, 0x0a, 0x0e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x7a, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0d, 0x70, 0x61, 0x72, 0x74, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x4d, 0x0a, 0x0c, 0x64, 0x65, 0x76, 0x69, + 0x63, 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2a, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x47, 0x50, 0x55, 0x41, 0x63, 0x63, 0x65, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x44, + 0x65, 0x76, 0x69, 0x63, 0x65, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x52, 0x0b, 0x64, 0x65, 0x76, 0x69, + 0x63, 0x65, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x22, 0x5f, 0x0a, 0x0b, 0x44, 0x65, 0x76, 0x69, 0x63, + 0x65, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x0e, 0x0a, 0x0a, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, + 0x5f, 0x47, 0x50, 0x55, 0x10, 0x00, 0x12, 0x0e, 0x0a, 0x0a, 0x47, 0x4f, 0x4f, 0x47, 0x4c, 0x45, + 0x5f, 0x54, 0x50, 0x55, 0x10, 0x01, 0x12, 0x11, 0x0a, 0x0d, 0x41, 0x4d, 0x41, 0x5a, 0x4f, 0x4e, + 0x5f, 0x4e, 0x45, 0x55, 0x52, 0x4f, 0x4e, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, 0x41, 0x4d, 0x44, + 0x5f, 0x47, 0x50, 0x55, 0x10, 0x03, 0x12, 0x10, 0x0a, 0x0c, 0x48, 0x41, 0x42, 0x41, 0x4e, 0x41, + 0x5f, 0x47, 0x41, 0x55, 0x44, 0x49, 0x10, 0x04, 0x42, 0x16, 0x0a, 0x14, 0x70, 0x61, 0x72, 0x74, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x22, 0x6b, 0x0a, 0x0c, 0x53, 0x68, 0x61, 0x72, 0x65, 0x64, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, + 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x61, 0x74, 0x68, 0x12, + 0x1d, 0x0a, 0x0a, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1d, + 0x0a, 0x0a, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x09, 0x73, 0x69, 0x7a, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x9f, 0x01, + 0x0a, 0x11, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x73, 0x12, 0x47, 0x0a, 0x0f, 0x67, 0x70, 0x75, 0x5f, 0x61, 0x63, 0x63, 0x65, 0x6c, + 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x47, 0x50, + 0x55, 0x41, 0x63, 0x63, 0x65, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x0e, 0x67, 0x70, + 0x75, 0x41, 0x63, 0x63, 0x65, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x41, 0x0a, 0x0d, + 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x65, 0x64, 0x4d, 0x65, 0x6d, 0x6f, 0x72, + 0x79, 0x52, 0x0c, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x22, + 0xad, 0x01, 0x0a, 0x0f, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x12, 0x3f, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0e, 0x32, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, + 0x74, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x16, + 0x0a, 0x06, 0x66, 0x6c, 0x61, 0x76, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x66, 0x6c, 0x61, 0x76, 0x6f, 0x72, 0x22, 0x27, 0x0a, 0x0b, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, + 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x09, 0x0a, 0x05, 0x4f, 0x54, 0x48, 0x45, 0x52, 0x10, 0x00, + 0x12, 0x0d, 0x0a, 0x09, 0x46, 0x4c, 0x59, 0x54, 0x45, 0x5f, 0x53, 0x44, 0x4b, 0x10, 0x01, 0x22, + 0x81, 0x07, 0x0a, 0x0c, 0x54, 0x61, 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x12, 0x22, 0x0a, 0x0c, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, + 0x61, 0x62, 0x6c, 0x65, 0x12, 0x39, 0x0a, 0x07, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x07, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x12, + 0x33, 0x0a, 0x07, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x74, 0x69, 0x6d, + 0x65, 0x6f, 0x75, 0x74, 0x12, 0x37, 0x0a, 0x07, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x53, 0x74, 0x72, 0x61, + 0x74, 0x65, 0x67, 0x79, 0x52, 0x07, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73, 0x12, 0x2b, 0x0a, + 0x11, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, + 0x65, 0x72, 0x79, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x38, 0x0a, 0x18, 0x64, 0x65, + 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x16, 0x64, 0x65, + 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x12, 0x26, 0x0a, 0x0d, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, + 0x74, 0x69, 0x62, 0x6c, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x0d, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x12, 0x2d, 0x0a, 0x12, + 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x62, + 0x6c, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x11, 0x63, 0x61, 0x63, 0x68, 0x65, 0x53, + 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x3a, 0x0a, 0x04, 0x74, + 0x61, 0x67, 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x70, 0x6f, 0x64, 0x5f, 0x74, + 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0c, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0f, 0x70, 0x6f, 0x64, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x4e, + 0x61, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x17, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x69, 0x67, 0x6e, + 0x6f, 0x72, 0x65, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x76, 0x61, 0x72, 0x73, 0x18, 0x0d, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x14, 0x63, 0x61, 0x63, 0x68, 0x65, 0x49, 0x67, 0x6e, 0x6f, 0x72, + 0x65, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x56, 0x61, 0x72, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x69, 0x73, + 0x5f, 0x65, 0x61, 0x67, 0x65, 0x72, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x69, 0x73, + 0x45, 0x61, 0x67, 0x65, 0x72, 0x12, 0x41, 0x0a, 0x0e, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, + 0x65, 0x73, 0x5f, 0x64, 0x65, 0x63, 0x6b, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0d, 0x67, 0x65, 0x6e, 0x65, 0x72, + 0x61, 0x74, 0x65, 0x73, 0x44, 0x65, 0x63, 0x6b, 0x12, 0x3d, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x38, 0x73, 0x4f, + 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1e, 0x0a, 0x0a, 0x64, 0x65, 0x62, 0x75, 0x67, + 0x67, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x64, 0x65, 0x62, + 0x75, 0x67, 0x67, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x34, 0x0a, 0x09, 0x6c, 0x6f, 0x67, 0x5f, 0x6c, + 0x69, 0x6e, 0x6b, 0x73, 0x18, 0x12, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, + 0x4c, 0x6f, 0x67, 0x52, 0x08, 0x6c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x6b, 0x73, 0x1a, 0x37, 0x0a, + 0x09, 0x54, 0x61, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, + 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0x15, 0x0a, 0x13, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x72, + 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x4a, 0x04, 0x08, + 0x0a, 0x10, 0x0b, 0x22, 0xdf, 0x05, 0x0a, 0x0c, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x65, 0x6d, 0x70, + 0x6c, 0x61, 0x74, 0x65, 0x12, 0x2a, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x02, 0x69, 0x64, + 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x74, 0x79, 0x70, 0x65, 0x12, 0x38, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x3c, + 0x0a, 0x09, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, + 0x65, 0x52, 0x09, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x12, 0x2f, 0x0a, 0x06, + 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, + 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x06, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x12, 0x39, 0x0a, + 0x09, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x48, 0x00, 0x52, 0x09, 0x63, + 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x12, 0x31, 0x0a, 0x07, 0x6b, 0x38, 0x73, 0x5f, + 0x70, 0x6f, 0x64, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x38, 0x73, 0x50, 0x6f, + 0x64, 0x48, 0x00, 0x52, 0x06, 0x6b, 0x38, 0x73, 0x50, 0x6f, 0x64, 0x12, 0x27, 0x0a, 0x03, 0x73, + 0x71, 0x6c, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x71, 0x6c, 0x48, 0x00, 0x52, + 0x03, 0x73, 0x71, 0x6c, 0x12, 0x2a, 0x0a, 0x11, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x74, 0x79, 0x70, + 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x0f, 0x74, 0x61, 0x73, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x12, 0x4a, 0x0a, 0x10, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x78, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, 0x75, + 0x72, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, 0x0f, 0x73, 0x65, 0x63, + 0x75, 0x72, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x50, 0x0a, 0x12, + 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, + 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x52, 0x11, 0x65, 0x78, 0x74, + 0x65, 0x6e, 0x64, 0x65, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x12, 0x40, + 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x10, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x54, 0x61, 0x73, 0x6b, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x2e, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 0x1a, 0x39, 0x0a, 0x0b, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, + 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, + 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0x08, 0x0a, 0x06, 0x74, + 0x61, 0x72, 0x67, 0x65, 0x74, 0x22, 0x4a, 0x0a, 0x0d, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x65, 0x72, 0x50, 0x6f, 0x72, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0d, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x50, 0x6f, 0x72, 0x74, 0x12, 0x12, 0x0a, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x22, 0x82, 0x04, 0x0a, 0x09, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x12, + 0x14, 0x0a, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, + 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x12, + 0x12, 0x0a, 0x04, 0x61, 0x72, 0x67, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x04, 0x61, + 0x72, 0x67, 0x73, 0x12, 0x37, 0x0a, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x73, 0x52, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x12, 0x2e, 0x0a, 0x03, + 0x65, 0x6e, 0x76, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x65, 0x79, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x50, 0x61, 0x69, 0x72, 0x52, 0x03, 0x65, 0x6e, 0x76, 0x12, 0x38, 0x0a, 0x06, + 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x65, + 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x61, 0x69, 0x72, 0x42, 0x02, 0x18, 0x01, 0x52, 0x06, + 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x33, 0x0a, 0x05, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x18, + 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x50, 0x6f, 0x72, 0x74, 0x52, 0x05, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x12, 0x42, 0x0a, 0x0b, 0x64, + 0x61, 0x74, 0x61, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x4c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x52, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, + 0x4a, 0x0a, 0x0c, 0x61, 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, 0x72, 0x65, 0x18, + 0x0a, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x2e, 0x41, 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, 0x72, 0x65, 0x52, 0x0c, 0x61, + 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, 0x72, 0x65, 0x22, 0x49, 0x0a, 0x0c, 0x41, + 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, 0x72, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x55, + 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x41, 0x4d, 0x44, 0x36, + 0x34, 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05, 0x41, 0x52, 0x4d, 0x36, 0x34, 0x10, 0x02, 0x12, 0x0a, + 0x0a, 0x06, 0x41, 0x52, 0x4d, 0x5f, 0x56, 0x36, 0x10, 0x03, 0x12, 0x0a, 0x0a, 0x06, 0x41, 0x52, + 0x4d, 0x5f, 0x56, 0x37, 0x10, 0x04, 0x22, 0xb7, 0x02, 0x0a, 0x0a, 0x49, 0x4f, 0x53, 0x74, 0x72, + 0x61, 0x74, 0x65, 0x67, 0x79, 0x12, 0x4c, 0x0a, 0x0d, 0x64, 0x6f, 0x77, 0x6e, 0x6c, 0x6f, 0x61, + 0x64, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x27, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x4f, + 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x2e, 0x44, 0x6f, 0x77, 0x6e, 0x6c, 0x6f, 0x61, + 0x64, 0x4d, 0x6f, 0x64, 0x65, 0x52, 0x0c, 0x64, 0x6f, 0x77, 0x6e, 0x6c, 0x6f, 0x61, 0x64, 0x4d, + 0x6f, 0x64, 0x65, 0x12, 0x46, 0x0a, 0x0b, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x6d, 0x6f, + 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x4f, 0x53, 0x74, 0x72, 0x61, + 0x74, 0x65, 0x67, 0x79, 0x2e, 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x4d, 0x6f, 0x64, 0x65, 0x52, + 0x0a, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x4d, 0x6f, 0x64, 0x65, 0x22, 0x4c, 0x0a, 0x0c, 0x44, + 0x6f, 0x77, 0x6e, 0x6c, 0x6f, 0x61, 0x64, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x12, 0x0a, 0x0e, 0x44, + 0x4f, 0x57, 0x4e, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x45, 0x41, 0x47, 0x45, 0x52, 0x10, 0x00, 0x12, + 0x13, 0x0a, 0x0f, 0x44, 0x4f, 0x57, 0x4e, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x53, 0x54, 0x52, 0x45, + 0x41, 0x4d, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x44, 0x4f, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x44, + 0x4f, 0x57, 0x4e, 0x4c, 0x4f, 0x41, 0x44, 0x10, 0x02, 0x22, 0x45, 0x0a, 0x0a, 0x55, 0x70, 0x6c, + 0x6f, 0x61, 0x64, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x12, 0x0a, 0x0e, 0x55, 0x50, 0x4c, 0x4f, 0x41, + 0x44, 0x5f, 0x4f, 0x4e, 0x5f, 0x45, 0x58, 0x49, 0x54, 0x10, 0x00, 0x12, 0x10, 0x0a, 0x0c, 0x55, + 0x50, 0x4c, 0x4f, 0x41, 0x44, 0x5f, 0x45, 0x41, 0x47, 0x45, 0x52, 0x10, 0x01, 0x12, 0x11, 0x0a, + 0x0d, 0x44, 0x4f, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x55, 0x50, 0x4c, 0x4f, 0x41, 0x44, 0x10, 0x02, + 0x22, 0xa9, 0x02, 0x0a, 0x11, 0x44, 0x61, 0x74, 0x61, 0x4c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67, + 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, + 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x50, 0x61, 0x74, 0x68, 0x12, + 0x1f, 0x0a, 0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x50, 0x61, 0x74, 0x68, + 0x12, 0x4a, 0x0a, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x32, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x4c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, 0x70, 0x46, 0x6f, + 0x72, 0x6d, 0x61, 0x74, 0x52, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x3b, 0x0a, 0x0b, + 0x69, 0x6f, 0x5f, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x49, 0x4f, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x52, 0x0a, 0x69, + 0x6f, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x22, 0x31, 0x0a, 0x10, 0x4c, 0x69, 0x74, + 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, 0x70, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x08, 0x0a, + 0x04, 0x4a, 0x53, 0x4f, 0x4e, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x59, 0x41, 0x4d, 0x4c, 0x10, + 0x01, 0x12, 0x09, 0x0a, 0x05, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x10, 0x02, 0x22, 0xf5, 0x01, 0x0a, + 0x06, 0x4b, 0x38, 0x73, 0x50, 0x6f, 0x64, 0x12, 0x3d, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x38, 0x73, 0x4f, 0x62, + 0x6a, 0x65, 0x63, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x32, 0x0a, 0x08, 0x70, 0x6f, 0x64, 0x5f, 0x73, 0x70, + 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, + 0x74, 0x52, 0x07, 0x70, 0x6f, 0x64, 0x53, 0x70, 0x65, 0x63, 0x12, 0x42, 0x0a, 0x0b, 0x64, 0x61, + 0x74, 0x61, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x44, 0x61, 0x74, 0x61, 0x4c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x52, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x34, + 0x0a, 0x16, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x14, + 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x4e, 0x61, 0x6d, 0x65, 0x22, 0xab, 0x02, 0x0a, 0x11, 0x4b, 0x38, 0x73, 0x4f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x45, 0x0a, 0x06, 0x6c, 0x61, + 0x62, 0x65, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x38, 0x73, 0x4f, + 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4c, 0x61, + 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, + 0x73, 0x12, 0x54, 0x0a, 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x38, 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, + 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x61, 0x6e, 0x6e, 0x6f, + 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x39, 0x0a, 0x0b, 0x4c, 0x61, 0x62, 0x65, 0x6c, + 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x1a, 0x3e, 0x0a, 0x10, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x22, 0x93, 0x01, 0x0a, 0x03, 0x53, 0x71, 0x6c, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x74, + 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, + 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x35, 0x0a, 0x07, 0x64, 0x69, 0x61, 0x6c, + 0x65, 0x63, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x71, 0x6c, 0x2e, 0x44, + 0x69, 0x61, 0x6c, 0x65, 0x63, 0x74, 0x52, 0x07, 0x64, 0x69, 0x61, 0x6c, 0x65, 0x63, 0x74, 0x22, + 0x37, 0x0a, 0x07, 0x44, 0x69, 0x61, 0x6c, 0x65, 0x63, 0x74, 0x12, 0x0d, 0x0a, 0x09, 0x55, 0x4e, + 0x44, 0x45, 0x46, 0x49, 0x4e, 0x45, 0x44, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x41, 0x4e, 0x53, + 0x49, 0x10, 0x01, 0x12, 0x08, 0x0a, 0x04, 0x48, 0x49, 0x56, 0x45, 0x10, 0x02, 0x12, 0x09, 0x0a, + 0x05, 0x4f, 0x54, 0x48, 0x45, 0x52, 0x10, 0x03, 0x42, 0xad, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x42, + 0x0a, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x32, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, + 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, + 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, + 0x65, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x4a, 0xe9, 0x9d, 0x01, 0x0a, 0x07, 0x12, 0x05, + 0x00, 0x00, 0x9d, 0x03, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, + 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x17, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, + 0x03, 0x04, 0x00, 0x28, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x29, 0x0a, + 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, 0x28, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x03, + 0x12, 0x03, 0x07, 0x00, 0x27, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x04, 0x12, 0x03, 0x08, 0x00, 0x27, + 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x05, 0x12, 0x03, 0x09, 0x00, 0x28, 0x0a, 0x09, 0x0a, 0x02, 0x03, + 0x06, 0x12, 0x03, 0x0a, 0x00, 0x26, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x07, 0x12, 0x03, 0x0b, 0x00, + 0x28, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x0d, 0x00, 0x49, 0x0a, 0x09, 0x0a, 0x02, 0x08, + 0x0b, 0x12, 0x03, 0x0d, 0x00, 0x49, 0x0a, 0x9c, 0x01, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x11, + 0x00, 0x2d, 0x01, 0x1a, 0x8f, 0x01, 0x20, 0x41, 0x20, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x69, + 0x7a, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x20, + 0x74, 0x6f, 0x20, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x79, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x73, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x2e, 0x20, 0x54, + 0x68, 0x69, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, + 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, + 0x6c, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, + 0x0a, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x65, 0x6e, 0x67, 0x69, + 0x6e, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x11, 0x08, + 0x11, 0x0a, 0x25, 0x0a, 0x04, 0x04, 0x00, 0x04, 0x00, 0x12, 0x04, 0x13, 0x02, 0x1b, 0x03, 0x1a, + 0x17, 0x20, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x04, 0x00, + 0x01, 0x12, 0x03, 0x13, 0x07, 0x13, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, + 0x12, 0x03, 0x14, 0x04, 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x14, 0x04, 0x0b, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x02, + 0x12, 0x03, 0x14, 0x0e, 0x0f, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, 0x12, + 0x03, 0x15, 0x04, 0x0c, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x15, 0x04, 0x07, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, + 0x03, 0x15, 0x0a, 0x0b, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, + 0x16, 0x04, 0x0c, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x16, 0x04, 0x07, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, + 0x16, 0x0a, 0x0b, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x17, + 0x04, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x17, + 0x04, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x17, + 0x0d, 0x0e, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, 0x18, 0x04, + 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x18, 0x04, + 0x0b, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, 0x18, 0x0e, + 0x0f, 0x0a, 0x7d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x1a, 0x04, 0x1a, + 0x1a, 0x6e, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, + 0x73, 0x2d, 0x62, 0x61, 0x73, 0x65, 0x64, 0x20, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, + 0x6e, 0x74, 0x73, 0x2c, 0x20, 0x70, 0x6f, 0x64, 0x73, 0x20, 0x75, 0x73, 0x65, 0x20, 0x65, 0x70, + 0x68, 0x65, 0x6d, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x73, 0x74, + 0x6f, 0x72, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x63, 0x72, 0x61, 0x74, 0x63, + 0x68, 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x2c, 0x20, 0x63, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x67, + 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x0a, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x1a, 0x04, 0x15, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x05, 0x02, 0x12, 0x03, 0x1a, 0x18, 0x19, + 0x0a, 0x37, 0x0a, 0x04, 0x04, 0x00, 0x03, 0x00, 0x12, 0x04, 0x1e, 0x02, 0x25, 0x03, 0x1a, 0x29, + 0x20, 0x45, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x03, + 0x00, 0x01, 0x12, 0x03, 0x1e, 0x0a, 0x17, 0x0a, 0x1f, 0x0a, 0x06, 0x04, 0x00, 0x03, 0x00, 0x02, + 0x00, 0x12, 0x03, 0x20, 0x04, 0x1a, 0x1a, 0x10, 0x20, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, + 0x02, 0x00, 0x06, 0x12, 0x03, 0x20, 0x04, 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x20, 0x11, 0x15, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x20, 0x18, 0x19, 0x0a, 0x96, 0x01, 0x0a, 0x06, 0x04, 0x00, 0x03, + 0x00, 0x02, 0x01, 0x12, 0x03, 0x24, 0x04, 0x15, 0x1a, 0x86, 0x01, 0x20, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x20, 0x6b, 0x38, 0x73, 0x20, 0x71, 0x75, 0x61, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x20, + 0x53, 0x65, 0x65, 0x0a, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, + 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, + 0x65, 0x73, 0x2f, 0x61, 0x70, 0x69, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x72, 0x79, 0x2f, + 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x2f, 0x70, 0x6b, 0x67, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2f, 0x71, 0x75, 0x61, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x67, 0x6f, 0x23, 0x4c, 0x33, 0x30, 0x2d, 0x4c, 0x38, 0x30, + 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x24, 0x04, + 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x24, 0x0b, + 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x24, 0x13, + 0x14, 0x0a, 0x64, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x28, 0x02, 0x26, 0x1a, 0x57, + 0x20, 0x54, 0x68, 0x65, 0x20, 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x20, 0x73, 0x65, 0x74, + 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x20, 0x72, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x2e, 0x20, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x75, + 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x04, + 0x12, 0x03, 0x28, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, + 0x28, 0x0b, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x28, 0x19, + 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x28, 0x24, 0x25, 0x0a, + 0x8c, 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x2c, 0x02, 0x24, 0x1a, 0x7f, 0x20, + 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x61, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, + 0x20, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x6d, 0x69, + 0x6e, 0x2f, 0x6d, 0x61, 0x78, 0x29, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x77, 0x68, + 0x69, 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x63, 0x61, 0x6e, + 0x20, 0x72, 0x65, 0x6c, 0x69, 0x61, 0x62, 0x6c, 0x79, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x20, 0x52, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x20, 0x6d, 0x75, 0x73, + 0x74, 0x20, 0x62, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x0a, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x04, 0x12, 0x03, 0x2c, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x2c, 0x0b, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x2c, 0x19, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x2c, 0x22, 0x23, 0x0a, 0xb4, 0x01, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x32, + 0x00, 0x4e, 0x01, 0x1a, 0xa7, 0x01, 0x20, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, + 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x47, 0x50, 0x55, 0x20, 0x61, 0x63, 0x63, 0x65, 0x6c, 0x65, 0x72, 0x61, + 0x74, 0x6f, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x65, 0x20, + 0x74, 0x6f, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x73, 0x0a, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6d, 0x75, 0x6c, 0x74, + 0x69, 0x2d, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x47, 0x50, 0x55, 0x73, 0x2c, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, + 0x69, 0x7a, 0x65, 0x20, 0x74, 0x6f, 0x0a, 0x20, 0x75, 0x73, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x32, 0x08, 0x16, 0x0a, 0x3a, 0x0a, 0x04, 0x04, 0x01, 0x04, + 0x00, 0x12, 0x04, 0x34, 0x02, 0x3f, 0x03, 0x1a, 0x2c, 0x20, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x20, 0x6f, 0x66, + 0x20, 0x61, 0x63, 0x63, 0x65, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x76, + 0x69, 0x63, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x04, 0x00, 0x01, 0x12, 0x03, + 0x34, 0x07, 0x12, 0x0a, 0x48, 0x0a, 0x06, 0x04, 0x01, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x36, + 0x04, 0x13, 0x1a, 0x39, 0x20, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x47, 0x50, 0x55, 0x20, + 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x20, 0x28, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x20, 0x63, 0x6f, + 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x29, 0x0a, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x36, 0x04, 0x0e, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x36, 0x11, 0x12, 0x0a, 0x23, 0x0a, + 0x06, 0x04, 0x01, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x38, 0x04, 0x13, 0x1a, 0x14, 0x20, 0x47, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x20, 0x54, 0x50, 0x55, 0x20, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, + 0x73, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x38, + 0x04, 0x0e, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x38, + 0x11, 0x12, 0x0a, 0x26, 0x0a, 0x06, 0x04, 0x01, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x3a, 0x04, + 0x16, 0x1a, 0x17, 0x20, 0x41, 0x6d, 0x61, 0x7a, 0x6f, 0x6e, 0x20, 0x4e, 0x65, 0x75, 0x72, 0x6f, + 0x6e, 0x20, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, + 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x3a, 0x04, 0x11, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, + 0x04, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x3a, 0x14, 0x15, 0x0a, 0x20, 0x0a, 0x06, 0x04, 0x01, + 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x3c, 0x04, 0x10, 0x1a, 0x11, 0x20, 0x41, 0x4d, 0x44, 0x20, + 0x47, 0x50, 0x55, 0x20, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x01, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x3c, 0x04, 0x0b, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x01, 0x04, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x3c, 0x0e, 0x0f, 0x0a, 0x25, 0x0a, 0x06, + 0x04, 0x01, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, 0x3e, 0x04, 0x15, 0x1a, 0x16, 0x20, 0x48, 0x61, + 0x62, 0x61, 0x6e, 0x61, 0x20, 0x47, 0x61, 0x75, 0x64, 0x69, 0x20, 0x64, 0x65, 0x76, 0x69, 0x63, + 0x65, 0x73, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, + 0x3e, 0x04, 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x04, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, + 0x3e, 0x13, 0x14, 0x0a, 0xf8, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x44, 0x02, + 0x14, 0x1a, 0xea, 0x01, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, + 0x20, 0x61, 0x6e, 0x79, 0x20, 0x61, 0x72, 0x62, 0x69, 0x74, 0x72, 0x61, 0x72, 0x79, 0x20, 0x73, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x20, 0x62, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x64, 0x20, 0x62, 0x79, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x20, 0x6f, 0x72, 0x20, 0x74, + 0x61, 0x69, 0x6e, 0x74, 0x73, 0x0a, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x73, + 0x20, 0x69, 0x6e, 0x20, 0x71, 0x75, 0x65, 0x73, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x44, 0x65, + 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x20, 0x70, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x72, 0x20, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x20, 0x74, 0x79, 0x70, 0x69, + 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x0a, 0x20, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x3a, + 0x20, 0x60, 0x6e, 0x76, 0x69, 0x64, 0x69, 0x61, 0x2d, 0x74, 0x65, 0x73, 0x6c, 0x61, 0x2d, 0x74, + 0x34, 0x60, 0x2c, 0x20, 0x60, 0x6e, 0x76, 0x69, 0x64, 0x69, 0x61, 0x2d, 0x74, 0x65, 0x73, 0x6c, + 0x61, 0x2d, 0x61, 0x31, 0x30, 0x30, 0x60, 0x2c, 0x20, 0x65, 0x74, 0x63, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x44, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x44, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x44, 0x12, 0x13, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x01, 0x08, 0x00, + 0x12, 0x04, 0x45, 0x02, 0x4b, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x08, 0x00, 0x01, 0x12, + 0x03, 0x45, 0x08, 0x1c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x46, 0x04, + 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, 0x46, 0x04, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x46, 0x09, 0x16, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x46, 0x19, 0x1a, 0x0a, 0xf4, 0x01, 0x0a, 0x04, + 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x4a, 0x04, 0x1e, 0x1a, 0xe6, 0x01, 0x20, 0x4c, 0x69, 0x6b, + 0x65, 0x20, 0x60, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x60, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x61, 0x72, 0x62, 0x69, + 0x74, 0x72, 0x61, 0x72, 0x79, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2c, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, + 0x72, 0x6d, 0x65, 0x64, 0x20, 0x62, 0x79, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x62, + 0x65, 0x6c, 0x73, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x73, + 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x63, 0x6c, 0x6f, + 0x75, 0x64, 0x0a, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x20, 0x6c, 0x61, 0x62, + 0x65, 0x6c, 0x73, 0x20, 0x74, 0x79, 0x70, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x75, 0x73, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x3a, 0x20, 0x60, 0x31, 0x67, 0x2e, 0x35, 0x67, 0x62, 0x60, + 0x2c, 0x20, 0x60, 0x32, 0x67, 0x2e, 0x31, 0x30, 0x67, 0x62, 0x60, 0x2c, 0x20, 0x65, 0x74, 0x63, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x05, 0x12, 0x03, 0x4a, 0x04, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x4a, 0x0b, 0x19, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x4a, 0x1c, 0x1d, 0x0a, 0x58, 0x0a, 0x04, + 0x04, 0x01, 0x02, 0x03, 0x12, 0x03, 0x4d, 0x02, 0x1f, 0x1a, 0x4b, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x63, 0x6c, 0x61, 0x73, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x63, 0x63, 0x65, 0x6c, 0x65, 0x72, + 0x61, 0x74, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x20, 0x44, 0x65, 0x66, + 0x61, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, 0x5f, + 0x47, 0x50, 0x55, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x06, 0x12, + 0x03, 0x4d, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x01, 0x12, 0x03, 0x4d, + 0x0e, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x03, 0x12, 0x03, 0x4d, 0x1d, 0x1e, + 0x0a, 0x55, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x51, 0x00, 0x5a, 0x01, 0x1a, 0x49, 0x20, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, + 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, + 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x20, 0x6d, 0x65, 0x6d, + 0x6f, 0x72, 0x79, 0x20, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, + 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, + 0x51, 0x08, 0x14, 0x0a, 0x2f, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x53, 0x02, 0x18, + 0x1a, 0x22, 0x20, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x74, 0x6f, + 0x20, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, 0x53, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x53, 0x09, 0x13, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x53, 0x16, 0x17, 0x0a, 0x1e, + 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x55, 0x02, 0x18, 0x1a, 0x11, 0x20, 0x4e, 0x61, + 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x05, 0x12, 0x03, 0x55, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x55, 0x09, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x55, 0x16, 0x17, 0x0a, 0x7d, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x02, + 0x12, 0x03, 0x59, 0x02, 0x18, 0x1a, 0x70, 0x20, 0x53, 0x69, 0x7a, 0x65, 0x20, 0x6c, 0x69, 0x6d, + 0x69, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x20, 0x6d, 0x65, + 0x6d, 0x6f, 0x72, 0x79, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x65, 0x74, + 0x2c, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x68, 0x61, 0x72, 0x65, + 0x64, 0x20, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x20, 0x69, 0x73, 0x20, 0x65, 0x71, 0x75, 0x61, + 0x6c, 0x0a, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x61, + 0x74, 0x65, 0x64, 0x20, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x05, + 0x12, 0x03, 0x59, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x59, 0x09, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x03, 0x12, 0x03, 0x59, 0x16, + 0x17, 0x0a, 0x77, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x5e, 0x00, 0x63, 0x01, 0x1a, 0x6b, 0x20, + 0x45, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x6c, 0x6c, + 0x20, 0x6e, 0x6f, 0x6e, 0x2d, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x20, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x2c, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x63, 0x61, 0x70, + 0x74, 0x75, 0x72, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, + 0x2c, 0x20, 0x74, 0x6f, 0x0a, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, + 0x6f, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, + 0x01, 0x12, 0x03, 0x5e, 0x08, 0x19, 0x0a, 0x94, 0x01, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, + 0x03, 0x61, 0x02, 0x25, 0x1a, 0x86, 0x01, 0x20, 0x47, 0x50, 0x55, 0x20, 0x61, 0x63, 0x63, 0x65, + 0x6c, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x65, 0x6c, 0x65, 0x63, + 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x0a, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6d, 0x75, 0x6c, + 0x74, 0x69, 0x2d, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x47, 0x50, 0x55, 0x73, + 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x73, 0x69, 0x7a, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x61, 0x02, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x61, 0x11, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x61, 0x23, 0x24, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, + 0x03, 0x62, 0x02, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x06, 0x12, 0x03, 0x62, + 0x02, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, 0x62, 0x0f, 0x1c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x62, 0x1f, 0x20, 0x0a, 0x56, + 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x66, 0x00, 0x75, 0x01, 0x1a, 0x4a, 0x20, 0x52, 0x75, 0x6e, + 0x74, 0x69, 0x6d, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x6f, 0x6f, 0x73, 0x65, 0x6c, + 0x79, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x6c, + 0x6f, 0x77, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x62, 0x69, + 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x66, + 0x08, 0x17, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x04, 0x04, 0x00, 0x12, 0x04, 0x67, 0x02, 0x6a, 0x03, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x04, 0x00, 0x01, 0x12, 0x03, 0x67, 0x07, 0x12, 0x0a, 0x0d, + 0x0a, 0x06, 0x04, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x68, 0x04, 0x0e, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x04, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x68, 0x04, 0x09, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x04, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x68, 0x0c, 0x0d, 0x0a, 0x0d, 0x0a, + 0x06, 0x04, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x69, 0x04, 0x12, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x04, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x69, 0x04, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x04, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x69, 0x10, 0x11, 0x0a, 0x1f, 0x0a, 0x04, + 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x6d, 0x02, 0x17, 0x1a, 0x12, 0x20, 0x54, 0x79, 0x70, 0x65, + 0x20, 0x6f, 0x66, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x00, 0x06, 0x12, 0x03, 0x6d, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x6d, 0x0e, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x6d, 0x15, 0x16, 0x0a, 0xb9, 0x01, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, + 0x12, 0x03, 0x71, 0x02, 0x15, 0x1a, 0xab, 0x01, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, + 0x20, 0x41, 0x6c, 0x6c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, + 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x2e, 0x20, 0x48, 0x6f, 0x77, + 0x65, 0x76, 0x65, 0x72, 0x2c, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x63, 0x61, + 0x73, 0x65, 0x73, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x76, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x20, 0x74, 0x6f, 0x20, + 0x65, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x20, 0x74, 0x69, 0x67, 0x68, 0x74, 0x65, 0x72, 0x20, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x73, 0x65, 0x74, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x05, 0x12, 0x03, 0x71, 0x02, + 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x71, 0x09, 0x10, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x71, 0x13, 0x14, 0x0a, 0x74, 0x0a, + 0x04, 0x04, 0x04, 0x02, 0x02, 0x12, 0x03, 0x74, 0x02, 0x14, 0x1a, 0x67, 0x2b, 0x6f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x49, 0x74, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, + 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x20, + 0x65, 0x78, 0x74, 0x72, 0x61, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x74, + 0x69, 0x6d, 0x65, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x70, 0x79, 0x74, 0x68, 0x6f, 0x6e, + 0x2c, 0x20, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x2e, 0x2e, 0x20, 0x65, 0x74, 0x63, 0x2e, + 0x29, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x05, 0x12, 0x03, 0x74, 0x02, + 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x74, 0x09, 0x0f, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, 0x74, 0x12, 0x13, 0x0a, 0x1c, 0x0a, + 0x02, 0x04, 0x05, 0x12, 0x05, 0x78, 0x00, 0xc2, 0x01, 0x01, 0x1a, 0x0f, 0x20, 0x54, 0x61, 0x73, + 0x6b, 0x20, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x05, 0x01, 0x12, 0x03, 0x78, 0x08, 0x14, 0x0a, 0x89, 0x01, 0x0a, 0x03, 0x04, 0x05, 0x09, 0x12, + 0x03, 0x7b, 0x02, 0x0e, 0x1a, 0x7d, 0x20, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6e, 0x75, 0x6d, + 0x62, 0x65, 0x72, 0x20, 0x31, 0x30, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x64, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x77, 0x65, 0x20, 0x61, 0x72, + 0x65, 0x20, 0x72, 0x65, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x61, + 0x6d, 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x73, 0x5f, 0x64, 0x65, 0x63, + 0x6b, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, + 0x65, 0x72, 0x20, 0x31, 0x35, 0x2c, 0x0a, 0x20, 0x62, 0x75, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x20, 0x61, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x79, 0x70, + 0x65, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x09, 0x00, 0x12, 0x03, 0x7b, 0x0b, 0x0d, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x09, 0x00, 0x01, 0x12, 0x03, 0x7b, 0x0b, 0x0d, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x09, 0x00, 0x02, 0x12, 0x03, 0x7b, 0x0b, 0x0d, 0x0a, 0x75, 0x0a, 0x04, + 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x7e, 0x02, 0x18, 0x1a, 0x68, 0x20, 0x49, 0x6e, 0x64, 0x69, + 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, + 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x75, + 0x70, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x27, 0x73, 0x20, 0x6f, 0x75, + 0x74, 0x70, 0x75, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x76, 0x6f, 0x69, 0x64, 0x20, 0x64, 0x75, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x77, 0x6f, 0x72, + 0x6b, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x05, 0x12, 0x03, 0x7e, 0x02, + 0x06, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x7e, 0x07, 0x13, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x7e, 0x16, 0x17, 0x0a, 0x33, 0x0a, + 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x04, 0x81, 0x01, 0x02, 0x1e, 0x1a, 0x25, 0x20, 0x52, 0x75, + 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x06, 0x12, 0x04, 0x81, 0x01, 0x02, + 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, 0x12, 0x04, 0x81, 0x01, 0x12, 0x19, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x04, 0x81, 0x01, 0x1c, 0x1d, 0x0a, + 0x4f, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x02, 0x12, 0x04, 0x84, 0x01, 0x02, 0x27, 0x1a, 0x41, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x69, 0x6d, 0x65, + 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x69, 0x6e, + 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x75, 0x73, 0x65, 0x72, 0x2d, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x65, 0x64, 0x20, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x06, 0x12, 0x04, 0x84, 0x01, 0x02, 0x1a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x01, 0x12, 0x04, 0x84, 0x01, 0x1b, 0x22, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x03, 0x12, 0x04, 0x84, 0x01, 0x25, 0x26, 0x0a, 0x2b, 0x0a, + 0x04, 0x04, 0x05, 0x02, 0x03, 0x12, 0x04, 0x87, 0x01, 0x02, 0x1c, 0x1a, 0x1d, 0x20, 0x4e, 0x75, + 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73, 0x20, + 0x70, 0x65, 0x72, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x03, 0x06, 0x12, 0x04, 0x87, 0x01, 0x02, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x03, 0x01, 0x12, 0x04, 0x87, 0x01, 0x10, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, + 0x03, 0x12, 0x04, 0x87, 0x01, 0x1a, 0x1b, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x04, 0x12, + 0x04, 0x8a, 0x01, 0x02, 0x1f, 0x1a, 0x51, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, + 0x73, 0x20, 0x61, 0x20, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x20, 0x74, 0x6f, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x70, 0x75, 0x72, 0x70, 0x6f, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x64, 0x69, 0x73, + 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, + 0x05, 0x12, 0x04, 0x8a, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x01, + 0x12, 0x04, 0x8a, 0x01, 0x09, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x03, 0x12, + 0x04, 0x8a, 0x01, 0x1d, 0x1e, 0x0a, 0xa7, 0x01, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x05, 0x12, 0x04, + 0x8e, 0x01, 0x02, 0x26, 0x1a, 0x98, 0x01, 0x20, 0x49, 0x66, 0x20, 0x73, 0x65, 0x74, 0x2c, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x69, 0x73, + 0x20, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x2e, 0x20, 0x20, 0x54, 0x68, + 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x6f, + 0x77, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x20, 0x74, + 0x6f, 0x20, 0x6e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, + 0x72, 0x73, 0x0a, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x64, 0x69, 0x6e, + 0x67, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x05, 0x05, 0x12, 0x04, 0x8e, 0x01, 0x02, 0x08, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x05, 0x01, 0x12, 0x04, 0x8e, 0x01, 0x09, 0x21, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x05, 0x03, 0x12, 0x04, 0x8e, 0x01, 0x24, 0x25, 0x0a, 0x98, 0x03, 0x0a, + 0x04, 0x04, 0x05, 0x08, 0x00, 0x12, 0x06, 0x97, 0x01, 0x02, 0x99, 0x01, 0x03, 0x1a, 0x28, 0x20, + 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x79, 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, + 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x72, 0x75, + 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x0a, 0x32, 0xdd, 0x02, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x77, 0x65, 0x20, + 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x69, 0x74, + 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x6c, 0x65, 0x76, + 0x65, 0x6c, 0x20, 0x62, 0x75, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x20, 0x69, + 0x74, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x54, 0x61, 0x73, + 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, + 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2e, 0x0a, 0x20, 0x57, 0x65, 0x20, 0x61, 0x72, 0x65, 0x20, + 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x20, 0x69, 0x6e, 0x73, 0x74, + 0x65, 0x61, 0x64, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6f, 0x6f, 0x6c, 0x20, 0x62, 0x65, 0x63, 0x61, + 0x75, 0x73, 0x65, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x77, 0x65, + 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x75, 0x6e, 0x61, 0x62, 0x6c, 0x65, + 0x20, 0x74, 0x6f, 0x20, 0x64, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x75, 0x69, 0x73, 0x68, 0x20, + 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x62, 0x65, + 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x73, 0x65, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x75, 0x73, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x69, + 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2e, 0x0a, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x20, 0x6f, 0x66, 0x20, 0x68, 0x61, 0x6e, 0x64, 0x6c, + 0x69, 0x6e, 0x67, 0x20, 0x70, 0x72, 0x65, 0x63, 0x65, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x77, + 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x64, 0x6f, 0x6e, 0x65, 0x20, 0x61, 0x73, 0x20, 0x70, + 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x70, 0x72, 0x6f, 0x70, + 0x65, 0x6c, 0x6c, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x08, 0x00, 0x01, + 0x12, 0x04, 0x97, 0x01, 0x08, 0x1b, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x06, 0x12, 0x04, + 0x98, 0x01, 0x04, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, 0x05, 0x12, 0x04, 0x98, + 0x01, 0x04, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, 0x01, 0x12, 0x04, 0x98, 0x01, + 0x09, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, 0x03, 0x12, 0x04, 0x98, 0x01, 0x19, + 0x1a, 0x0a, 0x7f, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x07, 0x12, 0x04, 0x9c, 0x01, 0x02, 0x1e, 0x1a, + 0x71, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x77, 0x68, 0x65, 0x74, + 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x20, 0x74, 0x6f, + 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x20, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, + 0x72, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x20, + 0x69, 0x6e, 0x20, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x76, 0x6f, + 0x69, 0x64, 0x20, 0x64, 0x75, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x77, 0x6f, 0x72, + 0x6b, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x05, 0x12, 0x04, 0x9c, 0x01, 0x02, + 0x06, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x01, 0x12, 0x04, 0x9c, 0x01, 0x07, 0x19, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x03, 0x12, 0x04, 0x9c, 0x01, 0x1c, 0x1d, 0x0a, + 0x64, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x08, 0x12, 0x04, 0x9f, 0x01, 0x02, 0x20, 0x1a, 0x56, 0x20, + 0x41, 0x72, 0x62, 0x69, 0x74, 0x72, 0x61, 0x72, 0x79, 0x20, 0x74, 0x61, 0x67, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x20, 0x75, 0x73, 0x65, 0x72, 0x73, 0x20, + 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x20, 0x74, 0x6f, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x20, 0x73, 0x6d, 0x61, 0x6c, 0x6c, 0x20, + 0x62, 0x75, 0x74, 0x20, 0x61, 0x72, 0x62, 0x69, 0x74, 0x72, 0x61, 0x72, 0x79, 0x20, 0x6c, 0x61, + 0x62, 0x65, 0x6c, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x08, 0x06, 0x12, 0x04, + 0x9f, 0x01, 0x02, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x08, 0x01, 0x12, 0x04, 0x9f, + 0x01, 0x16, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x08, 0x03, 0x12, 0x04, 0x9f, 0x01, + 0x1d, 0x1f, 0x0a, 0xb5, 0x02, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x09, 0x12, 0x04, 0xa4, 0x01, 0x02, + 0x20, 0x1a, 0xa6, 0x02, 0x20, 0x70, 0x6f, 0x64, 0x5f, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, + 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, + 0x69, 0x71, 0x75, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x50, + 0x6f, 0x64, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x6b, 0x38, 0x73, 0x20, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, + 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x63, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x66, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x0a, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x73, 0x20, 0x61, 0x20, 0x6b, 0x38, 0x73, 0x20, 0x50, 0x6f, 0x64, 0x2e, 0x20, 0x49, 0x66, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x69, 0x73, 0x20, 0x73, + 0x65, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x64, 0x20, 0x50, 0x6f, 0x64, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x77, 0x69, + 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, + 0x61, 0x64, 0x20, 0x6f, 0x66, 0x2c, 0x20, 0x62, 0x75, 0x74, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, + 0x65, 0x64, 0x0a, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, + 0x61, 0x73, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, + 0x50, 0x6f, 0x64, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x75, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x50, + 0x72, 0x6f, 0x70, 0x65, 0x6c, 0x6c, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x09, 0x05, 0x12, 0x04, 0xa4, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x09, 0x01, 0x12, 0x04, 0xa4, 0x01, 0x09, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x09, + 0x03, 0x12, 0x04, 0xa4, 0x01, 0x1d, 0x1f, 0x0a, 0x7b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x0a, 0x12, + 0x04, 0xa7, 0x01, 0x02, 0x2f, 0x1a, 0x6d, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x69, 0x67, + 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x76, 0x61, 0x72, 0x73, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x76, 0x61, 0x72, + 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, + 0x65, 0x64, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x63, 0x61, 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, + 0x69, 0x6e, 0x67, 0x20, 0x68, 0x61, 0x73, 0x68, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x63, 0x61, 0x63, + 0x68, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0a, 0x04, 0x12, 0x04, 0xa7, + 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0a, 0x05, 0x12, 0x04, 0xa7, 0x01, + 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0a, 0x01, 0x12, 0x04, 0xa7, 0x01, 0x12, + 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0a, 0x03, 0x12, 0x04, 0xa7, 0x01, 0x2c, 0x2e, + 0x0a, 0x70, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x0b, 0x12, 0x04, 0xaa, 0x01, 0x02, 0x15, 0x1a, 0x62, + 0x20, 0x69, 0x73, 0x5f, 0x65, 0x61, 0x67, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, + 0x74, 0x65, 0x73, 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x74, 0x61, 0x73, 0x6b, 0x20, 0x69, 0x73, 0x20, 0x65, 0x61, 0x67, 0x65, 0x72, 0x20, 0x6f, 0x72, + 0x20, 0x6e, 0x6f, 0x74, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x77, 0x6f, 0x75, 0x6c, + 0x64, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x54, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0b, 0x05, 0x12, 0x04, 0xaa, 0x01, 0x02, + 0x06, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0b, 0x01, 0x12, 0x04, 0xaa, 0x01, 0x07, 0x0f, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0b, 0x03, 0x12, 0x04, 0xaa, 0x01, 0x12, 0x14, 0x0a, + 0xf5, 0x01, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x0c, 0x12, 0x04, 0xb1, 0x01, 0x02, 0x30, 0x1a, 0xe6, + 0x01, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x77, 0x68, 0x65, 0x74, + 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x77, 0x69, 0x6c, + 0x6c, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x64, 0x65, 0x63, + 0x6b, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x69, 0x74, 0x20, 0x66, 0x69, 0x6e, 0x69, 0x73, 0x68, + 0x65, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x63, 0x61, 0x6e, + 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x72, 0x65, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, + 0x65, 0x73, 0x3a, 0x0a, 0x20, 0x2d, 0x20, 0x6e, 0x69, 0x6c, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x65, 0x74, + 0x2e, 0x0a, 0x20, 0x2d, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x74, + 0x61, 0x73, 0x6b, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, + 0x65, 0x20, 0x61, 0x20, 0x64, 0x65, 0x63, 0x6b, 0x2e, 0x0a, 0x20, 0x2d, 0x20, 0x66, 0x61, 0x6c, + 0x73, 0x65, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x77, 0x69, 0x6c, + 0x6c, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x20, 0x61, + 0x20, 0x64, 0x65, 0x63, 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0c, 0x06, + 0x12, 0x04, 0xb1, 0x01, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0c, 0x01, 0x12, + 0x04, 0xb1, 0x01, 0x1c, 0x2a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0c, 0x03, 0x12, 0x04, + 0xb1, 0x01, 0x2d, 0x2f, 0x0a, 0xb6, 0x04, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x0d, 0x12, 0x04, 0xbb, + 0x01, 0x02, 0x22, 0x1a, 0xa7, 0x04, 0x20, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, + 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, + 0x70, 0x6f, 0x64, 0x73, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x43, 0x52, 0x20, + 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2e, 0x0a, 0x20, 0x49, 0x6e, 0x20, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x6b, 0x69, 0x74, 0x2c, 0x20, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x72, 0x65, + 0x73, 0x75, 0x6c, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x0a, 0x20, + 0x61, 0x72, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x76, 0x69, 0x61, + 0x20, 0x60, 0x40, 0x74, 0x61, 0x73, 0x6b, 0x28, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x3d, 0x2e, + 0x2e, 0x2e, 0x2c, 0x20, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3d, + 0x2e, 0x2e, 0x2e, 0x29, 0x60, 0x2e, 0x0a, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x73, 0x6b, + 0x73, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x70, 0x6f, 0x64, 0x73, + 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x50, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x46, 0x75, 0x6e, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x73, 0x6b, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x73, 0x65, 0x20, + 0x74, 0x61, 0x6b, 0x65, 0x20, 0x70, 0x72, 0x65, 0x63, 0x65, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x0a, + 0x20, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x76, 0x69, 0x61, 0x20, + 0x60, 0x40, 0x74, 0x61, 0x73, 0x6b, 0x28, 0x70, 0x6f, 0x64, 0x5f, 0x74, 0x65, 0x6d, 0x70, 0x6c, + 0x61, 0x74, 0x65, 0x3d, 0x50, 0x6f, 0x64, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x28, + 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x3d, 0x2e, 0x2e, 0x2e, 0x29, 0x29, 0x60, 0x20, 0x77, 0x68, + 0x69, 0x63, 0x68, 0x20, 0x61, 0x72, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, + 0x74, 0x65, 0x64, 0x0a, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4b, 0x38, 0x73, 0x50, + 0x6f, 0x64, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, + 0x74, 0x61, 0x73, 0x6b, 0x73, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, + 0x43, 0x52, 0x44, 0x73, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x20, 0x69, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, + 0x6f, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x43, 0x52, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, + 0x20, 0x69, 0x74, 0x73, 0x65, 0x6c, 0x66, 0x20, 0x77, 0x68, 0x69, 0x6c, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x70, 0x6f, 0x64, 0x20, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x2f, 0x4b, + 0x38, 0x73, 0x50, 0x6f, 0x64, 0x20, 0x69, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, + 0x0a, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6f, 0x64, 0x20, 0x74, 0x65, 0x6d, + 0x70, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x43, 0x52, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x0d, 0x06, 0x12, 0x04, 0xbb, 0x01, 0x02, 0x13, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x0d, 0x01, 0x12, 0x04, 0xbb, 0x01, 0x14, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x0d, 0x03, 0x12, 0x04, 0xbb, 0x01, 0x1f, 0x21, 0x0a, 0x67, 0x0a, 0x04, 0x04, 0x05, + 0x02, 0x0e, 0x12, 0x04, 0xbe, 0x01, 0x02, 0x17, 0x1a, 0x59, 0x20, 0x57, 0x68, 0x65, 0x74, 0x68, + 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x69, 0x73, 0x20, 0x61, + 0x62, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, + 0x65, 0x62, 0x75, 0x67, 0x67, 0x65, 0x72, 0x20, 0x28, 0x76, 0x73, 0x63, 0x6f, 0x64, 0x65, 0x20, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x29, 0x20, 0x69, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, + 0x72, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0e, 0x05, 0x12, 0x04, 0xbe, 0x01, + 0x02, 0x06, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0e, 0x01, 0x12, 0x04, 0xbe, 0x01, 0x07, + 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0e, 0x03, 0x12, 0x04, 0xbe, 0x01, 0x14, 0x16, + 0x0a, 0x34, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x0f, 0x12, 0x04, 0xc1, 0x01, 0x02, 0x27, 0x1a, 0x26, + 0x20, 0x4c, 0x6f, 0x67, 0x20, 0x6c, 0x69, 0x6e, 0x6b, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, + 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0f, 0x04, 0x12, + 0x04, 0xc1, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0f, 0x06, 0x12, 0x04, + 0xc1, 0x01, 0x0b, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0f, 0x01, 0x12, 0x04, 0xc1, + 0x01, 0x18, 0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x0f, 0x03, 0x12, 0x04, 0xc1, 0x01, + 0x24, 0x26, 0x0a, 0x83, 0x01, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x06, 0xc6, 0x01, 0x00, 0xf0, 0x01, + 0x01, 0x1a, 0x75, 0x20, 0x41, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, + 0x74, 0x75, 0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, + 0x6c, 0x79, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x61, 0x20, + 0x74, 0x61, 0x73, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, + 0x65, 0x6d, 0x0a, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x72, 0x65, + 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x66, 0x69, + 0x72, 0x73, 0x74, 0x20, 0x73, 0x74, 0x65, 0x70, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, + 0x04, 0xc6, 0x01, 0x08, 0x14, 0x0a, 0x64, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x04, 0xc8, + 0x01, 0x02, 0x14, 0x1a, 0x56, 0x20, 0x41, 0x75, 0x74, 0x6f, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, + 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x20, + 0x49, 0x64, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x6c, 0x79, 0x20, 0x69, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, + 0x20, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x6c, 0x79, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x00, 0x06, 0x12, 0x04, 0xc8, 0x01, 0x02, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x00, 0x01, 0x12, 0x04, 0xc8, 0x01, 0x0d, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x00, 0x03, 0x12, 0x04, 0xc8, 0x01, 0x12, 0x13, 0x0a, 0x9b, 0x02, 0x0a, 0x04, 0x04, 0x06, 0x02, + 0x01, 0x12, 0x04, 0xcd, 0x01, 0x02, 0x12, 0x1a, 0x8c, 0x02, 0x20, 0x41, 0x20, 0x70, 0x72, 0x65, + 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x79, 0x65, 0x74, 0x20, 0x65, 0x78, 0x74, 0x65, + 0x6e, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x20, 0x74, 0x79, 0x70, 0x65, + 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x20, 0x54, 0x68, 0x69, + 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x20, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x69, 0x7a, 0x65, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, + 0x2e, 0x20, 0x49, 0x66, 0x20, 0x6e, 0x6f, 0x0a, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, + 0x6f, 0x6e, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, + 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2c, 0x20, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x6c, + 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, + 0x20, 0x74, 0x6f, 0x20, 0x69, 0x74, 0x73, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x43, 0x61, 0x74, 0x65, + 0x67, 0x6f, 0x72, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, + 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x65, 0x64, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x43, 0x61, 0x74, 0x65, + 0x67, 0x6f, 0x72, 0x79, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x05, 0x12, + 0x04, 0xcd, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x01, 0x12, 0x04, + 0xcd, 0x01, 0x09, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x03, 0x12, 0x04, 0xcd, + 0x01, 0x10, 0x11, 0x0a, 0x2e, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x02, 0x12, 0x04, 0xd0, 0x01, 0x02, + 0x1c, 0x1a, 0x20, 0x20, 0x45, 0x78, 0x74, 0x72, 0x61, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, + 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x06, 0x12, 0x04, 0xd0, 0x01, + 0x02, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x01, 0x12, 0x04, 0xd0, 0x01, 0x0f, + 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x03, 0x12, 0x04, 0xd0, 0x01, 0x1a, 0x1b, + 0x0a, 0xca, 0x01, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x03, 0x12, 0x04, 0xd4, 0x01, 0x02, 0x1f, 0x1a, + 0xbb, 0x01, 0x20, 0x41, 0x20, 0x73, 0x74, 0x72, 0x6f, 0x6e, 0x67, 0x6c, 0x79, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x73, 0x20, + 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x67, 0x75, 0x61, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65, + 0x73, 0x0a, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2d, 0x74, 0x69, 0x6d, 0x65, 0x20, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x76, + 0x6f, 0x69, 0x64, 0x20, 0x63, 0x6f, 0x73, 0x74, 0x6c, 0x79, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, + 0x6d, 0x65, 0x20, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x03, 0x06, 0x12, 0x04, 0xd4, 0x01, 0x02, 0x10, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x03, 0x01, 0x12, 0x04, 0xd4, 0x01, 0x11, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x03, 0x03, 0x12, 0x04, 0xd4, 0x01, 0x1d, 0x1e, 0x0a, 0x66, 0x0a, 0x04, 0x04, 0x06, + 0x02, 0x04, 0x12, 0x04, 0xd7, 0x01, 0x02, 0x24, 0x1a, 0x58, 0x20, 0x43, 0x75, 0x73, 0x74, 0x6f, + 0x6d, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x65, + 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x6c, + 0x6f, 0x77, 0x20, 0x76, 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x06, 0x12, 0x04, 0xd7, 0x01, 0x02, + 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x01, 0x12, 0x04, 0xd7, 0x01, 0x19, 0x1f, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x03, 0x12, 0x04, 0xd7, 0x01, 0x22, 0x23, 0x0a, + 0x84, 0x02, 0x0a, 0x04, 0x04, 0x06, 0x08, 0x00, 0x12, 0x06, 0xdc, 0x01, 0x02, 0xe0, 0x01, 0x03, + 0x1a, 0xf3, 0x01, 0x20, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x67, 0x75, 0x61, 0x72, + 0x61, 0x6e, 0x74, 0x65, 0x65, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x20, 0x66, 0x6f, + 0x72, 0x2e, 0x20, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x53, 0x44, 0x4b, 0x20, 0x70, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x73, 0x65, 0x20, 0x69, + 0x66, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x2e, 0x0a, 0x20, 0x49, 0x66, 0x20, 0x6e, 0x6f, + 0x20, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x20, 0x70, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x66, 0x6f, 0x75, 0x6e, 0x64, + 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x77, 0x69, 0x6c, + 0x6c, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x68, 0x61, 0x6e, + 0x64, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x73, 0x65, 0x20, 0x75, 0x73, 0x69, 0x6e, + 0x67, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x2d, 0x69, 0x6e, 0x0a, 0x20, 0x68, 0x61, 0x6e, 0x64, + 0x6c, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x08, 0x00, 0x01, 0x12, + 0x04, 0xdc, 0x01, 0x08, 0x0e, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x05, 0x12, 0x04, 0xdd, + 0x01, 0x04, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, 0x06, 0x12, 0x04, 0xdd, 0x01, + 0x04, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, 0x01, 0x12, 0x04, 0xdd, 0x01, 0x0e, + 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, 0x03, 0x12, 0x04, 0xdd, 0x01, 0x1a, 0x1b, + 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x06, 0x12, 0x04, 0xde, 0x01, 0x04, 0x18, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x06, 0x06, 0x12, 0x04, 0xde, 0x01, 0x04, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x06, 0x01, 0x12, 0x04, 0xde, 0x01, 0x0b, 0x12, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x06, 0x03, 0x12, 0x04, 0xde, 0x01, 0x15, 0x17, 0x0a, 0x0c, 0x0a, 0x04, 0x04, + 0x06, 0x02, 0x07, 0x12, 0x04, 0xdf, 0x01, 0x04, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x07, 0x06, 0x12, 0x04, 0xdf, 0x01, 0x04, 0x07, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x07, + 0x01, 0x12, 0x04, 0xdf, 0x01, 0x08, 0x0b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x07, 0x03, + 0x12, 0x04, 0xdf, 0x01, 0x0e, 0x10, 0x0a, 0x65, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x08, 0x12, 0x04, + 0xe3, 0x01, 0x02, 0x1e, 0x1a, 0x57, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, + 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x75, 0x73, 0x74, 0x6f, + 0x6d, 0x69, 0x7a, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x69, + 0x6e, 0x67, 0x20, 0x61, 0x74, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x74, 0x69, 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, + 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x08, 0x05, 0x12, 0x04, 0xe3, 0x01, 0x02, 0x07, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x08, 0x01, 0x12, 0x04, 0xe3, 0x01, 0x08, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x08, 0x03, 0x12, 0x04, 0xe3, 0x01, 0x1c, 0x1d, 0x0a, 0x5d, 0x0a, 0x04, 0x04, 0x06, + 0x02, 0x09, 0x12, 0x04, 0xe6, 0x01, 0x02, 0x27, 0x1a, 0x4f, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, + 0x69, 0x74, 0x79, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x20, 0x65, 0x6e, 0x63, 0x61, + 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, + 0x79, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x20, 0x72, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x09, 0x06, 0x12, 0x04, 0xe6, 0x01, 0x02, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x09, + 0x01, 0x12, 0x04, 0xe6, 0x01, 0x12, 0x22, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x09, 0x03, + 0x12, 0x04, 0xe6, 0x01, 0x25, 0x26, 0x0a, 0x79, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x0a, 0x12, 0x04, + 0xea, 0x01, 0x02, 0x2b, 0x1a, 0x6b, 0x20, 0x45, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, + 0x74, 0x65, 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x6e, 0x6f, 0x6e, 0x2d, 0x73, 0x74, 0x61, 0x6e, + 0x64, 0x61, 0x72, 0x64, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x2c, 0x20, + 0x6e, 0x6f, 0x74, 0x20, 0x63, 0x61, 0x70, 0x74, 0x75, 0x72, 0x65, 0x64, 0x20, 0x62, 0x79, 0x0a, + 0x20, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2c, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x6c, + 0x6f, 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0a, 0x06, 0x12, 0x04, 0xea, 0x01, 0x02, 0x13, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0a, 0x01, 0x12, 0x04, 0xea, 0x01, 0x14, 0x26, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0a, 0x03, 0x12, 0x04, 0xea, 0x01, 0x29, 0x2a, 0x0a, 0xe7, + 0x01, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x0b, 0x12, 0x04, 0xef, 0x01, 0x02, 0x22, 0x1a, 0xd8, 0x01, + 0x20, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, + 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, + 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, + 0x69, 0x62, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x20, 0x76, 0x61, + 0x72, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x20, 0x69, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x0a, 0x20, 0x74, 0x6f, 0x20, + 0x75, 0x73, 0x65, 0x20, 0x61, 0x73, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x2e, + 0x0a, 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x20, 0x31, 0x20, 0x74, 0x68, + 0x72, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x31, 0x35, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x76, 0x65, 0x72, + 0x79, 0x20, 0x66, 0x72, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x20, 0x6f, 0x63, 0x63, + 0x75, 0x72, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x65, + 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0b, + 0x06, 0x12, 0x04, 0xef, 0x01, 0x02, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0b, 0x01, + 0x12, 0x04, 0xef, 0x01, 0x16, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x0b, 0x03, 0x12, + 0x04, 0xef, 0x01, 0x1f, 0x21, 0x0a, 0x61, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x06, 0xf5, 0x01, 0x00, + 0xfb, 0x01, 0x01, 0x1a, 0x2a, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x70, 0x6f, + 0x72, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x2e, 0x0a, 0x32, + 0x27, 0x20, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x20, 0x46, 0x69, 0x72, 0x73, 0x74, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x20, + 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, + 0x04, 0xf5, 0x01, 0x08, 0x15, 0x0a, 0x73, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x04, 0xf8, + 0x01, 0x02, 0x1c, 0x1a, 0x65, 0x20, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, + 0x70, 0x6f, 0x72, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x78, 0x70, 0x6f, 0x73, 0x65, 0x20, 0x6f, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6f, 0x64, 0x27, 0x73, 0x20, 0x49, 0x50, 0x20, 0x61, + 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x70, 0x6f, + 0x72, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2c, 0x20, 0x30, 0x20, 0x3c, 0x20, 0x78, + 0x20, 0x3c, 0x20, 0x36, 0x35, 0x35, 0x33, 0x36, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x00, 0x05, 0x12, 0x04, 0xf8, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x00, 0x01, 0x12, 0x04, 0xf8, 0x01, 0x09, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, + 0x03, 0x12, 0x04, 0xf8, 0x01, 0x1a, 0x1b, 0x0a, 0x43, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x01, 0x12, + 0x04, 0xfa, 0x01, 0x02, 0x12, 0x1a, 0x35, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x78, 0x70, 0x6f, + 0x73, 0x65, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6f, 0x64, 0x27, 0x73, 0x20, + 0x49, 0x50, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x01, 0x05, 0x12, 0x04, 0xfa, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x01, 0x01, 0x12, 0x04, 0xfa, 0x01, 0x09, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x01, 0x03, 0x12, 0x04, 0xfa, 0x01, 0x10, 0x11, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x08, 0x12, + 0x06, 0xfd, 0x01, 0x00, 0xab, 0x02, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x08, 0x01, 0x12, 0x04, + 0xfd, 0x01, 0x08, 0x11, 0x0a, 0x3c, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x00, 0x12, 0x04, 0xff, 0x01, + 0x02, 0x13, 0x1a, 0x2e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x69, + 0x6d, 0x61, 0x67, 0x65, 0x20, 0x75, 0x72, 0x6c, 0x2e, 0x20, 0x45, 0x67, 0x3a, 0x20, 0x64, 0x6f, + 0x63, 0x6b, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x64, 0x69, 0x73, 0x3a, 0x6c, 0x61, 0x74, 0x65, 0x73, + 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x05, 0x12, 0x04, 0xff, 0x01, 0x02, + 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x04, 0xff, 0x01, 0x09, 0x0e, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x04, 0xff, 0x01, 0x11, 0x12, 0x0a, + 0x74, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x01, 0x12, 0x04, 0x82, 0x02, 0x02, 0x1e, 0x1a, 0x66, 0x20, + 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x70, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, + 0x61, 0x75, 0x6c, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x20, + 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x75, + 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x04, 0x12, 0x04, + 0x82, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x05, 0x12, 0x04, 0x82, + 0x02, 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x01, 0x12, 0x04, 0x82, 0x02, + 0x12, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x03, 0x12, 0x04, 0x82, 0x02, 0x1c, + 0x1d, 0x0a, 0xaf, 0x02, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x02, 0x12, 0x04, 0x87, 0x02, 0x02, 0x1b, + 0x1a, 0xa0, 0x02, 0x20, 0x54, 0x68, 0x65, 0x73, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x64, + 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x20, + 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x70, 0x61, 0x74, 0x68, 0x73, 0x2e, 0x20, 0x49, 0x66, 0x20, + 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x79, + 0x73, 0x74, 0x65, 0x6d, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x61, 0x70, + 0x70, 0x65, 0x6e, 0x64, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x70, 0x61, 0x74, 0x68, 0x73, + 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x73, 0x74, + 0x69, 0x6c, 0x6c, 0x0a, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x73, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x27, 0x73, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6f, 0x75, + 0x74, 0x70, 0x75, 0x74, 0x73, 0x20, 0x70, 0x61, 0x74, 0x68, 0x2c, 0x20, 0x61, 0x64, 0x64, 0x20, + 0x24, 0x28, 0x46, 0x4c, 0x59, 0x54, 0x45, 0x5f, 0x49, 0x4e, 0x50, 0x55, 0x54, 0x5f, 0x46, 0x49, + 0x4c, 0x45, 0x29, 0x2c, 0x20, 0x24, 0x28, 0x46, 0x4c, 0x59, 0x54, 0x45, 0x5f, 0x4f, 0x55, 0x54, + 0x50, 0x55, 0x54, 0x5f, 0x46, 0x49, 0x4c, 0x45, 0x29, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x76, + 0x65, 0x72, 0x20, 0x6d, 0x61, 0x6b, 0x65, 0x73, 0x20, 0x73, 0x65, 0x6e, 0x73, 0x65, 0x20, 0x61, + 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x77, + 0x69, 0x6c, 0x6c, 0x20, 0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x73, 0x65, 0x20, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, + 0x72, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x04, 0x12, 0x04, 0x87, 0x02, + 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x05, 0x12, 0x04, 0x87, 0x02, 0x0b, + 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x01, 0x12, 0x04, 0x87, 0x02, 0x12, 0x16, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x03, 0x12, 0x04, 0x87, 0x02, 0x19, 0x1a, 0x0a, + 0x55, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x03, 0x12, 0x04, 0x8a, 0x02, 0x02, 0x1a, 0x1a, 0x47, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x73, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, + 0x61, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x65, 0x6e, + 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x06, 0x12, + 0x04, 0x8a, 0x02, 0x02, 0x0b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x01, 0x12, 0x04, + 0x8a, 0x02, 0x0c, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x03, 0x12, 0x04, 0x8a, + 0x02, 0x18, 0x19, 0x0a, 0x52, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x04, 0x12, 0x04, 0x8d, 0x02, 0x02, + 0x20, 0x1a, 0x44, 0x20, 0x45, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, + 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, + 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x69, + 0x6e, 0x67, 0x20, 0x75, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x04, 0x04, + 0x12, 0x04, 0x8d, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x04, 0x06, 0x12, + 0x04, 0x8d, 0x02, 0x0b, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x04, 0x01, 0x12, 0x04, + 0x8d, 0x02, 0x18, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x04, 0x03, 0x12, 0x04, 0x8d, + 0x02, 0x1e, 0x1f, 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x05, 0x12, 0x04, 0x92, 0x02, + 0x02, 0x37, 0x1a, 0xa5, 0x01, 0x20, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x20, 0x65, 0x78, 0x74, + 0x72, 0x61, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, + 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x2e, 0x0a, 0x20, 0x54, + 0x4f, 0x44, 0x4f, 0x3a, 0x20, 0x65, 0x6c, 0x61, 0x62, 0x6f, 0x72, 0x61, 0x74, 0x65, 0x20, 0x6f, + 0x6e, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x20, 0x77, 0x69, + 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x63, 0x6f, 0x6d, 0x65, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, + 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x20, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, + 0x2c, 0x20, 0x70, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x75, 0x73, 0x65, 0x20, 0x54, 0x61, 0x73, + 0x6b, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x05, 0x04, 0x12, 0x04, 0x92, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x05, 0x06, 0x12, 0x04, 0x92, 0x02, 0x0b, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, + 0x01, 0x12, 0x04, 0x92, 0x02, 0x18, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x03, + 0x12, 0x04, 0x92, 0x02, 0x21, 0x22, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x08, 0x12, + 0x04, 0x92, 0x02, 0x23, 0x36, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x08, 0x02, 0x05, 0x08, 0x03, 0x12, + 0x04, 0x92, 0x02, 0x24, 0x35, 0x0a, 0xaa, 0x01, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x06, 0x12, 0x04, + 0x97, 0x02, 0x02, 0x23, 0x1a, 0x9b, 0x01, 0x20, 0x50, 0x6f, 0x72, 0x74, 0x73, 0x20, 0x74, 0x6f, + 0x20, 0x6f, 0x70, 0x65, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x65, 0x61, + 0x74, 0x75, 0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x75, 0x70, 0x70, + 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x73, 0x2e, 0x20, + 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, + 0x6f, 0x6e, 0x20, 0x4b, 0x38, 0x73, 0x20, 0x62, 0x75, 0x74, 0x0a, 0x20, 0x6e, 0x6f, 0x74, 0x20, + 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x41, 0x57, 0x53, + 0x20, 0x42, 0x61, 0x74, 0x63, 0x68, 0x29, 0x0a, 0x20, 0x4f, 0x6e, 0x6c, 0x79, 0x20, 0x4b, 0x38, + 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x04, 0x12, 0x04, 0x97, 0x02, 0x02, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x06, 0x12, 0x04, 0x97, 0x02, 0x0b, 0x18, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x01, 0x12, 0x04, 0x97, 0x02, 0x19, 0x1e, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x03, 0x12, 0x04, 0x97, 0x02, 0x21, 0x22, 0x0a, 0x90, + 0x05, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x07, 0x12, 0x04, 0xa0, 0x02, 0x02, 0x24, 0x1a, 0x81, 0x05, + 0x20, 0x42, 0x45, 0x54, 0x41, 0x3a, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, + 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x44, 0x61, 0x74, 0x61, 0x4c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x2e, 0x20, 0x49, + 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2c, + 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x20, + 0x54, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x61, 0x6b, 0x65, 0x73, 0x20, 0x69, 0x74, 0x20, 0x70, 0x6f, + 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x75, 0x6e, + 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x6c, 0x79, 0x20, 0x70, 0x6f, + 0x72, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x2c, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x75, 0x73, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x70, 0x75, + 0x74, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x0a, 0x20, + 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x6f, + 0x63, 0x61, 0x6c, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2d, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, + 0x61, 0x6e, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x6f, 0x75, 0x74, 0x20, 0x68, 0x61, 0x76, 0x69, + 0x6e, 0x67, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, + 0x20, 0x74, 0x6f, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x2e, 0x20, 0x54, 0x68, + 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, + 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x6f, 0x6e, 0x20, 0x4b, 0x38, 0x73, 0x20, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x0a, 0x20, 0x49, 0x66, 0x20, 0x64, + 0x61, 0x74, 0x61, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x73, 0x20, 0x65, + 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x65, + 0x64, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x63, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x6e, 0x79, 0x69, 0x6e, + 0x67, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x44, + 0x61, 0x74, 0x61, 0x4c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x69, 0x65, 0x73, 0x0a, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2c, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x20, + 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x64, 0x20, + 0x6f, 0x6e, 0x74, 0x6f, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, + 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x65, + 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x20, 0x70, 0x72, 0x65, 0x2d, 0x64, 0x65, 0x74, + 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2d, 0x73, 0x79, 0x73, + 0x74, 0x65, 0x6d, 0x20, 0x70, 0x61, 0x74, 0x68, 0x2e, 0x20, 0x52, 0x65, 0x66, 0x65, 0x72, 0x20, + 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x74, + 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, + 0x70, 0x61, 0x74, 0x68, 0x73, 0x2e, 0x0a, 0x20, 0x4f, 0x6e, 0x6c, 0x79, 0x20, 0x4b, 0x38, 0x73, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x06, 0x12, 0x04, 0xa0, 0x02, 0x02, 0x13, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x01, 0x12, 0x04, 0xa0, 0x02, 0x14, 0x1f, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x03, 0x12, 0x04, 0xa0, 0x02, 0x22, 0x23, 0x0a, 0x41, + 0x0a, 0x04, 0x04, 0x08, 0x04, 0x00, 0x12, 0x06, 0xa3, 0x02, 0x02, 0xa9, 0x02, 0x03, 0x1a, 0x31, + 0x20, 0x41, 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2d, 0x74, 0x79, + 0x70, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x04, 0x00, 0x01, 0x12, 0x04, 0xa3, 0x02, 0x07, 0x13, + 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x08, 0x04, 0x00, 0x02, 0x00, 0x12, 0x04, 0xa4, 0x02, 0x04, 0x10, + 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, 0xa4, 0x02, 0x04, + 0x0b, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x04, 0xa4, 0x02, + 0x0e, 0x0f, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x08, 0x04, 0x00, 0x02, 0x01, 0x12, 0x04, 0xa5, 0x02, + 0x04, 0x0e, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x04, 0xa5, + 0x02, 0x04, 0x09, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x04, + 0xa5, 0x02, 0x0c, 0x0d, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x08, 0x04, 0x00, 0x02, 0x02, 0x12, 0x04, + 0xa6, 0x02, 0x04, 0x0e, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, + 0x04, 0xa6, 0x02, 0x04, 0x09, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, 0x02, 0x02, + 0x12, 0x04, 0xa6, 0x02, 0x0c, 0x0d, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x08, 0x04, 0x00, 0x02, 0x03, + 0x12, 0x04, 0xa7, 0x02, 0x04, 0x0f, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, 0x03, + 0x01, 0x12, 0x04, 0xa7, 0x02, 0x04, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, + 0x03, 0x02, 0x12, 0x04, 0xa7, 0x02, 0x0d, 0x0e, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x08, 0x04, 0x00, + 0x02, 0x04, 0x12, 0x04, 0xa8, 0x02, 0x04, 0x0f, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, + 0x02, 0x04, 0x01, 0x12, 0x04, 0xa8, 0x02, 0x04, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, + 0x00, 0x02, 0x04, 0x02, 0x12, 0x04, 0xa8, 0x02, 0x0d, 0x0e, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x08, + 0x02, 0x08, 0x12, 0x04, 0xaa, 0x02, 0x02, 0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x08, + 0x06, 0x12, 0x04, 0xaa, 0x02, 0x02, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x08, 0x01, + 0x12, 0x04, 0xaa, 0x02, 0x0f, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x08, 0x03, 0x12, + 0x04, 0xaa, 0x02, 0x1e, 0x20, 0x0a, 0x67, 0x0a, 0x02, 0x04, 0x09, 0x12, 0x06, 0xae, 0x02, 0x00, + 0xc5, 0x02, 0x01, 0x1a, 0x59, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x20, 0x74, + 0x6f, 0x20, 0x75, 0x73, 0x65, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x64, 0x65, 0x61, 0x6c, 0x69, + 0x6e, 0x67, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x42, 0x6c, 0x6f, 0x62, 0x2c, 0x20, 0x53, 0x63, + 0x68, 0x65, 0x6d, 0x61, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x61, + 0x72, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x28, 0x6c, 0x61, + 0x72, 0x67, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x29, 0x0a, 0x0a, 0x0b, + 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, 0x04, 0xae, 0x02, 0x08, 0x12, 0x0a, 0x2d, 0x0a, 0x04, 0x04, + 0x09, 0x04, 0x00, 0x12, 0x06, 0xb0, 0x02, 0x02, 0xb7, 0x02, 0x03, 0x1a, 0x1d, 0x20, 0x4d, 0x6f, + 0x64, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x64, 0x6f, + 0x77, 0x6e, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, + 0x04, 0x00, 0x01, 0x12, 0x04, 0xb0, 0x02, 0x07, 0x13, 0x0a, 0x53, 0x0a, 0x06, 0x04, 0x09, 0x04, + 0x00, 0x02, 0x00, 0x12, 0x04, 0xb2, 0x02, 0x04, 0x17, 0x1a, 0x43, 0x20, 0x41, 0x6c, 0x6c, 0x20, + 0x64, 0x61, 0x74, 0x61, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x64, 0x6f, 0x77, + 0x6e, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, + 0x72, 0x20, 0x69, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x0a, 0x0a, 0x0f, + 0x0a, 0x07, 0x04, 0x09, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, 0xb2, 0x02, 0x04, 0x12, 0x0a, + 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x04, 0xb2, 0x02, 0x15, 0x16, + 0x0a, 0xaa, 0x01, 0x0a, 0x06, 0x04, 0x09, 0x04, 0x00, 0x02, 0x01, 0x12, 0x04, 0xb4, 0x02, 0x04, + 0x18, 0x1a, 0x99, 0x01, 0x20, 0x44, 0x61, 0x74, 0x61, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, + 0x65, 0x20, 0x64, 0x6f, 0x77, 0x6e, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, + 0x61, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6e, 0x20, + 0x45, 0x6e, 0x64, 0x2d, 0x4f, 0x66, 0x2d, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x20, 0x6d, 0x61, + 0x72, 0x6b, 0x65, 0x72, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x77, 0x72, 0x69, + 0x74, 0x74, 0x65, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, + 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x68, 0x61, 0x73, 0x20, 0x62, 0x65, + 0x65, 0x6e, 0x20, 0x64, 0x6f, 0x77, 0x6e, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x2e, 0x20, 0x52, + 0x65, 0x66, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x0a, 0x0a, 0x0f, 0x0a, + 0x07, 0x04, 0x09, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x04, 0xb4, 0x02, 0x04, 0x13, 0x0a, 0x0f, + 0x0a, 0x07, 0x04, 0x09, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x04, 0xb4, 0x02, 0x16, 0x17, 0x0a, + 0x42, 0x0a, 0x06, 0x04, 0x09, 0x04, 0x00, 0x02, 0x02, 0x12, 0x04, 0xb6, 0x02, 0x04, 0x18, 0x1a, + 0x32, 0x20, 0x4c, 0x61, 0x72, 0x67, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x20, + 0x28, 0x6f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x29, 0x20, 0x77, 0x69, 0x6c, 0x6c, + 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x64, 0x6f, 0x77, 0x6e, 0x6c, 0x6f, 0x61, 0x64, + 0x65, 0x64, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x04, + 0xb6, 0x02, 0x04, 0x13, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x04, 0x00, 0x02, 0x02, 0x02, 0x12, + 0x04, 0xb6, 0x02, 0x16, 0x17, 0x0a, 0x2b, 0x0a, 0x04, 0x04, 0x09, 0x04, 0x01, 0x12, 0x06, 0xb9, + 0x02, 0x02, 0xc0, 0x02, 0x03, 0x1a, 0x1b, 0x20, 0x4d, 0x6f, 0x64, 0x65, 0x20, 0x74, 0x6f, 0x20, + 0x75, 0x73, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x6e, + 0x67, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x04, 0x01, 0x01, 0x12, 0x04, 0xb9, 0x02, 0x07, + 0x11, 0x0a, 0x4a, 0x0a, 0x06, 0x04, 0x09, 0x04, 0x01, 0x02, 0x00, 0x12, 0x04, 0xbb, 0x02, 0x04, + 0x17, 0x1a, 0x3a, 0x20, 0x41, 0x6c, 0x6c, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x77, 0x69, 0x6c, + 0x6c, 0x20, 0x62, 0x65, 0x20, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20, 0x61, 0x66, + 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x65, 0x78, 0x69, 0x74, 0x73, 0x0a, 0x0a, 0x0f, 0x0a, + 0x07, 0x04, 0x09, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x04, 0xbb, 0x02, 0x04, 0x12, 0x0a, 0x0f, + 0x0a, 0x07, 0x04, 0x09, 0x04, 0x01, 0x02, 0x00, 0x02, 0x12, 0x04, 0xbb, 0x02, 0x15, 0x16, 0x0a, + 0x62, 0x0a, 0x06, 0x04, 0x09, 0x04, 0x01, 0x02, 0x01, 0x12, 0x04, 0xbd, 0x02, 0x04, 0x15, 0x1a, + 0x52, 0x20, 0x44, 0x61, 0x74, 0x61, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x75, + 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x69, 0x74, 0x20, 0x61, 0x70, + 0x70, 0x65, 0x61, 0x72, 0x73, 0x2e, 0x20, 0x52, 0x65, 0x66, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x04, + 0xbd, 0x02, 0x04, 0x10, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x04, 0x01, 0x02, 0x01, 0x02, 0x12, + 0x04, 0xbd, 0x02, 0x13, 0x14, 0x0a, 0x4c, 0x0a, 0x06, 0x04, 0x09, 0x04, 0x01, 0x02, 0x02, 0x12, + 0x04, 0xbf, 0x02, 0x04, 0x16, 0x1a, 0x3c, 0x20, 0x44, 0x61, 0x74, 0x61, 0x20, 0x77, 0x69, 0x6c, + 0x6c, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x65, + 0x64, 0x2c, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, + 0x65, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x77, 0x72, 0x69, 0x74, 0x74, + 0x65, 0x6e, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x04, + 0xbf, 0x02, 0x04, 0x11, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x04, 0x01, 0x02, 0x02, 0x02, 0x12, + 0x04, 0xbf, 0x02, 0x14, 0x15, 0x0a, 0x2f, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x00, 0x12, 0x04, 0xc2, + 0x02, 0x02, 0x21, 0x1a, 0x21, 0x20, 0x4d, 0x6f, 0x64, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, + 0x65, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x20, 0x64, 0x6f, 0x77, 0x6e, + 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x06, 0x12, + 0x04, 0xc2, 0x02, 0x02, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x04, + 0xc2, 0x02, 0x0f, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, 0x04, 0xc2, + 0x02, 0x1f, 0x20, 0x0a, 0x2d, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x01, 0x12, 0x04, 0xc4, 0x02, 0x02, + 0x1d, 0x1a, 0x1f, 0x20, 0x4d, 0x6f, 0x64, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x20, + 0x74, 0x6f, 0x20, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x20, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, + 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x06, 0x12, 0x04, 0xc4, 0x02, 0x02, + 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x01, 0x12, 0x04, 0xc4, 0x02, 0x0d, 0x18, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x03, 0x12, 0x04, 0xc4, 0x02, 0x1b, 0x1c, 0x0a, + 0xe5, 0x02, 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x06, 0xca, 0x02, 0x00, 0xe6, 0x02, 0x01, 0x1a, 0xd6, + 0x02, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x61, 0x77, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x20, 0x75, 0x73, + 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x20, 0x43, 0x6f, + 0x50, 0x69, 0x6c, 0x6f, 0x74, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x0a, 0x20, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x50, 0x69, 0x6c, 0x6f, 0x74, 0x2c, 0x20, 0x65, 0x6c, + 0x69, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x65, + 0x64, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6b, 0x69, 0x74, 0x20, 0x6f, + 0x72, 0x20, 0x73, 0x64, 0x6b, 0x20, 0x69, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x2e, 0x20, 0x41, 0x6e, 0x79, 0x20, + 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, + 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x73, 0x65, 0x72, 0x73, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x61, 0x72, 0x65, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2d, + 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, + 0x70, 0x75, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x0a, 0x20, 0x41, 0x6e, 0x79, 0x20, 0x6f, 0x75, + 0x74, 0x70, 0x75, 0x74, 0x73, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, + 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x63, 0x6f, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x2d, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x6f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, + 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x75, 0x70, 0x6c, + 0x6f, 0x61, 0x64, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0a, 0x01, 0x12, 0x04, + 0xca, 0x02, 0x08, 0x19, 0x0a, 0xb2, 0x03, 0x0a, 0x04, 0x04, 0x0a, 0x04, 0x00, 0x12, 0x06, 0xcf, + 0x02, 0x02, 0xd5, 0x02, 0x03, 0x1a, 0xa1, 0x03, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, + 0x4d, 0x61, 0x70, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x64, 0x65, 0x63, 0x69, 0x64, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x66, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x6d, 0x61, 0x64, 0x65, + 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x20, 0x49, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, + 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x20, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x64, 0x65, 0x66, + 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, + 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x75, + 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x20, 0x66, 0x6f, 0x72, + 0x6d, 0x61, 0x74, 0x2e, 0x0a, 0x20, 0x4a, 0x53, 0x4f, 0x4e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x59, + 0x41, 0x4d, 0x4c, 0x20, 0x64, 0x6f, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x20, + 0x61, 0x6e, 0x79, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x20, 0x64, 0x65, 0x66, + 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x61, 0x64, + 0x20, 0x69, 0x74, 0x0a, 0x20, 0x41, 0x6c, 0x6c, 0x20, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x20, + 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, 0x70, 0x20, 0x61, 0x72, + 0x65, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, + 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x20, 0x28, 0x74, 0x68, 0x65, + 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x69, 0x73, 0x20, 0x64, 0x6f, 0x77, 0x6e, 0x6c, 0x6f, 0x61, + 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x69, 0x6c, + 0x65, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x29, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x04, + 0x00, 0x01, 0x12, 0x04, 0xcf, 0x02, 0x07, 0x17, 0x0a, 0xcd, 0x01, 0x0a, 0x06, 0x04, 0x0a, 0x04, + 0x00, 0x02, 0x00, 0x12, 0x04, 0xd1, 0x02, 0x04, 0x0d, 0x1a, 0xbc, 0x01, 0x20, 0x4a, 0x53, 0x4f, + 0x4e, 0x20, 0x2f, 0x20, 0x59, 0x41, 0x4d, 0x4c, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x28, 0x77, 0x68, 0x69, 0x63, 0x68, + 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, + 0x64, 0x20, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x73, 0x29, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, + 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6e, 0x6c, 0x69, 0x6e, + 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x6e, 0x64, + 0x61, 0x72, 0x64, 0x20, 0x6a, 0x73, 0x6f, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x20, 0x2d, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77, + 0x77, 0x2e, 0x6a, 0x73, 0x6f, 0x6e, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x6a, 0x73, 0x6f, 0x6e, 0x2d, + 0x65, 0x6e, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, 0x04, 0x00, + 0x02, 0x00, 0x01, 0x12, 0x04, 0xd1, 0x02, 0x04, 0x08, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, 0x04, + 0x00, 0x02, 0x00, 0x02, 0x12, 0x04, 0xd1, 0x02, 0x0b, 0x0c, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0a, + 0x04, 0x00, 0x02, 0x01, 0x12, 0x04, 0xd2, 0x02, 0x04, 0x0d, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, + 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x04, 0xd2, 0x02, 0x04, 0x08, 0x0a, 0x0f, 0x0a, 0x07, 0x04, + 0x0a, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x04, 0xd2, 0x02, 0x0b, 0x0c, 0x0a, 0x5c, 0x0a, 0x06, + 0x04, 0x0a, 0x04, 0x00, 0x02, 0x02, 0x12, 0x04, 0xd4, 0x02, 0x04, 0x0e, 0x1a, 0x4c, 0x20, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, + 0x69, 0x7a, 0x65, 0x64, 0x20, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x60, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, 0x70, 0x60, + 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, + 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x04, 0xd4, 0x02, 0x04, 0x09, 0x0a, 0x0f, 0x0a, 0x07, 0x04, + 0x0a, 0x04, 0x00, 0x02, 0x02, 0x02, 0x12, 0x04, 0xd4, 0x02, 0x0c, 0x0d, 0x0a, 0x63, 0x0a, 0x04, + 0x04, 0x0a, 0x02, 0x00, 0x12, 0x04, 0xd7, 0x02, 0x02, 0x13, 0x1a, 0x55, 0x20, 0x46, 0x6c, 0x61, + 0x67, 0x20, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x44, 0x61, 0x74, 0x61, 0x4c, 0x6f, + 0x61, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x20, 0x49, 0x66, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x65, 0x74, + 0x2c, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x77, + 0x69, 0x6c, 0x6c, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x21, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x05, 0x12, 0x04, 0xd7, 0x02, 0x02, 0x06, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x04, 0xd7, 0x02, 0x07, 0x0e, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, 0x04, 0xd7, 0x02, 0x11, 0x12, 0x0a, 0xed, + 0x05, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x01, 0x12, 0x04, 0xdf, 0x02, 0x02, 0x18, 0x1a, 0xde, 0x05, + 0x20, 0x46, 0x69, 0x6c, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x70, 0x61, 0x74, + 0x68, 0x20, 0x28, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x61, 0x74, 0x20, 0x72, 0x6f, 0x6f, 0x74, + 0x29, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x20, 0x77, + 0x69, 0x6c, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x61, 0x6c, 0x6c, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x20, 0x65, 0x78, 0x70, 0x6c, 0x6f, + 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, + 0x65, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2e, 0x0a, 0x20, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, + 0x2c, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x73, 0x20, 0x28, + 0x78, 0x3a, 0x20, 0x69, 0x6e, 0x74, 0x2c, 0x20, 0x79, 0x3a, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x2c, + 0x20, 0x7a, 0x3a, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c, + 0x6f, 0x62, 0x29, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x70, 0x75, + 0x74, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x69, 0x73, 0x20, 0x27, 0x2f, 0x76, 0x61, 0x72, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x27, 0x2c, 0x20, 0x74, + 0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x73, 0x79, 0x73, + 0x74, 0x65, 0x6d, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x20, 0x6c, 0x69, + 0x6b, 0x65, 0x0a, 0x20, 0x2f, 0x76, 0x61, 0x72, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x69, + 0x6e, 0x70, 0x75, 0x74, 0x73, 0x2f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x2e, 0x3c, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x64, 0x65, + 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x74, 0x20, 0x2d, 0x3e, 0x20, 0x2e, 0x70, 0x62, 0x20, 0x2e, + 0x6a, 0x73, 0x6f, 0x6e, 0x20, 0x2e, 0x79, 0x61, 0x6d, 0x6c, 0x3e, 0x20, 0x2d, 0x3e, 0x20, 0x46, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x61, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, + 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x2e, 0x20, 0x54, 0x68, 0x65, + 0x20, 0x42, 0x6c, 0x6f, 0x62, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, + 0x61, 0x72, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x72, 0x65, + 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x69, + 0x6c, 0x65, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, + 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x0a, 0x20, 0x2f, 0x76, 0x61, 0x72, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x2f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x2f, 0x78, 0x20, 0x2d, 0x3e, 0x20, 0x58, 0x20, 0x69, + 0x73, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x20, 0x6f, 0x66, 0x20, 0x78, 0x20, 0x28, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x29, 0x20, + 0x69, 0x6e, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, + 0x0a, 0x20, 0x2f, 0x76, 0x61, 0x72, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x69, 0x6e, 0x70, + 0x75, 0x74, 0x73, 0x2f, 0x79, 0x20, 0x2d, 0x3e, 0x20, 0x59, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, + 0x66, 0x69, 0x6c, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x20, 0x66, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x0a, 0x20, 0x2f, 0x76, 0x61, 0x72, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x2f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x2f, 0x7a, 0x2f, 0x2e, 0x2e, 0x2e, 0x20, 0x2d, + 0x3e, 0x20, 0x4e, 0x6f, 0x74, 0x65, 0x20, 0x5a, 0x20, 0x69, 0x74, 0x73, 0x65, 0x6c, 0x66, 0x20, + 0x69, 0x73, 0x20, 0x61, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x79, 0x0a, 0x20, + 0x4d, 0x6f, 0x72, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x63, 0x6f, 0x6c, 0x20, 0x2d, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x64, + 0x6f, 0x63, 0x73, 0x20, 0x23, 0x54, 0x4f, 0x44, 0x4f, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, + 0x6e, 0x63, 0x65, 0x20, 0x64, 0x6f, 0x63, 0x73, 0x20, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x05, 0x12, 0x04, 0xdf, 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0a, 0x02, 0x01, 0x01, 0x12, 0x04, 0xdf, 0x02, 0x09, 0x13, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0a, 0x02, 0x01, 0x03, 0x12, 0x04, 0xdf, 0x02, 0x16, 0x17, 0x0a, 0x98, 0x01, 0x0a, 0x04, + 0x04, 0x0a, 0x02, 0x02, 0x12, 0x04, 0xe1, 0x02, 0x02, 0x19, 0x1a, 0x89, 0x01, 0x20, 0x46, 0x69, + 0x6c, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x28, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x61, 0x74, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x29, 0x2e, 0x20, + 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x20, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x76, + 0x69, 0x64, 0x75, 0x61, 0x6c, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x2f, + 0x6f, 0x72, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x74, 0x65, 0x78, 0x74, + 0x20, 0x66, 0x69, 0x6c, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x05, 0x12, + 0x04, 0xe1, 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x01, 0x12, 0x04, + 0xe1, 0x02, 0x09, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x03, 0x12, 0x04, 0xe1, + 0x02, 0x17, 0x18, 0x0a, 0xa5, 0x02, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x03, 0x12, 0x04, 0xe4, 0x02, + 0x02, 0x1e, 0x1a, 0x96, 0x02, 0x20, 0x49, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x70, + 0x75, 0x74, 0x73, 0x20, 0x66, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x72, + 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x64, 0x64, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x2f, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x72, 0x65, 0x66, 0x65, + 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x66, 0x69, + 0x6c, 0x65, 0x73, 0x20, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x70, + 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2e, + 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x64, 0x65, + 0x63, 0x69, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, + 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x20, 0x52, 0x65, 0x66, 0x65, 0x72, 0x20, 0x74, 0x6f, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, + 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0a, 0x02, 0x03, 0x06, 0x12, 0x04, 0xe4, 0x02, 0x02, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, + 0x02, 0x03, 0x01, 0x12, 0x04, 0xe4, 0x02, 0x13, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, + 0x03, 0x03, 0x12, 0x04, 0xe4, 0x02, 0x1c, 0x1d, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x04, + 0x12, 0x04, 0xe5, 0x02, 0x02, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x04, 0x06, 0x12, + 0x04, 0xe5, 0x02, 0x02, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, + 0xe5, 0x02, 0x0d, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0xe5, + 0x02, 0x1b, 0x1c, 0x0a, 0x67, 0x0a, 0x02, 0x04, 0x0b, 0x12, 0x06, 0xe9, 0x02, 0x00, 0xfe, 0x02, + 0x01, 0x1a, 0x59, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x61, 0x20, 0x70, 0x6f, + 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x64, 0x64, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x70, 0x6f, 0x64, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x64, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x69, + 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, + 0x04, 0x0b, 0x01, 0x12, 0x04, 0xe9, 0x02, 0x08, 0x0e, 0x0a, 0x4b, 0x0a, 0x04, 0x04, 0x0b, 0x02, + 0x00, 0x12, 0x04, 0xeb, 0x02, 0x02, 0x21, 0x1a, 0x3d, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x73, 0x20, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, + 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, + 0x20, 0x70, 0x6f, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x06, 0x12, + 0x04, 0xeb, 0x02, 0x02, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x01, 0x12, 0x04, + 0xeb, 0x02, 0x14, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x03, 0x12, 0x04, 0xeb, + 0x02, 0x1f, 0x20, 0x0a, 0xe2, 0x02, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x01, 0x12, 0x04, 0xf1, 0x02, + 0x02, 0x26, 0x1a, 0xd3, 0x02, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x20, 0x70, 0x6f, 0x64, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, + 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x69, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x65, 0x64, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x4a, 0x53, 0x4f, 0x4e, 0x2d, 0x6d, 0x61, 0x72, 0x73, 0x68, + 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x20, 0x70, 0x6f, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x2c, 0x20, + 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x64, 0x65, 0x66, + 0x69, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x0a, 0x20, 0x2d, 0x20, 0x67, 0x6f, 0x2c, 0x20, 0x75, + 0x73, 0x69, 0x6e, 0x67, 0x3a, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, + 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, + 0x74, 0x65, 0x73, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x72, 0x65, 0x6c, + 0x65, 0x61, 0x73, 0x65, 0x2d, 0x31, 0x2e, 0x32, 0x31, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x76, + 0x31, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x67, 0x6f, 0x23, 0x4c, 0x32, 0x39, 0x33, 0x36, + 0x0a, 0x20, 0x2d, 0x20, 0x70, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x3a, 0x20, 0x75, 0x73, 0x69, 0x6e, + 0x67, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, + 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x2d, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x70, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, + 0x6f, 0x62, 0x2f, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x2d, 0x31, 0x39, 0x2e, 0x30, 0x2f, + 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x2f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2f, 0x76, 0x31, 0x5f, 0x70, 0x6f, 0x64, 0x5f, + 0x73, 0x70, 0x65, 0x63, 0x2e, 0x70, 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, + 0x06, 0x12, 0x04, 0xf1, 0x02, 0x02, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x01, + 0x12, 0x04, 0xf1, 0x02, 0x19, 0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x03, 0x12, + 0x04, 0xf1, 0x02, 0x24, 0x25, 0x0a, 0x90, 0x05, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x02, 0x12, 0x04, + 0xfa, 0x02, 0x02, 0x24, 0x1a, 0x81, 0x05, 0x20, 0x42, 0x45, 0x54, 0x41, 0x3a, 0x20, 0x4f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x44, 0x61, 0x74, 0x61, 0x4c, 0x6f, 0x61, + 0x64, 0x69, 0x6e, 0x67, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x64, 0x65, 0x66, + 0x61, 0x75, 0x6c, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, + 0x75, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x61, 0x6b, 0x65, + 0x73, 0x20, 0x69, 0x74, 0x20, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x74, 0x6f, + 0x20, 0x74, 0x6f, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, + 0x74, 0x65, 0x6c, 0x79, 0x20, 0x70, 0x6f, 0x72, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x2c, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x75, 0x73, + 0x65, 0x73, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6f, 0x75, + 0x74, 0x70, 0x75, 0x74, 0x73, 0x0a, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x66, 0x72, 0x6f, 0x6d, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2d, + 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x6f, + 0x75, 0x74, 0x20, 0x68, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x72, 0x65, + 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x6b, 0x69, 0x74, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x73, 0x75, 0x70, + 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x6f, 0x6e, 0x20, 0x4b, + 0x38, 0x73, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, + 0x2e, 0x0a, 0x20, 0x49, 0x66, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x69, + 0x6e, 0x67, 0x20, 0x69, 0x73, 0x20, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x2c, 0x20, 0x74, + 0x68, 0x65, 0x6e, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, + 0x20, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x63, 0x63, 0x6f, + 0x6d, 0x70, 0x61, 0x6e, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x69, 0x65, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x69, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x44, 0x61, 0x74, 0x61, 0x4c, 0x6f, 0x61, 0x64, 0x69, 0x6e, + 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x0a, 0x20, 0x61, 0x72, 0x65, + 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2c, 0x20, + 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x6d, + 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x74, 0x6f, 0x20, 0x61, 0x6e, 0x64, 0x20, + 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, + 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x20, + 0x70, 0x72, 0x65, 0x2d, 0x64, 0x65, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x66, + 0x69, 0x6c, 0x65, 0x2d, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x70, 0x61, 0x74, 0x68, 0x2e, + 0x20, 0x52, 0x65, 0x66, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x6f, + 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x74, 0x6f, 0x20, + 0x75, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, + 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x70, 0x61, 0x74, 0x68, 0x73, 0x2e, 0x0a, 0x20, 0x4f, + 0x6e, 0x6c, 0x79, 0x20, 0x4b, 0x38, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x02, + 0x06, 0x12, 0x04, 0xfa, 0x02, 0x02, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x02, 0x01, + 0x12, 0x04, 0xfa, 0x02, 0x14, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x02, 0x03, 0x12, + 0x04, 0xfa, 0x02, 0x22, 0x23, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x03, 0x12, 0x04, 0xfd, + 0x02, 0x02, 0x24, 0x1a, 0x4c, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x70, 0x6f, + 0x64, 0x20, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x72, + 0x69, 0x64, 0x65, 0x20, 0x69, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x03, 0x05, 0x12, 0x04, 0xfd, 0x02, 0x02, 0x08, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x03, 0x01, 0x12, 0x04, 0xfd, 0x02, 0x09, 0x1f, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x03, 0x03, 0x12, 0x04, 0xfd, 0x02, 0x22, 0x23, 0x0a, 0x52, + 0x0a, 0x02, 0x04, 0x0c, 0x12, 0x06, 0x81, 0x03, 0x00, 0x87, 0x03, 0x01, 0x1a, 0x44, 0x20, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x75, 0x69, 0x6c, + 0x64, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, + 0x73, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x61, 0x20, + 0x74, 0x61, 0x73, 0x6b, 0x20, 0x69, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, + 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0c, 0x01, 0x12, 0x04, 0x81, 0x03, 0x08, 0x19, 0x0a, + 0x3d, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x00, 0x12, 0x04, 0x83, 0x03, 0x02, 0x21, 0x1a, 0x2f, 0x20, + 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x20, + 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6f, + 0x64, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x06, 0x12, 0x04, 0x83, 0x03, 0x02, 0x15, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0c, 0x02, 0x00, 0x01, 0x12, 0x04, 0x83, 0x03, 0x16, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0c, 0x02, 0x00, 0x03, 0x12, 0x04, 0x83, 0x03, 0x1f, 0x20, 0x0a, 0x42, 0x0a, 0x04, 0x04, + 0x0c, 0x02, 0x01, 0x12, 0x04, 0x86, 0x03, 0x02, 0x26, 0x1a, 0x34, 0x20, 0x4f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x20, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, + 0x6f, 0x64, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x06, 0x12, 0x04, 0x86, 0x03, 0x02, 0x15, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x01, 0x12, 0x04, 0x86, 0x03, 0x16, 0x21, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0c, 0x02, 0x01, 0x03, 0x12, 0x04, 0x86, 0x03, 0x24, 0x25, 0x0a, 0x53, 0x0a, 0x02, + 0x04, 0x0d, 0x12, 0x06, 0x8a, 0x03, 0x00, 0x9d, 0x03, 0x01, 0x1a, 0x45, 0x20, 0x53, 0x71, 0x6c, + 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x20, 0x67, 0x65, + 0x6e, 0x65, 0x72, 0x69, 0x63, 0x20, 0x73, 0x71, 0x6c, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, + 0x61, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, + 0x65, 0x6e, 0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x64, 0x69, 0x61, 0x6c, 0x65, 0x63, 0x74, 0x2e, + 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0d, 0x01, 0x12, 0x04, 0x8a, 0x03, 0x08, 0x0b, 0x0a, 0xa2, + 0x02, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x00, 0x12, 0x04, 0x92, 0x03, 0x02, 0x17, 0x1a, 0x93, 0x02, + 0x20, 0x54, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, + 0x79, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x75, 0x6e, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x71, 0x75, + 0x65, 0x72, 0x79, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x65, 0x6d, + 0x70, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, + 0x73, 0x2e, 0x0a, 0x20, 0x57, 0x65, 0x20, 0x75, 0x73, 0x65, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x27, 0x73, 0x20, 0x47, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x20, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x20, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x69, 0x6e, 0x67, + 0x2e, 0x0a, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2c, 0x0a, + 0x20, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, + 0x65, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x27, 0x7b, 0x7b, 0x20, + 0x2e, 0x72, 0x61, 0x77, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x44, 0x61, 0x74, 0x61, 0x50, 0x72, + 0x65, 0x66, 0x69, 0x78, 0x20, 0x7d, 0x7d, 0x27, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x64, 0x20, + 0x61, 0x73, 0x20, 0x70, 0x61, 0x72, 0x71, 0x75, 0x65, 0x74, 0x0a, 0x20, 0x73, 0x65, 0x6c, 0x65, + 0x63, 0x74, 0x20, 0x2a, 0x0a, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6d, 0x79, 0x5f, 0x74, 0x61, + 0x62, 0x6c, 0x65, 0x0a, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x64, 0x73, 0x20, 0x3d, 0x20, + 0x27, 0x7b, 0x7b, 0x20, 0x2e, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x2e, 0x64, 0x73, 0x20, 0x7d, + 0x7d, 0x27, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x05, 0x12, 0x04, 0x92, 0x03, + 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x01, 0x12, 0x04, 0x92, 0x03, 0x09, + 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x03, 0x12, 0x04, 0x92, 0x03, 0x15, 0x16, + 0x0a, 0xa0, 0x02, 0x0a, 0x04, 0x04, 0x0d, 0x04, 0x00, 0x12, 0x06, 0x96, 0x03, 0x02, 0x9b, 0x03, + 0x03, 0x1a, 0x8f, 0x02, 0x20, 0x54, 0x68, 0x65, 0x20, 0x64, 0x69, 0x61, 0x6c, 0x65, 0x63, 0x74, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x53, 0x51, 0x4c, 0x20, 0x73, 0x74, 0x61, 0x74, + 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x75, + 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x20, + 0x61, 0x6e, 0x64, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x20, 0x53, 0x51, 0x4c, 0x20, 0x73, 0x74, + 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x74, 0x20, 0x63, 0x6f, 0x6d, 0x70, + 0x69, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x74, 0x6f, 0x20, + 0x61, 0x76, 0x6f, 0x69, 0x64, 0x0a, 0x20, 0x65, 0x78, 0x70, 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, + 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x73, 0x65, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x61, + 0x6e, 0x20, 0x75, 0x6e, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x64, 0x69, + 0x61, 0x6c, 0x65, 0x63, 0x74, 0x2c, 0x20, 0x6e, 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x64, 0x6f, 0x6e, + 0x65, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, + 0x6e, 0x74, 0x2e, 0x0a, 0x20, 0x57, 0x65, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x69, + 0x61, 0x6c, 0x65, 0x63, 0x74, 0x3a, 0x20, 0x61, 0x6e, 0x73, 0x69, 0x2c, 0x20, 0x68, 0x69, 0x76, + 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x04, 0x00, 0x01, 0x12, 0x04, 0x96, 0x03, + 0x07, 0x0e, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0d, 0x04, 0x00, 0x02, 0x00, 0x12, 0x04, 0x97, 0x03, + 0x04, 0x12, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0d, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, 0x97, + 0x03, 0x04, 0x0d, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0d, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x04, + 0x97, 0x03, 0x10, 0x11, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0d, 0x04, 0x00, 0x02, 0x01, 0x12, 0x04, + 0x98, 0x03, 0x04, 0x0d, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0d, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, + 0x04, 0x98, 0x03, 0x04, 0x08, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0d, 0x04, 0x00, 0x02, 0x01, 0x02, + 0x12, 0x04, 0x98, 0x03, 0x0b, 0x0c, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0d, 0x04, 0x00, 0x02, 0x02, + 0x12, 0x04, 0x99, 0x03, 0x04, 0x0d, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0d, 0x04, 0x00, 0x02, 0x02, + 0x01, 0x12, 0x04, 0x99, 0x03, 0x04, 0x08, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0d, 0x04, 0x00, 0x02, + 0x02, 0x02, 0x12, 0x04, 0x99, 0x03, 0x0b, 0x0c, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0d, 0x04, 0x00, + 0x02, 0x03, 0x12, 0x04, 0x9a, 0x03, 0x04, 0x0e, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0d, 0x04, 0x00, + 0x02, 0x03, 0x01, 0x12, 0x04, 0x9a, 0x03, 0x04, 0x09, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0d, 0x04, + 0x00, 0x02, 0x03, 0x02, 0x12, 0x04, 0x9a, 0x03, 0x0c, 0x0d, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0d, + 0x02, 0x01, 0x12, 0x04, 0x9c, 0x03, 0x02, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, + 0x06, 0x12, 0x04, 0x9c, 0x03, 0x02, 0x09, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x01, + 0x12, 0x04, 0x9c, 0x03, 0x0a, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x03, 0x12, + 0x04, 0x9c, 0x03, 0x14, 0x15, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xdd, 0x08, + 0x0a, 0x1c, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x1a, 0x1c, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, + 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x5c, 0x0a, 0x15, + 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x52, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x2b, 0x0a, + 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, + 0x72, 0x75, 0x63, 0x74, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x42, 0xaf, 0x01, 0x0a, 0x12, 0x63, + 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x42, 0x0c, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, + 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, + 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x63, 0x6f, 0x72, 0x65, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0xca, 0x02, 0x0e, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0xe2, 0x02, 0x1a, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x47, + 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x4a, 0xf6, 0x05, 0x0a, + 0x06, 0x12, 0x04, 0x00, 0x00, 0x13, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, + 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x17, 0x0a, 0x09, 0x0a, 0x02, 0x03, + 0x00, 0x12, 0x03, 0x04, 0x00, 0x26, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x06, 0x00, 0x49, + 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x06, 0x00, 0x49, 0x0a, 0x72, 0x0a, 0x02, 0x04, + 0x00, 0x12, 0x04, 0x09, 0x00, 0x13, 0x01, 0x1a, 0x66, 0x20, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, + 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x65, + 0x74, 0x72, 0x69, 0x63, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x72, 0x65, 0x20, 0x63, + 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x64, 0x75, 0x72, 0x69, 0x6e, 0x67, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, + 0x20, 0x61, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x09, 0x08, 0x1d, 0x0a, 0x7d, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x00, 0x12, 0x03, 0x0b, 0x02, 0x14, 0x1a, 0x70, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, + 0x65, 0x74, 0x72, 0x69, 0x63, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, + 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x20, 0x65, 0x2e, 0x67, 0x2e, + 0x20, 0x45, 0x58, 0x45, 0x43, 0x55, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x4d, 0x45, 0x54, 0x52, 0x49, + 0x43, 0x5f, 0x55, 0x53, 0x45, 0x44, 0x5f, 0x43, 0x50, 0x55, 0x5f, 0x41, 0x56, 0x47, 0x20, 0x6f, + 0x72, 0x20, 0x45, 0x58, 0x45, 0x43, 0x55, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x4d, 0x45, 0x54, 0x52, + 0x49, 0x43, 0x5f, 0x55, 0x53, 0x45, 0x44, 0x5f, 0x4d, 0x45, 0x4d, 0x4f, 0x52, 0x59, 0x5f, 0x42, + 0x59, 0x54, 0x45, 0x53, 0x5f, 0x41, 0x56, 0x47, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x05, 0x12, 0x03, 0x0b, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x0b, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x0b, 0x12, 0x13, 0x0a, 0xe4, 0x02, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x12, + 0x02, 0x22, 0x1a, 0xd6, 0x02, 0x20, 0x54, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x69, 0x6e, 0x20, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, + 0x65, 0x75, 0x73, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x20, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x0a, 0x20, 0x68, + 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x65, 0x75, + 0x73, 0x2e, 0x69, 0x6f, 0x2f, 0x64, 0x6f, 0x63, 0x73, 0x2f, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, + 0x68, 0x65, 0x75, 0x73, 0x2f, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x71, 0x75, 0x65, 0x72, + 0x79, 0x69, 0x6e, 0x67, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x23, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x2d, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2d, 0x72, 0x65, 0x73, 0x75, 0x6c, + 0x74, 0x2d, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x73, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x6d, 0x61, 0x79, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x6d, 0x75, 0x6c, + 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x73, 0x65, 0x72, 0x69, 0x65, + 0x73, 0x2c, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x69, 0x72, 0x20, 0x6d, 0x65, 0x74, 0x72, 0x69, + 0x63, 0x20, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x2e, 0x0a, 0x20, 0x53, 0x74, 0x61, 0x72, 0x74, + 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x69, 0x73, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, + 0x20, 0x6f, 0x66, 0x20, 0x28, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, + 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x2c, 0x20, 0x34, 0x38, + 0x68, 0x20, 0x61, 0x67, 0x6f, 0x29, 0x0a, 0x20, 0x45, 0x6e, 0x64, 0x20, 0x74, 0x69, 0x6d, 0x65, + 0x20, 0x69, 0x73, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x28, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, + 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x20, 0x6e, 0x6f, 0x77, 0x29, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x12, 0x02, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x12, 0x19, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x12, 0x20, 0x21, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xde, 0x1b, + 0x0a, 0x1c, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x1a, 0x1f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, + 0x49, 0x0a, 0x12, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, + 0x63, 0x74, 0x54, 0x61, 0x67, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, + 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x72, 0x74, 0x69, + 0x66, 0x61, 0x63, 0x74, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x86, 0x02, 0x0a, 0x0f, 0x43, + 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x39, + 0x0a, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x09, + 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x49, 0x64, 0x12, 0x45, 0x0a, 0x0c, 0x61, 0x72, 0x74, + 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x74, 0x61, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, + 0x54, 0x61, 0x67, 0x52, 0x0b, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x54, 0x61, 0x67, + 0x12, 0x5d, 0x0a, 0x15, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x74, 0x61, 0x73, 0x6b, 0x5f, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x13, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x42, + 0x12, 0x0a, 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x22, 0x9e, 0x01, 0x0a, 0x12, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x52, + 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x87, 0x01, 0x0a, 0x06, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x14, 0x52, 0x45, 0x53, 0x45, 0x52, 0x56, 0x41, + 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x49, 0x53, 0x41, 0x42, 0x4c, 0x45, 0x44, 0x10, 0x00, 0x12, + 0x18, 0x0a, 0x14, 0x52, 0x45, 0x53, 0x45, 0x52, 0x56, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, + 0x43, 0x51, 0x55, 0x49, 0x52, 0x45, 0x44, 0x10, 0x01, 0x12, 0x16, 0x0a, 0x12, 0x52, 0x45, 0x53, + 0x45, 0x52, 0x56, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x58, 0x49, 0x53, 0x54, 0x53, 0x10, + 0x02, 0x12, 0x18, 0x0a, 0x14, 0x52, 0x45, 0x53, 0x45, 0x52, 0x56, 0x41, 0x54, 0x49, 0x4f, 0x4e, + 0x5f, 0x52, 0x45, 0x4c, 0x45, 0x41, 0x53, 0x45, 0x44, 0x10, 0x03, 0x12, 0x17, 0x0a, 0x13, 0x52, + 0x45, 0x53, 0x45, 0x52, 0x56, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, + 0x52, 0x45, 0x10, 0x04, 0x2a, 0xb3, 0x01, 0x0a, 0x12, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, + 0x43, 0x61, 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x12, 0x0a, 0x0e, 0x43, + 0x41, 0x43, 0x48, 0x45, 0x5f, 0x44, 0x49, 0x53, 0x41, 0x42, 0x4c, 0x45, 0x44, 0x10, 0x00, 0x12, + 0x0e, 0x0a, 0x0a, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x4d, 0x49, 0x53, 0x53, 0x10, 0x01, 0x12, + 0x0d, 0x0a, 0x09, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x48, 0x49, 0x54, 0x10, 0x02, 0x12, 0x13, + 0x0a, 0x0f, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x50, 0x4f, 0x50, 0x55, 0x4c, 0x41, 0x54, 0x45, + 0x44, 0x10, 0x03, 0x12, 0x18, 0x0a, 0x14, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x4c, 0x4f, 0x4f, + 0x4b, 0x55, 0x50, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x10, 0x04, 0x12, 0x15, 0x0a, + 0x11, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x50, 0x55, 0x54, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, + 0x52, 0x45, 0x10, 0x05, 0x12, 0x11, 0x0a, 0x0d, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x53, 0x4b, + 0x49, 0x50, 0x50, 0x45, 0x44, 0x10, 0x06, 0x12, 0x11, 0x0a, 0x0d, 0x43, 0x41, 0x43, 0x48, 0x45, + 0x5f, 0x45, 0x56, 0x49, 0x43, 0x54, 0x45, 0x44, 0x10, 0x07, 0x42, 0xaf, 0x01, 0x0a, 0x12, 0x63, + 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x42, 0x0c, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, + 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, + 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x63, 0x6f, 0x72, 0x65, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0xca, 0x02, 0x0e, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0xe2, 0x02, 0x1a, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x47, + 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x4a, 0xa7, 0x14, 0x0a, + 0x06, 0x12, 0x04, 0x00, 0x00, 0x3e, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, + 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x17, 0x0a, 0x09, 0x0a, 0x02, 0x03, + 0x00, 0x12, 0x03, 0x04, 0x00, 0x29, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x06, 0x00, 0x49, + 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x06, 0x00, 0x49, 0x0a, 0xb1, 0x01, 0x0a, 0x02, + 0x05, 0x00, 0x12, 0x04, 0x09, 0x00, 0x1a, 0x01, 0x1a, 0xa4, 0x01, 0x20, 0x49, 0x6e, 0x64, 0x69, + 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x20, 0x6f, 0x66, 0x20, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x43, 0x61, 0x63, 0x68, 0x69, + 0x6e, 0x67, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x77, + 0x68, 0x79, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, + 0x6d, 0x62, 0x65, 0x64, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x4e, + 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x69, 0x73, 0x2c, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x65, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x75, 0x73, 0x65, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x20, 0x61, 0x73, 0x20, 0x77, 0x65, 0x6c, 0x6c, + 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, 0x03, 0x09, 0x05, 0x17, 0x0a, 0x39, 0x0a, 0x04, 0x05, + 0x00, 0x02, 0x00, 0x12, 0x03, 0x0b, 0x02, 0x15, 0x1a, 0x2c, 0x20, 0x55, 0x73, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x63, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x77, 0x61, 0x73, 0x20, 0x64, 0x69, 0x73, + 0x61, 0x62, 0x6c, 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x0b, 0x02, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x0b, + 0x13, 0x14, 0x0a, 0x4c, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0d, 0x02, 0x11, 0x1a, + 0x3f, 0x20, 0x55, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, + 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, + 0x65, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x65, + 0x64, 0x20, 0x69, 0x6e, 0x20, 0x6e, 0x6f, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0d, 0x02, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x0d, 0x0f, 0x10, 0x0a, 0x61, 0x0a, 0x04, + 0x05, 0x00, 0x02, 0x02, 0x12, 0x03, 0x0f, 0x02, 0x10, 0x1a, 0x54, 0x20, 0x75, 0x73, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x20, 0x77, 0x61, 0x73, 0x20, 0x61, 0x20, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x70, 0x72, 0x65, 0x76, + 0x69, 0x6f, 0x75, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x0f, 0x02, 0x0b, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x0f, 0x0e, 0x0f, 0x0a, 0x52, 0x0a, 0x04, 0x05, + 0x00, 0x02, 0x03, 0x12, 0x03, 0x11, 0x02, 0x16, 0x1a, 0x45, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x61, 0x6e, 0x74, 0x20, 0x61, + 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x20, 0x77, 0x61, 0x73, 0x20, 0x61, 0x64, 0x64, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x11, 0x02, 0x11, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x11, 0x14, 0x15, 0x0a, 0x4c, 0x0a, 0x04, 0x05, + 0x00, 0x02, 0x04, 0x12, 0x03, 0x13, 0x02, 0x1b, 0x1a, 0x3f, 0x20, 0x55, 0x73, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x20, 0x66, 0x61, + 0x69, 0x6c, 0x65, 0x64, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, + 0x61, 0x6e, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, + 0x04, 0x01, 0x12, 0x03, 0x13, 0x02, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x04, 0x02, + 0x12, 0x03, 0x13, 0x19, 0x1a, 0x0a, 0x4c, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x05, 0x12, 0x03, 0x15, + 0x02, 0x18, 0x1a, 0x3f, 0x20, 0x55, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x64, + 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, + 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x20, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x62, + 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x72, 0x72, + 0x6f, 0x72, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x15, 0x02, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x05, 0x02, 0x12, 0x03, 0x15, 0x16, 0x17, 0x0a, + 0x3c, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x06, 0x12, 0x03, 0x17, 0x02, 0x14, 0x1a, 0x2f, 0x20, 0x55, + 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, + 0x20, 0x77, 0x61, 0x73, 0x20, 0x73, 0x6b, 0x69, 0x70, 0x70, 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x17, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x06, 0x02, 0x12, 0x03, 0x17, 0x12, 0x13, 0x0a, 0x3a, 0x0a, 0x04, 0x05, 0x00, 0x02, + 0x07, 0x12, 0x03, 0x19, 0x02, 0x14, 0x1a, 0x2d, 0x20, 0x55, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x77, 0x61, 0x73, 0x20, 0x65, 0x76, 0x69, + 0x63, 0x74, 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x07, 0x01, 0x12, 0x03, + 0x19, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x07, 0x02, 0x12, 0x03, 0x19, 0x12, + 0x13, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x1c, 0x00, 0x21, 0x01, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x1c, 0x08, 0x1a, 0x0a, 0x2c, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x00, 0x12, 0x03, 0x1e, 0x02, 0x19, 0x1a, 0x1f, 0x20, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, + 0x74, 0x20, 0x49, 0x44, 0x20, 0x69, 0x73, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, + 0x12, 0x03, 0x1e, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x1e, 0x09, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1e, 0x17, + 0x18, 0x0a, 0x4e, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x20, 0x02, 0x12, 0x1a, 0x41, + 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x67, 0x20, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, + 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x2c, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x68, 0x61, + 0x73, 0x68, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x20, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x20, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x20, 0x10, 0x11, 0x0a, 0x41, 0x0a, 0x02, 0x04, + 0x01, 0x12, 0x04, 0x24, 0x00, 0x2e, 0x01, 0x1a, 0x35, 0x20, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, + 0x67, 0x20, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, + 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x63, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x24, 0x08, 0x17, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x00, 0x12, 0x03, 0x26, 0x02, 0x1c, 0x1a, 0x1b, 0x20, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, + 0x74, 0x20, 0x49, 0x44, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x74, 0x61, + 0x6c, 0x6f, 0x67, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x26, + 0x02, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x26, 0x0d, 0x17, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x26, 0x1a, 0x1b, 0x0a, 0x2a, + 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x28, 0x02, 0x26, 0x1a, 0x1d, 0x20, 0x41, 0x72, + 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x20, 0x74, 0x61, 0x67, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x01, 0x06, 0x12, 0x03, 0x28, 0x02, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x28, 0x15, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x28, 0x24, 0x25, 0x0a, 0xb2, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x08, 0x00, 0x12, 0x04, 0x2a, + 0x02, 0x2d, 0x03, 0x1a, 0xa3, 0x01, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x3a, + 0x20, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2c, 0x20, 0x69, 0x66, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x20, 0x77, 0x61, + 0x73, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, + 0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x69, 0x6e, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, + 0x69, 0x73, 0x20, 0x61, 0x20, 0x6f, 0x6e, 0x65, 0x2d, 0x6f, 0x66, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x64, 0x65, 0x70, 0x65, 0x6e, + 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x67, + 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x08, + 0x00, 0x01, 0x12, 0x03, 0x2a, 0x08, 0x18, 0x0a, 0x7b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, + 0x03, 0x2c, 0x04, 0x36, 0x1a, 0x6e, 0x20, 0x54, 0x6f, 0x64, 0x61, 0x79, 0x20, 0x77, 0x65, 0x20, + 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x54, 0x61, 0x73, + 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x2c, 0x20, 0x61, 0x73, 0x20, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x20, 0x63, 0x61, 0x63, + 0x68, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x73, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x06, 0x12, 0x03, 0x2c, + 0x04, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x2c, 0x1c, 0x31, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x2c, 0x34, 0x35, 0x0a, 0x0a, + 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x30, 0x00, 0x3e, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, + 0x01, 0x12, 0x03, 0x30, 0x08, 0x1a, 0x0a, 0x48, 0x0a, 0x04, 0x04, 0x02, 0x04, 0x00, 0x12, 0x04, + 0x32, 0x02, 0x3d, 0x03, 0x1a, 0x3a, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x61, + 0x20, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x04, 0x00, 0x01, 0x12, 0x03, 0x32, 0x07, 0x0d, 0x0a, 0x40, + 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x34, 0x04, 0x1d, 0x1a, 0x31, 0x20, + 0x55, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x0a, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x34, 0x04, 0x18, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x34, 0x1b, 0x1c, + 0x0a, 0x5a, 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x36, 0x04, 0x1d, 0x1a, + 0x4b, 0x20, 0x55, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, + 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x61, 0x73, 0x20, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, + 0x73, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x20, 0x61, 0x63, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, + 0x6f, 0x72, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x02, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x36, 0x04, 0x18, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x02, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x36, 0x1b, 0x1c, 0x0a, 0x4d, 0x0a, 0x06, + 0x04, 0x02, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x38, 0x04, 0x1b, 0x1a, 0x3e, 0x20, 0x55, 0x73, + 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x72, 0x65, + 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, + 0x74, 0x6c, 0x79, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, + 0x02, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x38, 0x04, 0x16, 0x0a, 0x0e, 0x0a, 0x07, 0x04, + 0x02, 0x04, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x38, 0x19, 0x1a, 0x0a, 0x55, 0x0a, 0x06, 0x04, + 0x02, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x3a, 0x04, 0x1d, 0x1a, 0x46, 0x20, 0x55, 0x73, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x20, 0x73, 0x75, 0x63, 0x63, + 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x20, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, + 0x64, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x3a, + 0x04, 0x18, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x3a, + 0x1b, 0x1c, 0x0a, 0x52, 0x0a, 0x06, 0x04, 0x02, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, 0x3c, 0x04, + 0x1c, 0x1a, 0x43, 0x20, 0x55, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x64, 0x69, + 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x72, 0x65, 0x73, 0x65, + 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x66, 0x61, + 0x69, 0x6c, 0x75, 0x72, 0x65, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x04, + 0x01, 0x12, 0x03, 0x3c, 0x04, 0x17, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x04, 0x00, 0x02, 0x04, + 0x02, 0x12, 0x03, 0x3c, 0x1a, 0x1b, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0x92, + 0x0d, 0x0a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, + 0x65, 0x2f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x1a, 0x1e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xe7, + 0x01, 0x0a, 0x0e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x45, 0x72, 0x72, 0x6f, + 0x72, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x04, 0x63, 0x6f, 0x64, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, + 0x37, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, + 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x2e, 0x4b, 0x69, + 0x6e, 0x64, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x40, 0x0a, 0x06, 0x6f, 0x72, 0x69, 0x67, + 0x69, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x4b, 0x69, + 0x6e, 0x64, 0x52, 0x06, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x22, 0x2c, 0x0a, 0x04, 0x4b, 0x69, + 0x6e, 0x64, 0x12, 0x13, 0x0a, 0x0f, 0x4e, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x43, 0x4f, 0x56, 0x45, + 0x52, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x52, 0x45, 0x43, 0x4f, 0x56, + 0x45, 0x52, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x01, 0x22, 0x45, 0x0a, 0x0d, 0x45, 0x72, 0x72, 0x6f, + 0x72, 0x44, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x34, 0x0a, 0x05, 0x65, 0x72, 0x72, + 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x42, + 0xae, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x42, 0x0b, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, + 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0xa2, 0x02, 0x03, 0x46, 0x43, 0x58, 0xaa, + 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x43, 0x6f, 0x72, 0x65, + 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, 0x72, + 0x65, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x43, 0x6f, + 0x72, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, + 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, + 0x4a, 0xd8, 0x08, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x22, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, + 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x17, 0x0a, + 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x28, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, + 0x03, 0x06, 0x00, 0x49, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x06, 0x00, 0x49, 0x0a, + 0x6c, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0a, 0x00, 0x1b, 0x01, 0x1a, 0x60, 0x20, 0x45, 0x72, + 0x72, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x70, + 0x72, 0x6f, 0x70, 0x61, 0x67, 0x61, 0x74, 0x65, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, + 0x64, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0a, 0x08, 0x16, 0x0a, 0x66, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x00, 0x12, 0x03, 0x0c, 0x02, 0x12, 0x1a, 0x59, 0x20, 0x41, 0x20, 0x73, 0x69, 0x6d, 0x70, 0x6c, + 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, + 0x72, 0x72, 0x6f, 0x72, 0x73, 0x2c, 0x20, 0x73, 0x6f, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, + 0x65, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x20, 0x61, 0x20, + 0x67, 0x6c, 0x6f, 0x73, 0x73, 0x61, 0x72, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6c, 0x6c, 0x20, + 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x0c, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0c, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0c, 0x10, 0x11, 0x0a, 0x28, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x01, 0x12, 0x03, 0x0e, 0x02, 0x15, 0x1a, 0x1b, 0x20, 0x41, 0x20, 0x64, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, + 0x0e, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0e, 0x09, + 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x0e, 0x13, 0x14, 0x0a, + 0x5e, 0x0a, 0x04, 0x04, 0x00, 0x04, 0x00, 0x12, 0x04, 0x11, 0x02, 0x14, 0x03, 0x1a, 0x50, 0x20, + 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x61, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, + 0x63, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x64, 0x69, 0x63, 0x74, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, + 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, + 0x65, 0x74, 0x72, 0x79, 0x20, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x04, 0x00, 0x01, 0x12, 0x03, 0x11, 0x07, 0x0b, 0x0a, 0x0d, 0x0a, + 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x12, 0x04, 0x18, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x12, 0x04, 0x13, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x12, 0x16, 0x17, 0x0a, 0x0d, 0x0a, 0x06, + 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x13, 0x04, 0x14, 0x0a, 0x0e, 0x0a, 0x07, 0x04, + 0x00, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x13, 0x04, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, + 0x00, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x13, 0x12, 0x13, 0x0a, 0x63, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x02, 0x12, 0x03, 0x17, 0x02, 0x10, 0x1a, 0x56, 0x20, 0x41, 0x6e, 0x20, 0x61, 0x62, + 0x73, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6b, 0x69, 0x6e, + 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, + 0x2e, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x4e, 0x6f, + 0x6e, 0x5f, 0x52, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x69, 0x66, + 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x17, 0x02, 0x06, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x17, 0x07, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x17, 0x0e, 0x0f, 0x0a, 0x47, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x03, 0x12, 0x03, 0x1a, 0x02, 0x26, 0x1a, 0x3a, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x28, 0x73, 0x79, 0x73, 0x74, 0x65, + 0x6d, 0x2c, 0x20, 0x75, 0x73, 0x65, 0x72, 0x2c, 0x20, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, + 0x29, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x06, 0x12, 0x03, 0x1a, 0x02, + 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x1a, 0x1b, 0x21, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x1a, 0x24, 0x25, 0x0a, 0x82, 0x01, + 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x1f, 0x00, 0x22, 0x01, 0x1a, 0x76, 0x20, 0x44, 0x65, 0x66, + 0x69, 0x6e, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x2e, + 0x70, 0x62, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x63, 0x61, 0x6e, + 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6f, 0x6d, 0x6d, + 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74, 0x65, 0x0a, 0x20, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, + 0x20, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, + 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x1f, 0x08, 0x15, 0x0a, 0x31, + 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x21, 0x02, 0x1b, 0x1a, 0x24, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x72, 0x61, 0x69, 0x73, 0x65, 0x64, 0x20, 0x64, + 0x75, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x21, 0x02, 0x10, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x21, 0x11, 0x16, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x21, 0x19, 0x1a, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, +]; +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/flyteidl2.dataproxy.rs b/gen/rust/src/flyteidl2.dataproxy.rs new file mode 100644 index 0000000000..7835be024c --- /dev/null +++ b/gen/rust/src/flyteidl2.dataproxy.rs @@ -0,0 +1,413 @@ +// @generated +// This file is @generated by prost-build. +/// CreateUploadLocationRequest specifies the request for the CreateUploadLocation API. +/// The data proxy service will generate a storage location with server-side configured prefixes. +/// The generated path follows one of these patterns: +/// - project/domain/(deterministic hash of content_md5)/filename (if filename is present); OR +/// - project/domain/filename_root/filename (if filename_root and filename are present). +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateUploadLocationRequest { + /// Project to create the upload location for. + /// +required + #[prost(string, tag="1")] + pub project: ::prost::alloc::string::String, + /// Domain to create the upload location for. + /// +required + #[prost(string, tag="2")] + pub domain: ::prost::alloc::string::String, + /// Filename specifies the desired suffix for the generated location. E.g. `file.py` or `pre/fix/file.zip`. + /// +optional. By default, the service generates a consistent name based on the default filename length provided in the global config.. + #[prost(string, tag="3")] + pub filename: ::prost::alloc::string::String, + /// ExpiresIn defines the requested expiration duration for the generated URL. The request will be rejected if this + /// exceeds the platform's configured maximum. + /// +optional. The default value comes from the global config. + #[prost(message, optional, tag="4")] + pub expires_in: ::core::option::Option, + /// ContentMD5 restricts the upload location to the specific MD5 provided. The MD5 hash will also appear in the + /// generated path for verification. + /// +required + #[prost(bytes="vec", tag="5")] + pub content_md5: ::prost::alloc::vec::Vec, + /// FilenameRoot, if present, will be used instead of the MD5 hash in the path. When combined with filename, + /// this makes the upload location deterministic. The native URL will still be prefixed by the upload location prefix + /// configured in the data proxy. This option is useful when uploading multiple related files. + /// +optional + #[prost(string, tag="6")] + pub filename_root: ::prost::alloc::string::String, + /// If true, the data proxy will add content_md5 to the Signed URL requirements, + /// forcing clients to send this checksum with the object. + /// This is required to enforce data integrity on backends like GCP, ensuring that + /// the uploaded file matches the hash. + #[prost(bool, tag="7")] + pub add_content_md5_metadata: bool, + /// Org is the organization key applied to the resource. + /// +optional + #[prost(string, tag="8")] + pub org: ::prost::alloc::string::String, + /// ContentLength specifies the size of the content to be uploaded in bytes. + /// This is validated against the platform's maximum upload size if provided. + /// +optional + #[prost(int64, tag="9")] + pub content_length: i64, +} +/// CreateUploadLocationResponse specifies the response for the CreateUploadLocation API. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateUploadLocationResponse { + /// SignedUrl is the URL to use for uploading content (e.g. ). + #[prost(string, tag="1")] + pub signed_url: ::prost::alloc::string::String, + /// NativeUrl is the URL in the format of the configured storage provider (e.g. s3://my-bucket/randomstring/suffix.tar). + #[prost(string, tag="2")] + pub native_url: ::prost::alloc::string::String, + /// ExpiresAt defines when the signed URL will expire. + #[prost(message, optional, tag="3")] + pub expires_at: ::core::option::Option, + /// Headers are generated by the data proxy for the client. Clients must include these headers in the upload request. + #[prost(map="string, string", tag="4")] + pub headers: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, +} +/// Encoded file descriptor set for the `flyteidl2.dataproxy` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xe3, 0x29, 0x0a, 0x2b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x64, + 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2f, 0x64, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, + 0x78, 0x79, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x12, 0x13, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x64, 0x61, 0x74, 0x61, + 0x70, 0x72, 0x6f, 0x78, 0x79, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, + 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x6f, 0x70, + 0x65, 0x6e, 0x61, 0x70, 0x69, 0x76, 0x32, 0x2f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, + 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x22, 0xf8, 0x02, 0x0a, 0x1b, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x70, 0x6c, 0x6f, + 0x61, 0x64, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x21, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x07, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, 0x0a, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x06, 0x64, + 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, + 0x65, 0x12, 0x38, 0x0a, 0x0a, 0x65, 0x78, 0x70, 0x69, 0x72, 0x65, 0x73, 0x5f, 0x69, 0x6e, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x09, 0x65, 0x78, 0x70, 0x69, 0x72, 0x65, 0x73, 0x49, 0x6e, 0x12, 0x28, 0x0a, 0x0b, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x6d, 0x64, 0x35, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, + 0x42, 0x07, 0xba, 0x48, 0x04, 0x7a, 0x02, 0x68, 0x10, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x4d, 0x64, 0x35, 0x12, 0x23, 0x0a, 0x0d, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, + 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x66, 0x69, + 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x37, 0x0a, 0x18, 0x61, 0x64, + 0x64, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x6d, 0x64, 0x35, 0x5f, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x61, 0x64, + 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x4d, 0x64, 0x35, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x12, 0x10, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x5f, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x22, 0xad, 0x02, 0x0a, + 0x1c, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x4c, 0x6f, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1d, 0x0a, + 0x0a, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x55, 0x72, 0x6c, 0x12, 0x1d, 0x0a, 0x0a, + 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x55, 0x72, 0x6c, 0x12, 0x39, 0x0a, 0x0a, 0x65, + 0x78, 0x70, 0x69, 0x72, 0x65, 0x73, 0x5f, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x65, 0x78, 0x70, + 0x69, 0x72, 0x65, 0x73, 0x41, 0x74, 0x12, 0x58, 0x0a, 0x07, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, + 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2e, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, + 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, + 0x1a, 0x3a, 0x0a, 0x0c, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, + 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x32, 0xb5, 0x02, 0x0a, + 0x10, 0x44, 0x61, 0x74, 0x61, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x12, 0xa0, 0x02, 0x0a, 0x14, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x70, 0x6c, 0x6f, + 0x61, 0x64, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x30, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, + 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x4c, 0x6f, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, + 0x78, 0x79, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x4c, + 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0xa2, 0x01, 0x92, 0x41, 0x4d, 0x1a, 0x4b, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, + 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, 0x2d, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x68, 0x74, 0x74, 0x70, + 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, + 0x73, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x20, 0x61, 0x74, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, + 0x65, 0x2e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4c, 0x3a, 0x01, 0x2a, 0x5a, 0x27, 0x3a, 0x01, 0x2a, + 0x22, 0x22, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6f, 0x72, 0x67, 0x2f, 0x64, 0x61, + 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, + 0x5f, 0x75, 0x72, 0x6e, 0x22, 0x1e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x64, 0x61, + 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, + 0x5f, 0x75, 0x72, 0x6e, 0x42, 0xd6, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, + 0x42, 0x15, 0x44, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x37, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x64, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, + 0x78, 0x79, 0xa2, 0x02, 0x03, 0x46, 0x44, 0x58, 0xaa, 0x02, 0x13, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, 0xca, 0x02, + 0x13, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x44, 0x61, 0x74, 0x61, 0x70, + 0x72, 0x6f, 0x78, 0x79, 0xe2, 0x02, 0x1f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x44, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x3a, 0x3a, 0x44, 0x61, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x4a, 0xae, 0x1e, + 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x5b, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, + 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x1c, 0x0a, 0x09, 0x0a, 0x02, + 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, + 0x00, 0x26, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, 0x28, 0x0a, 0x09, 0x0a, + 0x02, 0x03, 0x03, 0x12, 0x03, 0x07, 0x00, 0x29, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x04, 0x12, 0x03, + 0x08, 0x00, 0x38, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x0a, 0x00, 0x4e, 0x0a, 0x09, 0x0a, + 0x02, 0x08, 0x0b, 0x12, 0x03, 0x0a, 0x00, 0x4e, 0x0a, 0x5d, 0x0a, 0x02, 0x06, 0x00, 0x12, 0x04, + 0x0d, 0x00, 0x1a, 0x01, 0x1a, 0x51, 0x20, 0x44, 0x61, 0x74, 0x61, 0x50, 0x72, 0x6f, 0x78, 0x79, + 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x73, + 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, + 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x64, 0x6f, 0x77, 0x6e, + 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x06, 0x00, 0x01, 0x12, 0x03, + 0x0d, 0x08, 0x18, 0x0a, 0x71, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x00, 0x12, 0x04, 0x0f, 0x02, 0x19, + 0x03, 0x1a, 0x63, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, + 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, + 0x65, 0x73, 0x20, 0x61, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x55, 0x52, 0x4c, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x61, + 0x74, 0x61, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 0x75, 0x72, 0x65, 0x64, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x20, 0x62, 0x61, 0x63, + 0x6b, 0x65, 0x6e, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x0f, 0x06, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x0f, + 0x1b, 0x36, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0f, 0x41, 0x5d, + 0x0a, 0x0d, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x04, 0x12, 0x04, 0x10, 0x04, 0x17, 0x06, 0x0a, + 0x11, 0x0a, 0x09, 0x06, 0x00, 0x02, 0x00, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x12, 0x04, 0x10, 0x04, + 0x17, 0x06, 0x0a, 0x11, 0x0a, 0x0a, 0x06, 0x00, 0x02, 0x00, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x04, + 0x12, 0x03, 0x11, 0x06, 0x2c, 0x0a, 0x11, 0x0a, 0x0a, 0x06, 0x00, 0x02, 0x00, 0x04, 0xb0, 0xca, + 0xbc, 0x22, 0x07, 0x12, 0x03, 0x12, 0x06, 0x0f, 0x0a, 0x13, 0x0a, 0x0b, 0x06, 0x00, 0x02, 0x00, + 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x0b, 0x00, 0x12, 0x04, 0x13, 0x06, 0x16, 0x07, 0x0a, 0x13, 0x0a, + 0x0c, 0x06, 0x00, 0x02, 0x00, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x0b, 0x00, 0x04, 0x12, 0x03, 0x14, + 0x08, 0x32, 0x0a, 0x13, 0x0a, 0x0c, 0x06, 0x00, 0x02, 0x00, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x0b, + 0x00, 0x07, 0x12, 0x03, 0x15, 0x08, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x04, + 0x12, 0x04, 0x18, 0x04, 0xaa, 0x01, 0x0a, 0x0f, 0x0a, 0x07, 0x06, 0x00, 0x02, 0x00, 0x04, 0x92, + 0x08, 0x12, 0x04, 0x18, 0x04, 0xaa, 0x01, 0x0a, 0x10, 0x0a, 0x08, 0x06, 0x00, 0x02, 0x00, 0x04, + 0x92, 0x08, 0x03, 0x12, 0x04, 0x18, 0x4e, 0xa8, 0x01, 0x0a, 0xaa, 0x03, 0x0a, 0x02, 0x04, 0x00, + 0x12, 0x04, 0x21, 0x00, 0x4c, 0x01, 0x1a, 0x9d, 0x03, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, + 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x41, 0x50, 0x49, 0x2e, 0x0a, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x20, 0x73, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, + 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x20, 0x6c, 0x6f, + 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x2d, 0x73, 0x69, 0x64, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, + 0x65, 0x64, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x70, 0x61, 0x74, 0x68, + 0x20, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x73, 0x65, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x73, 0x3a, 0x0a, + 0x20, 0x20, 0x20, 0x2d, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2f, 0x64, 0x6f, 0x6d, + 0x61, 0x69, 0x6e, 0x2f, 0x28, 0x64, 0x65, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x69, 0x73, 0x74, + 0x69, 0x63, 0x20, 0x68, 0x61, 0x73, 0x68, 0x20, 0x6f, 0x66, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x5f, 0x6d, 0x64, 0x35, 0x29, 0x2f, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, + 0x20, 0x28, 0x69, 0x66, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x29, 0x3b, 0x20, 0x4f, 0x52, 0x0a, 0x20, 0x20, + 0x20, 0x2d, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2f, 0x64, 0x6f, 0x6d, 0x61, 0x69, + 0x6e, 0x2f, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x2f, + 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x28, 0x69, 0x66, 0x20, 0x66, 0x69, 0x6c, + 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x66, + 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x61, 0x72, 0x65, 0x20, 0x70, 0x72, 0x65, 0x73, + 0x65, 0x6e, 0x74, 0x29, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x21, + 0x08, 0x23, 0x0a, 0x44, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x24, 0x02, 0x3f, 0x1a, + 0x37, 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x6c, + 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x2e, 0x0a, 0x20, 0x2b, 0x72, + 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x05, 0x12, 0x03, 0x24, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x24, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x24, + 0x13, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x08, 0x12, 0x03, 0x24, 0x15, 0x3e, + 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x24, + 0x16, 0x3d, 0x0a, 0x43, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x28, 0x02, 0x3e, 0x1a, + 0x36, 0x20, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x6c, 0x6f, + 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x2e, 0x0a, 0x20, 0x2b, 0x72, 0x65, + 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, + 0x12, 0x03, 0x28, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x28, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x28, 0x12, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x08, 0x12, 0x03, 0x28, 0x14, 0x3d, 0x0a, + 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x28, 0x15, + 0x3c, 0x0a, 0xfc, 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x2c, 0x02, 0x16, 0x1a, + 0xee, 0x01, 0x20, 0x46, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, + 0x64, 0x20, 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x45, 0x2e, 0x67, 0x2e, 0x20, 0x60, 0x66, 0x69, 0x6c, 0x65, 0x2e, + 0x70, 0x79, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x70, 0x72, 0x65, 0x2f, 0x66, 0x69, 0x78, 0x2f, + 0x66, 0x69, 0x6c, 0x65, 0x2e, 0x7a, 0x69, 0x70, 0x60, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2e, 0x20, 0x42, 0x79, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, + 0x74, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x67, + 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, + 0x73, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x62, 0x61, 0x73, 0x65, 0x64, + 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, + 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, + 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x2c, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x2c, 0x09, 0x11, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x2c, 0x14, 0x15, 0x0a, 0xe7, 0x01, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x03, 0x12, 0x03, 0x31, 0x02, 0x2a, 0x1a, 0xd9, 0x01, 0x20, 0x45, 0x78, 0x70, 0x69, + 0x72, 0x65, 0x73, 0x49, 0x6e, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x65, 0x78, 0x70, 0x69, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x55, 0x52, 0x4c, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x6a, 0x65, 0x63, + 0x74, 0x65, 0x64, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x0a, 0x20, 0x65, 0x78, 0x63, + 0x65, 0x65, 0x64, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x27, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x65, 0x64, 0x20, 0x6d, + 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x6c, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x65, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x06, 0x12, 0x03, 0x31, + 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x31, 0x1b, 0x25, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x31, 0x28, 0x29, 0x0a, 0xa8, + 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, 0x36, 0x02, 0x3e, 0x1a, 0x9a, 0x01, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x4d, 0x44, 0x35, 0x20, 0x72, 0x65, 0x73, 0x74, 0x72, + 0x69, 0x63, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x20, + 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x4d, 0x44, 0x35, 0x20, 0x70, 0x72, 0x6f, + 0x76, 0x69, 0x64, 0x65, 0x64, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x4d, 0x44, 0x35, 0x20, 0x68, + 0x61, 0x73, 0x68, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x61, 0x70, + 0x70, 0x65, 0x61, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x67, 0x65, 0x6e, + 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x76, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x2b, + 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x04, 0x05, 0x12, 0x03, 0x36, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x01, + 0x12, 0x03, 0x36, 0x08, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, + 0x36, 0x16, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x08, 0x12, 0x03, 0x36, 0x18, + 0x3d, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x04, 0x08, 0x87, 0x09, 0x0f, 0x0d, 0x12, 0x03, + 0x36, 0x19, 0x3c, 0x0a, 0xd2, 0x02, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x3c, 0x02, + 0x1b, 0x1a, 0xc4, 0x02, 0x20, 0x46, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x52, 0x6f, 0x6f, + 0x74, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x77, + 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x73, 0x74, + 0x65, 0x61, 0x64, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4d, 0x44, 0x35, 0x20, 0x68, + 0x61, 0x73, 0x68, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x2e, + 0x20, 0x57, 0x68, 0x65, 0x6e, 0x20, 0x63, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x0a, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x6d, 0x61, 0x6b, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x70, + 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x65, + 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x69, 0x73, 0x74, 0x69, 0x63, 0x2e, 0x20, 0x54, 0x68, 0x65, + 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x55, 0x52, 0x4c, 0x20, 0x77, 0x69, 0x6c, 0x6c, + 0x20, 0x73, 0x74, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, + 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, + 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, + 0x0a, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2e, 0x20, + 0x54, 0x68, 0x69, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x75, + 0x73, 0x65, 0x66, 0x75, 0x6c, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x75, 0x70, 0x6c, 0x6f, 0x61, + 0x64, 0x69, 0x6e, 0x67, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x72, 0x65, + 0x6c, 0x61, 0x74, 0x65, 0x64, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, + 0x05, 0x12, 0x03, 0x3c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x01, 0x12, + 0x03, 0x3c, 0x09, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x03, 0x12, 0x03, 0x3c, + 0x19, 0x1a, 0x0a, 0x89, 0x02, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x06, 0x12, 0x03, 0x42, 0x02, 0x24, + 0x1a, 0xfb, 0x01, 0x20, 0x49, 0x66, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x20, 0x77, 0x69, 0x6c, 0x6c, + 0x20, 0x61, 0x64, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x6d, 0x64, 0x35, + 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x55, + 0x52, 0x4c, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2c, + 0x0a, 0x20, 0x66, 0x6f, 0x72, 0x63, 0x69, 0x6e, 0x67, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x73, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x63, + 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, + 0x73, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x6e, + 0x66, 0x6f, 0x72, 0x63, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, + 0x72, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x6e, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x73, + 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x47, 0x43, 0x50, 0x2c, 0x20, 0x65, 0x6e, 0x73, 0x75, 0x72, + 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x61, 0x74, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x70, + 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x6d, 0x61, 0x74, 0x63, + 0x68, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x68, 0x61, 0x73, 0x68, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x05, 0x12, 0x03, 0x42, 0x02, 0x06, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x42, 0x07, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x06, 0x03, 0x12, 0x03, 0x42, 0x22, 0x23, 0x0a, 0x4e, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x07, + 0x12, 0x03, 0x46, 0x02, 0x11, 0x1a, 0x41, 0x20, 0x4f, 0x72, 0x67, 0x20, 0x69, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x6b, 0x65, 0x79, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x07, + 0x05, 0x12, 0x03, 0x46, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x07, 0x01, 0x12, + 0x03, 0x46, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x07, 0x03, 0x12, 0x03, 0x46, + 0x0f, 0x10, 0x0a, 0xae, 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x08, 0x12, 0x03, 0x4b, 0x02, 0x1b, + 0x1a, 0xa0, 0x01, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x4c, 0x65, 0x6e, 0x67, 0x74, + 0x68, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x69, 0x7a, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, + 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x54, 0x68, + 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x64, 0x20, + 0x61, 0x67, 0x61, 0x69, 0x6e, 0x73, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x27, 0x73, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x75, + 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x73, 0x69, 0x7a, 0x65, 0x20, 0x69, 0x66, 0x20, 0x70, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x05, 0x12, 0x03, 0x4b, 0x02, + 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x01, 0x12, 0x03, 0x4b, 0x08, 0x16, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x03, 0x12, 0x03, 0x4b, 0x19, 0x1a, 0x0a, 0x63, 0x0a, + 0x02, 0x04, 0x01, 0x12, 0x04, 0x4f, 0x00, 0x5b, 0x01, 0x1a, 0x57, 0x20, 0x43, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x70, + 0x6c, 0x6f, 0x61, 0x64, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x41, 0x50, 0x49, + 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x4f, 0x08, 0x24, 0x0a, 0x89, + 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x51, 0x02, 0x18, 0x1a, 0x7c, 0x20, 0x53, + 0x69, 0x67, 0x6e, 0x65, 0x64, 0x55, 0x72, 0x6c, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x55, 0x52, 0x4c, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x75, + 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x6d, + 0x79, 0x2d, 0x62, 0x75, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x73, 0x33, 0x2e, 0x61, 0x6d, 0x61, 0x7a, + 0x6f, 0x6e, 0x61, 0x77, 0x73, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, + 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2f, 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x2e, 0x74, 0x61, + 0x72, 0x3f, 0x58, 0x2d, 0x2e, 0x2e, 0x2e, 0x29, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x05, 0x12, 0x03, 0x51, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x51, 0x09, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x51, 0x16, 0x17, 0x0a, 0x83, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x54, + 0x02, 0x18, 0x1a, 0x76, 0x20, 0x4e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x55, 0x72, 0x6c, 0x20, 0x69, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x55, 0x52, 0x4c, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x65, 0x64, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, + 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, + 0x20, 0x73, 0x33, 0x3a, 0x2f, 0x2f, 0x6d, 0x79, 0x2d, 0x62, 0x75, 0x63, 0x6b, 0x65, 0x74, 0x2f, + 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2f, 0x73, 0x75, 0x66, + 0x66, 0x69, 0x78, 0x2e, 0x74, 0x61, 0x72, 0x29, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x01, 0x05, 0x12, 0x03, 0x54, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x54, 0x09, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x54, 0x16, 0x17, 0x0a, 0x41, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x57, 0x02, + 0x2b, 0x1a, 0x34, 0x20, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x73, 0x41, 0x74, 0x20, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x55, 0x52, 0x4c, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x65, + 0x78, 0x70, 0x69, 0x72, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x06, + 0x12, 0x03, 0x57, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x57, 0x1c, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x57, 0x29, + 0x2a, 0x0a, 0x80, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x03, 0x12, 0x03, 0x5a, 0x02, 0x22, 0x1a, + 0x73, 0x20, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x67, 0x65, + 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, + 0x61, 0x74, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x20, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x73, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x73, 0x65, 0x20, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x06, 0x12, 0x03, 0x5a, + 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x01, 0x12, 0x03, 0x5a, 0x16, 0x1d, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x03, 0x12, 0x03, 0x5a, 0x20, 0x21, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +]; +include!("flyteidl2.dataproxy.tonic.rs"); +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/flyteidl2.dataproxy.tonic.rs b/gen/rust/src/flyteidl2.dataproxy.tonic.rs new file mode 100644 index 0000000000..5c95dc8b0d --- /dev/null +++ b/gen/rust/src/flyteidl2.dataproxy.tonic.rs @@ -0,0 +1,292 @@ +// @generated +/// Generated client implementations. +pub mod data_proxy_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct DataProxyServiceClient { + inner: tonic::client::Grpc, + } + impl DataProxyServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl DataProxyServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> DataProxyServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + DataProxyServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + pub async fn create_upload_location( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.dataproxy.DataProxyService/CreateUploadLocation", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.dataproxy.DataProxyService", + "CreateUploadLocation", + ), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod data_proxy_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with DataProxyServiceServer. + #[async_trait] + pub trait DataProxyService: Send + Sync + 'static { + async fn create_upload_location( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + #[derive(Debug)] + pub struct DataProxyServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl DataProxyServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for DataProxyServiceServer + where + T: DataProxyService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.dataproxy.DataProxyService/CreateUploadLocation" => { + #[allow(non_camel_case_types)] + struct CreateUploadLocationSvc(pub Arc); + impl< + T: DataProxyService, + > tonic::server::UnaryService + for CreateUploadLocationSvc { + type Response = super::CreateUploadLocationResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::create_upload_location( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = CreateUploadLocationSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for DataProxyServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService for DataProxyServiceServer { + const NAME: &'static str = "flyteidl2.dataproxy.DataProxyService"; + } +} diff --git a/gen/rust/src/flyteidl2.event.rs b/gen/rust/src/flyteidl2.event.rs new file mode 100644 index 0000000000..b9d8ff8be6 --- /dev/null +++ b/gen/rust/src/flyteidl2.event.rs @@ -0,0 +1,2050 @@ +// @generated +// This file is @generated by prost-build. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorkflowExecutionEvent { + /// Workflow execution id + #[prost(message, optional, tag="1")] + pub execution_id: ::core::option::Option, + /// the id of the originator (Propeller) of the event + #[prost(string, tag="2")] + pub producer_id: ::prost::alloc::string::String, + #[prost(enumeration="super::core::workflow_execution::Phase", tag="3")] + pub phase: i32, + /// This timestamp represents when the original event occurred, it is generated + /// by the executor of the workflow. + #[prost(message, optional, tag="4")] + pub occurred_at: ::core::option::Option, + #[prost(oneof="workflow_execution_event::OutputResult", tags="5, 6, 7")] + pub output_result: ::core::option::Option, +} +/// Nested message and enum types in `WorkflowExecutionEvent`. +pub mod workflow_execution_event { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum OutputResult { + /// URL to the output of the execution, it encodes all the information + /// including Cloud source provider. ie., s3://... + #[prost(string, tag="5")] + OutputUri(::prost::alloc::string::String), + /// Error information for the execution + #[prost(message, tag="6")] + Error(super::super::core::ExecutionError), + /// Raw output data produced by this workflow execution. + #[prost(message, tag="7")] + OutputData(super::super::core::LiteralMap), + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct NodeExecutionEvent { + /// Unique identifier for this node execution + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + /// the id of the originator (Propeller) of the event + #[prost(string, tag="2")] + pub producer_id: ::prost::alloc::string::String, + #[prost(enumeration="super::core::node_execution::Phase", tag="3")] + pub phase: i32, + /// This timestamp represents when the original event occurred, it is generated + /// by the executor of the node. + #[prost(message, optional, tag="4")] + pub occurred_at: ::core::option::Option, + /// \[To be deprecated\] Specifies which task (if any) launched this node. + #[prost(message, optional, tag="9")] + pub parent_task_metadata: ::core::option::Option, + /// Specifies the parent node of the current node execution. Node executions at level zero will not have a parent node. + #[prost(message, optional, tag="10")] + pub parent_node_metadata: ::core::option::Option, + /// Retry group to indicate grouping of nodes by retries + #[prost(string, tag="11")] + pub retry_group: ::prost::alloc::string::String, + /// Identifier of the node in the original workflow/graph + /// This maps to value of WorkflowTemplate.nodes\[X\].id + #[prost(string, tag="12")] + pub spec_node_id: ::prost::alloc::string::String, + /// Friendly readable name for the node + #[prost(string, tag="13")] + pub node_name: ::prost::alloc::string::String, + #[prost(int32, tag="16")] + pub event_version: i32, + /// Whether this node launched a subworkflow. + #[prost(bool, tag="17")] + pub is_parent: bool, + /// Whether this node yielded a dynamic workflow. + #[prost(bool, tag="18")] + pub is_dynamic: bool, + /// String location uniquely identifying where the deck HTML file is + /// NativeUrl specifies the url in the format of the configured storage provider (e.g. s3://my-bucket/randomstring/suffix.tar) + #[prost(string, tag="19")] + pub deck_uri: ::prost::alloc::string::String, + /// This timestamp represents the instant when the event was reported by the executing framework. For example, + /// when first processing a node the `occurred_at` timestamp should be the instant propeller makes progress, so when + /// literal inputs are initially copied. The event however will not be sent until after the copy completes. + /// Extracting both of these timestamps facilitates a more accurate portrayal of the evaluation time-series. + #[prost(message, optional, tag="21")] + pub reported_at: ::core::option::Option, + /// Indicates if this node is an ArrayNode. + #[prost(bool, tag="22")] + pub is_array: bool, + /// So that Admin doesn't have to rebuild the node execution graph to find the target entity, propeller will fill this + /// in optionally - currently this is only filled in for subworkflows. This is the ID of the subworkflow corresponding + /// to this node execution. It is difficult to find because Admin only sees one node at a time. A subworkflow could be + /// nested multiple layers deep, and you'd need to access the correct workflow template to know the target subworkflow. + #[prost(message, optional, tag="23")] + pub target_entity: ::core::option::Option, + /// Tasks and subworkflows (but not launch plans) that are run within a dynamic task are effectively independent of + /// the tasks that are registered in Admin's db. Confusingly, they are often identical, but sometimes they are not + /// even registered at all. Similar to the target_entity field, at the time Admin receives this event, it has no idea + /// if the relevant execution entity is was registered, or dynamic. This field indicates that the target_entity ID, + /// as well as task IDs in any corresponding Task Executions, should not be used to looked up the task in Admin's db. + #[prost(bool, tag="24")] + pub is_in_dynamic_chain: bool, + /// Whether this node launched an eager task. + #[prost(bool, tag="25")] + pub is_eager: bool, + #[prost(oneof="node_execution_event::InputValue", tags="5, 20")] + pub input_value: ::core::option::Option, + #[prost(oneof="node_execution_event::OutputResult", tags="6, 7, 15")] + pub output_result: ::core::option::Option, + /// Additional metadata to do with this event's node target based + /// on the node type + #[prost(oneof="node_execution_event::TargetMetadata", tags="8, 14")] + pub target_metadata: ::core::option::Option, +} +/// Nested message and enum types in `NodeExecutionEvent`. +pub mod node_execution_event { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum InputValue { + #[prost(string, tag="5")] + InputUri(::prost::alloc::string::String), + /// Raw input data consumed by this node execution. + #[prost(message, tag="20")] + InputData(super::super::core::LiteralMap), + } + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum OutputResult { + /// URL to the output of the execution, it encodes all the information + /// including Cloud source provider. ie., s3://... + #[prost(string, tag="6")] + OutputUri(::prost::alloc::string::String), + /// Error information for the execution + #[prost(message, tag="7")] + Error(super::super::core::ExecutionError), + /// Raw output data produced by this node execution. + #[prost(message, tag="15")] + OutputData(super::super::core::LiteralMap), + } + /// Additional metadata to do with this event's node target based + /// on the node type + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum TargetMetadata { + #[prost(message, tag="8")] + WorkflowNodeMetadata(super::WorkflowNodeMetadata), + #[prost(message, tag="14")] + TaskNodeMetadata(super::TaskNodeMetadata), + } +} +/// For Workflow Nodes we need to send information about the workflow that's launched +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorkflowNodeMetadata { + #[prost(message, optional, tag="1")] + pub execution_id: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskNodeMetadata { + /// Captures the status of caching for this execution. + #[prost(enumeration="super::core::CatalogCacheStatus", tag="1")] + pub cache_status: i32, + /// This structure carries the catalog artifact information + #[prost(message, optional, tag="2")] + pub catalog_key: ::core::option::Option, + /// Captures the status of cache reservations for this execution. + #[prost(enumeration="super::core::catalog_reservation::Status", tag="3")] + pub reservation_status: i32, + /// The latest checkpoint location + #[prost(string, tag="4")] + pub checkpoint_uri: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ParentTaskExecutionMetadata { + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ParentNodeExecutionMetadata { + /// Unique identifier of the parent node id within the execution + /// This is value of core.NodeExecutionIdentifier.node_id of the parent node + #[prost(string, tag="1")] + pub node_id: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EventReason { + /// An explanation for this event + #[prost(string, tag="1")] + pub reason: ::prost::alloc::string::String, + /// The time this reason occurred + #[prost(message, optional, tag="2")] + pub occurred_at: ::core::option::Option, +} +/// Plugin specific execution event information. For tasks like Python, Hive, Spark, DynamicJob. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskExecutionEvent { + /// ID of the task. In combination with the retryAttempt this will indicate + /// the task execution uniquely for a given parent node execution. + #[prost(message, optional, tag="1")] + pub task_id: ::core::option::Option, + /// A task execution is always kicked off by a node execution, the event consumer + /// will use the parent_id to relate the task to it's parent node execution + #[prost(message, optional, tag="2")] + pub parent_node_execution_id: ::core::option::Option, + /// retry attempt number for this task, ie., 2 for the second attempt + #[prost(uint32, tag="3")] + pub retry_attempt: u32, + /// Phase associated with the event + #[prost(enumeration="super::core::task_execution::Phase", tag="4")] + pub phase: i32, + /// id of the process that sent this event, mainly for trace debugging + #[prost(string, tag="5")] + pub producer_id: ::prost::alloc::string::String, + /// log information for the task execution + #[prost(message, repeated, tag="6")] + pub logs: ::prost::alloc::vec::Vec, + /// This timestamp represents when the original event occurred, it is generated + /// by the executor of the task. + #[prost(message, optional, tag="7")] + pub occurred_at: ::core::option::Option, + /// Custom data that the task plugin sends back. This is extensible to allow various plugins in the system. + #[prost(message, optional, tag="11")] + pub custom_info: ::core::option::Option, + /// Some phases, like RUNNING, can send multiple events with changed metadata (new logs, additional custom_info, etc) + /// that should be recorded regardless of the lack of phase change. + /// The version field should be incremented when metadata changes across the duration of an individual phase. + #[prost(uint32, tag="12")] + pub phase_version: u32, + /// An optional explanation for the phase transition. + /// Deprecated: Use reasons instead. + #[deprecated] + #[prost(string, tag="13")] + pub reason: ::prost::alloc::string::String, + /// An optional list of explanations for the phase transition. + #[prost(message, repeated, tag="21")] + pub reasons: ::prost::alloc::vec::Vec, + /// A predefined yet extensible Task type identifier. If the task definition is already registered in flyte admin + /// this type will be identical, but not all task executions necessarily use pre-registered definitions and this + /// type is useful to render the task in the UI, filter task executions, etc. + #[prost(string, tag="14")] + pub task_type: ::prost::alloc::string::String, + /// Metadata around how a task was executed. + #[prost(message, optional, tag="16")] + pub metadata: ::core::option::Option, + /// The event version is used to indicate versioned changes in how data is reported using this + /// proto message. For example, event_verison > 0 means that maps tasks report logs using the + /// TaskExecutionMetadata ExternalResourceInfo fields for each subtask rather than the TaskLog + /// in this message. + #[prost(int32, tag="18")] + pub event_version: i32, + /// This timestamp represents the instant when the event was reported by the executing framework. For example, a k8s + /// pod task may be marked completed at (ie. `occurred_at`) the instant the container running user code completes, + /// but this event will not be reported until the pod is marked as completed. Extracting both of these timestamps + /// facilitates a more accurate portrayal of the evaluation time-series. + #[prost(message, optional, tag="20")] + pub reported_at: ::core::option::Option, + /// Contains metadata required to identify logs related to this task execution + #[prost(message, optional, tag="22")] + pub log_context: ::core::option::Option, + #[prost(oneof="task_execution_event::InputValue", tags="8, 19")] + pub input_value: ::core::option::Option, + #[prost(oneof="task_execution_event::OutputResult", tags="9, 10, 17")] + pub output_result: ::core::option::Option, +} +/// Nested message and enum types in `TaskExecutionEvent`. +pub mod task_execution_event { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum InputValue { + /// URI of the input file, it encodes all the information + /// including Cloud source provider. ie., s3://... + #[prost(string, tag="8")] + InputUri(::prost::alloc::string::String), + /// Raw input data consumed by this task execution. + #[prost(message, tag="19")] + InputData(super::super::core::LiteralMap), + } + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum OutputResult { + /// URI to the output of the execution, it will be in a format that encodes all the information + /// including Cloud source provider. ie., s3://... + #[prost(string, tag="9")] + OutputUri(::prost::alloc::string::String), + /// Error information for the execution + #[prost(message, tag="10")] + Error(super::super::core::ExecutionError), + /// Raw output data produced by this task execution. + #[prost(message, tag="17")] + OutputData(super::super::core::LiteralMap), + } +} +/// This message contains metadata about external resources produced or used by a specific task execution. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExternalResourceInfo { + /// Identifier for an external resource created by this task execution, for example Qubole query ID or presto query ids. + #[prost(string, tag="1")] + pub external_id: ::prost::alloc::string::String, + /// A unique index for the external resource with respect to all external resources for this task. Although the + /// identifier may change between task reporting events or retries, this will remain the same to enable aggregating + /// information from multiple reports. + #[prost(uint32, tag="2")] + pub index: u32, + /// Retry attempt number for this external resource, ie., 2 for the second attempt + #[prost(uint32, tag="3")] + pub retry_attempt: u32, + /// Phase associated with the external resource + #[prost(enumeration="super::core::task_execution::Phase", tag="4")] + pub phase: i32, + /// Captures the status of caching for this external resource execution. + #[prost(enumeration="super::core::CatalogCacheStatus", tag="5")] + pub cache_status: i32, + /// log information for the external resource execution + #[prost(message, repeated, tag="6")] + pub logs: ::prost::alloc::vec::Vec, + /// Extensible field for custom, plugin-specific info + #[prost(message, optional, tag="8")] + pub custom_info: ::core::option::Option, + /// Contains metadata required to identify logs related to this task execution + #[prost(message, optional, tag="9")] + pub log_context: ::core::option::Option, + /// Additional metadata to do with this event's node target based on the node type. We are + /// explicitly not including the task_node_metadata here because it is not clear if it is needed. + /// If we decide to include in the future, we should deprecate the cache_status field. + #[prost(oneof="external_resource_info::TargetMetadata", tags="7")] + pub target_metadata: ::core::option::Option, +} +/// Nested message and enum types in `ExternalResourceInfo`. +pub mod external_resource_info { + /// Additional metadata to do with this event's node target based on the node type. We are + /// explicitly not including the task_node_metadata here because it is not clear if it is needed. + /// If we decide to include in the future, we should deprecate the cache_status field. + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum TargetMetadata { + #[prost(message, tag="7")] + WorkflowNodeMetadata(super::WorkflowNodeMetadata), + } +} +/// This message holds task execution metadata specific to resource allocation used to manage concurrent +/// executions for a project namespace. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResourcePoolInfo { + /// Unique resource ID used to identify this execution when allocating a token. + #[prost(string, tag="1")] + pub allocation_token: ::prost::alloc::string::String, + /// Namespace under which this task execution requested an allocation token. + #[prost(string, tag="2")] + pub namespace: ::prost::alloc::string::String, +} +/// Holds metadata around how a task was executed. +/// As a task transitions across event phases during execution some attributes, such its generated name, generated external resources, +/// and more may grow in size but not change necessarily based on the phase transition that sparked the event update. +/// Metadata is a container for these attributes across the task execution lifecycle. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskExecutionMetadata { + /// Unique, generated name for this task execution used by the backend. + #[prost(string, tag="1")] + pub generated_name: ::prost::alloc::string::String, + /// Additional data on external resources on other back-ends or platforms (e.g. Hive, Qubole, etc) launched by this task execution. + #[prost(message, repeated, tag="2")] + pub external_resources: ::prost::alloc::vec::Vec, + /// Includes additional data on concurrent resource management used during execution.. + /// This is a repeated field because a plugin can request multiple resource allocations during execution. + #[prost(message, repeated, tag="3")] + pub resource_pool_info: ::prost::alloc::vec::Vec, + /// The identifier of the plugin used to execute this task. + #[prost(string, tag="4")] + pub plugin_identifier: ::prost::alloc::string::String, + #[prost(enumeration="task_execution_metadata::InstanceClass", tag="16")] + pub instance_class: i32, +} +/// Nested message and enum types in `TaskExecutionMetadata`. +pub mod task_execution_metadata { + /// Includes the broad category of machine used for this specific task execution. + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum InstanceClass { + /// The default instance class configured for the flyte application platform. + Default = 0, + /// The instance class configured for interruptible tasks. + Interruptible = 1, + } + impl InstanceClass { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + InstanceClass::Default => "DEFAULT", + InstanceClass::Interruptible => "INTERRUPTIBLE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "DEFAULT" => Some(Self::Default), + "INTERRUPTIBLE" => Some(Self::Interruptible), + _ => None, + } + } + } +} +/// This is the cloud event parallel to the raw WorkflowExecutionEvent message. It's filled in with additional +/// information that downstream consumers may find useful. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CloudEventWorkflowExecution { + #[prost(message, optional, tag="1")] + pub raw_event: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub output_interface: ::core::option::Option, + /// The following are ExecutionMetadata fields + /// We can't have the ExecutionMetadata object directly because of import cycle + #[prost(message, repeated, tag="3")] + pub artifact_ids: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="4")] + pub reference_execution: ::core::option::Option, + #[prost(string, tag="5")] + pub principal: ::prost::alloc::string::String, + /// The ID of the LP that generated the execution that generated the Artifact. + /// Here for provenance information. + /// Launch plan IDs are easier to get than workflow IDs so we'll use these for now. + #[prost(message, optional, tag="6")] + pub launch_plan_id: ::core::option::Option, + /// We can't have the ExecutionMetadata object directly because of import cycle + #[prost(map="string, string", tag="7")] + pub labels: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CloudEventNodeExecution { + #[prost(message, optional, tag="1")] + pub raw_event: ::core::option::Option, + /// The relevant task execution if applicable + #[prost(message, optional, tag="2")] + pub task_exec_id: ::core::option::Option, + /// The typed interface for the task that produced the event. + #[prost(message, optional, tag="3")] + pub output_interface: ::core::option::Option, + /// The following are ExecutionMetadata fields + /// We can't have the ExecutionMetadata object directly because of import cycle + #[prost(message, repeated, tag="4")] + pub artifact_ids: ::prost::alloc::vec::Vec, + #[prost(string, tag="5")] + pub principal: ::prost::alloc::string::String, + /// The ID of the LP that generated the execution that generated the Artifact. + /// Here for provenance information. + /// Launch plan IDs are easier to get than workflow IDs so we'll use these for now. + #[prost(message, optional, tag="6")] + pub launch_plan_id: ::core::option::Option, + /// We can't have the ExecutionMetadata object directly because of import cycle + #[prost(map="string, string", tag="7")] + pub labels: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CloudEventTaskExecution { + #[prost(message, optional, tag="1")] + pub raw_event: ::core::option::Option, + /// We can't have the ExecutionMetadata object directly because of import cycle + #[prost(map="string, string", tag="2")] + pub labels: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, +} +/// This event is to be sent by Admin after it creates an execution. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CloudEventExecutionStart { + /// The execution created. + #[prost(message, optional, tag="1")] + pub execution_id: ::core::option::Option, + /// The launch plan used. + #[prost(message, optional, tag="2")] + pub launch_plan_id: ::core::option::Option, + #[prost(message, optional, tag="3")] + pub workflow_id: ::core::option::Option, + /// Artifact inputs to the workflow execution for which we have the full Artifact ID. These are likely the result of artifact queries that are run. + #[prost(message, repeated, tag="4")] + pub artifact_ids: ::prost::alloc::vec::Vec, + /// Artifact inputs to the workflow execution for which we only have the tracking bit that's installed into the Literal's metadata by the Artifact service. + #[prost(string, repeated, tag="5")] + pub artifact_trackers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(string, tag="6")] + pub principal: ::prost::alloc::string::String, +} +/// Encoded file descriptor set for the `flyteidl2.event` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xf7, 0x96, 0x01, 0x0a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x0f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, + 0x6e, 0x74, 0x1a, 0x1c, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, + 0x72, 0x65, 0x2f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, + 0x65, 0x2f, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, + 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, + 0xae, 0x03, 0x0a, 0x16, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x4e, 0x0a, 0x0c, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x0b, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, + 0x6f, 0x64, 0x75, 0x63, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0a, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x72, 0x49, 0x64, 0x12, 0x3d, 0x0a, 0x05, 0x70, + 0x68, 0x61, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x57, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x50, 0x68, + 0x61, 0x73, 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x0b, 0x6f, 0x63, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0a, 0x6f, 0x63, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x64, 0x41, 0x74, 0x12, 0x1f, 0x0a, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x09, 0x6f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x55, 0x72, 0x69, 0x12, 0x36, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, + 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x48, 0x00, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, + 0x12, 0x3d, 0x0a, 0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, + 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, + 0x70, 0x48, 0x00, 0x52, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x44, 0x61, 0x74, 0x61, 0x42, + 0x0f, 0x0a, 0x0d, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x22, 0xbe, 0x0a, 0x0a, 0x12, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x37, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x02, 0x69, 0x64, + 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x72, 0x49, + 0x64, 0x12, 0x39, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, + 0x50, 0x68, 0x61, 0x73, 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x0b, + 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0a, 0x6f, + 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x41, 0x74, 0x12, 0x1d, 0x0a, 0x09, 0x69, 0x6e, 0x70, + 0x75, 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x08, + 0x69, 0x6e, 0x70, 0x75, 0x74, 0x55, 0x72, 0x69, 0x12, 0x3b, 0x0a, 0x0a, 0x69, 0x6e, 0x70, 0x75, + 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, + 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, 0x70, 0x48, 0x00, 0x52, 0x09, 0x69, 0x6e, 0x70, 0x75, + 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x1f, 0x0a, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, + 0x75, 0x72, 0x69, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x09, 0x6f, 0x75, 0x74, + 0x70, 0x75, 0x74, 0x55, 0x72, 0x69, 0x12, 0x36, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, + 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x45, 0x72, 0x72, 0x6f, 0x72, 0x48, 0x01, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x3d, + 0x0a, 0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x0f, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, 0x70, 0x48, + 0x01, 0x52, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x5d, 0x0a, + 0x16, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, + 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x48, 0x02, 0x52, 0x14, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x51, 0x0a, 0x12, + 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x4e, + 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x48, 0x02, 0x52, 0x10, 0x74, + 0x61, 0x73, 0x6b, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, + 0x5e, 0x0a, 0x14, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x6d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, + 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x12, 0x70, 0x61, 0x72, + 0x65, 0x6e, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, + 0x5e, 0x0a, 0x14, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, + 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x12, 0x70, 0x61, 0x72, + 0x65, 0x6e, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, + 0x1f, 0x0a, 0x0b, 0x72, 0x65, 0x74, 0x72, 0x79, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x0b, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x72, 0x65, 0x74, 0x72, 0x79, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x12, 0x20, 0x0a, 0x0c, 0x73, 0x70, 0x65, 0x63, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, + 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x70, 0x65, 0x63, 0x4e, 0x6f, 0x64, 0x65, + 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, + 0x23, 0x0a, 0x0d, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x18, 0x10, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x56, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x09, 0x69, 0x73, 0x5f, 0x70, 0x61, 0x72, 0x65, 0x6e, + 0x74, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x69, 0x73, 0x50, 0x61, 0x72, 0x65, 0x6e, + 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x73, 0x5f, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x18, + 0x12, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x69, 0x73, 0x44, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, + 0x12, 0x19, 0x0a, 0x08, 0x64, 0x65, 0x63, 0x6b, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x13, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x07, 0x64, 0x65, 0x63, 0x6b, 0x55, 0x72, 0x69, 0x12, 0x3b, 0x0a, 0x0b, 0x72, + 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0a, 0x72, 0x65, + 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x69, 0x73, 0x5f, 0x61, + 0x72, 0x72, 0x61, 0x79, 0x18, 0x16, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x69, 0x73, 0x41, 0x72, + 0x72, 0x61, 0x79, 0x12, 0x3f, 0x0a, 0x0d, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x65, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x18, 0x17, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x45, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x12, 0x2d, 0x0a, 0x13, 0x69, 0x73, 0x5f, 0x69, 0x6e, 0x5f, 0x64, 0x79, + 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x18, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x10, 0x69, 0x73, 0x49, 0x6e, 0x44, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x43, 0x68, + 0x61, 0x69, 0x6e, 0x12, 0x19, 0x0a, 0x08, 0x69, 0x73, 0x5f, 0x65, 0x61, 0x67, 0x65, 0x72, 0x18, + 0x19, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x69, 0x73, 0x45, 0x61, 0x67, 0x65, 0x72, 0x42, 0x0d, + 0x0a, 0x0b, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x0f, 0x0a, + 0x0d, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x42, 0x11, + 0x0a, 0x0f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x22, 0x66, 0x0a, 0x14, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x4e, 0x6f, 0x64, + 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x4e, 0x0a, 0x0c, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x0b, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x9c, 0x02, 0x0a, 0x10, 0x54, 0x61, + 0x73, 0x6b, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x45, + 0x0a, 0x0c, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x43, 0x61, 0x63, + 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x0b, 0x63, 0x61, 0x63, 0x68, 0x65, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x40, 0x0a, 0x0b, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, + 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x61, 0x74, 0x61, + 0x6c, 0x6f, 0x67, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x0a, 0x63, 0x61, 0x74, + 0x61, 0x6c, 0x6f, 0x67, 0x4b, 0x65, 0x79, 0x12, 0x58, 0x0a, 0x12, 0x72, 0x65, 0x73, 0x65, 0x72, + 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x52, 0x65, 0x73, 0x65, + 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x11, + 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x5f, + 0x75, 0x72, 0x69, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x68, 0x65, 0x63, 0x6b, + 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x55, 0x72, 0x69, 0x22, 0x56, 0x0a, 0x1b, 0x50, 0x61, 0x72, 0x65, + 0x6e, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x37, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x02, 0x69, 0x64, + 0x22, 0x36, 0x0a, 0x1b, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, + 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x22, 0x62, 0x0a, 0x0b, 0x45, 0x76, 0x65, 0x6e, + 0x74, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, + 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, + 0x3b, 0x0a, 0x0b, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x52, 0x0a, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x41, 0x74, 0x22, 0xdd, 0x08, 0x0a, + 0x12, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x76, + 0x65, 0x6e, 0x74, 0x12, 0x33, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x12, 0x60, 0x0a, 0x18, 0x70, 0x61, 0x72, 0x65, + 0x6e, 0x74, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4e, 0x6f, 0x64, 0x65, + 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x52, 0x15, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x45, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, + 0x74, 0x72, 0x79, 0x5f, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x0c, 0x72, 0x65, 0x74, 0x72, 0x79, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x12, + 0x39, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x50, 0x68, + 0x61, 0x73, 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, + 0x6f, 0x64, 0x75, 0x63, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0a, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x72, 0x49, 0x64, 0x12, 0x2b, 0x0a, 0x04, 0x6c, + 0x6f, 0x67, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x4c, + 0x6f, 0x67, 0x52, 0x04, 0x6c, 0x6f, 0x67, 0x73, 0x12, 0x3b, 0x0a, 0x0b, 0x6f, 0x63, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0a, 0x6f, 0x63, 0x63, 0x75, 0x72, + 0x72, 0x65, 0x64, 0x41, 0x74, 0x12, 0x1d, 0x0a, 0x09, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x75, + 0x72, 0x69, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x08, 0x69, 0x6e, 0x70, 0x75, + 0x74, 0x55, 0x72, 0x69, 0x12, 0x3b, 0x0a, 0x0a, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x64, 0x61, + 0x74, 0x61, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, + 0x6c, 0x4d, 0x61, 0x70, 0x48, 0x00, 0x52, 0x09, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x44, 0x61, 0x74, + 0x61, 0x12, 0x1f, 0x0a, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, + 0x09, 0x20, 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x09, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x55, + 0x72, 0x69, 0x12, 0x36, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x0a, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, + 0x72, 0x48, 0x01, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x3d, 0x0a, 0x0b, 0x6f, 0x75, + 0x74, 0x70, 0x75, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x61, 0x70, 0x48, 0x01, 0x52, 0x0a, 0x6f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x38, 0x0a, 0x0b, 0x63, 0x75, 0x73, + 0x74, 0x6f, 0x6d, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x0a, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x49, + 0x6e, 0x66, 0x6f, 0x12, 0x23, 0x0a, 0x0d, 0x70, 0x68, 0x61, 0x73, 0x65, 0x5f, 0x76, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x70, 0x68, 0x61, 0x73, + 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, + 0x6f, 0x6e, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x06, 0x72, 0x65, + 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x36, 0x0a, 0x07, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x73, 0x18, + 0x15, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x61, + 0x73, 0x6f, 0x6e, 0x52, 0x07, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x73, 0x12, 0x1b, 0x0a, 0x09, + 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x08, 0x74, 0x61, 0x73, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x12, 0x42, 0x0a, 0x08, 0x6d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x54, 0x61, + 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x23, 0x0a, + 0x0d, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x12, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x12, 0x3b, 0x0a, 0x0b, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x61, + 0x74, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x52, 0x0a, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, + 0x3b, 0x0a, 0x0b, 0x6c, 0x6f, 0x67, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x16, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, + 0x52, 0x0a, 0x6c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x42, 0x0d, 0x0a, 0x0b, + 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x0f, 0x0a, 0x0d, 0x6f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x8a, 0x04, 0x0a, + 0x14, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x65, 0x78, 0x74, 0x65, + 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x23, 0x0a, 0x0d, + 0x72, 0x65, 0x74, 0x72, 0x79, 0x5f, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x72, 0x65, 0x74, 0x72, 0x79, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, + 0x74, 0x12, 0x39, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, + 0x50, 0x68, 0x61, 0x73, 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x45, 0x0a, 0x0c, + 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x43, 0x61, 0x63, 0x68, 0x65, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x0b, 0x63, 0x61, 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x12, 0x2b, 0x0a, 0x04, 0x6c, 0x6f, 0x67, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x52, 0x04, 0x6c, 0x6f, 0x67, 0x73, + 0x12, 0x5d, 0x0a, 0x16, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x6e, 0x6f, 0x64, + 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, + 0x6e, 0x74, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x4e, 0x6f, 0x64, 0x65, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, 0x14, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, + 0x38, 0x0a, 0x0b, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x0a, 0x63, + 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3b, 0x0a, 0x0b, 0x6c, 0x6f, 0x67, + 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x4c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, 0x0a, 0x6c, 0x6f, 0x67, 0x43, + 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x42, 0x11, 0x0a, 0x0f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0x5b, 0x0a, 0x10, 0x52, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x6f, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x29, 0x0a, + 0x10, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x6f, 0x6b, 0x65, + 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, + 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0xa0, 0x03, 0x0a, 0x15, 0x54, 0x61, 0x73, 0x6b, 0x45, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x12, 0x25, 0x0a, 0x0e, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, + 0x74, 0x65, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x54, 0x0a, 0x12, 0x65, 0x78, 0x74, 0x65, 0x72, + 0x6e, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x18, 0x02, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x11, 0x65, 0x78, 0x74, 0x65, + 0x72, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x12, 0x4f, 0x0a, + 0x12, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x70, 0x6f, 0x6f, 0x6c, 0x5f, 0x69, + 0x6e, 0x66, 0x6f, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x52, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x6f, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x10, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x6f, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2b, + 0x0a, 0x11, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x70, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x5b, 0x0a, 0x0e, 0x69, + 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x18, 0x10, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x34, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x49, 0x6e, 0x73, 0x74, + 0x61, 0x6e, 0x63, 0x65, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x52, 0x0d, 0x69, 0x6e, 0x73, 0x74, 0x61, + 0x6e, 0x63, 0x65, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x22, 0x2f, 0x0a, 0x0d, 0x49, 0x6e, 0x73, 0x74, + 0x61, 0x6e, 0x63, 0x65, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x0b, 0x0a, 0x07, 0x44, 0x45, 0x46, + 0x41, 0x55, 0x4c, 0x54, 0x10, 0x00, 0x12, 0x11, 0x0a, 0x0d, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x52, + 0x55, 0x50, 0x54, 0x49, 0x42, 0x4c, 0x45, 0x10, 0x01, 0x42, 0xb3, 0x01, 0x0a, 0x13, 0x63, 0x6f, + 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x42, 0x0a, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, + 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, + 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x65, + 0x76, 0x65, 0x6e, 0x74, 0xa2, 0x02, 0x03, 0x46, 0x45, 0x58, 0xaa, 0x02, 0x0f, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0xca, 0x02, 0x0f, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0xe2, 0x02, + 0x1b, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x45, 0x76, 0x65, 0x6e, 0x74, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x10, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x4a, + 0xf1, 0x6f, 0x0a, 0x07, 0x12, 0x05, 0x00, 0x00, 0xc5, 0x02, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, + 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x18, 0x0a, + 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x26, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, + 0x12, 0x03, 0x05, 0x00, 0x28, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, 0x29, + 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x03, 0x12, 0x03, 0x07, 0x00, 0x27, 0x0a, 0x09, 0x0a, 0x02, 0x03, + 0x04, 0x12, 0x03, 0x08, 0x00, 0x26, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x05, 0x12, 0x03, 0x09, 0x00, + 0x29, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x0b, 0x00, 0x4a, 0x0a, 0x09, 0x0a, 0x02, 0x08, + 0x0b, 0x12, 0x03, 0x0b, 0x00, 0x4a, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0d, 0x00, + 0x25, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0d, 0x08, 0x1e, 0x0a, 0x24, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0f, 0x02, 0x34, 0x1a, 0x17, 0x20, 0x57, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x69, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x0f, + 0x02, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0f, 0x23, 0x2f, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0f, 0x32, 0x33, 0x0a, 0x40, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x12, 0x02, 0x19, 0x1a, 0x33, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x69, 0x64, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x72, 0x69, 0x67, + 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x28, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x6c, 0x6c, 0x65, + 0x72, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x12, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x12, 0x09, 0x14, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x12, 0x17, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x02, 0x12, 0x03, 0x14, 0x02, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, + 0x12, 0x03, 0x14, 0x02, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x14, 0x1f, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x14, 0x27, + 0x28, 0x0a, 0x7c, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x18, 0x02, 0x2c, 0x1a, 0x6f, + 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x20, + 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x65, 0x76, 0x65, + 0x6e, 0x74, 0x20, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x2c, 0x20, 0x69, 0x74, 0x20, + 0x69, 0x73, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x0a, 0x20, 0x62, 0x79, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x06, 0x12, 0x03, 0x18, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x18, 0x1c, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x18, 0x2a, 0x2b, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x00, 0x08, + 0x00, 0x12, 0x04, 0x1a, 0x02, 0x24, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x08, 0x00, 0x01, + 0x12, 0x03, 0x1a, 0x08, 0x15, 0x0a, 0x81, 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, + 0x1d, 0x04, 0x1a, 0x1a, 0x74, 0x20, 0x55, 0x52, 0x4c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x65, 0x6e, 0x63, + 0x6f, 0x64, 0x65, 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x66, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, + 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2e, 0x20, 0x69, 0x65, 0x2e, 0x2c, 0x20, + 0x73, 0x33, 0x3a, 0x2f, 0x2f, 0x2e, 0x2e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x04, 0x05, 0x12, 0x03, 0x1d, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x01, + 0x12, 0x03, 0x1d, 0x0b, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, + 0x1d, 0x18, 0x19, 0x0a, 0x32, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x20, 0x04, 0x22, + 0x1a, 0x25, 0x20, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x06, + 0x12, 0x03, 0x20, 0x04, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, + 0x20, 0x18, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x03, 0x12, 0x03, 0x20, 0x20, + 0x21, 0x0a, 0x43, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x06, 0x12, 0x03, 0x23, 0x04, 0x24, 0x1a, 0x36, + 0x20, 0x52, 0x61, 0x77, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, + 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x06, 0x12, + 0x03, 0x23, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x23, + 0x14, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x03, 0x12, 0x03, 0x23, 0x22, 0x23, + 0x0a, 0x0b, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x05, 0x27, 0x00, 0x82, 0x01, 0x01, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x27, 0x08, 0x1a, 0x0a, 0x38, 0x0a, 0x04, 0x04, 0x01, 0x02, + 0x00, 0x12, 0x03, 0x29, 0x02, 0x26, 0x1a, 0x2b, 0x20, 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, + 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x29, 0x02, + 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x29, 0x1f, 0x21, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x29, 0x24, 0x25, 0x0a, 0x40, 0x0a, + 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x2c, 0x02, 0x19, 0x1a, 0x33, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x69, 0x64, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x72, 0x69, 0x67, 0x69, + 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x28, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x6c, 0x6c, 0x65, 0x72, + 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, 0x2c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x2c, 0x09, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x2c, 0x17, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, + 0x02, 0x12, 0x03, 0x2e, 0x02, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x06, 0x12, + 0x03, 0x2e, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x2e, + 0x1b, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x2e, 0x23, 0x24, + 0x0a, 0x78, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x03, 0x12, 0x03, 0x32, 0x02, 0x2c, 0x1a, 0x6b, 0x20, + 0x54, 0x68, 0x69, 0x73, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x20, 0x72, + 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x20, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, + 0x73, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x0a, 0x20, 0x62, 0x79, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x03, 0x06, 0x12, 0x03, 0x32, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, + 0x01, 0x12, 0x03, 0x32, 0x1c, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x03, 0x12, + 0x03, 0x32, 0x2a, 0x2b, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x01, 0x08, 0x00, 0x12, 0x04, 0x34, 0x02, + 0x39, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x08, 0x00, 0x01, 0x12, 0x03, 0x34, 0x08, 0x13, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x04, 0x12, 0x03, 0x35, 0x04, 0x19, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x04, 0x05, 0x12, 0x03, 0x35, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x04, 0x01, 0x12, 0x03, 0x35, 0x0b, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x04, 0x03, 0x12, 0x03, 0x35, 0x17, 0x18, 0x0a, 0x3e, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x05, 0x12, + 0x03, 0x38, 0x04, 0x24, 0x1a, 0x31, 0x20, 0x52, 0x61, 0x77, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, + 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x64, 0x20, 0x62, + 0x79, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x06, + 0x12, 0x03, 0x38, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x01, 0x12, 0x03, + 0x38, 0x14, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x03, 0x12, 0x03, 0x38, 0x21, + 0x23, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x01, 0x08, 0x01, 0x12, 0x04, 0x3b, 0x02, 0x45, 0x03, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x08, 0x01, 0x01, 0x12, 0x03, 0x3b, 0x08, 0x15, 0x0a, 0x81, 0x01, + 0x0a, 0x04, 0x04, 0x01, 0x02, 0x06, 0x12, 0x03, 0x3e, 0x04, 0x1a, 0x1a, 0x74, 0x20, 0x55, 0x52, + 0x4c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x2c, 0x20, 0x69, 0x74, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x73, 0x20, 0x61, 0x6c, 0x6c, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x0a, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6c, 0x6f, 0x75, + 0x64, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x72, 0x2e, 0x20, 0x69, 0x65, 0x2e, 0x2c, 0x20, 0x73, 0x33, 0x3a, 0x2f, 0x2f, 0x2e, 0x2e, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x05, 0x12, 0x03, 0x3e, 0x04, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x01, 0x12, 0x03, 0x3e, 0x0b, 0x15, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x06, 0x03, 0x12, 0x03, 0x3e, 0x18, 0x19, 0x0a, 0x32, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x07, 0x12, 0x03, 0x41, 0x04, 0x22, 0x1a, 0x25, 0x20, 0x45, 0x72, 0x72, 0x6f, 0x72, + 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x06, 0x12, 0x03, 0x41, 0x04, 0x17, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x07, 0x01, 0x12, 0x03, 0x41, 0x18, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x07, 0x03, 0x12, 0x03, 0x41, 0x20, 0x21, 0x0a, 0x3f, 0x0a, 0x04, 0x04, 0x01, 0x02, + 0x08, 0x12, 0x03, 0x44, 0x04, 0x25, 0x1a, 0x32, 0x20, 0x52, 0x61, 0x77, 0x20, 0x6f, 0x75, 0x74, + 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, + 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x08, 0x06, 0x12, 0x03, 0x44, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x08, + 0x01, 0x12, 0x03, 0x44, 0x14, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x08, 0x03, 0x12, + 0x03, 0x44, 0x22, 0x24, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x01, 0x08, 0x02, 0x12, 0x04, 0x49, 0x02, + 0x4c, 0x03, 0x1a, 0x51, 0x20, 0x41, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x74, 0x6f, 0x20, 0x64, 0x6f, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x27, 0x73, + 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x20, 0x62, 0x61, 0x73, + 0x65, 0x64, 0x0a, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, + 0x74, 0x79, 0x70, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x08, 0x02, 0x01, 0x12, 0x03, + 0x49, 0x08, 0x17, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x09, 0x12, 0x03, 0x4a, 0x04, 0x34, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x09, 0x06, 0x12, 0x03, 0x4a, 0x04, 0x18, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x09, 0x01, 0x12, 0x03, 0x4a, 0x19, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x09, 0x03, 0x12, 0x03, 0x4a, 0x32, 0x33, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x0a, 0x12, 0x03, 0x4b, 0x04, 0x2d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0a, 0x06, + 0x12, 0x03, 0x4b, 0x04, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0a, 0x01, 0x12, 0x03, + 0x4b, 0x15, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0a, 0x03, 0x12, 0x03, 0x4b, 0x2a, + 0x2c, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x0b, 0x12, 0x03, 0x4f, 0x02, 0x37, 0x1a, 0x46, + 0x20, 0x5b, 0x54, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, + 0x65, 0x64, 0x5d, 0x20, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x77, 0x68, + 0x69, 0x63, 0x68, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x28, 0x69, 0x66, 0x20, 0x61, 0x6e, 0x79, + 0x29, 0x20, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x64, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0b, 0x06, 0x12, + 0x03, 0x4f, 0x02, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0b, 0x01, 0x12, 0x03, 0x4f, + 0x1e, 0x32, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0b, 0x03, 0x12, 0x03, 0x4f, 0x35, 0x36, + 0x0a, 0x82, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x0c, 0x12, 0x03, 0x52, 0x02, 0x38, 0x1a, 0x75, + 0x20, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, + 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x4e, 0x6f, 0x64, 0x65, 0x20, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x61, 0x74, 0x20, 0x6c, 0x65, 0x76, + 0x65, 0x6c, 0x20, 0x7a, 0x65, 0x72, 0x6f, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6e, 0x6f, 0x74, + 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x61, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x6e, + 0x6f, 0x64, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0c, 0x06, 0x12, 0x03, + 0x52, 0x02, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0c, 0x01, 0x12, 0x03, 0x52, 0x1e, + 0x32, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0c, 0x03, 0x12, 0x03, 0x52, 0x35, 0x37, 0x0a, + 0x43, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x0d, 0x12, 0x03, 0x55, 0x02, 0x1a, 0x1a, 0x36, 0x20, 0x52, + 0x65, 0x74, 0x72, 0x79, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, + 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x69, 0x6e, 0x67, 0x20, + 0x6f, 0x66, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x20, 0x62, 0x79, 0x20, 0x72, 0x65, 0x74, 0x72, + 0x69, 0x65, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0d, 0x05, 0x12, 0x03, 0x55, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0d, 0x01, 0x12, 0x03, 0x55, 0x09, 0x14, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0d, 0x03, 0x12, 0x03, 0x55, 0x17, 0x19, 0x0a, 0x78, + 0x0a, 0x04, 0x04, 0x01, 0x02, 0x0e, 0x12, 0x03, 0x59, 0x02, 0x1b, 0x1a, 0x6b, 0x20, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x72, 0x69, 0x67, + 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x67, 0x72, + 0x61, 0x70, 0x68, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x61, 0x70, 0x73, 0x20, 0x74, + 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x57, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x2e, 0x6e, 0x6f, 0x64, 0x65, + 0x73, 0x5b, 0x58, 0x5d, 0x2e, 0x69, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0e, + 0x05, 0x12, 0x03, 0x59, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0e, 0x01, 0x12, + 0x03, 0x59, 0x09, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0e, 0x03, 0x12, 0x03, 0x59, + 0x18, 0x1a, 0x0a, 0x32, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x0f, 0x12, 0x03, 0x5c, 0x02, 0x18, 0x1a, + 0x25, 0x20, 0x46, 0x72, 0x69, 0x65, 0x6e, 0x64, 0x6c, 0x79, 0x20, 0x72, 0x65, 0x61, 0x64, 0x61, + 0x62, 0x6c, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0f, 0x05, 0x12, + 0x03, 0x5c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0f, 0x01, 0x12, 0x03, 0x5c, + 0x09, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0f, 0x03, 0x12, 0x03, 0x5c, 0x15, 0x17, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x10, 0x12, 0x03, 0x5e, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x10, 0x05, 0x12, 0x03, 0x5e, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x10, 0x01, 0x12, 0x03, 0x5e, 0x08, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x10, 0x03, 0x12, 0x03, 0x5e, 0x18, 0x1a, 0x0a, 0x38, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x11, 0x12, + 0x03, 0x61, 0x02, 0x16, 0x1a, 0x2b, 0x20, 0x57, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, + 0x64, 0x20, 0x61, 0x20, 0x73, 0x75, 0x62, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x11, 0x05, 0x12, 0x03, 0x61, 0x02, 0x06, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x11, 0x01, 0x12, 0x03, 0x61, 0x07, 0x10, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x11, 0x03, 0x12, 0x03, 0x61, 0x13, 0x15, 0x0a, 0x3c, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x12, 0x12, 0x03, 0x64, 0x02, 0x17, 0x1a, 0x2f, 0x20, 0x57, 0x68, 0x65, 0x74, 0x68, + 0x65, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x79, 0x69, 0x65, + 0x6c, 0x64, 0x65, 0x64, 0x20, 0x61, 0x20, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x20, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x12, 0x05, 0x12, 0x03, 0x64, 0x02, 0x06, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x12, 0x01, + 0x12, 0x03, 0x64, 0x07, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x12, 0x03, 0x12, 0x03, + 0x64, 0x14, 0x16, 0x0a, 0xcc, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x13, 0x12, 0x03, 0x68, 0x02, + 0x17, 0x1a, 0xbe, 0x01, 0x20, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x6c, 0x6f, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x6c, 0x79, 0x20, 0x69, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x63, 0x6b, 0x20, 0x48, 0x54, 0x4d, 0x4c, 0x20, 0x66, 0x69, + 0x6c, 0x65, 0x20, 0x69, 0x73, 0x0a, 0x20, 0x4e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x55, 0x72, 0x6c, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, + 0x72, 0x6c, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, + 0x65, 0x64, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x72, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x73, 0x33, 0x3a, 0x2f, 0x2f, 0x6d, + 0x79, 0x2d, 0x62, 0x75, 0x63, 0x6b, 0x65, 0x74, 0x2f, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x73, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2f, 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x2e, 0x74, 0x61, 0x72, + 0x29, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x13, 0x05, 0x12, 0x03, 0x68, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x13, 0x01, 0x12, 0x03, 0x68, 0x09, 0x11, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x13, 0x03, 0x12, 0x03, 0x68, 0x14, 0x16, 0x0a, 0xbf, 0x03, 0x0a, + 0x04, 0x04, 0x01, 0x02, 0x14, 0x12, 0x03, 0x6e, 0x02, 0x2d, 0x1a, 0xb1, 0x03, 0x20, 0x54, 0x68, + 0x69, 0x73, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x20, 0x72, 0x65, 0x70, + 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x73, 0x74, + 0x61, 0x6e, 0x74, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x76, 0x65, + 0x6e, 0x74, 0x20, 0x77, 0x61, 0x73, 0x20, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, + 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6e, 0x67, + 0x20, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, + 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2c, 0x0a, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x66, + 0x69, 0x72, 0x73, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x20, + 0x61, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x60, 0x6f, 0x63, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x60, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x6c, 0x6c, + 0x65, 0x72, 0x20, 0x6d, 0x61, 0x6b, 0x65, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, + 0x73, 0x2c, 0x20, 0x73, 0x6f, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x6c, 0x69, 0x74, 0x65, + 0x72, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x69, + 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x63, 0x6f, 0x70, 0x69, 0x65, 0x64, 0x2e, + 0x20, 0x54, 0x68, 0x65, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x6f, 0x77, 0x65, 0x76, + 0x65, 0x72, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x73, + 0x65, 0x6e, 0x74, 0x20, 0x75, 0x6e, 0x74, 0x69, 0x6c, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x70, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, + 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x45, 0x78, 0x74, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6e, 0x67, 0x20, + 0x62, 0x6f, 0x74, 0x68, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x73, 0x65, 0x20, 0x74, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x73, 0x20, 0x66, 0x61, 0x63, 0x69, 0x6c, 0x69, 0x74, + 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x61, 0x63, 0x63, 0x75, + 0x72, 0x61, 0x74, 0x65, 0x20, 0x70, 0x6f, 0x72, 0x74, 0x72, 0x61, 0x79, 0x61, 0x6c, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2d, 0x73, 0x65, 0x72, 0x69, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x14, 0x06, 0x12, 0x03, 0x6e, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x14, 0x01, 0x12, 0x03, 0x6e, 0x1c, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x14, 0x03, 0x12, 0x03, 0x6e, 0x2a, 0x2c, 0x0a, 0x36, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x15, + 0x12, 0x03, 0x71, 0x02, 0x15, 0x1a, 0x29, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, + 0x73, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x69, + 0x73, 0x20, 0x61, 0x6e, 0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x15, 0x05, 0x12, 0x03, 0x71, 0x02, 0x06, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x15, 0x01, 0x12, 0x03, 0x71, 0x07, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x15, 0x03, 0x12, 0x03, 0x71, 0x12, 0x14, 0x0a, 0xdf, 0x03, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x16, 0x12, 0x03, 0x77, 0x02, 0x25, 0x1a, 0xd1, 0x03, 0x20, 0x53, 0x6f, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x41, 0x64, 0x6d, 0x69, 0x6e, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x6e, 0x27, + 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x62, 0x75, 0x69, 0x6c, + 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x67, 0x72, 0x61, 0x70, 0x68, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x69, + 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x20, 0x65, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x2c, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x6c, 0x6c, 0x65, 0x72, 0x20, + 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x66, 0x69, 0x6c, 0x6c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x0a, 0x20, + 0x69, 0x6e, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x2d, 0x20, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, + 0x73, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x66, 0x69, 0x6c, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x75, 0x62, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x73, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x49, + 0x44, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x75, 0x62, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x20, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x69, + 0x6e, 0x67, 0x0a, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x64, 0x65, + 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x49, 0x74, 0x20, 0x69, + 0x73, 0x20, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x66, + 0x69, 0x6e, 0x64, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x41, 0x64, 0x6d, 0x69, + 0x6e, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x65, 0x73, 0x20, 0x6f, 0x6e, 0x65, 0x20, + 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x20, + 0x41, 0x20, 0x73, 0x75, 0x62, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x20, 0x63, 0x6f, + 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x6d, + 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x20, 0x64, + 0x65, 0x65, 0x70, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x79, 0x6f, 0x75, 0x27, 0x64, 0x20, 0x6e, + 0x65, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x20, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x6b, + 0x6e, 0x6f, 0x77, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x20, 0x73, + 0x75, 0x62, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x16, 0x06, 0x12, 0x03, 0x77, 0x02, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x16, 0x01, 0x12, 0x03, 0x77, 0x12, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x16, + 0x03, 0x12, 0x03, 0x77, 0x22, 0x24, 0x0a, 0xc6, 0x04, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x17, 0x12, + 0x03, 0x7e, 0x02, 0x20, 0x1a, 0xb8, 0x04, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x73, 0x75, 0x62, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x73, 0x20, 0x28, + 0x62, 0x75, 0x74, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x20, 0x70, + 0x6c, 0x61, 0x6e, 0x73, 0x29, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x72, 0x65, 0x20, 0x72, + 0x75, 0x6e, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x64, 0x79, 0x6e, 0x61, + 0x6d, 0x69, 0x63, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x61, 0x72, 0x65, 0x20, 0x65, 0x66, 0x66, + 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x70, 0x65, 0x6e, + 0x64, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, + 0x6b, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x72, 0x65, 0x20, 0x72, 0x65, 0x67, 0x69, + 0x73, 0x74, 0x65, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x41, 0x64, 0x6d, 0x69, 0x6e, 0x27, + 0x73, 0x20, 0x64, 0x62, 0x2e, 0x20, 0x43, 0x6f, 0x6e, 0x66, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x6c, + 0x79, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6f, 0x66, 0x74, 0x65, + 0x6e, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x2c, 0x20, 0x62, 0x75, 0x74, + 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, + 0x61, 0x72, 0x65, 0x20, 0x6e, 0x6f, 0x74, 0x0a, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x72, 0x65, + 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x61, 0x6c, 0x6c, 0x2e, + 0x20, 0x53, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x2c, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, + 0x20, 0x41, 0x64, 0x6d, 0x69, 0x6e, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x68, + 0x61, 0x73, 0x20, 0x6e, 0x6f, 0x20, 0x69, 0x64, 0x65, 0x61, 0x0a, 0x20, 0x69, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x72, 0x65, 0x6c, 0x65, 0x76, 0x61, 0x6e, 0x74, 0x20, 0x65, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x69, 0x73, 0x20, + 0x77, 0x61, 0x73, 0x20, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x65, 0x64, 0x2c, 0x20, + 0x6f, 0x72, 0x20, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x5f, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x49, 0x44, 0x2c, 0x0a, 0x20, 0x61, 0x73, 0x20, + 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x61, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x49, 0x44, 0x73, + 0x20, 0x69, 0x6e, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x20, 0x45, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2c, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6e, 0x6f, + 0x74, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x6c, 0x6f, 0x6f, + 0x6b, 0x65, 0x64, 0x20, 0x75, 0x70, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, + 0x69, 0x6e, 0x20, 0x41, 0x64, 0x6d, 0x69, 0x6e, 0x27, 0x73, 0x20, 0x64, 0x62, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x17, 0x05, 0x12, 0x03, 0x7e, 0x02, 0x06, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x17, 0x01, 0x12, 0x03, 0x7e, 0x07, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x17, 0x03, 0x12, 0x03, 0x7e, 0x1d, 0x1f, 0x0a, 0x39, 0x0a, 0x04, 0x04, 0x01, 0x02, + 0x18, 0x12, 0x04, 0x81, 0x01, 0x02, 0x15, 0x1a, 0x2b, 0x20, 0x57, 0x68, 0x65, 0x74, 0x68, 0x65, + 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x6c, 0x61, 0x75, 0x6e, + 0x63, 0x68, 0x65, 0x64, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x61, 0x67, 0x65, 0x72, 0x20, 0x74, 0x61, + 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x18, 0x05, 0x12, 0x04, 0x81, + 0x01, 0x02, 0x06, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x18, 0x01, 0x12, 0x04, 0x81, 0x01, + 0x07, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x18, 0x03, 0x12, 0x04, 0x81, 0x01, 0x12, + 0x14, 0x0a, 0x61, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x06, 0x85, 0x01, 0x00, 0x87, 0x01, 0x01, 0x1a, + 0x53, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x20, 0x4e, + 0x6f, 0x64, 0x65, 0x73, 0x20, 0x77, 0x65, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x73, 0x65, 0x6e, 0x64, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x20, 0x74, 0x68, 0x61, 0x74, 0x27, 0x73, 0x20, 0x6c, 0x61, 0x75, 0x6e, 0x63, + 0x68, 0x65, 0x64, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x04, 0x85, 0x01, 0x08, + 0x1c, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x04, 0x86, 0x01, 0x02, 0x34, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, 0x04, 0x86, 0x01, 0x02, 0x22, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x04, 0x86, 0x01, 0x23, 0x2f, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x04, 0x86, 0x01, 0x32, 0x33, 0x0a, 0x0c, 0x0a, 0x02, + 0x04, 0x03, 0x12, 0x06, 0x89, 0x01, 0x00, 0x92, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x03, + 0x01, 0x12, 0x04, 0x89, 0x01, 0x08, 0x18, 0x0a, 0x42, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, + 0x04, 0x8b, 0x01, 0x02, 0x2b, 0x1a, 0x34, 0x20, 0x43, 0x61, 0x70, 0x74, 0x75, 0x72, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x63, + 0x61, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x00, 0x06, 0x12, 0x04, 0x8b, 0x01, 0x02, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x00, 0x01, 0x12, 0x04, 0x8b, 0x01, 0x1a, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x00, 0x03, 0x12, 0x04, 0x8b, 0x01, 0x29, 0x2a, 0x0a, 0x47, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, + 0x12, 0x04, 0x8d, 0x01, 0x02, 0x27, 0x1a, 0x39, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x73, 0x74, + 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x63, 0x61, 0x72, 0x72, 0x69, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x20, 0x61, 0x72, 0x74, 0x69, + 0x66, 0x61, 0x63, 0x74, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x06, 0x12, 0x04, 0x8d, 0x01, 0x02, 0x16, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x04, 0x8d, 0x01, 0x17, 0x22, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x04, 0x8d, 0x01, 0x25, 0x26, 0x0a, 0x4d, + 0x0a, 0x04, 0x04, 0x03, 0x02, 0x02, 0x12, 0x04, 0x8f, 0x01, 0x02, 0x38, 0x1a, 0x3f, 0x20, 0x43, + 0x61, 0x70, 0x74, 0x75, 0x72, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x65, + 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x02, 0x06, 0x12, 0x04, 0x8f, 0x01, 0x02, 0x20, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x02, 0x01, 0x12, 0x04, 0x8f, 0x01, 0x21, 0x33, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x02, 0x03, 0x12, 0x04, 0x8f, 0x01, 0x36, 0x37, 0x0a, 0x2e, 0x0a, 0x04, 0x04, 0x03, + 0x02, 0x03, 0x12, 0x04, 0x91, 0x01, 0x02, 0x1c, 0x1a, 0x20, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, + 0x61, 0x74, 0x65, 0x73, 0x74, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, + 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x03, 0x05, 0x12, 0x04, 0x91, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x03, 0x01, 0x12, 0x04, 0x91, 0x01, 0x09, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, + 0x03, 0x12, 0x04, 0x91, 0x01, 0x1a, 0x1b, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x06, 0x94, + 0x01, 0x00, 0x96, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x04, 0x94, 0x01, + 0x08, 0x23, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x04, 0x95, 0x01, 0x02, 0x26, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x06, 0x12, 0x04, 0x95, 0x01, 0x02, 0x1e, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x04, 0x95, 0x01, 0x1f, 0x21, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x04, 0x95, 0x01, 0x24, 0x25, 0x0a, 0x0c, 0x0a, + 0x02, 0x04, 0x05, 0x12, 0x06, 0x98, 0x01, 0x00, 0x9c, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, + 0x05, 0x01, 0x12, 0x04, 0x98, 0x01, 0x08, 0x23, 0x0a, 0x97, 0x01, 0x0a, 0x04, 0x04, 0x05, 0x02, + 0x00, 0x12, 0x04, 0x9b, 0x01, 0x02, 0x15, 0x1a, 0x88, 0x01, 0x20, 0x55, 0x6e, 0x69, 0x71, 0x75, + 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, + 0x69, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4e, + 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x6e, 0x6f, 0x64, + 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x05, 0x12, 0x04, 0x9b, 0x01, 0x02, + 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x04, 0x9b, 0x01, 0x09, 0x10, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x04, 0x9b, 0x01, 0x13, 0x14, 0x0a, + 0x0c, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x06, 0x9e, 0x01, 0x00, 0xa4, 0x01, 0x01, 0x0a, 0x0b, 0x0a, + 0x03, 0x04, 0x06, 0x01, 0x12, 0x04, 0x9e, 0x01, 0x08, 0x13, 0x0a, 0x2d, 0x0a, 0x04, 0x04, 0x06, + 0x02, 0x00, 0x12, 0x04, 0xa0, 0x01, 0x02, 0x14, 0x1a, 0x1f, 0x20, 0x41, 0x6e, 0x20, 0x65, 0x78, + 0x70, 0x6c, 0x61, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x00, 0x05, 0x12, 0x04, 0xa0, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, + 0x01, 0x12, 0x04, 0xa0, 0x01, 0x09, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, + 0x12, 0x04, 0xa0, 0x01, 0x12, 0x13, 0x0a, 0x2d, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x01, 0x12, 0x04, + 0xa3, 0x01, 0x02, 0x2c, 0x1a, 0x1f, 0x20, 0x54, 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x6f, 0x63, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x64, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x06, 0x12, 0x04, + 0xa3, 0x01, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x01, 0x12, 0x04, 0xa3, + 0x01, 0x1c, 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x03, 0x12, 0x04, 0xa3, 0x01, + 0x2a, 0x2b, 0x0a, 0x6c, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x06, 0xa7, 0x01, 0x00, 0xfa, 0x01, 0x01, + 0x1a, 0x5e, 0x20, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x63, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x76, 0x65, + 0x6e, 0x74, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, + 0x46, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x50, + 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x2c, 0x20, 0x48, 0x69, 0x76, 0x65, 0x2c, 0x20, 0x53, 0x70, 0x61, + 0x72, 0x6b, 0x2c, 0x20, 0x44, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x4a, 0x6f, 0x62, 0x2e, 0x0a, + 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x04, 0xa7, 0x01, 0x08, 0x1a, 0x0a, 0x98, 0x01, + 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x04, 0xaa, 0x01, 0x02, 0x1e, 0x1a, 0x89, 0x01, 0x20, + 0x49, 0x44, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x20, + 0x49, 0x6e, 0x20, 0x63, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x74, 0x72, 0x79, 0x41, 0x74, 0x74, + 0x65, 0x6d, 0x70, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x69, + 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, + 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x75, 0x6e, 0x69, 0x71, + 0x75, 0x65, 0x6c, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, + 0x20, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, + 0x06, 0x12, 0x04, 0xaa, 0x01, 0x02, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x01, + 0x12, 0x04, 0xaa, 0x01, 0x12, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x03, 0x12, + 0x04, 0xaa, 0x01, 0x1c, 0x1d, 0x0a, 0xa7, 0x01, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x01, 0x12, 0x04, + 0xae, 0x01, 0x02, 0x3c, 0x1a, 0x98, 0x01, 0x20, 0x41, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6c, 0x77, 0x61, + 0x79, 0x73, 0x20, 0x6b, 0x69, 0x63, 0x6b, 0x65, 0x64, 0x20, 0x6f, 0x66, 0x66, 0x20, 0x62, 0x79, + 0x20, 0x61, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x6f, 0x6e, + 0x73, 0x75, 0x6d, 0x65, 0x72, 0x0a, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x20, 0x74, 0x6f, + 0x20, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, + 0x20, 0x74, 0x6f, 0x20, 0x69, 0x74, 0x27, 0x73, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, + 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x06, 0x12, 0x04, 0xae, 0x01, 0x02, 0x1e, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x01, 0x12, 0x04, 0xae, 0x01, 0x1f, 0x37, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, 0x04, 0xae, 0x01, 0x3a, 0x3b, 0x0a, 0x51, 0x0a, 0x04, + 0x04, 0x07, 0x02, 0x02, 0x12, 0x04, 0xb1, 0x01, 0x02, 0x1b, 0x1a, 0x43, 0x20, 0x72, 0x65, 0x74, + 0x72, 0x79, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, + 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2c, + 0x20, 0x69, 0x65, 0x2e, 0x2c, 0x20, 0x32, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x05, 0x12, 0x04, 0xb1, 0x01, 0x02, 0x08, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x01, 0x12, 0x04, 0xb1, 0x01, 0x09, 0x16, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x02, 0x03, 0x12, 0x04, 0xb1, 0x01, 0x19, 0x1a, 0x0a, 0x2f, 0x0a, 0x04, + 0x04, 0x07, 0x02, 0x03, 0x12, 0x04, 0xb4, 0x01, 0x02, 0x25, 0x1a, 0x21, 0x20, 0x50, 0x68, 0x61, + 0x73, 0x65, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x03, 0x06, 0x12, 0x04, 0xb4, 0x01, 0x02, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x03, 0x01, 0x12, 0x04, 0xb4, 0x01, 0x1b, 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x03, 0x03, 0x12, 0x04, 0xb4, 0x01, 0x23, 0x24, 0x0a, 0x52, 0x0a, 0x04, 0x04, 0x07, + 0x02, 0x04, 0x12, 0x04, 0xb7, 0x01, 0x02, 0x19, 0x1a, 0x44, 0x20, 0x69, 0x64, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x73, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x2c, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x6c, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x72, + 0x61, 0x63, 0x65, 0x20, 0x64, 0x65, 0x62, 0x75, 0x67, 0x67, 0x69, 0x6e, 0x67, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x04, 0x05, 0x12, 0x04, 0xb7, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x04, 0x01, 0x12, 0x04, 0xb7, 0x01, 0x09, 0x14, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x04, 0x03, 0x12, 0x04, 0xb7, 0x01, 0x17, 0x18, 0x0a, 0x36, 0x0a, 0x04, 0x04, + 0x07, 0x02, 0x05, 0x12, 0x04, 0xba, 0x01, 0x02, 0x21, 0x1a, 0x28, 0x20, 0x6c, 0x6f, 0x67, 0x20, + 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x05, 0x04, 0x12, 0x04, 0xba, 0x01, + 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x05, 0x06, 0x12, 0x04, 0xba, 0x01, 0x0b, + 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x05, 0x01, 0x12, 0x04, 0xba, 0x01, 0x18, 0x1c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x05, 0x03, 0x12, 0x04, 0xba, 0x01, 0x1f, 0x20, 0x0a, + 0x79, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x06, 0x12, 0x04, 0xbe, 0x01, 0x02, 0x2c, 0x1a, 0x6b, 0x20, + 0x54, 0x68, 0x69, 0x73, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x20, 0x72, + 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x20, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, + 0x73, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x0a, 0x20, 0x62, 0x79, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x06, 0x06, 0x12, 0x04, 0xbe, 0x01, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x06, 0x01, 0x12, 0x04, 0xbe, 0x01, 0x1c, 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x06, + 0x03, 0x12, 0x04, 0xbe, 0x01, 0x2a, 0x2b, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x07, 0x08, 0x00, 0x12, + 0x06, 0xc0, 0x01, 0x02, 0xc7, 0x01, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x08, 0x00, 0x01, + 0x12, 0x04, 0xc0, 0x01, 0x08, 0x13, 0x0a, 0x75, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x07, 0x12, 0x04, + 0xc3, 0x01, 0x04, 0x19, 0x1a, 0x67, 0x20, 0x55, 0x52, 0x49, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2c, 0x20, 0x69, 0x74, + 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x69, 0x6e, + 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x20, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2e, 0x20, 0x69, + 0x65, 0x2e, 0x2c, 0x20, 0x73, 0x33, 0x3a, 0x2f, 0x2f, 0x2e, 0x2e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x07, 0x05, 0x12, 0x04, 0xc3, 0x01, 0x04, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x07, 0x01, 0x12, 0x04, 0xc3, 0x01, 0x0b, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x07, 0x03, 0x12, 0x04, 0xc3, 0x01, 0x17, 0x18, 0x0a, 0x3f, 0x0a, 0x04, 0x04, 0x07, + 0x02, 0x08, 0x12, 0x04, 0xc6, 0x01, 0x04, 0x24, 0x1a, 0x31, 0x20, 0x52, 0x61, 0x77, 0x20, 0x69, + 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, + 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x08, 0x06, 0x12, 0x04, 0xc6, 0x01, 0x04, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x08, 0x01, 0x12, 0x04, 0xc6, 0x01, 0x14, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x08, 0x03, 0x12, 0x04, 0xc6, 0x01, 0x21, 0x23, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x07, 0x08, 0x01, + 0x12, 0x06, 0xc9, 0x01, 0x02, 0xd3, 0x01, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x08, 0x01, + 0x01, 0x12, 0x04, 0xc9, 0x01, 0x08, 0x15, 0x0a, 0x9c, 0x01, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x09, + 0x12, 0x04, 0xcc, 0x01, 0x04, 0x1a, 0x1a, 0x8d, 0x01, 0x20, 0x55, 0x52, 0x49, 0x20, 0x74, 0x6f, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x69, 0x74, + 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x66, 0x6f, + 0x72, 0x6d, 0x61, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, + 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, + 0x20, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x70, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2e, 0x20, 0x69, 0x65, 0x2e, 0x2c, 0x20, 0x73, 0x33, 0x3a, + 0x2f, 0x2f, 0x2e, 0x2e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x09, 0x05, 0x12, + 0x04, 0xcc, 0x01, 0x04, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x09, 0x01, 0x12, 0x04, + 0xcc, 0x01, 0x0b, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x09, 0x03, 0x12, 0x04, 0xcc, + 0x01, 0x18, 0x19, 0x0a, 0x33, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x0a, 0x12, 0x04, 0xcf, 0x01, 0x04, + 0x23, 0x1a, 0x25, 0x20, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x0a, + 0x06, 0x12, 0x04, 0xcf, 0x01, 0x04, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x0a, 0x01, + 0x12, 0x04, 0xcf, 0x01, 0x18, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x0a, 0x03, 0x12, + 0x04, 0xcf, 0x01, 0x20, 0x22, 0x0a, 0x40, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x0b, 0x12, 0x04, 0xd2, + 0x01, 0x04, 0x25, 0x1a, 0x32, 0x20, 0x52, 0x61, 0x77, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, + 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x64, 0x20, 0x62, + 0x79, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x0b, 0x06, + 0x12, 0x04, 0xd2, 0x01, 0x04, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x0b, 0x01, 0x12, + 0x04, 0xd2, 0x01, 0x14, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x0b, 0x03, 0x12, 0x04, + 0xd2, 0x01, 0x22, 0x24, 0x0a, 0x77, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x0c, 0x12, 0x04, 0xd6, 0x01, + 0x02, 0x2a, 0x1a, 0x69, 0x20, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x64, 0x61, 0x74, 0x61, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x70, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x73, 0x20, 0x62, 0x61, 0x63, 0x6b, + 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, + 0x69, 0x62, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x20, 0x76, 0x61, + 0x72, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x20, 0x69, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x0c, 0x06, 0x12, 0x04, 0xd6, 0x01, 0x02, 0x18, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x0c, 0x01, 0x12, 0x04, 0xd6, 0x01, 0x19, 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x0c, 0x03, 0x12, 0x04, 0xd6, 0x01, 0x27, 0x29, 0x0a, 0xae, 0x02, 0x0a, 0x04, 0x04, + 0x07, 0x02, 0x0d, 0x12, 0x04, 0xdb, 0x01, 0x02, 0x1c, 0x1a, 0x9f, 0x02, 0x20, 0x53, 0x6f, 0x6d, + 0x65, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x73, 0x2c, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x52, + 0x55, 0x4e, 0x4e, 0x49, 0x4e, 0x47, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x73, 0x65, 0x6e, 0x64, + 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x20, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x28, 0x6e, 0x65, 0x77, 0x20, 0x6c, 0x6f, 0x67, 0x73, + 0x2c, 0x20, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x63, 0x75, 0x73, + 0x74, 0x6f, 0x6d, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x2c, 0x20, 0x65, 0x74, 0x63, 0x29, 0x0a, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x72, + 0x65, 0x63, 0x6f, 0x72, 0x64, 0x65, 0x64, 0x20, 0x72, 0x65, 0x67, 0x61, 0x72, 0x64, 0x6c, 0x65, + 0x73, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x63, 0x6b, 0x20, 0x6f, + 0x66, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x20, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x2e, 0x0a, + 0x20, 0x54, 0x68, 0x65, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x69, 0x6e, 0x63, + 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x20, 0x61, + 0x63, 0x72, 0x6f, 0x73, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x76, 0x69, 0x64, + 0x75, 0x61, 0x6c, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x0d, 0x05, 0x12, 0x04, 0xdb, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x0d, 0x01, 0x12, 0x04, 0xdb, 0x01, 0x09, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x0d, 0x03, 0x12, 0x04, 0xdb, 0x01, 0x19, 0x1b, 0x0a, 0x63, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x0e, + 0x12, 0x04, 0xdf, 0x01, 0x02, 0x29, 0x1a, 0x55, 0x20, 0x41, 0x6e, 0x20, 0x6f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x20, 0x74, + 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x44, 0x65, 0x70, 0x72, + 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x3a, 0x20, 0x55, 0x73, 0x65, 0x20, 0x72, 0x65, 0x61, 0x73, + 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x0e, 0x05, 0x12, 0x04, 0xdf, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x0e, 0x01, 0x12, 0x04, 0xdf, 0x01, 0x09, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x0e, 0x03, 0x12, 0x04, 0xdf, 0x01, 0x12, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x0e, 0x08, 0x12, 0x04, 0xdf, 0x01, 0x15, 0x28, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x07, 0x02, + 0x0e, 0x08, 0x03, 0x12, 0x04, 0xdf, 0x01, 0x16, 0x27, 0x0a, 0x4a, 0x0a, 0x04, 0x04, 0x07, 0x02, + 0x0f, 0x12, 0x04, 0xe2, 0x01, 0x02, 0x24, 0x1a, 0x3c, 0x20, 0x41, 0x6e, 0x20, 0x6f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x65, 0x78, + 0x70, 0x6c, 0x61, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x0f, 0x04, 0x12, 0x04, + 0xe2, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x0f, 0x06, 0x12, 0x04, 0xe2, + 0x01, 0x0b, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x0f, 0x01, 0x12, 0x04, 0xe2, 0x01, + 0x17, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x0f, 0x03, 0x12, 0x04, 0xe2, 0x01, 0x21, + 0x23, 0x0a, 0xb7, 0x02, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x10, 0x12, 0x04, 0xe7, 0x01, 0x02, 0x18, + 0x1a, 0xa8, 0x02, 0x20, 0x41, 0x20, 0x70, 0x72, 0x65, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, + 0x20, 0x79, 0x65, 0x74, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, + 0x54, 0x61, 0x73, 0x6b, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, + 0x6b, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, + 0x61, 0x6c, 0x72, 0x65, 0x61, 0x64, 0x79, 0x20, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, + 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x20, 0x61, 0x64, 0x6d, 0x69, + 0x6e, 0x0a, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x77, 0x69, 0x6c, + 0x6c, 0x20, 0x62, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x2c, 0x20, + 0x62, 0x75, 0x74, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x61, 0x73, 0x6b, + 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6e, 0x65, 0x63, 0x65, + 0x73, 0x73, 0x61, 0x72, 0x69, 0x6c, 0x79, 0x20, 0x75, 0x73, 0x65, 0x20, 0x70, 0x72, 0x65, 0x2d, + 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x65, 0x64, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x69, 0x73, 0x0a, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x66, 0x75, 0x6c, 0x20, + 0x74, 0x6f, 0x20, 0x72, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, + 0x73, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x55, 0x49, 0x2c, 0x20, 0x66, 0x69, + 0x6c, 0x74, 0x65, 0x72, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x2c, 0x20, 0x65, 0x74, 0x63, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x10, 0x05, 0x12, 0x04, 0xe7, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x10, 0x01, 0x12, 0x04, 0xe7, 0x01, 0x09, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x10, 0x03, 0x12, 0x04, 0xe7, 0x01, 0x15, 0x17, 0x0a, 0x38, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x11, + 0x12, 0x04, 0xea, 0x01, 0x02, 0x26, 0x1a, 0x2a, 0x20, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x61, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x61, 0x20, 0x74, + 0x61, 0x73, 0x6b, 0x20, 0x77, 0x61, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x11, 0x06, 0x12, 0x04, 0xea, 0x01, 0x02, + 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x11, 0x01, 0x12, 0x04, 0xea, 0x01, 0x18, 0x20, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x11, 0x03, 0x12, 0x04, 0xea, 0x01, 0x23, 0x25, 0x0a, + 0xb4, 0x02, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x12, 0x12, 0x04, 0xf0, 0x01, 0x02, 0x1b, 0x1a, 0xa5, + 0x02, 0x20, 0x54, 0x68, 0x65, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, + 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, + 0x64, 0x20, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x68, 0x6f, 0x77, + 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x69, 0x73, 0x0a, 0x20, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x20, 0x46, 0x6f, 0x72, + 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2c, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x5f, + 0x76, 0x65, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x3e, 0x20, 0x30, 0x20, 0x6d, 0x65, 0x61, 0x6e, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x6d, 0x61, 0x70, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, + 0x73, 0x20, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x75, 0x73, + 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x45, + 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, + 0x6e, 0x66, 0x6f, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, + 0x61, 0x63, 0x68, 0x20, 0x73, 0x75, 0x62, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x72, 0x61, 0x74, 0x68, + 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x54, 0x61, 0x73, 0x6b, + 0x4c, 0x6f, 0x67, 0x0a, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x12, 0x05, 0x12, + 0x04, 0xf0, 0x01, 0x02, 0x07, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x12, 0x01, 0x12, 0x04, + 0xf0, 0x01, 0x08, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x12, 0x03, 0x12, 0x04, 0xf0, + 0x01, 0x18, 0x1a, 0x0a, 0xa6, 0x03, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x13, 0x12, 0x04, 0xf6, 0x01, + 0x02, 0x2d, 0x1a, 0x97, 0x03, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x20, 0x77, 0x68, 0x65, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x20, 0x77, 0x61, 0x73, 0x20, 0x72, + 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x77, 0x6f, + 0x72, 0x6b, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2c, + 0x20, 0x61, 0x20, 0x6b, 0x38, 0x73, 0x0a, 0x20, 0x70, 0x6f, 0x64, 0x20, 0x74, 0x61, 0x73, 0x6b, + 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x64, 0x20, 0x63, + 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x28, 0x69, 0x65, 0x2e, + 0x20, 0x60, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x60, 0x29, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x72, 0x75, 0x6e, 0x6e, 0x69, 0x6e, + 0x67, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x70, + 0x6c, 0x65, 0x74, 0x65, 0x73, 0x2c, 0x0a, 0x20, 0x62, 0x75, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6e, 0x6f, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x74, 0x69, + 0x6c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6f, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6d, 0x61, 0x72, + 0x6b, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, + 0x2e, 0x20, 0x45, 0x78, 0x74, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x62, 0x6f, 0x74, + 0x68, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x73, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x73, 0x0a, 0x20, 0x66, 0x61, 0x63, 0x69, 0x6c, 0x69, 0x74, 0x61, 0x74, + 0x65, 0x73, 0x20, 0x61, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x61, 0x63, 0x63, 0x75, 0x72, 0x61, + 0x74, 0x65, 0x20, 0x70, 0x6f, 0x72, 0x74, 0x72, 0x61, 0x79, 0x61, 0x6c, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, + 0x69, 0x6d, 0x65, 0x2d, 0x73, 0x65, 0x72, 0x69, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x13, 0x06, 0x12, 0x04, 0xf6, 0x01, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x13, 0x01, 0x12, 0x04, 0xf6, 0x01, 0x1c, 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x13, 0x03, 0x12, 0x04, 0xf6, 0x01, 0x2a, 0x2c, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x07, 0x02, + 0x14, 0x12, 0x04, 0xf9, 0x01, 0x02, 0x23, 0x1a, 0x4c, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x73, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x72, 0x65, 0x71, 0x75, + 0x69, 0x72, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x79, + 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x14, 0x06, 0x12, 0x04, + 0xf9, 0x01, 0x02, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x14, 0x01, 0x12, 0x04, 0xf9, + 0x01, 0x12, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x14, 0x03, 0x12, 0x04, 0xf9, 0x01, + 0x20, 0x22, 0x0a, 0x76, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x06, 0xfd, 0x01, 0x00, 0x9e, 0x02, 0x01, + 0x1a, 0x68, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, + 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, + 0x63, 0x65, 0x64, 0x20, 0x6f, 0x72, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x08, + 0x01, 0x12, 0x04, 0xfd, 0x01, 0x08, 0x1c, 0x0a, 0x84, 0x01, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x00, + 0x12, 0x04, 0xff, 0x01, 0x02, 0x19, 0x1a, 0x76, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x78, 0x74, 0x65, 0x72, + 0x6e, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x63, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, + 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x51, 0x75, 0x62, 0x6f, 0x6c, 0x65, 0x20, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x20, 0x49, 0x44, 0x20, 0x6f, 0x72, 0x20, 0x70, 0x72, 0x65, 0x73, + 0x74, 0x6f, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x20, 0x69, 0x64, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x05, 0x12, 0x04, 0xff, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x04, 0xff, 0x01, 0x09, 0x14, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x04, 0xff, 0x01, 0x17, 0x18, 0x0a, 0x91, 0x02, 0x0a, 0x04, + 0x04, 0x08, 0x02, 0x01, 0x12, 0x04, 0x84, 0x02, 0x02, 0x13, 0x1a, 0x82, 0x02, 0x20, 0x41, 0x20, + 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x72, 0x65, 0x73, 0x70, + 0x65, 0x63, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x65, 0x78, 0x74, 0x65, 0x72, + 0x6e, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x20, 0x41, 0x6c, 0x74, + 0x68, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x72, 0x65, + 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x6f, + 0x72, 0x20, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x61, 0x6d, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x61, + 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x69, 0x6e, 0x66, 0x6f, + 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6d, 0x75, 0x6c, + 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x05, 0x12, 0x04, 0x84, 0x02, 0x02, 0x08, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x01, 0x12, 0x04, 0x84, 0x02, 0x09, 0x0e, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x01, 0x03, 0x12, 0x04, 0x84, 0x02, 0x11, 0x12, 0x0a, 0x5e, 0x0a, 0x04, + 0x04, 0x08, 0x02, 0x02, 0x12, 0x04, 0x87, 0x02, 0x02, 0x1b, 0x1a, 0x50, 0x20, 0x52, 0x65, 0x74, + 0x72, 0x79, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, + 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x65, 0x78, 0x74, 0x65, 0x72, + 0x6e, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2c, 0x20, 0x69, 0x65, + 0x2e, 0x2c, 0x20, 0x32, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, + 0x6f, 0x6e, 0x64, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x08, 0x02, 0x02, 0x05, 0x12, 0x04, 0x87, 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x02, 0x01, 0x12, 0x04, 0x87, 0x02, 0x09, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x02, 0x03, 0x12, 0x04, 0x87, 0x02, 0x19, 0x1a, 0x0a, 0x3b, 0x0a, 0x04, 0x04, 0x08, 0x02, + 0x03, 0x12, 0x04, 0x8a, 0x02, 0x02, 0x25, 0x1a, 0x2d, 0x20, 0x50, 0x68, 0x61, 0x73, 0x65, 0x20, + 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x06, 0x12, + 0x04, 0x8a, 0x02, 0x02, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x01, 0x12, 0x04, + 0x8a, 0x02, 0x1b, 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x03, 0x12, 0x04, 0x8a, + 0x02, 0x23, 0x24, 0x0a, 0x54, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x04, 0x12, 0x04, 0x8d, 0x02, 0x02, + 0x2b, 0x1a, 0x46, 0x20, 0x43, 0x61, 0x70, 0x74, 0x75, 0x72, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x63, 0x61, 0x63, 0x68, 0x69, + 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x65, 0x78, 0x74, 0x65, + 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x04, 0x06, 0x12, 0x04, 0x8d, 0x02, 0x02, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x04, + 0x01, 0x12, 0x04, 0x8d, 0x02, 0x1a, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x04, 0x03, + 0x12, 0x04, 0x8d, 0x02, 0x29, 0x2a, 0x0a, 0x43, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x05, 0x12, 0x04, + 0x90, 0x02, 0x02, 0x21, 0x1a, 0x35, 0x20, 0x6c, 0x6f, 0x67, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, + 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, + 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x05, 0x04, 0x12, 0x04, 0x90, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x05, 0x06, 0x12, 0x04, 0x90, 0x02, 0x0b, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x05, 0x01, 0x12, 0x04, 0x90, 0x02, 0x18, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, + 0x03, 0x12, 0x04, 0x90, 0x02, 0x1f, 0x20, 0x0a, 0x9c, 0x02, 0x0a, 0x04, 0x04, 0x08, 0x08, 0x00, + 0x12, 0x06, 0x95, 0x02, 0x02, 0x97, 0x02, 0x03, 0x1a, 0x8b, 0x02, 0x20, 0x41, 0x64, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, + 0x74, 0x6f, 0x20, 0x64, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x65, 0x76, 0x65, 0x6e, 0x74, 0x27, 0x73, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x74, 0x61, 0x72, + 0x67, 0x65, 0x74, 0x20, 0x62, 0x61, 0x73, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x20, 0x57, 0x65, 0x20, 0x61, + 0x72, 0x65, 0x0a, 0x20, 0x65, 0x78, 0x70, 0x6c, 0x69, 0x63, 0x69, 0x74, 0x6c, 0x79, 0x20, 0x6e, + 0x6f, 0x74, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x20, 0x68, 0x65, 0x72, 0x65, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, + 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x63, 0x6c, 0x65, 0x61, 0x72, + 0x20, 0x69, 0x66, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x65, 0x64, + 0x2e, 0x0a, 0x20, 0x49, 0x66, 0x20, 0x77, 0x65, 0x20, 0x64, 0x65, 0x63, 0x69, 0x64, 0x65, 0x20, + 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x2c, 0x20, 0x77, 0x65, 0x20, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x20, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x08, 0x00, 0x01, 0x12, + 0x04, 0x95, 0x02, 0x08, 0x17, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x06, 0x12, 0x04, 0x96, + 0x02, 0x04, 0x34, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x06, 0x12, 0x04, 0x96, 0x02, + 0x04, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x01, 0x12, 0x04, 0x96, 0x02, 0x19, + 0x2f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x03, 0x12, 0x04, 0x96, 0x02, 0x32, 0x33, + 0x0a, 0x41, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x07, 0x12, 0x04, 0x9a, 0x02, 0x02, 0x29, 0x1a, 0x33, + 0x20, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2c, 0x20, 0x70, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x2d, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x69, 0x6e, + 0x66, 0x6f, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x06, 0x12, 0x04, 0x9a, 0x02, + 0x02, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x01, 0x12, 0x04, 0x9a, 0x02, 0x19, + 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x03, 0x12, 0x04, 0x9a, 0x02, 0x27, 0x28, + 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x08, 0x12, 0x04, 0x9d, 0x02, 0x02, 0x22, 0x1a, 0x4c, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x79, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x72, 0x65, 0x6c, + 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, + 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x08, 0x02, 0x08, 0x06, 0x12, 0x04, 0x9d, 0x02, 0x02, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x08, 0x01, 0x12, 0x04, 0x9d, 0x02, 0x12, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x08, 0x03, 0x12, 0x04, 0x9d, 0x02, 0x20, 0x21, 0x0a, 0x9a, 0x01, 0x0a, 0x02, 0x04, 0x09, + 0x12, 0x06, 0xa2, 0x02, 0x00, 0xa8, 0x02, 0x01, 0x1a, 0x8b, 0x01, 0x20, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x68, 0x6f, 0x6c, 0x64, 0x73, 0x20, 0x74, + 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, + 0x74, 0x6f, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x61, 0x6c, 0x6c, 0x6f, + 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x6d, + 0x61, 0x6e, 0x61, 0x67, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, + 0x0a, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, 0x04, 0xa2, + 0x02, 0x08, 0x18, 0x0a, 0x5b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x00, 0x12, 0x04, 0xa4, 0x02, 0x02, + 0x1e, 0x1a, 0x4d, 0x20, 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x20, 0x49, 0x44, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x79, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x61, 0x6c, 0x6c, 0x6f, + 0x63, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x05, 0x12, 0x04, 0xa4, 0x02, 0x02, 0x08, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x04, 0xa4, 0x02, 0x09, 0x19, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, 0x04, 0xa4, 0x02, 0x1c, 0x1d, 0x0a, 0x58, 0x0a, + 0x04, 0x04, 0x09, 0x02, 0x01, 0x12, 0x04, 0xa7, 0x02, 0x02, 0x17, 0x1a, 0x4a, 0x20, 0x4e, 0x61, + 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x77, 0x68, + 0x69, 0x63, 0x68, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, + 0x64, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x05, + 0x12, 0x04, 0xa7, 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x01, 0x12, + 0x04, 0xa7, 0x02, 0x09, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x03, 0x12, 0x04, + 0xa7, 0x02, 0x15, 0x16, 0x0a, 0x89, 0x03, 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x06, 0xae, 0x02, 0x00, + 0xc5, 0x02, 0x01, 0x1a, 0xfa, 0x02, 0x20, 0x48, 0x6f, 0x6c, 0x64, 0x73, 0x20, 0x6d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x61, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x68, 0x6f, 0x77, + 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x77, 0x61, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x20, 0x41, 0x73, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, + 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x61, 0x63, 0x72, + 0x6f, 0x73, 0x73, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x73, + 0x20, 0x64, 0x75, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, + 0x73, 0x2c, 0x20, 0x73, 0x75, 0x63, 0x68, 0x20, 0x69, 0x74, 0x73, 0x20, 0x67, 0x65, 0x6e, 0x65, + 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x20, 0x67, 0x65, 0x6e, 0x65, + 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x2c, 0x0a, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, + 0x6f, 0x72, 0x65, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x67, 0x72, 0x6f, 0x77, 0x20, 0x69, 0x6e, 0x20, + 0x73, 0x69, 0x7a, 0x65, 0x20, 0x62, 0x75, 0x74, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x63, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x20, 0x6e, 0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72, 0x69, 0x6c, 0x79, 0x20, + 0x62, 0x61, 0x73, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x68, 0x61, + 0x73, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x73, 0x70, 0x61, 0x72, 0x6b, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, + 0x76, 0x65, 0x6e, 0x74, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x0a, 0x20, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x73, 0x65, 0x20, + 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x20, 0x61, 0x63, 0x72, 0x6f, 0x73, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6c, 0x69, 0x66, 0x65, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x2e, 0x0a, + 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0a, 0x01, 0x12, 0x04, 0xae, 0x02, 0x08, 0x1d, 0x0a, 0x53, 0x0a, + 0x04, 0x04, 0x0a, 0x02, 0x00, 0x12, 0x04, 0xb0, 0x02, 0x02, 0x1c, 0x1a, 0x45, 0x20, 0x55, 0x6e, + 0x69, 0x71, 0x75, 0x65, 0x2c, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, + 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, + 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x75, 0x73, 0x65, + 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x05, 0x12, 0x04, 0xb0, 0x02, 0x02, + 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x04, 0xb0, 0x02, 0x09, 0x17, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, 0x04, 0xb0, 0x02, 0x1a, 0x1b, 0x0a, + 0x90, 0x01, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x01, 0x12, 0x04, 0xb3, 0x02, 0x02, 0x37, 0x1a, 0x81, + 0x01, 0x20, 0x41, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x6f, 0x6e, 0x20, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x20, 0x6f, 0x6e, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, + 0x20, 0x62, 0x61, 0x63, 0x6b, 0x2d, 0x65, 0x6e, 0x64, 0x73, 0x20, 0x6f, 0x72, 0x20, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x73, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x48, 0x69, + 0x76, 0x65, 0x2c, 0x20, 0x51, 0x75, 0x62, 0x6f, 0x6c, 0x65, 0x2c, 0x20, 0x65, 0x74, 0x63, 0x29, + 0x20, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x04, 0x12, 0x04, 0xb3, 0x02, 0x02, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x06, 0x12, 0x04, 0xb3, 0x02, 0x0b, 0x1f, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x01, 0x12, 0x04, 0xb3, 0x02, 0x20, 0x32, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x03, 0x12, 0x04, 0xb3, 0x02, 0x35, 0x36, 0x0a, 0xca, + 0x01, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x02, 0x12, 0x04, 0xb7, 0x02, 0x02, 0x33, 0x1a, 0xbb, 0x01, + 0x20, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x6f, 0x6e, 0x20, 0x63, 0x6f, 0x6e, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x20, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x75, 0x73, 0x65, 0x64, + 0x20, 0x64, 0x75, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x2e, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x72, + 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x62, 0x65, + 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x61, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x20, 0x63, + 0x61, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, + 0x70, 0x6c, 0x65, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x61, 0x6c, 0x6c, + 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x64, 0x75, 0x72, 0x69, 0x6e, 0x67, 0x20, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0a, 0x02, 0x02, 0x04, 0x12, 0x04, 0xb7, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, + 0x02, 0x02, 0x06, 0x12, 0x04, 0xb7, 0x02, 0x0b, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, + 0x02, 0x01, 0x12, 0x04, 0xb7, 0x02, 0x1c, 0x2e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, + 0x03, 0x12, 0x04, 0xb7, 0x02, 0x31, 0x32, 0x0a, 0x47, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x03, 0x12, + 0x04, 0xba, 0x02, 0x02, 0x1f, 0x1a, 0x39, 0x20, 0x54, 0x68, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, 0x05, 0x12, 0x04, 0xba, 0x02, 0x02, 0x08, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x04, 0xba, 0x02, 0x09, 0x1a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, 0x03, 0x12, 0x04, 0xba, 0x02, 0x1d, 0x1e, 0x0a, 0x5f, 0x0a, + 0x04, 0x04, 0x0a, 0x04, 0x00, 0x12, 0x06, 0xbd, 0x02, 0x02, 0xc3, 0x02, 0x03, 0x1a, 0x4f, 0x20, + 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x72, 0x6f, + 0x61, 0x64, 0x20, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x6d, + 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x74, 0x61, + 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0a, 0x04, 0x00, 0x01, 0x12, 0x04, 0xbd, 0x02, 0x07, 0x14, 0x0a, 0x5b, 0x0a, + 0x06, 0x04, 0x0a, 0x04, 0x00, 0x02, 0x00, 0x12, 0x04, 0xbf, 0x02, 0x04, 0x10, 0x1a, 0x4b, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x69, 0x6e, 0x73, 0x74, + 0x61, 0x6e, 0x63, 0x65, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x75, 0x72, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x2e, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, + 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, 0xbf, 0x02, 0x04, 0x0b, 0x0a, 0x0f, 0x0a, 0x07, 0x04, + 0x0a, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x04, 0xbf, 0x02, 0x0e, 0x0f, 0x0a, 0x48, 0x0a, 0x06, + 0x04, 0x0a, 0x04, 0x00, 0x02, 0x01, 0x12, 0x04, 0xc2, 0x02, 0x04, 0x16, 0x1a, 0x38, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x63, 0x6c, 0x61, 0x73, + 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x74, + 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, 0x04, 0x00, 0x02, 0x01, + 0x01, 0x12, 0x04, 0xc2, 0x02, 0x04, 0x11, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, 0x04, 0x00, 0x02, + 0x01, 0x02, 0x12, 0x04, 0xc2, 0x02, 0x14, 0x15, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x04, + 0x12, 0x04, 0xc4, 0x02, 0x02, 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x04, 0x06, 0x12, + 0x04, 0xc4, 0x02, 0x02, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, + 0xc4, 0x02, 0x10, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0xc4, + 0x02, 0x21, 0x23, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0x84, 0x28, 0x0a, 0x21, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2f, + 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x0f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, + 0x6e, 0x74, 0x1a, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, + 0x72, 0x65, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x22, 0xb8, 0x04, 0x0a, 0x1b, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x45, 0x76, 0x65, 0x6e, + 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x44, 0x0a, 0x09, 0x72, 0x61, 0x77, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x08, + 0x72, 0x61, 0x77, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x49, 0x0a, 0x10, 0x6f, 0x75, 0x74, 0x70, + 0x75, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, + 0x63, 0x65, 0x52, 0x0f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, + 0x61, 0x63, 0x65, 0x12, 0x3d, 0x0a, 0x0c, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, + 0x69, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x66, + 0x61, 0x63, 0x74, 0x49, 0x44, 0x52, 0x0b, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, + 0x64, 0x73, 0x12, 0x5c, 0x0a, 0x13, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x12, 0x72, 0x65, + 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x12, 0x40, + 0x0a, 0x0e, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x70, 0x6c, 0x61, 0x6e, 0x5f, 0x69, 0x64, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x52, 0x0c, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x50, 0x6c, 0x61, 0x6e, 0x49, 0x64, + 0x12, 0x50, 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x38, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, + 0x6e, 0x74, 0x2e, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x57, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x4c, + 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, + 0x6c, 0x73, 0x1a, 0x39, 0x0a, 0x0b, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, + 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x99, 0x04, + 0x0a, 0x17, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x4e, 0x6f, 0x64, 0x65, + 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x40, 0x0a, 0x09, 0x72, 0x61, 0x77, + 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x4e, + 0x6f, 0x64, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x76, 0x65, 0x6e, + 0x74, 0x52, 0x08, 0x72, 0x61, 0x77, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x49, 0x0a, 0x0c, 0x74, + 0x61, 0x73, 0x6b, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x0a, 0x74, 0x61, 0x73, 0x6b, + 0x45, 0x78, 0x65, 0x63, 0x49, 0x64, 0x12, 0x49, 0x0a, 0x10, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, + 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, + 0x52, 0x0f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, + 0x65, 0x12, 0x3d, 0x0a, 0x0c, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x69, 0x64, + 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, + 0x74, 0x49, 0x44, 0x52, 0x0b, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x64, 0x73, + 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x12, 0x40, + 0x0a, 0x0e, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x70, 0x6c, 0x61, 0x6e, 0x5f, 0x69, 0x64, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x52, 0x0c, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x50, 0x6c, 0x61, 0x6e, 0x49, 0x64, + 0x12, 0x4c, 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x34, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, + 0x6e, 0x74, 0x2e, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x4e, 0x6f, 0x64, + 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, + 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x1a, 0x39, + 0x0a, 0x0b, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, + 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, + 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xe4, 0x01, 0x0a, 0x17, 0x43, 0x6c, + 0x6f, 0x75, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x40, 0x0a, 0x09, 0x72, 0x61, 0x77, 0x5f, 0x65, 0x76, 0x65, + 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x45, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x08, 0x72, + 0x61, 0x77, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x4c, 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, + 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x45, + 0x76, 0x65, 0x6e, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x6c, + 0x61, 0x62, 0x65, 0x6c, 0x73, 0x1a, 0x39, 0x0a, 0x0b, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, + 0x22, 0xf3, 0x02, 0x0a, 0x18, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x45, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x72, 0x74, 0x12, 0x4e, 0x0a, + 0x0c, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x52, 0x0b, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x40, 0x0a, + 0x0e, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x70, 0x6c, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x52, 0x0c, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x50, 0x6c, 0x61, 0x6e, 0x49, 0x64, 0x12, + 0x3b, 0x0a, 0x0b, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x69, 0x64, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x52, 0x0a, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x49, 0x64, 0x12, 0x3d, 0x0a, 0x0c, + 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x04, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x44, 0x52, 0x0b, + 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x49, 0x64, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x61, + 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x72, 0x73, + 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x10, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, + 0x54, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x72, 0x69, 0x6e, + 0x63, 0x69, 0x70, 0x61, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, 0x72, 0x69, + 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x42, 0xb9, 0x01, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x42, 0x10, + 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, + 0x50, 0x01, 0x5a, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, + 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0xa2, 0x02, 0x03, 0x46, 0x45, 0x58, 0xaa, 0x02, 0x0f, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0xca, + 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x45, 0x76, 0x65, 0x6e, + 0x74, 0xe2, 0x02, 0x1b, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x45, 0x76, + 0x65, 0x6e, 0x74, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, + 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x45, 0x76, 0x65, + 0x6e, 0x74, 0x4a, 0xd5, 0x17, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x4e, 0x01, 0x0a, 0x08, 0x0a, + 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, + 0x18, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x2a, 0x0a, 0x09, 0x0a, 0x02, + 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x29, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, + 0x00, 0x28, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x03, 0x12, 0x03, 0x07, 0x00, 0x25, 0x0a, 0x08, 0x0a, + 0x01, 0x08, 0x12, 0x03, 0x09, 0x00, 0x4a, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x09, + 0x00, 0x4a, 0x0a, 0xb1, 0x01, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0d, 0x00, 0x1f, 0x01, 0x1a, + 0xa4, 0x01, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, + 0x6c, 0x6f, 0x75, 0x64, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6c, + 0x6c, 0x65, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x77, 0x20, 0x57, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x45, 0x76, 0x65, 0x6e, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x20, 0x49, + 0x74, 0x27, 0x73, 0x20, 0x66, 0x69, 0x6c, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x20, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x0a, 0x20, 0x69, + 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x64, 0x6f, 0x77, 0x6e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x75, + 0x6d, 0x65, 0x72, 0x73, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x66, 0x69, 0x6e, 0x64, 0x20, 0x75, 0x73, + 0x65, 0x66, 0x75, 0x6c, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0d, + 0x08, 0x23, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0e, 0x02, 0x2d, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x0e, 0x02, 0x1e, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0e, 0x1f, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0e, 0x2b, 0x2c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x01, 0x12, 0x03, 0x10, 0x02, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, + 0x03, 0x10, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x10, + 0x16, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x10, 0x29, 0x2a, + 0x0a, 0x86, 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x14, 0x02, 0x2c, 0x1a, 0x79, + 0x20, 0x54, 0x68, 0x65, 0x20, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x61, + 0x72, 0x65, 0x20, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x0a, 0x20, 0x57, 0x65, 0x20, + 0x63, 0x61, 0x6e, 0x27, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x45, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6c, 0x79, + 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x6d, 0x70, 0x6f, + 0x72, 0x74, 0x20, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x02, 0x04, 0x12, 0x03, 0x14, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, + 0x12, 0x03, 0x14, 0x0b, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x14, 0x1b, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x14, 0x2a, + 0x2b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x15, 0x02, 0x3b, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x06, 0x12, 0x03, 0x15, 0x02, 0x22, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x15, 0x23, 0x36, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x03, 0x03, 0x12, 0x03, 0x15, 0x39, 0x3a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x04, + 0x12, 0x03, 0x16, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x05, 0x12, 0x03, + 0x16, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x16, 0x09, + 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, 0x16, 0x15, 0x16, 0x0a, + 0xcd, 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x1b, 0x02, 0x25, 0x1a, 0xbf, 0x01, + 0x20, 0x54, 0x68, 0x65, 0x20, 0x49, 0x44, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4c, + 0x50, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x2e, 0x0a, 0x20, 0x48, 0x65, 0x72, + 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, + 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x4c, + 0x61, 0x75, 0x6e, 0x63, 0x68, 0x20, 0x70, 0x6c, 0x61, 0x6e, 0x20, 0x49, 0x44, 0x73, 0x20, 0x61, + 0x72, 0x65, 0x20, 0x65, 0x61, 0x73, 0x69, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x67, 0x65, 0x74, + 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x20, 0x49, + 0x44, 0x73, 0x20, 0x73, 0x6f, 0x20, 0x77, 0x65, 0x27, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x73, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x77, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x06, 0x12, 0x03, 0x1b, 0x02, 0x11, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x1b, 0x12, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x05, 0x03, 0x12, 0x03, 0x1b, 0x23, 0x24, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x06, 0x12, 0x03, 0x1e, 0x02, 0x21, 0x1a, 0x4d, 0x20, 0x57, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x27, + 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x45, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x6f, 0x62, 0x6a, + 0x65, 0x63, 0x74, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x62, 0x65, 0x63, + 0x61, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x63, + 0x79, 0x63, 0x6c, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x06, 0x12, 0x03, + 0x1e, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x1e, 0x16, + 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x03, 0x12, 0x03, 0x1e, 0x1f, 0x20, 0x0a, + 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x21, 0x00, 0x36, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x01, 0x01, 0x12, 0x03, 0x21, 0x08, 0x1f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, + 0x03, 0x22, 0x02, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x22, + 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x22, 0x1b, 0x24, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x22, 0x27, 0x28, 0x0a, 0x38, + 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x25, 0x02, 0x30, 0x1a, 0x2b, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x72, 0x65, 0x6c, 0x65, 0x76, 0x61, 0x6e, 0x74, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x66, 0x20, 0x61, 0x70, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, + 0x06, 0x12, 0x03, 0x25, 0x02, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x25, 0x1f, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x25, + 0x2e, 0x2f, 0x0a, 0x48, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x28, 0x02, 0x2b, 0x1a, + 0x3b, 0x20, 0x54, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, + 0x72, 0x66, 0x61, 0x63, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, + 0x73, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x64, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x02, 0x06, 0x12, 0x03, 0x28, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x28, 0x16, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, + 0x03, 0x12, 0x03, 0x28, 0x29, 0x2a, 0x0a, 0x86, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x03, 0x12, + 0x03, 0x2c, 0x02, 0x2c, 0x1a, 0x79, 0x20, 0x54, 0x68, 0x65, 0x20, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, + 0x77, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x72, 0x65, 0x20, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x73, 0x0a, 0x20, 0x57, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x27, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x64, 0x69, + 0x72, 0x65, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x04, 0x12, 0x03, 0x2c, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x03, 0x06, 0x12, 0x03, 0x2c, 0x0b, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x03, 0x01, 0x12, 0x03, 0x2c, 0x1b, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x03, 0x03, 0x12, 0x03, 0x2c, 0x2a, 0x2b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x04, 0x12, + 0x03, 0x2d, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x05, 0x12, 0x03, 0x2d, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x01, 0x12, 0x03, 0x2d, 0x09, 0x12, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x03, 0x12, 0x03, 0x2d, 0x15, 0x16, 0x0a, 0xcd, + 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x05, 0x12, 0x03, 0x32, 0x02, 0x25, 0x1a, 0xbf, 0x01, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x49, 0x44, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4c, 0x50, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x2e, 0x0a, 0x20, 0x48, 0x65, 0x72, 0x65, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x20, + 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x4c, 0x61, + 0x75, 0x6e, 0x63, 0x68, 0x20, 0x70, 0x6c, 0x61, 0x6e, 0x20, 0x49, 0x44, 0x73, 0x20, 0x61, 0x72, + 0x65, 0x20, 0x65, 0x61, 0x73, 0x69, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x67, 0x65, 0x74, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x20, 0x49, 0x44, + 0x73, 0x20, 0x73, 0x6f, 0x20, 0x77, 0x65, 0x27, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x73, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x77, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x06, 0x12, 0x03, 0x32, 0x02, 0x11, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x05, 0x01, 0x12, 0x03, 0x32, 0x12, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x05, 0x03, 0x12, 0x03, 0x32, 0x23, 0x24, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x06, + 0x12, 0x03, 0x35, 0x02, 0x21, 0x1a, 0x4d, 0x20, 0x57, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x27, 0x74, + 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x6f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x62, 0x65, 0x63, 0x61, + 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x63, 0x79, + 0x63, 0x6c, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x06, 0x12, 0x03, 0x35, + 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x01, 0x12, 0x03, 0x35, 0x16, 0x1c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x03, 0x12, 0x03, 0x35, 0x1f, 0x20, 0x0a, 0x0a, + 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x38, 0x00, 0x3c, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, + 0x01, 0x12, 0x03, 0x38, 0x08, 0x1f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, + 0x39, 0x02, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, 0x03, 0x39, 0x02, + 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x39, 0x1b, 0x24, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x39, 0x27, 0x28, 0x0a, 0x5a, 0x0a, + 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x3b, 0x02, 0x21, 0x1a, 0x4d, 0x20, 0x57, 0x65, 0x20, + 0x63, 0x61, 0x6e, 0x27, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x45, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6c, 0x79, + 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x6d, 0x70, 0x6f, + 0x72, 0x74, 0x20, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x01, 0x06, 0x12, 0x03, 0x3b, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x3b, 0x16, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x3b, 0x1f, 0x20, 0x0a, 0x4e, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x3f, 0x00, 0x4e, 0x01, 0x1a, + 0x42, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x73, 0x20, + 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x79, 0x20, 0x41, 0x64, + 0x6d, 0x69, 0x6e, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x69, 0x74, 0x20, 0x63, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x3f, 0x08, 0x20, 0x0a, + 0x25, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x41, 0x02, 0x34, 0x1a, 0x18, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x41, 0x02, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x41, + 0x23, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x41, 0x32, 0x33, + 0x0a, 0x24, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, 0x43, 0x02, 0x25, 0x1a, 0x17, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x20, 0x70, 0x6c, 0x61, 0x6e, 0x20, + 0x75, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x06, 0x12, + 0x03, 0x43, 0x02, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, 0x43, + 0x12, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x43, 0x23, 0x24, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x02, 0x12, 0x03, 0x45, 0x02, 0x22, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x02, 0x06, 0x12, 0x03, 0x45, 0x02, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x02, 0x01, 0x12, 0x03, 0x45, 0x12, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x02, 0x03, 0x12, 0x03, 0x45, 0x20, 0x21, 0x0a, 0x9f, 0x01, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x03, + 0x12, 0x03, 0x48, 0x02, 0x2c, 0x1a, 0x91, 0x01, 0x20, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, + 0x74, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x77, 0x65, 0x20, + 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x6c, 0x6c, 0x20, 0x41, 0x72, + 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x20, 0x49, 0x44, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x73, 0x65, + 0x20, 0x61, 0x72, 0x65, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, + 0x63, 0x74, 0x20, 0x71, 0x75, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x61, 0x72, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x03, 0x04, 0x12, 0x03, 0x48, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x06, + 0x12, 0x03, 0x48, 0x0b, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x01, 0x12, 0x03, + 0x48, 0x1b, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x03, 0x12, 0x03, 0x48, 0x2a, + 0x2b, 0x0a, 0xa7, 0x01, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x04, 0x12, 0x03, 0x4b, 0x02, 0x28, 0x1a, + 0x99, 0x01, 0x20, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x20, 0x69, 0x6e, 0x70, 0x75, + 0x74, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x77, 0x65, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x68, + 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x69, 0x6e, 0x67, + 0x20, 0x62, 0x69, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x27, 0x73, 0x20, 0x69, 0x6e, 0x73, 0x74, + 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4c, + 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x27, 0x73, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, + 0x74, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x04, 0x04, 0x12, 0x03, 0x4b, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x04, 0x05, 0x12, 0x03, 0x4b, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x01, + 0x12, 0x03, 0x4b, 0x12, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x03, 0x12, 0x03, + 0x4b, 0x26, 0x27, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x05, 0x12, 0x03, 0x4d, 0x02, 0x17, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x05, 0x12, 0x03, 0x4d, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x01, 0x12, 0x03, 0x4d, 0x09, 0x12, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x05, 0x03, 0x12, 0x03, 0x4d, 0x15, 0x16, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x33, +]; +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/flyteidl2.imagebuilder.rs b/gen/rust/src/flyteidl2.imagebuilder.rs new file mode 100644 index 0000000000..e9072bd8ac --- /dev/null +++ b/gen/rust/src/flyteidl2.imagebuilder.rs @@ -0,0 +1,901 @@ +// @generated +// This file is @generated by prost-build. +/// ImageIdentifier is how to identify an image +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ImageIdentifier { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, +} +/// Simple container to surface if image exists +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Image { + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + /// Fully qualified, pullable, image name + #[prost(string, tag="2")] + pub fqin: ::prost::alloc::string::String, +} +/// AptPackages defines a list of apt packages to install in the image. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AptPackages { + /// List of apt packages to install + #[prost(string, repeated, tag="1")] + pub packages: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(message, repeated, tag="2")] + pub secret_mounts: ::prost::alloc::vec::Vec, +} +/// PipOptions defines options for pip packages to install in the image. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PipOptions { + /// Optional index URL for pip packages + #[prost(string, tag="2")] + pub index_url: ::prost::alloc::string::String, + /// Optional list of extra index URLs for pip packages + #[prost(string, repeated, tag="3")] + pub extra_index_urls: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Optional pre-release flag for pip packages + #[prost(bool, tag="4")] + pub pre: bool, + /// Optional extra arguments for pip install command + #[prost(string, tag="5")] + pub extra_args: ::prost::alloc::string::String, +} +/// PipPackages defines a list of pip packages to install in the image. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PipPackages { + /// List of pip packages to install + #[prost(string, repeated, tag="1")] + pub packages: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Options for pip packages. + #[prost(message, optional, tag="2")] + pub options: ::core::option::Option, + #[prost(message, repeated, tag="3")] + pub secret_mounts: ::prost::alloc::vec::Vec, +} +/// Requirements defines a python requirements file to use in the image. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Requirements { + /// The requirements file to use. + #[prost(string, tag="1")] + pub file: ::prost::alloc::string::String, + /// Options for pip packages. + #[prost(message, optional, tag="2")] + pub options: ::core::option::Option, + #[prost(message, repeated, tag="3")] + pub secret_mounts: ::prost::alloc::vec::Vec, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PythonWheels { + /// The directory containing Python wheel files. + #[prost(string, tag="1")] + pub dir: ::prost::alloc::string::String, + /// Options for pip packages. + #[prost(message, optional, tag="2")] + pub options: ::core::option::Option, + #[prost(message, repeated, tag="3")] + pub secret_mounts: ::prost::alloc::vec::Vec, +} +/// UVProject defines a UV project configuration, which includes +/// a pyproject.toml file and a uvlock file. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UvProject { + #[prost(string, tag="1")] + pub pyproject: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub uvlock: ::prost::alloc::string::String, + /// Options for pip packages. + #[prost(message, optional, tag="3")] + pub options: ::core::option::Option, + #[prost(message, repeated, tag="4")] + pub secret_mounts: ::prost::alloc::vec::Vec, +} +/// Commands defines a list of commands to run in the image. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Commands { + /// The command to run. + #[prost(string, repeated, tag="2")] + pub cmd: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(message, repeated, tag="3")] + pub secret_mounts: ::prost::alloc::vec::Vec, +} +/// WorkDir defines the working directory to set in the image. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorkDir { + /// The working directory to use. + #[prost(string, tag="1")] + pub workdir: ::prost::alloc::string::String, +} +/// CopyConfig defines a configuration for copying files/directories into the image. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CopyConfig { + /// The source directory to copy from. + #[prost(string, tag="1")] + pub src: ::prost::alloc::string::String, + /// The destination directory to copy to. + #[prost(string, tag="2")] + pub dst: ::prost::alloc::string::String, +} +/// Env defines environment to set in the image. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Env { + /// Environment variables to set in the image. + #[prost(map="string, string", tag="1")] + pub env_variables: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PoetryProject { + #[prost(string, tag="1")] + pub pyproject: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub poetry_lock: ::prost::alloc::string::String, + /// Optional extra arguments for poetry install command + #[prost(string, tag="3")] + pub extra_args: ::prost::alloc::string::String, + #[prost(message, repeated, tag="4")] + pub secret_mounts: ::prost::alloc::vec::Vec, +} +/// Layer defines a layer in the image, which can be one of several types. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Layer { + #[prost(oneof="layer::Layer", tags="1, 2, 3, 4, 5, 6, 7, 8, 9, 10")] + pub layer: ::core::option::Option, +} +/// Nested message and enum types in `Layer`. +pub mod layer { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Layer { + /// Apt packages to install. + #[prost(message, tag="1")] + AptPackages(super::AptPackages), + /// Python packages to install. + #[prost(message, tag="2")] + PipPackages(super::PipPackages), + /// Custom command to run. + #[prost(message, tag="3")] + Commands(super::Commands), + /// Requirements file to use. + #[prost(message, tag="4")] + Requirements(super::Requirements), + /// Python wheel file to use. + #[prost(message, tag="5")] + PythonWheels(super::PythonWheels), + /// Working directory to set. + #[prost(message, tag="6")] + Workdir(super::WorkDir), + /// Copy files/directories into the image. + #[prost(message, tag="7")] + CopyConfig(super::CopyConfig), + /// UV project configuration. + #[prost(message, tag="8")] + UvProject(super::UvProject), + /// Environment variables to set. + #[prost(message, tag="9")] + Env(super::Env), + /// Poetry project configuration + #[prost(message, tag="10")] + PoetryProject(super::PoetryProject), + } +} +/// Image definition defined in the sdk. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ImageSpec { + /// Identifier for the base image. + #[prost(string, tag="1")] + pub base_image: ::prost::alloc::string::String, + /// python version to use in the image. + #[prost(string, tag="2")] + pub python_version: ::prost::alloc::string::String, + /// List of layers to apply to the image. + #[prost(message, repeated, tag="3")] + pub layers: ::prost::alloc::vec::Vec, + /// List of platforms to build the image for. + #[prost(string, repeated, tag="4")] + pub platform: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetImageRequest { + /// Image ID + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + /// Optional organization that dictates which dataplane registry to reference + /// Deprecated, please use the full ProjectIdentifier instead + #[deprecated] + #[prost(string, tag="2")] + pub organization: ::prost::alloc::string::String, + /// The scope in which to look for the image. Images maybe accessible in different project-domain pairs through + /// different container registries (i.e. different image FQDNs) + /// TODO: This scope will be made required after updating all clients/servers to respect it. + #[prost(message, optional, tag="3")] + pub project_id: ::core::option::Option, +} +/// GetSecretProxyResponse returns the looked up secret from the secret service +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetImageResponse { + #[prost(message, optional, tag="1")] + pub image: ::core::option::Option, +} +/// Encoded file descriptor set for the `flyteidl2.imagebuilder` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xa1, 0x3f, 0x0a, 0x27, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x69, + 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2f, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x16, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, + 0x6c, 0x64, 0x65, 0x72, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, + 0x65, 0x2f, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x22, 0x2e, 0x0a, 0x0f, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x22, 0x54, 0x0a, 0x05, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x37, 0x0a, 0x02, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x49, + 0x6d, 0x61, 0x67, 0x65, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x02, + 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x71, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x66, 0x71, 0x69, 0x6e, 0x22, 0x66, 0x0a, 0x0b, 0x41, 0x70, 0x74, 0x50, 0x61, 0x63, + 0x6b, 0x61, 0x67, 0x65, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, + 0x73, 0x12, 0x3b, 0x0a, 0x0d, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, 0x6d, 0x6f, 0x75, 0x6e, + 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x52, 0x0c, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0x84, + 0x01, 0x0a, 0x0a, 0x50, 0x69, 0x70, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1b, 0x0a, + 0x09, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x55, 0x72, 0x6c, 0x12, 0x28, 0x0a, 0x10, 0x65, 0x78, + 0x74, 0x72, 0x61, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x75, 0x72, 0x6c, 0x73, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x65, 0x78, 0x74, 0x72, 0x61, 0x49, 0x6e, 0x64, 0x65, 0x78, + 0x55, 0x72, 0x6c, 0x73, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x72, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x03, 0x70, 0x72, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x65, 0x78, 0x74, 0x72, 0x61, 0x5f, + 0x61, 0x72, 0x67, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x65, 0x78, 0x74, 0x72, + 0x61, 0x41, 0x72, 0x67, 0x73, 0x22, 0xa4, 0x01, 0x0a, 0x0b, 0x50, 0x69, 0x70, 0x50, 0x61, 0x63, + 0x6b, 0x61, 0x67, 0x65, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, + 0x73, 0x12, 0x3c, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, + 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x50, 0x69, 0x70, 0x4f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, + 0x3b, 0x0a, 0x0d, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, + 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x0c, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0x9d, 0x01, 0x0a, + 0x0c, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x12, 0x0a, + 0x04, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x66, 0x69, 0x6c, + 0x65, 0x12, 0x3c, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, + 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x50, 0x69, 0x70, 0x4f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, + 0x3b, 0x0a, 0x0d, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, + 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x0c, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0x9b, 0x01, 0x0a, + 0x0c, 0x50, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x57, 0x68, 0x65, 0x65, 0x6c, 0x73, 0x12, 0x10, 0x0a, + 0x03, 0x64, 0x69, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x64, 0x69, 0x72, 0x12, + 0x3c, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, + 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x50, 0x69, 0x70, 0x4f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3b, 0x0a, + 0x0d, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x0c, 0x73, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0xbc, 0x01, 0x0a, 0x09, 0x55, + 0x56, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x79, 0x70, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, 0x79, 0x70, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x75, 0x76, 0x6c, 0x6f, 0x63, 0x6b, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x75, 0x76, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x3c, + 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x50, 0x69, 0x70, 0x4f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3b, 0x0a, 0x0d, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x0c, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0x59, 0x0a, 0x08, 0x43, 0x6f, 0x6d, + 0x6d, 0x61, 0x6e, 0x64, 0x73, 0x12, 0x10, 0x0a, 0x03, 0x63, 0x6d, 0x64, 0x18, 0x02, 0x20, 0x03, + 0x28, 0x09, 0x52, 0x03, 0x63, 0x6d, 0x64, 0x12, 0x3b, 0x0a, 0x0d, 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x5f, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x0c, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4d, 0x6f, + 0x75, 0x6e, 0x74, 0x73, 0x22, 0x23, 0x0a, 0x07, 0x57, 0x6f, 0x72, 0x6b, 0x44, 0x69, 0x72, 0x12, + 0x18, 0x0a, 0x07, 0x77, 0x6f, 0x72, 0x6b, 0x64, 0x69, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x07, 0x77, 0x6f, 0x72, 0x6b, 0x64, 0x69, 0x72, 0x22, 0x30, 0x0a, 0x0a, 0x43, 0x6f, 0x70, + 0x79, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x10, 0x0a, 0x03, 0x73, 0x72, 0x63, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x73, 0x72, 0x63, 0x12, 0x10, 0x0a, 0x03, 0x64, 0x73, 0x74, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x64, 0x73, 0x74, 0x22, 0x9a, 0x01, 0x0a, 0x03, + 0x45, 0x6e, 0x76, 0x12, 0x52, 0x0a, 0x0d, 0x65, 0x6e, 0x76, 0x5f, 0x76, 0x61, 0x72, 0x69, 0x61, + 0x62, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, + 0x64, 0x65, 0x72, 0x2e, 0x45, 0x6e, 0x76, 0x2e, 0x45, 0x6e, 0x76, 0x56, 0x61, 0x72, 0x69, 0x61, + 0x62, 0x6c, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x65, 0x6e, 0x76, 0x56, 0x61, + 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x1a, 0x3f, 0x0a, 0x11, 0x45, 0x6e, 0x76, 0x56, 0x61, + 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xaa, 0x01, 0x0a, 0x0d, 0x50, 0x6f, 0x65, + 0x74, 0x72, 0x79, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x79, + 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, + 0x79, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x6f, 0x65, 0x74, + 0x72, 0x79, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, + 0x6f, 0x65, 0x74, 0x72, 0x79, 0x4c, 0x6f, 0x63, 0x6b, 0x12, 0x1d, 0x0a, 0x0a, 0x65, 0x78, 0x74, + 0x72, 0x61, 0x5f, 0x61, 0x72, 0x67, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x65, + 0x78, 0x74, 0x72, 0x61, 0x41, 0x72, 0x67, 0x73, 0x12, 0x3b, 0x0a, 0x0d, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x5f, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x0c, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4d, + 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0xc6, 0x05, 0x0a, 0x05, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x12, + 0x48, 0x0a, 0x0c, 0x61, 0x70, 0x74, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x41, + 0x70, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x48, 0x00, 0x52, 0x0b, 0x61, 0x70, + 0x74, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x12, 0x48, 0x0a, 0x0c, 0x70, 0x69, 0x70, + 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x50, 0x69, 0x70, 0x50, 0x61, 0x63, 0x6b, + 0x61, 0x67, 0x65, 0x73, 0x48, 0x00, 0x52, 0x0b, 0x70, 0x69, 0x70, 0x50, 0x61, 0x63, 0x6b, 0x61, + 0x67, 0x65, 0x73, 0x12, 0x3e, 0x0a, 0x08, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x73, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x43, + 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x73, 0x48, 0x00, 0x52, 0x08, 0x63, 0x6f, 0x6d, 0x6d, 0x61, + 0x6e, 0x64, 0x73, 0x12, 0x4a, 0x0a, 0x0c, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, + 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, + 0x65, 0x72, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x48, + 0x00, 0x52, 0x0c, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, + 0x4b, 0x0a, 0x0d, 0x70, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x5f, 0x77, 0x68, 0x65, 0x65, 0x6c, 0x73, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, + 0x50, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x57, 0x68, 0x65, 0x65, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x0c, + 0x70, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x57, 0x68, 0x65, 0x65, 0x6c, 0x73, 0x12, 0x3b, 0x0a, 0x07, + 0x77, 0x6f, 0x72, 0x6b, 0x64, 0x69, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, + 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x44, 0x69, 0x72, 0x48, 0x00, + 0x52, 0x07, 0x77, 0x6f, 0x72, 0x6b, 0x64, 0x69, 0x72, 0x12, 0x45, 0x0a, 0x0b, 0x63, 0x6f, 0x70, + 0x79, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, + 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x43, 0x6f, 0x70, 0x79, 0x43, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x48, 0x00, 0x52, 0x0a, 0x63, 0x6f, 0x70, 0x79, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 0x12, 0x42, 0x0a, 0x0a, 0x75, 0x76, 0x5f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x55, 0x56, + 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x48, 0x00, 0x52, 0x09, 0x75, 0x76, 0x50, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x12, 0x2f, 0x0a, 0x03, 0x65, 0x6e, 0x76, 0x18, 0x09, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, + 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x45, 0x6e, 0x76, 0x48, 0x00, + 0x52, 0x03, 0x65, 0x6e, 0x76, 0x12, 0x4e, 0x0a, 0x0e, 0x70, 0x6f, 0x65, 0x74, 0x72, 0x79, 0x5f, + 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, + 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x50, 0x6f, 0x65, 0x74, 0x72, 0x79, 0x50, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x48, 0x00, 0x52, 0x0d, 0x70, 0x6f, 0x65, 0x74, 0x72, 0x79, 0x50, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x42, 0x07, 0x0a, 0x05, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x22, 0xa4, + 0x01, 0x0a, 0x09, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1d, 0x0a, 0x0a, + 0x62, 0x61, 0x73, 0x65, 0x5f, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x62, 0x61, 0x73, 0x65, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x70, + 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0d, 0x70, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x56, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x12, 0x35, 0x0a, 0x06, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x18, 0x03, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, + 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x4c, 0x61, 0x79, 0x65, + 0x72, 0x52, 0x06, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x42, 0xe2, 0x01, 0x0a, 0x1a, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, + 0x6c, 0x64, 0x65, 0x72, 0x42, 0x0f, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, + 0x64, 0x65, 0x72, 0xa2, 0x02, 0x03, 0x46, 0x49, 0x58, 0xaa, 0x02, 0x16, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, + 0x65, 0x72, 0xca, 0x02, 0x16, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x49, + 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0xe2, 0x02, 0x22, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, + 0x6c, 0x64, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0xea, 0x02, 0x17, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x49, 0x6d, + 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x4a, 0xaf, 0x29, 0x0a, 0x07, 0x12, + 0x05, 0x00, 0x00, 0x93, 0x01, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, + 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x1f, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, + 0x12, 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x27, + 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x07, 0x00, 0x51, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, + 0x12, 0x03, 0x07, 0x00, 0x51, 0x0a, 0x39, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0a, 0x00, 0x0c, + 0x01, 0x1a, 0x2d, 0x20, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x79, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0a, 0x08, 0x17, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0b, 0x02, 0x3c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x0b, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x0b, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x0b, 0x10, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x08, 0x12, 0x03, 0x0b, 0x12, + 0x3b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, + 0x0b, 0x13, 0x3a, 0x0a, 0x39, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x0f, 0x00, 0x13, 0x01, 0x1a, + 0x2d, 0x20, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x75, 0x72, 0x66, 0x61, 0x63, 0x65, 0x20, 0x69, 0x66, + 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x0a, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x0f, 0x08, 0x0d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x00, 0x12, 0x03, 0x10, 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x10, 0x02, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x10, 0x12, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x10, 0x17, + 0x18, 0x0a, 0x34, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x12, 0x02, 0x12, 0x1a, 0x27, + 0x20, 0x46, 0x75, 0x6c, 0x6c, 0x79, 0x20, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x2c, 0x20, 0x70, 0x75, 0x6c, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x20, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, + 0x12, 0x03, 0x12, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x12, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x12, 0x10, + 0x11, 0x0a, 0x51, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x16, 0x00, 0x1a, 0x01, 0x1a, 0x45, 0x20, + 0x41, 0x70, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x70, + 0x74, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, + 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6d, 0x61, + 0x67, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x16, 0x08, 0x13, + 0x0a, 0x2e, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x18, 0x02, 0x1f, 0x1a, 0x21, 0x20, + 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x70, 0x74, 0x20, 0x70, 0x61, 0x63, 0x6b, + 0x61, 0x67, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x04, 0x12, 0x03, 0x18, 0x02, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, 0x18, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x18, 0x12, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x18, 0x1d, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x19, 0x02, 0x33, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x04, 0x12, 0x03, + 0x19, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, 0x03, 0x19, 0x0b, + 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x19, 0x21, 0x2e, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x19, 0x31, 0x32, 0x0a, 0x52, 0x0a, + 0x02, 0x04, 0x03, 0x12, 0x04, 0x1d, 0x00, 0x26, 0x01, 0x1a, 0x46, 0x20, 0x50, 0x69, 0x70, 0x4f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x6f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x69, 0x70, 0x20, 0x70, + 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, + 0x6c, 0x6c, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2e, + 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x1d, 0x08, 0x12, 0x0a, 0x32, 0x0a, + 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x1f, 0x02, 0x17, 0x1a, 0x25, 0x20, 0x4f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x55, 0x52, 0x4c, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x70, 0x69, 0x70, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x05, 0x12, 0x03, 0x1f, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1f, 0x09, 0x12, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1f, 0x15, 0x16, 0x0a, 0x41, 0x0a, 0x04, 0x04, + 0x03, 0x02, 0x01, 0x12, 0x03, 0x21, 0x02, 0x27, 0x1a, 0x34, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x61, 0x6c, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x65, 0x78, 0x74, 0x72, + 0x61, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x55, 0x52, 0x4c, 0x73, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x70, 0x69, 0x70, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x04, 0x12, 0x03, 0x21, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x01, 0x05, 0x12, 0x03, 0x21, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x21, 0x12, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x21, 0x25, 0x26, 0x0a, 0x39, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x02, 0x12, 0x03, + 0x23, 0x02, 0x0f, 0x1a, 0x2c, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x70, + 0x72, 0x65, 0x2d, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x66, 0x6c, 0x61, 0x67, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x70, 0x69, 0x70, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x05, 0x12, 0x03, 0x23, 0x02, 0x06, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x01, 0x12, 0x03, 0x23, 0x07, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x02, 0x03, 0x12, 0x03, 0x23, 0x0d, 0x0e, 0x0a, 0x3f, 0x0a, 0x04, 0x04, + 0x03, 0x02, 0x03, 0x12, 0x03, 0x25, 0x02, 0x18, 0x1a, 0x32, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x61, 0x6c, 0x20, 0x65, 0x78, 0x74, 0x72, 0x61, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, + 0x6e, 0x74, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x69, 0x70, 0x20, 0x69, 0x6e, 0x73, 0x74, + 0x61, 0x6c, 0x6c, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x03, 0x05, 0x12, 0x03, 0x25, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x03, 0x01, 0x12, 0x03, 0x25, 0x09, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, + 0x03, 0x12, 0x03, 0x25, 0x16, 0x17, 0x0a, 0x51, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x29, 0x00, + 0x2f, 0x01, 0x1a, 0x45, 0x20, 0x50, 0x69, 0x70, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, + 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, + 0x6f, 0x66, 0x20, 0x70, 0x69, 0x70, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x20, + 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, + 0x12, 0x03, 0x29, 0x08, 0x13, 0x0a, 0x2e, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x2b, + 0x02, 0x1f, 0x1a, 0x21, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x70, 0x69, 0x70, + 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x73, + 0x74, 0x61, 0x6c, 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x04, 0x12, 0x03, + 0x2b, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x05, 0x12, 0x03, 0x2b, 0x0b, + 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2b, 0x12, 0x1a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x2b, 0x1d, 0x1e, 0x0a, 0x28, 0x0a, + 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x2d, 0x02, 0x19, 0x1a, 0x1b, 0x20, 0x4f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x69, 0x70, 0x20, 0x70, 0x61, 0x63, + 0x6b, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x06, + 0x12, 0x03, 0x2d, 0x02, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x2d, 0x0d, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x2d, 0x17, + 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x02, 0x12, 0x03, 0x2e, 0x02, 0x33, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x04, 0x12, 0x03, 0x2e, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x02, 0x06, 0x12, 0x03, 0x2e, 0x0b, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x2e, 0x21, 0x2e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, + 0x03, 0x12, 0x03, 0x2e, 0x31, 0x32, 0x0a, 0x52, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x32, 0x00, + 0x38, 0x01, 0x1a, 0x46, 0x20, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, + 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x61, 0x20, 0x70, 0x79, 0x74, 0x68, + 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, + 0x66, 0x69, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, + 0x01, 0x12, 0x03, 0x32, 0x08, 0x14, 0x0a, 0x2c, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, + 0x34, 0x02, 0x12, 0x1a, 0x1f, 0x20, 0x54, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, + 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x75, + 0x73, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x05, 0x12, 0x03, 0x34, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x34, 0x09, 0x0d, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x34, 0x10, 0x11, 0x0a, 0x28, + 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x03, 0x36, 0x02, 0x19, 0x1a, 0x1b, 0x20, 0x4f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x69, 0x70, 0x20, 0x70, 0x61, + 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, + 0x06, 0x12, 0x03, 0x36, 0x02, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x36, 0x0d, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x03, 0x36, + 0x17, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x02, 0x12, 0x03, 0x37, 0x02, 0x33, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x04, 0x12, 0x03, 0x37, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x02, 0x06, 0x12, 0x03, 0x37, 0x0b, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x02, 0x01, 0x12, 0x03, 0x37, 0x21, 0x2e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x02, 0x03, 0x12, 0x03, 0x37, 0x31, 0x32, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x04, 0x3a, + 0x00, 0x40, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x03, 0x3a, 0x08, 0x14, 0x0a, + 0x3b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x03, 0x3c, 0x02, 0x11, 0x1a, 0x2e, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x50, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x20, 0x77, + 0x68, 0x65, 0x65, 0x6c, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x00, 0x05, 0x12, 0x03, 0x3c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x3c, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x3c, 0x0f, 0x10, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x01, 0x12, 0x03, + 0x3e, 0x02, 0x19, 0x1a, 0x1b, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x70, 0x69, 0x70, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x06, 0x12, 0x03, 0x3e, 0x02, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x01, 0x12, 0x03, 0x3e, 0x0d, 0x14, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x01, 0x03, 0x12, 0x03, 0x3e, 0x17, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, + 0x02, 0x02, 0x12, 0x03, 0x3f, 0x02, 0x33, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x04, + 0x12, 0x03, 0x3f, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x06, 0x12, 0x03, + 0x3f, 0x0b, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x01, 0x12, 0x03, 0x3f, 0x21, + 0x2e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x03, 0x12, 0x03, 0x3f, 0x31, 0x32, 0x0a, + 0x74, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x04, 0x44, 0x00, 0x4a, 0x01, 0x1a, 0x68, 0x20, 0x55, 0x56, + 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, + 0x61, 0x20, 0x55, 0x56, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x63, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x77, 0x68, 0x69, 0x63, + 0x68, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x0a, 0x20, 0x61, 0x20, 0x70, 0x79, + 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x74, 0x6f, 0x6d, 0x6c, 0x20, 0x66, 0x69, 0x6c, + 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x20, 0x75, 0x76, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x66, + 0x69, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x03, 0x44, 0x08, + 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x03, 0x45, 0x02, 0x17, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x05, 0x12, 0x03, 0x45, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x00, 0x01, 0x12, 0x03, 0x45, 0x09, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x45, 0x15, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x01, + 0x12, 0x03, 0x46, 0x02, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x05, 0x12, 0x03, + 0x46, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x01, 0x12, 0x03, 0x46, 0x09, + 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, 0x03, 0x46, 0x12, 0x13, 0x0a, + 0x28, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x02, 0x12, 0x03, 0x48, 0x02, 0x19, 0x1a, 0x1b, 0x20, 0x4f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x69, 0x70, 0x20, 0x70, + 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x02, 0x06, 0x12, 0x03, 0x48, 0x02, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x48, 0x0d, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x03, 0x12, 0x03, + 0x48, 0x17, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x03, 0x12, 0x03, 0x49, 0x02, 0x33, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x03, 0x04, 0x12, 0x03, 0x49, 0x02, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x03, 0x06, 0x12, 0x03, 0x49, 0x0b, 0x20, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x03, 0x01, 0x12, 0x03, 0x49, 0x21, 0x2e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x03, 0x03, 0x12, 0x03, 0x49, 0x31, 0x32, 0x0a, 0x46, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x04, + 0x4d, 0x00, 0x51, 0x01, 0x1a, 0x3a, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x73, 0x20, + 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, + 0x66, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x75, + 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2e, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x08, 0x01, 0x12, 0x03, 0x4d, 0x08, 0x10, 0x0a, 0x22, 0x0a, 0x04, + 0x04, 0x08, 0x02, 0x00, 0x12, 0x03, 0x4f, 0x02, 0x1a, 0x1a, 0x15, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x04, 0x12, 0x03, 0x4f, 0x02, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x05, 0x12, 0x03, 0x4f, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x03, 0x4f, 0x12, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x4f, 0x18, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x01, + 0x12, 0x03, 0x50, 0x02, 0x33, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x04, 0x12, 0x03, + 0x50, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x06, 0x12, 0x03, 0x50, 0x0b, + 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x01, 0x12, 0x03, 0x50, 0x21, 0x2e, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x03, 0x12, 0x03, 0x50, 0x31, 0x32, 0x0a, 0x48, 0x0a, + 0x02, 0x04, 0x09, 0x12, 0x04, 0x54, 0x00, 0x57, 0x01, 0x1a, 0x3c, 0x20, 0x57, 0x6f, 0x72, 0x6b, + 0x44, 0x69, 0x72, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x77, 0x6f, 0x72, 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, + 0x79, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x65, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, 0x03, + 0x54, 0x08, 0x0f, 0x0a, 0x2c, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x00, 0x12, 0x03, 0x56, 0x02, 0x15, + 0x1a, 0x1f, 0x20, 0x54, 0x68, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x64, + 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x05, 0x12, 0x03, 0x56, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x03, 0x56, 0x09, 0x10, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, 0x03, 0x56, 0x13, 0x14, 0x0a, 0x5e, 0x0a, 0x02, 0x04, + 0x0a, 0x12, 0x04, 0x5a, 0x00, 0x5f, 0x01, 0x1a, 0x52, 0x20, 0x43, 0x6f, 0x70, 0x79, 0x43, 0x6f, + 0x6e, 0x66, 0x69, 0x67, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x61, 0x20, 0x63, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x63, 0x6f, 0x70, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x2f, 0x64, + 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x0a, 0x01, 0x12, 0x03, 0x5a, 0x08, 0x12, 0x0a, 0x31, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x00, 0x12, + 0x03, 0x5c, 0x02, 0x11, 0x1a, 0x24, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x63, + 0x6f, 0x70, 0x79, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, + 0x02, 0x00, 0x05, 0x12, 0x03, 0x5c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x5c, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x5c, 0x0f, 0x10, 0x0a, 0x34, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x01, 0x12, 0x03, 0x5e, 0x02, + 0x11, 0x1a, 0x27, 0x20, 0x54, 0x68, 0x65, 0x20, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x74, 0x6f, + 0x20, 0x63, 0x6f, 0x70, 0x79, 0x20, 0x74, 0x6f, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, + 0x02, 0x01, 0x05, 0x12, 0x03, 0x5e, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x5e, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x5e, 0x0f, 0x10, 0x0a, 0x3a, 0x0a, 0x02, 0x04, 0x0b, 0x12, 0x04, 0x62, 0x00, 0x65, 0x01, + 0x1a, 0x2e, 0x20, 0x45, 0x6e, 0x76, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x65, + 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x65, + 0x74, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2e, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x0b, 0x01, 0x12, 0x03, 0x62, 0x08, 0x0b, 0x0a, 0x39, 0x0a, 0x04, + 0x04, 0x0b, 0x02, 0x00, 0x12, 0x03, 0x64, 0x02, 0x28, 0x1a, 0x2c, 0x20, 0x45, 0x6e, 0x76, 0x69, + 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, + 0x73, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x65, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x64, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x64, 0x16, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x03, 0x12, 0x03, 0x64, 0x26, + 0x27, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x0c, 0x12, 0x04, 0x67, 0x00, 0x6d, 0x01, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x0c, 0x01, 0x12, 0x03, 0x67, 0x08, 0x15, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x0c, 0x02, + 0x00, 0x12, 0x03, 0x68, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x05, 0x12, + 0x03, 0x68, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x01, 0x12, 0x03, 0x68, + 0x09, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x03, 0x12, 0x03, 0x68, 0x15, 0x16, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x01, 0x12, 0x03, 0x69, 0x02, 0x19, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x0c, 0x02, 0x01, 0x05, 0x12, 0x03, 0x69, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x0c, 0x02, 0x01, 0x01, 0x12, 0x03, 0x69, 0x09, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, + 0x01, 0x03, 0x12, 0x03, 0x69, 0x17, 0x18, 0x0a, 0x42, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x02, 0x12, + 0x03, 0x6b, 0x02, 0x18, 0x1a, 0x35, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, + 0x65, 0x78, 0x74, 0x72, 0x61, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x70, 0x6f, 0x65, 0x74, 0x72, 0x79, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, + 0x6c, 0x6c, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x0c, 0x02, 0x02, 0x05, 0x12, 0x03, 0x6b, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x6b, 0x09, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x6b, 0x16, 0x17, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x03, 0x12, 0x03, 0x6c, + 0x02, 0x33, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x03, 0x04, 0x12, 0x03, 0x6c, 0x02, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x03, 0x06, 0x12, 0x03, 0x6c, 0x0b, 0x20, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x03, 0x01, 0x12, 0x03, 0x6c, 0x21, 0x2e, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x0c, 0x02, 0x03, 0x03, 0x12, 0x03, 0x6c, 0x31, 0x32, 0x0a, 0x55, 0x0a, 0x02, 0x04, 0x0d, + 0x12, 0x05, 0x70, 0x00, 0x87, 0x01, 0x01, 0x1a, 0x48, 0x20, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x20, + 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x20, + 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2c, 0x20, 0x77, 0x68, + 0x69, 0x63, 0x68, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x73, 0x65, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, + 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x0d, 0x01, 0x12, 0x03, 0x70, 0x08, 0x0d, 0x0a, 0x0d, 0x0a, + 0x04, 0x04, 0x0d, 0x08, 0x00, 0x12, 0x05, 0x71, 0x02, 0x86, 0x01, 0x03, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x0d, 0x08, 0x00, 0x01, 0x12, 0x03, 0x71, 0x08, 0x0d, 0x0a, 0x27, 0x0a, 0x04, 0x04, 0x0d, + 0x02, 0x00, 0x12, 0x03, 0x73, 0x04, 0x21, 0x1a, 0x1a, 0x20, 0x41, 0x70, 0x74, 0x20, 0x70, 0x61, + 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, + 0x6c, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x06, 0x12, 0x03, 0x73, 0x04, + 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x01, 0x12, 0x03, 0x73, 0x10, 0x1c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x03, 0x12, 0x03, 0x73, 0x1f, 0x20, 0x0a, 0x2a, 0x0a, + 0x04, 0x04, 0x0d, 0x02, 0x01, 0x12, 0x03, 0x75, 0x04, 0x21, 0x1a, 0x1d, 0x20, 0x50, 0x79, 0x74, + 0x68, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, + 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, + 0x01, 0x06, 0x12, 0x03, 0x75, 0x04, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x75, 0x10, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x75, 0x1f, 0x20, 0x0a, 0x25, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x02, 0x12, 0x03, 0x77, 0x04, 0x1a, + 0x1a, 0x18, 0x20, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, + 0x64, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, + 0x02, 0x02, 0x06, 0x12, 0x03, 0x77, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x02, + 0x01, 0x12, 0x03, 0x77, 0x0d, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x02, 0x03, 0x12, + 0x03, 0x77, 0x18, 0x19, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x03, 0x12, 0x03, 0x79, 0x04, + 0x22, 0x1a, 0x1b, 0x20, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, + 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x03, 0x06, 0x12, 0x03, 0x79, 0x04, 0x10, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x0d, 0x02, 0x03, 0x01, 0x12, 0x03, 0x79, 0x11, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, + 0x02, 0x03, 0x03, 0x12, 0x03, 0x79, 0x20, 0x21, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x04, + 0x12, 0x03, 0x7b, 0x04, 0x23, 0x1a, 0x1b, 0x20, 0x50, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x20, 0x77, + 0x68, 0x65, 0x65, 0x6c, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x04, 0x06, 0x12, 0x03, 0x7b, 0x04, 0x10, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x04, 0x01, 0x12, 0x03, 0x7b, 0x11, 0x1e, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x04, 0x03, 0x12, 0x03, 0x7b, 0x21, 0x22, 0x0a, 0x28, 0x0a, 0x04, + 0x04, 0x0d, 0x02, 0x05, 0x12, 0x03, 0x7d, 0x04, 0x18, 0x1a, 0x1b, 0x20, 0x57, 0x6f, 0x72, 0x6b, + 0x69, 0x6e, 0x67, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x74, 0x6f, + 0x20, 0x73, 0x65, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x05, 0x06, 0x12, + 0x03, 0x7d, 0x04, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x05, 0x01, 0x12, 0x03, 0x7d, + 0x0c, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x05, 0x03, 0x12, 0x03, 0x7d, 0x16, 0x17, + 0x0a, 0x35, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x06, 0x12, 0x03, 0x7f, 0x04, 0x1f, 0x1a, 0x28, 0x20, + 0x43, 0x6f, 0x70, 0x79, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x2f, 0x64, 0x69, 0x72, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x06, 0x06, + 0x12, 0x03, 0x7f, 0x04, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x06, 0x01, 0x12, 0x03, + 0x7f, 0x0f, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x06, 0x03, 0x12, 0x03, 0x7f, 0x1d, + 0x1e, 0x0a, 0x29, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x07, 0x12, 0x04, 0x81, 0x01, 0x04, 0x1d, 0x1a, + 0x1b, 0x20, 0x55, 0x56, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x63, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0d, 0x02, 0x07, 0x06, 0x12, 0x04, 0x81, 0x01, 0x04, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0d, 0x02, 0x07, 0x01, 0x12, 0x04, 0x81, 0x01, 0x0e, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, + 0x02, 0x07, 0x03, 0x12, 0x04, 0x81, 0x01, 0x1b, 0x1c, 0x0a, 0x2d, 0x0a, 0x04, 0x04, 0x0d, 0x02, + 0x08, 0x12, 0x04, 0x83, 0x01, 0x04, 0x10, 0x1a, 0x1f, 0x20, 0x45, 0x6e, 0x76, 0x69, 0x72, 0x6f, + 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, + 0x74, 0x6f, 0x20, 0x73, 0x65, 0x74, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x08, + 0x06, 0x12, 0x04, 0x83, 0x01, 0x04, 0x07, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x08, 0x01, + 0x12, 0x04, 0x83, 0x01, 0x08, 0x0b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x08, 0x03, 0x12, + 0x04, 0x83, 0x01, 0x0e, 0x0f, 0x0a, 0x2c, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x09, 0x12, 0x04, 0x85, + 0x01, 0x04, 0x26, 0x1a, 0x1e, 0x20, 0x50, 0x6f, 0x65, 0x74, 0x72, 0x79, 0x20, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x09, 0x06, 0x12, 0x04, 0x85, 0x01, + 0x04, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x09, 0x01, 0x12, 0x04, 0x85, 0x01, 0x12, + 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x09, 0x03, 0x12, 0x04, 0x85, 0x01, 0x23, 0x25, + 0x0a, 0x34, 0x0a, 0x02, 0x04, 0x0e, 0x12, 0x06, 0x8a, 0x01, 0x00, 0x93, 0x01, 0x01, 0x1a, 0x26, + 0x20, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x64, 0x6b, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0e, 0x01, 0x12, 0x04, 0x8a, + 0x01, 0x08, 0x11, 0x0a, 0x2e, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x00, 0x12, 0x04, 0x8c, 0x01, 0x02, + 0x18, 0x1a, 0x20, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x05, 0x12, 0x04, 0x8c, 0x01, + 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x01, 0x12, 0x04, 0x8c, 0x01, 0x09, + 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x03, 0x12, 0x04, 0x8c, 0x01, 0x16, 0x17, + 0x0a, 0x33, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x01, 0x12, 0x04, 0x8e, 0x01, 0x02, 0x1c, 0x1a, 0x25, + 0x20, 0x70, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, + 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6d, + 0x61, 0x67, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x05, 0x12, 0x04, + 0x8e, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x01, 0x12, 0x04, 0x8e, + 0x01, 0x09, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x03, 0x12, 0x04, 0x8e, 0x01, + 0x1a, 0x1b, 0x0a, 0x35, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x02, 0x12, 0x04, 0x90, 0x01, 0x02, 0x1c, + 0x1a, 0x27, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x6c, 0x61, 0x79, 0x65, 0x72, + 0x73, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x02, 0x04, 0x12, 0x04, 0x90, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x02, + 0x06, 0x12, 0x04, 0x90, 0x01, 0x0b, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x02, 0x01, + 0x12, 0x04, 0x90, 0x01, 0x11, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x02, 0x03, 0x12, + 0x04, 0x90, 0x01, 0x1a, 0x1b, 0x0a, 0x39, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x03, 0x12, 0x04, 0x92, + 0x01, 0x02, 0x1f, 0x1a, 0x2b, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x04, 0x12, 0x04, 0x92, 0x01, 0x02, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x05, 0x12, 0x04, 0x92, 0x01, 0x0b, 0x11, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x01, 0x12, 0x04, 0x92, 0x01, 0x12, 0x1a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x03, 0x03, 0x12, 0x04, 0x92, 0x01, 0x1d, 0x1e, 0x62, 0x06, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xa5, 0x0c, 0x0a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2f, + 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x16, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, + 0x69, 0x6c, 0x64, 0x65, 0x72, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x27, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2f, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xbe, + 0x01, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x3f, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, + 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, + 0x02, 0x69, 0x64, 0x12, 0x26, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0c, 0x6f, + 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x42, 0x0a, 0x0a, 0x70, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x22, + 0x47, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, + 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x49, 0x6d, 0x61, 0x67, + 0x65, 0x52, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x42, 0xdf, 0x01, 0x0a, 0x1a, 0x63, 0x6f, 0x6d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, + 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x42, 0x0c, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, + 0x64, 0x65, 0x72, 0xa2, 0x02, 0x03, 0x46, 0x49, 0x58, 0xaa, 0x02, 0x16, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, + 0x65, 0x72, 0xca, 0x02, 0x16, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x49, + 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0xe2, 0x02, 0x22, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, + 0x6c, 0x64, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0xea, 0x02, 0x17, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x49, 0x6d, + 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x4a, 0x87, 0x07, 0x0a, 0x06, 0x12, + 0x04, 0x00, 0x00, 0x1b, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, + 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x1f, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, + 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x2b, 0x0a, + 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, 0x31, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, + 0x03, 0x08, 0x00, 0x51, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x08, 0x00, 0x51, 0x0a, + 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0a, 0x00, 0x16, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x00, 0x01, 0x12, 0x03, 0x0a, 0x08, 0x17, 0x0a, 0x17, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, + 0x03, 0x0c, 0x02, 0x40, 0x1a, 0x0a, 0x20, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x20, 0x49, 0x44, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x0c, 0x02, 0x11, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0c, 0x12, 0x14, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0c, 0x17, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x08, 0x12, 0x03, 0x0c, 0x19, 0x3f, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x02, 0x00, + 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x0c, 0x1a, 0x3e, 0x0a, 0x94, 0x01, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x01, 0x12, 0x03, 0x10, 0x02, 0x2e, 0x1a, 0x86, 0x01, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x61, 0x6c, 0x20, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x64, 0x69, 0x63, 0x74, 0x61, 0x74, 0x65, 0x73, 0x20, 0x77, + 0x68, 0x69, 0x63, 0x68, 0x20, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x20, 0x72, + 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, + 0x65, 0x6e, 0x63, 0x65, 0x0a, 0x20, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, + 0x2c, 0x20, 0x70, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x66, 0x75, 0x6c, 0x6c, 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x10, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x10, 0x09, 0x15, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x10, 0x18, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x01, 0x08, 0x12, 0x03, 0x10, 0x1a, 0x2d, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x02, 0x01, + 0x08, 0x03, 0x12, 0x03, 0x10, 0x1b, 0x2c, 0x0a, 0x92, 0x02, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, + 0x12, 0x03, 0x15, 0x02, 0x34, 0x1a, 0x84, 0x02, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x63, 0x6f, + 0x70, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x74, 0x6f, 0x20, 0x6c, + 0x6f, 0x6f, 0x6b, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x2e, 0x20, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x20, 0x6d, 0x61, 0x79, 0x62, 0x65, 0x20, + 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x64, 0x69, + 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2d, + 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x70, 0x61, 0x69, 0x72, 0x73, 0x20, 0x74, 0x68, 0x72, + 0x6f, 0x75, 0x67, 0x68, 0x0a, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x20, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, + 0x72, 0x69, 0x65, 0x73, 0x20, 0x28, 0x69, 0x2e, 0x65, 0x2e, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, + 0x72, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x20, 0x46, 0x51, 0x44, 0x4e, 0x73, + 0x29, 0x0a, 0x20, 0x54, 0x4f, 0x44, 0x4f, 0x3a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x73, 0x63, + 0x6f, 0x70, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x6d, 0x61, 0x64, 0x65, + 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, + 0x75, 0x70, 0x64, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x20, 0x74, 0x6f, 0x20, + 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x20, 0x69, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x15, 0x02, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x15, 0x25, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, + 0x03, 0x12, 0x03, 0x15, 0x32, 0x33, 0x0a, 0x59, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x19, 0x00, + 0x1b, 0x01, 0x1a, 0x4d, 0x20, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x50, 0x72, + 0x6f, 0x78, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x65, 0x64, 0x20, 0x75, + 0x70, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x19, 0x08, 0x18, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x1a, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x06, 0x12, 0x03, 0x1a, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x1a, 0x08, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x1a, 0x10, 0x11, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xee, 0x04, 0x0a, + 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x69, 0x6d, 0x61, 0x67, 0x65, + 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x16, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x1a, 0x24, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, + 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x32, 0x72, 0x0a, 0x0c, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x53, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x12, 0x62, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x12, + 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6d, 0x61, 0x67, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, + 0x72, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x42, 0xdf, 0x01, 0x0a, 0x1a, 0x63, 0x6f, 0x6d, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, + 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x42, 0x0c, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, + 0x65, 0x72, 0xa2, 0x02, 0x03, 0x46, 0x49, 0x58, 0xaa, 0x02, 0x16, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, + 0x72, 0xca, 0x02, 0x16, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x49, 0x6d, + 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0xe2, 0x02, 0x22, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, + 0x64, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, + 0x02, 0x17, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x49, 0x6d, 0x61, + 0x67, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x4a, 0xa9, 0x01, 0x0a, 0x06, 0x12, 0x04, + 0x00, 0x00, 0x0c, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, + 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x1f, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, + 0x04, 0x00, 0x2e, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x06, 0x00, 0x51, 0x0a, 0x09, 0x0a, + 0x02, 0x08, 0x0b, 0x12, 0x03, 0x06, 0x00, 0x51, 0x0a, 0x0a, 0x0a, 0x02, 0x06, 0x00, 0x12, 0x04, + 0x08, 0x00, 0x0c, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x06, 0x00, 0x01, 0x12, 0x03, 0x08, 0x08, 0x14, + 0x0a, 0x0c, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x00, 0x12, 0x04, 0x09, 0x02, 0x0b, 0x03, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x09, 0x06, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x09, 0x0f, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x09, 0x29, 0x39, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, + 0x04, 0x12, 0x03, 0x0a, 0x04, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, 0x06, 0x00, 0x02, 0x00, 0x04, 0x22, + 0x12, 0x03, 0x0a, 0x04, 0x2f, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +]; +include!("flyteidl2.imagebuilder.tonic.rs"); +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/flyteidl2.imagebuilder.tonic.rs b/gen/rust/src/flyteidl2.imagebuilder.tonic.rs new file mode 100644 index 0000000000..29421b3dd4 --- /dev/null +++ b/gen/rust/src/flyteidl2.imagebuilder.tonic.rs @@ -0,0 +1,287 @@ +// @generated +/// Generated client implementations. +pub mod image_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct ImageServiceClient { + inner: tonic::client::Grpc, + } + impl ImageServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl ImageServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> ImageServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + ImageServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /// + pub async fn get_image( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.imagebuilder.ImageService/GetImage", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.imagebuilder.ImageService", "GetImage"), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod image_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with ImageServiceServer. + #[async_trait] + pub trait ImageService: Send + Sync + 'static { + /// + async fn get_image( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + #[derive(Debug)] + pub struct ImageServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl ImageServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for ImageServiceServer + where + T: ImageService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.imagebuilder.ImageService/GetImage" => { + #[allow(non_camel_case_types)] + struct GetImageSvc(pub Arc); + impl< + T: ImageService, + > tonic::server::UnaryService + for GetImageSvc { + type Response = super::GetImageResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_image(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetImageSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for ImageServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService for ImageServiceServer { + const NAME: &'static str = "flyteidl2.imagebuilder.ImageService"; + } +} diff --git a/gen/rust/src/flyteidl2.logs.dataplane.rs b/gen/rust/src/flyteidl2.logs.dataplane.rs new file mode 100644 index 0000000000..a7d7117f40 --- /dev/null +++ b/gen/rust/src/flyteidl2.logs.dataplane.rs @@ -0,0 +1,704 @@ +// @generated +// This file is @generated by prost-build. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PodResource { + /// The namespace of the pod. + #[prost(string, tag="1")] + pub namespace: ::prost::alloc::string::String, + /// The pod name. + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, + /// The container name. If not provided, attempt to find the primary container, else assume the first container. + /// +optional + #[prost(string, tag="3")] + pub container: ::prost::alloc::string::String, +} +/// Parameters of environment in which logs were collected. Should contain everything +/// necessary to identify location of task execution logs in cloud providers. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LoggingContext { + #[prost(string, tag="3")] + pub cluster_name: ::prost::alloc::string::String, + #[prost(string, tag="4")] + pub kubernetes_namespace: ::prost::alloc::string::String, + #[prost(string, tag="5")] + pub kubernetes_pod_name: ::prost::alloc::string::String, + #[prost(string, tag="6")] + pub kubernetes_container_name: ::prost::alloc::string::String, + #[prost(message, optional, tag="7")] + pub execution_attempt_start_time: ::core::option::Option, + #[prost(message, optional, tag="8")] + pub execution_attempt_end_time: ::core::option::Option, + #[prost(map="string, string", tag="9")] + pub kubernetes_pod_labels: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, +} +/// Parameters of environment in which logs were collected. Should contain everything +/// necessary to identify location of task execution logs in cloud providers. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ContainerIdentifier { + /// The name of the cluster. + #[prost(string, tag="1")] + pub cluster_name: ::prost::alloc::string::String, + /// The namespace in Kubernetes. + #[prost(string, tag="2")] + pub kubernetes_namespace: ::prost::alloc::string::String, + /// The name of the pod in Kubernetes. + #[prost(string, tag="3")] + pub kubernetes_pod_name: ::prost::alloc::string::String, + /// The name of the container in Kubernetes. + #[prost(string, tag="4")] + pub kubernetes_container_name: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ContainerSelector { + /// The name of the cluster. + #[prost(string, tag="1")] + pub cluster_name: ::prost::alloc::string::String, + /// The namespace in Kubernetes. + #[prost(string, tag="2")] + pub kubernetes_namespace: ::prost::alloc::string::String, + /// The prefix of the name of the pod in Kubernetes. This will only apply to persisted pods' logs because listing by + /// prefix is the supported way to filter pods. + #[prost(string, tag="3")] + pub kubernetes_pod_name_prefix: ::prost::alloc::string::String, + /// The name of the container in Kubernetes. If not specified, logs for all containers + /// will be streamed. + #[prost(string, tag="4")] + pub kubernetes_container_name: ::prost::alloc::string::String, + /// The label selector to filter pods. This will only apply to live pods' logs because Listing by prefix + /// isn't supported. + #[prost(string, tag="5")] + pub kubernetes_pod_label_selector: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct LiveLogsOptions { + /// LogPodStatus indicates whether to log the pod status along with the logs. + #[prost(bool, tag="1")] + pub log_pod_status: bool, + /// LogTimestamps indicates whether to log the timestamps along with the logs. It prepends RFC3339 or RFC3339Nano + /// format in the beginning of each log line. + #[prost(bool, tag="2")] + pub log_timestamps: bool, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LogLine { + #[prost(message, optional, tag="1")] + pub timestamp: ::core::option::Option, + /// Each line is separated by either CRLF, CR or LF, which are included + /// at the ends of the lines. This lets clients know whether log emitter + /// wanted to overwrite the previous line (LF) or append a new line (CRLF). + #[prost(string, tag="2")] + pub message: ::prost::alloc::string::String, + #[prost(enumeration="LogLineOriginator", tag="3")] + pub originator: i32, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LogLines { + /// Each line is separated by either CRLF, CR or LF, which are included + /// at the ends of the lines. This lets clients know whether log emitter + /// wanted to overwrite the previous line (LF) or append a new line (CRLF). + #[deprecated] + #[prost(string, repeated, tag="1")] + pub lines: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// The index of the container in the list of containers. If the request was made with a single container identifier, + /// this value will always be 0. Otherwise, it'll be an index into the last list of containers sent in the stream. + #[prost(uint32, tag="2")] + pub container_index: u32, + /// The container identifier. + #[prost(message, optional, tag="3")] + pub container: ::core::option::Option, + /// Each line is separated by either CRLF, CR or LF, which are included + /// at the ends of the lines. This lets clients know whether log emitter + /// wanted to overwrite the previous line (LF) or append a new line (CRLF). + #[prost(message, repeated, tag="4")] + pub structured_lines: ::prost::alloc::vec::Vec, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LogContainersList { + #[prost(message, repeated, tag="1")] + pub containers: ::prost::alloc::vec::Vec, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LogLinesBatch { + #[prost(message, repeated, tag="1")] + pub logs: ::prost::alloc::vec::Vec, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum LogLineOriginator { + /// The originator of the log line is unknown. + Unknown = 0, + /// The originator of the log line is the user application. + User = 1, + /// The originator of the log line is the system. + System = 2, +} +impl LogLineOriginator { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + LogLineOriginator::Unknown => "UNKNOWN", + LogLineOriginator::User => "USER", + LogLineOriginator::System => "SYSTEM", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNKNOWN" => Some(Self::Unknown), + "USER" => Some(Self::User), + "SYSTEM" => Some(Self::System), + _ => None, + } + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum LogsSource { + /// Return live logs and fall back to persisted if not available. + LiveOrPersisted = 0, + /// Return live logs only or error if pod is no longer around. + LiveOnly = 1, + /// Return persisted logs only. + PersistedOnly = 2, +} +impl LogsSource { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + LogsSource::LiveOrPersisted => "LIVE_OR_PERSISTED", + LogsSource::LiveOnly => "LIVE_ONLY", + LogsSource::PersistedOnly => "PERSISTED_ONLY", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "LIVE_OR_PERSISTED" => Some(Self::LiveOrPersisted), + "LIVE_ONLY" => Some(Self::LiveOnly), + "PERSISTED_ONLY" => Some(Self::PersistedOnly), + _ => None, + } + } +} +/// Encoded file descriptor set for the `flyteidl2.logs.dataplane` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xa5, 0x3d, 0x0a, 0x26, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x6c, + 0x6f, 0x67, 0x73, 0x2f, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2f, 0x70, 0x61, + 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x64, 0x61, 0x74, 0x61, + 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x22, 0x6f, 0x0a, 0x0b, 0x50, 0x6f, 0x64, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x12, 0x25, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x09, + 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, + 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x65, 0x72, 0x22, 0xf7, 0x04, 0x0a, 0x0e, 0x4c, 0x6f, 0x67, 0x67, 0x69, 0x6e, 0x67, + 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x2a, 0x0a, 0x0c, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, + 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, + 0x61, 0x6d, 0x65, 0x12, 0x3a, 0x0a, 0x14, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, + 0x73, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x13, 0x6b, 0x75, 0x62, 0x65, + 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, + 0x37, 0x0a, 0x13, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x5f, 0x70, 0x6f, + 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, + 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x11, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, + 0x73, 0x50, 0x6f, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x43, 0x0a, 0x19, 0x6b, 0x75, 0x62, 0x65, + 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, + 0x72, 0x02, 0x10, 0x01, 0x52, 0x17, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, + 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x5b, 0x0a, + 0x1c, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x61, 0x74, 0x74, 0x65, 0x6d, + 0x70, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x07, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, + 0x19, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, + 0x74, 0x53, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x57, 0x0a, 0x1a, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x5f, + 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x17, 0x65, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x45, 0x6e, 0x64, 0x54, + 0x69, 0x6d, 0x65, 0x12, 0x75, 0x0a, 0x15, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, + 0x73, 0x5f, 0x70, 0x6f, 0x64, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x09, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x41, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x6c, + 0x6f, 0x67, 0x73, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2e, 0x4c, 0x6f, + 0x67, 0x67, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2e, 0x4b, 0x75, 0x62, + 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x50, 0x6f, 0x64, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, + 0x73, 0x50, 0x6f, 0x64, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x1a, 0x46, 0x0a, 0x18, 0x4b, 0x75, + 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x50, 0x6f, 0x64, 0x4c, 0x61, 0x62, 0x65, 0x6c, + 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x4a, 0x04, 0x08, 0x01, 0x10, 0x02, 0x4a, 0x04, 0x08, 0x02, 0x10, 0x03, 0x22, 0xf2, + 0x01, 0x0a, 0x13, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x2a, 0x0a, 0x0c, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, + 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, + 0x6d, 0x65, 0x12, 0x3a, 0x0a, 0x14, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x13, 0x6b, 0x75, 0x62, 0x65, 0x72, + 0x6e, 0x65, 0x74, 0x65, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x37, + 0x0a, 0x13, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x5f, 0x70, 0x6f, 0x64, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, + 0x72, 0x02, 0x10, 0x01, 0x52, 0x11, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, + 0x50, 0x6f, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x3a, 0x0a, 0x19, 0x6b, 0x75, 0x62, 0x65, 0x72, + 0x6e, 0x65, 0x74, 0x65, 0x73, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x17, 0x6b, 0x75, 0x62, 0x65, + 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4e, + 0x61, 0x6d, 0x65, 0x22, 0xb7, 0x02, 0x0a, 0x11, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, + 0x72, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x2a, 0x0a, 0x0c, 0x63, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, + 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x3a, 0x0a, 0x14, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, + 0x74, 0x65, 0x73, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x13, 0x6b, 0x75, + 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, + 0x65, 0x12, 0x3b, 0x0a, 0x1a, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x5f, + 0x70, 0x6f, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x17, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, + 0x73, 0x50, 0x6f, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x3a, + 0x0a, 0x19, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x5f, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x17, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x43, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x41, 0x0a, 0x1d, 0x6b, 0x75, + 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x5f, 0x70, 0x6f, 0x64, 0x5f, 0x6c, 0x61, 0x62, + 0x65, 0x6c, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x1a, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x50, 0x6f, 0x64, + 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x22, 0x5e, 0x0a, + 0x0f, 0x4c, 0x69, 0x76, 0x65, 0x4c, 0x6f, 0x67, 0x73, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x12, 0x24, 0x0a, 0x0e, 0x6c, 0x6f, 0x67, 0x5f, 0x70, 0x6f, 0x64, 0x5f, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x6c, 0x6f, 0x67, 0x50, 0x6f, 0x64, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x6c, 0x6f, 0x67, 0x5f, 0x74, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, + 0x6c, 0x6f, 0x67, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x73, 0x22, 0xaa, 0x01, + 0x0a, 0x07, 0x4c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x12, 0x38, 0x0a, 0x09, 0x74, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x4b, 0x0a, + 0x0a, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0e, 0x32, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x6c, 0x6f, + 0x67, 0x73, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2e, 0x4c, 0x6f, 0x67, + 0x4c, 0x69, 0x6e, 0x65, 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x0a, + 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x22, 0xf0, 0x01, 0x0a, 0x08, 0x4c, + 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x73, 0x12, 0x18, 0x0a, 0x05, 0x6c, 0x69, 0x6e, 0x65, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x05, 0x6c, 0x69, 0x6e, 0x65, + 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x69, + 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x63, 0x6f, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x65, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x53, 0x0a, 0x09, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x64, + 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, + 0x03, 0xc8, 0x01, 0x01, 0x52, 0x09, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x12, + 0x4c, 0x0a, 0x10, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x5f, 0x6c, 0x69, + 0x6e, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, + 0x6c, 0x61, 0x6e, 0x65, 0x2e, 0x4c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x52, 0x0f, 0x73, 0x74, + 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, 0x4c, 0x69, 0x6e, 0x65, 0x73, 0x22, 0x62, 0x0a, + 0x11, 0x4c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x4c, 0x69, + 0x73, 0x74, 0x12, 0x4d, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, + 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x73, 0x22, 0x47, 0x0a, 0x0d, 0x4c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x73, 0x42, 0x61, 0x74, + 0x63, 0x68, 0x12, 0x36, 0x0a, 0x04, 0x6c, 0x6f, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x6c, 0x6f, 0x67, + 0x73, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2e, 0x4c, 0x6f, 0x67, 0x4c, + 0x69, 0x6e, 0x65, 0x73, 0x52, 0x04, 0x6c, 0x6f, 0x67, 0x73, 0x2a, 0x36, 0x0a, 0x11, 0x4c, 0x6f, + 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x12, + 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, + 0x55, 0x53, 0x45, 0x52, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, + 0x10, 0x02, 0x2a, 0x46, 0x0a, 0x0a, 0x4c, 0x6f, 0x67, 0x73, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x12, 0x15, 0x0a, 0x11, 0x4c, 0x49, 0x56, 0x45, 0x5f, 0x4f, 0x52, 0x5f, 0x50, 0x45, 0x52, 0x53, + 0x49, 0x53, 0x54, 0x45, 0x44, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x4c, 0x49, 0x56, 0x45, 0x5f, + 0x4f, 0x4e, 0x4c, 0x59, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x50, 0x45, 0x52, 0x53, 0x49, 0x53, + 0x54, 0x45, 0x44, 0x5f, 0x4f, 0x4e, 0x4c, 0x59, 0x10, 0x02, 0x42, 0xec, 0x01, 0x0a, 0x1c, 0x63, + 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x6c, 0x6f, 0x67, + 0x73, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x42, 0x0c, 0x50, 0x61, 0x79, + 0x6c, 0x6f, 0x61, 0x64, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3c, 0x67, 0x69, 0x74, + 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, + 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, + 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x6c, 0x6f, 0x67, 0x73, 0x2f, + 0x64, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0xa2, 0x02, 0x03, 0x46, 0x4c, 0x44, 0xaa, + 0x02, 0x18, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x4c, 0x6f, 0x67, 0x73, + 0x2e, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0xca, 0x02, 0x18, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x4c, 0x6f, 0x67, 0x73, 0x5c, 0x44, 0x61, 0x74, 0x61, + 0x70, 0x6c, 0x61, 0x6e, 0x65, 0xe2, 0x02, 0x24, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x5c, 0x4c, 0x6f, 0x67, 0x73, 0x5c, 0x44, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1a, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x4c, 0x6f, 0x67, 0x73, 0x3a, 0x3a, + 0x44, 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x4a, 0xe4, 0x29, 0x0a, 0x07, 0x12, 0x05, + 0x00, 0x00, 0x8a, 0x01, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, + 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x21, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, + 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x29, 0x0a, + 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x07, 0x00, 0x53, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, + 0x03, 0x07, 0x00, 0x53, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x09, 0x00, 0x13, 0x01, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x09, 0x08, 0x13, 0x0a, 0x28, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0b, 0x02, 0x41, 0x1a, 0x1b, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x6f, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, + 0x03, 0x0b, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0b, + 0x09, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0b, 0x15, 0x16, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x08, 0x12, 0x03, 0x0b, 0x17, 0x40, 0x0a, 0x10, + 0x0a, 0x09, 0x04, 0x00, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x0b, 0x18, 0x3f, + 0x0a, 0x1c, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0e, 0x02, 0x3c, 0x1a, 0x0f, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x70, 0x6f, 0x64, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x0e, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0e, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x0e, 0x10, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, + 0x08, 0x12, 0x03, 0x0e, 0x12, 0x3b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x01, 0x08, 0x87, + 0x09, 0x0e, 0x02, 0x12, 0x03, 0x0e, 0x13, 0x3a, 0x0a, 0x86, 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x02, 0x12, 0x03, 0x12, 0x02, 0x17, 0x1a, 0x79, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, + 0x6e, 0x6f, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x74, + 0x74, 0x65, 0x6d, 0x70, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x69, 0x6e, 0x64, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x65, 0x72, 0x2c, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x65, 0x72, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x12, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x12, 0x09, 0x12, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x12, 0x15, 0x16, 0x0a, 0xab, 0x01, 0x0a, 0x02, + 0x04, 0x01, 0x12, 0x04, 0x17, 0x00, 0x21, 0x01, 0x1a, 0x9e, 0x01, 0x20, 0x50, 0x61, 0x72, 0x61, + 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, + 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x6c, + 0x6f, 0x67, 0x73, 0x20, 0x77, 0x65, 0x72, 0x65, 0x20, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, + 0x65, 0x64, 0x2e, 0x20, 0x53, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x72, 0x79, 0x74, 0x68, 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x6e, + 0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x79, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x20, 0x70, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, + 0x12, 0x03, 0x17, 0x08, 0x16, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x09, 0x12, 0x03, 0x18, 0x02, + 0x10, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x09, 0x00, 0x12, 0x03, 0x18, 0x0b, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x09, 0x00, 0x01, 0x12, 0x03, 0x18, 0x0b, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x09, 0x00, 0x02, 0x12, 0x03, 0x18, 0x0b, 0x0c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, + 0x09, 0x01, 0x12, 0x03, 0x18, 0x0e, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x09, 0x01, 0x01, + 0x12, 0x03, 0x18, 0x0e, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x09, 0x01, 0x02, 0x12, 0x03, + 0x18, 0x0e, 0x0f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x1a, 0x02, 0x44, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x1a, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1a, 0x09, 0x15, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1a, 0x18, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x08, 0x12, 0x03, 0x1a, 0x1a, 0x43, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x01, 0x02, 0x00, + 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x1a, 0x1b, 0x42, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x01, 0x12, 0x03, 0x1b, 0x02, 0x4c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, + 0x12, 0x03, 0x1b, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x1b, 0x09, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x1b, 0x20, + 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x08, 0x12, 0x03, 0x1b, 0x22, 0x4b, 0x0a, + 0x10, 0x0a, 0x09, 0x04, 0x01, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x1b, 0x23, + 0x4a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x1c, 0x02, 0x4b, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x05, 0x12, 0x03, 0x1c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x1c, 0x09, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x02, 0x03, 0x12, 0x03, 0x1c, 0x1f, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, + 0x08, 0x12, 0x03, 0x1c, 0x21, 0x4a, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x01, 0x02, 0x02, 0x08, 0x87, + 0x09, 0x0e, 0x02, 0x12, 0x03, 0x1c, 0x22, 0x49, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x03, + 0x12, 0x03, 0x1d, 0x02, 0x51, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x05, 0x12, 0x03, + 0x1d, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x01, 0x12, 0x03, 0x1d, 0x09, + 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x03, 0x12, 0x03, 0x1d, 0x25, 0x26, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x08, 0x12, 0x03, 0x1d, 0x27, 0x50, 0x0a, 0x10, 0x0a, + 0x09, 0x04, 0x01, 0x02, 0x03, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x1d, 0x28, 0x4f, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x04, 0x12, 0x03, 0x1e, 0x02, 0x3d, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x04, 0x06, 0x12, 0x03, 0x1e, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x04, 0x01, 0x12, 0x03, 0x1e, 0x1c, 0x38, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, + 0x03, 0x12, 0x03, 0x1e, 0x3b, 0x3c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x05, 0x12, 0x03, + 0x1f, 0x02, 0x3b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x06, 0x12, 0x03, 0x1f, 0x02, + 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x01, 0x12, 0x03, 0x1f, 0x1c, 0x36, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x03, 0x12, 0x03, 0x1f, 0x39, 0x3a, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x01, 0x02, 0x06, 0x12, 0x03, 0x20, 0x02, 0x30, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x06, 0x06, 0x12, 0x03, 0x20, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, + 0x01, 0x12, 0x03, 0x20, 0x16, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x03, 0x12, + 0x03, 0x20, 0x2e, 0x2f, 0x0a, 0xab, 0x01, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x25, 0x00, 0x31, + 0x01, 0x1a, 0x9e, 0x01, 0x20, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x69, + 0x6e, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x77, 0x65, 0x72, + 0x65, 0x20, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x65, 0x64, 0x2e, 0x20, 0x53, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x72, + 0x79, 0x74, 0x68, 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x6e, 0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72, + 0x79, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x79, 0x20, 0x6c, 0x6f, + 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x69, 0x6e, + 0x20, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, + 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x25, 0x08, 0x1b, 0x0a, 0x27, + 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x27, 0x02, 0x44, 0x1a, 0x1a, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, + 0x12, 0x03, 0x27, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x27, 0x09, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x27, 0x18, + 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x08, 0x12, 0x03, 0x27, 0x1a, 0x43, 0x0a, + 0x10, 0x0a, 0x09, 0x04, 0x02, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x27, 0x1b, + 0x42, 0x0a, 0x2b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x2a, 0x02, 0x4c, 0x1a, 0x1e, + 0x20, 0x54, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x69, + 0x6e, 0x20, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x05, 0x12, 0x03, 0x2a, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x2a, 0x09, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x2a, 0x20, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, + 0x08, 0x12, 0x03, 0x2a, 0x22, 0x4b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x02, 0x02, 0x01, 0x08, 0x87, + 0x09, 0x0e, 0x02, 0x12, 0x03, 0x2a, 0x23, 0x4a, 0x0a, 0x31, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x02, + 0x12, 0x03, 0x2d, 0x02, 0x4b, 0x1a, 0x24, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6f, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x4b, + 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x02, 0x05, 0x12, 0x03, 0x2d, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x2d, 0x09, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x2d, 0x1f, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x08, 0x12, 0x03, + 0x2d, 0x21, 0x4a, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x02, 0x02, 0x02, 0x08, 0x87, 0x09, 0x0e, 0x02, + 0x12, 0x03, 0x2d, 0x22, 0x49, 0x0a, 0x37, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, 0x30, + 0x02, 0x27, 0x1a, 0x2a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x69, + 0x6e, 0x20, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x05, 0x12, 0x03, 0x30, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x03, 0x01, 0x12, 0x03, 0x30, 0x09, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x03, 0x03, 0x12, 0x03, 0x30, 0x25, 0x26, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, + 0x33, 0x00, 0x45, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x33, 0x08, 0x19, + 0x0a, 0x27, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x35, 0x02, 0x44, 0x1a, 0x1a, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x35, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x35, 0x09, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x35, 0x18, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x08, 0x12, 0x03, 0x35, 0x1a, + 0x43, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x03, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, + 0x35, 0x1b, 0x42, 0x0a, 0x2b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, 0x38, 0x02, 0x4c, + 0x1a, 0x1e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, + 0x20, 0x69, 0x6e, 0x20, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x05, 0x12, 0x03, 0x38, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, 0x38, 0x09, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x38, 0x20, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x01, 0x08, 0x12, 0x03, 0x38, 0x22, 0x4b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x03, 0x02, 0x01, + 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x38, 0x23, 0x4a, 0x0a, 0xad, 0x01, 0x0a, 0x04, 0x04, + 0x03, 0x02, 0x02, 0x12, 0x03, 0x3c, 0x02, 0x28, 0x1a, 0x9f, 0x01, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x61, + 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6f, 0x64, 0x20, 0x69, 0x6e, + 0x20, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x69, + 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x61, 0x70, 0x70, 0x6c, + 0x79, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x64, 0x20, 0x70, + 0x6f, 0x64, 0x73, 0x27, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, + 0x65, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x62, 0x79, 0x0a, 0x20, 0x70, 0x72, + 0x65, 0x66, 0x69, 0x78, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x75, 0x70, 0x70, + 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x77, 0x61, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x69, 0x6c, + 0x74, 0x65, 0x72, 0x20, 0x70, 0x6f, 0x64, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x02, 0x05, 0x12, 0x03, 0x3c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, + 0x01, 0x12, 0x03, 0x3c, 0x09, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x03, 0x12, + 0x03, 0x3c, 0x26, 0x27, 0x0a, 0x74, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x03, 0x12, 0x03, 0x40, 0x02, + 0x27, 0x1a, 0x67, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x69, 0x6e, + 0x20, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x2e, 0x20, 0x49, 0x66, 0x20, + 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2c, 0x20, 0x6c, + 0x6f, 0x67, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x0a, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, + 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x03, 0x05, 0x12, 0x03, 0x40, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, + 0x01, 0x12, 0x03, 0x40, 0x09, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x03, 0x12, + 0x03, 0x40, 0x25, 0x26, 0x0a, 0x85, 0x01, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x04, 0x12, 0x03, 0x44, + 0x02, 0x2b, 0x1a, 0x78, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x20, 0x73, + 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, + 0x72, 0x20, 0x70, 0x6f, 0x64, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, + 0x6c, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x20, 0x74, 0x6f, 0x20, + 0x6c, 0x69, 0x76, 0x65, 0x20, 0x70, 0x6f, 0x64, 0x73, 0x27, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, + 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, + 0x62, 0x79, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x0a, 0x20, 0x69, 0x73, 0x6e, 0x27, 0x74, + 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x04, 0x05, 0x12, 0x03, 0x44, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x04, 0x01, 0x12, 0x03, 0x44, 0x09, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, + 0x03, 0x12, 0x03, 0x44, 0x29, 0x2a, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x47, 0x00, + 0x4e, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x47, 0x08, 0x17, 0x0a, 0x58, + 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x49, 0x02, 0x1a, 0x1a, 0x4b, 0x20, 0x4c, 0x6f, + 0x67, 0x50, 0x6f, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, + 0x61, 0x74, 0x65, 0x73, 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, + 0x6c, 0x6f, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6f, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x20, 0x61, 0x6c, 0x6f, 0x6e, 0x67, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, + 0x05, 0x12, 0x03, 0x49, 0x02, 0x06, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x49, 0x07, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x49, + 0x18, 0x19, 0x0a, 0xa8, 0x01, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x4d, 0x02, 0x1a, + 0x1a, 0x9a, 0x01, 0x20, 0x4c, 0x6f, 0x67, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x73, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x77, 0x68, 0x65, 0x74, + 0x68, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x6c, 0x6f, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x73, 0x20, 0x61, 0x6c, 0x6f, 0x6e, 0x67, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x20, 0x49, + 0x74, 0x20, 0x70, 0x72, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x73, 0x20, 0x52, 0x46, 0x43, 0x33, 0x33, + 0x33, 0x39, 0x20, 0x6f, 0x72, 0x20, 0x52, 0x46, 0x43, 0x33, 0x33, 0x33, 0x39, 0x4e, 0x61, 0x6e, + 0x6f, 0x0a, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x66, 0x20, 0x65, 0x61, + 0x63, 0x68, 0x20, 0x6c, 0x6f, 0x67, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x01, 0x05, 0x12, 0x03, 0x4d, 0x02, 0x06, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x4d, 0x07, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x01, 0x03, 0x12, 0x03, 0x4d, 0x18, 0x19, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x00, 0x12, 0x04, 0x50, + 0x00, 0x59, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, 0x03, 0x50, 0x05, 0x16, 0x0a, + 0x39, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x00, 0x12, 0x03, 0x52, 0x02, 0x0e, 0x1a, 0x2c, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x67, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x52, 0x02, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, + 0x02, 0x12, 0x03, 0x52, 0x0c, 0x0d, 0x0a, 0x46, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x01, 0x12, 0x03, + 0x55, 0x02, 0x0b, 0x1a, 0x39, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, + 0x61, 0x74, 0x6f, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x67, 0x20, + 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x73, 0x65, 0x72, + 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x55, 0x02, 0x06, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x55, 0x09, 0x0a, 0x0a, 0x3c, 0x0a, 0x04, 0x05, 0x00, + 0x02, 0x02, 0x12, 0x03, 0x58, 0x02, 0x0d, 0x1a, 0x2f, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6f, 0x72, + 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6c, 0x6f, 0x67, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, + 0x01, 0x12, 0x03, 0x58, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x02, 0x12, + 0x03, 0x58, 0x0b, 0x0c, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x5b, 0x00, 0x64, 0x01, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x5b, 0x08, 0x0f, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x5c, 0x02, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x5c, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x5c, 0x1c, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x5c, 0x28, 0x29, 0x0a, 0xe2, 0x01, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x03, 0x61, 0x02, + 0x15, 0x1a, 0xd4, 0x01, 0x20, 0x45, 0x61, 0x63, 0x68, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x69, + 0x73, 0x20, 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x65, + 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x43, 0x52, 0x4c, 0x46, 0x2c, 0x20, 0x43, 0x52, 0x20, 0x6f, + 0x72, 0x20, 0x4c, 0x46, 0x2c, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x61, 0x72, 0x65, 0x20, + 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x0a, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x65, 0x6e, 0x64, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x6e, + 0x65, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6c, 0x65, 0x74, 0x73, 0x20, 0x63, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, + 0x65, 0x72, 0x20, 0x6c, 0x6f, 0x67, 0x20, 0x65, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x0a, 0x20, + 0x77, 0x61, 0x6e, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, + 0x69, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, + 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x28, 0x4c, 0x46, 0x29, 0x20, 0x6f, 0x72, 0x20, 0x61, 0x70, + 0x70, 0x65, 0x6e, 0x64, 0x20, 0x61, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x20, + 0x28, 0x43, 0x52, 0x4c, 0x46, 0x29, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, + 0x05, 0x12, 0x03, 0x61, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x61, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x03, 0x61, + 0x13, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x02, 0x12, 0x03, 0x63, 0x02, 0x23, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x06, 0x12, 0x03, 0x63, 0x02, 0x13, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x02, 0x01, 0x12, 0x03, 0x63, 0x14, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x02, 0x03, 0x12, 0x03, 0x63, 0x21, 0x22, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x06, 0x12, + 0x04, 0x66, 0x00, 0x77, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x03, 0x66, 0x08, + 0x10, 0x0a, 0xe2, 0x01, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x03, 0x6a, 0x02, 0x30, 0x1a, + 0xd4, 0x01, 0x20, 0x45, 0x61, 0x63, 0x68, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x69, 0x73, 0x20, + 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x65, 0x69, 0x74, + 0x68, 0x65, 0x72, 0x20, 0x43, 0x52, 0x4c, 0x46, 0x2c, 0x20, 0x43, 0x52, 0x20, 0x6f, 0x72, 0x20, + 0x4c, 0x46, 0x2c, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x61, 0x72, 0x65, 0x20, 0x69, 0x6e, + 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x0a, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, + 0x6e, 0x64, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x73, + 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6c, 0x65, 0x74, 0x73, 0x20, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x73, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, + 0x20, 0x6c, 0x6f, 0x67, 0x20, 0x65, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x0a, 0x20, 0x77, 0x61, + 0x6e, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x6c, + 0x69, 0x6e, 0x65, 0x20, 0x28, 0x4c, 0x46, 0x29, 0x20, 0x6f, 0x72, 0x20, 0x61, 0x70, 0x70, 0x65, + 0x6e, 0x64, 0x20, 0x61, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x28, 0x43, + 0x52, 0x4c, 0x46, 0x29, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x04, 0x12, + 0x03, 0x6a, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x05, 0x12, 0x03, 0x6a, + 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x03, 0x6a, 0x12, 0x17, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x03, 0x6a, 0x1a, 0x1b, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x08, 0x12, 0x03, 0x6a, 0x1c, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, + 0x04, 0x06, 0x02, 0x00, 0x08, 0x03, 0x12, 0x03, 0x6a, 0x1d, 0x2e, 0x0a, 0xf1, 0x01, 0x0a, 0x04, + 0x04, 0x06, 0x02, 0x01, 0x12, 0x03, 0x6e, 0x02, 0x1d, 0x1a, 0xe3, 0x01, 0x20, 0x54, 0x68, 0x65, + 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, + 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x73, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x20, 0x77, 0x61, 0x73, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x61, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x65, 0x72, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2c, 0x0a, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, + 0x61, 0x6c, 0x77, 0x61, 0x79, 0x73, 0x20, 0x62, 0x65, 0x20, 0x30, 0x2e, 0x20, 0x4f, 0x74, 0x68, + 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x2c, 0x20, 0x69, 0x74, 0x27, 0x6c, 0x6c, 0x20, 0x62, 0x65, + 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6c, 0x61, 0x73, 0x74, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x73, 0x65, 0x6e, 0x74, 0x20, + 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x05, 0x12, 0x03, 0x6e, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x01, 0x01, 0x12, 0x03, 0x6e, 0x09, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x01, 0x03, 0x12, 0x03, 0x6e, 0x1b, 0x1c, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x06, 0x02, + 0x02, 0x12, 0x03, 0x71, 0x02, 0x4b, 0x1a, 0x1b, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x06, 0x12, 0x03, 0x71, 0x02, + 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x01, 0x12, 0x03, 0x71, 0x16, 0x1f, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x03, 0x12, 0x03, 0x71, 0x22, 0x23, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x02, 0x08, 0x12, 0x03, 0x71, 0x24, 0x4a, 0x0a, 0x0f, 0x0a, 0x08, 0x04, + 0x06, 0x02, 0x02, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x71, 0x25, 0x49, 0x0a, 0xe2, 0x01, 0x0a, + 0x04, 0x04, 0x06, 0x02, 0x03, 0x12, 0x03, 0x76, 0x02, 0x28, 0x1a, 0xd4, 0x01, 0x20, 0x45, 0x61, + 0x63, 0x68, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x69, 0x73, 0x20, 0x73, 0x65, 0x70, 0x61, 0x72, + 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x43, + 0x52, 0x4c, 0x46, 0x2c, 0x20, 0x43, 0x52, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x46, 0x2c, 0x20, 0x77, + 0x68, 0x69, 0x63, 0x68, 0x20, 0x61, 0x72, 0x65, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, + 0x64, 0x0a, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x64, 0x73, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x69, + 0x73, 0x20, 0x6c, 0x65, 0x74, 0x73, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x6b, + 0x6e, 0x6f, 0x77, 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x6c, 0x6f, 0x67, 0x20, + 0x65, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x0a, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x28, + 0x4c, 0x46, 0x29, 0x20, 0x6f, 0x72, 0x20, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x64, 0x20, 0x61, 0x20, + 0x6e, 0x65, 0x77, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x28, 0x43, 0x52, 0x4c, 0x46, 0x29, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x03, 0x04, 0x12, 0x03, 0x76, 0x02, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x03, 0x06, 0x12, 0x03, 0x76, 0x0b, 0x12, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x03, 0x01, 0x12, 0x03, 0x76, 0x13, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x03, 0x03, 0x12, 0x03, 0x76, 0x26, 0x27, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x07, 0x12, + 0x04, 0x79, 0x00, 0x7b, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x03, 0x79, 0x08, + 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x03, 0x7a, 0x02, 0x2e, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x04, 0x12, 0x03, 0x7a, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x00, 0x06, 0x12, 0x03, 0x7a, 0x0b, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x7a, 0x1f, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x7a, 0x2c, 0x2d, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x04, 0x7d, 0x00, + 0x7f, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x08, 0x01, 0x12, 0x03, 0x7d, 0x08, 0x15, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x08, 0x02, 0x00, 0x12, 0x03, 0x7e, 0x02, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x00, 0x04, 0x12, 0x03, 0x7e, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x7e, 0x0b, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x7e, 0x14, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x7e, 0x1b, 0x1c, 0x0a, 0x0c, 0x0a, 0x02, 0x05, 0x01, 0x12, 0x06, 0x81, 0x01, 0x00, 0x8a, 0x01, + 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x05, 0x01, 0x01, 0x12, 0x04, 0x81, 0x01, 0x05, 0x0f, 0x0a, 0x4d, + 0x0a, 0x04, 0x05, 0x01, 0x02, 0x00, 0x12, 0x04, 0x83, 0x01, 0x02, 0x18, 0x1a, 0x3f, 0x20, 0x52, + 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6c, 0x69, 0x76, 0x65, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, + 0x61, 0x6e, 0x64, 0x20, 0x66, 0x61, 0x6c, 0x6c, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x20, 0x74, 0x6f, + 0x20, 0x70, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x64, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, + 0x74, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x05, 0x01, 0x02, 0x00, 0x01, 0x12, 0x04, 0x83, 0x01, 0x02, 0x13, 0x0a, 0x0d, 0x0a, 0x05, + 0x05, 0x01, 0x02, 0x00, 0x02, 0x12, 0x04, 0x83, 0x01, 0x16, 0x17, 0x0a, 0x4a, 0x0a, 0x04, 0x05, + 0x01, 0x02, 0x01, 0x12, 0x04, 0x86, 0x01, 0x02, 0x10, 0x1a, 0x3c, 0x20, 0x52, 0x65, 0x74, 0x75, + 0x72, 0x6e, 0x20, 0x6c, 0x69, 0x76, 0x65, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x6f, 0x6e, 0x6c, + 0x79, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x69, 0x66, 0x20, 0x70, 0x6f, + 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x20, 0x61, + 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x01, 0x01, + 0x12, 0x04, 0x86, 0x01, 0x02, 0x0b, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x01, 0x02, 0x12, + 0x04, 0x86, 0x01, 0x0e, 0x0f, 0x0a, 0x2b, 0x0a, 0x04, 0x05, 0x01, 0x02, 0x02, 0x12, 0x04, 0x89, + 0x01, 0x02, 0x15, 0x1a, 0x1d, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x70, 0x65, 0x72, + 0x73, 0x69, 0x73, 0x74, 0x65, 0x64, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x6f, 0x6e, 0x6c, 0x79, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x02, 0x01, 0x12, 0x04, 0x89, 0x01, 0x02, + 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x02, 0x02, 0x12, 0x04, 0x89, 0x01, 0x13, 0x14, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +]; +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/flyteidl2.plugins.kubeflow.rs b/gen/rust/src/flyteidl2.plugins.kubeflow.rs new file mode 100644 index 0000000000..23cf078360 --- /dev/null +++ b/gen/rust/src/flyteidl2.plugins.kubeflow.rs @@ -0,0 +1,836 @@ +// @generated +// This file is @generated by prost-build. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct RunPolicy { + /// Defines the policy to kill pods after the job completes. Default to None. + #[prost(enumeration="CleanPodPolicy", tag="1")] + pub clean_pod_policy: i32, + /// TTL to clean up jobs. Default to infinite. + #[prost(int32, tag="2")] + pub ttl_seconds_after_finished: i32, + /// Specifies the duration in seconds relative to the startTime that the job may be active + /// before the system tries to terminate it; value must be positive integer. + #[prost(int32, tag="3")] + pub active_deadline_seconds: i32, + /// Number of retries before marking this job failed. + #[prost(int32, tag="4")] + pub backoff_limit: i32, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum CleanPodPolicy { + CleanpodPolicyNone = 0, + CleanpodPolicyRunning = 1, + CleanpodPolicyAll = 2, +} +impl CleanPodPolicy { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + CleanPodPolicy::CleanpodPolicyNone => "CLEANPOD_POLICY_NONE", + CleanPodPolicy::CleanpodPolicyRunning => "CLEANPOD_POLICY_RUNNING", + CleanPodPolicy::CleanpodPolicyAll => "CLEANPOD_POLICY_ALL", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "CLEANPOD_POLICY_NONE" => Some(Self::CleanpodPolicyNone), + "CLEANPOD_POLICY_RUNNING" => Some(Self::CleanpodPolicyRunning), + "CLEANPOD_POLICY_ALL" => Some(Self::CleanpodPolicyAll), + _ => None, + } + } +} +/// Proto for plugin that enables distributed training using +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DistributedMpiTrainingTask { + /// Worker replicas spec + #[prost(message, optional, tag="1")] + pub worker_replicas: ::core::option::Option, + /// Master replicas spec + #[prost(message, optional, tag="2")] + pub launcher_replicas: ::core::option::Option, + /// RunPolicy encapsulates various runtime policies of the distributed training + /// job, for example how to clean up resources and how long the job can stay + /// active. + #[prost(message, optional, tag="3")] + pub run_policy: ::core::option::Option, + /// Number of slots per worker + #[prost(int32, tag="4")] + pub slots: i32, +} +/// Replica specification for distributed MPI training +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DistributedMpiTrainingReplicaSpec { + /// 1~4 deprecated. Use common instead. + /// Number of replicas + #[deprecated] + #[prost(int32, tag="1")] + pub replicas: i32, + /// Image used for the replica group + #[deprecated] + #[prost(string, tag="2")] + pub image: ::prost::alloc::string::String, + /// Resources required for the replica group + #[deprecated] + #[prost(message, optional, tag="3")] + pub resources: ::core::option::Option, + /// Restart policy determines whether pods will be restarted when they exit + #[deprecated] + #[prost(enumeration="super::RestartPolicy", tag="4")] + pub restart_policy: i32, + /// MPI sometimes requires different command set for different replica groups + #[prost(string, repeated, tag="5")] + pub command: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// The common replica spec + #[prost(message, optional, tag="6")] + pub common: ::core::option::Option, +} +/// Custom proto for torch elastic config for distributed training using +/// +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ElasticConfig { + #[prost(string, tag="1")] + pub rdzv_backend: ::prost::alloc::string::String, + #[prost(int32, tag="2")] + pub min_replicas: i32, + #[prost(int32, tag="3")] + pub max_replicas: i32, + #[prost(int32, tag="4")] + pub nproc_per_node: i32, + #[prost(int32, tag="5")] + pub max_restarts: i32, +} +/// Proto for plugin that enables distributed training using +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DistributedPyTorchTrainingTask { + /// Worker replicas spec + #[prost(message, optional, tag="1")] + pub worker_replicas: ::core::option::Option, + /// Master replicas spec, master replicas can only have 1 replica + #[prost(message, optional, tag="2")] + pub master_replicas: ::core::option::Option, + /// RunPolicy encapsulates various runtime policies of the distributed training + /// job, for example how to clean up resources and how long the job can stay + /// active. + #[prost(message, optional, tag="3")] + pub run_policy: ::core::option::Option, + /// config for an elastic pytorch job + #[prost(message, optional, tag="4")] + pub elastic_config: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DistributedPyTorchTrainingReplicaSpec { + /// 1~4 deprecated. Use common instead. + /// Number of replicas + #[deprecated] + #[prost(int32, tag="1")] + pub replicas: i32, + /// Image used for the replica group + #[deprecated] + #[prost(string, tag="2")] + pub image: ::prost::alloc::string::String, + /// Resources required for the replica group + #[deprecated] + #[prost(message, optional, tag="3")] + pub resources: ::core::option::Option, + /// Restart policy determines whether pods will be restarted when they exit + #[deprecated] + #[prost(enumeration="super::RestartPolicy", tag="4")] + pub restart_policy: i32, + /// The common replica spec + #[prost(message, optional, tag="5")] + pub common: ::core::option::Option, +} +/// Proto for plugin that enables distributed training using +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DistributedTensorflowTrainingTask { + /// Worker replicas spec + #[prost(message, optional, tag="1")] + pub worker_replicas: ::core::option::Option, + /// Parameter server replicas spec + #[prost(message, optional, tag="2")] + pub ps_replicas: ::core::option::Option, + /// Chief replicas spec + #[prost(message, optional, tag="3")] + pub chief_replicas: ::core::option::Option, + /// RunPolicy encapsulates various runtime policies of the distributed training + /// job, for example how to clean up resources and how long the job can stay + /// active. + #[prost(message, optional, tag="4")] + pub run_policy: ::core::option::Option, + /// Evaluator replicas spec + #[prost(message, optional, tag="5")] + pub evaluator_replicas: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DistributedTensorflowTrainingReplicaSpec { + /// 1~4 deprecated. Use common instead. + /// Number of replicas + #[deprecated] + #[prost(int32, tag="1")] + pub replicas: i32, + /// Image used for the replica group + #[deprecated] + #[prost(string, tag="2")] + pub image: ::prost::alloc::string::String, + /// Resources required for the replica group + #[deprecated] + #[prost(message, optional, tag="3")] + pub resources: ::core::option::Option, + /// Restart policy determines whether pods will be restarted when they exit + #[deprecated] + #[prost(enumeration="super::RestartPolicy", tag="4")] + pub restart_policy: i32, + /// The common replica spec + #[prost(message, optional, tag="5")] + pub common: ::core::option::Option, +} +/// Encoded file descriptor set for the `flyteidl2.plugins.kubeflow` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xb8, 0x0b, 0x0a, 0x27, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2f, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, + 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x22, 0xfb, 0x01, 0x0a, 0x09, 0x52, 0x75, 0x6e, + 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x54, 0x0a, 0x10, 0x63, 0x6c, 0x65, 0x61, 0x6e, 0x5f, + 0x70, 0x6f, 0x64, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x2a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x43, 0x6c, + 0x65, 0x61, 0x6e, 0x50, 0x6f, 0x64, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x0e, 0x63, 0x6c, + 0x65, 0x61, 0x6e, 0x50, 0x6f, 0x64, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x3b, 0x0a, 0x1a, + 0x74, 0x74, 0x6c, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x5f, 0x61, 0x66, 0x74, 0x65, + 0x72, 0x5f, 0x66, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x17, 0x74, 0x74, 0x6c, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x41, 0x66, 0x74, 0x65, + 0x72, 0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x12, 0x36, 0x0a, 0x17, 0x61, 0x63, 0x74, + 0x69, 0x76, 0x65, 0x5f, 0x64, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x73, 0x65, 0x63, + 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x15, 0x61, 0x63, 0x74, 0x69, + 0x76, 0x65, 0x44, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, + 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x62, 0x61, 0x63, 0x6b, 0x6f, 0x66, 0x66, 0x5f, 0x6c, 0x69, 0x6d, + 0x69, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x62, 0x61, 0x63, 0x6b, 0x6f, 0x66, + 0x66, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x2a, 0x60, 0x0a, 0x0e, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x50, + 0x6f, 0x64, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x18, 0x0a, 0x14, 0x43, 0x4c, 0x45, 0x41, + 0x4e, 0x50, 0x4f, 0x44, 0x5f, 0x50, 0x4f, 0x4c, 0x49, 0x43, 0x59, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, + 0x10, 0x00, 0x12, 0x1b, 0x0a, 0x17, 0x43, 0x4c, 0x45, 0x41, 0x4e, 0x50, 0x4f, 0x44, 0x5f, 0x50, + 0x4f, 0x4c, 0x49, 0x43, 0x59, 0x5f, 0x52, 0x55, 0x4e, 0x4e, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, + 0x17, 0x0a, 0x13, 0x43, 0x4c, 0x45, 0x41, 0x4e, 0x50, 0x4f, 0x44, 0x5f, 0x50, 0x4f, 0x4c, 0x49, + 0x43, 0x59, 0x5f, 0x41, 0x4c, 0x4c, 0x10, 0x02, 0x42, 0xf7, 0x01, 0x0a, 0x1e, 0x63, 0x6f, 0x6d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x0b, 0x43, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3e, 0x67, 0x69, 0x74, 0x68, + 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x4b, + 0xaa, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xca, 0x02, 0x1a, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0x5c, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xe2, 0x02, 0x26, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x4b, + 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0xea, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, + 0x3a, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x3a, 0x3a, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, + 0x6f, 0x77, 0x4a, 0x8e, 0x06, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x19, 0x01, 0x0a, 0x08, 0x0a, + 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, + 0x23, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x04, 0x00, 0x55, 0x0a, 0x09, 0x0a, 0x02, 0x08, + 0x0b, 0x12, 0x03, 0x04, 0x00, 0x55, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x00, 0x12, 0x04, 0x06, 0x00, + 0x0a, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, 0x03, 0x06, 0x05, 0x13, 0x0a, 0x0b, + 0x0a, 0x04, 0x05, 0x00, 0x02, 0x00, 0x12, 0x03, 0x07, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x07, 0x02, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, + 0x00, 0x02, 0x12, 0x03, 0x07, 0x19, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x01, 0x12, + 0x03, 0x08, 0x02, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x08, + 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x08, 0x1c, 0x1d, + 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x02, 0x12, 0x03, 0x09, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x09, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x09, 0x18, 0x19, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, + 0x04, 0x0c, 0x00, 0x19, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0c, 0x08, + 0x11, 0x0a, 0x58, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0e, 0x02, 0x26, 0x1a, 0x4b, + 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6f, 0x6c, + 0x69, 0x63, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6b, 0x69, 0x6c, 0x6c, 0x20, 0x70, 0x6f, 0x64, 0x73, + 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6a, 0x6f, 0x62, 0x20, 0x63, + 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x73, 0x2e, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, + 0x74, 0x20, 0x74, 0x6f, 0x20, 0x4e, 0x6f, 0x6e, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x0e, 0x02, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x0e, 0x11, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x0e, 0x24, 0x25, 0x0a, 0x39, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x11, + 0x02, 0x27, 0x1a, 0x2c, 0x20, 0x54, 0x54, 0x4c, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6c, 0x65, 0x61, + 0x6e, 0x20, 0x75, 0x70, 0x20, 0x6a, 0x6f, 0x62, 0x73, 0x2e, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, + 0x6c, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x65, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x11, 0x02, 0x07, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x11, 0x08, 0x22, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x11, 0x25, 0x26, 0x0a, 0xb0, 0x01, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x02, 0x12, 0x03, 0x15, 0x02, 0x24, 0x1a, 0xa2, 0x01, 0x20, 0x53, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x20, 0x72, 0x65, + 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6a, 0x6f, 0x62, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, + 0x76, 0x65, 0x0a, 0x20, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x74, 0x72, 0x69, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, + 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x20, 0x69, 0x74, 0x3b, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x70, 0x6f, 0x73, 0x69, 0x74, + 0x69, 0x76, 0x65, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x15, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x15, 0x08, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x02, 0x03, 0x12, 0x03, 0x15, 0x22, 0x23, 0x0a, 0x40, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x03, 0x12, + 0x03, 0x18, 0x02, 0x1a, 0x1a, 0x33, 0x20, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, + 0x20, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73, 0x20, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, + 0x6d, 0x61, 0x72, 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6a, 0x6f, 0x62, + 0x20, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x03, 0x05, 0x12, 0x03, 0x18, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, + 0x12, 0x03, 0x18, 0x08, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, + 0x18, 0x18, 0x19, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xaf, 0x14, 0x0a, 0x24, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x6d, 0x70, 0x69, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, + 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x27, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, + 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xcc, 0x02, 0x0a, 0x1a, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, + 0x62, 0x75, 0x74, 0x65, 0x64, 0x4d, 0x50, 0x49, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, + 0x54, 0x61, 0x73, 0x6b, 0x12, 0x66, 0x0a, 0x0f, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x5f, 0x72, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x3d, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x44, 0x69, 0x73, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x4d, 0x50, 0x49, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, + 0x67, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0e, 0x77, 0x6f, + 0x72, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x6a, 0x0a, 0x11, + 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x3d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, + 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, + 0x4d, 0x50, 0x49, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x52, 0x10, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, + 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x44, 0x0a, 0x0a, 0x72, 0x75, 0x6e, 0x5f, + 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x50, 0x6f, 0x6c, + 0x69, 0x63, 0x79, 0x52, 0x09, 0x72, 0x75, 0x6e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x14, + 0x0a, 0x05, 0x73, 0x6c, 0x6f, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, + 0x6c, 0x6f, 0x74, 0x73, 0x22, 0xbf, 0x02, 0x0a, 0x21, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x64, 0x4d, 0x50, 0x49, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x52, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1e, 0x0a, 0x08, 0x72, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x42, 0x02, 0x18, 0x01, + 0x52, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x18, 0x0a, 0x05, 0x69, 0x6d, + 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x05, 0x69, + 0x6d, 0x61, 0x67, 0x65, 0x12, 0x3b, 0x0a, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x73, 0x42, 0x02, 0x18, 0x01, 0x52, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x73, 0x12, 0x4b, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x70, 0x6f, 0x6c, + 0x69, 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x52, 0x65, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x42, 0x02, 0x18, 0x01, 0x52, + 0x0d, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x18, + 0x0a, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, + 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x12, 0x3c, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x43, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x52, 0x06, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x42, 0xf4, 0x01, 0x0a, 0x1e, 0x63, 0x6f, 0x6d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x08, 0x4d, 0x70, 0x69, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3e, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, + 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x6b, 0x75, 0x62, + 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x4b, 0xaa, 0x02, 0x1a, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, + 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xca, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x4b, 0x75, 0x62, + 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xe2, 0x02, 0x26, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, + 0x6f, 0x77, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, + 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x50, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x3a, 0x3a, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x4a, 0xf5, 0x0b, + 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x2f, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, + 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x23, 0x0a, 0x09, 0x0a, 0x02, + 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x24, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, + 0x00, 0x28, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, 0x31, 0x0a, 0x08, 0x0a, + 0x01, 0x08, 0x12, 0x03, 0x08, 0x00, 0x55, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x08, + 0x00, 0x55, 0x0a, 0x6f, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0b, 0x00, 0x19, 0x01, 0x1a, 0x63, + 0x20, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x64, + 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x20, 0x74, 0x72, 0x61, 0x69, 0x6e, + 0x69, 0x6e, 0x67, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, + 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6b, 0x75, 0x62, + 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x6d, 0x70, 0x69, 0x2d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, + 0x6f, 0x72, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0b, 0x08, 0x22, 0x0a, + 0x23, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0d, 0x02, 0x38, 0x1a, 0x16, 0x20, 0x57, + 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x0d, + 0x02, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0d, 0x24, 0x33, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0d, 0x36, 0x37, 0x0a, 0x23, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x10, 0x02, 0x3a, 0x1a, 0x16, 0x20, 0x4d, 0x61, + 0x73, 0x74, 0x65, 0x72, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x10, 0x02, + 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x10, 0x24, 0x35, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x10, 0x38, 0x39, 0x0a, 0xae, 0x01, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x15, 0x02, 0x1b, 0x1a, 0xa0, 0x01, 0x20, 0x52, + 0x75, 0x6e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x20, 0x65, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, + 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x76, 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x72, 0x75, + 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x65, 0x73, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, + 0x64, 0x20, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x6a, 0x6f, 0x62, 0x2c, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x68, 0x6f, 0x77, + 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6c, 0x65, 0x61, 0x6e, 0x20, 0x75, 0x70, 0x20, 0x72, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x6c, + 0x6f, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6a, 0x6f, 0x62, 0x20, 0x63, 0x61, 0x6e, 0x20, + 0x73, 0x74, 0x61, 0x79, 0x0a, 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x15, 0x02, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x15, 0x0c, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x02, 0x03, 0x12, 0x03, 0x15, 0x19, 0x1a, 0x0a, 0x29, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x03, + 0x12, 0x03, 0x18, 0x02, 0x12, 0x1a, 0x1c, 0x20, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, + 0x66, 0x20, 0x73, 0x6c, 0x6f, 0x74, 0x73, 0x20, 0x70, 0x65, 0x72, 0x20, 0x77, 0x6f, 0x72, 0x6b, + 0x65, 0x72, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x05, 0x12, 0x03, 0x18, 0x02, + 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x18, 0x08, 0x0d, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x18, 0x10, 0x11, 0x0a, 0x40, 0x0a, + 0x02, 0x04, 0x01, 0x12, 0x04, 0x1c, 0x00, 0x2f, 0x01, 0x1a, 0x34, 0x20, 0x52, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, + 0x64, 0x20, 0x4d, 0x50, 0x49, 0x20, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x1c, 0x08, 0x29, 0x0a, 0x46, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x00, 0x12, 0x03, 0x1f, 0x02, 0x29, 0x1a, 0x39, 0x20, 0x31, 0x7e, 0x34, 0x20, 0x64, + 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x2e, 0x20, 0x55, 0x73, 0x65, 0x20, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x2e, 0x0a, 0x20, + 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x1f, 0x02, + 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1f, 0x08, 0x10, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1f, 0x13, 0x14, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x00, 0x08, 0x12, 0x03, 0x1f, 0x15, 0x28, 0x0a, 0x0d, 0x0a, 0x06, 0x04, + 0x01, 0x02, 0x00, 0x08, 0x03, 0x12, 0x03, 0x1f, 0x16, 0x27, 0x0a, 0x2f, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x01, 0x12, 0x03, 0x22, 0x02, 0x27, 0x1a, 0x22, 0x20, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x20, + 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, 0x22, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x22, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x22, 0x11, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x08, 0x12, 0x03, + 0x22, 0x13, 0x26, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x02, 0x01, 0x08, 0x03, 0x12, 0x03, 0x22, + 0x14, 0x25, 0x0a, 0x37, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x25, 0x02, 0x33, 0x1a, + 0x2a, 0x20, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x20, 0x72, 0x65, 0x71, 0x75, + 0x69, 0x72, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x02, 0x06, 0x12, 0x03, 0x25, 0x02, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x25, 0x11, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x25, 0x1d, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x08, 0x12, 0x03, + 0x25, 0x1f, 0x32, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x02, 0x02, 0x08, 0x03, 0x12, 0x03, 0x25, + 0x20, 0x31, 0x0a, 0x56, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x03, 0x12, 0x03, 0x28, 0x02, 0x37, 0x1a, + 0x49, 0x20, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, + 0x20, 0x64, 0x65, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x77, 0x68, 0x65, 0x74, + 0x68, 0x65, 0x72, 0x20, 0x70, 0x6f, 0x64, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, + 0x20, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, + 0x74, 0x68, 0x65, 0x79, 0x20, 0x65, 0x78, 0x69, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x03, 0x06, 0x12, 0x03, 0x28, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, + 0x01, 0x12, 0x03, 0x28, 0x10, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x03, 0x12, + 0x03, 0x28, 0x21, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x08, 0x12, 0x03, 0x28, + 0x23, 0x36, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x02, 0x03, 0x08, 0x03, 0x12, 0x03, 0x28, 0x24, + 0x35, 0x0a, 0x58, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x04, 0x12, 0x03, 0x2b, 0x02, 0x1e, 0x1a, 0x4b, + 0x20, 0x4d, 0x50, 0x49, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x20, 0x72, + 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x73, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, + 0x74, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x65, 0x74, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x72, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x04, 0x04, 0x12, 0x03, 0x2b, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x04, 0x05, 0x12, 0x03, 0x2b, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x01, + 0x12, 0x03, 0x2b, 0x12, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x03, 0x12, 0x03, + 0x2b, 0x1c, 0x1d, 0x0a, 0x26, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x05, 0x12, 0x03, 0x2e, 0x02, 0x1f, + 0x1a, 0x19, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x72, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x05, 0x06, 0x12, 0x03, 0x2e, 0x02, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x05, 0x01, 0x12, 0x03, 0x2e, 0x14, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x03, + 0x12, 0x03, 0x2e, 0x1d, 0x1e, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xef, 0x18, + 0x0a, 0x28, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x70, 0x79, 0x74, + 0x6f, 0x72, 0x63, 0x68, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, + 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x27, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc1, 0x01, 0x0a, 0x0d, + 0x45, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x21, 0x0a, + 0x0c, 0x72, 0x64, 0x7a, 0x76, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0b, 0x72, 0x64, 0x7a, 0x76, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, + 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x69, 0x6e, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x69, 0x6e, 0x52, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x61, 0x78, 0x52, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x24, 0x0a, 0x0e, 0x6e, 0x70, 0x72, 0x6f, 0x63, 0x5f, + 0x70, 0x65, 0x72, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, + 0x6e, 0x70, 0x72, 0x6f, 0x63, 0x50, 0x65, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x21, 0x0a, 0x0c, + 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x73, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x61, 0x78, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x73, 0x22, + 0x90, 0x03, 0x0a, 0x1e, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x50, + 0x79, 0x54, 0x6f, 0x72, 0x63, 0x68, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x54, 0x61, + 0x73, 0x6b, 0x12, 0x6a, 0x0a, 0x0f, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x5f, 0x72, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x41, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, + 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x64, 0x50, 0x79, 0x54, 0x6f, 0x72, 0x63, 0x68, 0x54, 0x72, 0x61, 0x69, 0x6e, + 0x69, 0x6e, 0x67, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0e, + 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x6a, + 0x0a, 0x0f, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x41, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, + 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, + 0x50, 0x79, 0x54, 0x6f, 0x72, 0x63, 0x68, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x52, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0e, 0x6d, 0x61, 0x73, 0x74, + 0x65, 0x72, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x44, 0x0a, 0x0a, 0x72, 0x75, + 0x6e, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x50, + 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x09, 0x72, 0x75, 0x6e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, + 0x12, 0x50, 0x0a, 0x0e, 0x65, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x5f, 0x63, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, + 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x45, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x52, 0x0d, 0x65, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x43, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x22, 0xa9, 0x02, 0x0a, 0x25, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, + 0x65, 0x64, 0x50, 0x79, 0x54, 0x6f, 0x72, 0x63, 0x68, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, + 0x67, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1e, 0x0a, 0x08, + 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x42, 0x02, + 0x18, 0x01, 0x52, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x18, 0x0a, 0x05, + 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, + 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x3b, 0x0a, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x73, 0x42, 0x02, 0x18, 0x01, 0x52, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x73, 0x12, 0x4b, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x70, + 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, + 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x42, 0x02, 0x18, + 0x01, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, + 0x12, 0x3c, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x42, 0xf8, + 0x01, 0x0a, 0x1e, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, + 0x77, 0x42, 0x0c, 0x50, 0x79, 0x74, 0x6f, 0x72, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, + 0x01, 0x5a, 0x3e, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, + 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, + 0x77, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x4b, 0xaa, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x4b, 0x75, 0x62, 0x65, + 0x66, 0x6c, 0x6f, 0x77, 0xca, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, + 0x77, 0xe2, 0x02, 0x26, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x5c, 0x47, + 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1c, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x3a, + 0x3a, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x4a, 0xbb, 0x0e, 0x0a, 0x06, 0x12, 0x04, + 0x00, 0x00, 0x35, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, + 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x23, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, + 0x04, 0x00, 0x24, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x28, 0x0a, 0x09, + 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, 0x31, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, + 0x08, 0x00, 0x55, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x08, 0x00, 0x55, 0x0a, 0xb8, + 0x01, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0c, 0x00, 0x12, 0x01, 0x1a, 0xab, 0x01, 0x20, 0x43, + 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x74, 0x6f, 0x72, 0x63, 0x68, 0x20, 0x65, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x20, 0x63, 0x6f, + 0x6e, 0x66, 0x69, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x64, 0x20, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x75, 0x73, + 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, + 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, + 0x2f, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x2d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, + 0x6f, 0x72, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x2f, 0x70, + 0x6b, 0x67, 0x2f, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, + 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x79, 0x74, 0x6f, 0x72, 0x63, 0x68, 0x5f, + 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x67, 0x6f, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, + 0x12, 0x03, 0x0c, 0x08, 0x15, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0d, + 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x0d, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0d, 0x09, 0x15, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0d, 0x18, 0x19, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0e, 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x01, 0x05, 0x12, 0x03, 0x0e, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x0e, 0x08, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x0e, 0x17, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x0f, 0x02, 0x19, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x0f, 0x02, 0x07, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x0f, 0x08, 0x14, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x0f, 0x17, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x03, 0x12, 0x03, 0x10, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x05, + 0x12, 0x03, 0x10, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, + 0x10, 0x08, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x10, 0x19, + 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, 0x11, 0x02, 0x19, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x05, 0x12, 0x03, 0x11, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x11, 0x08, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x04, 0x03, 0x12, 0x03, 0x11, 0x17, 0x18, 0x0a, 0x73, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, + 0x15, 0x00, 0x23, 0x01, 0x1a, 0x67, 0x20, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x65, 0x6e, 0x61, + 0x62, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, + 0x20, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, + 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x70, 0x79, 0x74, 0x6f, + 0x72, 0x63, 0x68, 0x2d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x15, 0x08, 0x26, 0x0a, 0x23, 0x0a, 0x04, 0x04, 0x01, 0x02, + 0x00, 0x12, 0x03, 0x17, 0x02, 0x3c, 0x1a, 0x16, 0x20, 0x57, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x20, + 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x17, 0x02, 0x27, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x17, 0x28, 0x37, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x17, 0x3a, 0x3b, 0x0a, 0x4c, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, + 0x12, 0x03, 0x1a, 0x02, 0x3c, 0x1a, 0x3f, 0x20, 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x72, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x2c, 0x20, 0x6d, 0x61, + 0x73, 0x74, 0x65, 0x72, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, 0x63, 0x61, + 0x6e, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x31, 0x20, 0x72, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x06, 0x12, + 0x03, 0x1a, 0x02, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x1a, + 0x28, 0x37, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x1a, 0x3a, 0x3b, + 0x0a, 0xae, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x1f, 0x02, 0x1b, 0x1a, 0xa0, + 0x01, 0x20, 0x52, 0x75, 0x6e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x20, 0x65, 0x6e, 0x63, 0x61, + 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x76, 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, + 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x65, + 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x64, 0x20, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x6a, + 0x6f, 0x62, 0x2c, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, + 0x68, 0x6f, 0x77, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6c, 0x65, 0x61, 0x6e, 0x20, 0x75, 0x70, 0x20, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x68, 0x6f, + 0x77, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6a, 0x6f, 0x62, 0x20, 0x63, + 0x61, 0x6e, 0x20, 0x73, 0x74, 0x61, 0x79, 0x0a, 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x06, 0x12, 0x03, 0x1f, 0x02, 0x0b, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x1f, 0x0c, 0x16, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x1f, 0x19, 0x1a, 0x0a, 0x30, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x03, 0x12, 0x03, 0x22, 0x02, 0x23, 0x1a, 0x23, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, + 0x20, 0x70, 0x79, 0x74, 0x6f, 0x72, 0x63, 0x68, 0x20, 0x6a, 0x6f, 0x62, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x03, 0x06, 0x12, 0x03, 0x22, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x03, 0x01, 0x12, 0x03, 0x22, 0x10, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x03, 0x03, 0x12, 0x03, 0x22, 0x21, 0x22, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x25, + 0x00, 0x35, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x25, 0x08, 0x2d, 0x0a, + 0x46, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x28, 0x02, 0x29, 0x1a, 0x39, 0x20, 0x31, + 0x7e, 0x34, 0x20, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x2e, 0x20, 0x55, + 0x73, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, + 0x64, 0x2e, 0x0a, 0x20, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, + 0x12, 0x03, 0x28, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x28, 0x08, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x28, 0x13, + 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x08, 0x12, 0x03, 0x28, 0x15, 0x28, 0x0a, + 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x02, 0x00, 0x08, 0x03, 0x12, 0x03, 0x28, 0x16, 0x27, 0x0a, 0x2f, + 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x2b, 0x02, 0x27, 0x1a, 0x22, 0x20, 0x49, 0x6d, + 0x61, 0x67, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x05, 0x12, 0x03, 0x2b, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x2b, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x2b, 0x11, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x01, 0x08, 0x12, 0x03, 0x2b, 0x13, 0x26, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x02, 0x01, 0x08, + 0x03, 0x12, 0x03, 0x2b, 0x14, 0x25, 0x0a, 0x37, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x02, 0x12, 0x03, + 0x2e, 0x02, 0x33, 0x1a, 0x2a, 0x20, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x20, + 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x06, 0x12, 0x03, 0x2e, 0x02, 0x10, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, 0x2e, 0x11, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x02, 0x03, 0x12, 0x03, 0x2e, 0x1d, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x02, 0x08, 0x12, 0x03, 0x2e, 0x1f, 0x32, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x02, 0x02, 0x08, + 0x03, 0x12, 0x03, 0x2e, 0x20, 0x31, 0x0a, 0x56, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, + 0x31, 0x02, 0x37, 0x1a, 0x49, 0x20, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x70, 0x6f, + 0x6c, 0x69, 0x63, 0x79, 0x20, 0x64, 0x65, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65, 0x73, 0x20, + 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x70, 0x6f, 0x64, 0x73, 0x20, 0x77, 0x69, 0x6c, + 0x6c, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, 0x20, 0x77, + 0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x65, 0x78, 0x69, 0x74, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x06, 0x12, 0x03, 0x31, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x03, 0x01, 0x12, 0x03, 0x31, 0x10, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x03, 0x03, 0x12, 0x03, 0x31, 0x21, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, + 0x08, 0x12, 0x03, 0x31, 0x23, 0x36, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x02, 0x03, 0x08, 0x03, + 0x12, 0x03, 0x31, 0x24, 0x35, 0x0a, 0x26, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x04, 0x12, 0x03, 0x34, + 0x02, 0x1f, 0x1a, 0x19, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, + 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x04, 0x06, 0x12, 0x03, 0x34, 0x02, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x04, 0x01, 0x12, 0x03, 0x34, 0x14, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x04, 0x03, 0x12, 0x03, 0x34, 0x1d, 0x1e, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, + 0x8b, 0x15, 0x0a, 0x2b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x74, + 0x65, 0x6e, 0x73, 0x6f, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, + 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x1a, 0x1a, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x61, 0x73, 0x6b, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x27, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, + 0x6c, 0x6f, 0x77, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x22, 0xa1, 0x04, 0x0a, 0x21, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, + 0x54, 0x65, 0x6e, 0x73, 0x6f, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, + 0x6e, 0x67, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x6d, 0x0a, 0x0f, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, + 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x44, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x44, 0x69, 0x73, + 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x54, 0x65, 0x6e, 0x73, 0x6f, 0x72, 0x66, 0x6c, + 0x6f, 0x77, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0e, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x65, 0x0a, 0x0b, 0x70, 0x73, 0x5f, 0x72, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x44, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, + 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, + 0x74, 0x65, 0x64, 0x54, 0x65, 0x6e, 0x73, 0x6f, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x72, 0x61, + 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, + 0x52, 0x0a, 0x70, 0x73, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x6b, 0x0a, 0x0e, + 0x63, 0x68, 0x69, 0x65, 0x66, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x44, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, + 0x77, 0x2e, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x54, 0x65, 0x6e, + 0x73, 0x6f, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x52, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0d, 0x63, 0x68, 0x69, 0x65, + 0x66, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x44, 0x0a, 0x0a, 0x72, 0x75, 0x6e, + 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0x2e, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x50, 0x6f, + 0x6c, 0x69, 0x63, 0x79, 0x52, 0x09, 0x72, 0x75, 0x6e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, + 0x73, 0x0a, 0x12, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x72, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x44, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, + 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x64, 0x54, 0x65, 0x6e, 0x73, 0x6f, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x72, + 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, + 0x63, 0x52, 0x11, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x73, 0x22, 0xac, 0x02, 0x0a, 0x28, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x64, 0x54, 0x65, 0x6e, 0x73, 0x6f, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x72, + 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, + 0x63, 0x12, 0x1e, 0x0a, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x05, 0x42, 0x02, 0x18, 0x01, 0x52, 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x73, 0x12, 0x18, 0x0a, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x42, 0x02, 0x18, 0x01, 0x52, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x3b, 0x0a, 0x09, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x42, 0x02, 0x18, 0x01, 0x52, 0x09, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x12, 0x4b, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, + 0x63, 0x79, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, + 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x3c, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x52, 0x06, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x42, 0xfb, 0x01, 0x0a, 0x1e, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x6b, 0x75, + 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x0f, 0x54, 0x65, 0x6e, 0x73, 0x6f, 0x72, 0x66, 0x6c, + 0x6f, 0x77, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3e, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x4b, 0xaa, + 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2e, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xca, 0x02, 0x1a, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0x5c, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0xe2, 0x02, 0x26, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x4b, 0x75, + 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, + 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x3a, 0x3a, 0x4b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, + 0x77, 0x4a, 0x81, 0x0b, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x2e, 0x01, 0x0a, 0x08, 0x0a, 0x01, + 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x23, + 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x24, 0x0a, 0x09, 0x0a, 0x02, 0x03, + 0x01, 0x12, 0x03, 0x05, 0x00, 0x28, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, + 0x31, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x08, 0x00, 0x55, 0x0a, 0x09, 0x0a, 0x02, 0x08, + 0x0b, 0x12, 0x03, 0x08, 0x00, 0x55, 0x0a, 0x6e, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0b, 0x00, + 0x1c, 0x01, 0x1a, 0x62, 0x20, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x65, 0x6e, 0x61, 0x62, 0x6c, + 0x65, 0x73, 0x20, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x20, 0x74, + 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x68, 0x74, + 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, + 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x74, 0x66, 0x2d, 0x6f, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x6f, 0x72, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0b, + 0x08, 0x29, 0x0a, 0x23, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0d, 0x02, 0x3f, 0x1a, + 0x16, 0x20, 0x57, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x0d, 0x02, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x0d, 0x2b, 0x3a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0d, 0x3d, + 0x3e, 0x0a, 0x2d, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x10, 0x02, 0x3b, 0x1a, 0x20, + 0x20, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x10, 0x02, 0x2a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x10, 0x2b, 0x36, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x10, 0x39, 0x3a, 0x0a, 0x22, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x02, 0x12, 0x03, 0x13, 0x02, 0x3e, 0x1a, 0x15, 0x20, 0x43, 0x68, 0x69, 0x65, 0x66, 0x20, + 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x13, 0x02, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x13, 0x2b, 0x39, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x02, 0x03, 0x12, 0x03, 0x13, 0x3c, 0x3d, 0x0a, 0xae, 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x03, 0x12, 0x03, 0x18, 0x02, 0x1b, 0x1a, 0xa0, 0x01, 0x20, 0x52, 0x75, 0x6e, 0x50, 0x6f, 0x6c, + 0x69, 0x63, 0x79, 0x20, 0x65, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, + 0x20, 0x76, 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, + 0x20, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x20, 0x74, 0x72, 0x61, + 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x6a, 0x6f, 0x62, 0x2c, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x74, 0x6f, 0x20, 0x63, + 0x6c, 0x65, 0x61, 0x6e, 0x20, 0x75, 0x70, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6a, 0x6f, 0x62, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x73, 0x74, 0x61, 0x79, 0x0a, + 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x03, 0x06, 0x12, 0x03, 0x18, 0x02, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, + 0x12, 0x03, 0x18, 0x0c, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, + 0x18, 0x19, 0x1a, 0x0a, 0x26, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, 0x1b, 0x02, 0x42, + 0x1a, 0x19, 0x20, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x72, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x04, 0x06, 0x12, 0x03, 0x1b, 0x02, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x04, 0x01, 0x12, 0x03, 0x1b, 0x2b, 0x3d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x03, + 0x12, 0x03, 0x1b, 0x40, 0x41, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x1e, 0x00, 0x2e, + 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x1e, 0x08, 0x30, 0x0a, 0x46, 0x0a, + 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x21, 0x02, 0x29, 0x1a, 0x39, 0x20, 0x31, 0x7e, 0x34, + 0x20, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x2e, 0x20, 0x55, 0x73, 0x65, + 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x2e, + 0x0a, 0x20, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x21, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x21, 0x08, + 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x21, 0x13, 0x14, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x08, 0x12, 0x03, 0x21, 0x15, 0x28, 0x0a, 0x0d, 0x0a, + 0x06, 0x04, 0x01, 0x02, 0x00, 0x08, 0x03, 0x12, 0x03, 0x21, 0x16, 0x27, 0x0a, 0x2f, 0x0a, 0x04, + 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x24, 0x02, 0x27, 0x1a, 0x22, 0x20, 0x49, 0x6d, 0x61, 0x67, + 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, 0x24, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x24, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x01, 0x03, 0x12, 0x03, 0x24, 0x11, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x08, + 0x12, 0x03, 0x24, 0x13, 0x26, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x02, 0x01, 0x08, 0x03, 0x12, + 0x03, 0x24, 0x14, 0x25, 0x0a, 0x37, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x27, 0x02, + 0x33, 0x1a, 0x2a, 0x20, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x20, 0x72, 0x65, + 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x02, 0x06, 0x12, 0x03, 0x27, 0x02, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x27, 0x11, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x02, 0x03, 0x12, 0x03, 0x27, 0x1d, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x08, + 0x12, 0x03, 0x27, 0x1f, 0x32, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x02, 0x02, 0x08, 0x03, 0x12, + 0x03, 0x27, 0x20, 0x31, 0x0a, 0x56, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x03, 0x12, 0x03, 0x2a, 0x02, + 0x37, 0x1a, 0x49, 0x20, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x70, 0x6f, 0x6c, 0x69, + 0x63, 0x79, 0x20, 0x64, 0x65, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x77, 0x68, + 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x70, 0x6f, 0x64, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, + 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, 0x20, 0x77, 0x68, 0x65, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x65, 0x78, 0x69, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x03, 0x06, 0x12, 0x03, 0x2a, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x03, 0x01, 0x12, 0x03, 0x2a, 0x10, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, + 0x03, 0x12, 0x03, 0x2a, 0x21, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x08, 0x12, + 0x03, 0x2a, 0x23, 0x36, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x02, 0x03, 0x08, 0x03, 0x12, 0x03, + 0x2a, 0x24, 0x35, 0x0a, 0x26, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x04, 0x12, 0x03, 0x2d, 0x02, 0x1f, + 0x1a, 0x19, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x72, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x04, 0x06, 0x12, 0x03, 0x2d, 0x02, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x04, 0x01, 0x12, 0x03, 0x2d, 0x14, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x03, + 0x12, 0x03, 0x2d, 0x1d, 0x1e, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +]; +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/flyteidl2.plugins.rs b/gen/rust/src/flyteidl2.plugins.rs new file mode 100644 index 0000000000..8a6cfcf258 --- /dev/null +++ b/gen/rust/src/flyteidl2.plugins.rs @@ -0,0 +1,1368 @@ +// @generated +// This file is @generated by prost-build. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CommonReplicaSpec { + /// Number of replicas + #[prost(int32, tag="1")] + pub replicas: i32, + /// Image used for the replica group + #[prost(string, tag="2")] + pub image: ::prost::alloc::string::String, + /// Resources required for the replica group + #[prost(message, optional, tag="3")] + pub resources: ::core::option::Option, + /// RestartPolicy determines whether pods will be restarted when they exit + #[prost(enumeration="RestartPolicy", tag="4")] + pub restart_policy: i32, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum RestartPolicy { + Never = 0, + OnFailure = 1, + Always = 2, +} +impl RestartPolicy { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + RestartPolicy::Never => "RESTART_POLICY_NEVER", + RestartPolicy::OnFailure => "RESTART_POLICY_ON_FAILURE", + RestartPolicy::Always => "RESTART_POLICY_ALWAYS", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "RESTART_POLICY_NEVER" => Some(Self::Never), + "RESTART_POLICY_ON_FAILURE" => Some(Self::OnFailure), + "RESTART_POLICY_ALWAYS" => Some(Self::Always), + _ => None, + } + } +} +/// Custom Proto for Dask Plugin. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DaskJob { + /// Spec for the scheduler pod. + #[prost(message, optional, tag="1")] + pub scheduler: ::core::option::Option, + /// Spec of the default worker group. + #[prost(message, optional, tag="2")] + pub workers: ::core::option::Option, +} +/// Specification for the scheduler pod. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DaskScheduler { + /// Optional image to use. If unset, will use the default image. + #[prost(string, tag="1")] + pub image: ::prost::alloc::string::String, + /// Resources assigned to the scheduler pod. + #[prost(message, optional, tag="2")] + pub resources: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DaskWorkerGroup { + /// Number of workers in the group. + #[prost(uint32, tag="1")] + pub number_of_workers: u32, + /// Optional image to use for the pods of the worker group. If unset, will use the default image. + #[prost(string, tag="2")] + pub image: ::prost::alloc::string::String, + /// Resources assigned to the all pods of the worker group. + /// As per + /// it is advised to only set limits. If requests are not explicitly set, the plugin will make + /// sure to set requests==limits. + /// The plugin sets ` --memory-limit` as well as `--nthreads` for the workers according to the limit. + #[prost(message, optional, tag="3")] + pub resources: ::core::option::Option, +} +/// MPI operator proposal +/// Custom proto for plugin that enables distributed training using +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct DistributedMpiTrainingTask { + /// number of worker spawned in the cluster for this job + #[prost(int32, tag="1")] + pub num_workers: i32, + /// number of launcher replicas spawned in the cluster for this job + /// The launcher pod invokes mpirun and communicates with worker pods through MPI. + #[prost(int32, tag="2")] + pub num_launcher_replicas: i32, + /// number of slots per worker used in hostfile. + /// The available slots (GPUs) in each pod. + #[prost(int32, tag="3")] + pub slots: i32, +} +/// This message works with the 'presto' task type in the SDK and is the object that will be in the 'custom' field +/// of a Presto task's TaskTemplate +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PrestoQuery { + #[prost(string, tag="1")] + pub routing_group: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub catalog: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub schema: ::prost::alloc::string::String, + #[prost(string, tag="4")] + pub statement: ::prost::alloc::string::String, +} +/// Custom proto for torch elastic config for distributed training using +/// +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ElasticConfig { + #[prost(string, tag="1")] + pub rdzv_backend: ::prost::alloc::string::String, + #[prost(int32, tag="2")] + pub min_replicas: i32, + #[prost(int32, tag="3")] + pub max_replicas: i32, + #[prost(int32, tag="4")] + pub nproc_per_node: i32, + #[prost(int32, tag="5")] + pub max_restarts: i32, +} +/// Custom proto for plugin that enables distributed training using +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DistributedPyTorchTrainingTask { + /// number of worker replicas spawned in the cluster for this job + #[prost(int32, tag="1")] + pub workers: i32, + /// config for an elastic pytorch job + #[prost(message, optional, tag="2")] + pub elastic_config: ::core::option::Option, +} +/// Defines a query to execute on a hive cluster. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HiveQuery { + #[prost(string, tag="1")] + pub query: ::prost::alloc::string::String, + #[prost(uint32, tag="2")] + pub timeout_sec: u32, + #[prost(uint32, tag="3")] + pub retry_count: u32, +} +/// Defines a collection of hive queries. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HiveQueryCollection { + #[prost(message, repeated, tag="2")] + pub queries: ::prost::alloc::vec::Vec, +} +/// This message works with the 'hive' task type in the SDK and is the object that will be in the 'custom' field +/// of a hive task's TaskTemplate +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QuboleHiveJob { + #[prost(string, tag="1")] + pub cluster_label: ::prost::alloc::string::String, + #[deprecated] + #[prost(message, optional, tag="2")] + pub query_collection: ::core::option::Option, + #[prost(string, repeated, tag="3")] + pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(message, optional, tag="4")] + pub query: ::core::option::Option, +} +/// RayJobSpec defines the desired state of RayJob +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RayJob { + /// RayClusterSpec is the cluster template to run the job + #[prost(message, optional, tag="1")] + pub ray_cluster: ::core::option::Option, + /// runtime_env is base64 encoded. + /// Ray runtime environments: + #[deprecated] + #[prost(string, tag="2")] + pub runtime_env: ::prost::alloc::string::String, + /// shutdown_after_job_finishes specifies whether the RayCluster should be deleted after the RayJob finishes. + #[prost(bool, tag="3")] + pub shutdown_after_job_finishes: bool, + /// ttl_seconds_after_finished specifies the number of seconds after which the RayCluster will be deleted after the RayJob finishes. + #[prost(int32, tag="4")] + pub ttl_seconds_after_finished: i32, + /// RuntimeEnvYAML represents the runtime environment configuration + /// provided as a multi-line YAML string. + #[prost(string, tag="5")] + pub runtime_env_yaml: ::prost::alloc::string::String, +} +/// Define Ray cluster defines the desired state of RayCluster +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RayCluster { + /// HeadGroupSpecs are the spec for the head pod + #[prost(message, optional, tag="1")] + pub head_group_spec: ::core::option::Option, + /// WorkerGroupSpecs are the specs for the worker pods + #[prost(message, repeated, tag="2")] + pub worker_group_spec: ::prost::alloc::vec::Vec, + /// Whether to enable autoscaling. + #[prost(bool, tag="3")] + pub enable_autoscaling: bool, +} +/// HeadGroupSpec are the spec for the head pod +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HeadGroupSpec { + /// Optional. RayStartParams are the params of the start command: address, object-store-memory. + /// Refer to + #[prost(map="string, string", tag="1")] + pub ray_start_params: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + /// Pod Spec for the ray head pod + #[prost(message, optional, tag="2")] + pub k8s_pod: ::core::option::Option, +} +/// WorkerGroupSpec are the specs for the worker pods +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorkerGroupSpec { + /// Required. RayCluster can have multiple worker groups, and it distinguishes them by name + #[prost(string, tag="1")] + pub group_name: ::prost::alloc::string::String, + /// Required. Desired replicas of the worker group. Defaults to 1. + #[prost(int32, tag="2")] + pub replicas: i32, + /// Optional. Min replicas of the worker group. MinReplicas defaults to 1. + #[prost(int32, tag="3")] + pub min_replicas: i32, + /// Optional. Max replicas of the worker group. MaxReplicas defaults to maxInt32 + #[prost(int32, tag="4")] + pub max_replicas: i32, + /// Optional. RayStartParams are the params of the start command: address, object-store-memory. + /// Refer to + #[prost(map="string, string", tag="5")] + pub ray_start_params: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + /// Pod Spec for ray worker pods + #[prost(message, optional, tag="6")] + pub k8s_pod: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct SparkApplication { +} +/// Nested message and enum types in `SparkApplication`. +pub mod spark_application { + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum Type { + Python = 0, + Java = 1, + Scala = 2, + R = 3, + } + impl Type { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Type::Python => "PYTHON", + Type::Java => "JAVA", + Type::Scala => "SCALA", + Type::R => "R", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "PYTHON" => Some(Self::Python), + "JAVA" => Some(Self::Java), + "SCALA" => Some(Self::Scala), + "R" => Some(Self::R), + _ => None, + } + } + } +} +/// Custom Proto for Spark Plugin. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SparkJob { + #[prost(enumeration="spark_application::Type", tag="1")] + pub application_type: i32, + #[prost(string, tag="2")] + pub main_application_file: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub main_class: ::prost::alloc::string::String, + #[prost(map="string, string", tag="4")] + pub spark_conf: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + #[prost(map="string, string", tag="5")] + pub hadoop_conf: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + /// Executor path for Python jobs. + #[prost(string, tag="6")] + pub executor_path: ::prost::alloc::string::String, + /// Databricks job configuration. + /// Config structure can be found here. + #[prost(message, optional, tag="7")] + pub databricks_conf: ::core::option::Option, + /// Databricks access token. + /// This token can be set in either flytepropeller or flytekit. + #[prost(string, tag="8")] + pub databricks_token: ::prost::alloc::string::String, + /// Domain name of your deployment. Use the form .cloud.databricks.com. + /// This instance name can be set in either flytepropeller or flytekit. + #[prost(string, tag="9")] + pub databricks_instance: ::prost::alloc::string::String, + /// Pod Spec for the Spark driver pod + #[prost(message, optional, tag="10")] + pub driver_pod: ::core::option::Option, + /// Pod Spec for the Spark executor pod + #[prost(message, optional, tag="11")] + pub executor_pod: ::core::option::Option, +} +/// Custom proto for plugin that enables distributed training using +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct DistributedTensorflowTrainingTask { + /// number of worker replicas spawned in the cluster for this job + #[prost(int32, tag="1")] + pub workers: i32, + /// PS -> Parameter server + /// number of ps replicas spawned in the cluster for this job + #[prost(int32, tag="2")] + pub ps_replicas: i32, + /// number of chief replicas spawned in the cluster for this job + #[prost(int32, tag="3")] + pub chief_replicas: i32, + /// number of evaluator replicas spawned in the cluster for this job + #[prost(int32, tag="4")] + pub evaluator_replicas: i32, +} +/// Encoded file descriptor set for the `flyteidl2.plugins` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xbf, 0x09, 0x0a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x22, 0xc7, 0x01, 0x0a, 0x11, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x72, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x37, 0x0a, 0x09, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x52, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x73, 0x12, 0x47, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x70, + 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, + 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x0d, 0x72, + 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2a, 0x63, 0x0a, 0x0d, + 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x18, 0x0a, + 0x14, 0x52, 0x45, 0x53, 0x54, 0x41, 0x52, 0x54, 0x5f, 0x50, 0x4f, 0x4c, 0x49, 0x43, 0x59, 0x5f, + 0x4e, 0x45, 0x56, 0x45, 0x52, 0x10, 0x00, 0x12, 0x1d, 0x0a, 0x19, 0x52, 0x45, 0x53, 0x54, 0x41, + 0x52, 0x54, 0x5f, 0x50, 0x4f, 0x4c, 0x49, 0x43, 0x59, 0x5f, 0x4f, 0x4e, 0x5f, 0x46, 0x41, 0x49, + 0x4c, 0x55, 0x52, 0x45, 0x10, 0x01, 0x12, 0x19, 0x0a, 0x15, 0x52, 0x45, 0x53, 0x54, 0x41, 0x52, + 0x54, 0x5f, 0x50, 0x4f, 0x4c, 0x49, 0x43, 0x59, 0x5f, 0x41, 0x4c, 0x57, 0x41, 0x59, 0x53, 0x10, + 0x02, 0x42, 0xc0, 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x42, 0x0b, 0x43, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, + 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x58, 0xaa, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xca, 0x02, 0x11, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xe2, + 0x02, 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, + 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x50, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x73, 0x4a, 0xf3, 0x04, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x1a, 0x01, 0x0a, + 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, + 0x02, 0x00, 0x1a, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x24, 0x0a, 0x08, + 0x0a, 0x01, 0x08, 0x12, 0x03, 0x06, 0x00, 0x4c, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, + 0x06, 0x00, 0x4c, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x00, 0x12, 0x04, 0x08, 0x00, 0x0c, 0x01, 0x0a, + 0x0a, 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, 0x03, 0x08, 0x05, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x05, + 0x00, 0x02, 0x00, 0x12, 0x03, 0x09, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x09, 0x02, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x02, 0x12, + 0x03, 0x09, 0x19, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0a, 0x02, + 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0a, 0x02, 0x1b, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x0a, 0x1e, 0x1f, 0x0a, 0x0b, 0x0a, + 0x04, 0x05, 0x00, 0x02, 0x02, 0x12, 0x03, 0x0b, 0x02, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x0b, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, + 0x02, 0x12, 0x03, 0x0b, 0x1a, 0x1b, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0e, 0x00, + 0x1a, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0e, 0x08, 0x19, 0x0a, 0x21, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x10, 0x02, 0x15, 0x1a, 0x14, 0x20, 0x4e, 0x75, + 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x10, 0x02, 0x07, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x10, 0x08, 0x10, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x10, 0x13, 0x14, 0x0a, 0x2f, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x01, 0x12, 0x03, 0x13, 0x02, 0x13, 0x1a, 0x22, 0x20, 0x49, 0x6d, 0x61, 0x67, 0x65, + 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x13, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x13, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x13, 0x11, 0x12, 0x0a, 0x37, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, + 0x16, 0x02, 0x1f, 0x1a, 0x2a, 0x20, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x20, + 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x16, 0x02, 0x10, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x16, 0x11, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x16, 0x1d, 0x1e, 0x0a, 0x55, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x03, 0x12, 0x03, 0x19, 0x02, 0x23, 0x1a, 0x48, 0x20, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x20, 0x64, 0x65, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65, + 0x73, 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x70, 0x6f, 0x64, 0x73, 0x20, 0x77, + 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, + 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x65, 0x78, 0x69, 0x74, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x06, 0x12, 0x03, 0x19, 0x02, 0x0f, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x19, 0x10, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x19, 0x21, 0x22, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x33, 0x0a, 0x8d, 0x0f, 0x0a, 0x1c, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x64, 0x61, 0x73, 0x6b, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x22, 0x87, 0x01, 0x0a, 0x07, 0x44, 0x61, 0x73, 0x6b, 0x4a, 0x6f, 0x62, 0x12, 0x3e, + 0x0a, 0x09, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x44, 0x61, 0x73, 0x6b, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, + 0x6c, 0x65, 0x72, 0x52, 0x09, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x72, 0x12, 0x3c, + 0x0a, 0x07, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2e, 0x44, 0x61, 0x73, 0x6b, 0x57, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x52, 0x07, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x73, 0x22, 0x5e, 0x0a, 0x0d, + 0x44, 0x61, 0x73, 0x6b, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x72, 0x12, 0x14, 0x0a, + 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x69, 0x6d, + 0x61, 0x67, 0x65, 0x12, 0x37, 0x0a, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x73, 0x52, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x22, 0x8c, 0x01, 0x0a, + 0x0f, 0x44, 0x61, 0x73, 0x6b, 0x57, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x12, 0x2a, 0x0a, 0x11, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x5f, 0x6f, 0x66, 0x5f, 0x77, 0x6f, + 0x72, 0x6b, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0f, 0x6e, 0x75, 0x6d, + 0x62, 0x65, 0x72, 0x4f, 0x66, 0x57, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x73, 0x12, 0x14, 0x0a, 0x05, + 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x69, 0x6d, 0x61, + 0x67, 0x65, 0x12, 0x37, 0x0a, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, + 0x52, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x42, 0xbe, 0x01, 0x0a, 0x15, + 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x73, 0x42, 0x09, 0x44, 0x61, 0x73, 0x6b, 0x50, 0x72, 0x6f, 0x74, 0x6f, + 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, + 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x58, 0xaa, + 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0xca, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, + 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xe2, 0x02, 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x4a, 0xfb, 0x09, 0x0a, + 0x06, 0x12, 0x04, 0x00, 0x00, 0x27, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, + 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x1a, 0x0a, 0x09, 0x0a, 0x02, 0x03, + 0x00, 0x12, 0x03, 0x04, 0x00, 0x24, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x06, 0x00, 0x4c, + 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x06, 0x00, 0x4c, 0x0a, 0x2b, 0x0a, 0x02, 0x04, + 0x00, 0x12, 0x04, 0x09, 0x00, 0x0f, 0x01, 0x1a, 0x1f, 0x20, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, + 0x20, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x44, 0x61, 0x73, 0x6b, 0x20, + 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, + 0x03, 0x09, 0x08, 0x0f, 0x0a, 0x2a, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0b, 0x02, + 0x1e, 0x1a, 0x1d, 0x20, 0x53, 0x70, 0x65, 0x63, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x72, 0x20, 0x70, 0x6f, 0x64, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x0b, 0x02, 0x0f, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0b, 0x10, 0x19, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0b, 0x1c, 0x1d, 0x0a, 0x30, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x01, 0x12, 0x03, 0x0e, 0x02, 0x1e, 0x1a, 0x23, 0x20, 0x53, 0x70, 0x65, 0x63, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x77, 0x6f, + 0x72, 0x6b, 0x65, 0x72, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x0e, 0x02, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x0e, 0x12, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x0e, 0x1c, 0x1d, 0x0a, 0x32, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x12, 0x00, + 0x18, 0x01, 0x1a, 0x26, 0x20, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x63, 0x68, 0x65, 0x64, + 0x75, 0x6c, 0x65, 0x72, 0x20, 0x70, 0x6f, 0x64, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, + 0x01, 0x12, 0x03, 0x12, 0x08, 0x15, 0x0a, 0x4b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, + 0x14, 0x02, 0x13, 0x1a, 0x3e, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x69, + 0x6d, 0x61, 0x67, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, + 0x75, 0x6e, 0x73, 0x65, 0x74, 0x2c, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x14, 0x02, + 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x14, 0x09, 0x0e, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x14, 0x11, 0x12, 0x0a, 0x37, 0x0a, + 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x17, 0x02, 0x29, 0x1a, 0x2a, 0x20, 0x52, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x20, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x72, + 0x20, 0x70, 0x6f, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x06, 0x12, + 0x03, 0x17, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x17, + 0x1b, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x17, 0x27, 0x28, + 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x1a, 0x00, 0x27, 0x01, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x02, 0x01, 0x12, 0x03, 0x1a, 0x08, 0x17, 0x0a, 0x2e, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, + 0x12, 0x03, 0x1c, 0x02, 0x1f, 0x1a, 0x21, 0x20, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, + 0x66, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, + 0x05, 0x12, 0x03, 0x1c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x1c, 0x09, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1c, + 0x1d, 0x1e, 0x0a, 0x6c, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x1f, 0x02, 0x13, 0x1a, + 0x5f, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, + 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x70, 0x6f, 0x64, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6b, + 0x65, 0x72, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x75, 0x6e, 0x73, + 0x65, 0x74, 0x2c, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x05, 0x12, 0x03, 0x1f, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x1f, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x1f, 0x11, 0x12, 0x0a, 0x83, 0x03, 0x0a, 0x04, 0x04, + 0x02, 0x02, 0x02, 0x12, 0x03, 0x26, 0x02, 0x29, 0x1a, 0xf5, 0x02, 0x20, 0x52, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x73, 0x20, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x74, + 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x70, 0x6f, 0x64, 0x73, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x20, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x2e, 0x0a, 0x20, 0x41, 0x73, 0x20, 0x70, 0x65, 0x72, 0x20, 0x68, 0x74, 0x74, 0x70, + 0x73, 0x3a, 0x2f, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x2e, 0x64, + 0x61, 0x73, 0x6b, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x65, 0x6e, 0x2f, 0x6c, 0x61, 0x74, 0x65, 0x73, + 0x74, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x2e, 0x68, 0x74, + 0x6d, 0x6c, 0x3f, 0x68, 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x3d, 0x6c, 0x69, 0x6d, + 0x69, 0x74, 0x23, 0x62, 0x65, 0x73, 0x74, 0x2d, 0x70, 0x72, 0x61, 0x63, 0x74, 0x69, 0x63, 0x65, + 0x73, 0x0a, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x64, 0x76, 0x69, 0x73, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6c, 0x69, 0x6d, + 0x69, 0x74, 0x73, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, + 0x20, 0x61, 0x72, 0x65, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x78, 0x70, 0x6c, 0x69, 0x63, 0x69, + 0x74, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6d, 0x61, 0x6b, 0x65, 0x0a, 0x20, 0x73, + 0x75, 0x72, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x65, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x73, 0x3d, 0x3d, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x2e, 0x0a, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x20, 0x73, 0x65, 0x74, 0x73, 0x20, 0x60, 0x20, + 0x2d, 0x2d, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x2d, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x60, 0x20, + 0x61, 0x73, 0x20, 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x61, 0x73, 0x20, 0x60, 0x2d, 0x2d, 0x6e, 0x74, + 0x68, 0x72, 0x65, 0x61, 0x64, 0x73, 0x60, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x73, 0x20, 0x61, 0x63, 0x63, 0x6f, 0x72, 0x64, 0x69, 0x6e, + 0x67, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x06, 0x12, 0x03, 0x26, 0x02, 0x1a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, 0x26, 0x1b, 0x24, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x02, 0x03, 0x12, 0x03, 0x26, 0x27, 0x28, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x33, 0x0a, 0xf3, 0x08, 0x0a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x6d, 0x70, 0x69, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x12, 0x11, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x73, 0x22, 0x87, 0x01, 0x0a, 0x1a, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, + 0x62, 0x75, 0x74, 0x65, 0x64, 0x4d, 0x50, 0x49, 0x54, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, + 0x54, 0x61, 0x73, 0x6b, 0x12, 0x1f, 0x0a, 0x0b, 0x6e, 0x75, 0x6d, 0x5f, 0x77, 0x6f, 0x72, 0x6b, + 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x6e, 0x75, 0x6d, 0x57, 0x6f, + 0x72, 0x6b, 0x65, 0x72, 0x73, 0x12, 0x32, 0x0a, 0x15, 0x6e, 0x75, 0x6d, 0x5f, 0x6c, 0x61, 0x75, + 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x13, 0x6e, 0x75, 0x6d, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, + 0x72, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x6c, 0x6f, + 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x6c, 0x6f, 0x74, 0x73, 0x42, + 0xbd, 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x42, 0x08, 0x4d, 0x70, 0x69, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, + 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xa2, 0x02, 0x03, 0x46, + 0x50, 0x58, 0xaa, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xca, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xe2, 0x02, 0x1d, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x47, + 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x12, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x4a, + 0xee, 0x05, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x13, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, + 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x1a, 0x0a, 0x08, + 0x0a, 0x01, 0x08, 0x12, 0x03, 0x04, 0x00, 0x4c, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, + 0x04, 0x00, 0x4c, 0x0a, 0xe3, 0x01, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x08, 0x00, 0x13, 0x01, + 0x1a, 0xd6, 0x01, 0x20, 0x4d, 0x50, 0x49, 0x20, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, + 0x20, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, + 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6b, 0x75, 0x62, + 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x2f, + 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x70, + 0x6f, 0x73, 0x61, 0x6c, 0x73, 0x2f, 0x6d, 0x70, 0x69, 0x2d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, + 0x6f, 0x72, 0x2d, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x2e, 0x6d, 0x64, 0x0a, 0x20, + 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x65, 0x6e, 0x61, + 0x62, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, + 0x20, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, + 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x6d, 0x70, 0x69, 0x2d, + 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, + 0x12, 0x03, 0x08, 0x08, 0x22, 0x0a, 0x43, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0a, + 0x02, 0x18, 0x1a, 0x36, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x77, + 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x20, 0x73, 0x70, 0x61, 0x77, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6a, 0x6f, 0x62, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x05, 0x12, 0x03, 0x0a, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x0a, 0x08, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x0a, 0x16, 0x17, 0x0a, 0x9f, 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0e, + 0x02, 0x22, 0x1a, 0x91, 0x01, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, + 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x73, 0x20, 0x73, 0x70, 0x61, 0x77, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x6a, 0x6f, 0x62, 0x0a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x75, 0x6e, 0x63, + 0x68, 0x65, 0x72, 0x20, 0x70, 0x6f, 0x64, 0x20, 0x69, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x73, 0x20, + 0x6d, 0x70, 0x69, 0x72, 0x75, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, + 0x6e, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x77, 0x6f, 0x72, + 0x6b, 0x65, 0x72, 0x20, 0x70, 0x6f, 0x64, 0x73, 0x20, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, + 0x20, 0x4d, 0x50, 0x49, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, + 0x03, 0x0e, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0e, + 0x08, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x0e, 0x20, 0x21, + 0x0a, 0x64, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x12, 0x02, 0x12, 0x1a, 0x57, 0x20, + 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x6c, 0x6f, 0x74, 0x73, 0x20, + 0x70, 0x65, 0x72, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, + 0x69, 0x6e, 0x20, 0x68, 0x6f, 0x73, 0x74, 0x66, 0x69, 0x6c, 0x65, 0x2e, 0x0a, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x73, 0x6c, 0x6f, 0x74, + 0x73, 0x20, 0x28, 0x47, 0x50, 0x55, 0x73, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x65, 0x61, 0x63, 0x68, + 0x20, 0x70, 0x6f, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, + 0x03, 0x12, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x12, + 0x08, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x12, 0x10, 0x11, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xc0, 0x06, 0x0a, 0x1e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x70, + 0x72, 0x65, 0x73, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x22, 0x82, + 0x01, 0x0a, 0x0b, 0x50, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x23, + 0x0a, 0x0d, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x12, 0x16, 0x0a, + 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, + 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, + 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, + 0x65, 0x6e, 0x74, 0x42, 0xc0, 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x42, 0x0b, 0x50, + 0x72, 0x65, 0x73, 0x74, 0x6f, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, + 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, + 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, + 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x58, 0xaa, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xca, 0x02, 0x11, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0xe2, 0x02, 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0xea, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x50, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x4a, 0xba, 0x03, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x0d, + 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, + 0x12, 0x03, 0x02, 0x00, 0x1a, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x04, 0x00, 0x4c, 0x0a, + 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x04, 0x00, 0x4c, 0x0a, 0x9e, 0x01, 0x0a, 0x02, 0x04, + 0x00, 0x12, 0x04, 0x08, 0x00, 0x0d, 0x01, 0x1a, 0x91, 0x01, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x73, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x27, 0x70, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x27, 0x20, + 0x74, 0x61, 0x73, 0x6b, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x53, 0x44, 0x4b, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6c, 0x6c, + 0x20, 0x62, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x27, 0x63, 0x75, 0x73, 0x74, + 0x6f, 0x6d, 0x27, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x0a, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, + 0x50, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x27, 0x73, 0x20, 0x54, 0x61, + 0x73, 0x6b, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x00, 0x01, 0x12, 0x03, 0x08, 0x08, 0x13, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, + 0x03, 0x09, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x09, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x09, 0x09, 0x16, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x09, 0x19, 0x1a, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0a, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x0a, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x0a, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x0a, 0x13, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x0b, + 0x02, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x0b, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x0b, 0x09, 0x0f, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x0b, 0x12, 0x13, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x0c, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x03, 0x05, 0x12, 0x03, 0x0c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, + 0x12, 0x03, 0x0c, 0x09, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, + 0x0c, 0x15, 0x16, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xc7, 0x0b, 0x0a, 0x1f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0x2f, 0x70, 0x79, 0x74, 0x6f, 0x72, 0x63, 0x68, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, + 0x11, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x73, 0x22, 0xc1, 0x01, 0x0a, 0x0d, 0x45, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x43, 0x6f, + 0x6e, 0x66, 0x69, 0x67, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x64, 0x7a, 0x76, 0x5f, 0x62, 0x61, 0x63, + 0x6b, 0x65, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x72, 0x64, 0x7a, 0x76, + 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x69, 0x6e, 0x5f, 0x72, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, + 0x69, 0x6e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x61, + 0x78, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x0b, 0x6d, 0x61, 0x78, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x24, 0x0a, + 0x0e, 0x6e, 0x70, 0x72, 0x6f, 0x63, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x6e, 0x70, 0x72, 0x6f, 0x63, 0x50, 0x65, 0x72, 0x4e, + 0x6f, 0x64, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x61, 0x78, 0x52, 0x65, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x73, 0x22, 0x83, 0x01, 0x0a, 0x1e, 0x44, 0x69, 0x73, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x50, 0x79, 0x54, 0x6f, 0x72, 0x63, 0x68, 0x54, 0x72, 0x61, + 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x18, 0x0a, 0x07, 0x77, 0x6f, 0x72, + 0x6b, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x77, 0x6f, 0x72, 0x6b, + 0x65, 0x72, 0x73, 0x12, 0x47, 0x0a, 0x0e, 0x65, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x5f, 0x63, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, + 0x45, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0d, 0x65, + 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x42, 0xc1, 0x01, 0x0a, + 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x42, 0x0c, 0x50, 0x79, 0x74, 0x6f, 0x72, 0x63, 0x68, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xa2, 0x02, 0x03, + 0x46, 0x50, 0x58, 0xaa, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xca, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xe2, 0x02, 0x1d, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, + 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x12, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0x4a, 0xfa, 0x06, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x17, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, + 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x1a, 0x0a, + 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x04, 0x00, 0x4c, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, + 0x03, 0x04, 0x00, 0x4c, 0x0a, 0xd4, 0x01, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x08, 0x00, 0x0e, + 0x01, 0x1a, 0xc7, 0x01, 0x20, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x6f, 0x72, 0x63, 0x68, 0x20, 0x65, 0x6c, 0x61, 0x73, + 0x74, 0x69, 0x63, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x64, + 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x20, 0x74, 0x72, 0x61, 0x69, 0x6e, + 0x69, 0x6e, 0x67, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, + 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6b, 0x75, + 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x2f, 0x62, + 0x6c, 0x6f, 0x62, 0x2f, 0x65, 0x33, 0x31, 0x64, 0x31, 0x31, 0x66, 0x61, 0x61, 0x39, 0x66, 0x36, + 0x63, 0x65, 0x35, 0x31, 0x31, 0x31, 0x62, 0x36, 0x30, 0x63, 0x30, 0x31, 0x30, 0x37, 0x39, 0x64, + 0x33, 0x39, 0x32, 0x39, 0x35, 0x35, 0x38, 0x39, 0x65, 0x30, 0x65, 0x66, 0x2f, 0x70, 0x6b, 0x67, + 0x2f, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x6f, + 0x72, 0x67, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x79, 0x74, 0x6f, 0x72, 0x63, 0x68, 0x5f, 0x74, 0x79, + 0x70, 0x65, 0x73, 0x2e, 0x67, 0x6f, 0x23, 0x4c, 0x39, 0x38, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x00, 0x01, 0x12, 0x03, 0x08, 0x08, 0x15, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, + 0x03, 0x09, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x09, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x09, 0x09, 0x15, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x09, 0x18, 0x19, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0a, 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x0a, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x0a, 0x08, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x0a, 0x17, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x0b, + 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x0b, 0x02, 0x07, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x0b, 0x08, 0x14, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x0b, 0x17, 0x18, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x0c, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x03, 0x05, 0x12, 0x03, 0x0c, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, + 0x12, 0x03, 0x0c, 0x08, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, + 0x0c, 0x19, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, 0x0d, 0x02, 0x19, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x05, 0x12, 0x03, 0x0d, 0x02, 0x07, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x0d, 0x08, 0x14, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, 0x0d, 0x17, 0x18, 0x0a, 0x71, 0x0a, 0x02, 0x04, 0x01, + 0x12, 0x04, 0x11, 0x00, 0x17, 0x01, 0x1a, 0x65, 0x20, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x69, + 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x20, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x69, + 0x6e, 0x67, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, + 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6b, 0x75, 0x62, 0x65, + 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x11, 0x08, 0x26, 0x0a, 0x4c, 0x0a, 0x04, 0x04, 0x01, 0x02, + 0x00, 0x12, 0x03, 0x13, 0x02, 0x14, 0x1a, 0x3f, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, + 0x6f, 0x66, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x73, 0x20, 0x73, 0x70, 0x61, 0x77, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x6a, 0x6f, 0x62, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, + 0x12, 0x03, 0x13, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x13, 0x08, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x13, 0x12, + 0x13, 0x0a, 0x30, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x16, 0x02, 0x23, 0x1a, 0x23, + 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6e, 0x20, 0x65, + 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x20, 0x70, 0x79, 0x74, 0x6f, 0x72, 0x63, 0x68, 0x20, 0x6a, + 0x6f, 0x62, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x06, 0x12, 0x03, 0x16, 0x02, + 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x16, 0x10, 0x1e, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x16, 0x21, 0x22, 0x62, 0x06, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xdf, 0x0b, 0x0a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x71, 0x75, 0x62, 0x6f, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x22, 0x62, 0x0a, 0x09, 0x48, + 0x69, 0x76, 0x65, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x72, + 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x12, 0x1f, + 0x0a, 0x0b, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x5f, 0x73, 0x65, 0x63, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x53, 0x65, 0x63, 0x12, + 0x1e, 0x0a, 0x0a, 0x72, 0x65, 0x74, 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x72, 0x65, 0x74, 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, + 0x4d, 0x0a, 0x13, 0x48, 0x69, 0x76, 0x65, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6c, 0x6c, + 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x36, 0x0a, 0x07, 0x71, 0x75, 0x65, 0x72, 0x69, 0x65, + 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x48, 0x69, 0x76, 0x65, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x07, 0x71, 0x75, 0x65, 0x72, 0x69, 0x65, 0x73, 0x22, 0xd3, + 0x01, 0x0a, 0x0d, 0x51, 0x75, 0x62, 0x6f, 0x6c, 0x65, 0x48, 0x69, 0x76, 0x65, 0x4a, 0x6f, 0x62, + 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x6c, 0x61, 0x62, 0x65, + 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x55, 0x0a, 0x10, 0x71, 0x75, 0x65, 0x72, 0x79, 0x5f, 0x63, + 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2e, 0x48, 0x69, 0x76, 0x65, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6c, + 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0f, 0x71, 0x75, 0x65, + 0x72, 0x79, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, + 0x74, 0x61, 0x67, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, + 0x12, 0x32, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x2e, 0x48, 0x69, 0x76, 0x65, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x05, 0x71, + 0x75, 0x65, 0x72, 0x79, 0x42, 0xc0, 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x42, 0x0b, + 0x51, 0x75, 0x62, 0x6f, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x35, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, + 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, + 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x73, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x58, 0xaa, 0x02, 0x11, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xca, 0x02, + 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x73, 0xe2, 0x02, 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, + 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x4a, 0xd5, 0x06, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, + 0x19, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, + 0x02, 0x12, 0x03, 0x02, 0x00, 0x1a, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x04, 0x00, 0x4c, + 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x04, 0x00, 0x4c, 0x0a, 0x3b, 0x0a, 0x02, 0x04, + 0x00, 0x12, 0x04, 0x07, 0x00, 0x0b, 0x01, 0x1a, 0x2f, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, + 0x73, 0x20, 0x61, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x65, 0x20, 0x6f, 0x6e, 0x20, 0x61, 0x20, 0x68, 0x69, 0x76, 0x65, 0x20, 0x63, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, + 0x03, 0x07, 0x08, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x08, 0x02, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x08, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x08, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x08, 0x11, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x01, 0x12, 0x03, 0x09, 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, + 0x05, 0x12, 0x03, 0x09, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x09, 0x09, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x09, + 0x17, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x0a, 0x02, 0x18, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x0a, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x0a, 0x09, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x0a, 0x16, 0x17, 0x0a, 0x33, 0x0a, 0x02, 0x04, 0x01, 0x12, + 0x04, 0x0e, 0x00, 0x10, 0x01, 0x1a, 0x27, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, + 0x61, 0x20, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, + 0x68, 0x69, 0x76, 0x65, 0x20, 0x71, 0x75, 0x65, 0x72, 0x69, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x0e, 0x08, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x00, 0x12, 0x03, 0x0f, 0x02, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x04, + 0x12, 0x03, 0x0f, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, + 0x0f, 0x0b, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0f, 0x15, + 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0f, 0x1f, 0x20, 0x0a, + 0x9a, 0x01, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x14, 0x00, 0x19, 0x01, 0x1a, 0x8d, 0x01, 0x20, + 0x54, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x77, 0x6f, 0x72, + 0x6b, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x27, 0x68, 0x69, 0x76, + 0x65, 0x27, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x69, 0x6e, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x53, 0x44, 0x4b, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x69, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, + 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x27, 0x63, + 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x27, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x0a, 0x20, 0x6f, 0x66, + 0x20, 0x61, 0x20, 0x68, 0x69, 0x76, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x27, 0x73, 0x20, 0x54, + 0x61, 0x73, 0x6b, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x02, 0x01, 0x12, 0x03, 0x14, 0x08, 0x15, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, + 0x12, 0x03, 0x15, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x15, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x15, 0x09, + 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x15, 0x19, 0x1a, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x16, 0x02, 0x3f, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, 0x03, 0x16, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x16, 0x16, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x16, 0x29, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x08, 0x12, + 0x03, 0x16, 0x2b, 0x3e, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x02, 0x01, 0x08, 0x03, 0x12, 0x03, + 0x16, 0x2c, 0x3d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x02, 0x12, 0x03, 0x17, 0x02, 0x1b, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x04, 0x12, 0x03, 0x17, 0x02, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x05, 0x12, 0x03, 0x17, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, 0x17, 0x12, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x02, 0x03, 0x12, 0x03, 0x17, 0x19, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x18, 0x02, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x06, 0x12, 0x03, + 0x18, 0x02, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x01, 0x12, 0x03, 0x18, 0x0c, + 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x03, 0x12, 0x03, 0x18, 0x14, 0x15, 0x62, + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xe7, 0x1f, 0x0a, 0x1b, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x72, 0x61, + 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x93, 0x02, 0x0a, 0x06, 0x52, 0x61, 0x79, 0x4a, 0x6f, + 0x62, 0x12, 0x3e, 0x0a, 0x0b, 0x72, 0x61, 0x79, 0x5f, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x52, 0x61, 0x79, 0x43, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x0a, 0x72, 0x61, 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x12, 0x23, 0x0a, 0x0b, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x65, 0x6e, 0x76, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0a, 0x72, 0x75, 0x6e, 0x74, + 0x69, 0x6d, 0x65, 0x45, 0x6e, 0x76, 0x12, 0x3d, 0x0a, 0x1b, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, + 0x77, 0x6e, 0x5f, 0x61, 0x66, 0x74, 0x65, 0x72, 0x5f, 0x6a, 0x6f, 0x62, 0x5f, 0x66, 0x69, 0x6e, + 0x69, 0x73, 0x68, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x18, 0x73, 0x68, 0x75, + 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x41, 0x66, 0x74, 0x65, 0x72, 0x4a, 0x6f, 0x62, 0x46, 0x69, 0x6e, + 0x69, 0x73, 0x68, 0x65, 0x73, 0x12, 0x3b, 0x0a, 0x1a, 0x74, 0x74, 0x6c, 0x5f, 0x73, 0x65, 0x63, + 0x6f, 0x6e, 0x64, 0x73, 0x5f, 0x61, 0x66, 0x74, 0x65, 0x72, 0x5f, 0x66, 0x69, 0x6e, 0x69, 0x73, + 0x68, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x17, 0x74, 0x74, 0x6c, 0x53, 0x65, + 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x41, 0x66, 0x74, 0x65, 0x72, 0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, + 0x65, 0x64, 0x12, 0x28, 0x0a, 0x10, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x65, 0x6e, + 0x76, 0x5f, 0x79, 0x61, 0x6d, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x72, 0x75, + 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x45, 0x6e, 0x76, 0x59, 0x61, 0x6d, 0x6c, 0x22, 0xd5, 0x01, 0x0a, + 0x0a, 0x52, 0x61, 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, 0x48, 0x0a, 0x0f, 0x68, + 0x65, 0x61, 0x64, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0d, 0x68, 0x65, 0x61, 0x64, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x53, 0x70, 0x65, 0x63, 0x12, 0x4e, 0x0a, 0x11, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x5f, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x53, 0x70, 0x65, 0x63, 0x52, 0x0f, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x53, 0x70, 0x65, 0x63, 0x12, 0x2d, 0x0a, 0x12, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x5f, + 0x61, 0x75, 0x74, 0x6f, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x11, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x41, 0x75, 0x74, 0x6f, 0x73, 0x63, 0x61, + 0x6c, 0x69, 0x6e, 0x67, 0x22, 0xe3, 0x01, 0x0a, 0x0d, 0x48, 0x65, 0x61, 0x64, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x53, 0x70, 0x65, 0x63, 0x12, 0x5e, 0x0a, 0x10, 0x72, 0x61, 0x79, 0x5f, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x34, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x70, + 0x65, 0x63, 0x2e, 0x52, 0x61, 0x79, 0x53, 0x74, 0x61, 0x72, 0x74, 0x50, 0x61, 0x72, 0x61, 0x6d, + 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x72, 0x61, 0x79, 0x53, 0x74, 0x61, 0x72, 0x74, + 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x2f, 0x0a, 0x07, 0x6b, 0x38, 0x73, 0x5f, 0x70, 0x6f, + 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x38, 0x73, 0x50, 0x6f, 0x64, 0x52, + 0x06, 0x6b, 0x38, 0x73, 0x50, 0x6f, 0x64, 0x1a, 0x41, 0x0a, 0x13, 0x52, 0x61, 0x79, 0x53, 0x74, + 0x61, 0x72, 0x74, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, + 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, + 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xe8, 0x02, 0x0a, 0x0f, 0x57, + 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1d, + 0x0a, 0x0a, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, + 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x08, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x69, 0x6e, + 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x0b, 0x6d, 0x69, 0x6e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x21, 0x0a, 0x0c, + 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x61, 0x78, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, + 0x60, 0x0a, 0x10, 0x72, 0x61, 0x79, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x70, 0x61, 0x72, + 0x61, 0x6d, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x57, 0x6f, + 0x72, 0x6b, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x70, 0x65, 0x63, 0x2e, 0x52, 0x61, + 0x79, 0x53, 0x74, 0x61, 0x72, 0x74, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x52, 0x0e, 0x72, 0x61, 0x79, 0x53, 0x74, 0x61, 0x72, 0x74, 0x50, 0x61, 0x72, 0x61, 0x6d, + 0x73, 0x12, 0x2f, 0x0a, 0x07, 0x6b, 0x38, 0x73, 0x5f, 0x70, 0x6f, 0x64, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x38, 0x73, 0x50, 0x6f, 0x64, 0x52, 0x06, 0x6b, 0x38, 0x73, 0x50, + 0x6f, 0x64, 0x1a, 0x41, 0x0a, 0x13, 0x52, 0x61, 0x79, 0x53, 0x74, 0x61, 0x72, 0x74, 0x50, 0x61, + 0x72, 0x61, 0x6d, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0xbd, 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x42, + 0x08, 0x52, 0x61, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, + 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, + 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, + 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x73, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x58, 0xaa, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xca, 0x02, 0x11, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0xe2, 0x02, 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, + 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0xea, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x50, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x73, 0x4a, 0x91, 0x15, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x3a, 0x01, + 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, + 0x03, 0x02, 0x00, 0x1a, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x24, 0x0a, + 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x06, 0x00, 0x4c, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, + 0x03, 0x06, 0x00, 0x4c, 0x0a, 0x3c, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x09, 0x00, 0x16, 0x01, + 0x1a, 0x30, 0x20, 0x52, 0x61, 0x79, 0x4a, 0x6f, 0x62, 0x53, 0x70, 0x65, 0x63, 0x20, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, + 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x52, 0x61, 0x79, 0x4a, 0x6f, + 0x62, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x09, 0x08, 0x0e, 0x0a, 0x44, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0b, 0x02, 0x1d, 0x1a, 0x37, 0x20, 0x52, 0x61, + 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x53, 0x70, 0x65, 0x63, 0x20, 0x69, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x74, 0x65, 0x6d, 0x70, + 0x6c, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6a, 0x6f, 0x62, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x0b, + 0x02, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0b, 0x0d, 0x18, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0b, 0x1b, 0x1c, 0x0a, 0xa0, + 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0e, 0x02, 0x2d, 0x1a, 0x92, 0x01, 0x20, + 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x65, 0x6e, 0x76, 0x20, 0x69, 0x73, 0x20, 0x62, + 0x61, 0x73, 0x65, 0x36, 0x34, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x2e, 0x0a, 0x20, + 0x52, 0x61, 0x79, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x65, 0x6e, 0x76, 0x69, + 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x3a, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, + 0x2f, 0x2f, 0x64, 0x6f, 0x63, 0x73, 0x2e, 0x72, 0x61, 0x79, 0x2e, 0x69, 0x6f, 0x2f, 0x65, 0x6e, + 0x2f, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x72, 0x61, 0x79, 0x2d, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x69, 0x6e, 0x67, 0x2d, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, + 0x65, 0x6e, 0x63, 0x69, 0x65, 0x73, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x23, 0x72, 0x75, 0x6e, 0x74, + 0x69, 0x6d, 0x65, 0x2d, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x0e, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0e, 0x09, 0x14, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x0e, 0x17, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x01, 0x08, 0x12, 0x03, 0x0e, 0x19, 0x2c, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x02, + 0x01, 0x08, 0x03, 0x12, 0x03, 0x0e, 0x1a, 0x2b, 0x0a, 0x78, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, + 0x12, 0x03, 0x10, 0x02, 0x27, 0x1a, 0x6b, 0x20, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, + 0x5f, 0x61, 0x66, 0x74, 0x65, 0x72, 0x5f, 0x6a, 0x6f, 0x62, 0x5f, 0x66, 0x69, 0x6e, 0x69, 0x73, + 0x68, 0x65, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x77, 0x68, + 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x52, 0x61, 0x79, 0x43, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x64, + 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x52, 0x61, 0x79, 0x4a, 0x6f, 0x62, 0x20, 0x66, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x73, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x10, 0x02, 0x06, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x10, 0x07, 0x22, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x10, 0x25, 0x26, 0x0a, 0x90, 0x01, 0x0a, + 0x04, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x12, 0x02, 0x27, 0x1a, 0x82, 0x01, 0x20, 0x74, 0x74, + 0x6c, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x5f, 0x61, 0x66, 0x74, 0x65, 0x72, 0x5f, + 0x66, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, + 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x77, + 0x68, 0x69, 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x52, 0x61, 0x79, 0x43, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x64, 0x65, 0x6c, 0x65, + 0x74, 0x65, 0x64, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x52, 0x61, + 0x79, 0x4a, 0x6f, 0x62, 0x20, 0x66, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x73, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x05, 0x12, 0x03, 0x12, 0x02, 0x07, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x12, 0x08, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x12, 0x25, 0x26, 0x0a, 0x75, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x04, 0x12, 0x03, 0x15, 0x02, 0x1e, 0x1a, 0x68, 0x20, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, + 0x45, 0x6e, 0x76, 0x59, 0x41, 0x4d, 0x4c, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, + 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x65, + 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, + 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x2d, 0x6c, 0x69, + 0x6e, 0x65, 0x20, 0x59, 0x41, 0x4d, 0x4c, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x05, 0x12, 0x03, 0x15, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x15, 0x09, 0x19, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, 0x15, 0x1c, 0x1d, 0x0a, 0x48, 0x0a, 0x02, 0x04, 0x01, + 0x12, 0x04, 0x19, 0x00, 0x20, 0x01, 0x1a, 0x3c, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x20, + 0x52, 0x61, 0x79, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x20, + 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x52, 0x61, 0x79, 0x43, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x19, 0x08, 0x12, + 0x0a, 0x3b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x1b, 0x02, 0x24, 0x1a, 0x2e, 0x20, + 0x48, 0x65, 0x61, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x70, 0x65, 0x63, 0x73, 0x20, 0x61, + 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x68, 0x65, 0x61, 0x64, 0x20, 0x70, 0x6f, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x1b, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1b, 0x10, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x1b, 0x22, 0x23, 0x0a, 0x41, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, + 0x03, 0x1d, 0x02, 0x31, 0x1a, 0x34, 0x20, 0x57, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x53, 0x70, 0x65, 0x63, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x6f, + 0x72, 0x6b, 0x65, 0x72, 0x20, 0x70, 0x6f, 0x64, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x01, 0x04, 0x12, 0x03, 0x1d, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, + 0x06, 0x12, 0x03, 0x1d, 0x0b, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x1d, 0x1b, 0x2c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x1d, + 0x2f, 0x30, 0x0a, 0x2d, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x1f, 0x02, 0x1e, 0x1a, + 0x20, 0x20, 0x57, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x6e, 0x61, + 0x62, 0x6c, 0x65, 0x20, 0x61, 0x75, 0x74, 0x6f, 0x73, 0x63, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x05, 0x12, 0x03, 0x1f, 0x02, 0x06, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x1f, 0x07, 0x19, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x1f, 0x1c, 0x1d, 0x0a, 0x39, 0x0a, 0x02, 0x04, + 0x02, 0x12, 0x04, 0x23, 0x00, 0x29, 0x01, 0x1a, 0x2d, 0x20, 0x48, 0x65, 0x61, 0x64, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x53, 0x70, 0x65, 0x63, 0x20, 0x61, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x68, 0x65, 0x61, + 0x64, 0x20, 0x70, 0x6f, 0x64, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x23, + 0x08, 0x15, 0x0a, 0xb7, 0x01, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x26, 0x02, 0x2b, + 0x1a, 0xa9, 0x01, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2e, 0x20, 0x52, 0x61, + 0x79, 0x53, 0x74, 0x61, 0x72, 0x74, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x20, 0x61, 0x72, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, + 0x3a, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x2c, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, + 0x74, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2d, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x2e, 0x0a, + 0x20, 0x52, 0x65, 0x66, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, + 0x2f, 0x2f, 0x64, 0x6f, 0x63, 0x73, 0x2e, 0x72, 0x61, 0x79, 0x2e, 0x69, 0x6f, 0x2f, 0x65, 0x6e, + 0x2f, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x72, 0x61, 0x79, 0x2d, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x2d, 0x72, 0x65, 0x66, 0x2e, 0x68, 0x74, 0x6d, + 0x6c, 0x23, 0x72, 0x61, 0x79, 0x2d, 0x73, 0x74, 0x61, 0x72, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, 0x03, 0x26, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x26, 0x16, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x26, 0x29, 0x2a, 0x0a, 0x2c, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x28, 0x02, 0x1a, 0x1a, 0x1f, 0x20, 0x50, 0x6f, 0x64, 0x20, 0x53, 0x70, 0x65, 0x63, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x79, 0x20, 0x68, 0x65, 0x61, 0x64, 0x20, + 0x70, 0x6f, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, 0x03, 0x28, + 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x28, 0x0e, 0x15, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x28, 0x18, 0x19, 0x0a, 0x3f, + 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x2c, 0x00, 0x3a, 0x01, 0x1a, 0x33, 0x20, 0x57, 0x6f, 0x72, + 0x6b, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x70, 0x65, 0x63, 0x20, 0x61, 0x72, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x20, 0x70, 0x6f, 0x64, 0x73, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x2c, 0x08, 0x17, 0x0a, 0x66, 0x0a, 0x04, 0x04, + 0x03, 0x02, 0x00, 0x12, 0x03, 0x2e, 0x02, 0x18, 0x1a, 0x59, 0x20, 0x52, 0x65, 0x71, 0x75, 0x69, + 0x72, 0x65, 0x64, 0x2e, 0x20, 0x52, 0x61, 0x79, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, + 0x63, 0x61, 0x6e, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, + 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x2c, + 0x20, 0x61, 0x6e, 0x64, 0x20, 0x69, 0x74, 0x20, 0x64, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x75, + 0x69, 0x73, 0x68, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x6d, 0x20, 0x62, 0x79, 0x20, 0x6e, 0x61, + 0x6d, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x05, 0x12, 0x03, 0x2e, 0x02, + 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2e, 0x09, 0x13, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x2e, 0x16, 0x17, 0x0a, 0x4d, 0x0a, + 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, 0x30, 0x02, 0x15, 0x1a, 0x40, 0x20, 0x52, 0x65, 0x71, + 0x75, 0x69, 0x72, 0x65, 0x64, 0x2e, 0x20, 0x44, 0x65, 0x73, 0x69, 0x72, 0x65, 0x64, 0x20, 0x72, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, + 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x20, 0x44, 0x65, 0x66, + 0x61, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x31, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x01, 0x05, 0x12, 0x03, 0x30, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x30, 0x08, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x30, 0x13, 0x14, 0x0a, 0x55, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x02, 0x12, 0x03, + 0x32, 0x02, 0x19, 0x1a, 0x48, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2e, 0x20, + 0x4d, 0x69, 0x6e, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x2e, 0x20, 0x4d, 0x69, 0x6e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, 0x64, 0x65, + 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x31, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x02, 0x05, 0x12, 0x03, 0x32, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x02, 0x01, 0x12, 0x03, 0x32, 0x08, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x02, 0x03, 0x12, 0x03, 0x32, 0x17, 0x18, 0x0a, 0x5b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x03, 0x12, + 0x03, 0x34, 0x02, 0x19, 0x1a, 0x4e, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2e, + 0x20, 0x4d, 0x61, 0x78, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x20, 0x67, 0x72, 0x6f, 0x75, + 0x70, 0x2e, 0x20, 0x4d, 0x61, 0x78, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, 0x64, + 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x61, 0x78, 0x49, 0x6e, + 0x74, 0x33, 0x32, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x05, 0x12, 0x03, 0x34, + 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x01, 0x12, 0x03, 0x34, 0x08, 0x14, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x03, 0x12, 0x03, 0x34, 0x17, 0x18, 0x0a, 0xb7, + 0x01, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x04, 0x12, 0x03, 0x37, 0x02, 0x2b, 0x1a, 0xa9, 0x01, 0x20, + 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2e, 0x20, 0x52, 0x61, 0x79, 0x53, 0x74, 0x61, + 0x72, 0x74, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x3a, 0x20, 0x61, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x2c, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2d, 0x73, 0x74, + 0x6f, 0x72, 0x65, 0x2d, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x2e, 0x0a, 0x20, 0x52, 0x65, 0x66, + 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x64, 0x6f, + 0x63, 0x73, 0x2e, 0x72, 0x61, 0x79, 0x2e, 0x69, 0x6f, 0x2f, 0x65, 0x6e, 0x2f, 0x6c, 0x61, 0x74, + 0x65, 0x73, 0x74, 0x2f, 0x72, 0x61, 0x79, 0x2d, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x70, 0x61, 0x63, + 0x6b, 0x61, 0x67, 0x65, 0x2d, 0x72, 0x65, 0x66, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x23, 0x72, 0x61, + 0x79, 0x2d, 0x73, 0x74, 0x61, 0x72, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, + 0x06, 0x12, 0x03, 0x37, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x01, 0x12, + 0x03, 0x37, 0x16, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x03, 0x12, 0x03, 0x37, + 0x29, 0x2a, 0x0a, 0x2b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x05, 0x12, 0x03, 0x39, 0x02, 0x1a, 0x1a, + 0x1e, 0x20, 0x50, 0x6f, 0x64, 0x20, 0x53, 0x70, 0x65, 0x63, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x72, + 0x61, 0x79, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x20, 0x70, 0x6f, 0x64, 0x73, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x06, 0x12, 0x03, 0x39, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x05, 0x01, 0x12, 0x03, 0x39, 0x0e, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x05, 0x03, 0x12, 0x03, 0x39, 0x18, 0x19, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, 0x0a, 0xf7, 0x14, 0x0a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2f, 0x73, 0x70, 0x61, 0x72, 0x6b, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x22, 0x42, 0x0a, 0x10, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2e, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0a, 0x0a, 0x06, + 0x50, 0x59, 0x54, 0x48, 0x4f, 0x4e, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x4a, 0x41, 0x56, 0x41, + 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05, 0x53, 0x43, 0x41, 0x4c, 0x41, 0x10, 0x02, 0x12, 0x05, 0x0a, + 0x01, 0x52, 0x10, 0x03, 0x22, 0xf1, 0x05, 0x0a, 0x08, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x4a, 0x6f, + 0x62, 0x12, 0x52, 0x0a, 0x0f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x54, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x28, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x53, + 0x70, 0x61, 0x72, 0x6b, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, + 0x54, 0x79, 0x70, 0x65, 0x52, 0x0f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x30, 0x0a, 0x13, 0x6d, 0x61, 0x69, 0x6e, 0x41, 0x70, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x13, 0x6d, 0x61, 0x69, 0x6e, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x6d, 0x61, 0x69, 0x6e, 0x43, + 0x6c, 0x61, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x61, 0x69, 0x6e, + 0x43, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x48, 0x0a, 0x09, 0x73, 0x70, 0x61, 0x72, 0x6b, 0x43, 0x6f, + 0x6e, 0x66, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x53, 0x70, 0x61, + 0x72, 0x6b, 0x4a, 0x6f, 0x62, 0x2e, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x43, 0x6f, 0x6e, 0x66, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x09, 0x73, 0x70, 0x61, 0x72, 0x6b, 0x43, 0x6f, 0x6e, 0x66, 0x12, + 0x4b, 0x0a, 0x0a, 0x68, 0x61, 0x64, 0x6f, 0x6f, 0x70, 0x43, 0x6f, 0x6e, 0x66, 0x18, 0x05, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x2e, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x4a, 0x6f, 0x62, + 0x2e, 0x48, 0x61, 0x64, 0x6f, 0x6f, 0x70, 0x43, 0x6f, 0x6e, 0x66, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x52, 0x0a, 0x68, 0x61, 0x64, 0x6f, 0x6f, 0x70, 0x43, 0x6f, 0x6e, 0x66, 0x12, 0x22, 0x0a, 0x0c, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x50, 0x61, 0x74, 0x68, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0c, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x50, 0x61, 0x74, 0x68, + 0x12, 0x3f, 0x0a, 0x0e, 0x64, 0x61, 0x74, 0x61, 0x62, 0x72, 0x69, 0x63, 0x6b, 0x73, 0x43, 0x6f, + 0x6e, 0x66, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, + 0x74, 0x52, 0x0e, 0x64, 0x61, 0x74, 0x61, 0x62, 0x72, 0x69, 0x63, 0x6b, 0x73, 0x43, 0x6f, 0x6e, + 0x66, 0x12, 0x28, 0x0a, 0x0f, 0x64, 0x61, 0x74, 0x61, 0x62, 0x72, 0x69, 0x63, 0x6b, 0x73, 0x54, + 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x64, 0x61, 0x74, 0x61, + 0x62, 0x72, 0x69, 0x63, 0x6b, 0x73, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x2e, 0x0a, 0x12, 0x64, + 0x61, 0x74, 0x61, 0x62, 0x72, 0x69, 0x63, 0x6b, 0x73, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, + 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x64, 0x61, 0x74, 0x61, 0x62, 0x72, 0x69, + 0x63, 0x6b, 0x73, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x34, 0x0a, 0x09, 0x64, + 0x72, 0x69, 0x76, 0x65, 0x72, 0x50, 0x6f, 0x64, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x4b, 0x38, 0x73, 0x50, 0x6f, 0x64, 0x52, 0x09, 0x64, 0x72, 0x69, 0x76, 0x65, 0x72, 0x50, 0x6f, + 0x64, 0x12, 0x38, 0x0a, 0x0b, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x50, 0x6f, 0x64, + 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x38, 0x73, 0x50, 0x6f, 0x64, 0x52, 0x0b, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x50, 0x6f, 0x64, 0x1a, 0x3c, 0x0a, 0x0e, 0x53, + 0x70, 0x61, 0x72, 0x6b, 0x43, 0x6f, 0x6e, 0x66, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, + 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, + 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3d, 0x0a, 0x0f, 0x48, 0x61, 0x64, + 0x6f, 0x6f, 0x70, 0x43, 0x6f, 0x6e, 0x66, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0xbf, 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x73, 0x42, 0x0a, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, + 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, + 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x58, 0xaa, 0x02, 0x11, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0xca, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x73, 0xe2, 0x02, 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x3a, 0x3a, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x4a, 0x86, 0x0c, 0x0a, 0x06, 0x12, + 0x04, 0x00, 0x00, 0x29, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, + 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x1a, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, + 0x03, 0x04, 0x00, 0x24, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x26, 0x0a, + 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x07, 0x00, 0x4c, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, + 0x03, 0x07, 0x00, 0x4c, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x09, 0x00, 0x10, 0x01, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x09, 0x08, 0x18, 0x0a, 0x0c, 0x0a, 0x04, + 0x04, 0x00, 0x04, 0x00, 0x12, 0x04, 0x0a, 0x02, 0x0f, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x04, 0x00, 0x01, 0x12, 0x03, 0x0a, 0x07, 0x0b, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, + 0x02, 0x00, 0x12, 0x03, 0x0b, 0x04, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x0b, 0x04, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, + 0x00, 0x02, 0x12, 0x03, 0x0b, 0x0d, 0x0e, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, + 0x01, 0x12, 0x03, 0x0c, 0x04, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x0c, 0x04, 0x08, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, + 0x02, 0x12, 0x03, 0x0c, 0x0b, 0x0c, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, + 0x12, 0x03, 0x0d, 0x04, 0x0e, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x0d, 0x04, 0x09, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, 0x02, + 0x12, 0x03, 0x0d, 0x0c, 0x0d, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x03, 0x12, + 0x03, 0x0e, 0x04, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, + 0x03, 0x0e, 0x04, 0x05, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x03, 0x02, 0x12, + 0x03, 0x0e, 0x08, 0x09, 0x0a, 0x2c, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x13, 0x00, 0x29, 0x01, + 0x1a, 0x20, 0x20, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x20, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x13, 0x08, 0x10, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x14, 0x02, 0x2c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x14, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x14, 0x18, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x14, 0x2a, 0x2b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x15, + 0x02, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, 0x15, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x15, 0x09, 0x1c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x15, 0x1f, 0x20, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x16, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x02, 0x05, 0x12, 0x03, 0x16, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x16, 0x09, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, + 0x16, 0x15, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x03, 0x12, 0x03, 0x17, 0x02, 0x24, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x06, 0x12, 0x03, 0x17, 0x02, 0x15, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x01, 0x12, 0x03, 0x17, 0x16, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x03, 0x03, 0x12, 0x03, 0x17, 0x22, 0x23, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x04, 0x12, 0x03, 0x18, 0x02, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x06, + 0x12, 0x03, 0x18, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x01, 0x12, 0x03, + 0x18, 0x16, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x03, 0x12, 0x03, 0x18, 0x23, + 0x24, 0x0a, 0x2d, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x05, 0x12, 0x03, 0x19, 0x02, 0x1a, 0x22, 0x20, + 0x20, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x50, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x20, 0x6a, 0x6f, 0x62, 0x73, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x05, 0x12, 0x03, 0x19, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x01, 0x12, 0x03, 0x19, 0x09, 0x15, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x05, 0x03, 0x12, 0x03, 0x19, 0x18, 0x19, 0x0a, 0x9d, 0x01, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x06, 0x12, 0x03, 0x1c, 0x02, 0x2c, 0x1a, 0x8f, 0x01, 0x20, 0x44, 0x61, 0x74, 0x61, + 0x62, 0x72, 0x69, 0x63, 0x6b, 0x73, 0x20, 0x6a, 0x6f, 0x62, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x43, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x20, + 0x62, 0x65, 0x20, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x68, 0x65, 0x72, 0x65, 0x2e, 0x20, 0x68, + 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x64, 0x6f, 0x63, 0x73, 0x2e, 0x64, 0x61, 0x74, 0x61, + 0x62, 0x72, 0x69, 0x63, 0x6b, 0x73, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x65, 0x76, 0x2d, 0x74, + 0x6f, 0x6f, 0x6c, 0x73, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x32, 0x2e, 0x30, 0x2f, 0x6a, 0x6f, 0x62, + 0x73, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x23, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2d, 0x73, + 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x06, 0x06, 0x12, 0x03, 0x1c, 0x02, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, + 0x01, 0x12, 0x03, 0x1c, 0x19, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x03, 0x12, + 0x03, 0x1c, 0x2a, 0x2b, 0x0a, 0xaa, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x07, 0x12, 0x03, 0x1f, + 0x02, 0x1d, 0x1a, 0x9c, 0x01, 0x20, 0x44, 0x61, 0x74, 0x61, 0x62, 0x72, 0x69, 0x63, 0x6b, 0x73, + 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x20, 0x68, + 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x64, 0x6f, 0x63, 0x73, 0x2e, 0x64, 0x61, 0x74, 0x61, + 0x62, 0x72, 0x69, 0x63, 0x6b, 0x73, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x65, 0x76, 0x2d, 0x74, + 0x6f, 0x6f, 0x6c, 0x73, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x2f, + 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x68, + 0x74, 0x6d, 0x6c, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, + 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x65, 0x69, + 0x74, 0x68, 0x65, 0x72, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x6c, + 0x6c, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6b, 0x69, 0x74, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x05, 0x12, 0x03, 0x1f, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x01, 0x12, 0x03, 0x1f, 0x09, 0x18, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x07, 0x03, 0x12, 0x03, 0x1f, 0x1b, 0x1c, 0x0a, 0xa1, 0x01, 0x0a, 0x04, + 0x04, 0x01, 0x02, 0x08, 0x12, 0x03, 0x22, 0x02, 0x20, 0x1a, 0x93, 0x01, 0x20, 0x44, 0x6f, 0x6d, + 0x61, 0x69, 0x6e, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x79, 0x6f, 0x75, 0x72, + 0x20, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x20, 0x55, 0x73, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x3c, 0x61, 0x63, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x3e, 0x2e, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x62, 0x72, + 0x69, 0x63, 0x6b, 0x73, 0x2e, 0x63, 0x6f, 0x6d, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, + 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x63, 0x61, + 0x6e, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x65, 0x69, 0x74, 0x68, + 0x65, 0x72, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x6c, 0x6c, 0x65, + 0x72, 0x20, 0x6f, 0x72, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6b, 0x69, 0x74, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x08, 0x05, 0x12, 0x03, 0x22, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x08, 0x01, 0x12, 0x03, 0x22, 0x09, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x08, 0x03, 0x12, 0x03, 0x22, 0x1e, 0x1f, 0x0a, 0x30, 0x0a, 0x04, 0x04, 0x01, 0x02, + 0x09, 0x12, 0x03, 0x25, 0x02, 0x1d, 0x1a, 0x23, 0x20, 0x50, 0x6f, 0x64, 0x20, 0x53, 0x70, 0x65, + 0x63, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x20, + 0x64, 0x72, 0x69, 0x76, 0x65, 0x72, 0x20, 0x70, 0x6f, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x09, 0x06, 0x12, 0x03, 0x25, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x09, 0x01, 0x12, 0x03, 0x25, 0x0e, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x09, 0x03, + 0x12, 0x03, 0x25, 0x1a, 0x1c, 0x0a, 0x32, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x0a, 0x12, 0x03, 0x28, + 0x02, 0x1f, 0x1a, 0x25, 0x20, 0x50, 0x6f, 0x64, 0x20, 0x53, 0x70, 0x65, 0x63, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x20, 0x65, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x6f, 0x72, 0x20, 0x70, 0x6f, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x0a, 0x06, 0x12, 0x03, 0x28, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0a, 0x01, + 0x12, 0x03, 0x28, 0x0e, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0a, 0x03, 0x12, 0x03, + 0x28, 0x1c, 0x1e, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xea, 0x08, 0x0a, 0x22, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x73, 0x2f, 0x74, 0x65, 0x6e, 0x73, 0x6f, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x12, 0x11, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x73, 0x22, 0xb4, 0x01, 0x0a, 0x21, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, + 0x62, 0x75, 0x74, 0x65, 0x64, 0x54, 0x65, 0x6e, 0x73, 0x6f, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x54, + 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x18, 0x0a, 0x07, 0x77, + 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x77, 0x6f, + 0x72, 0x6b, 0x65, 0x72, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x73, 0x5f, 0x72, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x70, 0x73, 0x52, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x68, 0x69, 0x65, 0x66, 0x5f, + 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, + 0x63, 0x68, 0x69, 0x65, 0x66, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x2d, 0x0a, + 0x12, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x11, 0x65, 0x76, 0x61, 0x6c, 0x75, + 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x42, 0xc4, 0x01, 0x0a, + 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x42, 0x0f, 0x54, 0x65, 0x6e, 0x73, 0x6f, 0x72, 0x66, 0x6c, + 0x6f, 0x77, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, + 0xa2, 0x02, 0x03, 0x46, 0x50, 0x58, 0xaa, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xca, 0x02, 0x11, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0xe2, 0x02, + 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, + 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x50, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x73, 0x4a, 0xaa, 0x05, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x11, 0x01, 0x0a, 0x08, + 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, + 0x00, 0x1a, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x04, 0x00, 0x4c, 0x0a, 0x09, 0x0a, 0x02, + 0x08, 0x0b, 0x12, 0x03, 0x04, 0x00, 0x4c, 0x0a, 0x75, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x07, + 0x00, 0x11, 0x01, 0x1a, 0x69, 0x20, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x69, 0x73, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x20, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, + 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, + 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6b, 0x75, 0x62, 0x65, 0x66, 0x6c, 0x6f, + 0x77, 0x2f, 0x74, 0x66, 0x2d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x0a, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x07, 0x08, 0x29, 0x0a, 0x4c, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x00, 0x12, 0x03, 0x09, 0x02, 0x14, 0x1a, 0x3f, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, + 0x20, 0x6f, 0x66, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x73, 0x20, 0x73, 0x70, 0x61, 0x77, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x6a, 0x6f, 0x62, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x05, 0x12, 0x03, 0x09, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x09, 0x08, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x09, + 0x12, 0x13, 0x0a, 0x60, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0c, 0x02, 0x18, 0x1a, + 0x53, 0x20, 0x50, 0x53, 0x20, 0x2d, 0x3e, 0x20, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, + 0x72, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x0a, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, + 0x20, 0x6f, 0x66, 0x20, 0x70, 0x73, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, + 0x73, 0x70, 0x61, 0x77, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x6a, 0x6f, 0x62, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x0c, + 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0c, 0x08, 0x13, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x0c, 0x16, 0x17, 0x0a, 0x4b, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x0e, 0x02, 0x1b, 0x1a, 0x3e, 0x20, 0x6e, 0x75, + 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x63, 0x68, 0x69, 0x65, 0x66, 0x20, 0x72, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x20, 0x73, 0x70, 0x61, 0x77, 0x6e, 0x65, 0x64, 0x20, 0x69, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6a, 0x6f, 0x62, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x0e, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x0e, 0x08, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x0e, 0x19, 0x1a, 0x0a, 0x4f, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x10, + 0x02, 0x1f, 0x1a, 0x42, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x65, + 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x73, 0x20, 0x73, 0x70, 0x61, 0x77, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x6a, 0x6f, 0x62, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x05, 0x12, + 0x03, 0x10, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x10, + 0x08, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x10, 0x1d, 0x1e, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +]; +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/flyteidl2.project.rs b/gen/rust/src/flyteidl2.project.rs new file mode 100644 index 0000000000..ff02bd0186 --- /dev/null +++ b/gen/rust/src/flyteidl2.project.rs @@ -0,0 +1,549 @@ +// @generated +// This file is @generated by prost-build. +/// Namespace within a project commonly used to differentiate between different service instances. +/// e.g. "production", "development", etc. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Domain { + /// Globally unique domain name. + #[prost(string, tag="1")] + pub id: ::prost::alloc::string::String, + /// Display name. + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Project { + /// Globally unique project name. + #[prost(string, tag="1")] + pub id: ::prost::alloc::string::String, + /// Display name. + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, + #[prost(message, repeated, tag="3")] + pub domains: ::prost::alloc::vec::Vec, + #[prost(string, tag="4")] + pub description: ::prost::alloc::string::String, + /// Leverage Labels from flyteidl.admin.common.proto to + /// tag projects with ownership information. + #[prost(message, optional, tag="5")] + pub labels: ::core::option::Option, + #[prost(enumeration="ProjectState", tag="6")] + pub state: i32, + /// Optional, org key applied to the resource. + #[prost(string, tag="7")] + pub org: ::prost::alloc::string::String, +} +/// Represents a list of projects. +/// See :ref:`ref_flyteidl.admin.Project` for more details +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Projects { + #[prost(message, repeated, tag="1")] + pub projects: ::prost::alloc::vec::Vec, + /// In the case of multiple pages of results, the server-provided token can be used to fetch the next page + /// in a query. If there are no more results, this value will be empty. + #[prost(string, tag="2")] + pub token: ::prost::alloc::string::String, +} +/// Adds a new user-project within the Flyte deployment. +/// See :ref:`ref_flyteidl.admin.Project` for more details +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateProjectRequest { + /// +required + #[prost(message, optional, tag="1")] + pub project: ::core::option::Option, +} +/// Purposefully empty, may be updated in the future. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct CreateProjectResponse { +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UpdateProjectRequest { + /// +required + #[prost(message, optional, tag="1")] + pub project: ::core::option::Option, +} +/// Purposefully empty, may be updated in the future. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct UpdateProjectResponse { +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetProjectRequest { + /// Indicates a unique project. + /// +required + #[prost(string, tag="1")] + pub id: ::prost::alloc::string::String, + /// Optional, org key applied to the resource. + #[prost(string, tag="2")] + pub org: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetProjectResponse { + /// +required + #[prost(message, optional, tag="1")] + pub project: ::core::option::Option, +} +/// Request to retrieve a list of projects matching specified filters. +/// See :ref:`ref_flyteidl.admin.Project` for more details +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListProjectsRequest { + /// Indicates the number of projects to be returned. + /// +required + #[prost(uint32, tag="1")] + pub limit: u32, + /// In the case of multiple pages of results, this server-provided token can be used to fetch the next page + /// in a query. + /// +optional + #[prost(string, tag="2")] + pub token: ::prost::alloc::string::String, + /// Indicates a list of filters passed as string. + /// More info on constructing filters : + /// +optional + #[prost(string, tag="3")] + pub filters: ::prost::alloc::string::String, + /// Sort ordering. + /// +optional + #[prost(message, optional, tag="4")] + pub sort_by: ::core::option::Option, + /// Optional, org filter applied to list project requests. + #[prost(string, tag="5")] + pub org: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListProjectsResponse { + /// +required + #[prost(message, optional, tag="1")] + pub projects: ::core::option::Option, +} +/// The state of the project is used to control its visibility in the UI and validity. +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ProjectState { + /// By default, all projects are considered active. + Active = 0, + /// Archived projects are no longer visible in the UI and no longer valid. + Archived = 1, + /// System generated projects that aren't explicitly created or managed by a user. + SystemGenerated = 2, + /// System archived projects that aren't explicitly archived by a user. + SystemArchived = 3, +} +impl ProjectState { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ProjectState::Active => "PROJECT_STATE_ACTIVE", + ProjectState::Archived => "PROJECT_STATE_ARCHIVED", + ProjectState::SystemGenerated => "PROJECT_STATE_SYSTEM_GENERATED", + ProjectState::SystemArchived => "PROJECT_STATE_SYSTEM_ARCHIVED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "PROJECT_STATE_ACTIVE" => Some(Self::Active), + "PROJECT_STATE_ARCHIVED" => Some(Self::Archived), + "PROJECT_STATE_SYSTEM_GENERATED" => Some(Self::SystemGenerated), + "PROJECT_STATE_SYSTEM_ARCHIVED" => Some(Self::SystemArchived), + _ => None, + } + } +} +/// Encoded file descriptor set for the `flyteidl2.project` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xf3, 0x2d, 0x0a, 0x27, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x70, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x73, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x1a, + 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2f, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x18, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x72, 0x75, 0x6e, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x2c, 0x0a, 0x06, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, + 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, + 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x22, 0xfd, 0x01, 0x0a, 0x07, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, + 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x33, 0x0a, 0x07, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x73, 0x18, + 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, + 0x52, 0x07, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2e, 0x0a, 0x06, 0x6c, + 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4c, 0x61, 0x62, + 0x65, 0x6c, 0x73, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x12, 0x35, 0x0a, 0x05, 0x73, + 0x74, 0x61, 0x74, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x50, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, + 0x74, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x03, 0x6f, 0x72, 0x67, 0x22, 0x58, 0x0a, 0x08, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, + 0x12, 0x36, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x08, + 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, + 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x4c, + 0x0a, 0x14, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x34, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x50, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x17, 0x0a, 0x15, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4c, 0x0a, 0x14, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x34, 0x0a, + 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x22, 0x17, 0x0a, 0x15, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0x0a, 0x11, + 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, + 0x64, 0x12, 0x10, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, + 0x6f, 0x72, 0x67, 0x22, 0x4a, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x07, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x50, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x22, + 0x9e, 0x01, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x14, 0x0a, + 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x12, 0x2f, 0x0a, + 0x07, 0x73, 0x6f, 0x72, 0x74, 0x5f, 0x62, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x53, 0x6f, 0x72, 0x74, 0x52, 0x06, 0x73, 0x6f, 0x72, 0x74, 0x42, 0x79, 0x12, 0x10, + 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6f, 0x72, 0x67, + 0x22, 0x4f, 0x0a, 0x14, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x37, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x50, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x73, 0x2a, 0x8b, 0x01, 0x0a, 0x0c, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x53, 0x74, 0x61, + 0x74, 0x65, 0x12, 0x18, 0x0a, 0x14, 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x53, 0x54, + 0x41, 0x54, 0x45, 0x5f, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x10, 0x00, 0x12, 0x1a, 0x0a, 0x16, + 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x41, 0x52, + 0x43, 0x48, 0x49, 0x56, 0x45, 0x44, 0x10, 0x01, 0x12, 0x22, 0x0a, 0x1e, 0x50, 0x52, 0x4f, 0x4a, + 0x45, 0x43, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, + 0x5f, 0x47, 0x45, 0x4e, 0x45, 0x52, 0x41, 0x54, 0x45, 0x44, 0x10, 0x02, 0x12, 0x21, 0x0a, 0x1d, + 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x59, + 0x53, 0x54, 0x45, 0x4d, 0x5f, 0x41, 0x52, 0x43, 0x48, 0x49, 0x56, 0x45, 0x44, 0x10, 0x03, 0x32, + 0x9f, 0x03, 0x0a, 0x0e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x12, 0x64, 0x0a, 0x0d, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x12, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x64, 0x0a, 0x0d, 0x55, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x55, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5e, + 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x24, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x61, + 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x26, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x00, 0x42, 0xc8, 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x42, 0x13, 0x50, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, + 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, + 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0xa2, 0x02, 0x03, 0x46, 0x50, 0x58, 0xaa, + 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x50, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0xca, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, + 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0xe2, 0x02, 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5c, 0x47, 0x50, 0x42, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x4a, 0xaf, 0x1f, 0x0a, + 0x07, 0x12, 0x05, 0x00, 0x00, 0x89, 0x01, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, + 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x01, 0x00, 0x1a, 0x0a, 0x09, 0x0a, 0x02, + 0x03, 0x00, 0x12, 0x03, 0x03, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x04, + 0x00, 0x22, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x06, 0x00, 0x4c, 0x0a, 0x09, 0x0a, 0x02, + 0x08, 0x0b, 0x12, 0x03, 0x06, 0x00, 0x4c, 0x0a, 0x95, 0x01, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, + 0x0a, 0x00, 0x10, 0x01, 0x1a, 0x88, 0x01, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, + 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x75, 0x73, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x74, + 0x65, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, + 0x65, 0x6e, 0x74, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x69, 0x6e, 0x73, 0x74, + 0x61, 0x6e, 0x63, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x22, 0x70, 0x72, + 0x6f, 0x64, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x20, 0x22, 0x64, 0x65, 0x76, 0x65, + 0x6c, 0x6f, 0x70, 0x6d, 0x65, 0x6e, 0x74, 0x22, 0x2c, 0x20, 0x65, 0x74, 0x63, 0x2e, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0a, 0x08, 0x0e, 0x0a, 0x2b, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x00, 0x12, 0x03, 0x0c, 0x02, 0x10, 0x1a, 0x1e, 0x20, 0x47, 0x6c, 0x6f, 0x62, 0x61, + 0x6c, 0x6c, 0x79, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, + 0x6e, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x05, 0x12, 0x03, 0x0c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x0c, 0x09, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0c, + 0x0e, 0x0f, 0x0a, 0x1c, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0f, 0x02, 0x12, 0x1a, + 0x0f, 0x20, 0x44, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x0f, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0f, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x0f, 0x10, 0x11, 0x0a, 0x60, 0x0a, 0x02, 0x05, 0x00, + 0x12, 0x04, 0x13, 0x00, 0x1f, 0x01, 0x1a, 0x54, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, + 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x20, 0x69, 0x74, 0x73, 0x20, 0x76, 0x69, 0x73, 0x69, 0x62, 0x69, 0x6c, + 0x69, 0x74, 0x79, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x55, 0x49, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x69, 0x74, 0x79, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x05, 0x00, 0x01, 0x12, 0x03, 0x13, 0x05, 0x11, 0x0a, 0x3e, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x00, + 0x12, 0x03, 0x15, 0x02, 0x1b, 0x1a, 0x31, 0x20, 0x42, 0x79, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, + 0x6c, 0x74, 0x2c, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, + 0x20, 0x61, 0x72, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20, + 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x15, 0x02, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x02, 0x12, + 0x03, 0x15, 0x19, 0x1a, 0x0a, 0x55, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x01, 0x12, 0x03, 0x18, 0x02, + 0x1d, 0x1a, 0x48, 0x20, 0x41, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x64, 0x20, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6e, 0x6f, 0x20, 0x6c, 0x6f, 0x6e, + 0x67, 0x65, 0x72, 0x20, 0x76, 0x69, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x55, 0x49, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6e, 0x6f, 0x20, 0x6c, 0x6f, 0x6e, + 0x67, 0x65, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x18, 0x02, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, + 0x01, 0x02, 0x12, 0x03, 0x18, 0x1b, 0x1c, 0x0a, 0x5d, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x02, 0x12, + 0x03, 0x1b, 0x02, 0x25, 0x1a, 0x50, 0x20, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x67, 0x65, + 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x72, 0x65, 0x6e, 0x27, 0x74, 0x20, 0x65, 0x78, 0x70, + 0x6c, 0x69, 0x63, 0x69, 0x74, 0x6c, 0x79, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, + 0x6f, 0x72, 0x20, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x20, + 0x75, 0x73, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x1b, 0x02, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x1b, + 0x23, 0x24, 0x0a, 0x52, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x03, 0x12, 0x03, 0x1e, 0x02, 0x24, 0x1a, + 0x45, 0x20, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, + 0x64, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x61, 0x72, 0x65, 0x6e, 0x27, 0x74, 0x20, 0x65, 0x78, 0x70, 0x6c, 0x69, 0x63, 0x69, 0x74, 0x6c, + 0x79, 0x20, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x20, + 0x75, 0x73, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x01, 0x12, + 0x03, 0x1e, 0x02, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x1e, + 0x22, 0x23, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x21, 0x00, 0x34, 0x01, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x21, 0x08, 0x0f, 0x0a, 0x2c, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x00, 0x12, 0x03, 0x23, 0x02, 0x10, 0x1a, 0x1f, 0x20, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, + 0x6c, 0x79, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, + 0x05, 0x12, 0x03, 0x23, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x23, 0x09, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x23, + 0x0e, 0x0f, 0x0a, 0x1c, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x26, 0x02, 0x12, 0x1a, + 0x0f, 0x20, 0x44, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, 0x26, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x26, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x26, 0x10, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x02, 0x12, 0x03, 0x28, 0x02, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x04, + 0x12, 0x03, 0x28, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x06, 0x12, 0x03, + 0x28, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x28, 0x12, + 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x28, 0x1c, 0x1d, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x03, 0x12, 0x03, 0x2a, 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x03, 0x05, 0x12, 0x03, 0x2a, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x03, 0x01, 0x12, 0x03, 0x2a, 0x09, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, + 0x03, 0x12, 0x03, 0x2a, 0x17, 0x18, 0x0a, 0x6c, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x04, 0x12, 0x03, + 0x2e, 0x02, 0x23, 0x1a, 0x5f, 0x20, 0x4c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x20, 0x4c, + 0x61, 0x62, 0x65, 0x6c, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x2e, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x74, 0x6f, 0x0a, 0x20, 0x74, 0x61, 0x67, 0x20, 0x70, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6f, 0x77, 0x6e, + 0x65, 0x72, 0x73, 0x68, 0x69, 0x70, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x06, 0x12, 0x03, 0x2e, + 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x01, 0x12, 0x03, 0x2e, 0x18, 0x1e, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x03, 0x12, 0x03, 0x2e, 0x21, 0x22, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x01, 0x02, 0x05, 0x12, 0x03, 0x30, 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x05, 0x06, 0x12, 0x03, 0x30, 0x02, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x05, 0x01, 0x12, 0x03, 0x30, 0x0f, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x03, + 0x12, 0x03, 0x30, 0x17, 0x18, 0x0a, 0x39, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x06, 0x12, 0x03, 0x33, + 0x02, 0x11, 0x1a, 0x2c, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2c, 0x20, 0x6f, + 0x72, 0x67, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, + 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x05, 0x12, 0x03, 0x33, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x01, 0x12, 0x03, 0x33, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x06, 0x03, 0x12, 0x03, 0x33, 0x0f, 0x10, 0x0a, 0x64, 0x0a, 0x02, 0x04, 0x02, + 0x12, 0x04, 0x38, 0x00, 0x3e, 0x01, 0x1a, 0x58, 0x20, 0x52, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, + 0x6e, 0x74, 0x73, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x70, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2e, 0x0a, 0x20, 0x53, 0x65, 0x65, 0x20, 0x3a, 0x72, 0x65, + 0x66, 0x3a, 0x60, 0x72, 0x65, 0x66, 0x5f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x2e, + 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x60, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x38, 0x08, 0x10, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x39, 0x02, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x00, 0x04, 0x12, 0x03, 0x39, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x39, 0x0b, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x39, 0x13, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x39, 0x1e, + 0x1f, 0x0a, 0xbb, 0x01, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x3d, 0x02, 0x13, 0x1a, + 0xad, 0x01, 0x20, 0x49, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x70, 0x61, 0x67, 0x65, 0x73, + 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2c, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2d, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, + 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x65, 0x74, 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6e, 0x65, 0x78, 0x74, 0x20, 0x70, 0x61, 0x67, 0x65, 0x0a, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, + 0x61, 0x72, 0x65, 0x20, 0x6e, 0x6f, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x73, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, + 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x05, 0x12, 0x03, 0x3d, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x3d, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x3d, 0x11, 0x12, 0x0a, 0x7a, 0x0a, 0x02, 0x04, 0x03, 0x12, + 0x04, 0x42, 0x00, 0x45, 0x01, 0x1a, 0x6e, 0x20, 0x41, 0x64, 0x64, 0x73, 0x20, 0x61, 0x20, 0x6e, + 0x65, 0x77, 0x20, 0x75, 0x73, 0x65, 0x72, 0x2d, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x20, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x0a, 0x20, 0x53, 0x65, + 0x65, 0x20, 0x3a, 0x72, 0x65, 0x66, 0x3a, 0x60, 0x72, 0x65, 0x66, 0x5f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x2e, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x60, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x64, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x42, 0x08, + 0x1c, 0x0a, 0x18, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x44, 0x02, 0x16, 0x1a, 0x0b, + 0x20, 0x2b, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x44, 0x02, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x44, 0x0a, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x44, 0x14, 0x15, 0x0a, 0x3e, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x03, 0x48, 0x00, 0x20, + 0x1a, 0x33, 0x20, 0x50, 0x75, 0x72, 0x70, 0x6f, 0x73, 0x65, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x20, + 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2c, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x75, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x74, + 0x75, 0x72, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x48, 0x08, + 0x1d, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x4a, 0x00, 0x4d, 0x01, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x4a, 0x08, 0x1c, 0x0a, 0x18, 0x0a, 0x04, 0x04, 0x05, 0x02, + 0x00, 0x12, 0x03, 0x4c, 0x02, 0x16, 0x1a, 0x0b, 0x20, 0x2b, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, + 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x06, 0x12, 0x03, 0x4c, 0x02, + 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x4c, 0x0a, 0x11, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x4c, 0x14, 0x15, 0x0a, 0x3e, 0x0a, + 0x02, 0x04, 0x06, 0x12, 0x03, 0x50, 0x00, 0x20, 0x1a, 0x33, 0x20, 0x50, 0x75, 0x72, 0x70, 0x6f, + 0x73, 0x65, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2c, 0x20, 0x6d, + 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x06, 0x01, 0x12, 0x03, 0x50, 0x08, 0x1d, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x07, 0x12, + 0x04, 0x52, 0x00, 0x59, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x03, 0x52, 0x08, + 0x19, 0x0a, 0x35, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x03, 0x55, 0x02, 0x10, 0x1a, 0x28, + 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x75, 0x6e, 0x69, + 0x71, 0x75, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x0a, 0x20, 0x2b, 0x72, + 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, + 0x05, 0x12, 0x03, 0x55, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x55, 0x09, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x03, 0x12, 0x03, 0x55, + 0x0e, 0x0f, 0x0a, 0x39, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x01, 0x12, 0x03, 0x58, 0x02, 0x11, 0x1a, + 0x2c, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2c, 0x20, 0x6f, 0x72, 0x67, 0x20, + 0x6b, 0x65, 0x79, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x01, 0x05, 0x12, 0x03, 0x58, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x01, 0x01, 0x12, 0x03, 0x58, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x01, 0x03, 0x12, 0x03, 0x58, 0x0f, 0x10, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x04, 0x5b, + 0x00, 0x5e, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x08, 0x01, 0x12, 0x03, 0x5b, 0x08, 0x1a, 0x0a, + 0x18, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x00, 0x12, 0x03, 0x5d, 0x02, 0x16, 0x1a, 0x0b, 0x20, 0x2b, + 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x5d, 0x02, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x5d, 0x0a, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x5d, 0x14, 0x15, 0x0a, 0x88, 0x01, 0x0a, 0x02, 0x04, 0x09, 0x12, 0x04, 0x62, 0x00, 0x77, 0x01, + 0x1a, 0x7c, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, + 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, + 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, + 0x6e, 0x67, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x66, 0x69, 0x6c, + 0x74, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x20, 0x53, 0x65, 0x65, 0x20, 0x3a, 0x72, 0x65, 0x66, 0x3a, + 0x60, 0x72, 0x65, 0x66, 0x5f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x2e, 0x61, 0x64, + 0x6d, 0x69, 0x6e, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x60, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x0a, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, 0x03, 0x62, 0x08, 0x1b, 0x0a, 0x4a, 0x0a, 0x04, 0x04, 0x09, + 0x02, 0x00, 0x12, 0x03, 0x65, 0x02, 0x13, 0x1a, 0x3d, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, + 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, + 0x66, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, + 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x65, 0x64, 0x2e, 0x0a, 0x20, 0x2b, 0x72, 0x65, 0x71, + 0x75, 0x69, 0x72, 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x05, 0x12, + 0x03, 0x65, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x03, 0x65, + 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, 0x03, 0x65, 0x11, 0x12, + 0x0a, 0x8f, 0x01, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x01, 0x12, 0x03, 0x6a, 0x02, 0x13, 0x1a, 0x81, + 0x01, 0x20, 0x49, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x6f, 0x66, + 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x70, 0x61, 0x67, 0x65, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2d, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, + 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x65, 0x74, 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6e, 0x65, 0x78, 0x74, 0x20, 0x70, 0x61, 0x67, 0x65, 0x0a, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x05, 0x12, 0x03, 0x6a, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x01, 0x12, 0x03, 0x6a, 0x09, 0x0e, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x03, 0x12, 0x03, 0x6a, 0x11, 0x12, 0x0a, 0x73, 0x0a, 0x04, + 0x04, 0x09, 0x02, 0x02, 0x12, 0x03, 0x6f, 0x02, 0x15, 0x1a, 0x66, 0x20, 0x49, 0x6e, 0x64, 0x69, + 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, + 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x61, + 0x73, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x20, 0x4d, 0x6f, 0x72, 0x65, 0x20, + 0x69, 0x6e, 0x66, 0x6f, 0x20, 0x6f, 0x6e, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x20, 0x3a, 0x20, 0x3c, + 0x4c, 0x69, 0x6e, 0x6b, 0x3e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x05, 0x12, 0x03, 0x6f, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x01, 0x12, 0x03, 0x6f, 0x09, 0x10, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x09, 0x02, 0x02, 0x03, 0x12, 0x03, 0x6f, 0x13, 0x14, 0x0a, 0x28, 0x0a, 0x04, 0x04, + 0x09, 0x02, 0x03, 0x12, 0x03, 0x73, 0x02, 0x24, 0x1a, 0x1b, 0x20, 0x53, 0x6f, 0x72, 0x74, 0x20, + 0x6f, 0x72, 0x64, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x20, 0x2b, 0x6f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, 0x06, 0x12, 0x03, + 0x73, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, 0x01, 0x12, 0x03, 0x73, 0x18, + 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, 0x03, 0x12, 0x03, 0x73, 0x22, 0x23, 0x0a, + 0x45, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x04, 0x12, 0x03, 0x76, 0x02, 0x11, 0x1a, 0x38, 0x20, 0x4f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2c, 0x20, 0x6f, 0x72, 0x67, 0x20, 0x66, 0x69, 0x6c, + 0x74, 0x65, 0x72, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x6c, + 0x69, 0x73, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x04, 0x05, 0x12, + 0x03, 0x76, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x04, 0x01, 0x12, 0x03, 0x76, + 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x04, 0x03, 0x12, 0x03, 0x76, 0x0f, 0x10, + 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x04, 0x79, 0x00, 0x7c, 0x01, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x0a, 0x01, 0x12, 0x03, 0x79, 0x08, 0x1c, 0x0a, 0x18, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x00, + 0x12, 0x03, 0x7b, 0x02, 0x18, 0x1a, 0x0b, 0x20, 0x2b, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, + 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x06, 0x12, 0x03, 0x7b, 0x02, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x03, 0x7b, 0x0b, 0x13, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, 0x03, 0x7b, 0x16, 0x17, 0x0a, 0x0b, 0x0a, 0x02, + 0x06, 0x00, 0x12, 0x05, 0x7e, 0x00, 0x89, 0x01, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x06, 0x00, 0x01, + 0x12, 0x03, 0x7e, 0x08, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x00, 0x12, 0x03, 0x7f, + 0x02, 0x4c, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x7f, 0x06, 0x13, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x7f, 0x14, 0x28, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x7f, 0x33, 0x48, 0x0a, 0x5c, 0x0a, 0x04, + 0x06, 0x00, 0x02, 0x01, 0x12, 0x04, 0x82, 0x01, 0x02, 0x4c, 0x1a, 0x4e, 0x20, 0x69, 0x74, 0x20, + 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x64, 0x20, + 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x20, 0x61, + 0x73, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x20, 0x76, 0x69, 0x61, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x41, 0x50, 0x49, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x01, 0x01, 0x12, 0x04, 0x82, 0x01, 0x06, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x06, 0x00, 0x02, + 0x01, 0x02, 0x12, 0x04, 0x82, 0x01, 0x14, 0x28, 0x0a, 0x0d, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, + 0x03, 0x12, 0x04, 0x82, 0x01, 0x33, 0x48, 0x0a, 0x0e, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x02, 0x12, + 0x06, 0x84, 0x01, 0x02, 0x86, 0x01, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x01, + 0x12, 0x04, 0x84, 0x01, 0x06, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x02, 0x12, + 0x04, 0x84, 0x01, 0x11, 0x22, 0x0a, 0x0d, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x03, 0x12, 0x04, + 0x84, 0x01, 0x2d, 0x3f, 0x0a, 0x0d, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x04, 0x12, 0x04, 0x85, + 0x01, 0x04, 0x2f, 0x0a, 0x0e, 0x0a, 0x06, 0x06, 0x00, 0x02, 0x02, 0x04, 0x22, 0x12, 0x04, 0x85, + 0x01, 0x04, 0x2f, 0x0a, 0x0c, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x03, 0x12, 0x04, 0x88, 0x01, 0x02, + 0x49, 0x0a, 0x0d, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x01, 0x12, 0x04, 0x88, 0x01, 0x06, 0x12, + 0x0a, 0x0d, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x02, 0x12, 0x04, 0x88, 0x01, 0x13, 0x26, 0x0a, + 0x0d, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x03, 0x12, 0x04, 0x88, 0x01, 0x31, 0x45, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +]; +include!("flyteidl2.project.tonic.rs"); +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/flyteidl2.project.tonic.rs b/gen/rust/src/flyteidl2.project.tonic.rs new file mode 100644 index 0000000000..eed3280f46 --- /dev/null +++ b/gen/rust/src/flyteidl2.project.tonic.rs @@ -0,0 +1,534 @@ +// @generated +/// Generated client implementations. +pub mod project_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + /// + #[derive(Debug, Clone)] + pub struct ProjectServiceClient { + inner: tonic::client::Grpc, + } + impl ProjectServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl ProjectServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> ProjectServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + ProjectServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /// + pub async fn create_project( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.project.ProjectService/CreateProject", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.project.ProjectService", "CreateProject"), + ); + self.inner.unary(req, path, codec).await + } + /** it will be ignored in the handler as domains cannot be updated via this API. +*/ + pub async fn update_project( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.project.ProjectService/UpdateProject", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.project.ProjectService", "UpdateProject"), + ); + self.inner.unary(req, path, codec).await + } + /// + pub async fn get_project( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.project.ProjectService/GetProject", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.project.ProjectService", "GetProject"), + ); + self.inner.unary(req, path, codec).await + } + /// + pub async fn list_projects( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.project.ProjectService/ListProjects", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.project.ProjectService", "ListProjects"), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod project_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with ProjectServiceServer. + #[async_trait] + pub trait ProjectService: Send + Sync + 'static { + /// + async fn create_project( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /** it will be ignored in the handler as domains cannot be updated via this API. +*/ + async fn update_project( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// + async fn get_project( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// + async fn list_projects( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + /// + #[derive(Debug)] + pub struct ProjectServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl ProjectServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for ProjectServiceServer + where + T: ProjectService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.project.ProjectService/CreateProject" => { + #[allow(non_camel_case_types)] + struct CreateProjectSvc(pub Arc); + impl< + T: ProjectService, + > tonic::server::UnaryService + for CreateProjectSvc { + type Response = super::CreateProjectResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::create_project(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = CreateProjectSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.project.ProjectService/UpdateProject" => { + #[allow(non_camel_case_types)] + struct UpdateProjectSvc(pub Arc); + impl< + T: ProjectService, + > tonic::server::UnaryService + for UpdateProjectSvc { + type Response = super::UpdateProjectResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::update_project(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = UpdateProjectSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.project.ProjectService/GetProject" => { + #[allow(non_camel_case_types)] + struct GetProjectSvc(pub Arc); + impl< + T: ProjectService, + > tonic::server::UnaryService + for GetProjectSvc { + type Response = super::GetProjectResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_project(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetProjectSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.project.ProjectService/ListProjects" => { + #[allow(non_camel_case_types)] + struct ListProjectsSvc(pub Arc); + impl< + T: ProjectService, + > tonic::server::UnaryService + for ListProjectsSvc { + type Response = super::ListProjectsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::list_projects(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ListProjectsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for ProjectServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService for ProjectServiceServer { + const NAME: &'static str = "flyteidl2.project.ProjectService"; + } +} diff --git a/gen/rust/src/flyteidl2.secret.rs b/gen/rust/src/flyteidl2.secret.rs new file mode 100644 index 0000000000..944ba8fb0a --- /dev/null +++ b/gen/rust/src/flyteidl2.secret.rs @@ -0,0 +1,1041 @@ +// @generated +// This file is @generated by prost-build. +/// SecretSpec contains information used for creating/updating the secret. +/// Mainly it contains the value of the secret +/// In future we could add meta info like tags, rotation config, whether stored secret has any binary format etc for storage/retrieval. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SecretSpec { + /// The secret type + #[prost(enumeration="SecretType", tag="3")] + pub r#type: i32, + #[prost(oneof="secret_spec::Value", tags="1, 2")] + pub value: ::core::option::Option, +} +/// Nested message and enum types in `SecretSpec`. +pub mod secret_spec { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Value { + #[prost(string, tag="1")] + StringValue(::prost::alloc::string::String), + #[prost(bytes, tag="2")] + BinaryValue(::prost::alloc::vec::Vec), + } +} +/// SecretIdentifier contains the uniquely identifiable way of storing or retrieving the secret +/// Name and scope combination are used for defining the format for storage and retrieval of the secret +/// For eg : for org scope secrets +/// storage format org::name:secret-name +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SecretIdentifier { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// Only org scoped resources are supported right now + #[prost(string, tag="2")] + pub organization: ::prost::alloc::string::String, + /// domain scoped secret + #[prost(string, tag="3")] + pub domain: ::prost::alloc::string::String, + /// Project-domain scoped secret + #[prost(string, tag="4")] + pub project: ::prost::alloc::string::String, +} +/// SecretMetadata contain meta info about the secret +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SecretMetadata { + /// created_time of the secret. + #[prost(message, optional, tag="1")] + pub created_time: ::core::option::Option, + /// secret_status reports the overall status of the secret across all the clusters. + /// This relies on number of clusters queried which relies on there enabled state. + #[prost(message, optional, tag="2")] + pub secret_status: ::core::option::Option, + /// The secret type + #[prost(enumeration="SecretType", tag="3")] + pub r#type: i32, +} +/// SecretStatus contains the status of the secret across all the clusters +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SecretStatus { + /// overall_status reports the overall status of the secret across all the clusters. + #[prost(enumeration="OverallStatus", tag="1")] + pub overall_status: i32, + /// cluster_status reports the status of the secret in each cluster + #[prost(message, repeated, tag="2")] + pub cluster_status: ::prost::alloc::vec::Vec, +} +/// ClusterSecretStatus contains the status of the secret in a cluster +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ClusterSecretStatus { + #[prost(message, optional, tag="1")] + pub cluster: ::core::option::Option, + /// presence_status reports the status of the secret in the cluster + #[prost(enumeration="SecretPresenceStatus", tag="2")] + pub presence_status: i32, +} +/// Secret is the returned object for Get and List calls which returns the identifier of the secret along with +/// meta information in future about the creation data, update date, tags etc +/// This doesn't contain the value of the secret +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Secret { + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub secret_metadata: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum SecretType { + /// Default, unspecified secret type. Assumed to be generic and no type specific handling required. + Generic = 0, + /// Secret used specifically for pulling images from a container registry. + ImagePullSecret = 1, +} +impl SecretType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + SecretType::Generic => "SECRET_TYPE_GENERIC", + SecretType::ImagePullSecret => "SECRET_TYPE_IMAGE_PULL_SECRET", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "SECRET_TYPE_GENERIC" => Some(Self::Generic), + "SECRET_TYPE_IMAGE_PULL_SECRET" => Some(Self::ImagePullSecret), + _ => None, + } + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum OverallStatus { + Unspecified = 0, + /// Exists in some cluster + PartiallyPresent = 1, + /// Exists in all enabled clusters + FullyPresent = 2, + /// Status is unknown + UnknownStatus = 3, +} +impl OverallStatus { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + OverallStatus::Unspecified => "UNSPECIFIED", + OverallStatus::PartiallyPresent => "PARTIALLY_PRESENT", + OverallStatus::FullyPresent => "FULLY_PRESENT", + OverallStatus::UnknownStatus => "UNKNOWN_STATUS", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNSPECIFIED" => Some(Self::Unspecified), + "PARTIALLY_PRESENT" => Some(Self::PartiallyPresent), + "FULLY_PRESENT" => Some(Self::FullyPresent), + "UNKNOWN_STATUS" => Some(Self::UnknownStatus), + _ => None, + } + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum SecretPresenceStatus { + Unknown = 0, + /// Secret is missing in the cluster + Missing = 1, + /// Secret is present in the cluster + Present = 2, +} +impl SecretPresenceStatus { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + SecretPresenceStatus::Unknown => "UNKNOWN", + SecretPresenceStatus::Missing => "MISSING", + SecretPresenceStatus::Present => "PRESENT", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNKNOWN" => Some(Self::Unknown), + "MISSING" => Some(Self::Missing), + "PRESENT" => Some(Self::Present), + _ => None, + } + } +} +/// CreateSecretProxyRequest contains the spec and identifier used for secret creation +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateSecretRequest { + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub secret_spec: ::core::option::Option, +} +/// CreateSecretResponse +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct CreateSecretResponse { +} +/// UpdateSecretProxyRequest contains the spec and identifier used for secret updation +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UpdateSecretRequest { + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub secret_spec: ::core::option::Option, +} +/// UpdateSecretResponse returns an empty response if the secret is successfully updated +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct UpdateSecretResponse { +} +/// GetSecretRequest contains the identifier used for looking up the secret +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetSecretRequest { + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, +} +/// GetSecretProxyResponse returns the looked up secret from the secret service +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetSecretResponse { + #[prost(message, optional, tag="1")] + pub secret: ::core::option::Option, +} +/// DeleteSecretRequest contains the identifier used for looking up the secret for deletion +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DeleteSecretRequest { + /// name to be used for looking up the secret + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, +} +/// DeleteSecretResponse is an empty response right now on successfully deleting the secret. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct DeleteSecretResponse { +} +/// ListSecretsRequest is used for listing all the secrets accessible to the user at the passed in scope. +/// With org scope, user is given all secrets at org, domain, project-domain level etc +/// And returns paginated results +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListSecretsRequest { + /// Only org scoped resources are supported right now + #[prost(string, tag="1")] + pub organization: ::prost::alloc::string::String, + /// domain scoped secret + #[prost(string, tag="2")] + pub domain: ::prost::alloc::string::String, + /// Project-domain scoped secret + #[prost(string, tag="3")] + pub project: ::prost::alloc::string::String, + /// Max page results + #[prost(int32, tag="4")] + pub limit: i32, + /// Leave this empty if you are getting the first set of results. The next_token would be set in the response that can be used to fetch the next set of results. + #[prost(string, tag="5")] + pub token: ::prost::alloc::string::String, + /// Per cluster token. This allows the service to return paginated results per cluster. + /// Service collates the results from all clusters and returns the next token for each cluster. + /// The client can use the next token for each cluster to fetch the next page of results. + /// In multi cluster, inorder to page through next set of results, client needs to send this token in the next request + #[prost(map="string, string", tag="6")] + pub per_cluster_tokens: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, +} +/// ListSecretsResponse returns paginated results of the accessible secrets at the scope defined in the request. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListSecretsResponse { + #[prost(message, repeated, tag="1")] + pub secrets: ::prost::alloc::vec::Vec, + /// next token to use for fetching new page results. + #[prost(string, tag="2")] + pub token: ::prost::alloc::string::String, + /// Per cluster token. This allows the service to return paginated results per cluster. + /// Service collates the results from all clusters and returns the next token for each cluster. + /// The client can use the next token for each cluster to fetch the next page of results. + /// In multi cluster, inorder to page through next set of results, client needs to send this token in the next request + #[prost(map="string, string", tag="3")] + pub per_cluster_tokens: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, +} +/// Encoded file descriptor set for the `flyteidl2.secret` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xe2, 0x27, 0x0a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x2f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x98, 0x01, 0x0a, 0x0a, 0x53, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x53, 0x70, 0x65, 0x63, 0x12, 0x23, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, + 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23, 0x0a, + 0x0c, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0b, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x12, 0x30, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, + 0x74, 0x79, 0x70, 0x65, 0x42, 0x0e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x05, 0xba, + 0x48, 0x02, 0x08, 0x01, 0x22, 0x97, 0x01, 0x0a, 0x10, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x2d, 0x0a, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x19, 0xba, 0x48, 0x16, 0x72, 0x14, 0x10, 0x01, + 0x32, 0x10, 0x5e, 0x5b, 0x2d, 0x61, 0x2d, 0x7a, 0x41, 0x2d, 0x5a, 0x30, 0x2d, 0x39, 0x5f, 0x5d, + 0x2b, 0x24, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x22, 0x0a, 0x0c, 0x6f, 0x72, 0x67, 0x61, + 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, + 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, + 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x64, 0x6f, + 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x22, 0xc6, + 0x01, 0x0a, 0x0e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x12, 0x3d, 0x0a, 0x0c, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x69, 0x6d, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x52, 0x0b, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x54, 0x69, 0x6d, 0x65, + 0x12, 0x43, 0x0a, 0x0d, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x0c, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x30, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x54, 0x79, 0x70, + 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0xa4, 0x01, 0x0a, 0x0c, 0x53, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x46, 0x0a, 0x0e, 0x6f, 0x76, 0x65, 0x72, + 0x61, 0x6c, 0x6c, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x2e, 0x4f, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x52, 0x0d, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x12, 0x4c, 0x0a, 0x0e, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x43, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, + 0x0d, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0xa5, + 0x01, 0x0a, 0x13, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x3d, 0x0a, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x07, 0x63, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, 0x4f, 0x0a, 0x0f, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, + 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x0e, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x87, 0x01, 0x0a, 0x06, 0x53, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x12, 0x32, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x52, 0x02, 0x69, 0x64, 0x12, 0x49, 0x0a, 0x0f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x52, 0x0e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x2a, 0x48, 0x0a, 0x0a, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x17, + 0x0a, 0x13, 0x53, 0x45, 0x43, 0x52, 0x45, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x47, 0x45, + 0x4e, 0x45, 0x52, 0x49, 0x43, 0x10, 0x00, 0x12, 0x21, 0x0a, 0x1d, 0x53, 0x45, 0x43, 0x52, 0x45, + 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4d, 0x41, 0x47, 0x45, 0x5f, 0x50, 0x55, 0x4c, + 0x4c, 0x5f, 0x53, 0x45, 0x43, 0x52, 0x45, 0x54, 0x10, 0x01, 0x2a, 0x5e, 0x0a, 0x0d, 0x4f, 0x76, + 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0f, 0x0a, 0x0b, 0x55, + 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x15, 0x0a, 0x11, + 0x50, 0x41, 0x52, 0x54, 0x49, 0x41, 0x4c, 0x4c, 0x59, 0x5f, 0x50, 0x52, 0x45, 0x53, 0x45, 0x4e, + 0x54, 0x10, 0x01, 0x12, 0x11, 0x0a, 0x0d, 0x46, 0x55, 0x4c, 0x4c, 0x59, 0x5f, 0x50, 0x52, 0x45, + 0x53, 0x45, 0x4e, 0x54, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, + 0x4e, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x10, 0x03, 0x2a, 0x3d, 0x0a, 0x14, 0x53, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, + 0x0b, 0x0a, 0x07, 0x4d, 0x49, 0x53, 0x53, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, + 0x50, 0x52, 0x45, 0x53, 0x45, 0x4e, 0x54, 0x10, 0x02, 0x42, 0xbe, 0x01, 0x0a, 0x14, 0x63, 0x6f, + 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x42, 0x0f, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, + 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0xa2, 0x02, 0x03, 0x46, 0x53, + 0x58, 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x53, 0x65, + 0x63, 0x72, 0x65, 0x74, 0xca, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0xe2, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x3a, 0x3a, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4a, 0xc0, 0x1b, 0x0a, 0x06, 0x12, + 0x04, 0x00, 0x00, 0x5f, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, + 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x19, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, + 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x2b, 0x0a, + 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, 0x29, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, + 0x03, 0x08, 0x00, 0x4b, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x08, 0x00, 0x4b, 0x0a, + 0x0a, 0x0a, 0x02, 0x05, 0x00, 0x12, 0x04, 0x0a, 0x00, 0x0f, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, + 0x00, 0x01, 0x12, 0x03, 0x0a, 0x05, 0x0f, 0x0a, 0x6e, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x00, 0x12, + 0x03, 0x0c, 0x02, 0x1a, 0x1a, 0x61, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x2c, 0x20, + 0x75, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x20, 0x41, 0x73, 0x73, 0x75, 0x6d, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x20, 0x61, + 0x6e, 0x64, 0x20, 0x6e, 0x6f, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x63, 0x20, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x65, 0x71, + 0x75, 0x69, 0x72, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x0c, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, + 0x0c, 0x18, 0x19, 0x0a, 0x55, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0e, 0x02, 0x24, + 0x1a, 0x48, 0x20, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x70, 0x75, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x20, 0x66, + 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, + 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x0e, 0x02, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, + 0x02, 0x12, 0x03, 0x0e, 0x22, 0x23, 0x0a, 0x86, 0x02, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x14, + 0x00, 0x1e, 0x01, 0x1a, 0xf9, 0x01, 0x20, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x53, 0x70, 0x65, + 0x63, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, + 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x2f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x69, 0x6e, + 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x0a, 0x20, 0x4d, + 0x61, 0x69, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x0a, 0x20, 0x49, 0x6e, 0x20, 0x66, 0x75, + 0x74, 0x75, 0x72, 0x65, 0x20, 0x77, 0x65, 0x20, 0x63, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x61, 0x64, + 0x64, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x20, 0x6c, 0x69, 0x6b, 0x65, + 0x20, 0x74, 0x61, 0x67, 0x73, 0x2c, 0x20, 0x72, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2c, 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, + 0x73, 0x74, 0x6f, 0x72, 0x65, 0x64, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x68, 0x61, + 0x73, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x20, 0x66, 0x6f, 0x72, + 0x6d, 0x61, 0x74, 0x20, 0x65, 0x74, 0x63, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x74, 0x6f, 0x72, + 0x61, 0x67, 0x65, 0x2f, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x61, 0x6c, 0x2e, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x14, 0x08, 0x12, 0x0a, 0x0c, 0x0a, 0x04, 0x04, + 0x00, 0x08, 0x00, 0x12, 0x04, 0x15, 0x02, 0x1a, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x08, + 0x00, 0x01, 0x12, 0x03, 0x15, 0x08, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x08, 0x00, 0x02, + 0x12, 0x03, 0x16, 0x04, 0x30, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x08, 0x00, 0x02, 0x87, 0x09, + 0x01, 0x12, 0x03, 0x16, 0x04, 0x30, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, + 0x18, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x18, 0x04, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x18, 0x0b, 0x17, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x18, 0x1a, 0x1b, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x19, 0x04, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x01, 0x05, 0x12, 0x03, 0x19, 0x04, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x19, 0x0a, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x19, 0x19, 0x1a, 0x0a, 0x1e, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x1d, 0x02, + 0x16, 0x1a, 0x11, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x74, + 0x79, 0x70, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x1d, + 0x02, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x1d, 0x0d, 0x11, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x1d, 0x14, 0x15, 0x0a, 0x9f, + 0x02, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x24, 0x00, 0x2f, 0x01, 0x1a, 0x92, 0x02, 0x20, 0x53, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x69, + 0x71, 0x75, 0x65, 0x6c, 0x79, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x61, 0x62, + 0x6c, 0x65, 0x20, 0x77, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x6e, + 0x67, 0x20, 0x6f, 0x72, 0x20, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x69, 0x6e, 0x67, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x0a, 0x20, 0x4e, 0x61, 0x6d, 0x65, + 0x20, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x62, 0x69, + 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x72, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x74, 0x6f, 0x72, + 0x61, 0x67, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x61, + 0x6c, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x0a, + 0x20, 0x46, 0x6f, 0x72, 0x20, 0x65, 0x67, 0x20, 0x3a, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x72, + 0x67, 0x20, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x0a, + 0x20, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, + 0x6f, 0x72, 0x67, 0x3a, 0x3c, 0x6f, 0x72, 0x67, 0x2d, 0x6e, 0x61, 0x6d, 0x65, 0x3e, 0x3a, 0x6e, + 0x61, 0x6d, 0x65, 0x3a, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2d, 0x6e, 0x61, 0x6d, 0x65, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x24, 0x08, 0x18, 0x0a, 0x0c, 0x0a, 0x04, + 0x04, 0x01, 0x02, 0x00, 0x12, 0x04, 0x25, 0x02, 0x28, 0x04, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x05, 0x12, 0x03, 0x25, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x25, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x25, 0x10, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x08, 0x12, 0x04, 0x25, + 0x12, 0x28, 0x03, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x01, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, + 0x12, 0x03, 0x26, 0x04, 0x2b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x01, 0x02, 0x00, 0x08, 0x87, 0x09, + 0x0e, 0x06, 0x12, 0x03, 0x27, 0x04, 0x3c, 0x0a, 0x40, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, + 0x03, 0x2a, 0x02, 0x1a, 0x1a, 0x33, 0x20, 0x4f, 0x6e, 0x6c, 0x79, 0x20, 0x6f, 0x72, 0x67, 0x20, + 0x73, 0x63, 0x6f, 0x70, 0x65, 0x64, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, + 0x20, 0x61, 0x72, 0x65, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x20, 0x6e, 0x6f, 0x77, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x01, 0x05, 0x12, 0x03, 0x2a, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x2a, 0x09, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x2a, 0x18, 0x19, 0x0a, 0x23, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x2c, 0x02, 0x14, + 0x1a, 0x16, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x64, + 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, + 0x05, 0x12, 0x03, 0x2c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x2c, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x2c, + 0x12, 0x13, 0x0a, 0x2b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x03, 0x12, 0x03, 0x2e, 0x02, 0x15, 0x1a, + 0x1e, 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2d, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, + 0x20, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x64, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x05, 0x12, 0x03, 0x2e, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x03, 0x01, 0x12, 0x03, 0x2e, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x03, 0x03, 0x12, 0x03, 0x2e, 0x13, 0x14, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x01, 0x12, + 0x04, 0x31, 0x00, 0x36, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x01, 0x01, 0x12, 0x03, 0x31, 0x05, + 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x01, 0x02, 0x00, 0x12, 0x03, 0x32, 0x02, 0x12, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x32, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x01, 0x02, 0x00, 0x02, 0x12, 0x03, 0x32, 0x10, 0x11, 0x0a, 0x25, 0x0a, 0x04, 0x05, 0x01, + 0x02, 0x01, 0x12, 0x03, 0x33, 0x02, 0x18, 0x22, 0x18, 0x20, 0x45, 0x78, 0x69, 0x73, 0x74, 0x73, + 0x20, 0x69, 0x6e, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x33, 0x02, 0x13, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x01, 0x02, 0x12, 0x03, 0x33, 0x16, 0x17, 0x0a, 0x2d, 0x0a, + 0x04, 0x05, 0x01, 0x02, 0x02, 0x12, 0x03, 0x34, 0x02, 0x14, 0x22, 0x20, 0x20, 0x45, 0x78, 0x69, + 0x73, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x65, 0x6e, 0x61, 0x62, 0x6c, + 0x65, 0x64, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x34, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, + 0x02, 0x02, 0x02, 0x12, 0x03, 0x34, 0x12, 0x13, 0x0a, 0x20, 0x0a, 0x04, 0x05, 0x01, 0x02, 0x03, + 0x12, 0x03, 0x35, 0x02, 0x15, 0x22, 0x13, 0x20, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x69, + 0x73, 0x20, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, + 0x02, 0x03, 0x01, 0x12, 0x03, 0x35, 0x02, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x03, + 0x02, 0x12, 0x03, 0x35, 0x13, 0x14, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x02, 0x12, 0x04, 0x38, 0x00, + 0x3c, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x02, 0x01, 0x12, 0x03, 0x38, 0x05, 0x19, 0x0a, 0x0b, + 0x0a, 0x04, 0x05, 0x02, 0x02, 0x00, 0x12, 0x03, 0x39, 0x02, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x39, 0x02, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, + 0x00, 0x02, 0x12, 0x03, 0x39, 0x0c, 0x0d, 0x0a, 0x2f, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x3a, 0x02, 0x0e, 0x22, 0x22, 0x20, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x69, 0x73, + 0x20, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x3a, 0x02, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x01, 0x02, 0x12, + 0x03, 0x3a, 0x0c, 0x0d, 0x0a, 0x2f, 0x0a, 0x04, 0x05, 0x02, 0x02, 0x02, 0x12, 0x03, 0x3b, 0x02, + 0x0e, 0x22, 0x22, 0x20, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x69, 0x73, 0x20, 0x70, 0x72, + 0x65, 0x73, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x3b, 0x02, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x02, 0x02, 0x02, 0x02, 0x12, 0x03, 0x3b, 0x0c, + 0x0d, 0x0a, 0x3f, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x3f, 0x00, 0x48, 0x01, 0x1a, 0x33, 0x20, + 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x63, + 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x20, 0x69, 0x6e, 0x66, 0x6f, + 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x3f, 0x08, 0x16, 0x0a, 0x2a, + 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x41, 0x02, 0x2d, 0x1a, 0x1d, 0x20, 0x63, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x00, 0x06, 0x12, 0x03, 0x41, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x41, 0x1c, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x41, 0x2b, 0x2c, 0x0a, 0xaf, 0x01, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x44, + 0x02, 0x21, 0x1a, 0xa1, 0x01, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x20, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6f, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x61, 0x63, 0x72, + 0x6f, 0x73, 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x72, 0x65, 0x6c, 0x69, + 0x65, 0x73, 0x20, 0x6f, 0x6e, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, + 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, 0x20, 0x71, 0x75, 0x65, 0x72, 0x69, 0x65, 0x64, + 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x72, 0x65, 0x6c, 0x69, 0x65, 0x73, 0x20, 0x6f, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x20, 0x73, + 0x74, 0x61, 0x74, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, + 0x03, 0x44, 0x02, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x44, + 0x0f, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x44, 0x1f, 0x20, + 0x0a, 0x1e, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x02, 0x12, 0x03, 0x47, 0x02, 0x16, 0x1a, 0x11, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x06, 0x12, 0x03, 0x47, 0x02, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, 0x47, 0x0d, 0x11, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x02, 0x03, 0x12, 0x03, 0x47, 0x14, 0x15, 0x0a, 0x54, 0x0a, 0x02, 0x04, 0x03, + 0x12, 0x04, 0x4b, 0x00, 0x50, 0x01, 0x1a, 0x48, 0x20, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x61, 0x63, 0x72, 0x6f, 0x73, 0x73, 0x20, 0x61, + 0x6c, 0x6c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x4b, 0x08, 0x14, 0x0a, 0x5f, 0x0a, 0x04, + 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x4d, 0x02, 0x23, 0x1a, 0x52, 0x20, 0x6f, 0x76, 0x65, 0x72, + 0x61, 0x6c, 0x6c, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x72, 0x65, 0x70, 0x6f, 0x72, + 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x20, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x20, 0x61, 0x63, 0x72, 0x6f, 0x73, 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x4d, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x4d, 0x10, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x4d, 0x21, 0x22, 0x0a, 0x4e, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, + 0x03, 0x4f, 0x02, 0x32, 0x1a, 0x41, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x63, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x04, + 0x12, 0x03, 0x4f, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x06, 0x12, 0x03, + 0x4f, 0x0b, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, 0x4f, 0x1f, + 0x2d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x4f, 0x30, 0x31, 0x0a, + 0x50, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x53, 0x00, 0x57, 0x01, 0x1a, 0x44, 0x20, 0x43, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x53, 0x08, 0x1b, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x54, 0x02, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x00, 0x06, 0x12, 0x03, 0x54, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x54, 0x1b, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x54, 0x25, 0x26, 0x0a, 0x4e, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x56, 0x02, + 0x2b, 0x1a, 0x41, 0x20, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x20, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x06, 0x12, 0x03, 0x56, + 0x02, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x56, 0x17, 0x26, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x56, 0x29, 0x2a, 0x0a, 0xf2, + 0x01, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x5c, 0x00, 0x5f, 0x01, 0x1a, 0xe5, 0x01, 0x20, 0x53, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x74, + 0x75, 0x72, 0x6e, 0x65, 0x64, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x47, 0x65, 0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x63, 0x61, + 0x6c, 0x6c, 0x73, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x61, + 0x6c, 0x6f, 0x6e, 0x67, 0x20, 0x77, 0x69, 0x74, 0x68, 0x0a, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x20, + 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x66, + 0x75, 0x74, 0x75, 0x72, 0x65, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2c, 0x20, 0x75, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x20, 0x64, 0x61, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x61, 0x67, 0x73, + 0x20, 0x65, 0x74, 0x63, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x6e, + 0x27, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x5c, 0x08, 0x0e, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x5d, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x00, 0x06, 0x12, 0x03, 0x5d, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x5d, 0x13, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x5d, 0x18, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x03, + 0x5e, 0x02, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x06, 0x12, 0x03, 0x5e, 0x02, + 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, 0x12, 0x03, 0x5e, 0x11, 0x20, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x03, 0x5e, 0x23, 0x24, 0x62, 0x06, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xdc, 0x26, 0x0a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2f, 0x70, 0x61, 0x79, 0x6c, 0x6f, + 0x61, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x90, 0x01, 0x0a, 0x13, 0x43, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x3a, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3d, + 0x0a, 0x0b, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x53, 0x70, 0x65, + 0x63, 0x52, 0x0a, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x53, 0x70, 0x65, 0x63, 0x22, 0x16, 0x0a, + 0x14, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x90, 0x01, 0x0a, 0x13, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3a, 0x0a, + 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x53, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, + 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3d, 0x0a, 0x0b, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0a, 0x73, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x53, 0x70, 0x65, 0x63, 0x22, 0x16, 0x0a, 0x14, 0x55, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x4e, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x3a, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, + 0x22, 0x45, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x30, 0x0a, 0x06, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, + 0x06, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x22, 0x51, 0x0a, 0x13, 0x44, 0x65, 0x6c, 0x65, 0x74, + 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3a, + 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x53, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, + 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x22, 0x16, 0x0a, 0x14, 0x44, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0xc5, 0x02, 0x0a, 0x12, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x22, 0x0a, 0x0c, 0x6f, 0x72, 0x67, + 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0c, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, + 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x64, + 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, + 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, + 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x68, 0x0a, 0x12, 0x70, + 0x65, 0x72, 0x5f, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, + 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x53, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x50, 0x65, + 0x72, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x52, 0x10, 0x70, 0x65, 0x72, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x54, + 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x1a, 0x43, 0x0a, 0x15, 0x50, 0x65, 0x72, 0x43, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, + 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, + 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x8f, 0x02, 0x0a, 0x13, 0x4c, + 0x69, 0x73, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x32, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x07, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x69, 0x0a, 0x12, + 0x70, 0x65, 0x72, 0x5f, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x74, 0x6f, 0x6b, 0x65, + 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x4c, 0x69, 0x73, 0x74, + 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, + 0x50, 0x65, 0x72, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, 0x70, 0x65, 0x72, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x1a, 0x43, 0x0a, 0x15, 0x50, 0x65, 0x72, 0x43, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, + 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0xbb, 0x01, 0x0a, + 0x14, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x42, 0x0c, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, + 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0xa2, 0x02, 0x03, 0x46, 0x53, + 0x58, 0xaa, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x53, 0x65, + 0x63, 0x72, 0x65, 0x74, 0xca, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0xe2, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x3a, 0x3a, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4a, 0xef, 0x1a, 0x0a, 0x06, 0x12, + 0x04, 0x00, 0x00, 0x4d, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, + 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x19, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, + 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x2b, 0x0a, + 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x07, 0x00, 0x4b, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, + 0x03, 0x07, 0x00, 0x4b, 0x0a, 0x60, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0a, 0x00, 0x0d, 0x01, + 0x1a, 0x54, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x50, + 0x72, 0x6f, 0x78, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x75, 0x73, 0x65, + 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x63, 0x72, 0x65, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0a, + 0x08, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0b, 0x02, 0x41, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x0b, 0x02, 0x12, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0b, 0x13, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0b, 0x18, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x00, 0x08, 0x12, 0x03, 0x0b, 0x1a, 0x40, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x02, 0x00, 0x08, + 0x87, 0x09, 0x19, 0x12, 0x03, 0x0b, 0x1b, 0x3f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, + 0x12, 0x03, 0x0c, 0x02, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, + 0x0c, 0x02, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0c, 0x0d, + 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x0c, 0x1b, 0x1c, 0x0a, + 0x21, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x03, 0x10, 0x00, 0x1f, 0x1a, 0x16, 0x20, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x10, 0x08, 0x1c, 0x0a, 0x60, + 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x13, 0x00, 0x16, 0x01, 0x1a, 0x54, 0x20, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x69, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x13, 0x08, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x14, 0x02, 0x41, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x14, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x14, 0x13, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x14, 0x18, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x08, 0x12, 0x03, 0x14, 0x1a, + 0x40, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x02, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x14, + 0x1b, 0x3f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x15, 0x02, 0x1d, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, 0x03, 0x15, 0x02, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x15, 0x0d, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x15, 0x1b, 0x1c, 0x0a, 0x61, 0x0a, 0x02, 0x04, 0x03, 0x12, + 0x03, 0x19, 0x00, 0x1f, 0x1a, 0x56, 0x20, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x72, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, + 0x6c, 0x6c, 0x79, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x03, 0x01, 0x12, 0x03, 0x19, 0x08, 0x1c, 0x0a, 0x55, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, + 0x1c, 0x00, 0x1e, 0x01, 0x1a, 0x49, 0x20, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, + 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x69, 0x6e, 0x67, + 0x20, 0x75, 0x70, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x1c, 0x08, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x04, 0x02, 0x00, 0x12, 0x03, 0x1d, 0x02, 0x41, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, + 0x06, 0x12, 0x03, 0x1d, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x1d, 0x13, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1d, + 0x18, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x08, 0x12, 0x03, 0x1d, 0x1a, 0x40, + 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x04, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x1d, 0x1b, + 0x3f, 0x0a, 0x59, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x21, 0x00, 0x23, 0x01, 0x1a, 0x4d, 0x20, + 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x65, 0x64, 0x20, 0x75, 0x70, 0x20, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x05, 0x01, 0x12, 0x03, 0x21, 0x08, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, + 0x12, 0x03, 0x22, 0x02, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x06, 0x12, 0x03, + 0x22, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x22, 0x09, + 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x22, 0x12, 0x13, 0x0a, + 0x65, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x04, 0x26, 0x00, 0x29, 0x01, 0x1a, 0x59, 0x20, 0x44, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x75, 0x70, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x6c, + 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x03, 0x26, + 0x08, 0x1b, 0x0a, 0x38, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x03, 0x28, 0x02, 0x41, 0x1a, + 0x2b, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, + 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x75, 0x70, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x00, 0x06, 0x12, 0x03, 0x28, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x28, 0x13, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x28, 0x18, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x08, 0x12, + 0x03, 0x28, 0x1a, 0x40, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x06, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, + 0x12, 0x03, 0x28, 0x1b, 0x3f, 0x0a, 0x65, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x03, 0x2c, 0x00, 0x1f, + 0x1a, 0x5a, 0x20, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x6d, + 0x70, 0x74, 0x79, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x20, 0x6e, 0x6f, 0x77, 0x20, 0x6f, 0x6e, 0x20, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, + 0x73, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x20, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x69, 0x6e, 0x67, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x07, 0x01, 0x12, 0x03, 0x2c, 0x08, 0x1c, 0x0a, 0xe7, 0x01, 0x0a, 0x02, 0x04, 0x08, 0x12, + 0x04, 0x31, 0x00, 0x41, 0x01, 0x1a, 0xda, 0x01, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x65, 0x63, + 0x72, 0x65, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x69, 0x73, 0x20, 0x75, + 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, + 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x20, + 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, + 0x73, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x2e, 0x0a, 0x20, + 0x57, 0x69, 0x74, 0x68, 0x20, 0x6f, 0x72, 0x67, 0x20, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x2c, 0x20, + 0x75, 0x73, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x61, 0x6c, + 0x6c, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x20, 0x61, 0x74, 0x20, 0x6f, 0x72, 0x67, + 0x2c, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x2c, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x2d, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x20, 0x65, + 0x74, 0x63, 0x0a, 0x20, 0x41, 0x6e, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, + 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x64, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x73, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x08, 0x01, 0x12, 0x03, 0x31, 0x08, 0x1a, 0x0a, 0x40, + 0x0a, 0x04, 0x04, 0x08, 0x02, 0x00, 0x12, 0x03, 0x33, 0x02, 0x1a, 0x1a, 0x33, 0x20, 0x4f, 0x6e, + 0x6c, 0x79, 0x20, 0x6f, 0x72, 0x67, 0x20, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x64, 0x20, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x73, 0x75, 0x70, 0x70, + 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x6e, 0x6f, 0x77, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x05, 0x12, 0x03, 0x33, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x03, 0x33, 0x09, 0x15, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x03, 0x33, 0x18, 0x19, 0x0a, 0x23, 0x0a, 0x04, 0x04, 0x08, + 0x02, 0x01, 0x12, 0x03, 0x35, 0x02, 0x14, 0x1a, 0x16, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, + 0x20, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x64, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x05, 0x12, 0x03, 0x35, 0x02, 0x08, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x01, 0x01, 0x12, 0x03, 0x35, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x01, 0x03, 0x12, 0x03, 0x35, 0x12, 0x13, 0x0a, 0x2b, 0x0a, 0x04, 0x04, 0x08, 0x02, + 0x02, 0x12, 0x03, 0x37, 0x02, 0x15, 0x1a, 0x1e, 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x2d, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x64, 0x20, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x05, 0x12, + 0x03, 0x37, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x01, 0x12, 0x03, 0x37, + 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x03, 0x12, 0x03, 0x37, 0x13, 0x14, + 0x0a, 0x1f, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x03, 0x12, 0x03, 0x39, 0x02, 0x12, 0x1a, 0x12, 0x20, + 0x4d, 0x61, 0x78, 0x20, 0x70, 0x61, 0x67, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x05, 0x12, 0x03, 0x39, 0x02, 0x07, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x01, 0x12, 0x03, 0x39, 0x08, 0x0d, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x03, 0x03, 0x12, 0x03, 0x39, 0x10, 0x11, 0x0a, 0xac, 0x01, 0x0a, 0x04, + 0x04, 0x08, 0x02, 0x04, 0x12, 0x03, 0x3b, 0x02, 0x13, 0x1a, 0x9e, 0x01, 0x20, 0x4c, 0x65, 0x61, + 0x76, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x69, 0x66, + 0x20, 0x79, 0x6f, 0x75, 0x20, 0x61, 0x72, 0x65, 0x20, 0x67, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, + 0x66, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6e, + 0x65, 0x78, 0x74, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, + 0x62, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6e, 0x20, + 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x65, 0x74, 0x63, 0x68, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, + 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x04, 0x05, 0x12, 0x03, 0x3b, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x04, + 0x01, 0x12, 0x03, 0x3b, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x04, 0x03, 0x12, + 0x03, 0x3b, 0x11, 0x12, 0x0a, 0x8b, 0x03, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x05, 0x12, 0x03, 0x40, + 0x02, 0x2d, 0x1a, 0xfd, 0x02, 0x20, 0x50, 0x65, 0x72, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x61, 0x6c, + 0x6c, 0x6f, 0x77, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x70, 0x61, 0x67, 0x69, 0x6e, + 0x61, 0x74, 0x65, 0x64, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x70, 0x65, 0x72, + 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x2e, 0x0a, 0x20, 0x53, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x20, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x6c, 0x6c, + 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x72, 0x65, + 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x74, + 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x63, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, + 0x65, 0x78, 0x74, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x61, + 0x63, 0x68, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x65, + 0x74, 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x70, 0x61, 0x67, + 0x65, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2e, 0x0a, 0x20, 0x49, + 0x6e, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x2c, + 0x20, 0x69, 0x6e, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x67, 0x65, + 0x20, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x73, 0x65, + 0x74, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2c, 0x20, 0x63, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x65, + 0x6e, 0x64, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x69, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x06, 0x12, 0x03, 0x40, 0x02, 0x15, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x01, 0x12, 0x03, 0x40, 0x16, 0x28, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x03, 0x12, 0x03, 0x40, 0x2b, 0x2c, 0x0a, 0x7a, 0x0a, 0x02, + 0x04, 0x09, 0x12, 0x04, 0x44, 0x00, 0x4d, 0x01, 0x1a, 0x6e, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x53, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x73, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x20, + 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, + 0x03, 0x44, 0x08, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x00, 0x12, 0x03, 0x45, 0x02, + 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x04, 0x12, 0x03, 0x45, 0x02, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x06, 0x12, 0x03, 0x45, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x03, 0x45, 0x12, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x09, 0x02, 0x00, 0x03, 0x12, 0x03, 0x45, 0x1c, 0x1d, 0x0a, 0x3f, 0x0a, 0x04, 0x04, 0x09, 0x02, + 0x01, 0x12, 0x03, 0x47, 0x02, 0x13, 0x1a, 0x32, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, + 0x65, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x70, 0x61, 0x67, 0x65, + 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x01, 0x05, 0x12, 0x03, 0x47, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x47, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x47, 0x11, 0x12, 0x0a, 0x8b, 0x03, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x02, 0x12, 0x03, 0x4c, + 0x02, 0x2d, 0x1a, 0xfd, 0x02, 0x20, 0x50, 0x65, 0x72, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x61, 0x6c, + 0x6c, 0x6f, 0x77, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x70, 0x61, 0x67, 0x69, 0x6e, + 0x61, 0x74, 0x65, 0x64, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x70, 0x65, 0x72, + 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x2e, 0x0a, 0x20, 0x53, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x20, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x6c, 0x6c, + 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x72, 0x65, + 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x74, + 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x63, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, + 0x65, 0x78, 0x74, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x61, + 0x63, 0x68, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x65, + 0x74, 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x70, 0x61, 0x67, + 0x65, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2e, 0x0a, 0x20, 0x49, + 0x6e, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x2c, + 0x20, 0x69, 0x6e, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x67, 0x65, + 0x20, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x73, 0x65, + 0x74, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2c, 0x20, 0x63, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x65, + 0x6e, 0x64, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x69, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x06, 0x12, 0x03, 0x4c, 0x02, 0x15, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x01, 0x12, 0x03, 0x4c, 0x16, 0x28, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x03, 0x12, 0x03, 0x4c, 0x2b, 0x2c, 0x62, 0x06, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xea, 0x0c, 0x0a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2f, 0x70, 0x61, 0x79, 0x6c, 0x6f, + 0x61, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x90, 0x05, 0x0a, 0x0d, 0x53, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x79, 0x0a, 0x0c, 0x43, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x12, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x43, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x3a, + 0x01, 0x2a, 0x22, 0x0f, 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x12, 0x88, 0x01, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x12, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x55, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x29, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x23, 0x3a, 0x01, 0x2a, 0x1a, 0x1e, + 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, + 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, 0x7c, + 0x0a, 0x09, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x12, 0x22, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x47, + 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x20, 0x12, 0x1e, 0x2f, 0x73, + 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6e, 0x61, + 0x6d, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, 0x85, 0x01, 0x0a, + 0x0c, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x12, 0x25, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, + 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53, 0x65, + 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x20, 0x2a, 0x1e, 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x2e, 0x6e, + 0x61, 0x6d, 0x65, 0x7d, 0x12, 0x73, 0x0a, 0x0b, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x73, 0x12, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x2e, 0x4c, 0x69, 0x73, + 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x12, 0x0f, 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65, + 0x74, 0x73, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x42, 0xba, 0x01, 0x0a, 0x14, 0x63, 0x6f, + 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x73, 0x65, 0x63, 0x72, + 0x65, 0x74, 0x42, 0x0b, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, + 0x01, 0x5a, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, + 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0xa2, 0x02, 0x03, 0x46, 0x53, 0x58, 0xaa, 0x02, 0x10, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, + 0xca, 0x02, 0x10, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x53, 0x65, 0x63, + 0x72, 0x65, 0x74, 0xe2, 0x02, 0x1c, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, + 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, + 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4a, 0xa0, 0x05, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x1f, + 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, + 0x12, 0x03, 0x02, 0x00, 0x19, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x28, + 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x26, 0x0a, 0x08, 0x0a, 0x01, 0x08, + 0x12, 0x03, 0x07, 0x00, 0x4b, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x07, 0x00, 0x4b, + 0x0a, 0x0a, 0x0a, 0x02, 0x06, 0x00, 0x12, 0x04, 0x09, 0x00, 0x1f, 0x01, 0x0a, 0x0a, 0x0a, 0x03, + 0x06, 0x00, 0x01, 0x12, 0x03, 0x09, 0x08, 0x15, 0x0a, 0x0c, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x00, + 0x12, 0x04, 0x0a, 0x02, 0x0f, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x0a, 0x06, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x0a, + 0x13, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0a, 0x31, 0x45, + 0x0a, 0x0d, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x04, 0x12, 0x04, 0x0b, 0x04, 0x0e, 0x06, 0x0a, + 0x11, 0x0a, 0x09, 0x06, 0x00, 0x02, 0x00, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x12, 0x04, 0x0b, 0x04, + 0x0e, 0x06, 0x0a, 0x11, 0x0a, 0x0a, 0x06, 0x00, 0x02, 0x00, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x04, + 0x12, 0x03, 0x0c, 0x06, 0x1d, 0x0a, 0x11, 0x0a, 0x0a, 0x06, 0x00, 0x02, 0x00, 0x04, 0xb0, 0xca, + 0xbc, 0x22, 0x07, 0x12, 0x03, 0x0d, 0x06, 0x0f, 0x0a, 0x0c, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x01, + 0x12, 0x04, 0x10, 0x02, 0x15, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x10, 0x06, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x10, + 0x13, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x10, 0x31, 0x45, + 0x0a, 0x0d, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x04, 0x12, 0x04, 0x11, 0x04, 0x14, 0x06, 0x0a, + 0x11, 0x0a, 0x09, 0x06, 0x00, 0x02, 0x01, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x12, 0x04, 0x11, 0x04, + 0x14, 0x06, 0x0a, 0x11, 0x0a, 0x0a, 0x06, 0x00, 0x02, 0x01, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x03, + 0x12, 0x03, 0x12, 0x06, 0x2b, 0x0a, 0x11, 0x0a, 0x0a, 0x06, 0x00, 0x02, 0x01, 0x04, 0xb0, 0xca, + 0xbc, 0x22, 0x07, 0x12, 0x03, 0x13, 0x06, 0x0f, 0x0a, 0x0c, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x02, + 0x12, 0x04, 0x16, 0x02, 0x18, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x16, 0x06, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x16, + 0x10, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x16, 0x2b, 0x3c, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x04, 0x12, 0x03, 0x17, 0x04, 0x47, 0x0a, 0x10, + 0x0a, 0x09, 0x06, 0x00, 0x02, 0x02, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x12, 0x03, 0x17, 0x04, 0x47, + 0x0a, 0x11, 0x0a, 0x0a, 0x06, 0x00, 0x02, 0x02, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x02, 0x12, 0x03, + 0x17, 0x20, 0x45, 0x0a, 0x0c, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x03, 0x12, 0x04, 0x19, 0x02, 0x1b, + 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x19, 0x06, 0x12, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x19, 0x13, 0x26, 0x0a, 0x0c, 0x0a, + 0x05, 0x06, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x19, 0x31, 0x45, 0x0a, 0x0c, 0x0a, 0x05, 0x06, + 0x00, 0x02, 0x03, 0x04, 0x12, 0x03, 0x1a, 0x04, 0x4a, 0x0a, 0x10, 0x0a, 0x09, 0x06, 0x00, 0x02, + 0x03, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x12, 0x03, 0x1a, 0x04, 0x4a, 0x0a, 0x11, 0x0a, 0x0a, 0x06, + 0x00, 0x02, 0x03, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x05, 0x12, 0x03, 0x1a, 0x20, 0x48, 0x0a, 0x0c, + 0x0a, 0x04, 0x06, 0x00, 0x02, 0x04, 0x12, 0x04, 0x1c, 0x02, 0x1e, 0x03, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x1c, 0x06, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x04, 0x02, 0x12, 0x03, 0x1c, 0x12, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x04, + 0x03, 0x12, 0x03, 0x1c, 0x2f, 0x42, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x04, 0x04, 0x12, + 0x03, 0x1d, 0x04, 0x38, 0x0a, 0x10, 0x0a, 0x09, 0x06, 0x00, 0x02, 0x04, 0x04, 0xb0, 0xca, 0xbc, + 0x22, 0x12, 0x03, 0x1d, 0x04, 0x38, 0x0a, 0x11, 0x0a, 0x0a, 0x06, 0x00, 0x02, 0x04, 0x04, 0xb0, + 0xca, 0xbc, 0x22, 0x02, 0x12, 0x03, 0x1d, 0x20, 0x36, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, +]; +include!("flyteidl2.secret.tonic.rs"); +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/flyteidl2.secret.tonic.rs b/gen/rust/src/flyteidl2.secret.tonic.rs new file mode 100644 index 0000000000..e0b4ee6979 --- /dev/null +++ b/gen/rust/src/flyteidl2.secret.tonic.rs @@ -0,0 +1,607 @@ +// @generated +/// Generated client implementations. +pub mod secret_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct SecretServiceClient { + inner: tonic::client::Grpc, + } + impl SecretServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl SecretServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> SecretServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + SecretServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + pub async fn create_secret( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.secret.SecretService/CreateSecret", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.secret.SecretService", "CreateSecret"), + ); + self.inner.unary(req, path, codec).await + } + /// + pub async fn update_secret( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.secret.SecretService/UpdateSecret", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.secret.SecretService", "UpdateSecret"), + ); + self.inner.unary(req, path, codec).await + } + /// + pub async fn get_secret( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.secret.SecretService/GetSecret", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.secret.SecretService", "GetSecret")); + self.inner.unary(req, path, codec).await + } + /// + pub async fn delete_secret( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.secret.SecretService/DeleteSecret", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.secret.SecretService", "DeleteSecret"), + ); + self.inner.unary(req, path, codec).await + } + /// + pub async fn list_secrets( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.secret.SecretService/ListSecrets", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.secret.SecretService", "ListSecrets"), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod secret_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with SecretServiceServer. + #[async_trait] + pub trait SecretService: Send + Sync + 'static { + async fn create_secret( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// + async fn update_secret( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// + async fn get_secret( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// + async fn delete_secret( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// + async fn list_secrets( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + #[derive(Debug)] + pub struct SecretServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl SecretServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for SecretServiceServer + where + T: SecretService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.secret.SecretService/CreateSecret" => { + #[allow(non_camel_case_types)] + struct CreateSecretSvc(pub Arc); + impl< + T: SecretService, + > tonic::server::UnaryService + for CreateSecretSvc { + type Response = super::CreateSecretResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::create_secret(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = CreateSecretSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.secret.SecretService/UpdateSecret" => { + #[allow(non_camel_case_types)] + struct UpdateSecretSvc(pub Arc); + impl< + T: SecretService, + > tonic::server::UnaryService + for UpdateSecretSvc { + type Response = super::UpdateSecretResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::update_secret(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = UpdateSecretSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.secret.SecretService/GetSecret" => { + #[allow(non_camel_case_types)] + struct GetSecretSvc(pub Arc); + impl< + T: SecretService, + > tonic::server::UnaryService + for GetSecretSvc { + type Response = super::GetSecretResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_secret(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetSecretSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.secret.SecretService/DeleteSecret" => { + #[allow(non_camel_case_types)] + struct DeleteSecretSvc(pub Arc); + impl< + T: SecretService, + > tonic::server::UnaryService + for DeleteSecretSvc { + type Response = super::DeleteSecretResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::delete_secret(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = DeleteSecretSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.secret.SecretService/ListSecrets" => { + #[allow(non_camel_case_types)] + struct ListSecretsSvc(pub Arc); + impl< + T: SecretService, + > tonic::server::UnaryService + for ListSecretsSvc { + type Response = super::ListSecretsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::list_secrets(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ListSecretsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for SecretServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService for SecretServiceServer { + const NAME: &'static str = "flyteidl2.secret.SecretService"; + } +} diff --git a/gen/rust/src/flyteidl2.task.rs b/gen/rust/src/flyteidl2.task.rs new file mode 100644 index 0000000000..afe0253587 --- /dev/null +++ b/gen/rust/src/flyteidl2.task.rs @@ -0,0 +1,2487 @@ +// @generated +// This file is @generated by prost-build. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct NamedParameter { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + #[prost(message, optional, tag="2")] + pub parameter: ::core::option::Option, +} +/// Option for schedules run at a certain frequency e.g. every 2 minutes. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct FixedRate { + #[prost(uint32, tag="1")] + pub value: u32, + #[prost(enumeration="FixedRateUnit", tag="2")] + pub unit: i32, + /// Optional, timestamp after which rate should be calculated. Can be only in future. + /// E.g. We create a rate schedule "every 5 minutes" with start_time="12:00" inactive. + /// Activate it at "12:04". + /// Trigger should fire at "12:05" as it adds 5 minutes to start_time="12:00". + #[prost(message, optional, tag="3")] + pub start_time: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Cron { + /// Uses AWS syntax: Minutes Hours Day-of-month Month Day-of-week Year + /// e.g. for a schedule that runs every 15 minutes: 0/15 * * * ? * + #[prost(string, tag="1")] + pub expression: ::prost::alloc::string::String, + /// default is UTC + #[prost(string, tag="2")] + pub timezone: ::prost::alloc::string::String, +} +/// Defines complete set of information required to trigger an execution on a schedule. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Schedule { + /// Name of the input variable that the kickoff time will be supplied to when the workflow is kicked off. + #[prost(string, tag="3")] + pub kickoff_time_input_arg: ::prost::alloc::string::String, + #[prost(oneof="schedule::Expression", tags="1, 2, 4")] + pub expression: ::core::option::Option, +} +/// Nested message and enum types in `Schedule`. +pub mod schedule { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Expression { + #[prost(message, tag="1")] + Rate(super::FixedRate), + #[prost(string, tag="2")] + CronExpression(::prost::alloc::string::String), + #[prost(message, tag="4")] + Cron(super::Cron), + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TriggerAutomationSpec { + /// Explicitly defines trigger automation type. + #[prost(enumeration="TriggerAutomationSpecType", tag="1")] + pub r#type: i32, + #[prost(oneof="trigger_automation_spec::Automation", tags="2")] + pub automation: ::core::option::Option, +} +/// Nested message and enum types in `TriggerAutomationSpec`. +pub mod trigger_automation_spec { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Automation { + #[prost(message, tag="2")] + Schedule(super::Schedule), + } +} +/// Named literal value. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct NamedLiteral { + /// Name of the literal. + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// Literal value. + #[prost(message, optional, tag="2")] + pub value: ::core::option::Option, +} +/// Output references. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct OutputReferences { + /// The output uri. + #[prost(string, tag="1")] + pub output_uri: ::prost::alloc::string::String, + /// Native URI to HTML report + #[prost(string, tag="2")] + pub report_uri: ::prost::alloc::string::String, +} +/// Input payload for an action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Inputs { + /// Ordered inputs. THIS FIELD MUST REMAIN FIRST as this would break Run service assumptions if it were to move. + #[prost(message, repeated, tag="1")] + pub literals: ::prost::alloc::vec::Vec, + /// Context for the action. If an action receives context, it'll automatically pass it to any actions it spawns. + /// Context will not be used for cache key computation. + /// Examples for context include: + /// - User-provided metadata that is not part of the action's inputs. + /// - Information about the environment the action is running in (e.g. cluster, region, etc.) + /// - Tracing information about the action + #[prost(message, repeated, tag="2")] + pub context: ::prost::alloc::vec::Vec, +} +/// Output payload for an action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Outputs { + /// Ordered outputs. THIS FIELD MUST REMAIN FIRST as this would break Run service assumptions if it were to move. + #[prost(message, repeated, tag="1")] + pub literals: ::prost::alloc::vec::Vec, +} +/// Represents a frequency at which to run a schedule. +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum FixedRateUnit { + Unspecified = 0, + Minute = 1, + Hour = 2, + Day = 3, +} +impl FixedRateUnit { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + FixedRateUnit::Unspecified => "FIXED_RATE_UNIT_UNSPECIFIED", + FixedRateUnit::Minute => "FIXED_RATE_UNIT_MINUTE", + FixedRateUnit::Hour => "FIXED_RATE_UNIT_HOUR", + FixedRateUnit::Day => "FIXED_RATE_UNIT_DAY", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "FIXED_RATE_UNIT_UNSPECIFIED" => Some(Self::Unspecified), + "FIXED_RATE_UNIT_MINUTE" => Some(Self::Minute), + "FIXED_RATE_UNIT_HOUR" => Some(Self::Hour), + "FIXED_RATE_UNIT_DAY" => Some(Self::Day), + _ => None, + } + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum TriggerAutomationSpecType { + TypeUnspecified = 0, + TypeNone = 1, + TypeSchedule = 2, +} +impl TriggerAutomationSpecType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + TriggerAutomationSpecType::TypeUnspecified => "TYPE_UNSPECIFIED", + TriggerAutomationSpecType::TypeNone => "TYPE_NONE", + TriggerAutomationSpecType::TypeSchedule => "TYPE_SCHEDULE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "TYPE_UNSPECIFIED" => Some(Self::TypeUnspecified), + "TYPE_NONE" => Some(Self::TypeNone), + "TYPE_SCHEDULE" => Some(Self::TypeSchedule), + _ => None, + } + } +} +/// Label values to be applied to an execution resource. +/// In the future a mode (e.g. OVERRIDE, APPEND, etc) can be defined +/// to specify how to merge labels defined at registration and execution time. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Labels { + /// Map of custom labels to be applied to the execution resource. + #[prost(map="string, string", tag="1")] + pub values: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, +} +/// Annotation values to be applied to an execution resource. +/// In the future a mode (e.g. OVERRIDE, APPEND, etc) can be defined +/// to specify how to merge annotations defined at registration and execution time. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Annotations { + /// Map of custom annotations to be applied to the execution resource. + #[prost(map="string, string", tag="1")] + pub values: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, +} +/// Environment variable values to be applied to an execution resource. +/// In the future a mode (e.g. OVERRIDE, APPEND, etc) can be defined +/// to specify how to merge environment variables defined at registration and execution time. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Envs { + /// Map of custom environment variables to be applied to the execution resource. + #[prost(message, repeated, tag="1")] + pub values: ::prost::alloc::vec::Vec, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RawDataStorage { + /// Prefix for where offloaded data from user actions will be written + /// e.g. s3://bucket/key or s3://bucket/ + #[prost(string, tag="1")] + pub raw_data_prefix: ::prost::alloc::string::String, +} +/// CacheConfig contains configurations that influence the behavior of cache reads and writes +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct CacheConfig { + /// If true, recompute outputs for this run and overwrite any existing cache. + #[prost(bool, tag="1")] + pub overwrite_cache: bool, + /// CacheLookupScope defines the cache lookup behavior. If left unspecified, the default value from the system config + /// will be used (global unless configured otherwise). + #[prost(enumeration="CacheLookupScope", tag="2")] + pub cache_lookup_scope: i32, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RunSpec { + /// Labels to apply to the run. + #[prost(message, optional, tag="1")] + pub labels: ::core::option::Option, + /// Annotations to apply to the run. + #[prost(message, optional, tag="2")] + pub annotations: ::core::option::Option, + /// Envs to apply to the run. + #[prost(message, optional, tag="3")] + pub envs: ::core::option::Option, + /// Explicit override for executing this run as interruptible or not. If not set, use the default. + #[prost(message, optional, tag="4")] + pub interruptible: ::core::option::Option, + /// If true, recompute outputs for this run and overwrite any existing cache. + /// Deprecated, please use CacheConfig.OverwriteCache instead + #[deprecated] + #[prost(bool, tag="5")] + pub overwrite_cache: bool, + /// the specific cluster that this action should be executed on. this value will be used as the + /// default for all actions in the run unless overridden. + #[prost(string, tag="6")] + pub cluster: ::prost::alloc::string::String, + /// Encapsulates user settings pertaining to offloaded data (i.e. Blobs, Schema, query data, etc.). + #[prost(message, optional, tag="7")] + pub raw_data_storage: ::core::option::Option, + /// SecurityContext holds security attributes that apply to tasks. + #[prost(message, optional, tag="8")] + pub security_context: ::core::option::Option, + /// CacheConfig contains configurations that influence the behavior of cache reads and writes + #[prost(message, optional, tag="9")] + pub cache_config: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum CacheLookupScope { + /// CACHE_LOOKUP_SCOPE_UNSPECIFIED instructs cache lookup to follow the default behavior (global unless configured + /// otherwise) + Unspecified = 0, + /// CACHE_LOOKUP_SCOPE_GLOBAL instructs cache lookups to do a global lookup (unless overridden by a system config). + /// This has traditionally been the default behavior. It requires all workloads running in all projects/domains + /// to have access to the same artifacts/buckets. Otherwise it risks runtime failures. + Global = 1, + /// CACHE_LOOKUP_SCOPE_PROJECT_DOMAIN instructs cache lookups to do a project-domain scoped lookup. This ensures + /// data access success at the expense of potentially more cache misses and recomputation happening. This should not + /// be considered a security enforcement (that can happen through the system-wide config). + ProjectDomain = 2, +} +impl CacheLookupScope { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + CacheLookupScope::Unspecified => "CACHE_LOOKUP_SCOPE_UNSPECIFIED", + CacheLookupScope::Global => "CACHE_LOOKUP_SCOPE_GLOBAL", + CacheLookupScope::ProjectDomain => "CACHE_LOOKUP_SCOPE_PROJECT_DOMAIN", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "CACHE_LOOKUP_SCOPE_UNSPECIFIED" => Some(Self::Unspecified), + "CACHE_LOOKUP_SCOPE_GLOBAL" => Some(Self::Global), + "CACHE_LOOKUP_SCOPE_PROJECT_DOMAIN" => Some(Self::ProjectDomain), + _ => None, + } + } +} +/// Environment for a task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Environment { + /// Name of the environment. + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// Description of environment + #[prost(string, tag="2")] + pub description: ::prost::alloc::string::String, +} +/// Name of a task. It may have multiple versions deployed. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskName { + /// Org this task belongs to. + #[prost(string, tag="1")] + pub org: ::prost::alloc::string::String, + /// Project this task belongs to. + #[prost(string, tag="2")] + pub project: ::prost::alloc::string::String, + /// Domain this task belongs to. + #[prost(string, tag="3")] + pub domain: ::prost::alloc::string::String, + /// Unique name of the task. Should not be interpreted/parsed. Use `short_name` and `environment_name` for user facing names. + #[prost(string, tag="4")] + pub name: ::prost::alloc::string::String, +} +/// TaskIdentifier is the unique identifier for a task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskIdentifier { + /// Org this task belongs to. + #[prost(string, tag="1")] + pub org: ::prost::alloc::string::String, + /// Project this task belongs to. + #[prost(string, tag="2")] + pub project: ::prost::alloc::string::String, + /// Domain this task belongs to. + #[prost(string, tag="3")] + pub domain: ::prost::alloc::string::String, + /// Unique name of the task. Should not be interpreted/parsed. Use `short_name` and `environment_name` for user facing names. + #[prost(string, tag="4")] + pub name: ::prost::alloc::string::String, + /// Version of the task. + #[prost(string, tag="5")] + pub version: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskTriggersSummary { + #[prost(oneof="task_triggers_summary::Summary", tags="3, 2")] + pub summary: ::core::option::Option, +} +/// Nested message and enum types in `TaskTriggersSummary`. +pub mod task_triggers_summary { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct TriggerDetails { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + #[prost(bool, tag="2")] + pub active: bool, + #[prost(message, optional, tag="3")] + pub automation_spec: ::core::option::Option, + } + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] + pub struct TriggerStats { + #[prost(uint32, tag="1")] + pub total: u32, + #[prost(uint32, tag="2")] + pub active: u32, + } + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Summary { + #[prost(message, tag="3")] + Details(TriggerDetails), + #[prost(message, tag="2")] + Stats(TriggerStats), + } +} +/// LatestRunSummary contains minimal information about the most recent run of a task. +/// This is a lightweight summary that avoids circular dependencies with workflow package. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LatestRunSummary { + /// Run identifier + #[prost(message, optional, tag="1")] + pub run_id: ::core::option::Option, + /// Last run time + #[prost(message, optional, tag="2")] + pub run_time: ::core::option::Option, + /// Phase of the last run + #[prost(enumeration="super::common::ActionPhase", tag="3")] + pub phase: i32, + /// Name of the root task of the last run (env.task name) + #[prost(string, tag="4")] + pub root_task_name: ::prost::alloc::string::String, +} +/// TaskMetadata is static, lightweight metadata about a task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskMetadata { + /// Identity that deployed the task. + #[prost(message, optional, tag="1")] + pub deployed_by: ::core::option::Option, + /// The short name for this task + #[prost(string, tag="2")] + pub short_name: ::prost::alloc::string::String, + /// The time the task was deployed + #[prost(message, optional, tag="3")] + pub deployed_at: ::core::option::Option, + /// The environment name for this task, if present. + #[prost(string, tag="4")] + pub environment_name: ::prost::alloc::string::String, + /// Brief overview of attached triggers if any. + #[prost(message, optional, tag="5")] + pub triggers_summary: ::core::option::Option, + /// The short description for this task + #[prost(string, tag="6")] + pub short_description: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskSummary { + /// Summary of the latest run for this task, if any + #[prost(message, optional, tag="1")] + pub latest_run: ::core::option::Option, +} +/// Lightweight representation of a task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Task { + /// Id for this task. + #[prost(message, optional, tag="1")] + pub task_id: ::core::option::Option, + /// Metadata for this task. + #[prost(message, optional, tag="2")] + pub metadata: ::core::option::Option, + /// Summary for this task. + #[prost(message, optional, tag="3")] + pub task_summary: ::core::option::Option, +} +/// Link to source code used to define this entity +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SourceCode { + #[prost(string, tag="1")] + pub link: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DocumentationEntity { + /// One-liner overview of the entity. + #[prost(string, tag="1")] + pub short_description: ::prost::alloc::string::String, + /// Full user description with formatting preserved. + #[prost(string, tag="2")] + pub long_description: ::prost::alloc::string::String, + /// Optional link to source code used to define this entity. + #[prost(message, optional, tag="3")] + pub source_code: ::core::option::Option, +} +/// Specification for a task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskSpec { + /// The template for this task. + #[prost(message, optional, tag="1")] + pub task_template: ::core::option::Option, + /// Ordered default inputs. + /// These can be overridden when an run is created. + /// Client should not send required=true flag in underlying flyteidl2.core.Parameter. + #[prost(message, repeated, tag="2")] + pub default_inputs: ::prost::alloc::vec::Vec, + /// User facing display name for this task. Not required to be unique. + /// This is passed in via the SDK when the task is created and is either a user defined override or the name of the task. + #[prost(string, tag="3")] + pub short_name: ::prost::alloc::string::String, + /// Optional environment for this task. Note, some tasks may not be run in the context of an environment. + #[prost(message, optional, tag="4")] + pub environment: ::core::option::Option, + /// The documentation entity for the task + #[prost(message, optional, tag="5")] + pub documentation: ::core::option::Option, +} +/// Specification for a trace action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TraceSpec { + /// A strongly typed interface for the trace. + #[prost(message, optional, tag="1")] + pub interface: ::core::option::Option, +} +/// Detailed information about a task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskDetails { + /// Id for this task. + #[prost(message, optional, tag="1")] + pub task_id: ::core::option::Option, + /// Metadata for this task. + #[prost(message, optional, tag="2")] + pub metadata: ::core::option::Option, + /// Specification for this task. + #[prost(message, optional, tag="3")] + pub spec: ::core::option::Option, +} +/// Contains details about a single trigger attached to a task. Should only be used in DeployTask endpoint. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskTrigger { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + #[prost(message, optional, tag="2")] + pub spec: ::core::option::Option, + /// Optional automation spec. + #[prost(message, optional, tag="3")] + pub automation_spec: ::core::option::Option, +} +/// TaskTriggerSpec this is a copy of TriggerSpec without mandatory 'task_version' field. +/// This is supposed to be used only in DeployTask endpoint where 'task_version' is already provided in task_id. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskTriggerSpec { + /// Whether trigger is active + #[prost(bool, tag="1")] + pub active: bool, + /// Inputs for triggered task. + #[prost(message, optional, tag="2")] + pub inputs: ::core::option::Option, + /// The run spec for triggered task. + #[prost(message, optional, tag="3")] + pub run_spec: ::core::option::Option, + /// Optional description + #[prost(string, tag="4")] + pub description: ::prost::alloc::string::String, +} +/// Request message for deploying a task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DeployTaskRequest { + /// The user provided task id. + #[prost(message, optional, tag="1")] + pub task_id: ::core::option::Option, + /// Specification for the task. + #[prost(message, optional, tag="2")] + pub spec: ::core::option::Option, + /// Optional, set of triggers for a given task. Replaces previous set of triggers entirely if any. + #[prost(message, repeated, tag="3")] + pub triggers: ::prost::alloc::vec::Vec, +} +/// Response message for deploying a task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct DeployTaskResponse { +} +/// Request message for getting detailed information about a task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTaskDetailsRequest { + /// Id of the task. + #[prost(message, optional, tag="1")] + pub task_id: ::core::option::Option, +} +/// Response message for deploying a task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTaskDetailsResponse { + /// Detailed information about the task. + #[prost(message, optional, tag="1")] + pub details: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListTasksRequest { + /// Common list request parameters. + #[prost(message, optional, tag="1")] + pub request: ::core::option::Option, + /// Known filters for listing tasks. + #[prost(message, repeated, tag="4")] + pub known_filters: ::prost::alloc::vec::Vec, + #[prost(oneof="list_tasks_request::ScopeBy", tags="2, 3")] + pub scope_by: ::core::option::Option, +} +/// Nested message and enum types in `ListTasksRequest`. +pub mod list_tasks_request { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct KnownFilter { + #[prost(oneof="known_filter::FilterBy", tags="1")] + pub filter_by: ::core::option::Option, + } + /// Nested message and enum types in `KnownFilter`. + pub mod known_filter { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum FilterBy { + /// Filter by user + #[prost(string, tag="1")] + DeployedBy(::prost::alloc::string::String), + } + } + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum ScopeBy { + /// Organization name for filtering. + #[prost(string, tag="2")] + Org(::prost::alloc::string::String), + /// Project identifier for filtering. + #[prost(message, tag="3")] + ProjectId(super::super::common::ProjectIdentifier), + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListTasksResponse { + #[prost(message, repeated, tag="1")] + pub tasks: ::prost::alloc::vec::Vec, + /// Pagination token for the next page of tasks. + #[prost(string, tag="2")] + pub token: ::prost::alloc::string::String, + /// Metadata for the ListTasksResponse + #[prost(message, optional, tag="3")] + pub metadata: ::core::option::Option, +} +/// Nested message and enum types in `ListTasksResponse`. +pub mod list_tasks_response { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] + pub struct ListTasksMetadata { + /// Total number of tasks without filters applied + #[prost(uint32, tag="1")] + pub total: u32, + /// Total number of tasks matching the applied filters. + #[prost(uint32, tag="2")] + pub filtered_total: u32, + } +} +/// Request message for listing versions for a task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListVersionsRequest { + /// Common list request parameters. + #[prost(message, optional, tag="1")] + pub request: ::core::option::Option, + /// Id of the task. + #[prost(message, optional, tag="2")] + pub task_name: ::core::option::Option, +} +/// Response message for listing versions. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListVersionsResponse { + /// Version with deployed_at + #[prost(message, repeated, tag="1")] + pub versions: ::prost::alloc::vec::Vec, + /// Pagination token for the next page of versions. + #[prost(string, tag="2")] + pub token: ::prost::alloc::string::String, +} +/// Nested message and enum types in `ListVersionsResponse`. +pub mod list_versions_response { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct VersionResponse { + #[prost(string, tag="1")] + pub version: ::prost::alloc::string::String, + /// The time the task version was deployed + #[prost(message, optional, tag="2")] + pub deployed_at: ::core::option::Option, + } +} +/// Encoded file descriptor set for the `flyteidl2.task` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xe8, 0x29, 0x0a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, + 0x61, 0x73, 0x6b, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x12, 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, + 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, 0x6e, + 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x6c, 0x69, + 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x5d, 0x0a, + 0x0e, 0x4e, 0x61, 0x6d, 0x65, 0x64, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x12, + 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x09, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, + 0x72, 0x52, 0x09, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x22, 0xa2, 0x01, 0x0a, + 0x09, 0x46, 0x69, 0x78, 0x65, 0x64, 0x52, 0x61, 0x74, 0x65, 0x12, 0x1d, 0x0a, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, 0x02, + 0x20, 0x00, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x3b, 0x0a, 0x04, 0x75, 0x6e, 0x69, + 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x46, 0x69, 0x78, 0x65, 0x64, 0x52, 0x61, + 0x74, 0x65, 0x55, 0x6e, 0x69, 0x74, 0x42, 0x08, 0xba, 0x48, 0x05, 0x82, 0x01, 0x02, 0x20, 0x00, + 0x52, 0x04, 0x75, 0x6e, 0x69, 0x74, 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, + 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, + 0x65, 0x22, 0x4b, 0x0a, 0x04, 0x43, 0x72, 0x6f, 0x6e, 0x12, 0x27, 0x0a, 0x0a, 0x65, 0x78, 0x70, + 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, + 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x0a, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, + 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x74, 0x69, 0x6d, 0x65, 0x7a, 0x6f, 0x6e, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x74, 0x69, 0x6d, 0x65, 0x7a, 0x6f, 0x6e, 0x65, 0x22, 0xe0, + 0x01, 0x0a, 0x08, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x12, 0x2f, 0x0a, 0x04, 0x72, + 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x46, 0x69, 0x78, 0x65, 0x64, + 0x52, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x04, 0x72, 0x61, 0x74, 0x65, 0x12, 0x2d, 0x0a, 0x0f, + 0x63, 0x72, 0x6f, 0x6e, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x48, 0x00, 0x52, 0x0e, 0x63, 0x72, 0x6f, + 0x6e, 0x45, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x2a, 0x0a, 0x04, 0x63, + 0x72, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x43, 0x72, 0x6f, 0x6e, 0x48, + 0x00, 0x52, 0x04, 0x63, 0x72, 0x6f, 0x6e, 0x12, 0x33, 0x0a, 0x16, 0x6b, 0x69, 0x63, 0x6b, 0x6f, + 0x66, 0x66, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x61, 0x72, + 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x6b, 0x69, 0x63, 0x6b, 0x6f, 0x66, 0x66, + 0x54, 0x69, 0x6d, 0x65, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x41, 0x72, 0x67, 0x42, 0x13, 0x0a, 0x0a, + 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, + 0x01, 0x22, 0xa6, 0x01, 0x0a, 0x15, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x41, 0x75, 0x74, + 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x12, 0x47, 0x0a, 0x04, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x41, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, + 0x54, 0x79, 0x70, 0x65, 0x42, 0x08, 0xba, 0x48, 0x05, 0x82, 0x01, 0x02, 0x20, 0x00, 0x52, 0x04, + 0x74, 0x79, 0x70, 0x65, 0x12, 0x36, 0x0a, 0x08, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, + 0x48, 0x00, 0x52, 0x08, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x42, 0x0c, 0x0a, 0x0a, + 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x51, 0x0a, 0x0c, 0x4e, 0x61, + 0x6d, 0x65, 0x64, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2d, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, + 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x50, 0x0a, + 0x10, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, + 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x55, 0x72, 0x69, + 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x55, 0x72, 0x69, 0x22, + 0x7a, 0x0a, 0x06, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x12, 0x38, 0x0a, 0x08, 0x6c, 0x69, 0x74, + 0x65, 0x72, 0x61, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4e, 0x61, 0x6d, + 0x65, 0x64, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, + 0x61, 0x6c, 0x73, 0x12, 0x36, 0x0a, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x02, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x61, + 0x69, 0x72, 0x52, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x22, 0x43, 0x0a, 0x07, 0x4f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x12, 0x38, 0x0a, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, + 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x64, 0x4c, + 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, + 0x2a, 0x7f, 0x0a, 0x0d, 0x46, 0x69, 0x78, 0x65, 0x64, 0x52, 0x61, 0x74, 0x65, 0x55, 0x6e, 0x69, + 0x74, 0x12, 0x1f, 0x0a, 0x1b, 0x46, 0x49, 0x58, 0x45, 0x44, 0x5f, 0x52, 0x41, 0x54, 0x45, 0x5f, + 0x55, 0x4e, 0x49, 0x54, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, + 0x10, 0x00, 0x12, 0x1a, 0x0a, 0x16, 0x46, 0x49, 0x58, 0x45, 0x44, 0x5f, 0x52, 0x41, 0x54, 0x45, + 0x5f, 0x55, 0x4e, 0x49, 0x54, 0x5f, 0x4d, 0x49, 0x4e, 0x55, 0x54, 0x45, 0x10, 0x01, 0x12, 0x18, + 0x0a, 0x14, 0x46, 0x49, 0x58, 0x45, 0x44, 0x5f, 0x52, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x49, + 0x54, 0x5f, 0x48, 0x4f, 0x55, 0x52, 0x10, 0x02, 0x12, 0x17, 0x0a, 0x13, 0x46, 0x49, 0x58, 0x45, + 0x44, 0x5f, 0x52, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x49, 0x54, 0x5f, 0x44, 0x41, 0x59, 0x10, + 0x03, 0x2a, 0x53, 0x0a, 0x19, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x41, 0x75, 0x74, 0x6f, + 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, + 0x0a, 0x10, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, + 0x45, 0x44, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4e, 0x4f, 0x4e, + 0x45, 0x10, 0x01, 0x12, 0x11, 0x0a, 0x0d, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x43, 0x48, 0x45, + 0x44, 0x55, 0x4c, 0x45, 0x10, 0x02, 0x42, 0xae, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x42, 0x0b, 0x43, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, + 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, + 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, + 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, + 0xa2, 0x02, 0x03, 0x46, 0x54, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x61, 0x73, 0x6b, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x61, 0x73, 0x6b, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x3a, 0x3a, 0x54, 0x61, 0x73, 0x6b, 0x4a, 0xe9, 0x1c, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, + 0x74, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, + 0x02, 0x12, 0x03, 0x02, 0x00, 0x17, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, + 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x28, 0x0a, 0x09, 0x0a, 0x02, + 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, 0x27, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x03, 0x12, 0x03, 0x07, + 0x00, 0x29, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x09, 0x00, 0x49, 0x0a, 0x09, 0x0a, 0x02, + 0x08, 0x0b, 0x12, 0x03, 0x09, 0x00, 0x49, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0b, + 0x00, 0x0f, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0b, 0x08, 0x16, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0c, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x0c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x0c, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x0c, 0x10, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, + 0x0e, 0x02, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x0e, 0x02, + 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0e, 0x1b, 0x24, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x0e, 0x27, 0x28, 0x0a, 0x40, 0x0a, + 0x02, 0x05, 0x00, 0x12, 0x04, 0x12, 0x00, 0x17, 0x01, 0x1a, 0x34, 0x20, 0x52, 0x65, 0x70, 0x72, + 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x20, 0x66, 0x72, 0x65, 0x71, 0x75, 0x65, 0x6e, + 0x63, 0x79, 0x20, 0x61, 0x74, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x74, 0x6f, 0x20, 0x72, + 0x75, 0x6e, 0x20, 0x61, 0x20, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, 0x03, 0x12, 0x05, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x05, + 0x00, 0x02, 0x00, 0x12, 0x03, 0x13, 0x02, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x13, 0x02, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x02, 0x12, + 0x03, 0x13, 0x20, 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x01, 0x12, 0x03, 0x14, 0x02, + 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x14, 0x02, 0x18, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x14, 0x1b, 0x1c, 0x0a, 0x0b, 0x0a, + 0x04, 0x05, 0x00, 0x02, 0x02, 0x12, 0x03, 0x15, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x15, 0x02, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, + 0x02, 0x12, 0x03, 0x15, 0x19, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x03, 0x12, 0x03, + 0x16, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x16, 0x02, + 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x16, 0x18, 0x19, 0x0a, + 0x53, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x1a, 0x00, 0x25, 0x01, 0x1a, 0x47, 0x20, 0x4f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, + 0x65, 0x73, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x63, 0x65, 0x72, 0x74, + 0x61, 0x69, 0x6e, 0x20, 0x66, 0x72, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x79, 0x20, 0x65, 0x2e, + 0x67, 0x2e, 0x20, 0x65, 0x76, 0x65, 0x72, 0x79, 0x20, 0x32, 0x20, 0x6d, 0x69, 0x6e, 0x75, 0x74, + 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x1a, 0x08, 0x11, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x1b, 0x02, 0x38, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x1b, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1b, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x1b, 0x11, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x08, + 0x12, 0x03, 0x1b, 0x13, 0x37, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x01, 0x02, 0x00, 0x08, 0x87, 0x09, + 0x05, 0x04, 0x12, 0x03, 0x1b, 0x14, 0x36, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, + 0x04, 0x1c, 0x02, 0x1e, 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x06, 0x12, 0x03, + 0x1c, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x1c, 0x10, + 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x1c, 0x17, 0x18, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x08, 0x12, 0x04, 0x1c, 0x19, 0x1e, 0x04, 0x0a, 0x10, + 0x0a, 0x08, 0x04, 0x01, 0x02, 0x01, 0x08, 0x87, 0x09, 0x10, 0x12, 0x04, 0x1c, 0x1a, 0x1e, 0x03, + 0x0a, 0x11, 0x0a, 0x0a, 0x04, 0x01, 0x02, 0x01, 0x08, 0x87, 0x09, 0x10, 0x04, 0x00, 0x12, 0x03, + 0x1d, 0x0d, 0x0e, 0x0a, 0x9a, 0x02, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x24, 0x02, + 0x2b, 0x1a, 0x8c, 0x02, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2c, 0x20, 0x74, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x77, + 0x68, 0x69, 0x63, 0x68, 0x20, 0x72, 0x61, 0x74, 0x65, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x20, 0x62, 0x65, 0x20, 0x63, 0x61, 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x2e, 0x20, + 0x43, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x6e, 0x20, 0x66, + 0x75, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x0a, 0x20, 0x45, 0x2e, 0x67, 0x2e, 0x20, 0x57, 0x65, 0x20, + 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x72, 0x61, 0x74, 0x65, 0x20, 0x73, 0x63, + 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x20, 0x22, 0x65, 0x76, 0x65, 0x72, 0x79, 0x20, 0x35, 0x20, + 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x22, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x3d, 0x22, 0x31, 0x32, 0x3a, 0x30, 0x30, 0x22, + 0x20, 0x69, 0x6e, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x2e, 0x0a, 0x20, 0x41, 0x63, 0x74, 0x69, + 0x76, 0x61, 0x74, 0x65, 0x20, 0x69, 0x74, 0x20, 0x61, 0x74, 0x20, 0x22, 0x31, 0x32, 0x3a, 0x30, + 0x34, 0x22, 0x2e, 0x0a, 0x20, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x20, 0x66, 0x69, 0x72, 0x65, 0x20, 0x61, 0x74, 0x20, 0x22, 0x31, 0x32, 0x3a, + 0x30, 0x35, 0x22, 0x20, 0x61, 0x73, 0x20, 0x69, 0x74, 0x20, 0x61, 0x64, 0x64, 0x73, 0x20, 0x35, + 0x20, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x3d, 0x22, 0x31, 0x32, 0x3a, 0x30, 0x30, 0x22, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x06, 0x12, 0x03, 0x24, 0x02, 0x1b, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x24, 0x1c, 0x26, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x24, 0x29, 0x2a, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x02, + 0x12, 0x04, 0x27, 0x00, 0x2d, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x27, + 0x08, 0x0c, 0x0a, 0x92, 0x01, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x2a, 0x02, 0x42, + 0x1a, 0x84, 0x01, 0x20, 0x55, 0x73, 0x65, 0x73, 0x20, 0x41, 0x57, 0x53, 0x20, 0x73, 0x79, 0x6e, + 0x74, 0x61, 0x78, 0x3a, 0x20, 0x4d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x20, 0x48, 0x6f, 0x75, + 0x72, 0x73, 0x20, 0x44, 0x61, 0x79, 0x2d, 0x6f, 0x66, 0x2d, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x20, + 0x4d, 0x6f, 0x6e, 0x74, 0x68, 0x20, 0x44, 0x61, 0x79, 0x2d, 0x6f, 0x66, 0x2d, 0x77, 0x65, 0x65, + 0x6b, 0x20, 0x59, 0x65, 0x61, 0x72, 0x0a, 0x20, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x61, 0x20, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x72, 0x75, 0x6e, 0x73, 0x20, 0x65, 0x76, 0x65, 0x72, 0x79, 0x20, 0x31, 0x35, 0x20, 0x6d, + 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x3a, 0x20, 0x30, 0x2f, 0x31, 0x35, 0x20, 0x2a, 0x20, 0x2a, + 0x20, 0x2a, 0x20, 0x3f, 0x20, 0x2a, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, + 0x12, 0x03, 0x2a, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x2a, 0x09, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x2a, 0x16, + 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x08, 0x12, 0x03, 0x2a, 0x18, 0x41, 0x0a, + 0x10, 0x0a, 0x09, 0x04, 0x02, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x2a, 0x19, + 0x40, 0x0a, 0x1d, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x2c, 0x02, 0x16, 0x22, 0x10, + 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x69, 0x73, 0x20, 0x55, 0x54, 0x43, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x05, 0x12, 0x03, 0x2c, 0x02, 0x08, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x2c, 0x09, 0x11, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x2c, 0x14, 0x15, 0x0a, 0x61, 0x0a, 0x02, 0x04, 0x03, + 0x12, 0x04, 0x30, 0x00, 0x3b, 0x01, 0x1a, 0x55, 0x20, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, + 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, + 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x71, + 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x20, 0x61, 0x6e, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x6e, + 0x20, 0x61, 0x20, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x30, 0x08, 0x10, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x03, 0x08, + 0x00, 0x12, 0x04, 0x31, 0x02, 0x37, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x08, 0x00, 0x01, + 0x12, 0x03, 0x31, 0x08, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x08, 0x00, 0x02, 0x12, 0x03, + 0x32, 0x04, 0x30, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x03, 0x08, 0x00, 0x02, 0x87, 0x09, 0x01, 0x12, + 0x03, 0x32, 0x04, 0x30, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x34, 0x04, + 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x34, 0x04, 0x0d, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x34, 0x0e, 0x12, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x34, 0x15, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x03, 0x02, 0x01, 0x12, 0x03, 0x35, 0x04, 0x33, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, + 0x05, 0x12, 0x03, 0x35, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x35, 0x0b, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x35, + 0x1d, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x08, 0x12, 0x03, 0x35, 0x1f, 0x32, + 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x03, 0x02, 0x01, 0x08, 0x03, 0x12, 0x03, 0x35, 0x20, 0x31, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x02, 0x12, 0x03, 0x36, 0x04, 0x12, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x02, 0x06, 0x12, 0x03, 0x36, 0x04, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x36, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, + 0x03, 0x12, 0x03, 0x36, 0x10, 0x11, 0x0a, 0x74, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x03, 0x12, 0x03, + 0x3a, 0x02, 0x24, 0x1a, 0x67, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6b, 0x69, 0x63, 0x6b, 0x6f, 0x66, + 0x66, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x73, + 0x75, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, + 0x6b, 0x69, 0x63, 0x6b, 0x65, 0x64, 0x20, 0x6f, 0x66, 0x66, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x03, 0x05, 0x12, 0x03, 0x3a, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x03, 0x01, 0x12, 0x03, 0x3a, 0x09, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, + 0x03, 0x12, 0x03, 0x3a, 0x22, 0x23, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x01, 0x12, 0x04, 0x3d, 0x00, + 0x41, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x01, 0x01, 0x12, 0x03, 0x3d, 0x05, 0x1e, 0x0a, 0x0b, + 0x0a, 0x04, 0x05, 0x01, 0x02, 0x00, 0x12, 0x03, 0x3e, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x3e, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, + 0x00, 0x02, 0x12, 0x03, 0x3e, 0x15, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x01, 0x02, 0x01, 0x12, + 0x03, 0x3f, 0x02, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x3f, + 0x02, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x01, 0x02, 0x12, 0x03, 0x3f, 0x0e, 0x0f, + 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x01, 0x02, 0x02, 0x12, 0x03, 0x40, 0x02, 0x14, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x40, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x01, 0x02, 0x02, 0x02, 0x12, 0x03, 0x40, 0x12, 0x13, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x04, 0x12, + 0x04, 0x43, 0x00, 0x4e, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x43, 0x08, + 0x1d, 0x0a, 0x3b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x04, 0x45, 0x02, 0x47, 0x05, 0x1a, + 0x2d, 0x20, 0x45, 0x78, 0x70, 0x6c, 0x69, 0x63, 0x69, 0x74, 0x6c, 0x79, 0x20, 0x64, 0x65, 0x66, + 0x69, 0x6e, 0x65, 0x73, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x61, 0x75, 0x74, + 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x06, 0x12, 0x03, 0x45, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x45, 0x1c, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x45, 0x23, 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, + 0x08, 0x12, 0x04, 0x45, 0x25, 0x47, 0x04, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x04, 0x02, 0x00, 0x08, + 0x87, 0x09, 0x10, 0x12, 0x04, 0x45, 0x26, 0x47, 0x03, 0x0a, 0x11, 0x0a, 0x0a, 0x04, 0x04, 0x02, + 0x00, 0x08, 0x87, 0x09, 0x10, 0x04, 0x00, 0x12, 0x03, 0x46, 0x0d, 0x0e, 0x0a, 0x0c, 0x0a, 0x04, + 0x04, 0x04, 0x08, 0x00, 0x12, 0x04, 0x49, 0x02, 0x4d, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x08, 0x00, 0x01, 0x12, 0x03, 0x49, 0x08, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, + 0x12, 0x03, 0x4a, 0x04, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x06, 0x12, 0x03, + 0x4a, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x4a, 0x0d, + 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x4a, 0x18, 0x19, 0x0a, + 0x22, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x51, 0x00, 0x57, 0x01, 0x1a, 0x16, 0x20, 0x4e, 0x61, + 0x6d, 0x65, 0x64, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x51, 0x08, 0x14, 0x0a, + 0x23, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x53, 0x02, 0x12, 0x1a, 0x16, 0x20, 0x4e, + 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, + 0x61, 0x6c, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x05, 0x12, 0x03, 0x53, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x53, 0x09, 0x0d, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x53, 0x10, 0x11, 0x0a, 0x1d, + 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x03, 0x56, 0x02, 0x23, 0x1a, 0x10, 0x20, 0x4c, 0x69, + 0x74, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x01, 0x06, 0x12, 0x03, 0x56, 0x02, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x01, 0x01, 0x12, 0x03, 0x56, 0x19, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x01, 0x03, 0x12, 0x03, 0x56, 0x21, 0x22, 0x0a, 0x20, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x04, 0x5a, + 0x00, 0x60, 0x01, 0x1a, 0x14, 0x20, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x72, 0x65, 0x66, + 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, 0x01, + 0x12, 0x03, 0x5a, 0x08, 0x18, 0x0a, 0x1e, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x03, 0x5c, + 0x02, 0x18, 0x1a, 0x11, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, + 0x75, 0x72, 0x69, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x5c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x03, 0x5c, 0x09, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x03, 0x5c, 0x16, 0x17, 0x0a, + 0x28, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x01, 0x12, 0x03, 0x5f, 0x02, 0x18, 0x1a, 0x1b, 0x20, 0x4e, + 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x55, 0x52, 0x49, 0x20, 0x74, 0x6f, 0x20, 0x48, 0x54, 0x4d, + 0x4c, 0x20, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x01, 0x05, 0x12, 0x03, 0x5f, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x5f, 0x09, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x5f, 0x16, 0x17, 0x0a, 0x2a, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x04, 0x63, 0x00, 0x6e, 0x01, 0x1a, + 0x1e, 0x20, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x03, 0x63, 0x08, 0x0e, 0x0a, 0x7b, 0x0a, 0x04, 0x04, + 0x07, 0x02, 0x00, 0x12, 0x03, 0x65, 0x02, 0x25, 0x1a, 0x6e, 0x20, 0x4f, 0x72, 0x64, 0x65, 0x72, + 0x65, 0x64, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x2e, 0x20, 0x54, 0x48, 0x49, 0x53, 0x20, + 0x46, 0x49, 0x45, 0x4c, 0x44, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x52, 0x45, 0x4d, 0x41, 0x49, + 0x4e, 0x20, 0x46, 0x49, 0x52, 0x53, 0x54, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x20, 0x52, 0x75, 0x6e, 0x20, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x66, 0x20, 0x69, 0x74, 0x20, 0x77, 0x65, 0x72, 0x65, 0x20, 0x74, + 0x6f, 0x20, 0x6d, 0x6f, 0x76, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, + 0x04, 0x12, 0x03, 0x65, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x65, 0x0b, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x01, 0x12, 0x03, 0x65, + 0x18, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x03, 0x12, 0x03, 0x65, 0x23, 0x24, + 0x0a, 0x99, 0x03, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x01, 0x12, 0x03, 0x6d, 0x02, 0x33, 0x1a, 0x8b, + 0x03, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x61, 0x6e, 0x20, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x73, 0x20, + 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x69, 0x74, 0x27, 0x6c, 0x6c, 0x20, 0x61, + 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x70, 0x61, 0x73, + 0x73, 0x20, 0x69, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x61, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x74, 0x20, 0x73, 0x70, 0x61, 0x77, 0x6e, 0x73, 0x2e, 0x0a, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6e, 0x6f, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x63, 0x61, 0x63, + 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, + 0x65, 0x3a, 0x0a, 0x20, 0x20, 0x2d, 0x20, 0x55, 0x73, 0x65, 0x72, 0x2d, 0x70, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x64, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x73, 0x20, 0x69, + 0x6e, 0x70, 0x75, 0x74, 0x73, 0x2e, 0x0a, 0x20, 0x20, 0x2d, 0x20, 0x49, 0x6e, 0x66, 0x6f, 0x72, + 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x72, 0x75, 0x6e, 0x6e, 0x69, + 0x6e, 0x67, 0x20, 0x69, 0x6e, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x2c, 0x20, 0x72, 0x65, 0x67, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x65, 0x74, 0x63, + 0x2e, 0x29, 0x0a, 0x20, 0x20, 0x2d, 0x20, 0x54, 0x72, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x20, 0x69, + 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x01, 0x04, 0x12, 0x03, 0x6d, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x01, 0x06, 0x12, 0x03, 0x6d, 0x0b, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x6d, 0x27, 0x2e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x6d, 0x31, 0x32, 0x0a, 0x2b, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x04, 0x71, 0x00, 0x74, 0x01, + 0x1a, 0x1f, 0x20, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, + 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, + 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x08, 0x01, 0x12, 0x03, 0x71, 0x08, 0x0f, 0x0a, 0x7c, 0x0a, + 0x04, 0x04, 0x08, 0x02, 0x00, 0x12, 0x03, 0x73, 0x02, 0x25, 0x1a, 0x6f, 0x20, 0x4f, 0x72, 0x64, + 0x65, 0x72, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x2e, 0x20, 0x54, 0x48, + 0x49, 0x53, 0x20, 0x46, 0x49, 0x45, 0x4c, 0x44, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x52, 0x45, + 0x4d, 0x41, 0x49, 0x4e, 0x20, 0x46, 0x49, 0x52, 0x53, 0x54, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x20, 0x52, + 0x75, 0x6e, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x66, 0x20, 0x69, 0x74, 0x20, 0x77, 0x65, 0x72, + 0x65, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x6f, 0x76, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x00, 0x04, 0x12, 0x03, 0x73, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x73, 0x0b, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x73, 0x18, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x73, 0x23, 0x24, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0x98, 0x2b, 0x0a, 0x18, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x72, + 0x75, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x1a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x7f, 0x0a, 0x06, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, + 0x12, 0x3a, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, + 0x6b, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x1a, 0x39, 0x0a, 0x0b, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, + 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x89, 0x01, 0x0a, 0x0b, 0x41, 0x6e, 0x6e, 0x6f, + 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3f, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x1a, 0x39, 0x0a, 0x0b, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, + 0x02, 0x38, 0x01, 0x22, 0x3c, 0x0a, 0x04, 0x45, 0x6e, 0x76, 0x73, 0x12, 0x34, 0x0a, 0x06, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4b, 0x65, 0x79, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x61, 0x69, 0x72, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x73, 0x22, 0x38, 0x0a, 0x0e, 0x52, 0x61, 0x77, 0x44, 0x61, 0x74, 0x61, 0x53, 0x74, 0x6f, 0x72, + 0x61, 0x67, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x72, 0x61, 0x77, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, + 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x72, 0x61, + 0x77, 0x44, 0x61, 0x74, 0x61, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x22, 0x86, 0x01, 0x0a, 0x0b, + 0x43, 0x61, 0x63, 0x68, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x27, 0x0a, 0x0f, 0x6f, + 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x5f, 0x63, 0x61, 0x63, 0x68, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x43, + 0x61, 0x63, 0x68, 0x65, 0x12, 0x4e, 0x0a, 0x12, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x6c, 0x6f, + 0x6f, 0x6b, 0x75, 0x70, 0x5f, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, + 0x6b, 0x2e, 0x43, 0x61, 0x63, 0x68, 0x65, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x53, 0x63, 0x6f, + 0x70, 0x65, 0x52, 0x10, 0x63, 0x61, 0x63, 0x68, 0x65, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x53, + 0x63, 0x6f, 0x70, 0x65, 0x22, 0x81, 0x04, 0x0a, 0x07, 0x52, 0x75, 0x6e, 0x53, 0x70, 0x65, 0x63, + 0x12, 0x2e, 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, + 0x6b, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, + 0x12, 0x3d, 0x0a, 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x52, 0x0b, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, + 0x28, 0x0a, 0x04, 0x65, 0x6e, 0x76, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x45, + 0x6e, 0x76, 0x73, 0x52, 0x04, 0x65, 0x6e, 0x76, 0x73, 0x12, 0x40, 0x0a, 0x0d, 0x69, 0x6e, 0x74, + 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0d, 0x69, 0x6e, + 0x74, 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x12, 0x2b, 0x0a, 0x0f, 0x6f, + 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x5f, 0x63, 0x61, 0x63, 0x68, 0x65, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x08, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0e, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, + 0x69, 0x74, 0x65, 0x43, 0x61, 0x63, 0x68, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x12, 0x48, 0x0a, 0x10, 0x72, 0x61, 0x77, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x73, + 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x52, 0x61, + 0x77, 0x44, 0x61, 0x74, 0x61, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x52, 0x0e, 0x72, 0x61, + 0x77, 0x44, 0x61, 0x74, 0x61, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x12, 0x4a, 0x0a, 0x10, + 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, + 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, + 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, 0x0f, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, + 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x3e, 0x0a, 0x0c, 0x63, 0x61, 0x63, 0x68, + 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x43, 0x61, 0x63, 0x68, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0b, 0x63, 0x61, 0x63, + 0x68, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2a, 0x7c, 0x0a, 0x10, 0x43, 0x61, 0x63, 0x68, + 0x65, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x22, 0x0a, 0x1e, + 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x4c, 0x4f, 0x4f, 0x4b, 0x55, 0x50, 0x5f, 0x53, 0x43, 0x4f, + 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, + 0x12, 0x1d, 0x0a, 0x19, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x4c, 0x4f, 0x4f, 0x4b, 0x55, 0x50, + 0x5f, 0x53, 0x43, 0x4f, 0x50, 0x45, 0x5f, 0x47, 0x4c, 0x4f, 0x42, 0x41, 0x4c, 0x10, 0x01, 0x12, + 0x25, 0x0a, 0x21, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x4c, 0x4f, 0x4f, 0x4b, 0x55, 0x50, 0x5f, + 0x53, 0x43, 0x4f, 0x50, 0x45, 0x5f, 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x44, 0x4f, + 0x4d, 0x41, 0x49, 0x4e, 0x10, 0x02, 0x42, 0xab, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x42, 0x08, 0x52, + 0x75, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0xa2, 0x02, 0x03, + 0x46, 0x54, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x54, 0x61, 0x73, 0x6b, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x54, 0x61, 0x73, 0x6b, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x5c, 0x54, 0x61, 0x73, 0x6b, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, + 0x54, 0x61, 0x73, 0x6b, 0x4a, 0xc7, 0x1f, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x5f, 0x01, 0x0a, + 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, + 0x02, 0x00, 0x17, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x27, 0x0a, 0x09, + 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x27, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, + 0x03, 0x06, 0x00, 0x28, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x08, 0x00, 0x49, 0x0a, 0x09, + 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x08, 0x00, 0x49, 0x0a, 0xd1, 0x01, 0x0a, 0x02, 0x04, 0x00, + 0x12, 0x04, 0x0d, 0x00, 0x10, 0x01, 0x1a, 0xc4, 0x01, 0x20, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x61, 0x70, 0x70, + 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x0a, 0x20, + 0x49, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x20, 0x61, 0x20, + 0x6d, 0x6f, 0x64, 0x65, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x4f, 0x56, 0x45, 0x52, 0x52, + 0x49, 0x44, 0x45, 0x2c, 0x20, 0x41, 0x50, 0x50, 0x45, 0x4e, 0x44, 0x2c, 0x20, 0x65, 0x74, 0x63, + 0x29, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, + 0x0a, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x79, 0x20, 0x68, 0x6f, 0x77, + 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, + 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x72, 0x65, 0x67, 0x69, + 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x78, 0x65, + 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0d, 0x08, 0x0e, 0x0a, 0x4c, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x00, 0x12, 0x03, 0x0f, 0x02, 0x21, 0x1a, 0x3f, 0x20, 0x4d, 0x61, 0x70, 0x20, 0x6f, 0x66, 0x20, + 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x20, 0x74, 0x6f, + 0x20, 0x62, 0x65, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x0f, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x0f, 0x16, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0f, 0x1f, + 0x20, 0x0a, 0xdb, 0x01, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x15, 0x00, 0x18, 0x01, 0x1a, 0xce, + 0x01, 0x20, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x0a, 0x20, 0x49, 0x6e, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x20, 0x61, 0x20, 0x6d, 0x6f, 0x64, + 0x65, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x4f, 0x56, 0x45, 0x52, 0x52, 0x49, 0x44, 0x45, + 0x2c, 0x20, 0x41, 0x50, 0x50, 0x45, 0x4e, 0x44, 0x2c, 0x20, 0x65, 0x74, 0x63, 0x29, 0x20, 0x63, + 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x0a, 0x20, 0x74, + 0x6f, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x79, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x74, 0x6f, + 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x72, 0x65, + 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x15, 0x08, 0x13, 0x0a, 0x51, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x00, 0x12, 0x03, 0x17, 0x02, 0x21, 0x1a, 0x44, 0x20, 0x4d, 0x61, 0x70, 0x20, 0x6f, + 0x66, 0x20, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, + 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x17, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x17, 0x16, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x17, 0x1f, 0x20, 0x0a, 0xef, 0x01, 0x0a, 0x02, 0x04, 0x02, 0x12, + 0x04, 0x1d, 0x00, 0x20, 0x01, 0x1a, 0xe2, 0x01, 0x20, 0x45, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, + 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, + 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x0a, 0x20, 0x49, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x20, 0x61, 0x20, 0x6d, 0x6f, + 0x64, 0x65, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x4f, 0x56, 0x45, 0x52, 0x52, 0x49, 0x44, + 0x45, 0x2c, 0x20, 0x41, 0x50, 0x50, 0x45, 0x4e, 0x44, 0x2c, 0x20, 0x65, 0x74, 0x63, 0x29, 0x20, + 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x0a, 0x20, + 0x74, 0x6f, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x79, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x74, + 0x6f, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, + 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, + 0x01, 0x12, 0x03, 0x1d, 0x08, 0x0c, 0x0a, 0x5b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, + 0x1f, 0x02, 0x32, 0x1a, 0x4e, 0x20, 0x4d, 0x61, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x63, 0x75, 0x73, + 0x74, 0x6f, 0x6d, 0x20, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, + 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, + 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x04, 0x12, 0x03, 0x1f, 0x02, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, 0x03, 0x1f, 0x0b, 0x26, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1f, 0x27, 0x2d, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1f, 0x30, 0x31, 0x0a, 0x0a, 0x0a, 0x02, 0x04, + 0x03, 0x12, 0x04, 0x22, 0x00, 0x26, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, + 0x22, 0x08, 0x16, 0x0a, 0x76, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x25, 0x02, 0x1d, + 0x1a, 0x69, 0x20, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x77, 0x68, + 0x65, 0x72, 0x65, 0x20, 0x6f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20, 0x64, 0x61, + 0x74, 0x61, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x77, 0x72, 0x69, + 0x74, 0x74, 0x65, 0x6e, 0x0a, 0x20, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x73, 0x33, 0x3a, 0x2f, 0x2f, + 0x62, 0x75, 0x63, 0x6b, 0x65, 0x74, 0x2f, 0x6b, 0x65, 0x79, 0x20, 0x6f, 0x72, 0x20, 0x73, 0x33, + 0x3a, 0x2f, 0x2f, 0x62, 0x75, 0x63, 0x6b, 0x65, 0x74, 0x2f, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x00, 0x05, 0x12, 0x03, 0x25, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x25, 0x09, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x25, 0x1b, 0x1c, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x00, 0x12, 0x04, 0x28, 0x00, 0x36, + 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, 0x03, 0x28, 0x05, 0x15, 0x0a, 0x89, 0x01, + 0x0a, 0x04, 0x05, 0x00, 0x02, 0x00, 0x12, 0x03, 0x2b, 0x02, 0x25, 0x1a, 0x7c, 0x20, 0x43, 0x41, + 0x43, 0x48, 0x45, 0x5f, 0x4c, 0x4f, 0x4f, 0x4b, 0x55, 0x50, 0x5f, 0x53, 0x43, 0x4f, 0x50, 0x45, + 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x20, 0x69, 0x6e, 0x73, + 0x74, 0x72, 0x75, 0x63, 0x74, 0x73, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x6f, + 0x6b, 0x75, 0x70, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x62, 0x65, 0x68, 0x61, 0x76, 0x69, + 0x6f, 0x72, 0x20, 0x28, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x20, 0x75, 0x6e, 0x6c, 0x65, 0x73, + 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x65, 0x64, 0x0a, 0x20, 0x6f, 0x74, + 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x29, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x2b, 0x02, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x02, + 0x12, 0x03, 0x2b, 0x23, 0x24, 0x0a, 0xc0, 0x02, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x01, 0x12, 0x03, + 0x30, 0x02, 0x20, 0x1a, 0xb2, 0x02, 0x20, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x4c, 0x4f, 0x4f, + 0x4b, 0x55, 0x50, 0x5f, 0x53, 0x43, 0x4f, 0x50, 0x45, 0x5f, 0x47, 0x4c, 0x4f, 0x42, 0x41, 0x4c, + 0x20, 0x69, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x73, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, + 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x64, 0x6f, 0x20, 0x61, + 0x20, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x20, 0x28, + 0x75, 0x6e, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x64, 0x65, + 0x6e, 0x20, 0x62, 0x79, 0x20, 0x61, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x63, 0x6f, + 0x6e, 0x66, 0x69, 0x67, 0x29, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x68, 0x61, 0x73, + 0x20, 0x74, 0x72, 0x61, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x62, + 0x65, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, + 0x62, 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x2e, 0x20, 0x49, 0x74, 0x20, 0x72, 0x65, 0x71, + 0x75, 0x69, 0x72, 0x65, 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, + 0x61, 0x64, 0x73, 0x20, 0x72, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x6e, 0x20, 0x61, + 0x6c, 0x6c, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2f, 0x64, 0x6f, 0x6d, 0x61, + 0x69, 0x6e, 0x73, 0x0a, 0x20, 0x74, 0x6f, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x61, 0x63, 0x63, + 0x65, 0x73, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x20, + 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x2f, 0x62, 0x75, 0x63, 0x6b, 0x65, 0x74, + 0x73, 0x2e, 0x20, 0x4f, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x69, 0x74, 0x20, + 0x72, 0x69, 0x73, 0x6b, 0x73, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x66, 0x61, + 0x69, 0x6c, 0x75, 0x72, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x30, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x02, 0x12, + 0x03, 0x30, 0x1e, 0x1f, 0x0a, 0xc6, 0x02, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x02, 0x12, 0x03, 0x35, + 0x02, 0x28, 0x1a, 0xb8, 0x02, 0x20, 0x43, 0x41, 0x43, 0x48, 0x45, 0x5f, 0x4c, 0x4f, 0x4f, 0x4b, + 0x55, 0x50, 0x5f, 0x53, 0x43, 0x4f, 0x50, 0x45, 0x5f, 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, + 0x5f, 0x44, 0x4f, 0x4d, 0x41, 0x49, 0x4e, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, + 0x73, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x73, 0x20, + 0x74, 0x6f, 0x20, 0x64, 0x6f, 0x20, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2d, + 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x64, 0x20, 0x6c, 0x6f, + 0x6f, 0x6b, 0x75, 0x70, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x65, 0x6e, 0x73, 0x75, 0x72, + 0x65, 0x73, 0x0a, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, + 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, + 0x78, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, + 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, + 0x20, 0x6d, 0x69, 0x73, 0x73, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x72, 0x65, 0x63, 0x6f, + 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x70, 0x70, 0x65, 0x6e, + 0x69, 0x6e, 0x67, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x20, 0x6e, 0x6f, 0x74, 0x0a, 0x20, 0x62, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, + 0x72, 0x65, 0x64, 0x20, 0x61, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x20, 0x65, + 0x6e, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x28, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x63, 0x61, 0x6e, 0x20, 0x68, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x72, 0x6f, + 0x75, 0x67, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2d, 0x77, + 0x69, 0x64, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x29, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x35, 0x02, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x35, 0x26, 0x27, 0x0a, 0x67, 0x0a, 0x02, 0x04, 0x04, 0x12, + 0x04, 0x39, 0x00, 0x40, 0x01, 0x1a, 0x5b, 0x20, 0x43, 0x61, 0x63, 0x68, 0x65, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x63, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x69, 0x6e, 0x66, 0x6c, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, + 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, + 0x20, 0x72, 0x65, 0x61, 0x64, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, + 0x73, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x39, 0x08, 0x13, 0x0a, 0x58, + 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x3b, 0x02, 0x1b, 0x1a, 0x4b, 0x20, 0x49, 0x66, + 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, + 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, + 0x69, 0x74, 0x65, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, + 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, + 0x05, 0x12, 0x03, 0x3b, 0x02, 0x06, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x3b, 0x07, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x3b, + 0x19, 0x1a, 0x0a, 0xb5, 0x01, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x3f, 0x02, 0x2a, + 0x1a, 0xa7, 0x01, 0x20, 0x43, 0x61, 0x63, 0x68, 0x65, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x53, + 0x63, 0x6f, 0x70, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x20, 0x62, 0x65, + 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x6c, 0x65, 0x66, 0x74, 0x20, + 0x75, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2c, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x66, + 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x63, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x0a, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x75, + 0x73, 0x65, 0x64, 0x20, 0x28, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x20, 0x75, 0x6e, 0x6c, 0x65, + 0x73, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x65, 0x64, 0x20, 0x6f, 0x74, + 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x29, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x01, 0x06, 0x12, 0x03, 0x3f, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x3f, 0x13, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x3f, 0x28, 0x29, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x42, 0x00, 0x5f, 0x01, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x42, 0x08, 0x0f, 0x0a, 0x2a, 0x0a, 0x04, + 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x44, 0x02, 0x14, 0x1a, 0x1d, 0x20, 0x4c, 0x61, 0x62, 0x65, + 0x6c, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, + 0x06, 0x12, 0x03, 0x44, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x44, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x44, + 0x12, 0x13, 0x0a, 0x2f, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x03, 0x47, 0x02, 0x1e, 0x1a, + 0x22, 0x20, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x74, 0x6f, + 0x20, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, + 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x06, 0x12, 0x03, 0x47, 0x02, + 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, 0x12, 0x03, 0x47, 0x0e, 0x19, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x03, 0x47, 0x1c, 0x1d, 0x0a, 0x28, 0x0a, + 0x04, 0x04, 0x05, 0x02, 0x02, 0x12, 0x03, 0x4a, 0x02, 0x10, 0x1a, 0x1b, 0x20, 0x45, 0x6e, 0x76, + 0x73, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x06, + 0x12, 0x03, 0x4a, 0x02, 0x06, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x4a, 0x07, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x03, 0x12, 0x03, 0x4a, 0x0e, + 0x0f, 0x0a, 0x6d, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x03, 0x12, 0x03, 0x4d, 0x02, 0x2e, 0x1a, 0x60, + 0x20, 0x45, 0x78, 0x70, 0x6c, 0x69, 0x63, 0x69, 0x74, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x72, 0x69, + 0x64, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6e, 0x67, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x74, + 0x65, 0x72, 0x72, 0x75, 0x70, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x6f, 0x72, 0x20, 0x6e, 0x6f, + 0x74, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x65, 0x74, 0x2c, 0x20, 0x75, + 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x06, 0x12, 0x03, 0x4d, 0x02, 0x1b, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x01, 0x12, 0x03, 0x4d, 0x1c, 0x29, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x03, 0x03, 0x12, 0x03, 0x4d, 0x2c, 0x2d, 0x0a, 0x94, 0x01, 0x0a, 0x04, 0x04, + 0x05, 0x02, 0x04, 0x12, 0x03, 0x51, 0x02, 0x2f, 0x1a, 0x86, 0x01, 0x20, 0x49, 0x66, 0x20, 0x74, + 0x72, 0x75, 0x65, 0x2c, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x20, 0x6f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x72, 0x75, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, + 0x65, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x63, + 0x61, 0x63, 0x68, 0x65, 0x2e, 0x0a, 0x20, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, + 0x64, 0x2c, 0x20, 0x70, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x75, 0x73, 0x65, 0x20, 0x43, 0x61, + 0x63, 0x68, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x4f, 0x76, 0x65, 0x72, 0x77, 0x72, + 0x69, 0x74, 0x65, 0x43, 0x61, 0x63, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x05, 0x12, 0x03, 0x51, 0x02, 0x06, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x01, 0x12, 0x03, 0x51, 0x07, 0x16, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x04, 0x03, 0x12, 0x03, 0x51, 0x19, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x04, 0x08, 0x12, 0x03, 0x51, 0x1b, 0x2e, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x05, 0x02, + 0x04, 0x08, 0x03, 0x12, 0x03, 0x51, 0x1c, 0x2d, 0x0a, 0xa2, 0x01, 0x0a, 0x04, 0x04, 0x05, 0x02, + 0x05, 0x12, 0x03, 0x55, 0x02, 0x15, 0x1a, 0x94, 0x01, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x61, + 0x73, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x75, 0x6e, 0x6c, 0x65, 0x73, 0x73, + 0x20, 0x6f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x05, 0x05, 0x12, 0x03, 0x55, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x05, 0x01, 0x12, 0x03, 0x55, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x05, 0x03, 0x12, 0x03, 0x55, 0x13, 0x14, 0x0a, 0x6e, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x06, 0x12, + 0x03, 0x58, 0x02, 0x26, 0x1a, 0x61, 0x20, 0x45, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, + 0x74, 0x65, 0x73, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x73, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, + 0x73, 0x20, 0x70, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, + 0x6f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x28, + 0x69, 0x2e, 0x65, 0x2e, 0x20, 0x42, 0x6c, 0x6f, 0x62, 0x73, 0x2c, 0x20, 0x53, 0x63, 0x68, 0x65, + 0x6d, 0x61, 0x2c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2c, 0x20, + 0x65, 0x74, 0x63, 0x2e, 0x29, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, 0x06, + 0x12, 0x03, 0x58, 0x02, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, 0x01, 0x12, 0x03, + 0x58, 0x11, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, 0x03, 0x12, 0x03, 0x58, 0x24, + 0x25, 0x0a, 0x4d, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x07, 0x12, 0x03, 0x5b, 0x02, 0x36, 0x1a, 0x40, + 0x20, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, + 0x20, 0x68, 0x6f, 0x6c, 0x64, 0x73, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x20, + 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x61, 0x70, 0x70, 0x6c, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x06, 0x12, 0x03, 0x5b, 0x02, 0x20, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x01, 0x12, 0x03, 0x5b, 0x21, 0x31, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x07, 0x03, 0x12, 0x03, 0x5b, 0x34, 0x35, 0x0a, 0x68, 0x0a, 0x04, 0x04, 0x05, + 0x02, 0x08, 0x12, 0x03, 0x5e, 0x02, 0x1f, 0x1a, 0x5b, 0x20, 0x43, 0x61, 0x63, 0x68, 0x65, 0x43, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x63, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x69, 0x6e, 0x66, 0x6c, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x62, 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x63, 0x61, 0x63, + 0x68, 0x65, 0x20, 0x72, 0x65, 0x61, 0x64, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x77, 0x72, 0x69, + 0x74, 0x65, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x08, 0x06, 0x12, 0x03, 0x5e, + 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x08, 0x01, 0x12, 0x03, 0x5e, 0x0e, 0x1a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x08, 0x03, 0x12, 0x03, 0x5e, 0x1d, 0x1e, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xd5, 0x05, 0x0a, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, + 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x1a, 0x1b, 0x62, 0x75, 0x66, + 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x58, 0x0a, 0x0b, 0x45, 0x6e, 0x76, 0x69, + 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x1d, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x3f, + 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2a, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x08, 0xba, 0x48, 0x05, + 0x72, 0x03, 0x18, 0xff, 0x01, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x42, 0xb3, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x42, 0x10, 0x45, 0x6e, 0x76, 0x69, 0x72, + 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x32, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, + 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, + 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, + 0x6b, 0xa2, 0x02, 0x03, 0x46, 0x54, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x61, 0x73, 0x6b, 0xe2, 0x02, 0x1a, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x61, 0x73, 0x6b, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x3a, 0x3a, 0x54, 0x61, 0x73, 0x6b, 0x4a, 0xeb, 0x02, 0x0a, 0x06, 0x12, 0x04, 0x00, + 0x00, 0x12, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, + 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x17, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, + 0x00, 0x25, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x06, 0x00, 0x49, 0x0a, 0x09, 0x0a, 0x02, + 0x08, 0x0b, 0x12, 0x03, 0x06, 0x00, 0x49, 0x0a, 0x25, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x09, + 0x00, 0x12, 0x01, 0x1a, 0x19, 0x20, 0x45, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, + 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x09, 0x08, 0x13, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x00, 0x12, 0x04, 0x0b, 0x02, 0x0e, 0x04, 0x1a, 0x1a, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, + 0x6e, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x0b, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0b, 0x09, 0x0d, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0b, 0x10, 0x11, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x08, 0x12, 0x04, 0x0b, 0x12, 0x0e, 0x03, 0x0a, 0x10, 0x0a, + 0x09, 0x04, 0x00, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x0c, 0x04, 0x2b, 0x0a, + 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x03, 0x12, 0x03, 0x0d, 0x04, + 0x2c, 0x0a, 0x29, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x11, 0x02, 0x45, 0x1a, 0x1c, + 0x20, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, + 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x11, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x11, 0x09, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x11, 0x17, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x08, 0x12, + 0x03, 0x11, 0x19, 0x44, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, + 0x03, 0x12, 0x03, 0x11, 0x1a, 0x43, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xbc, + 0x53, 0x0a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, + 0x6b, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x70, 0x68, 0x61, 0x73, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, + 0x73, 0x6b, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, + 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, + 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x18, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, + 0x6b, 0x2f, 0x72, 0x75, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x8f, 0x01, 0x0a, + 0x08, 0x54, 0x61, 0x73, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1b, 0x0a, 0x03, 0x6f, 0x72, 0x67, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, + 0x3f, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x23, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, + 0x18, 0x3f, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x21, 0x0a, 0x06, 0x64, + 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, + 0x72, 0x04, 0x10, 0x01, 0x18, 0x3f, 0x52, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x1e, + 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0a, 0xba, 0x48, + 0x07, 0x72, 0x05, 0x10, 0x01, 0x18, 0xff, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0xba, + 0x01, 0x0a, 0x0e, 0x54, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x12, 0x1b, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, + 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x3f, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x23, + 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, + 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x3f, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x12, 0x21, 0x0a, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, 0x18, 0x3f, 0x52, 0x06, + 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x1e, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x0a, 0xba, 0x48, 0x07, 0x72, 0x05, 0x10, 0x01, 0x18, 0xff, 0x01, + 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, 0x10, 0x01, + 0x18, 0x3f, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x8d, 0x03, 0x0a, 0x13, + 0x54, 0x61, 0x73, 0x6b, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x53, 0x75, 0x6d, 0x6d, + 0x61, 0x72, 0x79, 0x12, 0x4e, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x73, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x48, 0x00, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x12, 0x48, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, + 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, + 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, + 0x74, 0x61, 0x74, 0x73, 0x48, 0x00, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x73, 0x1a, 0x8c, 0x01, + 0x0a, 0x0e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x12, 0x4e, 0x0a, 0x0f, + 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x41, 0x75, + 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0e, 0x61, 0x75, + 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x1a, 0x3c, 0x0a, 0x0c, + 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x14, 0x0a, 0x05, + 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x74, 0x6f, 0x74, + 0x61, 0x6c, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0d, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x42, 0x09, 0x0a, 0x07, 0x73, 0x75, + 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x4a, 0x04, 0x08, 0x01, 0x10, 0x02, 0x22, 0xdc, 0x01, 0x0a, 0x10, + 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x52, 0x75, 0x6e, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, + 0x12, 0x36, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x75, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x52, 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x12, 0x35, 0x0a, 0x08, 0x72, 0x75, 0x6e, 0x5f, + 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x07, 0x72, 0x75, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x12, + 0x33, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x68, 0x61, 0x73, 0x65, 0x52, 0x05, 0x70, + 0x68, 0x61, 0x73, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x74, 0x61, 0x73, + 0x6b, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x6f, + 0x6f, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0xe7, 0x02, 0x0a, 0x0c, 0x54, + 0x61, 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x4b, 0x0a, 0x0b, 0x64, + 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x0a, 0x64, 0x65, + 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x42, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x68, 0x6f, 0x72, + 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x68, + 0x6f, 0x72, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x43, 0x0a, 0x0b, 0x64, 0x65, 0x70, 0x6c, 0x6f, + 0x79, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, + 0x52, 0x0a, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x41, 0x74, 0x12, 0x29, 0x0a, 0x10, + 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, + 0x65, 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x4e, 0x0a, 0x10, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x73, 0x5f, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, + 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x53, + 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x0f, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, + 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x73, 0x68, 0x6f, 0x72, 0x74, + 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x10, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x62, 0x0a, 0x0b, 0x54, 0x61, 0x73, 0x6b, 0x53, 0x75, 0x6d, 0x6d, + 0x61, 0x72, 0x79, 0x12, 0x44, 0x0a, 0x0a, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x72, 0x75, + 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x52, + 0x75, 0x6e, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x48, 0x00, 0x52, 0x09, 0x6c, 0x61, 0x74, + 0x65, 0x73, 0x74, 0x52, 0x75, 0x6e, 0x88, 0x01, 0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x6c, 0x61, + 0x74, 0x65, 0x73, 0x74, 0x5f, 0x72, 0x75, 0x6e, 0x22, 0xdf, 0x01, 0x0a, 0x04, 0x54, 0x61, 0x73, + 0x6b, 0x12, 0x3f, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, + 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, + 0x49, 0x64, 0x12, 0x40, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x12, 0x43, 0x0a, 0x0c, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x73, 0x75, 0x6d, + 0x6d, 0x61, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, + 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x48, 0x00, 0x52, 0x0b, 0x74, 0x61, 0x73, 0x6b, 0x53, + 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x88, 0x01, 0x01, 0x42, 0x0f, 0x0a, 0x0d, 0x5f, 0x74, 0x61, + 0x73, 0x6b, 0x5f, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x20, 0x0a, 0x0a, 0x53, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6c, 0x69, 0x6e, 0x6b, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6c, 0x69, 0x6e, 0x6b, 0x22, 0xbe, 0x01, 0x0a, + 0x13, 0x44, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x12, 0x35, 0x0a, 0x11, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, + 0x08, 0xba, 0x48, 0x05, 0x72, 0x03, 0x18, 0xff, 0x01, 0x52, 0x10, 0x73, 0x68, 0x6f, 0x72, 0x74, + 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x33, 0x0a, 0x10, 0x6c, + 0x6f, 0x6e, 0x67, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x08, 0xba, 0x48, 0x05, 0x72, 0x03, 0x18, 0x80, 0x10, 0x52, + 0x0f, 0x6c, 0x6f, 0x6e, 0x67, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x3b, 0x0a, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, + 0x65, 0x52, 0x0a, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x22, 0xce, 0x02, + 0x0a, 0x08, 0x54, 0x61, 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x12, 0x49, 0x0a, 0x0d, 0x74, 0x61, + 0x73, 0x6b, 0x5f, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x42, + 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x0c, 0x74, 0x61, 0x73, 0x6b, 0x54, 0x65, 0x6d, + 0x70, 0x6c, 0x61, 0x74, 0x65, 0x12, 0x45, 0x0a, 0x0e, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, + 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4e, + 0x61, 0x6d, 0x65, 0x64, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x52, 0x0d, 0x64, + 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x12, 0x26, 0x0a, 0x0a, + 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x18, 0x3f, 0x52, 0x09, 0x73, 0x68, 0x6f, 0x72, 0x74, + 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x3d, 0x0a, 0x0b, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, + 0x65, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x45, 0x6e, 0x76, 0x69, 0x72, + 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x0b, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, + 0x65, 0x6e, 0x74, 0x12, 0x49, 0x0a, 0x0d, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x44, 0x6f, 0x63, 0x75, + 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, + 0x0d, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x49, + 0x0a, 0x09, 0x54, 0x72, 0x61, 0x63, 0x65, 0x53, 0x70, 0x65, 0x63, 0x12, 0x3c, 0x0a, 0x09, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x54, 0x79, 0x70, 0x65, 0x64, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x52, 0x09, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x22, 0xc6, 0x01, 0x0a, 0x0b, 0x54, 0x61, + 0x73, 0x6b, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x3f, 0x0a, 0x07, 0x74, 0x61, 0x73, + 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, + 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, + 0x01, 0x01, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x12, 0x40, 0x0a, 0x08, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, + 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, + 0x01, 0x01, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x34, 0x0a, 0x04, + 0x73, 0x70, 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, + 0x53, 0x70, 0x65, 0x63, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x04, 0x73, 0x70, + 0x65, 0x63, 0x22, 0xba, 0x01, 0x0a, 0x0b, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x12, 0x1e, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x42, 0x0a, 0xba, 0x48, 0x07, 0x72, 0x05, 0x10, 0x01, 0x18, 0xff, 0x01, 0x52, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x12, 0x3b, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, + 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, 0x70, 0x65, + 0x63, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x04, 0x73, 0x70, 0x65, 0x63, 0x12, + 0x4e, 0x0a, 0x0f, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x70, + 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x41, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x52, + 0x0e, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x22, + 0xaf, 0x01, 0x0a, 0x0f, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, + 0x70, 0x65, 0x63, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x12, 0x2e, 0x0a, 0x06, 0x69, + 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x49, 0x6e, 0x70, + 0x75, 0x74, 0x73, 0x52, 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x12, 0x32, 0x0a, 0x08, 0x72, + 0x75, 0x6e, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x52, + 0x75, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x52, 0x07, 0x72, 0x75, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x12, + 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x42, 0xb6, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x42, 0x13, 0x54, 0x61, 0x73, 0x6b, 0x44, 0x65, + 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, + 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, + 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, + 0x61, 0x73, 0x6b, 0xa2, 0x02, 0x03, 0x46, 0x54, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0xca, 0x02, 0x0e, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x61, 0x73, 0x6b, 0xe2, 0x02, 0x1a, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x61, 0x73, 0x6b, 0x5c, 0x47, 0x50, 0x42, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x54, 0x61, 0x73, 0x6b, 0x4a, 0xe8, 0x38, 0x0a, 0x07, 0x12, + 0x05, 0x00, 0x00, 0xe7, 0x01, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, + 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x17, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, + 0x12, 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x2b, + 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, 0x29, 0x0a, 0x09, 0x0a, 0x02, 0x03, + 0x03, 0x12, 0x03, 0x07, 0x00, 0x26, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x04, 0x12, 0x03, 0x08, 0x00, + 0x28, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x05, 0x12, 0x03, 0x09, 0x00, 0x24, 0x0a, 0x09, 0x0a, 0x02, + 0x03, 0x06, 0x12, 0x03, 0x0a, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x07, 0x12, 0x03, 0x0b, + 0x00, 0x2a, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x08, 0x12, 0x03, 0x0c, 0x00, 0x22, 0x0a, 0x09, 0x0a, + 0x02, 0x03, 0x09, 0x12, 0x03, 0x0d, 0x00, 0x29, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x0f, + 0x00, 0x49, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x0f, 0x00, 0x49, 0x0a, 0x45, 0x0a, + 0x02, 0x04, 0x00, 0x12, 0x04, 0x12, 0x00, 0x2a, 0x01, 0x1a, 0x39, 0x20, 0x4e, 0x61, 0x6d, 0x65, + 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x20, 0x49, 0x74, 0x20, 0x6d, + 0x61, 0x79, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, + 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, + 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x12, 0x08, 0x10, + 0x0a, 0x29, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x04, 0x14, 0x02, 0x17, 0x04, 0x1a, 0x1b, + 0x20, 0x4f, 0x72, 0x67, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x62, + 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x14, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x14, 0x09, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x14, 0x0f, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x08, 0x12, 0x04, + 0x14, 0x11, 0x17, 0x03, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, + 0x02, 0x12, 0x03, 0x15, 0x04, 0x2b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x00, 0x08, 0x87, + 0x09, 0x0e, 0x03, 0x12, 0x03, 0x16, 0x04, 0x2c, 0x0a, 0x2d, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, + 0x12, 0x04, 0x1a, 0x02, 0x1d, 0x04, 0x1a, 0x1f, 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x6e, + 0x67, 0x73, 0x20, 0x74, 0x6f, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, + 0x12, 0x03, 0x1a, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x1a, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x1a, 0x13, + 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x08, 0x12, 0x04, 0x1a, 0x15, 0x1d, 0x03, + 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x1b, + 0x04, 0x2b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, 0x03, 0x12, + 0x03, 0x1c, 0x04, 0x2c, 0x0a, 0x2c, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x04, 0x20, 0x02, + 0x23, 0x04, 0x1a, 0x1e, 0x20, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x20, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x20, 0x09, 0x0f, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x20, 0x12, 0x13, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x02, 0x08, 0x12, 0x04, 0x20, 0x14, 0x23, 0x03, 0x0a, 0x10, 0x0a, 0x09, 0x04, + 0x00, 0x02, 0x02, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x21, 0x04, 0x2b, 0x0a, 0x10, 0x0a, + 0x09, 0x04, 0x00, 0x02, 0x02, 0x08, 0x87, 0x09, 0x0e, 0x03, 0x12, 0x03, 0x22, 0x04, 0x2c, 0x0a, + 0x89, 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x03, 0x12, 0x04, 0x26, 0x02, 0x29, 0x04, 0x1a, 0x7b, + 0x20, 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x20, 0x53, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, + 0x74, 0x65, 0x64, 0x2f, 0x70, 0x61, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x20, 0x55, 0x73, 0x65, 0x20, + 0x60, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x60, 0x20, 0x61, 0x6e, 0x64, + 0x20, 0x60, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x6e, 0x61, + 0x6d, 0x65, 0x60, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x66, 0x61, 0x63, + 0x69, 0x6e, 0x67, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x03, 0x05, 0x12, 0x03, 0x26, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x03, 0x01, 0x12, 0x03, 0x26, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, + 0x12, 0x03, 0x26, 0x10, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x08, 0x12, 0x04, + 0x26, 0x12, 0x29, 0x03, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x03, 0x08, 0x87, 0x09, 0x0e, + 0x02, 0x12, 0x03, 0x27, 0x04, 0x2b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x03, 0x08, 0x87, + 0x09, 0x0e, 0x03, 0x12, 0x03, 0x28, 0x04, 0x2d, 0x0a, 0x41, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, + 0x2d, 0x00, 0x4b, 0x01, 0x1a, 0x35, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x69, + 0x71, 0x75, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x01, 0x01, 0x12, 0x03, 0x2d, 0x08, 0x16, 0x0a, 0x29, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, + 0x04, 0x2f, 0x02, 0x32, 0x04, 0x1a, 0x1b, 0x20, 0x4f, 0x72, 0x67, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x2f, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2f, 0x09, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x2f, 0x0f, 0x10, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x00, 0x08, 0x12, 0x04, 0x2f, 0x11, 0x32, 0x03, 0x0a, 0x10, 0x0a, 0x09, 0x04, + 0x01, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x30, 0x04, 0x2b, 0x0a, 0x10, 0x0a, + 0x09, 0x04, 0x01, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x03, 0x12, 0x03, 0x31, 0x04, 0x2c, 0x0a, + 0x2d, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x04, 0x35, 0x02, 0x38, 0x04, 0x1a, 0x1f, 0x20, + 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, + 0x6b, 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, 0x35, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x35, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x35, 0x13, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, + 0x08, 0x12, 0x04, 0x35, 0x15, 0x38, 0x03, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x01, 0x02, 0x01, 0x08, + 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x36, 0x04, 0x2b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x01, 0x02, + 0x01, 0x08, 0x87, 0x09, 0x0e, 0x03, 0x12, 0x03, 0x37, 0x04, 0x2c, 0x0a, 0x2c, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x02, 0x12, 0x04, 0x3b, 0x02, 0x3e, 0x04, 0x1a, 0x1e, 0x20, 0x44, 0x6f, 0x6d, 0x61, + 0x69, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x62, 0x65, 0x6c, + 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x02, 0x05, 0x12, 0x03, 0x3b, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x3b, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, + 0x3b, 0x12, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x08, 0x12, 0x04, 0x3b, 0x14, + 0x3e, 0x03, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x01, 0x02, 0x02, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, + 0x03, 0x3c, 0x04, 0x2b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x01, 0x02, 0x02, 0x08, 0x87, 0x09, 0x0e, + 0x03, 0x12, 0x03, 0x3d, 0x04, 0x2c, 0x0a, 0x89, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x03, 0x12, + 0x04, 0x41, 0x02, 0x44, 0x04, 0x1a, 0x7b, 0x20, 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x6e, + 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x20, 0x53, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x2f, 0x70, 0x61, 0x72, 0x73, 0x65, + 0x64, 0x2e, 0x20, 0x55, 0x73, 0x65, 0x20, 0x60, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x6e, 0x61, + 0x6d, 0x65, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x60, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, + 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x60, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x75, + 0x73, 0x65, 0x72, 0x20, 0x66, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x05, 0x12, 0x03, 0x41, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x01, 0x12, 0x03, 0x41, 0x09, 0x0d, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x03, 0x12, 0x03, 0x41, 0x10, 0x11, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x03, 0x08, 0x12, 0x04, 0x41, 0x12, 0x44, 0x03, 0x0a, 0x10, 0x0a, 0x09, 0x04, + 0x01, 0x02, 0x03, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x42, 0x04, 0x2b, 0x0a, 0x10, 0x0a, + 0x09, 0x04, 0x01, 0x02, 0x03, 0x08, 0x87, 0x09, 0x0e, 0x03, 0x12, 0x03, 0x43, 0x04, 0x2d, 0x0a, + 0x24, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x04, 0x12, 0x04, 0x47, 0x02, 0x4a, 0x04, 0x1a, 0x16, 0x20, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, + 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x05, 0x12, 0x03, + 0x47, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x01, 0x12, 0x03, 0x47, 0x09, + 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x03, 0x12, 0x03, 0x47, 0x13, 0x14, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x08, 0x12, 0x04, 0x47, 0x15, 0x4a, 0x03, 0x0a, 0x10, + 0x0a, 0x09, 0x04, 0x01, 0x02, 0x04, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x48, 0x04, 0x2b, + 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x01, 0x02, 0x04, 0x08, 0x87, 0x09, 0x0e, 0x03, 0x12, 0x03, 0x49, + 0x04, 0x2c, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x4d, 0x00, 0x5f, 0x01, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x4d, 0x08, 0x1b, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, + 0x09, 0x12, 0x03, 0x4e, 0x02, 0x0d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x09, 0x00, 0x12, 0x03, + 0x4e, 0x0b, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x09, 0x00, 0x01, 0x12, 0x03, 0x4e, 0x0b, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x09, 0x00, 0x02, 0x12, 0x03, 0x4e, 0x0b, 0x0c, 0x0a, + 0x0c, 0x0a, 0x04, 0x04, 0x02, 0x03, 0x00, 0x12, 0x04, 0x50, 0x02, 0x54, 0x03, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x03, 0x00, 0x01, 0x12, 0x03, 0x50, 0x0a, 0x18, 0x0a, 0x0d, 0x0a, 0x06, 0x04, + 0x02, 0x03, 0x00, 0x02, 0x00, 0x12, 0x03, 0x51, 0x04, 0x14, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, + 0x03, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x51, 0x04, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, + 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x51, 0x0b, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, + 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x51, 0x12, 0x13, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, + 0x03, 0x00, 0x02, 0x01, 0x12, 0x03, 0x52, 0x04, 0x14, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, + 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x52, 0x04, 0x08, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, + 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x52, 0x09, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, + 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x52, 0x12, 0x13, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x03, + 0x00, 0x02, 0x02, 0x12, 0x03, 0x53, 0x04, 0x2e, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, + 0x02, 0x02, 0x06, 0x12, 0x03, 0x53, 0x04, 0x19, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x53, 0x1a, 0x29, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, + 0x02, 0x02, 0x03, 0x12, 0x03, 0x53, 0x2c, 0x2d, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x02, 0x03, 0x01, + 0x12, 0x04, 0x56, 0x02, 0x59, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x03, 0x01, 0x01, 0x12, + 0x03, 0x56, 0x0a, 0x16, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x03, 0x01, 0x02, 0x00, 0x12, 0x03, + 0x57, 0x04, 0x15, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x57, 0x04, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x57, 0x0b, 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x57, 0x13, 0x14, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x03, 0x01, 0x02, 0x01, 0x12, 0x03, 0x58, + 0x04, 0x16, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, 0x58, + 0x04, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x58, + 0x0b, 0x11, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x58, + 0x14, 0x15, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x02, 0x08, 0x00, 0x12, 0x04, 0x5b, 0x02, 0x5e, 0x03, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x08, 0x00, 0x01, 0x12, 0x03, 0x5b, 0x08, 0x0f, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x5c, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x00, 0x06, 0x12, 0x03, 0x5c, 0x04, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x5c, 0x13, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x5c, 0x1d, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x5d, + 0x04, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, 0x03, 0x5d, 0x04, 0x10, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x5d, 0x11, 0x16, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x5d, 0x19, 0x1a, 0x0a, 0xb9, 0x01, 0x0a, + 0x02, 0x04, 0x03, 0x12, 0x04, 0x63, 0x00, 0x6f, 0x01, 0x1a, 0xac, 0x01, 0x20, 0x4c, 0x61, 0x74, + 0x65, 0x73, 0x74, 0x52, 0x75, 0x6e, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x20, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x61, 0x6c, 0x20, 0x69, + 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, + 0x20, 0x72, 0x75, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, + 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x67, 0x68, 0x74, + 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x20, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x61, 0x76, 0x6f, 0x69, 0x64, 0x73, 0x20, 0x63, 0x69, 0x72, 0x63, 0x75, + 0x6c, 0x61, 0x72, 0x20, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x69, 0x65, 0x73, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x20, 0x70, + 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, + 0x03, 0x63, 0x08, 0x18, 0x0a, 0x1d, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x65, 0x02, + 0x22, 0x1a, 0x10, 0x20, 0x52, 0x75, 0x6e, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x65, 0x02, + 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x65, 0x17, 0x1d, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x65, 0x20, 0x21, 0x0a, 0x1c, 0x0a, + 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, 0x68, 0x02, 0x29, 0x1a, 0x0f, 0x20, 0x4c, 0x61, 0x73, + 0x74, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x01, 0x06, 0x12, 0x03, 0x68, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x68, 0x1c, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x68, 0x27, 0x28, 0x0a, 0x24, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x02, 0x12, 0x03, 0x6b, + 0x02, 0x1f, 0x1a, 0x17, 0x20, 0x50, 0x68, 0x61, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6c, 0x61, 0x73, 0x74, 0x20, 0x72, 0x75, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x02, 0x06, 0x12, 0x03, 0x6b, 0x02, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x6b, 0x15, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x6b, 0x1d, 0x1e, 0x0a, 0x44, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x03, 0x12, 0x03, 0x6e, + 0x02, 0x1c, 0x1a, 0x37, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6c, 0x61, 0x73, 0x74, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x28, 0x65, 0x6e, 0x76, 0x2e, + 0x74, 0x61, 0x73, 0x6b, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x29, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x03, 0x05, 0x12, 0x03, 0x6e, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x03, 0x01, 0x12, 0x03, 0x6e, 0x09, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x03, + 0x12, 0x03, 0x6e, 0x1a, 0x1b, 0x0a, 0x49, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x05, 0x72, 0x00, 0x84, + 0x01, 0x01, 0x1a, 0x3c, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x69, 0x73, 0x20, 0x73, 0x74, 0x61, 0x74, 0x69, 0x63, 0x2c, 0x20, 0x6c, 0x69, 0x67, + 0x68, 0x74, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x72, 0x08, 0x14, 0x0a, 0x2f, 0x0a, 0x04, + 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x74, 0x02, 0x51, 0x1a, 0x22, 0x20, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, + 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x00, 0x06, 0x12, 0x03, 0x74, 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x74, 0x1a, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x74, 0x28, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x08, + 0x12, 0x03, 0x74, 0x2a, 0x50, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x04, 0x02, 0x00, 0x08, 0x87, 0x09, + 0x19, 0x12, 0x03, 0x74, 0x2b, 0x4f, 0x0a, 0x2b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, + 0x77, 0x02, 0x18, 0x1a, 0x1e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x20, + 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, + 0x73, 0x6b, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x05, 0x12, 0x03, 0x77, 0x02, + 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x77, 0x09, 0x13, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x77, 0x16, 0x17, 0x0a, 0x2d, 0x0a, + 0x04, 0x04, 0x04, 0x02, 0x02, 0x12, 0x03, 0x7a, 0x02, 0x53, 0x1a, 0x20, 0x20, 0x54, 0x68, 0x65, + 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x77, + 0x61, 0x73, 0x20, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x02, 0x06, 0x12, 0x03, 0x7a, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x7a, 0x1c, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, + 0x03, 0x12, 0x03, 0x7a, 0x2a, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x08, 0x12, + 0x03, 0x7a, 0x2c, 0x52, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x04, 0x02, 0x02, 0x08, 0x87, 0x09, 0x19, + 0x12, 0x03, 0x7a, 0x2d, 0x51, 0x0a, 0x3e, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x03, 0x12, 0x03, 0x7d, + 0x02, 0x1e, 0x1a, 0x31, 0x20, 0x54, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, + 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x70, 0x72, 0x65, 0x73, + 0x65, 0x6e, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x05, 0x12, 0x03, + 0x7d, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x01, 0x12, 0x03, 0x7d, 0x09, + 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x03, 0x12, 0x03, 0x7d, 0x1c, 0x1d, 0x0a, + 0x3b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x04, 0x12, 0x04, 0x80, 0x01, 0x02, 0x2b, 0x1a, 0x2d, 0x20, + 0x42, 0x72, 0x69, 0x65, 0x66, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x76, 0x69, 0x65, 0x77, 0x20, 0x6f, + 0x66, 0x20, 0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x73, 0x20, 0x69, 0x66, 0x20, 0x61, 0x6e, 0x79, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x04, 0x06, 0x12, 0x04, 0x80, 0x01, 0x02, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x04, 0x01, 0x12, 0x04, 0x80, 0x01, 0x16, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x04, 0x03, 0x12, 0x04, 0x80, 0x01, 0x29, 0x2a, 0x0a, 0x33, 0x0a, 0x04, 0x04, 0x04, 0x02, + 0x05, 0x12, 0x04, 0x83, 0x01, 0x02, 0x1f, 0x1a, 0x25, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x68, + 0x6f, 0x72, 0x74, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x05, 0x05, 0x12, 0x04, 0x83, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x05, 0x01, 0x12, 0x04, 0x83, 0x01, 0x09, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x05, 0x03, 0x12, 0x04, 0x83, 0x01, 0x1d, 0x1e, 0x0a, 0x0c, 0x0a, 0x02, 0x04, + 0x05, 0x12, 0x06, 0x86, 0x01, 0x00, 0x89, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x05, 0x01, + 0x12, 0x04, 0x86, 0x01, 0x08, 0x13, 0x0a, 0x3f, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x04, + 0x88, 0x01, 0x02, 0x2b, 0x1a, 0x31, 0x20, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x20, 0x72, 0x75, 0x6e, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2c, 0x20, + 0x69, 0x66, 0x20, 0x61, 0x6e, 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x04, + 0x12, 0x04, 0x88, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x06, 0x12, + 0x04, 0x88, 0x01, 0x0b, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x04, + 0x88, 0x01, 0x1c, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x04, 0x88, + 0x01, 0x29, 0x2a, 0x0a, 0x35, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x06, 0x8c, 0x01, 0x00, 0x95, 0x01, + 0x01, 0x1a, 0x27, 0x20, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x20, + 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, + 0x66, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x06, + 0x01, 0x12, 0x04, 0x8c, 0x01, 0x08, 0x0c, 0x0a, 0x21, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, + 0x04, 0x8e, 0x01, 0x02, 0x44, 0x1a, 0x13, 0x20, 0x49, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x00, 0x06, 0x12, 0x04, 0x8e, 0x01, 0x02, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x00, 0x01, 0x12, 0x04, 0x8e, 0x01, 0x11, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, + 0x03, 0x12, 0x04, 0x8e, 0x01, 0x1b, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x08, + 0x12, 0x04, 0x8e, 0x01, 0x1d, 0x43, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x06, 0x02, 0x00, 0x08, 0x87, + 0x09, 0x19, 0x12, 0x04, 0x8e, 0x01, 0x1e, 0x42, 0x0a, 0x27, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x01, + 0x12, 0x04, 0x91, 0x01, 0x02, 0x43, 0x1a, 0x19, 0x20, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x06, 0x12, 0x04, 0x91, 0x01, 0x02, 0x0e, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x01, 0x12, 0x04, 0x91, 0x01, 0x0f, 0x17, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x03, 0x12, 0x04, 0x91, 0x01, 0x1a, 0x1b, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x08, 0x12, 0x04, 0x91, 0x01, 0x1c, 0x42, 0x0a, 0x10, 0x0a, + 0x08, 0x04, 0x06, 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x04, 0x91, 0x01, 0x1d, 0x41, 0x0a, + 0x26, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x02, 0x12, 0x04, 0x94, 0x01, 0x02, 0x28, 0x1a, 0x18, 0x20, + 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x04, + 0x12, 0x04, 0x94, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x06, 0x12, + 0x04, 0x94, 0x01, 0x0b, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x01, 0x12, 0x04, + 0x94, 0x01, 0x17, 0x23, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x03, 0x12, 0x04, 0x94, + 0x01, 0x26, 0x27, 0x0a, 0x3e, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x06, 0x98, 0x01, 0x00, 0x9a, 0x01, + 0x01, 0x1a, 0x30, 0x20, 0x4c, 0x69, 0x6e, 0x6b, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x65, 0x6e, 0x74, 0x69, + 0x74, 0x79, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x04, 0x98, 0x01, 0x08, 0x12, + 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x04, 0x99, 0x01, 0x02, 0x12, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x05, 0x12, 0x04, 0x99, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x00, 0x01, 0x12, 0x04, 0x99, 0x01, 0x09, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x00, 0x03, 0x12, 0x04, 0x99, 0x01, 0x10, 0x11, 0x0a, 0x0c, 0x0a, 0x02, 0x04, + 0x08, 0x12, 0x06, 0x9c, 0x01, 0x00, 0xa3, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x08, 0x01, + 0x12, 0x04, 0x9c, 0x01, 0x08, 0x1b, 0x0a, 0x31, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x00, 0x12, 0x04, + 0x9e, 0x01, 0x02, 0x4b, 0x1a, 0x23, 0x20, 0x4f, 0x6e, 0x65, 0x2d, 0x6c, 0x69, 0x6e, 0x65, 0x72, + 0x20, 0x6f, 0x76, 0x65, 0x72, 0x76, 0x69, 0x65, 0x77, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x00, 0x05, 0x12, 0x04, 0x9e, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, + 0x01, 0x12, 0x04, 0x9e, 0x01, 0x09, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, + 0x12, 0x04, 0x9e, 0x01, 0x1d, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x08, 0x12, + 0x04, 0x9e, 0x01, 0x1f, 0x4a, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x08, 0x02, 0x00, 0x08, 0x87, 0x09, + 0x0e, 0x03, 0x12, 0x04, 0x9e, 0x01, 0x20, 0x49, 0x0a, 0x40, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x01, + 0x12, 0x04, 0xa0, 0x01, 0x02, 0x4b, 0x1a, 0x32, 0x20, 0x46, 0x75, 0x6c, 0x6c, 0x20, 0x75, 0x73, + 0x65, 0x72, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x70, + 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x01, 0x05, 0x12, 0x04, 0xa0, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x01, 0x01, 0x12, 0x04, 0xa0, 0x01, 0x09, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, + 0x03, 0x12, 0x04, 0xa0, 0x01, 0x1c, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x08, + 0x12, 0x04, 0xa0, 0x01, 0x1e, 0x4a, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x08, 0x02, 0x01, 0x08, 0x87, + 0x09, 0x0e, 0x03, 0x12, 0x04, 0xa0, 0x01, 0x1f, 0x49, 0x0a, 0x48, 0x0a, 0x04, 0x04, 0x08, 0x02, + 0x02, 0x12, 0x04, 0xa2, 0x01, 0x02, 0x1d, 0x1a, 0x3a, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x6c, 0x20, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x64, + 0x65, 0x66, 0x69, 0x6e, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x65, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x06, 0x12, 0x04, 0xa2, 0x01, + 0x02, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x01, 0x12, 0x04, 0xa2, 0x01, 0x0d, + 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x03, 0x12, 0x04, 0xa2, 0x01, 0x1b, 0x1c, + 0x0a, 0x29, 0x0a, 0x02, 0x04, 0x09, 0x12, 0x06, 0xa6, 0x01, 0x00, 0xb8, 0x01, 0x01, 0x1a, 0x1b, + 0x20, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, + 0x09, 0x01, 0x12, 0x04, 0xa6, 0x01, 0x08, 0x10, 0x0a, 0x2b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x00, + 0x12, 0x04, 0xa8, 0x01, 0x02, 0x57, 0x1a, 0x1d, 0x20, 0x54, 0x68, 0x65, 0x20, 0x74, 0x65, 0x6d, + 0x70, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, + 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x06, 0x12, 0x04, + 0xa8, 0x01, 0x02, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x04, 0xa8, + 0x01, 0x1e, 0x2b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, 0x04, 0xa8, 0x01, + 0x2e, 0x2f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x08, 0x12, 0x04, 0xa8, 0x01, 0x30, + 0x56, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x09, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x04, 0xa8, + 0x01, 0x31, 0x55, 0x0a, 0xac, 0x01, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x01, 0x12, 0x04, 0xad, 0x01, + 0x02, 0x2d, 0x1a, 0x9d, 0x01, 0x20, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20, 0x64, 0x65, + 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x2e, 0x0a, 0x20, 0x54, + 0x68, 0x65, 0x73, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x6f, 0x76, 0x65, 0x72, + 0x72, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x61, 0x6e, 0x20, 0x72, + 0x75, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x20, + 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6e, 0x6f, + 0x74, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x3d, + 0x74, 0x72, 0x75, 0x65, 0x20, 0x66, 0x6c, 0x61, 0x67, 0x20, 0x69, 0x6e, 0x20, 0x75, 0x6e, 0x64, + 0x65, 0x72, 0x6c, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x04, 0x12, 0x04, 0xad, 0x01, 0x02, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x06, 0x12, 0x04, 0xad, 0x01, 0x0b, 0x19, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x01, 0x12, 0x04, 0xad, 0x01, 0x1a, 0x28, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x03, 0x12, 0x04, 0xad, 0x01, 0x2b, 0x2c, 0x0a, 0xca, + 0x01, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x02, 0x12, 0x04, 0xb1, 0x01, 0x02, 0x43, 0x1a, 0xbb, 0x01, + 0x20, 0x55, 0x73, 0x65, 0x72, 0x20, 0x66, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x69, 0x73, + 0x70, 0x6c, 0x61, 0x79, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x20, 0x4e, 0x6f, 0x74, 0x20, 0x72, 0x65, 0x71, + 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, + 0x75, 0x65, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x70, 0x61, 0x73, + 0x73, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x76, 0x69, 0x61, 0x20, 0x74, 0x68, 0x65, 0x20, 0x53, + 0x44, 0x4b, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, + 0x20, 0x69, 0x73, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x61, 0x6e, 0x64, 0x20, + 0x69, 0x73, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x61, 0x20, 0x75, 0x73, 0x65, 0x72, + 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, + 0x65, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x09, 0x02, 0x02, 0x05, 0x12, 0x04, 0xb1, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x02, 0x01, 0x12, 0x04, 0xb1, 0x01, 0x09, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, + 0x02, 0x03, 0x12, 0x04, 0xb1, 0x01, 0x16, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, + 0x08, 0x12, 0x04, 0xb1, 0x01, 0x18, 0x42, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x09, 0x02, 0x02, 0x08, + 0x87, 0x09, 0x0e, 0x03, 0x12, 0x04, 0xb1, 0x01, 0x19, 0x41, 0x0a, 0x75, 0x0a, 0x04, 0x04, 0x09, + 0x02, 0x03, 0x12, 0x04, 0xb4, 0x01, 0x02, 0x1e, 0x1a, 0x67, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x61, 0x6c, 0x20, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x20, 0x4e, + 0x6f, 0x74, 0x65, 0x2c, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x20, + 0x6d, 0x61, 0x79, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x69, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x20, 0x6f, 0x66, + 0x20, 0x61, 0x6e, 0x20, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, 0x06, 0x12, 0x04, 0xb4, 0x01, 0x02, 0x0d, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, 0x01, 0x12, 0x04, 0xb4, 0x01, 0x0e, 0x19, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, 0x03, 0x12, 0x04, 0xb4, 0x01, 0x1c, 0x1d, 0x0a, 0x35, + 0x0a, 0x04, 0x04, 0x09, 0x02, 0x04, 0x12, 0x04, 0xb7, 0x01, 0x02, 0x28, 0x1a, 0x27, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x74, 0x61, 0x73, 0x6b, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x04, 0x06, 0x12, 0x04, + 0xb7, 0x01, 0x02, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x04, 0x01, 0x12, 0x04, 0xb7, + 0x01, 0x16, 0x23, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x04, 0x03, 0x12, 0x04, 0xb7, 0x01, + 0x26, 0x27, 0x0a, 0x31, 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x06, 0xbb, 0x01, 0x00, 0xbe, 0x01, 0x01, + 0x1a, 0x23, 0x20, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x74, 0x72, 0x61, 0x63, 0x65, 0x20, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0a, 0x01, 0x12, 0x04, 0xbb, 0x01, + 0x08, 0x11, 0x0a, 0x39, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x00, 0x12, 0x04, 0xbd, 0x01, 0x02, 0x2e, + 0x1a, 0x2b, 0x20, 0x41, 0x20, 0x73, 0x74, 0x72, 0x6f, 0x6e, 0x67, 0x6c, 0x79, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x63, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0a, 0x02, 0x00, 0x06, 0x12, 0x04, 0xbd, 0x01, 0x02, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x04, 0xbd, 0x01, 0x20, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0a, 0x02, 0x00, 0x03, 0x12, 0x04, 0xbd, 0x01, 0x2c, 0x2d, 0x0a, 0x32, 0x0a, 0x02, 0x04, 0x0b, + 0x12, 0x06, 0xc1, 0x01, 0x00, 0xca, 0x01, 0x01, 0x1a, 0x24, 0x20, 0x44, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0b, + 0x0a, 0x03, 0x04, 0x0b, 0x01, 0x12, 0x04, 0xc1, 0x01, 0x08, 0x13, 0x0a, 0x21, 0x0a, 0x04, 0x04, + 0x0b, 0x02, 0x00, 0x12, 0x04, 0xc3, 0x01, 0x02, 0x44, 0x1a, 0x13, 0x20, 0x49, 0x64, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x06, 0x12, 0x04, 0xc3, 0x01, 0x02, 0x10, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0b, 0x02, 0x00, 0x01, 0x12, 0x04, 0xc3, 0x01, 0x11, 0x18, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0b, 0x02, 0x00, 0x03, 0x12, 0x04, 0xc3, 0x01, 0x1b, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0b, 0x02, 0x00, 0x08, 0x12, 0x04, 0xc3, 0x01, 0x1d, 0x43, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x0b, + 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x04, 0xc3, 0x01, 0x1e, 0x42, 0x0a, 0x27, 0x0a, 0x04, + 0x04, 0x0b, 0x02, 0x01, 0x12, 0x04, 0xc6, 0x01, 0x02, 0x43, 0x1a, 0x19, 0x20, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, + 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x06, 0x12, 0x04, + 0xc6, 0x01, 0x02, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x01, 0x12, 0x04, 0xc6, + 0x01, 0x0f, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x03, 0x12, 0x04, 0xc6, 0x01, + 0x1a, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x08, 0x12, 0x04, 0xc6, 0x01, 0x1c, + 0x42, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x0b, 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x04, 0xc6, + 0x01, 0x1d, 0x41, 0x0a, 0x2c, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x02, 0x12, 0x04, 0xc9, 0x01, 0x02, + 0x3b, 0x1a, 0x1e, 0x20, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x02, 0x06, 0x12, 0x04, 0xc9, 0x01, 0x02, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x02, 0x01, 0x12, 0x04, 0xc9, 0x01, 0x0b, 0x0f, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x02, 0x03, 0x12, 0x04, 0xc9, 0x01, 0x12, 0x13, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x02, 0x08, 0x12, 0x04, 0xc9, 0x01, 0x14, 0x3a, 0x0a, 0x10, 0x0a, + 0x08, 0x04, 0x0b, 0x02, 0x02, 0x08, 0x87, 0x09, 0x19, 0x12, 0x04, 0xc9, 0x01, 0x15, 0x39, 0x0a, + 0x77, 0x0a, 0x02, 0x04, 0x0c, 0x12, 0x06, 0xcd, 0x01, 0x00, 0xd7, 0x01, 0x01, 0x1a, 0x69, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x20, 0x53, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, + 0x69, 0x6e, 0x20, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x54, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x6e, + 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0c, 0x01, 0x12, + 0x04, 0xcd, 0x01, 0x08, 0x13, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x00, 0x12, 0x06, 0xce, + 0x01, 0x02, 0xd1, 0x01, 0x04, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x05, 0x12, 0x04, + 0xce, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x01, 0x12, 0x04, 0xce, + 0x01, 0x09, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x03, 0x12, 0x04, 0xce, 0x01, + 0x10, 0x11, 0x0a, 0x0f, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x08, 0x12, 0x06, 0xce, 0x01, 0x12, + 0xd1, 0x01, 0x03, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x0c, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, + 0x12, 0x04, 0xcf, 0x01, 0x04, 0x2b, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x0c, 0x02, 0x00, 0x08, 0x87, + 0x09, 0x0e, 0x03, 0x12, 0x04, 0xd0, 0x01, 0x04, 0x2d, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0c, 0x02, + 0x01, 0x12, 0x04, 0xd3, 0x01, 0x02, 0x42, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x06, + 0x12, 0x04, 0xd3, 0x01, 0x02, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x01, 0x12, + 0x04, 0xd3, 0x01, 0x12, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x03, 0x12, 0x04, + 0xd3, 0x01, 0x19, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x08, 0x12, 0x04, 0xd3, + 0x01, 0x1b, 0x41, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x0c, 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, + 0x04, 0xd3, 0x01, 0x1c, 0x40, 0x0a, 0x29, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x02, 0x12, 0x04, 0xd6, + 0x01, 0x02, 0x3b, 0x1a, 0x1b, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x61, + 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x02, 0x06, 0x12, 0x04, 0xd6, 0x01, 0x02, 0x26, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x02, 0x01, 0x12, 0x04, 0xd6, 0x01, 0x27, 0x36, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x02, 0x03, 0x12, 0x04, 0xd6, 0x01, 0x39, 0x3a, 0x0a, 0xd4, 0x01, + 0x0a, 0x02, 0x04, 0x0d, 0x12, 0x06, 0xdb, 0x01, 0x00, 0xe7, 0x01, 0x01, 0x1a, 0xc5, 0x01, 0x20, + 0x54, 0x61, 0x73, 0x6b, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, 0x70, 0x65, 0x63, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x70, 0x79, 0x20, 0x6f, + 0x66, 0x20, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, 0x70, 0x65, 0x63, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x6f, 0x75, 0x74, 0x20, 0x6d, 0x61, 0x6e, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x79, 0x20, + 0x27, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x27, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x73, + 0x75, 0x70, 0x70, 0x6f, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, + 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x6e, 0x20, 0x44, 0x65, 0x70, 0x6c, 0x6f, + 0x79, 0x54, 0x61, 0x73, 0x6b, 0x20, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x20, 0x77, + 0x68, 0x65, 0x72, 0x65, 0x20, 0x27, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x27, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6c, 0x72, 0x65, 0x61, 0x64, 0x79, 0x20, 0x70, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x5f, + 0x69, 0x64, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0d, 0x01, 0x12, 0x04, 0xdb, 0x01, 0x08, + 0x17, 0x0a, 0x29, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x00, 0x12, 0x04, 0xdd, 0x01, 0x02, 0x12, 0x1a, + 0x1b, 0x20, 0x57, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x20, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0d, 0x02, 0x00, 0x05, 0x12, 0x04, 0xdd, 0x01, 0x02, 0x06, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0d, 0x02, 0x00, 0x01, 0x12, 0x04, 0xdd, 0x01, 0x07, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, + 0x02, 0x00, 0x03, 0x12, 0x04, 0xdd, 0x01, 0x10, 0x11, 0x0a, 0x2a, 0x0a, 0x04, 0x04, 0x0d, 0x02, + 0x01, 0x12, 0x04, 0xe0, 0x01, 0x02, 0x14, 0x1a, 0x1c, 0x20, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x65, 0x64, 0x20, 0x74, + 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x06, 0x12, 0x04, + 0xe0, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x01, 0x12, 0x04, 0xe0, + 0x01, 0x09, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x03, 0x12, 0x04, 0xe0, 0x01, + 0x12, 0x13, 0x0a, 0x30, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x02, 0x12, 0x04, 0xe3, 0x01, 0x02, 0x26, + 0x1a, 0x22, 0x20, 0x54, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x65, 0x64, 0x20, 0x74, 0x61, + 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x02, 0x06, 0x12, 0x04, 0xe3, + 0x01, 0x02, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x02, 0x01, 0x12, 0x04, 0xe3, 0x01, + 0x19, 0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x02, 0x03, 0x12, 0x04, 0xe3, 0x01, 0x24, + 0x25, 0x0a, 0x25, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x03, 0x12, 0x04, 0xe6, 0x01, 0x02, 0x19, 0x1a, + 0x17, 0x20, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x64, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x03, + 0x05, 0x12, 0x04, 0xe6, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x03, 0x01, + 0x12, 0x04, 0xe6, 0x01, 0x09, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x03, 0x03, 0x12, + 0x04, 0xe6, 0x01, 0x17, 0x18, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xb6, 0x2c, + 0x0a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, + 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, + 0x61, 0x73, 0x6b, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, + 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, + 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc3, 0x01, 0x0a, 0x11, 0x44, 0x65, 0x70, 0x6c, + 0x6f, 0x79, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3f, 0x0a, + 0x07, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x54, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, + 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x12, 0x34, + 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, + 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x04, + 0x73, 0x70, 0x65, 0x63, 0x12, 0x37, 0x0a, 0x08, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, + 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x52, 0x08, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x22, 0x14, 0x0a, + 0x12, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x58, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x44, 0x65, + 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3f, 0x0a, 0x07, + 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, + 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, + 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x22, 0x4f, 0x0a, + 0x16, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x44, 0x65, + 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0xd3, + 0x02, 0x0a, 0x10, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x37, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x03, + 0x6f, 0x72, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, + 0x10, 0x01, 0x48, 0x00, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x44, 0x0a, 0x0a, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x48, 0x00, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x12, + 0x51, 0x0a, 0x0d, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, + 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x73, 0x6b, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x46, 0x69, + 0x6c, 0x74, 0x65, 0x72, 0x52, 0x0c, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x46, 0x69, 0x6c, 0x74, 0x65, + 0x72, 0x73, 0x1a, 0x3d, 0x0a, 0x0b, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x46, 0x69, 0x6c, 0x74, 0x65, + 0x72, 0x12, 0x21, 0x0a, 0x0b, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x5f, 0x62, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, + 0x65, 0x64, 0x42, 0x79, 0x42, 0x0b, 0x0a, 0x09, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x62, + 0x79, 0x42, 0x11, 0x0a, 0x08, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x5f, 0x62, 0x79, 0x12, 0x05, 0xba, + 0x48, 0x02, 0x08, 0x01, 0x22, 0xf8, 0x01, 0x0a, 0x11, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x73, + 0x6b, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x05, 0x74, 0x61, + 0x73, 0x6b, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x52, + 0x05, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x4f, 0x0a, 0x08, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x33, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x50, 0x0a, + 0x11, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x05, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x12, 0x25, 0x0a, 0x0e, 0x66, 0x69, 0x6c, 0x74, + 0x65, 0x72, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, + 0x52, 0x0d, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x65, 0x64, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x22, + 0x8d, 0x01, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x37, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4c, 0x69, 0x73, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x3d, 0x0a, 0x09, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x42, 0x06, 0xba, + 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x74, 0x61, 0x73, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x22, + 0xf0, 0x01, 0x0a, 0x14, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x50, 0x0a, 0x08, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4c, 0x69, 0x73, 0x74, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x52, 0x08, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, + 0x1a, 0x70, 0x0a, 0x0f, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x43, 0x0a, + 0x0b, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x06, + 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, + 0x41, 0x74, 0x32, 0x81, 0x03, 0x0a, 0x0b, 0x54, 0x61, 0x73, 0x6b, 0x53, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x12, 0x55, 0x0a, 0x0a, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x54, 0x61, 0x73, 0x6b, + 0x12, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, + 0x6b, 0x2e, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x54, 0x61, 0x73, 0x6b, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x64, 0x0a, 0x0e, 0x47, 0x65, 0x74, + 0x54, 0x61, 0x73, 0x6b, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x25, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x47, 0x65, 0x74, + 0x54, 0x61, 0x73, 0x6b, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, + 0x61, 0x73, 0x6b, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x44, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, + 0x55, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x12, 0x20, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4c, 0x69, + 0x73, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x4c, 0x69, 0x73, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x5e, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4c, 0x69, 0x73, + 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x42, 0xb3, 0x01, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x42, 0x10, 0x54, + 0x61, 0x73, 0x6b, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, + 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, + 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2f, 0x74, 0x61, 0x73, 0x6b, 0xa2, 0x02, 0x03, 0x46, 0x54, 0x58, 0xaa, 0x02, 0x0e, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0xca, 0x02, 0x0e, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x61, 0x73, 0x6b, 0xe2, 0x02, 0x1a, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x61, 0x73, 0x6b, 0x5c, 0x47, + 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0f, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x54, 0x61, 0x73, 0x6b, 0x4a, 0xbf, 0x1b, 0x0a, + 0x06, 0x12, 0x04, 0x00, 0x00, 0x7e, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, + 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x17, 0x0a, 0x09, 0x0a, 0x02, 0x03, + 0x00, 0x12, 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, + 0x2b, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, + 0x03, 0x03, 0x12, 0x03, 0x07, 0x00, 0x2e, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x04, 0x12, 0x03, 0x08, + 0x00, 0x29, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x0a, 0x00, 0x49, 0x0a, 0x09, 0x0a, 0x02, + 0x08, 0x0b, 0x12, 0x03, 0x0a, 0x00, 0x49, 0x0a, 0x43, 0x0a, 0x02, 0x06, 0x00, 0x12, 0x04, 0x0d, + 0x00, 0x1f, 0x01, 0x1a, 0x37, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, + 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6d, 0x61, 0x6e, 0x61, + 0x67, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x06, 0x00, 0x01, 0x12, 0x03, 0x0d, 0x08, 0x13, 0x0a, 0x1d, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x00, + 0x12, 0x03, 0x0f, 0x02, 0x43, 0x1a, 0x10, 0x20, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x20, 0x61, + 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x0f, 0x06, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, + 0x0f, 0x11, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0f, 0x2d, + 0x3f, 0x0a, 0x36, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x01, 0x12, 0x04, 0x12, 0x02, 0x14, 0x03, 0x1a, + 0x28, 0x20, 0x47, 0x65, 0x74, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x69, + 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, + 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x12, 0x06, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x02, + 0x12, 0x03, 0x12, 0x15, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x12, 0x35, 0x4b, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x04, 0x12, 0x03, 0x13, 0x04, + 0x2f, 0x0a, 0x0d, 0x0a, 0x06, 0x06, 0x00, 0x02, 0x01, 0x04, 0x22, 0x12, 0x03, 0x13, 0x04, 0x2f, + 0x0a, 0x68, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x02, 0x12, 0x04, 0x17, 0x02, 0x19, 0x03, 0x1a, 0x5a, + 0x20, 0x4c, 0x69, 0x73, 0x74, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2c, 0x20, 0x6f, 0x6e, + 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2c, + 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, + 0x61, 0x74, 0x65, 0x73, 0x74, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x77, 0x68, 0x6f, 0x20, 0x69, 0x74, 0x20, 0x77, 0x61, 0x73, 0x20, 0x64, 0x65, 0x70, + 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x20, 0x62, 0x79, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x17, 0x06, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, + 0x02, 0x12, 0x03, 0x17, 0x10, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x03, 0x12, + 0x03, 0x17, 0x2b, 0x3c, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x04, 0x12, 0x03, 0x18, + 0x04, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, 0x06, 0x00, 0x02, 0x02, 0x04, 0x22, 0x12, 0x03, 0x18, 0x04, + 0x2f, 0x0a, 0x2e, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x03, 0x12, 0x04, 0x1c, 0x02, 0x1e, 0x03, 0x1a, + 0x20, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x1c, 0x06, 0x12, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x1c, 0x13, 0x26, 0x0a, 0x0c, 0x0a, + 0x05, 0x06, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x1c, 0x31, 0x45, 0x0a, 0x0c, 0x0a, 0x05, 0x06, + 0x00, 0x02, 0x03, 0x04, 0x12, 0x03, 0x1d, 0x04, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, 0x06, 0x00, 0x02, + 0x03, 0x04, 0x22, 0x12, 0x03, 0x1d, 0x04, 0x2f, 0x0a, 0x33, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, + 0x22, 0x00, 0x2b, 0x01, 0x1a, 0x27, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x70, 0x6c, 0x6f, + 0x79, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x22, 0x08, 0x19, 0x0a, 0x29, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x00, 0x12, 0x03, 0x24, 0x02, 0x44, 0x1a, 0x1c, 0x20, 0x54, 0x68, 0x65, 0x20, 0x75, 0x73, 0x65, + 0x72, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, + 0x69, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x24, + 0x02, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x24, 0x11, 0x18, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x24, 0x1b, 0x1c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x08, 0x12, 0x03, 0x24, 0x1d, 0x43, 0x0a, 0x0f, 0x0a, 0x08, + 0x04, 0x00, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x24, 0x1e, 0x42, 0x0a, 0x2a, 0x0a, + 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x27, 0x02, 0x3b, 0x1a, 0x1d, 0x20, 0x53, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x01, 0x06, 0x12, 0x03, 0x27, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x27, 0x0b, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x27, 0x12, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x08, 0x12, 0x03, 0x27, 0x14, + 0x3a, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x27, + 0x15, 0x39, 0x0a, 0x6d, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x2a, 0x02, 0x24, 0x1a, + 0x60, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2c, 0x20, 0x73, 0x65, 0x74, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x20, 0x52, 0x65, + 0x70, 0x6c, 0x61, 0x63, 0x65, 0x73, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, + 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x20, + 0x65, 0x6e, 0x74, 0x69, 0x72, 0x65, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x61, 0x6e, 0x79, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x04, 0x12, 0x03, 0x2a, 0x02, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x2a, 0x0b, 0x16, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x2a, 0x17, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x2a, 0x22, 0x23, 0x0a, 0x33, 0x0a, 0x02, 0x04, 0x01, 0x12, + 0x03, 0x2e, 0x00, 0x1d, 0x1a, 0x28, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x70, 0x6c, + 0x6f, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x2e, 0x08, 0x1a, 0x0a, 0x4c, 0x0a, 0x02, 0x04, 0x02, + 0x12, 0x04, 0x31, 0x00, 0x34, 0x01, 0x1a, 0x40, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x67, 0x65, 0x74, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, + 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, + 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, + 0x03, 0x31, 0x08, 0x1d, 0x0a, 0x1e, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x33, 0x02, + 0x44, 0x1a, 0x11, 0x20, 0x49, 0x64, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, + 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, 0x03, 0x33, + 0x02, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x33, 0x11, 0x18, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x33, 0x1b, 0x1c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x08, 0x12, 0x03, 0x33, 0x1d, 0x43, 0x0a, 0x0f, 0x0a, 0x08, + 0x04, 0x02, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x33, 0x1e, 0x42, 0x0a, 0x34, 0x0a, + 0x02, 0x04, 0x03, 0x12, 0x04, 0x37, 0x00, 0x3a, 0x01, 0x1a, 0x28, 0x20, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, + 0x6b, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x37, 0x08, 0x1e, 0x0a, + 0x33, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x39, 0x02, 0x1a, 0x1a, 0x26, 0x20, 0x44, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, + 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x39, + 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x39, 0x0e, 0x15, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x39, 0x18, 0x19, 0x0a, 0x0a, + 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x3c, 0x00, 0x53, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, + 0x01, 0x12, 0x03, 0x3c, 0x08, 0x18, 0x0a, 0x2e, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, + 0x3e, 0x02, 0x21, 0x1a, 0x21, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x6c, 0x69, 0x73, + 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, + 0x74, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x3e, 0x02, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x3e, + 0x15, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x3e, 0x1f, 0x20, + 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x04, 0x08, 0x00, 0x12, 0x04, 0x40, 0x02, 0x48, 0x03, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x08, 0x00, 0x01, 0x12, 0x03, 0x40, 0x08, 0x10, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x08, 0x00, 0x02, 0x12, 0x03, 0x41, 0x04, 0x30, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x04, + 0x08, 0x00, 0x02, 0x87, 0x09, 0x01, 0x12, 0x03, 0x41, 0x04, 0x30, 0x0a, 0x2f, 0x0a, 0x04, 0x04, + 0x04, 0x02, 0x01, 0x12, 0x03, 0x44, 0x04, 0x3d, 0x1a, 0x22, 0x20, 0x4f, 0x72, 0x67, 0x61, 0x6e, + 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x01, 0x05, 0x12, 0x03, 0x44, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x44, 0x0b, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x44, 0x11, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x08, 0x12, + 0x03, 0x44, 0x13, 0x3c, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x04, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, + 0x02, 0x12, 0x03, 0x44, 0x14, 0x3b, 0x0a, 0x30, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x02, 0x12, 0x03, + 0x47, 0x04, 0x2c, 0x1a, 0x23, 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x69, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x69, 0x6c, + 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, + 0x06, 0x12, 0x03, 0x47, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x47, 0x1d, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, 0x47, + 0x2a, 0x2b, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x04, 0x03, 0x00, 0x12, 0x04, 0x4a, 0x02, 0x4f, 0x03, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x03, 0x00, 0x01, 0x12, 0x03, 0x4a, 0x0a, 0x15, 0x0a, 0x0e, + 0x0a, 0x06, 0x04, 0x04, 0x03, 0x00, 0x08, 0x00, 0x12, 0x04, 0x4b, 0x04, 0x4e, 0x05, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x04, 0x03, 0x00, 0x08, 0x00, 0x01, 0x12, 0x03, 0x4b, 0x0a, 0x13, 0x0a, 0x1f, + 0x0a, 0x06, 0x04, 0x04, 0x03, 0x00, 0x02, 0x00, 0x12, 0x03, 0x4d, 0x06, 0x1d, 0x1a, 0x10, 0x20, + 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x62, 0x79, 0x20, 0x75, 0x73, 0x65, 0x72, 0x0a, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x03, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x4d, 0x06, 0x0c, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x4d, 0x0d, 0x18, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x4d, 0x1b, 0x1c, 0x0a, + 0x2f, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x03, 0x12, 0x03, 0x52, 0x02, 0x29, 0x1a, 0x22, 0x20, 0x4b, + 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x6c, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x04, 0x12, 0x03, 0x52, 0x02, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x06, 0x12, 0x03, 0x52, 0x0b, 0x16, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x03, 0x01, 0x12, 0x03, 0x52, 0x17, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x03, 0x03, 0x12, 0x03, 0x52, 0x27, 0x28, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, + 0x55, 0x00, 0x65, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x55, 0x08, 0x19, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x56, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x00, 0x04, 0x12, 0x03, 0x56, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x00, 0x06, 0x12, 0x03, 0x56, 0x0b, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x56, 0x10, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x56, 0x18, 0x19, 0x0a, 0x3b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x03, 0x59, + 0x02, 0x13, 0x1a, 0x2e, 0x20, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, + 0x78, 0x74, 0x20, 0x70, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x73, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x05, 0x12, 0x03, 0x59, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, 0x12, 0x03, 0x59, 0x09, 0x0e, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x03, 0x59, 0x11, 0x12, 0x0a, 0x0c, 0x0a, 0x04, + 0x04, 0x05, 0x03, 0x00, 0x12, 0x04, 0x5b, 0x02, 0x61, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x03, 0x00, 0x01, 0x12, 0x03, 0x5b, 0x0a, 0x1b, 0x0a, 0x3e, 0x0a, 0x06, 0x04, 0x05, 0x03, 0x00, + 0x02, 0x00, 0x12, 0x03, 0x5d, 0x04, 0x15, 0x1a, 0x2f, 0x20, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x20, + 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x6f, 0x75, 0x74, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x20, + 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x05, 0x03, 0x00, + 0x02, 0x00, 0x05, 0x12, 0x03, 0x5d, 0x04, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x05, 0x03, 0x00, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x5d, 0x0b, 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x05, 0x03, 0x00, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x5d, 0x13, 0x14, 0x0a, 0x44, 0x0a, 0x06, 0x04, 0x05, 0x03, 0x00, + 0x02, 0x01, 0x12, 0x03, 0x60, 0x04, 0x1e, 0x1a, 0x35, 0x20, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x20, + 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x20, + 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, + 0x6c, 0x69, 0x65, 0x64, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x05, 0x03, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x60, 0x04, 0x0a, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x05, 0x03, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x60, 0x0b, 0x19, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x05, 0x03, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x60, 0x1c, 0x1d, 0x0a, 0x31, + 0x0a, 0x04, 0x04, 0x05, 0x02, 0x02, 0x12, 0x03, 0x64, 0x02, 0x21, 0x1a, 0x24, 0x20, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4c, + 0x69, 0x73, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x06, 0x12, 0x03, 0x64, 0x02, 0x13, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x01, 0x12, 0x03, 0x64, 0x14, 0x1c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x02, 0x03, 0x12, 0x03, 0x64, 0x1f, 0x20, 0x0a, 0x3e, 0x0a, 0x02, 0x04, + 0x06, 0x12, 0x04, 0x68, 0x00, 0x6e, 0x01, 0x1a, 0x32, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6c, 0x69, + 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x06, 0x01, 0x12, 0x03, 0x68, 0x08, 0x1b, 0x0a, 0x2e, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, + 0x03, 0x6a, 0x02, 0x21, 0x1a, 0x21, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x6c, 0x69, + 0x73, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, + 0x65, 0x74, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x6a, 0x02, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x6a, 0x15, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x03, 0x6a, 0x1f, + 0x20, 0x0a, 0x1e, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x01, 0x12, 0x03, 0x6d, 0x02, 0x40, 0x1a, 0x11, + 0x20, 0x49, 0x64, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x06, 0x12, 0x03, 0x6d, 0x02, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x01, 0x12, 0x03, 0x6d, 0x0b, 0x14, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x01, 0x03, 0x12, 0x03, 0x6d, 0x17, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x01, 0x08, 0x12, 0x03, 0x6d, 0x19, 0x3f, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x06, 0x02, + 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x6d, 0x1a, 0x3e, 0x0a, 0x34, 0x0a, 0x02, 0x04, 0x07, + 0x12, 0x04, 0x71, 0x00, 0x7e, 0x01, 0x1a, 0x28, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6c, 0x69, + 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x03, 0x71, 0x08, 0x1c, 0x0a, 0x0c, 0x0a, 0x04, + 0x04, 0x07, 0x03, 0x00, 0x12, 0x04, 0x72, 0x02, 0x77, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, + 0x03, 0x00, 0x01, 0x12, 0x03, 0x72, 0x0a, 0x19, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x07, 0x03, 0x00, + 0x02, 0x00, 0x12, 0x03, 0x73, 0x04, 0x17, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x07, 0x03, 0x00, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x73, 0x04, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x07, 0x03, 0x00, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x73, 0x0b, 0x12, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x07, 0x03, 0x00, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x73, 0x15, 0x16, 0x0a, 0x37, 0x0a, 0x06, 0x04, 0x07, 0x03, 0x00, 0x02, + 0x01, 0x12, 0x03, 0x76, 0x04, 0x55, 0x1a, 0x28, 0x20, 0x54, 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x20, 0x77, 0x61, 0x73, 0x20, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x0a, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x07, 0x03, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x76, 0x04, 0x1d, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x07, 0x03, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x76, 0x1e, 0x29, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x07, 0x03, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x76, 0x2c, 0x2d, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x07, 0x03, 0x00, 0x02, 0x01, 0x08, 0x12, 0x03, 0x76, 0x2e, 0x54, + 0x0a, 0x11, 0x0a, 0x0a, 0x04, 0x07, 0x03, 0x00, 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, + 0x76, 0x2f, 0x53, 0x0a, 0x27, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x03, 0x7a, 0x02, 0x28, + 0x1a, 0x1a, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x00, 0x04, 0x12, 0x03, 0x7a, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x00, 0x06, 0x12, 0x03, 0x7a, 0x0b, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x7a, 0x1b, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x7a, 0x26, 0x27, 0x0a, 0x3e, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x01, 0x12, 0x03, 0x7d, 0x02, + 0x13, 0x1a, 0x31, 0x20, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, + 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x78, + 0x74, 0x20, 0x70, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x05, 0x12, 0x03, 0x7d, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x01, 0x12, 0x03, 0x7d, 0x09, 0x0e, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, 0x03, 0x7d, 0x11, 0x12, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +]; +include!("flyteidl2.task.tonic.rs"); +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/flyteidl2.task.tonic.rs b/gen/rust/src/flyteidl2.task.tonic.rs new file mode 100644 index 0000000000..1666ea61bf --- /dev/null +++ b/gen/rust/src/flyteidl2.task.tonic.rs @@ -0,0 +1,514 @@ +// @generated +/// Generated client implementations. +pub mod task_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct TaskServiceClient { + inner: tonic::client::Grpc, + } + impl TaskServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl TaskServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> TaskServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + TaskServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + pub async fn deploy_task( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.task.TaskService/DeployTask", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.task.TaskService", "DeployTask")); + self.inner.unary(req, path, codec).await + } + pub async fn get_task_details( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.task.TaskService/GetTaskDetails", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.task.TaskService", "GetTaskDetails")); + self.inner.unary(req, path, codec).await + } + pub async fn list_tasks( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.task.TaskService/ListTasks", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.task.TaskService", "ListTasks")); + self.inner.unary(req, path, codec).await + } + pub async fn list_versions( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.task.TaskService/ListVersions", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.task.TaskService", "ListVersions")); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod task_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with TaskServiceServer. + #[async_trait] + pub trait TaskService: Send + Sync + 'static { + async fn deploy_task( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn get_task_details( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn list_tasks( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn list_versions( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + #[derive(Debug)] + pub struct TaskServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl TaskServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for TaskServiceServer + where + T: TaskService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.task.TaskService/DeployTask" => { + #[allow(non_camel_case_types)] + struct DeployTaskSvc(pub Arc); + impl< + T: TaskService, + > tonic::server::UnaryService + for DeployTaskSvc { + type Response = super::DeployTaskResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::deploy_task(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = DeployTaskSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.task.TaskService/GetTaskDetails" => { + #[allow(non_camel_case_types)] + struct GetTaskDetailsSvc(pub Arc); + impl< + T: TaskService, + > tonic::server::UnaryService + for GetTaskDetailsSvc { + type Response = super::GetTaskDetailsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_task_details(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetTaskDetailsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.task.TaskService/ListTasks" => { + #[allow(non_camel_case_types)] + struct ListTasksSvc(pub Arc); + impl< + T: TaskService, + > tonic::server::UnaryService + for ListTasksSvc { + type Response = super::ListTasksResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::list_tasks(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ListTasksSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.task.TaskService/ListVersions" => { + #[allow(non_camel_case_types)] + struct ListVersionsSvc(pub Arc); + impl< + T: TaskService, + > tonic::server::UnaryService + for ListVersionsSvc { + type Response = super::ListVersionsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::list_versions(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ListVersionsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for TaskServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService for TaskServiceServer { + const NAME: &'static str = "flyteidl2.task.TaskService"; + } +} diff --git a/gen/rust/src/flyteidl2.trigger.rs b/gen/rust/src/flyteidl2.trigger.rs new file mode 100644 index 0000000000..885719f3da --- /dev/null +++ b/gen/rust/src/flyteidl2.trigger.rs @@ -0,0 +1,1144 @@ +// @generated +// This file is @generated by prost-build. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TriggerMetadata { + /// Identity that last deployed the trigger + #[prost(message, optional, tag="1")] + pub deployed_by: ::core::option::Option, + /// Identity that last activated or deactivated the trigger + #[prost(message, optional, tag="2")] + pub updated_by: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TriggerSpec { + /// Inputs for triggered task. + #[prost(message, optional, tag="2")] + pub inputs: ::core::option::Option, + /// The run spec for triggered task. + #[prost(message, optional, tag="3")] + pub run_spec: ::core::option::Option, + /// Whether trigger is active + #[prost(bool, tag="4")] + pub active: bool, + /// Task version together with trigger name will give us the unique task id + #[prost(string, tag="5")] + pub task_version: ::prost::alloc::string::String, + /// Optional description + #[prost(string, tag="6")] + pub description: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct TriggerStatus { + /// The first time trigger was deployed. + #[prost(message, optional, tag="1")] + pub deployed_at: ::core::option::Option, + /// The last time the trigger was updated. + #[prost(message, optional, tag="2")] + pub updated_at: ::core::option::Option, + /// The last time the trigger fired. + #[prost(message, optional, tag="3")] + pub triggered_at: ::core::option::Option, + /// The time trigger was deleted. + #[prost(message, optional, tag="4")] + pub deleted_at: ::core::option::Option, +} +/// Light-weight information about a single trigger revision +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TriggerRevision { + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub metadata: ::core::option::Option, + #[prost(message, optional, tag="3")] + pub status: ::core::option::Option, + #[prost(enumeration="TriggerRevisionAction", tag="4")] + pub action: i32, + /// Timestamp at which given revision was created. + #[prost(message, optional, tag="5")] + pub created_at: ::core::option::Option, +} +/// Full details about a trigger stored in DB +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TriggerDetails { + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub metadata: ::core::option::Option, + #[prost(message, optional, tag="3")] + pub spec: ::core::option::Option, + #[prost(message, optional, tag="4")] + pub status: ::core::option::Option, + /// Optional automation spec. + #[prost(message, optional, tag="5")] + pub automation_spec: ::core::option::Option, + /// Trigger description + #[prost(string, optional, tag="6")] + pub description: ::core::option::Option<::prost::alloc::string::String>, +} +/// Light-weight information about trigger for a list view +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Trigger { + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub metadata: ::core::option::Option, + #[prost(message, optional, tag="3")] + pub status: ::core::option::Option, + #[prost(bool, tag="5")] + pub active: bool, + #[prost(message, optional, tag="6")] + pub automation_spec: ::core::option::Option, +} +/// Stores human- and machine-friendly explanation of what changed in the revision +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum TriggerRevisionAction { + Unspecified = 0, + Deploy = 1, + Activate = 2, + Deactivate = 3, + Delete = 4, +} +impl TriggerRevisionAction { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + TriggerRevisionAction::Unspecified => "TRIGGER_REVISION_ACTION_UNSPECIFIED", + TriggerRevisionAction::Deploy => "TRIGGER_REVISION_ACTION_DEPLOY", + TriggerRevisionAction::Activate => "TRIGGER_REVISION_ACTION_ACTIVATE", + TriggerRevisionAction::Deactivate => "TRIGGER_REVISION_ACTION_DEACTIVATE", + TriggerRevisionAction::Delete => "TRIGGER_REVISION_ACTION_DELETE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "TRIGGER_REVISION_ACTION_UNSPECIFIED" => Some(Self::Unspecified), + "TRIGGER_REVISION_ACTION_DEPLOY" => Some(Self::Deploy), + "TRIGGER_REVISION_ACTION_ACTIVATE" => Some(Self::Activate), + "TRIGGER_REVISION_ACTION_DEACTIVATE" => Some(Self::Deactivate), + "TRIGGER_REVISION_ACTION_DELETE" => Some(Self::Delete), + _ => None, + } + } +} +/// Request message for saving a trigger. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DeployTriggerRequest { + #[prost(message, optional, tag="4")] + pub name: ::core::option::Option, + /// Revision of the trigger. + /// Optional for the initial deploy of the trigger. + /// Mandatory for updating existing trigger and should store latest previously deployed revision. + #[prost(uint64, tag="5")] + pub revision: u64, + #[prost(message, optional, tag="2")] + pub spec: ::core::option::Option, + /// Optional automation spec. + #[prost(message, optional, tag="3")] + pub automation_spec: ::core::option::Option, +} +/// Response message for saving a trigger. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DeployTriggerResponse { + #[prost(message, optional, tag="1")] + pub trigger: ::core::option::Option, +} +/// Request message for saving a trigger. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTriggerDetailsRequest { + #[prost(message, optional, tag="1")] + pub name: ::core::option::Option, +} +/// Response message for saving a trigger. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTriggerDetailsResponse { + #[prost(message, optional, tag="1")] + pub trigger: ::core::option::Option, +} +/// Request message for saving a trigger. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTriggerRevisionDetailsRequest { + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, +} +/// Response message for saving a trigger. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTriggerRevisionDetailsResponse { + #[prost(message, optional, tag="1")] + pub trigger: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListTriggersRequest { + /// Common list request parameters. + #[prost(message, optional, tag="1")] + pub request: ::core::option::Option, + #[prost(oneof="list_triggers_request::ScopeBy", tags="2, 3, 4, 5")] + pub scope_by: ::core::option::Option, +} +/// Nested message and enum types in `ListTriggersRequest`. +pub mod list_triggers_request { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum ScopeBy { + /// Organization name for filtering. + #[prost(string, tag="2")] + Org(::prost::alloc::string::String), + /// Project identifier for filtering. + #[prost(message, tag="3")] + ProjectId(super::super::common::ProjectIdentifier), + /// List all triggers attached to a given version of a task . + #[prost(message, tag="4")] + TaskId(super::super::task::TaskIdentifier), + /// List all triggers attached to a given task. + #[prost(message, tag="5")] + TaskName(super::super::task::TaskName), + } +} +/// Response message for listing triggers. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListTriggersResponse { + /// List of triggers matching the filter criteria. + #[prost(message, repeated, tag="1")] + pub triggers: ::prost::alloc::vec::Vec, + /// Token for fetching the next page of results, if any. + #[prost(string, tag="2")] + pub token: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTriggerRevisionHistoryRequest { + #[prost(message, optional, tag="1")] + pub request: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub name: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTriggerRevisionHistoryResponse { + /// List of triggers matching the filter criteria. + #[prost(message, repeated, tag="1")] + pub triggers: ::prost::alloc::vec::Vec, + /// Token for fetching the next page of results, if any. + #[prost(string, tag="2")] + pub token: ::prost::alloc::string::String, +} +/// Request message for updating some trigger spec fields for multiple triggers +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UpdateTriggersRequest { + #[prost(message, repeated, tag="1")] + pub names: ::prost::alloc::vec::Vec, + #[prost(bool, tag="2")] + pub active: bool, +} +/// Response message for updating some trigger spec fields for multiple triggers +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct UpdateTriggersResponse { +} +/// Request message for activating or deactivating multiple triggers +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DeleteTriggersRequest { + #[prost(message, repeated, tag="1")] + pub names: ::prost::alloc::vec::Vec, +} +/// Response message for activating or deactivating multiple triggers. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct DeleteTriggersResponse { +} +/// Encoded file descriptor set for the `flyteidl2.trigger` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xa2, 0x2b, 0x0a, 0x2a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2f, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x5f, 0x64, + 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, + 0x11, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, + 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, + 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, + 0x61, 0x73, 0x6b, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x18, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, + 0x2f, 0x72, 0x75, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa9, 0x01, 0x0a, 0x0f, + 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, + 0x4b, 0x0a, 0x0b, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, + 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, + 0x52, 0x0a, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x42, 0x79, 0x12, 0x49, 0x0a, 0x0a, + 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x09, 0x75, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x64, 0x42, 0x79, 0x22, 0xdf, 0x01, 0x0a, 0x0b, 0x54, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x53, 0x70, 0x65, 0x63, 0x12, 0x2e, 0x0a, 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, + 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x52, + 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x12, 0x32, 0x0a, 0x08, 0x72, 0x75, 0x6e, 0x5f, 0x73, + 0x70, 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x52, 0x75, 0x6e, 0x53, 0x70, + 0x65, 0x63, 0x52, 0x07, 0x72, 0x75, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x12, 0x16, 0x0a, 0x06, 0x61, + 0x63, 0x74, 0x69, 0x76, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x61, 0x63, 0x74, + 0x69, 0x76, 0x65, 0x12, 0x2c, 0x0a, 0x0c, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x42, 0x09, 0xba, 0x48, 0x06, 0x72, 0x04, + 0x10, 0x01, 0x18, 0x3f, 0x52, 0x0b, 0x74, 0x61, 0x73, 0x6b, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x4a, 0x04, 0x08, 0x01, 0x10, 0x02, 0x22, 0x91, 0x02, 0x0a, 0x0d, 0x54, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x43, 0x0a, 0x0b, 0x64, + 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x06, 0xba, 0x48, + 0x03, 0xc8, 0x01, 0x01, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x41, 0x74, + 0x12, 0x41, 0x0a, 0x0a, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x09, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x64, 0x41, 0x74, 0x12, 0x3d, 0x0a, 0x0c, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x65, 0x64, + 0x5f, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0b, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x65, 0x64, + 0x41, 0x74, 0x12, 0x39, 0x0a, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x52, 0x09, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x41, 0x74, 0x22, 0xbd, 0x02, + 0x0a, 0x0f, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, + 0x6e, 0x12, 0x33, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3e, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x38, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x12, 0x40, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, + 0x73, 0x69, 0x6f, 0x6e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x22, 0x94, 0x03, + 0x0a, 0x0e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x12, 0x3b, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3e, 0x0a, + 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x3a, 0x0a, + 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, + 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, 0x70, 0x65, 0x63, 0x42, 0x06, 0xba, 0x48, 0x03, + 0xc8, 0x01, 0x01, 0x52, 0x04, 0x73, 0x70, 0x65, 0x63, 0x12, 0x38, 0x0a, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x12, 0x4e, 0x0a, 0x0f, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x41, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, + 0x70, 0x65, 0x63, 0x52, 0x0e, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, + 0x70, 0x65, 0x63, 0x12, 0x2f, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x42, 0x08, 0xba, 0x48, 0x05, 0x72, 0x03, 0x18, + 0xff, 0x01, 0x48, 0x00, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x88, 0x01, 0x01, 0x42, 0x0e, 0x0a, 0x0c, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xa6, 0x02, 0x0a, 0x07, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x12, 0x33, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3e, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x38, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, + 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x12, 0x4e, 0x0a, 0x0f, 0x61, 0x75, 0x74, 0x6f, 0x6d, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, + 0x6b, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x41, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0e, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x2a, 0xd6, 0x01, + 0x0a, 0x15, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, + 0x6e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x27, 0x0a, 0x23, 0x54, 0x52, 0x49, 0x47, 0x47, + 0x45, 0x52, 0x5f, 0x52, 0x45, 0x56, 0x49, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x43, 0x54, 0x49, + 0x4f, 0x4e, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, + 0x12, 0x22, 0x0a, 0x1e, 0x54, 0x52, 0x49, 0x47, 0x47, 0x45, 0x52, 0x5f, 0x52, 0x45, 0x56, 0x49, + 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x50, 0x4c, + 0x4f, 0x59, 0x10, 0x01, 0x12, 0x24, 0x0a, 0x20, 0x54, 0x52, 0x49, 0x47, 0x47, 0x45, 0x52, 0x5f, + 0x52, 0x45, 0x56, 0x49, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, + 0x41, 0x43, 0x54, 0x49, 0x56, 0x41, 0x54, 0x45, 0x10, 0x02, 0x12, 0x26, 0x0a, 0x22, 0x54, 0x52, + 0x49, 0x47, 0x47, 0x45, 0x52, 0x5f, 0x52, 0x45, 0x56, 0x49, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x41, + 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x41, 0x43, 0x54, 0x49, 0x56, 0x41, 0x54, 0x45, + 0x10, 0x03, 0x12, 0x22, 0x0a, 0x1e, 0x54, 0x52, 0x49, 0x47, 0x47, 0x45, 0x52, 0x5f, 0x52, 0x45, + 0x56, 0x49, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x45, + 0x4c, 0x45, 0x54, 0x45, 0x10, 0x04, 0x42, 0xcb, 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x42, 0x16, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, + 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0xa2, 0x02, 0x03, 0x46, 0x54, 0x58, 0xaa, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0xca, 0x02, 0x11, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0xe2, + 0x02, 0x1d, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, + 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x4a, 0xd6, 0x18, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x6e, 0x01, 0x0a, + 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, + 0x02, 0x00, 0x1a, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, + 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x2b, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, + 0x03, 0x06, 0x00, 0x29, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x03, 0x12, 0x03, 0x07, 0x00, 0x25, 0x0a, + 0x09, 0x0a, 0x02, 0x03, 0x04, 0x12, 0x03, 0x08, 0x00, 0x22, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x05, + 0x12, 0x03, 0x09, 0x00, 0x29, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x0b, 0x00, 0x4c, 0x0a, + 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x0b, 0x00, 0x4c, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, + 0x12, 0x04, 0x0d, 0x00, 0x13, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0d, + 0x08, 0x17, 0x0a, 0x36, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0f, 0x02, 0x51, 0x1a, + 0x29, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x6c, 0x61, 0x73, 0x74, 0x20, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x06, 0x12, 0x03, 0x0f, 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x0f, 0x1a, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x0f, 0x28, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x08, 0x12, 0x03, 0x0f, + 0x2a, 0x50, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, + 0x0f, 0x2b, 0x4f, 0x0a, 0x46, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x12, 0x02, 0x50, + 0x1a, 0x39, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x6c, 0x61, 0x73, 0x74, 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x64, 0x20, + 0x6f, 0x72, 0x20, 0x64, 0x65, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x12, 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x12, 0x1a, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x12, 0x27, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x08, 0x12, 0x03, + 0x12, 0x29, 0x4f, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, + 0x03, 0x12, 0x2a, 0x4e, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x15, 0x00, 0x29, 0x01, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x15, 0x08, 0x13, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x01, 0x09, 0x12, 0x03, 0x16, 0x02, 0x0d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x09, 0x00, + 0x12, 0x03, 0x16, 0x0b, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x09, 0x00, 0x01, 0x12, 0x03, + 0x16, 0x0b, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x09, 0x00, 0x02, 0x12, 0x03, 0x16, 0x0b, + 0x0c, 0x0a, 0x29, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x19, 0x02, 0x23, 0x1a, 0x1c, + 0x20, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x65, 0x64, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x19, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x19, 0x18, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x19, 0x21, 0x22, 0x0a, 0x2f, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, + 0x1c, 0x02, 0x26, 0x1a, 0x22, 0x20, 0x54, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x65, 0x64, + 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x06, + 0x12, 0x03, 0x1c, 0x02, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x1c, 0x19, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x1c, 0x24, + 0x25, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x1f, 0x02, 0x12, 0x1a, 0x1b, + 0x20, 0x57, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x20, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x02, 0x05, 0x12, 0x03, 0x1f, 0x02, 0x06, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x1f, 0x07, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x1f, 0x10, 0x11, 0x0a, 0x57, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x03, 0x12, 0x04, 0x22, + 0x02, 0x25, 0x04, 0x1a, 0x49, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x67, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x77, 0x69, + 0x6c, 0x6c, 0x20, 0x67, 0x69, 0x76, 0x65, 0x20, 0x75, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, + 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x69, 0x64, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x05, 0x12, 0x03, 0x22, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x03, 0x01, 0x12, 0x03, 0x22, 0x09, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x03, 0x03, 0x12, 0x03, 0x22, 0x18, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, + 0x08, 0x12, 0x04, 0x22, 0x1a, 0x25, 0x03, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x01, 0x02, 0x03, 0x08, + 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x23, 0x04, 0x2b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x01, 0x02, + 0x03, 0x08, 0x87, 0x09, 0x0e, 0x03, 0x12, 0x03, 0x24, 0x04, 0x2c, 0x0a, 0x24, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x04, 0x12, 0x03, 0x28, 0x02, 0x19, 0x1a, 0x17, 0x20, 0x20, 0x4f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x05, 0x12, 0x03, 0x28, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x01, 0x12, 0x03, 0x28, 0x09, 0x14, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x04, 0x03, 0x12, 0x03, 0x28, 0x17, 0x18, 0x0a, 0x0a, 0x0a, 0x02, 0x04, + 0x02, 0x12, 0x04, 0x2b, 0x00, 0x37, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, + 0x2b, 0x08, 0x15, 0x0a, 0x33, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x2d, 0x02, 0x53, + 0x1a, 0x26, 0x20, 0x54, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x74, 0x69, 0x6d, + 0x65, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x77, 0x61, 0x73, 0x20, 0x64, 0x65, + 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, + 0x06, 0x12, 0x03, 0x2d, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x2d, 0x1c, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x2d, + 0x2a, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x08, 0x12, 0x03, 0x2d, 0x2c, 0x52, + 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x02, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x2d, 0x2d, + 0x51, 0x0a, 0x35, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x30, 0x02, 0x52, 0x1a, 0x28, + 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x73, 0x74, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x77, 0x61, 0x73, 0x20, 0x75, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, + 0x06, 0x12, 0x03, 0x30, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x30, 0x1c, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x30, + 0x29, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x08, 0x12, 0x03, 0x30, 0x2b, 0x51, + 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x02, 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x30, 0x2c, + 0x50, 0x0a, 0x2f, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x02, 0x12, 0x03, 0x33, 0x02, 0x2d, 0x1a, 0x22, + 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x73, 0x74, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x66, 0x69, 0x72, 0x65, 0x64, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x06, 0x12, 0x03, 0x33, 0x02, 0x1b, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, 0x33, 0x1c, 0x28, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x03, 0x12, 0x03, 0x33, 0x2b, 0x2c, 0x0a, 0x2c, 0x0a, 0x04, + 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, 0x36, 0x02, 0x2b, 0x1a, 0x1f, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x74, 0x69, 0x6d, 0x65, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x77, 0x61, 0x73, + 0x20, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x03, 0x06, 0x12, 0x03, 0x36, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, + 0x01, 0x12, 0x03, 0x36, 0x1c, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x03, 0x12, + 0x03, 0x36, 0x29, 0x2a, 0x0a, 0x5c, 0x0a, 0x02, 0x05, 0x00, 0x12, 0x04, 0x3a, 0x00, 0x40, 0x01, + 0x1a, 0x50, 0x20, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x73, 0x20, 0x68, 0x75, 0x6d, 0x61, 0x6e, 0x2d, + 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x2d, 0x66, 0x72, 0x69, + 0x65, 0x6e, 0x64, 0x6c, 0x79, 0x20, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x6e, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x77, 0x68, 0x61, 0x74, 0x20, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, + 0x6e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, 0x03, 0x3a, 0x05, 0x1a, 0x0a, 0x0b, + 0x0a, 0x04, 0x05, 0x00, 0x02, 0x00, 0x12, 0x03, 0x3b, 0x02, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x3b, 0x02, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, + 0x00, 0x02, 0x12, 0x03, 0x3b, 0x28, 0x29, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x01, 0x12, + 0x03, 0x3c, 0x02, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x3c, + 0x02, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x3c, 0x23, 0x24, + 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x02, 0x12, 0x03, 0x3d, 0x02, 0x27, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x3d, 0x02, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x3d, 0x25, 0x26, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, + 0x03, 0x12, 0x03, 0x3e, 0x02, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x01, 0x12, + 0x03, 0x3e, 0x02, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x3e, + 0x27, 0x28, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x04, 0x12, 0x03, 0x3f, 0x02, 0x25, 0x0a, + 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x3f, 0x02, 0x20, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, 0x3f, 0x23, 0x24, 0x0a, 0x46, 0x0a, 0x02, 0x04, + 0x03, 0x12, 0x04, 0x43, 0x00, 0x4e, 0x01, 0x1a, 0x3a, 0x20, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x2d, + 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, + 0x65, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, + 0x6f, 0x6e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x43, 0x08, 0x17, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x44, 0x02, 0x2c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x44, 0x02, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x44, 0x25, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x44, 0x2a, 0x2b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, + 0x46, 0x02, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x06, 0x12, 0x03, 0x46, 0x02, + 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, 0x46, 0x12, 0x1a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x46, 0x1d, 0x1e, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x03, 0x02, 0x02, 0x12, 0x03, 0x48, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x02, 0x06, 0x12, 0x03, 0x48, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, + 0x01, 0x12, 0x03, 0x48, 0x10, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x03, 0x12, + 0x03, 0x48, 0x19, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x03, 0x12, 0x03, 0x4a, 0x02, + 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x06, 0x12, 0x03, 0x4a, 0x02, 0x17, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x01, 0x12, 0x03, 0x4a, 0x18, 0x1e, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x03, 0x03, 0x12, 0x03, 0x4a, 0x21, 0x22, 0x0a, 0x3d, 0x0a, 0x04, 0x04, + 0x03, 0x02, 0x04, 0x12, 0x03, 0x4d, 0x02, 0x2b, 0x1a, 0x30, 0x20, 0x54, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x20, 0x61, 0x74, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x67, 0x69, + 0x76, 0x65, 0x6e, 0x20, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x61, 0x73, + 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x04, 0x06, 0x12, 0x03, 0x4d, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, + 0x01, 0x12, 0x03, 0x4d, 0x1c, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x03, 0x12, + 0x03, 0x4d, 0x29, 0x2a, 0x0a, 0x37, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x51, 0x00, 0x5f, 0x01, + 0x1a, 0x2b, 0x20, 0x46, 0x75, 0x6c, 0x6c, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x20, + 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, + 0x73, 0x74, 0x6f, 0x72, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x44, 0x42, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x51, 0x08, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, + 0x00, 0x12, 0x03, 0x52, 0x02, 0x49, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x52, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x52, + 0x1b, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x52, 0x20, 0x21, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x08, 0x12, 0x03, 0x52, 0x22, 0x48, 0x0a, 0x0f, + 0x0a, 0x08, 0x04, 0x04, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x52, 0x23, 0x47, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x54, 0x02, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x01, 0x06, 0x12, 0x03, 0x54, 0x02, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x54, 0x12, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x54, 0x1d, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x02, 0x12, 0x03, + 0x56, 0x02, 0x3e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x06, 0x12, 0x03, 0x56, 0x02, + 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x56, 0x0e, 0x12, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, 0x56, 0x15, 0x16, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x02, 0x08, 0x12, 0x03, 0x56, 0x17, 0x3d, 0x0a, 0x0f, 0x0a, 0x08, 0x04, + 0x04, 0x02, 0x02, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x56, 0x18, 0x3c, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x04, 0x02, 0x03, 0x12, 0x03, 0x58, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x03, 0x06, 0x12, 0x03, 0x58, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x01, + 0x12, 0x03, 0x58, 0x10, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x03, 0x12, 0x03, + 0x58, 0x19, 0x1a, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x04, 0x12, 0x03, 0x5b, 0x02, 0x3b, + 0x1a, 0x1b, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x61, 0x75, 0x74, 0x6f, + 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x04, 0x06, 0x12, 0x03, 0x5b, 0x02, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x04, 0x01, 0x12, 0x03, 0x5b, 0x27, 0x36, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x04, 0x03, 0x12, 0x03, 0x5b, 0x39, 0x3a, 0x0a, 0x22, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x05, 0x12, + 0x03, 0x5e, 0x02, 0x4e, 0x1a, 0x15, 0x20, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x64, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x05, 0x04, 0x12, 0x03, 0x5e, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x05, 0x05, 0x12, 0x03, 0x5e, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x05, 0x01, + 0x12, 0x03, 0x5e, 0x12, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x05, 0x03, 0x12, 0x03, + 0x5e, 0x20, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x05, 0x08, 0x12, 0x03, 0x5e, 0x22, + 0x4d, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x04, 0x02, 0x05, 0x08, 0x87, 0x09, 0x0e, 0x03, 0x12, 0x03, + 0x5e, 0x23, 0x4c, 0x0a, 0x44, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x62, 0x00, 0x6e, 0x01, 0x1a, + 0x38, 0x20, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x2d, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x20, 0x69, + 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, + 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x6c, + 0x69, 0x73, 0x74, 0x20, 0x76, 0x69, 0x65, 0x77, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, + 0x12, 0x03, 0x62, 0x08, 0x0f, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x09, 0x12, 0x03, 0x63, 0x02, + 0x0d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x09, 0x00, 0x12, 0x03, 0x63, 0x0b, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x09, 0x00, 0x01, 0x12, 0x03, 0x63, 0x0b, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x09, 0x00, 0x02, 0x12, 0x03, 0x63, 0x0b, 0x0c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, + 0x02, 0x00, 0x12, 0x03, 0x65, 0x02, 0x2c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x65, 0x02, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x65, 0x25, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x65, 0x2a, + 0x2b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x03, 0x67, 0x02, 0x1f, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x06, 0x12, 0x03, 0x67, 0x02, 0x11, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x01, 0x01, 0x12, 0x03, 0x67, 0x12, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x67, 0x1d, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x02, + 0x12, 0x03, 0x69, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x06, 0x12, 0x03, + 0x69, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x01, 0x12, 0x03, 0x69, 0x10, + 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x03, 0x12, 0x03, 0x69, 0x19, 0x1a, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x03, 0x12, 0x03, 0x6b, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x03, 0x05, 0x12, 0x03, 0x6b, 0x02, 0x06, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x03, 0x01, 0x12, 0x03, 0x6b, 0x07, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, + 0x03, 0x12, 0x03, 0x6b, 0x10, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x04, 0x12, 0x03, + 0x6d, 0x02, 0x3b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x06, 0x12, 0x03, 0x6d, 0x02, + 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x01, 0x12, 0x03, 0x6d, 0x27, 0x36, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x03, 0x12, 0x03, 0x6d, 0x39, 0x3a, 0x62, 0x06, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xe8, 0x3e, 0x0a, 0x27, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2f, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x11, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, + 0x6b, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x74, + 0x61, 0x73, 0x6b, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2a, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2f, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x5f, + 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x22, 0xff, 0x01, 0x0a, 0x14, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x54, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x39, 0x0a, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, + 0x12, 0x3a, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, 0x70, 0x65, 0x63, 0x42, 0x06, + 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x04, 0x73, 0x70, 0x65, 0x63, 0x12, 0x4e, 0x0a, 0x0f, + 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x41, 0x75, + 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0e, 0x61, 0x75, + 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x4a, 0x04, 0x08, 0x01, + 0x10, 0x02, 0x22, 0x5c, 0x0a, 0x15, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x54, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x07, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x42, + 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x07, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x22, 0x55, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, + 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x39, 0x0a, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, + 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x60, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x54, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x07, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, + 0x52, 0x07, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x22, 0x5f, 0x0a, 0x20, 0x47, 0x65, 0x74, + 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x44, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3b, 0x0a, + 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, + 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x22, 0x68, 0x0a, 0x21, 0x47, 0x65, + 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x43, 0x0a, 0x07, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x07, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x22, 0xb8, 0x02, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x37, 0x0a, 0x07, + 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x07, 0x72, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, 0x03, 0x6f, + 0x72, 0x67, 0x12, 0x44, 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x69, 0x64, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x09, 0x70, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x12, 0x39, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, + 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x06, 0x74, 0x61, 0x73, + 0x6b, 0x49, 0x64, 0x12, 0x37, 0x0a, 0x09, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x4e, 0x61, 0x6d, 0x65, + 0x48, 0x00, 0x52, 0x08, 0x74, 0x61, 0x73, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x42, 0x11, 0x0a, 0x08, + 0x73, 0x63, 0x6f, 0x70, 0x65, 0x5f, 0x62, 0x79, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, + 0x64, 0x0a, 0x14, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x36, 0x0a, 0x08, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x08, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x12, + 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x96, 0x01, 0x0a, 0x20, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, + 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x37, 0x0a, 0x07, 0x72, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4c, + 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x39, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, + 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x79, + 0x0a, 0x21, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, + 0x73, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x08, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x08, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x6e, 0x0a, 0x15, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x3d, 0x0a, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, + 0x42, 0x08, 0xba, 0x48, 0x05, 0x92, 0x01, 0x02, 0x08, 0x01, 0x52, 0x05, 0x6e, 0x61, 0x6d, 0x65, + 0x73, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x22, 0x18, 0x0a, 0x16, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x56, 0x0a, 0x15, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3d, 0x0a, 0x05, + 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x42, 0x08, 0xba, 0x48, 0x05, 0x92, + 0x01, 0x02, 0x08, 0x01, 0x52, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x22, 0x18, 0x0a, 0x16, 0x44, + 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0xbf, 0x06, 0x0a, 0x0e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x64, 0x0a, 0x0d, 0x44, 0x65, 0x70, 0x6c, + 0x6f, 0x79, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x12, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x44, 0x65, + 0x70, 0x6c, 0x6f, 0x79, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x73, + 0x0a, 0x11, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x12, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x2c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x44, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, + 0x90, 0x02, 0x01, 0x12, 0x8b, 0x01, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x12, 0x33, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x34, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, + 0x01, 0x12, 0x64, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x73, 0x12, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x4c, 0x69, + 0x73, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x8b, 0x01, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x54, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x48, 0x69, + 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x33, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, + 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x34, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x47, + 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, + 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x67, 0x0a, 0x0e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x12, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x55, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x67, + 0x0a, 0x0e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, + 0x12, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x44, + 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0xc8, 0x01, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x42, 0x13, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, + 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0xa2, + 0x02, 0x03, 0x46, 0x54, 0x58, 0xaa, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0xca, 0x02, 0x11, 0x46, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0xe2, 0x02, 0x1d, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x12, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x54, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x4a, 0xb3, 0x27, 0x0a, 0x07, 0x12, 0x05, 0x00, 0x00, 0x9a, 0x01, 0x21, 0x0a, 0x08, + 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, + 0x00, 0x1a, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, + 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x2b, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, + 0x06, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x03, 0x12, 0x03, 0x07, 0x00, 0x25, 0x0a, 0x09, + 0x0a, 0x02, 0x03, 0x04, 0x12, 0x03, 0x08, 0x00, 0x2e, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x05, 0x12, + 0x03, 0x09, 0x00, 0x34, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x0b, 0x00, 0x4c, 0x0a, 0x09, + 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x0b, 0x00, 0x4c, 0x0a, 0x49, 0x0a, 0x02, 0x06, 0x00, 0x12, + 0x04, 0x0e, 0x00, 0x32, 0x01, 0x1a, 0x3d, 0x20, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x73, 0x20, + 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x06, 0x00, 0x01, 0x12, 0x03, 0x0e, 0x08, 0x16, + 0x0a, 0xde, 0x04, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x00, 0x12, 0x03, 0x17, 0x02, 0x4c, 0x1a, 0xd0, + 0x04, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x69, 0x66, 0x20, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x20, 0x64, 0x69, 0x64, 0x6e, 0x27, 0x74, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, + 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x2e, 0x0a, 0x20, 0x55, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x20, 0x69, 0x66, 0x20, 0x69, 0x74, 0x20, 0x61, 0x6c, 0x72, 0x65, 0x61, + 0x64, 0x79, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x2e, 0x0a, 0x20, 0x52, 0x65, 0x2d, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x28, 0x6f, 0x72, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x6c, 0x65, 0x74, + 0x65, 0x29, 0x20, 0x69, 0x66, 0x20, 0x69, 0x74, 0x20, 0x77, 0x61, 0x73, 0x20, 0x73, 0x6f, 0x66, + 0x74, 0x2d, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x20, 0x43, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x66, 0x65, 0x74, 0x63, 0x68, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x20, 0x69, 0x6e, 0x20, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x62, 0x74, + 0x61, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x20, 0x60, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x69, 0x64, 0x2e, 0x72, 0x65, 0x76, 0x69, 0x73, + 0x69, 0x6f, 0x6e, 0x60, 0x2e, 0x0a, 0x20, 0x49, 0x66, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x2c, 0x20, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x73, 0x65, 0x74, 0x20, 0x60, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x69, 0x64, 0x2e, 0x72, 0x65, 0x76, 0x69, 0x73, + 0x69, 0x6f, 0x6e, 0x60, 0x20, 0x74, 0x6f, 0x20, 0x31, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, + 0x20, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x64, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x65, 0x74, + 0x20, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x62, + 0x79, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x2e, 0x0a, 0x20, 0x49, 0x66, 0x20, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x2c, + 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x73, + 0x65, 0x74, 0x20, 0x60, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x69, 0x64, 0x2e, 0x72, + 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x60, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x3c, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x3e, 0x2e, 0x0a, 0x20, 0x42, 0x61, 0x63, 0x6b, 0x65, + 0x6e, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, + 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x2e, 0x0a, 0x20, 0x4f, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x2c, 0x20, 0x6f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x6a, 0x65, + 0x63, 0x74, 0x65, 0x64, 0x28, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x73, 0x74, 0x69, 0x63, 0x20, + 0x6c, 0x6f, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x29, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x72, 0x65, 0x2d, 0x66, 0x65, 0x74, 0x63, + 0x68, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x61, 0x67, 0x61, 0x69, 0x6e, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x17, 0x06, 0x13, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x17, 0x14, 0x28, 0x0a, 0x0c, 0x0a, + 0x05, 0x06, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x17, 0x33, 0x48, 0x0a, 0x43, 0x0a, 0x04, 0x06, + 0x00, 0x02, 0x01, 0x12, 0x04, 0x1a, 0x02, 0x1c, 0x03, 0x1a, 0x35, 0x20, 0x47, 0x65, 0x74, 0x20, + 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x20, 0x61, 0x62, + 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x20, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x1a, 0x06, 0x17, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x1a, 0x18, 0x30, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x1a, 0x3b, 0x54, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x01, 0x04, 0x12, 0x03, 0x1b, 0x04, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, 0x06, 0x00, 0x02, 0x01, + 0x04, 0x22, 0x12, 0x03, 0x1b, 0x04, 0x2f, 0x0a, 0x43, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x02, 0x12, + 0x04, 0x1f, 0x02, 0x21, 0x03, 0x1a, 0x35, 0x20, 0x47, 0x65, 0x74, 0x20, 0x64, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, + 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x20, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x1f, 0x06, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x02, 0x02, 0x12, 0x03, 0x1f, 0x20, 0x40, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, + 0x03, 0x12, 0x03, 0x1f, 0x4b, 0x6c, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x04, 0x12, + 0x03, 0x20, 0x04, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, 0x06, 0x00, 0x02, 0x02, 0x04, 0x22, 0x12, 0x03, + 0x20, 0x04, 0x2f, 0x0a, 0x5c, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x03, 0x12, 0x04, 0x24, 0x02, 0x26, + 0x03, 0x1a, 0x4e, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x62, 0x61, 0x73, 0x69, 0x63, 0x20, 0x69, + 0x6e, 0x66, 0x6f, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x73, 0x20, 0x62, 0x61, 0x73, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x76, 0x61, 0x72, 0x69, + 0x6f, 0x75, 0x73, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x73, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x24, 0x06, 0x12, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x24, 0x13, 0x26, 0x0a, 0x0c, 0x0a, + 0x05, 0x06, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x24, 0x31, 0x45, 0x0a, 0x0c, 0x0a, 0x05, 0x06, + 0x00, 0x02, 0x03, 0x04, 0x12, 0x03, 0x25, 0x04, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, 0x06, 0x00, 0x02, + 0x03, 0x04, 0x22, 0x12, 0x03, 0x25, 0x04, 0x2f, 0x0a, 0x53, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x04, + 0x12, 0x04, 0x29, 0x02, 0x2b, 0x03, 0x1a, 0x45, 0x20, 0x47, 0x65, 0x74, 0x54, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, + 0x72, 0x79, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x72, + 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x67, + 0x69, 0x76, 0x65, 0x6e, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x06, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x29, 0x06, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x06, + 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, 0x29, 0x20, 0x40, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, + 0x04, 0x03, 0x12, 0x03, 0x29, 0x4b, 0x6c, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x04, 0x04, + 0x12, 0x03, 0x2a, 0x04, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, 0x06, 0x00, 0x02, 0x04, 0x04, 0x22, 0x12, + 0x03, 0x2a, 0x04, 0x2f, 0x0a, 0x4c, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x05, 0x12, 0x03, 0x2e, 0x02, + 0x4f, 0x1a, 0x3f, 0x20, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x73, 0x70, 0x65, 0x63, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, + 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x20, 0x61, 0x74, 0x20, 0x6f, 0x6e, 0x63, + 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x2e, 0x06, 0x14, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x05, 0x02, 0x12, 0x03, 0x2e, 0x15, 0x2a, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x05, 0x03, 0x12, 0x03, 0x2e, 0x35, 0x4b, 0x0a, 0x35, 0x0a, 0x04, + 0x06, 0x00, 0x02, 0x06, 0x12, 0x03, 0x31, 0x02, 0x4f, 0x1a, 0x28, 0x20, 0x53, 0x6f, 0x66, 0x74, + 0x2d, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, + 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x20, 0x61, 0x74, 0x20, 0x6f, 0x6e, 0x63, + 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x31, 0x06, + 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x06, 0x02, 0x12, 0x03, 0x31, 0x15, 0x2a, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x06, 0x03, 0x12, 0x03, 0x31, 0x35, 0x4b, 0x0a, 0x33, 0x0a, + 0x02, 0x04, 0x00, 0x12, 0x04, 0x35, 0x00, 0x43, 0x01, 0x1a, 0x27, 0x20, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x35, 0x08, 0x1c, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x00, 0x09, 0x12, 0x03, 0x36, 0x02, 0x0d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, + 0x09, 0x00, 0x12, 0x03, 0x36, 0x0b, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x09, 0x00, 0x01, + 0x12, 0x03, 0x36, 0x0b, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x09, 0x00, 0x02, 0x12, 0x03, + 0x36, 0x0b, 0x0c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x38, 0x02, 0x4f, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x38, 0x02, 0x1e, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x38, 0x1f, 0x23, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x38, 0x26, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x08, 0x12, 0x03, 0x38, 0x28, 0x4e, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x02, 0x00, + 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x38, 0x29, 0x4d, 0x0a, 0xb8, 0x01, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x01, 0x12, 0x03, 0x3d, 0x02, 0x16, 0x1a, 0xaa, 0x01, 0x20, 0x52, 0x65, 0x76, 0x69, 0x73, + 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x2e, 0x0a, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x20, 0x64, 0x65, + 0x70, 0x6c, 0x6f, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x2e, 0x0a, 0x20, 0x4d, 0x61, 0x6e, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x79, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x78, 0x69, + 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x20, 0x6c, + 0x61, 0x74, 0x65, 0x73, 0x74, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, + 0x20, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x20, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, + 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x3d, + 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x3d, 0x09, 0x11, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x3d, 0x14, 0x15, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x3f, 0x02, 0x3e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x3f, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x3f, 0x0e, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x3f, 0x15, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x08, 0x12, 0x03, + 0x3f, 0x17, 0x3d, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x02, 0x02, 0x08, 0x87, 0x09, 0x19, 0x12, + 0x03, 0x3f, 0x18, 0x3c, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x42, 0x02, + 0x3b, 0x1a, 0x1b, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x61, 0x75, 0x74, + 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x06, 0x12, 0x03, 0x42, 0x02, 0x26, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x42, 0x27, 0x36, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x03, 0x03, 0x12, 0x03, 0x42, 0x39, 0x3a, 0x0a, 0x34, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, + 0x46, 0x00, 0x48, 0x01, 0x1a, 0x28, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x61, 0x76, 0x69, + 0x6e, 0x67, 0x20, 0x61, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x46, 0x08, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x00, 0x12, 0x03, 0x47, 0x02, 0x56, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x47, 0x02, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x47, 0x23, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x47, 0x2d, + 0x2e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x08, 0x12, 0x03, 0x47, 0x2f, 0x55, 0x0a, + 0x0f, 0x0a, 0x08, 0x04, 0x01, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x47, 0x30, 0x54, + 0x0a, 0x33, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x4b, 0x00, 0x4d, 0x01, 0x1a, 0x27, 0x20, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x4b, 0x08, + 0x20, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x4c, 0x02, 0x45, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, 0x03, 0x4c, 0x02, 0x14, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x4c, 0x15, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x4c, 0x1c, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, + 0x08, 0x12, 0x03, 0x4c, 0x1e, 0x44, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x02, 0x02, 0x00, 0x08, 0x87, + 0x09, 0x19, 0x12, 0x03, 0x4c, 0x1f, 0x43, 0x0a, 0x34, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x50, + 0x00, 0x52, 0x01, 0x1a, 0x28, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x61, 0x76, 0x69, 0x6e, + 0x67, 0x20, 0x61, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x50, 0x08, 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, + 0x00, 0x12, 0x03, 0x51, 0x02, 0x56, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x51, 0x02, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x51, + 0x23, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x51, 0x2d, 0x2e, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x08, 0x12, 0x03, 0x51, 0x2f, 0x55, 0x0a, 0x0f, + 0x0a, 0x08, 0x04, 0x03, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x51, 0x30, 0x54, 0x0a, + 0x33, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x55, 0x00, 0x57, 0x01, 0x1a, 0x27, 0x20, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x55, 0x08, 0x28, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x56, 0x02, 0x49, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x00, 0x06, 0x12, 0x03, 0x56, 0x02, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x56, 0x1b, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x56, 0x20, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x08, + 0x12, 0x03, 0x56, 0x22, 0x48, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x04, 0x02, 0x00, 0x08, 0x87, 0x09, + 0x19, 0x12, 0x03, 0x56, 0x23, 0x47, 0x0a, 0x34, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x5a, 0x00, + 0x5c, 0x01, 0x1a, 0x28, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67, + 0x20, 0x61, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x05, 0x01, 0x12, 0x03, 0x5a, 0x08, 0x29, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, + 0x12, 0x03, 0x5b, 0x02, 0x56, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x06, 0x12, 0x03, + 0x5b, 0x02, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x5b, 0x23, + 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x5b, 0x2d, 0x2e, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x08, 0x12, 0x03, 0x5b, 0x2f, 0x55, 0x0a, 0x0f, 0x0a, + 0x08, 0x04, 0x05, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x5b, 0x30, 0x54, 0x0a, 0x0a, + 0x0a, 0x02, 0x04, 0x06, 0x12, 0x04, 0x5e, 0x00, 0x71, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, + 0x01, 0x12, 0x03, 0x5e, 0x08, 0x1b, 0x0a, 0x2e, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x03, + 0x60, 0x02, 0x2b, 0x1a, 0x21, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x6c, 0x69, 0x73, + 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, + 0x74, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x60, 0x02, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x03, 0x60, + 0x1f, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x03, 0x60, 0x29, 0x2a, + 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x06, 0x08, 0x00, 0x12, 0x04, 0x62, 0x02, 0x70, 0x03, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x06, 0x08, 0x00, 0x01, 0x12, 0x03, 0x62, 0x08, 0x10, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x06, 0x08, 0x00, 0x02, 0x12, 0x03, 0x63, 0x04, 0x30, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x06, + 0x08, 0x00, 0x02, 0x87, 0x09, 0x01, 0x12, 0x03, 0x63, 0x04, 0x30, 0x0a, 0x2f, 0x0a, 0x04, 0x04, + 0x06, 0x02, 0x01, 0x12, 0x03, 0x66, 0x04, 0x3d, 0x1a, 0x22, 0x20, 0x4f, 0x72, 0x67, 0x61, 0x6e, + 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x01, 0x05, 0x12, 0x03, 0x66, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x66, 0x0b, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x66, 0x11, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x08, 0x12, + 0x03, 0x66, 0x13, 0x3c, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x06, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, + 0x02, 0x12, 0x03, 0x66, 0x14, 0x3b, 0x0a, 0x30, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x02, 0x12, 0x03, + 0x69, 0x04, 0x36, 0x1a, 0x23, 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x69, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x69, 0x6c, + 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, + 0x06, 0x12, 0x03, 0x69, 0x04, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x69, 0x27, 0x31, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x03, 0x12, 0x03, 0x69, + 0x34, 0x35, 0x0a, 0x48, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x03, 0x12, 0x03, 0x6c, 0x04, 0x2e, 0x1a, + 0x3b, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x73, 0x20, 0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, + 0x6f, 0x66, 0x20, 0x61, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x03, 0x06, 0x12, 0x03, 0x6c, 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x03, 0x01, 0x12, 0x03, 0x6c, 0x22, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x03, + 0x03, 0x12, 0x03, 0x6c, 0x2c, 0x2d, 0x0a, 0x3a, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x04, 0x12, 0x03, + 0x6f, 0x04, 0x2a, 0x1a, 0x2d, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x20, 0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x74, 0x61, 0x73, 0x6b, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x06, 0x12, 0x03, 0x6f, 0x04, 0x1b, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x01, 0x12, 0x03, 0x6f, 0x1c, 0x25, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x03, 0x12, 0x03, 0x6f, 0x28, 0x29, 0x0a, 0x34, 0x0a, 0x02, + 0x04, 0x07, 0x12, 0x04, 0x74, 0x00, 0x7a, 0x01, 0x1a, 0x28, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x6c, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, + 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x03, 0x74, 0x08, 0x1c, 0x0a, 0x3d, + 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x03, 0x76, 0x02, 0x32, 0x1a, 0x30, 0x20, 0x4c, 0x69, + 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x20, 0x6d, + 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6c, 0x74, + 0x65, 0x72, 0x20, 0x63, 0x72, 0x69, 0x74, 0x65, 0x72, 0x69, 0x61, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x00, 0x04, 0x12, 0x03, 0x76, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x00, 0x06, 0x12, 0x03, 0x76, 0x0b, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x76, 0x25, 0x2d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x76, 0x30, 0x31, 0x0a, 0x43, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x01, 0x12, 0x03, 0x79, + 0x02, 0x13, 0x1a, 0x36, 0x20, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, + 0x65, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, + 0x20, 0x70, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, + 0x2c, 0x20, 0x69, 0x66, 0x20, 0x61, 0x6e, 0x79, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x01, 0x05, 0x12, 0x03, 0x79, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x79, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x79, 0x11, 0x12, 0x0a, 0x0b, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x05, 0x7c, 0x00, 0x80, 0x01, + 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x08, 0x01, 0x12, 0x03, 0x7c, 0x08, 0x28, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x08, 0x02, 0x00, 0x12, 0x03, 0x7d, 0x02, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x00, 0x06, 0x12, 0x03, 0x7d, 0x02, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x7d, 0x1f, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x7d, 0x29, 0x2a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x01, 0x12, 0x03, 0x7f, 0x02, + 0x45, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x06, 0x12, 0x03, 0x7f, 0x02, 0x14, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x01, 0x12, 0x03, 0x7f, 0x15, 0x19, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x01, 0x03, 0x12, 0x03, 0x7f, 0x1c, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x01, 0x08, 0x12, 0x03, 0x7f, 0x1e, 0x44, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x08, 0x02, + 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x7f, 0x1f, 0x43, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x09, + 0x12, 0x06, 0x82, 0x01, 0x00, 0x88, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, + 0x04, 0x82, 0x01, 0x08, 0x29, 0x0a, 0x3e, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x00, 0x12, 0x04, 0x84, + 0x01, 0x02, 0x3a, 0x1a, 0x30, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x63, 0x72, 0x69, 0x74, 0x65, + 0x72, 0x69, 0x61, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x04, 0x12, 0x04, + 0x84, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x06, 0x12, 0x04, 0x84, + 0x01, 0x0b, 0x2c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x04, 0x84, 0x01, + 0x2d, 0x35, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, 0x04, 0x84, 0x01, 0x38, + 0x39, 0x0a, 0x44, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x01, 0x12, 0x04, 0x87, 0x01, 0x02, 0x13, 0x1a, + 0x36, 0x20, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x65, 0x74, 0x63, + 0x68, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x70, 0x61, + 0x67, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2c, 0x20, 0x69, + 0x66, 0x20, 0x61, 0x6e, 0x79, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x05, + 0x12, 0x04, 0x87, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x01, 0x12, + 0x04, 0x87, 0x01, 0x09, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x03, 0x12, 0x04, + 0x87, 0x01, 0x11, 0x12, 0x0a, 0x5b, 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x06, 0x8b, 0x01, 0x00, 0x8f, + 0x01, 0x01, 0x1a, 0x4d, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x69, 0x6e, + 0x67, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6d, + 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, + 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0a, 0x01, 0x12, 0x04, 0x8b, 0x01, 0x08, 0x1d, 0x0a, 0x0c, + 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x00, 0x12, 0x04, 0x8c, 0x01, 0x02, 0x56, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0a, 0x02, 0x00, 0x04, 0x12, 0x04, 0x8c, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0a, 0x02, 0x00, 0x06, 0x12, 0x04, 0x8c, 0x01, 0x0b, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, + 0x02, 0x00, 0x01, 0x12, 0x04, 0x8c, 0x01, 0x1e, 0x23, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, + 0x00, 0x03, 0x12, 0x04, 0x8c, 0x01, 0x26, 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, + 0x08, 0x12, 0x04, 0x8c, 0x01, 0x28, 0x55, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x0a, 0x02, 0x00, 0x08, + 0x87, 0x09, 0x12, 0x01, 0x12, 0x04, 0x8c, 0x01, 0x29, 0x54, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0a, + 0x02, 0x01, 0x12, 0x04, 0x8e, 0x01, 0x02, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, + 0x05, 0x12, 0x04, 0x8e, 0x01, 0x02, 0x06, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x01, + 0x12, 0x04, 0x8e, 0x01, 0x07, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x03, 0x12, + 0x04, 0x8e, 0x01, 0x10, 0x11, 0x0a, 0x5a, 0x0a, 0x02, 0x04, 0x0b, 0x12, 0x04, 0x92, 0x01, 0x00, + 0x21, 0x1a, 0x4e, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x69, 0x6e, + 0x67, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6d, + 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, + 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0b, 0x01, 0x12, 0x04, 0x92, 0x01, 0x08, 0x1e, 0x0a, 0x50, + 0x0a, 0x02, 0x04, 0x0c, 0x12, 0x06, 0x95, 0x01, 0x00, 0x97, 0x01, 0x01, 0x1a, 0x42, 0x20, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x72, + 0x20, 0x64, 0x65, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x6d, 0x75, + 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x0a, + 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0c, 0x01, 0x12, 0x04, 0x95, 0x01, 0x08, 0x1d, 0x0a, 0x0c, 0x0a, + 0x04, 0x04, 0x0c, 0x02, 0x00, 0x12, 0x04, 0x96, 0x01, 0x02, 0x56, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0c, 0x02, 0x00, 0x04, 0x12, 0x04, 0x96, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, + 0x02, 0x00, 0x06, 0x12, 0x04, 0x96, 0x01, 0x0b, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, + 0x00, 0x01, 0x12, 0x04, 0x96, 0x01, 0x1e, 0x23, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, + 0x03, 0x12, 0x04, 0x96, 0x01, 0x26, 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x08, + 0x12, 0x04, 0x96, 0x01, 0x28, 0x55, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x0c, 0x02, 0x00, 0x08, 0x87, + 0x09, 0x12, 0x01, 0x12, 0x04, 0x96, 0x01, 0x29, 0x54, 0x0a, 0x50, 0x0a, 0x02, 0x04, 0x0d, 0x12, + 0x04, 0x9a, 0x01, 0x00, 0x21, 0x1a, 0x44, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x63, 0x74, + 0x69, 0x76, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x61, 0x63, 0x74, + 0x69, 0x76, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, + 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, + 0x0d, 0x01, 0x12, 0x04, 0x9a, 0x01, 0x08, 0x1e, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +]; +include!("flyteidl2.trigger.tonic.rs"); +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/flyteidl2.trigger.tonic.rs b/gen/rust/src/flyteidl2.trigger.tonic.rs new file mode 100644 index 0000000000..c538a40ccc --- /dev/null +++ b/gen/rust/src/flyteidl2.trigger.tonic.rs @@ -0,0 +1,785 @@ +// @generated +/// Generated client implementations. +pub mod trigger_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct TriggerServiceClient { + inner: tonic::client::Grpc, + } + impl TriggerServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl TriggerServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> TriggerServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + TriggerServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + pub async fn deploy_trigger( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.trigger.TriggerService/DeployTrigger", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.trigger.TriggerService", "DeployTrigger"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn get_trigger_details( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.trigger.TriggerService/GetTriggerDetails", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.trigger.TriggerService", + "GetTriggerDetails", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn get_trigger_revision_details( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.trigger.TriggerService/GetTriggerRevisionDetails", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.trigger.TriggerService", + "GetTriggerRevisionDetails", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn list_triggers( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.trigger.TriggerService/ListTriggers", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.trigger.TriggerService", "ListTriggers"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn get_trigger_revision_history( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.trigger.TriggerService/GetTriggerRevisionHistory", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.trigger.TriggerService", + "GetTriggerRevisionHistory", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn update_triggers( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.trigger.TriggerService/UpdateTriggers", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.trigger.TriggerService", "UpdateTriggers"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn delete_triggers( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.trigger.TriggerService/DeleteTriggers", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.trigger.TriggerService", "DeleteTriggers"), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod trigger_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with TriggerServiceServer. + #[async_trait] + pub trait TriggerService: Send + Sync + 'static { + async fn deploy_trigger( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn get_trigger_details( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn get_trigger_revision_details( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn list_triggers( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn get_trigger_revision_history( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn update_triggers( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn delete_triggers( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + #[derive(Debug)] + pub struct TriggerServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl TriggerServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for TriggerServiceServer + where + T: TriggerService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.trigger.TriggerService/DeployTrigger" => { + #[allow(non_camel_case_types)] + struct DeployTriggerSvc(pub Arc); + impl< + T: TriggerService, + > tonic::server::UnaryService + for DeployTriggerSvc { + type Response = super::DeployTriggerResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::deploy_trigger(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = DeployTriggerSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.trigger.TriggerService/GetTriggerDetails" => { + #[allow(non_camel_case_types)] + struct GetTriggerDetailsSvc(pub Arc); + impl< + T: TriggerService, + > tonic::server::UnaryService + for GetTriggerDetailsSvc { + type Response = super::GetTriggerDetailsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_trigger_details(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetTriggerDetailsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.trigger.TriggerService/GetTriggerRevisionDetails" => { + #[allow(non_camel_case_types)] + struct GetTriggerRevisionDetailsSvc(pub Arc); + impl< + T: TriggerService, + > tonic::server::UnaryService< + super::GetTriggerRevisionDetailsRequest, + > for GetTriggerRevisionDetailsSvc { + type Response = super::GetTriggerRevisionDetailsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::GetTriggerRevisionDetailsRequest, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_trigger_revision_details( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetTriggerRevisionDetailsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.trigger.TriggerService/ListTriggers" => { + #[allow(non_camel_case_types)] + struct ListTriggersSvc(pub Arc); + impl< + T: TriggerService, + > tonic::server::UnaryService + for ListTriggersSvc { + type Response = super::ListTriggersResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::list_triggers(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ListTriggersSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.trigger.TriggerService/GetTriggerRevisionHistory" => { + #[allow(non_camel_case_types)] + struct GetTriggerRevisionHistorySvc(pub Arc); + impl< + T: TriggerService, + > tonic::server::UnaryService< + super::GetTriggerRevisionHistoryRequest, + > for GetTriggerRevisionHistorySvc { + type Response = super::GetTriggerRevisionHistoryResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::GetTriggerRevisionHistoryRequest, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_trigger_revision_history( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetTriggerRevisionHistorySvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.trigger.TriggerService/UpdateTriggers" => { + #[allow(non_camel_case_types)] + struct UpdateTriggersSvc(pub Arc); + impl< + T: TriggerService, + > tonic::server::UnaryService + for UpdateTriggersSvc { + type Response = super::UpdateTriggersResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::update_triggers(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = UpdateTriggersSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.trigger.TriggerService/DeleteTriggers" => { + #[allow(non_camel_case_types)] + struct DeleteTriggersSvc(pub Arc); + impl< + T: TriggerService, + > tonic::server::UnaryService + for DeleteTriggersSvc { + type Response = super::DeleteTriggersResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::delete_triggers(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = DeleteTriggersSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for TriggerServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService for TriggerServiceServer { + const NAME: &'static str = "flyteidl2.trigger.TriggerService"; + } +} diff --git a/gen/rust/src/flyteidl2.workflow.rs b/gen/rust/src/flyteidl2.workflow.rs new file mode 100644 index 0000000000..a3a9a99613 --- /dev/null +++ b/gen/rust/src/flyteidl2.workflow.rs @@ -0,0 +1,4935 @@ +// @generated +// This file is @generated by prost-build. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Run { + /// Lightweight information about the root action. + #[prost(message, optional, tag="1")] + pub action: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RunDetails { + /// Run spec. + #[prost(message, optional, tag="1")] + pub run_spec: ::core::option::Option, + /// Detailed information about the root action. + #[prost(message, optional, tag="2")] + pub action: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskAction { + /// a unique identifier for the task this action is associated with, if applicable. + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + /// the definition of the task to be executed. + #[prost(message, optional, tag="2")] + pub spec: ::core::option::Option, + /// Enables caching when set and specifies the cache version to use. + #[prost(message, optional, tag="3")] + pub cache_key: ::core::option::Option, + /// the specific cluster that this action should be executed on. if not set, the cluster from the + /// `RunSpec` will be used. + #[prost(string, tag="4")] + pub cluster: ::prost::alloc::string::String, +} +/// TraceAction is used to define a trace action that can be used to track the execution of an action that's managed +/// by the local worker. This can be used to bring determinism to code that's otherwise not deterministic (e.g. current +/// time). +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TraceAction { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// Last known phase. + #[prost(enumeration="super::common::ActionPhase", tag="2")] + pub phase: i32, + /// Time the attempt started. + #[prost(message, optional, tag="3")] + pub start_time: ::core::option::Option, + /// Time the attempt ended, if applicable. + #[prost(message, optional, tag="4")] + pub end_time: ::core::option::Option, + /// Output references. + #[prost(message, optional, tag="5")] + pub outputs: ::core::option::Option, + /// Task spec for the trace, useful for the typed interface inside. + #[prost(message, optional, tag="6")] + pub spec: ::core::option::Option, +} +/// ConditionAction is used to define a condition that can be evaluated at runtime. It can be used to +/// await a signal from an external system and can carry a value. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ConditionAction { + /// Name is the unique identifier for the action. It must be unique within the defined scope below. + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// Type is the type of the value the condition is expected. This can be used to properly render + /// a UI element for the condition or validate when a value is received that it is of the expected + /// type. + #[prost(message, optional, tag="6")] + pub r#type: ::core::option::Option, + /// Prompt is the prompt that will be shown to the user when the condition is awaited. + #[prost(string, tag="7")] + pub prompt: ::prost::alloc::string::String, + /// Description is a description of the condition. This can be used to provide additional + /// information to the user about the condition. + #[prost(string, tag="8")] + pub description: ::prost::alloc::string::String, + #[prost(oneof="condition_action::Scope", tags="2, 3, 4")] + pub scope: ::core::option::Option, +} +/// Nested message and enum types in `ConditionAction`. +pub mod condition_action { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Scope { + /// RunId is the unique identifier for the run this action is associated with. + #[prost(string, tag="2")] + RunId(::prost::alloc::string::String), + /// ActionId is the unique identifier for the action this action is associated with. + #[prost(string, tag="3")] + ActionId(::prost::alloc::string::String), + /// Global indicates the condition is global and can be used across all runs and actions. + #[prost(bool, tag="4")] + Global(bool), + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskActionMetadata { + /// Id of the task this action is associated with. + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + /// Extensible task type. + #[prost(string, tag="2")] + pub task_type: ::prost::alloc::string::String, + /// The short name for this task. + #[prost(string, tag="3")] + pub short_name: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TraceActionMetadata { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ConditionActionMetadata { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + #[prost(oneof="condition_action_metadata::Scope", tags="2, 3, 4")] + pub scope: ::core::option::Option, +} +/// Nested message and enum types in `ConditionActionMetadata`. +pub mod condition_action_metadata { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Scope { + /// RunId is the unique identifier for the run this action is associated with. + #[prost(string, tag="2")] + RunId(::prost::alloc::string::String), + /// ActionId is the unique identifier for the action this action is associated with. + #[prost(string, tag="3")] + ActionId(::prost::alloc::string::String), + /// Global indicates the condition is global and can be used across all runs and actions. + #[prost(bool, tag="4")] + Global(bool), + } +} +/// Static, lightweight metadata about an action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ActionMetadata { + /// Parent action if not the root. + #[prost(string, tag="3")] + pub parent: ::prost::alloc::string::String, + /// Group this action belongs to, if applicable. + #[prost(string, tag="5")] + pub group: ::prost::alloc::string::String, + /// Identity that executed this run. + #[prost(message, optional, tag="6")] + pub executed_by: ::core::option::Option, + /// Action type. + #[prost(enumeration="ActionType", tag="10")] + pub action_type: i32, + /// If this run was initiated by a trigger, this will store the trigger identifier. + #[prost(message, optional, tag="11")] + pub trigger_id: ::core::option::Option, + /// Environment name + #[prost(string, tag="12")] + pub environment_name: ::prost::alloc::string::String, + /// Function name + #[prost(string, tag="13")] + pub funtion_name: ::prost::alloc::string::String, + /// Trigger name + #[prost(string, tag="14")] + pub trigger_name: ::prost::alloc::string::String, + /// Trigger Type + #[prost(message, optional, tag="15")] + pub trigger_type: ::core::option::Option, + /// Who initiated this run + #[prost(enumeration="RunSource", tag="16")] + pub source: i32, + #[prost(oneof="action_metadata::Spec", tags="7, 8, 9")] + pub spec: ::core::option::Option, +} +/// Nested message and enum types in `ActionMetadata`. +pub mod action_metadata { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Spec { + /// Task action. + #[prost(message, tag="7")] + Task(super::TaskActionMetadata), + /// Trace action. + #[prost(message, tag="8")] + Trace(super::TraceActionMetadata), + /// Condition action. + #[prost(message, tag="9")] + Condition(super::ConditionActionMetadata), + } +} +/// Lightweight status of an action. For more detailed status see ActionDetails. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct ActionStatus { + /// Last known phase. + #[prost(enumeration="super::common::ActionPhase", tag="1")] + pub phase: i32, + /// Time the action started. + #[prost(message, optional, tag="2")] + pub start_time: ::core::option::Option, + /// Time the action ended, if applicable. + #[prost(message, optional, tag="3")] + pub end_time: ::core::option::Option, + /// Number of action attempts. + #[prost(uint32, tag="4")] + pub attempts: u32, + /// cache status of the action's latest attempt + #[prost(enumeration="super::core::CatalogCacheStatus", tag="5")] + pub cache_status: i32, + /// Duration of the action in milliseconds. + #[prost(uint64, optional, tag="6")] + pub duration_ms: ::core::option::Option, +} +/// Lightweight representation of an action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Action { + /// Id for this action. + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + /// Metadata for this action. + #[prost(message, optional, tag="2")] + pub metadata: ::core::option::Option, + /// Last known status. + #[prost(message, optional, tag="3")] + pub status: ::core::option::Option, +} +/// EnrichedAction is a wrapper around Action that contains additional information +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EnrichedAction { + /// The action itself. + #[prost(message, optional, tag="1")] + pub action: ::core::option::Option, + /// Whether this action meets specified filters of the request or not. + /// If an action that was previously meeting the filter but no longer does, will be sent with this flag set to false + #[prost(bool, tag="2")] + pub meets_filter: bool, + /// Child phase info for this action (Map of phase to counts of children in given phase) + #[prost(map="int32, int32", tag="3")] + pub children_phase_counts: ::std::collections::HashMap, +} +/// ErrorInfo captures details of an error. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ErrorInfo { + /// Error message. + #[prost(string, tag="1")] + pub message: ::prost::alloc::string::String, + /// Error kind. + #[prost(enumeration="error_info::Kind", tag="2")] + pub kind: i32, +} +/// Nested message and enum types in `ErrorInfo`. +pub mod error_info { + #[pyo3::pyclass(dict, get_all, set_all)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum Kind { + Unspecified = 0, + User = 1, + System = 2, + } + impl Kind { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Kind::Unspecified => "KIND_UNSPECIFIED", + Kind::User => "KIND_USER", + Kind::System => "KIND_SYSTEM", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "KIND_UNSPECIFIED" => Some(Self::Unspecified), + "KIND_USER" => Some(Self::User), + "KIND_SYSTEM" => Some(Self::System), + _ => None, + } + } + } +} +/// AbortInfo captures details of an aborted run. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AbortInfo { + /// Reason provided for the abort. + #[prost(string, tag="1")] + pub reason: ::prost::alloc::string::String, + /// Identity that aborted the run. + #[prost(message, optional, tag="2")] + pub aborted_by: ::core::option::Option, +} +/// ActionDetails is the full details of an action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ActionDetails { + /// Id for this action. + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + /// Metadata for this action. + #[prost(message, optional, tag="2")] + pub metadata: ::core::option::Option, + /// Last known status. + #[prost(message, optional, tag="3")] + pub status: ::core::option::Option, + /// List of action attempts. + #[prost(message, repeated, tag="7")] + pub attempts: ::prost::alloc::vec::Vec, + #[prost(oneof="action_details::Result", tags="4, 5")] + pub result: ::core::option::Option, + /// Fully resolved spec of the action. Merges user submitted task spec with platform defaults. + #[prost(oneof="action_details::Spec", tags="6, 8")] + pub spec: ::core::option::Option, +} +/// Nested message and enum types in `ActionDetails`. +pub mod action_details { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Result { + /// Error info for the action, if failed. + #[prost(message, tag="4")] + ErrorInfo(super::ErrorInfo), + /// Abort info for the action, if aborted. + #[prost(message, tag="5")] + AbortInfo(super::AbortInfo), + } + /// Fully resolved spec of the action. Merges user submitted task spec with platform defaults. + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Spec { + #[prost(message, tag="6")] + Task(super::super::task::TaskSpec), + #[prost(message, tag="8")] + Trace(super::super::task::TraceSpec), + } +} +/// ActionAttempt is a single attempt of an action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ActionAttempt { + /// Last known phase. + #[prost(enumeration="super::common::ActionPhase", tag="1")] + pub phase: i32, + /// Time the attempt started. + #[prost(message, optional, tag="2")] + pub start_time: ::core::option::Option, + /// Time the attempt ended, if applicable. + #[prost(message, optional, tag="3")] + pub end_time: ::core::option::Option, + /// Error info for the attempt, if failed. + #[prost(message, optional, tag="4")] + pub error_info: ::core::option::Option, + /// The attempt number, starting with 1. + #[prost(uint32, tag="5")] + pub attempt: u32, + /// Log references. + #[prost(message, repeated, tag="6")] + pub log_info: ::prost::alloc::vec::Vec, + /// Output references. + #[prost(message, optional, tag="7")] + pub outputs: ::core::option::Option, + /// Indicates whether logs are available for tailing. It doesn't necessarily indicate the logs are present, but that + /// we have the info we need to look them up. + #[prost(bool, tag="8")] + pub logs_available: bool, + /// cache status of the action attempt + #[prost(enumeration="super::core::CatalogCacheStatus", tag="9")] + pub cache_status: i32, + /// Cluster events like k8s events in a human-readable form. + #[prost(message, repeated, tag="10")] + pub cluster_events: ::prost::alloc::vec::Vec, + /// History of phase transitions. + #[prost(message, repeated, tag="11")] + pub phase_transitions: ::prost::alloc::vec::Vec, + /// The cluster this attempt is assigned to. + #[prost(string, tag="12")] + pub cluster: ::prost::alloc::string::String, + /// Contains corresponding k8s pods and containers information for this action attempt. + #[prost(message, optional, tag="13")] + pub log_context: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ClusterEvent { + /// occurred_at is the timestamp indicating the instant that this reason happened. + #[prost(message, optional, tag="1")] + pub occurred_at: ::core::option::Option, + /// message is the explanation for the most recent phase transition or status update. + #[prost(string, tag="2")] + pub message: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct PhaseTransition { + /// The phase. + #[prost(enumeration="super::common::ActionPhase", tag="1")] + pub phase: i32, + /// Time this phase started. + #[prost(message, optional, tag="2")] + pub start_time: ::core::option::Option, + /// Time this phase ended, if applicable. For terminal phases, start time will equal end time. + #[prost(message, optional, tag="3")] + pub end_time: ::core::option::Option, +} +/// Event payload for an action +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ActionEvent { + /// The action id. + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + /// The attempt number. + #[prost(uint32, tag="2")] + pub attempt: u32, + /// The phase for this attempt. + #[prost(enumeration="super::common::ActionPhase", tag="3")] + pub phase: i32, + /// The version of this attempt and phase. + #[prost(uint32, tag="4")] + pub version: u32, + /// Time the attempt started. + #[deprecated] + #[prost(message, optional, tag="5")] + pub start_time: ::core::option::Option, + /// Timestamp when the event occurred, as recorded by the underlying platform (e.g. Kubernetes). + #[prost(message, optional, tag="6")] + pub updated_time: ::core::option::Option, + /// Time the attempt ended, if applicable. + #[deprecated] + #[prost(message, optional, tag="7")] + pub end_time: ::core::option::Option, + /// Error info for the attempt, if failed. + #[prost(message, optional, tag="8")] + pub error_info: ::core::option::Option, + /// Log references. + #[prost(message, repeated, tag="9")] + pub log_info: ::prost::alloc::vec::Vec, + /// Metadata to associate containers with logs. + #[prost(message, optional, tag="10")] + pub log_context: ::core::option::Option, + /// The cluster this attempt is running on. + #[prost(string, tag="11")] + pub cluster: ::prost::alloc::string::String, + /// Output references. + #[prost(message, optional, tag="12")] + pub outputs: ::core::option::Option, + /// cache status of the action attempt + #[prost(enumeration="super::core::CatalogCacheStatus", tag="13")] + pub cache_status: i32, + /// Cluster events like k8s events in a human-readable form. + #[prost(message, repeated, tag="14")] + pub cluster_events: ::prost::alloc::vec::Vec, + /// Timestamp when the event was observed and reported by the executor + #[prost(message, optional, tag="15")] + pub reported_time: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ActionSpec { + /// the unique identifier for the action. + #[prost(message, optional, tag="1")] + pub action_id: ::core::option::Option, + /// an optional name for the parent action, if it exists. the remaining run metadata (ex. org, + /// project, domain) will be the same as the action_id defined above. + #[prost(string, optional, tag="2")] + pub parent_action_name: ::core::option::Option<::prost::alloc::string::String>, + /// the run spec for this action + #[prost(message, optional, tag="3")] + pub run_spec: ::core::option::Option, + /// the path to the input data for this action. + #[prost(string, tag="4")] + pub input_uri: ::prost::alloc::string::String, + /// the run base path this action should write its output to. + #[prost(string, tag="5")] + pub run_output_base: ::prost::alloc::string::String, + /// group this action belongs to, if applicable. + #[prost(string, tag="8")] + pub group: ::prost::alloc::string::String, + #[prost(oneof="action_spec::Spec", tags="6, 7, 10")] + pub spec: ::core::option::Option, +} +/// Nested message and enum types in `ActionSpec`. +pub mod action_spec { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Spec { + #[prost(message, tag="6")] + Task(super::TaskAction), + #[prost(message, tag="7")] + Condition(super::ConditionAction), + #[prost(message, tag="10")] + Trace(super::TraceAction), + } +} +/// TaskGroup represents a group of runs for a specific task. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskGroup { + /// Task name. + #[prost(string, tag="1")] + pub task_name: ::prost::alloc::string::String, + /// Environment name. + #[prost(string, tag="2")] + pub environment_name: ::prost::alloc::string::String, + /// Total number of runs for this task. + #[prost(int64, tag="3")] + pub total_runs: i64, + /// Timestamp of the most recent run. + #[prost(message, optional, tag="4")] + pub latest_run_time: ::core::option::Option, + /// Recent run statuses, ordered from newest to oldest. Number of statuses determined by request. + #[prost(message, repeated, tag="5")] + pub recent_statuses: ::prost::alloc::vec::Vec, + /// Average failure rate of runs in this group (0.0 to 1.0). + /// Computed as number of root actions with phase FAILED divided by total root actions. + #[prost(double, tag="6")] + pub average_failure_rate: f64, + /// Average duration of runs in this group. + #[prost(message, optional, tag="7")] + pub average_duration: ::core::option::Option, + /// Timestamp of the most recent finished run (terminal phase). + #[prost(message, optional, tag="8")] + pub latest_finished_time: ::core::option::Option, + /// List of user/application's enriched identity that created runs in this group. + #[prost(message, repeated, tag="9")] + pub created_by: ::prost::alloc::vec::Vec, + #[prost(bool, tag="10")] + pub should_delete: bool, + /// short name (function name) of the task. + #[prost(string, tag="11")] + pub short_name: ::prost::alloc::string::String, + #[prost(message, optional, tag="12")] + pub error_counts: ::core::option::Option, + #[prost(message, repeated, tag="13")] + pub phase_counts: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `TaskGroup`. +pub mod task_group { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct RecentStatus { + #[prost(string, tag="1")] + pub run_name: ::prost::alloc::string::String, + #[prost(enumeration="super::super::common::ActionPhase", tag="2")] + pub phase: i32, + } + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] + pub struct ErrorCounts { + #[prost(int64, tag="1")] + pub user_error: i64, + #[prost(int64, tag="2")] + pub system_error: i64, + #[prost(int64, tag="3")] + pub unspecified_error: i64, + } + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] + pub struct PhaseCounts { + #[prost(enumeration="super::super::common::ActionPhase", tag="1")] + pub phase: i32, + #[prost(int64, tag="2")] + pub count: i64, + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ActionType { + Unspecified = 0, + Task = 1, + Trace = 2, + Condition = 3, +} +impl ActionType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ActionType::Unspecified => "ACTION_TYPE_UNSPECIFIED", + ActionType::Task => "ACTION_TYPE_TASK", + ActionType::Trace => "ACTION_TYPE_TRACE", + ActionType::Condition => "ACTION_TYPE_CONDITION", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ACTION_TYPE_UNSPECIFIED" => Some(Self::Unspecified), + "ACTION_TYPE_TASK" => Some(Self::Task), + "ACTION_TYPE_TRACE" => Some(Self::Trace), + "ACTION_TYPE_CONDITION" => Some(Self::Condition), + _ => None, + } + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum RunSource { + Unspecified = 0, + Web = 1, + Cli = 2, + ScheduleTrigger = 3, +} +impl RunSource { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + RunSource::Unspecified => "RUN_SOURCE_UNSPECIFIED", + RunSource::Web => "RUN_SOURCE_WEB", + RunSource::Cli => "RUN_SOURCE_CLI", + RunSource::ScheduleTrigger => "RUN_SOURCE_SCHEDULE_TRIGGER", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "RUN_SOURCE_UNSPECIFIED" => Some(Self::Unspecified), + "RUN_SOURCE_WEB" => Some(Self::Web), + "RUN_SOURCE_CLI" => Some(Self::Cli), + "RUN_SOURCE_SCHEDULE_TRIGGER" => Some(Self::ScheduleTrigger), + _ => None, + } + } +} +/// request message for queuing an action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EnqueueActionRequest { + /// the unique identifier for the action. + #[prost(message, optional, tag="1")] + pub action_id: ::core::option::Option, + /// an optional name for the parent action, if it exists. the remaining run metadata (ex. org, + /// project, domain) will be the same as the action_id defined above. + #[prost(string, optional, tag="2")] + pub parent_action_name: ::core::option::Option<::prost::alloc::string::String>, + /// Optional run spec passed in by the root action to be utilized by all downstream actions in the run. + #[prost(message, optional, tag="3")] + pub run_spec: ::core::option::Option, + /// the path to the input data for this action. + #[prost(string, tag="6")] + pub input_uri: ::prost::alloc::string::String, + /// the run base path this action should write its output to. + #[prost(string, tag="7")] + pub run_output_base: ::prost::alloc::string::String, + /// group this action belongs to, if applicable. + #[prost(string, tag="8")] + pub group: ::prost::alloc::string::String, + /// subject that created the run, if known. + #[prost(string, tag="9")] + pub subject: ::prost::alloc::string::String, + #[prost(oneof="enqueue_action_request::Spec", tags="10, 11, 12")] + pub spec: ::core::option::Option, +} +/// Nested message and enum types in `EnqueueActionRequest`. +pub mod enqueue_action_request { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Spec { + #[prost(message, tag="10")] + Task(super::TaskAction), + #[prost(message, tag="11")] + Trace(super::TraceAction), + #[prost(message, tag="12")] + Condition(super::ConditionAction), + } +} +/// response message for queuing an action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct EnqueueActionResponse { +} +/// request message for aborting a run. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AbortQueuedRunRequest { + /// the unique identifier for the run to be aborted. + #[prost(message, optional, tag="1")] + pub run_id: ::core::option::Option, + /// Reason for aborting the run, if applicable. + #[prost(string, optional, tag="2")] + pub reason: ::core::option::Option<::prost::alloc::string::String>, +} +/// response message for aborting a run. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct AbortQueuedRunResponse { +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AbortQueuedActionRequest { + /// ActionId is the unique identifier for the action to be aborted + #[prost(message, optional, tag="1")] + pub action_id: ::core::option::Option, + /// Reason for aborting the action, if applicable. + #[prost(string, optional, tag="2")] + pub reason: ::core::option::Option<::prost::alloc::string::String>, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct AbortQueuedActionResponse { +} +/// Request message for tailing logs. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TailLogsRequest { + /// The action id. + #[prost(message, optional, tag="1")] + pub action_id: ::core::option::Option, + /// The attempt number. + #[prost(uint32, tag="2")] + pub attempt: u32, +} +/// Reponse message for tailing logs. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TailLogsResponse { + /// One or more batches of logs. + #[prost(message, repeated, tag="1")] + pub logs: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `TailLogsResponse`. +pub mod tail_logs_response { + /// A batch of logs. + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Logs { + /// Structured log lines. + #[prost(message, repeated, tag="1")] + pub lines: ::prost::alloc::vec::Vec, + } +} +/// Request message for creating a run. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateRunRequest { + /// Inputs to use. + #[prost(message, optional, tag="4")] + pub inputs: ::core::option::Option, + /// The run spec to use. + #[prost(message, optional, tag="5")] + pub run_spec: ::core::option::Option, + /// Indicates client that created this run. + #[prost(enumeration="RunSource", tag="8")] + pub source: i32, + #[prost(oneof="create_run_request::Id", tags="1, 6")] + pub id: ::core::option::Option, + /// The task to run. + #[prost(oneof="create_run_request::Task", tags="2, 3, 7")] + pub task: ::core::option::Option, +} +/// Nested message and enum types in `CreateRunRequest`. +pub mod create_run_request { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Id { + /// The user provided run id. + #[prost(message, tag="1")] + RunId(super::super::common::RunIdentifier), + /// The project id for this run. Run name will be generated. + #[prost(message, tag="6")] + ProjectId(super::super::common::ProjectIdentifier), + } + /// The task to run. + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Task { + /// The task id to use. + #[prost(message, tag="2")] + TaskId(super::super::task::TaskIdentifier), + /// The task spec to use. + #[prost(message, tag="3")] + TaskSpec(super::super::task::TaskSpec), + /// The trigger name to use. + #[prost(message, tag="7")] + TriggerName(super::super::common::TriggerName), + } +} +/// Response message for creating a run. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateRunResponse { + #[prost(message, optional, tag="1")] + pub run: ::core::option::Option, +} +/// Request message for aborting a run. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AbortRunRequest { + /// Run to abort. + #[prost(message, optional, tag="1")] + pub run_id: ::core::option::Option, + /// Reason for aborting the run. if applicable. + #[prost(string, optional, tag="2")] + pub reason: ::core::option::Option<::prost::alloc::string::String>, +} +/// Response message for aborting a run. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct AbortRunResponse { +} +/// Request message for getting detailed information about a run. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetRunDetailsRequest { + /// Run to query. + #[prost(message, optional, tag="1")] + pub run_id: ::core::option::Option, +} +/// Response message for getting detailed information about a run. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetRunDetailsResponse { + /// Detailed information about the run. + #[prost(message, optional, tag="1")] + pub details: ::core::option::Option, +} +/// Request message for watching detailed information about a run. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchRunDetailsRequest { + /// Run to query. + #[prost(message, optional, tag="1")] + pub run_id: ::core::option::Option, +} +/// Response message for watching detailed information about a run. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchRunDetailsResponse { + /// Detailed information about the run. + #[prost(message, optional, tag="1")] + pub details: ::core::option::Option, +} +/// Request message for getting detailed information about an action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetActionDetailsRequest { + /// Action to query. + #[prost(message, optional, tag="1")] + pub action_id: ::core::option::Option, +} +/// Response message for getting detailed information about an action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetActionDetailsResponse { + /// Detailed information about the action. + #[prost(message, optional, tag="1")] + pub details: ::core::option::Option, +} +/// Request message for watching detailed information about an action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchActionDetailsRequest { + /// Action to query. + #[prost(message, optional, tag="1")] + pub action_id: ::core::option::Option, +} +/// Response message for watching detailed information about an action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchActionDetailsResponse { + /// Detailed information about the action. + #[prost(message, optional, tag="1")] + pub details: ::core::option::Option, +} +/// Request message for querying action data. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetActionDataRequest { + /// Action to query. + #[prost(message, optional, tag="1")] + pub action_id: ::core::option::Option, +} +/// Response message for querying action data. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetActionDataResponse { + /// Inputs for the action. + #[prost(message, optional, tag="1")] + pub inputs: ::core::option::Option, + /// Outputs for the action. + #[prost(message, optional, tag="2")] + pub outputs: ::core::option::Option, +} +/// Request message for listing runs. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListRunsRequest { + /// Common list request parameters. + #[prost(message, optional, tag="1")] + pub request: ::core::option::Option, + #[prost(oneof="list_runs_request::ScopeBy", tags="2, 4, 6, 7, 8")] + pub scope_by: ::core::option::Option, +} +/// Nested message and enum types in `ListRunsRequest`. +pub mod list_runs_request { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum ScopeBy { + /// Organization name for filtering runs. + #[prost(string, tag="2")] + Org(::prost::alloc::string::String), + /// Project identifier for filtering runs. + #[prost(message, tag="4")] + ProjectId(super::super::common::ProjectIdentifier), + /// List runs created from a trigger. + #[prost(message, tag="6")] + TriggerName(super::super::common::TriggerName), + /// Task name for filtering runs + #[prost(message, tag="7")] + TaskName(super::super::task::TaskName), + /// Task identifier for filtering runs + #[prost(message, tag="8")] + TaskId(super::super::task::TaskIdentifier), + } +} +/// Response message for listing runs. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListRunsResponse { + /// List of runs matching the filter criteria. + #[prost(message, repeated, tag="1")] + pub runs: ::prost::alloc::vec::Vec, + /// Token for fetching the next page of results, if any. + #[prost(string, tag="2")] + pub token: ::prost::alloc::string::String, +} +/// Request message for watching runs. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchRunsRequest { + #[prost(oneof="watch_runs_request::Target", tags="2, 3, 4, 5")] + pub target: ::core::option::Option, +} +/// Nested message and enum types in `WatchRunsRequest`. +pub mod watch_runs_request { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Target { + /// Organization name for filtering runs. + #[prost(string, tag="2")] + Org(::prost::alloc::string::String), + /// Cluster identifier for filtering runs. + #[prost(message, tag="3")] + ClusterId(super::super::common::ClusterIdentifier), + /// Project identifier for filtering runs. + #[prost(message, tag="4")] + ProjectId(super::super::common::ProjectIdentifier), + /// Task identifier for filtering runs. + #[prost(message, tag="5")] + TaskId(super::super::task::TaskIdentifier), + } +} +/// Response message for watching runs. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchRunsResponse { + /// New or updated runs matching the filter criteria. + #[prost(message, repeated, tag="1")] + pub runs: ::prost::alloc::vec::Vec, +} +/// Request message for listing actions. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListActionsRequest { + /// Common list request parameters. + #[prost(message, optional, tag="1")] + pub request: ::core::option::Option, + /// Run identifier for filtering actions. + #[prost(message, optional, tag="2")] + pub run_id: ::core::option::Option, +} +/// Response message for listing actions. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListActionsResponse { + /// List of actions matching the filter criteria. + #[prost(message, repeated, tag="1")] + pub actions: ::prost::alloc::vec::Vec, + /// Token for fetching the next page of results, if any. + #[prost(string, tag="2")] + pub token: ::prost::alloc::string::String, +} +/// Request message for watching actions. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchActionsRequest { + /// Run identifier for filtering actions. + #[prost(message, optional, tag="1")] + pub run_id: ::core::option::Option, + /// Optional filter(s) criteria for actions. + /// Valid filter fields include: + /// - NAME (must use function CONTAINS_CASE_INSENSITIVE): the value is whatever string to match to. This will cast all strings to lowercase and match. + /// - PHASE (must use function VALUE_IN): the value is the stringified integer of the enum of the phase and you can pass multiple phases (i.e. \["1", "4"\]) + #[prost(message, repeated, tag="2")] + pub filter: ::prost::alloc::vec::Vec, +} +/// Response message for watching actions, comes with enriched action metadata. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchActionsResponse { + /// New or updated actions matching the filter criteria. Enriched with children status counts + #[prost(message, repeated, tag="1")] + pub enriched_actions: ::prost::alloc::vec::Vec, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchClusterEventsRequest { + #[prost(message, optional, tag="1")] + pub id: ::core::option::Option, + #[prost(uint32, tag="2")] + pub attempt: u32, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchClusterEventsResponse { + #[prost(message, repeated, tag="1")] + pub cluster_events: ::prost::alloc::vec::Vec, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AbortActionRequest { + /// Action to abort. + #[prost(message, optional, tag="1")] + pub action_id: ::core::option::Option, + /// Optional reason for aborting the action. + #[prost(string, tag="2")] + pub reason: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct AbortActionResponse { +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchGroupsRequest { + /// Filter groups after this date (inclusive). Required. + #[prost(message, optional, tag="2")] + pub start_date: ::core::option::Option, + /// Filter groups before this date (inclusive). + /// If null, will stream updates up to current time. + /// If not null, will return groups once and close stream. + #[prost(message, optional, tag="3")] + pub end_date: ::core::option::Option, + /// Common list request parameters. + #[prost(message, optional, tag="4")] + pub request: ::core::option::Option, + /// Known sort fields in watch group + #[prost(message, repeated, tag="5")] + pub known_sort_fields: ::prost::alloc::vec::Vec, + #[prost(oneof="watch_groups_request::ScopeBy", tags="1")] + pub scope_by: ::core::option::Option, +} +/// Nested message and enum types in `WatchGroupsRequest`. +pub mod watch_groups_request { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] + pub struct KnownSortField { + #[prost(oneof="known_sort_field::SortBy", tags="1")] + pub sort_by: ::core::option::Option, + } + /// Nested message and enum types in `KnownSortField`. + pub mod known_sort_field { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Oneof)] + pub enum SortBy { + #[prost(enumeration="super::super::super::common::sort::Direction", tag="1")] + CreatedAt(i32), + } + } + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum ScopeBy { + /// Watch groups within a project. + #[prost(message, tag="1")] + ProjectId(super::super::common::ProjectIdentifier), + } +} +/// Response message for watching task groups. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchGroupsResponse { + /// List of task groups matching the filter criteria. + /// For the initial response, this contains all groups. + /// For subsequent updates, this contains only changed groups. + #[prost(message, repeated, tag="1")] + pub task_groups: ::prost::alloc::vec::Vec, + /// Indicates when the initial List call is complete, and subsequent messages are updates. + #[prost(bool, tag="2")] + pub sentinel: bool, +} +/// request message to put the state of an action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PutRequest { + /// a unique identifier for the action. + #[prost(message, optional, tag="1")] + pub action_id: ::core::option::Option, + /// optional name of the parent action if this is a nested action. + #[prost(string, optional, tag="2")] + pub parent_action_name: ::core::option::Option<::prost::alloc::string::String>, + /// currently we will store state as a json serialized `NodeStatus` object. this will be required + /// to seamlessly integrate with existing FlytePropeller node execution logic. we can update this + /// to be a subset of fields in the future if there are necessary performance improvements. + #[prost(string, tag="3")] + pub state: ::prost::alloc::string::String, +} +/// response message for putting the state of an action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PutResponse { + /// a unique identifier for the action. + #[prost(message, optional, tag="1")] + pub action_id: ::core::option::Option, + /// The result. + #[prost(message, optional, tag="2")] + pub status: ::core::option::Option, +} +/// request message to get the state of an action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetRequest { + /// a unique identifier for the action. + #[prost(message, optional, tag="1")] + pub action_id: ::core::option::Option, +} +/// response message for getting the state of an action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetResponse { + /// a unique identifier for the action. + #[prost(message, optional, tag="1")] + pub action_id: ::core::option::Option, + /// + /// The result. + #[prost(message, optional, tag="2")] + pub status: ::core::option::Option, + /// a json serialized `NodeStatus` object. + #[prost(string, tag="3")] + pub state: ::prost::alloc::string::String, +} +/// request message for watching updates to the state of actions. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchRequest { + /// criteria for filtering which actions to watch. + #[prost(oneof="watch_request::Filter", tags="1")] + pub filter: ::core::option::Option, +} +/// Nested message and enum types in `WatchRequest`. +pub mod watch_request { + /// criteria for filtering which actions to watch. + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Filter { + /// a unique identifier for the parent action to watch. this will result in updates for all child + /// actions. + #[prost(message, tag="1")] + ParentActionId(super::super::common::ActionIdentifier), + } +} +/// response message for watching updates to the state of actions. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchResponse { + /// an update to the state of a specific action. + #[prost(oneof="watch_response::Message", tags="1, 2")] + pub message: ::core::option::Option, +} +/// Nested message and enum types in `WatchResponse`. +pub mod watch_response { + /// an update to the state of a specific action. + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Message { + #[prost(message, tag="1")] + ActionUpdate(super::ActionUpdate), + #[prost(message, tag="2")] + ControlMessage(super::ControlMessage), + } +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct ControlMessage { + /// a sentinel value to indicate the end of a stream. this is used to disambiguate between a control message and a + /// regular message. When a watch begins the service will return the existing state of all actions, then a sentinel value, + /// before continuing on with ongoing updates. this sequence disambiguates the current state from new updates. + #[prost(bool, tag="1")] + pub sentinel: bool, +} +/// message to represent an update to the state of an action. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ActionUpdate { + /// A unique identifier for the action. `nil` is used as a sentinel value; for example, + #[prost(message, optional, tag="1")] + pub action_id: ::core::option::Option, + /// the current phase of the action. + #[prost(enumeration="super::common::ActionPhase", tag="2")] + pub phase: i32, + /// the error associated with the action (if exists). + #[prost(message, optional, tag="3")] + pub error: ::core::option::Option, + /// the output uri for the action + #[prost(string, tag="4")] + pub output_uri: ::prost::alloc::string::String, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LiteralsToLaunchFormJsonRequest { + /// The literals to convert to JSON. + #[prost(message, repeated, tag="1")] + pub literals: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="2")] + pub variables: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LiteralsToLaunchFormJsonResponse { + /// The JSON for the literals. + #[prost(message, optional, tag="1")] + pub json: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LaunchFormJsonToLiteralsRequest { + /// The JSON schema to convert to literals. + #[prost(message, optional, tag="1")] + pub json: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LaunchFormJsonToLiteralsResponse { + /// The literals generated from the JSON schema. + #[prost(message, repeated, tag="1")] + pub literals: ::prost::alloc::vec::Vec, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskSpecToLaunchFormJsonRequest { + /// The task spec to convert to JSON. + /// Merges the VariableMap and the default inputs + #[prost(message, optional, tag="1")] + pub task_spec: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TaskSpecToLaunchFormJsonResponse { + /// The JSON for the variables. + #[prost(message, optional, tag="1")] + pub json: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct JsonValuesToLiteralsRequest { + /// The type definitions (VariableMap) describing the expected structure. + #[prost(message, optional, tag="1")] + pub variables: ::core::option::Option, + /// The raw JSON values to convert to literals. + #[prost(message, optional, tag="2")] + pub values: ::core::option::Option, +} +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct JsonValuesToLiteralsResponse { + /// The literals generated from the JSON values using the type definitions. + #[prost(message, repeated, tag="1")] + pub literals: ::prost::alloc::vec::Vec, +} +/// Encoded file descriptor set for the `flyteidl2.workflow` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xd0, 0xc0, 0x01, 0x0a, 0x27, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x72, 0x75, 0x6e, 0x5f, 0x64, 0x65, 0x66, + 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x1f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x1c, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x70, 0x68, 0x61, 0x73, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x1c, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1a, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, + 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x18, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x72, 0x75, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x24, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, + 0x6b, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, + 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x39, 0x0a, 0x03, 0x52, 0x75, 0x6e, 0x12, + 0x32, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x06, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x22, 0x7b, 0x0a, 0x0a, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x12, 0x32, 0x0a, 0x08, 0x72, 0x75, 0x6e, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x52, 0x75, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x52, 0x07, 0x72, 0x75, + 0x6e, 0x53, 0x70, 0x65, 0x63, 0x12, 0x39, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x22, 0xc7, 0x01, 0x0a, 0x0a, 0x54, 0x61, 0x73, 0x6b, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x2e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, + 0x6b, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x02, 0x69, 0x64, 0x12, + 0x34, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, + 0x61, 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, + 0x04, 0x73, 0x70, 0x65, 0x63, 0x12, 0x39, 0x0a, 0x09, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x6b, + 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, + 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x08, 0x63, 0x61, 0x63, 0x68, 0x65, 0x4b, 0x65, 0x79, + 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x22, 0xd6, 0x02, 0x0a, 0x0b, 0x54, + 0x72, 0x61, 0x63, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, + 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x33, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x50, 0x68, 0x61, 0x73, 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x0a, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x3a, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, + 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x48, 0x00, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, + 0x88, 0x01, 0x01, 0x12, 0x3a, 0x0a, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x52, 0x65, 0x66, 0x65, + 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x12, + 0x35, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, + 0x72, 0x61, 0x63, 0x65, 0x53, 0x70, 0x65, 0x63, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, + 0x52, 0x04, 0x73, 0x70, 0x65, 0x63, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x74, + 0x69, 0x6d, 0x65, 0x22, 0x8d, 0x02, 0x0a, 0x0f, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, + 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x12, 0x26, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, + 0x10, 0x01, 0x48, 0x00, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x18, + 0x0a, 0x06, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, + 0x52, 0x06, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x12, 0x2f, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x54, + 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x72, 0x6f, + 0x6d, 0x70, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x72, 0x6f, 0x6d, 0x70, + 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x42, 0x0e, 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x05, 0xba, 0x48, + 0x02, 0x08, 0x01, 0x22, 0x80, 0x01, 0x0a, 0x12, 0x54, 0x61, 0x73, 0x6b, 0x41, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x2e, 0x0a, 0x02, 0x69, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x61, + 0x73, 0x6b, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x74, + 0x61, 0x73, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x68, 0x6f, 0x72, 0x74, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x68, 0x6f, + 0x72, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x29, 0x0a, 0x13, 0x54, 0x72, 0x61, 0x63, 0x65, 0x41, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x12, 0x0a, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x22, 0xa1, 0x01, 0x0a, 0x17, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x41, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x12, 0x0a, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x12, 0x20, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, 0x05, 0x72, 0x75, + 0x6e, 0x49, 0x64, 0x12, 0x26, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x48, + 0x00, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x18, 0x0a, 0x06, 0x67, + 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x06, 0x67, + 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x42, 0x0e, 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x05, + 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, 0xce, 0x05, 0x0a, 0x0e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x65, + 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, + 0x12, 0x14, 0x0a, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x43, 0x0a, 0x0b, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x45, + 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, + 0x0a, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x42, 0x79, 0x12, 0x3c, 0x0a, 0x04, 0x74, + 0x61, 0x73, 0x6b, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, + 0x61, 0x73, 0x6b, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x48, 0x00, 0x52, 0x04, 0x74, 0x61, 0x73, 0x6b, 0x12, 0x3f, 0x0a, 0x05, 0x74, 0x72, 0x61, + 0x63, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x72, + 0x61, 0x63, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x48, 0x00, 0x52, 0x05, 0x74, 0x72, 0x61, 0x63, 0x65, 0x12, 0x4b, 0x0a, 0x09, 0x63, 0x6f, + 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x2e, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, 0x09, 0x63, 0x6f, + 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3f, 0x0a, 0x0b, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1e, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, 0x61, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x42, 0x0a, 0x0a, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x52, 0x09, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x49, 0x64, 0x12, 0x29, 0x0a, 0x10, + 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, + 0x65, 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x66, 0x75, 0x6e, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x66, + 0x75, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0b, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x48, 0x0a, + 0x0c, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0f, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x41, 0x75, 0x74, 0x6f, + 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0b, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x35, 0x0a, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x52, 0x75, 0x6e, + 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x42, 0x06, + 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x22, 0xe9, 0x02, 0x0a, 0x0c, 0x41, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x33, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x50, 0x68, 0x61, 0x73, 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x0a, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x3a, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, + 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x48, 0x00, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, + 0x88, 0x01, 0x01, 0x12, 0x23, 0x0a, 0x08, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, 0x02, 0x20, 0x00, 0x52, 0x08, + 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x12, 0x45, 0x0a, 0x0c, 0x63, 0x61, 0x63, 0x68, + 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x43, 0x61, 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x52, 0x0b, 0x63, 0x61, 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, + 0x24, 0x0a, 0x0b, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x73, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x04, 0x48, 0x01, 0x52, 0x0a, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x4d, 0x73, 0x88, 0x01, 0x01, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, + 0x6d, 0x65, 0x42, 0x0e, 0x0a, 0x0c, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x6d, 0x73, 0x22, 0xb6, 0x01, 0x0a, 0x06, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x32, 0x0a, + 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x02, 0x69, + 0x64, 0x12, 0x3e, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x12, 0x38, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0xa0, 0x02, 0x0a, 0x0e, + 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x32, + 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x65, 0x65, 0x74, 0x73, 0x5f, 0x66, 0x69, 0x6c, 0x74, + 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x6d, 0x65, 0x65, 0x74, 0x73, 0x46, + 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x6f, 0x0a, 0x15, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, + 0x6e, 0x5f, 0x70, 0x68, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, + 0x65, 0x64, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, + 0x6e, 0x50, 0x68, 0x61, 0x73, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x52, 0x13, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x50, 0x68, 0x61, 0x73, 0x65, + 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x1a, 0x46, 0x0a, 0x18, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x72, + 0x65, 0x6e, 0x50, 0x68, 0x61, 0x73, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x9b, + 0x01, 0x0a, 0x09, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x18, 0x0a, 0x07, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x36, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x49, + 0x6e, 0x66, 0x6f, 0x2e, 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x22, 0x3c, + 0x0a, 0x04, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x14, 0x0a, 0x10, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x55, + 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, + 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x55, 0x53, 0x45, 0x52, 0x10, 0x01, 0x12, 0x0f, 0x0a, 0x0b, 0x4b, + 0x49, 0x4e, 0x44, 0x5f, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x10, 0x02, 0x22, 0x66, 0x0a, 0x09, + 0x41, 0x62, 0x6f, 0x72, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, + 0x73, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, + 0x6e, 0x12, 0x41, 0x0a, 0x0a, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, + 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x09, 0x61, 0x62, 0x6f, 0x72, 0x74, + 0x65, 0x64, 0x42, 0x79, 0x22, 0xf1, 0x03, 0x0a, 0x0d, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x32, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3e, 0x0a, 0x08, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x38, 0x0a, 0x06, 0x73, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, + 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x12, 0x3e, 0x0a, 0x0a, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x69, 0x6e, + 0x66, 0x6f, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x45, 0x72, + 0x72, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x48, 0x00, 0x52, 0x09, 0x65, 0x72, 0x72, 0x6f, 0x72, + 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3e, 0x0a, 0x0a, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x5f, 0x69, 0x6e, + 0x66, 0x6f, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x62, + 0x6f, 0x72, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x48, 0x00, 0x52, 0x09, 0x61, 0x62, 0x6f, 0x72, 0x74, + 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2e, 0x0a, 0x04, 0x74, 0x61, 0x73, 0x6b, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, + 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x48, 0x01, 0x52, 0x04, + 0x74, 0x61, 0x73, 0x6b, 0x12, 0x31, 0x0a, 0x05, 0x74, 0x72, 0x61, 0x63, 0x65, 0x18, 0x08, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x72, 0x61, 0x63, 0x65, 0x53, 0x70, 0x65, 0x63, 0x48, 0x01, + 0x52, 0x05, 0x74, 0x72, 0x61, 0x63, 0x65, 0x12, 0x3d, 0x0a, 0x08, 0x61, 0x74, 0x74, 0x65, 0x6d, + 0x70, 0x74, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x52, 0x08, 0x61, 0x74, + 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x42, 0x08, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x42, 0x06, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x22, 0x8d, 0x06, 0x0a, 0x0d, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x12, 0x33, 0x0a, 0x05, 0x70, 0x68, + 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x50, 0x68, 0x61, 0x73, 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, + 0x39, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, + 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x3a, 0x0a, 0x08, 0x65, 0x6e, + 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x48, 0x00, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, + 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, 0x41, 0x0a, 0x0a, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, + 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, + 0x45, 0x72, 0x72, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x48, 0x01, 0x52, 0x09, 0x65, 0x72, 0x72, + 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x88, 0x01, 0x01, 0x12, 0x21, 0x0a, 0x07, 0x61, 0x74, 0x74, + 0x65, 0x6d, 0x70, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, + 0x02, 0x20, 0x00, 0x52, 0x07, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x12, 0x32, 0x0a, 0x08, + 0x6c, 0x6f, 0x67, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x54, 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x52, 0x07, 0x6c, 0x6f, 0x67, 0x49, 0x6e, 0x66, 0x6f, + 0x12, 0x3a, 0x0a, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, + 0x73, 0x6b, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, + 0x63, 0x65, 0x73, 0x52, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x12, 0x25, 0x0a, 0x0e, + 0x6c, 0x6f, 0x67, 0x73, 0x5f, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x6c, 0x6f, 0x67, 0x73, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, + 0x62, 0x6c, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x61, 0x74, 0x61, 0x6c, + 0x6f, 0x67, 0x43, 0x61, 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x0b, 0x63, + 0x61, 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x47, 0x0a, 0x0e, 0x63, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x0a, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, + 0x76, 0x65, 0x6e, 0x74, 0x52, 0x0d, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, 0x76, 0x65, + 0x6e, 0x74, 0x73, 0x12, 0x50, 0x0a, 0x11, 0x70, 0x68, 0x61, 0x73, 0x65, 0x5f, 0x74, 0x72, 0x61, + 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2e, 0x50, 0x68, 0x61, 0x73, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x10, 0x70, 0x68, 0x61, 0x73, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, + 0x3b, 0x0a, 0x0b, 0x6c, 0x6f, 0x67, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x0d, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, + 0x52, 0x0a, 0x6c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x42, 0x0b, 0x0a, 0x09, + 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x65, 0x72, + 0x72, 0x6f, 0x72, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x22, 0x65, 0x0a, 0x0c, 0x43, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x3b, 0x0a, 0x0b, 0x6f, 0x63, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0a, 0x6f, 0x63, 0x63, 0x75, 0x72, + 0x72, 0x65, 0x64, 0x41, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, + 0xca, 0x01, 0x0a, 0x0f, 0x50, 0x68, 0x61, 0x73, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x33, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x68, 0x61, 0x73, + 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, + 0x69, 0x6d, 0x65, 0x12, 0x3a, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x48, 0x00, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x42, + 0x0b, 0x0a, 0x09, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x22, 0xf0, 0x06, 0x0a, + 0x0b, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x3a, 0x0a, 0x02, + 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, + 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0x21, 0x0a, 0x07, 0x61, 0x74, 0x74, 0x65, + 0x6d, 0x70, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, 0x02, + 0x20, 0x00, 0x52, 0x07, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x12, 0x33, 0x0a, 0x05, 0x70, + 0x68, 0x61, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x68, 0x61, 0x73, 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, + 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x3d, 0x0a, 0x0a, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x02, 0x18, 0x01, 0x52, 0x09, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x3d, 0x0a, 0x0c, 0x75, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0b, 0x75, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x3e, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, + 0x74, 0x69, 0x6d, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x02, 0x18, 0x01, 0x48, 0x00, 0x52, 0x07, 0x65, 0x6e, + 0x64, 0x54, 0x69, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, 0x41, 0x0a, 0x0a, 0x65, 0x72, 0x72, 0x6f, + 0x72, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x48, 0x01, 0x52, 0x09, 0x65, + 0x72, 0x72, 0x6f, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x88, 0x01, 0x01, 0x12, 0x32, 0x0a, 0x08, 0x6c, + 0x6f, 0x67, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x54, + 0x61, 0x73, 0x6b, 0x4c, 0x6f, 0x67, 0x52, 0x07, 0x6c, 0x6f, 0x67, 0x49, 0x6e, 0x66, 0x6f, 0x12, + 0x3b, 0x0a, 0x0b, 0x6c, 0x6f, 0x67, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x0a, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x4c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, + 0x52, 0x0a, 0x6c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x18, 0x0a, 0x07, + 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, 0x3a, 0x0a, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, + 0x73, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x52, + 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x73, 0x12, 0x45, 0x0a, 0x0c, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, + 0x67, 0x43, 0x61, 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x0b, 0x63, 0x61, + 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x47, 0x0a, 0x0e, 0x63, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x0e, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, 0x76, + 0x65, 0x6e, 0x74, 0x52, 0x0d, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, + 0x74, 0x73, 0x12, 0x3f, 0x0a, 0x0d, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x74, + 0x69, 0x6d, 0x65, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0c, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x54, + 0x69, 0x6d, 0x65, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, + 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x22, + 0x83, 0x04, 0x0a, 0x0a, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x12, 0x47, + 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x31, 0x0a, 0x12, 0x70, 0x61, 0x72, 0x65, 0x6e, + 0x74, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x10, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, 0x32, 0x0a, 0x08, 0x72, 0x75, + 0x6e, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x52, 0x75, + 0x6e, 0x53, 0x70, 0x65, 0x63, 0x52, 0x07, 0x72, 0x75, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x12, 0x24, + 0x0a, 0x09, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x08, 0x69, 0x6e, 0x70, 0x75, + 0x74, 0x55, 0x72, 0x69, 0x12, 0x2f, 0x0a, 0x0f, 0x72, 0x75, 0x6e, 0x5f, 0x6f, 0x75, 0x74, 0x70, + 0x75, 0x74, 0x5f, 0x62, 0x61, 0x73, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, + 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x0d, 0x72, 0x75, 0x6e, 0x4f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x42, 0x61, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x04, 0x74, 0x61, 0x73, 0x6b, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x04, 0x74, 0x61, 0x73, 0x6b, 0x12, 0x43, 0x0a, 0x09, 0x63, + 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2e, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x09, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x37, 0x0a, 0x05, 0x74, 0x72, 0x61, 0x63, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x72, 0x61, 0x63, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x48, 0x00, 0x52, 0x05, 0x74, 0x72, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x42, + 0x0d, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x42, 0x15, + 0x0a, 0x13, 0x5f, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0xac, 0x08, 0x0a, 0x09, 0x54, 0x61, 0x73, 0x6b, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x74, 0x61, 0x73, 0x6b, 0x4e, 0x61, 0x6d, 0x65, + 0x12, 0x29, 0x0a, 0x10, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x65, 0x6e, 0x76, 0x69, + 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x74, + 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x72, 0x75, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x09, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x52, 0x75, 0x6e, 0x73, 0x12, 0x42, 0x0a, 0x0f, 0x6c, 0x61, + 0x74, 0x65, 0x73, 0x74, 0x5f, 0x72, 0x75, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, + 0x0d, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x52, 0x75, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x53, + 0x0a, 0x0f, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x65, + 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x61, 0x73, + 0x6b, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x52, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x52, 0x0e, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x65, 0x73, 0x12, 0x30, 0x0a, 0x14, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x66, + 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x01, 0x52, 0x12, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, + 0x65, 0x52, 0x61, 0x74, 0x65, 0x12, 0x44, 0x0a, 0x10, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, + 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0f, 0x61, 0x76, 0x65, 0x72, + 0x61, 0x67, 0x65, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x4c, 0x0a, 0x14, 0x6c, + 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x66, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x5f, 0x74, + 0x69, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x12, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x46, 0x69, 0x6e, + 0x69, 0x73, 0x68, 0x65, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x41, 0x0a, 0x0a, 0x63, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x79, 0x12, 0x23, 0x0a, 0x0d, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x18, 0x0a, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x0c, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x44, 0x65, 0x6c, 0x65, 0x74, + 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x4e, 0x61, 0x6d, 0x65, + 0x12, 0x4c, 0x0a, 0x0c, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, + 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x61, 0x73, 0x6b, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, + 0x73, 0x52, 0x0b, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x12, 0x4c, + 0x0a, 0x0c, 0x70, 0x68, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, 0x0d, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x2e, 0x50, 0x68, 0x61, 0x73, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x52, + 0x0b, 0x70, 0x68, 0x61, 0x73, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x1a, 0x5e, 0x0a, 0x0c, + 0x52, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x19, 0x0a, 0x08, + 0x72, 0x75, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x72, 0x75, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x33, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x50, 0x68, 0x61, 0x73, 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x1a, 0x7c, 0x0a, 0x0b, + 0x45, 0x72, 0x72, 0x6f, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x75, + 0x73, 0x65, 0x72, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x09, 0x75, 0x73, 0x65, 0x72, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x79, + 0x73, 0x74, 0x65, 0x6d, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x0b, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x2b, 0x0a, + 0x11, 0x75, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x65, 0x72, 0x72, + 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x75, 0x6e, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x64, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x1a, 0x58, 0x0a, 0x0b, 0x50, 0x68, + 0x61, 0x73, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x12, 0x33, 0x0a, 0x05, 0x70, 0x68, 0x61, + 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x50, 0x68, 0x61, 0x73, 0x65, 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x14, + 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x63, + 0x6f, 0x75, 0x6e, 0x74, 0x2a, 0x71, 0x0a, 0x0a, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x1b, 0x0a, 0x17, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x54, 0x59, 0x50, + 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, + 0x14, 0x0a, 0x10, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x54, + 0x41, 0x53, 0x4b, 0x10, 0x01, 0x12, 0x15, 0x0a, 0x11, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, + 0x54, 0x59, 0x50, 0x45, 0x5f, 0x54, 0x52, 0x41, 0x43, 0x45, 0x10, 0x02, 0x12, 0x19, 0x0a, 0x15, + 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, 0x4f, 0x4e, 0x44, + 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x03, 0x2a, 0x70, 0x0a, 0x09, 0x52, 0x75, 0x6e, 0x53, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x12, 0x1a, 0x0a, 0x16, 0x52, 0x55, 0x4e, 0x5f, 0x53, 0x4f, 0x55, 0x52, + 0x43, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, + 0x12, 0x12, 0x0a, 0x0e, 0x52, 0x55, 0x4e, 0x5f, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x57, + 0x45, 0x42, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x52, 0x55, 0x4e, 0x5f, 0x53, 0x4f, 0x55, 0x52, + 0x43, 0x45, 0x5f, 0x43, 0x4c, 0x49, 0x10, 0x02, 0x12, 0x1f, 0x0a, 0x1b, 0x52, 0x55, 0x4e, 0x5f, + 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x53, 0x43, 0x48, 0x45, 0x44, 0x55, 0x4c, 0x45, 0x5f, + 0x54, 0x52, 0x49, 0x47, 0x47, 0x45, 0x52, 0x10, 0x03, 0x42, 0xcd, 0x01, 0x0a, 0x16, 0x63, 0x6f, + 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x12, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x36, 0x67, 0x69, 0x74, 0x68, + 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0xa2, 0x02, 0x03, 0x46, 0x57, 0x58, 0xaa, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xca, 0x02, 0x12, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0xe2, 0x02, 0x1e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x57, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0xea, 0x02, 0x13, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, + 0x3a, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x4a, 0xff, 0x80, 0x01, 0x0a, 0x07, 0x12, + 0x05, 0x00, 0x00, 0xe1, 0x03, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, + 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x1b, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, + 0x12, 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x2b, + 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, 0x29, 0x0a, 0x09, 0x0a, 0x02, 0x03, + 0x03, 0x12, 0x03, 0x07, 0x00, 0x26, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x04, 0x12, 0x03, 0x08, 0x00, + 0x26, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x05, 0x12, 0x03, 0x09, 0x00, 0x28, 0x0a, 0x09, 0x0a, 0x02, + 0x03, 0x06, 0x12, 0x03, 0x0a, 0x00, 0x24, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x07, 0x12, 0x03, 0x0b, + 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x08, 0x12, 0x03, 0x0c, 0x00, 0x22, 0x0a, 0x09, 0x0a, + 0x02, 0x03, 0x09, 0x12, 0x03, 0x0d, 0x00, 0x2e, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x0a, 0x12, 0x03, + 0x0e, 0x00, 0x28, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x0b, 0x12, 0x03, 0x0f, 0x00, 0x29, 0x0a, 0x09, + 0x0a, 0x02, 0x03, 0x0c, 0x12, 0x03, 0x10, 0x00, 0x28, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, + 0x12, 0x00, 0x4d, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x12, 0x00, 0x4d, 0x0a, 0x0a, + 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x14, 0x00, 0x17, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, + 0x01, 0x12, 0x03, 0x14, 0x08, 0x0b, 0x0a, 0x3d, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, + 0x16, 0x02, 0x14, 0x1a, 0x30, 0x20, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x77, 0x65, 0x69, 0x67, 0x68, + 0x74, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, + 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x20, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, + 0x16, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x16, 0x09, + 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x16, 0x12, 0x13, 0x0a, + 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x19, 0x00, 0x1f, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x01, 0x01, 0x12, 0x03, 0x19, 0x08, 0x12, 0x0a, 0x18, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, + 0x03, 0x1b, 0x02, 0x1c, 0x1a, 0x0b, 0x20, 0x52, 0x75, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x1b, 0x02, 0x0e, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1b, 0x0f, 0x17, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1b, 0x1a, 0x1b, 0x0a, 0x3a, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x01, 0x12, 0x03, 0x1e, 0x02, 0x1b, 0x1a, 0x2d, 0x20, 0x44, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x20, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x06, + 0x12, 0x03, 0x1e, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x1e, 0x10, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x1e, 0x19, + 0x1a, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x21, 0x00, 0x2e, 0x01, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x21, 0x08, 0x12, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x02, 0x02, + 0x00, 0x12, 0x03, 0x23, 0x02, 0x1d, 0x1a, 0x51, 0x20, 0x61, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, + 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, + 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x61, 0x70, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x23, 0x02, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x23, 0x16, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x23, 0x1b, 0x1c, 0x0a, 0x39, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x26, 0x02, 0x40, + 0x1a, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x74, 0x6f, + 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, 0x03, 0x26, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x26, 0x10, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x26, 0x17, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, + 0x08, 0x12, 0x03, 0x26, 0x19, 0x3f, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x02, 0x02, 0x01, 0x08, 0x87, + 0x09, 0x19, 0x12, 0x03, 0x26, 0x1a, 0x3e, 0x0a, 0x4f, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x02, 0x12, + 0x03, 0x29, 0x02, 0x2c, 0x1a, 0x42, 0x20, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x63, + 0x61, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x73, 0x65, 0x74, 0x20, + 0x61, 0x6e, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, + 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, + 0x06, 0x12, 0x03, 0x29, 0x02, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x29, 0x1e, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x03, 0x12, 0x03, 0x29, + 0x2a, 0x2b, 0x0a, 0x85, 0x01, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, 0x2d, 0x02, 0x15, + 0x1a, 0x78, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, + 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, + 0x62, 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x20, + 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x65, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, + 0x0a, 0x20, 0x60, 0x52, 0x75, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x60, 0x20, 0x77, 0x69, 0x6c, 0x6c, + 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x03, 0x05, 0x12, 0x03, 0x2d, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, + 0x01, 0x12, 0x03, 0x2d, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x03, 0x12, + 0x03, 0x2d, 0x13, 0x14, 0x0a, 0xfc, 0x01, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x33, 0x00, 0x44, + 0x01, 0x1a, 0xef, 0x01, 0x20, 0x54, 0x72, 0x61, 0x63, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x65, 0x20, 0x61, 0x20, 0x74, 0x72, 0x61, 0x63, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, + 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x27, 0x73, 0x20, 0x6d, 0x61, + 0x6e, 0x61, 0x67, 0x65, 0x64, 0x0a, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x6f, + 0x63, 0x61, 0x6c, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x62, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x65, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x69, 0x73, + 0x6d, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x27, 0x73, + 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x64, + 0x65, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x69, 0x73, 0x74, 0x69, 0x63, 0x20, 0x28, 0x65, 0x2e, + 0x67, 0x2e, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x0a, 0x20, 0x74, 0x69, 0x6d, 0x65, + 0x29, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x33, 0x08, 0x13, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x34, 0x02, 0x3c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x00, 0x05, 0x12, 0x03, 0x34, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x34, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x34, 0x10, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x08, 0x12, + 0x03, 0x34, 0x12, 0x3b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x03, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, + 0x02, 0x12, 0x03, 0x34, 0x13, 0x3a, 0x0a, 0x20, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, + 0x37, 0x02, 0x1f, 0x1a, 0x13, 0x20, 0x4c, 0x61, 0x73, 0x74, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, + 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, + 0x06, 0x12, 0x03, 0x37, 0x02, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x37, 0x15, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x37, + 0x1d, 0x1e, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x02, 0x12, 0x03, 0x3a, 0x02, 0x2b, 0x1a, + 0x1b, 0x20, 0x54, 0x69, 0x6d, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, + 0x70, 0x74, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x02, 0x06, 0x12, 0x03, 0x3a, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x3a, 0x1c, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, + 0x03, 0x12, 0x03, 0x3a, 0x29, 0x2a, 0x0a, 0x35, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x03, 0x12, 0x03, + 0x3d, 0x02, 0x32, 0x1a, 0x28, 0x20, 0x54, 0x69, 0x6d, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, + 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x20, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x2c, 0x20, 0x69, 0x66, + 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x03, 0x04, 0x12, 0x03, 0x3d, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x03, 0x06, 0x12, 0x03, 0x3d, 0x0b, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x03, 0x01, 0x12, 0x03, 0x3d, 0x25, 0x2d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x03, + 0x12, 0x03, 0x3d, 0x30, 0x31, 0x0a, 0x21, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x04, 0x12, 0x03, 0x40, + 0x02, 0x24, 0x1a, 0x14, 0x20, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x72, 0x65, 0x66, 0x65, + 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, + 0x06, 0x12, 0x03, 0x40, 0x02, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x01, 0x12, + 0x03, 0x40, 0x18, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x03, 0x12, 0x03, 0x40, + 0x22, 0x23, 0x0a, 0x4e, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x05, 0x12, 0x03, 0x43, 0x02, 0x41, 0x1a, + 0x41, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x20, 0x73, 0x70, 0x65, 0x63, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x63, 0x65, 0x2c, 0x20, 0x75, 0x73, 0x65, 0x66, 0x75, + 0x6c, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x64, 0x20, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x20, 0x69, 0x6e, 0x73, 0x69, 0x64, 0x65, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x06, 0x12, 0x03, 0x43, 0x02, 0x10, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x01, 0x12, 0x03, 0x43, 0x11, 0x15, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x03, 0x12, 0x03, 0x43, 0x18, 0x19, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x05, 0x08, 0x12, 0x03, 0x43, 0x1a, 0x40, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x03, + 0x02, 0x05, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x43, 0x1b, 0x3f, 0x0a, 0xaf, 0x01, 0x0a, 0x02, + 0x04, 0x04, 0x12, 0x04, 0x48, 0x00, 0x63, 0x01, 0x1a, 0xa2, 0x01, 0x20, 0x43, 0x6f, 0x6e, 0x64, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x75, + 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x20, 0x61, 0x20, + 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, + 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x20, + 0x61, 0x74, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x20, 0x49, 0x74, 0x20, 0x63, + 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x0a, 0x20, 0x61, + 0x77, 0x61, 0x69, 0x74, 0x20, 0x61, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x20, 0x66, 0x72, + 0x6f, 0x6d, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x73, + 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x63, 0x61, + 0x72, 0x72, 0x79, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x48, 0x08, 0x17, 0x0a, 0x6e, 0x0a, 0x04, 0x04, 0x04, 0x02, + 0x00, 0x12, 0x03, 0x4a, 0x02, 0x3c, 0x1a, 0x61, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x49, 0x74, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x73, 0x63, 0x6f, 0x70, + 0x65, 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x77, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x4a, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x4a, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x4a, 0x10, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x08, 0x12, 0x03, 0x4a, 0x12, + 0x3b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x04, 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, + 0x4a, 0x13, 0x3a, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x04, 0x08, 0x00, 0x12, 0x04, 0x4c, 0x02, 0x56, + 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x08, 0x00, 0x01, 0x12, 0x03, 0x4c, 0x08, 0x0d, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x08, 0x00, 0x02, 0x12, 0x03, 0x4d, 0x04, 0x30, 0x0a, 0x0f, 0x0a, + 0x08, 0x04, 0x04, 0x08, 0x00, 0x02, 0x87, 0x09, 0x01, 0x12, 0x03, 0x4d, 0x04, 0x30, 0x0a, 0x59, + 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x4f, 0x04, 0x40, 0x1a, 0x4c, 0x20, 0x52, 0x75, + 0x6e, 0x49, 0x64, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, + 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, + 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x01, 0x05, 0x12, 0x03, 0x4f, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x4f, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x4f, 0x14, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x08, 0x12, 0x03, 0x4f, 0x16, + 0x3f, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x04, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, + 0x4f, 0x17, 0x3e, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x02, 0x12, 0x03, 0x52, 0x04, 0x43, + 0x1a, 0x52, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x20, 0x69, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x69, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x05, 0x12, 0x03, 0x52, + 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x52, 0x0b, 0x14, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, 0x52, 0x17, 0x18, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x08, 0x12, 0x03, 0x52, 0x19, 0x42, 0x0a, 0x10, 0x0a, 0x09, + 0x04, 0x04, 0x02, 0x02, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x52, 0x1a, 0x41, 0x0a, 0x64, + 0x0a, 0x04, 0x04, 0x04, 0x02, 0x03, 0x12, 0x03, 0x55, 0x04, 0x14, 0x1a, 0x57, 0x20, 0x47, 0x6c, + 0x6f, 0x62, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, + 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, + 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x61, 0x63, 0x72, 0x6f, 0x73, 0x73, 0x20, 0x61, 0x6c, + 0x6c, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x05, 0x12, 0x03, 0x55, + 0x04, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x01, 0x12, 0x03, 0x55, 0x09, 0x0f, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x03, 0x12, 0x03, 0x55, 0x12, 0x13, 0x0a, 0xd3, + 0x01, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x04, 0x12, 0x03, 0x5b, 0x02, 0x26, 0x1a, 0xc5, 0x01, 0x20, + 0x54, 0x79, 0x70, 0x65, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x65, + 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x63, 0x61, + 0x6e, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x72, 0x6f, + 0x70, 0x65, 0x72, 0x6c, 0x79, 0x20, 0x72, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x0a, 0x20, 0x61, 0x20, + 0x55, 0x49, 0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x72, 0x20, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x61, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, + 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x0a, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x06, 0x12, 0x03, 0x5b, + 0x02, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x01, 0x12, 0x03, 0x5b, 0x1d, 0x21, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x03, 0x12, 0x03, 0x5b, 0x24, 0x25, 0x0a, 0x61, + 0x0a, 0x04, 0x04, 0x04, 0x02, 0x05, 0x12, 0x03, 0x5e, 0x02, 0x14, 0x1a, 0x54, 0x20, 0x50, 0x72, + 0x6f, 0x6d, 0x70, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x6d, + 0x70, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, + 0x73, 0x68, 0x6f, 0x77, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x73, 0x65, + 0x72, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x61, 0x77, 0x61, 0x69, 0x74, 0x65, 0x64, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x05, 0x05, 0x12, 0x03, 0x5e, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x05, 0x01, 0x12, 0x03, 0x5e, 0x09, 0x0f, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x05, 0x03, 0x12, 0x03, 0x5e, 0x12, 0x13, 0x0a, 0x93, 0x01, 0x0a, 0x04, + 0x04, 0x04, 0x02, 0x06, 0x12, 0x03, 0x62, 0x02, 0x19, 0x1a, 0x85, 0x01, 0x20, 0x44, 0x65, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, + 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x20, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x6c, 0x0a, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x61, 0x62, 0x6f, 0x75, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x06, 0x05, 0x12, 0x03, 0x62, 0x02, 0x08, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x06, 0x01, 0x12, 0x03, 0x62, 0x09, 0x14, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x06, 0x03, 0x12, 0x03, 0x62, 0x17, 0x18, 0x0a, 0x0a, 0x0a, 0x02, 0x04, + 0x05, 0x12, 0x04, 0x65, 0x00, 0x6e, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, + 0x65, 0x08, 0x1a, 0x0a, 0x3d, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x67, 0x02, 0x1d, + 0x1a, 0x30, 0x20, 0x49, 0x64, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, + 0x6b, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, + 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x06, 0x12, 0x03, 0x67, 0x02, 0x15, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x67, 0x16, 0x18, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x67, 0x1b, 0x1c, 0x0a, 0x24, 0x0a, 0x04, + 0x04, 0x05, 0x02, 0x01, 0x12, 0x03, 0x6a, 0x02, 0x17, 0x1a, 0x17, 0x20, 0x45, 0x78, 0x74, 0x65, + 0x6e, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x74, 0x79, 0x70, 0x65, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x05, 0x12, 0x03, 0x6a, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, 0x12, 0x03, 0x6a, 0x09, 0x12, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x03, 0x6a, 0x15, 0x16, 0x0a, 0x2c, 0x0a, 0x04, + 0x04, 0x05, 0x02, 0x02, 0x12, 0x03, 0x6d, 0x02, 0x18, 0x1a, 0x1f, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x73, 0x68, 0x6f, 0x72, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x02, 0x05, 0x12, 0x03, 0x6d, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, + 0x01, 0x12, 0x03, 0x6d, 0x09, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x03, 0x12, + 0x03, 0x6d, 0x16, 0x17, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x04, 0x70, 0x00, 0x72, 0x01, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x03, 0x70, 0x08, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x06, 0x02, 0x00, 0x12, 0x03, 0x71, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x71, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x71, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x71, 0x10, 0x11, 0x0a, 0x0b, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x05, 0x74, 0x00, 0x81, 0x01, 0x01, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x03, 0x74, 0x08, 0x1f, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x07, 0x02, 0x00, 0x12, 0x03, 0x75, 0x02, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x75, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x75, 0x09, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x75, 0x10, 0x11, 0x0a, 0x0d, 0x0a, 0x04, 0x04, 0x07, 0x08, 0x00, 0x12, 0x05, 0x76, 0x02, 0x80, + 0x01, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x08, 0x00, 0x01, 0x12, 0x03, 0x76, 0x08, 0x0d, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x08, 0x00, 0x02, 0x12, 0x03, 0x77, 0x04, 0x30, 0x0a, 0x0f, + 0x0a, 0x08, 0x04, 0x07, 0x08, 0x00, 0x02, 0x87, 0x09, 0x01, 0x12, 0x03, 0x77, 0x04, 0x30, 0x0a, + 0x59, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x01, 0x12, 0x03, 0x79, 0x04, 0x40, 0x1a, 0x4c, 0x20, 0x52, + 0x75, 0x6e, 0x49, 0x64, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, + 0x75, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, + 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x01, 0x05, 0x12, 0x03, 0x79, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x79, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x79, 0x14, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x08, 0x12, 0x03, 0x79, + 0x16, 0x3f, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x07, 0x02, 0x01, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, + 0x03, 0x79, 0x17, 0x3e, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x02, 0x12, 0x03, 0x7c, 0x04, + 0x43, 0x1a, 0x52, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x20, 0x69, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x69, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x05, 0x12, 0x03, + 0x7c, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x01, 0x12, 0x03, 0x7c, 0x0b, + 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x03, 0x12, 0x03, 0x7c, 0x17, 0x18, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x08, 0x12, 0x03, 0x7c, 0x19, 0x42, 0x0a, 0x10, 0x0a, + 0x09, 0x04, 0x07, 0x02, 0x02, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x7c, 0x1a, 0x41, 0x0a, + 0x64, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x03, 0x12, 0x03, 0x7f, 0x04, 0x14, 0x1a, 0x57, 0x20, 0x47, + 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, + 0x20, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x20, + 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x61, 0x63, 0x72, 0x6f, 0x73, 0x73, 0x20, 0x61, + 0x6c, 0x6c, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x03, 0x05, 0x12, 0x03, + 0x7f, 0x04, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x03, 0x01, 0x12, 0x03, 0x7f, 0x09, + 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x03, 0x03, 0x12, 0x03, 0x7f, 0x12, 0x13, 0x0a, + 0x3d, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x06, 0x84, 0x01, 0x00, 0xad, 0x01, 0x01, 0x1a, 0x2f, 0x20, + 0x53, 0x74, 0x61, 0x74, 0x69, 0x63, 0x2c, 0x20, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x77, 0x65, 0x69, + 0x67, 0x68, 0x74, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x61, 0x62, 0x6f, + 0x75, 0x74, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0b, + 0x0a, 0x03, 0x04, 0x08, 0x01, 0x12, 0x04, 0x84, 0x01, 0x08, 0x16, 0x0a, 0x2e, 0x0a, 0x04, 0x04, + 0x08, 0x02, 0x00, 0x12, 0x04, 0x86, 0x01, 0x02, 0x14, 0x1a, 0x20, 0x20, 0x50, 0x61, 0x72, 0x65, + 0x6e, 0x74, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x00, 0x05, 0x12, 0x04, 0x86, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x00, 0x01, 0x12, 0x04, 0x86, 0x01, 0x09, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x00, 0x03, 0x12, 0x04, 0x86, 0x01, 0x12, 0x13, 0x0a, 0x3c, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x01, + 0x12, 0x04, 0x89, 0x01, 0x02, 0x13, 0x1a, 0x2e, 0x20, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x6e, + 0x67, 0x73, 0x20, 0x74, 0x6f, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x05, 0x12, + 0x04, 0x89, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x01, 0x12, 0x04, + 0x89, 0x01, 0x09, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x03, 0x12, 0x04, 0x89, + 0x01, 0x11, 0x12, 0x0a, 0x30, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x02, 0x12, 0x04, 0x8c, 0x01, 0x02, + 0x2a, 0x1a, 0x22, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x06, 0x12, 0x04, + 0x8c, 0x01, 0x02, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x01, 0x12, 0x04, 0x8c, + 0x01, 0x1a, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x03, 0x12, 0x04, 0x8c, 0x01, + 0x28, 0x29, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x08, 0x08, 0x00, 0x12, 0x06, 0x8e, 0x01, 0x02, 0x97, + 0x01, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x08, 0x00, 0x01, 0x12, 0x04, 0x8e, 0x01, 0x08, + 0x0c, 0x0a, 0x1c, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x03, 0x12, 0x04, 0x90, 0x01, 0x04, 0x20, 0x1a, + 0x0e, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x06, 0x12, 0x04, 0x90, 0x01, 0x04, 0x16, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x01, 0x12, 0x04, 0x90, 0x01, 0x17, 0x1b, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x03, 0x03, 0x12, 0x04, 0x90, 0x01, 0x1e, 0x1f, 0x0a, 0x1d, 0x0a, 0x04, + 0x04, 0x08, 0x02, 0x04, 0x12, 0x04, 0x93, 0x01, 0x04, 0x22, 0x1a, 0x0f, 0x20, 0x54, 0x72, 0x61, + 0x63, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x04, 0x06, 0x12, 0x04, 0x93, 0x01, 0x04, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x04, 0x01, 0x12, 0x04, 0x93, 0x01, 0x18, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x04, 0x03, 0x12, 0x04, 0x93, 0x01, 0x20, 0x21, 0x0a, 0x21, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x05, + 0x12, 0x04, 0x96, 0x01, 0x04, 0x2a, 0x1a, 0x13, 0x20, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x05, 0x06, 0x12, 0x04, 0x96, 0x01, 0x04, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x05, 0x01, 0x12, 0x04, 0x96, 0x01, 0x1c, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x05, 0x03, 0x12, 0x04, 0x96, 0x01, 0x28, 0x29, 0x0a, 0x1c, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x06, + 0x12, 0x04, 0x9a, 0x01, 0x02, 0x1e, 0x1a, 0x0e, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x74, 0x79, 0x70, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x06, 0x12, + 0x04, 0x9a, 0x01, 0x02, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x01, 0x12, 0x04, + 0x9a, 0x01, 0x0d, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x03, 0x12, 0x04, 0x9a, + 0x01, 0x1b, 0x1d, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x07, 0x12, 0x04, 0x9d, 0x01, 0x02, + 0x2b, 0x1a, 0x51, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x72, 0x75, 0x6e, 0x20, + 0x77, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, + 0x20, 0x61, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x06, 0x12, 0x04, 0x9d, + 0x01, 0x02, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x01, 0x12, 0x04, 0x9d, 0x01, + 0x1b, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x03, 0x12, 0x04, 0x9d, 0x01, 0x28, + 0x2a, 0x0a, 0x20, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x08, 0x12, 0x04, 0xa0, 0x01, 0x02, 0x1f, 0x1a, + 0x12, 0x20, 0x45, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6e, 0x61, + 0x6d, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x08, 0x05, 0x12, 0x04, 0xa0, 0x01, + 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x08, 0x01, 0x12, 0x04, 0xa0, 0x01, 0x09, + 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x08, 0x03, 0x12, 0x04, 0xa0, 0x01, 0x1c, 0x1e, + 0x0a, 0x1d, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x09, 0x12, 0x04, 0xa3, 0x01, 0x02, 0x1b, 0x1a, 0x0f, + 0x20, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x09, 0x05, 0x12, 0x04, 0xa3, 0x01, 0x02, 0x08, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x09, 0x01, 0x12, 0x04, 0xa3, 0x01, 0x09, 0x15, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x09, 0x03, 0x12, 0x04, 0xa3, 0x01, 0x18, 0x1a, 0x0a, 0x1c, 0x0a, 0x04, + 0x04, 0x08, 0x02, 0x0a, 0x12, 0x04, 0xa6, 0x01, 0x02, 0x1b, 0x1a, 0x0e, 0x20, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x0a, 0x05, 0x12, 0x04, 0xa6, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x0a, 0x01, 0x12, 0x04, 0xa6, 0x01, 0x09, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x0a, + 0x03, 0x12, 0x04, 0xa6, 0x01, 0x18, 0x1a, 0x0a, 0x1c, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x0b, 0x12, + 0x04, 0xa9, 0x01, 0x02, 0x2f, 0x1a, 0x0e, 0x20, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, + 0x54, 0x79, 0x70, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x0b, 0x06, 0x12, 0x04, + 0xa9, 0x01, 0x02, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x0b, 0x01, 0x12, 0x04, 0xa9, + 0x01, 0x1d, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x0b, 0x03, 0x12, 0x04, 0xa9, 0x01, + 0x2c, 0x2e, 0x0a, 0x26, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x0c, 0x12, 0x04, 0xac, 0x01, 0x02, 0x18, + 0x1a, 0x18, 0x20, 0x57, 0x68, 0x6f, 0x20, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x72, 0x75, 0x6e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x0c, 0x06, 0x12, 0x04, 0xac, 0x01, 0x02, 0x0b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x0c, 0x01, 0x12, 0x04, 0xac, 0x01, 0x0c, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x0c, + 0x03, 0x12, 0x04, 0xac, 0x01, 0x15, 0x17, 0x0a, 0x0c, 0x0a, 0x02, 0x05, 0x00, 0x12, 0x06, 0xaf, + 0x01, 0x00, 0xb4, 0x01, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, 0x04, 0xaf, 0x01, + 0x05, 0x0f, 0x0a, 0x0c, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x00, 0x12, 0x04, 0xb0, 0x01, 0x02, 0x1e, + 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, 0xb0, 0x01, 0x02, 0x19, 0x0a, + 0x0d, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x02, 0x12, 0x04, 0xb0, 0x01, 0x1c, 0x1d, 0x0a, 0x0c, + 0x0a, 0x04, 0x05, 0x00, 0x02, 0x01, 0x12, 0x04, 0xb1, 0x01, 0x02, 0x17, 0x0a, 0x0d, 0x0a, 0x05, + 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x04, 0xb1, 0x01, 0x02, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x01, 0x02, 0x12, 0x04, 0xb1, 0x01, 0x15, 0x16, 0x0a, 0x0c, 0x0a, 0x04, 0x05, 0x00, + 0x02, 0x02, 0x12, 0x04, 0xb2, 0x01, 0x02, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, + 0x01, 0x12, 0x04, 0xb2, 0x01, 0x02, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x02, + 0x12, 0x04, 0xb2, 0x01, 0x16, 0x17, 0x0a, 0x0c, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x03, 0x12, 0x04, + 0xb3, 0x01, 0x02, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x01, 0x12, 0x04, 0xb3, + 0x01, 0x02, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x03, 0x02, 0x12, 0x04, 0xb3, 0x01, + 0x1a, 0x1b, 0x0a, 0x5c, 0x0a, 0x02, 0x04, 0x09, 0x12, 0x06, 0xb7, 0x01, 0x00, 0xc9, 0x01, 0x01, + 0x1a, 0x4e, 0x20, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x20, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x64, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x73, 0x65, 0x65, + 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x0a, + 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, 0x04, 0xb7, 0x01, 0x08, 0x14, 0x0a, 0x21, 0x0a, + 0x04, 0x04, 0x09, 0x02, 0x00, 0x12, 0x04, 0xb9, 0x01, 0x02, 0x1f, 0x1a, 0x13, 0x20, 0x4c, 0x61, + 0x73, 0x74, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x06, 0x12, 0x04, 0xb9, 0x01, 0x02, 0x14, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x04, 0xb9, 0x01, 0x15, 0x1a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, 0x04, 0xb9, 0x01, 0x1d, 0x1e, 0x0a, 0x28, 0x0a, + 0x04, 0x04, 0x09, 0x02, 0x01, 0x12, 0x04, 0xbc, 0x01, 0x02, 0x2b, 0x1a, 0x1a, 0x20, 0x54, 0x69, + 0x6d, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x06, + 0x12, 0x04, 0xbc, 0x01, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x01, 0x12, + 0x04, 0xbc, 0x01, 0x1c, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x03, 0x12, 0x04, + 0xbc, 0x01, 0x29, 0x2a, 0x0a, 0x35, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x02, 0x12, 0x04, 0xbf, 0x01, + 0x02, 0x32, 0x1a, 0x27, 0x20, 0x54, 0x69, 0x6d, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x61, + 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x09, 0x02, 0x02, 0x04, 0x12, 0x04, 0xbf, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x02, 0x06, 0x12, 0x04, 0xbf, 0x01, 0x0b, 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, + 0x02, 0x01, 0x12, 0x04, 0xbf, 0x01, 0x25, 0x2d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, + 0x03, 0x12, 0x04, 0xbf, 0x01, 0x30, 0x31, 0x0a, 0x2a, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x03, 0x12, + 0x04, 0xc2, 0x01, 0x02, 0x3b, 0x1a, 0x1c, 0x20, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, + 0x66, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, + 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, 0x05, 0x12, 0x04, 0xc2, 0x01, + 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, 0x01, 0x12, 0x04, 0xc2, 0x01, 0x09, + 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, 0x03, 0x12, 0x04, 0xc2, 0x01, 0x14, 0x15, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, 0x08, 0x12, 0x04, 0xc2, 0x01, 0x16, 0x3a, 0x0a, + 0x11, 0x0a, 0x09, 0x04, 0x09, 0x02, 0x03, 0x08, 0x87, 0x09, 0x05, 0x04, 0x12, 0x04, 0xc2, 0x01, + 0x17, 0x39, 0x0a, 0x3b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x04, 0x12, 0x04, 0xc5, 0x01, 0x02, 0x35, + 0x1a, 0x2d, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x73, 0x20, + 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x04, 0x06, 0x12, 0x04, 0xc5, 0x01, 0x02, 0x23, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x09, 0x02, 0x04, 0x01, 0x12, 0x04, 0xc5, 0x01, 0x24, 0x30, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x09, 0x02, 0x04, 0x03, 0x12, 0x04, 0xc5, 0x01, 0x33, 0x34, 0x0a, 0x37, 0x0a, 0x04, + 0x04, 0x09, 0x02, 0x05, 0x12, 0x04, 0xc8, 0x01, 0x02, 0x22, 0x1a, 0x29, 0x20, 0x44, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x73, 0x65, 0x63, 0x6f, + 0x6e, 0x64, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x05, 0x04, 0x12, 0x04, + 0xc8, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x05, 0x05, 0x12, 0x04, 0xc8, + 0x01, 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x05, 0x01, 0x12, 0x04, 0xc8, 0x01, + 0x12, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x05, 0x03, 0x12, 0x04, 0xc8, 0x01, 0x20, + 0x21, 0x0a, 0x38, 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x06, 0xcc, 0x01, 0x00, 0xd5, 0x01, 0x01, 0x1a, + 0x2a, 0x20, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x20, 0x72, 0x65, + 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, + 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, + 0x0a, 0x01, 0x12, 0x04, 0xcc, 0x01, 0x08, 0x0e, 0x0a, 0x23, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x00, + 0x12, 0x04, 0xce, 0x01, 0x02, 0x21, 0x1a, 0x15, 0x20, 0x49, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0a, 0x02, 0x00, 0x06, 0x12, 0x04, 0xce, 0x01, 0x02, 0x19, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x04, 0xce, 0x01, 0x1a, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0a, 0x02, 0x00, 0x03, 0x12, 0x04, 0xce, 0x01, 0x1f, 0x20, 0x0a, 0x29, 0x0a, 0x04, 0x04, 0x0a, + 0x02, 0x01, 0x12, 0x04, 0xd1, 0x01, 0x02, 0x1e, 0x1a, 0x1b, 0x20, 0x4d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x06, 0x12, 0x04, + 0xd1, 0x01, 0x02, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x01, 0x12, 0x04, 0xd1, + 0x01, 0x11, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x03, 0x12, 0x04, 0xd1, 0x01, + 0x1c, 0x1d, 0x0a, 0x22, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x02, 0x12, 0x04, 0xd4, 0x01, 0x02, 0x1a, + 0x1a, 0x14, 0x20, 0x4c, 0x61, 0x73, 0x74, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x73, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x06, 0x12, + 0x04, 0xd4, 0x01, 0x02, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x01, 0x12, 0x04, + 0xd4, 0x01, 0x0f, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x03, 0x12, 0x04, 0xd4, + 0x01, 0x18, 0x19, 0x0a, 0x5e, 0x0a, 0x02, 0x04, 0x0b, 0x12, 0x06, 0xd8, 0x01, 0x00, 0xe2, 0x01, + 0x01, 0x1a, 0x50, 0x20, 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x41, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x20, + 0x61, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x61, 0x64, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0b, 0x01, 0x12, 0x04, 0xd8, 0x01, 0x08, 0x16, + 0x0a, 0x22, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x00, 0x12, 0x04, 0xda, 0x01, 0x02, 0x14, 0x1a, 0x14, + 0x20, 0x54, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x74, 0x73, 0x65, + 0x6c, 0x66, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x06, 0x12, 0x04, 0xda, + 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x01, 0x12, 0x04, 0xda, 0x01, + 0x09, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x03, 0x12, 0x04, 0xda, 0x01, 0x12, + 0x13, 0x0a, 0xc5, 0x01, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x01, 0x12, 0x04, 0xde, 0x01, 0x02, 0x18, + 0x1a, 0xb6, 0x01, 0x20, 0x57, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6d, 0x65, 0x65, 0x74, 0x73, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6f, + 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x2e, 0x0a, 0x20, 0x49, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x61, 0x73, 0x20, 0x70, 0x72, + 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x20, 0x6d, 0x65, 0x65, 0x74, 0x69, 0x6e, 0x67, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x62, 0x75, 0x74, 0x20, + 0x6e, 0x6f, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x2c, 0x20, + 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x74, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x6c, 0x61, 0x67, 0x20, 0x73, 0x65, 0x74, 0x20, + 0x74, 0x6f, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, + 0x01, 0x05, 0x12, 0x04, 0xde, 0x01, 0x02, 0x06, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, + 0x01, 0x12, 0x04, 0xde, 0x01, 0x07, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x03, + 0x12, 0x04, 0xde, 0x01, 0x16, 0x17, 0x0a, 0x64, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x02, 0x12, 0x04, + 0xe1, 0x01, 0x02, 0x2e, 0x1a, 0x56, 0x20, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x20, 0x70, 0x68, 0x61, + 0x73, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x4d, 0x61, 0x70, 0x20, 0x6f, 0x66, 0x20, + 0x70, 0x68, 0x61, 0x73, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x67, + 0x69, 0x76, 0x65, 0x6e, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x29, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0b, 0x02, 0x02, 0x06, 0x12, 0x04, 0xe1, 0x01, 0x02, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0b, 0x02, 0x02, 0x01, 0x12, 0x04, 0xe1, 0x01, 0x14, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, + 0x02, 0x02, 0x03, 0x12, 0x04, 0xe1, 0x01, 0x2c, 0x2d, 0x0a, 0x37, 0x0a, 0x02, 0x04, 0x0c, 0x12, + 0x06, 0xe5, 0x01, 0x00, 0xf1, 0x01, 0x01, 0x1a, 0x29, 0x20, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x49, + 0x6e, 0x66, 0x6f, 0x20, 0x63, 0x61, 0x70, 0x74, 0x75, 0x72, 0x65, 0x73, 0x20, 0x64, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, + 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0c, 0x01, 0x12, 0x04, 0xe5, 0x01, 0x08, 0x11, 0x0a, + 0x1e, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x00, 0x12, 0x04, 0xe7, 0x01, 0x02, 0x15, 0x1a, 0x10, 0x20, + 0x45, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x05, 0x12, 0x04, 0xe7, 0x01, 0x02, 0x08, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x01, 0x12, 0x04, 0xe7, 0x01, 0x09, 0x10, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0c, 0x02, 0x00, 0x03, 0x12, 0x04, 0xe7, 0x01, 0x13, 0x14, 0x0a, 0x0e, 0x0a, 0x04, + 0x04, 0x0c, 0x04, 0x00, 0x12, 0x06, 0xe9, 0x01, 0x02, 0xed, 0x01, 0x03, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0c, 0x04, 0x00, 0x01, 0x12, 0x04, 0xe9, 0x01, 0x07, 0x0b, 0x0a, 0x0e, 0x0a, 0x06, 0x04, + 0x0c, 0x04, 0x00, 0x02, 0x00, 0x12, 0x04, 0xea, 0x01, 0x04, 0x19, 0x0a, 0x0f, 0x0a, 0x07, 0x04, + 0x0c, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, 0xea, 0x01, 0x04, 0x14, 0x0a, 0x0f, 0x0a, 0x07, + 0x04, 0x0c, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x04, 0xea, 0x01, 0x17, 0x18, 0x0a, 0x0e, 0x0a, + 0x06, 0x04, 0x0c, 0x04, 0x00, 0x02, 0x01, 0x12, 0x04, 0xeb, 0x01, 0x04, 0x12, 0x0a, 0x0f, 0x0a, + 0x07, 0x04, 0x0c, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x04, 0xeb, 0x01, 0x04, 0x0d, 0x0a, 0x0f, + 0x0a, 0x07, 0x04, 0x0c, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x04, 0xeb, 0x01, 0x10, 0x11, 0x0a, + 0x0e, 0x0a, 0x06, 0x04, 0x0c, 0x04, 0x00, 0x02, 0x02, 0x12, 0x04, 0xec, 0x01, 0x04, 0x14, 0x0a, + 0x0f, 0x0a, 0x07, 0x04, 0x0c, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x04, 0xec, 0x01, 0x04, 0x0f, + 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0c, 0x04, 0x00, 0x02, 0x02, 0x02, 0x12, 0x04, 0xec, 0x01, 0x12, + 0x13, 0x0a, 0x1b, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x01, 0x12, 0x04, 0xf0, 0x01, 0x02, 0x10, 0x1a, + 0x0d, 0x20, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6b, 0x69, 0x6e, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x06, 0x12, 0x04, 0xf0, 0x01, 0x02, 0x06, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0c, 0x02, 0x01, 0x01, 0x12, 0x04, 0xf0, 0x01, 0x07, 0x0b, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0c, 0x02, 0x01, 0x03, 0x12, 0x04, 0xf0, 0x01, 0x0e, 0x0f, 0x0a, 0x3d, 0x0a, 0x02, 0x04, + 0x0d, 0x12, 0x06, 0xf4, 0x01, 0x00, 0xfa, 0x01, 0x01, 0x1a, 0x2f, 0x20, 0x41, 0x62, 0x6f, 0x72, + 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x20, 0x63, 0x61, 0x70, 0x74, 0x75, 0x72, 0x65, 0x73, 0x20, 0x64, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x62, 0x6f, + 0x72, 0x74, 0x65, 0x64, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0d, + 0x01, 0x12, 0x04, 0xf4, 0x01, 0x08, 0x11, 0x0a, 0x2e, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x00, 0x12, + 0x04, 0xf6, 0x01, 0x02, 0x14, 0x1a, 0x20, 0x20, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x70, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x61, 0x62, 0x6f, 0x72, 0x74, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x05, + 0x12, 0x04, 0xf6, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x01, 0x12, + 0x04, 0xf6, 0x01, 0x09, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x03, 0x12, 0x04, + 0xf6, 0x01, 0x12, 0x13, 0x0a, 0x2e, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x01, 0x12, 0x04, 0xf9, 0x01, + 0x02, 0x29, 0x1a, 0x20, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, + 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x06, 0x12, 0x04, 0xf9, + 0x01, 0x02, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x01, 0x12, 0x04, 0xf9, 0x01, + 0x1a, 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x03, 0x12, 0x04, 0xf9, 0x01, 0x27, + 0x28, 0x0a, 0x3f, 0x0a, 0x02, 0x04, 0x0e, 0x12, 0x06, 0xfd, 0x01, 0x00, 0x96, 0x02, 0x01, 0x1a, + 0x31, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x20, + 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x6c, 0x6c, 0x20, 0x64, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0e, 0x01, 0x12, 0x04, 0xfd, 0x01, 0x08, 0x15, 0x0a, + 0x23, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x00, 0x12, 0x04, 0xff, 0x01, 0x02, 0x21, 0x1a, 0x15, 0x20, + 0x49, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x06, 0x12, 0x04, 0xff, + 0x01, 0x02, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x01, 0x12, 0x04, 0xff, 0x01, + 0x1a, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x03, 0x12, 0x04, 0xff, 0x01, 0x1f, + 0x20, 0x0a, 0x29, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x01, 0x12, 0x04, 0x82, 0x02, 0x02, 0x1e, 0x1a, + 0x1b, 0x20, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x01, 0x06, 0x12, 0x04, 0x82, 0x02, 0x02, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x01, 0x01, 0x12, 0x04, 0x82, 0x02, 0x11, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x01, 0x03, 0x12, 0x04, 0x82, 0x02, 0x1c, 0x1d, 0x0a, 0x22, 0x0a, 0x04, 0x04, 0x0e, 0x02, + 0x02, 0x12, 0x04, 0x85, 0x02, 0x02, 0x1a, 0x1a, 0x14, 0x20, 0x4c, 0x61, 0x73, 0x74, 0x20, 0x6b, + 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x02, 0x06, 0x12, 0x04, 0x85, 0x02, 0x02, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x02, 0x01, 0x12, 0x04, 0x85, 0x02, 0x0f, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x02, 0x03, 0x12, 0x04, 0x85, 0x02, 0x18, 0x19, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x0e, + 0x08, 0x00, 0x12, 0x06, 0x87, 0x02, 0x02, 0x8c, 0x02, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x08, 0x00, 0x01, 0x12, 0x04, 0x87, 0x02, 0x08, 0x0e, 0x0a, 0x35, 0x0a, 0x04, 0x04, 0x0e, 0x02, + 0x03, 0x12, 0x04, 0x89, 0x02, 0x04, 0x1d, 0x1a, 0x27, 0x20, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x20, + 0x69, 0x6e, 0x66, 0x6f, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x06, 0x12, 0x04, 0x89, 0x02, 0x04, 0x0d, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x01, 0x12, 0x04, 0x89, 0x02, 0x0e, 0x18, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x03, 0x12, 0x04, 0x89, 0x02, 0x1b, 0x1c, 0x0a, 0x36, 0x0a, + 0x04, 0x04, 0x0e, 0x02, 0x04, 0x12, 0x04, 0x8b, 0x02, 0x04, 0x1d, 0x1a, 0x28, 0x20, 0x41, 0x62, + 0x6f, 0x72, 0x74, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x61, 0x62, 0x6f, 0x72, + 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x04, 0x06, 0x12, 0x04, + 0x8b, 0x02, 0x04, 0x0d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x04, 0x01, 0x12, 0x04, 0x8b, + 0x02, 0x0e, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x04, 0x03, 0x12, 0x04, 0x8b, 0x02, + 0x1b, 0x1c, 0x0a, 0x6c, 0x0a, 0x04, 0x04, 0x0e, 0x08, 0x01, 0x12, 0x06, 0x8f, 0x02, 0x02, 0x92, + 0x02, 0x03, 0x1a, 0x5c, 0x20, 0x46, 0x75, 0x6c, 0x6c, 0x79, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x6c, + 0x76, 0x65, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x4d, 0x65, 0x72, 0x67, 0x65, 0x73, 0x20, 0x75, + 0x73, 0x65, 0x72, 0x20, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x64, 0x20, 0x74, 0x61, + 0x73, 0x6b, 0x20, 0x73, 0x70, 0x65, 0x63, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x08, 0x01, 0x01, 0x12, 0x04, 0x8f, 0x02, 0x08, 0x0c, 0x0a, + 0x0c, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x05, 0x12, 0x04, 0x90, 0x02, 0x04, 0x1b, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x05, 0x06, 0x12, 0x04, 0x90, 0x02, 0x04, 0x11, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x05, 0x01, 0x12, 0x04, 0x90, 0x02, 0x12, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x05, 0x03, 0x12, 0x04, 0x90, 0x02, 0x19, 0x1a, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0e, + 0x02, 0x06, 0x12, 0x04, 0x91, 0x02, 0x04, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x06, + 0x06, 0x12, 0x04, 0x91, 0x02, 0x04, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x06, 0x01, + 0x12, 0x04, 0x91, 0x02, 0x13, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x06, 0x03, 0x12, + 0x04, 0x91, 0x02, 0x1b, 0x1c, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x07, 0x12, 0x04, 0x95, + 0x02, 0x02, 0x26, 0x1a, 0x1a, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x07, 0x04, 0x12, 0x04, 0x95, 0x02, 0x02, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x07, 0x06, 0x12, 0x04, 0x95, 0x02, 0x0b, 0x18, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x07, 0x01, 0x12, 0x04, 0x95, 0x02, 0x19, 0x21, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x07, 0x03, 0x12, 0x04, 0x95, 0x02, 0x24, 0x25, 0x0a, 0x3f, 0x0a, 0x02, 0x04, + 0x0f, 0x12, 0x06, 0x99, 0x02, 0x00, 0xc1, 0x02, 0x01, 0x1a, 0x31, 0x20, 0x41, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x73, + 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x20, 0x6f, 0x66, + 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, + 0x04, 0x0f, 0x01, 0x12, 0x04, 0x99, 0x02, 0x08, 0x15, 0x0a, 0x21, 0x0a, 0x04, 0x04, 0x0f, 0x02, + 0x00, 0x12, 0x04, 0x9b, 0x02, 0x02, 0x1f, 0x1a, 0x13, 0x20, 0x4c, 0x61, 0x73, 0x74, 0x20, 0x6b, + 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0f, 0x02, 0x00, 0x06, 0x12, 0x04, 0x9b, 0x02, 0x02, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0f, 0x02, 0x00, 0x01, 0x12, 0x04, 0x9b, 0x02, 0x15, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, + 0x02, 0x00, 0x03, 0x12, 0x04, 0x9b, 0x02, 0x1d, 0x1e, 0x0a, 0x29, 0x0a, 0x04, 0x04, 0x0f, 0x02, + 0x01, 0x12, 0x04, 0x9e, 0x02, 0x02, 0x2b, 0x1a, 0x1b, 0x20, 0x54, 0x69, 0x6d, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x06, 0x12, 0x04, 0x9e, + 0x02, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x01, 0x12, 0x04, 0x9e, 0x02, + 0x1c, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x03, 0x12, 0x04, 0x9e, 0x02, 0x29, + 0x2a, 0x0a, 0x36, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x02, 0x12, 0x04, 0xa1, 0x02, 0x02, 0x32, 0x1a, + 0x28, 0x20, 0x54, 0x69, 0x6d, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, + 0x70, 0x74, 0x20, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x61, 0x70, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, + 0x02, 0x04, 0x12, 0x04, 0xa1, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x02, + 0x06, 0x12, 0x04, 0xa1, 0x02, 0x0b, 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x02, 0x01, + 0x12, 0x04, 0xa1, 0x02, 0x25, 0x2d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x02, 0x03, 0x12, + 0x04, 0xa1, 0x02, 0x30, 0x31, 0x0a, 0x36, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x03, 0x12, 0x04, 0xa4, + 0x02, 0x02, 0x24, 0x1a, 0x28, 0x20, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x66, 0x6f, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, + 0x2c, 0x20, 0x69, 0x66, 0x20, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0f, 0x02, 0x03, 0x04, 0x12, 0x04, 0xa4, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0f, 0x02, 0x03, 0x06, 0x12, 0x04, 0xa4, 0x02, 0x0b, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0f, 0x02, 0x03, 0x01, 0x12, 0x04, 0xa4, 0x02, 0x15, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, + 0x02, 0x03, 0x03, 0x12, 0x04, 0xa4, 0x02, 0x22, 0x23, 0x0a, 0x34, 0x0a, 0x04, 0x04, 0x0f, 0x02, + 0x04, 0x12, 0x04, 0xa7, 0x02, 0x02, 0x3a, 0x1a, 0x26, 0x20, 0x54, 0x68, 0x65, 0x20, 0x61, 0x74, + 0x74, 0x65, 0x6d, 0x70, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2c, 0x20, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x31, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x04, 0x05, 0x12, 0x04, 0xa7, 0x02, 0x02, 0x08, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x04, 0x01, 0x12, 0x04, 0xa7, 0x02, 0x09, 0x10, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0f, 0x02, 0x04, 0x03, 0x12, 0x04, 0xa7, 0x02, 0x13, 0x14, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0f, 0x02, 0x04, 0x08, 0x12, 0x04, 0xa7, 0x02, 0x15, 0x39, 0x0a, 0x11, 0x0a, 0x09, 0x04, + 0x0f, 0x02, 0x04, 0x08, 0x87, 0x09, 0x05, 0x04, 0x12, 0x04, 0xa7, 0x02, 0x16, 0x38, 0x0a, 0x1f, + 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x05, 0x12, 0x04, 0xaa, 0x02, 0x02, 0x2f, 0x1a, 0x11, 0x20, 0x4c, + 0x6f, 0x67, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x05, 0x04, 0x12, 0x04, 0xaa, 0x02, 0x02, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x05, 0x06, 0x12, 0x04, 0xaa, 0x02, 0x0b, 0x21, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0f, 0x02, 0x05, 0x01, 0x12, 0x04, 0xaa, 0x02, 0x22, 0x2a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0f, 0x02, 0x05, 0x03, 0x12, 0x04, 0xaa, 0x02, 0x2d, 0x2e, 0x0a, 0x22, 0x0a, 0x04, 0x04, + 0x0f, 0x02, 0x06, 0x12, 0x04, 0xad, 0x02, 0x02, 0x2e, 0x1a, 0x14, 0x20, 0x4f, 0x75, 0x74, 0x70, + 0x75, 0x74, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x06, 0x06, 0x12, 0x04, 0xad, 0x02, 0x02, 0x21, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x06, 0x01, 0x12, 0x04, 0xad, 0x02, 0x22, 0x29, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0f, 0x02, 0x06, 0x03, 0x12, 0x04, 0xad, 0x02, 0x2c, 0x2d, 0x0a, 0xac, 0x01, 0x0a, + 0x04, 0x04, 0x0f, 0x02, 0x07, 0x12, 0x04, 0xb1, 0x02, 0x02, 0x1a, 0x1a, 0x9d, 0x01, 0x20, 0x49, + 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, + 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, + 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x69, 0x6c, 0x69, 0x6e, 0x67, 0x2e, + 0x20, 0x49, 0x74, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x6e, 0x65, 0x63, 0x65, + 0x73, 0x73, 0x61, 0x72, 0x69, 0x6c, 0x79, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x70, 0x72, + 0x65, 0x73, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x62, 0x75, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x0a, + 0x20, 0x77, 0x65, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x66, + 0x6f, 0x20, 0x77, 0x65, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x6c, 0x6f, 0x6f, + 0x6b, 0x20, 0x74, 0x68, 0x65, 0x6d, 0x20, 0x75, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0f, 0x02, 0x07, 0x05, 0x12, 0x04, 0xb1, 0x02, 0x02, 0x06, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, + 0x02, 0x07, 0x01, 0x12, 0x04, 0xb1, 0x02, 0x07, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, + 0x07, 0x03, 0x12, 0x04, 0xb1, 0x02, 0x18, 0x19, 0x0a, 0x32, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x08, + 0x12, 0x04, 0xb4, 0x02, 0x02, 0x35, 0x1a, 0x24, 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0f, 0x02, 0x08, 0x06, 0x12, 0x04, 0xb4, 0x02, 0x02, 0x23, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0f, 0x02, 0x08, 0x01, 0x12, 0x04, 0xb4, 0x02, 0x24, 0x30, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, + 0x02, 0x08, 0x03, 0x12, 0x04, 0xb4, 0x02, 0x33, 0x34, 0x0a, 0x48, 0x0a, 0x04, 0x04, 0x0f, 0x02, + 0x09, 0x12, 0x04, 0xb7, 0x02, 0x02, 0x2c, 0x1a, 0x3a, 0x20, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x6b, 0x38, + 0x73, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x68, 0x75, + 0x6d, 0x61, 0x6e, 0x2d, 0x72, 0x65, 0x61, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, + 0x6d, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x09, 0x04, 0x12, 0x04, 0xb7, 0x02, + 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x09, 0x06, 0x12, 0x04, 0xb7, 0x02, 0x0b, + 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x09, 0x01, 0x12, 0x04, 0xb7, 0x02, 0x18, 0x26, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x09, 0x03, 0x12, 0x04, 0xb7, 0x02, 0x29, 0x2b, 0x0a, + 0x2d, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x0a, 0x12, 0x04, 0xba, 0x02, 0x02, 0x32, 0x1a, 0x1f, 0x20, + 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, + 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0a, 0x04, 0x12, 0x04, 0xba, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0f, 0x02, 0x0a, 0x06, 0x12, 0x04, 0xba, 0x02, 0x0b, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0f, 0x02, 0x0a, 0x01, 0x12, 0x04, 0xba, 0x02, 0x1b, 0x2c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0f, 0x02, 0x0a, 0x03, 0x12, 0x04, 0xba, 0x02, 0x2f, 0x31, 0x0a, 0x38, 0x0a, 0x04, 0x04, 0x0f, + 0x02, 0x0b, 0x12, 0x04, 0xbd, 0x02, 0x02, 0x16, 0x1a, 0x2a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x74, 0x74, 0x65, + 0x6d, 0x70, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0b, 0x05, 0x12, 0x04, 0xbd, + 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0b, 0x01, 0x12, 0x04, 0xbd, 0x02, + 0x09, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0b, 0x03, 0x12, 0x04, 0xbd, 0x02, 0x13, + 0x15, 0x0a, 0x63, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x0c, 0x12, 0x04, 0xc0, 0x02, 0x02, 0x2d, 0x1a, + 0x55, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x63, 0x6f, 0x72, 0x72, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x6b, 0x38, 0x73, 0x20, 0x70, 0x6f, 0x64, + 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, + 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x74, 0x74, + 0x65, 0x6d, 0x70, 0x74, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0c, 0x06, 0x12, + 0x04, 0xc0, 0x02, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0c, 0x01, 0x12, 0x04, + 0xc0, 0x02, 0x1c, 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0c, 0x03, 0x12, 0x04, 0xc0, + 0x02, 0x2a, 0x2c, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x10, 0x12, 0x06, 0xc3, 0x02, 0x00, 0xcb, 0x02, + 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x10, 0x01, 0x12, 0x04, 0xc3, 0x02, 0x08, 0x14, 0x0a, 0x5e, + 0x0a, 0x04, 0x04, 0x10, 0x02, 0x00, 0x12, 0x04, 0xc5, 0x02, 0x02, 0x2c, 0x1a, 0x50, 0x20, 0x6f, + 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x20, 0x69, 0x6e, 0x64, 0x69, + 0x63, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, + 0x6e, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x72, 0x65, 0x61, + 0x73, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, 0x06, 0x12, 0x04, 0xc5, 0x02, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x10, 0x02, 0x00, 0x01, 0x12, 0x04, 0xc5, 0x02, 0x1c, 0x27, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x10, 0x02, 0x00, 0x03, 0x12, 0x04, 0xc5, 0x02, 0x2a, 0x2b, 0x0a, 0x61, 0x0a, 0x04, 0x04, + 0x10, 0x02, 0x01, 0x12, 0x04, 0xc8, 0x02, 0x02, 0x15, 0x1a, 0x53, 0x20, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x70, 0x6c, 0x61, + 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, + 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, + 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x10, 0x02, 0x01, 0x05, 0x12, 0x04, 0xc8, 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x10, 0x02, 0x01, 0x01, 0x12, 0x04, 0xc8, 0x02, 0x09, 0x10, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x10, 0x02, 0x01, 0x03, 0x12, 0x04, 0xc8, 0x02, 0x13, 0x14, 0x0a, 0x0c, 0x0a, 0x02, 0x04, + 0x11, 0x12, 0x06, 0xcd, 0x02, 0x00, 0xd6, 0x02, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x11, 0x01, + 0x12, 0x04, 0xcd, 0x02, 0x08, 0x17, 0x0a, 0x1a, 0x0a, 0x04, 0x04, 0x11, 0x02, 0x00, 0x12, 0x04, + 0xcf, 0x02, 0x02, 0x1f, 0x1a, 0x0c, 0x20, 0x54, 0x68, 0x65, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, 0x06, 0x12, 0x04, 0xcf, 0x02, 0x02, + 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, 0x01, 0x12, 0x04, 0xcf, 0x02, 0x15, 0x1a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, 0x03, 0x12, 0x04, 0xcf, 0x02, 0x1d, 0x1e, 0x0a, + 0x28, 0x0a, 0x04, 0x04, 0x11, 0x02, 0x01, 0x12, 0x04, 0xd2, 0x02, 0x02, 0x2b, 0x1a, 0x1a, 0x20, + 0x54, 0x69, 0x6d, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x20, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, + 0x01, 0x06, 0x12, 0x04, 0xd2, 0x02, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x01, + 0x01, 0x12, 0x04, 0xd2, 0x02, 0x1c, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x01, 0x03, + 0x12, 0x04, 0xd2, 0x02, 0x29, 0x2a, 0x0a, 0x6a, 0x0a, 0x04, 0x04, 0x11, 0x02, 0x02, 0x12, 0x04, + 0xd5, 0x02, 0x02, 0x32, 0x1a, 0x5c, 0x20, 0x54, 0x69, 0x6d, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x20, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x2c, 0x20, 0x69, 0x66, + 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x20, 0x46, 0x6f, 0x72, + 0x20, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x73, + 0x2c, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x77, 0x69, 0x6c, + 0x6c, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x65, 0x6e, 0x64, 0x20, 0x74, 0x69, 0x6d, 0x65, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x02, 0x04, 0x12, 0x04, 0xd5, 0x02, 0x02, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x02, 0x06, 0x12, 0x04, 0xd5, 0x02, 0x0b, 0x24, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x02, 0x01, 0x12, 0x04, 0xd5, 0x02, 0x25, 0x2d, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x02, 0x03, 0x12, 0x04, 0xd5, 0x02, 0x30, 0x31, 0x0a, 0x2b, + 0x0a, 0x02, 0x04, 0x12, 0x12, 0x06, 0xd9, 0x02, 0x00, 0x86, 0x03, 0x01, 0x1a, 0x1d, 0x20, 0x45, + 0x76, 0x65, 0x6e, 0x74, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, + 0x12, 0x01, 0x12, 0x04, 0xd9, 0x02, 0x08, 0x13, 0x0a, 0x1e, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x00, + 0x12, 0x04, 0xdb, 0x02, 0x02, 0x48, 0x1a, 0x10, 0x20, 0x54, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x00, + 0x06, 0x12, 0x04, 0xdb, 0x02, 0x02, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x00, 0x01, + 0x12, 0x04, 0xdb, 0x02, 0x1a, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x00, 0x03, 0x12, + 0x04, 0xdb, 0x02, 0x1f, 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x00, 0x08, 0x12, 0x04, + 0xdb, 0x02, 0x21, 0x47, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x12, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, + 0x12, 0x04, 0xdb, 0x02, 0x22, 0x46, 0x0a, 0x23, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x01, 0x12, 0x04, + 0xde, 0x02, 0x02, 0x3a, 0x1a, 0x15, 0x20, 0x54, 0x68, 0x65, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, + 0x70, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x12, 0x02, 0x01, 0x05, 0x12, 0x04, 0xde, 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, + 0x02, 0x01, 0x01, 0x12, 0x04, 0xde, 0x02, 0x09, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, + 0x01, 0x03, 0x12, 0x04, 0xde, 0x02, 0x13, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x01, + 0x08, 0x12, 0x04, 0xde, 0x02, 0x15, 0x39, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x12, 0x02, 0x01, 0x08, + 0x87, 0x09, 0x05, 0x04, 0x12, 0x04, 0xde, 0x02, 0x16, 0x38, 0x0a, 0x2b, 0x0a, 0x04, 0x04, 0x12, + 0x02, 0x02, 0x12, 0x04, 0xe1, 0x02, 0x02, 0x1f, 0x1a, 0x1d, 0x20, 0x54, 0x68, 0x65, 0x20, 0x70, + 0x68, 0x61, 0x73, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x74, + 0x74, 0x65, 0x6d, 0x70, 0x74, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x02, 0x06, + 0x12, 0x04, 0xe1, 0x02, 0x02, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x02, 0x01, 0x12, + 0x04, 0xe1, 0x02, 0x15, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x02, 0x03, 0x12, 0x04, + 0xe1, 0x02, 0x1d, 0x1e, 0x0a, 0x36, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x03, 0x12, 0x04, 0xe4, 0x02, + 0x02, 0x15, 0x1a, 0x28, 0x20, 0x54, 0x68, 0x65, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, + 0x20, 0x61, 0x6e, 0x64, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x12, 0x02, 0x03, 0x05, 0x12, 0x04, 0xe4, 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x12, 0x02, 0x03, 0x01, 0x12, 0x04, 0xe4, 0x02, 0x09, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, + 0x02, 0x03, 0x03, 0x12, 0x04, 0xe4, 0x02, 0x13, 0x14, 0x0a, 0x29, 0x0a, 0x04, 0x04, 0x12, 0x02, + 0x04, 0x12, 0x04, 0xe7, 0x02, 0x02, 0x3f, 0x1a, 0x1b, 0x20, 0x54, 0x69, 0x6d, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x04, 0x06, 0x12, 0x04, 0xe7, + 0x02, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x04, 0x01, 0x12, 0x04, 0xe7, 0x02, + 0x1c, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x04, 0x03, 0x12, 0x04, 0xe7, 0x02, 0x29, + 0x2a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x04, 0x08, 0x12, 0x04, 0xe7, 0x02, 0x2b, 0x3e, + 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x12, 0x02, 0x04, 0x08, 0x03, 0x12, 0x04, 0xe7, 0x02, 0x2c, 0x3d, + 0x0a, 0x6c, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x05, 0x12, 0x04, 0xea, 0x02, 0x02, 0x2d, 0x1a, 0x5e, + 0x20, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, + 0x65, 0x64, 0x2c, 0x20, 0x61, 0x73, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x65, 0x64, 0x20, + 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, 0x79, 0x69, 0x6e, + 0x67, 0x20, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, + 0x20, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x29, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x12, 0x02, 0x05, 0x06, 0x12, 0x04, 0xea, 0x02, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x12, 0x02, 0x05, 0x01, 0x12, 0x04, 0xea, 0x02, 0x1c, 0x28, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x12, 0x02, 0x05, 0x03, 0x12, 0x04, 0xea, 0x02, 0x2b, 0x2c, 0x0a, 0x36, 0x0a, 0x04, 0x04, + 0x12, 0x02, 0x06, 0x12, 0x04, 0xed, 0x02, 0x02, 0x46, 0x1a, 0x28, 0x20, 0x54, 0x69, 0x6d, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x20, 0x65, 0x6e, 0x64, + 0x65, 0x64, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, + 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x06, 0x04, 0x12, 0x04, 0xed, 0x02, + 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x06, 0x06, 0x12, 0x04, 0xed, 0x02, 0x0b, + 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x06, 0x01, 0x12, 0x04, 0xed, 0x02, 0x25, 0x2d, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x06, 0x03, 0x12, 0x04, 0xed, 0x02, 0x30, 0x31, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x06, 0x08, 0x12, 0x04, 0xed, 0x02, 0x32, 0x45, 0x0a, 0x0e, + 0x0a, 0x06, 0x04, 0x12, 0x02, 0x06, 0x08, 0x03, 0x12, 0x04, 0xed, 0x02, 0x33, 0x44, 0x0a, 0x36, + 0x0a, 0x04, 0x04, 0x12, 0x02, 0x07, 0x12, 0x04, 0xf0, 0x02, 0x02, 0x24, 0x1a, 0x28, 0x20, 0x45, + 0x72, 0x72, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x66, 0x61, + 0x69, 0x6c, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x07, 0x04, 0x12, + 0x04, 0xf0, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x07, 0x06, 0x12, 0x04, + 0xf0, 0x02, 0x0b, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x07, 0x01, 0x12, 0x04, 0xf0, + 0x02, 0x15, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x07, 0x03, 0x12, 0x04, 0xf0, 0x02, + 0x22, 0x23, 0x0a, 0x1f, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x08, 0x12, 0x04, 0xf3, 0x02, 0x02, 0x2f, + 0x1a, 0x11, 0x20, 0x4c, 0x6f, 0x67, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, + 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x08, 0x04, 0x12, 0x04, 0xf3, 0x02, + 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x08, 0x06, 0x12, 0x04, 0xf3, 0x02, 0x0b, + 0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x08, 0x01, 0x12, 0x04, 0xf3, 0x02, 0x22, 0x2a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x08, 0x03, 0x12, 0x04, 0xf3, 0x02, 0x2d, 0x2e, 0x0a, + 0x3b, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x09, 0x12, 0x04, 0xf6, 0x02, 0x02, 0x2d, 0x1a, 0x2d, 0x20, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x73, 0x73, 0x6f, + 0x63, 0x69, 0x61, 0x74, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x12, 0x02, 0x09, 0x06, 0x12, 0x04, 0xf6, 0x02, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x12, 0x02, 0x09, 0x01, 0x12, 0x04, 0xf6, 0x02, 0x1c, 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, + 0x02, 0x09, 0x03, 0x12, 0x04, 0xf6, 0x02, 0x2a, 0x2c, 0x0a, 0x37, 0x0a, 0x04, 0x04, 0x12, 0x02, + 0x0a, 0x12, 0x04, 0xf9, 0x02, 0x02, 0x16, 0x1a, 0x29, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x74, 0x74, 0x65, 0x6d, + 0x70, 0x74, 0x20, 0x69, 0x73, 0x20, 0x72, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x6e, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x0a, 0x05, 0x12, 0x04, 0xf9, 0x02, 0x02, + 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x0a, 0x01, 0x12, 0x04, 0xf9, 0x02, 0x09, 0x10, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x0a, 0x03, 0x12, 0x04, 0xf9, 0x02, 0x13, 0x15, 0x0a, + 0x22, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x0b, 0x12, 0x04, 0xfc, 0x02, 0x02, 0x2f, 0x1a, 0x14, 0x20, + 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, + 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x0b, 0x06, 0x12, 0x04, 0xfc, 0x02, + 0x02, 0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x0b, 0x01, 0x12, 0x04, 0xfc, 0x02, 0x22, + 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x0b, 0x03, 0x12, 0x04, 0xfc, 0x02, 0x2c, 0x2e, + 0x0a, 0x32, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x0c, 0x12, 0x04, 0xff, 0x02, 0x02, 0x36, 0x1a, 0x24, + 0x20, 0x63, 0x61, 0x63, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x74, 0x74, 0x65, + 0x6d, 0x70, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x0c, 0x06, 0x12, 0x04, 0xff, + 0x02, 0x02, 0x23, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x0c, 0x01, 0x12, 0x04, 0xff, 0x02, + 0x24, 0x30, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x0c, 0x03, 0x12, 0x04, 0xff, 0x02, 0x33, + 0x35, 0x0a, 0x48, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x0d, 0x12, 0x04, 0x82, 0x03, 0x02, 0x2c, 0x1a, + 0x3a, 0x20, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, + 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x6b, 0x38, 0x73, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, + 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x68, 0x75, 0x6d, 0x61, 0x6e, 0x2d, 0x72, 0x65, 0x61, 0x64, + 0x61, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x12, 0x02, 0x0d, 0x04, 0x12, 0x04, 0x82, 0x03, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, + 0x02, 0x0d, 0x06, 0x12, 0x04, 0x82, 0x03, 0x0b, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, + 0x0d, 0x01, 0x12, 0x04, 0x82, 0x03, 0x18, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x0d, + 0x03, 0x12, 0x04, 0x82, 0x03, 0x29, 0x2b, 0x0a, 0x52, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x0e, 0x12, + 0x04, 0x85, 0x03, 0x02, 0x2f, 0x1a, 0x44, 0x20, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, + 0x20, 0x77, 0x61, 0x73, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x12, 0x02, 0x0e, 0x06, 0x12, 0x04, 0x85, 0x03, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, + 0x02, 0x0e, 0x01, 0x12, 0x04, 0x85, 0x03, 0x1c, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, + 0x0e, 0x03, 0x12, 0x04, 0x85, 0x03, 0x2c, 0x2e, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x13, 0x12, 0x06, + 0x88, 0x03, 0x00, 0xa2, 0x03, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x13, 0x01, 0x12, 0x04, 0x88, + 0x03, 0x08, 0x12, 0x0a, 0x35, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x00, 0x12, 0x04, 0x8a, 0x03, 0x02, + 0x59, 0x1a, 0x27, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, + 0x02, 0x00, 0x06, 0x12, 0x04, 0x8a, 0x03, 0x02, 0x23, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, + 0x00, 0x01, 0x12, 0x04, 0x8a, 0x03, 0x24, 0x2d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x00, + 0x03, 0x12, 0x04, 0x8a, 0x03, 0x30, 0x31, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x00, 0x08, + 0x12, 0x04, 0x8a, 0x03, 0x32, 0x58, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x13, 0x02, 0x00, 0x08, 0x87, + 0x09, 0x19, 0x12, 0x04, 0x8a, 0x03, 0x33, 0x57, 0x0a, 0xae, 0x01, 0x0a, 0x04, 0x04, 0x13, 0x02, + 0x01, 0x12, 0x04, 0x8e, 0x03, 0x02, 0x29, 0x1a, 0x9f, 0x01, 0x20, 0x61, 0x6e, 0x20, 0x6f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x69, 0x74, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x2e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x72, + 0x75, 0x6e, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x28, 0x65, 0x78, 0x2e, + 0x20, 0x6f, 0x72, 0x67, 0x2c, 0x0a, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x20, + 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x29, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, + 0x64, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, + 0x01, 0x04, 0x12, 0x04, 0x8e, 0x03, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x01, + 0x05, 0x12, 0x04, 0x8e, 0x03, 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x01, 0x01, + 0x12, 0x04, 0x8e, 0x03, 0x12, 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x01, 0x03, 0x12, + 0x04, 0x8e, 0x03, 0x27, 0x28, 0x0a, 0x2c, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x02, 0x12, 0x04, 0x91, + 0x03, 0x02, 0x26, 0x1a, 0x1e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x02, 0x06, 0x12, 0x04, 0x91, 0x03, + 0x02, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x02, 0x01, 0x12, 0x04, 0x91, 0x03, 0x19, + 0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x02, 0x03, 0x12, 0x04, 0x91, 0x03, 0x24, 0x25, + 0x0a, 0x3b, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x03, 0x12, 0x04, 0x94, 0x03, 0x02, 0x41, 0x1a, 0x2d, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x13, 0x02, 0x03, 0x05, 0x12, 0x04, 0x94, 0x03, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x13, 0x02, 0x03, 0x01, 0x12, 0x04, 0x94, 0x03, 0x09, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x13, 0x02, 0x03, 0x03, 0x12, 0x04, 0x94, 0x03, 0x15, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, + 0x02, 0x03, 0x08, 0x12, 0x04, 0x94, 0x03, 0x17, 0x40, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x13, 0x02, + 0x03, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x04, 0x94, 0x03, 0x18, 0x3f, 0x0a, 0x49, 0x0a, 0x04, + 0x04, 0x13, 0x02, 0x04, 0x12, 0x04, 0x97, 0x03, 0x02, 0x47, 0x1a, 0x3b, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x72, 0x75, 0x6e, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x69, 0x74, 0x73, 0x20, 0x6f, 0x75, 0x74, 0x70, + 0x75, 0x74, 0x20, 0x74, 0x6f, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x04, 0x05, + 0x12, 0x04, 0x97, 0x03, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x04, 0x01, 0x12, + 0x04, 0x97, 0x03, 0x09, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x04, 0x03, 0x12, 0x04, + 0x97, 0x03, 0x1b, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x04, 0x08, 0x12, 0x04, 0x97, + 0x03, 0x1d, 0x46, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x13, 0x02, 0x04, 0x08, 0x87, 0x09, 0x0e, 0x02, + 0x12, 0x04, 0x97, 0x03, 0x1e, 0x45, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x13, 0x08, 0x00, 0x12, 0x06, + 0x99, 0x03, 0x02, 0x9e, 0x03, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x08, 0x00, 0x01, 0x12, + 0x04, 0x99, 0x03, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x08, 0x00, 0x02, 0x12, 0x04, + 0x9a, 0x03, 0x04, 0x30, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x13, 0x08, 0x00, 0x02, 0x87, 0x09, 0x01, + 0x12, 0x04, 0x9a, 0x03, 0x04, 0x30, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x05, 0x12, 0x04, + 0x9b, 0x03, 0x04, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x05, 0x06, 0x12, 0x04, 0x9b, + 0x03, 0x04, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x05, 0x01, 0x12, 0x04, 0x9b, 0x03, + 0x0f, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x05, 0x03, 0x12, 0x04, 0x9b, 0x03, 0x16, + 0x17, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x06, 0x12, 0x04, 0x9c, 0x03, 0x04, 0x22, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x06, 0x06, 0x12, 0x04, 0x9c, 0x03, 0x04, 0x13, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x13, 0x02, 0x06, 0x01, 0x12, 0x04, 0x9c, 0x03, 0x14, 0x1d, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x13, 0x02, 0x06, 0x03, 0x12, 0x04, 0x9c, 0x03, 0x20, 0x21, 0x0a, 0x0c, 0x0a, 0x04, + 0x04, 0x13, 0x02, 0x07, 0x12, 0x04, 0x9d, 0x03, 0x04, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, + 0x02, 0x07, 0x06, 0x12, 0x04, 0x9d, 0x03, 0x04, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, + 0x07, 0x01, 0x12, 0x04, 0x9d, 0x03, 0x10, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x07, + 0x03, 0x12, 0x04, 0x9d, 0x03, 0x18, 0x1a, 0x0a, 0x3c, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x08, 0x12, + 0x04, 0xa1, 0x03, 0x02, 0x13, 0x1a, 0x2e, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x6e, 0x67, + 0x73, 0x20, 0x74, 0x6f, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x08, 0x05, 0x12, 0x04, + 0xa1, 0x03, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x08, 0x01, 0x12, 0x04, 0xa1, + 0x03, 0x09, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x08, 0x03, 0x12, 0x04, 0xa1, 0x03, + 0x11, 0x12, 0x0a, 0x0c, 0x0a, 0x02, 0x05, 0x01, 0x12, 0x06, 0xa4, 0x03, 0x00, 0xa9, 0x03, 0x01, + 0x0a, 0x0b, 0x0a, 0x03, 0x05, 0x01, 0x01, 0x12, 0x04, 0xa4, 0x03, 0x05, 0x0e, 0x0a, 0x0c, 0x0a, + 0x04, 0x05, 0x01, 0x02, 0x00, 0x12, 0x04, 0xa5, 0x03, 0x02, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x05, + 0x01, 0x02, 0x00, 0x01, 0x12, 0x04, 0xa5, 0x03, 0x02, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x01, + 0x02, 0x00, 0x02, 0x12, 0x04, 0xa5, 0x03, 0x1b, 0x1c, 0x0a, 0x0c, 0x0a, 0x04, 0x05, 0x01, 0x02, + 0x01, 0x12, 0x04, 0xa6, 0x03, 0x02, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x01, 0x01, + 0x12, 0x04, 0xa6, 0x03, 0x02, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x01, 0x02, 0x12, + 0x04, 0xa6, 0x03, 0x13, 0x14, 0x0a, 0x0c, 0x0a, 0x04, 0x05, 0x01, 0x02, 0x02, 0x12, 0x04, 0xa7, + 0x03, 0x02, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x02, 0x01, 0x12, 0x04, 0xa7, 0x03, + 0x02, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x02, 0x02, 0x12, 0x04, 0xa7, 0x03, 0x13, + 0x14, 0x0a, 0x0c, 0x0a, 0x04, 0x05, 0x01, 0x02, 0x03, 0x12, 0x04, 0xa8, 0x03, 0x02, 0x22, 0x0a, + 0x0d, 0x0a, 0x05, 0x05, 0x01, 0x02, 0x03, 0x01, 0x12, 0x04, 0xa8, 0x03, 0x02, 0x1d, 0x0a, 0x0d, + 0x0a, 0x05, 0x05, 0x01, 0x02, 0x03, 0x02, 0x12, 0x04, 0xa8, 0x03, 0x20, 0x21, 0x0a, 0x49, 0x0a, + 0x02, 0x04, 0x14, 0x12, 0x06, 0xac, 0x03, 0x00, 0xe1, 0x03, 0x01, 0x1a, 0x3b, 0x20, 0x54, 0x61, + 0x73, 0x6b, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, + 0x74, 0x73, 0x20, 0x61, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x75, + 0x6e, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x63, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x14, 0x01, 0x12, + 0x04, 0xac, 0x03, 0x08, 0x11, 0x0a, 0x1a, 0x0a, 0x04, 0x04, 0x14, 0x02, 0x00, 0x12, 0x04, 0xae, + 0x03, 0x02, 0x17, 0x1a, 0x0c, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x00, 0x05, 0x12, 0x04, 0xae, 0x03, 0x02, 0x08, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x00, 0x01, 0x12, 0x04, 0xae, 0x03, 0x09, 0x12, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x00, 0x03, 0x12, 0x04, 0xae, 0x03, 0x15, 0x16, 0x0a, 0x21, + 0x0a, 0x04, 0x04, 0x14, 0x02, 0x01, 0x12, 0x04, 0xb1, 0x03, 0x02, 0x1e, 0x1a, 0x13, 0x20, 0x45, + 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x01, 0x05, 0x12, 0x04, 0xb1, 0x03, 0x02, 0x08, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x01, 0x01, 0x12, 0x04, 0xb1, 0x03, 0x09, 0x19, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x01, 0x03, 0x12, 0x04, 0xb1, 0x03, 0x1c, 0x1d, 0x0a, 0x33, + 0x0a, 0x04, 0x04, 0x14, 0x02, 0x02, 0x12, 0x04, 0xb4, 0x03, 0x02, 0x17, 0x1a, 0x25, 0x20, 0x54, + 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x72, + 0x75, 0x6e, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x61, 0x73, + 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x02, 0x05, 0x12, 0x04, 0xb4, 0x03, + 0x02, 0x07, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x02, 0x01, 0x12, 0x04, 0xb4, 0x03, 0x08, + 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x02, 0x03, 0x12, 0x04, 0xb4, 0x03, 0x15, 0x16, + 0x0a, 0x31, 0x0a, 0x04, 0x04, 0x14, 0x02, 0x03, 0x12, 0x04, 0xb7, 0x03, 0x02, 0x30, 0x1a, 0x23, + 0x20, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x72, 0x75, + 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x03, 0x06, 0x12, 0x04, 0xb7, 0x03, + 0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x03, 0x01, 0x12, 0x04, 0xb7, 0x03, 0x1c, + 0x2b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x03, 0x03, 0x12, 0x04, 0xb7, 0x03, 0x2e, 0x2f, + 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x14, 0x03, 0x00, 0x12, 0x06, 0xb9, 0x03, 0x02, 0xbc, 0x03, 0x03, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x03, 0x00, 0x01, 0x12, 0x04, 0xb9, 0x03, 0x0a, 0x16, 0x0a, + 0x0e, 0x0a, 0x06, 0x04, 0x14, 0x03, 0x00, 0x02, 0x00, 0x12, 0x04, 0xba, 0x03, 0x04, 0x18, 0x0a, + 0x0f, 0x0a, 0x07, 0x04, 0x14, 0x03, 0x00, 0x02, 0x00, 0x05, 0x12, 0x04, 0xba, 0x03, 0x04, 0x0a, + 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x14, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, 0xba, 0x03, 0x0b, + 0x13, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x14, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x04, 0xba, 0x03, + 0x16, 0x17, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x14, 0x03, 0x00, 0x02, 0x01, 0x12, 0x04, 0xbb, 0x03, + 0x04, 0x21, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x14, 0x03, 0x00, 0x02, 0x01, 0x06, 0x12, 0x04, 0xbb, + 0x03, 0x04, 0x16, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x14, 0x03, 0x00, 0x02, 0x01, 0x01, 0x12, 0x04, + 0xbb, 0x03, 0x17, 0x1c, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x14, 0x03, 0x00, 0x02, 0x01, 0x03, 0x12, + 0x04, 0xbb, 0x03, 0x1f, 0x20, 0x0a, 0x6d, 0x0a, 0x04, 0x04, 0x14, 0x02, 0x04, 0x12, 0x04, 0xbf, + 0x03, 0x02, 0x2c, 0x1a, 0x5f, 0x20, 0x52, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x72, 0x75, 0x6e, + 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x65, 0x73, 0x2c, 0x20, 0x6f, 0x72, 0x64, 0x65, 0x72, + 0x65, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6e, 0x65, 0x77, 0x65, 0x73, 0x74, 0x20, 0x74, + 0x6f, 0x20, 0x6f, 0x6c, 0x64, 0x65, 0x73, 0x74, 0x2e, 0x20, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, + 0x20, 0x6f, 0x66, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x65, 0x73, 0x20, 0x64, 0x65, 0x74, + 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x04, 0x04, 0x12, 0x04, 0xbf, + 0x03, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x04, 0x06, 0x12, 0x04, 0xbf, 0x03, + 0x0b, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x04, 0x01, 0x12, 0x04, 0xbf, 0x03, 0x18, + 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x04, 0x03, 0x12, 0x04, 0xbf, 0x03, 0x2a, 0x2b, + 0x0a, 0x9e, 0x01, 0x0a, 0x04, 0x04, 0x14, 0x02, 0x05, 0x12, 0x04, 0xc3, 0x03, 0x02, 0x22, 0x1a, + 0x8f, 0x01, 0x20, 0x41, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x20, 0x66, 0x61, 0x69, 0x6c, 0x75, + 0x72, 0x65, 0x20, 0x72, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x20, + 0x69, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x20, 0x28, 0x30, + 0x2e, 0x30, 0x20, 0x74, 0x6f, 0x20, 0x31, 0x2e, 0x30, 0x29, 0x2e, 0x0a, 0x20, 0x43, 0x6f, 0x6d, + 0x70, 0x75, 0x74, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, + 0x6f, 0x66, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x20, 0x46, 0x41, 0x49, 0x4c, 0x45, + 0x44, 0x20, 0x64, 0x69, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x6f, 0x74, + 0x61, 0x6c, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x05, 0x05, 0x12, 0x04, 0xc3, 0x03, 0x02, 0x08, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x05, 0x01, 0x12, 0x04, 0xc3, 0x03, 0x09, 0x1d, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x05, 0x03, 0x12, 0x04, 0xc3, 0x03, 0x20, 0x21, 0x0a, 0x37, + 0x0a, 0x04, 0x04, 0x14, 0x02, 0x06, 0x12, 0x04, 0xc6, 0x03, 0x02, 0x30, 0x1a, 0x29, 0x20, 0x41, + 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x20, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x6f, 0x66, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x06, 0x06, + 0x12, 0x04, 0xc6, 0x03, 0x02, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x06, 0x01, 0x12, + 0x04, 0xc6, 0x03, 0x1b, 0x2b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x06, 0x03, 0x12, 0x04, + 0xc6, 0x03, 0x2e, 0x2f, 0x0a, 0x4b, 0x0a, 0x04, 0x04, 0x14, 0x02, 0x07, 0x12, 0x04, 0xc9, 0x03, + 0x02, 0x35, 0x1a, 0x3d, 0x20, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, + 0x74, 0x20, 0x66, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x28, + 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x29, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x07, 0x06, 0x12, 0x04, 0xc9, 0x03, 0x02, 0x1b, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x07, 0x01, 0x12, 0x04, 0xc9, 0x03, 0x1c, 0x30, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x07, 0x03, 0x12, 0x04, 0xc9, 0x03, 0x33, 0x34, 0x0a, 0x5d, + 0x0a, 0x04, 0x04, 0x14, 0x02, 0x08, 0x12, 0x04, 0xcc, 0x03, 0x02, 0x32, 0x1a, 0x4f, 0x20, 0x4c, + 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x75, 0x73, 0x65, 0x72, 0x2f, 0x61, 0x70, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x73, 0x20, 0x65, 0x6e, 0x72, 0x69, 0x63, 0x68, + 0x65, 0x64, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x20, 0x69, 0x6e, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x14, 0x02, 0x08, 0x04, 0x12, 0x04, 0xcc, 0x03, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x14, 0x02, 0x08, 0x06, 0x12, 0x04, 0xcc, 0x03, 0x0b, 0x22, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x14, 0x02, 0x08, 0x01, 0x12, 0x04, 0xcc, 0x03, 0x23, 0x2d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, + 0x02, 0x08, 0x03, 0x12, 0x04, 0xcc, 0x03, 0x30, 0x31, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x14, 0x02, + 0x09, 0x12, 0x04, 0xce, 0x03, 0x02, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x09, 0x05, + 0x12, 0x04, 0xce, 0x03, 0x02, 0x06, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x09, 0x01, 0x12, + 0x04, 0xce, 0x03, 0x07, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x09, 0x03, 0x12, 0x04, + 0xce, 0x03, 0x17, 0x19, 0x0a, 0x37, 0x0a, 0x04, 0x04, 0x14, 0x02, 0x0a, 0x12, 0x04, 0xd1, 0x03, + 0x02, 0x19, 0x1a, 0x29, 0x20, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, + 0x28, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x29, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x14, 0x02, 0x0a, 0x05, 0x12, 0x04, 0xd1, 0x03, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x14, 0x02, 0x0a, 0x01, 0x12, 0x04, 0xd1, 0x03, 0x09, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x14, 0x02, 0x0a, 0x03, 0x12, 0x04, 0xd1, 0x03, 0x16, 0x18, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x14, + 0x03, 0x01, 0x12, 0x06, 0xd3, 0x03, 0x02, 0xd7, 0x03, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, + 0x03, 0x01, 0x01, 0x12, 0x04, 0xd3, 0x03, 0x0a, 0x15, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x14, 0x03, + 0x01, 0x02, 0x00, 0x12, 0x04, 0xd4, 0x03, 0x04, 0x19, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x14, 0x03, + 0x01, 0x02, 0x00, 0x05, 0x12, 0x04, 0xd4, 0x03, 0x04, 0x09, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x14, + 0x03, 0x01, 0x02, 0x00, 0x01, 0x12, 0x04, 0xd4, 0x03, 0x0a, 0x14, 0x0a, 0x0f, 0x0a, 0x07, 0x04, + 0x14, 0x03, 0x01, 0x02, 0x00, 0x03, 0x12, 0x04, 0xd4, 0x03, 0x17, 0x18, 0x0a, 0x0e, 0x0a, 0x06, + 0x04, 0x14, 0x03, 0x01, 0x02, 0x01, 0x12, 0x04, 0xd5, 0x03, 0x04, 0x1b, 0x0a, 0x0f, 0x0a, 0x07, + 0x04, 0x14, 0x03, 0x01, 0x02, 0x01, 0x05, 0x12, 0x04, 0xd5, 0x03, 0x04, 0x09, 0x0a, 0x0f, 0x0a, + 0x07, 0x04, 0x14, 0x03, 0x01, 0x02, 0x01, 0x01, 0x12, 0x04, 0xd5, 0x03, 0x0a, 0x16, 0x0a, 0x0f, + 0x0a, 0x07, 0x04, 0x14, 0x03, 0x01, 0x02, 0x01, 0x03, 0x12, 0x04, 0xd5, 0x03, 0x19, 0x1a, 0x0a, + 0x0e, 0x0a, 0x06, 0x04, 0x14, 0x03, 0x01, 0x02, 0x02, 0x12, 0x04, 0xd6, 0x03, 0x04, 0x20, 0x0a, + 0x0f, 0x0a, 0x07, 0x04, 0x14, 0x03, 0x01, 0x02, 0x02, 0x05, 0x12, 0x04, 0xd6, 0x03, 0x04, 0x09, + 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x14, 0x03, 0x01, 0x02, 0x02, 0x01, 0x12, 0x04, 0xd6, 0x03, 0x0a, + 0x1b, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x14, 0x03, 0x01, 0x02, 0x02, 0x03, 0x12, 0x04, 0xd6, 0x03, + 0x1e, 0x1f, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x14, 0x02, 0x0b, 0x12, 0x04, 0xd9, 0x03, 0x02, 0x20, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x0b, 0x06, 0x12, 0x04, 0xd9, 0x03, 0x02, 0x0d, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x0b, 0x01, 0x12, 0x04, 0xd9, 0x03, 0x0e, 0x1a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x14, 0x02, 0x0b, 0x03, 0x12, 0x04, 0xd9, 0x03, 0x1d, 0x1f, 0x0a, 0x0e, 0x0a, + 0x04, 0x04, 0x14, 0x03, 0x02, 0x12, 0x06, 0xdb, 0x03, 0x02, 0xde, 0x03, 0x03, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x14, 0x03, 0x02, 0x01, 0x12, 0x04, 0xdb, 0x03, 0x0a, 0x15, 0x0a, 0x0e, 0x0a, 0x06, + 0x04, 0x14, 0x03, 0x02, 0x02, 0x00, 0x12, 0x04, 0xdc, 0x03, 0x04, 0x21, 0x0a, 0x0f, 0x0a, 0x07, + 0x04, 0x14, 0x03, 0x02, 0x02, 0x00, 0x06, 0x12, 0x04, 0xdc, 0x03, 0x04, 0x16, 0x0a, 0x0f, 0x0a, + 0x07, 0x04, 0x14, 0x03, 0x02, 0x02, 0x00, 0x01, 0x12, 0x04, 0xdc, 0x03, 0x17, 0x1c, 0x0a, 0x0f, + 0x0a, 0x07, 0x04, 0x14, 0x03, 0x02, 0x02, 0x00, 0x03, 0x12, 0x04, 0xdc, 0x03, 0x1f, 0x20, 0x0a, + 0x0e, 0x0a, 0x06, 0x04, 0x14, 0x03, 0x02, 0x02, 0x01, 0x12, 0x04, 0xdd, 0x03, 0x04, 0x14, 0x0a, + 0x0f, 0x0a, 0x07, 0x04, 0x14, 0x03, 0x02, 0x02, 0x01, 0x05, 0x12, 0x04, 0xdd, 0x03, 0x04, 0x09, + 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x14, 0x03, 0x02, 0x02, 0x01, 0x01, 0x12, 0x04, 0xdd, 0x03, 0x0a, + 0x0f, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x14, 0x03, 0x02, 0x02, 0x01, 0x03, 0x12, 0x04, 0xdd, 0x03, + 0x12, 0x13, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x14, 0x02, 0x0c, 0x12, 0x04, 0xe0, 0x03, 0x02, 0x29, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x0c, 0x04, 0x12, 0x04, 0xe0, 0x03, 0x02, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x0c, 0x06, 0x12, 0x04, 0xe0, 0x03, 0x0b, 0x16, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x14, 0x02, 0x0c, 0x01, 0x12, 0x04, 0xe0, 0x03, 0x17, 0x23, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x14, 0x02, 0x0c, 0x03, 0x12, 0x04, 0xe0, 0x03, 0x26, 0x28, 0x62, 0x06, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xc2, 0x21, 0x0a, 0x26, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x71, 0x75, 0x65, 0x75, + 0x65, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, + 0x12, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, + 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, + 0x61, 0x73, 0x6b, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x18, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, + 0x2f, 0x72, 0x75, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x27, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x72, + 0x75, 0x6e, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x22, 0xa7, 0x04, 0x0a, 0x14, 0x45, 0x6e, 0x71, 0x75, 0x65, 0x75, 0x65, 0x41, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x47, 0x0a, 0x09, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x31, 0x0a, 0x12, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x48, 0x01, 0x52, 0x10, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, 0x32, 0x0a, 0x08, 0x72, 0x75, 0x6e, 0x5f, + 0x73, 0x70, 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x52, 0x75, 0x6e, 0x53, + 0x70, 0x65, 0x63, 0x52, 0x07, 0x72, 0x75, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x12, 0x24, 0x0a, 0x09, + 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x42, + 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x08, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x55, + 0x72, 0x69, 0x12, 0x2f, 0x0a, 0x0f, 0x72, 0x75, 0x6e, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, + 0x5f, 0x62, 0x61, 0x73, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, + 0x72, 0x02, 0x10, 0x01, 0x52, 0x0d, 0x72, 0x75, 0x6e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x42, + 0x61, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x08, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x62, + 0x6a, 0x65, 0x63, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x75, 0x62, 0x6a, + 0x65, 0x63, 0x74, 0x12, 0x34, 0x0a, 0x04, 0x74, 0x61, 0x73, 0x6b, 0x18, 0x0a, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x41, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x48, 0x00, 0x52, 0x04, 0x74, 0x61, 0x73, 0x6b, 0x12, 0x37, 0x0a, 0x05, 0x74, 0x72, 0x61, + 0x63, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x72, + 0x61, 0x63, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x05, 0x74, 0x72, 0x61, + 0x63, 0x65, 0x12, 0x43, 0x0a, 0x09, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, + 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x43, 0x6f, 0x6e, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x09, 0x63, 0x6f, + 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x0d, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x12, + 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x42, 0x15, 0x0a, 0x13, 0x5f, 0x70, 0x61, 0x72, 0x65, 0x6e, + 0x74, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x17, 0x0a, + 0x15, 0x45, 0x6e, 0x71, 0x75, 0x65, 0x75, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x7f, 0x0a, 0x15, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x51, + 0x75, 0x65, 0x75, 0x65, 0x64, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x3e, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x52, 0x75, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x12, + 0x1b, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, + 0x00, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x88, 0x01, 0x01, 0x42, 0x09, 0x0a, 0x07, + 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x22, 0x18, 0x0a, 0x16, 0x41, 0x62, 0x6f, 0x72, 0x74, + 0x51, 0x75, 0x65, 0x75, 0x65, 0x64, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x8b, 0x01, 0x0a, 0x18, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x51, 0x75, 0x65, 0x75, 0x65, + 0x64, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x47, + 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, + 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, + 0x6e, 0x88, 0x01, 0x01, 0x42, 0x09, 0x0a, 0x07, 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x22, + 0x1b, 0x0a, 0x19, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x51, 0x75, 0x65, 0x75, 0x65, 0x64, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0xd5, 0x02, 0x0a, + 0x0c, 0x51, 0x75, 0x65, 0x75, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x66, 0x0a, + 0x0d, 0x45, 0x6e, 0x71, 0x75, 0x65, 0x75, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x28, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2e, 0x45, 0x6e, 0x71, 0x75, 0x65, 0x75, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x45, 0x6e, + 0x71, 0x75, 0x65, 0x75, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x0e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x51, 0x75, + 0x65, 0x75, 0x65, 0x64, 0x52, 0x75, 0x6e, 0x12, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x62, 0x6f, + 0x72, 0x74, 0x51, 0x75, 0x65, 0x75, 0x65, 0x64, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x51, 0x75, 0x65, + 0x75, 0x65, 0x64, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, + 0x12, 0x72, 0x0a, 0x11, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x51, 0x75, 0x65, 0x75, 0x65, 0x64, 0x41, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, + 0x51, 0x75, 0x65, 0x75, 0x65, 0x64, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x51, 0x75, + 0x65, 0x75, 0x65, 0x64, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x00, 0x42, 0xcc, 0x01, 0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x42, + 0x11, 0x51, 0x75, 0x65, 0x75, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, + 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x36, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, + 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, + 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xa2, 0x02, 0x03, 0x46, + 0x57, 0x58, 0xaa, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x57, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xca, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x5c, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xe2, 0x02, 0x1e, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x13, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x57, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x4a, 0xab, 0x14, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x4f, 0x24, 0x0a, 0x08, + 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, + 0x00, 0x1b, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, + 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x2b, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, + 0x06, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x03, 0x12, 0x03, 0x07, 0x00, 0x22, 0x0a, 0x09, + 0x0a, 0x02, 0x03, 0x04, 0x12, 0x03, 0x08, 0x00, 0x31, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, + 0x0a, 0x00, 0x4d, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x0a, 0x00, 0x4d, 0x0a, 0x60, + 0x0a, 0x02, 0x06, 0x00, 0x12, 0x04, 0x0d, 0x00, 0x16, 0x01, 0x1a, 0x54, 0x20, 0x70, 0x72, 0x6f, + 0x76, 0x69, 0x64, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, + 0x63, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x20, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x75, 0x6e, + 0x73, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x73, 0x2e, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x06, 0x00, 0x01, 0x12, 0x03, 0x0d, 0x08, 0x14, 0x0a, 0x30, 0x0a, 0x04, + 0x06, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0f, 0x02, 0x4c, 0x1a, 0x23, 0x20, 0x71, 0x75, 0x65, 0x75, + 0x65, 0x20, 0x61, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0f, 0x06, 0x13, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x0f, 0x14, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x0f, 0x33, 0x48, 0x0a, 0x22, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x01, + 0x12, 0x03, 0x12, 0x02, 0x4f, 0x1a, 0x15, 0x20, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x20, 0x61, 0x20, + 0x71, 0x75, 0x65, 0x75, 0x65, 0x64, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x12, 0x06, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x01, 0x02, 0x12, 0x03, 0x12, 0x15, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x12, 0x35, 0x4b, 0x0a, 0x79, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x02, 0x12, 0x03, + 0x15, 0x02, 0x58, 0x1a, 0x6c, 0x20, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x73, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, + 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x61, + 0x73, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x20, 0x71, 0x75, 0x65, + 0x75, 0x65, 0x64, 0x20, 0x6f, 0x72, 0x20, 0x69, 0x73, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, + 0x74, 0x6c, 0x79, 0x20, 0x62, 0x65, 0x69, 0x6e, 0x67, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, + 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x15, 0x06, 0x17, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x15, 0x18, 0x30, 0x0a, 0x0c, 0x0a, + 0x05, 0x06, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x15, 0x3b, 0x54, 0x0a, 0x34, 0x0a, 0x02, 0x04, + 0x00, 0x12, 0x04, 0x19, 0x00, 0x36, 0x01, 0x1a, 0x28, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x71, 0x75, + 0x65, 0x75, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, + 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x19, 0x08, 0x1c, 0x0a, 0x34, 0x0a, + 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x1b, 0x02, 0x59, 0x1a, 0x27, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x1b, 0x02, + 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1b, 0x24, 0x2d, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1b, 0x30, 0x31, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x08, 0x12, 0x03, 0x1b, 0x32, 0x58, 0x0a, 0x0f, 0x0a, 0x08, 0x04, + 0x00, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x1b, 0x33, 0x57, 0x0a, 0xad, 0x01, 0x0a, + 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x1f, 0x02, 0x29, 0x1a, 0x9f, 0x01, 0x20, 0x61, 0x6e, + 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x61, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x69, 0x74, 0x20, 0x65, 0x78, 0x69, 0x73, + 0x74, 0x73, 0x2e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x69, 0x6e, + 0x67, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x28, + 0x65, 0x78, 0x2e, 0x20, 0x6f, 0x72, 0x67, 0x2c, 0x0a, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x2c, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x29, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, + 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x20, 0x61, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x20, 0x64, 0x65, 0x66, + 0x69, 0x6e, 0x65, 0x64, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x04, 0x12, 0x03, 0x1f, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x01, 0x05, 0x12, 0x03, 0x1f, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x1f, 0x12, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x1f, 0x27, 0x28, 0x0a, 0x72, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x22, 0x02, + 0x1c, 0x1a, 0x65, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x72, 0x75, 0x6e, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, + 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x20, 0x61, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x65, + 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x64, 0x6f, 0x77, 0x6e, 0x73, 0x74, 0x72, + 0x65, 0x61, 0x6d, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, + 0x06, 0x12, 0x03, 0x22, 0x02, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x22, 0x0f, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x22, + 0x1a, 0x1b, 0x0a, 0x3a, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x25, 0x02, 0x41, 0x1a, + 0x2d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x05, 0x12, 0x03, 0x25, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x25, 0x09, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x03, 0x03, 0x12, 0x03, 0x25, 0x15, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, + 0x08, 0x12, 0x03, 0x25, 0x17, 0x40, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x03, 0x08, 0x87, + 0x09, 0x0e, 0x02, 0x12, 0x03, 0x25, 0x18, 0x3f, 0x0a, 0x48, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x04, + 0x12, 0x03, 0x28, 0x02, 0x47, 0x1a, 0x3b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x20, + 0x62, 0x61, 0x73, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x77, 0x72, 0x69, + 0x74, 0x65, 0x20, 0x69, 0x74, 0x73, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x74, 0x6f, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x05, 0x12, 0x03, 0x28, 0x02, 0x08, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x28, 0x09, 0x18, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, 0x28, 0x1b, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x04, 0x08, 0x12, 0x03, 0x28, 0x1d, 0x46, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, + 0x02, 0x04, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x28, 0x1e, 0x45, 0x0a, 0x3b, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x2b, 0x02, 0x13, 0x1a, 0x2e, 0x20, 0x67, 0x72, 0x6f, 0x75, + 0x70, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x62, 0x65, + 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x61, 0x70, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x05, 0x05, 0x12, 0x03, 0x2b, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x01, + 0x12, 0x03, 0x2b, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x03, 0x12, 0x03, + 0x2b, 0x11, 0x12, 0x0a, 0x36, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x06, 0x12, 0x03, 0x2e, 0x02, 0x15, + 0x1a, 0x29, 0x20, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x2c, + 0x20, 0x69, 0x66, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x06, 0x05, 0x12, 0x03, 0x2e, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x06, 0x01, 0x12, 0x03, 0x2e, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x03, + 0x12, 0x03, 0x2e, 0x13, 0x14, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x00, 0x08, 0x00, 0x12, 0x04, 0x30, + 0x02, 0x35, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x08, 0x00, 0x01, 0x12, 0x03, 0x30, 0x08, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x08, 0x00, 0x02, 0x12, 0x03, 0x31, 0x04, 0x30, 0x0a, + 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x08, 0x00, 0x02, 0x87, 0x09, 0x01, 0x12, 0x03, 0x31, 0x04, 0x30, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x07, 0x12, 0x03, 0x32, 0x04, 0x19, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x07, 0x06, 0x12, 0x03, 0x32, 0x04, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x07, 0x01, 0x12, 0x03, 0x32, 0x0f, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x07, 0x03, 0x12, 0x03, 0x32, 0x16, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x08, 0x12, + 0x03, 0x33, 0x04, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x06, 0x12, 0x03, 0x33, + 0x04, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x01, 0x12, 0x03, 0x33, 0x10, 0x15, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x03, 0x12, 0x03, 0x33, 0x18, 0x1a, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x09, 0x12, 0x03, 0x34, 0x04, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x09, 0x06, 0x12, 0x03, 0x34, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x09, 0x01, 0x12, 0x03, 0x34, 0x14, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x09, 0x03, + 0x12, 0x03, 0x34, 0x20, 0x22, 0x0a, 0x34, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x03, 0x39, 0x00, 0x20, + 0x1a, 0x29, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x71, 0x75, 0x65, 0x75, 0x69, 0x6e, 0x67, 0x20, + 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x01, 0x01, 0x12, 0x03, 0x39, 0x08, 0x1d, 0x0a, 0x31, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x3c, + 0x00, 0x42, 0x01, 0x1a, 0x25, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x69, + 0x6e, 0x67, 0x20, 0x61, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, + 0x01, 0x12, 0x03, 0x3c, 0x08, 0x1d, 0x0a, 0x3f, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, + 0x3e, 0x02, 0x49, 0x1a, 0x32, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, + 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x61, 0x62, + 0x6f, 0x72, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x3e, 0x02, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x3e, 0x17, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x3e, 0x20, + 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x08, 0x12, 0x03, 0x3e, 0x22, 0x48, 0x0a, + 0x0f, 0x0a, 0x08, 0x04, 0x02, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x3e, 0x23, 0x47, + 0x0a, 0x3a, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x41, 0x02, 0x1d, 0x1a, 0x2d, 0x20, + 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x62, 0x6f, 0x72, 0x74, + 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x2c, 0x20, 0x69, 0x66, 0x20, + 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x01, 0x04, 0x12, 0x03, 0x41, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x01, 0x05, 0x12, 0x03, 0x41, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x41, 0x12, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x41, 0x1b, 0x1c, 0x0a, 0x31, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x03, 0x45, 0x00, 0x21, 0x1a, + 0x26, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x20, + 0x61, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, + 0x45, 0x08, 0x1e, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x47, 0x00, 0x4d, 0x01, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x47, 0x08, 0x20, 0x0a, 0x4d, 0x0a, 0x04, 0x04, + 0x04, 0x02, 0x00, 0x12, 0x03, 0x49, 0x02, 0x4f, 0x1a, 0x40, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x64, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, + 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x62, + 0x65, 0x20, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x00, 0x06, 0x12, 0x03, 0x49, 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x49, 0x1a, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x49, 0x26, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x08, 0x12, 0x03, 0x49, + 0x28, 0x4e, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x04, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, + 0x49, 0x29, 0x4d, 0x0a, 0x3d, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x4c, 0x02, 0x1d, + 0x1a, 0x30, 0x20, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x62, + 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x04, 0x12, 0x03, 0x4c, 0x02, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x05, 0x12, 0x03, 0x4c, 0x0b, 0x11, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x4c, 0x12, 0x18, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x4c, 0x1b, 0x1c, 0x0a, 0x09, 0x0a, 0x02, 0x04, 0x05, + 0x12, 0x03, 0x4f, 0x00, 0x24, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x4f, 0x08, + 0x21, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xdd, 0x0c, 0x0a, 0x29, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x2f, 0x72, 0x75, 0x6e, 0x5f, 0x6c, 0x6f, 0x67, 0x73, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x1a, 0x1b, 0x62, 0x75, 0x66, + 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x26, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x6c, 0x6f, 0x67, 0x73, 0x2f, 0x64, 0x61, 0x74, 0x61, + 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x22, 0x7d, 0x0a, 0x0f, 0x54, 0x61, 0x69, 0x6c, 0x4c, 0x6f, 0x67, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, + 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, + 0x21, 0x0a, 0x07, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, + 0x42, 0x07, 0xba, 0x48, 0x04, 0x2a, 0x02, 0x20, 0x00, 0x52, 0x07, 0x61, 0x74, 0x74, 0x65, 0x6d, + 0x70, 0x74, 0x22, 0x92, 0x01, 0x0a, 0x10, 0x54, 0x61, 0x69, 0x6c, 0x4c, 0x6f, 0x67, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3d, 0x0a, 0x04, 0x6c, 0x6f, 0x67, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x61, 0x69, 0x6c, 0x4c, + 0x6f, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x4c, 0x6f, 0x67, 0x73, + 0x52, 0x04, 0x6c, 0x6f, 0x67, 0x73, 0x1a, 0x3f, 0x0a, 0x04, 0x4c, 0x6f, 0x67, 0x73, 0x12, 0x37, + 0x0a, 0x05, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x64, + 0x61, 0x74, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2e, 0x4c, 0x6f, 0x67, 0x4c, 0x69, 0x6e, 0x65, + 0x52, 0x05, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x32, 0x6e, 0x0a, 0x0e, 0x52, 0x75, 0x6e, 0x4c, 0x6f, + 0x67, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x5c, 0x0a, 0x08, 0x54, 0x61, 0x69, + 0x6c, 0x4c, 0x6f, 0x67, 0x73, 0x12, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x61, 0x69, 0x6c, 0x4c, + 0x6f, 0x67, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, + 0x54, 0x61, 0x69, 0x6c, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x03, 0x90, 0x02, 0x01, 0x30, 0x01, 0x42, 0xce, 0x01, 0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x42, 0x13, 0x52, 0x75, 0x6e, 0x4c, 0x6f, 0x67, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x36, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0xa2, 0x02, 0x03, 0x46, 0x57, 0x58, 0xaa, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xca, 0x02, 0x12, 0x46, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0xe2, 0x02, 0x1e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x57, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x13, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, + 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x4a, 0xd6, 0x06, 0x0a, 0x06, 0x12, 0x04, 0x00, + 0x00, 0x24, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, + 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x1b, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, + 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x2b, 0x0a, 0x09, 0x0a, + 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, 0x30, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x08, + 0x00, 0x4d, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x08, 0x00, 0x4d, 0x0a, 0x46, 0x0a, + 0x02, 0x06, 0x00, 0x12, 0x04, 0x0b, 0x00, 0x0f, 0x01, 0x1a, 0x3a, 0x20, 0x52, 0x75, 0x6e, 0x4c, + 0x6f, 0x67, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67, 0x20, 0x6c, + 0x6f, 0x67, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x06, 0x00, 0x01, 0x12, 0x03, 0x0b, 0x08, + 0x16, 0x0a, 0x0c, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x00, 0x12, 0x04, 0x0c, 0x02, 0x0e, 0x03, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0c, 0x06, 0x0e, 0x0a, 0x0c, 0x0a, + 0x05, 0x06, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x0c, 0x0f, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x06, + 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x0c, 0x29, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x0c, 0x30, 0x40, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x04, + 0x12, 0x03, 0x0d, 0x04, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, 0x06, 0x00, 0x02, 0x00, 0x04, 0x22, 0x12, + 0x03, 0x0d, 0x04, 0x2f, 0x0a, 0x2f, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x12, 0x00, 0x18, 0x01, + 0x1a, 0x23, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x69, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x6c, + 0x6f, 0x67, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x12, 0x08, + 0x17, 0x0a, 0x1d, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x14, 0x02, 0x4f, 0x1a, 0x10, + 0x20, 0x54, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x64, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x14, 0x02, 0x19, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x14, 0x1a, 0x23, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x14, 0x26, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x08, 0x12, 0x03, 0x14, 0x28, 0x4e, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x02, 0x00, + 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x14, 0x29, 0x4d, 0x0a, 0x22, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x01, 0x12, 0x03, 0x17, 0x02, 0x3a, 0x1a, 0x15, 0x20, 0x54, 0x68, 0x65, 0x20, 0x61, 0x74, 0x74, + 0x65, 0x6d, 0x70, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x17, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x17, 0x09, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x01, 0x03, 0x12, 0x03, 0x17, 0x13, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x08, + 0x12, 0x03, 0x17, 0x15, 0x39, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x01, 0x08, 0x87, 0x09, + 0x05, 0x04, 0x12, 0x03, 0x17, 0x16, 0x38, 0x0a, 0x2f, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x1b, + 0x00, 0x24, 0x01, 0x1a, 0x23, 0x20, 0x52, 0x65, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x69, 0x6c, 0x69, 0x6e, + 0x67, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, + 0x03, 0x1b, 0x08, 0x18, 0x0a, 0x20, 0x0a, 0x04, 0x04, 0x01, 0x03, 0x00, 0x12, 0x04, 0x1d, 0x02, + 0x20, 0x03, 0x1a, 0x12, 0x20, 0x41, 0x20, 0x62, 0x61, 0x74, 0x63, 0x68, 0x20, 0x6f, 0x66, 0x20, + 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x03, 0x00, 0x01, 0x12, + 0x03, 0x1d, 0x0a, 0x0e, 0x0a, 0x26, 0x0a, 0x06, 0x04, 0x01, 0x03, 0x00, 0x02, 0x00, 0x12, 0x03, + 0x1f, 0x04, 0x38, 0x1a, 0x17, 0x20, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x64, + 0x20, 0x6c, 0x6f, 0x67, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x01, 0x03, 0x00, 0x02, 0x00, 0x04, 0x12, 0x03, 0x1f, 0x04, 0x0c, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x01, 0x03, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x1f, 0x0d, 0x2d, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x01, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1f, 0x2e, 0x33, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x01, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1f, 0x36, 0x37, 0x0a, 0x2b, 0x0a, 0x04, + 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x23, 0x02, 0x19, 0x1a, 0x1e, 0x20, 0x4f, 0x6e, 0x65, 0x20, + 0x6f, 0x72, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x00, 0x04, 0x12, 0x03, 0x23, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x23, 0x0b, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x23, 0x10, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x23, 0x17, + 0x18, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xd0, 0x84, 0x01, 0x0a, 0x24, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x2f, 0x72, 0x75, 0x6e, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x1a, 0x1b, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, + 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x18, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, + 0x6b, 0x2f, 0x72, 0x75, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x74, 0x61, 0x73, 0x6b, + 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x27, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x72, 0x75, 0x6e, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x81, 0x04, 0x0a, 0x10, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x38, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x75, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x48, 0x00, 0x52, 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x12, 0x44, 0x0a, 0x0a, 0x70, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, + 0x12, 0x39, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, + 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x48, 0x01, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x12, 0x37, 0x0a, 0x09, 0x74, + 0x61, 0x73, 0x6b, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, + 0x54, 0x61, 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x48, 0x01, 0x52, 0x08, 0x74, 0x61, 0x73, 0x6b, + 0x53, 0x70, 0x65, 0x63, 0x12, 0x42, 0x0a, 0x0c, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x5f, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x48, 0x01, 0x52, 0x0b, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x2e, 0x0a, 0x06, 0x69, 0x6e, 0x70, 0x75, + 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, + 0x52, 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x12, 0x32, 0x0a, 0x08, 0x72, 0x75, 0x6e, 0x5f, + 0x73, 0x70, 0x65, 0x63, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x52, 0x75, 0x6e, 0x53, + 0x70, 0x65, 0x63, 0x52, 0x07, 0x72, 0x75, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x12, 0x35, 0x0a, 0x06, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x06, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x42, 0x0b, 0x0a, 0x02, 0x69, 0x64, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, + 0x42, 0x0d, 0x0a, 0x04, 0x74, 0x61, 0x73, 0x6b, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, + 0x3e, 0x0a, 0x11, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x03, 0x72, 0x75, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x52, 0x03, 0x72, 0x75, 0x6e, 0x22, + 0x79, 0x0a, 0x0f, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x3e, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x75, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x05, 0x72, 0x75, 0x6e, + 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x48, 0x00, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x88, 0x01, 0x01, 0x42, + 0x09, 0x0a, 0x07, 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x22, 0x12, 0x0a, 0x10, 0x41, 0x62, + 0x6f, 0x72, 0x74, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x56, + 0x0a, 0x14, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3e, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x75, 0x6e, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, + 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x22, 0x51, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6e, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x38, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x58, 0x0a, 0x16, 0x57, 0x61, 0x74, + 0x63, 0x68, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x3e, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x75, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x05, 0x72, 0x75, + 0x6e, 0x49, 0x64, 0x22, 0x53, 0x0a, 0x17, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x75, 0x6e, 0x44, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x38, + 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, + 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x62, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x41, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, + 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x57, 0x0a, 0x18, + 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x07, 0x64, 0x65, + 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x64, 0x0a, 0x19, 0x57, 0x61, 0x74, 0x63, 0x68, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, + 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x59, 0x0a, 0x1a, 0x57, + 0x61, 0x74, 0x63, 0x68, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x07, 0x64, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, + 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x07, 0x64, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x5f, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x47, + 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x7a, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x2e, 0x0a, 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x16, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, + 0x6b, 0x2e, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x52, 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, + 0x12, 0x31, 0x0a, 0x07, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x17, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, + 0x73, 0x6b, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x52, 0x07, 0x6f, 0x75, 0x74, 0x70, + 0x75, 0x74, 0x73, 0x22, 0x84, 0x03, 0x0a, 0x0f, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6e, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x37, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4c, 0x69, 0x73, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x1b, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, + 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, 0x03, 0x6f, 0x72, 0x67, 0x12, 0x44, 0x0a, + 0x0a, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x49, 0x64, 0x12, 0x42, 0x0a, 0x0c, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x5f, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x54, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x09, 0x74, 0x61, 0x73, 0x6b, 0x5f, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, + 0x4e, 0x61, 0x6d, 0x65, 0x48, 0x00, 0x52, 0x08, 0x74, 0x61, 0x73, 0x6b, 0x4e, 0x61, 0x6d, 0x65, + 0x12, 0x39, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, + 0x73, 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x48, 0x00, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x42, 0x11, 0x0a, 0x08, 0x73, + 0x63, 0x6f, 0x70, 0x65, 0x5f, 0x62, 0x79, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x4a, 0x04, + 0x08, 0x03, 0x10, 0x04, 0x4a, 0x04, 0x08, 0x05, 0x10, 0x06, 0x22, 0x55, 0x0a, 0x10, 0x4c, 0x69, + 0x73, 0x74, 0x52, 0x75, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, + 0x0a, 0x04, 0x72, 0x75, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x52, 0x04, 0x72, 0x75, 0x6e, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, + 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, + 0x6e, 0x22, 0x87, 0x02, 0x0a, 0x10, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x75, 0x6e, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x03, 0x6f, 0x72, 0x67, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, 0x03, + 0x6f, 0x72, 0x67, 0x12, 0x44, 0x0a, 0x0a, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x69, + 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x48, 0x00, 0x52, 0x09, + 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x12, 0x44, 0x0a, 0x0a, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x48, 0x00, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x12, + 0x39, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, + 0x6b, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x48, 0x00, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x42, 0x0f, 0x0a, 0x06, 0x74, 0x61, + 0x72, 0x67, 0x65, 0x74, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, 0x40, 0x0a, 0x11, 0x57, + 0x61, 0x74, 0x63, 0x68, 0x52, 0x75, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x2b, 0x0a, 0x04, 0x72, 0x75, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2e, 0x52, 0x75, 0x6e, 0x52, 0x04, 0x72, 0x75, 0x6e, 0x73, 0x22, 0x8d, 0x01, + 0x0a, 0x12, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x37, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3e, 0x0a, + 0x06, 0x72, 0x75, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x52, 0x75, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, + 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x22, 0x61, 0x0a, + 0x13, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x07, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x07, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, + 0x22, 0x87, 0x01, 0x0a, 0x13, 0x57, 0x61, 0x74, 0x63, 0x68, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3e, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x5f, + 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x52, 0x75, 0x6e, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, + 0x01, 0x52, 0x05, 0x72, 0x75, 0x6e, 0x49, 0x64, 0x12, 0x30, 0x0a, 0x06, 0x66, 0x69, 0x6c, 0x74, + 0x65, 0x72, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x46, 0x69, 0x6c, 0x74, + 0x65, 0x72, 0x52, 0x06, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x65, 0x0a, 0x14, 0x57, 0x61, + 0x74, 0x63, 0x68, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x4d, 0x0a, 0x10, 0x65, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x5f, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x2e, 0x45, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x0f, 0x65, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x22, 0x7a, 0x0a, 0x19, 0x57, 0x61, 0x74, 0x63, 0x68, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3a, + 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, + 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x02, 0x69, 0x64, 0x12, 0x21, 0x0a, 0x07, 0x61, 0x74, + 0x74, 0x65, 0x6d, 0x70, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x07, 0xba, 0x48, 0x04, + 0x2a, 0x02, 0x20, 0x00, 0x52, 0x07, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x22, 0x65, 0x0a, + 0x1a, 0x57, 0x61, 0x74, 0x63, 0x68, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, 0x76, 0x65, + 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x0e, 0x63, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x0d, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, 0x76, + 0x65, 0x6e, 0x74, 0x73, 0x22, 0x75, 0x0a, 0x12, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x22, 0x15, 0x0a, 0x13, 0x41, + 0x62, 0x6f, 0x72, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0xe3, 0x03, 0x0a, 0x12, 0x57, 0x61, 0x74, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x44, 0x0a, 0x0a, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x48, 0x00, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x12, + 0x41, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, + 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x44, 0x61, + 0x74, 0x65, 0x12, 0x35, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x52, 0x07, 0x65, 0x6e, 0x64, 0x44, 0x61, 0x74, 0x65, 0x12, 0x37, 0x0a, 0x07, 0x72, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4c, 0x69, + 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x61, 0x0a, 0x11, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x5f, 0x73, 0x6f, 0x72, 0x74, + 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x53, 0x6f, 0x72, 0x74, 0x46, + 0x69, 0x65, 0x6c, 0x64, 0x52, 0x0f, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x53, 0x6f, 0x72, 0x74, 0x46, + 0x69, 0x65, 0x6c, 0x64, 0x73, 0x1a, 0x5e, 0x0a, 0x0e, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x53, 0x6f, + 0x72, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x41, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, + 0x6f, 0x72, 0x74, 0x2e, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, + 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x42, 0x09, 0x0a, 0x07, 0x73, 0x6f, + 0x72, 0x74, 0x5f, 0x62, 0x79, 0x42, 0x11, 0x0a, 0x08, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x5f, 0x62, + 0x79, 0x12, 0x05, 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, 0x71, 0x0a, 0x13, 0x57, 0x61, 0x74, 0x63, + 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x3e, 0x0a, 0x0b, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x52, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x12, + 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x08, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x32, 0xb9, 0x0b, 0x0a, 0x0a, + 0x52, 0x75, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x5a, 0x0a, 0x09, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6e, 0x12, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x08, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x52, + 0x75, 0x6e, 0x12, 0x23, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x52, 0x75, 0x6e, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x62, 0x6f, + 0x72, 0x74, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, + 0x69, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x12, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, + 0x47, 0x65, 0x74, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x6e, 0x0a, 0x0f, 0x57, 0x61, + 0x74, 0x63, 0x68, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x2a, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x57, + 0x61, 0x74, 0x63, 0x68, 0x52, 0x75, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x72, 0x0a, 0x10, 0x47, 0x65, + 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x2b, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x2e, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x77, + 0x0a, 0x12, 0x57, 0x61, 0x74, 0x63, 0x68, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x12, 0x2d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x41, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x69, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x12, 0x28, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x47, 0x65, + 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, + 0x02, 0x01, 0x12, 0x5a, 0x0a, 0x08, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6e, 0x73, 0x12, 0x23, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6e, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x5c, + 0x0a, 0x09, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x75, 0x6e, 0x73, 0x12, 0x24, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x75, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x25, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x75, 0x6e, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x63, 0x0a, 0x0b, + 0x4c, 0x69, 0x73, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x26, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, + 0x01, 0x12, 0x65, 0x0a, 0x0c, 0x57, 0x61, 0x74, 0x63, 0x68, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x12, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x41, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, + 0x57, 0x61, 0x74, 0x63, 0x68, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x77, 0x0a, 0x12, 0x57, 0x61, 0x74, 0x63, + 0x68, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x2d, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x45, + 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, + 0x01, 0x12, 0x60, 0x0a, 0x0b, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x62, + 0x6f, 0x72, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x00, 0x12, 0x62, 0x0a, 0x0b, 0x57, 0x61, 0x74, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x73, 0x12, 0x26, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, + 0x57, 0x61, 0x74, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x42, 0xca, 0x01, 0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x42, 0x0f, 0x52, 0x75, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x36, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, + 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xa2, 0x02, 0x03, + 0x46, 0x57, 0x58, 0xaa, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xca, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xe2, 0x02, 0x1e, + 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, + 0x13, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x57, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x4a, 0x9e, 0x56, 0x0a, 0x07, 0x12, 0x05, 0x00, 0x00, 0xd6, 0x02, 0x01, + 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, + 0x03, 0x02, 0x00, 0x1b, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x25, 0x0a, + 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x2b, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, + 0x12, 0x03, 0x06, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x03, 0x12, 0x03, 0x07, 0x00, 0x25, + 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x04, 0x12, 0x03, 0x08, 0x00, 0x22, 0x0a, 0x09, 0x0a, 0x02, 0x03, + 0x05, 0x12, 0x03, 0x09, 0x00, 0x2e, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x06, 0x12, 0x03, 0x0a, 0x00, + 0x31, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x07, 0x12, 0x03, 0x0b, 0x00, 0x29, 0x0a, 0x08, 0x0a, 0x01, + 0x08, 0x12, 0x03, 0x0d, 0x00, 0x4d, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x0d, 0x00, + 0x4d, 0x0a, 0x41, 0x0a, 0x02, 0x06, 0x00, 0x12, 0x04, 0x10, 0x00, 0x46, 0x01, 0x1a, 0x35, 0x20, + 0x52, 0x75, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x75, + 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x06, 0x00, 0x01, 0x12, 0x03, 0x10, 0x08, 0x12, + 0x0a, 0x32, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x00, 0x12, 0x03, 0x12, 0x02, 0x40, 0x1a, 0x25, 0x20, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x72, 0x75, 0x6e, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x74, 0x61, + 0x73, 0x6b, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x12, + 0x06, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x12, 0x10, 0x20, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x12, 0x2b, 0x3c, 0x0a, 0x1b, + 0x0a, 0x04, 0x06, 0x00, 0x02, 0x01, 0x12, 0x03, 0x15, 0x02, 0x3d, 0x1a, 0x0e, 0x20, 0x41, 0x62, + 0x6f, 0x72, 0x74, 0x20, 0x61, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, + 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x15, 0x06, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, + 0x01, 0x02, 0x12, 0x03, 0x15, 0x0f, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x15, 0x29, 0x39, 0x0a, 0x35, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x02, 0x12, 0x04, 0x18, + 0x02, 0x1a, 0x03, 0x1a, 0x27, 0x20, 0x47, 0x65, 0x74, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x65, 0x64, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, + 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x18, 0x06, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x02, 0x02, 0x12, 0x03, 0x18, 0x14, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, + 0x03, 0x12, 0x03, 0x18, 0x33, 0x48, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x04, 0x12, + 0x03, 0x19, 0x04, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, 0x06, 0x00, 0x02, 0x02, 0x04, 0x22, 0x12, 0x03, + 0x19, 0x04, 0x2f, 0x0a, 0x7e, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x03, 0x12, 0x03, 0x1d, 0x02, 0x59, + 0x1a, 0x71, 0x20, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x65, 0x64, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x75, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x20, 0x72, + 0x75, 0x6e, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x77, 0x69, 0x6c, + 0x6c, 0x20, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x20, 0x77, 0x68, 0x65, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x72, 0x65, 0x61, 0x63, 0x68, 0x65, 0x73, + 0x20, 0x61, 0x20, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x70, 0x68, 0x61, 0x73, + 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x1d, 0x06, + 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x1d, 0x16, 0x2c, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x06, 0x12, 0x03, 0x1d, 0x37, 0x3d, 0x0a, 0x0c, 0x0a, + 0x05, 0x06, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x1d, 0x3e, 0x55, 0x0a, 0x39, 0x0a, 0x04, 0x06, + 0x00, 0x02, 0x04, 0x12, 0x04, 0x20, 0x02, 0x22, 0x03, 0x1a, 0x2b, 0x20, 0x47, 0x65, 0x74, 0x20, + 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x04, 0x01, 0x12, + 0x03, 0x20, 0x06, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, 0x20, + 0x17, 0x2e, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, 0x20, 0x39, 0x51, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x04, 0x04, 0x12, 0x03, 0x21, 0x04, 0x2f, 0x0a, 0x0d, + 0x0a, 0x06, 0x06, 0x00, 0x02, 0x04, 0x04, 0x22, 0x12, 0x03, 0x21, 0x04, 0x2f, 0x0a, 0x85, 0x01, + 0x0a, 0x04, 0x06, 0x00, 0x02, 0x05, 0x12, 0x03, 0x25, 0x02, 0x62, 0x1a, 0x78, 0x20, 0x53, 0x74, + 0x72, 0x65, 0x61, 0x6d, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, + 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x73, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x77, 0x69, 0x6c, 0x6c, + 0x20, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x61, 0x63, 0x68, + 0x65, 0x73, 0x20, 0x61, 0x20, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x70, 0x68, + 0x61, 0x73, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, + 0x25, 0x06, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x05, 0x02, 0x12, 0x03, 0x25, 0x19, + 0x32, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x05, 0x06, 0x12, 0x03, 0x25, 0x3d, 0x43, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x05, 0x03, 0x12, 0x03, 0x25, 0x44, 0x5e, 0x0a, 0x33, 0x0a, + 0x04, 0x06, 0x00, 0x02, 0x06, 0x12, 0x04, 0x28, 0x02, 0x2a, 0x03, 0x1a, 0x25, 0x20, 0x47, 0x65, + 0x74, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x70, + 0x75, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x28, 0x06, 0x13, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x06, 0x02, 0x12, 0x03, 0x28, 0x14, 0x28, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x06, 0x03, 0x12, 0x03, 0x28, 0x33, 0x48, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x06, 0x04, 0x12, 0x03, 0x29, 0x04, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, 0x06, 0x00, + 0x02, 0x06, 0x04, 0x22, 0x12, 0x03, 0x29, 0x04, 0x2f, 0x0a, 0x40, 0x0a, 0x04, 0x06, 0x00, 0x02, + 0x07, 0x12, 0x04, 0x2d, 0x02, 0x2f, 0x03, 0x1a, 0x32, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x72, + 0x75, 0x6e, 0x73, 0x20, 0x62, 0x61, 0x73, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, + 0x20, 0x63, 0x72, 0x69, 0x74, 0x65, 0x72, 0x69, 0x61, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, + 0x00, 0x02, 0x07, 0x01, 0x12, 0x03, 0x2d, 0x06, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, + 0x07, 0x02, 0x12, 0x03, 0x2d, 0x0f, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x07, 0x03, + 0x12, 0x03, 0x2d, 0x29, 0x39, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x07, 0x04, 0x12, 0x03, + 0x2e, 0x04, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, 0x06, 0x00, 0x02, 0x07, 0x04, 0x22, 0x12, 0x03, 0x2e, + 0x04, 0x2f, 0x0a, 0xb5, 0x01, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x08, 0x12, 0x03, 0x33, 0x02, 0x47, + 0x1a, 0xa7, 0x01, 0x20, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x20, 0x62, 0x61, 0x73, 0x65, + 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x64, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x63, 0x72, 0x69, 0x74, 0x65, 0x72, 0x69, + 0x61, 0x2e, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x20, 0x6d, 0x61, 0x79, + 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x6e, 0x65, 0x77, 0x6c, 0x79, 0x20, 0x64, + 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x65, 0x64, 0x0a, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x20, + 0x6f, 0x72, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x78, + 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x6e, 0x65, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x6e, + 0x76, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x08, 0x01, 0x12, 0x03, 0x33, 0x06, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x08, + 0x02, 0x12, 0x03, 0x33, 0x10, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x08, 0x06, 0x12, + 0x03, 0x33, 0x2b, 0x31, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x08, 0x03, 0x12, 0x03, 0x33, + 0x32, 0x43, 0x0a, 0x31, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x09, 0x12, 0x04, 0x36, 0x02, 0x38, 0x03, + 0x1a, 0x23, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x61, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, + 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x09, 0x01, 0x12, 0x03, + 0x36, 0x06, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x09, 0x02, 0x12, 0x03, 0x36, 0x12, + 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x09, 0x03, 0x12, 0x03, 0x36, 0x2f, 0x42, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x09, 0x04, 0x12, 0x03, 0x37, 0x04, 0x2f, 0x0a, 0x0d, 0x0a, + 0x06, 0x06, 0x00, 0x02, 0x09, 0x04, 0x22, 0x12, 0x03, 0x37, 0x04, 0x2f, 0x0a, 0xa6, 0x01, 0x0a, + 0x04, 0x06, 0x00, 0x02, 0x0a, 0x12, 0x03, 0x3c, 0x02, 0x50, 0x1a, 0x98, 0x01, 0x20, 0x53, 0x74, + 0x72, 0x65, 0x61, 0x6d, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x61, + 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x20, + 0x6d, 0x61, 0x79, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x6e, 0x65, 0x77, 0x6c, + 0x79, 0x20, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x65, 0x64, 0x20, 0x6e, 0x65, 0x73, + 0x74, 0x65, 0x64, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x20, 0x6f, 0x72, 0x20, 0x75, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x73, 0x0a, 0x20, 0x74, 0x6f, 0x20, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, + 0x67, 0x20, 0x6f, 0x6e, 0x65, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x6e, 0x76, 0x6f, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x0a, 0x01, 0x12, 0x03, + 0x3c, 0x06, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x0a, 0x02, 0x12, 0x03, 0x3c, 0x13, + 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x0a, 0x06, 0x12, 0x03, 0x3c, 0x31, 0x37, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x0a, 0x03, 0x12, 0x03, 0x3c, 0x38, 0x4c, 0x0a, 0x42, 0x0a, + 0x04, 0x06, 0x00, 0x02, 0x0b, 0x12, 0x03, 0x3f, 0x02, 0x62, 0x1a, 0x35, 0x20, 0x53, 0x74, 0x72, + 0x65, 0x61, 0x6d, 0x20, 0x6f, 0x66, 0x20, 0x6b, 0x38, 0x73, 0x20, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x68, 0x75, 0x6d, + 0x61, 0x6e, 0x20, 0x72, 0x65, 0x61, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6d, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x0b, 0x01, 0x12, 0x03, 0x3f, 0x06, 0x18, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x0b, 0x02, 0x12, 0x03, 0x3f, 0x19, 0x32, 0x0a, 0x0c, 0x0a, + 0x05, 0x06, 0x00, 0x02, 0x0b, 0x06, 0x12, 0x03, 0x3f, 0x3d, 0x43, 0x0a, 0x0c, 0x0a, 0x05, 0x06, + 0x00, 0x02, 0x0b, 0x03, 0x12, 0x03, 0x3f, 0x44, 0x5e, 0x0a, 0x7a, 0x0a, 0x04, 0x06, 0x00, 0x02, + 0x0c, 0x12, 0x03, 0x42, 0x02, 0x46, 0x1a, 0x6d, 0x20, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x73, 0x20, 0x61, 0x20, 0x73, 0x69, + 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x77, 0x61, 0x73, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x20, + 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x72, 0x20, 0x69, 0x73, 0x20, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x20, 0x62, 0x65, 0x69, 0x6e, 0x67, 0x20, 0x70, 0x72, + 0x6f, 0x63, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x20, 0x77, 0x6f, 0x72, + 0x6b, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x0c, 0x01, 0x12, 0x03, + 0x42, 0x06, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x0c, 0x02, 0x12, 0x03, 0x42, 0x12, + 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x0c, 0x03, 0x12, 0x03, 0x42, 0x2f, 0x42, 0x0a, + 0x54, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x0d, 0x12, 0x03, 0x45, 0x02, 0x4d, 0x1a, 0x47, 0x20, 0x53, + 0x74, 0x72, 0x65, 0x61, 0x6d, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x20, 0x62, 0x61, + 0x73, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x64, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x63, 0x72, 0x69, 0x74, 0x65, + 0x72, 0x69, 0x61, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x0d, 0x01, 0x12, 0x03, + 0x45, 0x06, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x0d, 0x02, 0x12, 0x03, 0x45, 0x12, + 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x0d, 0x06, 0x12, 0x03, 0x45, 0x2f, 0x35, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x0d, 0x03, 0x12, 0x03, 0x45, 0x36, 0x49, 0x0a, 0x31, 0x0a, + 0x02, 0x04, 0x00, 0x12, 0x04, 0x49, 0x00, 0x6a, 0x01, 0x1a, 0x25, 0x20, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x49, 0x08, 0x18, 0x0a, 0x0c, 0x0a, 0x04, + 0x04, 0x00, 0x08, 0x00, 0x12, 0x04, 0x4a, 0x02, 0x52, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x08, 0x00, 0x01, 0x12, 0x03, 0x4a, 0x08, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x08, 0x00, + 0x02, 0x12, 0x03, 0x4b, 0x04, 0x30, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x00, 0x08, 0x00, 0x02, 0x87, + 0x09, 0x01, 0x12, 0x03, 0x4b, 0x04, 0x30, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, + 0x03, 0x4e, 0x04, 0x24, 0x1a, 0x1b, 0x20, 0x54, 0x68, 0x65, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, + 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x69, 0x64, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x4e, 0x04, 0x18, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x4e, 0x19, 0x1f, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x4e, 0x22, 0x23, 0x0a, 0x47, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x01, 0x12, 0x03, 0x51, 0x04, 0x2c, 0x1a, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x70, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x69, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x20, 0x52, 0x75, 0x6e, 0x20, 0x6e, 0x61, 0x6d, 0x65, + 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, + 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x51, + 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x51, 0x1d, 0x27, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x51, 0x2a, 0x2b, 0x0a, 0x20, + 0x0a, 0x04, 0x04, 0x00, 0x08, 0x01, 0x12, 0x04, 0x55, 0x02, 0x60, 0x03, 0x1a, 0x12, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x08, 0x01, 0x01, 0x12, 0x03, 0x55, 0x08, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x08, 0x01, 0x02, 0x12, 0x03, 0x56, 0x04, 0x30, 0x0a, 0x0f, 0x0a, 0x08, + 0x04, 0x00, 0x08, 0x01, 0x02, 0x87, 0x09, 0x01, 0x12, 0x03, 0x56, 0x04, 0x30, 0x0a, 0x22, 0x0a, + 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x59, 0x04, 0x24, 0x1a, 0x15, 0x20, 0x54, 0x68, 0x65, + 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x69, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x59, 0x04, 0x17, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x59, 0x18, 0x1f, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x59, 0x22, 0x23, 0x0a, 0x24, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x03, 0x12, 0x03, 0x5c, 0x04, 0x20, 0x1a, 0x17, 0x20, 0x54, 0x68, 0x65, 0x20, 0x74, + 0x61, 0x73, 0x6b, 0x20, 0x73, 0x70, 0x65, 0x63, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x06, 0x12, 0x03, 0x5c, 0x04, 0x11, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x5c, 0x12, 0x1b, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x5c, 0x1e, 0x1f, 0x0a, 0x27, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x04, 0x12, 0x03, 0x5f, 0x04, 0x28, 0x1a, 0x1a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x75, + 0x73, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x06, 0x12, 0x03, 0x5f, + 0x04, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x5f, 0x17, 0x23, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, 0x5f, 0x26, 0x27, 0x0a, 0x1d, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x63, 0x02, 0x19, 0x1a, 0x10, 0x20, 0x49, 0x6e, + 0x70, 0x75, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x05, 0x06, 0x12, 0x03, 0x63, 0x02, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x63, 0x0e, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x05, 0x03, 0x12, 0x03, 0x63, 0x17, 0x18, 0x0a, 0x23, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x06, 0x12, + 0x03, 0x66, 0x02, 0x1c, 0x1a, 0x16, 0x20, 0x54, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x06, 0x06, 0x12, 0x03, 0x66, 0x02, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x06, 0x01, 0x12, 0x03, 0x66, 0x0f, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, + 0x03, 0x12, 0x03, 0x66, 0x1a, 0x1b, 0x0a, 0x36, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x07, 0x12, 0x03, + 0x69, 0x02, 0x17, 0x1a, 0x29, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x64, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x07, 0x06, 0x12, 0x03, 0x69, 0x02, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x07, 0x01, 0x12, 0x03, 0x69, 0x0c, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x07, 0x03, 0x12, 0x03, 0x69, 0x15, 0x16, 0x0a, 0x32, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, + 0x6d, 0x00, 0x6f, 0x01, 0x1a, 0x26, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x63, 0x72, 0x65, 0x61, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x01, 0x01, 0x12, 0x03, 0x6d, 0x08, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, + 0x12, 0x03, 0x6e, 0x02, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, + 0x6e, 0x02, 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x6e, 0x06, + 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x6e, 0x0c, 0x0d, 0x0a, + 0x31, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x72, 0x00, 0x78, 0x01, 0x1a, 0x25, 0x20, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x72, 0x75, 0x6e, + 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x72, 0x08, 0x17, 0x0a, 0x1c, + 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x74, 0x02, 0x49, 0x1a, 0x0f, 0x20, 0x52, 0x75, + 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, 0x03, 0x74, 0x02, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x74, 0x17, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x74, 0x20, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x08, 0x12, + 0x03, 0x74, 0x22, 0x48, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x02, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, + 0x12, 0x03, 0x74, 0x23, 0x47, 0x0a, 0x3a, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x77, + 0x02, 0x1d, 0x1a, 0x2d, 0x20, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x61, 0x62, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, + 0x2e, 0x20, 0x69, 0x66, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x2e, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x04, 0x12, 0x03, 0x77, 0x02, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x05, 0x12, 0x03, 0x77, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x77, 0x12, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x77, 0x1b, 0x1c, 0x0a, 0x31, 0x0a, 0x02, 0x04, 0x03, 0x12, + 0x03, 0x7b, 0x00, 0x1b, 0x1a, 0x26, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x62, 0x6f, 0x72, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x03, 0x01, 0x12, 0x03, 0x7b, 0x08, 0x18, 0x0a, 0x4c, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x05, + 0x7e, 0x00, 0x81, 0x01, 0x01, 0x1a, 0x3f, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x67, 0x65, 0x74, 0x74, + 0x69, 0x6e, 0x67, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x66, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, + 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x7e, + 0x08, 0x1c, 0x0a, 0x1d, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x04, 0x80, 0x01, 0x02, 0x49, + 0x1a, 0x0f, 0x20, 0x52, 0x75, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x06, 0x12, 0x04, 0x80, 0x01, 0x02, 0x16, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x04, 0x80, 0x01, 0x17, 0x1d, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x04, 0x80, 0x01, 0x20, 0x21, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x08, 0x12, 0x04, 0x80, 0x01, 0x22, 0x48, 0x0a, 0x10, 0x0a, + 0x08, 0x04, 0x04, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x04, 0x80, 0x01, 0x23, 0x47, 0x0a, + 0x4e, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x06, 0x84, 0x01, 0x00, 0x87, 0x01, 0x01, 0x1a, 0x40, 0x20, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x67, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, + 0x0b, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x04, 0x84, 0x01, 0x08, 0x1d, 0x0a, 0x33, 0x0a, 0x04, + 0x04, 0x05, 0x02, 0x00, 0x12, 0x04, 0x86, 0x01, 0x02, 0x19, 0x1a, 0x25, 0x20, 0x44, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x06, 0x12, 0x04, 0x86, 0x01, 0x02, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x04, 0x86, 0x01, 0x0d, 0x14, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x04, 0x86, 0x01, 0x17, 0x18, 0x0a, 0x4e, + 0x0a, 0x02, 0x04, 0x06, 0x12, 0x06, 0x8a, 0x01, 0x00, 0x8d, 0x01, 0x01, 0x1a, 0x40, 0x20, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x77, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0b, + 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x04, 0x8a, 0x01, 0x08, 0x1e, 0x0a, 0x1d, 0x0a, 0x04, 0x04, + 0x06, 0x02, 0x00, 0x12, 0x04, 0x8c, 0x01, 0x02, 0x49, 0x1a, 0x0f, 0x20, 0x52, 0x75, 0x6e, 0x20, + 0x74, 0x6f, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x00, 0x06, 0x12, 0x04, 0x8c, 0x01, 0x02, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x00, 0x01, 0x12, 0x04, 0x8c, 0x01, 0x17, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, + 0x03, 0x12, 0x04, 0x8c, 0x01, 0x20, 0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x08, + 0x12, 0x04, 0x8c, 0x01, 0x22, 0x48, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x06, 0x02, 0x00, 0x08, 0x87, + 0x09, 0x19, 0x12, 0x04, 0x8c, 0x01, 0x23, 0x47, 0x0a, 0x4f, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x06, + 0x90, 0x01, 0x00, 0x93, 0x01, 0x01, 0x1a, 0x41, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x77, 0x61, + 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, + 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, + 0x74, 0x20, 0x61, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x07, 0x01, + 0x12, 0x04, 0x90, 0x01, 0x08, 0x1f, 0x0a, 0x33, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x04, + 0x92, 0x01, 0x02, 0x19, 0x1a, 0x25, 0x20, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, + 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x00, 0x06, 0x12, 0x04, 0x92, 0x01, 0x02, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x00, 0x01, 0x12, 0x04, 0x92, 0x01, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x00, 0x03, 0x12, 0x04, 0x92, 0x01, 0x17, 0x18, 0x0a, 0x51, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x06, + 0x96, 0x01, 0x00, 0x99, 0x01, 0x01, 0x1a, 0x43, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x67, 0x65, 0x74, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, + 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, + 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, + 0x08, 0x01, 0x12, 0x04, 0x96, 0x01, 0x08, 0x1f, 0x0a, 0x20, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x00, + 0x12, 0x04, 0x98, 0x01, 0x02, 0x4f, 0x1a, 0x12, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x74, 0x6f, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x00, 0x06, 0x12, 0x04, 0x98, 0x01, 0x02, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x00, 0x01, 0x12, 0x04, 0x98, 0x01, 0x1a, 0x23, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, + 0x03, 0x12, 0x04, 0x98, 0x01, 0x26, 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x08, + 0x12, 0x04, 0x98, 0x01, 0x28, 0x4e, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x08, 0x02, 0x00, 0x08, 0x87, + 0x09, 0x19, 0x12, 0x04, 0x98, 0x01, 0x29, 0x4d, 0x0a, 0x52, 0x0a, 0x02, 0x04, 0x09, 0x12, 0x06, + 0x9c, 0x01, 0x00, 0x9f, 0x01, 0x01, 0x1a, 0x44, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x67, 0x65, + 0x74, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x69, + 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, + 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, + 0x04, 0x09, 0x01, 0x12, 0x04, 0x9c, 0x01, 0x08, 0x20, 0x0a, 0x36, 0x0a, 0x04, 0x04, 0x09, 0x02, + 0x00, 0x12, 0x04, 0x9e, 0x01, 0x02, 0x1c, 0x1a, 0x28, 0x20, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x65, 0x64, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, + 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x06, 0x12, 0x04, 0x9e, 0x01, 0x02, 0x0f, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x04, 0x9e, 0x01, 0x10, 0x17, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, 0x04, 0x9e, 0x01, 0x1a, 0x1b, 0x0a, 0x52, + 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x06, 0xa2, 0x01, 0x00, 0xa5, 0x01, 0x01, 0x1a, 0x44, 0x20, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x77, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0a, 0x01, 0x12, 0x04, 0xa2, 0x01, 0x08, 0x21, 0x0a, + 0x20, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x00, 0x12, 0x04, 0xa4, 0x01, 0x02, 0x4f, 0x1a, 0x12, 0x20, + 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x06, 0x12, 0x04, 0xa4, 0x01, 0x02, 0x19, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x04, 0xa4, 0x01, 0x1a, 0x23, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, 0x04, 0xa4, 0x01, 0x26, 0x27, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x08, 0x12, 0x04, 0xa4, 0x01, 0x28, 0x4e, 0x0a, 0x10, 0x0a, + 0x08, 0x04, 0x0a, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x04, 0xa4, 0x01, 0x29, 0x4d, 0x0a, + 0x53, 0x0a, 0x02, 0x04, 0x0b, 0x12, 0x06, 0xa8, 0x01, 0x00, 0xab, 0x01, 0x01, 0x1a, 0x45, 0x20, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x77, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x65, + 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0b, 0x01, 0x12, 0x04, 0xa8, 0x01, 0x08, + 0x22, 0x0a, 0x36, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x00, 0x12, 0x04, 0xaa, 0x01, 0x02, 0x1c, 0x1a, + 0x28, 0x20, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, + 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, + 0x00, 0x06, 0x12, 0x04, 0xaa, 0x01, 0x02, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, + 0x01, 0x12, 0x04, 0xaa, 0x01, 0x10, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x03, + 0x12, 0x04, 0xaa, 0x01, 0x1a, 0x1b, 0x0a, 0x39, 0x0a, 0x02, 0x04, 0x0c, 0x12, 0x06, 0xae, 0x01, + 0x00, 0xb1, 0x01, 0x01, 0x1a, 0x2b, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, + 0x69, 0x6e, 0x67, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0c, 0x01, 0x12, 0x04, 0xae, 0x01, 0x08, 0x1c, 0x0a, 0x20, + 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x00, 0x12, 0x04, 0xb0, 0x01, 0x02, 0x4f, 0x1a, 0x12, 0x20, 0x41, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x06, 0x12, 0x04, 0xb0, 0x01, 0x02, 0x19, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x01, 0x12, 0x04, 0xb0, 0x01, 0x1a, 0x23, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x03, 0x12, 0x04, 0xb0, 0x01, 0x26, 0x27, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0c, 0x02, 0x00, 0x08, 0x12, 0x04, 0xb0, 0x01, 0x28, 0x4e, 0x0a, 0x10, 0x0a, 0x08, + 0x04, 0x0c, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x04, 0xb0, 0x01, 0x29, 0x4d, 0x0a, 0x3a, + 0x0a, 0x02, 0x04, 0x0d, 0x12, 0x06, 0xb4, 0x01, 0x00, 0xba, 0x01, 0x01, 0x1a, 0x2c, 0x20, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0d, + 0x01, 0x12, 0x04, 0xb4, 0x01, 0x08, 0x1d, 0x0a, 0x26, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x00, 0x12, + 0x04, 0xb6, 0x01, 0x02, 0x19, 0x1a, 0x18, 0x20, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x06, 0x12, 0x04, 0xb6, 0x01, 0x02, 0x0d, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x01, 0x12, 0x04, 0xb6, 0x01, 0x0e, 0x14, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0d, 0x02, 0x00, 0x03, 0x12, 0x04, 0xb6, 0x01, 0x17, 0x18, 0x0a, 0x27, 0x0a, 0x04, + 0x04, 0x0d, 0x02, 0x01, 0x12, 0x04, 0xb9, 0x01, 0x02, 0x1b, 0x1a, 0x19, 0x20, 0x4f, 0x75, 0x74, + 0x70, 0x75, 0x74, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x06, 0x12, 0x04, + 0xb9, 0x01, 0x02, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x01, 0x12, 0x04, 0xb9, + 0x01, 0x0f, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x01, 0x03, 0x12, 0x04, 0xb9, 0x01, + 0x19, 0x1a, 0x0a, 0x31, 0x0a, 0x02, 0x04, 0x0e, 0x12, 0x06, 0xbd, 0x01, 0x00, 0xd5, 0x01, 0x01, + 0x1a, 0x23, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x72, + 0x75, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0e, 0x01, 0x12, 0x04, 0xbd, 0x01, + 0x08, 0x17, 0x0a, 0x19, 0x0a, 0x03, 0x04, 0x0e, 0x09, 0x12, 0x04, 0xbe, 0x01, 0x02, 0x10, 0x22, + 0x0c, 0x20, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x0a, 0x0a, 0x0c, 0x0a, + 0x04, 0x04, 0x0e, 0x09, 0x00, 0x12, 0x04, 0xbe, 0x01, 0x0b, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x09, 0x00, 0x01, 0x12, 0x04, 0xbe, 0x01, 0x0b, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x09, 0x00, 0x02, 0x12, 0x04, 0xbe, 0x01, 0x0b, 0x0c, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0e, 0x09, + 0x01, 0x12, 0x04, 0xbe, 0x01, 0x0e, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x09, 0x01, 0x01, + 0x12, 0x04, 0xbe, 0x01, 0x0e, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x09, 0x01, 0x02, 0x12, + 0x04, 0xbe, 0x01, 0x0e, 0x0f, 0x0a, 0x2f, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x00, 0x12, 0x04, 0xc1, + 0x01, 0x02, 0x21, 0x1a, 0x21, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x6c, 0x69, 0x73, + 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, + 0x74, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x06, 0x12, + 0x04, 0xc1, 0x01, 0x02, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x01, 0x12, 0x04, + 0xc1, 0x01, 0x15, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x03, 0x12, 0x04, 0xc1, + 0x01, 0x1f, 0x20, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x0e, 0x08, 0x00, 0x12, 0x06, 0xc3, 0x01, 0x02, + 0xd4, 0x01, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x08, 0x00, 0x01, 0x12, 0x04, 0xc3, 0x01, + 0x08, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x08, 0x00, 0x02, 0x12, 0x04, 0xc4, 0x01, 0x04, + 0x30, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x0e, 0x08, 0x00, 0x02, 0x87, 0x09, 0x01, 0x12, 0x04, 0xc4, + 0x01, 0x04, 0x30, 0x0a, 0x35, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x01, 0x12, 0x04, 0xc7, 0x01, 0x04, + 0x3d, 0x1a, 0x27, 0x20, 0x4f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, + 0x69, 0x6e, 0x67, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x01, 0x05, 0x12, 0x04, 0xc7, 0x01, 0x04, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x01, 0x01, 0x12, 0x04, 0xc7, 0x01, 0x0b, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, + 0x03, 0x12, 0x04, 0xc7, 0x01, 0x11, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x08, + 0x12, 0x04, 0xc7, 0x01, 0x13, 0x3c, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x0e, 0x02, 0x01, 0x08, 0x87, + 0x09, 0x0e, 0x02, 0x12, 0x04, 0xc7, 0x01, 0x14, 0x3b, 0x0a, 0x36, 0x0a, 0x04, 0x04, 0x0e, 0x02, + 0x02, 0x12, 0x04, 0xca, 0x01, 0x04, 0x2c, 0x1a, 0x28, 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x02, 0x06, 0x12, 0x04, 0xca, 0x01, 0x04, 0x1c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x02, 0x01, 0x12, 0x04, 0xca, 0x01, 0x1d, 0x27, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x02, 0x03, 0x12, 0x04, 0xca, 0x01, 0x2a, 0x2b, 0x0a, 0x31, + 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x03, 0x12, 0x04, 0xcd, 0x01, 0x04, 0x28, 0x1a, 0x23, 0x20, 0x4c, + 0x69, 0x73, 0x74, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x06, 0x12, 0x04, 0xcd, 0x01, 0x04, 0x16, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x01, 0x12, 0x04, 0xcd, 0x01, 0x17, 0x23, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x03, 0x12, 0x04, 0xcd, 0x01, 0x26, 0x27, 0x0a, 0x2c, + 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x04, 0x12, 0x04, 0xd0, 0x01, 0x04, 0x20, 0x1a, 0x1e, 0x20, 0x54, + 0x61, 0x73, 0x6b, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x69, 0x6c, + 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x04, 0x06, 0x12, 0x04, 0xd0, 0x01, 0x04, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x04, 0x01, 0x12, 0x04, 0xd0, 0x01, 0x12, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x04, 0x03, 0x12, 0x04, 0xd0, 0x01, 0x1e, 0x1f, 0x0a, 0x32, 0x0a, 0x04, 0x04, 0x0e, 0x02, + 0x05, 0x12, 0x04, 0xd3, 0x01, 0x04, 0x24, 0x1a, 0x24, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x20, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x69, + 0x6c, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x05, 0x06, 0x12, 0x04, 0xd3, 0x01, 0x04, 0x17, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x05, 0x01, 0x12, 0x04, 0xd3, 0x01, 0x18, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x05, 0x03, 0x12, 0x04, 0xd3, 0x01, 0x22, 0x23, 0x0a, 0x32, 0x0a, 0x02, 0x04, 0x0f, + 0x12, 0x06, 0xd8, 0x01, 0x00, 0xde, 0x01, 0x01, 0x1a, 0x24, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x6c, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0b, + 0x0a, 0x03, 0x04, 0x0f, 0x01, 0x12, 0x04, 0xd8, 0x01, 0x08, 0x18, 0x0a, 0x3a, 0x0a, 0x04, 0x04, + 0x0f, 0x02, 0x00, 0x12, 0x04, 0xda, 0x01, 0x02, 0x18, 0x1a, 0x2c, 0x20, 0x4c, 0x69, 0x73, 0x74, + 0x20, 0x6f, 0x66, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, + 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x63, 0x72, 0x69, + 0x74, 0x65, 0x72, 0x69, 0x61, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x04, + 0x12, 0x04, 0xda, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x06, 0x12, + 0x04, 0xda, 0x01, 0x0b, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x01, 0x12, 0x04, + 0xda, 0x01, 0x0f, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x03, 0x12, 0x04, 0xda, + 0x01, 0x16, 0x17, 0x0a, 0x44, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x01, 0x12, 0x04, 0xdd, 0x01, 0x02, + 0x13, 0x1a, 0x36, 0x20, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x65, + 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, + 0x70, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2c, + 0x20, 0x69, 0x66, 0x20, 0x61, 0x6e, 0x79, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, + 0x01, 0x05, 0x12, 0x04, 0xdd, 0x01, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, + 0x01, 0x12, 0x04, 0xdd, 0x01, 0x09, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x03, + 0x12, 0x04, 0xdd, 0x01, 0x11, 0x12, 0x0a, 0x32, 0x0a, 0x02, 0x04, 0x10, 0x12, 0x06, 0xe1, 0x01, + 0x00, 0xee, 0x01, 0x01, 0x1a, 0x24, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x77, 0x61, 0x74, 0x63, 0x68, + 0x69, 0x6e, 0x67, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x10, + 0x01, 0x12, 0x04, 0xe1, 0x01, 0x08, 0x18, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x10, 0x08, 0x00, 0x12, + 0x06, 0xe2, 0x01, 0x02, 0xed, 0x01, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x08, 0x00, 0x01, + 0x12, 0x04, 0xe2, 0x01, 0x08, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x08, 0x00, 0x02, 0x12, + 0x04, 0xe3, 0x01, 0x04, 0x30, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x10, 0x08, 0x00, 0x02, 0x87, 0x09, + 0x01, 0x12, 0x04, 0xe3, 0x01, 0x04, 0x30, 0x0a, 0x35, 0x0a, 0x04, 0x04, 0x10, 0x02, 0x00, 0x12, + 0x04, 0xe6, 0x01, 0x04, 0x3d, 0x1a, 0x27, 0x20, 0x4f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x69, + 0x6c, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, 0x05, 0x12, 0x04, 0xe6, 0x01, 0x04, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x10, 0x02, 0x00, 0x01, 0x12, 0x04, 0xe6, 0x01, 0x0b, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x10, 0x02, 0x00, 0x03, 0x12, 0x04, 0xe6, 0x01, 0x11, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x10, 0x02, 0x00, 0x08, 0x12, 0x04, 0xe6, 0x01, 0x13, 0x3c, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x10, + 0x02, 0x00, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x04, 0xe6, 0x01, 0x14, 0x3b, 0x0a, 0x36, 0x0a, + 0x04, 0x04, 0x10, 0x02, 0x01, 0x12, 0x04, 0xe8, 0x01, 0x04, 0x2c, 0x1a, 0x28, 0x20, 0x43, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x72, + 0x75, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x01, 0x06, 0x12, 0x04, + 0xe8, 0x01, 0x04, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x01, 0x01, 0x12, 0x04, 0xe8, + 0x01, 0x1d, 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x01, 0x03, 0x12, 0x04, 0xe8, 0x01, + 0x2a, 0x2b, 0x0a, 0x36, 0x0a, 0x04, 0x04, 0x10, 0x02, 0x02, 0x12, 0x04, 0xea, 0x01, 0x04, 0x2c, + 0x1a, 0x28, 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, + 0x69, 0x6e, 0x67, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, + 0x02, 0x02, 0x06, 0x12, 0x04, 0xea, 0x01, 0x04, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, + 0x02, 0x01, 0x12, 0x04, 0xea, 0x01, 0x1d, 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x02, + 0x03, 0x12, 0x04, 0xea, 0x01, 0x2a, 0x2b, 0x0a, 0x33, 0x0a, 0x04, 0x04, 0x10, 0x02, 0x03, 0x12, + 0x04, 0xec, 0x01, 0x04, 0x24, 0x1a, 0x25, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x20, 0x69, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x69, 0x6c, 0x74, + 0x65, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x10, 0x02, 0x03, 0x06, 0x12, 0x04, 0xec, 0x01, 0x04, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x10, 0x02, 0x03, 0x01, 0x12, 0x04, 0xec, 0x01, 0x18, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, + 0x02, 0x03, 0x03, 0x12, 0x04, 0xec, 0x01, 0x22, 0x23, 0x0a, 0x33, 0x0a, 0x02, 0x04, 0x11, 0x12, + 0x06, 0xf1, 0x01, 0x00, 0xf4, 0x01, 0x01, 0x1a, 0x25, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x77, + 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0b, + 0x0a, 0x03, 0x04, 0x11, 0x01, 0x12, 0x04, 0xf1, 0x01, 0x08, 0x19, 0x0a, 0x41, 0x0a, 0x04, 0x04, + 0x11, 0x02, 0x00, 0x12, 0x04, 0xf3, 0x01, 0x02, 0x18, 0x1a, 0x33, 0x20, 0x4e, 0x65, 0x77, 0x20, + 0x6f, 0x72, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x20, 0x72, 0x75, 0x6e, 0x73, 0x20, + 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6c, + 0x74, 0x65, 0x72, 0x20, 0x63, 0x72, 0x69, 0x74, 0x65, 0x72, 0x69, 0x61, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, 0x04, 0x12, 0x04, 0xf3, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x11, 0x02, 0x00, 0x06, 0x12, 0x04, 0xf3, 0x01, 0x0b, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x11, 0x02, 0x00, 0x01, 0x12, 0x04, 0xf3, 0x01, 0x0f, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x11, 0x02, 0x00, 0x03, 0x12, 0x04, 0xf3, 0x01, 0x16, 0x17, 0x0a, 0x34, 0x0a, 0x02, 0x04, 0x12, + 0x12, 0x06, 0xf7, 0x01, 0x00, 0xfd, 0x01, 0x01, 0x1a, 0x26, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6c, + 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, + 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x12, 0x01, 0x12, 0x04, 0xf7, 0x01, 0x08, 0x1a, 0x0a, 0x2f, 0x0a, + 0x04, 0x04, 0x12, 0x02, 0x00, 0x12, 0x04, 0xf9, 0x01, 0x02, 0x21, 0x1a, 0x21, 0x20, 0x43, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x12, 0x02, 0x00, 0x06, 0x12, 0x04, 0xf9, 0x01, 0x02, 0x14, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x12, 0x02, 0x00, 0x01, 0x12, 0x04, 0xf9, 0x01, 0x15, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x12, 0x02, 0x00, 0x03, 0x12, 0x04, 0xf9, 0x01, 0x1f, 0x20, 0x0a, 0x35, 0x0a, 0x04, 0x04, + 0x12, 0x02, 0x01, 0x12, 0x04, 0xfc, 0x01, 0x02, 0x49, 0x1a, 0x27, 0x20, 0x52, 0x75, 0x6e, 0x20, + 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, + 0x69, 0x6c, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x01, 0x06, 0x12, 0x04, 0xfc, 0x01, 0x02, + 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x01, 0x01, 0x12, 0x04, 0xfc, 0x01, 0x17, 0x1d, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x01, 0x03, 0x12, 0x04, 0xfc, 0x01, 0x20, 0x21, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x01, 0x08, 0x12, 0x04, 0xfc, 0x01, 0x22, 0x48, 0x0a, 0x10, + 0x0a, 0x08, 0x04, 0x12, 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x04, 0xfc, 0x01, 0x23, 0x47, + 0x0a, 0x35, 0x0a, 0x02, 0x04, 0x13, 0x12, 0x06, 0x80, 0x02, 0x00, 0x89, 0x02, 0x01, 0x1a, 0x27, + 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x13, 0x01, 0x12, 0x04, + 0x80, 0x02, 0x08, 0x1b, 0x0a, 0x3d, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x00, 0x12, 0x04, 0x82, 0x02, + 0x02, 0x1e, 0x1a, 0x2f, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x63, 0x72, 0x69, 0x74, 0x65, 0x72, 0x69, + 0x61, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x00, 0x04, 0x12, 0x04, 0x82, 0x02, + 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x00, 0x06, 0x12, 0x04, 0x82, 0x02, 0x0b, + 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x00, 0x01, 0x12, 0x04, 0x82, 0x02, 0x12, 0x19, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x00, 0x03, 0x12, 0x04, 0x82, 0x02, 0x1c, 0x1d, 0x0a, + 0x44, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x01, 0x12, 0x04, 0x85, 0x02, 0x02, 0x13, 0x1a, 0x36, 0x20, + 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x65, 0x74, 0x63, 0x68, 0x69, + 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x70, 0x61, 0x67, 0x65, + 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2c, 0x20, 0x69, 0x66, 0x20, + 0x61, 0x6e, 0x79, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x01, 0x05, 0x12, 0x04, + 0x85, 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x01, 0x01, 0x12, 0x04, 0x85, + 0x02, 0x09, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x01, 0x03, 0x12, 0x04, 0x85, 0x02, + 0x11, 0x12, 0x0a, 0x35, 0x0a, 0x02, 0x04, 0x14, 0x12, 0x06, 0x8c, 0x02, 0x00, 0x95, 0x02, 0x01, + 0x1a, 0x27, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x77, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x14, 0x01, + 0x12, 0x04, 0x8c, 0x02, 0x08, 0x1b, 0x0a, 0x35, 0x0a, 0x04, 0x04, 0x14, 0x02, 0x00, 0x12, 0x04, + 0x8e, 0x02, 0x02, 0x49, 0x1a, 0x27, 0x20, 0x52, 0x75, 0x6e, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, + 0x69, 0x6e, 0x67, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x14, 0x02, 0x00, 0x06, 0x12, 0x04, 0x8e, 0x02, 0x02, 0x16, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x14, 0x02, 0x00, 0x01, 0x12, 0x04, 0x8e, 0x02, 0x17, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x14, 0x02, 0x00, 0x03, 0x12, 0x04, 0x8e, 0x02, 0x20, 0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, + 0x02, 0x00, 0x08, 0x12, 0x04, 0x8e, 0x02, 0x22, 0x48, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x14, 0x02, + 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x04, 0x8e, 0x02, 0x23, 0x47, 0x0a, 0x83, 0x03, 0x0a, 0x04, + 0x04, 0x14, 0x02, 0x01, 0x12, 0x04, 0x94, 0x02, 0x02, 0x24, 0x1a, 0xf4, 0x02, 0x20, 0x4f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x28, 0x73, 0x29, + 0x20, 0x63, 0x72, 0x69, 0x74, 0x65, 0x72, 0x69, 0x61, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, 0x20, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x66, 0x69, + 0x6c, 0x74, 0x65, 0x72, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, 0x69, 0x6e, 0x63, 0x6c, + 0x75, 0x64, 0x65, 0x3a, 0x0a, 0x20, 0x2d, 0x20, 0x4e, 0x41, 0x4d, 0x45, 0x20, 0x28, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x75, 0x73, 0x65, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x43, 0x4f, 0x4e, 0x54, 0x41, 0x49, 0x4e, 0x53, 0x5f, 0x43, 0x41, 0x53, 0x45, 0x5f, 0x49, 0x4e, + 0x53, 0x45, 0x4e, 0x53, 0x49, 0x54, 0x49, 0x56, 0x45, 0x29, 0x3a, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x69, 0x73, 0x20, 0x77, 0x68, 0x61, 0x74, 0x65, 0x76, 0x65, + 0x72, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x61, 0x74, 0x63, + 0x68, 0x20, 0x74, 0x6f, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, + 0x63, 0x61, 0x73, 0x74, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x73, + 0x20, 0x74, 0x6f, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x63, 0x61, 0x73, 0x65, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x2e, 0x0a, 0x20, 0x2d, 0x20, 0x50, 0x48, 0x41, 0x53, + 0x45, 0x20, 0x28, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x75, 0x73, 0x65, 0x20, 0x66, 0x75, 0x6e, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x5f, 0x49, 0x4e, 0x29, 0x3a, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, + 0x65, 0x67, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x75, 0x6d, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x79, 0x6f, 0x75, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x70, 0x61, 0x73, 0x73, 0x20, 0x6d, + 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x73, 0x20, 0x28, + 0x69, 0x2e, 0x65, 0x2e, 0x20, 0x5b, 0x22, 0x31, 0x22, 0x2c, 0x20, 0x22, 0x34, 0x22, 0x5d, 0x29, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x01, 0x04, 0x12, 0x04, 0x94, 0x02, 0x02, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x01, 0x06, 0x12, 0x04, 0x94, 0x02, 0x0b, 0x18, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x01, 0x01, 0x12, 0x04, 0x94, 0x02, 0x19, 0x1f, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x14, 0x02, 0x01, 0x03, 0x12, 0x04, 0x94, 0x02, 0x22, 0x23, 0x0a, 0x5b, 0x0a, + 0x02, 0x04, 0x15, 0x12, 0x06, 0x98, 0x02, 0x00, 0x9b, 0x02, 0x01, 0x1a, 0x4d, 0x20, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x77, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x2c, 0x20, 0x63, 0x6f, 0x6d, 0x65, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x65, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x65, 0x64, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x15, + 0x01, 0x12, 0x04, 0x98, 0x02, 0x08, 0x1c, 0x0a, 0x69, 0x0a, 0x04, 0x04, 0x15, 0x02, 0x00, 0x12, + 0x04, 0x9a, 0x02, 0x02, 0x2f, 0x1a, 0x5b, 0x20, 0x4e, 0x65, 0x77, 0x20, 0x6f, 0x72, 0x20, 0x75, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6d, + 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6c, 0x74, + 0x65, 0x72, 0x20, 0x63, 0x72, 0x69, 0x74, 0x65, 0x72, 0x69, 0x61, 0x2e, 0x20, 0x45, 0x6e, 0x72, + 0x69, 0x63, 0x68, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x63, 0x68, 0x69, 0x6c, 0x64, + 0x72, 0x65, 0x6e, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x00, 0x04, 0x12, 0x04, 0x9a, 0x02, 0x02, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x00, 0x06, 0x12, 0x04, 0x9a, 0x02, 0x0b, 0x19, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x00, 0x01, 0x12, 0x04, 0x9a, 0x02, 0x1a, 0x2a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x00, 0x03, 0x12, 0x04, 0x9a, 0x02, 0x2d, 0x2e, 0x0a, 0x0c, + 0x0a, 0x02, 0x04, 0x16, 0x12, 0x06, 0x9d, 0x02, 0x00, 0xa1, 0x02, 0x01, 0x0a, 0x0b, 0x0a, 0x03, + 0x04, 0x16, 0x01, 0x12, 0x04, 0x9d, 0x02, 0x08, 0x21, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x16, 0x02, + 0x00, 0x12, 0x04, 0x9e, 0x02, 0x02, 0x48, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x00, 0x06, + 0x12, 0x04, 0x9e, 0x02, 0x02, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x00, 0x01, 0x12, + 0x04, 0x9e, 0x02, 0x1a, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x00, 0x03, 0x12, 0x04, + 0x9e, 0x02, 0x1f, 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x00, 0x08, 0x12, 0x04, 0x9e, + 0x02, 0x21, 0x47, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x16, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, + 0x04, 0x9e, 0x02, 0x22, 0x46, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x16, 0x02, 0x01, 0x12, 0x04, 0xa0, + 0x02, 0x02, 0x3a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x01, 0x05, 0x12, 0x04, 0xa0, 0x02, + 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x01, 0x01, 0x12, 0x04, 0xa0, 0x02, 0x09, + 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x01, 0x03, 0x12, 0x04, 0xa0, 0x02, 0x13, 0x14, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x01, 0x08, 0x12, 0x04, 0xa0, 0x02, 0x15, 0x39, 0x0a, + 0x11, 0x0a, 0x09, 0x04, 0x16, 0x02, 0x01, 0x08, 0x87, 0x09, 0x05, 0x04, 0x12, 0x04, 0xa0, 0x02, + 0x16, 0x38, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x17, 0x12, 0x06, 0xa3, 0x02, 0x00, 0xa5, 0x02, 0x01, + 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x17, 0x01, 0x12, 0x04, 0xa3, 0x02, 0x08, 0x22, 0x0a, 0x0c, 0x0a, + 0x04, 0x04, 0x17, 0x02, 0x00, 0x12, 0x04, 0xa4, 0x02, 0x02, 0x2b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x17, 0x02, 0x00, 0x04, 0x12, 0x04, 0xa4, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x17, + 0x02, 0x00, 0x06, 0x12, 0x04, 0xa4, 0x02, 0x0b, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x17, 0x02, + 0x00, 0x01, 0x12, 0x04, 0xa4, 0x02, 0x18, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x17, 0x02, 0x00, + 0x03, 0x12, 0x04, 0xa4, 0x02, 0x29, 0x2a, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x18, 0x12, 0x06, 0xa7, + 0x02, 0x00, 0xad, 0x02, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x18, 0x01, 0x12, 0x04, 0xa7, 0x02, + 0x08, 0x1a, 0x0a, 0x20, 0x0a, 0x04, 0x04, 0x18, 0x02, 0x00, 0x12, 0x04, 0xa9, 0x02, 0x02, 0x4f, + 0x1a, 0x12, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x62, 0x6f, + 0x72, 0x74, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x18, 0x02, 0x00, 0x06, 0x12, 0x04, 0xa9, + 0x02, 0x02, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x18, 0x02, 0x00, 0x01, 0x12, 0x04, 0xa9, 0x02, + 0x1a, 0x23, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x18, 0x02, 0x00, 0x03, 0x12, 0x04, 0xa9, 0x02, 0x26, + 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x18, 0x02, 0x00, 0x08, 0x12, 0x04, 0xa9, 0x02, 0x28, 0x4e, + 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x18, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x04, 0xa9, 0x02, + 0x29, 0x4d, 0x0a, 0x38, 0x0a, 0x04, 0x04, 0x18, 0x02, 0x01, 0x12, 0x04, 0xac, 0x02, 0x02, 0x14, + 0x1a, 0x2a, 0x20, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x61, 0x73, + 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x18, 0x02, 0x01, 0x05, 0x12, 0x04, 0xac, 0x02, 0x02, 0x08, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x18, 0x02, 0x01, 0x01, 0x12, 0x04, 0xac, 0x02, 0x09, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x18, + 0x02, 0x01, 0x03, 0x12, 0x04, 0xac, 0x02, 0x12, 0x13, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x19, 0x12, + 0x04, 0xaf, 0x02, 0x00, 0x1e, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x19, 0x01, 0x12, 0x04, 0xaf, 0x02, + 0x08, 0x1b, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x1a, 0x12, 0x06, 0xb1, 0x02, 0x00, 0xcb, 0x02, 0x01, + 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x1a, 0x01, 0x12, 0x04, 0xb1, 0x02, 0x08, 0x1a, 0x0a, 0x0e, 0x0a, + 0x04, 0x04, 0x1a, 0x08, 0x00, 0x12, 0x06, 0xb2, 0x02, 0x02, 0xb6, 0x02, 0x03, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x1a, 0x08, 0x00, 0x01, 0x12, 0x04, 0xb2, 0x02, 0x08, 0x10, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x1a, 0x08, 0x00, 0x02, 0x12, 0x04, 0xb3, 0x02, 0x04, 0x30, 0x0a, 0x10, 0x0a, 0x08, 0x04, + 0x1a, 0x08, 0x00, 0x02, 0x87, 0x09, 0x01, 0x12, 0x04, 0xb3, 0x02, 0x04, 0x30, 0x0a, 0x2e, 0x0a, + 0x04, 0x04, 0x1a, 0x02, 0x00, 0x12, 0x04, 0xb5, 0x02, 0x04, 0x2c, 0x1a, 0x20, 0x20, 0x57, 0x61, + 0x74, 0x63, 0x68, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, + 0x6e, 0x20, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x1a, 0x02, 0x00, 0x06, 0x12, 0x04, 0xb5, 0x02, 0x04, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x1a, 0x02, 0x00, 0x01, 0x12, 0x04, 0xb5, 0x02, 0x1d, 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x1a, 0x02, 0x00, 0x03, 0x12, 0x04, 0xb5, 0x02, 0x2a, 0x2b, 0x0a, 0x44, 0x0a, 0x04, 0x04, 0x1a, + 0x02, 0x01, 0x12, 0x04, 0xb9, 0x02, 0x02, 0x52, 0x1a, 0x36, 0x20, 0x46, 0x69, 0x6c, 0x74, 0x65, + 0x72, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x64, 0x61, 0x74, 0x65, 0x20, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, + 0x69, 0x76, 0x65, 0x29, 0x2e, 0x20, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1a, 0x02, 0x01, 0x06, 0x12, 0x04, 0xb9, 0x02, 0x02, 0x1b, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x1a, 0x02, 0x01, 0x01, 0x12, 0x04, 0xb9, 0x02, 0x1c, 0x26, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x1a, 0x02, 0x01, 0x03, 0x12, 0x04, 0xb9, 0x02, 0x29, 0x2a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x1a, 0x02, 0x01, 0x08, 0x12, 0x04, 0xb9, 0x02, 0x2b, 0x51, 0x0a, 0x10, 0x0a, 0x08, + 0x04, 0x1a, 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x04, 0xb9, 0x02, 0x2c, 0x50, 0x0a, 0xa6, + 0x01, 0x0a, 0x04, 0x04, 0x1a, 0x02, 0x02, 0x12, 0x04, 0xbe, 0x02, 0x02, 0x29, 0x1a, 0x97, 0x01, + 0x20, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x20, 0x62, + 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x64, 0x61, 0x74, 0x65, 0x20, + 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x29, 0x2e, 0x0a, 0x20, 0x49, 0x66, + 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x2c, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x73, 0x74, 0x72, 0x65, + 0x61, 0x6d, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x20, 0x75, 0x70, 0x20, 0x74, 0x6f, + 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x0a, 0x20, + 0x49, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x2c, 0x20, 0x77, 0x69, 0x6c, + 0x6c, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x20, + 0x6f, 0x6e, 0x63, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x20, 0x73, + 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1a, 0x02, 0x02, 0x06, + 0x12, 0x04, 0xbe, 0x02, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1a, 0x02, 0x02, 0x01, 0x12, + 0x04, 0xbe, 0x02, 0x1c, 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1a, 0x02, 0x02, 0x03, 0x12, 0x04, + 0xbe, 0x02, 0x27, 0x28, 0x0a, 0x2f, 0x0a, 0x04, 0x04, 0x1a, 0x02, 0x03, 0x12, 0x04, 0xc1, 0x02, + 0x02, 0x21, 0x1a, 0x21, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x6c, 0x69, 0x73, 0x74, + 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, + 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1a, 0x02, 0x03, 0x06, 0x12, 0x04, + 0xc1, 0x02, 0x02, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1a, 0x02, 0x03, 0x01, 0x12, 0x04, 0xc1, + 0x02, 0x15, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1a, 0x02, 0x03, 0x03, 0x12, 0x04, 0xc1, 0x02, + 0x1f, 0x20, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x1a, 0x03, 0x00, 0x12, 0x06, 0xc3, 0x02, 0x02, 0xc7, + 0x02, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1a, 0x03, 0x00, 0x01, 0x12, 0x04, 0xc3, 0x02, 0x0a, + 0x18, 0x0a, 0x10, 0x0a, 0x06, 0x04, 0x1a, 0x03, 0x00, 0x08, 0x00, 0x12, 0x06, 0xc4, 0x02, 0x04, + 0xc6, 0x02, 0x05, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x1a, 0x03, 0x00, 0x08, 0x00, 0x01, 0x12, 0x04, + 0xc4, 0x02, 0x0a, 0x11, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x1a, 0x03, 0x00, 0x02, 0x00, 0x12, 0x04, + 0xc5, 0x02, 0x06, 0x2b, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x1a, 0x03, 0x00, 0x02, 0x00, 0x06, 0x12, + 0x04, 0xc5, 0x02, 0x06, 0x1b, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x1a, 0x03, 0x00, 0x02, 0x00, 0x01, + 0x12, 0x04, 0xc5, 0x02, 0x1c, 0x26, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x1a, 0x03, 0x00, 0x02, 0x00, + 0x03, 0x12, 0x04, 0xc5, 0x02, 0x29, 0x2a, 0x0a, 0x30, 0x0a, 0x04, 0x04, 0x1a, 0x02, 0x04, 0x12, + 0x04, 0xca, 0x02, 0x02, 0x30, 0x1a, 0x22, 0x20, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x73, 0x6f, + 0x72, 0x74, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x61, 0x74, + 0x63, 0x68, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1a, 0x02, + 0x04, 0x04, 0x12, 0x04, 0xca, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1a, 0x02, 0x04, + 0x06, 0x12, 0x04, 0xca, 0x02, 0x0b, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1a, 0x02, 0x04, 0x01, + 0x12, 0x04, 0xca, 0x02, 0x1a, 0x2b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1a, 0x02, 0x04, 0x03, 0x12, + 0x04, 0xca, 0x02, 0x2e, 0x2f, 0x0a, 0x3a, 0x0a, 0x02, 0x04, 0x1b, 0x12, 0x06, 0xce, 0x02, 0x00, + 0xd6, 0x02, 0x01, 0x1a, 0x2c, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x77, 0x61, 0x74, 0x63, 0x68, + 0x69, 0x6e, 0x67, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x2e, + 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x1b, 0x01, 0x12, 0x04, 0xce, 0x02, 0x08, 0x1b, 0x0a, 0xb3, + 0x01, 0x0a, 0x04, 0x04, 0x1b, 0x02, 0x00, 0x12, 0x04, 0xd2, 0x02, 0x02, 0x25, 0x1a, 0xa4, 0x01, + 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x67, 0x72, + 0x6f, 0x75, 0x70, 0x73, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x63, 0x72, 0x69, 0x74, 0x65, 0x72, 0x69, + 0x61, 0x2e, 0x0a, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x69, 0x74, + 0x69, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2c, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x20, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x2e, 0x0a, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x73, 0x75, 0x62, + 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x2c, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x6f, + 0x6e, 0x6c, 0x79, 0x20, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x20, 0x67, 0x72, 0x6f, 0x75, + 0x70, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1b, 0x02, 0x00, 0x04, 0x12, 0x04, 0xd2, + 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1b, 0x02, 0x00, 0x06, 0x12, 0x04, 0xd2, 0x02, + 0x0b, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1b, 0x02, 0x00, 0x01, 0x12, 0x04, 0xd2, 0x02, 0x15, + 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1b, 0x02, 0x00, 0x03, 0x12, 0x04, 0xd2, 0x02, 0x23, 0x24, + 0x0a, 0x66, 0x0a, 0x04, 0x04, 0x1b, 0x02, 0x01, 0x12, 0x04, 0xd5, 0x02, 0x02, 0x14, 0x1a, 0x58, + 0x20, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x20, 0x4c, 0x69, 0x73, 0x74, + 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, + 0x65, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x75, 0x62, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, + 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x75, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1b, 0x02, 0x01, + 0x05, 0x12, 0x04, 0xd5, 0x02, 0x02, 0x06, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1b, 0x02, 0x01, 0x01, + 0x12, 0x04, 0xd5, 0x02, 0x07, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x1b, 0x02, 0x01, 0x03, 0x12, + 0x04, 0xd5, 0x02, 0x12, 0x13, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0x8c, 0x2c, + 0x0a, 0x26, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x1a, 0x1b, 0x62, 0x75, + 0x66, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x69, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x70, + 0x68, 0x61, 0x73, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x17, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2f, 0x72, 0x70, 0x63, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x22, 0xbe, 0x01, 0x0a, 0x0a, 0x50, 0x75, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, + 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x31, 0x0a, 0x12, 0x70, + 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x10, 0x70, 0x61, 0x72, 0x65, 0x6e, + 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x12, 0x1d, + 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, + 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x42, 0x15, 0x0a, + 0x13, 0x5f, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x8a, 0x01, 0x0a, 0x0b, 0x50, 0x75, 0x74, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, + 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x32, 0x0a, + 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x22, 0x55, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0xa9, 0x01, 0x0a, 0x0b, 0x47, 0x65, 0x74, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, + 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, + 0x64, 0x12, 0x32, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x72, 0x70, 0x63, 0x2e, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x06, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1d, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xba, 0x48, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x05, 0x73, + 0x74, 0x61, 0x74, 0x65, 0x22, 0x6f, 0x0a, 0x0c, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x4e, 0x0a, 0x10, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x48, 0x00, 0x52, 0x0e, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x41, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x64, 0x42, 0x0f, 0x0a, 0x06, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x05, + 0xba, 0x48, 0x02, 0x08, 0x01, 0x22, 0xb2, 0x01, 0x0a, 0x0d, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x0d, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, + 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x48, 0x00, 0x52, 0x0c, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x12, 0x4d, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x5f, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x48, 0x00, 0x52, + 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x42, + 0x09, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x2c, 0x0a, 0x0e, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1a, 0x0a, 0x08, + 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, + 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x22, 0xf0, 0x01, 0x0a, 0x0c, 0x41, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x47, 0x0a, 0x09, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x42, 0x06, 0xba, 0x48, 0x03, 0xc8, 0x01, 0x01, 0x52, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x64, 0x12, 0x33, 0x0a, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0e, 0x32, 0x1d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x68, 0x61, 0x73, 0x65, + 0x52, 0x05, 0x70, 0x68, 0x61, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, + 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x48, 0x00, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x88, + 0x01, 0x01, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x75, 0x72, 0x69, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x55, 0x72, + 0x69, 0x42, 0x08, 0x0a, 0x06, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x32, 0xf4, 0x01, 0x0a, 0x0c, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x48, 0x0a, 0x03, + 0x50, 0x75, 0x74, 0x12, 0x1e, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x50, 0x75, 0x74, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x50, 0x75, 0x74, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x48, 0x0a, 0x03, 0x47, 0x65, 0x74, 0x12, 0x1e, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, + 0x12, 0x50, 0x0a, 0x05, 0x57, 0x61, 0x74, 0x63, 0x68, 0x12, 0x20, 0x2e, 0x66, 0x6c, 0x79, 0x74, + 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x57, + 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, + 0x30, 0x01, 0x42, 0xcc, 0x01, 0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, + 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x11, 0x53, + 0x74, 0x61, 0x74, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, + 0x50, 0x01, 0x5a, 0x36, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, + 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xa2, 0x02, 0x03, 0x46, 0x57, 0x58, + 0xaa, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x57, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xca, 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x5c, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xe2, 0x02, 0x1e, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5c, + 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x13, 0x46, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x3a, 0x3a, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x4a, 0xd0, 0x1d, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x6a, 0x01, 0x0a, 0x08, 0x0a, 0x01, + 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x1b, + 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x25, 0x0a, 0x09, 0x0a, 0x02, 0x03, + 0x01, 0x12, 0x03, 0x05, 0x00, 0x2b, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, + 0x26, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x03, 0x12, 0x03, 0x07, 0x00, 0x28, 0x0a, 0x09, 0x0a, 0x02, + 0x03, 0x04, 0x12, 0x03, 0x08, 0x00, 0x21, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x0a, 0x00, + 0x4d, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x0a, 0x00, 0x4d, 0x0a, 0x46, 0x0a, 0x02, + 0x06, 0x00, 0x12, 0x04, 0x0d, 0x00, 0x16, 0x01, 0x1a, 0x3a, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x06, 0x00, 0x01, 0x12, 0x03, 0x0d, 0x08, 0x14, + 0x0a, 0x2a, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0f, 0x02, 0x2e, 0x1a, 0x1d, 0x20, + 0x70, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, + 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0f, 0x06, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x00, 0x02, 0x12, 0x03, 0x0f, 0x0a, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x0f, 0x1f, 0x2a, 0x0a, 0x2a, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x01, 0x12, 0x03, + 0x12, 0x02, 0x2e, 0x1a, 0x1d, 0x20, 0x67, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, + 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x12, 0x06, 0x09, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x12, 0x0a, 0x14, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x12, 0x1f, 0x2a, 0x0a, 0x6f, 0x0a, 0x04, + 0x06, 0x00, 0x02, 0x02, 0x12, 0x03, 0x15, 0x02, 0x3b, 0x1a, 0x62, 0x20, 0x77, 0x61, 0x74, 0x63, + 0x68, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6f, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x70, 0x69, 0x20, + 0x67, 0x75, 0x61, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65, 0x73, 0x20, 0x61, 0x74, 0x2d, 0x6c, 0x65, + 0x61, 0x73, 0x74, 0x2d, 0x6f, 0x6e, 0x63, 0x65, 0x20, 0x64, 0x65, 0x6c, 0x69, 0x76, 0x65, 0x72, + 0x79, 0x20, 0x73, 0x65, 0x6d, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x06, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x15, 0x06, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x06, + 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x15, 0x0c, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, + 0x02, 0x06, 0x12, 0x03, 0x15, 0x23, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x15, 0x2a, 0x37, 0x0a, 0x3c, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x19, 0x00, 0x24, + 0x01, 0x1a, 0x30, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x74, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x19, 0x08, 0x12, 0x0a, + 0x32, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x1b, 0x02, 0x4f, 0x1a, 0x25, 0x20, 0x61, + 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x1b, 0x02, + 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1b, 0x1a, 0x23, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1b, 0x26, 0x27, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x08, 0x12, 0x03, 0x1b, 0x28, 0x4e, 0x0a, 0x0f, 0x0a, 0x08, 0x04, + 0x00, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x1b, 0x29, 0x4d, 0x0a, 0x4d, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x1e, 0x02, 0x29, 0x1a, 0x40, 0x20, 0x6f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, + 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x6e, 0x65, 0x73, 0x74, + 0x65, 0x64, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x01, 0x04, 0x12, 0x03, 0x1e, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x01, 0x05, 0x12, 0x03, 0x1e, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x1e, 0x12, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x1e, 0x27, 0x28, 0x0a, 0xa5, 0x02, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x23, 0x02, + 0x3d, 0x1a, 0x97, 0x02, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x20, 0x77, + 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x20, 0x73, 0x74, 0x61, + 0x74, 0x65, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x6a, 0x73, 0x6f, 0x6e, 0x20, 0x73, 0x65, 0x72, + 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x60, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x60, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, + 0x65, 0x64, 0x0a, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x65, 0x61, 0x6d, 0x6c, 0x65, 0x73, 0x73, 0x6c, + 0x79, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x74, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x50, + 0x72, 0x6f, 0x70, 0x65, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x65, 0x78, + 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x2e, 0x20, 0x77, + 0x65, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x0a, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x73, 0x75, 0x62, 0x73, 0x65, + 0x74, 0x20, 0x6f, 0x66, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x72, 0x65, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6e, 0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72, 0x79, + 0x20, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x69, 0x6d, 0x70, + 0x72, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x23, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x23, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x23, 0x11, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x08, 0x12, 0x03, + 0x23, 0x13, 0x3c, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x00, 0x02, 0x02, 0x08, 0x87, 0x09, 0x0e, 0x02, + 0x12, 0x03, 0x23, 0x14, 0x3b, 0x0a, 0x42, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x27, 0x00, 0x2d, + 0x01, 0x1a, 0x36, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x75, 0x74, 0x74, 0x69, 0x6e, 0x67, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, + 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, + 0x12, 0x03, 0x27, 0x08, 0x13, 0x0a, 0x32, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x29, + 0x02, 0x4f, 0x1a, 0x25, 0x20, 0x61, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x69, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x29, 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x29, 0x1a, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x29, 0x26, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x08, 0x12, 0x03, 0x29, 0x28, + 0x4e, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x01, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x29, + 0x29, 0x4d, 0x0a, 0x1a, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x2c, 0x02, 0x46, 0x1a, + 0x0d, 0x20, 0x54, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x06, 0x12, 0x03, 0x2c, 0x02, 0x13, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x2c, 0x14, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x2c, 0x1d, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, + 0x08, 0x12, 0x03, 0x2c, 0x1f, 0x45, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x01, 0x02, 0x01, 0x08, 0x87, + 0x09, 0x19, 0x12, 0x03, 0x2c, 0x20, 0x44, 0x0a, 0x3c, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x30, + 0x00, 0x33, 0x01, 0x1a, 0x30, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x67, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x30, 0x08, + 0x12, 0x0a, 0x32, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x32, 0x02, 0x4f, 0x1a, 0x25, + 0x20, 0x61, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, 0x03, + 0x32, 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x32, 0x1a, + 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x32, 0x26, 0x27, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x08, 0x12, 0x03, 0x32, 0x28, 0x4e, 0x0a, 0x0f, 0x0a, + 0x08, 0x04, 0x02, 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x32, 0x29, 0x4d, 0x0a, 0x42, + 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x36, 0x00, 0x3f, 0x01, 0x1a, 0x36, 0x20, 0x72, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x67, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, + 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x36, 0x08, 0x13, 0x0a, 0x32, + 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x38, 0x02, 0x4f, 0x1a, 0x25, 0x20, 0x61, 0x20, + 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, + 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x38, 0x02, 0x19, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x38, 0x1a, 0x23, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x38, 0x26, 0x27, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x00, 0x08, 0x12, 0x03, 0x38, 0x28, 0x4e, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x03, + 0x02, 0x00, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x38, 0x29, 0x4d, 0x0a, 0x1b, 0x0a, 0x04, 0x04, + 0x03, 0x02, 0x01, 0x12, 0x03, 0x3b, 0x02, 0x46, 0x1a, 0x0e, 0x0a, 0x20, 0x54, 0x68, 0x65, 0x20, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, + 0x06, 0x12, 0x03, 0x3b, 0x02, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x3b, 0x14, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x3b, + 0x1d, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x08, 0x12, 0x03, 0x3b, 0x1f, 0x45, + 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x03, 0x02, 0x01, 0x08, 0x87, 0x09, 0x19, 0x12, 0x03, 0x3b, 0x20, + 0x44, 0x0a, 0x35, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x02, 0x12, 0x03, 0x3e, 0x02, 0x3d, 0x1a, 0x28, + 0x20, 0x61, 0x20, 0x6a, 0x73, 0x6f, 0x6e, 0x20, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, + 0x65, 0x64, 0x20, 0x60, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x60, 0x20, + 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, + 0x05, 0x12, 0x03, 0x3e, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x3e, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x03, 0x12, 0x03, 0x3e, + 0x11, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x08, 0x12, 0x03, 0x3e, 0x13, 0x3c, + 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x03, 0x02, 0x02, 0x08, 0x87, 0x09, 0x0e, 0x02, 0x12, 0x03, 0x3e, + 0x14, 0x3b, 0x0a, 0x4b, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x42, 0x00, 0x4b, 0x01, 0x1a, 0x3f, + 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x77, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x75, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, + 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x42, 0x08, 0x14, 0x0a, 0x3e, 0x0a, 0x04, 0x04, + 0x04, 0x08, 0x00, 0x12, 0x04, 0x44, 0x02, 0x4a, 0x03, 0x1a, 0x30, 0x20, 0x63, 0x72, 0x69, 0x74, + 0x65, 0x72, 0x69, 0x61, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x69, + 0x6e, 0x67, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x20, 0x74, 0x6f, 0x20, 0x77, 0x61, 0x74, 0x63, 0x68, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x08, 0x00, 0x01, 0x12, 0x03, 0x44, 0x08, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x08, + 0x00, 0x02, 0x12, 0x03, 0x45, 0x04, 0x30, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x04, 0x08, 0x00, 0x02, + 0x87, 0x09, 0x01, 0x12, 0x03, 0x45, 0x04, 0x30, 0x0a, 0x76, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, + 0x12, 0x03, 0x49, 0x04, 0x31, 0x1a, 0x69, 0x20, 0x61, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, + 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x61, 0x74, 0x63, 0x68, 0x2e, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x69, 0x6e, 0x20, + 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20, + 0x63, 0x68, 0x69, 0x6c, 0x64, 0x0a, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x06, 0x12, 0x03, 0x49, 0x04, 0x1b, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x49, 0x1c, 0x2c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x49, 0x2f, 0x30, 0x0a, 0x4c, 0x0a, 0x02, 0x04, 0x05, + 0x12, 0x04, 0x4e, 0x00, 0x54, 0x01, 0x1a, 0x40, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x77, 0x61, + 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, + 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, + 0x03, 0x4e, 0x08, 0x15, 0x0a, 0x3c, 0x0a, 0x04, 0x04, 0x05, 0x08, 0x00, 0x12, 0x04, 0x50, 0x02, + 0x53, 0x03, 0x1a, 0x2e, 0x20, 0x61, 0x6e, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x20, 0x74, + 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x08, 0x00, 0x01, 0x12, 0x03, 0x50, 0x08, 0x0f, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x51, 0x04, 0x23, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x00, 0x06, 0x12, 0x03, 0x51, 0x04, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x51, 0x11, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x51, 0x21, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, + 0x03, 0x52, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x06, 0x12, 0x03, 0x52, + 0x04, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, 0x12, 0x03, 0x52, 0x13, 0x22, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x03, 0x52, 0x25, 0x26, 0x0a, 0x0a, + 0x0a, 0x02, 0x04, 0x06, 0x12, 0x04, 0x56, 0x00, 0x5b, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, + 0x01, 0x12, 0x03, 0x56, 0x08, 0x16, 0x0a, 0xe2, 0x02, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, + 0x03, 0x5a, 0x02, 0x14, 0x1a, 0xd4, 0x02, 0x20, 0x61, 0x20, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, + 0x65, 0x6c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x64, 0x69, + 0x63, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x64, 0x20, 0x6f, 0x66, 0x20, + 0x61, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, + 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x64, 0x69, 0x73, 0x61, 0x6d, 0x62, + 0x69, 0x67, 0x75, 0x61, 0x74, 0x65, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x20, 0x61, + 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x0a, 0x20, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x20, 0x57, 0x68, 0x65, 0x6e, 0x20, 0x61, 0x20, + 0x77, 0x61, 0x74, 0x63, 0x68, 0x20, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x72, 0x65, + 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, + 0x67, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x61, 0x20, 0x73, + 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, + 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x69, 0x6e, + 0x67, 0x20, 0x6f, 0x6e, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6f, 0x6e, 0x67, 0x6f, 0x69, 0x6e, + 0x67, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x2e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x64, 0x69, 0x73, 0x61, 0x6d, 0x62, 0x69, + 0x67, 0x75, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x74, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6e, 0x65, + 0x77, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x00, 0x05, 0x12, 0x03, 0x5a, 0x02, 0x06, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x5a, 0x07, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x5a, 0x12, 0x13, 0x0a, 0x47, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x04, 0x5e, 0x00, 0x6a, + 0x01, 0x1a, 0x3b, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x72, + 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x20, 0x61, 0x6e, 0x20, 0x75, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x03, 0x5e, 0x08, 0x14, 0x0a, 0x62, 0x0a, 0x04, 0x04, 0x07, + 0x02, 0x00, 0x12, 0x03, 0x60, 0x02, 0x4f, 0x1a, 0x55, 0x20, 0x41, 0x20, 0x75, 0x6e, 0x69, 0x71, + 0x75, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x60, 0x6e, + 0x69, 0x6c, 0x60, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, + 0x20, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3b, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2c, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x06, 0x12, 0x03, 0x60, 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x00, 0x01, 0x12, 0x03, 0x60, 0x1a, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x60, 0x26, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, + 0x08, 0x12, 0x03, 0x60, 0x28, 0x4e, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x07, 0x02, 0x00, 0x08, 0x87, + 0x09, 0x19, 0x12, 0x03, 0x60, 0x29, 0x4d, 0x0a, 0x2f, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x01, 0x12, + 0x03, 0x63, 0x02, 0x1f, 0x1a, 0x22, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x74, 0x20, 0x70, 0x68, 0x61, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, + 0x06, 0x12, 0x03, 0x63, 0x02, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x63, 0x15, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, 0x03, 0x63, + 0x1d, 0x1e, 0x0a, 0x40, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x02, 0x12, 0x03, 0x66, 0x02, 0x33, 0x1a, + 0x33, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x61, 0x73, 0x73, 0x6f, + 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x69, 0x66, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, + 0x73, 0x29, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x04, 0x12, 0x03, 0x66, + 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x06, 0x12, 0x03, 0x66, 0x0b, 0x28, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x01, 0x12, 0x03, 0x66, 0x29, 0x2e, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x03, 0x12, 0x03, 0x66, 0x31, 0x32, 0x0a, 0x2c, 0x0a, 0x04, + 0x04, 0x07, 0x02, 0x03, 0x12, 0x03, 0x69, 0x02, 0x18, 0x1a, 0x1f, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x75, 0x72, 0x69, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x03, 0x05, 0x12, 0x03, 0x69, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x03, + 0x01, 0x12, 0x03, 0x69, 0x09, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x03, 0x03, 0x12, + 0x03, 0x69, 0x16, 0x17, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0x97, 0x1c, 0x0a, + 0x2b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x2f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x73, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x66, 0x6c, + 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x1a, 0x1e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x1b, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, + 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x74, 0x61, 0x73, 0x6b, 0x2f, 0x74, 0x61, + 0x73, 0x6b, 0x5f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x22, 0x96, 0x01, 0x0a, 0x1f, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x54, 0x6f, + 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x64, 0x4c, 0x69, + 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x12, + 0x39, 0x0a, 0x09, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x4d, 0x61, 0x70, 0x52, + 0x09, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x22, 0x4f, 0x0a, 0x20, 0x4c, 0x69, + 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x54, 0x6f, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, + 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, + 0x0a, 0x04, 0x6a, 0x73, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, + 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x04, 0x6a, 0x73, 0x6f, 0x6e, 0x22, 0x4e, 0x0a, 0x1f, 0x4c, + 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x54, 0x6f, 0x4c, + 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2b, + 0x0a, 0x04, 0x6a, 0x73, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, + 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x04, 0x6a, 0x73, 0x6f, 0x6e, 0x22, 0x5c, 0x0a, 0x20, 0x4c, + 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x54, 0x6f, 0x4c, + 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x38, 0x0a, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, + 0x73, 0x6b, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x64, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, + 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x22, 0x58, 0x0a, 0x1f, 0x54, 0x61, 0x73, + 0x6b, 0x53, 0x70, 0x65, 0x63, 0x54, 0x6f, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, + 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x35, 0x0a, 0x09, + 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x18, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, 0x61, 0x73, 0x6b, + 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x52, 0x08, 0x74, 0x61, 0x73, 0x6b, 0x53, + 0x70, 0x65, 0x63, 0x22, 0x4f, 0x0a, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x54, + 0x6f, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x04, 0x6a, 0x73, 0x6f, 0x6e, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x04, + 0x6a, 0x73, 0x6f, 0x6e, 0x22, 0x89, 0x01, 0x0a, 0x1b, 0x4a, 0x73, 0x6f, 0x6e, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x54, 0x6f, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x39, 0x0a, 0x09, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, + 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, + 0x65, 0x4d, 0x61, 0x70, 0x52, 0x09, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, + 0x2f, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x22, 0x58, 0x0a, 0x1c, 0x4a, 0x73, 0x6f, 0x6e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x54, 0x6f, + 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x38, 0x0a, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x74, + 0x61, 0x73, 0x6b, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x64, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, + 0x52, 0x08, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x32, 0xba, 0x04, 0x0a, 0x11, 0x54, + 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x12, 0x8a, 0x01, 0x0a, 0x18, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x54, 0x6f, 0x4c, + 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x12, 0x33, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x54, 0x6f, 0x4c, 0x61, 0x75, + 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x34, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, + 0x54, 0x6f, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x8a, 0x01, + 0x0a, 0x18, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, + 0x54, 0x6f, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x12, 0x33, 0x2e, 0x66, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, + 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x54, 0x6f, + 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x34, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, + 0x73, 0x6f, 0x6e, 0x54, 0x6f, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x8a, 0x01, 0x0a, 0x18, 0x54, + 0x61, 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x54, 0x6f, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, + 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x12, 0x33, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, + 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x54, 0x61, 0x73, + 0x6b, 0x53, 0x70, 0x65, 0x63, 0x54, 0x6f, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x6f, 0x72, + 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x34, 0x2e, 0x66, + 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x2e, 0x54, 0x61, 0x73, 0x6b, 0x53, 0x70, 0x65, 0x63, 0x54, 0x6f, 0x4c, 0x61, 0x75, 0x6e, + 0x63, 0x68, 0x46, 0x6f, 0x72, 0x6d, 0x4a, 0x73, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x7e, 0x0a, 0x14, 0x4a, 0x73, 0x6f, 0x6e, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x73, 0x54, 0x6f, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x12, + 0x2f, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x4a, 0x73, 0x6f, 0x6e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x54, + 0x6f, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x30, 0x2e, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x4a, 0x73, 0x6f, 0x6e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x54, 0x6f, 0x4c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x42, 0xd1, 0x01, 0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x2e, + 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x42, 0x16, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x36, 0x67, 0x69, + 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x6f, 0x72, + 0x67, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, + 0x6f, 0x2f, 0x66, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2f, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0xa2, 0x02, 0x03, 0x46, 0x57, 0x58, 0xaa, 0x02, 0x12, 0x46, 0x6c, 0x79, + 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0xca, + 0x02, 0x12, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, 0x5c, 0x57, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0xe2, 0x02, 0x1e, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, 0x32, + 0x5c, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x13, 0x46, 0x6c, 0x79, 0x74, 0x65, 0x69, 0x64, 0x6c, + 0x32, 0x3a, 0x3a, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x4a, 0x90, 0x0e, 0x0a, 0x06, + 0x12, 0x04, 0x00, 0x00, 0x45, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, + 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x1b, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, + 0x12, 0x03, 0x04, 0x00, 0x28, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x05, 0x00, 0x25, + 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x06, 0x00, 0x2e, 0x0a, 0x09, 0x0a, 0x02, 0x03, + 0x03, 0x12, 0x03, 0x07, 0x00, 0x26, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x09, 0x00, 0x4d, + 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x09, 0x00, 0x4d, 0x0a, 0x6e, 0x0a, 0x02, 0x06, + 0x00, 0x12, 0x04, 0x0c, 0x00, 0x19, 0x01, 0x1a, 0x62, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, + 0x61, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, + 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x64, 0x69, 0x66, 0x65, 0x72, 0x65, + 0x6e, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, + 0x73, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x06, + 0x00, 0x01, 0x12, 0x03, 0x0c, 0x08, 0x19, 0x0a, 0x0c, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x00, 0x12, + 0x04, 0x0d, 0x02, 0x0f, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x0d, 0x06, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x0d, 0x1f, + 0x3e, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0d, 0x49, 0x69, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x04, 0x12, 0x03, 0x0e, 0x04, 0x2f, 0x0a, 0x0d, 0x0a, + 0x06, 0x06, 0x00, 0x02, 0x00, 0x04, 0x22, 0x12, 0x03, 0x0e, 0x04, 0x2f, 0x0a, 0x0c, 0x0a, 0x04, + 0x06, 0x00, 0x02, 0x01, 0x12, 0x04, 0x10, 0x02, 0x12, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x10, 0x06, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, + 0x02, 0x12, 0x03, 0x10, 0x1f, 0x3e, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x10, 0x49, 0x69, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x04, 0x12, 0x03, 0x11, + 0x04, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, 0x06, 0x00, 0x02, 0x01, 0x04, 0x22, 0x12, 0x03, 0x11, 0x04, + 0x2f, 0x0a, 0x0c, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x02, 0x12, 0x04, 0x13, 0x02, 0x15, 0x03, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x13, 0x06, 0x1e, 0x0a, 0x0c, 0x0a, + 0x05, 0x06, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x13, 0x1f, 0x3e, 0x0a, 0x0c, 0x0a, 0x05, 0x06, + 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x13, 0x49, 0x69, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, + 0x02, 0x04, 0x12, 0x03, 0x14, 0x04, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, 0x06, 0x00, 0x02, 0x02, 0x04, + 0x22, 0x12, 0x03, 0x14, 0x04, 0x2f, 0x0a, 0x0c, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x03, 0x12, 0x04, + 0x16, 0x02, 0x18, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x16, + 0x06, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x16, 0x1b, 0x36, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x16, 0x41, 0x5d, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x04, 0x12, 0x03, 0x17, 0x04, 0x2f, 0x0a, 0x0d, 0x0a, 0x06, + 0x06, 0x00, 0x02, 0x03, 0x04, 0x22, 0x12, 0x03, 0x17, 0x04, 0x2f, 0x0a, 0x0a, 0x0a, 0x02, 0x04, + 0x00, 0x12, 0x04, 0x1b, 0x00, 0x1f, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, + 0x1b, 0x08, 0x27, 0x0a, 0x2f, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x1d, 0x02, 0x2a, + 0x1a, 0x22, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x20, + 0x74, 0x6f, 0x20, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x4a, 0x53, + 0x4f, 0x4e, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x04, 0x12, 0x03, 0x1d, + 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x1d, 0x0b, 0x1c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1d, 0x1d, 0x25, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1d, 0x28, 0x29, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x1e, 0x02, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x01, 0x06, 0x12, 0x03, 0x1e, 0x02, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x1e, 0x1d, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x1e, 0x29, 0x2a, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x21, 0x00, 0x24, 0x01, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x21, 0x08, 0x28, 0x0a, 0x29, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x00, 0x12, 0x03, 0x23, 0x02, 0x22, 0x1a, 0x1c, 0x20, 0x54, 0x68, 0x65, 0x20, 0x4a, + 0x53, 0x4f, 0x4e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x74, 0x65, + 0x72, 0x61, 0x6c, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x23, 0x02, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x23, + 0x19, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x23, 0x20, 0x21, + 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x26, 0x00, 0x29, 0x01, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x02, 0x01, 0x12, 0x03, 0x26, 0x08, 0x27, 0x0a, 0x36, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, + 0x12, 0x03, 0x28, 0x02, 0x22, 0x1a, 0x29, 0x20, 0x54, 0x68, 0x65, 0x20, 0x4a, 0x53, 0x4f, 0x4e, + 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6f, 0x6e, 0x76, 0x65, + 0x72, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, 0x03, 0x28, 0x02, 0x18, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x28, 0x19, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x28, 0x20, 0x21, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x03, + 0x12, 0x04, 0x2b, 0x00, 0x2e, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x2b, + 0x08, 0x28, 0x0a, 0x3b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x2d, 0x02, 0x2a, 0x1a, + 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x20, 0x67, + 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x4a, 0x53, 0x4f, 0x4e, 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x04, 0x12, 0x03, 0x2d, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x2d, 0x0b, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2d, 0x1d, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x2d, 0x28, 0x29, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x30, + 0x00, 0x34, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x30, 0x08, 0x27, 0x0a, + 0x5f, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x33, 0x02, 0x28, 0x1a, 0x52, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x20, 0x73, 0x70, 0x65, 0x63, 0x20, 0x74, 0x6f, 0x20, + 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x4a, 0x53, 0x4f, 0x4e, 0x2e, + 0x0a, 0x20, 0x4d, 0x65, 0x72, 0x67, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x56, 0x61, 0x72, + 0x69, 0x61, 0x62, 0x6c, 0x65, 0x4d, 0x61, 0x70, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x06, 0x12, 0x03, 0x33, 0x02, 0x19, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x33, 0x1a, 0x23, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x33, 0x26, 0x27, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x05, + 0x12, 0x04, 0x36, 0x00, 0x39, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x36, + 0x08, 0x28, 0x0a, 0x2a, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x38, 0x02, 0x22, 0x1a, + 0x1d, 0x20, 0x54, 0x68, 0x65, 0x20, 0x4a, 0x53, 0x4f, 0x4e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x06, 0x12, 0x03, 0x38, 0x02, 0x18, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x38, 0x19, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x38, 0x20, 0x21, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x04, + 0x3b, 0x00, 0x40, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x03, 0x3b, 0x08, 0x23, + 0x0a, 0x54, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x03, 0x3d, 0x02, 0x2b, 0x1a, 0x47, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x28, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x4d, 0x61, + 0x70, 0x29, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, + 0x74, 0x75, 0x72, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x3d, 0x02, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x03, 0x3d, + 0x1d, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x03, 0x3d, 0x29, 0x2a, + 0x0a, 0x3a, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x01, 0x12, 0x03, 0x3f, 0x02, 0x24, 0x1a, 0x2d, 0x20, + 0x54, 0x68, 0x65, 0x20, 0x72, 0x61, 0x77, 0x20, 0x4a, 0x53, 0x4f, 0x4e, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x20, 0x74, + 0x6f, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x01, 0x06, 0x12, 0x03, 0x3f, 0x02, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x3f, 0x19, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x3f, 0x22, 0x23, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x04, 0x42, 0x00, + 0x45, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x03, 0x42, 0x08, 0x24, 0x0a, 0x56, + 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x03, 0x44, 0x02, 0x2a, 0x1a, 0x49, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, + 0x61, 0x74, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4a, 0x53, + 0x4f, 0x4e, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x04, 0x12, + 0x03, 0x44, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x06, 0x12, 0x03, 0x44, + 0x0b, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x01, 0x12, 0x03, 0x44, 0x1d, 0x25, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x03, 0x12, 0x03, 0x44, 0x28, 0x29, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +]; +include!("flyteidl2.workflow.tonic.rs"); +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/flyteidl2.workflow.tonic.rs b/gen/rust/src/flyteidl2.workflow.tonic.rs new file mode 100644 index 0000000000..7ae46d2030 --- /dev/null +++ b/gen/rust/src/flyteidl2.workflow.tonic.rs @@ -0,0 +1,3068 @@ +// @generated +/// Generated client implementations. +pub mod queue_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct QueueServiceClient { + inner: tonic::client::Grpc, + } + impl QueueServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl QueueServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> QueueServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + QueueServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + pub async fn enqueue_action( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.QueueService/EnqueueAction", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.workflow.QueueService", "EnqueueAction"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn abort_queued_run( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.QueueService/AbortQueuedRun", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.workflow.QueueService", "AbortQueuedRun"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn abort_queued_action( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.QueueService/AbortQueuedAction", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.workflow.QueueService", + "AbortQueuedAction", + ), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod queue_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with QueueServiceServer. + #[async_trait] + pub trait QueueService: Send + Sync + 'static { + async fn enqueue_action( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn abort_queued_run( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn abort_queued_action( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + #[derive(Debug)] + pub struct QueueServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl QueueServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for QueueServiceServer + where + T: QueueService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.workflow.QueueService/EnqueueAction" => { + #[allow(non_camel_case_types)] + struct EnqueueActionSvc(pub Arc); + impl< + T: QueueService, + > tonic::server::UnaryService + for EnqueueActionSvc { + type Response = super::EnqueueActionResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::enqueue_action(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = EnqueueActionSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.QueueService/AbortQueuedRun" => { + #[allow(non_camel_case_types)] + struct AbortQueuedRunSvc(pub Arc); + impl< + T: QueueService, + > tonic::server::UnaryService + for AbortQueuedRunSvc { + type Response = super::AbortQueuedRunResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::abort_queued_run(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = AbortQueuedRunSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.QueueService/AbortQueuedAction" => { + #[allow(non_camel_case_types)] + struct AbortQueuedActionSvc(pub Arc); + impl< + T: QueueService, + > tonic::server::UnaryService + for AbortQueuedActionSvc { + type Response = super::AbortQueuedActionResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::abort_queued_action(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = AbortQueuedActionSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for QueueServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService for QueueServiceServer { + const NAME: &'static str = "flyteidl2.workflow.QueueService"; + } +} +/// Generated client implementations. +pub mod run_logs_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct RunLogsServiceClient { + inner: tonic::client::Grpc, + } + impl RunLogsServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl RunLogsServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> RunLogsServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + RunLogsServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + pub async fn tail_logs( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.RunLogsService/TailLogs", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.workflow.RunLogsService", "TailLogs"), + ); + self.inner.server_streaming(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod run_logs_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with RunLogsServiceServer. + #[async_trait] + pub trait RunLogsService: Send + Sync + 'static { + /// Server streaming response type for the TailLogs method. + type TailLogsStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + Send + + 'static; + async fn tail_logs( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + } + #[derive(Debug)] + pub struct RunLogsServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl RunLogsServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for RunLogsServiceServer + where + T: RunLogsService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.workflow.RunLogsService/TailLogs" => { + #[allow(non_camel_case_types)] + struct TailLogsSvc(pub Arc); + impl< + T: RunLogsService, + > tonic::server::ServerStreamingService + for TailLogsSvc { + type Response = super::TailLogsResponse; + type ResponseStream = T::TailLogsStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::tail_logs(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = TailLogsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for RunLogsServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService for RunLogsServiceServer { + const NAME: &'static str = "flyteidl2.workflow.RunLogsService"; + } +} +/// Generated client implementations. +pub mod run_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct RunServiceClient { + inner: tonic::client::Grpc, + } + impl RunServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl RunServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> RunServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + RunServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + pub async fn create_run( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.RunService/CreateRun", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.workflow.RunService", "CreateRun")); + self.inner.unary(req, path, codec).await + } + pub async fn abort_run( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.RunService/AbortRun", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.workflow.RunService", "AbortRun")); + self.inner.unary(req, path, codec).await + } + pub async fn get_run_details( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.RunService/GetRunDetails", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.workflow.RunService", "GetRunDetails"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn watch_run_details( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.RunService/WatchRunDetails", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.workflow.RunService", "WatchRunDetails"), + ); + self.inner.server_streaming(req, path, codec).await + } + pub async fn get_action_details( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.RunService/GetActionDetails", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.workflow.RunService", "GetActionDetails"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn watch_action_details( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.RunService/WatchActionDetails", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.workflow.RunService", + "WatchActionDetails", + ), + ); + self.inner.server_streaming(req, path, codec).await + } + pub async fn get_action_data( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.RunService/GetActionData", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.workflow.RunService", "GetActionData"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn list_runs( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.RunService/ListRuns", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.workflow.RunService", "ListRuns")); + self.inner.unary(req, path, codec).await + } + pub async fn watch_runs( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.RunService/WatchRuns", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.workflow.RunService", "WatchRuns")); + self.inner.server_streaming(req, path, codec).await + } + pub async fn list_actions( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.RunService/ListActions", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.workflow.RunService", "ListActions")); + self.inner.unary(req, path, codec).await + } + pub async fn watch_actions( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.RunService/WatchActions", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("flyteidl2.workflow.RunService", "WatchActions"), + ); + self.inner.server_streaming(req, path, codec).await + } + pub async fn watch_cluster_events( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.RunService/WatchClusterEvents", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.workflow.RunService", + "WatchClusterEvents", + ), + ); + self.inner.server_streaming(req, path, codec).await + } + pub async fn abort_action( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.RunService/AbortAction", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.workflow.RunService", "AbortAction")); + self.inner.unary(req, path, codec).await + } + pub async fn watch_groups( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.RunService/WatchGroups", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.workflow.RunService", "WatchGroups")); + self.inner.server_streaming(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod run_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with RunServiceServer. + #[async_trait] + pub trait RunService: Send + Sync + 'static { + async fn create_run( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn abort_run( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn get_run_details( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the WatchRunDetails method. + type WatchRunDetailsStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + Send + + 'static; + async fn watch_run_details( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn get_action_details( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the WatchActionDetails method. + type WatchActionDetailsStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result< + super::WatchActionDetailsResponse, + tonic::Status, + >, + > + + Send + + 'static; + async fn watch_action_details( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn get_action_data( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn list_runs( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the WatchRuns method. + type WatchRunsStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + Send + + 'static; + async fn watch_runs( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn list_actions( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the WatchActions method. + type WatchActionsStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + Send + + 'static; + async fn watch_actions( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the WatchClusterEvents method. + type WatchClusterEventsStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result< + super::WatchClusterEventsResponse, + tonic::Status, + >, + > + + Send + + 'static; + async fn watch_cluster_events( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn abort_action( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the WatchGroups method. + type WatchGroupsStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + Send + + 'static; + async fn watch_groups( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + #[derive(Debug)] + pub struct RunServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl RunServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for RunServiceServer + where + T: RunService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.workflow.RunService/CreateRun" => { + #[allow(non_camel_case_types)] + struct CreateRunSvc(pub Arc); + impl< + T: RunService, + > tonic::server::UnaryService + for CreateRunSvc { + type Response = super::CreateRunResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::create_run(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = CreateRunSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.RunService/AbortRun" => { + #[allow(non_camel_case_types)] + struct AbortRunSvc(pub Arc); + impl< + T: RunService, + > tonic::server::UnaryService + for AbortRunSvc { + type Response = super::AbortRunResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::abort_run(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = AbortRunSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.RunService/GetRunDetails" => { + #[allow(non_camel_case_types)] + struct GetRunDetailsSvc(pub Arc); + impl< + T: RunService, + > tonic::server::UnaryService + for GetRunDetailsSvc { + type Response = super::GetRunDetailsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_run_details(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetRunDetailsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.RunService/WatchRunDetails" => { + #[allow(non_camel_case_types)] + struct WatchRunDetailsSvc(pub Arc); + impl< + T: RunService, + > tonic::server::ServerStreamingService< + super::WatchRunDetailsRequest, + > for WatchRunDetailsSvc { + type Response = super::WatchRunDetailsResponse; + type ResponseStream = T::WatchRunDetailsStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::watch_run_details(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = WatchRunDetailsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.RunService/GetActionDetails" => { + #[allow(non_camel_case_types)] + struct GetActionDetailsSvc(pub Arc); + impl< + T: RunService, + > tonic::server::UnaryService + for GetActionDetailsSvc { + type Response = super::GetActionDetailsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_action_details(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetActionDetailsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.RunService/WatchActionDetails" => { + #[allow(non_camel_case_types)] + struct WatchActionDetailsSvc(pub Arc); + impl< + T: RunService, + > tonic::server::ServerStreamingService< + super::WatchActionDetailsRequest, + > for WatchActionDetailsSvc { + type Response = super::WatchActionDetailsResponse; + type ResponseStream = T::WatchActionDetailsStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::watch_action_details(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = WatchActionDetailsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.RunService/GetActionData" => { + #[allow(non_camel_case_types)] + struct GetActionDataSvc(pub Arc); + impl< + T: RunService, + > tonic::server::UnaryService + for GetActionDataSvc { + type Response = super::GetActionDataResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_action_data(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetActionDataSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.RunService/ListRuns" => { + #[allow(non_camel_case_types)] + struct ListRunsSvc(pub Arc); + impl< + T: RunService, + > tonic::server::UnaryService + for ListRunsSvc { + type Response = super::ListRunsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::list_runs(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ListRunsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.RunService/WatchRuns" => { + #[allow(non_camel_case_types)] + struct WatchRunsSvc(pub Arc); + impl< + T: RunService, + > tonic::server::ServerStreamingService + for WatchRunsSvc { + type Response = super::WatchRunsResponse; + type ResponseStream = T::WatchRunsStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::watch_runs(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = WatchRunsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.RunService/ListActions" => { + #[allow(non_camel_case_types)] + struct ListActionsSvc(pub Arc); + impl< + T: RunService, + > tonic::server::UnaryService + for ListActionsSvc { + type Response = super::ListActionsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::list_actions(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ListActionsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.RunService/WatchActions" => { + #[allow(non_camel_case_types)] + struct WatchActionsSvc(pub Arc); + impl< + T: RunService, + > tonic::server::ServerStreamingService + for WatchActionsSvc { + type Response = super::WatchActionsResponse; + type ResponseStream = T::WatchActionsStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::watch_actions(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = WatchActionsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.RunService/WatchClusterEvents" => { + #[allow(non_camel_case_types)] + struct WatchClusterEventsSvc(pub Arc); + impl< + T: RunService, + > tonic::server::ServerStreamingService< + super::WatchClusterEventsRequest, + > for WatchClusterEventsSvc { + type Response = super::WatchClusterEventsResponse; + type ResponseStream = T::WatchClusterEventsStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::watch_cluster_events(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = WatchClusterEventsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.RunService/AbortAction" => { + #[allow(non_camel_case_types)] + struct AbortActionSvc(pub Arc); + impl< + T: RunService, + > tonic::server::UnaryService + for AbortActionSvc { + type Response = super::AbortActionResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::abort_action(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = AbortActionSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.RunService/WatchGroups" => { + #[allow(non_camel_case_types)] + struct WatchGroupsSvc(pub Arc); + impl< + T: RunService, + > tonic::server::ServerStreamingService + for WatchGroupsSvc { + type Response = super::WatchGroupsResponse; + type ResponseStream = T::WatchGroupsStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::watch_groups(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = WatchGroupsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for RunServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService for RunServiceServer { + const NAME: &'static str = "flyteidl2.workflow.RunService"; + } +} +/// Generated client implementations. +pub mod state_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct StateServiceClient { + inner: tonic::client::Grpc, + } + impl StateServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl StateServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> StateServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + StateServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + pub async fn put( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.StateService/Put", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.workflow.StateService", "Put")); + self.inner.unary(req, path, codec).await + } + pub async fn get( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.StateService/Get", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.workflow.StateService", "Get")); + self.inner.unary(req, path, codec).await + } + pub async fn watch( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.StateService/Watch", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("flyteidl2.workflow.StateService", "Watch")); + self.inner.server_streaming(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod state_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with StateServiceServer. + #[async_trait] + pub trait StateService: Send + Sync + 'static { + async fn put( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn get( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Server streaming response type for the Watch method. + type WatchStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + Send + + 'static; + async fn watch( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + } + #[derive(Debug)] + pub struct StateServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl StateServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for StateServiceServer + where + T: StateService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.workflow.StateService/Put" => { + #[allow(non_camel_case_types)] + struct PutSvc(pub Arc); + impl tonic::server::UnaryService + for PutSvc { + type Response = super::PutResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::put(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = PutSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.StateService/Get" => { + #[allow(non_camel_case_types)] + struct GetSvc(pub Arc); + impl tonic::server::UnaryService + for GetSvc { + type Response = super::GetResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.StateService/Watch" => { + #[allow(non_camel_case_types)] + struct WatchSvc(pub Arc); + impl< + T: StateService, + > tonic::server::ServerStreamingService + for WatchSvc { + type Response = super::WatchResponse; + type ResponseStream = T::WatchStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::watch(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = WatchSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for StateServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService for StateServiceServer { + const NAME: &'static str = "flyteidl2.workflow.StateService"; + } +} +/// Generated client implementations. +pub mod translator_service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct TranslatorServiceClient { + inner: tonic::client::Grpc, + } + impl TranslatorServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl TranslatorServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> TranslatorServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + TranslatorServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + pub async fn literals_to_launch_form_json( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.TranslatorService/LiteralsToLaunchFormJson", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.workflow.TranslatorService", + "LiteralsToLaunchFormJson", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn launch_form_json_to_literals( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.TranslatorService/LaunchFormJsonToLiterals", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.workflow.TranslatorService", + "LaunchFormJsonToLiterals", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn task_spec_to_launch_form_json( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.TranslatorService/TaskSpecToLaunchFormJson", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.workflow.TranslatorService", + "TaskSpecToLaunchFormJson", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn json_values_to_literals( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/flyteidl2.workflow.TranslatorService/JsonValuesToLiterals", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "flyteidl2.workflow.TranslatorService", + "JsonValuesToLiterals", + ), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod translator_service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with TranslatorServiceServer. + #[async_trait] + pub trait TranslatorService: Send + Sync + 'static { + async fn literals_to_launch_form_json( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn launch_form_json_to_literals( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn task_spec_to_launch_form_json( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn json_values_to_literals( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + #[derive(Debug)] + pub struct TranslatorServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl TranslatorServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for TranslatorServiceServer + where + T: TranslatorService, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/flyteidl2.workflow.TranslatorService/LiteralsToLaunchFormJson" => { + #[allow(non_camel_case_types)] + struct LiteralsToLaunchFormJsonSvc(pub Arc); + impl< + T: TranslatorService, + > tonic::server::UnaryService + for LiteralsToLaunchFormJsonSvc { + type Response = super::LiteralsToLaunchFormJsonResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::LiteralsToLaunchFormJsonRequest, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::literals_to_launch_form_json( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = LiteralsToLaunchFormJsonSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.TranslatorService/LaunchFormJsonToLiterals" => { + #[allow(non_camel_case_types)] + struct LaunchFormJsonToLiteralsSvc(pub Arc); + impl< + T: TranslatorService, + > tonic::server::UnaryService + for LaunchFormJsonToLiteralsSvc { + type Response = super::LaunchFormJsonToLiteralsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::LaunchFormJsonToLiteralsRequest, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::launch_form_json_to_literals( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = LaunchFormJsonToLiteralsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.TranslatorService/TaskSpecToLaunchFormJson" => { + #[allow(non_camel_case_types)] + struct TaskSpecToLaunchFormJsonSvc(pub Arc); + impl< + T: TranslatorService, + > tonic::server::UnaryService + for TaskSpecToLaunchFormJsonSvc { + type Response = super::TaskSpecToLaunchFormJsonResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::TaskSpecToLaunchFormJsonRequest, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::task_spec_to_launch_form_json( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = TaskSpecToLaunchFormJsonSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/flyteidl2.workflow.TranslatorService/JsonValuesToLiterals" => { + #[allow(non_camel_case_types)] + struct JsonValuesToLiteralsSvc(pub Arc); + impl< + T: TranslatorService, + > tonic::server::UnaryService + for JsonValuesToLiteralsSvc { + type Response = super::JsonValuesToLiteralsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::json_values_to_literals( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = JsonValuesToLiteralsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for TranslatorServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService + for TranslatorServiceServer { + const NAME: &'static str = "flyteidl2.workflow.TranslatorService"; + } +} diff --git a/gen/rust/src/google.rpc.rs b/gen/rust/src/google.rpc.rs new file mode 100644 index 0000000000..2576dadaf8 --- /dev/null +++ b/gen/rust/src/google.rpc.rs @@ -0,0 +1,163 @@ +// @generated +// This file is @generated by prost-build. +/// The `Status` type defines a logical error model that is suitable for +/// different programming environments, including REST APIs and RPC APIs. It is +/// used by [gRPC](). Each `Status` message contains +/// three pieces of data: error code, error message, and error details. +/// +/// You can find out more about this error model and how to work with it in the +/// [API Design Guide](). +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Status { + /// The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]. + #[prost(int32, tag="1")] + pub code: i32, + /// A developer-facing error message, which should be in English. Any + /// user-facing error message should be localized and sent in the + /// [google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client. + #[prost(string, tag="2")] + pub message: ::prost::alloc::string::String, + /// A list of messages that carry the error details. There is a common set of + /// message types for APIs to use. + #[prost(message, repeated, tag="3")] + pub details: ::prost::alloc::vec::Vec, +} +/// Encoded file descriptor set for the `google.rpc` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xc5, 0x10, 0x0a, 0x17, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x72, 0x70, 0x63, 0x2f, + 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0a, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x72, 0x70, 0x63, 0x1a, 0x19, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x22, 0x66, 0x0a, 0x06, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x12, 0x0a, + 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x63, 0x6f, 0x64, + 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x2e, 0x0a, 0x07, 0x64, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, + 0x6e, 0x79, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x42, 0xa2, 0x01, 0x0a, 0x0e, + 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x72, 0x70, 0x63, 0x42, 0x0b, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x37, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, + 0x2f, 0x67, 0x65, 0x6e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x61, 0x70, 0x69, 0x73, 0x2f, 0x72, 0x70, 0x63, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x3b, + 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0xf8, 0x01, 0x01, 0xa2, 0x02, 0x03, 0x47, 0x52, 0x58, 0xaa, + 0x02, 0x0a, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x52, 0x70, 0x63, 0xca, 0x02, 0x0a, 0x47, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5c, 0x52, 0x70, 0x63, 0xe2, 0x02, 0x16, 0x47, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x5c, 0x52, 0x70, 0x63, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x0b, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x3a, 0x3a, 0x52, 0x70, 0x63, + 0x4a, 0xed, 0x0d, 0x0a, 0x06, 0x12, 0x04, 0x0e, 0x00, 0x2e, 0x01, 0x0a, 0xbc, 0x04, 0x0a, 0x01, + 0x0c, 0x12, 0x03, 0x0e, 0x00, 0x12, 0x32, 0xb1, 0x04, 0x20, 0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x20, 0x32, 0x30, 0x32, 0x30, 0x20, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x20, + 0x4c, 0x4c, 0x43, 0x0a, 0x0a, 0x20, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x64, 0x20, 0x75, + 0x6e, 0x64, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x41, 0x70, 0x61, 0x63, 0x68, 0x65, 0x20, + 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x2c, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x20, 0x32, 0x2e, 0x30, 0x20, 0x28, 0x74, 0x68, 0x65, 0x20, 0x22, 0x4c, 0x69, 0x63, 0x65, 0x6e, + 0x73, 0x65, 0x22, 0x29, 0x3b, 0x0a, 0x20, 0x79, 0x6f, 0x75, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x6e, + 0x6f, 0x74, 0x20, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6c, 0x65, + 0x20, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, + 0x69, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4c, + 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x2e, 0x0a, 0x20, 0x59, 0x6f, 0x75, 0x20, 0x6d, 0x61, 0x79, + 0x20, 0x6f, 0x62, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x70, 0x79, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x20, 0x61, 0x74, + 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, + 0x77, 0x2e, 0x61, 0x70, 0x61, 0x63, 0x68, 0x65, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x6c, 0x69, 0x63, + 0x65, 0x6e, 0x73, 0x65, 0x73, 0x2f, 0x4c, 0x49, 0x43, 0x45, 0x4e, 0x53, 0x45, 0x2d, 0x32, 0x2e, + 0x30, 0x0a, 0x0a, 0x20, 0x55, 0x6e, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, + 0x72, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, + 0x65, 0x20, 0x6c, 0x61, 0x77, 0x20, 0x6f, 0x72, 0x20, 0x61, 0x67, 0x72, 0x65, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x72, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x2c, 0x20, 0x73, + 0x6f, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x0a, 0x20, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4c, + 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x20, 0x69, 0x73, 0x20, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, + 0x62, 0x75, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x20, 0x22, 0x41, 0x53, 0x20, + 0x49, 0x53, 0x22, 0x20, 0x42, 0x41, 0x53, 0x49, 0x53, 0x2c, 0x0a, 0x20, 0x57, 0x49, 0x54, 0x48, + 0x4f, 0x55, 0x54, 0x20, 0x57, 0x41, 0x52, 0x52, 0x41, 0x4e, 0x54, 0x49, 0x45, 0x53, 0x20, 0x4f, + 0x52, 0x20, 0x43, 0x4f, 0x4e, 0x44, 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x53, 0x20, 0x4f, 0x46, 0x20, + 0x41, 0x4e, 0x59, 0x20, 0x4b, 0x49, 0x4e, 0x44, 0x2c, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, + 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x20, 0x6f, 0x72, 0x20, 0x69, 0x6d, 0x70, 0x6c, + 0x69, 0x65, 0x64, 0x2e, 0x0a, 0x20, 0x53, 0x65, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4c, 0x69, + 0x63, 0x65, 0x6e, 0x73, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x20, + 0x67, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x0a, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x2e, 0x0a, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, + 0x03, 0x10, 0x00, 0x13, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x12, 0x00, 0x23, 0x0a, + 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x14, 0x00, 0x1f, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x1f, 0x12, + 0x03, 0x14, 0x00, 0x1f, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x15, 0x00, 0x4e, 0x0a, 0x09, + 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x15, 0x00, 0x4e, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, + 0x16, 0x00, 0x22, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0a, 0x12, 0x03, 0x16, 0x00, 0x22, 0x0a, 0x08, + 0x0a, 0x01, 0x08, 0x12, 0x03, 0x17, 0x00, 0x2c, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x08, 0x12, 0x03, + 0x17, 0x00, 0x2c, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x18, 0x00, 0x27, 0x0a, 0x09, 0x0a, + 0x02, 0x08, 0x01, 0x12, 0x03, 0x18, 0x00, 0x27, 0x0a, 0xbe, 0x03, 0x0a, 0x02, 0x04, 0x00, 0x12, + 0x04, 0x22, 0x00, 0x2e, 0x01, 0x1a, 0xb1, 0x03, 0x20, 0x54, 0x68, 0x65, 0x20, 0x60, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x60, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, + 0x65, 0x73, 0x20, 0x61, 0x20, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x65, 0x72, 0x72, + 0x6f, 0x72, 0x20, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, + 0x20, 0x73, 0x75, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x0a, 0x20, 0x64, + 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, + 0x6d, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, + 0x73, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x52, 0x45, 0x53, + 0x54, 0x20, 0x41, 0x50, 0x49, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x52, 0x50, 0x43, 0x20, 0x41, + 0x50, 0x49, 0x73, 0x2e, 0x20, 0x49, 0x74, 0x20, 0x69, 0x73, 0x0a, 0x20, 0x75, 0x73, 0x65, 0x64, + 0x20, 0x62, 0x79, 0x20, 0x5b, 0x67, 0x52, 0x50, 0x43, 0x5d, 0x28, 0x68, 0x74, 0x74, 0x70, 0x73, + 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x72, + 0x70, 0x63, 0x29, 0x2e, 0x20, 0x45, 0x61, 0x63, 0x68, 0x20, 0x60, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x60, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x73, 0x0a, 0x20, 0x74, 0x68, 0x72, 0x65, 0x65, 0x20, 0x70, 0x69, 0x65, 0x63, 0x65, + 0x73, 0x20, 0x6f, 0x66, 0x20, 0x64, 0x61, 0x74, 0x61, 0x3a, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, + 0x20, 0x63, 0x6f, 0x64, 0x65, 0x2c, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, + 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x0a, 0x0a, 0x20, 0x59, 0x6f, 0x75, 0x20, 0x63, + 0x61, 0x6e, 0x20, 0x66, 0x69, 0x6e, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6d, 0x6f, 0x72, 0x65, + 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x65, 0x72, 0x72, 0x6f, + 0x72, 0x20, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x68, 0x6f, 0x77, 0x20, + 0x74, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x69, 0x74, 0x20, + 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x5b, 0x41, 0x50, 0x49, 0x20, 0x44, 0x65, 0x73, + 0x69, 0x67, 0x6e, 0x20, 0x47, 0x75, 0x69, 0x64, 0x65, 0x5d, 0x28, 0x68, 0x74, 0x74, 0x70, 0x73, + 0x3a, 0x2f, 0x2f, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x2f, + 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x29, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, + 0x12, 0x03, 0x22, 0x08, 0x0e, 0x0a, 0x64, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x24, + 0x02, 0x11, 0x1a, 0x57, 0x20, 0x54, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, + 0x63, 0x6f, 0x64, 0x65, 0x2c, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x6e, 0x75, 0x6d, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x5b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x72, + 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x64, 0x65, 0x5d, 0x5b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x64, 0x65, 0x5d, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x24, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x24, 0x08, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x24, 0x0f, 0x10, 0x0a, 0xeb, 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, + 0x29, 0x02, 0x15, 0x1a, 0xdd, 0x01, 0x20, 0x41, 0x20, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, + 0x65, 0x72, 0x2d, 0x66, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2c, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x45, 0x6e, 0x67, 0x6c, + 0x69, 0x73, 0x68, 0x2e, 0x20, 0x41, 0x6e, 0x79, 0x0a, 0x20, 0x75, 0x73, 0x65, 0x72, 0x2d, 0x66, + 0x61, 0x63, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x6f, + 0x63, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x65, 0x6e, 0x74, + 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x5b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x64, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x5d, 0x5b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x72, 0x70, 0x63, 0x2e, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x5d, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x69, + 0x7a, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x29, 0x02, + 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x29, 0x09, 0x10, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x29, 0x13, 0x14, 0x0a, 0x79, 0x0a, + 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x2d, 0x02, 0x2b, 0x1a, 0x6c, 0x20, 0x41, 0x20, 0x6c, + 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x72, 0x72, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, + 0x72, 0x72, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x20, 0x20, 0x54, + 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x41, 0x50, 0x49, 0x73, 0x20, + 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, + 0x04, 0x12, 0x03, 0x2d, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, + 0x03, 0x2d, 0x0b, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x2d, + 0x1f, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x2d, 0x29, 0x2a, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +]; +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/rust/src/lib.rs b/gen/rust/src/lib.rs new file mode 100644 index 0000000000..31b27dc8b9 --- /dev/null +++ b/gen/rust/src/lib.rs @@ -0,0 +1,99 @@ +// mod test_foo; + +// mod serde; + +// mod serde_impl; + +use pyo3; +use pyo3::prelude::*; +// use crate::HeartbeatResponse; +// include!("flyteidl.common.rs"); +// include!("flyteidl.workflow.rs"); +// include!("flyteidl.workflow.tonic.rs"); +// inculde!("flyteidl.logs.dataplane.rs"); +// include!("flyteidl.core.rs"); +// include!("google.rpc.rs"); +// include!("validate.rs"); + +// use crate::*; +// Re-export all generated protobuf modules +pub mod flyteidl { + + pub mod common { + include!("flyteidl2.common.rs"); + } + pub mod workflow { + include!("flyteidl2.workflow.rs"); + } + + pub mod logs { + pub mod dataplane { + include!("flyteidl2.logs.dataplane.rs"); + } + } + + pub mod core { + include!("flyteidl2.core.rs"); + } + + pub mod task { + include!("flyteidl2.task.rs"); + } + + pub mod trigger { + include!("flyteidl2.trigger.rs"); + } + + pub mod secret { + include!("flyteidl2.secret.rs"); + } +} + +// use pyo3_prost::pyclass_for_prost_struct; +pub mod google { + pub mod rpc { + include!("google.rpc.rs"); + // pub mod serde { + // include!("google.rpc.serde.rs"); + // } + } + pub mod protobuf { + include!(concat!(env!("OUT_DIR"), "/google.protobuf.rs")); + include!(concat!(env!("OUT_DIR"), "/google.protobuf.serde.rs")); + } +} + +pub mod validate { + include!("validate.rs"); + // pub mod serde { + // include!("validate.serde.rs"); + // } +} + +// Include the generated Box implementations +include!(concat!(env!("OUT_DIR"), "/boxed_impls.rs")); +// pub mod serde { +// include!(concat!(env!("OUT_DIR"), "/serde_impls.rs")); +// } +pub mod pymodules { + include!(concat!(env!("OUT_DIR"), "/pymodules.rs")); +} + +include!(concat!(env!("OUT_DIR"), "/serde_impls.rs")); +// include!("serde_impl.rs"); + +// +// // Re-export commonly used types at the root level for convenience +// pub use flyteidl::common::*; +// pub use flyteidl::workflow::*; +// pub use flyteidl::core::*; +// pub use google::rpc::*; +// pub use validate::*; +// pub use crate::*; + +// #[pymodule] +// fn pb_rust(_py: Python, m: &PyModule) -> PyResult<()> { +// m.add_submodule(flyteidl::workflow::make_module(_py)?)?; +// // ... all submodules ... +// Ok(()) +// } diff --git a/gen/rust/src/validate.rs b/gen/rust/src/validate.rs new file mode 100644 index 0000000000..01f02e8ad8 --- /dev/null +++ b/gen/rust/src/validate.rs @@ -0,0 +1,3658 @@ +// @generated +// This file is @generated by prost-build. +/// FieldRules encapsulates the rules for each type of field. Depending on the +/// field, the correct set should be used to ensure proper validations. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FieldRules { + #[prost(message, optional, tag="17")] + pub message: ::core::option::Option, + #[prost(oneof="field_rules::Type", tags="1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 20, 21, 22")] + pub r#type: ::core::option::Option, +} +/// Nested message and enum types in `FieldRules`. +pub mod field_rules { + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Type { + /// Scalar Field Types + #[prost(message, tag="1")] + Float(super::FloatRules), + #[prost(message, tag="2")] + Double(super::DoubleRules), + #[prost(message, tag="3")] + Int32(super::Int32Rules), + #[prost(message, tag="4")] + Int64(super::Int64Rules), + #[prost(message, tag="5")] + Uint32(super::UInt32Rules), + #[prost(message, tag="6")] + Uint64(super::UInt64Rules), + #[prost(message, tag="7")] + Sint32(super::SInt32Rules), + #[prost(message, tag="8")] + Sint64(super::SInt64Rules), + #[prost(message, tag="9")] + Fixed32(super::Fixed32Rules), + #[prost(message, tag="10")] + Fixed64(super::Fixed64Rules), + #[prost(message, tag="11")] + Sfixed32(super::SFixed32Rules), + #[prost(message, tag="12")] + Sfixed64(super::SFixed64Rules), + #[prost(message, tag="13")] + Bool(super::BoolRules), + #[prost(message, tag="14")] + String(super::StringRules), + #[prost(message, tag="15")] + Bytes(super::BytesRules), + /// Complex Field Types + #[prost(message, tag="16")] + Enum(super::EnumRules), + #[prost(message, tag="18")] + Repeated(::prost::alloc::boxed::Box), + #[prost(message, tag="19")] + Map(::prost::alloc::boxed::Box), + /// Well-Known Field Types + #[prost(message, tag="20")] + Any(super::AnyRules), + #[prost(message, tag="21")] + Duration(super::DurationRules), + #[prost(message, tag="22")] + Timestamp(super::TimestampRules), + } +} +/// FloatRules describes the constraints applied to `float` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FloatRules { + /// Const specifies that this field must be exactly the specified value + #[prost(float, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(float, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(float, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(float, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(float, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(float, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(float, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// DoubleRules describes the constraints applied to `double` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DoubleRules { + /// Const specifies that this field must be exactly the specified value + #[prost(double, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(double, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(double, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(double, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(double, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(double, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(double, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// Int32Rules describes the constraints applied to `int32` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Int32Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(int32, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(int32, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(int32, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(int32, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(int32, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(int32, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(int32, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// Int64Rules describes the constraints applied to `int64` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Int64Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(int64, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(int64, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(int64, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(int64, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(int64, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(int64, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(int64, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// UInt32Rules describes the constraints applied to `uint32` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UInt32Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(uint32, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(uint32, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(uint32, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(uint32, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(uint32, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(uint32, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(uint32, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// UInt64Rules describes the constraints applied to `uint64` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UInt64Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(uint64, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(uint64, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(uint64, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(uint64, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(uint64, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(uint64, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(uint64, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// SInt32Rules describes the constraints applied to `sint32` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SInt32Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(sint32, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(sint32, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(sint32, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(sint32, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(sint32, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(sint32, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(sint32, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// SInt64Rules describes the constraints applied to `sint64` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SInt64Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(sint64, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(sint64, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(sint64, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(sint64, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(sint64, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(sint64, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(sint64, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// Fixed32Rules describes the constraints applied to `fixed32` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Fixed32Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(fixed32, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(fixed32, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(fixed32, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(fixed32, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(fixed32, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(fixed32, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(fixed32, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// Fixed64Rules describes the constraints applied to `fixed64` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Fixed64Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(fixed64, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(fixed64, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(fixed64, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(fixed64, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(fixed64, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(fixed64, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(fixed64, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// SFixed32Rules describes the constraints applied to `sfixed32` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SFixed32Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(sfixed32, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(sfixed32, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(sfixed32, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(sfixed32, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(sfixed32, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(sfixed32, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(sfixed32, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// SFixed64Rules describes the constraints applied to `sfixed64` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SFixed64Rules { + /// Const specifies that this field must be exactly the specified value + #[prost(sfixed64, optional, tag="1")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(sfixed64, optional, tag="2")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than or equal to the + /// specified value, inclusive + #[prost(sfixed64, optional, tag="3")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive. If the value of Gt is larger than a specified Lt or Lte, the + /// range is reversed. + #[prost(sfixed64, optional, tag="4")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than or equal to the + /// specified value, inclusive. If the value of Gte is larger than a + /// specified Lt or Lte, the range is reversed. + #[prost(sfixed64, optional, tag="5")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(sfixed64, repeated, packed="false", tag="6")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(sfixed64, repeated, packed="false", tag="7")] + pub not_in: ::prost::alloc::vec::Vec, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="8")] + pub ignore_empty: ::core::option::Option, +} +/// BoolRules describes the constraints applied to `bool` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct BoolRules { + /// Const specifies that this field must be exactly the specified value + #[prost(bool, optional, tag="1")] + pub r#const: ::core::option::Option, +} +/// StringRules describe the constraints applied to `string` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct StringRules { + /// Const specifies that this field must be exactly the specified value + #[prost(string, optional, tag="1")] + pub r#const: ::core::option::Option<::prost::alloc::string::String>, + /// Len specifies that this field must be the specified number of + /// characters (Unicode code points). Note that the number of + /// characters may differ from the number of bytes in the string. + #[prost(uint64, optional, tag="19")] + pub len: ::core::option::Option, + /// MinLen specifies that this field must be the specified number of + /// characters (Unicode code points) at a minimum. Note that the number of + /// characters may differ from the number of bytes in the string. + #[prost(uint64, optional, tag="2")] + pub min_len: ::core::option::Option, + /// MaxLen specifies that this field must be the specified number of + /// characters (Unicode code points) at a maximum. Note that the number of + /// characters may differ from the number of bytes in the string. + #[prost(uint64, optional, tag="3")] + pub max_len: ::core::option::Option, + /// LenBytes specifies that this field must be the specified number of bytes + #[prost(uint64, optional, tag="20")] + pub len_bytes: ::core::option::Option, + /// MinBytes specifies that this field must be the specified number of bytes + /// at a minimum + #[prost(uint64, optional, tag="4")] + pub min_bytes: ::core::option::Option, + /// MaxBytes specifies that this field must be the specified number of bytes + /// at a maximum + #[prost(uint64, optional, tag="5")] + pub max_bytes: ::core::option::Option, + /// Pattern specifies that this field must match against the specified + /// regular expression (RE2 syntax). The included expression should elide + /// any delimiters. + #[prost(string, optional, tag="6")] + pub pattern: ::core::option::Option<::prost::alloc::string::String>, + /// Prefix specifies that this field must have the specified substring at + /// the beginning of the string. + #[prost(string, optional, tag="7")] + pub prefix: ::core::option::Option<::prost::alloc::string::String>, + /// Suffix specifies that this field must have the specified substring at + /// the end of the string. + #[prost(string, optional, tag="8")] + pub suffix: ::core::option::Option<::prost::alloc::string::String>, + /// Contains specifies that this field must have the specified substring + /// anywhere in the string. + #[prost(string, optional, tag="9")] + pub contains: ::core::option::Option<::prost::alloc::string::String>, + /// NotContains specifies that this field cannot have the specified substring + /// anywhere in the string. + #[prost(string, optional, tag="23")] + pub not_contains: ::core::option::Option<::prost::alloc::string::String>, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(string, repeated, tag="10")] + pub r#in: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(string, repeated, tag="11")] + pub not_in: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// This applies to regexes HTTP_HEADER_NAME and HTTP_HEADER_VALUE to enable + /// strict header validation. + /// By default, this is true, and HTTP header validations are RFC-compliant. + /// Setting to false will enable a looser validations that only disallows + /// \r\n\0 characters, which can be used to bypass header matching rules. + #[prost(bool, optional, tag="25", default="true")] + pub strict: ::core::option::Option, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="26")] + pub ignore_empty: ::core::option::Option, + /// WellKnown rules provide advanced constraints against common string + /// patterns + #[prost(oneof="string_rules::WellKnown", tags="12, 13, 14, 15, 16, 17, 18, 21, 22, 24")] + pub well_known: ::core::option::Option, +} +/// Nested message and enum types in `StringRules`. +pub mod string_rules { + /// WellKnown rules provide advanced constraints against common string + /// patterns + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Oneof)] + pub enum WellKnown { + /// Email specifies that the field must be a valid email address as + /// defined by RFC 5322 + #[prost(bool, tag="12")] + Email(bool), + /// Hostname specifies that the field must be a valid hostname as + /// defined by RFC 1034. This constraint does not support + /// internationalized domain names (IDNs). + #[prost(bool, tag="13")] + Hostname(bool), + /// Ip specifies that the field must be a valid IP (v4 or v6) address. + /// Valid IPv6 addresses should not include surrounding square brackets. + #[prost(bool, tag="14")] + Ip(bool), + /// Ipv4 specifies that the field must be a valid IPv4 address. + #[prost(bool, tag="15")] + Ipv4(bool), + /// Ipv6 specifies that the field must be a valid IPv6 address. Valid + /// IPv6 addresses should not include surrounding square brackets. + #[prost(bool, tag="16")] + Ipv6(bool), + /// Uri specifies that the field must be a valid, absolute URI as defined + /// by RFC 3986 + #[prost(bool, tag="17")] + Uri(bool), + /// UriRef specifies that the field must be a valid URI as defined by RFC + /// 3986 and may be relative or absolute. + #[prost(bool, tag="18")] + UriRef(bool), + /// Address specifies that the field must be either a valid hostname as + /// defined by RFC 1034 (which does not support internationalized domain + /// names or IDNs), or it can be a valid IP (v4 or v6). + #[prost(bool, tag="21")] + Address(bool), + /// Uuid specifies that the field must be a valid UUID as defined by + /// RFC 4122 + #[prost(bool, tag="22")] + Uuid(bool), + /// WellKnownRegex specifies a common well known pattern defined as a regex. + #[prost(enumeration="super::KnownRegex", tag="24")] + WellKnownRegex(i32), + } +} +/// BytesRules describe the constraints applied to `bytes` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BytesRules { + /// Const specifies that this field must be exactly the specified value + #[prost(bytes="vec", optional, tag="1")] + pub r#const: ::core::option::Option<::prost::alloc::vec::Vec>, + /// Len specifies that this field must be the specified number of bytes + #[prost(uint64, optional, tag="13")] + pub len: ::core::option::Option, + /// MinLen specifies that this field must be the specified number of bytes + /// at a minimum + #[prost(uint64, optional, tag="2")] + pub min_len: ::core::option::Option, + /// MaxLen specifies that this field must be the specified number of bytes + /// at a maximum + #[prost(uint64, optional, tag="3")] + pub max_len: ::core::option::Option, + /// Pattern specifies that this field must match against the specified + /// regular expression (RE2 syntax). The included expression should elide + /// any delimiters. + #[prost(string, optional, tag="4")] + pub pattern: ::core::option::Option<::prost::alloc::string::String>, + /// Prefix specifies that this field must have the specified bytes at the + /// beginning of the string. + #[prost(bytes="vec", optional, tag="5")] + pub prefix: ::core::option::Option<::prost::alloc::vec::Vec>, + /// Suffix specifies that this field must have the specified bytes at the + /// end of the string. + #[prost(bytes="vec", optional, tag="6")] + pub suffix: ::core::option::Option<::prost::alloc::vec::Vec>, + /// Contains specifies that this field must have the specified bytes + /// anywhere in the string. + #[prost(bytes="vec", optional, tag="7")] + pub contains: ::core::option::Option<::prost::alloc::vec::Vec>, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(bytes="vec", repeated, tag="8")] + pub r#in: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(bytes="vec", repeated, tag="9")] + pub not_in: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="14")] + pub ignore_empty: ::core::option::Option, + /// WellKnown rules provide advanced constraints against common byte + /// patterns + #[prost(oneof="bytes_rules::WellKnown", tags="10, 11, 12")] + pub well_known: ::core::option::Option, +} +/// Nested message and enum types in `BytesRules`. +pub mod bytes_rules { + /// WellKnown rules provide advanced constraints against common byte + /// patterns + #[pyo3::pyclass(dict, get_all, set_all)] + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Oneof)] + pub enum WellKnown { + /// Ip specifies that the field must be a valid IP (v4 or v6) address in + /// byte format + #[prost(bool, tag="10")] + Ip(bool), + /// Ipv4 specifies that the field must be a valid IPv4 address in byte + /// format + #[prost(bool, tag="11")] + Ipv4(bool), + /// Ipv6 specifies that the field must be a valid IPv6 address in byte + /// format + #[prost(bool, tag="12")] + Ipv6(bool), + } +} +/// EnumRules describe the constraints applied to enum values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EnumRules { + /// Const specifies that this field must be exactly the specified value + #[prost(int32, optional, tag="1")] + pub r#const: ::core::option::Option, + /// DefinedOnly specifies that this field must be only one of the defined + /// values for this enum, failing on any undefined value. + #[prost(bool, optional, tag="2")] + pub defined_only: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(int32, repeated, packed="false", tag="3")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(int32, repeated, packed="false", tag="4")] + pub not_in: ::prost::alloc::vec::Vec, +} +/// MessageRules describe the constraints applied to embedded message values. +/// For message-type fields, validation is performed recursively. +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MessageRules { + /// Skip specifies that the validation rules of this field should not be + /// evaluated + #[prost(bool, optional, tag="1")] + pub skip: ::core::option::Option, + /// Required specifies that this field must be set + #[prost(bool, optional, tag="2")] + pub required: ::core::option::Option, +} +/// RepeatedRules describe the constraints applied to `repeated` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RepeatedRules { + /// MinItems specifies that this field must have the specified number of + /// items at a minimum + #[prost(uint64, optional, tag="1")] + pub min_items: ::core::option::Option, + /// MaxItems specifies that this field must have the specified number of + /// items at a maximum + #[prost(uint64, optional, tag="2")] + pub max_items: ::core::option::Option, + /// Unique specifies that all elements in this field must be unique. This + /// constraint is only applicable to scalar and enum types (messages are not + /// supported). + #[prost(bool, optional, tag="3")] + pub unique: ::core::option::Option, + /// Items specifies the constraints to be applied to each item in the field. + /// Repeated message fields will still execute validation against each item + /// unless skip is specified here. + #[prost(message, optional, boxed, tag="4")] + pub items: ::core::option::Option<::prost::alloc::boxed::Box>, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="5")] + pub ignore_empty: ::core::option::Option, +} +/// MapRules describe the constraints applied to `map` values +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MapRules { + /// MinPairs specifies that this field must have the specified number of + /// KVs at a minimum + #[prost(uint64, optional, tag="1")] + pub min_pairs: ::core::option::Option, + /// MaxPairs specifies that this field must have the specified number of + /// KVs at a maximum + #[prost(uint64, optional, tag="2")] + pub max_pairs: ::core::option::Option, + /// NoSparse specifies values in this field cannot be unset. This only + /// applies to map's with message value types. + #[prost(bool, optional, tag="3")] + pub no_sparse: ::core::option::Option, + /// Keys specifies the constraints to be applied to each key in the field. + #[prost(message, optional, boxed, tag="4")] + pub keys: ::core::option::Option<::prost::alloc::boxed::Box>, + /// Values specifies the constraints to be applied to the value of each key + /// in the field. Message values will still have their validations evaluated + /// unless skip is specified here. + #[prost(message, optional, boxed, tag="5")] + pub values: ::core::option::Option<::prost::alloc::boxed::Box>, + /// IgnoreEmpty specifies that the validation rules of this field should be + /// evaluated only if the field is not empty + #[prost(bool, optional, tag="6")] + pub ignore_empty: ::core::option::Option, +} +/// AnyRules describe constraints applied exclusively to the +/// `google.protobuf.Any` well-known type +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AnyRules { + /// Required specifies that this field must be set + #[prost(bool, optional, tag="1")] + pub required: ::core::option::Option, + /// In specifies that this field's `type_url` must be equal to one of the + /// specified values. + #[prost(string, repeated, tag="2")] + pub r#in: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// NotIn specifies that this field's `type_url` must not be equal to any of + /// the specified values. + #[prost(string, repeated, tag="3")] + pub not_in: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +/// DurationRules describe the constraints applied exclusively to the +/// `google.protobuf.Duration` well-known type +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DurationRules { + /// Required specifies that this field must be set + #[prost(bool, optional, tag="1")] + pub required: ::core::option::Option, + /// Const specifies that this field must be exactly the specified value + #[prost(message, optional, tag="2")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(message, optional, tag="3")] + pub lt: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// inclusive + #[prost(message, optional, tag="4")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive + #[prost(message, optional, tag="5")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than the specified value, + /// inclusive + #[prost(message, optional, tag="6")] + pub gte: ::core::option::Option, + /// In specifies that this field must be equal to one of the specified + /// values + #[prost(message, repeated, tag="7")] + pub r#in: ::prost::alloc::vec::Vec, + /// NotIn specifies that this field cannot be equal to one of the specified + /// values + #[prost(message, repeated, tag="8")] + pub not_in: ::prost::alloc::vec::Vec, +} +/// TimestampRules describe the constraints applied exclusively to the +/// `google.protobuf.Timestamp` well-known type +#[pyo3::pyclass(dict, get_all, set_all)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct TimestampRules { + /// Required specifies that this field must be set + #[prost(bool, optional, tag="1")] + pub required: ::core::option::Option, + /// Const specifies that this field must be exactly the specified value + #[prost(message, optional, tag="2")] + pub r#const: ::core::option::Option, + /// Lt specifies that this field must be less than the specified value, + /// exclusive + #[prost(message, optional, tag="3")] + pub lt: ::core::option::Option, + /// Lte specifies that this field must be less than the specified value, + /// inclusive + #[prost(message, optional, tag="4")] + pub lte: ::core::option::Option, + /// Gt specifies that this field must be greater than the specified value, + /// exclusive + #[prost(message, optional, tag="5")] + pub gt: ::core::option::Option, + /// Gte specifies that this field must be greater than the specified value, + /// inclusive + #[prost(message, optional, tag="6")] + pub gte: ::core::option::Option, + /// LtNow specifies that this must be less than the current time. LtNow + /// can only be used with the Within rule. + #[prost(bool, optional, tag="7")] + pub lt_now: ::core::option::Option, + /// GtNow specifies that this must be greater than the current time. GtNow + /// can only be used with the Within rule. + #[prost(bool, optional, tag="8")] + pub gt_now: ::core::option::Option, + /// Within specifies that this field must be within this duration of the + /// current time. This constraint can be used alone or with the LtNow and + /// GtNow rules. + #[prost(message, optional, tag="9")] + pub within: ::core::option::Option, +} +/// WellKnownRegex contain some well-known patterns. +#[pyo3::pyclass(dict, get_all, set_all)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum KnownRegex { + Unknown = 0, + /// HTTP header name as defined by RFC 7230. + HttpHeaderName = 1, + /// HTTP header value as defined by RFC 7230. + HttpHeaderValue = 2, +} +impl KnownRegex { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + KnownRegex::Unknown => "UNKNOWN", + KnownRegex::HttpHeaderName => "HTTP_HEADER_NAME", + KnownRegex::HttpHeaderValue => "HTTP_HEADER_VALUE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNKNOWN" => Some(Self::Unknown), + "HTTP_HEADER_NAME" => Some(Self::HttpHeaderName), + "HTTP_HEADER_VALUE" => Some(Self::HttpHeaderValue), + _ => None, + } + } +} +/// Encoded file descriptor set for the `validate` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xbb, 0xcf, 0x02, 0x0a, 0x17, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x08, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc8, 0x08, 0x0a, 0x0a, 0x46, + 0x69, 0x65, 0x6c, 0x64, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x30, 0x0a, 0x07, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x75, 0x6c, + 0x65, 0x73, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x2c, 0x0a, 0x05, 0x66, + 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x73, + 0x48, 0x00, 0x52, 0x05, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x2f, 0x0a, 0x06, 0x64, 0x6f, 0x75, + 0x62, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x65, 0x2e, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x73, + 0x48, 0x00, 0x52, 0x06, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x2c, 0x0a, 0x05, 0x69, 0x6e, + 0x74, 0x33, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x65, 0x2e, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, + 0x00, 0x52, 0x05, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x2c, 0x0a, 0x05, 0x69, 0x6e, 0x74, 0x36, + 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x65, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, + 0x05, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2f, 0x0a, 0x06, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, + 0x65, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, + 0x06, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x2f, 0x0a, 0x06, 0x75, 0x69, 0x6e, 0x74, 0x36, + 0x34, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x65, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, + 0x52, 0x06, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x2f, 0x0a, 0x06, 0x73, 0x69, 0x6e, 0x74, + 0x33, 0x32, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x2e, 0x53, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, + 0x00, 0x52, 0x06, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x2f, 0x0a, 0x06, 0x73, 0x69, 0x6e, + 0x74, 0x36, 0x34, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x65, 0x2e, 0x53, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, + 0x48, 0x00, 0x52, 0x06, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x32, 0x0a, 0x07, 0x66, 0x69, + 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x52, 0x75, + 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, 0x07, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x32, + 0x0a, 0x07, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x16, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x46, 0x69, 0x78, 0x65, 0x64, + 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, 0x07, 0x66, 0x69, 0x78, 0x65, 0x64, + 0x36, 0x34, 0x12, 0x35, 0x0a, 0x08, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x0b, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, + 0x53, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, + 0x08, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x35, 0x0a, 0x08, 0x73, 0x66, 0x69, + 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x53, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, 0x08, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, + 0x12, 0x29, 0x0a, 0x04, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, + 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x52, 0x75, + 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, 0x04, 0x62, 0x6f, 0x6f, 0x6c, 0x12, 0x2f, 0x0a, 0x06, 0x73, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, + 0x65, 0x73, 0x48, 0x00, 0x52, 0x06, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x2c, 0x0a, 0x05, + 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73, 0x52, 0x75, 0x6c, 0x65, + 0x73, 0x48, 0x00, 0x52, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x12, 0x29, 0x0a, 0x04, 0x65, 0x6e, + 0x75, 0x6d, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, + 0x04, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x35, 0x0a, 0x08, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, + 0x64, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x65, 0x2e, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x52, 0x75, 0x6c, 0x65, 0x73, + 0x48, 0x00, 0x52, 0x08, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x12, 0x26, 0x0a, 0x03, + 0x6d, 0x61, 0x70, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x65, 0x2e, 0x4d, 0x61, 0x70, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, + 0x03, 0x6d, 0x61, 0x70, 0x12, 0x26, 0x0a, 0x03, 0x61, 0x6e, 0x79, 0x18, 0x14, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x12, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x41, 0x6e, 0x79, + 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, 0x03, 0x61, 0x6e, 0x79, 0x12, 0x35, 0x0a, 0x08, + 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, + 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x48, 0x00, 0x52, 0x08, 0x64, 0x75, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x38, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x18, 0x16, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, + 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x75, 0x6c, 0x65, 0x73, + 0x48, 0x00, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x06, 0x0a, + 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0xb0, 0x01, 0x0a, 0x0a, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x02, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x74, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x02, 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x74, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x02, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, + 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x02, 0x52, 0x02, 0x67, 0x74, 0x12, 0x10, 0x0a, 0x03, + 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x02, 0x52, 0x03, 0x67, 0x74, 0x65, 0x12, 0x0e, + 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x02, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, + 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x02, 0x52, 0x05, + 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, + 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, + 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0xb1, 0x01, 0x0a, 0x0b, 0x44, 0x6f, 0x75, + 0x62, 0x6c, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, + 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, + 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x6c, 0x74, 0x65, + 0x12, 0x0e, 0x0a, 0x02, 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x02, 0x67, 0x74, + 0x12, 0x10, 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x67, + 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x01, 0x52, 0x02, + 0x69, 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, + 0x28, 0x01, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, + 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0xb0, 0x01, 0x0a, + 0x0a, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, + 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, + 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x6c, + 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, + 0x6c, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x02, 0x67, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x03, 0x67, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, + 0x05, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, + 0x07, 0x20, 0x03, 0x28, 0x05, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x21, 0x0a, 0x0c, + 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, + 0xb0, 0x01, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, + 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x63, + 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x02, 0x67, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x03, 0x67, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, + 0x20, 0x03, 0x28, 0x03, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, + 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x03, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, + 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, + 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, + 0x74, 0x79, 0x22, 0xb1, 0x01, 0x0a, 0x0b, 0x55, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x52, 0x75, 0x6c, + 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0d, 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x67, 0x74, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x02, 0x67, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x67, 0x74, + 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x67, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, + 0x69, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, 0x0a, 0x06, + 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x05, 0x6e, 0x6f, + 0x74, 0x49, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, + 0x70, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, + 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0xb1, 0x01, 0x0a, 0x0b, 0x55, 0x49, 0x6e, 0x74, 0x36, + 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, + 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, + 0x6c, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x0e, + 0x0a, 0x02, 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x02, 0x67, 0x74, 0x12, 0x10, + 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x67, 0x74, 0x65, + 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x04, 0x52, 0x02, 0x69, 0x6e, + 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x04, + 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, + 0x65, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, + 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0xb1, 0x01, 0x0a, 0x0b, 0x53, + 0x49, 0x6e, 0x74, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, + 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x11, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, + 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x11, 0x52, 0x02, 0x6c, 0x74, + 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x11, 0x52, 0x03, 0x6c, + 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x11, 0x52, 0x02, + 0x67, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x11, 0x52, + 0x03, 0x67, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x11, + 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x07, + 0x20, 0x03, 0x28, 0x11, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x69, + 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0xb1, + 0x01, 0x0a, 0x0b, 0x53, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, + 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x12, 0x52, 0x05, 0x63, + 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x12, + 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x12, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x12, 0x52, 0x02, 0x67, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x12, 0x52, 0x03, 0x67, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, + 0x20, 0x03, 0x28, 0x12, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, + 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x12, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, + 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, + 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, + 0x74, 0x79, 0x22, 0xb2, 0x01, 0x0a, 0x0c, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x52, 0x75, + 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x07, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x74, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x07, 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x74, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x07, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x67, + 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x07, 0x52, 0x02, 0x67, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x67, + 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x07, 0x52, 0x03, 0x67, 0x74, 0x65, 0x12, 0x0e, 0x0a, + 0x02, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x07, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, 0x0a, + 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x07, 0x52, 0x05, 0x6e, + 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, + 0x6d, 0x70, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, + 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0xb2, 0x01, 0x0a, 0x0c, 0x46, 0x69, 0x78, 0x65, + 0x64, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, + 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, + 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x06, 0x52, 0x03, 0x6c, 0x74, 0x65, + 0x12, 0x0e, 0x0a, 0x02, 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x06, 0x52, 0x02, 0x67, 0x74, + 0x12, 0x10, 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x06, 0x52, 0x03, 0x67, + 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x06, 0x52, 0x02, + 0x69, 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, + 0x28, 0x06, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, + 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0xb3, 0x01, 0x0a, + 0x0d, 0x53, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, + 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0f, 0x52, 0x05, 0x63, + 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0f, + 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0f, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0f, 0x52, 0x02, 0x67, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x0f, 0x52, 0x03, 0x67, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, + 0x20, 0x03, 0x28, 0x0f, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, + 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0f, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, + 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, + 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, + 0x74, 0x79, 0x22, 0xb3, 0x01, 0x0a, 0x0d, 0x53, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x10, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x74, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x10, 0x52, 0x02, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x74, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x10, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, + 0x67, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x10, 0x52, 0x02, 0x67, 0x74, 0x12, 0x10, 0x0a, 0x03, + 0x67, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x10, 0x52, 0x03, 0x67, 0x74, 0x65, 0x12, 0x0e, + 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x10, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, + 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x10, 0x52, 0x05, + 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, + 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, + 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x21, 0x0a, 0x09, 0x42, 0x6f, 0x6f, 0x6c, + 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x22, 0xd4, 0x05, 0x0a, 0x0b, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, + 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, + 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x65, 0x6e, 0x18, 0x13, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, + 0x6c, 0x65, 0x6e, 0x12, 0x17, 0x0a, 0x07, 0x6d, 0x69, 0x6e, 0x5f, 0x6c, 0x65, 0x6e, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x6d, 0x69, 0x6e, 0x4c, 0x65, 0x6e, 0x12, 0x17, 0x0a, 0x07, + 0x6d, 0x61, 0x78, 0x5f, 0x6c, 0x65, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x6d, + 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x65, 0x6e, 0x5f, 0x62, 0x79, 0x74, + 0x65, 0x73, 0x18, 0x14, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x6c, 0x65, 0x6e, 0x42, 0x79, 0x74, + 0x65, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x69, 0x6e, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x6d, 0x69, 0x6e, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, + 0x1b, 0x0a, 0x09, 0x6d, 0x61, 0x78, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x04, 0x52, 0x08, 0x6d, 0x61, 0x78, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x18, 0x0a, 0x07, + 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, + 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x16, + 0x0a, 0x06, 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x6e, 0x6f, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, + 0x6e, 0x73, 0x18, 0x17, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6e, 0x6f, 0x74, 0x43, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x73, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x0a, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, + 0x0b, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x16, 0x0a, 0x05, + 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x05, 0x65, + 0x6d, 0x61, 0x69, 0x6c, 0x12, 0x1c, 0x0a, 0x08, 0x68, 0x6f, 0x73, 0x74, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x08, 0x68, 0x6f, 0x73, 0x74, 0x6e, 0x61, + 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x02, 0x69, 0x70, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, + 0x52, 0x02, 0x69, 0x70, 0x12, 0x14, 0x0a, 0x04, 0x69, 0x70, 0x76, 0x34, 0x18, 0x0f, 0x20, 0x01, + 0x28, 0x08, 0x48, 0x00, 0x52, 0x04, 0x69, 0x70, 0x76, 0x34, 0x12, 0x14, 0x0a, 0x04, 0x69, 0x70, + 0x76, 0x36, 0x18, 0x10, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x04, 0x69, 0x70, 0x76, 0x36, + 0x12, 0x12, 0x0a, 0x03, 0x75, 0x72, 0x69, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, + 0x03, 0x75, 0x72, 0x69, 0x12, 0x19, 0x0a, 0x07, 0x75, 0x72, 0x69, 0x5f, 0x72, 0x65, 0x66, 0x18, + 0x12, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x06, 0x75, 0x72, 0x69, 0x52, 0x65, 0x66, 0x12, + 0x1a, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x15, 0x20, 0x01, 0x28, 0x08, + 0x48, 0x00, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x14, 0x0a, 0x04, 0x75, + 0x75, 0x69, 0x64, 0x18, 0x16, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x04, 0x75, 0x75, 0x69, + 0x64, 0x12, 0x40, 0x0a, 0x10, 0x77, 0x65, 0x6c, 0x6c, 0x5f, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x5f, + 0x72, 0x65, 0x67, 0x65, 0x78, 0x18, 0x18, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x67, 0x65, + 0x78, 0x48, 0x00, 0x52, 0x0e, 0x77, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x52, 0x65, + 0x67, 0x65, 0x78, 0x12, 0x1c, 0x0a, 0x06, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x18, 0x19, 0x20, + 0x01, 0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65, 0x52, 0x06, 0x73, 0x74, 0x72, 0x69, 0x63, + 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, 0x70, 0x74, + 0x79, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, + 0x6d, 0x70, 0x74, 0x79, 0x42, 0x0c, 0x0a, 0x0a, 0x77, 0x65, 0x6c, 0x6c, 0x5f, 0x6b, 0x6e, 0x6f, + 0x77, 0x6e, 0x22, 0xe2, 0x02, 0x0a, 0x0a, 0x42, 0x79, 0x74, 0x65, 0x73, 0x52, 0x75, 0x6c, 0x65, + 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x65, 0x6e, 0x18, 0x0d, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x6c, 0x65, 0x6e, 0x12, 0x17, 0x0a, 0x07, 0x6d, 0x69, 0x6e, + 0x5f, 0x6c, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x6d, 0x69, 0x6e, 0x4c, + 0x65, 0x6e, 0x12, 0x17, 0x0a, 0x07, 0x6d, 0x61, 0x78, 0x5f, 0x6c, 0x65, 0x6e, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x04, 0x52, 0x06, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x70, + 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x61, + 0x74, 0x74, 0x65, 0x72, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x16, 0x0a, + 0x06, 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x73, + 0x75, 0x66, 0x66, 0x69, 0x78, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x73, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x02, 0x69, + 0x6e, 0x12, 0x15, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x09, 0x20, 0x03, 0x28, + 0x0c, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x12, 0x10, 0x0a, 0x02, 0x69, 0x70, 0x18, 0x0a, + 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x02, 0x69, 0x70, 0x12, 0x14, 0x0a, 0x04, 0x69, 0x70, + 0x76, 0x34, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x04, 0x69, 0x70, 0x76, 0x34, + 0x12, 0x14, 0x0a, 0x04, 0x69, 0x70, 0x76, 0x36, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, + 0x52, 0x04, 0x69, 0x70, 0x76, 0x36, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, + 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, + 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x42, 0x0c, 0x0a, 0x0a, 0x77, 0x65, 0x6c, + 0x6c, 0x5f, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x22, 0x6b, 0x0a, 0x09, 0x45, 0x6e, 0x75, 0x6d, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x65, 0x64, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x0b, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x4f, 0x6e, 0x6c, 0x79, 0x12, 0x0e, 0x0a, + 0x02, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x03, 0x28, 0x05, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, 0x0a, + 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x04, 0x20, 0x03, 0x28, 0x05, 0x52, 0x05, 0x6e, + 0x6f, 0x74, 0x49, 0x6e, 0x22, 0x3e, 0x0a, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x6b, 0x69, 0x70, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x04, 0x73, 0x6b, 0x69, 0x70, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, + 0x69, 0x72, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x71, 0x75, + 0x69, 0x72, 0x65, 0x64, 0x22, 0xb0, 0x01, 0x0a, 0x0d, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, + 0x64, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x69, 0x6e, 0x5f, 0x69, 0x74, + 0x65, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x6d, 0x69, 0x6e, 0x49, 0x74, + 0x65, 0x6d, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x61, 0x78, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x73, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x6d, 0x61, 0x78, 0x49, 0x74, 0x65, 0x6d, 0x73, + 0x12, 0x16, 0x0a, 0x06, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x06, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x12, 0x2a, 0x0a, 0x05, 0x69, 0x74, 0x65, 0x6d, + 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x65, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x05, 0x69, + 0x74, 0x65, 0x6d, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, + 0x6d, 0x70, 0x74, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, + 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0xdc, 0x01, 0x0a, 0x08, 0x4d, 0x61, 0x70, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x69, 0x6e, 0x5f, 0x70, 0x61, 0x69, 0x72, + 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x6d, 0x69, 0x6e, 0x50, 0x61, 0x69, 0x72, + 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x61, 0x78, 0x5f, 0x70, 0x61, 0x69, 0x72, 0x73, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x6d, 0x61, 0x78, 0x50, 0x61, 0x69, 0x72, 0x73, 0x12, 0x1b, + 0x0a, 0x09, 0x6e, 0x6f, 0x5f, 0x73, 0x70, 0x61, 0x72, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x08, 0x6e, 0x6f, 0x53, 0x70, 0x61, 0x72, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x6b, + 0x65, 0x79, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x65, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, + 0x04, 0x6b, 0x65, 0x79, 0x73, 0x12, 0x2c, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, + 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x06, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x6d, + 0x70, 0x74, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, + 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x4d, 0x0a, 0x08, 0x41, 0x6e, 0x79, 0x52, 0x75, 0x6c, + 0x65, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x12, 0x0e, + 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x02, 0x69, 0x6e, 0x12, 0x15, + 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, + 0x6e, 0x6f, 0x74, 0x49, 0x6e, 0x22, 0xe9, 0x02, 0x0a, 0x0d, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, + 0x72, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, + 0x72, 0x65, 0x64, 0x12, 0x2f, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x05, 0x63, + 0x6f, 0x6e, 0x73, 0x74, 0x12, 0x29, 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x02, 0x6c, 0x74, 0x12, + 0x2b, 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, + 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x02, + 0x67, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x02, 0x67, 0x74, 0x12, 0x2b, 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x03, 0x67, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x02, 0x69, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x02, 0x69, 0x6e, 0x12, + 0x30, 0x0a, 0x06, 0x6e, 0x6f, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x05, 0x6e, 0x6f, 0x74, 0x49, + 0x6e, 0x22, 0xf3, 0x02, 0x0a, 0x0e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, + 0x12, 0x30, 0x0a, 0x05, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x05, 0x63, 0x6f, 0x6e, + 0x73, 0x74, 0x12, 0x2a, 0x0a, 0x02, 0x6c, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x02, 0x6c, 0x74, 0x12, 0x2c, + 0x0a, 0x03, 0x6c, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x03, 0x6c, 0x74, 0x65, 0x12, 0x2a, 0x0a, 0x02, + 0x67, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x52, 0x02, 0x67, 0x74, 0x12, 0x2c, 0x0a, 0x03, 0x67, 0x74, 0x65, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x52, 0x03, 0x67, 0x74, 0x65, 0x12, 0x15, 0x0a, 0x06, 0x6c, 0x74, 0x5f, 0x6e, 0x6f, 0x77, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x6c, 0x74, 0x4e, 0x6f, 0x77, 0x12, 0x15, 0x0a, + 0x06, 0x67, 0x74, 0x5f, 0x6e, 0x6f, 0x77, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x67, + 0x74, 0x4e, 0x6f, 0x77, 0x12, 0x31, 0x0a, 0x06, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x18, 0x09, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x06, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x2a, 0x46, 0x0a, 0x0a, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, + 0x52, 0x65, 0x67, 0x65, 0x78, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, + 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, 0x48, 0x54, 0x54, 0x50, 0x5f, 0x48, 0x45, 0x41, 0x44, 0x45, + 0x52, 0x5f, 0x4e, 0x41, 0x4d, 0x45, 0x10, 0x01, 0x12, 0x15, 0x0a, 0x11, 0x48, 0x54, 0x54, 0x50, + 0x5f, 0x48, 0x45, 0x41, 0x44, 0x45, 0x52, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x10, 0x02, 0x3a, + 0x3c, 0x0a, 0x08, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x1f, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xaf, 0x08, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x08, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x3a, 0x3a, 0x0a, + 0x07, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x64, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xb0, 0x08, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x07, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x64, 0x3a, 0x3a, 0x0a, 0x08, 0x72, 0x65, 0x71, + 0x75, 0x69, 0x72, 0x65, 0x64, 0x12, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x4f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xaf, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x71, + 0x75, 0x69, 0x72, 0x65, 0x64, 0x3a, 0x4a, 0x0a, 0x05, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x1d, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xaf, 0x08, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, + 0x46, 0x69, 0x65, 0x6c, 0x64, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x05, 0x72, 0x75, 0x6c, 0x65, + 0x73, 0x42, 0x91, 0x01, 0x0a, 0x0c, 0x63, 0x6f, 0x6d, 0x2e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x65, 0x42, 0x0d, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x74, + 0x6f, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, + 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0xa2, 0x02, 0x03, 0x56, 0x58, 0x58, 0xaa, 0x02, 0x08, + 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0xca, 0x02, 0x08, 0x56, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0xe2, 0x02, 0x14, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x5c, 0x47, + 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x08, 0x56, 0x61, 0x6c, + 0x69, 0x64, 0x61, 0x74, 0x65, 0x4a, 0xc6, 0x9d, 0x02, 0x0a, 0x07, 0x12, 0x05, 0x00, 0x00, 0xdd, + 0x06, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x08, 0x0a, 0x01, + 0x02, 0x12, 0x03, 0x01, 0x00, 0x11, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x03, 0x00, 0x49, + 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x03, 0x00, 0x49, 0x0a, 0x09, 0x0a, 0x02, 0x03, + 0x00, 0x12, 0x03, 0x06, 0x00, 0x2a, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x07, 0x00, + 0x28, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, 0x12, 0x03, 0x08, 0x00, 0x29, 0x0a, 0x3a, 0x0a, 0x01, + 0x07, 0x12, 0x04, 0x0b, 0x00, 0x11, 0x01, 0x1a, 0x2f, 0x20, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, + 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x20, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x0a, 0x0a, 0x94, 0x01, 0x0a, 0x02, 0x07, 0x00, 0x12, + 0x03, 0x0e, 0x04, 0x22, 0x1a, 0x88, 0x01, 0x20, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, + 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x6e, 0x79, 0x0a, + 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, + 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x69, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, + 0x72, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x07, 0x00, 0x02, 0x12, 0x03, 0x0b, 0x07, 0x25, 0x0a, 0x0a, 0x0a, 0x03, 0x07, + 0x00, 0x04, 0x12, 0x03, 0x0e, 0x04, 0x0c, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x00, 0x05, 0x12, 0x03, + 0x0e, 0x0d, 0x11, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x00, 0x01, 0x12, 0x03, 0x0e, 0x12, 0x1a, 0x0a, + 0x0a, 0x0a, 0x03, 0x07, 0x00, 0x03, 0x12, 0x03, 0x0e, 0x1d, 0x21, 0x0a, 0x4c, 0x0a, 0x02, 0x07, + 0x01, 0x12, 0x03, 0x10, 0x04, 0x21, 0x1a, 0x41, 0x20, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x20, + 0x73, 0x6b, 0x69, 0x70, 0x73, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x6f, 0x66, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6d, + 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x01, 0x02, + 0x12, 0x03, 0x0b, 0x07, 0x25, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x01, 0x04, 0x12, 0x03, 0x10, 0x04, + 0x0c, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x01, 0x05, 0x12, 0x03, 0x10, 0x0d, 0x11, 0x0a, 0x0a, 0x0a, + 0x03, 0x07, 0x01, 0x01, 0x12, 0x03, 0x10, 0x12, 0x19, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x01, 0x03, + 0x12, 0x03, 0x10, 0x1c, 0x20, 0x0a, 0x38, 0x0a, 0x01, 0x07, 0x12, 0x04, 0x14, 0x00, 0x18, 0x01, + 0x1a, 0x2d, 0x20, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, + 0x6c, 0x65, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x20, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x0a, 0x0a, + 0x88, 0x01, 0x0a, 0x02, 0x07, 0x02, 0x12, 0x03, 0x17, 0x04, 0x22, 0x1a, 0x7d, 0x20, 0x52, 0x65, + 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x65, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x6f, 0x6e, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x20, 0x69, 0x73, 0x20, + 0x73, 0x65, 0x74, 0x3b, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x66, 0x61, 0x69, 0x6c, 0x73, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x6e, 0x65, 0x6f, 0x66, + 0x20, 0x61, 0x72, 0x65, 0x20, 0x73, 0x65, 0x74, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x02, + 0x02, 0x12, 0x03, 0x14, 0x07, 0x23, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x02, 0x04, 0x12, 0x03, 0x17, + 0x04, 0x0c, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x02, 0x05, 0x12, 0x03, 0x17, 0x0d, 0x11, 0x0a, 0x0a, + 0x0a, 0x03, 0x07, 0x02, 0x01, 0x12, 0x03, 0x17, 0x12, 0x1a, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x02, + 0x03, 0x12, 0x03, 0x17, 0x1d, 0x21, 0x0a, 0x38, 0x0a, 0x01, 0x07, 0x12, 0x04, 0x1b, 0x00, 0x1f, + 0x01, 0x1a, 0x2d, 0x20, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, + 0x75, 0x6c, 0x65, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x0a, + 0x0a, 0x82, 0x01, 0x0a, 0x02, 0x07, 0x03, 0x12, 0x03, 0x1e, 0x04, 0x25, 0x1a, 0x77, 0x20, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x79, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x74, 0x6f, 0x20, + 0x62, 0x65, 0x20, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2e, 0x20, 0x42, 0x79, 0x20, 0x64, + 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x2c, 0x0a, 0x20, 0x6e, 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, + 0x6d, 0x65, 0x64, 0x20, 0x61, 0x67, 0x61, 0x69, 0x6e, 0x73, 0x74, 0x20, 0x61, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x03, 0x02, 0x12, 0x03, 0x1b, 0x07, + 0x23, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x03, 0x04, 0x12, 0x03, 0x1e, 0x04, 0x0c, 0x0a, 0x0a, 0x0a, + 0x03, 0x07, 0x03, 0x06, 0x12, 0x03, 0x1e, 0x0d, 0x17, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x03, 0x01, + 0x12, 0x03, 0x1e, 0x18, 0x1d, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x03, 0x03, 0x12, 0x03, 0x1e, 0x20, + 0x24, 0x0a, 0x9e, 0x01, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x23, 0x00, 0x41, 0x01, 0x1a, 0x91, + 0x01, 0x20, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x65, 0x6e, 0x63, + 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x75, + 0x6c, 0x65, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x74, 0x79, 0x70, + 0x65, 0x20, 0x6f, 0x66, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2e, 0x20, 0x44, 0x65, 0x70, 0x65, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74, + 0x20, 0x73, 0x65, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x75, + 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x20, 0x70, 0x72, + 0x6f, 0x70, 0x65, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x23, 0x08, 0x12, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x24, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x00, 0x04, 0x12, 0x03, 0x24, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x24, 0x0d, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x24, 0x1a, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x24, 0x24, 0x26, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x00, 0x08, 0x00, 0x12, 0x04, 0x25, 0x04, 0x40, + 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x08, 0x00, 0x01, 0x12, 0x03, 0x25, 0x0a, 0x0e, 0x0a, + 0x21, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x27, 0x08, 0x23, 0x1a, 0x14, 0x20, 0x53, + 0x63, 0x61, 0x6c, 0x61, 0x72, 0x20, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x54, 0x79, 0x70, 0x65, + 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x27, 0x08, 0x12, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x27, 0x16, 0x1b, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x27, 0x21, 0x22, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x28, 0x08, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x02, 0x06, 0x12, 0x03, 0x28, 0x08, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x28, 0x16, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, + 0x28, 0x21, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x29, 0x08, 0x23, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x06, 0x12, 0x03, 0x29, 0x08, 0x12, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x29, 0x16, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x29, 0x21, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x04, 0x12, 0x03, 0x2a, 0x08, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x06, + 0x12, 0x03, 0x2a, 0x08, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, + 0x2a, 0x16, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, 0x2a, 0x21, + 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x2b, 0x08, 0x23, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x06, 0x12, 0x03, 0x2b, 0x08, 0x13, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x2b, 0x16, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x05, 0x03, 0x12, 0x03, 0x2b, 0x21, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x06, + 0x12, 0x03, 0x2c, 0x08, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x06, 0x12, 0x03, + 0x2c, 0x08, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x2c, 0x16, + 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x03, 0x12, 0x03, 0x2c, 0x21, 0x22, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x07, 0x12, 0x03, 0x2d, 0x08, 0x23, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x07, 0x06, 0x12, 0x03, 0x2d, 0x08, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x07, 0x01, 0x12, 0x03, 0x2d, 0x16, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x07, + 0x03, 0x12, 0x03, 0x2d, 0x21, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x08, 0x12, 0x03, + 0x2e, 0x08, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x06, 0x12, 0x03, 0x2e, 0x08, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x01, 0x12, 0x03, 0x2e, 0x16, 0x1c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x03, 0x12, 0x03, 0x2e, 0x21, 0x22, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x00, 0x02, 0x09, 0x12, 0x03, 0x2f, 0x08, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x09, 0x06, 0x12, 0x03, 0x2f, 0x08, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x09, + 0x01, 0x12, 0x03, 0x2f, 0x16, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x09, 0x03, 0x12, + 0x03, 0x2f, 0x21, 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x0a, 0x12, 0x03, 0x30, 0x08, + 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0a, 0x06, 0x12, 0x03, 0x30, 0x08, 0x14, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0a, 0x01, 0x12, 0x03, 0x30, 0x16, 0x1d, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x0a, 0x03, 0x12, 0x03, 0x30, 0x21, 0x23, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x0b, 0x12, 0x03, 0x31, 0x08, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0b, + 0x06, 0x12, 0x03, 0x31, 0x08, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0b, 0x01, 0x12, + 0x03, 0x31, 0x16, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0b, 0x03, 0x12, 0x03, 0x31, + 0x21, 0x23, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x0c, 0x12, 0x03, 0x32, 0x08, 0x24, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0c, 0x06, 0x12, 0x03, 0x32, 0x08, 0x15, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x0c, 0x01, 0x12, 0x03, 0x32, 0x16, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x0c, 0x03, 0x12, 0x03, 0x32, 0x21, 0x23, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x0d, 0x12, 0x03, 0x33, 0x08, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0d, 0x06, 0x12, + 0x03, 0x33, 0x08, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0d, 0x01, 0x12, 0x03, 0x33, + 0x16, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0d, 0x03, 0x12, 0x03, 0x33, 0x21, 0x23, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x0e, 0x12, 0x03, 0x34, 0x08, 0x24, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x0e, 0x06, 0x12, 0x03, 0x34, 0x08, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x0e, 0x01, 0x12, 0x03, 0x34, 0x16, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x0e, 0x03, 0x12, 0x03, 0x34, 0x21, 0x23, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x0f, 0x12, + 0x03, 0x35, 0x08, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0f, 0x06, 0x12, 0x03, 0x35, + 0x08, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0f, 0x01, 0x12, 0x03, 0x35, 0x16, 0x1b, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0f, 0x03, 0x12, 0x03, 0x35, 0x21, 0x23, 0x0a, 0x22, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x10, 0x12, 0x03, 0x38, 0x08, 0x24, 0x1a, 0x15, 0x20, 0x43, 0x6f, + 0x6d, 0x70, 0x6c, 0x65, 0x78, 0x20, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x54, 0x79, 0x70, 0x65, + 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x10, 0x06, 0x12, 0x03, 0x38, 0x08, 0x11, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x10, 0x01, 0x12, 0x03, 0x38, 0x16, 0x1a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x10, 0x03, 0x12, 0x03, 0x38, 0x21, 0x23, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x11, 0x12, 0x03, 0x39, 0x08, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x11, 0x06, 0x12, 0x03, 0x39, 0x08, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x11, 0x01, + 0x12, 0x03, 0x39, 0x16, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x11, 0x03, 0x12, 0x03, + 0x39, 0x21, 0x23, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x12, 0x12, 0x03, 0x3a, 0x08, 0x24, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x12, 0x06, 0x12, 0x03, 0x3a, 0x08, 0x10, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x12, 0x01, 0x12, 0x03, 0x3a, 0x16, 0x19, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x12, 0x03, 0x12, 0x03, 0x3a, 0x21, 0x23, 0x0a, 0x25, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x13, 0x12, 0x03, 0x3d, 0x08, 0x26, 0x1a, 0x18, 0x20, 0x57, 0x65, 0x6c, 0x6c, 0x2d, 0x4b, + 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x54, 0x79, 0x70, 0x65, 0x73, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x13, 0x06, 0x12, 0x03, 0x3d, 0x08, 0x10, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x13, 0x01, 0x12, 0x03, 0x3d, 0x17, 0x1a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x13, 0x03, 0x12, 0x03, 0x3d, 0x23, 0x25, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x14, 0x12, 0x03, 0x3e, 0x08, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x14, + 0x06, 0x12, 0x03, 0x3e, 0x08, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x14, 0x01, 0x12, + 0x03, 0x3e, 0x17, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x14, 0x03, 0x12, 0x03, 0x3e, + 0x23, 0x25, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x15, 0x12, 0x03, 0x3f, 0x08, 0x26, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x15, 0x06, 0x12, 0x03, 0x3f, 0x08, 0x16, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x15, 0x01, 0x12, 0x03, 0x3f, 0x17, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x15, 0x03, 0x12, 0x03, 0x3f, 0x23, 0x25, 0x0a, 0x4c, 0x0a, 0x02, 0x04, 0x01, 0x12, + 0x04, 0x44, 0x00, 0x65, 0x01, 0x1a, 0x40, 0x20, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x52, 0x75, 0x6c, + 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, + 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x60, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, + 0x44, 0x08, 0x12, 0x0a, 0x52, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x46, 0x04, 0x1d, + 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, + 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x04, + 0x12, 0x03, 0x46, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x46, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x46, 0x13, + 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x46, 0x1b, 0x1c, 0x0a, + 0x5d, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x4a, 0x04, 0x1a, 0x1a, 0x50, 0x20, 0x4c, + 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x04, 0x12, 0x03, 0x4a, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, 0x4a, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x4a, 0x13, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x4a, 0x18, 0x19, 0x0a, 0x6a, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x02, 0x12, 0x03, + 0x4e, 0x04, 0x1b, 0x1a, 0x5d, 0x20, 0x4c, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, + 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, + 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x04, 0x12, 0x03, 0x4e, 0x04, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x05, 0x12, 0x03, 0x4e, 0x0d, 0x12, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x4e, 0x13, 0x16, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x4e, 0x19, 0x1a, 0x0a, 0xb3, 0x01, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x03, 0x12, 0x03, 0x53, 0x04, 0x1a, 0x1a, 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, + 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, + 0x74, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, + 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, 0x6e, + 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x04, 0x12, 0x03, 0x53, 0x04, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x05, 0x12, 0x03, 0x53, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x03, 0x01, 0x12, 0x03, 0x53, 0x13, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x03, 0x03, 0x12, 0x03, 0x53, 0x18, 0x19, 0x0a, 0xc1, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, + 0x04, 0x12, 0x03, 0x58, 0x04, 0x1b, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, + 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, + 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x0a, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, + 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, + 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x04, 0x04, 0x12, 0x03, 0x58, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x04, 0x05, 0x12, 0x03, 0x58, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, + 0x01, 0x12, 0x03, 0x58, 0x13, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x03, 0x12, + 0x03, 0x58, 0x19, 0x1a, 0x0a, 0x59, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x05, 0x12, 0x03, 0x5c, 0x04, + 0x1a, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, + 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x04, 0x12, 0x03, 0x5c, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x05, 0x05, 0x12, 0x03, 0x5c, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x05, 0x01, 0x12, 0x03, 0x5c, 0x13, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x05, 0x03, 0x12, 0x03, 0x5c, 0x18, 0x19, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x06, 0x12, + 0x03, 0x60, 0x04, 0x1e, 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, + 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x04, + 0x12, 0x03, 0x60, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x05, 0x12, 0x03, + 0x60, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x01, 0x12, 0x03, 0x60, 0x13, + 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x03, 0x12, 0x03, 0x60, 0x1c, 0x1d, 0x0a, + 0x80, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x07, 0x12, 0x03, 0x64, 0x04, 0x23, 0x1a, 0x73, 0x20, + 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, + 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, + 0x79, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x04, 0x12, 0x03, 0x64, 0x04, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x05, 0x12, 0x03, 0x64, 0x0d, 0x11, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x01, 0x12, 0x03, 0x64, 0x12, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x07, 0x03, 0x12, 0x03, 0x64, 0x21, 0x22, 0x0a, 0x4f, 0x0a, 0x02, 0x04, 0x02, + 0x12, 0x05, 0x68, 0x00, 0x89, 0x01, 0x01, 0x1a, 0x42, 0x20, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, + 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, + 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x64, 0x6f, 0x75, 0x62, + 0x6c, 0x65, 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x02, 0x01, 0x12, 0x03, 0x68, 0x08, 0x13, 0x0a, 0x52, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, + 0x03, 0x6a, 0x04, 0x1e, 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, + 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x00, 0x04, 0x12, 0x03, 0x6a, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x6a, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x6a, 0x14, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x6a, 0x1c, 0x1d, 0x0a, 0x5d, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x6e, 0x04, 0x1b, + 0x1a, 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, + 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x04, 0x12, 0x03, 0x6e, 0x04, 0x0c, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x05, 0x12, 0x03, 0x6e, 0x0d, 0x13, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x6e, 0x14, 0x16, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x6e, 0x19, 0x1a, 0x0a, 0x6a, 0x0a, 0x04, 0x04, 0x02, + 0x02, 0x02, 0x12, 0x03, 0x72, 0x04, 0x1c, 0x1a, 0x5d, 0x20, 0x4c, 0x74, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, + 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, + 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x04, 0x12, + 0x03, 0x72, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x05, 0x12, 0x03, 0x72, + 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, 0x72, 0x14, 0x17, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x03, 0x12, 0x03, 0x72, 0x1a, 0x1b, 0x0a, 0xb3, + 0x01, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, 0x77, 0x04, 0x1b, 0x1a, 0xa5, 0x01, 0x20, + 0x47, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, + 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, + 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x47, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, + 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, + 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x04, 0x12, 0x03, 0x77, + 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x05, 0x12, 0x03, 0x77, 0x0d, 0x13, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x01, 0x12, 0x03, 0x77, 0x14, 0x16, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x03, 0x12, 0x03, 0x77, 0x19, 0x1a, 0x0a, 0xc1, 0x01, 0x0a, + 0x04, 0x04, 0x02, 0x02, 0x04, 0x12, 0x03, 0x7c, 0x04, 0x1c, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, + 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, + 0x65, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x61, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, + 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, + 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x04, 0x04, 0x12, 0x03, 0x7c, 0x04, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x04, 0x05, 0x12, 0x03, 0x7c, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x04, 0x01, 0x12, 0x03, 0x7c, 0x14, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x04, 0x03, 0x12, 0x03, 0x7c, 0x1a, 0x1b, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x05, + 0x12, 0x04, 0x80, 0x01, 0x04, 0x1b, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, + 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x05, 0x04, 0x12, 0x04, 0x80, + 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x05, 0x05, 0x12, 0x04, 0x80, 0x01, + 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x05, 0x01, 0x12, 0x04, 0x80, 0x01, 0x14, + 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x05, 0x03, 0x12, 0x04, 0x80, 0x01, 0x19, 0x1a, + 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x06, 0x12, 0x04, 0x84, 0x01, 0x04, 0x1f, 0x1a, 0x51, + 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, + 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x06, 0x04, 0x12, 0x04, 0x84, 0x01, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x06, 0x05, 0x12, 0x04, 0x84, 0x01, 0x0d, 0x13, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x06, 0x01, 0x12, 0x04, 0x84, 0x01, 0x14, 0x1a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x06, 0x03, 0x12, 0x04, 0x84, 0x01, 0x1d, 0x1e, 0x0a, 0x81, 0x01, + 0x0a, 0x04, 0x04, 0x02, 0x02, 0x07, 0x12, 0x04, 0x88, 0x01, 0x04, 0x23, 0x1a, 0x73, 0x20, 0x49, + 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x07, 0x04, 0x12, 0x04, 0x88, 0x01, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x07, 0x05, 0x12, 0x04, 0x88, 0x01, 0x0d, 0x11, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x07, 0x01, 0x12, 0x04, 0x88, 0x01, 0x12, 0x1e, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x07, 0x03, 0x12, 0x04, 0x88, 0x01, 0x21, 0x22, 0x0a, 0x4e, 0x0a, + 0x02, 0x04, 0x03, 0x12, 0x06, 0x8c, 0x01, 0x00, 0xad, 0x01, 0x01, 0x1a, 0x40, 0x20, 0x49, 0x6e, + 0x74, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, + 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x69, + 0x6e, 0x74, 0x33, 0x32, 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, + 0x03, 0x04, 0x03, 0x01, 0x12, 0x04, 0x8c, 0x01, 0x08, 0x12, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x03, + 0x02, 0x00, 0x12, 0x04, 0x8e, 0x01, 0x04, 0x1d, 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x04, 0x12, 0x04, 0x8e, 0x01, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x05, 0x12, 0x04, 0x8e, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x04, 0x8e, 0x01, 0x13, 0x18, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x04, 0x8e, 0x01, 0x1b, 0x1c, 0x0a, 0x5e, 0x0a, 0x04, 0x04, + 0x03, 0x02, 0x01, 0x12, 0x04, 0x92, 0x01, 0x04, 0x1a, 0x1a, 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, + 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, + 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x01, 0x04, 0x12, 0x04, 0x92, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x01, 0x05, 0x12, 0x04, 0x92, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x01, 0x01, 0x12, 0x04, 0x92, 0x01, 0x13, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, + 0x03, 0x12, 0x04, 0x92, 0x01, 0x18, 0x19, 0x0a, 0x6b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x02, 0x12, + 0x04, 0x96, 0x01, 0x04, 0x1b, 0x1a, 0x5d, 0x20, 0x4c, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, + 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, + 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, + 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x04, 0x12, 0x04, 0x96, + 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x05, 0x12, 0x04, 0x96, 0x01, + 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x01, 0x12, 0x04, 0x96, 0x01, 0x13, + 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x03, 0x12, 0x04, 0x96, 0x01, 0x19, 0x1a, + 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x03, 0x12, 0x04, 0x9b, 0x01, 0x04, 0x1a, 0x1a, + 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, + 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, + 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, + 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, + 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x04, + 0x12, 0x04, 0x9b, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x05, 0x12, + 0x04, 0x9b, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x01, 0x12, 0x04, + 0x9b, 0x01, 0x13, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x03, 0x12, 0x04, 0x9b, + 0x01, 0x18, 0x19, 0x0a, 0xc2, 0x01, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x04, 0x12, 0x04, 0xa0, 0x01, + 0x04, 0x1b, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, + 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, + 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, + 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, + 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, + 0x04, 0x12, 0x04, 0xa0, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x05, + 0x12, 0x04, 0xa0, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x01, 0x12, + 0x04, 0xa0, 0x01, 0x13, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x03, 0x12, 0x04, + 0xa0, 0x01, 0x19, 0x1a, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x05, 0x12, 0x04, 0xa4, 0x01, + 0x04, 0x1a, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, + 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x04, 0x12, 0x04, 0xa4, 0x01, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x05, 0x12, 0x04, 0xa4, 0x01, 0x0d, 0x12, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x01, 0x12, 0x04, 0xa4, 0x01, 0x13, 0x15, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x05, 0x03, 0x12, 0x04, 0xa4, 0x01, 0x18, 0x19, 0x0a, 0x5f, 0x0a, 0x04, + 0x04, 0x03, 0x02, 0x06, 0x12, 0x04, 0xa8, 0x01, 0x04, 0x1e, 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, + 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, + 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, + 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x06, 0x04, 0x12, 0x04, 0xa8, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x06, 0x05, 0x12, 0x04, 0xa8, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x06, 0x01, 0x12, 0x04, 0xa8, 0x01, 0x13, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x06, 0x03, 0x12, 0x04, 0xa8, 0x01, 0x1c, 0x1d, 0x0a, 0x81, 0x01, 0x0a, 0x04, 0x04, 0x03, + 0x02, 0x07, 0x12, 0x04, 0xac, 0x01, 0x04, 0x23, 0x1a, 0x73, 0x20, 0x49, 0x67, 0x6e, 0x6f, 0x72, + 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, + 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, + 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x07, 0x04, 0x12, 0x04, 0xac, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x07, 0x05, 0x12, 0x04, 0xac, 0x01, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x07, 0x01, 0x12, 0x04, 0xac, 0x01, 0x12, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x07, 0x03, 0x12, 0x04, 0xac, 0x01, 0x21, 0x22, 0x0a, 0x4e, 0x0a, 0x02, 0x04, 0x04, 0x12, + 0x06, 0xb0, 0x01, 0x00, 0xd1, 0x01, 0x01, 0x1a, 0x40, 0x20, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, + 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x69, 0x6e, 0x74, 0x36, 0x34, + 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x04, 0x01, + 0x12, 0x04, 0xb0, 0x01, 0x08, 0x12, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x04, + 0xb2, 0x01, 0x04, 0x1d, 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, + 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x00, 0x04, 0x12, 0x04, 0xb2, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x00, 0x05, 0x12, 0x04, 0xb2, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x00, 0x01, 0x12, 0x04, 0xb2, 0x01, 0x13, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, + 0x03, 0x12, 0x04, 0xb2, 0x01, 0x1b, 0x1c, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, + 0x04, 0xb6, 0x01, 0x04, 0x1a, 0x1a, 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, + 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x04, + 0x12, 0x04, 0xb6, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x05, 0x12, + 0x04, 0xb6, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x04, + 0xb6, 0x01, 0x13, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x04, 0xb6, + 0x01, 0x18, 0x19, 0x0a, 0x6b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x02, 0x12, 0x04, 0xba, 0x01, 0x04, + 0x1b, 0x1a, 0x5d, 0x20, 0x4c, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, + 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x04, 0x12, 0x04, 0xba, 0x01, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x05, 0x12, 0x04, 0xba, 0x01, 0x0d, 0x12, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x04, 0xba, 0x01, 0x13, 0x16, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x04, 0xba, 0x01, 0x19, 0x1a, 0x0a, 0xb4, 0x01, 0x0a, + 0x04, 0x04, 0x04, 0x02, 0x03, 0x12, 0x04, 0xbf, 0x01, 0x04, 0x1a, 0x1a, 0xa5, 0x01, 0x20, 0x47, + 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, + 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x47, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, + 0x68, 0x61, 0x6e, 0x20, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, + 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, + 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x04, 0x12, 0x04, 0xbf, 0x01, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x05, 0x12, 0x04, 0xbf, 0x01, 0x0d, + 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x01, 0x12, 0x04, 0xbf, 0x01, 0x13, 0x15, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x03, 0x12, 0x04, 0xbf, 0x01, 0x18, 0x19, 0x0a, + 0xc2, 0x01, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x04, 0x12, 0x04, 0xc4, 0x01, 0x04, 0x1b, 0x1a, 0xb3, + 0x01, 0x20, 0x47, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, + 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, + 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x47, 0x74, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, + 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x04, 0x12, 0x04, 0xc4, + 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x05, 0x12, 0x04, 0xc4, 0x01, + 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x01, 0x12, 0x04, 0xc4, 0x01, 0x13, + 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x03, 0x12, 0x04, 0xc4, 0x01, 0x19, 0x1a, + 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x05, 0x12, 0x04, 0xc8, 0x01, 0x04, 0x1a, 0x1a, 0x4c, + 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, + 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x05, 0x04, 0x12, 0x04, 0xc8, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x05, 0x05, 0x12, 0x04, 0xc8, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x05, 0x01, 0x12, 0x04, 0xc8, 0x01, 0x13, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x05, 0x03, 0x12, 0x04, 0xc8, 0x01, 0x18, 0x19, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x06, + 0x12, 0x04, 0xcc, 0x01, 0x04, 0x1e, 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x06, 0x04, 0x12, 0x04, 0xcc, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x06, + 0x05, 0x12, 0x04, 0xcc, 0x01, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x06, 0x01, + 0x12, 0x04, 0xcc, 0x01, 0x13, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x06, 0x03, 0x12, + 0x04, 0xcc, 0x01, 0x1c, 0x1d, 0x0a, 0x81, 0x01, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x07, 0x12, 0x04, + 0xd0, 0x01, 0x04, 0x23, 0x1a, 0x73, 0x20, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, + 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, + 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, + 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x07, 0x04, 0x12, 0x04, 0xd0, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x07, + 0x05, 0x12, 0x04, 0xd0, 0x01, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x07, 0x01, + 0x12, 0x04, 0xd0, 0x01, 0x12, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x07, 0x03, 0x12, + 0x04, 0xd0, 0x01, 0x21, 0x22, 0x0a, 0x50, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x06, 0xd4, 0x01, 0x00, + 0xf5, 0x01, 0x01, 0x1a, 0x42, 0x20, 0x55, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, + 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, + 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x60, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x04, + 0xd4, 0x01, 0x08, 0x13, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x04, 0xd6, 0x01, + 0x04, 0x1e, 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, + 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x00, 0x04, 0x12, 0x04, 0xd6, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, + 0x05, 0x12, 0x04, 0xd6, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, + 0x12, 0x04, 0xd6, 0x01, 0x14, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, + 0x04, 0xd6, 0x01, 0x1c, 0x1d, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x04, 0xda, + 0x01, 0x04, 0x1b, 0x1a, 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, + 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x04, 0x12, 0x04, + 0xda, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x05, 0x12, 0x04, 0xda, + 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, 0x12, 0x04, 0xda, 0x01, + 0x14, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x04, 0xda, 0x01, 0x19, + 0x1a, 0x0a, 0x6b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x02, 0x12, 0x04, 0xde, 0x01, 0x04, 0x1c, 0x1a, + 0x5d, 0x20, 0x4c, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, + 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x04, 0x12, 0x04, 0xde, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x02, 0x05, 0x12, 0x04, 0xde, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x02, 0x01, 0x12, 0x04, 0xde, 0x01, 0x14, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x02, 0x03, 0x12, 0x04, 0xde, 0x01, 0x1a, 0x1b, 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, + 0x05, 0x02, 0x03, 0x12, 0x04, 0xe3, 0x01, 0x04, 0x1b, 0x1a, 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, + 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, + 0x47, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, + 0x6e, 0x20, 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, + 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, + 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x04, 0x12, 0x04, 0xe3, 0x01, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x05, 0x12, 0x04, 0xe3, 0x01, 0x0d, 0x13, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x01, 0x12, 0x04, 0xe3, 0x01, 0x14, 0x16, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x03, 0x12, 0x04, 0xe3, 0x01, 0x19, 0x1a, 0x0a, 0xc2, 0x01, + 0x0a, 0x04, 0x04, 0x05, 0x02, 0x04, 0x12, 0x04, 0xe8, 0x01, 0x04, 0x1c, 0x1a, 0xb3, 0x01, 0x20, + 0x47, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, + 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, + 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, + 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, + 0x47, 0x74, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, + 0x61, 0x6e, 0x20, 0x61, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, + 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, + 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x04, 0x12, 0x04, 0xe8, 0x01, 0x04, + 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x05, 0x12, 0x04, 0xe8, 0x01, 0x0d, 0x13, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x01, 0x12, 0x04, 0xe8, 0x01, 0x14, 0x17, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x03, 0x12, 0x04, 0xe8, 0x01, 0x1a, 0x1b, 0x0a, 0x5a, + 0x0a, 0x04, 0x04, 0x05, 0x02, 0x05, 0x12, 0x04, 0xec, 0x01, 0x04, 0x1b, 0x1a, 0x4c, 0x20, 0x49, + 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x05, 0x04, 0x12, 0x04, 0xec, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x05, 0x05, 0x12, 0x04, 0xec, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x05, + 0x01, 0x12, 0x04, 0xec, 0x01, 0x14, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x05, 0x03, + 0x12, 0x04, 0xec, 0x01, 0x19, 0x1a, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x06, 0x12, 0x04, + 0xf0, 0x01, 0x04, 0x1f, 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, + 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, 0x04, + 0x12, 0x04, 0xf0, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, 0x05, 0x12, + 0x04, 0xf0, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, 0x01, 0x12, 0x04, + 0xf0, 0x01, 0x14, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, 0x03, 0x12, 0x04, 0xf0, + 0x01, 0x1d, 0x1e, 0x0a, 0x81, 0x01, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x07, 0x12, 0x04, 0xf4, 0x01, + 0x04, 0x23, 0x1a, 0x73, 0x20, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, + 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, + 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, + 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x04, + 0x12, 0x04, 0xf4, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x05, 0x12, + 0x04, 0xf4, 0x01, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x01, 0x12, 0x04, + 0xf4, 0x01, 0x12, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x03, 0x12, 0x04, 0xf4, + 0x01, 0x21, 0x22, 0x0a, 0x50, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x06, 0xf8, 0x01, 0x00, 0x99, 0x02, + 0x01, 0x1a, 0x42, 0x20, 0x55, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, + 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x60, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x04, 0xf8, 0x01, + 0x08, 0x13, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x04, 0xfa, 0x01, 0x04, 0x1e, + 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, + 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x04, + 0x12, 0x04, 0xfa, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x05, 0x12, + 0x04, 0xfa, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x04, + 0xfa, 0x01, 0x14, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x04, 0xfa, + 0x01, 0x1c, 0x1d, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x01, 0x12, 0x04, 0xfe, 0x01, 0x04, + 0x1b, 0x1a, 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, + 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x04, 0x12, 0x04, 0xfe, 0x01, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x05, 0x12, 0x04, 0xfe, 0x01, 0x0d, + 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x01, 0x12, 0x04, 0xfe, 0x01, 0x14, 0x16, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x03, 0x12, 0x04, 0xfe, 0x01, 0x19, 0x1a, 0x0a, + 0x6b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x02, 0x12, 0x04, 0x82, 0x02, 0x04, 0x1c, 0x1a, 0x5d, 0x20, + 0x4c, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, + 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x02, 0x04, 0x12, 0x04, 0x82, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x02, 0x05, 0x12, 0x04, 0x82, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, + 0x02, 0x02, 0x01, 0x12, 0x04, 0x82, 0x02, 0x14, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x02, 0x03, 0x12, 0x04, 0x82, 0x02, 0x1a, 0x1b, 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, 0x06, 0x02, + 0x03, 0x12, 0x04, 0x87, 0x02, 0x04, 0x1b, 0x1a, 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, + 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, + 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, + 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, 0x6e, 0x67, + 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x03, 0x04, 0x12, 0x04, 0x87, 0x02, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x03, 0x05, 0x12, 0x04, 0x87, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x03, 0x01, 0x12, 0x04, 0x87, 0x02, 0x14, 0x16, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x06, 0x02, 0x03, 0x03, 0x12, 0x04, 0x87, 0x02, 0x19, 0x1a, 0x0a, 0xc2, 0x01, 0x0a, 0x04, + 0x04, 0x06, 0x02, 0x04, 0x12, 0x04, 0x8c, 0x02, 0x04, 0x1c, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, + 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, + 0x65, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x61, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, + 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, + 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x04, 0x12, 0x04, 0x8c, 0x02, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x05, 0x12, 0x04, 0x8c, 0x02, 0x0d, 0x13, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x06, 0x02, 0x04, 0x01, 0x12, 0x04, 0x8c, 0x02, 0x14, 0x17, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x04, 0x03, 0x12, 0x04, 0x8c, 0x02, 0x1a, 0x1b, 0x0a, 0x5a, 0x0a, 0x04, + 0x04, 0x06, 0x02, 0x05, 0x12, 0x04, 0x90, 0x02, 0x04, 0x1b, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, + 0x04, 0x12, 0x04, 0x90, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, 0x05, + 0x12, 0x04, 0x90, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, 0x01, 0x12, + 0x04, 0x90, 0x02, 0x14, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x05, 0x03, 0x12, 0x04, + 0x90, 0x02, 0x19, 0x1a, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x06, 0x12, 0x04, 0x94, 0x02, + 0x04, 0x1f, 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, + 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x06, 0x04, 0x12, 0x04, + 0x94, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x06, 0x05, 0x12, 0x04, 0x94, + 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x06, 0x01, 0x12, 0x04, 0x94, 0x02, + 0x14, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x06, 0x03, 0x12, 0x04, 0x94, 0x02, 0x1d, + 0x1e, 0x0a, 0x81, 0x01, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x07, 0x12, 0x04, 0x98, 0x02, 0x04, 0x23, + 0x1a, 0x73, 0x20, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, + 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, + 0x75, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, + 0x6d, 0x70, 0x74, 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x07, 0x04, 0x12, 0x04, + 0x98, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x07, 0x05, 0x12, 0x04, 0x98, + 0x02, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x07, 0x01, 0x12, 0x04, 0x98, 0x02, + 0x12, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x07, 0x03, 0x12, 0x04, 0x98, 0x02, 0x21, + 0x22, 0x0a, 0x50, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x06, 0x9c, 0x02, 0x00, 0xbd, 0x02, 0x01, 0x1a, + 0x42, 0x20, 0x53, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, + 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x20, 0x60, 0x73, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x04, 0x9c, 0x02, 0x08, 0x13, + 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x04, 0x9e, 0x02, 0x04, 0x1e, 0x1a, 0x45, + 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x04, 0x12, 0x04, + 0x9e, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x05, 0x12, 0x04, 0x9e, + 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x01, 0x12, 0x04, 0x9e, 0x02, + 0x14, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x00, 0x03, 0x12, 0x04, 0x9e, 0x02, 0x1c, + 0x1d, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x01, 0x12, 0x04, 0xa2, 0x02, 0x04, 0x1b, 0x1a, + 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, + 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x04, 0x12, 0x04, 0xa2, 0x02, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x05, 0x12, 0x04, 0xa2, 0x02, 0x0d, 0x13, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x01, 0x12, 0x04, 0xa2, 0x02, 0x14, 0x16, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, 0x04, 0xa2, 0x02, 0x19, 0x1a, 0x0a, 0x6b, 0x0a, + 0x04, 0x04, 0x07, 0x02, 0x02, 0x12, 0x04, 0xa6, 0x02, 0x04, 0x1c, 0x1a, 0x5d, 0x20, 0x4c, 0x74, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, + 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, + 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x02, 0x04, 0x12, 0x04, 0xa6, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x02, 0x05, 0x12, 0x04, 0xa6, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, + 0x01, 0x12, 0x04, 0xa6, 0x02, 0x14, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x03, + 0x12, 0x04, 0xa6, 0x02, 0x1a, 0x1b, 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x03, 0x12, + 0x04, 0xab, 0x02, 0x04, 0x1b, 0x1a, 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, + 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x20, 0x69, + 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, + 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, + 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x03, 0x04, 0x12, 0x04, 0xab, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x03, 0x05, 0x12, 0x04, 0xab, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x03, 0x01, 0x12, 0x04, 0xab, 0x02, 0x14, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, + 0x02, 0x03, 0x03, 0x12, 0x04, 0xab, 0x02, 0x19, 0x1a, 0x0a, 0xc2, 0x01, 0x0a, 0x04, 0x04, 0x07, + 0x02, 0x04, 0x12, 0x04, 0xb0, 0x02, 0x04, 0x1c, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, + 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, + 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x65, 0x20, + 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, + 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, + 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, + 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x07, 0x02, 0x04, 0x04, 0x12, 0x04, 0xb0, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x04, 0x05, 0x12, 0x04, 0xb0, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x07, 0x02, 0x04, 0x01, 0x12, 0x04, 0xb0, 0x02, 0x14, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x04, 0x03, 0x12, 0x04, 0xb0, 0x02, 0x1a, 0x1b, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x07, + 0x02, 0x05, 0x12, 0x04, 0xb4, 0x02, 0x04, 0x1b, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x05, 0x04, 0x12, + 0x04, 0xb4, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x05, 0x05, 0x12, 0x04, + 0xb4, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x05, 0x01, 0x12, 0x04, 0xb4, + 0x02, 0x14, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x05, 0x03, 0x12, 0x04, 0xb4, 0x02, + 0x19, 0x1a, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x06, 0x12, 0x04, 0xb8, 0x02, 0x04, 0x1f, + 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, + 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x06, 0x04, 0x12, 0x04, 0xb8, 0x02, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x06, 0x05, 0x12, 0x04, 0xb8, 0x02, 0x0d, + 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x06, 0x01, 0x12, 0x04, 0xb8, 0x02, 0x14, 0x1a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x06, 0x03, 0x12, 0x04, 0xb8, 0x02, 0x1d, 0x1e, 0x0a, + 0x81, 0x01, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x07, 0x12, 0x04, 0xbc, 0x02, 0x04, 0x23, 0x1a, 0x73, + 0x20, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, + 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, + 0x74, 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x07, 0x04, 0x12, 0x04, 0xbc, 0x02, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x07, 0x05, 0x12, 0x04, 0xbc, 0x02, 0x0d, + 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x07, 0x01, 0x12, 0x04, 0xbc, 0x02, 0x12, 0x1e, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x07, 0x03, 0x12, 0x04, 0xbc, 0x02, 0x21, 0x22, 0x0a, + 0x50, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x06, 0xc0, 0x02, 0x00, 0xe1, 0x02, 0x01, 0x1a, 0x42, 0x20, + 0x53, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, + 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x20, 0x60, 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x08, 0x01, 0x12, 0x04, 0xc0, 0x02, 0x08, 0x13, 0x0a, 0x53, + 0x0a, 0x04, 0x04, 0x08, 0x02, 0x00, 0x12, 0x04, 0xc2, 0x02, 0x04, 0x1e, 0x1a, 0x45, 0x20, 0x43, + 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, + 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x04, 0x12, 0x04, 0xc2, 0x02, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x05, 0x12, 0x04, 0xc2, 0x02, 0x0d, + 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x04, 0xc2, 0x02, 0x14, 0x19, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x04, 0xc2, 0x02, 0x1c, 0x1d, 0x0a, + 0x5e, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x01, 0x12, 0x04, 0xc6, 0x02, 0x04, 0x1b, 0x1a, 0x50, 0x20, + 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, + 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x04, 0x12, 0x04, 0xc6, 0x02, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x05, 0x12, 0x04, 0xc6, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x01, 0x01, 0x12, 0x04, 0xc6, 0x02, 0x14, 0x16, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x08, 0x02, 0x01, 0x03, 0x12, 0x04, 0xc6, 0x02, 0x19, 0x1a, 0x0a, 0x6b, 0x0a, 0x04, 0x04, + 0x08, 0x02, 0x02, 0x12, 0x04, 0xca, 0x02, 0x04, 0x1c, 0x1a, 0x5d, 0x20, 0x4c, 0x74, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, + 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, + 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, + 0x04, 0x12, 0x04, 0xca, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x05, + 0x12, 0x04, 0xca, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x01, 0x12, + 0x04, 0xca, 0x02, 0x14, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x03, 0x12, 0x04, + 0xca, 0x02, 0x1a, 0x1b, 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x03, 0x12, 0x04, 0xcf, + 0x02, 0x04, 0x1b, 0x1a, 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, + 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x20, 0x69, 0x73, 0x20, + 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, + 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x03, 0x04, 0x12, 0x04, 0xcf, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x03, 0x05, 0x12, 0x04, 0xcf, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x03, 0x01, 0x12, 0x04, 0xcf, 0x02, 0x14, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, + 0x03, 0x12, 0x04, 0xcf, 0x02, 0x19, 0x1a, 0x0a, 0xc2, 0x01, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x04, + 0x12, 0x04, 0xd4, 0x02, 0x04, 0x1c, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, + 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, + 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x0a, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, + 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, + 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x08, 0x02, 0x04, 0x04, 0x12, 0x04, 0xd4, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x04, 0x05, 0x12, 0x04, 0xd4, 0x02, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, + 0x02, 0x04, 0x01, 0x12, 0x04, 0xd4, 0x02, 0x14, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, + 0x04, 0x03, 0x12, 0x04, 0xd4, 0x02, 0x1a, 0x1b, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x05, + 0x12, 0x04, 0xd8, 0x02, 0x04, 0x1b, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, + 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x04, 0x12, 0x04, 0xd8, + 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x05, 0x12, 0x04, 0xd8, 0x02, + 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x01, 0x12, 0x04, 0xd8, 0x02, 0x14, + 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x03, 0x12, 0x04, 0xd8, 0x02, 0x19, 0x1a, + 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x06, 0x12, 0x04, 0xdc, 0x02, 0x04, 0x1f, 0x1a, 0x51, + 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, + 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x04, 0x12, 0x04, 0xdc, 0x02, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x05, 0x12, 0x04, 0xdc, 0x02, 0x0d, 0x13, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x01, 0x12, 0x04, 0xdc, 0x02, 0x14, 0x1a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x03, 0x12, 0x04, 0xdc, 0x02, 0x1d, 0x1e, 0x0a, 0x81, 0x01, + 0x0a, 0x04, 0x04, 0x08, 0x02, 0x07, 0x12, 0x04, 0xe0, 0x02, 0x04, 0x23, 0x1a, 0x73, 0x20, 0x49, + 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x04, 0x12, 0x04, 0xe0, 0x02, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x05, 0x12, 0x04, 0xe0, 0x02, 0x0d, 0x11, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x01, 0x12, 0x04, 0xe0, 0x02, 0x12, 0x1e, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x03, 0x12, 0x04, 0xe0, 0x02, 0x21, 0x22, 0x0a, 0x52, 0x0a, + 0x02, 0x04, 0x09, 0x12, 0x06, 0xe4, 0x02, 0x00, 0x85, 0x03, 0x01, 0x1a, 0x44, 0x20, 0x46, 0x69, + 0x78, 0x65, 0x64, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, + 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x60, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, 0x04, 0xe4, 0x02, 0x08, 0x14, 0x0a, 0x53, + 0x0a, 0x04, 0x04, 0x09, 0x02, 0x00, 0x12, 0x04, 0xe6, 0x02, 0x04, 0x1f, 0x1a, 0x45, 0x20, 0x43, + 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, + 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x04, 0x12, 0x04, 0xe6, 0x02, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x05, 0x12, 0x04, 0xe6, 0x02, 0x0d, + 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x04, 0xe6, 0x02, 0x15, 0x1a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, 0x04, 0xe6, 0x02, 0x1d, 0x1e, 0x0a, + 0x5e, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x01, 0x12, 0x04, 0xea, 0x02, 0x04, 0x1c, 0x1a, 0x50, 0x20, + 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, + 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x04, 0x12, 0x04, 0xea, 0x02, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x05, 0x12, 0x04, 0xea, 0x02, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x09, 0x02, 0x01, 0x01, 0x12, 0x04, 0xea, 0x02, 0x15, 0x17, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x09, 0x02, 0x01, 0x03, 0x12, 0x04, 0xea, 0x02, 0x1a, 0x1b, 0x0a, 0x6b, 0x0a, 0x04, 0x04, + 0x09, 0x02, 0x02, 0x12, 0x04, 0xee, 0x02, 0x04, 0x1d, 0x1a, 0x5d, 0x20, 0x4c, 0x74, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, + 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, + 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, + 0x04, 0x12, 0x04, 0xee, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x05, + 0x12, 0x04, 0xee, 0x02, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x01, 0x12, + 0x04, 0xee, 0x02, 0x15, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x03, 0x12, 0x04, + 0xee, 0x02, 0x1b, 0x1c, 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x03, 0x12, 0x04, 0xf3, + 0x02, 0x04, 0x1c, 0x1a, 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, + 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x20, 0x69, 0x73, 0x20, + 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, + 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x09, 0x02, 0x03, 0x04, 0x12, 0x04, 0xf3, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x03, 0x05, 0x12, 0x04, 0xf3, 0x02, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, + 0x03, 0x01, 0x12, 0x04, 0xf3, 0x02, 0x15, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x03, + 0x03, 0x12, 0x04, 0xf3, 0x02, 0x1a, 0x1b, 0x0a, 0xc2, 0x01, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x04, + 0x12, 0x04, 0xf8, 0x02, 0x04, 0x1d, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, + 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, + 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x0a, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, + 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, + 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x09, 0x02, 0x04, 0x04, 0x12, 0x04, 0xf8, 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x09, 0x02, 0x04, 0x05, 0x12, 0x04, 0xf8, 0x02, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x04, 0x01, 0x12, 0x04, 0xf8, 0x02, 0x15, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, + 0x04, 0x03, 0x12, 0x04, 0xf8, 0x02, 0x1b, 0x1c, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x05, + 0x12, 0x04, 0xfc, 0x02, 0x04, 0x1c, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, + 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x05, 0x04, 0x12, 0x04, 0xfc, + 0x02, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x05, 0x05, 0x12, 0x04, 0xfc, 0x02, + 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x05, 0x01, 0x12, 0x04, 0xfc, 0x02, 0x15, + 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x05, 0x03, 0x12, 0x04, 0xfc, 0x02, 0x1a, 0x1b, + 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x06, 0x12, 0x04, 0x80, 0x03, 0x04, 0x20, 0x1a, 0x51, + 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, + 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x06, 0x04, 0x12, 0x04, 0x80, 0x03, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x06, 0x05, 0x12, 0x04, 0x80, 0x03, 0x0d, 0x14, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x06, 0x01, 0x12, 0x04, 0x80, 0x03, 0x15, 0x1b, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x09, 0x02, 0x06, 0x03, 0x12, 0x04, 0x80, 0x03, 0x1e, 0x1f, 0x0a, 0x81, 0x01, + 0x0a, 0x04, 0x04, 0x09, 0x02, 0x07, 0x12, 0x04, 0x84, 0x03, 0x04, 0x23, 0x1a, 0x73, 0x20, 0x49, + 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x07, 0x04, 0x12, 0x04, 0x84, 0x03, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x07, 0x05, 0x12, 0x04, 0x84, 0x03, 0x0d, 0x11, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x07, 0x01, 0x12, 0x04, 0x84, 0x03, 0x12, 0x1e, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x09, 0x02, 0x07, 0x03, 0x12, 0x04, 0x84, 0x03, 0x21, 0x22, 0x0a, 0x52, 0x0a, + 0x02, 0x04, 0x0a, 0x12, 0x06, 0x88, 0x03, 0x00, 0xa9, 0x03, 0x01, 0x1a, 0x44, 0x20, 0x46, 0x69, + 0x78, 0x65, 0x64, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, + 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x60, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0a, 0x01, 0x12, 0x04, 0x88, 0x03, 0x08, 0x14, 0x0a, 0x53, + 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x00, 0x12, 0x04, 0x8a, 0x03, 0x04, 0x1f, 0x1a, 0x45, 0x20, 0x43, + 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, + 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x04, 0x12, 0x04, 0x8a, 0x03, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x05, 0x12, 0x04, 0x8a, 0x03, 0x0d, + 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x04, 0x8a, 0x03, 0x15, 0x1a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, 0x04, 0x8a, 0x03, 0x1d, 0x1e, 0x0a, + 0x5e, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x01, 0x12, 0x04, 0x8e, 0x03, 0x04, 0x1c, 0x1a, 0x50, 0x20, + 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, + 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x04, 0x12, 0x04, 0x8e, 0x03, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x05, 0x12, 0x04, 0x8e, 0x03, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0a, 0x02, 0x01, 0x01, 0x12, 0x04, 0x8e, 0x03, 0x15, 0x17, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0a, 0x02, 0x01, 0x03, 0x12, 0x04, 0x8e, 0x03, 0x1a, 0x1b, 0x0a, 0x6b, 0x0a, 0x04, 0x04, + 0x0a, 0x02, 0x02, 0x12, 0x04, 0x92, 0x03, 0x04, 0x1d, 0x1a, 0x5d, 0x20, 0x4c, 0x74, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, + 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, + 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, + 0x04, 0x12, 0x04, 0x92, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x05, + 0x12, 0x04, 0x92, 0x03, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x01, 0x12, + 0x04, 0x92, 0x03, 0x15, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x03, 0x12, 0x04, + 0x92, 0x03, 0x1b, 0x1c, 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x03, 0x12, 0x04, 0x97, + 0x03, 0x04, 0x1c, 0x1a, 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, + 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x20, 0x69, 0x73, 0x20, + 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, + 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0a, 0x02, 0x03, 0x04, 0x12, 0x04, 0x97, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, + 0x02, 0x03, 0x05, 0x12, 0x04, 0x97, 0x03, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, + 0x03, 0x01, 0x12, 0x04, 0x97, 0x03, 0x15, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, + 0x03, 0x12, 0x04, 0x97, 0x03, 0x1a, 0x1b, 0x0a, 0xc2, 0x01, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x04, + 0x12, 0x04, 0x9c, 0x03, 0x04, 0x1d, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, 0x20, + 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, + 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x65, 0x20, 0x69, 0x73, + 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x0a, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, + 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, + 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x9c, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x9c, 0x03, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, + 0x02, 0x04, 0x01, 0x12, 0x04, 0x9c, 0x03, 0x15, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, + 0x04, 0x03, 0x12, 0x04, 0x9c, 0x03, 0x1b, 0x1c, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x05, + 0x12, 0x04, 0xa0, 0x03, 0x04, 0x1c, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, + 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x05, 0x04, 0x12, 0x04, 0xa0, + 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x05, 0x05, 0x12, 0x04, 0xa0, 0x03, + 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x05, 0x01, 0x12, 0x04, 0xa0, 0x03, 0x15, + 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x05, 0x03, 0x12, 0x04, 0xa0, 0x03, 0x1a, 0x1b, + 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x06, 0x12, 0x04, 0xa4, 0x03, 0x04, 0x20, 0x1a, 0x51, + 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, + 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x06, 0x04, 0x12, 0x04, 0xa4, 0x03, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x06, 0x05, 0x12, 0x04, 0xa4, 0x03, 0x0d, 0x14, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x06, 0x01, 0x12, 0x04, 0xa4, 0x03, 0x15, 0x1b, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x06, 0x03, 0x12, 0x04, 0xa4, 0x03, 0x1e, 0x1f, 0x0a, 0x81, 0x01, + 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x07, 0x12, 0x04, 0xa8, 0x03, 0x04, 0x23, 0x1a, 0x73, 0x20, 0x49, + 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x07, 0x04, 0x12, 0x04, 0xa8, 0x03, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x07, 0x05, 0x12, 0x04, 0xa8, 0x03, 0x0d, 0x11, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x07, 0x01, 0x12, 0x04, 0xa8, 0x03, 0x12, 0x1e, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x07, 0x03, 0x12, 0x04, 0xa8, 0x03, 0x21, 0x22, 0x0a, 0x54, 0x0a, + 0x02, 0x04, 0x0b, 0x12, 0x06, 0xac, 0x03, 0x00, 0xcd, 0x03, 0x01, 0x1a, 0x46, 0x20, 0x53, 0x46, + 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, + 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x20, 0x60, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0b, 0x01, 0x12, 0x04, 0xac, 0x03, 0x08, 0x15, + 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x00, 0x12, 0x04, 0xae, 0x03, 0x04, 0x20, 0x1a, 0x45, + 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x04, 0x12, 0x04, + 0xae, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x05, 0x12, 0x04, 0xae, + 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x01, 0x12, 0x04, 0xae, 0x03, + 0x16, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x03, 0x12, 0x04, 0xae, 0x03, 0x1e, + 0x1f, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x01, 0x12, 0x04, 0xb2, 0x03, 0x04, 0x1d, 0x1a, + 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, + 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x04, 0x12, 0x04, 0xb2, 0x03, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x05, 0x12, 0x04, 0xb2, 0x03, 0x0d, 0x15, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x01, 0x12, 0x04, 0xb2, 0x03, 0x16, 0x18, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x03, 0x12, 0x04, 0xb2, 0x03, 0x1b, 0x1c, 0x0a, 0x6b, 0x0a, + 0x04, 0x04, 0x0b, 0x02, 0x02, 0x12, 0x04, 0xb6, 0x03, 0x04, 0x1e, 0x1a, 0x5d, 0x20, 0x4c, 0x74, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, 0x72, + 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, + 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, + 0x02, 0x02, 0x04, 0x12, 0x04, 0xb6, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, + 0x02, 0x05, 0x12, 0x04, 0xb6, 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x02, + 0x01, 0x12, 0x04, 0xb6, 0x03, 0x16, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x02, 0x03, + 0x12, 0x04, 0xb6, 0x03, 0x1c, 0x1d, 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x03, 0x12, + 0x04, 0xbb, 0x03, 0x04, 0x1d, 0x1a, 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, + 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x20, 0x69, + 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, 0x72, 0x20, + 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, + 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0b, 0x02, 0x03, 0x04, 0x12, 0x04, 0xbb, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0b, 0x02, 0x03, 0x05, 0x12, 0x04, 0xbb, 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0b, 0x02, 0x03, 0x01, 0x12, 0x04, 0xbb, 0x03, 0x16, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, + 0x02, 0x03, 0x03, 0x12, 0x04, 0xbb, 0x03, 0x1b, 0x1c, 0x0a, 0xc2, 0x01, 0x0a, 0x04, 0x04, 0x0b, + 0x02, 0x04, 0x12, 0x04, 0xc0, 0x03, 0x04, 0x1e, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x6f, + 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, + 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, 0x65, 0x20, + 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x61, + 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, + 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, + 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x04, 0x04, 0x12, 0x04, 0xc0, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0b, 0x02, 0x04, 0x05, 0x12, 0x04, 0xc0, 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0b, 0x02, 0x04, 0x01, 0x12, 0x04, 0xc0, 0x03, 0x16, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0b, 0x02, 0x04, 0x03, 0x12, 0x04, 0xc0, 0x03, 0x1c, 0x1d, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x0b, + 0x02, 0x05, 0x12, 0x04, 0xc4, 0x03, 0x04, 0x1d, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x05, 0x04, 0x12, + 0x04, 0xc4, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x05, 0x05, 0x12, 0x04, + 0xc4, 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x05, 0x01, 0x12, 0x04, 0xc4, + 0x03, 0x16, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x05, 0x03, 0x12, 0x04, 0xc4, 0x03, + 0x1b, 0x1c, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x06, 0x12, 0x04, 0xc8, 0x03, 0x04, 0x21, + 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, + 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x06, 0x04, 0x12, 0x04, 0xc8, 0x03, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x06, 0x05, 0x12, 0x04, 0xc8, 0x03, 0x0d, + 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x06, 0x01, 0x12, 0x04, 0xc8, 0x03, 0x16, 0x1c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x06, 0x03, 0x12, 0x04, 0xc8, 0x03, 0x1f, 0x20, 0x0a, + 0x81, 0x01, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x07, 0x12, 0x04, 0xcc, 0x03, 0x04, 0x23, 0x1a, 0x73, + 0x20, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, + 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, + 0x74, 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x07, 0x04, 0x12, 0x04, 0xcc, 0x03, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x07, 0x05, 0x12, 0x04, 0xcc, 0x03, 0x0d, + 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x07, 0x01, 0x12, 0x04, 0xcc, 0x03, 0x12, 0x1e, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x07, 0x03, 0x12, 0x04, 0xcc, 0x03, 0x21, 0x22, 0x0a, + 0x54, 0x0a, 0x02, 0x04, 0x0c, 0x12, 0x06, 0xd0, 0x03, 0x00, 0xf1, 0x03, 0x01, 0x1a, 0x46, 0x20, + 0x53, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, + 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x20, 0x60, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x60, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0c, 0x01, 0x12, 0x04, 0xd0, 0x03, + 0x08, 0x15, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x00, 0x12, 0x04, 0xd2, 0x03, 0x04, 0x20, + 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, + 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x04, + 0x12, 0x04, 0xd2, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x05, 0x12, + 0x04, 0xd2, 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x01, 0x12, 0x04, + 0xd2, 0x03, 0x16, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x03, 0x12, 0x04, 0xd2, + 0x03, 0x1e, 0x1f, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x01, 0x12, 0x04, 0xd6, 0x03, 0x04, + 0x1d, 0x1a, 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, + 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x04, 0x12, 0x04, 0xd6, 0x03, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x05, 0x12, 0x04, 0xd6, 0x03, 0x0d, + 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x01, 0x12, 0x04, 0xd6, 0x03, 0x16, 0x18, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x01, 0x03, 0x12, 0x04, 0xd6, 0x03, 0x1b, 0x1c, 0x0a, + 0x6b, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x02, 0x12, 0x04, 0xda, 0x03, 0x04, 0x1e, 0x1a, 0x5d, 0x20, + 0x4c, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, + 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0c, 0x02, 0x02, 0x04, 0x12, 0x04, 0xda, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0c, 0x02, 0x02, 0x05, 0x12, 0x04, 0xda, 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, + 0x02, 0x02, 0x01, 0x12, 0x04, 0xda, 0x03, 0x16, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, + 0x02, 0x03, 0x12, 0x04, 0xda, 0x03, 0x1c, 0x1d, 0x0a, 0xb4, 0x01, 0x0a, 0x04, 0x04, 0x0c, 0x02, + 0x03, 0x12, 0x04, 0xdf, 0x03, 0x04, 0x1d, 0x1a, 0xa5, 0x01, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, + 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, + 0x61, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, 0x20, 0x6f, + 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, 0x61, 0x6e, 0x67, + 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x03, 0x04, 0x12, 0x04, 0xdf, 0x03, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x03, 0x05, 0x12, 0x04, 0xdf, 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0c, 0x02, 0x03, 0x01, 0x12, 0x04, 0xdf, 0x03, 0x16, 0x18, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0c, 0x02, 0x03, 0x03, 0x12, 0x04, 0xdf, 0x03, 0x1b, 0x1c, 0x0a, 0xc2, 0x01, 0x0a, 0x04, + 0x04, 0x0c, 0x02, 0x04, 0x12, 0x04, 0xe4, 0x03, 0x04, 0x1e, 0x1a, 0xb3, 0x01, 0x20, 0x47, 0x74, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x6f, 0x72, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, + 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x49, 0x66, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x74, + 0x65, 0x20, 0x69, 0x73, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, + 0x20, 0x61, 0x0a, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x4c, 0x74, + 0x20, 0x6f, 0x72, 0x20, 0x4c, 0x74, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x6e, + 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x04, 0x04, 0x12, 0x04, 0xe4, 0x03, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x04, 0x05, 0x12, 0x04, 0xe4, 0x03, 0x0d, 0x15, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x04, 0x01, 0x12, 0x04, 0xe4, 0x03, 0x16, 0x19, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0c, 0x02, 0x04, 0x03, 0x12, 0x04, 0xe4, 0x03, 0x1c, 0x1d, 0x0a, 0x5a, 0x0a, 0x04, + 0x04, 0x0c, 0x02, 0x05, 0x12, 0x04, 0xe8, 0x03, 0x04, 0x1d, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x05, + 0x04, 0x12, 0x04, 0xe8, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x05, 0x05, + 0x12, 0x04, 0xe8, 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x05, 0x01, 0x12, + 0x04, 0xe8, 0x03, 0x16, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x05, 0x03, 0x12, 0x04, + 0xe8, 0x03, 0x1b, 0x1c, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x06, 0x12, 0x04, 0xec, 0x03, + 0x04, 0x21, 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, + 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x06, 0x04, 0x12, 0x04, + 0xec, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x06, 0x05, 0x12, 0x04, 0xec, + 0x03, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x06, 0x01, 0x12, 0x04, 0xec, 0x03, + 0x16, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x06, 0x03, 0x12, 0x04, 0xec, 0x03, 0x1f, + 0x20, 0x0a, 0x81, 0x01, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x07, 0x12, 0x04, 0xf0, 0x03, 0x04, 0x23, + 0x1a, 0x73, 0x20, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, + 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, + 0x75, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, + 0x6d, 0x70, 0x74, 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x07, 0x04, 0x12, 0x04, + 0xf0, 0x03, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x07, 0x05, 0x12, 0x04, 0xf0, + 0x03, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x07, 0x01, 0x12, 0x04, 0xf0, 0x03, + 0x12, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x07, 0x03, 0x12, 0x04, 0xf0, 0x03, 0x21, + 0x22, 0x0a, 0x4c, 0x0a, 0x02, 0x04, 0x0d, 0x12, 0x06, 0xf4, 0x03, 0x00, 0xf7, 0x03, 0x01, 0x1a, + 0x3e, 0x20, 0x42, 0x6f, 0x6f, 0x6c, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, + 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x20, 0x60, 0x62, 0x6f, 0x6f, 0x6c, 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, + 0x0b, 0x0a, 0x03, 0x04, 0x0d, 0x01, 0x12, 0x04, 0xf4, 0x03, 0x08, 0x11, 0x0a, 0x53, 0x0a, 0x04, + 0x04, 0x0d, 0x02, 0x00, 0x12, 0x04, 0xf6, 0x03, 0x04, 0x1c, 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, + 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, + 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x04, 0x12, 0x04, 0xf6, 0x03, 0x04, 0x0c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x05, 0x12, 0x04, 0xf6, 0x03, 0x0d, 0x11, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x01, 0x12, 0x04, 0xf6, 0x03, 0x12, 0x17, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x03, 0x12, 0x04, 0xf6, 0x03, 0x1a, 0x1b, 0x0a, 0x4f, 0x0a, + 0x02, 0x04, 0x0e, 0x12, 0x06, 0xfa, 0x03, 0x00, 0xeb, 0x04, 0x01, 0x1a, 0x41, 0x20, 0x53, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, + 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x73, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0b, + 0x0a, 0x03, 0x04, 0x0e, 0x01, 0x12, 0x04, 0xfa, 0x03, 0x08, 0x13, 0x0a, 0x53, 0x0a, 0x04, 0x04, + 0x0e, 0x02, 0x00, 0x12, 0x04, 0xfc, 0x03, 0x04, 0x1e, 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, + 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x04, 0x12, 0x04, 0xfc, 0x03, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x05, 0x12, 0x04, 0xfc, 0x03, 0x0d, 0x13, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x01, 0x12, 0x04, 0xfc, 0x03, 0x14, 0x19, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x00, 0x03, 0x12, 0x04, 0xfc, 0x03, 0x1c, 0x1d, 0x0a, 0xc8, 0x01, 0x0a, + 0x04, 0x04, 0x0e, 0x02, 0x01, 0x12, 0x04, 0x81, 0x04, 0x04, 0x1d, 0x1a, 0xb9, 0x01, 0x20, 0x4c, + 0x65, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, + 0x74, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x63, 0x68, + 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x73, 0x20, 0x28, 0x55, 0x6e, 0x69, 0x63, 0x6f, 0x64, + 0x65, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x29, 0x2e, 0x20, + 0x4e, 0x6f, 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, + 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, + 0x65, 0x72, 0x73, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x20, 0x66, + 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, + 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x04, + 0x12, 0x04, 0x81, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x05, 0x12, + 0x04, 0x81, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x01, 0x12, 0x04, + 0x81, 0x04, 0x14, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x01, 0x03, 0x12, 0x04, 0x81, + 0x04, 0x1a, 0x1c, 0x0a, 0xd8, 0x01, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x02, 0x12, 0x04, 0x86, 0x04, + 0x04, 0x20, 0x1a, 0xc9, 0x01, 0x20, 0x4d, 0x69, 0x6e, 0x4c, 0x65, 0x6e, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x6e, 0x75, 0x6d, + 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, + 0x72, 0x73, 0x20, 0x28, 0x55, 0x6e, 0x69, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x63, 0x6f, 0x64, 0x65, + 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x29, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6d, 0x69, + 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x2e, 0x20, 0x4e, 0x6f, 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, + 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x73, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x64, + 0x69, 0x66, 0x66, 0x65, 0x72, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, + 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x69, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x02, 0x04, 0x12, 0x04, 0x86, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x02, 0x05, 0x12, 0x04, 0x86, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x02, 0x01, 0x12, 0x04, 0x86, 0x04, 0x14, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x02, 0x03, 0x12, 0x04, 0x86, 0x04, 0x1e, 0x1f, 0x0a, 0xd8, 0x01, 0x0a, 0x04, 0x04, + 0x0e, 0x02, 0x03, 0x12, 0x04, 0x8b, 0x04, 0x04, 0x20, 0x1a, 0xc9, 0x01, 0x20, 0x4d, 0x61, 0x78, + 0x4c, 0x65, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x63, + 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x73, 0x20, 0x28, 0x55, 0x6e, 0x69, 0x63, 0x6f, + 0x64, 0x65, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x29, 0x20, + 0x61, 0x74, 0x20, 0x61, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x2e, 0x20, 0x4e, 0x6f, + 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, + 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, + 0x73, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x20, 0x66, 0x72, 0x6f, + 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, + 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x04, 0x12, 0x04, + 0x8b, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x05, 0x12, 0x04, 0x8b, + 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x01, 0x12, 0x04, 0x8b, 0x04, + 0x14, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x03, 0x03, 0x12, 0x04, 0x8b, 0x04, 0x1e, + 0x1f, 0x0a, 0x58, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x04, 0x12, 0x04, 0x8e, 0x04, 0x04, 0x23, 0x1a, + 0x4a, 0x20, 0x4c, 0x65, 0x6e, 0x42, 0x79, 0x74, 0x65, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, + 0x72, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x04, 0x04, 0x12, 0x04, 0x8e, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x04, 0x05, 0x12, 0x04, 0x8e, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x04, 0x01, 0x12, 0x04, 0x8e, 0x04, 0x14, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x04, + 0x03, 0x12, 0x04, 0x8e, 0x04, 0x20, 0x22, 0x0a, 0x66, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x05, 0x12, + 0x04, 0x92, 0x04, 0x04, 0x22, 0x1a, 0x58, 0x20, 0x4d, 0x69, 0x6e, 0x42, 0x79, 0x74, 0x65, 0x73, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, + 0x0a, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x05, 0x04, 0x12, 0x04, 0x92, 0x04, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x05, 0x05, 0x12, 0x04, 0x92, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x05, 0x01, 0x12, 0x04, 0x92, 0x04, 0x14, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x05, 0x03, 0x12, 0x04, 0x92, 0x04, 0x20, 0x21, 0x0a, 0x66, 0x0a, 0x04, 0x04, + 0x0e, 0x02, 0x06, 0x12, 0x04, 0x96, 0x04, 0x04, 0x22, 0x1a, 0x58, 0x20, 0x4d, 0x61, 0x78, 0x42, + 0x79, 0x74, 0x65, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, + 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x62, + 0x79, 0x74, 0x65, 0x73, 0x0a, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, + 0x75, 0x6d, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x06, 0x04, 0x12, 0x04, 0x96, 0x04, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x06, 0x05, 0x12, 0x04, 0x96, 0x04, 0x0d, + 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x06, 0x01, 0x12, 0x04, 0x96, 0x04, 0x14, 0x1d, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x06, 0x03, 0x12, 0x04, 0x96, 0x04, 0x20, 0x21, 0x0a, + 0xab, 0x01, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x07, 0x12, 0x04, 0x9b, 0x04, 0x04, 0x21, 0x1a, 0x9c, + 0x01, 0x20, 0x50, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x20, 0x61, + 0x67, 0x61, 0x69, 0x6e, 0x73, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x20, 0x65, 0x78, + 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x52, 0x45, 0x32, 0x20, 0x73, 0x79, + 0x6e, 0x74, 0x61, 0x78, 0x29, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, + 0x64, 0x65, 0x64, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x65, 0x6c, 0x69, 0x64, 0x65, 0x0a, 0x20, 0x61, 0x6e, 0x79, + 0x20, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x07, 0x04, 0x12, 0x04, 0x9b, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x07, 0x05, 0x12, 0x04, 0x9b, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x07, 0x01, 0x12, 0x04, 0x9b, 0x04, 0x14, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x07, 0x03, 0x12, 0x04, 0x9b, 0x04, 0x1f, 0x20, 0x0a, 0x73, 0x0a, 0x04, 0x04, 0x0e, 0x02, + 0x08, 0x12, 0x04, 0x9f, 0x04, 0x04, 0x21, 0x1a, 0x65, 0x20, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, + 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x74, 0x0a, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x08, 0x04, 0x12, 0x04, 0x9f, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x08, 0x05, 0x12, 0x04, 0x9f, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x08, 0x01, 0x12, 0x04, 0x9f, 0x04, 0x14, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x08, 0x03, 0x12, 0x04, 0x9f, 0x04, 0x1f, 0x20, 0x0a, 0x6d, 0x0a, 0x04, 0x04, 0x0e, + 0x02, 0x09, 0x12, 0x04, 0xa3, 0x04, 0x04, 0x21, 0x1a, 0x5f, 0x20, 0x53, 0x75, 0x66, 0x66, 0x69, + 0x78, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x20, 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x74, + 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x64, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x09, 0x04, 0x12, 0x04, 0xa3, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x09, + 0x05, 0x12, 0x04, 0xa3, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x09, 0x01, + 0x12, 0x04, 0xa3, 0x04, 0x14, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x09, 0x03, 0x12, + 0x04, 0xa3, 0x04, 0x1f, 0x20, 0x0a, 0x6d, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x0a, 0x12, 0x04, 0xa7, + 0x04, 0x04, 0x21, 0x1a, 0x5f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x68, 0x61, + 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x61, 0x6e, 0x79, 0x77, + 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0a, 0x04, 0x12, 0x04, 0xa7, + 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0a, 0x05, 0x12, 0x04, 0xa7, 0x04, + 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0a, 0x01, 0x12, 0x04, 0xa7, 0x04, 0x14, + 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0a, 0x03, 0x12, 0x04, 0xa7, 0x04, 0x1f, 0x20, + 0x0a, 0x72, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x0b, 0x12, 0x04, 0xab, 0x04, 0x04, 0x26, 0x1a, 0x64, + 0x20, 0x4e, 0x6f, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x68, 0x61, + 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x20, 0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x61, 0x6e, 0x79, 0x77, + 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0b, 0x04, 0x12, 0x04, 0xab, + 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0b, 0x05, 0x12, 0x04, 0xab, 0x04, + 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0b, 0x01, 0x12, 0x04, 0xab, 0x04, 0x14, + 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0b, 0x03, 0x12, 0x04, 0xab, 0x04, 0x23, 0x25, + 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x0c, 0x12, 0x04, 0xaf, 0x04, 0x04, 0x20, 0x1a, 0x4c, + 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, + 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x0c, 0x04, 0x12, 0x04, 0xaf, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x0c, 0x05, 0x12, 0x04, 0xaf, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x0c, 0x01, 0x12, 0x04, 0xaf, 0x04, 0x14, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x0c, 0x03, 0x12, 0x04, 0xaf, 0x04, 0x1d, 0x1f, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x0d, + 0x12, 0x04, 0xb3, 0x04, 0x04, 0x20, 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x0d, 0x04, 0x12, 0x04, 0xb3, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0d, + 0x05, 0x12, 0x04, 0xb3, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0d, 0x01, + 0x12, 0x04, 0xb3, 0x04, 0x14, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0d, 0x03, 0x12, + 0x04, 0xb3, 0x04, 0x1d, 0x1f, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x0e, 0x08, 0x00, 0x12, 0x06, 0xb7, + 0x04, 0x04, 0xdf, 0x04, 0x05, 0x1a, 0x4e, 0x20, 0x57, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77, + 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x20, + 0x61, 0x64, 0x76, 0x61, 0x6e, 0x63, 0x65, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, + 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x67, 0x61, 0x69, 0x6e, 0x73, 0x74, 0x20, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x70, 0x61, 0x74, 0x74, + 0x65, 0x72, 0x6e, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x08, 0x00, 0x01, 0x12, 0x04, + 0xb7, 0x04, 0x0a, 0x14, 0x0a, 0x64, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x0e, 0x12, 0x04, 0xba, 0x04, + 0x08, 0x1b, 0x1a, 0x56, 0x20, 0x45, 0x6d, 0x61, 0x69, 0x6c, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x20, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, + 0x73, 0x20, 0x61, 0x73, 0x0a, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, + 0x20, 0x52, 0x46, 0x43, 0x20, 0x35, 0x33, 0x32, 0x32, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x0e, 0x05, 0x12, 0x04, 0xba, 0x04, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x0e, 0x01, 0x12, 0x04, 0xba, 0x04, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0e, + 0x03, 0x12, 0x04, 0xba, 0x04, 0x18, 0x1a, 0x0a, 0xad, 0x01, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x0f, + 0x12, 0x04, 0xbf, 0x04, 0x08, 0x1b, 0x1a, 0x9e, 0x01, 0x20, 0x48, 0x6f, 0x73, 0x74, 0x6e, 0x61, + 0x6d, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x68, 0x6f, 0x73, 0x74, + 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x61, 0x73, 0x0a, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, + 0x20, 0x62, 0x79, 0x20, 0x52, 0x46, 0x43, 0x20, 0x31, 0x30, 0x33, 0x34, 0x2e, 0x20, 0x54, 0x68, + 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x20, 0x64, 0x6f, + 0x65, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x0a, 0x20, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, + 0x64, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x20, 0x28, + 0x49, 0x44, 0x4e, 0x73, 0x29, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0f, 0x05, + 0x12, 0x04, 0xbf, 0x04, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0f, 0x01, 0x12, + 0x04, 0xbf, 0x04, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x0f, 0x03, 0x12, 0x04, + 0xbf, 0x04, 0x18, 0x1a, 0x0a, 0x99, 0x01, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x10, 0x12, 0x04, 0xc3, + 0x04, 0x08, 0x1b, 0x1a, 0x8a, 0x01, 0x20, 0x49, 0x70, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x20, 0x49, 0x50, 0x20, 0x28, 0x76, 0x34, 0x20, 0x6f, 0x72, 0x20, 0x76, 0x36, 0x29, + 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x2e, 0x0a, 0x20, 0x56, 0x61, 0x6c, 0x69, 0x64, + 0x20, 0x49, 0x50, 0x76, 0x36, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x20, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, + 0x64, 0x65, 0x20, 0x73, 0x75, 0x72, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x73, + 0x71, 0x75, 0x61, 0x72, 0x65, 0x20, 0x62, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x10, 0x05, 0x12, 0x04, 0xc3, 0x04, 0x08, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x10, 0x01, 0x12, 0x04, 0xc3, 0x04, 0x0d, 0x0f, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x10, 0x03, 0x12, 0x04, 0xc3, 0x04, 0x18, 0x1a, 0x0a, 0x4b, 0x0a, + 0x04, 0x04, 0x0e, 0x02, 0x11, 0x12, 0x04, 0xc6, 0x04, 0x08, 0x1b, 0x1a, 0x3d, 0x20, 0x49, 0x70, + 0x76, 0x34, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x49, 0x50, 0x76, 0x34, + 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x11, 0x05, 0x12, 0x04, 0xc6, 0x04, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, + 0x11, 0x01, 0x12, 0x04, 0xc6, 0x04, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x11, + 0x03, 0x12, 0x04, 0xc6, 0x04, 0x18, 0x1a, 0x0a, 0x92, 0x01, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x12, + 0x12, 0x04, 0xca, 0x04, 0x08, 0x1b, 0x1a, 0x83, 0x01, 0x20, 0x49, 0x70, 0x76, 0x36, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x49, 0x50, 0x76, 0x36, 0x20, 0x61, 0x64, 0x64, + 0x72, 0x65, 0x73, 0x73, 0x2e, 0x20, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x0a, 0x20, 0x49, 0x50, 0x76, + 0x36, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x20, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x73, + 0x75, 0x72, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x71, 0x75, 0x61, 0x72, + 0x65, 0x20, 0x62, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x12, 0x05, 0x12, 0x04, 0xca, 0x04, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x12, 0x01, 0x12, 0x04, 0xca, 0x04, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, + 0x02, 0x12, 0x03, 0x12, 0x04, 0xca, 0x04, 0x18, 0x1a, 0x0a, 0x62, 0x0a, 0x04, 0x04, 0x0e, 0x02, + 0x13, 0x12, 0x04, 0xce, 0x04, 0x08, 0x1b, 0x1a, 0x54, 0x20, 0x55, 0x72, 0x69, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, + 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x2c, 0x20, 0x61, 0x62, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x65, + 0x20, 0x55, 0x52, 0x49, 0x20, 0x61, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x0a, + 0x20, 0x62, 0x79, 0x20, 0x52, 0x46, 0x43, 0x20, 0x33, 0x39, 0x38, 0x36, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0e, 0x02, 0x13, 0x05, 0x12, 0x04, 0xce, 0x04, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0e, 0x02, 0x13, 0x01, 0x12, 0x04, 0xce, 0x04, 0x0d, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0e, 0x02, 0x13, 0x03, 0x12, 0x04, 0xce, 0x04, 0x18, 0x1a, 0x0a, 0x7c, 0x0a, 0x04, 0x04, 0x0e, + 0x02, 0x14, 0x12, 0x04, 0xd2, 0x04, 0x08, 0x1b, 0x1a, 0x6e, 0x20, 0x55, 0x72, 0x69, 0x52, 0x65, + 0x66, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x55, 0x52, 0x49, 0x20, 0x61, + 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x52, 0x46, 0x43, + 0x0a, 0x20, 0x33, 0x39, 0x38, 0x36, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, + 0x65, 0x20, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x6f, 0x72, 0x20, 0x61, 0x62, + 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x14, + 0x05, 0x12, 0x04, 0xd2, 0x04, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x14, 0x01, + 0x12, 0x04, 0xd2, 0x04, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x14, 0x03, 0x12, + 0x04, 0xd2, 0x04, 0x18, 0x1a, 0x0a, 0xcf, 0x01, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x15, 0x12, 0x04, + 0xd7, 0x04, 0x08, 0x1b, 0x1a, 0xc0, 0x01, 0x20, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, + 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, + 0x68, 0x6f, 0x73, 0x74, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x61, 0x73, 0x0a, 0x20, 0x64, 0x65, 0x66, + 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x52, 0x46, 0x43, 0x20, 0x31, 0x30, 0x33, 0x34, + 0x20, 0x28, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x20, 0x6e, 0x6f, 0x74, + 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, + 0x6e, 0x0a, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x20, 0x6f, 0x72, 0x20, 0x49, 0x44, 0x4e, 0x73, + 0x29, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x69, 0x74, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, + 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x49, 0x50, 0x20, 0x28, 0x76, 0x34, 0x20, 0x6f, + 0x72, 0x20, 0x76, 0x36, 0x29, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x15, 0x05, + 0x12, 0x04, 0xd7, 0x04, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x15, 0x01, 0x12, + 0x04, 0xd7, 0x04, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x15, 0x03, 0x12, 0x04, + 0xd7, 0x04, 0x18, 0x1a, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x16, 0x12, 0x04, 0xdb, 0x04, + 0x08, 0x1b, 0x1a, 0x4c, 0x20, 0x55, 0x75, 0x69, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x20, 0x55, 0x55, 0x49, 0x44, 0x20, 0x61, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, + 0x65, 0x64, 0x20, 0x62, 0x79, 0x0a, 0x20, 0x52, 0x46, 0x43, 0x20, 0x34, 0x31, 0x32, 0x32, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x16, 0x05, 0x12, 0x04, 0xdb, 0x04, 0x08, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x16, 0x01, 0x12, 0x04, 0xdb, 0x04, 0x0d, 0x11, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x16, 0x03, 0x12, 0x04, 0xdb, 0x04, 0x18, 0x1a, 0x0a, 0x58, 0x0a, + 0x04, 0x04, 0x0e, 0x02, 0x17, 0x12, 0x04, 0xde, 0x04, 0x08, 0x29, 0x1a, 0x4a, 0x20, 0x57, 0x65, + 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x67, 0x65, 0x78, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, + 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, + 0x72, 0x6e, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, + 0x72, 0x65, 0x67, 0x65, 0x78, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x17, 0x06, + 0x12, 0x04, 0xde, 0x04, 0x08, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x17, 0x01, 0x12, + 0x04, 0xde, 0x04, 0x13, 0x23, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x17, 0x03, 0x12, 0x04, + 0xde, 0x04, 0x26, 0x28, 0x0a, 0xcc, 0x02, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x18, 0x12, 0x04, 0xe6, + 0x04, 0x02, 0x2d, 0x1a, 0xbd, 0x02, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x67, 0x65, 0x78, 0x65, 0x73, 0x20, 0x48, + 0x54, 0x54, 0x50, 0x5f, 0x48, 0x45, 0x41, 0x44, 0x45, 0x52, 0x5f, 0x4e, 0x41, 0x4d, 0x45, 0x20, + 0x61, 0x6e, 0x64, 0x20, 0x48, 0x54, 0x54, 0x50, 0x5f, 0x48, 0x45, 0x41, 0x44, 0x45, 0x52, 0x5f, + 0x56, 0x41, 0x4c, 0x55, 0x45, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x0a, + 0x20, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x20, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x42, 0x79, 0x20, 0x64, + 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, + 0x74, 0x72, 0x75, 0x65, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x48, 0x54, 0x54, 0x50, 0x20, 0x68, + 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x52, 0x46, 0x43, 0x2d, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x69, + 0x61, 0x6e, 0x74, 0x2e, 0x0a, 0x20, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, + 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x65, 0x6e, 0x61, 0x62, + 0x6c, 0x65, 0x20, 0x61, 0x20, 0x6c, 0x6f, 0x6f, 0x73, 0x65, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x6f, 0x6e, 0x6c, + 0x79, 0x20, 0x64, 0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x0a, 0x20, 0x5c, 0x72, 0x5c, + 0x6e, 0x5c, 0x30, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x73, 0x2c, 0x20, + 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x79, 0x70, 0x61, 0x73, 0x73, 0x20, 0x68, 0x65, 0x61, 0x64, + 0x65, 0x72, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x75, 0x6c, 0x65, + 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x18, 0x04, 0x12, 0x04, 0xe6, 0x04, + 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x18, 0x05, 0x12, 0x04, 0xe6, 0x04, 0x0b, + 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x18, 0x01, 0x12, 0x04, 0xe6, 0x04, 0x10, 0x16, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x18, 0x03, 0x12, 0x04, 0xe6, 0x04, 0x19, 0x1b, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x18, 0x07, 0x12, 0x04, 0xe6, 0x04, 0x1d, 0x2b, 0x0a, 0x81, + 0x01, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x19, 0x12, 0x04, 0xea, 0x04, 0x02, 0x22, 0x1a, 0x73, 0x20, + 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, + 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, + 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x19, 0x04, 0x12, 0x04, 0xea, 0x04, 0x02, + 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x19, 0x05, 0x12, 0x04, 0xea, 0x04, 0x0b, 0x0f, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x19, 0x01, 0x12, 0x04, 0xea, 0x04, 0x10, 0x1c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x19, 0x03, 0x12, 0x04, 0xea, 0x04, 0x1f, 0x21, 0x0a, 0x40, + 0x0a, 0x02, 0x05, 0x00, 0x12, 0x06, 0xee, 0x04, 0x00, 0xf6, 0x04, 0x01, 0x1a, 0x32, 0x20, 0x57, + 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x67, 0x65, 0x78, 0x20, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x77, 0x65, 0x6c, 0x6c, 0x2d, + 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x73, 0x2e, 0x0a, + 0x0a, 0x0b, 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, 0x04, 0xee, 0x04, 0x05, 0x0f, 0x0a, 0x0c, 0x0a, + 0x04, 0x05, 0x00, 0x02, 0x00, 0x12, 0x04, 0xef, 0x04, 0x02, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, 0xef, 0x04, 0x02, 0x09, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x00, + 0x02, 0x00, 0x02, 0x12, 0x04, 0xef, 0x04, 0x0c, 0x0d, 0x0a, 0x38, 0x0a, 0x04, 0x05, 0x00, 0x02, + 0x01, 0x12, 0x04, 0xf2, 0x04, 0x02, 0x17, 0x1a, 0x2a, 0x20, 0x48, 0x54, 0x54, 0x50, 0x20, 0x68, + 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x61, 0x73, 0x20, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x52, 0x46, 0x43, 0x20, 0x37, 0x32, 0x33, + 0x30, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x04, 0xf2, 0x04, + 0x02, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x02, 0x12, 0x04, 0xf2, 0x04, 0x15, + 0x16, 0x0a, 0x39, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x02, 0x12, 0x04, 0xf5, 0x04, 0x02, 0x18, 0x1a, + 0x2b, 0x20, 0x48, 0x54, 0x54, 0x50, 0x20, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x20, 0x61, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, + 0x79, 0x20, 0x52, 0x46, 0x43, 0x20, 0x37, 0x32, 0x33, 0x30, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x05, 0x00, 0x02, 0x02, 0x01, 0x12, 0x04, 0xf5, 0x04, 0x02, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x02, 0x02, 0x12, 0x04, 0xf5, 0x04, 0x16, 0x17, 0x0a, 0x4d, 0x0a, 0x02, 0x04, 0x0f, + 0x12, 0x06, 0xf9, 0x04, 0x00, 0xb4, 0x05, 0x01, 0x1a, 0x3f, 0x20, 0x42, 0x79, 0x74, 0x65, 0x73, + 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, + 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x62, 0x79, 0x74, 0x65, 0x73, + 0x60, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0f, 0x01, + 0x12, 0x04, 0xf9, 0x04, 0x08, 0x12, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x00, 0x12, 0x04, + 0xfb, 0x04, 0x04, 0x1d, 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, + 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0f, 0x02, 0x00, 0x04, 0x12, 0x04, 0xfb, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, + 0x02, 0x00, 0x05, 0x12, 0x04, 0xfb, 0x04, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, + 0x00, 0x01, 0x12, 0x04, 0xfb, 0x04, 0x13, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, + 0x03, 0x12, 0x04, 0xfb, 0x04, 0x1b, 0x1c, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x01, 0x12, + 0x04, 0xfe, 0x04, 0x04, 0x1d, 0x1a, 0x45, 0x20, 0x4c, 0x65, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, + 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0f, 0x02, 0x01, 0x04, 0x12, 0x04, 0xfe, 0x04, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0f, 0x02, 0x01, 0x05, 0x12, 0x04, 0xfe, 0x04, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, + 0x02, 0x01, 0x01, 0x12, 0x04, 0xfe, 0x04, 0x14, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, + 0x01, 0x03, 0x12, 0x04, 0xfe, 0x04, 0x1a, 0x1c, 0x0a, 0x64, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x02, + 0x12, 0x04, 0x82, 0x05, 0x04, 0x20, 0x1a, 0x56, 0x20, 0x4d, 0x69, 0x6e, 0x4c, 0x65, 0x6e, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, + 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x02, 0x04, 0x12, 0x04, 0x82, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0f, 0x02, 0x02, 0x05, 0x12, 0x04, 0x82, 0x05, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0f, 0x02, 0x02, 0x01, 0x12, 0x04, 0x82, 0x05, 0x14, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0f, 0x02, 0x02, 0x03, 0x12, 0x04, 0x82, 0x05, 0x1e, 0x1f, 0x0a, 0x64, 0x0a, 0x04, 0x04, 0x0f, + 0x02, 0x03, 0x12, 0x04, 0x86, 0x05, 0x04, 0x20, 0x1a, 0x56, 0x20, 0x4d, 0x61, 0x78, 0x4c, 0x65, + 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, + 0x73, 0x0a, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x03, 0x04, 0x12, 0x04, 0x86, 0x05, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x03, 0x05, 0x12, 0x04, 0x86, 0x05, 0x0d, 0x13, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x03, 0x01, 0x12, 0x04, 0x86, 0x05, 0x14, 0x1b, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0f, 0x02, 0x03, 0x03, 0x12, 0x04, 0x86, 0x05, 0x1e, 0x1f, 0x0a, 0xab, 0x01, 0x0a, + 0x04, 0x04, 0x0f, 0x02, 0x04, 0x12, 0x04, 0x8b, 0x05, 0x04, 0x21, 0x1a, 0x9c, 0x01, 0x20, 0x50, + 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x20, 0x61, 0x67, 0x61, 0x69, + 0x6e, 0x73, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x64, 0x0a, 0x20, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, + 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x52, 0x45, 0x32, 0x20, 0x73, 0x79, 0x6e, 0x74, 0x61, + 0x78, 0x29, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, + 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x20, 0x65, 0x6c, 0x69, 0x64, 0x65, 0x0a, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x64, 0x65, + 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x72, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, + 0x02, 0x04, 0x04, 0x12, 0x04, 0x8b, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, + 0x04, 0x05, 0x12, 0x04, 0x8b, 0x05, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x04, + 0x01, 0x12, 0x04, 0x8b, 0x05, 0x14, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x04, 0x03, + 0x12, 0x04, 0x8b, 0x05, 0x1f, 0x20, 0x0a, 0x6f, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x05, 0x12, 0x04, + 0x8f, 0x05, 0x04, 0x21, 0x1a, 0x61, 0x20, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x68, 0x61, 0x76, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x62, 0x65, + 0x67, 0x69, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x05, 0x04, + 0x12, 0x04, 0x8f, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x05, 0x05, 0x12, + 0x04, 0x8f, 0x05, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x05, 0x01, 0x12, 0x04, + 0x8f, 0x05, 0x14, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x05, 0x03, 0x12, 0x04, 0x8f, + 0x05, 0x1f, 0x20, 0x0a, 0x69, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x06, 0x12, 0x04, 0x93, 0x05, 0x04, + 0x21, 0x1a, 0x5b, 0x20, 0x53, 0x75, 0x66, 0x66, 0x69, 0x78, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, + 0x65, 0x73, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x65, 0x6e, 0x64, 0x20, 0x6f, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x06, 0x04, 0x12, 0x04, 0x93, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0f, 0x02, 0x06, 0x05, 0x12, 0x04, 0x93, 0x05, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0f, 0x02, 0x06, 0x01, 0x12, 0x04, 0x93, 0x05, 0x14, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0f, 0x02, 0x06, 0x03, 0x12, 0x04, 0x93, 0x05, 0x1f, 0x20, 0x0a, 0x69, 0x0a, 0x04, 0x04, 0x0f, + 0x02, 0x07, 0x12, 0x04, 0x97, 0x05, 0x04, 0x21, 0x1a, 0x5b, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, 0x20, 0x61, 0x6e, 0x79, + 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x07, 0x04, 0x12, 0x04, + 0x97, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x07, 0x05, 0x12, 0x04, 0x97, + 0x05, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x07, 0x01, 0x12, 0x04, 0x97, 0x05, + 0x14, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x07, 0x03, 0x12, 0x04, 0x97, 0x05, 0x1f, + 0x20, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x08, 0x12, 0x04, 0x9b, 0x05, 0x04, 0x1e, 0x1a, + 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, + 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, + 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0f, 0x02, 0x08, 0x04, 0x12, 0x04, 0x9b, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0f, 0x02, 0x08, 0x05, 0x12, 0x04, 0x9b, 0x05, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0f, 0x02, 0x08, 0x01, 0x12, 0x04, 0x9b, 0x05, 0x13, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, + 0x02, 0x08, 0x03, 0x12, 0x04, 0x9b, 0x05, 0x1c, 0x1d, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x0f, 0x02, + 0x09, 0x12, 0x04, 0x9f, 0x05, 0x04, 0x1e, 0x1a, 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, + 0x02, 0x09, 0x04, 0x12, 0x04, 0x9f, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, + 0x09, 0x05, 0x12, 0x04, 0x9f, 0x05, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x09, + 0x01, 0x12, 0x04, 0x9f, 0x05, 0x13, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x09, 0x03, + 0x12, 0x04, 0x9f, 0x05, 0x1c, 0x1d, 0x0a, 0x5c, 0x0a, 0x04, 0x04, 0x0f, 0x08, 0x00, 0x12, 0x06, + 0xa3, 0x05, 0x04, 0xaf, 0x05, 0x05, 0x1a, 0x4c, 0x20, 0x57, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, + 0x77, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x20, 0x61, 0x64, 0x76, 0x61, 0x6e, 0x63, 0x65, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, + 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x67, 0x61, 0x69, 0x6e, 0x73, 0x74, 0x20, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x62, 0x79, 0x74, 0x65, 0x0a, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, + 0x72, 0x6e, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x08, 0x00, 0x01, 0x12, 0x04, 0xa3, + 0x05, 0x0a, 0x14, 0x0a, 0x61, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x0a, 0x12, 0x04, 0xa6, 0x05, 0x08, + 0x17, 0x1a, 0x53, 0x20, 0x49, 0x70, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, + 0x49, 0x50, 0x20, 0x28, 0x76, 0x34, 0x20, 0x6f, 0x72, 0x20, 0x76, 0x36, 0x29, 0x20, 0x61, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x69, 0x6e, 0x0a, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x66, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0a, 0x05, 0x12, + 0x04, 0xa6, 0x05, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0a, 0x01, 0x12, 0x04, + 0xa6, 0x05, 0x0d, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0a, 0x03, 0x12, 0x04, 0xa6, + 0x05, 0x14, 0x16, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x0b, 0x12, 0x04, 0xaa, 0x05, 0x08, + 0x17, 0x1a, 0x4c, 0x20, 0x49, 0x70, 0x76, 0x34, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x20, 0x49, 0x50, 0x76, 0x34, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x69, + 0x6e, 0x20, 0x62, 0x79, 0x74, 0x65, 0x0a, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0b, 0x05, 0x12, 0x04, 0xaa, 0x05, 0x08, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0b, 0x01, 0x12, 0x04, 0xaa, 0x05, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0f, 0x02, 0x0b, 0x03, 0x12, 0x04, 0xaa, 0x05, 0x14, 0x16, 0x0a, 0x5a, 0x0a, 0x04, + 0x04, 0x0f, 0x02, 0x0c, 0x12, 0x04, 0xae, 0x05, 0x08, 0x17, 0x1a, 0x4c, 0x20, 0x49, 0x70, 0x76, + 0x36, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, + 0x62, 0x65, 0x20, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x49, 0x50, 0x76, 0x36, 0x20, + 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x62, 0x79, 0x74, 0x65, 0x0a, + 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0c, + 0x05, 0x12, 0x04, 0xae, 0x05, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0c, 0x01, + 0x12, 0x04, 0xae, 0x05, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0c, 0x03, 0x12, + 0x04, 0xae, 0x05, 0x14, 0x16, 0x0a, 0x81, 0x01, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x0d, 0x12, 0x04, + 0xb3, 0x05, 0x04, 0x24, 0x1a, 0x73, 0x20, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, + 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, + 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, + 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, + 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, + 0x0d, 0x04, 0x12, 0x04, 0xb3, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0d, + 0x05, 0x12, 0x04, 0xb3, 0x05, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0d, 0x01, + 0x12, 0x04, 0xb3, 0x05, 0x12, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x0d, 0x03, 0x12, + 0x04, 0xb3, 0x05, 0x21, 0x23, 0x0a, 0x49, 0x0a, 0x02, 0x04, 0x10, 0x12, 0x06, 0xb7, 0x05, 0x00, + 0xc6, 0x05, 0x01, 0x1a, 0x3b, 0x20, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, + 0x20, 0x74, 0x6f, 0x20, 0x65, 0x6e, 0x75, 0x6d, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, + 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x10, 0x01, 0x12, 0x04, 0xb7, 0x05, 0x08, 0x11, 0x0a, 0x53, 0x0a, + 0x04, 0x04, 0x10, 0x02, 0x00, 0x12, 0x04, 0xb9, 0x05, 0x04, 0x24, 0x1a, 0x45, 0x20, 0x43, 0x6f, + 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, 0x04, 0x12, 0x04, 0xb9, 0x05, 0x04, + 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, 0x05, 0x12, 0x04, 0xb9, 0x05, 0x0d, 0x12, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, 0x01, 0x12, 0x04, 0xb9, 0x05, 0x13, 0x18, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, 0x03, 0x12, 0x04, 0xb9, 0x05, 0x22, 0x23, 0x0a, 0x8c, + 0x01, 0x0a, 0x04, 0x04, 0x10, 0x02, 0x01, 0x12, 0x04, 0xbd, 0x05, 0x04, 0x24, 0x1a, 0x7e, 0x20, + 0x44, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x4f, 0x6e, 0x6c, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6f, 0x6e, + 0x6c, 0x79, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x65, 0x6e, 0x75, 0x6d, 0x2c, 0x20, 0x66, 0x61, 0x69, + 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x75, 0x6e, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x10, 0x02, 0x01, 0x04, 0x12, 0x04, 0xbd, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x10, 0x02, 0x01, 0x05, 0x12, 0x04, 0xbd, 0x05, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x10, 0x02, 0x01, 0x01, 0x12, 0x04, 0xbd, 0x05, 0x13, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, + 0x02, 0x01, 0x03, 0x12, 0x04, 0xbd, 0x05, 0x22, 0x23, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x10, 0x02, + 0x02, 0x12, 0x04, 0xc1, 0x05, 0x04, 0x24, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, + 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x02, 0x04, 0x12, 0x04, + 0xc1, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x02, 0x05, 0x12, 0x04, 0xc1, + 0x05, 0x0d, 0x12, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x02, 0x01, 0x12, 0x04, 0xc1, 0x05, + 0x13, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x02, 0x03, 0x12, 0x04, 0xc1, 0x05, 0x22, + 0x23, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x10, 0x02, 0x03, 0x12, 0x04, 0xc5, 0x05, 0x04, 0x24, 0x1a, + 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, + 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x03, 0x04, 0x12, 0x04, 0xc5, 0x05, 0x04, + 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x03, 0x05, 0x12, 0x04, 0xc5, 0x05, 0x0d, 0x12, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x03, 0x01, 0x12, 0x04, 0xc5, 0x05, 0x13, 0x19, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x03, 0x03, 0x12, 0x04, 0xc5, 0x05, 0x22, 0x23, 0x0a, 0x99, + 0x01, 0x0a, 0x02, 0x04, 0x11, 0x12, 0x06, 0xca, 0x05, 0x00, 0xd1, 0x05, 0x01, 0x1a, 0x8a, 0x01, + 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, + 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, + 0x6f, 0x20, 0x65, 0x6d, 0x62, 0x65, 0x64, 0x64, 0x65, 0x64, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x46, 0x6f, 0x72, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x73, 0x2c, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x69, 0x73, 0x20, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x64, 0x20, 0x72, 0x65, 0x63, + 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x11, + 0x01, 0x12, 0x04, 0xca, 0x05, 0x08, 0x14, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x11, 0x02, 0x00, 0x12, + 0x04, 0xcd, 0x05, 0x04, 0x1f, 0x1a, 0x51, 0x20, 0x53, 0x6b, 0x69, 0x70, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, + 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, + 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, + 0x04, 0x12, 0x04, 0xcd, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, 0x05, + 0x12, 0x04, 0xcd, 0x05, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, 0x01, 0x12, + 0x04, 0xcd, 0x05, 0x12, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x00, 0x03, 0x12, 0x04, + 0xcd, 0x05, 0x1d, 0x1e, 0x0a, 0x3e, 0x0a, 0x04, 0x04, 0x11, 0x02, 0x01, 0x12, 0x04, 0xd0, 0x05, + 0x04, 0x1f, 0x1a, 0x30, 0x20, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x73, 0x65, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x01, 0x04, 0x12, 0x04, 0xd0, + 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x01, 0x05, 0x12, 0x04, 0xd0, 0x05, + 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x01, 0x01, 0x12, 0x04, 0xd0, 0x05, 0x12, + 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x11, 0x02, 0x01, 0x03, 0x12, 0x04, 0xd0, 0x05, 0x1d, 0x1e, + 0x0a, 0x53, 0x0a, 0x02, 0x04, 0x12, 0x12, 0x06, 0xd4, 0x05, 0x00, 0xea, 0x05, 0x01, 0x1a, 0x45, + 0x20, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, + 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x20, 0x60, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x60, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x12, 0x01, 0x12, 0x04, 0xd4, 0x05, + 0x08, 0x15, 0x0a, 0x68, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x00, 0x12, 0x04, 0xd7, 0x05, 0x04, 0x22, + 0x1a, 0x5a, 0x20, 0x4d, 0x69, 0x6e, 0x49, 0x74, 0x65, 0x6d, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x6e, 0x75, + 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x20, 0x61, + 0x74, 0x20, 0x61, 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x12, 0x02, 0x00, 0x04, 0x12, 0x04, 0xd7, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x12, 0x02, 0x00, 0x05, 0x12, 0x04, 0xd7, 0x05, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, + 0x02, 0x00, 0x01, 0x12, 0x04, 0xd7, 0x05, 0x14, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, + 0x00, 0x03, 0x12, 0x04, 0xd7, 0x05, 0x20, 0x21, 0x0a, 0x68, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x01, + 0x12, 0x04, 0xdb, 0x05, 0x04, 0x22, 0x1a, 0x5a, 0x20, 0x4d, 0x61, 0x78, 0x49, 0x74, 0x65, 0x6d, + 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x69, + 0x74, 0x65, 0x6d, 0x73, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, + 0x6d, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x01, 0x04, 0x12, 0x04, 0xdb, 0x05, 0x04, + 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x01, 0x05, 0x12, 0x04, 0xdb, 0x05, 0x0d, 0x13, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x01, 0x01, 0x12, 0x04, 0xdb, 0x05, 0x14, 0x1d, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x01, 0x03, 0x12, 0x04, 0xdb, 0x05, 0x20, 0x21, 0x0a, 0xad, + 0x01, 0x0a, 0x04, 0x04, 0x12, 0x02, 0x02, 0x12, 0x04, 0xe0, 0x05, 0x04, 0x22, 0x1a, 0x9e, 0x01, + 0x20, 0x55, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65, + 0x6e, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, + 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x0a, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, + 0x6e, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x63, 0x61, 0x6c, 0x61, 0x72, 0x20, + 0x61, 0x6e, 0x64, 0x20, 0x65, 0x6e, 0x75, 0x6d, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x28, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6e, 0x6f, 0x74, + 0x0a, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x29, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x12, 0x02, 0x02, 0x04, 0x12, 0x04, 0xe0, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x12, 0x02, 0x02, 0x05, 0x12, 0x04, 0xe0, 0x05, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x12, 0x02, 0x02, 0x01, 0x12, 0x04, 0xe0, 0x05, 0x14, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x12, 0x02, 0x02, 0x03, 0x12, 0x04, 0xe0, 0x05, 0x20, 0x21, 0x0a, 0xc2, 0x01, 0x0a, 0x04, 0x04, + 0x12, 0x02, 0x03, 0x12, 0x04, 0xe5, 0x05, 0x04, 0x22, 0x1a, 0xb3, 0x01, 0x20, 0x49, 0x74, 0x65, + 0x6d, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x20, + 0x62, 0x65, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x61, + 0x63, 0x68, 0x20, 0x69, 0x74, 0x65, 0x6d, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x2e, 0x0a, 0x20, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, 0x77, + 0x69, 0x6c, 0x6c, 0x20, 0x73, 0x74, 0x69, 0x6c, 0x6c, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x67, 0x61, + 0x69, 0x6e, 0x73, 0x74, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x69, 0x74, 0x65, 0x6d, 0x0a, 0x20, + 0x75, 0x6e, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x73, 0x6b, 0x69, 0x70, 0x20, 0x69, 0x73, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x68, 0x65, 0x72, 0x65, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x03, 0x04, 0x12, 0x04, 0xe5, 0x05, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x12, 0x02, 0x03, 0x06, 0x12, 0x04, 0xe5, 0x05, 0x0d, 0x17, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x12, 0x02, 0x03, 0x01, 0x12, 0x04, 0xe5, 0x05, 0x18, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x12, 0x02, 0x03, 0x03, 0x12, 0x04, 0xe5, 0x05, 0x20, 0x21, 0x0a, 0x81, 0x01, 0x0a, 0x04, + 0x04, 0x12, 0x02, 0x04, 0x12, 0x04, 0xe9, 0x05, 0x04, 0x23, 0x1a, 0x73, 0x20, 0x49, 0x67, 0x6e, + 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x20, + 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x12, 0x02, 0x04, 0x04, 0x12, 0x04, 0xe9, 0x05, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x12, 0x02, 0x04, 0x05, 0x12, 0x04, 0xe9, 0x05, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x12, 0x02, 0x04, 0x01, 0x12, 0x04, 0xe9, 0x05, 0x12, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x12, 0x02, 0x04, 0x03, 0x12, 0x04, 0xe9, 0x05, 0x21, 0x22, 0x0a, 0x49, 0x0a, 0x02, 0x04, + 0x13, 0x12, 0x06, 0xed, 0x05, 0x00, 0x85, 0x06, 0x01, 0x1a, 0x3b, 0x20, 0x4d, 0x61, 0x70, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, + 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x6d, 0x61, 0x70, 0x60, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x13, 0x01, 0x12, 0x04, 0xed, + 0x05, 0x08, 0x10, 0x0a, 0x66, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x00, 0x12, 0x04, 0xf0, 0x05, 0x04, + 0x22, 0x1a, 0x58, 0x20, 0x4d, 0x69, 0x6e, 0x50, 0x61, 0x69, 0x72, 0x73, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x6e, + 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x4b, 0x56, 0x73, 0x20, 0x61, 0x74, + 0x20, 0x61, 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x13, 0x02, 0x00, 0x04, 0x12, 0x04, 0xf0, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, + 0x02, 0x00, 0x05, 0x12, 0x04, 0xf0, 0x05, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, + 0x00, 0x01, 0x12, 0x04, 0xf0, 0x05, 0x14, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x00, + 0x03, 0x12, 0x04, 0xf0, 0x05, 0x20, 0x21, 0x0a, 0x66, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x01, 0x12, + 0x04, 0xf4, 0x05, 0x04, 0x22, 0x1a, 0x58, 0x20, 0x4d, 0x61, 0x78, 0x50, 0x61, 0x69, 0x72, 0x73, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, + 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x4b, 0x56, + 0x73, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x01, 0x04, 0x12, 0x04, 0xf4, 0x05, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x13, 0x02, 0x01, 0x05, 0x12, 0x04, 0xf4, 0x05, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x13, 0x02, 0x01, 0x01, 0x12, 0x04, 0xf4, 0x05, 0x14, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x13, 0x02, 0x01, 0x03, 0x12, 0x04, 0xf4, 0x05, 0x20, 0x21, 0x0a, 0x7e, 0x0a, 0x04, 0x04, + 0x13, 0x02, 0x02, 0x12, 0x04, 0xf8, 0x05, 0x04, 0x20, 0x1a, 0x70, 0x20, 0x4e, 0x6f, 0x53, 0x70, + 0x61, 0x72, 0x73, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x75, 0x6e, + 0x73, 0x65, 0x74, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x0a, 0x20, + 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x61, 0x70, 0x27, 0x73, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x13, 0x02, 0x02, 0x04, 0x12, 0x04, 0xf8, 0x05, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, + 0x02, 0x02, 0x05, 0x12, 0x04, 0xf8, 0x05, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, + 0x02, 0x01, 0x12, 0x04, 0xf8, 0x05, 0x12, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x02, + 0x03, 0x12, 0x04, 0xf8, 0x05, 0x1e, 0x1f, 0x0a, 0x56, 0x0a, 0x04, 0x04, 0x13, 0x02, 0x03, 0x12, + 0x04, 0xfb, 0x05, 0x04, 0x23, 0x1a, 0x48, 0x20, 0x4b, 0x65, 0x79, 0x73, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, + 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x61, 0x70, 0x70, + 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x6b, 0x65, 0x79, + 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2e, 0x0a, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x03, 0x04, 0x12, 0x04, 0xfb, 0x05, 0x04, 0x0c, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x13, 0x02, 0x03, 0x06, 0x12, 0x04, 0xfb, 0x05, 0x0d, 0x17, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x13, 0x02, 0x03, 0x01, 0x12, 0x04, 0xfb, 0x05, 0x18, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x13, 0x02, 0x03, 0x03, 0x12, 0x04, 0xfb, 0x05, 0x21, 0x22, 0x0a, 0xc2, 0x01, 0x0a, 0x04, + 0x04, 0x13, 0x02, 0x04, 0x12, 0x04, 0x80, 0x06, 0x04, 0x23, 0x1a, 0xb3, 0x01, 0x20, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x74, + 0x6f, 0x20, 0x62, 0x65, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x65, 0x61, 0x63, + 0x68, 0x20, 0x6b, 0x65, 0x79, 0x0a, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x2e, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x73, 0x74, 0x69, 0x6c, 0x6c, 0x20, 0x68, + 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x69, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x0a, + 0x20, 0x75, 0x6e, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x73, 0x6b, 0x69, 0x70, 0x20, 0x69, 0x73, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x68, 0x65, 0x72, 0x65, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x04, 0x04, 0x12, 0x04, 0x80, 0x06, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x04, 0x06, 0x12, 0x04, 0x80, 0x06, 0x0d, 0x17, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x13, 0x02, 0x04, 0x01, 0x12, 0x04, 0x80, 0x06, 0x18, 0x1e, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x13, 0x02, 0x04, 0x03, 0x12, 0x04, 0x80, 0x06, 0x21, 0x22, 0x0a, 0x81, 0x01, 0x0a, + 0x04, 0x04, 0x13, 0x02, 0x05, 0x12, 0x04, 0x84, 0x06, 0x04, 0x23, 0x1a, 0x73, 0x20, 0x49, 0x67, + 0x6e, 0x6f, 0x72, 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x6f, 0x66, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x05, 0x04, 0x12, 0x04, 0x84, 0x06, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x13, 0x02, 0x05, 0x05, 0x12, 0x04, 0x84, 0x06, 0x0d, 0x11, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x13, 0x02, 0x05, 0x01, 0x12, 0x04, 0x84, 0x06, 0x12, 0x1e, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x13, 0x02, 0x05, 0x03, 0x12, 0x04, 0x84, 0x06, 0x21, 0x22, 0x0a, 0x6f, 0x0a, 0x02, + 0x04, 0x14, 0x12, 0x06, 0x89, 0x06, 0x00, 0x94, 0x06, 0x01, 0x1a, 0x61, 0x20, 0x41, 0x6e, 0x79, + 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x63, + 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, + 0x65, 0x64, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x20, 0x74, + 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x60, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x60, 0x20, 0x77, 0x65, 0x6c, + 0x6c, 0x2d, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x0a, 0x0a, 0x0b, 0x0a, + 0x03, 0x04, 0x14, 0x01, 0x12, 0x04, 0x89, 0x06, 0x08, 0x10, 0x0a, 0x3e, 0x0a, 0x04, 0x04, 0x14, + 0x02, 0x00, 0x12, 0x04, 0x8b, 0x06, 0x04, 0x1f, 0x1a, 0x30, 0x20, 0x52, 0x65, 0x71, 0x75, 0x69, + 0x72, 0x65, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, + 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, + 0x02, 0x00, 0x04, 0x12, 0x04, 0x8b, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, + 0x00, 0x05, 0x12, 0x04, 0x8b, 0x06, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x00, + 0x01, 0x12, 0x04, 0x8b, 0x06, 0x12, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x00, 0x03, + 0x12, 0x04, 0x8b, 0x06, 0x1d, 0x1e, 0x0a, 0x68, 0x0a, 0x04, 0x04, 0x14, 0x02, 0x01, 0x12, 0x04, + 0x8f, 0x06, 0x04, 0x1f, 0x1a, 0x5a, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x27, 0x73, 0x20, 0x60, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x60, + 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, + 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2e, 0x0a, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x01, 0x04, 0x12, 0x04, 0x8f, 0x06, 0x04, 0x0c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x14, 0x02, 0x01, 0x05, 0x12, 0x04, 0x8f, 0x06, 0x0d, 0x13, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x14, 0x02, 0x01, 0x01, 0x12, 0x04, 0x8f, 0x06, 0x14, 0x16, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x14, 0x02, 0x01, 0x03, 0x12, 0x04, 0x8f, 0x06, 0x1d, 0x1e, 0x0a, 0x6f, 0x0a, 0x04, + 0x04, 0x14, 0x02, 0x02, 0x12, 0x04, 0x93, 0x06, 0x04, 0x1f, 0x1a, 0x61, 0x20, 0x4e, 0x6f, 0x74, + 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x27, 0x73, 0x20, 0x60, + 0x74, 0x79, 0x70, 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x60, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x6e, + 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x61, + 0x6e, 0x79, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x14, 0x02, 0x02, 0x04, 0x12, 0x04, 0x93, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x14, 0x02, 0x02, 0x05, 0x12, 0x04, 0x93, 0x06, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x14, 0x02, 0x02, 0x01, 0x12, 0x04, 0x93, 0x06, 0x14, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x14, + 0x02, 0x02, 0x03, 0x12, 0x04, 0x93, 0x06, 0x1d, 0x1e, 0x0a, 0x7d, 0x0a, 0x02, 0x04, 0x15, 0x12, + 0x06, 0x98, 0x06, 0x00, 0xb6, 0x06, 0x01, 0x1a, 0x6f, 0x20, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, + 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, + 0x76, 0x65, 0x6c, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x60, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x60, 0x20, 0x77, 0x65, 0x6c, 0x6c, 0x2d, 0x6b, 0x6e, 0x6f, + 0x77, 0x6e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x15, 0x01, 0x12, + 0x04, 0x98, 0x06, 0x08, 0x15, 0x0a, 0x3e, 0x0a, 0x04, 0x04, 0x15, 0x02, 0x00, 0x12, 0x04, 0x9a, + 0x06, 0x04, 0x1f, 0x1a, 0x30, 0x20, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, + 0x20, 0x73, 0x65, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x00, 0x04, 0x12, 0x04, + 0x9a, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x00, 0x05, 0x12, 0x04, 0x9a, + 0x06, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x00, 0x01, 0x12, 0x04, 0x9a, 0x06, + 0x12, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x00, 0x03, 0x12, 0x04, 0x9a, 0x06, 0x1d, + 0x1e, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x15, 0x02, 0x01, 0x12, 0x04, 0x9d, 0x06, 0x04, 0x30, 0x1a, + 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, + 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x01, 0x04, 0x12, + 0x04, 0x9d, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x01, 0x06, 0x12, 0x04, + 0x9d, 0x06, 0x0d, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x01, 0x01, 0x12, 0x04, 0x9d, + 0x06, 0x26, 0x2b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x01, 0x03, 0x12, 0x04, 0x9d, 0x06, + 0x2e, 0x2f, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x15, 0x02, 0x02, 0x12, 0x04, 0xa1, 0x06, 0x04, 0x2d, + 0x1a, 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, + 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, + 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x02, 0x04, 0x12, 0x04, 0xa1, 0x06, 0x04, + 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x02, 0x06, 0x12, 0x04, 0xa1, 0x06, 0x0d, 0x25, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x02, 0x01, 0x12, 0x04, 0xa1, 0x06, 0x26, 0x28, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x02, 0x03, 0x12, 0x04, 0xa1, 0x06, 0x2b, 0x2c, 0x0a, 0x5e, + 0x0a, 0x04, 0x04, 0x15, 0x02, 0x03, 0x12, 0x04, 0xa5, 0x06, 0x04, 0x2e, 0x1a, 0x50, 0x20, 0x4c, + 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x2c, 0x0a, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x15, 0x02, 0x03, 0x04, 0x12, 0x04, 0xa5, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x15, 0x02, 0x03, 0x06, 0x12, 0x04, 0xa5, 0x06, 0x0d, 0x25, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x15, 0x02, 0x03, 0x01, 0x12, 0x04, 0xa5, 0x06, 0x26, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x15, 0x02, 0x03, 0x03, 0x12, 0x04, 0xa5, 0x06, 0x2c, 0x2d, 0x0a, 0x61, 0x0a, 0x04, 0x04, 0x15, + 0x02, 0x04, 0x12, 0x04, 0xa9, 0x06, 0x04, 0x2d, 0x1a, 0x53, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x15, 0x02, 0x04, 0x04, 0x12, 0x04, 0xa9, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x15, 0x02, 0x04, 0x06, 0x12, 0x04, 0xa9, 0x06, 0x0d, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x15, 0x02, 0x04, 0x01, 0x12, 0x04, 0xa9, 0x06, 0x26, 0x28, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, + 0x02, 0x04, 0x03, 0x12, 0x04, 0xa9, 0x06, 0x2b, 0x2c, 0x0a, 0x62, 0x0a, 0x04, 0x04, 0x15, 0x02, + 0x05, 0x12, 0x04, 0xad, 0x06, 0x04, 0x2e, 0x1a, 0x54, 0x20, 0x47, 0x74, 0x65, 0x20, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, + 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, + 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x2c, 0x0a, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x15, 0x02, 0x05, 0x04, 0x12, 0x04, 0xad, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x15, 0x02, 0x05, 0x06, 0x12, 0x04, 0xad, 0x06, 0x0d, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x15, 0x02, 0x05, 0x01, 0x12, 0x04, 0xad, 0x06, 0x26, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, + 0x02, 0x05, 0x03, 0x12, 0x04, 0xad, 0x06, 0x2c, 0x2d, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x15, 0x02, + 0x06, 0x12, 0x04, 0xb1, 0x06, 0x04, 0x2d, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, + 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x06, 0x04, 0x12, 0x04, + 0xb1, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x06, 0x06, 0x12, 0x04, 0xb1, + 0x06, 0x0d, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x06, 0x01, 0x12, 0x04, 0xb1, 0x06, + 0x26, 0x28, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x06, 0x03, 0x12, 0x04, 0xb1, 0x06, 0x2b, + 0x2c, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x15, 0x02, 0x07, 0x12, 0x04, 0xb5, 0x06, 0x04, 0x31, 0x1a, + 0x51, 0x20, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, + 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x0a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x73, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x07, 0x04, 0x12, 0x04, 0xb5, 0x06, 0x04, + 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x07, 0x06, 0x12, 0x04, 0xb5, 0x06, 0x0d, 0x25, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x07, 0x01, 0x12, 0x04, 0xb5, 0x06, 0x26, 0x2c, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x15, 0x02, 0x07, 0x03, 0x12, 0x04, 0xb5, 0x06, 0x2f, 0x30, 0x0a, 0x7f, + 0x0a, 0x02, 0x04, 0x16, 0x12, 0x06, 0xba, 0x06, 0x00, 0xdd, 0x06, 0x01, 0x1a, 0x71, 0x20, 0x54, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, + 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x20, 0x65, + 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, + 0x65, 0x0a, 0x20, 0x60, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x60, 0x20, 0x77, + 0x65, 0x6c, 0x6c, 0x2d, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x0a, 0x0a, + 0x0b, 0x0a, 0x03, 0x04, 0x16, 0x01, 0x12, 0x04, 0xba, 0x06, 0x08, 0x16, 0x0a, 0x3e, 0x0a, 0x04, + 0x04, 0x16, 0x02, 0x00, 0x12, 0x04, 0xbc, 0x06, 0x04, 0x1f, 0x1a, 0x30, 0x20, 0x52, 0x65, 0x71, + 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x74, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x16, 0x02, 0x00, 0x04, 0x12, 0x04, 0xbc, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x16, 0x02, 0x00, 0x05, 0x12, 0x04, 0xbc, 0x06, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, + 0x02, 0x00, 0x01, 0x12, 0x04, 0xbc, 0x06, 0x12, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, + 0x00, 0x03, 0x12, 0x04, 0xbc, 0x06, 0x1d, 0x1e, 0x0a, 0x53, 0x0a, 0x04, 0x04, 0x16, 0x02, 0x01, + 0x12, 0x04, 0xbf, 0x06, 0x04, 0x31, 0x1a, 0x45, 0x20, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, + 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, + 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x16, 0x02, 0x01, 0x04, 0x12, 0x04, 0xbf, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x16, 0x02, 0x01, 0x06, 0x12, 0x04, 0xbf, 0x06, 0x0d, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x16, 0x02, 0x01, 0x01, 0x12, 0x04, 0xbf, 0x06, 0x27, 0x2c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, + 0x02, 0x01, 0x03, 0x12, 0x04, 0xbf, 0x06, 0x2f, 0x30, 0x0a, 0x5e, 0x0a, 0x04, 0x04, 0x16, 0x02, + 0x02, 0x12, 0x04, 0xc3, 0x06, 0x04, 0x2e, 0x1a, 0x50, 0x20, 0x4c, 0x74, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, + 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, + 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, + 0x02, 0x04, 0x12, 0x04, 0xc3, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x02, + 0x06, 0x12, 0x04, 0xc3, 0x06, 0x0d, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x02, 0x01, + 0x12, 0x04, 0xc3, 0x06, 0x27, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x02, 0x03, 0x12, + 0x04, 0xc3, 0x06, 0x2c, 0x2d, 0x0a, 0x5f, 0x0a, 0x04, 0x04, 0x16, 0x02, 0x03, 0x12, 0x04, 0xc7, + 0x06, 0x04, 0x2f, 0x1a, 0x51, 0x20, 0x4c, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, + 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x69, 0x6e, 0x63, 0x6c, + 0x75, 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x03, 0x04, 0x12, + 0x04, 0xc7, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x03, 0x06, 0x12, 0x04, + 0xc7, 0x06, 0x0d, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x03, 0x01, 0x12, 0x04, 0xc7, + 0x06, 0x27, 0x2a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x03, 0x03, 0x12, 0x04, 0xc7, 0x06, + 0x2d, 0x2e, 0x0a, 0x61, 0x0a, 0x04, 0x04, 0x16, 0x02, 0x04, 0x12, 0x04, 0xcb, 0x06, 0x04, 0x2e, + 0x1a, 0x53, 0x20, 0x47, 0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, + 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x04, 0x04, 0x12, 0x04, + 0xcb, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x04, 0x06, 0x12, 0x04, 0xcb, + 0x06, 0x0d, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x04, 0x01, 0x12, 0x04, 0xcb, 0x06, + 0x27, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x04, 0x03, 0x12, 0x04, 0xcb, 0x06, 0x2c, + 0x2d, 0x0a, 0x62, 0x0a, 0x04, 0x04, 0x16, 0x02, 0x05, 0x12, 0x04, 0xcf, 0x06, 0x04, 0x2f, 0x1a, + 0x54, 0x20, 0x47, 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, + 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x20, + 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, + 0x73, 0x69, 0x76, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x05, 0x04, 0x12, 0x04, + 0xcf, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x05, 0x06, 0x12, 0x04, 0xcf, + 0x06, 0x0d, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x05, 0x01, 0x12, 0x04, 0xcf, 0x06, + 0x27, 0x2a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x05, 0x03, 0x12, 0x04, 0xcf, 0x06, 0x2d, + 0x2e, 0x0a, 0x7b, 0x0a, 0x04, 0x04, 0x16, 0x02, 0x06, 0x12, 0x04, 0xd3, 0x06, 0x04, 0x1e, 0x1a, + 0x6d, 0x20, 0x4c, 0x74, 0x4e, 0x6f, 0x77, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, + 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x75, 0x73, 0x74, + 0x20, 0x62, 0x65, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x20, + 0x4c, 0x74, 0x4e, 0x6f, 0x77, 0x0a, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, + 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x57, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x16, 0x02, 0x06, 0x04, 0x12, 0x04, 0xd3, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x16, 0x02, 0x06, 0x05, 0x12, 0x04, 0xd3, 0x06, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x16, 0x02, 0x06, 0x01, 0x12, 0x04, 0xd3, 0x06, 0x12, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x16, 0x02, 0x06, 0x03, 0x12, 0x04, 0xd3, 0x06, 0x1c, 0x1d, 0x0a, 0x7e, 0x0a, 0x04, 0x04, 0x16, + 0x02, 0x07, 0x12, 0x04, 0xd7, 0x06, 0x04, 0x1e, 0x1a, 0x70, 0x20, 0x47, 0x74, 0x4e, 0x6f, 0x77, + 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x67, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x20, 0x47, 0x74, 0x4e, 0x6f, + 0x77, 0x0a, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x62, 0x65, 0x20, 0x75, + 0x73, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x57, 0x69, 0x74, + 0x68, 0x69, 0x6e, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, + 0x02, 0x07, 0x04, 0x12, 0x04, 0xd7, 0x06, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, + 0x07, 0x05, 0x12, 0x04, 0xd7, 0x06, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x07, + 0x01, 0x12, 0x04, 0xd7, 0x06, 0x12, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x07, 0x03, + 0x12, 0x04, 0xd7, 0x06, 0x1c, 0x1d, 0x0a, 0xaa, 0x01, 0x0a, 0x04, 0x04, 0x16, 0x02, 0x08, 0x12, + 0x04, 0xdc, 0x06, 0x04, 0x31, 0x1a, 0x9b, 0x01, 0x20, 0x57, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, + 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x64, 0x75, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x20, 0x54, 0x68, 0x69, + 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x20, 0x63, 0x61, 0x6e, + 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x61, 0x6c, 0x6f, 0x6e, 0x65, 0x20, 0x6f, + 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4c, 0x74, 0x4e, 0x6f, 0x77, + 0x20, 0x61, 0x6e, 0x64, 0x0a, 0x20, 0x47, 0x74, 0x4e, 0x6f, 0x77, 0x20, 0x72, 0x75, 0x6c, 0x65, + 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x08, 0x04, 0x12, 0x04, 0xdc, 0x06, + 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x08, 0x06, 0x12, 0x04, 0xdc, 0x06, 0x0d, + 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x08, 0x01, 0x12, 0x04, 0xdc, 0x06, 0x26, 0x2c, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x16, 0x02, 0x08, 0x03, 0x12, 0x04, 0xdc, 0x06, 0x2f, 0x30, +]; +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/gen/ts/Makefile b/gen/ts/Makefile new file mode 100644 index 0000000000..b6a0167bb8 --- /dev/null +++ b/gen/ts/Makefile @@ -0,0 +1,6 @@ +PLACEHOLDER_NPM := \"version\": \"0.0.0-develop\" + +.PHONY: update_npmversion +update_npmversion: + grep "$(PLACEHOLDER_NPM)" "package.json" + sed -i "s/$(PLACEHOLDER_NPM)/\"version\": \"${VERSION}\"/g" "package.json" diff --git a/gen/ts/buf/validate/validate_pb.ts b/gen/ts/buf/validate/validate_pb.ts new file mode 100644 index 0000000000..2f630f4e41 --- /dev/null +++ b/gen/ts/buf/validate/validate_pb.ts @@ -0,0 +1,4754 @@ +// Copyright 2023-2025 Buf Technologies, Inc. +// +// 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. + +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file buf/validate/validate.proto (package buf.validate, syntax proto2) +/* eslint-disable */ + +import type { GenEnum, GenExtension, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, extDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Duration, FieldDescriptorProto_Type, FieldOptions, MessageOptions, OneofOptions, Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_descriptor, file_google_protobuf_duration, file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file buf/validate/validate.proto. + */ +export const file_buf_validate_validate: GenFile = /*@__PURE__*/ + fileDesc("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", [file_google_protobuf_descriptor, file_google_protobuf_duration, file_google_protobuf_timestamp]); + +/** + * `Rule` represents a validation rule written in the Common Expression + * Language (CEL) syntax. Each Rule includes a unique identifier, an + * optional error message, and the CEL expression to evaluate. For more + * information, [see our documentation](https://buf.build/docs/protovalidate/schemas/custom-rules/). + * + * ```proto + * message Foo { + * option (buf.validate.message).cel = { + * id: "foo.bar" + * message: "bar must be greater than 0" + * expression: "this.bar > 0" + * }; + * int32 bar = 1; + * } + * ``` + * + * @generated from message buf.validate.Rule + */ +export type Rule = Message<"buf.validate.Rule"> & { + /** + * `id` is a string that serves as a machine-readable name for this Rule. + * It should be unique within its scope, which could be either a message or a field. + * + * @generated from field: optional string id = 1; + */ + id: string; + + /** + * `message` is an optional field that provides a human-readable error message + * for this Rule when the CEL expression evaluates to false. If a + * non-empty message is provided, any strings resulting from the CEL + * expression evaluation are ignored. + * + * @generated from field: optional string message = 2; + */ + message: string; + + /** + * `expression` is the actual CEL expression that will be evaluated for + * validation. This string must resolve to either a boolean or a string + * value. If the expression evaluates to false or a non-empty string, the + * validation is considered failed, and the message is rejected. + * + * @generated from field: optional string expression = 3; + */ + expression: string; +}; + +/** + * Describes the message buf.validate.Rule. + * Use `create(RuleSchema)` to create a new message. + */ +export const RuleSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 0); + +/** + * MessageRules represents validation rules that are applied to the entire message. + * It includes disabling options and a list of Rule messages representing Common Expression Language (CEL) validation rules. + * + * @generated from message buf.validate.MessageRules + */ +export type MessageRules = Message<"buf.validate.MessageRules"> & { + /** + * `cel` is a repeated field of type Rule. Each Rule specifies a validation rule to be applied to this message. + * These rules are written in Common Expression Language (CEL) syntax. For more information, + * [see our documentation](https://buf.build/docs/protovalidate/schemas/custom-rules/). + * + * + * ```proto + * message MyMessage { + * // The field `foo` must be greater than 42. + * option (buf.validate.message).cel = { + * id: "my_message.value", + * message: "value must be greater than 42", + * expression: "this.foo > 42", + * }; + * optional int32 foo = 1; + * } + * ``` + * + * @generated from field: repeated buf.validate.Rule cel = 3; + */ + cel: Rule[]; + + /** + * `oneof` is a repeated field of type MessageOneofRule that specifies a list of fields + * of which at most one can be present. If `required` is also specified, then exactly one + * of the specified fields _must_ be present. + * + * This will enforce oneof-like constraints with a few features not provided by + * actual Protobuf oneof declarations: + * 1. Repeated and map fields are allowed in this validation. In a Protobuf oneof, + * only scalar fields are allowed. + * 2. Fields with implicit presence are allowed. In a Protobuf oneof, all member + * fields have explicit presence. This means that, for the purpose of determining + * how many fields are set, explicitly setting such a field to its zero value is + * effectively the same as not setting it at all. + * 3. This will always generate validation errors for a message unmarshalled from + * serialized data that sets more than one field. With a Protobuf oneof, when + * multiple fields are present in the serialized form, earlier values are usually + * silently ignored when unmarshalling, with only the last field being set when + * unmarshalling completes. + * + * Note that adding a field to a `oneof` will also set the IGNORE_IF_ZERO_VALUE on the fields. This means + * only the field that is set will be validated and the unset fields are not validated according to the field rules. + * This behavior can be overridden by setting `ignore` against a field. + * + * ```proto + * message MyMessage { + * // Only one of `field1` or `field2` _can_ be present in this message. + * option (buf.validate.message).oneof = { fields: ["field1", "field2"] }; + * // Exactly one of `field3` or `field4` _must_ be present in this message. + * option (buf.validate.message).oneof = { fields: ["field3", "field4"], required: true }; + * string field1 = 1; + * bytes field2 = 2; + * bool field3 = 3; + * int32 field4 = 4; + * } + * ``` + * + * @generated from field: repeated buf.validate.MessageOneofRule oneof = 4; + */ + oneof: MessageOneofRule[]; +}; + +/** + * Describes the message buf.validate.MessageRules. + * Use `create(MessageRulesSchema)` to create a new message. + */ +export const MessageRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 1); + +/** + * @generated from message buf.validate.MessageOneofRule + */ +export type MessageOneofRule = Message<"buf.validate.MessageOneofRule"> & { + /** + * A list of field names to include in the oneof. All field names must be + * defined in the message. At least one field must be specified, and + * duplicates are not permitted. + * + * @generated from field: repeated string fields = 1; + */ + fields: string[]; + + /** + * If true, one of the fields specified _must_ be set. + * + * @generated from field: optional bool required = 2; + */ + required: boolean; +}; + +/** + * Describes the message buf.validate.MessageOneofRule. + * Use `create(MessageOneofRuleSchema)` to create a new message. + */ +export const MessageOneofRuleSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 2); + +/** + * The `OneofRules` message type enables you to manage rules for + * oneof fields in your protobuf messages. + * + * @generated from message buf.validate.OneofRules + */ +export type OneofRules = Message<"buf.validate.OneofRules"> & { + /** + * If `required` is true, exactly one field of the oneof must be set. A + * validation error is returned if no fields in the oneof are set. Further rules + * should be placed on the fields themselves to ensure they are valid values, + * such as `min_len` or `gt`. + * + * ```proto + * message MyMessage { + * oneof value { + * // Either `a` or `b` must be set. If `a` is set, it must also be + * // non-empty; whereas if `b` is set, it can still be an empty string. + * option (buf.validate.oneof).required = true; + * string a = 1 [(buf.validate.field).string.min_len = 1]; + * string b = 2; + * } + * } + * ``` + * + * @generated from field: optional bool required = 1; + */ + required: boolean; +}; + +/** + * Describes the message buf.validate.OneofRules. + * Use `create(OneofRulesSchema)` to create a new message. + */ +export const OneofRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 3); + +/** + * FieldRules encapsulates the rules for each type of field. Depending on + * the field, the correct set should be used to ensure proper validations. + * + * @generated from message buf.validate.FieldRules + */ +export type FieldRules = Message<"buf.validate.FieldRules"> & { + /** + * `cel` is a repeated field used to represent a textual expression + * in the Common Expression Language (CEL) syntax. For more information, + * [see our documentation](https://buf.build/docs/protovalidate/schemas/custom-rules/). + * + * ```proto + * message MyMessage { + * // The field `value` must be greater than 42. + * optional int32 value = 1 [(buf.validate.field).cel = { + * id: "my_message.value", + * message: "value must be greater than 42", + * expression: "this > 42", + * }]; + * } + * ``` + * + * @generated from field: repeated buf.validate.Rule cel = 23; + */ + cel: Rule[]; + + /** + * If `required` is true, the field must be set. A validation error is returned + * if the field is not set. + * + * ```proto + * syntax="proto3"; + * + * message FieldsWithPresence { + * // Requires any string to be set, including the empty string. + * optional string link = 1 [ + * (buf.validate.field).required = true + * ]; + * // Requires true or false to be set. + * optional bool disabled = 2 [ + * (buf.validate.field).required = true + * ]; + * // Requires a message to be set, including the empty message. + * SomeMessage msg = 4 [ + * (buf.validate.field).required = true + * ]; + * } + * ``` + * + * All fields in the example above track presence. By default, Protovalidate + * ignores rules on those fields if no value is set. `required` ensures that + * the fields are set and valid. + * + * Fields that don't track presence are always validated by Protovalidate, + * whether they are set or not. It is not necessary to add `required`: + * + * ```proto + * syntax="proto3"; + * + * message FieldsWithoutPresence { + * // `string.email` always applies, even to an empty string. + * string link = 1 [ + * (buf.validate.field).string.email = true + * ]; + * // `repeated.min_items` always applies, even to an empty list. + * repeated string labels = 4 [ + * (buf.validate.field).repeated.min_items = 1 + * ]; + * } + * ``` + * + * To learn which fields track presence, see the + * [Field Presence cheat sheet](https://protobuf.dev/programming-guides/field_presence/#cheat). + * + * Note: While field rules can be applied to repeated items, map keys, and map + * values, the elements are always considered to be set. Consequently, + * specifying `repeated.items.required` is redundant. + * + * @generated from field: optional bool required = 25; + */ + required: boolean; + + /** + * Ignore validation rules on the field if its value matches the specified + * criteria. See the `Ignore` enum for details. + * + * ```proto + * message UpdateRequest { + * // The uri rule only applies if the field is not an empty string. + * string url = 1 [ + * (buf.validate.field).ignore = IGNORE_IF_ZERO_VALUE, + * (buf.validate.field).string.uri = true + * ]; + * } + * ``` + * + * @generated from field: optional buf.validate.Ignore ignore = 27; + */ + ignore: Ignore; + + /** + * @generated from oneof buf.validate.FieldRules.type + */ + type: { + /** + * Scalar Field Types + * + * @generated from field: buf.validate.FloatRules float = 1; + */ + value: FloatRules; + case: "float"; + } | { + /** + * @generated from field: buf.validate.DoubleRules double = 2; + */ + value: DoubleRules; + case: "double"; + } | { + /** + * @generated from field: buf.validate.Int32Rules int32 = 3; + */ + value: Int32Rules; + case: "int32"; + } | { + /** + * @generated from field: buf.validate.Int64Rules int64 = 4; + */ + value: Int64Rules; + case: "int64"; + } | { + /** + * @generated from field: buf.validate.UInt32Rules uint32 = 5; + */ + value: UInt32Rules; + case: "uint32"; + } | { + /** + * @generated from field: buf.validate.UInt64Rules uint64 = 6; + */ + value: UInt64Rules; + case: "uint64"; + } | { + /** + * @generated from field: buf.validate.SInt32Rules sint32 = 7; + */ + value: SInt32Rules; + case: "sint32"; + } | { + /** + * @generated from field: buf.validate.SInt64Rules sint64 = 8; + */ + value: SInt64Rules; + case: "sint64"; + } | { + /** + * @generated from field: buf.validate.Fixed32Rules fixed32 = 9; + */ + value: Fixed32Rules; + case: "fixed32"; + } | { + /** + * @generated from field: buf.validate.Fixed64Rules fixed64 = 10; + */ + value: Fixed64Rules; + case: "fixed64"; + } | { + /** + * @generated from field: buf.validate.SFixed32Rules sfixed32 = 11; + */ + value: SFixed32Rules; + case: "sfixed32"; + } | { + /** + * @generated from field: buf.validate.SFixed64Rules sfixed64 = 12; + */ + value: SFixed64Rules; + case: "sfixed64"; + } | { + /** + * @generated from field: buf.validate.BoolRules bool = 13; + */ + value: BoolRules; + case: "bool"; + } | { + /** + * @generated from field: buf.validate.StringRules string = 14; + */ + value: StringRules; + case: "string"; + } | { + /** + * @generated from field: buf.validate.BytesRules bytes = 15; + */ + value: BytesRules; + case: "bytes"; + } | { + /** + * Complex Field Types + * + * @generated from field: buf.validate.EnumRules enum = 16; + */ + value: EnumRules; + case: "enum"; + } | { + /** + * @generated from field: buf.validate.RepeatedRules repeated = 18; + */ + value: RepeatedRules; + case: "repeated"; + } | { + /** + * @generated from field: buf.validate.MapRules map = 19; + */ + value: MapRules; + case: "map"; + } | { + /** + * Well-Known Field Types + * + * @generated from field: buf.validate.AnyRules any = 20; + */ + value: AnyRules; + case: "any"; + } | { + /** + * @generated from field: buf.validate.DurationRules duration = 21; + */ + value: DurationRules; + case: "duration"; + } | { + /** + * @generated from field: buf.validate.TimestampRules timestamp = 22; + */ + value: TimestampRules; + case: "timestamp"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message buf.validate.FieldRules. + * Use `create(FieldRulesSchema)` to create a new message. + */ +export const FieldRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 4); + +/** + * PredefinedRules are custom rules that can be re-used with + * multiple fields. + * + * @generated from message buf.validate.PredefinedRules + */ +export type PredefinedRules = Message<"buf.validate.PredefinedRules"> & { + /** + * `cel` is a repeated field used to represent a textual expression + * in the Common Expression Language (CEL) syntax. For more information, + * [see our documentation](https://buf.build/docs/protovalidate/schemas/predefined-rules/). + * + * ```proto + * message MyMessage { + * // The field `value` must be greater than 42. + * optional int32 value = 1 [(buf.validate.predefined).cel = { + * id: "my_message.value", + * message: "value must be greater than 42", + * expression: "this > 42", + * }]; + * } + * ``` + * + * @generated from field: repeated buf.validate.Rule cel = 1; + */ + cel: Rule[]; +}; + +/** + * Describes the message buf.validate.PredefinedRules. + * Use `create(PredefinedRulesSchema)` to create a new message. + */ +export const PredefinedRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 5); + +/** + * FloatRules describes the rules applied to `float` values. These + * rules may also be applied to the `google.protobuf.FloatValue` Well-Known-Type. + * + * @generated from message buf.validate.FloatRules + */ +export type FloatRules = Message<"buf.validate.FloatRules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MyFloat { + * // value must equal 42.0 + * float value = 1 [(buf.validate.field).float.const = 42.0]; + * } + * ``` + * + * @generated from field: optional float const = 1; + */ + const: number; + + /** + * @generated from oneof buf.validate.FloatRules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field < + * value). If the field value is equal to or greater than the specified value, + * an error message is generated. + * + * ```proto + * message MyFloat { + * // value must be less than 10.0 + * float value = 1 [(buf.validate.field).float.lt = 10.0]; + * } + * ``` + * + * @generated from field: float lt = 2; + */ + value: number; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MyFloat { + * // value must be less than or equal to 10.0 + * float value = 1 [(buf.validate.field).float.lte = 10.0]; + * } + * ``` + * + * @generated from field: float lte = 3; + */ + value: number; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.FloatRules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyFloat { + * // value must be greater than 5.0 [float.gt] + * float value = 1 [(buf.validate.field).float.gt = 5.0]; + * + * // value must be greater than 5 and less than 10.0 [float.gt_lt] + * float other_value = 2 [(buf.validate.field).float = { gt: 5.0, lt: 10.0 }]; + * + * // value must be greater than 10 or less than 5.0 [float.gt_lt_exclusive] + * float another_value = 3 [(buf.validate.field).float = { gt: 10.0, lt: 5.0 }]; + * } + * ``` + * + * @generated from field: float gt = 4; + */ + value: number; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyFloat { + * // value must be greater than or equal to 5.0 [float.gte] + * float value = 1 [(buf.validate.field).float.gte = 5.0]; + * + * // value must be greater than or equal to 5.0 and less than 10.0 [float.gte_lt] + * float other_value = 2 [(buf.validate.field).float = { gte: 5.0, lt: 10.0 }]; + * + * // value must be greater than or equal to 10.0 or less than 5.0 [float.gte_lt_exclusive] + * float another_value = 3 [(buf.validate.field).float = { gte: 10.0, lt: 5.0 }]; + * } + * ``` + * + * @generated from field: float gte = 5; + */ + value: number; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message + * is generated. + * + * ```proto + * message MyFloat { + * // value must be in list [1.0, 2.0, 3.0] + * float value = 1 [(buf.validate.field).float = { in: [1.0, 2.0, 3.0] }]; + * } + * ``` + * + * @generated from field: repeated float in = 6; + */ + in: number[]; + + /** + * `in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MyFloat { + * // value must not be in list [1.0, 2.0, 3.0] + * float value = 1 [(buf.validate.field).float = { not_in: [1.0, 2.0, 3.0] }]; + * } + * ``` + * + * @generated from field: repeated float not_in = 7; + */ + notIn: number[]; + + /** + * `finite` requires the field value to be finite. If the field value is + * infinite or NaN, an error message is generated. + * + * @generated from field: optional bool finite = 8; + */ + finite: boolean; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyFloat { + * float value = 1 [ + * (buf.validate.field).float.example = 1.0, + * (buf.validate.field).float.example = inf + * ]; + * } + * ``` + * + * @generated from field: repeated float example = 9; + */ + example: number[]; +}; + +/** + * Describes the message buf.validate.FloatRules. + * Use `create(FloatRulesSchema)` to create a new message. + */ +export const FloatRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 6); + +/** + * DoubleRules describes the rules applied to `double` values. These + * rules may also be applied to the `google.protobuf.DoubleValue` Well-Known-Type. + * + * @generated from message buf.validate.DoubleRules + */ +export type DoubleRules = Message<"buf.validate.DoubleRules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MyDouble { + * // value must equal 42.0 + * double value = 1 [(buf.validate.field).double.const = 42.0]; + * } + * ``` + * + * @generated from field: optional double const = 1; + */ + const: number; + + /** + * @generated from oneof buf.validate.DoubleRules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field < + * value). If the field value is equal to or greater than the specified + * value, an error message is generated. + * + * ```proto + * message MyDouble { + * // value must be less than 10.0 + * double value = 1 [(buf.validate.field).double.lt = 10.0]; + * } + * ``` + * + * @generated from field: double lt = 2; + */ + value: number; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified value + * (field <= value). If the field value is greater than the specified value, + * an error message is generated. + * + * ```proto + * message MyDouble { + * // value must be less than or equal to 10.0 + * double value = 1 [(buf.validate.field).double.lte = 10.0]; + * } + * ``` + * + * @generated from field: double lte = 3; + */ + value: number; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.DoubleRules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or `lte`, + * the range is reversed, and the field value must be outside the specified + * range. If the field value doesn't meet the required conditions, an error + * message is generated. + * + * ```proto + * message MyDouble { + * // value must be greater than 5.0 [double.gt] + * double value = 1 [(buf.validate.field).double.gt = 5.0]; + * + * // value must be greater than 5 and less than 10.0 [double.gt_lt] + * double other_value = 2 [(buf.validate.field).double = { gt: 5.0, lt: 10.0 }]; + * + * // value must be greater than 10 or less than 5.0 [double.gt_lt_exclusive] + * double another_value = 3 [(buf.validate.field).double = { gt: 10.0, lt: 5.0 }]; + * } + * ``` + * + * @generated from field: double gt = 4; + */ + value: number; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyDouble { + * // value must be greater than or equal to 5.0 [double.gte] + * double value = 1 [(buf.validate.field).double.gte = 5.0]; + * + * // value must be greater than or equal to 5.0 and less than 10.0 [double.gte_lt] + * double other_value = 2 [(buf.validate.field).double = { gte: 5.0, lt: 10.0 }]; + * + * // value must be greater than or equal to 10.0 or less than 5.0 [double.gte_lt_exclusive] + * double another_value = 3 [(buf.validate.field).double = { gte: 10.0, lt: 5.0 }]; + * } + * ``` + * + * @generated from field: double gte = 5; + */ + value: number; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message is + * generated. + * + * ```proto + * message MyDouble { + * // value must be in list [1.0, 2.0, 3.0] + * double value = 1 [(buf.validate.field).double = { in: [1.0, 2.0, 3.0] }]; + * } + * ``` + * + * @generated from field: repeated double in = 6; + */ + in: number[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MyDouble { + * // value must not be in list [1.0, 2.0, 3.0] + * double value = 1 [(buf.validate.field).double = { not_in: [1.0, 2.0, 3.0] }]; + * } + * ``` + * + * @generated from field: repeated double not_in = 7; + */ + notIn: number[]; + + /** + * `finite` requires the field value to be finite. If the field value is + * infinite or NaN, an error message is generated. + * + * @generated from field: optional bool finite = 8; + */ + finite: boolean; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyDouble { + * double value = 1 [ + * (buf.validate.field).double.example = 1.0, + * (buf.validate.field).double.example = inf + * ]; + * } + * ``` + * + * @generated from field: repeated double example = 9; + */ + example: number[]; +}; + +/** + * Describes the message buf.validate.DoubleRules. + * Use `create(DoubleRulesSchema)` to create a new message. + */ +export const DoubleRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 7); + +/** + * Int32Rules describes the rules applied to `int32` values. These + * rules may also be applied to the `google.protobuf.Int32Value` Well-Known-Type. + * + * @generated from message buf.validate.Int32Rules + */ +export type Int32Rules = Message<"buf.validate.Int32Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MyInt32 { + * // value must equal 42 + * int32 value = 1 [(buf.validate.field).int32.const = 42]; + * } + * ``` + * + * @generated from field: optional int32 const = 1; + */ + const: number; + + /** + * @generated from oneof buf.validate.Int32Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field + * < value). If the field value is equal to or greater than the specified + * value, an error message is generated. + * + * ```proto + * message MyInt32 { + * // value must be less than 10 + * int32 value = 1 [(buf.validate.field).int32.lt = 10]; + * } + * ``` + * + * @generated from field: int32 lt = 2; + */ + value: number; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MyInt32 { + * // value must be less than or equal to 10 + * int32 value = 1 [(buf.validate.field).int32.lte = 10]; + * } + * ``` + * + * @generated from field: int32 lte = 3; + */ + value: number; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.Int32Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyInt32 { + * // value must be greater than 5 [int32.gt] + * int32 value = 1 [(buf.validate.field).int32.gt = 5]; + * + * // value must be greater than 5 and less than 10 [int32.gt_lt] + * int32 other_value = 2 [(buf.validate.field).int32 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [int32.gt_lt_exclusive] + * int32 another_value = 3 [(buf.validate.field).int32 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: int32 gt = 4; + */ + value: number; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified value + * (exclusive). If the value of `gte` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyInt32 { + * // value must be greater than or equal to 5 [int32.gte] + * int32 value = 1 [(buf.validate.field).int32.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [int32.gte_lt] + * int32 other_value = 2 [(buf.validate.field).int32 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [int32.gte_lt_exclusive] + * int32 another_value = 3 [(buf.validate.field).int32 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: int32 gte = 5; + */ + value: number; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message is + * generated. + * + * ```proto + * message MyInt32 { + * // value must be in list [1, 2, 3] + * int32 value = 1 [(buf.validate.field).int32 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated int32 in = 6; + */ + in: number[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error message + * is generated. + * + * ```proto + * message MyInt32 { + * // value must not be in list [1, 2, 3] + * int32 value = 1 [(buf.validate.field).int32 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated int32 not_in = 7; + */ + notIn: number[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyInt32 { + * int32 value = 1 [ + * (buf.validate.field).int32.example = 1, + * (buf.validate.field).int32.example = -10 + * ]; + * } + * ``` + * + * @generated from field: repeated int32 example = 8; + */ + example: number[]; +}; + +/** + * Describes the message buf.validate.Int32Rules. + * Use `create(Int32RulesSchema)` to create a new message. + */ +export const Int32RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 8); + +/** + * Int64Rules describes the rules applied to `int64` values. These + * rules may also be applied to the `google.protobuf.Int64Value` Well-Known-Type. + * + * @generated from message buf.validate.Int64Rules + */ +export type Int64Rules = Message<"buf.validate.Int64Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MyInt64 { + * // value must equal 42 + * int64 value = 1 [(buf.validate.field).int64.const = 42]; + * } + * ``` + * + * @generated from field: optional int64 const = 1; + */ + const: bigint; + + /** + * @generated from oneof buf.validate.Int64Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field < + * value). If the field value is equal to or greater than the specified value, + * an error message is generated. + * + * ```proto + * message MyInt64 { + * // value must be less than 10 + * int64 value = 1 [(buf.validate.field).int64.lt = 10]; + * } + * ``` + * + * @generated from field: int64 lt = 2; + */ + value: bigint; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MyInt64 { + * // value must be less than or equal to 10 + * int64 value = 1 [(buf.validate.field).int64.lte = 10]; + * } + * ``` + * + * @generated from field: int64 lte = 3; + */ + value: bigint; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.Int64Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyInt64 { + * // value must be greater than 5 [int64.gt] + * int64 value = 1 [(buf.validate.field).int64.gt = 5]; + * + * // value must be greater than 5 and less than 10 [int64.gt_lt] + * int64 other_value = 2 [(buf.validate.field).int64 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [int64.gt_lt_exclusive] + * int64 another_value = 3 [(buf.validate.field).int64 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: int64 gt = 4; + */ + value: bigint; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyInt64 { + * // value must be greater than or equal to 5 [int64.gte] + * int64 value = 1 [(buf.validate.field).int64.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [int64.gte_lt] + * int64 other_value = 2 [(buf.validate.field).int64 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [int64.gte_lt_exclusive] + * int64 another_value = 3 [(buf.validate.field).int64 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: int64 gte = 5; + */ + value: bigint; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message is + * generated. + * + * ```proto + * message MyInt64 { + * // value must be in list [1, 2, 3] + * int64 value = 1 [(buf.validate.field).int64 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated int64 in = 6; + */ + in: bigint[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MyInt64 { + * // value must not be in list [1, 2, 3] + * int64 value = 1 [(buf.validate.field).int64 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated int64 not_in = 7; + */ + notIn: bigint[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyInt64 { + * int64 value = 1 [ + * (buf.validate.field).int64.example = 1, + * (buf.validate.field).int64.example = -10 + * ]; + * } + * ``` + * + * @generated from field: repeated int64 example = 9; + */ + example: bigint[]; +}; + +/** + * Describes the message buf.validate.Int64Rules. + * Use `create(Int64RulesSchema)` to create a new message. + */ +export const Int64RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 9); + +/** + * UInt32Rules describes the rules applied to `uint32` values. These + * rules may also be applied to the `google.protobuf.UInt32Value` Well-Known-Type. + * + * @generated from message buf.validate.UInt32Rules + */ +export type UInt32Rules = Message<"buf.validate.UInt32Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MyUInt32 { + * // value must equal 42 + * uint32 value = 1 [(buf.validate.field).uint32.const = 42]; + * } + * ``` + * + * @generated from field: optional uint32 const = 1; + */ + const: number; + + /** + * @generated from oneof buf.validate.UInt32Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field < + * value). If the field value is equal to or greater than the specified value, + * an error message is generated. + * + * ```proto + * message MyUInt32 { + * // value must be less than 10 + * uint32 value = 1 [(buf.validate.field).uint32.lt = 10]; + * } + * ``` + * + * @generated from field: uint32 lt = 2; + */ + value: number; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MyUInt32 { + * // value must be less than or equal to 10 + * uint32 value = 1 [(buf.validate.field).uint32.lte = 10]; + * } + * ``` + * + * @generated from field: uint32 lte = 3; + */ + value: number; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.UInt32Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyUInt32 { + * // value must be greater than 5 [uint32.gt] + * uint32 value = 1 [(buf.validate.field).uint32.gt = 5]; + * + * // value must be greater than 5 and less than 10 [uint32.gt_lt] + * uint32 other_value = 2 [(buf.validate.field).uint32 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [uint32.gt_lt_exclusive] + * uint32 another_value = 3 [(buf.validate.field).uint32 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: uint32 gt = 4; + */ + value: number; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyUInt32 { + * // value must be greater than or equal to 5 [uint32.gte] + * uint32 value = 1 [(buf.validate.field).uint32.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [uint32.gte_lt] + * uint32 other_value = 2 [(buf.validate.field).uint32 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [uint32.gte_lt_exclusive] + * uint32 another_value = 3 [(buf.validate.field).uint32 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: uint32 gte = 5; + */ + value: number; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message is + * generated. + * + * ```proto + * message MyUInt32 { + * // value must be in list [1, 2, 3] + * uint32 value = 1 [(buf.validate.field).uint32 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated uint32 in = 6; + */ + in: number[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MyUInt32 { + * // value must not be in list [1, 2, 3] + * uint32 value = 1 [(buf.validate.field).uint32 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated uint32 not_in = 7; + */ + notIn: number[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyUInt32 { + * uint32 value = 1 [ + * (buf.validate.field).uint32.example = 1, + * (buf.validate.field).uint32.example = 10 + * ]; + * } + * ``` + * + * @generated from field: repeated uint32 example = 8; + */ + example: number[]; +}; + +/** + * Describes the message buf.validate.UInt32Rules. + * Use `create(UInt32RulesSchema)` to create a new message. + */ +export const UInt32RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 10); + +/** + * UInt64Rules describes the rules applied to `uint64` values. These + * rules may also be applied to the `google.protobuf.UInt64Value` Well-Known-Type. + * + * @generated from message buf.validate.UInt64Rules + */ +export type UInt64Rules = Message<"buf.validate.UInt64Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MyUInt64 { + * // value must equal 42 + * uint64 value = 1 [(buf.validate.field).uint64.const = 42]; + * } + * ``` + * + * @generated from field: optional uint64 const = 1; + */ + const: bigint; + + /** + * @generated from oneof buf.validate.UInt64Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field < + * value). If the field value is equal to or greater than the specified value, + * an error message is generated. + * + * ```proto + * message MyUInt64 { + * // value must be less than 10 + * uint64 value = 1 [(buf.validate.field).uint64.lt = 10]; + * } + * ``` + * + * @generated from field: uint64 lt = 2; + */ + value: bigint; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MyUInt64 { + * // value must be less than or equal to 10 + * uint64 value = 1 [(buf.validate.field).uint64.lte = 10]; + * } + * ``` + * + * @generated from field: uint64 lte = 3; + */ + value: bigint; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.UInt64Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyUInt64 { + * // value must be greater than 5 [uint64.gt] + * uint64 value = 1 [(buf.validate.field).uint64.gt = 5]; + * + * // value must be greater than 5 and less than 10 [uint64.gt_lt] + * uint64 other_value = 2 [(buf.validate.field).uint64 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [uint64.gt_lt_exclusive] + * uint64 another_value = 3 [(buf.validate.field).uint64 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: uint64 gt = 4; + */ + value: bigint; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyUInt64 { + * // value must be greater than or equal to 5 [uint64.gte] + * uint64 value = 1 [(buf.validate.field).uint64.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [uint64.gte_lt] + * uint64 other_value = 2 [(buf.validate.field).uint64 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [uint64.gte_lt_exclusive] + * uint64 another_value = 3 [(buf.validate.field).uint64 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: uint64 gte = 5; + */ + value: bigint; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message is + * generated. + * + * ```proto + * message MyUInt64 { + * // value must be in list [1, 2, 3] + * uint64 value = 1 [(buf.validate.field).uint64 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated uint64 in = 6; + */ + in: bigint[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MyUInt64 { + * // value must not be in list [1, 2, 3] + * uint64 value = 1 [(buf.validate.field).uint64 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated uint64 not_in = 7; + */ + notIn: bigint[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyUInt64 { + * uint64 value = 1 [ + * (buf.validate.field).uint64.example = 1, + * (buf.validate.field).uint64.example = -10 + * ]; + * } + * ``` + * + * @generated from field: repeated uint64 example = 8; + */ + example: bigint[]; +}; + +/** + * Describes the message buf.validate.UInt64Rules. + * Use `create(UInt64RulesSchema)` to create a new message. + */ +export const UInt64RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 11); + +/** + * SInt32Rules describes the rules applied to `sint32` values. + * + * @generated from message buf.validate.SInt32Rules + */ +export type SInt32Rules = Message<"buf.validate.SInt32Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MySInt32 { + * // value must equal 42 + * sint32 value = 1 [(buf.validate.field).sint32.const = 42]; + * } + * ``` + * + * @generated from field: optional sint32 const = 1; + */ + const: number; + + /** + * @generated from oneof buf.validate.SInt32Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field + * < value). If the field value is equal to or greater than the specified + * value, an error message is generated. + * + * ```proto + * message MySInt32 { + * // value must be less than 10 + * sint32 value = 1 [(buf.validate.field).sint32.lt = 10]; + * } + * ``` + * + * @generated from field: sint32 lt = 2; + */ + value: number; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MySInt32 { + * // value must be less than or equal to 10 + * sint32 value = 1 [(buf.validate.field).sint32.lte = 10]; + * } + * ``` + * + * @generated from field: sint32 lte = 3; + */ + value: number; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.SInt32Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MySInt32 { + * // value must be greater than 5 [sint32.gt] + * sint32 value = 1 [(buf.validate.field).sint32.gt = 5]; + * + * // value must be greater than 5 and less than 10 [sint32.gt_lt] + * sint32 other_value = 2 [(buf.validate.field).sint32 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [sint32.gt_lt_exclusive] + * sint32 another_value = 3 [(buf.validate.field).sint32 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: sint32 gt = 4; + */ + value: number; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MySInt32 { + * // value must be greater than or equal to 5 [sint32.gte] + * sint32 value = 1 [(buf.validate.field).sint32.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [sint32.gte_lt] + * sint32 other_value = 2 [(buf.validate.field).sint32 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [sint32.gte_lt_exclusive] + * sint32 another_value = 3 [(buf.validate.field).sint32 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: sint32 gte = 5; + */ + value: number; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message is + * generated. + * + * ```proto + * message MySInt32 { + * // value must be in list [1, 2, 3] + * sint32 value = 1 [(buf.validate.field).sint32 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated sint32 in = 6; + */ + in: number[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MySInt32 { + * // value must not be in list [1, 2, 3] + * sint32 value = 1 [(buf.validate.field).sint32 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated sint32 not_in = 7; + */ + notIn: number[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MySInt32 { + * sint32 value = 1 [ + * (buf.validate.field).sint32.example = 1, + * (buf.validate.field).sint32.example = -10 + * ]; + * } + * ``` + * + * @generated from field: repeated sint32 example = 8; + */ + example: number[]; +}; + +/** + * Describes the message buf.validate.SInt32Rules. + * Use `create(SInt32RulesSchema)` to create a new message. + */ +export const SInt32RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 12); + +/** + * SInt64Rules describes the rules applied to `sint64` values. + * + * @generated from message buf.validate.SInt64Rules + */ +export type SInt64Rules = Message<"buf.validate.SInt64Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MySInt64 { + * // value must equal 42 + * sint64 value = 1 [(buf.validate.field).sint64.const = 42]; + * } + * ``` + * + * @generated from field: optional sint64 const = 1; + */ + const: bigint; + + /** + * @generated from oneof buf.validate.SInt64Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field + * < value). If the field value is equal to or greater than the specified + * value, an error message is generated. + * + * ```proto + * message MySInt64 { + * // value must be less than 10 + * sint64 value = 1 [(buf.validate.field).sint64.lt = 10]; + * } + * ``` + * + * @generated from field: sint64 lt = 2; + */ + value: bigint; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MySInt64 { + * // value must be less than or equal to 10 + * sint64 value = 1 [(buf.validate.field).sint64.lte = 10]; + * } + * ``` + * + * @generated from field: sint64 lte = 3; + */ + value: bigint; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.SInt64Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MySInt64 { + * // value must be greater than 5 [sint64.gt] + * sint64 value = 1 [(buf.validate.field).sint64.gt = 5]; + * + * // value must be greater than 5 and less than 10 [sint64.gt_lt] + * sint64 other_value = 2 [(buf.validate.field).sint64 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [sint64.gt_lt_exclusive] + * sint64 another_value = 3 [(buf.validate.field).sint64 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: sint64 gt = 4; + */ + value: bigint; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MySInt64 { + * // value must be greater than or equal to 5 [sint64.gte] + * sint64 value = 1 [(buf.validate.field).sint64.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [sint64.gte_lt] + * sint64 other_value = 2 [(buf.validate.field).sint64 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [sint64.gte_lt_exclusive] + * sint64 another_value = 3 [(buf.validate.field).sint64 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: sint64 gte = 5; + */ + value: bigint; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message + * is generated. + * + * ```proto + * message MySInt64 { + * // value must be in list [1, 2, 3] + * sint64 value = 1 [(buf.validate.field).sint64 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated sint64 in = 6; + */ + in: bigint[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MySInt64 { + * // value must not be in list [1, 2, 3] + * sint64 value = 1 [(buf.validate.field).sint64 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated sint64 not_in = 7; + */ + notIn: bigint[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MySInt64 { + * sint64 value = 1 [ + * (buf.validate.field).sint64.example = 1, + * (buf.validate.field).sint64.example = -10 + * ]; + * } + * ``` + * + * @generated from field: repeated sint64 example = 8; + */ + example: bigint[]; +}; + +/** + * Describes the message buf.validate.SInt64Rules. + * Use `create(SInt64RulesSchema)` to create a new message. + */ +export const SInt64RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 13); + +/** + * Fixed32Rules describes the rules applied to `fixed32` values. + * + * @generated from message buf.validate.Fixed32Rules + */ +export type Fixed32Rules = Message<"buf.validate.Fixed32Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. + * If the field value doesn't match, an error message is generated. + * + * ```proto + * message MyFixed32 { + * // value must equal 42 + * fixed32 value = 1 [(buf.validate.field).fixed32.const = 42]; + * } + * ``` + * + * @generated from field: optional fixed32 const = 1; + */ + const: number; + + /** + * @generated from oneof buf.validate.Fixed32Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field < + * value). If the field value is equal to or greater than the specified value, + * an error message is generated. + * + * ```proto + * message MyFixed32 { + * // value must be less than 10 + * fixed32 value = 1 [(buf.validate.field).fixed32.lt = 10]; + * } + * ``` + * + * @generated from field: fixed32 lt = 2; + */ + value: number; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MyFixed32 { + * // value must be less than or equal to 10 + * fixed32 value = 1 [(buf.validate.field).fixed32.lte = 10]; + * } + * ``` + * + * @generated from field: fixed32 lte = 3; + */ + value: number; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.Fixed32Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyFixed32 { + * // value must be greater than 5 [fixed32.gt] + * fixed32 value = 1 [(buf.validate.field).fixed32.gt = 5]; + * + * // value must be greater than 5 and less than 10 [fixed32.gt_lt] + * fixed32 other_value = 2 [(buf.validate.field).fixed32 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [fixed32.gt_lt_exclusive] + * fixed32 another_value = 3 [(buf.validate.field).fixed32 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: fixed32 gt = 4; + */ + value: number; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyFixed32 { + * // value must be greater than or equal to 5 [fixed32.gte] + * fixed32 value = 1 [(buf.validate.field).fixed32.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [fixed32.gte_lt] + * fixed32 other_value = 2 [(buf.validate.field).fixed32 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [fixed32.gte_lt_exclusive] + * fixed32 another_value = 3 [(buf.validate.field).fixed32 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: fixed32 gte = 5; + */ + value: number; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message + * is generated. + * + * ```proto + * message MyFixed32 { + * // value must be in list [1, 2, 3] + * fixed32 value = 1 [(buf.validate.field).fixed32 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated fixed32 in = 6; + */ + in: number[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MyFixed32 { + * // value must not be in list [1, 2, 3] + * fixed32 value = 1 [(buf.validate.field).fixed32 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated fixed32 not_in = 7; + */ + notIn: number[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyFixed32 { + * fixed32 value = 1 [ + * (buf.validate.field).fixed32.example = 1, + * (buf.validate.field).fixed32.example = 2 + * ]; + * } + * ``` + * + * @generated from field: repeated fixed32 example = 8; + */ + example: number[]; +}; + +/** + * Describes the message buf.validate.Fixed32Rules. + * Use `create(Fixed32RulesSchema)` to create a new message. + */ +export const Fixed32RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 14); + +/** + * Fixed64Rules describes the rules applied to `fixed64` values. + * + * @generated from message buf.validate.Fixed64Rules + */ +export type Fixed64Rules = Message<"buf.validate.Fixed64Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MyFixed64 { + * // value must equal 42 + * fixed64 value = 1 [(buf.validate.field).fixed64.const = 42]; + * } + * ``` + * + * @generated from field: optional fixed64 const = 1; + */ + const: bigint; + + /** + * @generated from oneof buf.validate.Fixed64Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field < + * value). If the field value is equal to or greater than the specified value, + * an error message is generated. + * + * ```proto + * message MyFixed64 { + * // value must be less than 10 + * fixed64 value = 1 [(buf.validate.field).fixed64.lt = 10]; + * } + * ``` + * + * @generated from field: fixed64 lt = 2; + */ + value: bigint; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MyFixed64 { + * // value must be less than or equal to 10 + * fixed64 value = 1 [(buf.validate.field).fixed64.lte = 10]; + * } + * ``` + * + * @generated from field: fixed64 lte = 3; + */ + value: bigint; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.Fixed64Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyFixed64 { + * // value must be greater than 5 [fixed64.gt] + * fixed64 value = 1 [(buf.validate.field).fixed64.gt = 5]; + * + * // value must be greater than 5 and less than 10 [fixed64.gt_lt] + * fixed64 other_value = 2 [(buf.validate.field).fixed64 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [fixed64.gt_lt_exclusive] + * fixed64 another_value = 3 [(buf.validate.field).fixed64 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: fixed64 gt = 4; + */ + value: bigint; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyFixed64 { + * // value must be greater than or equal to 5 [fixed64.gte] + * fixed64 value = 1 [(buf.validate.field).fixed64.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [fixed64.gte_lt] + * fixed64 other_value = 2 [(buf.validate.field).fixed64 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [fixed64.gte_lt_exclusive] + * fixed64 another_value = 3 [(buf.validate.field).fixed64 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: fixed64 gte = 5; + */ + value: bigint; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message is + * generated. + * + * ```proto + * message MyFixed64 { + * // value must be in list [1, 2, 3] + * fixed64 value = 1 [(buf.validate.field).fixed64 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated fixed64 in = 6; + */ + in: bigint[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MyFixed64 { + * // value must not be in list [1, 2, 3] + * fixed64 value = 1 [(buf.validate.field).fixed64 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated fixed64 not_in = 7; + */ + notIn: bigint[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyFixed64 { + * fixed64 value = 1 [ + * (buf.validate.field).fixed64.example = 1, + * (buf.validate.field).fixed64.example = 2 + * ]; + * } + * ``` + * + * @generated from field: repeated fixed64 example = 8; + */ + example: bigint[]; +}; + +/** + * Describes the message buf.validate.Fixed64Rules. + * Use `create(Fixed64RulesSchema)` to create a new message. + */ +export const Fixed64RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 15); + +/** + * SFixed32Rules describes the rules applied to `fixed32` values. + * + * @generated from message buf.validate.SFixed32Rules + */ +export type SFixed32Rules = Message<"buf.validate.SFixed32Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MySFixed32 { + * // value must equal 42 + * sfixed32 value = 1 [(buf.validate.field).sfixed32.const = 42]; + * } + * ``` + * + * @generated from field: optional sfixed32 const = 1; + */ + const: number; + + /** + * @generated from oneof buf.validate.SFixed32Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field < + * value). If the field value is equal to or greater than the specified value, + * an error message is generated. + * + * ```proto + * message MySFixed32 { + * // value must be less than 10 + * sfixed32 value = 1 [(buf.validate.field).sfixed32.lt = 10]; + * } + * ``` + * + * @generated from field: sfixed32 lt = 2; + */ + value: number; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MySFixed32 { + * // value must be less than or equal to 10 + * sfixed32 value = 1 [(buf.validate.field).sfixed32.lte = 10]; + * } + * ``` + * + * @generated from field: sfixed32 lte = 3; + */ + value: number; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.SFixed32Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MySFixed32 { + * // value must be greater than 5 [sfixed32.gt] + * sfixed32 value = 1 [(buf.validate.field).sfixed32.gt = 5]; + * + * // value must be greater than 5 and less than 10 [sfixed32.gt_lt] + * sfixed32 other_value = 2 [(buf.validate.field).sfixed32 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [sfixed32.gt_lt_exclusive] + * sfixed32 another_value = 3 [(buf.validate.field).sfixed32 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: sfixed32 gt = 4; + */ + value: number; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MySFixed32 { + * // value must be greater than or equal to 5 [sfixed32.gte] + * sfixed32 value = 1 [(buf.validate.field).sfixed32.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [sfixed32.gte_lt] + * sfixed32 other_value = 2 [(buf.validate.field).sfixed32 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [sfixed32.gte_lt_exclusive] + * sfixed32 another_value = 3 [(buf.validate.field).sfixed32 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: sfixed32 gte = 5; + */ + value: number; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message is + * generated. + * + * ```proto + * message MySFixed32 { + * // value must be in list [1, 2, 3] + * sfixed32 value = 1 [(buf.validate.field).sfixed32 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated sfixed32 in = 6; + */ + in: number[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MySFixed32 { + * // value must not be in list [1, 2, 3] + * sfixed32 value = 1 [(buf.validate.field).sfixed32 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated sfixed32 not_in = 7; + */ + notIn: number[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MySFixed32 { + * sfixed32 value = 1 [ + * (buf.validate.field).sfixed32.example = 1, + * (buf.validate.field).sfixed32.example = 2 + * ]; + * } + * ``` + * + * @generated from field: repeated sfixed32 example = 8; + */ + example: number[]; +}; + +/** + * Describes the message buf.validate.SFixed32Rules. + * Use `create(SFixed32RulesSchema)` to create a new message. + */ +export const SFixed32RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 16); + +/** + * SFixed64Rules describes the rules applied to `fixed64` values. + * + * @generated from message buf.validate.SFixed64Rules + */ +export type SFixed64Rules = Message<"buf.validate.SFixed64Rules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MySFixed64 { + * // value must equal 42 + * sfixed64 value = 1 [(buf.validate.field).sfixed64.const = 42]; + * } + * ``` + * + * @generated from field: optional sfixed64 const = 1; + */ + const: bigint; + + /** + * @generated from oneof buf.validate.SFixed64Rules.less_than + */ + lessThan: { + /** + * `lt` requires the field value to be less than the specified value (field < + * value). If the field value is equal to or greater than the specified value, + * an error message is generated. + * + * ```proto + * message MySFixed64 { + * // value must be less than 10 + * sfixed64 value = 1 [(buf.validate.field).sfixed64.lt = 10]; + * } + * ``` + * + * @generated from field: sfixed64 lt = 2; + */ + value: bigint; + case: "lt"; + } | { + /** + * `lte` requires the field value to be less than or equal to the specified + * value (field <= value). If the field value is greater than the specified + * value, an error message is generated. + * + * ```proto + * message MySFixed64 { + * // value must be less than or equal to 10 + * sfixed64 value = 1 [(buf.validate.field).sfixed64.lte = 10]; + * } + * ``` + * + * @generated from field: sfixed64 lte = 3; + */ + value: bigint; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.SFixed64Rules.greater_than + */ + greaterThan: { + /** + * `gt` requires the field value to be greater than the specified value + * (exclusive). If the value of `gt` is larger than a specified `lt` or + * `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MySFixed64 { + * // value must be greater than 5 [sfixed64.gt] + * sfixed64 value = 1 [(buf.validate.field).sfixed64.gt = 5]; + * + * // value must be greater than 5 and less than 10 [sfixed64.gt_lt] + * sfixed64 other_value = 2 [(buf.validate.field).sfixed64 = { gt: 5, lt: 10 }]; + * + * // value must be greater than 10 or less than 5 [sfixed64.gt_lt_exclusive] + * sfixed64 another_value = 3 [(buf.validate.field).sfixed64 = { gt: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: sfixed64 gt = 4; + */ + value: bigint; + case: "gt"; + } | { + /** + * `gte` requires the field value to be greater than or equal to the specified + * value (exclusive). If the value of `gte` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MySFixed64 { + * // value must be greater than or equal to 5 [sfixed64.gte] + * sfixed64 value = 1 [(buf.validate.field).sfixed64.gte = 5]; + * + * // value must be greater than or equal to 5 and less than 10 [sfixed64.gte_lt] + * sfixed64 other_value = 2 [(buf.validate.field).sfixed64 = { gte: 5, lt: 10 }]; + * + * // value must be greater than or equal to 10 or less than 5 [sfixed64.gte_lt_exclusive] + * sfixed64 another_value = 3 [(buf.validate.field).sfixed64 = { gte: 10, lt: 5 }]; + * } + * ``` + * + * @generated from field: sfixed64 gte = 5; + */ + value: bigint; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` requires the field value to be equal to one of the specified values. + * If the field value isn't one of the specified values, an error message is + * generated. + * + * ```proto + * message MySFixed64 { + * // value must be in list [1, 2, 3] + * sfixed64 value = 1 [(buf.validate.field).sfixed64 = { in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated sfixed64 in = 6; + */ + in: bigint[]; + + /** + * `not_in` requires the field value to not be equal to any of the specified + * values. If the field value is one of the specified values, an error + * message is generated. + * + * ```proto + * message MySFixed64 { + * // value must not be in list [1, 2, 3] + * sfixed64 value = 1 [(buf.validate.field).sfixed64 = { not_in: [1, 2, 3] }]; + * } + * ``` + * + * @generated from field: repeated sfixed64 not_in = 7; + */ + notIn: bigint[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MySFixed64 { + * sfixed64 value = 1 [ + * (buf.validate.field).sfixed64.example = 1, + * (buf.validate.field).sfixed64.example = 2 + * ]; + * } + * ``` + * + * @generated from field: repeated sfixed64 example = 8; + */ + example: bigint[]; +}; + +/** + * Describes the message buf.validate.SFixed64Rules. + * Use `create(SFixed64RulesSchema)` to create a new message. + */ +export const SFixed64RulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 17); + +/** + * BoolRules describes the rules applied to `bool` values. These rules + * may also be applied to the `google.protobuf.BoolValue` Well-Known-Type. + * + * @generated from message buf.validate.BoolRules + */ +export type BoolRules = Message<"buf.validate.BoolRules"> & { + /** + * `const` requires the field value to exactly match the specified boolean value. + * If the field value doesn't match, an error message is generated. + * + * ```proto + * message MyBool { + * // value must equal true + * bool value = 1 [(buf.validate.field).bool.const = true]; + * } + * ``` + * + * @generated from field: optional bool const = 1; + */ + const: boolean; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyBool { + * bool value = 1 [ + * (buf.validate.field).bool.example = 1, + * (buf.validate.field).bool.example = 2 + * ]; + * } + * ``` + * + * @generated from field: repeated bool example = 2; + */ + example: boolean[]; +}; + +/** + * Describes the message buf.validate.BoolRules. + * Use `create(BoolRulesSchema)` to create a new message. + */ +export const BoolRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 18); + +/** + * StringRules describes the rules applied to `string` values These + * rules may also be applied to the `google.protobuf.StringValue` Well-Known-Type. + * + * @generated from message buf.validate.StringRules + */ +export type StringRules = Message<"buf.validate.StringRules"> & { + /** + * `const` requires the field value to exactly match the specified value. If + * the field value doesn't match, an error message is generated. + * + * ```proto + * message MyString { + * // value must equal `hello` + * string value = 1 [(buf.validate.field).string.const = "hello"]; + * } + * ``` + * + * @generated from field: optional string const = 1; + */ + const: string; + + /** + * `len` dictates that the field value must have the specified + * number of characters (Unicode code points), which may differ from the number + * of bytes in the string. If the field value does not meet the specified + * length, an error message will be generated. + * + * ```proto + * message MyString { + * // value length must be 5 characters + * string value = 1 [(buf.validate.field).string.len = 5]; + * } + * ``` + * + * @generated from field: optional uint64 len = 19; + */ + len: bigint; + + /** + * `min_len` specifies that the field value must have at least the specified + * number of characters (Unicode code points), which may differ from the number + * of bytes in the string. If the field value contains fewer characters, an error + * message will be generated. + * + * ```proto + * message MyString { + * // value length must be at least 3 characters + * string value = 1 [(buf.validate.field).string.min_len = 3]; + * } + * ``` + * + * @generated from field: optional uint64 min_len = 2; + */ + minLen: bigint; + + /** + * `max_len` specifies that the field value must have no more than the specified + * number of characters (Unicode code points), which may differ from the + * number of bytes in the string. If the field value contains more characters, + * an error message will be generated. + * + * ```proto + * message MyString { + * // value length must be at most 10 characters + * string value = 1 [(buf.validate.field).string.max_len = 10]; + * } + * ``` + * + * @generated from field: optional uint64 max_len = 3; + */ + maxLen: bigint; + + /** + * `len_bytes` dictates that the field value must have the specified number of + * bytes. If the field value does not match the specified length in bytes, + * an error message will be generated. + * + * ```proto + * message MyString { + * // value length must be 6 bytes + * string value = 1 [(buf.validate.field).string.len_bytes = 6]; + * } + * ``` + * + * @generated from field: optional uint64 len_bytes = 20; + */ + lenBytes: bigint; + + /** + * `min_bytes` specifies that the field value must have at least the specified + * number of bytes. If the field value contains fewer bytes, an error message + * will be generated. + * + * ```proto + * message MyString { + * // value length must be at least 4 bytes + * string value = 1 [(buf.validate.field).string.min_bytes = 4]; + * } + * + * ``` + * + * @generated from field: optional uint64 min_bytes = 4; + */ + minBytes: bigint; + + /** + * `max_bytes` specifies that the field value must have no more than the + * specified number of bytes. If the field value contains more bytes, an + * error message will be generated. + * + * ```proto + * message MyString { + * // value length must be at most 8 bytes + * string value = 1 [(buf.validate.field).string.max_bytes = 8]; + * } + * ``` + * + * @generated from field: optional uint64 max_bytes = 5; + */ + maxBytes: bigint; + + /** + * `pattern` specifies that the field value must match the specified + * regular expression (RE2 syntax), with the expression provided without any + * delimiters. If the field value doesn't match the regular expression, an + * error message will be generated. + * + * ```proto + * message MyString { + * // value does not match regex pattern `^[a-zA-Z]//$` + * string value = 1 [(buf.validate.field).string.pattern = "^[a-zA-Z]//$"]; + * } + * ``` + * + * @generated from field: optional string pattern = 6; + */ + pattern: string; + + /** + * `prefix` specifies that the field value must have the + * specified substring at the beginning of the string. If the field value + * doesn't start with the specified prefix, an error message will be + * generated. + * + * ```proto + * message MyString { + * // value does not have prefix `pre` + * string value = 1 [(buf.validate.field).string.prefix = "pre"]; + * } + * ``` + * + * @generated from field: optional string prefix = 7; + */ + prefix: string; + + /** + * `suffix` specifies that the field value must have the + * specified substring at the end of the string. If the field value doesn't + * end with the specified suffix, an error message will be generated. + * + * ```proto + * message MyString { + * // value does not have suffix `post` + * string value = 1 [(buf.validate.field).string.suffix = "post"]; + * } + * ``` + * + * @generated from field: optional string suffix = 8; + */ + suffix: string; + + /** + * `contains` specifies that the field value must have the + * specified substring anywhere in the string. If the field value doesn't + * contain the specified substring, an error message will be generated. + * + * ```proto + * message MyString { + * // value does not contain substring `inside`. + * string value = 1 [(buf.validate.field).string.contains = "inside"]; + * } + * ``` + * + * @generated from field: optional string contains = 9; + */ + contains: string; + + /** + * `not_contains` specifies that the field value must not have the + * specified substring anywhere in the string. If the field value contains + * the specified substring, an error message will be generated. + * + * ```proto + * message MyString { + * // value contains substring `inside`. + * string value = 1 [(buf.validate.field).string.not_contains = "inside"]; + * } + * ``` + * + * @generated from field: optional string not_contains = 23; + */ + notContains: string; + + /** + * `in` specifies that the field value must be equal to one of the specified + * values. If the field value isn't one of the specified values, an error + * message will be generated. + * + * ```proto + * message MyString { + * // value must be in list ["apple", "banana"] + * string value = 1 [(buf.validate.field).string.in = "apple", (buf.validate.field).string.in = "banana"]; + * } + * ``` + * + * @generated from field: repeated string in = 10; + */ + in: string[]; + + /** + * `not_in` specifies that the field value cannot be equal to any + * of the specified values. If the field value is one of the specified values, + * an error message will be generated. + * ```proto + * message MyString { + * // value must not be in list ["orange", "grape"] + * string value = 1 [(buf.validate.field).string.not_in = "orange", (buf.validate.field).string.not_in = "grape"]; + * } + * ``` + * + * @generated from field: repeated string not_in = 11; + */ + notIn: string[]; + + /** + * `WellKnown` rules provide advanced rules against common string + * patterns. + * + * @generated from oneof buf.validate.StringRules.well_known + */ + wellKnown: { + /** + * `email` specifies that the field value must be a valid email address, for + * example "foo@example.com". + * + * Conforms to the definition for a valid email address from the [HTML standard](https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address). + * Note that this standard willfully deviates from [RFC 5322](https://datatracker.ietf.org/doc/html/rfc5322), + * which allows many unexpected forms of email addresses and will easily match + * a typographical error. + * + * If the field value isn't a valid email address, an error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid email address + * string value = 1 [(buf.validate.field).string.email = true]; + * } + * ``` + * + * @generated from field: bool email = 12; + */ + value: boolean; + case: "email"; + } | { + /** + * `hostname` specifies that the field value must be a valid hostname, for + * example "foo.example.com". + * + * A valid hostname follows the rules below: + * - The name consists of one or more labels, separated by a dot ("."). + * - Each label can be 1 to 63 alphanumeric characters. + * - A label can contain hyphens ("-"), but must not start or end with a hyphen. + * - The right-most label must not be digits only. + * - The name can have a trailing dotโ€”for example, "foo.example.com.". + * - The name can be 253 characters at most, excluding the optional trailing dot. + * + * If the field value isn't a valid hostname, an error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid hostname + * string value = 1 [(buf.validate.field).string.hostname = true]; + * } + * ``` + * + * @generated from field: bool hostname = 13; + */ + value: boolean; + case: "hostname"; + } | { + /** + * `ip` specifies that the field value must be a valid IP (v4 or v6) address. + * + * IPv4 addresses are expected in the dotted decimal formatโ€”for example, "192.168.5.21". + * IPv6 addresses are expected in their text representationโ€”for example, "::1", + * or "2001:0DB8:ABCD:0012::0". + * + * Both formats are well-defined in the internet standard [RFC 3986](https://datatracker.ietf.org/doc/html/rfc3986). + * Zone identifiers for IPv6 addresses (for example, "fe80::a%en1") are supported. + * + * If the field value isn't a valid IP address, an error message will be + * generated. + * + * ```proto + * message MyString { + * // value must be a valid IP address + * string value = 1 [(buf.validate.field).string.ip = true]; + * } + * ``` + * + * @generated from field: bool ip = 14; + */ + value: boolean; + case: "ip"; + } | { + /** + * `ipv4` specifies that the field value must be a valid IPv4 addressโ€”for + * example "192.168.5.21". If the field value isn't a valid IPv4 address, an + * error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid IPv4 address + * string value = 1 [(buf.validate.field).string.ipv4 = true]; + * } + * ``` + * + * @generated from field: bool ipv4 = 15; + */ + value: boolean; + case: "ipv4"; + } | { + /** + * `ipv6` specifies that the field value must be a valid IPv6 addressโ€”for + * example "::1", or "d7a:115c:a1e0:ab12:4843:cd96:626b:430b". If the field + * value is not a valid IPv6 address, an error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid IPv6 address + * string value = 1 [(buf.validate.field).string.ipv6 = true]; + * } + * ``` + * + * @generated from field: bool ipv6 = 16; + */ + value: boolean; + case: "ipv6"; + } | { + /** + * `uri` specifies that the field value must be a valid URI, for example + * "https://example.com/foo/bar?baz=quux#frag". + * + * URI is defined in the internet standard [RFC 3986](https://datatracker.ietf.org/doc/html/rfc3986). + * Zone Identifiers in IPv6 address literals are supported ([RFC 6874](https://datatracker.ietf.org/doc/html/rfc6874)). + * + * If the field value isn't a valid URI, an error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid URI + * string value = 1 [(buf.validate.field).string.uri = true]; + * } + * ``` + * + * @generated from field: bool uri = 17; + */ + value: boolean; + case: "uri"; + } | { + /** + * `uri_ref` specifies that the field value must be a valid URI Referenceโ€”either + * a URI such as "https://example.com/foo/bar?baz=quux#frag", or a Relative + * Reference such as "./foo/bar?query". + * + * URI, URI Reference, and Relative Reference are defined in the internet + * standard [RFC 3986](https://datatracker.ietf.org/doc/html/rfc3986). Zone + * Identifiers in IPv6 address literals are supported ([RFC 6874](https://datatracker.ietf.org/doc/html/rfc6874)). + * + * If the field value isn't a valid URI Reference, an error message will be + * generated. + * + * ```proto + * message MyString { + * // value must be a valid URI Reference + * string value = 1 [(buf.validate.field).string.uri_ref = true]; + * } + * ``` + * + * @generated from field: bool uri_ref = 18; + */ + value: boolean; + case: "uriRef"; + } | { + /** + * `address` specifies that the field value must be either a valid hostname + * (for example, "example.com"), or a valid IP (v4 or v6) address (for example, + * "192.168.0.1", or "::1"). If the field value isn't a valid hostname or IP, + * an error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid hostname, or ip address + * string value = 1 [(buf.validate.field).string.address = true]; + * } + * ``` + * + * @generated from field: bool address = 21; + */ + value: boolean; + case: "address"; + } | { + /** + * `uuid` specifies that the field value must be a valid UUID as defined by + * [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.2). If the + * field value isn't a valid UUID, an error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid UUID + * string value = 1 [(buf.validate.field).string.uuid = true]; + * } + * ``` + * + * @generated from field: bool uuid = 22; + */ + value: boolean; + case: "uuid"; + } | { + /** + * `tuuid` (trimmed UUID) specifies that the field value must be a valid UUID as + * defined by [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.2) with all dashes + * omitted. If the field value isn't a valid UUID without dashes, an error message + * will be generated. + * + * ```proto + * message MyString { + * // value must be a valid trimmed UUID + * string value = 1 [(buf.validate.field).string.tuuid = true]; + * } + * ``` + * + * @generated from field: bool tuuid = 33; + */ + value: boolean; + case: "tuuid"; + } | { + /** + * `ip_with_prefixlen` specifies that the field value must be a valid IP + * (v4 or v6) address with prefix lengthโ€”for example, "192.168.5.21/16" or + * "2001:0DB8:ABCD:0012::F1/64". If the field value isn't a valid IP with + * prefix length, an error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid IP with prefix length + * string value = 1 [(buf.validate.field).string.ip_with_prefixlen = true]; + * } + * ``` + * + * @generated from field: bool ip_with_prefixlen = 26; + */ + value: boolean; + case: "ipWithPrefixlen"; + } | { + /** + * `ipv4_with_prefixlen` specifies that the field value must be a valid + * IPv4 address with prefix lengthโ€”for example, "192.168.5.21/16". If the + * field value isn't a valid IPv4 address with prefix length, an error + * message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid IPv4 address with prefix length + * string value = 1 [(buf.validate.field).string.ipv4_with_prefixlen = true]; + * } + * ``` + * + * @generated from field: bool ipv4_with_prefixlen = 27; + */ + value: boolean; + case: "ipv4WithPrefixlen"; + } | { + /** + * `ipv6_with_prefixlen` specifies that the field value must be a valid + * IPv6 address with prefix lengthโ€”for example, "2001:0DB8:ABCD:0012::F1/64". + * If the field value is not a valid IPv6 address with prefix length, + * an error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid IPv6 address prefix length + * string value = 1 [(buf.validate.field).string.ipv6_with_prefixlen = true]; + * } + * ``` + * + * @generated from field: bool ipv6_with_prefixlen = 28; + */ + value: boolean; + case: "ipv6WithPrefixlen"; + } | { + /** + * `ip_prefix` specifies that the field value must be a valid IP (v4 or v6) + * prefixโ€”for example, "192.168.0.0/16" or "2001:0DB8:ABCD:0012::0/64". + * + * The prefix must have all zeros for the unmasked bits. For example, + * "2001:0DB8:ABCD:0012::0/64" designates the left-most 64 bits for the + * prefix, and the remaining 64 bits must be zero. + * + * If the field value isn't a valid IP prefix, an error message will be + * generated. + * + * ```proto + * message MyString { + * // value must be a valid IP prefix + * string value = 1 [(buf.validate.field).string.ip_prefix = true]; + * } + * ``` + * + * @generated from field: bool ip_prefix = 29; + */ + value: boolean; + case: "ipPrefix"; + } | { + /** + * `ipv4_prefix` specifies that the field value must be a valid IPv4 + * prefix, for example "192.168.0.0/16". + * + * The prefix must have all zeros for the unmasked bits. For example, + * "192.168.0.0/16" designates the left-most 16 bits for the prefix, + * and the remaining 16 bits must be zero. + * + * If the field value isn't a valid IPv4 prefix, an error message + * will be generated. + * + * ```proto + * message MyString { + * // value must be a valid IPv4 prefix + * string value = 1 [(buf.validate.field).string.ipv4_prefix = true]; + * } + * ``` + * + * @generated from field: bool ipv4_prefix = 30; + */ + value: boolean; + case: "ipv4Prefix"; + } | { + /** + * `ipv6_prefix` specifies that the field value must be a valid IPv6 prefixโ€”for + * example, "2001:0DB8:ABCD:0012::0/64". + * + * The prefix must have all zeros for the unmasked bits. For example, + * "2001:0DB8:ABCD:0012::0/64" designates the left-most 64 bits for the + * prefix, and the remaining 64 bits must be zero. + * + * If the field value is not a valid IPv6 prefix, an error message will be + * generated. + * + * ```proto + * message MyString { + * // value must be a valid IPv6 prefix + * string value = 1 [(buf.validate.field).string.ipv6_prefix = true]; + * } + * ``` + * + * @generated from field: bool ipv6_prefix = 31; + */ + value: boolean; + case: "ipv6Prefix"; + } | { + /** + * `host_and_port` specifies that the field value must be valid host/port + * pairโ€”for example, "example.com:8080". + * + * The host can be one of: + * - An IPv4 address in dotted decimal formatโ€”for example, "192.168.5.21". + * - An IPv6 address enclosed in square bracketsโ€”for example, "[2001:0DB8:ABCD:0012::F1]". + * - A hostnameโ€”for example, "example.com". + * + * The port is separated by a colon. It must be non-empty, with a decimal number + * in the range of 0-65535, inclusive. + * + * @generated from field: bool host_and_port = 32; + */ + value: boolean; + case: "hostAndPort"; + } | { + /** + * `well_known_regex` specifies a common well-known pattern + * defined as a regex. If the field value doesn't match the well-known + * regex, an error message will be generated. + * + * ```proto + * message MyString { + * // value must be a valid HTTP header value + * string value = 1 [(buf.validate.field).string.well_known_regex = KNOWN_REGEX_HTTP_HEADER_VALUE]; + * } + * ``` + * + * #### KnownRegex + * + * `well_known_regex` contains some well-known patterns. + * + * | Name | Number | Description | + * |-------------------------------|--------|-------------------------------------------| + * | KNOWN_REGEX_UNSPECIFIED | 0 | | + * | KNOWN_REGEX_HTTP_HEADER_NAME | 1 | HTTP header name as defined by [RFC 7230](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2) | + * | KNOWN_REGEX_HTTP_HEADER_VALUE | 2 | HTTP header value as defined by [RFC 7230](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.4) | + * + * @generated from field: buf.validate.KnownRegex well_known_regex = 24; + */ + value: KnownRegex; + case: "wellKnownRegex"; + } | { case: undefined; value?: undefined }; + + /** + * This applies to regexes `HTTP_HEADER_NAME` and `HTTP_HEADER_VALUE` to + * enable strict header validation. By default, this is true, and HTTP header + * validations are [RFC-compliant](https://datatracker.ietf.org/doc/html/rfc7230#section-3). Setting to false will enable looser + * validations that only disallow `\r\n\0` characters, which can be used to + * bypass header matching rules. + * + * ```proto + * message MyString { + * // The field `value` must have be a valid HTTP headers, but not enforced with strict rules. + * string value = 1 [(buf.validate.field).string.strict = false]; + * } + * ``` + * + * @generated from field: optional bool strict = 25; + */ + strict: boolean; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyString { + * string value = 1 [ + * (buf.validate.field).string.example = "hello", + * (buf.validate.field).string.example = "world" + * ]; + * } + * ``` + * + * @generated from field: repeated string example = 34; + */ + example: string[]; +}; + +/** + * Describes the message buf.validate.StringRules. + * Use `create(StringRulesSchema)` to create a new message. + */ +export const StringRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 19); + +/** + * BytesRules describe the rules applied to `bytes` values. These rules + * may also be applied to the `google.protobuf.BytesValue` Well-Known-Type. + * + * @generated from message buf.validate.BytesRules + */ +export type BytesRules = Message<"buf.validate.BytesRules"> & { + /** + * `const` requires the field value to exactly match the specified bytes + * value. If the field value doesn't match, an error message is generated. + * + * ```proto + * message MyBytes { + * // value must be "\x01\x02\x03\x04" + * bytes value = 1 [(buf.validate.field).bytes.const = "\x01\x02\x03\x04"]; + * } + * ``` + * + * @generated from field: optional bytes const = 1; + */ + const: Uint8Array; + + /** + * `len` requires the field value to have the specified length in bytes. + * If the field value doesn't match, an error message is generated. + * + * ```proto + * message MyBytes { + * // value length must be 4 bytes. + * optional bytes value = 1 [(buf.validate.field).bytes.len = 4]; + * } + * ``` + * + * @generated from field: optional uint64 len = 13; + */ + len: bigint; + + /** + * `min_len` requires the field value to have at least the specified minimum + * length in bytes. + * If the field value doesn't meet the requirement, an error message is generated. + * + * ```proto + * message MyBytes { + * // value length must be at least 2 bytes. + * optional bytes value = 1 [(buf.validate.field).bytes.min_len = 2]; + * } + * ``` + * + * @generated from field: optional uint64 min_len = 2; + */ + minLen: bigint; + + /** + * `max_len` requires the field value to have at most the specified maximum + * length in bytes. + * If the field value exceeds the requirement, an error message is generated. + * + * ```proto + * message MyBytes { + * // value must be at most 6 bytes. + * optional bytes value = 1 [(buf.validate.field).bytes.max_len = 6]; + * } + * ``` + * + * @generated from field: optional uint64 max_len = 3; + */ + maxLen: bigint; + + /** + * `pattern` requires the field value to match the specified regular + * expression ([RE2 syntax](https://github.com/google/re2/wiki/Syntax)). + * The value of the field must be valid UTF-8 or validation will fail with a + * runtime error. + * If the field value doesn't match the pattern, an error message is generated. + * + * ```proto + * message MyBytes { + * // value must match regex pattern "^[a-zA-Z0-9]+$". + * optional bytes value = 1 [(buf.validate.field).bytes.pattern = "^[a-zA-Z0-9]+$"]; + * } + * ``` + * + * @generated from field: optional string pattern = 4; + */ + pattern: string; + + /** + * `prefix` requires the field value to have the specified bytes at the + * beginning of the string. + * If the field value doesn't meet the requirement, an error message is generated. + * + * ```proto + * message MyBytes { + * // value does not have prefix \x01\x02 + * optional bytes value = 1 [(buf.validate.field).bytes.prefix = "\x01\x02"]; + * } + * ``` + * + * @generated from field: optional bytes prefix = 5; + */ + prefix: Uint8Array; + + /** + * `suffix` requires the field value to have the specified bytes at the end + * of the string. + * If the field value doesn't meet the requirement, an error message is generated. + * + * ```proto + * message MyBytes { + * // value does not have suffix \x03\x04 + * optional bytes value = 1 [(buf.validate.field).bytes.suffix = "\x03\x04"]; + * } + * ``` + * + * @generated from field: optional bytes suffix = 6; + */ + suffix: Uint8Array; + + /** + * `contains` requires the field value to have the specified bytes anywhere in + * the string. + * If the field value doesn't meet the requirement, an error message is generated. + * + * ```protobuf + * message MyBytes { + * // value does not contain \x02\x03 + * optional bytes value = 1 [(buf.validate.field).bytes.contains = "\x02\x03"]; + * } + * ``` + * + * @generated from field: optional bytes contains = 7; + */ + contains: Uint8Array; + + /** + * `in` requires the field value to be equal to one of the specified + * values. If the field value doesn't match any of the specified values, an + * error message is generated. + * + * ```protobuf + * message MyBytes { + * // value must in ["\x01\x02", "\x02\x03", "\x03\x04"] + * optional bytes value = 1 [(buf.validate.field).bytes.in = {"\x01\x02", "\x02\x03", "\x03\x04"}]; + * } + * ``` + * + * @generated from field: repeated bytes in = 8; + */ + in: Uint8Array[]; + + /** + * `not_in` requires the field value to be not equal to any of the specified + * values. + * If the field value matches any of the specified values, an error message is + * generated. + * + * ```proto + * message MyBytes { + * // value must not in ["\x01\x02", "\x02\x03", "\x03\x04"] + * optional bytes value = 1 [(buf.validate.field).bytes.not_in = {"\x01\x02", "\x02\x03", "\x03\x04"}]; + * } + * ``` + * + * @generated from field: repeated bytes not_in = 9; + */ + notIn: Uint8Array[]; + + /** + * WellKnown rules provide advanced rules against common byte + * patterns + * + * @generated from oneof buf.validate.BytesRules.well_known + */ + wellKnown: { + /** + * `ip` ensures that the field `value` is a valid IP address (v4 or v6) in byte format. + * If the field value doesn't meet this rule, an error message is generated. + * + * ```proto + * message MyBytes { + * // value must be a valid IP address + * optional bytes value = 1 [(buf.validate.field).bytes.ip = true]; + * } + * ``` + * + * @generated from field: bool ip = 10; + */ + value: boolean; + case: "ip"; + } | { + /** + * `ipv4` ensures that the field `value` is a valid IPv4 address in byte format. + * If the field value doesn't meet this rule, an error message is generated. + * + * ```proto + * message MyBytes { + * // value must be a valid IPv4 address + * optional bytes value = 1 [(buf.validate.field).bytes.ipv4 = true]; + * } + * ``` + * + * @generated from field: bool ipv4 = 11; + */ + value: boolean; + case: "ipv4"; + } | { + /** + * `ipv6` ensures that the field `value` is a valid IPv6 address in byte format. + * If the field value doesn't meet this rule, an error message is generated. + * ```proto + * message MyBytes { + * // value must be a valid IPv6 address + * optional bytes value = 1 [(buf.validate.field).bytes.ipv6 = true]; + * } + * ``` + * + * @generated from field: bool ipv6 = 12; + */ + value: boolean; + case: "ipv6"; + } | { case: undefined; value?: undefined }; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyBytes { + * bytes value = 1 [ + * (buf.validate.field).bytes.example = "\x01\x02", + * (buf.validate.field).bytes.example = "\x02\x03" + * ]; + * } + * ``` + * + * @generated from field: repeated bytes example = 14; + */ + example: Uint8Array[]; +}; + +/** + * Describes the message buf.validate.BytesRules. + * Use `create(BytesRulesSchema)` to create a new message. + */ +export const BytesRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 20); + +/** + * EnumRules describe the rules applied to `enum` values. + * + * @generated from message buf.validate.EnumRules + */ +export type EnumRules = Message<"buf.validate.EnumRules"> & { + /** + * `const` requires the field value to exactly match the specified enum value. + * If the field value doesn't match, an error message is generated. + * + * ```proto + * enum MyEnum { + * MY_ENUM_UNSPECIFIED = 0; + * MY_ENUM_VALUE1 = 1; + * MY_ENUM_VALUE2 = 2; + * } + * + * message MyMessage { + * // The field `value` must be exactly MY_ENUM_VALUE1. + * MyEnum value = 1 [(buf.validate.field).enum.const = 1]; + * } + * ``` + * + * @generated from field: optional int32 const = 1; + */ + const: number; + + /** + * `defined_only` requires the field value to be one of the defined values for + * this enum, failing on any undefined value. + * + * ```proto + * enum MyEnum { + * MY_ENUM_UNSPECIFIED = 0; + * MY_ENUM_VALUE1 = 1; + * MY_ENUM_VALUE2 = 2; + * } + * + * message MyMessage { + * // The field `value` must be a defined value of MyEnum. + * MyEnum value = 1 [(buf.validate.field).enum.defined_only = true]; + * } + * ``` + * + * @generated from field: optional bool defined_only = 2; + */ + definedOnly: boolean; + + /** + * `in` requires the field value to be equal to one of the + * specified enum values. If the field value doesn't match any of the + * specified values, an error message is generated. + * + * ```proto + * enum MyEnum { + * MY_ENUM_UNSPECIFIED = 0; + * MY_ENUM_VALUE1 = 1; + * MY_ENUM_VALUE2 = 2; + * } + * + * message MyMessage { + * // The field `value` must be equal to one of the specified values. + * MyEnum value = 1 [(buf.validate.field).enum = { in: [1, 2]}]; + * } + * ``` + * + * @generated from field: repeated int32 in = 3; + */ + in: number[]; + + /** + * `not_in` requires the field value to be not equal to any of the + * specified enum values. If the field value matches one of the specified + * values, an error message is generated. + * + * ```proto + * enum MyEnum { + * MY_ENUM_UNSPECIFIED = 0; + * MY_ENUM_VALUE1 = 1; + * MY_ENUM_VALUE2 = 2; + * } + * + * message MyMessage { + * // The field `value` must not be equal to any of the specified values. + * MyEnum value = 1 [(buf.validate.field).enum = { not_in: [1, 2]}]; + * } + * ``` + * + * @generated from field: repeated int32 not_in = 4; + */ + notIn: number[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * enum MyEnum { + * MY_ENUM_UNSPECIFIED = 0; + * MY_ENUM_VALUE1 = 1; + * MY_ENUM_VALUE2 = 2; + * } + * + * message MyMessage { + * (buf.validate.field).enum.example = 1, + * (buf.validate.field).enum.example = 2 + * } + * ``` + * + * @generated from field: repeated int32 example = 5; + */ + example: number[]; +}; + +/** + * Describes the message buf.validate.EnumRules. + * Use `create(EnumRulesSchema)` to create a new message. + */ +export const EnumRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 21); + +/** + * RepeatedRules describe the rules applied to `repeated` values. + * + * @generated from message buf.validate.RepeatedRules + */ +export type RepeatedRules = Message<"buf.validate.RepeatedRules"> & { + /** + * `min_items` requires that this field must contain at least the specified + * minimum number of items. + * + * Note that `min_items = 1` is equivalent to setting a field as `required`. + * + * ```proto + * message MyRepeated { + * // value must contain at least 2 items + * repeated string value = 1 [(buf.validate.field).repeated.min_items = 2]; + * } + * ``` + * + * @generated from field: optional uint64 min_items = 1; + */ + minItems: bigint; + + /** + * `max_items` denotes that this field must not exceed a + * certain number of items as the upper limit. If the field contains more + * items than specified, an error message will be generated, requiring the + * field to maintain no more than the specified number of items. + * + * ```proto + * message MyRepeated { + * // value must contain no more than 3 item(s) + * repeated string value = 1 [(buf.validate.field).repeated.max_items = 3]; + * } + * ``` + * + * @generated from field: optional uint64 max_items = 2; + */ + maxItems: bigint; + + /** + * `unique` indicates that all elements in this field must + * be unique. This rule is strictly applicable to scalar and enum + * types, with message types not being supported. + * + * ```proto + * message MyRepeated { + * // repeated value must contain unique items + * repeated string value = 1 [(buf.validate.field).repeated.unique = true]; + * } + * ``` + * + * @generated from field: optional bool unique = 3; + */ + unique: boolean; + + /** + * `items` details the rules to be applied to each item + * in the field. Even for repeated message fields, validation is executed + * against each item unless `ignore` is specified. + * + * ```proto + * message MyRepeated { + * // The items in the field `value` must follow the specified rules. + * repeated string value = 1 [(buf.validate.field).repeated.items = { + * string: { + * min_len: 3 + * max_len: 10 + * } + * }]; + * } + * ``` + * + * Note that the `required` rule does not apply. Repeated items + * cannot be unset. + * + * @generated from field: optional buf.validate.FieldRules items = 4; + */ + items?: FieldRules; +}; + +/** + * Describes the message buf.validate.RepeatedRules. + * Use `create(RepeatedRulesSchema)` to create a new message. + */ +export const RepeatedRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 22); + +/** + * MapRules describe the rules applied to `map` values. + * + * @generated from message buf.validate.MapRules + */ +export type MapRules = Message<"buf.validate.MapRules"> & { + /** + * Specifies the minimum number of key-value pairs allowed. If the field has + * fewer key-value pairs than specified, an error message is generated. + * + * ```proto + * message MyMap { + * // The field `value` must have at least 2 key-value pairs. + * map value = 1 [(buf.validate.field).map.min_pairs = 2]; + * } + * ``` + * + * @generated from field: optional uint64 min_pairs = 1; + */ + minPairs: bigint; + + /** + * Specifies the maximum number of key-value pairs allowed. If the field has + * more key-value pairs than specified, an error message is generated. + * + * ```proto + * message MyMap { + * // The field `value` must have at most 3 key-value pairs. + * map value = 1 [(buf.validate.field).map.max_pairs = 3]; + * } + * ``` + * + * @generated from field: optional uint64 max_pairs = 2; + */ + maxPairs: bigint; + + /** + * Specifies the rules to be applied to each key in the field. + * + * ```proto + * message MyMap { + * // The keys in the field `value` must follow the specified rules. + * map value = 1 [(buf.validate.field).map.keys = { + * string: { + * min_len: 3 + * max_len: 10 + * } + * }]; + * } + * ``` + * + * Note that the `required` rule does not apply. Map keys cannot be unset. + * + * @generated from field: optional buf.validate.FieldRules keys = 4; + */ + keys?: FieldRules; + + /** + * Specifies the rules to be applied to the value of each key in the + * field. Message values will still have their validations evaluated unless + * `ignore` is specified. + * + * ```proto + * message MyMap { + * // The values in the field `value` must follow the specified rules. + * map value = 1 [(buf.validate.field).map.values = { + * string: { + * min_len: 5 + * max_len: 20 + * } + * }]; + * } + * ``` + * Note that the `required` rule does not apply. Map values cannot be unset. + * + * @generated from field: optional buf.validate.FieldRules values = 5; + */ + values?: FieldRules; +}; + +/** + * Describes the message buf.validate.MapRules. + * Use `create(MapRulesSchema)` to create a new message. + */ +export const MapRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 23); + +/** + * AnyRules describe rules applied exclusively to the `google.protobuf.Any` well-known type. + * + * @generated from message buf.validate.AnyRules + */ +export type AnyRules = Message<"buf.validate.AnyRules"> & { + /** + * `in` requires the field's `type_url` to be equal to one of the + * specified values. If it doesn't match any of the specified values, an error + * message is generated. + * + * ```proto + * message MyAny { + * // The `value` field must have a `type_url` equal to one of the specified values. + * google.protobuf.Any value = 1 [(buf.validate.field).any = { + * in: ["type.googleapis.com/MyType1", "type.googleapis.com/MyType2"] + * }]; + * } + * ``` + * + * @generated from field: repeated string in = 2; + */ + in: string[]; + + /** + * requires the field's type_url to be not equal to any of the specified values. If it matches any of the specified values, an error message is generated. + * + * ```proto + * message MyAny { + * // The `value` field must not have a `type_url` equal to any of the specified values. + * google.protobuf.Any value = 1 [(buf.validate.field).any = { + * not_in: ["type.googleapis.com/ForbiddenType1", "type.googleapis.com/ForbiddenType2"] + * }]; + * } + * ``` + * + * @generated from field: repeated string not_in = 3; + */ + notIn: string[]; +}; + +/** + * Describes the message buf.validate.AnyRules. + * Use `create(AnyRulesSchema)` to create a new message. + */ +export const AnyRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 24); + +/** + * DurationRules describe the rules applied exclusively to the `google.protobuf.Duration` well-known type. + * + * @generated from message buf.validate.DurationRules + */ +export type DurationRules = Message<"buf.validate.DurationRules"> & { + /** + * `const` dictates that the field must match the specified value of the `google.protobuf.Duration` type exactly. + * If the field's value deviates from the specified value, an error message + * will be generated. + * + * ```proto + * message MyDuration { + * // value must equal 5s + * google.protobuf.Duration value = 1 [(buf.validate.field).duration.const = "5s"]; + * } + * ``` + * + * @generated from field: optional google.protobuf.Duration const = 2; + */ + const?: Duration; + + /** + * @generated from oneof buf.validate.DurationRules.less_than + */ + lessThan: { + /** + * `lt` stipulates that the field must be less than the specified value of the `google.protobuf.Duration` type, + * exclusive. If the field's value is greater than or equal to the specified + * value, an error message will be generated. + * + * ```proto + * message MyDuration { + * // value must be less than 5s + * google.protobuf.Duration value = 1 [(buf.validate.field).duration.lt = "5s"]; + * } + * ``` + * + * @generated from field: google.protobuf.Duration lt = 3; + */ + value: Duration; + case: "lt"; + } | { + /** + * `lte` indicates that the field must be less than or equal to the specified + * value of the `google.protobuf.Duration` type, inclusive. If the field's value is greater than the specified value, + * an error message will be generated. + * + * ```proto + * message MyDuration { + * // value must be less than or equal to 10s + * google.protobuf.Duration value = 1 [(buf.validate.field).duration.lte = "10s"]; + * } + * ``` + * + * @generated from field: google.protobuf.Duration lte = 4; + */ + value: Duration; + case: "lte"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.DurationRules.greater_than + */ + greaterThan: { + /** + * `gt` requires the duration field value to be greater than the specified + * value (exclusive). If the value of `gt` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyDuration { + * // duration must be greater than 5s [duration.gt] + * google.protobuf.Duration value = 1 [(buf.validate.field).duration.gt = { seconds: 5 }]; + * + * // duration must be greater than 5s and less than 10s [duration.gt_lt] + * google.protobuf.Duration another_value = 2 [(buf.validate.field).duration = { gt: { seconds: 5 }, lt: { seconds: 10 } }]; + * + * // duration must be greater than 10s or less than 5s [duration.gt_lt_exclusive] + * google.protobuf.Duration other_value = 3 [(buf.validate.field).duration = { gt: { seconds: 10 }, lt: { seconds: 5 } }]; + * } + * ``` + * + * @generated from field: google.protobuf.Duration gt = 5; + */ + value: Duration; + case: "gt"; + } | { + /** + * `gte` requires the duration field value to be greater than or equal to the + * specified value (exclusive). If the value of `gte` is larger than a + * specified `lt` or `lte`, the range is reversed, and the field value must + * be outside the specified range. If the field value doesn't meet the + * required conditions, an error message is generated. + * + * ```proto + * message MyDuration { + * // duration must be greater than or equal to 5s [duration.gte] + * google.protobuf.Duration value = 1 [(buf.validate.field).duration.gte = { seconds: 5 }]; + * + * // duration must be greater than or equal to 5s and less than 10s [duration.gte_lt] + * google.protobuf.Duration another_value = 2 [(buf.validate.field).duration = { gte: { seconds: 5 }, lt: { seconds: 10 } }]; + * + * // duration must be greater than or equal to 10s or less than 5s [duration.gte_lt_exclusive] + * google.protobuf.Duration other_value = 3 [(buf.validate.field).duration = { gte: { seconds: 10 }, lt: { seconds: 5 } }]; + * } + * ``` + * + * @generated from field: google.protobuf.Duration gte = 6; + */ + value: Duration; + case: "gte"; + } | { case: undefined; value?: undefined }; + + /** + * `in` asserts that the field must be equal to one of the specified values of the `google.protobuf.Duration` type. + * If the field's value doesn't correspond to any of the specified values, + * an error message will be generated. + * + * ```proto + * message MyDuration { + * // value must be in list [1s, 2s, 3s] + * google.protobuf.Duration value = 1 [(buf.validate.field).duration.in = ["1s", "2s", "3s"]]; + * } + * ``` + * + * @generated from field: repeated google.protobuf.Duration in = 7; + */ + in: Duration[]; + + /** + * `not_in` denotes that the field must not be equal to + * any of the specified values of the `google.protobuf.Duration` type. + * If the field's value matches any of these values, an error message will be + * generated. + * + * ```proto + * message MyDuration { + * // value must not be in list [1s, 2s, 3s] + * google.protobuf.Duration value = 1 [(buf.validate.field).duration.not_in = ["1s", "2s", "3s"]]; + * } + * ``` + * + * @generated from field: repeated google.protobuf.Duration not_in = 8; + */ + notIn: Duration[]; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyDuration { + * google.protobuf.Duration value = 1 [ + * (buf.validate.field).duration.example = { seconds: 1 }, + * (buf.validate.field).duration.example = { seconds: 2 }, + * ]; + * } + * ``` + * + * @generated from field: repeated google.protobuf.Duration example = 9; + */ + example: Duration[]; +}; + +/** + * Describes the message buf.validate.DurationRules. + * Use `create(DurationRulesSchema)` to create a new message. + */ +export const DurationRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 25); + +/** + * TimestampRules describe the rules applied exclusively to the `google.protobuf.Timestamp` well-known type. + * + * @generated from message buf.validate.TimestampRules + */ +export type TimestampRules = Message<"buf.validate.TimestampRules"> & { + /** + * `const` dictates that this field, of the `google.protobuf.Timestamp` type, must exactly match the specified value. If the field value doesn't correspond to the specified timestamp, an error message will be generated. + * + * ```proto + * message MyTimestamp { + * // value must equal 2023-05-03T10:00:00Z + * google.protobuf.Timestamp created_at = 1 [(buf.validate.field).timestamp.const = {seconds: 1727998800}]; + * } + * ``` + * + * @generated from field: optional google.protobuf.Timestamp const = 2; + */ + const?: Timestamp; + + /** + * @generated from oneof buf.validate.TimestampRules.less_than + */ + lessThan: { + /** + * requires the duration field value to be less than the specified value (field < value). If the field value doesn't meet the required conditions, an error message is generated. + * + * ```proto + * message MyDuration { + * // duration must be less than 'P3D' [duration.lt] + * google.protobuf.Duration value = 1 [(buf.validate.field).duration.lt = { seconds: 259200 }]; + * } + * ``` + * + * @generated from field: google.protobuf.Timestamp lt = 3; + */ + value: Timestamp; + case: "lt"; + } | { + /** + * requires the timestamp field value to be less than or equal to the specified value (field <= value). If the field value doesn't meet the required conditions, an error message is generated. + * + * ```proto + * message MyTimestamp { + * // timestamp must be less than or equal to '2023-05-14T00:00:00Z' [timestamp.lte] + * google.protobuf.Timestamp value = 1 [(buf.validate.field).timestamp.lte = { seconds: 1678867200 }]; + * } + * ``` + * + * @generated from field: google.protobuf.Timestamp lte = 4; + */ + value: Timestamp; + case: "lte"; + } | { + /** + * `lt_now` specifies that this field, of the `google.protobuf.Timestamp` type, must be less than the current time. `lt_now` can only be used with the `within` rule. + * + * ```proto + * message MyTimestamp { + * // value must be less than now + * google.protobuf.Timestamp created_at = 1 [(buf.validate.field).timestamp.lt_now = true]; + * } + * ``` + * + * @generated from field: bool lt_now = 7; + */ + value: boolean; + case: "ltNow"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof buf.validate.TimestampRules.greater_than + */ + greaterThan: { + /** + * `gt` requires the timestamp field value to be greater than the specified + * value (exclusive). If the value of `gt` is larger than a specified `lt` + * or `lte`, the range is reversed, and the field value must be outside the + * specified range. If the field value doesn't meet the required conditions, + * an error message is generated. + * + * ```proto + * message MyTimestamp { + * // timestamp must be greater than '2023-01-01T00:00:00Z' [timestamp.gt] + * google.protobuf.Timestamp value = 1 [(buf.validate.field).timestamp.gt = { seconds: 1672444800 }]; + * + * // timestamp must be greater than '2023-01-01T00:00:00Z' and less than '2023-01-02T00:00:00Z' [timestamp.gt_lt] + * google.protobuf.Timestamp another_value = 2 [(buf.validate.field).timestamp = { gt: { seconds: 1672444800 }, lt: { seconds: 1672531200 } }]; + * + * // timestamp must be greater than '2023-01-02T00:00:00Z' or less than '2023-01-01T00:00:00Z' [timestamp.gt_lt_exclusive] + * google.protobuf.Timestamp other_value = 3 [(buf.validate.field).timestamp = { gt: { seconds: 1672531200 }, lt: { seconds: 1672444800 } }]; + * } + * ``` + * + * @generated from field: google.protobuf.Timestamp gt = 5; + */ + value: Timestamp; + case: "gt"; + } | { + /** + * `gte` requires the timestamp field value to be greater than or equal to the + * specified value (exclusive). If the value of `gte` is larger than a + * specified `lt` or `lte`, the range is reversed, and the field value + * must be outside the specified range. If the field value doesn't meet + * the required conditions, an error message is generated. + * + * ```proto + * message MyTimestamp { + * // timestamp must be greater than or equal to '2023-01-01T00:00:00Z' [timestamp.gte] + * google.protobuf.Timestamp value = 1 [(buf.validate.field).timestamp.gte = { seconds: 1672444800 }]; + * + * // timestamp must be greater than or equal to '2023-01-01T00:00:00Z' and less than '2023-01-02T00:00:00Z' [timestamp.gte_lt] + * google.protobuf.Timestamp another_value = 2 [(buf.validate.field).timestamp = { gte: { seconds: 1672444800 }, lt: { seconds: 1672531200 } }]; + * + * // timestamp must be greater than or equal to '2023-01-02T00:00:00Z' or less than '2023-01-01T00:00:00Z' [timestamp.gte_lt_exclusive] + * google.protobuf.Timestamp other_value = 3 [(buf.validate.field).timestamp = { gte: { seconds: 1672531200 }, lt: { seconds: 1672444800 } }]; + * } + * ``` + * + * @generated from field: google.protobuf.Timestamp gte = 6; + */ + value: Timestamp; + case: "gte"; + } | { + /** + * `gt_now` specifies that this field, of the `google.protobuf.Timestamp` type, must be greater than the current time. `gt_now` can only be used with the `within` rule. + * + * ```proto + * message MyTimestamp { + * // value must be greater than now + * google.protobuf.Timestamp created_at = 1 [(buf.validate.field).timestamp.gt_now = true]; + * } + * ``` + * + * @generated from field: bool gt_now = 8; + */ + value: boolean; + case: "gtNow"; + } | { case: undefined; value?: undefined }; + + /** + * `within` specifies that this field, of the `google.protobuf.Timestamp` type, must be within the specified duration of the current time. If the field value isn't within the duration, an error message is generated. + * + * ```proto + * message MyTimestamp { + * // value must be within 1 hour of now + * google.protobuf.Timestamp created_at = 1 [(buf.validate.field).timestamp.within = {seconds: 3600}]; + * } + * ``` + * + * @generated from field: optional google.protobuf.Duration within = 9; + */ + within?: Duration; + + /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyTimestamp { + * google.protobuf.Timestamp value = 1 [ + * (buf.validate.field).timestamp.example = { seconds: 1672444800 }, + * (buf.validate.field).timestamp.example = { seconds: 1672531200 }, + * ]; + * } + * ``` + * + * @generated from field: repeated google.protobuf.Timestamp example = 10; + */ + example: Timestamp[]; +}; + +/** + * Describes the message buf.validate.TimestampRules. + * Use `create(TimestampRulesSchema)` to create a new message. + */ +export const TimestampRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 26); + +/** + * `Violations` is a collection of `Violation` messages. This message type is returned by + * Protovalidate when a proto message fails to meet the requirements set by the `Rule` validation rules. + * Each individual violation is represented by a `Violation` message. + * + * @generated from message buf.validate.Violations + */ +export type Violations = Message<"buf.validate.Violations"> & { + /** + * `violations` is a repeated field that contains all the `Violation` messages corresponding to the violations detected. + * + * @generated from field: repeated buf.validate.Violation violations = 1; + */ + violations: Violation[]; +}; + +/** + * Describes the message buf.validate.Violations. + * Use `create(ViolationsSchema)` to create a new message. + */ +export const ViolationsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 27); + +/** + * `Violation` represents a single instance where a validation rule, expressed + * as a `Rule`, was not met. It provides information about the field that + * caused the violation, the specific rule that wasn't fulfilled, and a + * human-readable error message. + * + * For example, consider the following message: + * + * ```proto + * message User { + * int32 age = 1 [(buf.validate.field).cel = { + * id: "user.age", + * expression: "this < 18 ? 'User must be at least 18 years old' : ''", + * }]; + * } + * ``` + * + * It could produce the following violation: + * + * ```json + * { + * "ruleId": "user.age", + * "message": "User must be at least 18 years old", + * "field": { + * "elements": [ + * { + * "fieldNumber": 1, + * "fieldName": "age", + * "fieldType": "TYPE_INT32" + * } + * ] + * }, + * "rule": { + * "elements": [ + * { + * "fieldNumber": 23, + * "fieldName": "cel", + * "fieldType": "TYPE_MESSAGE", + * "index": "0" + * } + * ] + * } + * } + * ``` + * + * @generated from message buf.validate.Violation + */ +export type Violation = Message<"buf.validate.Violation"> & { + /** + * `field` is a machine-readable path to the field that failed validation. + * This could be a nested field, in which case the path will include all the parent fields leading to the actual field that caused the violation. + * + * For example, consider the following message: + * + * ```proto + * message Message { + * bool a = 1 [(buf.validate.field).required = true]; + * } + * ``` + * + * It could produce the following violation: + * + * ```textproto + * violation { + * field { element { field_number: 1, field_name: "a", field_type: 8 } } + * ... + * } + * ``` + * + * @generated from field: optional buf.validate.FieldPath field = 5; + */ + field?: FieldPath; + + /** + * `rule` is a machine-readable path that points to the specific rule that failed validation. + * This will be a nested field starting from the FieldRules of the field that failed validation. + * For custom rules, this will provide the path of the rule, e.g. `cel[0]`. + * + * For example, consider the following message: + * + * ```proto + * message Message { + * bool a = 1 [(buf.validate.field).required = true]; + * bool b = 2 [(buf.validate.field).cel = { + * id: "custom_rule", + * expression: "!this ? 'b must be true': ''" + * }] + * } + * ``` + * + * It could produce the following violations: + * + * ```textproto + * violation { + * rule { element { field_number: 25, field_name: "required", field_type: 8 } } + * ... + * } + * violation { + * rule { element { field_number: 23, field_name: "cel", field_type: 11, index: 0 } } + * ... + * } + * ``` + * + * @generated from field: optional buf.validate.FieldPath rule = 6; + */ + rule?: FieldPath; + + /** + * `rule_id` is the unique identifier of the `Rule` that was not fulfilled. + * This is the same `id` that was specified in the `Rule` message, allowing easy tracing of which rule was violated. + * + * @generated from field: optional string rule_id = 2; + */ + ruleId: string; + + /** + * `message` is a human-readable error message that describes the nature of the violation. + * This can be the default error message from the violated `Rule`, or it can be a custom message that gives more context about the violation. + * + * @generated from field: optional string message = 3; + */ + message: string; + + /** + * `for_key` indicates whether the violation was caused by a map key, rather than a value. + * + * @generated from field: optional bool for_key = 4; + */ + forKey: boolean; +}; + +/** + * Describes the message buf.validate.Violation. + * Use `create(ViolationSchema)` to create a new message. + */ +export const ViolationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 28); + +/** + * `FieldPath` provides a path to a nested protobuf field. + * + * This message provides enough information to render a dotted field path even without protobuf descriptors. + * It also provides enough information to resolve a nested field through unknown wire data. + * + * @generated from message buf.validate.FieldPath + */ +export type FieldPath = Message<"buf.validate.FieldPath"> & { + /** + * `elements` contains each element of the path, starting from the root and recursing downward. + * + * @generated from field: repeated buf.validate.FieldPathElement elements = 1; + */ + elements: FieldPathElement[]; +}; + +/** + * Describes the message buf.validate.FieldPath. + * Use `create(FieldPathSchema)` to create a new message. + */ +export const FieldPathSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 29); + +/** + * `FieldPathElement` provides enough information to nest through a single protobuf field. + * + * If the selected field is a map or repeated field, the `subscript` value selects a specific element from it. + * A path that refers to a value nested under a map key or repeated field index will have a `subscript` value. + * The `field_type` field allows unambiguous resolution of a field even if descriptors are not available. + * + * @generated from message buf.validate.FieldPathElement + */ +export type FieldPathElement = Message<"buf.validate.FieldPathElement"> & { + /** + * `field_number` is the field number this path element refers to. + * + * @generated from field: optional int32 field_number = 1; + */ + fieldNumber: number; + + /** + * `field_name` contains the field name this path element refers to. + * This can be used to display a human-readable path even if the field number is unknown. + * + * @generated from field: optional string field_name = 2; + */ + fieldName: string; + + /** + * `field_type` specifies the type of this field. When using reflection, this value is not needed. + * + * This value is provided to make it possible to traverse unknown fields through wire data. + * When traversing wire data, be mindful of both packed[1] and delimited[2] encoding schemes. + * + * [1]: https://protobuf.dev/programming-guides/encoding/#packed + * [2]: https://protobuf.dev/programming-guides/encoding/#groups + * + * N.B.: Although groups are deprecated, the corresponding delimited encoding scheme is not, and + * can be explicitly used in Protocol Buffers 2023 Edition. + * + * @generated from field: optional google.protobuf.FieldDescriptorProto.Type field_type = 3; + */ + fieldType: FieldDescriptorProto_Type; + + /** + * `key_type` specifies the map key type of this field. This value is useful when traversing + * unknown fields through wire data: specifically, it allows handling the differences between + * different integer encodings. + * + * @generated from field: optional google.protobuf.FieldDescriptorProto.Type key_type = 4; + */ + keyType: FieldDescriptorProto_Type; + + /** + * `value_type` specifies map value type of this field. This is useful if you want to display a + * value inside unknown fields through wire data. + * + * @generated from field: optional google.protobuf.FieldDescriptorProto.Type value_type = 5; + */ + valueType: FieldDescriptorProto_Type; + + /** + * `subscript` contains a repeated index or map key, if this path element nests into a repeated or map field. + * + * @generated from oneof buf.validate.FieldPathElement.subscript + */ + subscript: { + /** + * `index` specifies a 0-based index into a repeated field. + * + * @generated from field: uint64 index = 6; + */ + value: bigint; + case: "index"; + } | { + /** + * `bool_key` specifies a map key of type bool. + * + * @generated from field: bool bool_key = 7; + */ + value: boolean; + case: "boolKey"; + } | { + /** + * `int_key` specifies a map key of type int32, int64, sint32, sint64, sfixed32 or sfixed64. + * + * @generated from field: int64 int_key = 8; + */ + value: bigint; + case: "intKey"; + } | { + /** + * `uint_key` specifies a map key of type uint32, uint64, fixed32 or fixed64. + * + * @generated from field: uint64 uint_key = 9; + */ + value: bigint; + case: "uintKey"; + } | { + /** + * `string_key` specifies a map key of type string. + * + * @generated from field: string string_key = 10; + */ + value: string; + case: "stringKey"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message buf.validate.FieldPathElement. + * Use `create(FieldPathElementSchema)` to create a new message. + */ +export const FieldPathElementSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 30); + +/** + * Specifies how `FieldRules.ignore` behaves, depending on the field's value, and + * whether the field tracks presence. + * + * @generated from enum buf.validate.Ignore + */ +export enum Ignore { + /** + * Ignore rules if the field tracks presence and is unset. This is the default + * behavior. + * + * In proto3, only message fields, members of a Protobuf `oneof`, and fields + * with the `optional` label track presence. Consequently, the following fields + * are always validated, whether a value is set or not: + * + * ```proto + * syntax="proto3"; + * + * message RulesApply { + * string email = 1 [ + * (buf.validate.field).string.email = true + * ]; + * int32 age = 2 [ + * (buf.validate.field).int32.gt = 0 + * ]; + * repeated string labels = 3 [ + * (buf.validate.field).repeated.min_items = 1 + * ]; + * } + * ``` + * + * In contrast, the following fields track presence, and are only validated if + * a value is set: + * + * ```proto + * syntax="proto3"; + * + * message RulesApplyIfSet { + * optional string email = 1 [ + * (buf.validate.field).string.email = true + * ]; + * oneof ref { + * string reference = 2 [ + * (buf.validate.field).string.uuid = true + * ]; + * string name = 3 [ + * (buf.validate.field).string.min_len = 4 + * ]; + * } + * SomeMessage msg = 4 [ + * (buf.validate.field).cel = {/* ... *\/} + * ]; + * } + * ``` + * + * To ensure that such a field is set, add the `required` rule. + * + * To learn which fields track presence, see the + * [Field Presence cheat sheet](https://protobuf.dev/programming-guides/field_presence/#cheat). + * + * @generated from enum value: IGNORE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * Ignore rules if the field is unset, or set to the zero value. + * + * The zero value depends on the field type: + * - For strings, the zero value is the empty string. + * - For bytes, the zero value is empty bytes. + * - For bool, the zero value is false. + * - For numeric types, the zero value is zero. + * - For enums, the zero value is the first defined enum value. + * - For repeated fields, the zero is an empty list. + * - For map fields, the zero is an empty map. + * - For message fields, absence of the message (typically a null-value) is considered zero value. + * + * For fields that track presence (e.g. adding the `optional` label in proto3), + * this a no-op and behavior is the same as the default `IGNORE_UNSPECIFIED`. + * + * @generated from enum value: IGNORE_IF_ZERO_VALUE = 1; + */ + IF_ZERO_VALUE = 1, + + /** + * Always ignore rules, including the `required` rule. + * + * This is useful for ignoring the rules of a referenced message, or to + * temporarily ignore rules during development. + * + * ```proto + * message MyMessage { + * // The field's rules will always be ignored, including any validations + * // on value's fields. + * MyOtherMessage value = 1 [ + * (buf.validate.field).ignore = IGNORE_ALWAYS]; + * } + * ``` + * + * @generated from enum value: IGNORE_ALWAYS = 3; + */ + ALWAYS = 3, +} + +/** + * Describes the enum buf.validate.Ignore. + */ +export const IgnoreSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_buf_validate_validate, 0); + +/** + * KnownRegex contains some well-known patterns. + * + * @generated from enum buf.validate.KnownRegex + */ +export enum KnownRegex { + /** + * @generated from enum value: KNOWN_REGEX_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * HTTP header name as defined by [RFC 7230](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2). + * + * @generated from enum value: KNOWN_REGEX_HTTP_HEADER_NAME = 1; + */ + HTTP_HEADER_NAME = 1, + + /** + * HTTP header value as defined by [RFC 7230](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.4). + * + * @generated from enum value: KNOWN_REGEX_HTTP_HEADER_VALUE = 2; + */ + HTTP_HEADER_VALUE = 2, +} + +/** + * Describes the enum buf.validate.KnownRegex. + */ +export const KnownRegexSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_buf_validate_validate, 1); + +/** + * Rules specify the validations to be performed on this message. By default, + * no validation is performed against a message. + * + * @generated from extension: optional buf.validate.MessageRules message = 1159; + */ +export const message: GenExtension = /*@__PURE__*/ + extDesc(file_buf_validate_validate, 0); + +/** + * Rules specify the validations to be performed on this oneof. By default, + * no validation is performed against a oneof. + * + * @generated from extension: optional buf.validate.OneofRules oneof = 1159; + */ +export const oneof: GenExtension = /*@__PURE__*/ + extDesc(file_buf_validate_validate, 1); + +/** + * Rules specify the validations to be performed on this field. By default, + * no validation is performed against a field. + * + * @generated from extension: optional buf.validate.FieldRules field = 1159; + */ +export const field: GenExtension = /*@__PURE__*/ + extDesc(file_buf_validate_validate, 2); + +/** + * Specifies predefined rules. When extending a standard rule message, + * this adds additional CEL expressions that apply when the extension is used. + * + * ```proto + * extend buf.validate.Int32Rules { + * bool is_zero [(buf.validate.predefined).cel = { + * id: "int32.is_zero", + * message: "value must be zero", + * expression: "!rule || this == 0", + * }]; + * } + * + * message Foo { + * int32 reserved = 1 [(buf.validate.field).int32.(is_zero) = true]; + * } + * ``` + * + * @generated from extension: optional buf.validate.PredefinedRules predefined = 1160; + */ +export const predefined: GenExtension = /*@__PURE__*/ + extDesc(file_buf_validate_validate, 3); + diff --git a/gen/ts/flyteidl2/app/app_definition_pb.ts b/gen/ts/flyteidl2/app/app_definition_pb.ts new file mode 100644 index 0000000000..5dc353d237 --- /dev/null +++ b/gen/ts/flyteidl2/app/app_definition_pb.ts @@ -0,0 +1,1112 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/app/app_definition.proto (package flyteidl2.app, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { EnrichedIdentity } from "../common/identity_pb.ts"; +import { file_flyteidl2_common_identity } from "../common/identity_pb.ts"; +import type { RuntimeMetadata } from "../common/runtime_version_pb.ts"; +import { file_flyteidl2_common_runtime_version } from "../common/runtime_version_pb.ts"; +import type { ArtifactID, ArtifactQuery } from "../core/artifact_id_pb.ts"; +import { file_flyteidl2_core_artifact_id } from "../core/artifact_id_pb.ts"; +import type { Identity, Secret } from "../core/security_pb.ts"; +import { file_flyteidl2_core_security } from "../core/security_pb.ts"; +import type { Container, ExtendedResources, K8sPod } from "../core/tasks_pb.ts"; +import { file_flyteidl2_core_tasks } from "../core/tasks_pb.ts"; +import type { Duration, Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_duration, file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/app/app_definition.proto. + */ +export const file_flyteidl2_app_app_definition: GenFile = /*@__PURE__*/ + fileDesc("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", [file_buf_validate_validate, file_flyteidl2_common_identity, file_flyteidl2_common_runtime_version, file_flyteidl2_core_artifact_id, file_flyteidl2_core_security, file_flyteidl2_core_tasks, file_google_protobuf_duration, file_google_protobuf_timestamp]); + +/** + * @generated from message flyteidl2.app.Identifier + */ +export type Identifier = Message<"flyteidl2.app.Identifier"> & { + /** + * Org that the app belongs to. + * + * @generated from field: string org = 1; + */ + org: string; + + /** + * Project that the app belongs to. + * + * @generated from field: string project = 2; + */ + project: string; + + /** + * Domain that the app belongs to. + * + * @generated from field: string domain = 3; + */ + domain: string; + + /** + * Name that the user provided for the app. + * + * @generated from field: string name = 4; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.app.Identifier. + * Use `create(IdentifierSchema)` to create a new message. + */ +export const IdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 0); + +/** + * @generated from message flyteidl2.app.Meta + */ +export type Meta = Message<"flyteidl2.app.Meta"> & { + /** + * ID of the app. + * + * @generated from field: flyteidl2.app.Identifier id = 1; + */ + id?: Identifier; + + /** + * Revision of the app object. + * + * @generated from field: uint64 revision = 2; + */ + revision: bigint; + + /** + * Labels for the app. + * + * @generated from field: map labels = 3; + */ + labels: { [key: string]: string }; +}; + +/** + * Describes the message flyteidl2.app.Meta. + * Use `create(MetaSchema)` to create a new message. + */ +export const MetaSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 1); + +/** + * For internal usage only. This message is used to wrap the app message with the host. + * + * @generated from message flyteidl2.app.AppWrapper + */ +export type AppWrapper = Message<"flyteidl2.app.AppWrapper"> & { + /** + * @generated from field: string host = 1; + */ + host: string; + + /** + * @generated from oneof flyteidl2.app.AppWrapper.payload + */ + payload: { + /** + * @generated from field: flyteidl2.app.App app = 2; + */ + value: App; + case: "app"; + } | { + /** + * @generated from field: flyteidl2.app.Identifier app_id = 3; + */ + value: Identifier; + case: "appId"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.app.AppWrapper. + * Use `create(AppWrapperSchema)` to create a new message. + */ +export const AppWrapperSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 2); + +/** + * Represents an app with its specification and status. + * + * @generated from message flyteidl2.app.App + */ +export type App = Message<"flyteidl2.app.App"> & { + /** + * Metadata of the app. + * + * @generated from field: flyteidl2.app.Meta metadata = 1; + */ + metadata?: Meta; + + /** + * Specification of the app. + * + * @generated from field: flyteidl2.app.Spec spec = 2; + */ + spec?: Spec; + + /** + * Status of the app. + * + * @generated from field: flyteidl2.app.Status status = 3; + */ + status?: Status; +}; + +/** + * Describes the message flyteidl2.app.App. + * Use `create(AppSchema)` to create a new message. + */ +export const AppSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 3); + +/** + * Represents the condition of an app. + * + * @generated from message flyteidl2.app.Condition + */ +export type Condition = Message<"flyteidl2.app.Condition"> & { + /** + * Last transition time of the condition. + * + * @generated from field: google.protobuf.Timestamp last_transition_time = 1; + */ + lastTransitionTime?: Timestamp; + + /** + * Deployment status of the app. + * + * @generated from field: flyteidl2.app.Status.DeploymentStatus deployment_status = 2; + */ + deploymentStatus: Status_DeploymentStatus; + + /** + * Message for the condition. + * + * @generated from field: string message = 3; + */ + message: string; + + /** + * Revision the Condition applies to. This can be used by consumers + * to introspect and visualize which revisions are up. + * + * @generated from field: uint64 revision = 4; + */ + revision: bigint; + + /** + * Actor is the principal that caused the condition. + * + * @generated from field: flyteidl2.common.EnrichedIdentity actor = 5; + */ + actor?: EnrichedIdentity; +}; + +/** + * Describes the message flyteidl2.app.Condition. + * Use `create(ConditionSchema)` to create a new message. + */ +export const ConditionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 4); + +/** + * Represents the status of an app. + * + * @generated from message flyteidl2.app.Status + */ +export type Status = Message<"flyteidl2.app.Status"> & { + /** + * @generated from field: string assigned_cluster = 1; + */ + assignedCluster: string; + + /** + * Current number of replicas. + * + * @generated from field: uint32 current_replicas = 2; + */ + currentReplicas: number; + + /** + * List of public URLs for the app. + * + * @generated from field: flyteidl2.app.Ingress ingress = 3; + */ + ingress?: Ingress; + + /** + * CreatedAt is the time when the app was first created + * + * @generated from field: google.protobuf.Timestamp created_at = 4; + */ + createdAt?: Timestamp; + + /** + * LastUpdatedAt is the time when the app was last updated + * + * @generated from field: google.protobuf.Timestamp last_updated_at = 5; + */ + lastUpdatedAt?: Timestamp; + + /** + * Conditions for the app. + * + * @generated from field: repeated flyteidl2.app.Condition conditions = 6; + */ + conditions: Condition[]; + + /** + * LeaseExpiration refers to how long the app is leased to a cluster for it to start processing it. If the lease + * period expires, the cluster will no longer be allowed to update this app and another cluster can pick it up. + * + * @generated from field: google.protobuf.Timestamp lease_expiration = 7; + */ + leaseExpiration?: Timestamp; + + /** + * K8sMetadata contains metadata about the app in the K8s cluster. + * + * @generated from field: flyteidl2.app.K8sMetadata k8s_metadata = 8; + */ + k8sMetadata?: K8sMetadata; + + /** + * @generated from field: flyteidl2.app.MaterializedInputs materialized_inputs = 9; + */ + materializedInputs?: MaterializedInputs; +}; + +/** + * Describes the message flyteidl2.app.Status. + * Use `create(StatusSchema)` to create a new message. + */ +export const StatusSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 5); + +/** + * Enum for deployment status of the app. + * + * @generated from enum flyteidl2.app.Status.DeploymentStatus + */ +export enum Status_DeploymentStatus { + /** + * Unspecified deployment status. + * + * @generated from enum value: DEPLOYMENT_STATUS_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * Deployment is enabled but hasn't been assigned to a cluster yet. + * + * @generated from enum value: DEPLOYMENT_STATUS_UNASSIGNED = 1; + */ + UNASSIGNED = 1, + + /** + * Deployment is assigned to a cluster but hasn't been acknowledged yet. + * + * @generated from enum value: DEPLOYMENT_STATUS_ASSIGNED = 2; + */ + ASSIGNED = 2, + + /** + * Deployment is picked up by a cluster but is awaiting deployment. + * + * @generated from enum value: DEPLOYMENT_STATUS_PENDING = 3; + */ + PENDING = 3, + + /** + * Deployment is disabled. + * + * @generated from enum value: DEPLOYMENT_STATUS_STOPPED = 4; + */ + STOPPED = 4, + + /** + * Deployment is completed. Please use DEPLOYMENT_STATUS_ACTIVE instead. + * + * @generated from enum value: DEPLOYMENT_STATUS_STARTED = 5 [deprecated = true]; + * @deprecated + */ + STARTED = 5, + + /** + * Deployment has failed. + * + * @generated from enum value: DEPLOYMENT_STATUS_FAILED = 6; + */ + FAILED = 6, + + /** + * Deployment is completed. + * + * @generated from enum value: DEPLOYMENT_STATUS_ACTIVE = 7; + */ + ACTIVE = 7, + + /** + * Triggered in response to desired app replicas > actual app replicas + * + * @generated from enum value: DEPLOYMENT_STATUS_SCALING_UP = 8; + */ + SCALING_UP = 8, + + /** + * Triggered in response to desired app replicas < actual app replicas + * + * @generated from enum value: DEPLOYMENT_STATUS_SCALING_DOWN = 9; + */ + SCALING_DOWN = 9, + + /** + * Triggered in response to the latest app spec changing + * + * @generated from enum value: DEPLOYMENT_STATUS_DEPLOYING = 10; + */ + DEPLOYING = 10, +} + +/** + * Describes the enum flyteidl2.app.Status.DeploymentStatus. + */ +export const Status_DeploymentStatusSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_app_app_definition, 5, 0); + +/** + * @generated from message flyteidl2.app.K8sMetadata + */ +export type K8sMetadata = Message<"flyteidl2.app.K8sMetadata"> & { + /** + * Namespace points to the namespace the app is deployed in. + * + * @generated from field: string namespace = 1; + */ + namespace: string; +}; + +/** + * Describes the message flyteidl2.app.K8sMetadata. + * Use `create(K8sMetadataSchema)` to create a new message. + */ +export const K8sMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 6); + +/** + * @generated from message flyteidl2.app.Ingress + */ +export type Ingress = Message<"flyteidl2.app.Ingress"> & { + /** + * Public URL of the app. + * + * @generated from field: string public_url = 1; + */ + publicUrl: string; + + /** + * Canonical name (CNAME) URL of the app. + * + * @generated from field: string cname_url = 2; + */ + cnameUrl: string; + + /** + * VPC URL of the app. + * + * @generated from field: string vpc_url = 3; + */ + vpcUrl: string; +}; + +/** + * Describes the message flyteidl2.app.Ingress. + * Use `create(IngressSchema)` to create a new message. + */ +export const IngressSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 7); + +/** + * Represents the specification of an app. + * + * @generated from message flyteidl2.app.Spec + */ +export type Spec = Message<"flyteidl2.app.Spec"> & { + /** + * Payload of the app, which can be either a container or a K8s pod. + * + * @generated from oneof flyteidl2.app.Spec.app_payload + */ + appPayload: { + /** + * Container payload. + * + * @generated from field: flyteidl2.core.Container container = 1; + */ + value: Container; + case: "container"; + } | { + /** + * K8s pod payload. + * + * @generated from field: flyteidl2.core.K8sPod pod = 2; + */ + value: K8sPod; + case: "pod"; + } | { case: undefined; value?: undefined }; + + /** + * Autoscaling configuration for the app. + * + * @generated from field: flyteidl2.app.AutoscalingConfig autoscaling = 3; + */ + autoscaling?: AutoscalingConfig; + + /** + * Ingress configuration for the app. + * + * @generated from field: flyteidl2.app.IngressConfig ingress = 4; + */ + ingress?: IngressConfig; + + /** + * Deployment status of the app. + * + * @generated from field: flyteidl2.app.Spec.DesiredState desired_state = 5; + */ + desiredState: Spec_DesiredState; + + /** + * ClusterPool to place this app on. By default it'll use the default cluster pool. + * + * @generated from field: string cluster_pool = 6; + */ + clusterPool: string; + + /** + * Set of image specifications for the app. + * + * @generated from field: flyteidl2.app.ImageSpecSet images = 7; + */ + images?: ImageSpecSet; + + /** + * security_context encapsulates security attributes requested to run this task. + * + * @generated from field: flyteidl2.app.SecurityContext security_context = 8; + */ + securityContext?: SecurityContext; + + /** + * Encapsulates all non-standard resources, not captured by + * v1.ResourceRequirements, to allocate to a task. + * + * @generated from field: flyteidl2.core.ExtendedResources extended_resources = 9; + */ + extendedResources?: ExtendedResources; + + /** + * Runtime metadata for the app. + * + * @generated from field: flyteidl2.common.RuntimeMetadata runtime_metadata = 10; + */ + runtimeMetadata?: RuntimeMetadata; + + /** + * Profile of the app. + * + * @generated from field: flyteidl2.app.Profile profile = 11; + */ + profile?: Profile; + + /** + * Creator of the app is the first principal that provisioned this app. Other principals may + * interact with the app by updating its spec or stopping/starting it. + * + * @generated from field: flyteidl2.common.EnrichedIdentity creator = 12; + */ + creator?: EnrichedIdentity; + + /** + * Inputs of the app. + * + * @generated from field: flyteidl2.app.InputList inputs = 13; + */ + inputs?: InputList; + + /** + * @generated from field: repeated flyteidl2.app.Link links = 14; + */ + links: Link[]; + + /** + * Timeout configuration for the app. + * + * @generated from field: flyteidl2.app.TimeoutConfig timeouts = 15; + */ + timeouts?: TimeoutConfig; +}; + +/** + * Describes the message flyteidl2.app.Spec. + * Use `create(SpecSchema)` to create a new message. + */ +export const SpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 8); + +/** + * Enum for deployment status of the app. + * + * @generated from enum flyteidl2.app.Spec.DesiredState + */ +export enum Spec_DesiredState { + /** + * Unspecified state + * + * @generated from enum value: DESIRED_STATE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * Deployment is disabled. + * + * @generated from enum value: DESIRED_STATE_STOPPED = 1; + */ + STOPPED = 1, + + /** + * Deployment is completed. Please use DESIRED_STATE_ACTIVE instead. + * + * @generated from enum value: DESIRED_STATE_STARTED = 2 [deprecated = true]; + * @deprecated + */ + STARTED = 2, + + /** + * Deployment is completed. + * + * @generated from enum value: DESIRED_STATE_ACTIVE = 3; + */ + ACTIVE = 3, +} + +/** + * Describes the enum flyteidl2.app.Spec.DesiredState. + */ +export const Spec_DesiredStateSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_app_app_definition, 8, 0); + +/** + * Represents a link to an external resource (Arize project link, W&B dashboard, etc) + * + * @generated from message flyteidl2.app.Link + */ +export type Link = Message<"flyteidl2.app.Link"> & { + /** + * URL of the external service. + * This can be an absolute or relative path. + * + * @generated from field: string path = 1; + */ + path: string; + + /** + * Human readable name of the external service. + * + * @generated from field: string title = 2; + */ + title: string; + + /** + * Whether the path is absolute (default) or relative. + * + * @generated from field: bool is_relative = 3; + */ + isRelative: boolean; +}; + +/** + * Describes the message flyteidl2.app.Link. + * Use `create(LinkSchema)` to create a new message. + */ +export const LinkSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 9); + +/** + * @generated from message flyteidl2.app.Input + */ +export type Input = Message<"flyteidl2.app.Input"> & { + /** + * Name is a unique identifier of the input within the list of inputs of the app + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * @generated from oneof flyteidl2.app.Input.value + */ + value: { + /** + * StringValue is a plain string value for the input + * + * @generated from field: string string_value = 2; + */ + value: string; + case: "stringValue"; + } | { + /** + * ArtifactQuery is that should result in a single artifact that will be used as the input to the app at runtime. + * The artifact will be pinned at the time of the app creation. + * + * @generated from field: flyteidl2.core.ArtifactQuery artifact_query = 3; + */ + value: ArtifactQuery; + case: "artifactQuery"; + } | { + /** + * ArtifactId is an identifier of an artifact that will be used as the input to the app at runtime. + * + * @generated from field: flyteidl2.core.ArtifactID artifact_id = 4; + */ + value: ArtifactID; + case: "artifactId"; + } | { + /** + * ID of the app. + * + * @generated from field: flyteidl2.app.Identifier app_id = 5; + */ + value: Identifier; + case: "appId"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.app.Input. + * Use `create(InputSchema)` to create a new message. + */ +export const InputSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 10); + +/** + * @generated from message flyteidl2.app.MaterializedInputs + */ +export type MaterializedInputs = Message<"flyteidl2.app.MaterializedInputs"> & { + /** + * @generated from field: repeated flyteidl2.app.MaterializedInput items = 1; + */ + items: MaterializedInput[]; + + /** + * Revision of the app object that we materialized the input for. + * + * @generated from field: uint64 revision = 2; + */ + revision: bigint; +}; + +/** + * Describes the message flyteidl2.app.MaterializedInputs. + * Use `create(MaterializedInputsSchema)` to create a new message. + */ +export const MaterializedInputsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 11); + +/** + * @generated from message flyteidl2.app.MaterializedInput + */ +export type MaterializedInput = Message<"flyteidl2.app.MaterializedInput"> & { + /** + * Name is a unique identifier of the input within the list of inputs of the app + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * @generated from oneof flyteidl2.app.MaterializedInput.value + */ + value: { + /** + * ArtifactId is an identifier of an artifact that will be used as the input to the app at runtime. + * + * @generated from field: flyteidl2.core.ArtifactID artifact_id = 2; + */ + value: ArtifactID; + case: "artifactId"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.app.MaterializedInput. + * Use `create(MaterializedInputSchema)` to create a new message. + */ +export const MaterializedInputSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 12); + +/** + * InputList is a list of dependencies for the app. + * + * @generated from message flyteidl2.app.InputList + */ +export type InputList = Message<"flyteidl2.app.InputList"> & { + /** + * Items is the list of inputs to fulfil for the app. + * + * @generated from field: repeated flyteidl2.app.Input items = 1; + */ + items: Input[]; +}; + +/** + * Describes the message flyteidl2.app.InputList. + * Use `create(InputListSchema)` to create a new message. + */ +export const InputListSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 13); + +/** + * @generated from message flyteidl2.app.Profile + */ +export type Profile = Message<"flyteidl2.app.Profile"> & { + /** + * App Type (e.g. FastAPI, Flask, VLLM, NIM etc.) + * + * @generated from field: string type = 1; + */ + type: string; + + /** + * Friendly name of the app. + * + * @generated from field: string name = 2; + */ + name: string; + + /** + * Short description of the app. + * + * @generated from field: string short_description = 3; + */ + shortDescription: string; + + /** + * Icon URL of the app. + * + * @generated from field: string icon_url = 4; + */ + iconUrl: string; +}; + +/** + * Describes the message flyteidl2.app.Profile. + * Use `create(ProfileSchema)` to create a new message. + */ +export const ProfileSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 14); + +/** + * SecurityContext holds security attributes that apply to tasks. + * + * @generated from message flyteidl2.app.SecurityContext + */ +export type SecurityContext = Message<"flyteidl2.app.SecurityContext"> & { + /** + * run_as encapsulates the identity a pod should run as. If the task fills in multiple fields here, it'll be up to the + * backend plugin to choose the appropriate identity for the execution engine the task will run on. + * + * @generated from field: flyteidl2.core.Identity run_as = 1; + */ + runAs?: Identity; + + /** + * secrets indicate the list of secrets the task needs in order to proceed. Secrets will be mounted/passed to the + * pod as it starts. If the plugin responsible for kicking of the task will not run it on a flyte cluster (e.g. AWS + * Batch), it's the responsibility of the plugin to fetch the secret (which means propeller identity will need access + * to the secret) and to pass it to the remote execution engine. + * + * @generated from field: repeated flyteidl2.core.Secret secrets = 2; + */ + secrets: Secret[]; + + /** + * AllowAnonymous indicates if the app should be accessible without authentication. This assumes the app will handle + * its own authentication or that it's a public app. + * + * @generated from field: bool allow_anonymous = 5; + */ + allowAnonymous: boolean; +}; + +/** + * Describes the message flyteidl2.app.SecurityContext. + * Use `create(SecurityContextSchema)` to create a new message. + */ +export const SecurityContextSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 15); + +/** + * @generated from message flyteidl2.app.ImageSpec + */ +export type ImageSpec = Message<"flyteidl2.app.ImageSpec"> & { + /** + * Tag of the image. + * + * @generated from field: string tag = 1; + */ + tag: string; + + /** + * URL of the build job for the image. + * + * @generated from field: string build_job_url = 2; + */ + buildJobUrl: string; +}; + +/** + * Describes the message flyteidl2.app.ImageSpec. + * Use `create(ImageSpecSchema)` to create a new message. + */ +export const ImageSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 16); + +/** + * @generated from message flyteidl2.app.ImageSpecSet + */ +export type ImageSpecSet = Message<"flyteidl2.app.ImageSpecSet"> & { + /** + * List of image specifications. + * + * @generated from field: repeated flyteidl2.app.ImageSpec images = 1; + */ + images: ImageSpec[]; +}; + +/** + * Describes the message flyteidl2.app.ImageSpecSet. + * Use `create(ImageSpecSetSchema)` to create a new message. + */ +export const ImageSpecSetSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 17); + +/** + * Represents the ingress configuration of an app. + * + * @generated from message flyteidl2.app.IngressConfig + */ +export type IngressConfig = Message<"flyteidl2.app.IngressConfig"> & { + /** + * Indicates if the app should be private. + * + * @generated from field: bool private = 1; + */ + private: boolean; + + /** + * Subdomain for the app. If not specified, a random subdomain will be generated. + * + * @generated from field: string subdomain = 2; + */ + subdomain: string; + + /** + * Canonical name (CNAME) for the app. + * + * @generated from field: string cname = 3; + */ + cname: string; +}; + +/** + * Describes the message flyteidl2.app.IngressConfig. + * Use `create(IngressConfigSchema)` to create a new message. + */ +export const IngressConfigSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 18); + +/** + * Represents the autoscaling configuration of an app. + * + * @generated from message flyteidl2.app.AutoscalingConfig + */ +export type AutoscalingConfig = Message<"flyteidl2.app.AutoscalingConfig"> & { + /** + * Configuration for the number of replicas. + * + * @generated from field: flyteidl2.app.Replicas replicas = 1; + */ + replicas?: Replicas; + + /** + * The period for scaling down the object. + * + * @generated from field: google.protobuf.Duration scaledown_period = 2; + */ + scaledownPeriod?: Duration; + + /** + * Metric for scaling the app. + * + * @generated from field: flyteidl2.app.ScalingMetric scaling_metric = 3; + */ + scalingMetric?: ScalingMetric; +}; + +/** + * Describes the message flyteidl2.app.AutoscalingConfig. + * Use `create(AutoscalingConfigSchema)` to create a new message. + */ +export const AutoscalingConfigSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 19); + +/** + * ScalingMetric allows different scaling strategies for the app. + * See: https://knative.dev/docs/serving/autoscaling/autoscaling-metrics/ + * + * @generated from message flyteidl2.app.ScalingMetric + */ +export type ScalingMetric = Message<"flyteidl2.app.ScalingMetric"> & { + /** + * @generated from oneof flyteidl2.app.ScalingMetric.metric + */ + metric: { + /** + * Configuration for scaling based on request rate. + * + * @generated from field: flyteidl2.app.RequestRate request_rate = 1; + */ + value: RequestRate; + case: "requestRate"; + } | { + /** + * Configuration for scaling based on concurrency. + * + * @generated from field: flyteidl2.app.Concurrency concurrency = 2; + */ + value: Concurrency; + case: "concurrency"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.app.ScalingMetric. + * Use `create(ScalingMetricSchema)` to create a new message. + */ +export const ScalingMetricSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 20); + +/** + * This section enables scaling based on the request concurrency. Concurrency calculates how many + * requests are being processed at the same time. This is useful for apps that take longer to process + * requests (e.g. seconds) + * The autoscaler has a default window of 60 seconds to calculate the concurrency value. However, it has + * panic mode that kicks in if the request rate jumps to 2x its value within 6 seconds. If that's + * triggered, it'll start scaling up immediately instead of waiting for the full 60 seconds. + * + * @generated from message flyteidl2.app.Concurrency + */ +export type Concurrency = Message<"flyteidl2.app.Concurrency"> & { + /** + * This is the target value for the scaling configuration. + * default=100 + * + * @generated from field: uint32 target_value = 1; + */ + targetValue: number; +}; + +/** + * Describes the message flyteidl2.app.Concurrency. + * Use `create(ConcurrencySchema)` to create a new message. + */ +export const ConcurrencySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 21); + +/** + * RequestRate enables scaling based on the request rate. Request rate calculates how many requests + * the app is receiving per second. + * The autoscaler has a default window of 60 seconds to calculate the request rate. However, it has + * panic mode that kicks in if the request rate jumps to 2x its value within 6 seconds. If that's + * triggered, it'll start scaling up immediately instead of waiting for the full 60 seconds. + * + * @generated from message flyteidl2.app.RequestRate + */ +export type RequestRate = Message<"flyteidl2.app.RequestRate"> & { + /** + * This is the target value for the scaling configuration. + * default=100 + * + * @generated from field: uint32 target_value = 1; + */ + targetValue: number; +}; + +/** + * Describes the message flyteidl2.app.RequestRate. + * Use `create(RequestRateSchema)` to create a new message. + */ +export const RequestRateSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 22); + +/** + * Represents the configuration for the number of replicas. + * + * @generated from message flyteidl2.app.Replicas + */ +export type Replicas = Message<"flyteidl2.app.Replicas"> & { + /** + * Minimum number of replicas. + * + * @generated from field: uint32 min = 1; + */ + min: number; + + /** + * Maximum number of replicas. + * + * @generated from field: uint32 max = 2; + */ + max: number; +}; + +/** + * Describes the message flyteidl2.app.Replicas. + * Use `create(ReplicasSchema)` to create a new message. + */ +export const ReplicasSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 23); + +/** + * @generated from message flyteidl2.app.TimeoutConfig + */ +export type TimeoutConfig = Message<"flyteidl2.app.TimeoutConfig"> & { + /** + * This is the maximum duration that the request instance + * is allowed to respond to a request. If unspecified, a system default will + * be provided. + * default=300s + * + * @generated from field: google.protobuf.Duration request_timeout = 1; + */ + requestTimeout?: Duration; +}; + +/** + * Describes the message flyteidl2.app.TimeoutConfig. + * Use `create(TimeoutConfigSchema)` to create a new message. + */ +export const TimeoutConfigSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_definition, 24); + diff --git a/gen/ts/flyteidl2/app/app_logs_payload_pb.ts b/gen/ts/flyteidl2/app/app_logs_payload_pb.ts new file mode 100644 index 0000000000..47fadee9f6 --- /dev/null +++ b/gen/ts/flyteidl2/app/app_logs_payload_pb.ts @@ -0,0 +1,161 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/app/app_logs_payload.proto (package flyteidl2.app, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { Identifier } from "./app_definition_pb.ts"; +import { file_flyteidl2_app_app_definition } from "./app_definition_pb.ts"; +import type { ReplicaIdentifier } from "./replica_definition_pb.ts"; +import { file_flyteidl2_app_replica_definition } from "./replica_definition_pb.ts"; +import type { LogLine, LogLines as LogLines$1 } from "../logs/dataplane/payload_pb.ts"; +import { file_flyteidl2_logs_dataplane_payload } from "../logs/dataplane/payload_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/app/app_logs_payload.proto. + */ +export const file_flyteidl2_app_app_logs_payload: GenFile = /*@__PURE__*/ + fileDesc("CiRmbHl0ZWlkbDIvYXBwL2FwcF9sb2dzX3BheWxvYWQucHJvdG8SDWZseXRlaWRsMi5hcHAihwEKD1RhaWxMb2dzUmVxdWVzdBIrCgZhcHBfaWQYASABKAsyGS5mbHl0ZWlkbDIuYXBwLklkZW50aWZpZXJIABI2CgpyZXBsaWNhX2lkGAIgASgLMiAuZmx5dGVpZGwyLmFwcC5SZXBsaWNhSWRlbnRpZmllckgAQg8KBnRhcmdldBIFukgCCAEiSwoVUmVwbGljYUlkZW50aWZpZXJMaXN0EjIKCHJlcGxpY2FzGAEgAygLMiAuZmx5dGVpZGwyLmFwcC5SZXBsaWNhSWRlbnRpZmllciKYAQoITG9nTGluZXMSEQoFbGluZXMYASADKAlCAhgBEjwKCnJlcGxpY2FfaWQYAiABKAsyIC5mbHl0ZWlkbDIuYXBwLlJlcGxpY2FJZGVudGlmaWVyQga6SAPIAQESOwoQc3RydWN0dXJlZF9saW5lcxgDIAMoCzIhLmZseXRlaWRsMi5sb2dzLmRhdGFwbGFuZS5Mb2dMaW5lIjYKDUxvZ0xpbmVzQmF0Y2gSJQoEbG9ncxgBIAMoCzIXLmZseXRlaWRsMi5hcHAuTG9nTGluZXMiyQEKEFRhaWxMb2dzUmVzcG9uc2USOAoIcmVwbGljYXMYASABKAsyJC5mbHl0ZWlkbDIuYXBwLlJlcGxpY2FJZGVudGlmaWVyTGlzdEgAEjsKCWxvZ19saW5lcxgCIAEoCzIiLmZseXRlaWRsMi5sb2dzLmRhdGFwbGFuZS5Mb2dMaW5lc0ICGAFIABIvCgdiYXRjaGVzGAMgASgLMhwuZmx5dGVpZGwyLmFwcC5Mb2dMaW5lc0JhdGNoSABCDQoEcmVzcBIFukgCCAFCsgEKEWNvbS5mbHl0ZWlkbDIuYXBwQhNBcHBMb2dzUGF5bG9hZFByb3RvSAJQAVoxZ2l0aHViLmNvbS9mbHl0ZW9yZy9mbHl0ZS92Mi9nZW4vZ28vZmx5dGVpZGwyL2FwcKICA0ZBWKoCDUZseXRlaWRsMi5BcHDKAg1GbHl0ZWlkbDJcQXBw4gIZRmx5dGVpZGwyXEFwcFxHUEJNZXRhZGF0YeoCDkZseXRlaWRsMjo6QXBwYgZwcm90bzM", [file_buf_validate_validate, file_flyteidl2_app_app_definition, file_flyteidl2_app_replica_definition, file_flyteidl2_logs_dataplane_payload]); + +/** + * @generated from message flyteidl2.app.TailLogsRequest + */ +export type TailLogsRequest = Message<"flyteidl2.app.TailLogsRequest"> & { + /** + * @generated from oneof flyteidl2.app.TailLogsRequest.target + */ + target: { + /** + * Identifier of the application to get logs for. + * + * @generated from field: flyteidl2.app.Identifier app_id = 1; + */ + value: Identifier; + case: "appId"; + } | { + /** + * Identifier of the replica to get logs for. + * + * @generated from field: flyteidl2.app.ReplicaIdentifier replica_id = 2; + */ + value: ReplicaIdentifier; + case: "replicaId"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.app.TailLogsRequest. + * Use `create(TailLogsRequestSchema)` to create a new message. + */ +export const TailLogsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_logs_payload, 0); + +/** + * @generated from message flyteidl2.app.ReplicaIdentifierList + */ +export type ReplicaIdentifierList = Message<"flyteidl2.app.ReplicaIdentifierList"> & { + /** + * @generated from field: repeated flyteidl2.app.ReplicaIdentifier replicas = 1; + */ + replicas: ReplicaIdentifier[]; +}; + +/** + * Describes the message flyteidl2.app.ReplicaIdentifierList. + * Use `create(ReplicaIdentifierListSchema)` to create a new message. + */ +export const ReplicaIdentifierListSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_logs_payload, 1); + +/** + * @generated from message flyteidl2.app.LogLines + */ +export type LogLines = Message<"flyteidl2.app.LogLines"> & { + /** + * @generated from field: repeated string lines = 1 [deprecated = true]; + * @deprecated + */ + lines: string[]; + + /** + * @generated from field: flyteidl2.app.ReplicaIdentifier replica_id = 2; + */ + replicaId?: ReplicaIdentifier; + + /** + * @generated from field: repeated flyteidl2.logs.dataplane.LogLine structured_lines = 3; + */ + structuredLines: LogLine[]; +}; + +/** + * Describes the message flyteidl2.app.LogLines. + * Use `create(LogLinesSchema)` to create a new message. + */ +export const LogLinesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_logs_payload, 2); + +/** + * @generated from message flyteidl2.app.LogLinesBatch + */ +export type LogLinesBatch = Message<"flyteidl2.app.LogLinesBatch"> & { + /** + * @generated from field: repeated flyteidl2.app.LogLines logs = 1; + */ + logs: LogLines[]; +}; + +/** + * Describes the message flyteidl2.app.LogLinesBatch. + * Use `create(LogLinesBatchSchema)` to create a new message. + */ +export const LogLinesBatchSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_logs_payload, 3); + +/** + * @generated from message flyteidl2.app.TailLogsResponse + */ +export type TailLogsResponse = Message<"flyteidl2.app.TailLogsResponse"> & { + /** + * @generated from oneof flyteidl2.app.TailLogsResponse.resp + */ + resp: { + /** + * Replicas lists the replicas that the logs are being tailed for. This is expected to be the first + * message to be sent in the stream but also can be sent at any later time to update the list of + * replicas being tailed. + * + * @generated from field: flyteidl2.app.ReplicaIdentifierList replicas = 1; + */ + value: ReplicaIdentifierList; + case: "replicas"; + } | { + /** + * The latest log lines for the application. + * Deprecated, use batches instead. + * + * @generated from field: flyteidl2.logs.dataplane.LogLines log_lines = 2 [deprecated = true]; + * @deprecated + */ + value: LogLines$1; + case: "logLines"; + } | { + /** + * The latest log lines for the application. + * + * @generated from field: flyteidl2.app.LogLinesBatch batches = 3; + */ + value: LogLinesBatch; + case: "batches"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.app.TailLogsResponse. + * Use `create(TailLogsResponseSchema)` to create a new message. + */ +export const TailLogsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_logs_payload, 4); + diff --git a/gen/ts/flyteidl2/app/app_logs_service_pb.ts b/gen/ts/flyteidl2/app/app_logs_service_pb.ts new file mode 100644 index 0000000000..a64228b1b1 --- /dev/null +++ b/gen/ts/flyteidl2/app/app_logs_service_pb.ts @@ -0,0 +1,30 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/app/app_logs_service.proto (package flyteidl2.app, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import type { TailLogsRequestSchema, TailLogsResponseSchema } from "./app_logs_payload_pb.ts"; +import { file_flyteidl2_app_app_logs_payload } from "./app_logs_payload_pb.ts"; + +/** + * Describes the file flyteidl2/app/app_logs_service.proto. + */ +export const file_flyteidl2_app_app_logs_service: GenFile = /*@__PURE__*/ + fileDesc("CiRmbHl0ZWlkbDIvYXBwL2FwcF9sb2dzX3NlcnZpY2UucHJvdG8SDWZseXRlaWRsMi5hcHAyZAoOQXBwTG9nc1NlcnZpY2USUgoIVGFpbExvZ3MSHi5mbHl0ZWlkbDIuYXBwLlRhaWxMb2dzUmVxdWVzdBofLmZseXRlaWRsMi5hcHAuVGFpbExvZ3NSZXNwb25zZSIDkAIBMAFCsgEKEWNvbS5mbHl0ZWlkbDIuYXBwQhNBcHBMb2dzU2VydmljZVByb3RvSAJQAVoxZ2l0aHViLmNvbS9mbHl0ZW9yZy9mbHl0ZS92Mi9nZW4vZ28vZmx5dGVpZGwyL2FwcKICA0ZBWKoCDUZseXRlaWRsMi5BcHDKAg1GbHl0ZWlkbDJcQXBw4gIZRmx5dGVpZGwyXEFwcFxHUEJNZXRhZGF0YeoCDkZseXRlaWRsMjo6QXBwYgZwcm90bzM", [file_flyteidl2_app_app_logs_payload]); + +/** + * @generated from service flyteidl2.app.AppLogsService + */ +export const AppLogsService: GenService<{ + /** + * @generated from rpc flyteidl2.app.AppLogsService.TailLogs + */ + tailLogs: { + methodKind: "server_streaming"; + input: typeof TailLogsRequestSchema; + output: typeof TailLogsResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_app_app_logs_service, 0); + diff --git a/gen/ts/flyteidl2/app/app_payload_pb.ts b/gen/ts/flyteidl2/app/app_payload_pb.ts new file mode 100644 index 0000000000..6876cad611 --- /dev/null +++ b/gen/ts/flyteidl2/app/app_payload_pb.ts @@ -0,0 +1,530 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/app/app_payload.proto (package flyteidl2.app, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { App, Identifier, Ingress } from "./app_definition_pb.ts"; +import { file_flyteidl2_app_app_definition } from "./app_definition_pb.ts"; +import type { ClusterIdentifier, ProjectIdentifier } from "../common/identifier_pb.ts"; +import { file_flyteidl2_common_identifier } from "../common/identifier_pb.ts"; +import type { ListRequest as ListRequest$1 } from "../common/list_pb.ts"; +import { file_flyteidl2_common_list } from "../common/list_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/app/app_payload.proto. + */ +export const file_flyteidl2_app_app_payload: GenFile = /*@__PURE__*/ + fileDesc("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", [file_buf_validate_validate, file_flyteidl2_app_app_definition, file_flyteidl2_common_identifier, file_flyteidl2_common_list]); + +/** + * Request message for creating an app. + * + * @generated from message flyteidl2.app.CreateRequest + */ +export type CreateRequest = Message<"flyteidl2.app.CreateRequest"> & { + /** + * The app to be created. + * + * @generated from field: flyteidl2.app.App app = 1; + */ + app?: App; +}; + +/** + * Describes the message flyteidl2.app.CreateRequest. + * Use `create(CreateRequestSchema)` to create a new message. + */ +export const CreateRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 0); + +/** + * Response message for creating an app. + * + * @generated from message flyteidl2.app.CreateResponse + */ +export type CreateResponse = Message<"flyteidl2.app.CreateResponse"> & { + /** + * The created app. + * + * @generated from field: flyteidl2.app.App app = 1; + */ + app?: App; +}; + +/** + * Describes the message flyteidl2.app.CreateResponse. + * Use `create(CreateResponseSchema)` to create a new message. + */ +export const CreateResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 1); + +/** + * Request message for retrieving an app. + * + * @generated from message flyteidl2.app.GetRequest + */ +export type GetRequest = Message<"flyteidl2.app.GetRequest"> & { + /** + * @generated from oneof flyteidl2.app.GetRequest.identifier + */ + identifier: { + /** + * Identifier of the app to be retrieved. + * + * @generated from field: flyteidl2.app.Identifier app_id = 1; + */ + value: Identifier; + case: "appId"; + } | { + /** + * Ingress of the app to be retrieved. Only one field need to be set. + * If multiple fields are set, they must resolve into the same app. + * Otherwise, an error is returned. + * + * @generated from field: flyteidl2.app.Ingress ingress = 2; + */ + value: Ingress; + case: "ingress"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.app.GetRequest. + * Use `create(GetRequestSchema)` to create a new message. + */ +export const GetRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 2); + +/** + * Response message for retrieving an app. + * + * @generated from message flyteidl2.app.GetResponse + */ +export type GetResponse = Message<"flyteidl2.app.GetResponse"> & { + /** + * The retrieved app. + * + * @generated from field: flyteidl2.app.App app = 1; + */ + app?: App; +}; + +/** + * Describes the message flyteidl2.app.GetResponse. + * Use `create(GetResponseSchema)` to create a new message. + */ +export const GetResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 3); + +/** + * Request message for updating an app. + * + * @generated from message flyteidl2.app.UpdateRequest + */ +export type UpdateRequest = Message<"flyteidl2.app.UpdateRequest"> & { + /** + * The app to be updated. + * + * @generated from field: flyteidl2.app.App app = 1; + */ + app?: App; + + /** + * @generated from field: string reason = 2; + */ + reason: string; +}; + +/** + * Describes the message flyteidl2.app.UpdateRequest. + * Use `create(UpdateRequestSchema)` to create a new message. + */ +export const UpdateRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 4); + +/** + * Response message for updating an app. + * + * @generated from message flyteidl2.app.UpdateResponse + */ +export type UpdateResponse = Message<"flyteidl2.app.UpdateResponse"> & { + /** + * The updated app. + * + * @generated from field: flyteidl2.app.App app = 1; + */ + app?: App; +}; + +/** + * Describes the message flyteidl2.app.UpdateResponse. + * Use `create(UpdateResponseSchema)` to create a new message. + */ +export const UpdateResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 5); + +/** + * Request message for deleting an app. + * + * @generated from message flyteidl2.app.DeleteRequest + */ +export type DeleteRequest = Message<"flyteidl2.app.DeleteRequest"> & { + /** + * Identifier of the app to be deleted. + * + * @generated from field: flyteidl2.app.Identifier app_id = 1; + */ + appId?: Identifier; +}; + +/** + * Describes the message flyteidl2.app.DeleteRequest. + * Use `create(DeleteRequestSchema)` to create a new message. + */ +export const DeleteRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 6); + +/** + * Response message for deleting an app. + * + * @generated from message flyteidl2.app.DeleteResponse + */ +export type DeleteResponse = Message<"flyteidl2.app.DeleteResponse"> & { +}; + +/** + * Describes the message flyteidl2.app.DeleteResponse. + * Use `create(DeleteResponseSchema)` to create a new message. + */ +export const DeleteResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 7); + +/** + * Request message for listing apps. + * + * @generated from message flyteidl2.app.ListRequest + */ +export type ListRequest = Message<"flyteidl2.app.ListRequest"> & { + /** + * Common list request parameters. + * + * @generated from field: flyteidl2.common.ListRequest request = 1; + */ + request?: ListRequest$1; + + /** + * @generated from oneof flyteidl2.app.ListRequest.filter_by + */ + filterBy: { + /** + * Organization name for filtering apps. + * + * @generated from field: string org = 2; + */ + value: string; + case: "org"; + } | { + /** + * Cluster identifier for filtering apps. + * + * @generated from field: flyteidl2.common.ClusterIdentifier cluster_id = 3; + */ + value: ClusterIdentifier; + case: "clusterId"; + } | { + /** + * Project identifier for filtering apps. + * + * @generated from field: flyteidl2.common.ProjectIdentifier project = 4; + */ + value: ProjectIdentifier; + case: "project"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.app.ListRequest. + * Use `create(ListRequestSchema)` to create a new message. + */ +export const ListRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 8); + +/** + * Response message for listing apps. + * + * @generated from message flyteidl2.app.ListResponse + */ +export type ListResponse = Message<"flyteidl2.app.ListResponse"> & { + /** + * List of apps. + * + * @generated from field: repeated flyteidl2.app.App apps = 1; + */ + apps: App[]; + + /** + * Token for fetching the next page of results, if any. + * + * @generated from field: string token = 2; + */ + token: string; +}; + +/** + * Describes the message flyteidl2.app.ListResponse. + * Use `create(ListResponseSchema)` to create a new message. + */ +export const ListResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 9); + +/** + * Request message for watching app events. + * + * @generated from message flyteidl2.app.WatchRequest + */ +export type WatchRequest = Message<"flyteidl2.app.WatchRequest"> & { + /** + * @generated from oneof flyteidl2.app.WatchRequest.target + */ + target: { + /** + * Organization name for filtering events. + * + * @generated from field: string org = 1; + */ + value: string; + case: "org"; + } | { + /** + * Cluster identifier for filtering events. + * + * @generated from field: flyteidl2.common.ClusterIdentifier cluster_id = 2; + */ + value: ClusterIdentifier; + case: "clusterId"; + } | { + /** + * Project identifier for filtering events. + * + * @generated from field: flyteidl2.common.ProjectIdentifier project = 3; + */ + value: ProjectIdentifier; + case: "project"; + } | { + /** + * App identifier for filtering events. + * + * @generated from field: flyteidl2.app.Identifier app_id = 4; + */ + value: Identifier; + case: "appId"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.app.WatchRequest. + * Use `create(WatchRequestSchema)` to create a new message. + */ +export const WatchRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 10); + +/** + * Event message for app creation. + * + * @generated from message flyteidl2.app.CreateEvent + */ +export type CreateEvent = Message<"flyteidl2.app.CreateEvent"> & { + /** + * The created app. + * + * @generated from field: flyteidl2.app.App app = 1; + */ + app?: App; +}; + +/** + * Describes the message flyteidl2.app.CreateEvent. + * Use `create(CreateEventSchema)` to create a new message. + */ +export const CreateEventSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 11); + +/** + * Event message for app update. + * + * @generated from message flyteidl2.app.UpdateEvent + */ +export type UpdateEvent = Message<"flyteidl2.app.UpdateEvent"> & { + /** + * The updated app. + * + * @generated from field: flyteidl2.app.App updated_app = 1; + */ + updatedApp?: App; + + /** + * The old app before the update. + * + * @generated from field: flyteidl2.app.App old_app = 2; + */ + oldApp?: App; +}; + +/** + * Describes the message flyteidl2.app.UpdateEvent. + * Use `create(UpdateEventSchema)` to create a new message. + */ +export const UpdateEventSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 12); + +/** + * Event message for app deletion. + * + * @generated from message flyteidl2.app.DeleteEvent + */ +export type DeleteEvent = Message<"flyteidl2.app.DeleteEvent"> & { + /** + * The deleted app. + * + * @generated from field: flyteidl2.app.App app = 1; + */ + app?: App; +}; + +/** + * Describes the message flyteidl2.app.DeleteEvent. + * Use `create(DeleteEventSchema)` to create a new message. + */ +export const DeleteEventSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 13); + +/** + * Response message for watching app events. + * + * @generated from message flyteidl2.app.WatchResponse + */ +export type WatchResponse = Message<"flyteidl2.app.WatchResponse"> & { + /** + * @generated from oneof flyteidl2.app.WatchResponse.event + */ + event: { + /** + * Event for app creation. + * + * @generated from field: flyteidl2.app.CreateEvent create_event = 1; + */ + value: CreateEvent; + case: "createEvent"; + } | { + /** + * Event for app update. + * + * @generated from field: flyteidl2.app.UpdateEvent update_event = 2; + */ + value: UpdateEvent; + case: "updateEvent"; + } | { + /** + * Event for app deletion. + * + * @generated from field: flyteidl2.app.DeleteEvent delete_event = 3; + */ + value: DeleteEvent; + case: "deleteEvent"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.app.WatchResponse. + * Use `create(WatchResponseSchema)` to create a new message. + */ +export const WatchResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 14); + +/** + * Request message for updating app status. + * + * @generated from message flyteidl2.app.UpdateStatusRequest + */ +export type UpdateStatusRequest = Message<"flyteidl2.app.UpdateStatusRequest"> & { + /** + * The app with updated status. + * + * @generated from field: flyteidl2.app.App app = 1; + */ + app?: App; +}; + +/** + * Describes the message flyteidl2.app.UpdateStatusRequest. + * Use `create(UpdateStatusRequestSchema)` to create a new message. + */ +export const UpdateStatusRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 15); + +/** + * Response message for updating app status. + * + * @generated from message flyteidl2.app.UpdateStatusResponse + */ +export type UpdateStatusResponse = Message<"flyteidl2.app.UpdateStatusResponse"> & { + /** + * The app with updated status. + * + * @generated from field: flyteidl2.app.App app = 1; + */ + app?: App; +}; + +/** + * Describes the message flyteidl2.app.UpdateStatusResponse. + * Use `create(UpdateStatusResponseSchema)` to create a new message. + */ +export const UpdateStatusResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 16); + +/** + * Request message for leasing apps. + * + * @generated from message flyteidl2.app.LeaseRequest + */ +export type LeaseRequest = Message<"flyteidl2.app.LeaseRequest"> & { + /** + * Cluster identifier for leasing apps. + * + * @generated from field: flyteidl2.common.ClusterIdentifier id = 1; + */ + id?: ClusterIdentifier; +}; + +/** + * Describes the message flyteidl2.app.LeaseRequest. + * Use `create(LeaseRequestSchema)` to create a new message. + */ +export const LeaseRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 17); + +/** + * Response message for leasing apps. + * + * @generated from message flyteidl2.app.LeaseResponse + */ +export type LeaseResponse = Message<"flyteidl2.app.LeaseResponse"> & { + /** + * List of leased apps. + * + * @generated from field: repeated flyteidl2.app.App apps = 1; + */ + apps: App[]; +}; + +/** + * Describes the message flyteidl2.app.LeaseResponse. + * Use `create(LeaseResponseSchema)` to create a new message. + */ +export const LeaseResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_app_payload, 18); + diff --git a/gen/ts/flyteidl2/app/app_service_pb.ts b/gen/ts/flyteidl2/app/app_service_pb.ts new file mode 100644 index 0000000000..e584748724 --- /dev/null +++ b/gen/ts/flyteidl2/app/app_service_pb.ts @@ -0,0 +1,104 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/app/app_service.proto (package flyteidl2.app, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import type { CreateRequestSchema, CreateResponseSchema, DeleteRequestSchema, DeleteResponseSchema, GetRequestSchema, GetResponseSchema, LeaseRequestSchema, LeaseResponseSchema, ListRequestSchema, ListResponseSchema, UpdateRequestSchema, UpdateResponseSchema, UpdateStatusRequestSchema, UpdateStatusResponseSchema, WatchRequestSchema, WatchResponseSchema } from "./app_payload_pb.ts"; +import { file_flyteidl2_app_app_payload } from "./app_payload_pb.ts"; + +/** + * Describes the file flyteidl2/app/app_service.proto. + */ +export const file_flyteidl2_app_app_service: GenFile = /*@__PURE__*/ + fileDesc("Ch9mbHl0ZWlkbDIvYXBwL2FwcF9zZXJ2aWNlLnByb3RvEg1mbHl0ZWlkbDIuYXBwMt4ECgpBcHBTZXJ2aWNlEkcKBkNyZWF0ZRIcLmZseXRlaWRsMi5hcHAuQ3JlYXRlUmVxdWVzdBodLmZseXRlaWRsMi5hcHAuQ3JlYXRlUmVzcG9uc2UiABJBCgNHZXQSGS5mbHl0ZWlkbDIuYXBwLkdldFJlcXVlc3QaGi5mbHl0ZWlkbDIuYXBwLkdldFJlc3BvbnNlIgOQAgESRwoGVXBkYXRlEhwuZmx5dGVpZGwyLmFwcC5VcGRhdGVSZXF1ZXN0Gh0uZmx5dGVpZGwyLmFwcC5VcGRhdGVSZXNwb25zZSIAElkKDFVwZGF0ZVN0YXR1cxIiLmZseXRlaWRsMi5hcHAuVXBkYXRlU3RhdHVzUmVxdWVzdBojLmZseXRlaWRsMi5hcHAuVXBkYXRlU3RhdHVzUmVzcG9uc2UiABJHCgZEZWxldGUSHC5mbHl0ZWlkbDIuYXBwLkRlbGV0ZVJlcXVlc3QaHS5mbHl0ZWlkbDIuYXBwLkRlbGV0ZVJlc3BvbnNlIgASRAoETGlzdBIaLmZseXRlaWRsMi5hcHAuTGlzdFJlcXVlc3QaGy5mbHl0ZWlkbDIuYXBwLkxpc3RSZXNwb25zZSIDkAIBEkkKBVdhdGNoEhsuZmx5dGVpZGwyLmFwcC5XYXRjaFJlcXVlc3QaHC5mbHl0ZWlkbDIuYXBwLldhdGNoUmVzcG9uc2UiA5ACATABEkYKBUxlYXNlEhsuZmx5dGVpZGwyLmFwcC5MZWFzZVJlcXVlc3QaHC5mbHl0ZWlkbDIuYXBwLkxlYXNlUmVzcG9uc2UiADABQq4BChFjb20uZmx5dGVpZGwyLmFwcEIPQXBwU2VydmljZVByb3RvSAJQAVoxZ2l0aHViLmNvbS9mbHl0ZW9yZy9mbHl0ZS92Mi9nZW4vZ28vZmx5dGVpZGwyL2FwcKICA0ZBWKoCDUZseXRlaWRsMi5BcHDKAg1GbHl0ZWlkbDJcQXBw4gIZRmx5dGVpZGwyXEFwcFxHUEJNZXRhZGF0YeoCDkZseXRlaWRsMjo6QXBwYgZwcm90bzM", [file_flyteidl2_app_app_payload]); + +/** + * AppService defines the service for managing apps. + * + * @generated from service flyteidl2.app.AppService + */ +export const AppService: GenService<{ + /** + * Create creates a new app. + * + * @generated from rpc flyteidl2.app.AppService.Create + */ + create: { + methodKind: "unary"; + input: typeof CreateRequestSchema; + output: typeof CreateResponseSchema; + }, + /** + * Get retrieves an app by its identifier. + * + * @generated from rpc flyteidl2.app.AppService.Get + */ + get: { + methodKind: "unary"; + input: typeof GetRequestSchema; + output: typeof GetResponseSchema; + }, + /** + * Update updates an existing app. + * + * @generated from rpc flyteidl2.app.AppService.Update + */ + update: { + methodKind: "unary"; + input: typeof UpdateRequestSchema; + output: typeof UpdateResponseSchema; + }, + /** + * UpdateStatus updates the status of an existing app. + * + * @generated from rpc flyteidl2.app.AppService.UpdateStatus + */ + updateStatus: { + methodKind: "unary"; + input: typeof UpdateStatusRequestSchema; + output: typeof UpdateStatusResponseSchema; + }, + /** + * Delete deletes an app by its identifier. + * + * @generated from rpc flyteidl2.app.AppService.Delete + */ + delete: { + methodKind: "unary"; + input: typeof DeleteRequestSchema; + output: typeof DeleteResponseSchema; + }, + /** + * List lists all apps with optional filtering. + * + * @generated from rpc flyteidl2.app.AppService.List + */ + list: { + methodKind: "unary"; + input: typeof ListRequestSchema; + output: typeof ListResponseSchema; + }, + /** + * Watch watches for app events. + * + * @generated from rpc flyteidl2.app.AppService.Watch + */ + watch: { + methodKind: "server_streaming"; + input: typeof WatchRequestSchema; + output: typeof WatchResponseSchema; + }, + /** + * Lease leases apps. + * + * @generated from rpc flyteidl2.app.AppService.Lease + */ + lease: { + methodKind: "server_streaming"; + input: typeof LeaseRequestSchema; + output: typeof LeaseResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_app_app_service, 0); + diff --git a/gen/ts/flyteidl2/app/replica_definition_pb.ts b/gen/ts/flyteidl2/app/replica_definition_pb.ts new file mode 100644 index 0000000000..bb39d38f88 --- /dev/null +++ b/gen/ts/flyteidl2/app/replica_definition_pb.ts @@ -0,0 +1,140 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/app/replica_definition.proto (package flyteidl2.app, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { Identifier } from "./app_definition_pb.ts"; +import { file_flyteidl2_app_app_definition } from "./app_definition_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/app/replica_definition.proto. + */ +export const file_flyteidl2_app_replica_definition: GenFile = /*@__PURE__*/ + fileDesc("CiZmbHl0ZWlkbDIvYXBwL3JlcGxpY2FfZGVmaW5pdGlvbi5wcm90bxINZmx5dGVpZGwyLmFwcCJdChFSZXBsaWNhSWRlbnRpZmllchIxCgZhcHBfaWQYASABKAsyGS5mbHl0ZWlkbDIuYXBwLklkZW50aWZpZXJCBrpIA8gBARIVCgRuYW1lGAIgASgJQge6SARyAhABIlUKC1JlcGxpY2FNZXRhEjQKAmlkGAEgASgLMiAuZmx5dGVpZGwyLmFwcC5SZXBsaWNhSWRlbnRpZmllckIGukgDyAEBEhAKCHJldmlzaW9uGAIgASgEIjQKC1JlcGxpY2FMaXN0EiUKBWl0ZW1zGAEgAygLMhYuZmx5dGVpZGwyLmFwcC5SZXBsaWNhIm0KB1JlcGxpY2ESNAoIbWV0YWRhdGEYASABKAsyGi5mbHl0ZWlkbDIuYXBwLlJlcGxpY2FNZXRhQga6SAPIAQESLAoGc3RhdHVzGAIgASgLMhwuZmx5dGVpZGwyLmFwcC5SZXBsaWNhU3RhdHVzIjoKDVJlcGxpY2FTdGF0dXMSGQoRZGVwbG95bWVudF9zdGF0dXMYASABKAkSDgoGcmVhc29uGAIgASgJQrUBChFjb20uZmx5dGVpZGwyLmFwcEIWUmVwbGljYURlZmluaXRpb25Qcm90b0gCUAFaMWdpdGh1Yi5jb20vZmx5dGVvcmcvZmx5dGUvdjIvZ2VuL2dvL2ZseXRlaWRsMi9hcHCiAgNGQViqAg1GbHl0ZWlkbDIuQXBwygINRmx5dGVpZGwyXEFwcOICGUZseXRlaWRsMlxBcHBcR1BCTWV0YWRhdGHqAg5GbHl0ZWlkbDI6OkFwcGIGcHJvdG8z", [file_buf_validate_validate, file_flyteidl2_app_app_definition]); + +/** + * @generated from message flyteidl2.app.ReplicaIdentifier + */ +export type ReplicaIdentifier = Message<"flyteidl2.app.ReplicaIdentifier"> & { + /** + * ID of the app. + * + * @generated from field: flyteidl2.app.Identifier app_id = 1; + */ + appId?: Identifier; + + /** + * @generated from field: string name = 2; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.app.ReplicaIdentifier. + * Use `create(ReplicaIdentifierSchema)` to create a new message. + */ +export const ReplicaIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_replica_definition, 0); + +/** + * @generated from message flyteidl2.app.ReplicaMeta + */ +export type ReplicaMeta = Message<"flyteidl2.app.ReplicaMeta"> & { + /** + * ID of the replica. + * + * @generated from field: flyteidl2.app.ReplicaIdentifier id = 1; + */ + id?: ReplicaIdentifier; + + /** + * Revision of the replica object. + * + * @generated from field: uint64 revision = 2; + */ + revision: bigint; +}; + +/** + * Describes the message flyteidl2.app.ReplicaMeta. + * Use `create(ReplicaMetaSchema)` to create a new message. + */ +export const ReplicaMetaSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_replica_definition, 1); + +/** + * @generated from message flyteidl2.app.ReplicaList + */ +export type ReplicaList = Message<"flyteidl2.app.ReplicaList"> & { + /** + * List of replicas. + * + * @generated from field: repeated flyteidl2.app.Replica items = 1; + */ + items: Replica[]; +}; + +/** + * Describes the message flyteidl2.app.ReplicaList. + * Use `create(ReplicaListSchema)` to create a new message. + */ +export const ReplicaListSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_replica_definition, 2); + +/** + * Represents a replica of an app with its specification and status. + * + * @generated from message flyteidl2.app.Replica + */ +export type Replica = Message<"flyteidl2.app.Replica"> & { + /** + * Metadata of the app. + * + * @generated from field: flyteidl2.app.ReplicaMeta metadata = 1; + */ + metadata?: ReplicaMeta; + + /** + * Status of the app. + * + * @generated from field: flyteidl2.app.ReplicaStatus status = 2; + */ + status?: ReplicaStatus; +}; + +/** + * Describes the message flyteidl2.app.Replica. + * Use `create(ReplicaSchema)` to create a new message. + */ +export const ReplicaSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_replica_definition, 3); + +/** + * Represents the status of the replica. + * + * @generated from message flyteidl2.app.ReplicaStatus + */ +export type ReplicaStatus = Message<"flyteidl2.app.ReplicaStatus"> & { + /** + * Current deployment status of the replica. + * + * @generated from field: string deployment_status = 1; + */ + deploymentStatus: string; + + /** + * @generated from field: string reason = 2; + */ + reason: string; +}; + +/** + * Describes the message flyteidl2.app.ReplicaStatus. + * Use `create(ReplicaStatusSchema)` to create a new message. + */ +export const ReplicaStatusSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_app_replica_definition, 4); + diff --git a/gen/ts/flyteidl2/auth/auth_service_pb.ts b/gen/ts/flyteidl2/auth/auth_service_pb.ts new file mode 100644 index 0000000000..dc6f94a669 --- /dev/null +++ b/gen/ts/flyteidl2/auth/auth_service_pb.ts @@ -0,0 +1,220 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/auth/auth_service.proto (package flyteidl2.auth, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/auth/auth_service.proto. + */ +export const file_flyteidl2_auth_auth_service: GenFile = /*@__PURE__*/ + fileDesc("CiFmbHl0ZWlkbDIvYXV0aC9hdXRoX3NlcnZpY2UucHJvdG8SDmZseXRlaWRsMi5hdXRoIhoKGEdldE9BdXRoMk1ldGFkYXRhUmVxdWVzdCLQAgoZR2V0T0F1dGgyTWV0YWRhdGFSZXNwb25zZRIOCgZpc3N1ZXIYASABKAkSHgoWYXV0aG9yaXphdGlvbl9lbmRwb2ludBgCIAEoCRIWCg50b2tlbl9lbmRwb2ludBgDIAEoCRIgChhyZXNwb25zZV90eXBlc19zdXBwb3J0ZWQYBCADKAkSGAoQc2NvcGVzX3N1cHBvcnRlZBgFIAMoCRItCiV0b2tlbl9lbmRwb2ludF9hdXRoX21ldGhvZHNfc3VwcG9ydGVkGAYgAygJEhAKCGp3a3NfdXJpGAcgASgJEigKIGNvZGVfY2hhbGxlbmdlX21ldGhvZHNfc3VwcG9ydGVkGAggAygJEh0KFWdyYW50X3R5cGVzX3N1cHBvcnRlZBgJIAMoCRIlCh1kZXZpY2VfYXV0aG9yaXphdGlvbl9lbmRwb2ludBgKIAEoCSIeChxHZXRQdWJsaWNDbGllbnRDb25maWdSZXF1ZXN0Iq0BCh1HZXRQdWJsaWNDbGllbnRDb25maWdSZXNwb25zZRIRCgljbGllbnRfaWQYASABKAkSFAoMcmVkaXJlY3RfdXJpGAIgASgJEg4KBnNjb3BlcxgDIAMoCRIiChphdXRob3JpemF0aW9uX21ldGFkYXRhX2tleRgEIAEoCRIdChVzZXJ2aWNlX2h0dHBfZW5kcG9pbnQYBSABKAkSEAoIYXVkaWVuY2UYBiABKAky/wEKE0F1dGhNZXRhZGF0YVNlcnZpY2USbQoRR2V0T0F1dGgyTWV0YWRhdGESKC5mbHl0ZWlkbDIuYXV0aC5HZXRPQXV0aDJNZXRhZGF0YVJlcXVlc3QaKS5mbHl0ZWlkbDIuYXV0aC5HZXRPQXV0aDJNZXRhZGF0YVJlc3BvbnNlIgOQAgESeQoVR2V0UHVibGljQ2xpZW50Q29uZmlnEiwuZmx5dGVpZGwyLmF1dGguR2V0UHVibGljQ2xpZW50Q29uZmlnUmVxdWVzdBotLmZseXRlaWRsMi5hdXRoLkdldFB1YmxpY0NsaWVudENvbmZpZ1Jlc3BvbnNlIgOQAgFCtQEKEmNvbS5mbHl0ZWlkbDIuYXV0aEIQQXV0aFNlcnZpY2VQcm90b0gCUAFaMmdpdGh1Yi5jb20vZmx5dGVvcmcvZmx5dGUvdjIvZ2VuL2dvL2ZseXRlaWRsMi9hdXRoogIDRkFYqgIORmx5dGVpZGwyLkF1dGjKAg5GbHl0ZWlkbDJcQXV0aOICGkZseXRlaWRsMlxBdXRoXEdQQk1ldGFkYXRh6gIPRmx5dGVpZGwyOjpBdXRoYgZwcm90bzM"); + +/** + * @generated from message flyteidl2.auth.GetOAuth2MetadataRequest + */ +export type GetOAuth2MetadataRequest = Message<"flyteidl2.auth.GetOAuth2MetadataRequest"> & { +}; + +/** + * Describes the message flyteidl2.auth.GetOAuth2MetadataRequest. + * Use `create(GetOAuth2MetadataRequestSchema)` to create a new message. + */ +export const GetOAuth2MetadataRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_auth_auth_service, 0); + +/** + * OAuth2MetadataResponse defines an RFC-Compliant response for /.well-known/oauth-authorization-server metadata + * as defined in https://tools.ietf.org/html/rfc8414 + * + * @generated from message flyteidl2.auth.GetOAuth2MetadataResponse + */ +export type GetOAuth2MetadataResponse = Message<"flyteidl2.auth.GetOAuth2MetadataResponse"> & { + /** + * Defines the issuer string in all JWT tokens this server issues. The issuer can be admin itself or an external + * issuer. + * + * @generated from field: string issuer = 1; + */ + issuer: string; + + /** + * URL of the authorization server's authorization endpoint [RFC6749]. This is REQUIRED unless no grant types are + * supported that use the authorization endpoint. + * + * @generated from field: string authorization_endpoint = 2; + */ + authorizationEndpoint: string; + + /** + * URL of the authorization server's token endpoint [RFC6749]. + * + * @generated from field: string token_endpoint = 3; + */ + tokenEndpoint: string; + + /** + * Array containing a list of the OAuth 2.0 response_type values that this authorization server supports. + * + * @generated from field: repeated string response_types_supported = 4; + */ + responseTypesSupported: string[]; + + /** + * JSON array containing a list of the OAuth 2.0 [RFC6749] scope values that this authorization server supports. + * + * @generated from field: repeated string scopes_supported = 5; + */ + scopesSupported: string[]; + + /** + * JSON array containing a list of client authentication methods supported by this token endpoint. + * + * @generated from field: repeated string token_endpoint_auth_methods_supported = 6; + */ + tokenEndpointAuthMethodsSupported: string[]; + + /** + * URL of the authorization server's JWK Set [JWK] document. The referenced document contains the signing key(s) the + * client uses to validate signatures from the authorization server. + * + * @generated from field: string jwks_uri = 7; + */ + jwksUri: string; + + /** + * JSON array containing a list of Proof Key for Code Exchange (PKCE) [RFC7636] code challenge methods supported by + * this authorization server. + * + * @generated from field: repeated string code_challenge_methods_supported = 8; + */ + codeChallengeMethodsSupported: string[]; + + /** + * JSON array containing a list of the OAuth 2.0 grant type values that this authorization server supports. + * + * @generated from field: repeated string grant_types_supported = 9; + */ + grantTypesSupported: string[]; + + /** + * URL of the authorization server's device authorization endpoint, as defined in Section 3.1 of [RFC8628] + * + * @generated from field: string device_authorization_endpoint = 10; + */ + deviceAuthorizationEndpoint: string; +}; + +/** + * Describes the message flyteidl2.auth.GetOAuth2MetadataResponse. + * Use `create(GetOAuth2MetadataResponseSchema)` to create a new message. + */ +export const GetOAuth2MetadataResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_auth_auth_service, 1); + +/** + * @generated from message flyteidl2.auth.GetPublicClientConfigRequest + */ +export type GetPublicClientConfigRequest = Message<"flyteidl2.auth.GetPublicClientConfigRequest"> & { +}; + +/** + * Describes the message flyteidl2.auth.GetPublicClientConfigRequest. + * Use `create(GetPublicClientConfigRequestSchema)` to create a new message. + */ +export const GetPublicClientConfigRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_auth_auth_service, 2); + +/** + * FlyteClientResponse encapsulates public information that flyte clients (CLIs... etc.) can use to authenticate users. + * + * @generated from message flyteidl2.auth.GetPublicClientConfigResponse + */ +export type GetPublicClientConfigResponse = Message<"flyteidl2.auth.GetPublicClientConfigResponse"> & { + /** + * client_id to use when initiating OAuth2 authorization requests. + * + * @generated from field: string client_id = 1; + */ + clientId: string; + + /** + * redirect uri to use when initiating OAuth2 authorization requests. + * + * @generated from field: string redirect_uri = 2; + */ + redirectUri: string; + + /** + * scopes to request when initiating OAuth2 authorization requests. + * + * @generated from field: repeated string scopes = 3; + */ + scopes: string[]; + + /** + * Authorization Header to use when passing Access Tokens to the server. If not provided, the client should use the + * default http `Authorization` header. + * + * @generated from field: string authorization_metadata_key = 4; + */ + authorizationMetadataKey: string; + + /** + * ServiceHttpEndpoint points to the http endpoint for the backend. If empty, clients can assume the endpoint used + * to configure the gRPC connection can be used for the http one respecting the insecure flag to choose between + * SSL or no SSL connections. + * + * @generated from field: string service_http_endpoint = 5; + */ + serviceHttpEndpoint: string; + + /** + * audience to use when initiating OAuth2 authorization requests. + * + * @generated from field: string audience = 6; + */ + audience: string; +}; + +/** + * Describes the message flyteidl2.auth.GetPublicClientConfigResponse. + * Use `create(GetPublicClientConfigResponseSchema)` to create a new message. + */ +export const GetPublicClientConfigResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_auth_auth_service, 3); + +/** + * The following defines an RPC service that is also served over HTTP via grpc-gateway. + * Standard response codes for both are defined here: https://github.com/grpc-ecosystem/grpc-gateway/blob/master/runtime/errors.go + * RPCs defined in this service must be anonymously accessible. + * + * @generated from service flyteidl2.auth.AuthMetadataService + */ +export const AuthMetadataService: GenService<{ + /** + * Anonymously accessible. Retrieves local or external oauth authorization server metadata. + * + * @generated from rpc flyteidl2.auth.AuthMetadataService.GetOAuth2Metadata + */ + getOAuth2Metadata: { + methodKind: "unary"; + input: typeof GetOAuth2MetadataRequestSchema; + output: typeof GetOAuth2MetadataResponseSchema; + }, + /** + * Anonymously accessible. Retrieves the client information clients should use when initiating OAuth2 authorization + * requests. + * + * @generated from rpc flyteidl2.auth.AuthMetadataService.GetPublicClientConfig + */ + getPublicClientConfig: { + methodKind: "unary"; + input: typeof GetPublicClientConfigRequestSchema; + output: typeof GetPublicClientConfigResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_auth_auth_service, 0); + diff --git a/gen/ts/flyteidl2/auth/identity_pb.ts b/gen/ts/flyteidl2/auth/identity_pb.ts new file mode 100644 index 0000000000..81233b8a67 --- /dev/null +++ b/gen/ts/flyteidl2/auth/identity_pb.ts @@ -0,0 +1,118 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/auth/identity.proto (package flyteidl2.auth, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_google_protobuf_struct } from "@bufbuild/protobuf/wkt"; +import type { JsonObject, Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/auth/identity.proto. + */ +export const file_flyteidl2_auth_identity: GenFile = /*@__PURE__*/ + fileDesc("Ch1mbHl0ZWlkbDIvYXV0aC9pZGVudGl0eS5wcm90bxIOZmx5dGVpZGwyLmF1dGgiEQoPVXNlckluZm9SZXF1ZXN0IsoBChBVc2VySW5mb1Jlc3BvbnNlEg8KB3N1YmplY3QYASABKAkSDAoEbmFtZRgCIAEoCRIaChJwcmVmZXJyZWRfdXNlcm5hbWUYAyABKAkSEgoKZ2l2ZW5fbmFtZRgEIAEoCRITCgtmYW1pbHlfbmFtZRgFIAEoCRINCgVlbWFpbBgGIAEoCRIPCgdwaWN0dXJlGAcgASgJEjIKEWFkZGl0aW9uYWxfY2xhaW1zGAggASgLMhcuZ29vZ2xlLnByb3RvYnVmLlN0cnVjdDJiCg9JZGVudGl0eVNlcnZpY2USTwoIVXNlckluZm8SHy5mbHl0ZWlkbDIuYXV0aC5Vc2VySW5mb1JlcXVlc3QaIC5mbHl0ZWlkbDIuYXV0aC5Vc2VySW5mb1Jlc3BvbnNlIgBCsgEKEmNvbS5mbHl0ZWlkbDIuYXV0aEINSWRlbnRpdHlQcm90b0gCUAFaMmdpdGh1Yi5jb20vZmx5dGVvcmcvZmx5dGUvdjIvZ2VuL2dvL2ZseXRlaWRsMi9hdXRoogIDRkFYqgIORmx5dGVpZGwyLkF1dGjKAg5GbHl0ZWlkbDJcQXV0aOICGkZseXRlaWRsMlxBdXRoXEdQQk1ldGFkYXRh6gIPRmx5dGVpZGwyOjpBdXRoYgZwcm90bzM", [file_google_protobuf_struct]); + +/** + * @generated from message flyteidl2.auth.UserInfoRequest + */ +export type UserInfoRequest = Message<"flyteidl2.auth.UserInfoRequest"> & { +}; + +/** + * Describes the message flyteidl2.auth.UserInfoRequest. + * Use `create(UserInfoRequestSchema)` to create a new message. + */ +export const UserInfoRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_auth_identity, 0); + +/** + * See the OpenID Connect spec at https://openid.net/specs/openid-connect-core-1_0.html#UserInfoResponse for more information. + * + * @generated from message flyteidl2.auth.UserInfoResponse + */ +export type UserInfoResponse = Message<"flyteidl2.auth.UserInfoResponse"> & { + /** + * Locally unique and never reassigned identifier within the Issuer for the End-User, which is intended to be consumed + * by the Client. + * + * @generated from field: string subject = 1; + */ + subject: string; + + /** + * Full name + * + * @generated from field: string name = 2; + */ + name: string; + + /** + * Shorthand name by which the End-User wishes to be referred to + * + * @generated from field: string preferred_username = 3; + */ + preferredUsername: string; + + /** + * Given name(s) or first name(s) + * + * @generated from field: string given_name = 4; + */ + givenName: string; + + /** + * Surname(s) or last name(s) + * + * @generated from field: string family_name = 5; + */ + familyName: string; + + /** + * Preferred e-mail address + * + * @generated from field: string email = 6; + */ + email: string; + + /** + * Profile picture URL + * + * @generated from field: string picture = 7; + */ + picture: string; + + /** + * Additional claims + * + * @generated from field: google.protobuf.Struct additional_claims = 8; + */ + additionalClaims?: JsonObject; +}; + +/** + * Describes the message flyteidl2.auth.UserInfoResponse. + * Use `create(UserInfoResponseSchema)` to create a new message. + */ +export const UserInfoResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_auth_identity, 1); + +/** + * IdentityService defines an RPC Service that interacts with user/app identities. + * + * @generated from service flyteidl2.auth.IdentityService + */ +export const IdentityService: GenService<{ + /** + * Retrieves user information about the currently logged in user. + * + * @generated from rpc flyteidl2.auth.IdentityService.UserInfo + */ + userInfo: { + methodKind: "unary"; + input: typeof UserInfoRequestSchema; + output: typeof UserInfoResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_auth_identity, 0); + diff --git a/gen/ts/flyteidl2/cacheservice/cacheservice_pb.ts b/gen/ts/flyteidl2/cacheservice/cacheservice_pb.ts new file mode 100644 index 0000000000..9939d89ec6 --- /dev/null +++ b/gen/ts/flyteidl2/cacheservice/cacheservice_pb.ts @@ -0,0 +1,506 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/cacheservice/cacheservice.proto (package flyteidl2.cacheservice, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Identifier } from "../core/identifier_pb.ts"; +import { file_flyteidl2_core_identifier } from "../core/identifier_pb.ts"; +import type { LiteralMap } from "../core/literals_pb.ts"; +import { file_flyteidl2_core_literals } from "../core/literals_pb.ts"; +import type { Duration, Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_duration, file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/cacheservice/cacheservice.proto. + */ +export const file_flyteidl2_cacheservice_cacheservice: GenFile = /*@__PURE__*/ + fileDesc("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", [file_flyteidl2_core_identifier, file_flyteidl2_core_literals, file_google_protobuf_duration, file_google_protobuf_timestamp]); + +/** + * + * Additional metadata as key-value pairs + * + * @generated from message flyteidl2.cacheservice.KeyMapMetadata + */ +export type KeyMapMetadata = Message<"flyteidl2.cacheservice.KeyMapMetadata"> & { + /** + * Additional metadata as key-value pairs + * + * @generated from field: map values = 1; + */ + values: { [key: string]: string }; +}; + +/** + * Describes the message flyteidl2.cacheservice.KeyMapMetadata. + * Use `create(KeyMapMetadataSchema)` to create a new message. + */ +export const KeyMapMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_cacheservice, 0); + +/** + * + * Metadata for cached outputs, including the source identifier and timestamps. + * + * @generated from message flyteidl2.cacheservice.Metadata + */ +export type Metadata = Message<"flyteidl2.cacheservice.Metadata"> & { + /** + * Source task or workflow identifier + * + * @generated from field: flyteidl2.core.Identifier source_identifier = 1; + */ + sourceIdentifier?: Identifier; + + /** + * Additional metadata as key-value pairs + * + * @generated from field: flyteidl2.cacheservice.KeyMapMetadata key_map = 2; + */ + keyMap?: KeyMapMetadata; + + /** + * Creation timestamp + * + * @generated from field: google.protobuf.Timestamp created_at = 3; + */ + createdAt?: Timestamp; + + /** + * Last update timestamp + * + * @generated from field: google.protobuf.Timestamp last_updated_at = 4; + */ + lastUpdatedAt?: Timestamp; +}; + +/** + * Describes the message flyteidl2.cacheservice.Metadata. + * Use `create(MetadataSchema)` to create a new message. + */ +export const MetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_cacheservice, 1); + +/** + * + * Represents cached output, either as literals or an URI, with associated metadata. + * + * @generated from message flyteidl2.cacheservice.CachedOutput + */ +export type CachedOutput = Message<"flyteidl2.cacheservice.CachedOutput"> & { + /** + * @generated from oneof flyteidl2.cacheservice.CachedOutput.output + */ + output: { + /** + * Output literals + * + * @generated from field: flyteidl2.core.LiteralMap output_literals = 1; + */ + value: LiteralMap; + case: "outputLiterals"; + } | { + /** + * URI to output data + * + * @generated from field: string output_uri = 2; + */ + value: string; + case: "outputUri"; + } | { case: undefined; value?: undefined }; + + /** + * Associated metadata + * + * @generated from field: flyteidl2.cacheservice.Metadata metadata = 3; + */ + metadata?: Metadata; +}; + +/** + * Describes the message flyteidl2.cacheservice.CachedOutput. + * Use `create(CachedOutputSchema)` to create a new message. + */ +export const CachedOutputSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_cacheservice, 2); + +/** + * + * Request to retrieve cached data by key. + * + * @generated from message flyteidl2.cacheservice.GetCacheRequest + */ +export type GetCacheRequest = Message<"flyteidl2.cacheservice.GetCacheRequest"> & { + /** + * Cache key + * + * @generated from field: string key = 1; + */ + key: string; +}; + +/** + * Describes the message flyteidl2.cacheservice.GetCacheRequest. + * Use `create(GetCacheRequestSchema)` to create a new message. + */ +export const GetCacheRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_cacheservice, 3); + +/** + * + * Response with cached data for a given key. + * + * @generated from message flyteidl2.cacheservice.GetCacheResponse + */ +export type GetCacheResponse = Message<"flyteidl2.cacheservice.GetCacheResponse"> & { + /** + * Cached output + * + * @generated from field: flyteidl2.cacheservice.CachedOutput output = 1; + */ + output?: CachedOutput; +}; + +/** + * Describes the message flyteidl2.cacheservice.GetCacheResponse. + * Use `create(GetCacheResponseSchema)` to create a new message. + */ +export const GetCacheResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_cacheservice, 4); + +/** + * @generated from message flyteidl2.cacheservice.OverwriteOutput + */ +export type OverwriteOutput = Message<"flyteidl2.cacheservice.OverwriteOutput"> & { + /** + * Overwrite flag + * + * @generated from field: bool overwrite = 1; + */ + overwrite: boolean; + + /** + * Delete existing blob + * + * @generated from field: bool delete_blob = 2; + */ + deleteBlob: boolean; + + /** + * Maximum age of the cached output since last update + * + * @generated from field: google.protobuf.Duration max_age = 3; + */ + maxAge?: Duration; +}; + +/** + * Describes the message flyteidl2.cacheservice.OverwriteOutput. + * Use `create(OverwriteOutputSchema)` to create a new message. + */ +export const OverwriteOutputSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_cacheservice, 5); + +/** + * + * Request to store/update cached data by key. + * + * @generated from message flyteidl2.cacheservice.PutCacheRequest + */ +export type PutCacheRequest = Message<"flyteidl2.cacheservice.PutCacheRequest"> & { + /** + * Cache key + * + * @generated from field: string key = 1; + */ + key: string; + + /** + * Output to cache + * + * @generated from field: flyteidl2.cacheservice.CachedOutput output = 2; + */ + output?: CachedOutput; + + /** + * Overwrite flag if exists + * + * @generated from field: flyteidl2.cacheservice.OverwriteOutput overwrite = 3; + */ + overwrite?: OverwriteOutput; +}; + +/** + * Describes the message flyteidl2.cacheservice.PutCacheRequest. + * Use `create(PutCacheRequestSchema)` to create a new message. + */ +export const PutCacheRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_cacheservice, 6); + +/** + * + * Response message of cache store/update operation. + * + * Empty, success indicated by no errors + * + * @generated from message flyteidl2.cacheservice.PutCacheResponse + */ +export type PutCacheResponse = Message<"flyteidl2.cacheservice.PutCacheResponse"> & { +}; + +/** + * Describes the message flyteidl2.cacheservice.PutCacheResponse. + * Use `create(PutCacheResponseSchema)` to create a new message. + */ +export const PutCacheResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_cacheservice, 7); + +/** + * + * Request to delete cached data by key. + * + * @generated from message flyteidl2.cacheservice.DeleteCacheRequest + */ +export type DeleteCacheRequest = Message<"flyteidl2.cacheservice.DeleteCacheRequest"> & { + /** + * Cache key + * + * @generated from field: string key = 1; + */ + key: string; +}; + +/** + * Describes the message flyteidl2.cacheservice.DeleteCacheRequest. + * Use `create(DeleteCacheRequestSchema)` to create a new message. + */ +export const DeleteCacheRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_cacheservice, 8); + +/** + * + * Response message of cache deletion operation. + * + * Empty, success indicated by no errors + * + * @generated from message flyteidl2.cacheservice.DeleteCacheResponse + */ +export type DeleteCacheResponse = Message<"flyteidl2.cacheservice.DeleteCacheResponse"> & { +}; + +/** + * Describes the message flyteidl2.cacheservice.DeleteCacheResponse. + * Use `create(DeleteCacheResponseSchema)` to create a new message. + */ +export const DeleteCacheResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_cacheservice, 9); + +/** + * A reservation including owner, heartbeat interval, expiration timestamp, and various metadata. + * + * @generated from message flyteidl2.cacheservice.Reservation + */ +export type Reservation = Message<"flyteidl2.cacheservice.Reservation"> & { + /** + * The unique ID for the reservation - same as the cache key + * + * @generated from field: string key = 1; + */ + key: string; + + /** + * The unique ID of the owner for the reservation + * + * @generated from field: string owner_id = 2; + */ + ownerId: string; + + /** + * Requested reservation extension heartbeat interval + * + * @generated from field: google.protobuf.Duration heartbeat_interval = 3; + */ + heartbeatInterval?: Duration; + + /** + * Expiration timestamp of this reservation + * + * @generated from field: google.protobuf.Timestamp expires_at = 4; + */ + expiresAt?: Timestamp; +}; + +/** + * Describes the message flyteidl2.cacheservice.Reservation. + * Use `create(ReservationSchema)` to create a new message. + */ +export const ReservationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_cacheservice, 10); + +/** + * + * Request to get or extend a reservation for a cache key + * + * @generated from message flyteidl2.cacheservice.GetOrExtendReservationRequest + */ +export type GetOrExtendReservationRequest = Message<"flyteidl2.cacheservice.GetOrExtendReservationRequest"> & { + /** + * The unique ID for the reservation - same as the cache key + * + * @generated from field: string key = 1; + */ + key: string; + + /** + * The unique ID of the owner for the reservation + * + * @generated from field: string owner_id = 2; + */ + ownerId: string; + + /** + * Requested reservation extension heartbeat interval + * + * @generated from field: google.protobuf.Duration heartbeat_interval = 3; + */ + heartbeatInterval?: Duration; +}; + +/** + * Describes the message flyteidl2.cacheservice.GetOrExtendReservationRequest. + * Use `create(GetOrExtendReservationRequestSchema)` to create a new message. + */ +export const GetOrExtendReservationRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_cacheservice, 11); + +/** + * + * Request to get or extend a reservation for a cache key + * + * @generated from message flyteidl2.cacheservice.GetOrExtendReservationResponse + */ +export type GetOrExtendReservationResponse = Message<"flyteidl2.cacheservice.GetOrExtendReservationResponse"> & { + /** + * The reservation that was created or extended + * + * @generated from field: flyteidl2.cacheservice.Reservation reservation = 1; + */ + reservation?: Reservation; +}; + +/** + * Describes the message flyteidl2.cacheservice.GetOrExtendReservationResponse. + * Use `create(GetOrExtendReservationResponseSchema)` to create a new message. + */ +export const GetOrExtendReservationResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_cacheservice, 12); + +/** + * + * Request to release the reservation for a cache key + * + * @generated from message flyteidl2.cacheservice.ReleaseReservationRequest + */ +export type ReleaseReservationRequest = Message<"flyteidl2.cacheservice.ReleaseReservationRequest"> & { + /** + * The unique ID for the reservation - same as the cache key + * + * @generated from field: string key = 1; + */ + key: string; + + /** + * The unique ID of the owner for the reservation + * + * @generated from field: string owner_id = 2; + */ + ownerId: string; +}; + +/** + * Describes the message flyteidl2.cacheservice.ReleaseReservationRequest. + * Use `create(ReleaseReservationRequestSchema)` to create a new message. + */ +export const ReleaseReservationRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_cacheservice, 13); + +/** + * + * Response message of release reservation operation. + * + * Empty, success indicated by no errors + * + * @generated from message flyteidl2.cacheservice.ReleaseReservationResponse + */ +export type ReleaseReservationResponse = Message<"flyteidl2.cacheservice.ReleaseReservationResponse"> & { +}; + +/** + * Describes the message flyteidl2.cacheservice.ReleaseReservationResponse. + * Use `create(ReleaseReservationResponseSchema)` to create a new message. + */ +export const ReleaseReservationResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_cacheservice, 14); + +/** + * + * CacheService defines operations for cache management including retrieval, storage, and deletion of cached task/workflow outputs. + * + * @generated from service flyteidl2.cacheservice.CacheService + */ +export const CacheService: GenService<{ + /** + * Retrieves cached data by key. + * + * @generated from rpc flyteidl2.cacheservice.CacheService.Get + */ + get: { + methodKind: "unary"; + input: typeof GetCacheRequestSchema; + output: typeof GetCacheResponseSchema; + }, + /** + * Stores or updates cached data by key. + * + * @generated from rpc flyteidl2.cacheservice.CacheService.Put + */ + put: { + methodKind: "unary"; + input: typeof PutCacheRequestSchema; + output: typeof PutCacheResponseSchema; + }, + /** + * Deletes cached data by key. + * + * @generated from rpc flyteidl2.cacheservice.CacheService.Delete + */ + delete: { + methodKind: "unary"; + input: typeof DeleteCacheRequestSchema; + output: typeof DeleteCacheResponseSchema; + }, + /** + * Get or extend a reservation for a cache key + * + * @generated from rpc flyteidl2.cacheservice.CacheService.GetOrExtendReservation + */ + getOrExtendReservation: { + methodKind: "unary"; + input: typeof GetOrExtendReservationRequestSchema; + output: typeof GetOrExtendReservationResponseSchema; + }, + /** + * Release the reservation for a cache key + * + * @generated from rpc flyteidl2.cacheservice.CacheService.ReleaseReservation + */ + releaseReservation: { + methodKind: "unary"; + input: typeof ReleaseReservationRequestSchema; + output: typeof ReleaseReservationResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_cacheservice_cacheservice, 0); + diff --git a/gen/ts/flyteidl2/cacheservice/v2/cacheservice_pb.ts b/gen/ts/flyteidl2/cacheservice/v2/cacheservice_pb.ts new file mode 100644 index 0000000000..82b274e027 --- /dev/null +++ b/gen/ts/flyteidl2/cacheservice/v2/cacheservice_pb.ts @@ -0,0 +1,249 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/cacheservice/v2/cacheservice.proto (package flyteidl2.cacheservice.v2, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../../buf/validate/validate_pb.ts"; +import type { DeleteCacheRequest as DeleteCacheRequest$1, DeleteCacheResponseSchema, GetCacheRequest as GetCacheRequest$1, GetCacheResponseSchema, GetOrExtendReservationRequest as GetOrExtendReservationRequest$1, GetOrExtendReservationResponseSchema, PutCacheRequest as PutCacheRequest$1, PutCacheResponseSchema, ReleaseReservationRequest as ReleaseReservationRequest$1, ReleaseReservationResponseSchema } from "../cacheservice_pb.ts"; +import { file_flyteidl2_cacheservice_cacheservice } from "../cacheservice_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/cacheservice/v2/cacheservice.proto. + */ +export const file_flyteidl2_cacheservice_v2_cacheservice: GenFile = /*@__PURE__*/ + fileDesc("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", [file_buf_validate_validate, file_flyteidl2_cacheservice_cacheservice]); + +/** + * + * Identifier for cache operations, including org, project, and domain. + * This is used to scope cache operations to specific organizational contexts. + * + * @generated from message flyteidl2.cacheservice.v2.Identifier + */ +export type Identifier = Message<"flyteidl2.cacheservice.v2.Identifier"> & { + /** + * Organization identifier + * + * @generated from field: string org = 1; + */ + org: string; + + /** + * Project identifier + * + * @generated from field: string project = 2; + */ + project: string; + + /** + * Domain identifier + * + * @generated from field: string domain = 3; + */ + domain: string; +}; + +/** + * Describes the message flyteidl2.cacheservice.v2.Identifier. + * Use `create(IdentifierSchema)` to create a new message. + */ +export const IdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_v2_cacheservice, 0); + +/** + * + * Request to retrieve cached data by key. + * + * @generated from message flyteidl2.cacheservice.v2.GetCacheRequest + */ +export type GetCacheRequest = Message<"flyteidl2.cacheservice.v2.GetCacheRequest"> & { + /** + * @generated from field: flyteidl2.cacheservice.GetCacheRequest base_request = 1; + */ + baseRequest?: GetCacheRequest$1; + + /** + * Identifier for the cache operation + * + * @generated from field: flyteidl2.cacheservice.v2.Identifier identifier = 2; + */ + identifier?: Identifier; +}; + +/** + * Describes the message flyteidl2.cacheservice.v2.GetCacheRequest. + * Use `create(GetCacheRequestSchema)` to create a new message. + */ +export const GetCacheRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_v2_cacheservice, 1); + +/** + * + * Request to store/update cached data by key. + * + * @generated from message flyteidl2.cacheservice.v2.PutCacheRequest + */ +export type PutCacheRequest = Message<"flyteidl2.cacheservice.v2.PutCacheRequest"> & { + /** + * @generated from field: flyteidl2.cacheservice.PutCacheRequest base_request = 1; + */ + baseRequest?: PutCacheRequest$1; + + /** + * Identifier for the cache operation + * + * @generated from field: flyteidl2.cacheservice.v2.Identifier identifier = 2; + */ + identifier?: Identifier; +}; + +/** + * Describes the message flyteidl2.cacheservice.v2.PutCacheRequest. + * Use `create(PutCacheRequestSchema)` to create a new message. + */ +export const PutCacheRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_v2_cacheservice, 2); + +/** + * + * Request to delete cached data by key. + * + * @generated from message flyteidl2.cacheservice.v2.DeleteCacheRequest + */ +export type DeleteCacheRequest = Message<"flyteidl2.cacheservice.v2.DeleteCacheRequest"> & { + /** + * @generated from field: flyteidl2.cacheservice.DeleteCacheRequest base_request = 1; + */ + baseRequest?: DeleteCacheRequest$1; + + /** + * Identifier for the cache operation + * + * @generated from field: flyteidl2.cacheservice.v2.Identifier identifier = 2; + */ + identifier?: Identifier; +}; + +/** + * Describes the message flyteidl2.cacheservice.v2.DeleteCacheRequest. + * Use `create(DeleteCacheRequestSchema)` to create a new message. + */ +export const DeleteCacheRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_v2_cacheservice, 3); + +/** + * + * Request to get or extend a reservation for a cache key + * + * @generated from message flyteidl2.cacheservice.v2.GetOrExtendReservationRequest + */ +export type GetOrExtendReservationRequest = Message<"flyteidl2.cacheservice.v2.GetOrExtendReservationRequest"> & { + /** + * @generated from field: flyteidl2.cacheservice.GetOrExtendReservationRequest base_request = 1; + */ + baseRequest?: GetOrExtendReservationRequest$1; + + /** + * Identifier for the cache operation + * + * @generated from field: flyteidl2.cacheservice.v2.Identifier identifier = 2; + */ + identifier?: Identifier; +}; + +/** + * Describes the message flyteidl2.cacheservice.v2.GetOrExtendReservationRequest. + * Use `create(GetOrExtendReservationRequestSchema)` to create a new message. + */ +export const GetOrExtendReservationRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_v2_cacheservice, 4); + +/** + * + * Request to release the reservation for a cache key + * + * @generated from message flyteidl2.cacheservice.v2.ReleaseReservationRequest + */ +export type ReleaseReservationRequest = Message<"flyteidl2.cacheservice.v2.ReleaseReservationRequest"> & { + /** + * @generated from field: flyteidl2.cacheservice.ReleaseReservationRequest base_request = 1; + */ + baseRequest?: ReleaseReservationRequest$1; + + /** + * Identifier for the cache operation + * + * @generated from field: flyteidl2.cacheservice.v2.Identifier identifier = 2; + */ + identifier?: Identifier; +}; + +/** + * Describes the message flyteidl2.cacheservice.v2.ReleaseReservationRequest. + * Use `create(ReleaseReservationRequestSchema)` to create a new message. + */ +export const ReleaseReservationRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_cacheservice_v2_cacheservice, 5); + +/** + * + * CacheService defines operations for cache management including retrieval, storage, and deletion of cached task/workflow outputs. + * + * @generated from service flyteidl2.cacheservice.v2.CacheService + */ +export const CacheService: GenService<{ + /** + * Retrieves cached data by key. + * + * @generated from rpc flyteidl2.cacheservice.v2.CacheService.Get + */ + get: { + methodKind: "unary"; + input: typeof GetCacheRequestSchema; + output: typeof GetCacheResponseSchema; + }, + /** + * Stores or updates cached data by key. + * + * @generated from rpc flyteidl2.cacheservice.v2.CacheService.Put + */ + put: { + methodKind: "unary"; + input: typeof PutCacheRequestSchema; + output: typeof PutCacheResponseSchema; + }, + /** + * Deletes cached data by key. + * + * @generated from rpc flyteidl2.cacheservice.v2.CacheService.Delete + */ + delete: { + methodKind: "unary"; + input: typeof DeleteCacheRequestSchema; + output: typeof DeleteCacheResponseSchema; + }, + /** + * Get or extend a reservation for a cache key + * + * @generated from rpc flyteidl2.cacheservice.v2.CacheService.GetOrExtendReservation + */ + getOrExtendReservation: { + methodKind: "unary"; + input: typeof GetOrExtendReservationRequestSchema; + output: typeof GetOrExtendReservationResponseSchema; + }, + /** + * Release the reservation for a cache key + * + * @generated from rpc flyteidl2.cacheservice.v2.CacheService.ReleaseReservation + */ + releaseReservation: { + methodKind: "unary"; + input: typeof ReleaseReservationRequestSchema; + output: typeof ReleaseReservationResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_cacheservice_v2_cacheservice, 0); + diff --git a/gen/ts/flyteidl2/common/authorization_pb.ts b/gen/ts/flyteidl2/common/authorization_pb.ts new file mode 100644 index 0000000000..ea3b495178 --- /dev/null +++ b/gen/ts/flyteidl2/common/authorization_pb.ts @@ -0,0 +1,323 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/common/authorization.proto (package flyteidl2.common, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { ClusterIdentifier } from "./identifier_pb.ts"; +import { file_flyteidl2_common_identifier } from "./identifier_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/common/authorization.proto. + */ +export const file_flyteidl2_common_authorization: GenFile = /*@__PURE__*/ + fileDesc("CiRmbHl0ZWlkbDIvY29tbW9uL2F1dGhvcml6YXRpb24ucHJvdG8SEGZseXRlaWRsMi5jb21tb24iJQoMT3JnYW5pemF0aW9uEhUKBG5hbWUYASABKAlCB7pIBHICEAEiVAoGRG9tYWluEgwKBG5hbWUYASABKAkSPAoMb3JnYW5pemF0aW9uGAIgASgLMh4uZmx5dGVpZGwyLmNvbW1vbi5Pcmdhbml6YXRpb25CBrpIA8gBASJSCgdQcm9qZWN0EhUKBG5hbWUYASABKAlCB7pIBHICEAESMAoGZG9tYWluGAIgASgLMhguZmx5dGVpZGwyLmNvbW1vbi5Eb21haW5CBrpIA8gBASJVCghXb3JrZmxvdxIVCgRuYW1lGAEgASgJQge6SARyAhABEjIKB3Byb2plY3QYAiABKAsyGS5mbHl0ZWlkbDIuY29tbW9uLlByb2plY3RCBrpIA8gBASJXCgpMYXVuY2hQbGFuEhUKBG5hbWUYASABKAlCB7pIBHICEAESMgoHcHJvamVjdBgCIAEoCzIZLmZseXRlaWRsMi5jb21tb24uUHJvamVjdEIGukgDyAEBIsUCCghSZXNvdXJjZRI2Cgxvcmdhbml6YXRpb24YASABKAsyHi5mbHl0ZWlkbDIuY29tbW9uLk9yZ2FuaXphdGlvbkgAEioKBmRvbWFpbhgCIAEoCzIYLmZseXRlaWRsMi5jb21tb24uRG9tYWluSAASLAoHcHJvamVjdBgDIAEoCzIZLmZseXRlaWRsMi5jb21tb24uUHJvamVjdEgAEi4KCHdvcmtmbG93GAQgASgLMhouZmx5dGVpZGwyLmNvbW1vbi5Xb3JrZmxvd0gAEjMKC2xhdW5jaF9wbGFuGAUgASgLMhwuZmx5dGVpZGwyLmNvbW1vbi5MYXVuY2hQbGFuSAASNgoHY2x1c3RlchgGIAEoCzIjLmZseXRlaWRsMi5jb21tb24uQ2x1c3RlcklkZW50aWZpZXJIAEIKCghyZXNvdXJjZSJlCgpQZXJtaXNzaW9uEiwKCHJlc291cmNlGAEgASgLMhouZmx5dGVpZGwyLmNvbW1vbi5SZXNvdXJjZRIpCgdhY3Rpb25zGAIgAygOMhguZmx5dGVpZGwyLmNvbW1vbi5BY3Rpb24qlAQKBkFjdGlvbhIPCgtBQ1RJT05fTk9ORRAAEhUKDUFDVElPTl9DUkVBVEUQARoCCAESEwoLQUNUSU9OX1JFQUQQAhoCCAESFQoNQUNUSU9OX1VQREFURRADGgIIARIVCg1BQ1RJT05fREVMRVRFEAQaAggBEh8KG0FDVElPTl9WSUVXX0ZMWVRFX0lOVkVOVE9SWRAFEiAKHEFDVElPTl9WSUVXX0ZMWVRFX0VYRUNVVElPTlMQBhIjCh9BQ1RJT05fUkVHSVNURVJfRkxZVEVfSU5WRU5UT1JZEAcSIgoeQUNUSU9OX0NSRUFURV9GTFlURV9FWEVDVVRJT05TEAgSHQoZQUNUSU9OX0FETUlOSVNURVJfUFJPSkVDVBAJEh0KGUFDVElPTl9NQU5BR0VfUEVSTUlTU0lPTlMQChIdChlBQ1RJT05fQURNSU5JU1RFUl9BQ0NPVU5UEAsSGQoVQUNUSU9OX01BTkFHRV9DTFVTVEVSEAwSLAooQUNUSU9OX0VESVRfRVhFQ1VUSU9OX1JFTEFURURfQVRUUklCVVRFUxANEioKJkFDVElPTl9FRElUX0NMVVNURVJfUkVMQVRFRF9BVFRSSUJVVEVTEA4SIQodQUNUSU9OX0VESVRfVU5VU0VEX0FUVFJJQlVURVMQDxIeChpBQ1RJT05fU1VQUE9SVF9TWVNURU1fTE9HUxAQQsMBChRjb20uZmx5dGVpZGwyLmNvbW1vbkISQXV0aG9yaXphdGlvblByb3RvSAJQAVo0Z2l0aHViLmNvbS9mbHl0ZW9yZy9mbHl0ZS92Mi9nZW4vZ28vZmx5dGVpZGwyL2NvbW1vbqICA0ZDWKoCEEZseXRlaWRsMi5Db21tb27KAhBGbHl0ZWlkbDJcQ29tbW9u4gIcRmx5dGVpZGwyXENvbW1vblxHUEJNZXRhZGF0YeoCEUZseXRlaWRsMjo6Q29tbW9uYgZwcm90bzM", [file_buf_validate_validate, file_flyteidl2_common_identifier]); + +/** + * @generated from message flyteidl2.common.Organization + */ +export type Organization = Message<"flyteidl2.common.Organization"> & { + /** + * @generated from field: string name = 1; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.common.Organization. + * Use `create(OrganizationSchema)` to create a new message. + */ +export const OrganizationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_authorization, 0); + +/** + * @generated from message flyteidl2.common.Domain + */ +export type Domain = Message<"flyteidl2.common.Domain"> & { + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * @generated from field: flyteidl2.common.Organization organization = 2; + */ + organization?: Organization; +}; + +/** + * Describes the message flyteidl2.common.Domain. + * Use `create(DomainSchema)` to create a new message. + */ +export const DomainSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_authorization, 1); + +/** + * @generated from message flyteidl2.common.Project + */ +export type Project = Message<"flyteidl2.common.Project"> & { + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * @generated from field: flyteidl2.common.Domain domain = 2; + */ + domain?: Domain; +}; + +/** + * Describes the message flyteidl2.common.Project. + * Use `create(ProjectSchema)` to create a new message. + */ +export const ProjectSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_authorization, 2); + +/** + * @generated from message flyteidl2.common.Workflow + */ +export type Workflow = Message<"flyteidl2.common.Workflow"> & { + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * @generated from field: flyteidl2.common.Project project = 2; + */ + project?: Project; +}; + +/** + * Describes the message flyteidl2.common.Workflow. + * Use `create(WorkflowSchema)` to create a new message. + */ +export const WorkflowSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_authorization, 3); + +/** + * @generated from message flyteidl2.common.LaunchPlan + */ +export type LaunchPlan = Message<"flyteidl2.common.LaunchPlan"> & { + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * @generated from field: flyteidl2.common.Project project = 2; + */ + project?: Project; +}; + +/** + * Describes the message flyteidl2.common.LaunchPlan. + * Use `create(LaunchPlanSchema)` to create a new message. + */ +export const LaunchPlanSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_authorization, 4); + +/** + * @generated from message flyteidl2.common.Resource + */ +export type Resource = Message<"flyteidl2.common.Resource"> & { + /** + * @generated from oneof flyteidl2.common.Resource.resource + */ + resource: { + /** + * @generated from field: flyteidl2.common.Organization organization = 1; + */ + value: Organization; + case: "organization"; + } | { + /** + * @generated from field: flyteidl2.common.Domain domain = 2; + */ + value: Domain; + case: "domain"; + } | { + /** + * @generated from field: flyteidl2.common.Project project = 3; + */ + value: Project; + case: "project"; + } | { + /** + * @generated from field: flyteidl2.common.Workflow workflow = 4; + */ + value: Workflow; + case: "workflow"; + } | { + /** + * @generated from field: flyteidl2.common.LaunchPlan launch_plan = 5; + */ + value: LaunchPlan; + case: "launchPlan"; + } | { + /** + * @generated from field: flyteidl2.common.ClusterIdentifier cluster = 6; + */ + value: ClusterIdentifier; + case: "cluster"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.common.Resource. + * Use `create(ResourceSchema)` to create a new message. + */ +export const ResourceSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_authorization, 5); + +/** + * Defines a set of allowed actions on a specific authorization resource. + * + * @generated from message flyteidl2.common.Permission + */ +export type Permission = Message<"flyteidl2.common.Permission"> & { + /** + * @generated from field: flyteidl2.common.Resource resource = 1; + */ + resource?: Resource; + + /** + * @generated from field: repeated flyteidl2.common.Action actions = 2; + */ + actions: Action[]; +}; + +/** + * Describes the message flyteidl2.common.Permission. + * Use `create(PermissionSchema)` to create a new message. + */ +export const PermissionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_authorization, 6); + +/** + * @generated from enum flyteidl2.common.Action + */ +export enum Action { + /** + * @generated from enum value: ACTION_NONE = 0; + */ + NONE = 0, + + /** + * @generated from enum value: ACTION_CREATE = 1 [deprecated = true]; + * @deprecated + */ + CREATE = 1, + + /** + * @generated from enum value: ACTION_READ = 2 [deprecated = true]; + * @deprecated + */ + READ = 2, + + /** + * @generated from enum value: ACTION_UPDATE = 3 [deprecated = true]; + * @deprecated + */ + UPDATE = 3, + + /** + * @generated from enum value: ACTION_DELETE = 4 [deprecated = true]; + * @deprecated + */ + DELETE = 4, + + /** + * Read Flyte workflows, tasks and launch plans + * + * @generated from enum value: ACTION_VIEW_FLYTE_INVENTORY = 5; + */ + VIEW_FLYTE_INVENTORY = 5, + + /** + * View Flyte executions + * + * @generated from enum value: ACTION_VIEW_FLYTE_EXECUTIONS = 6; + */ + VIEW_FLYTE_EXECUTIONS = 6, + + /** + * Register new versions of Flyte workflows, tasks and launch plans + * + * @generated from enum value: ACTION_REGISTER_FLYTE_INVENTORY = 7; + */ + REGISTER_FLYTE_INVENTORY = 7, + + /** + * Create new Flyte workflow and task executions + * + * @generated from enum value: ACTION_CREATE_FLYTE_EXECUTIONS = 8; + */ + CREATE_FLYTE_EXECUTIONS = 8, + + /** + * Create new projects and update project descriptions + * + * @generated from enum value: ACTION_ADMINISTER_PROJECT = 9; + */ + ADMINISTER_PROJECT = 9, + + /** + * Add users, roles and update role assignments. + * + * @generated from enum value: ACTION_MANAGE_PERMISSIONS = 10; + */ + MANAGE_PERMISSIONS = 10, + + /** + * Manage billing, account-wide settings + * + * @generated from enum value: ACTION_ADMINISTER_ACCOUNT = 11; + */ + ADMINISTER_ACCOUNT = 11, + + /** + * Operations for clusters + * + * @generated from enum value: ACTION_MANAGE_CLUSTER = 12; + */ + MANAGE_CLUSTER = 12, + + /** + * Edit execution related attributes, including TASK_RESOURCE, WORKFLOW_EXECUTION_CONFIG, and EXTERNAL_RESOURCE + * + * @generated from enum value: ACTION_EDIT_EXECUTION_RELATED_ATTRIBUTES = 13; + */ + EDIT_EXECUTION_RELATED_ATTRIBUTES = 13, + + /** + * Edit cluster related attributes, including CLUSTER_RESOURCE and CLUSTER_ASSIGNMENT + * + * @generated from enum value: ACTION_EDIT_CLUSTER_RELATED_ATTRIBUTES = 14; + */ + EDIT_CLUSTER_RELATED_ATTRIBUTES = 14, + + /** + * Edit unused attributes, including EXECUTION_QUEUE, EXECUTION_CLUSTER_LABEL, QUALITY_OF_SERVICE_SPECIFICATION, and PLUGIN_OVERRIDE + * + * @generated from enum value: ACTION_EDIT_UNUSED_ATTRIBUTES = 15; + */ + EDIT_UNUSED_ATTRIBUTES = 15, + + /** + * View system logs + * + * @generated from enum value: ACTION_SUPPORT_SYSTEM_LOGS = 16; + */ + SUPPORT_SYSTEM_LOGS = 16, +} + +/** + * Describes the enum flyteidl2.common.Action. + */ +export const ActionSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_common_authorization, 0); + diff --git a/gen/ts/flyteidl2/common/configuration_pb.ts b/gen/ts/flyteidl2/common/configuration_pb.ts new file mode 100644 index 0000000000..a8b5c1f8bb --- /dev/null +++ b/gen/ts/flyteidl2/common/configuration_pb.ts @@ -0,0 +1,68 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/common/configuration.proto (package flyteidl2.common, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc } from "@bufbuild/protobuf/codegenv1"; + +/** + * Describes the file flyteidl2/common/configuration.proto. + */ +export const file_flyteidl2_common_configuration: GenFile = /*@__PURE__*/ + fileDesc("CiRmbHl0ZWlkbDIvY29tbW9uL2NvbmZpZ3VyYXRpb24ucHJvdG8SEGZseXRlaWRsMi5jb21tb24qbAoQQXR0cmlidXRlc1NvdXJjZRIWChJTT1VSQ0VfVU5TUEVDSUZJRUQQABIKCgZHTE9CQUwQARIKCgZET01BSU4QAhILCgdQUk9KRUNUEAMSEgoOUFJPSkVDVF9ET01BSU4QBBIHCgNPUkcQBULDAQoUY29tLmZseXRlaWRsMi5jb21tb25CEkNvbmZpZ3VyYXRpb25Qcm90b0gCUAFaNGdpdGh1Yi5jb20vZmx5dGVvcmcvZmx5dGUvdjIvZ2VuL2dvL2ZseXRlaWRsMi9jb21tb26iAgNGQ1iqAhBGbHl0ZWlkbDIuQ29tbW9uygIQRmx5dGVpZGwyXENvbW1vbuICHEZseXRlaWRsMlxDb21tb25cR1BCTWV0YWRhdGHqAhFGbHl0ZWlkbDI6OkNvbW1vbmIGcHJvdG8z"); + +/** + * The source of an attribute. We may have other sources in the future. + * + * @generated from enum flyteidl2.common.AttributesSource + */ +export enum AttributesSource { + /** + * The source is unspecified. + * + * @generated from enum value: SOURCE_UNSPECIFIED = 0; + */ + SOURCE_UNSPECIFIED = 0, + + /** + * The configuration is a global configuration. + * + * @generated from enum value: GLOBAL = 1; + */ + GLOBAL = 1, + + /** + * The configuration is a domain configuration. + * + * @generated from enum value: DOMAIN = 2; + */ + DOMAIN = 2, + + /** + * The configuration is a project configuration. + * + * @generated from enum value: PROJECT = 3; + */ + PROJECT = 3, + + /** + * The configuration is a project-domain configuration. + * + * @generated from enum value: PROJECT_DOMAIN = 4; + */ + PROJECT_DOMAIN = 4, + + /** + * The configuration is a org configuration. + * + * @generated from enum value: ORG = 5; + */ + ORG = 5, +} + +/** + * Describes the enum flyteidl2.common.AttributesSource. + */ +export const AttributesSourceSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_common_configuration, 0); + diff --git a/gen/ts/flyteidl2/common/identifier_pb.ts b/gen/ts/flyteidl2/common/identifier_pb.ts new file mode 100644 index 0000000000..75c1c4defb --- /dev/null +++ b/gen/ts/flyteidl2/common/identifier_pb.ts @@ -0,0 +1,423 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/common/identifier.proto (package flyteidl2.common, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/common/identifier.proto. + */ +export const file_flyteidl2_common_identifier: GenFile = /*@__PURE__*/ + fileDesc("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", [file_buf_validate_validate]); + +/** + * @generated from message flyteidl2.common.ProjectIdentifier + */ +export type ProjectIdentifier = Message<"flyteidl2.common.ProjectIdentifier"> & { + /** + * @generated from field: string organization = 1; + */ + organization: string; + + /** + * @generated from field: string domain = 2; + */ + domain: string; + + /** + * @generated from field: string name = 3; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.common.ProjectIdentifier. + * Use `create(ProjectIdentifierSchema)` to create a new message. + */ +export const ProjectIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identifier, 0); + +/** + * @generated from message flyteidl2.common.ClusterIdentifier + */ +export type ClusterIdentifier = Message<"flyteidl2.common.ClusterIdentifier"> & { + /** + * @generated from field: string organization = 1; + */ + organization: string; + + /** + * @generated from field: string name = 2; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.common.ClusterIdentifier. + * Use `create(ClusterIdentifierSchema)` to create a new message. + */ +export const ClusterIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identifier, 1); + +/** + * @generated from message flyteidl2.common.ClusterPoolIdentifier + */ +export type ClusterPoolIdentifier = Message<"flyteidl2.common.ClusterPoolIdentifier"> & { + /** + * @generated from field: string organization = 1; + */ + organization: string; + + /** + * @generated from field: string name = 2; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.common.ClusterPoolIdentifier. + * Use `create(ClusterPoolIdentifierSchema)` to create a new message. + */ +export const ClusterPoolIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identifier, 2); + +/** + * @generated from message flyteidl2.common.ClusterConfigIdentifier + */ +export type ClusterConfigIdentifier = Message<"flyteidl2.common.ClusterConfigIdentifier"> & { + /** + * @generated from field: string organization = 1; + */ + organization: string; + + /** + * @generated from field: string id = 2; + */ + id: string; +}; + +/** + * Describes the message flyteidl2.common.ClusterConfigIdentifier. + * Use `create(ClusterConfigIdentifierSchema)` to create a new message. + */ +export const ClusterConfigIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identifier, 3); + +/** + * @generated from message flyteidl2.common.ClusterNodepoolIdentifier + */ +export type ClusterNodepoolIdentifier = Message<"flyteidl2.common.ClusterNodepoolIdentifier"> & { + /** + * @generated from field: string organization = 1; + */ + organization: string; + + /** + * @generated from field: string cluster_name = 2; + */ + clusterName: string; + + /** + * @generated from field: string name = 3; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.common.ClusterNodepoolIdentifier. + * Use `create(ClusterNodepoolIdentifierSchema)` to create a new message. + */ +export const ClusterNodepoolIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identifier, 4); + +/** + * @generated from message flyteidl2.common.UserIdentifier + */ +export type UserIdentifier = Message<"flyteidl2.common.UserIdentifier"> & { + /** + * @generated from field: string subject = 1; + */ + subject: string; +}; + +/** + * Describes the message flyteidl2.common.UserIdentifier. + * Use `create(UserIdentifierSchema)` to create a new message. + */ +export const UserIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identifier, 5); + +/** + * @generated from message flyteidl2.common.ApplicationIdentifier + */ +export type ApplicationIdentifier = Message<"flyteidl2.common.ApplicationIdentifier"> & { + /** + * @generated from field: string subject = 1; + */ + subject: string; +}; + +/** + * Describes the message flyteidl2.common.ApplicationIdentifier. + * Use `create(ApplicationIdentifierSchema)` to create a new message. + */ +export const ApplicationIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identifier, 6); + +/** + * @generated from message flyteidl2.common.RoleIdentifier + */ +export type RoleIdentifier = Message<"flyteidl2.common.RoleIdentifier"> & { + /** + * @generated from field: string organization = 1; + */ + organization: string; + + /** + * Unique name for this role within the organization + * + * @generated from field: string name = 2; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.common.RoleIdentifier. + * Use `create(RoleIdentifierSchema)` to create a new message. + */ +export const RoleIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identifier, 7); + +/** + * @generated from message flyteidl2.common.OrgIdentifier + */ +export type OrgIdentifier = Message<"flyteidl2.common.OrgIdentifier"> & { + /** + * @generated from field: string name = 1; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.common.OrgIdentifier. + * Use `create(OrgIdentifierSchema)` to create a new message. + */ +export const OrgIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identifier, 8); + +/** + * @generated from message flyteidl2.common.ManagedClusterIdentifier + */ +export type ManagedClusterIdentifier = Message<"flyteidl2.common.ManagedClusterIdentifier"> & { + /** + * @generated from field: string name = 2; + */ + name: string; + + /** + * @generated from field: flyteidl2.common.OrgIdentifier org = 3; + */ + org?: OrgIdentifier; +}; + +/** + * Describes the message flyteidl2.common.ManagedClusterIdentifier. + * Use `create(ManagedClusterIdentifierSchema)` to create a new message. + */ +export const ManagedClusterIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identifier, 9); + +/** + * @generated from message flyteidl2.common.PolicyIdentifier + */ +export type PolicyIdentifier = Message<"flyteidl2.common.PolicyIdentifier"> & { + /** + * @generated from field: string organization = 1; + */ + organization: string; + + /** + * Unique name for this policy within the organization + * + * @generated from field: string name = 2; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.common.PolicyIdentifier. + * Use `create(PolicyIdentifierSchema)` to create a new message. + */ +export const PolicyIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identifier, 10); + +/** + * Unique identifier of a run. + * + * @generated from message flyteidl2.common.RunIdentifier + */ +export type RunIdentifier = Message<"flyteidl2.common.RunIdentifier"> & { + /** + * Org this run belongs to. + * + * @generated from field: string org = 1; + */ + org: string; + + /** + * Project this run belongs to. + * + * @generated from field: string project = 2; + */ + project: string; + + /** + * Domain this run belongs to. + * + * @generated from field: string domain = 3; + */ + domain: string; + + /** + * Name of the run. Must be unique across all runs in this org, project, and domain pairing. + * + * @generated from field: string name = 4; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.common.RunIdentifier. + * Use `create(RunIdentifierSchema)` to create a new message. + */ +export const RunIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identifier, 11); + +/** + * Unique identifier of an action. + * + * @generated from message flyteidl2.common.ActionIdentifier + */ +export type ActionIdentifier = Message<"flyteidl2.common.ActionIdentifier"> & { + /** + * Identifier for the run. + * + * @generated from field: flyteidl2.common.RunIdentifier run = 1; + */ + run?: RunIdentifier; + + /** + * Name of the action. Must be unique within the run. + * + * @generated from field: string name = 2; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.common.ActionIdentifier. + * Use `create(ActionIdentifierSchema)` to create a new message. + */ +export const ActionIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identifier, 12); + +/** + * Unique identifier of a single action attempt + * + * @generated from message flyteidl2.common.ActionAttemptIdentifier + */ +export type ActionAttemptIdentifier = Message<"flyteidl2.common.ActionAttemptIdentifier"> & { + /** + * @generated from field: flyteidl2.common.ActionIdentifier action_id = 1; + */ + actionId?: ActionIdentifier; + + /** + * @generated from field: uint32 attempt = 2; + */ + attempt: number; +}; + +/** + * Describes the message flyteidl2.common.ActionAttemptIdentifier. + * Use `create(ActionAttemptIdentifierSchema)` to create a new message. + */ +export const ActionAttemptIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identifier, 13); + +/** + * Identifies trigger within an org, project and domain + * + * @generated from message flyteidl2.common.TriggerName + */ +export type TriggerName = Message<"flyteidl2.common.TriggerName"> & { + /** + * Org this trigger belongs to. + * + * @generated from field: string org = 1; + */ + org: string; + + /** + * Project this trigger belongs to. + * + * @generated from field: string project = 2; + */ + project: string; + + /** + * Domain this trigger belongs to. + * + * @generated from field: string domain = 3; + */ + domain: string; + + /** + * Unique name of the trigger. + * + * @generated from field: string name = 4; + */ + name: string; + + /** + * @generated from field: string task_name = 5; + */ + taskName: string; +}; + +/** + * Describes the message flyteidl2.common.TriggerName. + * Use `create(TriggerNameSchema)` to create a new message. + */ +export const TriggerNameSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identifier, 14); + +/** + * Identifies a trigger revision within an org, project and domain + * + * @generated from message flyteidl2.common.TriggerIdentifier + */ +export type TriggerIdentifier = Message<"flyteidl2.common.TriggerIdentifier"> & { + /** + * @generated from field: flyteidl2.common.TriggerName name = 1; + */ + name?: TriggerName; + + /** + * Revision of the trigger. + * + * @generated from field: uint64 revision = 2; + */ + revision: bigint; +}; + +/** + * Describes the message flyteidl2.common.TriggerIdentifier. + * Use `create(TriggerIdentifierSchema)` to create a new message. + */ +export const TriggerIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identifier, 15); + diff --git a/gen/ts/flyteidl2/common/identity_pb.ts b/gen/ts/flyteidl2/common/identity_pb.ts new file mode 100644 index 0000000000..e569ab45d9 --- /dev/null +++ b/gen/ts/flyteidl2/common/identity_pb.ts @@ -0,0 +1,205 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/common/identity.proto (package flyteidl2.common, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { ApplicationIdentifier, UserIdentifier } from "./identifier_pb.ts"; +import { file_flyteidl2_common_identifier } from "./identifier_pb.ts"; +import type { Policy } from "./policy_pb.ts"; +import { file_flyteidl2_common_policy } from "./policy_pb.ts"; +import type { Role } from "./role_pb.ts"; +import { file_flyteidl2_common_role } from "./role_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/common/identity.proto. + */ +export const file_flyteidl2_common_identity: GenFile = /*@__PURE__*/ + fileDesc("Ch9mbHl0ZWlkbDIvY29tbW9uL2lkZW50aXR5LnByb3RvEhBmbHl0ZWlkbDIuY29tbW9uIrUBCgRVc2VyEiwKAmlkGAEgASgLMiAuZmx5dGVpZGwyLmNvbW1vbi5Vc2VySWRlbnRpZmllchIoCgRzcGVjGAIgASgLMhouZmx5dGVpZGwyLmNvbW1vbi5Vc2VyU3BlYxIpCgVyb2xlcxgDIAMoCzIWLmZseXRlaWRsMi5jb21tb24uUm9sZUICGAESKgoIcG9saWNpZXMYBCADKAsyGC5mbHl0ZWlkbDIuY29tbW9uLlBvbGljeSKOAQoIVXNlclNwZWMSEgoKZmlyc3RfbmFtZRgBIAEoCRIRCglsYXN0X25hbWUYAiABKAkSDQoFZW1haWwYAyABKAkSFAoMb3JnYW5pemF0aW9uGAQgASgJEhMKC3VzZXJfaGFuZGxlGAUgASgJEg4KBmdyb3VwcxgGIAMoCRIRCglwaG90b191cmwYByABKAkiawoLQXBwbGljYXRpb24SMwoCaWQYASABKAsyJy5mbHl0ZWlkbDIuY29tbW9uLkFwcGxpY2F0aW9uSWRlbnRpZmllchInCgRzcGVjGAIgASgLMhkuZmx5dGVpZGwyLmNvbW1vbi5BcHBTcGVjIi0KB0FwcFNwZWMSDAoEbmFtZRgBIAEoCRIUCgxvcmdhbml6YXRpb24YAiABKAkihAEKEEVucmljaGVkSWRlbnRpdHkSJgoEdXNlchgBIAEoCzIWLmZseXRlaWRsMi5jb21tb24uVXNlckgAEjQKC2FwcGxpY2F0aW9uGAIgASgLMh0uZmx5dGVpZGwyLmNvbW1vbi5BcHBsaWNhdGlvbkgAQhIKCXByaW5jaXBhbBIFukgCCAEijwEKCElkZW50aXR5EjMKB3VzZXJfaWQYASABKAsyIC5mbHl0ZWlkbDIuY29tbW9uLlVzZXJJZGVudGlmaWVySAASQQoOYXBwbGljYXRpb25faWQYAiABKAsyJy5mbHl0ZWlkbDIuY29tbW9uLkFwcGxpY2F0aW9uSWRlbnRpZmllckgAQgsKCXByaW5jaXBhbEK+AQoUY29tLmZseXRlaWRsMi5jb21tb25CDUlkZW50aXR5UHJvdG9IAlABWjRnaXRodWIuY29tL2ZseXRlb3JnL2ZseXRlL3YyL2dlbi9nby9mbHl0ZWlkbDIvY29tbW9uogIDRkNYqgIQRmx5dGVpZGwyLkNvbW1vbsoCEEZseXRlaWRsMlxDb21tb27iAhxGbHl0ZWlkbDJcQ29tbW9uXEdQQk1ldGFkYXRh6gIRRmx5dGVpZGwyOjpDb21tb25iBnByb3RvMw", [file_buf_validate_validate, file_flyteidl2_common_identifier, file_flyteidl2_common_policy, file_flyteidl2_common_role]); + +/** + * Encapsulates user profile details for a member of an organization. + * + * @generated from message flyteidl2.common.User + */ +export type User = Message<"flyteidl2.common.User"> & { + /** + * @generated from field: flyteidl2.common.UserIdentifier id = 1; + */ + id?: UserIdentifier; + + /** + * @generated from field: flyteidl2.common.UserSpec spec = 2; + */ + spec?: UserSpec; + + /** + * @generated from field: repeated flyteidl2.common.Role roles = 3 [deprecated = true]; + * @deprecated + */ + roles: Role[]; + + /** + * @generated from field: repeated flyteidl2.common.Policy policies = 4; + */ + policies: Policy[]; +}; + +/** + * Describes the message flyteidl2.common.User. + * Use `create(UserSchema)` to create a new message. + */ +export const UserSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identity, 0); + +/** + * @generated from message flyteidl2.common.UserSpec + */ +export type UserSpec = Message<"flyteidl2.common.UserSpec"> & { + /** + * @generated from field: string first_name = 1; + */ + firstName: string; + + /** + * @generated from field: string last_name = 2; + */ + lastName: string; + + /** + * @generated from field: string email = 3; + */ + email: string; + + /** + * @generated from field: string organization = 4; + */ + organization: string; + + /** + * @generated from field: string user_handle = 5; + */ + userHandle: string; + + /** + * @generated from field: repeated string groups = 6; + */ + groups: string[]; + + /** + * @generated from field: string photo_url = 7; + */ + photoUrl: string; +}; + +/** + * Describes the message flyteidl2.common.UserSpec. + * Use `create(UserSpecSchema)` to create a new message. + */ +export const UserSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identity, 1); + +/** + * @generated from message flyteidl2.common.Application + */ +export type Application = Message<"flyteidl2.common.Application"> & { + /** + * @generated from field: flyteidl2.common.ApplicationIdentifier id = 1; + */ + id?: ApplicationIdentifier; + + /** + * @generated from field: flyteidl2.common.AppSpec spec = 2; + */ + spec?: AppSpec; +}; + +/** + * Describes the message flyteidl2.common.Application. + * Use `create(ApplicationSchema)` to create a new message. + */ +export const ApplicationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identity, 2); + +/** + * @generated from message flyteidl2.common.AppSpec + */ +export type AppSpec = Message<"flyteidl2.common.AppSpec"> & { + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * @generated from field: string organization = 2; + */ + organization: string; +}; + +/** + * Describes the message flyteidl2.common.AppSpec. + * Use `create(AppSpecSchema)` to create a new message. + */ +export const AppSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identity, 3); + +/** + * @generated from message flyteidl2.common.EnrichedIdentity + */ +export type EnrichedIdentity = Message<"flyteidl2.common.EnrichedIdentity"> & { + /** + * @generated from oneof flyteidl2.common.EnrichedIdentity.principal + */ + principal: { + /** + * @generated from field: flyteidl2.common.User user = 1; + */ + value: User; + case: "user"; + } | { + /** + * @generated from field: flyteidl2.common.Application application = 2; + */ + value: Application; + case: "application"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.common.EnrichedIdentity. + * Use `create(EnrichedIdentitySchema)` to create a new message. + */ +export const EnrichedIdentitySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identity, 4); + +/** + * @generated from message flyteidl2.common.Identity + */ +export type Identity = Message<"flyteidl2.common.Identity"> & { + /** + * @generated from oneof flyteidl2.common.Identity.principal + */ + principal: { + /** + * @generated from field: flyteidl2.common.UserIdentifier user_id = 1; + */ + value: UserIdentifier; + case: "userId"; + } | { + /** + * @generated from field: flyteidl2.common.ApplicationIdentifier application_id = 2; + */ + value: ApplicationIdentifier; + case: "applicationId"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.common.Identity. + * Use `create(IdentitySchema)` to create a new message. + */ +export const IdentitySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_identity, 5); + diff --git a/gen/ts/flyteidl2/common/list_pb.ts b/gen/ts/flyteidl2/common/list_pb.ts new file mode 100644 index 0000000000..a7d537f4c2 --- /dev/null +++ b/gen/ts/flyteidl2/common/list_pb.ts @@ -0,0 +1,232 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/common/list.proto (package flyteidl2.common, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/common/list.proto. + */ +export const file_flyteidl2_common_list: GenFile = /*@__PURE__*/ + fileDesc("ChtmbHl0ZWlkbDIvY29tbW9uL2xpc3QucHJvdG8SEGZseXRlaWRsMi5jb21tb24idAoEU29ydBILCgNrZXkYASABKAkSMwoJZGlyZWN0aW9uGAIgASgOMiAuZmx5dGVpZGwyLmNvbW1vbi5Tb3J0LkRpcmVjdGlvbiIqCglEaXJlY3Rpb24SDgoKREVTQ0VORElORxAAEg0KCUFTQ0VORElORxABIsgBCgtMaXN0UmVxdWVzdBINCgVsaW1pdBgBIAEoDRINCgV0b2tlbhgCIAEoCRIrCgdzb3J0X2J5GAMgASgLMhYuZmx5dGVpZGwyLmNvbW1vbi5Tb3J0QgIYARIpCgdmaWx0ZXJzGAQgAygLMhguZmx5dGVpZGwyLmNvbW1vbi5GaWx0ZXISEwoLcmF3X2ZpbHRlcnMYBSADKAkSLgoOc29ydF9ieV9maWVsZHMYBiADKAsyFi5mbHl0ZWlkbDIuY29tbW9uLlNvcnQitAIKBkZpbHRlchIzCghmdW5jdGlvbhgBIAEoDjIhLmZseXRlaWRsMi5jb21tb24uRmlsdGVyLkZ1bmN0aW9uEg0KBWZpZWxkGAIgASgJEg4KBnZhbHVlcxgDIAMoCSLVAQoIRnVuY3Rpb24SCQoFRVFVQUwQABINCglOT1RfRVFVQUwQARIQCgxHUkVBVEVSX1RIQU4QAhIZChVHUkVBVEVSX1RIQU5fT1JfRVFVQUwQAxINCglMRVNTX1RIQU4QBBIWChJMRVNTX1RIQU5fT1JfRVFVQUwQBRIMCghDT05UQUlOUxAGEgwKCFZBTFVFX0lOEAcSDQoJRU5EU19XSVRIEAwSEQoNTk9UX0VORFNfV0lUSBANEh0KGUNPTlRBSU5TX0NBU0VfSU5TRU5TSVRJVkUQDkK6AQoUY29tLmZseXRlaWRsMi5jb21tb25CCUxpc3RQcm90b0gCUAFaNGdpdGh1Yi5jb20vZmx5dGVvcmcvZmx5dGUvdjIvZ2VuL2dvL2ZseXRlaWRsMi9jb21tb26iAgNGQ1iqAhBGbHl0ZWlkbDIuQ29tbW9uygIQRmx5dGVpZGwyXENvbW1vbuICHEZseXRlaWRsMlxDb21tb25cR1BCTWV0YWRhdGHqAhFGbHl0ZWlkbDI6OkNvbW1vbmIGcHJvdG8z"); + +/** + * Specifies sort ordering in a list request. + * + * @generated from message flyteidl2.common.Sort + */ +export type Sort = Message<"flyteidl2.common.Sort"> & { + /** + * Indicates an attribute to sort the response values. + * +required + * + * @generated from field: string key = 1; + */ + key: string; + + /** + * Indicates the direction to apply sort key for response values. + * +optional + * + * @generated from field: flyteidl2.common.Sort.Direction direction = 2; + */ + direction: Sort_Direction; +}; + +/** + * Describes the message flyteidl2.common.Sort. + * Use `create(SortSchema)` to create a new message. + */ +export const SortSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_list, 0); + +/** + * @generated from enum flyteidl2.common.Sort.Direction + */ +export enum Sort_Direction { + /** + * By default, fields are sorted in descending order. + * + * @generated from enum value: DESCENDING = 0; + */ + DESCENDING = 0, + + /** + * @generated from enum value: ASCENDING = 1; + */ + ASCENDING = 1, +} + +/** + * Describes the enum flyteidl2.common.Sort.Direction. + */ +export const Sort_DirectionSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_common_list, 0, 0); + +/** + * @generated from message flyteidl2.common.ListRequest + */ +export type ListRequest = Message<"flyteidl2.common.ListRequest"> & { + /** + * Indicates the number of resources to be returned. + * +required + * + * @generated from field: uint32 limit = 1; + */ + limit: number; + + /** + * In the case of multiple pages of results, the server-provided token can be used to fetch the next page + * in a query. + * +optional + * + * @generated from field: string token = 2; + */ + token: string; + + /** + * Deprecated, use sort_by_fields instead. + * Specifies how listed entities should be sorted in the response. + * +optional + * + * @generated from field: flyteidl2.common.Sort sort_by = 3 [deprecated = true]; + * @deprecated + */ + sortBy?: Sort; + + /** + * Indicates a list of filters. This field is used for grpc get requests. + * +optional + * + * @generated from field: repeated flyteidl2.common.Filter filters = 4; + */ + filters: Filter[]; + + /** + * Indicates a raw list of filters passed as string.This field is used for REST get requests + * +optional + * + * @generated from field: repeated string raw_filters = 5; + */ + rawFilters: string[]; + + /** + * Specifies how listed entities should be sorted in the response. + * Sort fields are applied in order. + * +optional + * + * @generated from field: repeated flyteidl2.common.Sort sort_by_fields = 6; + */ + sortByFields: Sort[]; +}; + +/** + * Describes the message flyteidl2.common.ListRequest. + * Use `create(ListRequestSchema)` to create a new message. + */ +export const ListRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_list, 1); + +/** + * @generated from message flyteidl2.common.Filter + */ +export type Filter = Message<"flyteidl2.common.Filter"> & { + /** + * @generated from field: flyteidl2.common.Filter.Function function = 1; + */ + function: Filter_Function; + + /** + * e.g. name or version + * + * @generated from field: string field = 2; + */ + field: string; + + /** + * Only in the case of a VALUE_IN function, values may contain multiple entries. + * + * @generated from field: repeated string values = 3; + */ + values: string[]; +}; + +/** + * Describes the message flyteidl2.common.Filter. + * Use `create(FilterSchema)` to create a new message. + */ +export const FilterSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_list, 2); + +/** + * @generated from enum flyteidl2.common.Filter.Function + */ +export enum Filter_Function { + /** + * @generated from enum value: EQUAL = 0; + */ + EQUAL = 0, + + /** + * @generated from enum value: NOT_EQUAL = 1; + */ + NOT_EQUAL = 1, + + /** + * @generated from enum value: GREATER_THAN = 2; + */ + GREATER_THAN = 2, + + /** + * @generated from enum value: GREATER_THAN_OR_EQUAL = 3; + */ + GREATER_THAN_OR_EQUAL = 3, + + /** + * @generated from enum value: LESS_THAN = 4; + */ + LESS_THAN = 4, + + /** + * @generated from enum value: LESS_THAN_OR_EQUAL = 5; + */ + LESS_THAN_OR_EQUAL = 5, + + /** + * Case sensitive contains function. + * + * @generated from enum value: CONTAINS = 6; + */ + CONTAINS = 6, + + /** + * @generated from enum value: VALUE_IN = 7; + */ + VALUE_IN = 7, + + /** + * @generated from enum value: ENDS_WITH = 12; + */ + ENDS_WITH = 12, + + /** + * @generated from enum value: NOT_ENDS_WITH = 13; + */ + NOT_ENDS_WITH = 13, + + /** + * Case insensitive contains function. + * + * @generated from enum value: CONTAINS_CASE_INSENSITIVE = 14; + */ + CONTAINS_CASE_INSENSITIVE = 14, +} + +/** + * Describes the enum flyteidl2.common.Filter.Function. + */ +export const Filter_FunctionSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_common_list, 2, 0); + diff --git a/gen/ts/flyteidl2/common/phase_pb.ts b/gen/ts/flyteidl2/common/phase_pb.ts new file mode 100644 index 0000000000..a33dfc9abb --- /dev/null +++ b/gen/ts/flyteidl2/common/phase_pb.ts @@ -0,0 +1,92 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/common/phase.proto (package flyteidl2.common, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc } from "@bufbuild/protobuf/codegenv1"; + +/** + * Describes the file flyteidl2/common/phase.proto. + */ +export const file_flyteidl2_common_phase: GenFile = /*@__PURE__*/ + fileDesc("ChxmbHl0ZWlkbDIvY29tbW9uL3BoYXNlLnByb3RvEhBmbHl0ZWlkbDIuY29tbW9uKpACCgtBY3Rpb25QaGFzZRIcChhBQ1RJT05fUEhBU0VfVU5TUEVDSUZJRUQQABIXChNBQ1RJT05fUEhBU0VfUVVFVUVEEAESJgoiQUNUSU9OX1BIQVNFX1dBSVRJTkdfRk9SX1JFU09VUkNFUxACEh0KGUFDVElPTl9QSEFTRV9JTklUSUFMSVpJTkcQAxIYChRBQ1RJT05fUEhBU0VfUlVOTklORxAEEhoKFkFDVElPTl9QSEFTRV9TVUNDRUVERUQQBRIXChNBQ1RJT05fUEhBU0VfRkFJTEVEEAYSGAoUQUNUSU9OX1BIQVNFX0FCT1JURUQQBxIaChZBQ1RJT05fUEhBU0VfVElNRURfT1VUEAhCuwEKFGNvbS5mbHl0ZWlkbDIuY29tbW9uQgpQaGFzZVByb3RvSAJQAVo0Z2l0aHViLmNvbS9mbHl0ZW9yZy9mbHl0ZS92Mi9nZW4vZ28vZmx5dGVpZGwyL2NvbW1vbqICA0ZDWKoCEEZseXRlaWRsMi5Db21tb27KAhBGbHl0ZWlkbDJcQ29tbW9u4gIcRmx5dGVpZGwyXENvbW1vblxHUEJNZXRhZGF0YeoCEUZseXRlaWRsMjo6Q29tbW9uYgZwcm90bzM"); + +/** + * ActionPhase represents the execution state of an action. + * + * Phase transitions follow this typical flow: + * QUEUED -> WAITING_FOR_RESOURCES -> INITIALIZING -> RUNNING -> {SUCCEEDED|FAILED|ABORTED|TIMED_OUT} + * + * @generated from enum flyteidl2.common.ActionPhase + */ +export enum ActionPhase { + /** + * Default/unknown phase + * + * @generated from enum value: ACTION_PHASE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * Action has been accepted and is waiting to be scheduled + * + * @generated from enum value: ACTION_PHASE_QUEUED = 1; + */ + QUEUED = 1, + + /** + * Action is scheduled but waiting for compute resources to become available + * + * @generated from enum value: ACTION_PHASE_WAITING_FOR_RESOURCES = 2; + */ + WAITING_FOR_RESOURCES = 2, + + /** + * Resources have been allocated and the action is being set up + * + * @generated from enum value: ACTION_PHASE_INITIALIZING = 3; + */ + INITIALIZING = 3, + + /** + * Action is actively executing + * + * @generated from enum value: ACTION_PHASE_RUNNING = 4; + */ + RUNNING = 4, + + /** + * Action completed successfully + * + * @generated from enum value: ACTION_PHASE_SUCCEEDED = 5; + */ + SUCCEEDED = 5, + + /** + * Action failed during execution + * + * @generated from enum value: ACTION_PHASE_FAILED = 6; + */ + FAILED = 6, + + /** + * Action was manually terminated or cancelled + * + * @generated from enum value: ACTION_PHASE_ABORTED = 7; + */ + ABORTED = 7, + + /** + * Action exceeded its execution time limit + * + * @generated from enum value: ACTION_PHASE_TIMED_OUT = 8; + */ + TIMED_OUT = 8, +} + +/** + * Describes the enum flyteidl2.common.ActionPhase. + */ +export const ActionPhaseSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_common_phase, 0); + diff --git a/gen/ts/flyteidl2/common/policy_pb.ts b/gen/ts/flyteidl2/common/policy_pb.ts new file mode 100644 index 0000000000..1b81d30fdd --- /dev/null +++ b/gen/ts/flyteidl2/common/policy_pb.ts @@ -0,0 +1,76 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/common/policy.proto (package flyteidl2.common, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { Resource } from "./authorization_pb.ts"; +import { file_flyteidl2_common_authorization } from "./authorization_pb.ts"; +import type { PolicyIdentifier, RoleIdentifier } from "./identifier_pb.ts"; +import { file_flyteidl2_common_identifier } from "./identifier_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/common/policy.proto. + */ +export const file_flyteidl2_common_policy: GenFile = /*@__PURE__*/ + fileDesc("Ch1mbHl0ZWlkbDIvY29tbW9uL3BvbGljeS5wcm90bxIQZmx5dGVpZGwyLmNvbW1vbiKIAQoGUG9saWN5EjYKAmlkGAEgASgLMiIuZmx5dGVpZGwyLmNvbW1vbi5Qb2xpY3lJZGVudGlmaWVyQga6SAPIAQESMQoIYmluZGluZ3MYAiADKAsyHy5mbHl0ZWlkbDIuY29tbW9uLlBvbGljeUJpbmRpbmcSEwoLZGVzY3JpcHRpb24YAyABKAkigAEKDVBvbGljeUJpbmRpbmcSOQoHcm9sZV9pZBgBIAEoCzIgLmZseXRlaWRsMi5jb21tb24uUm9sZUlkZW50aWZpZXJCBrpIA8gBARI0CghyZXNvdXJjZRgCIAEoCzIaLmZseXRlaWRsMi5jb21tb24uUmVzb3VyY2VCBrpIA8gBAUK8AQoUY29tLmZseXRlaWRsMi5jb21tb25CC1BvbGljeVByb3RvSAJQAVo0Z2l0aHViLmNvbS9mbHl0ZW9yZy9mbHl0ZS92Mi9nZW4vZ28vZmx5dGVpZGwyL2NvbW1vbqICA0ZDWKoCEEZseXRlaWRsMi5Db21tb27KAhBGbHl0ZWlkbDJcQ29tbW9u4gIcRmx5dGVpZGwyXENvbW1vblxHUEJNZXRhZGF0YeoCEUZseXRlaWRsMjo6Q29tbW9uYgZwcm90bzM", [file_buf_validate_validate, file_flyteidl2_common_authorization, file_flyteidl2_common_identifier]); + +/** + * A policy is a collection of roles bound to a resource. + * + * @generated from message flyteidl2.common.Policy + */ +export type Policy = Message<"flyteidl2.common.Policy"> & { + /** + * @generated from field: flyteidl2.common.PolicyIdentifier id = 1; + */ + id?: PolicyIdentifier; + + /** + * @generated from field: repeated flyteidl2.common.PolicyBinding bindings = 2; + */ + bindings: PolicyBinding[]; + + /** + * Optional: human readable description + * + * @generated from field: string description = 3; + */ + description: string; +}; + +/** + * Describes the message flyteidl2.common.Policy. + * Use `create(PolicySchema)` to create a new message. + */ +export const PolicySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_policy, 0); + +/** + * A policy binding represents a role (a set of actions) defined on a resource. + * + * @generated from message flyteidl2.common.PolicyBinding + */ +export type PolicyBinding = Message<"flyteidl2.common.PolicyBinding"> & { + /** + * The role designates the permitted set of actions which can be applied to the resource. + * + * @generated from field: flyteidl2.common.RoleIdentifier role_id = 1; + */ + roleId?: RoleIdentifier; + + /** + * @generated from field: flyteidl2.common.Resource resource = 2; + */ + resource?: Resource; +}; + +/** + * Describes the message flyteidl2.common.PolicyBinding. + * Use `create(PolicyBindingSchema)` to create a new message. + */ +export const PolicyBindingSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_policy, 1); + diff --git a/gen/ts/flyteidl2/common/role_pb.ts b/gen/ts/flyteidl2/common/role_pb.ts new file mode 100644 index 0000000000..eb45f2cd6a --- /dev/null +++ b/gen/ts/flyteidl2/common/role_pb.ts @@ -0,0 +1,161 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/common/role.proto (package flyteidl2.common, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { Action, Permission } from "./authorization_pb.ts"; +import { file_flyteidl2_common_authorization } from "./authorization_pb.ts"; +import type { RoleIdentifier } from "./identifier_pb.ts"; +import { file_flyteidl2_common_identifier } from "./identifier_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/common/role.proto. + */ +export const file_flyteidl2_common_role: GenFile = /*@__PURE__*/ + fileDesc("ChtmbHl0ZWlkbDIvY29tbW9uL3JvbGUucHJvdG8SEGZseXRlaWRsMi5jb21tb24i/AEKBFJvbGUSNAoCaWQYASABKAsyIC5mbHl0ZWlkbDIuY29tbW9uLlJvbGVJZGVudGlmaWVyQga6SAPIAQESNQoLcGVybWlzc2lvbnMYAiADKAsyHC5mbHl0ZWlkbDIuY29tbW9uLlBlcm1pc3Npb25CAhgBEi0KCXJvbGVfc3BlYxgDIAEoCzIaLmZseXRlaWRsMi5jb21tb24uUm9sZVNwZWMSLQoJcm9sZV90eXBlGAQgASgOMhouZmx5dGVpZGwyLmNvbW1vbi5Sb2xlVHlwZRIpCgdhY3Rpb25zGAUgAygOMhguZmx5dGVpZGwyLmNvbW1vbi5BY3Rpb24iHwoIUm9sZVNwZWMSEwoLZGVzY3JpcHRpb24YASABKAkqmgIKCFJvbGVUeXBlEhIKDlJPTEVfVFlQRV9OT05FEAASEwoPUk9MRV9UWVBFX0FETUlOEAESGQoVUk9MRV9UWVBFX0NPTlRSSUJVVE9SEAISFAoQUk9MRV9UWVBFX1ZJRVdFUhADEhQKEFJPTEVfVFlQRV9DVVNUT00QBBIdChlST0xFX1RZUEVfQ0xVU1RFUl9NQU5BR0VSEAUSIQodUk9MRV9UWVBFX0ZMWVRFX1BST0pFQ1RfQURNSU4QBhIfChtST0xFX1RZUEVfU0VSVkVSTEVTU19WSUVXRVIQBxIkCiBST0xFX1RZUEVfU0VSVkVSTEVTU19DT05UUklCVVRPUhAIEhUKEVJPTEVfVFlQRV9TVVBQT1JUEAlCugEKFGNvbS5mbHl0ZWlkbDIuY29tbW9uQglSb2xlUHJvdG9IAlABWjRnaXRodWIuY29tL2ZseXRlb3JnL2ZseXRlL3YyL2dlbi9nby9mbHl0ZWlkbDIvY29tbW9uogIDRkNYqgIQRmx5dGVpZGwyLkNvbW1vbsoCEEZseXRlaWRsMlxDb21tb27iAhxGbHl0ZWlkbDJcQ29tbW9uXEdQQk1ldGFkYXRh6gIRRmx5dGVpZGwyOjpDb21tb25iBnByb3RvMw", [file_buf_validate_validate, file_flyteidl2_common_authorization, file_flyteidl2_common_identifier]); + +/** + * @generated from message flyteidl2.common.Role + */ +export type Role = Message<"flyteidl2.common.Role"> & { + /** + * @generated from field: flyteidl2.common.RoleIdentifier id = 1; + */ + id?: RoleIdentifier; + + /** + * @generated from field: repeated flyteidl2.common.Permission permissions = 2 [deprecated = true]; + * @deprecated + */ + permissions: Permission[]; + + /** + * @generated from field: flyteidl2.common.RoleSpec role_spec = 3; + */ + roleSpec?: RoleSpec; + + /** + * @generated from field: flyteidl2.common.RoleType role_type = 4; + */ + roleType: RoleType; + + /** + * @generated from field: repeated flyteidl2.common.Action actions = 5; + */ + actions: Action[]; +}; + +/** + * Describes the message flyteidl2.common.Role. + * Use `create(RoleSchema)` to create a new message. + */ +export const RoleSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_role, 0); + +/** + * @generated from message flyteidl2.common.RoleSpec + */ +export type RoleSpec = Message<"flyteidl2.common.RoleSpec"> & { + /** + * Optional, human readable description for this role. + * + * @generated from field: string description = 1; + */ + description: string; +}; + +/** + * Describes the message flyteidl2.common.RoleSpec. + * Use `create(RoleSpecSchema)` to create a new message. + */ +export const RoleSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_role, 1); + +/** + * A role type is a short-hand for understanding the permissions associated with a role. + * Boilerplate role types include a conventional collection of permissions + * Custom role types include a user-defined collection of permissions + * + * @generated from enum flyteidl2.common.RoleType + */ +export enum RoleType { + /** + * Default group. Not used in practice. + * + * @generated from enum value: ROLE_TYPE_NONE = 0; + */ + NONE = 0, + + /** + * The admin role has a collective set of permissions to do everything + * + * @generated from enum value: ROLE_TYPE_ADMIN = 1; + */ + ADMIN = 1, + + /** + * The contributor role has a collective set of permissions to view inventory, view executions, write inventory and create executions + * + * @generated from enum value: ROLE_TYPE_CONTRIBUTOR = 2; + */ + CONTRIBUTOR = 2, + + /** + * The viewer role has a collective set of permissions to view inventory and view executions + * + * @generated from enum value: ROLE_TYPE_VIEWER = 3; + */ + VIEWER = 3, + + /** + * Represent a role with user-defined sets of permissions. + * + * @generated from enum value: ROLE_TYPE_CUSTOM = 4; + */ + CUSTOM = 4, + + /** + * The role with permissions to administer a specific customer cluster. + * + * @generated from enum value: ROLE_TYPE_CLUSTER_MANAGER = 5; + */ + CLUSTER_MANAGER = 5, + + /** + * Role with permissions specific to administer flyte project(s). + * + * @generated from enum value: ROLE_TYPE_FLYTE_PROJECT_ADMIN = 6; + */ + FLYTE_PROJECT_ADMIN = 6, + + /** + * The viewer role for serverless + * + * @generated from enum value: ROLE_TYPE_SERVERLESS_VIEWER = 7; + */ + SERVERLESS_VIEWER = 7, + + /** + * The contributor role for serverless + * + * @generated from enum value: ROLE_TYPE_SERVERLESS_CONTRIBUTOR = 8; + */ + SERVERLESS_CONTRIBUTOR = 8, + + /** + * The support role would have contributor permissions plus the access to support endpoints + * + * @generated from enum value: ROLE_TYPE_SUPPORT = 9; + */ + SUPPORT = 9, +} + +/** + * Describes the enum flyteidl2.common.RoleType. + */ +export const RoleTypeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_common_role, 0); + diff --git a/gen/ts/flyteidl2/common/runtime_version_pb.ts b/gen/ts/flyteidl2/common/runtime_version_pb.ts new file mode 100644 index 0000000000..36c1b318bc --- /dev/null +++ b/gen/ts/flyteidl2/common/runtime_version_pb.ts @@ -0,0 +1,76 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/common/runtime_version.proto (package flyteidl2.common, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/common/runtime_version.proto. + */ +export const file_flyteidl2_common_runtime_version: GenFile = /*@__PURE__*/ + fileDesc("CiZmbHl0ZWlkbDIvY29tbW9uL3J1bnRpbWVfdmVyc2lvbi5wcm90bxIQZmx5dGVpZGwyLmNvbW1vbiKnAQoPUnVudGltZU1ldGFkYXRhEjsKBHR5cGUYASABKA4yLS5mbHl0ZWlkbDIuY29tbW9uLlJ1bnRpbWVNZXRhZGF0YS5SdW50aW1lVHlwZRIPCgd2ZXJzaW9uGAIgASgJEg4KBmZsYXZvchgDIAEoCSI2CgtSdW50aW1lVHlwZRIJCgVPVEhFUhAAEg0KCUZMWVRFX1NESxABEg0KCVVOSU9OX1NESxACQsQBChRjb20uZmx5dGVpZGwyLmNvbW1vbkITUnVudGltZVZlcnNpb25Qcm90b0gCUAFaNGdpdGh1Yi5jb20vZmx5dGVvcmcvZmx5dGUvdjIvZ2VuL2dvL2ZseXRlaWRsMi9jb21tb26iAgNGQ1iqAhBGbHl0ZWlkbDIuQ29tbW9uygIQRmx5dGVpZGwyXENvbW1vbuICHEZseXRlaWRsMlxDb21tb25cR1BCTWV0YWRhdGHqAhFGbHl0ZWlkbDI6OkNvbW1vbmIGcHJvdG8z"); + +/** + * Runtime information. This is loosely defined to allow for extensibility. + * + * @generated from message flyteidl2.common.RuntimeMetadata + */ +export type RuntimeMetadata = Message<"flyteidl2.common.RuntimeMetadata"> & { + /** + * Type of runtime. + * + * @generated from field: flyteidl2.common.RuntimeMetadata.RuntimeType type = 1; + */ + type: RuntimeMetadata_RuntimeType; + + /** + * Version of the runtime. All versions should be backward compatible. However, certain cases call for version + * checks to ensure tighter validation or setting expectations. + * + * @generated from field: string version = 2; + */ + version: string; + + /** + * +optional It can be used to provide extra information about the runtime (e.g. python, golang... etc.). + * + * @generated from field: string flavor = 3; + */ + flavor: string; +}; + +/** + * Describes the message flyteidl2.common.RuntimeMetadata. + * Use `create(RuntimeMetadataSchema)` to create a new message. + */ +export const RuntimeMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_common_runtime_version, 0); + +/** + * @generated from enum flyteidl2.common.RuntimeMetadata.RuntimeType + */ +export enum RuntimeMetadata_RuntimeType { + /** + * @generated from enum value: OTHER = 0; + */ + OTHER = 0, + + /** + * @generated from enum value: FLYTE_SDK = 1; + */ + FLYTE_SDK = 1, + + /** + * @generated from enum value: UNION_SDK = 2; + */ + UNION_SDK = 2, +} + +/** + * Describes the enum flyteidl2.common.RuntimeMetadata.RuntimeType. + */ +export const RuntimeMetadata_RuntimeTypeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_common_runtime_version, 0, 0); + diff --git a/gen/ts/flyteidl2/connector/connector_pb.ts b/gen/ts/flyteidl2/connector/connector_pb.ts new file mode 100644 index 0000000000..79238e3954 --- /dev/null +++ b/gen/ts/flyteidl2/connector/connector_pb.ts @@ -0,0 +1,722 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/connector/connector.proto (package flyteidl2.connector, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { TaskExecution_Phase, TaskLog } from "../core/execution_pb.ts"; +import { file_flyteidl2_core_execution } from "../core/execution_pb.ts"; +import type { TaskExecutionIdentifier } from "../core/identifier_pb.ts"; +import { file_flyteidl2_core_identifier } from "../core/identifier_pb.ts"; +import type { ExecutionMetricResult } from "../core/metrics_pb.ts"; +import { file_flyteidl2_core_metrics } from "../core/metrics_pb.ts"; +import type { Connection, Identity } from "../core/security_pb.ts"; +import { file_flyteidl2_core_security } from "../core/security_pb.ts"; +import type { TaskTemplate } from "../core/tasks_pb.ts"; +import { file_flyteidl2_core_tasks } from "../core/tasks_pb.ts"; +import type { Inputs, Outputs } from "../task/common_pb.ts"; +import { file_flyteidl2_task_common } from "../task/common_pb.ts"; +import type { Duration, Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_duration, file_google_protobuf_struct, file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import type { JsonObject, Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/connector/connector.proto. + */ +export const file_flyteidl2_connector_connector: GenFile = /*@__PURE__*/ + fileDesc("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", [file_flyteidl2_core_execution, file_flyteidl2_core_identifier, file_flyteidl2_core_metrics, file_flyteidl2_core_security, file_flyteidl2_core_tasks, file_flyteidl2_task_common, file_google_protobuf_duration, file_google_protobuf_struct, file_google_protobuf_timestamp]); + +/** + * Represents a subset of runtime task execution metadata that are relevant to external plugins. + * + * ID of the task execution + * + * @generated from message flyteidl2.connector.TaskExecutionMetadata + */ +export type TaskExecutionMetadata = Message<"flyteidl2.connector.TaskExecutionMetadata"> & { + /** + * @generated from field: flyteidl2.core.TaskExecutionIdentifier task_execution_id = 1; + */ + taskExecutionId?: TaskExecutionIdentifier; + + /** + * k8s namespace where the task is executed in + * + * @generated from field: string namespace = 2; + */ + namespace: string; + + /** + * Labels attached to the task execution + * + * @generated from field: map labels = 3; + */ + labels: { [key: string]: string }; + + /** + * Annotations attached to the task execution + * + * @generated from field: map annotations = 4; + */ + annotations: { [key: string]: string }; + + /** + * k8s service account associated with the task execution + * + * @generated from field: string k8s_service_account = 5; + */ + k8sServiceAccount: string; + + /** + * Environment variables attached to the task execution + * + * @generated from field: map environment_variables = 6; + */ + environmentVariables: { [key: string]: string }; + + /** + * Represents the maximum number of attempts allowed for a task. + * If a task fails, it can be retried up to this maximum number of attempts. + * + * @generated from field: int32 max_attempts = 7; + */ + maxAttempts: number; + + /** + * Indicates whether the task execution can be interrupted. + * If set to true, the task can be stopped before completion. + * + * @generated from field: bool interruptible = 8; + */ + interruptible: boolean; + + /** + * Specifies the threshold for failure count at which the interruptible property + * will take effect. If the number of consecutive task failures exceeds this threshold, + * interruptible behavior will be activated. + * + * @generated from field: int32 interruptible_failure_threshold = 9; + */ + interruptibleFailureThreshold: number; + + /** + * Identity of user running this task execution + * + * @generated from field: flyteidl2.core.Identity identity = 11; + */ + identity?: Identity; +}; + +/** + * Describes the message flyteidl2.connector.TaskExecutionMetadata. + * Use `create(TaskExecutionMetadataSchema)` to create a new message. + */ +export const TaskExecutionMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 0); + +/** + * Represents a request structure to create task. + * + * @generated from message flyteidl2.connector.CreateTaskRequest + */ +export type CreateTaskRequest = Message<"flyteidl2.connector.CreateTaskRequest"> & { + /** + * The inputs required to start the execution. All required inputs must be + * included in this map. If not required and not provided, defaults apply. + * +optional + * + * @generated from field: flyteidl2.task.Inputs inputs = 1; + */ + inputs?: Inputs; + + /** + * Template of the task that encapsulates all the metadata of the task. + * + * @generated from field: flyteidl2.core.TaskTemplate template = 2; + */ + template?: TaskTemplate; + + /** + * Prefix for where task output data will be written. (e.g. s3://my-bucket/randomstring) + * + * @generated from field: string output_prefix = 3; + */ + outputPrefix: string; + + /** + * subset of runtime task execution metadata. + * + * @generated from field: flyteidl2.connector.TaskExecutionMetadata task_execution_metadata = 4; + */ + taskExecutionMetadata?: TaskExecutionMetadata; + + /** + * Connection (secret and config) required by the connector. + * Connector will use the secret and config in the taskTemplate if it's None. + * +optional + * + * @generated from field: flyteidl2.core.Connection connection = 5; + */ + connection?: Connection; +}; + +/** + * Describes the message flyteidl2.connector.CreateTaskRequest. + * Use `create(CreateTaskRequestSchema)` to create a new message. + */ +export const CreateTaskRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 1); + +/** + * Represents a create response structure. + * + * @generated from message flyteidl2.connector.CreateTaskResponse + */ +export type CreateTaskResponse = Message<"flyteidl2.connector.CreateTaskResponse"> & { + /** + * ResourceMeta is created by the connector. It could be a string (jobId) or a dict (more complex metadata). + * + * @generated from field: bytes resource_meta = 1; + */ + resourceMeta: Uint8Array; +}; + +/** + * Describes the message flyteidl2.connector.CreateTaskResponse. + * Use `create(CreateTaskResponseSchema)` to create a new message. + */ +export const CreateTaskResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 2); + +/** + * @generated from message flyteidl2.connector.CreateRequestHeader + */ +export type CreateRequestHeader = Message<"flyteidl2.connector.CreateRequestHeader"> & { + /** + * Template of the task that encapsulates all the metadata of the task. + * + * @generated from field: flyteidl2.core.TaskTemplate template = 1; + */ + template?: TaskTemplate; + + /** + * Prefix for where task output data will be written. (e.g. s3://my-bucket/randomstring) + * + * @generated from field: string output_prefix = 2; + */ + outputPrefix: string; + + /** + * subset of runtime task execution metadata. + * + * @generated from field: flyteidl2.connector.TaskExecutionMetadata task_execution_metadata = 3; + */ + taskExecutionMetadata?: TaskExecutionMetadata; + + /** + * MaxDatasetSizeBytes is the maximum size of the dataset that can be generated by the task. + * + * @generated from field: int64 max_dataset_size_bytes = 4; + */ + maxDatasetSizeBytes: bigint; + + /** + * Connection (secret and config) required by the connector. + * Connector will use the secret and config in the taskTemplate if it's None. + * +optional + * + * @generated from field: flyteidl2.core.Connection connection = 5; + */ + connection?: Connection; +}; + +/** + * Describes the message flyteidl2.connector.CreateRequestHeader. + * Use `create(CreateRequestHeaderSchema)` to create a new message. + */ +export const CreateRequestHeaderSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 3); + +/** + * A message used to fetch a job resource from flyte connector server. + * + * @generated from message flyteidl2.connector.GetTaskRequest + */ +export type GetTaskRequest = Message<"flyteidl2.connector.GetTaskRequest"> & { + /** + * Metadata about the resource to be pass to the connector. + * + * @generated from field: bytes resource_meta = 2; + */ + resourceMeta: Uint8Array; + + /** + * A predefined yet extensible Task type identifier. + * + * @generated from field: flyteidl2.connector.TaskCategory task_category = 3; + */ + taskCategory?: TaskCategory; + + /** + * Prefix for where task output data will be written. (e.g. s3://my-bucket/randomstring) + * + * @generated from field: string output_prefix = 4; + */ + outputPrefix: string; + + /** + * Connection (secret and config) required by the connector. + * Connector will use the secret and config in the taskTemplate if it's None. + * +optional + * + * @generated from field: flyteidl2.core.Connection connection = 5; + */ + connection?: Connection; +}; + +/** + * Describes the message flyteidl2.connector.GetTaskRequest. + * Use `create(GetTaskRequestSchema)` to create a new message. + */ +export const GetTaskRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 4); + +/** + * Response to get an individual task resource. + * + * @generated from message flyteidl2.connector.GetTaskResponse + */ +export type GetTaskResponse = Message<"flyteidl2.connector.GetTaskResponse"> & { + /** + * @generated from field: flyteidl2.connector.Resource resource = 1; + */ + resource?: Resource; +}; + +/** + * Describes the message flyteidl2.connector.GetTaskResponse. + * Use `create(GetTaskResponseSchema)` to create a new message. + */ +export const GetTaskResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 5); + +/** + * @generated from message flyteidl2.connector.Resource + */ +export type Resource = Message<"flyteidl2.connector.Resource"> & { + /** + * The outputs of the execution. It's typically used by sql task. connector service will create a + * Structured dataset pointing to the query result table. + * +optional + * + * @generated from field: flyteidl2.task.Outputs outputs = 2; + */ + outputs?: Outputs; + + /** + * A descriptive message for the current state. e.g. waiting for cluster. + * + * @generated from field: string message = 3; + */ + message: string; + + /** + * log information for the task execution. + * + * @generated from field: repeated flyteidl2.core.TaskLog log_links = 4; + */ + logLinks: TaskLog[]; + + /** + * The phase of the execution is used to determine the phase of the plugin's execution. + * + * @generated from field: flyteidl2.core.TaskExecution.Phase phase = 5; + */ + phase: TaskExecution_Phase; + + /** + * Custom data specific to the connector. + * + * @generated from field: google.protobuf.Struct custom_info = 6; + */ + customInfo?: JsonObject; +}; + +/** + * Describes the message flyteidl2.connector.Resource. + * Use `create(ResourceSchema)` to create a new message. + */ +export const ResourceSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 6); + +/** + * A message used to delete a task. + * + * @generated from message flyteidl2.connector.DeleteTaskRequest + */ +export type DeleteTaskRequest = Message<"flyteidl2.connector.DeleteTaskRequest"> & { + /** + * Metadata about the resource to be pass to the connector. + * + * @generated from field: bytes resource_meta = 2; + */ + resourceMeta: Uint8Array; + + /** + * A predefined yet extensible Task type identifier. + * + * @generated from field: flyteidl2.connector.TaskCategory task_category = 3; + */ + taskCategory?: TaskCategory; + + /** + * Connection (secret and config) required by the connector. + * Connector will use the secret and config in the taskTemplate if it's None. + * +optional + * + * @generated from field: flyteidl2.core.Connection connection = 5; + */ + connection?: Connection; +}; + +/** + * Describes the message flyteidl2.connector.DeleteTaskRequest. + * Use `create(DeleteTaskRequestSchema)` to create a new message. + */ +export const DeleteTaskRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 7); + +/** + * Response to delete a task. + * + * @generated from message flyteidl2.connector.DeleteTaskResponse + */ +export type DeleteTaskResponse = Message<"flyteidl2.connector.DeleteTaskResponse"> & { +}; + +/** + * Describes the message flyteidl2.connector.DeleteTaskResponse. + * Use `create(DeleteTaskResponseSchema)` to create a new message. + */ +export const DeleteTaskResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 8); + +/** + * A message containing the connector metadata. + * + * @generated from message flyteidl2.connector.Connector + */ +export type Connector = Message<"flyteidl2.connector.Connector"> & { + /** + * Name is the developer-assigned name of the connector. + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * Supported_task_categories are the categories of the tasks that the connector can handle. + * + * @generated from field: repeated flyteidl2.connector.TaskCategory supported_task_categories = 4; + */ + supportedTaskCategories: TaskCategory[]; +}; + +/** + * Describes the message flyteidl2.connector.Connector. + * Use `create(ConnectorSchema)` to create a new message. + */ +export const ConnectorSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 9); + +/** + * @generated from message flyteidl2.connector.TaskCategory + */ +export type TaskCategory = Message<"flyteidl2.connector.TaskCategory"> & { + /** + * The name of the task type. + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * The version of the task type. + * + * @generated from field: int32 version = 2; + */ + version: number; +}; + +/** + * Describes the message flyteidl2.connector.TaskCategory. + * Use `create(TaskCategorySchema)` to create a new message. + */ +export const TaskCategorySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 10); + +/** + * A request to get an connector. + * + * @generated from message flyteidl2.connector.GetConnectorRequest + */ +export type GetConnectorRequest = Message<"flyteidl2.connector.GetConnectorRequest"> & { + /** + * The name of the connector. + * + * @generated from field: string name = 1; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.connector.GetConnectorRequest. + * Use `create(GetConnectorRequestSchema)` to create a new message. + */ +export const GetConnectorRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 11); + +/** + * A response containing an connector. + * + * @generated from message flyteidl2.connector.GetConnectorResponse + */ +export type GetConnectorResponse = Message<"flyteidl2.connector.GetConnectorResponse"> & { + /** + * @generated from field: flyteidl2.connector.Connector connector = 1; + */ + connector?: Connector; +}; + +/** + * Describes the message flyteidl2.connector.GetConnectorResponse. + * Use `create(GetConnectorResponseSchema)` to create a new message. + */ +export const GetConnectorResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 12); + +/** + * A request to list all connectors. + * + * @generated from message flyteidl2.connector.ListConnectorsRequest + */ +export type ListConnectorsRequest = Message<"flyteidl2.connector.ListConnectorsRequest"> & { +}; + +/** + * Describes the message flyteidl2.connector.ListConnectorsRequest. + * Use `create(ListConnectorsRequestSchema)` to create a new message. + */ +export const ListConnectorsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 13); + +/** + * A response containing a list of connectors. + * + * @generated from message flyteidl2.connector.ListConnectorsResponse + */ +export type ListConnectorsResponse = Message<"flyteidl2.connector.ListConnectorsResponse"> & { + /** + * @generated from field: repeated flyteidl2.connector.Connector connectors = 1; + */ + connectors: Connector[]; +}; + +/** + * Describes the message flyteidl2.connector.ListConnectorsResponse. + * Use `create(ListConnectorsResponseSchema)` to create a new message. + */ +export const ListConnectorsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 14); + +/** + * A request to get the metrics from a task execution. + * + * @generated from message flyteidl2.connector.GetTaskMetricsRequest + */ +export type GetTaskMetricsRequest = Message<"flyteidl2.connector.GetTaskMetricsRequest"> & { + /** + * Metadata is created by the connector. It could be a string (jobId) or a dict (more complex metadata). + * + * @generated from field: bytes resource_meta = 2; + */ + resourceMeta: Uint8Array; + + /** + * The metrics to query. If empty, will return a default set of metrics. + * e.g. EXECUTION_METRIC_USED_CPU_AVG or EXECUTION_METRIC_USED_MEMORY_BYTES_AVG + * + * @generated from field: repeated string queries = 3; + */ + queries: string[]; + + /** + * Start timestamp, inclusive. + * + * @generated from field: google.protobuf.Timestamp start_time = 4; + */ + startTime?: Timestamp; + + /** + * End timestamp, inclusive.. + * + * @generated from field: google.protobuf.Timestamp end_time = 5; + */ + endTime?: Timestamp; + + /** + * Query resolution step width in duration format or float number of seconds. + * + * @generated from field: google.protobuf.Duration step = 6; + */ + step?: Duration; + + /** + * A predefined yet extensible Task type identifier. + * + * @generated from field: flyteidl2.connector.TaskCategory task_category = 7; + */ + taskCategory?: TaskCategory; +}; + +/** + * Describes the message flyteidl2.connector.GetTaskMetricsRequest. + * Use `create(GetTaskMetricsRequestSchema)` to create a new message. + */ +export const GetTaskMetricsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 15); + +/** + * A response containing a list of metrics for a task execution. + * + * @generated from message flyteidl2.connector.GetTaskMetricsResponse + */ +export type GetTaskMetricsResponse = Message<"flyteidl2.connector.GetTaskMetricsResponse"> & { + /** + * The execution metric results. + * + * @generated from field: repeated flyteidl2.core.ExecutionMetricResult results = 1; + */ + results: ExecutionMetricResult[]; +}; + +/** + * Describes the message flyteidl2.connector.GetTaskMetricsResponse. + * Use `create(GetTaskMetricsResponseSchema)` to create a new message. + */ +export const GetTaskMetricsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 16); + +/** + * A request to get the log from a task execution. + * + * @generated from message flyteidl2.connector.GetTaskLogsRequest + */ +export type GetTaskLogsRequest = Message<"flyteidl2.connector.GetTaskLogsRequest"> & { + /** + * Metadata is created by the connector. It could be a string (jobId) or a dict (more complex metadata). + * + * @generated from field: bytes resource_meta = 2; + */ + resourceMeta: Uint8Array; + + /** + * Number of lines to return. + * + * @generated from field: uint64 lines = 3; + */ + lines: bigint; + + /** + * In the case of multiple pages of results, the server-provided token can be used to fetch the next page + * in a query. If there are no more results, this value will be empty. + * + * @generated from field: string token = 4; + */ + token: string; + + /** + * A predefined yet extensible Task type identifier. + * + * @generated from field: flyteidl2.connector.TaskCategory task_category = 5; + */ + taskCategory?: TaskCategory; +}; + +/** + * Describes the message flyteidl2.connector.GetTaskLogsRequest. + * Use `create(GetTaskLogsRequestSchema)` to create a new message. + */ +export const GetTaskLogsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 17); + +/** + * @generated from message flyteidl2.connector.GetTaskLogsResponseHeader + */ +export type GetTaskLogsResponseHeader = Message<"flyteidl2.connector.GetTaskLogsResponseHeader"> & { + /** + * In the case of multiple pages of results, the server-provided token can be used to fetch the next page + * in a query. If there are no more results, this value will be empty. + * + * @generated from field: string token = 1; + */ + token: string; +}; + +/** + * Describes the message flyteidl2.connector.GetTaskLogsResponseHeader. + * Use `create(GetTaskLogsResponseHeaderSchema)` to create a new message. + */ +export const GetTaskLogsResponseHeaderSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 18); + +/** + * @generated from message flyteidl2.connector.GetTaskLogsResponseBody + */ +export type GetTaskLogsResponseBody = Message<"flyteidl2.connector.GetTaskLogsResponseBody"> & { + /** + * The execution log results. + * + * @generated from field: repeated string results = 1; + */ + results: string[]; +}; + +/** + * Describes the message flyteidl2.connector.GetTaskLogsResponseBody. + * Use `create(GetTaskLogsResponseBodySchema)` to create a new message. + */ +export const GetTaskLogsResponseBodySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 19); + +/** + * A response containing the logs for a task execution. + * + * @generated from message flyteidl2.connector.GetTaskLogsResponse + */ +export type GetTaskLogsResponse = Message<"flyteidl2.connector.GetTaskLogsResponse"> & { + /** + * @generated from oneof flyteidl2.connector.GetTaskLogsResponse.part + */ + part: { + /** + * @generated from field: flyteidl2.connector.GetTaskLogsResponseHeader header = 1; + */ + value: GetTaskLogsResponseHeader; + case: "header"; + } | { + /** + * @generated from field: flyteidl2.connector.GetTaskLogsResponseBody body = 2; + */ + value: GetTaskLogsResponseBody; + case: "body"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.connector.GetTaskLogsResponse. + * Use `create(GetTaskLogsResponseSchema)` to create a new message. + */ +export const GetTaskLogsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_connector_connector, 20); + diff --git a/gen/ts/flyteidl2/connector/service_pb.ts b/gen/ts/flyteidl2/connector/service_pb.ts new file mode 100644 index 0000000000..736d159e81 --- /dev/null +++ b/gen/ts/flyteidl2/connector/service_pb.ts @@ -0,0 +1,109 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/connector/service.proto (package flyteidl2.connector, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import type { CreateTaskRequestSchema, CreateTaskResponseSchema, DeleteTaskRequestSchema, DeleteTaskResponseSchema, GetConnectorRequestSchema, GetConnectorResponseSchema, GetTaskLogsRequestSchema, GetTaskLogsResponseSchema, GetTaskMetricsRequestSchema, GetTaskMetricsResponseSchema, GetTaskRequestSchema, GetTaskResponseSchema, ListConnectorsRequestSchema, ListConnectorsResponseSchema } from "./connector_pb.ts"; +import { file_flyteidl2_connector_connector } from "./connector_pb.ts"; +import { file_google_api_annotations } from "../../google/api/annotations_pb.ts"; + +/** + * Describes the file flyteidl2/connector/service.proto. + */ +export const file_flyteidl2_connector_service: GenFile = /*@__PURE__*/ + fileDesc("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", [file_flyteidl2_connector_connector, file_google_api_annotations]); + +/** + * AsyncConnectorService defines an RPC Service that allows executor to send the request to the connector server asynchronously. + * + * @generated from service flyteidl2.connector.AsyncConnectorService + */ +export const AsyncConnectorService: GenService<{ + /** + * CreateTask sends a task create request to the connector service. + * + * @generated from rpc flyteidl2.connector.AsyncConnectorService.CreateTask + */ + createTask: { + methodKind: "unary"; + input: typeof CreateTaskRequestSchema; + output: typeof CreateTaskResponseSchema; + }, + /** + * Get job status. + * + * @generated from rpc flyteidl2.connector.AsyncConnectorService.GetTask + */ + getTask: { + methodKind: "unary"; + input: typeof GetTaskRequestSchema; + output: typeof GetTaskResponseSchema; + }, + /** + * Delete the task resource. + * + * @generated from rpc flyteidl2.connector.AsyncConnectorService.DeleteTask + */ + deleteTask: { + methodKind: "unary"; + input: typeof DeleteTaskRequestSchema; + output: typeof DeleteTaskResponseSchema; + }, + /** + * GetTaskMetrics returns one or more task execution metrics, if available. + * + * Errors include + * * OutOfRange if metrics are not available for the specified task time range + * * various other errors + * + * @generated from rpc flyteidl2.connector.AsyncConnectorService.GetTaskMetrics + */ + getTaskMetrics: { + methodKind: "unary"; + input: typeof GetTaskMetricsRequestSchema; + output: typeof GetTaskMetricsResponseSchema; + }, + /** + * GetTaskLogs returns task execution logs, if available. + * + * @generated from rpc flyteidl2.connector.AsyncConnectorService.GetTaskLogs + */ + getTaskLogs: { + methodKind: "server_streaming"; + input: typeof GetTaskLogsRequestSchema; + output: typeof GetTaskLogsResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_connector_service, 0); + +/** + * ConnectorMetadataService defines an RPC service that is also served over HTTP via grpc-gateway. + * This service allows executor or users to get the metadata of connectors. + * + * @generated from service flyteidl2.connector.ConnectorMetadataService + */ +export const ConnectorMetadataService: GenService<{ + /** + * Fetch a :ref:`ref_flyteidl2.plugins.Connector` definition. + * + * @generated from rpc flyteidl2.connector.ConnectorMetadataService.GetConnector + */ + getConnector: { + methodKind: "unary"; + input: typeof GetConnectorRequestSchema; + output: typeof GetConnectorResponseSchema; + }, + /** + * Fetch a list of :ref:`ref_flyteidl2.plugins.Connector` definitions. + * + * @generated from rpc flyteidl2.connector.ConnectorMetadataService.ListConnectors + */ + listConnectors: { + methodKind: "unary"; + input: typeof ListConnectorsRequestSchema; + output: typeof ListConnectorsResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_connector_service, 1); + diff --git a/gen/ts/flyteidl2/core/artifact_id_pb.ts b/gen/ts/flyteidl2/core/artifact_id_pb.ts new file mode 100644 index 0000000000..1501077859 --- /dev/null +++ b/gen/ts/flyteidl2/core/artifact_id_pb.ts @@ -0,0 +1,400 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/core/artifact_id.proto (package flyteidl2.core, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/core/artifact_id.proto. + */ +export const file_flyteidl2_core_artifact_id: GenFile = /*@__PURE__*/ + fileDesc("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", [file_google_protobuf_timestamp]); + +/** + * @generated from message flyteidl2.core.ArtifactKey + */ +export type ArtifactKey = Message<"flyteidl2.core.ArtifactKey"> & { + /** + * Project and domain and suffix needs to be unique across a given artifact store. + * + * @generated from field: string project = 1; + */ + project: string; + + /** + * @generated from field: string domain = 2; + */ + domain: string; + + /** + * @generated from field: string name = 3; + */ + name: string; + + /** + * @generated from field: string org = 4; + */ + org: string; +}; + +/** + * Describes the message flyteidl2.core.ArtifactKey. + * Use `create(ArtifactKeySchema)` to create a new message. + */ +export const ArtifactKeySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_artifact_id, 0); + +/** + * Only valid for triggers + * + * @generated from message flyteidl2.core.ArtifactBindingData + */ +export type ArtifactBindingData = Message<"flyteidl2.core.ArtifactBindingData"> & { + /** + * These two fields are only relevant in the partition value case + * + * @generated from oneof flyteidl2.core.ArtifactBindingData.partition_data + */ + partitionData: { + /** + * @generated from field: string partition_key = 5; + */ + value: string; + case: "partitionKey"; + } | { + /** + * @generated from field: bool bind_to_time_partition = 6; + */ + value: boolean; + case: "bindToTimePartition"; + } | { case: undefined; value?: undefined }; + + /** + * This is only relevant in the time partition case + * + * @generated from field: flyteidl2.core.TimeTransform time_transform = 7; + */ + timeTransform?: TimeTransform; +}; + +/** + * Describes the message flyteidl2.core.ArtifactBindingData. + * Use `create(ArtifactBindingDataSchema)` to create a new message. + */ +export const ArtifactBindingDataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_artifact_id, 1); + +/** + * @generated from message flyteidl2.core.TimeTransform + */ +export type TimeTransform = Message<"flyteidl2.core.TimeTransform"> & { + /** + * @generated from field: string transform = 1; + */ + transform: string; + + /** + * @generated from field: flyteidl2.core.Operator op = 2; + */ + op: Operator; +}; + +/** + * Describes the message flyteidl2.core.TimeTransform. + * Use `create(TimeTransformSchema)` to create a new message. + */ +export const TimeTransformSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_artifact_id, 2); + +/** + * @generated from message flyteidl2.core.InputBindingData + */ +export type InputBindingData = Message<"flyteidl2.core.InputBindingData"> & { + /** + * @generated from field: string var = 1; + */ + var: string; +}; + +/** + * Describes the message flyteidl2.core.InputBindingData. + * Use `create(InputBindingDataSchema)` to create a new message. + */ +export const InputBindingDataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_artifact_id, 3); + +/** + * @generated from message flyteidl2.core.RuntimeBinding + */ +export type RuntimeBinding = Message<"flyteidl2.core.RuntimeBinding"> & { +}; + +/** + * Describes the message flyteidl2.core.RuntimeBinding. + * Use `create(RuntimeBindingSchema)` to create a new message. + */ +export const RuntimeBindingSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_artifact_id, 4); + +/** + * @generated from message flyteidl2.core.LabelValue + */ +export type LabelValue = Message<"flyteidl2.core.LabelValue"> & { + /** + * @generated from oneof flyteidl2.core.LabelValue.value + */ + value: { + /** + * The string static value is for use in the Partitions object + * + * @generated from field: string static_value = 1; + */ + value: string; + case: "staticValue"; + } | { + /** + * The time value is for use in the TimePartition case + * + * @generated from field: google.protobuf.Timestamp time_value = 2; + */ + value: Timestamp; + case: "timeValue"; + } | { + /** + * @generated from field: flyteidl2.core.ArtifactBindingData triggered_binding = 3; + */ + value: ArtifactBindingData; + case: "triggeredBinding"; + } | { + /** + * @generated from field: flyteidl2.core.InputBindingData input_binding = 4; + */ + value: InputBindingData; + case: "inputBinding"; + } | { + /** + * @generated from field: flyteidl2.core.RuntimeBinding runtime_binding = 5; + */ + value: RuntimeBinding; + case: "runtimeBinding"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.core.LabelValue. + * Use `create(LabelValueSchema)` to create a new message. + */ +export const LabelValueSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_artifact_id, 5); + +/** + * @generated from message flyteidl2.core.Partitions + */ +export type Partitions = Message<"flyteidl2.core.Partitions"> & { + /** + * @generated from field: map value = 1; + */ + value: { [key: string]: LabelValue }; +}; + +/** + * Describes the message flyteidl2.core.Partitions. + * Use `create(PartitionsSchema)` to create a new message. + */ +export const PartitionsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_artifact_id, 6); + +/** + * @generated from message flyteidl2.core.TimePartition + */ +export type TimePartition = Message<"flyteidl2.core.TimePartition"> & { + /** + * @generated from field: flyteidl2.core.LabelValue value = 1; + */ + value?: LabelValue; + + /** + * @generated from field: flyteidl2.core.Granularity granularity = 2; + */ + granularity: Granularity; +}; + +/** + * Describes the message flyteidl2.core.TimePartition. + * Use `create(TimePartitionSchema)` to create a new message. + */ +export const TimePartitionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_artifact_id, 7); + +/** + * @generated from message flyteidl2.core.ArtifactID + */ +export type ArtifactID = Message<"flyteidl2.core.ArtifactID"> & { + /** + * @generated from field: flyteidl2.core.ArtifactKey artifact_key = 1; + */ + artifactKey?: ArtifactKey; + + /** + * @generated from field: string version = 2; + */ + version: string; + + /** + * Think of a partition as a tag on an Artifact, except it's a key-value pair. + * Different partitions naturally have different versions (execution ids). + * + * @generated from field: flyteidl2.core.Partitions partitions = 3; + */ + partitions?: Partitions; + + /** + * There is no such thing as an empty time partition - if it's not set, then there is no time partition. + * + * @generated from field: flyteidl2.core.TimePartition time_partition = 4; + */ + timePartition?: TimePartition; +}; + +/** + * Describes the message flyteidl2.core.ArtifactID. + * Use `create(ArtifactIDSchema)` to create a new message. + */ +export const ArtifactIDSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_artifact_id, 8); + +/** + * @generated from message flyteidl2.core.ArtifactTag + */ +export type ArtifactTag = Message<"flyteidl2.core.ArtifactTag"> & { + /** + * @generated from field: flyteidl2.core.ArtifactKey artifact_key = 1; + */ + artifactKey?: ArtifactKey; + + /** + * @generated from field: flyteidl2.core.LabelValue value = 2; + */ + value?: LabelValue; +}; + +/** + * Describes the message flyteidl2.core.ArtifactTag. + * Use `create(ArtifactTagSchema)` to create a new message. + */ +export const ArtifactTagSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_artifact_id, 9); + +/** + * Uniqueness constraints for Artifacts + * - project, domain, name, version, partitions + * Option 2 (tags are standalone, point to an individual artifact id): + * - project, domain, name, alias (points to one partition if partitioned) + * - project, domain, name, partition key, partition value + * + * @generated from message flyteidl2.core.ArtifactQuery + */ +export type ArtifactQuery = Message<"flyteidl2.core.ArtifactQuery"> & { + /** + * @generated from oneof flyteidl2.core.ArtifactQuery.identifier + */ + identifier: { + /** + * @generated from field: flyteidl2.core.ArtifactID artifact_id = 1; + */ + value: ArtifactID; + case: "artifactId"; + } | { + /** + * @generated from field: flyteidl2.core.ArtifactTag artifact_tag = 2; + */ + value: ArtifactTag; + case: "artifactTag"; + } | { + /** + * @generated from field: string uri = 3; + */ + value: string; + case: "uri"; + } | { + /** + * This is used in the trigger case, where a user specifies a value for an input that is one of the triggering + * artifacts, or a partition value derived from a triggering artifact. + * + * @generated from field: flyteidl2.core.ArtifactBindingData binding = 4; + */ + value: ArtifactBindingData; + case: "binding"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.core.ArtifactQuery. + * Use `create(ArtifactQuerySchema)` to create a new message. + */ +export const ArtifactQuerySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_artifact_id, 10); + +/** + * @generated from enum flyteidl2.core.Granularity + */ +export enum Granularity { + /** + * @generated from enum value: UNSET = 0; + */ + UNSET = 0, + + /** + * @generated from enum value: MINUTE = 1; + */ + MINUTE = 1, + + /** + * @generated from enum value: HOUR = 2; + */ + HOUR = 2, + + /** + * default + * + * @generated from enum value: DAY = 3; + */ + DAY = 3, + + /** + * @generated from enum value: MONTH = 4; + */ + MONTH = 4, +} + +/** + * Describes the enum flyteidl2.core.Granularity. + */ +export const GranularitySchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_artifact_id, 0); + +/** + * @generated from enum flyteidl2.core.Operator + */ +export enum Operator { + /** + * @generated from enum value: MINUS = 0; + */ + MINUS = 0, + + /** + * @generated from enum value: PLUS = 1; + */ + PLUS = 1, +} + +/** + * Describes the enum flyteidl2.core.Operator. + */ +export const OperatorSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_artifact_id, 1); + diff --git a/gen/ts/flyteidl2/core/catalog_pb.ts b/gen/ts/flyteidl2/core/catalog_pb.ts new file mode 100644 index 0000000000..611c08cea6 --- /dev/null +++ b/gen/ts/flyteidl2/core/catalog_pb.ts @@ -0,0 +1,215 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/core/catalog.proto (package flyteidl2.core, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Identifier, TaskExecutionIdentifier } from "./identifier_pb.ts"; +import { file_flyteidl2_core_identifier } from "./identifier_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/core/catalog.proto. + */ +export const file_flyteidl2_core_catalog: GenFile = /*@__PURE__*/ + fileDesc("ChxmbHl0ZWlkbDIvY29yZS9jYXRhbG9nLnByb3RvEg5mbHl0ZWlkbDIuY29yZSI3ChJDYXRhbG9nQXJ0aWZhY3RUYWcSEwoLYXJ0aWZhY3RfaWQYASABKAkSDAoEbmFtZRgCIAEoCSLZAQoPQ2F0YWxvZ01ldGFkYXRhEi4KCmRhdGFzZXRfaWQYASABKAsyGi5mbHl0ZWlkbDIuY29yZS5JZGVudGlmaWVyEjgKDGFydGlmYWN0X3RhZxgCIAEoCzIiLmZseXRlaWRsMi5jb3JlLkNhdGFsb2dBcnRpZmFjdFRhZxJIChVzb3VyY2VfdGFza19leGVjdXRpb24YAyABKAsyJy5mbHl0ZWlkbDIuY29yZS5UYXNrRXhlY3V0aW9uSWRlbnRpZmllckgAQhIKEHNvdXJjZV9leGVjdXRpb24ingEKEkNhdGFsb2dSZXNlcnZhdGlvbiKHAQoGU3RhdHVzEhgKFFJFU0VSVkFUSU9OX0RJU0FCTEVEEAASGAoUUkVTRVJWQVRJT05fQUNRVUlSRUQQARIWChJSRVNFUlZBVElPTl9FWElTVFMQAhIYChRSRVNFUlZBVElPTl9SRUxFQVNFRBADEhcKE1JFU0VSVkFUSU9OX0ZBSUxVUkUQBCqzAQoSQ2F0YWxvZ0NhY2hlU3RhdHVzEhIKDkNBQ0hFX0RJU0FCTEVEEAASDgoKQ0FDSEVfTUlTUxABEg0KCUNBQ0hFX0hJVBACEhMKD0NBQ0hFX1BPUFVMQVRFRBADEhgKFENBQ0hFX0xPT0tVUF9GQUlMVVJFEAQSFQoRQ0FDSEVfUFVUX0ZBSUxVUkUQBRIRCg1DQUNIRV9TS0lQUEVEEAYSEQoNQ0FDSEVfRVZJQ1RFRBAHQrEBChJjb20uZmx5dGVpZGwyLmNvcmVCDENhdGFsb2dQcm90b0gCUAFaMmdpdGh1Yi5jb20vZmx5dGVvcmcvZmx5dGUvdjIvZ2VuL2dvL2ZseXRlaWRsMi9jb3JlogIDRkNYqgIORmx5dGVpZGwyLkNvcmXKAg5GbHl0ZWlkbDJcQ29yZeICGkZseXRlaWRsMlxDb3JlXEdQQk1ldGFkYXRh6gIPRmx5dGVpZGwyOjpDb3JlYgZwcm90bzM", [file_flyteidl2_core_identifier]); + +/** + * @generated from message flyteidl2.core.CatalogArtifactTag + */ +export type CatalogArtifactTag = Message<"flyteidl2.core.CatalogArtifactTag"> & { + /** + * Artifact ID is generated name + * + * @generated from field: string artifact_id = 1; + */ + artifactId: string; + + /** + * Flyte computes the tag automatically, as the hash of the values + * + * @generated from field: string name = 2; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.core.CatalogArtifactTag. + * Use `create(CatalogArtifactTagSchema)` to create a new message. + */ +export const CatalogArtifactTagSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_catalog, 0); + +/** + * Catalog artifact information with specific metadata + * + * @generated from message flyteidl2.core.CatalogMetadata + */ +export type CatalogMetadata = Message<"flyteidl2.core.CatalogMetadata"> & { + /** + * Dataset ID in the catalog + * + * @generated from field: flyteidl2.core.Identifier dataset_id = 1; + */ + datasetId?: Identifier; + + /** + * Artifact tag in the catalog + * + * @generated from field: flyteidl2.core.CatalogArtifactTag artifact_tag = 2; + */ + artifactTag?: CatalogArtifactTag; + + /** + * Optional: Source Execution identifier, if this dataset was generated by another execution in Flyte. This is a one-of field and will depend on the caching context + * + * @generated from oneof flyteidl2.core.CatalogMetadata.source_execution + */ + sourceExecution: { + /** + * Today we only support TaskExecutionIdentifier as a source, as catalog caching only works for task executions + * + * @generated from field: flyteidl2.core.TaskExecutionIdentifier source_task_execution = 3; + */ + value: TaskExecutionIdentifier; + case: "sourceTaskExecution"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.core.CatalogMetadata. + * Use `create(CatalogMetadataSchema)` to create a new message. + */ +export const CatalogMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_catalog, 1); + +/** + * @generated from message flyteidl2.core.CatalogReservation + */ +export type CatalogReservation = Message<"flyteidl2.core.CatalogReservation"> & { +}; + +/** + * Describes the message flyteidl2.core.CatalogReservation. + * Use `create(CatalogReservationSchema)` to create a new message. + */ +export const CatalogReservationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_catalog, 2); + +/** + * Indicates the status of a catalog reservation operation. + * + * @generated from enum flyteidl2.core.CatalogReservation.Status + */ +export enum CatalogReservation_Status { + /** + * Used to indicate that reservations are disabled + * + * @generated from enum value: RESERVATION_DISABLED = 0; + */ + RESERVATION_DISABLED = 0, + + /** + * Used to indicate that a reservation was successfully acquired or extended + * + * @generated from enum value: RESERVATION_ACQUIRED = 1; + */ + RESERVATION_ACQUIRED = 1, + + /** + * Used to indicate that an active reservation currently exists + * + * @generated from enum value: RESERVATION_EXISTS = 2; + */ + RESERVATION_EXISTS = 2, + + /** + * Used to indicate that the reservation has been successfully released + * + * @generated from enum value: RESERVATION_RELEASED = 3; + */ + RESERVATION_RELEASED = 3, + + /** + * Used to indicate that a reservation operation resulted in failure + * + * @generated from enum value: RESERVATION_FAILURE = 4; + */ + RESERVATION_FAILURE = 4, +} + +/** + * Describes the enum flyteidl2.core.CatalogReservation.Status. + */ +export const CatalogReservation_StatusSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_catalog, 2, 0); + +/** + * Indicates the status of CatalogCaching. The reason why this is not embedded in TaskNodeMetadata is, that we may use for other types of nodes as well in the future + * + * @generated from enum flyteidl2.core.CatalogCacheStatus + */ +export enum CatalogCacheStatus { + /** + * Used to indicate that caching was disabled + * + * @generated from enum value: CACHE_DISABLED = 0; + */ + CACHE_DISABLED = 0, + + /** + * Used to indicate that the cache lookup resulted in no matches + * + * @generated from enum value: CACHE_MISS = 1; + */ + CACHE_MISS = 1, + + /** + * used to indicate that the associated artifact was a result of a previous execution + * + * @generated from enum value: CACHE_HIT = 2; + */ + CACHE_HIT = 2, + + /** + * used to indicate that the resultant artifact was added to the cache + * + * @generated from enum value: CACHE_POPULATED = 3; + */ + CACHE_POPULATED = 3, + + /** + * Used to indicate that cache lookup failed because of an error + * + * @generated from enum value: CACHE_LOOKUP_FAILURE = 4; + */ + CACHE_LOOKUP_FAILURE = 4, + + /** + * Used to indicate that cache lookup failed because of an error + * + * @generated from enum value: CACHE_PUT_FAILURE = 5; + */ + CACHE_PUT_FAILURE = 5, + + /** + * Used to indicate the cache lookup was skipped + * + * @generated from enum value: CACHE_SKIPPED = 6; + */ + CACHE_SKIPPED = 6, + + /** + * Used to indicate that the cache was evicted + * + * @generated from enum value: CACHE_EVICTED = 7; + */ + CACHE_EVICTED = 7, +} + +/** + * Describes the enum flyteidl2.core.CatalogCacheStatus. + */ +export const CatalogCacheStatusSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_catalog, 0); + diff --git a/gen/ts/flyteidl2/core/errors_pb.ts b/gen/ts/flyteidl2/core/errors_pb.ts new file mode 100644 index 0000000000..e30f657cff --- /dev/null +++ b/gen/ts/flyteidl2/core/errors_pb.ts @@ -0,0 +1,104 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/core/errors.proto (package flyteidl2.core, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { ExecutionError_ErrorKind } from "./execution_pb.ts"; +import { file_flyteidl2_core_execution } from "./execution_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/core/errors.proto. + */ +export const file_flyteidl2_core_errors: GenFile = /*@__PURE__*/ + fileDesc("ChtmbHl0ZWlkbDIvY29yZS9lcnJvcnMucHJvdG8SDmZseXRlaWRsMi5jb3JlIsoBCg5Db250YWluZXJFcnJvchIMCgRjb2RlGAEgASgJEg8KB21lc3NhZ2UYAiABKAkSMQoEa2luZBgDIAEoDjIjLmZseXRlaWRsMi5jb3JlLkNvbnRhaW5lckVycm9yLktpbmQSOAoGb3JpZ2luGAQgASgOMiguZmx5dGVpZGwyLmNvcmUuRXhlY3V0aW9uRXJyb3IuRXJyb3JLaW5kIiwKBEtpbmQSEwoPTk9OX1JFQ09WRVJBQkxFEAASDwoLUkVDT1ZFUkFCTEUQASI+Cg1FcnJvckRvY3VtZW50Ei0KBWVycm9yGAEgASgLMh4uZmx5dGVpZGwyLmNvcmUuQ29udGFpbmVyRXJyb3JCsAEKEmNvbS5mbHl0ZWlkbDIuY29yZUILRXJyb3JzUHJvdG9IAlABWjJnaXRodWIuY29tL2ZseXRlb3JnL2ZseXRlL3YyL2dlbi9nby9mbHl0ZWlkbDIvY29yZaICA0ZDWKoCDkZseXRlaWRsMi5Db3JlygIORmx5dGVpZGwyXENvcmXiAhpGbHl0ZWlkbDJcQ29yZVxHUEJNZXRhZGF0YeoCD0ZseXRlaWRsMjo6Q29yZWIGcHJvdG8z", [file_flyteidl2_core_execution]); + +/** + * Error message to propagate detailed errors from container executions to the execution + * engine. + * + * @generated from message flyteidl2.core.ContainerError + */ +export type ContainerError = Message<"flyteidl2.core.ContainerError"> & { + /** + * A simplified code for errors, so that we can provide a glossary of all possible errors. + * + * @generated from field: string code = 1; + */ + code: string; + + /** + * A detailed error message. + * + * @generated from field: string message = 2; + */ + message: string; + + /** + * An abstract error kind for this error. Defaults to Non_Recoverable if not specified. + * + * @generated from field: flyteidl2.core.ContainerError.Kind kind = 3; + */ + kind: ContainerError_Kind; + + /** + * Defines the origin of the error (system, user, unknown). + * + * @generated from field: flyteidl2.core.ExecutionError.ErrorKind origin = 4; + */ + origin: ExecutionError_ErrorKind; +}; + +/** + * Describes the message flyteidl2.core.ContainerError. + * Use `create(ContainerErrorSchema)` to create a new message. + */ +export const ContainerErrorSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_errors, 0); + +/** + * Defines a generic error type that dictates the behavior of the retry strategy. + * + * @generated from enum flyteidl2.core.ContainerError.Kind + */ +export enum ContainerError_Kind { + /** + * @generated from enum value: NON_RECOVERABLE = 0; + */ + NON_RECOVERABLE = 0, + + /** + * @generated from enum value: RECOVERABLE = 1; + */ + RECOVERABLE = 1, +} + +/** + * Describes the enum flyteidl2.core.ContainerError.Kind. + */ +export const ContainerError_KindSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_errors, 0, 0); + +/** + * Defines the errors.pb file format the container can produce to communicate + * failure reasons to the execution engine. + * + * @generated from message flyteidl2.core.ErrorDocument + */ +export type ErrorDocument = Message<"flyteidl2.core.ErrorDocument"> & { + /** + * The error raised during execution. + * + * @generated from field: flyteidl2.core.ContainerError error = 1; + */ + error?: ContainerError; +}; + +/** + * Describes the message flyteidl2.core.ErrorDocument. + * Use `create(ErrorDocumentSchema)` to create a new message. + */ +export const ErrorDocumentSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_errors, 1); + diff --git a/gen/ts/flyteidl2/core/execution_pb.ts b/gen/ts/flyteidl2/core/execution_pb.ts new file mode 100644 index 0000000000..a11a33c1dc --- /dev/null +++ b/gen/ts/flyteidl2/core/execution_pb.ts @@ -0,0 +1,646 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/core/execution.proto (package flyteidl2.core, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Duration, Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_duration, file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/core/execution.proto. + */ +export const file_flyteidl2_core_execution: GenFile = /*@__PURE__*/ + fileDesc("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", [file_google_protobuf_duration, file_google_protobuf_timestamp]); + +/** + * Indicates various phases of Workflow Execution + * + * @generated from message flyteidl2.core.WorkflowExecution + */ +export type WorkflowExecution = Message<"flyteidl2.core.WorkflowExecution"> & { +}; + +/** + * Describes the message flyteidl2.core.WorkflowExecution. + * Use `create(WorkflowExecutionSchema)` to create a new message. + */ +export const WorkflowExecutionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_execution, 0); + +/** + * @generated from enum flyteidl2.core.WorkflowExecution.Phase + */ +export enum WorkflowExecution_Phase { + /** + * @generated from enum value: UNDEFINED = 0; + */ + UNDEFINED = 0, + + /** + * @generated from enum value: QUEUED = 1; + */ + QUEUED = 1, + + /** + * @generated from enum value: RUNNING = 2; + */ + RUNNING = 2, + + /** + * @generated from enum value: SUCCEEDING = 3; + */ + SUCCEEDING = 3, + + /** + * @generated from enum value: SUCCEEDED = 4; + */ + SUCCEEDED = 4, + + /** + * @generated from enum value: FAILING = 5; + */ + FAILING = 5, + + /** + * @generated from enum value: FAILED = 6; + */ + FAILED = 6, + + /** + * @generated from enum value: ABORTED = 7; + */ + ABORTED = 7, + + /** + * @generated from enum value: TIMED_OUT = 8; + */ + TIMED_OUT = 8, + + /** + * @generated from enum value: ABORTING = 9; + */ + ABORTING = 9, +} + +/** + * Describes the enum flyteidl2.core.WorkflowExecution.Phase. + */ +export const WorkflowExecution_PhaseSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_execution, 0, 0); + +/** + * Indicates various phases of Node Execution that only include the time spent to run the nodes/workflows + * + * @generated from message flyteidl2.core.NodeExecution + */ +export type NodeExecution = Message<"flyteidl2.core.NodeExecution"> & { +}; + +/** + * Describes the message flyteidl2.core.NodeExecution. + * Use `create(NodeExecutionSchema)` to create a new message. + */ +export const NodeExecutionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_execution, 1); + +/** + * @generated from enum flyteidl2.core.NodeExecution.Phase + */ +export enum NodeExecution_Phase { + /** + * @generated from enum value: UNDEFINED = 0; + */ + UNDEFINED = 0, + + /** + * @generated from enum value: QUEUED = 1; + */ + QUEUED = 1, + + /** + * @generated from enum value: RUNNING = 2; + */ + RUNNING = 2, + + /** + * @generated from enum value: SUCCEEDED = 3; + */ + SUCCEEDED = 3, + + /** + * @generated from enum value: FAILING = 4; + */ + FAILING = 4, + + /** + * @generated from enum value: FAILED = 5; + */ + FAILED = 5, + + /** + * @generated from enum value: ABORTED = 6; + */ + ABORTED = 6, + + /** + * @generated from enum value: SKIPPED = 7; + */ + SKIPPED = 7, + + /** + * @generated from enum value: TIMED_OUT = 8; + */ + TIMED_OUT = 8, + + /** + * @generated from enum value: DYNAMIC_RUNNING = 9; + */ + DYNAMIC_RUNNING = 9, + + /** + * @generated from enum value: RECOVERED = 10; + */ + RECOVERED = 10, +} + +/** + * Describes the enum flyteidl2.core.NodeExecution.Phase. + */ +export const NodeExecution_PhaseSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_execution, 1, 0); + +/** + * Phases that task plugins can go through. Not all phases may be applicable to a specific plugin task, + * but this is the cumulative list that customers may want to know about for their task. + * + * @generated from message flyteidl2.core.TaskExecution + */ +export type TaskExecution = Message<"flyteidl2.core.TaskExecution"> & { +}; + +/** + * Describes the message flyteidl2.core.TaskExecution. + * Use `create(TaskExecutionSchema)` to create a new message. + */ +export const TaskExecutionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_execution, 2); + +/** + * @generated from enum flyteidl2.core.TaskExecution.Phase + */ +export enum TaskExecution_Phase { + /** + * @generated from enum value: UNDEFINED = 0; + */ + UNDEFINED = 0, + + /** + * @generated from enum value: QUEUED = 1; + */ + QUEUED = 1, + + /** + * @generated from enum value: RUNNING = 2; + */ + RUNNING = 2, + + /** + * @generated from enum value: SUCCEEDED = 3; + */ + SUCCEEDED = 3, + + /** + * @generated from enum value: ABORTED = 4; + */ + ABORTED = 4, + + /** + * @generated from enum value: FAILED = 5; + */ + FAILED = 5, + + /** + * To indicate cases where task is initializing, like: ErrImagePull, ContainerCreating, PodInitializing + * + * @generated from enum value: INITIALIZING = 6; + */ + INITIALIZING = 6, + + /** + * To address cases, where underlying resource is not available: Backoff error, Resource quota exceeded + * + * @generated from enum value: WAITING_FOR_RESOURCES = 7; + */ + WAITING_FOR_RESOURCES = 7, + + /** + * @generated from enum value: RETRYABLE_FAILED = 8; + */ + RETRYABLE_FAILED = 8, +} + +/** + * Describes the enum flyteidl2.core.TaskExecution.Phase. + */ +export const TaskExecution_PhaseSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_execution, 2, 0); + +/** + * Represents the error message from the execution. + * + * @generated from message flyteidl2.core.ExecutionError + */ +export type ExecutionError = Message<"flyteidl2.core.ExecutionError"> & { + /** + * Error code indicates a grouping of a type of error. + * More Info: + * + * @generated from field: string code = 1; + */ + code: string; + + /** + * Detailed description of the error - including stack trace. + * + * @generated from field: string message = 2; + */ + message: string; + + /** + * Full error contents accessible via a URI + * + * @generated from field: string error_uri = 3; + */ + errorUri: string; + + /** + * @generated from field: flyteidl2.core.ExecutionError.ErrorKind kind = 4; + */ + kind: ExecutionError_ErrorKind; + + /** + * Timestamp of the error + * + * @generated from field: google.protobuf.Timestamp timestamp = 5; + */ + timestamp?: Timestamp; + + /** + * Worker that generated the error + * + * @generated from field: string worker = 6; + */ + worker: string; +}; + +/** + * Describes the message flyteidl2.core.ExecutionError. + * Use `create(ExecutionErrorSchema)` to create a new message. + */ +export const ExecutionErrorSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_execution, 3); + +/** + * Error type: System or User + * + * @generated from enum flyteidl2.core.ExecutionError.ErrorKind + */ +export enum ExecutionError_ErrorKind { + /** + * @generated from enum value: UNKNOWN = 0; + */ + UNKNOWN = 0, + + /** + * @generated from enum value: USER = 1; + */ + USER = 1, + + /** + * @generated from enum value: SYSTEM = 2; + */ + SYSTEM = 2, +} + +/** + * Describes the enum flyteidl2.core.ExecutionError.ErrorKind. + */ +export const ExecutionError_ErrorKindSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_execution, 3, 0); + +/** + * Log information for the task that is specific to a log sink + * When our log story is flushed out, we may have more metadata here like log link expiry + * + * @generated from message flyteidl2.core.TaskLog + */ +export type TaskLog = Message<"flyteidl2.core.TaskLog"> & { + /** + * @generated from field: string uri = 1; + */ + uri: string; + + /** + * @generated from field: string name = 2; + */ + name: string; + + /** + * @generated from field: flyteidl2.core.TaskLog.MessageFormat message_format = 3; + */ + messageFormat: TaskLog_MessageFormat; + + /** + * @generated from field: google.protobuf.Duration ttl = 4; + */ + ttl?: Duration; + + /** + * @generated from field: bool ShowWhilePending = 5; + */ + ShowWhilePending: boolean; + + /** + * @generated from field: bool HideOnceFinished = 6; + */ + HideOnceFinished: boolean; + + /** + * @generated from field: flyteidl2.core.TaskLog.LinkType link_type = 7; + */ + linkType: TaskLog_LinkType; + + /** + * @generated from field: bool ready = 8; + */ + ready: boolean; + + /** + * @generated from field: string icon_uri = 9; + */ + iconUri: string; +}; + +/** + * Describes the message flyteidl2.core.TaskLog. + * Use `create(TaskLogSchema)` to create a new message. + */ +export const TaskLogSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_execution, 4); + +/** + * @generated from enum flyteidl2.core.TaskLog.MessageFormat + */ +export enum TaskLog_MessageFormat { + /** + * @generated from enum value: UNKNOWN = 0; + */ + UNKNOWN = 0, + + /** + * @generated from enum value: CSV = 1; + */ + CSV = 1, + + /** + * @generated from enum value: JSON = 2; + */ + JSON = 2, +} + +/** + * Describes the enum flyteidl2.core.TaskLog.MessageFormat. + */ +export const TaskLog_MessageFormatSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_execution, 4, 0); + +/** + * @generated from enum flyteidl2.core.TaskLog.LinkType + */ +export enum TaskLog_LinkType { + /** + * The link for task log. For example, the aws cloudwatch logs, gcp stackdriver logs, etc. + * + * @generated from enum value: EXTERNAL = 0; + */ + EXTERNAL = 0, + + /** + * The link for spark UI, ray dashboard, etc. + * + * @generated from enum value: DASHBOARD = 1; + */ + DASHBOARD = 1, + + /** + * The link for vscode or other IDEs. + * + * @generated from enum value: IDE = 2; + */ + IDE = 2, +} + +/** + * Describes the enum flyteidl2.core.TaskLog.LinkType. + */ +export const TaskLog_LinkTypeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_execution, 4, 1); + +/** + * Contains metadata required to identify logs produces by a set of pods + * + * @generated from message flyteidl2.core.LogContext + */ +export type LogContext = Message<"flyteidl2.core.LogContext"> & { + /** + * @generated from field: repeated flyteidl2.core.PodLogContext pods = 1; + */ + pods: PodLogContext[]; + + /** + * @generated from field: string primary_pod_name = 2; + */ + primaryPodName: string; +}; + +/** + * Describes the message flyteidl2.core.LogContext. + * Use `create(LogContextSchema)` to create a new message. + */ +export const LogContextSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_execution, 5); + +/** + * Contains metadata required to identify logs produces by a single pod + * + * @generated from message flyteidl2.core.PodLogContext + */ +export type PodLogContext = Message<"flyteidl2.core.PodLogContext"> & { + /** + * @generated from field: string namespace = 1; + */ + namespace: string; + + /** + * @generated from field: string pod_name = 2; + */ + podName: string; + + /** + * @generated from field: repeated flyteidl2.core.ContainerContext containers = 3; + */ + containers: ContainerContext[]; + + /** + * @generated from field: string primary_container_name = 4; + */ + primaryContainerName: string; + + /** + * @generated from field: repeated flyteidl2.core.ContainerContext init_containers = 5; + */ + initContainers: ContainerContext[]; +}; + +/** + * Describes the message flyteidl2.core.PodLogContext. + * Use `create(PodLogContextSchema)` to create a new message. + */ +export const PodLogContextSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_execution, 6); + +/** + * Contains metadata required to identify logs produces by a single container + * + * @generated from message flyteidl2.core.ContainerContext + */ +export type ContainerContext = Message<"flyteidl2.core.ContainerContext"> & { + /** + * @generated from field: string container_name = 1; + */ + containerName: string; + + /** + * @generated from field: flyteidl2.core.ContainerContext.ProcessContext process = 2; + */ + process?: ContainerContext_ProcessContext; +}; + +/** + * Describes the message flyteidl2.core.ContainerContext. + * Use `create(ContainerContextSchema)` to create a new message. + */ +export const ContainerContextSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_execution, 7); + +/** + * Contains metadata required to identify logs produces by a single light-weight process that was run inside a container + * + * @generated from message flyteidl2.core.ContainerContext.ProcessContext + */ +export type ContainerContext_ProcessContext = Message<"flyteidl2.core.ContainerContext.ProcessContext"> & { + /** + * @generated from field: google.protobuf.Timestamp container_start_time = 1; + */ + containerStartTime?: Timestamp; + + /** + * @generated from field: google.protobuf.Timestamp container_end_time = 2; + */ + containerEndTime?: Timestamp; +}; + +/** + * Describes the message flyteidl2.core.ContainerContext.ProcessContext. + * Use `create(ContainerContext_ProcessContextSchema)` to create a new message. + */ +export const ContainerContext_ProcessContextSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_execution, 7, 0); + +/** + * Represents customized execution run-time attributes. + * + * @generated from message flyteidl2.core.QualityOfServiceSpec + */ +export type QualityOfServiceSpec = Message<"flyteidl2.core.QualityOfServiceSpec"> & { + /** + * Indicates how much queueing delay an execution can tolerate. + * + * @generated from field: google.protobuf.Duration queueing_budget = 1; + */ + queueingBudget?: Duration; +}; + +/** + * Describes the message flyteidl2.core.QualityOfServiceSpec. + * Use `create(QualityOfServiceSpecSchema)` to create a new message. + */ +export const QualityOfServiceSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_execution, 8); + +/** + * Indicates the priority of an execution. + * + * @generated from message flyteidl2.core.QualityOfService + */ +export type QualityOfService = Message<"flyteidl2.core.QualityOfService"> & { + /** + * @generated from oneof flyteidl2.core.QualityOfService.designation + */ + designation: { + /** + * @generated from field: flyteidl2.core.QualityOfService.Tier tier = 1; + */ + value: QualityOfService_Tier; + case: "tier"; + } | { + /** + * @generated from field: flyteidl2.core.QualityOfServiceSpec spec = 2; + */ + value: QualityOfServiceSpec; + case: "spec"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.core.QualityOfService. + * Use `create(QualityOfServiceSchema)` to create a new message. + */ +export const QualityOfServiceSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_execution, 9); + +/** + * @generated from enum flyteidl2.core.QualityOfService.Tier + */ +export enum QualityOfService_Tier { + /** + * Default: no quality of service specified. + * + * @generated from enum value: UNDEFINED = 0; + */ + UNDEFINED = 0, + + /** + * @generated from enum value: HIGH = 1; + */ + HIGH = 1, + + /** + * @generated from enum value: MEDIUM = 2; + */ + MEDIUM = 2, + + /** + * @generated from enum value: LOW = 3; + */ + LOW = 3, +} + +/** + * Describes the enum flyteidl2.core.QualityOfService.Tier. + */ +export const QualityOfService_TierSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_execution, 9, 0); + diff --git a/gen/ts/flyteidl2/core/identifier_pb.ts b/gen/ts/flyteidl2/core/identifier_pb.ts new file mode 100644 index 0000000000..b0751c957e --- /dev/null +++ b/gen/ts/flyteidl2/core/identifier_pb.ts @@ -0,0 +1,237 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/core/identifier.proto (package flyteidl2.core, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/core/identifier.proto. + */ +export const file_flyteidl2_core_identifier: GenFile = /*@__PURE__*/ + fileDesc("Ch9mbHl0ZWlkbDIvY29yZS9pZGVudGlmaWVyLnByb3RvEg5mbHl0ZWlkbDIuY29yZSKOAQoKSWRlbnRpZmllchIzCg1yZXNvdXJjZV90eXBlGAEgASgOMhwuZmx5dGVpZGwyLmNvcmUuUmVzb3VyY2VUeXBlEg8KB3Byb2plY3QYAiABKAkSDgoGZG9tYWluGAMgASgJEgwKBG5hbWUYBCABKAkSDwoHdmVyc2lvbhgFIAEoCRILCgNvcmcYBiABKAkiWQobV29ya2Zsb3dFeGVjdXRpb25JZGVudGlmaWVyEg8KB3Byb2plY3QYASABKAkSDgoGZG9tYWluGAIgASgJEgwKBG5hbWUYBCABKAkSCwoDb3JnGAUgASgJIm0KF05vZGVFeGVjdXRpb25JZGVudGlmaWVyEg8KB25vZGVfaWQYASABKAkSQQoMZXhlY3V0aW9uX2lkGAIgASgLMisuZmx5dGVpZGwyLmNvcmUuV29ya2Zsb3dFeGVjdXRpb25JZGVudGlmaWVyIqEBChdUYXNrRXhlY3V0aW9uSWRlbnRpZmllchIrCgd0YXNrX2lkGAEgASgLMhouZmx5dGVpZGwyLmNvcmUuSWRlbnRpZmllchJCChFub2RlX2V4ZWN1dGlvbl9pZBgCIAEoCzInLmZseXRlaWRsMi5jb3JlLk5vZGVFeGVjdXRpb25JZGVudGlmaWVyEhUKDXJldHJ5X2F0dGVtcHQYAyABKA0iaAoQU2lnbmFsSWRlbnRpZmllchIRCglzaWduYWxfaWQYASABKAkSQQoMZXhlY3V0aW9uX2lkGAIgASgLMisuZmx5dGVpZGwyLmNvcmUuV29ya2Zsb3dFeGVjdXRpb25JZGVudGlmaWVyKlUKDFJlc291cmNlVHlwZRIPCgtVTlNQRUNJRklFRBAAEggKBFRBU0sQARIMCghXT1JLRkxPVxACEg8KC0xBVU5DSF9QTEFOEAMSCwoHREFUQVNFVBAEQrQBChJjb20uZmx5dGVpZGwyLmNvcmVCD0lkZW50aWZpZXJQcm90b0gCUAFaMmdpdGh1Yi5jb20vZmx5dGVvcmcvZmx5dGUvdjIvZ2VuL2dvL2ZseXRlaWRsMi9jb3JlogIDRkNYqgIORmx5dGVpZGwyLkNvcmXKAg5GbHl0ZWlkbDJcQ29yZeICGkZseXRlaWRsMlxDb3JlXEdQQk1ldGFkYXRh6gIPRmx5dGVpZGwyOjpDb3JlYgZwcm90bzM"); + +/** + * Encapsulation of fields that uniquely identifies a Flyte resource. + * + * @generated from message flyteidl2.core.Identifier + */ +export type Identifier = Message<"flyteidl2.core.Identifier"> & { + /** + * Identifies the specific type of resource that this identifier corresponds to. + * + * @generated from field: flyteidl2.core.ResourceType resource_type = 1; + */ + resourceType: ResourceType; + + /** + * Name of the project the resource belongs to. + * + * @generated from field: string project = 2; + */ + project: string; + + /** + * Name of the domain the resource belongs to. + * A domain can be considered as a subset within a specific project. + * + * @generated from field: string domain = 3; + */ + domain: string; + + /** + * User provided value for the resource. + * + * @generated from field: string name = 4; + */ + name: string; + + /** + * Specific version of the resource. + * + * @generated from field: string version = 5; + */ + version: string; + + /** + * Optional, org key applied to the resource. + * + * @generated from field: string org = 6; + */ + org: string; +}; + +/** + * Describes the message flyteidl2.core.Identifier. + * Use `create(IdentifierSchema)` to create a new message. + */ +export const IdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_identifier, 0); + +/** + * Encapsulation of fields that uniquely identifies a Flyte workflow execution + * + * @generated from message flyteidl2.core.WorkflowExecutionIdentifier + */ +export type WorkflowExecutionIdentifier = Message<"flyteidl2.core.WorkflowExecutionIdentifier"> & { + /** + * Name of the project the resource belongs to. + * + * @generated from field: string project = 1; + */ + project: string; + + /** + * Name of the domain the resource belongs to. + * A domain can be considered as a subset within a specific project. + * + * @generated from field: string domain = 2; + */ + domain: string; + + /** + * User or system provided value for the resource. + * + * @generated from field: string name = 4; + */ + name: string; + + /** + * Optional, org key applied to the resource. + * + * @generated from field: string org = 5; + */ + org: string; +}; + +/** + * Describes the message flyteidl2.core.WorkflowExecutionIdentifier. + * Use `create(WorkflowExecutionIdentifierSchema)` to create a new message. + */ +export const WorkflowExecutionIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_identifier, 1); + +/** + * Encapsulation of fields that identify a Flyte node execution entity. + * + * @generated from message flyteidl2.core.NodeExecutionIdentifier + */ +export type NodeExecutionIdentifier = Message<"flyteidl2.core.NodeExecutionIdentifier"> & { + /** + * @generated from field: string node_id = 1; + */ + nodeId: string; + + /** + * @generated from field: flyteidl2.core.WorkflowExecutionIdentifier execution_id = 2; + */ + executionId?: WorkflowExecutionIdentifier; +}; + +/** + * Describes the message flyteidl2.core.NodeExecutionIdentifier. + * Use `create(NodeExecutionIdentifierSchema)` to create a new message. + */ +export const NodeExecutionIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_identifier, 2); + +/** + * Encapsulation of fields that identify a Flyte task execution entity. + * + * @generated from message flyteidl2.core.TaskExecutionIdentifier + */ +export type TaskExecutionIdentifier = Message<"flyteidl2.core.TaskExecutionIdentifier"> & { + /** + * @generated from field: flyteidl2.core.Identifier task_id = 1; + */ + taskId?: Identifier; + + /** + * @generated from field: flyteidl2.core.NodeExecutionIdentifier node_execution_id = 2; + */ + nodeExecutionId?: NodeExecutionIdentifier; + + /** + * @generated from field: uint32 retry_attempt = 3; + */ + retryAttempt: number; +}; + +/** + * Describes the message flyteidl2.core.TaskExecutionIdentifier. + * Use `create(TaskExecutionIdentifierSchema)` to create a new message. + */ +export const TaskExecutionIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_identifier, 3); + +/** + * Encapsulation of fields the uniquely identify a signal. + * + * @generated from message flyteidl2.core.SignalIdentifier + */ +export type SignalIdentifier = Message<"flyteidl2.core.SignalIdentifier"> & { + /** + * Unique identifier for a signal. + * + * @generated from field: string signal_id = 1; + */ + signalId: string; + + /** + * Identifies the Flyte workflow execution this signal belongs to. + * + * @generated from field: flyteidl2.core.WorkflowExecutionIdentifier execution_id = 2; + */ + executionId?: WorkflowExecutionIdentifier; +}; + +/** + * Describes the message flyteidl2.core.SignalIdentifier. + * Use `create(SignalIdentifierSchema)` to create a new message. + */ +export const SignalIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_identifier, 4); + +/** + * Indicates a resource type within Flyte. + * + * @generated from enum flyteidl2.core.ResourceType + */ +export enum ResourceType { + /** + * @generated from enum value: UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: TASK = 1; + */ + TASK = 1, + + /** + * @generated from enum value: WORKFLOW = 2; + */ + WORKFLOW = 2, + + /** + * @generated from enum value: LAUNCH_PLAN = 3; + */ + LAUNCH_PLAN = 3, + + /** + * A dataset represents an entity modeled in Flyte DataCatalog. A Dataset is also a versioned entity and can be a compilation of multiple individual objects. + * Eventually all Catalog objects should be modeled similar to Flyte Objects. The Dataset entities makes it possible for the UI and CLI to act on the objects + * in a similar manner to other Flyte objects + * + * @generated from enum value: DATASET = 4; + */ + DATASET = 4, +} + +/** + * Describes the enum flyteidl2.core.ResourceType. + */ +export const ResourceTypeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_identifier, 0); + diff --git a/gen/ts/flyteidl2/core/interface_pb.ts b/gen/ts/flyteidl2/core/interface_pb.ts new file mode 100644 index 0000000000..47720b0993 --- /dev/null +++ b/gen/ts/flyteidl2/core/interface_pb.ts @@ -0,0 +1,187 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/core/interface.proto (package flyteidl2.core, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { ArtifactID, ArtifactQuery, ArtifactTag } from "./artifact_id_pb.ts"; +import { file_flyteidl2_core_artifact_id } from "./artifact_id_pb.ts"; +import type { Literal } from "./literals_pb.ts"; +import { file_flyteidl2_core_literals } from "./literals_pb.ts"; +import type { LiteralType } from "./types_pb.ts"; +import { file_flyteidl2_core_types } from "./types_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/core/interface.proto. + */ +export const file_flyteidl2_core_interface: GenFile = /*@__PURE__*/ + fileDesc("Ch5mbHl0ZWlkbDIvY29yZS9pbnRlcmZhY2UucHJvdG8SDmZseXRlaWRsMi5jb3JlIrYBCghWYXJpYWJsZRIpCgR0eXBlGAEgASgLMhsuZmx5dGVpZGwyLmNvcmUuTGl0ZXJhbFR5cGUSEwoLZGVzY3JpcHRpb24YAiABKAkSNwoTYXJ0aWZhY3RfcGFydGlhbF9pZBgDIAEoCzIaLmZseXRlaWRsMi5jb3JlLkFydGlmYWN0SUQSMQoMYXJ0aWZhY3RfdGFnGAQgASgLMhsuZmx5dGVpZGwyLmNvcmUuQXJ0aWZhY3RUYWcimAEKC1ZhcmlhYmxlTWFwEj0KCXZhcmlhYmxlcxgBIAMoCzIqLmZseXRlaWRsMi5jb3JlLlZhcmlhYmxlTWFwLlZhcmlhYmxlc0VudHJ5GkoKDlZhcmlhYmxlc0VudHJ5EgsKA2tleRgBIAEoCRInCgV2YWx1ZRgCIAEoCzIYLmZseXRlaWRsMi5jb3JlLlZhcmlhYmxlOgI4ASJrCg5UeXBlZEludGVyZmFjZRIrCgZpbnB1dHMYASABKAsyGy5mbHl0ZWlkbDIuY29yZS5WYXJpYWJsZU1hcBIsCgdvdXRwdXRzGAIgASgLMhsuZmx5dGVpZGwyLmNvcmUuVmFyaWFibGVNYXAi6gEKCVBhcmFtZXRlchIlCgN2YXIYASABKAsyGC5mbHl0ZWlkbDIuY29yZS5WYXJpYWJsZRIqCgdkZWZhdWx0GAIgASgLMhcuZmx5dGVpZGwyLmNvcmUuTGl0ZXJhbEgAEhIKCHJlcXVpcmVkGAMgASgISAASNwoOYXJ0aWZhY3RfcXVlcnkYBCABKAsyHS5mbHl0ZWlkbDIuY29yZS5BcnRpZmFjdFF1ZXJ5SAASMQoLYXJ0aWZhY3RfaWQYBSABKAsyGi5mbHl0ZWlkbDIuY29yZS5BcnRpZmFjdElESABCCgoIYmVoYXZpb3IingEKDFBhcmFtZXRlck1hcBJACgpwYXJhbWV0ZXJzGAEgAygLMiwuZmx5dGVpZGwyLmNvcmUuUGFyYW1ldGVyTWFwLlBhcmFtZXRlcnNFbnRyeRpMCg9QYXJhbWV0ZXJzRW50cnkSCwoDa2V5GAEgASgJEigKBXZhbHVlGAIgASgLMhkuZmx5dGVpZGwyLmNvcmUuUGFyYW1ldGVyOgI4AUKzAQoSY29tLmZseXRlaWRsMi5jb3JlQg5JbnRlcmZhY2VQcm90b0gCUAFaMmdpdGh1Yi5jb20vZmx5dGVvcmcvZmx5dGUvdjIvZ2VuL2dvL2ZseXRlaWRsMi9jb3JlogIDRkNYqgIORmx5dGVpZGwyLkNvcmXKAg5GbHl0ZWlkbDJcQ29yZeICGkZseXRlaWRsMlxDb3JlXEdQQk1ldGFkYXRh6gIPRmx5dGVpZGwyOjpDb3JlYgZwcm90bzM", [file_flyteidl2_core_artifact_id, file_flyteidl2_core_literals, file_flyteidl2_core_types]); + +/** + * Defines a strongly typed variable. + * + * @generated from message flyteidl2.core.Variable + */ +export type Variable = Message<"flyteidl2.core.Variable"> & { + /** + * Variable literal type. + * + * @generated from field: flyteidl2.core.LiteralType type = 1; + */ + type?: LiteralType; + + /** + * +optional string describing input variable + * + * @generated from field: string description = 2; + */ + description: string; + + /** + * +optional This object allows the user to specify how Artifacts are created. + * name, tag, partitions can be specified. The other fields (version and project/domain) are ignored. + * + * @generated from field: flyteidl2.core.ArtifactID artifact_partial_id = 3; + */ + artifactPartialId?: ArtifactID; + + /** + * @generated from field: flyteidl2.core.ArtifactTag artifact_tag = 4; + */ + artifactTag?: ArtifactTag; +}; + +/** + * Describes the message flyteidl2.core.Variable. + * Use `create(VariableSchema)` to create a new message. + */ +export const VariableSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_interface, 0); + +/** + * A map of Variables + * + * @generated from message flyteidl2.core.VariableMap + */ +export type VariableMap = Message<"flyteidl2.core.VariableMap"> & { + /** + * Defines a map of variable names to variables. + * + * @generated from field: map variables = 1; + */ + variables: { [key: string]: Variable }; +}; + +/** + * Describes the message flyteidl2.core.VariableMap. + * Use `create(VariableMapSchema)` to create a new message. + */ +export const VariableMapSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_interface, 1); + +/** + * Defines strongly typed inputs and outputs. + * + * @generated from message flyteidl2.core.TypedInterface + */ +export type TypedInterface = Message<"flyteidl2.core.TypedInterface"> & { + /** + * @generated from field: flyteidl2.core.VariableMap inputs = 1; + */ + inputs?: VariableMap; + + /** + * @generated from field: flyteidl2.core.VariableMap outputs = 2; + */ + outputs?: VariableMap; +}; + +/** + * Describes the message flyteidl2.core.TypedInterface. + * Use `create(TypedInterfaceSchema)` to create a new message. + */ +export const TypedInterfaceSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_interface, 2); + +/** + * A parameter is used as input to a launch plan and has + * the special ability to have a default value or mark itself as required. + * + * @generated from message flyteidl2.core.Parameter + */ +export type Parameter = Message<"flyteidl2.core.Parameter"> & { + /** + * +required Variable. Defines the type of the variable backing this parameter. + * + * @generated from field: flyteidl2.core.Variable var = 1; + */ + var?: Variable; + + /** + * +optional + * + * @generated from oneof flyteidl2.core.Parameter.behavior + */ + behavior: { + /** + * Defines a default value that has to match the variable type defined. + * + * @generated from field: flyteidl2.core.Literal default = 2; + */ + value: Literal; + case: "default"; + } | { + /** + * +optional, is this value required to be filled. + * + * @generated from field: bool required = 3; + */ + value: boolean; + case: "required"; + } | { + /** + * This is an execution time search basically that should result in exactly one Artifact with a Type that + * matches the type of the variable. + * + * @generated from field: flyteidl2.core.ArtifactQuery artifact_query = 4; + */ + value: ArtifactQuery; + case: "artifactQuery"; + } | { + /** + * @generated from field: flyteidl2.core.ArtifactID artifact_id = 5; + */ + value: ArtifactID; + case: "artifactId"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.core.Parameter. + * Use `create(ParameterSchema)` to create a new message. + */ +export const ParameterSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_interface, 3); + +/** + * A map of Parameters. + * + * @generated from message flyteidl2.core.ParameterMap + */ +export type ParameterMap = Message<"flyteidl2.core.ParameterMap"> & { + /** + * Defines a map of parameter names to parameters. + * + * @generated from field: map parameters = 1; + */ + parameters: { [key: string]: Parameter }; +}; + +/** + * Describes the message flyteidl2.core.ParameterMap. + * Use `create(ParameterMapSchema)` to create a new message. + */ +export const ParameterMapSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_interface, 4); + diff --git a/gen/ts/flyteidl2/core/literals_pb.ts b/gen/ts/flyteidl2/core/literals_pb.ts new file mode 100644 index 0000000000..9b70c6fd48 --- /dev/null +++ b/gen/ts/flyteidl2/core/literals_pb.ts @@ -0,0 +1,673 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/core/literals.proto (package flyteidl2.core, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { BlobType, Error, LiteralType, OutputReference, SchemaType, StructuredDatasetType } from "./types_pb.ts"; +import { file_flyteidl2_core_types } from "./types_pb.ts"; +import type { Duration, Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_duration, file_google_protobuf_struct, file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import type { JsonObject, Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/core/literals.proto. + */ +export const file_flyteidl2_core_literals: GenFile = /*@__PURE__*/ + fileDesc("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", [file_flyteidl2_core_types, file_google_protobuf_duration, file_google_protobuf_struct, file_google_protobuf_timestamp]); + +/** + * Primitive Types + * + * @generated from message flyteidl2.core.Primitive + */ +export type Primitive = Message<"flyteidl2.core.Primitive"> & { + /** + * Defines one of simple primitive types. These types will get translated into different programming languages as + * described in https://developers.google.com/protocol-buffers/docs/proto#scalar. + * + * @generated from oneof flyteidl2.core.Primitive.value + */ + value: { + /** + * @generated from field: int64 integer = 1; + */ + value: bigint; + case: "integer"; + } | { + /** + * @generated from field: double float_value = 2; + */ + value: number; + case: "floatValue"; + } | { + /** + * @generated from field: string string_value = 3; + */ + value: string; + case: "stringValue"; + } | { + /** + * @generated from field: bool boolean = 4; + */ + value: boolean; + case: "boolean"; + } | { + /** + * @generated from field: google.protobuf.Timestamp datetime = 5; + */ + value: Timestamp; + case: "datetime"; + } | { + /** + * @generated from field: google.protobuf.Duration duration = 6; + */ + value: Duration; + case: "duration"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.core.Primitive. + * Use `create(PrimitiveSchema)` to create a new message. + */ +export const PrimitiveSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 0); + +/** + * Used to denote a nil/null/None assignment to a scalar value. The underlying LiteralType for Void is intentionally + * undefined since it can be assigned to a scalar of any LiteralType. + * + * @generated from message flyteidl2.core.Void + */ +export type Void = Message<"flyteidl2.core.Void"> & { +}; + +/** + * Describes the message flyteidl2.core.Void. + * Use `create(VoidSchema)` to create a new message. + */ +export const VoidSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 1); + +/** + * Refers to an offloaded set of files. It encapsulates the type of the store and a unique uri for where the data is. + * There are no restrictions on how the uri is formatted since it will depend on how to interact with the store. + * + * @generated from message flyteidl2.core.Blob + */ +export type Blob = Message<"flyteidl2.core.Blob"> & { + /** + * @generated from field: flyteidl2.core.BlobMetadata metadata = 1; + */ + metadata?: BlobMetadata; + + /** + * @generated from field: string uri = 3; + */ + uri: string; +}; + +/** + * Describes the message flyteidl2.core.Blob. + * Use `create(BlobSchema)` to create a new message. + */ +export const BlobSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 2); + +/** + * @generated from message flyteidl2.core.BlobMetadata + */ +export type BlobMetadata = Message<"flyteidl2.core.BlobMetadata"> & { + /** + * @generated from field: flyteidl2.core.BlobType type = 1; + */ + type?: BlobType; +}; + +/** + * Describes the message flyteidl2.core.BlobMetadata. + * Use `create(BlobMetadataSchema)` to create a new message. + */ +export const BlobMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 3); + +/** + * A simple byte array with a tag to help different parts of the system communicate about what is in the byte array. + * It's strongly advisable that consumers of this type define a unique tag and validate the tag before parsing the data. + * + * @generated from message flyteidl2.core.Binary + */ +export type Binary = Message<"flyteidl2.core.Binary"> & { + /** + * Serialized data (MessagePack) for supported types like Dataclass, Pydantic BaseModel, and untyped dict. + * + * @generated from field: bytes value = 1; + */ + value: Uint8Array; + + /** + * The serialization format identifier (e.g., MessagePack). Consumers must define unique tags and validate them before deserialization. + * + * @generated from field: string tag = 2; + */ + tag: string; +}; + +/** + * Describes the message flyteidl2.core.Binary. + * Use `create(BinarySchema)` to create a new message. + */ +export const BinarySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 4); + +/** + * A strongly typed schema that defines the interface of data retrieved from the underlying storage medium. + * + * @generated from message flyteidl2.core.Schema + */ +export type Schema = Message<"flyteidl2.core.Schema"> & { + /** + * @generated from field: string uri = 1; + */ + uri: string; + + /** + * @generated from field: flyteidl2.core.SchemaType type = 3; + */ + type?: SchemaType; +}; + +/** + * Describes the message flyteidl2.core.Schema. + * Use `create(SchemaSchema)` to create a new message. + */ +export const SchemaSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 5); + +/** + * The runtime representation of a tagged union value. See `UnionType` for more details. + * + * @generated from message flyteidl2.core.Union + */ +export type Union = Message<"flyteidl2.core.Union"> & { + /** + * @generated from field: flyteidl2.core.Literal value = 1; + */ + value?: Literal; + + /** + * @generated from field: flyteidl2.core.LiteralType type = 2; + */ + type?: LiteralType; +}; + +/** + * Describes the message flyteidl2.core.Union. + * Use `create(UnionSchema)` to create a new message. + */ +export const UnionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 6); + +/** + * @generated from message flyteidl2.core.StructuredDatasetMetadata + */ +export type StructuredDatasetMetadata = Message<"flyteidl2.core.StructuredDatasetMetadata"> & { + /** + * Bundle the type information along with the literal. + * This is here because StructuredDatasets can often be more defined at run time than at compile time. + * That is, at compile time you might only declare a task to return a pandas dataframe or a StructuredDataset, + * without any column information, but at run time, you might have that column information. + * flytekit python will copy this type information into the literal, from the type information, if not provided by + * the various plugins (encoders). + * Since this field is run time generated, it's not used for any type checking. + * + * @generated from field: flyteidl2.core.StructuredDatasetType structured_dataset_type = 1; + */ + structuredDatasetType?: StructuredDatasetType; +}; + +/** + * Describes the message flyteidl2.core.StructuredDatasetMetadata. + * Use `create(StructuredDatasetMetadataSchema)` to create a new message. + */ +export const StructuredDatasetMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 7); + +/** + * @generated from message flyteidl2.core.StructuredDataset + */ +export type StructuredDataset = Message<"flyteidl2.core.StructuredDataset"> & { + /** + * String location uniquely identifying where the data is. + * Should start with the storage location (e.g. s3://, gs://, bq://, etc.) + * + * @generated from field: string uri = 1; + */ + uri: string; + + /** + * @generated from field: flyteidl2.core.StructuredDatasetMetadata metadata = 2; + */ + metadata?: StructuredDatasetMetadata; +}; + +/** + * Describes the message flyteidl2.core.StructuredDataset. + * Use `create(StructuredDatasetSchema)` to create a new message. + */ +export const StructuredDatasetSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 8); + +/** + * @generated from message flyteidl2.core.Scalar + */ +export type Scalar = Message<"flyteidl2.core.Scalar"> & { + /** + * @generated from oneof flyteidl2.core.Scalar.value + */ + value: { + /** + * @generated from field: flyteidl2.core.Primitive primitive = 1; + */ + value: Primitive; + case: "primitive"; + } | { + /** + * @generated from field: flyteidl2.core.Blob blob = 2; + */ + value: Blob; + case: "blob"; + } | { + /** + * @generated from field: flyteidl2.core.Binary binary = 3; + */ + value: Binary; + case: "binary"; + } | { + /** + * @generated from field: flyteidl2.core.Schema schema = 4; + */ + value: Schema; + case: "schema"; + } | { + /** + * @generated from field: flyteidl2.core.Void none_type = 5; + */ + value: Void; + case: "noneType"; + } | { + /** + * @generated from field: flyteidl2.core.Error error = 6; + */ + value: Error; + case: "error"; + } | { + /** + * @generated from field: google.protobuf.Struct generic = 7; + */ + value: JsonObject; + case: "generic"; + } | { + /** + * @generated from field: flyteidl2.core.StructuredDataset structured_dataset = 8; + */ + value: StructuredDataset; + case: "structuredDataset"; + } | { + /** + * @generated from field: flyteidl2.core.Union union = 9; + */ + value: Union; + case: "union"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.core.Scalar. + * Use `create(ScalarSchema)` to create a new message. + */ +export const ScalarSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 9); + +/** + * A simple value. This supports any level of nesting (e.g. array of array of array of Blobs) as well as simple primitives. + * + * @generated from message flyteidl2.core.Literal + */ +export type Literal = Message<"flyteidl2.core.Literal"> & { + /** + * @generated from oneof flyteidl2.core.Literal.value + */ + value: { + /** + * A simple value. + * + * @generated from field: flyteidl2.core.Scalar scalar = 1; + */ + value: Scalar; + case: "scalar"; + } | { + /** + * A collection of literals to allow nesting. + * + * @generated from field: flyteidl2.core.LiteralCollection collection = 2; + */ + value: LiteralCollection; + case: "collection"; + } | { + /** + * A map of strings to literals. + * + * @generated from field: flyteidl2.core.LiteralMap map = 3; + */ + value: LiteralMap; + case: "map"; + } | { + /** + * Offloaded literal metadata + * When you deserialize the offloaded metadata, it would be of Literal and its type would be defined by LiteralType stored in offloaded_metadata. + * + * @generated from field: flyteidl2.core.LiteralOffloadedMetadata offloaded_metadata = 8; + */ + value: LiteralOffloadedMetadata; + case: "offloadedMetadata"; + } | { case: undefined; value?: undefined }; + + /** + * A hash representing this literal. + * This is used for caching purposes. For more details refer to RFC 1893 + * (https://github.com/flyteorg/flyte/blob/master/rfc/system/1893-caching-of-offloaded-objects.md) + * + * @generated from field: string hash = 4; + */ + hash: string; + + /** + * Additional metadata for literals. + * + * @generated from field: map metadata = 5; + */ + metadata: { [key: string]: string }; +}; + +/** + * Describes the message flyteidl2.core.Literal. + * Use `create(LiteralSchema)` to create a new message. + */ +export const LiteralSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 10); + +/** + * A message that contains the metadata of the offloaded data. + * + * @generated from message flyteidl2.core.LiteralOffloadedMetadata + */ +export type LiteralOffloadedMetadata = Message<"flyteidl2.core.LiteralOffloadedMetadata"> & { + /** + * The location of the offloaded core.Literal. + * + * @generated from field: string uri = 1; + */ + uri: string; + + /** + * The size of the offloaded data. + * + * @generated from field: uint64 size_bytes = 2; + */ + sizeBytes: bigint; + + /** + * The inferred literal type of the offloaded data. + * + * @generated from field: flyteidl2.core.LiteralType inferred_type = 3; + */ + inferredType?: LiteralType; +}; + +/** + * Describes the message flyteidl2.core.LiteralOffloadedMetadata. + * Use `create(LiteralOffloadedMetadataSchema)` to create a new message. + */ +export const LiteralOffloadedMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 11); + +/** + * A collection of literals. This is a workaround since oneofs in proto messages cannot contain a repeated field. + * + * @generated from message flyteidl2.core.LiteralCollection + */ +export type LiteralCollection = Message<"flyteidl2.core.LiteralCollection"> & { + /** + * @generated from field: repeated flyteidl2.core.Literal literals = 1; + */ + literals: Literal[]; +}; + +/** + * Describes the message flyteidl2.core.LiteralCollection. + * Use `create(LiteralCollectionSchema)` to create a new message. + */ +export const LiteralCollectionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 12); + +/** + * A map of literals. This is a workaround since oneofs in proto messages cannot contain a repeated field. + * + * @generated from message flyteidl2.core.LiteralMap + */ +export type LiteralMap = Message<"flyteidl2.core.LiteralMap"> & { + /** + * @generated from field: map literals = 1; + */ + literals: { [key: string]: Literal }; +}; + +/** + * Describes the message flyteidl2.core.LiteralMap. + * Use `create(LiteralMapSchema)` to create a new message. + */ +export const LiteralMapSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 13); + +/** + * A collection of BindingData items. + * + * @generated from message flyteidl2.core.BindingDataCollection + */ +export type BindingDataCollection = Message<"flyteidl2.core.BindingDataCollection"> & { + /** + * @generated from field: repeated flyteidl2.core.BindingData bindings = 1; + */ + bindings: BindingData[]; +}; + +/** + * Describes the message flyteidl2.core.BindingDataCollection. + * Use `create(BindingDataCollectionSchema)` to create a new message. + */ +export const BindingDataCollectionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 14); + +/** + * A map of BindingData items. + * + * @generated from message flyteidl2.core.BindingDataMap + */ +export type BindingDataMap = Message<"flyteidl2.core.BindingDataMap"> & { + /** + * @generated from field: map bindings = 1; + */ + bindings: { [key: string]: BindingData }; +}; + +/** + * Describes the message flyteidl2.core.BindingDataMap. + * Use `create(BindingDataMapSchema)` to create a new message. + */ +export const BindingDataMapSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 15); + +/** + * @generated from message flyteidl2.core.UnionInfo + */ +export type UnionInfo = Message<"flyteidl2.core.UnionInfo"> & { + /** + * @generated from field: flyteidl2.core.LiteralType targetType = 1; + */ + targetType?: LiteralType; +}; + +/** + * Describes the message flyteidl2.core.UnionInfo. + * Use `create(UnionInfoSchema)` to create a new message. + */ +export const UnionInfoSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 16); + +/** + * Specifies either a simple value or a reference to another output. + * + * @generated from message flyteidl2.core.BindingData + */ +export type BindingData = Message<"flyteidl2.core.BindingData"> & { + /** + * @generated from oneof flyteidl2.core.BindingData.value + */ + value: { + /** + * A simple scalar value. + * + * @generated from field: flyteidl2.core.Scalar scalar = 1; + */ + value: Scalar; + case: "scalar"; + } | { + /** + * A collection of binding data. This allows nesting of binding data to any number + * of levels. + * + * @generated from field: flyteidl2.core.BindingDataCollection collection = 2; + */ + value: BindingDataCollection; + case: "collection"; + } | { + /** + * References an output promised by another node. + * + * @generated from field: flyteidl2.core.OutputReference promise = 3; + */ + value: OutputReference; + case: "promise"; + } | { + /** + * A map of bindings. The key is always a string. + * + * @generated from field: flyteidl2.core.BindingDataMap map = 4; + */ + value: BindingDataMap; + case: "map"; + } | { + /** + * Offloaded literal metadata + * When you deserialize the offloaded metadata, it would be of Literal and its type would be defined by LiteralType stored in offloaded_metadata. + * Used for nodes that don't have promises from upstream nodes such as ArrayNode subNodes. + * + * @generated from field: flyteidl2.core.LiteralOffloadedMetadata offloaded_metadata = 6; + */ + value: LiteralOffloadedMetadata; + case: "offloadedMetadata"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from field: flyteidl2.core.UnionInfo union = 5; + */ + union?: UnionInfo; +}; + +/** + * Describes the message flyteidl2.core.BindingData. + * Use `create(BindingDataSchema)` to create a new message. + */ +export const BindingDataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 17); + +/** + * An input/output binding of a variable to either static value or a node output. + * + * @generated from message flyteidl2.core.Binding + */ +export type Binding = Message<"flyteidl2.core.Binding"> & { + /** + * Variable name must match an input/output variable of the node. + * + * @generated from field: string var = 1; + */ + var: string; + + /** + * Data to use to bind this variable. + * + * @generated from field: flyteidl2.core.BindingData binding = 2; + */ + binding?: BindingData; +}; + +/** + * Describes the message flyteidl2.core.Binding. + * Use `create(BindingSchema)` to create a new message. + */ +export const BindingSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 18); + +/** + * A generic key value pair. + * + * @generated from message flyteidl2.core.KeyValuePair + */ +export type KeyValuePair = Message<"flyteidl2.core.KeyValuePair"> & { + /** + * required. + * + * @generated from field: string key = 1; + */ + key: string; + + /** + * +optional. + * + * @generated from field: string value = 2; + */ + value: string; +}; + +/** + * Describes the message flyteidl2.core.KeyValuePair. + * Use `create(KeyValuePairSchema)` to create a new message. + */ +export const KeyValuePairSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 19); + +/** + * Retry strategy associated with an executable unit. + * + * @generated from message flyteidl2.core.RetryStrategy + */ +export type RetryStrategy = Message<"flyteidl2.core.RetryStrategy"> & { + /** + * Number of retries. Retries will be consumed when the job fails with a recoverable error. + * The number of retries must be less than or equals to 10. + * + * @generated from field: uint32 retries = 5; + */ + retries: number; +}; + +/** + * Describes the message flyteidl2.core.RetryStrategy. + * Use `create(RetryStrategySchema)` to create a new message. + */ +export const RetryStrategySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_literals, 20); + diff --git a/gen/ts/flyteidl2/core/metrics_pb.ts b/gen/ts/flyteidl2/core/metrics_pb.ts new file mode 100644 index 0000000000..d8a39f0c34 --- /dev/null +++ b/gen/ts/flyteidl2/core/metrics_pb.ts @@ -0,0 +1,47 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/core/metrics.proto (package flyteidl2.core, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_google_protobuf_struct } from "@bufbuild/protobuf/wkt"; +import type { JsonObject, Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/core/metrics.proto. + */ +export const file_flyteidl2_core_metrics: GenFile = /*@__PURE__*/ + fileDesc("ChxmbHl0ZWlkbDIvY29yZS9tZXRyaWNzLnByb3RvEg5mbHl0ZWlkbDIuY29yZSJOChVFeGVjdXRpb25NZXRyaWNSZXN1bHQSDgoGbWV0cmljGAEgASgJEiUKBGRhdGEYAiABKAsyFy5nb29nbGUucHJvdG9idWYuU3RydWN0QrEBChJjb20uZmx5dGVpZGwyLmNvcmVCDE1ldHJpY3NQcm90b0gCUAFaMmdpdGh1Yi5jb20vZmx5dGVvcmcvZmx5dGUvdjIvZ2VuL2dvL2ZseXRlaWRsMi9jb3JlogIDRkNYqgIORmx5dGVpZGwyLkNvcmXKAg5GbHl0ZWlkbDJcQ29yZeICGkZseXRlaWRsMlxDb3JlXEdQQk1ldGFkYXRh6gIPRmx5dGVpZGwyOjpDb3JlYgZwcm90bzM", [file_google_protobuf_struct]); + +/** + * ExecutionMetrics is a collection of metrics that are collected during the execution of a Flyte task. + * + * @generated from message flyteidl2.core.ExecutionMetricResult + */ +export type ExecutionMetricResult = Message<"flyteidl2.core.ExecutionMetricResult"> & { + /** + * The metric this data represents. e.g. EXECUTION_METRIC_USED_CPU_AVG or EXECUTION_METRIC_USED_MEMORY_BYTES_AVG. + * + * @generated from field: string metric = 1; + */ + metric: string; + + /** + * The result data in prometheus range query result format + * https://prometheus.io/docs/prometheus/latest/querying/api/#expression-query-result-formats. + * This may include multiple time series, differentiated by their metric labels. + * Start time is greater of (execution attempt start, 48h ago) + * End time is lesser of (execution attempt end, now) + * + * @generated from field: google.protobuf.Struct data = 2; + */ + data?: JsonObject; +}; + +/** + * Describes the message flyteidl2.core.ExecutionMetricResult. + * Use `create(ExecutionMetricResultSchema)` to create a new message. + */ +export const ExecutionMetricResultSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_metrics, 0); + diff --git a/gen/ts/flyteidl2/core/security_pb.ts b/gen/ts/flyteidl2/core/security_pb.ts new file mode 100644 index 0000000000..2fb5a76241 --- /dev/null +++ b/gen/ts/flyteidl2/core/security_pb.ts @@ -0,0 +1,346 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/core/security.proto (package flyteidl2.core, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/core/security.proto. + */ +export const file_flyteidl2_core_security: GenFile = /*@__PURE__*/ + fileDesc("Ch1mbHl0ZWlkbDIvY29yZS9zZWN1cml0eS5wcm90bxIOZmx5dGVpZGwyLmNvcmUitgEKBlNlY3JldBINCgVncm91cBgBIAEoCRIVCg1ncm91cF92ZXJzaW9uGAIgASgJEgsKA2tleRgDIAEoCRI7ChFtb3VudF9yZXF1aXJlbWVudBgEIAEoDjIgLmZseXRlaWRsMi5jb3JlLlNlY3JldC5Nb3VudFR5cGUSDwoHZW52X3ZhchgFIAEoCSIrCglNb3VudFR5cGUSBwoDQU5ZEAASCwoHRU5WX1ZBUhABEggKBEZJTEUQAiLzAQoKQ29ubmVjdGlvbhIRCgl0YXNrX3R5cGUYASABKAkSOAoHc2VjcmV0cxgCIAMoCzInLmZseXRlaWRsMi5jb3JlLkNvbm5lY3Rpb24uU2VjcmV0c0VudHJ5EjgKB2NvbmZpZ3MYAyADKAsyJy5mbHl0ZWlkbDIuY29yZS5Db25uZWN0aW9uLkNvbmZpZ3NFbnRyeRouCgxTZWNyZXRzRW50cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ARouCgxDb25maWdzRW50cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ASJQCgxPQXV0aDJDbGllbnQSEQoJY2xpZW50X2lkGAEgASgJEi0KDWNsaWVudF9zZWNyZXQYAiABKAsyFi5mbHl0ZWlkbDIuY29yZS5TZWNyZXQiigEKCElkZW50aXR5EhAKCGlhbV9yb2xlGAEgASgJEhsKE2s4c19zZXJ2aWNlX2FjY291bnQYAiABKAkSMwoNb2F1dGgyX2NsaWVudBgDIAEoCzIcLmZseXRlaWRsMi5jb3JlLk9BdXRoMkNsaWVudBIaChJleGVjdXRpb25faWRlbnRpdHkYBCABKAki3wEKEk9BdXRoMlRva2VuUmVxdWVzdBIMCgRuYW1lGAEgASgJEjUKBHR5cGUYAiABKA4yJy5mbHl0ZWlkbDIuY29yZS5PQXV0aDJUb2tlblJlcXVlc3QuVHlwZRIsCgZjbGllbnQYAyABKAsyHC5mbHl0ZWlkbDIuY29yZS5PQXV0aDJDbGllbnQSHgoWaWRwX2Rpc2NvdmVyeV9lbmRwb2ludBgEIAEoCRIWCg50b2tlbl9lbmRwb2ludBgFIAEoCSIeCgRUeXBlEhYKEkNMSUVOVF9DUkVERU5USUFMUxAAIpgBCg9TZWN1cml0eUNvbnRleHQSKAoGcnVuX2FzGAEgASgLMhguZmx5dGVpZGwyLmNvcmUuSWRlbnRpdHkSJwoHc2VjcmV0cxgCIAMoCzIWLmZseXRlaWRsMi5jb3JlLlNlY3JldBIyCgZ0b2tlbnMYAyADKAsyIi5mbHl0ZWlkbDIuY29yZS5PQXV0aDJUb2tlblJlcXVlc3RCsgEKEmNvbS5mbHl0ZWlkbDIuY29yZUINU2VjdXJpdHlQcm90b0gCUAFaMmdpdGh1Yi5jb20vZmx5dGVvcmcvZmx5dGUvdjIvZ2VuL2dvL2ZseXRlaWRsMi9jb3JlogIDRkNYqgIORmx5dGVpZGwyLkNvcmXKAg5GbHl0ZWlkbDJcQ29yZeICGkZseXRlaWRsMlxDb3JlXEdQQk1ldGFkYXRh6gIPRmx5dGVpZGwyOjpDb3JlYgZwcm90bzM"); + +/** + * Secret encapsulates information about the secret a task needs to proceed. An environment variable + * FLYTE_SECRETS_ENV_PREFIX will be passed to indicate the prefix of the environment variables that will be present if + * secrets are passed through environment variables. + * FLYTE_SECRETS_DEFAULT_DIR will be passed to indicate the prefix of the path where secrets will be mounted if secrets + * are passed through file mounts. + * + * @generated from message flyteidl2.core.Secret + */ +export type Secret = Message<"flyteidl2.core.Secret"> & { + /** + * The name of the secret group where to find the key referenced below. For K8s secrets, this should be the name of + * the v1/secret object. For Confidant, this should be the Credential name. For Vault, this should be the secret name. + * For AWS Secret Manager, this should be the name of the secret. + * +required + * + * @generated from field: string group = 1; + */ + group: string; + + /** + * The group version to fetch. This is not supported in all secret management systems. It'll be ignored for the ones + * that do not support it. + * +optional + * + * @generated from field: string group_version = 2; + */ + groupVersion: string; + + /** + * The name of the secret to mount. This has to match an existing secret in the system. It's up to the implementation + * of the secret management system to require case sensitivity. For K8s secrets, Confidant and Vault, this should + * match one of the keys inside the secret. For AWS Secret Manager, it's ignored. + * +optional + * + * @generated from field: string key = 3; + */ + key: string; + + /** + * mount_requirement is optional. Indicates where the secret has to be mounted. If provided, the execution will fail + * if the underlying key management system cannot satisfy that requirement. If not provided, the default location + * will depend on the key management system. + * +optional + * + * @generated from field: flyteidl2.core.Secret.MountType mount_requirement = 4; + */ + mountRequirement: Secret_MountType; + + /** + * env_var is optional. Custom environment variable to set the value of the secret. If mount_requirement is ENV_VAR, + * then the value is the secret itself. If mount_requirement is FILE, then the value is the path to the secret file. + * +optional + * + * @generated from field: string env_var = 5; + */ + envVar: string; +}; + +/** + * Describes the message flyteidl2.core.Secret. + * Use `create(SecretSchema)` to create a new message. + */ +export const SecretSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_security, 0); + +/** + * @generated from enum flyteidl2.core.Secret.MountType + */ +export enum Secret_MountType { + /** + * Default case, indicates the client can tolerate either mounting options. + * + * @generated from enum value: ANY = 0; + */ + ANY = 0, + + /** + * ENV_VAR indicates the secret needs to be mounted as an environment variable. + * + * @generated from enum value: ENV_VAR = 1; + */ + ENV_VAR = 1, + + /** + * FILE indicates the secret needs to be mounted as a file. + * + * @generated from enum value: FILE = 2; + */ + FILE = 2, +} + +/** + * Describes the enum flyteidl2.core.Secret.MountType. + */ +export const Secret_MountTypeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_security, 0, 0); + +/** + * @generated from message flyteidl2.core.Connection + */ +export type Connection = Message<"flyteidl2.core.Connection"> & { + /** + * The task type that the connection is used for. + * + * @generated from field: string task_type = 1; + */ + taskType: string; + + /** + * The credentials to use for the connection, such as API keys, OAuth2 tokens, etc. + * The key is the name of the secret, and it's defined in the flytekit. + * flytekit uses the key to locate the desired secret within the map. + * + * @generated from field: map secrets = 2; + */ + secrets: { [key: string]: string }; + + /** + * The configuration to use for the connection, such as the endpoint, account name, etc. + * The key is the name of the config, and it's defined in the flytekit. + * + * @generated from field: map configs = 3; + */ + configs: { [key: string]: string }; +}; + +/** + * Describes the message flyteidl2.core.Connection. + * Use `create(ConnectionSchema)` to create a new message. + */ +export const ConnectionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_security, 1); + +/** + * OAuth2Client encapsulates OAuth2 Client Credentials to be used when making calls on behalf of that task. + * + * @generated from message flyteidl2.core.OAuth2Client + */ +export type OAuth2Client = Message<"flyteidl2.core.OAuth2Client"> & { + /** + * client_id is the public id for the client to use. The system will not perform any pre-auth validation that the + * secret requested matches the client_id indicated here. + * +required + * + * @generated from field: string client_id = 1; + */ + clientId: string; + + /** + * client_secret is a reference to the secret used to authenticate the OAuth2 client. + * +required + * + * @generated from field: flyteidl2.core.Secret client_secret = 2; + */ + clientSecret?: Secret; +}; + +/** + * Describes the message flyteidl2.core.OAuth2Client. + * Use `create(OAuth2ClientSchema)` to create a new message. + */ +export const OAuth2ClientSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_security, 2); + +/** + * Identity encapsulates the various security identities a task can run as. It's up to the underlying plugin to pick the + * right identity for the execution environment. + * + * @generated from message flyteidl2.core.Identity + */ +export type Identity = Message<"flyteidl2.core.Identity"> & { + /** + * iam_role references the fully qualified name of Identity & Access Management role to impersonate. + * + * @generated from field: string iam_role = 1; + */ + iamRole: string; + + /** + * k8s_service_account references a kubernetes service account to impersonate. + * + * @generated from field: string k8s_service_account = 2; + */ + k8sServiceAccount: string; + + /** + * oauth2_client references an oauth2 client. Backend plugins can use this information to impersonate the client when + * making external calls. + * + * @generated from field: flyteidl2.core.OAuth2Client oauth2_client = 3; + */ + oauth2Client?: OAuth2Client; + + /** + * execution_identity references the subject who makes the execution + * + * @generated from field: string execution_identity = 4; + */ + executionIdentity: string; +}; + +/** + * Describes the message flyteidl2.core.Identity. + * Use `create(IdentitySchema)` to create a new message. + */ +export const IdentitySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_security, 3); + +/** + * OAuth2TokenRequest encapsulates information needed to request an OAuth2 token. + * FLYTE_TOKENS_ENV_PREFIX will be passed to indicate the prefix of the environment variables that will be present if + * tokens are passed through environment variables. + * FLYTE_TOKENS_PATH_PREFIX will be passed to indicate the prefix of the path where secrets will be mounted if tokens + * are passed through file mounts. + * + * @generated from message flyteidl2.core.OAuth2TokenRequest + */ +export type OAuth2TokenRequest = Message<"flyteidl2.core.OAuth2TokenRequest"> & { + /** + * name indicates a unique id for the token request within this task token requests. It'll be used as a suffix for + * environment variables and as a filename for mounting tokens as files. + * +required + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * type indicates the type of the request to make. Defaults to CLIENT_CREDENTIALS. + * +required + * + * @generated from field: flyteidl2.core.OAuth2TokenRequest.Type type = 2; + */ + type: OAuth2TokenRequest_Type; + + /** + * client references the client_id/secret to use to request the OAuth2 token. + * +required + * + * @generated from field: flyteidl2.core.OAuth2Client client = 3; + */ + client?: OAuth2Client; + + /** + * idp_discovery_endpoint references the discovery endpoint used to retrieve token endpoint and other related + * information. + * +optional + * + * @generated from field: string idp_discovery_endpoint = 4; + */ + idpDiscoveryEndpoint: string; + + /** + * token_endpoint references the token issuance endpoint. If idp_discovery_endpoint is not provided, this parameter is + * mandatory. + * +optional + * + * @generated from field: string token_endpoint = 5; + */ + tokenEndpoint: string; +}; + +/** + * Describes the message flyteidl2.core.OAuth2TokenRequest. + * Use `create(OAuth2TokenRequestSchema)` to create a new message. + */ +export const OAuth2TokenRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_security, 4); + +/** + * Type of the token requested. + * + * @generated from enum flyteidl2.core.OAuth2TokenRequest.Type + */ +export enum OAuth2TokenRequest_Type { + /** + * CLIENT_CREDENTIALS indicates a 2-legged OAuth token requested using client credentials. + * + * @generated from enum value: CLIENT_CREDENTIALS = 0; + */ + CLIENT_CREDENTIALS = 0, +} + +/** + * Describes the enum flyteidl2.core.OAuth2TokenRequest.Type. + */ +export const OAuth2TokenRequest_TypeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_security, 4, 0); + +/** + * SecurityContext holds security attributes that apply to tasks. + * + * @generated from message flyteidl2.core.SecurityContext + */ +export type SecurityContext = Message<"flyteidl2.core.SecurityContext"> & { + /** + * run_as encapsulates the identity a pod should run as. If the task fills in multiple fields here, it'll be up to the + * backend plugin to choose the appropriate identity for the execution engine the task will run on. + * + * @generated from field: flyteidl2.core.Identity run_as = 1; + */ + runAs?: Identity; + + /** + * secrets indicate the list of secrets the task needs in order to proceed. Secrets will be mounted/passed to the + * pod as it starts. If the plugin responsible for kicking of the task will not run it on a flyte cluster (e.g. AWS + * Batch), it's the responsibility of the plugin to fetch the secret (which means propeller identity will need access + * to the secret) and to pass it to the remote execution engine. + * + * @generated from field: repeated flyteidl2.core.Secret secrets = 2; + */ + secrets: Secret[]; + + /** + * tokens indicate the list of token requests the task needs in order to proceed. Tokens will be mounted/passed to the + * pod as it starts. If the plugin responsible for kicking of the task will not run it on a flyte cluster (e.g. AWS + * Batch), it's the responsibility of the plugin to fetch the secret (which means propeller identity will need access + * to the secret) and to pass it to the remote execution engine. + * + * @generated from field: repeated flyteidl2.core.OAuth2TokenRequest tokens = 3; + */ + tokens: OAuth2TokenRequest[]; +}; + +/** + * Describes the message flyteidl2.core.SecurityContext. + * Use `create(SecurityContextSchema)` to create a new message. + */ +export const SecurityContextSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_security, 5); + diff --git a/gen/ts/flyteidl2/core/tasks_pb.ts b/gen/ts/flyteidl2/core/tasks_pb.ts new file mode 100644 index 0000000000..f0f8b1cf7f --- /dev/null +++ b/gen/ts/flyteidl2/core/tasks_pb.ts @@ -0,0 +1,1097 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/core/tasks.proto (package flyteidl2.core, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { TaskLog } from "./execution_pb.ts"; +import { file_flyteidl2_core_execution } from "./execution_pb.ts"; +import type { Identifier } from "./identifier_pb.ts"; +import { file_flyteidl2_core_identifier } from "./identifier_pb.ts"; +import type { TypedInterface } from "./interface_pb.ts"; +import { file_flyteidl2_core_interface } from "./interface_pb.ts"; +import type { KeyValuePair, RetryStrategy } from "./literals_pb.ts"; +import { file_flyteidl2_core_literals } from "./literals_pb.ts"; +import type { SecurityContext } from "./security_pb.ts"; +import { file_flyteidl2_core_security } from "./security_pb.ts"; +import type { Duration } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_duration, file_google_protobuf_struct, file_google_protobuf_wrappers } from "@bufbuild/protobuf/wkt"; +import type { JsonObject, Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/core/tasks.proto. + */ +export const file_flyteidl2_core_tasks: GenFile = /*@__PURE__*/ + fileDesc("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", [file_flyteidl2_core_execution, file_flyteidl2_core_identifier, file_flyteidl2_core_interface, file_flyteidl2_core_literals, file_flyteidl2_core_security, file_google_protobuf_duration, file_google_protobuf_struct, file_google_protobuf_wrappers]); + +/** + * A customizable interface to convey resources requested for a container. This can be interpreted differently for different + * container engines. + * + * @generated from message flyteidl2.core.Resources + */ +export type Resources = Message<"flyteidl2.core.Resources"> & { + /** + * The desired set of resources requested. ResourceNames must be unique within the list. + * + * @generated from field: repeated flyteidl2.core.Resources.ResourceEntry requests = 1; + */ + requests: Resources_ResourceEntry[]; + + /** + * Defines a set of bounds (e.g. min/max) within which the task can reliably run. ResourceNames must be unique + * within the list. + * + * @generated from field: repeated flyteidl2.core.Resources.ResourceEntry limits = 2; + */ + limits: Resources_ResourceEntry[]; +}; + +/** + * Describes the message flyteidl2.core.Resources. + * Use `create(ResourcesSchema)` to create a new message. + */ +export const ResourcesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_tasks, 0); + +/** + * Encapsulates a resource name and value. + * + * @generated from message flyteidl2.core.Resources.ResourceEntry + */ +export type Resources_ResourceEntry = Message<"flyteidl2.core.Resources.ResourceEntry"> & { + /** + * Resource name. + * + * @generated from field: flyteidl2.core.Resources.ResourceName name = 1; + */ + name: Resources_ResourceName; + + /** + * Value must be a valid k8s quantity. See + * https://github.com/kubernetes/apimachinery/blob/master/pkg/api/resource/quantity.go#L30-L80 + * + * @generated from field: string value = 2; + */ + value: string; +}; + +/** + * Describes the message flyteidl2.core.Resources.ResourceEntry. + * Use `create(Resources_ResourceEntrySchema)` to create a new message. + */ +export const Resources_ResourceEntrySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_tasks, 0, 0); + +/** + * Known resource names. + * + * @generated from enum flyteidl2.core.Resources.ResourceName + */ +export enum Resources_ResourceName { + /** + * @generated from enum value: UNKNOWN = 0; + */ + UNKNOWN = 0, + + /** + * @generated from enum value: CPU = 1; + */ + CPU = 1, + + /** + * @generated from enum value: GPU = 2; + */ + GPU = 2, + + /** + * @generated from enum value: MEMORY = 3; + */ + MEMORY = 3, + + /** + * @generated from enum value: STORAGE = 4; + */ + STORAGE = 4, + + /** + * For Kubernetes-based deployments, pods use ephemeral local storage for scratch space, caching, and for logs. + * + * @generated from enum value: EPHEMERAL_STORAGE = 5; + */ + EPHEMERAL_STORAGE = 5, +} + +/** + * Describes the enum flyteidl2.core.Resources.ResourceName. + */ +export const Resources_ResourceNameSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_tasks, 0, 0); + +/** + * Metadata associated with the GPU accelerator to allocate to a task. Contains + * information about device type, and for multi-instance GPUs, the partition size to + * use. + * + * @generated from message flyteidl2.core.GPUAccelerator + */ +export type GPUAccelerator = Message<"flyteidl2.core.GPUAccelerator"> & { + /** + * This can be any arbitrary string, and should be informed by the labels or taints + * associated with the nodes in question. Default cloud provider labels typically + * use the following values: `nvidia-tesla-t4`, `nvidia-tesla-a100`, etc. + * + * @generated from field: string device = 1; + */ + device: string; + + /** + * @generated from oneof flyteidl2.core.GPUAccelerator.partition_size_value + */ + partitionSizeValue: { + /** + * @generated from field: bool unpartitioned = 2; + */ + value: boolean; + case: "unpartitioned"; + } | { + /** + * Like `device`, this can be any arbitrary string, and should be informed by + * the labels or taints associated with the nodes in question. Default cloud + * provider labels typically use the following values: `1g.5gb`, `2g.10gb`, etc. + * + * @generated from field: string partition_size = 3; + */ + value: string; + case: "partitionSize"; + } | { case: undefined; value?: undefined }; + + /** + * The class of accelerator device. Defaults to NVIDIA_GPU if not specified. + * + * @generated from field: flyteidl2.core.GPUAccelerator.DeviceClass device_class = 4; + */ + deviceClass: GPUAccelerator_DeviceClass; +}; + +/** + * Describes the message flyteidl2.core.GPUAccelerator. + * Use `create(GPUAcceleratorSchema)` to create a new message. + */ +export const GPUAcceleratorSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_tasks, 1); + +/** + * Specifies the class of accelerator device. + * + * @generated from enum flyteidl2.core.GPUAccelerator.DeviceClass + */ +export enum GPUAccelerator_DeviceClass { + /** + * NVIDIA GPU devices (default for backward compatibility) + * + * @generated from enum value: NVIDIA_GPU = 0; + */ + NVIDIA_GPU = 0, + + /** + * Google TPU devices + * + * @generated from enum value: GOOGLE_TPU = 1; + */ + GOOGLE_TPU = 1, + + /** + * Amazon Neuron devices + * + * @generated from enum value: AMAZON_NEURON = 2; + */ + AMAZON_NEURON = 2, + + /** + * AMD GPU devices + * + * @generated from enum value: AMD_GPU = 3; + */ + AMD_GPU = 3, + + /** + * Habana Gaudi devices + * + * @generated from enum value: HABANA_GAUDI = 4; + */ + HABANA_GAUDI = 4, +} + +/** + * Describes the enum flyteidl2.core.GPUAccelerator.DeviceClass. + */ +export const GPUAccelerator_DeviceClassSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_tasks, 1, 0); + +/** + * Metadata associated with configuring a shared memory volume for a task. + * + * @generated from message flyteidl2.core.SharedMemory + */ +export type SharedMemory = Message<"flyteidl2.core.SharedMemory"> & { + /** + * Mount path to place in container + * + * @generated from field: string mount_path = 1; + */ + mountPath: string; + + /** + * Name for volume + * + * @generated from field: string mount_name = 2; + */ + mountName: string; + + /** + * Size limit for shared memory. If not set, then the shared memory is equal + * to the allocated memory. + * +optional + * + * @generated from field: string size_limit = 3; + */ + sizeLimit: string; +}; + +/** + * Describes the message flyteidl2.core.SharedMemory. + * Use `create(SharedMemorySchema)` to create a new message. + */ +export const SharedMemorySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_tasks, 2); + +/** + * Encapsulates all non-standard resources, not captured by v1.ResourceRequirements, to + * allocate to a task. + * + * @generated from message flyteidl2.core.ExtendedResources + */ +export type ExtendedResources = Message<"flyteidl2.core.ExtendedResources"> & { + /** + * GPU accelerator to select for task. Contains information about device type, and + * for multi-instance GPUs, the partition size to use. + * + * @generated from field: flyteidl2.core.GPUAccelerator gpu_accelerator = 1; + */ + gpuAccelerator?: GPUAccelerator; + + /** + * @generated from field: flyteidl2.core.SharedMemory shared_memory = 2; + */ + sharedMemory?: SharedMemory; +}; + +/** + * Describes the message flyteidl2.core.ExtendedResources. + * Use `create(ExtendedResourcesSchema)` to create a new message. + */ +export const ExtendedResourcesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_tasks, 3); + +/** + * Runtime information. This is loosely defined to allow for extensibility. + * + * @generated from message flyteidl2.core.RuntimeMetadata + */ +export type RuntimeMetadata = Message<"flyteidl2.core.RuntimeMetadata"> & { + /** + * Type of runtime. + * + * @generated from field: flyteidl2.core.RuntimeMetadata.RuntimeType type = 1; + */ + type: RuntimeMetadata_RuntimeType; + + /** + * Version of the runtime. All versions should be backward compatible. However, certain cases call for version + * checks to ensure tighter validation or setting expectations. + * + * @generated from field: string version = 2; + */ + version: string; + + /** + * +optional It can be used to provide extra information about the runtime (e.g. python, golang... etc.). + * + * @generated from field: string flavor = 3; + */ + flavor: string; +}; + +/** + * Describes the message flyteidl2.core.RuntimeMetadata. + * Use `create(RuntimeMetadataSchema)` to create a new message. + */ +export const RuntimeMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_tasks, 4); + +/** + * @generated from enum flyteidl2.core.RuntimeMetadata.RuntimeType + */ +export enum RuntimeMetadata_RuntimeType { + /** + * @generated from enum value: OTHER = 0; + */ + OTHER = 0, + + /** + * @generated from enum value: FLYTE_SDK = 1; + */ + FLYTE_SDK = 1, +} + +/** + * Describes the enum flyteidl2.core.RuntimeMetadata.RuntimeType. + */ +export const RuntimeMetadata_RuntimeTypeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_tasks, 4, 0); + +/** + * Task Metadata + * + * @generated from message flyteidl2.core.TaskMetadata + */ +export type TaskMetadata = Message<"flyteidl2.core.TaskMetadata"> & { + /** + * Indicates whether the system should attempt to lookup this task's output to avoid duplication of work. + * + * @generated from field: bool discoverable = 1; + */ + discoverable: boolean; + + /** + * Runtime information about the task. + * + * @generated from field: flyteidl2.core.RuntimeMetadata runtime = 2; + */ + runtime?: RuntimeMetadata; + + /** + * The overall timeout of a task including user-triggered retries. + * + * @generated from field: google.protobuf.Duration timeout = 4; + */ + timeout?: Duration; + + /** + * Number of retries per task. + * + * @generated from field: flyteidl2.core.RetryStrategy retries = 5; + */ + retries?: RetryStrategy; + + /** + * Indicates a logical version to apply to this task for the purpose of discovery. + * + * @generated from field: string discovery_version = 6; + */ + discoveryVersion: string; + + /** + * If set, this indicates that this task is deprecated. This will enable owners of tasks to notify consumers + * of the ending of support for a given task. + * + * @generated from field: string deprecated_error_message = 7; + */ + deprecatedErrorMessage: string; + + /** + * Identify whether task is interruptible + * + * @generated from oneof flyteidl2.core.TaskMetadata.interruptible_value + */ + interruptibleValue: { + /** + * @generated from field: bool interruptible = 8; + */ + value: boolean; + case: "interruptible"; + } | { case: undefined; value?: undefined }; + + /** + * Indicates whether the system should attempt to execute discoverable instances in serial to avoid duplicate work + * + * @generated from field: bool cache_serializable = 9; + */ + cacheSerializable: boolean; + + /** + * Arbitrary tags that allow users and the platform to store small but arbitrary labels + * + * @generated from field: map tags = 11; + */ + tags: { [key: string]: string }; + + /** + * pod_template_name is the unique name of a PodTemplate k8s resource to be used as the base configuration if this + * task creates a k8s Pod. If this value is set, the specified PodTemplate will be used instead of, but applied + * identically as, the default PodTemplate configured in FlytePropeller. + * + * @generated from field: string pod_template_name = 12; + */ + podTemplateName: string; + + /** + * cache_ignore_input_vars is the input variables that should not be included when calculating hash for cache. + * + * @generated from field: repeated string cache_ignore_input_vars = 13; + */ + cacheIgnoreInputVars: string[]; + + /** + * is_eager indicates whether the task is eager or not. + * This would be used by CreateTask endpoint. + * + * @generated from field: bool is_eager = 14; + */ + isEager: boolean; + + /** + * Indicates whether the task will generate a deck when it finishes executing. + * The BoolValue can have three states: + * - nil: The value is not set. + * - true: The task will generate a deck. + * - false: The task will not generate a deck. + * + * @generated from field: google.protobuf.BoolValue generates_deck = 15; + */ + generatesDeck?: boolean; + + /** + * Metadata applied to task pods or task CR objects. + * In flytekit, labels and annotations resulting in this metadata field + * are provided via `@task(labels=..., annotations=...)`. + * For tasks backed by pods like PythonFunctionTask, these take precedence + * over the metadata provided via `@task(pod_template=PodTemplate(labels=...))` which are transported + * in the K8sPod message. For tasks backed by CRDs, this metadata is applied to + * the CR object itself while the metadata in the pod template/K8sPod is applied + * to the pod template spec of the CR object. + * + * @generated from field: flyteidl2.core.K8sObjectMetadata metadata = 16; + */ + metadata?: K8sObjectMetadata; + + /** + * Whether the task is able to run the debugger (vscode server) inside the task container. + * + * @generated from field: bool debuggable = 17; + */ + debuggable: boolean; + + /** + * Log links associated with this task. + * + * @generated from field: repeated flyteidl2.core.TaskLog log_links = 18; + */ + logLinks: TaskLog[]; +}; + +/** + * Describes the message flyteidl2.core.TaskMetadata. + * Use `create(TaskMetadataSchema)` to create a new message. + */ +export const TaskMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_tasks, 5); + +/** + * A Task structure that uniquely identifies a task in the system + * Tasks are registered as a first step in the system. + * + * @generated from message flyteidl2.core.TaskTemplate + */ +export type TaskTemplate = Message<"flyteidl2.core.TaskTemplate"> & { + /** + * Auto generated taskId by the system. Task Id uniquely identifies this task globally. + * + * @generated from field: flyteidl2.core.Identifier id = 1; + */ + id?: Identifier; + + /** + * A predefined yet extensible Task type identifier. This can be used to customize any of the components. If no + * extensions are provided in the system, Flyte will resolve the this task to its TaskCategory and default the + * implementation registered for the TaskCategory. + * + * @generated from field: string type = 2; + */ + type: string; + + /** + * Extra metadata about the task. + * + * @generated from field: flyteidl2.core.TaskMetadata metadata = 3; + */ + metadata?: TaskMetadata; + + /** + * A strongly typed interface for the task. This enables others to use this task within a workflow and guarantees + * compile-time validation of the workflow to avoid costly runtime failures. + * + * @generated from field: flyteidl2.core.TypedInterface interface = 4; + */ + interface?: TypedInterface; + + /** + * Custom data about the task. This is extensible to allow various plugins in the system. + * + * @generated from field: google.protobuf.Struct custom = 5; + */ + custom?: JsonObject; + + /** + * Known target types that the system will guarantee plugins for. Custom SDK plugins are allowed to set these if needed. + * If no corresponding execution-layer plugins are found, the system will default to handling these using built-in + * handlers. + * + * @generated from oneof flyteidl2.core.TaskTemplate.target + */ + target: { + /** + * @generated from field: flyteidl2.core.Container container = 6; + */ + value: Container; + case: "container"; + } | { + /** + * @generated from field: flyteidl2.core.K8sPod k8s_pod = 17; + */ + value: K8sPod; + case: "k8sPod"; + } | { + /** + * @generated from field: flyteidl2.core.Sql sql = 18; + */ + value: Sql; + case: "sql"; + } | { case: undefined; value?: undefined }; + + /** + * This can be used to customize task handling at execution time for the same task type. + * + * @generated from field: int32 task_type_version = 7; + */ + taskTypeVersion: number; + + /** + * security_context encapsulates security attributes requested to run this task. + * + * @generated from field: flyteidl2.core.SecurityContext security_context = 8; + */ + securityContext?: SecurityContext; + + /** + * Encapsulates all non-standard resources, not captured by + * v1.ResourceRequirements, to allocate to a task. + * + * @generated from field: flyteidl2.core.ExtendedResources extended_resources = 9; + */ + extendedResources?: ExtendedResources; + + /** + * Metadata about the custom defined for this task. This is extensible to allow various plugins in the system + * to use as required. + * reserve the field numbers 1 through 15 for very frequently occurring message elements + * + * @generated from field: map config = 16; + */ + config: { [key: string]: string }; +}; + +/** + * Describes the message flyteidl2.core.TaskTemplate. + * Use `create(TaskTemplateSchema)` to create a new message. + */ +export const TaskTemplateSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_tasks, 6); + +/** + * Defines port properties for a container. + * + * @generated from message flyteidl2.core.ContainerPort + */ +export type ContainerPort = Message<"flyteidl2.core.ContainerPort"> & { + /** + * Number of port to expose on the pod's IP address. + * This must be a valid port number, 0 < x < 65536. + * + * @generated from field: uint32 container_port = 1; + */ + containerPort: number; + + /** + * Name of the port to expose on the pod's IP address. + * + * @generated from field: string name = 2; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.core.ContainerPort. + * Use `create(ContainerPortSchema)` to create a new message. + */ +export const ContainerPortSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_tasks, 7); + +/** + * @generated from message flyteidl2.core.Container + */ +export type Container = Message<"flyteidl2.core.Container"> & { + /** + * Container image url. Eg: docker/redis:latest + * + * @generated from field: string image = 1; + */ + image: string; + + /** + * Command to be executed, if not provided, the default entrypoint in the container image will be used. + * + * @generated from field: repeated string command = 2; + */ + command: string[]; + + /** + * These will default to Flyte given paths. If provided, the system will not append known paths. If the task still + * needs flyte's inputs and outputs path, add $(FLYTE_INPUT_FILE), $(FLYTE_OUTPUT_FILE) wherever makes sense and the + * system will populate these before executing the container. + * + * @generated from field: repeated string args = 3; + */ + args: string[]; + + /** + * Container resources requirement as specified by the container engine. + * + * @generated from field: flyteidl2.core.Resources resources = 4; + */ + resources?: Resources; + + /** + * Environment variables will be set as the container is starting up. + * + * @generated from field: repeated flyteidl2.core.KeyValuePair env = 5; + */ + env: KeyValuePair[]; + + /** + * Allows extra configs to be available for the container. + * TODO: elaborate on how configs will become available. + * Deprecated, please use TaskTemplate.config instead. + * + * @generated from field: repeated flyteidl2.core.KeyValuePair config = 6 [deprecated = true]; + * @deprecated + */ + config: KeyValuePair[]; + + /** + * Ports to open in the container. This feature is not supported by all execution engines. (e.g. supported on K8s but + * not supported on AWS Batch) + * Only K8s + * + * @generated from field: repeated flyteidl2.core.ContainerPort ports = 7; + */ + ports: ContainerPort[]; + + /** + * BETA: Optional configuration for DataLoading. If not specified, then default values are used. + * This makes it possible to to run a completely portable container, that uses inputs and outputs + * only from the local file-system and without having any reference to flyteidl. This is supported only on K8s at the moment. + * If data loading is enabled, then data will be mounted in accompanying directories specified in the DataLoadingConfig. If the directories + * are not specified, inputs will be mounted onto and outputs will be uploaded from a pre-determined file-system path. Refer to the documentation + * to understand the default paths. + * Only K8s + * + * @generated from field: flyteidl2.core.DataLoadingConfig data_config = 9; + */ + dataConfig?: DataLoadingConfig; + + /** + * @generated from field: flyteidl2.core.Container.Architecture architecture = 10; + */ + architecture: Container_Architecture; +}; + +/** + * Describes the message flyteidl2.core.Container. + * Use `create(ContainerSchema)` to create a new message. + */ +export const ContainerSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_tasks, 8); + +/** + * Architecture-type the container image supports. + * + * @generated from enum flyteidl2.core.Container.Architecture + */ +export enum Container_Architecture { + /** + * @generated from enum value: UNKNOWN = 0; + */ + UNKNOWN = 0, + + /** + * @generated from enum value: AMD64 = 1; + */ + AMD64 = 1, + + /** + * @generated from enum value: ARM64 = 2; + */ + ARM64 = 2, + + /** + * @generated from enum value: ARM_V6 = 3; + */ + ARM_V6 = 3, + + /** + * @generated from enum value: ARM_V7 = 4; + */ + ARM_V7 = 4, +} + +/** + * Describes the enum flyteidl2.core.Container.Architecture. + */ +export const Container_ArchitectureSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_tasks, 8, 0); + +/** + * Strategy to use when dealing with Blob, Schema, or multipart blob data (large datasets) + * + * @generated from message flyteidl2.core.IOStrategy + */ +export type IOStrategy = Message<"flyteidl2.core.IOStrategy"> & { + /** + * Mode to use to manage downloads + * + * @generated from field: flyteidl2.core.IOStrategy.DownloadMode download_mode = 1; + */ + downloadMode: IOStrategy_DownloadMode; + + /** + * Mode to use to manage uploads + * + * @generated from field: flyteidl2.core.IOStrategy.UploadMode upload_mode = 2; + */ + uploadMode: IOStrategy_UploadMode; +}; + +/** + * Describes the message flyteidl2.core.IOStrategy. + * Use `create(IOStrategySchema)` to create a new message. + */ +export const IOStrategySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_tasks, 9); + +/** + * Mode to use for downloading + * + * @generated from enum flyteidl2.core.IOStrategy.DownloadMode + */ +export enum IOStrategy_DownloadMode { + /** + * All data will be downloaded before the main container is executed + * + * @generated from enum value: DOWNLOAD_EAGER = 0; + */ + DOWNLOAD_EAGER = 0, + + /** + * Data will be downloaded as a stream and an End-Of-Stream marker will be written to indicate all data has been downloaded. Refer to protocol for details + * + * @generated from enum value: DOWNLOAD_STREAM = 1; + */ + DOWNLOAD_STREAM = 1, + + /** + * Large objects (offloaded) will not be downloaded + * + * @generated from enum value: DO_NOT_DOWNLOAD = 2; + */ + DO_NOT_DOWNLOAD = 2, +} + +/** + * Describes the enum flyteidl2.core.IOStrategy.DownloadMode. + */ +export const IOStrategy_DownloadModeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_tasks, 9, 0); + +/** + * Mode to use for uploading + * + * @generated from enum flyteidl2.core.IOStrategy.UploadMode + */ +export enum IOStrategy_UploadMode { + /** + * All data will be uploaded after the main container exits + * + * @generated from enum value: UPLOAD_ON_EXIT = 0; + */ + UPLOAD_ON_EXIT = 0, + + /** + * Data will be uploaded as it appears. Refer to protocol specification for details + * + * @generated from enum value: UPLOAD_EAGER = 1; + */ + UPLOAD_EAGER = 1, + + /** + * Data will not be uploaded, only references will be written + * + * @generated from enum value: DO_NOT_UPLOAD = 2; + */ + DO_NOT_UPLOAD = 2, +} + +/** + * Describes the enum flyteidl2.core.IOStrategy.UploadMode. + */ +export const IOStrategy_UploadModeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_tasks, 9, 1); + +/** + * This configuration allows executing raw containers in Flyte using the Flyte CoPilot system. + * Flyte CoPilot, eliminates the needs of flytekit or sdk inside the container. Any inputs required by the users container are side-loaded in the input_path + * Any outputs generated by the user container - within output_path are automatically uploaded. + * + * @generated from message flyteidl2.core.DataLoadingConfig + */ +export type DataLoadingConfig = Message<"flyteidl2.core.DataLoadingConfig"> & { + /** + * Flag enables DataLoading Config. If this is not set, data loading will not be used! + * + * @generated from field: bool enabled = 1; + */ + enabled: boolean; + + /** + * File system path (start at root). This folder will contain all the inputs exploded to a separate file. + * Example, if the input interface needs (x: int, y: blob, z: multipart_blob) and the input path is '/var/flyte/inputs', then the file system will look like + * /var/flyte/inputs/inputs. .pb .json .yaml> -> Format as defined previously. The Blob and Multipart blob will reference local filesystem instead of remote locations + * /var/flyte/inputs/x -> X is a file that contains the value of x (integer) in string format + * /var/flyte/inputs/y -> Y is a file in Binary format + * /var/flyte/inputs/z/... -> Note Z itself is a directory + * More information about the protocol - refer to docs #TODO reference docs here + * + * @generated from field: string input_path = 2; + */ + inputPath: string; + + /** + * File system path (start at root). This folder should contain all the outputs for the task as individual files and/or an error text file + * + * @generated from field: string output_path = 3; + */ + outputPath: string; + + /** + * In the inputs folder, there will be an additional summary/metadata file that contains references to all files or inlined primitive values. + * This format decides the actual encoding for the data. Refer to the encoding to understand the specifics of the contents and the encoding + * + * @generated from field: flyteidl2.core.DataLoadingConfig.LiteralMapFormat format = 4; + */ + format: DataLoadingConfig_LiteralMapFormat; + + /** + * @generated from field: flyteidl2.core.IOStrategy io_strategy = 5; + */ + ioStrategy?: IOStrategy; +}; + +/** + * Describes the message flyteidl2.core.DataLoadingConfig. + * Use `create(DataLoadingConfigSchema)` to create a new message. + */ +export const DataLoadingConfigSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_tasks, 10); + +/** + * LiteralMapFormat decides the encoding format in which the input metadata should be made available to the containers. + * If the user has access to the protocol buffer definitions, it is recommended to use the PROTO format. + * JSON and YAML do not need any protobuf definitions to read it + * All remote references in core.LiteralMap are replaced with local filesystem references (the data is downloaded to local filesystem) + * + * @generated from enum flyteidl2.core.DataLoadingConfig.LiteralMapFormat + */ +export enum DataLoadingConfig_LiteralMapFormat { + /** + * JSON / YAML for the metadata (which contains inlined primitive values). The representation is inline with the standard json specification as specified - https://www.json.org/json-en.html + * + * @generated from enum value: JSON = 0; + */ + JSON = 0, + + /** + * @generated from enum value: YAML = 1; + */ + YAML = 1, + + /** + * Proto is a serialized binary of `core.LiteralMap` defined in flyteidl/core + * + * @generated from enum value: PROTO = 2; + */ + PROTO = 2, +} + +/** + * Describes the enum flyteidl2.core.DataLoadingConfig.LiteralMapFormat. + */ +export const DataLoadingConfig_LiteralMapFormatSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_tasks, 10, 0); + +/** + * Defines a pod spec and additional pod metadata that is created when a task is executed. + * + * @generated from message flyteidl2.core.K8sPod + */ +export type K8sPod = Message<"flyteidl2.core.K8sPod"> & { + /** + * Contains additional metadata for building a kubernetes pod. + * + * @generated from field: flyteidl2.core.K8sObjectMetadata metadata = 1; + */ + metadata?: K8sObjectMetadata; + + /** + * Defines the primary pod spec created when a task is executed. + * This should be a JSON-marshalled pod spec, which can be defined in + * - go, using: https://github.com/kubernetes/api/blob/release-1.21/core/v1/types.go#L2936 + * - python: using https://github.com/kubernetes-client/python/blob/release-19.0/kubernetes/client/models/v1_pod_spec.py + * + * @generated from field: google.protobuf.Struct pod_spec = 2; + */ + podSpec?: JsonObject; + + /** + * BETA: Optional configuration for DataLoading. If not specified, then default values are used. + * This makes it possible to to run a completely portable container, that uses inputs and outputs + * only from the local file-system and without having any reference to flytekit. This is supported only on K8s at the moment. + * If data loading is enabled, then data will be mounted in accompanying directories specified in the DataLoadingConfig. If the directories + * are not specified, inputs will be mounted onto and outputs will be uploaded from a pre-determined file-system path. Refer to the documentation + * to understand the default paths. + * Only K8s + * + * @generated from field: flyteidl2.core.DataLoadingConfig data_config = 3; + */ + dataConfig?: DataLoadingConfig; + + /** + * Defines the primary container name when pod template override is executed. + * + * @generated from field: string primary_container_name = 4; + */ + primaryContainerName: string; +}; + +/** + * Describes the message flyteidl2.core.K8sPod. + * Use `create(K8sPodSchema)` to create a new message. + */ +export const K8sPodSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_tasks, 11); + +/** + * Metadata for building a kubernetes object when a task is executed. + * + * @generated from message flyteidl2.core.K8sObjectMetadata + */ +export type K8sObjectMetadata = Message<"flyteidl2.core.K8sObjectMetadata"> & { + /** + * Optional labels to add to the pod definition. + * + * @generated from field: map labels = 1; + */ + labels: { [key: string]: string }; + + /** + * Optional annotations to add to the pod definition. + * + * @generated from field: map annotations = 2; + */ + annotations: { [key: string]: string }; +}; + +/** + * Describes the message flyteidl2.core.K8sObjectMetadata. + * Use `create(K8sObjectMetadataSchema)` to create a new message. + */ +export const K8sObjectMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_tasks, 12); + +/** + * Sql represents a generic sql workload with a statement and dialect. + * + * @generated from message flyteidl2.core.Sql + */ +export type Sql = Message<"flyteidl2.core.Sql"> & { + /** + * The actual query to run, the query can have templated parameters. + * We use Flyte's Golang templating format for Query templating. + * For example, + * insert overwrite directory '{{ .rawOutputDataPrefix }}' stored as parquet + * select * + * from my_table + * where ds = '{{ .Inputs.ds }}' + * + * @generated from field: string statement = 1; + */ + statement: string; + + /** + * @generated from field: flyteidl2.core.Sql.Dialect dialect = 2; + */ + dialect: Sql_Dialect; +}; + +/** + * Describes the message flyteidl2.core.Sql. + * Use `create(SqlSchema)` to create a new message. + */ +export const SqlSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_tasks, 13); + +/** + * The dialect of the SQL statement. This is used to validate and parse SQL statements at compilation time to avoid + * expensive runtime operations. If set to an unsupported dialect, no validation will be done on the statement. + * We support the following dialect: ansi, hive. + * + * @generated from enum flyteidl2.core.Sql.Dialect + */ +export enum Sql_Dialect { + /** + * @generated from enum value: UNDEFINED = 0; + */ + UNDEFINED = 0, + + /** + * @generated from enum value: ANSI = 1; + */ + ANSI = 1, + + /** + * @generated from enum value: HIVE = 2; + */ + HIVE = 2, + + /** + * @generated from enum value: OTHER = 3; + */ + OTHER = 3, +} + +/** + * Describes the enum flyteidl2.core.Sql.Dialect. + */ +export const Sql_DialectSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_tasks, 13, 0); + diff --git a/gen/ts/flyteidl2/core/types_pb.ts b/gen/ts/flyteidl2/core/types_pb.ts new file mode 100644 index 0000000000..2afba2de74 --- /dev/null +++ b/gen/ts/flyteidl2/core/types_pb.ts @@ -0,0 +1,592 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/core/types.proto (package flyteidl2.core, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_google_protobuf_struct } from "@bufbuild/protobuf/wkt"; +import type { JsonObject, Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/core/types.proto. + */ +export const file_flyteidl2_core_types: GenFile = /*@__PURE__*/ + fileDesc("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", [file_google_protobuf_struct]); + +/** + * Defines schema columns and types to strongly type-validate schemas interoperability. + * + * @generated from message flyteidl2.core.SchemaType + */ +export type SchemaType = Message<"flyteidl2.core.SchemaType"> & { + /** + * A list of ordered columns this schema comprises of. + * + * @generated from field: repeated flyteidl2.core.SchemaType.SchemaColumn columns = 3; + */ + columns: SchemaType_SchemaColumn[]; +}; + +/** + * Describes the message flyteidl2.core.SchemaType. + * Use `create(SchemaTypeSchema)` to create a new message. + */ +export const SchemaTypeSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_types, 0); + +/** + * @generated from message flyteidl2.core.SchemaType.SchemaColumn + */ +export type SchemaType_SchemaColumn = Message<"flyteidl2.core.SchemaType.SchemaColumn"> & { + /** + * A unique name -within the schema type- for the column + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * The column type. This allows a limited set of types currently. + * + * @generated from field: flyteidl2.core.SchemaType.SchemaColumn.SchemaColumnType type = 2; + */ + type: SchemaType_SchemaColumn_SchemaColumnType; +}; + +/** + * Describes the message flyteidl2.core.SchemaType.SchemaColumn. + * Use `create(SchemaType_SchemaColumnSchema)` to create a new message. + */ +export const SchemaType_SchemaColumnSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_types, 0, 0); + +/** + * @generated from enum flyteidl2.core.SchemaType.SchemaColumn.SchemaColumnType + */ +export enum SchemaType_SchemaColumn_SchemaColumnType { + /** + * @generated from enum value: INTEGER = 0; + */ + INTEGER = 0, + + /** + * @generated from enum value: FLOAT = 1; + */ + FLOAT = 1, + + /** + * @generated from enum value: STRING = 2; + */ + STRING = 2, + + /** + * @generated from enum value: BOOLEAN = 3; + */ + BOOLEAN = 3, + + /** + * @generated from enum value: DATETIME = 4; + */ + DATETIME = 4, + + /** + * @generated from enum value: DURATION = 5; + */ + DURATION = 5, +} + +/** + * Describes the enum flyteidl2.core.SchemaType.SchemaColumn.SchemaColumnType. + */ +export const SchemaType_SchemaColumn_SchemaColumnTypeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_types, 0, 0, 0); + +/** + * @generated from message flyteidl2.core.StructuredDatasetType + */ +export type StructuredDatasetType = Message<"flyteidl2.core.StructuredDatasetType"> & { + /** + * A list of ordered columns this schema comprises of. + * + * @generated from field: repeated flyteidl2.core.StructuredDatasetType.DatasetColumn columns = 1; + */ + columns: StructuredDatasetType_DatasetColumn[]; + + /** + * This is the storage format, the format of the bits at rest + * parquet, feather, csv, etc. + * For two types to be compatible, the format will need to be an exact match. + * + * @generated from field: string format = 2; + */ + format: string; + + /** + * This is a string representing the type that the bytes in external_schema_bytes are formatted in. + * This is an optional field that will not be used for type checking. + * + * @generated from field: string external_schema_type = 3; + */ + externalSchemaType: string; + + /** + * The serialized bytes of a third-party schema library like Arrow. + * This is an optional field that will not be used for type checking. + * + * @generated from field: bytes external_schema_bytes = 4; + */ + externalSchemaBytes: Uint8Array; +}; + +/** + * Describes the message flyteidl2.core.StructuredDatasetType. + * Use `create(StructuredDatasetTypeSchema)` to create a new message. + */ +export const StructuredDatasetTypeSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_types, 1); + +/** + * @generated from message flyteidl2.core.StructuredDatasetType.DatasetColumn + */ +export type StructuredDatasetType_DatasetColumn = Message<"flyteidl2.core.StructuredDatasetType.DatasetColumn"> & { + /** + * A unique name within the schema type for the column. + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * The column type. + * + * @generated from field: flyteidl2.core.LiteralType literal_type = 2; + */ + literalType?: LiteralType; +}; + +/** + * Describes the message flyteidl2.core.StructuredDatasetType.DatasetColumn. + * Use `create(StructuredDatasetType_DatasetColumnSchema)` to create a new message. + */ +export const StructuredDatasetType_DatasetColumnSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_types, 1, 0); + +/** + * Defines type behavior for blob objects + * + * @generated from message flyteidl2.core.BlobType + */ +export type BlobType = Message<"flyteidl2.core.BlobType"> & { + /** + * Format can be a free form string understood by SDK/UI etc like + * csv, parquet etc + * + * @generated from field: string format = 1; + */ + format: string; + + /** + * @generated from field: flyteidl2.core.BlobType.BlobDimensionality dimensionality = 2; + */ + dimensionality: BlobType_BlobDimensionality; +}; + +/** + * Describes the message flyteidl2.core.BlobType. + * Use `create(BlobTypeSchema)` to create a new message. + */ +export const BlobTypeSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_types, 2); + +/** + * @generated from enum flyteidl2.core.BlobType.BlobDimensionality + */ +export enum BlobType_BlobDimensionality { + /** + * @generated from enum value: SINGLE = 0; + */ + SINGLE = 0, + + /** + * @generated from enum value: MULTIPART = 1; + */ + MULTIPART = 1, +} + +/** + * Describes the enum flyteidl2.core.BlobType.BlobDimensionality. + */ +export const BlobType_BlobDimensionalitySchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_types, 2, 0); + +/** + * Enables declaring enum types, with predefined string values + * For len(values) > 0, the first value in the ordered list is regarded as the default value. If you wish + * To provide no defaults, make the first value as undefined. + * + * @generated from message flyteidl2.core.EnumType + */ +export type EnumType = Message<"flyteidl2.core.EnumType"> & { + /** + * Predefined set of enum values. + * + * @generated from field: repeated string values = 1; + */ + values: string[]; +}; + +/** + * Describes the message flyteidl2.core.EnumType. + * Use `create(EnumTypeSchema)` to create a new message. + */ +export const EnumTypeSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_types, 3); + +/** + * Defines a tagged union type, also known as a variant (and formally as the sum type). + * + * A sum type S is defined by a sequence of types (A, B, C, ...), each tagged by a string tag + * A value of type S is constructed from a value of any of the variant types. The specific choice of type is recorded by + * storing the varaint's tag with the literal value and can be examined in runtime. + * + * Type S is typically written as + * S := Apple A | Banana B | Cantaloupe C | ... + * + * Notably, a nullable (optional) type is a sum type between some type X and the singleton type representing a null-value: + * Optional X := X | Null + * + * See also: https://en.wikipedia.org/wiki/Tagged_union + * + * @generated from message flyteidl2.core.UnionType + */ +export type UnionType = Message<"flyteidl2.core.UnionType"> & { + /** + * Predefined set of variants in union. + * + * @generated from field: repeated flyteidl2.core.LiteralType variants = 1; + */ + variants: LiteralType[]; +}; + +/** + * Describes the message flyteidl2.core.UnionType. + * Use `create(UnionTypeSchema)` to create a new message. + */ +export const UnionTypeSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_types, 4); + +/** + * Hints to improve type matching + * e.g. allows distinguishing output from custom type transformers + * even if the underlying IDL serialization matches. + * + * @generated from message flyteidl2.core.TypeStructure + */ +export type TypeStructure = Message<"flyteidl2.core.TypeStructure"> & { + /** + * Must exactly match for types to be castable + * + * @generated from field: string tag = 1; + */ + tag: string; + + /** + * dataclass_type only exists for dataclasses. + * This is used to resolve the type of the fields of dataclass + * The key is the field name, and the value is the literal type of the field + * e.g. For dataclass Foo, with fields a, and a is a string + * Foo.a will be resolved as a literal type of string from dataclass_type + * + * @generated from field: map dataclass_type = 2; + */ + dataclassType: { [key: string]: LiteralType }; +}; + +/** + * Describes the message flyteidl2.core.TypeStructure. + * Use `create(TypeStructureSchema)` to create a new message. + */ +export const TypeStructureSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_types, 5); + +/** + * TypeAnnotation encapsulates registration time information about a type. This can be used for various control-plane operations. TypeAnnotation will not be available at runtime when a task runs. + * + * @generated from message flyteidl2.core.TypeAnnotation + */ +export type TypeAnnotation = Message<"flyteidl2.core.TypeAnnotation"> & { + /** + * A arbitrary JSON payload to describe a type. + * + * @generated from field: google.protobuf.Struct annotations = 1; + */ + annotations?: JsonObject; +}; + +/** + * Describes the message flyteidl2.core.TypeAnnotation. + * Use `create(TypeAnnotationSchema)` to create a new message. + */ +export const TypeAnnotationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_types, 6); + +/** + * Defines a strong type to allow type checking between interfaces. + * + * @generated from message flyteidl2.core.LiteralType + */ +export type LiteralType = Message<"flyteidl2.core.LiteralType"> & { + /** + * @generated from oneof flyteidl2.core.LiteralType.type + */ + type: { + /** + * A simple type that can be compared one-to-one with another. + * + * @generated from field: flyteidl2.core.SimpleType simple = 1; + */ + value: SimpleType; + case: "simple"; + } | { + /** + * A complex type that requires matching of inner fields. + * + * @generated from field: flyteidl2.core.SchemaType schema = 2; + */ + value: SchemaType; + case: "schema"; + } | { + /** + * Defines the type of the value of a collection. Only homogeneous collections are allowed. + * + * @generated from field: flyteidl2.core.LiteralType collection_type = 3; + */ + value: LiteralType; + case: "collectionType"; + } | { + /** + * Defines the type of the value of a map type. The type of the key is always a string. + * + * @generated from field: flyteidl2.core.LiteralType map_value_type = 4; + */ + value: LiteralType; + case: "mapValueType"; + } | { + /** + * A blob might have specialized implementation details depending on associated metadata. + * + * @generated from field: flyteidl2.core.BlobType blob = 5; + */ + value: BlobType; + case: "blob"; + } | { + /** + * Defines an enum with pre-defined string values. + * + * @generated from field: flyteidl2.core.EnumType enum_type = 7; + */ + value: EnumType; + case: "enumType"; + } | { + /** + * Generalized schema support + * + * @generated from field: flyteidl2.core.StructuredDatasetType structured_dataset_type = 8; + */ + value: StructuredDatasetType; + case: "structuredDatasetType"; + } | { + /** + * Defines an union type with pre-defined LiteralTypes. + * + * @generated from field: flyteidl2.core.UnionType union_type = 10; + */ + value: UnionType; + case: "unionType"; + } | { case: undefined; value?: undefined }; + + /** + * This field contains type metadata that is descriptive of the type, but is NOT considered in type-checking. This might be used by + * consumers to identify special behavior or display extended information for the type. + * + * @generated from field: google.protobuf.Struct metadata = 6; + */ + metadata?: JsonObject; + + /** + * This field contains arbitrary data that might have special semantic + * meaning for the client but does not effect internal flyte behavior. + * + * @generated from field: flyteidl2.core.TypeAnnotation annotation = 9; + */ + annotation?: TypeAnnotation; + + /** + * Hints to improve type matching. + * + * @generated from field: flyteidl2.core.TypeStructure structure = 11; + */ + structure?: TypeStructure; +}; + +/** + * Describes the message flyteidl2.core.LiteralType. + * Use `create(LiteralTypeSchema)` to create a new message. + */ +export const LiteralTypeSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_types, 7); + +/** + * A reference to an output produced by a node. The type can be retrieved -and validated- from + * the underlying interface of the node. + * + * @generated from message flyteidl2.core.OutputReference + */ +export type OutputReference = Message<"flyteidl2.core.OutputReference"> & { + /** + * Node id must exist at the graph layer. + * + * @generated from field: string node_id = 1; + */ + nodeId: string; + + /** + * Variable name must refer to an output variable for the node. + * + * @generated from field: string var = 2; + */ + var: string; + + /** + * @generated from field: repeated flyteidl2.core.PromiseAttribute attr_path = 3; + */ + attrPath: PromiseAttribute[]; +}; + +/** + * Describes the message flyteidl2.core.OutputReference. + * Use `create(OutputReferenceSchema)` to create a new message. + */ +export const OutputReferenceSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_types, 8); + +/** + * @generated from message flyteidl2.core.PromiseAttribute + */ +export type PromiseAttribute = Message<"flyteidl2.core.PromiseAttribute"> & { + /** + * @generated from oneof flyteidl2.core.PromiseAttribute.value + */ + value: { + /** + * @generated from field: string string_value = 1; + */ + value: string; + case: "stringValue"; + } | { + /** + * @generated from field: int32 int_value = 2; + */ + value: number; + case: "intValue"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.core.PromiseAttribute. + * Use `create(PromiseAttributeSchema)` to create a new message. + */ +export const PromiseAttributeSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_types, 9); + +/** + * Represents an error thrown from a node. + * + * @generated from message flyteidl2.core.Error + */ +export type Error = Message<"flyteidl2.core.Error"> & { + /** + * The node id that threw the error. + * + * @generated from field: string failed_node_id = 1; + */ + failedNodeId: string; + + /** + * Error message thrown. + * + * @generated from field: string message = 2; + */ + message: string; +}; + +/** + * Describes the message flyteidl2.core.Error. + * Use `create(ErrorSchema)` to create a new message. + */ +export const ErrorSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_core_types, 10); + +/** + * Define a set of simple types. + * + * @generated from enum flyteidl2.core.SimpleType + */ +export enum SimpleType { + /** + * @generated from enum value: NONE = 0; + */ + NONE = 0, + + /** + * @generated from enum value: INTEGER = 1; + */ + INTEGER = 1, + + /** + * @generated from enum value: FLOAT = 2; + */ + FLOAT = 2, + + /** + * @generated from enum value: STRING = 3; + */ + STRING = 3, + + /** + * @generated from enum value: BOOLEAN = 4; + */ + BOOLEAN = 4, + + /** + * @generated from enum value: DATETIME = 5; + */ + DATETIME = 5, + + /** + * @generated from enum value: DURATION = 6; + */ + DURATION = 6, + + /** + * @generated from enum value: BINARY = 7; + */ + BINARY = 7, + + /** + * @generated from enum value: ERROR = 8; + */ + ERROR = 8, + + /** + * @generated from enum value: STRUCT = 9; + */ + STRUCT = 9, +} + +/** + * Describes the enum flyteidl2.core.SimpleType. + */ +export const SimpleTypeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_core_types, 0); + diff --git a/gen/ts/flyteidl2/dataproxy/dataproxy_service_pb.ts b/gen/ts/flyteidl2/dataproxy/dataproxy_service_pb.ts new file mode 100644 index 0000000000..76d4012417 --- /dev/null +++ b/gen/ts/flyteidl2/dataproxy/dataproxy_service_pb.ts @@ -0,0 +1,177 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/dataproxy/dataproxy_service.proto (package flyteidl2.dataproxy, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import { file_google_api_annotations } from "../../google/api/annotations_pb.ts"; +import type { Duration, Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_duration, file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import { file_protoc_gen_openapiv2_options_annotations } from "../../protoc-gen-openapiv2/options/annotations_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/dataproxy/dataproxy_service.proto. + */ +export const file_flyteidl2_dataproxy_dataproxy_service: GenFile = /*@__PURE__*/ + fileDesc("CitmbHl0ZWlkbDIvZGF0YXByb3h5L2RhdGFwcm94eV9zZXJ2aWNlLnByb3RvEhNmbHl0ZWlkbDIuZGF0YXByb3h5Io0CChtDcmVhdGVVcGxvYWRMb2NhdGlvblJlcXVlc3QSGAoHcHJvamVjdBgBIAEoCUIHukgEcgIQARIXCgZkb21haW4YAiABKAlCB7pIBHICEAESEAoIZmlsZW5hbWUYAyABKAkSLQoKZXhwaXJlc19pbhgEIAEoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJhdGlvbhIcCgtjb250ZW50X21kNRgFIAEoDEIHukgEegJoEBIVCg1maWxlbmFtZV9yb290GAYgASgJEiAKGGFkZF9jb250ZW50X21kNV9tZXRhZGF0YRgHIAEoCBILCgNvcmcYCCABKAkSFgoOY29udGVudF9sZW5ndGgYCSABKAMi9wEKHENyZWF0ZVVwbG9hZExvY2F0aW9uUmVzcG9uc2USEgoKc2lnbmVkX3VybBgBIAEoCRISCgpuYXRpdmVfdXJsGAIgASgJEi4KCmV4cGlyZXNfYXQYAyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEk8KB2hlYWRlcnMYBCADKAsyPi5mbHl0ZWlkbDIuZGF0YXByb3h5LkNyZWF0ZVVwbG9hZExvY2F0aW9uUmVzcG9uc2UuSGVhZGVyc0VudHJ5Gi4KDEhlYWRlcnNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBMrUCChBEYXRhUHJveHlTZXJ2aWNlEqACChRDcmVhdGVVcGxvYWRMb2NhdGlvbhIwLmZseXRlaWRsMi5kYXRhcHJveHkuQ3JlYXRlVXBsb2FkTG9jYXRpb25SZXF1ZXN0GjEuZmx5dGVpZGwyLmRhdGFwcm94eS5DcmVhdGVVcGxvYWRMb2NhdGlvblJlc3BvbnNlIqIBkkFNGktDcmVhdGVzIGEgd3JpdGUtb25seSBodHRwIGxvY2F0aW9uIHRoYXQgaXMgYWNjZXNzaWJsZSBmb3IgdGFza3MgYXQgcnVudGltZS6C0+STAkw6ASpaJzoBKiIiL2FwaS92MS9vcmcvZGF0YXByb3h5L2FydGlmYWN0X3VybiIeL2FwaS92MS9kYXRhcHJveHkvYXJ0aWZhY3RfdXJuQtgBChdjb20uZmx5dGVpZGwyLmRhdGFwcm94eUIVRGF0YXByb3h5U2VydmljZVByb3RvSAJQAVo3Z2l0aHViLmNvbS9mbHl0ZW9yZy9mbHl0ZS92Mi9nZW4vZ28vZmx5dGVpZGwyL2RhdGFwcm94eaICA0ZEWKoCE0ZseXRlaWRsMi5EYXRhcHJveHnKAhNGbHl0ZWlkbDJcRGF0YXByb3h54gIfRmx5dGVpZGwyXERhdGFwcm94eVxHUEJNZXRhZGF0YeoCFEZseXRlaWRsMjo6RGF0YXByb3h5YgZwcm90bzM", [file_buf_validate_validate, file_google_api_annotations, file_google_protobuf_duration, file_google_protobuf_timestamp, file_protoc_gen_openapiv2_options_annotations]); + +/** + * CreateUploadLocationRequest specifies the request for the CreateUploadLocation API. + * The data proxy service will generate a storage location with server-side configured prefixes. + * The generated path follows one of these patterns: + * - project/domain/(deterministic hash of content_md5)/filename (if filename is present); OR + * - project/domain/filename_root/filename (if filename_root and filename are present). + * + * @generated from message flyteidl2.dataproxy.CreateUploadLocationRequest + */ +export type CreateUploadLocationRequest = Message<"flyteidl2.dataproxy.CreateUploadLocationRequest"> & { + /** + * Project to create the upload location for. + * +required + * + * @generated from field: string project = 1; + */ + project: string; + + /** + * Domain to create the upload location for. + * +required + * + * @generated from field: string domain = 2; + */ + domain: string; + + /** + * Filename specifies the desired suffix for the generated location. E.g. `file.py` or `pre/fix/file.zip`. + * +optional. By default, the service generates a consistent name based on the default filename length provided in the global config.. + * + * @generated from field: string filename = 3; + */ + filename: string; + + /** + * ExpiresIn defines the requested expiration duration for the generated URL. The request will be rejected if this + * exceeds the platform's configured maximum. + * +optional. The default value comes from the global config. + * + * @generated from field: google.protobuf.Duration expires_in = 4; + */ + expiresIn?: Duration; + + /** + * ContentMD5 restricts the upload location to the specific MD5 provided. The MD5 hash will also appear in the + * generated path for verification. + * +required + * + * @generated from field: bytes content_md5 = 5; + */ + contentMd5: Uint8Array; + + /** + * FilenameRoot, if present, will be used instead of the MD5 hash in the path. When combined with filename, + * this makes the upload location deterministic. The native URL will still be prefixed by the upload location prefix + * configured in the data proxy. This option is useful when uploading multiple related files. + * +optional + * + * @generated from field: string filename_root = 6; + */ + filenameRoot: string; + + /** + * If true, the data proxy will add content_md5 to the Signed URL requirements, + * forcing clients to send this checksum with the object. + * This is required to enforce data integrity on backends like GCP, ensuring that + * the uploaded file matches the hash. + * + * @generated from field: bool add_content_md5_metadata = 7; + */ + addContentMd5Metadata: boolean; + + /** + * Org is the organization key applied to the resource. + * +optional + * + * @generated from field: string org = 8; + */ + org: string; + + /** + * ContentLength specifies the size of the content to be uploaded in bytes. + * This is validated against the platform's maximum upload size if provided. + * +optional + * + * @generated from field: int64 content_length = 9; + */ + contentLength: bigint; +}; + +/** + * Describes the message flyteidl2.dataproxy.CreateUploadLocationRequest. + * Use `create(CreateUploadLocationRequestSchema)` to create a new message. + */ +export const CreateUploadLocationRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_dataproxy_dataproxy_service, 0); + +/** + * CreateUploadLocationResponse specifies the response for the CreateUploadLocation API. + * + * @generated from message flyteidl2.dataproxy.CreateUploadLocationResponse + */ +export type CreateUploadLocationResponse = Message<"flyteidl2.dataproxy.CreateUploadLocationResponse"> & { + /** + * SignedUrl is the URL to use for uploading content (e.g. https://my-bucket.s3.amazonaws.com/randomstring/suffix.tar?X-...). + * + * @generated from field: string signed_url = 1; + */ + signedUrl: string; + + /** + * NativeUrl is the URL in the format of the configured storage provider (e.g. s3://my-bucket/randomstring/suffix.tar). + * + * @generated from field: string native_url = 2; + */ + nativeUrl: string; + + /** + * ExpiresAt defines when the signed URL will expire. + * + * @generated from field: google.protobuf.Timestamp expires_at = 3; + */ + expiresAt?: Timestamp; + + /** + * Headers are generated by the data proxy for the client. Clients must include these headers in the upload request. + * + * @generated from field: map headers = 4; + */ + headers: { [key: string]: string }; +}; + +/** + * Describes the message flyteidl2.dataproxy.CreateUploadLocationResponse. + * Use `create(CreateUploadLocationResponseSchema)` to create a new message. + */ +export const CreateUploadLocationResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_dataproxy_dataproxy_service, 1); + +/** + * DataProxyService provides an interface for managing data uploads and downloads. + * + * @generated from service flyteidl2.dataproxy.DataProxyService + */ +export const DataProxyService: GenService<{ + /** + * CreateUploadLocation generates a signed URL for uploading data to the configured storage backend. + * + * @generated from rpc flyteidl2.dataproxy.DataProxyService.CreateUploadLocation + */ + createUploadLocation: { + methodKind: "unary"; + input: typeof CreateUploadLocationRequestSchema; + output: typeof CreateUploadLocationResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_dataproxy_dataproxy_service, 0); + diff --git a/gen/ts/flyteidl2/event/cloudevents_pb.ts b/gen/ts/flyteidl2/event/cloudevents_pb.ts new file mode 100644 index 0000000000..a57da06ef4 --- /dev/null +++ b/gen/ts/flyteidl2/event/cloudevents_pb.ts @@ -0,0 +1,217 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/event/cloudevents.proto (package flyteidl2.event, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { ArtifactID } from "../core/artifact_id_pb.ts"; +import { file_flyteidl2_core_artifact_id } from "../core/artifact_id_pb.ts"; +import type { Identifier, TaskExecutionIdentifier, WorkflowExecutionIdentifier } from "../core/identifier_pb.ts"; +import { file_flyteidl2_core_identifier } from "../core/identifier_pb.ts"; +import type { TypedInterface } from "../core/interface_pb.ts"; +import { file_flyteidl2_core_interface } from "../core/interface_pb.ts"; +import type { NodeExecutionEvent, TaskExecutionEvent, WorkflowExecutionEvent } from "./event_pb.ts"; +import { file_flyteidl2_event_event } from "./event_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/event/cloudevents.proto. + */ +export const file_flyteidl2_event_cloudevents: GenFile = /*@__PURE__*/ + fileDesc("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", [file_flyteidl2_core_artifact_id, file_flyteidl2_core_identifier, file_flyteidl2_core_interface, file_flyteidl2_event_event]); + +/** + * This is the cloud event parallel to the raw WorkflowExecutionEvent message. It's filled in with additional + * information that downstream consumers may find useful. + * + * @generated from message flyteidl2.event.CloudEventWorkflowExecution + */ +export type CloudEventWorkflowExecution = Message<"flyteidl2.event.CloudEventWorkflowExecution"> & { + /** + * @generated from field: flyteidl2.event.WorkflowExecutionEvent raw_event = 1; + */ + rawEvent?: WorkflowExecutionEvent; + + /** + * @generated from field: flyteidl2.core.TypedInterface output_interface = 2; + */ + outputInterface?: TypedInterface; + + /** + * The following are ExecutionMetadata fields + * We can't have the ExecutionMetadata object directly because of import cycle + * + * @generated from field: repeated flyteidl2.core.ArtifactID artifact_ids = 3; + */ + artifactIds: ArtifactID[]; + + /** + * @generated from field: flyteidl2.core.WorkflowExecutionIdentifier reference_execution = 4; + */ + referenceExecution?: WorkflowExecutionIdentifier; + + /** + * @generated from field: string principal = 5; + */ + principal: string; + + /** + * The ID of the LP that generated the execution that generated the Artifact. + * Here for provenance information. + * Launch plan IDs are easier to get than workflow IDs so we'll use these for now. + * + * @generated from field: flyteidl2.core.Identifier launch_plan_id = 6; + */ + launchPlanId?: Identifier; + + /** + * We can't have the ExecutionMetadata object directly because of import cycle + * + * @generated from field: map labels = 7; + */ + labels: { [key: string]: string }; +}; + +/** + * Describes the message flyteidl2.event.CloudEventWorkflowExecution. + * Use `create(CloudEventWorkflowExecutionSchema)` to create a new message. + */ +export const CloudEventWorkflowExecutionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_event_cloudevents, 0); + +/** + * @generated from message flyteidl2.event.CloudEventNodeExecution + */ +export type CloudEventNodeExecution = Message<"flyteidl2.event.CloudEventNodeExecution"> & { + /** + * @generated from field: flyteidl2.event.NodeExecutionEvent raw_event = 1; + */ + rawEvent?: NodeExecutionEvent; + + /** + * The relevant task execution if applicable + * + * @generated from field: flyteidl2.core.TaskExecutionIdentifier task_exec_id = 2; + */ + taskExecId?: TaskExecutionIdentifier; + + /** + * The typed interface for the task that produced the event. + * + * @generated from field: flyteidl2.core.TypedInterface output_interface = 3; + */ + outputInterface?: TypedInterface; + + /** + * The following are ExecutionMetadata fields + * We can't have the ExecutionMetadata object directly because of import cycle + * + * @generated from field: repeated flyteidl2.core.ArtifactID artifact_ids = 4; + */ + artifactIds: ArtifactID[]; + + /** + * @generated from field: string principal = 5; + */ + principal: string; + + /** + * The ID of the LP that generated the execution that generated the Artifact. + * Here for provenance information. + * Launch plan IDs are easier to get than workflow IDs so we'll use these for now. + * + * @generated from field: flyteidl2.core.Identifier launch_plan_id = 6; + */ + launchPlanId?: Identifier; + + /** + * We can't have the ExecutionMetadata object directly because of import cycle + * + * @generated from field: map labels = 7; + */ + labels: { [key: string]: string }; +}; + +/** + * Describes the message flyteidl2.event.CloudEventNodeExecution. + * Use `create(CloudEventNodeExecutionSchema)` to create a new message. + */ +export const CloudEventNodeExecutionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_event_cloudevents, 1); + +/** + * @generated from message flyteidl2.event.CloudEventTaskExecution + */ +export type CloudEventTaskExecution = Message<"flyteidl2.event.CloudEventTaskExecution"> & { + /** + * @generated from field: flyteidl2.event.TaskExecutionEvent raw_event = 1; + */ + rawEvent?: TaskExecutionEvent; + + /** + * We can't have the ExecutionMetadata object directly because of import cycle + * + * @generated from field: map labels = 2; + */ + labels: { [key: string]: string }; +}; + +/** + * Describes the message flyteidl2.event.CloudEventTaskExecution. + * Use `create(CloudEventTaskExecutionSchema)` to create a new message. + */ +export const CloudEventTaskExecutionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_event_cloudevents, 2); + +/** + * This event is to be sent by Admin after it creates an execution. + * + * @generated from message flyteidl2.event.CloudEventExecutionStart + */ +export type CloudEventExecutionStart = Message<"flyteidl2.event.CloudEventExecutionStart"> & { + /** + * The execution created. + * + * @generated from field: flyteidl2.core.WorkflowExecutionIdentifier execution_id = 1; + */ + executionId?: WorkflowExecutionIdentifier; + + /** + * The launch plan used. + * + * @generated from field: flyteidl2.core.Identifier launch_plan_id = 2; + */ + launchPlanId?: Identifier; + + /** + * @generated from field: flyteidl2.core.Identifier workflow_id = 3; + */ + workflowId?: Identifier; + + /** + * Artifact inputs to the workflow execution for which we have the full Artifact ID. These are likely the result of artifact queries that are run. + * + * @generated from field: repeated flyteidl2.core.ArtifactID artifact_ids = 4; + */ + artifactIds: ArtifactID[]; + + /** + * Artifact inputs to the workflow execution for which we only have the tracking bit that's installed into the Literal's metadata by the Artifact service. + * + * @generated from field: repeated string artifact_trackers = 5; + */ + artifactTrackers: string[]; + + /** + * @generated from field: string principal = 6; + */ + principal: string; +}; + +/** + * Describes the message flyteidl2.event.CloudEventExecutionStart. + * Use `create(CloudEventExecutionStartSchema)` to create a new message. + */ +export const CloudEventExecutionStartSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_event_cloudevents, 3); + diff --git a/gen/ts/flyteidl2/event/event_pb.ts b/gen/ts/flyteidl2/event/event_pb.ts new file mode 100644 index 0000000000..f4abccaf5b --- /dev/null +++ b/gen/ts/flyteidl2/event/event_pb.ts @@ -0,0 +1,818 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/event/event.proto (package flyteidl2.event, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { CatalogCacheStatus, CatalogMetadata, CatalogReservation_Status } from "../core/catalog_pb.ts"; +import { file_flyteidl2_core_catalog } from "../core/catalog_pb.ts"; +import type { ExecutionError, LogContext, NodeExecution_Phase, TaskExecution_Phase, TaskLog, WorkflowExecution_Phase } from "../core/execution_pb.ts"; +import { file_flyteidl2_core_execution } from "../core/execution_pb.ts"; +import type { Identifier, NodeExecutionIdentifier, TaskExecutionIdentifier, WorkflowExecutionIdentifier } from "../core/identifier_pb.ts"; +import { file_flyteidl2_core_identifier } from "../core/identifier_pb.ts"; +import type { LiteralMap } from "../core/literals_pb.ts"; +import { file_flyteidl2_core_literals } from "../core/literals_pb.ts"; +import type { Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_struct, file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import type { JsonObject, Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/event/event.proto. + */ +export const file_flyteidl2_event_event: GenFile = /*@__PURE__*/ + fileDesc("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", [file_flyteidl2_core_catalog, file_flyteidl2_core_execution, file_flyteidl2_core_identifier, file_flyteidl2_core_literals, file_google_protobuf_struct, file_google_protobuf_timestamp]); + +/** + * @generated from message flyteidl2.event.WorkflowExecutionEvent + */ +export type WorkflowExecutionEvent = Message<"flyteidl2.event.WorkflowExecutionEvent"> & { + /** + * Workflow execution id + * + * @generated from field: flyteidl2.core.WorkflowExecutionIdentifier execution_id = 1; + */ + executionId?: WorkflowExecutionIdentifier; + + /** + * the id of the originator (Propeller) of the event + * + * @generated from field: string producer_id = 2; + */ + producerId: string; + + /** + * @generated from field: flyteidl2.core.WorkflowExecution.Phase phase = 3; + */ + phase: WorkflowExecution_Phase; + + /** + * This timestamp represents when the original event occurred, it is generated + * by the executor of the workflow. + * + * @generated from field: google.protobuf.Timestamp occurred_at = 4; + */ + occurredAt?: Timestamp; + + /** + * @generated from oneof flyteidl2.event.WorkflowExecutionEvent.output_result + */ + outputResult: { + /** + * URL to the output of the execution, it encodes all the information + * including Cloud source provider. ie., s3://... + * + * @generated from field: string output_uri = 5; + */ + value: string; + case: "outputUri"; + } | { + /** + * Error information for the execution + * + * @generated from field: flyteidl2.core.ExecutionError error = 6; + */ + value: ExecutionError; + case: "error"; + } | { + /** + * Raw output data produced by this workflow execution. + * + * @generated from field: flyteidl2.core.LiteralMap output_data = 7; + */ + value: LiteralMap; + case: "outputData"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.event.WorkflowExecutionEvent. + * Use `create(WorkflowExecutionEventSchema)` to create a new message. + */ +export const WorkflowExecutionEventSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_event_event, 0); + +/** + * @generated from message flyteidl2.event.NodeExecutionEvent + */ +export type NodeExecutionEvent = Message<"flyteidl2.event.NodeExecutionEvent"> & { + /** + * Unique identifier for this node execution + * + * @generated from field: flyteidl2.core.NodeExecutionIdentifier id = 1; + */ + id?: NodeExecutionIdentifier; + + /** + * the id of the originator (Propeller) of the event + * + * @generated from field: string producer_id = 2; + */ + producerId: string; + + /** + * @generated from field: flyteidl2.core.NodeExecution.Phase phase = 3; + */ + phase: NodeExecution_Phase; + + /** + * This timestamp represents when the original event occurred, it is generated + * by the executor of the node. + * + * @generated from field: google.protobuf.Timestamp occurred_at = 4; + */ + occurredAt?: Timestamp; + + /** + * @generated from oneof flyteidl2.event.NodeExecutionEvent.input_value + */ + inputValue: { + /** + * @generated from field: string input_uri = 5; + */ + value: string; + case: "inputUri"; + } | { + /** + * Raw input data consumed by this node execution. + * + * @generated from field: flyteidl2.core.LiteralMap input_data = 20; + */ + value: LiteralMap; + case: "inputData"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof flyteidl2.event.NodeExecutionEvent.output_result + */ + outputResult: { + /** + * URL to the output of the execution, it encodes all the information + * including Cloud source provider. ie., s3://... + * + * @generated from field: string output_uri = 6; + */ + value: string; + case: "outputUri"; + } | { + /** + * Error information for the execution + * + * @generated from field: flyteidl2.core.ExecutionError error = 7; + */ + value: ExecutionError; + case: "error"; + } | { + /** + * Raw output data produced by this node execution. + * + * @generated from field: flyteidl2.core.LiteralMap output_data = 15; + */ + value: LiteralMap; + case: "outputData"; + } | { case: undefined; value?: undefined }; + + /** + * Additional metadata to do with this event's node target based + * on the node type + * + * @generated from oneof flyteidl2.event.NodeExecutionEvent.target_metadata + */ + targetMetadata: { + /** + * @generated from field: flyteidl2.event.WorkflowNodeMetadata workflow_node_metadata = 8; + */ + value: WorkflowNodeMetadata; + case: "workflowNodeMetadata"; + } | { + /** + * @generated from field: flyteidl2.event.TaskNodeMetadata task_node_metadata = 14; + */ + value: TaskNodeMetadata; + case: "taskNodeMetadata"; + } | { case: undefined; value?: undefined }; + + /** + * [To be deprecated] Specifies which task (if any) launched this node. + * + * @generated from field: flyteidl2.event.ParentTaskExecutionMetadata parent_task_metadata = 9; + */ + parentTaskMetadata?: ParentTaskExecutionMetadata; + + /** + * Specifies the parent node of the current node execution. Node executions at level zero will not have a parent node. + * + * @generated from field: flyteidl2.event.ParentNodeExecutionMetadata parent_node_metadata = 10; + */ + parentNodeMetadata?: ParentNodeExecutionMetadata; + + /** + * Retry group to indicate grouping of nodes by retries + * + * @generated from field: string retry_group = 11; + */ + retryGroup: string; + + /** + * Identifier of the node in the original workflow/graph + * This maps to value of WorkflowTemplate.nodes[X].id + * + * @generated from field: string spec_node_id = 12; + */ + specNodeId: string; + + /** + * Friendly readable name for the node + * + * @generated from field: string node_name = 13; + */ + nodeName: string; + + /** + * @generated from field: int32 event_version = 16; + */ + eventVersion: number; + + /** + * Whether this node launched a subworkflow. + * + * @generated from field: bool is_parent = 17; + */ + isParent: boolean; + + /** + * Whether this node yielded a dynamic workflow. + * + * @generated from field: bool is_dynamic = 18; + */ + isDynamic: boolean; + + /** + * String location uniquely identifying where the deck HTML file is + * NativeUrl specifies the url in the format of the configured storage provider (e.g. s3://my-bucket/randomstring/suffix.tar) + * + * @generated from field: string deck_uri = 19; + */ + deckUri: string; + + /** + * This timestamp represents the instant when the event was reported by the executing framework. For example, + * when first processing a node the `occurred_at` timestamp should be the instant propeller makes progress, so when + * literal inputs are initially copied. The event however will not be sent until after the copy completes. + * Extracting both of these timestamps facilitates a more accurate portrayal of the evaluation time-series. + * + * @generated from field: google.protobuf.Timestamp reported_at = 21; + */ + reportedAt?: Timestamp; + + /** + * Indicates if this node is an ArrayNode. + * + * @generated from field: bool is_array = 22; + */ + isArray: boolean; + + /** + * So that Admin doesn't have to rebuild the node execution graph to find the target entity, propeller will fill this + * in optionally - currently this is only filled in for subworkflows. This is the ID of the subworkflow corresponding + * to this node execution. It is difficult to find because Admin only sees one node at a time. A subworkflow could be + * nested multiple layers deep, and you'd need to access the correct workflow template to know the target subworkflow. + * + * @generated from field: flyteidl2.core.Identifier target_entity = 23; + */ + targetEntity?: Identifier; + + /** + * Tasks and subworkflows (but not launch plans) that are run within a dynamic task are effectively independent of + * the tasks that are registered in Admin's db. Confusingly, they are often identical, but sometimes they are not + * even registered at all. Similar to the target_entity field, at the time Admin receives this event, it has no idea + * if the relevant execution entity is was registered, or dynamic. This field indicates that the target_entity ID, + * as well as task IDs in any corresponding Task Executions, should not be used to looked up the task in Admin's db. + * + * @generated from field: bool is_in_dynamic_chain = 24; + */ + isInDynamicChain: boolean; + + /** + * Whether this node launched an eager task. + * + * @generated from field: bool is_eager = 25; + */ + isEager: boolean; +}; + +/** + * Describes the message flyteidl2.event.NodeExecutionEvent. + * Use `create(NodeExecutionEventSchema)` to create a new message. + */ +export const NodeExecutionEventSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_event_event, 1); + +/** + * For Workflow Nodes we need to send information about the workflow that's launched + * + * @generated from message flyteidl2.event.WorkflowNodeMetadata + */ +export type WorkflowNodeMetadata = Message<"flyteidl2.event.WorkflowNodeMetadata"> & { + /** + * @generated from field: flyteidl2.core.WorkflowExecutionIdentifier execution_id = 1; + */ + executionId?: WorkflowExecutionIdentifier; +}; + +/** + * Describes the message flyteidl2.event.WorkflowNodeMetadata. + * Use `create(WorkflowNodeMetadataSchema)` to create a new message. + */ +export const WorkflowNodeMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_event_event, 2); + +/** + * @generated from message flyteidl2.event.TaskNodeMetadata + */ +export type TaskNodeMetadata = Message<"flyteidl2.event.TaskNodeMetadata"> & { + /** + * Captures the status of caching for this execution. + * + * @generated from field: flyteidl2.core.CatalogCacheStatus cache_status = 1; + */ + cacheStatus: CatalogCacheStatus; + + /** + * This structure carries the catalog artifact information + * + * @generated from field: flyteidl2.core.CatalogMetadata catalog_key = 2; + */ + catalogKey?: CatalogMetadata; + + /** + * Captures the status of cache reservations for this execution. + * + * @generated from field: flyteidl2.core.CatalogReservation.Status reservation_status = 3; + */ + reservationStatus: CatalogReservation_Status; + + /** + * The latest checkpoint location + * + * @generated from field: string checkpoint_uri = 4; + */ + checkpointUri: string; +}; + +/** + * Describes the message flyteidl2.event.TaskNodeMetadata. + * Use `create(TaskNodeMetadataSchema)` to create a new message. + */ +export const TaskNodeMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_event_event, 3); + +/** + * @generated from message flyteidl2.event.ParentTaskExecutionMetadata + */ +export type ParentTaskExecutionMetadata = Message<"flyteidl2.event.ParentTaskExecutionMetadata"> & { + /** + * @generated from field: flyteidl2.core.TaskExecutionIdentifier id = 1; + */ + id?: TaskExecutionIdentifier; +}; + +/** + * Describes the message flyteidl2.event.ParentTaskExecutionMetadata. + * Use `create(ParentTaskExecutionMetadataSchema)` to create a new message. + */ +export const ParentTaskExecutionMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_event_event, 4); + +/** + * @generated from message flyteidl2.event.ParentNodeExecutionMetadata + */ +export type ParentNodeExecutionMetadata = Message<"flyteidl2.event.ParentNodeExecutionMetadata"> & { + /** + * Unique identifier of the parent node id within the execution + * This is value of core.NodeExecutionIdentifier.node_id of the parent node + * + * @generated from field: string node_id = 1; + */ + nodeId: string; +}; + +/** + * Describes the message flyteidl2.event.ParentNodeExecutionMetadata. + * Use `create(ParentNodeExecutionMetadataSchema)` to create a new message. + */ +export const ParentNodeExecutionMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_event_event, 5); + +/** + * @generated from message flyteidl2.event.EventReason + */ +export type EventReason = Message<"flyteidl2.event.EventReason"> & { + /** + * An explanation for this event + * + * @generated from field: string reason = 1; + */ + reason: string; + + /** + * The time this reason occurred + * + * @generated from field: google.protobuf.Timestamp occurred_at = 2; + */ + occurredAt?: Timestamp; +}; + +/** + * Describes the message flyteidl2.event.EventReason. + * Use `create(EventReasonSchema)` to create a new message. + */ +export const EventReasonSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_event_event, 6); + +/** + * Plugin specific execution event information. For tasks like Python, Hive, Spark, DynamicJob. + * + * @generated from message flyteidl2.event.TaskExecutionEvent + */ +export type TaskExecutionEvent = Message<"flyteidl2.event.TaskExecutionEvent"> & { + /** + * ID of the task. In combination with the retryAttempt this will indicate + * the task execution uniquely for a given parent node execution. + * + * @generated from field: flyteidl2.core.Identifier task_id = 1; + */ + taskId?: Identifier; + + /** + * A task execution is always kicked off by a node execution, the event consumer + * will use the parent_id to relate the task to it's parent node execution + * + * @generated from field: flyteidl2.core.NodeExecutionIdentifier parent_node_execution_id = 2; + */ + parentNodeExecutionId?: NodeExecutionIdentifier; + + /** + * retry attempt number for this task, ie., 2 for the second attempt + * + * @generated from field: uint32 retry_attempt = 3; + */ + retryAttempt: number; + + /** + * Phase associated with the event + * + * @generated from field: flyteidl2.core.TaskExecution.Phase phase = 4; + */ + phase: TaskExecution_Phase; + + /** + * id of the process that sent this event, mainly for trace debugging + * + * @generated from field: string producer_id = 5; + */ + producerId: string; + + /** + * log information for the task execution + * + * @generated from field: repeated flyteidl2.core.TaskLog logs = 6; + */ + logs: TaskLog[]; + + /** + * This timestamp represents when the original event occurred, it is generated + * by the executor of the task. + * + * @generated from field: google.protobuf.Timestamp occurred_at = 7; + */ + occurredAt?: Timestamp; + + /** + * @generated from oneof flyteidl2.event.TaskExecutionEvent.input_value + */ + inputValue: { + /** + * URI of the input file, it encodes all the information + * including Cloud source provider. ie., s3://... + * + * @generated from field: string input_uri = 8; + */ + value: string; + case: "inputUri"; + } | { + /** + * Raw input data consumed by this task execution. + * + * @generated from field: flyteidl2.core.LiteralMap input_data = 19; + */ + value: LiteralMap; + case: "inputData"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from oneof flyteidl2.event.TaskExecutionEvent.output_result + */ + outputResult: { + /** + * URI to the output of the execution, it will be in a format that encodes all the information + * including Cloud source provider. ie., s3://... + * + * @generated from field: string output_uri = 9; + */ + value: string; + case: "outputUri"; + } | { + /** + * Error information for the execution + * + * @generated from field: flyteidl2.core.ExecutionError error = 10; + */ + value: ExecutionError; + case: "error"; + } | { + /** + * Raw output data produced by this task execution. + * + * @generated from field: flyteidl2.core.LiteralMap output_data = 17; + */ + value: LiteralMap; + case: "outputData"; + } | { case: undefined; value?: undefined }; + + /** + * Custom data that the task plugin sends back. This is extensible to allow various plugins in the system. + * + * @generated from field: google.protobuf.Struct custom_info = 11; + */ + customInfo?: JsonObject; + + /** + * Some phases, like RUNNING, can send multiple events with changed metadata (new logs, additional custom_info, etc) + * that should be recorded regardless of the lack of phase change. + * The version field should be incremented when metadata changes across the duration of an individual phase. + * + * @generated from field: uint32 phase_version = 12; + */ + phaseVersion: number; + + /** + * An optional explanation for the phase transition. + * Deprecated: Use reasons instead. + * + * @generated from field: string reason = 13 [deprecated = true]; + * @deprecated + */ + reason: string; + + /** + * An optional list of explanations for the phase transition. + * + * @generated from field: repeated flyteidl2.event.EventReason reasons = 21; + */ + reasons: EventReason[]; + + /** + * A predefined yet extensible Task type identifier. If the task definition is already registered in flyte admin + * this type will be identical, but not all task executions necessarily use pre-registered definitions and this + * type is useful to render the task in the UI, filter task executions, etc. + * + * @generated from field: string task_type = 14; + */ + taskType: string; + + /** + * Metadata around how a task was executed. + * + * @generated from field: flyteidl2.event.TaskExecutionMetadata metadata = 16; + */ + metadata?: TaskExecutionMetadata; + + /** + * The event version is used to indicate versioned changes in how data is reported using this + * proto message. For example, event_verison > 0 means that maps tasks report logs using the + * TaskExecutionMetadata ExternalResourceInfo fields for each subtask rather than the TaskLog + * in this message. + * + * @generated from field: int32 event_version = 18; + */ + eventVersion: number; + + /** + * This timestamp represents the instant when the event was reported by the executing framework. For example, a k8s + * pod task may be marked completed at (ie. `occurred_at`) the instant the container running user code completes, + * but this event will not be reported until the pod is marked as completed. Extracting both of these timestamps + * facilitates a more accurate portrayal of the evaluation time-series. + * + * @generated from field: google.protobuf.Timestamp reported_at = 20; + */ + reportedAt?: Timestamp; + + /** + * Contains metadata required to identify logs related to this task execution + * + * @generated from field: flyteidl2.core.LogContext log_context = 22; + */ + logContext?: LogContext; +}; + +/** + * Describes the message flyteidl2.event.TaskExecutionEvent. + * Use `create(TaskExecutionEventSchema)` to create a new message. + */ +export const TaskExecutionEventSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_event_event, 7); + +/** + * This message contains metadata about external resources produced or used by a specific task execution. + * + * @generated from message flyteidl2.event.ExternalResourceInfo + */ +export type ExternalResourceInfo = Message<"flyteidl2.event.ExternalResourceInfo"> & { + /** + * Identifier for an external resource created by this task execution, for example Qubole query ID or presto query ids. + * + * @generated from field: string external_id = 1; + */ + externalId: string; + + /** + * A unique index for the external resource with respect to all external resources for this task. Although the + * identifier may change between task reporting events or retries, this will remain the same to enable aggregating + * information from multiple reports. + * + * @generated from field: uint32 index = 2; + */ + index: number; + + /** + * Retry attempt number for this external resource, ie., 2 for the second attempt + * + * @generated from field: uint32 retry_attempt = 3; + */ + retryAttempt: number; + + /** + * Phase associated with the external resource + * + * @generated from field: flyteidl2.core.TaskExecution.Phase phase = 4; + */ + phase: TaskExecution_Phase; + + /** + * Captures the status of caching for this external resource execution. + * + * @generated from field: flyteidl2.core.CatalogCacheStatus cache_status = 5; + */ + cacheStatus: CatalogCacheStatus; + + /** + * log information for the external resource execution + * + * @generated from field: repeated flyteidl2.core.TaskLog logs = 6; + */ + logs: TaskLog[]; + + /** + * Additional metadata to do with this event's node target based on the node type. We are + * explicitly not including the task_node_metadata here because it is not clear if it is needed. + * If we decide to include in the future, we should deprecate the cache_status field. + * + * @generated from oneof flyteidl2.event.ExternalResourceInfo.target_metadata + */ + targetMetadata: { + /** + * @generated from field: flyteidl2.event.WorkflowNodeMetadata workflow_node_metadata = 7; + */ + value: WorkflowNodeMetadata; + case: "workflowNodeMetadata"; + } | { case: undefined; value?: undefined }; + + /** + * Extensible field for custom, plugin-specific info + * + * @generated from field: google.protobuf.Struct custom_info = 8; + */ + customInfo?: JsonObject; + + /** + * Contains metadata required to identify logs related to this task execution + * + * @generated from field: flyteidl2.core.LogContext log_context = 9; + */ + logContext?: LogContext; +}; + +/** + * Describes the message flyteidl2.event.ExternalResourceInfo. + * Use `create(ExternalResourceInfoSchema)` to create a new message. + */ +export const ExternalResourceInfoSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_event_event, 8); + +/** + * This message holds task execution metadata specific to resource allocation used to manage concurrent + * executions for a project namespace. + * + * @generated from message flyteidl2.event.ResourcePoolInfo + */ +export type ResourcePoolInfo = Message<"flyteidl2.event.ResourcePoolInfo"> & { + /** + * Unique resource ID used to identify this execution when allocating a token. + * + * @generated from field: string allocation_token = 1; + */ + allocationToken: string; + + /** + * Namespace under which this task execution requested an allocation token. + * + * @generated from field: string namespace = 2; + */ + namespace: string; +}; + +/** + * Describes the message flyteidl2.event.ResourcePoolInfo. + * Use `create(ResourcePoolInfoSchema)` to create a new message. + */ +export const ResourcePoolInfoSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_event_event, 9); + +/** + * Holds metadata around how a task was executed. + * As a task transitions across event phases during execution some attributes, such its generated name, generated external resources, + * and more may grow in size but not change necessarily based on the phase transition that sparked the event update. + * Metadata is a container for these attributes across the task execution lifecycle. + * + * @generated from message flyteidl2.event.TaskExecutionMetadata + */ +export type TaskExecutionMetadata = Message<"flyteidl2.event.TaskExecutionMetadata"> & { + /** + * Unique, generated name for this task execution used by the backend. + * + * @generated from field: string generated_name = 1; + */ + generatedName: string; + + /** + * Additional data on external resources on other back-ends or platforms (e.g. Hive, Qubole, etc) launched by this task execution. + * + * @generated from field: repeated flyteidl2.event.ExternalResourceInfo external_resources = 2; + */ + externalResources: ExternalResourceInfo[]; + + /** + * Includes additional data on concurrent resource management used during execution.. + * This is a repeated field because a plugin can request multiple resource allocations during execution. + * + * @generated from field: repeated flyteidl2.event.ResourcePoolInfo resource_pool_info = 3; + */ + resourcePoolInfo: ResourcePoolInfo[]; + + /** + * The identifier of the plugin used to execute this task. + * + * @generated from field: string plugin_identifier = 4; + */ + pluginIdentifier: string; + + /** + * @generated from field: flyteidl2.event.TaskExecutionMetadata.InstanceClass instance_class = 16; + */ + instanceClass: TaskExecutionMetadata_InstanceClass; +}; + +/** + * Describes the message flyteidl2.event.TaskExecutionMetadata. + * Use `create(TaskExecutionMetadataSchema)` to create a new message. + */ +export const TaskExecutionMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_event_event, 10); + +/** + * Includes the broad category of machine used for this specific task execution. + * + * @generated from enum flyteidl2.event.TaskExecutionMetadata.InstanceClass + */ +export enum TaskExecutionMetadata_InstanceClass { + /** + * The default instance class configured for the flyte application platform. + * + * @generated from enum value: DEFAULT = 0; + */ + DEFAULT = 0, + + /** + * The instance class configured for interruptible tasks. + * + * @generated from enum value: INTERRUPTIBLE = 1; + */ + INTERRUPTIBLE = 1, +} + +/** + * Describes the enum flyteidl2.event.TaskExecutionMetadata.InstanceClass. + */ +export const TaskExecutionMetadata_InstanceClassSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_event_event, 10, 0); + diff --git a/gen/ts/flyteidl2/imagebuilder/definition_pb.ts b/gen/ts/flyteidl2/imagebuilder/definition_pb.ts new file mode 100644 index 0000000000..a336732eb7 --- /dev/null +++ b/gen/ts/flyteidl2/imagebuilder/definition_pb.ts @@ -0,0 +1,535 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/imagebuilder/definition.proto (package flyteidl2.imagebuilder, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { Secret } from "../core/security_pb.ts"; +import { file_flyteidl2_core_security } from "../core/security_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/imagebuilder/definition.proto. + */ +export const file_flyteidl2_imagebuilder_definition: GenFile = /*@__PURE__*/ + fileDesc("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", [file_buf_validate_validate, file_flyteidl2_core_security]); + +/** + * ImageIdentifier is how to identify an image + * + * @generated from message flyteidl2.imagebuilder.ImageIdentifier + */ +export type ImageIdentifier = Message<"flyteidl2.imagebuilder.ImageIdentifier"> & { + /** + * @generated from field: string name = 1; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.imagebuilder.ImageIdentifier. + * Use `create(ImageIdentifierSchema)` to create a new message. + */ +export const ImageIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_imagebuilder_definition, 0); + +/** + * Simple container to surface if image exists + * + * @generated from message flyteidl2.imagebuilder.Image + */ +export type Image = Message<"flyteidl2.imagebuilder.Image"> & { + /** + * @generated from field: flyteidl2.imagebuilder.ImageIdentifier id = 1; + */ + id?: ImageIdentifier; + + /** + * Fully qualified, pullable, image name + * + * @generated from field: string fqin = 2; + */ + fqin: string; +}; + +/** + * Describes the message flyteidl2.imagebuilder.Image. + * Use `create(ImageSchema)` to create a new message. + */ +export const ImageSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_imagebuilder_definition, 1); + +/** + * AptPackages defines a list of apt packages to install in the image. + * + * @generated from message flyteidl2.imagebuilder.AptPackages + */ +export type AptPackages = Message<"flyteidl2.imagebuilder.AptPackages"> & { + /** + * List of apt packages to install + * + * @generated from field: repeated string packages = 1; + */ + packages: string[]; + + /** + * @generated from field: repeated flyteidl2.core.Secret secret_mounts = 2; + */ + secretMounts: Secret[]; +}; + +/** + * Describes the message flyteidl2.imagebuilder.AptPackages. + * Use `create(AptPackagesSchema)` to create a new message. + */ +export const AptPackagesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_imagebuilder_definition, 2); + +/** + * PipOptions defines options for pip packages to install in the image. + * + * @generated from message flyteidl2.imagebuilder.PipOptions + */ +export type PipOptions = Message<"flyteidl2.imagebuilder.PipOptions"> & { + /** + * Optional index URL for pip packages + * + * @generated from field: string index_url = 2; + */ + indexUrl: string; + + /** + * Optional list of extra index URLs for pip packages + * + * @generated from field: repeated string extra_index_urls = 3; + */ + extraIndexUrls: string[]; + + /** + * Optional pre-release flag for pip packages + * + * @generated from field: bool pre = 4; + */ + pre: boolean; + + /** + * Optional extra arguments for pip install command + * + * @generated from field: string extra_args = 5; + */ + extraArgs: string; +}; + +/** + * Describes the message flyteidl2.imagebuilder.PipOptions. + * Use `create(PipOptionsSchema)` to create a new message. + */ +export const PipOptionsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_imagebuilder_definition, 3); + +/** + * PipPackages defines a list of pip packages to install in the image. + * + * @generated from message flyteidl2.imagebuilder.PipPackages + */ +export type PipPackages = Message<"flyteidl2.imagebuilder.PipPackages"> & { + /** + * List of pip packages to install + * + * @generated from field: repeated string packages = 1; + */ + packages: string[]; + + /** + * Options for pip packages. + * + * @generated from field: flyteidl2.imagebuilder.PipOptions options = 2; + */ + options?: PipOptions; + + /** + * @generated from field: repeated flyteidl2.core.Secret secret_mounts = 3; + */ + secretMounts: Secret[]; +}; + +/** + * Describes the message flyteidl2.imagebuilder.PipPackages. + * Use `create(PipPackagesSchema)` to create a new message. + */ +export const PipPackagesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_imagebuilder_definition, 4); + +/** + * Requirements defines a python requirements file to use in the image. + * + * @generated from message flyteidl2.imagebuilder.Requirements + */ +export type Requirements = Message<"flyteidl2.imagebuilder.Requirements"> & { + /** + * The requirements file to use. + * + * @generated from field: string file = 1; + */ + file: string; + + /** + * Options for pip packages. + * + * @generated from field: flyteidl2.imagebuilder.PipOptions options = 2; + */ + options?: PipOptions; + + /** + * @generated from field: repeated flyteidl2.core.Secret secret_mounts = 3; + */ + secretMounts: Secret[]; +}; + +/** + * Describes the message flyteidl2.imagebuilder.Requirements. + * Use `create(RequirementsSchema)` to create a new message. + */ +export const RequirementsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_imagebuilder_definition, 5); + +/** + * @generated from message flyteidl2.imagebuilder.PythonWheels + */ +export type PythonWheels = Message<"flyteidl2.imagebuilder.PythonWheels"> & { + /** + * The directory containing Python wheel files. + * + * @generated from field: string dir = 1; + */ + dir: string; + + /** + * Options for pip packages. + * + * @generated from field: flyteidl2.imagebuilder.PipOptions options = 2; + */ + options?: PipOptions; + + /** + * @generated from field: repeated flyteidl2.core.Secret secret_mounts = 3; + */ + secretMounts: Secret[]; +}; + +/** + * Describes the message flyteidl2.imagebuilder.PythonWheels. + * Use `create(PythonWheelsSchema)` to create a new message. + */ +export const PythonWheelsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_imagebuilder_definition, 6); + +/** + * UVProject defines a UV project configuration, which includes + * a pyproject.toml file and a uvlock file. + * + * @generated from message flyteidl2.imagebuilder.UVProject + */ +export type UVProject = Message<"flyteidl2.imagebuilder.UVProject"> & { + /** + * @generated from field: string pyproject = 1; + */ + pyproject: string; + + /** + * @generated from field: string uvlock = 2; + */ + uvlock: string; + + /** + * Options for pip packages. + * + * @generated from field: flyteidl2.imagebuilder.PipOptions options = 3; + */ + options?: PipOptions; + + /** + * @generated from field: repeated flyteidl2.core.Secret secret_mounts = 4; + */ + secretMounts: Secret[]; +}; + +/** + * Describes the message flyteidl2.imagebuilder.UVProject. + * Use `create(UVProjectSchema)` to create a new message. + */ +export const UVProjectSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_imagebuilder_definition, 7); + +/** + * Commands defines a list of commands to run in the image. + * + * @generated from message flyteidl2.imagebuilder.Commands + */ +export type Commands = Message<"flyteidl2.imagebuilder.Commands"> & { + /** + * The command to run. + * + * @generated from field: repeated string cmd = 2; + */ + cmd: string[]; + + /** + * @generated from field: repeated flyteidl2.core.Secret secret_mounts = 3; + */ + secretMounts: Secret[]; +}; + +/** + * Describes the message flyteidl2.imagebuilder.Commands. + * Use `create(CommandsSchema)` to create a new message. + */ +export const CommandsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_imagebuilder_definition, 8); + +/** + * WorkDir defines the working directory to set in the image. + * + * @generated from message flyteidl2.imagebuilder.WorkDir + */ +export type WorkDir = Message<"flyteidl2.imagebuilder.WorkDir"> & { + /** + * The working directory to use. + * + * @generated from field: string workdir = 1; + */ + workdir: string; +}; + +/** + * Describes the message flyteidl2.imagebuilder.WorkDir. + * Use `create(WorkDirSchema)` to create a new message. + */ +export const WorkDirSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_imagebuilder_definition, 9); + +/** + * CopyConfig defines a configuration for copying files/directories into the image. + * + * @generated from message flyteidl2.imagebuilder.CopyConfig + */ +export type CopyConfig = Message<"flyteidl2.imagebuilder.CopyConfig"> & { + /** + * The source directory to copy from. + * + * @generated from field: string src = 1; + */ + src: string; + + /** + * The destination directory to copy to. + * + * @generated from field: string dst = 2; + */ + dst: string; +}; + +/** + * Describes the message flyteidl2.imagebuilder.CopyConfig. + * Use `create(CopyConfigSchema)` to create a new message. + */ +export const CopyConfigSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_imagebuilder_definition, 10); + +/** + * Env defines environment to set in the image. + * + * @generated from message flyteidl2.imagebuilder.Env + */ +export type Env = Message<"flyteidl2.imagebuilder.Env"> & { + /** + * Environment variables to set in the image. + * + * @generated from field: map env_variables = 1; + */ + envVariables: { [key: string]: string }; +}; + +/** + * Describes the message flyteidl2.imagebuilder.Env. + * Use `create(EnvSchema)` to create a new message. + */ +export const EnvSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_imagebuilder_definition, 11); + +/** + * @generated from message flyteidl2.imagebuilder.PoetryProject + */ +export type PoetryProject = Message<"flyteidl2.imagebuilder.PoetryProject"> & { + /** + * @generated from field: string pyproject = 1; + */ + pyproject: string; + + /** + * @generated from field: string poetry_lock = 2; + */ + poetryLock: string; + + /** + * Optional extra arguments for poetry install command + * + * @generated from field: string extra_args = 3; + */ + extraArgs: string; + + /** + * @generated from field: repeated flyteidl2.core.Secret secret_mounts = 4; + */ + secretMounts: Secret[]; +}; + +/** + * Describes the message flyteidl2.imagebuilder.PoetryProject. + * Use `create(PoetryProjectSchema)` to create a new message. + */ +export const PoetryProjectSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_imagebuilder_definition, 12); + +/** + * Layer defines a layer in the image, which can be one of several types. + * + * @generated from message flyteidl2.imagebuilder.Layer + */ +export type Layer = Message<"flyteidl2.imagebuilder.Layer"> & { + /** + * @generated from oneof flyteidl2.imagebuilder.Layer.layer + */ + layer: { + /** + * Apt packages to install. + * + * @generated from field: flyteidl2.imagebuilder.AptPackages apt_packages = 1; + */ + value: AptPackages; + case: "aptPackages"; + } | { + /** + * Python packages to install. + * + * @generated from field: flyteidl2.imagebuilder.PipPackages pip_packages = 2; + */ + value: PipPackages; + case: "pipPackages"; + } | { + /** + * Custom command to run. + * + * @generated from field: flyteidl2.imagebuilder.Commands commands = 3; + */ + value: Commands; + case: "commands"; + } | { + /** + * Requirements file to use. + * + * @generated from field: flyteidl2.imagebuilder.Requirements requirements = 4; + */ + value: Requirements; + case: "requirements"; + } | { + /** + * Python wheel file to use. + * + * @generated from field: flyteidl2.imagebuilder.PythonWheels python_wheels = 5; + */ + value: PythonWheels; + case: "pythonWheels"; + } | { + /** + * Working directory to set. + * + * @generated from field: flyteidl2.imagebuilder.WorkDir workdir = 6; + */ + value: WorkDir; + case: "workdir"; + } | { + /** + * Copy files/directories into the image. + * + * @generated from field: flyteidl2.imagebuilder.CopyConfig copy_config = 7; + */ + value: CopyConfig; + case: "copyConfig"; + } | { + /** + * UV project configuration. + * + * @generated from field: flyteidl2.imagebuilder.UVProject uv_project = 8; + */ + value: UVProject; + case: "uvProject"; + } | { + /** + * Environment variables to set. + * + * @generated from field: flyteidl2.imagebuilder.Env env = 9; + */ + value: Env; + case: "env"; + } | { + /** + * Poetry project configuration + * + * @generated from field: flyteidl2.imagebuilder.PoetryProject poetry_project = 10; + */ + value: PoetryProject; + case: "poetryProject"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.imagebuilder.Layer. + * Use `create(LayerSchema)` to create a new message. + */ +export const LayerSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_imagebuilder_definition, 13); + +/** + * Image definition defined in the sdk. + * + * @generated from message flyteidl2.imagebuilder.ImageSpec + */ +export type ImageSpec = Message<"flyteidl2.imagebuilder.ImageSpec"> & { + /** + * Identifier for the base image. + * + * @generated from field: string base_image = 1; + */ + baseImage: string; + + /** + * python version to use in the image. + * + * @generated from field: string python_version = 2; + */ + pythonVersion: string; + + /** + * List of layers to apply to the image. + * + * @generated from field: repeated flyteidl2.imagebuilder.Layer layers = 3; + */ + layers: Layer[]; + + /** + * List of platforms to build the image for. + * + * @generated from field: repeated string platform = 4; + */ + platform: string[]; +}; + +/** + * Describes the message flyteidl2.imagebuilder.ImageSpec. + * Use `create(ImageSpecSchema)` to create a new message. + */ +export const ImageSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_imagebuilder_definition, 14); + diff --git a/gen/ts/flyteidl2/imagebuilder/payload_pb.ts b/gen/ts/flyteidl2/imagebuilder/payload_pb.ts new file mode 100644 index 0000000000..303c16db79 --- /dev/null +++ b/gen/ts/flyteidl2/imagebuilder/payload_pb.ts @@ -0,0 +1,75 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/imagebuilder/payload.proto (package flyteidl2.imagebuilder, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { ProjectIdentifier } from "../common/identifier_pb.ts"; +import { file_flyteidl2_common_identifier } from "../common/identifier_pb.ts"; +import type { Image, ImageIdentifier } from "./definition_pb.ts"; +import { file_flyteidl2_imagebuilder_definition } from "./definition_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/imagebuilder/payload.proto. + */ +export const file_flyteidl2_imagebuilder_payload: GenFile = /*@__PURE__*/ + fileDesc("CiRmbHl0ZWlkbDIvaW1hZ2VidWlsZGVyL3BheWxvYWQucHJvdG8SFmZseXRlaWRsMi5pbWFnZWJ1aWxkZXIioQEKD0dldEltYWdlUmVxdWVzdBI7CgJpZBgBIAEoCzInLmZseXRlaWRsMi5pbWFnZWJ1aWxkZXIuSW1hZ2VJZGVudGlmaWVyQga6SAPIAQESGAoMb3JnYW5pemF0aW9uGAIgASgJQgIYARI3Cgpwcm9qZWN0X2lkGAMgASgLMiMuZmx5dGVpZGwyLmNvbW1vbi5Qcm9qZWN0SWRlbnRpZmllciJAChBHZXRJbWFnZVJlc3BvbnNlEiwKBWltYWdlGAEgASgLMh0uZmx5dGVpZGwyLmltYWdlYnVpbGRlci5JbWFnZULhAQoaY29tLmZseXRlaWRsMi5pbWFnZWJ1aWxkZXJCDFBheWxvYWRQcm90b0gCUAFaOmdpdGh1Yi5jb20vZmx5dGVvcmcvZmx5dGUvdjIvZ2VuL2dvL2ZseXRlaWRsMi9pbWFnZWJ1aWxkZXKiAgNGSViqAhZGbHl0ZWlkbDIuSW1hZ2VidWlsZGVyygIWRmx5dGVpZGwyXEltYWdlYnVpbGRlcuICIkZseXRlaWRsMlxJbWFnZWJ1aWxkZXJcR1BCTWV0YWRhdGHqAhdGbHl0ZWlkbDI6OkltYWdlYnVpbGRlcmIGcHJvdG8z", [file_buf_validate_validate, file_flyteidl2_common_identifier, file_flyteidl2_imagebuilder_definition]); + +/** + * @generated from message flyteidl2.imagebuilder.GetImageRequest + */ +export type GetImageRequest = Message<"flyteidl2.imagebuilder.GetImageRequest"> & { + /** + * Image ID + * + * @generated from field: flyteidl2.imagebuilder.ImageIdentifier id = 1; + */ + id?: ImageIdentifier; + + /** + * Optional organization that dictates which dataplane registry to reference + * Deprecated, please use the full ProjectIdentifier instead + * + * @generated from field: string organization = 2 [deprecated = true]; + * @deprecated + */ + organization: string; + + /** + * The scope in which to look for the image. Images maybe accessible in different project-domain pairs through + * different container registries (i.e. different image FQDNs) + * TODO: This scope will be made required after updating all clients/servers to respect it. + * + * @generated from field: flyteidl2.common.ProjectIdentifier project_id = 3; + */ + projectId?: ProjectIdentifier; +}; + +/** + * Describes the message flyteidl2.imagebuilder.GetImageRequest. + * Use `create(GetImageRequestSchema)` to create a new message. + */ +export const GetImageRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_imagebuilder_payload, 0); + +/** + * GetSecretProxyResponse returns the looked up secret from the secret service + * + * @generated from message flyteidl2.imagebuilder.GetImageResponse + */ +export type GetImageResponse = Message<"flyteidl2.imagebuilder.GetImageResponse"> & { + /** + * @generated from field: flyteidl2.imagebuilder.Image image = 1; + */ + image?: Image; +}; + +/** + * Describes the message flyteidl2.imagebuilder.GetImageResponse. + * Use `create(GetImageResponseSchema)` to create a new message. + */ +export const GetImageResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_imagebuilder_payload, 1); + diff --git a/gen/ts/flyteidl2/imagebuilder/service_pb.ts b/gen/ts/flyteidl2/imagebuilder/service_pb.ts new file mode 100644 index 0000000000..d617930f82 --- /dev/null +++ b/gen/ts/flyteidl2/imagebuilder/service_pb.ts @@ -0,0 +1,30 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/imagebuilder/service.proto (package flyteidl2.imagebuilder, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import type { GetImageRequestSchema, GetImageResponseSchema } from "./payload_pb.ts"; +import { file_flyteidl2_imagebuilder_payload } from "./payload_pb.ts"; + +/** + * Describes the file flyteidl2/imagebuilder/service.proto. + */ +export const file_flyteidl2_imagebuilder_service: GenFile = /*@__PURE__*/ + fileDesc("CiRmbHl0ZWlkbDIvaW1hZ2VidWlsZGVyL3NlcnZpY2UucHJvdG8SFmZseXRlaWRsMi5pbWFnZWJ1aWxkZXIycgoMSW1hZ2VTZXJ2aWNlEmIKCEdldEltYWdlEicuZmx5dGVpZGwyLmltYWdlYnVpbGRlci5HZXRJbWFnZVJlcXVlc3QaKC5mbHl0ZWlkbDIuaW1hZ2VidWlsZGVyLkdldEltYWdlUmVzcG9uc2UiA5ACAULhAQoaY29tLmZseXRlaWRsMi5pbWFnZWJ1aWxkZXJCDFNlcnZpY2VQcm90b0gCUAFaOmdpdGh1Yi5jb20vZmx5dGVvcmcvZmx5dGUvdjIvZ2VuL2dvL2ZseXRlaWRsMi9pbWFnZWJ1aWxkZXKiAgNGSViqAhZGbHl0ZWlkbDIuSW1hZ2VidWlsZGVyygIWRmx5dGVpZGwyXEltYWdlYnVpbGRlcuICIkZseXRlaWRsMlxJbWFnZWJ1aWxkZXJcR1BCTWV0YWRhdGHqAhdGbHl0ZWlkbDI6OkltYWdlYnVpbGRlcmIGcHJvdG8z", [file_flyteidl2_imagebuilder_payload]); + +/** + * @generated from service flyteidl2.imagebuilder.ImageService + */ +export const ImageService: GenService<{ + /** + * @generated from rpc flyteidl2.imagebuilder.ImageService.GetImage + */ + getImage: { + methodKind: "unary"; + input: typeof GetImageRequestSchema; + output: typeof GetImageResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_imagebuilder_service, 0); + diff --git a/gen/ts/flyteidl2/logs/dataplane/payload_pb.ts b/gen/ts/flyteidl2/logs/dataplane/payload_pb.ts new file mode 100644 index 0000000000..5c8852fc34 --- /dev/null +++ b/gen/ts/flyteidl2/logs/dataplane/payload_pb.ts @@ -0,0 +1,396 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/logs/dataplane/payload.proto (package flyteidl2.logs.dataplane, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../../buf/validate/validate_pb.ts"; +import type { Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/logs/dataplane/payload.proto. + */ +export const file_flyteidl2_logs_dataplane_payload: GenFile = /*@__PURE__*/ + fileDesc("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", [file_buf_validate_validate, file_google_protobuf_timestamp]); + +/** + * @generated from message flyteidl2.logs.dataplane.PodResource + */ +export type PodResource = Message<"flyteidl2.logs.dataplane.PodResource"> & { + /** + * The namespace of the pod. + * + * @generated from field: string namespace = 1; + */ + namespace: string; + + /** + * The pod name. + * + * @generated from field: string name = 2; + */ + name: string; + + /** + * The container name. If not provided, attempt to find the primary container, else assume the first container. + * +optional + * + * @generated from field: string container = 3; + */ + container: string; +}; + +/** + * Describes the message flyteidl2.logs.dataplane.PodResource. + * Use `create(PodResourceSchema)` to create a new message. + */ +export const PodResourceSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_logs_dataplane_payload, 0); + +/** + * Parameters of environment in which logs were collected. Should contain everything + * necessary to identify location of task execution logs in cloud providers. + * + * @generated from message flyteidl2.logs.dataplane.LoggingContext + */ +export type LoggingContext = Message<"flyteidl2.logs.dataplane.LoggingContext"> & { + /** + * @generated from field: string cluster_name = 3; + */ + clusterName: string; + + /** + * @generated from field: string kubernetes_namespace = 4; + */ + kubernetesNamespace: string; + + /** + * @generated from field: string kubernetes_pod_name = 5; + */ + kubernetesPodName: string; + + /** + * @generated from field: string kubernetes_container_name = 6; + */ + kubernetesContainerName: string; + + /** + * @generated from field: google.protobuf.Timestamp execution_attempt_start_time = 7; + */ + executionAttemptStartTime?: Timestamp; + + /** + * @generated from field: google.protobuf.Timestamp execution_attempt_end_time = 8; + */ + executionAttemptEndTime?: Timestamp; + + /** + * @generated from field: map kubernetes_pod_labels = 9; + */ + kubernetesPodLabels: { [key: string]: string }; +}; + +/** + * Describes the message flyteidl2.logs.dataplane.LoggingContext. + * Use `create(LoggingContextSchema)` to create a new message. + */ +export const LoggingContextSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_logs_dataplane_payload, 1); + +/** + * Parameters of environment in which logs were collected. Should contain everything + * necessary to identify location of task execution logs in cloud providers. + * + * @generated from message flyteidl2.logs.dataplane.ContainerIdentifier + */ +export type ContainerIdentifier = Message<"flyteidl2.logs.dataplane.ContainerIdentifier"> & { + /** + * The name of the cluster. + * + * @generated from field: string cluster_name = 1; + */ + clusterName: string; + + /** + * The namespace in Kubernetes. + * + * @generated from field: string kubernetes_namespace = 2; + */ + kubernetesNamespace: string; + + /** + * The name of the pod in Kubernetes. + * + * @generated from field: string kubernetes_pod_name = 3; + */ + kubernetesPodName: string; + + /** + * The name of the container in Kubernetes. + * + * @generated from field: string kubernetes_container_name = 4; + */ + kubernetesContainerName: string; +}; + +/** + * Describes the message flyteidl2.logs.dataplane.ContainerIdentifier. + * Use `create(ContainerIdentifierSchema)` to create a new message. + */ +export const ContainerIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_logs_dataplane_payload, 2); + +/** + * @generated from message flyteidl2.logs.dataplane.ContainerSelector + */ +export type ContainerSelector = Message<"flyteidl2.logs.dataplane.ContainerSelector"> & { + /** + * The name of the cluster. + * + * @generated from field: string cluster_name = 1; + */ + clusterName: string; + + /** + * The namespace in Kubernetes. + * + * @generated from field: string kubernetes_namespace = 2; + */ + kubernetesNamespace: string; + + /** + * The prefix of the name of the pod in Kubernetes. This will only apply to persisted pods' logs because listing by + * prefix is the supported way to filter pods. + * + * @generated from field: string kubernetes_pod_name_prefix = 3; + */ + kubernetesPodNamePrefix: string; + + /** + * The name of the container in Kubernetes. If not specified, logs for all containers + * will be streamed. + * + * @generated from field: string kubernetes_container_name = 4; + */ + kubernetesContainerName: string; + + /** + * The label selector to filter pods. This will only apply to live pods' logs because Listing by prefix + * isn't supported. + * + * @generated from field: string kubernetes_pod_label_selector = 5; + */ + kubernetesPodLabelSelector: string; +}; + +/** + * Describes the message flyteidl2.logs.dataplane.ContainerSelector. + * Use `create(ContainerSelectorSchema)` to create a new message. + */ +export const ContainerSelectorSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_logs_dataplane_payload, 3); + +/** + * @generated from message flyteidl2.logs.dataplane.LiveLogsOptions + */ +export type LiveLogsOptions = Message<"flyteidl2.logs.dataplane.LiveLogsOptions"> & { + /** + * LogPodStatus indicates whether to log the pod status along with the logs. + * + * @generated from field: bool log_pod_status = 1; + */ + logPodStatus: boolean; + + /** + * LogTimestamps indicates whether to log the timestamps along with the logs. It prepends RFC3339 or RFC3339Nano + * format in the beginning of each log line. + * + * @generated from field: bool log_timestamps = 2; + */ + logTimestamps: boolean; +}; + +/** + * Describes the message flyteidl2.logs.dataplane.LiveLogsOptions. + * Use `create(LiveLogsOptionsSchema)` to create a new message. + */ +export const LiveLogsOptionsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_logs_dataplane_payload, 4); + +/** + * @generated from message flyteidl2.logs.dataplane.LogLine + */ +export type LogLine = Message<"flyteidl2.logs.dataplane.LogLine"> & { + /** + * @generated from field: google.protobuf.Timestamp timestamp = 1; + */ + timestamp?: Timestamp; + + /** + * Each line is separated by either CRLF, CR or LF, which are included + * at the ends of the lines. This lets clients know whether log emitter + * wanted to overwrite the previous line (LF) or append a new line (CRLF). + * + * @generated from field: string message = 2; + */ + message: string; + + /** + * @generated from field: flyteidl2.logs.dataplane.LogLineOriginator originator = 3; + */ + originator: LogLineOriginator; +}; + +/** + * Describes the message flyteidl2.logs.dataplane.LogLine. + * Use `create(LogLineSchema)` to create a new message. + */ +export const LogLineSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_logs_dataplane_payload, 5); + +/** + * @generated from message flyteidl2.logs.dataplane.LogLines + */ +export type LogLines = Message<"flyteidl2.logs.dataplane.LogLines"> & { + /** + * Each line is separated by either CRLF, CR or LF, which are included + * at the ends of the lines. This lets clients know whether log emitter + * wanted to overwrite the previous line (LF) or append a new line (CRLF). + * + * @generated from field: repeated string lines = 1 [deprecated = true]; + * @deprecated + */ + lines: string[]; + + /** + * The index of the container in the list of containers. If the request was made with a single container identifier, + * this value will always be 0. Otherwise, it'll be an index into the last list of containers sent in the stream. + * + * @generated from field: uint32 container_index = 2; + */ + containerIndex: number; + + /** + * The container identifier. + * + * @generated from field: flyteidl2.logs.dataplane.ContainerIdentifier container = 3; + */ + container?: ContainerIdentifier; + + /** + * Each line is separated by either CRLF, CR or LF, which are included + * at the ends of the lines. This lets clients know whether log emitter + * wanted to overwrite the previous line (LF) or append a new line (CRLF). + * + * @generated from field: repeated flyteidl2.logs.dataplane.LogLine structured_lines = 4; + */ + structuredLines: LogLine[]; +}; + +/** + * Describes the message flyteidl2.logs.dataplane.LogLines. + * Use `create(LogLinesSchema)` to create a new message. + */ +export const LogLinesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_logs_dataplane_payload, 6); + +/** + * @generated from message flyteidl2.logs.dataplane.LogContainersList + */ +export type LogContainersList = Message<"flyteidl2.logs.dataplane.LogContainersList"> & { + /** + * @generated from field: repeated flyteidl2.logs.dataplane.ContainerIdentifier containers = 1; + */ + containers: ContainerIdentifier[]; +}; + +/** + * Describes the message flyteidl2.logs.dataplane.LogContainersList. + * Use `create(LogContainersListSchema)` to create a new message. + */ +export const LogContainersListSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_logs_dataplane_payload, 7); + +/** + * @generated from message flyteidl2.logs.dataplane.LogLinesBatch + */ +export type LogLinesBatch = Message<"flyteidl2.logs.dataplane.LogLinesBatch"> & { + /** + * @generated from field: repeated flyteidl2.logs.dataplane.LogLines logs = 1; + */ + logs: LogLines[]; +}; + +/** + * Describes the message flyteidl2.logs.dataplane.LogLinesBatch. + * Use `create(LogLinesBatchSchema)` to create a new message. + */ +export const LogLinesBatchSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_logs_dataplane_payload, 8); + +/** + * @generated from enum flyteidl2.logs.dataplane.LogLineOriginator + */ +export enum LogLineOriginator { + /** + * The originator of the log line is unknown. + * + * @generated from enum value: UNKNOWN = 0; + */ + UNKNOWN = 0, + + /** + * The originator of the log line is the user application. + * + * @generated from enum value: USER = 1; + */ + USER = 1, + + /** + * The originator of the log line is the system. + * + * @generated from enum value: SYSTEM = 2; + */ + SYSTEM = 2, +} + +/** + * Describes the enum flyteidl2.logs.dataplane.LogLineOriginator. + */ +export const LogLineOriginatorSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_logs_dataplane_payload, 0); + +/** + * @generated from enum flyteidl2.logs.dataplane.LogsSource + */ +export enum LogsSource { + /** + * Return live logs and fall back to persisted if not available. + * + * @generated from enum value: LIVE_OR_PERSISTED = 0; + */ + LIVE_OR_PERSISTED = 0, + + /** + * Return live logs only or error if pod is no longer around. + * + * @generated from enum value: LIVE_ONLY = 1; + */ + LIVE_ONLY = 1, + + /** + * Return persisted logs only. + * + * @generated from enum value: PERSISTED_ONLY = 2; + */ + PERSISTED_ONLY = 2, +} + +/** + * Describes the enum flyteidl2.logs.dataplane.LogsSource. + */ +export const LogsSourceSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_logs_dataplane_payload, 1); + diff --git a/gen/ts/flyteidl2/plugins/common_pb.ts b/gen/ts/flyteidl2/plugins/common_pb.ts new file mode 100644 index 0000000000..e02ac7ec9a --- /dev/null +++ b/gen/ts/flyteidl2/plugins/common_pb.ts @@ -0,0 +1,82 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/plugins/common.proto (package flyteidl2.plugins, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Resources } from "../core/tasks_pb.ts"; +import { file_flyteidl2_core_tasks } from "../core/tasks_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/plugins/common.proto. + */ +export const file_flyteidl2_plugins_common: GenFile = /*@__PURE__*/ + fileDesc("Ch5mbHl0ZWlkbDIvcGx1Z2lucy9jb21tb24ucHJvdG8SEWZseXRlaWRsMi5wbHVnaW5zIpwBChFDb21tb25SZXBsaWNhU3BlYxIQCghyZXBsaWNhcxgBIAEoBRINCgVpbWFnZRgCIAEoCRIsCglyZXNvdXJjZXMYAyABKAsyGS5mbHl0ZWlkbDIuY29yZS5SZXNvdXJjZXMSOAoOcmVzdGFydF9wb2xpY3kYBCABKA4yIC5mbHl0ZWlkbDIucGx1Z2lucy5SZXN0YXJ0UG9saWN5KmMKDVJlc3RhcnRQb2xpY3kSGAoUUkVTVEFSVF9QT0xJQ1lfTkVWRVIQABIdChlSRVNUQVJUX1BPTElDWV9PTl9GQUlMVVJFEAESGQoVUkVTVEFSVF9QT0xJQ1lfQUxXQVlTEAJCwgEKFWNvbS5mbHl0ZWlkbDIucGx1Z2luc0ILQ29tbW9uUHJvdG9IAlABWjVnaXRodWIuY29tL2ZseXRlb3JnL2ZseXRlL3YyL2dlbi9nby9mbHl0ZWlkbDIvcGx1Z2luc6ICA0ZQWKoCEUZseXRlaWRsMi5QbHVnaW5zygIRRmx5dGVpZGwyXFBsdWdpbnPiAh1GbHl0ZWlkbDJcUGx1Z2luc1xHUEJNZXRhZGF0YeoCEkZseXRlaWRsMjo6UGx1Z2luc2IGcHJvdG8z", [file_flyteidl2_core_tasks]); + +/** + * @generated from message flyteidl2.plugins.CommonReplicaSpec + */ +export type CommonReplicaSpec = Message<"flyteidl2.plugins.CommonReplicaSpec"> & { + /** + * Number of replicas + * + * @generated from field: int32 replicas = 1; + */ + replicas: number; + + /** + * Image used for the replica group + * + * @generated from field: string image = 2; + */ + image: string; + + /** + * Resources required for the replica group + * + * @generated from field: flyteidl2.core.Resources resources = 3; + */ + resources?: Resources; + + /** + * RestartPolicy determines whether pods will be restarted when they exit + * + * @generated from field: flyteidl2.plugins.RestartPolicy restart_policy = 4; + */ + restartPolicy: RestartPolicy; +}; + +/** + * Describes the message flyteidl2.plugins.CommonReplicaSpec. + * Use `create(CommonReplicaSpecSchema)` to create a new message. + */ +export const CommonReplicaSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_common, 0); + +/** + * @generated from enum flyteidl2.plugins.RestartPolicy + */ +export enum RestartPolicy { + /** + * @generated from enum value: RESTART_POLICY_NEVER = 0; + */ + NEVER = 0, + + /** + * @generated from enum value: RESTART_POLICY_ON_FAILURE = 1; + */ + ON_FAILURE = 1, + + /** + * @generated from enum value: RESTART_POLICY_ALWAYS = 2; + */ + ALWAYS = 2, +} + +/** + * Describes the enum flyteidl2.plugins.RestartPolicy. + */ +export const RestartPolicySchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_plugins_common, 0); + diff --git a/gen/ts/flyteidl2/plugins/dask_pb.ts b/gen/ts/flyteidl2/plugins/dask_pb.ts new file mode 100644 index 0000000000..b335abd4f4 --- /dev/null +++ b/gen/ts/flyteidl2/plugins/dask_pb.ts @@ -0,0 +1,109 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/plugins/dask.proto (package flyteidl2.plugins, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Resources } from "../core/tasks_pb.ts"; +import { file_flyteidl2_core_tasks } from "../core/tasks_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/plugins/dask.proto. + */ +export const file_flyteidl2_plugins_dask: GenFile = /*@__PURE__*/ + fileDesc("ChxmbHl0ZWlkbDIvcGx1Z2lucy9kYXNrLnByb3RvEhFmbHl0ZWlkbDIucGx1Z2lucyJzCgdEYXNrSm9iEjMKCXNjaGVkdWxlchgBIAEoCzIgLmZseXRlaWRsMi5wbHVnaW5zLkRhc2tTY2hlZHVsZXISMwoHd29ya2VycxgCIAEoCzIiLmZseXRlaWRsMi5wbHVnaW5zLkRhc2tXb3JrZXJHcm91cCJMCg1EYXNrU2NoZWR1bGVyEg0KBWltYWdlGAEgASgJEiwKCXJlc291cmNlcxgCIAEoCzIZLmZseXRlaWRsMi5jb3JlLlJlc291cmNlcyJpCg9EYXNrV29ya2VyR3JvdXASGQoRbnVtYmVyX29mX3dvcmtlcnMYASABKA0SDQoFaW1hZ2UYAiABKAkSLAoJcmVzb3VyY2VzGAMgASgLMhkuZmx5dGVpZGwyLmNvcmUuUmVzb3VyY2VzQsABChVjb20uZmx5dGVpZGwyLnBsdWdpbnNCCURhc2tQcm90b0gCUAFaNWdpdGh1Yi5jb20vZmx5dGVvcmcvZmx5dGUvdjIvZ2VuL2dvL2ZseXRlaWRsMi9wbHVnaW5zogIDRlBYqgIRRmx5dGVpZGwyLlBsdWdpbnPKAhFGbHl0ZWlkbDJcUGx1Z2luc+ICHUZseXRlaWRsMlxQbHVnaW5zXEdQQk1ldGFkYXRh6gISRmx5dGVpZGwyOjpQbHVnaW5zYgZwcm90bzM", [file_flyteidl2_core_tasks]); + +/** + * Custom Proto for Dask Plugin. + * + * @generated from message flyteidl2.plugins.DaskJob + */ +export type DaskJob = Message<"flyteidl2.plugins.DaskJob"> & { + /** + * Spec for the scheduler pod. + * + * @generated from field: flyteidl2.plugins.DaskScheduler scheduler = 1; + */ + scheduler?: DaskScheduler; + + /** + * Spec of the default worker group. + * + * @generated from field: flyteidl2.plugins.DaskWorkerGroup workers = 2; + */ + workers?: DaskWorkerGroup; +}; + +/** + * Describes the message flyteidl2.plugins.DaskJob. + * Use `create(DaskJobSchema)` to create a new message. + */ +export const DaskJobSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_dask, 0); + +/** + * Specification for the scheduler pod. + * + * @generated from message flyteidl2.plugins.DaskScheduler + */ +export type DaskScheduler = Message<"flyteidl2.plugins.DaskScheduler"> & { + /** + * Optional image to use. If unset, will use the default image. + * + * @generated from field: string image = 1; + */ + image: string; + + /** + * Resources assigned to the scheduler pod. + * + * @generated from field: flyteidl2.core.Resources resources = 2; + */ + resources?: Resources; +}; + +/** + * Describes the message flyteidl2.plugins.DaskScheduler. + * Use `create(DaskSchedulerSchema)` to create a new message. + */ +export const DaskSchedulerSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_dask, 1); + +/** + * @generated from message flyteidl2.plugins.DaskWorkerGroup + */ +export type DaskWorkerGroup = Message<"flyteidl2.plugins.DaskWorkerGroup"> & { + /** + * Number of workers in the group. + * + * @generated from field: uint32 number_of_workers = 1; + */ + numberOfWorkers: number; + + /** + * Optional image to use for the pods of the worker group. If unset, will use the default image. + * + * @generated from field: string image = 2; + */ + image: string; + + /** + * Resources assigned to the all pods of the worker group. + * As per https://kubernetes.dask.org/en/latest/kubecluster.html?highlight=limit#best-practices + * it is advised to only set limits. If requests are not explicitly set, the plugin will make + * sure to set requests==limits. + * The plugin sets ` --memory-limit` as well as `--nthreads` for the workers according to the limit. + * + * @generated from field: flyteidl2.core.Resources resources = 3; + */ + resources?: Resources; +}; + +/** + * Describes the message flyteidl2.plugins.DaskWorkerGroup. + * Use `create(DaskWorkerGroupSchema)` to create a new message. + */ +export const DaskWorkerGroupSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_dask, 2); + diff --git a/gen/ts/flyteidl2/plugins/kubeflow/common_pb.ts b/gen/ts/flyteidl2/plugins/kubeflow/common_pb.ts new file mode 100644 index 0000000000..cc643853ee --- /dev/null +++ b/gen/ts/flyteidl2/plugins/kubeflow/common_pb.ts @@ -0,0 +1,81 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/plugins/kubeflow/common.proto (package flyteidl2.plugins.kubeflow, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/plugins/kubeflow/common.proto. + */ +export const file_flyteidl2_plugins_kubeflow_common: GenFile = /*@__PURE__*/ + fileDesc("CidmbHl0ZWlkbDIvcGx1Z2lucy9rdWJlZmxvdy9jb21tb24ucHJvdG8SGmZseXRlaWRsMi5wbHVnaW5zLmt1YmVmbG93Iq0BCglSdW5Qb2xpY3kSRAoQY2xlYW5fcG9kX3BvbGljeRgBIAEoDjIqLmZseXRlaWRsMi5wbHVnaW5zLmt1YmVmbG93LkNsZWFuUG9kUG9saWN5EiIKGnR0bF9zZWNvbmRzX2FmdGVyX2ZpbmlzaGVkGAIgASgFEh8KF2FjdGl2ZV9kZWFkbGluZV9zZWNvbmRzGAMgASgFEhUKDWJhY2tvZmZfbGltaXQYBCABKAUqYAoOQ2xlYW5Qb2RQb2xpY3kSGAoUQ0xFQU5QT0RfUE9MSUNZX05PTkUQABIbChdDTEVBTlBPRF9QT0xJQ1lfUlVOTklORxABEhcKE0NMRUFOUE9EX1BPTElDWV9BTEwQAkL5AQoeY29tLmZseXRlaWRsMi5wbHVnaW5zLmt1YmVmbG93QgtDb21tb25Qcm90b0gCUAFaPmdpdGh1Yi5jb20vZmx5dGVvcmcvZmx5dGUvdjIvZ2VuL2dvL2ZseXRlaWRsMi9wbHVnaW5zL2t1YmVmbG93ogIDRlBLqgIaRmx5dGVpZGwyLlBsdWdpbnMuS3ViZWZsb3fKAhpGbHl0ZWlkbDJcUGx1Z2luc1xLdWJlZmxvd+ICJkZseXRlaWRsMlxQbHVnaW5zXEt1YmVmbG93XEdQQk1ldGFkYXRh6gIcRmx5dGVpZGwyOjpQbHVnaW5zOjpLdWJlZmxvd2IGcHJvdG8z"); + +/** + * @generated from message flyteidl2.plugins.kubeflow.RunPolicy + */ +export type RunPolicy = Message<"flyteidl2.plugins.kubeflow.RunPolicy"> & { + /** + * Defines the policy to kill pods after the job completes. Default to None. + * + * @generated from field: flyteidl2.plugins.kubeflow.CleanPodPolicy clean_pod_policy = 1; + */ + cleanPodPolicy: CleanPodPolicy; + + /** + * TTL to clean up jobs. Default to infinite. + * + * @generated from field: int32 ttl_seconds_after_finished = 2; + */ + ttlSecondsAfterFinished: number; + + /** + * Specifies the duration in seconds relative to the startTime that the job may be active + * before the system tries to terminate it; value must be positive integer. + * + * @generated from field: int32 active_deadline_seconds = 3; + */ + activeDeadlineSeconds: number; + + /** + * Number of retries before marking this job failed. + * + * @generated from field: int32 backoff_limit = 4; + */ + backoffLimit: number; +}; + +/** + * Describes the message flyteidl2.plugins.kubeflow.RunPolicy. + * Use `create(RunPolicySchema)` to create a new message. + */ +export const RunPolicySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_kubeflow_common, 0); + +/** + * @generated from enum flyteidl2.plugins.kubeflow.CleanPodPolicy + */ +export enum CleanPodPolicy { + /** + * @generated from enum value: CLEANPOD_POLICY_NONE = 0; + */ + CLEANPOD_POLICY_NONE = 0, + + /** + * @generated from enum value: CLEANPOD_POLICY_RUNNING = 1; + */ + CLEANPOD_POLICY_RUNNING = 1, + + /** + * @generated from enum value: CLEANPOD_POLICY_ALL = 2; + */ + CLEANPOD_POLICY_ALL = 2, +} + +/** + * Describes the enum flyteidl2.plugins.kubeflow.CleanPodPolicy. + */ +export const CleanPodPolicySchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_plugins_kubeflow_common, 0); + diff --git a/gen/ts/flyteidl2/plugins/kubeflow/mpi_pb.ts b/gen/ts/flyteidl2/plugins/kubeflow/mpi_pb.ts new file mode 100644 index 0000000000..d9ffcc2d6c --- /dev/null +++ b/gen/ts/flyteidl2/plugins/kubeflow/mpi_pb.ts @@ -0,0 +1,125 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/plugins/kubeflow/mpi.proto (package flyteidl2.plugins.kubeflow, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Resources } from "../../core/tasks_pb.ts"; +import { file_flyteidl2_core_tasks } from "../../core/tasks_pb.ts"; +import type { CommonReplicaSpec, RestartPolicy } from "../common_pb.ts"; +import { file_flyteidl2_plugins_common } from "../common_pb.ts"; +import type { RunPolicy } from "./common_pb.ts"; +import { file_flyteidl2_plugins_kubeflow_common } from "./common_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/plugins/kubeflow/mpi.proto. + */ +export const file_flyteidl2_plugins_kubeflow_mpi: GenFile = /*@__PURE__*/ + fileDesc("CiRmbHl0ZWlkbDIvcGx1Z2lucy9rdWJlZmxvdy9tcGkucHJvdG8SGmZseXRlaWRsMi5wbHVnaW5zLmt1YmVmbG93IpgCChpEaXN0cmlidXRlZE1QSVRyYWluaW5nVGFzaxJWCg93b3JrZXJfcmVwbGljYXMYASABKAsyPS5mbHl0ZWlkbDIucGx1Z2lucy5rdWJlZmxvdy5EaXN0cmlidXRlZE1QSVRyYWluaW5nUmVwbGljYVNwZWMSWAoRbGF1bmNoZXJfcmVwbGljYXMYAiABKAsyPS5mbHl0ZWlkbDIucGx1Z2lucy5rdWJlZmxvdy5EaXN0cmlidXRlZE1QSVRyYWluaW5nUmVwbGljYVNwZWMSOQoKcnVuX3BvbGljeRgDIAEoCzIlLmZseXRlaWRsMi5wbHVnaW5zLmt1YmVmbG93LlJ1blBvbGljeRINCgVzbG90cxgEIAEoBSKDAgohRGlzdHJpYnV0ZWRNUElUcmFpbmluZ1JlcGxpY2FTcGVjEhQKCHJlcGxpY2FzGAEgASgFQgIYARIRCgVpbWFnZRgCIAEoCUICGAESMAoJcmVzb3VyY2VzGAMgASgLMhkuZmx5dGVpZGwyLmNvcmUuUmVzb3VyY2VzQgIYARI8Cg5yZXN0YXJ0X3BvbGljeRgEIAEoDjIgLmZseXRlaWRsMi5wbHVnaW5zLlJlc3RhcnRQb2xpY3lCAhgBEg8KB2NvbW1hbmQYBSADKAkSNAoGY29tbW9uGAYgASgLMiQuZmx5dGVpZGwyLnBsdWdpbnMuQ29tbW9uUmVwbGljYVNwZWNC9gEKHmNvbS5mbHl0ZWlkbDIucGx1Z2lucy5rdWJlZmxvd0IITXBpUHJvdG9IAlABWj5naXRodWIuY29tL2ZseXRlb3JnL2ZseXRlL3YyL2dlbi9nby9mbHl0ZWlkbDIvcGx1Z2lucy9rdWJlZmxvd6ICA0ZQS6oCGkZseXRlaWRsMi5QbHVnaW5zLkt1YmVmbG93ygIaRmx5dGVpZGwyXFBsdWdpbnNcS3ViZWZsb3fiAiZGbHl0ZWlkbDJcUGx1Z2luc1xLdWJlZmxvd1xHUEJNZXRhZGF0YeoCHEZseXRlaWRsMjo6UGx1Z2luczo6S3ViZWZsb3diBnByb3RvMw", [file_flyteidl2_core_tasks, file_flyteidl2_plugins_common, file_flyteidl2_plugins_kubeflow_common]); + +/** + * Proto for plugin that enables distributed training using https://github.com/kubeflow/mpi-operator + * + * @generated from message flyteidl2.plugins.kubeflow.DistributedMPITrainingTask + */ +export type DistributedMPITrainingTask = Message<"flyteidl2.plugins.kubeflow.DistributedMPITrainingTask"> & { + /** + * Worker replicas spec + * + * @generated from field: flyteidl2.plugins.kubeflow.DistributedMPITrainingReplicaSpec worker_replicas = 1; + */ + workerReplicas?: DistributedMPITrainingReplicaSpec; + + /** + * Master replicas spec + * + * @generated from field: flyteidl2.plugins.kubeflow.DistributedMPITrainingReplicaSpec launcher_replicas = 2; + */ + launcherReplicas?: DistributedMPITrainingReplicaSpec; + + /** + * RunPolicy encapsulates various runtime policies of the distributed training + * job, for example how to clean up resources and how long the job can stay + * active. + * + * @generated from field: flyteidl2.plugins.kubeflow.RunPolicy run_policy = 3; + */ + runPolicy?: RunPolicy; + + /** + * Number of slots per worker + * + * @generated from field: int32 slots = 4; + */ + slots: number; +}; + +/** + * Describes the message flyteidl2.plugins.kubeflow.DistributedMPITrainingTask. + * Use `create(DistributedMPITrainingTaskSchema)` to create a new message. + */ +export const DistributedMPITrainingTaskSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_kubeflow_mpi, 0); + +/** + * Replica specification for distributed MPI training + * + * @generated from message flyteidl2.plugins.kubeflow.DistributedMPITrainingReplicaSpec + */ +export type DistributedMPITrainingReplicaSpec = Message<"flyteidl2.plugins.kubeflow.DistributedMPITrainingReplicaSpec"> & { + /** + * 1~4 deprecated. Use common instead. + * Number of replicas + * + * @generated from field: int32 replicas = 1 [deprecated = true]; + * @deprecated + */ + replicas: number; + + /** + * Image used for the replica group + * + * @generated from field: string image = 2 [deprecated = true]; + * @deprecated + */ + image: string; + + /** + * Resources required for the replica group + * + * @generated from field: flyteidl2.core.Resources resources = 3 [deprecated = true]; + * @deprecated + */ + resources?: Resources; + + /** + * Restart policy determines whether pods will be restarted when they exit + * + * @generated from field: flyteidl2.plugins.RestartPolicy restart_policy = 4 [deprecated = true]; + * @deprecated + */ + restartPolicy: RestartPolicy; + + /** + * MPI sometimes requires different command set for different replica groups + * + * @generated from field: repeated string command = 5; + */ + command: string[]; + + /** + * The common replica spec + * + * @generated from field: flyteidl2.plugins.CommonReplicaSpec common = 6; + */ + common?: CommonReplicaSpec; +}; + +/** + * Describes the message flyteidl2.plugins.kubeflow.DistributedMPITrainingReplicaSpec. + * Use `create(DistributedMPITrainingReplicaSpecSchema)` to create a new message. + */ +export const DistributedMPITrainingReplicaSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_kubeflow_mpi, 1); + diff --git a/gen/ts/flyteidl2/plugins/kubeflow/pytorch_pb.ts b/gen/ts/flyteidl2/plugins/kubeflow/pytorch_pb.ts new file mode 100644 index 0000000000..19d06e07b1 --- /dev/null +++ b/gen/ts/flyteidl2/plugins/kubeflow/pytorch_pb.ts @@ -0,0 +1,156 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/plugins/kubeflow/pytorch.proto (package flyteidl2.plugins.kubeflow, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Resources } from "../../core/tasks_pb.ts"; +import { file_flyteidl2_core_tasks } from "../../core/tasks_pb.ts"; +import type { CommonReplicaSpec, RestartPolicy } from "../common_pb.ts"; +import { file_flyteidl2_plugins_common } from "../common_pb.ts"; +import type { RunPolicy } from "./common_pb.ts"; +import { file_flyteidl2_plugins_kubeflow_common } from "./common_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/plugins/kubeflow/pytorch.proto. + */ +export const file_flyteidl2_plugins_kubeflow_pytorch: GenFile = /*@__PURE__*/ + fileDesc("CihmbHl0ZWlkbDIvcGx1Z2lucy9rdWJlZmxvdy9weXRvcmNoLnByb3RvEhpmbHl0ZWlkbDIucGx1Z2lucy5rdWJlZmxvdyJ/Cg1FbGFzdGljQ29uZmlnEhQKDHJkenZfYmFja2VuZBgBIAEoCRIUCgxtaW5fcmVwbGljYXMYAiABKAUSFAoMbWF4X3JlcGxpY2FzGAMgASgFEhYKDm5wcm9jX3Blcl9ub2RlGAQgASgFEhQKDG1heF9yZXN0YXJ0cxgFIAEoBSLWAgoeRGlzdHJpYnV0ZWRQeVRvcmNoVHJhaW5pbmdUYXNrEloKD3dvcmtlcl9yZXBsaWNhcxgBIAEoCzJBLmZseXRlaWRsMi5wbHVnaW5zLmt1YmVmbG93LkRpc3RyaWJ1dGVkUHlUb3JjaFRyYWluaW5nUmVwbGljYVNwZWMSWgoPbWFzdGVyX3JlcGxpY2FzGAIgASgLMkEuZmx5dGVpZGwyLnBsdWdpbnMua3ViZWZsb3cuRGlzdHJpYnV0ZWRQeVRvcmNoVHJhaW5pbmdSZXBsaWNhU3BlYxI5CgpydW5fcG9saWN5GAMgASgLMiUuZmx5dGVpZGwyLnBsdWdpbnMua3ViZWZsb3cuUnVuUG9saWN5EkEKDmVsYXN0aWNfY29uZmlnGAQgASgLMikuZmx5dGVpZGwyLnBsdWdpbnMua3ViZWZsb3cuRWxhc3RpY0NvbmZpZyL2AQolRGlzdHJpYnV0ZWRQeVRvcmNoVHJhaW5pbmdSZXBsaWNhU3BlYxIUCghyZXBsaWNhcxgBIAEoBUICGAESEQoFaW1hZ2UYAiABKAlCAhgBEjAKCXJlc291cmNlcxgDIAEoCzIZLmZseXRlaWRsMi5jb3JlLlJlc291cmNlc0ICGAESPAoOcmVzdGFydF9wb2xpY3kYBCABKA4yIC5mbHl0ZWlkbDIucGx1Z2lucy5SZXN0YXJ0UG9saWN5QgIYARI0CgZjb21tb24YBSABKAsyJC5mbHl0ZWlkbDIucGx1Z2lucy5Db21tb25SZXBsaWNhU3BlY0L6AQoeY29tLmZseXRlaWRsMi5wbHVnaW5zLmt1YmVmbG93QgxQeXRvcmNoUHJvdG9IAlABWj5naXRodWIuY29tL2ZseXRlb3JnL2ZseXRlL3YyL2dlbi9nby9mbHl0ZWlkbDIvcGx1Z2lucy9rdWJlZmxvd6ICA0ZQS6oCGkZseXRlaWRsMi5QbHVnaW5zLkt1YmVmbG93ygIaRmx5dGVpZGwyXFBsdWdpbnNcS3ViZWZsb3fiAiZGbHl0ZWlkbDJcUGx1Z2luc1xLdWJlZmxvd1xHUEJNZXRhZGF0YeoCHEZseXRlaWRsMjo6UGx1Z2luczo6S3ViZWZsb3diBnByb3RvMw", [file_flyteidl2_core_tasks, file_flyteidl2_plugins_common, file_flyteidl2_plugins_kubeflow_common]); + +/** + * Custom proto for torch elastic config for distributed training using + * https://github.com/kubeflow/training-operator/blob/master/pkg/apis/kubeflow.org/v1/pytorch_types.go + * + * @generated from message flyteidl2.plugins.kubeflow.ElasticConfig + */ +export type ElasticConfig = Message<"flyteidl2.plugins.kubeflow.ElasticConfig"> & { + /** + * @generated from field: string rdzv_backend = 1; + */ + rdzvBackend: string; + + /** + * @generated from field: int32 min_replicas = 2; + */ + minReplicas: number; + + /** + * @generated from field: int32 max_replicas = 3; + */ + maxReplicas: number; + + /** + * @generated from field: int32 nproc_per_node = 4; + */ + nprocPerNode: number; + + /** + * @generated from field: int32 max_restarts = 5; + */ + maxRestarts: number; +}; + +/** + * Describes the message flyteidl2.plugins.kubeflow.ElasticConfig. + * Use `create(ElasticConfigSchema)` to create a new message. + */ +export const ElasticConfigSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_kubeflow_pytorch, 0); + +/** + * Proto for plugin that enables distributed training using https://github.com/kubeflow/pytorch-operator + * + * @generated from message flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingTask + */ +export type DistributedPyTorchTrainingTask = Message<"flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingTask"> & { + /** + * Worker replicas spec + * + * @generated from field: flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingReplicaSpec worker_replicas = 1; + */ + workerReplicas?: DistributedPyTorchTrainingReplicaSpec; + + /** + * Master replicas spec, master replicas can only have 1 replica + * + * @generated from field: flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingReplicaSpec master_replicas = 2; + */ + masterReplicas?: DistributedPyTorchTrainingReplicaSpec; + + /** + * RunPolicy encapsulates various runtime policies of the distributed training + * job, for example how to clean up resources and how long the job can stay + * active. + * + * @generated from field: flyteidl2.plugins.kubeflow.RunPolicy run_policy = 3; + */ + runPolicy?: RunPolicy; + + /** + * config for an elastic pytorch job + * + * @generated from field: flyteidl2.plugins.kubeflow.ElasticConfig elastic_config = 4; + */ + elasticConfig?: ElasticConfig; +}; + +/** + * Describes the message flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingTask. + * Use `create(DistributedPyTorchTrainingTaskSchema)` to create a new message. + */ +export const DistributedPyTorchTrainingTaskSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_kubeflow_pytorch, 1); + +/** + * @generated from message flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingReplicaSpec + */ +export type DistributedPyTorchTrainingReplicaSpec = Message<"flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingReplicaSpec"> & { + /** + * 1~4 deprecated. Use common instead. + * Number of replicas + * + * @generated from field: int32 replicas = 1 [deprecated = true]; + * @deprecated + */ + replicas: number; + + /** + * Image used for the replica group + * + * @generated from field: string image = 2 [deprecated = true]; + * @deprecated + */ + image: string; + + /** + * Resources required for the replica group + * + * @generated from field: flyteidl2.core.Resources resources = 3 [deprecated = true]; + * @deprecated + */ + resources?: Resources; + + /** + * Restart policy determines whether pods will be restarted when they exit + * + * @generated from field: flyteidl2.plugins.RestartPolicy restart_policy = 4 [deprecated = true]; + * @deprecated + */ + restartPolicy: RestartPolicy; + + /** + * The common replica spec + * + * @generated from field: flyteidl2.plugins.CommonReplicaSpec common = 5; + */ + common?: CommonReplicaSpec; +}; + +/** + * Describes the message flyteidl2.plugins.kubeflow.DistributedPyTorchTrainingReplicaSpec. + * Use `create(DistributedPyTorchTrainingReplicaSpecSchema)` to create a new message. + */ +export const DistributedPyTorchTrainingReplicaSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_kubeflow_pytorch, 2); + diff --git a/gen/ts/flyteidl2/plugins/kubeflow/tensorflow_pb.ts b/gen/ts/flyteidl2/plugins/kubeflow/tensorflow_pb.ts new file mode 100644 index 0000000000..d9e186f5e4 --- /dev/null +++ b/gen/ts/flyteidl2/plugins/kubeflow/tensorflow_pb.ts @@ -0,0 +1,123 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/plugins/kubeflow/tensorflow.proto (package flyteidl2.plugins.kubeflow, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Resources } from "../../core/tasks_pb.ts"; +import { file_flyteidl2_core_tasks } from "../../core/tasks_pb.ts"; +import type { CommonReplicaSpec, RestartPolicy } from "../common_pb.ts"; +import { file_flyteidl2_plugins_common } from "../common_pb.ts"; +import type { RunPolicy } from "./common_pb.ts"; +import { file_flyteidl2_plugins_kubeflow_common } from "./common_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/plugins/kubeflow/tensorflow.proto. + */ +export const file_flyteidl2_plugins_kubeflow_tensorflow: GenFile = /*@__PURE__*/ + fileDesc("CitmbHl0ZWlkbDIvcGx1Z2lucy9rdWJlZmxvdy90ZW5zb3JmbG93LnByb3RvEhpmbHl0ZWlkbDIucGx1Z2lucy5rdWJlZmxvdyLYAwohRGlzdHJpYnV0ZWRUZW5zb3JmbG93VHJhaW5pbmdUYXNrEl0KD3dvcmtlcl9yZXBsaWNhcxgBIAEoCzJELmZseXRlaWRsMi5wbHVnaW5zLmt1YmVmbG93LkRpc3RyaWJ1dGVkVGVuc29yZmxvd1RyYWluaW5nUmVwbGljYVNwZWMSWQoLcHNfcmVwbGljYXMYAiABKAsyRC5mbHl0ZWlkbDIucGx1Z2lucy5rdWJlZmxvdy5EaXN0cmlidXRlZFRlbnNvcmZsb3dUcmFpbmluZ1JlcGxpY2FTcGVjElwKDmNoaWVmX3JlcGxpY2FzGAMgASgLMkQuZmx5dGVpZGwyLnBsdWdpbnMua3ViZWZsb3cuRGlzdHJpYnV0ZWRUZW5zb3JmbG93VHJhaW5pbmdSZXBsaWNhU3BlYxI5CgpydW5fcG9saWN5GAQgASgLMiUuZmx5dGVpZGwyLnBsdWdpbnMua3ViZWZsb3cuUnVuUG9saWN5EmAKEmV2YWx1YXRvcl9yZXBsaWNhcxgFIAEoCzJELmZseXRlaWRsMi5wbHVnaW5zLmt1YmVmbG93LkRpc3RyaWJ1dGVkVGVuc29yZmxvd1RyYWluaW5nUmVwbGljYVNwZWMi+QEKKERpc3RyaWJ1dGVkVGVuc29yZmxvd1RyYWluaW5nUmVwbGljYVNwZWMSFAoIcmVwbGljYXMYASABKAVCAhgBEhEKBWltYWdlGAIgASgJQgIYARIwCglyZXNvdXJjZXMYAyABKAsyGS5mbHl0ZWlkbDIuY29yZS5SZXNvdXJjZXNCAhgBEjwKDnJlc3RhcnRfcG9saWN5GAQgASgOMiAuZmx5dGVpZGwyLnBsdWdpbnMuUmVzdGFydFBvbGljeUICGAESNAoGY29tbW9uGAUgASgLMiQuZmx5dGVpZGwyLnBsdWdpbnMuQ29tbW9uUmVwbGljYVNwZWNC/QEKHmNvbS5mbHl0ZWlkbDIucGx1Z2lucy5rdWJlZmxvd0IPVGVuc29yZmxvd1Byb3RvSAJQAVo+Z2l0aHViLmNvbS9mbHl0ZW9yZy9mbHl0ZS92Mi9nZW4vZ28vZmx5dGVpZGwyL3BsdWdpbnMva3ViZWZsb3eiAgNGUEuqAhpGbHl0ZWlkbDIuUGx1Z2lucy5LdWJlZmxvd8oCGkZseXRlaWRsMlxQbHVnaW5zXEt1YmVmbG934gImRmx5dGVpZGwyXFBsdWdpbnNcS3ViZWZsb3dcR1BCTWV0YWRhdGHqAhxGbHl0ZWlkbDI6OlBsdWdpbnM6Okt1YmVmbG93YgZwcm90bzM", [file_flyteidl2_core_tasks, file_flyteidl2_plugins_common, file_flyteidl2_plugins_kubeflow_common]); + +/** + * Proto for plugin that enables distributed training using https://github.com/kubeflow/tf-operator + * + * @generated from message flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingTask + */ +export type DistributedTensorflowTrainingTask = Message<"flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingTask"> & { + /** + * Worker replicas spec + * + * @generated from field: flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpec worker_replicas = 1; + */ + workerReplicas?: DistributedTensorflowTrainingReplicaSpec; + + /** + * Parameter server replicas spec + * + * @generated from field: flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpec ps_replicas = 2; + */ + psReplicas?: DistributedTensorflowTrainingReplicaSpec; + + /** + * Chief replicas spec + * + * @generated from field: flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpec chief_replicas = 3; + */ + chiefReplicas?: DistributedTensorflowTrainingReplicaSpec; + + /** + * RunPolicy encapsulates various runtime policies of the distributed training + * job, for example how to clean up resources and how long the job can stay + * active. + * + * @generated from field: flyteidl2.plugins.kubeflow.RunPolicy run_policy = 4; + */ + runPolicy?: RunPolicy; + + /** + * Evaluator replicas spec + * + * @generated from field: flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpec evaluator_replicas = 5; + */ + evaluatorReplicas?: DistributedTensorflowTrainingReplicaSpec; +}; + +/** + * Describes the message flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingTask. + * Use `create(DistributedTensorflowTrainingTaskSchema)` to create a new message. + */ +export const DistributedTensorflowTrainingTaskSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_kubeflow_tensorflow, 0); + +/** + * @generated from message flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpec + */ +export type DistributedTensorflowTrainingReplicaSpec = Message<"flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpec"> & { + /** + * 1~4 deprecated. Use common instead. + * Number of replicas + * + * @generated from field: int32 replicas = 1 [deprecated = true]; + * @deprecated + */ + replicas: number; + + /** + * Image used for the replica group + * + * @generated from field: string image = 2 [deprecated = true]; + * @deprecated + */ + image: string; + + /** + * Resources required for the replica group + * + * @generated from field: flyteidl2.core.Resources resources = 3 [deprecated = true]; + * @deprecated + */ + resources?: Resources; + + /** + * Restart policy determines whether pods will be restarted when they exit + * + * @generated from field: flyteidl2.plugins.RestartPolicy restart_policy = 4 [deprecated = true]; + * @deprecated + */ + restartPolicy: RestartPolicy; + + /** + * The common replica spec + * + * @generated from field: flyteidl2.plugins.CommonReplicaSpec common = 5; + */ + common?: CommonReplicaSpec; +}; + +/** + * Describes the message flyteidl2.plugins.kubeflow.DistributedTensorflowTrainingReplicaSpec. + * Use `create(DistributedTensorflowTrainingReplicaSpecSchema)` to create a new message. + */ +export const DistributedTensorflowTrainingReplicaSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_kubeflow_tensorflow, 1); + diff --git a/gen/ts/flyteidl2/plugins/mpi_pb.ts b/gen/ts/flyteidl2/plugins/mpi_pb.ts new file mode 100644 index 0000000000..94cfb540fd --- /dev/null +++ b/gen/ts/flyteidl2/plugins/mpi_pb.ts @@ -0,0 +1,52 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/plugins/mpi.proto (package flyteidl2.plugins, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/plugins/mpi.proto. + */ +export const file_flyteidl2_plugins_mpi: GenFile = /*@__PURE__*/ + fileDesc("ChtmbHl0ZWlkbDIvcGx1Z2lucy9tcGkucHJvdG8SEWZseXRlaWRsMi5wbHVnaW5zIl8KGkRpc3RyaWJ1dGVkTVBJVHJhaW5pbmdUYXNrEhMKC251bV93b3JrZXJzGAEgASgFEh0KFW51bV9sYXVuY2hlcl9yZXBsaWNhcxgCIAEoBRINCgVzbG90cxgDIAEoBUK/AQoVY29tLmZseXRlaWRsMi5wbHVnaW5zQghNcGlQcm90b0gCUAFaNWdpdGh1Yi5jb20vZmx5dGVvcmcvZmx5dGUvdjIvZ2VuL2dvL2ZseXRlaWRsMi9wbHVnaW5zogIDRlBYqgIRRmx5dGVpZGwyLlBsdWdpbnPKAhFGbHl0ZWlkbDJcUGx1Z2luc+ICHUZseXRlaWRsMlxQbHVnaW5zXEdQQk1ldGFkYXRh6gISRmx5dGVpZGwyOjpQbHVnaW5zYgZwcm90bzM"); + +/** + * MPI operator proposal https://github.com/kubeflow/community/blob/master/proposals/mpi-operator-proposal.md + * Custom proto for plugin that enables distributed training using https://github.com/kubeflow/mpi-operator + * + * @generated from message flyteidl2.plugins.DistributedMPITrainingTask + */ +export type DistributedMPITrainingTask = Message<"flyteidl2.plugins.DistributedMPITrainingTask"> & { + /** + * number of worker spawned in the cluster for this job + * + * @generated from field: int32 num_workers = 1; + */ + numWorkers: number; + + /** + * number of launcher replicas spawned in the cluster for this job + * The launcher pod invokes mpirun and communicates with worker pods through MPI. + * + * @generated from field: int32 num_launcher_replicas = 2; + */ + numLauncherReplicas: number; + + /** + * number of slots per worker used in hostfile. + * The available slots (GPUs) in each pod. + * + * @generated from field: int32 slots = 3; + */ + slots: number; +}; + +/** + * Describes the message flyteidl2.plugins.DistributedMPITrainingTask. + * Use `create(DistributedMPITrainingTaskSchema)` to create a new message. + */ +export const DistributedMPITrainingTaskSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_mpi, 0); + diff --git a/gen/ts/flyteidl2/plugins/presto_pb.ts b/gen/ts/flyteidl2/plugins/presto_pb.ts new file mode 100644 index 0000000000..c66b1d41df --- /dev/null +++ b/gen/ts/flyteidl2/plugins/presto_pb.ts @@ -0,0 +1,49 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/plugins/presto.proto (package flyteidl2.plugins, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/plugins/presto.proto. + */ +export const file_flyteidl2_plugins_presto: GenFile = /*@__PURE__*/ + fileDesc("Ch5mbHl0ZWlkbDIvcGx1Z2lucy9wcmVzdG8ucHJvdG8SEWZseXRlaWRsMi5wbHVnaW5zIlgKC1ByZXN0b1F1ZXJ5EhUKDXJvdXRpbmdfZ3JvdXAYASABKAkSDwoHY2F0YWxvZxgCIAEoCRIOCgZzY2hlbWEYAyABKAkSEQoJc3RhdGVtZW50GAQgASgJQsIBChVjb20uZmx5dGVpZGwyLnBsdWdpbnNCC1ByZXN0b1Byb3RvSAJQAVo1Z2l0aHViLmNvbS9mbHl0ZW9yZy9mbHl0ZS92Mi9nZW4vZ28vZmx5dGVpZGwyL3BsdWdpbnOiAgNGUFiqAhFGbHl0ZWlkbDIuUGx1Z2luc8oCEUZseXRlaWRsMlxQbHVnaW5z4gIdRmx5dGVpZGwyXFBsdWdpbnNcR1BCTWV0YWRhdGHqAhJGbHl0ZWlkbDI6OlBsdWdpbnNiBnByb3RvMw"); + +/** + * This message works with the 'presto' task type in the SDK and is the object that will be in the 'custom' field + * of a Presto task's TaskTemplate + * + * @generated from message flyteidl2.plugins.PrestoQuery + */ +export type PrestoQuery = Message<"flyteidl2.plugins.PrestoQuery"> & { + /** + * @generated from field: string routing_group = 1; + */ + routingGroup: string; + + /** + * @generated from field: string catalog = 2; + */ + catalog: string; + + /** + * @generated from field: string schema = 3; + */ + schema: string; + + /** + * @generated from field: string statement = 4; + */ + statement: string; +}; + +/** + * Describes the message flyteidl2.plugins.PrestoQuery. + * Use `create(PrestoQuerySchema)` to create a new message. + */ +export const PrestoQuerySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_presto, 0); + diff --git a/gen/ts/flyteidl2/plugins/pytorch_pb.ts b/gen/ts/flyteidl2/plugins/pytorch_pb.ts new file mode 100644 index 0000000000..3e89d00065 --- /dev/null +++ b/gen/ts/flyteidl2/plugins/pytorch_pb.ts @@ -0,0 +1,82 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/plugins/pytorch.proto (package flyteidl2.plugins, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/plugins/pytorch.proto. + */ +export const file_flyteidl2_plugins_pytorch: GenFile = /*@__PURE__*/ + fileDesc("Ch9mbHl0ZWlkbDIvcGx1Z2lucy9weXRvcmNoLnByb3RvEhFmbHl0ZWlkbDIucGx1Z2lucyJ/Cg1FbGFzdGljQ29uZmlnEhQKDHJkenZfYmFja2VuZBgBIAEoCRIUCgxtaW5fcmVwbGljYXMYAiABKAUSFAoMbWF4X3JlcGxpY2FzGAMgASgFEhYKDm5wcm9jX3Blcl9ub2RlGAQgASgFEhQKDG1heF9yZXN0YXJ0cxgFIAEoBSJrCh5EaXN0cmlidXRlZFB5VG9yY2hUcmFpbmluZ1Rhc2sSDwoHd29ya2VycxgBIAEoBRI4Cg5lbGFzdGljX2NvbmZpZxgCIAEoCzIgLmZseXRlaWRsMi5wbHVnaW5zLkVsYXN0aWNDb25maWdCwwEKFWNvbS5mbHl0ZWlkbDIucGx1Z2luc0IMUHl0b3JjaFByb3RvSAJQAVo1Z2l0aHViLmNvbS9mbHl0ZW9yZy9mbHl0ZS92Mi9nZW4vZ28vZmx5dGVpZGwyL3BsdWdpbnOiAgNGUFiqAhFGbHl0ZWlkbDIuUGx1Z2luc8oCEUZseXRlaWRsMlxQbHVnaW5z4gIdRmx5dGVpZGwyXFBsdWdpbnNcR1BCTWV0YWRhdGHqAhJGbHl0ZWlkbDI6OlBsdWdpbnNiBnByb3RvMw"); + +/** + * Custom proto for torch elastic config for distributed training using + * https://github.com/kubeflow/trainer/blob/e31d11faa9f6ce5111b60c01079d39295589e0ef/pkg/apis/kubeflow.org/v1/pytorch_types.go#L98 + * + * @generated from message flyteidl2.plugins.ElasticConfig + */ +export type ElasticConfig = Message<"flyteidl2.plugins.ElasticConfig"> & { + /** + * @generated from field: string rdzv_backend = 1; + */ + rdzvBackend: string; + + /** + * @generated from field: int32 min_replicas = 2; + */ + minReplicas: number; + + /** + * @generated from field: int32 max_replicas = 3; + */ + maxReplicas: number; + + /** + * @generated from field: int32 nproc_per_node = 4; + */ + nprocPerNode: number; + + /** + * @generated from field: int32 max_restarts = 5; + */ + maxRestarts: number; +}; + +/** + * Describes the message flyteidl2.plugins.ElasticConfig. + * Use `create(ElasticConfigSchema)` to create a new message. + */ +export const ElasticConfigSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_pytorch, 0); + +/** + * Custom proto for plugin that enables distributed training using https://github.com/kubeflow/trainer + * + * @generated from message flyteidl2.plugins.DistributedPyTorchTrainingTask + */ +export type DistributedPyTorchTrainingTask = Message<"flyteidl2.plugins.DistributedPyTorchTrainingTask"> & { + /** + * number of worker replicas spawned in the cluster for this job + * + * @generated from field: int32 workers = 1; + */ + workers: number; + + /** + * config for an elastic pytorch job + * + * @generated from field: flyteidl2.plugins.ElasticConfig elastic_config = 2; + */ + elasticConfig?: ElasticConfig; +}; + +/** + * Describes the message flyteidl2.plugins.DistributedPyTorchTrainingTask. + * Use `create(DistributedPyTorchTrainingTaskSchema)` to create a new message. + */ +export const DistributedPyTorchTrainingTaskSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_pytorch, 1); + diff --git a/gen/ts/flyteidl2/plugins/qubole_pb.ts b/gen/ts/flyteidl2/plugins/qubole_pb.ts new file mode 100644 index 0000000000..d6b26bf059 --- /dev/null +++ b/gen/ts/flyteidl2/plugins/qubole_pb.ts @@ -0,0 +1,98 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/plugins/qubole.proto (package flyteidl2.plugins, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/plugins/qubole.proto. + */ +export const file_flyteidl2_plugins_qubole: GenFile = /*@__PURE__*/ + fileDesc("Ch5mbHl0ZWlkbDIvcGx1Z2lucy9xdWJvbGUucHJvdG8SEWZseXRlaWRsMi5wbHVnaW5zIkMKCUhpdmVRdWVyeRINCgVxdWVyeRgBIAEoCRITCgt0aW1lb3V0X3NlYxgCIAEoDRISCgpyZXRyeUNvdW50GAMgASgNIkQKE0hpdmVRdWVyeUNvbGxlY3Rpb24SLQoHcXVlcmllcxgCIAMoCzIcLmZseXRlaWRsMi5wbHVnaW5zLkhpdmVRdWVyeSKnAQoNUXVib2xlSGl2ZUpvYhIVCg1jbHVzdGVyX2xhYmVsGAEgASgJEkQKEHF1ZXJ5X2NvbGxlY3Rpb24YAiABKAsyJi5mbHl0ZWlkbDIucGx1Z2lucy5IaXZlUXVlcnlDb2xsZWN0aW9uQgIYARIMCgR0YWdzGAMgAygJEisKBXF1ZXJ5GAQgASgLMhwuZmx5dGVpZGwyLnBsdWdpbnMuSGl2ZVF1ZXJ5QsIBChVjb20uZmx5dGVpZGwyLnBsdWdpbnNCC1F1Ym9sZVByb3RvSAJQAVo1Z2l0aHViLmNvbS9mbHl0ZW9yZy9mbHl0ZS92Mi9nZW4vZ28vZmx5dGVpZGwyL3BsdWdpbnOiAgNGUFiqAhFGbHl0ZWlkbDIuUGx1Z2luc8oCEUZseXRlaWRsMlxQbHVnaW5z4gIdRmx5dGVpZGwyXFBsdWdpbnNcR1BCTWV0YWRhdGHqAhJGbHl0ZWlkbDI6OlBsdWdpbnNiBnByb3RvMw"); + +/** + * Defines a query to execute on a hive cluster. + * + * @generated from message flyteidl2.plugins.HiveQuery + */ +export type HiveQuery = Message<"flyteidl2.plugins.HiveQuery"> & { + /** + * @generated from field: string query = 1; + */ + query: string; + + /** + * @generated from field: uint32 timeout_sec = 2; + */ + timeoutSec: number; + + /** + * @generated from field: uint32 retryCount = 3; + */ + retryCount: number; +}; + +/** + * Describes the message flyteidl2.plugins.HiveQuery. + * Use `create(HiveQuerySchema)` to create a new message. + */ +export const HiveQuerySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_qubole, 0); + +/** + * Defines a collection of hive queries. + * + * @generated from message flyteidl2.plugins.HiveQueryCollection + */ +export type HiveQueryCollection = Message<"flyteidl2.plugins.HiveQueryCollection"> & { + /** + * @generated from field: repeated flyteidl2.plugins.HiveQuery queries = 2; + */ + queries: HiveQuery[]; +}; + +/** + * Describes the message flyteidl2.plugins.HiveQueryCollection. + * Use `create(HiveQueryCollectionSchema)` to create a new message. + */ +export const HiveQueryCollectionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_qubole, 1); + +/** + * This message works with the 'hive' task type in the SDK and is the object that will be in the 'custom' field + * of a hive task's TaskTemplate + * + * @generated from message flyteidl2.plugins.QuboleHiveJob + */ +export type QuboleHiveJob = Message<"flyteidl2.plugins.QuboleHiveJob"> & { + /** + * @generated from field: string cluster_label = 1; + */ + clusterLabel: string; + + /** + * @generated from field: flyteidl2.plugins.HiveQueryCollection query_collection = 2 [deprecated = true]; + * @deprecated + */ + queryCollection?: HiveQueryCollection; + + /** + * @generated from field: repeated string tags = 3; + */ + tags: string[]; + + /** + * @generated from field: flyteidl2.plugins.HiveQuery query = 4; + */ + query?: HiveQuery; +}; + +/** + * Describes the message flyteidl2.plugins.QuboleHiveJob. + * Use `create(QuboleHiveJobSchema)` to create a new message. + */ +export const QuboleHiveJobSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_qubole, 2); + diff --git a/gen/ts/flyteidl2/plugins/ray_pb.ts b/gen/ts/flyteidl2/plugins/ray_pb.ts new file mode 100644 index 0000000000..4690aaf471 --- /dev/null +++ b/gen/ts/flyteidl2/plugins/ray_pb.ts @@ -0,0 +1,189 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/plugins/ray.proto (package flyteidl2.plugins, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { K8sPod } from "../core/tasks_pb.ts"; +import { file_flyteidl2_core_tasks } from "../core/tasks_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/plugins/ray.proto. + */ +export const file_flyteidl2_plugins_ray: GenFile = /*@__PURE__*/ + fileDesc("ChtmbHl0ZWlkbDIvcGx1Z2lucy9yYXkucHJvdG8SEWZseXRlaWRsMi5wbHVnaW5zIrgBCgZSYXlKb2ISMgoLcmF5X2NsdXN0ZXIYASABKAsyHS5mbHl0ZWlkbDIucGx1Z2lucy5SYXlDbHVzdGVyEhcKC3J1bnRpbWVfZW52GAIgASgJQgIYARIjChtzaHV0ZG93bl9hZnRlcl9qb2JfZmluaXNoZXMYAyABKAgSIgoadHRsX3NlY29uZHNfYWZ0ZXJfZmluaXNoZWQYBCABKAUSGAoQcnVudGltZV9lbnZfeWFtbBgFIAEoCSKiAQoKUmF5Q2x1c3RlchI5Cg9oZWFkX2dyb3VwX3NwZWMYASABKAsyIC5mbHl0ZWlkbDIucGx1Z2lucy5IZWFkR3JvdXBTcGVjEj0KEXdvcmtlcl9ncm91cF9zcGVjGAIgAygLMiIuZmx5dGVpZGwyLnBsdWdpbnMuV29ya2VyR3JvdXBTcGVjEhoKEmVuYWJsZV9hdXRvc2NhbGluZxgDIAEoCCK/AQoNSGVhZEdyb3VwU3BlYxJOChByYXlfc3RhcnRfcGFyYW1zGAEgAygLMjQuZmx5dGVpZGwyLnBsdWdpbnMuSGVhZEdyb3VwU3BlYy5SYXlTdGFydFBhcmFtc0VudHJ5EicKB2s4c19wb2QYAiABKAsyFi5mbHl0ZWlkbDIuY29yZS5LOHNQb2QaNQoTUmF5U3RhcnRQYXJhbXNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBIpUCCg9Xb3JrZXJHcm91cFNwZWMSEgoKZ3JvdXBfbmFtZRgBIAEoCRIQCghyZXBsaWNhcxgCIAEoBRIUCgxtaW5fcmVwbGljYXMYAyABKAUSFAoMbWF4X3JlcGxpY2FzGAQgASgFElAKEHJheV9zdGFydF9wYXJhbXMYBSADKAsyNi5mbHl0ZWlkbDIucGx1Z2lucy5Xb3JrZXJHcm91cFNwZWMuUmF5U3RhcnRQYXJhbXNFbnRyeRInCgdrOHNfcG9kGAYgASgLMhYuZmx5dGVpZGwyLmNvcmUuSzhzUG9kGjUKE1JheVN0YXJ0UGFyYW1zRW50cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4AUK/AQoVY29tLmZseXRlaWRsMi5wbHVnaW5zQghSYXlQcm90b0gCUAFaNWdpdGh1Yi5jb20vZmx5dGVvcmcvZmx5dGUvdjIvZ2VuL2dvL2ZseXRlaWRsMi9wbHVnaW5zogIDRlBYqgIRRmx5dGVpZGwyLlBsdWdpbnPKAhFGbHl0ZWlkbDJcUGx1Z2luc+ICHUZseXRlaWRsMlxQbHVnaW5zXEdQQk1ldGFkYXRh6gISRmx5dGVpZGwyOjpQbHVnaW5zYgZwcm90bzM", [file_flyteidl2_core_tasks]); + +/** + * RayJobSpec defines the desired state of RayJob + * + * @generated from message flyteidl2.plugins.RayJob + */ +export type RayJob = Message<"flyteidl2.plugins.RayJob"> & { + /** + * RayClusterSpec is the cluster template to run the job + * + * @generated from field: flyteidl2.plugins.RayCluster ray_cluster = 1; + */ + rayCluster?: RayCluster; + + /** + * runtime_env is base64 encoded. + * Ray runtime environments: https://docs.ray.io/en/latest/ray-core/handling-dependencies.html#runtime-environments + * + * @generated from field: string runtime_env = 2 [deprecated = true]; + * @deprecated + */ + runtimeEnv: string; + + /** + * shutdown_after_job_finishes specifies whether the RayCluster should be deleted after the RayJob finishes. + * + * @generated from field: bool shutdown_after_job_finishes = 3; + */ + shutdownAfterJobFinishes: boolean; + + /** + * ttl_seconds_after_finished specifies the number of seconds after which the RayCluster will be deleted after the RayJob finishes. + * + * @generated from field: int32 ttl_seconds_after_finished = 4; + */ + ttlSecondsAfterFinished: number; + + /** + * RuntimeEnvYAML represents the runtime environment configuration + * provided as a multi-line YAML string. + * + * @generated from field: string runtime_env_yaml = 5; + */ + runtimeEnvYaml: string; +}; + +/** + * Describes the message flyteidl2.plugins.RayJob. + * Use `create(RayJobSchema)` to create a new message. + */ +export const RayJobSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_ray, 0); + +/** + * Define Ray cluster defines the desired state of RayCluster + * + * @generated from message flyteidl2.plugins.RayCluster + */ +export type RayCluster = Message<"flyteidl2.plugins.RayCluster"> & { + /** + * HeadGroupSpecs are the spec for the head pod + * + * @generated from field: flyteidl2.plugins.HeadGroupSpec head_group_spec = 1; + */ + headGroupSpec?: HeadGroupSpec; + + /** + * WorkerGroupSpecs are the specs for the worker pods + * + * @generated from field: repeated flyteidl2.plugins.WorkerGroupSpec worker_group_spec = 2; + */ + workerGroupSpec: WorkerGroupSpec[]; + + /** + * Whether to enable autoscaling. + * + * @generated from field: bool enable_autoscaling = 3; + */ + enableAutoscaling: boolean; +}; + +/** + * Describes the message flyteidl2.plugins.RayCluster. + * Use `create(RayClusterSchema)` to create a new message. + */ +export const RayClusterSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_ray, 1); + +/** + * HeadGroupSpec are the spec for the head pod + * + * @generated from message flyteidl2.plugins.HeadGroupSpec + */ +export type HeadGroupSpec = Message<"flyteidl2.plugins.HeadGroupSpec"> & { + /** + * Optional. RayStartParams are the params of the start command: address, object-store-memory. + * Refer to https://docs.ray.io/en/latest/ray-core/package-ref.html#ray-start + * + * @generated from field: map ray_start_params = 1; + */ + rayStartParams: { [key: string]: string }; + + /** + * Pod Spec for the ray head pod + * + * @generated from field: flyteidl2.core.K8sPod k8s_pod = 2; + */ + k8sPod?: K8sPod; +}; + +/** + * Describes the message flyteidl2.plugins.HeadGroupSpec. + * Use `create(HeadGroupSpecSchema)` to create a new message. + */ +export const HeadGroupSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_ray, 2); + +/** + * WorkerGroupSpec are the specs for the worker pods + * + * @generated from message flyteidl2.plugins.WorkerGroupSpec + */ +export type WorkerGroupSpec = Message<"flyteidl2.plugins.WorkerGroupSpec"> & { + /** + * Required. RayCluster can have multiple worker groups, and it distinguishes them by name + * + * @generated from field: string group_name = 1; + */ + groupName: string; + + /** + * Required. Desired replicas of the worker group. Defaults to 1. + * + * @generated from field: int32 replicas = 2; + */ + replicas: number; + + /** + * Optional. Min replicas of the worker group. MinReplicas defaults to 1. + * + * @generated from field: int32 min_replicas = 3; + */ + minReplicas: number; + + /** + * Optional. Max replicas of the worker group. MaxReplicas defaults to maxInt32 + * + * @generated from field: int32 max_replicas = 4; + */ + maxReplicas: number; + + /** + * Optional. RayStartParams are the params of the start command: address, object-store-memory. + * Refer to https://docs.ray.io/en/latest/ray-core/package-ref.html#ray-start + * + * @generated from field: map ray_start_params = 5; + */ + rayStartParams: { [key: string]: string }; + + /** + * Pod Spec for ray worker pods + * + * @generated from field: flyteidl2.core.K8sPod k8s_pod = 6; + */ + k8sPod?: K8sPod; +}; + +/** + * Describes the message flyteidl2.plugins.WorkerGroupSpec. + * Use `create(WorkerGroupSpecSchema)` to create a new message. + */ +export const WorkerGroupSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_ray, 3); + diff --git a/gen/ts/flyteidl2/plugins/spark_pb.ts b/gen/ts/flyteidl2/plugins/spark_pb.ts new file mode 100644 index 0000000000..79f7edfdae --- /dev/null +++ b/gen/ts/flyteidl2/plugins/spark_pb.ts @@ -0,0 +1,145 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/plugins/spark.proto (package flyteidl2.plugins, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { K8sPod } from "../core/tasks_pb.ts"; +import { file_flyteidl2_core_tasks } from "../core/tasks_pb.ts"; +import { file_google_protobuf_struct } from "@bufbuild/protobuf/wkt"; +import type { JsonObject, Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/plugins/spark.proto. + */ +export const file_flyteidl2_plugins_spark: GenFile = /*@__PURE__*/ + fileDesc("Ch1mbHl0ZWlkbDIvcGx1Z2lucy9zcGFyay5wcm90bxIRZmx5dGVpZGwyLnBsdWdpbnMiQgoQU3BhcmtBcHBsaWNhdGlvbiIuCgRUeXBlEgoKBlBZVEhPThAAEggKBEpBVkEQARIJCgVTQ0FMQRACEgUKAVIQAyK2BAoIU3BhcmtKb2ISQQoPYXBwbGljYXRpb25UeXBlGAEgASgOMiguZmx5dGVpZGwyLnBsdWdpbnMuU3BhcmtBcHBsaWNhdGlvbi5UeXBlEhsKE21haW5BcHBsaWNhdGlvbkZpbGUYAiABKAkSEQoJbWFpbkNsYXNzGAMgASgJEj0KCXNwYXJrQ29uZhgEIAMoCzIqLmZseXRlaWRsMi5wbHVnaW5zLlNwYXJrSm9iLlNwYXJrQ29uZkVudHJ5Ej8KCmhhZG9vcENvbmYYBSADKAsyKy5mbHl0ZWlkbDIucGx1Z2lucy5TcGFya0pvYi5IYWRvb3BDb25mRW50cnkSFAoMZXhlY3V0b3JQYXRoGAYgASgJEi8KDmRhdGFicmlja3NDb25mGAcgASgLMhcuZ29vZ2xlLnByb3RvYnVmLlN0cnVjdBIXCg9kYXRhYnJpY2tzVG9rZW4YCCABKAkSGgoSZGF0YWJyaWNrc0luc3RhbmNlGAkgASgJEikKCWRyaXZlclBvZBgKIAEoCzIWLmZseXRlaWRsMi5jb3JlLks4c1BvZBIrCgtleGVjdXRvclBvZBgLIAEoCzIWLmZseXRlaWRsMi5jb3JlLks4c1BvZBowCg5TcGFya0NvbmZFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBGjEKD0hhZG9vcENvbmZFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBQsEBChVjb20uZmx5dGVpZGwyLnBsdWdpbnNCClNwYXJrUHJvdG9IAlABWjVnaXRodWIuY29tL2ZseXRlb3JnL2ZseXRlL3YyL2dlbi9nby9mbHl0ZWlkbDIvcGx1Z2luc6ICA0ZQWKoCEUZseXRlaWRsMi5QbHVnaW5zygIRRmx5dGVpZGwyXFBsdWdpbnPiAh1GbHl0ZWlkbDJcUGx1Z2luc1xHUEJNZXRhZGF0YeoCEkZseXRlaWRsMjo6UGx1Z2luc2IGcHJvdG8z", [file_flyteidl2_core_tasks, file_google_protobuf_struct]); + +/** + * @generated from message flyteidl2.plugins.SparkApplication + */ +export type SparkApplication = Message<"flyteidl2.plugins.SparkApplication"> & { +}; + +/** + * Describes the message flyteidl2.plugins.SparkApplication. + * Use `create(SparkApplicationSchema)` to create a new message. + */ +export const SparkApplicationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_spark, 0); + +/** + * @generated from enum flyteidl2.plugins.SparkApplication.Type + */ +export enum SparkApplication_Type { + /** + * @generated from enum value: PYTHON = 0; + */ + PYTHON = 0, + + /** + * @generated from enum value: JAVA = 1; + */ + JAVA = 1, + + /** + * @generated from enum value: SCALA = 2; + */ + SCALA = 2, + + /** + * @generated from enum value: R = 3; + */ + R = 3, +} + +/** + * Describes the enum flyteidl2.plugins.SparkApplication.Type. + */ +export const SparkApplication_TypeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_plugins_spark, 0, 0); + +/** + * Custom Proto for Spark Plugin. + * + * @generated from message flyteidl2.plugins.SparkJob + */ +export type SparkJob = Message<"flyteidl2.plugins.SparkJob"> & { + /** + * @generated from field: flyteidl2.plugins.SparkApplication.Type applicationType = 1; + */ + applicationType: SparkApplication_Type; + + /** + * @generated from field: string mainApplicationFile = 2; + */ + mainApplicationFile: string; + + /** + * @generated from field: string mainClass = 3; + */ + mainClass: string; + + /** + * @generated from field: map sparkConf = 4; + */ + sparkConf: { [key: string]: string }; + + /** + * @generated from field: map hadoopConf = 5; + */ + hadoopConf: { [key: string]: string }; + + /** + * Executor path for Python jobs. + * + * @generated from field: string executorPath = 6; + */ + executorPath: string; + + /** + * Databricks job configuration. + * Config structure can be found here. https://docs.databricks.com/dev-tools/api/2.0/jobs.html#request-structure. + * + * @generated from field: google.protobuf.Struct databricksConf = 7; + */ + databricksConf?: JsonObject; + + /** + * Databricks access token. https://docs.databricks.com/dev-tools/api/latest/authentication.html + * This token can be set in either flytepropeller or flytekit. + * + * @generated from field: string databricksToken = 8; + */ + databricksToken: string; + + /** + * Domain name of your deployment. Use the form .cloud.databricks.com. + * This instance name can be set in either flytepropeller or flytekit. + * + * @generated from field: string databricksInstance = 9; + */ + databricksInstance: string; + + /** + * Pod Spec for the Spark driver pod + * + * @generated from field: flyteidl2.core.K8sPod driverPod = 10; + */ + driverPod?: K8sPod; + + /** + * Pod Spec for the Spark executor pod + * + * @generated from field: flyteidl2.core.K8sPod executorPod = 11; + */ + executorPod?: K8sPod; +}; + +/** + * Describes the message flyteidl2.plugins.SparkJob. + * Use `create(SparkJobSchema)` to create a new message. + */ +export const SparkJobSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_spark, 1); + diff --git a/gen/ts/flyteidl2/plugins/tensorflow_pb.ts b/gen/ts/flyteidl2/plugins/tensorflow_pb.ts new file mode 100644 index 0000000000..36ca9e8e8c --- /dev/null +++ b/gen/ts/flyteidl2/plugins/tensorflow_pb.ts @@ -0,0 +1,57 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/plugins/tensorflow.proto (package flyteidl2.plugins, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/plugins/tensorflow.proto. + */ +export const file_flyteidl2_plugins_tensorflow: GenFile = /*@__PURE__*/ + fileDesc("CiJmbHl0ZWlkbDIvcGx1Z2lucy90ZW5zb3JmbG93LnByb3RvEhFmbHl0ZWlkbDIucGx1Z2lucyJ9CiFEaXN0cmlidXRlZFRlbnNvcmZsb3dUcmFpbmluZ1Rhc2sSDwoHd29ya2VycxgBIAEoBRITCgtwc19yZXBsaWNhcxgCIAEoBRIWCg5jaGllZl9yZXBsaWNhcxgDIAEoBRIaChJldmFsdWF0b3JfcmVwbGljYXMYBCABKAVCxgEKFWNvbS5mbHl0ZWlkbDIucGx1Z2luc0IPVGVuc29yZmxvd1Byb3RvSAJQAVo1Z2l0aHViLmNvbS9mbHl0ZW9yZy9mbHl0ZS92Mi9nZW4vZ28vZmx5dGVpZGwyL3BsdWdpbnOiAgNGUFiqAhFGbHl0ZWlkbDIuUGx1Z2luc8oCEUZseXRlaWRsMlxQbHVnaW5z4gIdRmx5dGVpZGwyXFBsdWdpbnNcR1BCTWV0YWRhdGHqAhJGbHl0ZWlkbDI6OlBsdWdpbnNiBnByb3RvMw"); + +/** + * Custom proto for plugin that enables distributed training using https://github.com/kubeflow/tf-operator + * + * @generated from message flyteidl2.plugins.DistributedTensorflowTrainingTask + */ +export type DistributedTensorflowTrainingTask = Message<"flyteidl2.plugins.DistributedTensorflowTrainingTask"> & { + /** + * number of worker replicas spawned in the cluster for this job + * + * @generated from field: int32 workers = 1; + */ + workers: number; + + /** + * PS -> Parameter server + * number of ps replicas spawned in the cluster for this job + * + * @generated from field: int32 ps_replicas = 2; + */ + psReplicas: number; + + /** + * number of chief replicas spawned in the cluster for this job + * + * @generated from field: int32 chief_replicas = 3; + */ + chiefReplicas: number; + + /** + * number of evaluator replicas spawned in the cluster for this job + * + * @generated from field: int32 evaluator_replicas = 4; + */ + evaluatorReplicas: number; +}; + +/** + * Describes the message flyteidl2.plugins.DistributedTensorflowTrainingTask. + * Use `create(DistributedTensorflowTrainingTaskSchema)` to create a new message. + */ +export const DistributedTensorflowTrainingTaskSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_plugins_tensorflow, 0); + diff --git a/gen/ts/flyteidl2/project/project_service_pb.ts b/gen/ts/flyteidl2/project/project_service_pb.ts new file mode 100644 index 0000000000..3f027cdd4c --- /dev/null +++ b/gen/ts/flyteidl2/project/project_service_pb.ts @@ -0,0 +1,405 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/project/project_service.proto (package flyteidl2.project, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Sort } from "../common/list_pb.ts"; +import { file_flyteidl2_common_list } from "../common/list_pb.ts"; +import type { Labels } from "../task/run_pb.ts"; +import { file_flyteidl2_task_run } from "../task/run_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/project/project_service.proto. + */ +export const file_flyteidl2_project_project_service: GenFile = /*@__PURE__*/ + fileDesc("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", [file_flyteidl2_common_list, file_flyteidl2_task_run]); + +/** + * Namespace within a project commonly used to differentiate between different service instances. + * e.g. "production", "development", etc. + * + * @generated from message flyteidl2.project.Domain + */ +export type Domain = Message<"flyteidl2.project.Domain"> & { + /** + * Globally unique domain name. + * + * @generated from field: string id = 1; + */ + id: string; + + /** + * Display name. + * + * @generated from field: string name = 2; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.project.Domain. + * Use `create(DomainSchema)` to create a new message. + */ +export const DomainSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_project_project_service, 0); + +/** + * @generated from message flyteidl2.project.Project + */ +export type Project = Message<"flyteidl2.project.Project"> & { + /** + * Globally unique project name. + * + * @generated from field: string id = 1; + */ + id: string; + + /** + * Display name. + * + * @generated from field: string name = 2; + */ + name: string; + + /** + * @generated from field: repeated flyteidl2.project.Domain domains = 3; + */ + domains: Domain[]; + + /** + * @generated from field: string description = 4; + */ + description: string; + + /** + * Leverage Labels from flyteidl.admin.common.proto to + * tag projects with ownership information. + * + * @generated from field: flyteidl2.task.Labels labels = 5; + */ + labels?: Labels; + + /** + * @generated from field: flyteidl2.project.ProjectState state = 6; + */ + state: ProjectState; + + /** + * Optional, org key applied to the resource. + * + * @generated from field: string org = 7; + */ + org: string; +}; + +/** + * Describes the message flyteidl2.project.Project. + * Use `create(ProjectSchema)` to create a new message. + */ +export const ProjectSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_project_project_service, 1); + +/** + * Represents a list of projects. + * See :ref:`ref_flyteidl.admin.Project` for more details + * + * @generated from message flyteidl2.project.Projects + */ +export type Projects = Message<"flyteidl2.project.Projects"> & { + /** + * @generated from field: repeated flyteidl2.project.Project projects = 1; + */ + projects: Project[]; + + /** + * In the case of multiple pages of results, the server-provided token can be used to fetch the next page + * in a query. If there are no more results, this value will be empty. + * + * @generated from field: string token = 2; + */ + token: string; +}; + +/** + * Describes the message flyteidl2.project.Projects. + * Use `create(ProjectsSchema)` to create a new message. + */ +export const ProjectsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_project_project_service, 2); + +/** + * Adds a new user-project within the Flyte deployment. + * See :ref:`ref_flyteidl.admin.Project` for more details + * + * @generated from message flyteidl2.project.CreateProjectRequest + */ +export type CreateProjectRequest = Message<"flyteidl2.project.CreateProjectRequest"> & { + /** + * +required + * + * @generated from field: flyteidl2.project.Project project = 1; + */ + project?: Project; +}; + +/** + * Describes the message flyteidl2.project.CreateProjectRequest. + * Use `create(CreateProjectRequestSchema)` to create a new message. + */ +export const CreateProjectRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_project_project_service, 3); + +/** + * Purposefully empty, may be updated in the future. + * + * @generated from message flyteidl2.project.CreateProjectResponse + */ +export type CreateProjectResponse = Message<"flyteidl2.project.CreateProjectResponse"> & { +}; + +/** + * Describes the message flyteidl2.project.CreateProjectResponse. + * Use `create(CreateProjectResponseSchema)` to create a new message. + */ +export const CreateProjectResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_project_project_service, 4); + +/** + * @generated from message flyteidl2.project.UpdateProjectRequest + */ +export type UpdateProjectRequest = Message<"flyteidl2.project.UpdateProjectRequest"> & { + /** + * +required + * + * @generated from field: flyteidl2.project.Project project = 1; + */ + project?: Project; +}; + +/** + * Describes the message flyteidl2.project.UpdateProjectRequest. + * Use `create(UpdateProjectRequestSchema)` to create a new message. + */ +export const UpdateProjectRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_project_project_service, 5); + +/** + * Purposefully empty, may be updated in the future. + * + * @generated from message flyteidl2.project.UpdateProjectResponse + */ +export type UpdateProjectResponse = Message<"flyteidl2.project.UpdateProjectResponse"> & { +}; + +/** + * Describes the message flyteidl2.project.UpdateProjectResponse. + * Use `create(UpdateProjectResponseSchema)` to create a new message. + */ +export const UpdateProjectResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_project_project_service, 6); + +/** + * @generated from message flyteidl2.project.GetProjectRequest + */ +export type GetProjectRequest = Message<"flyteidl2.project.GetProjectRequest"> & { + /** + * Indicates a unique project. + * +required + * + * @generated from field: string id = 1; + */ + id: string; + + /** + * Optional, org key applied to the resource. + * + * @generated from field: string org = 2; + */ + org: string; +}; + +/** + * Describes the message flyteidl2.project.GetProjectRequest. + * Use `create(GetProjectRequestSchema)` to create a new message. + */ +export const GetProjectRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_project_project_service, 7); + +/** + * @generated from message flyteidl2.project.GetProjectResponse + */ +export type GetProjectResponse = Message<"flyteidl2.project.GetProjectResponse"> & { + /** + * +required + * + * @generated from field: flyteidl2.project.Project project = 1; + */ + project?: Project; +}; + +/** + * Describes the message flyteidl2.project.GetProjectResponse. + * Use `create(GetProjectResponseSchema)` to create a new message. + */ +export const GetProjectResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_project_project_service, 8); + +/** + * Request to retrieve a list of projects matching specified filters. + * See :ref:`ref_flyteidl.admin.Project` for more details + * + * @generated from message flyteidl2.project.ListProjectsRequest + */ +export type ListProjectsRequest = Message<"flyteidl2.project.ListProjectsRequest"> & { + /** + * Indicates the number of projects to be returned. + * +required + * + * @generated from field: uint32 limit = 1; + */ + limit: number; + + /** + * In the case of multiple pages of results, this server-provided token can be used to fetch the next page + * in a query. + * +optional + * + * @generated from field: string token = 2; + */ + token: string; + + /** + * Indicates a list of filters passed as string. + * More info on constructing filters : + * +optional + * + * @generated from field: string filters = 3; + */ + filters: string; + + /** + * Sort ordering. + * +optional + * + * @generated from field: flyteidl2.common.Sort sort_by = 4; + */ + sortBy?: Sort; + + /** + * Optional, org filter applied to list project requests. + * + * @generated from field: string org = 5; + */ + org: string; +}; + +/** + * Describes the message flyteidl2.project.ListProjectsRequest. + * Use `create(ListProjectsRequestSchema)` to create a new message. + */ +export const ListProjectsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_project_project_service, 9); + +/** + * @generated from message flyteidl2.project.ListProjectsResponse + */ +export type ListProjectsResponse = Message<"flyteidl2.project.ListProjectsResponse"> & { + /** + * +required + * + * @generated from field: flyteidl2.project.Projects projects = 1; + */ + projects?: Projects; +}; + +/** + * Describes the message flyteidl2.project.ListProjectsResponse. + * Use `create(ListProjectsResponseSchema)` to create a new message. + */ +export const ListProjectsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_project_project_service, 10); + +/** + * The state of the project is used to control its visibility in the UI and validity. + * + * @generated from enum flyteidl2.project.ProjectState + */ +export enum ProjectState { + /** + * By default, all projects are considered active. + * + * @generated from enum value: PROJECT_STATE_ACTIVE = 0; + */ + ACTIVE = 0, + + /** + * Archived projects are no longer visible in the UI and no longer valid. + * + * @generated from enum value: PROJECT_STATE_ARCHIVED = 1; + */ + ARCHIVED = 1, + + /** + * System generated projects that aren't explicitly created or managed by a user. + * + * @generated from enum value: PROJECT_STATE_SYSTEM_GENERATED = 2; + */ + SYSTEM_GENERATED = 2, + + /** + * System archived projects that aren't explicitly archived by a user. + * + * @generated from enum value: PROJECT_STATE_SYSTEM_ARCHIVED = 3; + */ + SYSTEM_ARCHIVED = 3, +} + +/** + * Describes the enum flyteidl2.project.ProjectState. + */ +export const ProjectStateSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_project_project_service, 0); + +/** + * @generated from service flyteidl2.project.ProjectService + */ +export const ProjectService: GenService<{ + /** + * @generated from rpc flyteidl2.project.ProjectService.CreateProject + */ + createProject: { + methodKind: "unary"; + input: typeof CreateProjectRequestSchema; + output: typeof CreateProjectResponseSchema; + }, + /** + * it will be ignored in the handler as domains cannot be updated via this API. + * + * @generated from rpc flyteidl2.project.ProjectService.UpdateProject + */ + updateProject: { + methodKind: "unary"; + input: typeof UpdateProjectRequestSchema; + output: typeof UpdateProjectResponseSchema; + }, + /** + * @generated from rpc flyteidl2.project.ProjectService.GetProject + */ + getProject: { + methodKind: "unary"; + input: typeof GetProjectRequestSchema; + output: typeof GetProjectResponseSchema; + }, + /** + * @generated from rpc flyteidl2.project.ProjectService.ListProjects + */ + listProjects: { + methodKind: "unary"; + input: typeof ListProjectsRequestSchema; + output: typeof ListProjectsResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_project_project_service, 0); + diff --git a/gen/ts/flyteidl2/secret/definition_pb.ts b/gen/ts/flyteidl2/secret/definition_pb.ts new file mode 100644 index 0000000000..514f89ff2d --- /dev/null +++ b/gen/ts/flyteidl2/secret/definition_pb.ts @@ -0,0 +1,310 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/secret/definition.proto (package flyteidl2.secret, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { ClusterIdentifier } from "../common/identifier_pb.ts"; +import { file_flyteidl2_common_identifier } from "../common/identifier_pb.ts"; +import type { Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/secret/definition.proto. + */ +export const file_flyteidl2_secret_definition: GenFile = /*@__PURE__*/ + fileDesc("CiFmbHl0ZWlkbDIvc2VjcmV0L2RlZmluaXRpb24ucHJvdG8SEGZseXRlaWRsMi5zZWNyZXQieAoKU2VjcmV0U3BlYxIWCgxzdHJpbmdfdmFsdWUYASABKAlIABIWCgxiaW5hcnlfdmFsdWUYAiABKAxIABIqCgR0eXBlGAMgASgOMhwuZmx5dGVpZGwyLnNlY3JldC5TZWNyZXRUeXBlQg4KBXZhbHVlEgW6SAIIASJyChBTZWNyZXRJZGVudGlmaWVyEicKBG5hbWUYASABKAlCGbpIFnIUEAEyEF5bLWEtekEtWjAtOV9dKyQSFAoMb3JnYW5pemF0aW9uGAIgASgJEg4KBmRvbWFpbhgDIAEoCRIPCgdwcm9qZWN0GAQgASgJIqUBCg5TZWNyZXRNZXRhZGF0YRIwCgxjcmVhdGVkX3RpbWUYASABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEjUKDXNlY3JldF9zdGF0dXMYAiABKAsyHi5mbHl0ZWlkbDIuc2VjcmV0LlNlY3JldFN0YXR1cxIqCgR0eXBlGAMgASgOMhwuZmx5dGVpZGwyLnNlY3JldC5TZWNyZXRUeXBlIoYBCgxTZWNyZXRTdGF0dXMSNwoOb3ZlcmFsbF9zdGF0dXMYASABKA4yHy5mbHl0ZWlkbDIuc2VjcmV0Lk92ZXJhbGxTdGF0dXMSPQoOY2x1c3Rlcl9zdGF0dXMYAiADKAsyJS5mbHl0ZWlkbDIuc2VjcmV0LkNsdXN0ZXJTZWNyZXRTdGF0dXMijAEKE0NsdXN0ZXJTZWNyZXRTdGF0dXMSNAoHY2x1c3RlchgBIAEoCzIjLmZseXRlaWRsMi5jb21tb24uQ2x1c3RlcklkZW50aWZpZXISPwoPcHJlc2VuY2Vfc3RhdHVzGAIgASgOMiYuZmx5dGVpZGwyLnNlY3JldC5TZWNyZXRQcmVzZW5jZVN0YXR1cyJzCgZTZWNyZXQSLgoCaWQYASABKAsyIi5mbHl0ZWlkbDIuc2VjcmV0LlNlY3JldElkZW50aWZpZXISOQoPc2VjcmV0X21ldGFkYXRhGAIgASgLMiAuZmx5dGVpZGwyLnNlY3JldC5TZWNyZXRNZXRhZGF0YSpICgpTZWNyZXRUeXBlEhcKE1NFQ1JFVF9UWVBFX0dFTkVSSUMQABIhCh1TRUNSRVRfVFlQRV9JTUFHRV9QVUxMX1NFQ1JFVBABKl4KDU92ZXJhbGxTdGF0dXMSDwoLVU5TUEVDSUZJRUQQABIVChFQQVJUSUFMTFlfUFJFU0VOVBABEhEKDUZVTExZX1BSRVNFTlQQAhISCg5VTktOT1dOX1NUQVRVUxADKj0KFFNlY3JldFByZXNlbmNlU3RhdHVzEgsKB1VOS05PV04QABILCgdNSVNTSU5HEAESCwoHUFJFU0VOVBACQsABChRjb20uZmx5dGVpZGwyLnNlY3JldEIPRGVmaW5pdGlvblByb3RvSAJQAVo0Z2l0aHViLmNvbS9mbHl0ZW9yZy9mbHl0ZS92Mi9nZW4vZ28vZmx5dGVpZGwyL3NlY3JldKICA0ZTWKoCEEZseXRlaWRsMi5TZWNyZXTKAhBGbHl0ZWlkbDJcU2VjcmV04gIcRmx5dGVpZGwyXFNlY3JldFxHUEJNZXRhZGF0YeoCEUZseXRlaWRsMjo6U2VjcmV0YgZwcm90bzM", [file_buf_validate_validate, file_flyteidl2_common_identifier, file_google_protobuf_timestamp]); + +/** + * SecretSpec contains information used for creating/updating the secret. + * Mainly it contains the value of the secret + * In future we could add meta info like tags, rotation config, whether stored secret has any binary format etc for storage/retrieval. + * + * @generated from message flyteidl2.secret.SecretSpec + */ +export type SecretSpec = Message<"flyteidl2.secret.SecretSpec"> & { + /** + * @generated from oneof flyteidl2.secret.SecretSpec.value + */ + value: { + /** + * @generated from field: string string_value = 1; + */ + value: string; + case: "stringValue"; + } | { + /** + * @generated from field: bytes binary_value = 2; + */ + value: Uint8Array; + case: "binaryValue"; + } | { case: undefined; value?: undefined }; + + /** + * The secret type + * + * @generated from field: flyteidl2.secret.SecretType type = 3; + */ + type: SecretType; +}; + +/** + * Describes the message flyteidl2.secret.SecretSpec. + * Use `create(SecretSpecSchema)` to create a new message. + */ +export const SecretSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_secret_definition, 0); + +/** + * SecretIdentifier contains the uniquely identifiable way of storing or retrieving the secret + * Name and scope combination are used for defining the format for storage and retrieval of the secret + * For eg : for org scope secrets + * storage format org::name:secret-name + * + * @generated from message flyteidl2.secret.SecretIdentifier + */ +export type SecretIdentifier = Message<"flyteidl2.secret.SecretIdentifier"> & { + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * Only org scoped resources are supported right now + * + * @generated from field: string organization = 2; + */ + organization: string; + + /** + * domain scoped secret + * + * @generated from field: string domain = 3; + */ + domain: string; + + /** + * Project-domain scoped secret + * + * @generated from field: string project = 4; + */ + project: string; +}; + +/** + * Describes the message flyteidl2.secret.SecretIdentifier. + * Use `create(SecretIdentifierSchema)` to create a new message. + */ +export const SecretIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_secret_definition, 1); + +/** + * SecretMetadata contain meta info about the secret + * + * @generated from message flyteidl2.secret.SecretMetadata + */ +export type SecretMetadata = Message<"flyteidl2.secret.SecretMetadata"> & { + /** + * created_time of the secret. + * + * @generated from field: google.protobuf.Timestamp created_time = 1; + */ + createdTime?: Timestamp; + + /** + * secret_status reports the overall status of the secret across all the clusters. + * This relies on number of clusters queried which relies on there enabled state. + * + * @generated from field: flyteidl2.secret.SecretStatus secret_status = 2; + */ + secretStatus?: SecretStatus; + + /** + * The secret type + * + * @generated from field: flyteidl2.secret.SecretType type = 3; + */ + type: SecretType; +}; + +/** + * Describes the message flyteidl2.secret.SecretMetadata. + * Use `create(SecretMetadataSchema)` to create a new message. + */ +export const SecretMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_secret_definition, 2); + +/** + * SecretStatus contains the status of the secret across all the clusters + * + * @generated from message flyteidl2.secret.SecretStatus + */ +export type SecretStatus = Message<"flyteidl2.secret.SecretStatus"> & { + /** + * overall_status reports the overall status of the secret across all the clusters. + * + * @generated from field: flyteidl2.secret.OverallStatus overall_status = 1; + */ + overallStatus: OverallStatus; + + /** + * cluster_status reports the status of the secret in each cluster + * + * @generated from field: repeated flyteidl2.secret.ClusterSecretStatus cluster_status = 2; + */ + clusterStatus: ClusterSecretStatus[]; +}; + +/** + * Describes the message flyteidl2.secret.SecretStatus. + * Use `create(SecretStatusSchema)` to create a new message. + */ +export const SecretStatusSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_secret_definition, 3); + +/** + * ClusterSecretStatus contains the status of the secret in a cluster + * + * @generated from message flyteidl2.secret.ClusterSecretStatus + */ +export type ClusterSecretStatus = Message<"flyteidl2.secret.ClusterSecretStatus"> & { + /** + * @generated from field: flyteidl2.common.ClusterIdentifier cluster = 1; + */ + cluster?: ClusterIdentifier; + + /** + * presence_status reports the status of the secret in the cluster + * + * @generated from field: flyteidl2.secret.SecretPresenceStatus presence_status = 2; + */ + presenceStatus: SecretPresenceStatus; +}; + +/** + * Describes the message flyteidl2.secret.ClusterSecretStatus. + * Use `create(ClusterSecretStatusSchema)` to create a new message. + */ +export const ClusterSecretStatusSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_secret_definition, 4); + +/** + * Secret is the returned object for Get and List calls which returns the identifier of the secret along with + * meta information in future about the creation data, update date, tags etc + * This doesn't contain the value of the secret + * + * @generated from message flyteidl2.secret.Secret + */ +export type Secret = Message<"flyteidl2.secret.Secret"> & { + /** + * @generated from field: flyteidl2.secret.SecretIdentifier id = 1; + */ + id?: SecretIdentifier; + + /** + * @generated from field: flyteidl2.secret.SecretMetadata secret_metadata = 2; + */ + secretMetadata?: SecretMetadata; +}; + +/** + * Describes the message flyteidl2.secret.Secret. + * Use `create(SecretSchema)` to create a new message. + */ +export const SecretSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_secret_definition, 5); + +/** + * @generated from enum flyteidl2.secret.SecretType + */ +export enum SecretType { + /** + * Default, unspecified secret type. Assumed to be generic and no type specific handling required. + * + * @generated from enum value: SECRET_TYPE_GENERIC = 0; + */ + GENERIC = 0, + + /** + * Secret used specifically for pulling images from a container registry. + * + * @generated from enum value: SECRET_TYPE_IMAGE_PULL_SECRET = 1; + */ + IMAGE_PULL_SECRET = 1, +} + +/** + * Describes the enum flyteidl2.secret.SecretType. + */ +export const SecretTypeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_secret_definition, 0); + +/** + * @generated from enum flyteidl2.secret.OverallStatus + */ +export enum OverallStatus { + /** + * @generated from enum value: UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * Exists in some cluster + * + * @generated from enum value: PARTIALLY_PRESENT = 1; + */ + PARTIALLY_PRESENT = 1, + + /** + * Exists in all enabled clusters + * + * @generated from enum value: FULLY_PRESENT = 2; + */ + FULLY_PRESENT = 2, + + /** + * Status is unknown + * + * @generated from enum value: UNKNOWN_STATUS = 3; + */ + UNKNOWN_STATUS = 3, +} + +/** + * Describes the enum flyteidl2.secret.OverallStatus. + */ +export const OverallStatusSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_secret_definition, 1); + +/** + * @generated from enum flyteidl2.secret.SecretPresenceStatus + */ +export enum SecretPresenceStatus { + /** + * @generated from enum value: UNKNOWN = 0; + */ + UNKNOWN = 0, + + /** + * Secret is missing in the cluster + * + * @generated from enum value: MISSING = 1; + */ + MISSING = 1, + + /** + * Secret is present in the cluster + * + * @generated from enum value: PRESENT = 2; + */ + PRESENT = 2, +} + +/** + * Describes the enum flyteidl2.secret.SecretPresenceStatus. + */ +export const SecretPresenceStatusSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_secret_definition, 2); + diff --git a/gen/ts/flyteidl2/secret/payload_pb.ts b/gen/ts/flyteidl2/secret/payload_pb.ts new file mode 100644 index 0000000000..85d8c97c07 --- /dev/null +++ b/gen/ts/flyteidl2/secret/payload_pb.ts @@ -0,0 +1,266 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/secret/payload.proto (package flyteidl2.secret, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { Secret, SecretIdentifier, SecretSpec } from "./definition_pb.ts"; +import { file_flyteidl2_secret_definition } from "./definition_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/secret/payload.proto. + */ +export const file_flyteidl2_secret_payload: GenFile = /*@__PURE__*/ + fileDesc("Ch5mbHl0ZWlkbDIvc2VjcmV0L3BheWxvYWQucHJvdG8SEGZseXRlaWRsMi5zZWNyZXQigAEKE0NyZWF0ZVNlY3JldFJlcXVlc3QSNgoCaWQYASABKAsyIi5mbHl0ZWlkbDIuc2VjcmV0LlNlY3JldElkZW50aWZpZXJCBrpIA8gBARIxCgtzZWNyZXRfc3BlYxgCIAEoCzIcLmZseXRlaWRsMi5zZWNyZXQuU2VjcmV0U3BlYyIWChRDcmVhdGVTZWNyZXRSZXNwb25zZSKAAQoTVXBkYXRlU2VjcmV0UmVxdWVzdBI2CgJpZBgBIAEoCzIiLmZseXRlaWRsMi5zZWNyZXQuU2VjcmV0SWRlbnRpZmllckIGukgDyAEBEjEKC3NlY3JldF9zcGVjGAIgASgLMhwuZmx5dGVpZGwyLnNlY3JldC5TZWNyZXRTcGVjIhYKFFVwZGF0ZVNlY3JldFJlc3BvbnNlIkoKEEdldFNlY3JldFJlcXVlc3QSNgoCaWQYASABKAsyIi5mbHl0ZWlkbDIuc2VjcmV0LlNlY3JldElkZW50aWZpZXJCBrpIA8gBASI9ChFHZXRTZWNyZXRSZXNwb25zZRIoCgZzZWNyZXQYASABKAsyGC5mbHl0ZWlkbDIuc2VjcmV0LlNlY3JldCJNChNEZWxldGVTZWNyZXRSZXF1ZXN0EjYKAmlkGAEgASgLMiIuZmx5dGVpZGwyLnNlY3JldC5TZWNyZXRJZGVudGlmaWVyQga6SAPIAQEiFgoURGVsZXRlU2VjcmV0UmVzcG9uc2Ui+gEKEkxpc3RTZWNyZXRzUmVxdWVzdBIUCgxvcmdhbml6YXRpb24YASABKAkSDgoGZG9tYWluGAIgASgJEg8KB3Byb2plY3QYAyABKAkSDQoFbGltaXQYBCABKAUSDQoFdG9rZW4YBSABKAkSVgoScGVyX2NsdXN0ZXJfdG9rZW5zGAYgAygLMjouZmx5dGVpZGwyLnNlY3JldC5MaXN0U2VjcmV0c1JlcXVlc3QuUGVyQ2x1c3RlclRva2Vuc0VudHJ5GjcKFVBlckNsdXN0ZXJUb2tlbnNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBIuEBChNMaXN0U2VjcmV0c1Jlc3BvbnNlEikKB3NlY3JldHMYASADKAsyGC5mbHl0ZWlkbDIuc2VjcmV0LlNlY3JldBINCgV0b2tlbhgCIAEoCRJXChJwZXJfY2x1c3Rlcl90b2tlbnMYAyADKAsyOy5mbHl0ZWlkbDIuc2VjcmV0Lkxpc3RTZWNyZXRzUmVzcG9uc2UuUGVyQ2x1c3RlclRva2Vuc0VudHJ5GjcKFVBlckNsdXN0ZXJUb2tlbnNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBQr0BChRjb20uZmx5dGVpZGwyLnNlY3JldEIMUGF5bG9hZFByb3RvSAJQAVo0Z2l0aHViLmNvbS9mbHl0ZW9yZy9mbHl0ZS92Mi9nZW4vZ28vZmx5dGVpZGwyL3NlY3JldKICA0ZTWKoCEEZseXRlaWRsMi5TZWNyZXTKAhBGbHl0ZWlkbDJcU2VjcmV04gIcRmx5dGVpZGwyXFNlY3JldFxHUEJNZXRhZGF0YeoCEUZseXRlaWRsMjo6U2VjcmV0YgZwcm90bzM", [file_buf_validate_validate, file_flyteidl2_secret_definition]); + +/** + * CreateSecretProxyRequest contains the spec and identifier used for secret creation + * + * @generated from message flyteidl2.secret.CreateSecretRequest + */ +export type CreateSecretRequest = Message<"flyteidl2.secret.CreateSecretRequest"> & { + /** + * @generated from field: flyteidl2.secret.SecretIdentifier id = 1; + */ + id?: SecretIdentifier; + + /** + * @generated from field: flyteidl2.secret.SecretSpec secret_spec = 2; + */ + secretSpec?: SecretSpec; +}; + +/** + * Describes the message flyteidl2.secret.CreateSecretRequest. + * Use `create(CreateSecretRequestSchema)` to create a new message. + */ +export const CreateSecretRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_secret_payload, 0); + +/** + * CreateSecretResponse + * + * @generated from message flyteidl2.secret.CreateSecretResponse + */ +export type CreateSecretResponse = Message<"flyteidl2.secret.CreateSecretResponse"> & { +}; + +/** + * Describes the message flyteidl2.secret.CreateSecretResponse. + * Use `create(CreateSecretResponseSchema)` to create a new message. + */ +export const CreateSecretResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_secret_payload, 1); + +/** + * UpdateSecretProxyRequest contains the spec and identifier used for secret updation + * + * @generated from message flyteidl2.secret.UpdateSecretRequest + */ +export type UpdateSecretRequest = Message<"flyteidl2.secret.UpdateSecretRequest"> & { + /** + * @generated from field: flyteidl2.secret.SecretIdentifier id = 1; + */ + id?: SecretIdentifier; + + /** + * @generated from field: flyteidl2.secret.SecretSpec secret_spec = 2; + */ + secretSpec?: SecretSpec; +}; + +/** + * Describes the message flyteidl2.secret.UpdateSecretRequest. + * Use `create(UpdateSecretRequestSchema)` to create a new message. + */ +export const UpdateSecretRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_secret_payload, 2); + +/** + * UpdateSecretResponse returns an empty response if the secret is successfully updated + * + * @generated from message flyteidl2.secret.UpdateSecretResponse + */ +export type UpdateSecretResponse = Message<"flyteidl2.secret.UpdateSecretResponse"> & { +}; + +/** + * Describes the message flyteidl2.secret.UpdateSecretResponse. + * Use `create(UpdateSecretResponseSchema)` to create a new message. + */ +export const UpdateSecretResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_secret_payload, 3); + +/** + * GetSecretRequest contains the identifier used for looking up the secret + * + * @generated from message flyteidl2.secret.GetSecretRequest + */ +export type GetSecretRequest = Message<"flyteidl2.secret.GetSecretRequest"> & { + /** + * @generated from field: flyteidl2.secret.SecretIdentifier id = 1; + */ + id?: SecretIdentifier; +}; + +/** + * Describes the message flyteidl2.secret.GetSecretRequest. + * Use `create(GetSecretRequestSchema)` to create a new message. + */ +export const GetSecretRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_secret_payload, 4); + +/** + * GetSecretProxyResponse returns the looked up secret from the secret service + * + * @generated from message flyteidl2.secret.GetSecretResponse + */ +export type GetSecretResponse = Message<"flyteidl2.secret.GetSecretResponse"> & { + /** + * @generated from field: flyteidl2.secret.Secret secret = 1; + */ + secret?: Secret; +}; + +/** + * Describes the message flyteidl2.secret.GetSecretResponse. + * Use `create(GetSecretResponseSchema)` to create a new message. + */ +export const GetSecretResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_secret_payload, 5); + +/** + * DeleteSecretRequest contains the identifier used for looking up the secret for deletion + * + * @generated from message flyteidl2.secret.DeleteSecretRequest + */ +export type DeleteSecretRequest = Message<"flyteidl2.secret.DeleteSecretRequest"> & { + /** + * name to be used for looking up the secret + * + * @generated from field: flyteidl2.secret.SecretIdentifier id = 1; + */ + id?: SecretIdentifier; +}; + +/** + * Describes the message flyteidl2.secret.DeleteSecretRequest. + * Use `create(DeleteSecretRequestSchema)` to create a new message. + */ +export const DeleteSecretRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_secret_payload, 6); + +/** + * DeleteSecretResponse is an empty response right now on successfully deleting the secret. + * + * @generated from message flyteidl2.secret.DeleteSecretResponse + */ +export type DeleteSecretResponse = Message<"flyteidl2.secret.DeleteSecretResponse"> & { +}; + +/** + * Describes the message flyteidl2.secret.DeleteSecretResponse. + * Use `create(DeleteSecretResponseSchema)` to create a new message. + */ +export const DeleteSecretResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_secret_payload, 7); + +/** + * ListSecretsRequest is used for listing all the secrets accessible to the user at the passed in scope. + * With org scope, user is given all secrets at org, domain, project-domain level etc + * And returns paginated results + * + * @generated from message flyteidl2.secret.ListSecretsRequest + */ +export type ListSecretsRequest = Message<"flyteidl2.secret.ListSecretsRequest"> & { + /** + * Only org scoped resources are supported right now + * + * @generated from field: string organization = 1; + */ + organization: string; + + /** + * domain scoped secret + * + * @generated from field: string domain = 2; + */ + domain: string; + + /** + * Project-domain scoped secret + * + * @generated from field: string project = 3; + */ + project: string; + + /** + * Max page results + * + * @generated from field: int32 limit = 4; + */ + limit: number; + + /** + * Leave this empty if you are getting the first set of results. The next_token would be set in the response that can be used to fetch the next set of results. + * + * @generated from field: string token = 5; + */ + token: string; + + /** + * Per cluster token. This allows the service to return paginated results per cluster. + * Service collates the results from all clusters and returns the next token for each cluster. + * The client can use the next token for each cluster to fetch the next page of results. + * In multi cluster, inorder to page through next set of results, client needs to send this token in the next request + * + * @generated from field: map per_cluster_tokens = 6; + */ + perClusterTokens: { [key: string]: string }; +}; + +/** + * Describes the message flyteidl2.secret.ListSecretsRequest. + * Use `create(ListSecretsRequestSchema)` to create a new message. + */ +export const ListSecretsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_secret_payload, 8); + +/** + * ListSecretsResponse returns paginated results of the accessible secrets at the scope defined in the request. + * + * @generated from message flyteidl2.secret.ListSecretsResponse + */ +export type ListSecretsResponse = Message<"flyteidl2.secret.ListSecretsResponse"> & { + /** + * @generated from field: repeated flyteidl2.secret.Secret secrets = 1; + */ + secrets: Secret[]; + + /** + * next token to use for fetching new page results. + * + * @generated from field: string token = 2; + */ + token: string; + + /** + * Per cluster token. This allows the service to return paginated results per cluster. + * Service collates the results from all clusters and returns the next token for each cluster. + * The client can use the next token for each cluster to fetch the next page of results. + * In multi cluster, inorder to page through next set of results, client needs to send this token in the next request + * + * @generated from field: map per_cluster_tokens = 3; + */ + perClusterTokens: { [key: string]: string }; +}; + +/** + * Describes the message flyteidl2.secret.ListSecretsResponse. + * Use `create(ListSecretsResponseSchema)` to create a new message. + */ +export const ListSecretsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_secret_payload, 9); + diff --git a/gen/ts/flyteidl2/secret/secret_pb.ts b/gen/ts/flyteidl2/secret/secret_pb.ts new file mode 100644 index 0000000000..c88e1c34c8 --- /dev/null +++ b/gen/ts/flyteidl2/secret/secret_pb.ts @@ -0,0 +1,63 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/secret/secret.proto (package flyteidl2.secret, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import type { CreateSecretRequestSchema, CreateSecretResponseSchema, DeleteSecretRequestSchema, DeleteSecretResponseSchema, GetSecretRequestSchema, GetSecretResponseSchema, ListSecretsRequestSchema, ListSecretsResponseSchema, UpdateSecretRequestSchema, UpdateSecretResponseSchema } from "./payload_pb.ts"; +import { file_flyteidl2_secret_payload } from "./payload_pb.ts"; +import { file_google_api_annotations } from "../../google/api/annotations_pb.ts"; + +/** + * Describes the file flyteidl2/secret/secret.proto. + */ +export const file_flyteidl2_secret_secret: GenFile = /*@__PURE__*/ + fileDesc("Ch1mbHl0ZWlkbDIvc2VjcmV0L3NlY3JldC5wcm90bxIQZmx5dGVpZGwyLnNlY3JldDKQBQoNU2VjcmV0U2VydmljZRJ5CgxDcmVhdGVTZWNyZXQSJS5mbHl0ZWlkbDIuc2VjcmV0LkNyZWF0ZVNlY3JldFJlcXVlc3QaJi5mbHl0ZWlkbDIuc2VjcmV0LkNyZWF0ZVNlY3JldFJlc3BvbnNlIhqC0+STAhQ6ASoiDy9zZWNyZXRzL2FwaS92MRKIAQoMVXBkYXRlU2VjcmV0EiUuZmx5dGVpZGwyLnNlY3JldC5VcGRhdGVTZWNyZXRSZXF1ZXN0GiYuZmx5dGVpZGwyLnNlY3JldC5VcGRhdGVTZWNyZXRSZXNwb25zZSIpgtPkkwIjOgEqGh4vc2VjcmV0cy9hcGkvdjEvbmFtZS97aWQubmFtZX0SfAoJR2V0U2VjcmV0EiIuZmx5dGVpZGwyLnNlY3JldC5HZXRTZWNyZXRSZXF1ZXN0GiMuZmx5dGVpZGwyLnNlY3JldC5HZXRTZWNyZXRSZXNwb25zZSImgtPkkwIgEh4vc2VjcmV0cy9hcGkvdjEvbmFtZS97aWQubmFtZX0ShQEKDERlbGV0ZVNlY3JldBIlLmZseXRlaWRsMi5zZWNyZXQuRGVsZXRlU2VjcmV0UmVxdWVzdBomLmZseXRlaWRsMi5zZWNyZXQuRGVsZXRlU2VjcmV0UmVzcG9uc2UiJoLT5JMCICoeL3NlY3JldHMvYXBpL3YxL25hbWUve2lkLm5hbWV9EnMKC0xpc3RTZWNyZXRzEiQuZmx5dGVpZGwyLnNlY3JldC5MaXN0U2VjcmV0c1JlcXVlc3QaJS5mbHl0ZWlkbDIuc2VjcmV0Lkxpc3RTZWNyZXRzUmVzcG9uc2UiF4LT5JMCERIPL3NlY3JldHMvYXBpL3YxQrwBChRjb20uZmx5dGVpZGwyLnNlY3JldEILU2VjcmV0UHJvdG9IAlABWjRnaXRodWIuY29tL2ZseXRlb3JnL2ZseXRlL3YyL2dlbi9nby9mbHl0ZWlkbDIvc2VjcmV0ogIDRlNYqgIQRmx5dGVpZGwyLlNlY3JldMoCEEZseXRlaWRsMlxTZWNyZXTiAhxGbHl0ZWlkbDJcU2VjcmV0XEdQQk1ldGFkYXRh6gIRRmx5dGVpZGwyOjpTZWNyZXRiBnByb3RvMw", [file_flyteidl2_secret_payload, file_google_api_annotations]); + +/** + * @generated from service flyteidl2.secret.SecretService + */ +export const SecretService: GenService<{ + /** + * @generated from rpc flyteidl2.secret.SecretService.CreateSecret + */ + createSecret: { + methodKind: "unary"; + input: typeof CreateSecretRequestSchema; + output: typeof CreateSecretResponseSchema; + }, + /** + * @generated from rpc flyteidl2.secret.SecretService.UpdateSecret + */ + updateSecret: { + methodKind: "unary"; + input: typeof UpdateSecretRequestSchema; + output: typeof UpdateSecretResponseSchema; + }, + /** + * @generated from rpc flyteidl2.secret.SecretService.GetSecret + */ + getSecret: { + methodKind: "unary"; + input: typeof GetSecretRequestSchema; + output: typeof GetSecretResponseSchema; + }, + /** + * @generated from rpc flyteidl2.secret.SecretService.DeleteSecret + */ + deleteSecret: { + methodKind: "unary"; + input: typeof DeleteSecretRequestSchema; + output: typeof DeleteSecretResponseSchema; + }, + /** + * @generated from rpc flyteidl2.secret.SecretService.ListSecrets + */ + listSecrets: { + methodKind: "unary"; + input: typeof ListSecretsRequestSchema; + output: typeof ListSecretsResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_secret_secret, 0); + diff --git a/gen/ts/flyteidl2/task/common_pb.ts b/gen/ts/flyteidl2/task/common_pb.ts new file mode 100644 index 0000000000..1dc803bcb5 --- /dev/null +++ b/gen/ts/flyteidl2/task/common_pb.ts @@ -0,0 +1,348 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/task/common.proto (package flyteidl2.task, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { Parameter } from "../core/interface_pb.ts"; +import { file_flyteidl2_core_interface } from "../core/interface_pb.ts"; +import type { KeyValuePair, Literal } from "../core/literals_pb.ts"; +import { file_flyteidl2_core_literals } from "../core/literals_pb.ts"; +import type { Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/task/common.proto. + */ +export const file_flyteidl2_task_common: GenFile = /*@__PURE__*/ + fileDesc("ChtmbHl0ZWlkbDIvdGFzay9jb21tb24ucHJvdG8SDmZseXRlaWRsMi50YXNrIkwKDk5hbWVkUGFyYW1ldGVyEgwKBG5hbWUYASABKAkSLAoJcGFyYW1ldGVyGAIgASgLMhkuZmx5dGVpZGwyLmNvcmUuUGFyYW1ldGVyIooBCglGaXhlZFJhdGUSFgoFdmFsdWUYASABKA1CB7pIBCoCIAASNQoEdW5pdBgCIAEoDjIdLmZseXRlaWRsMi50YXNrLkZpeGVkUmF0ZVVuaXRCCLpIBYIBAiAAEi4KCnN0YXJ0X3RpbWUYAyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wIjUKBENyb24SGwoKZXhwcmVzc2lvbhgBIAEoCUIHukgEcgIQARIQCgh0aW1lem9uZRgCIAEoCSKvAQoIU2NoZWR1bGUSKQoEcmF0ZRgBIAEoCzIZLmZseXRlaWRsMi50YXNrLkZpeGVkUmF0ZUgAEh0KD2Nyb25fZXhwcmVzc2lvbhgCIAEoCUICGAFIABIkCgRjcm9uGAQgASgLMhQuZmx5dGVpZGwyLnRhc2suQ3JvbkgAEh4KFmtpY2tvZmZfdGltZV9pbnB1dF9hcmcYAyABKAlCEwoKZXhwcmVzc2lvbhIFukgCCAEilgEKFVRyaWdnZXJBdXRvbWF0aW9uU3BlYxJBCgR0eXBlGAEgASgOMikuZmx5dGVpZGwyLnRhc2suVHJpZ2dlckF1dG9tYXRpb25TcGVjVHlwZUIIukgFggECIAASLAoIc2NoZWR1bGUYAiABKAsyGC5mbHl0ZWlkbDIudGFzay5TY2hlZHVsZUgAQgwKCmF1dG9tYXRpb24iRAoMTmFtZWRMaXRlcmFsEgwKBG5hbWUYASABKAkSJgoFdmFsdWUYAiABKAsyFy5mbHl0ZWlkbDIuY29yZS5MaXRlcmFsIjoKEE91dHB1dFJlZmVyZW5jZXMSEgoKb3V0cHV0X3VyaRgBIAEoCRISCgpyZXBvcnRfdXJpGAIgASgJImcKBklucHV0cxIuCghsaXRlcmFscxgBIAMoCzIcLmZseXRlaWRsMi50YXNrLk5hbWVkTGl0ZXJhbBItCgdjb250ZXh0GAIgAygLMhwuZmx5dGVpZGwyLmNvcmUuS2V5VmFsdWVQYWlyIjkKB091dHB1dHMSLgoIbGl0ZXJhbHMYASADKAsyHC5mbHl0ZWlkbDIudGFzay5OYW1lZExpdGVyYWwqfwoNRml4ZWRSYXRlVW5pdBIfChtGSVhFRF9SQVRFX1VOSVRfVU5TUEVDSUZJRUQQABIaChZGSVhFRF9SQVRFX1VOSVRfTUlOVVRFEAESGAoURklYRURfUkFURV9VTklUX0hPVVIQAhIXChNGSVhFRF9SQVRFX1VOSVRfREFZEAMqUwoZVHJpZ2dlckF1dG9tYXRpb25TcGVjVHlwZRIUChBUWVBFX1VOU1BFQ0lGSUVEEAASDQoJVFlQRV9OT05FEAESEQoNVFlQRV9TQ0hFRFVMRRACQrABChJjb20uZmx5dGVpZGwyLnRhc2tCC0NvbW1vblByb3RvSAJQAVoyZ2l0aHViLmNvbS9mbHl0ZW9yZy9mbHl0ZS92Mi9nZW4vZ28vZmx5dGVpZGwyL3Rhc2uiAgNGVFiqAg5GbHl0ZWlkbDIuVGFza8oCDkZseXRlaWRsMlxUYXNr4gIaRmx5dGVpZGwyXFRhc2tcR1BCTWV0YWRhdGHqAg9GbHl0ZWlkbDI6OlRhc2tiBnByb3RvMw", [file_buf_validate_validate, file_flyteidl2_core_interface, file_flyteidl2_core_literals, file_google_protobuf_timestamp]); + +/** + * @generated from message flyteidl2.task.NamedParameter + */ +export type NamedParameter = Message<"flyteidl2.task.NamedParameter"> & { + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * @generated from field: flyteidl2.core.Parameter parameter = 2; + */ + parameter?: Parameter; +}; + +/** + * Describes the message flyteidl2.task.NamedParameter. + * Use `create(NamedParameterSchema)` to create a new message. + */ +export const NamedParameterSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_common, 0); + +/** + * Option for schedules run at a certain frequency e.g. every 2 minutes. + * + * @generated from message flyteidl2.task.FixedRate + */ +export type FixedRate = Message<"flyteidl2.task.FixedRate"> & { + /** + * @generated from field: uint32 value = 1; + */ + value: number; + + /** + * @generated from field: flyteidl2.task.FixedRateUnit unit = 2; + */ + unit: FixedRateUnit; + + /** + * Optional, timestamp after which rate should be calculated. Can be only in future. + * E.g. We create a rate schedule "every 5 minutes" with start_time="12:00" inactive. + * Activate it at "12:04". + * Trigger should fire at "12:05" as it adds 5 minutes to start_time="12:00". + * + * @generated from field: google.protobuf.Timestamp start_time = 3; + */ + startTime?: Timestamp; +}; + +/** + * Describes the message flyteidl2.task.FixedRate. + * Use `create(FixedRateSchema)` to create a new message. + */ +export const FixedRateSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_common, 1); + +/** + * @generated from message flyteidl2.task.Cron + */ +export type Cron = Message<"flyteidl2.task.Cron"> & { + /** + * Uses AWS syntax: Minutes Hours Day-of-month Month Day-of-week Year + * e.g. for a schedule that runs every 15 minutes: 0/15 * * * ? * + * + * @generated from field: string expression = 1; + */ + expression: string; + + /** + * default is UTC + * + * @generated from field: string timezone = 2; + */ + timezone: string; +}; + +/** + * Describes the message flyteidl2.task.Cron. + * Use `create(CronSchema)` to create a new message. + */ +export const CronSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_common, 2); + +/** + * Defines complete set of information required to trigger an execution on a schedule. + * + * @generated from message flyteidl2.task.Schedule + */ +export type Schedule = Message<"flyteidl2.task.Schedule"> & { + /** + * @generated from oneof flyteidl2.task.Schedule.expression + */ + expression: { + /** + * @generated from field: flyteidl2.task.FixedRate rate = 1; + */ + value: FixedRate; + case: "rate"; + } | { + /** + * @generated from field: string cron_expression = 2 [deprecated = true]; + * @deprecated + */ + value: string; + case: "cronExpression"; + } | { + /** + * @generated from field: flyteidl2.task.Cron cron = 4; + */ + value: Cron; + case: "cron"; + } | { case: undefined; value?: undefined }; + + /** + * Name of the input variable that the kickoff time will be supplied to when the workflow is kicked off. + * + * @generated from field: string kickoff_time_input_arg = 3; + */ + kickoffTimeInputArg: string; +}; + +/** + * Describes the message flyteidl2.task.Schedule. + * Use `create(ScheduleSchema)` to create a new message. + */ +export const ScheduleSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_common, 3); + +/** + * @generated from message flyteidl2.task.TriggerAutomationSpec + */ +export type TriggerAutomationSpec = Message<"flyteidl2.task.TriggerAutomationSpec"> & { + /** + * Explicitly defines trigger automation type. + * + * @generated from field: flyteidl2.task.TriggerAutomationSpecType type = 1; + */ + type: TriggerAutomationSpecType; + + /** + * @generated from oneof flyteidl2.task.TriggerAutomationSpec.automation + */ + automation: { + /** + * @generated from field: flyteidl2.task.Schedule schedule = 2; + */ + value: Schedule; + case: "schedule"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.task.TriggerAutomationSpec. + * Use `create(TriggerAutomationSpecSchema)` to create a new message. + */ +export const TriggerAutomationSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_common, 4); + +/** + * Named literal value. + * + * @generated from message flyteidl2.task.NamedLiteral + */ +export type NamedLiteral = Message<"flyteidl2.task.NamedLiteral"> & { + /** + * Name of the literal. + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * Literal value. + * + * @generated from field: flyteidl2.core.Literal value = 2; + */ + value?: Literal; +}; + +/** + * Describes the message flyteidl2.task.NamedLiteral. + * Use `create(NamedLiteralSchema)` to create a new message. + */ +export const NamedLiteralSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_common, 5); + +/** + * Output references. + * + * @generated from message flyteidl2.task.OutputReferences + */ +export type OutputReferences = Message<"flyteidl2.task.OutputReferences"> & { + /** + * The output uri. + * + * @generated from field: string output_uri = 1; + */ + outputUri: string; + + /** + * Native URI to HTML report + * + * @generated from field: string report_uri = 2; + */ + reportUri: string; +}; + +/** + * Describes the message flyteidl2.task.OutputReferences. + * Use `create(OutputReferencesSchema)` to create a new message. + */ +export const OutputReferencesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_common, 6); + +/** + * Input payload for an action. + * + * @generated from message flyteidl2.task.Inputs + */ +export type Inputs = Message<"flyteidl2.task.Inputs"> & { + /** + * Ordered inputs. THIS FIELD MUST REMAIN FIRST as this would break Run service assumptions if it were to move. + * + * @generated from field: repeated flyteidl2.task.NamedLiteral literals = 1; + */ + literals: NamedLiteral[]; + + /** + * Context for the action. If an action receives context, it'll automatically pass it to any actions it spawns. + * Context will not be used for cache key computation. + * Examples for context include: + * - User-provided metadata that is not part of the action's inputs. + * - Information about the environment the action is running in (e.g. cluster, region, etc.) + * - Tracing information about the action + * + * @generated from field: repeated flyteidl2.core.KeyValuePair context = 2; + */ + context: KeyValuePair[]; +}; + +/** + * Describes the message flyteidl2.task.Inputs. + * Use `create(InputsSchema)` to create a new message. + */ +export const InputsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_common, 7); + +/** + * Output payload for an action. + * + * @generated from message flyteidl2.task.Outputs + */ +export type Outputs = Message<"flyteidl2.task.Outputs"> & { + /** + * Ordered outputs. THIS FIELD MUST REMAIN FIRST as this would break Run service assumptions if it were to move. + * + * @generated from field: repeated flyteidl2.task.NamedLiteral literals = 1; + */ + literals: NamedLiteral[]; +}; + +/** + * Describes the message flyteidl2.task.Outputs. + * Use `create(OutputsSchema)` to create a new message. + */ +export const OutputsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_common, 8); + +/** + * Represents a frequency at which to run a schedule. + * + * @generated from enum flyteidl2.task.FixedRateUnit + */ +export enum FixedRateUnit { + /** + * @generated from enum value: FIXED_RATE_UNIT_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: FIXED_RATE_UNIT_MINUTE = 1; + */ + MINUTE = 1, + + /** + * @generated from enum value: FIXED_RATE_UNIT_HOUR = 2; + */ + HOUR = 2, + + /** + * @generated from enum value: FIXED_RATE_UNIT_DAY = 3; + */ + DAY = 3, +} + +/** + * Describes the enum flyteidl2.task.FixedRateUnit. + */ +export const FixedRateUnitSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_task_common, 0); + +/** + * @generated from enum flyteidl2.task.TriggerAutomationSpecType + */ +export enum TriggerAutomationSpecType { + /** + * @generated from enum value: TYPE_UNSPECIFIED = 0; + */ + TYPE_UNSPECIFIED = 0, + + /** + * @generated from enum value: TYPE_NONE = 1; + */ + TYPE_NONE = 1, + + /** + * @generated from enum value: TYPE_SCHEDULE = 2; + */ + TYPE_SCHEDULE = 2, +} + +/** + * Describes the enum flyteidl2.task.TriggerAutomationSpecType. + */ +export const TriggerAutomationSpecTypeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_task_common, 1); + diff --git a/gen/ts/flyteidl2/task/environment_pb.ts b/gen/ts/flyteidl2/task/environment_pb.ts new file mode 100644 index 0000000000..e0cd8ff4df --- /dev/null +++ b/gen/ts/flyteidl2/task/environment_pb.ts @@ -0,0 +1,43 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/task/environment.proto (package flyteidl2.task, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/task/environment.proto. + */ +export const file_flyteidl2_task_environment: GenFile = /*@__PURE__*/ + fileDesc("CiBmbHl0ZWlkbDIvdGFzay9lbnZpcm9ubWVudC5wcm90bxIOZmx5dGVpZGwyLnRhc2siRQoLRW52aXJvbm1lbnQSFwoEbmFtZRgBIAEoCUIJukgGcgQQARg/Eh0KC2Rlc2NyaXB0aW9uGAIgASgJQgi6SAVyAxj/AUK1AQoSY29tLmZseXRlaWRsMi50YXNrQhBFbnZpcm9ubWVudFByb3RvSAJQAVoyZ2l0aHViLmNvbS9mbHl0ZW9yZy9mbHl0ZS92Mi9nZW4vZ28vZmx5dGVpZGwyL3Rhc2uiAgNGVFiqAg5GbHl0ZWlkbDIuVGFza8oCDkZseXRlaWRsMlxUYXNr4gIaRmx5dGVpZGwyXFRhc2tcR1BCTWV0YWRhdGHqAg9GbHl0ZWlkbDI6OlRhc2tiBnByb3RvMw", [file_buf_validate_validate]); + +/** + * Environment for a task. + * + * @generated from message flyteidl2.task.Environment + */ +export type Environment = Message<"flyteidl2.task.Environment"> & { + /** + * Name of the environment. + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * Description of environment + * + * @generated from field: string description = 2; + */ + description: string; +}; + +/** + * Describes the message flyteidl2.task.Environment. + * Use `create(EnvironmentSchema)` to create a new message. + */ +export const EnvironmentSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_environment, 0); + diff --git a/gen/ts/flyteidl2/task/run_pb.ts b/gen/ts/flyteidl2/task/run_pb.ts new file mode 100644 index 0000000000..eff180b7fd --- /dev/null +++ b/gen/ts/flyteidl2/task/run_pb.ts @@ -0,0 +1,252 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/task/run.proto (package flyteidl2.task, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { KeyValuePair } from "../core/literals_pb.ts"; +import { file_flyteidl2_core_literals } from "../core/literals_pb.ts"; +import type { SecurityContext } from "../core/security_pb.ts"; +import { file_flyteidl2_core_security } from "../core/security_pb.ts"; +import { file_google_protobuf_wrappers } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/task/run.proto. + */ +export const file_flyteidl2_task_run: GenFile = /*@__PURE__*/ + fileDesc("ChhmbHl0ZWlkbDIvdGFzay9ydW4ucHJvdG8SDmZseXRlaWRsMi50YXNrImsKBkxhYmVscxIyCgZ2YWx1ZXMYASADKAsyIi5mbHl0ZWlkbDIudGFzay5MYWJlbHMuVmFsdWVzRW50cnkaLQoLVmFsdWVzRW50cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ASJ1CgtBbm5vdGF0aW9ucxI3CgZ2YWx1ZXMYASADKAsyJy5mbHl0ZWlkbDIudGFzay5Bbm5vdGF0aW9ucy5WYWx1ZXNFbnRyeRotCgtWYWx1ZXNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBIjQKBEVudnMSLAoGdmFsdWVzGAEgAygLMhwuZmx5dGVpZGwyLmNvcmUuS2V5VmFsdWVQYWlyIikKDlJhd0RhdGFTdG9yYWdlEhcKD3Jhd19kYXRhX3ByZWZpeBgBIAEoCSJkCgtDYWNoZUNvbmZpZxIXCg9vdmVyd3JpdGVfY2FjaGUYASABKAgSPAoSY2FjaGVfbG9va3VwX3Njb3BlGAIgASgOMiAuZmx5dGVpZGwyLnRhc2suQ2FjaGVMb29rdXBTY29wZSKQAwoHUnVuU3BlYxImCgZsYWJlbHMYASABKAsyFi5mbHl0ZWlkbDIudGFzay5MYWJlbHMSMAoLYW5ub3RhdGlvbnMYAiABKAsyGy5mbHl0ZWlkbDIudGFzay5Bbm5vdGF0aW9ucxIiCgRlbnZzGAMgASgLMhQuZmx5dGVpZGwyLnRhc2suRW52cxIxCg1pbnRlcnJ1cHRpYmxlGAQgASgLMhouZ29vZ2xlLnByb3RvYnVmLkJvb2xWYWx1ZRIbCg9vdmVyd3JpdGVfY2FjaGUYBSABKAhCAhgBEg8KB2NsdXN0ZXIYBiABKAkSOAoQcmF3X2RhdGFfc3RvcmFnZRgHIAEoCzIeLmZseXRlaWRsMi50YXNrLlJhd0RhdGFTdG9yYWdlEjkKEHNlY3VyaXR5X2NvbnRleHQYCCABKAsyHy5mbHl0ZWlkbDIuY29yZS5TZWN1cml0eUNvbnRleHQSMQoMY2FjaGVfY29uZmlnGAkgASgLMhsuZmx5dGVpZGwyLnRhc2suQ2FjaGVDb25maWcqfAoQQ2FjaGVMb29rdXBTY29wZRIiCh5DQUNIRV9MT09LVVBfU0NPUEVfVU5TUEVDSUZJRUQQABIdChlDQUNIRV9MT09LVVBfU0NPUEVfR0xPQkFMEAESJQohQ0FDSEVfTE9PS1VQX1NDT1BFX1BST0pFQ1RfRE9NQUlOEAJCrQEKEmNvbS5mbHl0ZWlkbDIudGFza0IIUnVuUHJvdG9IAlABWjJnaXRodWIuY29tL2ZseXRlb3JnL2ZseXRlL3YyL2dlbi9nby9mbHl0ZWlkbDIvdGFza6ICA0ZUWKoCDkZseXRlaWRsMi5UYXNrygIORmx5dGVpZGwyXFRhc2viAhpGbHl0ZWlkbDJcVGFza1xHUEJNZXRhZGF0YeoCD0ZseXRlaWRsMjo6VGFza2IGcHJvdG8z", [file_flyteidl2_core_literals, file_flyteidl2_core_security, file_google_protobuf_wrappers]); + +/** + * Label values to be applied to an execution resource. + * In the future a mode (e.g. OVERRIDE, APPEND, etc) can be defined + * to specify how to merge labels defined at registration and execution time. + * + * @generated from message flyteidl2.task.Labels + */ +export type Labels = Message<"flyteidl2.task.Labels"> & { + /** + * Map of custom labels to be applied to the execution resource. + * + * @generated from field: map values = 1; + */ + values: { [key: string]: string }; +}; + +/** + * Describes the message flyteidl2.task.Labels. + * Use `create(LabelsSchema)` to create a new message. + */ +export const LabelsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_run, 0); + +/** + * Annotation values to be applied to an execution resource. + * In the future a mode (e.g. OVERRIDE, APPEND, etc) can be defined + * to specify how to merge annotations defined at registration and execution time. + * + * @generated from message flyteidl2.task.Annotations + */ +export type Annotations = Message<"flyteidl2.task.Annotations"> & { + /** + * Map of custom annotations to be applied to the execution resource. + * + * @generated from field: map values = 1; + */ + values: { [key: string]: string }; +}; + +/** + * Describes the message flyteidl2.task.Annotations. + * Use `create(AnnotationsSchema)` to create a new message. + */ +export const AnnotationsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_run, 1); + +/** + * Environment variable values to be applied to an execution resource. + * In the future a mode (e.g. OVERRIDE, APPEND, etc) can be defined + * to specify how to merge environment variables defined at registration and execution time. + * + * @generated from message flyteidl2.task.Envs + */ +export type Envs = Message<"flyteidl2.task.Envs"> & { + /** + * Map of custom environment variables to be applied to the execution resource. + * + * @generated from field: repeated flyteidl2.core.KeyValuePair values = 1; + */ + values: KeyValuePair[]; +}; + +/** + * Describes the message flyteidl2.task.Envs. + * Use `create(EnvsSchema)` to create a new message. + */ +export const EnvsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_run, 2); + +/** + * @generated from message flyteidl2.task.RawDataStorage + */ +export type RawDataStorage = Message<"flyteidl2.task.RawDataStorage"> & { + /** + * Prefix for where offloaded data from user actions will be written + * e.g. s3://bucket/key or s3://bucket/ + * + * @generated from field: string raw_data_prefix = 1; + */ + rawDataPrefix: string; +}; + +/** + * Describes the message flyteidl2.task.RawDataStorage. + * Use `create(RawDataStorageSchema)` to create a new message. + */ +export const RawDataStorageSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_run, 3); + +/** + * CacheConfig contains configurations that influence the behavior of cache reads and writes + * + * @generated from message flyteidl2.task.CacheConfig + */ +export type CacheConfig = Message<"flyteidl2.task.CacheConfig"> & { + /** + * If true, recompute outputs for this run and overwrite any existing cache. + * + * @generated from field: bool overwrite_cache = 1; + */ + overwriteCache: boolean; + + /** + * CacheLookupScope defines the cache lookup behavior. If left unspecified, the default value from the system config + * will be used (global unless configured otherwise). + * + * @generated from field: flyteidl2.task.CacheLookupScope cache_lookup_scope = 2; + */ + cacheLookupScope: CacheLookupScope; +}; + +/** + * Describes the message flyteidl2.task.CacheConfig. + * Use `create(CacheConfigSchema)` to create a new message. + */ +export const CacheConfigSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_run, 4); + +/** + * @generated from message flyteidl2.task.RunSpec + */ +export type RunSpec = Message<"flyteidl2.task.RunSpec"> & { + /** + * Labels to apply to the run. + * + * @generated from field: flyteidl2.task.Labels labels = 1; + */ + labels?: Labels; + + /** + * Annotations to apply to the run. + * + * @generated from field: flyteidl2.task.Annotations annotations = 2; + */ + annotations?: Annotations; + + /** + * Envs to apply to the run. + * + * @generated from field: flyteidl2.task.Envs envs = 3; + */ + envs?: Envs; + + /** + * Explicit override for executing this run as interruptible or not. If not set, use the default. + * + * @generated from field: google.protobuf.BoolValue interruptible = 4; + */ + interruptible?: boolean; + + /** + * If true, recompute outputs for this run and overwrite any existing cache. + * Deprecated, please use CacheConfig.OverwriteCache instead + * + * @generated from field: bool overwrite_cache = 5 [deprecated = true]; + * @deprecated + */ + overwriteCache: boolean; + + /** + * the specific cluster that this action should be executed on. this value will be used as the + * default for all actions in the run unless overridden. + * + * @generated from field: string cluster = 6; + */ + cluster: string; + + /** + * Encapsulates user settings pertaining to offloaded data (i.e. Blobs, Schema, query data, etc.). + * + * @generated from field: flyteidl2.task.RawDataStorage raw_data_storage = 7; + */ + rawDataStorage?: RawDataStorage; + + /** + * SecurityContext holds security attributes that apply to tasks. + * + * @generated from field: flyteidl2.core.SecurityContext security_context = 8; + */ + securityContext?: SecurityContext; + + /** + * CacheConfig contains configurations that influence the behavior of cache reads and writes + * + * @generated from field: flyteidl2.task.CacheConfig cache_config = 9; + */ + cacheConfig?: CacheConfig; +}; + +/** + * Describes the message flyteidl2.task.RunSpec. + * Use `create(RunSpecSchema)` to create a new message. + */ +export const RunSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_run, 5); + +/** + * @generated from enum flyteidl2.task.CacheLookupScope + */ +export enum CacheLookupScope { + /** + * CACHE_LOOKUP_SCOPE_UNSPECIFIED instructs cache lookup to follow the default behavior (global unless configured + * otherwise) + * + * @generated from enum value: CACHE_LOOKUP_SCOPE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * CACHE_LOOKUP_SCOPE_GLOBAL instructs cache lookups to do a global lookup (unless overridden by a system config). + * This has traditionally been the default behavior. It requires all workloads running in all projects/domains + * to have access to the same artifacts/buckets. Otherwise it risks runtime failures. + * + * @generated from enum value: CACHE_LOOKUP_SCOPE_GLOBAL = 1; + */ + GLOBAL = 1, + + /** + * CACHE_LOOKUP_SCOPE_PROJECT_DOMAIN instructs cache lookups to do a project-domain scoped lookup. This ensures + * data access success at the expense of potentially more cache misses and recomputation happening. This should not + * be considered a security enforcement (that can happen through the system-wide config). + * + * @generated from enum value: CACHE_LOOKUP_SCOPE_PROJECT_DOMAIN = 2; + */ + PROJECT_DOMAIN = 2, +} + +/** + * Describes the enum flyteidl2.task.CacheLookupScope. + */ +export const CacheLookupScopeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_task_run, 0); + diff --git a/gen/ts/flyteidl2/task/task_definition_pb.ts b/gen/ts/flyteidl2/task/task_definition_pb.ts new file mode 100644 index 0000000000..6788f14e21 --- /dev/null +++ b/gen/ts/flyteidl2/task/task_definition_pb.ts @@ -0,0 +1,589 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/task/task_definition.proto (package flyteidl2.task, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { RunIdentifier } from "../common/identifier_pb.ts"; +import { file_flyteidl2_common_identifier } from "../common/identifier_pb.ts"; +import type { EnrichedIdentity } from "../common/identity_pb.ts"; +import { file_flyteidl2_common_identity } from "../common/identity_pb.ts"; +import type { ActionPhase } from "../common/phase_pb.ts"; +import { file_flyteidl2_common_phase } from "../common/phase_pb.ts"; +import type { TypedInterface } from "../core/interface_pb.ts"; +import { file_flyteidl2_core_interface } from "../core/interface_pb.ts"; +import type { TaskTemplate } from "../core/tasks_pb.ts"; +import { file_flyteidl2_core_tasks } from "../core/tasks_pb.ts"; +import type { Inputs, NamedParameter, TriggerAutomationSpec } from "./common_pb.ts"; +import { file_flyteidl2_task_common } from "./common_pb.ts"; +import type { Environment } from "./environment_pb.ts"; +import { file_flyteidl2_task_environment } from "./environment_pb.ts"; +import type { RunSpec } from "./run_pb.ts"; +import { file_flyteidl2_task_run } from "./run_pb.ts"; +import type { Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/task/task_definition.proto. + */ +export const file_flyteidl2_task_task_definition: GenFile = /*@__PURE__*/ + fileDesc("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", [file_buf_validate_validate, file_flyteidl2_common_identifier, file_flyteidl2_common_identity, file_flyteidl2_common_phase, file_flyteidl2_core_interface, file_flyteidl2_core_tasks, file_flyteidl2_task_common, file_flyteidl2_task_environment, file_flyteidl2_task_run, file_google_protobuf_timestamp]); + +/** + * Name of a task. It may have multiple versions deployed. + * + * @generated from message flyteidl2.task.TaskName + */ +export type TaskName = Message<"flyteidl2.task.TaskName"> & { + /** + * Org this task belongs to. + * + * @generated from field: string org = 1; + */ + org: string; + + /** + * Project this task belongs to. + * + * @generated from field: string project = 2; + */ + project: string; + + /** + * Domain this task belongs to. + * + * @generated from field: string domain = 3; + */ + domain: string; + + /** + * Unique name of the task. Should not be interpreted/parsed. Use `short_name` and `environment_name` for user facing names. + * + * @generated from field: string name = 4; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.task.TaskName. + * Use `create(TaskNameSchema)` to create a new message. + */ +export const TaskNameSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_definition, 0); + +/** + * TaskIdentifier is the unique identifier for a task. + * + * @generated from message flyteidl2.task.TaskIdentifier + */ +export type TaskIdentifier = Message<"flyteidl2.task.TaskIdentifier"> & { + /** + * Org this task belongs to. + * + * @generated from field: string org = 1; + */ + org: string; + + /** + * Project this task belongs to. + * + * @generated from field: string project = 2; + */ + project: string; + + /** + * Domain this task belongs to. + * + * @generated from field: string domain = 3; + */ + domain: string; + + /** + * Unique name of the task. Should not be interpreted/parsed. Use `short_name` and `environment_name` for user facing names. + * + * @generated from field: string name = 4; + */ + name: string; + + /** + * Version of the task. + * + * @generated from field: string version = 5; + */ + version: string; +}; + +/** + * Describes the message flyteidl2.task.TaskIdentifier. + * Use `create(TaskIdentifierSchema)` to create a new message. + */ +export const TaskIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_definition, 1); + +/** + * @generated from message flyteidl2.task.TaskTriggersSummary + */ +export type TaskTriggersSummary = Message<"flyteidl2.task.TaskTriggersSummary"> & { + /** + * @generated from oneof flyteidl2.task.TaskTriggersSummary.summary + */ + summary: { + /** + * @generated from field: flyteidl2.task.TaskTriggersSummary.TriggerDetails details = 3; + */ + value: TaskTriggersSummary_TriggerDetails; + case: "details"; + } | { + /** + * @generated from field: flyteidl2.task.TaskTriggersSummary.TriggerStats stats = 2; + */ + value: TaskTriggersSummary_TriggerStats; + case: "stats"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.task.TaskTriggersSummary. + * Use `create(TaskTriggersSummarySchema)` to create a new message. + */ +export const TaskTriggersSummarySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_definition, 2); + +/** + * @generated from message flyteidl2.task.TaskTriggersSummary.TriggerDetails + */ +export type TaskTriggersSummary_TriggerDetails = Message<"flyteidl2.task.TaskTriggersSummary.TriggerDetails"> & { + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * @generated from field: bool active = 2; + */ + active: boolean; + + /** + * @generated from field: flyteidl2.task.TriggerAutomationSpec automation_spec = 3; + */ + automationSpec?: TriggerAutomationSpec; +}; + +/** + * Describes the message flyteidl2.task.TaskTriggersSummary.TriggerDetails. + * Use `create(TaskTriggersSummary_TriggerDetailsSchema)` to create a new message. + */ +export const TaskTriggersSummary_TriggerDetailsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_definition, 2, 0); + +/** + * @generated from message flyteidl2.task.TaskTriggersSummary.TriggerStats + */ +export type TaskTriggersSummary_TriggerStats = Message<"flyteidl2.task.TaskTriggersSummary.TriggerStats"> & { + /** + * @generated from field: uint32 total = 1; + */ + total: number; + + /** + * @generated from field: uint32 active = 2; + */ + active: number; +}; + +/** + * Describes the message flyteidl2.task.TaskTriggersSummary.TriggerStats. + * Use `create(TaskTriggersSummary_TriggerStatsSchema)` to create a new message. + */ +export const TaskTriggersSummary_TriggerStatsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_definition, 2, 1); + +/** + * LatestRunSummary contains minimal information about the most recent run of a task. + * This is a lightweight summary that avoids circular dependencies with workflow package. + * + * @generated from message flyteidl2.task.LatestRunSummary + */ +export type LatestRunSummary = Message<"flyteidl2.task.LatestRunSummary"> & { + /** + * Run identifier + * + * @generated from field: flyteidl2.common.RunIdentifier run_id = 1; + */ + runId?: RunIdentifier; + + /** + * Last run time + * + * @generated from field: google.protobuf.Timestamp run_time = 2; + */ + runTime?: Timestamp; + + /** + * Phase of the last run + * + * @generated from field: flyteidl2.common.ActionPhase phase = 3; + */ + phase: ActionPhase; + + /** + * Name of the root task of the last run (env.task name) + * + * @generated from field: string root_task_name = 4; + */ + rootTaskName: string; +}; + +/** + * Describes the message flyteidl2.task.LatestRunSummary. + * Use `create(LatestRunSummarySchema)` to create a new message. + */ +export const LatestRunSummarySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_definition, 3); + +/** + * TaskMetadata is static, lightweight metadata about a task. + * + * @generated from message flyteidl2.task.TaskMetadata + */ +export type TaskMetadata = Message<"flyteidl2.task.TaskMetadata"> & { + /** + * Identity that deployed the task. + * + * @generated from field: flyteidl2.common.EnrichedIdentity deployed_by = 1; + */ + deployedBy?: EnrichedIdentity; + + /** + * The short name for this task + * + * @generated from field: string short_name = 2; + */ + shortName: string; + + /** + * The time the task was deployed + * + * @generated from field: google.protobuf.Timestamp deployed_at = 3; + */ + deployedAt?: Timestamp; + + /** + * The environment name for this task, if present. + * + * @generated from field: string environment_name = 4; + */ + environmentName: string; + + /** + * Brief overview of attached triggers if any. + * + * @generated from field: flyteidl2.task.TaskTriggersSummary triggers_summary = 5; + */ + triggersSummary?: TaskTriggersSummary; + + /** + * The short description for this task + * + * @generated from field: string short_description = 6; + */ + shortDescription: string; +}; + +/** + * Describes the message flyteidl2.task.TaskMetadata. + * Use `create(TaskMetadataSchema)` to create a new message. + */ +export const TaskMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_definition, 4); + +/** + * @generated from message flyteidl2.task.TaskSummary + */ +export type TaskSummary = Message<"flyteidl2.task.TaskSummary"> & { + /** + * Summary of the latest run for this task, if any + * + * @generated from field: optional flyteidl2.task.LatestRunSummary latest_run = 1; + */ + latestRun?: LatestRunSummary; +}; + +/** + * Describes the message flyteidl2.task.TaskSummary. + * Use `create(TaskSummarySchema)` to create a new message. + */ +export const TaskSummarySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_definition, 5); + +/** + * Lightweight representation of a task. + * + * @generated from message flyteidl2.task.Task + */ +export type Task = Message<"flyteidl2.task.Task"> & { + /** + * Id for this task. + * + * @generated from field: flyteidl2.task.TaskIdentifier task_id = 1; + */ + taskId?: TaskIdentifier; + + /** + * Metadata for this task. + * + * @generated from field: flyteidl2.task.TaskMetadata metadata = 2; + */ + metadata?: TaskMetadata; + + /** + * Summary for this task. + * + * @generated from field: optional flyteidl2.task.TaskSummary task_summary = 3; + */ + taskSummary?: TaskSummary; +}; + +/** + * Describes the message flyteidl2.task.Task. + * Use `create(TaskSchema)` to create a new message. + */ +export const TaskSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_definition, 6); + +/** + * Link to source code used to define this entity + * + * @generated from message flyteidl2.task.SourceCode + */ +export type SourceCode = Message<"flyteidl2.task.SourceCode"> & { + /** + * @generated from field: string link = 1; + */ + link: string; +}; + +/** + * Describes the message flyteidl2.task.SourceCode. + * Use `create(SourceCodeSchema)` to create a new message. + */ +export const SourceCodeSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_definition, 7); + +/** + * @generated from message flyteidl2.task.DocumentationEntity + */ +export type DocumentationEntity = Message<"flyteidl2.task.DocumentationEntity"> & { + /** + * One-liner overview of the entity. + * + * @generated from field: string short_description = 1; + */ + shortDescription: string; + + /** + * Full user description with formatting preserved. + * + * @generated from field: string long_description = 2; + */ + longDescription: string; + + /** + * Optional link to source code used to define this entity. + * + * @generated from field: flyteidl2.task.SourceCode source_code = 3; + */ + sourceCode?: SourceCode; +}; + +/** + * Describes the message flyteidl2.task.DocumentationEntity. + * Use `create(DocumentationEntitySchema)` to create a new message. + */ +export const DocumentationEntitySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_definition, 8); + +/** + * Specification for a task. + * + * @generated from message flyteidl2.task.TaskSpec + */ +export type TaskSpec = Message<"flyteidl2.task.TaskSpec"> & { + /** + * The template for this task. + * + * @generated from field: flyteidl2.core.TaskTemplate task_template = 1; + */ + taskTemplate?: TaskTemplate; + + /** + * Ordered default inputs. + * These can be overridden when an run is created. + * Client should not send required=true flag in underlying flyteidl2.core.Parameter. + * + * @generated from field: repeated flyteidl2.task.NamedParameter default_inputs = 2; + */ + defaultInputs: NamedParameter[]; + + /** + * User facing display name for this task. Not required to be unique. + * This is passed in via the SDK when the task is created and is either a user defined override or the name of the task. + * + * @generated from field: string short_name = 3; + */ + shortName: string; + + /** + * Optional environment for this task. Note, some tasks may not be run in the context of an environment. + * + * @generated from field: flyteidl2.task.Environment environment = 4; + */ + environment?: Environment; + + /** + * The documentation entity for the task + * + * @generated from field: flyteidl2.task.DocumentationEntity documentation = 5; + */ + documentation?: DocumentationEntity; +}; + +/** + * Describes the message flyteidl2.task.TaskSpec. + * Use `create(TaskSpecSchema)` to create a new message. + */ +export const TaskSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_definition, 9); + +/** + * Specification for a trace action. + * + * @generated from message flyteidl2.task.TraceSpec + */ +export type TraceSpec = Message<"flyteidl2.task.TraceSpec"> & { + /** + * A strongly typed interface for the trace. + * + * @generated from field: flyteidl2.core.TypedInterface interface = 1; + */ + interface?: TypedInterface; +}; + +/** + * Describes the message flyteidl2.task.TraceSpec. + * Use `create(TraceSpecSchema)` to create a new message. + */ +export const TraceSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_definition, 10); + +/** + * Detailed information about a task. + * + * @generated from message flyteidl2.task.TaskDetails + */ +export type TaskDetails = Message<"flyteidl2.task.TaskDetails"> & { + /** + * Id for this task. + * + * @generated from field: flyteidl2.task.TaskIdentifier task_id = 1; + */ + taskId?: TaskIdentifier; + + /** + * Metadata for this task. + * + * @generated from field: flyteidl2.task.TaskMetadata metadata = 2; + */ + metadata?: TaskMetadata; + + /** + * Specification for this task. + * + * @generated from field: flyteidl2.task.TaskSpec spec = 3; + */ + spec?: TaskSpec; +}; + +/** + * Describes the message flyteidl2.task.TaskDetails. + * Use `create(TaskDetailsSchema)` to create a new message. + */ +export const TaskDetailsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_definition, 11); + +/** + * Contains details about a single trigger attached to a task. Should only be used in DeployTask endpoint. + * + * @generated from message flyteidl2.task.TaskTrigger + */ +export type TaskTrigger = Message<"flyteidl2.task.TaskTrigger"> & { + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * @generated from field: flyteidl2.task.TaskTriggerSpec spec = 2; + */ + spec?: TaskTriggerSpec; + + /** + * Optional automation spec. + * + * @generated from field: flyteidl2.task.TriggerAutomationSpec automation_spec = 3; + */ + automationSpec?: TriggerAutomationSpec; +}; + +/** + * Describes the message flyteidl2.task.TaskTrigger. + * Use `create(TaskTriggerSchema)` to create a new message. + */ +export const TaskTriggerSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_definition, 12); + +/** + * TaskTriggerSpec this is a copy of TriggerSpec without mandatory 'task_version' field. + * This is supposed to be used only in DeployTask endpoint where 'task_version' is already provided in task_id. + * + * @generated from message flyteidl2.task.TaskTriggerSpec + */ +export type TaskTriggerSpec = Message<"flyteidl2.task.TaskTriggerSpec"> & { + /** + * Whether trigger is active + * + * @generated from field: bool active = 1; + */ + active: boolean; + + /** + * Inputs for triggered task. + * + * @generated from field: flyteidl2.task.Inputs inputs = 2; + */ + inputs?: Inputs; + + /** + * The run spec for triggered task. + * + * @generated from field: flyteidl2.task.RunSpec run_spec = 3; + */ + runSpec?: RunSpec; + + /** + * Optional description + * + * @generated from field: string description = 4; + */ + description: string; +}; + +/** + * Describes the message flyteidl2.task.TaskTriggerSpec. + * Use `create(TaskTriggerSpecSchema)` to create a new message. + */ +export const TaskTriggerSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_definition, 13); + diff --git a/gen/ts/flyteidl2/task/task_service_pb.ts b/gen/ts/flyteidl2/task/task_service_pb.ts new file mode 100644 index 0000000000..6e879f593a --- /dev/null +++ b/gen/ts/flyteidl2/task/task_service_pb.ts @@ -0,0 +1,373 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/task/task_service.proto (package flyteidl2.task, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { ProjectIdentifier } from "../common/identifier_pb.ts"; +import { file_flyteidl2_common_identifier } from "../common/identifier_pb.ts"; +import type { ListRequest } from "../common/list_pb.ts"; +import { file_flyteidl2_common_list } from "../common/list_pb.ts"; +import type { Task, TaskDetails, TaskIdentifier, TaskName, TaskSpec, TaskTrigger } from "./task_definition_pb.ts"; +import { file_flyteidl2_task_task_definition } from "./task_definition_pb.ts"; +import type { Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/task/task_service.proto. + */ +export const file_flyteidl2_task_task_service: GenFile = /*@__PURE__*/ + fileDesc("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", [file_buf_validate_validate, file_flyteidl2_common_identifier, file_flyteidl2_common_list, file_flyteidl2_task_task_definition, file_google_protobuf_timestamp]); + +/** + * Request message for deploying a task. + * + * @generated from message flyteidl2.task.DeployTaskRequest + */ +export type DeployTaskRequest = Message<"flyteidl2.task.DeployTaskRequest"> & { + /** + * The user provided task id. + * + * @generated from field: flyteidl2.task.TaskIdentifier task_id = 1; + */ + taskId?: TaskIdentifier; + + /** + * Specification for the task. + * + * @generated from field: flyteidl2.task.TaskSpec spec = 2; + */ + spec?: TaskSpec; + + /** + * Optional, set of triggers for a given task. Replaces previous set of triggers entirely if any. + * + * @generated from field: repeated flyteidl2.task.TaskTrigger triggers = 3; + */ + triggers: TaskTrigger[]; +}; + +/** + * Describes the message flyteidl2.task.DeployTaskRequest. + * Use `create(DeployTaskRequestSchema)` to create a new message. + */ +export const DeployTaskRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_service, 0); + +/** + * Response message for deploying a task. + * + * @generated from message flyteidl2.task.DeployTaskResponse + */ +export type DeployTaskResponse = Message<"flyteidl2.task.DeployTaskResponse"> & { +}; + +/** + * Describes the message flyteidl2.task.DeployTaskResponse. + * Use `create(DeployTaskResponseSchema)` to create a new message. + */ +export const DeployTaskResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_service, 1); + +/** + * Request message for getting detailed information about a task. + * + * @generated from message flyteidl2.task.GetTaskDetailsRequest + */ +export type GetTaskDetailsRequest = Message<"flyteidl2.task.GetTaskDetailsRequest"> & { + /** + * Id of the task. + * + * @generated from field: flyteidl2.task.TaskIdentifier task_id = 1; + */ + taskId?: TaskIdentifier; +}; + +/** + * Describes the message flyteidl2.task.GetTaskDetailsRequest. + * Use `create(GetTaskDetailsRequestSchema)` to create a new message. + */ +export const GetTaskDetailsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_service, 2); + +/** + * Response message for deploying a task. + * + * @generated from message flyteidl2.task.GetTaskDetailsResponse + */ +export type GetTaskDetailsResponse = Message<"flyteidl2.task.GetTaskDetailsResponse"> & { + /** + * Detailed information about the task. + * + * @generated from field: flyteidl2.task.TaskDetails details = 1; + */ + details?: TaskDetails; +}; + +/** + * Describes the message flyteidl2.task.GetTaskDetailsResponse. + * Use `create(GetTaskDetailsResponseSchema)` to create a new message. + */ +export const GetTaskDetailsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_service, 3); + +/** + * @generated from message flyteidl2.task.ListTasksRequest + */ +export type ListTasksRequest = Message<"flyteidl2.task.ListTasksRequest"> & { + /** + * Common list request parameters. + * + * @generated from field: flyteidl2.common.ListRequest request = 1; + */ + request?: ListRequest; + + /** + * @generated from oneof flyteidl2.task.ListTasksRequest.scope_by + */ + scopeBy: { + /** + * Organization name for filtering. + * + * @generated from field: string org = 2; + */ + value: string; + case: "org"; + } | { + /** + * Project identifier for filtering. + * + * @generated from field: flyteidl2.common.ProjectIdentifier project_id = 3; + */ + value: ProjectIdentifier; + case: "projectId"; + } | { case: undefined; value?: undefined }; + + /** + * Known filters for listing tasks. + * + * @generated from field: repeated flyteidl2.task.ListTasksRequest.KnownFilter known_filters = 4; + */ + knownFilters: ListTasksRequest_KnownFilter[]; +}; + +/** + * Describes the message flyteidl2.task.ListTasksRequest. + * Use `create(ListTasksRequestSchema)` to create a new message. + */ +export const ListTasksRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_service, 4); + +/** + * @generated from message flyteidl2.task.ListTasksRequest.KnownFilter + */ +export type ListTasksRequest_KnownFilter = Message<"flyteidl2.task.ListTasksRequest.KnownFilter"> & { + /** + * @generated from oneof flyteidl2.task.ListTasksRequest.KnownFilter.filter_by + */ + filterBy: { + /** + * Filter by user + * + * @generated from field: string deployed_by = 1; + */ + value: string; + case: "deployedBy"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.task.ListTasksRequest.KnownFilter. + * Use `create(ListTasksRequest_KnownFilterSchema)` to create a new message. + */ +export const ListTasksRequest_KnownFilterSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_service, 4, 0); + +/** + * @generated from message flyteidl2.task.ListTasksResponse + */ +export type ListTasksResponse = Message<"flyteidl2.task.ListTasksResponse"> & { + /** + * @generated from field: repeated flyteidl2.task.Task tasks = 1; + */ + tasks: Task[]; + + /** + * Pagination token for the next page of tasks. + * + * @generated from field: string token = 2; + */ + token: string; + + /** + * Metadata for the ListTasksResponse + * + * @generated from field: flyteidl2.task.ListTasksResponse.ListTasksMetadata metadata = 3; + */ + metadata?: ListTasksResponse_ListTasksMetadata; +}; + +/** + * Describes the message flyteidl2.task.ListTasksResponse. + * Use `create(ListTasksResponseSchema)` to create a new message. + */ +export const ListTasksResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_service, 5); + +/** + * @generated from message flyteidl2.task.ListTasksResponse.ListTasksMetadata + */ +export type ListTasksResponse_ListTasksMetadata = Message<"flyteidl2.task.ListTasksResponse.ListTasksMetadata"> & { + /** + * Total number of tasks without filters applied + * + * @generated from field: uint32 total = 1; + */ + total: number; + + /** + * Total number of tasks matching the applied filters. + * + * @generated from field: uint32 filtered_total = 2; + */ + filteredTotal: number; +}; + +/** + * Describes the message flyteidl2.task.ListTasksResponse.ListTasksMetadata. + * Use `create(ListTasksResponse_ListTasksMetadataSchema)` to create a new message. + */ +export const ListTasksResponse_ListTasksMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_service, 5, 0); + +/** + * Request message for listing versions for a task. + * + * @generated from message flyteidl2.task.ListVersionsRequest + */ +export type ListVersionsRequest = Message<"flyteidl2.task.ListVersionsRequest"> & { + /** + * Common list request parameters. + * + * @generated from field: flyteidl2.common.ListRequest request = 1; + */ + request?: ListRequest; + + /** + * Id of the task. + * + * @generated from field: flyteidl2.task.TaskName task_name = 2; + */ + taskName?: TaskName; +}; + +/** + * Describes the message flyteidl2.task.ListVersionsRequest. + * Use `create(ListVersionsRequestSchema)` to create a new message. + */ +export const ListVersionsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_service, 6); + +/** + * Response message for listing versions. + * + * @generated from message flyteidl2.task.ListVersionsResponse + */ +export type ListVersionsResponse = Message<"flyteidl2.task.ListVersionsResponse"> & { + /** + * Version with deployed_at + * + * @generated from field: repeated flyteidl2.task.ListVersionsResponse.VersionResponse versions = 1; + */ + versions: ListVersionsResponse_VersionResponse[]; + + /** + * Pagination token for the next page of versions. + * + * @generated from field: string token = 2; + */ + token: string; +}; + +/** + * Describes the message flyteidl2.task.ListVersionsResponse. + * Use `create(ListVersionsResponseSchema)` to create a new message. + */ +export const ListVersionsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_service, 7); + +/** + * @generated from message flyteidl2.task.ListVersionsResponse.VersionResponse + */ +export type ListVersionsResponse_VersionResponse = Message<"flyteidl2.task.ListVersionsResponse.VersionResponse"> & { + /** + * @generated from field: string version = 1; + */ + version: string; + + /** + * The time the task version was deployed + * + * @generated from field: google.protobuf.Timestamp deployed_at = 2; + */ + deployedAt?: Timestamp; +}; + +/** + * Describes the message flyteidl2.task.ListVersionsResponse.VersionResponse. + * Use `create(ListVersionsResponse_VersionResponseSchema)` to create a new message. + */ +export const ListVersionsResponse_VersionResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_task_task_service, 7, 0); + +/** + * TaskService provides an interface for managing tasks. + * + * @generated from service flyteidl2.task.TaskService + */ +export const TaskService: GenService<{ + /** + * Deploy a task. + * + * @generated from rpc flyteidl2.task.TaskService.DeployTask + */ + deployTask: { + methodKind: "unary"; + input: typeof DeployTaskRequestSchema; + output: typeof DeployTaskResponseSchema; + }, + /** + * Get detailed information about a task. + * + * @generated from rpc flyteidl2.task.TaskService.GetTaskDetails + */ + getTaskDetails: { + methodKind: "unary"; + input: typeof GetTaskDetailsRequestSchema; + output: typeof GetTaskDetailsResponseSchema; + }, + /** + * Lists tasks, one per task name, returning the latest version and who it was deployed by. + * + * @generated from rpc flyteidl2.task.TaskService.ListTasks + */ + listTasks: { + methodKind: "unary"; + input: typeof ListTasksRequestSchema; + output: typeof ListTasksResponseSchema; + }, + /** + * Lists all versions for a task. + * + * @generated from rpc flyteidl2.task.TaskService.ListVersions + */ + listVersions: { + methodKind: "unary"; + input: typeof ListVersionsRequestSchema; + output: typeof ListVersionsResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_task_task_service, 0); + diff --git a/gen/ts/flyteidl2/trigger/trigger_definition_pb.ts b/gen/ts/flyteidl2/trigger/trigger_definition_pb.ts new file mode 100644 index 0000000000..ef8e5781e3 --- /dev/null +++ b/gen/ts/flyteidl2/trigger/trigger_definition_pb.ts @@ -0,0 +1,304 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/trigger/trigger_definition.proto (package flyteidl2.trigger, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { TriggerIdentifier } from "../common/identifier_pb.ts"; +import { file_flyteidl2_common_identifier } from "../common/identifier_pb.ts"; +import type { EnrichedIdentity } from "../common/identity_pb.ts"; +import { file_flyteidl2_common_identity } from "../common/identity_pb.ts"; +import type { Inputs, TriggerAutomationSpec } from "../task/common_pb.ts"; +import { file_flyteidl2_task_common } from "../task/common_pb.ts"; +import type { RunSpec } from "../task/run_pb.ts"; +import { file_flyteidl2_task_run } from "../task/run_pb.ts"; +import type { Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/trigger/trigger_definition.proto. + */ +export const file_flyteidl2_trigger_trigger_definition: GenFile = /*@__PURE__*/ + fileDesc("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", [file_buf_validate_validate, file_flyteidl2_common_identifier, file_flyteidl2_common_identity, file_flyteidl2_task_common, file_flyteidl2_task_run, file_google_protobuf_timestamp]); + +/** + * @generated from message flyteidl2.trigger.TriggerMetadata + */ +export type TriggerMetadata = Message<"flyteidl2.trigger.TriggerMetadata"> & { + /** + * Identity that last deployed the trigger + * + * @generated from field: flyteidl2.common.EnrichedIdentity deployed_by = 1; + */ + deployedBy?: EnrichedIdentity; + + /** + * Identity that last activated or deactivated the trigger + * + * @generated from field: flyteidl2.common.EnrichedIdentity updated_by = 2; + */ + updatedBy?: EnrichedIdentity; +}; + +/** + * Describes the message flyteidl2.trigger.TriggerMetadata. + * Use `create(TriggerMetadataSchema)` to create a new message. + */ +export const TriggerMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_definition, 0); + +/** + * @generated from message flyteidl2.trigger.TriggerSpec + */ +export type TriggerSpec = Message<"flyteidl2.trigger.TriggerSpec"> & { + /** + * Inputs for triggered task. + * + * @generated from field: flyteidl2.task.Inputs inputs = 2; + */ + inputs?: Inputs; + + /** + * The run spec for triggered task. + * + * @generated from field: flyteidl2.task.RunSpec run_spec = 3; + */ + runSpec?: RunSpec; + + /** + * Whether trigger is active + * + * @generated from field: bool active = 4; + */ + active: boolean; + + /** + * Task version together with trigger name will give us the unique task id + * + * @generated from field: string task_version = 5; + */ + taskVersion: string; + + /** + * Optional description + * + * @generated from field: string description = 6; + */ + description: string; +}; + +/** + * Describes the message flyteidl2.trigger.TriggerSpec. + * Use `create(TriggerSpecSchema)` to create a new message. + */ +export const TriggerSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_definition, 1); + +/** + * @generated from message flyteidl2.trigger.TriggerStatus + */ +export type TriggerStatus = Message<"flyteidl2.trigger.TriggerStatus"> & { + /** + * The first time trigger was deployed. + * + * @generated from field: google.protobuf.Timestamp deployed_at = 1; + */ + deployedAt?: Timestamp; + + /** + * The last time the trigger was updated. + * + * @generated from field: google.protobuf.Timestamp updated_at = 2; + */ + updatedAt?: Timestamp; + + /** + * The last time the trigger fired. + * + * @generated from field: google.protobuf.Timestamp triggered_at = 3; + */ + triggeredAt?: Timestamp; + + /** + * The time trigger was deleted. + * + * @generated from field: google.protobuf.Timestamp deleted_at = 4; + */ + deletedAt?: Timestamp; +}; + +/** + * Describes the message flyteidl2.trigger.TriggerStatus. + * Use `create(TriggerStatusSchema)` to create a new message. + */ +export const TriggerStatusSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_definition, 2); + +/** + * Light-weight information about a single trigger revision + * + * @generated from message flyteidl2.trigger.TriggerRevision + */ +export type TriggerRevision = Message<"flyteidl2.trigger.TriggerRevision"> & { + /** + * @generated from field: flyteidl2.common.TriggerIdentifier id = 1; + */ + id?: TriggerIdentifier; + + /** + * @generated from field: flyteidl2.trigger.TriggerMetadata metadata = 2; + */ + metadata?: TriggerMetadata; + + /** + * @generated from field: flyteidl2.trigger.TriggerStatus status = 3; + */ + status?: TriggerStatus; + + /** + * @generated from field: flyteidl2.trigger.TriggerRevisionAction action = 4; + */ + action: TriggerRevisionAction; + + /** + * Timestamp at which given revision was created. + * + * @generated from field: google.protobuf.Timestamp created_at = 5; + */ + createdAt?: Timestamp; +}; + +/** + * Describes the message flyteidl2.trigger.TriggerRevision. + * Use `create(TriggerRevisionSchema)` to create a new message. + */ +export const TriggerRevisionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_definition, 3); + +/** + * Full details about a trigger stored in DB + * + * @generated from message flyteidl2.trigger.TriggerDetails + */ +export type TriggerDetails = Message<"flyteidl2.trigger.TriggerDetails"> & { + /** + * @generated from field: flyteidl2.common.TriggerIdentifier id = 1; + */ + id?: TriggerIdentifier; + + /** + * @generated from field: flyteidl2.trigger.TriggerMetadata metadata = 2; + */ + metadata?: TriggerMetadata; + + /** + * @generated from field: flyteidl2.trigger.TriggerSpec spec = 3; + */ + spec?: TriggerSpec; + + /** + * @generated from field: flyteidl2.trigger.TriggerStatus status = 4; + */ + status?: TriggerStatus; + + /** + * Optional automation spec. + * + * @generated from field: flyteidl2.task.TriggerAutomationSpec automation_spec = 5; + */ + automationSpec?: TriggerAutomationSpec; + + /** + * Trigger description + * + * @generated from field: optional string description = 6; + */ + description?: string; +}; + +/** + * Describes the message flyteidl2.trigger.TriggerDetails. + * Use `create(TriggerDetailsSchema)` to create a new message. + */ +export const TriggerDetailsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_definition, 4); + +/** + * Light-weight information about trigger for a list view + * + * @generated from message flyteidl2.trigger.Trigger + */ +export type Trigger = Message<"flyteidl2.trigger.Trigger"> & { + /** + * @generated from field: flyteidl2.common.TriggerIdentifier id = 1; + */ + id?: TriggerIdentifier; + + /** + * @generated from field: flyteidl2.trigger.TriggerMetadata metadata = 2; + */ + metadata?: TriggerMetadata; + + /** + * @generated from field: flyteidl2.trigger.TriggerStatus status = 3; + */ + status?: TriggerStatus; + + /** + * @generated from field: bool active = 5; + */ + active: boolean; + + /** + * @generated from field: flyteidl2.task.TriggerAutomationSpec automation_spec = 6; + */ + automationSpec?: TriggerAutomationSpec; +}; + +/** + * Describes the message flyteidl2.trigger.Trigger. + * Use `create(TriggerSchema)` to create a new message. + */ +export const TriggerSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_definition, 5); + +/** + * Stores human- and machine-friendly explanation of what changed in the revision + * + * @generated from enum flyteidl2.trigger.TriggerRevisionAction + */ +export enum TriggerRevisionAction { + /** + * @generated from enum value: TRIGGER_REVISION_ACTION_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: TRIGGER_REVISION_ACTION_DEPLOY = 1; + */ + DEPLOY = 1, + + /** + * @generated from enum value: TRIGGER_REVISION_ACTION_ACTIVATE = 2; + */ + ACTIVATE = 2, + + /** + * @generated from enum value: TRIGGER_REVISION_ACTION_DEACTIVATE = 3; + */ + DEACTIVATE = 3, + + /** + * @generated from enum value: TRIGGER_REVISION_ACTION_DELETE = 4; + */ + DELETE = 4, +} + +/** + * Describes the enum flyteidl2.trigger.TriggerRevisionAction. + */ +export const TriggerRevisionActionSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_trigger_trigger_definition, 0); + diff --git a/gen/ts/flyteidl2/trigger/trigger_service_pb.ts b/gen/ts/flyteidl2/trigger/trigger_service_pb.ts new file mode 100644 index 0000000000..72f72fa3f1 --- /dev/null +++ b/gen/ts/flyteidl2/trigger/trigger_service_pb.ts @@ -0,0 +1,451 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/trigger/trigger_service.proto (package flyteidl2.trigger, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { ProjectIdentifier, TriggerIdentifier, TriggerName } from "../common/identifier_pb.ts"; +import { file_flyteidl2_common_identifier } from "../common/identifier_pb.ts"; +import type { ListRequest } from "../common/list_pb.ts"; +import { file_flyteidl2_common_list } from "../common/list_pb.ts"; +import type { TriggerAutomationSpec } from "../task/common_pb.ts"; +import { file_flyteidl2_task_common } from "../task/common_pb.ts"; +import type { TaskIdentifier, TaskName } from "../task/task_definition_pb.ts"; +import { file_flyteidl2_task_task_definition } from "../task/task_definition_pb.ts"; +import type { Trigger, TriggerDetails, TriggerRevision, TriggerSpec } from "./trigger_definition_pb.ts"; +import { file_flyteidl2_trigger_trigger_definition } from "./trigger_definition_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/trigger/trigger_service.proto. + */ +export const file_flyteidl2_trigger_trigger_service: GenFile = /*@__PURE__*/ + fileDesc("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", [file_buf_validate_validate, file_flyteidl2_common_identifier, file_flyteidl2_common_list, file_flyteidl2_task_common, file_flyteidl2_task_task_definition, file_flyteidl2_trigger_trigger_definition]); + +/** + * Request message for saving a trigger. + * + * @generated from message flyteidl2.trigger.DeployTriggerRequest + */ +export type DeployTriggerRequest = Message<"flyteidl2.trigger.DeployTriggerRequest"> & { + /** + * @generated from field: flyteidl2.common.TriggerName name = 4; + */ + name?: TriggerName; + + /** + * Revision of the trigger. + * Optional for the initial deploy of the trigger. + * Mandatory for updating existing trigger and should store latest previously deployed revision. + * + * @generated from field: uint64 revision = 5; + */ + revision: bigint; + + /** + * @generated from field: flyteidl2.trigger.TriggerSpec spec = 2; + */ + spec?: TriggerSpec; + + /** + * Optional automation spec. + * + * @generated from field: flyteidl2.task.TriggerAutomationSpec automation_spec = 3; + */ + automationSpec?: TriggerAutomationSpec; +}; + +/** + * Describes the message flyteidl2.trigger.DeployTriggerRequest. + * Use `create(DeployTriggerRequestSchema)` to create a new message. + */ +export const DeployTriggerRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_service, 0); + +/** + * Response message for saving a trigger. + * + * @generated from message flyteidl2.trigger.DeployTriggerResponse + */ +export type DeployTriggerResponse = Message<"flyteidl2.trigger.DeployTriggerResponse"> & { + /** + * @generated from field: flyteidl2.trigger.TriggerDetails trigger = 1; + */ + trigger?: TriggerDetails; +}; + +/** + * Describes the message flyteidl2.trigger.DeployTriggerResponse. + * Use `create(DeployTriggerResponseSchema)` to create a new message. + */ +export const DeployTriggerResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_service, 1); + +/** + * Request message for saving a trigger. + * + * @generated from message flyteidl2.trigger.GetTriggerDetailsRequest + */ +export type GetTriggerDetailsRequest = Message<"flyteidl2.trigger.GetTriggerDetailsRequest"> & { + /** + * @generated from field: flyteidl2.common.TriggerName name = 1; + */ + name?: TriggerName; +}; + +/** + * Describes the message flyteidl2.trigger.GetTriggerDetailsRequest. + * Use `create(GetTriggerDetailsRequestSchema)` to create a new message. + */ +export const GetTriggerDetailsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_service, 2); + +/** + * Response message for saving a trigger. + * + * @generated from message flyteidl2.trigger.GetTriggerDetailsResponse + */ +export type GetTriggerDetailsResponse = Message<"flyteidl2.trigger.GetTriggerDetailsResponse"> & { + /** + * @generated from field: flyteidl2.trigger.TriggerDetails trigger = 1; + */ + trigger?: TriggerDetails; +}; + +/** + * Describes the message flyteidl2.trigger.GetTriggerDetailsResponse. + * Use `create(GetTriggerDetailsResponseSchema)` to create a new message. + */ +export const GetTriggerDetailsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_service, 3); + +/** + * Request message for saving a trigger. + * + * @generated from message flyteidl2.trigger.GetTriggerRevisionDetailsRequest + */ +export type GetTriggerRevisionDetailsRequest = Message<"flyteidl2.trigger.GetTriggerRevisionDetailsRequest"> & { + /** + * @generated from field: flyteidl2.common.TriggerIdentifier id = 1; + */ + id?: TriggerIdentifier; +}; + +/** + * Describes the message flyteidl2.trigger.GetTriggerRevisionDetailsRequest. + * Use `create(GetTriggerRevisionDetailsRequestSchema)` to create a new message. + */ +export const GetTriggerRevisionDetailsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_service, 4); + +/** + * Response message for saving a trigger. + * + * @generated from message flyteidl2.trigger.GetTriggerRevisionDetailsResponse + */ +export type GetTriggerRevisionDetailsResponse = Message<"flyteidl2.trigger.GetTriggerRevisionDetailsResponse"> & { + /** + * @generated from field: flyteidl2.trigger.TriggerDetails trigger = 1; + */ + trigger?: TriggerDetails; +}; + +/** + * Describes the message flyteidl2.trigger.GetTriggerRevisionDetailsResponse. + * Use `create(GetTriggerRevisionDetailsResponseSchema)` to create a new message. + */ +export const GetTriggerRevisionDetailsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_service, 5); + +/** + * @generated from message flyteidl2.trigger.ListTriggersRequest + */ +export type ListTriggersRequest = Message<"flyteidl2.trigger.ListTriggersRequest"> & { + /** + * Common list request parameters. + * + * @generated from field: flyteidl2.common.ListRequest request = 1; + */ + request?: ListRequest; + + /** + * @generated from oneof flyteidl2.trigger.ListTriggersRequest.scope_by + */ + scopeBy: { + /** + * Organization name for filtering. + * + * @generated from field: string org = 2; + */ + value: string; + case: "org"; + } | { + /** + * Project identifier for filtering. + * + * @generated from field: flyteidl2.common.ProjectIdentifier project_id = 3; + */ + value: ProjectIdentifier; + case: "projectId"; + } | { + /** + * List all triggers attached to a given version of a task . + * + * @generated from field: flyteidl2.task.TaskIdentifier task_id = 4; + */ + value: TaskIdentifier; + case: "taskId"; + } | { + /** + * List all triggers attached to a given task. + * + * @generated from field: flyteidl2.task.TaskName task_name = 5; + */ + value: TaskName; + case: "taskName"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.trigger.ListTriggersRequest. + * Use `create(ListTriggersRequestSchema)` to create a new message. + */ +export const ListTriggersRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_service, 6); + +/** + * Response message for listing triggers. + * + * @generated from message flyteidl2.trigger.ListTriggersResponse + */ +export type ListTriggersResponse = Message<"flyteidl2.trigger.ListTriggersResponse"> & { + /** + * List of triggers matching the filter criteria. + * + * @generated from field: repeated flyteidl2.trigger.Trigger triggers = 1; + */ + triggers: Trigger[]; + + /** + * Token for fetching the next page of results, if any. + * + * @generated from field: string token = 2; + */ + token: string; +}; + +/** + * Describes the message flyteidl2.trigger.ListTriggersResponse. + * Use `create(ListTriggersResponseSchema)` to create a new message. + */ +export const ListTriggersResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_service, 7); + +/** + * @generated from message flyteidl2.trigger.GetTriggerRevisionHistoryRequest + */ +export type GetTriggerRevisionHistoryRequest = Message<"flyteidl2.trigger.GetTriggerRevisionHistoryRequest"> & { + /** + * @generated from field: flyteidl2.common.ListRequest request = 1; + */ + request?: ListRequest; + + /** + * @generated from field: flyteidl2.common.TriggerName name = 2; + */ + name?: TriggerName; +}; + +/** + * Describes the message flyteidl2.trigger.GetTriggerRevisionHistoryRequest. + * Use `create(GetTriggerRevisionHistoryRequestSchema)` to create a new message. + */ +export const GetTriggerRevisionHistoryRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_service, 8); + +/** + * @generated from message flyteidl2.trigger.GetTriggerRevisionHistoryResponse + */ +export type GetTriggerRevisionHistoryResponse = Message<"flyteidl2.trigger.GetTriggerRevisionHistoryResponse"> & { + /** + * List of triggers matching the filter criteria. + * + * @generated from field: repeated flyteidl2.trigger.TriggerRevision triggers = 1; + */ + triggers: TriggerRevision[]; + + /** + * Token for fetching the next page of results, if any. + * + * @generated from field: string token = 2; + */ + token: string; +}; + +/** + * Describes the message flyteidl2.trigger.GetTriggerRevisionHistoryResponse. + * Use `create(GetTriggerRevisionHistoryResponseSchema)` to create a new message. + */ +export const GetTriggerRevisionHistoryResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_service, 9); + +/** + * Request message for updating some trigger spec fields for multiple triggers + * + * @generated from message flyteidl2.trigger.UpdateTriggersRequest + */ +export type UpdateTriggersRequest = Message<"flyteidl2.trigger.UpdateTriggersRequest"> & { + /** + * @generated from field: repeated flyteidl2.common.TriggerName names = 1; + */ + names: TriggerName[]; + + /** + * @generated from field: bool active = 2; + */ + active: boolean; +}; + +/** + * Describes the message flyteidl2.trigger.UpdateTriggersRequest. + * Use `create(UpdateTriggersRequestSchema)` to create a new message. + */ +export const UpdateTriggersRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_service, 10); + +/** + * Response message for updating some trigger spec fields for multiple triggers + * + * @generated from message flyteidl2.trigger.UpdateTriggersResponse + */ +export type UpdateTriggersResponse = Message<"flyteidl2.trigger.UpdateTriggersResponse"> & { +}; + +/** + * Describes the message flyteidl2.trigger.UpdateTriggersResponse. + * Use `create(UpdateTriggersResponseSchema)` to create a new message. + */ +export const UpdateTriggersResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_service, 11); + +/** + * Request message for activating or deactivating multiple triggers + * + * @generated from message flyteidl2.trigger.DeleteTriggersRequest + */ +export type DeleteTriggersRequest = Message<"flyteidl2.trigger.DeleteTriggersRequest"> & { + /** + * @generated from field: repeated flyteidl2.common.TriggerName names = 1; + */ + names: TriggerName[]; +}; + +/** + * Describes the message flyteidl2.trigger.DeleteTriggersRequest. + * Use `create(DeleteTriggersRequestSchema)` to create a new message. + */ +export const DeleteTriggersRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_service, 12); + +/** + * Response message for activating or deactivating multiple triggers. + * + * @generated from message flyteidl2.trigger.DeleteTriggersResponse + */ +export type DeleteTriggersResponse = Message<"flyteidl2.trigger.DeleteTriggersResponse"> & { +}; + +/** + * Describes the message flyteidl2.trigger.DeleteTriggersResponse. + * Use `create(DeleteTriggersResponseSchema)` to create a new message. + */ +export const DeleteTriggersResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_trigger_trigger_service, 13); + +/** + * TriggerService provides an interface for managing triggers. + * + * @generated from service flyteidl2.trigger.TriggerService + */ +export const TriggerService: GenService<{ + /** + * Create if trigger didn't exist previously. + * Update if it already exists. + * Re-create(or undelete) if it was soft-deleted. + * Client must fetch the latest trigger in order to obtain the latest `trigger.id.revision`. + * If trigger is not found, client can set `trigger.id.revision` to 1, it is ignored and set automatically by backend. + * If trigger is found, client should set `trigger.id.revision` to the . + * Backend validates that version is the latest and creates a new revision of the trigger. + * Otherwise, operation is rejected(optimistic locking) and client must re-fetch trigger again. + * + * @generated from rpc flyteidl2.trigger.TriggerService.DeployTrigger + */ + deployTrigger: { + methodKind: "unary"; + input: typeof DeployTriggerRequestSchema; + output: typeof DeployTriggerResponseSchema; + }, + /** + * Get detailed info about the latest trigger revision + * + * @generated from rpc flyteidl2.trigger.TriggerService.GetTriggerDetails + */ + getTriggerDetails: { + methodKind: "unary"; + input: typeof GetTriggerDetailsRequestSchema; + output: typeof GetTriggerDetailsResponseSchema; + }, + /** + * Get detailed info about a specific trigger revision + * + * @generated from rpc flyteidl2.trigger.TriggerService.GetTriggerRevisionDetails + */ + getTriggerRevisionDetails: { + methodKind: "unary"; + input: typeof GetTriggerRevisionDetailsRequestSchema; + output: typeof GetTriggerRevisionDetailsResponseSchema; + }, + /** + * List basic info about triggers based on various filtering and sorting rules. + * + * @generated from rpc flyteidl2.trigger.TriggerService.ListTriggers + */ + listTriggers: { + methodKind: "unary"; + input: typeof ListTriggersRequestSchema; + output: typeof ListTriggersResponseSchema; + }, + /** + * GetTriggerRevisionHistory returns all revisions for a given trigger + * + * @generated from rpc flyteidl2.trigger.TriggerService.GetTriggerRevisionHistory + */ + getTriggerRevisionHistory: { + methodKind: "unary"; + input: typeof GetTriggerRevisionHistoryRequestSchema; + output: typeof GetTriggerRevisionHistoryResponseSchema; + }, + /** + * Update some trigger spec fields for multiple triggers at once + * + * @generated from rpc flyteidl2.trigger.TriggerService.UpdateTriggers + */ + updateTriggers: { + methodKind: "unary"; + input: typeof UpdateTriggersRequestSchema; + output: typeof UpdateTriggersResponseSchema; + }, + /** + * Soft-delete multiple triggers at once. + * + * @generated from rpc flyteidl2.trigger.TriggerService.DeleteTriggers + */ + deleteTriggers: { + methodKind: "unary"; + input: typeof DeleteTriggersRequestSchema; + output: typeof DeleteTriggersResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_trigger_trigger_service, 0); + diff --git a/gen/ts/flyteidl2/workflow/queue_service_pb.ts b/gen/ts/flyteidl2/workflow/queue_service_pb.ts new file mode 100644 index 0000000000..8417e2a38c --- /dev/null +++ b/gen/ts/flyteidl2/workflow/queue_service_pb.ts @@ -0,0 +1,245 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/workflow/queue_service.proto (package flyteidl2.workflow, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { ActionIdentifier, RunIdentifier } from "../common/identifier_pb.ts"; +import { file_flyteidl2_common_identifier } from "../common/identifier_pb.ts"; +import { file_flyteidl2_task_common } from "../task/common_pb.ts"; +import type { RunSpec } from "../task/run_pb.ts"; +import { file_flyteidl2_task_run } from "../task/run_pb.ts"; +import type { ConditionAction, TaskAction, TraceAction } from "./run_definition_pb.ts"; +import { file_flyteidl2_workflow_run_definition } from "./run_definition_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/workflow/queue_service.proto. + */ +export const file_flyteidl2_workflow_queue_service: GenFile = /*@__PURE__*/ + fileDesc("CiZmbHl0ZWlkbDIvd29ya2Zsb3cvcXVldWVfc2VydmljZS5wcm90bxISZmx5dGVpZGwyLndvcmtmbG93IsEDChRFbnF1ZXVlQWN0aW9uUmVxdWVzdBI9CglhY3Rpb25faWQYASABKAsyIi5mbHl0ZWlkbDIuY29tbW9uLkFjdGlvbklkZW50aWZpZXJCBrpIA8gBARIfChJwYXJlbnRfYWN0aW9uX25hbWUYAiABKAlIAYgBARIpCghydW5fc3BlYxgDIAEoCzIXLmZseXRlaWRsMi50YXNrLlJ1blNwZWMSGgoJaW5wdXRfdXJpGAYgASgJQge6SARyAhABEiAKD3J1bl9vdXRwdXRfYmFzZRgHIAEoCUIHukgEcgIQARINCgVncm91cBgIIAEoCRIPCgdzdWJqZWN0GAkgASgJEi4KBHRhc2sYCiABKAsyHi5mbHl0ZWlkbDIud29ya2Zsb3cuVGFza0FjdGlvbkgAEjAKBXRyYWNlGAsgASgLMh8uZmx5dGVpZGwyLndvcmtmbG93LlRyYWNlQWN0aW9uSAASOAoJY29uZGl0aW9uGAwgASgLMiMuZmx5dGVpZGwyLndvcmtmbG93LkNvbmRpdGlvbkFjdGlvbkgAQg0KBHNwZWMSBbpIAggBQhUKE19wYXJlbnRfYWN0aW9uX25hbWUiFwoVRW5xdWV1ZUFjdGlvblJlc3BvbnNlInAKFUFib3J0UXVldWVkUnVuUmVxdWVzdBI3CgZydW5faWQYASABKAsyHy5mbHl0ZWlkbDIuY29tbW9uLlJ1bklkZW50aWZpZXJCBrpIA8gBARITCgZyZWFzb24YAiABKAlIAIgBAUIJCgdfcmVhc29uIhgKFkFib3J0UXVldWVkUnVuUmVzcG9uc2UieQoYQWJvcnRRdWV1ZWRBY3Rpb25SZXF1ZXN0Ej0KCWFjdGlvbl9pZBgBIAEoCzIiLmZseXRlaWRsMi5jb21tb24uQWN0aW9uSWRlbnRpZmllckIGukgDyAEBEhMKBnJlYXNvbhgCIAEoCUgAiAEBQgkKB19yZWFzb24iGwoZQWJvcnRRdWV1ZWRBY3Rpb25SZXNwb25zZTLVAgoMUXVldWVTZXJ2aWNlEmYKDUVucXVldWVBY3Rpb24SKC5mbHl0ZWlkbDIud29ya2Zsb3cuRW5xdWV1ZUFjdGlvblJlcXVlc3QaKS5mbHl0ZWlkbDIud29ya2Zsb3cuRW5xdWV1ZUFjdGlvblJlc3BvbnNlIgASaQoOQWJvcnRRdWV1ZWRSdW4SKS5mbHl0ZWlkbDIud29ya2Zsb3cuQWJvcnRRdWV1ZWRSdW5SZXF1ZXN0GiouZmx5dGVpZGwyLndvcmtmbG93LkFib3J0UXVldWVkUnVuUmVzcG9uc2UiABJyChFBYm9ydFF1ZXVlZEFjdGlvbhIsLmZseXRlaWRsMi53b3JrZmxvdy5BYm9ydFF1ZXVlZEFjdGlvblJlcXVlc3QaLS5mbHl0ZWlkbDIud29ya2Zsb3cuQWJvcnRRdWV1ZWRBY3Rpb25SZXNwb25zZSIAQs4BChZjb20uZmx5dGVpZGwyLndvcmtmbG93QhFRdWV1ZVNlcnZpY2VQcm90b0gCUAFaNmdpdGh1Yi5jb20vZmx5dGVvcmcvZmx5dGUvdjIvZ2VuL2dvL2ZseXRlaWRsMi93b3JrZmxvd6ICA0ZXWKoCEkZseXRlaWRsMi5Xb3JrZmxvd8oCEkZseXRlaWRsMlxXb3JrZmxvd+ICHkZseXRlaWRsMlxXb3JrZmxvd1xHUEJNZXRhZGF0YeoCE0ZseXRlaWRsMjo6V29ya2Zsb3diBnByb3RvMw", [file_buf_validate_validate, file_flyteidl2_common_identifier, file_flyteidl2_task_common, file_flyteidl2_task_run, file_flyteidl2_workflow_run_definition]); + +/** + * request message for queuing an action. + * + * @generated from message flyteidl2.workflow.EnqueueActionRequest + */ +export type EnqueueActionRequest = Message<"flyteidl2.workflow.EnqueueActionRequest"> & { + /** + * the unique identifier for the action. + * + * @generated from field: flyteidl2.common.ActionIdentifier action_id = 1; + */ + actionId?: ActionIdentifier; + + /** + * an optional name for the parent action, if it exists. the remaining run metadata (ex. org, + * project, domain) will be the same as the action_id defined above. + * + * @generated from field: optional string parent_action_name = 2; + */ + parentActionName?: string; + + /** + * Optional run spec passed in by the root action to be utilized by all downstream actions in the run. + * + * @generated from field: flyteidl2.task.RunSpec run_spec = 3; + */ + runSpec?: RunSpec; + + /** + * the path to the input data for this action. + * + * @generated from field: string input_uri = 6; + */ + inputUri: string; + + /** + * the run base path this action should write its output to. + * + * @generated from field: string run_output_base = 7; + */ + runOutputBase: string; + + /** + * group this action belongs to, if applicable. + * + * @generated from field: string group = 8; + */ + group: string; + + /** + * subject that created the run, if known. + * + * @generated from field: string subject = 9; + */ + subject: string; + + /** + * @generated from oneof flyteidl2.workflow.EnqueueActionRequest.spec + */ + spec: { + /** + * @generated from field: flyteidl2.workflow.TaskAction task = 10; + */ + value: TaskAction; + case: "task"; + } | { + /** + * @generated from field: flyteidl2.workflow.TraceAction trace = 11; + */ + value: TraceAction; + case: "trace"; + } | { + /** + * @generated from field: flyteidl2.workflow.ConditionAction condition = 12; + */ + value: ConditionAction; + case: "condition"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.workflow.EnqueueActionRequest. + * Use `create(EnqueueActionRequestSchema)` to create a new message. + */ +export const EnqueueActionRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_queue_service, 0); + +/** + * response message for queuing an action. + * + * @generated from message flyteidl2.workflow.EnqueueActionResponse + */ +export type EnqueueActionResponse = Message<"flyteidl2.workflow.EnqueueActionResponse"> & { +}; + +/** + * Describes the message flyteidl2.workflow.EnqueueActionResponse. + * Use `create(EnqueueActionResponseSchema)` to create a new message. + */ +export const EnqueueActionResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_queue_service, 1); + +/** + * request message for aborting a run. + * + * @generated from message flyteidl2.workflow.AbortQueuedRunRequest + */ +export type AbortQueuedRunRequest = Message<"flyteidl2.workflow.AbortQueuedRunRequest"> & { + /** + * the unique identifier for the run to be aborted. + * + * @generated from field: flyteidl2.common.RunIdentifier run_id = 1; + */ + runId?: RunIdentifier; + + /** + * Reason for aborting the run, if applicable. + * + * @generated from field: optional string reason = 2; + */ + reason?: string; +}; + +/** + * Describes the message flyteidl2.workflow.AbortQueuedRunRequest. + * Use `create(AbortQueuedRunRequestSchema)` to create a new message. + */ +export const AbortQueuedRunRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_queue_service, 2); + +/** + * response message for aborting a run. + * + * @generated from message flyteidl2.workflow.AbortQueuedRunResponse + */ +export type AbortQueuedRunResponse = Message<"flyteidl2.workflow.AbortQueuedRunResponse"> & { +}; + +/** + * Describes the message flyteidl2.workflow.AbortQueuedRunResponse. + * Use `create(AbortQueuedRunResponseSchema)` to create a new message. + */ +export const AbortQueuedRunResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_queue_service, 3); + +/** + * @generated from message flyteidl2.workflow.AbortQueuedActionRequest + */ +export type AbortQueuedActionRequest = Message<"flyteidl2.workflow.AbortQueuedActionRequest"> & { + /** + * ActionId is the unique identifier for the action to be aborted + * + * @generated from field: flyteidl2.common.ActionIdentifier action_id = 1; + */ + actionId?: ActionIdentifier; + + /** + * Reason for aborting the action, if applicable. + * + * @generated from field: optional string reason = 2; + */ + reason?: string; +}; + +/** + * Describes the message flyteidl2.workflow.AbortQueuedActionRequest. + * Use `create(AbortQueuedActionRequestSchema)` to create a new message. + */ +export const AbortQueuedActionRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_queue_service, 4); + +/** + * @generated from message flyteidl2.workflow.AbortQueuedActionResponse + */ +export type AbortQueuedActionResponse = Message<"flyteidl2.workflow.AbortQueuedActionResponse"> & { +}; + +/** + * Describes the message flyteidl2.workflow.AbortQueuedActionResponse. + * Use `create(AbortQueuedActionResponseSchema)` to create a new message. + */ +export const AbortQueuedActionResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_queue_service, 5); + +/** + * provides an interface for managing execution of runs over a collection of workers. + * + * @generated from service flyteidl2.workflow.QueueService + */ +export const QueueService: GenService<{ + /** + * queue a new action for execution. + * + * @generated from rpc flyteidl2.workflow.QueueService.EnqueueAction + */ + enqueueAction: { + methodKind: "unary"; + input: typeof EnqueueActionRequestSchema; + output: typeof EnqueueActionResponseSchema; + }, + /** + * abort a queued run. + * + * @generated from rpc flyteidl2.workflow.QueueService.AbortQueuedRun + */ + abortQueuedRun: { + methodKind: "unary"; + input: typeof AbortQueuedRunRequestSchema; + output: typeof AbortQueuedRunResponseSchema; + }, + /** + * AbortAction aborts a single action that was previously queued or is currently being processed by a worker. + * + * @generated from rpc flyteidl2.workflow.QueueService.AbortQueuedAction + */ + abortQueuedAction: { + methodKind: "unary"; + input: typeof AbortQueuedActionRequestSchema; + output: typeof AbortQueuedActionResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_workflow_queue_service, 0); + diff --git a/gen/ts/flyteidl2/workflow/run_definition_pb.ts b/gen/ts/flyteidl2/workflow/run_definition_pb.ts new file mode 100644 index 0000000000..43ebe8b006 --- /dev/null +++ b/gen/ts/flyteidl2/workflow/run_definition_pb.ts @@ -0,0 +1,1349 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/workflow/run_definition.proto (package flyteidl2.workflow, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { ActionIdentifier, TriggerIdentifier } from "../common/identifier_pb.ts"; +import { file_flyteidl2_common_identifier } from "../common/identifier_pb.ts"; +import type { EnrichedIdentity } from "../common/identity_pb.ts"; +import { file_flyteidl2_common_identity } from "../common/identity_pb.ts"; +import type { ActionPhase } from "../common/phase_pb.ts"; +import { file_flyteidl2_common_phase } from "../common/phase_pb.ts"; +import type { CatalogCacheStatus } from "../core/catalog_pb.ts"; +import { file_flyteidl2_core_catalog } from "../core/catalog_pb.ts"; +import type { LogContext, TaskLog } from "../core/execution_pb.ts"; +import { file_flyteidl2_core_execution } from "../core/execution_pb.ts"; +import type { LiteralType } from "../core/types_pb.ts"; +import { file_flyteidl2_core_types } from "../core/types_pb.ts"; +import type { OutputReferences, TriggerAutomationSpec } from "../task/common_pb.ts"; +import { file_flyteidl2_task_common } from "../task/common_pb.ts"; +import type { RunSpec } from "../task/run_pb.ts"; +import { file_flyteidl2_task_run } from "../task/run_pb.ts"; +import type { TaskIdentifier, TaskSpec, TraceSpec } from "../task/task_definition_pb.ts"; +import { file_flyteidl2_task_task_definition } from "../task/task_definition_pb.ts"; +import type { Duration, Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_duration, file_google_protobuf_timestamp, file_google_protobuf_wrappers } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/workflow/run_definition.proto. + */ +export const file_flyteidl2_workflow_run_definition: GenFile = /*@__PURE__*/ + fileDesc("CidmbHl0ZWlkbDIvd29ya2Zsb3cvcnVuX2RlZmluaXRpb24ucHJvdG8SEmZseXRlaWRsMi53b3JrZmxvdyIxCgNSdW4SKgoGYWN0aW9uGAEgASgLMhouZmx5dGVpZGwyLndvcmtmbG93LkFjdGlvbiJqCgpSdW5EZXRhaWxzEikKCHJ1bl9zcGVjGAEgASgLMhcuZmx5dGVpZGwyLnRhc2suUnVuU3BlYxIxCgZhY3Rpb24YAiABKAsyIS5mbHl0ZWlkbDIud29ya2Zsb3cuQWN0aW9uRGV0YWlscyKqAQoKVGFza0FjdGlvbhIqCgJpZBgBIAEoCzIeLmZseXRlaWRsMi50YXNrLlRhc2tJZGVudGlmaWVyEi4KBHNwZWMYAiABKAsyGC5mbHl0ZWlkbDIudGFzay5UYXNrU3BlY0IGukgDyAEBEi8KCWNhY2hlX2tleRgDIAEoCzIcLmdvb2dsZS5wcm90b2J1Zi5TdHJpbmdWYWx1ZRIPCgdjbHVzdGVyGAQgASgJIqYCCgtUcmFjZUFjdGlvbhIVCgRuYW1lGAEgASgJQge6SARyAhABEiwKBXBoYXNlGAIgASgOMh0uZmx5dGVpZGwyLmNvbW1vbi5BY3Rpb25QaGFzZRIuCgpzdGFydF90aW1lGAMgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIxCghlbmRfdGltZRgEIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBIAIgBARIxCgdvdXRwdXRzGAUgASgLMiAuZmx5dGVpZGwyLnRhc2suT3V0cHV0UmVmZXJlbmNlcxIvCgRzcGVjGAYgASgLMhkuZmx5dGVpZGwyLnRhc2suVHJhY2VTcGVjQga6SAPIAQFCCwoJX2VuZF90aW1lItMBCg9Db25kaXRpb25BY3Rpb24SFQoEbmFtZRgBIAEoCUIHukgEcgIQARIZCgZydW5faWQYAiABKAlCB7pIBHICEAFIABIcCglhY3Rpb25faWQYAyABKAlCB7pIBHICEAFIABIQCgZnbG9iYWwYBCABKAhIABIpCgR0eXBlGAYgASgLMhsuZmx5dGVpZGwyLmNvcmUuTGl0ZXJhbFR5cGUSDgoGcHJvbXB0GAcgASgJEhMKC2Rlc2NyaXB0aW9uGAggASgJQg4KBXNjb3BlEgW6SAIIASJnChJUYXNrQWN0aW9uTWV0YWRhdGESKgoCaWQYASABKAsyHi5mbHl0ZWlkbDIudGFzay5UYXNrSWRlbnRpZmllchIRCgl0YXNrX3R5cGUYAiABKAkSEgoKc2hvcnRfbmFtZRgDIAEoCSIjChNUcmFjZUFjdGlvbk1ldGFkYXRhEgwKBG5hbWUYASABKAkiggEKF0NvbmRpdGlvbkFjdGlvbk1ldGFkYXRhEgwKBG5hbWUYASABKAkSGQoGcnVuX2lkGAIgASgJQge6SARyAhABSAASHAoJYWN0aW9uX2lkGAMgASgJQge6SARyAhABSAASEAoGZ2xvYmFsGAQgASgISABCDgoFc2NvcGUSBbpIAggBIsQECg5BY3Rpb25NZXRhZGF0YRIOCgZwYXJlbnQYAyABKAkSDQoFZ3JvdXAYBSABKAkSNwoLZXhlY3V0ZWRfYnkYBiABKAsyIi5mbHl0ZWlkbDIuY29tbW9uLkVucmljaGVkSWRlbnRpdHkSNgoEdGFzaxgHIAEoCzImLmZseXRlaWRsMi53b3JrZmxvdy5UYXNrQWN0aW9uTWV0YWRhdGFIABI4CgV0cmFjZRgIIAEoCzInLmZseXRlaWRsMi53b3JrZmxvdy5UcmFjZUFjdGlvbk1ldGFkYXRhSAASQAoJY29uZGl0aW9uGAkgASgLMisuZmx5dGVpZGwyLndvcmtmbG93LkNvbmRpdGlvbkFjdGlvbk1ldGFkYXRhSAASMwoLYWN0aW9uX3R5cGUYCiABKA4yHi5mbHl0ZWlkbDIud29ya2Zsb3cuQWN0aW9uVHlwZRI3Cgp0cmlnZ2VyX2lkGAsgASgLMiMuZmx5dGVpZGwyLmNvbW1vbi5UcmlnZ2VySWRlbnRpZmllchIYChBlbnZpcm9ubWVudF9uYW1lGAwgASgJEhQKDGZ1bnRpb25fbmFtZRgNIAEoCRIUCgx0cmlnZ2VyX25hbWUYDiABKAkSOwoMdHJpZ2dlcl90eXBlGA8gASgLMiUuZmx5dGVpZGwyLnRhc2suVHJpZ2dlckF1dG9tYXRpb25TcGVjEi0KBnNvdXJjZRgQIAEoDjIdLmZseXRlaWRsMi53b3JrZmxvdy5SdW5Tb3VyY2VCBgoEc3BlYyKrAgoMQWN0aW9uU3RhdHVzEiwKBXBoYXNlGAEgASgOMh0uZmx5dGVpZGwyLmNvbW1vbi5BY3Rpb25QaGFzZRIuCgpzdGFydF90aW1lGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIxCghlbmRfdGltZRgDIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBIAIgBARIZCghhdHRlbXB0cxgEIAEoDUIHukgEKgIgABI4CgxjYWNoZV9zdGF0dXMYBSABKA4yIi5mbHl0ZWlkbDIuY29yZS5DYXRhbG9nQ2FjaGVTdGF0dXMSGAoLZHVyYXRpb25fbXMYBiABKARIAYgBAUILCglfZW5kX3RpbWVCDgoMX2R1cmF0aW9uX21zIqABCgZBY3Rpb24SLgoCaWQYASABKAsyIi5mbHl0ZWlkbDIuY29tbW9uLkFjdGlvbklkZW50aWZpZXISNAoIbWV0YWRhdGEYAiABKAsyIi5mbHl0ZWlkbDIud29ya2Zsb3cuQWN0aW9uTWV0YWRhdGESMAoGc3RhdHVzGAMgASgLMiAuZmx5dGVpZGwyLndvcmtmbG93LkFjdGlvblN0YXR1cyLqAQoORW5yaWNoZWRBY3Rpb24SKgoGYWN0aW9uGAEgASgLMhouZmx5dGVpZGwyLndvcmtmbG93LkFjdGlvbhIUCgxtZWV0c19maWx0ZXIYAiABKAgSWgoVY2hpbGRyZW5fcGhhc2VfY291bnRzGAMgAygLMjsuZmx5dGVpZGwyLndvcmtmbG93LkVucmljaGVkQWN0aW9uLkNoaWxkcmVuUGhhc2VDb3VudHNFbnRyeRo6ChhDaGlsZHJlblBoYXNlQ291bnRzRW50cnkSCwoDa2V5GAEgASgFEg0KBXZhbHVlGAIgASgFOgI4ASKMAQoJRXJyb3JJbmZvEg8KB21lc3NhZ2UYASABKAkSMAoEa2luZBgCIAEoDjIiLmZseXRlaWRsMi53b3JrZmxvdy5FcnJvckluZm8uS2luZCI8CgRLaW5kEhQKEEtJTkRfVU5TUEVDSUZJRUQQABINCglLSU5EX1VTRVIQARIPCgtLSU5EX1NZU1RFTRACIlMKCUFib3J0SW5mbxIOCgZyZWFzb24YASABKAkSNgoKYWJvcnRlZF9ieRgCIAEoCzIiLmZseXRlaWRsMi5jb21tb24uRW5yaWNoZWRJZGVudGl0eSKuAwoNQWN0aW9uRGV0YWlscxIuCgJpZBgBIAEoCzIiLmZseXRlaWRsMi5jb21tb24uQWN0aW9uSWRlbnRpZmllchI0CghtZXRhZGF0YRgCIAEoCzIiLmZseXRlaWRsMi53b3JrZmxvdy5BY3Rpb25NZXRhZGF0YRIwCgZzdGF0dXMYAyABKAsyIC5mbHl0ZWlkbDIud29ya2Zsb3cuQWN0aW9uU3RhdHVzEjMKCmVycm9yX2luZm8YBCABKAsyHS5mbHl0ZWlkbDIud29ya2Zsb3cuRXJyb3JJbmZvSAASMwoKYWJvcnRfaW5mbxgFIAEoCzIdLmZseXRlaWRsMi53b3JrZmxvdy5BYm9ydEluZm9IABIoCgR0YXNrGAYgASgLMhguZmx5dGVpZGwyLnRhc2suVGFza1NwZWNIARIqCgV0cmFjZRgIIAEoCzIZLmZseXRlaWRsMi50YXNrLlRyYWNlU3BlY0gBEjMKCGF0dGVtcHRzGAcgAygLMiEuZmx5dGVpZGwyLndvcmtmbG93LkFjdGlvbkF0dGVtcHRCCAoGcmVzdWx0QgYKBHNwZWMi+gQKDUFjdGlvbkF0dGVtcHQSLAoFcGhhc2UYASABKA4yHS5mbHl0ZWlkbDIuY29tbW9uLkFjdGlvblBoYXNlEi4KCnN0YXJ0X3RpbWUYAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEjEKCGVuZF90aW1lGAMgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEgAiAEBEjYKCmVycm9yX2luZm8YBCABKAsyHS5mbHl0ZWlkbDIud29ya2Zsb3cuRXJyb3JJbmZvSAGIAQESGAoHYXR0ZW1wdBgFIAEoDUIHukgEKgIgABIpCghsb2dfaW5mbxgGIAMoCzIXLmZseXRlaWRsMi5jb3JlLlRhc2tMb2cSMQoHb3V0cHV0cxgHIAEoCzIgLmZseXRlaWRsMi50YXNrLk91dHB1dFJlZmVyZW5jZXMSFgoObG9nc19hdmFpbGFibGUYCCABKAgSOAoMY2FjaGVfc3RhdHVzGAkgASgOMiIuZmx5dGVpZGwyLmNvcmUuQ2F0YWxvZ0NhY2hlU3RhdHVzEjgKDmNsdXN0ZXJfZXZlbnRzGAogAygLMiAuZmx5dGVpZGwyLndvcmtmbG93LkNsdXN0ZXJFdmVudBI+ChFwaGFzZV90cmFuc2l0aW9ucxgLIAMoCzIjLmZseXRlaWRsMi53b3JrZmxvdy5QaGFzZVRyYW5zaXRpb24SDwoHY2x1c3RlchgMIAEoCRIvCgtsb2dfY29udGV4dBgNIAEoCzIaLmZseXRlaWRsMi5jb3JlLkxvZ0NvbnRleHRCCwoJX2VuZF90aW1lQg0KC19lcnJvcl9pbmZvIlAKDENsdXN0ZXJFdmVudBIvCgtvY2N1cnJlZF9hdBgBIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASDwoHbWVzc2FnZRgCIAEoCSKvAQoPUGhhc2VUcmFuc2l0aW9uEiwKBXBoYXNlGAEgASgOMh0uZmx5dGVpZGwyLmNvbW1vbi5BY3Rpb25QaGFzZRIuCgpzdGFydF90aW1lGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIxCghlbmRfdGltZRgDIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBIAIgBAUILCglfZW5kX3RpbWUi1gUKC0FjdGlvbkV2ZW50EjYKAmlkGAEgASgLMiIuZmx5dGVpZGwyLmNvbW1vbi5BY3Rpb25JZGVudGlmaWVyQga6SAPIAQESGAoHYXR0ZW1wdBgCIAEoDUIHukgEKgIgABIsCgVwaGFzZRgDIAEoDjIdLmZseXRlaWRsMi5jb21tb24uQWN0aW9uUGhhc2USDwoHdmVyc2lvbhgEIAEoDRIyCgpzdGFydF90aW1lGAUgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEICGAESMAoMdXBkYXRlZF90aW1lGAYgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBI1CghlbmRfdGltZRgHIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCAhgBSACIAQESNgoKZXJyb3JfaW5mbxgIIAEoCzIdLmZseXRlaWRsMi53b3JrZmxvdy5FcnJvckluZm9IAYgBARIpCghsb2dfaW5mbxgJIAMoCzIXLmZseXRlaWRsMi5jb3JlLlRhc2tMb2cSLwoLbG9nX2NvbnRleHQYCiABKAsyGi5mbHl0ZWlkbDIuY29yZS5Mb2dDb250ZXh0Eg8KB2NsdXN0ZXIYCyABKAkSMQoHb3V0cHV0cxgMIAEoCzIgLmZseXRlaWRsMi50YXNrLk91dHB1dFJlZmVyZW5jZXMSOAoMY2FjaGVfc3RhdHVzGA0gASgOMiIuZmx5dGVpZGwyLmNvcmUuQ2F0YWxvZ0NhY2hlU3RhdHVzEjgKDmNsdXN0ZXJfZXZlbnRzGA4gAygLMiAuZmx5dGVpZGwyLndvcmtmbG93LkNsdXN0ZXJFdmVudBIxCg1yZXBvcnRlZF90aW1lGA8gASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEILCglfZW5kX3RpbWVCDQoLX2Vycm9yX2luZm8ipgMKCkFjdGlvblNwZWMSPQoJYWN0aW9uX2lkGAEgASgLMiIuZmx5dGVpZGwyLmNvbW1vbi5BY3Rpb25JZGVudGlmaWVyQga6SAPIAQESHwoScGFyZW50X2FjdGlvbl9uYW1lGAIgASgJSAGIAQESKQoIcnVuX3NwZWMYAyABKAsyFy5mbHl0ZWlkbDIudGFzay5SdW5TcGVjEhoKCWlucHV0X3VyaRgEIAEoCUIHukgEcgIQARIgCg9ydW5fb3V0cHV0X2Jhc2UYBSABKAlCB7pIBHICEAESLgoEdGFzaxgGIAEoCzIeLmZseXRlaWRsMi53b3JrZmxvdy5UYXNrQWN0aW9uSAASOAoJY29uZGl0aW9uGAcgASgLMiMuZmx5dGVpZGwyLndvcmtmbG93LkNvbmRpdGlvbkFjdGlvbkgAEjAKBXRyYWNlGAogASgLMh8uZmx5dGVpZGwyLndvcmtmbG93LlRyYWNlQWN0aW9uSAASDQoFZ3JvdXAYCCABKAlCDQoEc3BlYxIFukgCCAFCFQoTX3BhcmVudF9hY3Rpb25fbmFtZSKoBgoJVGFza0dyb3VwEhEKCXRhc2tfbmFtZRgBIAEoCRIYChBlbnZpcm9ubWVudF9uYW1lGAIgASgJEhIKCnRvdGFsX3J1bnMYAyABKAMSMwoPbGF0ZXN0X3J1bl90aW1lGAQgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBJDCg9yZWNlbnRfc3RhdHVzZXMYBSADKAsyKi5mbHl0ZWlkbDIud29ya2Zsb3cuVGFza0dyb3VwLlJlY2VudFN0YXR1cxIcChRhdmVyYWdlX2ZhaWx1cmVfcmF0ZRgGIAEoARIzChBhdmVyYWdlX2R1cmF0aW9uGAcgASgLMhkuZ29vZ2xlLnByb3RvYnVmLkR1cmF0aW9uEjgKFGxhdGVzdF9maW5pc2hlZF90aW1lGAggASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBI2CgpjcmVhdGVkX2J5GAkgAygLMiIuZmx5dGVpZGwyLmNvbW1vbi5FbnJpY2hlZElkZW50aXR5EhUKDXNob3VsZF9kZWxldGUYCiABKAgSEgoKc2hvcnRfbmFtZRgLIAEoCRI/CgxlcnJvcl9jb3VudHMYDCABKAsyKS5mbHl0ZWlkbDIud29ya2Zsb3cuVGFza0dyb3VwLkVycm9yQ291bnRzEj8KDHBoYXNlX2NvdW50cxgNIAMoCzIpLmZseXRlaWRsMi53b3JrZmxvdy5UYXNrR3JvdXAuUGhhc2VDb3VudHMaTgoMUmVjZW50U3RhdHVzEhAKCHJ1bl9uYW1lGAEgASgJEiwKBXBoYXNlGAIgASgOMh0uZmx5dGVpZGwyLmNvbW1vbi5BY3Rpb25QaGFzZRpSCgtFcnJvckNvdW50cxISCgp1c2VyX2Vycm9yGAEgASgDEhQKDHN5c3RlbV9lcnJvchgCIAEoAxIZChF1bnNwZWNpZmllZF9lcnJvchgDIAEoAxpKCgtQaGFzZUNvdW50cxIsCgVwaGFzZRgBIAEoDjIdLmZseXRlaWRsMi5jb21tb24uQWN0aW9uUGhhc2USDQoFY291bnQYAiABKAMqcQoKQWN0aW9uVHlwZRIbChdBQ1RJT05fVFlQRV9VTlNQRUNJRklFRBAAEhQKEEFDVElPTl9UWVBFX1RBU0sQARIVChFBQ1RJT05fVFlQRV9UUkFDRRACEhkKFUFDVElPTl9UWVBFX0NPTkRJVElPThADKnAKCVJ1blNvdXJjZRIaChZSVU5fU09VUkNFX1VOU1BFQ0lGSUVEEAASEgoOUlVOX1NPVVJDRV9XRUIQARISCg5SVU5fU09VUkNFX0NMSRACEh8KG1JVTl9TT1VSQ0VfU0NIRURVTEVfVFJJR0dFUhADQs8BChZjb20uZmx5dGVpZGwyLndvcmtmbG93QhJSdW5EZWZpbml0aW9uUHJvdG9IAlABWjZnaXRodWIuY29tL2ZseXRlb3JnL2ZseXRlL3YyL2dlbi9nby9mbHl0ZWlkbDIvd29ya2Zsb3eiAgNGV1iqAhJGbHl0ZWlkbDIuV29ya2Zsb3fKAhJGbHl0ZWlkbDJcV29ya2Zsb3fiAh5GbHl0ZWlkbDJcV29ya2Zsb3dcR1BCTWV0YWRhdGHqAhNGbHl0ZWlkbDI6OldvcmtmbG93YgZwcm90bzM", [file_buf_validate_validate, file_flyteidl2_common_identifier, file_flyteidl2_common_identity, file_flyteidl2_common_phase, file_flyteidl2_core_catalog, file_flyteidl2_core_execution, file_flyteidl2_core_types, file_flyteidl2_task_common, file_flyteidl2_task_run, file_flyteidl2_task_task_definition, file_google_protobuf_duration, file_google_protobuf_timestamp, file_google_protobuf_wrappers]); + +/** + * @generated from message flyteidl2.workflow.Run + */ +export type Run = Message<"flyteidl2.workflow.Run"> & { + /** + * Lightweight information about the root action. + * + * @generated from field: flyteidl2.workflow.Action action = 1; + */ + action?: Action; +}; + +/** + * Describes the message flyteidl2.workflow.Run. + * Use `create(RunSchema)` to create a new message. + */ +export const RunSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 0); + +/** + * @generated from message flyteidl2.workflow.RunDetails + */ +export type RunDetails = Message<"flyteidl2.workflow.RunDetails"> & { + /** + * Run spec. + * + * @generated from field: flyteidl2.task.RunSpec run_spec = 1; + */ + runSpec?: RunSpec; + + /** + * Detailed information about the root action. + * + * @generated from field: flyteidl2.workflow.ActionDetails action = 2; + */ + action?: ActionDetails; +}; + +/** + * Describes the message flyteidl2.workflow.RunDetails. + * Use `create(RunDetailsSchema)` to create a new message. + */ +export const RunDetailsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 1); + +/** + * @generated from message flyteidl2.workflow.TaskAction + */ +export type TaskAction = Message<"flyteidl2.workflow.TaskAction"> & { + /** + * a unique identifier for the task this action is associated with, if applicable. + * + * @generated from field: flyteidl2.task.TaskIdentifier id = 1; + */ + id?: TaskIdentifier; + + /** + * the definition of the task to be executed. + * + * @generated from field: flyteidl2.task.TaskSpec spec = 2; + */ + spec?: TaskSpec; + + /** + * Enables caching when set and specifies the cache version to use. + * + * @generated from field: google.protobuf.StringValue cache_key = 3; + */ + cacheKey?: string; + + /** + * the specific cluster that this action should be executed on. if not set, the cluster from the + * `RunSpec` will be used. + * + * @generated from field: string cluster = 4; + */ + cluster: string; +}; + +/** + * Describes the message flyteidl2.workflow.TaskAction. + * Use `create(TaskActionSchema)` to create a new message. + */ +export const TaskActionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 2); + +/** + * TraceAction is used to define a trace action that can be used to track the execution of an action that's managed + * by the local worker. This can be used to bring determinism to code that's otherwise not deterministic (e.g. current + * time). + * + * @generated from message flyteidl2.workflow.TraceAction + */ +export type TraceAction = Message<"flyteidl2.workflow.TraceAction"> & { + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * Last known phase. + * + * @generated from field: flyteidl2.common.ActionPhase phase = 2; + */ + phase: ActionPhase; + + /** + * Time the attempt started. + * + * @generated from field: google.protobuf.Timestamp start_time = 3; + */ + startTime?: Timestamp; + + /** + * Time the attempt ended, if applicable. + * + * @generated from field: optional google.protobuf.Timestamp end_time = 4; + */ + endTime?: Timestamp; + + /** + * Output references. + * + * @generated from field: flyteidl2.task.OutputReferences outputs = 5; + */ + outputs?: OutputReferences; + + /** + * Task spec for the trace, useful for the typed interface inside. + * + * @generated from field: flyteidl2.task.TraceSpec spec = 6; + */ + spec?: TraceSpec; +}; + +/** + * Describes the message flyteidl2.workflow.TraceAction. + * Use `create(TraceActionSchema)` to create a new message. + */ +export const TraceActionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 3); + +/** + * ConditionAction is used to define a condition that can be evaluated at runtime. It can be used to + * await a signal from an external system and can carry a value. + * + * @generated from message flyteidl2.workflow.ConditionAction + */ +export type ConditionAction = Message<"flyteidl2.workflow.ConditionAction"> & { + /** + * Name is the unique identifier for the action. It must be unique within the defined scope below. + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * @generated from oneof flyteidl2.workflow.ConditionAction.scope + */ + scope: { + /** + * RunId is the unique identifier for the run this action is associated with. + * + * @generated from field: string run_id = 2; + */ + value: string; + case: "runId"; + } | { + /** + * ActionId is the unique identifier for the action this action is associated with. + * + * @generated from field: string action_id = 3; + */ + value: string; + case: "actionId"; + } | { + /** + * Global indicates the condition is global and can be used across all runs and actions. + * + * @generated from field: bool global = 4; + */ + value: boolean; + case: "global"; + } | { case: undefined; value?: undefined }; + + /** + * Type is the type of the value the condition is expected. This can be used to properly render + * a UI element for the condition or validate when a value is received that it is of the expected + * type. + * + * @generated from field: flyteidl2.core.LiteralType type = 6; + */ + type?: LiteralType; + + /** + * Prompt is the prompt that will be shown to the user when the condition is awaited. + * + * @generated from field: string prompt = 7; + */ + prompt: string; + + /** + * Description is a description of the condition. This can be used to provide additional + * information to the user about the condition. + * + * @generated from field: string description = 8; + */ + description: string; +}; + +/** + * Describes the message flyteidl2.workflow.ConditionAction. + * Use `create(ConditionActionSchema)` to create a new message. + */ +export const ConditionActionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 4); + +/** + * @generated from message flyteidl2.workflow.TaskActionMetadata + */ +export type TaskActionMetadata = Message<"flyteidl2.workflow.TaskActionMetadata"> & { + /** + * Id of the task this action is associated with. + * + * @generated from field: flyteidl2.task.TaskIdentifier id = 1; + */ + id?: TaskIdentifier; + + /** + * Extensible task type. + * + * @generated from field: string task_type = 2; + */ + taskType: string; + + /** + * The short name for this task. + * + * @generated from field: string short_name = 3; + */ + shortName: string; +}; + +/** + * Describes the message flyteidl2.workflow.TaskActionMetadata. + * Use `create(TaskActionMetadataSchema)` to create a new message. + */ +export const TaskActionMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 5); + +/** + * @generated from message flyteidl2.workflow.TraceActionMetadata + */ +export type TraceActionMetadata = Message<"flyteidl2.workflow.TraceActionMetadata"> & { + /** + * @generated from field: string name = 1; + */ + name: string; +}; + +/** + * Describes the message flyteidl2.workflow.TraceActionMetadata. + * Use `create(TraceActionMetadataSchema)` to create a new message. + */ +export const TraceActionMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 6); + +/** + * @generated from message flyteidl2.workflow.ConditionActionMetadata + */ +export type ConditionActionMetadata = Message<"flyteidl2.workflow.ConditionActionMetadata"> & { + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * @generated from oneof flyteidl2.workflow.ConditionActionMetadata.scope + */ + scope: { + /** + * RunId is the unique identifier for the run this action is associated with. + * + * @generated from field: string run_id = 2; + */ + value: string; + case: "runId"; + } | { + /** + * ActionId is the unique identifier for the action this action is associated with. + * + * @generated from field: string action_id = 3; + */ + value: string; + case: "actionId"; + } | { + /** + * Global indicates the condition is global and can be used across all runs and actions. + * + * @generated from field: bool global = 4; + */ + value: boolean; + case: "global"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.workflow.ConditionActionMetadata. + * Use `create(ConditionActionMetadataSchema)` to create a new message. + */ +export const ConditionActionMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 7); + +/** + * Static, lightweight metadata about an action. + * + * @generated from message flyteidl2.workflow.ActionMetadata + */ +export type ActionMetadata = Message<"flyteidl2.workflow.ActionMetadata"> & { + /** + * Parent action if not the root. + * + * @generated from field: string parent = 3; + */ + parent: string; + + /** + * Group this action belongs to, if applicable. + * + * @generated from field: string group = 5; + */ + group: string; + + /** + * Identity that executed this run. + * + * @generated from field: flyteidl2.common.EnrichedIdentity executed_by = 6; + */ + executedBy?: EnrichedIdentity; + + /** + * @generated from oneof flyteidl2.workflow.ActionMetadata.spec + */ + spec: { + /** + * Task action. + * + * @generated from field: flyteidl2.workflow.TaskActionMetadata task = 7; + */ + value: TaskActionMetadata; + case: "task"; + } | { + /** + * Trace action. + * + * @generated from field: flyteidl2.workflow.TraceActionMetadata trace = 8; + */ + value: TraceActionMetadata; + case: "trace"; + } | { + /** + * Condition action. + * + * @generated from field: flyteidl2.workflow.ConditionActionMetadata condition = 9; + */ + value: ConditionActionMetadata; + case: "condition"; + } | { case: undefined; value?: undefined }; + + /** + * Action type. + * + * @generated from field: flyteidl2.workflow.ActionType action_type = 10; + */ + actionType: ActionType; + + /** + * If this run was initiated by a trigger, this will store the trigger identifier. + * + * @generated from field: flyteidl2.common.TriggerIdentifier trigger_id = 11; + */ + triggerId?: TriggerIdentifier; + + /** + * Environment name + * + * @generated from field: string environment_name = 12; + */ + environmentName: string; + + /** + * Function name + * + * @generated from field: string funtion_name = 13; + */ + funtionName: string; + + /** + * Trigger name + * + * @generated from field: string trigger_name = 14; + */ + triggerName: string; + + /** + * Trigger Type + * + * @generated from field: flyteidl2.task.TriggerAutomationSpec trigger_type = 15; + */ + triggerType?: TriggerAutomationSpec; + + /** + * Who initiated this run + * + * @generated from field: flyteidl2.workflow.RunSource source = 16; + */ + source: RunSource; +}; + +/** + * Describes the message flyteidl2.workflow.ActionMetadata. + * Use `create(ActionMetadataSchema)` to create a new message. + */ +export const ActionMetadataSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 8); + +/** + * Lightweight status of an action. For more detailed status see ActionDetails. + * + * @generated from message flyteidl2.workflow.ActionStatus + */ +export type ActionStatus = Message<"flyteidl2.workflow.ActionStatus"> & { + /** + * Last known phase. + * + * @generated from field: flyteidl2.common.ActionPhase phase = 1; + */ + phase: ActionPhase; + + /** + * Time the action started. + * + * @generated from field: google.protobuf.Timestamp start_time = 2; + */ + startTime?: Timestamp; + + /** + * Time the action ended, if applicable. + * + * @generated from field: optional google.protobuf.Timestamp end_time = 3; + */ + endTime?: Timestamp; + + /** + * Number of action attempts. + * + * @generated from field: uint32 attempts = 4; + */ + attempts: number; + + /** + * cache status of the action's latest attempt + * + * @generated from field: flyteidl2.core.CatalogCacheStatus cache_status = 5; + */ + cacheStatus: CatalogCacheStatus; + + /** + * Duration of the action in milliseconds. + * + * @generated from field: optional uint64 duration_ms = 6; + */ + durationMs?: bigint; +}; + +/** + * Describes the message flyteidl2.workflow.ActionStatus. + * Use `create(ActionStatusSchema)` to create a new message. + */ +export const ActionStatusSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 9); + +/** + * Lightweight representation of an action. + * + * @generated from message flyteidl2.workflow.Action + */ +export type Action = Message<"flyteidl2.workflow.Action"> & { + /** + * Id for this action. + * + * @generated from field: flyteidl2.common.ActionIdentifier id = 1; + */ + id?: ActionIdentifier; + + /** + * Metadata for this action. + * + * @generated from field: flyteidl2.workflow.ActionMetadata metadata = 2; + */ + metadata?: ActionMetadata; + + /** + * Last known status. + * + * @generated from field: flyteidl2.workflow.ActionStatus status = 3; + */ + status?: ActionStatus; +}; + +/** + * Describes the message flyteidl2.workflow.Action. + * Use `create(ActionSchema)` to create a new message. + */ +export const ActionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 10); + +/** + * EnrichedAction is a wrapper around Action that contains additional information + * + * @generated from message flyteidl2.workflow.EnrichedAction + */ +export type EnrichedAction = Message<"flyteidl2.workflow.EnrichedAction"> & { + /** + * The action itself. + * + * @generated from field: flyteidl2.workflow.Action action = 1; + */ + action?: Action; + + /** + * Whether this action meets specified filters of the request or not. + * If an action that was previously meeting the filter but no longer does, will be sent with this flag set to false + * + * @generated from field: bool meets_filter = 2; + */ + meetsFilter: boolean; + + /** + * Child phase info for this action (Map of phase to counts of children in given phase) + * + * @generated from field: map children_phase_counts = 3; + */ + childrenPhaseCounts: { [key: number]: number }; +}; + +/** + * Describes the message flyteidl2.workflow.EnrichedAction. + * Use `create(EnrichedActionSchema)` to create a new message. + */ +export const EnrichedActionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 11); + +/** + * ErrorInfo captures details of an error. + * + * @generated from message flyteidl2.workflow.ErrorInfo + */ +export type ErrorInfo = Message<"flyteidl2.workflow.ErrorInfo"> & { + /** + * Error message. + * + * @generated from field: string message = 1; + */ + message: string; + + /** + * Error kind. + * + * @generated from field: flyteidl2.workflow.ErrorInfo.Kind kind = 2; + */ + kind: ErrorInfo_Kind; +}; + +/** + * Describes the message flyteidl2.workflow.ErrorInfo. + * Use `create(ErrorInfoSchema)` to create a new message. + */ +export const ErrorInfoSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 12); + +/** + * @generated from enum flyteidl2.workflow.ErrorInfo.Kind + */ +export enum ErrorInfo_Kind { + /** + * @generated from enum value: KIND_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: KIND_USER = 1; + */ + USER = 1, + + /** + * @generated from enum value: KIND_SYSTEM = 2; + */ + SYSTEM = 2, +} + +/** + * Describes the enum flyteidl2.workflow.ErrorInfo.Kind. + */ +export const ErrorInfo_KindSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_workflow_run_definition, 12, 0); + +/** + * AbortInfo captures details of an aborted run. + * + * @generated from message flyteidl2.workflow.AbortInfo + */ +export type AbortInfo = Message<"flyteidl2.workflow.AbortInfo"> & { + /** + * Reason provided for the abort. + * + * @generated from field: string reason = 1; + */ + reason: string; + + /** + * Identity that aborted the run. + * + * @generated from field: flyteidl2.common.EnrichedIdentity aborted_by = 2; + */ + abortedBy?: EnrichedIdentity; +}; + +/** + * Describes the message flyteidl2.workflow.AbortInfo. + * Use `create(AbortInfoSchema)` to create a new message. + */ +export const AbortInfoSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 13); + +/** + * ActionDetails is the full details of an action. + * + * @generated from message flyteidl2.workflow.ActionDetails + */ +export type ActionDetails = Message<"flyteidl2.workflow.ActionDetails"> & { + /** + * Id for this action. + * + * @generated from field: flyteidl2.common.ActionIdentifier id = 1; + */ + id?: ActionIdentifier; + + /** + * Metadata for this action. + * + * @generated from field: flyteidl2.workflow.ActionMetadata metadata = 2; + */ + metadata?: ActionMetadata; + + /** + * Last known status. + * + * @generated from field: flyteidl2.workflow.ActionStatus status = 3; + */ + status?: ActionStatus; + + /** + * @generated from oneof flyteidl2.workflow.ActionDetails.result + */ + result: { + /** + * Error info for the action, if failed. + * + * @generated from field: flyteidl2.workflow.ErrorInfo error_info = 4; + */ + value: ErrorInfo; + case: "errorInfo"; + } | { + /** + * Abort info for the action, if aborted. + * + * @generated from field: flyteidl2.workflow.AbortInfo abort_info = 5; + */ + value: AbortInfo; + case: "abortInfo"; + } | { case: undefined; value?: undefined }; + + /** + * Fully resolved spec of the action. Merges user submitted task spec with platform defaults. + * + * @generated from oneof flyteidl2.workflow.ActionDetails.spec + */ + spec: { + /** + * @generated from field: flyteidl2.task.TaskSpec task = 6; + */ + value: TaskSpec; + case: "task"; + } | { + /** + * @generated from field: flyteidl2.task.TraceSpec trace = 8; + */ + value: TraceSpec; + case: "trace"; + } | { case: undefined; value?: undefined }; + + /** + * List of action attempts. + * + * @generated from field: repeated flyteidl2.workflow.ActionAttempt attempts = 7; + */ + attempts: ActionAttempt[]; +}; + +/** + * Describes the message flyteidl2.workflow.ActionDetails. + * Use `create(ActionDetailsSchema)` to create a new message. + */ +export const ActionDetailsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 14); + +/** + * ActionAttempt is a single attempt of an action. + * + * @generated from message flyteidl2.workflow.ActionAttempt + */ +export type ActionAttempt = Message<"flyteidl2.workflow.ActionAttempt"> & { + /** + * Last known phase. + * + * @generated from field: flyteidl2.common.ActionPhase phase = 1; + */ + phase: ActionPhase; + + /** + * Time the attempt started. + * + * @generated from field: google.protobuf.Timestamp start_time = 2; + */ + startTime?: Timestamp; + + /** + * Time the attempt ended, if applicable. + * + * @generated from field: optional google.protobuf.Timestamp end_time = 3; + */ + endTime?: Timestamp; + + /** + * Error info for the attempt, if failed. + * + * @generated from field: optional flyteidl2.workflow.ErrorInfo error_info = 4; + */ + errorInfo?: ErrorInfo; + + /** + * The attempt number, starting with 1. + * + * @generated from field: uint32 attempt = 5; + */ + attempt: number; + + /** + * Log references. + * + * @generated from field: repeated flyteidl2.core.TaskLog log_info = 6; + */ + logInfo: TaskLog[]; + + /** + * Output references. + * + * @generated from field: flyteidl2.task.OutputReferences outputs = 7; + */ + outputs?: OutputReferences; + + /** + * Indicates whether logs are available for tailing. It doesn't necessarily indicate the logs are present, but that + * we have the info we need to look them up. + * + * @generated from field: bool logs_available = 8; + */ + logsAvailable: boolean; + + /** + * cache status of the action attempt + * + * @generated from field: flyteidl2.core.CatalogCacheStatus cache_status = 9; + */ + cacheStatus: CatalogCacheStatus; + + /** + * Cluster events like k8s events in a human-readable form. + * + * @generated from field: repeated flyteidl2.workflow.ClusterEvent cluster_events = 10; + */ + clusterEvents: ClusterEvent[]; + + /** + * History of phase transitions. + * + * @generated from field: repeated flyteidl2.workflow.PhaseTransition phase_transitions = 11; + */ + phaseTransitions: PhaseTransition[]; + + /** + * The cluster this attempt is assigned to. + * + * @generated from field: string cluster = 12; + */ + cluster: string; + + /** + * Contains corresponding k8s pods and containers information for this action attempt. + * + * @generated from field: flyteidl2.core.LogContext log_context = 13; + */ + logContext?: LogContext; +}; + +/** + * Describes the message flyteidl2.workflow.ActionAttempt. + * Use `create(ActionAttemptSchema)` to create a new message. + */ +export const ActionAttemptSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 15); + +/** + * @generated from message flyteidl2.workflow.ClusterEvent + */ +export type ClusterEvent = Message<"flyteidl2.workflow.ClusterEvent"> & { + /** + * occurred_at is the timestamp indicating the instant that this reason happened. + * + * @generated from field: google.protobuf.Timestamp occurred_at = 1; + */ + occurredAt?: Timestamp; + + /** + * message is the explanation for the most recent phase transition or status update. + * + * @generated from field: string message = 2; + */ + message: string; +}; + +/** + * Describes the message flyteidl2.workflow.ClusterEvent. + * Use `create(ClusterEventSchema)` to create a new message. + */ +export const ClusterEventSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 16); + +/** + * @generated from message flyteidl2.workflow.PhaseTransition + */ +export type PhaseTransition = Message<"flyteidl2.workflow.PhaseTransition"> & { + /** + * The phase. + * + * @generated from field: flyteidl2.common.ActionPhase phase = 1; + */ + phase: ActionPhase; + + /** + * Time this phase started. + * + * @generated from field: google.protobuf.Timestamp start_time = 2; + */ + startTime?: Timestamp; + + /** + * Time this phase ended, if applicable. For terminal phases, start time will equal end time. + * + * @generated from field: optional google.protobuf.Timestamp end_time = 3; + */ + endTime?: Timestamp; +}; + +/** + * Describes the message flyteidl2.workflow.PhaseTransition. + * Use `create(PhaseTransitionSchema)` to create a new message. + */ +export const PhaseTransitionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 17); + +/** + * Event payload for an action + * + * @generated from message flyteidl2.workflow.ActionEvent + */ +export type ActionEvent = Message<"flyteidl2.workflow.ActionEvent"> & { + /** + * The action id. + * + * @generated from field: flyteidl2.common.ActionIdentifier id = 1; + */ + id?: ActionIdentifier; + + /** + * The attempt number. + * + * @generated from field: uint32 attempt = 2; + */ + attempt: number; + + /** + * The phase for this attempt. + * + * @generated from field: flyteidl2.common.ActionPhase phase = 3; + */ + phase: ActionPhase; + + /** + * The version of this attempt and phase. + * + * @generated from field: uint32 version = 4; + */ + version: number; + + /** + * Time the attempt started. + * + * @generated from field: google.protobuf.Timestamp start_time = 5 [deprecated = true]; + * @deprecated + */ + startTime?: Timestamp; + + /** + * Timestamp when the event occurred, as recorded by the underlying platform (e.g. Kubernetes). + * + * @generated from field: google.protobuf.Timestamp updated_time = 6; + */ + updatedTime?: Timestamp; + + /** + * Time the attempt ended, if applicable. + * + * @generated from field: optional google.protobuf.Timestamp end_time = 7 [deprecated = true]; + * @deprecated + */ + endTime?: Timestamp; + + /** + * Error info for the attempt, if failed. + * + * @generated from field: optional flyteidl2.workflow.ErrorInfo error_info = 8; + */ + errorInfo?: ErrorInfo; + + /** + * Log references. + * + * @generated from field: repeated flyteidl2.core.TaskLog log_info = 9; + */ + logInfo: TaskLog[]; + + /** + * Metadata to associate containers with logs. + * + * @generated from field: flyteidl2.core.LogContext log_context = 10; + */ + logContext?: LogContext; + + /** + * The cluster this attempt is running on. + * + * @generated from field: string cluster = 11; + */ + cluster: string; + + /** + * Output references. + * + * @generated from field: flyteidl2.task.OutputReferences outputs = 12; + */ + outputs?: OutputReferences; + + /** + * cache status of the action attempt + * + * @generated from field: flyteidl2.core.CatalogCacheStatus cache_status = 13; + */ + cacheStatus: CatalogCacheStatus; + + /** + * Cluster events like k8s events in a human-readable form. + * + * @generated from field: repeated flyteidl2.workflow.ClusterEvent cluster_events = 14; + */ + clusterEvents: ClusterEvent[]; + + /** + * Timestamp when the event was observed and reported by the executor + * + * @generated from field: google.protobuf.Timestamp reported_time = 15; + */ + reportedTime?: Timestamp; +}; + +/** + * Describes the message flyteidl2.workflow.ActionEvent. + * Use `create(ActionEventSchema)` to create a new message. + */ +export const ActionEventSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 18); + +/** + * @generated from message flyteidl2.workflow.ActionSpec + */ +export type ActionSpec = Message<"flyteidl2.workflow.ActionSpec"> & { + /** + * the unique identifier for the action. + * + * @generated from field: flyteidl2.common.ActionIdentifier action_id = 1; + */ + actionId?: ActionIdentifier; + + /** + * an optional name for the parent action, if it exists. the remaining run metadata (ex. org, + * project, domain) will be the same as the action_id defined above. + * + * @generated from field: optional string parent_action_name = 2; + */ + parentActionName?: string; + + /** + * the run spec for this action + * + * @generated from field: flyteidl2.task.RunSpec run_spec = 3; + */ + runSpec?: RunSpec; + + /** + * the path to the input data for this action. + * + * @generated from field: string input_uri = 4; + */ + inputUri: string; + + /** + * the run base path this action should write its output to. + * + * @generated from field: string run_output_base = 5; + */ + runOutputBase: string; + + /** + * @generated from oneof flyteidl2.workflow.ActionSpec.spec + */ + spec: { + /** + * @generated from field: flyteidl2.workflow.TaskAction task = 6; + */ + value: TaskAction; + case: "task"; + } | { + /** + * @generated from field: flyteidl2.workflow.ConditionAction condition = 7; + */ + value: ConditionAction; + case: "condition"; + } | { + /** + * @generated from field: flyteidl2.workflow.TraceAction trace = 10; + */ + value: TraceAction; + case: "trace"; + } | { case: undefined; value?: undefined }; + + /** + * group this action belongs to, if applicable. + * + * @generated from field: string group = 8; + */ + group: string; +}; + +/** + * Describes the message flyteidl2.workflow.ActionSpec. + * Use `create(ActionSpecSchema)` to create a new message. + */ +export const ActionSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 19); + +/** + * TaskGroup represents a group of runs for a specific task. + * + * @generated from message flyteidl2.workflow.TaskGroup + */ +export type TaskGroup = Message<"flyteidl2.workflow.TaskGroup"> & { + /** + * Task name. + * + * @generated from field: string task_name = 1; + */ + taskName: string; + + /** + * Environment name. + * + * @generated from field: string environment_name = 2; + */ + environmentName: string; + + /** + * Total number of runs for this task. + * + * @generated from field: int64 total_runs = 3; + */ + totalRuns: bigint; + + /** + * Timestamp of the most recent run. + * + * @generated from field: google.protobuf.Timestamp latest_run_time = 4; + */ + latestRunTime?: Timestamp; + + /** + * Recent run statuses, ordered from newest to oldest. Number of statuses determined by request. + * + * @generated from field: repeated flyteidl2.workflow.TaskGroup.RecentStatus recent_statuses = 5; + */ + recentStatuses: TaskGroup_RecentStatus[]; + + /** + * Average failure rate of runs in this group (0.0 to 1.0). + * Computed as number of root actions with phase FAILED divided by total root actions. + * + * @generated from field: double average_failure_rate = 6; + */ + averageFailureRate: number; + + /** + * Average duration of runs in this group. + * + * @generated from field: google.protobuf.Duration average_duration = 7; + */ + averageDuration?: Duration; + + /** + * Timestamp of the most recent finished run (terminal phase). + * + * @generated from field: google.protobuf.Timestamp latest_finished_time = 8; + */ + latestFinishedTime?: Timestamp; + + /** + * List of user/application's enriched identity that created runs in this group. + * + * @generated from field: repeated flyteidl2.common.EnrichedIdentity created_by = 9; + */ + createdBy: EnrichedIdentity[]; + + /** + * @generated from field: bool should_delete = 10; + */ + shouldDelete: boolean; + + /** + * short name (function name) of the task. + * + * @generated from field: string short_name = 11; + */ + shortName: string; + + /** + * @generated from field: flyteidl2.workflow.TaskGroup.ErrorCounts error_counts = 12; + */ + errorCounts?: TaskGroup_ErrorCounts; + + /** + * @generated from field: repeated flyteidl2.workflow.TaskGroup.PhaseCounts phase_counts = 13; + */ + phaseCounts: TaskGroup_PhaseCounts[]; +}; + +/** + * Describes the message flyteidl2.workflow.TaskGroup. + * Use `create(TaskGroupSchema)` to create a new message. + */ +export const TaskGroupSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 20); + +/** + * @generated from message flyteidl2.workflow.TaskGroup.RecentStatus + */ +export type TaskGroup_RecentStatus = Message<"flyteidl2.workflow.TaskGroup.RecentStatus"> & { + /** + * @generated from field: string run_name = 1; + */ + runName: string; + + /** + * @generated from field: flyteidl2.common.ActionPhase phase = 2; + */ + phase: ActionPhase; +}; + +/** + * Describes the message flyteidl2.workflow.TaskGroup.RecentStatus. + * Use `create(TaskGroup_RecentStatusSchema)` to create a new message. + */ +export const TaskGroup_RecentStatusSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 20, 0); + +/** + * @generated from message flyteidl2.workflow.TaskGroup.ErrorCounts + */ +export type TaskGroup_ErrorCounts = Message<"flyteidl2.workflow.TaskGroup.ErrorCounts"> & { + /** + * @generated from field: int64 user_error = 1; + */ + userError: bigint; + + /** + * @generated from field: int64 system_error = 2; + */ + systemError: bigint; + + /** + * @generated from field: int64 unspecified_error = 3; + */ + unspecifiedError: bigint; +}; + +/** + * Describes the message flyteidl2.workflow.TaskGroup.ErrorCounts. + * Use `create(TaskGroup_ErrorCountsSchema)` to create a new message. + */ +export const TaskGroup_ErrorCountsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 20, 1); + +/** + * @generated from message flyteidl2.workflow.TaskGroup.PhaseCounts + */ +export type TaskGroup_PhaseCounts = Message<"flyteidl2.workflow.TaskGroup.PhaseCounts"> & { + /** + * @generated from field: flyteidl2.common.ActionPhase phase = 1; + */ + phase: ActionPhase; + + /** + * @generated from field: int64 count = 2; + */ + count: bigint; +}; + +/** + * Describes the message flyteidl2.workflow.TaskGroup.PhaseCounts. + * Use `create(TaskGroup_PhaseCountsSchema)` to create a new message. + */ +export const TaskGroup_PhaseCountsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_definition, 20, 2); + +/** + * @generated from enum flyteidl2.workflow.ActionType + */ +export enum ActionType { + /** + * @generated from enum value: ACTION_TYPE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: ACTION_TYPE_TASK = 1; + */ + TASK = 1, + + /** + * @generated from enum value: ACTION_TYPE_TRACE = 2; + */ + TRACE = 2, + + /** + * @generated from enum value: ACTION_TYPE_CONDITION = 3; + */ + CONDITION = 3, +} + +/** + * Describes the enum flyteidl2.workflow.ActionType. + */ +export const ActionTypeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_workflow_run_definition, 0); + +/** + * @generated from enum flyteidl2.workflow.RunSource + */ +export enum RunSource { + /** + * @generated from enum value: RUN_SOURCE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: RUN_SOURCE_WEB = 1; + */ + WEB = 1, + + /** + * @generated from enum value: RUN_SOURCE_CLI = 2; + */ + CLI = 2, + + /** + * @generated from enum value: RUN_SOURCE_SCHEDULE_TRIGGER = 3; + */ + SCHEDULE_TRIGGER = 3, +} + +/** + * Describes the enum flyteidl2.workflow.RunSource. + */ +export const RunSourceSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_flyteidl2_workflow_run_definition, 1); + diff --git a/gen/ts/flyteidl2/workflow/run_logs_service_pb.ts b/gen/ts/flyteidl2/workflow/run_logs_service_pb.ts new file mode 100644 index 0000000000..adf198d430 --- /dev/null +++ b/gen/ts/flyteidl2/workflow/run_logs_service_pb.ts @@ -0,0 +1,106 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/workflow/run_logs_service.proto (package flyteidl2.workflow, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { ActionIdentifier } from "../common/identifier_pb.ts"; +import { file_flyteidl2_common_identifier } from "../common/identifier_pb.ts"; +import type { LogLine } from "../logs/dataplane/payload_pb.ts"; +import { file_flyteidl2_logs_dataplane_payload } from "../logs/dataplane/payload_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/workflow/run_logs_service.proto. + */ +export const file_flyteidl2_workflow_run_logs_service: GenFile = /*@__PURE__*/ + fileDesc("CilmbHl0ZWlkbDIvd29ya2Zsb3cvcnVuX2xvZ3Nfc2VydmljZS5wcm90bxISZmx5dGVpZGwyLndvcmtmbG93ImoKD1RhaWxMb2dzUmVxdWVzdBI9CglhY3Rpb25faWQYASABKAsyIi5mbHl0ZWlkbDIuY29tbW9uLkFjdGlvbklkZW50aWZpZXJCBrpIA8gBARIYCgdhdHRlbXB0GAIgASgNQge6SAQqAiAAIoUBChBUYWlsTG9nc1Jlc3BvbnNlEjcKBGxvZ3MYASADKAsyKS5mbHl0ZWlkbDIud29ya2Zsb3cuVGFpbExvZ3NSZXNwb25zZS5Mb2dzGjgKBExvZ3MSMAoFbGluZXMYASADKAsyIS5mbHl0ZWlkbDIubG9ncy5kYXRhcGxhbmUuTG9nTGluZTJuCg5SdW5Mb2dzU2VydmljZRJcCghUYWlsTG9ncxIjLmZseXRlaWRsMi53b3JrZmxvdy5UYWlsTG9nc1JlcXVlc3QaJC5mbHl0ZWlkbDIud29ya2Zsb3cuVGFpbExvZ3NSZXNwb25zZSIDkAIBMAFC0AEKFmNvbS5mbHl0ZWlkbDIud29ya2Zsb3dCE1J1bkxvZ3NTZXJ2aWNlUHJvdG9IAlABWjZnaXRodWIuY29tL2ZseXRlb3JnL2ZseXRlL3YyL2dlbi9nby9mbHl0ZWlkbDIvd29ya2Zsb3eiAgNGV1iqAhJGbHl0ZWlkbDIuV29ya2Zsb3fKAhJGbHl0ZWlkbDJcV29ya2Zsb3fiAh5GbHl0ZWlkbDJcV29ya2Zsb3dcR1BCTWV0YWRhdGHqAhNGbHl0ZWlkbDI6OldvcmtmbG93YgZwcm90bzM", [file_buf_validate_validate, file_flyteidl2_common_identifier, file_flyteidl2_logs_dataplane_payload]); + +/** + * Request message for tailing logs. + * + * @generated from message flyteidl2.workflow.TailLogsRequest + */ +export type TailLogsRequest = Message<"flyteidl2.workflow.TailLogsRequest"> & { + /** + * The action id. + * + * @generated from field: flyteidl2.common.ActionIdentifier action_id = 1; + */ + actionId?: ActionIdentifier; + + /** + * The attempt number. + * + * @generated from field: uint32 attempt = 2; + */ + attempt: number; +}; + +/** + * Describes the message flyteidl2.workflow.TailLogsRequest. + * Use `create(TailLogsRequestSchema)` to create a new message. + */ +export const TailLogsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_logs_service, 0); + +/** + * Reponse message for tailing logs. + * + * @generated from message flyteidl2.workflow.TailLogsResponse + */ +export type TailLogsResponse = Message<"flyteidl2.workflow.TailLogsResponse"> & { + /** + * One or more batches of logs. + * + * @generated from field: repeated flyteidl2.workflow.TailLogsResponse.Logs logs = 1; + */ + logs: TailLogsResponse_Logs[]; +}; + +/** + * Describes the message flyteidl2.workflow.TailLogsResponse. + * Use `create(TailLogsResponseSchema)` to create a new message. + */ +export const TailLogsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_logs_service, 1); + +/** + * A batch of logs. + * + * @generated from message flyteidl2.workflow.TailLogsResponse.Logs + */ +export type TailLogsResponse_Logs = Message<"flyteidl2.workflow.TailLogsResponse.Logs"> & { + /** + * Structured log lines. + * + * @generated from field: repeated flyteidl2.logs.dataplane.LogLine lines = 1; + */ + lines: LogLine[]; +}; + +/** + * Describes the message flyteidl2.workflow.TailLogsResponse.Logs. + * Use `create(TailLogsResponse_LogsSchema)` to create a new message. + */ +export const TailLogsResponse_LogsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_logs_service, 1, 0); + +/** + * RunLogsService provides an interface for streaming logs. + * + * @generated from service flyteidl2.workflow.RunLogsService + */ +export const RunLogsService: GenService<{ + /** + * @generated from rpc flyteidl2.workflow.RunLogsService.TailLogs + */ + tailLogs: { + methodKind: "server_streaming"; + input: typeof TailLogsRequestSchema; + output: typeof TailLogsResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_workflow_run_logs_service, 0); + diff --git a/gen/ts/flyteidl2/workflow/run_service_pb.ts b/gen/ts/flyteidl2/workflow/run_service_pb.ts new file mode 100644 index 0000000000..4e22be1f0e --- /dev/null +++ b/gen/ts/flyteidl2/workflow/run_service_pb.ts @@ -0,0 +1,1006 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/workflow/run_service.proto (package flyteidl2.workflow, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { ActionIdentifier, ClusterIdentifier, ProjectIdentifier, RunIdentifier, TriggerName } from "../common/identifier_pb.ts"; +import { file_flyteidl2_common_identifier } from "../common/identifier_pb.ts"; +import type { Filter, ListRequest, Sort_Direction } from "../common/list_pb.ts"; +import { file_flyteidl2_common_list } from "../common/list_pb.ts"; +import type { Inputs, Outputs } from "../task/common_pb.ts"; +import { file_flyteidl2_task_common } from "../task/common_pb.ts"; +import type { RunSpec } from "../task/run_pb.ts"; +import { file_flyteidl2_task_run } from "../task/run_pb.ts"; +import type { TaskIdentifier, TaskName, TaskSpec } from "../task/task_definition_pb.ts"; +import { file_flyteidl2_task_task_definition } from "../task/task_definition_pb.ts"; +import type { Action, ActionDetails, ClusterEvent, EnrichedAction, Run, RunDetails, RunSource, TaskGroup } from "./run_definition_pb.ts"; +import { file_flyteidl2_workflow_run_definition } from "./run_definition_pb.ts"; +import type { Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/workflow/run_service.proto. + */ +export const file_flyteidl2_workflow_run_service: GenFile = /*@__PURE__*/ + fileDesc("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", [file_buf_validate_validate, file_flyteidl2_common_identifier, file_flyteidl2_common_list, file_flyteidl2_task_common, file_flyteidl2_task_run, file_flyteidl2_task_task_definition, file_flyteidl2_workflow_run_definition, file_google_protobuf_timestamp]); + +/** + * Request message for creating a run. + * + * @generated from message flyteidl2.workflow.CreateRunRequest + */ +export type CreateRunRequest = Message<"flyteidl2.workflow.CreateRunRequest"> & { + /** + * @generated from oneof flyteidl2.workflow.CreateRunRequest.id + */ + id: { + /** + * The user provided run id. + * + * @generated from field: flyteidl2.common.RunIdentifier run_id = 1; + */ + value: RunIdentifier; + case: "runId"; + } | { + /** + * The project id for this run. Run name will be generated. + * + * @generated from field: flyteidl2.common.ProjectIdentifier project_id = 6; + */ + value: ProjectIdentifier; + case: "projectId"; + } | { case: undefined; value?: undefined }; + + /** + * The task to run. + * + * @generated from oneof flyteidl2.workflow.CreateRunRequest.task + */ + task: { + /** + * The task id to use. + * + * @generated from field: flyteidl2.task.TaskIdentifier task_id = 2; + */ + value: TaskIdentifier; + case: "taskId"; + } | { + /** + * The task spec to use. + * + * @generated from field: flyteidl2.task.TaskSpec task_spec = 3; + */ + value: TaskSpec; + case: "taskSpec"; + } | { + /** + * The trigger name to use. + * + * @generated from field: flyteidl2.common.TriggerName trigger_name = 7; + */ + value: TriggerName; + case: "triggerName"; + } | { case: undefined; value?: undefined }; + + /** + * Inputs to use. + * + * @generated from field: flyteidl2.task.Inputs inputs = 4; + */ + inputs?: Inputs; + + /** + * The run spec to use. + * + * @generated from field: flyteidl2.task.RunSpec run_spec = 5; + */ + runSpec?: RunSpec; + + /** + * Indicates client that created this run. + * + * @generated from field: flyteidl2.workflow.RunSource source = 8; + */ + source: RunSource; +}; + +/** + * Describes the message flyteidl2.workflow.CreateRunRequest. + * Use `create(CreateRunRequestSchema)` to create a new message. + */ +export const CreateRunRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 0); + +/** + * Response message for creating a run. + * + * @generated from message flyteidl2.workflow.CreateRunResponse + */ +export type CreateRunResponse = Message<"flyteidl2.workflow.CreateRunResponse"> & { + /** + * @generated from field: flyteidl2.workflow.Run run = 1; + */ + run?: Run; +}; + +/** + * Describes the message flyteidl2.workflow.CreateRunResponse. + * Use `create(CreateRunResponseSchema)` to create a new message. + */ +export const CreateRunResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 1); + +/** + * Request message for aborting a run. + * + * @generated from message flyteidl2.workflow.AbortRunRequest + */ +export type AbortRunRequest = Message<"flyteidl2.workflow.AbortRunRequest"> & { + /** + * Run to abort. + * + * @generated from field: flyteidl2.common.RunIdentifier run_id = 1; + */ + runId?: RunIdentifier; + + /** + * Reason for aborting the run. if applicable. + * + * @generated from field: optional string reason = 2; + */ + reason?: string; +}; + +/** + * Describes the message flyteidl2.workflow.AbortRunRequest. + * Use `create(AbortRunRequestSchema)` to create a new message. + */ +export const AbortRunRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 2); + +/** + * Response message for aborting a run. + * + * @generated from message flyteidl2.workflow.AbortRunResponse + */ +export type AbortRunResponse = Message<"flyteidl2.workflow.AbortRunResponse"> & { +}; + +/** + * Describes the message flyteidl2.workflow.AbortRunResponse. + * Use `create(AbortRunResponseSchema)` to create a new message. + */ +export const AbortRunResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 3); + +/** + * Request message for getting detailed information about a run. + * + * @generated from message flyteidl2.workflow.GetRunDetailsRequest + */ +export type GetRunDetailsRequest = Message<"flyteidl2.workflow.GetRunDetailsRequest"> & { + /** + * Run to query. + * + * @generated from field: flyteidl2.common.RunIdentifier run_id = 1; + */ + runId?: RunIdentifier; +}; + +/** + * Describes the message flyteidl2.workflow.GetRunDetailsRequest. + * Use `create(GetRunDetailsRequestSchema)` to create a new message. + */ +export const GetRunDetailsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 4); + +/** + * Response message for getting detailed information about a run. + * + * @generated from message flyteidl2.workflow.GetRunDetailsResponse + */ +export type GetRunDetailsResponse = Message<"flyteidl2.workflow.GetRunDetailsResponse"> & { + /** + * Detailed information about the run. + * + * @generated from field: flyteidl2.workflow.RunDetails details = 1; + */ + details?: RunDetails; +}; + +/** + * Describes the message flyteidl2.workflow.GetRunDetailsResponse. + * Use `create(GetRunDetailsResponseSchema)` to create a new message. + */ +export const GetRunDetailsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 5); + +/** + * Request message for watching detailed information about a run. + * + * @generated from message flyteidl2.workflow.WatchRunDetailsRequest + */ +export type WatchRunDetailsRequest = Message<"flyteidl2.workflow.WatchRunDetailsRequest"> & { + /** + * Run to query. + * + * @generated from field: flyteidl2.common.RunIdentifier run_id = 1; + */ + runId?: RunIdentifier; +}; + +/** + * Describes the message flyteidl2.workflow.WatchRunDetailsRequest. + * Use `create(WatchRunDetailsRequestSchema)` to create a new message. + */ +export const WatchRunDetailsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 6); + +/** + * Response message for watching detailed information about a run. + * + * @generated from message flyteidl2.workflow.WatchRunDetailsResponse + */ +export type WatchRunDetailsResponse = Message<"flyteidl2.workflow.WatchRunDetailsResponse"> & { + /** + * Detailed information about the run. + * + * @generated from field: flyteidl2.workflow.RunDetails details = 1; + */ + details?: RunDetails; +}; + +/** + * Describes the message flyteidl2.workflow.WatchRunDetailsResponse. + * Use `create(WatchRunDetailsResponseSchema)` to create a new message. + */ +export const WatchRunDetailsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 7); + +/** + * Request message for getting detailed information about an action. + * + * @generated from message flyteidl2.workflow.GetActionDetailsRequest + */ +export type GetActionDetailsRequest = Message<"flyteidl2.workflow.GetActionDetailsRequest"> & { + /** + * Action to query. + * + * @generated from field: flyteidl2.common.ActionIdentifier action_id = 1; + */ + actionId?: ActionIdentifier; +}; + +/** + * Describes the message flyteidl2.workflow.GetActionDetailsRequest. + * Use `create(GetActionDetailsRequestSchema)` to create a new message. + */ +export const GetActionDetailsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 8); + +/** + * Response message for getting detailed information about an action. + * + * @generated from message flyteidl2.workflow.GetActionDetailsResponse + */ +export type GetActionDetailsResponse = Message<"flyteidl2.workflow.GetActionDetailsResponse"> & { + /** + * Detailed information about the action. + * + * @generated from field: flyteidl2.workflow.ActionDetails details = 1; + */ + details?: ActionDetails; +}; + +/** + * Describes the message flyteidl2.workflow.GetActionDetailsResponse. + * Use `create(GetActionDetailsResponseSchema)` to create a new message. + */ +export const GetActionDetailsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 9); + +/** + * Request message for watching detailed information about an action. + * + * @generated from message flyteidl2.workflow.WatchActionDetailsRequest + */ +export type WatchActionDetailsRequest = Message<"flyteidl2.workflow.WatchActionDetailsRequest"> & { + /** + * Action to query. + * + * @generated from field: flyteidl2.common.ActionIdentifier action_id = 1; + */ + actionId?: ActionIdentifier; +}; + +/** + * Describes the message flyteidl2.workflow.WatchActionDetailsRequest. + * Use `create(WatchActionDetailsRequestSchema)` to create a new message. + */ +export const WatchActionDetailsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 10); + +/** + * Response message for watching detailed information about an action. + * + * @generated from message flyteidl2.workflow.WatchActionDetailsResponse + */ +export type WatchActionDetailsResponse = Message<"flyteidl2.workflow.WatchActionDetailsResponse"> & { + /** + * Detailed information about the action. + * + * @generated from field: flyteidl2.workflow.ActionDetails details = 1; + */ + details?: ActionDetails; +}; + +/** + * Describes the message flyteidl2.workflow.WatchActionDetailsResponse. + * Use `create(WatchActionDetailsResponseSchema)` to create a new message. + */ +export const WatchActionDetailsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 11); + +/** + * Request message for querying action data. + * + * @generated from message flyteidl2.workflow.GetActionDataRequest + */ +export type GetActionDataRequest = Message<"flyteidl2.workflow.GetActionDataRequest"> & { + /** + * Action to query. + * + * @generated from field: flyteidl2.common.ActionIdentifier action_id = 1; + */ + actionId?: ActionIdentifier; +}; + +/** + * Describes the message flyteidl2.workflow.GetActionDataRequest. + * Use `create(GetActionDataRequestSchema)` to create a new message. + */ +export const GetActionDataRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 12); + +/** + * Response message for querying action data. + * + * @generated from message flyteidl2.workflow.GetActionDataResponse + */ +export type GetActionDataResponse = Message<"flyteidl2.workflow.GetActionDataResponse"> & { + /** + * Inputs for the action. + * + * @generated from field: flyteidl2.task.Inputs inputs = 1; + */ + inputs?: Inputs; + + /** + * Outputs for the action. + * + * @generated from field: flyteidl2.task.Outputs outputs = 2; + */ + outputs?: Outputs; +}; + +/** + * Describes the message flyteidl2.workflow.GetActionDataResponse. + * Use `create(GetActionDataResponseSchema)` to create a new message. + */ +export const GetActionDataResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 13); + +/** + * Request message for listing runs. + * + * @generated from message flyteidl2.workflow.ListRunsRequest + */ +export type ListRunsRequest = Message<"flyteidl2.workflow.ListRunsRequest"> & { + /** + * Common list request parameters. + * + * @generated from field: flyteidl2.common.ListRequest request = 1; + */ + request?: ListRequest; + + /** + * @generated from oneof flyteidl2.workflow.ListRunsRequest.scope_by + */ + scopeBy: { + /** + * Organization name for filtering runs. + * + * @generated from field: string org = 2; + */ + value: string; + case: "org"; + } | { + /** + * Project identifier for filtering runs. + * + * @generated from field: flyteidl2.common.ProjectIdentifier project_id = 4; + */ + value: ProjectIdentifier; + case: "projectId"; + } | { + /** + * List runs created from a trigger. + * + * @generated from field: flyteidl2.common.TriggerName trigger_name = 6; + */ + value: TriggerName; + case: "triggerName"; + } | { + /** + * Task name for filtering runs + * + * @generated from field: flyteidl2.task.TaskName task_name = 7; + */ + value: TaskName; + case: "taskName"; + } | { + /** + * Task identifier for filtering runs + * + * @generated from field: flyteidl2.task.TaskIdentifier task_id = 8; + */ + value: TaskIdentifier; + case: "taskId"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.workflow.ListRunsRequest. + * Use `create(ListRunsRequestSchema)` to create a new message. + */ +export const ListRunsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 14); + +/** + * Response message for listing runs. + * + * @generated from message flyteidl2.workflow.ListRunsResponse + */ +export type ListRunsResponse = Message<"flyteidl2.workflow.ListRunsResponse"> & { + /** + * List of runs matching the filter criteria. + * + * @generated from field: repeated flyteidl2.workflow.Run runs = 1; + */ + runs: Run[]; + + /** + * Token for fetching the next page of results, if any. + * + * @generated from field: string token = 2; + */ + token: string; +}; + +/** + * Describes the message flyteidl2.workflow.ListRunsResponse. + * Use `create(ListRunsResponseSchema)` to create a new message. + */ +export const ListRunsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 15); + +/** + * Request message for watching runs. + * + * @generated from message flyteidl2.workflow.WatchRunsRequest + */ +export type WatchRunsRequest = Message<"flyteidl2.workflow.WatchRunsRequest"> & { + /** + * @generated from oneof flyteidl2.workflow.WatchRunsRequest.target + */ + target: { + /** + * Organization name for filtering runs. + * + * @generated from field: string org = 2; + */ + value: string; + case: "org"; + } | { + /** + * Cluster identifier for filtering runs. + * + * @generated from field: flyteidl2.common.ClusterIdentifier cluster_id = 3; + */ + value: ClusterIdentifier; + case: "clusterId"; + } | { + /** + * Project identifier for filtering runs. + * + * @generated from field: flyteidl2.common.ProjectIdentifier project_id = 4; + */ + value: ProjectIdentifier; + case: "projectId"; + } | { + /** + * Task identifier for filtering runs. + * + * @generated from field: flyteidl2.task.TaskIdentifier task_id = 5; + */ + value: TaskIdentifier; + case: "taskId"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.workflow.WatchRunsRequest. + * Use `create(WatchRunsRequestSchema)` to create a new message. + */ +export const WatchRunsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 16); + +/** + * Response message for watching runs. + * + * @generated from message flyteidl2.workflow.WatchRunsResponse + */ +export type WatchRunsResponse = Message<"flyteidl2.workflow.WatchRunsResponse"> & { + /** + * New or updated runs matching the filter criteria. + * + * @generated from field: repeated flyteidl2.workflow.Run runs = 1; + */ + runs: Run[]; +}; + +/** + * Describes the message flyteidl2.workflow.WatchRunsResponse. + * Use `create(WatchRunsResponseSchema)` to create a new message. + */ +export const WatchRunsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 17); + +/** + * Request message for listing actions. + * + * @generated from message flyteidl2.workflow.ListActionsRequest + */ +export type ListActionsRequest = Message<"flyteidl2.workflow.ListActionsRequest"> & { + /** + * Common list request parameters. + * + * @generated from field: flyteidl2.common.ListRequest request = 1; + */ + request?: ListRequest; + + /** + * Run identifier for filtering actions. + * + * @generated from field: flyteidl2.common.RunIdentifier run_id = 2; + */ + runId?: RunIdentifier; +}; + +/** + * Describes the message flyteidl2.workflow.ListActionsRequest. + * Use `create(ListActionsRequestSchema)` to create a new message. + */ +export const ListActionsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 18); + +/** + * Response message for listing actions. + * + * @generated from message flyteidl2.workflow.ListActionsResponse + */ +export type ListActionsResponse = Message<"flyteidl2.workflow.ListActionsResponse"> & { + /** + * List of actions matching the filter criteria. + * + * @generated from field: repeated flyteidl2.workflow.Action actions = 1; + */ + actions: Action[]; + + /** + * Token for fetching the next page of results, if any. + * + * @generated from field: string token = 2; + */ + token: string; +}; + +/** + * Describes the message flyteidl2.workflow.ListActionsResponse. + * Use `create(ListActionsResponseSchema)` to create a new message. + */ +export const ListActionsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 19); + +/** + * Request message for watching actions. + * + * @generated from message flyteidl2.workflow.WatchActionsRequest + */ +export type WatchActionsRequest = Message<"flyteidl2.workflow.WatchActionsRequest"> & { + /** + * Run identifier for filtering actions. + * + * @generated from field: flyteidl2.common.RunIdentifier run_id = 1; + */ + runId?: RunIdentifier; + + /** + * Optional filter(s) criteria for actions. + * Valid filter fields include: + * - NAME (must use function CONTAINS_CASE_INSENSITIVE): the value is whatever string to match to. This will cast all strings to lowercase and match. + * - PHASE (must use function VALUE_IN): the value is the stringified integer of the enum of the phase and you can pass multiple phases (i.e. ["1", "4"]) + * + * @generated from field: repeated flyteidl2.common.Filter filter = 2; + */ + filter: Filter[]; +}; + +/** + * Describes the message flyteidl2.workflow.WatchActionsRequest. + * Use `create(WatchActionsRequestSchema)` to create a new message. + */ +export const WatchActionsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 20); + +/** + * Response message for watching actions, comes with enriched action metadata. + * + * @generated from message flyteidl2.workflow.WatchActionsResponse + */ +export type WatchActionsResponse = Message<"flyteidl2.workflow.WatchActionsResponse"> & { + /** + * New or updated actions matching the filter criteria. Enriched with children status counts + * + * @generated from field: repeated flyteidl2.workflow.EnrichedAction enriched_actions = 1; + */ + enrichedActions: EnrichedAction[]; +}; + +/** + * Describes the message flyteidl2.workflow.WatchActionsResponse. + * Use `create(WatchActionsResponseSchema)` to create a new message. + */ +export const WatchActionsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 21); + +/** + * @generated from message flyteidl2.workflow.WatchClusterEventsRequest + */ +export type WatchClusterEventsRequest = Message<"flyteidl2.workflow.WatchClusterEventsRequest"> & { + /** + * @generated from field: flyteidl2.common.ActionIdentifier id = 1; + */ + id?: ActionIdentifier; + + /** + * @generated from field: uint32 attempt = 2; + */ + attempt: number; +}; + +/** + * Describes the message flyteidl2.workflow.WatchClusterEventsRequest. + * Use `create(WatchClusterEventsRequestSchema)` to create a new message. + */ +export const WatchClusterEventsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 22); + +/** + * @generated from message flyteidl2.workflow.WatchClusterEventsResponse + */ +export type WatchClusterEventsResponse = Message<"flyteidl2.workflow.WatchClusterEventsResponse"> & { + /** + * @generated from field: repeated flyteidl2.workflow.ClusterEvent cluster_events = 1; + */ + clusterEvents: ClusterEvent[]; +}; + +/** + * Describes the message flyteidl2.workflow.WatchClusterEventsResponse. + * Use `create(WatchClusterEventsResponseSchema)` to create a new message. + */ +export const WatchClusterEventsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 23); + +/** + * @generated from message flyteidl2.workflow.AbortActionRequest + */ +export type AbortActionRequest = Message<"flyteidl2.workflow.AbortActionRequest"> & { + /** + * Action to abort. + * + * @generated from field: flyteidl2.common.ActionIdentifier action_id = 1; + */ + actionId?: ActionIdentifier; + + /** + * Optional reason for aborting the action. + * + * @generated from field: string reason = 2; + */ + reason: string; +}; + +/** + * Describes the message flyteidl2.workflow.AbortActionRequest. + * Use `create(AbortActionRequestSchema)` to create a new message. + */ +export const AbortActionRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 24); + +/** + * @generated from message flyteidl2.workflow.AbortActionResponse + */ +export type AbortActionResponse = Message<"flyteidl2.workflow.AbortActionResponse"> & { +}; + +/** + * Describes the message flyteidl2.workflow.AbortActionResponse. + * Use `create(AbortActionResponseSchema)` to create a new message. + */ +export const AbortActionResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 25); + +/** + * @generated from message flyteidl2.workflow.WatchGroupsRequest + */ +export type WatchGroupsRequest = Message<"flyteidl2.workflow.WatchGroupsRequest"> & { + /** + * @generated from oneof flyteidl2.workflow.WatchGroupsRequest.scope_by + */ + scopeBy: { + /** + * Watch groups within a project. + * + * @generated from field: flyteidl2.common.ProjectIdentifier project_id = 1; + */ + value: ProjectIdentifier; + case: "projectId"; + } | { case: undefined; value?: undefined }; + + /** + * Filter groups after this date (inclusive). Required. + * + * @generated from field: google.protobuf.Timestamp start_date = 2; + */ + startDate?: Timestamp; + + /** + * Filter groups before this date (inclusive). + * If null, will stream updates up to current time. + * If not null, will return groups once and close stream. + * + * @generated from field: google.protobuf.Timestamp end_date = 3; + */ + endDate?: Timestamp; + + /** + * Common list request parameters. + * + * @generated from field: flyteidl2.common.ListRequest request = 4; + */ + request?: ListRequest; + + /** + * Known sort fields in watch group + * + * @generated from field: repeated flyteidl2.workflow.WatchGroupsRequest.KnownSortField known_sort_fields = 5; + */ + knownSortFields: WatchGroupsRequest_KnownSortField[]; +}; + +/** + * Describes the message flyteidl2.workflow.WatchGroupsRequest. + * Use `create(WatchGroupsRequestSchema)` to create a new message. + */ +export const WatchGroupsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 26); + +/** + * @generated from message flyteidl2.workflow.WatchGroupsRequest.KnownSortField + */ +export type WatchGroupsRequest_KnownSortField = Message<"flyteidl2.workflow.WatchGroupsRequest.KnownSortField"> & { + /** + * @generated from oneof flyteidl2.workflow.WatchGroupsRequest.KnownSortField.sort_by + */ + sortBy: { + /** + * @generated from field: flyteidl2.common.Sort.Direction created_at = 1; + */ + value: Sort_Direction; + case: "createdAt"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.workflow.WatchGroupsRequest.KnownSortField. + * Use `create(WatchGroupsRequest_KnownSortFieldSchema)` to create a new message. + */ +export const WatchGroupsRequest_KnownSortFieldSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 26, 0); + +/** + * Response message for watching task groups. + * + * @generated from message flyteidl2.workflow.WatchGroupsResponse + */ +export type WatchGroupsResponse = Message<"flyteidl2.workflow.WatchGroupsResponse"> & { + /** + * List of task groups matching the filter criteria. + * For the initial response, this contains all groups. + * For subsequent updates, this contains only changed groups. + * + * @generated from field: repeated flyteidl2.workflow.TaskGroup task_groups = 1; + */ + taskGroups: TaskGroup[]; + + /** + * Indicates when the initial List call is complete, and subsequent messages are updates. + * + * @generated from field: bool sentinel = 2; + */ + sentinel: boolean; +}; + +/** + * Describes the message flyteidl2.workflow.WatchGroupsResponse. + * Use `create(WatchGroupsResponseSchema)` to create a new message. + */ +export const WatchGroupsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_run_service, 27); + +/** + * RunService provides an interface for managing runs. + * + * @generated from service flyteidl2.workflow.RunService + */ +export const RunService: GenService<{ + /** + * Create a new run of the given task. + * + * @generated from rpc flyteidl2.workflow.RunService.CreateRun + */ + createRun: { + methodKind: "unary"; + input: typeof CreateRunRequestSchema; + output: typeof CreateRunResponseSchema; + }, + /** + * Abort a run. + * + * @generated from rpc flyteidl2.workflow.RunService.AbortRun + */ + abortRun: { + methodKind: "unary"; + input: typeof AbortRunRequestSchema; + output: typeof AbortRunResponseSchema; + }, + /** + * Get detailed information about a run. + * + * @generated from rpc flyteidl2.workflow.RunService.GetRunDetails + */ + getRunDetails: { + methodKind: "unary"; + input: typeof GetRunDetailsRequestSchema; + output: typeof GetRunDetailsResponseSchema; + }, + /** + * Stream detailed information updates about a run. The call will terminate when the run reaches a terminal phase. + * + * @generated from rpc flyteidl2.workflow.RunService.WatchRunDetails + */ + watchRunDetails: { + methodKind: "server_streaming"; + input: typeof WatchRunDetailsRequestSchema; + output: typeof WatchRunDetailsResponseSchema; + }, + /** + * Get detailed information about an action. + * + * @generated from rpc flyteidl2.workflow.RunService.GetActionDetails + */ + getActionDetails: { + methodKind: "unary"; + input: typeof GetActionDetailsRequestSchema; + output: typeof GetActionDetailsResponseSchema; + }, + /** + * Stream detailed information updates about an action. The call will terminate when the action reaches a terminal phase. + * + * @generated from rpc flyteidl2.workflow.RunService.WatchActionDetails + */ + watchActionDetails: { + methodKind: "server_streaming"; + input: typeof WatchActionDetailsRequestSchema; + output: typeof WatchActionDetailsResponseSchema; + }, + /** + * Get input and output for an action. + * + * @generated from rpc flyteidl2.workflow.RunService.GetActionData + */ + getActionData: { + methodKind: "unary"; + input: typeof GetActionDataRequestSchema; + output: typeof GetActionDataResponseSchema; + }, + /** + * List runs based on the provided filter criteria. + * + * @generated from rpc flyteidl2.workflow.RunService.ListRuns + */ + listRuns: { + methodKind: "unary"; + input: typeof ListRunsRequestSchema; + output: typeof ListRunsResponseSchema; + }, + /** + * Stream updates for runs based on the provided filter criteria. Responses may include newly discovered + * runs or updates to existing ones from the point of invocation. + * + * @generated from rpc flyteidl2.workflow.RunService.WatchRuns + */ + watchRuns: { + methodKind: "server_streaming"; + input: typeof WatchRunsRequestSchema; + output: typeof WatchRunsResponseSchema; + }, + /** + * List all actions for a given run. + * + * @generated from rpc flyteidl2.workflow.RunService.ListActions + */ + listActions: { + methodKind: "unary"; + input: typeof ListActionsRequestSchema; + output: typeof ListActionsResponseSchema; + }, + /** + * Stream updates for actions given a run. Responses may include newly discovered nested runs or updates + * to existing ones from the point of invocation. + * + * @generated from rpc flyteidl2.workflow.RunService.WatchActions + */ + watchActions: { + methodKind: "server_streaming"; + input: typeof WatchActionsRequestSchema; + output: typeof WatchActionsResponseSchema; + }, + /** + * Stream of k8s cluster events in human readable form + * + * @generated from rpc flyteidl2.workflow.RunService.WatchClusterEvents + */ + watchClusterEvents: { + methodKind: "server_streaming"; + input: typeof WatchClusterEventsRequestSchema; + output: typeof WatchClusterEventsResponseSchema; + }, + /** + * AbortAction aborts a single action that was previously created or is currently being processed by a worker. + * + * @generated from rpc flyteidl2.workflow.RunService.AbortAction + */ + abortAction: { + methodKind: "unary"; + input: typeof AbortActionRequestSchema; + output: typeof AbortActionResponseSchema; + }, + /** + * Stream updates for task groups based on the provided filter criteria. + * + * @generated from rpc flyteidl2.workflow.RunService.WatchGroups + */ + watchGroups: { + methodKind: "server_streaming"; + input: typeof WatchGroupsRequestSchema; + output: typeof WatchGroupsResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_workflow_run_service, 0); + diff --git a/gen/ts/flyteidl2/workflow/state_service_pb.ts b/gen/ts/flyteidl2/workflow/state_service_pb.ts new file mode 100644 index 0000000000..034dd97ba7 --- /dev/null +++ b/gen/ts/flyteidl2/workflow/state_service_pb.ts @@ -0,0 +1,310 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/workflow/state_service.proto (package flyteidl2.workflow, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.ts"; +import type { ActionIdentifier } from "../common/identifier_pb.ts"; +import { file_flyteidl2_common_identifier } from "../common/identifier_pb.ts"; +import type { ActionPhase } from "../common/phase_pb.ts"; +import { file_flyteidl2_common_phase } from "../common/phase_pb.ts"; +import type { ExecutionError } from "../core/execution_pb.ts"; +import { file_flyteidl2_core_execution } from "../core/execution_pb.ts"; +import type { Status } from "../../google/rpc/status_pb.ts"; +import { file_google_rpc_status } from "../../google/rpc/status_pb.ts"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/workflow/state_service.proto. + */ +export const file_flyteidl2_workflow_state_service: GenFile = /*@__PURE__*/ + fileDesc("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", [file_buf_validate_validate, file_flyteidl2_common_identifier, file_flyteidl2_common_phase, file_flyteidl2_core_execution, file_google_rpc_status]); + +/** + * request message to put the state of an action. + * + * @generated from message flyteidl2.workflow.PutRequest + */ +export type PutRequest = Message<"flyteidl2.workflow.PutRequest"> & { + /** + * a unique identifier for the action. + * + * @generated from field: flyteidl2.common.ActionIdentifier action_id = 1; + */ + actionId?: ActionIdentifier; + + /** + * optional name of the parent action if this is a nested action. + * + * @generated from field: optional string parent_action_name = 2; + */ + parentActionName?: string; + + /** + * currently we will store state as a json serialized `NodeStatus` object. this will be required + * to seamlessly integrate with existing FlytePropeller node execution logic. we can update this + * to be a subset of fields in the future if there are necessary performance improvements. + * + * @generated from field: string state = 3; + */ + state: string; +}; + +/** + * Describes the message flyteidl2.workflow.PutRequest. + * Use `create(PutRequestSchema)` to create a new message. + */ +export const PutRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_state_service, 0); + +/** + * response message for putting the state of an action. + * + * @generated from message flyteidl2.workflow.PutResponse + */ +export type PutResponse = Message<"flyteidl2.workflow.PutResponse"> & { + /** + * a unique identifier for the action. + * + * @generated from field: flyteidl2.common.ActionIdentifier action_id = 1; + */ + actionId?: ActionIdentifier; + + /** + * The result. + * + * @generated from field: google.rpc.Status status = 2; + */ + status?: Status; +}; + +/** + * Describes the message flyteidl2.workflow.PutResponse. + * Use `create(PutResponseSchema)` to create a new message. + */ +export const PutResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_state_service, 1); + +/** + * request message to get the state of an action. + * + * @generated from message flyteidl2.workflow.GetRequest + */ +export type GetRequest = Message<"flyteidl2.workflow.GetRequest"> & { + /** + * a unique identifier for the action. + * + * @generated from field: flyteidl2.common.ActionIdentifier action_id = 1; + */ + actionId?: ActionIdentifier; +}; + +/** + * Describes the message flyteidl2.workflow.GetRequest. + * Use `create(GetRequestSchema)` to create a new message. + */ +export const GetRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_state_service, 2); + +/** + * response message for getting the state of an action. + * + * @generated from message flyteidl2.workflow.GetResponse + */ +export type GetResponse = Message<"flyteidl2.workflow.GetResponse"> & { + /** + * a unique identifier for the action. + * + * @generated from field: flyteidl2.common.ActionIdentifier action_id = 1; + */ + actionId?: ActionIdentifier; + + /** + * + * The result. + * + * @generated from field: google.rpc.Status status = 2; + */ + status?: Status; + + /** + * a json serialized `NodeStatus` object. + * + * @generated from field: string state = 3; + */ + state: string; +}; + +/** + * Describes the message flyteidl2.workflow.GetResponse. + * Use `create(GetResponseSchema)` to create a new message. + */ +export const GetResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_state_service, 3); + +/** + * request message for watching updates to the state of actions. + * + * @generated from message flyteidl2.workflow.WatchRequest + */ +export type WatchRequest = Message<"flyteidl2.workflow.WatchRequest"> & { + /** + * criteria for filtering which actions to watch. + * + * @generated from oneof flyteidl2.workflow.WatchRequest.filter + */ + filter: { + /** + * a unique identifier for the parent action to watch. this will result in updates for all child + * actions. + * + * @generated from field: flyteidl2.common.ActionIdentifier parent_action_id = 1; + */ + value: ActionIdentifier; + case: "parentActionId"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.workflow.WatchRequest. + * Use `create(WatchRequestSchema)` to create a new message. + */ +export const WatchRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_state_service, 4); + +/** + * response message for watching updates to the state of actions. + * + * @generated from message flyteidl2.workflow.WatchResponse + */ +export type WatchResponse = Message<"flyteidl2.workflow.WatchResponse"> & { + /** + * an update to the state of a specific action. + * + * @generated from oneof flyteidl2.workflow.WatchResponse.message + */ + message: { + /** + * @generated from field: flyteidl2.workflow.ActionUpdate action_update = 1; + */ + value: ActionUpdate; + case: "actionUpdate"; + } | { + /** + * @generated from field: flyteidl2.workflow.ControlMessage control_message = 2; + */ + value: ControlMessage; + case: "controlMessage"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message flyteidl2.workflow.WatchResponse. + * Use `create(WatchResponseSchema)` to create a new message. + */ +export const WatchResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_state_service, 5); + +/** + * @generated from message flyteidl2.workflow.ControlMessage + */ +export type ControlMessage = Message<"flyteidl2.workflow.ControlMessage"> & { + /** + * a sentinel value to indicate the end of a stream. this is used to disambiguate between a control message and a + * regular message. When a watch begins the service will return the existing state of all actions, then a sentinel value, + * before continuing on with ongoing updates. this sequence disambiguates the current state from new updates. + * + * @generated from field: bool sentinel = 1; + */ + sentinel: boolean; +}; + +/** + * Describes the message flyteidl2.workflow.ControlMessage. + * Use `create(ControlMessageSchema)` to create a new message. + */ +export const ControlMessageSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_state_service, 6); + +/** + * message to represent an update to the state of an action. + * + * @generated from message flyteidl2.workflow.ActionUpdate + */ +export type ActionUpdate = Message<"flyteidl2.workflow.ActionUpdate"> & { + /** + * A unique identifier for the action. `nil` is used as a sentinel value; for example, + * + * @generated from field: flyteidl2.common.ActionIdentifier action_id = 1; + */ + actionId?: ActionIdentifier; + + /** + * the current phase of the action. + * + * @generated from field: flyteidl2.common.ActionPhase phase = 2; + */ + phase: ActionPhase; + + /** + * the error associated with the action (if exists). + * + * @generated from field: optional flyteidl2.core.ExecutionError error = 3; + */ + error?: ExecutionError; + + /** + * the output uri for the action + * + * @generated from field: string output_uri = 4; + */ + outputUri: string; +}; + +/** + * Describes the message flyteidl2.workflow.ActionUpdate. + * Use `create(ActionUpdateSchema)` to create a new message. + */ +export const ActionUpdateSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_state_service, 7); + +/** + * provides an interface for managing the state of actions. + * + * @generated from service flyteidl2.workflow.StateService + */ +export const StateService: GenService<{ + /** + * put the state of an action. + * + * @generated from rpc flyteidl2.workflow.StateService.Put + */ + put: { + methodKind: "unary"; + input: typeof PutRequestSchema; + output: typeof PutResponseSchema; + }, + /** + * get the state of an action. + * + * @generated from rpc flyteidl2.workflow.StateService.Get + */ + get: { + methodKind: "unary"; + input: typeof GetRequestSchema; + output: typeof GetResponseSchema; + }, + /** + * watch for updates to the state of actions. this api guarantees at-least-once delivery semantics. + * + * @generated from rpc flyteidl2.workflow.StateService.Watch + */ + watch: { + methodKind: "server_streaming"; + input: typeof WatchRequestSchema; + output: typeof WatchResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_workflow_state_service, 0); + diff --git a/gen/ts/flyteidl2/workflow/translator_service_pb.ts b/gen/ts/flyteidl2/workflow/translator_service_pb.ts new file mode 100644 index 0000000000..47b51f8c60 --- /dev/null +++ b/gen/ts/flyteidl2/workflow/translator_service_pb.ts @@ -0,0 +1,227 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file flyteidl2/workflow/translator_service.proto (package flyteidl2.workflow, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import type { VariableMap } from "../core/interface_pb.ts"; +import { file_flyteidl2_core_interface } from "../core/interface_pb.ts"; +import type { NamedLiteral } from "../task/common_pb.ts"; +import { file_flyteidl2_task_common } from "../task/common_pb.ts"; +import type { TaskSpec } from "../task/task_definition_pb.ts"; +import { file_flyteidl2_task_task_definition } from "../task/task_definition_pb.ts"; +import { file_google_protobuf_struct } from "@bufbuild/protobuf/wkt"; +import type { JsonObject, Message } from "@bufbuild/protobuf"; + +/** + * Describes the file flyteidl2/workflow/translator_service.proto. + */ +export const file_flyteidl2_workflow_translator_service: GenFile = /*@__PURE__*/ + fileDesc("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", [file_flyteidl2_core_interface, file_flyteidl2_task_common, file_flyteidl2_task_task_definition, file_google_protobuf_struct]); + +/** + * @generated from message flyteidl2.workflow.LiteralsToLaunchFormJsonRequest + */ +export type LiteralsToLaunchFormJsonRequest = Message<"flyteidl2.workflow.LiteralsToLaunchFormJsonRequest"> & { + /** + * The literals to convert to JSON. + * + * @generated from field: repeated flyteidl2.task.NamedLiteral literals = 1; + */ + literals: NamedLiteral[]; + + /** + * @generated from field: flyteidl2.core.VariableMap variables = 2; + */ + variables?: VariableMap; +}; + +/** + * Describes the message flyteidl2.workflow.LiteralsToLaunchFormJsonRequest. + * Use `create(LiteralsToLaunchFormJsonRequestSchema)` to create a new message. + */ +export const LiteralsToLaunchFormJsonRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_translator_service, 0); + +/** + * @generated from message flyteidl2.workflow.LiteralsToLaunchFormJsonResponse + */ +export type LiteralsToLaunchFormJsonResponse = Message<"flyteidl2.workflow.LiteralsToLaunchFormJsonResponse"> & { + /** + * The JSON for the literals. + * + * @generated from field: google.protobuf.Struct json = 1; + */ + json?: JsonObject; +}; + +/** + * Describes the message flyteidl2.workflow.LiteralsToLaunchFormJsonResponse. + * Use `create(LiteralsToLaunchFormJsonResponseSchema)` to create a new message. + */ +export const LiteralsToLaunchFormJsonResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_translator_service, 1); + +/** + * @generated from message flyteidl2.workflow.LaunchFormJsonToLiteralsRequest + */ +export type LaunchFormJsonToLiteralsRequest = Message<"flyteidl2.workflow.LaunchFormJsonToLiteralsRequest"> & { + /** + * The JSON schema to convert to literals. + * + * @generated from field: google.protobuf.Struct json = 1; + */ + json?: JsonObject; +}; + +/** + * Describes the message flyteidl2.workflow.LaunchFormJsonToLiteralsRequest. + * Use `create(LaunchFormJsonToLiteralsRequestSchema)` to create a new message. + */ +export const LaunchFormJsonToLiteralsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_translator_service, 2); + +/** + * @generated from message flyteidl2.workflow.LaunchFormJsonToLiteralsResponse + */ +export type LaunchFormJsonToLiteralsResponse = Message<"flyteidl2.workflow.LaunchFormJsonToLiteralsResponse"> & { + /** + * The literals generated from the JSON schema. + * + * @generated from field: repeated flyteidl2.task.NamedLiteral literals = 1; + */ + literals: NamedLiteral[]; +}; + +/** + * Describes the message flyteidl2.workflow.LaunchFormJsonToLiteralsResponse. + * Use `create(LaunchFormJsonToLiteralsResponseSchema)` to create a new message. + */ +export const LaunchFormJsonToLiteralsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_translator_service, 3); + +/** + * @generated from message flyteidl2.workflow.TaskSpecToLaunchFormJsonRequest + */ +export type TaskSpecToLaunchFormJsonRequest = Message<"flyteidl2.workflow.TaskSpecToLaunchFormJsonRequest"> & { + /** + * The task spec to convert to JSON. + * Merges the VariableMap and the default inputs + * + * @generated from field: flyteidl2.task.TaskSpec task_spec = 1; + */ + taskSpec?: TaskSpec; +}; + +/** + * Describes the message flyteidl2.workflow.TaskSpecToLaunchFormJsonRequest. + * Use `create(TaskSpecToLaunchFormJsonRequestSchema)` to create a new message. + */ +export const TaskSpecToLaunchFormJsonRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_translator_service, 4); + +/** + * @generated from message flyteidl2.workflow.TaskSpecToLaunchFormJsonResponse + */ +export type TaskSpecToLaunchFormJsonResponse = Message<"flyteidl2.workflow.TaskSpecToLaunchFormJsonResponse"> & { + /** + * The JSON for the variables. + * + * @generated from field: google.protobuf.Struct json = 1; + */ + json?: JsonObject; +}; + +/** + * Describes the message flyteidl2.workflow.TaskSpecToLaunchFormJsonResponse. + * Use `create(TaskSpecToLaunchFormJsonResponseSchema)` to create a new message. + */ +export const TaskSpecToLaunchFormJsonResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_translator_service, 5); + +/** + * @generated from message flyteidl2.workflow.JsonValuesToLiteralsRequest + */ +export type JsonValuesToLiteralsRequest = Message<"flyteidl2.workflow.JsonValuesToLiteralsRequest"> & { + /** + * The type definitions (VariableMap) describing the expected structure. + * + * @generated from field: flyteidl2.core.VariableMap variables = 1; + */ + variables?: VariableMap; + + /** + * The raw JSON values to convert to literals. + * + * @generated from field: google.protobuf.Struct values = 2; + */ + values?: JsonObject; +}; + +/** + * Describes the message flyteidl2.workflow.JsonValuesToLiteralsRequest. + * Use `create(JsonValuesToLiteralsRequestSchema)` to create a new message. + */ +export const JsonValuesToLiteralsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_translator_service, 6); + +/** + * @generated from message flyteidl2.workflow.JsonValuesToLiteralsResponse + */ +export type JsonValuesToLiteralsResponse = Message<"flyteidl2.workflow.JsonValuesToLiteralsResponse"> & { + /** + * The literals generated from the JSON values using the type definitions. + * + * @generated from field: repeated flyteidl2.task.NamedLiteral literals = 1; + */ + literals: NamedLiteral[]; +}; + +/** + * Describes the message flyteidl2.workflow.JsonValuesToLiteralsResponse. + * Use `create(JsonValuesToLiteralsResponseSchema)` to create a new message. + */ +export const JsonValuesToLiteralsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_flyteidl2_workflow_translator_service, 7); + +/** + * TranslatorService provides an interface for all diferent types of translations for the platform. + * + * @generated from service flyteidl2.workflow.TranslatorService + */ +export const TranslatorService: GenService<{ + /** + * @generated from rpc flyteidl2.workflow.TranslatorService.LiteralsToLaunchFormJson + */ + literalsToLaunchFormJson: { + methodKind: "unary"; + input: typeof LiteralsToLaunchFormJsonRequestSchema; + output: typeof LiteralsToLaunchFormJsonResponseSchema; + }, + /** + * @generated from rpc flyteidl2.workflow.TranslatorService.LaunchFormJsonToLiterals + */ + launchFormJsonToLiterals: { + methodKind: "unary"; + input: typeof LaunchFormJsonToLiteralsRequestSchema; + output: typeof LaunchFormJsonToLiteralsResponseSchema; + }, + /** + * @generated from rpc flyteidl2.workflow.TranslatorService.TaskSpecToLaunchFormJson + */ + taskSpecToLaunchFormJson: { + methodKind: "unary"; + input: typeof TaskSpecToLaunchFormJsonRequestSchema; + output: typeof TaskSpecToLaunchFormJsonResponseSchema; + }, + /** + * @generated from rpc flyteidl2.workflow.TranslatorService.JsonValuesToLiterals + */ + jsonValuesToLiterals: { + methodKind: "unary"; + input: typeof JsonValuesToLiteralsRequestSchema; + output: typeof JsonValuesToLiteralsResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_flyteidl2_workflow_translator_service, 0); + diff --git a/gen/ts/google/api/annotations_pb.ts b/gen/ts/google/api/annotations_pb.ts new file mode 100644 index 0000000000..6750b58ec2 --- /dev/null +++ b/gen/ts/google/api/annotations_pb.ts @@ -0,0 +1,39 @@ +// Copyright 2015 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. + +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file google/api/annotations.proto (package google.api, syntax proto3) +/* eslint-disable */ + +import type { GenExtension, GenFile } from "@bufbuild/protobuf/codegenv1"; +import { extDesc, fileDesc } from "@bufbuild/protobuf/codegenv1"; +import type { HttpRule } from "./http_pb.ts"; +import { file_google_api_http } from "./http_pb.ts"; +import type { MethodOptions } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_descriptor } from "@bufbuild/protobuf/wkt"; + +/** + * Describes the file google/api/annotations.proto. + */ +export const file_google_api_annotations: GenFile = /*@__PURE__*/ + fileDesc("Chxnb29nbGUvYXBpL2Fubm90YXRpb25zLnByb3RvEgpnb29nbGUuYXBpOksKBGh0dHASHi5nb29nbGUucHJvdG9idWYuTWV0aG9kT3B0aW9ucxiwyrwiIAEoCzIULmdvb2dsZS5hcGkuSHR0cFJ1bGVSBGh0dHBCsAEKDmNvbS5nb29nbGUuYXBpQhBBbm5vdGF0aW9uc1Byb3RvSAJQAVpBZ29vZ2xlLmdvbGFuZy5vcmcvZ2VucHJvdG8vZ29vZ2xlYXBpcy9hcGkvYW5ub3RhdGlvbnM7YW5ub3RhdGlvbnOiAgNHQViqAgpHb29nbGUuQXBpygIKR29vZ2xlXEFwaeICFkdvb2dsZVxBcGlcR1BCTWV0YWRhdGHqAgtHb29nbGU6OkFwaWIGcHJvdG8z", [file_google_api_http, file_google_protobuf_descriptor]); + +/** + * See `HttpRule`. + * + * @generated from extension: google.api.HttpRule http = 72295728; + */ +export const http: GenExtension = /*@__PURE__*/ + extDesc(file_google_api_annotations, 0); + diff --git a/gen/ts/google/api/http_pb.ts b/gen/ts/google/api/http_pb.ts new file mode 100644 index 0000000000..464b173f1f --- /dev/null +++ b/gen/ts/google/api/http_pb.ts @@ -0,0 +1,478 @@ +// Copyright 2015 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. + +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file google/api/http.proto (package google.api, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file google/api/http.proto. + */ +export const file_google_api_http: GenFile = /*@__PURE__*/ + fileDesc("ChVnb29nbGUvYXBpL2h0dHAucHJvdG8SCmdvb2dsZS5hcGkiVAoESHR0cBIjCgVydWxlcxgBIAMoCzIULmdvb2dsZS5hcGkuSHR0cFJ1bGUSJwofZnVsbHlfZGVjb2RlX3Jlc2VydmVkX2V4cGFuc2lvbhgCIAEoCCKBAgoISHR0cFJ1bGUSEAoIc2VsZWN0b3IYASABKAkSDQoDZ2V0GAIgASgJSAASDQoDcHV0GAMgASgJSAASDgoEcG9zdBgEIAEoCUgAEhAKBmRlbGV0ZRgFIAEoCUgAEg8KBXBhdGNoGAYgASgJSAASLwoGY3VzdG9tGAggASgLMh0uZ29vZ2xlLmFwaS5DdXN0b21IdHRwUGF0dGVybkgAEgwKBGJvZHkYByABKAkSFQoNcmVzcG9uc2VfYm9keRgMIAEoCRIxChNhZGRpdGlvbmFsX2JpbmRpbmdzGAsgAygLMhQuZ29vZ2xlLmFwaS5IdHRwUnVsZUIJCgdwYXR0ZXJuIi8KEUN1c3RvbUh0dHBQYXR0ZXJuEgwKBGtpbmQYASABKAkSDAoEcGF0aBgCIAEoCUKsAQoOY29tLmdvb2dsZS5hcGlCCUh0dHBQcm90b0gCUAFaQWdvb2dsZS5nb2xhbmcub3JnL2dlbnByb3RvL2dvb2dsZWFwaXMvYXBpL2Fubm90YXRpb25zO2Fubm90YXRpb25z+AEBogIDR0FYqgIKR29vZ2xlLkFwacoCCkdvb2dsZVxBcGniAhZHb29nbGVcQXBpXEdQQk1ldGFkYXRh6gILR29vZ2xlOjpBcGliBnByb3RvMw"); + +/** + * Defines the HTTP configuration for an API service. It contains a list of + * [HttpRule][google.api.HttpRule], each specifying the mapping of an RPC method + * to one or more HTTP REST API methods. + * + * @generated from message google.api.Http + */ +export type Http = Message<"google.api.Http"> & { + /** + * A list of HTTP configuration rules that apply to individual API methods. + * + * **NOTE:** All service configuration rules follow "last one wins" order. + * + * @generated from field: repeated google.api.HttpRule rules = 1; + */ + rules: HttpRule[]; + + /** + * When set to true, URL path parameters will be fully URI-decoded except in + * cases of single segment matches in reserved expansion, where "%2F" will be + * left encoded. + * + * The default behavior is to not decode RFC 6570 reserved characters in multi + * segment matches. + * + * @generated from field: bool fully_decode_reserved_expansion = 2; + */ + fullyDecodeReservedExpansion: boolean; +}; + +/** + * Describes the message google.api.Http. + * Use `create(HttpSchema)` to create a new message. + */ +export const HttpSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_google_api_http, 0); + +/** + * # gRPC Transcoding + * + * gRPC Transcoding is a feature for mapping between a gRPC method and one or + * more HTTP REST endpoints. It allows developers to build a single API service + * that supports both gRPC APIs and REST APIs. Many systems, including [Google + * APIs](https://github.com/googleapis/googleapis), + * [Cloud Endpoints](https://cloud.google.com/endpoints), [gRPC + * Gateway](https://github.com/grpc-ecosystem/grpc-gateway), + * and [Envoy](https://github.com/envoyproxy/envoy) proxy support this feature + * and use it for large scale production services. + * + * `HttpRule` defines the schema of the gRPC/REST mapping. The mapping specifies + * how different portions of the gRPC request message are mapped to the URL + * path, URL query parameters, and HTTP request body. It also controls how the + * gRPC response message is mapped to the HTTP response body. `HttpRule` is + * typically specified as an `google.api.http` annotation on the gRPC method. + * + * Each mapping specifies a URL path template and an HTTP method. The path + * template may refer to one or more fields in the gRPC request message, as long + * as each field is a non-repeated field with a primitive (non-message) type. + * The path template controls how fields of the request message are mapped to + * the URL path. + * + * Example: + * + * service Messaging { + * rpc GetMessage(GetMessageRequest) returns (Message) { + * option (google.api.http) = { + * get: "/v1/{name=messages/*}" + * }; + * } + * } + * message GetMessageRequest { + * string name = 1; // Mapped to URL path. + * } + * message Message { + * string text = 1; // The resource content. + * } + * + * This enables an HTTP REST to gRPC mapping as below: + * + * HTTP | gRPC + * -----|----- + * `GET /v1/messages/123456` | `GetMessage(name: "messages/123456")` + * + * Any fields in the request message which are not bound by the path template + * automatically become HTTP query parameters if there is no HTTP request body. + * For example: + * + * service Messaging { + * rpc GetMessage(GetMessageRequest) returns (Message) { + * option (google.api.http) = { + * get:"/v1/messages/{message_id}" + * }; + * } + * } + * message GetMessageRequest { + * message SubMessage { + * string subfield = 1; + * } + * string message_id = 1; // Mapped to URL path. + * int64 revision = 2; // Mapped to URL query parameter `revision`. + * SubMessage sub = 3; // Mapped to URL query parameter `sub.subfield`. + * } + * + * This enables a HTTP JSON to RPC mapping as below: + * + * HTTP | gRPC + * -----|----- + * `GET /v1/messages/123456?revision=2&sub.subfield=foo` | + * `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield: + * "foo"))` + * + * Note that fields which are mapped to URL query parameters must have a + * primitive type or a repeated primitive type or a non-repeated message type. + * In the case of a repeated type, the parameter can be repeated in the URL + * as `...?param=A¶m=B`. In the case of a message type, each field of the + * message is mapped to a separate parameter, such as + * `...?foo.a=A&foo.b=B&foo.c=C`. + * + * For HTTP methods that allow a request body, the `body` field + * specifies the mapping. Consider a REST update method on the + * message resource collection: + * + * service Messaging { + * rpc UpdateMessage(UpdateMessageRequest) returns (Message) { + * option (google.api.http) = { + * patch: "/v1/messages/{message_id}" + * body: "message" + * }; + * } + * } + * message UpdateMessageRequest { + * string message_id = 1; // mapped to the URL + * Message message = 2; // mapped to the body + * } + * + * The following HTTP JSON to RPC mapping is enabled, where the + * representation of the JSON in the request body is determined by + * protos JSON encoding: + * + * HTTP | gRPC + * -----|----- + * `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: + * "123456" message { text: "Hi!" })` + * + * The special name `*` can be used in the body mapping to define that + * every field not bound by the path template should be mapped to the + * request body. This enables the following alternative definition of + * the update method: + * + * service Messaging { + * rpc UpdateMessage(Message) returns (Message) { + * option (google.api.http) = { + * patch: "/v1/messages/{message_id}" + * body: "*" + * }; + * } + * } + * message Message { + * string message_id = 1; + * string text = 2; + * } + * + * + * The following HTTP JSON to RPC mapping is enabled: + * + * HTTP | gRPC + * -----|----- + * `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: + * "123456" text: "Hi!")` + * + * Note that when using `*` in the body mapping, it is not possible to + * have HTTP parameters, as all fields not bound by the path end in + * the body. This makes this option more rarely used in practice when + * defining REST APIs. The common usage of `*` is in custom methods + * which don't use the URL at all for transferring data. + * + * It is possible to define multiple HTTP methods for one RPC by using + * the `additional_bindings` option. Example: + * + * service Messaging { + * rpc GetMessage(GetMessageRequest) returns (Message) { + * option (google.api.http) = { + * get: "/v1/messages/{message_id}" + * additional_bindings { + * get: "/v1/users/{user_id}/messages/{message_id}" + * } + * }; + * } + * } + * message GetMessageRequest { + * string message_id = 1; + * string user_id = 2; + * } + * + * This enables the following two alternative HTTP JSON to RPC mappings: + * + * HTTP | gRPC + * -----|----- + * `GET /v1/messages/123456` | `GetMessage(message_id: "123456")` + * `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id: + * "123456")` + * + * ## Rules for HTTP mapping + * + * 1. Leaf request fields (recursive expansion nested messages in the request + * message) are classified into three categories: + * - Fields referred by the path template. They are passed via the URL path. + * - Fields referred by the [HttpRule.body][google.api.HttpRule.body]. They are passed via the HTTP + * request body. + * - All other fields are passed via the URL query parameters, and the + * parameter name is the field path in the request message. A repeated + * field can be represented as multiple query parameters under the same + * name. + * 2. If [HttpRule.body][google.api.HttpRule.body] is "*", there is no URL query parameter, all fields + * are passed via URL path and HTTP request body. + * 3. If [HttpRule.body][google.api.HttpRule.body] is omitted, there is no HTTP request body, all + * fields are passed via URL path and URL query parameters. + * + * ### Path template syntax + * + * Template = "/" Segments [ Verb ] ; + * Segments = Segment { "/" Segment } ; + * Segment = "*" | "**" | LITERAL | Variable ; + * Variable = "{" FieldPath [ "=" Segments ] "}" ; + * FieldPath = IDENT { "." IDENT } ; + * Verb = ":" LITERAL ; + * + * The syntax `*` matches a single URL path segment. The syntax `**` matches + * zero or more URL path segments, which must be the last part of the URL path + * except the `Verb`. + * + * The syntax `Variable` matches part of the URL path as specified by its + * template. A variable template must not contain other variables. If a variable + * matches a single path segment, its template may be omitted, e.g. `{var}` + * is equivalent to `{var=*}`. + * + * The syntax `LITERAL` matches literal text in the URL path. If the `LITERAL` + * contains any reserved character, such characters should be percent-encoded + * before the matching. + * + * If a variable contains exactly one path segment, such as `"{var}"` or + * `"{var=*}"`, when such a variable is expanded into a URL path on the client + * side, all characters except `[-_.~0-9a-zA-Z]` are percent-encoded. The + * server side does the reverse decoding. Such variables show up in the + * [Discovery + * Document](https://developers.google.com/discovery/v1/reference/apis) as + * `{var}`. + * + * If a variable contains multiple path segments, such as `"{var=foo/*}"` + * or `"{var=**}"`, when such a variable is expanded into a URL path on the + * client side, all characters except `[-_.~/0-9a-zA-Z]` are percent-encoded. + * The server side does the reverse decoding, except "%2F" and "%2f" are left + * unchanged. Such variables show up in the + * [Discovery + * Document](https://developers.google.com/discovery/v1/reference/apis) as + * `{+var}`. + * + * ## Using gRPC API Service Configuration + * + * gRPC API Service Configuration (service config) is a configuration language + * for configuring a gRPC service to become a user-facing product. The + * service config is simply the YAML representation of the `google.api.Service` + * proto message. + * + * As an alternative to annotating your proto file, you can configure gRPC + * transcoding in your service config YAML files. You do this by specifying a + * `HttpRule` that maps the gRPC method to a REST endpoint, achieving the same + * effect as the proto annotation. This can be particularly useful if you + * have a proto that is reused in multiple services. Note that any transcoding + * specified in the service config will override any matching transcoding + * configuration in the proto. + * + * Example: + * + * http: + * rules: + * # Selects a gRPC method and applies HttpRule to it. + * - selector: example.v1.Messaging.GetMessage + * get: /v1/messages/{message_id}/{sub.subfield} + * + * ## Special notes + * + * When gRPC Transcoding is used to map a gRPC to JSON REST endpoints, the + * proto to JSON conversion must follow the [proto3 + * specification](https://developers.google.com/protocol-buffers/docs/proto3#json). + * + * While the single segment variable follows the semantics of + * [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 Simple String + * Expansion, the multi segment variable **does not** follow RFC 6570 Section + * 3.2.3 Reserved Expansion. The reason is that the Reserved Expansion + * does not expand special characters like `?` and `#`, which would lead + * to invalid URLs. As the result, gRPC Transcoding uses a custom encoding + * for multi segment variables. + * + * The path variables **must not** refer to any repeated or mapped field, + * because client libraries are not capable of handling such variable expansion. + * + * The path variables **must not** capture the leading "/" character. The reason + * is that the most common use case "{var}" does not capture the leading "/" + * character. For consistency, all path variables must share the same behavior. + * + * Repeated message fields must not be mapped to URL query parameters, because + * no client library can support such complicated mapping. + * + * If an API needs to use a JSON array for request or response body, it can map + * the request or response body to a repeated field. However, some gRPC + * Transcoding implementations may not support this feature. + * + * @generated from message google.api.HttpRule + */ +export type HttpRule = Message<"google.api.HttpRule"> & { + /** + * Selects a method to which this rule applies. + * + * Refer to [selector][google.api.DocumentationRule.selector] for syntax details. + * + * @generated from field: string selector = 1; + */ + selector: string; + + /** + * Determines the URL pattern is matched by this rules. This pattern can be + * used with any of the {get|put|post|delete|patch} methods. A custom method + * can be defined using the 'custom' field. + * + * @generated from oneof google.api.HttpRule.pattern + */ + pattern: { + /** + * Maps to HTTP GET. Used for listing and getting information about + * resources. + * + * @generated from field: string get = 2; + */ + value: string; + case: "get"; + } | { + /** + * Maps to HTTP PUT. Used for replacing a resource. + * + * @generated from field: string put = 3; + */ + value: string; + case: "put"; + } | { + /** + * Maps to HTTP POST. Used for creating a resource or performing an action. + * + * @generated from field: string post = 4; + */ + value: string; + case: "post"; + } | { + /** + * Maps to HTTP DELETE. Used for deleting a resource. + * + * @generated from field: string delete = 5; + */ + value: string; + case: "delete"; + } | { + /** + * Maps to HTTP PATCH. Used for updating a resource. + * + * @generated from field: string patch = 6; + */ + value: string; + case: "patch"; + } | { + /** + * The custom pattern is used for specifying an HTTP method that is not + * included in the `pattern` field, such as HEAD, or "*" to leave the + * HTTP method unspecified for this rule. The wild-card rule is useful + * for services that provide content to Web (HTML) clients. + * + * @generated from field: google.api.CustomHttpPattern custom = 8; + */ + value: CustomHttpPattern; + case: "custom"; + } | { case: undefined; value?: undefined }; + + /** + * The name of the request field whose value is mapped to the HTTP request + * body, or `*` for mapping all request fields not captured by the path + * pattern to the HTTP body, or omitted for not having any HTTP request body. + * + * NOTE: the referred field must be present at the top-level of the request + * message type. + * + * @generated from field: string body = 7; + */ + body: string; + + /** + * Optional. The name of the response field whose value is mapped to the HTTP + * response body. When omitted, the entire response message will be used + * as the HTTP response body. + * + * NOTE: The referred field must be present at the top-level of the response + * message type. + * + * @generated from field: string response_body = 12; + */ + responseBody: string; + + /** + * Additional HTTP bindings for the selector. Nested bindings must + * not contain an `additional_bindings` field themselves (that is, + * the nesting may only be one level deep). + * + * @generated from field: repeated google.api.HttpRule additional_bindings = 11; + */ + additionalBindings: HttpRule[]; +}; + +/** + * Describes the message google.api.HttpRule. + * Use `create(HttpRuleSchema)` to create a new message. + */ +export const HttpRuleSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_google_api_http, 1); + +/** + * A custom pattern is used for defining custom HTTP verb. + * + * @generated from message google.api.CustomHttpPattern + */ +export type CustomHttpPattern = Message<"google.api.CustomHttpPattern"> & { + /** + * The name of this custom HTTP verb. + * + * @generated from field: string kind = 1; + */ + kind: string; + + /** + * The path matched by this custom verb. + * + * @generated from field: string path = 2; + */ + path: string; +}; + +/** + * Describes the message google.api.CustomHttpPattern. + * Use `create(CustomHttpPatternSchema)` to create a new message. + */ +export const CustomHttpPatternSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_google_api_http, 2); + diff --git a/gen/ts/google/rpc/status_pb.ts b/gen/ts/google/rpc/status_pb.ts new file mode 100644 index 0000000000..b3297fcefe --- /dev/null +++ b/gen/ts/google/rpc/status_pb.ts @@ -0,0 +1,74 @@ +// 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. + +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file google/rpc/status.proto (package google.rpc, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Any } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_any } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file google/rpc/status.proto. + */ +export const file_google_rpc_status: GenFile = /*@__PURE__*/ + fileDesc("Chdnb29nbGUvcnBjL3N0YXR1cy5wcm90bxIKZ29vZ2xlLnJwYyJOCgZTdGF0dXMSDAoEY29kZRgBIAEoBRIPCgdtZXNzYWdlGAIgASgJEiUKB2RldGFpbHMYAyADKAsyFC5nb29nbGUucHJvdG9idWYuQW55QqQBCg5jb20uZ29vZ2xlLnJwY0ILU3RhdHVzUHJvdG9IAlABWjdnb29nbGUuZ29sYW5nLm9yZy9nZW5wcm90by9nb29nbGVhcGlzL3JwYy9zdGF0dXM7c3RhdHVz+AEBogIDR1JYqgIKR29vZ2xlLlJwY8oCCkdvb2dsZVxScGPiAhZHb29nbGVcUnBjXEdQQk1ldGFkYXRh6gILR29vZ2xlOjpScGNiBnByb3RvMw", [file_google_protobuf_any]); + +/** + * The `Status` type defines a logical error model that is suitable for + * different programming environments, including REST APIs and RPC APIs. It is + * used by [gRPC](https://github.com/grpc). Each `Status` message contains + * three pieces of data: error code, error message, and error details. + * + * You can find out more about this error model and how to work with it in the + * [API Design Guide](https://cloud.google.com/apis/design/errors). + * + * @generated from message google.rpc.Status + */ +export type Status = Message<"google.rpc.Status"> & { + /** + * The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]. + * + * @generated from field: int32 code = 1; + */ + code: number; + + /** + * A developer-facing error message, which should be in English. Any + * user-facing error message should be localized and sent in the + * [google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client. + * + * @generated from field: string message = 2; + */ + message: string; + + /** + * A list of messages that carry the error details. There is a common set of + * message types for APIs to use. + * + * @generated from field: repeated google.protobuf.Any details = 3; + */ + details: Any[]; +}; + +/** + * Describes the message google.rpc.Status. + * Use `create(StatusSchema)` to create a new message. + */ +export const StatusSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_google_rpc_status, 0); + diff --git a/gen/ts/package-lock.json b/gen/ts/package-lock.json new file mode 100644 index 0000000000..92093066c2 --- /dev/null +++ b/gen/ts/package-lock.json @@ -0,0 +1,39 @@ +{ + "name": "@flyteorg/flyteidl2", + "version": "0.0.0-develop", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "@flyteorg/flyteidl2", + "version": "0.0.0-develop", + "license": "Apache-2.0", + "dependencies": { + "@bufbuild/protobuf": "^2.10.0" + }, + "devDependencies": { + "typescript": "^5.6.0" + } + }, + "node_modules/@bufbuild/protobuf": { + "version": "2.11.0", + "resolved": "https://registry.npmjs.org/@bufbuild/protobuf/-/protobuf-2.11.0.tgz", + "integrity": "sha512-sBXGT13cpmPR5BMgHE6UEEfEaShh5Ror6rfN3yEK5si7QVrtZg8LEPQb0VVhiLRUslD2yLnXtnRzG035J/mZXQ==", + "license": "(Apache-2.0 AND BSD-3-Clause)" + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + } + } +} diff --git a/gen/ts/package.json b/gen/ts/package.json new file mode 100644 index 0000000000..2c6e180d91 --- /dev/null +++ b/gen/ts/package.json @@ -0,0 +1,26 @@ +{ + "name": "@flyteorg/flyteidl2", + "version": "0.0.0-develop", + "description": "Compiled protocol buffers and gRPC service and connect clients/servers for Flyte IDLs", + "repository": { + "type": "git", + "url": "git@github.com:flyteorg/flyte" + }, + "author": "Union Eng ", + "license": "Apache-2.0", + "keywords": [ + "flyte", + "flyte2" + ], + "files": [ + "flyteidl2", + "buf", + "google" + ], + "dependencies": { + "@bufbuild/protobuf": "^2.10.0" + }, + "devDependencies": { + "typescript": "^5.6.0" + } +} diff --git a/gen/ts/protoc-gen-openapiv2/options/annotations_pb.ts b/gen/ts/protoc-gen-openapiv2/options/annotations_pb.ts new file mode 100644 index 0000000000..f60f3fb2ff --- /dev/null +++ b/gen/ts/protoc-gen-openapiv2/options/annotations_pb.ts @@ -0,0 +1,83 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file protoc-gen-openapiv2/options/annotations.proto (package grpc.gateway.protoc_gen_openapiv2.options, syntax proto3) +/* eslint-disable */ + +import type { GenExtension, GenFile } from "@bufbuild/protobuf/codegenv1"; +import { extDesc, fileDesc } from "@bufbuild/protobuf/codegenv1"; +import type { EnumOptions, FieldOptions, FileOptions, MessageOptions, MethodOptions, ServiceOptions } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_descriptor } from "@bufbuild/protobuf/wkt"; +import type { EnumSchema, JSONSchema, Operation, Schema, Swagger, Tag } from "./openapiv2_pb.ts"; +import { file_protoc_gen_openapiv2_options_openapiv2 } from "./openapiv2_pb.ts"; + +/** + * Describes the file protoc-gen-openapiv2/options/annotations.proto. + */ +export const file_protoc_gen_openapiv2_options_annotations: GenFile = /*@__PURE__*/ + fileDesc("Ci5wcm90b2MtZ2VuLW9wZW5hcGl2Mi9vcHRpb25zL2Fubm90YXRpb25zLnByb3RvEilncnBjLmdhdGV3YXkucHJvdG9jX2dlbl9vcGVuYXBpdjIub3B0aW9uczp+ChFvcGVuYXBpdjJfc3dhZ2dlchIcLmdvb2dsZS5wcm90b2J1Zi5GaWxlT3B0aW9ucxiSCCABKAsyMi5ncnBjLmdhdGV3YXkucHJvdG9jX2dlbl9vcGVuYXBpdjIub3B0aW9ucy5Td2FnZ2VyUhBvcGVuYXBpdjJTd2FnZ2VyOoYBChNvcGVuYXBpdjJfb3BlcmF0aW9uEh4uZ29vZ2xlLnByb3RvYnVmLk1ldGhvZE9wdGlvbnMYkgggASgLMjQuZ3JwYy5nYXRld2F5LnByb3RvY19nZW5fb3BlbmFwaXYyLm9wdGlvbnMuT3BlcmF0aW9uUhJvcGVuYXBpdjJPcGVyYXRpb246fgoQb3BlbmFwaXYyX3NjaGVtYRIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxiSCCABKAsyMS5ncnBjLmdhdGV3YXkucHJvdG9jX2dlbl9vcGVuYXBpdjIub3B0aW9ucy5TY2hlbWFSD29wZW5hcGl2MlNjaGVtYTp7Cg5vcGVuYXBpdjJfZW51bRIcLmdvb2dsZS5wcm90b2J1Zi5FbnVtT3B0aW9ucxiSCCABKAsyNS5ncnBjLmdhdGV3YXkucHJvdG9jX2dlbl9vcGVuYXBpdjIub3B0aW9ucy5FbnVtU2NoZW1hUg1vcGVuYXBpdjJFbnVtOnUKDW9wZW5hcGl2Ml90YWcSHy5nb29nbGUucHJvdG9idWYuU2VydmljZU9wdGlvbnMYkgggASgLMi4uZ3JwYy5nYXRld2F5LnByb3RvY19nZW5fb3BlbmFwaXYyLm9wdGlvbnMuVGFnUgxvcGVuYXBpdjJUYWc6fgoPb3BlbmFwaXYyX2ZpZWxkEh0uZ29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0aW9ucxiSCCABKAsyNS5ncnBjLmdhdGV3YXkucHJvdG9jX2dlbl9vcGVuYXBpdjIub3B0aW9ucy5KU09OU2NoZW1hUg5vcGVuYXBpdjJGaWVsZELLAgotY29tLmdycGMuZ2F0ZXdheS5wcm90b2NfZ2VuX29wZW5hcGl2Mi5vcHRpb25zQhBBbm5vdGF0aW9uc1Byb3RvSAJQAVpGZ2l0aHViLmNvbS9ncnBjLWVjb3N5c3RlbS9ncnBjLWdhdGV3YXkvdjIvcHJvdG9jLWdlbi1vcGVuYXBpdjIvb3B0aW9uc6ICBEdHUE+qAidHcnBjLkdhdGV3YXkuUHJvdG9jR2VuT3BlbmFwaXYyLk9wdGlvbnPKAidHcnBjXEdhdGV3YXlcUHJvdG9jR2VuT3BlbmFwaXYyXE9wdGlvbnPiAjNHcnBjXEdhdGV3YXlcUHJvdG9jR2VuT3BlbmFwaXYyXE9wdGlvbnNcR1BCTWV0YWRhdGHqAipHcnBjOjpHYXRld2F5OjpQcm90b2NHZW5PcGVuYXBpdjI6Ok9wdGlvbnNiBnByb3RvMw", [file_google_protobuf_descriptor, file_protoc_gen_openapiv2_options_openapiv2]); + +/** + * ID assigned by protobuf-global-extension-registry@google.com for gRPC-Gateway project. + * + * All IDs are the same, as assigned. It is okay that they are the same, as they extend + * different descriptor messages. + * + * @generated from extension: grpc.gateway.protoc_gen_openapiv2.options.Swagger openapiv2_swagger = 1042; + */ +export const openapiv2_swagger: GenExtension = /*@__PURE__*/ + extDesc(file_protoc_gen_openapiv2_options_annotations, 0); + +/** + * ID assigned by protobuf-global-extension-registry@google.com for gRPC-Gateway project. + * + * All IDs are the same, as assigned. It is okay that they are the same, as they extend + * different descriptor messages. + * + * @generated from extension: grpc.gateway.protoc_gen_openapiv2.options.Operation openapiv2_operation = 1042; + */ +export const openapiv2_operation: GenExtension = /*@__PURE__*/ + extDesc(file_protoc_gen_openapiv2_options_annotations, 1); + +/** + * ID assigned by protobuf-global-extension-registry@google.com for gRPC-Gateway project. + * + * All IDs are the same, as assigned. It is okay that they are the same, as they extend + * different descriptor messages. + * + * @generated from extension: grpc.gateway.protoc_gen_openapiv2.options.Schema openapiv2_schema = 1042; + */ +export const openapiv2_schema: GenExtension = /*@__PURE__*/ + extDesc(file_protoc_gen_openapiv2_options_annotations, 2); + +/** + * ID assigned by protobuf-global-extension-registry@google.com for gRPC-Gateway project. + * + * All IDs are the same, as assigned. It is okay that they are the same, as they extend + * different descriptor messages. + * + * @generated from extension: grpc.gateway.protoc_gen_openapiv2.options.EnumSchema openapiv2_enum = 1042; + */ +export const openapiv2_enum: GenExtension = /*@__PURE__*/ + extDesc(file_protoc_gen_openapiv2_options_annotations, 3); + +/** + * ID assigned by protobuf-global-extension-registry@google.com for gRPC-Gateway project. + * + * All IDs are the same, as assigned. It is okay that they are the same, as they extend + * different descriptor messages. + * + * @generated from extension: grpc.gateway.protoc_gen_openapiv2.options.Tag openapiv2_tag = 1042; + */ +export const openapiv2_tag: GenExtension = /*@__PURE__*/ + extDesc(file_protoc_gen_openapiv2_options_annotations, 4); + +/** + * ID assigned by protobuf-global-extension-registry@google.com for gRPC-Gateway project. + * + * All IDs are the same, as assigned. It is okay that they are the same, as they extend + * different descriptor messages. + * + * @generated from extension: grpc.gateway.protoc_gen_openapiv2.options.JSONSchema openapiv2_field = 1042; + */ +export const openapiv2_field: GenExtension = /*@__PURE__*/ + extDesc(file_protoc_gen_openapiv2_options_annotations, 5); + diff --git a/gen/ts/protoc-gen-openapiv2/options/openapiv2_pb.ts b/gen/ts/protoc-gen-openapiv2/options/openapiv2_pb.ts new file mode 100644 index 0000000000..e74f5529db --- /dev/null +++ b/gen/ts/protoc-gen-openapiv2/options/openapiv2_pb.ts @@ -0,0 +1,1623 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.ts" +// @generated from file protoc-gen-openapiv2/options/openapiv2.proto (package grpc.gateway.protoc_gen_openapiv2.options, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import type { Value } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_struct } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file protoc-gen-openapiv2/options/openapiv2.proto. + */ +export const file_protoc_gen_openapiv2_options_openapiv2: GenFile = /*@__PURE__*/ + fileDesc("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", [file_google_protobuf_struct]); + +/** + * `Swagger` is a representation of OpenAPI v2 specification's Swagger object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#swaggerObject + * + * Example: + * + * option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = { + * info: { + * title: "Echo API"; + * version: "1.0"; + * description: ""; + * contact: { + * name: "gRPC-Gateway project"; + * url: "https://github.com/grpc-ecosystem/grpc-gateway"; + * email: "none@example.com"; + * }; + * license: { + * name: "BSD 3-Clause License"; + * url: "https://github.com/grpc-ecosystem/grpc-gateway/blob/main/LICENSE"; + * }; + * }; + * schemes: HTTPS; + * consumes: "application/json"; + * produces: "application/json"; + * }; + * + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.Swagger + */ +export type Swagger = Message<"grpc.gateway.protoc_gen_openapiv2.options.Swagger"> & { + /** + * Specifies the OpenAPI Specification version being used. It can be + * used by the OpenAPI UI and other clients to interpret the API listing. The + * value MUST be "2.0". + * + * @generated from field: string swagger = 1; + */ + swagger: string; + + /** + * Provides metadata about the API. The metadata can be used by the + * clients if needed. + * + * @generated from field: grpc.gateway.protoc_gen_openapiv2.options.Info info = 2; + */ + info?: Info; + + /** + * The host (name or ip) serving the API. This MUST be the host only and does + * not include the scheme nor sub-paths. It MAY include a port. If the host is + * not included, the host serving the documentation is to be used (including + * the port). The host does not support path templating. + * + * @generated from field: string host = 3; + */ + host: string; + + /** + * The base path on which the API is served, which is relative to the host. If + * it is not included, the API is served directly under the host. The value + * MUST start with a leading slash (/). The basePath does not support path + * templating. + * Note that using `base_path` does not change the endpoint paths that are + * generated in the resulting OpenAPI file. If you wish to use `base_path` + * with relatively generated OpenAPI paths, the `base_path` prefix must be + * manually removed from your `google.api.http` paths and your code changed to + * serve the API from the `base_path`. + * + * @generated from field: string base_path = 4; + */ + basePath: string; + + /** + * The transfer protocol of the API. Values MUST be from the list: "http", + * "https", "ws", "wss". If the schemes is not included, the default scheme to + * be used is the one used to access the OpenAPI definition itself. + * + * @generated from field: repeated grpc.gateway.protoc_gen_openapiv2.options.Scheme schemes = 5; + */ + schemes: Scheme[]; + + /** + * A list of MIME types the APIs can consume. This is global to all APIs but + * can be overridden on specific API calls. Value MUST be as described under + * Mime Types. + * + * @generated from field: repeated string consumes = 6; + */ + consumes: string[]; + + /** + * A list of MIME types the APIs can produce. This is global to all APIs but + * can be overridden on specific API calls. Value MUST be as described under + * Mime Types. + * + * @generated from field: repeated string produces = 7; + */ + produces: string[]; + + /** + * An object to hold responses that can be used across operations. This + * property does not define global responses for all operations. + * + * @generated from field: map responses = 10; + */ + responses: { [key: string]: Response }; + + /** + * Security scheme definitions that can be used across the specification. + * + * @generated from field: grpc.gateway.protoc_gen_openapiv2.options.SecurityDefinitions security_definitions = 11; + */ + securityDefinitions?: SecurityDefinitions; + + /** + * A declaration of which security schemes are applied for the API as a whole. + * The list of values describes alternative security schemes that can be used + * (that is, there is a logical OR between the security requirements). + * Individual operations can override this definition. + * + * @generated from field: repeated grpc.gateway.protoc_gen_openapiv2.options.SecurityRequirement security = 12; + */ + security: SecurityRequirement[]; + + /** + * A list of tags for API documentation control. Tags can be used for logical + * grouping of operations by resources or any other qualifier. + * + * @generated from field: repeated grpc.gateway.protoc_gen_openapiv2.options.Tag tags = 13; + */ + tags: Tag[]; + + /** + * Additional external documentation. + * + * @generated from field: grpc.gateway.protoc_gen_openapiv2.options.ExternalDocumentation external_docs = 14; + */ + externalDocs?: ExternalDocumentation; + + /** + * Custom properties that start with "x-" such as "x-foo" used to describe + * extra functionality that is not covered by the standard OpenAPI Specification. + * See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + * + * @generated from field: map extensions = 15; + */ + extensions: { [key: string]: Value }; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.Swagger. + * Use `create(SwaggerSchema)` to create a new message. + */ +export const SwaggerSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 0); + +/** + * `Operation` is a representation of OpenAPI v2 specification's Operation object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#operationObject + * + * Example: + * + * service EchoService { + * rpc Echo(SimpleMessage) returns (SimpleMessage) { + * option (google.api.http) = { + * get: "/v1/example/echo/{id}" + * }; + * + * option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = { + * summary: "Get a message."; + * operation_id: "getMessage"; + * tags: "echo"; + * responses: { + * key: "200" + * value: { + * description: "OK"; + * } + * } + * }; + * } + * } + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.Operation + */ +export type Operation = Message<"grpc.gateway.protoc_gen_openapiv2.options.Operation"> & { + /** + * A list of tags for API documentation control. Tags can be used for logical + * grouping of operations by resources or any other qualifier. + * + * @generated from field: repeated string tags = 1; + */ + tags: string[]; + + /** + * A short summary of what the operation does. For maximum readability in the + * swagger-ui, this field SHOULD be less than 120 characters. + * + * @generated from field: string summary = 2; + */ + summary: string; + + /** + * A verbose explanation of the operation behavior. GFM syntax can be used for + * rich text representation. + * + * @generated from field: string description = 3; + */ + description: string; + + /** + * Additional external documentation for this operation. + * + * @generated from field: grpc.gateway.protoc_gen_openapiv2.options.ExternalDocumentation external_docs = 4; + */ + externalDocs?: ExternalDocumentation; + + /** + * Unique string used to identify the operation. The id MUST be unique among + * all operations described in the API. Tools and libraries MAY use the + * operationId to uniquely identify an operation, therefore, it is recommended + * to follow common programming naming conventions. + * + * @generated from field: string operation_id = 5; + */ + operationId: string; + + /** + * A list of MIME types the operation can consume. This overrides the consumes + * definition at the OpenAPI Object. An empty value MAY be used to clear the + * global definition. Value MUST be as described under Mime Types. + * + * @generated from field: repeated string consumes = 6; + */ + consumes: string[]; + + /** + * A list of MIME types the operation can produce. This overrides the produces + * definition at the OpenAPI Object. An empty value MAY be used to clear the + * global definition. Value MUST be as described under Mime Types. + * + * @generated from field: repeated string produces = 7; + */ + produces: string[]; + + /** + * The list of possible responses as they are returned from executing this + * operation. + * + * @generated from field: map responses = 9; + */ + responses: { [key: string]: Response }; + + /** + * The transfer protocol for the operation. Values MUST be from the list: + * "http", "https", "ws", "wss". The value overrides the OpenAPI Object + * schemes definition. + * + * @generated from field: repeated grpc.gateway.protoc_gen_openapiv2.options.Scheme schemes = 10; + */ + schemes: Scheme[]; + + /** + * Declares this operation to be deprecated. Usage of the declared operation + * should be refrained. Default value is false. + * + * @generated from field: bool deprecated = 11; + */ + deprecated: boolean; + + /** + * A declaration of which security schemes are applied for this operation. The + * list of values describes alternative security schemes that can be used + * (that is, there is a logical OR between the security requirements). This + * definition overrides any declared top-level security. To remove a top-level + * security declaration, an empty array can be used. + * + * @generated from field: repeated grpc.gateway.protoc_gen_openapiv2.options.SecurityRequirement security = 12; + */ + security: SecurityRequirement[]; + + /** + * Custom properties that start with "x-" such as "x-foo" used to describe + * extra functionality that is not covered by the standard OpenAPI Specification. + * See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + * + * @generated from field: map extensions = 13; + */ + extensions: { [key: string]: Value }; + + /** + * Custom parameters such as HTTP request headers. + * See: https://swagger.io/docs/specification/2-0/describing-parameters/ + * and https://swagger.io/specification/v2/#parameter-object. + * + * @generated from field: grpc.gateway.protoc_gen_openapiv2.options.Parameters parameters = 14; + */ + parameters?: Parameters; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.Operation. + * Use `create(OperationSchema)` to create a new message. + */ +export const OperationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 1); + +/** + * `Parameters` is a representation of OpenAPI v2 specification's parameters object. + * Note: This technically breaks compatibility with the OpenAPI 2 definition structure as we only + * allow header parameters to be set here since we do not want users specifying custom non-header + * parameters beyond those inferred from the Protobuf schema. + * See: https://swagger.io/specification/v2/#parameter-object + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.Parameters + */ +export type Parameters = Message<"grpc.gateway.protoc_gen_openapiv2.options.Parameters"> & { + /** + * `Headers` is one or more HTTP header parameter. + * See: https://swagger.io/docs/specification/2-0/describing-parameters/#header-parameters + * + * @generated from field: repeated grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter headers = 1; + */ + headers: HeaderParameter[]; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.Parameters. + * Use `create(ParametersSchema)` to create a new message. + */ +export const ParametersSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 2); + +/** + * `HeaderParameter` a HTTP header parameter. + * See: https://swagger.io/specification/v2/#parameter-object + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter + */ +export type HeaderParameter = Message<"grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter"> & { + /** + * `Name` is the header name. + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * `Description` is a short description of the header. + * + * @generated from field: string description = 2; + */ + description: string; + + /** + * `Type` is the type of the object. The value MUST be one of "string", "number", "integer", or "boolean". The "array" type is not supported. + * See: https://swagger.io/specification/v2/#parameterType. + * + * @generated from field: grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter.Type type = 3; + */ + type: HeaderParameter_Type; + + /** + * `Format` The extending format for the previously mentioned type. + * + * @generated from field: string format = 4; + */ + format: string; + + /** + * `Required` indicates if the header is optional + * + * @generated from field: bool required = 5; + */ + required: boolean; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter. + * Use `create(HeaderParameterSchema)` to create a new message. + */ +export const HeaderParameterSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 3); + +/** + * `Type` is a supported HTTP header type. + * See https://swagger.io/specification/v2/#parameterType. + * + * @generated from enum grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter.Type + */ +export enum HeaderParameter_Type { + /** + * @generated from enum value: UNKNOWN = 0; + */ + UNKNOWN = 0, + + /** + * @generated from enum value: STRING = 1; + */ + STRING = 1, + + /** + * @generated from enum value: NUMBER = 2; + */ + NUMBER = 2, + + /** + * @generated from enum value: INTEGER = 3; + */ + INTEGER = 3, + + /** + * @generated from enum value: BOOLEAN = 4; + */ + BOOLEAN = 4, +} + +/** + * Describes the enum grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter.Type. + */ +export const HeaderParameter_TypeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_protoc_gen_openapiv2_options_openapiv2, 3, 0); + +/** + * `Header` is a representation of OpenAPI v2 specification's Header object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#headerObject + * + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.Header + */ +export type Header = Message<"grpc.gateway.protoc_gen_openapiv2.options.Header"> & { + /** + * `Description` is a short description of the header. + * + * @generated from field: string description = 1; + */ + description: string; + + /** + * The type of the object. The value MUST be one of "string", "number", "integer", or "boolean". The "array" type is not supported. + * + * @generated from field: string type = 2; + */ + type: string; + + /** + * `Format` The extending format for the previously mentioned type. + * + * @generated from field: string format = 3; + */ + format: string; + + /** + * `Default` Declares the value of the header that the server will use if none is provided. + * See: https://tools.ietf.org/html/draft-fge-json-schema-validation-00#section-6.2. + * Unlike JSON Schema this value MUST conform to the defined type for the header. + * + * @generated from field: string default = 6; + */ + default: string; + + /** + * 'Pattern' See https://tools.ietf.org/html/draft-fge-json-schema-validation-00#section-5.2.3. + * + * @generated from field: string pattern = 13; + */ + pattern: string; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.Header. + * Use `create(HeaderSchema)` to create a new message. + */ +export const HeaderSchema: GenMessage
= /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 4); + +/** + * `Response` is a representation of OpenAPI v2 specification's Response object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#responseObject + * + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.Response + */ +export type Response = Message<"grpc.gateway.protoc_gen_openapiv2.options.Response"> & { + /** + * `Description` is a short description of the response. + * GFM syntax can be used for rich text representation. + * + * @generated from field: string description = 1; + */ + description: string; + + /** + * `Schema` optionally defines the structure of the response. + * If `Schema` is not provided, it means there is no content to the response. + * + * @generated from field: grpc.gateway.protoc_gen_openapiv2.options.Schema schema = 2; + */ + schema?: Schema; + + /** + * `Headers` A list of headers that are sent with the response. + * `Header` name is expected to be a string in the canonical format of the MIME header key + * See: https://golang.org/pkg/net/textproto/#CanonicalMIMEHeaderKey + * + * @generated from field: map headers = 3; + */ + headers: { [key: string]: Header }; + + /** + * `Examples` gives per-mimetype response examples. + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#example-object + * + * @generated from field: map examples = 4; + */ + examples: { [key: string]: string }; + + /** + * Custom properties that start with "x-" such as "x-foo" used to describe + * extra functionality that is not covered by the standard OpenAPI Specification. + * See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + * + * @generated from field: map extensions = 5; + */ + extensions: { [key: string]: Value }; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.Response. + * Use `create(ResponseSchema)` to create a new message. + */ +export const ResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 5); + +/** + * `Info` is a representation of OpenAPI v2 specification's Info object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#infoObject + * + * Example: + * + * option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = { + * info: { + * title: "Echo API"; + * version: "1.0"; + * description: ""; + * contact: { + * name: "gRPC-Gateway project"; + * url: "https://github.com/grpc-ecosystem/grpc-gateway"; + * email: "none@example.com"; + * }; + * license: { + * name: "BSD 3-Clause License"; + * url: "https://github.com/grpc-ecosystem/grpc-gateway/blob/main/LICENSE"; + * }; + * }; + * ... + * }; + * + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.Info + */ +export type Info = Message<"grpc.gateway.protoc_gen_openapiv2.options.Info"> & { + /** + * The title of the application. + * + * @generated from field: string title = 1; + */ + title: string; + + /** + * A short description of the application. GFM syntax can be used for rich + * text representation. + * + * @generated from field: string description = 2; + */ + description: string; + + /** + * The Terms of Service for the API. + * + * @generated from field: string terms_of_service = 3; + */ + termsOfService: string; + + /** + * The contact information for the exposed API. + * + * @generated from field: grpc.gateway.protoc_gen_openapiv2.options.Contact contact = 4; + */ + contact?: Contact; + + /** + * The license information for the exposed API. + * + * @generated from field: grpc.gateway.protoc_gen_openapiv2.options.License license = 5; + */ + license?: License; + + /** + * Provides the version of the application API (not to be confused + * with the specification version). + * + * @generated from field: string version = 6; + */ + version: string; + + /** + * Custom properties that start with "x-" such as "x-foo" used to describe + * extra functionality that is not covered by the standard OpenAPI Specification. + * See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + * + * @generated from field: map extensions = 7; + */ + extensions: { [key: string]: Value }; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.Info. + * Use `create(InfoSchema)` to create a new message. + */ +export const InfoSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 6); + +/** + * `Contact` is a representation of OpenAPI v2 specification's Contact object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#contactObject + * + * Example: + * + * option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = { + * info: { + * ... + * contact: { + * name: "gRPC-Gateway project"; + * url: "https://github.com/grpc-ecosystem/grpc-gateway"; + * email: "none@example.com"; + * }; + * ... + * }; + * ... + * }; + * + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.Contact + */ +export type Contact = Message<"grpc.gateway.protoc_gen_openapiv2.options.Contact"> & { + /** + * The identifying name of the contact person/organization. + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * The URL pointing to the contact information. MUST be in the format of a + * URL. + * + * @generated from field: string url = 2; + */ + url: string; + + /** + * The email address of the contact person/organization. MUST be in the format + * of an email address. + * + * @generated from field: string email = 3; + */ + email: string; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.Contact. + * Use `create(ContactSchema)` to create a new message. + */ +export const ContactSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 7); + +/** + * `License` is a representation of OpenAPI v2 specification's License object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#licenseObject + * + * Example: + * + * option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = { + * info: { + * ... + * license: { + * name: "BSD 3-Clause License"; + * url: "https://github.com/grpc-ecosystem/grpc-gateway/blob/main/LICENSE"; + * }; + * ... + * }; + * ... + * }; + * + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.License + */ +export type License = Message<"grpc.gateway.protoc_gen_openapiv2.options.License"> & { + /** + * The license name used for the API. + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * A URL to the license used for the API. MUST be in the format of a URL. + * + * @generated from field: string url = 2; + */ + url: string; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.License. + * Use `create(LicenseSchema)` to create a new message. + */ +export const LicenseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 8); + +/** + * `ExternalDocumentation` is a representation of OpenAPI v2 specification's + * ExternalDocumentation object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#externalDocumentationObject + * + * Example: + * + * option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = { + * ... + * external_docs: { + * description: "More about gRPC-Gateway"; + * url: "https://github.com/grpc-ecosystem/grpc-gateway"; + * } + * ... + * }; + * + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.ExternalDocumentation + */ +export type ExternalDocumentation = Message<"grpc.gateway.protoc_gen_openapiv2.options.ExternalDocumentation"> & { + /** + * A short description of the target documentation. GFM syntax can be used for + * rich text representation. + * + * @generated from field: string description = 1; + */ + description: string; + + /** + * The URL for the target documentation. Value MUST be in the format + * of a URL. + * + * @generated from field: string url = 2; + */ + url: string; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.ExternalDocumentation. + * Use `create(ExternalDocumentationSchema)` to create a new message. + */ +export const ExternalDocumentationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 9); + +/** + * `Schema` is a representation of OpenAPI v2 specification's Schema object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#schemaObject + * + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.Schema + */ +export type Schema = Message<"grpc.gateway.protoc_gen_openapiv2.options.Schema"> & { + /** + * @generated from field: grpc.gateway.protoc_gen_openapiv2.options.JSONSchema json_schema = 1; + */ + jsonSchema?: JSONSchema; + + /** + * Adds support for polymorphism. The discriminator is the schema property + * name that is used to differentiate between other schema that inherit this + * schema. The property name used MUST be defined at this schema and it MUST + * be in the required property list. When used, the value MUST be the name of + * this schema or any schema that inherits it. + * + * @generated from field: string discriminator = 2; + */ + discriminator: string; + + /** + * Relevant only for Schema "properties" definitions. Declares the property as + * "read only". This means that it MAY be sent as part of a response but MUST + * NOT be sent as part of the request. Properties marked as readOnly being + * true SHOULD NOT be in the required list of the defined schema. Default + * value is false. + * + * @generated from field: bool read_only = 3; + */ + readOnly: boolean; + + /** + * Additional external documentation for this schema. + * + * @generated from field: grpc.gateway.protoc_gen_openapiv2.options.ExternalDocumentation external_docs = 5; + */ + externalDocs?: ExternalDocumentation; + + /** + * A free-form property to include an example of an instance for this schema in JSON. + * This is copied verbatim to the output. + * + * @generated from field: string example = 6; + */ + example: string; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.Schema. + * Use `create(SchemaSchema)` to create a new message. + */ +export const SchemaSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 10); + +/** + * `EnumSchema` is subset of fields from the OpenAPI v2 specification's Schema object. + * Only fields that are applicable to Enums are included + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#schemaObject + * + * Example: + * + * option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_enum) = { + * ... + * title: "MyEnum"; + * description:"This is my nice enum"; + * example: "ZERO"; + * required: true; + * ... + * }; + * + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.EnumSchema + */ +export type EnumSchema = Message<"grpc.gateway.protoc_gen_openapiv2.options.EnumSchema"> & { + /** + * A short description of the schema. + * + * @generated from field: string description = 1; + */ + description: string; + + /** + * @generated from field: string default = 2; + */ + default: string; + + /** + * The title of the schema. + * + * @generated from field: string title = 3; + */ + title: string; + + /** + * @generated from field: bool required = 4; + */ + required: boolean; + + /** + * @generated from field: bool read_only = 5; + */ + readOnly: boolean; + + /** + * Additional external documentation for this schema. + * + * @generated from field: grpc.gateway.protoc_gen_openapiv2.options.ExternalDocumentation external_docs = 6; + */ + externalDocs?: ExternalDocumentation; + + /** + * @generated from field: string example = 7; + */ + example: string; + + /** + * Ref is used to define an external reference to include in the message. + * This could be a fully qualified proto message reference, and that type must + * be imported into the protofile. If no message is identified, the Ref will + * be used verbatim in the output. + * For example: + * `ref: ".google.protobuf.Timestamp"`. + * + * @generated from field: string ref = 8; + */ + ref: string; + + /** + * Custom properties that start with "x-" such as "x-foo" used to describe + * extra functionality that is not covered by the standard OpenAPI Specification. + * See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + * + * @generated from field: map extensions = 9; + */ + extensions: { [key: string]: Value }; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.EnumSchema. + * Use `create(EnumSchemaSchema)` to create a new message. + */ +export const EnumSchemaSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 11); + +/** + * `JSONSchema` represents properties from JSON Schema taken, and as used, in + * the OpenAPI v2 spec. + * + * This includes changes made by OpenAPI v2. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#schemaObject + * + * See also: https://cswr.github.io/JsonSchema/spec/basic_types/, + * https://github.com/json-schema-org/json-schema-spec/blob/master/schema.json + * + * Example: + * + * message SimpleMessage { + * option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema) = { + * json_schema: { + * title: "SimpleMessage" + * description: "A simple message." + * required: ["id"] + * } + * }; + * + * // Id represents the message identifier. + * string id = 1; [ + * (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = { + * description: "The unique identifier of the simple message." + * }]; + * } + * + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.JSONSchema + */ +export type JSONSchema = Message<"grpc.gateway.protoc_gen_openapiv2.options.JSONSchema"> & { + /** + * Ref is used to define an external reference to include in the message. + * This could be a fully qualified proto message reference, and that type must + * be imported into the protofile. If no message is identified, the Ref will + * be used verbatim in the output. + * For example: + * `ref: ".google.protobuf.Timestamp"`. + * + * @generated from field: string ref = 3; + */ + ref: string; + + /** + * The title of the schema. + * + * @generated from field: string title = 5; + */ + title: string; + + /** + * A short description of the schema. + * + * @generated from field: string description = 6; + */ + description: string; + + /** + * @generated from field: string default = 7; + */ + default: string; + + /** + * @generated from field: bool read_only = 8; + */ + readOnly: boolean; + + /** + * A free-form property to include a JSON example of this field. This is copied + * verbatim to the output swagger.json. Quotes must be escaped. + * This property is the same for 2.0 and 3.0.0 https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/3.0.0.md#schemaObject https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#schemaObject + * + * @generated from field: string example = 9; + */ + example: string; + + /** + * @generated from field: double multiple_of = 10; + */ + multipleOf: number; + + /** + * Maximum represents an inclusive upper limit for a numeric instance. The + * value of MUST be a number, + * + * @generated from field: double maximum = 11; + */ + maximum: number; + + /** + * @generated from field: bool exclusive_maximum = 12; + */ + exclusiveMaximum: boolean; + + /** + * minimum represents an inclusive lower limit for a numeric instance. The + * value of MUST be a number, + * + * @generated from field: double minimum = 13; + */ + minimum: number; + + /** + * @generated from field: bool exclusive_minimum = 14; + */ + exclusiveMinimum: boolean; + + /** + * @generated from field: uint64 max_length = 15; + */ + maxLength: bigint; + + /** + * @generated from field: uint64 min_length = 16; + */ + minLength: bigint; + + /** + * @generated from field: string pattern = 17; + */ + pattern: string; + + /** + * @generated from field: uint64 max_items = 20; + */ + maxItems: bigint; + + /** + * @generated from field: uint64 min_items = 21; + */ + minItems: bigint; + + /** + * @generated from field: bool unique_items = 22; + */ + uniqueItems: boolean; + + /** + * @generated from field: uint64 max_properties = 24; + */ + maxProperties: bigint; + + /** + * @generated from field: uint64 min_properties = 25; + */ + minProperties: bigint; + + /** + * @generated from field: repeated string required = 26; + */ + required: string[]; + + /** + * Items in 'array' must be unique. + * + * @generated from field: repeated string array = 34; + */ + array: string[]; + + /** + * @generated from field: repeated grpc.gateway.protoc_gen_openapiv2.options.JSONSchema.JSONSchemaSimpleTypes type = 35; + */ + type: JSONSchema_JSONSchemaSimpleTypes[]; + + /** + * `Format` + * + * @generated from field: string format = 36; + */ + format: string; + + /** + * Items in `enum` must be unique https://tools.ietf.org/html/draft-fge-json-schema-validation-00#section-5.5.1 + * + * @generated from field: repeated string enum = 46; + */ + enum: string[]; + + /** + * Additional field level properties used when generating the OpenAPI v2 file. + * + * @generated from field: grpc.gateway.protoc_gen_openapiv2.options.JSONSchema.FieldConfiguration field_configuration = 1001; + */ + fieldConfiguration?: JSONSchema_FieldConfiguration; + + /** + * Custom properties that start with "x-" such as "x-foo" used to describe + * extra functionality that is not covered by the standard OpenAPI Specification. + * See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + * + * @generated from field: map extensions = 48; + */ + extensions: { [key: string]: Value }; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.JSONSchema. + * Use `create(JSONSchemaSchema)` to create a new message. + */ +export const JSONSchemaSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 12); + +/** + * 'FieldConfiguration' provides additional field level properties used when generating the OpenAPI v2 file. + * These properties are not defined by OpenAPIv2, but they are used to control the generation. + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.JSONSchema.FieldConfiguration + */ +export type JSONSchema_FieldConfiguration = Message<"grpc.gateway.protoc_gen_openapiv2.options.JSONSchema.FieldConfiguration"> & { + /** + * Alternative parameter name when used as path parameter. If set, this will + * be used as the complete parameter name when this field is used as a path + * parameter. Use this to avoid having auto generated path parameter names + * for overlapping paths. + * + * @generated from field: string path_param_name = 47; + */ + pathParamName: string; + + /** + * Declares this field to be deprecated. Allows for the generated OpenAPI + * parameter to be marked as deprecated without affecting the proto field. + * + * @generated from field: bool deprecated = 49; + */ + deprecated: boolean; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.JSONSchema.FieldConfiguration. + * Use `create(JSONSchema_FieldConfigurationSchema)` to create a new message. + */ +export const JSONSchema_FieldConfigurationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 12, 0); + +/** + * @generated from enum grpc.gateway.protoc_gen_openapiv2.options.JSONSchema.JSONSchemaSimpleTypes + */ +export enum JSONSchema_JSONSchemaSimpleTypes { + /** + * @generated from enum value: UNKNOWN = 0; + */ + UNKNOWN = 0, + + /** + * @generated from enum value: ARRAY = 1; + */ + ARRAY = 1, + + /** + * @generated from enum value: BOOLEAN = 2; + */ + BOOLEAN = 2, + + /** + * @generated from enum value: INTEGER = 3; + */ + INTEGER = 3, + + /** + * @generated from enum value: NULL = 4; + */ + NULL = 4, + + /** + * @generated from enum value: NUMBER = 5; + */ + NUMBER = 5, + + /** + * @generated from enum value: OBJECT = 6; + */ + OBJECT = 6, + + /** + * @generated from enum value: STRING = 7; + */ + STRING = 7, +} + +/** + * Describes the enum grpc.gateway.protoc_gen_openapiv2.options.JSONSchema.JSONSchemaSimpleTypes. + */ +export const JSONSchema_JSONSchemaSimpleTypesSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_protoc_gen_openapiv2_options_openapiv2, 12, 0); + +/** + * `Tag` is a representation of OpenAPI v2 specification's Tag object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#tagObject + * + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.Tag + */ +export type Tag = Message<"grpc.gateway.protoc_gen_openapiv2.options.Tag"> & { + /** + * The name of the tag. Use it to allow override of the name of a + * global Tag object, then use that name to reference the tag throughout the + * OpenAPI file. + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * A short description for the tag. GFM syntax can be used for rich text + * representation. + * + * @generated from field: string description = 2; + */ + description: string; + + /** + * Additional external documentation for this tag. + * + * @generated from field: grpc.gateway.protoc_gen_openapiv2.options.ExternalDocumentation external_docs = 3; + */ + externalDocs?: ExternalDocumentation; + + /** + * Custom properties that start with "x-" such as "x-foo" used to describe + * extra functionality that is not covered by the standard OpenAPI Specification. + * See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + * + * @generated from field: map extensions = 4; + */ + extensions: { [key: string]: Value }; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.Tag. + * Use `create(TagSchema)` to create a new message. + */ +export const TagSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 13); + +/** + * `SecurityDefinitions` is a representation of OpenAPI v2 specification's + * Security Definitions object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#securityDefinitionsObject + * + * A declaration of the security schemes available to be used in the + * specification. This does not enforce the security schemes on the operations + * and only serves to provide the relevant details for each scheme. + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.SecurityDefinitions + */ +export type SecurityDefinitions = Message<"grpc.gateway.protoc_gen_openapiv2.options.SecurityDefinitions"> & { + /** + * A single security scheme definition, mapping a "name" to the scheme it + * defines. + * + * @generated from field: map security = 1; + */ + security: { [key: string]: SecurityScheme }; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.SecurityDefinitions. + * Use `create(SecurityDefinitionsSchema)` to create a new message. + */ +export const SecurityDefinitionsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 14); + +/** + * `SecurityScheme` is a representation of OpenAPI v2 specification's + * Security Scheme object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#securitySchemeObject + * + * Allows the definition of a security scheme that can be used by the + * operations. Supported schemes are basic authentication, an API key (either as + * a header or as a query parameter) and OAuth2's common flows (implicit, + * password, application and access code). + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.SecurityScheme + */ +export type SecurityScheme = Message<"grpc.gateway.protoc_gen_openapiv2.options.SecurityScheme"> & { + /** + * The type of the security scheme. Valid values are "basic", + * "apiKey" or "oauth2". + * + * @generated from field: grpc.gateway.protoc_gen_openapiv2.options.SecurityScheme.Type type = 1; + */ + type: SecurityScheme_Type; + + /** + * A short description for security scheme. + * + * @generated from field: string description = 2; + */ + description: string; + + /** + * The name of the header or query parameter to be used. + * Valid for apiKey. + * + * @generated from field: string name = 3; + */ + name: string; + + /** + * The location of the API key. Valid values are "query" or + * "header". + * Valid for apiKey. + * + * @generated from field: grpc.gateway.protoc_gen_openapiv2.options.SecurityScheme.In in = 4; + */ + in: SecurityScheme_In; + + /** + * The flow used by the OAuth2 security scheme. Valid values are + * "implicit", "password", "application" or "accessCode". + * Valid for oauth2. + * + * @generated from field: grpc.gateway.protoc_gen_openapiv2.options.SecurityScheme.Flow flow = 5; + */ + flow: SecurityScheme_Flow; + + /** + * The authorization URL to be used for this flow. This SHOULD be in + * the form of a URL. + * Valid for oauth2/implicit and oauth2/accessCode. + * + * @generated from field: string authorization_url = 6; + */ + authorizationUrl: string; + + /** + * The token URL to be used for this flow. This SHOULD be in the + * form of a URL. + * Valid for oauth2/password, oauth2/application and oauth2/accessCode. + * + * @generated from field: string token_url = 7; + */ + tokenUrl: string; + + /** + * The available scopes for the OAuth2 security scheme. + * Valid for oauth2. + * + * @generated from field: grpc.gateway.protoc_gen_openapiv2.options.Scopes scopes = 8; + */ + scopes?: Scopes; + + /** + * Custom properties that start with "x-" such as "x-foo" used to describe + * extra functionality that is not covered by the standard OpenAPI Specification. + * See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + * + * @generated from field: map extensions = 9; + */ + extensions: { [key: string]: Value }; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.SecurityScheme. + * Use `create(SecuritySchemeSchema)` to create a new message. + */ +export const SecuritySchemeSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 15); + +/** + * The type of the security scheme. Valid values are "basic", + * "apiKey" or "oauth2". + * + * @generated from enum grpc.gateway.protoc_gen_openapiv2.options.SecurityScheme.Type + */ +export enum SecurityScheme_Type { + /** + * @generated from enum value: TYPE_INVALID = 0; + */ + INVALID = 0, + + /** + * @generated from enum value: TYPE_BASIC = 1; + */ + BASIC = 1, + + /** + * @generated from enum value: TYPE_API_KEY = 2; + */ + API_KEY = 2, + + /** + * @generated from enum value: TYPE_OAUTH2 = 3; + */ + OAUTH2 = 3, +} + +/** + * Describes the enum grpc.gateway.protoc_gen_openapiv2.options.SecurityScheme.Type. + */ +export const SecurityScheme_TypeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_protoc_gen_openapiv2_options_openapiv2, 15, 0); + +/** + * The location of the API key. Valid values are "query" or "header". + * + * @generated from enum grpc.gateway.protoc_gen_openapiv2.options.SecurityScheme.In + */ +export enum SecurityScheme_In { + /** + * @generated from enum value: IN_INVALID = 0; + */ + INVALID = 0, + + /** + * @generated from enum value: IN_QUERY = 1; + */ + QUERY = 1, + + /** + * @generated from enum value: IN_HEADER = 2; + */ + HEADER = 2, +} + +/** + * Describes the enum grpc.gateway.protoc_gen_openapiv2.options.SecurityScheme.In. + */ +export const SecurityScheme_InSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_protoc_gen_openapiv2_options_openapiv2, 15, 1); + +/** + * The flow used by the OAuth2 security scheme. Valid values are + * "implicit", "password", "application" or "accessCode". + * + * @generated from enum grpc.gateway.protoc_gen_openapiv2.options.SecurityScheme.Flow + */ +export enum SecurityScheme_Flow { + /** + * @generated from enum value: FLOW_INVALID = 0; + */ + INVALID = 0, + + /** + * @generated from enum value: FLOW_IMPLICIT = 1; + */ + IMPLICIT = 1, + + /** + * @generated from enum value: FLOW_PASSWORD = 2; + */ + PASSWORD = 2, + + /** + * @generated from enum value: FLOW_APPLICATION = 3; + */ + APPLICATION = 3, + + /** + * @generated from enum value: FLOW_ACCESS_CODE = 4; + */ + ACCESS_CODE = 4, +} + +/** + * Describes the enum grpc.gateway.protoc_gen_openapiv2.options.SecurityScheme.Flow. + */ +export const SecurityScheme_FlowSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_protoc_gen_openapiv2_options_openapiv2, 15, 2); + +/** + * `SecurityRequirement` is a representation of OpenAPI v2 specification's + * Security Requirement object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#securityRequirementObject + * + * Lists the required security schemes to execute this operation. The object can + * have multiple security schemes declared in it which are all required (that + * is, there is a logical AND between the schemes). + * + * The name used for each property MUST correspond to a security scheme + * declared in the Security Definitions. + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.SecurityRequirement + */ +export type SecurityRequirement = Message<"grpc.gateway.protoc_gen_openapiv2.options.SecurityRequirement"> & { + /** + * Each name must correspond to a security scheme which is declared in + * the Security Definitions. If the security scheme is of type "oauth2", + * then the value is a list of scope names required for the execution. + * For other security scheme types, the array MUST be empty. + * + * @generated from field: map security_requirement = 1; + */ + securityRequirement: { [key: string]: SecurityRequirement_SecurityRequirementValue }; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.SecurityRequirement. + * Use `create(SecurityRequirementSchema)` to create a new message. + */ +export const SecurityRequirementSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 16); + +/** + * If the security scheme is of type "oauth2", then the value is a list of + * scope names required for the execution. For other security scheme types, + * the array MUST be empty. + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.SecurityRequirement.SecurityRequirementValue + */ +export type SecurityRequirement_SecurityRequirementValue = Message<"grpc.gateway.protoc_gen_openapiv2.options.SecurityRequirement.SecurityRequirementValue"> & { + /** + * @generated from field: repeated string scope = 1; + */ + scope: string[]; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.SecurityRequirement.SecurityRequirementValue. + * Use `create(SecurityRequirement_SecurityRequirementValueSchema)` to create a new message. + */ +export const SecurityRequirement_SecurityRequirementValueSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 16, 0); + +/** + * `Scopes` is a representation of OpenAPI v2 specification's Scopes object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#scopesObject + * + * Lists the available scopes for an OAuth2 security scheme. + * + * @generated from message grpc.gateway.protoc_gen_openapiv2.options.Scopes + */ +export type Scopes = Message<"grpc.gateway.protoc_gen_openapiv2.options.Scopes"> & { + /** + * Maps between a name of a scope to a short description of it (as the value + * of the property). + * + * @generated from field: map scope = 1; + */ + scope: { [key: string]: string }; +}; + +/** + * Describes the message grpc.gateway.protoc_gen_openapiv2.options.Scopes. + * Use `create(ScopesSchema)` to create a new message. + */ +export const ScopesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_protoc_gen_openapiv2_options_openapiv2, 17); + +/** + * Scheme describes the schemes supported by the OpenAPI Swagger + * and Operation objects. + * + * @generated from enum grpc.gateway.protoc_gen_openapiv2.options.Scheme + */ +export enum Scheme { + /** + * @generated from enum value: UNKNOWN = 0; + */ + UNKNOWN = 0, + + /** + * @generated from enum value: HTTP = 1; + */ + HTTP = 1, + + /** + * @generated from enum value: HTTPS = 2; + */ + HTTPS = 2, + + /** + * @generated from enum value: WS = 3; + */ + WS = 3, + + /** + * @generated from enum value: WSS = 4; + */ + WSS = 4, +} + +/** + * Describes the enum grpc.gateway.protoc_gen_openapiv2.options.Scheme. + */ +export const SchemeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_protoc_gen_openapiv2_options_openapiv2, 0); + diff --git a/gen/ts/tsconfig.json b/gen/ts/tsconfig.json new file mode 100644 index 0000000000..3b37703eef --- /dev/null +++ b/gen/ts/tsconfig.json @@ -0,0 +1,23 @@ +{ + "compilerOptions": { + "target": "ES2020", + "module": "ESNext", + "lib": ["ES2020"], + "moduleResolution": "bundler", + "strict": true, + "skipLibCheck": true, + "esModuleInterop": true, + "allowSyntheticDefaultImports": true, + "forceConsistentCasingInFileNames": true, + "noEmit": true, + "resolveJsonModule": true, + "isolatedModules": true, + "allowImportingTsExtensions": true + }, + "include": [ + "**/*.ts" + ], + "exclude": [ + "node_modules" + ] +} diff --git a/go.Makefile b/go.Makefile new file mode 100644 index 0000000000..f55126ca3f --- /dev/null +++ b/go.Makefile @@ -0,0 +1,196 @@ +# Common Go Makefile for Flyte services +# Include this file in service-specific Makefiles and set the required variables: +# SERVICE_NAME - Name of the service (e.g., "manager", "runs", "queue") +# CMD_PATH - Path to main.go relative to service directory (default: cmd/main.go) +# BIN_DIR - Directory for binaries (default: bin) + +# Set defaults +CMD_PATH ?= cmd/main.go +BIN_DIR ?= bin +BIN_NAME ?= $(SERVICE_NAME) +GOLANGCI_LINT_VERSION ?= v2.4.0 +LOCALBIN ?= $(shell pwd)/bin + +# ANSI color codes for prettier output +COLOR_RESET := \033[0m +COLOR_BOLD := \033[1m +COLOR_GREEN := \033[32m +COLOR_YELLOW := \033[33m +COLOR_BLUE := \033[36m + +##@ General + +.PHONY: help +help: ## Display this help message + @echo '' + @echo '$(COLOR_BOLD)Usage:$(COLOR_RESET)' + @echo ' make $(COLOR_BLUE)$(COLOR_RESET)' + @echo '' + @echo '$(COLOR_BOLD)Available targets:$(COLOR_RESET)' + @awk 'BEGIN {FS = ":.*##"; printf ""} \ + /^[a-zA-Z_0-9-]+:.*?##/ { printf " $(COLOR_BLUE)%-20s$(COLOR_RESET) %s\n", $$1, $$2 } \ + /^##@/ { printf "\n$(COLOR_BOLD)%s$(COLOR_RESET)\n", substr($$0, 5) } ' \ + $(MAKEFILE_LIST) + +##@ Development + +.PHONY: fmt +fmt: ## Run go fmt to format code + @echo "$(COLOR_GREEN)Formatting Go code...$(COLOR_RESET)" + @go fmt ./... + +.PHONY: vet +vet: ## Run go vet to examine code + @echo "$(COLOR_GREEN)Running go vet...$(COLOR_RESET)" + @go vet ./... + +.PHONY: lint +lint: golangci-lint ## Run golangci-lint linter (skips *_test.go files) + @echo "$(COLOR_GREEN)Running golangci-lint (skipping tests)...$(COLOR_RESET)" + @$(GOLANGCI_LINT) run --tests=false + +.PHONY: lint-all +lint-all: golangci-lint ## Run golangci-lint linter (includes all files) + @echo "$(COLOR_GREEN)Running golangci-lint (including tests)...$(COLOR_RESET)" + @$(GOLANGCI_LINT) run + +.PHONY: lint-fix +lint-fix: golangci-lint ## Run golangci-lint and automatically fix issues (skips *_test.go files) + @echo "$(COLOR_GREEN)Running golangci-lint with auto-fix (skipping tests)...$(COLOR_RESET)" + @$(GOLANGCI_LINT) run --fix --tests=false + +.PHONY: tidy +tidy: ## Run go mod tidy to clean up dependencies + @echo "$(COLOR_GREEN)Tidying Go modules...$(COLOR_RESET)" + @go mod tidy + +.PHONY: verify +verify: fmt vet ## Run fmt and vet + @echo "$(COLOR_GREEN)Code verification complete$(COLOR_RESET)" + +##@ Build + +.PHONY: build +build: verify ## Build the service binary + @echo "$(COLOR_GREEN)Building $(SERVICE_NAME)...$(COLOR_RESET)" + @mkdir -p $(BIN_DIR) + @go build -o $(BIN_DIR)/$(BIN_NAME) $(CMD_PATH) + @echo "$(COLOR_GREEN)Built: $(BIN_DIR)/$(BIN_NAME)$(COLOR_RESET)" + +.PHONY: build-fast +build-fast: ## Build without verification (faster) + @echo "$(COLOR_GREEN)Building $(SERVICE_NAME) (fast mode)...$(COLOR_RESET)" + @mkdir -p $(BIN_DIR) + @go build -o $(BIN_DIR)/$(BIN_NAME) $(CMD_PATH) + @echo "$(COLOR_GREEN)Built: $(BIN_DIR)/$(BIN_NAME)$(COLOR_RESET)" + +.PHONY: install +install: build ## Build and install binary to $GOPATH/bin + @echo "$(COLOR_GREEN)Installing $(SERVICE_NAME)...$(COLOR_RESET)" + @go install $(CMD_PATH) + +##@ Testing + +.PHONY: test +test: ## Run unit tests + @echo "$(COLOR_GREEN)Running tests...$(COLOR_RESET)" + @go test -v -race -cover ./... + +.PHONY: test-short +test-short: ## Run unit tests (short mode) + @echo "$(COLOR_GREEN)Running tests (short mode)...$(COLOR_RESET)" + @go test -short -v ./... + +.PHONY: test-coverage +test-coverage: ## Run tests with coverage report + @echo "$(COLOR_GREEN)Running tests with coverage...$(COLOR_RESET)" + @go test -v -race -coverprofile=coverage.out -covermode=atomic ./... + @go tool cover -html=coverage.out -o coverage.html + @echo "$(COLOR_GREEN)Coverage report generated: coverage.html$(COLOR_RESET)" + +.PHONY: bench +bench: ## Run benchmarks + @echo "$(COLOR_GREEN)Running benchmarks...$(COLOR_RESET)" + @go test -bench=. -benchmem ./... + +##@ Running + +.PHONY: run +run: build-fast ## Build and run the service + @echo "$(COLOR_GREEN)Running $(SERVICE_NAME)...$(COLOR_RESET)" + @./$(BIN_DIR)/$(BIN_NAME) $(RUN_ARGS) + +.PHONY: run-dev +run-dev: ## Run service directly with go run (no build) + @echo "$(COLOR_GREEN)Running $(SERVICE_NAME) (dev mode)...$(COLOR_RESET)" + @go run $(CMD_PATH) $(RUN_ARGS) + +##@ Cleanup + +.PHONY: clean +clean: ## Remove build artifacts + @echo "$(COLOR_YELLOW)Cleaning build artifacts...$(COLOR_RESET)" + @rm -rf $(BIN_DIR) + @rm -f coverage.out coverage.html + @echo "$(COLOR_GREEN)Clean complete$(COLOR_RESET)" + +.PHONY: clean-all +clean-all: clean ## Remove build artifacts and installed tools + @echo "$(COLOR_YELLOW)Cleaning all artifacts and tools...$(COLOR_RESET)" + @rm -rf $(LOCALBIN) + @echo "$(COLOR_GREEN)Clean complete$(COLOR_RESET)" + +##@ Dependencies + +.PHONY: deps +deps: ## Download dependencies + @echo "$(COLOR_GREEN)Downloading dependencies...$(COLOR_RESET)" + @go mod download + +.PHONY: deps-upgrade +deps-upgrade: ## Upgrade all dependencies + @echo "$(COLOR_GREEN)Upgrading dependencies...$(COLOR_RESET)" + @go get -u ./... + @go mod tidy + +##@ Tools + +GOLANGCI_LINT = $(LOCALBIN)/golangci-lint + +.PHONY: golangci-lint +golangci-lint: $(GOLANGCI_LINT) ## Download golangci-lint locally if necessary +$(GOLANGCI_LINT): $(LOCALBIN) + @echo "$(COLOR_GREEN)Installing golangci-lint $(GOLANGCI_LINT_VERSION)...$(COLOR_RESET)" + @$(call go-install-tool,$(GOLANGCI_LINT),github.com/golangci/golangci-lint/v2/cmd/golangci-lint,$(GOLANGCI_LINT_VERSION)) + +$(LOCALBIN): + @mkdir -p $(LOCALBIN) + +# go-install-tool will 'go install' any package with custom target and name of binary, if it doesn't exist +# $1 - target path with name of binary +# $2 - package url which can be installed +# $3 - specific version of package +define go-install-tool +@[ -f "$(1)-$(3)" ] && [ "$$(readlink -- "$(1)" 2>/dev/null)" = "$(1)-$(3)" ] || { \ +set -e; \ +package=$(2)@$(3) ;\ +echo " Downloading $${package}" ;\ +rm -f $(1) ;\ +GOBIN=$(LOCALBIN) go install $${package} ;\ +mv $(1) $(1)-$(3) ;\ +} ;\ +ln -sf $$(basename $(1)-$(3)) $(1) +endef + +##@ Info + +.PHONY: info +info: ## Display service information + @echo "$(COLOR_BOLD)Service Information:$(COLOR_RESET)" + @echo " Service Name: $(COLOR_BLUE)$(SERVICE_NAME)$(COLOR_RESET)" + @echo " Binary Name: $(COLOR_BLUE)$(BIN_NAME)$(COLOR_RESET)" + @echo " Binary Path: $(COLOR_BLUE)$(BIN_DIR)/$(BIN_NAME)$(COLOR_RESET)" + @echo " CMD Path: $(COLOR_BLUE)$(CMD_PATH)$(COLOR_RESET)" + @echo " Go Version: $(COLOR_BLUE)$$(go version | cut -d' ' -f3)$(COLOR_RESET)" + +.DEFAULT_GOAL := help diff --git a/go.mod b/go.mod new file mode 100644 index 0000000000..5193b4d8d3 --- /dev/null +++ b/go.mod @@ -0,0 +1,266 @@ +module github.com/flyteorg/flyte/v2 + +go 1.24.6 + +require ( + buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go v1.36.10-20250912141014-52f32327d4b0.1 + cloud.google.com/go/secretmanager v1.16.0 + connectrpc.com/connect v1.19.1 + github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.0 + github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.10.1 + github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azsecrets v1.4.0 + github.com/GoogleCloudPlatform/spark-on-k8s-operator v0.0.0-20200723154620-6f35a1152625 + github.com/aws/aws-sdk-go v1.55.8 + github.com/aws/aws-sdk-go-v2 v1.41.1 + github.com/aws/aws-sdk-go-v2/config v1.26.1 + github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.41.1 + github.com/benlaurie/objecthash v0.0.0-20180202135721-d1e3d6079fc1 + github.com/coocood/freecache v1.2.4 + github.com/dask/dask-kubernetes/v2023 v2023.0.0-20230626103304-abd02cd17b26 + github.com/eko/gocache/lib/v4 v4.2.0 + github.com/eko/gocache/store/freecache/v4 v4.2.0 + github.com/eko/gocache/store/redis/v4 v4.2.0 + github.com/fatih/color v1.13.0 + github.com/flyteorg/stow v0.3.12 + github.com/fsnotify/fsnotify v1.9.0 + github.com/ghodss/yaml v1.0.0 + github.com/go-gormigrate/gormigrate/v2 v2.1.5 + github.com/go-test/deep v1.1.1 + github.com/golang/protobuf v1.5.4 + github.com/googleapis/gax-go/v2 v2.15.0 + github.com/grpc-ecosystem/go-grpc-middleware/providers/prometheus v1.1.0 + github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3 + github.com/hashicorp/golang-lru v0.5.4 + github.com/imdario/mergo v0.3.16 + github.com/jackc/pgconn v1.14.3 + github.com/jackc/pgx/v5 v5.7.6 + github.com/kubeflow/training-operator v1.9.3 + github.com/lib/pq v1.10.9 + github.com/magiconair/properties v1.8.6 + github.com/mitchellh/mapstructure v1.5.0 + github.com/onsi/ginkgo/v2 v2.22.0 + github.com/onsi/gomega v1.36.1 + github.com/pkg/errors v0.9.1 + github.com/prometheus/client_golang v1.23.2 + github.com/prometheus/common v0.67.4 + github.com/ray-project/kuberay/ray-operator v1.1.0-rc.1 + github.com/redis/go-redis/extra/redisprometheus/v9 v9.17.2 + github.com/redis/go-redis/v9 v9.17.2 + github.com/samber/lo v1.39.0 + github.com/shamaton/msgpack/v2 v2.4.0 + github.com/sirupsen/logrus v1.9.3 + github.com/spf13/cobra v1.9.1 + github.com/spf13/pflag v1.0.6 + github.com/spf13/viper v1.11.0 + github.com/stretchr/testify v1.11.1 + github.com/vmihailenco/msgpack/v5 v5.4.1 + go.opentelemetry.io/otel v1.37.0 + go.opentelemetry.io/otel/exporters/jaeger v1.17.0 + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.37.0 + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.37.0 + go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.37.0 + go.opentelemetry.io/otel/sdk v1.37.0 + go.opentelemetry.io/otel/trace v1.37.0 + golang.org/x/exp v0.0.0-20251209150349-8475f28825e9 + golang.org/x/net v0.48.0 + golang.org/x/oauth2 v0.32.0 + golang.org/x/time v0.12.0 + google.golang.org/api v0.247.0 + google.golang.org/genproto/googleapis/api v0.0.0-20251103181224-f26f9409b101 + google.golang.org/genproto/googleapis/rpc v0.0.0-20251103181224-f26f9409b101 + google.golang.org/grpc v1.76.0 + google.golang.org/protobuf v1.36.10 + gopkg.in/yaml.v2 v2.4.0 + gorm.io/datatypes v1.2.7 + gorm.io/driver/postgres v1.6.0 + gorm.io/driver/sqlite v1.6.0 + gorm.io/gorm v1.31.1 + gotest.tools v2.2.0+incompatible + k8s.io/api v0.34.1 + k8s.io/apimachinery v0.34.1 + k8s.io/client-go v0.34.1 + k8s.io/klog/v2 v2.130.1 + k8s.io/utils v0.0.0-20251002143259-bc988d571ff4 + sigs.k8s.io/controller-runtime v0.22.4 +) + +require ( + cel.dev/expr v0.24.0 // indirect + cloud.google.com/go v0.121.6 // indirect + cloud.google.com/go/auth v0.16.4 // indirect + cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect + cloud.google.com/go/compute/metadata v0.8.0 // indirect + cloud.google.com/go/iam v1.5.3 // indirect + cloud.google.com/go/monitoring v1.24.3 // indirect + cloud.google.com/go/storage v1.56.0 // indirect + filippo.io/edwards25519 v1.1.0 // indirect + github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.1 // indirect + github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/internal v1.2.0 // indirect + github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.4.0 // indirect + github.com/AzureAD/microsoft-authentication-library-for-go v1.4.2 // indirect + github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.29.0 // indirect + github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.53.0 // indirect + github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.53.0 // indirect + github.com/NYTimes/gziphandler v1.1.1 // indirect + github.com/antlr/antlr4/runtime/Go/antlr/v4 v4.0.0-20230512164433-5d1fd1a340c9 // indirect + github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a // indirect + github.com/aws/aws-sdk-go-v2/credentials v1.16.12 // indirect + github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.10 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.17 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.17 // indirect + github.com/aws/aws-sdk-go-v2/internal/ini v1.7.2 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.9 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.18.5 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.5 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.26.5 // indirect + github.com/aws/smithy-go v1.24.0 // indirect + github.com/beorn7/perks v1.0.1 // indirect + github.com/blang/semver/v4 v4.0.0 // indirect + github.com/cenkalti/backoff/v5 v5.0.3 // indirect + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/cncf/xds/go v0.0.0-20250501225837-2ac532fd4443 // indirect + github.com/coreos/go-semver v0.3.1 // indirect + github.com/coreos/go-systemd/v22 v22.5.0 // indirect + github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect + github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect + github.com/emicklei/go-restful/v3 v3.12.2 // indirect + github.com/envoyproxy/go-control-plane/envoy v1.32.4 // indirect + github.com/envoyproxy/protoc-gen-validate v1.2.1 // indirect + github.com/evanphx/json-patch v5.6.0+incompatible // indirect + github.com/evanphx/json-patch/v5 v5.9.11 // indirect + github.com/felixge/httpsnoop v1.0.4 // indirect + github.com/go-jose/go-jose/v4 v4.1.2 // indirect + github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/stdr v1.2.2 // indirect + github.com/go-logr/zapr v1.3.0 // indirect + github.com/go-openapi/jsonpointer v0.21.0 // indirect + github.com/go-openapi/jsonreference v0.21.0 // indirect + github.com/go-openapi/swag v0.23.0 // indirect + github.com/go-sql-driver/mysql v1.8.1 // indirect + github.com/go-task/slim-sprig/v3 v3.0.0 // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/golang-jwt/jwt/v5 v5.3.0 // indirect + github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect + github.com/golang/mock v1.6.0 // indirect + github.com/google/btree v1.1.3 // indirect + github.com/google/cel-go v0.26.0 // indirect + github.com/google/gnostic-models v0.7.0 // indirect + github.com/google/go-cmp v0.7.0 // indirect + github.com/google/gofuzz v1.2.0 // indirect + github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db // indirect + github.com/google/s2a-go v0.1.9 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/googleapis/enterprise-certificate-proxy v0.3.6 // indirect + github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0 // indirect + github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0 // indirect + github.com/hashicorp/hcl v1.0.0 // indirect + github.com/inconshreveable/mousetrap v1.1.0 // indirect + github.com/jackc/chunkreader/v2 v2.0.1 // indirect + github.com/jackc/pgio v1.0.0 // indirect + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgproto3/v2 v2.3.3 // indirect + github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect + github.com/jackc/puddle/v2 v2.2.2 // indirect + github.com/jinzhu/inflection v1.0.0 // indirect + github.com/jinzhu/now v1.1.5 // indirect + github.com/jmespath/go-jmespath v0.4.0 // indirect + github.com/josharian/intern v1.0.0 // indirect + github.com/json-iterator/go v1.1.12 // indirect + github.com/kylelemons/godebug v1.1.0 // indirect + github.com/mailru/easyjson v0.7.7 // indirect + github.com/mattn/go-colorable v0.1.12 // indirect + github.com/mattn/go-isatty v0.0.16 // indirect + github.com/mattn/go-sqlite3 v1.14.24 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee // indirect + github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect + github.com/ncw/swift v1.0.53 // indirect + github.com/pelletier/go-toml v1.9.4 // indirect + github.com/pelletier/go-toml/v2 v2.0.0-beta.8 // indirect + github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect + github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect + github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect + github.com/prometheus/client_model v0.6.2 // indirect + github.com/prometheus/procfs v0.19.2 // indirect + github.com/rogpeppe/go-internal v1.14.1 // indirect + github.com/spf13/afero v1.10.0 // indirect + github.com/spf13/cast v1.4.1 // indirect + github.com/spf13/jwalterweatherman v1.1.0 // indirect + github.com/spiffe/go-spiffe/v2 v2.5.0 // indirect + github.com/stoewer/go-strcase v1.3.0 // indirect + github.com/stretchr/objx v0.5.3 // indirect + github.com/subosito/gotenv v1.2.0 // indirect + github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect + github.com/zeebo/errs v1.4.0 // indirect + go.etcd.io/etcd/api/v3 v3.5.9 // indirect + go.etcd.io/etcd/client/pkg/v3 v3.5.9 // indirect + go.etcd.io/etcd/client/v3 v3.5.9 // indirect + go.opentelemetry.io/auto/sdk v1.1.0 // indirect + go.opentelemetry.io/contrib/detectors/gcp v1.36.0 // indirect + go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.61.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.61.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.37.0 // indirect + go.opentelemetry.io/otel/metric v1.37.0 // indirect + go.opentelemetry.io/otel/sdk/metric v1.37.0 // indirect + go.opentelemetry.io/proto/otlp v1.7.1 // indirect + go.uber.org/mock v0.4.0 // indirect + go.uber.org/multierr v1.11.0 // indirect + go.uber.org/zap v1.27.0 // indirect + go.yaml.in/yaml/v2 v2.4.3 // indirect + golang.org/x/crypto v0.46.0 // indirect + golang.org/x/sync v0.19.0 // indirect + golang.org/x/sys v0.39.0 // indirect + golang.org/x/term v0.38.0 // indirect + golang.org/x/text v0.32.0 // indirect + golang.org/x/tools v0.40.0 // indirect + gomodules.xyz/jsonpatch/v2 v2.4.0 // indirect + google.golang.org/genproto v0.0.0-20251103181224-f26f9409b101 // indirect + gopkg.in/inf.v0 v0.9.1 // indirect + gopkg.in/ini.v1 v1.66.4 // indirect + gopkg.in/natefinch/lumberjack.v2 v2.2.1 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect + gorm.io/driver/mysql v1.5.6 // indirect + k8s.io/apiextensions-apiserver v0.34.1 // indirect + k8s.io/apiserver v0.34.1 // indirect + k8s.io/component-base v0.34.1 // indirect + k8s.io/kms v0.28.3 // indirect + k8s.io/kube-openapi v0.0.0-20250710124328-f3f2b991d03b // indirect + sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.31.2 // indirect + sigs.k8s.io/json v0.0.0-20241014173422-cfa47c3a1cc8 // indirect + sigs.k8s.io/structured-merge-diff/v4 v4.4.1 // indirect + sigs.k8s.io/yaml v1.6.0 // indirect +) + +replace ( + github.com/flyteorg/flyte/flyteidl => ./flyteidl2 + github.com/flyteorg/flyte/flyteplugins => ./flyteplugins + github.com/flyteorg/flyte/flytestdlib => ./flytestdlib + github.com/flyteorg/flyte/v2 => ./ + github.com/flyteorg/flyte/v2/flyteplugins => ./flyteplugins + github.com/flyteorg/flyte/v2/flytestdlib => ./flytestdlib + github.com/google/cel-go => github.com/google/cel-go v0.16.1 + github.com/google/gnostic-models => github.com/google/gnostic-models v0.6.8 + github.com/robfig/cron/v3 => github.com/unionai/cron/v3 v3.0.2-0.20220915080349-5790c370e63a + go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc => go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.54.0 + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp => go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0 + go.opentelemetry.io/otel => go.opentelemetry.io/otel v1.37.0 + go.opentelemetry.io/otel/exporters/otlp/otlptrace => go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.37.0 + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc => go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.37.0 + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp => go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.37.0 + go.opentelemetry.io/otel/exporters/stdout/stdouttrace => go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.37.0 + go.opentelemetry.io/otel/metric => go.opentelemetry.io/otel/metric v1.37.0 + go.opentelemetry.io/otel/sdk => go.opentelemetry.io/otel/sdk v1.37.0 + go.opentelemetry.io/otel/sdk/metric => go.opentelemetry.io/otel/sdk/metric v1.37.0 + go.opentelemetry.io/otel/trace => go.opentelemetry.io/otel/trace v1.37.0 + k8s.io/api => k8s.io/api v0.28.2 + k8s.io/apiextensions-apiserver => k8s.io/apiextensions-apiserver v0.28.2 + k8s.io/apimachinery => k8s.io/apimachinery v0.28.2 + k8s.io/apiserver => k8s.io/apiserver v0.28.2 + k8s.io/client-go => k8s.io/client-go v0.28.2 + k8s.io/component-base => k8s.io/component-base v0.28.2 + k8s.io/klog/v2 => k8s.io/klog/v2 v2.100.1 + k8s.io/kube-openapi => k8s.io/kube-openapi v0.0.0-20230905202853-d090da108d2f + k8s.io/utils => k8s.io/utils v0.0.0-20230726121419-3b25d923346b + sigs.k8s.io/controller-runtime => sigs.k8s.io/controller-runtime v0.16.3 +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000000..34d9288076 --- /dev/null +++ b/go.sum @@ -0,0 +1,1007 @@ +buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go v1.36.10-20250912141014-52f32327d4b0.1 h1:31on4W/yPcV4nZHL4+UCiCvLPsMqe/vJcNg8Rci0scc= +buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go v1.36.10-20250912141014-52f32327d4b0.1/go.mod h1:fUl8CEN/6ZAMk6bP8ahBJPUJw7rbp+j4x+wCcYi2IG4= +cel.dev/expr v0.24.0 h1:56OvJKSH3hDGL0ml5uSxZmz3/3Pq4tJ+fb1unVLAFcY= +cel.dev/expr v0.24.0/go.mod h1:hLPLo1W4QUmuYdA72RBX06QTs6MXw941piREPl3Yfiw= +cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= +cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= +cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= +cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= +cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= +cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4= +cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= +cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc= +cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk= +cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs= +cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc= +cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= +cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI= +cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk= +cloud.google.com/go v0.75.0/go.mod h1:VGuuCn7PG0dwsd5XPVm2Mm3wlh3EL55/79EKB6hlPTY= +cloud.google.com/go v0.121.6 h1:waZiuajrI28iAf40cWgycWNgaXPO06dupuS+sgibK6c= +cloud.google.com/go v0.121.6/go.mod h1:coChdst4Ea5vUpiALcYKXEpR1S9ZgXbhEzzMcMR66vI= +cloud.google.com/go/auth v0.16.4 h1:fXOAIQmkApVvcIn7Pc2+5J8QTMVbUGLscnSVNl11su8= +cloud.google.com/go/auth v0.16.4/go.mod h1:j10ncYwjX/g3cdX7GpEzsdM+d+ZNsXAbb6qXA7p1Y5M= +cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIiLpZnkHRbnc= +cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c= +cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= +cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= +cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= +cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= +cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= +cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= +cloud.google.com/go/compute/metadata v0.8.0 h1:HxMRIbao8w17ZX6wBnjhcDkW6lTFpgcaobyVfZWqRLA= +cloud.google.com/go/compute/metadata v0.8.0/go.mod h1:sYOGTp851OV9bOFJ9CH7elVvyzopvWQFNNghtDQ/Biw= +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/iam v1.5.3 h1:+vMINPiDF2ognBJ97ABAYYwRgsaqxPbQDlMnbHMjolc= +cloud.google.com/go/iam v1.5.3/go.mod h1:MR3v9oLkZCTlaqljW6Eb2d3HGDGK5/bDv93jhfISFvU= +cloud.google.com/go/logging v1.13.1 h1:O7LvmO0kGLaHY/gq8cV7T0dyp6zJhYAOtZPX4TF3QtY= +cloud.google.com/go/logging v1.13.1/go.mod h1:XAQkfkMBxQRjQek96WLPNze7vsOmay9H5PqfsNYDqvw= +cloud.google.com/go/longrunning v0.7.0 h1:FV0+SYF1RIj59gyoWDRi45GiYUMM3K1qO51qoboQT1E= +cloud.google.com/go/longrunning v0.7.0/go.mod h1:ySn2yXmjbK9Ba0zsQqunhDkYi0+9rlXIwnoAf+h+TPY= +cloud.google.com/go/monitoring v1.24.3 h1:dde+gMNc0UhPZD1Azu6at2e79bfdztVDS5lvhOdsgaE= +cloud.google.com/go/monitoring v1.24.3/go.mod h1:nYP6W0tm3N9H/bOw8am7t62YTzZY+zUeQ+Bi6+2eonI= +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/secretmanager v1.16.0 h1:19QT7ZsLJ8FSP1k+4esQvuCD7npMJml6hYzilxVyT+k= +cloud.google.com/go/secretmanager v1.16.0/go.mod h1://C/e4I8D26SDTz1f3TQcddhcmiC3rMEl0S1Cakvs3Q= +cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= +cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= +cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= +cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= +cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= +cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo= +cloud.google.com/go/storage v1.56.0 h1:iixmq2Fse2tqxMbWhLWC9HfBj1qdxqAmiK8/eqtsLxI= +cloud.google.com/go/storage v1.56.0/go.mod h1:Tpuj6t4NweCLzlNbw9Z9iwxEkrSem20AetIeH/shgVU= +cloud.google.com/go/trace v1.11.7 h1:kDNDX8JkaAG3R2nq1lIdkb7FCSi1rCmsEtKVsty7p+U= +cloud.google.com/go/trace v1.11.7/go.mod h1:TNn9d5V3fQVf6s4SCveVMIBS2LJUqo73GACmq/Tky0s= +connectrpc.com/connect v1.19.1 h1:R5M57z05+90EfEvCY1b7hBxDVOUl45PrtXtAV2fOC14= +connectrpc.com/connect v1.19.1/go.mod h1:tN20fjdGlewnSFeZxLKb0xwIZ6ozc3OQs2hTXy4du9w= +dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= +filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA= +filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.0 h1:Gt0j3wceWMwPmiazCa8MzMA0MfhmPIz0Qp0FJ6qcM0U= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.0/go.mod h1:Ot/6aikWnKWi4l9QB7qVSwa8iMphQNqkWALMoNT3rzM= +github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.10.1 h1:B+blDbyVIG3WaikNxPnhPiJ1MThR03b3vKGtER95TP4= +github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.10.1/go.mod h1:JdM5psgjfBf5fo2uWOZhflPWyDBZ/O/CNAH9CtsuZE4= +github.com/Azure/azure-sdk-for-go/sdk/azidentity/cache v0.3.2 h1:yz1bePFlP5Vws5+8ez6T3HWXPmwOK7Yvq8QxDBD3SKY= +github.com/Azure/azure-sdk-for-go/sdk/azidentity/cache v0.3.2/go.mod h1:Pa9ZNPuoNu/GztvBSKk9J1cDJW6vk/n0zLtV4mgd8N8= +github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.1 h1:FPKJS1T+clwv+OLGt13a8UjqeRuh0O4SJ3lUriThc+4= +github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.1/go.mod h1:j2chePtV91HrC22tGoRX3sGY42uF13WzmmV80/OdVAA= +github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.6.0 h1:PiSrjRPpkQNjrM8H0WwKMnZUdu1RGMtd/LdGKUrOo+c= +github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.6.0/go.mod h1:oDrbWx4ewMylP7xHivfgixbfGBT6APAwsSoHRKotnIc= +github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azsecrets v1.4.0 h1:/g8S6wk65vfC6m3FIxJ+i5QDyN9JWwXI8Hb0Img10hU= +github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azsecrets v1.4.0/go.mod h1:gpl+q95AzZlKVI3xSoseF9QPrypk0hQqBiJYeB/cR/I= +github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/internal v1.2.0 h1:nCYfgcSyHZXJI8J0IWE5MsCGlb2xp9fJiXyxWgmOFg4= +github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/internal v1.2.0/go.mod h1:ucUjca2JtSZboY8IoUqyQyuuXvwbMBVwFOm0vdQPNhA= +github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.4.0 h1:Be6KInmFEKV81c0pOAEbRYehLMwmmGI1exuFj248AMk= +github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.4.0/go.mod h1:WCPBHsOXfBVnivScjs2ypRfimjEW0qPVLGgJkZlrIOA= +github.com/AzureAD/microsoft-authentication-extensions-for-go/cache v0.1.1 h1:WJTmL004Abzc5wDB5VtZG2PJk5ndYDgVacGqfirKxjM= +github.com/AzureAD/microsoft-authentication-extensions-for-go/cache v0.1.1/go.mod h1:tCcJZ0uHAmvjsVYzEFivsRTN00oz5BEsRgQHu5JZ9WE= +github.com/AzureAD/microsoft-authentication-library-for-go v1.4.2 h1:oygO0locgZJe7PpYPXT5A29ZkwJaPqcva7BVeemZOZs= +github.com/AzureAD/microsoft-authentication-library-for-go v1.4.2/go.mod h1:wP83P5OoQ5p6ip3ScPr0BAq0BvuPAvacpEuSzyouqAI= +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= +github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.29.0 h1:UQUsRi8WTzhZntp5313l+CHIAT95ojUI2lpP/ExlZa4= +github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.29.0/go.mod h1:Cz6ft6Dkn3Et6l2v2a9/RpN7epQ1GtDlO6lj8bEcOvw= +github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.53.0 h1:owcC2UnmsZycprQ5RfRgjydWhuoxg71LUfyiQdijZuM= +github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.53.0/go.mod h1:ZPpqegjbE99EPKsu3iUWV22A04wzGPcAY/ziSIQEEgs= +github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/cloudmock v0.53.0 h1:4LP6hvB4I5ouTbGgWtixJhgED6xdf67twf9PoY96Tbg= +github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/cloudmock v0.53.0/go.mod h1:jUZ5LYlw40WMd07qxcQJD5M40aUxrfwqQX1g7zxYnrQ= +github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.53.0 h1:Ron4zCA/yk6U7WOBXhTJcDpsUBG9npumK6xw2auFltQ= +github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.53.0/go.mod h1:cSgYe11MCNYunTnRXrKiR/tHc0eoKjICUuWpNZoVCOo= +github.com/GoogleCloudPlatform/spark-on-k8s-operator v0.0.0-20200723154620-6f35a1152625 h1:cQyO5JQ2iuHnEcF3v24kdDMsgh04RjyFPDtuvD6PCE0= +github.com/GoogleCloudPlatform/spark-on-k8s-operator v0.0.0-20200723154620-6f35a1152625/go.mod h1:6PnrZv6zUDkrNMw0mIoGRmGBR7i9LulhKPmxFq4rUiM= +github.com/NYTimes/gziphandler v1.1.1 h1:ZUDjpQae29j0ryrS0u/B8HZfJBtBQHjqw2rQ2cqUQ3I= +github.com/NYTimes/gziphandler v1.1.1/go.mod h1:n/CVRwUEOgIxrgPvAQhUUr9oeUtvrhMomdKFjzJNB0c= +github.com/antlr/antlr4/runtime/Go/antlr/v4 v4.0.0-20230512164433-5d1fd1a340c9 h1:goHVqTbFX3AIo0tzGr14pgfAW2ZfPChKO21Z9MGf/gk= +github.com/antlr/antlr4/runtime/Go/antlr/v4 v4.0.0-20230512164433-5d1fd1a340c9/go.mod h1:pSwJ0fSY5KhvocuWSx4fz3BA8OrA1bQn+K1Eli3BRwM= +github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a h1:idn718Q4B6AGu/h5Sxe66HYVdqdGu2l9Iebqhi/AEoA= +github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY= +github.com/aws/aws-sdk-go v1.55.8 h1:JRmEUbU52aJQZ2AjX4q4Wu7t4uZjOu71uyNmaWlUkJQ= +github.com/aws/aws-sdk-go v1.55.8/go.mod h1:ZkViS9AqA6otK+JBBNH2++sx1sgxrPKcSzPPvQkUtXk= +github.com/aws/aws-sdk-go-v2 v1.41.1 h1:ABlyEARCDLN034NhxlRUSZr4l71mh+T5KAeGh6cerhU= +github.com/aws/aws-sdk-go-v2 v1.41.1/go.mod h1:MayyLB8y+buD9hZqkCW3kX1AKq07Y5pXxtgB+rRFhz0= +github.com/aws/aws-sdk-go-v2/config v1.26.1 h1:z6DqMxclFGL3Zfo+4Q0rLnAZ6yVkzCRxhRMsiRQnD1o= +github.com/aws/aws-sdk-go-v2/config v1.26.1/go.mod h1:ZB+CuKHRbb5v5F0oJtGdhFTelmrxd4iWO1lf0rQwSAg= +github.com/aws/aws-sdk-go-v2/credentials v1.16.12 h1:v/WgB8NxprNvr5inKIiVVrXPuuTegM+K8nncFkr1usU= +github.com/aws/aws-sdk-go-v2/credentials v1.16.12/go.mod h1:X21k0FjEJe+/pauud82HYiQbEr9jRKY3kXEIQ4hXeTQ= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.10 h1:w98BT5w+ao1/r5sUuiH6JkVzjowOKeOJRHERyy1vh58= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.10/go.mod h1:K2WGI7vUvkIv1HoNbfBA1bvIZ+9kL3YVmWxeKuLQsiw= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.17 h1:xOLELNKGp2vsiteLsvLPwxC+mYmO6OZ8PYgiuPJzF8U= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.17/go.mod h1:5M5CI3D12dNOtH3/mk6minaRwI2/37ifCURZISxA/IQ= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.17 h1:WWLqlh79iO48yLkj1v3ISRNiv+3KdQoZ6JWyfcsyQik= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.17/go.mod h1:EhG22vHRrvF8oXSTYStZhJc1aUgKtnJe+aOiFEV90cM= +github.com/aws/aws-sdk-go-v2/internal/ini v1.7.2 h1:GrSw8s0Gs/5zZ0SX+gX4zQjRnRsMJDJ2sLur1gRBhEM= +github.com/aws/aws-sdk-go-v2/internal/ini v1.7.2/go.mod h1:6fQQgfuGmw8Al/3M2IgIllycxV7ZW7WCdVSqfBeUiCY= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4 h1:/b31bi3YVNlkzkBrm9LfpaKoaYZUxIAj4sHfOTmLfqw= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4/go.mod h1:2aGXHFmbInwgP9ZfpmdIfOELL79zhdNYNmReK8qDfdQ= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.9 h1:Nf2sHxjMJR8CSImIVCONRi4g0Su3J+TSTbS7G0pUeMU= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.9/go.mod h1:idky4TER38YIjr2cADF1/ugFMKvZV7p//pVeV5LZbF0= +github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.41.1 h1:72DBkm/CCuWx2LMHAXvLDkZfzopT3psfAeyZDIt1/yE= +github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.41.1/go.mod h1:A+oSJxFvzgjZWkpM0mXs3RxB5O1SD6473w3qafOC9eU= +github.com/aws/aws-sdk-go-v2/service/sso v1.18.5 h1:ldSFWz9tEHAwHNmjx2Cvy1MjP5/L9kNoR0skc6wyOOM= +github.com/aws/aws-sdk-go-v2/service/sso v1.18.5/go.mod h1:CaFfXLYL376jgbP7VKC96uFcU8Rlavak0UlAwk1Dlhc= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.5 h1:2k9KmFawS63euAkY4/ixVNsYYwrwnd5fIvgEKkfZFNM= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.5/go.mod h1:W+nd4wWDVkSUIox9bacmkBP5NMFQeTJ/xqNabpzSR38= +github.com/aws/aws-sdk-go-v2/service/sts v1.26.5 h1:5UYvv8JUvllZsRnfrcMQ+hJ9jNICmcgKPAO1CER25Wg= +github.com/aws/aws-sdk-go-v2/service/sts v1.26.5/go.mod h1:XX5gh4CB7wAs4KhcF46G6C8a2i7eupU19dcAAE+EydU= +github.com/aws/smithy-go v1.24.0 h1:LpilSUItNPFr1eY85RYgTIg5eIEPtvFbskaFcmmIUnk= +github.com/aws/smithy-go v1.24.0/go.mod h1:LEj2LM3rBRQJxPZTB4KuzZkaZYnZPnvgIhb4pu07mx0= +github.com/benlaurie/objecthash v0.0.0-20180202135721-d1e3d6079fc1 h1:VRtJdDi2lqc3MFwmouppm2jlm6icF+7H3WYKpLENMTo= +github.com/benlaurie/objecthash v0.0.0-20180202135721-d1e3d6079fc1/go.mod h1:jvdWlw8vowVGnZqSDC7yhPd7AifQeQbRDkZcQXV2nRg= +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/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM= +github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ= +github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= +github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= +github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA= +github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0= +github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM= +github.com/cenkalti/backoff/v5 v5.0.3/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw= +github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cheekybits/is v0.0.0-20150225183255-68e9c0620927 h1:SKI1/fuSdodxmNNyVBR8d7X/HuLnRpvvFO0AgyQk764= +github.com/cheekybits/is v0.0.0-20150225183255-68e9c0620927/go.mod h1:h/aW8ynjgkuj+NQRlZcDbAbM1ORAbXjXX77sX7T289U= +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= +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-20250501225837-2ac532fd4443 h1:aQ3y1lwWyqYPiWZThqv1aFbZMiM9vblcSArJRf2Irls= +github.com/cncf/xds/go v0.0.0-20250501225837-2ac532fd4443/go.mod h1:W+zGtBO5Y1IgJhy4+A9GOqVhqLpfZi+vwmdNXUehLA8= +github.com/coocood/freecache v1.2.4 h1:UdR6Yz/X1HW4fZOuH0Z94KwG851GWOSknua5VUbb/5M= +github.com/coocood/freecache v1.2.4/go.mod h1:RBUWa/Cy+OHdfTGFEhEuE1pMCMX51Ncizj7rthiQ3vk= +github.com/coreos/go-semver v0.3.1 h1:yi21YpKnrx1gt5R+la8n5WgS0kCrsPp33dmEyHReZr4= +github.com/coreos/go-semver v0.3.1/go.mod h1:irMmmIw/7yzSRPWryHsK7EYSg09caPQL03VsM8rvUec= +github.com/coreos/go-systemd/v22 v22.5.0 h1:RrqgGjYQKalulkV8NGVIfkXQf6YYmOyiJKk8iXXhfZs= +github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= +github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g= +github.com/dask/dask-kubernetes/v2023 v2023.0.0-20230626103304-abd02cd17b26 h1:6RByIva89lKEvwIzNQSUNcu8NG1p1wwwC4mJfVk/kqw= +github.com/dask/dask-kubernetes/v2023 v2023.0.0-20230626103304-abd02cd17b26/go.mod h1:OqIYr2QnxR3sQK2XahJIyWVcjz38LQ4GNcUzqezFpRg= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= +github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/eko/gocache/lib/v4 v4.2.0 h1:MNykyi5Xw+5Wu3+PUrvtOCaKSZM1nUSVftbzmeC7Yuw= +github.com/eko/gocache/lib/v4 v4.2.0/go.mod h1:7ViVmbU+CzDHzRpmB4SXKyyzyuJ8A3UW3/cszpcqB4M= +github.com/eko/gocache/store/freecache/v4 v4.2.0 h1:MYiUyF5D3JsMfQAyURolH9AMJaBzhX36dEppbgYKbp4= +github.com/eko/gocache/store/freecache/v4 v4.2.0/go.mod h1:2w6a/5NPHIZIm27AGDKFphRqKygLGqlNt49wd3iXmdE= +github.com/eko/gocache/store/redis/v4 v4.2.0 h1:YguIDZuMeVFlQFi0DiYQpL7NvHAckinYFjWxvr0qmLw= +github.com/eko/gocache/store/redis/v4 v4.2.0/go.mod h1:IP4GWCjca/pyruK5GweTZ7zzoFlgQABd3cVMJFEgHfs= +github.com/emicklei/go-restful/v3 v3.12.2 h1:DhwDP0vY3k8ZzE0RunuJy8GhNpPL6zqLkDf9B/a0/xU= +github.com/emicklei/go-restful/v3 v3.12.2/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc= +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.13.4 h1:zEqyPVyku6IvWCFwux4x9RxkLOMUL+1vC9xUFv5l2/M= +github.com/envoyproxy/go-control-plane v0.13.4/go.mod h1:kDfuBlDVsSj2MjrLEtRWtHlsWIFcGyB2RMO44Dc5GZA= +github.com/envoyproxy/go-control-plane/envoy v1.32.4 h1:jb83lalDRZSpPWW2Z7Mck/8kXZ5CQAFYVjQcdVIr83A= +github.com/envoyproxy/go-control-plane/envoy v1.32.4/go.mod h1:Gzjc5k8JcJswLjAx1Zm+wSYE20UrLtt7JZMWiWQXQEw= +github.com/envoyproxy/go-control-plane/ratelimit v0.1.0 h1:/G9QYbddjL25KvtKTv3an9lx6VBE2cnb8wp1vEGNYGI= +github.com/envoyproxy/go-control-plane/ratelimit v0.1.0/go.mod h1:Wk+tMFAFbCXaJPzVVHnPgRKdUdwW/KdbRt94AzgRee4= +github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= +github.com/envoyproxy/protoc-gen-validate v1.2.1 h1:DEo3O99U8j4hBFwbJfrz9VtgcDfUKS7KJ7spH3d86P8= +github.com/envoyproxy/protoc-gen-validate v1.2.1/go.mod h1:d/C80l/jxXLdfEIhX1W2TmLfsJ31lvEjwamM4DxlWXU= +github.com/evanphx/json-patch v5.6.0+incompatible h1:jBYDEEiFBPxA0v50tFdvOzQQTCvpL6mnFh5mB2/l16U= +github.com/evanphx/json-patch v5.6.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= +github.com/evanphx/json-patch/v5 v5.9.11 h1:/8HVnzMq13/3x9TPvjG08wUGqBTmZBsCWzjTM0wiaDU= +github.com/evanphx/json-patch/v5 v5.9.11/go.mod h1:3j+LviiESTElxA4p3EMKAB9HXj3/XEtnUf6OZxqIQTM= +github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w= +github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= +github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= +github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/flyteorg/stow v0.3.12 h1:RRXI5RUdxaK6A46HrO0D2r14cRlW1lJRL6qyzqpVMPU= +github.com/flyteorg/stow v0.3.12/go.mod h1:nyaBf8ZWkpHWkKIl4rqKI2uXfPx+VbL0PmEtvq4Pxkc= +github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k= +github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0= +github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= +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= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/go-gormigrate/gormigrate/v2 v2.1.5 h1:1OyorA5LtdQw12cyJDEHuTrEV3GiXiIhS4/QTTa/SM8= +github.com/go-gormigrate/gormigrate/v2 v2.1.5/go.mod h1:mj9ekk/7CPF3VjopaFvWKN2v7fN3D9d3eEOAXRhi/+M= +github.com/go-jose/go-jose/v4 v4.1.2 h1:TK/7NqRQZfgAh+Td8AlsrvtPoUyiHh0LqVvokh+1vHI= +github.com/go-jose/go-jose/v4 v4.1.2/go.mod h1:22cg9HWM1pOlnRiY+9cQYJ9XHmya1bYW8OeDM6Ku6Oo= +github.com/go-logr/logr v1.2.0/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= +github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/go-logr/zapr v1.3.0 h1:XGdV8XW8zdwFiwOA2Dryh1gj2KRQyOOoNmBy4EplIcQ= +github.com/go-logr/zapr v1.3.0/go.mod h1:YKepepNBd1u/oyhd/yQmtjVXmm9uML4IXUgMOwR8/Gg= +github.com/go-openapi/jsonpointer v0.21.0 h1:YgdVicSA9vH5RiHs9TZW5oyafXZFc6+2Vc1rr/O9oNQ= +github.com/go-openapi/jsonpointer v0.21.0/go.mod h1:IUyH9l/+uyhIYQ/PXVA41Rexl+kOkAPDdXEYns6fzUY= +github.com/go-openapi/jsonreference v0.21.0 h1:Rs+Y7hSXT83Jacb7kFyjn4ijOuVGSvOdF2+tg1TRrwQ= +github.com/go-openapi/jsonreference v0.21.0/go.mod h1:LmZmgsrTkVg9LG4EaHeY8cBDslNPMo06cago5JNLkm4= +github.com/go-openapi/swag v0.23.0 h1:vsEVJDUo2hPJ2tu0/Xc+4noaxyEffXNIs3cOULZ+GrE= +github.com/go-openapi/swag v0.23.0/go.mod h1:esZ8ITTYEsH1V2trKHjAN8Ai7xHb8RV+YSZ577vPjgQ= +github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI= +github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y= +github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg= +github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI= +github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8= +github.com/go-test/deep v1.1.1 h1:0r/53hagsehfO4bzD2Pgr/+RgHqhmf+k1Bpse2cTu1U= +github.com/go-test/deep v1.1.1/go.mod h1:5C2ZWiW0ErCdrYzpqxLbTX7MG14M9iiw8DgHncVwcsE= +github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg= +github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= +github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo= +github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE= +github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 h1:au07oEsX2xN0ktxqI+Sida1w446QrXBRJ0nee3SNZlA= +github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0= +github.com/golang-sql/sqlexp v0.1.0 h1:ZCD6MBpcuOVfGVqsEmY5/4FtYiKz6tSyUv9LPEDei6A= +github.com/golang-sql/sqlexp v0.1.0/go.mod h1:J4ad9Vo8ZCWQ2GMrC4UCQy1JpCbwU9m3EOqtpKwwwHI= +github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE= +github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= +github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= +github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= +github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk= +github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= +github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= +github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= +github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= +github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +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.1.3 h1:CVpQJjYgC4VbzxeGVHfvZrv1ctoYCAI8vbl07Fcxlyg= +github.com/google/btree v1.1.3/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4= +github.com/google/cel-go v0.16.1 h1:3hZfSNiAU3KOiNtxuFXVp5WFy4hf/Ly3Sa4/7F8SXNo= +github.com/google/cel-go v0.16.1/go.mod h1:HXZKzB0LXqer5lHHgfWAnlYwJaQBDKMjxjulNQzhwhY= +github.com/google/gnostic-models v0.6.8 h1:yo/ABAfM5IMRsS1VnXjTBvUb61tFIHozhlYvRgGre9I= +github.com/google/gnostic-models v0.6.8/go.mod h1:5n7qKqH0f5wFt+aWF8CW6pZLLNOfYuF5OpfBSENuI8U= +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.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= +github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/martian v2.1.0+incompatible h1:/CP5g8u/VJHijgedC/Legn3BAbAaWPgecwXBIDzw5no= +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/martian/v3 v3.3.3 h1:DIhPTQrbPkgs2yJYdXU/eNACCG5DVQjySNRNlflZ9Fc= +github.com/google/martian/v3 v3.3.3/go.mod h1:iEPrYcgCF7jA9OtScMFQyAlZZ4YXTKEtJ1E6RWzmBA0= +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-20201218002935-b9804c9f04c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db h1:097atOisP2aRj7vFgYQBbFN4U4JNXUNYpxael3UzMyo= +github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db/go.mod h1:vavhavw2zAxS5dIdcRluK6cSGGPlZynqzFM8NdvU144= +github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= +github.com/google/s2a-go v0.1.9 h1:LGD7gtMgezd8a/Xak7mEWL0PjoTQFvpRudN895yqKW0= +github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0dXayM= +github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/googleapis/enterprise-certificate-proxy v0.3.6 h1:GW/XbdyBFQ8Qe+YAmFU9uHLo7OnF5tL52HFAgMmyrf4= +github.com/googleapis/enterprise-certificate-proxy v0.3.6/go.mod h1:MkHOF77EYAE7qfSuSS9PU6g4Nt4e11cnsDUowfwewLA= +github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= +github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= +github.com/googleapis/gax-go/v2 v2.15.0 h1:SyjDc1mGgZU5LncH8gimWo9lW1DtIfPibOG81vgd/bo= +github.com/googleapis/gax-go/v2 v2.15.0/go.mod h1:zVVkkxAQHa1RQpg9z2AUCMnKhi0Qld9rcmyfL1OZhoc= +github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g= +github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc= +github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 h1:+9834+KizmvFV7pXQGSXQTsaWhq2GjuNUt0aUU0YBYw= +github.com/grpc-ecosystem/go-grpc-middleware v1.3.0/go.mod h1:z0ButlSOZa5vEBq9m2m2hlwIgKw+rp3sdCBRoJY+30Y= +github.com/grpc-ecosystem/go-grpc-middleware/providers/prometheus v1.1.0 h1:QGLs/O40yoNK9vmy4rhUGBVyMf1lISBGtXRpsu/Qu/o= +github.com/grpc-ecosystem/go-grpc-middleware/providers/prometheus v1.1.0/go.mod h1:hM2alZsMUni80N33RBe6J0e423LB+odMj7d3EMP9l20= +github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0 h1:pRhl55Yx1eC7BZ1N+BBWwnKaMyD8uC+34TLdndZMAKk= +github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0/go.mod h1:XKMd7iuf/RGPSMJ/U4HP0zS2Z9Fh8Ps9a+6X26m/tmI= +github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0 h1:Ovs26xHkKqVztRpIrF/92BcuyuQ/YW4NSIpoGtfXNho= +github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk= +github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo= +github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3 h1:NmZ1PKzSTQbuGHw9DGPFomqkkLWMC+vZCkfs+FHv1Vg= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3/go.mod h1:zQrxl1YP88HQlA6i9c63DSVPFklWpGX4OWAc9bFuaH4= +github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc= +github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= +github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= +github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= +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.16 h1:wwQJbIsHYGMUyLSPrEq1CT16AhnhNJQ51+4fdHUnCl4= +github.com/imdario/mergo v0.3.16/go.mod h1:WBLT9ZmE3lPoWsEzCh9LPo3TiwVN+ZKEjmz+hD27ysY= +github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= +github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/jackc/chunkreader/v2 v2.0.0/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk= +github.com/jackc/chunkreader/v2 v2.0.1 h1:i+RDz65UE+mmpjTfyz0MoVTnzeYxroil2G82ki7MGG8= +github.com/jackc/chunkreader/v2 v2.0.1/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk= +github.com/jackc/pgconn v1.14.3 h1:bVoTr12EGANZz66nZPkMInAV/KHD2TxH9npjXXgiB3w= +github.com/jackc/pgconn v1.14.3/go.mod h1:RZbme4uasqzybK2RK5c65VsHxoyaml09lx3tXOcO/VM= +github.com/jackc/pgio v1.0.0 h1:g12B9UwVnzGhueNavwioyEEpAmqMe1E/BN9ES+8ovkE= +github.com/jackc/pgio v1.0.0/go.mod h1:oP+2QK2wFfUWgr+gxjoBH9KGBb31Eio69xUb0w5bYf8= +github.com/jackc/pgmock v0.0.0-20210724152146-4ad1a8207f65 h1:DadwsjnMwFjfWc9y5Wi/+Zz7xoE5ALHsRQlOctkOiHc= +github.com/jackc/pgmock v0.0.0-20210724152146-4ad1a8207f65/go.mod h1:5R2h2EEX+qri8jOWMbJCtaPWkrrNc7OHwsp2TCqp7ak= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgproto3/v2 v2.3.3 h1:1HLSx5H+tXR9pW3in3zaztoEwQYRC9SQaYUHjTSUOag= +github.com/jackc/pgproto3/v2 v2.3.3/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.7.6 h1:rWQc5FwZSPX58r1OQmkuaNicxdmExaEz5A2DO2hUuTk= +github.com/jackc/pgx/v5 v5.7.6/go.mod h1:aruU7o91Tc2q2cFp5h4uP3f6ztExVpyVv88Xl/8Vl8M= +github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= +github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= +github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= +github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= +github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= +github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg= +github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= +github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8= +github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= +github.com/jonboulle/clockwork v0.2.2 h1:UOGuzwb1PwsrDAObMuhUnj0p5ULPj8V/xJ7Kx9qUBdQ= +github.com/jonboulle/clockwork v0.2.2/go.mod h1:Pkfl5aHPm1nk2H9h0bjmnJD/BcgbGXUBGnn1kMkgxc8= +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.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/keybase/go-keychain v0.0.1 h1:way+bWYa6lDppZoZcgMbYsvC7GxljxrskdNInRtuthU= +github.com/keybase/go-keychain v0.0.1/go.mod h1:PdEILRW3i9D8JcdM+FmY6RwkHGnhHxXwkPPMeUgOK1k= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= +github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= +github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/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/kubeflow/training-operator v1.9.3 h1:aaSHqskOtCY8Dn8sVd+l9p5XAczW6O0nYMPjVLAw/lc= +github.com/kubeflow/training-operator v1.9.3/go.mod h1:6zI0hgeCOheiW5Z12IcVkKBuSWm714fz8mUvYu4Fid4= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw= +github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= +github.com/magiconair/properties v1.8.6 h1:5ibWZ6iY0NctNGWo87LalDlEZ6R41TqbbDamhfG/Qzo= +github.com/magiconair/properties v1.8.6/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60= +github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0= +github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= +github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= +github.com/mattn/go-colorable v0.1.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40= +github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= +github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= +github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= +github.com/mattn/go-isatty v0.0.16 h1:bq3VjFmv/sOjHtdEhmkEV4x1AJtvUvOJ2PFAZ5+peKQ= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-sqlite3 v1.14.24 h1:tpSp2G2KyMnnQu99ngJ47EIkWVmliIizyZBfPrBWDRM= +github.com/mattn/go-sqlite3 v1.14.24/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y= +github.com/microsoft/go-mssqldb v1.7.2 h1:CHkFJiObW7ItKTJfHo1QX7QBBD1iV+mn1eOyRP3b/PA= +github.com/microsoft/go-mssqldb v1.7.2/go.mod h1:kOvZKUdrhhFQmxLZqbwUV0rHkNkZpthMITIb2Ko1IoA= +github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= +github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/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 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee h1:W5t00kpgFdJifH4BDsTlE89Zl93FEloxaWZfGcifgq8= +github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= +github.com/ncw/swift v1.0.53 h1:luHjjTNtekIEvHg5KdAFIBaH7bWfNkefwFnpDffSIks= +github.com/ncw/swift v1.0.53/go.mod h1:23YIA4yWVnGwv2dQlN4bB7egfYX6YLn0Yo/S6zZO/ZM= +github.com/onsi/ginkgo/v2 v2.22.0 h1:Yed107/8DjTr0lKCNt7Dn8yQ6ybuDRQoMGrNFKzMfHg= +github.com/onsi/ginkgo/v2 v2.22.0/go.mod h1:7Du3c42kxCUegi0IImZ1wUQzMBVecgIHjR1C+NkhLQo= +github.com/onsi/gomega v1.36.1 h1:bJDPBO7ibjxcbHMgSCoo4Yj18UWbKDlLwX1x9sybDcw= +github.com/onsi/gomega v1.36.1/go.mod h1:PvZbdDc8J6XJEpDK4HCuRBm8a6Fzp9/DmhC9C7yFlog= +github.com/pelletier/go-toml v1.9.4 h1:tjENF6MfZAg8e4ZmZTeWaWiT2vXtsoO6+iuOjFhECwM= +github.com/pelletier/go-toml v1.9.4/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= +github.com/pelletier/go-toml/v2 v2.0.0-beta.8 h1:dy81yyLYJDwMTifq24Oi/IslOslRrDSb3jwDggjz3Z0= +github.com/pelletier/go-toml/v2 v2.0.0-beta.8/go.mod h1:r9LEWfGN8R5k0VXJ+0BkIe7MYkRdwZOjgMj2KwnJFUo= +github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ= +github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU= +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.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg= +github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo= +github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= +github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg= +github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= +github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= +github.com/prometheus/common v0.67.4 h1:yR3NqWO1/UyO1w2PhUvXlGQs/PtFmoveVO0KZ4+Lvsc= +github.com/prometheus/common v0.67.4/go.mod h1:gP0fq6YjjNCLssJCQp0yk4M8W6ikLURwkdd/YKtTbyI= +github.com/prometheus/procfs v0.19.2 h1:zUMhqEW66Ex7OXIiDkll3tl9a1ZdilUOd/F6ZXw4Vws= +github.com/prometheus/procfs v0.19.2/go.mod h1:M0aotyiemPhBCM0z5w87kL22CxfcH05ZpYlu+b4J7mw= +github.com/ray-project/kuberay/ray-operator v1.1.0-rc.1 h1:skD8MXnQMO3QGUeTKt09VOXvuch/gJh8+6q3OLm0kAQ= +github.com/ray-project/kuberay/ray-operator v1.1.0-rc.1/go.mod h1:ZqyKKvMP5nKDldQoKmur+Wcx7wVlV9Q98phFqHzr+KY= +github.com/redis/go-redis/extra/redisprometheus/v9 v9.17.2 h1:0c8P2OMKaMFMMA7ve1SJPUXVsI9urJMO6BNVZzgKNJY= +github.com/redis/go-redis/extra/redisprometheus/v9 v9.17.2/go.mod h1:cncJRRYpIpSRR2zyFcXjC9mSULvKWAfOOGnyQi6z1mQ= +github.com/redis/go-redis/v9 v9.17.2 h1:P2EGsA4qVIM3Pp+aPocCJ7DguDHhqrXNhVcEp4ViluI= +github.com/redis/go-redis/v9 v9.17.2/go.mod h1:u410H11HMLoB+TP67dz8rL9s6QW2j76l0//kSOd3370= +github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= +github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/samber/lo v1.39.0 h1:4gTz1wUhNYLhFSKl6O+8peW0v2F4BCY034GRpU9WnuA= +github.com/samber/lo v1.39.0/go.mod h1:+m/ZKRl6ClXCE2Lgf3MsQlWfh4bn1bz6CXEOxnEXnEA= +github.com/shamaton/msgpack/v2 v2.4.0 h1:O5Z08MRmbo0lA9o2xnQ4TXx6teJbPqEurqcCOQ8Oi/4= +github.com/shamaton/msgpack/v2 v2.4.0/go.mod h1:6khjYnkx73f7VQU7wjcFS9DFjs+59naVWJv1TB7qdOI= +github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= +github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= +github.com/soheilhy/cmux v0.1.5 h1:jjzc5WVemNEDTLwv9tlmemhC73tI08BNOIGwBOo10Js= +github.com/soheilhy/cmux v0.1.5/go.mod h1:T7TcVDs9LWfQgPlPsdngu6I6QIoyIFZDDC6sNE1GqG0= +github.com/spf13/afero v1.10.0 h1:EaGW2JJh15aKOejeuJ+wpFSHnbd7GE6Wvp3TsNhb6LY= +github.com/spf13/afero v1.10.0/go.mod h1:UBogFpq8E9Hx+xc5CNTTEpTnuHVmXDwZcZcE1eb/UhQ= +github.com/spf13/cast v1.4.1 h1:s0hze+J0196ZfEMTs80N7UlFt0BDuQ7Q+JDnHiMWKdA= +github.com/spf13/cast v1.4.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= +github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo= +github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0= +github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk= +github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= +github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o= +github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/spf13/viper v1.11.0 h1:7OX/1FS6n7jHD1zGrZTM7WtY13ZELRyosK4k93oPr44= +github.com/spf13/viper v1.11.0/go.mod h1:djo0X/bA5+tYVoCn+C7cAYJGcVn/qYLFTG8gdUsX7Zk= +github.com/spiffe/go-spiffe/v2 v2.5.0 h1:N2I01KCUkv1FAjZXJMwh95KK1ZIQLYbPfhaxw8WS0hE= +github.com/spiffe/go-spiffe/v2 v2.5.0/go.mod h1:P+NxobPc6wXhVtINNtFjNWGBTreew1GBUCwT2wPmb7g= +github.com/stoewer/go-strcase v1.3.0 h1:g0eASXYtp+yvN9fK8sH94oCIk0fau9uV1/ZdJ0AVEzs= +github.com/stoewer/go-strcase v1.3.0/go.mod h1:fAH5hQ5pehh+j3nZfvwdk2RgEgQjAoM8wodgtPmh1xo= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4= +github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/subosito/gotenv v1.2.0 h1:Slr1R9HxAlEKefgq5jn9U+DnETlIUa6HfgEzj0g5d7s= +github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw= +github.com/tmc/grpc-websocket-proxy v0.0.0-20220101234140-673ab2c3ae75 h1:6fotK7otjonDflCTK0BCfls4SPy3NcCVb5dqqmbRknE= +github.com/tmc/grpc-websocket-proxy v0.0.0-20220101234140-673ab2c3ae75/go.mod h1:KO6IkyS8Y3j8OdNO85qEYBsRPuteD+YciPomcXdrMnk= +github.com/vmihailenco/msgpack/v5 v5.4.1 h1:cQriyiUvjTwOHg8QZaPihLWeRAAVoCpE00IUPn0Bjt8= +github.com/vmihailenco/msgpack/v5 v5.4.1/go.mod h1:GaZTsDaehaPpQVyxrf5mtQlH+pc21PIudVV/E3rRQok= +github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g= +github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds= +github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2 h1:eY9dn8+vbi4tKz5Qo6v2eYzo7kUS51QINcR5jNpbZS8= +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/zeebo/errs v1.4.0 h1:XNdoD/RRMKP7HD0UhJnIzUy74ISdGGxURlYG8HSWSfM= +github.com/zeebo/errs v1.4.0/go.mod h1:sgbWHsvVuTPHcqJJGQ1WhI5KbWlHYz+2+2C/LSEtCw4= +go.etcd.io/bbolt v1.3.7 h1:j+zJOnnEjF/kyHlDDgGnVL/AIqIJPq8UoB2GSNfkUfQ= +go.etcd.io/bbolt v1.3.7/go.mod h1:N9Mkw9X8x5fupy0IKsmuqVtoGDyxsaDlbk4Rd05IAQw= +go.etcd.io/etcd/api/v3 v3.5.9 h1:4wSsluwyTbGGmyjJktOf3wFQoTBIURXHnq9n/G/JQHs= +go.etcd.io/etcd/api/v3 v3.5.9/go.mod h1:uyAal843mC8uUVSLWz6eHa/d971iDGnCRpmKd2Z+X8k= +go.etcd.io/etcd/client/pkg/v3 v3.5.9 h1:oidDC4+YEuSIQbsR94rY9gur91UPL6DnxDCIYd2IGsE= +go.etcd.io/etcd/client/pkg/v3 v3.5.9/go.mod h1:y+CzeSmkMpWN2Jyu1npecjB9BBnABxGM4pN8cGuJeL4= +go.etcd.io/etcd/client/v2 v2.305.9 h1:YZ2OLi0OvR0H75AcgSUajjd5uqKDKocQUqROTG11jIo= +go.etcd.io/etcd/client/v2 v2.305.9/go.mod h1:0NBdNx9wbxtEQLwAQtrDHwx58m02vXpDcgSYI2seohQ= +go.etcd.io/etcd/client/v3 v3.5.9 h1:r5xghnU7CwbUxD/fbUtRyJGaYNfDun8sp/gTr1hew6E= +go.etcd.io/etcd/client/v3 v3.5.9/go.mod h1:i/Eo5LrZ5IKqpbtpPDuaUnDOUv471oDg8cjQaUr2MbA= +go.etcd.io/etcd/pkg/v3 v3.5.9 h1:6R2jg/aWd/zB9+9JxmijDKStGJAPFsX3e6BeJkMi6eQ= +go.etcd.io/etcd/pkg/v3 v3.5.9/go.mod h1:BZl0SAShQFk0IpLWR78T/+pyt8AruMHhTNNX73hkNVY= +go.etcd.io/etcd/raft/v3 v3.5.9 h1:ZZ1GIHoUlHsn0QVqiRysAm3/81Xx7+i2d7nSdWxlOiI= +go.etcd.io/etcd/raft/v3 v3.5.9/go.mod h1:WnFkqzFdZua4LVlVXQEGhmooLeyS7mqzS4Pf4BCVqXg= +go.etcd.io/etcd/server/v3 v3.5.9 h1:vomEmmxeztLtS5OEH7d0hBAg4cjVIu9wXuNzUZx2ZA0= +go.etcd.io/etcd/server/v3 v3.5.9/go.mod h1:GgI1fQClQCFIzuVjlvdbMxNbnISt90gdfYyqiAIt65g= +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.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA= +go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= +go.opentelemetry.io/contrib/detectors/gcp v1.36.0 h1:F7q2tNlCaHY9nMKHR6XH9/qkp8FktLnIcy6jJNyOCQw= +go.opentelemetry.io/contrib/detectors/gcp v1.36.0/go.mod h1:IbBN8uAIIx734PTonTPxAxnjc2pQTxWNkwfstZ+6H2k= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.54.0 h1:r6I7RJCN86bpD/FQwedZ0vSixDpwuWREjW9oRMsmqDc= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.54.0/go.mod h1:B9yO6b04uB80CzjedvewuqDhxJxi11s7/GtiGa8bAjI= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0 h1:TT4fX+nBOA/+LUkobKGW1ydGcn+G3vRw9+g5HwCphpk= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0/go.mod h1:L7UH0GbB0p47T4Rri3uHjbpCFYrVrwc1I25QhNPiGK8= +go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ= +go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I= +go.opentelemetry.io/otel/exporters/jaeger v1.17.0 h1:D7UpUy2Xc2wsi1Ras6V40q806WM07rqoCWzXu7Sqy+4= +go.opentelemetry.io/otel/exporters/jaeger v1.17.0/go.mod h1:nPCqOnEH9rNLKqH/+rrUjiMzHJdV1BlpKcTwRTyKkKI= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.37.0 h1:Ahq7pZmv87yiyn3jeFz/LekZmPLLdKejuO3NcK9MssM= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.37.0/go.mod h1:MJTqhM0im3mRLw1i8uGHnCvUEeS7VwRyxlLC78PA18M= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.37.0 h1:EtFWSnwW9hGObjkIdmlnWSydO+Qs8OwzfzXLUPg4xOc= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.37.0/go.mod h1:QjUEoiGCPkvFZ/MjK6ZZfNOS6mfVEVKYE99dFhuN2LI= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.37.0 h1:bDMKF3RUSxshZ5OjOTi8rsHGaPKsAt76FaqgvIUySLc= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.37.0/go.mod h1:dDT67G/IkA46Mr2l9Uj7HsQVwsjASyV9SjGofsiUZDA= +go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.36.0 h1:rixTyDGXFxRy1xzhKrotaHy3/KXdPhlWARrCgK+eqUY= +go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.36.0/go.mod h1:dowW6UsM9MKbJq5JTz2AMVp3/5iW5I/TStsk8S+CfHw= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.37.0 h1:SNhVp/9q4Go/XHBkQ1/d5u9P/U+L1yaGPoi0x+mStaI= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.37.0/go.mod h1:tx8OOlGH6R4kLV67YaYO44GFXloEjGPZuMjEkaaqIp4= +go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE= +go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E= +go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI= +go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg= +go.opentelemetry.io/otel/sdk/metric v1.37.0 h1:90lI228XrB9jCMuSdA0673aubgRobVZFhbjxHHspCPc= +go.opentelemetry.io/otel/sdk/metric v1.37.0/go.mod h1:cNen4ZWfiD37l5NhS+Keb5RXVWZWpRE+9WyVCpbo5ps= +go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4= +go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0= +go.opentelemetry.io/proto/otlp v1.7.1 h1:gTOMpGDb0WTBOP8JaO72iL3auEZhVmAQg4ipjOVAtj4= +go.opentelemetry.io/proto/otlp v1.7.1/go.mod h1:b2rVh6rfI/s2pHWNlB7ILJcRALpcNDzKhACevjI+ZnE= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU= +go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= +go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= +go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= +go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= +go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= +go.yaml.in/yaml/v2 v2.4.3 h1:6gvOSjQoTB3vt1l+CU+tSyi/HOjfOjRLJ4YwYZGwRO0= +go.yaml.in/yaml/v2 v2.4.3/go.mod h1:zSxWcmIDjOzPXpjlTTbAsKokqkDNAVtZO0WOMiT90s8= +go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= +go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= +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-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-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= +golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/crypto v0.46.0 h1:cKRW/pmt1pKAfetfu+RCEvjvZkA9RimPbh7bhFjGVBU= +golang.org/x/crypto v0.46.0/go.mod h1:Evb/oLKmMraqjZ2iQTwDwvCtJkczlDuTmdJXoZVzqU0= +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= +golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek= +golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= +golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= +golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= +golang.org/x/exp v0.0.0-20251209150349-8475f28825e9 h1:MDfG8Cvcqlt9XXrmEiD4epKn7VJHZO84hejP9Jmp0MM= +golang.org/x/exp v0.0.0-20251209150349-8475f28825e9/go.mod h1:EPRbTFwzwjXj9NpYyyrvenVh9Y+GFeEvMNh7Xuz7xgU= +golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= +golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= +golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs= +golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= +golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= +golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= +golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= +golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= +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-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-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-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.48.0 h1:zyQRTTrjc33Lhh0fBgT/H3oZq9WuvRR5gPC70xpDiQU= +golang.org/x/net v0.48.0/go.mod h1:+ndRgGjkh8FGtu1w1FGbEC31if4VrNVMuKTgcAAnQRY= +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/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.32.0 h1:jsCblLleRMDrxMN29H3z/k1KliIvpLgCkE6R8FXXNgY= +golang.org/x/oauth2 v0.32.0/go.mod h1:lzm5WQJQwKZ3nwavOZ3IS5Aulzxi68dUSgRHujetwEA= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4= +golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= +golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/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-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-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-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-20191001151750-bb3f8db39f24/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-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= +golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/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-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/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-20210615035016-665e8c7367d1/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-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk= +golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.38.0 h1:PQ5pkm/rLO6HnxFR7N2lJHOZX6Kez5Y1gDSJla6jo7Q= +golang.org/x/term v0.38.0/go.mod h1:bSEAKrOT1W+VSu9TSCMtoGEOUcKxOKgl3LE5QEF/xVg= +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.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU= +golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY= +golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE= +golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg= +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= +golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-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-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-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-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-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= +golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.40.0 h1:yLkxfA+Qnul4cs9QA3KnlFu0lVmd8JJfoq+E41uSutA= +golang.org/x/tools v0.40.0/go.mod h1:Ik/tzLRlbscWpqqMRjyWYDisX8bG13FrdXp3o4Sr9lc= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +gomodules.xyz/jsonpatch/v2 v2.4.0 h1:Ci3iUJyx9UeRx7CeFN8ARgGbkESwJK+KB9lLcWxY/Zw= +gomodules.xyz/jsonpatch/v2 v2.4.0/go.mod h1:AH3dM2RI6uoBZxn3LVrfvJ3E0/9dG4cSrbuBJT4moAY= +gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk= +gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E= +google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= +google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= +google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.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.247.0 h1:tSd/e0QrUlLsrwMKmkbQhYVa109qIintOls2Wh6bngc= +google.golang.org/api v0.247.0/go.mod h1:r1qZOPmxXffXg6xS5uhx16Fa/UFY8QU/K4bfKrnvovM= +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/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8= +google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA= +google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-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-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-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-20210108203827-ffc7fda8c3d7/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20251103181224-f26f9409b101 h1:MgBTzgUJFAmp2PlyqKJecSpZpjFxkYL3nDUIeH/6Q30= +google.golang.org/genproto v0.0.0-20251103181224-f26f9409b101/go.mod h1:bbWg36d7wp3knc0hIlmJAnW5R/CQ2rzpEVb72eH4ex4= +google.golang.org/genproto/googleapis/api v0.0.0-20251103181224-f26f9409b101 h1:vk5TfqZHNn0obhPIYeS+cxIFKFQgser/M2jnI+9c6MM= +google.golang.org/genproto/googleapis/api v0.0.0-20251103181224-f26f9409b101/go.mod h1:E17fc4PDhkr22dE3RgnH2hEubUaky6ZwW4VhANxyspg= +google.golang.org/genproto/googleapis/rpc v0.0.0-20251103181224-f26f9409b101 h1:tRPGkdGHuewF4UisLzzHHr1spKw92qLM98nIzxbC0wY= +google.golang.org/genproto/googleapis/rpc v0.0.0-20251103181224-f26f9409b101/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk= +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= +google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= +google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= +google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= +google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= +google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.33.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.76.0 h1:UnVkv1+uMLYXoIz6o7chp59WfQUYA2ex/BXQ9rHZu7A= +google.golang.org/grpc v1.76.0/go.mod h1:Ju12QI8M6iQJtbcsV+awF5a4hfJMLi4X0JLo94ULZ6c= +google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= +google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= +google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= +google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= +google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= +google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= +google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE= +google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +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-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= +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.66.4 h1:SsAcf+mM7mRZo2nJNGt8mZCjG8ZRaNGMURJw7BsIST4= +gopkg.in/ini.v1 v1.66.4/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc= +gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gorm.io/datatypes v1.2.7 h1:ww9GAhF1aGXZY3EB3cJPJ7//JiuQo7DlQA7NNlVaTdk= +gorm.io/datatypes v1.2.7/go.mod h1:M2iO+6S3hhi4nAyYe444Pcb0dcIiOMJ7QHaUXxyiNZY= +gorm.io/driver/mysql v1.5.6 h1:Ld4mkIickM+EliaQZQx3uOJDJHtrd70MxAUqWqlx3Y8= +gorm.io/driver/mysql v1.5.6/go.mod h1:sEtPWMiqiN1N1cMXoXmBbd8C6/l+TESwriotuRRpkDM= +gorm.io/driver/postgres v1.6.0 h1:2dxzU8xJ+ivvqTRph34QX+WrRaJlmfyPqXmoGVjMBa4= +gorm.io/driver/postgres v1.6.0/go.mod h1:vUw0mrGgrTK+uPHEhAdV4sfFELrByKVGnaVRkXDhtWo= +gorm.io/driver/sqlite v1.6.0 h1:WHRRrIiulaPiPFmDcod6prc4l2VGVWHz80KspNsxSfQ= +gorm.io/driver/sqlite v1.6.0/go.mod h1:AO9V1qIQddBESngQUKWL9yoH93HIeA1X6V633rBwyT8= +gorm.io/driver/sqlserver v1.6.0 h1:VZOBQVsVhkHU/NzNhRJKoANt5pZGQAS1Bwc6m6dgfnc= +gorm.io/driver/sqlserver v1.6.0/go.mod h1:WQzt4IJo/WHKnckU9jXBLMJIVNMVeTu25dnOzehntWw= +gorm.io/gorm v1.25.7/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8= +gorm.io/gorm v1.31.1 h1:7CA8FTFz/gRfgqgpeKIBcervUn3xSyPUmr6B2WXJ7kg= +gorm.io/gorm v1.31.1/go.mod h1:XyQVbO2k6YkOis7C2437jSit3SsDK72s7n7rsSHd+Gs= +gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo= +gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw= +honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= +honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +k8s.io/api v0.28.2 h1:9mpl5mOb6vXZvqbQmankOfPIGiudghwCoLl1EYfUZbw= +k8s.io/api v0.28.2/go.mod h1:RVnJBsjU8tcMq7C3iaRSGMeaKt2TWEUXcpIt/90fjEg= +k8s.io/apiextensions-apiserver v0.28.2 h1:J6/QRWIKV2/HwBhHRVITMLYoypCoPY1ftigDM0Kn+QU= +k8s.io/apiextensions-apiserver v0.28.2/go.mod h1:5tnkxLGa9nefefYzWuAlWZ7RZYuN/765Au8cWLA6SRg= +k8s.io/apimachinery v0.28.2 h1:KCOJLrc6gu+wV1BYgwik4AF4vXOlVJPdiqn0yAWWwXQ= +k8s.io/apimachinery v0.28.2/go.mod h1:RdzF87y/ngqk9H4z3EL2Rppv5jj95vGS/HaFXrLDApU= +k8s.io/apiserver v0.28.2 h1:rBeYkLvF94Nku9XfXyUIirsVzCzJBs6jMn3NWeHieyI= +k8s.io/apiserver v0.28.2/go.mod h1:f7D5e8wH8MWcKD7azq6Csw9UN+CjdtXIVQUyUhrtb+E= +k8s.io/client-go v0.28.2 h1:DNoYI1vGq0slMBN/SWKMZMw0Rq+0EQW6/AK4v9+3VeY= +k8s.io/client-go v0.28.2/go.mod h1:sMkApowspLuc7omj1FOSUxSoqjr+d5Q0Yc0LOFnYFJY= +k8s.io/component-base v0.28.2 h1:Yc1yU+6AQSlpJZyvehm/NkJBII72rzlEsd6MkBQ+G0E= +k8s.io/component-base v0.28.2/go.mod h1:4IuQPQviQCg3du4si8GpMrhAIegxpsgPngPRR/zWpzc= +k8s.io/klog/v2 v2.100.1 h1:7WCHKK6K8fNhTqfBhISHQ97KrnJNFZMcQvKp7gP/tmg= +k8s.io/klog/v2 v2.100.1/go.mod h1:y1WjHnz7Dj687irZUWR/WLkLc5N1YHtjLdmgWjndZn0= +k8s.io/kms v0.28.3 h1:jYwwAe96XELNjYWv1G4kNzizcFoZ50OOElvPansbw70= +k8s.io/kms v0.28.3/go.mod h1:kSMjU2tg7vjqqoWVVCcmPmNZ/CofPsoTbSxAipCvZuE= +k8s.io/kube-openapi v0.0.0-20230905202853-d090da108d2f h1:eeEUOoGYWhOz7EyXqhlR2zHKNw2mNJ9vzJmub6YN6kk= +k8s.io/kube-openapi v0.0.0-20230905202853-d090da108d2f/go.mod h1:AsvuZPBlUDVuCdzJ87iajxtXuR9oktsTctW/R9wwouA= +k8s.io/utils v0.0.0-20230726121419-3b25d923346b h1:sgn3ZU783SCgtaSJjpcVVlRqd6GSnlTLKgpAAttJvpI= +k8s.io/utils v0.0.0-20230726121419-3b25d923346b/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0= +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.31.2 h1:jpcvIRr3GLoUoEKRkHKSmGjxb6lWwrBlJsXc+eUYQHM= +sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.31.2/go.mod h1:Ve9uj1L+deCXFrPOk1LpFXqTg7LCFzFso6PA48q/XZw= +sigs.k8s.io/controller-runtime v0.16.3 h1:2TuvuokmfXvDUamSx1SuAOO3eTyye+47mJCigwG62c4= +sigs.k8s.io/controller-runtime v0.16.3/go.mod h1:j7bialYoSn142nv9sCOJmQgDXQXxnroFU4VnX/brVJ0= +sigs.k8s.io/json v0.0.0-20241014173422-cfa47c3a1cc8 h1:gBQPwqORJ8d8/YNZWEjoZs7npUVDpVXUUOFfW6CgAqE= +sigs.k8s.io/json v0.0.0-20241014173422-cfa47c3a1cc8/go.mod h1:mdzfpAEoE6DHQEN0uh9ZbOCuHbLK5wOm7dK4ctXE9Tg= +sigs.k8s.io/structured-merge-diff/v4 v4.4.1 h1:150L+0vs/8DA78h1u02ooW1/fFq/Lwr+sGiqlzvrtq4= +sigs.k8s.io/structured-merge-diff/v4 v4.4.1/go.mod h1:N8hJocpFajUSSeSJ9bOZ77VzejKZaXsTtZo4/u7Io08= +sigs.k8s.io/yaml v1.6.0 h1:G8fkbMSAFqgEFgh4b1wmtzDnioxFCUgTZhlbj5P9QYs= +sigs.k8s.io/yaml v1.6.0/go.mod h1:796bPqUfzR/0jLAl6XjHl3Ck7MiyVv8dbTdyT3/pMf4= diff --git a/manager/Makefile b/manager/Makefile new file mode 100644 index 0000000000..228336c6c4 --- /dev/null +++ b/manager/Makefile @@ -0,0 +1,28 @@ +# Manager Service Makefile +# This Makefile includes common Go targets from ../go.Makefile + +# Service configuration +SERVICE_NAME := flyte-manager +BIN_NAME := flyte-manager +CMD_PATH := cmd/main.go +RUN_ARGS ?= --config config.yaml + +# Include common Go targets +include ../go.Makefile + +##@ Manager Specific + +.PHONY: run-testclient +run-testclient: ## Run the test client + @echo "Running test client..." + @go run testclient/main.go + +.PHONY: clean-db +clean-db: ## Remove local database file + @echo "Removing flyte.db..." + @rm -f flyte.db + +# Override clean to also remove database +clean: clean-db ## Remove build artifacts and database + @echo "Cleaning build artifacts..." + @rm -rf bin/ diff --git a/manager/README.md b/manager/README.md new file mode 100644 index 0000000000..ecf550a2e3 --- /dev/null +++ b/manager/README.md @@ -0,0 +1,311 @@ +# Flyte Manager - Unified Binary + +The Flyte Manager is a unified binary that runs all Flyte services in a single process: + +- **Runs Service** (port 8090) - Manages workflow runs and action state +- **Queue Service** (port 8089) - Creates and manages TaskAction CRs in Kubernetes +- **Executor/Operator** (port 8081 health) - Reconciles TaskAction CRs and transitions them through states + +## Features + +โœ… **Single Binary** - One process to deploy and manage +โœ… **Single SQLite Database** - All data in one file +โœ… **Auto Kubernetes Detection** - Uses current kubeconfig +โœ… **Unified Configuration** - One config file for all services +โœ… **HTTP/2 Support** - Buf Connect compatible + +## Quick Start + +### Prerequisites + +1. **Kubernetes cluster** (k3d, kind, minikube, or any cluster) +2. **Go 1.24 or later** +3. **TaskAction CRD** installed in the cluster +4. **Kubeconfig** configured (or running in-cluster) + +### Install TaskAction CRD + +```bash +kubectl apply -f ../executor/config/crd/bases/flyte.org_taskactions.yaml +``` + +### Build and Run + +```bash +# Build the binary +make build + +# Run the manager +make run + +# Or run directly +./bin/flyte-manager --config config.yaml +``` + +The manager will: +1. Initialize a SQLite database (`flyte.db`) +2. Run database migrations +3. Start all three services in parallel goroutines +4. Connect to your Kubernetes cluster +5. Begin reconciling TaskAction CRs + +## Configuration + +Edit `config.yaml`: + +```yaml +manager: + runsService: + host: "0.0.0.0" + port: 8090 + + queueService: + host: "0.0.0.0" + port: 8089 + + executor: + healthProbePort: 8081 + + kubernetes: + namespace: "flyte" + # Optional: specify custom kubeconfig path + # kubeconfig: "/path/to/kubeconfig" + +database: + type: "sqlite" + sqlite: + file: "flyte.db" + +logger: + level: 4 # Info level + show-source: true +``` + +## Architecture + +``` +โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” +โ”‚ Flyte Manager Process โ”‚ +โ”œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”ค +โ”‚ โ”‚ +โ”‚ โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” โ”‚ +โ”‚ โ”‚ Runs Service โ”‚ โ”‚ Queue Service โ”‚ โ”‚ Executor โ”‚ โ”‚ +โ”‚ โ”‚ :8090 โ”‚ โ”‚ :8089 โ”‚ โ”‚ โ”‚ โ”‚ +โ”‚ โ”‚ โ”‚ โ”‚ โ”‚ โ”‚ Reconciles โ”‚ โ”‚ +โ”‚ โ”‚ - RunService โ”‚ โ”‚ Creates K8s โ”‚ โ”‚ TaskActions โ”‚ โ”‚ +โ”‚ โ”‚ - StateServ. โ”‚ โ”‚ TaskAction CRsโ”‚ โ”‚ โ”‚ โ”‚ +โ”‚ โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”ฌโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”ฌโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”ฌโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ โ”‚ +โ”‚ โ”‚ โ”‚ โ”‚ โ”‚ +โ”‚ โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”ดโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ โ”‚ +โ”‚ โ”‚ โ”‚ +โ”‚ โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”ดโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” โ”‚ +โ”‚ โ”‚ SQLite DB โ”‚ โ”‚ +โ”‚ โ”‚ flyte.db โ”‚ โ”‚ +โ”‚ โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ โ”‚ +โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ + โ”‚ + โ†“ + Kubernetes Cluster + (TaskAction CRs) +``` + +## API Endpoints + +### Runs Service (port 8090) + +- `POST /flyteidl2.workflow.RunService/CreateRun` - Create a new run +- `POST /flyteidl2.workflow.RunService/GetRun` - Get run details +- `POST /flyteidl2.workflow.RunService/ListRuns` - List runs +- `POST /flyteidl2.workflow.RunService/AbortRun` - Abort a run +- `POST /flyteidl2.workflow.StateService/Put` - Update action state +- `POST /flyteidl2.workflow.StateService/Get` - Get action state +- `POST /flyteidl2.workflow.StateService/Watch` - Watch state updates +- `GET /healthz` - Health check +- `GET /readyz` - Readiness check + +### Queue Service (port 8089) + +- `POST /flyteidl2.workflow.QueueService/EnqueueAction` - Create TaskAction CR +- `POST /flyteidl2.workflow.QueueService/AbortQueuedRun` - Delete root TaskAction +- `POST /flyteidl2.workflow.QueueService/AbortQueuedAction` - Delete specific TaskAction +- `GET /healthz` - Health check +- `GET /readyz` - Readiness check + +### Executor (port 8081) + +- `GET /healthz` - Health check +- `GET /readyz` - Readiness check + +## How It Works + +1. **CreateRun** โ†’ Runs Service persists run to SQLite DB +2. **CreateRun** โ†’ Runs Service calls Queue Service to enqueue root action +3. **EnqueueAction** โ†’ Queue Service creates TaskAction CR in Kubernetes +4. **Executor** โ†’ Watches TaskAction CRs and reconciles them +5. **Executor** โ†’ Transitions: Queued โ†’ Initializing โ†’ Running โ†’ Succeeded +6. **Executor** โ†’ Calls State Service Put() on each transition +7. **State Service** โ†’ Persists state updates to SQLite DB +8. **State Service** โ†’ Notifies watchers of state changes + +## Testing + +### Check Services + +```bash +# Runs Service health +curl http://localhost:8090/healthz + +# Queue Service health +curl http://localhost:8089/healthz + +# Executor health +curl http://localhost:8081/healthz +``` + +### Watch TaskActions + +```bash +# List all TaskActions +kubectl get taskactions -n flyte + +# Watch TaskActions in real-time +kubectl get taskactions -n flyte -w + +# Get details of a specific TaskAction +kubectl describe taskaction -n flyte +``` + +### Check Database + +```bash +# Open SQLite database +sqlite3 flyte.db + +# List tables +.tables + +# Query runs +SELECT * FROM runs; + +# Query actions +SELECT name, phase, state FROM actions; +``` + +## Deployment + +### Local Development + +```bash +make run +``` + +### Docker + +```dockerfile +FROM golang:1.21 AS builder +WORKDIR /app +COPY . . +RUN cd manager && make build + +FROM alpine:latest +RUN apk --no-cache add ca-certificates sqlite +WORKDIR /root/ +COPY --from=builder /app/manager/bin/flyte-manager . +COPY --from=builder /app/manager/config.yaml . +CMD ["./flyte-manager", "--config", "config.yaml"] +``` + +### Kubernetes + +Deploy as a single pod with access to the Kubernetes API: + +```yaml +apiVersion: apps/v1 +kind: Deployment +metadata: + name: flyte-manager + namespace: flyte +spec: + replicas: 1 + selector: + matchLabels: + app: flyte-manager + template: + metadata: + labels: + app: flyte-manager + spec: + serviceAccountName: flyte-manager + containers: + - name: manager + image: flyte-manager:latest + ports: + - containerPort: 8090 + name: runs + - containerPort: 8089 + name: queue + - containerPort: 8081 + name: health +``` + +## Troubleshooting + +### Connection Issues + +**Error:** "failed to get Kubernetes config" + +```bash +# Verify kubeconfig +kubectl cluster-info + +# Or set explicit kubeconfig in config.yaml +manager: + kubernetes: + kubeconfig: "/path/to/kubeconfig" +``` + +### Database Issues + +**Error:** "failed to run migrations" + +```bash +# Remove and recreate database +rm flyte.db +./bin/flyte-manager --config config.yaml +``` + +### Port Conflicts + +**Error:** "address already in use" + +```bash +# Check what's using the ports +lsof -i :8090 +lsof -i :8089 +lsof -i :8081 + +# Change ports in config.yaml +manager: + runsService: + port: 9090 # Changed from 8090 +``` + +## Development + +### Build + +```bash +make build +``` + +### Clean + +```bash +make clean +``` + +### Run Tests + +```bash +make test +``` diff --git a/manager/cmd/main.go b/manager/cmd/main.go new file mode 100644 index 0000000000..7ff635be6c --- /dev/null +++ b/manager/cmd/main.go @@ -0,0 +1,395 @@ +package main + +import ( + "context" + "errors" + "fmt" + "net/http" + "os" + "os/signal" + "sync" + "syscall" + + "github.com/spf13/cobra" + "golang.org/x/net/http2" + "golang.org/x/net/http2/h2c" + "gorm.io/gorm" + corev1 "k8s.io/api/core/v1" + apierrors "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/types" + utilruntime "k8s.io/apimachinery/pkg/util/runtime" + clientgoscheme "k8s.io/client-go/kubernetes/scheme" + "k8s.io/client-go/rest" + "k8s.io/client-go/tools/clientcmd" + ctrl "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/healthz" + "sigs.k8s.io/controller-runtime/pkg/log/zap" + + dataproxyconfig "github.com/flyteorg/flyte/v2/dataproxy/config" + dataproxyservice "github.com/flyteorg/flyte/v2/dataproxy/service" + flyteorgv1 "github.com/flyteorg/flyte/v2/executor/api/v1" + executorcontroller "github.com/flyteorg/flyte/v2/executor/pkg/controller" + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/config/viper" + "github.com/flyteorg/flyte/v2/flytestdlib/contextutils" + "github.com/flyteorg/flyte/v2/flytestdlib/database" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils" + "github.com/flyteorg/flyte/v2/flytestdlib/promutils/labeled" + "github.com/flyteorg/flyte/v2/flytestdlib/storage" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/dataproxy/dataproxyconnect" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow/workflowconnect" + managerconfig "github.com/flyteorg/flyte/v2/manager/config" + queuek8s "github.com/flyteorg/flyte/v2/queue/k8s" + queueservice "github.com/flyteorg/flyte/v2/queue/service" + "github.com/flyteorg/flyte/v2/runs/migrations" + "github.com/flyteorg/flyte/v2/runs/repository" + runsservice "github.com/flyteorg/flyte/v2/runs/service" +) + +var ( + cfgFile string + rootCmd = &cobra.Command{ + Use: "flyte", + Short: "Unified Flyte Service - Runs all services and operator", + RunE: func(cmd *cobra.Command, args []string) error { + return serve(cmd.Context()) + }, + } + scheme = runtime.NewScheme() +) + +func init() { + rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is ./config.yaml)") + + // Register Kubernetes schemes + utilruntime.Must(clientgoscheme.AddToScheme(scheme)) + utilruntime.Must(flyteorgv1.AddToScheme(scheme)) +} + +func main() { + if err := rootCmd.Execute(); err != nil { + os.Exit(1) + } +} + +func serve(ctx context.Context) error { + // Initialize config + if err := initConfig(); err != nil { + return fmt.Errorf("failed to initialize config: %w", err) + } + + // Initialize logger + logConfig := logger.GetConfig() + if err := logger.SetConfig(logConfig); err != nil { + return fmt.Errorf("failed to initialize logger: %w", err) + } + + // Set controller-runtime logger + ctrl.SetLogger(zap.New(zap.UseDevMode(true))) + + logger.Infof(ctx, "Starting Flyte Manager (unified binary)") + + // Get configuration (use defaults if config doesn't load) + cfg := &managerconfig.Config{ + Server: managerconfig.ServerConfig{ + Host: "0.0.0.0", + Port: 8090, // Single port for all Connect services + }, + Executor: managerconfig.ExecutorConfig{ + HealthProbePort: 8081, + }, + Kubernetes: managerconfig.KubernetesConfig{ + Namespace: "flyte", + }, + } + + dbCfg := &database.DbConfig{ + SQLite: database.SQLiteConfig{ + File: "flyte.db", + }, + } + + // Initialize database + db, err := initDB(ctx, dbCfg) + if err != nil { + return fmt.Errorf("failed to initialize database: %w", err) + } + + // Run migrations + logger.Infof(ctx, "Running database migrations") + if err := migrations.RunMigrations(db); err != nil { + return fmt.Errorf("failed to run migrations: %w", err) + } + + // Create repository + repo := repository.NewRepository(db) + + // Initialize Kubernetes client + k8sClient, k8sConfig, err := initKubernetesClient(ctx, &cfg.Kubernetes) + if err != nil { + return fmt.Errorf("failed to initialize Kubernetes client: %w", err) + } + + // Initialize the executor API scheme + if err := queuek8s.InitScheme(); err != nil { + return fmt.Errorf("failed to initialize scheme: %w", err) + } + + // Create queue client (for Kubernetes operations) + queueK8sClient := queuek8s.NewQueueClient(k8sClient, cfg.Kubernetes.Namespace) + logger.Infof(ctx, "Kubernetes client initialized for namespace: %s", cfg.Kubernetes.Namespace) + + // Initialize labeled metrics (required for storage) + labeled.SetMetricKeys(contextutils.ProjectKey, contextutils.DomainKey, contextutils.WorkflowIDKey, contextutils.TaskIDKey) + + // Initialize storage for DataProxy + storageCfg := storage.GetConfig() + metricsScope := promutils.NewTestScope() + dataStore, err := storage.NewDataStore(storageCfg, metricsScope) + if err != nil { + return fmt.Errorf("failed to initialize storage: %w", err) + } + logger.Infof(ctx, "Storage initialized with type: %s", storageCfg.Type) + + // Create queue service client (points to same server) + queueClient := workflowconnect.NewQueueServiceClient( + http.DefaultClient, + fmt.Sprintf("http://localhost:%d", cfg.Server.Port), + ) + + // Create all services + runsSvc := runsservice.NewRunService(repo, queueClient) + stateSvc := runsservice.NewStateService(repo) + queueSvc := queueservice.NewQueueService(queueK8sClient) + dataProxyCfg := dataproxyconfig.GetConfig() + dataProxySvc := dataproxyservice.NewService(*dataProxyCfg, dataStore) + + // Setup single HTTP server with all services mounted + mux := http.NewServeMux() + + // Mount all Connect services on the same mux + runsPath, runsHandler := workflowconnect.NewRunServiceHandler(runsSvc) + mux.Handle(runsPath, runsHandler) + logger.Infof(ctx, "Mounted RunService at %s", runsPath) + + statePath, stateHandler := workflowconnect.NewStateServiceHandler(stateSvc) + mux.Handle(statePath, stateHandler) + logger.Infof(ctx, "Mounted StateService at %s", statePath) + + queuePath, queueHandler := workflowconnect.NewQueueServiceHandler(queueSvc) + mux.Handle(queuePath, queueHandler) + logger.Infof(ctx, "Mounted QueueService at %s", queuePath) + + dataProxyPath, dataProxyHandler := dataproxyconnect.NewDataProxyServiceHandler(dataProxySvc) + mux.Handle(dataProxyPath, dataProxyHandler) + logger.Infof(ctx, "Mounted DataProxyService at %s", dataProxyPath) + + // Health checks + mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte("OK")) + }) + + mux.HandleFunc("/readyz", func(w http.ResponseWriter, r *http.Request) { + // Check database + sqlDB, err := db.DB() + if err != nil || sqlDB.Ping() != nil { + w.WriteHeader(http.StatusServiceUnavailable) + _, _ = w.Write([]byte("Database unavailable")) + return + } + // Check storage + baseContainer := dataStore.GetBaseContainerFQN(r.Context()) + if baseContainer == "" { + w.WriteHeader(http.StatusServiceUnavailable) + _, _ = w.Write([]byte("Storage connection error")) + return + } + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte("OK")) + }) + + // Wait group for both server and executor + var wg sync.WaitGroup + errCh := make(chan error, 2) + + // 1. Start unified HTTP server with all Connect services + wg.Add(1) + go func() { + defer wg.Done() + addr := fmt.Sprintf("%s:%d", cfg.Server.Host, cfg.Server.Port) + server := &http.Server{ + Addr: addr, + Handler: h2c.NewHandler(mux, &http2.Server{}), + } + + logger.Infof(ctx, "Flyte Connect Server listening on %s", addr) + logger.Infof(ctx, "All services (Runs, State, Queue, DataProxy) available on port %d", cfg.Server.Port) + if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { + errCh <- fmt.Errorf("server error: %w", err) + } + }() + + // 2. Start Executor/Operator + wg.Add(1) + go func() { + defer wg.Done() + logger.Infof(ctx, "Starting Executor/Operator") + + // Create controller manager + mgr, err := ctrl.NewManager(k8sConfig, ctrl.Options{ + Scheme: scheme, + HealthProbeBindAddress: fmt.Sprintf(":%d", cfg.Executor.HealthProbePort), + LeaderElection: false, // Single instance for now + }) + if err != nil { + errCh <- fmt.Errorf("failed to create controller manager: %w", err) + return + } + + // Setup TaskAction controller + stateServiceURL := fmt.Sprintf("http://localhost:%d", cfg.Server.Port) + if err := executorcontroller.NewTaskActionReconciler( + mgr.GetClient(), + mgr.GetScheme(), + stateServiceURL, + ).SetupWithManager(mgr); err != nil { + errCh <- fmt.Errorf("failed to setup controller: %w", err) + return + } + + // Add health checks + if err := mgr.AddHealthzCheck("healthz", healthz.Ping); err != nil { + errCh <- fmt.Errorf("failed to add health check: %w", err) + return + } + if err := mgr.AddReadyzCheck("readyz", healthz.Ping); err != nil { + errCh <- fmt.Errorf("failed to add ready check: %w", err) + return + } + + logger.Infof(ctx, "Executor controller starting") + if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil { + errCh <- fmt.Errorf("executor controller error: %w", err) + } + }() + + // Wait for interrupt signal or error + sigCh := make(chan os.Signal, 1) + signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM) + + select { + case sig := <-sigCh: + logger.Infof(ctx, "Received signal %v, shutting down gracefully...", sig) + case err := <-errCh: + logger.Errorf(ctx, "Service error: %v", err) + return err + } + + logger.Infof(ctx, "Flyte Manager stopped") + return nil +} + +func initConfig() error { + configAccessor := viper.NewAccessor(config.Options{ + SearchPaths: []string{cfgFile, ".", "/etc/flyte/config"}, + StrictMode: false, + }) + + return configAccessor.UpdateConfig(context.Background()) +} + +func initDB(ctx context.Context, cfg *database.DbConfig) (*gorm.DB, error) { + logCfg := logger.GetConfig() + + db, err := database.GetDB(ctx, cfg, logCfg) + if err != nil { + return nil, fmt.Errorf("failed to initialize database: %w", err) + } + + logger.Infof(ctx, "Database connection established") + return db, nil +} + +func initKubernetesClient(ctx context.Context, cfg *managerconfig.KubernetesConfig) (client.Client, *rest.Config, error) { + var restConfig *rest.Config + var err error + + if cfg.KubeConfig != "" { + // Use explicitly configured kubeconfig file + logger.Infof(ctx, "Using kubeconfig from: %s", cfg.KubeConfig) + restConfig, err = clientcmd.BuildConfigFromFlags("", cfg.KubeConfig) + if err != nil { + return nil, nil, fmt.Errorf("failed to build k8s config from flags: %w", err) + } + } else { + // Try in-cluster config first + logger.Infof(ctx, "Attempting to use in-cluster Kubernetes configuration") + restConfig, err = rest.InClusterConfig() + + if err != nil { + // Fall back to default kubeconfig location + logger.Infof(ctx, "In-cluster config not available, falling back to default kubeconfig") + loadingRules := clientcmd.NewDefaultClientConfigLoadingRules() + configOverrides := &clientcmd.ConfigOverrides{} + kubeConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(loadingRules, configOverrides) + restConfig, err = kubeConfig.ClientConfig() + + if err != nil { + return nil, nil, fmt.Errorf("failed to get Kubernetes config: %w", err) + } + + logger.Infof(ctx, "Using default kubeconfig from standard locations (~/.kube/config)") + } + } + + // Create the controller-runtime client + k8sClient, err := client.New(restConfig, client.Options{Scheme: scheme}) + if err != nil { + return nil, nil, fmt.Errorf("failed to create Kubernetes client: %w", err) + } + + logger.Infof(ctx, "Kubernetes client initialized successfully") + + // Ensure the namespace exists + if err := ensureNamespaceExists(ctx, k8sClient, cfg.Namespace); err != nil { + return nil, nil, fmt.Errorf("failed to ensure namespace exists: %w", err) + } + + return k8sClient, restConfig, nil +} + +func ensureNamespaceExists(ctx context.Context, k8sClient client.Client, namespaceName string) error { + namespace := &corev1.Namespace{} + err := k8sClient.Get(ctx, types.NamespacedName{Name: namespaceName}, namespace) + + if err == nil { + // Namespace already exists + logger.Infof(ctx, "Namespace '%s' already exists", namespaceName) + return nil + } + + if !apierrors.IsNotFound(err) { + // Some other error occurred + return fmt.Errorf("failed to check if namespace exists: %w", err) + } + + // Namespace doesn't exist, create it + logger.Infof(ctx, "Creating namespace '%s'", namespaceName) + namespace = &corev1.Namespace{ + ObjectMeta: metav1.ObjectMeta{ + Name: namespaceName, + }, + } + + if err := k8sClient.Create(ctx, namespace); err != nil { + return fmt.Errorf("failed to create namespace: %w", err) + } + + logger.Infof(ctx, "Successfully created namespace '%s'", namespaceName) + return nil +} diff --git a/manager/config.yaml b/manager/config.yaml new file mode 100644 index 0000000000..d714885ada --- /dev/null +++ b/manager/config.yaml @@ -0,0 +1,53 @@ +# Unified Flyte Manager Configuration + +manager: + # Single server port for all Connect services (Runs, State, Queue, DataProxy) + server: + host: "0.0.0.0" + port: 8090 + + executor: + healthProbePort: 8081 + + kubernetes: + namespace: "flyte" + # Optional: specify custom kubeconfig path + # kubeconfig: "/path/to/kubeconfig" + +# Database configuration (SQLite) +database: + type: "sqlite" + sqlite: + file: "flyte.db" + +# Logger configuration +logger: + level: 4 # Info level + show-source: true + +# Data Proxy Configuration +dataproxy: + upload: + maxSize: "100Mi" + maxExpiresIn: 1h + defaultFileNameLength: 20 + storagePrefix: "uploads" + download: + maxExpiresIn: 1h + +# Storage Configuration +# For local development, using MinIO (make sure MinIO is running on localhost:9000) +# You can also use "mem" type for in-memory storage during testing +storage: + type: minio + container: "flyte-data" + enable-multicontainer: false + stow: + kind: "s3" + config: + auth_type: "accesskey" + access_key_id: "minioadmin" + secret_key: "minioadmin" + region: "us-east-1" + endpoint: "http://localhost:9000" + disable_ssl: "true" diff --git a/manager/config/config.go b/manager/config/config.go new file mode 100644 index 0000000000..846d984439 --- /dev/null +++ b/manager/config/config.go @@ -0,0 +1,61 @@ +package config + +import "github.com/flyteorg/flyte/v2/flytestdlib/config" + +const configSectionKey = "manager" + +//go:generate pflags Config --default-var=defaultConfig + +// Config holds configuration for the unified Flyte Manager +type Config struct { + // Server configuration - single port for all Connect services + Server ServerConfig `json:"server"` + + // Executor configuration + Executor ExecutorConfig `json:"executor"` + + // Kubernetes configuration + Kubernetes KubernetesConfig `json:"kubernetes"` +} + +// ServerConfig holds HTTP server configuration +type ServerConfig struct { + Host string `json:"host"` + Port int `json:"port"` +} + +// ExecutorConfig holds executor-specific configuration +type ExecutorConfig struct { + HealthProbePort int `json:"healthProbePort"` +} + +// KubernetesConfig holds Kubernetes client configuration +type KubernetesConfig struct { + Namespace string `json:"namespace"` + KubeConfig string `json:"kubeconfig"` // Optional, defaults to in-cluster or ~/.kube/config +} + +var defaultConfig = &Config{ + Server: ServerConfig{ + Host: "0.0.0.0", + Port: 8090, + }, + Executor: ExecutorConfig{ + HealthProbePort: 8081, + }, + Kubernetes: KubernetesConfig{ + Namespace: "flyte", + KubeConfig: "", + }, +} + +var cfg Config + +// GetConfig retrieves the current config value or default. +func GetConfig() *Config { + return &cfg +} + +func init() { + config.MustRegisterSection(configSectionKey, &cfg) +} diff --git a/manager/testclient/main.go b/manager/testclient/main.go new file mode 100644 index 0000000000..24fc8afa06 --- /dev/null +++ b/manager/testclient/main.go @@ -0,0 +1,250 @@ +package main + +import ( + "context" + "fmt" + "log" + "net/http" + "os" + "os/signal" + "sync" + "syscall" + "time" + + "connectrpc.com/connect" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow/workflowconnect" +) + +const ( + runsServiceURL = "http://localhost:8090" + org = "my-org" + project = "my-project" + domain = "development" +) + +func main() { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + // Handle interrupts + sigCh := make(chan os.Signal, 1) + signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM) + go func() { + <-sigCh + log.Println("\n๐Ÿ›‘ Shutting down...") + cancel() + }() + + // Create HTTP client + httpClient := &http.Client{ + Transport: &http.Transport{ + ForceAttemptHTTP2: true, + }, + } + + // Create service clients + runClient := workflowconnect.NewRunServiceClient(httpClient, runsServiceURL) + + log.Println("๐Ÿš€ Flyte Client Demo") + log.Println("===================") + + var wg sync.WaitGroup + + // 1. Start watching runs (background goroutine) + wg.Add(1) + go func() { + defer wg.Done() + watchRuns(ctx, runClient) + }() + + // Give the watch a moment to start + time.Sleep(500 * time.Millisecond) + + // 2. Create a run + runID := createRun(ctx, runClient) + if runID == nil { + log.Println("โŒ Failed to create run") + return + } + + // 3. Watch actions for the run + wg.Add(1) + go func() { + defer wg.Done() + watchActions(ctx, runClient, runID) + }() + + // Wait for context cancellation or all watchers to finish + done := make(chan struct{}) + go func() { + wg.Wait() + close(done) + }() + + select { + case <-ctx.Done(): + log.Println("Context cancelled, waiting for goroutines to finish...") + wg.Wait() + case <-done: + log.Println("All watchers finished") + } + + log.Println("โœ… Client demo complete") +} + +// watchRuns watches for run updates and logs them +func watchRuns(ctx context.Context, client workflowconnect.RunServiceClient) { + log.Println("๐Ÿ“ก Starting WatchRuns stream...") + + req := &workflow.WatchRunsRequest{ + Target: &workflow.WatchRunsRequest_ProjectId{ + ProjectId: &common.ProjectIdentifier{ + Organization: org, + Name: project, + Domain: domain, + }, + }, + } + + stream, err := client.WatchRuns(ctx, connect.NewRequest(req)) + if err != nil { + log.Printf("โŒ Failed to start WatchRuns: %v", err) + return + } + defer stream.Close() + + log.Println("โœ… WatchRuns stream connected") + + for stream.Receive() { + msg := stream.Msg() + for _, run := range msg.Runs { + if run.Action != nil && run.Action.Id != nil && run.Action.Id.Run != nil { + runID := run.Action.Id.Run + log.Printf("๐Ÿ“ฅ [WatchRuns] Run Update: %s (org: %s, project: %s, domain: %s. Action0 Phase: %v)", + runID.Name, runID.Org, runID.Project, runID.Domain, run.GetAction().GetStatus().GetPhase()) + } + } + } + + if err := stream.Err(); err != nil { + log.Printf("โŒ WatchRuns stream error: %v", err) + } +} + +// watchActions watches for action updates and logs them +func watchActions(ctx context.Context, client workflowconnect.RunServiceClient, runID *common.RunIdentifier) { + log.Printf("๐Ÿ“ก Starting WatchActions stream for run: %s...", runID.Name) + + req := &workflow.WatchActionsRequest{ + RunId: runID, + } + + stream, err := client.WatchActions(ctx, connect.NewRequest(req)) + if err != nil { + log.Printf("โŒ Failed to start WatchActions: %v", err) + return + } + defer stream.Close() + + log.Println("โœ… WatchActions stream connected") + + for stream.Receive() { + msg := stream.Msg() + for _, enrichedAction := range msg.EnrichedActions { + if enrichedAction.Action != nil && enrichedAction.Action.Id != nil { + var phase common.ActionPhase + if enrichedAction.Action.Status != nil { + phase = enrichedAction.Action.Status.Phase + } + log.Printf("๐Ÿ“ฅ [WatchActions] Action: %s | Phase: %s", + enrichedAction.Action.Id.Name, + formatPhase(phase)) + } + } + } + + if err := stream.Err(); err != nil { + log.Printf("โŒ WatchActions stream error: %v", err) + } +} + +// createRun creates a new workflow run +func createRun(ctx context.Context, client workflowconnect.RunServiceClient) *common.RunIdentifier { + log.Println("\n๐Ÿ“ Creating a new run...") + + // Generate a unique run name + runName := fmt.Sprintf("run-%d", time.Now().Unix()) + + runID := &common.RunIdentifier{ + Org: org, + Project: project, + Domain: domain, + Name: runName, + } + + // Create a simple task identifier + taskID := &task.TaskIdentifier{ + Org: org, + Project: project, + Domain: domain, + Name: "example-task", + Version: "v1", + } + + req := &workflow.CreateRunRequest{ + Id: &workflow.CreateRunRequest_RunId{ + RunId: runID, + }, + Task: &workflow.CreateRunRequest_TaskId{ + TaskId: taskID, + }, + Inputs: &task.Inputs{}, + } + + resp, err := client.CreateRun(ctx, connect.NewRequest(req)) + if err != nil { + log.Printf("โŒ Failed to create run: %v", err) + return nil + } + + if resp.Msg.Run != nil && resp.Msg.Run.Action != nil && resp.Msg.Run.Action.Id != nil && resp.Msg.Run.Action.Id.Run != nil { + createdRunID := resp.Msg.Run.Action.Id.Run + log.Printf("โœ… Run created: %s", createdRunID.Name) + log.Printf(" Organization: %s", createdRunID.Org) + log.Printf(" Project: %s", createdRunID.Project) + log.Printf(" Domain: %s", createdRunID.Domain) + log.Println() + } + + return runID +} + +// formatPhase converts a Phase enum to a readable string with emoji +func formatPhase(phase common.ActionPhase) string { + switch phase { + case common.ActionPhase_ACTION_PHASE_UNSPECIFIED: + return "โšช UNSPECIFIED" + case common.ActionPhase_ACTION_PHASE_QUEUED: + return "๐Ÿ”ต QUEUED" + case common.ActionPhase_ACTION_PHASE_WAITING_FOR_RESOURCES: + return "โณ WAITING_FOR_RESOURCES" + case common.ActionPhase_ACTION_PHASE_INITIALIZING: + return "๐Ÿ”„ INITIALIZING" + case common.ActionPhase_ACTION_PHASE_RUNNING: + return "๐Ÿƒ RUNNING" + case common.ActionPhase_ACTION_PHASE_SUCCEEDED: + return "โœ… SUCCEEDED" + case common.ActionPhase_ACTION_PHASE_FAILED: + return "โŒ FAILED" + case common.ActionPhase_ACTION_PHASE_ABORTED: + return "๐Ÿ›‘ ABORTED" + case common.ActionPhase_ACTION_PHASE_TIMED_OUT: + return "โฐ TIMED_OUT" + default: + return fmt.Sprintf("โ“ UNKNOWN(%d)", phase) + } +} diff --git a/queue/Dockerfile b/queue/Dockerfile new file mode 100644 index 0000000000..5a1a30d4eb --- /dev/null +++ b/queue/Dockerfile @@ -0,0 +1,33 @@ +# Build stage +FROM golang:1.24.6-alpine AS builder + +RUN apk add --no-cache git build-base + +WORKDIR /workspace + +# Use repo root go.mod/go.sum for better caching in monorepo +COPY go.mod go.sum ./ +RUN go mod download + +# Copy the entire repository (rely on .dockerignore to trim) +COPY . ./ + +# Build the queue service binary from the queue module +WORKDIR /workspace/queue +RUN CGO_ENABLED=0 GOOS=linux go build -a -o queue-service ./cmd/main.go + +# Final stage +FROM alpine:latest + +RUN apk --no-cache add ca-certificates + +WORKDIR /app + +# Copy binary and default config +COPY --from=builder /workspace/queue/queue-service . +COPY --from=builder /workspace/queue/config.yaml . + +EXPOSE 8089 + +ENTRYPOINT ["./queue-service"] +CMD ["--config", "config.yaml"] diff --git a/queue/MANUAL_TEST.md b/queue/MANUAL_TEST.md new file mode 100644 index 0000000000..f200317287 --- /dev/null +++ b/queue/MANUAL_TEST.md @@ -0,0 +1,173 @@ +# Manual Testing Guide for Queue Service + +## Step 1: Prepare PostgreSQL Database + +You have PostgreSQL running on localhost:5432. Create the database manually: + +```bash +# Option A: If you know your PostgreSQL password +psql -h localhost -U postgres +# Then run: +CREATE DATABASE flyte_queue; +\q + +# Option B: Use your existing database +# Just update config.yaml with your database name +``` + +## Step 2: Update Configuration + +Edit `queue/config.yaml` and set your PostgreSQL credentials: + +```yaml +database: + postgres: + host: "localhost" + port: 5432 + dbname: "flyte_queue" # or your existing database name + username: "postgres" # or your PostgreSQL username + password: "YOUR_PASSWORD_HERE" + extraOptions: "sslmode=disable" +``` + +## Step 3: Start the Queue Service + +```bash +cd /Users/haytham/src/github.com/flyteorg/flyte/queue +./bin/queue-service --config config.yaml +``` + +Expected output: +``` +Starting Queue Service +Running database migrations +Queue Service listening on 0.0.0.0:8089 +``` + +## Step 4: Test Health Endpoints (New Terminal) + +```bash +# Health check +curl http://localhost:8089/healthz +# Should return: OK + +# Readiness check +curl http://localhost:8089/readyz +# Should return: OK +``` + +## Step 5: Run the Test Client + +```bash +cd /Users/haytham/src/github.com/flyteorg/flyte +go run queue/testclient/main.go +``` + +Expected output: +``` +Test 1: Enqueuing an action... +โœ“ Action enqueued successfully: {} + +Test 2: Enqueuing another action in the same run... +โœ“ Second action enqueued successfully + +Test 3: Aborting a specific action... +โœ“ Action aborted successfully + +Test 4: Enqueuing action for a different run... +โœ“ Action for run-002 enqueued successfully + +Test 5: Aborting entire run-001... +โœ“ Run aborted successfully + +All tests completed successfully! ๐ŸŽ‰ +``` + +## Step 6: Verify Database Contents + +```bash +# Connect to your database +psql -h localhost -U postgres -d flyte_queue + +# View all queued actions +SELECT id, org, project, domain, run_name, action_name, status, enqueued_at +FROM queued_actions +ORDER BY enqueued_at DESC; + +# View aborted actions +SELECT id, run_name, action_name, status, abort_reason +FROM queued_actions +WHERE status = 'aborted'; + +# Exit +\q +``` + +## Alternative: Use SQLite for Quick Testing + +If PostgreSQL setup is complex, you can modify the code to use SQLite instead: + +## Troubleshooting + +### PostgreSQL password issues + +If you don't know your PostgreSQL password: + +```bash +# Check pg_hba.conf location +psql -U postgres -c "SHOW hba_file;" + +# Or try without password (if configured for trust auth) +psql -h localhost -U postgres -c "CREATE DATABASE flyte_queue;" +``` + +### Port already in use + +If port 8089 is busy, edit `config.yaml`: +```yaml +queue: + server: + port: 8090 # Use different port +``` + +### Service won't start + +Check the logs for specific errors. Common issues: +- Database connection failed โ†’ Check credentials in config.yaml +- Port in use โ†’ Change port in config.yaml +- Migration failed โ†’ Check database permissions + +--- + +## Quick curl Test (Alternative to Go client) + +```bash +# Enqueue an action +curl -X POST http://localhost:8089/flyteidl2.workflow.QueueService/EnqueueAction \ + -H "Content-Type: application/json" \ + -d '{ + "actionId": { + "run": { + "org": "test-org", + "project": "test-proj", + "domain": "dev", + "name": "run-001" + }, + "name": "action-001" + }, + "inputUri": "s3://bucket/input", + "runOutputBase": "s3://bucket/output", + "task": { + "spec": { + "template": { + "container": { + "image": "alpine:latest", + "args": ["echo", "hello"] + } + } + } + } + }' + +# Should return: {} +``` diff --git a/queue/Makefile b/queue/Makefile new file mode 100644 index 0000000000..af5e8ec755 --- /dev/null +++ b/queue/Makefile @@ -0,0 +1,53 @@ +# Queue Service Makefile +# This Makefile includes common Go targets from ../go.Makefile + +# Service configuration +SERVICE_NAME := queue-service +BIN_NAME := queue-service +CMD_PATH := cmd/main.go +RUN_ARGS ?= serve --config config.yaml + +# Include common Go targets +include ../go.Makefile + +##@ Queue Specific + +.PHONY: run-testclient +run-testclient: ## Run the test client + @echo "Running test client..." + @go run testclient/main.go + +##@ Docker - PostgreSQL + +.PHONY: docker-postgres +docker-postgres: ## Start PostgreSQL in Docker + @echo "Starting PostgreSQL container..." + @docker run --name flyte-queue-postgres \ + -e POSTGRES_PASSWORD=postgres \ + -e POSTGRES_DB=flyte_queue \ + -p 5432:5432 \ + -d postgres:15 + +.PHONY: docker-postgres-stop +docker-postgres-stop: ## Stop and remove PostgreSQL container + @echo "Stopping PostgreSQL container..." + @docker stop flyte-queue-postgres || true + @docker rm flyte-queue-postgres || true + +##@ Integration Tests + +.PHONY: integration-test +integration-test: docker-postgres-stop docker-postgres ## Run integration test with PostgreSQL + @echo "Waiting for PostgreSQL to start..." + @sleep 3 + @echo "Building service..." + @$(MAKE) build-fast + @echo "Running service..." + @./bin/queue-service serve --config config.yaml & \ + SERVER_PID=$$!; \ + sleep 2; \ + echo "Running client tests..."; \ + go run testclient/main.go; \ + kill $$SERVER_PID; \ + docker stop flyte-queue-postgres; \ + docker rm flyte-queue-postgres diff --git a/queue/QUICKSTART.md b/queue/QUICKSTART.md new file mode 100644 index 0000000000..e109d5190e --- /dev/null +++ b/queue/QUICKSTART.md @@ -0,0 +1,251 @@ +# Queue Service - Quick Start Guide + +## Prerequisites + +- Go 1.24+ installed +- PostgreSQL 12+ (or Docker) + +## Option 1: Quick Test (Recommended) + +Run the automated test script: + +```bash +# If you don't have PostgreSQL running, start it with Docker: +docker run --name flyte-queue-postgres \ + -e POSTGRES_PASSWORD=postgres \ + -e POSTGRES_DB=flyte_queue \ + -p 5432:5432 \ + -d postgres:15 + +# Run the test script (builds, starts service, runs tests) +cd queue +./test.sh +``` + +The script will: +1. Build the service if needed +2. Check PostgreSQL connection +3. Start the Queue Service +4. Run health checks +5. Execute the test client +6. Show database contents +7. Clean up + +## Option 2: Manual Testing + +### Step 1: Start PostgreSQL + +```bash +# Using Docker +docker run --name flyte-queue-postgres \ + -e POSTGRES_PASSWORD=postgres \ + -e POSTGRES_DB=flyte_queue \ + -p 5432:5432 \ + -d postgres:15 + +# Or create the database in your existing PostgreSQL +createdb -h localhost -U postgres flyte_queue +``` + +### Step 2: Build the Service + +```bash +cd /path/to/flyte +go build -o queue/bin/queue-service ./queue/cmd/main.go +``` + +### Step 3: Start the Service + +```bash +cd queue +./bin/queue-service --config config.yaml +``` + +You should see: +``` +Starting Queue Service +Running database migrations +Queue Service listening on 0.0.0.0:8089 +``` + +### Step 4: Test the Service + +In a new terminal: + +```bash +# Health check +curl http://localhost:8089/healthz +# Should return: OK + +# Readiness check +curl http://localhost:8089/readyz +# Should return: OK + +# Run the test client +cd queue +go run testclient/main.go +``` + +Expected output: +``` +Test 1: Enqueuing an action... +โœ“ Action enqueued successfully + +Test 2: Enqueuing another action in the same run... +โœ“ Second action enqueued successfully + +Test 3: Aborting a specific action... +โœ“ Action aborted successfully + +Test 4: Enqueuing action for a different run... +โœ“ Action for run-002 enqueued successfully + +Test 5: Aborting entire run-001... +โœ“ Run aborted successfully + +All tests completed successfully! ๐ŸŽ‰ +``` + +### Step 5: Inspect the Database + +```bash +psql -h localhost -U postgres -d flyte_queue + +# View all actions +SELECT id, org, project, domain, run_name, action_name, status, enqueued_at +FROM queued_actions +ORDER BY enqueued_at DESC; + +# View aborted actions +SELECT id, org, project, domain, run_name, action_name, status, abort_reason +FROM queued_actions +WHERE status = 'aborted'; +``` + +## Testing with curl + +You can also test the service using curl (Connect protocol over HTTP): + +```bash +# Enqueue an action +curl -X POST http://localhost:8089/flyteidl2.workflow.QueueService/EnqueueAction \ + -H "Content-Type: application/json" \ + -d '{ + "actionId": { + "run": { + "org": "test-org", + "project": "test-project", + "domain": "development", + "name": "test-run-001" + }, + "name": "test-action-001" + }, + "inputUri": "s3://bucket/input", + "runOutputBase": "s3://bucket/output", + "task": { + "spec": { + "template": { + "container": { + "image": "alpine:latest", + "args": ["echo", "hello"] + } + } + } + } + }' + +# Abort a run +curl -X POST http://localhost:8089/flyteidl2.workflow.QueueService/AbortQueuedRun \ + -H "Content-Type: application/json" \ + -d '{ + "runId": { + "org": "test-org", + "project": "test-project", + "domain": "development", + "name": "test-run-001" + }, + "reason": "Testing abort" + }' +``` + +## Configuration + +Edit `queue/config.yaml` to customize: + +```yaml +queue: + server: + host: "0.0.0.0" + port: 8089 # Change port if needed + maxQueueSize: 10000 + workerCount: 10 + +database: + postgres: + host: "localhost" + port: 5432 + dbname: "flyte_queue" + username: "postgres" + password: "postgres" # Or use passwordPath for secrets + extraOptions: "sslmode=disable" + maxIdleConnections: 10 + maxOpenConnections: 100 + connMaxLifeTime: 1h +``` + +## Troubleshooting + +### Cannot connect to database + +```bash +# Check PostgreSQL is running +docker ps | grep postgres + +# Check database exists +psql -h localhost -U postgres -l | grep flyte_queue + +# If not, create it +createdb -h localhost -U postgres flyte_queue +``` + +### Port 8089 already in use + +Edit `queue/config.yaml` and change the port: + +```yaml +queue: + server: + port: 8090 # Use a different port +``` + +### Build errors + +```bash +# Make sure you're in the root of the flyte repo +cd /path/to/flyte + +# Tidy dependencies +go mod tidy + +# Try building again +go build -o queue/bin/queue-service ./queue/cmd/main.go +``` + +## Clean Up + +```bash +# Stop the service (Ctrl+C if running in foreground) + +# Stop and remove PostgreSQL container +docker stop flyte-queue-postgres +docker rm flyte-queue-postgres + +# Or just stop it to keep the data +docker stop flyte-queue-postgres +``` + +## Next Steps + +- See [README.md](README.md) for detailed documentation +- Check [IMPLEMENTATION_SPEC.md](../IMPLEMENTATION_SPEC.md) for architecture details +- Implement worker logic to process queued actions diff --git a/queue/README.md b/queue/README.md new file mode 100644 index 0000000000..9d78fdf169 --- /dev/null +++ b/queue/README.md @@ -0,0 +1,328 @@ +# Queue Service + +The Queue Service implements the `QueueService` gRPC interface using buf connect. It manages action execution by creating and managing Kubernetes TaskAction Custom Resources. + +## Architecture + +**Kubernetes-Native Design:** +- No database required +- Creates TaskAction CRs in Kubernetes for each action +- Uses OwnerReferences for automatic cascading deletion +- Leverages Kubernetes garbage collection for cleanup + +## Features + +- **Enqueue actions** - Creates TaskAction CRs in Kubernetes +- **Abort queued runs** - Deletes root TaskAction (children cascade automatically) +- **Abort individual actions** - Deletes specific TaskAction (children cascade automatically) +- **OwnerReference hierarchy** - Parent-child relationships via Kubernetes OwnerReferences +- **Automatic cleanup** - Kubernetes handles cascading deletion of dependent resources +- **Health and readiness checks** + +## Running the Service + +### Prerequisites + +1. **Kubernetes cluster** (k3d, kind, minikube, or any K8s cluster) +2. **Go 1.24 or later** +3. **TaskAction CRD** installed in the cluster +4. **Kubeconfig** configured (or running in-cluster) + +### Quick Start with k3d + +```bash +# Create a k3d cluster +k3d cluster create flyte-dev + +# Verify cluster is running +kubectl cluster-info + +# The service will automatically use your ~/.kube/config +``` + +### Run the service + +```bash +# From the queue directory +go build -o bin/queue-service ./cmd +./bin/queue-service --config config.yaml +``` + +The service will: +1. **Auto-detect Kubernetes config:** + - Try in-cluster config (when running in K8s) + - Fall back to `~/.kube/config` (for local development) + - Or use explicit kubeconfig path from config +2. Initialize Kubernetes client +3. Start HTTP/2 server on port 8089 (configurable) + +### Configuration + +Edit `config.yaml`: + +```yaml +queue: + server: + host: "0.0.0.0" + port: 8089 + kubernetes: + namespace: "flyte" + # Optional: specify custom kubeconfig path + # kubeconfig: "/path/to/kubeconfig" +``` + +**Kubeconfig Resolution:** +1. If `kubeconfig` is set โ†’ uses that file +2. Else tries in-cluster config +3. Falls back to default kubeconfig (`~/.kube/config`, `$KUBECONFIG`) + +## How It Works + +### Enqueue Action + +When `EnqueueAction` is called: + +1. Creates a TaskAction CR in Kubernetes +2. **Root action:** No OwnerReference, labeled `flyte.org/is-root: "true"` +3. **Child action:** Sets OwnerReference to parent TaskAction +4. Executor watches TaskAction CRs and executes them + +**Example TaskAction CR:** +```yaml +apiVersion: flyte.org/v1 +kind: TaskAction +metadata: + name: my-org-my-project-dev-run-001-task-001 + namespace: flyte + labels: + flyte.org/org: my-org + flyte.org/project: my-project + flyte.org/domain: dev + flyte.org/run: run-001 + flyte.org/action: task-001 + flyte.org/is-root: "true" +spec: + taskActionBytes: +``` + +**Child action with OwnerReference:** +```yaml +apiVersion: flyte.org/v1 +kind: TaskAction +metadata: + name: my-org-my-project-dev-run-001-task-002 + namespace: flyte + labels: + flyte.org/is-root: "false" + ownerReferences: + - apiVersion: flyte.org/v1 + kind: TaskAction + name: my-org-my-project-dev-run-001-task-001 + uid: + blockOwnerDeletion: true +spec: + taskActionBytes: +``` + +### Abort Queued Run + +When `AbortQueuedRun` is called: + +1. Finds root TaskAction (labeled `flyte.org/is-root: "true"`) +2. Deletes the root TaskAction +3. **Kubernetes automatically cascades the deletion** to all child TaskActions + +**Hierarchy example:** +``` +root-action (deleted manually) +โ”œโ”€ child-1 (deleted by K8s) +โ”‚ โ”œโ”€ grandchild-1 (deleted by K8s) +โ”‚ โ””โ”€ grandchild-2 (deleted by K8s) +โ””โ”€ child-2 (deleted by K8s) +``` + +### Abort Queued Action + +When `AbortQueuedAction` is called: + +1. Deletes the specific TaskAction +2. **Kubernetes automatically cascades the deletion** to any child TaskActions +3. Parent and sibling actions remain unaffected + +## Testing + +### Check service health + +```bash +# Health check +curl http://localhost:8089/healthz + +# Readiness check +curl http://localhost:8089/readyz +``` + +### View TaskActions in Kubernetes + +```bash +# List all TaskActions +kubectl get taskactions -n flyte + +# Watch TaskActions in real-time +kubectl get taskactions -n flyte -w + +# Get details of a specific TaskAction +kubectl describe taskaction -n flyte + +# View TaskAction hierarchy (via OwnerReferences) +kubectl get taskaction -n flyte -o yaml | grep -A 5 ownerReferences +``` + +### Test with queue client + +```bash +# Run the test client +go run testclient/main.go +``` + +Expected flow: +1. Client calls `EnqueueAction` โ†’ TaskAction CR created in K8s +2. Client calls `AbortQueuedRun` โ†’ Root TaskAction deleted, children cascade deleted +3. Verify in K8s: `kubectl get taskactions -n flyte` (should show deletions) + +## API Endpoints + +The service exposes the following buf connect endpoints: + +- `POST /flyteidl2.workflow.QueueService/EnqueueAction` - Create TaskAction CR +- `POST /flyteidl2.workflow.QueueService/AbortQueuedRun` - Delete root TaskAction (cascades) +- `POST /flyteidl2.workflow.QueueService/AbortQueuedAction` - Delete specific TaskAction (cascades) + +Plus health endpoints: +- `GET /healthz` - Health check +- `GET /readyz` - Readiness check + +## Kubernetes Resources + +### TaskAction CR Structure + +The TaskAction Custom Resource stores: +- **Spec:** Protobuf-encoded `ActionSpec` (includes task definition, inputs, etc.) +- **Labels:** For organization, filtering, and identifying root actions +- **OwnerReferences:** For automatic cascading deletion + +### Required RBAC + +The Queue Service needs permissions to: +```yaml +apiVersion: rbac.authorization.k8s.io/v1 +kind: Role +metadata: + name: queue-service + namespace: flyte +rules: +- apiGroups: ["flyte.org"] + resources: ["taskactions"] + verbs: ["get", "list", "watch", "create", "delete"] +``` + +## Project Structure + +``` +queue/ +โ”œโ”€โ”€ cmd/ +โ”‚ โ””โ”€โ”€ main.go # Entry point with K8s client setup +โ”œโ”€โ”€ config/ +โ”‚ โ””โ”€โ”€ config.go # Configuration structs +โ”œโ”€โ”€ k8s/ +โ”‚ โ””โ”€โ”€ client.go # Kubernetes operations (create/delete TaskActions) +โ”œโ”€โ”€ service/ +โ”‚ โ””โ”€โ”€ queue_service.go # gRPC service handlers +โ”œโ”€โ”€ client/ +โ”‚ โ””โ”€โ”€ main.go # Test client +โ”œโ”€โ”€ config.yaml # Configuration file +โ”œโ”€โ”€ Makefile # Build and test commands +โ””โ”€โ”€ README.md # This file +``` + +## Development + +### Build + +```bash +# Build the service +make build + +# Or manually +go build -o bin/queue-service ./cmd +``` + +### Run locally + +```bash +# Ensure you have a kubeconfig configured +export KUBECONFIG=~/.kube/config + +# Run the service +./bin/queue-service --config config.yaml +``` + +### Run in Kubernetes + +```bash +# Build Docker image +docker build -t queue-service:latest . + +# Deploy to K8s (requires deployment manifests) +kubectl apply -f k8s-manifests/ +``` + +## Advantages of Kubernetes-Native Design + +โœ… **No Database** - Kubernetes is the single source of truth +โœ… **Built-in Durability** - K8s etcd provides persistence +โœ… **Automatic Cleanup** - Cascading deletion via OwnerReferences +โœ… **Native Watching** - Controllers can watch CR changes +โœ… **Scalability** - Kubernetes handles distribution and scheduling +โœ… **Simpler Architecture** - One less component to manage +โœ… **Idiomatic K8s** - Leverages native Kubernetes patterns + +## Troubleshooting + +### Connection Issues + +**Error:** "failed to get Kubernetes config" +```bash +# Verify kubeconfig is valid +kubectl cluster-info + +# Or set explicit kubeconfig in config.yaml +queue: + kubernetes: + kubeconfig: "/path/to/kubeconfig" +``` + +### Permission Issues + +**Error:** "failed to create TaskAction CR: forbidden" + +Ensure the service has proper RBAC permissions: +```bash +kubectl create role queue-service \ + --verb=get,list,watch,create,delete \ + --resource=taskactions \ + -n flyte + +kubectl create rolebinding queue-service \ + --role=queue-service \ + --serviceaccount=flyte:queue-service \ + -n flyte +``` + +### TaskAction CRD Not Found + +**Error:** "no matches for kind TaskAction" + +Install the TaskAction CRD: +```bash +kubectl apply -f executor/config/crd/ +``` diff --git a/queue/TEST_RESULTS.md b/queue/TEST_RESULTS.md new file mode 100644 index 0000000000..02911cec40 --- /dev/null +++ b/queue/TEST_RESULTS.md @@ -0,0 +1,116 @@ +# Queue Service - Test Results โœ… + +## Test Run Summary + +**Date**: October 3, 2025 +**Database**: SQLite (./queue.db) +**Status**: All tests passed! ๐ŸŽ‰ + +## Test Results + +### Health Checks +- โœ… `/healthz` - OK +- โœ… `/readyz` - OK + +### Functional Tests + +**Test 1: Enqueue Action** +- โœ… Successfully enqueued `task-001` for `run-001` + +**Test 2: Enqueue Nested Action** +- โœ… Successfully enqueued `task-002` with parent `task-001` + +**Test 3: Abort Single Action** +- โœ… Successfully aborted `task-002` + +**Test 4: Enqueue Action in Different Run** +- โœ… Successfully enqueued `task-001` for `run-002` + +**Test 5: Abort Entire Run** +- โœ… Successfully aborted all actions in `run-001` + +## Database Verification + +### Final State + +| ID | Org | Project | Domain | Run | Action | Status | Enqueued At | +|----|-----|---------|--------|-----|--------|--------|-------------| +| 1 | my-org | my-project | development | run-001 | task-001 | **aborted** | 2025-10-03 16:30:06 | +| 2 | my-org | my-project | development | run-001 | task-002 | **aborted** | 2025-10-03 16:30:06 | +| 3 | my-org | my-project | development | run-002 | task-001 | **queued** | 2025-10-03 16:30:06 | + +### Schema Verification + +โœ… Table `queued_actions` created successfully with: +- All required columns +- 5 indexes for performance: + - `idx_queued_actions_status` + - `idx_queued_actions_enqueued` + - `idx_queued_actions_parent` + - `idx_queued_actions_run` + - `idx_queued_actions_identifier` (composite) + +## Database Support + +The service now supports **both databases**: + +### SQLite (Default) +```yaml +database: + sqlite: + file: "./queue.db" +``` +- โœ… No external setup required +- โœ… Perfect for testing and development +- โœ… Single file storage + +### PostgreSQL +```yaml +database: + postgres: + host: "localhost" + port: 5432 + dbname: "flyte_queue" + username: "postgres" + password: "postgres" + extraOptions: "sslmode=disable" + maxIdleConnections: 10 + maxOpenConnections: 100 + connMaxLifeTime: 1h +``` +- โœ… Production-ready +- โœ… Connection pooling +- โœ… Auto-creates database if missing + +## Performance Observations + +- Service startup: ~1 second +- Database migrations: Instant +- API response time: <10ms per request +- All 5 test scenarios completed in <1 second + +## Files Created + +``` +queue/ +โ”œโ”€โ”€ bin/ +โ”‚ โ””โ”€โ”€ queue-service (36MB) # Compiled binary +โ”œโ”€โ”€ queue.db # SQLite database +โ”œโ”€โ”€ config.yaml # SQLite config (default) +โ””โ”€โ”€ config-postgres.yaml # PostgreSQL config +``` + +## Next Steps + +The Queue Service is now **production-ready** with: +- โœ… Multi-database support (SQLite + PostgreSQL) +- โœ… Full CRUD operations +- โœ… Health checks +- โœ… Graceful shutdown +- โœ… Database migrations +- โœ… Comprehensive testing + +Ready to implement: +- RunService (with streaming RPCs) +- StateService (with PostgreSQL LISTEN/NOTIFY) +- Unified binary (all services + executor) diff --git a/queue/cmd/main.go b/queue/cmd/main.go new file mode 100644 index 0000000000..efe02720c1 --- /dev/null +++ b/queue/cmd/main.go @@ -0,0 +1,194 @@ +package main + +import ( + "context" + "errors" + "fmt" + "net/http" + "os" + "os/signal" + "syscall" + "time" + + "github.com/spf13/cobra" + "golang.org/x/net/http2" + "golang.org/x/net/http2/h2c" + "k8s.io/client-go/rest" + "k8s.io/client-go/tools/clientcmd" + "sigs.k8s.io/controller-runtime/pkg/client" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/config/viper" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow/workflowconnect" + queueconfig "github.com/flyteorg/flyte/v2/queue/config" + "github.com/flyteorg/flyte/v2/queue/k8s" + "github.com/flyteorg/flyte/v2/queue/service" +) + +var ( + cfgFile string + rootCmd = &cobra.Command{ + Use: "queue-service", + Short: "Queue Service for Flyte", + RunE: func(cmd *cobra.Command, args []string) error { + return serve(cmd.Context()) + }, + } +) + +func init() { + rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.flyte/config.yaml)") +} + +func main() { + if err := rootCmd.Execute(); err != nil { + os.Exit(1) + } +} + +func serve(ctx context.Context) error { + // Initialize config + if err := initConfig(); err != nil { + return fmt.Errorf("failed to initialize config: %w", err) + } + + // Initialize logger + logConfig := logger.GetConfig() + if err := logger.SetConfig(logConfig); err != nil { + return fmt.Errorf("failed to initialize logger: %w", err) + } + + logger.Infof(ctx, "Starting Queue Service") + + // Get configuration + cfg := queueconfig.GetConfig() + + // Initialize Kubernetes client + k8sClient, err := initKubernetesClient(ctx, &cfg.Kubernetes) + if err != nil { + return fmt.Errorf("failed to initialize Kubernetes client: %w", err) + } + + // Initialize the executor API scheme + if err := k8s.InitScheme(); err != nil { + return fmt.Errorf("failed to initialize scheme: %w", err) + } + + // Create queue client + queueClient := k8s.NewQueueClient(k8sClient, cfg.Kubernetes.Namespace) + logger.Infof(ctx, "Kubernetes client initialized for namespace: %s", cfg.Kubernetes.Namespace) + + // Create service + queueSvc := service.NewQueueService(queueClient) + + // Setup HTTP server with Connect handlers + mux := http.NewServeMux() + + // Mount the Queue Service + path, handler := workflowconnect.NewQueueServiceHandler(queueSvc) + mux.Handle(path, handler) + + // Add health check endpoint + mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte("OK")) + }) + + // Add readiness check endpoint + mux.HandleFunc("/readyz", func(w http.ResponseWriter, r *http.Request) { + // Queue service is always ready (no database to check) + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte("OK")) + }) + + // Setup HTTP/2 support (required for gRPC) + addr := fmt.Sprintf("%s:%d", cfg.Server.Host, cfg.Server.Port) + server := &http.Server{ + Addr: addr, + Handler: h2c.NewHandler(mux, &http2.Server{}), + } + + // Start server in a goroutine + errCh := make(chan error, 1) + go func() { + logger.Infof(ctx, "Queue Service listening on %s", addr) + if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { + errCh <- fmt.Errorf("server error: %w", err) + } + }() + + // Wait for interrupt signal or error + sigCh := make(chan os.Signal, 1) + signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM) + + select { + case sig := <-sigCh: + logger.Infof(ctx, "Received signal %v, shutting down gracefully...", sig) + case err := <-errCh: + return err + } + + // Graceful shutdown + shutdownCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + + if err := server.Shutdown(shutdownCtx); err != nil { + return fmt.Errorf("server shutdown failed: %w", err) + } + + logger.Infof(ctx, "Queue Service stopped") + return nil +} + +func initConfig() error { + // Use viper to load config + configAccessor := viper.NewAccessor(config.Options{ + SearchPaths: []string{cfgFile, ".", "/etc/flyte/config"}, + StrictMode: false, + }) + + return configAccessor.UpdateConfig(context.Background()) +} + +func initKubernetesClient(ctx context.Context, cfg *queueconfig.KubernetesConfig) (client.Client, error) { + var restConfig *rest.Config + var err error + + if cfg.KubeConfig != "" { + // Use explicitly configured kubeconfig file + logger.Infof(ctx, "Using kubeconfig from: %s", cfg.KubeConfig) + restConfig, err = clientcmd.BuildConfigFromFlags("", cfg.KubeConfig) + if err != nil { + return nil, fmt.Errorf("failed to build k8s config from flags: %w", err) + } + } else { + // Try in-cluster config first + logger.Infof(ctx, "Attempting to use in-cluster Kubernetes configuration") + restConfig, err = rest.InClusterConfig() + + if err != nil { + // Fall back to default kubeconfig location + logger.Infof(ctx, "In-cluster config not available, falling back to default kubeconfig") + loadingRules := clientcmd.NewDefaultClientConfigLoadingRules() + configOverrides := &clientcmd.ConfigOverrides{} + kubeConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(loadingRules, configOverrides) + restConfig, err = kubeConfig.ClientConfig() + + if err != nil { + return nil, fmt.Errorf("failed to get Kubernetes config (tried in-cluster and default kubeconfig): %w", err) + } + + logger.Infof(ctx, "Using default kubeconfig from standard locations (~/.kube/config)") + } + } + + // Create the controller-runtime client + k8sClient, err := client.New(restConfig, client.Options{}) + if err != nil { + return nil, fmt.Errorf("failed to create Kubernetes client: %w", err) + } + + logger.Infof(ctx, "Kubernetes client initialized successfully") + return k8sClient, nil +} diff --git a/queue/config.yaml b/queue/config.yaml new file mode 100644 index 0000000000..991be86114 --- /dev/null +++ b/queue/config.yaml @@ -0,0 +1,16 @@ +# Queue Service Configuration + +queue: + server: + host: "0.0.0.0" + port: 8089 + kubernetes: + namespace: "flyte" + # Optional kubeconfig path. If not specified: + # 1. Tries in-cluster config (when running in Kubernetes) + # 2. Falls back to default kubeconfig (~/.kube/config) + # kubeconfig: "/path/to/custom/kubeconfig" + +logger: + level: 4 # Info level + show-source: true diff --git a/queue/config/config.go b/queue/config/config.go new file mode 100644 index 0000000000..93c2331025 --- /dev/null +++ b/queue/config/config.go @@ -0,0 +1,50 @@ +package config + +import ( + "github.com/flyteorg/flyte/v2/flytestdlib/config" +) + +const configSectionKey = "queue" + +//go:generate pflags Config --default-var=defaultConfig + +var defaultConfig = &Config{ + Server: ServerConfig{ + Port: 8089, + Host: "0.0.0.0", + }, + Kubernetes: KubernetesConfig{ + Namespace: "flyte", + }, +} + +var configSection = config.MustRegisterSection(configSectionKey, defaultConfig) + +// Config holds the configuration for the Queue service +type Config struct { + // HTTP server configuration + Server ServerConfig `json:"server"` + + // Kubernetes configuration + Kubernetes KubernetesConfig `json:"kubernetes"` +} + +// ServerConfig holds HTTP server configuration +type ServerConfig struct { + Port int `json:"port" pflag:",Port to bind the HTTP server"` + Host string `json:"host" pflag:",Host to bind the HTTP server"` +} + +// KubernetesConfig holds Kubernetes client configuration +type KubernetesConfig struct { + // Namespace where TaskAction CRs will be created + Namespace string `json:"namespace" pflag:",Kubernetes namespace for TaskAction CRs"` + + // KubeConfig path (optional - if empty, uses in-cluster config) + KubeConfig string `json:"kubeconfig" pflag:",Path to kubeconfig file (optional)"` +} + +// GetConfig returns the parsed queue configuration +func GetConfig() *Config { + return configSection.GetConfig().(*Config) +} diff --git a/queue/config/default/kustomization.yaml b/queue/config/default/kustomization.yaml new file mode 100644 index 0000000000..aa790cf4a7 --- /dev/null +++ b/queue/config/default/kustomization.yaml @@ -0,0 +1,10 @@ +apiVersion: kustomize.config.k8s.io/v1beta1 +kind: Kustomization + +# Namespace applied to all resources +namespace: flyte + +resources: + - ../rbac + - ../manager + diff --git a/queue/config/manager/kustomization.yaml b/queue/config/manager/kustomization.yaml new file mode 100644 index 0000000000..623d2576ec --- /dev/null +++ b/queue/config/manager/kustomization.yaml @@ -0,0 +1,6 @@ +apiVersion: kustomize.config.k8s.io/v1beta1 +kind: Kustomization + +resources: + - manager.yaml + diff --git a/queue/config/manager/manager.yaml b/queue/config/manager/manager.yaml new file mode 100644 index 0000000000..b5ecfd8458 --- /dev/null +++ b/queue/config/manager/manager.yaml @@ -0,0 +1,48 @@ +apiVersion: apps/v1 +kind: Deployment +metadata: + name: queue +spec: + replicas: 1 + selector: + matchLabels: + app: queue + template: + metadata: + labels: + app: queue + spec: + serviceAccountName: queue-sa + containers: + - name: queue + image: flyte-queue:latest + imagePullPolicy: IfNotPresent + args: ["--config", "/app/config.yaml"] + ports: + - containerPort: 8089 + name: http + readinessProbe: + httpGet: + path: /readyz + port: http + initialDelaySeconds: 2 + periodSeconds: 5 + livenessProbe: + httpGet: + path: /healthz + port: http + initialDelaySeconds: 5 + periodSeconds: 10 +--- +apiVersion: v1 +kind: Service +metadata: + name: queue +spec: + selector: + app: queue + ports: + - name: http + port: 8089 + targetPort: http + diff --git a/queue/config/rbac/kustomization.yaml b/queue/config/rbac/kustomization.yaml new file mode 100644 index 0000000000..e3dbb48f7c --- /dev/null +++ b/queue/config/rbac/kustomization.yaml @@ -0,0 +1,8 @@ +apiVersion: kustomize.config.k8s.io/v1beta1 +kind: Kustomization + +resources: + - service_account.yaml + - role.yaml + - role_binding.yaml + diff --git a/queue/config/rbac/role.yaml b/queue/config/rbac/role.yaml new file mode 100644 index 0000000000..e6ec53ee2b --- /dev/null +++ b/queue/config/rbac/role.yaml @@ -0,0 +1,15 @@ +apiVersion: rbac.authorization.k8s.io/v1 +kind: Role +metadata: + name: queue-role +rules: +- apiGroups: + - flyte.org + resources: + - taskactions + verbs: + - create + - delete + - get + - list + - watch diff --git a/queue/config/rbac/role_binding.yaml b/queue/config/rbac/role_binding.yaml new file mode 100644 index 0000000000..ad62b0bdad --- /dev/null +++ b/queue/config/rbac/role_binding.yaml @@ -0,0 +1,12 @@ +apiVersion: rbac.authorization.k8s.io/v1 +kind: RoleBinding +metadata: + name: queue-rb +subjects: + - kind: ServiceAccount + name: queue-sa +roleRef: + kind: Role + name: queue-role + apiGroup: rbac.authorization.k8s.io + diff --git a/queue/config/rbac/service_account.yaml b/queue/config/rbac/service_account.yaml new file mode 100644 index 0000000000..5a3eb75628 --- /dev/null +++ b/queue/config/rbac/service_account.yaml @@ -0,0 +1,7 @@ +apiVersion: v1 +kind: ServiceAccount +metadata: + labels: + app.kubernetes.io/name: queue + app.kubernetes.io/managed-by: kustomize + name: queue-sa diff --git a/queue/k8s/client.go b/queue/k8s/client.go new file mode 100644 index 0000000000..0514c3170d --- /dev/null +++ b/queue/k8s/client.go @@ -0,0 +1,238 @@ +package k8s + +import ( + "context" + "fmt" + + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/kubernetes/scheme" + "sigs.k8s.io/controller-runtime/pkg/client" + + executorv1 "github.com/flyteorg/flyte/v2/executor/api/v1" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// QueueClient implements queue operations using Kubernetes TaskAction CRs +type QueueClient struct { + k8sClient client.Client + namespace string +} + +// NewQueueClient creates a new Kubernetes-based queue client +func NewQueueClient(k8sClient client.Client, namespace string) *QueueClient { + return &QueueClient{ + k8sClient: k8sClient, + namespace: namespace, + } +} + +// EnqueueAction creates a TaskAction CR in Kubernetes +func (q *QueueClient) EnqueueAction(ctx context.Context, req *workflow.EnqueueActionRequest) error { + logger.Infof(ctx, "Enqueuing action: %s/%s/%s/%s/%s", + req.ActionId.Run.Org, req.ActionId.Run.Project, req.ActionId.Run.Domain, + req.ActionId.Run.Name, req.ActionId.Name) + + // Build ActionSpec from EnqueueActionRequest + actionSpec := buildActionSpec(req) + + // Determine if this is the root action + isRootAction := req.ParentActionName == nil || *req.ParentActionName == "" + + // Create TaskAction CR + taskAction := &executorv1.TaskAction{ + ObjectMeta: metav1.ObjectMeta{ + Name: buildTaskActionName(req.ActionId), + Namespace: q.namespace, + Labels: map[string]string{ + "flyte.org/org": req.ActionId.Run.Org, + "flyte.org/project": req.ActionId.Run.Project, + "flyte.org/domain": req.ActionId.Run.Domain, + "flyte.org/run": req.ActionId.Run.Name, + "flyte.org/action": req.ActionId.Name, + "flyte.org/action-type": "task", // TODO: detect from spec + "flyte.org/is-root": fmt.Sprintf("%t", isRootAction), + }, + }, + Spec: executorv1.TaskActionSpec{}, + } + + // If this is not the root action, set the owner reference to the parent action + if !isRootAction { + parentActionID := &common.ActionIdentifier{ + Run: req.ActionId.Run, + Name: *req.ParentActionName, + } + parentTaskActionName := buildTaskActionName(parentActionID) + + // Get the parent TaskAction to set as owner + parentTaskAction := &executorv1.TaskAction{} + if err := q.k8sClient.Get(ctx, client.ObjectKey{ + Name: parentTaskActionName, + Namespace: q.namespace, + }, parentTaskAction); err != nil { + return fmt.Errorf("failed to get parent TaskAction %s: %w", parentTaskActionName, err) + } + + // Set owner reference with cascading deletion enabled + blockOwnerDeletion := true + taskAction.OwnerReferences = []metav1.OwnerReference{ + { + APIVersion: "flyte.org/v1", + Kind: "TaskAction", + Name: parentTaskAction.Name, + UID: parentTaskAction.UID, + BlockOwnerDeletion: &blockOwnerDeletion, + }, + } + + logger.Infof(ctx, "Setting parent TaskAction %s as owner for %s", + parentTaskActionName, taskAction.Name) + } else { + logger.Infof(ctx, "Creating root TaskAction: %s", taskAction.Name) + } + + // Set the ActionSpec bytes + if err := taskAction.Spec.SetActionSpec(actionSpec); err != nil { + return fmt.Errorf("failed to set action spec: %w", err) + } + + // Create in Kubernetes + if err := q.k8sClient.Create(ctx, taskAction); err != nil { + return fmt.Errorf("failed to create TaskAction CR: %w", err) + } + + logger.Infof(ctx, "Successfully created TaskAction CR: %s", taskAction.Name) + return nil +} + +// AbortQueuedRun deletes the root TaskAction CR for a run +// Kubernetes will automatically cascade delete all child TaskActions via OwnerReferences +func (q *QueueClient) AbortQueuedRun(ctx context.Context, runID *common.RunIdentifier, reason *string) error { + logger.Infof(ctx, "Aborting run by deleting root TaskAction: %s/%s/%s/%s", + runID.Org, runID.Project, runID.Domain, runID.Name) + + // Find the root TaskAction for this run + taskActionList := &executorv1.TaskActionList{} + listOpts := []client.ListOption{ + client.InNamespace(q.namespace), + client.MatchingLabels{ + "flyte.org/org": runID.Org, + "flyte.org/project": runID.Project, + "flyte.org/domain": runID.Domain, + "flyte.org/run": runID.Name, + "flyte.org/is-root": "true", + }, + } + + if err := q.k8sClient.List(ctx, taskActionList, listOpts...); err != nil { + return fmt.Errorf("failed to list TaskActions: %w", err) + } + + if len(taskActionList.Items) == 0 { + logger.Warnf(ctx, "No root TaskAction found for run %s", runID.Name) + return nil + } + + if len(taskActionList.Items) > 1 { + logger.Warnf(ctx, "Found %d root TaskActions for run %s, expected 1", + len(taskActionList.Items), runID.Name) + } + + // Delete the root TaskAction - Kubernetes will cascade delete all children + rootTaskAction := &taskActionList.Items[0] + if err := q.k8sClient.Delete(ctx, rootTaskAction); err != nil { + return fmt.Errorf("failed to delete root TaskAction %s: %w", rootTaskAction.Name, err) + } + + logger.Infof(ctx, "Deleted root TaskAction: %s (children will be cascade deleted by Kubernetes)", + rootTaskAction.Name) + return nil +} + +// AbortQueuedAction deletes a specific TaskAction CR +// If the action has children, Kubernetes will cascade delete them via OwnerReferences +func (q *QueueClient) AbortQueuedAction(ctx context.Context, actionID *common.ActionIdentifier, reason *string) error { + logger.Infof(ctx, "Aborting action: %s/%s/%s/%s/%s", + actionID.Run.Org, actionID.Run.Project, actionID.Run.Domain, + actionID.Run.Name, actionID.Name) + + taskActionName := buildTaskActionName(actionID) + + // Get the TaskAction to check if it exists and if it's a root action + taskAction := &executorv1.TaskAction{} + if err := q.k8sClient.Get(ctx, client.ObjectKey{ + Name: taskActionName, + Namespace: q.namespace, + }, taskAction); err != nil { + return fmt.Errorf("failed to get TaskAction %s: %w", taskActionName, err) + } + + isRoot := taskAction.Labels["flyte.org/is-root"] == "true" + + // Delete the TaskAction - children will be cascade deleted by Kubernetes + if err := q.k8sClient.Delete(ctx, taskAction); err != nil { + return fmt.Errorf("failed to delete TaskAction %s: %w", taskActionName, err) + } + + if isRoot { + logger.Infof(ctx, "Deleted root TaskAction %s (all child actions will be cascade deleted)", + taskActionName) + } else { + logger.Infof(ctx, "Deleted TaskAction %s (any child actions will be cascade deleted)", + taskActionName) + } + + return nil +} + +// Helper functions + +// buildTaskActionName generates a Kubernetes-compliant name for the TaskAction +func buildTaskActionName(actionID *common.ActionIdentifier) string { + // K8s names must be lowercase alphanumeric, dashes, or dots + // Format: org-project-domain-run-action + return fmt.Sprintf("%s-%s-%s-%s-%s", + actionID.Run.Org, + actionID.Run.Project, + actionID.Run.Domain, + actionID.Run.Name, + actionID.Name, + ) +} + +// buildActionSpec converts EnqueueActionRequest to ActionSpec +func buildActionSpec(req *workflow.EnqueueActionRequest) *workflow.ActionSpec { + actionSpec := &workflow.ActionSpec{ + ActionId: req.ActionId, + ParentActionName: req.ParentActionName, + RunSpec: req.RunSpec, + InputUri: req.InputUri, + RunOutputBase: req.RunOutputBase, + Group: req.Group, + } + + // Set the spec based on the request type + switch spec := req.Spec.(type) { + case *workflow.EnqueueActionRequest_Task: + actionSpec.Spec = &workflow.ActionSpec_Task{ + Task: spec.Task, + } + case *workflow.EnqueueActionRequest_Trace: + actionSpec.Spec = &workflow.ActionSpec_Trace{ + Trace: spec.Trace, + } + case *workflow.EnqueueActionRequest_Condition: + actionSpec.Spec = &workflow.ActionSpec_Condition{ + Condition: spec.Condition, + } + } + + return actionSpec +} + +// InitScheme adds the executor API types to the scheme +func InitScheme() error { + return executorv1.AddToScheme(scheme.Scheme) +} diff --git a/queue/service/interfaces.go b/queue/service/interfaces.go new file mode 100644 index 0000000000..26876a43ad --- /dev/null +++ b/queue/service/interfaces.go @@ -0,0 +1,16 @@ +package service + +import ( + "context" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// QueueClientInterface defines the interface for queue operations +// This allows for easier testing and mocking +type QueueClientInterface interface { + EnqueueAction(ctx context.Context, req *workflow.EnqueueActionRequest) error + AbortQueuedRun(ctx context.Context, runID *common.RunIdentifier, reason *string) error + AbortQueuedAction(ctx context.Context, actionID *common.ActionIdentifier, reason *string) error +} diff --git a/queue/service/mocks/queue_client_interface.go b/queue/service/mocks/queue_client_interface.go new file mode 100644 index 0000000000..cdc1f3f7f3 --- /dev/null +++ b/queue/service/mocks/queue_client_interface.go @@ -0,0 +1,183 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + + mock "github.com/stretchr/testify/mock" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// QueueClientInterface is an autogenerated mock type for the QueueClientInterface type +type QueueClientInterface struct { + mock.Mock +} + +type QueueClientInterface_Expecter struct { + mock *mock.Mock +} + +func (_m *QueueClientInterface) EXPECT() *QueueClientInterface_Expecter { + return &QueueClientInterface_Expecter{mock: &_m.Mock} +} + +// AbortQueuedAction provides a mock function with given fields: ctx, actionID, reason +func (_m *QueueClientInterface) AbortQueuedAction(ctx context.Context, actionID *common.ActionIdentifier, reason *string) error { + ret := _m.Called(ctx, actionID, reason) + + if len(ret) == 0 { + panic("no return value specified for AbortQueuedAction") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *common.ActionIdentifier, *string) error); ok { + r0 = rf(ctx, actionID, reason) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// QueueClientInterface_AbortQueuedAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortQueuedAction' +type QueueClientInterface_AbortQueuedAction_Call struct { + *mock.Call +} + +// AbortQueuedAction is a helper method to define mock.On call +// - ctx context.Context +// - actionID *common.ActionIdentifier +// - reason *string +func (_e *QueueClientInterface_Expecter) AbortQueuedAction(ctx interface{}, actionID interface{}, reason interface{}) *QueueClientInterface_AbortQueuedAction_Call { + return &QueueClientInterface_AbortQueuedAction_Call{Call: _e.mock.On("AbortQueuedAction", ctx, actionID, reason)} +} + +func (_c *QueueClientInterface_AbortQueuedAction_Call) Run(run func(ctx context.Context, actionID *common.ActionIdentifier, reason *string)) *QueueClientInterface_AbortQueuedAction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*common.ActionIdentifier), args[2].(*string)) + }) + return _c +} + +func (_c *QueueClientInterface_AbortQueuedAction_Call) Return(_a0 error) *QueueClientInterface_AbortQueuedAction_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueueClientInterface_AbortQueuedAction_Call) RunAndReturn(run func(context.Context, *common.ActionIdentifier, *string) error) *QueueClientInterface_AbortQueuedAction_Call { + _c.Call.Return(run) + return _c +} + +// AbortQueuedRun provides a mock function with given fields: ctx, runID, reason +func (_m *QueueClientInterface) AbortQueuedRun(ctx context.Context, runID *common.RunIdentifier, reason *string) error { + ret := _m.Called(ctx, runID, reason) + + if len(ret) == 0 { + panic("no return value specified for AbortQueuedRun") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *common.RunIdentifier, *string) error); ok { + r0 = rf(ctx, runID, reason) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// QueueClientInterface_AbortQueuedRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortQueuedRun' +type QueueClientInterface_AbortQueuedRun_Call struct { + *mock.Call +} + +// AbortQueuedRun is a helper method to define mock.On call +// - ctx context.Context +// - runID *common.RunIdentifier +// - reason *string +func (_e *QueueClientInterface_Expecter) AbortQueuedRun(ctx interface{}, runID interface{}, reason interface{}) *QueueClientInterface_AbortQueuedRun_Call { + return &QueueClientInterface_AbortQueuedRun_Call{Call: _e.mock.On("AbortQueuedRun", ctx, runID, reason)} +} + +func (_c *QueueClientInterface_AbortQueuedRun_Call) Run(run func(ctx context.Context, runID *common.RunIdentifier, reason *string)) *QueueClientInterface_AbortQueuedRun_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*common.RunIdentifier), args[2].(*string)) + }) + return _c +} + +func (_c *QueueClientInterface_AbortQueuedRun_Call) Return(_a0 error) *QueueClientInterface_AbortQueuedRun_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueueClientInterface_AbortQueuedRun_Call) RunAndReturn(run func(context.Context, *common.RunIdentifier, *string) error) *QueueClientInterface_AbortQueuedRun_Call { + _c.Call.Return(run) + return _c +} + +// EnqueueAction provides a mock function with given fields: ctx, req +func (_m *QueueClientInterface) EnqueueAction(ctx context.Context, req *workflow.EnqueueActionRequest) error { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for EnqueueAction") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.EnqueueActionRequest) error); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// QueueClientInterface_EnqueueAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnqueueAction' +type QueueClientInterface_EnqueueAction_Call struct { + *mock.Call +} + +// EnqueueAction is a helper method to define mock.On call +// - ctx context.Context +// - req *workflow.EnqueueActionRequest +func (_e *QueueClientInterface_Expecter) EnqueueAction(ctx interface{}, req interface{}) *QueueClientInterface_EnqueueAction_Call { + return &QueueClientInterface_EnqueueAction_Call{Call: _e.mock.On("EnqueueAction", ctx, req)} +} + +func (_c *QueueClientInterface_EnqueueAction_Call) Run(run func(ctx context.Context, req *workflow.EnqueueActionRequest)) *QueueClientInterface_EnqueueAction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.EnqueueActionRequest)) + }) + return _c +} + +func (_c *QueueClientInterface_EnqueueAction_Call) Return(_a0 error) *QueueClientInterface_EnqueueAction_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *QueueClientInterface_EnqueueAction_Call) RunAndReturn(run func(context.Context, *workflow.EnqueueActionRequest) error) *QueueClientInterface_EnqueueAction_Call { + _c.Call.Return(run) + return _c +} + +// NewQueueClientInterface creates a new instance of QueueClientInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewQueueClientInterface(t interface { + mock.TestingT + Cleanup(func()) +}) *QueueClientInterface { + mock := &QueueClientInterface{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/queue/service/queue_service.go b/queue/service/queue_service.go new file mode 100644 index 0000000000..fa12cacd89 --- /dev/null +++ b/queue/service/queue_service.go @@ -0,0 +1,111 @@ +package service + +import ( + "context" + + "connectrpc.com/connect" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow/workflowconnect" + "github.com/flyteorg/flyte/v2/queue/k8s" +) + +// QueueService implements the QueueServiceHandler interface +type QueueService struct { + k8sClient QueueClientInterface +} + +// NewQueueService creates a new QueueService instance +func NewQueueService(k8sClient *k8s.QueueClient) *QueueService { + return &QueueService{k8sClient: k8sClient} +} + +// NewQueueServiceWithClient creates a new QueueService with a custom client implementation +// This is useful for testing +func NewQueueServiceWithClient(client QueueClientInterface) *QueueService { + return &QueueService{k8sClient: client} +} + +// Ensure we implement the interface +var _ workflowconnect.QueueServiceHandler = (*QueueService)(nil) + +// EnqueueAction creates a TaskAction CR in Kubernetes +func (s *QueueService) EnqueueAction( + ctx context.Context, + req *connect.Request[workflow.EnqueueActionRequest], +) (*connect.Response[workflow.EnqueueActionResponse], error) { + logger.Infof(ctx, "Received EnqueueAction request for action: %s/%s/%s/%s/%s", + req.Msg.ActionId.Run.Org, + req.Msg.ActionId.Run.Project, + req.Msg.ActionId.Run.Domain, + req.Msg.ActionId.Run.Name, + req.Msg.ActionId.Name) + + // Validate request using buf validate + if err := req.Msg.Validate(); err != nil { + logger.Errorf(ctx, "Invalid EnqueueAction request: %v", err) + return nil, connect.NewError(connect.CodeInvalidArgument, err) + } + + // Create TaskAction CR in Kubernetes + if err := s.k8sClient.EnqueueAction(ctx, req.Msg); err != nil { + logger.Errorf(ctx, "Failed to create TaskAction CR: %v", err) + return nil, connect.NewError(connect.CodeInternal, err) + } + + return connect.NewResponse(&workflow.EnqueueActionResponse{}), nil +} + +// AbortQueuedRun deletes all TaskAction CRs for a run +func (s *QueueService) AbortQueuedRun( + ctx context.Context, + req *connect.Request[workflow.AbortQueuedRunRequest], +) (*connect.Response[workflow.AbortQueuedRunResponse], error) { + logger.Infof(ctx, "Received AbortQueuedRun request for run: %s/%s/%s/%s", + req.Msg.RunId.Org, + req.Msg.RunId.Project, + req.Msg.RunId.Domain, + req.Msg.RunId.Name) + + // Validate request + if err := req.Msg.Validate(); err != nil { + logger.Errorf(ctx, "Invalid AbortQueuedRun request: %v", err) + return nil, connect.NewError(connect.CodeInvalidArgument, err) + } + + // Delete all TaskAction CRs for this run + if err := s.k8sClient.AbortQueuedRun(ctx, req.Msg.RunId, req.Msg.Reason); err != nil { + logger.Errorf(ctx, "Failed to abort queued run: %v", err) + return nil, connect.NewError(connect.CodeInternal, err) + } + + return connect.NewResponse(&workflow.AbortQueuedRunResponse{}), nil +} + +// AbortQueuedAction deletes a specific TaskAction CR +func (s *QueueService) AbortQueuedAction( + ctx context.Context, + req *connect.Request[workflow.AbortQueuedActionRequest], +) (*connect.Response[workflow.AbortQueuedActionResponse], error) { + logger.Infof(ctx, "Received AbortQueuedAction request for action: %s/%s/%s/%s/%s", + req.Msg.ActionId.Run.Org, + req.Msg.ActionId.Run.Project, + req.Msg.ActionId.Run.Domain, + req.Msg.ActionId.Run.Name, + req.Msg.ActionId.Name) + + // Validate request + if err := req.Msg.Validate(); err != nil { + logger.Errorf(ctx, "Invalid AbortQueuedAction request: %v", err) + return nil, connect.NewError(connect.CodeInvalidArgument, err) + } + + // Delete the TaskAction CR + if err := s.k8sClient.AbortQueuedAction(ctx, req.Msg.ActionId, req.Msg.Reason); err != nil { + logger.Errorf(ctx, "Failed to abort queued action: %v", err) + return nil, connect.NewError(connect.CodeInternal, err) + } + + return connect.NewResponse(&workflow.AbortQueuedActionResponse{}), nil +} diff --git a/queue/service/queue_service_test.go b/queue/service/queue_service_test.go new file mode 100644 index 0000000000..5c76e52d5c --- /dev/null +++ b/queue/service/queue_service_test.go @@ -0,0 +1,116 @@ +package service + +import ( + "context" + "testing" + + "connectrpc.com/connect" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + "github.com/flyteorg/flyte/v2/queue/service/mocks" +) + +func TestEnqueueAction(t *testing.T) { + mockClient := mocks.NewQueueClientInterface(t) + svc := NewQueueServiceWithClient(mockClient) + + req := &workflow.EnqueueActionRequest{ + ActionId: &common.ActionIdentifier{ + Run: &common.RunIdentifier{ + Org: "test-org", + Project: "test-project", + Domain: "test-domain", + Name: "test-run", + }, + Name: "test-action", + }, + InputUri: "s3://bucket/input", + RunOutputBase: "s3://bucket/output", + Spec: &workflow.EnqueueActionRequest_Task{ + Task: &workflow.TaskAction{ + Spec: &task.TaskSpec{ + TaskTemplate: &core.TaskTemplate{ + Type: "container", + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Image: "alpine:latest", + Args: []string{"echo", "hello"}, + }, + }, + }, + }, + }, + }, + } + + mockClient.EXPECT().EnqueueAction(mock.Anything, req).Return(nil) + + connectReq := connect.NewRequest(req) + resp, err := svc.EnqueueAction(context.Background(), connectReq) + + assert.NoError(t, err) + assert.NotNil(t, resp) + mockClient.AssertExpectations(t) +} + +func TestAbortQueuedRun(t *testing.T) { + mockClient := mocks.NewQueueClientInterface(t) + svc := NewQueueServiceWithClient(mockClient) + + runID := &common.RunIdentifier{ + Org: "test-org", + Project: "test-project", + Domain: "test-domain", + Name: "test-run", + } + + reason := "test abort" + req := &workflow.AbortQueuedRunRequest{ + RunId: runID, + Reason: &reason, + } + + mockClient.EXPECT().AbortQueuedRun(mock.Anything, runID, &reason).Return(nil) + + connectReq := connect.NewRequest(req) + resp, err := svc.AbortQueuedRun(context.Background(), connectReq) + + assert.NoError(t, err) + assert.NotNil(t, resp) + mockClient.AssertExpectations(t) +} + +func TestAbortQueuedAction(t *testing.T) { + mockClient := mocks.NewQueueClientInterface(t) + svc := NewQueueServiceWithClient(mockClient) + + actionID := &common.ActionIdentifier{ + Run: &common.RunIdentifier{ + Org: "test-org", + Project: "test-project", + Domain: "test-domain", + Name: "test-run", + }, + Name: "test-action", + } + + reason := "test abort" + req := &workflow.AbortQueuedActionRequest{ + ActionId: actionID, + Reason: &reason, + } + + mockClient.EXPECT().AbortQueuedAction(mock.Anything, actionID, &reason).Return(nil) + + connectReq := connect.NewRequest(req) + resp, err := svc.AbortQueuedAction(context.Background(), connectReq) + + assert.NoError(t, err) + assert.NotNil(t, resp) + mockClient.AssertExpectations(t) +} diff --git a/queue/start-postgres.sh b/queue/start-postgres.sh new file mode 100755 index 0000000000..f67c7031ec --- /dev/null +++ b/queue/start-postgres.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +# Stop any existing container +docker stop flyte-queue-postgres 2>/dev/null || true +docker rm flyte-queue-postgres 2>/dev/null || true + +# Start PostgreSQL with the correct password +echo "Starting PostgreSQL with Docker..." +docker run --name flyte-queue-postgres \ + -e POSTGRES_PASSWORD=mysecretpassword \ + -e POSTGRES_DB=flyte_queue \ + -p 5432:5432 \ + -d postgres:15 + +echo "Waiting for PostgreSQL to be ready..." +sleep 3 + +# Check if it's ready +if docker exec flyte-queue-postgres pg_isready -U postgres; then + echo "โœ“ PostgreSQL is ready!" + echo " Host: localhost" + echo " Port: 5432" + echo " Database: flyte_queue" + echo " Username: postgres" + echo " Password: mysecretpassword" +else + echo "โŒ PostgreSQL failed to start" + exit 1 +fi diff --git a/queue/test.sh b/queue/test.sh new file mode 100755 index 0000000000..9c68323f07 --- /dev/null +++ b/queue/test.sh @@ -0,0 +1,88 @@ +#!/bin/bash +set -e + +echo "=== Queue Service Test Script ===" +echo + +# Check if PostgreSQL is running +if ! command -v psql &> /dev/null; then + echo "โš ๏ธ psql not found. Make sure PostgreSQL is installed." + echo " You can use Docker: docker run --name flyte-queue-postgres -e POSTGRES_PASSWORD=postgres -e POSTGRES_DB=flyte_queue -p 5432:5432 -d postgres:15" + exit 1 +fi + +# Check if the service binary exists +if [ ! -f "bin/queue-service" ]; then + echo "๐Ÿ“ฆ Building queue service..." + cd .. + go build -o queue/bin/queue-service ./queue/cmd/main.go + cd queue + echo "โœ“ Build complete" + echo +fi + +# Check if PostgreSQL is accessible +if ! psql -h localhost -U postgres -d flyte_queue -c "SELECT 1" &> /dev/null; then + echo "โš ๏ธ Cannot connect to PostgreSQL at localhost:5432" + echo " Make sure PostgreSQL is running with database 'flyte_queue'" + echo " Quick start: docker run --name flyte-queue-postgres -e POSTGRES_PASSWORD=postgres -e POSTGRES_DB=flyte_queue -p 5432:5432 -d postgres:15" + exit 1 +fi + +echo "โœ“ PostgreSQL is running" +echo + +# Start the service in the background +echo "๐Ÿš€ Starting Queue Service..." +./bin/queue-service --config config.yaml & +SERVICE_PID=$! + +# Wait for service to start +sleep 3 + +# Check if service is running +if ! kill -0 $SERVICE_PID 2>/dev/null; then + echo "โŒ Failed to start service" + exit 1 +fi + +echo "โœ“ Service started (PID: $SERVICE_PID)" +echo + +# Test health endpoint +echo "๐Ÿ” Testing health endpoint..." +if curl -sf http://localhost:8089/healthz > /dev/null; then + echo "โœ“ Health check passed" +else + echo "โŒ Health check failed" + kill $SERVICE_PID + exit 1 +fi +echo + +# Run the test client +echo "๐Ÿงช Running test client..." +echo +cd .. && go run queue/testclient/main.go +TEST_RESULT=$? +cd queue + +echo +if [ $TEST_RESULT -eq 0 ]; then + echo "โœ… All tests passed!" +else + echo "โŒ Tests failed" +fi + +# Check database +echo +echo "๐Ÿ“Š Database contents:" +psql -h localhost -U postgres -d flyte_queue -c "SELECT id, org, project, domain, run_name, action_name, status, enqueued_at FROM queued_actions ORDER BY id;" + +# Cleanup +echo +echo "๐Ÿงน Stopping service..." +kill $SERVICE_PID +wait $SERVICE_PID 2>/dev/null || true + +echo "โœ“ Done" diff --git a/queue/testclient/main.go b/queue/testclient/main.go new file mode 100644 index 0000000000..b5e6377803 --- /dev/null +++ b/queue/testclient/main.go @@ -0,0 +1,180 @@ +package main + +import ( + "context" + "fmt" + "log" + "net/http" + + "connectrpc.com/connect" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow/workflowconnect" +) + +func main() { + // Create a client + client := workflowconnect.NewQueueServiceClient( + http.DefaultClient, + "http://localhost:8089", + ) + + ctx := context.Background() + + // Test 1: Enqueue an action + fmt.Println("Test 1: Enqueuing an action...") + enqueueReq := &workflow.EnqueueActionRequest{ + ActionId: &common.ActionIdentifier{ + Run: &common.RunIdentifier{ + Org: "my-org", + Project: "my-project", + Domain: "development", + Name: "run-001", + }, + Name: "task-001", + }, + InputUri: "s3://my-bucket/inputs/run-001/task-001", + RunOutputBase: "s3://my-bucket/outputs/run-001", + Spec: &workflow.EnqueueActionRequest_Task{ + Task: &workflow.TaskAction{ + Spec: &task.TaskSpec{ + TaskTemplate: &core.TaskTemplate{ + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Image: "alpine:latest", + Args: []string{"echo", "Hello from Queue Service!"}, + }, + }, + }, + }, + }, + }, + } + + enqueueResp, err := client.EnqueueAction(ctx, connect.NewRequest(enqueueReq)) + if err != nil { + log.Fatalf("Failed to enqueue action: %v", err) + } + fmt.Printf("โœ“ Action enqueued successfully: %+v\n\n", enqueueResp.Msg) + + // Test 2: Enqueue another action in the same run + fmt.Println("Test 2: Enqueuing another action in the same run...") + enqueueReq2 := &workflow.EnqueueActionRequest{ + ActionId: &common.ActionIdentifier{ + Run: &common.RunIdentifier{ + Org: "my-org", + Project: "my-project", + Domain: "development", + Name: "run-001", + }, + Name: "task-002", + }, + ParentActionName: strPtr("task-001"), + InputUri: "s3://my-bucket/inputs/run-001/task-002", + RunOutputBase: "s3://my-bucket/outputs/run-001", + Spec: &workflow.EnqueueActionRequest_Task{ + Task: &workflow.TaskAction{ + Spec: &task.TaskSpec{ + TaskTemplate: &core.TaskTemplate{ + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Image: "alpine:latest", + Args: []string{"echo", "Second task!"}, + }, + }, + }, + }, + }, + }, + } + + _, err = client.EnqueueAction(ctx, connect.NewRequest(enqueueReq2)) + if err != nil { + log.Fatalf("Failed to enqueue second action: %v", err) + } + fmt.Println("โœ“ Second action enqueued successfully") + + // Test 3: Abort a specific action + fmt.Println("Test 3: Aborting a specific action...") + abortActionReq := &workflow.AbortQueuedActionRequest{ + ActionId: &common.ActionIdentifier{ + Run: &common.RunIdentifier{ + Org: "my-org", + Project: "my-project", + Domain: "development", + Name: "run-001", + }, + Name: "task-002", + }, + Reason: strPtr("Testing abort functionality"), + } + + _, err = client.AbortQueuedAction(ctx, connect.NewRequest(abortActionReq)) + if err != nil { + log.Fatalf("Failed to abort action: %v", err) + } + fmt.Println("โœ“ Action aborted successfully") + + // Test 4: Enqueue action for a different run + fmt.Println("Test 4: Enqueuing action for a different run...") + enqueueReq3 := &workflow.EnqueueActionRequest{ + ActionId: &common.ActionIdentifier{ + Run: &common.RunIdentifier{ + Org: "my-org", + Project: "my-project", + Domain: "development", + Name: "run-002", + }, + Name: "task-001", + }, + InputUri: "s3://my-bucket/inputs/run-002/task-001", + RunOutputBase: "s3://my-bucket/outputs/run-002", + Spec: &workflow.EnqueueActionRequest_Task{ + Task: &workflow.TaskAction{ + Spec: &task.TaskSpec{ + TaskTemplate: &core.TaskTemplate{ + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Image: "alpine:latest", + Args: []string{"echo", "Different run!"}, + }, + }, + }, + }, + }, + }, + } + + _, err = client.EnqueueAction(ctx, connect.NewRequest(enqueueReq3)) + if err != nil { + log.Fatalf("Failed to enqueue third action: %v", err) + } + fmt.Println("โœ“ Action for run-002 enqueued successfully") + + // Test 5: Abort entire run + fmt.Println("Test 5: Aborting entire run-001...") + abortRunReq := &workflow.AbortQueuedRunRequest{ + RunId: &common.RunIdentifier{ + Org: "my-org", + Project: "my-project", + Domain: "development", + Name: "run-001", + }, + Reason: strPtr("Testing run abort functionality"), + } + + _, err = client.AbortQueuedRun(ctx, connect.NewRequest(abortRunReq)) + if err != nil { + log.Fatalf("Failed to abort run: %v", err) + } + fmt.Println("โœ“ Run aborted successfully") + + fmt.Println("All tests completed successfully! ๐ŸŽ‰") +} + +func strPtr(s string) *string { + return &s +} diff --git a/runs/.gitignore b/runs/.gitignore new file mode 100644 index 0000000000..7f2439ff0b --- /dev/null +++ b/runs/.gitignore @@ -0,0 +1,30 @@ +# Binaries +bin/ +runs-service +runs-client + +# SQLite database +*.db +*.db-shm +*.db-wal + +# Test artifacts +coverage.txt +coverage.html +*.test + +# IDE +.idea/ +.vscode/ +*.swp +*.swo +*~ + +# OS +.DS_Store +Thumbs.db + +# Local config overrides +config-local.yaml + +runs.db \ No newline at end of file diff --git a/runs/Dockerfile b/runs/Dockerfile new file mode 100644 index 0000000000..f571b22017 --- /dev/null +++ b/runs/Dockerfile @@ -0,0 +1,42 @@ +# Build stage +FROM golang:1.24.6-alpine AS builder + +# Install dependencies +RUN apk add --no-cache git make build-base + +WORKDIR /workspace + +# Copy go mod files +COPY go.mod go.sum ./ +RUN go mod download + +# Copy the entire repository +COPY . ./ + +# Build the service +WORKDIR /workspace/runs +RUN CGO_ENABLED=1 GOOS=linux go build -a -o runs-service ./cmd/main.go + +# Final stage +FROM alpine:latest + +RUN apk --no-cache add ca-certificates + +WORKDIR /app + +# Copy the binary from builder +COPY --from=builder /workspace/runs/runs-service . + +# Copy default config +COPY --from=builder /workspace/runs/config.yaml . + +# Expose the service port +EXPOSE 8090 + +# Health check +HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \ + CMD wget --no-verbose --tries=1 --spider http://localhost:8090/healthz || exit 1 + +# Run the service +ENTRYPOINT ["./runs-service"] +CMD ["--config", "config.yaml"] diff --git a/runs/Makefile b/runs/Makefile new file mode 100644 index 0000000000..5cbe39db4b --- /dev/null +++ b/runs/Makefile @@ -0,0 +1,124 @@ +# Runs Service Makefile +# This Makefile includes common Go targets from ../go.Makefile + +# Service configuration +SERVICE_NAME := runs-service +BIN_NAME := runs-service +CMD_PATH := cmd/main.go +RUN_ARGS ?= --config config.yaml + +# Include common Go targets +include ../go.Makefile + +##@ Runs Specific + +.PHONY: build-client +build-client: ## Build the test client + @echo "Building test client..." + @mkdir -p bin + @go build -o bin/runs-client testclient/main.go + +.PHONY: run-postgres +run-postgres: build-fast ## Run the service with PostgreSQL config + @echo "Running $(SERVICE_NAME) with PostgreSQL..." + @./$(BIN_DIR)/$(BIN_NAME) --config config-postgres.yaml + +.PHONY: run-testclient +run-testclient: build-client ## Run the test client + @echo "Running test client..." + @./bin/runs-client + +.PHONY: clean-db +clean-db: ## Remove local database file + @echo "Removing runs.db..." + @rm -f runs.db + +##@ Docker - PostgreSQL + +.PHONY: docker-postgres +docker-postgres: ## Start PostgreSQL in Docker + @echo "Starting PostgreSQL container..." + @docker run --name flyte-runs-postgres \ + -e POSTGRES_PASSWORD=postgres \ + -e POSTGRES_DB=flyte_runs \ + -p 5433:5432 \ + -d postgres:15 + +.PHONY: docker-postgres-stop +docker-postgres-stop: ## Stop and remove PostgreSQL container + @echo "Stopping PostgreSQL container..." + @docker stop flyte-runs-postgres || true + @docker rm flyte-runs-postgres || true + +##@ Testing + +# Override test to exclude API tests +.PHONY: test +test: ## Run unit tests only (excludes test/) + @echo "Running unit tests..." + @go test -v -race -cover $(shell go list ./... | grep -v '/test') + +##@ Integration Tests + +.PHONY: api-test +api-test: ## Run API integration tests + @echo "Running API integration tests..." + @go test -v -race ./test/api/... + +.PHONY: integration-test +integration-test: build-fast build-client ## Run integration test with SQLite + @echo "Running service with SQLite..." + @./bin/runs-service --config config.yaml & \ + SERVER_PID=$$!; \ + sleep 2; \ + echo "Running client tests..."; \ + ./bin/runs-client; \ + kill $$SERVER_PID || true + +.PHONY: integration-test-postgres +integration-test-postgres: docker-postgres-stop docker-postgres ## Run integration test with PostgreSQL + @echo "Waiting for PostgreSQL to start..." + @sleep 3 + @echo "Running service with PostgreSQL..." + @$(MAKE) build-fast build-client + @./bin/runs-service --config config-postgres.yaml & \ + SERVER_PID=$$!; \ + sleep 2; \ + echo "Running client tests..."; \ + ./bin/runs-client; \ + kill $$SERVER_PID; \ + docker stop flyte-runs-postgres; \ + docker rm flyte-runs-postgres + +##@ Docker - Service + +.PHONY: docker-build +docker-build: ## Build Docker image + @echo "Building Docker image..." + @docker build -t flyte-runs-service:latest -f Dockerfile .. + +.PHONY: docker-run +docker-run: docker-build ## Build and run with docker compose + @docker compose up -d + +.PHONY: docker-stop +docker-stop: ## Stop docker compose + @docker compose down + +.PHONY: docker-logs +docker-logs: ## Show docker compose logs + @docker compose logs -f runs-service + +.PHONY: docker-up +docker-up: ## Run everything with docker compose + @docker compose up --build + +.PHONY: docker-down +docker-down: ## Stop docker compose and remove volumes + @docker compose down -v + +# Override clean to also remove database +clean: clean-db ## Remove build artifacts and database + @echo "Cleaning build artifacts..." + @rm -rf bin/ + @rm -f coverage.out coverage.html diff --git a/runs/README.md b/runs/README.md new file mode 100644 index 0000000000..438c6cff13 --- /dev/null +++ b/runs/README.md @@ -0,0 +1,453 @@ +# Runs Service + +The Runs Service implements the `RunService` gRPC interface using buf connect. It manages workflow runs, actions, attempts, and cluster events. + +## Features + +- Create and manage runs +- Track actions and their execution state +- Record action attempts and retries +- Store cluster events and phase transitions +- List and filter runs and actions +- Abort runs and individual actions +- Dual database support: **SQLite** (default) and **PostgreSQL** +- Health and readiness checks +- Streaming RPCs for real-time updates + +## Running the Service + +### Prerequisites + +1. Go 1.24 or later +2. (Optional) PostgreSQL running for production use + +### Quick Start with SQLite + +The service uses SQLite by default, no database setup required! + +```bash +# Build and run +go build -o runs-service cmd/main.go +./runs-service --config config.yaml +``` + +Or using make: + +```bash +make build +make run +``` + +The service will: +1. Create/connect to SQLite database (`runs.db`) +2. Run database migrations +3. Start HTTP/2 server on port 8090 (configurable) + +### Setup with PostgreSQL + +For production deployments, use PostgreSQL: + +```bash +# Using Docker +docker run --name flyte-runs-postgres \ + -e POSTGRES_PASSWORD=postgres \ + -e POSTGRES_DB=flyte_runs \ + -p 5433:5432 \ + -d postgres:15 + +# Or use your existing PostgreSQL instance +createdb flyte_runs +``` + +Run with PostgreSQL config: + +```bash +./runs-service --config config-postgres.yaml +``` + +### Configuration + +**SQLite (default) - `config.yaml`:** + +```yaml +runs: + server: + host: "0.0.0.0" + port: 8090 + watchBufferSize: 100 + +database: + sqlite: + file: "./runs.db" + +logger: + level: 4 # Info level + show-source: true +``` + +**PostgreSQL - `config-postgres.yaml`:** + +```yaml +runs: + server: + host: "0.0.0.0" + port: 8090 + watchBufferSize: 100 + +database: + postgres: + host: "localhost" + port: 5433 + dbname: "flyte_runs" + username: "postgres" + password: "postgres" + extraOptions: "sslmode=disable" + maxIdleConnections: 10 + maxOpenConnections: 100 + connMaxLifeTime: 1h + +logger: + level: 4 + show-source: true +``` + +## Testing + +### Run unit tests + +```bash +go test ./... +# or +make test +``` + +### Run API tests + +Please ensure the service is started by following [Quick Start with SQLite](#quick-start-with-sqlite) section +before running API tests. + +```sh +make api-test +``` + +### Run integration test with client + +**Using SQLite:** + +```bash +# Terminal 1: Start the service +go run cmd/main.go --config config.yaml + +# Terminal 2: Run the test client +go run testclient/main.go +``` + +**Or use make:** + +```bash +make integration-test +``` + +**Using PostgreSQL:** + +```bash +make integration-test-postgres +``` + +Expected output: +``` +Test 1: Creating a run with task spec... +โœ“ Run created successfully: test-run-001 + +Test 2: Creating a run with auto-generated name... +โœ“ Run with auto-generated name created: run-1759535665 + +Test 3: Getting run details... +โœ“ Retrieved run details: details:{} + +Test 4: Listing runs... +โœ“ Found 2 runs + +Test 5: Listing actions for the run... +โœ“ Found 0 actions + +Test 6: Aborting an action... +โœ“ Action aborted successfully + +Test 7: Aborting a run... +โœ“ Run aborted successfully + +All tests completed successfully! ๐ŸŽ‰ +``` + +## Scripts + +Convenient scripts are provided in `runs/tests/scripts/` to interact with the service using `buf curl`. +Ensure the service is running before executing these scripts. + +- `./runs/tests/scripts/create_task.sh` - create a new task +- `./runs/tests/scripts/list_tasks.sh` - list tasks with name filtering + +### Check service health + +```bash +# Health check +curl http://localhost:8090/healthz + +# Readiness check +curl http://localhost:8090/readyz +``` + +### Inspect database + +**SQLite:** + +```bash +sqlite3 runs.db + +# View runs +SELECT id, org, project, domain, name, root_action_name, created_at +FROM runs +ORDER BY created_at DESC; + +# View actions +SELECT id, org, project, domain, run_name, name, phase, action_type +FROM actions +ORDER BY created_at DESC; +``` + +**PostgreSQL:** + +```bash +# Connect to PostgreSQL +psql -h localhost -p 5433 -U postgres -d flyte_runs + +# View runs +SELECT id, org, project, domain, name, root_action_name, created_at +FROM runs +ORDER BY created_at DESC; + +# View actions +SELECT id, org, project, domain, run_name, name, phase, action_type +FROM actions +ORDER BY created_at DESC; +``` + +## API Endpoints + +The service exposes the following buf connect endpoints: + +### Run Management +- `POST /flyteidl2.workflow.RunService/CreateRun` - Create a new run +- `POST /flyteidl2.workflow.RunService/GetRunDetails` - Get run details +- `POST /flyteidl2.workflow.RunService/ListRuns` - List runs with filtering +- `POST /flyteidl2.workflow.RunService/AbortRun` - Abort a run + +### Action Management +- `POST /flyteidl2.workflow.RunService/GetActionDetails` - Get action details +- `POST /flyteidl2.workflow.RunService/GetActionData` - Get action input/output data +- `POST /flyteidl2.workflow.RunService/ListActions` - List actions for a run +- `POST /flyteidl2.workflow.RunService/AbortAction` - Abort a specific action + +### Task Management +- `POST /flyteidl2.workflow.TaskService/CreateTask` - Create a new task +- `POST /flyteidl2.workflow.TaskService/GetTask` - Get task details +- `POST /flyteidl2.workflow.TaskService/ListTasks` - List tasks with filtering and sorting +- `POST /flyteidl2.workflow.TaskService/UpdateTask` - Update an existing task + +### Streaming (Watch) RPCs +- `POST /flyteidl2.workflow.RunService/WatchRunDetails` - Stream run detail updates +- `POST /flyteidl2.workflow.RunService/WatchActionDetails` - Stream action detail updates +- `POST /flyteidl2.workflow.RunService/WatchRuns` - Stream run updates +- `POST /flyteidl2.workflow.RunService/WatchActions` - Stream action updates +- `POST /flyteidl2.workflow.RunService/WatchClusterEvents` - Stream cluster events + +### Health Endpoints +- `GET /healthz` - Health check +- `GET /readyz` - Readiness check + +## Database Schema + +### runs table + +```sql +CREATE TABLE runs ( + id BIGSERIAL PRIMARY KEY, + org VARCHAR(255) NOT NULL, + project VARCHAR(255) NOT NULL, + domain VARCHAR(255) NOT NULL, + name VARCHAR(255) NOT NULL, + root_action_name VARCHAR(255) NOT NULL, + trigger_org VARCHAR(255), + trigger_project VARCHAR(255), + trigger_domain VARCHAR(255), + trigger_name VARCHAR(255), + run_spec JSONB NOT NULL, + created_by_principal VARCHAR(255), + created_by_k8s_service_account VARCHAR(255), + created_at TIMESTAMP NOT NULL DEFAULT NOW(), + updated_at TIMESTAMP NOT NULL DEFAULT NOW(), + UNIQUE(org, project, domain, name) +); +``` + +### actions table + +```sql +CREATE TABLE actions ( + id BIGSERIAL PRIMARY KEY, + org VARCHAR(255) NOT NULL, + project VARCHAR(255) NOT NULL, + domain VARCHAR(255) NOT NULL, + run_name VARCHAR(255) NOT NULL, + name VARCHAR(255) NOT NULL, + run_id BIGINT NOT NULL REFERENCES runs(id), + parent_action_name VARCHAR(255), + action_type VARCHAR(50) NOT NULL, + phase VARCHAR(50) NOT NULL DEFAULT 'PHASE_QUEUED', + task_spec JSONB, + trace_spec JSONB, + condition_spec JSONB, + input_uri TEXT, + metadata JSONB, + created_at TIMESTAMP NOT NULL DEFAULT NOW(), + updated_at TIMESTAMP NOT NULL DEFAULT NOW(), + UNIQUE(org, project, domain, run_name, name) +); +``` + +### action_attempts table + +```sql +CREATE TABLE action_attempts ( + id BIGSERIAL PRIMARY KEY, + action_id BIGINT NOT NULL REFERENCES actions(id), + attempt_number INT NOT NULL, + phase VARCHAR(50) NOT NULL DEFAULT 'PHASE_QUEUED', + start_time TIMESTAMP, + end_time TIMESTAMP, + outputs JSONB, + log_info JSONB, + log_context JSONB, + created_at TIMESTAMP NOT NULL DEFAULT NOW(), + updated_at TIMESTAMP NOT NULL DEFAULT NOW(), + UNIQUE(action_id, attempt_number) +); +``` + +### cluster_events table + +```sql +CREATE TABLE cluster_events ( + id BIGSERIAL PRIMARY KEY, + attempt_id BIGINT NOT NULL REFERENCES action_attempts(id), + occurred_at TIMESTAMP NOT NULL, + message TEXT NOT NULL, + created_at TIMESTAMP NOT NULL DEFAULT NOW() +); +``` + +### phase_transitions table + +```sql +CREATE TABLE phase_transitions ( + id BIGSERIAL PRIMARY KEY, + attempt_id BIGINT NOT NULL REFERENCES action_attempts(id), + phase VARCHAR(50) NOT NULL, + start_time TIMESTAMP NOT NULL, + end_time TIMESTAMP, + created_at TIMESTAMP NOT NULL DEFAULT NOW() +); +``` + +## Project Structure + +``` +runs/ +โ”œโ”€โ”€ cmd/ +โ”‚ โ””โ”€โ”€ main.go # Entry point +โ”œโ”€โ”€ config/ +โ”‚ โ””โ”€โ”€ config.go # Configuration structs +โ”œโ”€โ”€ repository/ +โ”‚ โ”œโ”€โ”€ interfaces.go # Repository interface +โ”‚ โ”œโ”€โ”€ models.go # Database models +โ”‚ โ””โ”€โ”€ postgres.go # PostgreSQL/SQLite implementation +โ”œโ”€โ”€ service/ +โ”‚ โ””โ”€โ”€ run_service.go # Service implementation +โ”œโ”€โ”€ migrations/ +โ”‚ โ””โ”€โ”€ migrations.go # Database migrations +โ”œโ”€โ”€ client/ +โ”‚ โ””โ”€โ”€ main.go # Test client +โ”œโ”€โ”€ config.yaml # SQLite configuration (default) +โ”œโ”€โ”€ config-postgres.yaml # PostgreSQL configuration +โ”œโ”€โ”€ Makefile # Build and test commands +โ””โ”€โ”€ README.md # This file +``` + +## Development + +### Build commands + +```bash +# Build service +make build + +# Build client +make build-testclient + +# Clean artifacts +make clean +``` + +### Database switching + +The service automatically selects the database based on configuration: +- If `database.sqlite.file` is set โ†’ uses SQLite +- If `database.postgres` is set โ†’ uses PostgreSQL + +No code changes needed, just update `config.yaml`! + +### Database migration + +We are using gorm for auto migration, please ensure addding `gorm` tags in `/runs/repository/models/` when you +add any more columns/models. + +### Adding new features + +1. Update proto definitions in `/flyteidl2/workflow/` +2. Regenerate code: `buf generate` +3. Update repository interface in `repository/interfaces/` +4. Update DB models in `repository/models/` +5. Implement in `repository/impl/` +6. Add service handler in `service/xxx_service.go` +7. Add tests and update client + +## Troubleshooting + +### Port already in use + +If port 8090 is already in use, update in `config.yaml`: + +```yaml +runs: + server: + port: 8091 # Use a different port +``` + +### Database connection issues + +**SQLite:** +- Check file permissions on `./runs.db` +- Ensure directory is writable + +**PostgreSQL:** +- Verify PostgreSQL is running: `pg_isready -h localhost -p 5433` +- Check credentials in `config-postgres.yaml` +- Ensure database exists: `psql -h localhost -p 5433 -U postgres -l` + +### Service won't start + +Check logs for detailed error messages. Common issues: +- Config file not found (use `--config` flag) +- Database connection failed +- Port already in use diff --git a/runs/cmd/main.go b/runs/cmd/main.go new file mode 100644 index 0000000000..ad1a13e980 --- /dev/null +++ b/runs/cmd/main.go @@ -0,0 +1,199 @@ +package main + +import ( + "context" + "errors" + "fmt" + "net/http" + "os" + "os/signal" + "syscall" + "time" + + "github.com/spf13/cobra" + "golang.org/x/net/http2" + "golang.org/x/net/http2/h2c" + "gorm.io/gorm" + + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/config/viper" + "github.com/flyteorg/flyte/v2/flytestdlib/database" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task/taskconnect" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow/workflowconnect" + runsconfig "github.com/flyteorg/flyte/v2/runs/config" + "github.com/flyteorg/flyte/v2/runs/migrations" + "github.com/flyteorg/flyte/v2/runs/repository" + "github.com/flyteorg/flyte/v2/runs/service" +) + +var ( + cfgFile string + rootCmd = &cobra.Command{ + Use: "runs-service", + Short: "Runs Service for Flyte", + RunE: func(cmd *cobra.Command, args []string) error { + return serve(cmd.Context()) + }, + } +) + +func init() { + rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.flyte/config.yaml)") +} + +func main() { + if err := rootCmd.Execute(); err != nil { + os.Exit(1) + } +} + +func serve(ctx context.Context) error { + // Initialize config + if err := initConfig(); err != nil { + return fmt.Errorf("failed to initialize config: %w", err) + } + + // Initialize logger + logConfig := logger.GetConfig() + if err := logger.SetConfig(logConfig); err != nil { + return fmt.Errorf("failed to initialize logger: %w", err) + } + + logger.Infof(ctx, "Starting Runs Service") + + // Get configuration + cfg := runsconfig.GetConfig() + dbCfg := database.GetConfig() + + // Initialize database + db, err := initDB(ctx, dbCfg) + if err != nil { + return fmt.Errorf("failed to initialize database: %w", err) + } + + // Run migrations + logger.Infof(ctx, "Running database migrations") + if err := migrations.RunMigrations(db); err != nil { + return fmt.Errorf("failed to run migrations: %w", err) + } + + // Create repository + repo := repository.NewRepository(db) + + // Create queue service client + queueClient := workflowconnect.NewQueueServiceClient( + http.DefaultClient, + cfg.QueueServiceURL, + ) + logger.Infof(ctx, "Queue service client configured for: %s", cfg.QueueServiceURL) + + // Create services + runsSvc := service.NewRunService(repo, queueClient) + stateSvc := service.NewStateService(repo) + taskSvc := service.NewTaskService(repo) + + // Setup HTTP server with Connect handlers + mux := http.NewServeMux() + + // Mount the Run Service + runsPath, runsHandler := workflowconnect.NewRunServiceHandler(runsSvc) + mux.Handle(runsPath, runsHandler) + + // Mount the State Service + statePath, stateHandler := workflowconnect.NewStateServiceHandler(stateSvc) + mux.Handle(statePath, stateHandler) + + // Mount the Task Service + taskPath, taskHandler := taskconnect.NewTaskServiceHandler(taskSvc) + mux.Handle(taskPath, taskHandler) + + logger.Infof(ctx, "Mounted RunService at %s", runsPath) + logger.Infof(ctx, "Mounted StateService at %s", statePath) + logger.Infof(ctx, "Mounted TaskService at %s", taskPath) + + // Add health check endpoint + mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte("OK")) + }) + + // Add readiness check endpoint + mux.HandleFunc("/readyz", func(w http.ResponseWriter, r *http.Request) { + // Check database connection + sqlDB, err := db.DB() + if err != nil { + w.WriteHeader(http.StatusServiceUnavailable) + _, _ = w.Write([]byte("Database connection error")) + return + } + if err := sqlDB.Ping(); err != nil { + w.WriteHeader(http.StatusServiceUnavailable) + _, _ = w.Write([]byte("Database ping failed")) + return + } + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte("OK")) + }) + + // Setup HTTP/2 support (required for gRPC) + addr := fmt.Sprintf("%s:%d", cfg.Server.Host, cfg.Server.Port) + server := &http.Server{ + Addr: addr, + Handler: h2c.NewHandler(mux, &http2.Server{}), + } + + // Start server in a goroutine + errCh := make(chan error, 1) + go func() { + logger.Infof(ctx, "Runs Service listening on %s", addr) + if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { + errCh <- fmt.Errorf("server error: %w", err) + } + }() + + // Wait for interrupt signal or error + sigCh := make(chan os.Signal, 1) + signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM) + + select { + case sig := <-sigCh: + logger.Infof(ctx, "Received signal %v, shutting down gracefully...", sig) + case err := <-errCh: + return err + } + + // Graceful shutdown + shutdownCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + + if err := server.Shutdown(shutdownCtx); err != nil { + return fmt.Errorf("server shutdown failed: %w", err) + } + + logger.Infof(ctx, "Runs Service stopped") + return nil +} + +func initConfig() error { + // Use viper to load config + configAccessor := viper.NewAccessor(config.Options{ + SearchPaths: []string{cfgFile, ".", "/etc/flyte/config"}, + StrictMode: false, + }) + + return configAccessor.UpdateConfig(context.Background()) +} + +func initDB(ctx context.Context, cfg *database.DbConfig) (*gorm.DB, error) { + logCfg := logger.GetConfig() + + // Use flytestdlib's GetDB which handles both SQLite and PostgreSQL + db, err := database.GetDB(ctx, cfg, logCfg) + if err != nil { + return nil, fmt.Errorf("failed to initialize database: %w", err) + } + + logger.Infof(ctx, "Database connection established") + return db, nil +} diff --git a/runs/config-postgres.yaml b/runs/config-postgres.yaml new file mode 100644 index 0000000000..12b1ba86e3 --- /dev/null +++ b/runs/config-postgres.yaml @@ -0,0 +1,25 @@ +# Runs Service Configuration - PostgreSQL + +runs: + server: + host: "0.0.0.0" + port: 8090 + watchBufferSize: 100 + queueServiceUrl: "http://localhost:8089" + +database: + # Using PostgreSQL + postgres: + host: "postgres" + port: 5432 + dbname: "flyte_runs" + username: "postgres" + password: "postgres" + extraOptions: "sslmode=disable" + maxIdleConnections: 10 + maxOpenConnections: 100 + connMaxLifeTime: 1h + +logger: + level: 4 # Info level + show-source: true diff --git a/runs/config.yaml b/runs/config.yaml new file mode 100644 index 0000000000..658c39cbd5 --- /dev/null +++ b/runs/config.yaml @@ -0,0 +1,29 @@ +# Runs Service Configuration + +runs: + server: + host: "0.0.0.0" + port: 8090 + watchBufferSize: 100 + queueServiceUrl: "http://localhost:8089" + +database: + # Option 1: Use SQLite (easier for testing, no setup required) + sqlite: + file: "./runs.db" + + # Option 2: Use PostgreSQL (comment out sqlite above and uncomment below) + # postgres: + # host: "localhost" + # port: 5432 + # dbname: "flyte_runs" + # username: "postgres" + # password: "postgres" + # extraOptions: "sslmode=disable" + # maxIdleConnections: 10 + # maxOpenConnections: 100 + # connMaxLifeTime: 1h + +logger: + level: 4 # Info level + show-source: true diff --git a/runs/config/config.go b/runs/config/config.go new file mode 100644 index 0000000000..763e17b8a2 --- /dev/null +++ b/runs/config/config.go @@ -0,0 +1,47 @@ +package config + +import ( + "github.com/flyteorg/flyte/v2/flytestdlib/config" + "github.com/flyteorg/flyte/v2/flytestdlib/database" +) + +const configSectionKey = "runs" + +//go:generate pflags Config --default-var=defaultConfig + +var defaultConfig = &Config{ + Server: ServerConfig{ + Port: 8090, + Host: "0.0.0.0", + }, + WatchBufferSize: 100, + QueueServiceURL: "http://localhost:8089", +} + +var configSection = config.MustRegisterSection(configSectionKey, defaultConfig) + +// Config holds the configuration for the Runs service +type Config struct { + // HTTP server configuration + Server ServerConfig `json:"server"` + + // Database configuration + Database database.DbConfig `json:"database"` + + // Watch/streaming settings + WatchBufferSize int `json:"watchBufferSize" pflag:",Buffer size for watch streams"` + + // Queue service URL for enqueuing actions + QueueServiceURL string `json:"queueServiceUrl" pflag:",URL of the queue service"` +} + +// ServerConfig holds HTTP server configuration +type ServerConfig struct { + Port int `json:"port" pflag:",Port to bind the HTTP server"` + Host string `json:"host" pflag:",Host to bind the HTTP server"` +} + +// GetConfig returns the parsed runs configuration +func GetConfig() *Config { + return configSection.GetConfig().(*Config) +} diff --git a/runs/docker-compose.yaml b/runs/docker-compose.yaml new file mode 100644 index 0000000000..3d37476041 --- /dev/null +++ b/runs/docker-compose.yaml @@ -0,0 +1,41 @@ +version: '3.8' + +services: + postgres: + image: postgres:15 + container_name: flyte-runs-postgres + environment: + POSTGRES_DB: flyte_runs + POSTGRES_USER: postgres + POSTGRES_PASSWORD: postgres + ports: + - "5433:5432" + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U postgres"] + interval: 10s + timeout: 5s + retries: 5 + + runs-service: + build: + context: .. + dockerfile: runs/Dockerfile + container_name: flyte-runs-service + ports: + - "8090:8090" + depends_on: + postgres: + condition: service_healthy + volumes: + - ./config-postgres.yaml:/app/config.yaml + command: ["--config", "config.yaml"] + healthcheck: + test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8090/healthz"] + interval: 30s + timeout: 3s + retries: 3 + +volumes: + postgres_data: diff --git a/runs/migrations/migrations.go b/runs/migrations/migrations.go new file mode 100644 index 0000000000..e7119396f1 --- /dev/null +++ b/runs/migrations/migrations.go @@ -0,0 +1,43 @@ +package migrations + +import ( + "context" + "fmt" + + "gorm.io/gorm" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/runs/repository/models" +) + +// AllModels contains all GORM models used in the runs service +var AllModels = []interface{}{ + &models.Action{}, + &models.Task{}, + &models.TaskSpec{}, +} + +// RunMigrations runs all database migrations for the runs service +func RunMigrations(db *gorm.DB) error { + ctx := context.Background() + + // Drop ALL old tables if they exist (from previous schema) + // This includes the old actions table which had different columns + oldTables := []string{"runs", "actions", "action_attempts", "cluster_events", "phase_transitions"} + for _, table := range oldTables { + if db.Migrator().HasTable(table) { + logger.Infof(ctx, "Dropping old table: %s", table) + if err := db.Migrator().DropTable(table); err != nil { + return fmt.Errorf("failed to drop table %s: %w", table, err) + } + } + } + + // AutoMigrate will create the new actions table with simplified schema + if err := db.AutoMigrate(AllModels...); err != nil { + return fmt.Errorf("failed to run migrations: %w", err) + } + + logger.Infof(ctx, "Database migrations completed successfully (recreated actions table)") + return nil +} diff --git a/runs/repository/impl/action.go b/runs/repository/impl/action.go new file mode 100644 index 0000000000..da7fb4800c --- /dev/null +++ b/runs/repository/impl/action.go @@ -0,0 +1,769 @@ +package impl + +import ( + "context" + "encoding/json" + "fmt" + "strings" + "sync" + "time" + + "github.com/lib/pq" + "gorm.io/datatypes" + "gorm.io/gorm" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + "github.com/flyteorg/flyte/v2/runs/repository/interfaces" + "github.com/flyteorg/flyte/v2/runs/repository/models" +) + +// actionRepo implements actionRepo interface using PostgreSQL/SQLite +type actionRepo struct { + db *gorm.DB + isPostgres bool + listener *pq.Listener + + // Subscriber management for LISTEN/NOTIFY + runSubscribers map[chan string]bool + actionSubscribers map[chan string]bool + mu sync.RWMutex +} + +// NewActionRepo creates a new PostgreSQL/SQLite repository +func NewActionRepo(db *gorm.DB) interfaces.ActionRepo { + // Detect database type + dbName := db.Name() + isPostgres := dbName == "postgres" + + repo := &actionRepo{ + db: db, + isPostgres: isPostgres, + runSubscribers: make(map[chan string]bool), + actionSubscribers: make(map[chan string]bool), + } + + // Start LISTEN/NOTIFY for PostgreSQL + if isPostgres { + go repo.startPostgresListener() + } + + return repo +} + +// CreateRun creates a new run (root action with parent_action_name = null) +func (r *actionRepo) CreateRun(ctx context.Context, req *workflow.CreateRunRequest) (*models.Run, error) { + // Determine run ID + var runID *common.RunIdentifier + switch id := req.Id.(type) { + case *workflow.CreateRunRequest_RunId: + runID = id.RunId + case *workflow.CreateRunRequest_ProjectId: + // Generate a run name (simplified - in production, use a better generator) + runID = &common.RunIdentifier{ + Org: id.ProjectId.Organization, + Project: id.ProjectId.Name, + Domain: id.ProjectId.Domain, + Name: fmt.Sprintf("run-%d", time.Now().Unix()), + } + default: + return nil, fmt.Errorf("invalid run ID type") + } + + // Build ActionSpec from CreateRunRequest + actionSpec := &workflow.ActionSpec{ + ActionId: &common.ActionIdentifier{ + Run: runID, + Name: runID.Name, // For root actions, action name = run name + }, + ParentActionName: nil, // NULL for root actions + RunSpec: req.RunSpec, + InputUri: "", // TODO: build from inputs + RunOutputBase: "", // TODO: build output path + } + + // Set the task spec based on the request + switch taskSpec := req.Task.(type) { + case *workflow.CreateRunRequest_TaskSpec: + actionSpec.Spec = &workflow.ActionSpec_Task{ + Task: &workflow.TaskAction{ + Spec: taskSpec.TaskSpec, + }, + } + case *workflow.CreateRunRequest_TaskId: + actionSpec.Spec = &workflow.ActionSpec_Task{ + Task: &workflow.TaskAction{ + Id: taskSpec.TaskId, + }, + } + } + + // Serialize the ActionSpec to JSON + actionSpecBytes, err := json.Marshal(actionSpec) + if err != nil { + return nil, fmt.Errorf("failed to marshal action spec: %w", err) + } + + // Create root action (represents the run) + run := &models.Run{ + Org: runID.Org, + Project: runID.Project, + Domain: runID.Domain, + Name: runID.Name, + ParentActionName: nil, // NULL for root actions/runs + Phase: "PHASE_QUEUED", + ActionSpec: datatypes.JSON(actionSpecBytes), + ActionDetails: datatypes.JSON([]byte("{}")), // Empty details initially + } + + if err := r.db.WithContext(ctx).Create(run).Error; err != nil { + return nil, fmt.Errorf("failed to create run: %w", err) + } + + logger.Infof(ctx, "Created run: %s/%s/%s/%s (ID: %d)", + run.Org, run.Project, run.Domain, run.Name, run.ID) + + // Notify subscribers of run creation + r.notifyRunUpdate(ctx, runID) + + return run, nil +} + +// GetRun retrieves a run by identifier +func (r *actionRepo) GetRun(ctx context.Context, runID *common.RunIdentifier) (*models.Run, error) { + var run models.Run + result := r.db.WithContext(ctx). + Where("org = ? AND project = ? AND domain = ? AND name = ? AND parent_action_name IS NULL", + runID.Org, runID.Project, runID.Domain, runID.Name). + First(&run) + + if result.Error != nil { + if result.Error == gorm.ErrRecordNotFound { + return nil, fmt.Errorf("run not found: %s/%s/%s/%s", + runID.Org, runID.Project, runID.Domain, runID.Name) + } + return nil, fmt.Errorf("failed to get run: %w", result.Error) + } + + return &run, nil +} + +// ListRuns lists runs with pagination +func (r *actionRepo) ListRuns(ctx context.Context, req *workflow.ListRunsRequest) ([]*models.Run, string, error) { + query := r.db.WithContext(ctx).Model(&models.Run{}). + Where("parent_action_name IS NULL") // Only root actions (runs) + + // Apply scope filters + switch scope := req.ScopeBy.(type) { + case *workflow.ListRunsRequest_Org: + query = query.Where("org = ?", scope.Org) + case *workflow.ListRunsRequest_ProjectId: + query = query.Where("org = ? AND project = ? AND domain = ?", + scope.ProjectId.Organization, scope.ProjectId.Name, scope.ProjectId.Domain) + } + + // Apply pagination + limit := 50 + if req.Request != nil && req.Request.Limit > 0 { + limit = int(req.Request.Limit) + } + + var runs []*models.Run + result := query. + Order("created_at DESC"). + Limit(limit + 1). // Fetch one extra to determine if there are more + Find(&runs) + + if result.Error != nil { + return nil, "", fmt.Errorf("failed to list runs: %w", result.Error) + } + + // Determine next token + var nextToken string + if len(runs) > limit { + runs = runs[:limit] + nextToken = fmt.Sprintf("%d", runs[len(runs)-1].ID) + } + + return runs, nextToken, nil +} + +// AbortRun aborts a run and all its actions +func (r *actionRepo) AbortRun(ctx context.Context, runID *common.RunIdentifier, reason string, abortedBy *common.EnrichedIdentity) error { + // Update the run action to aborted + updates := map[string]interface{}{ + "phase": "PHASE_ABORTED", + "updated_at": time.Now(), + } + + result := r.db.WithContext(ctx). + Model(&models.Run{}). + Where("org = ? AND project = ? AND domain = ? AND name = ? AND parent_action_name IS NULL", + runID.Org, runID.Project, runID.Domain, runID.Name). + Updates(updates) + + if result.Error != nil { + return fmt.Errorf("failed to abort run: %w", result.Error) + } + + // Notify subscribers + r.notifyRunUpdate(ctx, runID) + + logger.Infof(ctx, "Aborted run: %s/%s/%s/%s", runID.Org, runID.Project, runID.Domain, runID.Name) + return nil +} + +// CreateAction creates a new action +func (r *actionRepo) CreateAction(ctx context.Context, runID uint, actionSpec *workflow.ActionSpec) (*models.Action, error) { + // Serialize action spec + actionSpecBytes, err := json.Marshal(actionSpec) + if err != nil { + return nil, fmt.Errorf("failed to marshal action spec: %w", err) + } + + // Determine parent action name + var parentActionName *string + if actionSpec.ParentActionName != nil { + parentActionName = actionSpec.ParentActionName + } + + action := &models.Action{ + Org: actionSpec.ActionId.Run.Org, + Project: actionSpec.ActionId.Run.Project, + Domain: actionSpec.ActionId.Run.Domain, + Name: actionSpec.ActionId.Name, + ParentActionName: parentActionName, + Phase: "PHASE_QUEUED", + ActionSpec: datatypes.JSON(actionSpecBytes), + ActionDetails: datatypes.JSON([]byte("{}")), // Empty details initially + } + + if err := r.db.WithContext(ctx).Create(action).Error; err != nil { + return nil, fmt.Errorf("failed to create action: %w", err) + } + + logger.Infof(ctx, "Created action: %s (ID: %d)", action.Name, action.ID) + + // Notify subscribers of action creation + r.notifyActionUpdate(ctx, actionSpec.ActionId) + + return action, nil +} + +// GetAction retrieves an action by identifier +func (r *actionRepo) GetAction(ctx context.Context, actionID *common.ActionIdentifier) (*models.Action, error) { + var action models.Action + result := r.db.WithContext(ctx). + Where("org = ? AND project = ? AND domain = ? AND name = ?", + actionID.Run.Org, actionID.Run.Project, actionID.Run.Domain, actionID.Name). + First(&action) + + if result.Error != nil { + if result.Error == gorm.ErrRecordNotFound { + return nil, fmt.Errorf("action not found") + } + return nil, fmt.Errorf("failed to get action: %w", result.Error) + } + + return &action, nil +} + +// ListActions lists actions for a run +func (r *actionRepo) ListActions(ctx context.Context, runID *common.RunIdentifier, limit int, token string) ([]*models.Action, string, error) { + if limit == 0 { + limit = 100 + } + + query := r.db.WithContext(ctx).Model(&models.Action{}). + Where("org = ? AND project = ? AND domain = ?", + runID.Org, runID.Project, runID.Domain). + Where("parent_action_name IS NOT NULL") // Exclude the root action/run itself + + // Apply pagination token + if token != "" { + query = query.Where("id > ?", token) + } + + var actions []*models.Action + result := query. + Order("id ASC"). + Limit(limit + 1). + Find(&actions) + + if result.Error != nil { + return nil, "", fmt.Errorf("failed to list actions: %w", result.Error) + } + + // Determine next token + var nextToken string + if len(actions) > limit { + actions = actions[:limit] + nextToken = fmt.Sprintf("%d", actions[len(actions)-1].ID) + } + + return actions, nextToken, nil +} + +// UpdateActionPhase updates the phase of an action +func (r *actionRepo) UpdateActionPhase(ctx context.Context, actionID *common.ActionIdentifier, phase string, startTime, endTime *string) error { + updates := map[string]interface{}{ + "phase": phase, + "updated_at": time.Now(), + } + + result := r.db.WithContext(ctx). + Model(&models.Action{}). + Where("org = ? AND project = ? AND domain = ? AND name = ?", + actionID.Run.Org, actionID.Run.Project, actionID.Run.Domain, actionID.Name). + Updates(updates) + + if result.Error != nil { + return result.Error + } + + // Notify subscribers of action update + r.notifyActionUpdate(ctx, actionID) + + return nil +} + +// AbortAction aborts a specific action +func (r *actionRepo) AbortAction(ctx context.Context, actionID *common.ActionIdentifier, reason string, abortedBy *common.EnrichedIdentity) error { + updates := map[string]interface{}{ + "phase": "PHASE_ABORTED", + "updated_at": time.Now(), + } + + result := r.db.WithContext(ctx). + Model(&models.Action{}). + Where("org = ? AND project = ? AND domain = ? AND name = ?", + actionID.Run.Org, actionID.Run.Project, actionID.Run.Domain, actionID.Name). + Updates(updates) + + if result.Error != nil { + return fmt.Errorf("failed to abort action: %w", result.Error) + } + + // Notify subscribers + r.notifyActionUpdate(ctx, actionID) + + logger.Infof(ctx, "Aborted action: %s", actionID.Name) + return nil +} + +// UpdateActionState updates the state of an action +func (r *actionRepo) UpdateActionState(ctx context.Context, actionID *common.ActionIdentifier, state string) error { + // Parse the state JSON to extract the phase + var stateObj map[string]interface{} + if err := json.Unmarshal([]byte(state), &stateObj); err != nil { + return fmt.Errorf("failed to unmarshal state JSON: %w", err) + } + + updates := map[string]interface{}{ + "updated_at": time.Now(), + } + + // Extract phase if present + if phase, ok := stateObj["phase"].(string); ok { + updates["phase"] = phase + logger.Infof(ctx, "Updating action %s phase to %s", actionID.Name, phase) + } + + // Store state in ActionDetails JSON + // For now, we'll replace the entire ActionDetails with the state + // In a full implementation, we'd merge it with existing ActionDetails + updates["action_details"] = datatypes.JSON([]byte(state)) + + result := r.db.WithContext(ctx). + Model(&models.Action{}). + Where("org = ? AND project = ? AND domain = ? AND name = ?", + actionID.Run.Org, actionID.Run.Project, actionID.Run.Domain, actionID.Name). + Updates(updates) + + if result.Error != nil { + return fmt.Errorf("failed to update action state: %w", result.Error) + } + + if result.RowsAffected == 0 { + return fmt.Errorf("action not found: %s/%s/%s/%s", + actionID.Run.Org, actionID.Run.Project, actionID.Run.Domain, actionID.Name) + } + + // Notify subscribers of the update + r.notifyActionUpdate(ctx, actionID) + + return nil +} + +// GetActionState retrieves the state of an action +func (r *actionRepo) GetActionState(ctx context.Context, actionID *common.ActionIdentifier) (string, error) { + var action models.Action + result := r.db.WithContext(ctx). + Select("action_details"). + Where("org = ? AND project = ? AND domain = ? AND name = ?", + actionID.Run.Org, actionID.Run.Project, actionID.Run.Domain, actionID.Name). + First(&action) + + if result.Error != nil { + return "", fmt.Errorf("failed to get action state: %w", result.Error) + } + + // Extract state from ActionDetails JSON + // For now, return the whole ActionDetails JSON + return string(action.ActionDetails), nil +} + +// NotifyStateUpdate sends a notification about a state update +func (r *actionRepo) NotifyStateUpdate(ctx context.Context, actionID *common.ActionIdentifier) error { + // This is already handled by notifyActionUpdate + r.notifyActionUpdate(ctx, actionID) + return nil +} + +// WatchStateUpdates watches for state updates (simplified implementation) +func (r *actionRepo) WatchStateUpdates(ctx context.Context, updates chan<- *common.ActionIdentifier, errs chan<- error) { + // For now, just block until context is cancelled + // In a full implementation, this would listen for state notifications + <-ctx.Done() +} + +// WatchRunUpdates watches for run updates (simplified polling implementation) +func (r *actionRepo) WatchRunUpdates(ctx context.Context, runID *common.RunIdentifier, updates chan<- *models.Run, errs chan<- error) { + if r.isPostgres { + // PostgreSQL: Use LISTEN/NOTIFY with dedicated channel for this watcher + runKey := fmt.Sprintf("%s/%s/%s/%s", runID.Org, runID.Project, runID.Domain, runID.Name) + notifCh := make(chan string, 10) + + // Register as subscriber + r.mu.Lock() + r.runSubscribers[notifCh] = true + r.mu.Unlock() + + // Unregister on exit + defer func() { + r.mu.Lock() + delete(r.runSubscribers, notifCh) + close(notifCh) + r.mu.Unlock() + }() + + for { + select { + case <-ctx.Done(): + return + case notifPayload := <-notifCh: + // Check if this notification is for the run we're watching + if notifPayload == runKey { + run, err := r.GetRun(ctx, runID) + if err != nil { + errs <- err + return + } + updates <- run + } + } + } + } else { + // SQLite: Use polling + ticker := time.NewTicker(1 * time.Second) + defer ticker.Stop() + + var lastUpdated time.Time + + for { + select { + case <-ctx.Done(): + return + case <-ticker.C: + run, err := r.GetRun(ctx, runID) + if err != nil { + errs <- err + return + } + + if run.UpdatedAt.After(lastUpdated) { + lastUpdated = run.UpdatedAt + updates <- run + } + } + } + } +} + +// WatchAllRunUpdates watches for all run updates (not filtered by runID) +func (r *actionRepo) WatchAllRunUpdates(ctx context.Context, updates chan<- *models.Run, errs chan<- error) { + if r.isPostgres { + // PostgreSQL: Use LISTEN/NOTIFY with dedicated channel for this watcher + notifCh := make(chan string, 10) + + // Register as subscriber + r.mu.Lock() + r.runSubscribers[notifCh] = true + r.mu.Unlock() + + // Unregister on exit + defer func() { + r.mu.Lock() + delete(r.runSubscribers, notifCh) + close(notifCh) + r.mu.Unlock() + }() + + for { + select { + case <-ctx.Done(): + return + case notifPayload := <-notifCh: + // Parse notification payload: org/project/domain/run + parts := strings.Split(notifPayload, "/") + if len(parts) != 4 { + logger.Warnf(ctx, "Invalid run notification payload: %s", notifPayload) + continue + } + + runID := &common.RunIdentifier{ + Org: parts[0], + Project: parts[1], + Domain: parts[2], + Name: parts[3], + } + + run, err := r.GetRun(ctx, runID) + if err != nil { + logger.Errorf(ctx, "Failed to get run from notification: %v", err) + continue + } + updates <- run + } + } + } else { + // SQLite: Use polling for all runs + ticker := time.NewTicker(2 * time.Second) + defer ticker.Stop() + + lastCheck := time.Now() + + for { + select { + case <-ctx.Done(): + return + case <-ticker.C: + // Query runs updated since last check + var runs []*models.Run + if err := r.db.WithContext(ctx). + Where("updated_at > ? AND parent_action_name IS NULL", lastCheck). + Find(&runs).Error; err != nil { + errs <- err + return + } + + for _, run := range runs { + updates <- run + } + + lastCheck = time.Now() + } + } + } +} + +// WatchActionUpdates watches for action updates +func (r *actionRepo) WatchActionUpdates(ctx context.Context, runID *common.RunIdentifier, updates chan<- *models.Action, errs chan<- error) { + if r.isPostgres { + // PostgreSQL: Use LISTEN/NOTIFY with dedicated channel for this watcher + runPrefix := fmt.Sprintf("%s/%s/%s/%s/", runID.Org, runID.Project, runID.Domain, runID.Name) + notifCh := make(chan string, 10) + + // Register as subscriber + r.mu.Lock() + r.actionSubscribers[notifCh] = true + r.mu.Unlock() + + // Unregister on exit + defer func() { + r.mu.Lock() + delete(r.actionSubscribers, notifCh) + close(notifCh) + r.mu.Unlock() + }() + + for { + select { + case <-ctx.Done(): + return + case notifPayload := <-notifCh: + // Check if this notification is for an action in the run we're watching + // Payload format: org/project/domain/run/action + if len(notifPayload) > len(runPrefix) && notifPayload[:len(runPrefix)] == runPrefix { + // Extract action name from payload + actionName := notifPayload[len(runPrefix):] + actionID := &common.ActionIdentifier{ + Run: runID, + Name: actionName, + } + + action, err := r.GetAction(ctx, actionID) + if err != nil { + logger.Errorf(ctx, "Failed to get action from notification: %v", err) + continue + } + updates <- action + } + } + } + } else { + // SQLite: Use polling + ticker := time.NewTicker(1 * time.Second) + defer ticker.Stop() + + lastCheck := time.Now() + + for { + select { + case <-ctx.Done(): + return + case <-ticker.C: + // Query actions updated since last check + var actions []*models.Action + if err := r.db.WithContext(ctx). + Where("org = ? AND project = ? AND domain = ? AND updated_at > ? AND parent_action_name IS NOT NULL", + runID.Org, runID.Project, runID.Domain, lastCheck). + Find(&actions).Error; err != nil { + errs <- err + return + } + + for _, action := range actions { + updates <- action + } + + lastCheck = time.Now() + } + } + } +} + +// startPostgresListener starts the PostgreSQL LISTEN/NOTIFY listener +func (r *actionRepo) startPostgresListener() { + // Get the underlying SQL DB + sqlDB, err := r.db.DB() + if err != nil { + logger.Errorf(context.Background(), "Failed to get SQL DB: %v", err) + return + } + + // Get the connection string + var connStr string + row := sqlDB.QueryRow("SELECT current_database()") + var dbName string + if err := row.Scan(&dbName); err != nil { + logger.Errorf(context.Background(), "Failed to get database name: %v", err) + return + } + + // Build connection string from the existing connection + // This is a simplified approach - in production, get from config + row = sqlDB.QueryRow("SHOW server_version") + var version string + _ = row.Scan(&version) // Ignore error, just need a connection + + // Create listener with a simple connection string + // In production, get this from the database config + connStr = "user=postgres password=mysecretpassword host=localhost port=5432 dbname=" + dbName + " sslmode=disable" + + r.listener = pq.NewListener(connStr, 10*time.Second, time.Minute, func(ev pq.ListenerEventType, err error) { + if err != nil { + logger.Errorf(context.Background(), "Listener error: %v", err) + } + }) + + // Listen to channels + if err := r.listener.Listen("run_updates"); err != nil { + logger.Errorf(context.Background(), "Failed to listen to run_updates: %v", err) + return + } + + if err := r.listener.Listen("action_updates"); err != nil { + logger.Errorf(context.Background(), "Failed to listen to action_updates: %v", err) + return + } + + logger.Infof(context.Background(), "PostgreSQL LISTEN/NOTIFY started") + + // Process notifications + for { + select { + case notif := <-r.listener.Notify: + if notif == nil { + continue + } + + switch notif.Channel { + case "run_updates": + // Broadcast to all run subscribers + r.mu.RLock() + for ch := range r.runSubscribers { + select { + case ch <- notif.Extra: + default: + // Channel full, skip this subscriber + logger.Warnf(context.Background(), "Run subscriber channel full, dropping notification") + } + } + r.mu.RUnlock() + + case "action_updates": + // Broadcast to all action subscribers + r.mu.RLock() + for ch := range r.actionSubscribers { + select { + case ch <- notif.Extra: + default: + // Channel full, skip this subscriber + logger.Warnf(context.Background(), "Action subscriber channel full, dropping notification") + } + } + r.mu.RUnlock() + } + + case <-time.After(90 * time.Second): + // Ping to keep connection alive + if err := r.listener.Ping(); err != nil { + logger.Errorf(context.Background(), "Listener ping failed: %v", err) + return + } + } + } +} + +// notifyRunUpdate sends a notification about a run update +func (r *actionRepo) notifyRunUpdate(ctx context.Context, runID *common.RunIdentifier) { + if !r.isPostgres { + return + } + + payload := fmt.Sprintf("%s/%s/%s/%s", runID.Org, runID.Project, runID.Domain, runID.Name) + + // Execute NOTIFY + sql := fmt.Sprintf("NOTIFY run_updates, '%s'", payload) + if err := r.db.WithContext(ctx).Exec(sql).Error; err != nil { + logger.Errorf(ctx, "Failed to NOTIFY run_updates: %v", err) + } +} + +// notifyActionUpdate sends a notification about an action update +func (r *actionRepo) notifyActionUpdate(ctx context.Context, actionID *common.ActionIdentifier) { + if !r.isPostgres { + return + } + + payload := fmt.Sprintf("%s/%s/%s/%s/%s", + actionID.Run.Org, actionID.Run.Project, actionID.Run.Domain, actionID.Run.Name, actionID.Name) + + // Execute NOTIFY + sql := fmt.Sprintf("NOTIFY action_updates, '%s'", payload) + if err := r.db.WithContext(ctx).Exec(sql).Error; err != nil { + logger.Errorf(ctx, "Failed to NOTIFY action_updates: %v", err) + } +} diff --git a/runs/repository/impl/filters.go b/runs/repository/impl/filters.go new file mode 100644 index 0000000000..3875fbd1ad --- /dev/null +++ b/runs/repository/impl/filters.go @@ -0,0 +1,231 @@ +package impl + +import ( + "fmt" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + "github.com/flyteorg/flyte/v2/runs/repository/interfaces" +) + +// basicFilter implements the Filter interface for simple field comparisons +type basicFilter struct { + field string + expression interfaces.FilterExpression + value interface{} +} + +func (f *basicFilter) GormQueryExpression(table string) (interfaces.GormQueryExpr, error) { + var query string + column := f.field + if table != "" { + column = table + "." + f.field + } + + switch f.expression { + case interfaces.FilterExpressionEqual: + query = fmt.Sprintf("%s = ?", column) + case interfaces.FilterExpressionNotEqual: + query = fmt.Sprintf("%s != ?", column) + case interfaces.FilterExpressionGreaterThan: + query = fmt.Sprintf("%s > ?", column) + case interfaces.FilterExpressionGreaterThanOrEqual: + query = fmt.Sprintf("%s >= ?", column) + case interfaces.FilterExpressionLessThan: + query = fmt.Sprintf("%s < ?", column) + case interfaces.FilterExpressionLessThanOrEqual: + query = fmt.Sprintf("%s <= ?", column) + case interfaces.FilterExpressionContains: + query = fmt.Sprintf("%s LIKE ?", column) + f.value = fmt.Sprintf("%%%v%%", f.value) + case interfaces.FilterExpressionValueIn: + query = fmt.Sprintf("%s IN ?", column) + case interfaces.FilterExpressionEndsWith: + query = fmt.Sprintf("%s LIKE ?", column) + f.value = fmt.Sprintf("%%%v", f.value) + case interfaces.FilterExpressionNotEndsWith: + query = fmt.Sprintf("%s NOT LIKE ?", column) + f.value = fmt.Sprintf("%%%v", f.value) + case interfaces.FilterExpressionContainsCaseInsensitive: + query = fmt.Sprintf("LOWER(%s) LIKE LOWER(?)", column) + f.value = fmt.Sprintf("%%%v%%", f.value) + default: + return interfaces.GormQueryExpr{}, fmt.Errorf("unsupported filter expression: %d", f.expression) + } + + return interfaces.GormQueryExpr{ + Query: query, + Args: []interface{}{f.value}, + }, nil +} + +func (f *basicFilter) And(filter interfaces.Filter) interfaces.Filter { + return &compositeFilter{ + left: f, + right: filter, + operator: "AND", + } +} + +func (f *basicFilter) Or(filter interfaces.Filter) interfaces.Filter { + return &compositeFilter{ + left: f, + right: filter, + operator: "OR", + } +} + +// compositeFilter implements the Filter interface for AND/OR operations +type compositeFilter struct { + left interfaces.Filter + right interfaces.Filter + operator string // "AND" or "OR" +} + +func (f *compositeFilter) GormQueryExpression(table string) (interfaces.GormQueryExpr, error) { + leftExpr, err := f.left.GormQueryExpression(table) + if err != nil { + return interfaces.GormQueryExpr{}, err + } + + rightExpr, err := f.right.GormQueryExpression(table) + if err != nil { + return interfaces.GormQueryExpr{}, err + } + + query := fmt.Sprintf("(%s) %s (%s)", leftExpr.Query, f.operator, rightExpr.Query) + args := append(leftExpr.Args, rightExpr.Args...) + + return interfaces.GormQueryExpr{ + Query: query, + Args: args, + }, nil +} + +func (f *compositeFilter) And(filter interfaces.Filter) interfaces.Filter { + return &compositeFilter{ + left: f, + right: filter, + operator: "AND", + } +} + +func (f *compositeFilter) Or(filter interfaces.Filter) interfaces.Filter { + return &compositeFilter{ + left: f, + right: filter, + operator: "OR", + } +} + +// Helper functions to create filters + +// NewEqualFilter creates a filter for field = value +func NewEqualFilter(field string, value interface{}) interfaces.Filter { + return &basicFilter{ + field: field, + expression: interfaces.FilterExpressionEqual, + value: value, + } +} + +// NewOrgFilter creates a filter for org = value +func NewOrgFilter(org string) interfaces.Filter { + return NewEqualFilter("org", org) +} + +// NewProjectIdFilter creates a filter for project identifier (org, project, domain) +func NewProjectIdFilter(projectId *common.ProjectIdentifier) interfaces.Filter { + orgFilter := NewOrgFilter(projectId.GetOrganization()) + projectFilter := NewEqualFilter("project", projectId.GetName()) + domainFilter := NewEqualFilter("domain", projectId.GetDomain()) + + return orgFilter.And(projectFilter).And(domainFilter) +} + +// NewTaskNameFilter creates a filter for task name (org, project, domain, name) +func NewTaskNameFilter(taskName *task.TaskName) interfaces.Filter { + orgFilter := NewOrgFilter(taskName.GetOrg()) + projectFilter := NewEqualFilter("project", taskName.GetProject()) + domainFilter := NewEqualFilter("domain", taskName.GetDomain()) + nameFilter := NewEqualFilter("name", taskName.GetName()) + + return orgFilter.And(projectFilter).And(domainFilter).And(nameFilter) +} + +// NewDeployedByFilter creates a filter for deployed_by = value +func NewDeployedByFilter(deployedBy string) interfaces.Filter { + return NewEqualFilter("deployed_by", deployedBy) +} + +// ConvertProtoFiltersToGormFilters converts proto filters to our Filter interfaces +func ConvertProtoFiltersToGormFilters(protoFilters []*common.Filter) (interfaces.Filter, error) { + if len(protoFilters) == 0 { + return nil, nil + } + + filters := make([]interfaces.Filter, 0, len(protoFilters)) + + for _, protoFilter := range protoFilters { + // Convert filter function to expression + var expression interfaces.FilterExpression + switch protoFilter.Function { + case common.Filter_EQUAL: + expression = interfaces.FilterExpressionEqual + case common.Filter_NOT_EQUAL: + expression = interfaces.FilterExpressionNotEqual + case common.Filter_GREATER_THAN: + expression = interfaces.FilterExpressionGreaterThan + case common.Filter_GREATER_THAN_OR_EQUAL: + expression = interfaces.FilterExpressionGreaterThanOrEqual + case common.Filter_LESS_THAN: + expression = interfaces.FilterExpressionLessThan + case common.Filter_LESS_THAN_OR_EQUAL: + expression = interfaces.FilterExpressionLessThanOrEqual + case common.Filter_CONTAINS: + expression = interfaces.FilterExpressionContains + case common.Filter_VALUE_IN: + expression = interfaces.FilterExpressionValueIn + case common.Filter_ENDS_WITH: + expression = interfaces.FilterExpressionEndsWith + case common.Filter_NOT_ENDS_WITH: + expression = interfaces.FilterExpressionNotEndsWith + case common.Filter_CONTAINS_CASE_INSENSITIVE: + expression = interfaces.FilterExpressionContainsCaseInsensitive + default: + return nil, fmt.Errorf("unsupported filter function: %s", protoFilter.Function) + } + + // Get filter value(s) + var value interface{} + if len(protoFilter.Values) == 1 { + value = protoFilter.Values[0] + } else if len(protoFilter.Values) > 1 { + // For VALUE_IN, pass the array + value = protoFilter.Values + } else { + return nil, fmt.Errorf("filter %s has no values", protoFilter.Field) + } + + // Create basic filter + filter := &basicFilter{ + field: protoFilter.Field, + expression: expression, + value: value, + } + + filters = append(filters, filter) + } + + // Combine all filters with AND + if len(filters) == 0 { + return nil, nil + } + + combinedFilter := filters[0] + for i := 1; i < len(filters); i++ { + combinedFilter = combinedFilter.And(filters[i]) + } + + return combinedFilter, nil +} diff --git a/runs/repository/impl/filters_test.go b/runs/repository/impl/filters_test.go new file mode 100644 index 0000000000..eec23ea164 --- /dev/null +++ b/runs/repository/impl/filters_test.go @@ -0,0 +1,126 @@ +package impl + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + "github.com/flyteorg/flyte/v2/runs/repository/interfaces" +) + +func TestNewEqualFilter(t *testing.T) { + filter := NewEqualFilter("org", "test-org") + + expr, err := filter.GormQueryExpression("") + require.NoError(t, err) + assert.Equal(t, "org = ?", expr.Query) + assert.Equal(t, []interface{}{"test-org"}, expr.Args) +} + +func TestBasicFilter_Contains(t *testing.T) { + filter := &basicFilter{ + field: "name", + expression: interfaces.FilterExpressionContains, + value: "test", + } + + expr, err := filter.GormQueryExpression("") + require.NoError(t, err) + assert.Equal(t, "name LIKE ?", expr.Query) + assert.Equal(t, []interface{}{"%test%"}, expr.Args) +} + +func TestBasicFilter_ValueIn(t *testing.T) { + filter := &basicFilter{ + field: "status", + expression: interfaces.FilterExpressionValueIn, + value: []string{"active", "pending"}, + } + + expr, err := filter.GormQueryExpression("") + require.NoError(t, err) + assert.Equal(t, "status IN ?", expr.Query) +} + +func TestCompositeFilter_And(t *testing.T) { + f1 := NewEqualFilter("org", "test-org") + f2 := NewEqualFilter("project", "test-project") + + combined := f1.And(f2) + expr, err := combined.GormQueryExpression("") + require.NoError(t, err) + assert.Contains(t, expr.Query, "AND") + assert.Len(t, expr.Args, 2) +} + +func TestCompositeFilter_Or(t *testing.T) { + f1 := NewEqualFilter("status", "active") + f2 := NewEqualFilter("status", "pending") + + combined := f1.Or(f2) + expr, err := combined.GormQueryExpression("") + require.NoError(t, err) + assert.Contains(t, expr.Query, "OR") +} + +func TestNewProjectIdFilter(t *testing.T) { + projectId := &common.ProjectIdentifier{ + Organization: "test-org", + Name: "test-project", + Domain: "test-domain", + } + + filter := NewProjectIdFilter(projectId) + expr, err := filter.GormQueryExpression("") + require.NoError(t, err) + assert.Contains(t, expr.Query, "org = ?") + assert.Contains(t, expr.Query, "project = ?") + assert.Contains(t, expr.Query, "domain = ?") +} + +func TestNewTaskNameFilter(t *testing.T) { + taskName := &task.TaskName{ + Org: "test-org", + Project: "test-project", + Domain: "test-domain", + Name: "test-task", + } + + filter := NewTaskNameFilter(taskName) + expr, err := filter.GormQueryExpression("") + require.NoError(t, err) + assert.Contains(t, expr.Query, "name = ?") +} + +func TestConvertProtoFiltersToGormFilters(t *testing.T) { + protoFilters := []*common.Filter{ + { + Field: "org", + Function: common.Filter_EQUAL, + Values: []string{"test-org"}, + }, + { + Field: "name", + Function: common.Filter_CONTAINS, + Values: []string{"test"}, + }, + } + + filter, err := ConvertProtoFiltersToGormFilters(protoFilters) + require.NoError(t, err) + assert.NotNil(t, filter) + + expr, err := filter.GormQueryExpression("") + require.NoError(t, err) + assert.Contains(t, expr.Query, "org = ?") + assert.Contains(t, expr.Query, "name LIKE ?") +} + +func TestConvertProtoFilters_EmptyList(t *testing.T) { + filter, err := ConvertProtoFiltersToGormFilters([]*common.Filter{}) + require.NoError(t, err) + assert.Nil(t, filter) +} diff --git a/runs/repository/impl/requests.go b/runs/repository/impl/requests.go new file mode 100644 index 0000000000..c68d476d09 --- /dev/null +++ b/runs/repository/impl/requests.go @@ -0,0 +1,63 @@ +package impl + +import ( + "fmt" + + "k8s.io/apimachinery/pkg/util/sets" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/flyteorg/flyte/v2/runs/repository/interfaces" +) + +const ( + defaultLimit = 50 + maxLimit = 200 +) + +// NewListResourceInputFromProto converts a proto ListRequest to ListResourceInput for querying DB +func NewListResourceInputFromProto(request *common.ListRequest, allowedColumns sets.Set[string]) (interfaces.ListResourceInput, error) { + if request == nil { + request = &common.ListRequest{} + } + + // Validate and parse limit + limit := int(request.GetLimit()) + if limit == 0 { + limit = defaultLimit + } + if limit < 0 { + return interfaces.ListResourceInput{}, fmt.Errorf("invalid limit: %d (must be non-negative)", limit) + } + if limit > maxLimit { + return interfaces.ListResourceInput{}, fmt.Errorf("invalid limit: %d (exceeds maximum of %d)", limit, maxLimit) + } + + // Parse token as offset + var offset int + if request.Token != "" { + _, err := fmt.Sscanf(request.Token, "%d", &offset) + if err != nil { + return interfaces.ListResourceInput{}, fmt.Errorf("invalid token format: %s", request.Token) + } + if offset < 0 { + return interfaces.ListResourceInput{}, fmt.Errorf("invalid offset: %d (must be non-negative)", offset) + } + } + + sortParameters, err := GetSortByFieldsV2(request, allowedColumns) + if err != nil { + return interfaces.ListResourceInput{}, err + } + + combinedFilter, err := ConvertProtoFiltersToGormFilters(request.GetFilters()) + if err != nil { + return interfaces.ListResourceInput{}, fmt.Errorf("failed to convert filters: %w", err) + } + + return interfaces.ListResourceInput{ + Limit: limit, + Filter: combinedFilter, + Offset: offset, + SortParameters: sortParameters, + }, nil +} diff --git a/runs/repository/impl/sorting.go b/runs/repository/impl/sorting.go new file mode 100644 index 0000000000..5ca2ccdb89 --- /dev/null +++ b/runs/repository/impl/sorting.go @@ -0,0 +1,65 @@ +package impl + +import ( + "fmt" + + "k8s.io/apimachinery/pkg/util/sets" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/flyteorg/flyte/v2/runs/repository/interfaces" +) + +// sortParameter implements the SortParameter interface +type sortParameter struct { + field string + order interfaces.SortOrder +} + +func (s *sortParameter) GetGormOrderExpr() string { + orderStr := "DESC" + if s.order == interfaces.SortOrderAscending { + orderStr = "ASC" + } + return fmt.Sprintf("%s %s", s.field, orderStr) +} + +// NewSortParameter creates a new sort parameter +func NewSortParameter(field string, order interfaces.SortOrder) interfaces.SortParameter { + return &sortParameter{ + field: field, + order: order, + } +} + +// GetSortByFieldsV2 converts proto sort fields to our SortParameter interfaces with validation +func GetSortByFieldsV2(request *common.ListRequest, allowedSortColumns sets.Set[string]) ([]interfaces.SortParameter, error) { + if request == nil || request.GetSortByFields() == nil { + return nil, nil + } + + protoSortFields := request.GetSortByFields() + if len(protoSortFields) == 0 { + return nil, nil + } + + sortParams := make([]interfaces.SortParameter, 0, len(protoSortFields)) + + for _, sortField := range protoSortFields { + // Validate field is allowed + if !allowedSortColumns.Has(sortField.Key) { + return nil, fmt.Errorf("invalid sort field: %s", sortField.Key) + } + + // Convert direction + var order interfaces.SortOrder + if sortField.Direction == common.Sort_ASCENDING { + order = interfaces.SortOrderAscending + } else { + order = interfaces.SortOrderDescending + } + + sortParams = append(sortParams, NewSortParameter(sortField.Key, order)) + } + + return sortParams, nil +} diff --git a/runs/repository/impl/sorting_test.go b/runs/repository/impl/sorting_test.go new file mode 100644 index 0000000000..60886da3d2 --- /dev/null +++ b/runs/repository/impl/sorting_test.go @@ -0,0 +1,95 @@ +package impl + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "k8s.io/apimachinery/pkg/util/sets" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/flyteorg/flyte/v2/runs/repository/interfaces" +) + +func TestNewSortParameter(t *testing.T) { + sp := NewSortParameter("created_at", interfaces.SortOrderDescending) + assert.Equal(t, "created_at DESC", sp.GetGormOrderExpr()) +} + +func TestSortParameter_Ascending(t *testing.T) { + sp := NewSortParameter("name", interfaces.SortOrderAscending) + assert.Equal(t, "name ASC", sp.GetGormOrderExpr()) +} + +func TestGetSortByFieldsV2_SingleField(t *testing.T) { + request := &common.ListRequest{ + SortByFields: []*common.Sort{ + { + Key: "created_at", + Direction: common.Sort_DESCENDING, + }, + }, + } + + allowedColumns := sets.New("created_at", "name", "version") + sortParams, err := GetSortByFieldsV2(request, allowedColumns) + require.NoError(t, err) + require.Len(t, sortParams, 1) + assert.Equal(t, "created_at DESC", sortParams[0].GetGormOrderExpr()) +} + +func TestGetSortByFieldsV2_MultipleFields(t *testing.T) { + request := &common.ListRequest{ + SortByFields: []*common.Sort{ + { + Key: "name", + Direction: common.Sort_ASCENDING, + }, + { + Key: "version", + Direction: common.Sort_DESCENDING, + }, + }, + } + + allowedColumns := sets.New("name", "version") + sortParams, err := GetSortByFieldsV2(request, allowedColumns) + require.NoError(t, err) + require.Len(t, sortParams, 2) + assert.Equal(t, "name ASC", sortParams[0].GetGormOrderExpr()) + assert.Equal(t, "version DESC", sortParams[1].GetGormOrderExpr()) +} + +func TestGetSortByFieldsV2_InvalidField(t *testing.T) { + request := &common.ListRequest{ + SortByFields: []*common.Sort{ + { + Key: "invalid_field", + Direction: common.Sort_ASCENDING, + }, + }, + } + + allowedColumns := sets.New("name", "version") + _, err := GetSortByFieldsV2(request, allowedColumns) + assert.Error(t, err) + assert.Contains(t, err.Error(), "invalid sort field") +} + +func TestGetSortByFieldsV2_NilRequest(t *testing.T) { + allowedColumns := sets.New("name") + sortParams, err := GetSortByFieldsV2(nil, allowedColumns) + require.NoError(t, err) + assert.Nil(t, sortParams) +} + +func TestGetSortByFieldsV2_EmptyFields(t *testing.T) { + request := &common.ListRequest{ + SortByFields: []*common.Sort{}, + } + + allowedColumns := sets.New("name") + sortParams, err := GetSortByFieldsV2(request, allowedColumns) + require.NoError(t, err) + assert.Nil(t, sortParams) +} diff --git a/runs/repository/impl/task.go b/runs/repository/impl/task.go new file mode 100644 index 0000000000..5486b234ab --- /dev/null +++ b/runs/repository/impl/task.go @@ -0,0 +1,238 @@ +package impl + +import ( + "context" + "fmt" + "time" + + "gorm.io/gorm" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/runs/repository/interfaces" + "github.com/flyteorg/flyte/v2/runs/repository/models" +) + +type tasksRepo struct { + db *gorm.DB +} + +func NewTaskRepo(db *gorm.DB) interfaces.TaskRepo { + return &tasksRepo{ + db: db, + } +} + +// TODO(nary): add triggers back +func (r *tasksRepo) CreateTask(ctx context.Context, newTask *models.Task) error { + // Use GORM's Create or Updates based on conflict + // ON CONFLICT (org, project, domain, name, version) DO UPDATE + result := r.db.WithContext(ctx). + Exec(`INSERT INTO tasks ( + org, project, domain, name, version, + environment, function_name, deployed_by, + trigger_name, total_triggers, active_triggers, + trigger_automation_spec, trigger_types, + task_spec, env_description, short_description, + created_at, updated_at + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + ON CONFLICT (org, project, domain, name, version) DO UPDATE SET + environment = EXCLUDED.environment, + function_name = EXCLUDED.function_name, + deployed_by = EXCLUDED.deployed_by, + trigger_name = EXCLUDED.trigger_name, + total_triggers = EXCLUDED.total_triggers, + active_triggers = EXCLUDED.active_triggers, + trigger_automation_spec = EXCLUDED.trigger_automation_spec, + trigger_types = EXCLUDED.trigger_types, + task_spec = EXCLUDED.task_spec, + env_description = EXCLUDED.env_description, + short_description = EXCLUDED.short_description, + updated_at = EXCLUDED.updated_at`, + newTask.Org, + newTask.Project, + newTask.Domain, + newTask.Name, + newTask.Version, + newTask.Environment, + newTask.FunctionName, + newTask.DeployedBy, + newTask.TriggerName, + newTask.TotalTriggers, + newTask.ActiveTriggers, + newTask.TriggerAutomationSpec, + newTask.TriggerTypes, + newTask.TaskSpec, + newTask.EnvDescription, + newTask.ShortDescription, + time.Now(), + time.Now(), + ) + + if result.Error != nil { + logger.Errorf(ctx, "failed to create task %v: %v", newTask.TaskKey, result.Error) + return fmt.Errorf("failed to create task %v: %w", newTask.TaskKey, result.Error) + } + + logger.Infof(ctx, "Created/Updated task: %s/%s/%s/%s version %s", + newTask.Org, newTask.Project, newTask.Domain, newTask.Name, newTask.Version) + + return nil +} + +func (r *tasksRepo) GetTask(ctx context.Context, key models.TaskKey) (*models.Task, error) { + var task models.Task + result := r.db.WithContext(ctx). + Where("org = ? AND project = ? AND domain = ? AND name = ? AND version = ?", + key.Org, key.Project, key.Domain, key.Name, key.Version). + First(&task) + + if result.Error != nil { + if result.Error == gorm.ErrRecordNotFound { + return nil, fmt.Errorf("task not found: %v", key) + } + logger.Errorf(ctx, "failed to get task %v: %v", key, result.Error) + return nil, fmt.Errorf("failed to get task %v: %w", key, result.Error) + } + + return &task, nil +} + +func (r *tasksRepo) CreateTaskSpec(ctx context.Context, taskSpec *models.TaskSpec) error { + // Insert task spec (ignore conflicts since specs are immutable by digest) + result := r.db.WithContext(ctx). + Exec(`INSERT INTO task_specs (digest, spec) VALUES (?, ?) ON CONFLICT (digest) DO NOTHING`, + taskSpec.Digest, taskSpec.Spec) + + if result.Error != nil { + logger.Errorf(ctx, "failed to create task spec %v: %v", taskSpec.Digest, result.Error) + return fmt.Errorf("failed to create task spec %v: %w", taskSpec.Digest, result.Error) + } + + return nil +} + +func (r *tasksRepo) GetTaskSpec(ctx context.Context, digest string) (*models.TaskSpec, error) { + var taskSpec models.TaskSpec + result := r.db.WithContext(ctx). + Where("digest = ?", digest). + First(&taskSpec) + + if result.Error != nil { + if result.Error == gorm.ErrRecordNotFound { + return nil, fmt.Errorf("task spec not found: %s", digest) + } + logger.Errorf(ctx, "failed to get task spec %v: %v", digest, result.Error) + return nil, fmt.Errorf("failed to get task spec %v: %w", digest, result.Error) + } + + return &taskSpec, nil +} + +func (r *tasksRepo) ListTasks(ctx context.Context, input interfaces.ListResourceInput) (*models.TaskListResult, error) { + // TODO(nary): This is a simplified version without following features: + // - Selecting latest version per task name using ROW_NUMBER() window function + // - Filtered and unfiltered counts + // - Custom filter expressions + + var tasks []*models.Task + query := r.db.WithContext(ctx).Model(&models.Task{}) + + // Apply filters if provided + if input.Filter != nil { + expr, err := input.Filter.GormQueryExpression("") + if err != nil { + return nil, fmt.Errorf("failed to build filter: %w", err) + } + query = query.Where(expr.Query, expr.Args...) + } + + if input.ScopeByFilter != nil { + expr, err := input.ScopeByFilter.GormQueryExpression("") + if err != nil { + return nil, fmt.Errorf("failed to build scope filter: %w", err) + } + query = query.Where(expr.Query, expr.Args...) + } + + // Apply sorting + if len(input.SortParameters) > 0 { + for _, sp := range input.SortParameters { + query = query.Order(sp.GetGormOrderExpr()) + } + } else { + query = query.Order("created_at DESC") + } + + // Apply pagination + query = query.Limit(input.Limit).Offset(input.Offset) + + result := query.Find(&tasks) + if result.Error != nil { + logger.Errorf(ctx, "failed to list tasks: %v", result.Error) + return nil, fmt.Errorf("failed to list tasks: %w", result.Error) + } + + // Get total counts + var filteredTotal int64 + var total int64 + + countQuery := r.db.WithContext(ctx).Model(&models.Task{}) + if input.Filter != nil { + expr, _ := input.Filter.GormQueryExpression("") + countQuery = countQuery.Where(expr.Query, expr.Args...) + } + if input.ScopeByFilter != nil { + expr, _ := input.ScopeByFilter.GormQueryExpression("") + countQuery = countQuery.Where(expr.Query, expr.Args...) + } + countQuery.Count(&filteredTotal) + + totalQuery := r.db.WithContext(ctx).Model(&models.Task{}) + if input.ScopeByFilter != nil { + expr, _ := input.ScopeByFilter.GormQueryExpression("") + totalQuery = totalQuery.Where(expr.Query, expr.Args...) + } + totalQuery.Count(&total) + + return &models.TaskListResult{ + Tasks: tasks, + FilteredTotal: uint32(filteredTotal), + Total: uint32(total), + }, nil +} + +func (r *tasksRepo) ListVersions(ctx context.Context, input interfaces.ListResourceInput) ([]*models.TaskVersion, error) { + var versions []*models.TaskVersion + query := r.db.WithContext(ctx). + Model(&models.Task{}). + Select("version, created_at") + + // Apply filters + if input.Filter != nil { + expr, err := input.Filter.GormQueryExpression("") + if err != nil { + return nil, fmt.Errorf("failed to build filter: %w", err) + } + query = query.Where(expr.Query, expr.Args...) + } + + // Apply sorting + if len(input.SortParameters) > 0 { + for _, sp := range input.SortParameters { + query = query.Order(sp.GetGormOrderExpr()) + } + } else { + query = query.Order("created_at DESC") + } + + // Apply pagination + query = query.Limit(input.Limit).Offset(input.Offset) + + result := query.Find(&versions) + if result.Error != nil { + logger.Errorf(ctx, "failed to list versions: %v", result.Error) + return nil, fmt.Errorf("failed to list versions: %w", result.Error) + } + + return versions, nil +} diff --git a/runs/repository/impl/task_test.go b/runs/repository/impl/task_test.go new file mode 100644 index 0000000000..4d7531e73f --- /dev/null +++ b/runs/repository/impl/task_test.go @@ -0,0 +1,200 @@ +package impl + +import ( + "context" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "gorm.io/driver/sqlite" + "gorm.io/gorm" + + "github.com/flyteorg/flyte/v2/runs/repository/interfaces" + "github.com/flyteorg/flyte/v2/runs/repository/models" +) + +func setupTestDB(t *testing.T) *gorm.DB { + db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{}) + require.NoError(t, err) + + err = db.Exec(`CREATE TABLE tasks ( + org TEXT NOT NULL, + project TEXT NOT NULL, + domain TEXT NOT NULL, + name TEXT NOT NULL, + version TEXT NOT NULL, + environment TEXT, + function_name TEXT, + deployed_by TEXT, + trigger_name TEXT, + total_triggers INTEGER DEFAULT 0, + active_triggers INTEGER DEFAULT 0, + trigger_automation_spec BLOB, + trigger_types INTEGER, + task_spec BLOB, + env_description TEXT, + short_description TEXT, + created_at DATETIME DEFAULT CURRENT_TIMESTAMP, + updated_at DATETIME DEFAULT CURRENT_TIMESTAMP, + PRIMARY KEY (org, project, domain, name, version) + )`).Error + require.NoError(t, err) + + return db +} + +func TestCreateTask(t *testing.T) { + db := setupTestDB(t) + repo := NewTaskRepo(db) + ctx := context.Background() + + task := &models.Task{ + TaskKey: models.TaskKey{ + Org: "test-org", + Project: "test-project", + Domain: "test-domain", + Name: "test-task", + Version: "v1", + }, + Environment: "production", + FunctionName: "my_function", + DeployedBy: "user@example.com", + TaskSpec: []byte(`{"type": "python"}`), + } + + startTime := time.Now() + err := repo.CreateTask(ctx, task) + assert.NoError(t, err) + + retrieved, err := repo.GetTask(ctx, task.TaskKey) + require.NoError(t, err) + assert.Equal(t, task.Environment, retrieved.Environment) + assert.Equal(t, task.FunctionName, retrieved.FunctionName) + assert.WithinDuration(t, startTime, retrieved.CreatedAt, 1*time.Second, "created_at should be close to now") + assert.Equal(t, retrieved.CreatedAt, retrieved.UpdatedAt, "created_at and updated_at should be equal") +} + +func TestGetTask_NotFound(t *testing.T) { + db := setupTestDB(t) + repo := NewTaskRepo(db) + ctx := context.Background() + + key := models.TaskKey{ + Org: "non-existent", + Project: "test", + Domain: "test", + Name: "test", + Version: "v1", + } + + _, err := repo.GetTask(ctx, key) + assert.Error(t, err) + assert.Contains(t, err.Error(), "not found") +} + +func TestListTasks(t *testing.T) { + db := setupTestDB(t) + repo := NewTaskRepo(db) + ctx := context.Background() + + task1 := &models.Task{ + TaskKey: models.TaskKey{ + Org: "org1", + Project: "proj1", + Domain: "domain1", + Name: "task1", + Version: "v1", + }, + Environment: "prod", + TaskSpec: []byte("{}"), + } + + task2 := &models.Task{ + TaskKey: models.TaskKey{ + Org: "org1", + Project: "proj1", + Domain: "domain1", + Name: "task2", + Version: "v1", + }, + Environment: "dev", + TaskSpec: []byte("{}"), + } + + require.NoError(t, repo.CreateTask(ctx, task1)) + require.NoError(t, repo.CreateTask(ctx, task2)) + + result, err := repo.ListTasks(ctx, interfaces.ListResourceInput{ + Limit: 10, + Offset: 0, + }) + + require.NoError(t, err) + assert.Len(t, result.Tasks, 2) + assert.Equal(t, uint32(2), result.Total) +} + +func TestCreateTaskSpec(t *testing.T) { + db := setupTestDB(t) + + err := db.Exec(`CREATE TABLE task_specs ( + digest TEXT PRIMARY KEY, + spec BLOB NOT NULL + )`).Error + require.NoError(t, err) + + repo := NewTaskRepo(db) + ctx := context.Background() + + spec := &models.TaskSpec{ + Digest: "abc123", + Spec: []byte(`{"task": "spec"}`), + } + + err = repo.CreateTaskSpec(ctx, spec) + assert.NoError(t, err) + + retrieved, err := repo.GetTaskSpec(ctx, "abc123") + require.NoError(t, err) + assert.Equal(t, spec.Digest, retrieved.Digest) + assert.Equal(t, spec.Spec, retrieved.Spec) +} + +func TestCreateTask_UpdatePreservesCreatedAt(t *testing.T) { + db := setupTestDB(t) + repo := NewTaskRepo(db) + ctx := context.Background() + + task := &models.Task{ + TaskKey: models.TaskKey{ + Org: "test-org", + Project: "test-project", + Domain: "test-domain", + Name: "test-task", + Version: "v1", + }, + Environment: "production", + FunctionName: "original_function", + TaskSpec: []byte(`{}`), + } + + err := repo.CreateTask(ctx, task) + require.NoError(t, err) + + original, err := repo.GetTask(ctx, task.TaskKey) + require.NoError(t, err) + + time.Sleep(100 * time.Millisecond) + + task.FunctionName = "updated_function" + err = repo.CreateTask(ctx, task) + require.NoError(t, err) + + updated, err := repo.GetTask(ctx, task.TaskKey) + require.NoError(t, err) + + assert.Equal(t, original.CreatedAt, updated.CreatedAt, "create time shouldn't change") + assert.True(t, updated.UpdatedAt.After(original.UpdatedAt)) + assert.Equal(t, "updated_function", updated.FunctionName) +} diff --git a/runs/repository/interfaces/action.go b/runs/repository/interfaces/action.go new file mode 100644 index 0000000000..92bc1554b4 --- /dev/null +++ b/runs/repository/interfaces/action.go @@ -0,0 +1,38 @@ +package interfaces + +import ( + "context" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + "github.com/flyteorg/flyte/v2/runs/repository/models" +) + +// ActionRepo defines the interface for actions/runs data access +type ActionRepo interface { + // Run operations + CreateRun(ctx context.Context, req *workflow.CreateRunRequest) (*models.Run, error) + GetRun(ctx context.Context, runID *common.RunIdentifier) (*models.Run, error) + ListRuns(ctx context.Context, req *workflow.ListRunsRequest) ([]*models.Run, string, error) + AbortRun(ctx context.Context, runID *common.RunIdentifier, reason string, abortedBy *common.EnrichedIdentity) error + + // Action operations + CreateAction(ctx context.Context, runID uint, actionSpec *workflow.ActionSpec) (*models.Action, error) + GetAction(ctx context.Context, actionID *common.ActionIdentifier) (*models.Action, error) + ListActions(ctx context.Context, runID *common.RunIdentifier, limit int, token string) ([]*models.Action, string, error) + UpdateActionPhase(ctx context.Context, actionID *common.ActionIdentifier, phase string, startTime, endTime *string) error + AbortAction(ctx context.Context, actionID *common.ActionIdentifier, reason string, abortedBy *common.EnrichedIdentity) error + + // Watch operations (for streaming) + WatchRunUpdates(ctx context.Context, runID *common.RunIdentifier, updates chan<- *models.Run, errs chan<- error) + WatchAllRunUpdates(ctx context.Context, updates chan<- *models.Run, errs chan<- error) + WatchActionUpdates(ctx context.Context, runID *common.RunIdentifier, updates chan<- *models.Action, errs chan<- error) + + // State operations + UpdateActionState(ctx context.Context, actionID *common.ActionIdentifier, state string) error + GetActionState(ctx context.Context, actionID *common.ActionIdentifier) (string, error) + + // Event notification (for state updates) + NotifyStateUpdate(ctx context.Context, actionID *common.ActionIdentifier) error + WatchStateUpdates(ctx context.Context, updates chan<- *common.ActionIdentifier, errs chan<- error) +} diff --git a/runs/repository/interfaces/common.go b/runs/repository/interfaces/common.go new file mode 100644 index 0000000000..b2f6f2fc9e --- /dev/null +++ b/runs/repository/interfaces/common.go @@ -0,0 +1,31 @@ +package interfaces + +// ListResourceInput contains parameters for querying collections of resources. +type ListResourceInput struct { + Limit int + Offset int + + Filter Filter + // The filter set by scopeBy in the query + ScopeByFilter Filter + SortParameters []SortParameter +} + +func (l ListResourceInput) WithFilter(filter Filter) ListResourceInput { + if l.Filter != nil { + l.Filter = l.Filter.And(filter) + } else { + l.Filter = filter + } + + return l +} + +func (l ListResourceInput) WithSortParameters(sortParameters ...SortParameter) ListResourceInput { + if l.SortParameters == nil { + l.SortParameters = make([]SortParameter, 0, len(sortParameters)) + } + + l.SortParameters = append(l.SortParameters, sortParameters...) + return l +} diff --git a/runs/repository/interfaces/filter.go b/runs/repository/interfaces/filter.go new file mode 100644 index 0000000000..4cec8b0c80 --- /dev/null +++ b/runs/repository/interfaces/filter.go @@ -0,0 +1,30 @@ +package interfaces + +type FilterExpression = int + +// Set of filters available for database queries. +const ( + FilterExpressionEqual FilterExpression = iota + FilterExpressionNotEqual + FilterExpressionGreaterThan + FilterExpressionGreaterThanOrEqual + FilterExpressionLessThan + FilterExpressionLessThanOrEqual + FilterExpressionContains + FilterExpressionValueIn + FilterExpressionEndsWith + FilterExpressionNotEndsWith + FilterExpressionContainsCaseInsensitive +) + +// GormQueryExpr is a container for arguments necessary to issue a GORM query. +type GormQueryExpr struct { + Query string + Args []interface{} +} + +type Filter interface { + GormQueryExpression(table string) (GormQueryExpr, error) + And(filter Filter) Filter + Or(filter Filter) Filter +} diff --git a/runs/repository/interfaces/repository.go b/runs/repository/interfaces/repository.go new file mode 100644 index 0000000000..6bacc7e2d5 --- /dev/null +++ b/runs/repository/interfaces/repository.go @@ -0,0 +1,6 @@ +package interfaces + +type Repository interface { + ActionRepo() ActionRepo + TaskRepo() TaskRepo +} diff --git a/runs/repository/interfaces/sort.go b/runs/repository/interfaces/sort.go new file mode 100644 index 0000000000..b8acf74f4b --- /dev/null +++ b/runs/repository/interfaces/sort.go @@ -0,0 +1,13 @@ +package interfaces + +type SortOrder int + +// Set of sort orders available for database queries. +const ( + SortOrderDescending SortOrder = iota + SortOrderAscending +) + +type SortParameter interface { + GetGormOrderExpr() string +} diff --git a/runs/repository/interfaces/task.go b/runs/repository/interfaces/task.go new file mode 100644 index 0000000000..e72e784f96 --- /dev/null +++ b/runs/repository/interfaces/task.go @@ -0,0 +1,18 @@ +package interfaces + +import ( + "context" + + "github.com/flyteorg/flyte/v2/runs/repository/models" +) + +type TaskRepo interface { + // TODO: add triggers back + CreateTask(ctx context.Context, task *models.Task) error + GetTask(ctx context.Context, key models.TaskKey) (*models.Task, error) + ListTasks(ctx context.Context, input ListResourceInput) (*models.TaskListResult, error) + ListVersions(ctx context.Context, input ListResourceInput) ([]*models.TaskVersion, error) + + CreateTaskSpec(ctx context.Context, taskSpec *models.TaskSpec) error + GetTaskSpec(ctx context.Context, digest string) (*models.TaskSpec, error) +} diff --git a/runs/repository/mocks/action_repo.go b/runs/repository/mocks/action_repo.go new file mode 100644 index 0000000000..a3474999c5 --- /dev/null +++ b/runs/repository/mocks/action_repo.go @@ -0,0 +1,855 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + common "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + + mock "github.com/stretchr/testify/mock" + + models "github.com/flyteorg/flyte/v2/runs/repository/models" + + workflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" +) + +// ActionRepo is an autogenerated mock type for the ActionRepo type +type ActionRepo struct { + mock.Mock +} + +type ActionRepo_Expecter struct { + mock *mock.Mock +} + +func (_m *ActionRepo) EXPECT() *ActionRepo_Expecter { + return &ActionRepo_Expecter{mock: &_m.Mock} +} + +// AbortAction provides a mock function with given fields: ctx, actionID, reason, abortedBy +func (_m *ActionRepo) AbortAction(ctx context.Context, actionID *common.ActionIdentifier, reason string, abortedBy *common.EnrichedIdentity) error { + ret := _m.Called(ctx, actionID, reason, abortedBy) + + if len(ret) == 0 { + panic("no return value specified for AbortAction") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *common.ActionIdentifier, string, *common.EnrichedIdentity) error); ok { + r0 = rf(ctx, actionID, reason, abortedBy) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// ActionRepo_AbortAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortAction' +type ActionRepo_AbortAction_Call struct { + *mock.Call +} + +// AbortAction is a helper method to define mock.On call +// - ctx context.Context +// - actionID *common.ActionIdentifier +// - reason string +// - abortedBy *common.EnrichedIdentity +func (_e *ActionRepo_Expecter) AbortAction(ctx interface{}, actionID interface{}, reason interface{}, abortedBy interface{}) *ActionRepo_AbortAction_Call { + return &ActionRepo_AbortAction_Call{Call: _e.mock.On("AbortAction", ctx, actionID, reason, abortedBy)} +} + +func (_c *ActionRepo_AbortAction_Call) Run(run func(ctx context.Context, actionID *common.ActionIdentifier, reason string, abortedBy *common.EnrichedIdentity)) *ActionRepo_AbortAction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*common.ActionIdentifier), args[2].(string), args[3].(*common.EnrichedIdentity)) + }) + return _c +} + +func (_c *ActionRepo_AbortAction_Call) Return(_a0 error) *ActionRepo_AbortAction_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ActionRepo_AbortAction_Call) RunAndReturn(run func(context.Context, *common.ActionIdentifier, string, *common.EnrichedIdentity) error) *ActionRepo_AbortAction_Call { + _c.Call.Return(run) + return _c +} + +// AbortRun provides a mock function with given fields: ctx, runID, reason, abortedBy +func (_m *ActionRepo) AbortRun(ctx context.Context, runID *common.RunIdentifier, reason string, abortedBy *common.EnrichedIdentity) error { + ret := _m.Called(ctx, runID, reason, abortedBy) + + if len(ret) == 0 { + panic("no return value specified for AbortRun") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *common.RunIdentifier, string, *common.EnrichedIdentity) error); ok { + r0 = rf(ctx, runID, reason, abortedBy) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// ActionRepo_AbortRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortRun' +type ActionRepo_AbortRun_Call struct { + *mock.Call +} + +// AbortRun is a helper method to define mock.On call +// - ctx context.Context +// - runID *common.RunIdentifier +// - reason string +// - abortedBy *common.EnrichedIdentity +func (_e *ActionRepo_Expecter) AbortRun(ctx interface{}, runID interface{}, reason interface{}, abortedBy interface{}) *ActionRepo_AbortRun_Call { + return &ActionRepo_AbortRun_Call{Call: _e.mock.On("AbortRun", ctx, runID, reason, abortedBy)} +} + +func (_c *ActionRepo_AbortRun_Call) Run(run func(ctx context.Context, runID *common.RunIdentifier, reason string, abortedBy *common.EnrichedIdentity)) *ActionRepo_AbortRun_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*common.RunIdentifier), args[2].(string), args[3].(*common.EnrichedIdentity)) + }) + return _c +} + +func (_c *ActionRepo_AbortRun_Call) Return(_a0 error) *ActionRepo_AbortRun_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ActionRepo_AbortRun_Call) RunAndReturn(run func(context.Context, *common.RunIdentifier, string, *common.EnrichedIdentity) error) *ActionRepo_AbortRun_Call { + _c.Call.Return(run) + return _c +} + +// CreateAction provides a mock function with given fields: ctx, runID, actionSpec +func (_m *ActionRepo) CreateAction(ctx context.Context, runID uint, actionSpec *workflow.ActionSpec) (*models.Action, error) { + ret := _m.Called(ctx, runID, actionSpec) + + if len(ret) == 0 { + panic("no return value specified for CreateAction") + } + + var r0 *models.Action + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, uint, *workflow.ActionSpec) (*models.Action, error)); ok { + return rf(ctx, runID, actionSpec) + } + if rf, ok := ret.Get(0).(func(context.Context, uint, *workflow.ActionSpec) *models.Action); ok { + r0 = rf(ctx, runID, actionSpec) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*models.Action) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, uint, *workflow.ActionSpec) error); ok { + r1 = rf(ctx, runID, actionSpec) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ActionRepo_CreateAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAction' +type ActionRepo_CreateAction_Call struct { + *mock.Call +} + +// CreateAction is a helper method to define mock.On call +// - ctx context.Context +// - runID uint +// - actionSpec *workflow.ActionSpec +func (_e *ActionRepo_Expecter) CreateAction(ctx interface{}, runID interface{}, actionSpec interface{}) *ActionRepo_CreateAction_Call { + return &ActionRepo_CreateAction_Call{Call: _e.mock.On("CreateAction", ctx, runID, actionSpec)} +} + +func (_c *ActionRepo_CreateAction_Call) Run(run func(ctx context.Context, runID uint, actionSpec *workflow.ActionSpec)) *ActionRepo_CreateAction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(uint), args[2].(*workflow.ActionSpec)) + }) + return _c +} + +func (_c *ActionRepo_CreateAction_Call) Return(_a0 *models.Action, _a1 error) *ActionRepo_CreateAction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ActionRepo_CreateAction_Call) RunAndReturn(run func(context.Context, uint, *workflow.ActionSpec) (*models.Action, error)) *ActionRepo_CreateAction_Call { + _c.Call.Return(run) + return _c +} + +// CreateRun provides a mock function with given fields: ctx, req +func (_m *ActionRepo) CreateRun(ctx context.Context, req *workflow.CreateRunRequest) (*models.Run, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for CreateRun") + } + + var r0 *models.Run + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.CreateRunRequest) (*models.Run, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.CreateRunRequest) *models.Run); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*models.Run) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.CreateRunRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ActionRepo_CreateRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRun' +type ActionRepo_CreateRun_Call struct { + *mock.Call +} + +// CreateRun is a helper method to define mock.On call +// - ctx context.Context +// - req *workflow.CreateRunRequest +func (_e *ActionRepo_Expecter) CreateRun(ctx interface{}, req interface{}) *ActionRepo_CreateRun_Call { + return &ActionRepo_CreateRun_Call{Call: _e.mock.On("CreateRun", ctx, req)} +} + +func (_c *ActionRepo_CreateRun_Call) Run(run func(ctx context.Context, req *workflow.CreateRunRequest)) *ActionRepo_CreateRun_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.CreateRunRequest)) + }) + return _c +} + +func (_c *ActionRepo_CreateRun_Call) Return(_a0 *models.Run, _a1 error) *ActionRepo_CreateRun_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ActionRepo_CreateRun_Call) RunAndReturn(run func(context.Context, *workflow.CreateRunRequest) (*models.Run, error)) *ActionRepo_CreateRun_Call { + _c.Call.Return(run) + return _c +} + +// GetAction provides a mock function with given fields: ctx, actionID +func (_m *ActionRepo) GetAction(ctx context.Context, actionID *common.ActionIdentifier) (*models.Action, error) { + ret := _m.Called(ctx, actionID) + + if len(ret) == 0 { + panic("no return value specified for GetAction") + } + + var r0 *models.Action + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *common.ActionIdentifier) (*models.Action, error)); ok { + return rf(ctx, actionID) + } + if rf, ok := ret.Get(0).(func(context.Context, *common.ActionIdentifier) *models.Action); ok { + r0 = rf(ctx, actionID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*models.Action) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *common.ActionIdentifier) error); ok { + r1 = rf(ctx, actionID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ActionRepo_GetAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAction' +type ActionRepo_GetAction_Call struct { + *mock.Call +} + +// GetAction is a helper method to define mock.On call +// - ctx context.Context +// - actionID *common.ActionIdentifier +func (_e *ActionRepo_Expecter) GetAction(ctx interface{}, actionID interface{}) *ActionRepo_GetAction_Call { + return &ActionRepo_GetAction_Call{Call: _e.mock.On("GetAction", ctx, actionID)} +} + +func (_c *ActionRepo_GetAction_Call) Run(run func(ctx context.Context, actionID *common.ActionIdentifier)) *ActionRepo_GetAction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*common.ActionIdentifier)) + }) + return _c +} + +func (_c *ActionRepo_GetAction_Call) Return(_a0 *models.Action, _a1 error) *ActionRepo_GetAction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ActionRepo_GetAction_Call) RunAndReturn(run func(context.Context, *common.ActionIdentifier) (*models.Action, error)) *ActionRepo_GetAction_Call { + _c.Call.Return(run) + return _c +} + +// GetActionState provides a mock function with given fields: ctx, actionID +func (_m *ActionRepo) GetActionState(ctx context.Context, actionID *common.ActionIdentifier) (string, error) { + ret := _m.Called(ctx, actionID) + + if len(ret) == 0 { + panic("no return value specified for GetActionState") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *common.ActionIdentifier) (string, error)); ok { + return rf(ctx, actionID) + } + if rf, ok := ret.Get(0).(func(context.Context, *common.ActionIdentifier) string); ok { + r0 = rf(ctx, actionID) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(context.Context, *common.ActionIdentifier) error); ok { + r1 = rf(ctx, actionID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ActionRepo_GetActionState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActionState' +type ActionRepo_GetActionState_Call struct { + *mock.Call +} + +// GetActionState is a helper method to define mock.On call +// - ctx context.Context +// - actionID *common.ActionIdentifier +func (_e *ActionRepo_Expecter) GetActionState(ctx interface{}, actionID interface{}) *ActionRepo_GetActionState_Call { + return &ActionRepo_GetActionState_Call{Call: _e.mock.On("GetActionState", ctx, actionID)} +} + +func (_c *ActionRepo_GetActionState_Call) Run(run func(ctx context.Context, actionID *common.ActionIdentifier)) *ActionRepo_GetActionState_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*common.ActionIdentifier)) + }) + return _c +} + +func (_c *ActionRepo_GetActionState_Call) Return(_a0 string, _a1 error) *ActionRepo_GetActionState_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ActionRepo_GetActionState_Call) RunAndReturn(run func(context.Context, *common.ActionIdentifier) (string, error)) *ActionRepo_GetActionState_Call { + _c.Call.Return(run) + return _c +} + +// GetRun provides a mock function with given fields: ctx, runID +func (_m *ActionRepo) GetRun(ctx context.Context, runID *common.RunIdentifier) (*models.Run, error) { + ret := _m.Called(ctx, runID) + + if len(ret) == 0 { + panic("no return value specified for GetRun") + } + + var r0 *models.Run + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *common.RunIdentifier) (*models.Run, error)); ok { + return rf(ctx, runID) + } + if rf, ok := ret.Get(0).(func(context.Context, *common.RunIdentifier) *models.Run); ok { + r0 = rf(ctx, runID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*models.Run) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *common.RunIdentifier) error); ok { + r1 = rf(ctx, runID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ActionRepo_GetRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRun' +type ActionRepo_GetRun_Call struct { + *mock.Call +} + +// GetRun is a helper method to define mock.On call +// - ctx context.Context +// - runID *common.RunIdentifier +func (_e *ActionRepo_Expecter) GetRun(ctx interface{}, runID interface{}) *ActionRepo_GetRun_Call { + return &ActionRepo_GetRun_Call{Call: _e.mock.On("GetRun", ctx, runID)} +} + +func (_c *ActionRepo_GetRun_Call) Run(run func(ctx context.Context, runID *common.RunIdentifier)) *ActionRepo_GetRun_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*common.RunIdentifier)) + }) + return _c +} + +func (_c *ActionRepo_GetRun_Call) Return(_a0 *models.Run, _a1 error) *ActionRepo_GetRun_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ActionRepo_GetRun_Call) RunAndReturn(run func(context.Context, *common.RunIdentifier) (*models.Run, error)) *ActionRepo_GetRun_Call { + _c.Call.Return(run) + return _c +} + +// ListActions provides a mock function with given fields: ctx, runID, limit, token +func (_m *ActionRepo) ListActions(ctx context.Context, runID *common.RunIdentifier, limit int, token string) ([]*models.Action, string, error) { + ret := _m.Called(ctx, runID, limit, token) + + if len(ret) == 0 { + panic("no return value specified for ListActions") + } + + var r0 []*models.Action + var r1 string + var r2 error + if rf, ok := ret.Get(0).(func(context.Context, *common.RunIdentifier, int, string) ([]*models.Action, string, error)); ok { + return rf(ctx, runID, limit, token) + } + if rf, ok := ret.Get(0).(func(context.Context, *common.RunIdentifier, int, string) []*models.Action); ok { + r0 = rf(ctx, runID, limit, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*models.Action) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *common.RunIdentifier, int, string) string); ok { + r1 = rf(ctx, runID, limit, token) + } else { + r1 = ret.Get(1).(string) + } + + if rf, ok := ret.Get(2).(func(context.Context, *common.RunIdentifier, int, string) error); ok { + r2 = rf(ctx, runID, limit, token) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ActionRepo_ListActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListActions' +type ActionRepo_ListActions_Call struct { + *mock.Call +} + +// ListActions is a helper method to define mock.On call +// - ctx context.Context +// - runID *common.RunIdentifier +// - limit int +// - token string +func (_e *ActionRepo_Expecter) ListActions(ctx interface{}, runID interface{}, limit interface{}, token interface{}) *ActionRepo_ListActions_Call { + return &ActionRepo_ListActions_Call{Call: _e.mock.On("ListActions", ctx, runID, limit, token)} +} + +func (_c *ActionRepo_ListActions_Call) Run(run func(ctx context.Context, runID *common.RunIdentifier, limit int, token string)) *ActionRepo_ListActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*common.RunIdentifier), args[2].(int), args[3].(string)) + }) + return _c +} + +func (_c *ActionRepo_ListActions_Call) Return(_a0 []*models.Action, _a1 string, _a2 error) *ActionRepo_ListActions_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ActionRepo_ListActions_Call) RunAndReturn(run func(context.Context, *common.RunIdentifier, int, string) ([]*models.Action, string, error)) *ActionRepo_ListActions_Call { + _c.Call.Return(run) + return _c +} + +// ListRuns provides a mock function with given fields: ctx, req +func (_m *ActionRepo) ListRuns(ctx context.Context, req *workflow.ListRunsRequest) ([]*models.Run, string, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for ListRuns") + } + + var r0 []*models.Run + var r1 string + var r2 error + if rf, ok := ret.Get(0).(func(context.Context, *workflow.ListRunsRequest) ([]*models.Run, string, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflow.ListRunsRequest) []*models.Run); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*models.Run) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflow.ListRunsRequest) string); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Get(1).(string) + } + + if rf, ok := ret.Get(2).(func(context.Context, *workflow.ListRunsRequest) error); ok { + r2 = rf(ctx, req) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ActionRepo_ListRuns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRuns' +type ActionRepo_ListRuns_Call struct { + *mock.Call +} + +// ListRuns is a helper method to define mock.On call +// - ctx context.Context +// - req *workflow.ListRunsRequest +func (_e *ActionRepo_Expecter) ListRuns(ctx interface{}, req interface{}) *ActionRepo_ListRuns_Call { + return &ActionRepo_ListRuns_Call{Call: _e.mock.On("ListRuns", ctx, req)} +} + +func (_c *ActionRepo_ListRuns_Call) Run(run func(ctx context.Context, req *workflow.ListRunsRequest)) *ActionRepo_ListRuns_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflow.ListRunsRequest)) + }) + return _c +} + +func (_c *ActionRepo_ListRuns_Call) Return(_a0 []*models.Run, _a1 string, _a2 error) *ActionRepo_ListRuns_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ActionRepo_ListRuns_Call) RunAndReturn(run func(context.Context, *workflow.ListRunsRequest) ([]*models.Run, string, error)) *ActionRepo_ListRuns_Call { + _c.Call.Return(run) + return _c +} + +// NotifyStateUpdate provides a mock function with given fields: ctx, actionID +func (_m *ActionRepo) NotifyStateUpdate(ctx context.Context, actionID *common.ActionIdentifier) error { + ret := _m.Called(ctx, actionID) + + if len(ret) == 0 { + panic("no return value specified for NotifyStateUpdate") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *common.ActionIdentifier) error); ok { + r0 = rf(ctx, actionID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// ActionRepo_NotifyStateUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NotifyStateUpdate' +type ActionRepo_NotifyStateUpdate_Call struct { + *mock.Call +} + +// NotifyStateUpdate is a helper method to define mock.On call +// - ctx context.Context +// - actionID *common.ActionIdentifier +func (_e *ActionRepo_Expecter) NotifyStateUpdate(ctx interface{}, actionID interface{}) *ActionRepo_NotifyStateUpdate_Call { + return &ActionRepo_NotifyStateUpdate_Call{Call: _e.mock.On("NotifyStateUpdate", ctx, actionID)} +} + +func (_c *ActionRepo_NotifyStateUpdate_Call) Run(run func(ctx context.Context, actionID *common.ActionIdentifier)) *ActionRepo_NotifyStateUpdate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*common.ActionIdentifier)) + }) + return _c +} + +func (_c *ActionRepo_NotifyStateUpdate_Call) Return(_a0 error) *ActionRepo_NotifyStateUpdate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ActionRepo_NotifyStateUpdate_Call) RunAndReturn(run func(context.Context, *common.ActionIdentifier) error) *ActionRepo_NotifyStateUpdate_Call { + _c.Call.Return(run) + return _c +} + +// UpdateActionPhase provides a mock function with given fields: ctx, actionID, phase, startTime, endTime +func (_m *ActionRepo) UpdateActionPhase(ctx context.Context, actionID *common.ActionIdentifier, phase string, startTime *string, endTime *string) error { + ret := _m.Called(ctx, actionID, phase, startTime, endTime) + + if len(ret) == 0 { + panic("no return value specified for UpdateActionPhase") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *common.ActionIdentifier, string, *string, *string) error); ok { + r0 = rf(ctx, actionID, phase, startTime, endTime) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// ActionRepo_UpdateActionPhase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateActionPhase' +type ActionRepo_UpdateActionPhase_Call struct { + *mock.Call +} + +// UpdateActionPhase is a helper method to define mock.On call +// - ctx context.Context +// - actionID *common.ActionIdentifier +// - phase string +// - startTime *string +// - endTime *string +func (_e *ActionRepo_Expecter) UpdateActionPhase(ctx interface{}, actionID interface{}, phase interface{}, startTime interface{}, endTime interface{}) *ActionRepo_UpdateActionPhase_Call { + return &ActionRepo_UpdateActionPhase_Call{Call: _e.mock.On("UpdateActionPhase", ctx, actionID, phase, startTime, endTime)} +} + +func (_c *ActionRepo_UpdateActionPhase_Call) Run(run func(ctx context.Context, actionID *common.ActionIdentifier, phase string, startTime *string, endTime *string)) *ActionRepo_UpdateActionPhase_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*common.ActionIdentifier), args[2].(string), args[3].(*string), args[4].(*string)) + }) + return _c +} + +func (_c *ActionRepo_UpdateActionPhase_Call) Return(_a0 error) *ActionRepo_UpdateActionPhase_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ActionRepo_UpdateActionPhase_Call) RunAndReturn(run func(context.Context, *common.ActionIdentifier, string, *string, *string) error) *ActionRepo_UpdateActionPhase_Call { + _c.Call.Return(run) + return _c +} + +// UpdateActionState provides a mock function with given fields: ctx, actionID, state +func (_m *ActionRepo) UpdateActionState(ctx context.Context, actionID *common.ActionIdentifier, state string) error { + ret := _m.Called(ctx, actionID, state) + + if len(ret) == 0 { + panic("no return value specified for UpdateActionState") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *common.ActionIdentifier, string) error); ok { + r0 = rf(ctx, actionID, state) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// ActionRepo_UpdateActionState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateActionState' +type ActionRepo_UpdateActionState_Call struct { + *mock.Call +} + +// UpdateActionState is a helper method to define mock.On call +// - ctx context.Context +// - actionID *common.ActionIdentifier +// - state string +func (_e *ActionRepo_Expecter) UpdateActionState(ctx interface{}, actionID interface{}, state interface{}) *ActionRepo_UpdateActionState_Call { + return &ActionRepo_UpdateActionState_Call{Call: _e.mock.On("UpdateActionState", ctx, actionID, state)} +} + +func (_c *ActionRepo_UpdateActionState_Call) Run(run func(ctx context.Context, actionID *common.ActionIdentifier, state string)) *ActionRepo_UpdateActionState_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*common.ActionIdentifier), args[2].(string)) + }) + return _c +} + +func (_c *ActionRepo_UpdateActionState_Call) Return(_a0 error) *ActionRepo_UpdateActionState_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ActionRepo_UpdateActionState_Call) RunAndReturn(run func(context.Context, *common.ActionIdentifier, string) error) *ActionRepo_UpdateActionState_Call { + _c.Call.Return(run) + return _c +} + +// WatchActionUpdates provides a mock function with given fields: ctx, runID, updates, errs +func (_m *ActionRepo) WatchActionUpdates(ctx context.Context, runID *common.RunIdentifier, updates chan<- *models.Action, errs chan<- error) { + _m.Called(ctx, runID, updates, errs) +} + +// ActionRepo_WatchActionUpdates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchActionUpdates' +type ActionRepo_WatchActionUpdates_Call struct { + *mock.Call +} + +// WatchActionUpdates is a helper method to define mock.On call +// - ctx context.Context +// - runID *common.RunIdentifier +// - updates chan<- *models.Action +// - errs chan<- error +func (_e *ActionRepo_Expecter) WatchActionUpdates(ctx interface{}, runID interface{}, updates interface{}, errs interface{}) *ActionRepo_WatchActionUpdates_Call { + return &ActionRepo_WatchActionUpdates_Call{Call: _e.mock.On("WatchActionUpdates", ctx, runID, updates, errs)} +} + +func (_c *ActionRepo_WatchActionUpdates_Call) Run(run func(ctx context.Context, runID *common.RunIdentifier, updates chan<- *models.Action, errs chan<- error)) *ActionRepo_WatchActionUpdates_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*common.RunIdentifier), args[2].(chan<- *models.Action), args[3].(chan<- error)) + }) + return _c +} + +func (_c *ActionRepo_WatchActionUpdates_Call) Return() *ActionRepo_WatchActionUpdates_Call { + _c.Call.Return() + return _c +} + +func (_c *ActionRepo_WatchActionUpdates_Call) RunAndReturn(run func(context.Context, *common.RunIdentifier, chan<- *models.Action, chan<- error)) *ActionRepo_WatchActionUpdates_Call { + _c.Run(run) + return _c +} + +// WatchAllRunUpdates provides a mock function with given fields: ctx, updates, errs +func (_m *ActionRepo) WatchAllRunUpdates(ctx context.Context, updates chan<- *models.Run, errs chan<- error) { + _m.Called(ctx, updates, errs) +} + +// ActionRepo_WatchAllRunUpdates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchAllRunUpdates' +type ActionRepo_WatchAllRunUpdates_Call struct { + *mock.Call +} + +// WatchAllRunUpdates is a helper method to define mock.On call +// - ctx context.Context +// - updates chan<- *models.Run +// - errs chan<- error +func (_e *ActionRepo_Expecter) WatchAllRunUpdates(ctx interface{}, updates interface{}, errs interface{}) *ActionRepo_WatchAllRunUpdates_Call { + return &ActionRepo_WatchAllRunUpdates_Call{Call: _e.mock.On("WatchAllRunUpdates", ctx, updates, errs)} +} + +func (_c *ActionRepo_WatchAllRunUpdates_Call) Run(run func(ctx context.Context, updates chan<- *models.Run, errs chan<- error)) *ActionRepo_WatchAllRunUpdates_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(chan<- *models.Run), args[2].(chan<- error)) + }) + return _c +} + +func (_c *ActionRepo_WatchAllRunUpdates_Call) Return() *ActionRepo_WatchAllRunUpdates_Call { + _c.Call.Return() + return _c +} + +func (_c *ActionRepo_WatchAllRunUpdates_Call) RunAndReturn(run func(context.Context, chan<- *models.Run, chan<- error)) *ActionRepo_WatchAllRunUpdates_Call { + _c.Run(run) + return _c +} + +// WatchRunUpdates provides a mock function with given fields: ctx, runID, updates, errs +func (_m *ActionRepo) WatchRunUpdates(ctx context.Context, runID *common.RunIdentifier, updates chan<- *models.Run, errs chan<- error) { + _m.Called(ctx, runID, updates, errs) +} + +// ActionRepo_WatchRunUpdates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchRunUpdates' +type ActionRepo_WatchRunUpdates_Call struct { + *mock.Call +} + +// WatchRunUpdates is a helper method to define mock.On call +// - ctx context.Context +// - runID *common.RunIdentifier +// - updates chan<- *models.Run +// - errs chan<- error +func (_e *ActionRepo_Expecter) WatchRunUpdates(ctx interface{}, runID interface{}, updates interface{}, errs interface{}) *ActionRepo_WatchRunUpdates_Call { + return &ActionRepo_WatchRunUpdates_Call{Call: _e.mock.On("WatchRunUpdates", ctx, runID, updates, errs)} +} + +func (_c *ActionRepo_WatchRunUpdates_Call) Run(run func(ctx context.Context, runID *common.RunIdentifier, updates chan<- *models.Run, errs chan<- error)) *ActionRepo_WatchRunUpdates_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*common.RunIdentifier), args[2].(chan<- *models.Run), args[3].(chan<- error)) + }) + return _c +} + +func (_c *ActionRepo_WatchRunUpdates_Call) Return() *ActionRepo_WatchRunUpdates_Call { + _c.Call.Return() + return _c +} + +func (_c *ActionRepo_WatchRunUpdates_Call) RunAndReturn(run func(context.Context, *common.RunIdentifier, chan<- *models.Run, chan<- error)) *ActionRepo_WatchRunUpdates_Call { + _c.Run(run) + return _c +} + +// WatchStateUpdates provides a mock function with given fields: ctx, updates, errs +func (_m *ActionRepo) WatchStateUpdates(ctx context.Context, updates chan<- *common.ActionIdentifier, errs chan<- error) { + _m.Called(ctx, updates, errs) +} + +// ActionRepo_WatchStateUpdates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchStateUpdates' +type ActionRepo_WatchStateUpdates_Call struct { + *mock.Call +} + +// WatchStateUpdates is a helper method to define mock.On call +// - ctx context.Context +// - updates chan<- *common.ActionIdentifier +// - errs chan<- error +func (_e *ActionRepo_Expecter) WatchStateUpdates(ctx interface{}, updates interface{}, errs interface{}) *ActionRepo_WatchStateUpdates_Call { + return &ActionRepo_WatchStateUpdates_Call{Call: _e.mock.On("WatchStateUpdates", ctx, updates, errs)} +} + +func (_c *ActionRepo_WatchStateUpdates_Call) Run(run func(ctx context.Context, updates chan<- *common.ActionIdentifier, errs chan<- error)) *ActionRepo_WatchStateUpdates_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(chan<- *common.ActionIdentifier), args[2].(chan<- error)) + }) + return _c +} + +func (_c *ActionRepo_WatchStateUpdates_Call) Return() *ActionRepo_WatchStateUpdates_Call { + _c.Call.Return() + return _c +} + +func (_c *ActionRepo_WatchStateUpdates_Call) RunAndReturn(run func(context.Context, chan<- *common.ActionIdentifier, chan<- error)) *ActionRepo_WatchStateUpdates_Call { + _c.Run(run) + return _c +} + +// NewActionRepo creates a new instance of ActionRepo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewActionRepo(t interface { + mock.TestingT + Cleanup(func()) +}) *ActionRepo { + mock := &ActionRepo{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/runs/repository/mocks/filter.go b/runs/repository/mocks/filter.go new file mode 100644 index 0000000000..403e3c5bac --- /dev/null +++ b/runs/repository/mocks/filter.go @@ -0,0 +1,187 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + interfaces "github.com/flyteorg/flyte/v2/runs/repository/interfaces" + mock "github.com/stretchr/testify/mock" +) + +// Filter is an autogenerated mock type for the Filter type +type Filter struct { + mock.Mock +} + +type Filter_Expecter struct { + mock *mock.Mock +} + +func (_m *Filter) EXPECT() *Filter_Expecter { + return &Filter_Expecter{mock: &_m.Mock} +} + +// And provides a mock function with given fields: filter +func (_m *Filter) And(filter interfaces.Filter) interfaces.Filter { + ret := _m.Called(filter) + + if len(ret) == 0 { + panic("no return value specified for And") + } + + var r0 interfaces.Filter + if rf, ok := ret.Get(0).(func(interfaces.Filter) interfaces.Filter); ok { + r0 = rf(filter) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interfaces.Filter) + } + } + + return r0 +} + +// Filter_And_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'And' +type Filter_And_Call struct { + *mock.Call +} + +// And is a helper method to define mock.On call +// - filter interfaces.Filter +func (_e *Filter_Expecter) And(filter interface{}) *Filter_And_Call { + return &Filter_And_Call{Call: _e.mock.On("And", filter)} +} + +func (_c *Filter_And_Call) Run(run func(filter interfaces.Filter)) *Filter_And_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interfaces.Filter)) + }) + return _c +} + +func (_c *Filter_And_Call) Return(_a0 interfaces.Filter) *Filter_And_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Filter_And_Call) RunAndReturn(run func(interfaces.Filter) interfaces.Filter) *Filter_And_Call { + _c.Call.Return(run) + return _c +} + +// GormQueryExpression provides a mock function with given fields: table +func (_m *Filter) GormQueryExpression(table string) (interfaces.GormQueryExpr, error) { + ret := _m.Called(table) + + if len(ret) == 0 { + panic("no return value specified for GormQueryExpression") + } + + var r0 interfaces.GormQueryExpr + var r1 error + if rf, ok := ret.Get(0).(func(string) (interfaces.GormQueryExpr, error)); ok { + return rf(table) + } + if rf, ok := ret.Get(0).(func(string) interfaces.GormQueryExpr); ok { + r0 = rf(table) + } else { + r0 = ret.Get(0).(interfaces.GormQueryExpr) + } + + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(table) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Filter_GormQueryExpression_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GormQueryExpression' +type Filter_GormQueryExpression_Call struct { + *mock.Call +} + +// GormQueryExpression is a helper method to define mock.On call +// - table string +func (_e *Filter_Expecter) GormQueryExpression(table interface{}) *Filter_GormQueryExpression_Call { + return &Filter_GormQueryExpression_Call{Call: _e.mock.On("GormQueryExpression", table)} +} + +func (_c *Filter_GormQueryExpression_Call) Run(run func(table string)) *Filter_GormQueryExpression_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Filter_GormQueryExpression_Call) Return(_a0 interfaces.GormQueryExpr, _a1 error) *Filter_GormQueryExpression_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Filter_GormQueryExpression_Call) RunAndReturn(run func(string) (interfaces.GormQueryExpr, error)) *Filter_GormQueryExpression_Call { + _c.Call.Return(run) + return _c +} + +// Or provides a mock function with given fields: filter +func (_m *Filter) Or(filter interfaces.Filter) interfaces.Filter { + ret := _m.Called(filter) + + if len(ret) == 0 { + panic("no return value specified for Or") + } + + var r0 interfaces.Filter + if rf, ok := ret.Get(0).(func(interfaces.Filter) interfaces.Filter); ok { + r0 = rf(filter) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interfaces.Filter) + } + } + + return r0 +} + +// Filter_Or_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Or' +type Filter_Or_Call struct { + *mock.Call +} + +// Or is a helper method to define mock.On call +// - filter interfaces.Filter +func (_e *Filter_Expecter) Or(filter interface{}) *Filter_Or_Call { + return &Filter_Or_Call{Call: _e.mock.On("Or", filter)} +} + +func (_c *Filter_Or_Call) Run(run func(filter interfaces.Filter)) *Filter_Or_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interfaces.Filter)) + }) + return _c +} + +func (_c *Filter_Or_Call) Return(_a0 interfaces.Filter) *Filter_Or_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Filter_Or_Call) RunAndReturn(run func(interfaces.Filter) interfaces.Filter) *Filter_Or_Call { + _c.Call.Return(run) + return _c +} + +// NewFilter creates a new instance of Filter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewFilter(t interface { + mock.TestingT + Cleanup(func()) +}) *Filter { + mock := &Filter{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/runs/repository/mocks/repository.go b/runs/repository/mocks/repository.go new file mode 100644 index 0000000000..58e97e5478 --- /dev/null +++ b/runs/repository/mocks/repository.go @@ -0,0 +1,129 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + interfaces "github.com/flyteorg/flyte/v2/runs/repository/interfaces" + mock "github.com/stretchr/testify/mock" +) + +// Repository is an autogenerated mock type for the Repository type +type Repository struct { + mock.Mock +} + +type Repository_Expecter struct { + mock *mock.Mock +} + +func (_m *Repository) EXPECT() *Repository_Expecter { + return &Repository_Expecter{mock: &_m.Mock} +} + +// ActionRepo provides a mock function with no fields +func (_m *Repository) ActionRepo() interfaces.ActionRepo { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for ActionRepo") + } + + var r0 interfaces.ActionRepo + if rf, ok := ret.Get(0).(func() interfaces.ActionRepo); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interfaces.ActionRepo) + } + } + + return r0 +} + +// Repository_ActionRepo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ActionRepo' +type Repository_ActionRepo_Call struct { + *mock.Call +} + +// ActionRepo is a helper method to define mock.On call +func (_e *Repository_Expecter) ActionRepo() *Repository_ActionRepo_Call { + return &Repository_ActionRepo_Call{Call: _e.mock.On("ActionRepo")} +} + +func (_c *Repository_ActionRepo_Call) Run(run func()) *Repository_ActionRepo_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Repository_ActionRepo_Call) Return(_a0 interfaces.ActionRepo) *Repository_ActionRepo_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_ActionRepo_Call) RunAndReturn(run func() interfaces.ActionRepo) *Repository_ActionRepo_Call { + _c.Call.Return(run) + return _c +} + +// TaskRepo provides a mock function with no fields +func (_m *Repository) TaskRepo() interfaces.TaskRepo { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for TaskRepo") + } + + var r0 interfaces.TaskRepo + if rf, ok := ret.Get(0).(func() interfaces.TaskRepo); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interfaces.TaskRepo) + } + } + + return r0 +} + +// Repository_TaskRepo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TaskRepo' +type Repository_TaskRepo_Call struct { + *mock.Call +} + +// TaskRepo is a helper method to define mock.On call +func (_e *Repository_Expecter) TaskRepo() *Repository_TaskRepo_Call { + return &Repository_TaskRepo_Call{Call: _e.mock.On("TaskRepo")} +} + +func (_c *Repository_TaskRepo_Call) Run(run func()) *Repository_TaskRepo_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Repository_TaskRepo_Call) Return(_a0 interfaces.TaskRepo) *Repository_TaskRepo_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Repository_TaskRepo_Call) RunAndReturn(run func() interfaces.TaskRepo) *Repository_TaskRepo_Call { + _c.Call.Return(run) + return _c +} + +// NewRepository creates a new instance of Repository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRepository(t interface { + mock.TestingT + Cleanup(func()) +}) *Repository { + mock := &Repository{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/runs/repository/mocks/sort_parameter.go b/runs/repository/mocks/sort_parameter.go new file mode 100644 index 0000000000..07dd84a2fc --- /dev/null +++ b/runs/repository/mocks/sort_parameter.go @@ -0,0 +1,77 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// SortParameter is an autogenerated mock type for the SortParameter type +type SortParameter struct { + mock.Mock +} + +type SortParameter_Expecter struct { + mock *mock.Mock +} + +func (_m *SortParameter) EXPECT() *SortParameter_Expecter { + return &SortParameter_Expecter{mock: &_m.Mock} +} + +// GetGormOrderExpr provides a mock function with no fields +func (_m *SortParameter) GetGormOrderExpr() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetGormOrderExpr") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// SortParameter_GetGormOrderExpr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGormOrderExpr' +type SortParameter_GetGormOrderExpr_Call struct { + *mock.Call +} + +// GetGormOrderExpr is a helper method to define mock.On call +func (_e *SortParameter_Expecter) GetGormOrderExpr() *SortParameter_GetGormOrderExpr_Call { + return &SortParameter_GetGormOrderExpr_Call{Call: _e.mock.On("GetGormOrderExpr")} +} + +func (_c *SortParameter_GetGormOrderExpr_Call) Run(run func()) *SortParameter_GetGormOrderExpr_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SortParameter_GetGormOrderExpr_Call) Return(_a0 string) *SortParameter_GetGormOrderExpr_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SortParameter_GetGormOrderExpr_Call) RunAndReturn(run func() string) *SortParameter_GetGormOrderExpr_Call { + _c.Call.Return(run) + return _c +} + +// NewSortParameter creates a new instance of SortParameter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewSortParameter(t interface { + mock.TestingT + Cleanup(func()) +}) *SortParameter { + mock := &SortParameter{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/runs/repository/mocks/task_repo.go b/runs/repository/mocks/task_repo.go new file mode 100644 index 0000000000..8bae788388 --- /dev/null +++ b/runs/repository/mocks/task_repo.go @@ -0,0 +1,369 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + interfaces "github.com/flyteorg/flyte/v2/runs/repository/interfaces" + mock "github.com/stretchr/testify/mock" + + models "github.com/flyteorg/flyte/v2/runs/repository/models" +) + +// TaskRepo is an autogenerated mock type for the TaskRepo type +type TaskRepo struct { + mock.Mock +} + +type TaskRepo_Expecter struct { + mock *mock.Mock +} + +func (_m *TaskRepo) EXPECT() *TaskRepo_Expecter { + return &TaskRepo_Expecter{mock: &_m.Mock} +} + +// CreateTask provides a mock function with given fields: ctx, task +func (_m *TaskRepo) CreateTask(ctx context.Context, task *models.Task) error { + ret := _m.Called(ctx, task) + + if len(ret) == 0 { + panic("no return value specified for CreateTask") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *models.Task) error); ok { + r0 = rf(ctx, task) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// TaskRepo_CreateTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTask' +type TaskRepo_CreateTask_Call struct { + *mock.Call +} + +// CreateTask is a helper method to define mock.On call +// - ctx context.Context +// - task *models.Task +func (_e *TaskRepo_Expecter) CreateTask(ctx interface{}, task interface{}) *TaskRepo_CreateTask_Call { + return &TaskRepo_CreateTask_Call{Call: _e.mock.On("CreateTask", ctx, task)} +} + +func (_c *TaskRepo_CreateTask_Call) Run(run func(ctx context.Context, task *models.Task)) *TaskRepo_CreateTask_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*models.Task)) + }) + return _c +} + +func (_c *TaskRepo_CreateTask_Call) Return(_a0 error) *TaskRepo_CreateTask_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskRepo_CreateTask_Call) RunAndReturn(run func(context.Context, *models.Task) error) *TaskRepo_CreateTask_Call { + _c.Call.Return(run) + return _c +} + +// CreateTaskSpec provides a mock function with given fields: ctx, taskSpec +func (_m *TaskRepo) CreateTaskSpec(ctx context.Context, taskSpec *models.TaskSpec) error { + ret := _m.Called(ctx, taskSpec) + + if len(ret) == 0 { + panic("no return value specified for CreateTaskSpec") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *models.TaskSpec) error); ok { + r0 = rf(ctx, taskSpec) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// TaskRepo_CreateTaskSpec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTaskSpec' +type TaskRepo_CreateTaskSpec_Call struct { + *mock.Call +} + +// CreateTaskSpec is a helper method to define mock.On call +// - ctx context.Context +// - taskSpec *models.TaskSpec +func (_e *TaskRepo_Expecter) CreateTaskSpec(ctx interface{}, taskSpec interface{}) *TaskRepo_CreateTaskSpec_Call { + return &TaskRepo_CreateTaskSpec_Call{Call: _e.mock.On("CreateTaskSpec", ctx, taskSpec)} +} + +func (_c *TaskRepo_CreateTaskSpec_Call) Run(run func(ctx context.Context, taskSpec *models.TaskSpec)) *TaskRepo_CreateTaskSpec_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*models.TaskSpec)) + }) + return _c +} + +func (_c *TaskRepo_CreateTaskSpec_Call) Return(_a0 error) *TaskRepo_CreateTaskSpec_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *TaskRepo_CreateTaskSpec_Call) RunAndReturn(run func(context.Context, *models.TaskSpec) error) *TaskRepo_CreateTaskSpec_Call { + _c.Call.Return(run) + return _c +} + +// GetTask provides a mock function with given fields: ctx, key +func (_m *TaskRepo) GetTask(ctx context.Context, key models.TaskKey) (*models.Task, error) { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for GetTask") + } + + var r0 *models.Task + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.TaskKey) (*models.Task, error)); ok { + return rf(ctx, key) + } + if rf, ok := ret.Get(0).(func(context.Context, models.TaskKey) *models.Task); ok { + r0 = rf(ctx, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*models.Task) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, models.TaskKey) error); ok { + r1 = rf(ctx, key) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TaskRepo_GetTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTask' +type TaskRepo_GetTask_Call struct { + *mock.Call +} + +// GetTask is a helper method to define mock.On call +// - ctx context.Context +// - key models.TaskKey +func (_e *TaskRepo_Expecter) GetTask(ctx interface{}, key interface{}) *TaskRepo_GetTask_Call { + return &TaskRepo_GetTask_Call{Call: _e.mock.On("GetTask", ctx, key)} +} + +func (_c *TaskRepo_GetTask_Call) Run(run func(ctx context.Context, key models.TaskKey)) *TaskRepo_GetTask_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(models.TaskKey)) + }) + return _c +} + +func (_c *TaskRepo_GetTask_Call) Return(_a0 *models.Task, _a1 error) *TaskRepo_GetTask_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TaskRepo_GetTask_Call) RunAndReturn(run func(context.Context, models.TaskKey) (*models.Task, error)) *TaskRepo_GetTask_Call { + _c.Call.Return(run) + return _c +} + +// GetTaskSpec provides a mock function with given fields: ctx, digest +func (_m *TaskRepo) GetTaskSpec(ctx context.Context, digest string) (*models.TaskSpec, error) { + ret := _m.Called(ctx, digest) + + if len(ret) == 0 { + panic("no return value specified for GetTaskSpec") + } + + var r0 *models.TaskSpec + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string) (*models.TaskSpec, error)); ok { + return rf(ctx, digest) + } + if rf, ok := ret.Get(0).(func(context.Context, string) *models.TaskSpec); ok { + r0 = rf(ctx, digest) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*models.TaskSpec) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = rf(ctx, digest) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TaskRepo_GetTaskSpec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTaskSpec' +type TaskRepo_GetTaskSpec_Call struct { + *mock.Call +} + +// GetTaskSpec is a helper method to define mock.On call +// - ctx context.Context +// - digest string +func (_e *TaskRepo_Expecter) GetTaskSpec(ctx interface{}, digest interface{}) *TaskRepo_GetTaskSpec_Call { + return &TaskRepo_GetTaskSpec_Call{Call: _e.mock.On("GetTaskSpec", ctx, digest)} +} + +func (_c *TaskRepo_GetTaskSpec_Call) Run(run func(ctx context.Context, digest string)) *TaskRepo_GetTaskSpec_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *TaskRepo_GetTaskSpec_Call) Return(_a0 *models.TaskSpec, _a1 error) *TaskRepo_GetTaskSpec_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TaskRepo_GetTaskSpec_Call) RunAndReturn(run func(context.Context, string) (*models.TaskSpec, error)) *TaskRepo_GetTaskSpec_Call { + _c.Call.Return(run) + return _c +} + +// ListTasks provides a mock function with given fields: ctx, input +func (_m *TaskRepo) ListTasks(ctx context.Context, input interfaces.ListResourceInput) (*models.TaskListResult, error) { + ret := _m.Called(ctx, input) + + if len(ret) == 0 { + panic("no return value specified for ListTasks") + } + + var r0 *models.TaskListResult + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, interfaces.ListResourceInput) (*models.TaskListResult, error)); ok { + return rf(ctx, input) + } + if rf, ok := ret.Get(0).(func(context.Context, interfaces.ListResourceInput) *models.TaskListResult); ok { + r0 = rf(ctx, input) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*models.TaskListResult) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, interfaces.ListResourceInput) error); ok { + r1 = rf(ctx, input) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TaskRepo_ListTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTasks' +type TaskRepo_ListTasks_Call struct { + *mock.Call +} + +// ListTasks is a helper method to define mock.On call +// - ctx context.Context +// - input interfaces.ListResourceInput +func (_e *TaskRepo_Expecter) ListTasks(ctx interface{}, input interface{}) *TaskRepo_ListTasks_Call { + return &TaskRepo_ListTasks_Call{Call: _e.mock.On("ListTasks", ctx, input)} +} + +func (_c *TaskRepo_ListTasks_Call) Run(run func(ctx context.Context, input interfaces.ListResourceInput)) *TaskRepo_ListTasks_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interfaces.ListResourceInput)) + }) + return _c +} + +func (_c *TaskRepo_ListTasks_Call) Return(_a0 *models.TaskListResult, _a1 error) *TaskRepo_ListTasks_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TaskRepo_ListTasks_Call) RunAndReturn(run func(context.Context, interfaces.ListResourceInput) (*models.TaskListResult, error)) *TaskRepo_ListTasks_Call { + _c.Call.Return(run) + return _c +} + +// ListVersions provides a mock function with given fields: ctx, input +func (_m *TaskRepo) ListVersions(ctx context.Context, input interfaces.ListResourceInput) ([]*models.TaskVersion, error) { + ret := _m.Called(ctx, input) + + if len(ret) == 0 { + panic("no return value specified for ListVersions") + } + + var r0 []*models.TaskVersion + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, interfaces.ListResourceInput) ([]*models.TaskVersion, error)); ok { + return rf(ctx, input) + } + if rf, ok := ret.Get(0).(func(context.Context, interfaces.ListResourceInput) []*models.TaskVersion); ok { + r0 = rf(ctx, input) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*models.TaskVersion) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, interfaces.ListResourceInput) error); ok { + r1 = rf(ctx, input) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TaskRepo_ListVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVersions' +type TaskRepo_ListVersions_Call struct { + *mock.Call +} + +// ListVersions is a helper method to define mock.On call +// - ctx context.Context +// - input interfaces.ListResourceInput +func (_e *TaskRepo_Expecter) ListVersions(ctx interface{}, input interface{}) *TaskRepo_ListVersions_Call { + return &TaskRepo_ListVersions_Call{Call: _e.mock.On("ListVersions", ctx, input)} +} + +func (_c *TaskRepo_ListVersions_Call) Run(run func(ctx context.Context, input interfaces.ListResourceInput)) *TaskRepo_ListVersions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(interfaces.ListResourceInput)) + }) + return _c +} + +func (_c *TaskRepo_ListVersions_Call) Return(_a0 []*models.TaskVersion, _a1 error) *TaskRepo_ListVersions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *TaskRepo_ListVersions_Call) RunAndReturn(run func(context.Context, interfaces.ListResourceInput) ([]*models.TaskVersion, error)) *TaskRepo_ListVersions_Call { + _c.Call.Return(run) + return _c +} + +// NewTaskRepo creates a new instance of TaskRepo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTaskRepo(t interface { + mock.TestingT + Cleanup(func()) +}) *TaskRepo { + mock := &TaskRepo{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/runs/repository/models/action.go b/runs/repository/models/action.go new file mode 100644 index 0000000000..93a0dd0d9c --- /dev/null +++ b/runs/repository/models/action.go @@ -0,0 +1,59 @@ +package models + +import ( + "time" + + "gorm.io/datatypes" +) + +// Action represents a workflow action in the database +// Root actions (where ParentActionName is NULL) represent runs +type Action struct { + ID uint `gorm:"primaryKey" db:"id"` + + // Action Identifier (unique across org/project/domain/name) + Org string `gorm:"not null;uniqueIndex:idx_actions_identifier,priority:1;index:idx_actions_org" db:"org"` + Project string `gorm:"not null;uniqueIndex:idx_actions_identifier,priority:2;index:idx_actions_project" db:"project"` + Domain string `gorm:"not null;uniqueIndex:idx_actions_identifier,priority:3;index:idx_actions_domain" db:"domain"` + Name string `gorm:"not null;uniqueIndex:idx_actions_identifier,priority:4" db:"name"` + + // Parent action (NULL for root actions/runs) + ParentActionName *string `gorm:"index:idx_actions_parent" db:"parent_action_name"` + + // High-level status for quick queries/filtering + Phase string `gorm:"not null;default:'PHASE_QUEUED';index:idx_actions_phase" db:"phase"` + + // Serialized protobuf messages + // ActionSpec contains the full action specification proto + ActionSpec datatypes.JSON `gorm:"type:jsonb" db:"action_spec"` + + // ActionDetails contains the full action details proto: + // - ActionStatus (phase, timestamps, error, cache status, etc.) + // - ActionAttempts array (all attempts with their phase transitions, cluster events, logs, etc.) + // - Any other runtime state + ActionDetails datatypes.JSON `gorm:"type:jsonb" db:"action_details"` + + // Timestamps + CreatedAt time.Time `gorm:"not null;default:CURRENT_TIMESTAMP;index:idx_actions_created" db:"created_at"` + UpdatedAt time.Time `gorm:"not null;default:CURRENT_TIMESTAMP;index:idx_actions_updated" db:"updated_at"` +} + +// TableName specifies the table name +func (Action) TableName() string { return "actions" } + +// GetRunName extracts the run name from the action +// For root actions (runs), returns the action's own name +// For child actions, extracts from ActionSpec JSON +func (a *Action) GetRunName() string { + if a.ParentActionName == nil { + // Root action - the run name is the action name + return a.Name + } + + // TODO: Extract run name from ActionSpec JSON + // For now, return empty string as placeholder + return "" +} + +// Run is a type alias for Action (runs are just actions with ParentActionName == nil) +type Run = Action diff --git a/runs/repository/models/task.go b/runs/repository/models/task.go new file mode 100644 index 0000000000..e7794b0c9f --- /dev/null +++ b/runs/repository/models/task.go @@ -0,0 +1,137 @@ +package models + +import ( + "database/sql" + "time" + + "github.com/jackc/pgx/v5/pgtype" + "k8s.io/apimachinery/pkg/util/sets" +) + +// TaskColumns are the allowed columns for task queries +var TaskColumns = sets.New( + "org", + "project", + "domain", + "name", + "version", + "environment", + "function_name", + "deployed_by", + "created_at", + "updated_at", + "trigger_name", + "total_triggers", + "active_triggers", + "env_description", + "short_description", +) + +// TaskVersionColumns are the allowed columns for task version queries +var TaskVersionColumns = sets.New( + "version", + "created_at", +) + +// TaskName is a composite key representing a task +type TaskName struct { + Org string + Project string + Domain string + Name string +} + +// TaskKey is a composite key for a task +type TaskKey struct { + Org string `gorm:"primaryKey;index:idx_tasks_identifier,priority:1" db:"org"` + Project string `gorm:"primaryKey;index:idx_tasks_identifier,priority:2" db:"project"` + Domain string `gorm:"primaryKey;index:idx_tasks_identifier,priority:3" db:"domain"` + Name string `gorm:"primaryKey;index:idx_tasks_identifier,priority:4" db:"name"` + Version string `gorm:"primaryKey;index:idx_tasks_identifier,priority:5" db:"version"` +} + +// Tasks models the TaskDetails from the task_definition.proto +type Task struct { + TaskKey `gorm:"embedded"` + + // Extracted from Name + Environment string `gorm:"column:environment" db:"environment"` + FunctionName string `gorm:"column:function_name" db:"function_name"` + + // Base fields + CreatedAt time.Time `gorm:"column:created_at" db:"created_at"` + UpdatedAt time.Time `gorm:"column:updated_at" db:"updated_at"` + + // Metadata + DeployedBy string `gorm:"column:deployed_by" db:"deployed_by"` + TriggerName sql.NullString `gorm:"column:trigger_name" db:"trigger_name"` + TotalTriggers uint32 `gorm:"column:total_triggers" db:"total_triggers"` + ActiveTriggers uint32 `gorm:"column:active_triggers" db:"active_triggers"` + TriggerAutomationSpec []byte `gorm:"column:trigger_automation_spec" db:"trigger_automation_spec"` + TriggerTypes pgtype.Bits `gorm:"column:trigger_types;type:bit(10)" db:"trigger_types"` + EnvDescription sql.NullString `gorm:"column:env_description" db:"env_description" json:"env_description,omitempty"` + ShortDescription sql.NullString `gorm:"column:short_description" db:"short_description" json:"short_description,omitempty"` + + // Spec + TaskSpec []byte `gorm:"column:task_spec" db:"task_spec"` +} + +// TableName specifies the table name +func (Task) TableName() string { return "tasks" } + +type TaskCounts struct { + // FilteredTotal is the number of tasks matching the applied filter + FilteredTotal uint32 `db:"filtered_total"` + // Total is the total number of tasks without any filters + Total uint32 `db:"total"` +} + +// TaskWithCounts extends Task with count information for pagination +type TaskWithCounts struct { + Task + TaskCounts +} + +type TaskListResult struct { + Tasks []*Task + FilteredTotal uint32 + Total uint32 +} + +type TaskGroup struct { + TaskName string `db:"task_name"` + EnvironmentName *string `db:"environment_name"` + TaskShortName *string `db:"task_short_name"` + + ActionCount int64 `db:"action_count"` + LatestCreatedAt time.Time `db:"latest_created_at"` + LastRunEndedAt *time.Time `db:"last_run_ended_at"` + AverageFailurePercent float64 `db:"average_failure_percent"` + AverageDurationMs *float64 `db:"average_duration_ms"` + CreatedByList []string `db:"created_by_list"` + RecentPhases []int32 `db:"-"` + + // Error counts from action_events table by error kind + UserErrorCount int64 `db:"user_error_count"` + SystemErrorCount int64 `db:"system_error_count"` + UnspecifiedErrorCount int64 `db:"unspecified_error_count"` +} + +type RecentAction struct { + TaskName string `db:"task_name"` + Phase int32 `db:"phase"` +} + +type TaskGroupNotificationPayload struct { + Org string + Project string + Domain string + TaskName string + EnvironmentName *string +} + +// Models the TaskVersion response +type TaskVersion struct { + Version string `db:"version"` + CreatedAt time.Time `db:"created_at"` +} diff --git a/runs/repository/models/task_spec.go b/runs/repository/models/task_spec.go new file mode 100644 index 0000000000..e51131fa34 --- /dev/null +++ b/runs/repository/models/task_spec.go @@ -0,0 +1,69 @@ +package models + +import ( + "context" + "time" + + "google.golang.org/protobuf/proto" + + "github.com/flyteorg/flyte/v2/flytestdlib/pbhash" + flyteWorkflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" +) + +var ( + Marshaller = proto.MarshalOptions{} +) + +// TaskSpec is the model for ALL action specs, including normal tasks, traces, conditional actions, etc. +type TaskSpec struct { + // Base64 encoded digest used as a unique identifier for the task spec + Digest string `gorm:"primaryKey" db:"digest"` + + // Base fields + CreatedAt time.Time `gorm:"not null;default:CURRENT_TIMESTAMP" db:"created_at"` + UpdatedAt time.Time `gorm:"not null;default:CURRENT_TIMESTAMP" db:"updated_at"` + + // Marshaled task spec + Spec []byte `gorm:"not null" db:"spec"` +} + +// TableName specifies the table name +func (TaskSpec) TableName() string { return "task_specs" } + +func NewTaskSpecModel(ctx context.Context, spec *flyteWorkflow.TaskSpec) (*TaskSpec, error) { + digest, err := pbhash.ComputeHashString(ctx, spec) + if err != nil { + return nil, err + } + + specBytes, err := Marshaller.Marshal(spec) + if err != nil { + return nil, err + } + + return &TaskSpec{ + Digest: digest, + Spec: specBytes, + }, nil +} + +func NewTaskSpecModelFromTraceSpec(ctx context.Context, traceSpec *flyteWorkflow.TraceSpec) (*TaskSpec, error) { + if traceSpec == nil { + return nil, nil + } + + digest, err := pbhash.ComputeHashString(ctx, traceSpec) + if err != nil { + return nil, err + } + + specBytes, err := Marshaller.Marshal(traceSpec) + if err != nil { + return nil, err + } + + return &TaskSpec{ + Digest: digest, + Spec: specBytes, + }, nil +} diff --git a/runs/repository/repository.go b/runs/repository/repository.go new file mode 100644 index 0000000000..b9eb67ee58 --- /dev/null +++ b/runs/repository/repository.go @@ -0,0 +1,32 @@ +package repository + +import ( + "gorm.io/gorm" + + "github.com/flyteorg/flyte/v2/runs/repository/impl" + "github.com/flyteorg/flyte/v2/runs/repository/interfaces" +) + +// repository implements the Repository interface +type repository struct { + actionRepo interfaces.ActionRepo + taskRepo interfaces.TaskRepo +} + +// NewRepository creates a new Repository instance +func NewRepository(db *gorm.DB) interfaces.Repository { + return &repository{ + actionRepo: impl.NewActionRepo(db), + taskRepo: impl.NewTaskRepo(db), + } +} + +// ActionRepo returns the action repository +func (r *repository) ActionRepo() interfaces.ActionRepo { + return r.actionRepo +} + +// TaskRepo returns the task repository +func (r *repository) TaskRepo() interfaces.TaskRepo { + return r.taskRepo +} diff --git a/runs/repository/transformers/task.go b/runs/repository/transformers/task.go new file mode 100644 index 0000000000..9f9d8fbe34 --- /dev/null +++ b/runs/repository/transformers/task.go @@ -0,0 +1,275 @@ +package transformers + +import ( + "context" + "database/sql" + "strings" + + "github.com/golang/protobuf/proto" + "google.golang.org/protobuf/types/known/timestamppb" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + "github.com/flyteorg/flyte/v2/runs/repository/models" +) + +// NewTaskKey creates a models.TaskKey from a task.TaskIdentifier +func ToTaskKey(taskId *task.TaskIdentifier) models.TaskKey { + return models.TaskKey{ + Org: taskId.GetOrg(), + Project: taskId.GetProject(), + Domain: taskId.GetDomain(), + Name: taskId.GetName(), + Version: taskId.GetVersion(), + } +} + +// ToTaskName creates a models.TaskName from a task.TaskName +func ToTaskName(taskName *task.TaskName) models.TaskName { + return models.TaskName{ + Org: taskName.GetOrg(), + Project: taskName.GetProject(), + Domain: taskName.GetDomain(), + Name: taskName.GetName(), + } +} + +func NewTaskModel(ctx context.Context, taskId *task.TaskIdentifier, spec *task.TaskSpec) (*models.Task, error) { + var deployedBy string + // TODO(nary): Get real identity subject after adding auth + deployedBy = "mock-subject" + // if subject, err := authorization.GetCallerIdentitySubject(ctx); err != nil { + // logger.Warnf(ctx, "Failed to get caller identity subject. Error: %v", err) + // } else { + // deployedBy = subject + // } + + specBytes, err := proto.Marshal(spec) + if err != nil { + return nil, err + } + + var environment string + var envDescription string + if env := spec.GetEnvironment(); env != nil { + environment = env.GetName() + envDescription = env.GetDescription() + } + var shortDescription string + if documentation := spec.GetDocumentation(); documentation != nil { + shortDescription = documentation.GetShortDescription() + } + + m := &models.Task{ + TaskKey: ToTaskKey(taskId), + Environment: environment, + FunctionName: ExtractFunctionName(ctx, taskId.GetName(), environment), + DeployedBy: deployedBy, + TaskSpec: specBytes, + EnvDescription: newNullString(envDescription), + ShortDescription: newNullString(shortDescription), + } + return m, nil +} + +func TaskModelsToTaskDetailsWithoutIdentity(ctx context.Context, taskModels []*models.Task) ([]*task.TaskDetails, error) { + // TODO(nary): Add identity enrichment after adding auth + return TaskModelsToTaskDetails(ctx, taskModels) +} + +// TaskModelsToTaskDetails transforms task database models to task.TaskDetails objects +func TaskModelsToTaskDetails(ctx context.Context, taskModels []*models.Task) ([]*task.TaskDetails, error) { + // TODO(nary): Add identity enrichment after adding auth + // subjectToIdentity, err := getEnrichedIdentities(ctx, taskModels, identityCache, enrichIdentities, enrichIdentitiesRemoteFallback) + // if err != nil { + // return nil, err + // } + + tasks := make([]*task.TaskDetails, 0, len(taskModels)) + for _, m := range taskModels { + taskIdl := &task.TaskDetails{ + TaskId: taskIdentifier(m), + Metadata: &task.TaskMetadata{ + // TODO(nary): We should either store ShortName or rename this to FunctionName in the future + ShortName: m.FunctionName, + EnvironmentName: m.Environment, + DeployedAt: timestamppb.New(m.CreatedAt), + TriggersSummary: taskTriggersSummaryFromModel(m), + }, + } + if m.ShortDescription.Valid { + taskIdl.Metadata.ShortDescription = m.ShortDescription.String + } + // TODO(nary): Add the deployed by identity if available after adding auth + // if identity, ok := subjectToIdentity[m.DeployedBy]; ok { + // taskIdl.Metadata.DeployedBy = identity + // } + + // Parse task spec if available + var spec task.TaskSpec + err := proto.Unmarshal(m.TaskSpec, &spec) + if err != nil { + logger.Errorf(ctx, "failed to unmarshal task spec for task %v: %v", m.TaskKey, err) + return nil, err + } + taskIdl.Spec = &spec + tasks = append(tasks, taskIdl) + } + return tasks, nil +} + +// TaskModelsToTasks uses the above TaskModelsToTaskDetails function to convert task models +// to task.TaskDetails objects, which are then simplified to task.Task objects. +func TaskModelsToTasks(ctx context.Context, taskModels []*models.Task, latestRuns map[models.TaskName]*models.Action) ([]*task.Task, error) { + // TODO(nary): Add identity enrichment after adding auth + // subjectToIdentity, err := getEnrichedIdentities(ctx, taskModels, identityCache, enrichIdentities, enrichIdentitiesRemoteFallback) + // if err != nil { + // return nil, err + // } + + tasks := make([]*task.Task, 0, len(taskModels)) + for _, m := range taskModels { + t := &task.Task{ + TaskId: taskIdentifier(m), + Metadata: &task.TaskMetadata{ + // TODO(nary): We should either store ShortName or rename this to FunctionName in the future + ShortName: m.FunctionName, + EnvironmentName: m.Environment, + DeployedAt: timestamppb.New(m.CreatedAt), + TriggersSummary: taskTriggersSummaryFromModel(m), + }, + TaskSummary: &task.TaskSummary{}, + } + if m.ShortDescription.Valid { + t.Metadata.ShortDescription = m.ShortDescription.String + } + // TODO(nary): Add the deployed by identity if available after adding auth + // if identity, ok := subjectToIdentity[m.DeployedBy]; ok { + // t.Metadata.DeployedBy = identity + // } + + // Add latest run if available + if latestRuns != nil { + taskName := models.TaskName{ + Org: m.Org, + Project: m.Project, + Domain: m.Domain, + Name: m.Name, + } + if latestRun, ok := latestRuns[taskName]; ok { + // TODO(nary): Implement ActionToLatestRunSummary after adding action transformers + _ = latestRun + // t.TaskSummary.LatestRun = ActionToLatestRunSummary(latestRun) + } + } + + tasks = append(tasks, t) + } + + return tasks, nil +} + +func taskTriggersSummaryFromModel(taskModel *models.Task) *task.TaskTriggersSummary { + if taskModel.TotalTriggers == 0 { + return nil + } + + // TODO(nary): Add back trigger automation spec unmarshaling after adding trigger support + if taskModel.TotalTriggers == 1 { + // automationSpec, err := UnmarshalAutomationSpec(taskModel.TriggerAutomationSpec, "") + // if err != nil { + // logger.Errorf(context.Background(), "failed to unmarshal trigger automation spec: %v", err) + // return nil + // } + + return &task.TaskTriggersSummary{ + Summary: &task.TaskTriggersSummary_Details{ + Details: &task.TaskTriggersSummary_TriggerDetails{ + Name: taskModel.TriggerName.String, + Active: taskModel.ActiveTriggers > 0, + // AutomationSpec: automationSpec, + }, + }, + } + } + return &task.TaskTriggersSummary{ + Summary: &task.TaskTriggersSummary_Stats{ + Stats: &task.TaskTriggersSummary_TriggerStats{ + Total: taskModel.TotalTriggers, + Active: taskModel.ActiveTriggers, + }, + }, + } +} + +// ExtractFunctionName extracts the function name from a task name. +// If environment is set, it strips the "environment." prefix from the task name. +// Otherwise, it falls back to taking the last segment after splitting on ".". +func ExtractFunctionName(ctx context.Context, taskName, environment string) string { + if environment != "" { + prefix := environment + "." + if functionName, ok := strings.CutPrefix(taskName, prefix); ok { + return functionName + } + logger.Warnf(ctx, "Task name '%s' does not start with environment prefix '%s', falling back to extracting last segment", taskName, prefix) + } + // Fallback: take the last segment after splitting on "." + segments := strings.Split(taskName, ".") + return segments[len(segments)-1] +} + +// VersionModelsToVersionResponses transforms version database models to task.ListVersionsResponse_VersionResponse objects. +func VersionModelsToVersionResponses(versionModels []*models.TaskVersion) []*task.ListVersionsResponse_VersionResponse { + versions := make([]*task.ListVersionsResponse_VersionResponse, 0, len(versionModels)) + for _, m := range versionModels { + versions = append(versions, &task.ListVersionsResponse_VersionResponse{ + Version: m.Version, + DeployedAt: timestamppb.New(m.CreatedAt), + }) + } + return versions +} + +// Helper function to create a task identifier from a task model +func taskIdentifier(m *models.Task) *task.TaskIdentifier { + return &task.TaskIdentifier{ + Org: m.Org, + Project: m.Project, + Domain: m.Domain, + Name: m.Name, + Version: m.Version, + } +} + +// TaskListResultToTasksAndMetadata transforms a TaskListResult into tasks and metadata. +// Returns nil tasks and metadata if the input is nil. +func TaskListResultToTasksAndMetadata(ctx context.Context, result *models.TaskListResult, + latestRuns map[models.TaskName]*models.Action, _ interface{}, _, _ bool) ([]*task.Task, *task.ListTasksResponse_ListTasksMetadata, error) { + + var taskModels []*models.Task + var metadata *task.ListTasksResponse_ListTasksMetadata + + if result != nil { + taskModels = result.Tasks + metadata = &task.ListTasksResponse_ListTasksMetadata{ + Total: result.Total, + FilteredTotal: result.FilteredTotal, + } + } + + // TODO(nary): Add identity enrichment after adding auth (last 3 params) + tasks, err := TaskModelsToTasks(ctx, taskModels, latestRuns) + if err != nil { + return nil, nil, err + } + + return tasks, metadata, nil +} + +// newNullString creates a sql.NullString from a string value +func newNullString(s string) sql.NullString { + if s == "" { + return sql.NullString{Valid: false} + } + return sql.NullString{String: s, Valid: true} +} diff --git a/runs/repository/transformers/task_spec.go b/runs/repository/transformers/task_spec.go new file mode 100644 index 0000000000..790c3bb7ad --- /dev/null +++ b/runs/repository/transformers/task_spec.go @@ -0,0 +1,26 @@ +package transformers + +import ( + "google.golang.org/protobuf/proto" + + flyteWorkflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + "github.com/flyteorg/flyte/v2/runs/repository/models" +) + +// ToTaskSpec converts TaskSpec model to proto TaskSpec +func ToTaskSpec(specModel *models.TaskSpec) (*flyteWorkflow.TaskSpec, error) { + spec := &flyteWorkflow.TaskSpec{} + if err := proto.Unmarshal(specModel.Spec, spec); err != nil { + return nil, err + } + return spec, nil +} + +// ToTraceSpec converts TaskSpec model to proto TraceSpec +func ToTraceSpec(specModel *models.TaskSpec) (*flyteWorkflow.TraceSpec, error) { + spec := &flyteWorkflow.TraceSpec{} + if err := proto.Unmarshal(specModel.Spec, spec); err != nil { + return nil, err + } + return spec, nil +} diff --git a/runs/repository/transformers/task_spec_test.go b/runs/repository/transformers/task_spec_test.go new file mode 100644 index 0000000000..6640abfa43 --- /dev/null +++ b/runs/repository/transformers/task_spec_test.go @@ -0,0 +1,102 @@ +package transformers + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "google.golang.org/protobuf/proto" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + flyteWorkflow "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + "github.com/flyteorg/flyte/v2/runs/repository/models" +) + +func TestToTaskSpec(t *testing.T) { + ctx := context.Background() + spec := &flyteWorkflow.TaskSpec{ + ShortName: "test-task", + Environment: &flyteWorkflow.Environment{ + Name: "prod", + Description: "Production environment", + }, + } + + specModel, err := models.NewTaskSpecModel(ctx, spec) + require.NoError(t, err) + + result, err := ToTaskSpec(specModel) + require.NoError(t, err) + assert.Equal(t, "test-task", result.ShortName) + assert.Equal(t, "prod", result.Environment.Name) +} + +func TestToTaskSpec_InvalidData(t *testing.T) { + specModel := &models.TaskSpec{ + Digest: "invalid", + Spec: []byte("invalid proto data"), + } + + _, err := ToTaskSpec(specModel) + assert.Error(t, err) +} + +func TestToTraceSpec(t *testing.T) { + ctx := context.Background() + traceSpec := &flyteWorkflow.TraceSpec{ + Interface: &core.TypedInterface{}, + } + + specModel, err := models.NewTaskSpecModelFromTraceSpec(ctx, traceSpec) + require.NoError(t, err) + + result, err := ToTraceSpec(specModel) + require.NoError(t, err) + assert.NotNil(t, result.Interface) +} + +func TestToTraceSpec_InvalidData(t *testing.T) { + specModel := &models.TaskSpec{ + Digest: "invalid", + Spec: []byte("invalid proto data"), + } + + _, err := ToTraceSpec(specModel) + assert.Error(t, err) +} + +func TestToTaskSpec_RoundTrip(t *testing.T) { + ctx := context.Background() + original := &flyteWorkflow.TaskSpec{ + ShortName: "my-task", + Environment: &flyteWorkflow.Environment{ + Name: "prod", + Description: "Production environment", + }, + Documentation: &flyteWorkflow.DocumentationEntity{ + ShortDescription: "Test task", + }, + } + + specModel, err := models.NewTaskSpecModel(ctx, original) + require.NoError(t, err) + + result, err := ToTaskSpec(specModel) + require.NoError(t, err) + assert.True(t, proto.Equal(original, result)) +} + +func TestToTraceSpec_RoundTrip(t *testing.T) { + ctx := context.Background() + original := &flyteWorkflow.TraceSpec{ + Interface: &core.TypedInterface{}, + } + + specModel, err := models.NewTaskSpecModelFromTraceSpec(ctx, original) + require.NoError(t, err) + + result, err := ToTraceSpec(specModel) + require.NoError(t, err) + assert.True(t, proto.Equal(original, result)) +} diff --git a/runs/repository/transformers/task_test.go b/runs/repository/transformers/task_test.go new file mode 100644 index 0000000000..b1b87c79f1 --- /dev/null +++ b/runs/repository/transformers/task_test.go @@ -0,0 +1,255 @@ +package transformers + +import ( + "context" + "database/sql" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "google.golang.org/protobuf/proto" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + "github.com/flyteorg/flyte/v2/runs/repository/models" +) + +func TestToTaskKey(t *testing.T) { + taskId := &task.TaskIdentifier{ + Org: "test-org", + Project: "test-project", + Domain: "test-domain", + Name: "test-task", + Version: "v1", + } + + key := ToTaskKey(taskId) + assert.Equal(t, "test-org", key.Org) + assert.Equal(t, "test-project", key.Project) + assert.Equal(t, "test-domain", key.Domain) + assert.Equal(t, "test-task", key.Name) + assert.Equal(t, "v1", key.Version) +} + +func TestToTaskName(t *testing.T) { + taskName := &task.TaskName{ + Org: "test-org", + Project: "test-project", + Domain: "test-domain", + Name: "test-task", + } + + name := ToTaskName(taskName) + assert.Equal(t, "test-org", name.Org) + assert.Equal(t, "test-project", name.Project) + assert.Equal(t, "test-domain", name.Domain) + assert.Equal(t, "test-task", name.Name) +} + +func TestNewTaskModel(t *testing.T) { + ctx := context.Background() + taskId := &task.TaskIdentifier{ + Org: "test-org", + Project: "test-project", + Domain: "test-domain", + Name: "prod.my_function", + Version: "v1", + } + spec := &task.TaskSpec{ + Environment: &task.Environment{ + Name: "prod", + Description: "Production environment", + }, + Documentation: &task.DocumentationEntity{ + ShortDescription: "A test task", + }, + } + + model, err := NewTaskModel(ctx, taskId, spec) + require.NoError(t, err) + assert.Equal(t, "test-org", model.Org) + assert.Equal(t, "prod", model.Environment) + assert.Equal(t, "my_function", model.FunctionName) + assert.Equal(t, "mock-subject", model.DeployedBy) + assert.True(t, model.EnvDescription.Valid) + assert.Equal(t, "Production environment", model.EnvDescription.String) + assert.True(t, model.ShortDescription.Valid) + assert.Equal(t, "A test task", model.ShortDescription.String) +} + +func TestExtractFunctionName_WithEnvironment(t *testing.T) { + ctx := context.Background() + functionName := ExtractFunctionName(ctx, "prod.my_function", "prod") + assert.Equal(t, "my_function", functionName) +} + +func TestExtractFunctionName_WithoutEnvironment(t *testing.T) { + ctx := context.Background() + functionName := ExtractFunctionName(ctx, "my.nested.function", "") + assert.Equal(t, "function", functionName) +} + +func TestExtractFunctionName_Fallback(t *testing.T) { + ctx := context.Background() + functionName := ExtractFunctionName(ctx, "prod.my_function", "staging") + assert.Equal(t, "my_function", functionName) +} + +func TestTaskModelsToTaskDetails(t *testing.T) { + ctx := context.Background() + spec := &task.TaskSpec{ + Environment: &task.Environment{ + Name: "prod", + }, + } + specBytes, _ := proto.Marshal(spec) + + taskModels := []*models.Task{ + { + TaskKey: models.TaskKey{ + Org: "org1", + Project: "proj1", + Domain: "domain1", + Name: "task1", + Version: "v1", + }, + Environment: "prod", + FunctionName: "my_func", + DeployedBy: "user@example.com", + TaskSpec: specBytes, + CreatedAt: time.Now(), + ShortDescription: sql.NullString{String: "Test task", Valid: true}, + }, + } + + details, err := TaskModelsToTaskDetails(ctx, taskModels) + require.NoError(t, err) + require.Len(t, details, 1) + assert.Equal(t, "org1", details[0].TaskId.Org) + assert.Equal(t, "my_func", details[0].Metadata.ShortName) + assert.Equal(t, "prod", details[0].Metadata.EnvironmentName) + assert.Equal(t, "Test task", details[0].Metadata.ShortDescription) + assert.NotNil(t, details[0].Spec) +} + +func TestTaskModelsToTasks(t *testing.T) { + ctx := context.Background() + taskModels := []*models.Task{ + { + TaskKey: models.TaskKey{ + Org: "org1", + Project: "proj1", + Domain: "domain1", + Name: "task1", + Version: "v1", + }, + Environment: "prod", + FunctionName: "my_func", + CreatedAt: time.Now(), + }, + } + + tasks, err := TaskModelsToTasks(ctx, taskModels, nil) + require.NoError(t, err) + require.Len(t, tasks, 1) + assert.Equal(t, "org1", tasks[0].TaskId.Org) + assert.Equal(t, "my_func", tasks[0].Metadata.ShortName) + assert.NotNil(t, tasks[0].TaskSummary) +} + +func TestTaskTriggersSummaryFromModel_NoTriggers(t *testing.T) { + taskModel := &models.Task{ + TotalTriggers: 0, + } + + summary := taskTriggersSummaryFromModel(taskModel) + assert.Nil(t, summary) +} + +func TestTaskTriggersSummaryFromModel_SingleTrigger(t *testing.T) { + taskModel := &models.Task{ + TotalTriggers: 1, + ActiveTriggers: 1, + TriggerName: sql.NullString{String: "my-trigger", Valid: true}, + } + + summary := taskTriggersSummaryFromModel(taskModel) + require.NotNil(t, summary) + details := summary.GetDetails() + require.NotNil(t, details) + assert.Equal(t, "my-trigger", details.Name) + assert.True(t, details.Active) +} + +func TestTaskTriggersSummaryFromModel_MultipleTriggers(t *testing.T) { + taskModel := &models.Task{ + TotalTriggers: 5, + ActiveTriggers: 3, + } + + summary := taskTriggersSummaryFromModel(taskModel) + require.NotNil(t, summary) + stats := summary.GetStats() + require.NotNil(t, stats) + assert.Equal(t, uint32(5), stats.Total) + assert.Equal(t, uint32(3), stats.Active) +} + +func TestVersionModelsToVersionResponses(t *testing.T) { + now := time.Now() + versionModels := []*models.TaskVersion{ + { + Version: "v1", + CreatedAt: now, + }, + { + Version: "v2", + CreatedAt: now.Add(time.Hour), + }, + } + + responses := VersionModelsToVersionResponses(versionModels) + require.Len(t, responses, 2) + assert.Equal(t, "v1", responses[0].Version) + assert.Equal(t, "v2", responses[1].Version) + assert.NotNil(t, responses[0].DeployedAt) + assert.NotNil(t, responses[1].DeployedAt) +} + +func TestNewNullString(t *testing.T) { + validStr := newNullString("test") + assert.True(t, validStr.Valid) + assert.Equal(t, "test", validStr.String) + + invalidStr := newNullString("") + assert.False(t, invalidStr.Valid) +} + +func TestTaskListResultToTasksAndMetadata(t *testing.T) { + ctx := context.Background() + result := &models.TaskListResult{ + Tasks: []*models.Task{ + { + TaskKey: models.TaskKey{ + Org: "org1", + Project: "proj1", + Domain: "domain1", + Name: "task1", + Version: "v1", + }, + FunctionName: "func1", + CreatedAt: time.Now(), + }, + }, + Total: 10, + FilteredTotal: 1, + } + + tasks, metadata, err := TaskListResultToTasksAndMetadata(ctx, result, nil, nil, false, false) + require.NoError(t, err) + require.Len(t, tasks, 1) + assert.Equal(t, "func1", tasks[0].Metadata.ShortName) + require.NotNil(t, metadata) + assert.Equal(t, uint32(10), metadata.Total) + assert.Equal(t, uint32(1), metadata.FilteredTotal) +} diff --git a/runs/service/run_service.go b/runs/service/run_service.go new file mode 100644 index 0000000000..b5945cebba --- /dev/null +++ b/runs/service/run_service.go @@ -0,0 +1,721 @@ +package service + +import ( + "context" + + "connectrpc.com/connect" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow/workflowconnect" + "github.com/flyteorg/flyte/v2/runs/repository/interfaces" + "github.com/flyteorg/flyte/v2/runs/repository/models" +) + +// RunService implements the RunServiceHandler interface +type RunService struct { + repo interfaces.Repository + queueClient workflowconnect.QueueServiceClient +} + +func (s *RunService) WatchGroups(ctx context.Context, c *connect.Request[workflow.WatchGroupsRequest], c2 *connect.ServerStream[workflow.WatchGroupsResponse]) error { + //TODO implement me + panic("implement me") +} + +// NewRunService creates a new RunService instance +func NewRunService(repo interfaces.Repository, queueClient workflowconnect.QueueServiceClient) *RunService { + return &RunService{ + repo: repo, + queueClient: queueClient, + } +} + +// Ensure we implement the interface +var _ workflowconnect.RunServiceHandler = (*RunService)(nil) + +// CreateRun creates a new run +func (s *RunService) CreateRun( + ctx context.Context, + req *connect.Request[workflow.CreateRunRequest], +) (*connect.Response[workflow.CreateRunResponse], error) { + logger.Infof(ctx, "Received CreateRun request") + + // Validate request + if err := req.Msg.Validate(); err != nil { + logger.Errorf(ctx, "Invalid CreateRun request: %v", err) + return nil, connect.NewError(connect.CodeInvalidArgument, err) + } + + // Create run in database + run, err := s.repo.ActionRepo().CreateRun(ctx, req.Msg) + if err != nil { + logger.Errorf(ctx, "Failed to create run: %v", err) + return nil, connect.NewError(connect.CodeInternal, err) + } + + // Enqueue the root action to the queue service + actionID := &common.ActionIdentifier{ + Run: &common.RunIdentifier{ + Org: run.Org, + Project: run.Project, + Domain: run.Domain, + Name: run.Name, + }, + Name: run.Name, // For root actions, action name = run name + } + + // Build EnqueueActionRequest from CreateRunRequest + enqueueReq := &workflow.EnqueueActionRequest{ + ActionId: actionID, + RunSpec: req.Msg.RunSpec, + InputUri: buildInputURI(run), + RunOutputBase: buildRunOutputBase(run), + } + + // Set the spec based on the task type in CreateRunRequest + switch taskSpec := req.Msg.Task.(type) { + case *workflow.CreateRunRequest_TaskSpec: + enqueueReq.Spec = &workflow.EnqueueActionRequest_Task{ + Task: &workflow.TaskAction{ + Spec: taskSpec.TaskSpec, + }, + } + case *workflow.CreateRunRequest_TaskId: + enqueueReq.Spec = &workflow.EnqueueActionRequest_Task{ + Task: &workflow.TaskAction{ + Id: taskSpec.TaskId, + }, + } + } + + // Call queue service to enqueue the root action + _, err = s.queueClient.EnqueueAction(ctx, connect.NewRequest(enqueueReq)) + if err != nil { + logger.Errorf(ctx, "Failed to enqueue root action: %v", err) + // Note: We don't fail the CreateRun if enqueue fails - the run is already created + // In production, you might want to mark the run as failed or retry the enqueue + logger.Warnf(ctx, "Run %s created but failed to enqueue root action", run.Name) + } else { + logger.Infof(ctx, "Successfully enqueued root action for run %s", run.Name) + } + + // Build response (simplified - you'd convert the full Run model) + resp := &workflow.CreateRunResponse{ + Run: &workflow.Run{ + Action: &workflow.Action{ + Id: actionID, + }, + }, + } + + return connect.NewResponse(resp), nil +} + +// AbortRun aborts a run +func (s *RunService) AbortRun( + ctx context.Context, + req *connect.Request[workflow.AbortRunRequest], +) (*connect.Response[workflow.AbortRunResponse], error) { + logger.Infof(ctx, "Received AbortRun request for run: %s/%s/%s/%s", + req.Msg.RunId.Org, req.Msg.RunId.Project, req.Msg.RunId.Domain, req.Msg.RunId.Name) + + // Validate request + if err := req.Msg.Validate(); err != nil { + return nil, connect.NewError(connect.CodeInvalidArgument, err) + } + + reason := "User requested abort" + if req.Msg.Reason != nil { + reason = *req.Msg.Reason + } + + // Abort in database + if err := s.repo.ActionRepo().AbortRun(ctx, req.Msg.RunId, reason, nil); err != nil { + logger.Errorf(ctx, "Failed to abort run: %v", err) + return nil, connect.NewError(connect.CodeInternal, err) + } + + return connect.NewResponse(&workflow.AbortRunResponse{}), nil +} + +// GetRunDetails gets detailed information about a run +func (s *RunService) GetRunDetails( + ctx context.Context, + req *connect.Request[workflow.GetRunDetailsRequest], +) (*connect.Response[workflow.GetRunDetailsResponse], error) { + logger.Infof(ctx, "Received GetRunDetails request") + + // Validate request + if err := req.Msg.Validate(); err != nil { + return nil, connect.NewError(connect.CodeInvalidArgument, err) + } + + // Get run from database + run, err := s.repo.ActionRepo().GetRun(ctx, req.Msg.RunId) + if err != nil { + logger.Errorf(ctx, "Failed to get run: %v", err) + return nil, connect.NewError(connect.CodeNotFound, err) + } + + // TODO: Build full RunDetails from the run model + // For now, return a minimal response + resp := &workflow.GetRunDetailsResponse{ + Details: &workflow.RunDetails{ + // Would populate this from run model + }, + } + + logger.Infof(ctx, "Retrieved run details for: %s", run.Name) + return connect.NewResponse(resp), nil +} + +// GetActionDetails gets detailed information about an action +func (s *RunService) GetActionDetails( + ctx context.Context, + req *connect.Request[workflow.GetActionDetailsRequest], +) (*connect.Response[workflow.GetActionDetailsResponse], error) { + logger.Infof(ctx, "Received GetActionDetails request") + + // Validate request + if err := req.Msg.Validate(); err != nil { + return nil, connect.NewError(connect.CodeInvalidArgument, err) + } + + // Get action from database + action, err := s.repo.ActionRepo().GetAction(ctx, req.Msg.ActionId) + if err != nil { + logger.Errorf(ctx, "Failed to get action: %v", err) + return nil, connect.NewError(connect.CodeNotFound, err) + } + + // TODO: Build full ActionDetails from the action model + resp := &workflow.GetActionDetailsResponse{ + Details: &workflow.ActionDetails{ + // Would populate this from action model + }, + } + + logger.Infof(ctx, "Retrieved action details for: %s", action.Name) + return connect.NewResponse(resp), nil +} + +// GetActionData gets input and output data for an action +func (s *RunService) GetActionData( + ctx context.Context, + req *connect.Request[workflow.GetActionDataRequest], +) (*connect.Response[workflow.GetActionDataResponse], error) { + logger.Infof(ctx, "Received GetActionData request") + + // Validate request + if err := req.Msg.Validate(); err != nil { + return nil, connect.NewError(connect.CodeInvalidArgument, err) + } + + // Get action from database + action, err := s.repo.ActionRepo().GetAction(ctx, req.Msg.ActionId) + if err != nil { + logger.Errorf(ctx, "Failed to get action: %v", err) + return nil, connect.NewError(connect.CodeNotFound, err) + } + + // Return URIs only (not actual data) + resp := &workflow.GetActionDataResponse{ + Inputs: &task.Inputs{}, // Would populate from action.InputURI + Outputs: &task.Outputs{}, // Would populate from outputs + } + + logger.Infof(ctx, "Retrieved action data for: %s", action.Name) + return connect.NewResponse(resp), nil +} + +// ListRuns lists runs based on filter criteria +func (s *RunService) ListRuns( + ctx context.Context, + req *connect.Request[workflow.ListRunsRequest], +) (*connect.Response[workflow.ListRunsResponse], error) { + logger.Infof(ctx, "Received ListRuns request") + + // Validate request + if err := req.Msg.Validate(); err != nil { + return nil, connect.NewError(connect.CodeInvalidArgument, err) + } + + // List runs from database + runs, nextToken, err := s.repo.ActionRepo().ListRuns(ctx, req.Msg) + if err != nil { + logger.Errorf(ctx, "Failed to list runs: %v", err) + return nil, connect.NewError(connect.CodeInternal, err) + } + + // Convert to proto format + protoRuns := make([]*workflow.Run, len(runs)) + for i, run := range runs { + protoRuns[i] = &workflow.Run{ + Action: &workflow.Action{ + Id: &common.ActionIdentifier{ + Run: &common.RunIdentifier{ + Org: run.Org, + Project: run.Project, + Domain: run.Domain, + Name: run.Name, + }, + Name: run.Name, // For root actions, action name = run name + }, + }, + } + } + + resp := &workflow.ListRunsResponse{ + Runs: protoRuns, + Token: nextToken, + } + + logger.Infof(ctx, "Listed %d runs", len(runs)) + return connect.NewResponse(resp), nil +} + +// ListActions lists actions for a run +func (s *RunService) ListActions( + ctx context.Context, + req *connect.Request[workflow.ListActionsRequest], +) (*connect.Response[workflow.ListActionsResponse], error) { + logger.Infof(ctx, "Received ListActions request") + + // Validate request + if err := req.Msg.Validate(); err != nil { + return nil, connect.NewError(connect.CodeInvalidArgument, err) + } + + // List actions from database + limit := 50 + if req.Msg.Request != nil && req.Msg.Request.Limit > 0 { + limit = int(req.Msg.Request.Limit) + } + + actions, nextToken, err := s.repo.ActionRepo().ListActions(ctx, req.Msg.RunId, limit, "") + if err != nil { + logger.Errorf(ctx, "Failed to list actions: %v", err) + return nil, connect.NewError(connect.CodeInternal, err) + } + + // Convert to proto format (simplified) + protoActions := make([]*workflow.Action, len(actions)) + for i, action := range actions { + protoActions[i] = &workflow.Action{ + Id: &common.ActionIdentifier{ + Run: &common.RunIdentifier{ + Org: action.Org, + Project: action.Project, + Domain: action.Domain, + Name: action.GetRunName(), + }, + Name: action.Name, + }, + } + } + + resp := &workflow.ListActionsResponse{ + Actions: protoActions, + Token: nextToken, + } + + logger.Infof(ctx, "Listed %d actions", len(actions)) + return connect.NewResponse(resp), nil +} + +// AbortAction aborts a specific action +func (s *RunService) AbortAction( + ctx context.Context, + req *connect.Request[workflow.AbortActionRequest], +) (*connect.Response[workflow.AbortActionResponse], error) { + logger.Infof(ctx, "Received AbortAction request") + + // Validate request + if err := req.Msg.Validate(); err != nil { + return nil, connect.NewError(connect.CodeInvalidArgument, err) + } + + reason := "User requested abort" + if req.Msg.Reason != "" { + reason = req.Msg.Reason + } + + // Abort in database + if err := s.repo.ActionRepo().AbortAction(ctx, req.Msg.ActionId, reason, nil); err != nil { + logger.Errorf(ctx, "Failed to abort action: %v", err) + return nil, connect.NewError(connect.CodeInternal, err) + } + + return connect.NewResponse(&workflow.AbortActionResponse{}), nil +} + +// Streaming RPCs (simplified implementations) + +// WatchRunDetails streams run details updates +func (s *RunService) WatchRunDetails( + ctx context.Context, + req *connect.Request[workflow.WatchRunDetailsRequest], + stream *connect.ServerStream[workflow.WatchRunDetailsResponse], +) error { + logger.Infof(ctx, "Received WatchRunDetails request") + + // For now, just send initial state and close + // TODO: Implement actual streaming with polling or database triggers + run, err := s.repo.ActionRepo().GetRun(ctx, req.Msg.RunId) + if err != nil { + return connect.NewError(connect.CodeNotFound, err) + } + + resp := &workflow.WatchRunDetailsResponse{ + Details: &workflow.RunDetails{ + // Would populate from run model + }, + } + + if err := stream.Send(resp); err != nil { + return err + } + + logger.Infof(ctx, "Sent initial run details for: %s", run.Name) + + // Keep connection open and send updates (simplified) + updates := make(chan *models.Run) + errs := make(chan error) + + go s.repo.ActionRepo().WatchRunUpdates(ctx, req.Msg.RunId, updates, errs) + + for { + select { + case <-ctx.Done(): + return nil + case err := <-errs: + return connect.NewError(connect.CodeInternal, err) + case run := <-updates: + resp := &workflow.WatchRunDetailsResponse{ + Details: &workflow.RunDetails{ + // Would populate from run + }, + } + if err := stream.Send(resp); err != nil { + return err + } + logger.Infof(ctx, "Sent run update for: %s", run.Name) + } + } +} + +// WatchActionDetails streams action details updates +func (s *RunService) WatchActionDetails( + ctx context.Context, + req *connect.Request[workflow.WatchActionDetailsRequest], + stream *connect.ServerStream[workflow.WatchActionDetailsResponse], +) error { + logger.Infof(ctx, "Received WatchActionDetails request") + + // Send initial state + action, err := s.repo.ActionRepo().GetAction(ctx, req.Msg.ActionId) + if err != nil { + return connect.NewError(connect.CodeNotFound, err) + } + + resp := &workflow.WatchActionDetailsResponse{ + Details: &workflow.ActionDetails{ + // Would populate from action model + }, + } + + if err := stream.Send(resp); err != nil { + return err + } + + logger.Infof(ctx, "Sent initial action details for: %s", action.Name) + + // TODO: Implement actual streaming + <-ctx.Done() + return nil +} + +// WatchRuns streams run updates based on filter criteria +func (s *RunService) WatchRuns( + ctx context.Context, + req *connect.Request[workflow.WatchRunsRequest], + stream *connect.ServerStream[workflow.WatchRunsResponse], +) error { + logger.Infof(ctx, "Received WatchRuns request") + + // Step 1: Send existing runs that match filter + listReq := s.convertWatchRequestToListRequest(req.Msg) + + runs, _, err := s.repo.ActionRepo().ListRuns(ctx, listReq) + if err != nil { + logger.Errorf(ctx, "Failed to list runs: %v", err) + // Continue even if list fails - still watch for new updates + } else if len(runs) > 0 { + // Send existing runs + protoRuns := make([]*workflow.Run, len(runs)) + for i, run := range runs { + protoRuns[i] = s.convertRunToProto(run) + } + + if err := stream.Send(&workflow.WatchRunsResponse{ + Runs: protoRuns, + }); err != nil { + return err + } + } + + // Step 2: Watch for run updates using repository notifications + // Create channels for receiving updates + updatesCh := make(chan *models.Run, 10) + errsCh := make(chan error, 1) + + // Start watching for updates in a goroutine + go s.repo.ActionRepo().WatchAllRunUpdates(ctx, updatesCh, errsCh) + + for { + select { + case <-ctx.Done(): + return nil + + case err := <-errsCh: + logger.Errorf(ctx, "Error watching runs: %v", err) + return err + + case run := <-updatesCh: + // Filter the run based on the watch request criteria + if !s.runMatchesFilter(run, req.Msg) { + continue + } + + // Convert and send the updated run + protoRun := s.convertRunToProto(run) + if err := stream.Send(&workflow.WatchRunsResponse{ + Runs: []*workflow.Run{protoRun}, + }); err != nil { + return err + } + } + } +} + +// WatchActions streams action updates for a run +func (s *RunService) WatchActions( + ctx context.Context, + req *connect.Request[workflow.WatchActionsRequest], + stream *connect.ServerStream[workflow.WatchActionsResponse], +) error { + logger.Infof(ctx, "Received WatchActions request for run: %s", req.Msg.RunId.Name) + + // Step 1: Send existing actions for this run + actions, _, err := s.repo.ActionRepo().ListActions(ctx, req.Msg.RunId, 100, "") + if err != nil { + logger.Errorf(ctx, "Failed to list actions: %v", err) + // Continue even if list fails - still watch for new updates + } else if len(actions) > 0 { + // Send existing actions + enrichedActions := make([]*workflow.EnrichedAction, len(actions)) + for i, action := range actions { + enrichedActions[i] = s.convertActionToEnrichedProto(action) + } + + if err := stream.Send(&workflow.WatchActionsResponse{ + EnrichedActions: enrichedActions, + }); err != nil { + return err + } + } + + // Step 2: Watch for action updates using repository notifications + // Create channels for receiving updates + updatesCh := make(chan *models.Action, 10) + errsCh := make(chan error, 1) + + // Start watching for updates in a goroutine + go s.repo.ActionRepo().WatchActionUpdates(ctx, req.Msg.RunId, updatesCh, errsCh) + + for { + select { + case <-ctx.Done(): + return nil + + case err := <-errsCh: + logger.Errorf(ctx, "Error watching actions: %v", err) + return err + + case action := <-updatesCh: + // Convert and send the updated action + enrichedAction := s.convertActionToEnrichedProto(action) + if err := stream.Send(&workflow.WatchActionsResponse{ + EnrichedActions: []*workflow.EnrichedAction{enrichedAction}, + }); err != nil { + return err + } + } + } +} + +// WatchClusterEvents streams cluster events for an action attempt +func (s *RunService) WatchClusterEvents( + ctx context.Context, + req *connect.Request[workflow.WatchClusterEventsRequest], + stream *connect.ServerStream[workflow.WatchClusterEventsResponse], +) error { + logger.Infof(ctx, "Received WatchClusterEvents request") + + // TODO: Implement cluster events watching + // Cluster events are now stored in ActionDetails JSON + // Need to: + // 1. Get action using s.repo.ActionRepo().GetAction(ctx, req.Msg.Id) + // 2. Unmarshal action.ActionDetails to extract cluster events for the specified attempt + // 3. Send existing events and watch for updates + + <-ctx.Done() + return nil +} + +// Helper functions + +// buildInputURI generates the input URI for the root action +func buildInputURI(run *models.Run) string { + // TODO: In production, this should be a real storage path (e.g., s3://bucket/inputs/org/project/domain/run) + return "" +} + +// buildRunOutputBase generates the output base path for the run +func buildRunOutputBase(run *models.Run) string { + // TODO: In production, this should be a real storage path (e.g., s3://bucket/outputs/org/project/domain/run) + return "" +} + +// convertRunToProto converts a repository Run to a proto Run +func (s *RunService) convertRunToProto(run *models.Run) *workflow.Run { + if run == nil { + return nil + } + + // Build the action identifier from the run + runID := &common.RunIdentifier{ + Org: run.Org, + Project: run.Project, + Domain: run.Domain, + Name: run.Name, + } + + // Create the root action with status + action := &workflow.Action{ + Id: &common.ActionIdentifier{ + Run: runID, + Name: run.Name, // For root actions, action name = run name + }, + Metadata: &workflow.ActionMetadata{ + // TODO: Extract from ActionSpec JSON if needed + }, + Status: &workflow.ActionStatus{ + Phase: common.ActionPhase(common.ActionPhase_value[run.Phase]), + // TODO: Extract timestamps, error, etc. from ActionDetails JSON + }, + } + + return &workflow.Run{ + Action: action, + } +} + +// convertActionToEnrichedProto converts a repository Action to an EnrichedAction proto +func (s *RunService) convertActionToEnrichedProto(action *models.Action) *workflow.EnrichedAction { + if action == nil { + return nil + } + + // Build the action identifier + actionID := &common.ActionIdentifier{ + Run: &common.RunIdentifier{ + Org: action.Org, + Project: action.Project, + Domain: action.Domain, + Name: action.GetRunName(), + }, + Name: action.Name, + } + + // Build the action status + actionStatus := &workflow.ActionStatus{ + Phase: common.ActionPhase(common.ActionPhase_value[action.Phase]), + } + + // Build the action proto + actionProto := &workflow.Action{ + Id: actionID, + Status: actionStatus, + } + + return &workflow.EnrichedAction{ + Action: actionProto, + MeetsFilter: true, // For now, all actions meet the filter + } +} + +// convertWatchRequestToListRequest converts a WatchRunsRequest to a ListRunsRequest +func (s *RunService) convertWatchRequestToListRequest(req *workflow.WatchRunsRequest) *workflow.ListRunsRequest { + listReq := &workflow.ListRunsRequest{ + Request: &common.ListRequest{ + Limit: 100, + }, + } + + // Convert the target filter to the appropriate ListRuns scope + switch target := req.Target.(type) { + case *workflow.WatchRunsRequest_Org: + listReq.ScopeBy = &workflow.ListRunsRequest_Org{ + Org: target.Org, + } + case *workflow.WatchRunsRequest_ClusterId: + // Cluster filtering not directly supported in ListRuns, will filter client-side + // Could be added to ListRuns if needed + case *workflow.WatchRunsRequest_ProjectId: + listReq.ScopeBy = &workflow.ListRunsRequest_ProjectId{ + ProjectId: target.ProjectId, + } + case *workflow.WatchRunsRequest_TaskId: + // Task filtering not directly supported in ListRuns, will filter client-side + // Could be added to ListRuns if needed + } + + return listReq +} + +// runMatchesFilter checks if a run matches the WatchRunsRequest filter criteria +func (s *RunService) runMatchesFilter(run *models.Run, req *workflow.WatchRunsRequest) bool { + if req.Target == nil { + // No filter, all runs match + return true + } + + switch target := req.Target.(type) { + case *workflow.WatchRunsRequest_Org: + return run.Org == target.Org + + case *workflow.WatchRunsRequest_ClusterId: + // TODO: Add cluster field to Run model if needed + // For now, accept all runs + return true + + case *workflow.WatchRunsRequest_ProjectId: + return run.Org == target.ProjectId.Organization && + run.Project == target.ProjectId.Name && + run.Domain == target.ProjectId.Domain + + case *workflow.WatchRunsRequest_TaskId: + // TODO: Need to check if the run was triggered by this task + // This would require storing task_id in the Run model or querying actions + // For now, accept all runs + return true + + default: + // Unknown filter, accept all runs + return true + } +} diff --git a/runs/service/state_service.go b/runs/service/state_service.go new file mode 100644 index 0000000000..dcf1898112 --- /dev/null +++ b/runs/service/state_service.go @@ -0,0 +1,326 @@ +package service + +import ( + "context" + "encoding/json" + "fmt" + + "connectrpc.com/connect" + "google.golang.org/genproto/googleapis/rpc/status" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + "github.com/flyteorg/flyte/v2/runs/repository/interfaces" + "github.com/flyteorg/flyte/v2/runs/repository/models" +) + +// StateService implements the StateService gRPC API +type StateService struct { + repo interfaces.Repository +} + +// NewStateService creates a new StateService +func NewStateService(repo interfaces.Repository) *StateService { + return &StateService{ + repo: repo, + } +} + +// Put handles the unary Put RPC +// Client sends a single PutRequest, server responds with PutResponse +func (s *StateService) Put(ctx context.Context, req *connect.Request[workflow.PutRequest]) (*connect.Response[workflow.PutResponse], error) { + logger.Infof(ctx, "StateService.Put called") + + msg := req.Msg + + // Validate request + if msg.ActionId == nil { + return connect.NewResponse(&workflow.PutResponse{ + ActionId: msg.ActionId, + Status: &status.Status{ + Code: int32(connect.CodeInvalidArgument), + Message: "action_id is required", + }, + }), nil + } + + if msg.State == "" { + return connect.NewResponse(&workflow.PutResponse{ + ActionId: msg.ActionId, + Status: &status.Status{ + Code: int32(connect.CodeInvalidArgument), + Message: "state is required", + }, + }), nil + } + + // Validate that state is valid JSON + var stateObj map[string]interface{} + if err := json.Unmarshal([]byte(msg.State), &stateObj); err != nil { + return connect.NewResponse(&workflow.PutResponse{ + ActionId: msg.ActionId, + Status: &status.Status{ + Code: int32(connect.CodeInvalidArgument), + Message: fmt.Sprintf("state must be valid JSON: %v", err), + }, + }), nil + } + + // Update action state in database + if err := s.repo.ActionRepo().UpdateActionState(ctx, msg.ActionId, msg.State); err != nil { + logger.Warnf(ctx, "Failed to update action state: %v", err) + return connect.NewResponse(&workflow.PutResponse{ + ActionId: msg.ActionId, + Status: &status.Status{ + Code: int32(connect.CodeInternal), + Message: fmt.Sprintf("failed to update state: %v", err), + }, + }), nil + } + + // Send notification + if err := s.repo.ActionRepo().NotifyStateUpdate(ctx, msg.ActionId); err != nil { + logger.Warnf(ctx, "Failed to send state update notification: %v", err) + // Continue anyway - the update was saved + } + + logger.Infof(ctx, "Updated state for action: %s/%s/%s/%s/%s", + msg.ActionId.Run.Org, msg.ActionId.Run.Project, msg.ActionId.Run.Domain, + msg.ActionId.Run.Name, msg.ActionId.Name) + + // Return success response + return connect.NewResponse(&workflow.PutResponse{ + ActionId: msg.ActionId, + Status: &status.Status{ + Code: 0, // OK + Message: "state updated successfully", + }, + }), nil +} + +// Get handles the unary Get RPC +// Client sends a single GetRequest, server responds with GetResponse +func (s *StateService) Get(ctx context.Context, req *connect.Request[workflow.GetRequest]) (*connect.Response[workflow.GetResponse], error) { + logger.Infof(ctx, "StateService.Get called") + + msg := req.Msg + + // Validate request + if msg.ActionId == nil { + return connect.NewResponse(&workflow.GetResponse{ + ActionId: msg.ActionId, + Status: &status.Status{ + Code: int32(connect.CodeInvalidArgument), + Message: "action_id is required", + }, + State: "", + }), nil + } + + // Get action state from database + state, err := s.repo.ActionRepo().GetActionState(ctx, msg.ActionId) + if err != nil { + logger.Warnf(ctx, "Failed to get action state: %v", err) + return connect.NewResponse(&workflow.GetResponse{ + ActionId: msg.ActionId, + Status: &status.Status{ + Code: int32(connect.CodeNotFound), + Message: fmt.Sprintf("failed to get state: %v", err), + }, + State: "", + }), nil + } + + logger.Infof(ctx, "Retrieved state for action: %s/%s/%s/%s/%s", + msg.ActionId.Run.Org, msg.ActionId.Run.Project, msg.ActionId.Run.Domain, + msg.ActionId.Run.Name, msg.ActionId.Name) + + // Return success response + return connect.NewResponse(&workflow.GetResponse{ + ActionId: msg.ActionId, + Status: &status.Status{ + Code: 0, // OK + Message: "state retrieved successfully", + }, + State: state, + }), nil +} + +// Watch handles the server-side streaming Watch RPC +// Streams ActionUpdate messages for actions matching the filter +func (s *StateService) Watch(ctx context.Context, req *connect.Request[workflow.WatchRequest], stream *connect.ServerStream[workflow.WatchResponse]) error { + logger.Infof(ctx, "StateService.Watch stream started") + + // Get parent action ID from filter + var parentActionID *common.ActionIdentifier + switch filter := req.Msg.Filter.(type) { + case *workflow.WatchRequest_ParentActionId: + parentActionID = filter.ParentActionId + default: + return connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("filter is required")) + } + + if parentActionID == nil { + return connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("parent_action_id is required")) + } + + // Get all child actions for the parent + childActions, err := s.getChildActions(ctx, parentActionID) + if err != nil { + return connect.NewError(connect.CodeInternal, fmt.Errorf("failed to get child actions: %w", err)) + } + + // Send current state of all actions + for _, action := range childActions { + actionUpdate := s.actionToUpdate(action) + resp := &workflow.WatchResponse{ + Message: &workflow.WatchResponse_ActionUpdate{ + ActionUpdate: actionUpdate, + }, + } + + if err := stream.Send(resp); err != nil { + return err + } + } + + // Send sentinel message to indicate end of initial state + sentinelResp := &workflow.WatchResponse{ + Message: &workflow.WatchResponse_ControlMessage{ + ControlMessage: &workflow.ControlMessage{ + Sentinel: true, + }, + }, + } + if err := stream.Send(sentinelResp); err != nil { + return err + } + + logger.Infof(ctx, "Sent initial state (%d actions) and sentinel for parent action: %s", len(childActions), parentActionID.Name) + + // Watch for state updates + updates := make(chan *common.ActionIdentifier, 100) + errs := make(chan error, 1) + + go s.repo.ActionRepo().WatchStateUpdates(ctx, updates, errs) + + for { + select { + case <-ctx.Done(): + logger.Infof(ctx, "StateService.Watch stream closed by client") + return nil + + case err := <-errs: + logger.Errorf(ctx, "Error watching state updates: %v", err) + return connect.NewError(connect.CodeInternal, err) + + case actionID := <-updates: + // Filter for actions that are children of the parent + if !s.isChildOf(actionID, parentActionID) { + continue + } + + // Get the full action details + action, err := s.repo.ActionRepo().GetAction(ctx, actionID) + if err != nil { + logger.Warnf(ctx, "Failed to get action details: %v", err) + continue + } + + // Send action update + actionUpdate := s.actionToUpdate(action) + resp := &workflow.WatchResponse{ + Message: &workflow.WatchResponse_ActionUpdate{ + ActionUpdate: actionUpdate, + }, + } + + if err := stream.Send(resp); err != nil { + return err + } + + logger.Debugf(ctx, "Sent action update for: %s", actionID.Name) + } + } +} + +// Helper functions + +// getChildActions retrieves all child actions for a parent action +func (s *StateService) getChildActions(ctx context.Context, parentActionID *common.ActionIdentifier) ([]*models.Action, error) { + // For simplicity, we'll list all actions in the run and filter by parent + // In a production system, you'd add a more efficient query + runID := parentActionID.Run + allActions, _, err := s.repo.ActionRepo().ListActions(ctx, runID, 1000, "") + if err != nil { + return nil, err + } + + var childActions []*models.Action + for _, action := range allActions { + // Include the parent action itself and all its children + if action.Name == parentActionID.Name || + (action.ParentActionName != nil && *action.ParentActionName == parentActionID.Name) { + childActions = append(childActions, action) + } + } + + return childActions, nil +} + +// isChildOf checks if an action is a child of a parent action +func (s *StateService) isChildOf(actionID *common.ActionIdentifier, parentActionID *common.ActionIdentifier) bool { + // Same run + if actionID.Run.Org != parentActionID.Run.Org || + actionID.Run.Project != parentActionID.Run.Project || + actionID.Run.Domain != parentActionID.Run.Domain || + actionID.Run.Name != parentActionID.Run.Name { + return false + } + + // For now, we'll include all actions in the run + // In production, you'd check the parent relationship + return true +} + +// actionToUpdate converts a repository Action to an ActionUpdate message +func (s *StateService) actionToUpdate(action *models.Action) *workflow.ActionUpdate { + update := &workflow.ActionUpdate{ + ActionId: &common.ActionIdentifier{ + Run: &common.RunIdentifier{ + Org: action.Org, + Project: action.Project, + Domain: action.Domain, + Name: action.GetRunName(), + }, + Name: action.Name, + }, + Phase: s.stringToPhase(action.Phase), + } + + // TODO: Extract output URI and error info from ActionDetails JSON + // This would require unmarshaling action.ActionDetails and extracting the fields + + return update +} + +// stringToPhase converts a string phase to a Phase enum +func (s *StateService) stringToPhase(phase string) common.ActionPhase { + switch phase { + case "PHASE_QUEUED": + return common.ActionPhase_ACTION_PHASE_QUEUED + case "PHASE_INITIALIZING": + return common.ActionPhase_ACTION_PHASE_INITIALIZING + case "PHASE_RUNNING": + return common.ActionPhase_ACTION_PHASE_RUNNING + case "PHASE_SUCCEEDED": + return common.ActionPhase_ACTION_PHASE_SUCCEEDED + case "PHASE_FAILED": + return common.ActionPhase_ACTION_PHASE_FAILED + case "PHASE_ABORTED": + return common.ActionPhase_ACTION_PHASE_ABORTED + default: + return common.ActionPhase_ACTION_PHASE_UNSPECIFIED + } +} diff --git a/runs/service/task_service.go b/runs/service/task_service.go new file mode 100644 index 0000000000..912a73b434 --- /dev/null +++ b/runs/service/task_service.go @@ -0,0 +1,193 @@ +package service + +import ( + "context" + "fmt" + + "connectrpc.com/connect" + + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + flyteTask "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task/taskconnect" + "github.com/flyteorg/flyte/v2/runs/repository/impl" + "github.com/flyteorg/flyte/v2/runs/repository/interfaces" + "github.com/flyteorg/flyte/v2/runs/repository/models" + "github.com/flyteorg/flyte/v2/runs/repository/transformers" +) + +type taskService struct { + taskconnect.UnimplementedTaskServiceHandler + db interfaces.Repository +} + +func NewTaskService(repo interfaces.Repository) taskconnect.TaskServiceHandler { + return &taskService{ + db: repo, + } +} + +func (s *taskService) DeployTask(ctx context.Context, c *connect.Request[task.DeployTaskRequest]) (*connect.Response[task.DeployTaskResponse], error) { + request := c.Msg + + // Validate request using proto validation + if err := request.Validate(); err != nil { + logger.Errorf(ctx, "Invalid DeployTask request: %v", err) + return nil, connect.NewError(connect.CodeInvalidArgument, err) + } + + taskSpec := request.GetSpec() + + // TODO(nary): Add semantic validation to validate that default input types match the task interface + + // Truncate fields that exceed maximum length + if env := taskSpec.GetEnvironment(); env != nil { + env.Description = truncateShortDescription(env.GetDescription()) + } + + if doc := taskSpec.GetDocumentation(); doc != nil { + doc.ShortDescription = truncateShortDescription(doc.GetShortDescription()) + doc.LongDescription = truncateLongDescription(doc.GetLongDescription()) + } + + taskId := request.GetTaskId() + taskModel, err := transformers.NewTaskModel(ctx, taskId, taskSpec) + if err != nil { + return nil, connect.NewError(connect.CodeInternal, err) + } + + // TODO(nary): Add triggers when the trigger service is ready + if len(request.GetTriggers()) > 0 { + logger.Infof(ctx, "Triggers currently not supported") + } + + taskModel.TotalTriggers = uint32(len(request.GetTriggers())) + + err = s.db.TaskRepo().CreateTask(ctx, taskModel) + if err != nil { + return nil, connect.NewError(connect.CodeInternal, err) + } + + return connect.NewResponse(&task.DeployTaskResponse{}), nil +} + +func (s *taskService) GetTaskDetails(ctx context.Context, c *connect.Request[task.GetTaskDetailsRequest]) (*connect.Response[task.GetTaskDetailsResponse], error) { + request := c.Msg + model, err := s.db.TaskRepo().GetTask(ctx, transformers.ToTaskKey(request.GetTaskId())) + if err != nil { + return nil, connect.NewError(connect.CodeNotFound, err) + } + + // TODO(nary): Add identity enrichment after adding auth + tasks, err := transformers.TaskModelsToTaskDetailsWithoutIdentity(ctx, []*models.Task{model}) + if err != nil { + return nil, connect.NewError(connect.CodeInternal, err) + } + + return connect.NewResponse(&flyteTask.GetTaskDetailsResponse{ + Details: tasks[0], + }), nil +} + +// ListTasks lists tasks based on the provided request. This implicitly returns a list that is sorted by project, domain, name in descending order. +// Thus there is no need to add a sort by name clause to this request. +func (s *taskService) ListTasks(ctx context.Context, c *connect.Request[task.ListTasksRequest]) (*connect.Response[task.ListTasksResponse], error) { + request := c.Msg + + // TODO(nary): Add auth and get organization from identity context + // org := authz.IdentityContextFromContext(ctx).Organization() + // For now, we'll skip org-level filtering + + // Convert request to ListResourceInput + listInput, err := impl.NewListResourceInputFromProto(request.GetRequest(), models.TaskColumns) + if err != nil { + return nil, connect.NewError(connect.CodeInvalidArgument, err) + } + + // Apply scope filters based on request + switch scope := request.GetScopeBy().(type) { + case *task.ListTasksRequest_Org: + // Filter by organization + orgFilter := impl.NewOrgFilter(scope.Org) + listInput.ScopeByFilter = orgFilter + case *task.ListTasksRequest_ProjectId: + // Filter by project (org + project + domain) + projectFilter := impl.NewProjectIdFilter(scope.ProjectId) + listInput.ScopeByFilter = projectFilter + } + + // Handle known filters + if request.GetKnownFilters() != nil { + for _, knownFilter := range request.GetKnownFilters() { + switch filterType := knownFilter.GetFilterBy().(type) { + case *task.ListTasksRequest_KnownFilter_DeployedBy: + deployedByFilter := impl.NewDeployedByFilter(filterType.DeployedBy) + if listInput.Filter == nil { + listInput.Filter = deployedByFilter + } else { + listInput.Filter = listInput.Filter.And(deployedByFilter) + } + } + } + } + + taskResWithCounts, err := s.db.TaskRepo().ListTasks(ctx, listInput) + if err != nil { + return nil, connect.NewError(connect.CodeInternal, err) + } + + // TODO(nary): Extract task names and get latest runs after adding ActionRepo.GetLatestRunByTasks + // For now, return tasks without latest run information + var latestRuns map[models.TaskName]*models.Action + + // TODO(nary): Add identity enrichment after adding auth + tasks, taskMetadata, err := transformers.TaskListResultToTasksAndMetadata( + ctx, taskResWithCounts, latestRuns, nil, false, false) + if err != nil { + return nil, connect.NewError(connect.CodeInternal, err) + } + + var token string + if len(tasks) > 0 && len(tasks) == int(listInput.Limit) { + token = fmt.Sprintf("%d", listInput.Offset+listInput.Limit) + } + + return connect.NewResponse(&task.ListTasksResponse{ + Tasks: tasks, + Token: token, + Metadata: taskMetadata, + }), nil +} + +// ListVersions lists versions based on the provided request. This implicitly returns a list that is sorted by deployedAt in descending order. +func (s *taskService) ListVersions(ctx context.Context, c *connect.Request[task.ListVersionsRequest]) (*connect.Response[task.ListVersionsResponse], error) { + request := c.Msg + + // Convert request to ListResourceInput + listInput, err := impl.NewListResourceInputFromProto(request.GetRequest(), models.TaskVersionColumns) + if err != nil { + return nil, connect.NewError(connect.CodeInvalidArgument, err) + } + + // Add task name filter + taskNameFilter := impl.NewTaskNameFilter(request.GetTaskName()) + listInput = listInput.WithFilter(taskNameFilter) + + versionModels, err := s.db.TaskRepo().ListVersions(ctx, listInput) + if err != nil { + return nil, connect.NewError(connect.CodeInternal, err) + } + + versions := transformers.VersionModelsToVersionResponses(versionModels) + + // Generate pagination token + var token string + if len(versions) > 0 && len(versions) == int(listInput.Limit) { + token = fmt.Sprintf("%d", listInput.Offset+listInput.Limit) + } + + return connect.NewResponse(&task.ListVersionsResponse{ + Versions: versions, + Token: token, + }), nil +} diff --git a/runs/service/task_service_test.go b/runs/service/task_service_test.go new file mode 100644 index 0000000000..16bc6c2f58 --- /dev/null +++ b/runs/service/task_service_test.go @@ -0,0 +1,183 @@ +package service + +import ( + "context" + "testing" + "time" + + "connectrpc.com/connect" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/require" + "google.golang.org/protobuf/proto" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + mocks "github.com/flyteorg/flyte/v2/runs/repository/mocks" + "github.com/flyteorg/flyte/v2/runs/repository/models" +) + +func TestDeployTask(t *testing.T) { + ctx := context.Background() + mockRepo := mocks.NewRepository(t) + mockTaskRepo := mocks.NewTaskRepo(t) + + mockRepo.EXPECT().TaskRepo().Return(mockTaskRepo) + mockTaskRepo.EXPECT().CreateTask(ctx, mock.AnythingOfType("*models.Task")).Return(nil) + + service := NewTaskService(mockRepo) + + req := &task.DeployTaskRequest{ + TaskId: &task.TaskIdentifier{ + Org: "test-org", + Project: "test-project", + Domain: "test-domain", + Name: "test-task", + Version: "v1", + }, + Spec: &task.TaskSpec{ + Environment: &task.Environment{ + Name: "prod", + }, + }, + } + + resp, err := service.DeployTask(ctx, connect.NewRequest(req)) + require.NoError(t, err) + assert.NotNil(t, resp) +} + +func TestGetTaskDetails(t *testing.T) { + ctx := context.Background() + mockRepo := mocks.NewRepository(t) + mockTaskRepo := mocks.NewTaskRepo(t) + + spec := &task.TaskSpec{ + Environment: &task.Environment{Name: "prod"}, + } + specBytes, _ := proto.Marshal(spec) + + taskModel := &models.Task{ + TaskKey: models.TaskKey{ + Org: "test-org", + Project: "test-project", + Domain: "test-domain", + Name: "test-task", + Version: "v1", + }, + Environment: "prod", + FunctionName: "test_func", + TaskSpec: specBytes, + CreatedAt: time.Now(), + } + + mockRepo.EXPECT().TaskRepo().Return(mockTaskRepo) + mockTaskRepo.EXPECT().GetTask(ctx, mock.AnythingOfType("models.TaskKey")).Return(taskModel, nil) + + service := NewTaskService(mockRepo) + + req := &task.GetTaskDetailsRequest{ + TaskId: &task.TaskIdentifier{ + Org: "test-org", + Project: "test-project", + Domain: "test-domain", + Name: "test-task", + Version: "v1", + }, + } + + resp, err := service.GetTaskDetails(ctx, connect.NewRequest(req)) + require.NoError(t, err) + assert.NotNil(t, resp) + assert.NotNil(t, resp.Msg.Details) + assert.Equal(t, "test-org", resp.Msg.Details.TaskId.Org) +} + +func TestListTasks(t *testing.T) { + ctx := context.Background() + mockRepo := mocks.NewRepository(t) + mockTaskRepo := mocks.NewTaskRepo(t) + + taskModels := []*models.Task{ + { + TaskKey: models.TaskKey{ + Org: "test-org", + Project: "test-project", + Domain: "test-domain", + Name: "task1", + Version: "v1", + }, + FunctionName: "func1", + CreatedAt: time.Now(), + }, + } + + result := &models.TaskListResult{ + Tasks: taskModels, + Total: 1, + FilteredTotal: 1, + } + + mockRepo.EXPECT().TaskRepo().Return(mockTaskRepo) + mockTaskRepo.EXPECT().ListTasks(ctx, mock.AnythingOfType("interfaces.ListResourceInput")).Return(result, nil) + + service := NewTaskService(mockRepo) + + req := &task.ListTasksRequest{ + ScopeBy: &task.ListTasksRequest_Org{ + Org: "test-org", + }, + Request: &common.ListRequest{ + Limit: 10, + }, + } + + resp, err := service.ListTasks(ctx, connect.NewRequest(req)) + require.NoError(t, err) + assert.NotNil(t, resp) + assert.Len(t, resp.Msg.Tasks, 1) + assert.NotNil(t, resp.Msg.Metadata) + assert.Equal(t, uint32(1), resp.Msg.Metadata.Total) +} + +func TestListVersions(t *testing.T) { + ctx := context.Background() + mockRepo := mocks.NewRepository(t) + mockTaskRepo := mocks.NewTaskRepo(t) + + now := time.Now() + versions := []*models.TaskVersion{ + { + Version: "v1", + CreatedAt: now, + }, + { + Version: "v2", + CreatedAt: now.Add(time.Hour), + }, + } + + mockRepo.EXPECT().TaskRepo().Return(mockTaskRepo) + mockTaskRepo.EXPECT().ListVersions(ctx, mock.AnythingOfType("interfaces.ListResourceInput")).Return(versions, nil) + + service := NewTaskService(mockRepo) + + req := &task.ListVersionsRequest{ + TaskName: &task.TaskName{ + Org: "test-org", + Project: "test-project", + Domain: "test-domain", + Name: "test-task", + }, + Request: &common.ListRequest{ + Limit: 10, + }, + } + + resp, err := service.ListVersions(ctx, connect.NewRequest(req)) + require.NoError(t, err) + assert.NotNil(t, resp) + assert.Len(t, resp.Msg.Versions, 2) + assert.Equal(t, "v1", resp.Msg.Versions[0].Version) + assert.Equal(t, "v2", resp.Msg.Versions[1].Version) +} diff --git a/runs/service/utils.go b/runs/service/utils.go new file mode 100644 index 0000000000..b09beac1d2 --- /dev/null +++ b/runs/service/utils.go @@ -0,0 +1,17 @@ +package service + +// TruncateShortDescription truncates the short description to 255 characters if it exceeds the maximum length. +func truncateShortDescription(description string) string { + if len(description) > 255 { + return description[:255] + } + return description +} + +// truncateLongDescription truncates the long description to 2048 characters if it exceeds the maximum length. +func truncateLongDescription(description string) string { + if len(description) > 2048 { + return description[:2048] + } + return description +} diff --git a/runs/service/utils_test.go b/runs/service/utils_test.go new file mode 100644 index 0000000000..6d5ef490b1 --- /dev/null +++ b/runs/service/utils_test.go @@ -0,0 +1,48 @@ +package service + +import ( + "strings" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestTruncateShortDescription_UnderLimit(t *testing.T) { + desc := "Short description" + result := truncateShortDescription(desc) + assert.Equal(t, desc, result) +} + +func TestTruncateShortDescription_AtLimit(t *testing.T) { + desc := strings.Repeat("a", 255) + result := truncateShortDescription(desc) + assert.Equal(t, desc, result) + assert.Len(t, result, 255) +} + +func TestTruncateShortDescription_OverLimit(t *testing.T) { + desc := strings.Repeat("a", 300) + result := truncateShortDescription(desc) + assert.Len(t, result, 255) + assert.Equal(t, strings.Repeat("a", 255), result) +} + +func TestTruncateLongDescription_UnderLimit(t *testing.T) { + desc := "Long description" + result := truncateLongDescription(desc) + assert.Equal(t, desc, result) +} + +func TestTruncateLongDescription_AtLimit(t *testing.T) { + desc := strings.Repeat("b", 2048) + result := truncateLongDescription(desc) + assert.Equal(t, desc, result) + assert.Len(t, result, 2048) +} + +func TestTruncateLongDescription_OverLimit(t *testing.T) { + desc := strings.Repeat("b", 3000) + result := truncateLongDescription(desc) + assert.Len(t, result, 2048) + assert.Equal(t, strings.Repeat("b", 2048), result) +} diff --git a/runs/start-postgres.sh b/runs/start-postgres.sh new file mode 100755 index 0000000000..768a59ed97 --- /dev/null +++ b/runs/start-postgres.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +# Stop any existing container +docker stop flyte-runs-postgres 2>/dev/null || true +docker rm flyte-runs-postgres 2>/dev/null || true + +# Start PostgreSQL with the correct password +echo "Starting PostgreSQL with Docker..." +docker run --name flyte-runs-postgres \ + -e POSTGRES_PASSWORD=postgres \ + -e POSTGRES_DB=flyte_runs \ + -p 5433:5432 \ + -d postgres:15 + +echo "Waiting for PostgreSQL to be ready..." +sleep 3 + +# Check if it's ready +if docker exec flyte-runs-postgres pg_isready -U postgres; then + echo "โœ“ PostgreSQL is ready!" + echo " Host: localhost" + echo " Port: 5433" + echo " Database: flyte_runs" + echo " Username: postgres" + echo " Password: postgres" +else + echo "โŒ PostgreSQL failed to start" + exit 1 +fi diff --git a/runs/test.sh b/runs/test.sh new file mode 100755 index 0000000000..7e73dbdff5 --- /dev/null +++ b/runs/test.sh @@ -0,0 +1,129 @@ +#!/bin/bash +set -e + +echo "=== Runs Service Test Script ===" +echo + +# Determine which database to use +DB_TYPE=${1:-sqlite} + +if [ "$DB_TYPE" = "postgres" ]; then + CONFIG_FILE="config-postgres.yaml" + echo "๐Ÿ“Š Using PostgreSQL" + + # Check if PostgreSQL is running + if ! command -v psql &> /dev/null; then + echo "โš ๏ธ psql not found. Make sure PostgreSQL is installed." + echo " You can use Docker: docker run --name flyte-runs-postgres -e POSTGRES_PASSWORD=postgres -e POSTGRES_DB=flyte_runs -p 5433:5432 -d postgres:15" + exit 1 + fi + + # Check if PostgreSQL is accessible + if ! psql -h localhost -p 5433 -U postgres -d flyte_runs -c "SELECT 1" &> /dev/null; then + echo "โš ๏ธ Cannot connect to PostgreSQL at localhost:5433" + echo " Make sure PostgreSQL is running with database 'flyte_runs'" + echo " Quick start: ./start-postgres.sh" + exit 1 + fi + + echo "โœ“ PostgreSQL is running" +else + CONFIG_FILE="config.yaml" + echo "๐Ÿ“Š Using SQLite" + echo "โœ“ SQLite ready (no setup required)" +fi + +echo + +# Check if the service binary exists +if [ ! -f "bin/runs-service" ]; then + echo "๐Ÿ“ฆ Building runs service..." + go build -o bin/runs-service ./cmd/main.go + echo "โœ“ Build complete" + echo +fi + +# Check if the client binary exists +if [ ! -f "bin/runs-client" ]; then + echo "๐Ÿ“ฆ Building test client..." + go build -o bin/runs-testclient ./testclient/main.go + echo "โœ“ Build complete" + echo +fi + +# Start the service in the background +echo "๐Ÿš€ Starting Runs Service..." +./bin/runs-service --config $CONFIG_FILE & +SERVICE_PID=$! + +# Wait for service to start +sleep 3 + +# Check if service is running +if ! kill -0 $SERVICE_PID 2>/dev/null; then + echo "โŒ Failed to start service" + exit 1 +fi + +echo "โœ“ Service started (PID: $SERVICE_PID)" +echo + +# Test health endpoint +echo "๐Ÿ” Testing health endpoint..." +if curl -sf http://localhost:8090/healthz > /dev/null; then + echo "โœ“ Health check passed" +else + echo "โŒ Health check failed" + kill $SERVICE_PID + exit 1 +fi +echo + +# Test readiness endpoint +echo "๐Ÿ” Testing readiness endpoint..." +if curl -sf http://localhost:8090/readyz > /dev/null; then + echo "โœ“ Readiness check passed" +else + echo "โŒ Readiness check failed" + kill $SERVICE_PID + exit 1 +fi +echo + +# Run the test client +echo "๐Ÿงช Running test client..." +echo +./bin/runs-testclient +TEST_RESULT=$? + +echo +if [ $TEST_RESULT -eq 0 ]; then + echo "โœ… All tests passed!" +else + echo "โŒ Tests failed" +fi + +# Check database contents +echo +echo "๐Ÿ“Š Database contents:" +if [ "$DB_TYPE" = "postgres" ]; then + psql -h localhost -p 5433 -U postgres -d flyte_runs -c "SELECT id, org, project, domain, name, root_action_name, created_at FROM runs ORDER BY id LIMIT 10;" + echo + psql -h localhost -p 5433 -U postgres -d flyte_runs -c "SELECT id, org, project, domain, run_name, name, phase FROM actions ORDER BY id LIMIT 10;" +else + echo "Runs:" + sqlite3 runs.db "SELECT id, org, project, domain, name, root_action_name FROM runs ORDER BY id LIMIT 10;" + echo + echo "Actions:" + sqlite3 runs.db "SELECT id, org, project, domain, run_name, name, phase FROM actions ORDER BY id LIMIT 10;" || echo "No actions found" +fi + +# Cleanup +echo +echo "๐Ÿงน Stopping service..." +kill $SERVICE_PID +wait $SERVICE_PID 2>/dev/null || true + +echo "โœ“ Done" + +exit $TEST_RESULT diff --git a/runs/test/api/setup_test.go b/runs/test/api/setup_test.go new file mode 100644 index 0000000000..02dfa49254 --- /dev/null +++ b/runs/test/api/setup_test.go @@ -0,0 +1,180 @@ +package api + +import ( + "context" + "fmt" + "log" + "net/http" + "os" + "reflect" + "testing" + "time" + + "golang.org/x/net/http2" + "golang.org/x/net/http2/h2c" + "gorm.io/gorm" + + "github.com/flyteorg/flyte/v2/flytestdlib/database" + "github.com/flyteorg/flyte/v2/flytestdlib/logger" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task/taskconnect" + "github.com/flyteorg/flyte/v2/runs/migrations" + "github.com/flyteorg/flyte/v2/runs/repository" + "github.com/flyteorg/flyte/v2/runs/service" +) + +const ( + testPort = 8091 // Different port to avoid conflicts with main service + testDBFile = "/tmp/flyte-runs-test.db" // Temporary database file for tests +) + +var ( + endpoint string + testServer *http.Server + testDB *gorm.DB // Expose DB for cleanup +) + + +// TestMain sets up the test environment with SQLite database and runs service +func TestMain(m *testing.M) { + ctx := context.Background() + var exitCode int + + defer func() { + // Stop server if it was started + if testServer != nil { + shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + if err := testServer.Shutdown(shutdownCtx); err != nil { + log.Printf("Test server shutdown error: %v", err) + } + log.Println("Test server stopped") + } + + // Remove test database file + if err := os.Remove(testDBFile); err != nil && !os.IsNotExist(err) { + log.Printf("Warning: Failed to remove test database: %v", err) + } + + os.Exit(exitCode) + }() + + // Setup: Create SQLite database + // NOTE: Using a temp file instead of :memory: to avoid GORM AutoMigrate issues + // with index creation on fresh in-memory databases + dbConfig := &database.DbConfig{ + SQLite: database.SQLiteConfig{ + File: testDBFile, + }, + } + logCfg := logger.GetConfig() + var err error + testDB, err = database.GetDB(ctx, dbConfig, logCfg) + if err != nil { + log.Printf("Failed to initialize database: %v", err) + exitCode = 1 + return + } + log.Println("Database initialized") + + // Run migrations + if err := migrations.RunMigrations(testDB); err != nil { + log.Printf("Failed to run migrations: %v", err) + exitCode = 1 + return + } + log.Println("Database migrations completed") + + // Create repository and services + repo := repository.NewRepository(testDB) + taskSvc := service.NewTaskService(repo) + + // Setup HTTP server + mux := http.NewServeMux() + taskPath, taskHandler := taskconnect.NewTaskServiceHandler(taskSvc) + mux.Handle(taskPath, taskHandler) + + // Add health check + mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte("OK")) + }) + + endpoint = fmt.Sprintf("http://localhost:%d", testPort) + testServer = &http.Server{ + Addr: fmt.Sprintf(":%d", testPort), + Handler: h2c.NewHandler(mux, &http2.Server{}), + } + + // Start server in background + errChan := make(chan error, 1) + go func() { + log.Printf("Test server starting on %s", endpoint) + if err := testServer.ListenAndServe(); err != nil && err != http.ErrServerClosed { + errChan <- err + } + }() + + // Wait for either server readiness or startup error + readyChan := make(chan bool, 1) + go func() { + readyChan <- waitForServer(endpoint, 10*time.Second) + }() + + select { + case err := <-errChan: + log.Printf("Test server failed to start: %v", err) + exitCode = 1 + return + case ready := <-readyChan: + if !ready { + log.Printf("Test server failed to start (health check timeout)") + exitCode = 1 + return + } + } + log.Println("Test server is ready") + + // Run tests + exitCode = m.Run() +} + +// waitForServer waits for the server to be ready +func waitForServer(url string, timeout time.Duration) bool { + client := &http.Client{Timeout: 1 * time.Second} + deadline := time.Now().Add(timeout) + + for time.Now().Before(deadline) { + resp, err := client.Get(url + "/healthz") + if err == nil && resp.StatusCode == http.StatusOK { + resp.Body.Close() + return true + } + if resp != nil { + resp.Body.Close() + } + time.Sleep(100 * time.Millisecond) + } + return false +} + +// cleanupTestDB clears all tables in the test database +// This ensures each test starts with a clean state +func cleanupTestDB(t *testing.T) { + t.Helper() + + if testDB == nil { + t.Log("Warning: testDB is nil, skipping cleanup") + return + } + + // Loop through all models defined in migrations + for _, model := range migrations.AllModels { + tableName := testDB.NamingStrategy.TableName(reflect.TypeOf(model).Elem().Name()) + + if err := testDB.Exec(fmt.Sprintf("DELETE FROM %s", tableName)).Error; err != nil { + t.Logf("Warning: Failed to cleanup table %s: %v", tableName, err) + } + } + + t.Log("Test database cleaned up") +} diff --git a/runs/test/api/task_service_test.go b/runs/test/api/task_service_test.go new file mode 100644 index 0000000000..89889d899c --- /dev/null +++ b/runs/test/api/task_service_test.go @@ -0,0 +1,152 @@ +package api + +import ( + "context" + "fmt" + "testing" + + "connectrpc.com/connect" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/common" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task/taskconnect" +) + +const ( + testOrg = "test-org" + testProject = "test-project" + testDomain = "test-domain" +) + +func TestDeployTask(t *testing.T) { + // Cleanup after test + t.Cleanup(func() { + cleanupTestDB(t) + }) + + ctx := context.Background() + httpClient := newClient() + opts := []connect.ClientOption{} + + taskClient := taskconnect.NewTaskServiceClient(httpClient, endpoint, opts...) + + // Deploy a task + taskID := &task.TaskIdentifier{ + Org: testOrg, + Project: testProject, + Domain: testDomain, + Name: "test-task", + Version: uniqueString(), + } + + deployResp, err := taskClient.DeployTask(ctx, connect.NewRequest(&task.DeployTaskRequest{ + TaskId: taskID, + Spec: &task.TaskSpec{ + TaskTemplate: &core.TaskTemplate{ + Type: "container", + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Image: "alpine:latest", + Args: []string{"echo", "hello"}, + }, + }, + }, + }, + })) + + require.NoError(t, err) + require.NotNil(t, deployResp) + t.Logf("Task deployed successfully: %v", taskID) + + // Get task details + getTaskDetailsResp, err := taskClient.GetTaskDetails(ctx, connect.NewRequest(&task.GetTaskDetailsRequest{ + TaskId: taskID, + })) + + require.NoError(t, err) + require.NotNil(t, getTaskDetailsResp) + details := getTaskDetailsResp.Msg.GetDetails() + assert.Equal(t, taskID.GetOrg(), details.GetTaskId().GetOrg()) + assert.Equal(t, taskID.GetProject(), details.GetTaskId().GetProject()) + assert.Equal(t, taskID.GetDomain(), details.GetTaskId().GetDomain()) + assert.Equal(t, taskID.GetName(), details.GetTaskId().GetName()) + assert.Equal(t, taskID.GetVersion(), details.GetTaskId().GetVersion()) + t.Logf("Task details retrieved successfully: %v", details) + + // Get versions of the task + getVersionsResp, err := taskClient.ListVersions(ctx, connect.NewRequest(&task.ListVersionsRequest{ + TaskName: &task.TaskName{ + Org: testOrg, + Project: testProject, + Domain: testDomain, + Name: "test-task", + }, + })) + + require.NoError(t, err) + require.NotNil(t, getVersionsResp) + versions := getVersionsResp.Msg.GetVersions() + assert.Equal(t, 1, len(versions)) + assert.Equal(t, taskID.GetVersion(), versions[0].Version) + t.Logf("Task versions retrieved successfully: %v", versions) +} + +func TestListTasks(t *testing.T) { + t.Cleanup(func() { + cleanupTestDB(t) + }) + + ctx := context.Background() + httpClient := newClient() + opts := []connect.ClientOption{} + + taskClient := taskconnect.NewTaskServiceClient(httpClient, endpoint, opts...) + + // Deploy multiple tasks + count := 3 + for i := range count { + taskID := &task.TaskIdentifier{ + Org: testOrg, + Project: testProject, + Domain: testDomain, + Name: fmt.Sprintf("test-task-%d", i+1), + Version: uniqueString(), + } + + deployResp, err := taskClient.DeployTask(ctx, connect.NewRequest(&task.DeployTaskRequest{ + TaskId: taskID, + Spec: &task.TaskSpec{ + TaskTemplate: &core.TaskTemplate{ + Type: "container", + Target: &core.TaskTemplate_Container{ + Container: &core.Container{ + Image: "alpine:latest", + Args: []string{"echo", "hello"}, + }, + }, + }, + }, + })) + require.NotNil(t, deployResp) + require.NoError(t, err) + } + + // List tasks + listResp, err := taskClient.ListTasks(ctx, connect.NewRequest(&task.ListTasksRequest{ + ScopeBy: &task.ListTasksRequest_Org{ + Org: "test-org", + }, + Request: &common.ListRequest{ + Limit: 10, + }, + })) + require.NoError(t, err) + require.NotNil(t, listResp) + + tasks := listResp.Msg.GetTasks() + assert.Equal(t, count, len(tasks)) + t.Logf("Listed %d tasks", len(tasks)) +} diff --git a/runs/test/api/utils.go b/runs/test/api/utils.go new file mode 100644 index 0000000000..3ab31b3861 --- /dev/null +++ b/runs/test/api/utils.go @@ -0,0 +1,17 @@ +package api + +import ( + "fmt" + "net/http" + "time" +) + +func uniqueString() string { + return fmt.Sprintf("%d", time.Now().UnixNano()) +} + +func newClient() *http.Client { + return &http.Client{ + Timeout: 30 * time.Second, + } +} diff --git a/runs/test/scripts/create_task.sh b/runs/test/scripts/create_task.sh new file mode 100755 index 0000000000..3b9b2ea4f5 --- /dev/null +++ b/runs/test/scripts/create_task.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +ENDPOINT="${ENDPOINT:-http://localhost:8090}" +ORG="${ORG:-testorg}" +PROJECT="${PROJECT:-testproject}" +DOMAIN="${DOMAIN:-development}" +TASK_NAME="${TASK_NAME:-my_task}" +VERSION="${VERSION:-1}" + +buf curl --schema . $ENDPOINT/flyteidl2.task.TaskService/DeployTask --data @- < 0 { + fmt.Println("Test 6: Aborting an action...") + actionToAbort := listActionsResp.Msg.Actions[0] + abortActionReq := &workflow.AbortActionRequest{ + ActionId: actionToAbort.Id, + Reason: "Testing abort functionality", + } + + _, err = client.AbortAction(ctx, connect.NewRequest(abortActionReq)) + if err != nil { + log.Fatalf("Failed to abort action: %v", err) + } + fmt.Println("โœ“ Action aborted successfully") + } + + // Test 7: Abort a run + fmt.Println("Test 7: Aborting a run...") + abortRunReq := &workflow.AbortRunRequest{ + RunId: &common.RunIdentifier{ + Org: "my-org", + Project: "my-project", + Domain: "development", + Name: runName, // Use the auto-generated run name + }, + Reason: strPtr("Testing run abort functionality"), + } + + _, err = client.AbortRun(ctx, connect.NewRequest(abortRunReq)) + if err != nil { + log.Fatalf("Failed to abort run: %v", err) + } + fmt.Println("โœ“ Run aborted successfully") + + fmt.Println("All tests completed successfully! ๐ŸŽ‰") +} + +func strPtr(s string) *string { + return &s +} diff --git a/scripts/docker-dev.sh b/scripts/docker-dev.sh new file mode 100755 index 0000000000..db8098c2bb --- /dev/null +++ b/scripts/docker-dev.sh @@ -0,0 +1,77 @@ +#!/bin/bash +# Helper script to run commands in the CI Docker container +# Usage: +# ./scripts/docker-dev.sh # Start interactive shell +# ./scripts/docker-dev.sh pull # Pull latest image +# ./scripts/docker-dev.sh make gen # Run make gen + +set -e + +IMAGE="ghcr.io/flyteorg/flyte/ci:v2" +WORKSPACE="/workspace" + +# Color codes for output +GREEN='\033[0;32m' +BLUE='\033[0;34m' +NC='\033[0m' # No Color + +# Get the repository root (parent of scripts directory) +REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)" + +# Function to print colored messages +info() { + echo -e "${BLUE}๐Ÿณ $1${NC}" +} + +success() { + echo -e "${GREEN}โœ“ $1${NC}" +} + +# Handle special commands +case "$1" in + pull) + info "Pulling latest CI image..." + docker pull "$IMAGE" + success "Image pulled successfully" + exit 0 + ;; + help|--help|-h) + echo "Docker Development Helper" + echo "" + echo "Usage:" + echo " $0 Start interactive shell in CI container" + echo " $0 pull Pull the latest CI image" + echo " $0 Run a command in the CI container" + echo "" + echo "Examples:" + echo " $0 # Interactive shell" + echo " $0 make gen # Generate protocol buffers" + echo " $0 buf lint # Lint protocol buffers" + echo " $0 cargo build # Build Rust crate" + exit 0 + ;; +esac + +# Check if Docker is running +if ! docker info > /dev/null 2>&1; then + echo "Error: Docker is not running. Please start Docker and try again." + exit 1 +fi + +# Run interactively if no command provided +if [ $# -eq 0 ]; then + info "Starting interactive shell..." + docker run --rm -it \ + -v "$REPO_ROOT:$WORKSPACE" \ + -w "$WORKSPACE" \ + "$IMAGE" \ + bash +else + # Run the provided command + info "Running: $*" + docker run --rm \ + -v "$REPO_ROOT:$WORKSPACE" \ + -w "$WORKSPACE" \ + "$IMAGE" \ + "$@" +fi